CAN-Kommunikation mit Arduino

Einleitung / Aufgabenstellung

In diesem Beitrag wird erläutert, wie mit einem Arduino Daten per CAN-Protokoll übertragen werden können. Dazu wird ein CAN-Shield eingesetzt. Alle verwendeten Programme bzw. Libraries werden an entsprechender Stelle hochgeladen. Zur Überprüfung der Kommunikation wird ein "CAN-Case" der Firma Vector eingesetzt.

Bei dem Shield handelt es sich um um Hardware der Firma "Sparkfun". Diese arbeitet mit dem Mikrocontroller MCP2515, für welchen bereits fertige Libraries zum ansteuern zur verüfung stehen. Weitere Daten sind auf der Seite von Sparkfun zu finden: Sparkfun-Homepage

Ziel dieses, im Rahmen des SDE-Praktikums "Systemintegration", ist es einen Arduino in Simulink so zu programmieren, dass mit diesem alle gängigen Sensoren ausgelesen, sowie Aktuatoren angesteuert werden können, wobei alle Informationen über CAN gesendet bzw. empfangen werden sollen. Die dabei gewonnenen Erkenntnisse sollen die Grundlage für ein Carolo-Cup Fahrzeug sein, welches komplett auf Mikrocontrollerbasis aufgebaut wird.

Inbetriebnahme der Hardware

Um die Funktion der zur verfügung gestellten Hardware zu testen, wird ein kleines CAN-Netzwerk mit zwei Teilnehmern aufgebaut. Ein Teilnehmer ist dabei der Arduino mit einem CAN-Shield der Firma Sparkfun. Der andere Teilnehmer ist ein CAN-Case der Firma Vector. Es soll gewährleistet werden, dass beide Teilnehmer senden und empfangen können. Um dies zu wird ein kleines Programm erstellt, welches eine CAN-Botschaft empfängt und zurückschickt. Das Programm bedient sich dieser Library, welcher auf der Sparkfun Seite von diversen Nutzern hochgeladen wurde. Die Library lässt durch einfaches Kopieren in den Arduino Unterordner "Libraries" (z.B. ...\arduino-1.0.3\libraries) einbinden. Die Software wird in einem späteren Kapitel erläutert.

Erste Versuche mit gegebener Hard- und Software blieben erfolglos, nach diversen Tests stellte sich heraus das die Verbindung über das vorgekrimpte Kabel nicht funktioniert. Der Grund dafür ist, dass das Pinning des Sub-D Stecker nicht der üblichen Vector-Norm entspricht. Sollen vorgefertigte Kabel verwendet werden, ist ein Adapter Notwendig. Üblicherweise liegt der CAN-High (im folgenden als CAN-H bezeichnet) an Pin 7 des Sub-D Steckers und CAN-Low (im folgenden als CAN-L bezeichnet) an Pin 2. Auf dem Sparkfun Shield liegt CAN-H auf Pin 3 und CAN-L auf Pin 5. Die folgende Tabelle zeigt die Zuordnung des Adapters:

Bezeichnung	Vector-Pinning	Sparkfun-Pinning
CAN-H	Pin 7	Pin 3
CAN-L	Pin 2	Pin 5

--Ulrich Schneider (Diskussion) 17:47, 22. Jan. 2014 (CET) SCH: Laut Schematic sind es CANH Pin3 und CANL Pin5. Was ist richtig? Schematic

Alternativ stellt das Arduino-Shield an anderer Stelle CAN-H und CAN-L zur verfügung, über diese Kontakte kann mit zwei einadrigen Leitungen einer direkte Verbindung zu dem CAN-Case hergestellt werden.

Ein einfaches Aufstecken des CAN-Shieldes nur bei dem Arduino UNO möglich ist. Wird ein Arduino Mega 2560 vewendet, müssen die Pins des Shieldes mit Leitungen zu bestimmten Pins des Arduino Megas geleitet werden. Der Grund dafür ist, dass Arduino und Shield über eine sogenannte SPI Schnittstelle Kommunizieren. SPI bedeutet "Serial Peripheral Interface" und ist ein serieller Datenbus mit einer Master und Slave Architektur. Die Pins die die Schnittstelle zum SPI zur verfügung stellen liegen beim Arduino Mega 2560 anders als beim UNO. Die Pin-Zuordnung dieser Pins zeigt folgende Tabelle:

CAN-Shield	Arduino-Mega	Arduino-UNO
VIN	VIN	VIN
GND	GND	GND
GND	GND	GND
+5V	+5V	+5V
+3,3V	+3,3V	+3,3V
RST	RST	RST
D10	D50	D10
D11	D51	D11
D12	D52	D12
D13	D53	D13

alle anderen Pins sind zum Betrieb des Shields nicht notwendig.

Bei dem elektronischen Aufbau dieses Versuches ist zu beachten das die Enden der CAN-Leitungen mit einem 120 Ohm Widerstand zwischen CAN-H und CAN-L abgeschlossen werden müssen. Wird dies nicht gemacht kommt es zu Reflektionen der Signale an den Leitungenden wodurch im schlimmsten Fall ein Kommunizieren auf der Leitung unmöglich wird. Das folgende Bild zeigt Schematisch den Aufbau:

Einlesen von Sensoren

Zum einlesen von analogen Werten, ist der Arduino mit Analog/Digitalwandlern ausgestattet. Als Referenz zum messen dient dabei die von dem Arduino zur Verfügung gestellte 5V Spannungsversorgung. Die Wandler können Werte von 0-1023 vom Typ integer zurückgeben. Damit ergibt sich eine Auflösung von 5V/1023=0,0049V=4,9mV pro Schritt. Im Programm können die analogen Eingänge mit dem Befehl "analogRead()" angesprochen werden. Die folgende mit dem Tool "Fritzing" erstellte und zeigt einen Versuchsaufbau zur Simulation eines Sensors. Dabei dient das Potentiometer als Sensor. Die LED wird zu Anzeigezwecken verbaut. An späterer Stelle soll diese durch einen DC-Motor ersetzt werden.

Einlesen eines PWM-Signals

Eingabegeräte, Sensoren und Aktuatoren arbeiten oftmals mit PWM-Signalen. Um diese mit einfachen Mitteln mit dem Arduino einlesen zu können, können Interrupts benutzt werden. Der Arduino kann an seinen Interrupts zwischen steigenden und fallenden Flanken unterscheiden. Dies kann genutzt werden, um eine Zeitmessung während der High Zeit eines PWM Signals durchzuführen. Mithilfe der bekannten Frequenz kann so das High-Low Verhältnis des Signals bestimmt werden. Ist die Frequenz unbekannt kann Sie durch die Zeitmessung zwischen Zwei High bzw. Low Flanken bestimmt werden. Die folgende Abbildung zeigt eine Oszilloskop-Aufnahme einer Fernsteuerung. In diesem Fall ist das Lenk- und Geschwindigkeitssignal zu erkennen. Wie zuvor beschrieben zeigt Thigh die zu messende Zeit für die bestimmung von High und Low verhältnis. Tfreq zeigt die Zeit, die gemessen werden muss, falls die Frequenz zunächst bestimmt werden soll. Mit dieser Periodendauer lässt sich nach der formel f=1/Tfreq die Frequenz bestimmen.

Die nächste Abbildung zeigt das PWM-Signal der Gashebelstellung, wenn dieser sich auf der Maximalstellung Rückwärts und Vorwärts befindet. Es ist zu sehen, dass das Signal bei Neutralstellung eine High-Zeit von 1,5ms aufweist. Wechselt der Gashebel auf Rückwärts beträgt diese Zeit 1ms, bei Vorwärts 2ms.

Um die Auf- und Absteigenden Flanken mit dem Arduino erkennen zu können, wird das zu messende Signal auf zwei Interrupt Pins gelegt. Die folgende Abbildung zeigt die verwendbaren Pins beim Arduino-Mega.

Im folgenden wird ein einfaches Programm gezeigt, welches mithilfe der Pins die High-Zeit des PWM-Signals bestimmt. In diesem Fall werden Auf- und Absteigende Flanke separat detektiert. Dies würde sich auch mit einem Pin realisieren lassen, da hier alerdings zwei PWM Signale bestimmt wurden und diese gleich angeordnet werden soll, ist die Info ob es sich um welche Flanke es sich handelt entscheidend. Zunächst werden die notwendigen, globalen Variablen als Volatile und long definiert um einen Zeitwert in Mikrosekunden speichern zu können:

  volatile unsigned long Anfang_PWM = 0; //Variable zur ermittlung der Impulslaenge der Beschleunigung
  volatile unsigned long Mitte_PWM = 0;
  volatile unsigned long PWM_Lenk = 0;   //Variable zur ermittlung der Impulslaenge des Lenkwinkels
  volatile unsigned long PWM_Geschw = 0;

Danach werden die Interrupts in der setup Funktion festgelegt. Dazu wird für jeden Interrupt die Funktion "attachInterrupt" aufgerufen. Als erster Wert wird die Interrupt Nummer übergeben. Die Zuordnung welche Nummer zu welchem Pin gehört kann der vorherigen Abbildung entnommen werden. Als nächstes wird die Funktion angegeben die in dem Interruptfall ausgeführt werden soll. Als letzter Punkt wird angegeben ob auf eine steigende, fallende oder wechselnde Flanke reagiert werden soll (Steigend=RISING, Fallend=FALLING, Wechselnd=CHANGING).

  void setup()
  {
  attachInterrupt(2, PWM_down_Geschw, FALLING);		//Interrupt zur identifikation einer fallenden Flanke 
  attachInterrupt(4, PWM_up_Lenk, RISING);			//Interrupt zur identifikation einer steigenden Flanke 
  attachInterrupt(5, PWM_down_Lenk, FALLING);		//Interrupt zur identifikation einer fallenden Flanke Lenkung
  }

Nun werden die entsprechenden Funktion erstellt. Diese besitzen weder Übergabe- noch Rückgabewert. Wenn Werte gespeichert werden sollen, muss dies über globale Variablen geschehen. Dabei ist zu beachten, dass diese als volatile definiert werden, da es sonst passieren kann, dass der Compiler die Variablen "wegoptimiert" da Sie nicht im Hauptprogramm auffindbar sind. Es ist hier zu sehen das beim Signalbeginn (in diesem Fall das Lenksignal) die Zeit gemessen wird. Danach wird die Zeitdifferenz zwischen dem Abfallenden Lenksignal und dem Signalstart gemessen. Da dieser Punkt zeitgleich mit der Aufsteigenden Flanke des beschleunigungssignal auftritt, kann der Zeitpunkt als ebenfalls als startsignal für das beschleunigungs PWM Signal genutz werden. Mit der letzten Funktion wird die abfallende Flanke des Beschleunigungssignals gemessen, wodurch wieder eine Zeitdifferenz ermittelt werden kann. Somit ist nun die High-Zeit beider PWM-Signale bestimmt.

//Interruptroutinen

  void PWM_up_Lenk()
  {
  cli();
  Anfang_PWM=micros();
  sei();
  }

  void PWM_down_Lenk()
  {
  cli();
  Mitte_PWM=micros();
  PWM_Lenk=Mitte_PWM-Anfang_PWM;
  sei();
  }

  void PWM_down_Geschw()
  {
  cli();
  PWM_Geschw=micros()-Mitte_PWM;
  sei();
  }

Ansteuerung von Aktuatoren

Um einen Aktuator mit dem Arduino ansteuern zu können, ist eine zusatzschaltung notwendig, da der Arduino an seinen digitalen Ausgängen nur einen begrenzten Strom liefern kann. Dieses Problem kann z.B. mit Leistungstransistoren, Mosfets oder einem Relais gelöst werden. Da die meisten Relais einen höheren Strom benötigen, als der Arduino liefern kann und die Spule eine große Störquelle darstellt, wird an dieser Stelle eine Lösung mit einem Leistungstransistor realisiert. Analog dazu kann genau so gut ein Mosfet eingesetzt werden.

Die folgende Schaltung zeigt die Realisierung einer Motoransteuerung mithilfe eines Mikrocontrollers. Da ein Mikrocontroller Ausgang in der Regel nur geringe Ströme liefern kann, ist eine Treiber Schaltung mit einem Transistor notwendig. Wechselt in dieser Schaltung der Pin des Mikrocontrollers (dargestellt durch die Spannungsquelle "Digitaler_Pin" auf 5V liegen an den Widerständen R1 und R2 jeweils 2,5 V an. Da der Widerstand R1 parallel zu der Basis-Emitter Strecke des Transistors liegt, ist die notwendige Spannung des Transistors zum durchschalten erreicht. Diese liegt in der Regel bei mind. 0,7V. Durch das Durchschalten des Transistors fällt die Spannung aus der Spannungsquelle Uversorgung an dem Widerstand R3 ab. Dieser wiederum liegt parallel zur Gate-Source Strecke des eingesetzten P-Kanal Mosfets, wodurch dieser durchschaltet. Nun ist ein Stromluss über den Mosfet zum Motor (dargestellt durch den Widerstand Rm und der Spule Lm) möglich.

100

Konfiguration des CAN-Case

Um mit dem CAN-Case zu kommunizieren wird hier die Software "CANalayzer" eingesetzt. Als ersten Schritt muss der Messaufbau in der Software eingestellt werden. Dieser kann unter dem Reiter "Configuarion" am unteren Teil des Fensters von CANalayzer gefunden werden. Hier wir zunächst die der CAN-Kanal und die Baudrate eingesetllt. Die Einstellmöglichkeiten können durch einen Doppelklick auf das Kartensymbol oder unter Konfiguration/Netzwerk-Hardware-Konfiguration erreicht werden. Sind diese Einstellungen getroffen, kann der CAN-Bus mitgeloggt werden. Alle Botschaften auf dem CAN-Bus können unter dem Reiter "Trace" im unteren Bereich des Fensters angeschaut werden.

Soll das CAN-Case ebenfalls Botschaften senden, müssen in dem Messaufbau Generatorblöcke eingefügt werden. Diese können zyklisch oder auf Knopfdruck Botschaften senden. Alternativ können diese blöcke mit der C- Ähnlichen Programmiersprache "CAPL" programmiert werden. Dies ermöglicht z.B. das reagieren auf bestimmte Botschaften.

Umsetzung der Aufgabe in C

Wie zuvor beschrieben dient als Grundlage die Bibliothek "mcp2515.h". Diese bietet für den auf dem Shield eingesetzten Microcontroller zugeschnittene Funktionen. Dafür müssen die entsprechenden Dateien wie oben beschrieben in den Arduino Ordner kopiert werden. Im Quelltext kann die Datei dann mit #include <mcp2515.h> eingebunden werden.

In der Library wird eine Struktur mit dem Namen "tCAN" zum erstellen von CAN-Botschaften definiert. Diese Klasse hat die Attribute: ID, rtr, length und Data. Diese Werte sind mindestens nötig um eine Nachricht nach dem Standard des CAN Protokolls zu versenden. Wichtig für dabei ist, dass beim CAN-Bus ist die 0 Dominant und 1en überschreibt.

Die ID dient zur Identifizierung von CAN Botschaften, gleichzeitig können dadurch Nachrichten priorisiert werden. Bei der CAN Kommunikation findet regelmäßig eine Arbitierungsphase statt. Das bedeutet es wird ermittelt welche CAN Botschaft die höchste Priorität hat und somit als erstes übertragen wird. Dies wird so realisiert, dass alle Bus- Teilnehmer gleichzeit versuchen eine Botschaft zu senden. Da die ID als erstes gesendet wird wird die ID mit den meisten 0en alle anderen überschreiben. Wird eine Botschaft eines Teilnehmers von einer 0 eines anderen Teilnehmers überschreiben, registriert der entsprechende Teilnehmer das und bricht den Sendevorgang ab.

Mit dem rtr Bit wird angegeben ob es sich bei der CAN Botschaft um einen sogenannten "Remote Frame" handelt. Mit einem Remoteframe können Daten von einem anderen Busteilnehmer angefordert werden. In dem Fall der Übertragung von Sensorwerten, muss dieses Bit also auf 0 gesetzt werden.

Das length Bit gibt an, wie lang das Datenfeld der CAN Botschaft ist. Die hier eingesetzte Library benötigt diese Angabe als Ganzzahl, welche die Anzahl der Bytes angibt. Der Arduino kann an seinen Analogen Eingängen Werte von 0 - 1024 einlesen. Um dies per CAN zu übertragen benötigt man hier also 2 Bytes (2Bytes=FFFF=65535).

In dem Datenfeld werden die eigentlich zu üebrtragenden Daten angegeben.

Die entsprechende Sendenfunktion sieht so aus:

 void CAN_send(int ID, int length,unsigned char *Data)  //Funktion zum senden einer CAN-Botschaft
 {
   message.id = ID;                            //Zuweisen der ID in die Strukturvariable
   message.header.rtr = 0;                     //Zuweisen des rtr in den Header der Strukturvariable
   message.header.length = length;             //Zuweisen der lenth in den Header der Strukturvariable
 
   for( int i = 0; i < length; i++ )           //kopieren des Datenarrays in das Datenarrays der Struktur
     {
      message.data[i] = Data[i]; 
     }
 
   mcp2515_send_message(&message);             //Funktion aus Library die das senden der fertigen Botschaft übernimmt
 }

Daten werden mit dem Befehl

   ret = mcp2515_get_message(&msg_in);      //Emfpange Botschaft (Funktion aus Library)

empfangen und befinden sich dann im Buffer. Um die Daten aus der Botschaft zu ennehmen muss auf das Datenfeld der zuvor erzeugtens Strukturvariable msg_in zugegriffen werden. Im Quellcode sieht dies wie folgt aus.

 Aktuator_an=msg_in.data[0];            //Lese Botschaft aus (überträgt in diesem Fall 1 oder 0

Quelle:Vector, Bussysteme und Bordnetze Vorlesung 10

Sensorwerte von Arduino empfangen und Antwort senden

Nachdem es nach der Beschreibung aus dem vorherigen Kapitel nun möglich ist, Daten mit dem Arduino zu senden und empfangen, sollen diese Daten nun von einer anderen Station verarbeitet werden. Hierzu wird ein Can-Case der Firma Vektor verwendet. Dieses wird mithilfe eines "CAPL" Programmes so programmiert, dass dieses einen Wert von dem Arduino empfängt und eine Antwort in form von 0 oder 1 zurücksendet. Dies könnte z.B. dazu dienen einen Aktuator einzuschalten. Das folgende Programm soll auf die Beispielnachricht 0x7B reagieren. Die Zahl ist dabei Hexadezimal angegeben und ist nur als Beispiel gewählt. Dies wird durch den Befehl "on message 0x7B{...}" angegeben.

  on message 0x7B
  {
  (...)
  }

Zunächst werden dann alle notwendigen Variablen angegeben. In CAPL werden Can-Botschaften wie Struktur-Variablen behandelt. Hier wird dazu mithilfe von "message 1 msg" eine Nachricht mit dem Namen msg und der Nummer 1 erstellt. Im weiteren Verlauf wird das erste Datenbyte mit 0 gefüllt, und das DLC (Data length Byte) auf 1 gesetzt.

   message 1 msg;
   msg.byte(0) = 0;
   msg.DLC =1;

Anschließend werden drei Variablen vom Typ "Integer" erzeugt um Daten vom Arduino empfangen zu können. In diesem Fall soll die vom Arduino gesendete Botschaft 2 Bytes lang sein, da ein Wert aus einem Analog-Digital-Wandler gesendet werden soll, dessen maximallänge 1023 entspricht. Die Variable "Ges" soll dann den Wert enthalten, wie dieser vom Arduino gesendet wurde.

   int wert1;
   int wert2;
   int Ges;

Mithilfe von this.byte wird das entsprechende Datenbyte der am Anfang festgelegten Botschaft ausgelesen. Diese werden hier in die entsprechenden Variablen geschrieben. In der anschließenden Rechnung werden die Datenbytes wieder in einen Wert von 0-1023 umgerechnet.

   wert1=this.byte(0);
   wert2=this.byte(1);
   Ges=wert1*256+wert2;

Die folgende Auswertung legt nun einen Schwellwert von 1000 fest. Wenn also ein Wert vom Arduino empfangen wurde, der größter als 1000 ist, wird das byte von "msg" auf 1 gesetzt.

   if(Ges>1000)
   {
      msg.byte(0) = 1;   
   }

Mit dem Befehl "output(msg)" wird diese Botschaft dann gesendet

   output(msg);

Eine Beispielanwendung für solch einen Programmablauf könnte eine Distanzmessung mit einem Infrarotsensor sein, wobei die Verarbeitung zentral verlaufen soll. Dabei könnte der Infrarotsensor mit einem Mikrocontroller ausgewertet und auf desssen Signal ein Motor gestoppt werden.

Umsetzung der Aufgabe in Simulink

Aus Zeitgründen konnte die Aufgabe leider nicht mehr komplett in Simulink gelöst werden. Es folgt daher in diesem Abschnitt nur der erste Schritt dazu. Eine Anleitung zur Entwicklung von Arduino Treibern in Simulink befindet sich unter folgendem Link.

Laut dieser Anleitung sollte es möglich sein, mithilfe des S-Function Builder aus der Matlab-Simulink Library, auf dem Arduino lauffähige Programme zu erstellen. Theoretisch können die Arduino Programme Stückweise, 1 zu 1 an die entsprechende Stelle in dem S-Function block kopiert werden. Die Eingänge müssen dabei allerdings voreingestellt werden. Abbildung 1 zeigt die Definition der Eingänge, wie sie für das zuvor erstellte C-Programm notwendig wären.

Verbesserungsvorschläge zum Artikel

--Ulrich Schneider (Diskussion) 13:36, 4. Feb. 2014 (CET)

• Welches Shield wurde eingesetzt? Link auf Datenblätter fehlern