CAN-Kommunikation mit Arduino - Versionsgeschichte

Michael Menke: /* Verbesserungsvorschläge zum Artikel */

2019-02-12T15:01:47Z

Verbesserungsvorschläge zum Artikel

← Nächstältere Version		Version vom 12. Februar 2019, 15:01 Uhr
Zeile 297:		Zeile 297:

	Autor: [[Benutzer:Jens Henze\|Jens Henze]] ([[Benutzer Diskussion:Jens Henze\|Diskussion]]) 14:11, 6. Feb. 2014 (CET)		Autor: [[Benutzer:Jens Henze\|Jens Henze]] ([[Benutzer Diskussion:Jens Henze\|Diskussion]]) 14:11, 6. Feb. 2014 (CET)
			<!-- Gehört in die Diskussion
	== Verbesserungsvorschläge zum Artikel ==		== Verbesserungsvorschläge zum Artikel ==
	--[[Benutzer:Ulrich Schneider\|Ulrich Schneider]] ([[Benutzer Diskussion:Ulrich Schneider\|Diskussion]]) 13:36, 4. Feb. 2014 (CET)		--[[Benutzer:Ulrich Schneider\|Ulrich Schneider]] ([[Benutzer Diskussion:Ulrich Schneider\|Diskussion]]) 13:36, 4. Feb. 2014 (CET)
	* Welches Shield wurde eingesetzt? Link auf Datenblätter fehlern		* Welches Shield wurde eingesetzt? Link auf Datenblätter fehlern
			-->

			----
			→ zurück zum Hauptartikel: [[Praktikum_SDE\|Praktikum SDE]]

Jens Henze am 7. Februar 2014 um 17:48 Uhr

2014-02-07T17:48:11Z

Jens Henze: /* Einlesen eines PWM-Signals */

2014-02-07T17:44:49Z

Einlesen eines PWM-Signals

← Nächstältere Version		Version vom 7. Februar 2014, 17:44 Uhr
Zeile 102:		Zeile 102:

	==Einlesen eines PWM-Signals==		==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. Als Anschauungsbeispiel soll hier das PWM-Signal einer Fernsteuerung erfasst werden. Die folgende Abbildung zeigt eine Oszilloskop-Aufnahme dieser Fernsteuerung. In diesem Fall ist das Lenk- und Geschwindigkeitssignal zu erkennen. "~~T_{high}~~" in der Abbildung zeigt die High-Zeit des Signals. "Tfreq" zeigt die Zeit, die gemessen werden muss, falls die Frequenz bestimmt werden soll. Mit dieser Periodendauer lässt sich nach der Formel f=1/Tfreq die Frequenz bestimmen. Das Verhältnis Thigh/Tfreq ist dann das High-Low Verhältnis des 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. Als Anschauungsbeispiel soll hier das PWM-Signal einer Fernsteuerung erfasst werden. Die folgende Abbildung zeigt eine Oszilloskop-Aufnahme dieser Fernsteuerung. In diesem Fall ist das Lenk- und Geschwindigkeitssignal zu erkennen. "Thigh" in der Abbildung zeigt die High-Zeit des Signals. "Tfreq" zeigt die Zeit, die gemessen werden muss, falls die Frequenz bestimmt werden soll. Mit dieser Periodendauer lässt sich nach der Formel f=1/Tfreq die Frequenz bestimmen. Das Verhältnis Thigh/Tfreq ist dann das High-Low Verhältnis des PWM-Signals.
	[[Datei:PWM.png\|600px\|center]]		[[Datei:PWM.png\|600px\|center]]
	Die nächste Abbildung zeigt das PWM-Signal der Gashebelstellung der Fernsteuerung, wenn diese sich auf Neutral und Maximalstellung Rückwärts bzw. Vorwärts befindet. Es ist zu sehen, dass das Signal bei Neutralstellung eine High-Zeit von 1,5ms, bei Rückwärts 1ms und bei Vorwärts 2ms beträgt.		Die nächste Abbildung zeigt das PWM-Signal der Gashebelstellung der Fernsteuerung, wenn diese sich auf Neutral und Maximalstellung Rückwärts bzw. Vorwärts befindet. Es ist zu sehen, dass das Signal bei Neutralstellung eine High-Zeit von 1,5ms, bei Rückwärts 1ms und bei Vorwärts 2ms beträgt.

Jens Henze am 7. Februar 2014 um 17:44 Uhr

2014-02-07T17:44:07Z

Jens Henze: /* Kommunizieren per CAN */

2014-02-07T17:10:50Z

Kommunizieren per CAN

Änderungen zeigen

Jens Henze: /* Ansteuerung von Aktuatoren */

2014-02-07T16:49:31Z

Ansteuerung von Aktuatoren

← Nächstältere Version		Version vom 7. Februar 2014, 16:49 Uhr
Zeile 160:		Zeile 160:
	Um einen Aktuator mit dem Arduino ansteuern zu können, ist eine Zusatzschaltung (auch Treiberschaltung genannt) notwendig. Grund dafür ist, dass der Arduino an seinen digitalen Ausgängen nur begrenzt belastet werden 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 Mosfet realisiert. Analog dazu kann genau so gut ein Leistungstransistor eingesetzt werden.		Um einen Aktuator mit dem Arduino ansteuern zu können, ist eine Zusatzschaltung (auch Treiberschaltung genannt) notwendig. Grund dafür ist, dass der Arduino an seinen digitalen Ausgängen nur begrenzt belastet werden 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 Mosfet realisiert. Analog dazu kann genau so gut ein Leistungstransistor eingesetzt werden.

	Die folgende Schaltung zeigt die Realisierung einer Motoransteuerung mithilfe eines Mikrocontrollers. Da ein Mikrocontrollerausgang in der Regel nur geringe Ströme liefern kann, ist eine Treiberschaltung 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. Das Durchschalten des Transistors verursacht eine Spannung mit Höhe der Spannungsquelle "Uversorgung" an dem Widerstand R3. 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.		Die folgende Schaltung zeigt die Realisierung einer Motoransteuerung mithilfe eines Mikrocontrollers. Da ein Mikrocontrollerausgang in der Regel nur geringe Ströme liefern kann, ist eine Treiberschaltung 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. Das Durchschalten des Transistors verursacht eine Spannung mit Höhe der Spannungsquelle "Uversorgung" an dem Widerstand R3. Dieser wiederum liegt parallel zur Gate-Source Strecke des eingesetzten P-Kanal Mosfets, wodurch dieser durchschaltet. Nun ist ein Stromfluss über den Mosfet zum Motor (dargestellt durch den Widerstand Rm und der Spule Lm) möglich.

	[[Datei:Digit_Aktuator_Anschaltung.png\|500px\|center]]		[[Datei:Digit_Aktuator_Anschaltung.png\|500px\|center]]

Jens Henze: /* Ansteuerung von Aktuatoren */

2014-02-07T16:49:07Z

Ansteuerung von Aktuatoren

← Nächstältere Version		Version vom 7. Februar 2014, 16:49 Uhr
Zeile 160:		Zeile 160:
	Um einen Aktuator mit dem Arduino ansteuern zu können, ist eine Zusatzschaltung (auch Treiberschaltung genannt) notwendig. Grund dafür ist, dass der Arduino an seinen digitalen Ausgängen nur begrenzt belastet werden 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 Mosfet realisiert. Analog dazu kann genau so gut ein Leistungstransistor eingesetzt werden.		Um einen Aktuator mit dem Arduino ansteuern zu können, ist eine Zusatzschaltung (auch Treiberschaltung genannt) notwendig. Grund dafür ist, dass der Arduino an seinen digitalen Ausgängen nur begrenzt belastet werden 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 Mosfet realisiert. Analog dazu kann genau so gut ein Leistungstransistor eingesetzt werden.

	Die folgende Schaltung zeigt die Realisierung einer Motoransteuerung mithilfe eines Mikrocontrollers. Da ein Mikrocontrollerausgang in der Regel nur geringe Ströme liefern kann, ist eine Treiberschaltung 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. Das Durchschalten des Transistors verursacht eine Spannung mit ~~höhe~~ der Spannungsquelle "Uversorgung" an dem Widerstand R3. 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.		Die folgende Schaltung zeigt die Realisierung einer Motoransteuerung mithilfe eines Mikrocontrollers. Da ein Mikrocontrollerausgang in der Regel nur geringe Ströme liefern kann, ist eine Treiberschaltung 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. Das Durchschalten des Transistors verursacht eine Spannung mit Höhe der Spannungsquelle "Uversorgung" an dem Widerstand R3. 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.

	[[Datei:Digit_Aktuator_Anschaltung.png\|500px\|center]]		[[Datei:Digit_Aktuator_Anschaltung.png\|500px\|center]]

Jens Henze: /* Ansteuerung von Aktuatoren */

2014-02-07T16:48:16Z

Ansteuerung von Aktuatoren

← Nächstältere Version		Version vom 7. Februar 2014, 16:48 Uhr
Zeile 160:		Zeile 160:
	Um einen Aktuator mit dem Arduino ansteuern zu können, ist eine Zusatzschaltung (auch Treiberschaltung genannt) notwendig. Grund dafür ist, dass der Arduino an seinen digitalen Ausgängen nur begrenzt belastet werden 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 Mosfet realisiert. Analog dazu kann genau so gut ein Leistungstransistor eingesetzt werden.		Um einen Aktuator mit dem Arduino ansteuern zu können, ist eine Zusatzschaltung (auch Treiberschaltung genannt) notwendig. Grund dafür ist, dass der Arduino an seinen digitalen Ausgängen nur begrenzt belastet werden 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 Mosfet realisiert. Analog dazu kann genau so gut ein Leistungstransistor 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. Das Durchschalten des Transistors verursacht eine Spannung mit höhe der Spannungsquelle "Uversorgung" an dem Widerstand R3. 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.		Die folgende Schaltung zeigt die Realisierung einer Motoransteuerung mithilfe eines Mikrocontrollers. Da ein Mikrocontrollerausgang in der Regel nur geringe Ströme liefern kann, ist eine Treiberschaltung 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. Das Durchschalten des Transistors verursacht eine Spannung mit höhe der Spannungsquelle "Uversorgung" an dem Widerstand R3. 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.

	[[Datei:Digit_Aktuator_Anschaltung.png\|500px\|center]]		[[Datei:Digit_Aktuator_Anschaltung.png\|500px\|center]]

Jens Henze: /* Einlesen eines PWM-Signals */

2014-02-07T16:45:00Z

Einlesen eines PWM-Signals

← Nächstältere Version		Version vom 7. Februar 2014, 16:45 Uhr
Zeile 102:		Zeile 102:

	==Einlesen eines PWM-Signals==		==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. Als Anschauungsbeispiel soll hier das PWM-Signal einer Fernsteuerung erfasst werden. Die folgende Abbildung zeigt eine Oszilloskop-Aufnahme dieser Fernsteuerung. In diesem Fall ist das Lenk- und Geschwindigkeitssignal zu erkennen. "Thigh" in der Abbildung zeigt die High-Zeit des Signals. "Tfreq" zeigt die Zeit, die gemessen werden muss, falls die Frequenz bestimmt werden soll. Mit dieser Periodendauer lässt sich nach der ~~formel~~ f=1/Tfreq die Frequenz bestimmen. Das Verhältnis Thigh/Tfreq ist dann das High-Low Verhältnis des 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. Als Anschauungsbeispiel soll hier das PWM-Signal einer Fernsteuerung erfasst werden. Die folgende Abbildung zeigt eine Oszilloskop-Aufnahme dieser Fernsteuerung. In diesem Fall ist das Lenk- und Geschwindigkeitssignal zu erkennen. "Thigh" in der Abbildung zeigt die High-Zeit des Signals. "Tfreq" zeigt die Zeit, die gemessen werden muss, falls die Frequenz bestimmt werden soll. Mit dieser Periodendauer lässt sich nach der Formel f=1/Tfreq die Frequenz bestimmen. Das Verhältnis Thigh/Tfreq ist dann das High-Low Verhältnis des PWM-Signals.
	[[Datei:PWM.png\|600px\|center]]		[[Datei:PWM.png\|600px\|center]]
	Die nächste Abbildung zeigt das PWM-Signal der Gashebelstellung der Fernsteuerung, wenn ~~dieser~~ sich auf Neutral und Maximalstellung Rückwärts bzw. Vorwärts befindet. Es ist zu sehen, dass das Signal bei Neutralstellung eine High-Zeit von 1,5ms bei Rückwärts 1ms und bei Vorwärts 2ms beträgt.		Die nächste Abbildung zeigt das PWM-Signal der Gashebelstellung der Fernsteuerung, wenn diese sich auf Neutral und Maximalstellung Rückwärts bzw. Vorwärts befindet. Es ist zu sehen, dass das Signal bei Neutralstellung eine High-Zeit von 1,5ms, bei Rückwärts 1ms und bei Vorwärts 2ms beträgt.
	[[Datei:PWM_brems_gas.png\|600px\|center]]		[[Datei:PWM_brems_gas.png\|600px\|center]]
	Um die Auf- und Absteigenden Flanken mit dem Arduino gesondert erkennen zu können, wird das zu messende Signal auf zwei Interrupt Pins gelegt. Die folgende Abbildung zeigt die verwendbaren Pins beim Arduino-Mega.		Um die Auf- und Absteigenden Flanken mit dem Arduino gesondert erkennen zu können, wird das zu messende Signal auf zwei Interrupt Pins gelegt. Die folgende Abbildung zeigt die verwendbaren Pins beim Arduino-Mega.
	[[Datei:Interrupts.png\|600px\|center]]		[[Datei:Interrupts.png\|600px\|center]]
	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 und gleich angeordnet werden sollen, ist diese Info von großer Bedeutung. Zunächst werden die notwendigen, globalen Variablen als Volatile und long definiert um einen Zeitwert in Mikrosekunden speichern zu können (der Grund für Volatile wird später erläutert):		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 Flanken separat detektiert. Dies würde sich auch mit einem Pin realisieren lassen, da hier allerdings zwei PWM Signale bestimmt und gleich angeordnet werden sollen, ist diese Info von großer Bedeutung. Zunächst werden die notwendigen, globalen Variablen als Volatile und long definiert um einen Zeitwert in Mikrosekunden speichern zu können (der Grund für Volatile wird später erläutert):

	<code>		<code>
Zeile 122:		Zeile 122:
	void setup()		void setup()
	{		{
	attachInterrupt(2, PWM_down_Geschw, FALLING); //Interrupt zur identifikation einer fallenden Flanke		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(4, PWM_up_Lenk, RISING); //Interrupt zur identifikation einer steigenden Flanke
	attachInterrupt(5, PWM_down_Lenk, FALLING); //Interrupt zur identifikation einer fallenden Flanke Lenkung		attachInterrupt(5, PWM_down_Lenk, FALLING); //Interrupt zur identifikation einer fallenden Flanke Lenkung
	}		}
	</code>		</code>
	Nun werden die entsprechenden Funktionen 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 worden sind. Sonst kann es passieren, dass der Compiler die Variablen "wegoptimiert", da Sie nicht im Hauptprogramm auffindbar sind. Den Funktionen ist zu entehmen, dass beim Signalbeginn (in diesem Fall das Lenksignal) die Prozessorlaufzeit gespeichert wird. Fällt die Flanke ab wird die Zeitdifferenz zwischen dem Abfallenden Lenksignal und dem Signalstart gemessen. Da dieser Punkt zeitgleich mit der Aufsteigenden Flanke des Beschleunigungssignals auftritt, kann der Zeitpunkt als Startsignal für das ~~beschleunigungs~~ PWM Signal ~~genutz~~ werden (so kann ein Interrupt-Pin gespart 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.		Nun werden die entsprechenden Funktionen 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 worden sind. Sonst kann es passieren, dass der Compiler die Variablen "wegoptimiert", da Sie nicht im Hauptprogramm auffindbar sind. Den Funktionen ist zu entehmen, dass beim Signalbeginn (in diesem Fall das Lenksignal) die Prozessorlaufzeit gespeichert wird. Fällt die Flanke ab wird die Zeitdifferenz zwischen dem Abfallenden Lenksignal und dem Signalstart gemessen. Da dieser Punkt zeitgleich mit der Aufsteigenden Flanke des Beschleunigungssignals auftritt, kann der Zeitpunkt als Startsignal für das Beschleunigungs-PWM-Signal genutzt werden (so kann ein Interrupt-Pin gespart 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.
	<code>		<code>

Zeile 156:		Zeile 156:
	</code>		</code>
	Autor: [[Benutzer:Jens Henze\|Jens Henze]] ([[Benutzer Diskussion:Jens Henze\|Diskussion]]) 14:13, 6. Feb. 2014 (CET)		Autor: [[Benutzer:Jens Henze\|Jens Henze]] ([[Benutzer Diskussion:Jens Henze\|Diskussion]]) 14:13, 6. Feb. 2014 (CET)

	=Ansteuerung von Aktuatoren=		=Ansteuerung von Aktuatoren=
	Um einen Aktuator mit dem Arduino ansteuern zu können, ist eine Zusatzschaltung (auch Treiberschaltung genannt) notwendig. Grund dafür ist, dass der Arduino an seinen digitalen Ausgängen nur begrenzt belastet werden 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 Mosfet realisiert. Analog dazu kann genau so gut ein Leistungstransistor eingesetzt werden.		Um einen Aktuator mit dem Arduino ansteuern zu können, ist eine Zusatzschaltung (auch Treiberschaltung genannt) notwendig. Grund dafür ist, dass der Arduino an seinen digitalen Ausgängen nur begrenzt belastet werden 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 Mosfet realisiert. Analog dazu kann genau so gut ein Leistungstransistor eingesetzt werden.

Jens Henze: /* Inbetriebnahme der Hardware */

2014-02-07T16:32:46Z

Inbetriebnahme der Hardware

← Nächstältere Version		Version vom 7. Februar 2014, 16:32 Uhr
Zeile 88:		Zeile 88:
	alle anderen Pins sind zum Betrieb des Shields nicht notwendig.		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. Fehlen diese Widerstände 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:		Bei dem elektronischen Aufbau dieses Versuches ist zu beachten, dass die Enden der CAN-Leitungen mit einem 120 Ohm Widerstand zwischen CAN-H und CAN-L abgeschlossen werden müssen. Fehlen diese Widerstände 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:

	[[Datei:CAN-Netzwerk_aufbau.jpg\|500px\|center]]		[[Datei:CAN-Netzwerk_aufbau.jpg\|500px\|center]]

← Nächstältere Version		Version vom 7. Februar 2014, 17:48 Uhr
Zeile 127:		Zeile 127:
	}		}
	</code>		</code>
	Nun werden die entsprechenden Funktionen 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 worden sind. Sonst kann es passieren, dass der Compiler die Variablen "wegoptimiert", da ~~Sie~~ nicht im Hauptprogramm auffindbar sind. Den Funktionen ist zu entehmen, dass beim Signalbeginn (in diesem Fall das Lenksignal) die Prozessorlaufzeit gespeichert wird. Fällt die Flanke ab wird die Zeitdifferenz zwischen dem Abfallenden Lenksignal und dem Signalstart gemessen. Da dieser Punkt zeitgleich mit der Aufsteigenden Flanke des Beschleunigungssignals auftritt, kann der Zeitpunkt als Startsignal für das Beschleunigungs-PWM-Signal genutzt werden (so kann ein Interrupt-Pin gespart 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.		Nun werden die entsprechenden Funktionen 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 worden sind. Sonst kann es passieren, dass der Compiler die Variablen "wegoptimiert", da sie nicht im Hauptprogramm auffindbar sind. Den Funktionen ist zu entehmen, dass beim Signalbeginn (in diesem Fall das Lenksignal) die Prozessorlaufzeit gespeichert wird. Fällt die Flanke ab wird die Zeitdifferenz zwischen dem Abfallenden Lenksignal und dem Signalstart gemessen. Da dieser Punkt zeitgleich mit der Aufsteigenden Flanke des Beschleunigungssignals auftritt, kann der Zeitpunkt als Startsignal für das Beschleunigungs-PWM-Signal genutzt werden (so kann ein Interrupt-Pin gespart 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.
	<code>		<code>

Zeile 167:		Zeile 167:

	=Kommunizieren per CAN=		=Kommunizieren per CAN=
	Es folgt eine Beschreibung zum Aufbau einer CAN-Kommunikation zwischen dem Arduino und dem CAN-Case. Zu Schluss wird eine Möglichkeit beschrieben eine Kommunikation auf der Basis von Matlab-Simulink zu erstellen.		Es folgt eine Beschreibung zum Aufbau einer CAN-Kommunikation zwischen dem Arduino und dem CAN-Case. Zum Schluss wird eine Möglichkeit beschrieben eine Kommunikation auf der Basis von Matlab-Simulink zu erstellen.

	==Konfiguration des CAN-Case==		==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.		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 "Configuration" am unteren Teil des Fensters von CANalayzer gefunden werden. Hier wir zunächst der CAN-Kanal und die Baudrate eingestellt. 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.		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.
Zeile 179:		Zeile 179:
	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 dabei ist, dass beim CAN-Bus die 0 Dominant ist und 1en überschreibt.		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 dabei ist, dass beim CAN-Bus die 0 Dominant ist 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. Die am höchsten priorisierte Botschaft ist die, dessen ID die meisten 0en enthält. Wird eine Botschaft eines Teilnehmers von einer 0 eines anderen Teilnehmers überschreiben, registriert der entsprechende Teilnehmer das und bricht den Sendevorgang ab.		Die ID dient zur Identifizierung von CAN Botschaften, gleichzeitig können dadurch Nachrichten priorisiert werden. Bei der CAN Kommunikation findet regelmäßig eine Arbitrierungsphase 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. Die am höchsten priorisierte Botschaft ist die, dessen ID die meisten 0en enthält. 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.		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.
Zeile 257:		Zeile 257:
	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 [http://www.mathworks.de/matlabcentral/fileexchange/39354-device-drivers Link].		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 [http://www.mathworks.de/matlabcentral/fileexchange/39354-device-drivers 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 im S-Function-Block unter "Data Properties" voreingestellt werden. Abbildung 1 zeigt die Definition der Eingänge, wie sie für das zuvor erstellte C-Programm notwendig wären.		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, eins zu eins an die entsprechende Stelle in dem S-Function-Block kopiert werden. Die Eingänge müssen dabei allerdings im S-Function-Block unter "Data Properties" voreingestellt werden. Abbildung 1 zeigt die Definition der Eingänge, wie sie für das zuvor erstellte C-Programm notwendig wären.

	[[Datei:S-Function Input.png\|500px\|center]]		[[Datei:S-Function Input.png\|500px\|center]]
Zeile 269:		Zeile 269:
	[[Datei:S-Function_Libraries.png\|500px\|center]]		[[Datei:S-Function_Libraries.png\|500px\|center]]

	Unter dem Reiter "Outputs" wird das eigentliche Hauptprogramm aufgeführt. Also alles was in Arduino Programmen unter "void loop(){(...]}" steht. Die in der folgenden Abbildung gezeigte Variable xD[0] ist eine interne Matlab Variable. Da diese hier auf 1 ~~Abgefragt~~ wird, wird dieser Programmteil als Endlosschleife ausgeführt. Dazu im nächsten Abschnitt mehr.		Unter dem Reiter "Outputs" wird das eigentliche Hauptprogramm aufgeführt. Also alles was in Arduino Programmen unter "void loop(){(...]}" steht. Die in der folgenden Abbildung gezeigte Variable xD[0] ist eine interne Matlab Variable. Da diese hier auf 1 abgefragt wird, wird dieser Programmteil als Endlosschleife ausgeführt. Dazu im nächsten Abschnitt mehr.

	[[Datei:S-Function_Output.png\|500px\|center]]		[[Datei:S-Function_Output.png\|500px\|center]]
Zeile 277:		Zeile 277:
	[[Datei:S-Function_DiscreteUpdate.png\|500px\|center]]		[[Datei:S-Function_DiscreteUpdate.png\|500px\|center]]

	Wird nun auf den Button Build des S-Function Menüs geklickt, wird der gesamte Block compiliert. Dazu muss allerdings ein C-Compiler für Matlab installiert sein. Dieser kann mithilfe von mex -setup im Matlab ~~Status~~ Fenster initialisiert werden.		Wird nun auf den Button Build des S-Function Menüs geklickt, wird der gesamte Block compiliert. Dazu muss allerdings ein C-Compiler für Matlab installiert sein. Dieser kann mithilfe von mex -setup im Matlab Command Fenster initialisiert werden.
	Wurde die S-Function compiliert sind in dem Arbeitsverzeichnis mehrere Dateien zu finden, darunter auch eine Datei namens "sfcn_exout_slsp_wrapper.c". Schaut man sich diese Datei an, ist die Struktur des "klassischen" Arduino Programmes wieder zu erkennen. Hier kann also verglichen werden ob das Programm auch so compiliert wurde, wie es soll.		Wurde die S-Function compiliert sind in dem Arbeitsverzeichnis mehrere Dateien zu finden, darunter auch eine Datei namens "sfcn_exout_slsp_wrapper.c". Schaut man sich diese Datei an, ist die Struktur des "klassischen" Arduino Programmes wieder zu erkennen. Hier kann also verglichen werden ob das Programm auch so compiliert wurde, wie es soll.
	Die Übertragung der S-Function findet wie mit den Arduino-Standard-Programmen über "Run on target Hardware" statt.		Die Übertragung der S-Function findet wie mit den Arduino-Standard-Programmen über "Run on target Hardware" statt.

← Nächstältere Version		Version vom 7. Februar 2014, 17:44 Uhr
Zeile 5:		Zeile 5:

	=Einleitung / Aufgabenstellung=		=Einleitung / Aufgabenstellung=
	In diesem Beitrag wird erläutert wie, mit einem Arduino, Daten per CAN-Protokoll übertragen werden können. Dazu wird entsprechende Hardware in Form eines CAN-Shieldes eingesetzt.		In diesem Beitrag wird erläutert, wie mit einem Arduino, Daten per CAN-Protokoll übertragen werden können. Dazu wird entsprechende Hardware in Form eines CAN-Shieldes eingesetzt.
	Die notwendigen Programmteile werden zunächst erklärt und dann in besonders markierten Kästen dargestellt. Zur Überprüfung der Kommunikation wird ein "CAN-Case" der Firma Vector eingesetzt.		Die notwendigen Programmteile werden zunächst erklärt und dann in besonders markierten Kästen dargestellt. Zur Überprüfung der Kommunikation wird ein "CAN-Case" der Firma Vector eingesetzt.

	Bei dem Shield handelt es sich um Hardware der Firma "Sparkfun". ~~Diese~~ arbeitet mit dem Mikrocontroller MCP2515, für welchen bereits fertige Libraries zum ~~ansteuern~~ zur ~~Verüfung~~ stehen. Weitere technische Daten, sowie Datenblätter und Schaltpläne sind auf der Seite von Sparkfun zu finden: [https://www.sparkfun.com/products/10039 Sparkfun-Homepage]		Bei dem Shield handelt es sich um Hardware der Firma "Sparkfun". Dieses arbeitet mit dem Mikrocontroller MCP2515, für welchen bereits fertige Libraries zum Ansteuern zur Verfügung stehen. Weitere technische Daten, sowie Datenblätter und Schaltpläne sind auf der Seite von Sparkfun zu finden: [https://www.sparkfun.com/products/10039 Sparkfun-Homepage]

	Ziel dieses, im Rahmen des SDE-Praktikums "Systemintegration", durchgeführten Projektes ist es, Sensoren verschiedener Art mit einem Arduino ~~auszulesen~~ und die Daten per CAN weiterzusenden. Die dabei gewonnenen Erkenntnisse sollen die Grundlage für ein Carolo-Cup Fahrzeug sein, welches komplett auf Mikrocontrollerbasis aufgebaut wird.		Ziel dieses, im Rahmen des SDE-Praktikums "Systemintegration", durchgeführten Projektes ist es, Sensoren verschiedener Art mit einem Arduino einzulesen und die Daten per CAN weiterzusenden. Die dabei gewonnenen Erkenntnisse sollen die Grundlage für ein Carolo-Cup Fahrzeug sein, welches komplett auf Mikrocontrollerbasis aufgebaut wird.

	Autor: [[Benutzer:Jens Henze\|Jens Henze]] ([[Benutzer Diskussion:Jens Henze\|Diskussion]]) 14:13, 6. Feb. 2014 (CET)		Autor: [[Benutzer:Jens Henze\|Jens Henze]] ([[Benutzer Diskussion:Jens Henze\|Diskussion]]) 14:13, 6. Feb. 2014 (CET)
Zeile 39:		Zeile 39:
	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.		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 ist nur bei dem Arduino UNO möglich. Soll ein Arduino Mega 2560 vewendet werden, müssen die Pins des Shieldes mit Leitungen zu bestimmten Pins des Arduino Mega geleitet werden. Der Grund dafür ist, dass Arduino und Shield über eine sogenannte SPI Schnittstelle kommunizieren. SPI steht für "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:		Ein einfaches Aufstecken des CAN-Shieldes ist nur bei dem Arduino UNO möglich. Soll ein Arduino Mega 2560 vewendet werden, müssen die Pins des Shieldes mit Leitungen zu bestimmten Pins des Arduino Mega geleitet werden. Der Grund dafür ist, dass Arduino und Shield über eine sogenannte SPI Schnittstelle kommunizieren. SPI steht für "Serial Peripheral Interface" und ist ein serieller Datenbus mit einer Master-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:
	{\| class="wikitable"		{\| class="wikitable"
	!CAN-Shield		!CAN-Shield
Zeile 86:		Zeile 86:
	\|-		\|-
	\|}		\|}
	~~alle~~ anderen Pins sind zum Betrieb des Shields nicht notwendig.		Alle anderen Pins sind zum Betrieb des Shields nicht notwendig.

	Bei dem elektronischen Aufbau dieses Versuches ist zu beachten, dass die Enden der CAN-Leitungen mit einem 120 Ohm Widerstand zwischen CAN-H und CAN-L abgeschlossen werden müssen. Fehlen diese Widerstände 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:		Bei dem elektronischen Aufbau dieses Versuches ist zu beachten, dass die Enden der CAN-Leitungen mit einem 120 Ohm Widerstand zwischen CAN-H und CAN-L abgeschlossen werden müssen. Fehlen diese Widerstände kommt es zu Reflektionen der Signale an den Leitungsenden, wodurch im schlimmsten Fall ein Kommunizieren auf der Leitung unmöglich wird. Das folgende Bild zeigt Schematisch den Aufbau:

	[[Datei:CAN-Netzwerk_aufbau.jpg\|500px\|center]]		[[Datei:CAN-Netzwerk_aufbau.jpg\|500px\|center]]
Zeile 102:		Zeile 102:

	==Einlesen eines PWM-Signals==		==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. Als Anschauungsbeispiel soll hier das PWM-Signal einer Fernsteuerung erfasst werden. Die folgende Abbildung zeigt eine Oszilloskop-Aufnahme dieser Fernsteuerung. In diesem Fall ist das Lenk- und Geschwindigkeitssignal zu erkennen. "~~Thigh~~" in der Abbildung zeigt die High-Zeit des Signals. "Tfreq" zeigt die Zeit, die gemessen werden muss, falls die Frequenz bestimmt werden soll. Mit dieser Periodendauer lässt sich nach der Formel f=1/Tfreq die Frequenz bestimmen. Das Verhältnis Thigh/Tfreq ist dann das High-Low Verhältnis des 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. Als Anschauungsbeispiel soll hier das PWM-Signal einer Fernsteuerung erfasst werden. Die folgende Abbildung zeigt eine Oszilloskop-Aufnahme dieser Fernsteuerung. In diesem Fall ist das Lenk- und Geschwindigkeitssignal zu erkennen. "T_{high}" in der Abbildung zeigt die High-Zeit des Signals. "Tfreq" zeigt die Zeit, die gemessen werden muss, falls die Frequenz bestimmt werden soll. Mit dieser Periodendauer lässt sich nach der Formel f=1/Tfreq die Frequenz bestimmen. Das Verhältnis Thigh/Tfreq ist dann das High-Low Verhältnis des PWM-Signals.
	[[Datei:PWM.png\|600px\|center]]		[[Datei:PWM.png\|600px\|center]]
	Die nächste Abbildung zeigt das PWM-Signal der Gashebelstellung der Fernsteuerung, wenn diese sich auf Neutral und Maximalstellung Rückwärts bzw. Vorwärts befindet. Es ist zu sehen, dass das Signal bei Neutralstellung eine High-Zeit von 1,5ms, bei Rückwärts 1ms und bei Vorwärts 2ms beträgt.		Die nächste Abbildung zeigt das PWM-Signal der Gashebelstellung der Fernsteuerung, wenn diese sich auf Neutral und Maximalstellung Rückwärts bzw. Vorwärts befindet. Es ist zu sehen, dass das Signal bei Neutralstellung eine High-Zeit von 1,5ms, bei Rückwärts 1ms und bei Vorwärts 2ms beträgt.