@tscircuit/checks

Validity check functions. These functions generally take a tscircuit json array and output an array of arrays for any issues found.

Getting Started Contributor Video

Function Overview

Function	Description
checkConnectorAccessibleOrientation	Returns pcb_accessibility_error for connectors whose orientation makes them inaccessible.
checkAllPinsInComponentAreUnderspecified	Returns source_component_pins_underspecified_warning when every pin on a chip lacks pin attributes.
checkDifferentNetViaSpacing	Returns pcb_via_clearance_error if vias on different nets are too close together.
checkEachPcbPortConnectedToPcbTraces	Returns pcb_trace_error if any source_port is not connected to its corresponding PCB traces.
checkEachPcbTraceNonOverlapping	Returns pcb_trace_error when pcb_trace segments overlap incompatible geometry on the same layer.
checkPcbComponentOverlap	Returns pcb_footprint_overlap_error when footprint elements from different components overlap in disallowed ways.
checkPcbComponentsOutOfBoard	Returns pcb_placement_error when PCB components do not fit inside the board area.
checkPcbTracesOutOfBoard	Returns pcb_trace_error when any trace segment or via extends beyond the board boundary.
checkPinMustBeConnected	Returns pcb_trace_error when required source pins are not connected.
checkSameNetViaSpacing	Returns pcb_via_clearance_error if vias on the same net are closer than the allowed margin.
checkSourceTracesHavePcbTraces	Returns pcb_trace_error when source traces are missing corresponding pcb_trace routes.
checkTracesAreContiguous	Returns pcb_trace_error when trace endpoints are floating or do not connect as expected.
checkViasOffBoard	Returns pcb_placement_error if any PCB via lies outside or crosses the board boundary.

Aggregate check runner functions

Function	Description
runAllPlacementChecks	Runs all placement checks (checkViasOffBoard, checkPcbComponentsOutOfBoard, checkPcbComponentOverlap, and checkConnectorAccessibleOrientation).
runAllNetlistChecks	Runs all netlist checks (e.g. checkPinMustBeConnected, checkAllPinsInComponentAreUnderspecified).
runAllRoutingChecks	Runs all routing checks currently enabled (checkEachPcbPortConnectedToPcbTraces, checkSourceTracesHavePcbTraces, checkEachPcbTraceNonOverlapping, same/different net via spacing, and checkPcbTracesOutOfBoard).
runAllChecks	Runs all placement, netlist, and routing checks and returns a combined list of errors.

Implementation Details

Note

It can be helpful to look at an example soup file

tscircuit soup JSON array containing elements. For checks involving source ports, and pcb traces here are the relevant elements (the types are produced below)

Note

For the most up-to-date types, check out @tscircuit/soup

// You can import these types from the @tscircuit/soup package e.g.
// import type { PCBPort, PCBTrace, AnySoupElement } from "circuit-json"

import { z } from "zod"
import { distance } from "../units"

export const pcb_trace = z.object({
  type: z.literal("pcb_trace"),
  source_trace_id: z.string().optional(),
  pcb_component_id: z.string().optional(),
  pcb_trace_id: z.string(),
  route: z.array(
    z.union([
      z.object({
        route_type: z.literal("wire"),
        x: distance,
        y: distance,
        width: distance,
        start_pcb_port_id: z.string().optional(),
        end_pcb_port_id: z.string().optional(),
        layer: z.string(),
      }),
      z.object({
        route_type: z.literal("via"),
        x: distance,
        y: distance,
        from_layer: z.string(),
        to_layer: z.string(),
      }),
    ])
  ),
})

export type PCBTraceInput = z.input<typeof pcb_trace>
export type PCBTrace = z.output<typeof pcb_trace>

import { distance } from "../units"
import { layer_ref } from "./properties/layer_ref"

export const pcb_port = z
  .object({
    type: z.literal("pcb_port"),
    pcb_port_id: z.string(),
    source_port_id: z.string(),
    pcb_component_id: z.string(),
    x: distance,
    y: distance,
    layers: z.array(layer_ref),
  })
  .describe("Defines a port on the PCB")

export type PCBPort = z.infer<typeof pcb_port>
export type PCBPortInput = z.input<typeof pcb_port>

export const source_port = z.object({
  type: z.literal("source_port"),
  pin_number: z.number().optional(),
  port_hints: z.array(z.string()).optional(),
  name: z.string(),
  source_port_id: z.string(),
  source_component_id: z.string(),
})

export type SourcePort = z.infer<typeof source_port>

export const source_net = z.object({
  type: z.literal("source_net"),
  source_net_id: z.string(),
  name: z.string(),
  member_source_group_ids: z.array(z.string()),
  is_power: z.boolean().optional(),
  is_ground: z.boolean().optional(),
  is_digital_signal: z.boolean().optional(),
  is_analog_signal: z.boolean().optional(),
})

export type SourceNet = z.infer<typeof source_net>
export type SourceNetInput = z.input<typeof source_net>

import { z } from "zod"

export const pcb_trace_error = z
  .object({
    pcb_error_id: z.string(),
    type: z.literal("pcb_error"),
    error_type: z.literal("pcb_trace_error"),
    message: z.string(),
    pcb_trace_id: z.string(),
    source_trace_id: z.string(),
    pcb_component_ids: z.array(z.string()),
    pcb_port_ids: z.array(z.string()),
  })
  .describe("Defines a trace error on the PCB")

export type PCBTraceErrorInput = z.input<typeof pcb_trace_error>
export type PCBTraceError = z.infer<typeof pcb_trace_error>