Grundlagen der Feldbustechnik - edu.elektronikschule.deamann/hambsch/can/can_script.pdf · Hersteller Mikrocontroller mit integriertem CAN-Modul an. Anwendungsschicht (Schicht 7)

Script für den Unterricht zum Thema CAN (Ha/EST)

1

1

Grundlagen der Feldbustechnik 1.Referenzmodell für die Kommunikation technischer Systeme Die International Standardization Organization (ISO) empfiehlt in ihrem ISO/OSI-7-Schichtenmodell eine weltweite Standardisierung für die geordnete Kommunikation technischer Systeme. Die komplexe Gesamtaufgabe der Gerätekommunikation wird dabei in überschaubare Teilbereiche (Schichten) aufgeteilt. In jeder Schicht existieren Objekte, welche die schichtenspezifischen Leistungen erbringen. Die Kommunikation zwischen den benachbarten Schichten wird durch Protokolle geregelt. Unter einem Protokoll versteht man einen Satz von Regeln für den Austausch von Informationen. Bei einfachen Kommunikationssystemen (z.B. Feldbusse) sind nicht alle Funktionalitäten (Schichten) des OSI-Modells erforderlich. So sind bei der Kommunikation von Automatisierungssystemen z.B. das Routing (Wegsuche durch ein komplexes Netz) , welches über die Schicht 4 abgewickelt wird, nicht erforderlich. Aus diesem Grunde sind für die Kommunikation technischer Systeme im Automatisierungsbereich die physikalische Schicht (Schicht 1), Datensicherungsschicht (Schicht 2) und Anwendungsschicht (Schicht 7) relevant.

Ebene Bezeichnung Funktion 7

Application Layer

Anwendungs-dienste

6

Presentation Layer

Datenanpassung

5

Session Layer

Kommunikations- steuerung

4

Transport Layer

Verbindungs- auf- und abbau

3

Network Layer

Netzverbindungen

2

Data Link Layer

Buszugriff Fehlererkennung

1

Physical Layer

Physik der Über-tragungsstrecke

Bild1-1: ISO/OSI-Modell

Für die Feldbustechnik relevant


2

2

Physikalische Schicht (Schicht 1) In dieser Schicht wird die eigentliche Signalübertragung festgelegt. Dabei geht es um Pegelwerte, logische Zuordnungen und Steckerbelegungen. Die Übertragung beim CAN kann über eine RS485-Schnittstelle (Differenzspannung) oder nach ISO 11898 erfolgen. Datensicherungsschicht (Schicht 2) Die zu übertragenden Informationen werden in dieser Schicht in ein geeignetes Frame gepackt und mit einem Fehlercode zur Fehlererkennung versehen. Auch wird in dieser Schicht der Medienzugriff überwacht. Beim CAN sind hierfür eine Vielzahl von Protokollbausteinen am Markt. Ebenso bieten viele Hersteller Mikrocontroller mit integriertem CAN-Modul an. Anwendungsschicht (Schicht 7) Der Anwender nutzt hier die bereitgestellten Dienste für kommunikationsbezogene Grundfunktionen, die viele Anwendungen benötigen (z.B. Aufbau und Abbau von Verbindungen). Für die Verwendung von CAN in der Automatisierungstechnik wurde die CAN Application Layer geschaffen (CAL). Hier werden mehrere Dienste definiert, die von einer Applikation verwendet werden können. 2.Wichtige Begriffe bzgl. der Vernetzung technischer Systeme Die Vernetzung von technischen Systemen erfordert nach dem ISO/OSI-Modell die Festlegung von

Topologoie (räumliche Anordnung), Pegel auf dem Übertragungsmedium (physikalische Signaldarstellung ), Arbitrierung (Zugriffsrechte) auf das Übertragungsmedium und Protokolle („Spielregeln“ der Kommunikation) .

2.1 Topologie (Netzwerkformen) Die räumliche Verbindung der technischen Systeme wird mit dem Begriff Topologie näher spezifiziert. Bedeutung haben in der Praxis die Stern,- Ring - und Bus- Topologie. Bild 1-2: Topologien bei der Vernetzung technischer Systeme

Stern

Bus

Ring


3

3

Sternstruktur: Der Zentralrechner ist Sternmittelpunkt. Jeder Teilnehmer ist über eine eigene Leitung angekoppelt. Die gesamte Kommunikation wird vom Zentralrechner gesteuert und über diesen abgewickelt. Fällt der Zentralrechner aus, so ist keine Kommunikation mehr möglich. Ringstruktur: Jede Station ist sowohl Sender als auch Empfänger. Die Daten umkreisen den Ring genau einmal und werden dabei von Station zu Station weitergereicht. Jede Sation prüft, ob die Daten an sie gerichtet sind. Ist dies der Fall, übernimmt sie die Daten in den internen Speicher. Die Sendeberechtigung wird meist durch einen umlaufenden Token geregelt (Tokenring). Busstruktur: Im Gegensatz zum Ring ist der Bus nicht geschlossen. Jede Station kann mit jeder anderen kommunizieren. Für den Buszugriff werden verschiedene Verfahren verwendet (s. 2.2) . Anmerkung: Beim CAN wird eine Bus-Struktur verwendet. Eine Nachricht kann somit alle Teilnehmer (abgesehen von der Signallaufzeit ) gleichzeitig erreichen. Eine wichtige Forderung für die Funktionsweise von CAN . 2.2 Arbitrierung Wenn mehrere Teilnehmer über ein physikalisches Medium kommunizieren, sind Regelungen für den Zugriff auf das Übertragungsmedium erforderlich. Dabei gilt der Grundsatz, daß nur ein Sender jedoch mehrere Empfänger gleichzeitig aktiv sein dürfen. In Konfliktsituationen regelt ein Zugriffsmechanismus (Arbitrierung ) den Zugang zum Bus. Die zur Anwendung kommenden Verfahren lassen sich in kontrolliert (deterministisch) und zufällig (stochastisch) einteilen. Bild 5: Zugriffsmechanismen im Überblick

Zugriffsverfahren

Zufällige Verfahren Kontrollierte Verfahren

Trägerabtastung mit Kollisionserkennung (CSMA/CD)

Trägerabtastung mit Kollisionserkennung und Botschaftspriorisierung (CSMA/CA)

zentral dezentral

Token-Bus Token-Ring

Token Passing

Logischer Ring

Verfahren wird bei CAN verwendet


4

4

Bei dem kontrollierten Verfahren unterscheidet man darüber hinaus, ob die Vergabe des Buszugriffsrechts durch eine Zentrale ( Master,Synchronisationseinheit ) oder dezentral durch Absprache zwischen den Teilnehmern z.B. durch die Weitergabe eines Tokens von Teilnehmer zu Teilnehmer erfolgt. Bei dem Verfahren mit zufälligem Buszugriff können die Teilnehmer den Bus belegen, sobald dieser frei ist. Jeder Teilnehmer ist bezüglich des Buszugriffs gleichberechtigt (Multi-Master-System). Da dies jedoch durch mehrere Teilnehmer gleichzeitig erfolgen kann und somit eine Kollision ausgelöst würde, sind je nach Verfahren Regelungen zur Verhinderung oder Auflösung dieser Situation erforderlich. Beim zufälligen Buszugriff wird eine ereignis- gesteuerte Übertragung möglich. Hierbei wird eine Übertragung nur dann eingeleitet, wenn dies erforderlich ist. Anmerkung: Beim CAN wird das CSMA/CA-Verfahren ( Carrier-Sense Multiple Access/Collision Avoidance ) verwendet. Im Konfliktfall (mehrere Zugriffe zur gleichen Zeit) wird der Zugriff durch eine bitweise Arbitrierung (vgl. L 06) aufgelöst. 1-1: Weshalb ist der CAN für eine Ringtopologie nicht geeignet ? Versuchen Sie Ihre Erklärung mit Hilfe der Arbitrierung. 1-2: Bei der Übertragung von Daten kann es zu Fehlern kommen. In welcher Instanz von OSI wird dies überwacht und ggf. behoben? 1-3: Erklären Sie die Busarbitrierung nach dem Token-Passing- Verfahren.


5

5

Kommunikation bei CAN Der Einsatzbereich und die Leistungsfähigkeit von vernetzten technischen Systemen ist vom Arbitrierungsverfahren und von der Arbeitsweise des Schicht 2-Protokolls abhängig. Die Kommunikation der Teilnehmer kann dabei über teilnehmer- oder nachrichtenorientierte Protokolle abgewickelt werden. Teilnehmerorientierte Protokolle Hierbei verschlüsselt der Sender in seinem Datenstrom die Zieladresse und Quelladresse. Die Nachricht ist somit exklusiv für einen ausgewählten Teilnehmer bestimmt. Nachrichtenorientierte Protokolle Ein berechtigter Teilnehmer sendet seine Nachricht an alle am Bus angeschlossenen Teilnehmer (Broadcasting). Die Empfänger besitzen für die Selektion der Nachricht eine Filtereinrichtung. Die Nachrichten werden mit Nachrichtennummern (Identifier) ausgestattet. Eine Zieladresse der Nachricht ist hierbei nicht erforderlich. Die Kommunikation beim CAN basiert auf einem nachrichtenorientierten Protokoll. Hierbei werden folgende Nachrichtenobjekte verwendet. • Über ein Datenanforderungstelegramm (Remote Frame) können Busteilnehmer das

Senden einer bestimmten Nachricht anfordern. • Mit einem Datentelegramm (Data Frame ) erfolgt die Datenübertragung von einem

Sender zu einem oder mehreren Empfängern. • Mit einem Fehlerdiagramm (Error Frame) erfolgt die Signalisierung eines von einem

Busteilnehmer erkannten Fehlers. Beim CAN sind alle Teilnehmer gleichberechtigt (Multimaster). Der direkte Austausch von Nachrichten zwischen allen Teilnehmern ist somit möglich. Übungsaufgabe 2-1: Versuchen Sie die Interaktion des CAN mit der menschlichen Kommunikation zu vergleichen und arbeiten Sie die Ähnlichkeiten heraus. Übungsaufgabe 2-2: Weshalb benötigen nachrichtenorientierte Protokolle keine Teilnehmeradressierung ?


6

6

2 Descriptorbytes

Aufbau einer CAN-Nachricht (Data- und RemoteFrame) Eine CAN-Nachricht setzt sich aus dem

Identifier (Nachrichtenkennung) , einem RTR-Bit (Remote Transmission Request ) , dem DLC (Data Length Code) und max. 8 Datenbytes

zusammen. Der Identifier besteht beim Standard-CAN (CAN-2.0 A) aus 11 Bits. Damit können bis zu 2048 verschiedene Identifier in einem System vergeben werden. Die niedrigste Nummer trägt dabei die höchste Priorität (vgl. Lektion 4). Der Extended -CAN (CAN-Spezifikation 2.0 B]) besitzt einen 29-bit-Identifier. Er kann somit über 536 Millionen Nachrichten unterscheiden. Bild 3-1: Aufbau einer CAN-Nachricht bei einem 11 bit Identifier Die Anzahl der Datenbytes wird im DLC ( 4-Bit Feld ) dual verschlüsselt. Von den theoretisch möglichen 16 Datenbytes werden jedoch max. 8 per Definition zugelassen. Ist das RTR-Bit gesetzt, so wird die Nachricht mit dem eingestellten Identifier im System angefragt. Besitzt ein Teilnehmer diese Nachricht, stellt er diese im Broadcasting allen Teilnehmern zur Verfügung. Dem Applikationsprogrammierer stehen heute viele Protokollbausteine zu Verfügung. Allen gemeinsam ist die Abbildung von CAN-Nachrichten in die entsprechenden Register. So werden beim Standard-CAN der Identifier ,das RTR-Bit und die Anzahl der Datenbytes (DLC) i.d.R. in zwei Bytes (Descriptorbytes) codiert.

Identifier (11 bit) RTR DLC Datenbytes (max. 8 )


7

Beispiel 3-1: Die Nachricht mit dem Identifier 123 dez und den Datenbytes 11h ,22h,33h und 44h soll auf den Bus geschaltet werden. Bestimmen Sie die beiden Descriptorbytes ? Lösungsweg: 1. Schritt: 123 dez in eine hexadezimale Zahl umwandeln.

Ergebnis: 07B hex

2. Schritt: den hexadezimalen Wert des Identifiers in ein 11-bit Feld eintragen. Ergebnis:

0Fh 64h

000 0 111 1 011 0 0 1 0 0 11 22 .. 33 44 0 7 B

3. Schritt: Bildung der 2 Descriptorb 3-1: Bestimmen Sie den Identifier, das RTR-Wert 88h eingetragen ist. 3-2: Für die CAN-Nachricht mit dem IdentifiDescriptorbytes zu bestimmen. 3-3: Die CAN-Nachricht mit dem IdenBestimmen Sie die erforderlichen Descri

Descriptorbytes

DLC

RTR

ytes

Bit und den DLC, wenn in beid

er 666h, RTR=0 und 6 Daten

tifier 007 soll im System ptorbytes für den Standard-CAN

s
Datenbyte
7

en Decriptorbytes der

bytes sind die beiden

angefordert werden. .


8

8

Beim CAN wird das CSMA/CA-Verfahren ( Carrier-Sense Multiple Access/Collision Avoidance) verwendet. Im Konfliktfall (mehrere Zugriffe zur gleichen Zeit) wird der Zugriff durch eine bitweise Arbitrierung aufgelöst.

Bild 4-1 Prinzip der bitweisen Arbitrierung Grundlage der bitweisen Arbitrierung ist die Unterscheidung von zwei physikalischen Buspegeln, einem dominaten (überstimmenden ) und einem rezessiven (nachgebenden) Pegel. Typische Schaltungen hierfür sind die Wired - And - Verknüpfungen (Bild 4-1). Ist der Bus frei, befindet er sich im rezessiven Zustand. Schaltet sich ein Teilnehmer auf den Bus, signalisiert er dies durch Aufschalten eines dominanten Bits. Während der Arbitrierungsphase wird das höchste Bit des Identifieres als erstes gesendet . Dabei vergleicht jeder sendende Teilnehmer den von ihm aufgeschalteten Buspegel mit dem tatsächlich auf dem Bus vorhandenen Pegel. Jeder Teilnehmer der ein rezessives Bit gesendet hat und ein dominantes beobachtet, stellt sein Arbitrierungsversuch sofort ein und wird zum Empfänger der gerade von einem anderen Teilnehmer gesendeten Nachricht. Jede Nachricht wird eindeutig einem Identifier zugeordnet . Da eine logische Null mit einem dominanten Buspegel abgebildet wird, bleibt am Ende eines Arbitrierungsprozesses der Teilnehmer mit dem niedrigsten Identifierwert und somit mit der höchsten Priorität übrig. Dies ist eine wichtige Voraussetzung für Systeme mit Echtzeitforderung. Stellt man in der Applikation sicher, daß ein Teilnehmer mit hochpriorer Nachricht nicht ständig den Bus belegt, so ist es trotz des zufälligen Buszugriffes möglich, die maximale Latenzzeit (Wartezeit bis Bus frei ist) einer Nachricht zu bestimmen. Somit ist die allgemeine Bedingung für Echtzeitfähigkeit erfüllt.

1

2

3

Tln 1 verliert Tln 3 verliert

rezessiv

dominant

Bus

Tln 1 Tln 2 Tln 3

Busleitung

Kollisionsbehebung (Arbitrierung) bei CAN


9

9

4-1: Drei CAN-Teilnehmer gehen mit einem Data Frame gleichzeitig auf den Bus. Skizzieren Sie die bitweise Arbitrierung und ermitteln Sie so den „Gewinner“ ( Teilnehmer mit der höchsten Priorität ). Teilnehmer 1:

Identifier 444h Teilnehmer 2: Identifier 222h Teilnehmer 3: Identifier 111h Buspegel: Ergebnis: 4-2: Das Data Frame und das Remote Frame mit dem Identifier 311h werden zeitgleich auf den Bus gelegt. Wer ist der „Gewinner“?


10

10

Das Kommunikationsgebilde CAN überträgt die Nachrichten über eine Bus -Struktur. Damit empfängt jeder Busknoten die Nachrichtentelegramme. Aber nicht alle Nachrichten sind für den jeweiligen Knoten interessant. Eine vorhandene Nachrichtenfilterung leitet nur gewünschte Nachrichten in den Empfangspuffer weiter. Die am Markt befindlichen Bausteine werden je nach Filterrealisierung und Speichergröße in FullCAN- und BasicCAN -Controller eingeteilt. Die FullCAN- Controller besitzen einen Auftragsspeicher . In diesen können die gewünschten Identifier eingetragen und so der Host von zeitaufwendigen Vergleichsroutinen entlastet werden. Bei den BasicCAN-Bausteinen wird die empfangene Nachricht über eine Filtermaske auf eine zuvor eingestellte Gruppenzugehörigkeit vorselektiert. Gehört die empfangene Nachricht zu dieser Gruppe, erfolgt eine Übernahme in den Empfangspuffer. Bild 5-1: Empfangslogik beim SJA 1000 (BasicCAN) bei der Filterung mit ACR und AMR Der CAN-Controller SJA1000 von Philips besitzt im Basic_CAN-Mode zur Nachrichten-filterung das Acceptance Code Register ( ACR ) und das Acceptance Mask Register ( AMR).

Descriptorbyte 1 Descriptorbyte 2

RTR DLC

x x x

I d e n t i f i e r

. . . . . . . . . = =

>=1

&

>=1

E

Ist E=1 erfolgt die Nachrichtenübernahme in den Empfangspuffer, bei E=0 wird die Übernahme verweigert.

. . . . . . . . . Oder -Verknüpfung

AMR.7-AMR.0

ACR.7-ACR.0

Äquivalenz- Verknüpfung

CAN

Nachrichtenfilterung


11

11

Die Arbeitsweise der Filterung wird in Bild 5-1 gezeigt. Der Controller führt zwischen den 8 höchstwertigen Identifier-Bits, sowie dem ACR und dem AMR einen logischen Vergleich durch. Die verbleibenden 3 niederwertigen Bits des Identifiers werden bei dieser Filterung nicht berücksichtigt. Ist der folgende logische Vergleich erfüllt, so erfolgt eine Übernahme der Nachricht in den Empfangspuffer. [( ID.10....ID.3)=(ACR.7...ACR.0)] OR (AMR.7 ... AMR.0)= 1111 1111b Das AMR kennzeichnet, welche der zugehörigen Bits des ACR wichtig oder unbedeutend sind. Steht an der entsprechenden Bitposition eine „0“ so ist diese Stelle des ACR relevant für die Filterung. Die Einstellung der Filterung wird während der Initialisierungsphase (Reset-Zustand) durchgeführt. Beispiel 5-1: Ein CAN-Knoten (mit dem SJA1000) soll für die Nachrichten mit dem Identifier 220h -227h geöffnet werden. Bestimmen Sie das ACR und das AMR Lösungsschritte: 1. Schritt : Bitdarstellung des Identifiers Die mit x gekennzeichneten Bits werden bei der Filterung nicht beachtet. Dadurch entsteht eine Gruppe von 8 Nachrichten die per Hardware nicht weiter unterschieden werden können. Die weitere Selektion muß per Software erfolgen. 2. Schritt: ACR und AMR-Bestimmung 5-1: Welche Nachrichten können von einem CAN-Knoten empfangen werden, wenn das ACR mit 3Fh und das AMR mit 1Eh beschrieben wird ? 5-2: Welche Werte müssen das AMR und ACR annehmen, wenn die Nachrichten mit den Nummern 300h-3FFh von dem SJA1000 akzeptiert werden sollen ?

Descriptorbyte 1 Descriptorbyte 2

ACR=44h

AMR = 00h (alle Bits des ACR sollen relevant sein)

RTR DLC

0 1 0 0 0 1 0 0

0 0 0 0 0 0 0 0

x x x

I d e n t i f i e r


12

12

Einstellung der Baudrate Bei allen technischen Kommunikationssystemen müssen die Teilnehmer auf gleiche Übertragungsgeschwindigkeit (Baudrate) eingestellt sein. Beim CAN stehen die Baudrate und die Ausdehnung des gesamten Bussystems in einem funktionalen Zusammenhang (Bild 6-1). Bild 6-1: Zusammenhang zwischen max. Buslänge und Datenrate Wird die Ausdehnug des CAN auf 40m begrenzt, so ist eine maximale Übertragungsrate von 1Mbit/s zulässig. Soll die Ausdehnung vergrößert werden , ist die Baudrate zu reduzieren. Ursache ist die in einer Bitzeit zu erkennenden Pegelüberschreibung (dominant/rezessiv), welche für das CSMA/CA -Verfahren (vgl. Lektion 4) wichtig ist. Die CAN-Controller besitzen für die Einstellung der Baudrate und des Abtastzeitpunktes zuständige Register. Der CAN-Controller SJA1000 besitzt hierfür das Bus- Timing -Register 0 (BTR0) und das Bus Timing Register 1 (BTR1). Ist der Baustein im Reset-Mode , können diese beiden Register beschrieben und gelesen werden. Die Einstellung muß immer in der Initialisierungsphase erfolgen.

7 6 5 4 3 2 1 0 SJW.1 SJW.0 BRP.5 BRP.4 BRP.3 BRP.2 BRP.1 BRP.0

7 6 5 4 3 2 1 0 SAM TSEG2.2 TSEG2.1 TSEG2.0 TSEG1.3 TSEG1.2 TSEG1.1 TSEG1.0

Die mathematischen Zusammenhänge zur Einstellung der Baudrate und Bitabtastung werden in Bild 6-2 erklärt.

BTR0

BTR1

| | | | | | | 0 10 50 100 500 1000 5000 10000 Leitungslänge/m

1000_ 500_ 200_ 100_ 50 _ 10_ 5 _

Datenrate in kBits/s


13

13

Bild 6-2: Zusammenhang zwischen Baudrate und Abtastzeitpunkt Zusammenhänge : (1) tscl ist der vom Baudratengenerator eingestellte Systemclock. tbit = n* tscl (2) tbit = tscl+tTSEG1+tTSEG2 (3) tscl = 2*tclk *(32* BRP.5+ 16*BRP.4+8*BRP.3+4*BRP.2+2*BRP1+1*BRP.0 +1) ( tclk ist die Periodendauer des 82C200 Oszillators) (4) tTSEG1 = tscl *(8*TSEG1.3 + 4*TSEG1.2 + 2*TSEG1.1+1*TSEG1.0+1) (5) tTSEG2 = tscl *(4*TSEG2.2 + 2*TSEG2.1 + 1*TSEG2.0 +1) Beispiel 6-1: Ein CAN-Teilnehmer verfügt über den SJA1000 und wird während der Initialisierungphase mit dem BTR0 und BTR1 auf Baudrate und Abtastpunkt eingestellt. Bestimmen Sie die Baudrate und den Abtastzeitpunkt, wenn in BTR= 83h und in BTR1 = FAh eingeschrieben wird. Die Oszillatorfrequenz des SJA1000 beträgt 16 MHz.

1 0 0 0 0 0 1 1 SJW.1 SJW.0 BRP.5 BRP.4 BRP.3 BRP.2 BRP.1 BRP.0 1 1 1 1 1 0 1 0 SAM TSEG2.2 TSEG2.1 TSEG2.0 TSEG1.3 TSEG1.2 TSEG1.1 TSEG1.0

t one bit period= tbit

BTR0

BTR1

tscl tTSEG1 tTSEG2

Sample Point

Synchronisationsbereich


14

Lösung: tscl = 2* (1/16MHZ)*(2+1+1) nach Formel (3) = 0,5µs tTSEG1 = 0,5µs * (8+0+0+2+0+1) nach Formel (4) = 5,5 µs tTSEG2 = 0,5µs (4+2+1+1) nach Formel (5) = 4,0µs tges = tscl+ tTSEG1+tTSEG2 nach Formal (2) = 0,5µs + 5,5µs + 4,0µs = 10µs Die Bitzeit beträgt somit 10µs. Daraus ergibt sich eine Baudrate von 100kBit/s Tabelle 6-1: Ve 6-1: Bestimmen Sie dBTR0 mit 81h ugetaktet.

Baudrate (kBits/s)

BTR0 BTR1

10 9F FF 20 8F FF 50 87 FA 100 83 FA 125 83 D8 250 81 D8 500 80 D8 1000 80 23

14

rschiede Baudraten und BTR0/BTR1-Werte bei 16 MHz

ie Baudrate und den Abtastzeitpunkt, wenn bei der Initialisierung das nd das BTR1 mit D8h beschrieben wird. Der Baustein wird mit 16 MHz


15

15

CAN-Controller SJA1000 (BasicCAN-Mode)

Der Aufbau eines CAN-Knotens ist mit den am Markt verfügbaren Controllern leicht zu realisieren. Als Beispiel dient hier der SJA 1000, der Nachfolger des bekannten 82C200 von Philips. Der Baustein kann im BasicCAN-Mode (BasicCAN) und im PeliCAN-Mode (FullCAN) betrieben werden. Für den Programmierer stehen im BasicCAN-Mode 32 Register zur Verfügung, über welche der Protokoll-Baustein den vollständigen Datenverkehr abwickelt. In dieser Betriebsart können vom Programmierer ein Sendepuffer und zwei Empfangspuffer mit je 10 Bytes verwendet werden. Das Host-System muß also ausreichend Ressourcen besitzen, um bei hoher Buslast genügend schnell auszulesen. Um dies zu unterstützen, besitzen alle Protokollbausteine einen Interruptausgang, der für den Host verwendet werden kann.

0 Control (CR) 1 COMMAND (CMR) 2 STATUS (SR) 3 INTERRUPT (IR) 4 ACCEPTANCE CODE (ACR) 5 ACCEPTANCE MASK (AMR) 6 BUS TIMING 0 (BTR0) 7 BUS TIMING 1 (BTR1) 8 OUTPUT CONTROL (OCR) 9 TEST 10 IDENTIFIER 11 RTR-Bit, DLC 12 Byte1 13 Byte2 14 Byte3 15 Byte4 16 Byte5 17 Byte6 18 Byte7 19 Byte8 20 IDENTIFIER IDENTIFIER 21 RTR-Bit, DLC RTR-Bit , DLC 22

Byte1

22

Byte1

23 Byte2 23 Byte2 24 Byte3 24 Byte3 25 Byte4 25 Byte4 26 Byte5 26 Byte5 27 Byte6 27 Byte6 28 Byte7 28 Byte7 29 Byte8 29 Byte8 Bild 7-3: Die Register des SJA 1000 im BasicCAN-Mode

Adresse

control segment

transmit buffer

descriptor

data field

receive buffer 0 receive buffer 1

descriptor

data field


16

16

Die Steuerung des CAN-Controllers erfolgt dabei über das control segment. Hier kann durch den Zugriff auf einzelne Bits die CAN-Kommunikation abgewickelt werden.

Register Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0 CR

Test-Mode Synch reserved Overrun Interrupt Enable

Error Interrupt Enable

Transmit Interrupt Enable

Receive Interrupt Enable

Reset Request

CMR

reserved reserved reserved Goto Sleep

Clear Overrun Status

Release Receive Buffer

Abort Transmit

Transmit Request

SR Bus Status

Error Status

Transmit Status

Receive Status

Transmit Complete Status

Transmit Buffer Access

Data Overrun

Receive Buffer Status

IR reserved reserved reserved Wake-Up Interrupt

Overrun Interrupt

Error Interrupt

Transmit Interrupt

Receive Interrupt

ACR AC.7 AC.6 AC.5 AC.4 AC.3 AC.2 AC.1 AC.0 AMR AM.7 AM.6 AM.5 AM.4 AM.3 AM.2 AM.1 AM.0 BTR0 SJW.1 SJW.0 BRP.5 BRP.4 BRP.3 BRP.2 BRP.1 BRP.0 BTR1 SAM TSEG2.2 TSEG2.1 TSEG2.0 TSEG1.3 TSEG1.2 TSEG1.1 TSEG1.0 OCR OCTP1 OCTN1 OCPOL1 OCTP0 OCTN0 OCPOL0 OCMODE1 OCMODE0

Tabelle 7-1: Bitbedeutung der Register des Control Segment beim 82C200 Beispiel 7-1 In einem PC befindet sich eine passive BasicCAN-Karte mit dem SJA 1000 CAN-Controller. Die hier verwendete Low-Level -Registerprogrammierung setzt direkt auf die Hardware auf und erfolgt bei dieser Karte nach folgendem Verfahren: Basisadresse : -> Einstellung der Registeradresse des SJA1000 (0..31) Basisadresse +1: -> Zugriff auf das unter der Basisadresse eingestellte Register Bei diesem Verfahren wird der 32 Byte- Registerraum des SJA1000 auf nur zwei IO-Kanäle abgebildet. Die Ressourcen der PC-IO-Kanäle werden dadurch geschont. Die Basisadresse ist über Konfigurationssoftware oder Jumper einstellbar und ist vom Anwender in einen freien IO-Bereich des PC zu legen. In der Programmiersprache C könnte der Zugriff auf die Register dann so aussehen: 7-1: Entwerfen Sie:

die Funktion void canreg_write (int reg_adresse, int reg_wert), welche durch call by value eine Registeradresse und einen Wert übergibt sowie die Funktion int canreg_read (int reg_adresse), welche ebenfalls durch call by value eine Registeradresse übergibt und den Inhalt des Registers als Funktionswert zurückliefert. Die Basisadresse ist auf 200h eingestellt.

outportb(Basisadresse,Register ) // SJA1000Adresse wird eingestellt reg_wert = inportb(Basisadresse+ 1); // Registerwert lesen outportb(Basisadresse+1,reg_wert); // Registerwert schreiben


17

17

Applikationsbeispiel In einem Feldbussystem werden unterschiedliche Geräte mit Sensor-und Aktoreigenschaften vernetzt. Wird ein PC mit einer entsprechenden Interface-Karte ausgestattet, kann er für die Prozess-Steuerung oder für die Visualisierung eingesetzt werden. Am Markt sind dafür geeignete Karten vorhanden, inklusiv geeigneter Treiber. Dadurch hat der Anwender die Möglichkeit, in den verschiedenen Ebenen seine Anwendung zu implementieren. CAN-Knoten 1 ( PC-Karte ) Eine passive PC -Einschubkarte , auf dem sich der SJA1000 von Philips befindet, wird zur Prozessvisualisierung verwendet und im BasicCAN-Mode programmiert. Bild 1: CAN- Applikationsbeispiel Die PC-CAN-Karte wird zur Visualisierung der Prozessdaten in der Sprache C programmiert. Der Low-Level -Zugriff auf die Register des SJA 1000 erfolgt dabei wie in Lektion 07 gezeigt. Eine schnelle Adaptierung auf andere PC-Karten ist durch den Austausch der hardwarenahen Funktionen canreg_read() und canreg_write () leicht möglich .

CAN

PC

Prozess

CAN-Knoten 2

CAN-Knoten 3 CAN-Knoten 1

?

80C535 SJA1000


18

18

/**************************************************/ /* Low-Level-Funktionen für die PC-Karte */ /* Funktionen can_init, canreg_write und canreg_read */ /* hambsch/EST */ /* Prog_Name: can_pc.h */ /**************************************************/ #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <bios.h> #include <dos.h> //Definitionsblock für die CAN-PC-Karte (hier: Fa. Bauer) #define CAN_ADD 0x200 // Auswahl des Registers 0 - 31 des SJA 1000 #define CAN_DAT 0x201 // Daten für das ausgewählte Register #define CR 0 // Steuerregister #define CMR 1 // Kommandoregister #define SR 2 // Statusregister #define IR 3 // Interruptregister #define ACR 4 // ID Filter #define AMR 5 // Filtermaske #define BTR0 6 // Bus Timing Register 0 #define BTR1 7 // Bus Timing Register 1 #define OCR 8 // Ausgang Steuerregister #define TBUF_DSCR1 10 // Senderegister ID3 - ID10 #define TBUF_DSCR2 11 // Senderegister ID0 - ID2, RTR, DLC #define TBYTE_1 12 // 1. Senderegister Daten #define TBYTE_2 13 // 2. Senderegister Daten #define TBYTE_3 14 // 3. Senderegister Daten #define TBYTE_4 15 // 4. Senderegister Daten #define TBYTE_5 16 // 5. Senderegister Daten #define TBYTE_6 17 // 6. Senderegister Daten #define TBYTE_7 18 // 7. Senderegister Daten #define TBYTE_8 19 // 8. Senderegister Daten #define RBUF_DSCR1 20 // Empfangsregister ID3 - ID10 #define RBUF_DSCR2 21 // Empfangsregister ID0 - ID2, RTR, DLC #define RBYTE_1 22 // 1. Empfangsregister Daten #define RBYTE_2 23 // 2. Empfangsregister Daten #define RBYTE_3 24 // 3. Empfangsregister Daten #define RBYTE_4 25 // 4. Empfangsregister Daten #define RBYTE_5 26 // 5. Empfangsregister Daten #define RBYTE_6 27 // 6. Empfangsregister Daten #define RBYTE_7 28 // 7. Empfangsregister Daten #define RBYTE_8 29 // 8. Empfangsregister Daten


19

/********** Register -Schreib-Funktion *****************/ void canreg_write (int reg_adresse,int reg_wert) { outportb(CAN_ADD,reg_adresse); outportb(CAN_DAT,reg_wert); } /********** Register-Lese -Funktion *******************/ int canreg_read (int reg_adresse) { outportb(CAN_ADD,reg_adresse); return(inportb(CAN_DAT)); } /********* CAN-Controller initialisieren ***************/ void can_init () { do { canreg_write(CR,0x01); //Reset -Bit setzen } while(canreg_read(CR)&0x01!=0x01); canreg_write(ACR,0x00); canreg_write(AMR,0xFF); //Filterung canreg_write(BTR0,0x83); canreg_write(BTR1,0xD8); //Baudrate und Abtastung canreg_write(OCR,0xAA); //Ausgangstreiber do { canreg_write(CR,0x00); //Reset--Bit löschen } while((canreg_read(CR)&0x01)!=0x00); } /**************************************************/ Auf diesen „hardwarenahen“ Funktionen setzen nun die „ CANnahecanmessage_write(&transmit) und canmessage_read(&receive ) auf. Berder Anwender keinerlei Kenntnisse mehr über die Hardware. Allein das Aufbau einer CAN-Nachricht reicht aus, um diese Funktionen anzuwendenNachricht abzusetzen, werden die Komponenten der Strukturvariable tranmessage mit Werten belegt und anschließend die Funktion canmessage_wmit call by reference aufgerufen (Beispiel 8-1).

SJA1000

can_init

canreg_write canreg_write

can_pc.h

can.h

Knoten 1 Anwendung für PC

CA
82C250
19

n“ Funktionen eits hier benötigt Wissen über den . Um eine CAN-smit vom Type rite(&transmit)

N


20

20

Knoten 1 Anwendung für den PC

SJA1000

can_init

canreg_write

can_pc.h

can.h

canmessage_write canmessage_read

canreg_read

CAN

/************************************************/ /* Funktionen canmessage_write und canmessage_read */ /* erstellt hambsch/est */ /* setzt auf dem entsprechenden Hardwaretreiber auf */ /* z.B. can_pc.h */ /* Name : can.h */ /***********************************************/ struct message { unsigned int id; unsigned char rtr; unsigned char dlc; unsigned char byte[8]; }; struct message transmit,receive; /*---------------------------------------------------*/ void canmessage_write (struct message *ptransmit) { unsigned char id_1,id_2,id_3; unsigned char id_1_hilf,id_2_hilf,id_3_hilf; unsigned char trdscr_wert; unsigned char i; id_3=((*ptransmit).id)&0x0f; id_2=(((*ptransmit).id)/16)&0x0f; id_1=(((*ptransmit).id)/256)&0x0f; id_1_hilf=id_1*32; id_2_hilf=id_2*2; id_3_hilf=id_3/8; trdscr_wert=(id_1_hilf)|(id_2_hilf)|(id_3_hilf); canreg_write(TBUF_DSCR1,trdscr_wert); id_3=((*ptransmit).dlc)&0x0f; id_2=((*ptransmit).rtr)*16; id_1=(((*ptransmit).id)&0x0f)*32; trdscr_wert =(id_3)|(id_2)|(id_1); canreg_write(TBUF_DSCR2,trdscr_wert); for (i=0;i<=7;i++) { canreg_write (TBYTE_1+i,(*ptransmit).byte[i]); } canreg_write (CMR,0x01); /*Sendung starten*/ do { /*warten bis Sendung fertig*/ } while ((canreg_read(SR))&0x08==0); }

Beispiel 8-1: Die Nachricht 123h mit den Datenbytes 10h,20h,30 und 40h soll übertragen werden. //vorbereiten der CAN-Nachricht transmit.id =0x123; transmit.rtr =0; transmit.dlc = 4; transmit.byte[0] =0x10; transmit.byte[1] =0x20; transmit.byte[2] =0x30; transmit.byte[3] =0x40; // Funktionsaufruf zum Senden canmessage_write (&transmit);

Knoten 1 Anwendung für PC

82C250


21

21

CAN-Knoten 2 ( µC80535 mit SJA1000 Controller)

/*------------------------------------------------------------------------------------------*/ unsigned char canmessage_read (struct message *preceive) { unsigned char id_1,id_2,id_3; unsigned char i; if ((canreg_read(SR))&0x1!=0) { id_1=canreg_read(RBUF_DSCR1); id_2=canreg_read(RBUF_DSCR2); (*preceive).id=(id_1/32)*256+((id_1/2)&0x0f)*16+((id_1)&0x01)*8+(id_2/32); (*preceive).rtr=(id_2/16)&0x01; (*preceive).dlc=(id_2)&0x0f; for(i=0;i<=7;i++) { (*preceive).byte[i]=canreg_read(RBYTE_1+i); } canreg_write(CMR,0x04); /*ReceiveBuffer wieder freigeben*/ return (1); //Funktionswert=1 -> Empfang vorhanden } else { return (0); // Funktionswert =0 -> kein Empfang } } /*------------------------------------------------------------------------------------*/

canmessage_read


22

22

Die Erfassung der Prozessdaten und die Steuerung des SJA1000 erfolgt in diesem Beispiel mit dem 80C535 (8051Derivat). Der µC80535 besitzt einen externen Daten- und CodeSpeicher ( Harvard-Architektur). Im vorliegenden Fall werden die 32 Register des SJA1000 physikalisch am Anfang des XDATA-Bereichs (externer Datenspeicher) abgelegt. Die Programmierung erfolgt in der Sprache C (Keil C51). Auch hier werden wie in der PC-Programmierung Low-Level-Funktionen verwendet, welche schnell auf einen anderen Anwendungsfall übertragen werden können.

/***********************************************************/ /* Low-Level-Funktionen für die 80535 -Umgebung */ /* Funktionen canreg_write, canreg_read und can_init */ /* erstellt hambsch/est */ /* Name:can_535.h */ /***********************************************************/ #define OFFSET 0000 /*falls CANbaustein irgendwo im XADTA liegt*/ #define CR 0+OFFSET #define CMR 1+OFFSET #define SR 2+OFFSET #define IR 3+OFFSET #define ACR 4+OFFSET #define AMR 5+OFFSET #define BTR0 6+OFFSET #define BTR1 7+OFFSET #define OCR 8+OFFSET #define TRDSCR1 10+OFFSET #define TRDSCR2 11+OFFSET #define TRBYTE 12+OFFSET #define REDSCR1 20+OFFSET #define REDSCR2 21+OFFSET #define REBYTE 22+OFFSET /*--------------------------------------------------------------------------------------*/ void canreg_write (unsigned char xdata *adresse,unsigned char wert) { *adresse=wert; } /*-------------------------------------------------------------------------------------*/ unsigned char canreg_read(unsigned char xdata *adresse) { return(*adresse); } /*------------------------------------------------------------------------------------*/ void can_init(void) { do { canreg_write(CR,0x01; // CANbaustein in den RESET / } while ((canreg_read(CR) &0x01)==0); canreg_write(ACR,0xff); // Akzeptanzeinstellung canreg_write (AMR,0xff); canreg_write(BTR0,0x83); //Baudrate-Einstellung canreg_write(BTR1,0xFA); canreg_write(OCR,0xEA); //Ausgangstreiber setzen do { canreg_write(CR,0x00); // Reset aufheben } while ((canreg_read (CR) &0x01)==01); } /*-------------------------------------------------------------*/


23

23

/***************************************************/ /* Funktionen canmessage_write und canmessage_read */ /* erstellt hambsch/est */ /* setzt auf dem entsprechenden Hardwaretreiber auf */ /* z.B. can_535.h */ /* Name : can.h */ /***************************************************/ struct message { unsigned int id; unsigned char rtr; unsigned char dlc; unsigned char byte[8]; }; struct message transmit,receive; /*---------------------------------------------------------------------------------------------------------------------------------*/ void canmessage_write(struct message *ptransmit) { unsigned char id_1,id_2,id_3; unsigned char id_1_hilf,id_2_hilf,id_3_hilf; unsigned char trdscr_wert; unsigned char i; id_3=((*ptransmit).id)&0x0f; id_2=(((*ptransmit).id)/16)&0x0f; id_1=(((*ptransmit).id)/256)&0x0f; id_1_hilf=id_1*32; id_2_hilf=id_2*2; id_3_hilf=id_3/8; trdscr_wert=(id_1_hilf)|(id_2_hilf)|(id_3_hilf); canreg_write(TRDSCR1,trdscr_wert); id_3=((*ptransmit).dlc)&0x0f; id_2=((*ptransmit).rtr)*16; id_1=(((*ptransmit).id)&0x0f)*32; trdscr_wert =(id_3)|(id_2)|(id_1); canreg_write(TRDSCR2,trdscr_wert); for (i=0;i<=7;i++) { canreg_write (TRBYTE+i,(*ptransmit).byte[i]); } canreg_write (CMR,0x01); /*Sendung auslösen*/ do { } while ((canreg_read(SR)&0x08)==0); /*warten bis Sendung fertig*/ } /*----------------------------------------------------------------------------------------------------------------------------------*/ unsigned char canmessage_read(struct message *preceive) { unsigned char id_1,id_2,id_3; unsigned char i; if ((canreg_read(SR))&0x1!=0) { id_1=canreg_read(REDSCR1); id_2=canreg_read(REDSCR2); (*preceive).id=(id_1/32)*256+((id_1/2)&0x0f)*16+((id_1)&0x01)*8+(id_2/32); (*preceive).rtr=(id_2/16)&0x01; (*preceive).dlc=(id_2)&0x0f; for(i=0;i<=7;i++) { (*preceive).byte[i]=canreg_read(REBYTE+i); } canreg_write(CMR,0x04); /*ReceiveBuffer wieder freigeben*/ return(1); } //Funktionswert=1-> Empfang stattgefunden (wichtig für Polling) else { return (0); //Funktionswert =0 -> kein Empfang stattgefunden (wichtig für Polling) } } /*--------------------------------------------------------------------------------------------------------------*/


24

8-1: Bestimmen Sie die Baudrate, welche bei der PC-Karte von can_init () ein 8-2: Wie erfolgt bei der PC-Programmierung die Verwendung von canmessacanmessage_write ()? 8-3: Bestimmen Sie den Identifier, das RTR-Bit und den DLC für folgenden P canreg_write(TBUF_DSCR1,0x06); canreg_write(TBUF_DSCR2,0xB0); canreg_write(CMR,0x01);

Die hier vorgestellten C-Funktionen erlauben der Anwendung mit wenig Aufwand eine CAN -Nachricht abzusetzen. Beispiel: void main() { can_init(); // Baudrate und Akzeptanzfilterung transmit.id=0x007; transmit.rtr=0; transmit.dlc=2; transmit.byte[0]=0; transmit.byte[1]=1; //Aufruf zum Senden canmessage_write(&transmit); } Das Programm sendet die Nachricht mit dem Identifier 007 , RTR=0 sowie die Datenbytes 00 und 01 auf den Bus.

Welche BedeutBefehl?

can_init

SJA1000

Anwendung mit dem µC

canreg_write

can_535.h

can.h

canmessage_write canmessage_read

canreg_read

CAN

can_init

82C250

24

gestellt wird!

ge_read () und

rogrammausschnitt:

ung hat dieser

Documents

Grundlagen der Feldbustechnik - edu.elektronikschule.deamann/hambsch/can/can_script.pdf · Hersteller Mikrocontroller mit integriertem CAN-Modul an. Anwendungsschicht (Schicht 7)