Sie sind auf Seite 1von 66

EDIABAS — BEST BENUTZERHANDBUCH

EDIABAS
Elektronik Diagnose Basissystem

BEST BENUTZERHANDBUCH

VERSION 6d

Copyright BMW AG, created by Softing AG

BESTUSER.DOC
EDIABAS — BEST BENUTZERHANDBUCH

INHALT

INHALT ............................................................................................................2

1. Änderungshistorie .................................................................................5

2. Einführung ..............................................................................................6
2.1. Über diese Dokumentation .............................................................6
2.2. Konventionen..................................................................................6
2.3. Besonderheiten, Begriffe, Akronyme ..............................................7
2.4. Warenzeichen.................................................................................7

3. Allgemeines ............................................................................................8
3.1. Jobkonzept .....................................................................................8
3.2. Beschreibungsdateien ....................................................................8
3.2.1. Gruppenbeschreibungsdateien ...........................................8
3.2.2. Variantenbeschreibungsdateien..........................................9
3.2.3. Basisbeschreibungsdateien ................................................9
3.2.3.1. Zugriff auf Jobs in einer Basis-SGBD .......................9
3.2.3.2. "Überladen" eines Jobs aus der Basis-SGBD ..........11
3.3. Standardjobs...................................................................................11
3.3.1. Standardjob INITIALISIERUNG ..........................................13
3.3.2. Standardjob IDENTIFIKATION ...........................................15
3.3.3. Standardjob ENDE..............................................................15
3.4. Variantenermittlung.........................................................................15
3.5. Dateinamen ....................................................................................17

4. Tutorial....................................................................................................18
4.1. Vorbedingungen..............................................................................18
4.2. Wie fange ich an? ...........................................................................19
4.3. Schritt 1: Der Rahmen ....................................................................20
4.4. Schritt 2: Mindestversion.................................................................22
4.5. Schritt 3: Steuergeräteparameter....................................................24
4.6. Schritt 4: Steuergerätekommunikation ............................................25

2
EDIABAS — BEST BENUTZERHANDBUCH

4.7. Schritt 5: String- und Data- Funktionen...........................................27


4.8. Schritt 6: Ergebnissätze ..................................................................29
4.9. Schritt 7: Tabellenbearbeitung ........................................................30
4.10. Schritt 8: Realverarbeitung und Ergebnisanforderung ....................32
4.11. Schritt 9: Jobparameter...................................................................34
4.12. Binärparameter und -Ergebnisse ....................................................36

5. BEST-Tools.............................................................................................38
5.1. BEST2WIN .....................................................................................38
5.2. BestBoard .......................................................................................40
5.2.1. Allgemeines ........................................................................40
5.2.2. Menüübersicht ....................................................................41
5.2.3. Toolbar................................................................................43
5.2.4. Anwendungsprogramme .....................................................43
5.2.5. Entwicklung einer Beschreibungsdatei mit BestBoard ........44
5.3. BestView.........................................................................................45
5.3.1. Allgemeines ........................................................................45
5.3.2. Benutzeroberfläche .............................................................46
5.3.2.1. Toolbar 46
5.3.2.2. Statuszeile ................................................................47
5.3.2.3. Project-Fenster .........................................................47
5.3.2.4. Quellcode-Fenster ....................................................48
5.3.2.5. Watch-Fenster ..........................................................48
5.3.2.6. Results-Fenster ........................................................48
5.3.2.7. IFH-Trace-Fenster ....................................................48
5.3.3. Auswahl einer Beschreibungsdatei .....................................48
5.3.4. Aktualisieren einer Beschreibungsdatei ..............................50
5.3.5. Selektieren eines Jobs ........................................................51
5.3.6. Setzen von Breakpoints ......................................................53
5.3.7. Anzeigen und Verändern von Variablen..............................54
5.3.8. Ausführen eines Jobs..........................................................55

3
EDIABAS — BEST BENUTZERHANDBUCH

5.3.9. Menüübersicht ....................................................................56


5.3.9.1. Menü File..................................................................56
5.3.9.2. Menü Edit .................................................................57
5.3.9.3. Menü Run.................................................................58
5.3.9.4. Menü Debug .............................................................59
5.3.9.5. Menü Options ...........................................................60
5.3.9.6. Menü Window...........................................................61
5.3.9.7. Menü Help ................................................................62

A. GRENZEN UND BESCHRÄNKUNGEN ..................................................63

B. LITERATURVERZEICHNIS.....................................................................65

C. INDEX ......................................................................................................66

4
EDIABAS — BEST BENUTZERHANDBUCH

1. Änderungshistorie

Version 3.0 Ersterstellung


Version 4.1 Überarbeitung für EDIABAS V4.1.0
Version 5 Überarbeitung für EDIABAS V5.1.0
Version 5a Erweitert für EDIABAS V5.5.0
Version 5b Erweitert um Anhang "Grenzen und Beschränkungen"
Version 6 Erweiterung für EDIABAS V6.0.0
Version 6a Erweiterung des Anhangs "Grenzen und Beschränkungen“
Version 6b Änderung Job-Header (defrslt)
Version 6c Überarbeitung für EDIABAS V6.4.0

5
EDIABAS — BEST BENUTZERHANDBUCH

2. Einführung

2.1. Über diese Dokumentation

Diese Dokumentation beschreibt die Grundlagen für die Erstellung von


Steuergerätebeschreibungsdateien. Es werden die Benutzung und die Optionen der
Programme zur Entwicklungsunterstützung erklärt. In dieser Dokumentation wird
nicht näher auf die Sprache BEST/1 eingegangen. Im allgemeinen lassen sich alle
Steuergerätebeschreibungsdateien in der leichter lesbaren BEST/2 Notation
formulieren. Eine detailierte Beschreibung der Sprache BEST/1 finden Sie in [3].
Allgemeines über EDIABAS und über Steuergerätebeschreibungsdateien wird in [4]
beschrieben.

2.2. Konventionen

Diese Dokumentation verwendet die folgenden typographischen Konventionen:

Beispiel Beschreibung
SAMPLE.B2V Großschrift kennzeichnet Dateinamen, Register und
Betriebssystemkommandos.
job, string, Fettschrift kennzeichnet Schlüsselwörter und
while Operatoren der Sprachen BEST/2 und BEST/1
sowie der API-Funktionen.
In Beschreibungen der Syntax müssen diese Wörter
wie angegeben geschrieben werden.
ausdruck Kursivschrift kennzeichnet Platzhalter für vom
Programmierer einzutragende Werte, wie z.B.
Dateinamen.
[option] Wörter in eckigen Klammern bedeuten optionale
Angaben.
{ result | Geschweifte Klammern und senkrechte Striche
argument } kennzeichnen Eingaben, von denen jeweils eine
gewählt werden muß, außer wenn sie in eckigen
Klammern steht.
[constant...] job... Drei Punkte, die direkt einem Ausdruck folgen,
kennzeichnen, daß mehrere Ausdrücke der selben
Form folgen können.

6
EDIABAS — BEST BENUTZERHANDBUCH

hallo="Test"; Diese Schriftart kennzeichnet Beispiele,


Benutzereingaben, Programmausgaben und
Fehlermeldungen.
while() { Eine Spalte oder eine Zeile aus drei Punkten
. kennzeichnet, daß ein Teil eines Beispiels
.} absichtlich weggelassen wurde.
[1] Verweis auf ein Dokument aus dem
Literaturverzeichnis.

2.3. Besonderheiten, Begriffe, Akronyme

Eine Erklärung der in dieser und allen anderen EDIABAS-Dokumentationen


verwendeten Abkürzungen finden Sie in der Dokumentation "EDIABAS
Benuterhandbuch" im Kapitel "GLOSSAR".

2.4. Warenzeichen

Microsoft, MS, MS-DOS, Windows und WIN32 sind registrierte Warenzeichen der
Microsoft Corporation.

7
EDIABAS — BEST BENUTZERHANDBUCH

3. Allgemeines

3.1. Jobkonzept

Steuergerätebeschreibungsdateien, kurz SGBDen, enthalten Methoden um


steuergerätespezifische Daten aus dem Steuergerät auszulesen und in eine
abstrakte, allgemein lesbare Form zu übersetzen.

Diese Methoden heißen innerhalb von EDIABAS Jobs und werden normalerweise in
BEST/2 formuliert. Die Syntax von BEST/2 ist an die Sprache C angelehnt, jedoch an
die spezifischen Bedürfnisse der Steuergerätebeschreibung angepasst. Eine genaue
Beschreibung der BEST/2 Syntax befindet sich in [5]. Insbesondere mußten die Jobs
als eine spezielle Art von Funktionen aufgenommen werden. Desweiteren ist der
Umgang mit Feldern vereinfacht worden, um eine einfachere Handhabung komplexer
Telegrammdaten zu ermöglichen. Im Gegensatz zu C können keine Funktionen vom
Benutzer selbst definiert werden. Es ist jedoch eine für die Diagnoseproblematik
optimierte Laufzeitbibliothek (siehe [1]) vorhanden, die Funktionen für alle Probleme
bereitstellt.

Ein Job darf jederzeit unabhängig von anderen Jobs aufgerufen werden, das heißt
Jobs dürfen nicht zeitlich voneinander abhängig sein. Um dies zu unterbinden gibt es
in BEST/2 keinerlei Konstrukte, die einen Datenaustausch zwischen Jobs zulassen.
Lediglich Konstanten dürfen global sein.

3.2. Beschreibungsdateien

Es gibt drei Arten von SGBDen, die Varianten-, die Basis- und die
Gruppenbeschreibungsdateien (eine Erläuterung der Begriffe Steuergerätevariante
und Steuergerätegruppe befindet sich in [4]).

Alle SGBDen, werden von EDIABAS im ECU-Verzeichnis (Konfigurationselement


EcuPath in EDIABAS.INI) erwartet.

3.2.1.Gruppenbeschreibungsdateien
Die Gruppenbeschreibungsdatei enthält neben den Jobs INITIALISIERUNG und
ENDE (optional) nur den Job IDENTIFIKATION, der die aktuell im Fahrzeug verbaute
Variante ermittelt. Jobs in einer Gruppenbeschreibungsdatei können nicht mit einem
API-Auftrag aufgerufen werden.

8
EDIABAS — BEST BENUTZERHANDBUCH

3.2.2.Variantenbeschreibungsdateien
Die Variantenbeschreibungsdateien enthalten neben den Jobs INITIALISIERUNG
und ENDE (optional) die eigentlichen Jobs zur Ermittlung von Daten aus dem
Steuergerät.

Eine Variantenbeschreibungsdatei kann auf eine oder mehrere


Basisbeschreibungsdateien zugreifen. Jobs in den Basisbeschreibungsdateien
werden bei der Jobbearbeitung wie Jobs aus der Variantenbeschreibungsdatei
behandelt. Standardjobs in den Basisbeschreibungsdateien werden ignoriert.

3.2.3.Basisbeschreibungsdateien
Jobs, die für mehrere Steuergeräte gleich sind, liegen in gemeinsam genutzten
Basis-SGBDen. SG-spezifische Jobs dagegen in der jeweiligen Varianten-SGBD.

Um die alternative Suche nicht auf eine einzige Basis-SGBD zu beschränken,


können innerhalb einer SGBD alternative Basis-SGBDen angegeben werden.

3.2.3.1. Zugriff auf Jobs in einer Basis-SGBD


Im Header einer Varianten-SGBD kann angegeben werden, welche Basis-SGBD
bzw. alternativen SGBDen angezogen werden sollen wenn der Job in der Varianten-
SGBD nicht gefunden wird. Dazu wird der neue Eintrag uses im Header definiert,
hinter dem der oder die Namen (ohne Extension) der alternativen Basis-SGBDen
(PRG-Dateien), getrennt durch ein oder mehrere Leerzeichen und/oder Komma,
angegeben werden können. Die Zeile muß mit einem Semikolon abgeschlossen
werden.

Beispiele:

Das folgende Beispiel zeigt den Header einer Varianten-SGBD mit dem Namen
VARIANTE.PRG. Jobs, die in dieser SGBD nicht gefunden werden, sollen in den
Basis-SGBDen BASIS1, BASIS2 und BASIS3 gesucht werden. Dies wird in der Zeile
uses definiert.

/////////////////////////////////////////////////////////////
// H E A D E R
/////////////////////////////////////////////////////////////

ecu : Demo Steuergeraet VARIANTE.PRG;


origin : softing.BG5.Ma;
revision: 1.0;
author : softing.BG5.Ma;

9
EDIABAS — BEST BENUTZERHANDBUCH

language: Deutsch;
uses : BASIS1, BASIS2, BASIS3;
comment : Beispiel fuer die Anwendung von Basis-SGBDen;

/////////////////////////////////////////////////////////////

EDIABAS überprüft zuerst, ob der im apiJob-Aufruf angegebene Job in


VARIANTE.PRG zu finden ist. Ist dies der Fall, wird dieser ausgeführt. Ist der Job
nicht in VARIANTE.PRG vorhanden, so wird in der ersten im Header von
VARIANTE.PRG hinter uses angegebenen alternativen Basis-SGBD, hier
BASIS1.PRG, weitergesucht. Entspechend wird weitergesucht bis der Job gefunden
wird. Wird der Job auch in der letzten SGBD, hier BASIS3.PRG , nicht gefunden, so
setzt EDIABAS die Fehlermeldung "SYS-0008: JOB NOT FOUND" ab.

Im einem weiteren Beispiel wird angenommen, daß die Applikation im apiJob-Aufruf


neben dem Jobnamen den Namen einer Gruppen-SGBD, hier D_XY angegeben hat.
Im Job Identifikation der Gruppen-SGBD D_XY.GRP wird die SG-Variante ermittelt
und im Ergebnis VARIANTE der zugehörige Name der Varianten-SGBD eigetragen:
Hier XY_1 oder XY_2 oder XY_3. EDIABAS sucht den Job in der entsprechenden
SGBD. Jobs, die dort nicht gefunden werden, werden in der Basis-SGBD, hier
BASIS.PRG bzw. BASIS2.PRG, gesucht. Der Verweis auf die Basis-SGBD muß
jeweils in den Varianten-SGBDen stehen.

Es muß für jede SG-Variante eine Varianten-SGBD existieren, die im Extremfall nur
aus dem Header und den Jobs INITIALISIERUNG und ENDE (optional) besteht.
Beim Zugriff auf eine Basis-SGBD werden die Standardjobs INITIALISIERUNG und
ENDE der Basis-SGBD nicht aufgerufen (die Standardjobs INITIALISIERUNG und
ENDE werden in einer Basis-SGBD nicht benötigt).

10
EDIABAS — BEST BENUTZERHANDBUCH

D_XY.GRP
Gruppen-SGBD VARIANTE= ...

...XY_1 ...XY_2 ...XY_3

XY_1.PRG XY_2.PRG XY_3.PRG


Varianten-SGBD
uses: BASIS; uses: BASIS; uses: BASIS2;

Basis-SGBD BASIS.PRG BASIS2.PRG

Zugriff auf Basis-SGBD

3.2.3.2. "Überladen" eines Jobs aus der Basis-SGBD


Soll ein Job eine SG-spezifische Ausprägung haben und nicht aus der Basis-SGBD
aufgerufen werden, so ist dieser Job in der Varianten-SGBD entsprechend zu
definieren. Dazu wird der entsprechende Job in der Varianten-SGBD des SGs unter
dem gleichen Namen angelegt und SG-spezifisch implementiert. Da EDIABAS den
Job bereits in der Varianten-SGBD findet, wird dieser ausgeführt und nicht der
gleichnamige Job aus der Basis-SGBD.

3.3. Standardjobs

Standardjobs sind Jobs, die für EDIABAS eine besondere Bedeutung haben. Diese
Jobs werden unter bestimmtien Bedingungen zusätzlich zum im Auftrag
angegebenen Job automatisch von Laufzeitsystem aufgerufen. Diese Jobs können
Parameter empfangen.

11
EDIABAS — BEST BENUTZERHANDBUCH

Das Ergebnis von Standardjobs ist in festgelegten Standardergebnissenn abgelegt,


welche vom EDIABAS automatisch abgefragt werden.

Ein Auftrag, der über eine Variante abgesetzt wird, wird wie folgt abgearbeitet:

Anwendungprogramm EDIABAS EDIABAS


ruft auf selektiert SGBD: bearbeitet Jobs:
apiInit()
apiJob(SGBD1,JOB1,...)
SGBD1.PRG INITIALISERUNG
JOB1
apiJob(SGBD1,JOB1,...)
SGBD1.PRG JOB1
apiJob(SGBD1,JOB1,...)
SGBD1.PRG JOB1 (ein Fehler ist
aufgetreten)
apiJob(SGBD1,JOB1,...)
SGBD1.PRG INITIALISERUNG
JOB1
apiJob(SGBD2,JOB1,...)
SGBD1.PRG ENDE
SGBD2.PRG INITIALISIERUNG
JOB1
apiInit()
apiJob(SGBD3,JOB1,...)
SGBD2.PRG ENDE
SGBD3.PRG INITIALISIERUNG
JOB1

12
EDIABAS — BEST BENUTZERHANDBUCH

Ein Auftrag, der über eine Gruppe abgesetzt wird, wird wie folgt abgearbeitet:

Anwendungprogramm EDIABAS EDIABAS


ruft auf selektiert SGBD: bearbeitet Jobs:
apiInit()
apiJob(GRUPPE,JOB1,...)
GRUPPE.GRP INITIALISERUNG
IDENTIFIKATION (der
Variante)
ENDE
VARIANTE.PRG INITIALISIERUNG
JOB1
apiJob(GRUPPE,JOB1,...)
VARIANTE.PRG ENDE
GRUPPE.GRP INITIALISERUNG
IDENTIFIKATION (der
Variante)
ENDE
VARIANTE.PRG INITIALISIERUNG
JOB1
apiInit()
apiJob(GRUPPE,JOB1,...)
GRUPPE.GRP INITIALISERUNG
IDENTIFIKATION (der
Variante)
ENDE
VARIANTE.PRG INITIALISIERUNG
JOB1

3.3.1.Standardjob INITIALISIERUNG
Der Standardjob INITIALISIERUNG muß in jeder Gruppen- und Varianten-
Beschreibungsdatei vorhanden sein. Er wird automatisch aufgerufen:

„ nach vorhergehender Initialisierung von API (apiInit()/apiInitExt())


„ nach vorhergehendem Device-Wechsel (apiSwitchDevice())
„ nach vorhergehendem Auftreten eines Fehlers
„ bei einem Auftrag mit vorgegebener Variante (nur nach Wechsel der
Steuergeräte-Variante)
„ bei einem Auftrag mit unbekannter Variante

13
EDIABAS — BEST BENUTZERHANDBUCH

Die erfolgreiche Initialisierung ist mit dem Standardergebnis DONE (Ergebnistyp int
oder unsigned int) im ersten Ergebnissatz anzuzeigen:

„ Ergebnis DONE <> 0 Erfolgreiche Initialisierung


„ Ergebnis DONE = 0 Fehlerhafte Initialisierung
„ Ergebnis DONE nicht vorhanden Fehlerhafte Initialisierung

Der Standardauftrag INITIALISIERUNG darf außer DONE keine weiteren Ergebnisse


zurückliefern.

14
EDIABAS — BEST BENUTZERHANDBUCH

3.3.2.Standardjob IDENTIFIKATION
Der Standardjob IDENTIFIKATION wird zur Ermittlung der verbauten Steuergeräte-
Variante aufgerufen, wenn im Auftrag eine :Gruppen-Beschreibungsdatei angegeben
wurde.

Der Standardjob IDENTIFIKATION muß in jeder Gruppen-Beschreibungsdatei


vohanden sein.

Eine identifizierte Steuergeräte-Variante ist mit dem Standardergebnis VARIANTE


(String vom Ergebnistyp string) ersten Ergebnissatz anzuzeigen:

„ Ergebnis VARIANTE = String (mind. 1 Zeichen) Erfolgreiche Identifikation, das


Ergebnis stellt den Namen der
Steuergeräte-Variante dar
„ Ergebnis VARIANTE = Leer-String Fehlerhafte Identifikation
„ Ergebnis VARIANTE nicht vorhanden Fehlerhafte Identifikation

Der Standardauftrag IDENTIFIKATION darf außer VARIANTE keine weiteren


Ergebnisse zurückliefern.

3.3.3.Standardjob ENDE
Der optionale Standardauftrag ENDE wird beim Wechsel der Beschreibungsdatei
aufgerufen:

„ vor dem Wechsel der Beschreibungsdatei


„ vor einem Auftrag mit unbekannter Variante

Der Standardauftrag ENDE kann in jeder Gruppen- und Varianten-


Beschreibungsdatei vorliegen.

Der Standardauftrag ENDE darf keine Ergebnisse zurückliefern.

3.4. Variantenermittlung

Die Variantenermittlung erfolgt über den in der Gruppenbeschreibungsdatei


zwingend erforderlichen Job IDENTIFIKATION. Dieser Job muß das Ergebnis
VARIANTE zurückgeben, welches dann zur Ermittlung der
Variantenbeschreibungsdatei herangezogen wird.

15
EDIABAS — BEST BENUTZERHANDBUCH

Ein Auftrag, der über eine Gruppe abgesetzt wird, wird wie folgt abgearbeitet:

Anwendungprogramm EDIABAS
ruft auf selektiert SGBD: bearbeitet Job:
apiInit()
apiJob(GRUPPE,JOB1,...)
GRUPPE.GRP INITIALISERUNG
IDENTIFIKATION (der
Variante)
ENDE
VARIANTE.PRG INITIALISIERUNG
JOB1

16
EDIABAS — BEST BENUTZERHANDBUCH

3.5. Dateinamen

Dateien, die von EDIABAS verwendet werden, haben definierte Erweiterungen.


Diese Erweiterungen sind zwingend vorgeschrieben. Sie unterscheiden sich bei
Gruppen- und Variantenbeschreibungsdateien.

Dateityp Variante Gruppe

SGBD-Objektdatei *.PRG *.GRP

BEST/2 Quelldatei *.B2V *.B2G

BEST/2 Preprozessordatei *.P2V *.P2G

BEST/1 Quelldatei *.B1V *.B1G

BEST Infodatei *.BIV *.BIG

BEST/1 Mapdatei *.M1V *.M1G

17
EDIABAS — BEST BENUTZERHANDBUCH

4. Tutorial

In diesem Tutorial soll Ihnen anhand eines möglichst realistischen Beispiels die
Erstellung einer BEST/2 Beschreibungsdatei erläutert werden. Es wird versucht, auf
möglichst alle Aspekte der Programmierung einzugehen. Desweiteren wird im Laufe
der Erläuterungen immer wieder die Bedienung der Entwicklungswerkzeuge mit
einbezogen.

Dieses Tutorial kann auf 2 Arten durchgearbeitet werden:

1. Sie verwenden die mit dem BEST-DEVELOPMENT-KIT gelieferten Dateien,


oder
2. Sie editieren die Dateien ausgehend von der Datei DEMO0.B2V im Kapitel 4.2
fortlaufend mit.

Für die erste Methode wird immer angegeben, welche Datei für das Kapitel zu laden
ist. Für die zweite Methode werden alle Änderungen in dieser Dokumentation
aufgelistet und folgendermaßen dargestellt:
→ // Diese Zeile muß gegenüber der vorherigen Version hinzugefügt werden.
← // Diese Zeile muß gegenüber der vorherigen Version entfernt werden.
↔ // Diese Zeile muß gegenüber der vorherigen Version ausgetauscht werden.

Eine detaillierte Beschreibung der in diesem Tutorial benutzen BEST/2 Funktionen


finden Sie in [1]. Dort werden alle BEST/2 Bibliotheksfunktionen mit ihren
Aufrufparametern und einem Beispiel ausführlich beschrieben.

4.1. Vorbedingungen

Für dieses Tutorial wird eine Entwicklung der Beschreibungsdateien unter MS-
WINDOWS vorausgesetzt, da nur dort eine integrierte Entwicklungsumgebung
(BestBoard) und ein Source Level Debugger (BestView) zur Verfügung stehen.

Um die in diesem Tutorial gezeigten Abläufe selbst durchzuspielen muß das


EDIABAS-RUNTIME-SYSTEM und das BEST-DEVELOPMENT-KIT installiert sein.

In der EDIABAS-Konfigurationsdatei EDIABAS.INI sind folgende Einstellungen


vorzunehmen:

EcuPath = C:\EDIABAS\TUTORIAL
TracePath = C:\EDIABAS\TUTORIAL
SimulationPath = C:\EDIABAS\TUTORIAL
Simulation = 1

18
EDIABAS — BEST BENUTZERHANDBUCH

Es wird davon ausgegangen, daß EDIABAS im Verzeichnis C:\EDIABAS installiert


wurde. Ist dies nicht der Fall, so muß die EDIABAS-Konfigurationsdatei EDIABAS.INI
entsprechend angepaßt werden. Für die Konfigurationselemente EcuPath, TracePath
und SimulationPath ist die Konfigurationseinstellung C:\EDIABAS\TUTORIAL durch
<EDIABAS-Verzeichnis>\TUTORIAL zu ersetzen. Außerdem muß überall wo in
dieser Beschreibung C:\EDIABAS zu lesen ist dies durch den Pfad des EDIABAS-
Verzeichnisses ersetzt werden.

Außerdem sind folgende Einstellungen einzuhalten:

Die Environmentvariable PATH sollte C:\EDIABAS\BIN enthalten.


Das Verzeichnis C:\EDIABAS\TUTORIAL darf nicht schreibgeschützt sein.

Während des Tutorials wird auch auf die Programmierung der


Steuergerätekommunikation eingegangen. Um dies unabhängig von der
verwendeten Hardware und der verfügbaren Steuergeräte zu ermöglichen, wird der
in EDIABAS enthaltene Steuergeräte-Simulator verwendet. Eine genaue
Funktionsbeschreibung dazu befindet sich in [2]. Notwendig sind dazu die Dateien
DEMO*.SIM und EDIC.SIM.

Die einzelnen Phasen in der Entwicklung werden durch vorbereitete


Beschreibungsdateien im Verzeichnis C:\EDIABAS\TUTORIAL dargestellt. Es gibt
insgesammt 9 Schritte und dazu entsprechend die Dateien DEMO0.B2V bis
DEMO8.B2V.

Um mit dem nächsten Schritt fortzufahren starten Sie jetzt MS-WINDOWS.

4.2. Wie fange ich an?

Um mit der Entwicklung unserer SGBD beginnen zu können starten Sie im


Verzeichnis \EDIABAS\BIN das BestBoard-Programm BESTBD32.EXE (WIN32)
bzw. BESTBRD.EXE (WIN16). Sind alle Einstellungen richtig vorgenommen worden,
so erscheint sofort die Dialogbox "Notify Test Environment", die anzeigt, daß in dem
ausgewählten ECU-Directory der Steuergeräte-Simulator aktiviert ist. Außerdem wird
das Verzeichnis der Simulationsdateien und das simulierte Interface angezeigt. Es
wird angezeigt, ob die Traces von API und IFH aktiviert sind.

Nach Quittierung dieser Meldung sehen Sie das Hauptfenster von BestBoard. Aus
diesem Programm heraus lassen sich alle zur Erstellung und zum Test einer SGBD
notwendigen Aktionen steuern.

19
EDIABAS — BEST BENUTZERHANDBUCH

Um die Rohversion unserer SGBD zu öffnen wählen Sie das Menü FILE/OPEN oder
drücken Sie den dazugehörigen Button (2. von links, siehe auch Beschreibung von
BestBoard).

Um mit dem nächsten Punkt fortzufahren muß jetzt die Datei


C:\EDIABAS\TUTORIAL\DEMO0.B2V ausgewählt werden.

4.3. Schritt 1: Der Rahmen

Ist die Datei geöffnet worden, so wird automatisch der Texteditor NOTEPAD.EXE
aufgerufen, in dem die gewählte Datei angezeigt wird, in diesem Fall die Datei
DEMO0.B2V (Die in dieser Datei vorhandene Copyright Meldung wird in diesem
Dokument nicht abgedruckt). Diese Datei enthält einen leeren, aber bereits mit
Kommentaren versehenen Rahmen für eine SGBD:
////////////////////////////////////////////////////////////////////////
// H E A D E R
////////////////////////////////////////////////////////////////////////
ecu : ;
origin : ;
revision: ;
author : ;
comment : ;

////////////////////////////////////////////////////////////////////////
// K O N S T A N T E N
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// J O B S
////////////////////////////////////////////////////////////////////////

job( name : INITIALISIERUNG;


comment : Initialisierung;
comment : Dieser Job wird vom EDIABAS automatisch beim ersten;
comment : Zugriff auf eine SGBD aufgerufen. Bei weiteren Zugriffen;
comment : auf die selbe SGBD wird dieser Job nicht mehr aufgerufen.;
comment : in der INITIALISIERUNG werden alle Funktionen aufgerufen,;
comment : die nur einmal, vor der Kommunikation mit einem SG;
comment : notwendig sind.;
result : DONE;
type : int;
defrslt : ;
comment : Werte: 0 = Fehler bei der Initialisierung;
comment : Werte: 1 = Initialisierung erfolgreich durchgefuehrt;
)
{
DONE = 1;
}

20
EDIABAS — BEST BENUTZERHANDBUCH

////////////////////////////////////////////////////////////////////////

job( name : ENDE;


comment : Deinitialisierung;
comment : Dieser Job wird vom EDIABAS automatisch nach dem letzten;
comment : Zugriff auf diese SGBD aufgerufen. Er dient zu einer;
comment : evtl. Deinitialisierung der Interfacehardware;
)
{

////////////////////////////////////////////////////////////////////////

Die Datei enthält einen Header, der allerdings noch ausgefüllt werden muß, und zwei
Jobs. Es handelt sich um die StandardJobs INITIALISIERUNG und ENDE. Diese
Standardaufträge werden vom Laufzeitsystem automatisch aufgerufen, wenn eine
Beschreibungsdatei geladen (INITIALISIERUNG) bzw. wieder entladen (ENDE) wird.

Wie man erkennt, ist im Header eines Jobs dessen Name und mindestens eine
Kommentarzeile abgelegt. Ferner werden dort alle Parameter und Ergebnisse dieses
Jobs aufgelistet und kommentiert. Diese Header werden beim Übersetzten mit in die
Objekte übernommen und können mit Hilfe des XTRACT Tools aus diesem
ausgelesen werden. Der Header besteht aus n Einträgen der Form: "keyword : data
;". Hier nun die Beschreibung der Schlüsselwörter:

„ name Name des Jobs. Unter diesem Namen spricht das


Anwendungsprogramm diesen Job an.
„ comment Kommentarzeile. Hier steht ein beliebiger Kommentar (mindestens
1 Zeile)
„ result Beginn eines Ergebnisblocks. Es müssen die Schlüsselwörter type,
defrslt und comment(s) folgen, wobei die Angabe von defrslt
optional ist. data gibt den Namen des Ergebnisses an. Über diesen
Namen kann das Anwendungsprogramm und der Job auf das
Ergebnis zugreifen.
„ argument Beginn eines Parameterblocks. Es müssen die Schlüsselwörter
type und comment(s) folgen. data gibt den Namen des Parameters
an. Über diesen Namen kann der Job auf den Parameter zugreifen.
Für das Anwendungsprogram ist nur die Reihenfolge der Parameter
maßgebend.
„ type Typ des Parameters oder Ergebnisses, folgende Werte für data
zugelassen:
„ [unsigned] char Byte oder Character (8Bit)
„ [unsigned] int Word oder Integer (16Bit)
„ [unsigned] long Doubleword oder Long Integer (32Bit)
„ string Nullterminierter Textstring (maximal 1024
Byte)

21
EDIABAS — BEST BENUTZERHANDBUCH

„ real double-Wert
„ data Bytefeld (maximal 1024 Byte)
„ defrslt Optionaler Defaultwert für ein Ergebnis.

Im Job INITIALISIERUNG wird dem Ergebnis DONE der Wert 1 zugewiesen. Dieses
Ergebnis muß in diesem Job vorhanden sein. Es teilt dem Laufzeitsystem mit, ob der
Job erfolgreich beendet wurde oder nicht.

Um mit dem nächsten Punkt fortzufahren öffnen Sie jetzt die Datei
C:\EDIABAS\TUTORIAL\DEMO1.B2V .

4.4. Schritt 2: Mindestversion

Die jetzt geöffnete Datei ist jetzt bereits übersetzbar. Sie versucht eine Verbindung
zum Interface aufzubauen. Dazu mußten folgende Zeilen eingefügt bzw. abgeändert
werden:
////////////////////////////////////////////////////////////////////////
// H E A D E R
////////////////////////////////////////////////////////////////////////
↔ ecu : EDIABAS BEST/2 Demo Steuergeraet;
↔ origin : softing.SAG.HD;
↔ revision: 1.1;
↔ author : softing.SAG.HD;
↔ comment : Demonstrationsdatei fuer EDIABAS BEST/2;
...
job( name : INITIALISIERUNG;
comment : Initialisierung;
comment : Dieser Job wird vom EDIABAS automatisch beim ersten;
comment : Zugriff auf eine SGBD aufgerufen. Bei weiteren Zugriffen;
comment : auf dieselbe SGBD wird dieser Job nicht mehr aufgerufen;
comment : in der INITIALISIERUNG werden alle Funktionen aufgerufen;
comment : die nur einmal, vor der Kommunikation mit einem SG;
comment : notwendig sind.;
result : DONE;
type : int;
defrslt : ;
comment : Werte: 0 = Fehler bei der Initialisierung;
comment : Werte: 1 = Initialisierung erfolgreich durchgefuehrt;
)
{
→ open_communication(); // Verbindung zum Interface aufbauen

DONE = 1;
...
job( name : ENDE;
comment : Deinitialisierung;
comment : Dieser Job wird vom EDIABAS automatisch nach dem letzten;
comment : Zugriff auf diese SGBD aufgerufen. Er dient zu einer;

22
EDIABAS — BEST BENUTZERHANDBUCH

comment : evtl. Deinitialisierung der Interfacehardware;


)
{
→ open_communication(); // Verbindung zum Interface aufbauen

Der Header enthält jetzt folgende Informationen:

„ ecu: Ausgeschriebene Bedeutung und Funktion dieser


Beschreibungsdatei
„ origin: Name des Ersterstellers
„ revision: Versionskennung (RevMajor.RevMinor)
„ author: Autor der letzten Änderung (mehr als 63 Zeichen werden ignoriert)
„ comment: Beliebiger Kommentar (n Zeilen comment: ...; )

Diese Einträge werden beim Übersetzen mit ins Objekt übernommen.

Da diese SGBD mit einem Steuergerät , das heißt eigentlich mit dem
dazwischengeschalteten Interface, kommunizieren will, muß in den Jobs
INITIALISIERUNG und ENDE die Funktion open_communication aufgerufen
werden. Diese Funktion versucht, einen Kommunikationskanal zum Interface zu
öffnen. Eine spezielle Fehlerbehandlung ist nicht nötig. Tritt bei diesem
Funktionsaufruf ein Fehler auf, so wird die Bearbeitung des Jobs an dieser Stelle
abgebrochen und dem Anwendungsprogramm eine entsprechende Fehlermeldung
übergeben. Dies gilt für alle Kommunikationsfunktionen.

Um die jetzt erzeugte Datei zu übersetzen starten Sie im Menü PROJECT/COMPILE


den Compiler BEST2WIN. Solange der Compiler arbeitet ist sein Icon auf dem
Windows Bildschirmhintergrund sichtbar. Sollten bei der Übersetzung Fehler
auftreten, so werden diese danach im Anwendungsbereich von BestBoard angezeigt
und der Editor wird mit der entsprechenden Datei geladen. Mittels des Menüs
PROJECT/NEXT ERROR bzw. PROJECT/PREVIOUS ERROR ( optional auch mit
dem 6. und 7. Toolbar Button ) können alle Fehler der Reihe nach angezeigt und im
Editor korrigiert werden. Ein akustisches Signal und ein leerer Anwendungsbereich
zeigen an, daß der letzte Fehler bearbeitet wurde. Ist dies der Fall, so können Sie
jetzt den Compiler erneut starten. Zeigt der Compiler keine Fehlermeldungen mehr
an, so ist eine ablauffähige SGBD-Objektdatei generiert worden.

Um mit dem nächsten Punkt fortzufahren muß jetzt die Datei


C:\EDIABAS\TUTORIAL\DEMO2.B2V geöffnet werden.

23
EDIABAS — BEST BENUTZERHANDBUCH

4.5. Schritt 3: Steuergeräteparameter

Die jetzt geöffnete Datei soll jetzt auch das Hardwareinterface für die Kommunikation
mit dem Steuergerät vorbereiten. Dazu werden zuerst die Konstanten für die
Parameter und Telegramme definiert:
/////////////////////////////////////////////////////////////////////
// K O N S T A N T E N
/////////////////////////////////////////////////////////////////////
→ // *** SG - PARAMETER ***
→ //
→ // Konzept 1
→ // Baudrate 9600
→ // Reizadresse 0xaa
→ // Wakeup-Zeit 0 ms
→ // Idle-Zeit 0 ms
→ // Timeout-Zeit 2000 ms
→ // Regenerations-Zeit 500 ms
→ // Antwortlaenge -2 (2.Byte im Antworttelegram)
→ // Controlbyte 3 (3.Byte im Antworttelegram)
→ // 0x80: 3.Byte im Sendtelegram ist damit zu verknuepfen,
→ // um gueltiges drittes Antwortbyte darzustellen
→ //
→ int PARAMETER[] = {1,9600,0xaa,0,0,2000,500};
→ int AWLEN[] = {-2,0};
→ int CTRLPOS = 3;
→ int CTRLOR = 0x80;

→ // *** SG - TELEGRAMME ***
→ //
→ char TEL_ID_READ[] = { 0xAA,0x00,0x04,0x01 };
→ char TEL_TC_READ[] = { 0xAA,0x00,0x04,0x02 };
→ char TEL_TC_CLEAR[] = { 0xAA,0x00,0x04,0x03 };
→ char TEL_RPM_READ[] = { 0xAA,0x00,0x05,0x04,0x01 };
→ char TEL_TEMP_READ[] = { 0xAA,0x00,0x05,0x04,0x02 };
→ char TEL_VOLT_READ[] = { 0xAA,0x00,0x05,0x04,0x03 };
→ char TEL_PARAM_SET[] = { 0xAA,0x00,0x05,0x05,0xFF };
→ char TEL_END_DIAG[] = { 0xAA,0x00,0x04,0x0F };

Die Parameter defininieren, wie das Interface die Telegramme auf dem Diagnosebus
abarbeiten soll. Eine Erklärung der einzelnen Parameter befindet sich im Kommentar
vor der Definition der Parameterfelder.

CTRLPOS und CTRLOR sind Konstanten, die man immer wieder in dieser SGBD
braucht, deshalb werden sie hier am Beginn der Datei definiert, um die Datei leichter
lesbar zu machen.

Die Telegramme sind im Lastenheft des Steuergeräts festgelegte Diagnoseaufträge.

Im Job INITIALISIERUNG werden dem Interface die Kommunikationsparameter


übermittelt:

24
EDIABAS — BEST BENUTZERHANDBUCH

/////////////////////////////////////////////////////////////////////
{
open_communication(); // Verbindung zum Interface aufbauen
→ set_repeat_counter(2); // Wiederholungszaehler setzen
→ set_communication_pars(PARAMETER); // Kommunikationsparameter
→ set_answer_length(AWLEN); // einstellen
DONE = 1;
}

Die Funktion set_repeat_counter sorgt hier dafür, daß jede erfolglose


Steuergerätekommunikation zweimal wiederholt wird. Die Funktionen
set_communication_pars und set_answer_length benutzen die vorher definierten
Konstanten, um die Kommunikationsparameter in das Interface zu laden. Die genaue
Beschreibung der Funktionen und ihrer Parameter finden Sie in [1].

Um mit dem nächsten Punkt fortzufahren muß jetzt die Datei


C:\EDIABAS\TUTORIAL\DEMO3.B2V geöffnet werden.

4.6. Schritt 4: Steuergerätekommunikation

Die Datei DEMO3.B2V kann bereits mit dem Steuergerät kommunizieren. Um dies
sinnvoll zu ermöglichen werden am Ende der SGBD zwei Jobs angehängt:
→ ////////////////////////////////////////////////////////////////////////

→ job( name : READ_IDENT;
→ comment : Auslesen der Identifikationsdaten;
→ result : IDENT_STRING;
→ type : string;
→ defrslt : ;
→ comment : String der das SG identifiziert;
→ result : IDENT_VERSION;
→ type : string;
→ defrslt : ;
→ comment : SG-Versionsnummer (1.1);
→ )
→ {
→ unsigned char antwort[];
→ IDENT_STRING="*****";
→ IDENT_VERSION="*****";

→ send_and_receive(antwort,TEL_ID_READ);

→ }

→ ////////////////////////////////////////////////////////////////////////

→ job( name : CLEAR_TC;
→ comment : Loeschen des Fehlerspeichers;
→ result : STATUS;
→ type : string;

25
EDIABAS — BEST BENUTZERHANDBUCH

→ defrslt : ;
→ comment : Text: "Fehlerspeicher (NICHT) gelöscht";
→ )
→ {

→ unsigned char antwort[];
→ unsigned char statusText[];

→ send_and_receive(antwort,TEL_TC_CLEAR);
→ }

→ ////////////////////////////////////////////////////////////////////////

Der Job READ_IDENT soll zum Auslesen der Identifiaktionsdaten dienen. Er liefert
diese Identifikationsdaten in Form von zwei Textergebnissen, IDENT_STRING und
IDENT_VERSION an das aufrufende Anwendungsprogramm zurück. Diese
Ergebnisse werden im Job mit den Werten "*****" vorbelegt. Für die Aufnahme
der Steuergeräteantwort wird der Puffer antwort[] definiert. Eine Längenangabe
entfällt, in BEST/2 haben alle Felder 1024 Bytes Länge. Mit dem Aufruf der Funktion
send_and_receive wird das vordefinierte TEL_ID_READ an das Steuergerät
abgeschickt und die Antwort im Feld antwort erwartet.

Der Job CLEAR_TC soll den Fehlerspeicher im Steuergerät löschen. Dazu schickt er
das Telegramm TEL_TC_CLEAR an das Steuergerät. Die Antwort darauf wird im
lokal definierten Puffer antwort erwartet. Zusätzlich dazu wird noch das Feld
statusText definiert, in dem der Ergebnistext für das Ergebnis STATUS erzeugt
werden soll.

Der Job ENDE wird noch um das Senden des Diagnoseendetelegram


TEL_END_DIAG erweitert:
{
→ unsigned char antwort[];

open_communication(); // Verbindung zum Interface aufbauen
→ send_and_receive(antwort,TEL_END_DIAG);
}

Auch hier erwartet man die Antwort in dem Feld antwort.

Um die bisherigen Änderungen zu testen überstetzt man jetzt die SGBD. Die 2
Warnungen die ausgegeben werden, können ignoriert werden. Sie zeigen an, daß im
Job CLEAR_TC die Variable statusText und das Ergebnis STATUS nicht benutzt
wurden. Ist der Übersetzungslauf fehlerfrei, kann die Beschreibungsdatei mit dem
Debugger getestet werden. Dazu startet man den Debugger BestView mit dem Menü
PROJECT/DEBUG oder dem 5. Button von links.

26
EDIABAS — BEST BENUTZERHANDBUCH

Ist der Debugger gestartet, befindet man sich sofort in der Jobauswahl. Für den
ersten Versuch wählen Sie den Job READ_IDENT. Drücken Sie OK um Ihre Auswahl
zu bestätigen. Im Fenster sieht man den Quellcode der SGBD. Blättern Sie nach
unten bis zur Zeile 109 und setzen Sie den Cursor darauf. Mit der Taste F9
(DEBUG/TOGGLE BREAKPOINT) können Sie in dieser Zeile einen Breakpoint
setzen, d.h. die Bearbeitung des Jobs wird dort unterbrochen. Die Taste F5
(RUN/GO) startet den ausgewählten Job. Ein Fenster mit einem Zähler zeigt die
Anzahl der abgearbeiteten internen Abarbeitungszyklen an. Ist die Bearbeitung an
der Zeile 109 angelangt, so wird die Bearbeitung unterbochen und die aktuelle Zeile
markiert. Diese Zeile ist noch nicht bearbeitet worden. Mit der Taste F8 (RUN/STEP)
können Sie die Bearbeitung jetzt zeilenweise fortsetzten. Der Debugger ermöglicht
Ihnen während der zeilenweisen Abarbeitung oder nach dem Erreichen eines
Breakpoints die Anzeige von Variablen und Ergebnisinhalten. Eine näherere
Beschreibung finden Sie in der Online-Hilfe von BestView (HELP/CONTENTS).

Um den Job ohne Unterbrechung zum Ende durchlaufen zu lassen betätigen Sie
einfach wieder die Taste F5 (RUN/GO). Ist der Job vollständig abgearbeitet worden,
so erscheint ein Fenster mit den vom Job ermittelten Ergebnissen in diesem Fall
sollte es folgendes enthalten:

VARIANTE = DEMO3.PRG
OBJECT = DEMO3
SETS = 1
UBATTCURRENT = UNKNOWN UBATTHISTORY = UNKNOWN
IGNITIONCURRENT = UNKNOWN IGNITIONHISTORY = UNKNOWN
JOB STATUS =

SET 1: RESULT 1: [ TEXT ] IDENT_STRING = "*****"


RESULT 2: [ TEXT ] IDENT_VERSION = "*****"

Der beschriebene Vorgang kann beliebig oft mit diesem oder einem anderen Job
wiederholt werden.

Um mit dem nächsten Punkt fortzufahren muß jetzt die Datei


\EDIABAS\TUTORIAL\DEMO4.B2V geöffnet werden.

4.7. Schritt 5: String- und Data- Funktionen

In dieser Version werden die vom Steuergerät gelieferten Antworttelegramme


ausgewertet. Der Job READ_IDENT wird hierzu wie folgt erweitert:
{
unsigned char antwort[];
→ unsigned char idString[];

27
EDIABAS — BEST BENUTZERHANDBUCH

→ unsigned char verString[];

IDENT_STRING="*****";
IDENT_VERSION="*****";

send_and_receive(antwort,TEL_ID_READ);

→ // Gueltige Antwort ?
→ if (antwort[CTRLPOS]==TEL_ID_READ[CTRLPOS]|CTRLOR) {

→ // Make IDENT_STRING
→ datacopy(idString,antwort,4,13);
→ strrevers(idString);
→ IDENT_STRING=idString;

→ // Make IDENT_VERSION
→ dataclear(idString);
→ bcd2ascii(verString,antwort,17,1);
→ strcpy(idString,verString);
→ strcat(idString,".");
→ bcd2ascii(verString,antwort,18,1);
→ strcat(idString,verString);
→ IDENT_VERSION=idString;
→ }
}

Zur Berechnung der Textergebnisse werden die Puffer idString und verString
definiert. Nach Prüfung des Kontrollbytes im Antworttelegramm werden ab der 4.
Stelle 13 Zeichen aus dem Telegramm herauskopiert. Damit das Ergebnis richtig
dargestellt wird, muß der String noch mit der Funktion strrevers umgedreht werden.

Die Steuergeräteversion liegt als 4stellige BCD-Zahl im Telegramm ab Adresse 17


vor. Die erste BCD-Zahl wird eingelesen (bcd2ascii) und in den Puffer idString
kopiert. Zur Trennung der Versionsnummer wird daran ein Punkt angehängt und des
weiteren die zweite BCD-Zahl angehängt.

Im Job CLEAR_TC soll abhängig vom zurückgelieferten Kontrollbyte das


Textergebnis Status mit dem String "Fehlerspeicher geloescht" oder
"Fehlerspeicher NICHT geloescht" belegt werden:
unsigned char antwort[];
unsigned char statusText[];

→ statusText="Fehlerspeicher ";

send_and_receive(antwort,TEL_TC_CLEAR);

→ // Gueltige Antwort ?
→ if (antwort[CTRLPOS]!=(TEL_TC_CLEAR[CTRLPOS]|CTRLOR))
→ strcat(statusText,"NICHT ");

→ strcat(statusText,"geloescht");

28
EDIABAS — BEST BENUTZERHANDBUCH

→ STATUS=statusText;
}

Übersetzt man die jetzt erstellte Datei und startet wie im vorhergehenden Kapitel den
Debugger, so bekommt man nach Abarbeitung des Jobs READ_IDENT jetzt folgende
Ausgabe im Fenster Results zu sehen:

VARIANTE = DEMO4.PRG
OBJECT = DEMO4
SETS = 1
UBATTCURRENT = UNKNOWN UBATTHISTORY = UNKNOWN
IGNITIONCURRENT = UNKNOWN IGNITIONHISTORY = UNKNOWN
JOB STATUS =

SET 1: RESULT 1: [ TEXT ] IDENT_STRING = "ICH BIN SG


AA"
RESULT 2: [ TEXT ] IDENT_VERSION = "18.29"

Um mit dem nächsten Punkt fortzufahren muß jetzt die Datei


C:\EDIABAS\TUTORIAL\DEMO5.B2V geöffnet werden.

4.8. Schritt 6: Ergebnissätze

Diese Version soll den Fehlerspeicher des Steuergeräts auslesen und auswerten.
Dazu wird die SGBD um den Job READ_TC erweitert:
→ job( name : READ_TC;
→ comment : Auslesen des Fehlerspeichers;
→ result : TC_NR;
→ type : int;
→ defrslt : ;
→ comment : Nr des Fehlers;
→ )
→ {
→ unsigned char antwort[];
→ int count;

→ send_and_receive(antwort,TEL_TC_READ);

→ // Gueltige Antwort ?
→ if (antwort[CTRLPOS]==TEL_TC_READ[CTRLPOS]|CTRLOR) {

→ count=256*antwort[1]+antwort[2]-4; // Anzahl der Fehler berechnen.

→ while(count--) { // Fuer alle Fehler
→ TC_NR=antwort[4+count]; // Ergebnis Fehlernummer zuweisen
→ new_set_of_results(); // Neuen Ergebnissatz beginnen
→ }
→ }

29
EDIABAS — BEST BENUTZERHANDBUCH

→ }

Dieser Job liefert das Ergebnis TC_NR, das einfach den gespeicherten Fehlercode
abbildet, für alle vom Steuergerät gemeldeten Fehler zurück. Um dies zu
ermöglichen wird dasselbe Ergebnis in mehreren Ergebnissätzen abgelegt. In der
Schleife, die über alle Fehler läuft, wird nach der Zuweisung des Ergebniswerts
immer wieder der Beginn eines neuen Satzes markiert. Alle Ergebnisse, die danach
zugewiesen werden, werden in diesem neuen Satz abgelegt. Die Ergebnisse in den
vorhergehenden Sätzen werden nicht mehr verändert.

Dieser Job liefert folgende Ergebnisse zurück, wenn er nach oben beschriebenen
Muster im Debugger abgearbeitet wird:

VARIANTE = DEMO5.PRG
OBJECT = DEMO5
SETS = 5
UBATTCURRENT = UNKNOWN UBATTHISTORY = UNKNOWN
IGNITIONCURRENT = UNKNOWN IGNITIONHISTORY = UNKNOWN
JOB STATUS =

SET 1: RESULT 1: [ INTEGER ] TC_NR = +5


SET 2: RESULT 1: [ INTEGER ] TC_NR = +48
SET 3: RESULT 1: [ INTEGER ] TC_NR = +2
SET 4: RESULT 1: [ INTEGER ] TC_NR = +16
SET 5: RESULT 1: [ INTEGER ] TC_NR = +1

Es werden fünf Ergebnissätze angelegt, die alle das gleiche Ergebnis, jedoch mit
verschiedenen Werten, beinhalten.

Um mit dem nächsten Punkt fortzufahren muß jetzt die Datei


C:\EDIABAS\TUTORIAL\DEMO6.B2V geöffnet werden.

4.9. Schritt 7: Tabellenbearbeitung

Die Datei DEMO6.B2V soll zusätzlich zu den vorgenannten Ergebnissen im Job


READ_TC nicht nur den Fehlercode, sondern auch den entsprechenden Fehlertext
zurückliefern. Diese Fehlertexte werden hierzu in einer Tabelle abgelegt:
char TEL_END_DIAG[] = { 0xAA,0x00,0x04,0x0F };

→ // *** SG - TABELLEN ***
→ //
→ // Tabelle der Fehlerorttexte
→ table TCText[2][]=

30
EDIABAS — BEST BENUTZERHANDBUCH

→ {
→ {"NR", "TEXT" },
→ {"0x01", "Drehzahlfuehler Fehler hinten links" },
→ {"0x02", "Drehzahlfuehler Fehler hinten rechts" },
→ {"0x03", "Drehzahlfuehler Fehler vorne rechts" },
→ {"0x04", "Drehzahlfuehler Fehler vorne links" },
→ {"0x05", "ABS Ventil Fehler hinten links" },
→ {"0x06", "ABS Ventil Fehler hinten rechts" },
→ {"0x07", "ABS Ventil Fehler vorne rechts" },
→ {"0x08", "ABS Ventil Fehler vorne links" },
→ {"0x10", "Interner Fehler" },
→ {"0xFF", "undefinierter Fehler" }
→ };

Diese Tabelle hat 2 Spalten und beliebig viele Zeilen. In der ersten Spalte "NR" ist
der Fehlercode im Hexadezimalformat abgelegt, wie es die Funktion
tab_suche_index verlangt. Die 2. Spalte "TEXT" enthält den korrespondierenden
Fehlertext zur entspechenden Fehlernummer. Die letzte Zeile enthält die
Defaultfehlermeldung, die vewendet werden soll, wenn der Fehlercode nicht
gefunden wird.

Der Job READ_TC muß wie folgt abgeändert werden:


comment : Nr des Fehlers;
→ result : TC_TEXT;
→ type : string;
→ defrslt : ;
→ comment : Fehlertext;
)
{
unsigned char antwort[];
→ char tableText[];
int count;

send_and_receive(antwort,TEL_TC_READ);

// Gueltige Antwort ?
if (antwort[CTRLPOS]==TEL_TC_READ[CTRLPOS]|CTRLOR) {

count=256*antwort[1]+antwort[2]-4; //Anzahl Fehler berechnen.

→ tabset("TCText"); // Initialisierung der Tabellenbehandlung

while(count--) { // Fuer alle Fehler

→ tab_suche_index("Nr",antwort[4+count]); // Suchen der


// Fehlernummer
→ tabget(tableText,"Text"); // Auslesen des korrespon-
// dierenden Fehlertexts
TC_NR=antwort[4+count]; // Ergebnis Fehlernummer zuweisen
→ TC_TEXT=tableText; // Ergebnis Fehlertext zuweisen

new_set_of_results(); // Neuen Ergebnissatz beginnen


}

31
EDIABAS — BEST BENUTZERHANDBUCH

Der Befehl tabset initialisert die Tabellenbehandlung. Alle Befehle zur


Tabellenverarbeitung wirken sich danach auf die Tabelle "TCText" aus. Der Befehl
tab_suche_index wandelt das zweite ihm übergebene Argument in einen String
um, der das Format "0x##" hat. Dieser String wird in der Tabellenspalte "NR"
gesucht. Ist der Wert gefunden, so wird die Suche abgebrochen. Der Befehl tabget
liest dann den zugehörigen Text in der Spalte "TEXT" der gleichen Zeile aus. Wenn
der Suchtext nicht gefunden wurde, so liest er den Text aus der letzten Zeile.

Die Ergebnisse dieses Jobs sehen jetzt folgendermaßen aus:


VARIANTE = DEMO6.PRG
OBJECT = DEMO6
SETS = 5
UBATTCURRENT = UNKNOWN UBATTHISTORY = UNKNOWN
IGNITIONCURRENT = UNKNOWN IGNITIONHISTORY = UNKNOWN
JOB STATUS =

SET 1: RESULT 1: [ INTEGER ] TC_NR = +5


RESULT 2: [ TEXT ] TC_TEXT = "ABS Ventil Fehler hinten links"
SET 2: RESULT 1: [ INTEGER ] TC_NR = +48
RESULT 2: [ TEXT ] TC_TEXT = "undefinierter Fehler"
SET 3: RESULT 1: [ INTEGER ] TC_NR = +2
RESULT 2: [ TEXT ] TC_TEXT = "Drehzahlfuehler Fehler hinten rechts"
SET 4: RESULT 1: [ INTEGER ] TC_NR = +16
RESULT 2: [ TEXT ] TC_TEXT = "Interner Fehler"
SET 5: RESULT 1: [ INTEGER ] TC_NR = +1
RESULT 2: [ TEXT ] TC_TEXT = "Drehzahlfuehler Fehler hinten links"

In jedem Ergebnissatz werden 2 Ergebnisse, die Fehlernummer und der Fehlertext,


zurückgegeben.

Um mit dem nächsten Punkt fortzufahren müssen Sie jetzt die Datei
C:\EDIABAS\TUTORIAL\DEMO7.B2V öffnen.

4.10. Schritt 8: Realverarbeitung und Ergebnisanforderung

In dieser Version unserer SGBD wird ein Job hinzugefügt, der das Auslesen von drei
Statuswerten aus dem Steuergerät ermöglicht. Das Anwendungsprogramm kann hier
bestimmen, welche Ergebnisse berechnet werden sollen, und welche nicht. Damit
kann der Jobablauf beschleunigt werden, wenn nur ein Ergebnis benötigt wird. Der
neue Job wird an das Ende der SGBD angehängt:
→ /////////////////////////////////////////////////////////////////////

→ job( name : READ_STATES;
→ comment : Auslesen diverser Stati;
→ result : ENGINESPEED;
→ type : unsigned int;
→ defrslt : ;
→ comment : Drehzahl in UPM;

32
EDIABAS — BEST BENUTZERHANDBUCH

→ result : TEMPERATURE;
→ type : real;
→ defrslt : ;
→ comment : Temperatur in Grad C;
→ result : VOLTAGE;
→ type : real;
→ defrslt : ;
→ comment : Versorgungsspannung in Volt;
→ )
→ {

→ unsigned char antwort[]; // Puffer fuer SG-Antwort
→ unsigned int tmp; // Hilfsvariable
→ real a; // Hilfsvariable
→ real b; // Hilfsvariable

→ if(ENGINESPEED) { //Ergebnis angefordert ?

→ send_and_receive(antwort,TEL_RPM_READ);

→ if (antwort[CTRLPOS]==TEL_RPM_READ[CTRLPOS]|CTRLOR) {
→ tmp=256*antwort[4]+antwort[5];
→ tmp/=4; //adc16/4
→ ENGINESPEED=tmp;
→ }
→ }
→ if(TEMPERATURE) { //Ergebnis TEMPERATURE angefordert ?

→ send_and_receive(antwort,TEL_TEMP_READ);

→ if (antwort[CTRLPOS]==TEL_TEMP_READ[CTRLPOS]|CTRLOR) {
→ tmp=256*antwort[4]+antwort[5];
→ itor(a,tmp);
→ ator(b,"100.0"); //adc16/100-40
→ realdiv(a,b);
→ ator(b,"40.0");
→ realsub(a,b);
→ TEMPERATURE=a;
→ }
→ }
→ if(VOLTAGE) { //Ergebnis VOLTAGE angefordert ?

→ send_and_receive(antwort,TEL_VOLT_READ);

→ if (antwort[CTRLPOS]==TEL_VOLT_READ[CTRLPOS]|CTRLOR) {
→ tmp=256*antwort[4]+antwort[5];
→ itor(a,tmp);
→ ator(b,"1.238"); //1.238*adc16100/4000
→ realmul(a,b);
→ ator(b,"4000.0");
→ realdiv(a,b);
→ VOLTAGE=a;
→ }
→ }
→ }

33
EDIABAS — BEST BENUTZERHANDBUCH

Das Konstrukt if(ENGINESPEED) liest nicht etwa den Wert des Ergebnisses
ENGINESPEED aus, sondern stellt fest, ob dieses Ergebnis vom
Anwendungsprogramm angefordert wurde (wie das Anwendungprogramm diese
Ergebnisse anfordert, ist in [6] beschrieben). ENGINESPEED liefert TRUE zurück,
wenn das Ergebnis berechnet werden soll, ansonsten FALSE. Sie können dies auch
in BestView testen, der Dialog RUN/JOB enthält ein Feld, in dem die Ergebnisse, die
angefordert werden, eingetragen werden können. Wird nicht eingegeben, so werden
alle Ergebnisse zurückgegeben. Um die Ergebnisse VOLTAGE und ENGINESPEED
anzufordern, geben Sie folgendes in das Feld "Results you want to see:"

voltage;enginespeed

In diesem Fall werden die Anweisungen im Block if(TEMPERATURE) { ... }


nicht bearbeitet. Wird nichts übergeben, dann gelten alle Ergebnisse als angefordert.

Wird nichts eingegeben, so werden alle Ergebnisse zurückgegeben.

Bei der Berechnung der Temperatur (TEMPERATURE) und der Versorgungsspannung


(VOLTAGE) wird ein Integerwert aus dem Antworttelegram ausgelesen (tmp) und
mittels der Funktion itor in eine Realzahl gewandelt. Die weitere Manipluation dieser
Realzahl erfolgt über Funktionen, da BEST/2 keine Operatoren zur Verarbeitung von
Realzahlen zur Verfügung stellt.

Um mit dem nächsten Punkt fortzufahren müssen Sie jetzt die Datei
C:\EDIABAS\TUTORIAL\DEMO8.B2V öffnen.

4.11. Schritt 9: Jobparameter

Die Beschreibungsdatei wird in dieser letzten Version noch um einen Job erweitert,
der einen vom Anwendungprogramm übergebenen Parameter an das Steuergerät
übermittelt. Der Parameter, der übergeben wird, ist ein Byte, das in das Telegramm
zum Steuergerät eingefügt werden soll. Ist der Parameter übergeben worden, so wird
das 5. Byte im Telegramm an das Steuergerät mit seinem Wert überschrieben. Wenn
er nicht angegeben wird, wird das vordefinierte Telegramm benutzt:
→ /////////////////////////////////////////////////////////////////////

→ job( name : SET_PARAM;
→ comment : Setzen eines Parameters im SG;
→ argument : PARAMETER;
→ type : int;
→ comment : Wert des zu setzenden Parameters;
→ result : STATUS;
→ type : string;
→ defrslt : ;

34
EDIABAS — BEST BENUTZERHANDBUCH

→ comment : Text: "Parameter (NICHT) gesetzt";


→ )
→ {

→ unsigned char antwort[]; // Puffer fuer SG-Antwort
→ unsigned char request[]; // Puffer fuer SG_Request
→ unsigned char statusText[]; // Puffer fuer Ergebnistext

→ request=TEL_PARAM_SET; // Request erzeugen

→ if(exist(PARAMETER)) { // Wenn Parameter vorhanden
→ request[4]=PARAMETER; // Reuqest aendern
→ }
→ send_and_receive(antwort,request);

→ statusText="Parameter "; // statusText vorbelegen
→ // Gueltige Antwort ?
→ if (antwort[CTRLPOS]!=(TEL_PARAM_SET[CTRLPOS]|CTRLOR))
→ strcat(statusText,"NICHT ");

→ strcat(statusText,"gesetzt");
→ STATUS=statusText;
→ }

Der exist Operator überprüft, ob dem Job der Parameter PARAMETER übergeben
wurde. Das Anwendungsproramm muß die Parameter in der Reihenfolge übergeben,
in der sie im Job Header definiert worden sind. Eine Überprüfung findet nicht statt.
Die Parameter werden vom Anwendungsprogramm als ein zusammenhängender
String übergeben. Darin werden die einzelnen Parameter mit ; getrennt. Ein
Parameter ;; gilt als nicht übergeben. Sie können auch in BestView dem Job
Argumente übergeben. Dazu editieren Sie im Dialog RUN/JOB das Feld "Parameters
to supplied to job:".

Beispiele:

;;TEST
Übergibt nur TEST als drittes Argument an einen Job.

0x0005;0x0001
Übergibt zwei Parameter an einen Job.

Die Parameter müssen mit Datentypen versehen werden. Es wird dann automatisch
gewandelt. Ist der erste Parameter im vorhergehenden Beispiel z.B. vom Typ string
und der zweite vom Typ int, so wird der erste als Feld betrachetet und der zweite als
Zahl.

35
EDIABAS — BEST BENUTZERHANDBUCH

4.12. Binärparameter und -Ergebnisse

Ein Job kann auch binäre Parameter und Ergebnisse erhalten und zurückgeben.

Es kann nur ein binärer Parameter vom Typ data definiert werden. Dieser enthält ein
binäres Feld, das entweder den kompletten Parameterstring oder ein spezielles
Datenfeld enthält. Zur Übergabe eines binären Datenfelds stehen in API spezielle
Funtionen (apiJobData/apiJobExt, siehe [6]) zur Verfügung.

Im Gegensatz dazu kann man mehrere Ergebnisse vom Typ data definieren. Diesen
Ergebnissen können dann Arrayvariablen im binären Format, z.B. Telegramme
zugewiesen werden.

36
EDIABAS — BEST BENUTZERHANDBUCH

Beispiel:
job( name : READ_2_TELEGRAMS
comment : Setzen eines Parameters im SG;
argument : SEND_TEL;
type : data;
comment : Zu sendendes Telegramm;
result : RECV_TEL_1;
type : data;
defrslt : ;
comment : 1. Empfangstelegram;
result : RECV_TEL_2;
type : data;
defrslt : ;
comment : 2. Empfangstelegram;
)
{

unsigned char antwort1[]; // Puffer fuer SG-Antwort


unsigned char antwort2[]; // Puffer fuer SG-Antwort
unsigned char request[]; // Puffer fuer SG_Request

request=SEND_TEL; // Request erzeugen

send_and_receive(antwort1,request); // SG-Kommunikation
send_and_receive(antwort2,request);

RECV_TEL_1=antwort1; // Ergebnisse
RECV_TEL_2=antwort2;

37
EDIABAS — BEST BENUTZERHANDBUCH

5. BEST-Tools

In diesem Kapitel werden Tools zur Erstellung von Beschreibungsdateien


beschrieben.

5.1. BEST2WIN

BEST2WIN dient zur Übersetzung von in BEST/2 geschriebenen SGBDen in ein von
EDIABAS interpretierbares Objektformat.

BEST2WIN ist ein Windows Programm mit Namen BEST2WIN.EXE und wird somit
aus dem Programm- oder dem Datei-Manager heraus gestartet. Es empfiehlt sich
jedoch BEST2WIN in eine Programm-Gruppe aufzunehmen.

Im Menü "Help" finden Sie unter dem Punkt "Contents" eine Online Hilfe, die alle
Bedienungsvorgänge sowie die Aufrufparameter von BEST2WIN ausführlich erklärt.

BEST2WIN kann auch über die Kommandozeile parametrisiert werden:

BEST2WIN [-C commandfile] [-B] [-A] [-I] [-S] [-L libfile] [-Z includedir]
[-R RevMAJ.RevMIN username] [-O errorlogfile]
[-P Paßwortlabel|@Paßwortlabelliste ] sourcefile [outdir]
Die Option -L ermöglicht die Angabe einer alternativen BEST/2 Laufzeitbibliothek.
Wird diese Option nicht genutzt, verwendet BEST2WIN standardmäßig die Datei
B2RUNTIM.LIB. Sie wird in dem Verzeichnis gesucht, in dem BEST2WIN.EXE steht.
BEST2WIN unterstützt die Verwendung von Includedateien. Include-Dateien werden
zuerst im Verzeichnis der BEST/2-Quelldatei gesucht. Mit der Option -Z ist es
möglich die Suche auf ein zusätzliches Verzeichnis auszudehnen. Bei Angabe
mehrere Include-Verzeichnisse werden diese von links nach rechts berücksichtigt,
Wobei jedes Verzeichnis mit der Option –Z gekennzeichnet ist (-Z incldir1 –Z incldir2
... –Z incldirN). Die Option -Z wird nicht berücksichtigt, falls in der BEST/2-Quelldatei
bereits Angaben zum Pfad der Include-Datei gemacht wurden.
Die Option -S bewirkt die zusätzliche Ausgabe der BEST/2-Preprozessordatei mit der
Endung .p2v für Variantenbeschreibungsdateien oder .p2g für
Gruppenbeschreibungsdateien. In der BEST/2-Preprozessordatei befindet sich der
gesamte BEST/2-Quellcode inklusive dem Inhalt der BEST/2-Includedateien.
Wird die Option -A oder -I mit angegeben, so wird zusätzlich zur Objektdatei
entweder ein Assembleroutput (*.b1?) oder ein Infofile mit der Endung .biv für
Variantenbeschreibungsdateien oder .big für Gruppenbeschreibungsdateien oder

38
EDIABAS — BEST BENUTZERHANDBUCH

beides ausgegeben. Im Infofile sind alle Zwangskommentare aus der BEST/2-


Quelldatei aufgelistet.
Mit der Option -R und ihren Parametern ist es möglich in der Objektdatei eine
bestimmte Revsionsnummer und einen Autor zu speichern, damit werden die
Angaben im BEST/2 Header überschrieben.

Mit der Option –O wird eine Error-Log-Datei angelegt. Diese Datei hat die Endung
.out. Wird Option -O nicht angegeben, dann wird im Fehlerfall automatisch eine
Error-Log-Datei mit dem Namen best2err.out angelegt.
Mit der Option -P und ihren Parametern ist es möglich, in der Objektdatei bestimmte
Paßwörter zu speichern. Es kann entweder ein einzelnes Label zu einem Paßwort
angegeben werden oder es kann eine ganze Liste von Label in einer Datei
angegeben werden. Der Parameter wird durch ein vorangestelltes "@" als
Dateiname gekennzeichnet. Es können nur Label von Paßwörtern verwendet
werden, die dem System zuvor über den Paßworteditor bekanntgemacht wurden.

Der Parameter sourcefile beschreibt die BEST/2 Quelldatei. Der optionale Parameter
outdir legt fest, in welchem Verzeichnis BEST2WIN die Ausgabedateien anlegen soll.

BEST2WIN-Kommandozeilenparameter können in gesonderten Textdateien


gespeichert und BEST2WIN über den Kommandozeilenparameter -C
<Kommandozeilenparameterdatei> bekanntgegeben werden.

Beispiele:

BEST2WIN demo.b2v
BEST2WIN -R 1.0 Otto *.b2g
BEST2WIN -A -I -S -Z c:\test\ecu\include test.b2v c:\test\ecu
BEST2WIN -L c:\test\ecu\mylib.lib -I test.b2v c:\test\ecu
BEST2WIN -P GEHEIM test.b2v c:\test\ecu

Für jede fehlerfrei übersetzte Quelldatei wird die erforderliche Mindestversion von
EDIABAS ausgegeben:

<Quelldatei>: 0 error(s) [ EDIABAS <Mindestversion> ]

39
EDIABAS — BEST BENUTZERHANDBUCH

5.2. BestBoard

5.2.1.Allgemeines
BestBoard integriert die Erstellung von Beschreibunsdateien in einem Programm. Es
übernimmt die Ansteuerung des Editors, des Compilers und des Debuggers.
Darüberhinaus ist das Ausführen von eigenen Anwendungsprogrammen zu
Testzwecken möglich.

BestBoard ist für WIN32 (BESTBD32.EXE) und WIN16 (BESTBRD.EXE) verfügbar.


BestBoard wird aus dem Explorer- bzw. dem Datei-Manager heraus gestartet. Es
empfiehlt sich jedoch BestBoard in eine Programm-Gruppe aufzunehmen.

Nach dem Aufruf von BestBoard sind zuerst 2 Verzeichnisse einzutragen:

„ ECU-Verzeichnis:
Menü: Options-ECU Directory
In diesem Verzeichnis befinden sich die SGBDen im Objektformat, bzw. sollen
dort abgelegt werden.
Bei Programmstart wird das EDIABAS-Konfigurationselement EcuPath
berücksichtigt und - falls vorhanden - übernommen.

„ EDIABAS-Verzeichnis:
Menü: Options-EDIABAS Directory
In diesem Verzeichnis befindet sich die installierte EDIABAS-Version mit den
Unterverzeichnissen BIN, ECU, API usw.
Bei Programmstart wird das aktuelle EDIABAS-Verzeichnis angenommen.

Zusätzlich sollte der zu verwendende Editor eingetragen werden:

Im Menü Tools/Editor ist der Name des Editors mit der genauen Kommandozeile
einzutragen. Ein Arbeitsverzeichnis des Editors kann optional angegeben werden.
Als Voreinstellung wird der unter Windows allgemein verfügbare Editor "Notepad"
benutzt.

Ist während des Startens oder Stoppens von BestBoard die Steuergerätesimulation
oder ein EDIABAS-Trace eingeschaltet, so erfolgt eine Warnung unter Anzeige der
eingestellten Parameter.

40
EDIABAS — BEST BENUTZERHANDBUCH

5.2.2.Menüübersicht
File
New Erstellung einer neuen Beschreibungsdatei (BEST/2-
Quelldatei)
Open Öffnen einer Beschreibungsdatei (als Quelldatei oder
Objektdatei)
Im Menü File werden zudem die letzten 4
Beschreibungsdateien aufgeführt, durch Anwahl eines
Namens wird die jeweilige Beschreibungsdatei geöffnet
Exit Verlassen des Programms
Project
Edit Aufruf des Editors mit der BEST-Quelldatei
Compile Übersetzung der BEST-Quelldatei durch Aufruf von
BEST2WIN
Debug Aufruf des BEST-Debuggers BestView mit der BEST-
Quelldatei und der BEST-Objektdatei
Next Error Anzeige des nächsten Übersetzungsfehlers
Previous Error Anzeige des vorherigen Übersetzungsfehlers
Run Application Aufruf des aktiven Anwendungsprogramms (siehe auch
Kapitel Anwendungsprogramme)
Tools
Applications Menü zur Anwendungsprogrammverwaltung: Aktivieren,
Löschen, Hinzufügen, Ändern und Aufruf von
Anwendungsprogrammenen
Editor Bestimmung des zu verwendenden Editors
API-Trace Ein-/Ausschalten von API-Trace
IFH-Trace Ein-/Ausschalten von IFH-Trace
ECU Simulation Ein-/Ausschalten des Steuergeräte-Simulators
Options
ECU Directory Bestimmung des ECU-Verzeichnisses
Hinweis: Die Environment-Variable ECU wird nicht
geändert !
EDIABAS-Dir. Bestimmung des EDIABAS-Verzeichnisses
Hinweis: Die Environment-Variable EDIABAS wird nicht
geändert !
Auto Editor Act. Automatische Aktivierung des Editors beim Öffnen der
BEST-Quelldatei.
Save Configur. Speicherung der aktuellen BestBoard-Konfiguration bei
Verlassen von BestBoard (Datei BESTBD.INI bzw.
BESTBRD.INI im Windows-Verzeichnis)
Window

41
EDIABAS — BEST BENUTZERHANDBUCH

Default Setzen der voreingestellten Position und Größe des


BestBoard-Hauptfensters
Always On Top Ein-/Ausschalten der Möglichkeit, BestBoard immer im
Vordergrund des Desktops zu positionieren
Toolbar Ein-/Ausschalten der Toolbar
Status Bar Ein-/Ausschalten der Statusanzeige
Help
About Anzeigen der Version von BestBoard

42
EDIABAS — BEST BENUTZERHANDBUCH

5.2.3.Toolbar
Die Toolbar soll das Anwählen der wichtigsten Menüpunkte vereinfachen. So bewirkt
das Anwählen eines Buttons in der Toolbar nur das Anwählen des zugeordneten
Menüs.

Anwendungsprogramm ausf
Nächster Fehler
Vorhergehender Fehler
Debugger aufrufen
Compiler starten
Datei editieren
Datei öffnen
Neue Beschreibungsdatei anlegen

"Gedrückte" Buttons zeigen eine bereits gestartete Aktion an (z.B. Übersetzer läuft)

5.2.4.Anwendungsprogramme
Es besteht in BestBoard die Möglichkeit, beliebige Programme zu integrieren, welche
zur Entwicklung bzw. zum Test von Beschreibungsdateien benötigt werden.
BestBoard kann mehrere Anwendungsprogramme gleichzeitig verwalten, wobei
immer das aktive Anwendungsprogramm von BestBoard gestartet wird. Als aktives
Anwendungsprogramm gilt das im Menü TOOLS/APPLICATIONS ausgewählte
Anwendungsprogramm.

Für jedes Anwendungsprogramm ist der Name sowie die Kommandozeile


anzugeben. Optional kann noch das Arbeitsverzeichnis angegeben werden, in
welchem die Anwendungsprogramm gestartet wird.

In der Kommandozeile können verschiedene Ersetzungen angegeben werden


(z.B.aktuelle Objektdatei, aktuelles ECU-Verzeichnis, ...)

Als Anwendungsprogramm können in BESTBD32.EXE sowohl WIN32- als auch


WIN16- Programme angegeben werden. IN BESTBRD.EXE können hingegen nur
WIN16-Programme angegeben werden.

43
EDIABAS — BEST BENUTZERHANDBUCH

Hinweis:

Anwendungsprogramme können nur aufgerufen werden, wenn eine


Beschreibungsdatei in BestBoard geöffnet bzw. erzeugt ist.

5.2.5.Entwicklung einer Beschreibungsdatei mit BestBoard


1. BEST-Quelldatei erstellen:
„ Falls Quelldatei noch nicht existiert: Menü File/New oder Toolbar-Button
„ Falls Quelldatei bereits existiert: Menü File/Open oder Toolbar-Button
„ Quelldatei im Editor (wird automatisch gestartet) eingeben

2. BEST-Quelldatei übersetzen
„ Menü Project/Compile oder Toolbar-Button
„ Falls Übersetzungsfehler auftreten:
Quelldatei im Editor (wird automatisch gestartet) korrigieren, die
betreffende Zeilennummer sowie die Fehlermeldung wird im
Arbeitsbereich von BestBoard ausgegeben. Mit den Menüs Project/Next
Error bzw. Project/Previous Error kann auf die anderen Fehlermeldungen
umgeschaltet werden. Ein akustischer Warnton und leerer Arbeitsbereich
zeigen das Ende der Fehlerliste an.
„ Nach Korrektur der Beschreibungsdatei im Editor: Wiederholung von 2.

3. Beschreibungsdatei mit Debugger testen


„ Menü Project/Debug oder Toolbar-Button
„ Bei logischen Fehlern:
Editor mit Menü Project/Edit oder Toolbar-Button starten und Quelldatei
ändern, dann Wiederholung von 2.

4. Beschreibungsdatei mit einer oder mehreren Anwendungsprogrammen testen


„ Anwendungsprogramm im Menü Tools/Applications auswählen
„ Anwendungsprogramm mit Menü Project/Run Application oder Toolbar-
Button starten
„ Bei logischen Fehlern wie unter 3. im Fehlerfall fortfahren

44
EDIABAS — BEST BENUTZERHANDBUCH

5.3. BestView

5.3.1.Allgemeines
BestView ist ein Source Level Debugger zum Test von in BEST/2 geschriebenen
SGBDen. Diese Dateien müssen sowohl als Quellcode als auch als Objektdatei
vorliegen. Alternativ können auch Objekt- oder BEST/1 Dateien getestet werden,
jedoch ohne die Funktionalität des Quellcodedebuggings.
BestView ist für WIN32 (BESTVW32.EXE) und WIN16 (BESTVIEW.EXE) verfügbar.
Beide Varianten werden entweder aus BestBoard oder aus dem Explorer- bzw. dem
Datei-Manager heraus gestartet.
Mittels BestView können Sie Jobs Zeile für Zeile ablaufen lassen, Variablen während
des Ablaufs betrachten und ändern und die Ergebnisse des Jobs analysieren.
Im Menü "Help" finden Sie unter dem Punkt "Contents" eine Online Hilfe, die alle
Bedienungsvorgänge sowie die Aufrufparameter von BestView ausführlich erklärt.
In den folgenden Kapiteln wird die WIN32 Variante näher beschrieben.

45
EDIABAS — BEST BENUTZERHANDBUCH

5.3.2.Benutzeroberfläche
BestView für WIN32 verfügt über eine gegenüber der WIN16 Variante geänderten
Benutzeroberfläche mit neuen bzw. geänderten Arbeitsbereichen:

5.3.2.1. Toolbar

Project- Source- Statuszeile

BestView verfügt jetzt über eine Toolbar mit Buttons für folgende Funktionen:

• SGBD auswählen
• Job auswählen
• Job starten/fortsetzen
• Job um 1 Anweisung fortsetzen
• Breakpoint setzen/entfernen
• Variable/Parameter/Ergebnis-Dialog öffnen
• Watch-Variable-Dialog öffnen
• IFH-Trace-Datei anzeigen

46
EDIABAS — BEST BENUTZERHANDBUCH

• IFH-Trace-Datei löschen
• Text-Suchdialog öffnen
• Textsuche wiederholen
• Online-Hilfe

Die Toolbar ist als Docking-Fenster implementiert und kann auch außerhalb des
BestView-Arbeitsbereichs positioniert werden.

5.3.2.2. Statuszeile
In der Statuszeile zeigt BestView zusätzliche Informationen an. Auf der rechten Seite
wird auf eine eingeschaltete Simulation und/oder einen eingeschalteten IFH-Trace
hingewiesen.
Bei aktivem Source-, IFH- und Ergebnisfenster wird in der Statuszeile zudem die
aktuelle Position innerhalb des Fensters angezeigt (Zeile, Spalte).

5.3.2.3. Project-Fenster
Das Project-Fenster informiert über den Inhalt der aktuell geladenen
Beschreibungsdatei. Unter dem Ordner "Source Files" sind alle am
Übersetzungsvorgang beteiligten Quelldateien aufgelistet (B2V-Datei + Include-
Dateien). Im Ordner "Jobs" sind alle in der Beschreibungsdatei verfügbaren Jobs
aufgelistet (ohne virtuelle Jobs und ohne Jobs in Basisdateien).
Ein einfaches Anklicken eines Eintrags innerhalb des Project-Fensters bewirkt die
Anzeige der betreffenden Quelldatei bzw. der ersten Anweisung des entsprechenden
Jobs im Quellfenster.
Ein Doppel-Click auf einen Job innerhalb des Project-Fensters öffnet den Job-
Auswahldialog, sofern dieser Job nicht zu den zuletzt gestarteten Jobs gehört (siehe
Kap. Menü Run-Job). Gehört der ausgewählte Job zu den zuletzt gestarteten Jobs,
so bewirkt ein Doppel-Click den sofortigen Start des Jobs.
Das Project-Fenster kann als Mini-Fenster oder als Docking-Fenster (siehe Abb.)
benutzt werden. Als Mini-Fenster ist das Project-Fenster auch außerhalb des
BestView-Arbeitsbereichs positionierbar, der BestView-Arbeitsbereich bleibt hierbei
unverändert. Als Docking-Fenster kann das Project-Fenster an den
linken/rechten/oberen/unteren Teil des BestView-Arbeitsbereichs ange"dock"t
werden, wobei sich der BestView-Arbeitsbereich entsprechend verkleinert. Die
Umschaltung zwischen Mini- und Docking-Fenster-Darstellung ist durch Doppel-Click
auf den Rand des Project-Fensters möglich. Eine neue Docking-Ausrichtung ist
durch einfaches Ziehen des Project-Fenster an den gewünschten BestView-Rand
vorzunehmen.
Die Breite bzw. Höhe eines ge"dock"ten Project-Fenster orientiert sich an der Größe
des Project-Fensters in der Mini-Fenster-Darstellung. Für eine Größenänderung des

47
EDIABAS — BEST BENUTZERHANDBUCH

ge"dock"ten Project-Fensters muß hierzu in die Mini-Fenster-Darstellung gewechselt,


die Größe des Mini-Fensters geändert und das Project-Fenster wieder in die
Docking-Darstellung zurückgestellt werden.

5.3.2.4. Quellcode-Fenster
Im Quellcode-Fenster wird der Quellcode der SGBD angezeigt. In diesem Fenster
können Breakpoints (braun hinterlegt) gesetzt werden. In diesem Fenster ist die Zeile
die beim nächsten Programmschritt ausgeführt wird gelb hinterlegt.

5.3.2.5. Watch-Fenster
Im Watch-Fenster wird der Inhalt von Variablen angezeigt.

5.3.2.6. Results-Fenster
Im Results -Fenster wird der Inhalt der Job-Ergebnisse angezeigt.

5.3.2.7. IFH-Trace-Fenster
Im IFH-Trace-Fenster wird der Inhalt der IFH-Trace-Datei angezeigt. Nach jeder Job-
Ausführung bzw. nach jeder Job-Unterbrechung (z.B. nach Run-Step) wird das
Trace-Fenster automatisch aktualisiert.

5.3.3.Auswahl einer Beschreibungsdatei


Beschreibungsdateien werden mit dem Menü „File Open“ ausgewählt. Es können
sowohl BEST/2-Quelldateien ( mit der Endung .B2V oder .B2G ), BEST/1-
Quelldateien (mit der Endung .B1V oder .B1G) als auch ausführbare Objektdateien
(mit der Endung .PRG oder .GRP) geöffnet werden. Eine Beschreibungsdatei kann
auch mittels Drag&Drop geöffnet werden, hierzu ist die zu öffnende
Beschreibungsdatei vom Explorer in den Arbeitsbereich von BestView zu ziehen.
Nur wenn eine BEST/2-Quelldatei geöffnet wird, besteht die Möglichkeit zu
debuggen. Bei einer BEST/1-Quelldatei oder einer Objektdatei können die Jobs nur
ausgeführt werden.
Wird eine Quelldatei gewählt, so sucht BestView die entsprechende Objektdatei in
dem mit der Option „ECU-Directory“ ausgewählten Directory. Ist dies nicht gewünscht
kann man in der Option „ECU-Directory“ diese auf '.' setzen. Dann sucht BestView
die Objektdatei im Verzeichnis der Quelldatei. Eine Änderung des ECU-Directory ist
nur möglich, wenn in BestView keine Beschreibungsdatei geladen ist.
Wird eine Objektdatei ausgewählt, so verhält sich BestView wie das normale
EDIABAS Laufzeitsystem. Bei Auswahl einer Gruppe wird der Job IDENTIFIKATION

48
EDIABAS — BEST BENUTZERHANDBUCH

in der Gruppendatei automatisch ausgeführt, und erst dann der ausgesuchte Job in
der dadurch bestimmten Variantendatei. Bei Auswahl einer Quelldatei verhält sich
eine Gruppenbeschreibungsdatei wie eine Variantenbeschreibungsdatei, d.h. der Job
IDENTIFIKATION hat keine besondere Bedeutung und kann jederzeit untersucht
werden.
Nach dem Öffnen einer Beschreibungsdatei wird diese in einem Source-Fenster
angezeigt, bei Auswahl einer Objektdatei wird hingegen nur ein minimiertes Objekt-
Fenster angezeigt. Einer Beschreibungsdatei können mehrere BEST/2-Quelldateien
(Moduln) zugrundeliegen. Über das Menü „File View“ kann die Anzeige zwischen den
jeweiligen Moduln umgeschaltet werden.
BestView ermöglicht das automatische Öffnen eines Projekt-Fensters, welches alle
Jobs und BEST/2-Quelldateien (Moduln) der geladenen Beschreibungsdatei darstellt.
Das Projekt-Fenster kann als Mini-Fenster oder Docking-Fenster verwendet werden.
Die Mini-Fenster-Darstellung ermöglicht die Positionierung des Mini-Fensters in
jeden Bereich des Fensters-Desktops, der Arbeitsbereich von BestView bleibt
hiervon unbeeinflußt. Bei der Docking-Fenster-Darstellung wird der Arbeitsbereich
von BestView entsprechend der Docking-Ausrichtung (links, rechts, oben, unten)
automatisch verkleinert. Durch Doppel-Click auf den Projekt-Fenster-Rand ist eine
Umschaltung zwischen Mini- und Docking- Darstellung möglich. Über das Menü
„Window Projekt“ kann das Projekt-Fenster zu- oder abgeschaltet werden.
Die Bindung des Debuggers an eine Beschreibungsdatei bleibt solange erhalten, bis
diese mit dem Menü „File Close“ verworfen, das Beschreibungsdatei-Fenster
geschlossen oder eine Beschreibungsdatei neu ausgewählt wird.
Besteht eine Beschreibungsdatei aus mehreren Moduln (die mit File Open
geöffnetete B2V-Datei + Include-Dateien), so wird für die Include-Datei-Suche der
gleiche Suchalgorithmus angewendet wie beim BEST/2-Compiler:
Bei #include-Anweisungen mit absoluten oder relativen Pfadangaben sucht
BestView nur in den vorgegebenen Pfaden nach der jeweiligen Include-Datei.
Bei relativen Pfadangaben bezieht sich die Pfadangabe immer auf das
Verzeichnis der mit „File Open“ geöffneten B2V-Datei (Source-Verzeichnis).
Bei #include-Anweisungen ohne Pfadangaben sucht BestView zuerst im
Verzeichnis der mit „File Open“ geöffneten B2V-Datei nach der jeweiligen
Include-Datei. Über das Menü „Options Include-Path“ kann die Suche auf
zusätzliche Verzeichnisse ausgedehnt werden.

49
EDIABAS — BEST BENUTZERHANDBUCH

5.3.4.Aktualisieren einer Beschreibungsdatei


Die Änderung einer Beschreibungsdatei ohne zwischenzeitlichem Verlassen des
Debuggers erfordert die Aktualisierung der Beschreibungsdatei.
Die Aktualisierung der Beschreibungsdatei ist einfach durch die erneute Auswahl
der bereits geladenen Beschreibungsdatei mit dem Menü „File Open“
durchzuführen.
Als zu ladende Datei ist die bereits als Voreinstellung angebotene Datei zu wählen.

50
EDIABAS — BEST BENUTZERHANDBUCH

5.3.5.Selektieren eines Jobs

Die Auswahl eines Jobs geschieht mit dem Menü „Run Job“. Es werden alle
vorhanden Jobs der gewählten Beschreibungsdatei angezeigt. Es kann auch der
Job INITIALISIERUNG ausgewählt werden. In Gruppenbeschreibungsdateien ist
auch die Auswahl des Jobs IDENTIFIKATION möglich.
Wurde eine Gruppenbeschreibungsdatei als Objektdatei geöffnet, so betrifft der
eingegeben Jobname die Variantendatei und nicht die Gruppdendatei.
Der auszuführende Job kann über folgende Eingaben konfiguriert werden:
Job-Parameter
Die hier eingegebenen Daten werden später an den auszuführenden Job
übergeben. Bei der Einstellung „String“ werden die Job-Parameter 1:1 an den
Job übergeben. Bei der Einstellung „Data“ werden die Job-Parameter vor der
Job-Ausführung in einen entsprechenden binären Datenstrom konvertiert und
so an den Job übergeben.
Bei Eingabe von binären Daten ist folgende Syntax notwendig:

51
EDIABAS — BEST BENUTZERHANDBUCH

hex,hex,hex,...
Alternativ zur direkten Eingabe binärer Daten kann der Job auch mit binären
Daten versorgt werden, welche in einer eigenen Textdatei spezifiziert sind.
Durch Angabe von @<Textdateiname> wird bei Ausführung des Jobs die
Textdatei eingelesen, in einen entsprechenden binären Datenstrom konvertiert
und so an den Job übergeben. Die Textdatei muß hierzu folgendes Format
aufweisen:
hex,hex,hex,hex,hex,hex,hex,hex
hex,hex,...
Standardjob-Parameter
Die hier eingegebenen Daten werden später an die Standardjobs übergeben,
welche von BestView automatisch abgearbeitet werden.
Die Eingabemöglichkeiten sind identisch mit den Eingabemöglichkeiten der
eigentlichen Job-Parameter.
Job-Ergebnisse
Hier kann eine Auswahl der vom Job zu generierenden Ergebnisse getroffen
werden. Diese Funktionalität muß von der Beschreibungsdatei unterstützt
werden.
Der Job generiert alle Ergebnisse, wenn in diesem Eingabefeld nichts
eingegeben wird.
Initialisierung der Beschreibungsdatei
Diese Eingabe ermöglicht die automatische Durchführung des Jobs
INITIALISIERUNG unmittelbar vor der Ausführung des ausgewählten Jobs.
Nach Laden einer Beschreibungsdatei, Auftreten eines Fehlers oder bei
Abbruch eines Jobs ist die Durchführung des Jobs INITIALISIERUNG immer
notwendig.
BestView speichert die letzten 8 Job-Namen incl. aller Job-Konfigurationen. Über
die Drop-Down-Liste kann ein vorhergehender Job mit den entsprechenden Job-
Konfigurationen ausgewählt werden.
Der Job kann über „Go“direkt aus dieser Dialogbox heraus gestartet werden.

52
EDIABAS — BEST BENUTZERHANDBUCH

5.3.6.Setzen von Breakpoints


Breakpoint werden im Source-Fenster gesetzt. Dazu wird der Cursor im Source-
Fenster auf die Zeile gesetzt, in der der Breakpoint erscheinen soll.
Mit der Taste F9 wird der Breakpoint in dieser Zeile aktiviert. Die Zeile bekommt eine
andere Farbe. Mit einem weiteren Druck auf die Taste F9 wird der Breakpoint wieder
deaktiviert.
Das Setzen und Löschen von Breakpoints kann auch mit der Maus geschehen. Dazu
wird der Mauszeiger auf die betreffende Zeile gesetzt. Ein Doppelklick mit der linken
Maustaste aktiviert bzw. deaktiviert den Breakpoint in dieser Zeile.
Mit dem Menüpunkt „Debug Clear Breakpoints“ werden alle Breakpoints gelöscht.

53
EDIABAS — BEST BENUTZERHANDBUCH

5.3.7.Anzeigen und Verändern von Variablen

Variable, Ergebnisse und Parameter können mit dem Menüpunkt „Debug Show Data“
angezeigt werden.
Es erscheint eine Dialogbox, in der die Art der anzuzeigenden Daten ausgewählt
werden kann. Bei den Ergebnissen muß zusätzlich zum Namen noch der
gewünschte Ergebnissatz ausgewählt werden.
Alle Daten werden als Wert und als binäre Daten angezeigt. Das Anzeigeformat des
Wertes kann den Möglichkeiten entsprechend angepasst werden.
Ist der angezeigte Wert eine Variable so kann er aus der Dialogbox heraus durch
Klicken des Buttons Modify ebenso mit dem Menüpunkt „Debug Modify Variable“ in
einer eigenen Dialogbox verändert werden.

54
EDIABAS — BEST BENUTZERHANDBUCH

Eine Variable kann während des Debuggens in einem eigenen Fenster laufend
beobachtet werden, indem sie mit dem Menüpunkt „Debug Watch Variable“ in die
Watchliste aufgenommen wird. Dort kann sie auch wieder entfernt werden.
Variable und Parameter werden automatisch angezeigt, wenn die Maus im Source-
Fenster auf eine Variable oder einen Parameter zeigt. Data-Variable werden in
hexadezimaler Form ausgegeben, wobei die Anzeige auf max. 32 Byte beschränkt
ist.

5.3.8.Ausführen eines Jobs


Vor der Ausführung eines Jobs wird eine Initialisierung der Beschreibungsdatei
vorgenommen, wenn dies bei der Job-Auswahl vorgegeben wurde. Hierzu wird das
EDIABAS-Laufzeitsystem initialisiert und der Job INITIALISIERUNG durchlaufen.
Job können auf drei verschiedene Arten abgearbeitet werden:
Go
Der Job wir ausgeführt bis entweder ein Breakpoint, oder das Ende das Jobs
erreicht wurde.
Step
Die nächste Zeile im Job wird ausgeführt.
Continue to Cursor
Der Job wir bis zu der Zeile ausgeführt, auf der der Cursor steht. Ist vor der
markierten Zeile ein Breakpoint gesetzt, wird der Job nur bis zum Breakpoint
ausgeführt. ausgeführt bis entweder ein Breakpoint, oder das Ende das Jobs
erreicht wurde.
Zusätzlich besteht die Möglichkeit, durch Doppel-Click auf einen Job-Namen im
Projekt-Fenster den entsprechenden Job zu starten. Bei unbekannter Job-
Konfiguration wird stattdessen der Job-Auswahldialog angezeigt.
Die aktuelle Bearbeitungszeile wird farbig gekennzeichnet. Die gekennzeichnete
Zeile wurde zu diesem Zeitpunkt noch nicht ausgeführt.

55
EDIABAS — BEST BENUTZERHANDBUCH

5.3.9.Menüübersicht

5.3.9.1. Menü File


Open
Öffnen einer Beschreibungsdatei. Es können sowohl Quelldateien als auch
Objektdateien geöffnet werden. Nur wenn eine BEST/2-Quelldatei geöffnet wird,
besteht die Möglichkeit zu debuggen. Bei einer BEST/1-Quelldatei oder einer
Objektdatei können die Jobs nur ausgeführt werden.
Bei Auswahl einer Quelldatei wird die Objektdatei entsprechend des konfigurierten
ECU-Directory gesucht. Soll das ECU-Directory immer dem Quelldatei-Verzeichnis
entsprechen, so ist im Menü Options das Directory auf '.' zu setzen. Wird die Option
„Use EDIABAS Configuration“ verwendet, wird das ECU-Directory aus der EDIABAS
Konfigurationsdatei (EDIABAS.INI) verwendet.
Close
Schliessen der geladenen Beschreibungsdatei. Die Bindung des Debuggers mit der
geladenen Beschreibungsdatei wird aufgelöst.
Solange eine Beschreibungsdatei geladen ist, darf diese nicht in einem Editor
geändert werden. Das Öffnen einer neuen Beschreibungsdatei sowie das Verlassen
von BestView bewirken das automatische Schliessen der geladenen
Beschreibungsdatei.
View
Auswahl des anzuzeigenden Moduls.Falls eine Beschreibungsdatei aus mehreren
BEST/2-Quelldateien (Moduln) besteht, kann hierüber ein anderes Modul der
Beschreibungsdatei angezeigt werden.
Das anzuzeigenden Modul kann auch über das Projekt-Fenster ausgewählt werden.
Exit
Verlassen von BestView.

56
EDIABAS — BEST BENUTZERHANDBUCH

5.3.9.2. Menü Edit


Copy
Kopieren eines im aktiven Fenster selektierten Textes in die Zwischenablage.
Select All
Selektieren des gesamten Textes in aktiven Fensters.
Find
Suchen eines Textes im aktiven Fenster. Durch Aktivieren der Option „Match
Uppercase/Lowercase“ müssen Groß/Klein-Schreibung des gesuchten Textes exakt
übereinstimmen.
Die Textsuche beginnt an der aktuellen Cursorposition.
Find Next
Die letzte Textsuche wird an der aktuellen Cursorposition fortgesetzt.
Goto Line
Sprung an eine bestimmte Textzeile. Durch Eingabe der gewünschten Zeilennummer
kann auf die entsprechende Textzeile in der Quelldatei gesprungen werden.

57
EDIABAS — BEST BENUTZERHANDBUCH

5.3.9.3. Menü Run


Job
Auswahl des auszuführenden Jobs. Es können alle in der Beschreibungsdatei
vorhandenen Jobs angewählt werden. Zusätzlich können die Jobparameter und
gewünschten Ergebnisse angegeben werden. Mit dem Button „Go“ können die Jobs
sofort gestartet werden.
Go
Beginn oder Wiederaufnahme der Jobbearbeitung. Der Job wird ausgeführt bis
entweder ein Breakpoint oder das Ende des Jobs erreicht wird.
Continue to Cursor
Beginn oder Wiederaufnahme der Jobbearbeitung. Der Job wir bis zu der Zeile
ausgeführt, auf der der Cursor steht. Ist vor der markierten Zeile ein Breakpoint
gesetzt, wird der Job nur bis zum Breakpoint ausgeführt. ausgeführt bis entweder ein
Breakpoint, oder das Ende das Jobs erreicht wurde.
Step
Beginn oder Wiederaufnahme der Jobbearbeitung. Die nächste Codezeile wird
ausgeführt.
Restart
Neustart des ausgewählten Jobs. Ermöglicht den Neustart eines Jobs, falls dessen
Ausführung noch nicht beendet wurde.

58
EDIABAS — BEST BENUTZERHANDBUCH

5.3.9.4. Menü Debug


Toggle Breakpoint
Setzen oder Rücksetzen eines Breakpoints. Falls in der aktuellen Zeile kein
Breakpoint gesetzt ist, so wird jetzt ein Breakpoint gesetzt. Ist jedoch bereits ein
Breakpoint gesetzt so wird dieser gelöscht.
Das gleiche bewirkt ein Doppelklick mit der linken Maustaste auf die betreffende
Zeile.
Ist das Setzen eines Breakpoints nich möglich, so ertönt ein Signal.
Clear Breakpoints
Löschen aller Breakpoints.
Show Data
Anzeigen einer Variable, eines Parameters oder eines Ergebnisses. Es erscheint
eine Dialogbox, in der die Werte aller momentan gültigen Variablen, Parameter oder
Ergebnisse und ihre binäre Repräsentation anzeigt werden können.
Aus dieser Dialogbox können die Werte der Variablen auch verändert werden.
Modify Variable
Anzeigen und Verändern einer Variable. Alle momentan gültigen Variablen können
angezeigt und verändert werden. Es erscheint eine Dialogbox, in der der Wert der
Variablen und ihre binäre Repräsentation angzeigt wird.
Bei einfachen Variablen ( keine Arrays ) kann der Wert der Variablen in dezimaler-,
hexadezimaler oder ASCII-Darstellung erfolgen.
Der Wert der Variablen kann in allen drei Darstellung verändert werden. Durch
Drücken der Taste Update wird die binäre Darstellung aktualisiert.
Die Variable kann auch in der binären Darstellung verändert werden, jedoch ist auf
die Wahrung des Anzeigeformats zu achten.
Nach „OK“ oder „Return“ wird der geänderte Variableninhalt übernommen.
Nach „Cancel“ oder „ESC“ wird der Vorgang ohne Änderung der Variable beendet.
Watch Variable
Beobachten einer Variable. Die Werte ausgewählter Variablen werden in einem
eigenem Watch-Fenster angezeigt und laufend, d.h. nach jedem Step, aktualisiert.

59
EDIABAS — BEST BENUTZERHANDBUCH

5.3.9.5. Menü Options


ECU-Directory
Hier kann das Directory eingestellt werden, in dem der Debugger die Objektdateien
sucht. Wenn der Debugger dem Source-Directory folgen soll, so ist hier ein „.“
einzutragen.
Bei Aktivierung der Option „Use EDIABAS Configuration“ wird das über die
EDIABAS-Konfigurationsdatei EDIABAS.INI gewählte ECU-Directory verwendet.
Include Path
Hier können zusätzliche Verzeichnisse angegeben werden, in welchen BestView
nach Include-Dateien sucht. Mehrere Verzeichnisse sind mit „:“ zu trennen. Die
Suche beginnt immer im Verzeichnis der mit Menü „File Open“ geöffneten BEST/2-
Quelldatei. Anschließend wird der Include-Pfad von links nach rechts durchsucht.
Bei #include-Anweisungen mit absoluten oder relativen Pfaden wird der Include-Pfad
nicht berücksichtigt.
Device
Hier kann das Kommunikationsdevice fuer EDIABAS eingestellt werden.
ECU Simulation
Hier kann die Steuergeräte-Simulation ein- oder ausgeschaltet werden, die
EDIABAS-Konfigurationsdatei EDIABAS.INI bleibt unverändert. In der Statuszeile
wird auf eine aktivierte Steuergeräte-Simulation hingewiesen.
IFH Trace
Hier kann das IFH-Trace-Level eingegeben und der IFH-Trace entsprechend ein-
oder ausgeschaltet werden. Die EDIABAS-Konfigurationsdatei EDIABAS.INI bleibt
unverändert. In der Statuszeile wird auf einen aktivierten IFH-Trace hingewiesen.
Der IFH-Trace kann über das Menü „Window IFH Trace“ angezeigt werden.
Über den Button „Delete File“ kann die IFH-Trace-Datei gelöscht bzw. zurückgesetzt
werden.
Auto Job Selection
Falls diese Option aktiviert ist wird automatisch nach dem Öffnen einer
Beschreibungsdatei das Menü „Run Job“ ausgeführt.

60
EDIABAS — BEST BENUTZERHANDBUCH

5.3.9.6. Menü Window


Project
Projekt-Fenster anzeigen oder schließen.
Watch
Watch-Fenster anzeigen oder schließen.
IFH Trace
IFH-Trace-Fenster anzeigen oder schließen.
Cascade
Arrangieren der Fensters in Form eines Kartenstapels.
Tile Horizontally
Gleichmäßiges horzontales Teilen der Fensters mit Ausnahme der minimierten
Fenster.
Tile Vertically
Gleichmäßiges vertikales Teilen der Fensters mit Ausnahme der minimierten
Fenster.
Arrange Icons
Gleichmäßiges Aufreihen aller minimierter Fenster am unteren linken Rand.

61
EDIABAS — BEST BENUTZERHANDBUCH

5.3.9.7. Menü Help


Contents
Ruft den Hilfetext mit seiner Inhaltsseite auf.
Index
Ruft den Hilfetext mit seinem Suchdialog auf.
About
Anzeigen der Versionsinformation von BestView und EDIABAS.

62
EDIABAS — BEST BENUTZERHANDBUCH

A. GRENZEN UND BESCHRÄNKUNGEN

Steuergerätebeschreibungsdateien unterliegen nachfolgenden technischen


Grenzen und Beschränkungen:

• Max. Länge einer BEST/2-Quelldatei = 65535 Zeilen

• Max. Zeilenlänge einer BEST/2-Quelldatei = 5199 Zeichen

• Max. Länge eines BEST/2-Quelldateinamens (ohne Extension) = 8 Zeichen

• Max. Länge eines Basisdateinamens (ohne Extension) = 8 Zeichen

• Max. Länge eines Autor-Namens = 63 Zeichen


(weitere Zeichen werden ignoriert)

• Max. Länge eines BEST/2-Namens = 32 Zeichen


(weitere Zeichen werden ignoriert)

• Max. Länge eines Job-Namens im Job-Header = 63 Zeichen

• Max. Länge eines Argument-Namens im Job-Header = 63 Zeichen

• Max. Länge eines Ergebnis-Namens im Job-Header = 63 Zeichen

• Max. Länge eines Kommentars im Job-Header = 999 Zeichen

• Max. Anzahl von Ergebnissätzen eines Jobs = 65535

• Max. Anzahl von Ergebnissen in einem Ergebnissatz = 65535

• Max. Anzahl von String- und Array- Variablen innerhalb eines Jobs = 6

• Max. Größe eines char-Arrays = 1023 Zeichen

• Max. Größe eines (unsigned) int-Arrays = 1023 Bytes (511 Werte)

• Max. Größe eines (unsigned) long-Arrays = 1023 Bytes (255 Werte)

• Max. Länge eines String-Ergebnisses = 1023 Zeichen

• Max. Größe eines data-Ergebnisses = 1023 Bytes

• Max. Größe des globalen Datenspeichers = 1023 Zeichen

• Max. Länge einer globalen Datenspeicher-ID = 32 Zeichen

• Max. Anzahl von Passwörtern = 10

63
EDIABAS — BEST BENUTZERHANDBUCH

• Max. Länge eines Passwort-Labels = 10 Zeichen

• Max. Länge eines Passworts = 10 Zeichen

• Max. Anzahl geschachtelter Include-Dateien = 8

• Max. Länge eines Ergebnisnamens = 255

• Die Verschachtelungstiefe von Statements ist beschränkt.

64
EDIABAS — BEST BENUTZERHANDBUCH

B. LITERATURVERZEICHNIS

[1] EDIABAS: BEST/2 Funktionsreferenz

[2] EDIABAS: Steuergeräte-Simulator

[3] EDIABAS: BEST/1 - Sprache und Interpreter

[4] EDIABAS: Benutzerhandbuch

[5] EDIABAS: BEST/2 - Sprachbeschreibung

[6] EDIABAS: API Benutzerhandbuch

65
EDIABAS — BEST BENUTZERHANDBUCH

C. INDEX
revision 23

apiJobExt 35 send_and_receive 26
argument 21 set_answer_length 25
author 23 set_communication_pars 25
set_repeat_counter 24
Basisbeschreibungsdatei 9 Standardergebnisse 12
bcd2ascii 28 Standardjob 11
Best2/Win 37 Steuergerätegruppe 8
Steuergeräte-Simulator 19
comment 21, 23 Steuergerätevariante 8
strrevers 28
data 35
Debugger 26 tab_suche_index 31
defrslt 21 Tabelle 30
DONE 14 tabset 31
Tools 37
ecu 23 type 21
ENDE 15
Ergebnissätze 29 uses 9
exist 35
VARIANTE 15
Gruppenbeschreibungsdatei 8 Variantenbeschreibungsdatei 9
Variantenermittlung 15
Header 21
Windows 37
IDENTIFIKATION 15
INITIALISIERUNG 13
itor 34

Jobkonzept 8

Kommunikationskanal 23

Methoden 8

name 21

open_communication 23
origin 23

Realzahl 34

66