7 ElaSim

(/$62)762)7:$5(%(6&+5(,%81* V1.
0/V2_70/Li
ElaSim
INHALT
ELASIM ......................................................................................................................... .................................................................... 1
WAS IST ELASIM .............................................................................................................................................................................. 3
Was ist neu in ElaSim V2.70........................................................................................................................................................ 4
Zusammenhang der einzelnen Komponenten............................................................................................................................... 5
Vorbereitete ElaGraph USER Bausteine ..................................................................................................................................... 6
Neue ElaGraph Bausteine erstellen............................................................................................................................................. 7
Projektmanagement (Projekt.exe)............................................................................................................................................... 8
Projektaufbau .............................................................................................................................................................................. 8
Projekte verwalten mit ElaSim .................................................................................................................................................. 10
ElaSim-Teilprogramme.............................................................................................................................................................. 10
Makefile aus der Projektverwaltung.......................................................................................................................................... 11
DIE ERSTEN SCHRITTE ZUM ERSTEN PROJEKT................................................................................................................................. 12
DIE USERWARE .............................................................................................................................................................................. 16
Start der Userware „ob.c“ ........................................................................................................................................................ 16
Aufbau der Userware................................................................................................................................................................. 17
Zyklische Verarbeitung .............................................................................................................................................................. 18
Die Funktion “ob1".....................................................................................................................................................................................19
Ereignisorientierte Verarbeitung.................................................................................................................................................................19
Die Funktion “ob2_x”.................................................................................................................................................................................19
Zeitzyklische Verarbeitung .........................................................................................................................................................................20
Die Funktion “ob13“,“ob14“ ......................................................................................................................................................................20
}...................................................................................................................................................................................................................20
Die Bereiche der Userware .........................................................................................................................................................................21
Verschiedene CAN Protokolle durch die Userware realisieren...................................................................................................................21
Notation der Userware ................................................................................................................................................................................21
Aufteilung Userware in verschiedene Bibliotheksfunktionen .....................................................................................................................22
Näheres zu den Userware Bibliotheken ......................................................................................................................................................27
Beispiele der Programmierung.................................................................................................................................................. 30
Programmbeispiel “Boolsche Verknüpfungen” in “C.................................................................................................................................30
Programmbeispiel “Analogverarbeitung” in “C”........................................................................................................................................31
Programmbeispiel “Mathematische Operationen” in “C”...........................................................................................................................31
Programmbeispiel “Regler parametrisieren” in “C” ...................................................................................................................................31
DIE FIRMWARE ........................................................................................................................................................................... 32
Festlegung der thematischen Adressbereiche............................................................................................................................ 33
Hardware Adressmapping ......................................................................................................................................................... 33
Zykluszeitüberwachung.............................................................................................................................................................. 34
Wichtige Hinweise zur USERWARE auf verschiedener Prozessoren/Compilern...................................................................... 35
Hinweis für CPU515...................................................................................................................................................................................35
Hinweis für CPU167...................................................................................................................................................................................36
Hinweis für CPU960...................................................................................................................................................................................37
USERWARE PROGRAMMBEISPIELE .............................................................................................................................................. 38
Programmaufbau....................................................................................................................................................................... 38
Ablaufprogrammkopf..................................................................................................................................................................................38
Variable deklarieren....................................................................................................................................................................................38
Initialisieren im “ob22()” ............................................................................................................................................................................38
Ablauf in “ob1()” ........................................................................................................................................................................................38
Zählvorgänge und Zeitgeber...................................................................................................................................................... 39
Softwarezähleingang im ob1() ....................................................................................................................................................................39
Softwarezähleingang mittels Interruptroutine .............................................................................................................................................40
Softwarezähleingang mittels FIRMWARE-Routine ...................................................................................................................................41
Softwaretimer abfragen...............................................................................................................................................................................42
Pulsierender Ausgang .................................................................................................................................................................................43
Einschaltverzögerung eines Ausganges ......................................................................................................................................................44
Softwarerampen......................................................................................................................................................................... 45
Rampe eines analogen Ausganges ..............................................................................................................................................................45
VISUALISIERUNG ............................................................................................................................... ............................................. 46
Best.-Nr: E5000 ELASIM.DOC

elrest Automationssysteme Seite 1 von 67
(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Der Simulator (Visual.exe) ........................................................................................................................................................ 46

Simulation von ElaSim auf dem PC............................................................................................................................................................46
PC-Simulation und Betrieb auf der Zielhardware .......................................................................................................................................47
Visualisierung der Simulation.....................................................................................................................................................................47
Was kann simuliert werden.........................................................................................................................................................................48
Wie wird simuliert ......................................................................................................................................................................................48
DEBUGGEN IM SIMULATIONSBETRIEB (OFFLINE-DEBUGGEN) ........................................................................................................ 49
Einrichten einer Debug-Umgebung........................................................................................................................................... 49
Wechsel auf die zweite Seite des Eingabefensters durch Anwahl von Debug............................................................................ 51
Anlegen eines ElaSim-Projektes über die Projektverwaltung ................................................................................................... 52
Maximierung des DOS-Speichers zur Kompilierung (speziell Keil-Compiler) ......................................................................... 56
ANHANG ELASIM ......................................................................................................................................................................... 59
Tabelle Parametertypen............................................................................................................................................................. 59
Tabelle Reglertypen ................................................................................................................................................................... 62
Tabelle Fühlerarten ................................................................................................................................................................... 62
Liste der Bibliotheksfunktionen ab Firmware V1.20 ................................................................................................................. 63
Liste der Bibliotheksfunktionen ab Firmware V1.30 ................................................................................................................. 64
Die pixelgenaue Elementanordnung im WindowsµE Koordinatensystem ................................................................................. 65

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Was ist ElaSim

ElaSim ist ein Programmpaket, welches die Programmentwicklung für verschiedene Hardwareplattformen in der
Programmiersprache „C“ unterstützt.
Es umfaßt folgende Programmteile:

ElaSim ist in der Projektverwaltung integriert.
Das Projektmanagement erfolgt in einer Windows-Explorer
ähnlichen Darstellung,
Erstellen eines C - Programmes mittels dem integrierten oder

einem kundenspezifischen Editor.
Es wird empfohlen das Mircosoft Developer Studio als Editor
zu verwenden.
Compilieren des Programmes und testen des erstellten
Programmes mit einem optinalen Hochsprachen-Debugger.
Das erstellte Programm kann in einer Simulationsumgebung (OD6LP =LHOV\VWHP

auf dem Entwicklungs-PC betrieben werden. 3URJUDPP
Dazu werden eigenständigen Simulationsprogramme (ob00.exe

für M0 bis ob63.exe für M63) erzeugt. 6LPXODWLRQVEHWULHE
DXI HLQHP
In der Simulation können auch Peripherie-Einheiten wie : :LQGRZV 175HFKQHU
Drucker über CENTRONICS-Verbindung,
Rechner/Modemkopplung über RS232-Verbindung integriert REF
werden..
%HWULHE DXI GHU
JHZQVFKWHQ
=LHOKDUGZDUH
Es existiert eine einheitliche Entwicklungsumgebung der

Programme für alle Zielsysteme wie :
Bedienpulte
Meß- Steuer- und Regelungsmodule
mit unterschiedlichen Prozessortypen.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Der Entwicklungsrechner wird zur vollständigen

Simulationsumgebung von verteilten Systemen.
Dabei können mehrere Zielsysteme gleichzeitig gedebuggt
werden.
Für die Simulation wird ab 1Q. 2000 die Zusatzkomponente

„Virtuelle Kommunikation“ angeboten.
Mit dieser Option kann ein PC die vollständige Funktionalität
eines oder mehrerer Zielsysteme in quasi Echtzeit mit all
dessen Kommunikationsfunktionalitäten simulieren
Zur ElaSim Programmentwicklung gehört der Download von :

FIRMWARE
USERWARE
Integration eines Zielsystem-Variablen-Debuggers
Was ist neu in ElaSim V2.70

Integration von CPU167
Verwaltung verschiedener FIRMWARE-Versionen
Einbindung mehrerer C-Quellen und mehrerer Bibliotheken in einem Projekt.
Anbindung an die Microsoft Visual C++ V4.x und V5.0 Entwicklungsumgebung.
Automatisches Erzeugen von Makefiles entsprechend dem Zielsystemprozessor.
Lauffähig unter Windows95/98 und WindowsNT 4.0 .

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Zusammenhang der einzelnen Komponenten

Ein Zielsystem wird gewöhnlich nur mit der FIRMWARE
ausgeliefert. Dies entspricht, verglichen mit einem PC,
dem BIOS.
Da auch beim PC ein Endanwender ohne Betriebssystem

wenig damit anzufangen weiß, wird für unsere
Zielsysteme eine USERWARE benötigt.
In der Standard-Lieferumfang ist ein Projekt „Userware“
enthalten, welches für die beiden Zielsysteme :
CPU167 16-bit Prozessor
CPU960 32-bit Prozessor
vorcompilierte USERWARE enthält.
Diese USERWARE wurde aus folgenden Komponenten
aufgebaut :
Graph.lib (ElaGraph Kernel):
dieser Laufzeitkern ermöglicht die Lösung von MSR-
Aufgabenstellungen mit einer graphischen
Programmieroberfläche.
Design.lib (ElaDesign Kernel):
dieser Laufzeitkern ermöglich die Lösung von MMI-
Aufgabenstellungen mit einem Ressourcenworkshop.
Zonline.lib
(Zonline Communication Scheduler):
dieser Laufzeitkern übernimmt die
Kommunikationsaufgaben übergreifend zwischen
ElaGraph / ElaDesign / ElaSim.
0RGXO
Mit einem beliebigen Texteditor kann ein neues ANSI C-
Programm erstellt werden.
REF 6<66,0/,% 2%(;( 2%(;(
Die Einsprungfunktionen werden standardseitig in der

Datei „ob.c“ geführt.
&$1B0/,% &$1B0+(;
Die Übersetzung aller C-Quellen erfolgt mit dem zum &$1B0,2/,% &$1B0,2+(;
Zielsystem oder zur Simulation gehörenden Compiler. &$1B0,2/,% &$1B0,2+(;
&$1B0&3/,% &$1B0&3+(;
'RZQORDGSURJUDPP
=LHOKDUGZDUH
,1
2 87
HOUHVW

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Damit das Zielsystem auch mit weiteren Editoren :

ElaDesign Ressourcenworkshop
ElaGraph Flow-Chart, Ablaufplan- und
Funktionsplansprache.
zusätzlich programmiert werden kann, müssen die bereits
erwähnten Bibliotheken eingebunden werden.
Die Übersetzung der mit dem Ressourcen-Workshop
erstellten Masken erfolgt mit dem Ressourcen-Generator
(ResGen.exe).
Die Übersetzung der mit dem graphischen Editor
ElaGraph erstellten Abläufe erfolgt mit dem
Übersetzungsprogramm (iTrans32.exe).
Es können folgende Übersetzungsergebnisse

downgeladen werden :
FIRMWARE,
wird vom Zielsystemhersteller mitgeliefert.
USERWARE,
ist als Standardvorgabe im Projekt „Userware“
mitgeliefert, kann mittels ElaSim kundenspezifisch
angepaßt werden.
RESSOURCE,
das durch den Ressourcen-Generator (ResGen.exe)
erzeugte Flash-Dateisystem.
Hinweis : bei Download innerhalb von Elagraph wird die
Ressource ggf. mitgeladen.
ELAGRAPH CODE/PARAMETER,
die durch den Übersetzer (iTrans32.exe) erzeugten
Binärdaten.
Vorbereitete ElaGraph USER Bausteine

Im Standard Lieferumfang von ElaSim sind bereits 10
User-spezifische Bausteine vorbereitet.
Diese müssen lediglich mit applikations-spezifischen C-
Code ausgefüllt werden.
Der C-Code dieser USER-Bausteine wird durch den

Projektbaum mitverwaltet.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Neue ElaGraph Bausteine erstellen

Ein ElaGraph-Baustein kann zu dessen Parametrisierung
mit beliebig komplexen MFC Dialogen ausgestattet
werden.
PRIMITIVE BSP;
Das Erstellen dieser Bausteine erfolgt mittels eines INPUT
OUTPUT
SIGNAL
SIGNAL
X
Y
:
:
FLOAT
FLOAT
:
:
0,15
40,15
:
:
LEFT;
RIGHT;
Texteditors. INPUT SIGNAL Yu : FLOAT : 10,30 : DOWN;
INPUT SIGNAL Yo : FLOAT : 25,30 : DOWN;
OUTPUT SIGNAL Qu : BIT : 10, 0 : UP;
Das Generieren der Bausteine erfolgt durch den OUTPUT SIGNAL Qo : BIT : 25, 0 : UP;
mitgelieferten PERL Compiler. STATICSYM;
BEGIN
Dieser kann direkt in die Entwicklungsober-fläche von Width := 40;
Height := 30;
Visual Studio integriert werden. Bar(0:0:40:30);
Line(6, 0:0: 0:30: 30:30: 40:15: 30:0: 0:0);
Line(4, 3:27: 8:27: 22:3: 27:3);
END STATICSYM;
TARGET
BEGIN
{
if (X <= Yu) {
Y = Yu;
Qu = high;
Qo = low;
return;
}
if (X >= Yo) {
Y = Yo;
Qu = low;
Qo = high;
return;
}
Y = X;
Qu = low;
Qo = low;
}
END TARGET;
END BSP;
Mittels der optionalen Entwicklungsumgebung MFB SURMHFW!HGV

(Make Function Block) werden kundenspezifische
Bausteine aus der Quelle <project>.eds erzeugt.
Dabei entsteht automatisch Dateien für 3(5/&203,/(5
die Simulation
das Zielsystem
6LPXODWLRQ =LHOV\VWHP
SURMHFW!GOO SURMHFW!K
SURMHFW!PFR SURMHFW!F
SURMHFW!PRG

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Projektmanagement (Projekt.exe)
Ein ElaSim-Projekt kann bis zu 64 Module umfassen (CAN-Protokoll 1, 2 und Layer2)
Ein ElaSim-Projekt unterstützt verschiedene Zielprozessoren, wie
Intel 8051 alias CPU8051 in Vorbereitung
Intel 80251 alias CPU80251 in Vorbereitung
SAB 80515 alias CPU515
SAB 80515A alias CPU515A
SAB 80C515C alias CPU515C in Vorbereitung
SAB 80167 alias CPU167
I 80960 alias CPU960
Die entsprechenden Makefiles für die Zielsysteme und die Simulationsumgebung werden von ElaSim automatisch erzeugt.
Die zahlreichen Compiler-Einstellungen für die Zielsysteme werden automatisch von Elasim vorgenommen.
Zu jedem Projekt wird ein Simulationssystem zu den maximal 64 CAN-Modulen erzeugt. Diese Simulationsumgebung
umfaßt ein Visual.exe, welches bis zu 64 CAN-Module mit Bedienerinterface simuliert.
Der Laufzeitkern der einzelnen CAN-Module wird in eigenständigen Programmen
OB00.exe ... OB63.exe nachgebildet.
Projektaufbau
Der Aufbau eines ElaSim-Projektes :
Das Stammverzeichnis ...\Projektname\ kann auf einem beliebigen Pfad eingerichtet werden.
Der Projekt-Pfad und die Dateinamen im Projekt dürfen nicht mehr als 8 Zeichen lang sein,
wenn später der Keil-Compiler verwendet werden soll.
Ab diesem Stammverzeichnis wird für jedes CAN-Modul ein eigenes Unterverzeichnis geführt.
Bsp. : ...\Projekte\Projektname\Geraetename1
...\Projekte\Projektname\Geraetename2
.......
In jedem dieser Unterverzeichnisse (Geraetename1 ... Geraetename63 (Dev00 .... Dev63)) werden die entsprechenden
Makefiles für die unterschiedlichen Prozessoren generiert.
Bsp. : ...\Projekte\Projektname\Geraetename1\Elasim\USR_515.MAK
...\Projekte\Projektname\Geraetename1\Elasim\USR_167.MAK
...\Projekte\Projektname\Geraetename1\Elasim\USR_960.MAK
...\Projekte\Projektname\Geraetename1\Elasim\USR_SIM.MAK

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Nicht in ElaSim enthaltene Software (muß je nach Bedarf erworben werden) :

Betriebssytem
(Windows 95/98, Windows NT)
C-Compiler für die Simulation.(Microsoft Visual C/C++ V4.XX/V5.0)
C-Compiler um Programme für die 8-bit CPU (80535-Prozessor) zu erstellen
(Keil 8051-C-Compiler V4.01)
C-Compiler um Programme für die 32-bit CPU (80960-Prozessor) zu erstellen
(Microtec Research Compiler V2.0, GNU 960-C-Compiler)
+RVW 7DUJHW &RPSLOHU
0LFURVRIW
9LVXDO &&9;; 9
6LPXODWLRQ
*18 17
;
.(,/

$
:LQGRZV
:LQGRZV 17
*18 [
0LFURWHF 9
*18

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Projekte verwalten mit ElaSim
3URMHNW SURMHNWH[H
D 3URMHNWDXVZDKO
E &RPSLOLHUHQ 6LPXODWLRQ =LHOV\VWHP
9LVLXDOLVLHUXQJ YLVXDOH[H 'RZQORDGLQJ FDQBKH[H[H
D 6LPXODWLRQVEHGLHQXQJ D 3URJUDPP'RZQORDGLQJ
E 2IIOLQH'HEXJJLQJ E 2QOLQH'HEXJJLQJ
PLW 6LQJOH6WHS XQG %UHDNSRLQWV
Die Software-Pfade für ElaSim-Projekte setzen sich wie folgt zusammen :
Festplattenlaufwerk\Softwareverzeichnis\Softwarename\Projektzuordnung
z.B.
...\C51V4 => Keil Compiler V4.01
...\MICROV2 => Microtec Compiler V2.0
...\HighTec => GNU 167 Compiler V3.2
...\ElaSoft\EStudio\Default => Die Default-Daten, aus denen neue Projekte erzeugt werden
...\ElaSoft\Projekte => eigene Projekte und mitgelieferte Beispielprogramme
...\ElaSoft\Can_inc => Alle relevanten Include-Dateien
...\ElaSoft\Can_lib\V1_xx => Alle relevanten Librarys in den entsprechenden Unterverzeichnissen
ElaSim-Teilprogramme
In ElaSim enthaltene Programmteile :

Online-Debugging der Simulationsumgebung
Downloading für die einzelnen Zielsysteme
Aufruf eines Editors (Standard PFE32.EXE)
(der Aufruf von kundenspezifischen Editoren ist ebenso möglich)

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Makefile aus der Projektverwaltung

Die Projektverwaltung von ElaGraph ab V2.70 unterteilt das Makefile in zwei Makefiles pro Prozessor.
Beispiel :
Musr_960.mak
Hierin stehen die Grundeinstellungen zum Makefile. Dieses kann vom Anwender erweitert werden.
Pusr_960.mak
Dieses wird vor jedem Compiliervorgang neu erstellt. Hierin werden alle Programmodule aus der Projektverwaltung
automatisch eingefügt. Das unveränderliche Makefile Musr_960.mak wird darin eingebunden.
Momentan werden folgende Prozessoren unterstützt :

?usr_960.mak CPU960
?usr_167.mak CPU167
?usr_515.mak CPU515, CPU515A
?usr_sim.mak PC Simulation

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Die ersten Schritte zum ersten Projekt

Zuerst wird ein neues Projekt angelegt.
Bei der Auswahl der möglichen Objekte wird „Projekt“

ausgewählt.
Anschließend ein beliebiger Projektname eingegeben.

Bitte beachten Sie, daß nicht alle Zielsystem – Compiler mehr
als 8 Zeichen unterstützen. Deshalb wird eine Name von bis zu 8
Zeichen empfohlen.
Es folgt das Anlegen der sich im Projekt befindenden Geräte.
Wählen Sie als Objekt ein „Projektiertes Gerät“ aus.
Anschließend werden Sie nach der von Ihnen gewünschten PC-

Verbindung gefragt.
Falls Sie via der seriellen RS232 Schnittstelle kontakt mit dem
Zielsystem aufnehmen möchten, wählen Sie „RS232“ aus.
Falls Sie via der zuvor installierten CAN-MPC2-Einsteckkarte

kontakt mit dem Zielsystem aufnehmen möchten, wählen Sie
„CAN_MPC2“ aus.
Mit dem Button „...“ können Sie sensitiv der gewählten PC-
Verbindung die notwendigen Netzwerk Parameter vorwählen.
Anschließend wählen Sie den Button „Weiter“.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Bei der seriellen Schnittstelle genügt das Vorwählen des

richtigen COM-Ports :
„COM_1“, „COM_2“, „COM_3“, „COM_4“.
Vor Verwendung des Parameters „Rooting“ sollten Sie die

notwendigen Randbedingungen im Kapitel „Kommunikation“
nachlesen.
Im Eingabedialog „Allgemein“ müssen die Einstellungen für :

Name des Gerätes
Geräteart (CAN_M1, ..., CAN_P100)
Treiber, passend zur verwandten CPU
Knotennummer (M0,...,M63), entspricht der Netzwerkadresse.
eingestellt werden.
Um Sie von lästigen Eingaben zu entlasten ist den Button
„Autoscan“ vorgesehen.
Falls Sie ihre gewünschte(n) Zielsystem(e) bereits angeschlossen
haben, drücken Sie diese Schaltfläche und können anschließend
aus einer Listbox die am Bus gefundenen Zielsysteme
auswählen. Die Eingabewerten von :
Geräteart (CAN_M1, ..., CAN_P100)
Treiber, passend zur verwandten CPU
Knotennummer (M0,...,M63), entspricht der Netzwerkadresse.
werden automatisch übernommen.
Nach Ausfüllen der Felder könnte der Eingabe-dialog folgendes

Erscheinungsbild besitzen.
Mit der Schaltfläche „Fertig stellen“ beenden Sie das Erstellen
eines neuen Zielsystemes.
Jetzt wählen Sie bei selektiertem Gerät den Menüeintrag „Neu“:

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Es erscheint der Auswahldialog der möglichen Objekte.

Selektieren Sie :
„ElaSim-Program“
zur Erstellung eines USERWARE – Programmes.
Es folgt der Dialog für die Auswahl der Moduleinstellungen.

Falls Sie ein einfaches USERWARE-C-Programm erstellen
möchten, ohne Einbindung von anderen Bibliotheken, genügt es
diesen Dialog mit der Schaltfläche „OK“ zu bestätigen.
Die relevanten Einstellungen wie :

Prozessor
Firmware
werden aus den Moduleinstellungen automatisch übernommen.
Es wurde direkt in unser „XY_Projekt“ unter dem Zielsystem

„MeinPult“ eine Rubrik „Programme“ angelegt.
Unterhalb der Rubrik „Programme“ wird
„ElaSim-Program“ mit der Auflistung alle C-Dateien gelistet.
Wie oben beschrieben wird bei Standardvorgabe lediglich die
Datei „ob.c“ angezeigt.
Ein Doppelklick auf „ob.c“ öffnet automatisch den
voreingestellten Programmeditor mit dieser Datei.
In dem Programmeditor können Sie direkt mit der

Programmentwicklung beginnen.
In diesem Beispiel wurde in die Funktion „ob22()“ die

Progrannzeile :
lcd_vdspls(0,0,"Hallo");
ergänzt.
Die vorgehensweise zur Programmentwicklung sehen Sie im

folgenden Kapitel.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Anschließend können Sie über den Projektbaum direkt das

Übersetzen des soeben erstellen Programmes durchführen.
Dabei ist zwischen :
Zielsystem (reale Hardware)
Simulation (Zielsystemsimulation auf dem PC)
zu unterscheiden.
Es folgt die Abfrage, ob Sie die Simulation automatisch Starten

möchten.
Dies führt zum Start des Simulationsprogrammes für das

angelegte Zielsystem.
Im aktiven Display erscheint die Textausgabe „Hallo“, welche in
unserem ersten C-Porgramm eingefügt wurde.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Die Userware
Start der Userware „ob.c“

Damit in die USERWARE verschiedene Themenkreise
eingebunden werden können, wurde folgende
Bibliotheksstruktur eingeführt :
Unter dem Installationsverzeichnis:

\ElaSoft\can_lib
wird zunächst verzweigt in die verschiedenen
Firmwareversionsstände z.B. „V1_30“
Darunter wird eine Bibliothek „Zonline.lib“ pro unterstützter
Prozessor in den jeweiligen Unterverzeichnissen geführt.
Im Projektbaum (ab V2.61) ist lediglich einzutragen:
Ob.c:
als kompatible Schnittstelle zu bereits realisierten Projekten.
Uwmodul.c:
diese Datei dient zur generellen Konfiguration, welche
USERWARE-Programmteile zusammen-geführt werden
sollen.
User.c:
Der Source-Code zu den 10 vorbereiteten USERWARE-
Bausteinen für ElaGraph „USR0“ bis „USR9“.
Die gewünschte Bibliotheken können in dieser Rubrik

übernommen werden.
Als Bibliotheken sind vorhanden :

Uwbase.lib
Standard Funktionen (Zmalloc) aller Bibliotheken.
Graph.lib
ElaGraph-Kernel
Design.lib
ElaDesign-Kernel, dazu gehört Ressource- und Window-
System.
Zonline.lib
Kommunikations Scheduler

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Aufbau der Userware
Die Programmierung mit der ElaCAN™-Umgebung kann erfolgen :

zyklisch, d. h. der Organisationsbaustein ob1 wird zyklisch aufgerufen.
zeitzyklisch, d. h. in festen Zeitabständen (minimal 10 ms oder ein Vielfaches hiervon) wird eine Routine aufgerufen.
ereignisgesteuerte Programmverarbeitung, die Routine wird nach einem Flankenwechsel an den digitalen Eingängen
aufgerufen.
Als Funktionen stehen im Programm „ob.c“ zur Verfügung :

ob21
Wird vor ob22 aufgerufen, falls noch keine CAN-Verbindung stattgefunden hat.
ob22
Initialisieren der programminternen Variablen, bevor die Endlosschleife ob1 aufgerufen wird.
ob1
Wird zyklisch aufgerufen.
ob13
Timer- Interrupt. Wird zeitzyklisch alle 10 ms aufgerufen.
ob14
Timer- Interrupt. Wird zeitzyklisch aufgerufen. Die Zykluszeit ist im Bereich von 0... 65535 µs
(default 10 ms) einstellbar.
Neu ab Firmware-Version 1.20. Um alte Userware unter der neuen Firmware betreiben zu können, muß diese Funktion
eingefügt werden, auch wenn sie nicht genutzt wird.
Ein Beispiel zum Gebrauch und zur Konfiguration von ob14 finden Sie unter ...\Projekte\Ob14.
ob2_1
Alarmgesteuerter Aufruf. Interrupt- Routine, die ausgelöst wird, wenn am Eingang E1 eine positive Flanke angelegt wird
(nicht bei der 80960-CPU).
ob2_2
Alarmgesteuerter Aufruf. Interrupt- Routine, die ausgelöst wird, wenn am Eingang E2 eine positive Flanke angelegt wird
(nicht bei der 80960-CPU).
ob31
Wird aufgerufen, falls die einstellbare Zykluszeit überschritten wurde.
ob34
Wird aufgerufen nach ob22, falls die batteriegespeicherten Daten verändert wurden.
can_recv_telegram
Wird beim Eintreffen eines Telegramms über das CAN-Netzwerk durchgeführt.
rs232_interrupt
Empfangsinterrupt für Kommunikation über die RS232-Schnittstelle.
can_recv_masteractiv
Wird, falls ein Busmaster vorhanden ist, jede Sekunde aufgerufen. Dies dient zur Zeitsynchronisation zwischen Busmaster
und den Slave-Modulen.
Hinweis:
Alle oben aufgeführte Funktionen müssen in der USERWARE vorhanden sein.
Falls sie diese nicht nutzen, können die Funktionsinhalte leer bleiben.
Die Funktionsdeklarationen dürfen nicht gelöscht werden.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Zyklische Verarbeitung
3URJUDPPDEODXI
Die zyklische Programmverarbeitung ist die meistverwendete Art
Steuerungsprogramme zu erstellen.
Merkervariablen mit nahezu beliebigen Namen können frei nach C-Notation
definiert werden. Die Verknüpfung von Eingangs-und Ausgangsvariablen wird in
einigen Beispielen erläutert.
Nachteile :
Schnelle Signale (kleiner als die Zykluszeit) können nicht verarbeitet werden.
- Die Zykluszeit beträgt bei einer 8-bit CPU typisch 2-100ms.
- Die Zykluszeit beträgt bei einer 16-bit CPU typisch 0,5-20ms.
- Die Zykluszeit beträgt bei einer 32-bit CPU typisch 0,1-10ms. 0DLQWDVN
Firmware- Zugriff auf die Hardware:

Innerhalb von „ob1“ erfolgt nur ein Zugriff auf Speichervariablen, nicht direkt auf
die Hardware. +:=XJULII
Der eigentliche Hardwarezugriff erfolgt vor jedem „ob1“-Start.

Dabei werden zuerst die Eingänge gelesen und anschließend die Ausgänge gesetzt.
Vorteile :
Übersichtliche Programmierung möglich.
Einfachste Form der Programmierung.
Regeln der zyklischen Programmierung:

Zwingend ist das zyklische Verlassen von „ob1“, damit auf die Hardware zugegriffen werden kann. Aus diesem Grund dürfen
keine „while“-Schleifen verwendet werden.
Programmierfehler bei zu tiefer Schachtelungstiefe können den ganzen Ablauf gefährden.
Während der Bearbeitung von „ob1“ kann ein nicht deterministischer Interruptzugriff erfolgen, deshalb sind vom Programmierer
ggf. Verriegelungen zu berücksichtigen.
Die Eingangszustände müssen am Anfang von „ob1“ eingelesen werden.
Zum Beispiel mit den Funktionen:
can_read_long(modul_nr,0,PARM_TYP_DIG_EIN_LESEN,&can_eingang[modul_nr].l_data);
can_read_float(modul_nr,eing_nr,PARM_TYP_X_LESEN,&analoger_eingang_wert);
Die Ausgangszustände müssen am Ende von „ob1“ ausgegeben werden.
Zum Beispiel mit den Funktionen.
can_write_long(modul_nr,0,PARM_TYP_DIG_AUS,can_ausgang[modul_nr].l_data);
can_write_float(modul_nr,ausg_nr,PARM_TYP_ANALOG_AUS,analoger_eingang_wert);
Zu Beginn von „ob1“ sollte eine Notaus-Funktion realisiert sein.
...
void ob1
{
can_read_long(modul_nr,0,PARM_TPY_DIG_EIN_LESEN,&can_eingang[modul_nr].l_data);
...
if (NOTAUS) /* Wenn ein Notaus durchgeführt werden soll: ... */
{
... /* z.B. Ausgabe auf einem Display . . . */
can_write_long(modul_nr, . . . /* setzen der Ausgänge nach Wunsch */
return; /* danach wird "ob1" verlassen. */
}
... /* Hier steht der Programm-Code, der */
... /* abgearbeitet werden soll, wenn die */
... /* NOTAUS-Bedingung nicht erfüllt ist */

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Programmierung von Schrittketten, Folgesequenzen:

...
switch (schritt)
{
case 0:
if (. . .)
schritt++;
break;
case 1:
...
Es dürfen keine zeitintesiven Bearbeitungen in den Interruptroutinen erfolgen.

Sekunden-, Minuten-Timer:
...
void ob13() /* wird alle 10ms durchlaufen */
{
static ushort zehn_ms_auf_1s = 0;
static ushort zehn_ms_auf_1min = 0;
if (!zehn_ms_auf_1s--) /* wenn die Variable "zehn_ms_auf_1s" Null erreicht hat */
{
zehn_ms_auf_1s = 100; /* 10ms * 100 = 1s */
sekunden_zaehler++; /* Variable, die in "ob1" verwendet werden kann */
}
if (!zehn_ms_to_1min--)
{
zehn_ms_auf_1min = 60000; /* 10ms * 60000 = 1min */
minuten_zaehler++;
}
...
Die Funktion “ob1"

Die Funktion “ob1 ( )” muß als Abarbeitungskette programmiert werden.
Falls durch eine zu lange Verarbeitungszeit die einstellbare Zykluszeit überschritten wird, wird die Funktion ob31()
aufgerufen, in dieser können entsprechende Maßnahmen eingeleitet werden.
Ereignisorientierte Verarbeitung
Die ereignisgesteuerte Programmverarbeitung dient zur (UHLJQLVJHVWHXHUWHU 3URJUDPPDEODXI
Bearbeitung von schnellen Hardware-Signalen, die schneller ,QWHUUXSWHLQJDQJ ,QWHUUXSWHLQJDQJ
als die Zykluszeit sind.
(nicht verfügbar bei der 80960-CPU)
REB REB
Die Funktion “ob2_x”

Die Funktion “ob2_x ( )” entspricht einer Interruptfunktion, die bei Aktiveren des Interrupteinganges aufgerufen wird.
Aus dieser Interruptfunktion heraus dürfen nur Funktionen aufgerufen werden, die als “reentrant” deklariert
wurden! Es dürfen keine float-Werte benutzt werden.
Diese Interruptfunktion dient lediglich zum Generieren von Variablen.
Nach der Initialisierung werden die Interrupts für die Funktionen ob2_1 und ob2_2 freigeschaltet.
Mit der Funktion “can_set(CANMODUS_OB2_1,FALSE)” bzw. “can_set (CANMODUS_OB2_2,FALSE)” können diese
Interrupt gesperrt werden. Werden die Interrupteingänge als Frequenzzähleingänge benützt, müssen die Interruptaufrufe
aus Programmlaufzeitgründen gesperrt werden.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Zeitzyklische Verarbeitung
=HLWJHVWHXHUWHU 3URJUDPPDEODXI
,QWHUUXSW DOOH PV
Die zeitzyklische Programmverarbeitung dient zum einen

der Bearbeitung von Software-Timern, zum anderen der
Verarbeitung von zeitsynchronen Vorgängen.
Zum Beispiel kann hier ein Inkrementalzähler jede
Sekunde ausgelesen werden, um die Anzahl der Impulse
pro Sekunde zu ermitteln. RERE
Die Funktion “ob13“,“ob14“

Die Funktionen „ob13“ und „ob14“ entsprechen Timer-Interruptfunktionen. „ob13“ wird mit einer festen Zykluszeit alle
10msec aufgerufen. Die Zykluszeit von „ob14“ ist im Bereich von 0... 65535usec über den Parametertyp
„PARM_TYP_MODULSTATUS“ frei wählbar. Falls keine ausdrückliche Einstellung der Zykluszeit erfolgt, wird „ob14“
wie „ob13“ alle 10msec ausgeführt.
Aus dieser Interruptfunktion heraus dürfen nur Funktionen aufgerufen werden, die als “reentrant”
deklariert wurden! Es dürfen keine float-Werte verwendet werden.
Diese Interruptfunktion dient lediglich zum Generieren von zeitgesteuerten Variablen.
Bsp.:
...
void ob22()
{
u_long value;
...
/* Zeitbasis für ob14 (Hardwaretimer 2) einstellen in us. */
value.s_data[0] = 1000/*usec ==> 1msec*/;
can_write_long(meine_modul_nr, 8, PARM_TYP_MODULSTATUS, value.l_data);
...
}
void ob14()
{
ob14_zaehler++;

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Die Bereiche der Userware

Zentraler Einsprung (Uwmodul.c)
Bibliothek „Uwbase“
Bibliothek „Zonline“, der komplette Programmcode zum Kommunikationsscheduler
Bibliothek „Design“, der komplette Programmcode zu ElaDesign
Bibliothek „Graph“, der komplette Programmcode zu ElaGraph Kernel
ElaGraph zuladbare Bibliotheken
Verschiedene CAN Protokolle durch die Userware realisieren

Falls andere als die Elrest Protokol 1.0 oder 2.0 zum Einsatz kommen sollen, müssen diese in der USERWARE realisiert
werden. Dazu ist es notwendig mit dem Befehl :
can_set(CONNECT_CAN_RESPONSE, 0); /* New above FIRMWARE V1.40 */
das automatische Quittieren mit RESPONSE von REQUEST Anforderungen zu unterbinden.
Siehe nähere Erläuterung im Kapitel „Kommunikation“.
Mit den FIRMWARE Funktionen :
can_get_receivequeue( USIGN8 card, USIGN32 _HUGE* arg_recv_id,

USIGN16 _HUGE* systemtick, USIGN8 _HUGE* len,
USIGN8 HUGE* recv_dat)
can_req_unconfirmed( USIGN8 card, USIGN32 arg_send_id,

USIGN8 length, USIGN8 _HUGE* dat)
können andere Protokolle wie :

CANopen
DeviceNet
CAL
Mannesmann Demag
Fernheizungsregler
U.v.m
realisiert werden.
Für die praktische Umsetzung diverser Protokolle empfehlen wir dies in einem Workshop gemeinsam mit unseren Treiber
– Entwickler vorzunehmen.
Notation der Userware

Die USERWARE wurde nach der polnischen Notation geschrieben, d.h. eine Variable Y wird der Variablentyp beim
Namen vorangestellt. Folgende Abkürzungen:
p Pointer
n Number (char, long, short)
s String
sz String Zero (String mit abschließender Null)
db4 DATABUFFER4 (siehe stuct u_long)
b Bool

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Aufteilung Userware in verschiedene Bibliotheksfunktionen
Aufbau der Userware Bibliothek „UWbase“

In der Bibliothek UWbase ist enthalten:
UW_UTIL.C
ZMALLOC.C
Aufbau der Userware Bereich „Zonline“

Hierfür wurde der Compilerschalter :
„#define ZONLINE_ACTIVE“
eingeführt. Mittels diesem Schalter wird im Uwmodul.c nur der relevante Teil übersetzt.
In der Bibliothek Zonline ist enthalten:

• CAN_M960.C
Device-Treiber für CPU167 und/oder CPU960
• CAN_M515.C
Device-Treiber für CPU515
• CAN_MX.C
Device-Treiber für CPU515 und/oder CPU167 und/oder CPU960
• RS_PROT2.C
Elrest Protokol 1.0 und/oder 2.0 für serielle Schnittstelle
• L2_PROT2.C
Layer 2 des Elrest Protokolles.
• L7_PROT2.C
Alle auf Layer 2 basierende höhere Protokollschichten.
• L7_DRV.C
Alle Dienste des Elrest Protokolles-
• DRIVER.C
Verwaltung von Driver.
• DEVICE.C
Verwaltung von Device.
• ZONLINE.C
Applikationsinterface zu Zonline.
SCHEDULE.C
Realtime Scheduler von Zonline.
HASH.C
Hash – Tabelle, zur Verwaltung dynamischer Suchroutinen.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
6FKLFKW
'5,9(56&
'LHQVWH 6HUYLFH YRP 7UHLEHU

6FKLFKW 6WDQGDUG '3 (OD*UDSK '3 'RZQORDG 2IIOLQH 'DWHQ $XWRVFDQ
/B'UYF (OD*UDSKF 'RZQORDGF 2IIOLQHF $XWRVFDQ
'RZQ/'F 'RZQ/'F
/B3URWF
6FKLFKW 3& 0RGXO
/B3URWF /B3URWF
&$103& 56 &$103& 56
&DQB:LQF 56B3URWF &DQBF 56B3URWF
56B:LQF 56F
,62 ,(& ,62 ,(&
Namenskonventionen für ZOnline
ZOnline ruft bei Programmstart die Funktion Driver_SetFunctionDLL( ) auf. In dieser Funktion wird eine Struktur mit
Functionpointer zugewiesen. Hiermit wird erreicht, daß die C-Funktionen dem entsprechendem Treibernamen, z.B. RS232
zugeordnet wird.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Funktionsweise von ZOnline
verwendete Funktionen:
pDriverDllStruct->SlotReceiveData = (void _FUNC_PTR*)L7_Drv_SlotReceiveData;
pDriverDllStruct->SlotTransmitData = (void _FUNC_PTR*)L7_Drv_SlotTransmitData;
pDriverDllStruct->SizeDataList = (void _FUNC_PTR*)L7_Drv_SizeDataList;
pDriverDllStruct->GetSchedulerCycle = (void _FUNC_PTR*)L7_Drv_GetSchedulerCycle;
pDriverDllStruct->GetPreTime = (void _FUNC_PTR*)L7_Drv_GetPreTime;

pDriverDllStruct->WindowDriverParameter = (void _FUNC_PTR*)L7_Drv_WindowDriverParameter;
pDriverDllStruct->InitDriverSlot = (void _FUNC_PTR*)L7_Drv_InitDriverSlot;
pDriverDllStruct->GetRestartTime = (void _FUNC_PTR*)L7_Drv_GetRestartTime;
pDriverDllStruct->GetRestartTelegram = (void _FUNC_PTR*)L7_Drv_GetRestartTelegram;
Eine Anfrage von ZOnline erfolgt indem die Funktion L7_Drv_SlotTransmitData ausgeführt wird. In dieser Funktion werden
alle vorhandenen Dienste abgearbeitet.
Dienste Adressierungsmodus
1. Autoscan
2. ElaSim Firmware Download ADRESSMODE_C_DOWNLOAD
3. ElaSim Userware Download ADRESSMODE_C_DOWNLOAD
4. ElaSim Ressource Download ADRESSMODE_C_DOWNLOAD
5. ElaGraph Attributfile und Download ADRESSMODE_ELAGRAPH_DIRECT
6. CAN ID direct ADRESSMODE_CAN_ID_DIRECT
7. Restart Telegram ADRESSMODE_DIRECT
DATATYPE_ERRORTELEGRAMM
8. Schreiber ADRESSMODE_OFFLINE_SCHREIBER
ADRESSMODE_GESAMT_SCHREIBER
9. Firmware-Variablen ADRESSMODE_DIRECT
10. C-based Variablen ADRESSMODE_USERWARE
ADRESSMODE_C_VARIABLE
ADRESSMODE_ELEGRAPH

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Nach Ablauf der cycle time werden die Antworten durch die Funktion L7_Drv_SlotReceiveData ausgewertet.
Die Funktion L7_Drv_SizeDataList gibt an, wie viele DP pro cycle time maximal verschickt werden dürfen.
Die Funktion L7_Drv_GetSchedulerCycle gibt die cycle time an. Die cycle time wird in Abhängigkeit vom Treiber und der
Übertragungsrate ermittelt.
L7_Drv_GetSchedulerCycle= cycle time. Entspricht der kürzesten Zeit in der Telegramme gesendet werden. Polltime ist die
einstellbare Zykluszeit und ist ein vielfaches von cycle time. Bei Öffnen von Tasks (CanHex) mit unterschiedlichen
Zykluszeiten hat der Task mit der kleinsten Zykuszeit die höchste Priorität, d.h. möchte dieser Task in seiner vorgegebenen
Zykluszeit Telegramme versenden, so unterbricht er den Task mit der größen Zykluszeit, wenn diese zur selben Zeit
Telegramme versenden will
Bsp.:
Einstellungen: bei 123kBaud Æ cycle time = 100ms
Task1: Zykluszeit 200ms, 3 DP Æ 15 Telegramme/Sek.
Summe: 35 Telegramme/Sek.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Arbeiten mit Datenpunkte direkt aus der Userware
Es bietet sich an, mit denselben Datenpunkten in der

Programmierung von C Programmen unter ElaSim zu
arbeiten, wie unter ElaDesign und/oder ElaGraph.
Es müssen mindestens die Bibliotheken :

• sys<processor>.lib
• Uwbase.lib
Basisbibliothek, in der diverse Hilfsfunktionen
definiert wurden.
• Zonline.lib
Stellt die eigentliche Funktionalität des Echtzeit
Kommunikations Schedulers dar.
eingebunden werden.
Zuerst muß ein Datenpunkt Handle erzeugt werden. Die void _HUGE* ResTypeGetZOnlineDatapoint(USIGN32 nID,
Funktion „ResTypeGetZonlineDatapoint()“ liefert ein char _HUGE* _HUGE* ppszUnit, int _HUGE*
pOnlineDataType, DATABUFFER4 _HUGE* db4VarMin,
Handle auf einen Datenpunkt zurück, sofern die DATABUFFER4 _HUGE* db4VarMax, DATABUFFER4 _HUGE*
Definition dieses Datenpunktes durch nID richtig db4DefaultValue)
angegeben wurde.
[Resource Offset]
Es gilt zu beachten, daß nID einer physikalischen ID
Bitmap=1000000
entspricht. Die Offsets aus der Spalte „ID“ müssen noch
Text=2000000
je nach Themenkreis mit Ihren Resource Offset addiert
DataPoint=3000000
werden.
Mask=4000000
Die Resouce Offset sind in der Device.set im Driver=5000000
Geräteverzeichnis geführt. Device=6000000
Font=7000000
Im gegenwärtigen Stand sind die Offset fest, sodaß diese
System=8000000
mit einer #define Anweisung als Konstante im C-
Programm integriert werden können.
Im C-Source verwendet als :
#define OFFSET_BITMAP 1000000L
#define OFFSET_TEXT 2000000L
#define OFFSET_MASK 4000000L
#define OFFSET_FONT 7000000L
Die physikalischen IDs werden vom System vergeben

und entsprechen meist direkt der Satznummer in der nMaskID = res_GetResIDFromLogID(&(pUserVar-
Datenbank. Werden Ressourcen von einem Proojekt zum >rc),RESOURCE_TYPE_MASK, nLogMaskID);
anderen kopiert erfolgt die Vergabe der physikalischen nPhyBmpID = res_GetResIDFromLogID(&(pUserVar-
IDs automatisch und kann nicht geändert werden. >rc),RESOURCE_TYPE_BITMAP, nLogBmpID);
Es wurde ein weiterer Ordnungsbegriff eingeführt, die

logische ID. Diese kann manuell beliebig in einem
Projekt geändert werden. Sie muß eindeutig sein und kann
die Sortierung nach logischen Gesichtpunkten
entsprechen.
Die Funktion „res_GetResIDFromLogID“ dient zur
Ermittlung der physikalischen ID aus einer logischen ID.
Nachdem der Datenpunkt Handle erzeugt wurde, stehen
prinzipiell zwei Funktionen zur Verfügung :
• Lesen des Datenpunktes BOOL Target_ReadDataPoint(void _HUGE* hdl, void _HUGE*
Buffer)
• Schreiben des Datenpunktes
BOOL Target_WriteDataPoint(void _HUGE* hdl, void
_HUGE* Buffer)

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Aufbau der Userware Bereich „ElaDesign“

Hierfür wurden die Compilerschalter „#define RESSOURCE_ACTIVE“ und „#define ZWINDOWS_ACTIVE“
eingeführt. Mittels dieser Schalter wird im Uwmodul.c nur der relevante Teil übersetzt.
MENUE.C
PASSWORD.C
SOFTBUTT.C
FSCR.C
FIELD.C (nur für CPU167, ansonsten ist diese Funktionalität in der FW)
EZONLINE.C
ZWINDOWS.C
BARGRAPH.C
RESTYPE1.C
Aufbau der Userware Bereich „ElaGraph Kernel Programmcode“

Hierfür wurde der Compilerschalter „#define ELAGRAPH_ACTIVE“ eingeführt. Mittels diesem Schalter wird im
Uwmodul.c nur der relevante Teil übersetzt.
Ablauf.C
Kernel.C
Comu.C
Din.C
Icon.C
Para.C
Target.C
Näheres zu den Userware Bibliotheken
Verzeichnisse zu ElaGraph
Quellen
Die Quellen *.eds werden mit der MFB (Mkae Function Block) Umgebung bearbeitet und stehen unter :
\MFB4063\Biblio\UsrLib
Simulation
Für die Simulation (iRTK32.exe) werden 2 Dateien benötigt. Die <project>.mco ist die graphische Darstellung eines
Bausteines, die <project>.dll stellt den funktionalen Anteil (C-Code) eines Bausteines dar und stehen unter:
\ElaSoft\ElaGraph\Lib
Zielsystem-Include
Um das Zielsystem compilieren zu können, müssen die Bausteine den ElaGraph Laufzeitkernel des Zielsystemes mitgeteilt
werden. Dazu wird die Datei <project>.h als Function-Prototyping und die <project>.mod als Function-Array benötigt und
stehen unter : \ElaSoft\Can_inc\BibGraph
Zielsystem
Um ein Zielsystem zu erzeugen werden in der ElaSim C-Programmierumgebung die aus der *.eds Quelle erzeugten C-
Quellen für das Zielsystem und dessen Compiler übersetzt in in das USERWARE Projekt mit eingebunden. Die von Elrest
erzeugten ElaGraph-Bibliotheken (ModIO1, ModAdv1,...) werden nicht im Quellcode „*.c“, sondern lediglich als
Bibliothek für den jeweiligen Zielsystemcompiler mitgeliefert. Die Verzeichnisse der Elrest Bibliothek werden in
Versionsnummern und nach Prozessor unterschieden :
\ElaSoft\Can_lib\V1_30\960\ModIO1.lib
\ElaSoft\Can_lib\V1_40\167\ModIO1.lib

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
ElaGraph Bibliotheken ab V1.00

Quelle Simulation Zielsystem-Include Zielsystem
Schreib.eds Schreib.mco Schreib.h Schreib.lib aus Schreib.c
Schreib.dll Schreib.mod
ModAdapt.eds ModAdapt.mco ModAdapt.h ModAdapt.lib aus ModAdapt.c
ModAdapt.dll ModAdapt.mod
ModIO.eds ModIO.mco ModIO.h ModIO.lib aus ModIO.c
ModIO.dll ModIO.mod
ModSFB.eds ModSFB.mco ModSFB.h ModSFB.lib aus ModSFB.c
ModSFB.dll ModSFB.mod
ElaGraph Bibliothek ab V2.50

ModIO.dll ModIO.mod
ModADV1.eds ModADV1.mco ModADV1.h ModADV1.lib aus ModADV1.c
ModADV1.dll ModADV1.mod

ModIO.dll ModIO.mod
Selbst1.eds Selbst1.mco Selbst1.h Selbst1.lib aus Selbst1.c
Selbst1.dll Selbst1.mod
Remote1.eds Remote1.mco Remote1.h Remote1.lib aus Remote1.c
Remote1.dll Remote1.mod
Comm0104.eds Comm0104.mco ModComm1.h ModComm1.lib aus ModComm1.c
ModComm1.eds ModComm1.dll ModComm1.mod
Pult0109.eds Pult0110.mco Modpult1.h Modpult1.lib aus Modpult1.c
ModPult1.eds Modpult1.dll Modpult1.mod

Quelle Simulation Zielsystem- Zielsystem
Include
Sequence.eds Sequence.mco Ablauf.h Graph.lib integriert, da fester Bestandteil
Ablauf.eds Ablauf.dll Ablauf.mod
Schrittkette Sequence.hlp
Kernel.eds Kernel.h Graph.lib integriert, da fester Bestandteil
Kernel Kernel.mod
Funktionen
Archiv.eds Archiv.mco Wurde entfernt und durch Schreib ersetzt.
Vorgängerversio Archiv.dll Wird aus Kompatiblitätsgründen dennoch
n von Schreib weiter geführt.
Comm0104.eds Comm0104.mco Aus Kompatiblitätsgründen
ModComm1.eds ModComm1.dll
Comm0105.eds Comm0105.mco ModComm1.h ModComm1.lib aus ModComm1.c
ModComm1.eds ModComm1.dll ModComm1.mod

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Kommunikation Comm0105.hlp
s-bausteine zu
Zonline
Adapter zur ModAdapt.dll ModAdapt.mod
Daten- ModAdapt.hlp
konvertierung
ModAdv1.eds ModAdv1.mco ModAdv1.h ModAdv1.lib aus ModAdv1.c
Erweiterte ModAdv1.dll ModAdv1.mod
Reglerfunktione ModAdv1.hlp
n
ModCAL1.eds ModCAL1.mco ModCAL1.h ModCAL1.lib aus ModCAL1.c
Kalender- ModCAL1.dll ModCAL1.mod
funktionen ModCAL1.hlp
ModIO.eds ModIO.mco Aus Kompatiblitätsgründen
ModIO1.dll
ModIO1.eds ModIO1.mco ModIO1.h ModIO1.lib aus ModIO1.c
Digitale und ModIO1.dll ModIO1.mod
Analoge Ein- ModIO1.hlp
und Ausgänge
Alle boolsch, ModSFB.dll ModSFB.mod
mathematische ModSFB.hlp
Funktionen
Para.eds Para.mco
Dient zur Para.hlp
Parametereinga
be
Pult0109.eds Pult0109.mco Aus Kompatiblitätsgründen
ModPult1.eds Modpult1.dll
Pult0110.hlp
Pult0201.hlp
Remote1.eds Remote1.mco Remote1.h Remote1.lib aus Remote1.c
Ansteuerung Remote1.dll Remote1.mod
Remote Remote1.hlp
Terminals
(CAN_P50)
Offline - Schreib.dll Schreib.mod
Schreiber Schreib.hlp
Selbst1.eds Selbst1.mco Selbst1.h Selbst1.lib aus Selbst1.c
Selbstoptimierun Selbst1.dll Selbst1.mod
g Selbst1.hlp
User.eds User.mco User.h User.c
Kundenspezifisc User.dll User.mod
he C-
Funktionen
innerhalb von
ElaSim
Visual.eds Visual.mco
Dient zur Visual.hlp
Anzeige

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Beispiele der Programmierung

Programmbeispiel “Boolsche Verknüpfungen” in “C
Beispiel 1 : %HLVSLHO
if ( M0_E1 | | M0_E2 ) 0B( 0B(

M0_A1_EIN;
else
M0_A1_AUS;
0B$
if ( M0_E1 && M0_E2 )

0B(
M0_A2_EIN;
else
0B(
M0_A2_AUS;
0B$
if ( M0_E1 && ( M0_E2 | | M0_E3 ) ) 0B(

M0_A3_EIN;
else
M0_A3_AUS; 0B( 0B(
0B$
Beispiel 4 :
%HLVSLHO
if ( (M0_E1 && M0_E2 ) | | M0_E3 )
0B(
M0_A4_EIN;
else
M0_A4_AUS;
0B( 0B(
0B$

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Programmbeispiel “Analogverarbeitung” in “C”

Beispiel :
float analog_wert3
...
can_read_float(0,3,PARM_TYP_X,&analog_wert3);
if ( analog_wert3 > 200.0F )
M0_A1_EIN;
else
M0_A1_AUS;
Falls der Meßwert des analogen Einganges von Modul 0, Zone 3 den Wert 200 der physikalischen Maßeinheit z.B. “bar”
überschreitet, wird der Ausgang des Moduls 0 M0_A1 eingeschaltet. In anderen Fall bleibt dieser ausgeschaltet. Mit dem
Funktionsparameter “PARM_TYP_X” wird der skalierte Istwert bestimmt.
Programmbeispiel “Mathematische Operationen” in “C”
Beispiel :
float sin_wert;
sin_wert = sin(30.0F) * 2.0F;
Programmbeispiel “Regler parametrisieren” in “C”

Die integrierten Reglerfunktionen in den CAN-Modulen können über die nachfolgende Funktion konfiguriert werden.
Beispiel :
Es soll ein Regler konfiguriert werden, an dem ein Thermoelement
angeschlossen wird und der mittels eines Schützes (als Stellventil) 5HJOHU 6WHOO 6WUHFNH
die Heizung direkt mit 400VAC ansteuert. Folgende Schritte sind YHQWLO
hierfür notwendig :
Festlegen des Regelkreises im Modul

Einstellen der Fühlerart
Bestimmung des Reglertyps (siehe dazu Umdruck “Reglertypen nach DIN19226")
Festlegen des Ausganges A4 zum Ansteuern des Schützes.
Einstellen des Sollwertes von 120°C
Beispiel :
char regelkreis = 2;
...
/* Modul 0 sendet an Modul 0 und konfiguriert hiermit sich selbst. */
can_write_float(0,regelkreis,PARM_TYP_FUEHLERART,FUEHLERART_PT100);
can_write_float(0,regelkreis,PARM_TYP_REGELTYP,REGELTYP_ZPMR);
can_write_float(0,regelkreis,PARM_TYP_BIT1,3.0F); /* 00 .. 31-0 entspricht A1 .. A32 */
can_write_float(0,regelkreis,PARM_TYP_SOLLWERT,120.0F);

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Die FIRMWARE
((3520 6SHLFKHU
/(',QWHUIDFH
/&' ,QWHUIDFH
7H[WDQ]HLJH
*UDSKLN
3DUDOOHOH 6FKQLWWVWHOOH
'UXFNHU
6HULHOOH 6FKQLWWVWHOOH
)UHPGUHFKQHU
RE
0RGHP
&$1,QWHUIDFH
7DVWDWXU
(FKW]HLWXKU
1
, ,1
,1 ,1
28 7 287
H O UH V W H OUH VW
Die einzelnen FIRMWARE Funktionen werden in der Online-Hilfe dokumentiert.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Festlegung der thematischen Adressbereiche

In den Include-Files \ElaSoft\can_inc :
RANGE960.h
RANGE167.h
wird das folgende Adressmapping festgelegt.
Hardware Adressmapping
Nutzung der Festspeicher CPU515 CPU167 CPU960
(Flash-Speicher) Bereiche
Firmware ab 0x0000..7FFF ab 0x00000000L ab 0x00000000L

entspricht dem BIOS beim PC 32 kByte CODE 64 kByte 64 kByte
FIRMWARE_CODE_BEGIN
FIRMWARE_CODE_LEN
Userware (C-Programmcode) ab 0x8000..FFFF ab 0x00010000L ab 0x00010000L

entspricht dem 32 kByte CODE 576 kByte 192 kByte
Anwendungsprogramm (9 x 64 kByte) (3 x 64 kByte)
<project>.exe beim PC
USERWARE_CODE_BEGIN
USERWARE_CODE_LEN
Ressourcen (bei ElaDesign) ab 0x000A0000L ab 0x00040000L

entspricht den Daten innerhalb einer nicht vorhanden 256 kByte 128 kByte
Verzeichnisstruktur beim PC (4 x 64 kByte) (2 x 64 kByte)
RESSOURCE_CODE_BEGIN
RESSOURCE_CODE_LEN
ElaGraph-Programmcode ab 0x000E0000L ab 0x00060000L

(bei ElaGraph) ab 0x8000..BFFF 64 kByte 64 kByte
entspricht Programmcode in der 16 kByte XDATA (1 x 64 kByte) (1 x 64 kByte)
<project >.mvl beim PC
ELAGRAPH_MVL_CODE_BEGIN
ELAGRAPH_MVL_CODE_LEN
Remanente-Parameter ab 0x000F0000L ab 0x00070000L

(bei ElaDesign oder ElaGraph) ab 0xC000..FFFF 64 kByte 64 kByte
entspricht Parametereinstelldaten, 16 kByte XDATA (1 x 64 kByte) (1 x 64 kByte)
die beim PC auf Festplatte
gespeichert werden.
ELAGRAPHPARA_CODE_BEGIN
ELAGRAPHPARA_CODE_LEN
Hinweis zu CPU515 :
Erkennungs-Zeichenfolge;
Gibt die Versionsnummer der verwendeten Interface-funktionen an.
Bsp.: Die Library „SYS515M.LIB“ erzeugt „ V1.2“

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Nutzung der Arbeitsspeicher CPU515 CPU167 CPU960

(RAM-Speicher) Bereiche
Firmware ab 0x0000..1FFF ab 0x00800000 ab 0xE0000000

Arbeitsspeicherbedarf der 2 kByte XDATA 128 kByte 64 kByte
Firmware
FIRMWARE_RAM_BEGIN
FIRMWARE_RAM_LEN
Userware (C-Programmcode) ab 0x2000..3FFF ab 0x00820000L ab 0xE0010000

Arbeitsspeicherbedarf des 2 kByte XDATA 64 kByte 14 kByte
Anwendungsprogramm.
USERWARE_RAM_BEGIN
USERWARE_RAM_LEN
Bereich für ZMALLOC nicht vorhanden ab 0x00830000L ab 0xE0013800

Dies ist der dynamische 320 kByte 50 kByte
Arbeitsspeicherbedarf für Zmalloc.
USERWARE_MALLOC_BEGIN
USERWARE_MALLOC_LEN
Zykluszeitüberwachung
In der Firmware besteht die Möglichkeit die Programmdurchlaufzeit von ob1() zu kontrollieren.
Im ob22() :
{
can_set(CYCLE_TIMEOUT,1000); /*1000 x 10 ms*/
}
Im ob31() :
{
DISABLE;
while (1);
}
Mit „can_set....“ wird die Zykluszeitüberwachung auf 1000 x 10ms = 10sec aktiviert.
Verweilt das Programm länger als 10s im ob1,zum Beispiel durch eine programmierte while (...) Schleife, springt die
Firmware in den ob31.
Im ob31 werden alle Interrupts gesperrt und mit einem while(1); auf den Hardwarewatchdog gewartet.
Dieser resetet nach 1-2s das Modul.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Wichtige Hinweise zur USERWARE auf verschiedener

Prozessoren/Compilern
Hinweis für CPU515
Die Firmware prüft die Erkennungs-Zeichenfolge ab und startet das USERWARE-Programm nur, falls die FIRMWARE-
Version mit der Library-Version übereinstimmt.
Bsp. 1: Firmware-Version 1.00 ... 1.19 Bsp. 2: Firmware-Version 1.20 ... 1.29
Library-Version 1.0 Library-Version 1.2
FFF0-FFFF „CAN_M1 V1.0“ FFF0-FFFF „ V1.2“
Damit wird sichergestellt, daß FIRMWARE und USERWARE zusammenpassen.
Bei Modulen wird bei einem Neustart mit der Hex-Schalter Stellung “F”
Hinweis zum Zielssystem
oder bei Pulten in der Service Stellung die komplette Userware gelöscht
werden.
Wichtige Regeln für Ihren C-Code :

Motorola-Notation, d.h.
Mastermerker Char0 == 0x00
Mastermerker Char0 == 0xF6
Mastermerker Short0 == 0x0000
Mastermerker Short1 == 0xF642
Mastermerker Long == 0x0000F642
Mastermerker Float == 123.0
Bei Userware Programme die mit

verschiedenen Prozessoren Daten
austauschen, muß die Notation des
jeweiligen Prozessors berücksichtigt
werden
Floating-Point Unit Floating-Point-Operationen werden auf einer 8- und 16-bit CPU

per Software realisiert und sind deshalb äußerst rechenzeitintensiv
(z.B. bei einem 80535-Prozessor mit @12MHz dauert eine Float-
Addition 190us).
Hinweis zu Interrupt - Funktionen ob13 wird aus dem Hardwaretimer 0 aufgerufen
ob14 wird aus dem Hardwaretimer 2 aufgerufen
Æ
kleinste sinnvolle Zeit 1000 usec = 1 msec
1 kHz
Hinweis zu ob22 In ob22 muß mindestens ein Funktionsaufruf erfolgen. Sinnvoll ist zum
Beispiel das Lesen der
Modulnummer des betreffenden Moduls. Das erfolgt mit der
Programmzeile:
meine_modul_nr = can_set(CANMODUS_MODULADRESSE,0);
Hinweise zu Linker Fehler Werden aus ob22 und ob1 dieselben Funktionen aufgerufen, produziert
der KEIL-Compiler einen
Linker-Fehler.
Abhilfe: Am Ende von ob22 wird ob1 einmalig aufgerufen.
Hinweis für den KEIL- Compiler Logische BIT- Operationen sollten mit „unsigned char“-Datentypen
(SAB 80515-12-, SAB 80515A-18- erfolgen. Damit kann eine schnellere Abarbeitung erreicht werden.
CPU):

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Hinweis für CPU167

Es handelt sich um eine 16-bit CPU, die mit einem Assembler – Befehl einen 8-bit oder 16-bit Speicherzugriff vornehmen
kann.
Bei Modulen oder bei Pulten kann die Userware nur via CAN oder
RS232 gelöscht werden.

Intel-Notation, d.h.

werden
Floating-Point Unit Floating-Point-Operationen werden auf einer 8- und 16-bit CPU

per Software realisiert und sind deshalb äußerst rechenzeitintensiv
(z.B. bei einem 80535-Prozessor mit @12MHz dauert eine Float-
Addition 190us).
Hinweis zu Interrupt - Funktionen

Æ
ob13 und ob14 werden aus einem extern getriggerten Zeitgeber
generiert. Kleinste mögliche Zeit 750 usec = 0.75 msec 1.25 kHz
Es dürfen lediglich _HUGE - Pointer (32-bit linearer Adreßspeicher)
Hinweis zu Pointer
verwendet werden.
char _HUGE* pXY;
Anstatt
char * pXY;
Falls der Operator sizeof(STRUCT) verwendet wird, muß beachtet
Hinweis zu Strukturen
werden, daß das Alignment vom GNU-Compiler automatisch auf 16-bit
erweitert wird.
Bei der Verwendung von der Bibliotheksfunktion „sprintf“ muß
Hinweis zu der Funktion „sprintf“
beachtet werden, daß der Cast Operator „(char far*)“ verwendet wird :
sprintf(szBuffer, „Name = %s“, (char far*)szName);
Des weitern können mit „sprintf“ kein float oder double – Variablen
formatiert werden.
Alle ob1(), ob22().... Funktionen, die aus der Firmware gerufen werden müssen zwingend im der Programmdatei ob.c
stehen.
HINWEIS : Dies war bei CPU515 und CPU960 nicht zwingend notwendig.
_NEAR Funktionen sollten nicht verwendet werden.
Bei Aufruf von Funktionen
memcpy(((USIGN32 _HUGE*)szDataBufferRead) + nActualAreaNo, pDest, sizeof(long));
Dürfen keine Adressoperationen im Argument passieren !

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Hinweis für CPU960

Bei Modulen oder bei Pulten kann die Userware nur via CAN oder
RS232 gelöscht werden.
Bei Modulen wird bei einem Neustart mit der Hex-Schalter Stellung “F”
oder bei Pulten in der Service Stellung die komplette Userware gelöscht
werden.

Intel-Notation, d.h.

werden
Linearer Adressraum von 4GB.
Floating-Point Unit Floating-Point-Operationen auf einer 32-bit CPU mit integrierter
Floating-Point-Unit werden per Hardware realisiert und sind
deshalb wesentlich schneller.
(z.B. bei einem 80960SB-Prozessor mit @32MHz dauert eine
Float-Addition 625ns)
Hinweis zu Interrupt - Funktionen

Æ
ob13 und ob14 werden aus einem extern getriggerten Zeitgeber
generiert. Kleinste mögliche Zeit 750 usec = 0.75 msec 1.25 kHz

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
USERWARE Programmbeispiele
Programmaufbau
Ablaufprogrammkopf
/*
* OB.C
*
* Version : x.x
*
* Copyright (C) 1990-1999 elrest Automationssysteme GmbH
*/
#include \ElaSoft\can_inc\oh.h
Im Programmkopf sollte die aktuelle Versionsnummer, Änderungsindex, Datum, Programmierer und vieles mehr
eingetragen werden. Die Form der Darstellung ist innerhalb der Kommentarklammern frei wählbar.
Die generelle Includedatei „ob.h“ steht nach der Installation in einem absoluten Verzeichnis, damit sichergestellt wird, daß
alle Programme auf nur diese einzige Datei zugreifen.
Variable deklarieren
short schritt;
short zaehler = 0;
short zaehler_flanke = 0;
Es folgt die Deklaration von globalen Variablen.

Modulübergreifende globale Variable sollten im Modul “projekt.h” mit dem Präfix GLOBAL deklariert werden. Die
Includedatei „projekt.h“ soll modulübergreifend alle modulglobale Variablen verwalten.
Initialisieren im “ob22()”
/*
* Initialisierung
*/
void ob22()
{
schritt = 1;
}
Die Funktion “ob22()” wird einmalig nach dem Programmstart durchlaufen. In dieser Funktion müssen alle
Initialisierungsarbeiten erfolgen. Im obigen Beispiel wurde die Variable “schritt” auf den Wert 1 vorbesetzt. Wie in dem
oberen Beispiel zu ersehen, könnte aber bei der Deklaration einer Variablen dieser auch unmittelbar ein Wert zugewiesen
werden.
Ablauf in “ob1()”
Es wird bei Schritt 1 begonnen, da die Variable so vordefiniert wurde. Es wird unmittelbar in den Folgeschritt 2
gewechselt, nachdem die analogen Ausgänge AA1 und AA2 auf 10.0 Volt gesetzt wurden.
/*
* Ablaufsteuerung
*/
void ob1()
{
if ( schritt == 1 )
{
schritt = 2;
can_write_float(0,0,PARM_TYP_ANALOG _AUS,4000.0);
can_write_float(0,1,PARM_TYP_ANALOG _AUS,4000.0);
}
Das eigentliche Steuerungsprogramm wird in der Funktion “ob1()” realisiert.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Zählvorgänge und Zeitgeber

Beispiele in Æ ...\Projekte\DemoSim\P200_CNT\ElaSim\ob.c und ...\MM2_CNT\ElaSim\ob.c
Softwarezähleingang im ob1()
Der Zähler „zaehler_1“ wird inkrementiert, falls sich die Eingangsflanke des Eingangs M1_E1 von LOW nach HIGH
ändert. Hat der Zähler den Wert 5 erreicht, werden die nächsten Schritte eingeleitet.
ulong zaehler_1 = 0;
short zaehler_flanke = 0;
. . .
if (M1_E1 && zaehler_flanke == 0)
{
zaehler_flanke = 1;
zaehler_1++; /* M1_E1 ein mal ..*/
}
if (!M1_E1 && (zaehler_flanke == 1))
zaehler_flanke = 0;
if (zaehler_1 == 5)
/* M1_E1 zum 5. mal gesetzt. */
{
/* .. die nächsten Schritte */
. . .
Die kürzeste Verarbeitungsgeschwindigkeit eines Flankenwechsels entspricht der doppelten Zykluszeit des ob1().
Die Zykluszeit beträgt bei einer 8-bit CPU typisch 2-100ms.
Die Zykluszeit beträgt bei einer 16-bit CPU typisch 0,5-20ms
Die Zykluszeit beträgt bei einer 32-bit CPU typisch 0,1-10ms.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Softwarezähleingang mittels Interruptroutine
Wird im Initialisierungsbaustein “ob22" der Interrupt für ”ob2_1" freigeschaltet, so wird mit jedem
LOW->HIGH Flankenwechsel auf dem Eingang E1 ein Interrupt ausgelöst.
Dieser Interrupt ruft die Funktion “ob2_1" auf. In dieser Funktion wird die Variable ”zaehler_1" inkrementiert, diese kann
im Hauptprogramm “ob1" bearbeitet werden.
Bsp.:
void ob22()
{
. . .
can_set(CANMODUS_OB2_1,TRUE);
/* Interrupt auslösen, falls E1 aktiviert wird; default TRUE */
. . .
void ob1()
. . .
if (zaehler_1 == 1)
/* Wenn E1 1 mal aktiviert wurde: ... */
M1_A1_EIN; /* Der digitale Ausgang Nr. 1 soll gesetzt werden. */
else if (zaehler_1 == 3) /* Wenn E1 das 3te mal aktiviert wurde: ... */
M1_A2_EIN; /* Der digitale Ausgang Nr. 2 soll gesetzt werden. */
else if (zaehler_1 == 7) /* Wenn E1 das 7te mal aktiviert wurde: ... */
{
M1_A1_AUS; /* Die digitalen Ausgänge Nr. 1 und Nr. 2 sollen */
M1_A2_AUS; /* zurückgesetzt werden. */
zaehler_1 = 0; /* Der "zaehler_1" wird zurückgesetzt. */
}
. . .
void ob2_1()
{
zaehler_1++;
}
. . .

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Softwarezähleingang mittels FIRMWARE-Routine
In der USERWARE ist ein 32-bit Softwarezähler bereits integriert, der wie folgt konfiguriert ist :
Mit der Funktion “can_read_long (modul,0,PARM_TYP_DIG_IMPULSZAEHLEINGANG_LESEN,
&impulszahl);” können die Anzahl Impulse gelesen werden, die an Eingang E1 anliegen (LOW->HIGH Flanke).
Dabei bestimmt ..E3 das Vorzeichen des Zählers, ..E3 = 0V entspricht positiver Zählung und vice versa.
Mit der Funktion “can_read_long(modul,1,PARM_TYP_DIG_IMPULSZAEHLEINGANG_LESEN,
&impulszahl);” können die Anzahl Impulse gelesen werden, die an Eingang E2 anliegen (LOW->HIGH Flanke).
Dabei bestimmt ..E4 das Vorzeichen des Zählers, ..E4 = 0V entspricht positiver Zählung und vice versa.
u_long impulszahl;
. . .
void ob22() /* Dev01 */
. . .
can_set(IMPULS_ZEITBASIS,0);
. . .
void ob1() /* Dev00 */
. . .
/* Lesen der am digitalen Eingang Nr. 2 eingegangen Impulse. */
can_read_long(1,2,PARM_TYP_DIG_IMPULSZAEHLEINGANG_LESEN,&impulszahl.l_data);
. . .
/* Wenn ein Impuls registriert wurde: ... */
if (impulszahl.l_data[3] == 1L)
M1_A3_EIN; /* Der digitale Ausg. Nr. 3 soll gesetzt werden. */
/* Wenn zwei Impulse registriert wurden: ... */
if (impulszahl.l_data[3] == 2L)
M1_A4_EIN; /* Der digitale Ausg. Nr. 4 soll gesetzt werden. */
/* Wenn drei Impulse registriert wurden: ... */
if (impulszahl.l_data[3] >= 3L)
{
M1_A3_AUS; /* Die digitalen Ausg. Nr. 3 und Nr. 4 sollen */
M1_A4_AUS; /* zurückgesetzt werden. */
/* Mit dieser Funktion kann der Zähler manuell genullt werden. */
/* default 0 */
can_write_long(1,1,PARM_TYP_DIG_IMPULSZAEHLEINGANG,0L);
}
. . .

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Softwaretimer abfragen
Bsp.:
Es wird im Ablaufschritt 102 der „zaehler_2“ auf die Zeitdauer „schritt_dauer_102“ gesetzt.
Der Timer wird im “ob13()”dekrementiert.
Es folgt der Schritt 103. Im Schritt 103 wird die verbleibende Zeit ausgegeben, bis der „zaehler_2“ zu 0 geworden ist. Ist
dies erreicht, so wird der „zaehler_2“ auf die Zeitdauer „schritt_dauer_103“ gesetzt.
Auf diese Weise springt die Steuerung von „schritt“ 102 zu „schritt“ 103 und wieder zurück.
. . .
void ob1()
. . .
if ((schritt == 102) && (zaehler_2 == 0))
{
zaehler_2 = schritt_dauer_102;
lcd_vdspls(7,0," ");
lcd_vdspls(5,0," Jetzt wird 'schritt' 102 durchgeführt. ");
schritt = 103; /* nächster "schritt" ist "schritt" 102 */
}
sprintf(buffer," Rest-Zeit bis zum 'schritt' %3i: %1i sec.",schritt, zaehler_2/100);
lcd_vdspls(6,0,buffer);
if ((schritt == 103) && (zaehler_2 == 0))
{
zaehler_2 = schritt_dauer_103;
lcd_vdspls(5,0," ");
lcd_vdspls(7,0," Jetzt wird 'schritt' 103 durchgeführt. ");
schritt = 102; /* zurück zu "schritt" 102 */
}
. . .
void ob13()
{
/* Solange 'zaehler_2' ungleich Null ist wird er alle 10 msec */
/* dekrementiert. */
if ( zaehler_2 )
zaehler_2--;
. . .

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Pulsierender Ausgang
Bsp.: Der Ausgang A4 soll im Taktverhältnis von 50 % Ein- und 50 % Ausschalten.
. . .
void ob(1)
. . .
/* Am Anfang und wenn "zaehler_3" bis auf Null dekre- */
/* mentiert wurde, wird der digitale Ausgang Nr. 1 gesetzt. */
if (zaehler_3 == 0)
{
zaehler_3 = periodendauer; /* "zaehler_3" wird hochgesetzt. */
M1_A1_EIN;
lcd_vdspls(3,26,"ein");
}
/* Erst wenn die halbe Periodendauer verstrichen ist wird der */
/* digitale Eingang Nr. 1 wieder zurückgesetzt. */
else if (zaehler_3 < periodendauer/2)
{
M1_A1_AUS;
lcd_vdspls(3,26,"aus");
}
. . .
void ob13()
{
if ( zaehler_3 )
zaehler_3--;
. . .

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Einschaltverzögerung eines Ausganges

Bei Kompressoren ist eine Verweilzeit (z.B. 3 Minuten) notwendig, bevor dieser wieder eingeschaltet werden darf.
Dies könnte wie folgt realisiert werden :
. . .
ushort einschaltverzoegerung = 18000;
. . .
void ob1()
. . .
if (!M1_E1)
{
/* Sobald der digitale Eingang zurückgesetzt wird, wird */
/* auch der der digitale Ausgang Nr. 2 zurückgesetzt. */
M1_A2_AUS;
/* Solange der digitale Eingang nicht gesetzt ist, wird der */
/* "zaehler_4" auf dem Wert "einschaltverzögerung" gehalten. */
zaehler_4 = einschaltverzoegerung;
}
if (M1_E1) /* Der digitale Eingang wurde gesetzt. Ab jetzt wird der */
{ /* "zaehler_4" nicht mehr auf dem Wert */
/* "einschaltverzögerung" gehalten, sondern er wird im */
/* Programmteil "ob13()" dekrementiert. */
if (zaehler_4 == 0) /* "zaehler_4" wird solange dekrementiert, */
{ /* bis er Null erreicht hat. Dann: ... */
M1_A2_EIN; /* Der digitale Ausgang Nr. 2 wird gesetzt. */
}
}
. . .
void ob13()
{
if ( zaehler_4 )
zaehler_4--;
. . .
Der Eingang ..._E1 startet den Kompressor neu, jedoch nur falls der „zaehler_4“ abgelaufen.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Softwarerampen
Rampe eines analogen Ausganges
Für analoge Ausgänge werden oft Rampenfunktionen benötigt. Als Beispiel soll der analoge Ausgang 1 stetig von 0 bis 10
Volt ansteigen.
Wichtig ist, in welchen Zeiteinheiten der Rampenwert inkrementiert werden soll, und wie schnell sich die Rampe erhöhen
soll.
. . .
static short rampen_wert = 0;
. . .
void ob1()
. . .
/* Wird der digitale Eingang M1_A3 gesetzt */
/* wird die analoge Rampe aktiviert. */
if (M1_E3)
{
/* Der "zaehler_2" wird im Programmteil "ob13()" so lange */
/* dekrementiert bis er Null ist. */
if (zaehler_2 == 0)
{
/* Dann wird er auf den Wert 10 hochgesetzt, damit es */
/* 10 * 10 msec = 0,1 sec dauert, bis ein weiteres mal die */
/* Bedingung dieser "if"-Abfrage erfüllt ist. */
zaehler_2 = 10;
/* Der "rampen_wert" wird alle 0,1 sec neu berechnet. */
rampen_wert += 10;
if (rampen_wert > 4000)
rampen_wert = 0;
. . .
}
}
. . .
void ob13()
{
if ( zaehler_2 )
zaehler_2--;
. . .

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Visualisierung
Der Simulator (Visual.exe)
Debuggen von Zusatzelementen wie LEDs
Debuggen von LCD, Keyboard, Bitmaps
Debuggen von Menüstrukturen
Simulation von ElaSim auf dem PC

Das Simulationsprogramm „Visual.exe“ dient dazu, Bedienabläufe und Erscheinungsbild der Masken auf dem PC
möglichst originalgetreu zu simulieren.
Des weiteren ist eine wesentliche Funktionskomponente die Kommunikation. Die Kommunikation im Zielsystem, realisiert
durch Zonline.c wird auf dem PC durch Eonline.exe nachgebildet. Ein offenes Treiberkonzept für Zonline und Eonline
ermöglicht das Einbinden nahezu beliebiger kommunikativer Partner.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
PC-Simulation und Betrieb auf der Zielhardware
Simulation : Zielhardware :
CAN_P200
CAN_M4 CAN_M1
Visualisierung der Simulation

Die Visualisierung der Simulation erfolgt mittels dem Programm „visual.exe“
Jedes sich im System befindliche Modul M0 .... M63 wird durch ein eigenständiges Programm
OB00.exe .... OB63.exe simuliert. Das Gegenstück dazu sind die einzelnen *.hex-Programme, die auf den echten Modulen
laufen.
Diese Programme können auf dem PC mittels Interprozesskommunikation untereinander Nachrichten versenden wie dies
auch im Zielsystem über den CAN-Feldbus erfolgt.
Die Programmabläufe verhalten sich in den eigenständigen Tasks OB00 .... OB63 ebenso wie auf den eigenständigen
Modulen M00 .... M63.
Auch der Einschaltvorgang läßt sich durch die Aufteilung auf einzelne exe-Dateien pro virtuellem Modul realistisch
simulieren. Wird ein einzelnes Modul in ein aktives CAN-Netzwerk integriert, kann das in der Simulation mit dem Starten
der Simulation nachgestellt werden.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Was kann simuliert werden
CAN - Pult CAN - Modul
Tastaturinterface X
LED Anzeigen X
LCD Anzeigen X
Digitale Ein- und Ausgänge X X
Analoge Ein- und Ausgänge X X
CAN-Feldbusschnittstelle X X
Serielle Schnittstelle X X
Parallele Schnittstelle X
Echtzeituhr X
Speichern in Eprom X X
Wie wird simuliert
Tastaturinterface durch PC- Tastatur oder Mausklick auf simuliertes Tastenfeld

LED Anzeigen durch Bildschirmausgabe
LCD Anzeigen durch Bildschirmausgabe
Digitale Ein – und Ausgänge durch Bildschirmausgabe
Analoge Ein - und Ausgänge durch Bildschirmausgabe
Serielle Schnittstelle durch PC-COM1 .... COM4
Parallele Schnittstelle durch Ausdruckfenster
Echtzeituhr durch PC-Uhr
Speichern in Eprom durch Speichern auf Festplatte

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Debuggen im Simulationsbetrieb (Offline-Debuggen)

Mittels Microsoft Visual C 4.2 oder C5.0 Debugger können die Programmtasks
OB 00 .... OB63 gedebuggt werden.
Der Debugger erlaubt:

Variablen-Anzeige
Programm-Breakpoints
Programm-Single Stepping
Paralleles Debuggen mehrerer Module
Die Bedienung des Debuggers ist nicht Bestandteil dieses Handbuches. Im Programmierkurs wird ausführlich auf den
Debugger eingegangen.
Einrichten einer Debug-Umgebung

Um eine Debug-Umgebung für das Microsoft Developer Studio einzurichten, wird wie folgt vorgegangen:
Start des Microsoft Developer Studios
Öffnen von File > New und Auswahl von Project Workspace (VC4.x) bzw. Projects (VC5.0)
Auswahl des Typs Makefile, Eingabe des Projektnamens für das Makefile
z.B.: Ob01 (Ob0 .... Ob63 ) =
ˆ Gerät Nr. 1 (0 ... 63)

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Und Eingabe der Location

z.B.: C:\ElaSoft\Projekte\DemoSim\MM2_CAN\elasim
Hinweis : Am Ende des Location-Pfades darf nicht der Name des Makefiles stehen (Ob0.... Ob63)
C:\ELASOFT\.....\ElaSim\Ob01
Bestätigen mit Create, bzw. OK
Ein Meldefenster von Microsoft Developer Studio wird geöffnet
Meldung mit Ja bestätigen

Das Fenster Projekt Settings wird geöffnet
Eingabe im Textfeld Build command line:

NMAKE/fMusr_sim.MAK
Eingabe im Textfeld Rebuild all options: CLEAN
ALL
(Großschreibung beachten!)

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Wechsel auf die zweite Seite des Eingabefensters durch Anwahl von Debug
Eingabe im Textfeld Program arguments: 1 1

1 => Modulnummer (0...63)
1 => Portnummer
(0= kein Com-Port)
(1= Com1-Port)
(2= Com2-Port)
Bestätigen mit OK
Öffnen von Insert >Files into Projekt (V4.x)
Öffnen von Project >Add To Project->Files (V5.0)
Auswahl des Ob.c Files

Bestätigen mit Add
Die Einrichtung der Debug-Umgebung ist somit beendet. Mit der Debug-Umgebung kann jedes Modul einzeln simuliert
werden. Das Projekt können Sie nun normal kompilieren und debuggen.
Sollten Sie beim Kompilieren Fehlermeldung erhalten, überprüfen Sie bitte unter anderem, ob Sie in der Autoexec.bat oder
auch in der Registry von WindowsNT die Umgebungsvariablen des Compilers richtig gesetzt haben!
Diese Variablen werden beim Kompilieren durch die Projektverwaltung von ElaGraphII gesetzt, müssen aber bei
Verwendung des Debuggers von Ihnen eingetragen werden.
Folgende Einträge sind nötig:
Für V4.x Für V5.0
PATH %path%;f:\MSDEV\BIN; PATH %path%;f:\programme\devstudio\vc\bin;
PATH %path%;f:\programme\devstudio\sharedide\bin;
SET INCLUDE=f:\MSDEV\INCLUDE; SET INCLUDE=f:\programme\devstudio\vc\INCLUDE
SET LIB=f:\MSDEV\LIB; SET LIB=f:\programme\devstudio\vc\LIB
Laufwerk und Pfad sind auf Ihre Installation des Compilers hin anzupassen.
Um das Zusammenspiel mehrerer Module zu simulieren, muß für jedes Modul das Microsoft Developer Studio einmal
geöffnet werden und die Debug-Umgebung eingerichtet werden. Zusätzlich müssen die Tasks bzw. Module in der
Visualisierung der Simulation aktiviert werden. Das muß zuvor über die ElaSim-Projektverwaltung erfolgen.
Auf diese Weise können mehrere Module „eingeschaltet“ werden, in dem die entsprechenden Programme (ob.c) einzeln
von dem zugehörigen Developer Studio aus gestartet werden.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Anlegen eines ElaSim-Projektes über die Projektverwaltung

Starten Sie die ElaGraphII-Projektverwaltung über das Windows
Startmenü
Start > Programme > Projektverwaltung
Als ersten Schritt sollten Sie überprüfen, ob die Compiler korrekt eingestellt sind und ob Ihr gewünschter Editor
eingebunden ist. Dafür muß aus dem Menü der Projektverwaltung der Menüpunkt
Optionen > Einstellungen... aufgerufen werden.
Über diesen Menüpunkt gelangen Sie in das Fenster Einstellungen, in dem Sie folgende Einstellungen vornehmen können:
Editor:
Hier wird Pfad und Name der *.exe-Datei des zu verwendeten Editors ausgewählt.
Compiler
Ziel: 80515 (KEIL)
Pfad: Hier wird der Pfad des zu verwendeten Compilers für ein 80515 Zielsystem eingetragen:
z.B. <Laufwerk>:\Installationspfad\c51v4
Version: Versionsnummer des verwendeten Compilers
Ziel: 80167 (GNU)
z.B. <Laufwerk>:\Installationspfad\microsys
Ziel: 80960 (Microtec)
z.B. <Laufwerk>:\Installationspfad\microv2
Ziel: Simulation (MSDev)
Pfad: Hier wird der Pfad des zu verwendeten Compilers für die Simulation eingetragen:
z.B. <Laufwerk>:\Installationspfad\MSDEV für Visual C/C++ V4.x
z.B. <Laufwerk>:\Installationspfad\DevStudio\VC für Visual C/C++ V5.0
Version: Versionsnummer des verwendeten Compilers (für V4.x und V5.0 ohne Verwendung)
Bestätigen Sie bitte mit OK.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Um ein neues Projekt anzulegen, sind folgende Schritte nötig:
Mit der rechten Maustaste öffnen Sie von der Projekt-Ebene aus (d.h. ein bestehendes Projekt ist markiert) das angezeigte
Menü. Mit Hilfe der Menüpunkte ist es möglich ein bestehendes Projekt zu importieren, das markierte Projekt zu löschen
oder zu ändern und über den Menüpunkt Neues Projekt ein neues Projekt anzulegen.
Mit dem damit geöffneten Fenster

Neues Projekt kann der Name und der Pfad
des Projektes vergeben werden.
Ab jetzt erscheint das neue, bisher noch leere, Projekt in der Projekte-Liste.
Um das Projekt mit einem Gerät zu füllen,

kann mit der rechten Maustaste und dem
Menüpunkt Neu... das Fenster
Neues Objekt einfügen geöffnet und von hier
aus ein Projektiertes Gerät angelegt werden
Die Eigenschaften des Gerätes werden in den folgenden vier Fenstern angegeben.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Dem Gerät kann ein beliebiger Name gegeben

werden.
Die Geräteart ist die
Elrest-Bezeichnung für das Gerät und muß aus
der vorgegeben Liste ausgewählt werden.
Über die Liste Treiber muß eingegeben werden,
mit welchem Prozessor das Gerät ausgerüstet ist
(CAN_M960 für die 80960-CPU, ...).
Über den Druckknopf ... wird in das Fenster des

ausgewählten Geräte-Treibers gesprungen, über
das die Geräteparameter eingestellt werden
können.
Über OK und Weiter wird das Fenster PC-

Verbindung angesprungen. Hier muß das
verwendete Netzwerk zwischen PC und Gerät
eingetragen werden. Zur Auswahl stehen dabei
die CAN_MPC1-Karte, die CAN_MPC2-Karte
oder die RS232-Schnittstelle des PCs.
Über den Druckknopf ... wird in das Fenster des

ausgewählten Netzwerk-Treibers gesprungen,
über das die Netzwerkparameter eingestellt
werden können.
Über OK und Fertigstellen werden die
Netzwerk- und Geräte-Einstellungen verlassen.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Anschließend wird das projektierte Gerät im neuen Projekt „prj_neu“ aufgeführt und hat die oben ausgewählten
Eigenschaften.
Für das „Geraet0“ kann ein ElaSim-Programm erstellt werden. Dazu wird, bei markiertem Gerät, die rechte Maustaste
betätigt. Mit dem damit geöffneten Menü kann über den Menüpunkt Neu... ein Neues Objekt eingefügt werden.
Aus der Liste der möglichen Objekte für dieses Gerät
wird das ElaSim-Programm ausgewählt.
Weitere Angaben zum ElaSim-Programm werden über das nächste Fenster Moduleinstellungen vorgenommen. Der
verwendete Prozessor ist bereits korrekt eingetragen, kann aber an dieser Stelle noch geändert werden. LCD-Typ Grafik
kann angegeben werden, ob das Pult ein grafikfähiges Display besitzt. Aus der Liste Firmware muß die im Gerät
verwendete Firmware-Version (<V1.20 oder >=V1.20) ausgewählt werden, da dementsprechend andere *.lib-Dateien
eingebunden werden.
Über den Ordner *.c, *.asm, *.a51-Sourcen können Dateien dieses Formates zusätzlich zu „ob.c“ in das Projekt zum
Compilieren eingebunden werden.
Über den Ordner Bibliotheken können zusätzlich zu der zum Modul und zur Firmware-Version passenden
*.lib-Datei, die automatisch ausgewählt wird, weitere *.lib-Dateien eingebunden werden.
Über den Ordner Target Compiler kann ein vom Standard-Compiler abweichender Compiler angegeben werden.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Die ausgewählten C-Quellen werden anschließend auch im Projekt-Baum mit angezeigt. Über Doppelklicken auf der C-
Quelle wird diese mit dem eingestellten Editor geöffnet und kann bearbeitet werden.
Ist ein Programm erstellt, so kann es für die Simulation mit dem eingestellten Simulations-Compiler eine *.exe-Datei
erzeugt werden, die direkt nach dem Compiliervorgang oder später über den Menüpunkt Simulation starten auf dem PC
zum Laufen gebracht werden kann. Dazu wird bei markiertem Baumeintrag ElaSim-Programm die rechte Maustaste
betätigt und der Menüpunkt Compilieren Simulation ausgewählt Weist das Programm noch Fehler auf, werden diese
angezeigt.
Für das Zielsystem kann mit dem Menüpunkt Compilieren Zielsystem mit dem eingestellten Compiler passend zum
verwendeten Prozessor eine *.hex-Datei erzeugt werden. Diese kann direkt nach dem erfolgreichen Compiliervorgang oder
später mit dem Menüpunkt Download auf das Gerät gespielt werden.
Maximierung des DOS-Speichers zur Kompilierung (speziell Keil-Compiler)

Für die Kompilierung von Projektes mit 515er Prozessor muß für den Keil-Compiler V4.01 ausreichend DOS-Speicher zur
Verfügung stehen. Haben Sie nicht ausreichend Speicherplatz zugeordnet, erhalten Sie beim Kompilieren eine
Fehlermeldung „Memory exhausted“.Durch eine verkleinerte Version der ob.h speziell für den Keil-Compiler wurde dem
Problem bereits Rechnung getragen.
Am Anfang Ihres Programmes sollten Sie daher diese verkürzte Form includieren:
#if __C51__ == 320
#include <ob.h>
#elif __C51__ == 401
#include "obc51v4.h"
#else
#include "ob.h"
#endif

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Windows 95:
Überprüfen Sie durch „mem“ auf DOS-Ebene (Verzeichnis Windows), wieviel Speicher Ihren Applikationen
zur Verfügung steht:
594K (608.000 Bytes) sollten erreichbar sein.
Windows NT:
Überprüfen Sie durch „mem /c |more“ auf DOS-Ebene (Verzeichnis WinNT\System32), wieviel Speicher
Ihren Applikationen zur Verfügung steht:

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
612K (627.000 Bytes) sollten erreichbar sein.
Überprüfen Sie Ihre config.sys und autoexec.bat und bereinigen Sie diese von unnötigen Systemtreibern.
Laden Sie insbesondere DOS in den hohen Speicher:
Entfernen Sie nicht die device=...\display Einstellung oder mode con... Einstellungen, da sonst Ungereimtheiten im
Umgang mit Windows auftreten können.
Erhalten Sie dennoch beim Kompilieren großer Quellen weiterhin die Fehlermeldung, müssen Sie als letzte Konsequenz
Ihre Quellprogramme in mehrere Sourcen aufteilen und in den Programmeinstellungen die zweite Quelle ergänzen.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Anhang ELASIM
Tabelle Parametertypen
Alle Parameter können gelesen werden, falls das MSB (most significant bit) gesetzt ist.
In der unten angeführten Tabelle sind die fett/kursiv dargestellten Parametertypen read-only,
d.h. diese können unabhängig von dem MSB nur gelesen werden.
#define Anweisung Format Wert Beschreibung
PARM_TYP_W float 0 Sollwert

PARM_TYP_KP float 1 Proportionalanteil
PARM_TYP_TN float 2 Nachhaltezeit
PARM_TYP_TV float 3 Vorhaltezeit
PARM_TYP_F float 4 Schaltfrequenz
PARM_TYP_Y_MAX float 5 Maximale Stellgröße 0.0 - 1.0 (100%)
PARM_TYP_X float 6 Istwert
PARM_TYP_Y float 7 Stellgröße 0.0-1.0 (100% PWM)
PARM_TYP_T float 8 Abtastzeit des Reglers und Analogeingangs
PARM_TYP_ALARM0 float 9 Alarmwert 0.0 - 9999.9 rel. MAX
PARM_TYP_ALARM1 float 10 Alarmwert 0.0 - 9999.9 rel. MIN
PARM_TYP_ALARM2 float 11 Alarmwert -9999.9 - 9999.9 abs. MAX
PARM_TYP_ALARM3 float 12 Alarmwert -9999.9 - 9999.9 abs. MIN
PARM_TYP_ALARMBIT0 float 13 Ausgabebit des Alarmes rel. MAX
PARM_TYP_ALARMBIT1 float 14 Ausgabebit des Alarmes rel. MIN
PARM_TYP_ALARMBIT2 float 15 Ausgabebit des Alarmes abs. MAX
PARM_TYP_ALARMBIT3 float 16 Ausgabebit des Alarmes abs. MIN
PARM_TYP_BIT1 float 17 Ausgabebit nr Linkslauf oder Heizkreis
PARM_TYP_BIT2 float 18 Ausgabebit nr Rechtslauf
PARM_TYP_REGELTYP float 19 Zweipunkt, Dreipunkt, etc.
PARM_TYP_FUEHLERART float 20 PT100, FeCuNi, NiCrNi, etc.
PARM_TYP_MODULMERKER char[4] 21 Daten vom Modul zum Master (4 * 16 Bytes)
PARM_TYP_MASTERMERKER char[4] 22 Daten vom Master zum Modul (4 * 16 Bytes)
PARM_TYP_PROGRAMMSTART char[4] 23 Initialisierung eines Down-Load Programmes
PARM_TYP_PROGRAMMCODE char[4] 24 Programmcode in Hexadezimal.
PARM_TYP_ANALOG_AUS float 25 Analoge Ausgabe 0-4095 entspricht 0-10VDC
PARM_TYP_PROGRAMMSTATUS char[4] 26 Programmstatus der Übertragung
PARM_TYP_FUE float 27 Führungsformer
PARM_TYP_Y_MIN float 28 Minimale Stellgrößenbegrenzung 0-1.0
PARM_TYP_TOT float 30 Totbereich
PARM_TYP_ANZEIGE_T float 31 Abtastzeit der Istwertanzeige
PARM_TYP_HYS float 32 Hysterese
PARM_TYP_W2 float 33 2. Sollwert
PARM_TYP_T2 float 34 Vorheizzeit
PARM_TYP_KP2 float 35 2. Proportionalanteil
PARM_TYP_TN2 float 36 2. Nachhaltezeit
PARM_TYP_TV2 float 37 2. Vorhaltezeit
PARM_TYP_ANALOG_AUS_ZUSTAND float 38 Zustand des analogen Ausgangs.
PARM_TYP_DIG_AUS_ZUSTAND long 39 Zustand des digitalen Ausgangs, dabei ist nr = 0,
Long-Wert = Bit 0 bis 31 entspricht A1 bis A32.
PARM_TYP_MODUL_MODUS_SETZEN char[4] 40 Auswahl eines Modulmodus in char[0]
PARM_TYP_DIG_AUS long 41 Digitalen Ausgang setzen
PARM_TYP_DIG_AUSFLAG long 42 Freischaltung wer auf dig.Ausgang zugreifen darf.
PARM_TYP_DIG_EIN long 43 Digitalen Eingang abfragen.
PARM_TYP_DIG_EINFLAG long 44 Freischaltung um dig. Eingänge zu simulieren.
PARM_TYP_DIG_IMPULSZAEHLEINGANG long 45 Frequenzzähleingänge
PARM_TYP_DIG_RAM_SETUP long 46 Einstellen der RAM-Adresse.
PARM_TYP_DIG_RAM long 47 Freie RAM Zugriffe (lesend/schreibend)
PARM_TYP_RESERVED long 48
PARM_TYP_RESERVED long 49
PARM_TYP_MODULSTATUS char[4] 127 Statusmeldungen abfragen.
Folgende Parameter sind Read-Only :

PARM_TYP_X // define für 6
PARM_TYP_Y // define für 7
PARM_TYP_DIG_EIN // define für 43
PARM_TYP_DIG_AUS_ZUSTAND // define für 39
PARM_TYP_ANALOG_AUS_ZUSTAND // define für 38

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
In dieser Form dürfen diese Datenpunkte aber nicht verwendet werden.

Der lesende Zugriff darf nur über die Typen
PARM_TYP_X_LESEN // define für 134 (6 +128)
PARM_TYP_Y_LESEN // define für 135 (7 +128)
PARM_TYP_DIG_EIN_LESEN // define für 171 (43+128)
PARM_TYP_DIG_AUS_ZUSTAND_LESEN // define für 167 (39+128)
PARM_TYP_ANALOG_AUS_ZUSTAND_LESEN // define für 166 (38+128)
oder beispielsweise über die Bit-Verknüpfung der Typen (wie in den auf der folgenden Seite beschriebenen Funktionen
„can_read_...“ und „can_write_...“)
PARM_TYP_X_LESEN | 0x80
PARM_TYP_Y_LESEN | 0x80
PARM_TYP_DIG_EIN_LESEN | 0x80
PARM_TYP_DIG_AUS_ZUSTAND_LESEN | 0x80
PARM_TYP_ANALOG_AUS_ZUSTAND_LESEN | 0x80
erfolgen.
Folgende Formate werden unterstützt :
char[4]
Es werden in Folge vier einzelne Byte interpretiert.Diese Darstellung ist Prozessortyp unabhängig!
short[2]
Es werden in Folge zwei einzelne Short-Daten (signed 16-bit) übermittelt. Dabei ist die Darstellung einer Short-Zahl in
Motorola-Notation.
long
Es wird eine Long-Data (signed 32-bit) übermittelt. Dabei ist die Darstellung einer Long-Zahl in Motorola-Notation.
float
Diese Gleitkommazahl entspricht der IEEE-Normung über Float-Variable.
Folgende Strukturen werden verwendet:

typedef enum e_can_telegram_type
{
CAN_TELEGRAM_REQUEST,
CAN_TELEGRAM_INDICATION, /* Anfrage eines anderen Modules */
CAN_TELEGRAM_RESPONSE,
CAN_TELEGRAM_CONFIRM, /* Antwort einer aktiven Anfrage */
} CAN_TELEGRAM_TYPE;
typedef unsigned long ulong;
typedef unsigned short ushort;
typedef unsigned char uchar;
typedef union
{
float f_data;
long l_data;
ulong ul_data;
short s_data[2];
ushort us_data[2];
char c_data[4];
uchar uc_data[4];
} u_long;
typedef struct
{
char parm_nr;
char parm_typ;
u_long d;
/* Neue Elemente ab V1.20 */
CAN_TELEGRAM_TYPE type; /* enum-Feld */
short client_modul_no; /* Relative Modul-Adresse */
short server_modul_no; /* Relative Modul-Adresse */
} can_telegram;

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Einfachste Form der Funktionen „can_read_...“ und „can_write_...“:

char can_read_long(char modul, char nr, char typ, long _HUGE* wert)
{
static can_telegram daten;
daten.parm_typ = typ | 0x80;
daten.parm_nr = nr;
if (can_send_telegram(modul,&daten))
{
*wert = daten.d.l_data;
return TRUE;
}
return FALSE;
}
char can_write_long(char modul, char nr, char typ, long wert)
{
daten.parm_typ = typ & ~0x80;
daten.parm_nr = nr;
daten.d.l_data = wert;
{
return TRUE;
}
return FALSE;
}
char can_read_float(char modul, char nr, char typ, float _HUGE* wert)
{
daten.parm_typ = typ | 0x80;
daten.parm_nr = nr;
{
*wert = daten.d.f_data;
return TRUE;
}
return FALSE;
}
char can_write_float(char modul, char nr, char typ, float wert)

{
daten.parm_typ = typ & ~0x80;
daten.parm_nr = nr;
daten.d.f_data = wert;
{
return TRUE;
}
return FALSE;
}

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Tabelle Reglertypen
#define REGELTYP_AUS 0 /* Keine Regelung */
#define REGELTYP_PWM 1 /* Reine PWM Ausgabe */
#define REGELTYP_ZPMR 2 /* 2-Punkt m. Rückführung PID-T1 */
#define REGELTYP_DPMR 3 /* 3-Punkt m. Rückführung PID-T1 */
#define REGELTYP_ZPOR 4 /* 2-Punkt o. Rückführung */
#define REGELTYP_DPOR 5 /* 3-Punkt o. Rückführung */
#define REGELTYP_DPS 6 /* 3-Punkt Schrittregler */
#define REGELTYP_SELBST 9 /* Selbstoptimierung */
Tabelle Fühlerarten
#define FUEHLERART_FECO 0 /* Fühlerart FECO */
#define FUEHLERART_NICRNI 1 /* Fühlerart NICRNI */
#define FUEHLERART_PT100 2 /* Fühlerart PT100 */
#define FUEHLERART_PTRHPT 3 /* Fühlerart PTRHPT */
#define FUEHLERART_VOLT 4 /* Fühlerart Spannungseing */
#define FUEHLERART_AUS 5 /* Kein Fühler */
#define FUEHLERART_AMPERE 6 /* Fühlerart Stromeing. */
#define FUEHLERART_RAUMTEMP 7 /* Raumtemperatur */
#define FUEHLERART_OHM 8 /* 0 .. 1 k-Ohm */
#define FUEHLERART_PT1000 9 /* Fühlerart PT1000 */
#define FUEHLERART_12BIT_FECO 20 /* Fühlerart FECO */
#define FUEHLERART_12BIT_NICRNI 21 /* Fühlerart NICRNI */
#define FUEHLERART_12BIT_PT100 22 /* Fühlerart PT100 */
#define FUEHLERART_12BIT_PTRHPT 23 /* Fühlerart PTRHPT */
#define FUEHLERART_12BIT_VOLT 24 /* Fühlerart Spannungseing. */
#define FUEHLERART_12BIT_AMPERE 26 /* Fühlerart Stromeing. */
#define FUEHLERART_12BIT_OHM 27 /* 0 .. 1 k-Ohm */
#define FUEHLERART_12_BIT_PT1000 28 /* Fühlerart PT1000 */
Hinweis: Die erhöhte Auflösung von 12-bit ist nur optional erhältlich, bitte prüfen Sie dies im Vorfeld

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Liste der Bibliotheksfunktionen ab Firmware V1.20

char can_send_telegram (char modul, can_telegram _HUGE* daten)
short can_set (char modus, short wert)
char rs232_in_rdy (void)
void rs232_in (void)
void rs232_init (char mode)
void rs232_out (char c)
void rs232_str_out (char _HUGE* str)
void setdatetime (char modus, char wert)
char getdatetime (char modus)
short ee_short_rd (unsigned char adresse)
long ee_long_rd (unsigned char adresse)
float ee_float_rd (unsigned char adresse)
void ee_disable (void)
void ee_enable (void)
void ee_float_wr (unsigned char adresse, float daten)
void ee_long_wr (unsigned char adresse, long daten)
void ee_short_wr (unsigned char adresse, short daten)
char kbbgd (void)
char kbrdy (void)
short kblasttime (void)
short kbnec (void)
void kbflush (void)
void kbsetkey (short key)
short ad_10bit (char nr)
short ad_12bit (char nr)
char _HUGE* feld_get_einheit (void)
char feld_get_eingabe (void)
char feld_get_nachkomma (void)
char feld_get_typ (void)
float feld_check_0 (float wert)
float feld_get_float_wert (void)
long feld_get_long_wert (void)
short feld_get_short_wert (void)
void feld_set (feld_struct _HUGE* pfeld)
void feld_set_eingabe (char eingabe)
void feld_set_prio (char prio)
void feld_taste (short key)
void feld_set_float (float _HUGE* wert, float min, float max, float memo,
char _HUGE* einheit, char nachkomma, char kennwort_prio,
short eeprom_adresse)
void feld_set_long (long _HUGE* wert, long min, long max, long memo,
char _HUGE* einheit, char kennwort_prio, short eeprom_adresse)
void feld_set_short (short HUGE* wert, short min, short max, short memo,
char *HUGE einheit, char kennwort_prio, short eeprom_adresse)
void lcd_clr (void)
void lcd_init (void)
void lcd_refresh_anzeige (void)
void lcd_reinit (void)
void lcd_setloc (char row, char col)
void lcd_vdsp (vdsp_struct _HUGE* dsp)
void lcd_vdspad (char att, char vk, short wert)
void lcd_vdspaf (char att, char vk, char nk, float wert)
void lcd_vdspal (char att, char vk, long wert)
void lcd_vdspas (char attribute, char _HUGE*str)
void lcd_vdspd (char vk, short wert)
void lcd_vdspf (char vk, char nk, float wert)
void lcd_vdspl (char vk, long wert)
void lcd_vdsplad (char row, char col, char att, char vk, short wert)
void lcd_vdsplaf (char row, char col, char att, char vk, char nk, float wert)
void lcd_vdsplal (char row, char col, char att, char vk, long wert)
void lcd_vdsplas (char row, char col, char att, char _HUGE* str)
void lcd_vdspld (char row, char col, char vk, short wert)
void lcd_vdsplf (char row, char col, char vk, char nk, float wert)
void lcd_vdspll (char row, char col, char vk, long wert)
void lcd_vdspas (char attribute, char _HUGE* str)
void lcd_vdspls (char row, char col, char _HUGE* str)
void lcd_vdsps (char _HUGE* str)
void led_display (char nr, char mode)
void led_vdsp (vdsp_struct _HUGE* dsp)
void led_vdspld (char row, char col, char vk, short wert)
void led_vdsplf (char row, char col, char vk, char nk, float wert)
void led_vdspll (char row, char col, char vk, long wert)
void led_vdspls (char row, char col, char _HUGE* str)
void led_vdsp_dp (char row, char col, char on)
void prtc (char c)
void prtreset (void)
void prtstr(char _HUGE* str)
void lcd_point (int x,int y, long color)
void lcd_draw_set_pos(int x, int y)
void lcd_mode_set (DRAW_MODE draw_mode)
int lcd_draw_font_char(int x, int y, char ch, int scale, long color, FONT _HUGE* pFont,
RECTANGLE _HUGE* pRect);
int lcd_draw_font_str (int x, int y, char _HUGE* str, int scale, long color,
FONT _HUGE* pFont, RECTANGLE _HUGE* pRect);

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
void lcd_draw_line (int to_pos_x, int to_pos_y, long color, RECTANGLE _HUGE* pRect);
void lcd_draw_bitmap (int xa1, int ya1, int xa2, int ya2, BOOL opark, long backcolor,
USIGN8 scale, USIGN8 opaque, BITMAP_STRUCT * bmp, RECTANGLE *pRect);
void lcd_draw_circle (int xr, int yr, int r, long color, RECTANGLE _HUGE* pRect);
void lcd_draw_pyramid (int xa1, int ya1, int npixel, BOOL top, BOOL filled, long forecolor,
RECTANGLE _HUGE* pRect);
void lcd_draw_box (int xa1, int ya1, int xa2, int ya2, int d_box, long forecolor,
RECTANGLE _HUGE* pRect );
void feld_ink_vorkomma (short sek1, short ink1,short sek2, short ink2,short sek3,
short ink3)
void feld_ink_nachkomma (short sek1, short ink1,short sek2, short ink2,short sek3,
short ink3)
char can_user_telegram (long send_id, long recv_id, char len, char _HUGE* p_data)
Liste der Bibliotheksfunktionen ab Firmware V1.30

void can_set_distance (USIGN8 card, USIGN8 can_distance)
USIGN8 can_reset (USIGN8 card, USIGN16 io_address, USIGN16 baudrate, USIGN8 standard_id)
USIGN8 can_req_confirmed (USIGN8 card, USIGN32 arg_send_id, USIGN32 arg_recv_id,
USIGN8 length, USIGN8 _HUGE* dat)
USIGN8 can_req_unconfirmed (USIGN8 card, USIGN32 arg_send_id, USIGN8 length,
USIGN8 _HUGE* dat)
USIGN8 can_mpc2_receive_lock (USIGN8 card, USIGN32 arg_id,USIGN8 lock)
USIGN8 can_get_receivequeue (USIGN8 card, USIGN32 _HUGE* arg_recv_id,
USIGN16 _HUGE* systemtick,USIGN8 _HUGE* len,
USIGN8 _HUGE* recv_dat)
USIGN8 can_mpc2_get_error (USIGN8 card, USIGN32 _HUGE* arg_id, USIGN8 _HUGE* mac)
USIGN32 uw_outp (USIGN32 port, USIGN32 value, USIGN32 write_mask)
USIGN32 uw_inp (USIGN32 port, USIGN32 read_mask)
void FieldSetKey (short virtual_key, short physical_key)
short FieldTranslateKey (short physical_key)
void FieldSetActive (FIELD _HUGE* pField,void _HUGE* pOrgValue,char _HUGE* pszTitle,
char _HUGE* pszUnit, int nDataType, DATABUFFER4 db4MinValue,
DATABUFFER4 db4MaxValue, DATABUFFER4 db4DefaultValue,
long nEEpromAdress,short nPosX, short nPosY, char nPrePrecision,
char nPostPrecision, char nPasswordLevel,
void _HUGE* pHandleDatapoint)
void FieldProcessKey (FIELD _HUGE* pField, WND _HUGE* pWnd, short key)
void FieldProcessVirtualKey (FIELD _HUGE* pField, WND _HUGE* pWnd, short key,
char translate)
void FieldStoreToEEPROM (long nEEpromAdress, int nDataType, DATABUFFER4 db4Value)
void FieldReadFromEEPROM (long nEEpromAdress, int nDataType,
DATABUFFER4 _HUGE* pdb4EditValue)
void FieldSetEEFunction (P_EE_ENABLE pArgEEenable, P_EE_DISABLE pArgEEdisable,
P_EE_SHORT_RD pArgEEshortRd, P_EE_SHORT_WR pArgEEshortWr)
USIGN8 L7_Receive_Protocol1 (USIGN32 nClientNo, USIGN8 _HUGE* pDat)

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Die pixelgenaue Elementanordnung im WindowsµE Koordinatensystem

Diverse Firmware Bibliotheksfunktionen (lcd_....) greifen auf ein LCD-Display zu. Dabei ist die pixelgenaue Anordnung
speziell von Linien, Rechtecken Rahmen, Fonts zu beachten. Nachfolgend ist die Verfahrensweise für die Anordnung
aufgeführt:
Das Koordinatensystem
Das Koordinatensystem beginnt in der linken
oberen Ecke mit der Koordinaten x=0 und y=0.
Mit der Funktion :
lcd_point (int x,int y, long color);
kann ein einzelnes Pixel auf der angegebenen
Koordinate (97,33) positioniert werden.
Eine Linie
Eine Linie wird mit den Funktionen :
lcd_draw_set_pos (int x1,int y1);
lcd_draw_line(int x2, int y2, long color);
realisiert.
Dabei positioniert die Funktion :
lcd_draw_set_pos (92,33);
den Beginn der Linie.
Die Funktion :
lcd_draw_line(97,33,COLOR_RED);
zeichnet eine Linie in der Farbe ROT bis
einschließlich der Koordinate (97,33).
Ein Rechteck
Die Funktion :
lcd_draw_box(int xa1, int ya1, int xa2, int ya2,
int d_box, long forecolor );
zeichnet ein Rechteck innerhalb der angegebenen
Koordinaten.
Mit dem Aufruf :

lcd_draw_box(90, 30, 97, 33,BOX_2D
COLOR_RED);
wird das dargestellte Rechteck gezeichnet.
Wird als Attribut BOX_3D_HIGHLIGHTED

oder BOX_3D_DOWNLIGHTED angegeben, so
wird nach innen mit 2 Pixel Breite ein 3D
Rechteck gezeichnet.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Fonts
Ein Font wird in eine Windows95/NT kompatiblen Fixed - Font Format mit der Dateiendung *.FNT gespeichert.
In dieser Font - Datei sind alle Zeichen gesammelt gespeichert. Die Höhe und die Breite eines Fonts kann 1 – 64 Pixel
umfassen.
Als Position wird die obere linke Ecke des

Zeichens verwendet.
Im Beispiel rechts wird ein Zeichen des Fonts
8x8 an der Position 95, 33 dargestellt.
Hinweis : Der Systemfont kann nur in
vielfachen seiner Auflösung z.B. 8x6
positioniert werden !
Außerdem ist ein Systemfont nur
schwarz/weiß und nicht skalierbar !
Wird ein Zeichen in einem Rahmen ausgegeben,

so wird der Rahmen mit einem gewissen Abstand
zum Zeichen gezeichnet. Die Rahmenbreite ist
bei 2D-Rahmen ein Pixel und bei 3D-Rahmen
zwei Pixel. Der Abstand zwischen Zeichen und
Rahmen wird wie folgt berechnet:
• Abstand über und unter dem Zeichen =
Fonthöhe / 4. Sich ergebende
Nachkommastellen werden abgeschnitten.
• Abstand links und rechts vom Zeichen =
Fontbreite / 2. Sich ergebende
Nachkommastellen werden abgeschnitten.
Als Position wird die linke obere Ecke des
Zeichens verwendet.
Im Beispiel rechts wird ein Zeichen des Fonts
8x8 mit 2D-Rahmen an der Position 95, 33
dargestellt.
Dies ergibt nebenstehendes Erscheinungsbild.

Die ausgewählte Rahmen um den Text werden
außerhalb der Fontfläche gezeichnet. Das
bedeutet, bei gleichen Koordinaten x erscheint
der Text „Font 8x15 .....“ immer pixelgenau
untereinander.

(/$62)762)7:$5(%(6&+5(,%81* V1.0/V2_70/Li
Fenster
Zur Positionsangabe eines Fensters wird immer das linke obere Pixel des Arbeitsbereichs, das ist der Teil des Fensters in
dem gezeichnet werden kann, verwendet. Dies ist unabhängig davon ob das Fenster einen Rahmen oder eine Titelzeile hat.
Hat ein Fenster einen Rahmen, so wird dieser außerhalb des Arbeitsbereichs gezeichnet. Die Rahmenbreite beträgt bei
einem 2D-Rahmen 1 Pixel und bei einem 3D-Rahmen 2 Pixel. Das Fensters vergrößert sich folglich um die zweifache
Rahmenbreite in der Höhe und in der Breite.
Hat ein Fenster eine Titelzeile so wird diese über dem Arbeitsbereich gezeichnet. Die Höhe der Titelzeile ist dabei die
Höhe des verwendeten Fonts + 1. Das Fenster wird dadurch um die Höhe der Titelzeile höher.
Hinweis: Zur Zeit kann für die Titelzeile nur der Systemfont verwendet werden. Dies hat zur Folge, daß ein
Fenster mit einer Titelzeile nur in dem durch den Systemfont gegebenen Raster positioniert werden
kann.
Das abgebildeten Beispiel zeigt ein Fenster mit 2D-Rahmen und Titelzeile an der Position 91, 40.


7 ElaSim

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

7 ElaSim

Hochgeladen von

Copyright:

Verfügbare Formate

(/$62)762)7:$5(%(6&+5(,%81* V1.

Best.-Nr: E5000 ELASIM.DOC

Der Simulator (Visual.exe) ........................................................................................................................................................ 46

Best.-Nr: E5000 ELASIM.DOC

Was ist ElaSim

Es umfaßt folgende Programmteile:

Erstellen eines C - Programmes mittels dem integrierten oder

Das erstellte Programm kann in einer Simulationsumgebung (OD6LP =LHOV\VWHP

Dazu werden eigenständigen Simulationsprogramme (ob00.exe

Es existiert eine einheitliche Entwicklungsumgebung der

Best.-Nr: E5000 ELASIM.DOC

Der Entwicklungsrechner wird zur vollständigen

Für die Simulation wird ab 1Q. 2000 die Zusatzkomponente

Zur ElaSim Programmentwicklung gehört der Download von :

Integration eines Zielsystem-Variablen-Debuggers

Was ist neu in ElaSim V2.70

Best.-Nr: E5000 ELASIM.DOC

Zusammenhang der einzelnen Komponenten

Da auch beim PC ein Endanwender ohne Betriebssystem

Die Einsprungfunktionen werden standardseitig in der

Best.-Nr: E5000 ELASIM.DOC

Damit das Zielsystem auch mit weiteren Editoren :

Es können folgende Übersetzungsergebnisse

Vorbereitete ElaGraph USER Bausteine

Der C-Code dieser USER-Bausteine wird durch den

Best.-Nr: E5000 ELASIM.DOC

Neue ElaGraph Bausteine erstellen

Mittels der optionalen Entwicklungsumgebung MFB SURMHFW!HGV

Best.-Nr: E5000 ELASIM.DOC

Best.-Nr: E5000 ELASIM.DOC

Nicht in ElaSim enthaltene Software (muß je nach Bedarf erworben werden) :

+RVW 7DUJHW &RPSLOHU

 .(,/ 

 0LFURWHF 9

Best.-Nr: E5000 ELASIM.DOC

Projekte verwalten mit ElaSim

E &RPSLOLHUHQ 6LPXODWLRQ  =LHOV\VWHP

9LVLXDOLVLHUXQJ YLVXDOH[H 'RZQORDGLQJ FDQBKH[H[H

PLW 6LQJOH6WHS XQG %UHDNSRLQWV

Die Software-Pfade für ElaSim-Projekte setzen sich wie folgt zusammen :

In ElaSim enthaltene Programmteile :

Best.-Nr: E5000 ELASIM.DOC

Makefile aus der Projektverwaltung

Momentan werden folgende Prozessoren unterstützt :

Best.-Nr: E5000 ELASIM.DOC

Die ersten Schritte zum ersten Projekt

Bei der Auswahl der möglichen Objekte wird „Projekt“

Anschließend ein beliebiger Projektname eingegeben.

Es folgt das Anlegen der sich im Projekt befindenden Geräte.

Wählen Sie als Objekt ein „Projektiertes Gerät“ aus.

Anschließend werden Sie nach der von Ihnen gewünschten PC-

Falls Sie via der zuvor installierten CAN-MPC2-Einsteckkarte

Best.-Nr: E5000 ELASIM.DOC

Bei der seriellen Schnittstelle genügt das Vorwählen des

Vor Verwendung des Parameters „Rooting“ sollten Sie die

Im Eingabedialog „Allgemein“ müssen die Einstellungen für :

Nach Ausfüllen der Felder könnte der Eingabe-dialog folgendes

Jetzt wählen Sie bei selektiertem Gerät den Menüeintrag „Neu“:

Best.-Nr: E5000 ELASIM.DOC

Es erscheint der Auswahldialog der möglichen Objekte.

Es folgt der Dialog für die Auswahl der Moduleinstellungen.

Die relevanten Einstellungen wie :

werden aus den Moduleinstellungen automatisch übernommen.

Das erstellte Programm kann in einer Simulationsumgebung (OD6LP =LHOV\VWHP

Mittels der optionalen Entwicklungsumgebung MFB SURMHFW!HGV

.(,/

0LFURWHF 9

E &RPSLOLHUHQ 6LPXODWLRQ =LHOV\VWHP

9LVLXDOLVLHUXQJ YLVXDOH[H 'RZQORDGLQJ FDQBKH[H[H

PLW 6LQJOH6WHS XQG %UHDNSRLQWV

6FKLFKW 6WDQGDUG '3 (OD*UDSK '3 'RZQORDG 2IIOLQH 'DWHQ $XWRVFDQ

/B'UYF (OD*UDSKF 'RZQORDGF 2IIOLQHF $XWRVFDQ

6FKLFKW 3& 0RGXO

&$103& 56 &$103& 56

&DQB:LQF 56B3URWF &DQBF 56B3URWF

,62 ,(& ,62 ,(&