Hallo,
ist es mit einem ULP möglich, andere (noch nicht geöffnete)
Schaltpläne/Boards zu öffnen in der Art, dass das ULP anschließend
darauf zugreifen kann als würde man das ULP unter EAGLE im geöffneten
Schaltplan ausführen?
Also etwas so:
schematic.open("c:\neuerSchaltplan.sch");
// etwas mit dem neuen Schaltplan machen....
Vielen Dank im voraus.
MfG,
Sebastian
Hallo!
Am Donnerstag, den 03.03.2011, 10:27 +0100 schrieb A. Zaffran:
Am 03.03.2011 08:55, schrieb Sebastian Schlüter:
Hallo,
ist es mit einem ULP möglich, andere (noch nicht geöffnete)
Schaltpläne/Boards zu öffnen in der Art, dass das ULP anschließend
darauf zugreifen kann als würde man das ULP unter EAGLE im geöffneten
Schaltplan ausführen?
Also etwas so:
schematic.open("c:\neuerSchaltplan.sch");
// etwas mit dem neuen Schaltplan machen....
Nein. Die User-Language ist wie schon gesagt nur dazu gedacht,
an die Eagle-Daten zu gelangen, alles was die Daten verändert
muß als SCRIPT oder String an die Kommandozeile des Editor
zurückgegeben werden.
Beispiel:
exit("EDIT 'c:/neuerSchaltplan.sch/'; RUN 'name.ulp'");
Vielen Dank für diese klare Aussage zum Unterschied zw. ULP und Script.
Ich hatte das schon länger so im Kopf, war mir aber nicht sicher.
Meine Frage: Wieso ist das so?
Und: Muss das so bleiben? Was spricht dagegen, in der neuen Version 6
gleich eine wesentliche Verbesserung der Scripting-Fähigkeit von Eagle
zu realisieren? (außer dem Aufwand, natürlich). IMHO müssten SCR und ULP
aus Kompatibilitätsgründen natürlich weiter existieren, aber ich würde
möglichst viel auf das neue übertragen.
Ich persönlich bin, seitdem ich enger mit Programmen für Chip-Design zu
tun habe, ein großer Fan von guter Scripting-Fähigkeit geworden. Leider
nutzen die meisten Tools dazu die Sprache TCL (und Abwandlungen), was
mir nicht so gut gefällt. Aber da Eagle starken Gebraucht von Qt macht,
stünde das JavaScript ähnliche QtScript mit nur geringem Aufwand zur
Verfügung.
Besonders faszinierend finde ich es, wenn ein Programm selbst eigentlich
nackt ist und nichts tut, aber alle Funktionen und Daten den Scripts zur
Verfügung stellt, und die GUI und die Zusammenhänge erst durch (relativ
überschaubare) Scripts entstehen. Das ist zwar ein im Consumer-Bereich
sehr außergewöhnlicher Ansatz, aber er ist nicht viel aufwändiger als
die üblichen Konzepte, und bietet gleichzeitig unendliche Flexibilität.
Und ein User bekommt davon gar nichts mit, wenn er nicht will. Aber wenn
er will, kann er sich das Programm nach Belieben anpassen und erweitern.
Die normale Kern-Funktionalität (Zeichnen, Routen, ...) ist natürlich in
C++ implementiert, wird aber für Scripts angeboten.
Für Eagle würde ich vorschlagen, dass es durchaus als vollständiges
Programm startet. Allerdings würde ich Dinge wie die Toolbars mit den
Buttons, Menüs, ... über Scripts erzeugen. Und jeder Knopf und jeder
Menüpunkt löset seinerseits einen Script-Event aus. Beispiel:
function SetupBoardEditor() {
// create new toolbar at top
TlbTop = Window.CreateToolbar("top");
// create a button with an (internal) name and an image
BtnOpen = TlbTop.CreateButton("Open","open.png");
// action taken on left-click
BtnOpen.OnLeftClick = function() {
Window.OpenFile();
}
// action taken on right-click
BtnOpen.OnRightClick = function() {
LastFilesMenu = PopupMenu.New();
LastFilesMenu.Add(LastFileList);
}
// create another button
BtnSave = TlbTop.CreateButton("Save","save.png");
BtnSave.OnLeftClick = function() {
Board.Save();
}
/* ... */
// button for "real" stuff
BtnInfo = TlbLeft.CreateButton("Info","info.png");
BtnInfo.OnLeftClick = function() {
// execute a "normal" Eagle function
Board.ExecuteScript("INFO");
}
/* ... */
}
Und wenn jemand seine Bauteile im Kreis anordnen möchte, dann könnte das
z.B. so aussehen:
function PlaceInCircle(Components,CenterX,CenterY,Radius,StartAngle) {
AngleStep = 2*pi/Components.Count;
for (i=0; i < Components.Count; i++) {
Angle = StartAngle+i*AngleStep;
Components[i].X = CenterX + Radius * cos(Angle);
Components[i].Y = CenterX + Radius * sin(Angle);
Components[i].Angle = Angle;
}
}
Und aufgerufen wird das dann auf folgende Arten:
// use group
PlaceInCircle(Board.Group.Components, 3.5, 7.4, 1.0, 0.0);
// use search mask
CircleComponents = Board.SearchComponents("D(|1[0-5]"); // regex
PlaceInCircle(CircleComponents, 3.5, 7.4, 1.0, 0.0);
Und wenn das jemand öfter braucht, dann könnte man das auch als
Menüpunkt anbieten.
// create new drop-down menu like "File", ...
MnuEigenbau = Window.Menu.AddMenu("Eigenbau");
// create new menu item
MnpPlcInCrcl = MnuEigenbau.AddItem("Bauteile in Kreis anordnen...");
// function executed if menu item is selected
MnpPlcInCrcl.OnActivate = function() {
// create dialog window
Dlg = Dialog.Create("Bauteile im Kreis anordnen");
// group box for the component selection
GrpSelection = DlgGroupBox.Create("Bauteile auswählen");
// radio button: use GROUP marked before selecting this menu item
RdbGroup = DlgRadioButton.Create(GrpSelection,"Gruppe");
// radio button: search components by regex
RdbRegex = DlgRadioButton.Create(GrpSelection,"Suche: ");
// entry field for the regex
EdtRegex = DlgEditField.Create(GrpSelection);
EdtRegex.Active = false;
// (de-)activate edit field depending on radio buttons
RdbRegex.OnActivate = function() {
EdtRegex.Active = true;
}
RdbRegex.OnDeactivate = function() {
EdtRegex.Active = false;
}
// group box for the circle geometry
GrpGeometry = DlgGroup.Create("Anordnung");
LblCenter = DlgLabel.Create(GrpGeometry,"Mittelpunkt");
PntCenter = DlgPointPicker.Create(GrpGeometry);
LblRadius = DlgLabel.Create(GrpGeometry,"Radius");
EdtRadius = DlgEditField.Create(GrpGeometry);
EdtRadius.Validate = "[0-9.]+"; // numeric input
EdtStartAngle = DlgEditField.Create(GrpGeometry);
EdtStartAngle.Validate = "[0-9.]+"; // numeric input
BtnOk = DlgButton.Create(Dlg,"OK");
BtnOk.OnClick = function () {
Dlg.Close();
// get components
if (RdbGroup.Selected)
Components = Board.Group.Components;
else
Components = Board.SearchComponents(EdtRegex.Text);
// geometry parameters
Center = PntCenter.Point;
Radius = Str2Float(EdtRadius.Text);
StartAngle = Str2Float(EdtStartAngle.Text);
// go, go, go!
PlaceInCircle(Components,Center.X,Center.Y,Radius,StartAngel);
}
BtnCancel = DlgButton.Create(Dlg,"Abbruch");
BtnCancel.OnClick = function () {
Dlg.Close();
}
}
Alles in einem Guss, alles ohne "exit" und "RUN".
Weiter Ideen:
- Simulator-Kopplung (Netzlisten-Export, interaktives markieren von
Signalen, Annotation direkt im Schaltplan, ...)
- "Nachrüsten" besonderer Funktionalitäten, z.B. Routen differentieller
Paare, Längenausgleich mit Mänder, ...
Und was noch dazu kommt: Man könnte ein "Plugins"-Verzeichnis anlegen,
aus dem beim Start sämtliche Scripts ausgeführt werden. Die enthalten
ähnlich obigem Beispiel zwei Teile:
1) eine Funktion mit Funktionalität wie PlaceInCircle(), die wird nicht
ausgeführt sondern nur "kompiliert", und es können natürlich
beliebig viele Funktionen sein
2) ausgeführter Code, sozusagen die void main() des Plugins, der
Menü-Einträge und Toolbar-Buttons anlegt
Dadurch würde endlich das Suchen von .scr- und .ulp-Files wegfallen,
wenn man eine Funktion ausführen möchte, sondern man findet sie direkt
im Menü. Und die wichtigen ULPs würden von den Usern beim Durchstöbern
der Menüs gefunden.
Ihr seht, ich komme ins Schwärmen. 
Eine mächtige Script-Sprache
(QtScript) kombiniert mit umfangreichen Interfaces zu den
Eagle-Kernfunktionen eröffnet eine Vielzahl an Möglichkeiten und
ermöglicht gleichzeitig, viele z.Z. unschöne Konzepte aufzuräumen.
Bye
Hansi
PS: Falls Cadsoft wirklich ein so schönes Scripting-Interface
realisieren würde, dürfen meine obigen Scripts natürlich gerne verwendet
werden. :-D
