0hmX/am62l-lpddr4-clean

This code defines the hardware connections and routing logic for a DDR memory interface, specifying physical signal mappings between the system-on-chip (SoC) and DDR memory components, including connections for data, address, clock, reset, and power/ground balls.

Version: 1.0.0
License: unset
Stars: 0

direct-global-autorouter.ts

import type {
  AutorouterCompleteEvent,
  AutorouterErrorEvent,
  AutorouterProgressEvent,
  GenericLocalAutorouter,
  SimpleRouteJson,
  SimplifiedPcbTrace,
} from "@tscircuit/core"

const routeDirectly = (input: SimpleRouteJson): SimplifiedPcbTrace[] =>
  input.connections.map((connection, index) => ({
    type: "pcb_trace",
    pcb_trace_id: `direct_global_trace_${index}`,
    connection_name: connection.source_trace_id ?? connection.name,
    route: connection.pointsToConnect.map((point) => ({
      route_type: "wire",
      x: point.x,
      y: point.y,
      width: connection.nominalTraceWidth ?? input.minTraceWidth,
      layer: point.layer,
    })),
  }))

export const directGlobalAutorouter = {
  algorithmFn: async (
    input: SimpleRouteJson,
  ): Promise<GenericLocalAutorouter> => {
    const completeHandlers: Array<(event: AutorouterCompleteEvent) => void> = []
    const errorHandlers: Array<(event: AutorouterErrorEvent) => void> = []
    const progressHandlers: Array<(event: AutorouterProgressEvent) => void> = []

    const autorouter: GenericLocalAutorouter = {
      input,
      isRouting: false,
      async start() {
        if (this.isRouting) return
        this.isRouting = true

        try {
          const traces = routeDirectly(this.input)
          progressHandlers.forEach((handler) =>
            handler({
              type: "progress",
              steps: 1,
              progress: 1,
              phase: "complete",
            }),
          )
          this.isRouting = false
          completeHandlers.forEach((handler) =>
            handler({ type: "complete", traces }),
          )
        } catch (error) {
          this.isRouting = false
          errorHandlers.forEach((handler) =>
            handler({
              type: "error",
              error: error instanceof Error ? error : new Error(String(error)),
            }),
          )
        }
      },
      stop() {
        this.isRouting = false
      },
      on(event, callback) {
        if (event === "complete") {
          completeHandlers.push(callback as (event: AutorouterCompleteEvent) => void)
        } else if (event === "error") {
          errorHandlers.push(callback as (event: AutorouterErrorEvent) => void)
        } else {
          progressHandlers.push(callback as (event: AutorouterProgressEvent) => void)
        }
      },
      solveSync() {
        return routeDirectly(this.input)
      },
    }

    return autorouter
  },
}