Willkommen bei Bartels
Layout Index-Beschreibung (LAY) - Deutsche Version Layout Index Description (LAY) - English Version
Bartels

Bartels System GmbH
[13.07.2017 13:03:54 [UTC]] Willkommen bei Bartels / AktualisiertBartels
Bartels AutoEngineer
BAE Produktinfo
BAE Preisliste
BAE Downloads
BAE Dokumentation
BAE Installationsanleitung
BAE Benutzerhandbuch
BAE Bibliotheken
User Language Programmierhandbuch
Vorwort
1 Einleitung
2 Sprachbeschreibung
3 Programmiersystem
4 BAE User Language-Programme
A Konventionen und Definitionen
B Index-Variablen-Typen
B.1 Index-Übersicht
B.2 Standard Index-Beschreibung (STD)
B.3 Schematic Capture Index-Beschreibung (CAP)
B.4 Layout Index-Beschreibung (LAY)
B.5 CAM-View Index-Beschreibung (CV)
B.6 IC Design Index-Beschreibung (ICD)
C Systemfunktionen
BAE Update-Historie
BAE Nächste Version Freigabemitteilungen Vorabinfo
BAE V8.0 Freigabemitteilungen
BAE V7.8 Freigabemitteilungen
BAE V7.6 Freigabemitteilungen
BAE V7.4 Freigabemitteilungen
BAE V7.2 Freigabemitteilungen
BAE V7.0 Freigabemitteilungen
BAE V6.8 Freigabemitteilungen
BAE V6.6 Freigabemitteilungen
BAE V6.4 Freigabemitteilungen
BAE V6.2 Freigabemitteilungen
BAE V6.0 Freigabemitteilungen
BAE V5.4 Freigabemitteilungen
BAE V5.0 Freigabemitteilungen
BAE V4.6 Freigabemitteilungen
BAE V4.4 Freigabemitteilungen
BAE V4.2 Freigabemitteilungen
BAE V4.0 Freigabemitteilungen
BAE V3.4 Freigabemitteilungen
BAE Support
BAE Contrib
BAE Entwickler und Dienstleister
Elektronikentwicklung
Sport
Firmenprofil
Impressum
Bartels :: Bartels AutoEngineer :: BAE Dokumentation :: User Language Programmierhandbuch :: Index-Variablen-Typen :: Layout Index-Beschreibung (LAY)
Bartels User Language - Programmierhandbuch

B.4 Layout Index-Beschreibung (LAY)

Bartels AutoEngineer® Dokumentation

Dieser Abschnitt beschreibt die in der Bartels User Language definierten Index-Variablen-Typen für den Layout Datenzugriff (LAY).


L_ALTPLNAME - Layoutnetzlisteneintrag Alternativbauform

Über den Index L_ALTPLNAME ist der Zugriff auf die in der Netzliste des aktuell geladenen Layouts eingetragenen Alternativbauformen möglich. Die Strukturdefinition von L_ALTPLNAME lautet:

index L_ALTPLNAME {           // Alternativbauform Index
      string PLNAME;          // Alternativbauform Name
      };

L_ATTRIBUTE - Layoutnetzlisteneintrag Attribut

Über den Index L_ATTRIBUTE ist der Zugriff auf die in der Netzliste des aktuell geladenen Layouts eingetragenen Bauteil- bzw. Netzattribute möglich. Die Strukturdefinition von L_ATTRIBUTE lautet:

index L_ATTRIBUTE {           // Attribut Index
      string NAME;            // Attribut Name
      string VALUE;           // Attribut Wert
      };

L_CNET - Layoutnetzliste

Über den Index L_CNET ist der Zugriff auf die in der Netzliste des aktuell geladenen Layouts eingetragenen Netze möglich. Die Strukturdefinition von L_CNET lautet:

index L_CNET {                // Layoutnetzliste
      string NAME;            // Netz Name
      int NUMBER;             // Netz Nummer
      int PRIOR;              // Netz Routingpriorität
      double RDIST;           // Netz Mindestabstand (STD2)
      int VIS;                // Netz Sichtbarkeitsflag
      int PINN;               // Anzahl Pins
      index L_CPIN;           // Liste der Pins
      index L_ATTRIBUTE;      // Liste der Attribute
      index L_POOL UNRPOOL;   // Verweis auf Unroutes Poolelement
      };

Die Netznummer wird allgemein zur Identifizierung eines Netzes herangezogen. Mit der Funktion lay_gettreeidx kann ausgehend von der angegebenen Netznummer der entsprechende L_CNET Index gefunden werden. Der Mindestabstand gibt die Distanz an, die Leiterbahnen dieses Netzes zu nicht dem entsprechenden Netz zugehörenden Kupferstrukturen mindestens einhalten müssen. Der Zugriff auf die zum Netz gehörenden Pins bzw. Attribute erfolgt über eine entsprechende forall-of-Schleife. Die Indexvariable UNRPOOL ermöglicht den Zugriff auf die noch nicht verlegten Verbindungen (Unroutes, Airlines) des entsprechenden Netzes; die Abarbeitung dieser Verbindungen kann mit Hilfe der Funktion lay_scanpool erfolgen.


L_CPART - Layoutnetzlisteneintrag Bauteil

Über den Index L_CPART ist der Zugriff auf die in der Netzliste des aktuell geladenen Layouts eingetragenen Bauteile möglich. Die Strukturdefinition von L_CPART lautet:

index L_CPART {               // Netzliste Bauteilindex
      string NAME;            // Bauteil Name
      string PLNAME;          // Physikalisches Bibliotheksteil
      int USED;               // Bauteilplatzierungscode:
                              //    0 = Bauteil nicht platziert
                              //    1 = Bauteil platziert
                              //    2 = Bauteil platziert und zur Gruppe selektiert
      int PEQUC;              // Bauteil Äquivalenz-Code
      int PINN;               // Anzahl Pins
      int FPINN;              // Anzahl nicht angeschlossene Pins
      index L_MACRO MACRO;    // Verweis auf Makro
      index L_CPIN;           // Liste der Pins
      index L_ALTPLNAME;      // Liste der Alternativbauformen
      index L_ATTRIBUTE;      // Liste der Attribute
      };

Auf die Pinliste, die Alternativbauformen und die Attributwerte kann mit Hilfe von entsprechenden forall-of Schleifen zugegriffen werden. Bauteile mit identischen Äquivalenz-Codes dürfen auf ihren Einbauplätzen im Zuge einer Platzierungsoptimierung vertauscht werden (Component Swap).


L_CPIN - Layoutnetzlisteneintrag Bauteilpin

Über den Index L_CPIN ist der Zugriff auf die in der Netzliste des aktuell geladenen Layouts eingetragenen Bauteilpins möglich. Die Strukturdefinition von L_CPIN lautet:

index L_CPIN {                // Netzliste Pin Index
      string NAME;            // Pin Name
      double RWIDTH;          // Pin Routingbreite (STD2)
      int TREE;               // Pin Netznummer
      int GATE;               // Pin Gatternummer
      int GEQUC;              // Pin Gatter-Äquivalenz-Code
      int GEQUP;              // Pin Äquivalenz-Code
      int GGRPC;              // Pin Gatter-Gruppennummer
      int GPNUM;              // Pin Gatter-Relativnummer
      index L_CNET CNET;      // Verweis auf Netz
      index L_CPART CPART;    // Verweis auf Bauteil
      };

Die Pin Routingbreite gibt die Breite an, mit der von dem Pin zum nächsten Verbindungspunkt geroutet werden soll. Über die Indexvariablen CNET bzw. CPART ist der Rückwärtsverweis auf das Netz bzw. das Bauteil, an dem der Pin definiert ist, möglich. Über die Indexvariablen GATE, GEQUC, GEQUP, GGRPC und GPNUM kann die Zulässigkeit der Gatter- und Pinvertauschbarkeit (Pin/Gate Swap) ermittelt werden.


L_DRCERROR - Layout DRC-Fehlermarker

Über den Index L_DRCERROR ist der Zugriff auf die vom Design Rule Check angezeigten Fehlermarker des aktuell geladenen Layoutelements möglich. Die Strukturdefinition von L_DRCERROR lautet:

index L_DRCERROR {            // DRC-Fehlermarker Index
      int TYP;                // DRC-Fehlertyp:
                              //    1 = Kupferabstandsverletzung
                              //    2 = Dokumentarlagen-Sperrflächenverletzung
                              //    3 = Dokumentarlagen-Höhensperrflächenverletzung
                              //    4 = HF-Designregelverletzung
                              //    5 = Polygonablage-Designregelverletzung
      int LAYER;              // DRC-Fehlermarker Lage (LAY1)
      double RLX;             // DRC-Fehlermarker linke Begrenzung (STD2)
      double RLY;             // DRC-Fehlermarker untere Begrenzung (STD2)
      double RUX;             // DRC-Fehlermarker rechte Begrenzung (STD2)
      double RUY;             // DRC-Fehlermarker obere Begrenzung (STD2)
      double CHKDIST;         // DRC-Fehlermarker DRC-Mindestabstandsvorgabe (STD2)
      double ERRDIST;         // DRC-Fehlermarker tatsächlicher Elementabstand (STD2)
      string IDSTR;           // DRC-Fehler-Id-String
      index L_FIGURE FIG1;    // DRC-Fehlerelement 1
      index L_FIGURE FIG2;    // DRC-Fehlerelement 2
      };

L_DRCERROROK - Layout DRC-Fehlerakzeptierung

Über den Index L_DRCERROROK ist der Zugriff auf die DRC-Fehlerakzeptanzeinstellungen des aktuell geladenen Layoutelements möglich. Die Strukturdefinition von L_DRCERROROK lautet:

index L_DRCERROROK {          // Layout DRC-Fehlerakzeptierung Index
      string IDSTR;           // DRC-Fehler-Id-String
      };

L_DRILL - Layout Bohrung

Über den Index L_DRILL ist der Zugriff auf die Bohrdaten des aktuell geladenen Padstack-Bibliothekselements möglich. Die Strukturdefinition von L_DRILL lautet:

index L_DRILL {               // Bohrung Index
      double X;               // Bohrung X-Koordinate (STD2)
      double Y;               // Bohrung Y-Koordinate (STD2)
      double RAD;             // Bohrung Radius (STD2)
      int CLASS;              // Bohrung Klasse (LAY5)
      };

Bei der Verwendung des Index L_DRILL in der Drillscanfunktion von lay_scanfelem, lay_scanall bzw. lay_scanpool ist zu beachten, dass in dem Index die Platzierungsdaten der Bohrung auf dem Padstack eingetragen sind. Die Koordinaten auf dem Layout bzw. Bauteil werden durch die übergebenen transformierten Koordinaten angegeben.


L_FIGURE - Layout Figurenelement

Über den Index L_FIGURE ist der Zugriff auf die platzierten Figurenelemente (Polygone, Leiterbahnen, Makroreferenzen, Texte, Bohrungen) des aktuell geladenen Elements möglich. Die Strukturdefinition von L_FIGURE lautet:

index L_FIGURE {              // Figurenelement Index
      int TYP;                // Element Typ (LAY6)
      string NAME;            // Element Name
      double SIZE;            // Element Größe (STD2)
      double X;               // Element X-Koordinate (STD2)
      double Y;               // Element Y-Koordinate (STD2)
      double ANGLE;           // Element Drehwinkel (STD3)
      int MIRROR;             // Element Spiegelung (STD14)
      int LAYER;              // Element Lage/Klasse (LAY1 | LAY5)
      int GROUP;              // Element Gruppenflag (STD13)
      int FIXED;              // Element Fixiert Flag (STD11 | STD12)
      int TREE;               // Element Netznummer
      index L_POOL POOL;      // Verweis auf Poolelement
      index L_POLY POLY;      // Verweis auf Polygonelement
      index L_LINE LINE;      // Verweis auf Leiterbahnelement
      index L_NREF NREF;      // Verweis auf Makroreferenz (benannt)
      index L_UREF UREF;      // Verweis auf Makroreferenz (unbenannt)
      index L_TEXT TEXT;      // Verweis auf Textelement
      index L_DRILL DRILL;    // Verweis auf Bohrelement
      };

Die Indexvariable NAME gibt für benannte Makroreferenzen den Namen und für Texte den Textstring an. Bei Elementen mit TYP 7 (intern) gibt NAME den Namen des Padstackmakros zurück, falls es sich bei dem internen Element um eine Standardviadefinition handelt. Die Indexvariable LAYER gibt die Lagennummer des Figurenelements bzw. bei Bohrungen die Bohrklasse an. Die Indexvariable POOL ermöglicht den Zugriff auf das Bibliotheks- bzw. Poolelement, aus dem das Figurenelement aufgebaut ist. Einzelne Daten eines Figurenelements können mit den Funktionen ged_elem*chg modifiziert werden. Der komplette Datensatz eines Figurenelements kann mit der Funktion lay_scanfelem über alle Hierarchieebenen abgearbeitet werden.


L_LEVEL - Layout Signalpotential

Über den Index L_LEVEL ist der Zugriff auf die Connectivity-Level, d.h. auf die Netzlisten- bzw. Signalpotentiale des aktuell geladenen Layouts möglich. Die Strukturdefinition von L_LEVEL lautet:

index L_LEVEL {               // Connectivity-Level Index
      int LEVVAL;             // Level Wert (LAY7)
      };

L_LINE - Layout Leiterbahn

Über den Index L_LINE ist der Zugriff auf die Leiterbahndaten des aktuell geladenen Layouts bzw. Bauteils möglich. Die Strukturdefinition von L_LINE lautet:

index L_LINE {                // Leiterbahn Index
      double WIDTH;           // Leiterbahn Breite (STD2)
      int LAYER;              // Leiterbahn Lage (LAY1)
      int TREE;               // Leiterbahn Netznummer
      int PN;                 // Anzahl Polygonpunkte
      index L_POINT;          // Liste der Polygonpunkte
      };


L_MACRO - Layout Bibliothekselement

Über den Index L_MACRO ist der Zugriff auf die Makros, d.h. auf die Bibliothekselemente (Bauteile, Padstacks, Pads) des aktuell geladenen Elements möglich. Die Strukturdefinition von L_MACRO lautet:

index L_MACRO {               // Makrodefinition Index
      string NAME;            // Makro Name
      double MLX;             // Linke Makrobegrenzung (STD2)
      double MLY;             // Untere Makrobegrenzung (STD2)
      double MUX;             // Rechte Makrobegrenzung (STD2)
      double MUY;             // Obere Makrobegrenzung (STD2)
      double MNX;             // Nullpunkt X-Koordinate (STD2)
      double MNY;             // Nullpunkt Y-Koordinate (STD2)
      int CLASS;              // Makro Klasse (STD1)
      int COMP;               // Makro Status (STD16)
      };

L_NREF - Layout Makroreferenz (benannt)

Über den Index L_NREF ist der Zugriff auf die benannten Makroreferenzen, d.h. auf die auf dem aktuell geladenen Element namentlich platzierten Bibliothekselemente möglich. Auf Layoutebene sind dies die platzierten Bauteile; auf Bauteilebene sind dies die platzierten Pins. Die Strukturdefinition von L_NREF lautet:

index L_NREF {                // Benannte Referenz Index
      string NAME;            // Referenz Name
      double X;               // Referenz X-Koordinate (STD2)
      double Y;               // Referenz Y-Koordinate (STD2)
      double ANGLE;           // Referenz Drehwinkel (STD3)
      int LAYOFF;             // Referenz Lagenoffset (LAY1)
      int MIRROR;             // Referenz Spiegelung (STD14)
      index L_MACRO MACRO;    // Makro Index
      };

Über die Indexvariable MACRO ist der Zugriff auf das durch das L_NREF-Element referenzierte Bibliothekselement möglich.


L_POINT - Layout Polygonpunkt

Über den Index L_POINT ist der Zugriff auf einzelne Polygonpunkte eines Polygons möglich. Die Strukturdefinition von L_POINT lautet:

index L_POINT {               // Polygonpunkt Index
      double X;               // Polygonpunkt X-Koordinate (STD2)
      double Y;               // Polygonpunkt Y-Koordinate (STD2)
      int TYP;                // Polygonpunkt Typ (STD15)
      };

Der Index L_POINT ist nur als of-Index für die Liste der Polygonpunkte in L_POLY bzw. in L_LINE zu verwenden.


L_POLY - Layout Polygon

Über den Index L_POLY ist der Zugriff auf die im aktuell geladenen Element definierten Polygone (Kupferflächen, Sperrflächen, Umrandung, Potentialflächen, Dokumentarlinien, Dokumentarflächen, Füllbereiche, Schraffurflächen oder Split-Powerplane-Flächen) möglich. Die Strukturdefinition von L_POLY lautet:

index L_POLY {                // Polygon Index
      int LAYER;              // Polygon Lage (LAY1)
      int TREE;               // Polygon Netznummer
      int TYP;                // Polygon Typ (LAY4)
      int MVIS;               // Polygon Spiegelungsmodus (LAY3) bzw:
                              //   LAY3 + 4 = gestricheltes Polygon
                              //   LAY3 + 8 = gepunktetes Polygon
      double WIDTH;           // Polygon Linienbreite (STD2)
      double DASHLEN;         // Polygon Strichelungslänge (STD2)
      double DASHSPC;         // Polygon Strichelungsrelativabstand
      int PN;                 // Anzahl Polygonpunkte
      index L_POINT;          // Liste der Polygonpunkte
      };

Der Zugriff auf die zum Polygon gehörenden Polygonpunkte erfolgt über eine entsprechende forall-of-Schleife. Die Netznummer ist nur für Potentialflächen, Füllbereiche, Schraffurflächen und Split-Powerplane-Flächen von Bedeutung. Zur Bestimmung der Netzzugehörigkeit passiver Kupferflächen sind die Funktionen lay_scanfelem bzw. lay_scanall zu verwenden.


L_POOL - Layout Poolelement

Über den Index L_POOL ist der Zugriff auf die aktuell geladenen Poolelemente möglich. Die Strukturdefinition von L_POOL lautet:

index L_POOL {                // Poolelement Index
      int TYP;                // Poolelement Typ (LAY8)
      int REFCNT;             // Poolelement Referenzierungsanzahl
      int LAYER;              // Poolelement Lage (LAY1)
      index L_POOL NXT;       // Verweis auf nächstes Poolelement
      index L_POOL REF;       // Verweis auf Referenz-Poolelement
      index L_POLY POLY;      // Verweis auf Polygonelement
      index L_LINE LINE;      // Verweis auf Leiterbahnelement
      index L_NREF NREF;      // Verweis auf Makroreferenz (benannt)
      index L_UREF UREF;      // Verweis auf Makroreferenz (unbenannt)
      index L_TEXT TEXT;      // Verweis auf Textelement
      index L_DRILL DRILL;    // Verweis auf Bohrelement
      index L_DRCERROR DRCERR;// Verweis auf DRC-Fehlerelement
      index L_MACRO MACRO;    // Verweis auf Bibliothekselement
      };

Der Index L_POOL wird zur Abarbeitung von Bibliotheksdefinitionen mit Hilfe der Systemfunktion lay_scanpool benötigt. Die Indexvariable REFCNT gibt an, wie oft das entsprechende Poolelement innerhalb des aktuell geladenen Elements referenziert wird. Die Indexvariablen NXT und REF dienen der schnellen Abarbeitung der aktuell referenzierten Poolelemente.


L_POWLAYER - Layout Versorgungslage

Über den Index L_POWLAYER ist der Zugriff auf die Definition der Versorgungslagen des aktuell geladenen Layouts möglich. Die Strukturdefinition von L_POWLAYER lautet:

index L_POWLAYER {            // Versorgungslage Index
      index L_CNET CNET;      // Verweis auf Netz
      index L_LEVEL LEVEL;    // Verweis auf Level
      int LAYER;              // Versorgungslagencode (LAY1)
      };

Die Indexvariable CNET ermöglicht den Zugriff auf das Netz, für welches die Versorgungslage definiert ist. Mit Hilfe der Indexvariablen LEVEL kann das Signalpotential der betreffenden Versorgungslage ermittelt werden.


L_TEXT - Layout Text

Über den Index L_TEXT ist der Zugriff auf die im aktuell geladenen Element definierten Texte möglich. Die Strukturdefinition von L_TEXT lautet:

index L_TEXT {                // Text Index
      string STR;             // Text String
      double X;               // Text X-Koordinate (STD2)
      double Y;               // Text Y-Koordinate (STD2)
      double ANGLE;           // Text Drehwinkel (STD3)
      double SIZE;            // Text Größe (STD2)
      double WIDTH;           // Text Linienbreite (STD2)
      int LAYER;              // Text Lage (LAY1)
      int MIRROR;             // Text Spiegelung (STD14)
      int MODE;               // Text Modus (LAY2)
      };

L_UREF - Layout Makroreferenz (unbenannt)

Über den Index L_UREF ist der Zugriff auf die unbenannten Makroreferenzen, d.h. auf die auf dem aktuell geladenen Element namenlos platzierten Bibliothekselemente möglich. Auf Layout- bzw. Bauteilebene sind dies die platzierten Vias; auf Padstackebene sind dies die platzierten Pads. Die Strukturdefinition von L_UREF lautet:

index L_UREF {                // Namenlose Referenz Index
      int TREE;               // Referenz Netznummer
      double X;               // Referenz X-Koordinate (STD2)
      double Y;               // Referenz Y-Koordinate (STD2)
      double ANGLE;           // Referenz Drehwinkel (STD3)
      int LAYOFF;             // Referenz Lagenoffset (LAY1)
      int MIRROR;             // Referenz Spiegelung (STD14)
      index L_MACRO MACRO;    // Verweis auf Makro
      };

Über die Indexvariable MACRO ist der Zugriff auf das durch das L_UREF-Element referenzierte Bibliothekselement möglich. Die Indexvariable LAYOFF ist nur für die Referenzierung von Pads auf Padstacks von Bedeutung.

Bartels :: Bartels AutoEngineer :: BAE Dokumentation :: User Language Programmierhandbuch :: Index-Variablen-Typen :: Layout Index-Beschreibung (LAY)

Layout Index-Beschreibung (LAY)
© 1985-2017 Oliver Bartels F+E • Aktualisiert: 02. October 2010, 21:54 [UTC]

© 1985-2017 Oliver Bartels F+E Bartels Startseite Kontakt und Impressum

Webentwicklung Baumeister Mediasoft Engineering

Layout Index-Beschreibung (LAY) - Deutsche Version Layout Index Description (LAY) - English Version