Der Mikrokontroller – Arduino Uno Rev 3

Der Mikrokontroller – Arduino Uno Rev 3
Copyright by H. Sporenberg-2016

Das erste Beispiel Blinkende LED int ledPin = 13; // LED verbunden mit dem digitalen Pin 13 // Die setup()-Methode läuft einmal, wenn der sketch gestartet wird void setup() { // Initializiert den Pin 13 zur Ausgabe pinMode(ledPin, OUTPUT); } // Die loop()-Methode läuft als Schleife solange bis der Arduino abgeschaltet wird void loop() { digitalWrite(ledPin, HIGH); // Schaltet die LED ein delay(1000); // wartet ca. 1 Sekunde digitalWrite(ledPin, LOW); // Schaltet die LED aus Copyright by H. Sporenberg-2016

Das erste Beispiel Blinkende LED Copyright by H. Sporenberg-2016

4 Räder - Roboter – mit dem Arduino
Mit Hilfe des Mikrocontrollers Arduino soll ein Roboter mit 4 Rädern gebaut werden. Erstes Ziel ist: 1.Aufbau des Roboters 2.Steuerung durch den Arduino 3.Bewegung: Vor- und Rückwärtsfahren Copyright by H. Sporenberg-2016

Das Motor Drive Shield L293D

Für Gleichstrommotoren Als erstes muss die Library für das Shield installiert werden. Diese kann von folgender Seite heruntergeladen werden. Die Datei heißt: Adafruit-Motor-Shield-library-master.zip (12 kB) Diese ZIP-Datei muss entzipped werden. Achtung: Der Gleichstrom-motor wird in diesem Beispiel an #2 angeschlossen. Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Diese ZIP-Datei wird entzipped und man erhält Folgendes Das Unterverzeichnis Adafruit-Motor-Shield-library-master wird umbenannt in AFMotor. Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Im Verzeichnis AFMotor müssen folgende Dateien vorhanden sein: AFMotor.ccp AFMotor.h Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Das Verzeichnis wird kopiert nach: C:\Programme\arduino windows\arduino-1.5.8\libraries\AFMotor Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Die Include-Datei AFMotor.h stellt für die Verwendung eines Gleichstrommotors folgenden Konstruktor zur Verfügung: AF_DCMotor Motorname(Portnummer,Frequenz) Angegeben werden muss ein Motorname, die Portnummer (1, 2, 3 bzw. 4) und die PWM-Frequenz. Für #1 und #2 sind dies: MOTOR12_64KHZ MOTOR12_8KHZ MOTOR12_2KHZ MOTOR12_1KHZ Für #3 und #4 sind dies: MOTOR34_64KHZ MOTOR34_8KHZ MOTOR34_1KHZ Wird keine Frequenz angegeben, so ist die Voreinstellung 1KHZ Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Es gibt folgende Methoden: motor.setSpeed(Nummer) – Werte für Nummer sind 0 bis 255. Dabei bedeutet: 0 – Motor steht; 255 – maximale Drehzahl motor.run(Zustand) – Werte für Zustand sind: FORWARD BACKWARD RELEASE Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Das Programm (Sketch) zum Test des Gleichstrommotors sieht wie folgt aus: #include <AFMotor.h> AF_DCMotor motor2(2, MOTOR12_64KHZ); // create motor #2, 64KHz pwm void setup() { Serial.begin(9600); // set up Serial library at 9600 bps Serial.println("Motor test!"); motor2.setSpeed(200); // set the speed to 200/255 } void loop() { Serial.print("tick"); motor2.run(FORWARD); // turn it on going forward delay(5000); // 5 Sekunden Serial.print("tock"); motor2.run(BACKWARD); // the other way delay(5000); // 5 Sekunden Serial.print("tack"); motor2.run(RELEASE); // stopped delay(5000);} // 5 Sekunden Motor ist an #2 angeschlossen Motor_DC_01.ino Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Bevor das Programm über Sketch -> Prüfen/Übersetzen auf Fehler überprüft wird, müssen der Port und das Board eingestellt werden. Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Board-Überprüfung über: Werkzeuge -> Board -> Arduino Uno Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Port-Überprüfung über: Werkzeuge -> Port -> COM4 Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Jetzt kann das Programm auf Syntaxfehler überprüft werden. Dies geschieht durch: Sketch -> Prüfen/Übersetzen Copyright by H. Sporenberg-2016

Für Gleichstrommotoren Jetzt muss das Programm noch auf den Arduino geladen werden: Datei -> Hochladen mit Programmer Copyright by H. Sporenberg-2016

Mehrere Gleichstrommotoren Jetzt werden 2 Gleichstrommotoren an #1 und #2 angeschlossen. Dazu müssen zwei Variable (sinnvoll: motor1 und motor2) vereinbart werden. #include <AFMotor.h> AF_DCMotor motor1(1, MOTOR12_64KHZ); // create motor #1, 64KHz pwm AF_DCMotor motor2(2, MOTOR12_64KHZ); // create motor #2, 64KHz pwm void setup() { Serial.begin(9600); // set up Serial library at 9600 bps Serial.println("Motor test!"); motor1.setSpeed(200); motor2.setSpeed(200); // set the speed to 200/255 } void loop() { Serial.print("tick"); motor1.run(FORWARD); motor2.run(FORWARD); // turn it on going forward delay(5000); // 5 Sekunden Serial.print("tock"); motor1.run(BACKWARD); motor2.run(BACKWARD); // the other way delay(5000); // 5 Sekunden Serial.print("tack"); motor1.run(RELEASE); motor2.run(RELEASE); // stopped delay(5000);} // 5 Sekunden Motor_DC_02.ino Copyright by H. Sporenberg-2016

Mehrere Gleichstrommotoren Jetzt werden 4 Gleichstrommotoren an #1, #2, #3 und #4 angeschlossen. Dazu müssen 4 Variable (sinnvoll: motor1, motor2, motor3, motor4) vereinbart werden. #include <AFMotor.h> AF_DCMotor motor1(1, MOTOR12_64KHZ); // create motor #1, 64KHz pwm AF_DCMotor motor2(2, MOTOR12_64KHZ); // create motor #2, 64KHz pwm AF_DCMotor motor3(3, MOTOR34_64KHZ); // create motor #3, 64KHz pwm AF_DCMotor motor4(4, MOTOR34_64KHZ); // create motor #4, 64KHz pwm void setup() { Serial.begin(9600); // set up Serial library at 9600 bps Serial.println("Motor test!"); motor1.setSpeed(200); motor2.setSpeed(200); // set the speed to 200/255 motor3.setSpeed(200); motor4.setSpeed(200); // set the speed to 200/255 } Motor_DC_03.ino Copyright by H. Sporenberg-2016

Mehrere Gleichstrommotoren void loop() { motor1.run(FORWARD); motor2.run(FORWARD); delay(5000); motor1.run(BACKWARD); motor2.run(BACKWARD); motor1.run(RELEASE); motor2.run(RELEASE); motor3.run(FORWARD); motor4.run(FORWARD); motor3.run(BACKWARD); motor4.run(BACKWARD); motor3.run(RELEASE); motor4.run(RELEASE); } Zuerst drehen sich die beiden Motoren 1 und 2, die sich auf einer Achse befinden, 5 Sekunden nach vorn, 5 Sekunden rückwärts und werden dann abgeschaltet. Dann, nach 5 Sekunden, drehen sich die Motoren 3 und 4 (auf der anderen Achse) 5 Sekunden nach vorn, 5 Sekunden rückwärts. Dann dauert es 5 Sekunden bis sich der Vorgang wiederholt. Motor_DC_03.ino Copyright by H. Sporenberg-2016

4 Gleichstrommotoren Jetzt werden 4 Gleichstrommotoren an #1, #2. #3 und #4 angeschlossen. Dazu müssen vier Variable (hier: Motor_Left_Rear (Motor 1), Motor_Left_Rear (Motor 2), Motor_Right_Front (Motor 3) und Motor_Left_Front (Motor 4)) eingerichtet werden. /******************************************* * MotorDC_04.ino * Initial motor test for 4WD ********************************************/ const int LED_PIN = 13; const int speed = 60; // percent of maximum speed #include <AFMotor.h> // adafruit motor shield library (modified my mm) AF_DCMotor Motor_Left_Front(4, MOTOR34_1KHZ); // Motor 4 AF_DCMotor Motor_Right_Front(3, MOTOR34_1KHZ); // Motor 3 AF_DCMotor Motor_Left_Rear(1, MOTOR12_1KHZ); // Motor 1 AF_DCMotor Motor_Right_Rear(2, MOTOR12_1KHZ); // Motor 2 int pwm; void setup(){ Serial.begin(9600); blinkNumber(8); // open port while flashing. Needed for Leonardo only // scale percent into pwm range (0-255) pwm= map(speed, 0,100, 0,255); Motor_Left_Front.setSpeed(pwm); Motor_Right_Front.setSpeed(pwm); Motor_Left_Rear.setSpeed(pwm); Motor_Right_Rear.setSpeed(pwm);} Copyright by H. Sporenberg-2016

4 Gleichstrommotoren // run over and over void loop(){ Serial.println("rotate cw"); Motor_Left_Front.run(FORWARD); Motor_Left_Rear.run(FORWARD); Motor_Right_Front.run(FORWARD); Motor_Right_Rear.run(FORWARD); delay(5000); // run for 5 seconds Serial.println("stopped"); Motor_Left_Front.run(RELEASE); // stop the motors Motor_Right_Front.run(RELEASE); Motor_Left_Rear.run(RELEASE); // stop the motors Motor_Right_Rear.run(RELEASE); delay(5000); // stop for 5 seconds } // function to indicate numbers by flashing the built-in LED void blinkNumber( byte number) { pinMode(LED_PIN, OUTPUT); // enable the LED pin for output while(number--) { digitalWrite(LED_PIN, HIGH); delay(100); digitalWrite(LED_PIN, LOW); delay(400); }} Copyright by H. Sporenberg-2016

Make an Arduino-Controlled Robot
Das Buch von Michael Margolis Make an Arduino-Controlled Robot Die Datei für die verschiedenen Sketches ist eine ZIP-Datei und lautet: Arduino-Controlled-Robot-Sample-Code.zip und hat eine Größe von 137 kB. Man entzipped diese Datei und erhält als Verzeichnis: Arduino-Controlled-Robot-Sample-Code mit den entsprechenden Unterverzeichnissen. Dieses Verzeichnis kopiert man in: Programme\ arduino windows\arduino-1.5.8\libraries Copyright by H. Sporenberg-2016

Das Buch von Michael Margolis Make an Arduino-Controlled Robot Betrachtet wird hier die Überprüfung des 4-Rad-Roboters. Das Programm heißt MotorTest4wd.ino Copyright by H. Sporenberg-2016

Das Buch von Michael Margolis Make an Arduino-Controlled Robot Man lädt dieses Programm MotorTest4wd.ino in die IDE des Arduino. Man überprüft jetzt den Anschluss (Port -> COM4 oder COM3) und die Art des Mikrokontrollers (Arduino Uno). Wichtig ist, dass über Werkzeuge -> Programmer -> ArduinoISP eingestellt ist. Copyright by H. Sporenberg-2016

Das Buch von Michael Margolis Make an Arduino-Controlled Robot * MotorTest4wd.ino - Initial motor test for 4WD * robot rotates clockwise - (Left motors driven forward, right backward) const int LED_PIN = 13; const int speed = 60; // percent of maximum speed #include <AFMotor.h> // adafruit motor shield library (modified my mm) AF_DCMotor Motor_Left_Front(4, MOTOR34_1KHZ); // Motor 4 AF_DCMotor Motor_Right_Front(3, MOTOR34_1KHZ); // Motor 3 AF_DCMotor Motor_Left_Rear(1, MOTOR12_1KHZ); // Motor 1 AF_DCMotor Motor_Right_Rear(2, MOTOR12_1KHZ); // Motor 2 int pwm; void setup(){ Serial.begin(9600); blinkNumber(8); // open port while flashing. Needed for Leonardo only pwm= map(speed, 0,100, 0,255); // scale percent into pwm range (0-255) Motor_Left_Front.setSpeed(pwm); Motor_Right_Front.setSpeed(pwm); Motor_Left_Rear.setSpeed(pwm); Motor_Right_Rear.setSpeed(pwm); } Copyright by H. Sporenberg-2016

Das Buch von Michael Margolis Make an Arduino-Controlled Robot // run over and over void loop(){ Serial.println("rotate cw"); Motor_Left_Front.run(FORWARD); Motor_Left_Rear.run(FORWARD); Motor_Right_Front.run(BACKWARD); Motor_Right_Rear.run(BACKWARD); delay(5000); // run for 5 seconds Serial.println("stopped"); Motor_Left_Front.run(RELEASE); // stop the motors Motor_Right_Front.run(RELEASE); Motor_Left_Rear.run(RELEASE); // stop the motors Motor_Right_Rear.run(RELEASE); delay(5000); // stop for 5 seconds } // function to indicate numbers by flashing the built-in LED void blinkNumber( byte number) { pinMode(LED_PIN, OUTPUT); // enable the LED pin for output while(number--) { digitalWrite(LED_PIN, HIGH); delay(100); digitalWrite(LED_PIN, LOW); delay(400); }} Copyright by H. Sporenberg-2016

Der IR-Sensor Sharp GPY0A21YK
Der Sensor ermöglicht genaue oder relative Abstandsmessungen des Objekts zwischen 10 und 80 cm. Die Besonderheit besteht in der einfachen Ansteuerung. Der dreipolige Anschluss besteht nur aus Stromversorgung und einem Pin für das analoge Ausgangs-Signal. Es muss kein aufwändiges Taktsignal mehr generiert werden. Der Ausgangspin kann quasi sofort an einen analogen Port eines Mikrocontrollers angeschlossen werden. Die Entfernung kann dann einfach durch ein Umrechnung der Spannung bestimmt werden. Funktionsweise des Sharp GP2Y0A21YK0F Die Farbunabhängig ermittelt die Auswerteelektronik im Sensor die Entfernung und gibt sie über analoges Signal als Spannung aus. Dabei entsprechen 10 cm etwa 2,6 V und 80 cm. Anwendungsbeispiele sind neben Robotern auch Händetrockner, Einparkhilfe am Kfz, Toilettenspülung, Türöffner, Alarmanlagen, Wasseraufbereitung u.v.m. Copyright by H. Sporenberg-2016

Technische Daten Messbereich: 10 cm bis 80 cm Betriebsspannung VCC 5 Volt Vout: 0,4V bis 2,6V typ. (80cm – 10cm); Strom: 30 mA typ. Bezeichnung: GP2Y0A21YK0F Hersteller: Sharp Infrarot-Sensoren (IR) arbeiten mit elektromagnetischen Wellen (c = km/s). Die Frequenzen des IR-Boereichs liegen unterhalb des sichtbaren Lichts. Da die Echozeiten im Nanosekundenbereich liegen, wird bei IR-Sensoren ein anderes Verfahren zum Messen des Abstand verwendet als bei den Ultraschall-Sensoren. Bei der Triangulationsmethode wird der Zusammenhang zwischen den Winkeln in einem Dreieck und den Kantenlängen ausgenutzt. Das reflektierte Signal einer Infrarotdiode (IRED) trifft im Detektor je nach Winkel das Signal an einer anderen Stelle auf den PSD (position sensitive detector). Der PSD wandelt die Position in eine Spannung um. Copyright by H. Sporenberg-2016

Dateiname: IR_Sensor_Sharp_04.ino int i; int val; int redpin=0; void setup() { pinMode(redpin,OUTPUT); Serial.begin(9600); } void loop() { i=analogRead(redpin); val=(6762/(i-9))-4; Serial.println(val); delay(300); C:\Program Files\arduino windows \arduino \examples\ SharpGP2Y0A21_ArduinoExamples\ IR_Sensor_02\ IR_Sensor_Sharp_04 Copyright by H. Sporenberg-2016

Beim folgenden Programm werden 5 Werte eingelesen und der Mittelwert alle halbe Sekunde ausgegeben. /* Sharp GP2Y0A21YK0F infrared proximity sensor (#28995) Collects an average of five readings from the sensor and displays the resulting value about every half second. See the SharpGP2Y0A21_Simple demonstration for additional usage notes, including connection diagram. This example code is for the Arduino Uno and direct compatible boards, using the Arduino 1.0 or later IDE software. It has not been tested, nor designed for, other Arduino boards, including the Arduino Due. */ const int irSense = A0; // Connect sensor to analog pin A0 int distance = 0; void setup() { Serial.begin(9600); // Use Serial Monitor window } Copyright by H. Sporenberg-2016

void loop() { Serial.println(irRead(), DEC); // Call irRead function to read sensor // Print value in Serial Monitor delay(250); // Wait another 1/4 second for the next read // (Note: Because of delays built into the // irRead function the display of values will // be slower than in the SharpGP2Y0A21_Simple // sketch } // Take multiple readings, and average them out to reduce false readings int irRead() { int averaging = 0; // Holds value to average readings // Get a sampling of 5 readings from sensor for (int i=0; i<5; i++) { distance = analogRead(irSense); averaging = averaging + distance; delay(55); // Wait 55 ms between each read // According to datasheet time between each read // is -38ms +/- 10ms. Waiting 55 ms assures each // read is from a different sample distance = averaging / 5; // Average out readings return(distance); // Return value Copyright by H. Sporenberg-2016

Der Ultraschall-Sensor HC-SR04
Wenn der Abstand eines Objekts gemessen werden soll, benutzt man meist IR- oder Ultraschall-Sensoren. Als Ultraschall werden Wellen mit einer Frequenz über 20 kHz bezeichnet. Die meisten Ultraschall-Sensoren arbeiten bei einer Frequenz von 40 kHz. Diese senden aktiv ein Signal aus und messen die Laufzeit t, mit der das an einem Objekt reflektierte Signal zurückkommt. Aus dieser Zeit, der Echo-Laufzeit, lässt sich der Abstand d berechnen. d = t*c/2. Hierbei ist c die Ausbreitungsgeschwindigkeit der Schallwelle (c = 343 m/s bei 20 Co). Die Abhängigkeit von der Temperatur wird aber vernachlässigt und ein Näherungswert von 340 m/s verwendet. Copyright by H. Sporenberg-2016

Ein 10 us langer Impuls am Trigger-Pin löst 8 40kHz Ultraschall Impulse aus. Die gemessene Ent-fernung ist proportional zur Echo-Puls-Weite am Signal Pin und kann durch die folgende Formel berechnet werden: Distanz = Pulsweite Signal-PIN / 29 /2 (Die Schallschwindigkeit beträgt ca. 29us/cm und das Signal muss den doppelten Weg zum Hindernis und zurück laufen). Copyright by H. Sporenberg-2016

Technische Daten – HC-SR04 Betriebsspannung: 5 V Stromaufnahme: 15 mA Öffnungswinkel: <= 15 Grad Entfernung: 2 bis 450 cm Genauigkeit: max. 0,3 cm Eingangs Triggersignal: 10 s TTL High Ausgangssignal: TTL Low aktiv Copyright by H. Sporenberg-2016

const uint8_t trigPin = 8; const uint8_t echoPin = 9; void setup() { // initialize serial communication: Serial.begin(9600); } void loop(){ uint32_t duration; // duration of the round trip uint32_t cm; // distance of the obstacle // The sensor is triggered by a HIGH pulse of 10 or more microseconds. // Give a short LOW pulse beforehand to ensure a clean HIGH pulse: pinMode(trigPin, OUTPUT); digitalWrite(trigPin, LOW); delayMicroseconds(3); // Start trigger signal digitalWrite(trigPin, HIGH); delayMicroseconds(10); // Read the signal from the sensor: a HIGH pulse whose // duration is the time (in microseconds) from the sending // of the ping to the reception of its echo off of an object. pinMode(echoPin, INPUT); duration = pulseIn(echoPin, HIGH); // convert the time into a distance cm = (uint32_t)((duration<<4)+duration)/1000.0; // cm = 17 * duration/1000 Serial.print(cm); Serial.print(" centimeters"); Serial.println ); delay(100); } Copyright by H. Sporenberg-2016

int trigPin = 8; int echoPin = 9; float v= *20; // m/s void setup() { Serial.begin(9600); pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); } float distanceM(){ // Sendet Schallimpuls digitalWrite(trigPin, LOW); delayMicroseconds(3); digitalWrite(trigPin, HIGH); delayMicroseconds(5); digitalWrite(trigPin, LOW); // Lauscht auf Echo float tUs = pulseIn(echoPin, HIGH); // Mikrosekunden float t = tUs / / / 2; // s float d = t*v; // m return d*100; // cm void loop() { int d=distanceM(); Serial.println(d, DEC); delay(200); // ms Dateiname: UltraSchall_03.ino Copyright by H. Sporenberg-2016

int trigger=8; int echo=9; long dauer=0; long entfernung=0; void setup(){ Serial.begin (9600); pinMode(trigger, OUTPUT); pinMode(echo, INPUT);} void loop(){ digitalWrite(trigger, LOW); delay(5); digitalWrite(trigger, HIGH); delay(10); dauer = pulseIn(echo, HIGH); entfernung = (dauer/2) / 29.1; if (entfernung >= 500 || entfernung <= 0) { Serial.println("Kein Messwert");} else { Serial.print(entfernung); Serial.println(" cm");} delay(1000); } Dateiname: UltraSchall_04.ino Copyright by H. Sporenberg-2016

Sketches mit Libraries – NewPing.h und Ultrasonic.h Für den Ultraschall-Sensor HC-SR04 gibt es zwei Libraries, die für die Programmierung eingesetzt werden können: 1.Ultrasonic.h 2.NewPing.h Bei der Library Ultrasonic.h muss darauf geachtet werden, dass diese mit der IDE des Arduino kompatibel ist. Zur Zeit (August 2015) hat die IDE die Version Dazu muss die Library mit dem Namen Ultrasonic-HC-SR4-master.zip (7 kB) heruntergeladen werden. Die anderen Dateien ergeben Fehlermeldungen und können nicht verwendet werden. Wichtige Methoden der Library Ultrasonic.h: Ultrasonic ultrasonic(8,9); // (Trig PIN, Echo PIN) Ultrasonic ultrasonic(8,9,3000); // (Trig PIN, Echo PIN, Max.TimeOut in µsec ) Copyright by H. Sporenberg-2016

Sketch mit der Library Ultrasonic.h Beispiel #include <Ultrasonic.h> Ultrasonic ultrasonic(8,9); void setup() { Serial.begin(9600); } void loop(){ Serial.print(ultrasonic.Ranging(INC)*0.0254); Serial.println(" m"); delay(100); Achtung: Die Baudrate muss auf 9600 eingestellt sein, andernfalls funktioniert die Ausgabe nicht (falsche Zeichen werden dargestellt). Copyright by H. Sporenberg-2016

Sketches mit Libraries – Ultrasonic.h Methoden Ultrasonic(int T_PIN, int E_PIN); - Create the Ultrasonic object void setupPINs(); - If you change any PIN value, you’ll need to run this method to update it void setTriggerPIN(int T_PIN); - Set the TRIGGER_PIN void setEchoPIN(int E_PIN); - Set the ECHO_PIN int getTriggerPIN(); - Get the TRIGGER_PIN int getEchoPIN(); - Get the ECHO_PIN float readDistanceCM(); - Read the distance in CM float readDistanceRaw(); - Read the raw value returned by the sensor Copyright by H. Sporenberg-2016

Sketch mit der Include-Datei NewPing.c: NewPingExample.ino / Example NewPing library sketch that does a ping about 20 times per second. #include <NewPing.h> #define TRIGGER_PIN 8 // Arduino pin tied to trigger pin on the ultrasonic sensor. #define ECHO_PIN // Arduino pin tied to echo pin on the ultrasonic sensor. #define MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at cm. NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance. void setup() { Serial.begin(9600); // Open serial monitor at 9600 baud to see ping results. } void loop() { delay(50); // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings. unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS). Serial.print("Ping: "); Serial.print(uS / US_ROUNDTRIP_CM); // Convert ping time to distance in cm and print result (0 = outside set distance range) Serial.println("cm"); Copyright by H. Sporenberg-2016

Wenn der Abstand eines Objekts gemessen werden soll, benutzt man meist IR- oder Ultraschall-Sensoren. Als Ultraschall werden Wellen mit einer Frequenz über 20 kHz bezeichnet. Die meisten Ultraschall-Sensoren arbeiten bei einer Frequenz von 40 kHz. Die Ultraschall-Abstands-Sensoren senden aktiv ein Signal aus und messen die Laufzeit t, mit der das an einem Objekt reflektierte Signal zurückkommt. Aus dieser Zeit, der Echo-Laufzeit, lässt sich der Abstand d berechnen. d = t*c/2. Hierbei ist c die Ausbreitungsgeschwindigkeit der Schallwelle (c = 343 m/s bei 20 Co). Die Abhängigkeit von der Temperatur wird aber vernachlässigt und ein Näherungswert von 340 m/s verwendet. Copyright by H. Sporenberg-2016

Der PIR-Infrarot Sensor – HC-SR501
Aufbau und Funktionsweisess (Quelle: elv-Seite) Der PIR-Infrarot Sensor – HC-SR501 PIR ist die Abkürzung für (engl.): passiv infrared Ein in Bewegungsmeldern üblicherweise eingesetzter 2-Element-Pyrosensor besteht aus einer Kombination von zwei gemeinsam mit einer FET-Verstärker-/Pufferstufe in einem TO-5-Gehäuse untergebrachten pyrotechnischen Keramikelementen mit einem IR-Filter. Dieser passiv arbeitende Sensor empfängt von einem Gegenstand oder Lebewesen abgestrahlte Wärmeenergie. Die Arbeitsweise dieses Sensors ist etwa vergleichbar mit der eines Kondensators. Auch hier finden wir zwei Folien, die (durch den Produktionsprozess vorgegeben) verschiedene elektrische Ladungen an ihrer Oberfläche enthalten. Trifft Wärmestrahlung eines bestimmten Frequenzbereichs auf diese Folien, wird deren Polarisation verschoben und somit eine von der normalen (stabilen) elektrischen Ladung differierende elektrische Spannung erzeugt, die über Elektroden auf den Folien abgegriffen und über die nachfolgende Verstärkerelektronik ausgewertet wird. Copyright by H. Sporenberg-2016

Aufbau und Funktionsweisess (Quelle: elv-Seite) Der PIR-Infrarot Sensor – HC-SR501 Wie ein solcher Sensor im Prinzip aufgebaut ist, zeigt der hier vorge-stellte 2-Element-Sensor. Jedes Element entspricht der besprochenen kondensatorartigen Sensor-Anordnung. Jetzt kann man bereits erken-nen, warum sich dieser 2-Element-Sensor so gut für die Bewegungs-erfassung eignet. Denn beide Sensorelemente befinden sich nicht am gleichen Platz, sondern nebeneinander. Damit ist eine besonders gute Differenzierung zwischen Hintergrund und vorbeilaufendem Menschen möglich. Denn erst dann, wenn die Sensor-Elemente abweichende Wärmestrahlung empfangen, entsteht auch eine genügend hohe Än-derung der erzeugten Spannung zur Auswertung durch die nach-folgende Verstärkerelektronik. Eine Filteranordnung vor den Sensorelementen eliminiert den Einfluss von störendem Fremdlicht. Dies alles ermöglicht jedoch noch keine effektive optische Richtungsdifferen-zierung. Durch die Anordnung im Gehäuse des Sensors und die spektrale Empfindlichkeit der Folienoberfläche je nach Einfallswinkel der Wärmestrahlung ist der Erfassungsbereich des reinen Sensors relativ schmal. Größer wird dieser erst durch eine vorgeschaltete Lin-senanordnung. Diese teilt den Erfassungsbereich in viele verschiedene Zonen auf. Jede Linse „sieht“ nun einen genau abgegrenzten Bereich ihrer Umgebung und lenkt die dort auftretende Wärmestrahlung direkt auf eines der beiden Sensorelemente. Bewegt sich jetzt die Wärmequelle Mensch durch die einzelnen Zonen, werden also ganz unterschied-liche Ladungsdifferenzen auf den beiden Sensorelementen erzeugt und man kann eine Bewegung über einen großen Bereich und in relativ großer Entfernung registrieren. Die folgende Auswerteelektronik hat nun die Aufgabe, die geringen Spannungsdifferenzen zu verstärken und die gewünschte Reaktion darauf zu erzeugen. Copyright by H. Sporenberg-2016

Aufbau und Funktionsweisess (Quelle: wikipedia) Der PIR-Infrarot Sensor – HC-SR501 Der PIR-Sensor reagiert unter Ausnutzung der Pyroelektrizität seiner Empfängerfläche auf eine Temperaturänderung, bewirkt durch eine Strahlungsflussänderung (hauptsächlich durch Wärmestrahlung im mittleren Infrarot; Wellenlänge zirka 10 µm) von Menschen, Tieren und Kraftfahrzeugen in seiner näheren Umgebung. Er reagiert nicht auf statische Wärmeunterschiede, die auf natürliche Weise hervorgerufen werden, wie zum Beispiel durch Sonneneinstrahlung – er kann nur sich ändernde Signale wahrnehmen, beispielsweise wenn ein Mensch in den Detektionsbereich des Sensors eintritt. Vor dem eigentlichen Sensor liegt – in Brennweitenabstand – eine kugelige oder zylindrisch gewölbte Kuppel aus kleinen Sammellinsen aus visuell weißlich-trübem Kunststoff, der jedoch im Infraroten klar durchsichtig ist. Diese Vielfachlinse sammelt infrarotes Licht aus einer entsprechenden Anzahl diskreter Richtungssektoren auf die kleine Sensorfläche. Sichtbares Licht wird mehr zurückgestreut. Der Sensor sieht je nach Linsenanordnung die Umgebung wie durch gespreizte Finger, (senkrechte) Jalousieschlitze oder den Raster eines Lochblechs. Bewegt sich nun ein Gegenstand oder Lebewesen mit einer Oberflächentemperatur genügend höher (selten: tiefer) als der Hintergrund quer durch diese Fächer aus Sichtsektoren, und ist die warme, im Infrarot daher hellere Fläche, günstigerweise etwa so breit wie ein einzelner Sichtsektor dort, so spürt der Sensor die zeitliche Abfolge warm-kalt-warm. Denn die Wärmequelle ist mal sichtbar, verschwindet dann im Sichtschatten eines „Fingers“ und taucht im Sehschlitz des nächsten Fingerspalts wieder auf. Die – durch Wärmekapazität etwas verzögerte – Temperaturänderung am Sensor bewirkt ein elektrisches Signal, das verarbeitet und verstärkt wird, um über ein Relais etwa Licht einzuschalten. Copyright by H. Sporenberg-2016

Aufbau und Funktionsweisess (Quelle: wikipedia) Der PIR-Infrarot Sensor – HC-SR501 Neben Querbewegung zu den Sichtsektorstreifen wird auch das erstmalige Eintreten oder aber das ausreichend rasche Näherkommen (also „Größerwerden“) in einen solchen Streifen detektiert. Bewegungsmelder sind meist in der Empfindlichkeit einstellbar und mit einem ebenfalls justierbaren Dämmerungsschalter gekoppelt. Durch Vorsatzblenden kann ein Teil der Sichtsektoren abgedeckt und das Sensormodul eventuell auch verschwenkt werden. Ein Sensor, der selbst im Leuchtenschatten liegt, wird das Ausgehen dieser Leuchte per Zeitschaltung kaum unerwünscht als Auslösesignal werten. Radfahrer mit exponierter Haut werden von Bewegungsmeldern oft weiter gesehen als geschlossene Pkw mit Wärmeschutzglas und luftgekühlter Karosserie. Abgekühlte, gut isolierende Winterkleidung mit Kapuze und gesenktes Gesicht kann auch die Körperwärme eines Menschen verstecken. PIR-Sensoren empfangen ausschließlich von Objekten ausgesandte Strahlen und senden selbst keine Strahlung aus, was durch die Benennung Passiv-Infrarot-Sensor zum Ausdruck kommt. PIR-Sensoren reagieren schlecht, wenn sich ein Objekt auf sie zu oder von ihnen weg bewegt. Dies liegt an deren Funktionsprinzip, da die Bewegungserkennung aufgrund eines Temperaturwechsels auf der Sensorfläche erfolgt und Bewegungen quer zum Erfassungsbereich aufgrund des vorwiegend quer angeordneten Linsenbereichs besser erkannt werden können. Durch sich aufwärmende Fußbodenheizungen können PIR-Melder fälschlicherweise ausgelöst werden. Copyright by H. Sporenberg-2016

Sketch Der PIR-Infrarot Sensor – HC-SR501 /* PIR sensor tester */ int ledPin = 13; // choose the pin for the LED int inputPin = 2; // choose the input pin (for PIR sensor) int pirState = LOW; // we start, assuming no motion detected int val = 0; // variable for reading the pin status void setup() { pinMode(ledPin, OUTPUT); // declare LED as output pinMode(inputPin, INPUT); // declare sensor as input Serial.begin(9600); } void loop(){ val = digitalRead(inputPin); // read input value if (val == HIGH) { // check if the input is HIGH digitalWrite(ledPin, HIGH); // turn LED ON if (pirState == LOW) { // we have just turned on Serial.println("Motion detected!"); // We only want to print on the output change, not state pirState = HIGH; } else { digitalWrite(ledPin, LOW); // turn LED OFF if (pirState == HIGH){ // we have just turned of Serial.println("Motion ended!"); // We only want to print on the output change, not state pirState = LOW; } } } Dateiname: PIR_Sensor_01.ino Copyright by H. Sporenberg-2016

Sketch Der PIR-Infrarot Sensor – HC-SR501 Copyright by H. Sporenberg-2016

Sketch Der PIR-Infrarot Sensor – HC-SR501 int sensorPin=2; int led=13; boolean sensorValue=false; void setup() { pinMode(led,OUTPUT); pinMode(sensorPin,INPUT); Serial.begin(9600); } void loop() { sensorValue=digitalRead(sensorPin); delay(50); if(sensorValue==HIGH){ digitalWrite(13,HIGH); delay(100);} else{ digitalWrite(13,LOW); delay(50);} Dateiname: PIR_Sensor_02.ino Copyright by H. Sporenberg-2016

Sketch Der PIR-Infrarot Sensor – HC-SR501 // The Parallax PIR Sensor is an easy to use digital infrared motion sensor module. // ( // The sensor's output pin goes to HIGH if motion is present. // However, even if motion is present it goes to LOW from time to time, // which might give the impression no motion is present. // This program deals with this issue by ignoring LOW-phases shorter than a given time, // assuming continuous motion is present during these phases. //VARIABLE // the time we give the sensor to calibrate // (10-60 secs according to the datasheet) int calibrationTime = 30; // the time when the sensor outputs a low impulse long unsigned int lowIn; // the amount of milliseconds the sensor has to be low // before we assume all motion has stopped long unsigned int pause = 5000; boolean lockLow = true; boolean takeLowTime; int pirPin = 3; //the digital pin connected to the PIR sensor's output int ledPin = 13; Dateiname: PIR_Sensor_03.ino Copyright by H. Sporenberg-2016

Sketch Der PIR-Infrarot Sensor – HC-SR501 void setup(){ Serial.begin(9600); pinMode(pirPin, INPUT); pinMode(ledPin, OUTPUT); digitalWrite(pirPin, LOW); //give the sensor some time to calibrate Serial.print("calibrating sensor "); for(int i = 0; i < calibrationTime; i++){ Serial.print("."); delay(1000); } Serial.println(" done"); Serial.println("SENSOR ACTIVE"); delay(50); Dateiname: PIR_Sensor_03.ino Copyright by H. Sporenberg-2016

Sketch Der PIR-Infrarot Sensor – HC-SR501 void loop(){ if(digitalRead(pirPin) == HIGH){ digitalWrite(ledPin, HIGH); //the led visualizes the sensors output pin state if(lockLow){ //makes sure we wait for a transition to LOW // before any further output is made: lockLow = false; Serial.println("---"); Serial.print("motion detected at "); Serial.print(millis()/1000); Serial.println(" sec"); delay(50); } takeLowTime = true; Dateiname: PIR_Sensor_03.ino Copyright by H. Sporenberg-2016

Sketch Der PIR-Infrarot Sensor – HC-SR501 if(digitalRead(pirPin) == LOW){ digitalWrite(ledPin, LOW); //the led visualizes the sensors output pin state if(takeLowTime){ lowIn = millis(); //save the time of the transition from high to LOW takeLowTime = false; //make sure this is only done at the start of a LOW phase } //if the sensor is low for more than the given pause, //we assume that no more motion is going to happen if(!lockLow && millis() - lowIn > pause){ //makes sure this block of code is only executed again after //a new motion sequence has been detected lockLow = true; Serial.print("motion ended at "); //output Serial.print((millis() - pause)/1000); Serial.println(" sec"); delay(50); Dateiname: PIR_Sensor_03.ino Copyright by H. Sporenberg-2016

Sketch Der PIR-Infrarot Sensor – HC-SR501 int ledPin = 13; // choose the pin for the LED int inputPin = 2; // choose the input pin (for PIR sensor) int pirState = LOW; // we start, assuming no motion detected int val = 0; // variable for reading the pin status void setup() { pinMode(ledPin, OUTPUT); // declare LED as output pinMode(inputPin, INPUT); // declare sensor as input Serial.begin(9600); } Dateiname: PIR_Sensor_04.ino Copyright by H. Sporenberg-2016

Sketch Der PIR-Infrarot Sensor – HC-SR501 void loop(){ val = digitalRead(inputPin); // read input value if (val == HIGH) { // check if the input is HIGH digitalWrite(ledPin, HIGH); // turn LED ON if (pirState == LOW) { // we have just turned on Serial.println("Motion detected!"); // We only want to print on the output change, not state pirState = HIGH; } } else { digitalWrite(ledPin, LOW); // turn LED OFF if (pirState == HIGH){ // we have just turned of Serial.println("Motion ended!"); // We only want to print on the output // change, not state pirState = LOW; } } Dateiname: PIR_Sensor_04.ino Copyright by H. Sporenberg-2016

Die IRremote.h – Library
Sketch Die IRremote.h – Library Die IDE – Version ist nicht kompatibel mit der mitgelieferten Library IRremote.c. Man erhält die Fehlermeldung Fehlermeldung: The IR Receiver program worked fine with the 1.01 IDE but would not compile with r2 the error was as follows: C:\Program Files (x86)\Arduino\libraries\RobotIRremote\src\IRremoteTools.cpp:5: error: 'TKD2' was not declared in this scope Copyright by H. Sporenberg-2016

Die IRremote.h – Library
Sketch Die IRremote.h – Library 1.Ein Programm, das die Library IRremote.h benutzt wird in die IDE geladen. 2.Mit Hilfe von Sketch/ Prüfen/Übersetzen wird die Syntax des Sketch überprüft. Man erhält eine Fehlermeldung. 3.Beim Hochladen auf den Arduino erhält man dann folgende Fehlermeldung :\Program Files (x86)\Arduino\libraries\RobotIRremote\src\IRremoteTools.cpp:5:16: error: 'TKD2' was not declared in this scope int RECV_PIN = TKD2; // the pin the IR receiver is connected to CODE: include <IRremote.h> include <IRremoteInt.h> include <IRremoteTools.h> void setup() { // put your setup code here, to run once: } void loop() { // put your main code here, to run repeatedly: } Hier ist die Lösung: Offensichtlich erzeugt die Standard-Library den Fehler, da sie mit der IDE nicht kompatibel ist. Und so wir das Problem gelöst: 1.Das Verzeichnis mit der Library wird gelöscht. (RobotIRremote sollte leicht zu finden sein). 2.Dann wird die neue Library installiert, die man von folgender Seite downloaden kann: Die Datei heißt: Arduino-IRremote-master.zip – 67 kB

Die IRremote.h – Library – Receiving -Befehle
Sketch Die IRremote.h – Library – Receiving -Befehle IRrecv irrecv(receivePin) Create the receiver object, using a name of your choice. irrecv.enableIRIn() Begin the receiving process. This will enable the timer interrupt which consumes a small amount of CPU every 50 µs. irrecv.decode(&results) Attempt to receive a IR code. Returns true if a code was received, or false if nothing received yet. When a code is received, information is stored into "results". results.decode_type: Will be one of the following: NEC, SONY, RC5, RC6, or UNKNOWN. results.value: The actual IR code (0 if type is UNKNOWN) results.bits: The number of bits used by this code results.rawbuf: An array of IR pulse times results.rawlen: The number of items stored in the array irrecv.resume() After receiving, this must be called to reset the receiver and prepare it to receive another code. irrecv.blink13(true) Enable blinking the LED when during reception. Because you can't see infrared light, blinking the LED can be useful while troubleshooting, or just to give visual feedback.

Die IRremote.h – Library – Receiving -Befehle
Sketch Die IRremote.h – Library – Receiving -Befehle #include <IRremote.h> const int RECV_PIN = 3; IRrecv irrecv(RECV_PIN); decode_results results; void setup() { Serial.begin(9600); irrecv.enableIRIn(); // Start the receiver irrecv.blink13(true); } void loop() { if (irrecv.decode(&results)) { if (results.decode_type == NEC) { Serial.print("NEC: "); } else if (results.decode_type == SONY) { Serial.print("SONY: "); } else if (results.decode_type == RC5) { Serial.print("RC5: "); } else if (results.decode_type == RC6) { Serial.print("RC6: "); } else if (results.decode_type == UNKNOWN) { Serial.print("UNKNOWN: "); } Serial.println(results.value, HEX); irrecv.resume(); // Receive the next value } } Copyright by H. Sporenberg-2016

Die IRremote.h – Library Transmitting-Befehle
Sketch Die IRremote.h – Library Transmitting-Befehle IRsend irsend; Create the transmit object. A fixed pin number is always used, depending on which timer the library is utilizing. irsend.sendNEC(IRcode, numBits); Send a code in NEC format. irsend.sendSony(IRcode, numBits); Send a code in Sony format. irsend.sendRC5(IRcode, numBits); Send a code in RC5 format. irsend.sendRC6(IRcode, numBits); Send a code in RC6 irsend.sendRaw(rawbuf, rawlen, frequency); Send a raw code. Normally you would obtain the contents of rawbuf and rawlen by using the receiver many times and averaging the results. Some adjustments may be necessary for best performance. The frequency is the expected bandpass filter frequency at the receiver, where 38 is the most commonly used. Copyright by H. Sporenberg-2016

IR-Remote #include <IRremote.h>
Sketch IR-Remote #include <IRremote.h> int RECV_PIN = 3; //define input pin on Arduino IRrecv irrecv(RECV_PIN); decode_results results; void setup() { Serial.begin(9600); irrecv.enableIRIn(); // Start the receiver } void loop() { if (irrecv.decode(&results)) { Serial.println(results.value, HEX); irreceiver.resume(); // Receive the next value Dateiname: IRremote_02.ino Copyright by H. Sporenberg-2016

Sketch IR-Remote Mit Hilfe eines Infrarotempfängers kann das Arduinoboard die Befehle einer Infrarotfernbedienung auswerten. Die Daten werden dabei in Form von Infrarotlicht von der Fernbedienung zum Empfänger gesendet. Da unser Auge dieses Licht nicht wahrnehmen kann, können wir dieses Licht nicht sehen. Mit einem kleinen Trick kann man jedoch testen, ob bspw. eine Fernbedienung ein Infrarotsignal sendet. Dazu nimmt man eine Digitalkamera (zum Beispiel die vom Smartphone) und betrachtet über das Display die Infrarotdiode. Wenn nun die Fernbedienung betätigt wird, kann man die Infrarotdiode leuchten sehen. Das liegt daran, dass die Sensoren von Digitalkameras das Infrarotlicht wahrnehmen und darstellen können. Das Licht flackert leicht, da die Infrarotdiode sehr schnell an- und aus geht. Dahinter verbirgt sich ein ganz bestimmter Rhythmus, anhand dessen der Infrarotempfänger später auswerten kann, welche Taste an der Fernbedienung gedrückt wurde. Copyright by H. Sporenberg-2016

IR-Remote Sketch #include <IRremote.h> RECV_PIN = 3;
/* * IRremote: IRrecvDemo - demonstrates receiving IR codes with IRrecv * An IR detector/demodulator must be connected to the input RECV_PIN. * Version 0.1 July, 2009 * Copyright 2009 Ken Shirriff * */ #include <IRremote.h> RECV_PIN = 3; IRrecv irrecv(RECV_PIN); Das Programm greift an dieser Stelle auf eine „Library“ zurück. Das erleichtert einem viel Arbeit. Denn das Infrarotlicht wird mit einem Code verschlüsselt gesendet. Um diesen Code selber auszulesen und in passende Werte umzuwandeln, wären sehr viele Zeilen Code erforderlich. Der Kontakt der am Infrarotsensor die Daten ausgibt, wird mit Pin 3 des Arduinoboards verbunden. An dieser Stelle wird ein Objekt definiert, dass den Infrarotsensor an Pin 3 ausliest. Copyright by H. Sporenberg-2016

IR-Remote Sketch decode_results results; void setup() {
Serial.begin(9600); pinMode (13, OUTPUT); irrecv.enableIRIn(); } Dieser Befehl sorgt dafür, dass die Daten, die per Infrarot eingelesen werden unter „results“ abgespeichert werden. Im Setup wird die Serielle Verbindung gestartet, damit man sich die Empfangenen Daten der Fernbedienung per seriellen Monitor ansehen kann. Dieser Befehl initialisiert den Infrarotempfänger. Copyright by H. Sporenberg-2016

IR-Remote Sketch void loop() { if (irrecv.decode(&results)) {
Serial.println(results.value, DEC); irrecv.resume(); } Der loop-Teil fällt durch den Rückgriff auf die „library“ sehr kurz aus. Wenn Daten empfangen wurden, werden sie als Dezimalzahl (DEC) an den Serial-Monitor ausgegeben. Der nächste Wert soll vom IR-Empfänger eingelesen werden. Ein Druck auf die Taste „1“ der Infrarotfernbedienung bewirkt, dass am Serialmonitor die Zahl „ “ ausgegeben wird. Dies ist der entschlüsselte Zahlencode, der sich hinter dieser Taste verbirgt. Wenn man die Taste dauerhaft gedrückt hält, erscheint permanent die Zahl „ “. Dies ist der Code der angibt, dass eine Taste dauerhaft gedrückt wird. Diese Zahl ist unabhängig davon, welche Taste gedrückt wird. Es können aber auch noch andere Zahlen auftauchen, falls eine Taste nur ganz kurz oder pulsierend gerückt wird. In dem Fall kann der Sensor keinen eindeutigen Wert auslesen. Copyright by H. Sporenberg-2016

IR-Remote – Erweiterung
Sketch IR-Remote – Erweiterung #include <IRremote.h> int RECV_PIN = 3; IRrecv irrecv(RECV_PIN); decode_results results; void setup() { Serial.begin(9600); pinMode (13, OUTPUT); digitalWrite(13, LOW); irrecv.enableIRIn(); } Der loop-Teil fällt durch den Rückgriff auf die „library“ sehr kurz aus. Wenn Daten empfangen wurden, werden sie als Dezimalzahl (DEC) an den Serial-Monitor ausgegeben. Der nächste Wert soll vom IR-Empfänger eingelesen werden. An Pin 13 wird eine LED angeschlossen. Diese soll zunächst aus sein. Erweiterung des Programms: Beim Drücken der Taste“1“ soll eine LED an gehen und beim Drücken der Taste“2“ soll die LED aus gehen. Copyright by H. Sporenberg-2016

Sketch IR-Remote – Erweiterung void loop() { if (irrecv.decode(&results)) { Serial.println(results.value, DEC); if (results.value == ) {digitalWrite (13, HIGH);} if (results.value == ) {digitalWrite (13, LOW);} irrecv.resume(); // Receive the next value } Wenn der Infrarotempfänger die Zahl „ “ ausgelesen hat (Entsprechend der Taste“1“ der Fernbedienung), soll die LED an gehen. Wenn der Infrarotempfänger die Zahl „ “ ausgelesen hat (Entsprechend der Taste“2“ der Fernbedienung), soll die LED aus gehen. Copyright by H. Sporenberg-2016

Sketch IR-Remote – Erweiterung #include <IRremote.h> int RECEIVE_PIN= 3; IRrecv irreceiver(RECEIVE_PIN); decode_results results; void setup() { Serial.begin(9600); irreceiver.enableIRIn(); // Start the receiver } void loop() { if (irreceiver.decode(&results)) { Serial.println(results.value, HEX); } Be sure to change the RECEIVE_PIN to yours. We are using the IRremote.h infrared sensor library which is included in every Arduino environment. Open a serial connection and try to press some buttons on your remote control. Every key outputs one hex value. You may notice different hex values for one button. This happens when you´re too far away from your sensor. Furthermore, when you “long-press” any key you will get the correct hex value only one time – “FFFFFF” will follow. This indicates your long press. Don´t forget to implement this behavior. Copyright by H. Sporenberg-2016

IR-Remote – Verkabelung
Sketch IR-Remote – Verkabelung Copyright by H. Sporenberg-2016

Bluetooth Sketch Verkabelung HC-06 VCC -> Arduino +5V
HC-06 GND -> Arduino GND HC-06 TXD -> Arduino Pin 0 (RX) HC-06 RXD -> Arduino Pin 1 (TX) Copyright by H. Sporenberg-2016

Sketch Bluetooth This code enables you to send a string to the Arduino via Bluetooth and get an echo back on your serial monitor. String message; //string that stores the incoming message void setup(){ Serial.begin(9600); //set baud rate } void loop(){ while(Serial.available()) {//while there is data available on the serial monitor message+=char(Serial.read()); //store string from serial command } if(!Serial.available()) { if(message!="") {//if data is available Serial.println(message); //show the data message=""; //clear the data } delay(5000); //delay Copyright by H. Sporenberg-2016

Bluetooth Sketch LED Code
This code allows you to switch on and off an LED using by sending a command to the Arduino via Bluetooth. char blueToothVal; //VALUE SENT OVER VIA BLUETOOTH char lastValue; //STORES LAST STATE OF DEVICE (ON/OFF) void setup) { Serial.begin(9600); pinMode(13,OUTPUT); } void loop(){ if(Serial.available()) { //IF THERE IS DATA BEING RECIEVED blueToothVal=Serial.read(); //READ IT } if (blueToothVal==‚n') { //IF VALUE FROM BLUETOOTH SERIAL IS n digitalWrite(13,HIGH); //SWITCH ON LED if (lastValue!=‚N') Serial.println(F("LED IS ON")); //PRINT LED IS ON lastValue=blueToothValue; else if (blueToothValue==‚f') { //IF VALUE FROM BLUETOOTH SERIAL IS n digitalWrite(13,LOW); //TURN OFF LED if (lastValue!=‚f') Serial.println(F("LED IS OFF")); //PRINT LED IS OFF lastValue=blueToothVal; delay(1000); } Copyright by H. Sporenberg-2016

Bluetooth Sketch LED Code
This code allows you to switch on and off an LED using by sending a command to the Arduino via Bluetooth. char btchar; int led = 13; void setup() { Serial.begin(9600); pinMode(led,OUTPUT); } void loop(){ if(Serial.available()) { btchar=Serial.read(); } if (btchar=='1') { digitalWrite(led,HIGH); } else if (btchar=='0') { digitalWrite(led,LOW); } delay(10); Copyright by H. Sporenberg-2016

433MHz RF Modul Sketch LED Code
This code allows you to switch on and off an LED using by sending a command to the Arduino via Bluetooth. Copyright by H. Sporenberg-2016

Sketch 433MHz RF Modul Copyright by H. Sporenberg-2016

433MHz RF Modul Senden Sketch
Als erstes wird der Sender auf den Uno gesteckt. Die Pins können die Stromversorgung übernehmen, das spart ein extra Steckbrett ein. D5 ist GND D6 ist VCC / 5V D7 ist Datenausgang Copyright by H. Sporenberg-2016

433MHz RF Modul Senden – der Sketch Sketch // Verbindungen zum Uno
// GND > D5 // VCC > D6 // Daten > D7 int led = 13; int data = 7; void setup(){ Serial.begin(38400); pinMode(led, OUTPUT); pinMode(5, OUTPUT); digitalWrite(5, LOW); // GND 0V pinMode(6, OUTPUT); digitalWrite(6, HIGH); // VCC 5V pinMode(data, OUTPUT); digitalWrite(data, LOW); // Daten } void loop() { // H/L im Sekundentakt ausgeben digitalWrite(data, LOW); digitalWrite(led, LOW); delay(500); digitalWrite(data, HIGH); digitalWrite(led, HIGH); } Es werden je 500 Millisekunden lang 1 und 0 gesendet. Zur Kontrolle blinkt die LED entsprechend. Copyright by H. Sporenberg-2016

433MHz RF Modul Empfangen Sketch
Der Empfänger wird auf einen 2. Uno gesteckt. Die Pins können wieder die Stromversorgung übernehmen. D4 ist GND D5 ist der Dateneingang D6 ist ein Eingang, wird aber nicht verwendet D7 ist VCC / 5V Copyright by H. Sporenberg-2016

433MHz RF Modul Empfangen – der Sketch Sketch // Verbindungen zum Uno
// GND > D4 // Data > D5 // Input > D6 // VCC > D7 int led = 13; int data = 5; void setup(){ Serial.begin(38400); pinMode(led, OUTPUT); pinMode(4, OUTPUT); digitalWrite(4, LOW); // GND 0V pinMode(data, INPUT); digitalWrite(data, LOW); // Daten pinMode(6, INPUT); // wird hier nicht verwendet pinMode(7, OUTPUT); digitalWrite(7, HIGH); // VCC 5V } void loop() { // data lesen und LED entsprechend schalten digitalWrite(led,digitalRead(data)); delay(50); } Das Empfängerprogramm soll die LED entsprechend leuchten lassen als Bestätigung für den Empfang. Die Datenleitung wird alle 50ms, also 20x in der Sekunde abgefragt und das Ergebnis wird auf den LED Ausgang gegeben. Damit wird eine wirklich simple Funk Datenverbindung aufgebaut. Die Reichweite beträgt ein paar Meter. Copyright by H. Sporenberg-2016

433MHz RF Modul Probleme – die VirtualWire-Library Sketch
Wenn der Sender ausgeschaltet ist oder die Reichweite überschritten wird, kommen Störungen rein und die Empfänger-LED blinkt weiterhin zufällig vor sich hin. Auch sonst ist die Übertragung stark gestört. Nach den Störungen bei der AM Datenübertragung auf 433 MHz muss eine entsprechende Synchronisierung und Fehlerkorrektur eingerichtet werden. Hier bietet sich die VirtualWire Library von Mike McCauley an. Sie enthält all das bereits und ist einfach anzuwenden. Der 433 MHz Sender und der Empfänger sind wieder direkt an den Pins des Arduino angeschlossen, wie im vorherigen beschrieben. Copyright by H. Sporenberg-2016

433MHz RF Modul Die VirtualWire-Library Sketch
Die Funktionen zur Konfiguration vw_set_tx_pin(transmit_pin) Configure the transmit pin. Default is pin 12. vw_set_rx_pin(receive_pin) Configure the receive pin, Default is pin 11. On Teensy 2.0, pin 11 should not be used because most receiver modules can not work correctly with the orange LED on that pin. vw_set_ptt_pin(transmit_en_pin) Configure the transmit enable pin, or "push to talk". Default is pin 10. vw_set_ptt_inverted(true) Configure the "push to talk" polarity. vw_setup(2000) Begin using all settings and initialize the library. This is similar to the "begin" function of other libraries. All pins should be configured before calling this function. Copyright by H. Sporenberg-2016

Die Funktionen zum Senden vw_send(message, length) Transmit a message. "message" is an array of the bytes to send, and "length" is the number of bytes stored in the array. This function returns immediately and the message is sent slowly by an interrupt-based background process. vw_tx_active() Returns true if the message is being sent, or false if the transmitter is not active. You can use this after sending a message to test when it has finished being transmitted. vw_wait_tx() Wait for a message to be fully transmitted. Often the simplest approach is to call this after vw_send. Copyright by H. Sporenberg-2016

Die Funktionen zum Empfangen vw_rx_start() Activate the receiver process. You must call this function before any reception can occur. An interrupt-based background process is started which monitors the reception of data. vw_have_message() Returns true if message has been received. This is similar to the "available" function of most other libraries. vw_wait_rx() Wait for a message to be received. This will only return when a message has been received, otherwise it will wait forever. Copyright by H. Sporenberg-2016

Die Funktionen zum Empfangen vw_wait_rx_max(timeout_ms) Wait for a message, but give up after "timeout_ms". Returns true if a message was received, or false if the timeout period elapsed. vw_get_message(buf, &buflen)) Read the last received message. This should be called only when a message is known to be received with any of the 3 functions above. "buf" is an array where the message is copied. "buflen" should have the array's maximum size upon input, and upon return the number of bytes actually copied is retured. The function itself returns true if the message was verified correct, or false if a message was received but appears to have been corrupted. vw_rx_stop() Disable the receiver process. Copyright by H. Sporenberg-2016

433MHz RF Modul Senden – der Sketch Sketch // Verbindungen zum Uno
// GND > D5 // VCC > D6 // Daten > D7 #include < VirtualWire.h> char *msg = "Hallo Welt";// Nachricht void setup() { pinMode(7, OUTPUT); pinMode(5, OUTPUT); // GND 0V digitalWrite(5, LOW); pinMode(6, OUTPUT); // VCC 5V digitalWrite(6, HIGH); vw_setup(5000); // Bits pro Sekunde vw_set_tx_pin(7); // Datenleitung } void loop(){ vw_send((uint8_t *)msg, strlen(msg)); vw_wait_tx(); // warten bis alles übertragen ist delay(1000);} Die Datei heißt: FunkModul_433MHz_02.ino Copyright by H. Sporenberg-2016

433MHz RF Modul Empfangen – der Sketch Sketch void loop() {
// Verbindungen zum Uno // GND > D4 // Data > D5 // Input > D6 // VCC > D7 #include < VirtualWire.h> int i; uint8_t buf[VW_MAX_MESSAGE_LEN]; uint8_t buflen = VW_MAX_MESSAGE_LEN; void setup() { Serial.begin(38400); pinMode(5, INPUT); pinMode(6, INPUT); pinMode(4, OUTPUT); // GND 0V digitalWrite(4, LOW); pinMode(7, OUTPUT); // VCC 5V digitalWrite(7, HIGH); vw_setup(5000); // Bits pro Sekunde vw_set_rx_pin(5); // Datenleitung vw_rx_start(); // Empfänger starten } void loop() { if (vw_get_message(buf, &buflen)) { // überprüfen ob eine Nachricht eingegangen ist for (i=0;i< buflen;i++) { Serial.print((char)buf[i]); // Nachricht aus buf ausgeben } Serial.println(""); } } Die Datei heißt: FunkModul_433MHz_03.ino Copyright by H. Sporenberg-2016

433MHz RF Modul Empfangen – der Sketch Sketch Empfänger-Verbindung
Rot -> Pin 7 Blau -> Pin 6 Gelb -> Pin 5 Schwarz -> Pin 4 Die Datei heißt: FunkModul_433MHz_03.ino Copyright by H. Sporenberg-2016

Temperatur – Sensor LM35 Sketch Sketch
const int inPin 0; // analoger Pin void setup() { Serial.begin(9600); } void loop() { int value = analogRead(inPin); Serial.print(value); Serial.print(" > "); float millivolts = (value /1024.0)*5000: float celsius = millivolts / 10 ; //Sensor-output is 10mV pro Grad Celsius Serial.print(celsius); Serial.print(" Grad Celsius, "); Serial.print((celsius*9)/5+32); // Umrechnung in Fahrenheit Serial.println(" Grad Fahrenheit"); delay(1000); // 1 Sekunde Pause } Copyright by H. Sporenberg-2016

Temperatur – Sensor LM35 Sketch Sketch #define ref_voltage 5.00
/* AnalogReadSerial - modefied for use with an LM35 */ #define ref_voltage 5.00 #define volt2temp 100 void setup() { // initialize serial communication at 9600 bits per second: Serial.begin(9600); } // the loop routine runs over and over again forever: void loop() { // read the input on analog pin 0: int sensorValue = analogRead(A0); // print out the value you read: Serial.println(sensorValue * ref_voltage * volt2temp / 1024 ); delay(1); // delay in between reads for stability Copyright by H. Sporenberg-2016

Die rohen Sensordaten liegen im Bereich zwischen 0 und bedeutet 0 Volt und 1023 die volle Referenzspannung. Also muss SensorValue zu einer echten Spannung und diese Spannung in die gesuchte Temperatur umgerechnet werden. Dafür wird der Messwert mit 5.0 multipliziert und dann durch 1024 geteilt. Der Grund warum mit 5.0 multipliziert wird und nicht mit 5, liegt darin implizit (nebenbei) das Ergebnis in einen Float-Wert umzuwandeln. Schließlich wird das Zwischenergebnis mit einem Proportionalitätsfaktor multipliziert, um die Temperatur zu bekommen. Laut Datenblatt entsprechen 10mV gleich 1 ° C oder in anderen Worten, 1 Volt entspricht 100 ° C. All dies wird in einer Zeile durchgeführt: Serial.println(sensorValue * ref_voltage* volt2temp / 1024 ); Copyright by H. Sporenberg-2016

Der Code funktioniert, aber das Ergebnis ist ein wenig seltsam, um nicht zu sagen enttäuschend was die Genauigkeit angeht. Mit einer Raumtemperatur von 23,7 ° C, gibt der Arduino 28,32 ° C aus. Wenn man darüber nachdenkt, ist die Referenzspannung des Arduino UNO standardmäßig 5V. Da der ADC 1024 Werte dazwischen ausgibt, gibt dies eine Genauigkeit von etwa V pro Schritt. So liegt die Auflösung des ADCs bei 0.48 °C, was etwas besser ist als die minimale Genauigkeit des Sensors. Wie sich herausstellt, liegt die große Diskrepanz an der Referenzspannung . Sie ist jedenfalls bei Anschluss über den USB-Hub kleiner als 5 Volt. Sobald man die Referenzspannung korrigierte (hier: 4,17 Volt), erhält man bessere Werte. Copyright by H. Sporenberg-2016

#define LM35 A0 //Sensor Pin #define ref_voltage 1.08 //Der aktuell gemessene Wert der AREF Spanung #define volt2temp 100 #define average_count 50 #define prop_constant ref_voltage* volt2temp / 1024 /average_count void setup() { // Initialisiert die serielle Kommunikation mit 9600 Bits pro Sekunde Serial.begin(9600); analogReference(INTERNAL); } void loop() { int sensorValue = 0; // Die Werte werden mehrmals (hier: 50) gelesen und der gemittelte Wert wird ausgegeben for (int i = 0; i<average_count; i++){ sensorValue += analogRead(LM35); // Druckt den Wert der Temperatur aus Serial.println(sensorValue * prop_constant); delay(1000); // Pause von 1 Sekunde zwischen der Erfassung der Werte und Ausgabe Jetzt erhält man für die Tempe-ratur einen realistischen Wert: 23,5o C Copyright by H. Sporenberg-2016

WICHTIG void setup () { // níchts } void loop () { // nichts
Der Arduino hat zwar einen Reset-Knopf auf dem Board. Ein Sketch kann nach meinen Erfahrungen aber so nicht gelöscht werden. Vielmehr empfiehlt sich, dies softwaremäßig zu machen. Das heißt, man schreibt ein Programm und lädt dieses auf den Arduino. void setup () { // níchts } void loop () { // nichts Copyright by H. Sporenberg-2016

WICHTIG Externe Spannungsversorgung: 6 V – 12 V – innen Plus

WICHTIG Gute Seite im Netz: „http://funduino.de/index.php/anleitung

WICHTIG PWM PWM bedeutet Pulse Width Modulation und beschreibt ein Verfahren, bei dem der Strom in schneller Abfolge ein- und abgeschaltet wird. Ein Zeitintervall ist dabei 20 Millisekunden lang. Träge Bauelemente kann man durch ein PWM Signal dimmen. Ist der Strom z.B. 10 Millisekunden ein- und danach 10 Millisekunden abgeschaltet, ist der resultierende Strom nur halb so groß. Eine LED würde also nur halb so kräftig leuchten. Auf dem Arduino-Board gibt es sechs Kanäle, die PWM-Signale erzeugen können – Siehe Analog Out. Copyright by H. Sporenberg-2016

WICHTIG Mathematica für den Arduino: Homepage:
„ pi Copyright by H. Sporenberg-2016

WICHTIG Abkürzungen IDE – Integrated Development Enviroment
ArduinoISP - InSystemProgrammer PID – Proportional Integral Derivate GUI – Graphical User Interface GPS – Global Positioning Systems ESC – Electronic Speed Control Copyright by H. Sporenberg-2016

WICHTIG Bücher Tero Kervinen: Make Arduino Bots and Gadgets – 2011, 22,95 Euro Gibt es im Netz als PDF-Datei. Bei mir: Sporenberg\Arduino\Buecher\Make_Arduino_Bots_and_Gadgets Erik Bartmann: Die elektronische Welt mit Arduino entdecken – 2014, gebraucht: 25,98 Euro – 1080 Seiten Copyright by H. Sporenberg-2016

WICHTIG Bücher John-David Warren: Arduino Robotics – 2011 – viel zu teuer – ab ca. 50 Euro Auf dieser Seite kann man den Code für die Beispiele herunterladen. Dieses Buch kann als PDF-Datei im Netz heruntergeladen werden. Copyright by H. Sporenberg-2016

WICHTIG Internetseiten „http://www.arduino-projekte.de/index.php?n=47

GPS - Modul Internetseiten
BayPrice GY-NEO6MV2 Flight Controller GPS Module For Arduino MWC Quadrocopter Drohne mit Arduino Pilot Mega 2.5 Copyright by H. Sporenberg-2016

New MultiWii Standard Edition MWC SE v2.5 Flight Controller Board for FPV Multirotor Quadcopter Quadrocopter Drohne mit Arduino Pilot Mega 2.5 Copyright by H. Sporenberg-2016

GPS – Global Positioning System
Das Global Positioning Sytem (GPS) ist ein welt-weites Netzwerk von Navigationssatelliten, mit dessen Aufbau das US-amerikanische Verteidi-gungsministerium 1973 begann und das offiziell am in Betrieb genommen wurde. Die mindestens 24 GPS-Satelliten, die in einer Höhe von etwa km auf 6 unterschiedlichen Bahnen zweimal täglich die Erde umkreisen, senden nahezu alle 30 Sekunden ihre Position und den Zeitpunkt der Positionsbestimmung auf zwei Frequenzen (L1 = 1.575,42 MHz und L2 = 1.227,60 MHz) in einem festen Format aus. Aus der Laufzeit der Signale kann ein Empfänger seine genaue Position bestimmen. Das zivil nutzbare unverschlüsselte Signal hat eine Datenrate von 50 Bit/s. Ein zweites, nur für militärische Nutzung vorgesehenes Signal wird mit der zehnfachen Bitrate gesendet und erlaubt eine entsprechend genauere Positionsbestimmung. Anfänglich wurden die zivilen Signale (Standard Positioning System, SPS) mit einem Fehlerwert künstlich verschlechtert, sodass die Positionsbe-stimmung eine Ungenauigkeit von 100 m besaß. Dieser Selective Availability genannte Mechanismus wurde am abgeschaltet. Seitdem liegt die Ungenauigkeit – abhängig von der Anzahl der sichtbaren Satelliten und dem verwendeten Lokalisierungs-verfahren – zu 95% unter 8m. Für einen etwaigen Krisenfall behalten sich die USA jedoch vor, das zivil genutzte Signal zu stören. Auch deshalb haben die Sowjetunion (Glonass, nutzbar seit 2011), China (Compass, ab 2020) und die EU (Galileo, nicht vor 2020) eigene Satellitennavigations-systeme entwickelt. Quelle: Heft 3/2013 – ft:pedia Copyright by H. Sporenberg-2016

GPS – Positionsbestimmung
Ein GPS-Sensor kann aus empfangenen GPS-Signalen nicht nur seine Position (geograf. Länge und Breite, Höhe) bestimmen, sondern auch seine Geschwindigkeit und seine Bewegungsrichtung und daraus den Abstand zu einem vorgegebenen Zielpunkt und dessen Richtung berechnen. Wie funktioniert das genau? Die Position (Längengrad, Breitengrad und Höhe) bestimmt ein GPS-Sensor, indem er aus der Signallaufzeit den Abstand zur Posi-tion des sendenden Satelliten bestimmt. Dazu subtrahiert er die im GPS-Signal enthaltene Zeitangabe von der Signalfrequenz. Das GPS-Signal eines einzelnen Satelliten liefert als möglichen Standort also die Punkte auf einer Kugel um den Satelliten – wenn die Höhe bekannt ist, auf einer Kreislinie, dem Schnitt der Kugel mit der Erdoberfläche. Empfängt man das Signal eines zweiten Satelliten, reduziert sich die Lösungsmenge auf zwei Punkte (die Schnittpunkte der Kugeln um die beiden Satelliten), von denen nur einer auf der Erdoberfläche liegt. Somit genügen grundsätzlich zwei GPS-Signale zur Positionsbestimmung, sofern die Höhe der eigenen Position bekannt ist. So weit die Theorie. In der Praxis ist das allerdings nicht ganz so einfach, denn die Ausbreitungsgeschwindigkeit des Signals erreicht fast Lichtge-schwindigkeit – knapp km/s. Das Signal benötigt für die gut km lange Strecke vom Satelliten bis zur Erde weniger als 0,07 s – ein Messfeh-ler von 0,001 s führt so zu einem Mess-fehler in der Positionsbestimmung Quelle: Heft 3/2013 – ft:pedia Copyright by H. Sporenberg-2016

von etwa 300 km, Damit die Zeitangabe des Satelliten hinreichend genau ist, verfügen diese über eine Atomuhr mit einer Abweichung von 1,210-14 – das entspricht einem Fehler von einer Sekunde alle 2,64 Mio. Jahre. GPS-Sensoren besitzen allerdings in der Regel keine ausreichend genaue und mit dem GPS-Satelliten exakt synchronisierte Uhr. Für dieses Problem gibt es jedoch eine elegante Lösung. Man betrachtet die Empfangszeit als weitere Unbekannte – und wertet ein drittes Satelli-tensignal aus. Dann lassen sich Ort (geograph. Länge und Breite) und Empfangszeitpunkt als Gleichungssystem mit drei Unbekannten ausdrücken. Als ein Nebenprodukt liefert der GPS-Sensor damit sogar die Atomzeit. Hat der GPS-Sensor drei Satellitensignale empfangen und daraus seine geographische Position bestimmt, zeigt er das als 2D-fix an. Dabei geht der GPS-Sensor von der Annahme aus, dass er sich auf Meereshöhe befindet. Will man auch die exakte Höhe (als vierte Unbekannte) mit Hilfe des GPS-Sensors bestimmen, muss dieser das Signal eines vierten Satelliten auswerten – und damit ein Gleichungssystem mit vier Unbekannten lösen. Eine solche Positionsbestimmung (Länge, Breite, Höhe) wird vom Sensor als 3D-fix angezeigt. Damit eine 3D-Positionsbestimmung möglichst überall gelingt, wurden die Umlaufbahnen der GPS-Satelliten so gewählt, dass an jeder Position der Erde Signale von mindestens 4 verschiedenen Satelliten empfangen werden können. Quelle: Heft 3/2013 – ft:pedia Copyright by H. Sporenberg-2016

In der Praxis wird die Genauigkeit der Posi-tionsbestimmung außerdem dadurch beein-trächtigt, dass sich die Satelliten selbst mit einer großen Eigengeschwindigkeit (fast km/h) fortbewegen. Auch ist die Aus-breitungsgeschwindigkeit der Signale in der Atmosphäre kleiner als im Vakuum. Schließ-lich verfälschen oder überlagern Reflexionen, z.B. von Gebäuden, einzelne Signale. Und nicht zuletzt hängt die Genauigkeit davon ab, wie exakt der Sensor einen Flankenwechsel in der Codefolge identifizieren kann. Moderne Empfänger berücksichtigen diese Effekte und erreichen bei der Positionsbe-stimmung eine Genauigkeit von unter 3 m. Die Präzision kann – je nach Ort (Tal oder Berg) und Empfangsqualität (Stadt oder Land) durch die Berücksichtigung zusätzlicher Sa-tellitensignale oder die Verwendung von Differential GPS (DGPS) auf unter 1 m verbessert werden. Weitere Optimierungen Sind durch die Nutzung anderer Sensoren (Höhen- und Geschwin-digkeitsmesser) und einen Abgleich mit terrestrischen Referenzsignalen möglich (bis zu 1 cm). Mit wiederholten Positionsbe-stimmungen kann ein bewegter GPS-Sensor auch seine Ge-schwindigkeit (Ground Speed) und – richtung (Ground Course) aus dem Abstand der jeweils letzten Positionen sowie der dazwischen verstrichenen Zeit berechnen. Quelle: Heft 3/2013 – ft:pedia Copyright by H. Sporenberg-2016

GPS – Auswertung der GPS-Daten
Längen- und Breitengrad Der GPS-Sender liefert die Positionsdaten nach dem globalen Referenzsystem WGS84 (World Geodetic System 1984). Zur Festlegung der geographischen Koordinaten wird die Erdoberfläche dabei in 360 Längen- und 180 Breitengrade unterteilt, mit Greenwich (der Londoner Sternwarte) und dem Äquator als Nullmeridiane. Das WGS84 berücksichtigt zudem, dass die Erde keine Kugel ist, sondern ein Ellipsoid. Der GPS-Sensor gibt die Geographische Länge und Breite als 32-bit-Wert mit einer Genauigkeit von 10-7 Grad zurück. Üblicherweise erfolgt die Angabe des Längen- und Breitengrads als Fließkommazahl in Grad. Diesen Wert erhält man, indem man den vom Sensor empfangenen Wert durch 107 teilt. Alternativ kann eine Position auch klassisch in Grad, Minuten und Sekunden ausgedrückt werden. Für die Umrechnung In Minuten sind die Nachkommastel-len der Gradangabe mit 60 zu mul-tiplizieren; die Sekunden erhält man, indem man die verbleibenden Nach-kommastellen mit 60 multipliziert. Quelle: Heft 3/2013 – ft:pedia Copyright by H. Sporenberg-2016

GPS – Modul GY-GPS6MV2 Setup Complete
$GPGGA, , ,N, ,E,1,7,1.41,67.8,M,47.4 $GPGGA, , ,N, ,E,1,7,1.41,67.8,M,47.4,M,,*67 $GPGSA,A,3,22,03,01,11,17,19,14,,,,,,1.69,1.41,0.92*0A $GPGSV,4,1,13,22,87,084733,257,3,,,9,32,1141,2*76 $G,2,13,1430,9,17,37033,27, ,*7A PS4,3,13,,,121,31,10,2,15,04,86175,*78$GV,4,13,202,*44 $PC ,,3789,N,0052,E, ,,* $GPGGA, , ,N, ,E,1,7,1.41,67.8,M,47.4,M,,*68 $GPGSV,4,1,13,22,87,084733,257,3,,,9,32,1141,1*75 $G,2,13,1430,9,17,3,033,27, ,*7A PV4,3,1312,621,31,10,2,15,04,8675,*78 $G,,4,13,2027*44 $PC ,,3789,N,0752,E, ,,5 $GPGGA, , ,N, ,E,1,7,1.41,67.8,M,47.4,M,,*68 Copyright by H. Sporenberg-2016

GPS – Modul GY-GPS6MV2 Achtung: Das GPS-Modul muss dort platziert werden, wo es Signale empfangen kann. In einer geschlossenen Wohnung ist dies meist nicht überall der Fall. Also: entweder nach draußen oder den GPS-Sender wenigstens auf die Fensterbank legen. Breite Länge GPS-Modul 51,645677 7,098817 Netz 1 51,659123 7,106021 Netz 2 51,645615 7,098673 Differenz 1 0,013446 0,007204 Prozent 1 0, % 0, % Differenz 2 0,000062 0,000144 Prozent 2 0, % 0, % Copyright by H. Sporenberg-2016

GPS – Modul GY-GPS6MV2 #include <SoftwareSerial.h>
#include <TinyGPS.h> long lat,lon; // create variable for latitude and longitude object SoftwareSerial gpsSerial(2, 3); // create gps sensor connection TinyGPS gps; // create gps object void setup(){ Serial.begin(9600); // connect serial gpsSerial.begin(9600); // connect gps sensor } void loop(){ while(gpsSerial.available()){ // check for gps data if(gps.encode(gpsSerial.read())){ // encode gps data gps.get_position(&lat,&lon); // get latitude and longitude // display position Serial.print("Position: "); Serial.print("lat: ");Serial.print(lat);Serial.print(" ");// print latitude Serial.print("lon: ");Serial.println(lon); // print longitude }}} Copyright by H. Sporenberg-2016

Das Protokoll NMEA-0183 Die NMEA hat nun unter anderem den Standard NMEA-1083 definiert, um einen Datenaustausch zwischen verschiedenen Geräten aus der Marineelektronik zu ermöglichen. Die NMEA-0180,0182 und 0183 Standards (die ersten beiden sind nicht mehr von Bedeutung) sehen pro "Netz" ein Sendegerät und diverse Empfangsgeräte vor. Der Sender soll Daten nach dem RS-232-Standard (vom PC als Datenformat der COM-Schnittstellen bekannt) ausgeben. Die Datenrate beträgt 4800 baud (ca. 600 Bytes/Sekunde) und es ist in diesem Standard kein Stecker oder ähnliches definiert. Die Anschlussart bleibt also dem Hersteller überlassen, weswegen alle Geräte unterschiedliche Stecker benötigen. Die Einschränkung, dass es nur einen Sender geben darf, sorgt dafür, dass nicht wild durcheinander gequatscht wird. Sollen die Daten von mehreren Geräten zusammengefasst werden, braucht man mindestens ein Gerät, dass auch als Empfänger arbeitet und alle erhaltenen Daten in einen neues "Netz" wieder kombiniert einspeist. Copyright by H. Sporenberg-2016

Das Protokoll NMEA-0183 Die Daten werden im ASCII-Format (American Standard Code for Information Interchange, Amerikanischer Standard Code für Informationsaustausch) übertragen. Dabei sind alle druckbaren Zeichen sowie Carriage-Return (CR, Waagenrücklauf) und Line-Feed (LF, Neue Zeile) erlaubt und die Daten werden in der Form von Sätzen übertragen. Jeder dieser Sätze beginnt mir dem Zeichen "$", einer zwei Zeichen langen Senderkennung, einer drei Zeichen langen Satzkennung und dann folgt eine Reihe von Datensätzen, die mit Kommas unterteilt werden. Schließlich wird der Satz mit einer optionalen Prüfsumme und einer CR/LF abgeschlossen. Jeder Satz kann inklusive des führenden "$" und den beiden CR/LF bis zu 82 Zeichen enthalten. Ist ein Datenfeld in einem Satz zwar vorgesehen aber nicht verfügbar, so wird er einfach weggelassen, das dazugehörige Komma zur Trennung der Datensätze wird aber ohne Leerzeichen beibehalten. Durch Zählen der Kommas kann ein Empfänger dann aus jedem Satz die entsprechenden Informationen richtig zuordnen. Copyright by H. Sporenberg-2016

Das Protokoll NMEA-0183 Die meist optionale Prüfsumme besteht aus einem "*" und eine Hexadezimalzahl, die sich durch ein (bitweise) exklusiv-oder (1+1=0, 1+0=1, 0+0=0) aller Zeichen zwischen dem "$" und dem "*" berechnen. Bei manchen Sätzen ist die Prüfsumme notwendig. ALs Beispiel berechnet sich die Prüfsumme folgendermaßen: Aus $GPVTG... wird GPVTG... und die Prüfsumme berechnet sich aus dem ASCII-Werten aller Zeichen: 71 XOR 80 XOR 86 XOR 84 XOR 71 XOR ... Der erhaltene Wert als Hexadezimalzahl ist die Prüfsumme. Der Standard erlaubt weiterhin einzelnen Herstellern eigene (proprietäre) Satzformate. Diese fangen mit "$P" an, gefolgt von der drei Buchstaben langen Herstellerkennung. Anschließend folgen die Daten. Einige gängige Senderkennungen sind: GP GPS Empfänger LCLoran-C Empfänger (älteres Positionsbestimmungssystem) OMOmega Navigations Empfänger (altes Radionavigationssystem; außer Betrieb) IIIntegrated Instrumentation (z.B. AutoHelm Seatalk System; Autopiloten) Copyright by H. Sporenberg-2016

Das Protokoll NMEA-0183 Die Datensätze der unterschiedlichen Geräte können sehr viele verschiedene Informationen beinhalten, darunter Position, Geschwindigkeit, Richtung, Wassertiefe, Wassertemperatur, Wegpunkte, Windgeschwindigkeit usw. Nachfolgend sollen beispielhaft die Daten, die ein Garmin etrex Vista ausgibt näher beschrieben werden. Wichtig ist, dass das Datenformat des GPS auf NMEA umgestellt wird (heißt beim Vista genau: NMEA In/NMEA Out). Die Daten werden dann einmal alle zwei Sekunden über die Schnittstelle ausgegeben. Viele PC-Navigations- und Kartenprogramme mit Anschlussmöglichkeit für GPS-Empfänger erwarten im übrigen auch das NMEA-Format zur Navigation. Funktioniert das Zusammenspiel zwischen GPS und einem PC-Programm nicht, sollte man also sowohl kontrollieren, ob man den GPS an der richtigen seriellen Schnittstelle (COM1 oder COM2) angeschlossen hat, als auch überprüfen, ob das Ausgabeformat am GPS auf NMEA eingestellt ist. Copyright by H. Sporenberg-2016

Das Protokoll NMEA-0183 Ein kompletter Block Daten sieht dann beispielsweise beim Garmin etrex Vista (Software Version 2.41) folgendermaßen aus: $GPRMC,191410,A, ,N, ,E,0.0,0.0,181102,0.4,E,A*19 $GPRMB,A,9.99,L,,Exit, ,N, ,E,29.212,107.2,,V,A*69 $GPGGA,191410, ,N, ,E,1,04,4.4,351.5,M,48.0,M,,*45 $GPGSA,A,3,,,,15,17,18,23,,,,,,4.7,4.4,1.5*3F $GPGSV,2,1,08,02,59,282,00,03,42,287,00,06,16,094,00,15,80,090,48*79 $GPGLL, ,N, ,E,191410,A,A*4A $GPBOD,221.9,T,221.5,M,Exit,*6B $GPVTG,0.0,T,359.6,M,0.0,N,0.0,K*47 $PGRME,24.7,M,23.5,M,34.1,M*1D $PGRMZ,1012,f*36 $PGRMM,WGS 84*06 $HCHDG,170.4,,,0.4,E*03 $GPRTE,1,1,c,*37 Wenn die Navigation mit einer Route aktiviert wurde, können noch weitere Sätze hinzukommen, die die Route beschreiben. Interessant ist auch, dass anscheinend je nach Softwareversion unterschiedliche Datensätze ausgegeben werden. Copyright by H. Sporenberg-2016

Das Protokoll NMEA-0183 Die Datensätze GPRMC
Der GPRMC-Datensatz (RMC = recommended minimum sentence C, empfohlener Minimumdatensatz) ist eine Empfehlung für das Minimum, was ein GPS-Empfänger ausgeben soll. $GPRMC,191410,A, ,N, ,E,0.0,0.0,181102,0.4,E,A*19 > Uhrzeit der Bestimmung: 19:14:10 (UTC-Zeit) A -> Status der Bestimmung: A=Active (Gültig); V=void (ungültig) ,N,> Breitengrad mit (Vorzeichen)-Richtung (N=Nord, S=Süd) 46o ´ Nord ,E-> Längengrad mit (Vorzeichen)-Richtung ((E=Ost, W=West) 007o ´ Ost E,A*19 -> Neu in NMEA 2.3: Art der Bestimmung A=autonomous (selbst) D=differential E=estimated(gechätzt) N=not valid(ungültig) S=simulator) 0.0 -> Geschwindigkeit über Grund (Knoten) 0.0 -> Bewegungsrichtung in Grad (wahr) > Datum: 0.4 -> Missweisung (mit Richtung) Copyright by H. Sporenberg-2016

Das Protokoll NMEA-0183 Die Datensätze GPGGA
Der GPGGA-Datensatz ist einer der wichtigesten Datensätze, darin enthalten sind Zeit, Position (inkl. Höhe) sowie Qualität der Messung. $GPGGA,191410, ,N, ,E,1,04,4.4,351.5,M,48.0,M,,*45 > Uhrzeit der Bestimmung: 19:14:10 (UTC-Zeit) ,N,> Breitengrad mit (Vorzeichen)-Richtung (N=Nord, S=Süd) 46o ´ Nord ,E-> Längengrad mit (Vorzeichen)-Richtung ((E=Ost, W=West) 007o ´ Ost 1 -> Qualität der Messung: 0=ungültig, 1=GPS,2=DGPS, 6=geschätzt nur NMEA 04 -> Anzahl der erfassten Satelliten 4.4 -> HDOP (horizontal dilution of precision) Genauigkeit 351 -> Höhe über Meer (über Geoid) in Metern (351.5 M) Copyright by H. Sporenberg-2016

Das Protokoll NMEA-0183 Die Datensätze GPGSA
Der GPGSA-Datensatz (SA=satellites active, aktive Satelliten) enthält Informationen über die PRN-Nummern der Satelliten, deren Signale zur Positionsbestimmung verwendet werden. $GPGSA,A,3,,,,15,17,18,23,,,,,,4.7,4.4,1.5*3F A -> Auto-Auswahl 2D oder 3D Bestimmung 3 -> Art der Positionsbestimmung (3=3D-fix, 2=2D-fix, 1=kein Fix) Die nächsten Felder -> PRN-Nummer von maximal 12 Satelliten 4.7 -> PDOP (Genauigkeit) 4.4 -> HDOP (horizontal dilution of precision) Genauigkeit 1.5*3F -> VDOP (vertikale Genauigkeit) Copyright by H. Sporenberg-2016

Das Protokoll NMEA-0183 Die Datensätze GPGSV
Der GPGSV-Datensatz (SV=satellites in view, sichtbare Satelliten) enthält Informationen über Satelliten, die zur Zeit möglicherweise empfangen werden können und Informationen zu deren Position, Signalstärke usw. Da pro Satz nur die Informationen von vier Satelliten übertragen werden können (Beschränkung auf 82 Zeichen), kann es bis zu drei solche Datensätze geben. $GPGSV,2,1,08,02,59,282,00,03,42,287,00,06,16,094,00,15,80,090,48*79 GPGLL Der GPGLL-Datensatz ist ein Überbleibsel aus der Zeit, als es nur LORAN-C als Navigationssystem gab und enthält die geographische Position. Das GPS-Gerät emuliert sozusagen den LORAN-C Empfänger. $GPGLL, ,N, ,E,191410,A,A*4A Copyright by H. Sporenberg-2016

Das Protokoll NMEA-0183 Die Datensätze GPBOD
Der GPBOD-Datensatz gibt Informationen zur Richtung vom Startpunk zum Zielpunkt an. Der Kurs wird als wahrer (T=true) und magnetischer (M=magnetic) Kurs zum benannten Zielpunkt (hier 'Exit', da keiner angegeben ist) ausgegeben. $GPBOD,221.9,T,221.5,M,Exit,*6B GPVTG Der GPVTG-Datensatz enthält Daten zur Bewegungsgeschwindigkeit und Richtung. $GPVTG,0.0,T,359.6,M,0.0,N,0.0,K*47 0.0,T -> Kurs (wahr, T) 359.6,M -> Kurs (magnetisch, M) 0.0,N -> Geschwindigkeit über Grund in Knoten (N) 0.0,K*47 -> Geschwindigkeit über Grund in km/h (K) Copyright by H. Sporenberg-2016

Libraries einbinden Eine nicht standardmäßig in der für den Arduino vorliegende Library liegt in den meisten Fällen als ZIP-Datei vor. Diese lädt man aus dem Netz und entpackt sie. Es empfiehlt sich, den dann erhaltenen Ordner komplett in den Ordner …\arduino windows\arduino-1.5.8\libraries\NewPing_v1.7 zu kopieren. Achtung: Der Ordner NewPing liegt als Unterordner von NewPing_v1.7 vor. Auf jeden Fall muss dieser Unterordner kopiert werden. In diesem Ordner sind die Libraries vorhanden, hier: NewPing.ccp und NewPing.h, zusätzlich gibt es eine Textdatei keywords.txt, die die Befehle der Library angibt. Weiter ist wiederum ein Unterordner examples vorhanden, der einige Beispieldateien enthält. Copyright by H. Sporenberg-2016

Libraries einbinden Eine Library
In der Command-Zeile wählt man den Punkt Sketch an. In dem sich aufklappenden Fenster wählt man Library importieren. In dem langen Fenster wird nun Library hinzufügen angeklickt. Copyright by H. Sporenberg-2016

Libraries einbinden Jetzt klappt der Explorer auf und man hangelt sich dann über ..\arduino windows\arduino-1.5.8\libraries zu dem Ordner der Libraries durch. Hier wählt man den neuen Ordner NewPing aus und öffnet ihn. Damit ist diese Library hinzugefügt. Copyright by H. Sporenberg-2016

Hindernisse erkennen mit einem IR-Sensor u. Arduino
IR-Sensor FC-51 Copyright by H. Sporenberg-2016

IR-Sensor FC-51 Achtung: Die Empfindlichkeit muss an der Schraube im blauen Würfel eingestellt werden. #define IR 2 int detection = HIGH; // Kein Hindernis void setup() { Serial.begin(9600); pinMode(IR, INPUT); } void loop() { detection = digitalRead(IR); if(detection == LOW){ Serial.print("Hier ist ein Hindernis!\n"); else{ Serial.print("Kein Hindernis!\n"); delay(500); // in ms Diese Diode leuchtet immer Diode leuchtet nur, wenn Hindernis erkannt wird Copyright by H. Sporenberg-2016

L293D Motor Shield ServoMotor
#include <Servo.h> //create servo object Servo servo1; void setup() { //attach servo1 to pin 10 servo1.attach(10); } void loop() { while(1){ //0 position servo1.write(0); delay(1000); //90 degrees servo1.write(90); delay(1000); //180 degrees servo1.write(180); delay(1000); servo1.write(90); delay(1000); As you can see pulse width vary in small range comparing to PWM period. Lets try to run simple Arduino program to get motor shaft turning arduino motor shield Servo1 channel is attached to Arduino D10 pin. Controlling servo motors with Arduino is really easy, and you even don’t need a motor shield for this. Anyway motor shield is convenient because there are already pins available where standard servo connector fits. And so to drive servo you only need to include servo.h library in to Arduino code:

L293D Motor Shield ServoMotor Anschlüsse für 2 Servomotoren

L293D Motor Shield ServoMotor
As you can see first we create a servo1 object from class Servo. 1Servo servo1; Then we assign pin 10 to it where servo motor is connected. 1Servo1.attach(10); And that’s it – we can start using servo motor right away by using command: 1servo1.write(angle);Servo library allows to set servo motor rotation angle in degrees from 0 to 180. In this example program we simply rotate servo motor 90º backwards and forward every second. There are other functions available in servo library that can be used. We used couple of those – attach() and write(). There is also detach() command that allows to free pin from servo control and use it as normal pin like for using analogWrite(). If you don’t like to control servo motor by writing angular values you can use writeMicroseconds() function instead of write(). It is easy to convert angle to microseconds. If we know that 0º angle is 1ms or 1000us. Then instead of writing servo1.write(0) we can write servo1.writeMicroseconds(1000) and this will be same. Also this command is useful when you get a bit different servo motor, where signal timing won’t match common practice. Then you can set custom pulse length to match the angle. The last command in servo library is read(). It simply returns last angle sent with write() command. As we can see controlling servo motors with Arduino motor shield is easy. And you don’t need any external libraries for this.

Der Mikrokontroller – Arduino Uno Rev 3

Ähnliche Präsentationen

Präsentation zum Thema: "Der Mikrokontroller – Arduino Uno Rev 3"— Präsentation transkript:

Ähnliche Präsentationen

Über Projekt

Feedback

Anmelden

Anmeldung über soziales Netzwerk:

Der Mikrokontroller – Arduino Uno Rev 3

Ähnliche Präsentationen

Präsentation zum Thema: "Der Mikrokontroller – Arduino Uno Rev 3"— Präsentation transkript:

Ähnliche Präsentationen

Über Projekt

Feedback