Skip to content
master
Switch branches/tags
Code

Latest commit

 

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
 
 
doc
 
 
 
 
 
 
 
 
src
 
 
 
 
 
 
 
 
 
 

SYSTEM ET

An ECAD-Tool for complex schematics and layouts

The Idea behind

  • Most ECAD tools do not allow opening, checking and editing of multiple designs simultaneously.
  • We need real hierarchic and modular designs.
  • We need a text based, machine and human readable format for design files.
  • Design checks provided by common ECAD tools are way too superficial and trivial.
  • Style guides must be checked against.
  • The tool must be highly scripting capable.
  • We want to do agile hardware develpment which requires the features mentioned above.
  • The tool must be open sourced.
  • Currently the GUI is under construction.
  • Your feedback and collaboration is highly welcome !

Outstanding Features

  • native Linux support
  • ASCII / text based design and device model files - optimized for version control with GIT
  • human readable and editable design and model files
  • multi-schematic/board/layout support
  • true hierarchic and modular design with interfaces at the module boundaries
  • submodules instantiated in parent module by reference
  • extensive design rule checking (device prefixes, purpose of user-interactive devices, partcodes, pinout of board-to-board connections ...)
  • interfacing with system modelling tools

Examples of design and component models

Supported CAE formats

  • KiCad V4, V5 (import only)
  • Planned is to support also EAGLE (import only)
  • An ET native format as shown above.

Usage

For everything ET does you will find in the current working directory a folder named "ET/reports" for log messages.

Importing a KiCad project

To import a single KiCad V5 design into a native project 'my_et_project' run this command:

$ et --import-format kicad_v5 --import-project my_kicad_project/

Optionally provide a log level for debugging:

$ et --import-format kicad_v5 --import-project my_kicad_project/ --log-level 2

ET creates in the current working directory a folder named "ET/et_import" where you find the now native project. Inside the project you will find a directory named 'libraries' where the imported component libraries associated with the project live. There is also an import report where log messages can be found. See "ET/reports". Depending on the log level this report contains more or less debug information.

NOTE: Currently all kinds of text styles (normal, italic, bold) are ignored and replaced by ET internal hard coded fonts.

Creating a conventions file

The conventions file is the place where file where prefixes, units of measurement and other things are defined. It is not mandatory. This step can be omitted. If so, lots of design checks wil not be performed. Change into the root directory of your projects and generate a conventions file with this command:

$ et --make-conventions conventions.txt

This file can now be found in the root directory of your projects. Edit it according to your customs. Assign the conventions file to the module by editing the rig configuration file.

An example file can be seen here https://github.com/Blunk-electronic/ET_training/blob/master/conventions.txt

Creating an ET native project

To create a new project like 'my_new_et_project' run this command. CAUTION: An already existing project of the same name will be deleted without warning !

$ et --create-project my_new_et_project/

NOTE: The project to be created must be a child directory of the current working directory. Creating a project across several directory levels like ecad/my_et_project/ is not possible.

Opening an ET native project

To open a native project like 'my_et_project' run this command:

$ et --open-project my_et_project/

Optionally the file name of the generic module to be opened can be added:

$ et --open-project my_et_project/ --module my_et_project/power_supply.mod

or just

$ et --open-project my_et_project/ --module power_supply.mod

The module file must exist in the project directory.

further-on a sheet can be specified so that the desired sheet gets opened right away:

$ et --open-project my_et_project/ --module power_supply.mod --sheet 3

NOTE: The project to be opened must be a child directory of the current working directory. Opening a project across several directory levels like ecad/my_et_project/ is not possible.

A log level can also be passed:

$ et --open-project my_et_project/ --log-level 2

Opening a project includes syntax checking. See the report for details.

Creating an ET native package (or footprint)

Packages can be real or virtual. Virtual components are things like testpoints or edge connectors. By default a real package will be created. The newly created package should be saved right away. To create a native package drawing like 'S_0805.pac' run this command:

$ et --create-package --package-appearance real --save-package-as tmp/dummy_S_0805.pac
$ et --create-package --package-appearance virtual --save-package-as tmp/dummy_connector.pac

Since the appearance has a default, it can be omitted:

$ et --create-package --save-package-as tmp/dummy_S_0805.pac

Opening an ET native package (or footprint)

To open a native package drawing like 'S_0805.pac' run this command:

$ et --open-package libraries/packages/S_0805.pac

The package can also be saved under a different name at a different place:

$ et --open-package libraries/packages/S_0805.pac --save-package-as tmp/dummy_S_0805.pac

Opening a package includes syntax checking. See the report for details.

Creating an ET native symbol

A symbol is an abstraction of a component in the schematic. Symbols can represent a virtual component such as a GND-symbol or something real like a resistor that is mounted on the PCB. By default a pcb-type symbol will be created. The newly created symbol should be saved right away. To create a native symbol like 'opamp.sym' run this command:

$ et --create-symbol --symbol-appearance pcb --save-symbol-as tmp/dummy_opamp.sym
$ et --create-symbol --symbol-appearance virtual --save-symbol-as tmp/gnd.sym

Since the appearance has a default, it can be omitted:

$ et --create-symbol --save-symbol-as tmp/dummy_opamp.sym

Opening an ET native symbol

To open a native symbol drawing like 'opamp.sym' run this command:

$ et --open-symbol libraries/symbols/opamp.sym

The symbol can also be saved under a different name at a different place:

$ et --open-symbol libraries/symbols/opamp.sym --save-symbol-as tmp/dummy_opamp.sym

Opening a symbol includes syntax checking. See the report for details.

Creating an ET native device

A device is the compound of symbol(s) and package(s).

$ et --create-device --device-appearance pcb --save-device-as tmp/TL084D.dev
$ et --create-device --device-appearance virtual --save-device-as tmp/gnd.dev

Since the appearance has a default, it can be omitted:

$ et --create-device --device-appearance pcb --save-device-as tmp/TL084D.dev

Creating drawing frame templates

There is a distiction between drawing frames for schematic and PCB.

To create or open a schematic frame:

$ et --create-schematic-frame tmp/frames/A4_landscape.frs
$ et --open-schematic-frame lib/frames/schematic/A4_landscape.frs --save-schematic-frame-as tmp/frames/A4_landscape.frs

Similar a board frame can be created or opened:

$ et --create-pcb-frame tmp/frames/A4_landscape.frb
$ et --open-pcb-frame lib/frames/pcb/A4_landscape.frb --save-pcb-frame-as tmp/frames/A4_landscape.frb

Runmode

By default ET launches a GUI (which is currently under construction). For automated processing the GUI is not required. A command line switch for the runmode can be used. This example launches ET in headless mode, which means without any graphical user interface:

$ et --open-project my_project --runmode headless

Depending on the specified runmode, ET launches a dedicated GUI. The next example starts the module edtior, which is default. In this mode you can edit the schematic and layout of a module:

$ et --open-project my_project --runmode module

Other runmodes currently under construction are:

  • rig
  • symbol
  • package
  • device

Executing scripts

ET has an internal script processor that reads and executes a script file. The scripting feature allows manipulating designs without GUI:

$ et --open-project my_et_project/ --script my_et_project/my_script.scr --save-project-as modified_project --log-level 2

Find the script processor command set here.

Installation

  • Currently there is no proper install script.

  • Install the following packages:

    • the GNAT Ada compiler (version 9 or later). It should come along with major linux distros.
    • make
    • gprbuild
    • gtkada
  • Find a installation howto for gtkada and gprbuild here https://github.com/Blunk-electronic/ada_training

  • Change into src/et and follow the instructions in readme.txt.

Why Ada ??

  • The only programming language that provides a robust and strong typing system is Ada.
  • Objects and structures within a schematic, library and board layout are very very complex things and require sound modelling.
  • If saftey/mission critical and military applications use Ada, then is must be good for an advanced ECAD system as well.
  • Ada is defined by ISO/IEC 8652:2012 and MIL-STD-1815
  • Ada is beautiful :-)

Roadmap, things to do and issues

  • zero-Ohms resistors
  • accessories of components (screws, washers, clamps, ...)
  • import EAGLE and KiCad V6 projects and libraries
  • web browser support so that ET can be operated on every operating system

Collaboration

  • We need a nice web site for the project.
  • You are highly welcome !

About

An ECAD design tool for complex schematics and layouts

Resources

License

Packages

No packages published

Languages