Basic types & Connections¶
There's a handful of major types that you'll use in your
.ato files, falling into two categories: blocks and nodes.
Blocks represent something that can contain other things. They provide an abstraction over their contents. For example, a block could be a power supply chip and all the passive components around it.
Nodes are elements you can connect to.
Block types are:
component - represents exactly one component
module - a collection of components and other modules
interface - walks the line between a block and a node. It's a connectable block that lets you connect multiple nodes at a time
Node types are:
pin - represents a physical pin/pad on a package
signal - represents a logical signal that can be connected to other signals
Here is an example of a block (in this case, a
component) created within a file named
Footprints for resistors and capacitors¶
For convenience, the footprints for resistors and caps can be defined like so
Here is an example of a
module definition, in this case a resistor divider:
A module can contain an arbitrary amount of components, modules, signals, and interface instances.
Here is an example of an
interface definition; in this case, a CAN interface
An interface can contain an arbitrary amount of signals.
Interfaces can be connected together with the
~ operator like so:
Two interfaces can be connected as long as they contain the same signals.
Signals can be useful as they allow you to name a connection point used throughout your design. Here is an example with a ground signal:
Signals can be connected in the following way:
Pins can be defined in a similar way to signals. Pins are used specifically within components to tie your signals back to your footprints. The pin should have the same name as the copper pads in your footprint.
We usually recommend creating a signal within your component and tying it to your pin. That gives you a meaningful signal to connect to instead of an ephemeral pin. For example: