µCµC

Hochschule für Technik und

Wirtschaft Dresden (FH)

Versuch 4

CANoe als Erprobungs- und Entwicklungsumgebung

Praktikum:

Automobil-

elektronik

Inhaltsverzeichnis

1 VERSUCHSZIEL......................................................................................................................................................2

2 LITERATUR..............................................................................................................................................................2

3 VORBEREITUNG / GRUNDLAGEN.....................................................................................................................2

3.1 CAN-NETZWERK.....................................................................................................................................................2

3.1.1 CAN Knoten...................................................................................................................................................33.1.2 CAN Nachrichtenrahmen..............................................................................................................................43.1.3 Protocoll Data Unit.......................................................................................................................................53.1.4 Zusammenfassung CAN.................................................................................................................................6

3.2 EINFÜHRUNG IN CANOE............................................................................................................................................6

3.2.1 Struktur von CANoe.......................................................................................................................................63.2.2 Programmierung in CANoe mit CAPL..........................................................................................................7 CANoe Datenbank CANdb++...............................................................................................................................93.2.3 Panel Editor.................................................................................................................................................10

4 VORBEREITUNGSAUFGABEN..........................................................................................................................11

5 VERSUCHSDURCHFÜHRUNG..........................................................................................................................12

5.1 ANALYSE UND INBETRIEBNAHME CAN STAND............................................................................................................12

5.2 ERSTELLUNG VIRTUELLER KNOTEN IN CANOE............................................................................................................13

5.2.1 Neues Projekt erstellen................................................................................................................................145.2.2 Entwurf Datenbank......................................................................................................................................145.2.3 Entwurf der Bedienkonsole..........................................................................................................................145.2.4 Entwurf des Aktorknotens............................................................................................................................155.2.5 Interaktiver Generatorblock........................................................................................................................16

5.3 KOPPLUNG CANOE MIT VERSUCHSSTAND..................................................................................................................16

5.3.1 Anbindung der Praktikumsapplikation........................................................................................................165.3.2 Anbindung des Hochschulbussystems.........................................................................................................17

1

Prof. Dr.-Ing. M. HübnerM.Sc. S. Martin

1 Versuchsziel

Als praxisrelevante Anwendung bildet CANoe eine Schnittstelle zwischen simulativer

Entwicklung/ Erprobung und praktischer Umsetzung von CAN-Knoten. Der Versuch soll

neben einer ingenieurmäßigen Vorgehensweise bei modernen Projektentwicklungen auch

die grundlegenden Funktionsweisen sowie den Umgang mit der Entwicklungsumgebung

CANoe vermitteln.

2 Literatur

[1] Werner Zimmermann, Ralf Schmidgall: Bussysteme in der Fahrzeugtechnik -

Protokolle und Standards-. Vieweg Verlag, 2. aktualisierte Auflage.

[2] Christoph Marscholik, Peter Subke: Datenkommunikation im Automobil -Grundlagen,

Bussysteme, Protokolle und Anwendungen-. Hüthig Verlag Heidelberg, 1. Auflage

2007.

[3] Vector Informatik GmbH: CANoe Handbuch -CANoe Option .J1939- Version 7.0

Deutsch.

[4] Vector Informatik: Vector Informatik Homepage. https://www.vector-worldwide.com

[5] SAE International: Truck and Bus Control & Communications Network -Standards

Manual-. 2005 Edition.

Hinweis: Download der Demo-Version von CANoe 7.0 unter [4]\Download-Center

3 Vorbereitung / Grundlagen

3.1 CAN-Netzwerk

Die CAN Technologie wurde in der zweiten Hälfte der 80 er Jahre von BOSCH im Raum

Stuttgart entwickelt und 1991 bereits in ersten Fahrzeugen serienmäßig implementiert.

Durch den Einsatz von CAN sollte das Gewicht von Kabelbäumen (damals bereits ca. 100

kg) reduziert und die Installation vereinfacht werden. CAN arbeitet nach dem Multi-Master-

Prinzip und gegen den Ausfall einzelner Busteilnehmer resistent.

2

3.1.1 CAN Knoten

Im Fahrzeug repräsentiert jeder CAN-Knoten eine Funktion, wie beispielsweise die De-/

Aktivierung eines Frontscheinwerfers, des Schiebdaches oder der Darstellung von Mes-

swerten auf dem Armaturenbrett.

Als Übertragungsmedium zwischen den einzelnen Knoten kommt in der Regel eine verdril-

lte Zweidrahtkupferleitung zum Einsatz. Jedoch sind auch optische Übertragungsmedien

und Ausführungen als kostengünstige Eindrahtleitung in Anwendung.

Die einzelnen Teilnehmer (Knoten) sind parallel an den Bus gekoppelt und tauschen

Informationen über ein Differenzsignal aus (siehe Abbildung 1). So werden unliebsame

Gleichtaktstörungen vermieden beziehungsweise gefiltert.

Aus einem CAN-Knoten sind dazu die zwei Leitungen CAN_H und CAN_L herausgeführt

und mit dem Bus verbunden. Unterschiedliche Potenziale auf den Leitungen realisieren die

logischen Zustände Null (dominant) und Eins (rezessiv). Ein dominantes Signal wird durch

CAN_H mit 3,5 V und CAN_L mit 1,5 V erzeugt. Bei einem rezessiven Signal nehmen

beide Leitungen das Potenzial 2,5 V an. Als Signalkodierung kommt das NRZ Verfahren

zur Anwendung. Da hiermit eine Taktübertragung nur indirekt möglich ist, kann es bei

gleichartigen aufeinanderfolgenden Bits zu Synchronisierungsproblemen kommen. Daher

wird durch den Sender automatisch nach fünf gleichartigen Bits ein invertiertes Bit

eingefügt und durch den Empfänger später wieder herausgefiltert (Bitstuffing).

Abbildung 1: Signalpegel auf dem CAN-Bus

Die Anzahl der Busteilnehmer ist abhängig von den CAN-Treiberbausteinen sowie der

verwendeten Bitrate des CAN. Üblich sind jedoch 40 und mehr Teilnehmer. Der

Busabschlusswiderstand beträgt 120 Ω und vermeidet Reflexionen an den Busenden.

3

Abbildung 2: CAN-Knoten und Abschlusswiderstand

Zur Abschätzung der Buslänge kann folgende Faustformel verwendet werden [1, S. 33]:

BitratesMBitsmBuslänge /150...40 ⋅≤ (Gl. 3.1)

3.1.2 CAN Nachrichtenrahmen

Standard Rahmen CAN 2.0 A

Der Standard Rahmen (Frame) besteht im Wesentlichen aus einem 11 Bit Identifier, 7

Control Bits und einem 64 Bit (8 Byte) langen Datenteil. Mit diesem Frame können

theoretisch 112 (2048) Nachrichten übertragen werden.

Erweiterter Rahmen CAN 2.0 B

Da die Nachrichtenanzahl in modernen Kfz stetig steigt, reichte der bisherige Adressbe-

reich nicht mehr aus. Daher wurde in der zweiten CAN Generation der 11Bit Identifier auf

29 Bit erweitert. CAN 2.0 B ist abwärtskompatibel und erlaubt so die Interaktion auch mit

der älteren Generation. Mit dem erweiterten Identifier sind 292 (über 500 Mio.) Nachrichten

möglich. Anhand des IDE Bits wird unterschieden, ob es sich um eine Nachricht mit einem

erweiterten Identifier handelt.

4

Die Abkürzungen der Nachrichtenelemente sind im Folgenden dargestellt:

3.1.3 Protocoll Data Unit

Anhand des Identifiers lässt sich eine CAN Botschaft priorisieren. Das Arbitrierungsver-

fahren vermeidet Kollisionen von Nachrichten auf dem CAN Bus und gewährleistet die

Übertragung der jeweils höchstprioren Botschaft. Der Identifier gliedert sich dazu wiederum

in mehrere Teile, die Einfluss auf die Übertragungspriorität der Nachricht haben. Folgende

Bestandteile besitzt der Identifier:

Abkürzung Name Erläuterung

SOF Start of Frame Ist das Startbit der Nachricht

RTR Remote Transmission Request

Kennzeichnet das Telegramm als Datennachricht oder Datenanforderungsnachricht

IDE Identifer Extension Im Standard Frame ist dieses Bit dominant und zeigt, dass keine weiteren Identifier folgen

r1, r0 Diese beiden Bit sind reserviert für zukünftige Entwicklungen

DLC Data Length Code Diese 4 Bit enthalten Informationen über die Länge der gesendeten oder angeforderten Daten

Data Das Datenfeld enthält die Informationen

CRC Cyclic Reduncy Check Enthält den Fehlercode über alle vorausgegangen Stellen. Er dient nur zu Fehlererkennung

EOF End of Frame Kennzeichnet das Ende des Datentelegramms durch eine bewusste Codeverletzung. Das EOF Bitfeld ist immer rezessiv

SRR Substitute Remote Request Ersetzt das RTR-Bit eines Standard-Frame und ist immer rezessiv

5

3.1.4 Zusammenfassung CAN

• Kommunikation zwischen mehreren Kfz-Steuergeräten zum Austausch von Mess-,

Steuer- und Regelsignalen

• Bitstrom-orientiertes Übertragungsprotokoll mit bidirektionaler Zwei-Draht-Leitung als

Linien-Bus

• Bitraten bis 500 kbit/s (HighSpeed CAN) und 125 kbit/s (LowSpeed CAN)

• Buslänge ist abhängig von der Bitrate (Bitrate ↑ Buslänge ↓). Maximal 1 Mbit/s bis zu

40 m Buslänge und Stichleitungen (Busankopplung) < 30 cm.

• Max. 40 Busteilnehmer (durch Treiberbausteine begrenzt); theoretisch 256 pro

Busstrang

• Broadcast-System, in dem die Botschaften durch Identifier gekennzeichnet und priorisiert

sind. Identifier mit 11 und 29 bit sind in einem Netzwerk anwendbar.

• Netzweite Datenkonsistenz, da automatische Sendewiederholung im Fehlerfall

beziehungsweise Ausfall eines Gerätesautomatische Abschaltung defekter Knoten

3.2 Einführung in CANoe

CAN Open Environment ist eine Entwicklungs- und Testsoftware der Firma Vector Informa-

tik zum Entwurf von verteilten Systemen. CANoe ist nicht nur auf die Entwicklung CAN-

basierter Netzstrukturen ausgelegt. Auch andere Bussysteme, wie beispielsweise MOST

(Media Oriented Systems Transport) oder Flexray sind als separate Softwaremodule

erhältlich.

3.2.1 Struktur von CANoe

Grundsätzlich verwendet CANoe einige firmenspezifische Bezeichnungen. So werden

CAN-Nachrichten prinzipiell als Botschaften und zu übertragende Daten als Signale

bezeichnet. Weiterhin ist CANoe nicht als ein einzelnes Programm, sondern vielmehr als

ein aus vielen Einzeltools aufgebautes Softwarepaket zu betrachten. Folgende

Komponenten seien besonders hervorgehoben:

• das Hauptprogramm CANoe

• die Programmierumgebung-/software CAPL Browser

• die CANoe Datenbank CANdb++, zur Verwaltung der Nachrichten

• der Panel Editor zur Erstellung von Nutzeroberflächen

6

Prinzipiell bietet CANoe die Möglichkeit ein simulativ entworfenes System mit einem realen

System zu koppeln. So lassen sich in Entwicklung befindliche Komponenten eines

Gesamtsystems schon vor der eigentlichen Realisierung mit realen Systemnetzen

(beispielsweise einem CAN-Bus eines Kfz) koppeln und austesten.

Die Kopplung von CANoe mit einem realen Bus erfolgt, abhängig von der jeweiligen

Schnittstelle, über ein CANcaseXL (USB), einer CANCardXL (PCMCIA) oder einem

CANBoardXL (PCI-Steckkarte).

Abbildung 3: CANoe Hauptbildschirm mit vorhandenen Netzwerkknoten

3.2.2 Programmierung in CANoe mit CAPL

Hinter jeder Funktion (beispielsweise Licht an/aus) verbirgt sich eine Intelligenz. Diese ist

über einen Mikrocontroller mit Busanbindung (CAN-Knoten) realisiert. In CANoe sind diese

Knoten virtuell realisiert und werden mit der C-ähnlichen Programmiersprache CAPL

(Communication Access Programming Language) programmiert. CAPL ist eine

ereignisorientierte Programmiersprache, die auf unterschiedlichste Ereignisse (z.B.

Eintreffen einer Nachricht, Tastendruck) reagiert. Der CAPL Browser wird mit einem

Doppelklick auf einen erstellten Knoten geöffnet oder über den CAPL-Browser Button in

der Symbolleiste. Danach stehen im linken Bereich, in Form einer Baumstruktur, alle

möglichen Ereignisse, CAN Nachrichten und Funktionen bereit die durch den Knoten

realisiert sind. Auf der rechten Seite öffnet sich nach einem Mouseklick der dazugehörige

Inhalt. Im oberen Teil werden übersichtlich alle globalen Variablen des CAN-Knotens

dargestellt (siehe Abbildung 4).

7

CAPL-Browser Symbol

Umschalter: realer/simulierter Bus

Abbildung 4: CAPL-Browser

Ausgewählte CAPL Ereignisse:

• CAN Nachrichten: Mit dem Befehl „ on message ‚Nachrichtenname’ “ kann auf

entsprechende CAN Nachrichten reagiert werden.

Syntax: „on message <Botschaftsname> …“

• Timer: Zum zeitgesteuerten Ausführen von Funktionen. CAN Nachrichten können

zyklisch gesendet werden. Die Initialisierung geschieht über „ SetTimer

(Timername, Zeit in ms) “

Syntax: „on timer <Timername> …“

• Systemereignisse: Beschreibt Funktionen, die beim Start oder beim Beenden

von Programmen aufgerufen werden. Beim Systemstart werden so

beispielsweise Variablen initialisiert.

• Tastatureingaben: Primär ist CANoe für die Nutzung mit der Maus ausgelegt.

Dennoch lassen sich Funktionen per Tastendruck aufrufen.

Syntax: „on key <Taste> …“

• Umgebungs-/(Environment-)variablen: Zeigen den Zustand von grafischen

Bedien- und Anzeigeelementen an. Stellen eine Schnittstelle zwischen der

grafischen Oberfläche und dem Quellcode dar.

Syntax: „on envVar <Environmentvariable> …“

8

CANoe Datenbank CANdb++

In modernen Kraftfahrzeugen werden mehrere Tausend Botschaften durch den CAN-Bus

übertragen. Zur Wahrung der Übersichtlichkeit bei der Entwicklung, der Datenpflege sowie

zur Gewährleistung einer Reproduzierbarkeit werden Datenbanksysteme eingesetzt. Das

Tool CANdb++ verwaltet sämtliche Botschaften (Nachrichten) und Signale (Daten) einer

Datenbusanwendung.

Der CANdb++ Editor wird über „Datei\CANdb Editor öffnen“ gestartet. Mit diesem Tool

können CAN Botschaften erstellt, editiert und gelöscht werden (siehe Abbildung 5 und

Abbildung 6). Eine sinnvolle Planung der einzusetzenden Botschaften ist daher schon vor

Entwicklungsbeginn möglich und bei großen Systemen auch unabdingbar.

Abbildung 5: CANoe Datenbank db++ Abbildung 6: CAN-Botschaften Editor

Weiterhin sind alle Umgebungsvariablen in der Datenbank administriert. Die

Übersichtlichkeit dieser Variablen lässt sich weiterhin durch den Einsatz von so genannten

Präfixen erhöhen - Tabelle 1 zeigt eine Auswahl.

Präfix BedeutungEnv Aktor

Bar Füllstandsanzeige

Btn Schalter

Led Leuchte

Lgt Beleuchtung

Pbtn Taster

Ptr Zeigerinstrumente

Sb Schieberegler

Tabelle 1: Präfixe von Umgebungsvariablen

9

3.2.3 Panel Editor

Der Panel Editor erlaubt das Erstellen von grafischen Benutzeroberflächen und wird über

„Datei\Panel Editor öffnen“ aufgerufen. Es können, ähnlich der Windows-basierten Pro-

grammierung, Ein- und Ausgabeelemente verwendet werden. So stehen beispielsweise

Taster/Schalter, Zeigerinstrumente, Schieberegler sowie Ein- und Ausgabefelder zur

Verfügung (siehe Abbildung 7).

Abbildung 7: Bedienoberfläche Panel Editor

Abbildung 8: Fenster zum konfigurieren

eines Schalters

Zur Veranschaulichung einer Simulation können beispielsweise Schalter mit Bitmaps

kombiniert werden (siehe Abbildung 7 -mitte-). So sind realistische Bedien- sowie

realitätsnahe Anzeigeelemente darstellbar. Die Besonderheit beim Bitmap Einsatz besteht

darin, dass die verschiedenen Schaltzustände durch das Hintereinanderschalten von

Teilbitmaps realisiert sind (siehe Abbildung 8 und Abbildung 9).

Abbildung 9: Schalterbitmap

10

4 Vorbereitungsaufgaben

Überlegen Sie sich wie eine Blinkersteuerung zwischen zwei CAN Knoten softwaretech-nisch umsetzbar ist. Ein Knoten soll dabei die Funktion der Steuerung, ein anderer die des Aktors übernehmen.

• Skizzieren Sie die CAN-Knoten und überlegen Sie welche Signale bzw. Botschaften zur Kommunikation notwendig sind - planen Sie in Ihre Überlegungen auch Statusmeldungen ein. Wohin, von wem und wozu könnten Statusmeldungen gesendet werden.

• Entwerfen Sie einen Programmablaufplan (PAP) für die Funktion ‚Blinker’. Verwenden Sie dazu Normsymbole der DIN 66001.

Hinweis 1: Überlegen Sie welche Zustände der Blinker bzw. der Schalter des Blinkers haben kann (siehe dazu auch Tabelle 2).

Hinweis 2: Das Signal zum Blinken ist alle 500 ms alternierend zu senden.

11

5 Versuchsdurchführung

5.1 Analyse und Inbetriebnahme CAN Stand

Öffnen eines Projekts

Öffnen Sie das Projekt ‚Lenkbus.cfg’ im Ordner „…\Lenkbus Simulationsmodell 2010“ über „Datei\Konfiguration laden“. Nach erfolgreichem laden des Projekts öffnen Sie mit „Ansicht\ Simulationsaufbau“ ein Fenster in dem alle implementierten CAN-Knoten dargestellt sind (siehe Abbildung 3). Verschaffen Sie sich einen Überblick über die realisierten Funktionen und versuchen Sie diese auf dem realen CAN Stand zu identifizieren.

Datenbank

Im Anschluss öffnen Sie die CAN Datenbank ‚bus.dbc’ über einen Doppelklick auf den entsprechenden Namen unter der Rubrik Datenbasen im rechten Teil des Fensters „Simulationsaufbau“ (siehe Abbildung 3 -rechts-). Im nun geöffneten „Vector CAN db++ Editor“ finden Sie alle vorhandenen Steuergeräte (Netzknoten), Botschaften (Nachrichten) und die dazugehörigen Signale. Gehen Sie beispielhaft auf die CAN-Botschaft ‚Lighting_Command’ und öffnen Sie diese. Im nun geöffneten Fenster sind die enthaltenen Signale sowie die Eigenschaften der Botschaft aufgelistet. Im Reiter „Layout“ lässt sich die Struktur des CAN-Datenfeldes (64-Bit) erkennen.

Aufgabe:

Erfassen Sie die Signale in der Botschaft und halten Sie die Struktur fest. Wieviel Byte des Datenteils sind genutzt/nutzbar. Welche Anzahl an Bytes ist für das Datenfeld reserviert und ist dessen Größe sinnvoll gewählt?

Tracefenster

Stellen Sie sicher, dass eine Verbindung vom CANcaseXL zum Bussystem des Autobus CAN-Stands besteht. Schalten Sie am Drop-down Menü auf „Realer Bus“ und führen Sie das Projekt über „Start\Starten“ aus (F9). Öffnen Sie dazu das Tracefenster über „Ansicht\Trace“ und beobachten Sie die sich gerade auf dem realen CAN-Bus befindlichen Botschaften mit deren Eigenschaften (u.a. ID, Name, Dateninhalte).Am Ende der Betrachtung soll die Anwendung wieder gestoppt werden (Esc).

Byte 0:Byte 1Byte 2Byte 3Byte 4Byte 5Byte 6Byte 7

12

CAPL- Programmierumgebung

Der CAPL-Editor soll am Beispiel der Bedienkonsole des Busses dargestellt werden. Dazu wird im Fenster Simulationsaufbau (Ansicht) auf den Knoten „Cab_Controller_Node“ doppelgeklickt. Ein Fenster „CAPL-Browser - cab“ öffnet sich. Das Fenster ist wie in Abschnitt 3.2.2 erläutert aufgebaut. Unter ‚CAN Messages’ im linken Fenster sind alle Botschaften gelistet, auf die der Knoten reagiert. Im Unterpunkt ‚Variables’ sind unter anderem die vom Knoten gesendeten Nachrichten definiert (Die Botschaften müssen zuvor in der Datenbank erstellt worden sein).

Aufgabe:

• Erfassen und listen Sie die realisierten Funktionen der Bedienkonsole (Cab_Controller). Vergleichen Sie dazu die Environmentvariablen im CAPL-Browser. Listen Sie weiterhin die eingehenden/ausgehenden CAN-Botschaften auf.

• Öffnen Sie im Anschluss den Panel Editor über einen Linksklick auf die Fensterleiste des ‚Cab_Controllers’ und den Menüpunkt ‚Bearbeiten’. Im geöffneten Panel Editor klicken Sie rechts auf das Blinkersymbol und dann auf ‚Konfigurieren’. Unter Symbol sehen Sie die zugewiesene Umgebungsvariable ‚btnBlinker’. Listen Sie auch von anderen Schaltsymbolen die zugewiesenen Umgebungsvariablen in einer Tabelle auf.

• Schematisieren Sie den Zusammenhang: Schalter/Anzeige - Umgebungsvariable – Source Code im CAPL-Browser

5.2 Erstellung virtueller Knoten in CANoe

In Aufgabe 5.1 wurden Sie mit den Funktionsprinzipien von CANoe vertraut gemacht. Im Folgenden sollen CAN-Knoten selbst erstellt und getestet werden. Dazu soll ein Controller-Knoten und ein dazugehöriger Aktorknoten erstellt werden. Siehe Tabelle 2.

Steuerknoten CAN-Botschaften Aktorknoten

Zündschalter/ Simulation

Variable:btn_Cab_Ignitionbtn_Simulation_PC

Battery_Main_Switch_Information(ID: 0x18FE6631)

Signale: Ignition_Switch [0.0]Simulation_PC [7.0]

Zündung-Aktor

Variable:EnvLEDMainSwitchEnvSimulation_PC

BlinklichtschalterVariable:btnBlinker

Lighting_Command(ID: 0xCFE4131)

Signale: Left_Turn_Signal [1.6]Right_Turn_Signal [1.4]Small_Lights [0.0]

Blinker-AktorVariable:EnvLEDBlinker_Left_Right

LichtschalterVariable:btn_Cab_ParkLight

Licht-AktorVariable:EnvLEDSmallLights

TürschalterVariable:btnFrontDoor

Door_Command_Cab_Controller_Node(ID: 0x18FED731)

Signale: Door_Command_Front_Door [1.0]Door_Command_Rear_Door [1.2]

Tür-AktorVariable:EnvFrontDoorLimitSwitch

Tabelle 2: Übersicht der zu erstellenden Knoten und Nachrichten

13

5.2.1 Neues Projekt erstellen

Erstellen Sie ein neues CANoe Projekt über „Datei\Konfiguration neu…“ CAN500kBaud Template.tcn. Nach dem Betätigen der Schaltfläche OK erscheinen mehrere Fenster, schließen Sie alle bis auf die Fenster „Simulationsaufbau“ und „Trace“. Speichern Sie das Projekt über „Datei\Konfiguration speichern unter…“ mit dem Dateinamen „Prakt_Simulation_Studiengruppe“ in dem Verzeichnis “\Studiengruppe_Name“. Ändern Sie die Baudrate unter Konfiguration\Hardware Konfiguration…\Setup“ auf 250kBaud.

5.2.2 Entwurf Datenbank

In Abschnitt ist das Öffnen der Datenbank beschrieben. Gehen Sie entsprechend danach vor und erstellen Sie über „Datei\Datenbank erstellen…“ CANoeTemplate- eine Datenbank „prakt.dbc“.

Erstellen der Environmentvariablen

Erstellen Sie die in Tabelle 2 kursiv gekennzeichneten Umgebungsvariablen. Rechtsklicken Sie dazu auf die Untergruppe „Umgebungsvariablen\Neu…“. Als Attribute können zunächst bei Wertetyp „Integer“ und bei Zugriff „uneingeschränkt“ angenommen werden.

Erstellen der CAN-Signale

Botschaften enthalten Signale, die die eigentliche zu übertragende Information darstellen. Vor dem Erstellen von Botschaften müssen daher Signale erstellt werden, die dann ver-schiedenen Botschaften zuordenbar sind. Erstellen Sie über Rechtsklick auf ‚Signale’\Neu die in Tabelle 2 aufgeführten Signale.

Erstellen der CAN-Botschaften

Rechtsklicken Sie im geöffneten Datenbankfenster auf ‚Botschaften’\Neu und erstellen Sie die eingangs beschriebenen CAN-Botschaften. Fügen Sie die zuvor erstellten Signale hinzu.

5.2.3 Entwurf der Bedienkonsole

Die Bedienkonsole soll den Steuerknoten darstellen. Im Fenster „Simulationsaufbau“ rechtsklicken Sie auf ‚Knoten’. Wählen Sie „Füge Netzknoten ein“, um einen neuen CANoe-Knoten zu erstellen. Öffnen Sie nun eine neue CAPL-Datei über den Button „CAPL-Browser“ (siehe Abbildung 3) in der Symbolleiste und speichern Sie diese unter „Bedienkonsole.can“ in Ihrem Verzeichnis ab. Weisen Sie anschließend diese Datei dem erstellten Knoten über einen Rechtsklick auf „Konfiguration\Datei…“ zu - der Knoten nimmt dann den Dateinamen an.

Bedienpanel: Erstellen des Bedienpanels

In Abschnitt 3.2.3 ist das Öffnen des Panel Editors beschrieben. Gehen Sie dementsprech-end vor und speichern Sie das Panel unter „\Arbeitsverzeichnis\Panels\Bedienkonsole.cnp“ ab.

14

Implementierung der Schaltelemente

Um eine Aktion (z.B. Blinken) auszulösen stehen grafische Bedienelemente zur Verfügung. Die Implementierung und Nutzung dieser Elemente ist im Folgenden beschrieben:

Implementierung Blinker: Platzieren Sie einen Bitmap-Schalter auf dem geöffneten Panel und öffnen Sie dessen Konfigurationsmenü mit einem Rechtsklick auf den Schalter und „Konfigurieren“ (siehe Abbildung 8). Stellen Sie darin das Drop-down Menü von „Signal“ auf „EnvVar“ um und wählen Sie die Umgebungsvariable „btnBlinker“ aus - der Schalter ist nun mit der Umgebungsvariable verknüpft.

Zündung: Gehen Sie vor wie bei der Implementierung des Blinkers. Wählen Sie als Environmentvariable für den Zündschalter „btn_Cab_Ignition“.

Zusatz:

Implementierung Lichtschalter und Türschalter: Gehen Sie vor wie bei der Implementierung des Blinkers. Wählen Sie als Environmentvariable für den Lichtschalter „btn_Cab_ParkLight“ und für die Tür „btnFrontDoor“.

Programmierung des Knotens

Das Grundgerüst des CAN-Knotens ist realisiert - nun muss der Knoten mit einer Intel-ligenz versehen werden. Öffnen Sie dazu die CAPL-Datei „Bedienkonsole.can“ (Doppel-klick auf Knoten „Bedienkonsole“). Im geöffneten CAPL Browser gehen Sie auf „Environment“. Lösen Sie ein Ereignis aus sobald der Schalter „btnBlinker“ gedrückt wird (siehe Abschnitt 3.2.2).

Fügen Sie dazu den von Ihnen in Abschnitt 4 erstellten Programmcode ein. Nutzen Sie bei der Programmierung ‚Timer’, um ein zyklisches Senden zu realisieren.

Gehen Sie bei den Schaltern für die Zündung synonym vor.

5.2.4 Entwurf des Aktorknotens

Entsprechend Abschnitt 5.2.3 vorgehen. Als Dateiname wird „Aktorknoten.can“ verwendet.

Erstellen des Aktorpanels

Entsprechend Abschnitt 5.2.3 -Erstellen des Bedienpanels- vorgehen. Als Dateiname wird „Aktorknoten.cnp“ verwendet.

Implementierung der Schaltelemente

Implementieren Sie gemäß dem vorigen Abschnitt 5.2.3 -Implementierung der Schaltele-mente- zwei Bitmap Taster/Schalter. Belegen Sie diese Schalter mit den Environment-variablen aus Tabelle 2.

Zusatz:

Implementierung des Standlicht - und Türaktors.

15

Programmierung des Knotens

Öffnen Sie die CAPL-Datei „Aktorknoten.can“ (Doppelklick auf Knoten „Aktorknoten“). Im geöffneten CAPL Browser gehen Sie auf „CAN Messages“. Lösen Sie ein Ereignis bei Eintreffen der Botschaften „Lighting_Command“ und „Battery_Main_Switch_Information“ aus (siehe Abschnitt 3.2.2). Rechtsklicken Sie dazu auf „CAN Messages“\Neu. Fügen Sie für „<newMessage>“ den Botschaftsnamen ein.Entwerfen Sie einen Programmcode, der im Aktorknoten die aktivierte Zündung sowie das Blinken darstellt. Nutzen Sie die Methode ‚putValue(Environmentvariable, Wert) zur Wertzuweisung von Environmentvariablen.

Hinweis: Auf Signale einer Botschaft kann über this.<Signalname> zugegriffen werden.

5.2.5 Interaktiver Generatorblock

Der Generatorblock ist ein virtueller Knoten mit vorgefertigter Bedienoberfläche. Dieser erlaubt das Generieren und Senden von frei definierbaren Nachrichten. Die Funktion des Generatorblocks soll anhand des „Aktorknotens“ dargestellt werden.

Aufgabe:

• Fügen Sie einen „Interaktiven Generatorblock“ im Fenster „Simulationsaufbau“ über „Interaktive Generatoren\Füge interaktiven Generatorblock ein“. Ein Doppelklick auf den Knoten startet das Interface. Laden Sie folgende Nachrichten über einen Doppelklick auf das Feld unter Botschaftsname:

- Battery_Main_Switch_Information- Lighting_Command

• Senden Sie die Nachrichten und beobachten Sie das Panel “Aktorknoten”. Erzeugen Sie für das Signal „Lighting_Command.Left_Turn_Signal_Light“ einen Wechselschalter, der alle 500 ms sendet. Klicken Sie dazu in der Zeile des Signals auf den Definieren-Button und anschließend auf Wechselschalter.

5.3 Kopplung CANoe mit Versuchsstand

CANoe ermöglicht die Simulation eines virtuellen Systems ebenso wie die Kommunikation mit einem realen System. Zwischen simuliertem Bus und realem Bus kann über das Drop-down Menü in der Hauptleiste umgeschaltet werden (siehe Abbildung 3). Verbinden Sie die Simulation (CANoe Projekt) mit dem realen System, indem Sie den CAN-Stecker des Versuchsstandes mit dem CANcaseXL verbinden.

5.3.1 Anbindung der Praktikumsapplikation

Stellen Sie das Drop-down Menü (siehe Abbildung 3) auf „Realer Bus“ und starten Sie das Projekt über F9. Testen Sie, ob die simulierten Knoten mit dem realen System kom-munizieren können.

5.3.2 Anbindung des Hochschulbussystems

Starten Sie erneut das Projekt ‚Lenkbus.cfg’ im Ordner „…\Lenkbus Simulationsmodell 2010“. Stellen Sie das Drop-down Menü auf „Realer Bus“ und starten Sie das Projekt über F9. Zum Anhalten der Anwendung drücken sie „Stop“ oder Esc.

16