jitx/commands

Package name: jitx/commands

Summary

Data Types

AssignSymbolError

Constructors

Function	Description
AssignSymbolError	Constructor for defstruct AssignSymbolError

AssignLandPatternError

Constructors

Function	Description
AssignLandPatternError	Constructor for defstruct AssignLandPatternError

AuthorizedVendor

Define the approved vendors used by the design.

Functions

Function	Description
set-bom-vendors

General Definitions

Function	Description
clear-definitions
make-port (+ 1)
via-filled	Get the filled attribute o a pcb-via definition.
design-explorer-to-string
enable-import-dump-ir	Dump the generated internal representation during import
port-type	Get the type of a port from a component or module definition/instance
modify-components	Transforms module by modifying every component definition by calling the
simplify
dbquery
ref?
apply-variants	Apply Variants to a design to obtain a new design
set-config-sets
ports (+ 1)	Get the ports of a component, bundle, or module
get-min-space	Get the minimum space rule for a given LayerSpecifier.
set-main-module	Define the "main" module of the current design.
public-instances (+ 1)	Get the public instances of a module.
start-timer
clearance (+ 1)	Get a specific clearance rule.
public-single-instances (+ 1)	Get the public single (non array) instances of a module.
bom-vendors
no-connect?	Check if a pin is no-connect.
assign-pins?
instantiable-type	Return the type of instantiable an object is.
view-schematic (+ 1)	Visualize the generated schematic.
print-rules-functions
export-bom	Export the bill of materials (BOM) to the design directory.
set-export-board?	Set whether export-cad should generate board files.
enable-debug-plugin-serializer	Enable debugging printout from the plugin object serializer.
set-design-directory
start-new-timer
dbquery-first
export-cad (+ 1)	Export the JITX design to CAD.
set-value-format-options	Set the formats of the value strings during export operation.
public-single-pin-nets (+ 1)	Get the nets of a module.
pad-type	Get the type of a pcb-pad definition.
make-pin
assign-symbol	Assign a symbol to a pcb-component
get-signal-boundary	Retrieve the signal-boundary of a Board.
model3ds	Get the model3ds of a pcb-landpattern.
single-instances (+ 1)	Get the single (non array) instances of a module.
get-shape-from-contour	Get a shape from a tuple of lines/polylines.
set-use-layout-sketch	Configure the placer to run in sketch mode.
make-net (+ 3)
set-default-rules	Sets the default rules for all designs in the current program.
pads	Get the pads of a pcb-landpattern.
refs	Return all the refs inside of an object
layers	Get the layer statements of a pcb-landpattern or pcb-pad.
landpattern	Get the landpattern associated with a pcb-component definition.
view-design-explorer (+ 1)	Visualize the design as a hierarchical tree.
set-export-backend	Set the CAD exporter backend to use.
dot (+ 2)
log-event-time
run-evals?
save-generated-file
clear-timers
layer	Get all the shapes on a specific layer of a landpattern
get-property?
view-board-to-string
instance-status?	Retrieve the component in-BOM and on-board status of a component instance (deprecated)
connected? (+ 1)	Check if a pin or a net is connected
get
side	Get the side of a pad in a landpattern
dbquery-skip-cache
disable-spy	Disable dumping the generated internal representation during compilation
do-not-populate?	Check if a component instance is marked do-not-populate
public-nets (+ 1)	Get the nets of a module.
set-current-design	Set the directory "./designs/" that JITX will use to store design data.
dbquery-all
set-cad-info
all-items-with-properties
set-paper	Set the paper size used in schematic export
via-stop	Get the stop layer of a pcb-via definition.
save-to-svg
set-use-layout-groups	Configure the placer to run in groups mode.
assign-landpattern	Map a landpattern to a component using pin properties.
reference-prefix? (+ 1)	Get the reference prefix of a component, if it exists.
via-diameter	Get the diameter of a pcb-via definition.
get-property
im-feeling-lucky
get-merged-physical-design-module	Obtain the physical-design-transformed "main" module of the current design.
instance-type	Determine if an instance is a component, module, or array.
enable-spy	Dump the generated internal representation during compilation
mpn? (+ 1)	Get the MPN of a component, if it exists.
via-tented	Get the tented sides of a pcb-via definition.
nets (+ 1)	Get the nets of a module.
notify-vscode-of-loaded-jitx-shell
via-hole-diameter	Get the hole diameter of a pcb-via definition.
pins (+ 1)	Get the pins associated with an object.
instances (+ 1)	Get the instances of a module.
clear-dbquery-cache	Clear the cache on disk used for part queries with dbquery so that the parts gets refreshed next time the queries are run.
make-node (+ 1)
print-current-rules
via-in-pad	Get the via-in-pad attribute of a pcb-via definition.
instance-definition	Get the pcb-* definition of an instance.
min-width	Compute the minimum width in a sequence of shapes.
name	Get the name of an object
manufacturer? (+ 1)	Get the manufacturer name of a component, if it exists.
pose	Get the pose of a pad inside a pcb-landpattern.
single-pin-nets (+ 1)	Get the nets of a module.
offset	Compute a shape that is "offset" from another by a fixed distance.
pad	Get the pcb-pad definition of a pad in a landpattern.
ref	Get the associated Ref of an object instance.
run-evals	Runs all eval-when blocks nested within module to return a newly evaluated Instantiable.
topology-ends	Get the ends of a named topology.
view-bom	View the bill of materials (BOM).
evaluate	Evaluates a definition, expanding its statements.
via-type	Get the drill type of a pcb-via definition.
expand	Expand a shape by a fixed distance.
assign-pins	Explicitly run pin assignment before automatic placement, visualization, or export.
import-cad (+ 1)	Import CAD projects from KiCAD or Altium.
set-export-schematic?	Set whether export-cad should generate schematic files.
current-rules	Get the current design rules of the project
view (+ 5)	View a landpattern, schematic symbol, or pcb-component.
get-net	Find a net with a given name in a module.
freeze-reference-designators	Freeze all the reference designators, so they will not be recomputed.
indices	Get the indices of an array of JITX objects.
get? (+ 2)
has-board?	Check if the board has been set.
get-stackup	Retrieve the stackup of a Board.
component-instances (+ 1)	Get the instances of a module that are components (not modules).
get-board	Get the current pcb-board, if it exists
get-def-string	Get the string representation of the ESIR definition as ASCII.
explorer-json
stop-timer
set-board	Sets the pcb-board object used by the current design.
package-poses	Get the package poses associated with a pcb-component definition.
component-status?	Retrieve the component in-BOM and on-board status of a component instance (deprecated)
view-board (+ 1)	Visualize the generated board.
get-boundary	Retrieve the boundary of a Board.
set-bom-design-quantity	Set the quantity of boards to manufacturer when generating a BOM.
connected-pins	Return the pins connected to an existing pin.
make-inst
save-timing-report
set-ipc-info
min-space	Compute the minimum space in a sequence of shapes.
pad-def	Get the pcb-pad definition of a pad in a landpattern.
set-bom-metrics	set-bom-metrics(metrics: Tuple)
set-rules	Set the design rules for the current design.
all-connected-items	Returns a list of all the connected items to a pin or net.
get-export-backend	Get the currently set CAD exporter backend.
get-min-width	Get the minimum width rule for a given LayerSpecifier.
via-backdrill	Get the backdrill of a pcb-via definition.
reference-designator	Get the reference designator of a component.
optimized-mode?	Checks whether the algorithmic core has been compiled
clearances	Get the clearances specified by a Rules object
view-sub-schematic (+ 3)	Visualize the generated sub-schematic for a list of nets and instances.
emodel? (+ 1)	Get the emodel of a component or the component of an inst, if it exists.
transform-component	Applies body on component to return a newly transformed Instantiable.
compare-cad
set-property
via-start	Get the start layer of a pcb-via definition.
print-def	Print the ESIR definition as ASCII. Not very human readable.
set-bom-columns	set-bom-columns(cols: Tuple)
length	Get the length of an instance or bundle array.
originating-instantiable	Get the inst definition that created an instance.
pad-shape	Get the shape of a pcb-pad definition.
datasheet? (+ 1)	Get the datasheet name of a component, if it exists.
dims	Compute the x/y dimensions of a shape.
clear-default-rules	This has been deprecated; JITX now includes a default rule set.
run-checks	Runs all checks statements, saves results in a file named filename, and returns a CheckSummary.
transform-module	Applies body on module to return a newly transformed Instantiable. This is how to run custom passes on your design module.
containing-instance	Get the instance that an object is contained within, if it exists.
current-rules?	Get the current design rules.

Definitions

AssignSymbolError

public defstruct AssignSymbolError <: Exception
    errors: Tuple
    symbol: String

• errors: Tuple

• symbol: String

Constructors

AssignSymbolError

Constructor for defstruct AssignSymbolError

public defn AssignSymbolError (symbol:String, errors:Tuple)

AssignLandPatternError

public defstruct AssignLandPatternError <: Exception
    msg: String|Printable
    name: String

• msg: String|Printable

• name: String

Constructors

AssignLandPatternError

Constructor for defstruct AssignLandPatternError

public defn AssignLandPatternError (name:String, msg:String|Printable)

AuthorizedVendor

Define the approved vendors used by the design.

public defenum AuthorizedVendor <: Equalable & Hashable

• JLCPCB

• LCSC

• DigiKey

• Future

• Mouser

• Arrow

• Avnet

• Newark

Syntax

set-bom-vendors([
  "JLCPCB",
  "Arrow",
  "Avnet",
  "DigiKey",
  "Future",
  "Mouser",
  "Newark"
])

set-bom-design-quantity(100)

;write the BOM files to disk
export-bom()

Description

The set-bom-vendors command will define the list of approved parts vendors. Parts are queried from these vendors to be placed in the design.

It is possible to use the enum's specified in AuthorizedVendor instead of String to avoid typo. For example: set-bom-vendors([LCSC]) works also.

Functions

set-bom-vendors

public defn set-bom-vendors (vendors:Tuple<String|AuthorizedVendor>|False) -> Null

• Returns Null

General Definitions

clear-definitions

public defn clear-definitions () -> Null

• Returns Null

make-port

public defn make-port (name:Symbol)

make-port

public defn make-port (name:Symbol, type:PortType)

via-filled

Get the filled attribute o a pcb-via definition.

public defn via-filled (obj:JITXDef) -> True|False

• Returns True|False

Syntax

pcb-via th-via :
  type = MechanicalDrill
  start = LayerIndex(0, Top)
  stop = LayerIndex(0, Bottom)
  diameter = 0.6
  hole-diameter = 0.3

println(via-filled(th-via))

Description

The via-filled introspection function returns whether a pcb-via definition is filled or not. If the filled attribute is not specified, the default value is returned. See pcb-via documentation for more information.

design-explorer-to-string

public defn design-explorer-to-string (def:Instantiable) -> String

• Returns String

enable-import-dump-ir

Dump the generated internal representation during import

public defn enable-import-dump-ir (b:True|False) -> Null

• Returns Null

Syntax

enable-import-dump-ir(true)
import-cad(...)

Description

The enable-import-dump-ir command is a debugging tool to dump the importer's internal representation(s) into a human readable text form. It is generally only useful for analyzing importer errors. The command can be called with false as the input to re-disable dumping after enabling.

port-type

Get the type of a port from a component or module definition/instance

public defn port-type (obj:JITXObject) -> PortType

• Returns PortType

Syntax

pcb-module my-module :
  port p : i2c
  println(port-type(p))

Description

Ports of components or modules may be one of a given [PortType], valid port types are SinglePin, Bundle, PortArray

modify-components

Transforms module by modifying every component definition by calling the

public defn modify-components (modify-component:(Instantiable) -> Instantiable|False, module:Instantiable) -> Instantiable

• Returns Instantiable

user-supplied function modify-component on them. Whenever modify-component returns a new Instantiable, the component definition will be swapped in place. However, this substitution only takes effect in the new module returned by modify-components. If modify-component instead returns false, the component will be left as is.

To make useful changes, modify-component can use the transform-component function to add statements to the given component definition.

Example

defn standardize-parts (module:Instantiable) -> Instantiable :
  within component = modify-components(module) :
    if name(component) == "my-resistor" :
      println("standardizing component %_" % [name(component)])
      within transform-component(component) :
        inside pcb-component :
          val [p1,p2] = pins(self) as [Pin Pin]
          val symb = my-preferred-resistor-symbol
          val [q1,q2] = pins(symb) as [Pin Pin]
          override symbol = symb(p1 => q1, p2 => q2)
    else :
      false ; don't change the component
val new-design = standardize-parts(original-design)
set-main-module(new-design)

This example overrides the symbol of every component named my-resistor to my-preferred-resistor-symbol, mapping the pins in the order they were given.

simplify

public defn simplify (s:Shape) -> Shape

• Returns Shape

dbquery

public defn dbquery (params:Tuple<KeyValue<String, Tuple<String>|Tuple<Double>|String|Double|Int>>, limit:Int) -> Tuple<JSON>

• Returns Tuple<JSON>

ref?

public defn ref? (a:JITXObject) -> Ref|False

• Returns Ref|False

apply-variants

Apply Variants to a design to obtain a new design

public defn apply-variants (vs:Tuple<String>, module:Instantiable) -> Instantiable

• Returns Instantiable

Or no Variant is used if the argument is empty

Syntax

pcb-module my-module :
  inst a : component-a

  variant "DNP" :
    do-not-populate(a)

val new-module = apply-variants(["DNP"] my-module)
set-main-module(new-module)

Description

The apply-variants command is used to transform a module into another module with the Variants applied.

set-config-sets

public defn set-config-sets (configs:Tuple<Symbol>) -> Null

• Returns Null

ports

Get the ports of a component, bundle, or module

public defn ports (obj:JITXObject)

Syntax

val ports = ports(my-component)
for p in ports do :
  println(ref(port))

Description

ports are defined using the port statement. The ports introspection retrieves all port statements associated with the bundle, component, or module.

ports

public defn ports (def:Instantiable|Bundle)

get-min-space

Get the minimum space rule for a given LayerSpecifier.

public defn get-min-space (l:LayerSpecifier|LayerIndex) -> Double

• Returns Double

Syntax

val min-cu-space = get-min-space(LayerIndex(0))

Description

get-min-space is a convenience function around clearance and current-rules introspections for quickly retrieving the DRC parameters for the minimum space on a given layer. Currently only copper and solder mask bridge spacings are supported.

set-main-module

Define the "main" module of the current design.

public defn set-main-module (module:Instantiable)

Syntax

pcb-module main-module :
  ...

set-main-module(main-module)

Description

The main module is the root of the entire JITX design, and is analogous to a "root" schematic sheet.

public-instances

Get the public instances of a module.

public defn public-instances (obj:JITXObject)

Syntax

pcb-module my-module :
  inst R1 : gen-res-cmp(1.0e3)
  public inst R2 : gen-res-cmp(2.0e3)

; This loop will only print "2000.0", since
; R1 is a private instance.
for cmp in public-instances(my-module) do :
  println(property(cmp.resistance))

Description

By default, all instances in a module are considered to have "private" visibility, which disables instantiators from referencing the instances' refs, ports, and properties.

The public-instances introspection returns a sequence of instances of a module that are explicitly marked public.

public-instances

public defn public-instances (def:Instantiable)

start-timer

public defn start-timer (name:String) -> Null

• Returns Null

clearance

Get a specific clearance rule.

public defn clearance (r:Rules, c:ClearanceType) -> Double

• Returns Double

Syntax

val min-cu-width = clearance(current-rules(), MinCopperWidth)
println(min-cu-width)

; convenience variation to lookup a
; val min-cu-width = clearance(MinCopperWidth)

Description

The clearance introspection takes a Rules and ClearanceType and lookups up the associated value with that ClearanceType. When called without an explicit Rules argument, the current-rules() are used.

clearance

public defn clearance (c:ClearanceType) -> Double

• Returns Double

public-single-instances

Get the public single (non array) instances of a module.

public defn public-single-instances (obj:JITXObject)

Syntax

pcb-module my-module :
  inst R : gen-res-cmp(1.0e3)[10]
  inst R11 : gen-res-cmp(2.0e3)
  public inst R12 : gen-res-cmp(3.0e3)

; This loop will only print "3000.0", as there
; is only one "single' instance in `my-module`.
; that is explicitly marked `public`
for cmp in single-instances(my-module) do :
  println(property(cmp.resistance))

Description

The public-single-instances introspection returns a sequence of explicitly public instances that are not defined within instance arrays.

public-single-instances

public defn public-single-instances (def:Instantiable)

bom-vendors

public defn bom-vendors () -> Tuple<String>|False

• Returns Tuple<String>|False

no-connect?

Check if a pin is no-connect.

public defn no-connect? (pin:JITXObject) -> True|False

• Returns True|False

Syntax

pcb-component component :
  pin GND
  pin VDD
  pin NC
  no-connect(NC)

pcb-module my-module :
  inst U1 : component
  ; prints false.
  println(no-connect?(U1.GND)
  ; prints false.
  println(no-connect?(U1.VDD)
  ; prints true.
  println(no-connect?(U1.NC)

Description

The no-connect? introspection checks if a no-connect(...) statement has been applied to the given pin. This is useful when writing checks.

assign-pins?

public defn assign-pins? () -> Instantiable|False

• Returns Instantiable|False

instantiable-type

Return the type of instantiable an object is.

public defn instantiable-type (obj:JITXObject) -> InstantiableType

• Returns InstantiableType

Syntax

pcb-module my-module :
  ...

; prints `Instantiable`.
println(instantiable-type(obj))

Description

The instantiable-type is either a single instantiable (Instantiable) or an array of instantiables (InstantiableArray).

view-schematic

Visualize the generated schematic.

public defn view-schematic (view-mode:ViewMode) -> Null

• Returns Null

Syntax

; Default: update the view
view-schematic()
; Visualize, panning to the center of the view and zooming to fit
view-schematic(NewView)
; Visualize, but maintain the same pan/zoom state.
view-schematic(UpdateView)

Description

The view-schematic command is used to visualize the generated circuit board.

view-schematic

public defn view-schematic () -> Null

• Returns Null

print-rules-functions

public defn print-rules-functions () -> Null

• Returns Null

export-bom

Export the bill of materials (BOM) to the design directory.

public defn export-bom () -> Null

• Returns Null

Syntax

set-bom-vendors([
  "JLCPCB",
  "Arrow",
  "Avnet",
  "DigiKey",
  "Future",
  "Mouser",
  "Newark"
])

set-bom-design-quantity(100)

;write the BOM files to disk
export-bom()

Description

The export-bom command will create the following files in the design directory :

<design-directory>/bom/<design>.tsv
<design-directory>/bom/<design>.select

The .tsv file is a tab separated value that can be imported by spreadsheet software to order parts. The formatting is not defined and subject to change. Parts are autoselected, unless overridden by the .select file.

set-export-board?

Set whether export-cad should generate board files.

public defn set-export-board? (b:True|False) -> Null

• Returns Null

Syntax

set-export-board?(true) ; or false

Description

By default, the export command will generate a board. Use set-export-board? to control whether it is generated or not.

enable-debug-plugin-serializer

Enable debugging printout from the plugin object serializer.

public defn enable-debug-plugin-serializer () -> Null

• Returns Null

Syntax

enable-debug-serializer()

set-design-directory

public defn set-design-directory (filepath:String) -> Null

• Returns Null

start-new-timer

public defn start-new-timer (name:String) -> String

• Returns String

dbquery-first

public defn dbquery-first (args:Tuple<KeyValue<String, Tuple<String>|Tuple<Double>|String|Double|Int>>) -> JSON

• Returns JSON

export-cad

Export the JITX design to CAD.

public defn export-cad (field-mapping:False|Tuple<KeyValue<String, String>>) -> Null

• Returns Null

Syntax

set-current-design("jitx-design")
set-export-backend(`altium)

; ... run design ...

export-cad()
; Cad files written to <project-root>/designs/jitx-design/altium

Or

val mappings = [
  "rated-temperature" => "Rated-temperature"
  "datasheet" => "Datasheet"
]
export-cad(mappings)
; Cad files exported with the field/property names converted.

Description

The export-cad command will take the generated board and schematic and convert it to a set of files in the design directory that can be used in CAD software.

The output directory will be <design-directory-name>/<export-backend>.

An optional field-mappings can be supplied as an argument. Name, Description, Manufacturer, MPN, Reference-prefix will always be exported, even if there is no field-mappings. Their exported names can be changed by using the field-mapping.

Component properties can also be exported if an entry exists in field-mappings. For example, if there is a property(U1.datasheet) = "http://www.somewhere.com/my-datasheet.pdf", using "datasheet" => "Datasheet" in the field-mappings (as above), a field "Datasheet" with value "https://www.somewhere.com/my-datasheet.pdf" will appear as a property of the component in CAD software.

A property will not be exported if... * there is no corresponding entry in field-mappings; OR * it does not exist; OR * its value cannot be converted to a string.

To export a property without name change, put the same name in both ends of the mapping. For example, "rated-voltage" => "rated-voltage".

export-cad

public defn export-cad ()

set-value-format-options

Set the formats of the value strings during export operation.

public defn set-value-format-options (format-options:Tuple<String>) -> Null

• Returns Null

Syntax

set-current-design("jitx-design")
set-export-backend(`kicad)
val format-options = ["keep-decimal" "LC-units-always-present"]
set-value-format-options(format-options)

; ... run design ...

export-cad()
; Cad files written to <project-root>/designs/jitx-design/altium

Description

The set-value-format-options command will set the preferences to generate component values. It is optional. export-cad will work even if this command is not present. By default, without this command the output will look like these: By way of examples: | |Value |Output| |----------|------------------|------| |Resistor |3300 Ohm |3K3 | | |100 Ohm |100R | |----------|------------------|------| |Capacitor |0.0000047 Farad |4.7u | | |0.000000010 Farad |10n | |----------|------------------|------| |Inductor |0.010 Henry |10m |

If a string is present in the format-options, the value will be different: "use-small-k" => 3300-ohm Resistor Value will be: 3k3 "use-greek-mu" => 0.0000047-farad Capacitor Value will be: 4.7μ "use-greek-ohm" => 100-ohm Resistor Value will be: 100Ω "R-unit-always-present" => 3300-ohm Resistor Value will be: 3K3R or 3K3Ω "LC-units-always-present" => 0.0000047-farad Capacitor Value will be: 4.7uF "R-not-replace-decimal-by-quantifier" => 3300-ohm Resistor Value will be: 3.3K "LC-replace-decimal-by-quantifier" => 0.0000047-farad Capacitor Value will be: 4u7 "keep-decimal" => 100-ohm Resistor Value will be: 100.0R "C-replace-n-by-K" => 0.000000010-farad Capacitor Value will be: 10K or 10k (if "use-small-k" is also present) "add-tolerance" => 0.010-henry Inductor Value will be: 10m ± 20% (depends on actual tolerance value)

public-single-pin-nets

Get the nets of a module.

public defn public-single-pin-nets (obj:JITXObject)

Syntax

pcb-module my-module :
  inst R1 : gen-res-cmp(1.0e3)
  inst R2 : gen-res-cmp(1.0e3)
  net my-net (R1.p[1], R2.p[1])
  public net my-public-net (R1.p[2], R2.p[2])

  for n in public-nets(self) do :
    println(name(n))

Description

The public-single-pin-nets introspection is useful for extracting all the net statements of a module with a single pin that are explicitly marked public.

public-single-pin-nets

public defn public-single-pin-nets (def:Instantiable)

pad-type

Get the type of a pcb-pad definition.

public defn pad-type (p:Pad|Self)

Syntax

pcb-pad my-pad :
  shape = Circle(1.0)
  type  = SMD

println(pad-type(my-pad))

Description

The pad-type introspection returns the PadType associated with a pcb-pad definition, which can either be TH (through hole) or SMD (surface mount)

make-pin

public defn make-pin (name:Symbol)

assign-symbol

Assign a symbol to a pcb-component

public defn assign-symbol (symbol:SchematicSymbol) -> Null

• Returns Null

Syntax

public pcb-component component :
  name = "142-0761-881"
  manufacturer = "Johnson / Cinch Connectivity Solutions"
  mpn = "142-0761-881"
  reference-prefix = "J"

  pin-properties :
    [pin:Ref  |pads:Int ...   | side:Dir]
    [sig      | 1             | Left    ]
    [gnd      | 2 3           | Down    ]

  assign-symbol(coax-sym)
  assign-landpattern(johnson-142-0761-881-pkg)

Description

The assign-symbol function uses the pin column in a pin-properties table to map the pins of a component to the pins of a schematic symbol. The symbol pin names must match the component pin names

get-signal-boundary

Retrieve the signal-boundary of a Board.

public defn get-signal-boundary (def:Board) -> Shape

• Returns Shape

Syntax

pcb-board my-board:
  signal-boundary = my-shape
  ...

pcb-module main-module :
  println("Board signal-boundary: %_" % [get-signal-boundary(get-board() as Board)])

set-board(my-board)
; Prints the value of `my-shape`, a Shape object
set-main-module(main-module)

Description

The get-signal-boundary introspection returns the "signal-boundary" field of a given pcb-board. Its return value is a Shape.

model3ds

Get the model3ds of a pcb-landpattern.

public defn model3ds (obj:LandPattern|Self) -> Tuple<Model3D>

• Returns Tuple<Model3D>

Syntax

stanza val landpattern = ocdb/components/st-microelectronics/landpatterns/TSSOP20 for model3d in model3ds(landpattern) do : println(model3d)

# Description

The model3ds introspection returns all the Model3Ds in the landpattern.

single-instances

Get the single (non array) instances of a module.

public defn single-instances (obj:JITXObject)

Syntax

pcb-module my-module :
  inst R : gen-res-cmp(1.0e3)[10]
  inst R11 : gen-res-cmp(2.0e3)

; This loop will only print "2000.0", as there
; is only one "single' instance in `my-module`.
for cmp in single-instances(my-module) do :
  println(property(cmp.resistance))

Description

The single-instances introspection returns a sequence of instances of a module that are not defined within instance arrays.

single-instances

public defn single-instances (def:Instantiable)

get-shape-from-contour

Get a shape from a tuple of lines/polylines.

public defn get-shape-from-contour (lines:Tuple<Line|Polyline>) -> Polygon|PolygonWithArcs

• Returns Polygon|PolygonWithArcs

Syntax

val line1 = Line(1.0, [Point(0.0, 1.0), Point(0.0, 0.0)])
val line2 = Polyline(1.0, [Point(0.0, 0.0), Point(1.0, 0.0), Point(0.0, 1.0)])
val shape = get-shape-from-contour([line1, line2])
println(shape)

Description

The get-shape-from-contour command computes a polygon from a list of lines and/or polylines. The lines/polylines must be in the same order as they are along the boundary of the polygon.

set-use-layout-sketch

Configure the placer to run in sketch mode.

public defn set-use-layout-sketch () -> Null

• Returns Null

Syntax

set-use-layout-sketch()

Description

When running in sketch mode, the placer will not take Layout Groups into account (faster).

make-net

public defn make-net (name:Symbol, type:PortType|False, refs:Seqable<JITXObject|Seqable<JITXObject>>, public?:True|False)

make-net

public defn make-net (name:Symbol, type:PortType|False, refs:Seqable<JITXObject|Seqable<JITXObject>>)

make-net

public defn make-net (name:Symbol, refs:Seqable<JITXObject|Seqable<JITXObject>>, public?:True|False)

make-net

public defn make-net (name:Symbol, refs:Seqable<JITXObject|Seqable<JITXObject>>)

set-default-rules

Sets the default rules for all designs in the current program.

public defn set-default-rules (rules:Rules)

This has been deprecated; JITX now includes a default rule set.

Syntax

pcb-rules jlc-pcb-rules :
  ...

set-default-rules(jlc-pcb-rules)

Description

Default rules differ from design rules set in set-rules in that they are not cleared between designs, and serves as temporary or default values for design rules so generators can make progress even if you have not set the rules for your design.

Default rules can also be used to share design rules in multi-design programs.

pads

Get the pads of a pcb-landpattern.

public defn pads (obj:LandPattern|Self) -> Tuple<LandPatternPad>

• Returns Tuple<LandPatternPad>

Syntax

val landpattern = ocdb/components/st-microelectronics/landpatterns/TSSOP20
for pad in pads(landpattern) do :
  println(pad)

Description

The pads introspection returns all the LandPatternPads that have been created using the pad ... statement.

refs

Return all the refs inside of an object

public defn refs (obj:JITXObject)

Syntax

pcb-module main-module :
  for r in refs(self) do :
    println(r)

layers

Get the layer statements of a pcb-landpattern or pcb-pad.

public defn layers (obj:LandPattern|Pad|Self) -> Tuple<LayerShape>

• Returns Tuple<LayerShape>

Syntax

val landpattern = ocdb/components/st-microelectronics/landpatterns/TSSOP20
for layer in layers(landpattern) do :
  println("There is a %_ on %_." % [shape(layer), specifier(layer)])

Description

The layers introspection finds all the geometry specified in layer statements in landpattern or pad definitions. It is useful for writing landpattern checks.

landpattern

Get the landpattern associated with a pcb-component definition.

public defn landpattern (obj:Self|JITXDef) -> LandPattern

• Returns LandPattern

Syntax

val component   = ocdb/components/abracon/AMB7/component(10.0e6)
val landpattern = landpattern(component)
print-def(landpattern)

Description

The landpattern introspection function returns the pcb-landpattern definition associated with a pcb-component definition. This is useful for writing checks that look at the landpatterns of components placed in the design.

view-design-explorer

Visualize the design as a hierarchical tree.

public defn view-design-explorer () -> Null

• Returns Null

Syntax

; Visualize the design as a tree
view-design-explorer()

Description

The view-design-explorer command is used to visualize the design in the VSCode UI.

view-design-explorer

public defn view-design-explorer (def:Instantiable -- default-3d:True|False = ?) -> Null

• Returns Null

set-export-backend

Set the CAD exporter backend to use.

public defn set-export-backend (backend:Symbol) -> Null

• Returns Null

Syntax

set-current-design("jitx-design")
set-export-backend(`altium)

; ... run design ...

export-cad()
; Cad files written to <project-root>/designs/jitx-design/altium

Description

The set-export-backend command will control which CAD backend that export-cad will use. The backend will also define some constraints on internals like placement and visualization.

dot

public defn dot (obj:JITXObject, name:Symbol|String) -> JITXObject

• Returns JITXObject

dot

public defn dot (def:JITXDef, name:Symbol|String) -> JITXObject

• Returns JITXObject

dot

public defn dot (obj:JITXObject|JITXDef, r:Ref) -> JITXObject

• Returns JITXObject

log-event-time

public defn log-event-time (name:String) -> Null

• Returns Null

run-evals?

public defn run-evals? (module:Instantiable) -> Instantiable|False

• Returns Instantiable|False

save-generated-file

public defn save-generated-file (file:String, contents:String) -> Null

• Returns Null

clear-timers

public defn clear-timers () -> Null

• Returns Null

layer

Get all the shapes on a specific layer of a landpattern

public defn layer (obj:LandPattern|Pad|Self, l:LayerSpecifier) -> Tuple<Shape>

• Returns Tuple<Shape>

Syntax

val landpattern = ocdb/components/st-microelectronics/landpatterns/TSSOP20
val solder-mask = layer(landpattern, SolderMask(Top))

Description

The layer introspection retrieves all the geometry on a single layer defined in a landpattern or pad.

get-property?

public defn get-property? (obj:JITXObject|JITXDef, name:Symbol) -> Maybe<?>

• Returns Maybe<?>

view-board-to-string

public defn view-board-to-string () -> String

• Returns String

instance-status?

Retrieve the component in-BOM and on-board status of a component instance (deprecated)

public defn instance-status? (obj:JITXObject) -> [ComponentBOMStatus, ComponentBoardStatus]

• Returns [ComponentBOMStatus, ComponentBoardStatus]

connected?

Check if a pin or a net is connected

public defn connected? (obj:JITXObject) -> True|False

• Returns True|False

Syntax

pcb-module my-module :
  inst R : gen-res-cmp(1.0e3)
  println(connected?(R.p[1]))

Description

The connected? introspection checks if a pin or net is connected to any other pins or nets in a design. This is useful when writing checks for connected or unconnected components.

connected?

public defn connected? (objs:Seqable<JITXObject>) -> True|False

• Returns True|False

get

public defn get (obj:JITXObject, index:Int) -> JITXObject

• Returns JITXObject

side

Get the side of a pad in a landpattern

public defn side (l:JITXObject)

Syntax

val landpattern = ocdb/components/st-microelectronics/landpatterns/TSSOP20
val pads-on-top =
  for pad in pads(landpattern) filter :
    side(pad) is Top

Description

The side introspection is used to find which side of the board a landpattern pad is upon.

dbquery-skip-cache

public defn dbquery-skip-cache (params:Tuple<KeyValue<String, Tuple<String>|Tuple<Double>|String|Double|Int>>, limit:Int) -> Tuple<JSON>

• Returns Tuple<JSON>

disable-spy

Disable dumping the generated internal representation during compilation

public defn disable-spy () -> Null

• Returns Null

Syntax

disable-spy()

Description

The disable-spy command disables the dumping of the compiler's internal representation(s) after a call to enable-spy.

do-not-populate?

Check if a component instance is marked do-not-populate

public defn do-not-populate? (obj:JITXObject) -> True|False

• Returns True|False

public-nets

Get the nets of a module.

public defn public-nets (obj:JITXObject)

Syntax

pcb-module my-module :
  inst R1 : gen-res-cmp(1.0e3)
  inst R2 : gen-res-cmp(1.0e3)
  net my-net (R1.p[1], R2.p[1])
  public net my-public-net (R1.p[2], R2.p[2])

  for n in public-nets(self) do :
    println(name(n))

Description

The public-nets introspection is useful for extracting all the net statements of a module that are explicitly marked public. It's important to note that this corresponds to the individual net statements, and not the electrical concept of a "net." For example, if there are two public nets in a module that are electrically identical, calling nets(self) will return both of them.

public-nets

public defn public-nets (def:Instantiable)

set-current-design

Set the directory "./designs/<name>" that JITX will use to store design data.

public defn set-current-design (name:String) -> Null

• Returns Null

Syntax

set-current-design("jitx-design")

Description

The set-current-design command will clear design state and create a new design directory to store data JITX uses. This directory will contain export data, 3D model files, and cached data used by the design.

dbquery-all

public defn dbquery-all (params:Tuple<KeyValue<String, Tuple<String>|Tuple<Double>|String|Double|Int>>) -> Tuple<JSON>

• Returns Tuple<JSON>

set-cad-info

public defn set-cad-info (name:String, info:?)

all-items-with-properties

public defn all-items-with-properties (m:Self|JITXDef, prop-names:Tuple<Symbol>) -> Tuple<JITXObjectProperty>

• Returns Tuple<JITXObjectProperty>

set-paper

Set the paper size used in schematic export

public defn set-paper (paper:Paper) -> Null

• Returns Null

Syntax

set-paper(ISO-A4)

Description

The set-paper command is used to define the paper size in the exported schematic files.

Valid values are :

public defenum Paper :
  ISO-A0
  ISO-A1
  ISO-A2
  ISO-A3
  ISO-A4
  ISO-A5
  ANSI-A
  ANSI-B
  ANSI-C
  ANSI-D
  ANSI-E
  ANSI-A0 ;deprecated do not use
  ANSI-A1 ;deprecated do not use
  ANSI-A2 ;deprecated do not use
  ANSI-A3 ;deprecated do not use
  ANSI-A4 ;deprecated do not use
  ANSI-A5 ;deprecated do not use

Deprecation Notice: Enum values ANSI-A0 through ANSI-A5 are being deprecated and will be removed soon. Do not use them, use ISO-A0 through ISO-A5 instead.

via-stop

Get the stop layer of a pcb-via definition.

public defn via-stop (obj:JITXDef) -> LayerIndex

• Returns LayerIndex

Syntax

pcb-via th-via :
  type = MechanicalDrill
  start = LayerIndex(0, Top)
  stop = LayerIndex(0, Bottom)
  diameter = 0.6
  hole-diameter = 0.3

println(via-stop(th-via))

Description

The via-stop introspection function returns the stop LayerIndex of a pcb-via definition.

save-to-svg

public defn save-to-svg (filename:String) -> Null

• Returns Null

set-use-layout-groups

Configure the placer to run in groups mode.

public defn set-use-layout-groups () -> Null

• Returns Null

Syntax

set-use-layout-groups()

Description

When running in groups mode, the placer will take Layout Groups into account (slower).

assign-landpattern

Map a landpattern to a component using pin properties.

public defn assign-landpattern (package:LandPattern) -> Null

• Returns Null

Syntax

public pcb-component component :
  manufacturer = "Texas Instruments"
  mpn          = "FDC2214QRGH"

  pin-properties :
    [pin:Ref | pads:Int ... | side:Dir ]
    [i2c.scl | 1            | Left     ]
    [i2c.sda | 2            | Left     ]
    [CLKIN   | 3            | Left     ]
    [ADDR    | 4            | Left     ]
    [INTB    | 5            | Left     ]
    [SD      | 6            | Left     ]
    [VDD     | 7            | Left     ]
    [GND     | 8            | Left     ]
    [IN0A    | 9            | Right    ]
    [IN0B    | 10           | Right    ]
    [IN1A    | 11           | Right    ]
    [IN1B    | 12           | Right    ]
    [IN2A    | 13           | Right    ]
    [IN2B    | 14           | Right    ]
    [IN3A    | 15           | Right    ]
    [IN3B    | 16           | Right    ]

val lp = qfn-landpattern(0.5, 3.8, 16, 0.25, 0.4, [2.6 2.6])
assign-landpattern(lp)

Description

The assign-landpattern convenience function is a helper for mapping a landpattern to a pcb-component using the pin-properties table. The table must contain a pads column whose type is | pads: Int ...|, | pads: Ref ...| or |pads: Int|Ref ...|. Multiple entries in the pads column can be used to assign a component pin to multiple pads.

reference-prefix?

Get the reference prefix of a component, if it exists.

public defn reference-prefix? (c:Instantiable) -> String|False

• Returns String|False

Syntax

pcb-module my-module :
  inst U : ocdb/components/abracon/AMB7/component(10.0e6)
  println(reference-prefix?(U))

Description

Looks up the value associated with an reference-prefix = ... statement in a pcb-component.

reference-prefix?

public defn reference-prefix? (obj:JITXObject) -> String|False

• Returns String|False

via-diameter

Get the diameter of a pcb-via definition.

public defn via-diameter (obj:JITXDef) -> Double

• Returns Double

Syntax

pcb-via th-via :
  type = MechanicalDrill
  start = LayerIndex(0, Top)
  stop = LayerIndex(0, Bottom)
  diameter = 0.6
  hole-diameter = 0.3

println(via-diameter(th-via))

Description

The via-diameter introspection function returns the diameter of a pcb-via definition.

get-property

public defn get-property (obj:JITXObject|JITXDef, name:Symbol) -> ?

• Returns ?

im-feeling-lucky

public defn im-feeling-lucky () -> Null

• Returns Null

get-merged-physical-design-module

Obtain the physical-design-transformed "main" module of the current design.

public defn get-merged-physical-design-module () -> Instantiable

• Returns Instantiable

Syntax

val new-module = get-merged-physical-design-module()

Description

Returns a new module which incorporates all of the physical design information incorporated into the "main" module of the current design.

instance-type

Determine if an instance is a component, module, or array.

public defn instance-type (obj:JITXObject) -> InstanceType

• Returns InstanceType

Syntax

pcb-module my-module :
  inst X : my-component[10]
  print-def(instance-type(X))

Description

The instance-type introspection retrieves the type of an instance, represented as the enum InstanceType:

public defenum InstanceType :
  SingleComponent
  SingleModule
  InstanceArray

enable-spy

Dump the generated internal representation during compilation

public defn enable-spy () -> Null

• Returns Null

Syntax

enable-spy()
evaluate(my-design)

Description

The enable-spy command is a debugging tool to dump the compiler's internal representation(s) into a human readable text form. It is generally only useful for analyzing internal compiler errors.

mpn?

Get the MPN of a component, if it exists.

public defn mpn? (c:Instantiable) -> String|False

• Returns String|False

Syntax

pcb-module my-module :
  inst U : ocdb/components/abracon/AMB7/component(10.0e6)
  println(mpn?(U))

Description

Looks up the value associated with an mpn = ... statement in a pcb-component.

mpn?

public defn mpn? (obj:JITXObject) -> String|False

• Returns String|False

via-tented

Get the tented sides of a pcb-via definition.

public defn via-tented (obj:JITXDef) -> Side|True|False

• Returns Side|True|False

Syntax

pcb-via th-via :
  type = MechanicalDrill
  start = LayerIndex(0, Top)
  stop = LayerIndex(0, Bottom)
  diameter = 0.6
  hole-diameter = 0.3

println(via-tented(th-via))

Description

The via-tented introspection function returns which sides of a pcb-via definition are tented. If the tented attribute is not specified, the default value is returned. See pcb-via documentation for more information.

nets

Get the nets of a module.

public defn nets (obj:JITXObject)

Syntax

pcb-module my-module :
  port p : power
  inst R1 : gen-res-cmp(1.0e3)
  inst R2 : gen-res-cmp(1.0e3)
  net my-net (R1.p[1], R2.p[1])
  net (R1.p[2], R2.p[2])
  net (R1.p[2], p.V-)

  ; Prints three net objects
  for n in nets(self) do :
    println(name(n))

Description

The nets introspection is useful for extracting all the net statements of a module. It's important to note that this corresponds to the individual net statements, and not the electrical concept of a "net". For example, the code snippet above will print out three unique net objects, even though we only have two electrical nets.

nets

public defn nets (def:Instantiable)

notify-vscode-of-loaded-jitx-shell

public defn notify-vscode-of-loaded-jitx-shell (filepath:String) -> Null

• Returns Null

via-hole-diameter

Get the hole diameter of a pcb-via definition.

public defn via-hole-diameter (obj:JITXDef) -> Double

• Returns Double

Syntax

pcb-via th-via :
  type = MechanicalDrill
  start = LayerIndex(0, Top)
  stop = LayerIndex(0, Bottom)
  diameter = 0.6
  hole-diameter = 0.3

println(via-hole-diameter(th-via))

Description

The via-hole-diameter introspection function returns the hole diameter of a pcb-via definition.

pins

Get the pins associated with an object.

public defn pins (obj:JITXObject)

Syntax

val cmp = gen-res-cmp(1.0e3)
for p in pins(cmp) do :
  println(ref(p))

Description

The pins introspection is useful for extracting the pins of a component, bundle, or schematic symbol.

pins

public defn pins (def:Instantiable|Bundle|SchematicSymbol)

instances

Get the instances of a module.

public defn instances (obj:JITXObject)

Syntax

inside pcb-module :
  for r in [1.0e3, 2.0e3, 3.0e3] do :
    inst R : gen-res-cmp(r)

  for i in instances(self) do :
    if has-property?(i.resistance) :
      println("There is a resistor: %_ ohms." % [property(i.resistance)])

Description

The instances introspection returns a sequence of all the instances within a module. This is useful for checks and generators that need to loop over the instances of a module to find their properties, generate additional instances, and so on.

instances

public defn instances (def:Instantiable)

clear-dbquery-cache

Clear the cache on disk used for part queries with dbquery so that the parts gets refreshed next time the queries are run.

public defn clear-dbquery-cache () -> Null

• Returns Null

make-node

public defn make-node (name:Symbol, type:PortType, public?:True|False)

make-node

public defn make-node (name:Symbol, type:PortType)

print-current-rules

public defn print-current-rules ()

via-in-pad

Get the via-in-pad attribute of a pcb-via definition.

public defn via-in-pad (obj:JITXDef) -> True|False

• Returns True|False

Syntax

pcb-via th-via :
  type = MechanicalDrill
  start = LayerIndex(0, Top)
  stop = LayerIndex(0, Bottom)
  diameter = 0.6
  hole-diameter = 0.3

println(via-in-pad(th-via))

Description

The via-in-pad introspection function returns whether a via definition is permitted inside a pad or not. If the via-in-pad attribute is not specified, the default value is returned. See pcb-via documentation for more information.

instance-definition

Get the pcb-* definition of an instance.

public defn instance-definition (obj:JITXObject) -> Instantiable

• Returns Instantiable

Syntax

pcb-module my-module :
  inst X : my-component
  print-def(instance-definition(X))

Description

The instance-definition introspection retrieves the pcb-* definition that corresponds to a given component or module.

min-width

Compute the minimum width in a sequence of shapes.

public defn min-width (s:Seqable<Shape>) -> Double

• Returns Double

Syntax

val r1 = loc(-0.5, 0.0) * Rectangle(2.0, 1.0)
val r2 = loc( 0.5, 0.0) * Rectangle(2.0, 1.0)
val mw = min-width([r1, r2])
println(mw)

Description

The minimum width is defined as the minimum length of a line you can draw inside the shape between two segments (on the boundary) with opposite directions and overlapping.

name

Get the name of an object

public defn name (def:JITXDef) -> String

• Returns String

Syntax

pcb-component my-component :
  name = "My Awesome Component"

println(name(my-component))
; prints, "My Awesome Component"

Description

Every definition in JITX has an associated name. It may be overridden explicitly using the name = ... syntax, else it is inferred from the identifier given in the definition. The name (...) introspection function will lookup the associated name from a given definition

manufacturer?

Get the manufacturer name of a component, if it exists.

public defn manufacturer? (c:Instantiable) -> String|False

• Returns String|False

Syntax

pcb-module my-module :
  inst U : ocdb/components/abracon/AMB7/component(10.0e6)
  println(manufacturer?(U))

Description

Looks up the value associated with an manufacturer = ... statement in a pcb-component.

manufacturer?

public defn manufacturer? (obj:JITXObject) -> String|False

• Returns String|False

pose

Get the pose of a pad inside a pcb-landpattern.

public defn pose (l:JITXObject)

WARNING: pad is deprecated. Please use pad-def instead.

Syntax

val landpattern = ocdb/components/st-microelectronics/landpatterns/TSSOP20
for pad in pads(landpattern) do :
  println("There is a pad at: %_" % [pose(pad)])

Description

The pose introspection retrieves the Pose of a pad in a landpattern.

single-pin-nets

Get the nets of a module.

public defn single-pin-nets (obj:JITXObject)

Syntax

pcb-module my-module :
  inst R1 : gen-res-cmp(1.0e3)
  inst R2 : gen-res-cmp(1.0e3)
  net my-net (R1.p[1], R2.p[1])
  net my-single-net (R1.p[2])

  for n in public-nets(self) do :
    println(name(n))

Description

The single-pin-nets introspection is useful for extracting all the net statements of a module that contain only a single pin.

single-pin-nets

public defn single-pin-nets (def:Instantiable)

offset

Compute a shape that is "offset" from another by a fixed distance.

public defn offset (s:Shape, amount:Double) -> Shape

• Returns Shape

Syntax

val rect = Rectangle(10.0, 10.0)
val offset-rect = offset(rect, 1.0)
println(offset-rect) ; Rectangle(11.0, 11.0)

Description

The offset command derives a new shape from an existing one using a factor to expand the dimensions in x/y directions. This is useful when creating new shapes that are a fixed size larger than some root shape.

pad

Get the pcb-pad definition of a pad in a landpattern.

public defn pad (l:JITXObject)

Syntax

val landpattern = ocdb/components/st-microelectronics/landpatterns/TSSOP20
for p in pads(landpattern) do :
  val def = pad(p)
  print-def(def)

Description

The pad introspection returns the pcb-pad definition of a landpattern pad. This is useful for writing landpattern checks that need to inspect the pad data, for example their layers.

ref

Get the associated Ref of an object instance.

public defn ref (a:JITXObject) -> Ref

• Returns Ref

Syntax

pcb-module my-module :
  inst U1 : my-component

  ; Print out the Refs of the pins of a component
  for p in pins(U1) do :
    println(ref(p))

Description

Instances, ports, pins, and pads in the design hierarchy have an associated "reference" name, for example, my-module.U1.p[3]. The ref(...) introspection will look up the associated Ref value with any object, if it is assigned.

run-evals

Runs all eval-when blocks nested within module to return a newly evaluated Instantiable.

public defn run-evals (module:Instantiable) -> Instantiable

• Returns Instantiable

Syntax

pcb-module main-module :
  eval-when has-property?(self.voltage) :
    println("Voltage assigned!")

defn assign-voltage () :
  inside pcb-module :
    property(self.voltage) = 3.3

val transformed-module = transform-module(assign-voltage, main-module)
val evaluated-module = run-evals(transformed-module)

Description

eval-when statements need to be driven by the design generator code. The run-evals command is used to control this.

topology-ends

Get the ends of a named topology.

public defn topology-ends (obj:JITXObject) -> KeyValue<JITXObject, JITXObject>

• Returns KeyValue<JITXObject, JITXObject>

Syntax

pcb-module my-module :
  inst R1 : gen-res-cmp(1.0e3)
  inst R2 : gen-res-cmp(1.0e3)
  topology my-topo (R1.p[1] => R2.p[1])
  val ends:KeyValue<JITXObject,JITXObject> = topology-ends(my-topo)
  println("Topology goes from %_ to %_" % [key(ends) value(ends)])

Description

The topology-ends introspection is useful for extracting the start and end of a named topology object.

view-bom

View the bill of materials (BOM).

public defn view-bom (view:BOMViewMode = ?)

Syntax

view-bom(view:BOMViewMode = BOM-LAST)

Description

BOMViewMode is either BOM-STD: evaluate based on the criteria and display the result BOM-DIFF: evaluate based on the criteria and display the difference since the last version BOM-LAST: do not evaluate, just display the last version if no parameter is given, view-bom(BOM-LAST) is the default.

evaluate

Evaluates a definition, expanding its statements.

public defn evaluate (def:JITXDef) -> Null

• Returns Null

Syntax

pcb-pad simple-pad :
  shape = Circle(1.0)
  apply-soldermask()

evaluate(simple-pad)

Description

The evaluate (...) introspection forces the expansion of a pcb-*** definition, including all of its generators. This is useful when writing unit test, or working on generators outside of an existing design.

via-type

Get the drill type of a pcb-via definition.

public defn via-type (obj:JITXDef) -> ViaDrillType

• Returns ViaDrillType

Syntax

pcb-via th-via :
  type = MechanicalDrill
  start = LayerIndex(0, Top)
  stop = LayerIndex(0, Bottom)
  diameter = 0.6
  hole-diameter = 0.3

println(via-type(th-via))

Description

The via-type introspection function returns the ViaDrillType of a pcb-via definition, which can be either MechanicalDrill or LaserDrill.

expand

Expand a shape by a fixed distance.

public defn expand (s:Shape, amount:Double) -> Shape

• Returns Shape

Syntax

val shape = Rectangle(10.0, 10.0)
val expanded = expand(shape, 1.0)
println(expanded)

Description

The expand command computes an "expanded" shape, which is a shape that is exactly amount distance away from the perimeter of s.

assign-pins

Explicitly run pin assignment before automatic placement, visualization, or export.

public defn assign-pins () -> Instantiable

• Returns Instantiable

Syntax

pcb-module my-module :
  pin x
  supports gpio :
    gpio.gpio => x
  require mygpio: gpio from self

set-main-module(my-module)
val my-module-assigned = assign-pins()

Description

JITX will automatically run pin assignment prior to board placement, export, and visualization. Pin assignment can be run manually using the assign-pins function, which can be useful when running checks or debugging.

Running assign-pins?() instead of assign-pins will return False if there is no valid pin assignment.

import-cad

Import CAD projects from KiCAD or Altium.

public defn import-cad (input-dir:String, output-dir:String, cad:CadSoftware) -> ImportCadResult

• Returns ImportCadResult

Syntax

defpackage import-script :
  import core
  import jitx
  import jitx/commands

import-cad("input-directory", "output-directory", Altium)

Optional field-mapping can be used to change property field names, used only in KiCad. Possible target Fields are "Name", "Manufacturer", "MPN", "Description", case-sensitive. For example, you can map "Field1" to "Manufacturer" and "Part Desc" to "Description" by

val mapping = [ "Field1" => "Manufacturer" "Part Desc" => "Description" ]
import-cad("input-design", "output-directory", Altium, field-mapping)

Description

The import-cad command is used to read KiCAD or Altium files from input-directory and generate JITX code in output-directory. The currently supported CadSoftware values are :

public defenum CadSoftware :
  Kicad ; Experimental v6 support
  Altium

Requirements

• The inputdirectory must exist.
• input may not be a symbolic link.
• The output directory must not exist or be an empty directory
• When importing a board, schematic, and netlist:
• Reference designators in the project files must be consistent.
• Nets on the board, in the schematic, and netlist must be consistent.
• "Consistent" means components may not be present on the board or schematic that aren't in the other, nets on the board/schematic/netlist must be the same, etc.
• Altium constraints :
• Only files generated with the JITX Altium Extension will be imported. These are files with the following extensions :
  • (SCHLIB).JSON
  • (SCHDOC).JSON
  • (PRJPCB).JSON
  • (PCBLIB).JSON
  • (PCBDOC).JSON
• Kicad constraints :
• Only files of the following file extension will be imported :
  • kicad_mod
  • kicad_sym
  • kicad_pcb
  • kicad_sch
  • net
  • kicad_pro
  • fp-lib-table
• Only Kicad 6 is supported.
• A netlist (.net) file must be provided.
• Only one .kicad_pcb, .kicad_pro, and .net file may exist in the input directory.
• 3D Model Files:
• only .step, .stp, and .wrl files will be copied to imported code.
• BOM Files:
• BOM files must be named jitx-import-bom.tsv and be of the correct schema

import-cad

public defn import-cad (input-dir:String, output-dir:String, cad:CadSoftware, field-mapping:False|Tuple<KeyValue<String, String>>) -> ImportCadResult

• Returns ImportCadResult

set-export-schematic?

Set whether export-cad should generate schematic files.

public defn set-export-schematic? (b:True|False) -> Null

• Returns Null

Syntax

set-export-schematic?(true) ; or false

Description

By default, the export command will generate a schematic. Use set-export-schematic? to control whether it is generated or not.

current-rules

Get the current design rules of the project

public defn current-rules () -> Rules

• Returns Rules

Syntax

val rules = current-rules()

Description

The current-rules introspection returns the design rules that have been set with set-rules, or set-default-rules if set-rules has never been called. It fails if there are no design rules for the design.

view

View a landpattern, schematic symbol, or pcb-component.

public defn view (def:LandPattern, view-mode:ViewMode) -> Null

• Returns Null

Syntax

; Default: update the view
view(ocdb/utils/symbols/resistor-sym)
; Visualize, panning to the center of the view and zooming to fit
view(ocdb/utils/symbols/resistor-sym, NewView)
; Visualize, but maintain the same pan/zoom state.
view(ocdb/utils/symbols/resistor-sym, UpdateView)

Description

The view command is used to visualize generated landpatterns, schematic symbols, or components. It will fail if passed a pcb-module or array of instantiables.

view

public defn view (def:SchematicSymbol, view-mode:ViewMode) -> Null

• Returns Null

view

public defn view (def:Instantiable, view-mode:ViewMode) -> Null

• Returns Null

view

public defn view (def:LandPattern) -> Null

• Returns Null

view

public defn view (def:SchematicSymbol) -> Null

• Returns Null

view

public defn view (def:Instantiable) -> Null

• Returns Null

get-net

Find a net with a given name in a module.

public defn get-net (name:String) -> JITXObject

• Returns JITXObject

Syntax

pcb-module my-module :
  inst R1 : gen-res-cmp(1.0e3)
  inst R2 : gen-res-cmp(1.0e3)
  net my-net (R1.p[1], R2.p[1])

  ; ...

  val my-net = get-net(my-module, "my-net")

Description

Sometimes nets are generated programmatically and it may not be possible to use the local identifier to lookup a net. For this purpose, the get-net introspection will search the net statements of the current module.

This function must be called inside pcb-module.

freeze-reference-designators

Freeze all the reference designators, so they will not be recomputed.

public defn freeze-reference-designators () -> Instantiable

• Returns Instantiable

Syntax

val lowered-module = run-final-passes(module)
set-main-module(lowered-module)
set-main-module(freeze-reference-designators())

Description

The freeze-reference-designators command stops the JITX compiler from generating new reference designators for existing components in a design.

indices

Get the indices of an array of JITX objects.

public defn indices (obj:JITXObject) -> Seqable<Int>

• Returns Seqable<Int>

Syntax

inside pcb-module :
  port p: pin[[1 2 3 5 7]]

  val indices = indices(p)

  for idx in indices do :
    val p* = p[idx]
    println(port-type(p*))

Description

Arrays of JITX objects can have custom indices. The indices (...) introspection is useful for extracting port/pin or instances indices for generators that may need to reference them.

get?

public defn get? (obj:JITXObject, index:Int) -> JITXObject|False

• Returns JITXObject|False

get?

public defn get? (obj:JITXObject, name:Symbol|String) -> JITXObject|False

• Returns JITXObject|False

get?

public defn get? (def:JITXDef, name:Symbol|String) -> JITXObject|False

• Returns JITXObject|False

has-board?

Check if the board has been set.

public defn has-board? () -> True|False

• Returns True|False

Syntax

println(has-board?())
set-board(ocdb/utils/defaults/default-board(4))
println(has-board?())

Description

The has-board? introspection is a convenience function to check if the board has been set by a call to set-board.

get-stackup

Retrieve the stackup of a Board.

public defn get-stackup (def:Board) -> Stackup

• Returns Stackup

Syntax

pcb-stackup my-stackup :
  ...
pcb-board my-board:
  stackup = my-stackup
  ...

pcb-module main-module :
; Prints my-stackup 
  println("Stackup: %_" % [get-stackup(get-board() as Board)])

set-board(my-board)
set-main-module(main-module)

Description

The get-stackup introspection returns the "stackup" property of a given pcb-board. Its return value is a Stackup JITX definition.

component-instances

Get the instances of a module that are components (not modules).

public defn component-instances (obj:JITXObject)

Syntax

pcb-module sub-module :
  ..
pcb-module my-module :
  inst sub : sub-module
  inst cmp : gen-res-cmp(1.0e3)

; This will only print "my-module.cmp" as it is the only
; instance of the module that is **not** another module.
for cmp in component-instances(my-module) do :
  println(ref(cmp))

Description

The component-instances introspection returns a sequence of instances of a module that are components, that is to say that they are instances at the bottom of the design hierarchy (not contained within submodules of the module).

component-instances

public defn component-instances (def:Instantiable)

get-board

Get the current pcb-board, if it exists

public defn get-board () -> Board|False

• Returns Board|False

Syntax

val current-board? = get-board()

Description

The get-board introspection returns a board that has been set by set-board, if it exists.

get-def-string

Get the string representation of the ESIR definition as ASCII.

public defn get-def-string (def:JITXDef) -> String

• Returns String

Returns the same string that print-def prints.

Syntax

pcb-module my-module :
  ...

val my-module-str = get-def-string(my-module)

get-def-string will return the fully expanded definition string. JITX definitions include pcb-board, pcb-module, pcb-rules, pcb-stackup, pcb-component, pcb-pad, pcb-landpattern, etc.

explorer-json

public defn explorer-json (def:JITXDef) -> JSON

• Returns JSON

stop-timer

public defn stop-timer (name:String) -> Null

• Returns Null

set-board

Sets the pcb-board object used by the current design.

public defn set-board (board:Board)

Syntax

pcb-board my-board :
  ...

set-board(my-board)

Description

This specifies the pcb-board which defines the stackup, board outline, and signal boundary of the physical board used in the design.

Multi-board designs require separate calls to set-current-design, set-board, etc.

package-poses

Get the package poses associated with a pcb-component definition.

public defn package-poses (obj:JITXDef) -> Tuple<PackagePose>

• Returns Tuple<PackagePose>

Syntax

val package-poses = package-poses(my-module)
do(println, package-poses)
print-def(inst(package-poses[0]))

Description

The package-poses introspection function returns the pose information given explicitly to instances in a pcb-module definition. The returned object is

public defstruct PackagePose :
  inst:Instance
  pose:Pose|False
  side:Side
  anchor:Instance|False

component-status?

Retrieve the component in-BOM and on-board status of a component instance (deprecated)

public defn component-status? (obj:JITXObject) -> [ComponentBOMStatus, ComponentBoardStatus]

• Returns [ComponentBOMStatus, ComponentBoardStatus]

view-board

Visualize the generated board.

public defn view-board (view-mode:ViewMode) -> Null

• Returns Null

Syntax

; Default: update the view
view-board()
; Visualize, panning to the center of the view and zooming to fit
view-board(NewView)
; Visualize, but maintain the same pan/zoom state.
view-board(UpdateView)

Description

The view-board command is used to visualize the generated circuit board.

view-board

public defn view-board () -> Null

• Returns Null

get-boundary

Retrieve the boundary of a Board.

public defn get-boundary (def:Board) -> Shape

• Returns Shape

Syntax

pcb-board my-board:
  boundary = my-shape
  ...

pcb-module main-module :
  println("Board boundary: %_" % [get-boundary(get-board() as Board)])

set-board(my-board)
; Prints the value of `my-shape`, a Shape object
set-main-module(main-module)

Description

The get-boundary introspection returns the "boundary" field of a given pcb-board. Its return value is a Shape.

set-bom-design-quantity

Set the quantity of boards to manufacturer when generating a BOM.

public defn set-bom-design-quantity (quantity:Int) -> Null

• Returns Null

Syntax

set-bom-vendors([
  "JLCPCB",
  "LCSC",
  "DigiKey",
  "Future",
  "Mouser",
  "Arrow",
  "Avnet"
  "Newark"
])

set-bom-design-quantity(100)

;write the BOM files to disk
export-bom()

Description

The set-bom-design-quantity is used to define the number of boards to manufacturer. It is combined with the vendors list to automatically find parts from the vendors lists in the appropriate quantity to assemble the generated board design.

connected-pins

Return the pins connected to an existing pin.

public defn connected-pins (obj:JITXObject) -> Tuple<Pin>

• Returns Tuple<Pin>

Syntax

pcb-module my-module :
  pin gnd
  public inst R: gen-res-cmp(1.0e3)[4]
  for n in 0 to 4 do :
    net (gnd, R[n].p[1])

  val connected = connected-pins(gnd)
  for p in connected do :
    println(ref(p))

Description

The connected-pins introspection returns a Tuple of all the pins connected to the argument, excluding the argument pin itself. This is useful for writing connectivity checks.

make-inst

public defn make-inst (name:Symbol, type:InstantiableType, public?:True|False)

save-timing-report

public defn save-timing-report (filename:String) -> Null

• Returns Null

set-ipc-info

public defn set-ipc-info (ipc-info:IpcInfo) -> Null

• Returns Null

min-space

Compute the minimum space in a sequence of shapes.

public defn min-space (s:Seqable<Shape>) -> Double

• Returns Double

Syntax

val shapes = [
  loc(1.0, 1.0) * Circle(0.001)
  loc(2.0, -1.0) * Circle(0.01)
]

println(min-space(shapes))

Description

The minimum space in a set of shapes is defined as the smallest distance between non overlapping sides of the shapes. This command is useful when writing DRC checks.

pad-def

Get the pcb-pad definition of a pad in a landpattern.

public defn pad-def (l:JITXObject)

This is an alias for the pad introspection, since pad is a reserved keyword in pcb-landpattern contexts.

Syntax

pcb-landpattern lp (pad-size:Dims) :
  pad p[1] : smd-pad(pad-size)
  pad p[2] : smd-pad(pad-size)
  for p in pads(self) do :
    val def = pad-def(p)
    ; Prints "SMD"
    println(pad-type(def))

Description

The pad-def introspection returns the pcb-pad definition of a landpattern pad. This is useful for writing landpattern checks that need to inspect the pad definition.

set-bom-metrics

set-bom-metrics(metrics: Tuple<BOMMetric>)

public defn set-bom-metrics (metrics:Tuple<BOMMetric>|False)

set the metrics of the bill of materials (BOM).

Syntax

set-bom-metrics([
  BOMMetric(BOMMetricLineItems, "Line Items"),
  BOMMetric(BOMMetricComponentCount, "Components"),
  BOMMetric(BOMMetricTotalCost, "Cost")
])

Description

Set the metrics and their display names in the BOM visualizer.

If not set, the above metrics are used by default.

set-rules

Set the design rules for the current design.

public defn set-rules (rules:Rules)

Syntax

pcb-rules jlc-pcb-rules :
  ...

set-rules(jlc-pcb-rules)

Description

The design rules takes the name of a pcb-rules as an argument and configures the design rules used for generators and checks in the current design. This will be cleared on calls to set-current-design.

all-connected-items

Returns a list of all the connected items to a pin or net.

public defn all-connected-items (m:Self|Instantiable) -> Tuple<ConnectedItems>

• Returns Tuple<ConnectedItems>

Syntax

pcb-module my-module :
  val N = 100
  inst R: gen-res-cmp(1.0e3)[N]
  net gnd ()
  for n in 0 to 100 do :
    net (R.p[1], gnd)

  val connected-items = all-connected-items(self)
  for item in connected-items :
    for n in nets(item) do :
      println(ref(n))

Description

The all-connected-items introspection returns a tuple of ConnectedItems which represent all the connected items in a module. This is primarily used when writing checks that need to observe the full design, for example checking if specific component pins are net'd together or pins on nets have the appropriate properties.

The ConnectedItems structure contains the following fields :

public defstruct ConnectedItems :
  nets: Tuple<Net>
  module-pins: Tuple<Pin>
  component-pins: Tuple<Pin>
  abstract-pins: Tuple<Pin>

get-export-backend

Get the currently set CAD exporter backend.

public defn get-export-backend ()

Syntax

set-current-design("jitx-design")
get-export-backend()

Description

The get-export-backend command returns which CAD backend export-cad is currently set to use.

get-min-width

Get the minimum width rule for a given LayerSpecifier.

public defn get-min-width (l:LayerSpecifier|LayerIndex) -> Double

• Returns Double

Syntax

val min-cu-width = get-min-width(LayerIndex(0))

Description

get-min-width is a convenience function around clearance and current-rules introspections for quickly retrieving the DRC parameters for minimum width on a given layer. Currently, only copper, silkscreen, and solder mask opening widths are supported.

via-backdrill

Get the backdrill of a pcb-via definition.

public defn via-backdrill (obj:JITXDef) -> Backdrill|False

• Returns Backdrill|False

Syntax

pcb-via th-via :
  type = MechanicalDrill
  start = LayerIndex(0, Top)
  stop = LayerIndex(0, Bottom)
  diameter = 0.6
  hole-diameter = 0.3

println(via-backdrill(th-via))

Description

The via-backdrill introspection function returns the backdrill of a pcb-via definition, if it has one. If the backdrill is not specified, the default value is returned. See pcb-via documentation for more information.

reference-designator

Get the reference designator of a component.

public defn reference-designator (obj:JITXObject) -> String

• Returns String

Syntax

pcb-module my-module :
  inst R : gen-res-cmp(1.0e3)
  println(reference-designator(R))

Description

The reference-designator retrieves the the reference designator of a component in the design, which is either generated automatically or defined explicitly using the reference-designator(object) = ... syntax.

optimized-mode?

Checks whether the algorithmic core has been compiled

public defn optimized-mode? () -> True|False

• Returns True|False

with optimizations enabled.

Syntax

optimized-mode?()

Description

The optimized-mode? command returns true if the algorithmic core has been compiled with optimizations enabled, or false otherwise.

clearances

Get the clearances specified by a Rules object

public defn clearances (r:Rules) -> Tuple<RuleClearance>

• Returns Tuple<RuleClearance>

Syntax

for clearance in clearances(current-rules()) :
  println(clearance)

Description

The clearances introspection returns the design rules as a list of RuleClearance objects, containing their name and value.

view-sub-schematic

Visualize the generated sub-schematic for a list of nets and instances.

public defn view-sub-schematic (objects:Tuple<JITXObject>, schematic-group?:True|False) -> Null

• Returns Null

Nets can be single nets, net arrays or bundle nets.

Instances can be component or module instances. They can be single instances or instance arrays.

Syntax

; Objects given to view-sub-schematic need to reference the design main module.
set-main-module(main-module)

; Visualize a list of nets and instances. Default: no schematic groups.
view-sub-schematic([main-module.gnd, main-module.P3V3])
; Visualize a list of nets and instances with schematic groups.
view-sub-schematic([main-module.gnd, main-module.P3V3], true)
; Visualize a single net or instance. Default: no schematic groups.
view-sub-schematic(main-module.sensors)
; Visualize a single net or instance with schematic groups.
view-sub-schematic(main-module.sensors, true)

Description

The view-sub-schematic command is used to visualize a subset of the schematic of the generated board.

view-sub-schematic

public defn view-sub-schematic (object:JITXObject, schematic-group?:True|False) -> Null

• Returns Null

view-sub-schematic

public defn view-sub-schematic (object:JITXObject) -> Null

• Returns Null

view-sub-schematic

public defn view-sub-schematic (objects:Tuple<JITXObject>) -> Null

• Returns Null

emodel?

Get the emodel of a component or the component of an inst, if it exists.

public defn emodel? (c:Instantiable) -> EModel|False

• Returns EModel|False

Syntax

pcb-module my-module :
  inst U : chip-resistor(1000.0)
  println(emodel?(U))

Description

Looks up the value associated with an emodel = ... statement in a pcb-component.

emodel?

public defn emodel? (obj:JITXObject) -> EModel|False

• Returns EModel|False

transform-component

Applies body on component to return a newly transformed Instantiable.

public defn transform-component (body:() -> ?, module:Instantiable) -> Instantiable

• Returns Instantiable

Example

pcb-component my-component :
  ; ...

val my-modified-component = within transform-component(my-component) :
  inside pcb-component :
    override landpattern = my-new-landpattern
    override symbol = my-new-symbol
    property(self.transformed) = true

This example returns a modified component which has the same name, descriptions, pins, and so on, of the original component, but now has a different landpattern and symbol, and a new property. Note the use of the override keyword to allow setting the landpattern and symbol after they have already been set.

Because override is not yet implemented for many component attributes which can only be set once, such as name, description, mpn, manufacturer, etc., these will only be able to be set if the original component definition did not set them. override is also not yet implemented for symbols (setting multiple symbol units on one component).

transform-component is mainly intended to be used with modify-components.

compare-cad

public defn compare-cad (input-dir:String, output-dir:String, cad:CadSoftware) -> ImportCadResult

• Returns ImportCadResult

set-property

public defn set-property (obj:JITXObject, name:Symbol, value:JITXValue) -> Null

• Returns Null

via-start

Get the start layer of a pcb-via definition.

public defn via-start (obj:JITXDef) -> LayerIndex

• Returns LayerIndex

Syntax

pcb-via th-via :
  type = MechanicalDrill
  start = LayerIndex(0, Top)
  stop = LayerIndex(0, Bottom)
  diameter = 0.6
  hole-diameter = 0.3

println(via-start(th-via))

Description

The via-start introspection function returns the start LayerIndex of a pcb-via definition.

print-def

Print the ESIR definition as ASCII. Not very human readable.

public defn print-def (def:JITXDef)

Use Design Explorer to see this data structured for human consumption.

Syntax

pcb-module my-module :
  ...

print-def(my-module)

print-def will print out the fully expanded definition. JITX definitions include pcb-board, pcb-module, pcb-rules, pcb-stackup, pcb-component, pcb-pad, pcb-landpattern, etc.

set-bom-columns

set-bom-columns(cols: Tuple<BOMColumn>)

public defn set-bom-columns (cols:Tuple<BOMColumn>|False)

set the columns of the bill of materials (BOM).

Syntax

set-bom-columns([
  BOMColumn(BOMFieldStatus, "Status", 10.0)
  BOMColumn(BOMFieldInsts, "References", 10.0)
  BOMColumn(BOMFieldMPN, "MPN", 10.0)
  BOMColumn(BOMFieldDescription, "Description", 20.0)
  BOMColumn(BOMFieldVendor, "Supplier", 10.0)
  BOMColumn(BOMFieldQuantity, "Qty", 5.0)
  BOMColumn(BOMFieldSubtotal, "Total", 5.0)
  BOMColumn(BOMFieldPreferred, "Preferred", 5.0)
])

Description

Set the columns to display in BOM Visualizer and to export. If none is set, JITX default columns are used.

length

Get the length of an instance or bundle array.

public defn length (obj:JITXObject) -> Int

• Returns Int

Syntax

  inst R : gen-res-cmp(1.0e3)[5]
  println(length(R))

Description

Bundles and instances may be created in arrays, the length introspection will return the length of those arrays.

originating-instantiable

Get the inst definition that created an instance.

public defn originating-instantiable (obj:JITXObject) -> Instantiable

• Returns Instantiable

Syntax

  inst i: gen-res-cmp(3.0)
  print-def(originating-instantiable(i))

Description

The originating-instantiable retrieves the Instantiable that was used to create an instance in a module.

pad-shape

Get the shape of a pcb-pad definition.

public defn pad-shape (p:Pad|Self)

Syntax

pcb-pad my-pad :
  shape = Circle(1.0)
  type  = SMD

println(pad-shape(my-pad))

Description

The pad-shape introspection returns the shape of a pad that has been defined using the shape = ... statement.

datasheet?

Get the datasheet name of a component, if it exists.

public defn datasheet? (c:Instantiable) -> String|False

• Returns String|False

Syntax

pcb-module my-module :
  inst U : ocdb/components/abracon/AMB7/component(10.0e6)
  println(datasheet?(U))

Description

Looks up the value associated with an datasheet = ... statement in a pcb-component.

datasheet?

public defn datasheet? (obj:JITXObject) -> String|False

• Returns String|False

dims

Compute the x/y dimensions of a shape.

public defn dims (s:Shape) -> Dims

• Returns Dims

Syntax

val shape = Union([
  Rectangle(10.0, 10.0)
  loc(2.0, 0.0 * Circle(10.0, 10.0)
])

println(dims(shape))

Description

The dims command takes a shape as an argument and computes the x/y dimensions (bounding box) of the complete shape. This is useful for simple collision detection and size computation.

clear-default-rules

This has been deprecated; JITX now includes a default rule set.

public defn clear-default-rules ()

Syntax

  clear-default-rules()

Description

Removes default rules if they are set. This is primarily used for testing.

run-checks

Runs all checks statements, saves results in a file named filename, and returns a CheckSummary.

public defn run-checks (filename:String) -> CheckSummary

• Returns CheckSummary

Syntax

pcb-check check-5V (a:JITXObject) :
  #CHECK(has-property?(a.voltage))
  #CHECK(property(a.voltage) is Double)
  #CHECK(property(a.voltage) == 5.0)

pcb-module mymodule :
  pin x
  property(x.voltage) = 5.0
  check check-5V(self)

set-main-module(mymodule)
run-checks("5V-check.txt")

Description

The run-checks command is used to run pcb-checks on a design. Checks are arbitrary DRC, ERC, or other static analyses defined in code to validate a design programmatically.

transform-module

Applies body on module to return a newly transformed Instantiable. This is how to run custom passes on your design module.

public defn transform-module (body:() -> ?, module:Instantiable) -> Instantiable

• Returns Instantiable

Syntax

pcb-module main-module :
  ; ...

defn generate-power () :
  inside pcb-module :
    ; ...

val module-with-power = transform-module(generate-power, main-module)

Description

The transform-module function takes two arguments, a function body and pcb-module module. The compiler will apply body to the module

containing-instance

Get the instance that an object is contained within, if it exists.

public defn containing-instance (obj:JITXObject) -> Instance|False

• Returns Instance|False

Syntax

pcb-module sub-module :
  public inst R : gen-res-cmp(1.0e3)

pcb-module parent-module :
  inst i: sub-module

  println(ref(containing-instance(i.R)))

Description

The containing-instance introspection retrieves the instance that owns another instance. This is useful for generators and checks that might not have access to the original identifier of a given instance.

current-rules?

Get the current design rules.

public defn current-rules? () -> Rules|False

• Returns Rules|False

This has been deprecated; use current-rules() instead.

Syntax

val no-rules = current-rules?()
println(no-rules) ; false
set-rules(ocdb/utils/defaults/default-rules)
val rules = current-rules?()
println(rules) ; Rules

Description

Like current-rules, current-rules? returns the design rules of the project if they have been set, but does not crash if they are not available and returns false otherwise.