topicchi/SyncHome
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ef805b494ad2ed0ddcb287c34b7a53ef96fa3ba0
SyncHome/trunk/ulp/ltspice.ulp

4604 lines
191 KiB
Plaintext
Raw Normal View History

2023-03-09 10:24:21 +00:00
#usage "en:<b>Interface to the simulation software LTspice IV </b><br>"
"Export of EAGLE schematics and libraries into LTspice and import of schematics and symbols from LTspice<p>"
"RUN ltspice /E [/S][/G]<br>"
"RUN ltspice /I [/S][/G]<br>"
"RUN ltspice /?<br>"
" /E == Export<br>"
" /I == Import<br>"
" /? == System info<br>"
"Option /S opens the SETUP menu for default settings.<br>"
"Option /G exports a group previously created in the schematic with the GROUP command.<br>"
"RUN ltspice /I 'importfilename' [RELOAD]<p>"
"Start this ULP with the option /E from a Deviceset (Library), in order to export the current Deviceset. "
"Use the ULP without an option in order to export the whole library.<br>"
"For the import you can choose the option <i>Import all symbols from directory</i> in the dialog. Select a symbol file then, "
"and all symbols from the current directory will be imported into an EAGLE library."
"<p>"
"The option RELOAD is planned to check a schematic for modifications. "
"This option is not implemented yet! 2012-09<br>"
"<hr>"
"<b>SpiceOrder</b><br>"
"The so-called SpiceOrder will be defined in layer 99 'SpiceOrder' as a text. "
"It has to be placed exactly at the connection point (coordinate) of the pin. "
"While exporting an EAGLE schematic the ULP checks for SpiceOrder and SpiceModel. "
"If SpiceOrder is not defined, EAGLE loads the Deviceset and starts spiceorder.ulp.<br>"
"This ULP helps to assign pins of the symbol and its Spiceorder. This assignment will be written "
"as a text at the pin connection point in layer 99 automatically."
"<p>"
"<b>SpiceModel</b><br>"
"SpiceModel is the simulation model. It will be attached with the help of the attribute "
"<i>SPICEMODEL</i> in the device. Therefore the LTC icon in the device editor contains the entry <i>SpiceModel</i>."
"<p>"
"<b>Value2</b><br>"
"For some components you have to assign the additional <i>Value2</i>. It has to be created with an attribute, "
"as well. There is a further entry in the LTC icon's menu for this."
"<p>"
"For an error-free schematic import we need correctly and clearly defined libraries. "
"The library <b>lt-spice-simulation.lbr</b> has a special status:<br>"
"It should not appear in the list of USEd libraries. Otherwise the ADD dialog will open "
"for placing resistors while the import script is running.<br>"
"The simulation resistors \"Rload\" are treated like normal resistors in LTSpice. "
"Just the device name gets the extension \"_RLOAD\". "
"<p>"
"<b>lt-spice-simulation.lbr</b> contains only devices that are used for the simulation, like "
"power supply, voltage generator, loads, measurement equipment and so on.). "
"All those devices have an attribute with the name \"_EXTERNAL_\". So you don't have to "
"assign a package; such components are not transferred into the board and do not "
"appear in the bill of materials.<br>"
"<p>"
"A FLAG comming from LTspice results in EAGLE in a simple LABEL that is placed on the net line (FLAG 1248 176 BI_Port).<br>"
"There is no rotation given for FLAGs. The rotation has to be determined with the help of the orientation of the referring line! "
"It can happen that a FLAG is placed onto a pin directly. It's not possible to determine the rotation then. "
"In such a case you have to take care on this matter manually!<br>"
"<p>"
"An IOPIN is reflected as a cross-reference label in EAGLE. (IOPIN 1248 176 BiDir)<br>"
"There is no equivalent for IOPIN in EAGLE, so we use a cross-reference (XREF) label for BI_Port, In and Out."
"<p>"
"Supply symbols (FLAGs) like 0 or COM, are taken from <i>lt-supply.lbr</i> directly.<br>"
"If you have to use other supply symbols (not 0 and COM), you have to create them in LTspice as *.asy files "
"containing the spice symbols.<br>"
"Example:<br>"
"Version 4<br>"
"SymbolType CELL<br>"
"LINE Normal 0 11 0 16<br>"
"LINE Normal -11 14 0 0<br>"
"LINE Normal 0 0 11 14<br>"
"LINE Normal 0 11 -11 14<br>"
"LINE Normal 11 14 0 11<br>"
"TEXT 0 -4 Bottom 2 +3.3V<br>"
"SYMATTR Prefix X<br>"
"SYMATTR SpiceModel node.sub<br>"
"SYMATTR Value node<br>"
"SYMATTR Value2 node<br>"
"PIN 0 16 NONE 36<br>"
"PINATTR PinName +3.3V<br>"
"PINATTR SpiceOrder 1<br>"
"<p>"
"And the simulation model:<br>"
"* Copyright (C) Linear Technology Corp. 1998, 1999, 2000. All rights reserved.<br>"
"*<br>"
".subckt node 1<br>"
"R1 1 1 0<br>"
".ends node<br>"
"<p>"
"In order to define a supply device in an EAGLE library, place a supply pin in a symbol and "
"define a device with <b>ATTRIBUTE 'SPICEMODEL' 'node.sub';</b> and <b>ATTRIBUTE 'VALUE2' 'node';</b> . "
"These two attributes make the device 'spice-usable'.<br>"
"In the transferred schematic you have to place a FLAG with all the neccessary information at the pin's position."
"<p>"
"When you start this ULP, EAGLE searches for the path of the LTspice executable in the file eaglerc.usr. If it "
"is not yet stored there, it searches in the default program folder and stores it in eaglerc.usr then."
"<br>"
"For the export of a schematic, EAGLE checks the availability of all necessary LTspice symbols .asy. "
"If there is one is missing, EAGLE opens the referring deviceset in the EAGLE library.<br>"
"<p>"
"There is a check for the SpiceOrder texts in layer 99 <i>SpiceOrder</i>. "
"In devices EAGLE searches for the attribute 'SPICEMODEL'. If one of these items is missing, "
"EAGLE opens the library editor. Please add the missing definitions. "
"For the SpiceOrder there will be called an ULP automatically."
"<p>"
"<b>The names of the symbols in EAGLE must be different compared to the names of the LTspice symbols.</b><br>"
"Example: If you export a symbol/device with name 'DIODE' from EAGLE, LTspice takes its own "
"symbol with name 'diode'. To insure that the EAGLE symbol is taken it has to have a unique name. "
"You can also combine device name and library name. The library name then reflects a subfolder in the "
"LTspice folder /sym . 2012-10-09"
"<p>"
"The SPICEMODEL attribute can be created through an entry in the LTC icon menu."
"<br>"
"This icon is created through the file eagle.scr. It will be executed automatically when you are "
"creating a new device or symbol. The icon images (PNG files) should be in "
"the subfolder <i>bin</i> of the EAGLE folder."
"<p>"
"Export/import Libraries:<br>"
"Libraries imported from LTspice have to be created in the subfolder ./lbr/ltspice/... "
"So the export function recognizes that the libary file comes from LTspice.<br>"
"When you start the ULP for the first time it copies some files to LTspice. <br>"
"They have to be copied into the following folder structure:<br>"
"./eagle-x.x.x/<br>"
" - /misc/<br>"
" - - /ltspice/<br>"
" - - - /lib/<br>"
" - - - - /sub/ note.sub and other .sub files<br>"
" - - - - /sym/<br>"
" - - - - - /eagle/<br>"
" - - - - - - /lbrname/ exported symbols from the EAGLE libraries<br>"
" - - - /scr/ Connect scripts (provided by LT)<br>"
"<br>"
"EAGLE libraries will be created/copied in(to) the following folders:<br>"
"./LTC/LTspiceIV/lib/sym/eagle/<br>"
"Each library exported results in a subfolder with the library name.<br>"
"<p>"
"<author>Author: alf@cadsoft.de</author>"
,
"de:<b>Schnittstelle zur Simulationssoftware LTspiceIV </b><br>"
"Export von EAGLE-Schaltplänen und Bibliothekssymbolen nach LTspiceIV und Import von Schaltplänen und Symbolen aus LTspiceIV<p>"
"RUN ltspice /E [/S][/G]<br>"
"RUN ltspice /I [/S][/G]<br>"
"RUN ltspice /?<br>"
" /E == Export<br>"
" /I == Import<br>"
" /? == Systeminfo<br>"
"Option /S öffnet das SETUP-Menü für Grundeinstellungen.<br>"
"Option /G exportiert eine Gruppe, die vorher im Schaltplan mit GROUP definiert wurde.<br>"
"RUN ltspice /I 'importfilename' [RELOAD]<p>"
"Startet man das ULP mit der Option /E aus einem Deviceset (Bibliothek), wird dieses eine Deviceset exportiert. "
"Gibt man keine Option an, wird die gesamte Bibliothek exportiert.<br>"
"Beim Import kann man im Dialog die Option <i>Import all symbols from directory</i> aktivieren. Wählen Sie dann eine Symboldatei aus, "
"werden alle Symbole aus dem Verzeichnis in die EAGLE-Bibliothek importiert."
"<p>"
"Die Option RELOAD soll in Zukunft den Schaltplan auf Änderungen prüfen. "
"Diese Option ist noch nicht implementiert! 2012-09<br>"
"<hr>"
"<b>SpiceOrder</b><br>"
"Die sogenannte SpiceOrder wird im Layer 99 'SpiceOrder' als Text abgelegt. Dieser muss exakt auf dem Kontaktpunkt (Koordinate) des Pins liegen. "
"Beim Export eines EAGLE-Schaltplans wird geprüft, ob SpiceOrder und SpiceModel definiert sind. "
"Fehlt die SpiceOrder, lädt EAGLE das entsprechende Deviceset und startet spiceorder.ulp.<br>"
"Mit Hilfe dieses ULPs ordnet man den Symbolpins die SpiceOrder zu. Diese Zuordnung wird automatisch an "
"den Pins als Text im Layer 99 platziert."
"<p>"
"<b>SpiceModel</b><br>"
"Das SpiceModel ist das Simulationsmodell. Es wird in EAGLE im Device "
"als Attribut <i>SPICEMODEL</i> hinterlegt. Das LTC-Icon im Device-Editor enthält dazu den Eintrag <i>SpiceModel</i>."
"<p>"
"<b>Value2</b><br>"
"Für manche Bauteile benötigt man zusätzlich <i>Value2</i>. Dieser kann ebenfalls als Attribut "
"angelegt werden. Auch hierzu gibt es eine Option im Menü des LTC-Icons."
"<p>"
"Für einen fehlerfreien Schaltplan-Import benötigt man passende und eindeutige Bibliotheken. "
"Die Bibliothek <b>lt-spice-simulation.lbr</b> hat einen Sonderstatus:<br>"
"Sie darf nicht in der USE-Liste enthalten sein, da ansonsten beim Ausführen des Scripts "
"und Einfügen von Widerständen das ADD-Menu geöffnet wird.<br>"
"Die Simulationswiderstände \"Rload\" werden in LTSpice wie normale Widerstände behandelt, "
"nur der Devicename wird mit dem Anhang \"_RLOAD\" erweitert. "
"<p>"
"<b>lt-spice-simulation.lbr</b> enthält nur Devices, die für die Simulation benötigt werden, wie "
"z.B. (Stromquellen, Spannungsquellen, Lasten, Messgeräte etc.). "
"In diesen Devices ist jeweils ein Attribut mit dem Namen \"_EXTERNAL_\" angelegt. Dadurch muss kein Package "
"zugeordnet werden; es handelt sich hierbei um Bauteile, die nicht in das Board übertragen "
"und auch nicht in die Stückliste aufgenommen werden.<br>"
"<p>"
"Ein FLAG aus LTspice wird in EAGLE als einfaches LABEL dargestellt und auf der Netzlinie platziert (FLAG 1248 176 BI_Port).<br>"
"Bei FLAGs wird keine Rotation angegeben. Die Rotation muss anhand der Ausrichtung der letzten zugehörigen Linie "
"ermittelt werden! Es kann auch vorkommen dass FLAGs direkt auf Pins gesetzt werden. Dann ist es nicht möglich die "
"Rotation zu ermitteln. In diesem Fall muss man sich manuell um die korrekte Ausrichtung des Labels anhand des "
"Pins im Symbol kümmern!<br>"
"<p>"
"Ein IOPIN wird in EAGLE als LABEL mit Querverweis dargestellt. (IOPIN 1248 176 BiDir)<br>"
"Da es in EAGLE keine Pendant für IOPIN gibt, wird für BI_Port, In und Out ein Label mit Querverweis (XREF) platziert."
"<p>"
"Supply-Symbole (FLAG) wie 0 oder COM, werden direkt aus der lt-supply.lbr genommen.<br>"
"Werden andere Supply-Symbole (ausser 0 und COM) benutzt, müssen diese in LTspice als *.asy-Datei "
"mit dem entsprechenden Spicemodel angelegt werden.<br>"
"Beispiel:<br>"
"Version 4<br>"
"SymbolType CELL<br>"
"LINE Normal 0 11 0 16<br>"
"LINE Normal -11 14 0 0<br>"
"LINE Normal 0 0 11 14<br>"
"LINE Normal 0 11 -11 14<br>"
"LINE Normal 11 14 0 11<br>"
"TEXT 0 -4 Bottom 2 +3.3V<br>"
"SYMATTR Prefix X<br>"
"SYMATTR SpiceModel node.sub<br>"
"SYMATTR Value node<br>"
"SYMATTR Value2 node<br>"
"PIN 0 16 NONE 36<br>"
"PINATTR PinName +3.3V<br>"
"PINATTR SpiceOrder 1<br>"
"<p>"
"Dazu das Simulationsmodell:<br>"
"* Copyright (C) Linear Technology Corp. 1998, 1999, 2000. All rights reserved.<br>"
"*<br>"
".subckt node 1<br>"
"R1 1 1 0<br>"
".ends node<br>"
"<p>"
"Um ein Supply-Device in einer EAGLE-Bibliothek anzulegen, platziert man im Symbol einen Supply-Pin und "
"legt dann ein Device mit <b>ATTRIBUTE 'SPICEMODEL' 'node.sub';</b> und <b>ATTRIBUTE 'VALUE2' 'node';</b> an. "
"Diese beiden Attribute machen das Device 'spicetauglich'.<br>"
"Im übertragenen Schaltplan, muß an der Position des Pins ein FLAG mit entsprechenden Informationen platziert werden."
"<p>"
"Beim Sart des ULPs wird in der Datei eaglerc.usr nach dem Pfad zur Programmdatei von Ltspice gesucht. Ist dieser "
"noch nicht hinterlegt, wird im Default-Programme-Ordner gesucht und in eaglerc.usr eingetragen."
"<br>"
"Das ULP überprüft beim Export des Schaltplan die Verfügbarkeit der benötigten LTspice-Symbole .asy. "
"Fehlt eines, öffnet EAGLE das Deviceset in der entsprechenden Bibliothek.<br>"
"<p>"
"Geprüft wird, ob in den Symbolen die SpiceOrder-Texte im Layer 99 <i>SpiceOrder</i> vorhanden sind. "
"In Devices wird nach dem Attribut 'SPICEMODEL' gesucht. Fehlt eines dieser Merkmale, wird "
"die Bibliothek mit dem entsprechenden Symbol bzw. Device geöffnet. Machen Sie dann die nötigen "
"Ergänzungen. Für die SpiceOrder ist ein ULP verfügbar, das automatisch aufgerufen wird."
"<p>"
"<b>Die Symbolnamen von EAGLE-Symbolen müssen sich von denen in LTspice unterscheiden.</b><br>"
"Beispiel: Exportiert man aus EAGLE ein Symbol/Devic 'DIODE', verwendet LTspice sein eigenes "
"Symbol mit Namen 'diode'. Damit das EAGLE-Symbol verwendet wird, muss es einen eigenen Namen haben. "
"Man kann auchden Namen mit dem LBR-Namen zusammen angegeben. Der LBR-Name entspricht dann einem "
"Unterordner im LTspice-Ordner /sym . 2012-10-09"
"<p>"
"Das Attribut SPICEMODEL kann über den Menü-Eintrag des LTC-Icons angelegt werden."
"<br>"
"Dieses Icon wird durch die Datei eagle.scr angelegt. Diese wird beim Anlegen eines neuen "
"Devices bzw. Symbols automatisch ausgeführt. Die benötigten Icons (PNG-Dateien) müssen im "
"Unterordner <i>bin</i> des EAGLE-Verzeichnisses abgelegt werden."
"<p>"
"Bibliotheken importieren/exportieren:<br>"
"Die importierten LTspice-Bilbiotheken müssen im Unterordner ./lbr/ltspice/.. angelegt werden, "
"damit die Export-Funktion erkennen kann, dass es sich um eine LTspice-Bibliothek handelt.<br>"
"Beim ersten Start des ULPs werden entsprechende Dateien nach LTspice kopiert. <br>"
"Die zu kopierenden Dateien müssen in folgender Ordnerstruktur abgelegt sein:<br>"
"./eagle-x.x.x/<br>"
" - /misc/<br>"
" - - /ltspice/<br>"
" - - - /lib/<br>"
" - - - - /sub/ note.sub und sonstige .sub Dateien<br>"
" - - - - /sym/<br>"
" - - - - - /eagle/<br>"
" - - - - - - /lbrname/ die exportierten Symbole der entsprechenden EAGLE-Bibliotheken<br>"
" - - - /scr/ die Connect-Scripte von LT (werden von LT geliefert)<br>"
"<br>"
"EAGLE-Bibliotheken werden in den folgenden Ordner kopiert/erzeugt:<br>"
"./LTC/LTspiceIV/lib/sym/eagle/<br>"
"Dabei wird für jede Bibliothek ein Ordner mit dem Namen der exportierten Bibliothek angelegt.<br>"
"<p>"
"<author>Author: alf@cadsoft.de</author>"
string LTspiceFormatInfo = "<nobr>" +
"Das Koordinatensystem von LTspice ist entsprechend der BitMap einer Grafikkarte organisiert.<br>" +
"Der Nullpunkt ist links oben, und die Vorzeichen der Y-Achse sind invertiert!<br>" +
"Positiv nach unten, negativ nach oben.<br>" +
"LTspice benutzt ein 16er Grid, das die Auflösung für Symbole etwas einschränkt.<br>" +
"Das Raster in LTspice wird ohne Einheit angegeben und ist auf (100) mil umgerechnet.<br>" +
"In Device-Namen darf kein Schrägstrich (Slash) oder Rückstrich (Backslash) vorkommen.<br>" +
"Der Name des Symbols in LTspice definiert den Device-Namen, der gleichzeitig der Name der .asy-Datei ist.<br>" +
"Unter Windows ist der 'Schrägstrich' in Dateinamen nicht erlaubt.<br>" +
"Unter Linux würde das einen weiteren Unterordner bedeuten!" +
"</nobr>" +
"<p>" +
"alf@cadsoft.de";
if (language() != "de") LTspiceFormatInfo = "<nobr>" +
"The coordinates system of LTspice is similar to the BitMap of a graphics adapter.<br>" +
"The origin is located in the upper left corner. The coordinates direction of the y axis is inverted.<br>" +
"Positive coodinates down, negative up.<br>" +
"LTspice works with a multiple of 16 grid, which limits the resolution for symbols a bit.<br>" +
"LTspice uses an inch based grid (units not visible) converted to (100) mil.<br>" +
"Device names may not contain slash / or backslash \.<br>" +
"The symbol name in LTspice defines the device name. This name is used for the .asy file, as well.<br>" +
"Windows does not tolerate a slash in file names. Linux would create a subfolder." +
"</nobr>" +
"<p>" +
"alf@cadsoft.de";
#require 6.0500
string ULP_Version = "1.0.4"; // 1.0.2 - 2013-10-01 alf erweitert mit Option /? Systeminfo für Diagnose
// 1.0.3 - 2014-01-23 R C L braucht kein SpiceModel (Attribute)
// 1.0.4 - 2014-04-03 Pfadauswertung zur importierten LTspice-Lbr berichtigt
int Test = 0;
/* *** export vaiable **** */
string LTSpiceExecute = ""; // Pfad-Dateiname zum LTspice-Programm
string EagleExecute = EAGLE_PATH; // 2012-11-23
string LTSpiceLibDir = ""; // das Directory der LTspice-Symbole .asy
string ExpEagleSpiceSymDir = ""; // das Directory der exportierten Eagle Library-Symbole
string ImpSpiceSchematicAsc = ""; // der ausgewählte LTspice-Schaltplan zum importieren
string SpiceSymbol = "";
string ExpSchematic2LTpice = ""; // der Eagle-Schaltplan der exportiert wird
string SpiceSimulationLbr = ""; // die LBR für die Generatoren, Messinstrumente, Lastwiderstände etc.
// wird mit USE benutzt.
string SpiceDefaultSymLbr = ""; // die LBR für die default Symbole wie R, C, L, D, T ....
// wird ebenfalls mit USE benutzt, damit es keine Konflikte zwischen EAGLE-LBRs
// und LTspice-LBRs gibt.
string EagleSpiceLbrDir = ""; // Das Verzeichnis für die importierten Spice-Bibliotheken (*.asy -> .lbr)
string LbrName; // current eagle lbr name
string NewLbrName; // new eagle lbr name
string FileSpiceSym[]; // file names of spice symbols of a directory
int CntFileSpiceSym = 0;
string Import_All_Symbols = "1";
string Imp_SpiceSchematicAsc = "";
string Imp_SpiceSymbol = "";
string Imp_SpiceSimulationLbr = ""; // die LBR für die Generatoren, Messinstrumente, Lastwiderstände etc.
string Imp_SpiceDefaultSymLbr = ""; // die LBR für die default Symbole wie R, C, L, D, T ....
string Imp_EagleSpiceSchDir = "";
string Imp_LbrName; // current eagle lbr name
string Imp_FileSpiceSym[]; // file names of spice symbols of a directory
int Imp_CntFileSpiceSym = 0;
string Imp_ConnectScriptDir = "";
string Ex_AsyName;
string Ex_SpiceAscDir;
int ExportAll = 1; // 0 to export only a GROUP
int Ex_cntFileSpiceAsc = 0;
int CntOutput = 0; // exported devices/technologies as *.asy
int Ex_WaitOnHandShake = 0; // flag for response of external executable (LTspice)
int Ex_PinDirSup = 0; // Flag to generate Supply-Symbols for LTspice as library
string Ex_SpiceOrder = "SpiceOrder";
string Ex_AttributeSPICEMODEL = "SPICEMODEL";
string Ex_AttributeSPICEPREFIX = "SPICEPREFIX";
string Ex_SpiceOrderNum[];
int Ex_PinX[], Ex_PinY[];
int Ex_LayerSpiceOrder = 99; // Die Zuordnung der Pins zu der SpiceOrder geschieht über den Text "SpiceOrder XX"
// und wird als Text in diesem Layer abgelegt!
int Ex_CntSymText = 0;
int ExOnceLib = 0;
string FileNewTemp = "wtD"; // option for function output() for generate temporary file (script).
string FileAppend = "at"; // option for function output() append data to existing file.
/***** import variable ******/
int RELOAD = 0; // Flag zum vergleichen bzw. nachladen nach beenden von export ltspice.ulp
string Imp_InfoExternalSymbol = "<b>In EAGLE besteht jedes reguläre Bauteil aus ein oder mehreren Symbolen "
"und ein oder mehreren Package-Varianten!</b><p>" +
"Simulationssymbole für LTspice (Stromquellen, Spannungsquellen, " +
"Generatoren, Messgeräte, Lasten etc.), dürfen nicht in das Board oder in die " +
"Stück- Netz- Pin-Listen übernommen werden.<br>" +
"Um das zu bewerkstelligen, und alle Pin-Directions in Symbolen " +
"nutzen zu können, muß in den Devices für Simulations-Symbole ein " +
"Attribute \"_EXTERNAL_\" definiert werden." +
"Dieses Attribute veranlasst Eagle (ab Version 6.2), die Überprüfung " +
"des Device bezüglich der CONNECT-Liste und Vorhandensein eines " +
"Packages zu unterdrücken.<br>";
if (language() != "de") {
Imp_InfoExternalSymbol = "In EAGLE every component definition consists of one or more symbols assigned to " +
"one or more package variants<p>." +
"Simulation symbols in LTSpice (like power supply, voltage supply, generators, " +
"measurment tools, loads and so on...) do not appear in the board nor in a " +
"bill of materials, pin list or net list.<br>" +
"In order to have all pin directions available for such symbols, a device for " +
"a simulation symbol must have defined an attribute named \"_EXTERNAL_\". " +
"This attribute suppresses the connection check and the package check (from " +
"EAGLE version 6.2.0 on).<br>";
}
string LTspicePrefix[], LTspicePrefixDescript[];
LTspicePrefix[ 0] = "none"; LTspicePrefixDescript[0] = "Device used not spice prefix";
LTspicePrefix[ 1] = "A"; LTspicePrefixDescript[ 1] = "Special functions";
LTspicePrefix[ 2] = "B"; LTspicePrefixDescript[ 2] = "Arbitrary behavioral source";
LTspicePrefix[ 3] = "C"; LTspicePrefixDescript[ 3] = "Capacitor";
LTspicePrefix[ 4] = "D"; LTspicePrefixDescript[ 4] = "Diode";
LTspicePrefix[ 5] = "E"; LTspicePrefixDescript[ 5] = "Voltage dependent voltage";
LTspicePrefix[ 6] = "F"; LTspicePrefixDescript[ 6] = "Current dependent current";
LTspicePrefix[ 7] = "G"; LTspicePrefixDescript[ 7] = "Voltage dependent current";
LTspicePrefix[ 8] = "H"; LTspicePrefixDescript[ 8] = "Current dependent voltage";
LTspicePrefix[ 9] = "I"; LTspicePrefixDescript[ 9] = "Independent current source";
LTspicePrefix[10] = "J"; LTspicePrefixDescript[10] = "JFET transistor";
LTspicePrefix[11] = "K"; LTspicePrefixDescript[11] = "Mutual inductance";
LTspicePrefix[12] = "L"; LTspicePrefixDescript[12] = "Inductance";
LTspicePrefix[13] = "M"; LTspicePrefixDescript[13] = "MOSFET transistor";
LTspicePrefix[14] = "O"; LTspicePrefixDescript[14] = "Lossy transmission line";
LTspicePrefix[15] = "Q"; LTspicePrefixDescript[15] = "Bipolar transistor";
LTspicePrefix[16] = "R"; LTspicePrefixDescript[16] = "Resistor";
LTspicePrefix[17] = "S"; LTspicePrefixDescript[17] = "Voltage controlled switch";
LTspicePrefix[18] = "T"; LTspicePrefixDescript[18] = "Lossless transmission line";
LTspicePrefix[19] = "U"; LTspicePrefixDescript[19] = "Uniform RC-line";
LTspicePrefix[20] = "V"; LTspicePrefixDescript[20] = "Independent voltage source";
LTspicePrefix[21] = "W"; LTspicePrefixDescript[21] = "Current controlled switch";
LTspicePrefix[22] = "X"; LTspicePrefixDescript[22] = "Subcircuit";
LTspicePrefix[23] = "Z"; LTspicePrefixDescript[23] = "MESFET transistor";
string ExternalAttributeName = "_EXTERNAL_"; // Attribute in order to define a device without package in eagle
string ExternalSymbol = "";
int LayerSpiceOrder = 99; // Die Zuordnung der Pins zu der SpiceOrder geschieht über den Text SpiceOrderXX
// und wird als Text in diesem Layer abgelegt!
int ColorViolett = 5;
string SchName;
int Imp_CntFileSpiceAsc = 0;
char Delimiter = '@';
int Imp_SetWireStyle = 0; // setze WireStyle auf continuous für den NET-Befehl
string Imp_Coords[]; // LT-Spice rotiert ein FLAG (Supplypin/Label) automatisch
// anhand der Ausrichtung des Wire, an dessen Ende das FLAG sitzt.
// Dazu muss man alle Wires sammeln, um dann später die Rotation
// des FLAGs zu bestimmen.
int Imp_CntCo = 0;
int Imp_WireX1[], Imp_WireY1[], Imp_WireX2[], Imp_WireY2[];
int Imp_CntW = 0;
int Imp_WireSeg[]; // Da ein NET sehr verzweigt, und später mit einem BUSTAB zu einem BUS deklariert werden kann,
// werden die Wire, Segmenten zugeordnet.
int Imp_WireType[]; // Der Index des WireType entspricht der Segmentnummer.
// Der Inhalt wird zunächst auf NET gesetzt, wird später im Segment eine Koordinate eines BUSTAB
// gefunden, so wird das Segment auf BUS gesetzt.
int Imp_CntSeg = 0; // Anzahl der Segmente
int Imp_WireChecked = 0; // Flag ob zusammenhängenden Wire-Segmente schon ermittelt wurden.
enum { Null, BUS, NET }
int Imp_DrawNetBus = 0; // Flag ob NET und BUS schon gezeichnet wurde.
string Imp_LineView[]; // nur zum Test
// Eine Besonderheit beim Simulieren in LTspice sind Lastwiderstände.
// Lastwiderständer werden mit Rload benannt.
string Imp_RloadExtention = "_RLOAD"; // Namenserweiterung innerhalb Eagle, um Simulations-/Last-Widerstände von "Res" zu unterscheiden
string Imp_InstanceName = "";
string Imp_Winattrib[];
real Imp_InstCoordX, Imp_InstCoordY; // remember coordinate from last instance in schematic
real Imp_InstNameSmashX, Imp_InstNameSmashY;
real Imp_InstNameOffset;
real Imp_InstValueSmashX, Imp_InstValueSmashY;
real Imp_InstValueOffset;
real Imp_SpiceModelSmashX, Imp_SpiceModelSmashY;
real Imp_InstValue2SmashX, Imp_InstValue2SmashY;
real Imp_InstValue2Offset;
real Imp_SpiceLineSmashX, Imp_SpiceLineSmashY;
real Imp_SpiceLine2SmashX, Imp_SpiceLine2SmashY;
real Imp_FlagRotate = 0.0; // used to rotate Label (Flag) on NET-Wire
string Add;
string AddPart;
string AddPartLib;
string AddPartOrientation;
string TextAlign; // die Textausrichtung für Text allgemein
string TextAlignRotation; // die Rotation für algemeinen Text
string TextAlignName; // die Textausrichtung für >NAME
string TextAlignValue; // die Textausrichtung für >VALUE
string TextAlignValue2; // die Textausrichtung für Value2
string TextAlignSpiceLine; // die Textasurichtung für die Spiceline
string TextAlignSpiceLine2; // die Textasurichtung für die Spiceline2
string ScriptFile = "";
string CmdNameLabel = "";
string RememberFlag = ""; // Ein Flag kann ein Label oder ein IOPIN sein,
// die Entscheidung fällt erst eine Zeile später
// mit IOPIN. Dazu muß man sich das Flag merken
// und die Koordinaten mit dem IOPIN vergleichen.
string Lines[];
int CntLines;
int n; // Global line counter
string h;
string Imp_Cmd = "";
string Imp_CmdValueV = "";
string Imp_CmdPartValue = "";
string Imp_CmdValue2 = ""; // Das Teilscript für den Wert von Value2, wenn der Instance name erst später zugewiesen wird.
// LTspice kann Value2 schon zuweisen, bevor die Instance den Namen erhält.
// Im Script darf ein Attribute erst nach bestehen des Part erfolgen.
string Imp_MemSpiceline = "";
string Imp_MemSpiceline2 = "";
string Imp_DefaultGateName = "G$1";
string Imp_SymDevName;
string Imp_CmdDev;
string Imp_SymPinName;
// für die Symbolbearbeitung
real Imp_SpiceLineSymX, Imp_SpiceLineSymY, Imp_SpiceLineSymOffset;
string Imp_SpiceLineSymAlign;
real Imp_SpiceLine2SymX, Imp_SpiceLine2SymY, Imp_SpiceLine2SymOffset;
string Imp_SpiceLine2SymAlign;
real Imp_SpiceModelSymX, Imp_SpiceModelSymY, Imp_SpiceModelSymOffset;
string Imp_SpiceModelSymAlign;
string Imp_ScriptExt = "~ltspice~.scr";
string Imp_SpicePinName[];
int Imp_CntPinname = 0;
string Imp_UsedLbrs[];
int Imp_CntUsedLbrs = 0;
int LTTextSize = 112; // default zum importieren von LTspice symbolen
// in mil bei Font: Arial, Size: 28, unter LT_Spice-Control-Panel / Drafting Options
// die Texte können nicht exakt berechnet werden, da die Programme unterschiedliche Fonts,
// und innerhalb der Fonts die Zeichen wiederum unterschiedlich definert sind!
/*
// ********************************
Syntax Definition Symbol
// ********************************
// *
Coordinate System
Anchor Point 0 0 -------> grid 16
|
|
|
V grid 16
// *
// * Generics *
<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<number> ::= <digit>
| <number> <digit>
<alphanum> ::= [a-zA-Z0-9_]
<string> ::= <alphanum>
| <string> <alphanum>
<filename> ::= <string> '.' <string>
// * Coordinates *
<coordinate_x> ::= <number>
<coordinate_y> ::= <number>
<point> ::= <coordinate_x> <coordinate_y>
<offset> ::= <number>
<spiceprefix> ::= [A-MOQ-XZ]
// * Line Styles
solid no
dash 1
dott 2
dash dot 3
dash dot dot 4
// *
<linestyle> ::= 1 | 2 | 3 | 4
// /* Justification *
<jhorizontal> ::= Left | Right | Center | Top | Bottom
<jvertical> ::= VLeft | VRight | VCenter | VTop | VBottom
<justification> ::= <jhorizontal> | <jvertical>
// * Symbol Type *
<symboltype> ::= CELL | BLOCK
<symboltype_def> ::= SymbolType <symboltype>
// * Drawings *
<text> ::= TEXT <point> <justification> <offset> <string>
<line> ::= LINE Normal <point> <point>
| LINE Normal <point> <point> <linestyle>
<circle> ::= CIRCLE Normal <point> <point>
| CIRCLE Normal <point> <point> <linestyle>
<arc> ::= ARC Normal <point> <point> <point> <point>
| ARC Normal <point> <point> <point> <point> <linestyle>
<rectangle> ::= RECTANGLE Normal <point> <point>
| RECTANGLE Normal <point> <point> <linestyle>
<drawing> ::= <text> | <line> | <circle> | <arc> | <rectangle>
<drawing_list> ::= <drawing>
| <drawing_list> '\n' <drawing>
// * Attribute Window *
Type 1 -
SpiceModel 38 +SYMATTR
Value 3 -
Value2 123 -
SpiceLine 39 -
SpiceLine2 40 -
// *
<windowattr> ::= 0 | 1 | 3 | 39 | 40 | 123
<windowsymattr> ::= 38
<window> ::= WINDOW <windowattr> <point> <justification> <offset>
| WINDOW <windowsymattr> <point> <justification> <offset> '\n' SYMATTR <spicemodel>
<window_list> ::= <window>
| <window_list> '\n' <window>
// * Symbol Attributes *
<prefix> ::= Prefix <spiceprefix>
<spicemodel> ::= SpiceModel <string>
<value> ::= Value <string>
<value2> ::= Value2 <string>
<spiceline> ::= SpiceLine <string>
<spiceline2> ::= SpiceLine2 <string>
<description> ::= Description <string>
<modelfile> ::= ModelFile <filename>
<symattribute> ::= <prefix> | <spicemodel> | <value> | <value2> | <spiceline> | <spiceline2> | <description> | <modelfile>
<symattribute_def> ::= SYMATTR <symattribute>
<symattribute_list> ::= <symattribute_def>
| <symattribute_list> '\n' <symattribute_def>
// * Pin Definition *
<pinjustification> ::= NONE | <justification>
<pin_def> ::= PIN <point> <pinjustification> <offset>
<pinname> ::= PinName <string>
<apiceorder> ::= SpiceOrder <number>
<pinattribute> ::= <pinname> | <apiceorder>
<pinattribute_def> ::= PINATTR <pinattribute>
<pin> ::= <pin_def> '\n' PINATTR <pinname> '\n' PINATTR <apiceorder>
<pin_list> ::= <pin>
| <pin_list> '\n' <pin>
// * File *
<header> ::= Version <number>
// *
<body> ::= <symboltype_def> <drawing_list> <window_list> <symattribute_list> <pin_list>
// *
<body> ::= SymbolType BLOCK '\n' <drawing_list> <pin_list>
| SymbolType CELL '\n' <drawing_list> <window_list> <symattribute_list> <pin_list>
<file> ::= <header> <body>
*/
int showtest = 1;
void testsyscommand(string cmdexe, string s) {
dlgDialog("DOS comand check") {
dlgHBoxLayout dlgSpacing(600);
dlgLabel(s);
dlgTextEdit(cmdexe);
dlgHBoxLayout {
dlgPushButton("OK") dlgAccept();
dlgPushButton("ESC") { dlgReject(); exit(-666); }
}
};
return;
}
char SearchStartDrive = 'C'; // *** erstes Windowslaufwerk ***
string StartFolder; // der Grundpfad
char SearchLastDrive = 'Z'; // 'Z' *** letztes Windowslaufwerk ***
int SearchnRoot;
string SearchRoot[];
//string SearchRootfound;
string SearchFiles[];
int SearchStart, SearchEnd;
string a[];
int SearchIs_UNC;
int CntSubDir = 4; // maximal bis in den 4. Unterordner suchen
int OS = strstr(OS_SIGNATURE, "Windows");
if (OS < 0) {
dlgMessageBox("This ULP runs only on Windows", "OK");
exit(-1);
}
/* *************** file functions *************** */
int check_files(string path, string file_ext) {
return fileglob(SearchFiles, path + file_ext);
}
// ein Windows-Laufwerk beginnt mit "Buchstabe:\"
// suche nach ":/" hinter dem Laufwerksbuchstaben
void check_windows_root(void) {
string drv;
for(int d = SearchStartDrive; d <= SearchLastDrive; d++) {
sprintf(drv, "%c:/", d);
if (check_files(drv, "/")) {
SearchRoot[SearchnRoot] = drv;
SearchnRoot++;
}
}
return;
}
string cut_path(string s) {
int pos = strrchr(s, '/', -1);
if (pos > 0) return strsub(s, 0, pos);
return "";
}
/*
void check_UNC(string s) {
int unc = strstr(s, "//", 0); // windows beginnt UNC Namen mit zweimal Slash // bzw. Backslash \\
string last_unc = s;
if (unc == 0) {
SearchIs_UNC = 1;
do {
string akt_unc = cut_path(last_unc);
unc = check_files(akt_unc, "");
if (unc) last_unc = akt_unc;
} while (unc);
SearchRootfound += last_unc;
SearchRoot[SearchnRoot] = last_unc;
SearchnRoot++;
}
return;
}
*/
/************************ die Suchschleife *******************************************************/
// searchfile = die zu suchende Datei
// root = der Start-Pfad ab dem gesucht werden soll, inkl. Laufwerkbuchstabe unter Windows
// maxiteration = die Tiefe, Anzahl der Verzweigung (Unterordner) ab dem root Pfad.
/*************************************************************************************************/
string file_search(string searchfile, string root, int maxiteration, string debugnum) {
if (!root) {
if (debugnum == "init") {
dlgMessageBox("RUN ltspice.ulp with option Setup: "+searchfile, "CANCEL");
}
else {
if (dlgMessageBox(debugnum + "\nUnknown path of file : "+searchfile, "OK", "CANCEL") == 0) return "";
}
exit(-752);
}
int len = strlen(root);
if (root[len-1] != '/') root += "/"; // root muß mit Slash enden!
if (!check_files(root, "")) { // den Pfad prüfen
return "";
}
// *** Betriebsystem feststellen ***
// ******* Windows Laufwerke *******
if (root) {
SearchRoot[0] = root;
SearchnRoot = 1;
}
else {
check_windows_root(); // unter Windows die Laufwerke ermitteln
//if (SearchnRoot) {
// sprintf(SearchRootfound, "Betriebssystem WINDOWS");
// for (int d = 0; d < SearchnRoot; d++) {
// SearchRootfound += SearchRoot[d] + "\n";
// }
//}
//int pos;
// ************* Windows UNC-Pfad *****************
//pos = strstr(root, "//", 0); // windows hat bei UNC Namen zweimal Slash // am Anfang
//check_UNC(root);
//if (!SearchIs_UNC) if (project.board) project.board(B) check_UNC(B.name);
//if (!SearchIs_UNC) if (project.schematic) project.schematic(S) check_UNC(S.name);
//if (!SearchIs_UNC) if (library) library(L) check_UNC(L.name);
// ************* LINUX File system ****************
//if (!SearchRootfound) {
// pos = strstr(root, "/", 0);
// if (pos == 0) {
// sprintf(SearchRootfound, "Betriebsystem LINUX");
// if (check_files("/", "/")) {
// SearchRoot[SearchnRoot] = "/";
// SearchnRoot = 1;
// }
// }
//}
}
int n, r;
SearchStart = 0;
SearchEnd = SearchnRoot;
int iteration = 1;
int finish = 0;
int cntf;
string searchfoundfile[];
do {
// 1. die Root-Ordner nach der Datei durchsuchen
for (r = SearchStart; r < SearchEnd; r++) {
status(SearchRoot[r]); // Anzeige des aktuellen Verzeichnisnamen
n = check_files(SearchRoot[r], searchfile); // suche im Verzeichnis nach Datei
if (n) {
for (int f=0; f<n; f++) {
searchfoundfile[cntf] = SearchFiles[f];
return searchfoundfile[cntf]; // das erst gefunden File zurückgeben
cntf++;
}
}
}
if (finish || (maxiteration && iteration == maxiteration)) break;
// 2. die Root-Ordner nach Ordnern durchsuchen
for (r = SearchStart; r < SearchEnd; r++) {
sprintf(h, "%d %d %s", iteration, SearchnRoot, SearchRoot[r]);
status(h); // Anzeige des aktuellen Verzeichnisnamen
n = fileglob(a, SearchRoot[r] + "/"); // lesen der Dateien
if (n) {
for (int xl = 0; xl < n; xl++) {
sprintf(h, "%s\n", a[xl]);
if (a[xl][strlen(a[xl])-1] == '/') { // nach Verzeichnis suchen
SearchRoot[SearchnRoot] = a[xl];
sprintf(h, "%d %d %s", iteration, SearchnRoot, SearchRoot[SearchnRoot]);
status(h); // Anzeige des aktuellen Verzeichnisnamen
SearchnRoot++;
}
else {
break;
}
}
}
}
SearchStart = r;
SearchEnd = SearchnRoot; // Suchende erweitern
if (SearchStart == SearchEnd) {
finish = 1;
}
iteration++;
} while(SearchnRoot);
return searchfoundfile[0];
}
/************* export import functions ****************/
// change Eagle slash in path names to backslash for windows
string lash2backslash(string s) {
int pos;
do {
pos = strchr(s, '/');
if (pos >= 0) s[pos] = '\\';
} while(pos >= 0);
return s;
}
// change backslash in windows path names to Eagle slash
string backslash2lash(string s) {
int pos;
do {
pos = strchr(s, '\\');
if (pos >= 0) s[pos] = '/';
} while(pos >= 0);
return s;
}
string checkapostroph(string s) { // da der ganze String in ' eingeschlossen wird,
// müssen die Apostrophen verdoppelt werden.
string t[];
int cnt;
cnt = strsplit(t, s, '\''); // check Apostroph
if (cnt > 1) {
s = "";
for (int i = 0; i < cnt; i++) {
if (i == 0) {
if (t[i]) s += t[i];
}
else if (i) s += "''" + t[i];
}
}
return s;
}
/********* export functions ***********/
void looptest(string fname) {
string text;
int cnttext = fileread(text, fname);
if (showtest) {
dlgDialog("Export to LTspice : "+ fname) {
dlgLabel("Die Datei, siehe Kopfzeile, wurde aktuell gelesen.");
dlgLabel(fname);
dlgHBoxLayout dlgSpacing(500);
dlgHBoxLayout {
dlgVBoxLayout dlgSpacing(500);
dlgTextEdit(text);
}
dlgHBoxLayout {
dlgPushButton("+OK") dlgAccept();
dlgPushButton("Cancel") { dlgReject(); exit(-9); }
dlgPushButton("Dieses Menu nicht mehr anzeigen") { showtest = 0; dlgAccept(); }
dlgStretch(1);
}
};
}
return;
}
string ex_checkbackslash(string s) { // für die Anzeige des Windows-Pfad mit Slash statt Backslash
int pos;
do {
pos = strchr(s, '\\');
if (pos >= 0) s[pos] = '/';
} while(pos >= 0);
return s;
}
string ex_check_text(string text) { // Eagle gibt Backslash doppelt aus, also halbieren!
string t[];
int cnt = strsplit(t, text, '\n');
if (cnt == 1) return text;
string t2 = "";
for (int n = 0; n < cnt-1; n++) {
t2 += t[n] + "\\n";
}
t2 += t[n];
return t2;
}
string ex_checktextangle(int talign, int tangle, string name, int iangle) {
/* Wenn das Symbol gedreht ist, und der Text nicht, dann muß der Text vertikal ausgegeben werden.
Wenn der Text gedreht ist und das Symbo nicht, dann muß der Text auch vertikal ausgegeben werden,
in allen anderen Fällen horizontal.
*/
string v = "";
if (iangle == 0 || iangle == 180) {
if ((tangle == 90 || tangle == 270 || iangle == 90 || iangle == 270)) v = "V";
}
else if (iangle == 90 || iangle == 270) {
if ((tangle == 0 || tangle == 180 || iangle == 0 || iangle == 180)) v = "V";
}
switch(talign) {
case ALIGN_BOTTOM_LEFT : return v+"Left";
break;
case ALIGN_BOTTOM_CENTER : return v+"Bottom";
break;
case ALIGN_BOTTOM_RIGHT : return v+"Right";
break;
case ALIGN_CENTER_LEFT : return v+"Left";
break;
case ALIGN_CENTER : return v+"Center";
break;
case ALIGN_CENTER_RIGHT : return v+"Right";
break;
case ALIGN_TOP_LEFT : return v+"Left";
break;
case ALIGN_TOP_CENTER : return v+"Top";
break;
case ALIGN_TOP_RIGHT : return v+"Right";
break;
default : return "Left";
}
}
real ex_spicegrid(real v) {
return v / 100 * 16;
}
string ex_spicetextcoord(UL_TEXT T, UL_INSTANCE I) {
string s;
int ang = I.angle;
real x;
real y;
switch(ang) {
case 0 : x = ex_spicegrid(u2mil(T.x - I.x));
y = ex_spicegrid(u2mil(T.y - I.y)*-1.0); // checked ok
break;
case 90 : if (I.mirror) {
y = ex_spicegrid(u2mil(T.x - I.x)*-1.0);
x = ex_spicegrid(u2mil(T.y - I.y)); // checked ok
}
else {
y = ex_spicegrid(u2mil(T.x - I.x));
x = ex_spicegrid(u2mil(T.y - I.y)); // checked ok
}
break;
case 180 : if (I.mirror) {
x = ex_spicegrid(u2mil(T.x - I.x));
y = ex_spicegrid(u2mil(T.y - I.y)); // checked ok
}
else {
x = ex_spicegrid(u2mil(I.x - T.x));
y = ex_spicegrid(u2mil(I.y - T.y)*-1.0); // checked ok
}
break;
case 270 : if (I.mirror) {
y = ex_spicegrid(u2mil(T.x - I.x));
x = ex_spicegrid(u2mil(T.y - I.y)*-1.0); // checked ok
}
else {
y = ex_spicegrid(u2mil(I.x - T.x));
x = ex_spicegrid(u2mil(I.y - T.y)); // checked ok
}
break;
}
sprintf(s, "%.0f %.0f", x, y);
return s;
}
void ex_draw_wire(UL_WIRE W) {
if (W.curve) {
/* ARC Normal 32 -32 0 0 27 -27 5 -27
die ersten vier Zahlen sind die umschließende Box,
die nächsten 2 die Start-Koordinate,
und die letzten beiden die End-Koordinate des ARC
*/
printf("ARC Normal %.0f %.0f %.0f %.0f %.0f %.0f %.0f %.0f\n",
ex_spicegrid(u2mil(W.arc.xc - W.arc.radius)), ex_spicegrid(u2mil(W.arc.yc + W.arc.radius)*-1.0),
ex_spicegrid(u2mil(W.arc.xc + W.arc.radius)), ex_spicegrid(u2mil(W.arc.yc - W.arc.radius)*-1.0),
ex_spicegrid(u2mil(W.arc.x1)), ex_spicegrid(u2mil(W.arc.y1)*-1.0),
ex_spicegrid(u2mil(W.arc.x2)), ex_spicegrid(u2mil(W.arc.y2)*-1.0)
);
}
else {
printf("LINE Normal %.0f %.0f %.0f %.0f\n",
ex_spicegrid(u2mil(W.x1)), ex_spicegrid(u2mil(W.y1)*-1.0),
ex_spicegrid(u2mil(W.x2)), ex_spicegrid(u2mil(W.y2)*-1.0)
);
}
return;
}
void ex_draw_rect(UL_RECTANGLE R) {
printf("LINE Normal %.0f %.0f %.0f %.0f\nLINE Normal %.0f %.0f %.0f %.0f\nLINE Normal %.0f %.0f %.0f %.0f\nLINE Normal %.0f %.0f %.0f %.0f\n",
ex_spicegrid(u2mil(R.x1)), ex_spicegrid(u2mil(R.y1)*-1.0),
ex_spicegrid(u2mil(R.x2)), ex_spicegrid(u2mil(R.y1)*-1.0),
ex_spicegrid(u2mil(R.x2)), ex_spicegrid(u2mil(R.y1)*-1.0),
ex_spicegrid(u2mil(R.x2)), ex_spicegrid(u2mil(R.y2)*-1.0),
ex_spicegrid(u2mil(R.x2)), ex_spicegrid(u2mil(R.y2)*-1.0),
ex_spicegrid(u2mil(R.x1)), ex_spicegrid(u2mil(R.y2)*-1.0),
ex_spicegrid(u2mil(R.x1)), ex_spicegrid(u2mil(R.y2)*-1.0),
ex_spicegrid(u2mil(R.x1)), ex_spicegrid(u2mil(R.y1)*-1.0)
);
return ;
}
void ex_draw_poly(UL_POLYGON P) {
P.contours(W) ex_draw_wire(W);
return;
}
void ex_draw_net_wire(UL_WIRE W) {
printf("WIRE %.0f %.0f %.0f %.0f\n",
ex_spicegrid(u2mil(W.x1)), ex_spicegrid(u2mil(W.y1)*-1.0),
ex_spicegrid(u2mil(W.x2)), ex_spicegrid(u2mil(W.y2)*-1.0)
);
return;
}
/* CIRCLE Normal 64 0 48 -16 */
void ex_draw_circle(UL_CIRCLE C) {
printf("CIRCLE Normal %.0f %.0f %.0f %.0f\n", // 64 0 48 -16
ex_spicegrid(u2mil(C.x - C.radius)), ex_spicegrid(u2mil(C.y + C.radius)*-1.0),
ex_spicegrid(u2mil(C.x + C.radius)), ex_spicegrid(u2mil(C.y - C.radius)*-1.0)
);
return;
}
/* LTspice directiven beginnen mit ! */
void ex_draw_text(UL_TEXT T, string option, string supply) {
string t = strupr(T.value);
real tx = ex_spicegrid(u2mil(T.x));
real ty = ex_spicegrid(u2mil(T.y)*-1.0);
switch(T.align) {
case ALIGN_BOTTOM_LEFT : if (T.angle == 0) {
ty -= ex_spicegrid(u2mil(T.size/2));
}
else if (T.angle == 90) {
tx += ex_spicegrid(u2mil(T.size/2));
}
break;
case ALIGN_BOTTOM_CENTER : ;
break;
case ALIGN_BOTTOM_RIGHT : ty -= ex_spicegrid(u2mil(T.size/2));
break;
case ALIGN_CENTER_LEFT : ty -= ex_spicegrid(u2mil(T.size/2));
break;
case ALIGN_CENTER : ty -= ex_spicegrid(u2mil(T.size/2));
break;
case ALIGN_CENTER_RIGHT : ty -= ex_spicegrid(u2mil(T.size/2));
break;
case ALIGN_TOP_LEFT : ;
break;
case ALIGN_TOP_CENTER : ;
break;
case ALIGN_TOP_RIGHT : ;
break;
}
// TEXT 0 0 Bottom 2 +3.3V : example of supply pin name
if (Ex_PinDirSup && supply) {
if (T.layer != Ex_LayerSpiceOrder) {
printf("TEXT %.0f %.0f %s 0 %s\n",
tx, ty,
ex_checktextangle(T.align, T.angle, "", 0),
ex_check_text(supply)
);
}
return;
}
if (t == ">NAME" || option == ">NAME") {
// WINDOW 0 36 40 Left 0 // Textplatzhalter für >NAME
if(option == ">NAME") printf("WINDOW 0 %.0f %.0f %s 0\n", tx, ty, ex_checktextangle(T.align, T.angle, "", 0));
return;
}
if (t == ">VALUE" || option == ">VALUE") {
// WINDOW 3 36 76 Left 0 // platzhalter für >VALUE
if (option == ">VALUE") printf("WINDOW 3 %.0f %.0f %s 0\n", tx, ty, ex_checktextangle(T.align, T.angle, "", 0));
return;
}
// if (strstr(T.value, "SpiceOrder") == 0) return; // nur vorübergehender Text im Symbol zum überprüfen
if (option == "*") {
// TEXT 0 0 Center 0 LT
printf("TEXT %.0f %.0f %s 0 %s\n", tx, ty, ex_checktextangle(T.align, T.angle, "", 0), ex_check_text(T.value));
return;
}
t = T.value;
if (t[0] == '\\' && t[1] == '!') { // damit Eagle den Text nicht Überstreicht, muß ein Backslash vorangestellt werden.
t = strsub(t, 1); // schneide das Backslash (Escapezeichen) vor dem ! wieder ab.
}
printf("TEXT %.0f %.0f %s 0 %s\n",
tx, ty,
ex_checktextangle(T.align, T.angle, "", 0),
ex_check_text(t)
);
return;
}
void ex_collectordertext(UL_SYMBOL S) {
Ex_CntSymText = 0; // reinitialization
S.texts(T) {
if (T.layer == Ex_LayerSpiceOrder) {
string s[];
strsplit(s, T.value, ' ');
if (s[0] == Ex_SpiceOrder) {
Ex_PinX[Ex_CntSymText] = T.x;
Ex_PinY[Ex_CntSymText] = T.y;
Ex_SpiceOrderNum[Ex_CntSymText] = s[1];
Ex_CntSymText++;
}
}
}
}
string ex_getspiceorder(int x, int y) {
for (int n = 0; n < Ex_CntSymText; n++ ) {
if (x == Ex_PinX[n] && y == Ex_PinY[n]) return Ex_SpiceOrderNum[n];
}
return "";
}
string ex_checkinverted(string pinname) { // LTspice benutzt Underline als Einleitungszeichen für den Negierungsüberstrich,
if (pinname[0] == '!') pinname[0] = '_'; // Eagle beginnt mit Ausrufezeichen.
return pinname;
}
void ex_draw_pin(UL_PIN P, int pcnt) {
int pinlength;
int x2, y2;
if (P.direction == PIN_DIRECTION_SUP) Ex_PinDirSup = 1;
if (pcnt) { // draw line and pin it self
switch(P.length) { // Grid unit = mil
case (PIN_LENGTH_POINT) : pinlength = 0; // kein Wire
break;
case (PIN_LENGTH_SHORT) : pinlength = 100; // 0.1-Inch-Wire
break;
case (PIN_LENGTH_MIDDLE) : pinlength = 200; // 0.2-Inch-Wire
break;
case (PIN_LENGTH_LONG) : pinlength = 300; // 0.3-Inch-Wire
break;
}
int ang = P.angle;
switch(ang) {
case (0) : x2 = pinlength;
y2 = 0;
break;
case (90) : x2 = 0;
y2 = pinlength;
break;
case (180) : x2 = pinlength * -1;
y2 = 0;
break;
case (270) : x2 = 0;
y2 = pinlength * -1;
break;
}
if (pinlength) {
printf("LINE Normal %.0f %.0f %.0f %.0f\n", // Linie des PIN
ex_spicegrid(u2mil(P.x)), ex_spicegrid(u2mil(P.y)*-1.0), // Das Vorzeichen der Y-Achse ist bei LT-Spice vertauscht
ex_spicegrid(u2mil(P.x)+x2), ex_spicegrid((u2mil(P.y)+y2)*-1.0)
);
}
//if (!Ex_PinDirSup) {
printf("PIN %.0f %.0f NONE 0\n", ex_spicegrid(u2mil(P.x)), ex_spicegrid(u2mil(P.y)*-1.0 ));
printf("PINATTR PinName %s\n", ex_checkinverted(P.name));
printf("PINATTR SpiceOrder %s\n", ex_getspiceorder(P.x, P.y));
//}
//else {
/* ****************************************************************
if (Ex_PinDirSup) { // a supply symbol is generated
sprintf(acmd, "EDIT %s.DEV; ATTRIBUTE %s 'node.sub'; ATTRIBUT 'VALUE2' 'node';",
DEV.name, Ex_AttributeSPICEMODEL
);
exit(acmd);
}
* ****************************************************************/
//}
}
return;
}
void readconfig(void) { // read configuration file of ULP
SpiceDefaultSymLbr = cfgget("ULP:ltspice.SpiceDefaultSymLbr");
SpiceSimulationLbr = cfgget("ULP:ltspice.SpiceSimulationLbr");
EagleSpiceLbrDir = cfgget("ULP:ltspice.EagleSpiceLbrDir");
LTSpiceLibDir = cfgget("ULP:ltspice.LTSpiceLibDir");
ImpSpiceSchematicAsc = cfgget("ULP:ltspice.ImpSpiceSchematicAsc");
LTSpiceExecute = cfgget("ULP:ltspice.LTSpiceExecute");
SpiceSymbol = cfgget("ULP:ltspice.SpiceSymbol");
ExpSchematic2LTpice = cfgget("ULP:ltspice.ExpSchematic2LTpice");
SchName = cfgget("ULP:ltspice.SchName");
Import_All_Symbols = cfgget("ULP:ltspice.Import_All_Symbols");
ExternalSymbol = cfgget("ULP:ltspice.ExternalSymbol");
Imp_ConnectScriptDir = cfgget("ULP:ltspice.Imp_ConnectScriptDir");
ExpEagleSpiceSymDir = cfgget("ULP:ltspice.ExpEagleSpiceSymDir");
Ex_SpiceAscDir = cfgget("ULP:ltspice.SpiceAscDir");
return;
}
void saveconfig(void) {
cfgset("ULP:ltspice.SpiceDefaultSymLbr", SpiceDefaultSymLbr);
cfgset("ULP:ltspice.SpiceSimulationLbr", SpiceSimulationLbr);
cfgset("ULP:ltspice.EagleSpiceLbrDir", EagleSpiceLbrDir);
cfgset("ULP:ltspice.LTSpiceLibDir", LTSpiceLibDir);
cfgset("ULP:ltspice.ImpSpiceSchematicAsc", ImpSpiceSchematicAsc);
cfgset("ULP:ltspice.LTSpiceExecute", LTSpiceExecute);
cfgset("ULP:ltspice.SpiceSymbol", SpiceSymbol);
cfgset("ULP:ltspice.ExpSchematic2LTpice", ExpSchematic2LTpice);
cfgset("ULP:ltspice.SchName", SchName);
cfgset("ULP:ltspice.Import_All_Symbols", Import_All_Symbols);
cfgset("ULP:ltspice.ExternalSymbol", ExternalSymbol);
cfgset("ULP:ltspice.Imp_ConnectScriptDir", Imp_ConnectScriptDir);
cfgset("ULP:ltspice.ExpEagleSpiceSymDir", ExpEagleSpiceSymDir);
cfgset("ULP:ltspice.SpiceAscDir", Ex_SpiceAscDir);
return;
}
int ex_check_slash(string name) {
string s[];
return strsplit(s, name, '/') -1;
}
string ex_check_dev_name(string dev) { // wenn Package-Variante "leer" dann gib auch leeren string zurück
if (dev == "''") return "";
int pos;
do {
pos = strchr(dev, '/'); // Slash ist in Device-Namen (Packagevariant) verboten, da unter Linux sonst ein Unterordner angesprichen wird.
if (pos >= 0) dev[pos] = '_';
} while(pos >= 0);
return dev;
}
string ex_check_devset_name(string devset, string pac, string tech) { // * ist in Dateinamen Deviceset verboten,
if (pac == "''") pac = ""; // da es sich hier um ein Wildcard-Zeichen handelt
if (tech == "''") tech = ""; // wie auch das ? muß es durch Pacvariante und Technology ersetzt werden.
string s[];
int np = strsplit(s, devset, '*'); // Technologie
if (np > 1) {
if (tech == "''") tech = ""; // ein leeres Device wird intern mit '' angegeben, und muß "" (leer) werden!
devset = s[0]+tech+s[1];
}
else {
devset = s[0]+tech;
}
int nt = strsplit(s, devset, '?'); // Packagevariante
if (nt > 1) {
if (pac == "''") pac = ""; // ein leeres Device wird intern mit '' angegeben, und muß "" (leer) werden!
devset = s[0]+pac+s[1];
}
else {
devset = s[0]+pac;
}
//if (dlgMessageBox(">"+devset+"<", "okpactech1189", "escpactech1189") != 0) exit(-1321);
return devset;
}
string check_dev_description(string descript) {
if(descript[0] == '<') return ""; // Description beginnt mit HTML-Tag, dann nur leeren String zurückgeben.
string s[];
int cnt = strsplit(s, descript, '\n'); // nur die Kopfzeile zurückgeben, da LTspice bei der Description
descript = s[0]; // keine mehrzeiligen Texte benutzen kann.
return descript;
}
string check_exist_asy(string symname, string sympath, string debugnum) { // müssen bestimmte symbole in bestimmten Pfaden abgelegt sein?
return file_search( symname, sympath, CntSubDir, debugnum);
}
int makedir(string root1, string subdir) { /*** generate DOS command MKDIR ***/
string DOScommand;
sprintf(DOScommand, "CMD.EXE /C MKDIR \"%s%s\"", lash2backslash(root1), lash2backslash(subdir));
system(DOScommand);
string f[];
int n = fileglob(f, root1 + subdir); // prüfe ob das Verzeichnis angelegt werden konnte.
return n;
}
void check_exist_directory(string fname) { // überprüfe die Existenz des Verzeichneis, und wenn nicht vorhanden, anlegen!
string fdir = filedir(fname);
string fd[];
int n = fileglob(fd, fdir);
int len =strlen(fdir);
if (fdir[len-1] == '/') fdir[len-1] = 0; // für MKDIR darf kein Backslash (Slash) am Ende sein.
if (!n) {
if (!makedir("", fdir)) { // Returnwert 0 wenn das Verzeichnis nicht angelegt werden konnte
dlgMessageBox("!Can't build:\n" + fdir, "ok", "esc");
exit(-1359);
}
}
return;
}
void ex_draw_device(UL_DEVICE D, UL_DEVICESET DEV) {
string error;
int cntgate = 0;
D.gates(G) {
cntgate++;
}
if (ex_check_slash(DEV.name)) {
dlgMessageBox("!Do not use character / in device name!\n"+ DEV.name + ".DEV\nPlease change to '_' !", "OK");
sprintf(error, "EDIT %s.DEV;", DEV.name);
exit(error);
}
// check attribute SPICEMODEL
string acmd = "";
int cntnoattspicemodel = 0;
int cntnoattspiceprefix = 0;
string devnoattmodel[];
string technoattmodel[];
string devnoattprefix[];
string technoattprefix[];
int cntde = 0;
DEV.devices(DE) {
cntde++;
string t[];
int nt = strsplit(t, DE.technologies, ' ');
int spicemodelexist = 0;
int spiceprefixexist = 0;
//if (dlgMessageBox(DEV.name + DE.name, "ok", "esc") !=0) exit(-1392);
// prüfe erst die Existenz der Spicemodelle
for (int i = 0; i < nt; i++) {
spicemodelexist = 0;
spiceprefixexist = 0;
DE.attributes(A, t[i]) {
if (A.name == "SPICEMODEL") { spicemodelexist++; // 1 = Attribute existiert
if (A.value) spicemodelexist++; // 2 = Wert gesetzt
}
if (A.name == "SPICEPREFIX") { spiceprefixexist++; // 1 = Attribute existiert
if (A.value) spiceprefixexist++; // 2 = Wert gesetzt
}
}
if (DEV.prefix == "C" || DEV.prefix == "L" || DEV.prefix == "R") { // 2014-01-23
// C braucht kein Spicemodel
// L braucht kein Spicemodel
// R braucht kein Spicemodel
}
else {
if (spicemodelexist < 2) {
devnoattmodel[cntnoattspicemodel] = DE.name;
technoattmodel[cntnoattspicemodel] = t[i];
cntnoattspicemodel++;
}
}
if (spiceprefixexist < 2) { // 2012-11-30
devnoattprefix[cntnoattspiceprefix] = DE.name;
technoattprefix[cntnoattspiceprefix] = t[i];
cntnoattspiceprefix++;
}
}
}
// check all devices of this deviceset, of attribute SPICEMODEL
string attvalspicemodel;
string attvalspiceprefix;
if (cntnoattspicemodel || cntnoattspiceprefix) {
if (cntnoattspicemodel) { // 2012-12-05
int result = dlgDialog("Set Attributes") {
dlgHBoxLayout dlgSpacing(300);
if (cntnoattspicemodel) {
dlgLabel("<b>" + DEV.name + "</b>.DEV<p>MISSING SpiceModel<br>Type in the name of spicemodel for this device!");
dlgStringEdit(attvalspicemodel);
}
dlgHBoxLayout {
dlgPushButton("OK") if (attvalspicemodel) dlgAccept();
else dlgMessageBox("First type in the name of spicemodel for this device!", "OK");
dlgPushButton("CANCEL") dlgReject();
}
};
if(!result) exit(-1441);
}
if (cntnoattspiceprefix) { // 2012-12-05
string prefixlist[];
for (int l = 0; LTspicePrefix[l]; l++) prefixlist[l] = LTspicePrefix[l] + "\t" + LTspicePrefixDescript[l];
int prefsel = -1;
int result = dlgDialog("Set Attributes") {
dlgHBoxLayout dlgSpacing(300);
if (cntnoattspiceprefix) {
dlgLabel("<b>" + DEV.name + "</b>.DEV<p>MISSING SpicePrefix<br>Select a spiceprefix for this device!");
dlgListBox(prefixlist, prefsel) { attvalspiceprefix = LTspicePrefix[prefsel]; dlgAccept(); }
}
dlgHBoxLayout {
dlgPushButton("OK") if (attvalspiceprefix) dlgAccept();
else {
if (prefsel >= 0) {
attvalspiceprefix = LTspicePrefix[prefsel];
dlgAccept();
}
else dlgMessageBox("First select a Spice prefix for this device.", "OK");
}
dlgPushButton("CANCEL") dlgReject();
}
};
if(!result) exit(-1466);
}
// if (!spicemodelexist) dlgMessageBox("Missing attribute SPICEMODEL of technology '"+ ex_check_dev_name(actualtechno) + "' of package variant " + D.name, "OK");
// else dlgMessageBox("Attribute SPICEMODEL of technologie '"+ ex_check_dev_name(actualtechno) + "' of package variante " + D.name + " has no value!", "OK");
string as;
int i;
for (i = 0; i < cntnoattspicemodel; i++) {
sprintf(as, "EDIT %s.DEV;\n", DEV.name);
acmd += as;
/*** in Device und Technologie darf kein Schrägstrich, oder Backslash vorkommen,
denn das gibt ein Proglem bei Pfad und Dateinamen in Linux/MAX-OS bzw. Windows!
Hier muß ein Unterstrich benutzt werden!
***/
string chkdevname = ex_check_dev_name(devnoattmodel[i]);
if (devnoattmodel[i] != chkdevname && chkdevname) { // Supply-Devices haben kein Package, nicht mal ''
sprintf(as, "PACKAGE -%s %s;\n", devnoattmodel[i], chkdevname); // 2012-10-04 benenne die Packagevariante um, mit "_" als "/".
acmd += as;
}
// 2012-09-17 Attribute-Befehl zweimal aufrufen! Fehler in Dialog-Menu.
// Wenn kein Wert angegeben wird, wird es nicht als geändert erkannt, und das Attribute wird nicht angelegt!
sprintf(as, "PACkage '%s'; TECHNOLOGY %s; ATTRIBUTE %s '%s';\n",
checkapostroph(ex_check_dev_name(devnoattmodel[i])), technoattmodel[i], Ex_AttributeSPICEMODEL, attvalspicemodel // 2012-12-10
);
acmd += as; // if(dlgMessageBox(acmd, "acmd ok", "acmd esc") != 0) exit(-1489); ;
}
// 2012-11-30 setze den Wert für das Attribute SPICEPREFIX
for (i = 0; i < cntnoattspiceprefix; i++) {
sprintf(as, "EDIT %s.DEV;\n", DEV.name);
acmd += as;
/* ** in Device und Technologie darf kein Schrägstrich, oder Backslash vorkommen,
denn das gibt ein Proglem bei Pfad und Dateinamen in Linux/MAX-OS bzw. Windows!
Hier muß ein Unterstrich benutzt werden!
** */
string chkdevname = ex_check_dev_name(devnoattprefix[i]);
if (devnoattprefix[i] != chkdevname && chkdevname) { // Supply-Devices haben kein Package, nicht mal ''
sprintf(as, "PACKAGE -%s %s;\n", devnoattprefix[i], chkdevname); // 2012-10-04 benenne die Packagevariante um, mit "_" als "/".
acmd += as;
}
// 2012-09-17 Attribute-Befehl zweimal aufrufen! Fehler in Dialog-Menu.
// Wenn kein Wert angegeben wird, wird es nicht als geändert erkannt, und das Attribute wird nicht angelegt!
sprintf(as, "PACkagE '%s'; TECHNOLOGY %s; ATTRIBUTE %s '%s';\n",
checkapostroph(ex_check_dev_name(devnoattprefix[i])), technoattprefix[i], Ex_AttributeSPICEPREFIX, attvalspiceprefix // 2012-12-10
);
acmd += as; // if(dlgMessageBox(acmd, "acmd ok", "acmd esc") != 0) exit(-1509); ;
}
if (acmd) {
if (dlgMessageBox("ex_draw_device() : exit " + acmd , "ok", "esc") != 0) exit(-1513);
exit(acmd);
}
}
//if (dlgMessageBox("ex_draw_device() : symbole ausgeben" , "ok", "esc") != 0) exit(-1517);
Ex_PinDirSup = 0;
DEV.gates(G) {
library(L) {
L.symbols(SYM) {
if (SYM.name == G.symbol.name) { // prüfe nur die zum Device gehörenden Symbole
if (ex_check_slash(SYM.name)) {
dlgMessageBox("!Do not use character / in symbol name!\n"+SYM.name+".SYM\nPlease change to '_' !", "OK");
sprintf(error, "EDIT %s.SYM;", SYM.name);
exit(error);
}
// check exist SpiceOrder
int cnttext = 0;
int cntpin = 0;
string h;
SYM.texts(T) {
if (T.layer == Ex_LayerSpiceOrder) {
if (strstr(T.value, "SpiceOrder") == 0) cnttext++;
}
}
SYM.pins(P) {
if (P.direction == PIN_DIRECTION_SUP) Ex_PinDirSup = 1; // ein Supply-Pin ist beteiligt, also ist es ein Supply-symbol
cntpin++;
}
if (!cnttext) {
sprintf(h, "!Symbol %s can not be exported, missing SpiceOder for PINs!", SYM.name);
dlgMessageBox(h, "OK");
sprintf(h, "EDIT %s.SYM;RUN spiceorder.ulp", SYM.name);
exit(h);
}
if (cnttext != cntpin) {
dlgMessageBox("!Different counts of SpiceOrder and PINs.", "OK");
sprintf(h, "EDIT %s.SYM;RUN spiceorder.ulp", SYM.name); // run spiceordr.ulp to define the missing spiceorder in device
exit(h);
}
ex_collectordertext(SYM);
string actgatename = G.name;
if (cntgate < 2) actgatename = ""; // wenn Deviceset nur aus 1 Gate besteht,
// dann den Gatenamen nicht benutzen!
// keine leere '' Package-Variante angeben
int ltspicelbr = strstr(L.name, "/ltspice/");
string tech[];
int n = strsplit(tech, D.technologies, ' ');
for (int i = 0; i < n; i++) {
if (ltspicelbr > 0) { // eine LTspice importierte LBR ist geladen
Ex_AsyName = LTSpiceLibDir + "sym/" + DEV.library + "/" + ex_check_devset_name(DEV.name, D.name, "") + actgatename + ".asy"; // keine leere '' Package-Variante angeben
}
// eine Eagle-Lbr ist geladen
else Ex_AsyName = ExpEagleSpiceSymDir + DEV.library + "/" + ex_check_devset_name(DEV.name, D.name, tech[i]) + actgatename + ".asy"; // 2012-12-10 Technologie
// für jede technologie ein symbol anlegen 2012-10-02
check_exist_directory(Ex_AsyName); // 2012-12-10 bevor das Symbol angelegt werden kann, muß das Verzeicnis existieren!
output(Ex_AsyName, "wt") {
//if (dlgMessageBox(Ex_AsyName, "ok", "esc") != 0) exit(-1571);
CntOutput++;
printf("Version 4\n");
printf("SymbolType CELL\n");
int pcnt = 0;
SYM.wires(W) ex_draw_wire(W); // Symbollinien zeichnen.
SYM.polygons(POL) ex_draw_poly(POL); // Die Kontur des Polygon zeichen (werden nicht gefüllt).
SYM.rectangles(R) ex_draw_rect(R); // Rechteck als Linien zeichnen.
SYM.circles(C) ex_draw_circle(C);
SYM.texts(T) {
if (T.layer != Ex_LayerSpiceOrder && T.layer != 93) { // Spiceorder nicht als Text ausgeben! Zusätzliche Doku im Layer 93 Pins nicht ausgeben.
if (strupr(T.value) != ">NAME" && strupr(T.value) != ">VALUE") ex_draw_text(T, "*", SYM.name); // beliebiger Text
else if (strupr(T.value) == ">NAME") ex_draw_text(T, ">NAME", ""); // der Textplatzhalter >NAME
else if (strupr(T.value) == ">VALUE") ex_draw_text(T, ">VALUE", ""); // der Textplatzhalter >VALUE
}
}
/*
SYMATTR Value LT6231
SYMATTR Prefix X
*/
printf("SYMATTR Value %s\n", DEV.name); // nicht der Device-Prefix, sondern der Device-Name
string t[];
int n = strsplit(t, D.technologies, ' ');
// check exist Spice Attribute for Spice Model
//int spicemodelexist = 0;
//int spiceprefixexist = 0;
string actualtechno = "";
/*
SYMATTR Value LT3518
SYMATTR Prefix X
SYMATTR SpiceModel LT3518.sub
SYMATTR Value2 LT3518
*/
string aspiceprefix;
string aspicemodel;
string avalue2;
string aspiceline;
string aspiceline2;
string aspicetype;
DEV.devices(DE) {
if (DE.name == D.name) {
for (int i = 0; i < n; i++) {
D.attributes(A, t[i]) {
actualtechno = t[i];
if (A.name == "SPICEPREFIX") {
sprintf(aspiceprefix, "SYMATTR Prefix %s\n", A.value); //
}
else if (A.name == "SPICEMODEL") {
//spicemodelexist++; // 1 = Attribute existiert
if (A.value != "NONE") {
sprintf(aspicemodel, "SYMATTR SpiceModel %s\n", A.value);
}
else {
//if (dlgMessageBox(A.name + " : " + A.value, "NONE ok", "NONE esc") != 0) exit(-1627);
}
}
/* Der Value im LTspice-Symbol ist der Devicesetname
else if (A.name == "VALUE") {
sprintf(avalue, "SYMATTR Value %s\n", A.value);
}
*/
else if (A.name == "VALUE2") {
sprintf(avalue2, "SYMATTR Value2 %s\n", A.value);
}
else if (A.name == "SPICELINE") {
sprintf(aspiceline, "SYMATTR Spiceline %s\n", A.value);
}
else if (A.name == "SPICELINE2") {
sprintf(aspiceline2, "SYMATTR Spiceline2 %s\n", A.value);
}
else if (A.name == "SPICETYPE") {
sprintf(aspicetype, "SYMATTR Type %s\n", A.value);
}
}
}
printf("%s", aspiceprefix);
printf("%s", aspicemodel);
if (avalue2) printf("%s", avalue2);
if (aspiceline) printf("%s", avalue2);
if (aspicetype) {
printf("%s", aspicetype);
}
}
}
printf("SYMATTR Description %s\n", check_dev_description(DEV.description));
SYM.pins(P) ex_draw_pin(P, 1); // die Linien der Pins plus die PINs selbst zeichnen.
/* export no description
string descript = DEV.description;
if (!descript) descript = DEV.prefix;
printf("SYMATTR Description : %s Export with %s\n", descript, argv[0]);
SYM.pins(P) ex_draw_pin(P, ++pcnt); // die Pinkontakte selbst
*/
} // end output()
}
}
}
}
}
if (Test) looptest(Ex_AsyName);
return;
}
void ex_draw_label(UL_LABEL L) {
// ein Flag ist ein Supply-Symbol, wobei nur zwischen 0 == GND und COM == Common unterschieden wird.
return;
}
void ex_draw_line(UL_WIRE W) {
return;
}
void ex_draw_rectangle(UL_RECTANGLE R) {
// RECTANGLE Normal 352 336 288 304
printf("RECTANGLE Normal %.0f %.0f %.0f %.0f\n",
ex_spicegrid(u2mil(R.x1)), ex_spicegrid(u2mil(R.y1)*-1.0),
ex_spicegrid(u2mil(R.x2)), ex_spicegrid(u2mil(R.y2)*-1.0)
);
return;
}
string ex_check_gate_name(UL_PART P, string igatename) {
// wenn Device aus nur 1 Gate besteht, dann keine Gate-Namen verwenden
int gcnt = 0;
P.deviceset.gates(G) {
gcnt++;
}
//string h;
//sprintf(h, "%s (%s) has %d gates!", P.name, P.deviceset.name, gcnt);
if (gcnt == 1) return "";
return igatename;
}
void ex_draw_instance(UL_INSTANCE I, UL_PART P) {
int cnttext = 0;
int cntpin = 0;
string h;
string currentgatename = ex_check_gate_name(P, I.gate.name);
string libpath;
I.gate.symbol.texts(T) {
if (T.layer == Ex_LayerSpiceOrder) {
if (strstr(T.value, "SpiceOrder") == 0) cnttext++;
}
}
I.gate.symbol.pins(P) {
cntpin++;
}
if (cnttext != cntpin || !cnttext) {
if (!cnttext) {
sprintf(h, "!No SpiceOrder in symbol %s of Part %s,\nplease define the SpiceOder for PINs first!", I.gate.symbol.name, P.name);
}
if (cnttext != cntpin) {
sprintf(h, "!Different quantity of SpiceOrder and PINs in symbol %s of part %s (%s).\nPlease check symbol!",
I.gate.symbol.name, P.name, P.device.name
);
}
dlgMessageBox(h, "OK");
libpath = file_search(P.deviceset.library+".lbr", EAGLE_DIR, 4, "1733");
if (strstr(libpath, P.deviceset.library) < 0) {
dlgMessageBox("Library " + P.deviceset.library + ".lbr not found in path:\n"+ EAGLE_DIR, "OK");
if (dlgMessageBox("Export from schematic ?", "YES", "CANCEL") != 0) exit(-1739);
exit("RUN exp-project-lbr");
}
sprintf(h, "OPEN '%s';\nEDIT %s.DEV;RUN spiceorder.ulp", libpath, P.deviceset.name);
//if (dlgMessageBox(h, "ok", "esc1740") != 0) exit(-1743);
exit(h);
}
if (P.deviceset.library == "lt-supply") { // LTspice-Versorgungssymbole bzw. LABEL müssen in der lt-supply.lbr angelegt sein!
// FLAG(s) haben keine Rotation, sie werden anhand der Richtung des angelegten WIRE ausgerichtet!
if (P.device.name == "0") { // FLAG 144 -416 0
printf("FLAG %.0f %.0f 0\n", ex_spicegrid(u2mil(I.x)), ex_spicegrid(u2mil(I.y)*-1.0));
return;
}
else if (P.device.name =="COM") { // FLAG -128 288 COM
printf("FLAG %.0f %.0f COM\n", ex_spicegrid(u2mil(I.x)), ex_spicegrid(u2mil(I.y)*-1.0));
return;
}
else {
printf("FLAG %.0f %.0f %s\n", ex_spicegrid(u2mil(I.x)), ex_spicegrid(u2mil(I.y)*-1.0), P.device.name);
return;
}
}
string devicename = P.device.name;
if (P.deviceset.library == "lt-spice-simulation") { // Spezielle Behandlung von Bauteilen aus der Simulations-LBR
if (devicename == "RES_RLOAD") devicename = "res"; // Konvertiere einen LOAD-Resistor wieder zurück zu "res"
else if (devicename == "VOLTAGE");
else if (devicename == "CURRENT");
else if (devicename == "BV");
else if (devicename == "E");
else if (devicename == "LOAD"); // ein LOAD (veränderbarer Widerstand) als Last aus der lt-spice-simulation.lbr
else {
dlgMessageBox("Unknown simulation part <b>" +P.name+ "</b> (Device:"+ devicename + "), please check :<br><b>" + P.deviceset.library + ".lbr</b>", "OK");
exit(-1772);
}
}
// Prüfe das Vorhandensein des benötigten Symbol in der LTspice-Datenstruktur.
// Müssen bestimmte Symbole in bestimmten Verzeichissen abgelegt sein?
string asyfile;
if (P.deviceset.library == "lt-spice-simulation") {
asyfile = check_exist_asy(ex_check_dev_name(devicename+currentgatename+".asy"), LTSpiceLibDir, "init");
}
else if (P.deviceset.library == "lt-supply") {
if (dlgMessageBox(devicename+currentgatename+".asy" + ":" + LTSpiceLibDir , "ok1779", "esc1779") != 0) exit(-1782);
}
else {
asyfile = check_exist_asy(ex_check_dev_name(devicename+currentgatename+".asy"), LTSpiceLibDir, "1782"); // evtl. einen Ordner weiter unten beginnen, ExpEagleSpiceSymDir);
}
if (!asyfile) { // 2014-01-23
if (dlgMessageBox(LTSpiceLibDir + "\n" + devicename+currentgatename + ".asy\ndoes not exist as LTspice symbol.\nOpen library and deviceset, and export device (symbols).", "OK", "CANCEL") != 0) exit(-1788);
libpath = file_search(P.deviceset.library+".lbr", EAGLE_DIR, 4, "1786");
sprintf(h, "OPEN '%s';\nEDIT %s.DEV;", libpath, P.deviceset.name);
exit(h);
}
/* *** Lastwiderstände "Rload" benutzen das selbe Symbol wie R (res.asy) beim ****
**** importieren wird dem Devicenamen (Instance) der Zusatz "_RLOAD" vergeben. *** */
if (devicename == "RES_RLOAD") devicename = "res"; // hier ohne den expliziten Hinweis auf die Herkunft (LBR)
string rotation;
sprintf(rotation, "R%.0f", I.angle); // ok 2012-05-11
if (rotation == "R0" && I.mirror) rotation = "M0";
else if (rotation == "R180" && I.mirror) rotation = "M180";
else if (rotation == "R180") rotation = "R180";
else if (rotation == "R90" && I.mirror) rotation = "M270";
else if (rotation == "R90") rotation = "R270";
else if(rotation == "R270" && I.mirror) rotation = "M90";
else if(rotation == "R270") rotation = "R90";
printf("SYMBOL %s %.0f %.0f %s\n",
// Device- und Gate-Namen dürfen keine Slash enthalten, siehe LTspiceFormatInfo.
ex_check_dev_name(devicename+currentgatename), // aktueller Gatename, wenn Device aus mehr als 1 Gate besteht
/*** hier fehlt evtl. noch die Technologie ***/
ex_spicegrid(u2mil(I.x)),
ex_spicegrid(u2mil(I.y)*-1.0),
rotation
);
string iname = I.name;
if (strstr(iname, "RLOAD") == 0) {
// iname = "Rload"; Kleinschreibung muß nicht sein!
}
printf("SYMATTR InstName %s\n", iname);
printf("SYMATTR Value %s\n", I.value);
string SPICEMODEL = "", VALUE2 = "", SPICELINE = "", SPICELINE2 = "", SPICETYPE = "", NAME = "", VALUE = "";
/* nur in der LBR für das Symbol ausgeben
if (P.attribute["SPICEMODEL"]) {
SPICEMODEL = P.attribute["SPICEMODEL"];
} */
if (P.attribute["VALUE2"]) {
VALUE2 = P.attribute["VALUE2"];
if (VALUE2) printf("SYMATTR Value2 %s\n", VALUE2);
}
if (P.attribute["SPICELINE"]) {
SPICELINE = P.attribute["SPICELINE"];
if(SPICELINE) printf("SYMATTR SpiceLine %s\n", SPICELINE);
}
if (P.attribute["SPICELINE2"]) {
SPICELINE2 = P.attribute["SPICELINE2"];
if(SPICELINE2) printf("SYMATTR SpiceLine2 %s\n", SPICELINE2);
}
if (P.attribute["SPICETYPE"]) {
SPICETYPE = P.attribute["SPICETYPE"];
if (SPICETYPE) {
printf("SYMATTR Type %s\n", SPICETYPE);
}
}
I.gate.symbol.texts(T) {
if (strupr(T.value) == ">VALUE") VALUE = T.value;
}
I.texts(T) {
int windowattrib = -1;
int textoffset = 0;
if (I.name == T.value) windowattrib = 0;
else if (I.value == T.value) windowattrib = 3;
else if (SPICETYPE == T.value) windowattrib = 1;
else if (SPICEMODEL == T.value) windowattrib = 38;
else if (SPICELINE == T.value) windowattrib = 39;
else if (SPICELINE2 == T.value) windowattrib = 40;
else if (VALUE2 == T.value) windowattrib = 123;
if (windowattrib >=0) {
printf("WINDOW %d %s %s %.0f\n",
windowattrib,
ex_spicetextcoord(T, I),
ex_checktextangle(T.align, T.angle, P.name, I.angle),
u2mil(textoffset)
);
}
}
return;
}
/****************** Import functions *********************/
void imp_Testview(string head) {
int sel = 0;
int srt = 0;
for (int n = 0; n < Imp_CntW; n++) {
sprintf(Imp_LineView[n], "%d\t%d\t%d\t%d\t%d\t%d\t%d", n, Imp_WireX1[n], Imp_WireY1[n], Imp_WireX2[n], Imp_WireY2[n], Imp_WireSeg[n], Imp_WireType[Imp_WireSeg[n]]);
}
dlgDialog(head) {
dlgHBoxLayout dlgSpacing(500);
dlgHBoxLayout {
dlgVBoxLayout dlgSpacing(400);
dlgListView("Nr.\tx1\ty1\tx2\ty2\tSegnr\t1 BUS/2 NET", Imp_LineView, sel, srt);
}
dlgHBoxLayout {
dlgPushButton("OK") dlgAccept();
dlgPushButton("esc") { dlgReject(); exit(-1890); }
dlgStretch(1);
}
};
return;
}
void imp_helpSimulationSymbols(void) {
dlgDialog("HELP import-LTspice") {
dlgHBoxLayout dlgSpacing(400);
dlgLabel(Imp_InfoExternalSymbol);
dlgHBoxLayout {
dlgStretch(1);
dlgPushButton("OK") dlgAccept();
dlgStretch(1);
}
};
return;
}
string imp_dirname(string name) { // ermittle den letzen Verzeichnisnamen
string s[];
int cntd = strsplit(s, name, '/');
if (cntd > 1) return s[cntd-2];
return s[0];
}
string imp_check_use(string lname) { // check exist lbr in library path
if (!lname) return "";
for (int n = 0; n < Imp_CntUsedLbrs; n++) { // check lbr in used list?
if (Imp_UsedLbrs[n] == lname) return ""; // LBR are in use
}
int nl = 0;
int exist = 0;
string lb[];
string dir = filedir(lname); // prüfe auf kompletten Pfad-Datei-Namen
if (dir) { // mit Pfad zur Lib
if (fileglob(lb, lname)) {
Imp_Cmd += "USE '" + lname + "'; #1933\n";
Imp_UsedLbrs[Imp_CntUsedLbrs] = lname; // set lbr on used list
Imp_CntUsedLbrs++;
return "@"+lname;
}
else {
do {
if (fileglob(lb, path_lbr[nl] + "/" + lname + "*.lbr")) {
Imp_Cmd += "USE '" + path_lbr[nl] + "/" + lname + ".lbr'; #1941\n";
Imp_UsedLbrs[Imp_CntUsedLbrs] = lname; // set lbr on used list
Imp_CntUsedLbrs++;
return "@"+path_lbr[nl] + "/" + lname + ".lbr";
}
nl++;
} while(path_lbr[nl]);
dlgMessageBox("!Library does not exist:\n\n\"" + lname + "\"\n\nULP aborted.", "OK");
//return "lbr not found";
exit(-1951);
}
}
else { // Ohne Pfad zur Lib, suche in allen Verzeichnissen die im Control-Panel angegeben sind.
do {
if (fileglob(lb, path_lbr[nl] + "/" + lname + "*.lbr")) {
Imp_Cmd += "USE '" + path_lbr[nl] + "/" + lname + ".lbr'; #1957\n";
Imp_UsedLbrs[Imp_CntUsedLbrs] = lname; // set lbr on used list
Imp_CntUsedLbrs++;
return "@"+path_lbr[nl] + "/" + lname + ".lbr";
}
nl++;
} while(path_lbr[nl]);
dlgMessageBox("!Library <b>" + lname + "</b>.lbr can't be found in path!<br>Please check: Control Panel - Options - Directories - Libraries.<br>Add path of : " + lname + ".lbr.<br>" +
"Are you sure, you have imported this lbr from LTspice?", "OK");
exit(-3);
}
}
int check_exist_packname(string pacname) {
int len = strlen(pacname);
if (!len) {
dlgMessageBox("! No package name : Error 1674", "CANCEL"); exit(-1962);
}
if (pacname[len-1] == '\'') pacname[len-1] =0;
if (pacname[0] == '\'') pacname = strsub(pacname, 1);
library(L) L.packages(PAC) {
if (PAC.name == pacname) return 1;
}
return 0;
}
string get_pac_from_script(string scriptname) { // lade existierendes script und suche nach der Packagebezeichnung
string scrlines[];
int cntsline = fileread(scrlines, scriptname);
string s[];
int cnt;
int pacexist = 0;
int paccnt = 0;
string pacname = "";
for ( int n = 0; n < cntsline; n++) {
cnt = strsplit(s, scrlines[n], ' ');
if (s[0] == "Package") {
paccnt++;
if (check_exist_packname(s[1])) {
pacname = s[1];
pacexist++;
}
else {
dlgMessageBox("!Script:" + scriptname + "\nPackage " + s[1] + " not found in lbr.", "OK");
exit(-1992);
}
}
else if (s[1] == "Package") { // Die Zeile beginnt mit einem SPACE
paccnt++;
if (check_exist_packname(s[2])) {
pacname = s[2];
pacexist++;
}
else {
dlgMessageBox("!Script:\n" + scriptname + "\nPackage " + s[2] + " not found in lbr.", "OK");
exit(-2003);
}
}
}
if (paccnt == pacexist) return pacname; // das zuletzt gefundene Package wird zurückgegeben
return "";
}
string imp_checkpinname(string pname) {
/*
LTspice läßt gleichen Pin-Namen mehrfach zu,
in Eagle muß der Pinname eindeutig sein,
hier wird geprüft ob der Pinname einzigartig ist.
Wenn nein, dann wird "@n" hinzugefügt, wobei im SCH
das Zeichen @ und alle dahinter vorkommenden Zeichen
nicht angezeigt werden. n wird hochgezählt.
*/
if (pname[0] == '_') pname[0] = '!'; // LTspice benutzt das Underlinezeichen als Einleitung des Negierungsüberstrich,
string name = pname; // Eagle benutzt das Ausrufezeichen, also tauschen.
int cnt = 0;
do {
int found = 0;
for(int n = 0; n < Imp_CntPinname; n++) {
if (name == Imp_SpicePinName[n]) {
found = 1;
break;
}
}
if (!found) {
Imp_SpicePinName[Imp_CntPinname] = name;
Imp_CntPinname++;
return name;
}
else {
sprintf(name, "%s@%d", pname, ++cnt);
}
} while(pname);
}
real imp_eagle_coordvalue(real v) { // calculate LT_SPice-16-Grid to Eagle-100-mil-Grid
return (v / 16) * 100;
}
void imp_add_wire(int x1, int y1, int x2, int y2) {
Imp_WireX1[Imp_CntW] = x1; // für die spätere Untersuchung wegen des BUS-Flags
Imp_WireY1[Imp_CntW] = y1;
Imp_WireX2[Imp_CntW] = x2;
Imp_WireY2[Imp_CntW] = y2;
Imp_CntW++;
// LT-Spice rotiert ein FLAG (Supplypin/Label) automatisch
// anhand der Ausrichtung des Wire, an dessen Ende das FLAG sitzt.
// Dazu muß man alle Wire sammeln, um dann später die Rotation
// des FLAG zu bestimmen.
// Hier wird die Tabelle aufgebaut, für die Funktion lookup().
sprintf(Imp_Coords[Imp_CntCo], "%d %d;%d %d", x1, y1, x2, y2); // erstellen der Tabelle für lookup()
Imp_CntCo++;
sprintf(Imp_Coords[Imp_CntCo], "%d %d;%d %d", x2, y2, x1, y1);
Imp_CntCo++;
return;
}
int imp_getflagrotate(string coord, string l) {
string xy2[];
strsplit(xy2, lookup(Imp_Coords, coord, 1, ';'), ' '); // prüfe auf übereinstimmung der Wire-Koordinaten
if (!xy2[0]) { // Rückgabewert ist leer, wenn keine Wire-Koordinate gefunden wurde.
strsplit(xy2, coord, ' ');
sprintf(h, "Import line: %s\nCould not find wire's coordinates in order to place a supply symbol.\n(%.4fmil %.4fmil)",
l,
imp_eagle_coordvalue(strtod(xy2[0])), // als Eagle-Koordinate anzeigen
imp_eagle_coordvalue(strtod(xy2[1]))*-1.0
);
if (dlgMessageBox(h, "OK", "CANCEL") != 0) exit(-2079);
return 0;
}
real r;
string xy1[];
strsplit(xy1, coord, ' ' );
int x1 = strtol(xy1[0]);
int y1 = strtol(xy1[1]);
int x2 = strtol(xy2[0]);
int y2 = strtol(xy2[1]);
if (x1 == x2) { // vertical
if (y1 < y2) Imp_FlagRotate = 180.0; // in LT-Spice ist die Y-Achse auf den Kopf gestellt
else Imp_FlagRotate = 0.0;
}
else if (y1 == y2) { // horizontal
if (x1 < x2) Imp_FlagRotate = 270.0; // in LT-Spice ist die Y-Achse auf den Kopf gestellt
else Imp_FlagRotate = 90.0;
}
else Imp_FlagRotate = 0.0;
return 1;
}
void imp_get_net_segment(void) {
/*
LT-Spice zeichnet WIRE immer von rechts nach links, und von unten nach oben!
Ein BUS wird erst am Ende durch ein BUSTAP markiert.
In Eagle wird NET und BUS unterschieden, sowohl als Befehl als auch als Objekt.
Hier müssen zuerst die Segmente zugeordnet werden, und dann als NET oder BUS
gezeichnet werden.
WireSeg[]; // Da ein NET sehr verzweigt, und später mit einem BUSTAB zu einem BUS deklariert werden kann,
// werden die Wire, Segmenten zugeordnet.
WireType[]; // Der Index des WireType entspricht der Segmentnummer.
// Der Inhalt wird zunächst auf NET gesetzt, wird im Segment eine Koordinate eines BUSTAB
// gefunden, so wird das Segment auf BUS gesetzt.
CntSeg = 0; // Anzahl der Segmente
*/
int found = 0;
Imp_CntSeg = 0;
int fx1 = Imp_WireX1[0];
int fy1 = Imp_WireY1[0];
int fx2 = Imp_WireX2[0];
int fy2 = Imp_WireY2[0];
for (int n = 0; n < Imp_CntW; n++) {
if (!Imp_WireSeg[n]) {
Imp_WireSeg[n] = ++Imp_CntSeg;
Imp_WireType[Imp_CntSeg] = NET; // setze Segment-Type NET als Default
}
fx1 = Imp_WireX1[n];
fy1 = Imp_WireY1[n];
fx2 = Imp_WireX2[n];
fy2 = Imp_WireY2[n];
do {
found = 0;
for(int i = n+1; i < Imp_CntW; i++) {
if (!Imp_WireSeg[i]) {
if ( Imp_WireX1[i] == fx1 && Imp_WireY1[i] == fy1 || Imp_WireX2[i] == fx2 && Imp_WireY2[i] == fy2 ||
Imp_WireX1[i] == fx2 && Imp_WireY1[i] == fy2 || Imp_WireX2[i] == fx1 && Imp_WireY2[i] == fy1 ) {
Imp_WireSeg[i] = Imp_CntSeg;
found = i;
fx1 = Imp_WireX1[i];
fy1 = Imp_WireY1[i];
fx2 = Imp_WireX2[i];
fy2 = Imp_WireY2[i];
}
}
}
} while (found > 0);
}
Imp_WireChecked = 1; // Segmente ermittelt
return;
}
void imp_check_bus(int x, int y) { // check Koordinate auf BUSTAB
for (int n = 0; n < Imp_CntW; n++) {
if ( Imp_WireX1[n] == x && Imp_WireY1[n] == y || Imp_WireX2[n] == x && Imp_WireY2[n] == y) {
Imp_WireType[Imp_WireSeg[n]] = BUS;
break;
}
}
return;
}
void imp_draw_net(void) { // zeichne alle NETze und BUSse
Imp_Cmd += "SET CONFIRM YES;\n";
string commandtype = "NET";
for (int n = 0; n < Imp_CntW; n++ ) {
commandtype = "NET";
if (Imp_WireType[Imp_WireSeg[n]] == BUS) {
sprintf(commandtype, "BUS 'B_$%d' ", Imp_WireSeg[n]);
}
sprintf(h, "%s (%.4f %.4f) (%.4f %.4f);\n",
commandtype,
imp_eagle_coordvalue(Imp_WireX1[n]),
imp_eagle_coordvalue(Imp_WireY1[n])*-1.0,
imp_eagle_coordvalue(Imp_WireX2[n]),
imp_eagle_coordvalue(Imp_WireY2[n])*-1.0
);
Imp_Cmd+= h;
}
Imp_Cmd += "SET CONFIRM OFF;\n";
Imp_DrawNetBus = 1; // Flag NET/BUS gezeichnet
return;
}
void imp_version(string l) {
// Version 4
string s[];
int n = strsplit(s, l, ' ');
int versionnumber = strtol(s[1]);
sprintf(h, "# Spice version %d\n", versionnumber);
Imp_Cmd += h;
return;
}
// calculate angle from a pair of coordinates
real imp_wire_angle(int x1, int y1, int x2, int y2) {
real xe = imp_eagle_coordvalue(x1);
real ye = imp_eagle_coordvalue(y1);
real xa = imp_eagle_coordvalue(x2);
real ya = imp_eagle_coordvalue(y2);
real RADIUS = sqrt(((xa - xe) * (xa - xe)) + ((ya - ye) * (ya - ye)));
if ((xa > xe) && (ya >= ye)) { /* Quadrant 1 */
return acos((xa - xe) / RADIUS) * 57.29578;
}
if ((xa < xe) && (ya >= ye)) { /* Quadrant 2 */
return acos((xa - xe) / RADIUS) * 57.29578;
}
if ((xa < xe) && (ya < ye)) { /* Quadrant 3 */
return 360 - acos((xa - xe) / RADIUS) * 57.29578;
}
if ((xa > xe) && (ya < ye)) { /* Quadrant 4 */
return 360 - acos((xa - xe) / RADIUS) * 57.29578;
}
if ((xa == xe) && (ya == ye)) { /* Ursprung */
return (xa - xe);
}
if ((xa == xe) && (ya > ye)) { /* 90<39> */
return (xa - xe + 90);
}
if ((xa == xe) && (ya < ye)) { /* 270<37> */
return (xa - xe + 270);
}
}
/******************************************************
parse library lines
******************************************************/
void imp_symboltype(string l){
// SymbolType CELL
// SymbolType BLOCK
string s[];
int n = strsplit(s, l, ' ');
string symboltype = s[1];
if (symboltype == "CELL") {
}
else if (symboltype == "BLOCK") {
}
else {
dlgMessageBox("Unknown symbol type:\n" + l, "CANCEL");
exit(-2250);
}
sprintf(h, "# Symbol Type %s\n", symboltype);
Imp_Cmd += h;
sprintf(h, "CHAnge Align Left Center; # Symbol\n");
Imp_Cmd += h;
return;
}
void imp_line(string l) {
string s[];
int n = strsplit(s, l, ' ');
if (s[1] == "Normal") {
Imp_Cmd+="CHANGE WIDTH 6 ;\n";
}
else if (s[1] == "Bold") {
Imp_Cmd+="CHANGE WIDTH 10;\n";
}
else {
string e;
sprintf(e, "Unknown LINE " + s[1]);
dlgMessageBox(e, "OK");
exit(-2273);
}
if (s[6]) {
if (s[6] == "0") {
Imp_Cmd += "CHANGE STYLE Continuous;\n";
}
else if (s[6] == "1") {
Imp_Cmd += "CHANGE STYLE LongDash;\n";
}
else if (s[6] == "2") {
Imp_Cmd += "CHANGE STYLE ShortDash;\n";
}
else if (s[6] == "3") {
Imp_Cmd += "CHANGE STYLE DashDot;\n";
}
else {
Imp_Cmd += "CHANGE STYLE Continuous;\n";
}
}
sprintf(h, "SET WIRE_BEND 2;\nLAYER 94;\nWIRE (%.4f %.4f) (%.4f %.4f);\n",
imp_eagle_coordvalue(strtod(s[2])),
imp_eagle_coordvalue(strtod(s[3])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[4])),
imp_eagle_coordvalue(strtod(s[5])*-1.0) // in LT-Spice ist die Y-Achse auf den Kopf gestellt
);
Imp_Cmd+=h;
return;
}
void imp_rectangle(string l) {
string s[];
int n = strsplit(s, l, ' ');
if (s[1] == "Normal") {
Imp_Cmd+="CHANGE WIDTH 6;\n";
}
else if (s[1] == "Bold") {
Imp_Cmd+="CHANGE WIDTH 10;\n";
}
sprintf(h, "SET WIRE_BEND 2;\nLAYER 94;\nWIRE (%.4f %.4f) (%.4f %.4f) (%.4f %.4f) (%.4f %.4f) (%.4f %.4f);\n",
imp_eagle_coordvalue(strtod(s[2])), imp_eagle_coordvalue(strtod(s[3])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[4])), imp_eagle_coordvalue(strtod(s[3])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[4])), imp_eagle_coordvalue(strtod(s[5])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[2])), imp_eagle_coordvalue(strtod(s[5])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[2])), imp_eagle_coordvalue(strtod(s[3])*-1.0) // in LT-Spice ist die Y-Achse auf den Kopf gestellt
);
Imp_Cmd+=h;
return;
}
void imp_circle(string l) {
/*
Definition eines CIRCLE:
Die ersten zwei Koordinaten definieren mit den zwei diagonalen Ecken ein umschliesendes
Rechteck um den Kreis. Innerhalb dieses Rechteck befindet sich der Kreis, also
ist Breite und Länge des Rechteck zugleich der Durchmesser.
*/
string s[];
int n = strsplit(s, l, ' ');
if (s[1] == "Normal") {
Imp_Cmd+="CHANGE WIDTH 6 ;\n";
}
else if (s[1] == "Bold") {
Imp_Cmd+="CHANGE WIDTH 10;\n";
}
sprintf(h, "LAYER 94;\nCIRCLE (%.4f %.4f) (%.4f %.4f);\n",
(imp_eagle_coordvalue(strtod(s[2])) + imp_eagle_coordvalue(strtod(s[4]))) / 2,
(imp_eagle_coordvalue(strtod(s[3])*-1.0) + imp_eagle_coordvalue(strtod(s[5])*-1.0)) / 2, // in LT-Spice ist die Y-Achse auf den Kopf gestellt
(imp_eagle_coordvalue(strtod(s[2])) + imp_eagle_coordvalue(strtod(s[4]))) / 2,
imp_eagle_coordvalue(strtod(s[5])*-1.0) // in LT-Spice ist die Y-Achse auf den Kopf gestellt
);
Imp_Cmd+=h;
return;
}
void imp_arc(string l) {
// ARC Normal -20 -124 4 -100 -20 -112 -8 -100
/*
Definition des ARC:
Die ersten zwei Koordinaten definieren die zwei diagonalen Ecken eines umschließenden
Rechteck um einen Kreis. Die Mitte dieses Rechteck ist der Mittelpunkt des Kreises,
und somit der Mittelpunkt des ARC.
Die 3. und 4. Koordinate ergibt vom Mittelpunkt des zuvor definierten Kreises
den Anfangswinkel und die 7. und 8. Koordinate den Endwinkel.
Die Genauigkeit der Zeichnungen bezüglich der Enden eines ARC in LT-Spice, ist beschränkt
durch die relativ geringe Auflösung von 16 (Einheiten), siehe ARC in Optokoppler PC817D.
2011-10-12
*/
string s[];
int n = strsplit(s, l, ' ');
if (s[1] == "Normal") {
Imp_Cmd+="CHANGE WIDTH 6 ;\n";
}
else if (s[1] == "Bold") {
Imp_Cmd+="CHANGE WIDTH 10;\n";
}
if (n > 10) {
sprintf(h, "# %d Parameter in line:\n# %s\n", n, l);
Imp_Cmd+=h;
}
int centerx = (strtod(s[2]) + strtod(s[4])) / 2;
int centery = (strtod(s[3])*-1.0 + strtod(s[5])*-1.0) / 2;
int aax = strtod(s[6]);
int aay = strtod(s[7]) * -1;
int aex = strtod(s[8]);
int aey = strtod(s[9]) * -1;
int radius = strtod(s[4])- centerx;
if (radius < 0) radius *= -1; // Radius darf nie negativ sein.
real startangle = imp_wire_angle(centerx, centery, strtod(s[6]), strtod(s[7])*-1.0);
real endangle = imp_wire_angle(centerx, centery, strtod(s[8]), strtod(s[9])*-1.0);
/* P Polar-Koordinaten (relativ zur Marke, x = Radius, y = Winkel in Grad, gegen den Uhrzeigersinn) */
sprintf(h, "LAYER 94;\nMARK (%.4f %.4f);\nARC CCW (P%.4f %.4f) (P%.4f %.4f) (P%.4f %.4f);\nMARK;\n",
imp_eagle_coordvalue(centerx), imp_eagle_coordvalue(centery), // setze Marke ins Zentrum des ARC
imp_eagle_coordvalue(radius), startangle,
imp_eagle_coordvalue(radius), startangle + 180.0,
imp_eagle_coordvalue(radius), endangle
);
Imp_Cmd+=h;
return;
}
void imp_print_text(real thigh, char leading, string text, real tx, real ty) { // damit Eagle Directiven-Texte nicht überstreicht,
// muss das Einleitende ! mit einem Escapezeichen markiert werden.
string t[];
int cnt;
cnt = strsplit(t, text, '\''); // check Apostroph
/*
Text '''' == '
Text '''''' == ''
Text '''''''' == '''
Text '''ein Apostroph am Anfang'
Text 'ein Apostroph am Ende'''
Text 'ein Apostroph '' in der Mitte'
Text ''' vier '' Apostrophen '' verteilt'''
Text '''\\'''
*/
if (cnt > 1) {
text = "";
for (int i = 0; i < cnt; i++) {
// da der ganze String in ' eingeschlossen wird,
// müssen die Apostrophen verdoppelt werden.
if (i == 0) {
if (t[i]) text += t[i];
}
else if (i) text += "''" + t[i];
}
}
if (leading) sprintf(h, "CHANGE SIZE %.0f;\nTEXT '%c%s' %s (%.4f %.4f);\n", thigh, leading, text, TextAlignRotation, tx, ty);
else sprintf(h, "CHANGE SIZE %.0f;\nTEXT '%s' %s (%.4f %.4f);\n", thigh, text, TextAlignRotation, tx, ty);
Imp_Cmd+=h;
return;
}
string imp_secondstr(string line, string w) { // return the rest of string after word
int pos = strstr(line, w) + strlen(w)+1;
return strsub(line, pos);
}
void imp_text(string l) {
string s[];
int cnt = strsplit(s, l, ' ');
// berechne den wirklichen Anfang des "Textes"
// TEXT -16 512 Left 2 A A A A
int textbegin = strlen(s[0]) + strlen(s[1]) + strlen(s[2]) + strlen(s[3]) + strlen(s[4]) + 5; // 5 = 5 Spaces
string text = strsub(l, textbegin);
TextAlignRotation = "R0";
if (s[3] == "Center") {
sprintf(TextAlign, "change align Center;\n");
}
else if(s[3] == "Left") {
sprintf(TextAlign, "change align Center Left;\n");
}
else if(s[3] == "Right") {
sprintf(TextAlign, "change align Center Right;\n");
}
else if(s[3] == "Top") {
sprintf(TextAlign, "change align Center Top;\n");
}
else if(s[3] == "Bottom") {
sprintf(TextAlign, "change align Center Bottom;\n");
}
else if(s[3] == "VLeft") { // 90<39>gedreht
sprintf(TextAlign, "change align Center Left;\n");
TextAlignRotation = "R90";
}
else if(s[3] == "VRight") { // 90<39>gedreht
sprintf(TextAlign, "change align Center Right;\n");
TextAlignRotation = "R90";
}
else if (s[3] == "VCenter") { // 90<39>gedreht
sprintf(TextAlign, "change align Center;\n");
TextAlignRotation = "R90";
}
else if(s[3] == "VTop") { // 90<39>gedreht
sprintf(TextAlign, "change align Center Top;\n");
TextAlignRotation = "R90";
}
else if(s[3] == "VBottom") { // 90! gedreht
sprintf(TextAlign, "change align Center Bottom;\n");
TextAlignRotation = "R90";
}
else {
dlgMessageBox("Unknown Text justification:" + s[3] + "\n" + Imp_SymDevName + "\n" + l, "ok", "esc");
exit(-2485);
}
Imp_Cmd+=TextAlign;
real texthigh = LTTextSize;
real textoffsety = 0;
real textoffsetx = 0;
char leadingcharacter = 0;
if (text[0] == ';') {
Imp_Cmd += "CHanGe Layer 94;\n";
}
else if (text[0] == '!') { // check spice directive
Imp_Cmd += "CHanGE Layer 97;\n";
leadingcharacter = '\\'; // Einleitendes Ausrufezeichen als Sonderzeichen definieren, da Eagle sonst den Text überstreicht.
}
imp_print_text(texthigh, leadingcharacter, text, imp_eagle_coordvalue(strtod(s[1])), imp_eagle_coordvalue(strtod(s[2])*-1.0)); // in LT-Spice ist die Y-Achse auf den Kopf gestellt
return;
}
void imp_window_sym(string l, int line) {
string s[];
int n = strsplit(s, l, ' ');
int winattrib = strtod(s[1]);
string h = "";
switch(winattrib) {
case 0 : Imp_Winattrib[0] = "0"; // InstName // WINDOW 0 273 -48 Bottom 2
sprintf(h, "Change Layer 95;\nChange Size 70mil;\nTexT '>NAME' (%.4f %.4f);\n", imp_eagle_coordvalue(strtod(s[2])), imp_eagle_coordvalue(strtod(s[3])*-1.0));
Imp_Cmd += h;
break;
case 1 : Imp_Winattrib[1] = "1"; // Type
sprintf(h, "Change Layer 97;\nChange Size 10mil;\nTexT 'win1' (%.4f %.4f);\n", imp_eagle_coordvalue(strtod(s[2])), imp_eagle_coordvalue(strtod(s[3])*-1.0));
Imp_Cmd += h;
break;
case 2 : Imp_Winattrib[2] = "2";
sprintf(h, "Change Layer 97;\nChange Size 10mil;\nTexT 'win2' (%.4f %.4f);\n", imp_eagle_coordvalue(strtod(s[2])), imp_eagle_coordvalue(strtod(s[3])*-1.0));
Imp_Cmd += h;
break;
case 3 : Imp_Winattrib[3] = "3"; // Value // WINDOW 3 0 151 Center 0
sprintf(h, "Change Layer 96;\nChange Size 70mil;\nTexT '>VALUE' (%.4f %.4f);\n", imp_eagle_coordvalue(strtod(s[2])), imp_eagle_coordvalue(strtod(s[3])*-1.0));
Imp_Cmd += h;
break;
case 38 : Imp_Winattrib[38] = "38"; // SpiceModel // WINDOW 38 0 32 Center 0
Imp_SpiceModelSymX = imp_eagle_coordvalue(strtod(s[2]));
Imp_SpiceModelSymY = imp_eagle_coordvalue(strtod(s[3])*-1.0);
Imp_SpiceModelSymAlign = s[4];
Imp_SpiceModelSymOffset = imp_eagle_coordvalue(strtod(s[5]));
if (Imp_SpiceModelSymAlign != "Center") if (dlgMessageBox(l + "\error 2246", "OK", "CANCEL") != 0) exit(-2538);
break;
case 39 : Imp_Winattrib[39] = "39"; // SpiceLine // WINDOW 39 273 154 Center 2
Imp_SpiceLineSymX = imp_eagle_coordvalue(strtod(s[2]));
Imp_SpiceLineSymY = imp_eagle_coordvalue(strtod(s[3])*-1.0);
Imp_SpiceLineSymAlign = s[4];
Imp_SpiceLineSymOffset = imp_eagle_coordvalue(strtod(s[5]));
break;
case 40 : Imp_Winattrib[40] = "40"; // SpiceLine2
Imp_SpiceLine2SymX = imp_eagle_coordvalue(strtod(s[2]));
Imp_SpiceLine2SymY = imp_eagle_coordvalue(strtod(s[3])*-1.0);
Imp_SpiceLine2SymAlign = s[4];
Imp_SpiceLine2SymOffset = imp_eagle_coordvalue(strtod(s[5]));
break;
case 123 : Imp_Winattrib[123] = "123"; // Value2
sprintf(h, "Change Layer 96;\nChange Size 70mil;\nTexT '>VALUE2' (%.4f %.4f);\n", // Attribute Platzhalter
imp_eagle_coordvalue(strtod(s[2])), imp_eagle_coordvalue(strtod(s[3])*-1.0)
);
Imp_Cmd += h;
break;
default : sprintf(h, "File:%s\nUnknown window attribute \"%s\" in line :%d\n%s", Imp_SymDevName, s[1], line+1, l);
if (dlgMessageBox(h, "OK", "CANCEL") != 0) exit(-2563);
}
return;
}
void attribute2script(string at, string symbolfile, string mode) {
output(filesetext(symbolfile, ".scr"), mode) {
printf("%s", at);
}
return;
}
string imp_symattr_sym(string l, int cnt, string source) {
/***3
Zu diesem Zeitpunk existiert noch kein Package, also kann man Attribute nur für das Packagelose
Device anlegen!
Das anlegen einer Package-Variante, löscht die Attribute, die keinem Package zugeordnet sind.
Die Attribute müssen in einem separaten SCRIPT eingetragen werden, daß dann zu gegebenen Zeitpunkt
nach dem erzeugen der Package-Variante gestartet wird.
***3 ***/
string s[];
int n = strsplit(s, l, ' ');
string sy;
if (s[1] == "Prefix") {
Imp_Winattrib[0] = s[2];
sprintf(sy, "ATTRIBUTE SPICEPREFIX '%s';\n", Imp_Winattrib[0]); // 2012-10-04
attribute2script(sy, source, FileAppend); // im Device ablegen ***3
return "";
}
else if (s[1] == "Value") { // Value [3]
Imp_Winattrib[3] = s[2];
attribute2script("VALUE OFF;\n", source, FileAppend); // im Device ablegen ***3
return ""; // im Device ablegen
}
else if (s[1] == "SpiceModel") { // SpiceModel [38]
Imp_Winattrib[38] = s[2];
sprintf(sy, "ATTRIBUTE 'SPICEMODEL' '%s';\n", Imp_Winattrib[38]);
attribute2script(sy, source, FileAppend); // im Device ablegen ***3
return "";
}
else if (s[1] == "SpiceLine") { // SpiceLine Imp_Winattrib[39]
if (Imp_Winattrib[39]) {
sprintf(sy, "Change Layer %d;\nChange Size 70mil;\nCHanGE Align %s;\nTexT 'Spiceline>%s' (%.4f %.4f);\n",
LayerSpiceOrder,
Imp_SpiceLineSymAlign,
imp_secondstr(l, s[1]), // Spiceline : können mehrere Wörter durch Space getrennt sein
Imp_SpiceLineSymX, Imp_SpiceLineSymY
);
Imp_Cmd += sy; // im Symbol ablegen
return "";
}
else {
sprintf(sy, "ATTRIButE 'Spiceline' '%s';\n", // im Device als Attribute ablegen
imp_secondstr(l, s[1]) // Spiceline : können mehrere Wörter durch Space getrennt sein
);
attribute2script(sy, source, FileAppend); // im Device ablegen ***3
return "";
}
}
else if (s[1] == "SpiceLine2") { // SpiceLine2 Winattrib[40]
if (Imp_Winattrib[40]) {
sprintf(sy, "Change Layer %d;\nChange Size 70mil;\nTexT 'Spiceline2>%s' (%.4f %.4f);\n", // im Symbol ablegen
LayerSpiceOrder, imp_secondstr(l, s[1]), // Spiceline2 : können mehrere Wörter durch Space getrennt sein
Imp_SpiceLine2SymX, Imp_SpiceLine2SymY
);
Imp_Cmd+= sy;
return "";
}
else {
sprintf(sy, "ATTRIButE 'Spiceline2' '%s';\n", // im Device als Attribute ablegen
imp_secondstr(l, s[1]) // Spiceline2 : können mehrere Wörter durch Space getrennt sein
);
attribute2script(sy, source, FileAppend); // im Device ablegen ***3
return "";
}
}
else if (s[1] == "Value2") { // Value2 [123]
Imp_Winattrib[123] = imp_secondstr(l, s[1]);
sprintf(sy, "ATTRIBUTE 'VALUE2' '%s'; #2658\n", Imp_Winattrib[123]);
attribute2script(sy, source, FileAppend); // im Device ablegen ***3
return "";
}
else if (s[1] == "Description") {
string descript;
sprintf(descript, "DESCRIPTION '%s'\n", imp_secondstr(l, s[1]));
return descript; // im Device ablegen
}
else if (s[1] == "ModelFile") {
Imp_Winattrib[123] = s[2];
sprintf(sy, "ATTRIBUTE 'ModelFile' '%s'; #2671\n", Imp_Winattrib[123]);
attribute2script(sy, source, FileAppend); // im Device ablegen ***3
return "";
}
else if (s[1] == "DefSubstrate") {
sprintf(sy, "ATTRIBUTE 'DefSubstrate' '%s'; #2676\n", s[2]);
attribute2script(sy, source, FileAppend); // im Device ablegen ***3
return "";
}
sprintf(h, "%s:\nUnknown SYMATTR in line %d:\n%s", source, cnt+1, l);
if (dlgMessageBox(h, "OK", "ESC") != 0) exit(-2670);
return "";
}
string imp_pin(string l) {
string s[];
int n = strsplit(s, l, ' ');
string coord;
if (s[3] == "NONE") { // bedeutet der PIN hat keinen sichbaren Namen
sprintf(coord, "%.4f %.4f\t%.4f %.4f\t%s",
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[1]) + strtod(s[4])), // plus offset
imp_eagle_coordvalue(strtod(s[2])*-1.0),
s[3]
);
}
else if (s[3] == "LEFT") { // bedeutet der PIN steht an der linken Seite und der Name des Pin verschieb sich nach rechts
sprintf(coord, " %.4f %.4f\t%.4f %.4f\t%s",
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[1]) + strtod(s[4])), // plus offset
imp_eagle_coordvalue(strtod(s[2])*-1.0),
s[3]
);
}
else if (s[3] == "RIGHT") {// bedeutet der PIN steh an der rechten Seite und der Name des Pin verschieb sich nach links
sprintf(coord, "%.4f %.4f\t%.4f %.4f\t%s",
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[1]) - strtod(s[4])), // minus offset
imp_eagle_coordvalue(strtod(s[2])*-1.0),
s[3]
);
}
else if (s[3] == "TOP") { // bedeutet der PIN steht an der oberen Seite und der Name des Pin verschieb sich nach unten
sprintf(coord, "%.4f %.4f\t%.4f %.4f)\t%s",
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue((strtod(s[2]) + strtod(s[4]))*-1.0), // plus offset
s[3]
);
}
else if (s[3] == "BOTTOM") { // bedeutet der PIN steht an der unteren Seite und der Name des Pin verschieb sich nach oben
sprintf(coord, "%.4f %.4f\t%.4f %.4f\t%s",
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue((strtod(s[2]) - strtod(s[4]))*-1.0), // minus offset
s[3]
);
}
else {
string e;
sprintf(e, "Unknown '%s' in %s\nerror 2436", s[3], l);
dlgMessageBox(e, "OK");
}
return coord;
}
void imp_pinattr(string l, string coordpin, string coordname, string orientation) {
string s[];
int cnt = strsplit(s, l, ' ');
string k[];
int cntk = strsplit(k, coordname, ' ');
real kx = strtod(k[0]);
real ky = strtod(k[1]);
if (s[1] == "PinName") {
if (cnt > 3) { // Mehr als 3 Teilstrings bedeutet der Pin-Name besteht aus mehreren Teilstrings (Leerzeichen getrennt).
for (int n = 3; n < cnt; n++) { // LTspice läßt im Namen SPACE (Leerzeichen) zu, in Eagle sind SPACE verboten!
s[2] += "_" + s[n];
}
}
Imp_SymPinName = strupr(s[2]); // Pinnamen in Eagle nur in upper case
// Pin name of pin to use with CONNECT
// PINATTR PinName _RST der Unterstrich bedeutet das Negierungszeichen, in Eagle das !
if (Imp_SymPinName[0] == '_') Imp_SymPinName[0] = '!'; // ! das Negierungszeichen in EAGLE
Imp_SymPinName = imp_checkpinname(Imp_SymPinName); // doppelte Pin-Namen dürfen nicht vorkommen.
if (!orientation) {
Imp_Cmd += "CHANGE VISIBLE Off;\n"; // visible Off
sprintf(h, "PIN '%s' PAS NONE POINT (%s);\n", Imp_SymPinName, coordpin);
Imp_Cmd+=h;
}
else if (orientation == "NONE") {
Imp_Cmd += "CHANGE VISIBLE Off;\n"; // visible Off
sprintf(h, "PIN '%s' PAS NONE POINT (%s);\n", Imp_SymPinName, coordpin);
Imp_Cmd+=h;
}
else if (orientation == "LEFT") {
Imp_Cmd += "CHANGE VISIBLE Pin;\n"; // Visible Pin
sprintf(h, "PIN '%s' PAS NONE POINT R0 (%s);\n", Imp_SymPinName, coordpin);
Imp_Cmd+=h;
}
else if (orientation == "RIGHT") {
Imp_Cmd += "CHANGE VISIBLE Pin;\n"; // Visible Pin
sprintf(h, "PIN '%s' PAS NONE POINT R180 (%s);\n", Imp_SymPinName, coordpin);
Imp_Cmd+=h;
}
else if (orientation == "TOP") {
Imp_Cmd += "CHANGE VISIBLE Off;\n"; // Visible Off, der Pinnmaem wir waagerecht als Text erzeugt
sprintf(h, "PIN '%s' PAS NONE POINT R270 (%s);\n", Imp_SymPinName, coordpin);
Imp_Cmd+=h;
sprintf(h, "Change Layer 95;\nChange Align Top Center;\nCHANGE SIZE 60;\nTEXT '%s' R0 (%.4f %.4f);\n", Imp_SymPinName, kx, ky); // 50 ist der Eagle-Offset zum Pinnamen
Imp_Cmd+=h;
}
else if (orientation == "BOTTOM") {
Imp_Cmd += "CHANGE VISIBLE Off;\n"; // Visible Off, der Pinnmaem wir waagerecht als Text erzeugt
sprintf(h, "PIN '%s' PAS NONE POINT R90 (%s);\n", Imp_SymPinName, coordpin);
Imp_Cmd+=h;
sprintf(h, "CHange Layer 95;\nChAnge Align Bottom Center;\nCHANGE SIZE 60;\nTEXT '%s' R0 (%.4f %.4f);\n", Imp_SymPinName, kx , ky); // 50 ist der Eagle-Offset zum Pinnamen
Imp_Cmd+=h;
}
else {
if (dlgMessageBox("Unknown orientation: " + orientation + "\nin line:" + l,"OK", "CANCEL") != 0) exit(-2790);
}
}
else if (s[1] == "SpiceOrder") {
if (coordname) {
sprintf(h, "CHANGE Size 16;\nChange Layer %d;\n", LayerSpiceOrder);
Imp_Cmd+=h;
sprintf(h, "CHANGE Align Center; # SpiceOrder\n");
Imp_Cmd+=h;
sprintf(h, "TEXt '%s %s' (%s);\n", s[1], s[2], coordpin); // SpiceOrder number 2012-06-11
Imp_Cmd+=h;
}
}
return;
}
void imp_dataflag(string l) { // 2012-06-14
string s[];
int cnt = strsplit(s, l, ' ');
string datflag;
sprintf(datflag, "TEXT 'DATAFLAG:%s' (%.6f %.6f);\n",
s[3],
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0) // in LT-Spice ist die Y-Achse auf den Kopf gestellt
);
Imp_Cmd+=datflag;
return;
}
int imp_checkexist_sym(string name) {
if (library) {
library(L) {
L.symbols(S) {
if (S.name == name) return 1;
}
}
}
return 0;
}
int imp_checkexist_dev(string name) {
if (library) {
library(L) {
L.devicesets(DEV) {
if (DEV.name == name) return 1;
}
}
}
return 0;
}
int imp_checkexist_sch(string name) {
string f[];
int cnt = fileglob(f, name);
if (cnt) { dlgMessageBox("Schematic exist:\n" + name, "CANCEL"); exit(-2847); }
return 0;
}
/**************************************************
parse schematic lines
***************************************************/
void imp_sheet(string l) {
string s[];
int cnt = strsplit(s, l, ' ');
s[2] = strupr(s[2]);
sprintf(h, "EDIT .s%s;\nSET WIRE_BEND 0;\nCHANGE STYLE Continuous;\n;", s[1]);
Imp_Cmd+=h;
if (Test) { // nur im Testfall wird der Zeichnungsrahmen übernommen.
sprintf(h, "CHangE LAYER 94;\nWIRE 10 (%.4f %.4f) (%.4f %.4f) (%.4f %.4f);\n# frame\n",
0.0, 0.0,
imp_eagle_coordvalue(strtod(s[2])),
imp_eagle_coordvalue(strtod(s[3])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
0.0, 0.0
);
Imp_Cmd+=h;
}
return;
}
void imp_wire(string l) {
status("WIRE"); // ein Lebenszeichen
if (!Imp_SetWireStyle) {
Imp_Cmd += "CHANGE STYLE Continuous;\n";
Imp_SetWireStyle++;
}
string s[];
int cnt = strsplit(s, l, ' ');
imp_add_wire(strtod(s[1]), strtod(s[2]), strtod(s[3]), strtod(s[4]));
return;
}
void imp_flag(string l) { // NET-Name des Segment, zugleich Supply-Symbol und LABEL
// Die FLAGs 0 und COM werden besonders behandelt,
// hier zeichnet LT-Spice ein Dreieck (Supply) das nach unten zeigt.
// Bei COM (Common/Masse) zeichnet LT-spice eine Pfeilspitze nach unten.
// Alle weiteren FLAGs sind NETz-Namen / LABEL
status("FLAG"); // ein Lebenszeichen
string s[];
int cnt = strsplit(s, l, ' ');
CmdNameLabel+=RememberFlag;
RememberFlag = "";
string coordidirection;
sprintf(coordidirection, "%d %d", strtol(s[1]), strtol(s[2]) );
int flagr = imp_getflagrotate(coordidirection, l); // Supply-Symbole sind in der Nulllage vertical ausgerichtet.
if (!flagr) { // kein NET-Segment mit der gleichen Koordinate gefunden,
// dann platziere ein Supply-Symbol
if (s[3] == "+V") Imp_FlagRotate = 0; // + Symbole nach oben 90<39>
else if (s[3] == "-V") Imp_FlagRotate = 180; // - Symbole nach unten 270<37>
string ltsupplylbr = imp_check_use("lt-supply");
sprintf(h, "Add '%s%s' R%.0f (%.4f %.4f);\n",
s[3], ltsupplylbr,
Imp_FlagRotate,
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0)
);
Imp_Cmd+=h;
return;
}
sprintf(h, "Ein FLAG an Netz %s\n(%.4f %.4f)\nRotation : %.1f ",
s[3],
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0),
Imp_FlagRotate);
//if (dlgMessageBox(h, "ok", "esc") != 0) exit(-2921);
if (s[3] == "0") {
string ltsupplylbr = imp_check_use("lt-supply");
sprintf(h, "aDd '%s%s' R%.0f (%.4f %.4f);\n",
s[3], ltsupplylbr,
Imp_FlagRotate,
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0)
);
Imp_Cmd+=h;
}
else if (s[3] == "COM") {
string ltsupplylbr = imp_check_use("lt-supply");
sprintf(h, "adD '%s%s' R%.0f (%.4f %.4f);\n",
s[3], ltsupplylbr,
Imp_FlagRotate,
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0)
);
Imp_Cmd+=h;
}
// Eagle kann kein LABEL ohne NET setzen,
else {
// Imp_FlagRotate wird in der Funktion imp_getflagrotate() behandelt! 2012-11-05
// Da LTspice die Rotation der FLAGS anahand des letzen Wiresegement berstimmt,
// hier muss die Nullage des Symbol entsptrechend korrigiert werden.
// Typischerweise werden die Spannungen (Pfeile) bei plus nach oben und bei
// minus nach unten angelegt. Dazu muß es für jedes Symbole eine Nulagenkorrektur geben.
// OUT ist nach rechts zeigend angelegt.
if (s[3] == "+V") Imp_FlagRotate -= 180.0;
else if (s[3] == "-V") Imp_FlagRotate -= 180.0;
else if (s[3] == "OUT") Imp_FlagRotate -= 90.0;
string ltsupplylbr = imp_check_use("lt-supply"); // alle benötigten Supply-Symbole müssen in dieser LBR erstellt sein
sprintf(h, "Add '%s%s' R%.0f (%.4f %.4f);\n",
s[3], ltsupplylbr,
Imp_FlagRotate,
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0)
);
Imp_Cmd+=h;
/* 2012-11-05
sprintf(h, "#2582\nSET CONFIRM YES;\nNAME '%s' (%.4f %.4f) ;\n# FLAG\nSET CONFIRM OFF;\n",
s[3],
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0) // in LT-Spice ist die Y-Achse auf den Kopf gestellt
);
RememberFlag += h;
string xrefoption = "OFF";
sprintf(h, "Change size 70;\nCHANGE XREF %s;\nLABEL R%.1f (%.4f %.4f) (%.4f %.4f);\n",
xrefoption,
Imp_FlagRotate - 90.0, // Label sind in der Nulllage horizontal nach rechts ausgerichtet
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0)
);
RememberFlag += h;
*/
}
return;
}
void imp_iopin(string l) {
/*
FLAG 1248 176 BI_Port
IOPIN 1248 176 BiDir
FLAG 1248 144 Input_Port
IOPIN 1248 144 In
FLAG 1248 112 Output_Port
IOPIN 1248 112 Out
*/ string s[];
int n = strsplit(s, l, ' ');
// der IOPIN kommt immer nach dem FLAG, also immer die gleiche Kordinate
sprintf(h, "CHANGE XREF ON;\nLABEL (%.4f %.4f) (%.4f %.4f);\n",
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0), // in LT-Spice ist die Y-Achse auf den Kopf gestellt
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0)
);
CmdNameLabel += h;
RememberFlag = "";
return;
}
string imp_checktextalign(string align) {
TextAlignRotation = "R0";
string textalign = "Left"; // default
if (align == "Center") {
sprintf(textalign, " align Center");
}
else if(align == "Left") {
sprintf(textalign, " align Center Left");
}
else if(align == "Right") {
sprintf(textalign, " align Center Right");
}
else if(align == "Top") {
sprintf(textalign, " align Center Top");
}
else if(align == "Bottom") {
sprintf(textalign, " align Center Bottom");
}
else if(align == "VLeft") { // 90<39>gedreht
sprintf(textalign, " align Center Left");
TextAlignRotation = "R90";
}
else if(align == "VRight") { // 90<39>gedreht
sprintf(textalign, " align Center Right");
TextAlignRotation = "R90";
}
else if (align == "VCenter") { // 90<39>gedreht
sprintf(textalign, " align Center");
TextAlignRotation = "R90";
}
else if(align == "VTop") { // 90<39>gedreht
sprintf(textalign, " align Center Top");
TextAlignRotation = "R90";
}
else if(align == "VBottom") { // 90! gedreht
sprintf(textalign, " align Center Bottom");
TextAlignRotation = "R90";
}
return textalign;
}
string imp_checkempty(string s) {
if (s == "\"\"") return "";
return s;
}
void imp_symbol_sch(string l) { // place a symbol in schematic
/* ******* Ein Lastwiderstand zum simulieren ******
SYMBOL res 864 128 R0
SYMATTR InstName Rload1 *** Rload macht aus einem normalen Widerstand einen Lastwiderstand zum simulieren.
SYMATTR Value .5
SYMBOL eagle\\PNP_LABOR\\BST62 160 176 R0
************************************************* */
Imp_InstanceName = ""; // Reset Instance name
Imp_Cmd += "CHanGe Align Left Center;\n"; // default für Textanordnung von Name/Value
// es kann, aber es muss nicht ein
// WINDOW 0 .... oder WINDOW 3 ... folgen.
Imp_CmdValueV = ""; // Reset Value
Imp_Winattrib[0] = ""; // Reset window attribute
Imp_Winattrib[1] = "";
Imp_Winattrib[3] = "";
Imp_Winattrib[38] = "";
Imp_Winattrib[39] = "";
Imp_Winattrib[40] = "";
Imp_Winattrib[123] = "";
string s[];
int cnt = strsplit(s, l, ' ');
AddPart = s[1];
status(AddPart); // ein Lebenszeichen
Imp_InstCoordX = imp_eagle_coordvalue(strtod(s[2]));
Imp_InstCoordY = imp_eagle_coordvalue(strtod(s[3])*-1.0); // in LT-Spice ist die Y-Achse auf den Kopf gestellt
AddPartOrientation = s[4];
string libpart[];
cnt = strsplit(libpart, s[1], '\\'); // == "eagle\\PNP_LABOR\\BST62"
if (cnt > 1) { // Wenn ein doppelter Backslash vor kommt, dann ist der LBR-Name angegeben.
AddPart = libpart[cnt-1]; // Library-name ist mit backslash vom part-name getrennt,
AddPartLib = ""; // es können auch mehr als ein backslash vorkommen,
for (int n = 0; n < cnt-1; n++) { // dann ist der Partname der letzte Teilstring.
if (libpart[n]) AddPartLib = libpart[n]; // 2014-04-03 setze den Pfad auf den vorletzen Teilstring
}
}
else { // dann ist es vermutlich ein Simulations-Symbol
AddPart = libpart[cnt-1];
AddPartLib = "";
}
return;
}
void imp_window_sch(string l, int cnt) {
/* Attribute Window *
InstName 0 -
Type 1 -
SpiceModel 38 +SYMATTR
Value 3 -
Value2 123 -
SpiceLine 39 -
SpiceLine2 40 -
Rotated symbols get windows for parameters relative to the
anchor point of the symbol
*/
string h = "";
string s[];
int n = strsplit(s, l, ' ');
int winattrib = strtod(s[1]);
switch(winattrib) {
case 0 : Imp_Winattrib[0] = "0";
Imp_InstNameSmashX = imp_eagle_coordvalue(strtod(s[2])); // InstName 0 -
Imp_InstNameSmashY = imp_eagle_coordvalue(strtod(s[3])*-1.0);
TextAlignName = s[4];
Imp_InstNameOffset = imp_eagle_coordvalue(strtod(s[5]));
break;
case 1 : Imp_Winattrib[1] = "1"; // Type
dlgMessageBox("WINDOW 1 : Type found", "CANCEL");
exit(-3129);
break;
case 3 : Imp_Winattrib[3] = "3";
Imp_InstValueSmashX = imp_eagle_coordvalue(strtod(s[2])); // Value 3 -
Imp_InstValueSmashY = imp_eagle_coordvalue(strtod(s[3])*-1.0);
TextAlignValue = s[4];
Imp_InstValueOffset = imp_eagle_coordvalue(strtod(s[5]));
break;
case 38 : Imp_Winattrib[38] = "38";
Imp_SpiceModelSmashX = imp_eagle_coordvalue(strtod(s[2])); // SpiceModel 38 +SYMATTR
Imp_SpiceModelSmashY = imp_eagle_coordvalue(strtod(s[3])*-1.0);
break;
case 39 : Imp_Winattrib[39] = "39"; // WINDOW 39 273 154 Center 2
Imp_SpiceLineSmashX = imp_eagle_coordvalue(strtod(s[2])); // SpiceLine 39 -
Imp_SpiceLineSmashY = imp_eagle_coordvalue(strtod(s[3])*-1.0);
TextAlignSpiceLine = s[4];
Imp_SpiceLineSymOffset = imp_eagle_coordvalue(strtod(s[5]));
break;
case 40 : Imp_Winattrib[40] = "40";
Imp_SpiceLine2SmashX = imp_eagle_coordvalue(strtod(s[2])); // SpiceLine2 40 -
Imp_SpiceLine2SmashY = imp_eagle_coordvalue(strtod(s[3])*-1.0);
TextAlignSpiceLine2 = s[4];
Imp_SpiceLine2SymOffset = imp_eagle_coordvalue(strtod(s[5]));
break;
case 123 : Imp_Winattrib[123] = "123"; // WINDOW 123 24 146 Left 0
Imp_InstValue2SmashX = imp_eagle_coordvalue(strtod(s[2])); // Value2 123 -
Imp_InstValue2SmashY = imp_eagle_coordvalue(strtod(s[3])*-1.0);
TextAlignValue2 = s[4];
Imp_InstValue2Offset = imp_eagle_coordvalue(strtod(s[5]));
break;
default : dlgMessageBox("!Unknown window attribute:\n"+ l, "OK");
}
// <offset>
if (s[5] != "0") {
sprintf(h, "# %s:\n\# <offset> %s in Line %d:%s\n", ImpSpiceSchematicAsc, s[5] , cnt+1, l );
Imp_Cmd+=h;
}
return;
}
string imp_getTextOrientation( string instancename, string textholder, string textalign, string addpartorientation, real instcoordX, real instcoordY, real insttextsmashX, real insttextsmashY ) {
string os;
real nameposx, nameposy;
if (addpartorientation == "R0") {
nameposx = instcoordX + insttextsmashX;
nameposy = instcoordY + insttextsmashY;
}
else if (addpartorientation == "R90") {
nameposx = instcoordX + insttextsmashY; // wegen der 90<39>Grad
nameposy = instcoordY - insttextsmashX; // muß der für den Offset X und Y getauscht werden
}
else if (addpartorientation == "R180") {
nameposx = instcoordX - insttextsmashX;
nameposy = instcoordY - insttextsmashY;
}
else if (addpartorientation == "R270") {
nameposx = instcoordX - insttextsmashY; // wegen der 270 Grad-Drehung muß der Offset X und Y getauscht werden
nameposy = instcoordY + insttextsmashX;
}
// mirrored
else if (addpartorientation == "M0") {
nameposx = instcoordX - insttextsmashX;
nameposy = instcoordY + insttextsmashY;
}
else if (addpartorientation == "M90") {
nameposx = instcoordX - insttextsmashY; // wegen der 90<39>Grad
nameposy = instcoordY - insttextsmashX; // muß der für den Offset X und Y getauscht werden
}
else if (addpartorientation == "M180") {
nameposx = instcoordX + insttextsmashX;
nameposy = instcoordY - insttextsmashY;
}
else if (addpartorientation == "M270") {
nameposx = instcoordX + insttextsmashY; // wegen der 270 Grad
nameposy = instcoordY + insttextsmashX; // muß der für den Offset X und Y getauscht werden
}
sprintf(h, ";\nMOVe %s>%s (%.4f %.4f); #3229\n",
strupr(instancename), textholder, nameposx, nameposy
);
os += h;
string alignorientation;
// text align kann bisher nur mit Hilfe der Koordinaten erfolgen
if (textalign == "Center") {
sprintf(alignorientation, "Center");
if (addpartorientation == "R0") {
sprintf(h, "ROTATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R0 Name Center\n
}
else if (addpartorientation == "R90") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R90<39>Name Center\n
}
else if (addpartorientation == "R180") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # R180 Name Center\n
}
else if (addpartorientation == "R270") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R270 Name Center\n
}
if (addpartorientation == "M0") {
sprintf(h, "ROTATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # M0 Name Center\n
}
else if (addpartorientation == "M90") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M90<39>Name Center\n
}
else if (addpartorientation == "M180") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # M180 Name Center\n
}
else if (addpartorientation == "M270") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M270 Name Center\n
}
os += h;
}
else if(textalign == "Left") {
sprintf(alignorientation, "Bottom Left"); // 2012-07-09 Center Left
if (addpartorientation == "R0") {
sprintf(h, "rOTATe =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R0 Name Left\n
}
else if (addpartorientation == "R90") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # R90<39>Name Left\n
}
else if (addpartorientation == "R180") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # R180 Name Left\n
}
else if (addpartorientation == "R270") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R270 Name Left\n
}
if (addpartorientation == "M0") {
sprintf(h, "ROTATE =MR0 %s>%s ;\n", strupr(instancename), textholder) ; // # M0 Name Left\n
}
else if (addpartorientation == "M90") {
sprintf(h, "ROTATE =MR270 %s>%s ;\n", strupr(instancename), textholder) ; // # M90<39>Name Left\n
}
else if (addpartorientation == "M180") {
sprintf(h, "roTATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # M180 Name Left\n
}
else if (addpartorientation == "M270") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M270 Name Left\n
}
os += h;
}
else if(textalign == "Right") {
sprintf(alignorientation, "Center Right");
if (addpartorientation == "R0") {
sprintf(h, "RoTATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R0 Name Right\n
}
else if (addpartorientation == "R90") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # R90<39>Name Right\n
}
else if (addpartorientation == "R180") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # R180 Name Right\n
}
else if (addpartorientation == "R270") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R270 Name Right\n
}
if (addpartorientation == "M0") {
sprintf(h, "ROTATE =MR0 %s>%s ;\n", strupr(instancename), textholder) ; // # M0 Name Right\n
}
else if (addpartorientation == "M90") {
sprintf(h, "ROTATE =MR270 %s>%s ;\n", strupr(instancename), textholder) ; // # M90<39>Name Right\n
}
else if (addpartorientation == "M180") {
sprintf(h, "RotATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # M180 Name Right\n
}
else if (addpartorientation == "M270") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M270 Name Right\n
}
os += h;
}
else if(textalign == "Top") {
sprintf(alignorientation, "Center Top");
if (addpartorientation == "R0") {
sprintf(h, "ROtATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R0 Name Top\n
}
else if (addpartorientation == "R90") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # R90<39>Name Top\n
}
else if (addpartorientation == "R180") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # R180 Name Top\n
}
else if (addpartorientation == "R270") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R270 Name Top\n
}
if (addpartorientation == "M0") {
sprintf(h, "ROtaTE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # M0 Name Top\n
}
else if (addpartorientation == "M90") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M90<39>Name Top\n
}
else if (addpartorientation == "M180") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # M180 Name Top\n
}
else if (addpartorientation == "M270") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # M270 Name Top\n
}
os += h;
}
else if(textalign == "Bottom") {
sprintf(alignorientation, "Center Bottom");
if (addpartorientation == "R0") {
sprintf(h, "ROTaTE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R0 Name Bottom\n
}
else if (addpartorientation == "R90") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # R90<39>Name Bottom\n
}
else if (addpartorientation == "R180") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # R180 Name Bottom\n
}
else if (addpartorientation == "R270") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R270 Name Bottom\n
}
if (addpartorientation == "M0") {
sprintf(h, "ROTatE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # M0 Name Bottom\n
}
else if (addpartorientation == "M90") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M90<39>Name Bottom\n
}
else if (addpartorientation == "M180") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # M180 Name Bottom\n
}
else if (addpartorientation == "M270") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # M270 Name Bottom\n
}
os += h;
}
else if(textalign == "VLeft") { // 90<39>gedreht
sprintf(alignorientation, "Center Left");
if (addpartorientation == "R0") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R0 Name VLeft\n
}
else if (addpartorientation == "R90") {
sprintf(h, "ROTAtE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R90<39>Name VLeft\n
}
else if (addpartorientation == "R180") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # R180 Name VLeft\n
}
else if (addpartorientation == "R270") {
sprintf(h, "ROTATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R270 Name VLeft\n
}
if (addpartorientation == "M0") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M0 Name VLeft\n
}
else if (addpartorientation == "M90") {
sprintf(h, "ROTATE =MR0 %s>%s ;\n", strupr(instancename), textholder) ; // # M90<39>Name VLeft\n
}
else if (addpartorientation == "M180") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # M180 Name VLeft\n
}
else if (addpartorientation == "M270") {
sprintf(h, "ROTAte =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # M270 Name VLeft\n
}
os += h;
}
else if(textalign == "VRight") { // 90<39>gedreht
sprintf(alignorientation, "Center Right");
if (addpartorientation == "R0") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R0 Name VRight\n
}
else if (addpartorientation == "R90") {
sprintf(h, "rOtATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R90<39>Name VRight\n
}
else if (addpartorientation == "R180") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # R180 Name VRight\n
}
else if (addpartorientation == "R270") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # R270 Name VRight\n
}
if (addpartorientation == "M0") {
sprintf(h, "ROTATE =MR90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M0 Name VRight\n
}
else if (addpartorientation == "M90") {
sprintf(h, "ROTATE =MR0 %s>%s ;\n", strupr(instancename), textholder) ; // # M90<39>Name VRight\n
}
else if (addpartorientation == "M180") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # M180 Name VRight\n
}
else if (addpartorientation == "M270") {
sprintf(h, "ROTATE =MR180 %s>%s ;\n", strupr(instancename), textholder) ; // # M270 Name VRight\n
}
os += h;
}
else if (textalign == "VCenter") { // 90<39>gedreht
sprintf(alignorientation, "Center");
if (addpartorientation == "R0") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R0 Name VCenter\n
}
else if (addpartorientation == "R90") {
sprintf(h, "ROTATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R90<39>Name VCenter\n
}
else if (addpartorientation == "R180") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # R180 Name VCenter\n
}
else if (addpartorientation == "R270") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # R270 Name VCenter\n
}
if (addpartorientation == "M0") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M0 Name VCenter\n
}
else if (addpartorientation == "M90") {
sprintf(h, "ROTATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # M90<39>Name VCenter\n
}
else if (addpartorientation == "M180") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # M180 Name VCenter\n
}
else if (addpartorientation == "M270") {
sprintf(h, "ROTATE =MR180 %s>%s ;\n", strupr(instancename), textholder) ; // # M270 Name VCenter\n
}
os += h;
}
else if(textalign == "VTop") { // 90<39>gedreht
sprintf(alignorientation, "Center Top");
if (addpartorientation == "R0") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R0 Name VTop\n
}
else if (addpartorientation == "R90") {
sprintf(h, "ROTATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R90<39>Name VTop\n
}
else if (addpartorientation == "R180") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # R180 Name VTop\n
}
else if (addpartorientation == "R270") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # R270 Name VTop\n
}
if (addpartorientation == "M0") {
sprintf(h, "ROTATE =MR90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M0 Name VTop\n
}
else if (addpartorientation == "M90") {
sprintf(h, "ROTATE =MR0 %s>%s ;\n", strupr(instancename), textholder) ; // # M90<39>Name VTop\n
}
else if (addpartorientation == "M180") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M180 Name VTop\n
}
else if (addpartorientation == "M270") {
sprintf(h, "ROTATE =MR180 %s>%s ;\n", strupr(instancename), textholder) ; // # M270 Name VTop\n
}
os += h;
}
else if(textalign == "VBottom") { // 90<39> gedreht
sprintf(alignorientation, "Center Bottom");
if (addpartorientation == "R0") {
sprintf(h, "ROTATE =R90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # R0 Name VBottom\n
}
else if (addpartorientation == "R90") {
sprintf(h, "ROTATE =R0 %s>%s ;\n", strupr(instancename), textholder) ; // # R90<39>Name VBottom\n
}
else if (addpartorientation == "R180") {
sprintf(h, "ROTATE =R270 %s>%s ;\n", strupr(instancename), textholder) ; // # R180 Name VBottom\n
}
else if (addpartorientation == "R270") {
sprintf(h, "ROTATE =R180 %s>%s ;\n", strupr(instancename), textholder) ; // # R270 Name VBottom\n
}
if (addpartorientation == "M0") {
sprintf(h, "ROTATE =MR90<39>%s>%s ;\n", strupr(instancename), textholder) ; // # M0 Name VBottom\n
}
else if (addpartorientation == "M90") {
sprintf(h, "ROTATE =MR0 %s>%s ;\n", strupr(instancename), textholder) ; // # M90<39>Name VBottom\n
}
else if (addpartorientation == "M180") {
sprintf(h, "ROTATE =MR270 %s>%s ;\n", strupr(instancename), textholder) ; // # M180 Name VBottom\n
}
else if (addpartorientation == "M270") {
sprintf(h, "ROTATE =MR180 %s>%s ;\n", strupr(instancename), textholder) ; // # M270 Name VBottom\n
}
os += h;
}
sprintf(h, "Change Align %s (%.4f %.4f);\n", alignorientation, nameposx, nameposy) ; // # Name\n
os += h;
return os;
}
void imp_symattr_sch(string l, int cnt) {
/* Attribute Window *
InstName 0 -
Type 1 -
SpiceModel 38 +SYMATTR
Value 3 -
Value2 123 -
SpiceLine 39 -
SpiceLine2 40 -
Rotated symbols get windows for parameters relative to the
anchor point of the symbol
*/
string s[];
int sn = strsplit(s, l, ' ');
string addpartorient;
if (s[1] == "InstName") { // Imp_Winattrib[0]
Imp_InstanceName = s[2];
int rload = strstr(Imp_InstanceName, "Rload");
if (!rload) { // hier nur ein Simulations-Symbol laden
AddPart += Imp_RloadExtention; // "_RLOAD";
//AddPartLib = SpiceSimulationLbr; /**** ACHTUNG: die LBR darf nicht in der USE-Liste aufgeführt sein! ****/
if (Test) if (dlgMessageBox("Ein Simulationswiderstand wird geladen.\n" + l + "\n" + Imp_InstanceName + ":" + SpiceSimulationLbr, "ok", "esc") != 0) exit(-3540);
}
else {
int Vsym = strstr(Imp_InstanceName, "V");
/* Hier gibt es ein Missverständnis wegen dem Prefix V
eine BATTRY wird in LT SPice auch mit V bezeichnet! */
// *** es wird nicht immer die LBR angegeben siehe LTC4000 *** if (!AddPartLib) AddPartLib = "sym"; // set library on USE-list
}
/* *** Im ADD-Menu muss das Flag SMD aktiv sein, sonst findet das Script die Devices nicht! *** */
AddPartLib = imp_check_use(AddPartLib);
if(AddPartOrientation == "R0") addpartorient = "R0";
else if(AddPartOrientation == "R90") addpartorient = "R270";
else if(AddPartOrientation == "R180") addpartorient = "R180";
else if(AddPartOrientation == "R270") addpartorient = "R90";
else if(AddPartOrientation == "M0") addpartorient = "MR0";
else if(AddPartOrientation == "M90" ) addpartorient = "MR270";
else if(AddPartOrientation == "M180") addpartorient = "MR180";
else if(AddPartOrientation == "M270" ) addpartorient = "MR90";
sprintf(h, "AdD '%s%s' '%s' %s (%.4f %.4f) ;\n", // wegen der Package-Varianten ist es evtl. besser wenn man mit Joker * sucht?!
AddPart, AddPartLib, // Leider nein, da es CAP & CAP[METER], RES & RES[2], IND & IND[2] und
strupr(Imp_InstanceName), // sontige gleichlautende Symbole gibt!
addpartorient,
Imp_InstCoordX,
Imp_InstCoordY
);
Imp_Cmd += h;
sprintf(h, "SMASH %s;\n", strupr(Imp_InstanceName)); // Smash kann jetzt schon mit >Name erfolgen.
Imp_Cmd += h;
if (Imp_CmdPartValue) {
sprintf(h, "VALUE '%s' '%s'; #3586\n", strupr(Imp_InstanceName), Imp_CmdPartValue);
Imp_Cmd += h;
Imp_CmdPartValue = ""; // wieder leeren, damit der Value nicht mehrfach zugewiesen wird.
}
if (Imp_Winattrib[0]) { // WINDOW 0 == InstName
Imp_Cmd += imp_getTextOrientation( Imp_InstanceName, "NAME", TextAlignName, AddPartOrientation, Imp_InstCoordX, Imp_InstCoordY, Imp_InstNameSmashX, Imp_InstNameSmashY);
/**** LTSpice weist den InstancNamen mal vor, mal nach dem Value zu! ****/
if (Imp_CmdPartValue) {
sprintf(h, "VALUE '%s' '%s'; #3596\n", strupr(Imp_InstanceName), Imp_CmdPartValue);
Imp_Cmd += h;
Imp_CmdPartValue = "";
}
if (Imp_CmdValueV) { // Dadurch ergeben sich Probleme bei der Scriptausführung was
// die Zuweisung der Attribute (wie VALUE) betrifft.
// Trenne die Kommandos bei dem Zeichen '>' und füge die entsprechenden
// Instance-namen ein. ***###***
string vs[];
int vn = strsplit(vs, Imp_CmdValueV, '>');
Imp_CmdValueV = vs[0] + strupr(Imp_InstanceName) +">" + vs[1]; // Füge für das '>' den InstanceName ein!
int n = 2;
while (vs[n]) {
Imp_CmdValueV += strupr(Imp_InstanceName) + ">" + vs[n]; // Füge für das '>' den InstanceName plus '>' ein!
n++;
}
Imp_Cmd += Imp_CmdValueV; // In LTspice kann das Attribute Value vor der Zuweisung des Namen kommen,
// dann gibt es diverse Probleme bei der Zuordnung der Attribute über Koordinaten!
// Deshalb erst den Namen zuweisen, dann alle anderen Attribute!
Imp_CmdValueV = ""; // Reset Value-Attribute
}
string v[];
if (Imp_CmdValue2) { // [123] LTspice weist auch ein Attribute zu, bevor der Instancename bekannt ist!
strsplit(v, Imp_CmdValue2, '>');
string displayonoff = "OFF";
if (Imp_Winattrib[123]) displayonoff = "Value"; // 2012-12-17
sprintf(h, "ChAngE Display %s;\nATTRIBUTE '%s' %s%s>%s%s>%s\n", displayonoff, strupr(Imp_InstanceName), v[0], strupr(Imp_InstanceName), v[1], strupr(Imp_InstanceName), v[2]); // füge den jetzt bekannten Instanc Name ein
Imp_Cmd += h;
Imp_CmdValue2 = ""; // für das nächste Symbol/Instance wieder leeren!
}
if (Imp_MemSpiceline) { // [39] 2012-12-17
strsplit(v, Imp_MemSpiceline, '>');
string displayonoff = "OFF";
if (Imp_Winattrib[38]) displayonoff = "Value";
sprintf(h, "ChAngE Display %s;\nATTRIBUTE %s SPICELINE '%s';\nMOvE %s>SPICELINE %s;\nCHange Align %s %s;\n", // 2012-12-17 Display off
displayonoff,
strupr(Imp_InstanceName),
v[0],
strupr(Imp_InstanceName),
v[1],
v[2],
v[1]
); // füge den jetzt bekannten Instance Namen ein
Imp_Cmd += h;
Imp_Cmd += "ChAngE Display Off; #3642\n"; // 2012-10-11
Imp_MemSpiceline = "";
}
if (Imp_MemSpiceline2) {
strsplit(v, Imp_MemSpiceline2, '>');
sprintf(h, "ChaNgE Display Value;\nATTRIBUTE %s SPICELINE2 '%s';\nMOVE %s>SPICELINE2 %s;\nCHange Align %s %s;\n",
strupr(Imp_InstanceName),
v[0],
strupr(Imp_InstanceName),
v[1],
v[2],
v[1]
); // füge den jetzt bekannten Instance Namen ein
Imp_Cmd += h;
Imp_Cmd += "ChAngE Display Off; #3656\n"; // 2012-10-11
Imp_MemSpiceline2 = "";
}
return;
}
}
// SYMATTR Value 100%
else if (s[1] == "Value") {
if (Imp_InstanceName) { // LTSpice weist den Instance-Namen mal vor mal nach dem Value zu!
sprintf(h, "VALUE '%s' '%s';\n", strupr(Imp_InstanceName), imp_checkempty(imp_secondstr(l, s[1])));
Imp_Cmd += h;
}
else {
sprintf(Imp_CmdPartValue, "%s", imp_secondstr(l, s[1]));
}
if (Imp_Winattrib[3]) { // WINDOW 3 == Value
Imp_CmdValueV += imp_getTextOrientation( Imp_InstanceName, "VALUE", TextAlignValue, AddPartOrientation, Imp_InstCoordX, Imp_InstCoordY, Imp_InstValueSmashX, Imp_InstValueSmashY);
if (Imp_InstanceName) {
Imp_Cmd += Imp_CmdValueV;
Imp_CmdValueV = "";
}
}
return;
}
// SYMATTR Value2 X2
else if (s[1] == "Value2") { // [123] 2012-12-17
string displayonoff = "OFF";
if (Imp_Winattrib[123]) displayonoff = "Value";
if (Imp_InstanceName) {
sprintf(h, "Change Display %s;\nATTRIBUTE '%s' 'VALUE2' '%s';\n#3557\n", displayonoff, strupr(Imp_InstanceName), imp_secondstr(l, s[1]));
Imp_Cmd += h;
}
else {
// da noch kein InstanceName definiert ist, das Attribute zwischenmerken!
sprintf(Imp_CmdValue2, " 'VALUE2' '%s';\n#3562\n", imp_secondstr(l, s[1]));
}
Imp_CmdValue2 += imp_getTextOrientation( Imp_InstanceName, strupr(s[1]), TextAlignValue2, AddPartOrientation, Imp_InstCoordX, Imp_InstCoordY, Imp_InstValue2SmashX, Imp_InstValue2SmashY);
/********************************************/
if (Imp_InstanceName) {
Imp_Cmd += Imp_CmdValue2; // Ist der Name noch nicht zugewiesen, dann erfolgt die Zuweisung des Value
Imp_CmdValue2 = ""; // mit dem Namen. Die Befehlssequenz wird entsprechend nachbearbeitet. ******
}
return;
}
else if(s[1] == "SpiceLine") { // [39]
if (Imp_Winattrib[39]) { // wenn es eine Koordinate für das Attribute gibt, dann anzeigen, sonst nur ein Attribute definieren
real spicelineposx, spicelineposy;
if (AddPartOrientation == "R0") {
spicelineposx = Imp_InstCoordX + Imp_SpiceLineSmashX;
spicelineposy = Imp_InstCoordY + Imp_SpiceLineSmashY;
}
else if (AddPartOrientation == "R90") {
spicelineposx = Imp_InstCoordX + Imp_SpiceLineSmashY; // wegen der der 90<39>Drehung muß X und Y getauscht werden
spicelineposy = Imp_InstCoordY - Imp_SpiceLineSmashX;
}
else if (AddPartOrientation == "R180") {
spicelineposx = Imp_InstCoordX - Imp_SpiceLineSmashX;
spicelineposy = Imp_InstCoordY - Imp_SpiceLineSmashY;
}
else if (AddPartOrientation == "R270") { // Verkehrtes Vorzeichen der Y-Achse
spicelineposx = Imp_InstCoordX - Imp_SpiceLineSmashY; // wegen der 270 Grad-Drehung muß der Offset X und Y getauscht werden
spicelineposy = Imp_InstCoordY + Imp_SpiceLineSmashX;
}
else if (AddPartOrientation == "M0") {
spicelineposx = Imp_InstCoordX - Imp_SpiceLineSmashX;
spicelineposy = Imp_InstCoordY + Imp_SpiceLineSmashY;
}
else if (AddPartOrientation == "M90") {
spicelineposx = Imp_InstCoordX - Imp_SpiceLineSmashY;
spicelineposy = Imp_InstCoordY - Imp_SpiceLineSmashX;
}
else if (AddPartOrientation == "M180") {
spicelineposx = Imp_InstCoordX + Imp_SpiceLineSmashX;
spicelineposy = Imp_InstCoordY - Imp_SpiceLineSmashY;
}
else if (AddPartOrientation == "M270") {
spicelineposx = Imp_InstCoordX + Imp_SpiceLineSmashY;
spicelineposy = Imp_InstCoordY + Imp_SpiceLineSmashX;
}
// den Wert des Attribute mit Textplatzhalter anzeigen
sprintf(Imp_MemSpiceline, "%s> (%.4f %.4f)>%s",
imp_secondstr(l, s[1]), // der Value für Spiceline kannen mehrere Wörter durch Space getrennt enthalten
spicelineposx, spicelineposy,
TextAlignSpiceLine
);
}
else {
sprintf(h, "ATTRIBUTE %s %s '%s';\n", strupr(Imp_InstanceName), s[1], imp_secondstr(l, s[1]));
Imp_Cmd += h;
}
return;
}
else if(s[1] == "SpiceLine2") { // [40]
if (Imp_Winattrib[40]) { // wenn es eine Koordinate für das Atrribute gibt, dann anzeigen, sonst nur ein Attribute definieren
real spiceline2posx, spiceline2posy;
if (AddPartOrientation == "R0") {
spiceline2posx = Imp_InstCoordX + Imp_SpiceLine2SmashX;
spiceline2posy = Imp_InstCoordY + Imp_SpiceLine2SmashY;
}
else if (AddPartOrientation == "R90") {
spiceline2posx = Imp_InstCoordX + Imp_SpiceLine2SmashY; // wegen der der 90<39>Drehung muß X und Y getauscht werden
spiceline2posy = Imp_InstCoordY - Imp_SpiceLine2SmashX;
}
else if (AddPartOrientation == "R180") {
spiceline2posx = Imp_InstCoordX - Imp_SpiceLine2SmashX;
spiceline2posy = Imp_InstCoordY - Imp_SpiceLine2SmashY;
}
else if (AddPartOrientation == "R270") { // Verkehrtes Vorzeichen der Y-Achse
spiceline2posx = Imp_InstCoordX - Imp_SpiceLine2SmashY; // wegen der 270 Grad-Drehung muß der Offset X und Y getauscht werden
spiceline2posy = Imp_InstCoordY + Imp_SpiceLine2SmashX;
}
else if (AddPartOrientation == "M0") {
spiceline2posx = Imp_InstCoordX - Imp_SpiceLine2SmashX;
spiceline2posy = Imp_InstCoordY + Imp_SpiceLine2SmashY;
}
else if (AddPartOrientation == "M90") {
spiceline2posx = Imp_InstCoordX - Imp_SpiceLine2SmashY;
spiceline2posy = Imp_InstCoordY - Imp_SpiceLine2SmashX;
}
else if (AddPartOrientation == "M180") {
spiceline2posx = Imp_InstCoordX + Imp_SpiceLine2SmashX;
spiceline2posy = Imp_InstCoordY - Imp_SpiceLine2SmashY;
}
else if (AddPartOrientation == "M270") {
spiceline2posx = Imp_InstCoordX + Imp_SpiceLine2SmashY;
spiceline2posy = Imp_InstCoordY + Imp_SpiceLine2SmashX;
}
// den Wert des Attribute mit Textplatzhalter anzeigen
sprintf(Imp_MemSpiceline2, "%s> (%.4f %.4f)>%s",
imp_secondstr(l, s[1]), // Der Value von Spiceline kann mehrere Wörter durch Space getrennt enthalten
spiceline2posx, spiceline2posy,
TextAlignSpiceLine2
);
}
else {
sprintf(h, "CHANGE Display Off;\nATTRIBUTE %s %s '%s';\n", strupr(Imp_InstanceName), s[1], imp_secondstr(l, s[1]));
Imp_Cmd += h;
}
return;
}
// SYMATTR Description Capacitor
else if(s[1] == "Description") { // kein WINDOW für SYMATTR Description - deshalb die Description im Schaltplan als Attribute anlegen
if (!Imp_InstanceName) {
sprintf(h, "CHANGE Display OFF;\nATTRIBUTE (%.4f %.4f) 'SPICE_DESCRIPTION' '%s';\n", Imp_InstCoordX, Imp_InstCoordY, s[2]); // 2012-12-17
}
else sprintf(h, "CHANGE Display OFF;\nATTRIBUTE '%s' 'SPICE_DESCRIPTION' '%s';\n", strupr(Imp_InstanceName), s[2]);
Imp_Cmd += h;
return;
}
// SYMATTR Type cap
else if(s[1] == "Type") {
if (!Imp_InstanceName) {
sprintf(h, "ATTRIBUTE (%.4f %.4f) 'SpiceType' '%s';\n", Imp_InstCoordX, Imp_InstCoordY, s[2]);
}
else sprintf(h, "ATTRIBUTE '%s' 'SpiceType' '%s';\n", strupr(Imp_InstanceName), s[2]);
Imp_Cmd += h;
return;
}
return;
}
void imp_bustap(string l) {
if (!Imp_WireChecked) {
imp_get_net_segment(); // nachdem alle Wire gesammelt wurden, müssen die Segmente ermittelt werden
}
// BUSTAP 864 208 880 208
string s[];
int n = strsplit(s, l, ' ');
imp_check_bus(strtod(s[1]), strtod(s[2])); // Die erste Koordinate ist der Anschluss an den BUS,
// die zweite Koordinate an das Netz.
sprintf(h, "NET (%.4f %.4f)(%.4f %.4f);\n", // zeichne das fehlende NET-Stück.
imp_eagle_coordvalue(strtod(s[1])),
imp_eagle_coordvalue(strtod(s[2])*-1.0),
imp_eagle_coordvalue(strtod(s[3])),
imp_eagle_coordvalue(strtod(s[4])*-1.0)
);
Imp_Cmd += h;
return;
}
void call_system(string exportfile) { // DOS comand execute
string syscommand;
// Das executable und der Dateiname müssen in " " eingeschlossen werden, wegen Spaces im Pfad-Dateinamen!
sprintf(syscommand, "\"%s\" \"%s\"", lash2backslash(LTSpiceExecute), lash2backslash(exportfile));
system(syscommand); // externes Programm starten
return;
}
/****** IMPORT SETUP MENU ******/
void imp_setupmenu(void) {
int editspicesym = 0;
int editspicesch = 0;
int fImport_All_Symbols = strtol(Import_All_Symbols);
int fExternalSymbol = strtol(ExternalSymbol);
dlgDialog("LT-Spice import") {
dlgHBoxLayout dlgSpacing(600);
if (library) { /*** SYMBOL ***/
//library(L) NewLbrName = L.name;
if (!SpiceSymbol) {
SpiceSymbol = LTSpiceLibDir + "*.asy";
}
FileSpiceSym[0] = SpiceSymbol;
dlgGridLayout {
dlgCell( 1, 1) dlgLabel("Directory of Eagle connect scrips");
dlgCell( 1, 2) dlgStringEdit(Imp_ConnectScriptDir);
dlgCell( 2, 1) dlgLabel("LTspice symbol:");
dlgCell( 2, 2) dlgStringEdit(SpiceSymbol);
dlgCell( 2, 3) dlgPushButton("&Browse") {
string mFileSpiceSym = backslash2lash(dlgFileOpen("Select a LTspice symbol", SpiceSymbol, "*.asy"));
if (mFileSpiceSym) {
EagleSpiceLbrDir = filedir(mFileSpiceSym);
SpiceSymbol = mFileSpiceSym;
FileSpiceSym[0] = mFileSpiceSym;
CntFileSpiceSym = 1;
editspicesym = 1;
string f[];
int cntf = strsplit(f, FileSpiceSym[0], '/');
if (cntf > 2) LbrName = f[cntf-2] + ".lbr"; // Bibliotheksname = Verzeichnisname
else LbrName = filesetext(FileSpiceSym[0], ".lbr");
if (Import_All_Symbols) NewLbrName = filedir(NewLbrName) + imp_dirname(SpiceSymbol) + ".lbr";
else NewLbrName = ""; // filedir(NewLbrName) + filesetext(filename(SpiceSymbol), ".lbr");
}
}
dlgCell( 3, 1) ;
dlgCell( 3, 2) dlgCheckBox("Import &all symbols from directory", fImport_All_Symbols) {
if (fImport_All_Symbols) {
NewLbrName = filedir(NewLbrName) + imp_dirname(SpiceSymbol) + ".lbr";
Import_All_Symbols = "1";
}
else {
NewLbrName = ""; // filedir(NewLbrName) + filesetext(filename(SpiceSymbol), ".lbr");
Import_All_Symbols = "";
}
}
dlgCell( 3, 3) ;
dlgCell( 4, 1) ;
dlgCell( 4, 2) dlgCheckBox("Import as simulation &part ( generate ATTRIBUTE _EXTERNAL_ )", fExternalSymbol) imp_helpSimulationSymbols();
dlgCell( 4, 3) ;
dlgCell( 7, 1) dlgLabel("&New EAGLE library name ");
dlgCell( 7, 2) dlgStringEdit(NewLbrName);
dlgCell( 7, 3) dlgPushButton("Br&owse") {
string mNewLbrName = backslash2lash(dlgFileSave("Select a Spice symbol", NewLbrName, "*.lbr"));
if (mNewLbrName) NewLbrName = mNewLbrName;
};
dlgCell( 8, 2) dlgLabel("(<i>let this line empty to import symbol at current lbr.</b>)");
}
}
else if (schematic) { /*** SHEMATIC ***/
string schname;
schematic(SCH) schname = SCH.name;
dlgGridLayout {
dlgCell( 0, 1) dlgLabel(" ");
dlgCell( 0, 2) dlgSpacing(300);
dlgCell( 0, 3) dlgLabel(" ");
/*********************************************************************************
Für LT-Spice gibt es Standard-Symbole (default) die nicht als Datei angelegt sind,
für diese Symbole muß es in Eagle eine entsprechende Bibliothek geben, die exakt
dem Aussehen in LT-Spice entsprechen.
Hier wird der Pfad und Dateiname dieser Bibliothek eingetragen.
**********************************************************************************/
dlgCell( 1 , 1 ) dlgLabel("Spice default symbols");
dlgCell( 1 , 2 ) dlgLabel(SpiceDefaultSymLbr, 1); // = lt-spice-simulation.lbr
//dlgCell( 1 , 3 ) dlgPushButton("B&rowse") {
// string mSpiceDefaultSymLbr = backslash2lash(dlgFileOpen("Select a spice default symbol library", SpiceDefaultSymLbr));
// if (mSpiceDefaultSymLbr) SpiceDefaultSymLbr = mSpiceDefaultSymLbr;
//}
// Die Symbol-LBR für Generatorn, Messgeräte, Lastwiderstände etc.
/*****************************************************************************
Symbole die für die Simulation von Bedeutung sind, müssen in einer Bibliothek
angelegt werden, und mit dem ATTRIBUTE "_EXTERNAL_" versehen sein.
Hier wird der Pfad und Dateiname dieser Bibliothek eingetragen.
******************************************************************************/
dlgCell( 2 , 1 ) dlgLabel("Spice simulation library");
dlgCell( 2 , 2 ) dlgLabel(SpiceSimulationLbr, 1);
//dlgCell( 2 , 3 ) dlgPushButton("&Browse") {
// string mSpiceSimulationLbr = backslash2lash(dlgFileOpen("Select Simuation-Symbol-LBR", SpiceSimulationLbr , "*.lbr"));
// if (mSpiceSimulationLbr) {
// SpiceSimulationLbr = mSpiceSimulationLbr;
// }
//}
dlgCell( 4 , 1 ) dlgLabel("<hr>");
dlgCell( 4 , 2 ) dlgLabel("<hr>");
dlgCell( 4 , 3 ) dlgLabel("<hr>");
dlgCell( 6 , 1 ) dlgLabel("Spice schematic");
dlgCell( 6 , 2 ) dlgStringEdit(ImpSpiceSchematicAsc);
dlgCell( 6 , 3 ) dlgPushButton("&Browse") {
string mImpSpiceSchematicAsc = backslash2lash(dlgFileOpen("Select a spice schematic", ImpSpiceSchematicAsc , "*.asc"));
if (mImpSpiceSchematicAsc) {
ImpSpiceSchematicAsc = mImpSpiceSchematicAsc;
SchName = filedir(schname) + filesetext(filename(mImpSpiceSchematicAsc), ".sch");
string f[];
int exist = fileglob(f, SchName);
if (exist) {
dlgMessageBox("!Schematic '" + SchName + "' exist.", "CANCEL"); exit(-3960);
}
}
}
dlgCell( 7 , 1 ) dlgLabel("Eagle schematic ");
dlgCell( 7 , 2 ) dlgStringEdit(SchName);
dlgCell( 7 , 3 ) dlgPushButton("&Browse") {
string mSchName = backslash2lash(dlgFileOpen("Select eagle schematic", SpiceSimulationLbr , "*.sch"));
if (mSchName) {
SchName = mSchName;
}
}
}
}
else {
dlgMessageBox("!Start this ULP in a schematic or library.", "OK");
exit(-4);
}
dlgHBoxLayout {
dlgPushButton("+OK") {
if (fileext(ImpSpiceSchematicAsc) == ".asc" || fileext(FileSpiceSym[0]) == ".asy") {
if (schematic) {
if (!SchName) SchName = filename(filesetext(ImpSpiceSchematicAsc, ".sch"));
ScriptFile = filesetext(SchName, Imp_ScriptExt);
dlgAccept();
}
else if (library) {
CntFileSpiceSym = fileglob(FileSpiceSym, SpiceSymbol);
dlgAccept();
}
}
else {
if (schematic) dlgMessageBox("Select a LTC schematic file (*.asc) first!", "OK");
else if (library) {
if (fileext(FileSpiceSym[0]) != ".asy" ) dlgMessageBox("Select a LTC symbol file (*.asy) first!", "OK");
}
}
}
dlgPushButton("-CANCEL") { dlgReject(); exit(-5); }
dlgStretch(1);
dlgLabel(ULP_Version);
dlgPushButton("&Save config") saveconfig();
}
};
return;
}
/***** EXPORT menu *****/
void ex_setupmenu(void) {
string schexportname;
dlgDialog("Eagle-LTspice Setup") {
dlgHBoxLayout dlgSpacing(200);
dlgLabel("spice.asy = "+ LTSpiceLibDir);
dlgLabel("eagle.asy = "+ ExpEagleSpiceSymDir);
if (schematic) { /*** SCHEMATIC ***/ //2012-10-10 alf
schematic(SCH) schexportname = filesetext(SCH.name, ".asc");
dlgLabel("SCH = "+ schexportname);
}
else if (library) { /*** LIBRARY ***/
dlgGridLayout {
ExOnceLib = 1;
if (deviceset) {
dlgCell( 5 , 2 ) dlgGroup("Export") {
dlgRadioButton("Export &all devices", ExOnceLib);
dlgRadioButton("EXPORT &only this deviceset to LTspice symbol (*.asy)", ExOnceLib);
}
}
else {
dlgCell( 5 , 2 ) dlgLabel("EXPORT all devicesets to LTspice symbols (*.asy)");
}
}
}
dlgHBoxLayout {
dlgPushButton("+OK") dlgAccept();
dlgPushButton("-CANCEL") { dlgReject(); exit(-2); }
dlgStretch(1);
dlgLabel(ULP_Version);
}
};
saveconfig();
return;
}
void dosfilecopy( string source, string target, string option) {
string DOScommand;
sprintf(DOScommand, "XCOPY \"%s\" \"%s\" %s", lash2backslash(source), lash2backslash(target), option);
/*
dlgDialog("DOS command") {
dlgHBoxLayout dlgSpacing(800);
dlgStringEdit(DOScommand);
dlgPushButton("ok") dlgAccept();
dlgPushButton("esc") { dlgReject(); exit(-4056); }
};
*/
system(DOScommand);
return;
}
void autosetupinfo(string dlgheader, string cntscrsetup) {
dlgDialog(dlgheader) {
dlgGridLayout {
dlgCell( 0, 1) dlgLabel("Program:");
dlgCell( 0, 2) dlgLabel(EAGLE_SIGNATURE);
dlgCell( 1, 1) dlgLabel("System:");
dlgCell( 1, 2) dlgLabel(OS_SIGNATURE);
dlgCell( 2, 1) dlgLabel("Eagle Path:");
dlgCell( 2, 2) dlgLabel(EAGLE_PATH);
dlgCell( 3, 1) dlgLabel("Eagle Dir:");
dlgCell( 3, 2) dlgLabel(EAGLE_DIR);
dlgCell( 4, 1) dlgLabel("User Dir:");
dlgCell( 4, 2) dlgLabel(EAGLE_HOME);
dlgCell( 5, 1) dlgLabel("<hr>");
dlgCell( 5, 2) dlgLabel("<hr>");
dlgCell( 6, 1) dlgLabel("LTSpiceExecute");
dlgCell( 6, 2) dlgLabel(LTSpiceExecute);
dlgCell( 7, 1) dlgLabel("LTSpiceLibDir");
dlgCell( 7, 2) dlgLabel(LTSpiceLibDir);
dlgCell( 8, 1) dlgLabel("ExpEagleSpiceSymDir");
dlgCell( 8, 2) dlgLabel(ExpEagleSpiceSymDir);
dlgCell( 9, 1) dlgLabel("<hr>");
dlgCell( 9, 2) dlgLabel("<hr>");
dlgCell( 10, 1) dlgLabel("EagleExecute");
dlgCell( 10, 2) dlgLabel(EagleExecute);
dlgCell( 11, 1) dlgLabel("Imp_ConnectScriptDir");
dlgCell( 11, 2) dlgLabel(Imp_ConnectScriptDir);
dlgCell( 12, 2) dlgLabel(cntscrsetup);
dlgCell( 13, 1) dlgLabel("SpiceSimulationLbr");
dlgCell( 13, 2) dlgLabel(SpiceSimulationLbr);
dlgCell( 14, 1) dlgLabel("SpiceDefaultSymLbr");
dlgCell( 14, 2) dlgLabel(SpiceDefaultSymLbr);
}
dlgHBoxLayout {
dlgPushButton("+OK") dlgAccept();
//dlgPushButton("-CANCEL") {dlgReject(); exit(-10); }
dlgStretch(1);
if (dlgheader == "Diagnose") {
dlgPushButton("Save") {
string rptfile = filesetext(argv[0], ".rpt");
output(rptfile, "wt") {
printf("Program:\t%s\n", EAGLE_SIGNATURE);
printf("System:\t%s\n", OS_SIGNATURE);
printf("Eagle Path:\t%s\n", EAGLE_PATH);
printf("Eagle Dir:\t%s\n", EAGLE_DIR);
printf("User Dir:\t%s\n", EAGLE_HOME);
printf("LTSpiceExecute:\t%s\n", LTSpiceExecute);
printf("LTSpiceLibDir:\t%s\n", LTSpiceLibDir);
printf("ExpEagleSpiceSymDir:\t%s\n", ExpEagleSpiceSymDir);
printf("EagleExecute:\t%s\n", EagleExecute);
printf("Imp_ConnectScriptDir:\t%s\n", Imp_ConnectScriptDir);
printf("%s\n", cntscrsetup);
printf("SpiceSimulationLbr:\t%s\n", SpiceSimulationLbr);
printf("SpiceDefaultSymLbr:\t%s\n", SpiceDefaultSymLbr);
}
dlgMessageBox("Saved to:"+rptfile, "OK");
}
}
}
};
return;
}
/* ***********************
******** MAIN ***********
*********************** */
readconfig();
int CntScr = 0;
if (!LTSpiceExecute || argv[2] == "/S") {
string rootpath[] = { "C:/Programme/", "C:/Program files (x86)/", "C:/Program files/", "D:/Program files (x86)/", "D:/Program files/" }; // 2012-10-11
int nroot = 0;
do {
LTSpiceExecute = file_search("LTspiceIV/scad3.exe", rootpath[nroot], 3, "4085"); // 2012-11-27 das LTspice executable, in Pfad LTspiceIV, das es ältere Versionen gibt, mit unterschiedlichen Pfadnamen!
nroot++;
} while (!LTSpiceExecute && rootpath[nroot]);
if (!LTSpiceExecute) {
dlgMessageBox("!LTspiceIV (scad3.exe) not found.", "OK");
exit(-4141);
}
else {
ExpEagleSpiceSymDir = filedir(LTSpiceExecute) + "lib/sym/eagle/"; // 2012-12-05
LTSpiceLibDir = filedir(LTSpiceExecute) + "lib/"; // 2012-11-27
}
int pos = strstr(EagleExecute, "bin/"); // 2012-11-27 nur den Hauptpfad zu den Unterordnern
string eagleroot = strsub(EagleExecute, 0, pos);
string cfgdirlbr = cfgget("EAGLE:Directories.Lbr"); // 2012-10-30 den Pfad unter Optionen Verzeichnisse zu den importierten LTspice-LBRs erweitern!
pos = strstr(cfgdirlbr, "lbr/ltspice");
if (pos <0) {
cfgdirlbr = eagleroot + "lbr/ltspice;" + cfgdirlbr;
cfgset("EAGLE:Directories.Lbr", cfgdirlbr);
}
// prüfe Verzeichnis für Scripte zum erzeugen der Devices von LT
Imp_ConnectScriptDir = file_search("misc/ltspice/scr", eagleroot, 4, "4109"); // Das Directory der Scripte von LT zum erzeugen der Devices CONNECT, PACKAGE, ATTRIBUTE...
if (!Imp_ConnectScriptDir) {
if (dlgMessageBox("!Directory of LT connect scripts not found:\n" + eagleroot + "scr/ltc", "MAKE DIR", "CANCEL") != 0) exit(-4161);
// makedir(eagleroot, "scr/ltc");
}
else {
string scr[];
CntScr = fileglob(scr, Imp_ConnectScriptDir + "*.scr");
if (!CntScr) {
sprintf(h, "!No scripts found in:\n%s\n\nCopy first LT connect scripts!", Imp_ConnectScriptDir);
dlgMessageBox(h, "CANCEL");
exit(-4170);
}
}
string copyeaglesym2spice = file_search( "eagle", LTSpiceLibDir, 3, "4123"); // prüfe ob Unterordner /eagle unter /sym besteht?
string copysource = eagleroot+"misc/ltspice/lib/*.*";
if (copyeaglesym2spice) {
dosfilecopy( copysource, LTSpiceLibDir, "/S /Y"); // 2012-11-27 XCOPY mit Unterordner und ohne Eingabe/Quittierung
}
else {
if (!makedir(LTSpiceLibDir, "/sym/eagle")) { // Returnwert 0 wenn das Verzeichnis nicht angelegt werden konnte.
dlgMessageBox("!Can't creat directory:\n" + LTSpiceLibDir + "eagle", "CANCEL");
exit(-4181);
}
// kopiere die Spice Symbole vom Eagle-Paket nach LTC lib/sym/eagle inkl. Unterordner
// 2012-11-27 neu ist der Ordner sub mit der Datei note.sub
dosfilecopy( copysource, LTSpiceLibDir, "/S /Y"); // 2012-11-27 XCOPY mit Unterordner und ohne Eingabe/Quittierung
}
SpiceSimulationLbr = file_search("ltspice/lt-spice-simulation.lbr", EAGLE_DIR, 4, "4138"); // die Symbole zum simulieren, Stimuli (V, I, F Generatoren)
if (!SpiceSimulationLbr) {
dlgMessageBox("!Default LTspice simulation library not found, please import first:" + EAGLE_DIR + "/lbr/ltspice/lt-spice-simulation.lbr", "CANCEL");
// 2013-10-01 Pfadtrenner nach EAGLE_DIR und lbr...
exit(-4192);
}
dlgMessageBox("!Default LTspice simulation library found on:\n" + EAGLE_DIR + "/lbr/ltspice/lt-spice-simulation.lbr", "CANCEL");
SpiceDefaultSymLbr = file_search("ltspice/sym.lbr", EAGLE_DIR, 4, "4144"); // die Default-Lbr für R, L, C, D, Res...
if (!SpiceDefaultSymLbr) {
dlgMessageBox("!Default LTspice symbol library (R C L D ...) not found, please import first:" + EAGLE_DIR + "lbr/ltspice/sym.lbr", "CANCEL");
exit(-4199);
}
string cntscrsetup;
sprintf(cntscrsetup, "%d scripts", CntScr);
autosetupinfo("Auto Setup Info", cntscrsetup);
saveconfig();
// 2012-10-30 die LTspice LBRs (den gesamten Ordner) in die USE-Liste eintragen!
string uselbr;
sprintf(uselbr, "USE -*;\nUSE '%slbr/ltspice';\nUSE '%slbr/eagle-ltspice'; #4222\n", eagleroot, eagleroot);
// Pfade immer in ' einschließen, besonders bei Windows 7/8 64-Bit,
// da es den Ordner "Programm (x86)" gibt, und die Klammern () von Eagle als Koordinate ausgewertet werden!
// für die eagle-ltspice.lbr muß der absolute Pfad angegeben werden,
// da der Pfad für die "eagl-lbrs" jetzt an zweiter Stelle steht! 2012-10-30
exit(uselbr);
}
/* ******************************
******** main Export ***********
****************************** */
if (strupr(argv[1]) == "/E") {
if (library) { /*** LIBRARY ***/
library(L) {
ex_setupmenu(); // runs always with setup menu
if (deviceset && ExOnceLib) {
deviceset(DEV) {
DEV.devices(D) ex_draw_device(D, DEV);
/* *****************************************************************************************
Kein Handshake, das ULP wartet auf die Beendigung des aufgerufenen Programm (DOS-BOX)
und kehrt dann zum aufrufenden Fenster zurück.
Vorteil, das Fenster (Schaltplan) hat den Fokus wieder!
****************************************************************************************** */
//call_system(Ex_AsyName);
//exit("RUN ulpmessage 'DEVICESET <b>" + DEV.name + ".dev</b><br>exported to<br>" + ExpEagleSpiceSymDir + filename(filesetext(L.name, "/")) + DEV.name + ".asy'");
string rmsg;
sprintf(rmsg, "RUN ulpmessage 'DEVICESET <b>%s.dev</b> (%d)<br>exported to<br>%s", DEV.name, CntOutput, filedir(Ex_AsyName));
exit(rmsg);
}
}
else {
int cnt = 0;
L.devicesets(DEV) DEV.devices(D) {
cnt++;
ex_draw_device(D, DEV);
}
//exit("RUN ulpmessage '" + L.name + "<br>exported to<br>" + ExpEagleSpiceSymDir + filename(filesetext(L.name, "/")) + "*.asy'");
exit("RUN ulpmessage '" + L.name + "<br>exported to<br>" + filedir(Ex_AsyName) + "*.asy");
}
}
}
else if (sheet) { /*** SHEET ***/
if (strupr(argv[2]) == "/G") ExportAll = 0; // export only selected group
schematic(SCH) {
if (!ExportAll) ExpSchematic2LTpice = filesetext(SCH.name, "_group.asc"); // 2012-06-22
else ExpSchematic2LTpice = filesetext(SCH.name, ".asc"); // 2012-05-10
}
if (strupr(argv[2]) == "/S") {
ex_setupmenu();
exit(0);
}
if (Test) if (dlgMessageBox("Export Schematic to:\n" + ExpSchematic2LTpice, "OK", "CANCEL") != 0) exit(-6);
output(ExpSchematic2LTpice, "wt") {
printf("Version 4\n");
sheet(S) {
printf("SHEET %d %.0f %.0f\n", S.number, ex_spicegrid(u2mil(S.area.x2)), ex_spicegrid(u2mil(S.area.y2)*-1.0)); // SHEET 1 1684 1612
S.nets(N) N.segments(SEG) SEG.wires(W) if (ingroup(W) || ExportAll) ex_draw_net_wire(W);
S.nets(N) N.segments(SEG) SEG.labels(LAB) if (ingroup(LAB) || ExportAll) ex_draw_label(LAB);
S.parts(P) P.instances(I) if (ingroup(I) || ExportAll) ex_draw_instance(I, P);
S.wires(W) if (ingroup(W) || ExportAll) ex_draw_wire(W);
S.rectangles(R) if (ingroup(R) || ExportAll) ex_draw_rectangle(R);
S.circles(C) if (ingroup(C) || ExportAll) ex_draw_circle(C);
S.texts(T) if (ingroup(T) || ExportAll) ex_draw_text(T, "SCH", ""); // 2012-05-11
}
}
//string ExportedFile = ExpSchematic2LTpice;
int ExportedFileTime = -1;
int newfiletim = -1;
string f[];
int cnt = fileglob(f, ExpSchematic2LTpice);
if (cnt) {
ExportedFileTime = filetime(ExpSchematic2LTpice);
}
else {
dlgMessageBox("Warning, file '"+ExpSchematic2LTpice+"' does not exist!", "Break");
exit(-7);
}
status(" Waiting for return of "+filename(LTSpiceExecute));
string syscommand;
// Handshake mit LT-Spice über eine Datei (momentan der LTspice-Schaltplan selber, über den Zeitstempel)
if (Ex_WaitOnHandShake) {
sprintf(syscommand, "cmd.exe /c \"%s\" \"%s\"", LTSpiceExecute, ExpSchematic2LTpice);
system(syscommand); // externes Programm starten
ExportedFileTime = filetime(ExpSchematic2LTpice);
newfiletim = filetime(ExpSchematic2LTpice);
status("Waiting for LTspice response");
do {
newfiletim = filetime(ExpSchematic2LTpice);
} while (newfiletim == ExportedFileTime);
exit ("RUN 'ltspice.ulp /I' '"+ ExpSchematic2LTpice + "' 'RELOAD'");
}
/******************************************************************************************
Kein Handshake, das ULP wartet auf die Beendigung des aufgerufenen Programm (DOS-BOX)
und kehrt dann zum aufrufenden Fenster zurück.
Vorteil, das Fenster (Schaltplan) hat den Fokus wieder!
*******************************************************************************************/
call_system(ExpSchematic2LTpice);
newfiletim = filetime(ExpSchematic2LTpice);
// Überprüfe den Timestamp der Datei, falls geändert, dann starte das ULP mit der Option RELOAD!
if (newfiletim == ExportedFileTime) exit(0); // nothing changed!
exit ("RUN 'ltspice.ulp' '/I' '"+ ExpSchematic2LTpice + "' 'RELOAD'");
}
else dlgMessageBox("Start this ULP in a library or schematic!", "OK");
exit(-4320);
}
/* *******************************
******** main Imxport ***********
******************************* */
else if (strupr(argv[1]) == "/I") {
sprintf(h, "%d", argc);
readconfig();
if (argc == 4) {
if (fileext(argv[2]) == ".asc") { // work with schematic
Imp_CntFileSpiceAsc = 1;
ImpSpiceSchematicAsc = argv[2];
}
else if (fileext(argv[2]) == ".asy") { // work with symbol
CntFileSpiceSym = 1;
FileSpiceSym[0] = argv[2];
}
ScriptFile = filesetext(argv[2], "~spice2eagle.scr");
}
else {
// ### main menu SYMBOL/SCHEMATIC ###
imp_setupmenu();
saveconfig();
}
if (!FileSpiceSym[0] && !ImpSpiceSchematicAsc) exit(-8);
/**** Import a library ****/
if (CntFileSpiceSym) {
int t = time();
string fext = "*.asy";
string libsource;
if (Import_All_Symbols) {
CntFileSpiceSym = fileglob(FileSpiceSym, filedir(FileSpiceSym[0])+fext);
if (!LbrName) LbrName = imp_dirname(FileSpiceSym[0]);
libsource = filedir(FileSpiceSym[0]) + "*.asy";
}
else {
if (!LbrName) LbrName = filesetext(FileSpiceSym[0], ".lbr");
libsource = filesetext(FileSpiceSym[0], "*.asy");
}
ScriptFile = filesetext(FileSpiceSym[0], Imp_ScriptExt);
if (NewLbrName) sprintf(Imp_Cmd, "OPEN '%s';\n", NewLbrName);
sprintf(h, "DESCRIPTION 'LT-Spice library generated with :<br>\\n%s<br>\\nfrom: %s<br>\\nat %s';\n",
filename(argv[0]), libsource, t2string(t)
);
Imp_Cmd+=h;
sprintf(h, "LAYER %d SpiceOrder;\n", LayerSpiceOrder);
Imp_Cmd+=h;
sprintf(h, "SET COLOR_LAYER %d %d;\n", LayerSpiceOrder, ColorViolett); // SET COLOR_LAYER layer color;
Imp_Cmd+=h;
int nf = 0;
if (ScriptFile && FileSpiceSym[nf]) {
for (nf = 0; nf < CntFileSpiceSym; nf++) {
attribute2script("#4232\n", FileSpiceSym[nf], FileNewTemp); // neues Script anlegen, um die Attribute die in den PAckage-Varianten
// angelegt werden müssen, zwischen zu speichern. Denn das anlegen einer
// Package-Variante löscht die ATTRIBUTE, die vorher angelegt wurden!
string cmd;
Imp_CntPinname = 0;
int len = strlen(FileSpiceSym[nf]);
if (FileSpiceSym[nf] && FileSpiceSym[nf][len-1] != '/') { // can not use directories, cut last character /
CntLines = fileread(Lines, FileSpiceSym[nf]);
status(FileSpiceSym[nf]); // ein Lebenszeichen
Imp_SymDevName = strupr(filesetext(filename(FileSpiceSym[nf]), ""));
if (imp_checkexist_dev(Imp_SymDevName)) {
if (dlgMessageBox("! Attention: <b>" + Imp_SymDevName + ".DEV</b> exist.<p>DELETE ?", "YES", "NO") != 0) {
exit("EDIT " + Imp_SymDevName + ".SYM");
}
else sprintf(Imp_Cmd, "SET CONFIRM YES;\nREMOVE %s.DEV;\nSET CONFIRM OFF;\n", Imp_SymDevName);
}
if (imp_checkexist_sym(Imp_SymDevName)) {
if (dlgMessageBox("! Attention: <b>" + Imp_SymDevName + ".SYM</b> exist.<p>DELETE ?", "YES", "NO") != 0) {
exit("EDIT " + Imp_SymDevName + ".SYM");
}
else sprintf(Imp_Cmd, "SET CONFIRM YES;\nREMOVE %s.SYM;\nSET CONFIRM OFF;\n", Imp_SymDevName);
}
sprintf(cmd, "EDIT %s.SYM;\nCHANGE LAYER 96;\nGRID MIL 50 2 LINES ON;\nCHANGE WIDTH 0;\nCHANGE STYLE Continuous;\n", Imp_SymDevName);
Imp_Cmd+=cmd;
if (ExternalSymbol) {
sprintf(Imp_CmdDev, "EDIT %s.DEV;\nVALUE ON;\nADD %s '%s' (0 0);\n", Imp_SymDevName, Imp_SymDevName, Imp_DefaultGateName); // add new gate (symbol)
sprintf(cmd, "ATTRIBUTE '%s';\n", ExternalAttributeName);
Imp_CmdDev+=cmd;
}
string pincoord[]; // remember pin coordinate for attribute
int cntpin;
for (n = 0; n < CntLines; n++) {
if (strstr(Lines[n], "Version") == 0) imp_version(Lines[n]);
else if (strstr(Lines[n], "SymbolType") == 0) imp_symboltype(Lines[n]);
else if (strstr(Lines[n], "LINE") == 0) imp_line(Lines[n]);
else if (strstr(Lines[n], "RECTANGLE") == 0) imp_rectangle(Lines[n]);
else if (strstr(Lines[n], "CIRCLE") == 0) imp_circle(Lines[n]);
else if (strstr(Lines[n], "ARC") == 0) imp_arc(Lines[n]);
else if (strstr(Lines[n], "TEXT") == 0) imp_text(Lines[n]);
else if (strstr(Lines[n], "WINDOW") == 0) imp_window_sym(Lines[n], n);
else if (strstr(Lines[n], "SYMATTR") == 0) Imp_CmdDev += imp_symattr_sym(Lines[n], n, FileSpiceSym[nf]);
// PIN -48 -32 LEFT 8
else if (strstr(Lines[n], "PIN ") == 0) cntpin = strsplit(pincoord, imp_pin(Lines[n]), '\t');
else if (strstr(Lines[n], "PINATTR") == 0) imp_pinattr(Lines[n], pincoord[0], pincoord[1], pincoord[2]);
else if (Lines[n] == ""); // empty line in LTC3703-5.asy
else {
sprintf(h, "Symbol: Line %d unknown:\n%s", n+1, Lines[n]);
if (dlgMessageBox(h, "OK", "CANCEL") != 0) exit(-4429);
}
}
Imp_Cmd += Imp_CmdDev + "WIN FIT;\n"; // make a device and use generated symbol
if (Test) {
dlgDialog("Test") {
dlgHBoxLayout dlgSpacing(700);
dlgHBoxLayout {
dlgVBoxLayout dlgSpacing(700);
dlgTextEdit(Imp_Cmd);
}
dlgHBoxLayout {
dlgPushButton("ok") dlgAccept();
dlgPushButton("esc") { dlgReject(); exit(-9); }
dlgPushButton("weiter ohne Scriptanzeige") { dlgAccept(); Test = 0; }
}
};
}
}
sprintf(cmd, "EDIT %s.DEV;\nVALUE ON;\n", Imp_SymDevName); // add new empty device
Imp_Cmd+=cmd;
string connectscript = file_search(filename(filesetext(FileSpiceSym[nf], ".scr")), Imp_ConnectScriptDir, 3, "4434");
if (connectscript) {
string usedpacname = get_pac_from_script(connectscript);
int pacexist = check_exist_packname(usedpacname);
if (!pacexist) {
exit(-10); // without package can not define ATTRIBUTEs
}
sprintf(cmd, "SCRIPT '%s';\n", connectscript);
Imp_Cmd += cmd;
sprintf(cmd, "SCRIPT '%s';\n", filesetext(FileSpiceSym[nf], ".scr"));
Imp_Cmd += cmd; // die zuvor geretteten ATTRIBUTE in das Device schreiben
Imp_Cmd += "RUN 'copy-attribute-at-deviceset';\n"; // kopiert alle Attribute in alle Packagevarianten,
// und benennt die ertse Variante um zu '', damit die
// Schaltpläne reibungslos importiert werden können. 2012-10-07
}
}
output(ScriptFile, "wtD") {
printf("#Generated with %s\n#from %s\n# at %s\n", argv[0], libsource, t2string(time(), "dd-MM-yyyy hh:mm:ss"));
printf("%s", Imp_Cmd);
}
exit ("SCRIPT '"+ ScriptFile + "'");
}
}
/*** Import a schematic ***/
if (ImpSpiceSchematicAsc) {
if (schematic) {
string schname;
string spicename = filesetext(filename(ImpSpiceSchematicAsc), "");
schematic(SCH) {
schname = filesetext(filename(SCH.name), "");
if (spicename == schname) {
if (argv[3] == "RELOAD") { // return from export (RUN ltpsice.ulp /E)
RELOAD = 1;
exit(-4484); /* include here the different import */
}
}
}
}
string FileImpSpiceSchematicAsc[];
Imp_CntFileSpiceAsc = fileglob(FileImpSpiceSchematicAsc, ImpSpiceSchematicAsc);
if (ScriptFile && ImpSpiceSchematicAsc) {
if (ImpSpiceSchematicAsc) {
CntLines = fileread(Lines, ImpSpiceSchematicAsc);
status(ImpSpiceSchematicAsc); // ein Lebenszeichen
if (!imp_checkexist_sch(SchName)) {
string cmd;
sprintf(cmd, "EDIT '%s';\nCHANGE LAYER 96;\nGRID MIL 50 2 LINES ON;\nCHANGE WIDTH 10;\n", SchName);
Imp_Cmd+=cmd;
Imp_Cmd+= "SET CONFIRM YES;\n";
Imp_Cmd+= "CHANGE STYLE Continuous;\n";
Imp_Cmd+= "USE '"+ SpiceSimulationLbr + "'; #4516\n"; // set simulation symbol lbr to use list
Imp_Cmd+= "USE '"+ SpiceDefaultSymLbr + "';\n"; // set spice default symbol lbr to use list
for (n = 0; n < CntLines; n++) {
if (strstr(Lines[n], "Version") == 0) imp_version(Lines[n]);
else if (strstr(Lines[n], "SHEET") == 0) imp_sheet(Lines[n]);
else if (strstr(Lines[n], "WIRE") == 0) imp_wire(Lines[n]);
else if (strstr(Lines[n], "FLAG") == 0) imp_flag(Lines[n]);
else if (strstr(Lines[n], "IOPIN") == 0) imp_iopin(Lines[n]);
else if (strstr(Lines[n], "BUSTAP") == 0) imp_bustap(Lines[n]);
else if (strstr(Lines[n], "SYMBOL") == 0) imp_symbol_sch(Lines[n]);
else if (strstr(Lines[n], "WINDOW") == 0) imp_window_sch(Lines[n], n);
else if (strstr(Lines[n], "SYMATTR") == 0) imp_symattr_sch(Lines[n], n);
else if (strstr(Lines[n], "CIRCLE") == 0) imp_circle(Lines[n]);
else if (strstr(Lines[n], "RECTANGLE") == 0) imp_rectangle(Lines[n]);
else if (strstr(Lines[n], "ARC") == 0) imp_arc(Lines[n]);
else if (strstr(Lines[n], "TEXT") == 0) imp_text(Lines[n]);
else if (strstr(Lines[n], "text") == 0) imp_text(Lines[n]);
else if (strstr(Lines[n], "LINE") == 0) imp_line(Lines[n]);
else if (strstr(Lines[n], "DATAFLAG") == 0) imp_dataflag(Lines[n]);
else {
sprintf(h, "Schematic: Line %d unknown:\n%s", n+1, Lines[n]);
if (dlgMessageBox(h, "OK", "CANCEL") != 0) exit(-4);
}
}
imp_draw_net();
if (RememberFlag) CmdNameLabel += RememberFlag;
Imp_Cmd += CmdNameLabel;
Imp_Cmd += Imp_CmdDev + "WIN FIT;\n"; // make a device and use generated symbol
Imp_Cmd += "SET CONFIRM OFF;\n";
}
}
}
if (Test) { // Testview("nach allem");
dlgDialog("Das Rückgabe-SCRIPT") {
dlgHBoxLayout dlgSpacing(700);
dlgHBoxLayout {
dlgVBoxLayout dlgSpacing(700);
dlgTextEdit(Imp_Cmd);
}
dlgHBoxLayout {
dlgPushButton("ok") dlgAccept();
dlgPushButton("esc") { dlgReject(); exit(-4544); }
dlgPushButton("weiter") dlgAccept();
}
};
}
output(ScriptFile, "wtD") {
printf("#Generated with %s\n#from %s\n# at %s\n", argv[0], ImpSpiceSchematicAsc, t2string(time(), "dd-MM-yyyy hh:mm:ss"));
printf("%s", Imp_Cmd);
printf("DISPLAY NONE 91 92 94 95 96 97 98;\n"); // Display Layer 99 'SpiceOrder' off !
}
exit ("SCRIPT '"+ ScriptFile + "'");
}
}
/* ******************************
******** main Diagnostic *******
****************************** */
else if (strupr(argv[1]) == "/?") { // 2013-10-01
string cntscrsetup;
sprintf(cntscrsetup, "%d scripts", CntScr);
autosetupinfo("Diagnose", cntscrsetup);
exit(-4565);
}
dlgDialog("Help") {
dlgHBoxLayout dlgSpacing(800);
dlgHBoxLayout {
dlgVBoxLayout dlgSpacing(500);
dlgTextView(usage);
}
dlgHBoxLayout {
dlgStretch(1);
dlgPushButton("OK") dlgAccept();
dlgPushButton("LTspice Info") dlgMessageBox(LTspiceFormatInfo, "OK");
dlgStretch(1);
}
};
Reference in New Issue Copy Permalink