Grundlagen der Feldbustechnik

Transkript

1 Script für den Unterricht zum Thema CAN (Ha/EST) 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 Anwendungsdienste 6 Presentation Layer Datenanpassung 5 4 Session Layer Transport Layer Kommunikationssteuerung Verbindungsauf- und abbau Für die Feldbustechnik relevant 3 Network Layer Netzverbindungen 2 Data Link Layer Buszugriff Fehlererkennung 1 Physical Layer Physik der Übertragungsstrecke Bild1-1: ISO/OSI-Modell 1

2 Script für den Unterricht zum Thema CAN (Ha/EST) 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 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. Bus Stern Ring Bild 1-2: Topologien bei der Vernetzung technischer Systeme 2

3 Script für den Unterricht zum Thema CAN (Ha/EST) 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. Zugriffsverfahren Kontrollierte Verfahren Zufällige Verfahren zentral dezentral Trägerabtastung mit Kollisionserkennung (CSMA/CD) Trägerabtastung mit Kollisionserkennung und Botschaftspriorisierung (CSMA/CA) Token-Bus Token-Ring Verfahren wird bei CAN verwendet Token Passing Logischer Ring Bild 5: Zugriffsmechanismen im Überblick 3

4 Script für den Unterricht zum Thema CAN (Ha/EST) 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 ereignisgesteuerte Ü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. 4

5 Script für den Unterricht zum Thema CAN (Ha/EST) 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? 5

6 Script für den Unterricht zum Thema CAN (Ha/EST) 6 Aufbau einer CAN-Nachricht (Data- und RemoteFrame) Eine CAN-Nachricht setzt sich aus dem zusammen. Identifier (Nachrichtenkennung), einem RTR-Bit (Remote Transmission Request ), dem DLC (Data Length Code) und max. 8 Datenbytes 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. Identifier (11 bit) RTR DLC Datenbytes (max. 8 ) 2 Descriptorbytes 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. 6

7 Script für den Unterricht zum Thema CAN (Ha/EST) 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: Descriptorbytes 0Fh 64h B RTR DLC Datenbytes 3. Schritt: Bildung der 2 Descriptorbytes 3-1: Bestimmen Sie den Identifier, das RTR-Bit und den DLC, wenn in beiden Decriptorbytes der Wert 88h eingetragen ist. 3-2: Für die CAN-Nachricht mit dem Identifier 666h, RTR=0 und 6 Datenbytes sind die beiden Descriptorbytes zu bestimmen. 3-3: Die CAN-Nachricht mit dem Identifier 007 soll im System angefordert werden. Bestimmen Sie die erforderlichen Descriptorbytes für den Standard-CAN. 7

8 Script für den Unterricht zum Thema CAN (Ha/EST) 8 Kollisionsbehebung (Arbitrierung) bei CAN 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. Bus rezessiv 1 dominant Busleitung 2 3 Tln 1 Tln 2 Tln 3 Bild 4-1 Prinzip der bitweisen Arbitrierung Tln 1 verliert Tln 3 verliert 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. 8

9 Script für den Unterricht zum Thema CAN (Ha/EST) 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? 9

10 Script für den Unterricht zum Thema CAN (Ha/EST) 10 Nachrichtenfilterung 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. CAN I d e n t i f i e r RTR DLC x x x Descriptorbyte 1 Descriptorbyte 2 ACR.7-ACR.0 = = Äquivalenz- Verknüpfung AMR.7-AMR.0 >= Oder -Verknüpfung >=1 & E Ist E=1 erfolgt die Nachrichtenübernahme in den Empfangspuffer, bei E=0 wird die Übernahme verweigert. 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 Nachrichtenfilterung das Acceptance Code Register ( ACR ) und das Acceptance Mask Register ( AMR). 10

11 Script für den Unterricht zum Thema CAN (Ha/EST) 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)= b 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 I d e n t i f i e r RTR DLC x x x Descriptorbyte 1 Descriptorbyte 2 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 ACR=44h AMR = 00h (alle Bits des ACR sollen relevant sein) 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? 11

12 Script für den Unterricht zum Thema CAN (Ha/EST) 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). 1000_ Datenrate in kbits/s 500_ 200_ 100_ 50 _ 10_ 5 _ Leitungslänge/m 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. BTR SJW.1 SJW.0 BRP.5 BRP.4 BRP.3 BRP.2 BRP.1 BRP.0 BTR 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. 12

13 Script für den Unterricht zum Thema CAN (Ha/EST) 13 Synchronisationsbereich t one bit period= tbit tscl ttseg1 ttseg2 Sample Point 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*TSEG *TSEG *TSEG1.1+1*TSEG1.0+1) (5) ttseg2 = tscl *(4*TSEG *TSEG *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. BTR0 BTR SJW.1 SJW.0 BRP.5 BRP.4 BRP.3 BRP.2 BRP.1 BRP SAM TSEG2.2 TSEG2.1 TSEG2.0 TSEG1.3 TSEG1.2 TSEG1.1 TSEG1.0 13

14 Script für den Unterricht zum Thema CAN (Ha/EST) 14 Lösung: tscl = 2* (1/16MHZ)*(2+1+1) nach Formel (3) = 0,5µs ttseg1 = 0,5µs * ( ) nach Formel (4) = 5,5 µs ttseg2 = 0,5µs ( ) 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 Baudrate BTR0 BTR1 (kbits/s) 10 9F FF 20 8F FF FA FA D D D Tabelle 6-1: Verschiede Baudraten und BTR0/BTR1-Werte bei 16 MHz 6-1: Bestimmen Sie die Baudrate und den Abtastzeitpunkt, wenn bei der Initialisierung das BTR0 mit 81h und das BTR1 mit D8h beschrieben wird. Der Baustein wird mit 16 MHz getaktet. 14

15 Script für den Unterricht zum Thema CAN (Ha/EST) 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. Adresse 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 control segment 10 IDENTIFIER 11 RTR-Bit, DLC 12 Byte1 13 Byte2 14 Byte3 15 Byte4 16 Byte5 17 Byte6 18 Byte7 19 Byte8 descriptor data field transmit buffer receive buffer 0 receive buffer 1 20 IDENTIFIER descriptor IDENTIFIER 21 RTR-Bit, DLC RTR-Bit, DLC 22 Byte1 22 Byte1 23 Byte2 23 Byte2 24 Byte3 24 Byte3 data field 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 15

16 Script für den Unterricht zum Thema CAN (Ha/EST) 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 SR Bus Status Error Status Transmit Status Receive Status IR reserved reserved reserved Wake- Up Interrupt Clear Overrun Status Transmit Complete Status Overrun Interrupt Release Receive Buffer Transmit Buffer Access Error Interrupt Abort Transmit Data Overrun Transmit Interrupt Transmit Request Receive Buffer Status 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: outportb(basisadresse,register ) // SJA1000Adresse wird eingestellt reg_wert = inportb(basisadresse+ 1); // Registerwert lesen outportb(basisadresse+1,reg_wert); // Registerwert schreiben 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. 16

17 Script für den Unterricht zum Thema CAN (Ha/EST) 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. PC CAN-Knoten 1? CAN-Knoten 3 CAN 80C535 SJA1000 CAN-Knoten 2 Prozess 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. 17

18 Script für den Unterricht zum Thema CAN (Ha/EST) 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 18

19 Script für den Unterricht zum Thema CAN (Ha/EST) 19 /********** Register -Schreib-Funktion *****************/ void canreg_write (int reg_adresse,int reg_wert) outportb(can_add,reg_adresse); outportb(can_dat,reg_wert); Knoten 1 Anwendung für PC can.h /********** Register-Lese -Funktion *******************/ int canreg_read (int reg_adresse) outportb(can_add,reg_adresse); return(inportb(can_dat)); can_init canreg_write can_pc.h canreg_write /********* CAN-Controller initialisieren ***************/ void can_init () do canreg_write(cr,0x01); //Reset -Bit setzen while(canreg_read(cr)&0x01!=0x01); SJA C250 canreg_write(acr,0x00); canreg_write(amr,0xff); //Filterung canreg_write(btr0,0x83); canreg_write(btr1,0xd8); //Baudrate und Abtastung CAN 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 CANnahen Funktionen canmessage_write(&transmit) und canmessage_read(&receive ) auf. Bereits hier benötigt der Anwender keinerlei Kenntnisse mehr über die Hardware. Allein das Wissen über den Aufbau einer CAN-Nachricht reicht aus, um diese Funktionen anzuwenden. Um eine CAN- Nachricht abzusetzen, werden die Komponenten der Strukturvariable transmit vom Type message mit Werten belegt und anschließend die Funktion canmessage_write(&transmit) mit call by reference aufgerufen (Beispiel 8-1). 19

20 Script für den Unterricht zum Thema CAN (Ha/EST) 20 /************************************************/ /* 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); Knoten Knoten 1 1 Anwendung Anwendung für für PC den PC can.h canmessage_write can_init can_pc.h canmessage_read canreg_write canreg_read SJA C250 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: CAN 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); 20

21 Script für den Unterricht zum Thema CAN (Ha/EST) 21 /* */ 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); canmessage_read (*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 /* */ CAN-Knoten 2 ( µc80535 mit SJA1000 Controller) 21

22 Script für den Unterricht zum Thema CAN (Ha/EST) 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 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); /* */ 22

23 Script für den Unterricht zum Thema CAN (Ha/EST) 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) /* */ 23

24 Script für den Unterricht zum Thema CAN (Ha/EST) 24 Die hier vorgestellten C-Funktionen erlauben der Anwendung mit wenig Aufwand eine CAN - Nachricht abzusetzen. Anwendung mit dem µc Beispiel: void main() can_init(); // Baudrate und Akzeptanzfilterung can.h canmessage_write canmessage_read transmit.id=0x007; transmit.rtr=0; transmit.dlc=2; transmit.byte[0]=0; transmit.byte[1]=1; can_init can_535.h canreg_write canreg_read //Aufruf zum Senden canmessage_write(&transmit); SJA1000 Das Programm sendet die Nachricht mit dem Identifier 007, RTR=0 sowie die Datenbytes 00 und 01 auf den Bus. 82C250 CAN 8-1: Bestimmen Sie die Baudrate, welche bei der PC-Karte von can_init () eingestellt wird! 8-2: Wie erfolgt bei der PC-Programmierung die Verwendung von canmessage_read () und canmessage_write ()? 8-3: Bestimmen Sie den Identifier, das RTR-Bit und den DLC für folgenden Programmausschnitt: canreg_write(tbuf_dscr1,0x06); canreg_write(tbuf_dscr2,0xb0); canreg_write(cmr,0x01); Welche Bedeutung hat dieser Befehl? 24