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 = 4; const uint8_t echoPin = 2; 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 = 4; int echoPin = 2; 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=4; int echo=2; 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(4,2); // (Trig PIN, Echo PIN) Ultrasonic ultrasonic(4,2,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 4 // 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

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 wird 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); irrecv.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 Die einzelnen Ziffern-Tasten haben folgenden Code 16738455 1
Sketch IR-Remote Die einzelnen Ziffern-Tasten haben folgenden Code 1 2 3 4 5 6 7 8 9 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, das 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 gedrü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 Anschlüsse einer LED Copyright by H. Sporenberg-2016

WICHTIG Gute Seite im Netz:
„ „ Copyright by H. Sporenberg-2016

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 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

GPS - Modul Internetseiten Libraries
„ 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 TX RX Copyright by H. Sporenberg-2016

GPS – Modul GY-GPS6MV2 Achtung: Im Netz gibt es die Möglichkeit bei Angabe des Standortes, die GPS-Daten zu erhalten. Eine Adresse im Internet ist: „ Copyright by H. Sporenberg-2016

GPS – Modul GY-GPS6MV2 In das untere Feld wird die Adresse angegeben.

GPS – Modul GY-GPS6MV2 In das untere Feld wird die Adresse eingegeben. Die Ausgabe erfolgt in den beiden Feldern Latitude und Longitude. 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 51,645615 7,098673 Differenz 0,000062 0,000144 Prozent 0, % 0, % Die GPS-Daten aus dem Netz für Marl werden hier verglichen mit der Angabe durch das GPS-Modul GY-GPS6MV2. Die Abweichung ist, wie man sieht, minimal. 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

GPS – Modul GY-GPS6MV2 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 Die Verbindung mit dem Arduino Copyright by H. Sporenberg-2016

IR-Sensor FC-51 Achtung: Die Empfindlichkeit muss an der Schraube im blauen Würfel eingestellt werden. #define IR; int detection = HIGH; // Kein Hindernis void setup() { Serial.begin(96 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 ein 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.

2-Rad-Car Ziel dieses Projektes ist es, ein Fahrzeug mit zwei angetriebenen und einem beweglichen Rad mit Hilfe einer IR-Fernbedienung zu steuern. Folgende Befehle sollen implementiert werden: Vorwärts, rückwärts, links, rechts und stopp. Lieferumfang des 2WD-Fahrzeuges

2-Rad-Car Das Fahrzeug wird entsprechend zusammengebaut.

2-Rad-Car Um eine einfachere Steuerung der DC-Motoren zu erreichen, verwendet man das Motor Drive Shield L293D. Dieses wird einfach auf den Arduino aufgesteckt. Dann werden die beiden Motoren angeschlossen. Dazu lötet man die Kabel an die Motoren. Bei der vorgesehenen Anordnung müssen die beiden Anschlüsse Motor #3 und Motor #4 benutzt werden. Unter Umständen muss man die Kabel an den Ausgängen des Shields umschrauben, damit die Motoren in dieselbe Richtung drehen.

2-Rad-Car Der IR-Empfänger muss über dass Shield angeschlossen werden. Dabei können nicht die digitalen I/O verwendet werden, da diese irgendwie mit den Ausgängen der Motoren verbunden sind. Frei sind dafür die analogen Eingänge A0 bis A5 (dies sind Pin 14 bis Pin 19). Diese können aber auch als digitale Eingänge benutzt werden. In diesem Beispiel wird der Eingang A0 (= Pin 14) benutzt. Zusätzlich benötigt man für den IR-Empfänger eine Spannungsversorgung.

2-Rad-Car

2-Rad-Car Die Tasten sind so gewählt, dass die verwendeten ein Kreuz bilden. Der mittlere Button soll die Stop-Taste darstellen.

Quadrocopter Die wichtigsten Flugmodi
ACRO MODE Der Acro Mode beim Arducopter ist – wie der Name schon sagt – der manuelle Flugmodus, in welchem der Copter sich nicht von selbst stabilisiert, also für fortgeschrittene Nutzer und nichts für Anfänger. Wer sehr geübt im Flug ist und mit seinem Copter Stunts ausführen möchte, der ist mit dem Acro Mode gut beraten. STABLE MODE Im Stable Modus stabilisiert sich der Copter stets von selbst. Das bedeutet, dass er nach jeder Stickeingabe versuchen wird, sich wieder in der Horizontalen auszurichten. Dieser Modus ist für Anfänger und vor allem für FPV-Flieger geeignet. Voreingestellt ist ein Winkel von + und – 45 Grad. Giert man den Copter, wird er die entsprechende Richtung beibehalten, sobald man den Stick loslässt. VIDEO VOM ALTITUDE HOLD MODE Hier ein kurzes Video eines ersten Tests im Alt Hold Modus. Der Barometer funktioniert wie man sehen kann ganz gut. Allerdings habe ich das Gefühl, dass der Barometer der Naza Flighcontrol von DJI ein wenig besser ist. Dem APM 2 zu Gute halten muss man aber, dass an dem Tag der Videoaufnahme ein sehr starker Wind ging, was die Funktionsweise des Barometers durchaus negativ beeinträchtigen kann.

ALT HOLD Im Altitude Hold Modus versucht der Copter die Höhe zu halten. Hierbei kann die Höhe während des Fluges im Alt Mode mit dem Throttle Stick variiert werden, indem man ihn in Bezug zum Nullpunkt hoch- oder runterschiebt. Der Nullpunkt wird zum Zeitpunkt des Aktivierend des Alt Hold Modus festgelegt. Schaltet man den Alt Hold Modus während des Fluges ein, so wird die gegenwärtige Position des Throttles sozusagen zur 0 Position, von der ausgehend man höher oder tiefer fliegen kann. Daher ist zu beachten, dass man beim Aktivieren des Alt Hold Modus weder steigt noch sinkt, sondern eine konstante Höhe hält. Verlässt man den Alt Hold Modus während des Fluges, so sollte man auch darauf achten, dass die Position des Throttle Sticks bei ca. 50% liegt, da der Copter ansonsten rapide steigen oder sinken könnte. Des Weiteren kann man im Alt Hold Modus weder landen noch die Motoren abstellen – hierfür muss man erst in einen anderen Modus, am Besten in den Staple Mode umschalten.

SIMPLE MODE Der so genannte Simple Mode wird bei vielen anderen Flight Controls als “Care Free” bezeichnet. In diesem Modus wird der integrierte Kompass genutzt, um die Flugrichtung des Copters aus der Sicht des Piloten sozusagen zu fixieren. Konkret bedeutet das, dass in diesem Modus vorne immer vorne aus der Pilotensicht ist. Giert um z.B. 45 Grad nach rechts und drückt Nick nach Vorne, so wird der Copter nicht nach rechts fliegen, sondern aus der Pilotensicht weiterhin nach vorne. Daher sollte sich der Pilot keinesfalls selbst drehen. Dieser Modus ist evtl. für komplette Multicopteranfänger interessant, aber für Leute mit Flugerfahrung könnte dieser Modus in einem Desaster enden. GUIDED MODE Der Guided Mode funktioniert im Prinzip wie der RTL Mode mit dem Unterschied, dass der Ausgangspunkt festgelegt wird, indem man auf einen Punkt auf der Karte klickt. Dieser Modus ist vor allem für alle interessant, die ihr Notebook auf dem Flugfeld dabei haben. Erreicht der Copter seinen Ausgangspunkt, wird er über diesem hovern bis er ein neues Kommando erhält.

AUTO MODE Der Auto Mode ist einer der interessantesten des Arducopters. Hierbei fliegt der Copter im Autopilot Modus, was bedeutet, dass er einen vorher im Mission Planer definierten Flug ausführt. Hierbei kann er Wegpunkte abfliegen, starten, ein Foto auslösen oder eine beliebige Aktion zum Ereignis X ausführen. Der Autopilot Modus kann sowohl am Boden als auch in der Luft gestartet werden. Sollte man vom Boden aus in den Auto Modus wechseln, so wird dieser erst beginnen, wenn man den Copter armed und den Throttle nach vorne bewegt. Dies ist eine Sicherheitsvorkehrung, damit der Copter nicht automatisch startet, falls man am Boden aus Versehen den Schalter mit dem Auto Modus betätigt. Beim Autopiloten sollte man beachten, dass der Copter nachdem er alle Wegpunkte abgeflogen hat nicht automatisch zum Ausgangspunkt (Home) zurückkehrt. Er wird beim letzten Wegpunkt in den Loiter Modus gehen. Will man, dass der Copter nach Hause kommt, sollte man als letztes Kommando Return to Launch (RTL) programmieren. Zudem kann man im Automodus nicht manuell landen. Um selbst eine Landung vornehmen zu können, muss man den Automodus abschalten und in den Stabilize Modus schalten.

RTL MODE RTL steht für Return to Launch. In diesem Modus kehrt der Copter zu seinem Ausgangspunkt zurück. Dieser wird festgelegt, indem man den Copter armed, sobald dieser über GPS Fix verfügt. Also den Copter erst ar-men, wenn das blaue LED in der Mitte des APM2 Boards nicht mehr blinkt, sondern konstant leuchtet. Die Höhe, in welcher der Copter zum Ausgangspunkt zurückkehrt kann man im Mission Planer einstellen. Stellt man RTL altitude im Mission Planer auf 0, wird der Copter auf der Höhe zurückkehren, auf welcher er sich zum Zeitpunkt des Aktivieren des RTL Modus befindet. Erreicht der Arducopter seinen Ausgangspunkt, wird er über diesem im Loiter Modus (GPS Hold + Alt Hold) hovern. Achtung: nach 20 Sekunden im Loiter Modus wird der Copter eine automatische Landung initiieren. Um dies zu verhindern und eine manuelle Landung auszuführen, muss man in den Stabilize Modus umschalten. Immer daran denken, dass der Ausgangspunkt beim armen des Copters neu gesetzt wird. Steckt man also einen neuen Akku an und armed nachdem das Board einen GPS-Fix hat, ist der Ausgangspunkt neu gesetzt. Startet man den Copter ohne GPS-Fix, so kann es sein, dass dieser während des Fluges einen Fix erzielt und sich die Ausgangsposition somit irgendwo auf der Flugstrecke befindet. Also unbedingt auf das blaue LED achten!

LOITER MODUS Im Loiter Mode wird der Copter versuchen, die gegen-wärtige Position zu halten. Man kann den Copter wei-terhin steuern, wobei nach einer Bewegung der Punkt, an dem man die Sticks loslässt zur neuen Loiter Posi-tion wird. Die Höhe kann ähnlich wie im Alt-Hold Modus variiert werden. Die Throttlestellung zum Zeitpunkt des Einschaltend des Loiter Modus wird sozusagen der Null-punkt. Bewegt man den Throttle oberhalb dieses Null-punktes, wird der Copter steigen, bewegt man den Throttle unterhalb, wird er sinken. Zu beachten ist da-her, dass man den Loiter Mode erst einschaltet, wenn der Copter die Höhe hält. Ansonsten könnte beim zu-rückschalten in z.B. den Stabilize Modus der Copter stark steigen oder sinken.Im Loiter Mode kann man nicht landen oder den Copter disarmen, hierzu muss man in z.B. den Stabilize Modus schalten.. POSITION HOLD MODE Der Position Hold Modus ist im Prinzip dasselbe wie Loiter Mode (vgl. oben). Mit dem Unterschied, dass der Throttle, also die Höhe, manuell steuerbar ist.

VIDEO VOM LOITER MODE Der Loiter Mode beim Arducopter ist so etwas wie GPS Position Hold mit Altitude Hold. Der Copter versucht über die GPS Daten und den Barometer seine Position zu behalten. Zum Zeitpunkt des Videos war sehr starker Wind, weshalb mein Quadrocopter in etwa maximal vier Meter Abweichung hatte, was durchaus tolerabel ist. Ich bin mal gespannt, wie genau der Loiter Mode bei Windstille funktioniert. CIRCLE MODE Im Circle Modus umkreist der Copter einen bestimmten Punkt, wobei Yak immer auf das Zentrum des Kreises zeigt. Das Zentrum des Orbits wird der Punkt, an dem sich der Arducopter zum Zeitpunkt des Aktivierend des Circle Mode befindet. Im Circle Mode kann man nicht manuell landen oder die Motoren ausschalten.

FOLLOW ME MODE Der Follow me Modus könnte im Deutschen als “Gassi geh” Modus bezeichnet werden. Aktiviert man diesen Modus, wird der Copter einem folgen. Hierzu sind allerdings folgende Komponenten notwendig: Arducopter mit Telemetrie Ein Notebook GPS USB dingle oder Bluetooth GPS Um der Position des Piloten zu folgen, setzt der Copter ständig neue Wegpunkte.

Quadrocopter LiPo – Akku (Lithium Polymer)
Die Verwendung von LiPo-Akkus hat Vor- und Nachteile (laut Netz). Vorteile: 1.Geringes Gewicht 2.Große Stromabgabe Nachteile: 1.Wartung des Akkus, besonders beim Aufladen muss man vorsichtig sein, da dieser bei unsachgemäßer Aufladung durchaus explodieren und Feuer fangen kann (laut Netz). Für das Aufladen sollte man ein spezielles Ladegerät für LiPo-Akkus verwenden. Diese berücksichtigen einen sog. Balancer, der dafür sorgt, dass die einzelnen Akkus gleichmäßig aufgeladen werden.

Quadrocopter LiPo – Akku (Lithium Polymer) Ein LiPo Akku ist im Prinzip immer gleich aufgebaut und besitzt gewisse Regeldaten, Minimal- und Maximalwerte. Spannung-Angabe: 7,4 Volt Ein LiPo Akku besteht vom Aufbau her immer aus mindestens einer Zelle oder einem Vielfachen daraus. Die Normzelle besitzt im Normalfall eine Regelvoltangabe von 3,7 Volt! D.h. in unserem Beispiel besteht der Akku aus zwei LiPo Zellen. Strom-Angabe: 4000mAh (4 Ampere) Dieser Wert gibt an, wie viel Strom der Akku liefern kann. Leistung: 29,6 Watt Die Leistung kann durch Multiplikation von Ampere und Voltangabe berechnet werden: 7,4 V x 4 A = 29,6 Watt Angabe: 2S1P Diese Angabe bezieht sich auf die oben genannten Angaben. 2S –> zwei Zellen 1P –> die Zellen sind in Reihe geschalten Angabe: 2S2P 2S –> zwei Zellen 2P –> zu diesen zwei Zellen wurden zwei weitere Zellen parallel dazu geschalten

Quadrocopter LiPo – Akku (Lithium Polymer) Hat man die Wahl zwischen der 1P und 2P Variante, so ist die 1P Variante vorzuziehen, auch wenn diese wahrscheinlich ein paar Euro mehr kosten dürfte. C-Wert Hier kann man oft unterschiedliche C Werte auf einen Lithium Polymer Akku finden! Der C Wert steht für einen Faktor, wenn es um das Laden oder Entladen von LiPos geht. Angabe: 30C Steht dieser Wert allein, so kann aus dem Akku die bis 30fache Amperezahl für kurze Zeit gezogen werden. Die Amperewerte werden für einen Zeitraum über eine Stunde angegeben, jedoch können die Akkus kurzzeitig mehr Leistung für kürzere Zeit zur Verfügung stellen. Beispiel 4 Ampere x 30 = 120 A –> der Akku kann bis zu 120 A am Ausgang zur Verfügung stellen Angabe: 30C – 50C Sind zwei C Werte bei einem Akku angegeben, so ist der erste Wert der Faktor, mit dem die Batterie dauerhaft belastet werden kann. Der zweite Wert gibt den Spitzenstrom an, der kurzzeitig vom LiPo Akku angefordert werden kann.

Quadrocopter LiPo – Akku (Lithium Polymer) Beispiel: 4 Ampere x 30 = 120 A –> dieser Wert kann über längere Zeit vom Akku abgefordert werden — 4 Ampere x 50 = 200 A –> der gleiche Akku ist aber auch in der Lage Spitzenströme in der Höhe von 200 Ampere zur Verfügung zu stellen! Angabe: 3C Maximum charge rate – Laden mit maximal 3C Wie man hier aus der Bezeichnung schon entnehmen kann, wird durch diesen C Wert, der maximale Ladestrom bestimmt. Beispiel: 4 Ampere x 3 = 12 Ampere –> Die Akku darf mit einem maximalen Ladestrom von 12 Ampere geladen werden.

Quadrocopter LiPo – Akku (Lithium Polymer) Um einen LiPo Akku zu laden, muss ein Ladegerät verwendet werden, das mit der LiPo Technik zurecht kommt und auch bei einer vielleicht falschen Einstellung den Akku vor Zerstörung schützt, welche im Extremfall zu einem Wohnungsbrand führen könnte. Mit wie vielen Zellen ein Ladegerät zurecht kommt, bzw. bei wie vielen es den genauen Ladezustand ermitteln kann, ist in der Beschreibung des Ladegerätes ersichtlich. Im Normalfall gibt es bei LiPo Akkus zwei Anschlüsse. Der Anschluss mit den großen dicken Kabeln wird verwendet, um den Akku auf eine Grundladung zu bringen. Ein weiteres Kabel mit vielen dünnen Kabeln wird ebenfalls mit dem Ladegerät verbunden. Dies ist der Balancer- Anschluss, der dafür sorgt, dass jede Zelle im Akku selbst die gleiche Ladespannung erhält. D.h. einzelne Zellen werden bei Bedarf über den Balancer-Anschluss nachgeladen.

Quadrocopter LiPo – Akku (Lithium Polymer) Welche Werte muss man beim Ladegerät einstellen? Ein normales LiPo Ladegerät fragt im Normalfall folgende Daten ab: -> Ampereangabe des Akkus (dies dient als zusätzlicher Schutzmechanismus – sollte aus irgendeinen Grund versucht werden mehr Ampere in den Akku zu laden, als dieser fassen kann, löst der Schutz des Ladegerätes aus und beendet den Ladevorgang.) -> Ampereangabe zur Höhe der Ladespannung (dieser Wert muss entweder über den C-Wert, wie oben beschrieben, ermittelt werden oder ist direkt als mA bzw. als A-Ladestrom auf dem Akku zu finden – evt. auch im Datenblatt zum Akku) -> Ladeendspannung des Akkus (dieser Wert entspricht nicht den 3,7 Volt einer Einzelzelle! Um einen LiPo Akku richtig voll zu laden, muss die Voltangabe auf ca. 4,2 Volt hoch geregelt werden.)

Quadrocopter LiPo – Akku (Lithium Polymer) Die wichtigsten Daten bei einem normalen Ladevorgang! Oft bieten die Ladegeräte jedoch noch mehr Ladeprogramme an! Erhaltungsladung / Lagerungsladung: Einen LiPo Akku sollte man wenn möglich nicht bis an das Maximum laden und danach in den Schrank einlagern! Wer seinem LiPo Akku etwas Gutes tun möchte, der wählt am Ladegerät den Punkt Erhaltungsladung aus und stellt dort eine Spannung von 3,8 Volt ein. Dieser Wert ist optimal, um den Akku über längere Zeit einzulagern. Von diesem Wert aus kann der Akku dann auch recht schnell „fertig“ geladen werden. Optimale Lagertemperatur liegt zwischen 16 und 18 Grad.

Quadrocopter LiPo – Akku (Lithium Polymer) Entladen eines Akkus über das Ladegerät: Auch dies ist möglich und auch hier wird die Spannung abgefragt, wie weit der LiPo entladen werden soll. 3 Volt sind die absolute Untergrenze für einen LiPo Akku. Einen manuellen Entladevorgang sollte man auf 3,3 Volt ansetzen. Hier kann man dann sicher stellen, dass der Akku beim Entladen keinen Schaden nimmt. Wissenswertes zu den LiPo Akkus: Die optimale Betriebsspannung eines LiPo Akkus fängt bei ca. 20 Grad an. Befindet sich die Temperatur darunter wird man kein optimales Ergebnis erzielen. Die maximale Temperatur eines LiPo Akkus liegt bei ca. 60 Grad. Ab dieser Gradzahl fängt ein chemischer Prozess im Akku an, welcher zur Zerstörung führt.

Quadrocopter Brushless Motor (BLCD)
Brushless-Motoren (BLDC, Brushless DC Motor) sind bürstenlose Gleichstrommo-toren, wobei zwischen Außen- und Innenläufern unterschieden wird (Outrunner/Inrunner). Erstere haben ein höheres Drehmoment bei niedrigerer Drehzahl, bei Innenläufern ist es umgekehrt. Diese Art von Motor läuft somit leiser und kann höhere Drehzahlen erreichen, weswegen Brushless-Motoren häufig im Modellbau eingesetzt werden. Beispielsweise finden sich bei Quadrocoptern ausschließlich solche als Antrieb, da zudem auch die Leistung pro Masse höher ist und damit auch der Wirkungsgrad. Der wohl größte Vorteil ist der Wegfall von Bürsten/Kohleschleifer, somit können nur die Wellen-lager verschleißen. Bürstenlose Motoren finden aber auch in Alltagsgeräten wie etwa CD/DVD-Spielern, PC-Lüftern und Festplatten Anwendung, wo es entweder auf Laufruhe oder auf konstante Drehzahlen ankommt. Jeder Schrittmotor in Scannern, Druckern und vielen weiteren Geräten ist auch bürsten-los und besitzt eine hohe Schrittanzahl pro Umdrehung, wodurch der Winkelversatz pro Schritt sehr viel kleiner ist (Größenordnung um die 1.8°).

Quadrocopter Brushless Motor
Zusammenfassend sind die Vorteile dieser Motoren: 1.Laufruhe 2.Höhere Drehzahlen möglich 3.Stellgenauigkeit (Auch ohne ext. Sensorik) 4.Wenig Verschleiß (Nur die Lager) 5.Höherer Wirkungsgrad Und die Nachteile: 1.Eine spezielle Steuerelektronik wird benötigt (ESC, electronic speed controller) 1: Festplattenmotor (3,5″, 7200 U/min) 2: Nema-Schrittmotor 3: CD-Player (Notebook) 4: Videokopf aus 8mm-Camcorder 5: Videorecorder 6: Lüfter

Quadrocopter Brushless Motor Ansteuerung
Die Ansteuerung wird nicht mit einer Gleichspannung bewerkstelligt, deren Intensität die Drehzahl bestimmt, sondern über ein Drehfeld. (Modellbau) BL-Motoren haben in der Regel 3-4 Anschlüsse, die abwechselnd bestromt werden, jeweils mit 120° Phasenverschiebung. Die Frequenz dieses Drehfeldes bestimmt die Drehzahl, der maximale Ausgangsstrom kann einfach über PWM geregelt werden.

Anschluss 12 Der ESC (oben) besitzt 2 Hoch-stromeingänge für die Versor-gung, sowie einen 3-poligen Stecker, an dem die Masse und das Taktsignal (hier orange) der Fernsteueranlage anliegen. Die meisten ESCs haben zudem einen sog. BEC (Battery Eliminator Circuit) integriert (kleines rotes Kabel), wodurch zusätzlich gere-gelte 5V für weitere Elektronik bereitgestellt wird und auf einen zusätzlichen Spannungswandler verzichtet werden kann. Hier muss beachtet werden, dass zwar die Masse des ESCs mit der des Arduinos verbunden wird, jedoch nicht die rote 5V-Leitung, sonst kommt es zum Kurz-schluss zweier Spannungsquellen! Die Signalleitung wird an dem gewünschten Pin angeschlossen.

Quadrocopter Brushless Motor Anschluss 12
Das Taktsignal ist ein einfaches Rechtecksignal mit einer Periodendauer von meist 20 ms, obwohl auch kürzere Zeiten noch möglich sind (und eine entsprechend höhere Aktualisierungsrate). Wichtig ist die Pulsdauer, die zwischen 1 ms und 2 ms liegt, was in 0-100% Aussteuerung resultiert, bei Servos 0-180°, bei ESCs die Drehgeschwindigkeit. Hierbei ist noch sehr wichtig, dass viele ESCs gar nicht erst starten, wenn am Anfang die Aussteuerung 0% beträgt (servo.write(0)), es muss ein kleiner Offset vorgegeben werden. Zudem sind ESCs für Flugmodelle grundsätzlich leichter anzusteuern, da Modi wie Bremsen oder Rückwärtsgang grundsätzlich fehlen. Nachfolgend ist hier der Code für den Arduino, über servo.write(Wert) kann man die Geschwindigkeit des Motor regeln.

Quadrocopter Brushless Motor #include <Servo.h>
Anschluss 12 Brushless Motor #include <Servo.h> Servo servo; // Erzeugung eines Servoelements unsigned long startzeit; unsigned long messzeit = ; // Messintervall in Mikrosekunden int val = 25; void setup(){ Serial.begin(115200); startzeit = micros(); servo.attach(12); servo.write(25); // Wird zum Initialisieren des ESC benötigt delay(2000); //servo.write(40); } void loop(){ if ((micros()- startzeit) >= messzeit){ servo.write(val); Serial.println(val); val = map(analogRead(A0), 0, 1023, 30, 110);

Anschluss 12 Brushless Motor Einfaches Programm zum Testen der Brushless-Motoren. Achtung: ohne Propeller #include <Servo.h> Servo esc_signal; void setup() { esc_signal.attach(12); esc_signal.write(30); delay(2000); } void loop() { esc_signal.write(55); delay(15)

Quadrocopter ESC ESC – Electronic Speed Controller
As the brushless motors are multi-phased, normally 3 phases, you can’t just apply power to it to make it spin. The motors requires some special phase-control electronics that is capable of generating three high frequency signals with different but controllable phases, but the electronics should also be able to source a lot of current as the motors can be very “power-hungry”.

Quadrocopter QUADX QUADX: Diese Variante hat 2 Motoren vorne (Flugrichtung VORNE liegt zwischen den beiden Frontmotoren) und zwei Motoren hinten. Diese Variante bietet den Vorteil, dass bei Kameraflügen kein Motor im Bild ist.

Quadrocopter HMC5883L Gyro – MPU 6050 BMP085

Quadrocopter HMC5883L MPU6050: ist DER meistbenutzte Sensor im aktuellen Copterbau (Stand:März 2013). Die MPU6050 wird von InvenSense gefertigt und vereint ein hochpräzises Gyro und einen hochpräzisen Beschleunigungssensor in einem Gehäuse. Durch diese Bauweise und weil die internen Sensoren die genauesten sind, empfehle ich für jeden Neubau diesen Sensor als Gyro+ACC. Keiner der oben genannten Sensoren erreicht annähernd die Genauigkeit der MPU6050. Gyro – MPU 6050 BMP085

Quadrocopter Die config.h flashen (=übertragen) Die MultiWii Software
Am besten lädt man das Paket 2.3, das nach dem Entpacken des ZIP-Files in ein Verzeichnis zwei Ordner enthält: MultiWii …. enthält die nötige Konfigurationsdatei MultiWiiConf …. ist das GUI für spätere Schritte Mit der Arduino-Softwareumgebung lassen sich Dateien mit der Endung *.ino aufrufen. Gebraucht wird die Datei im Ordner MultiWii/MultiWii.ino

Quadrocopter Die config.h flashen (=übertragen)
Die Arduino-Programmierumgebung Als erstes muss der Flugregler über eine FTDI-Schnittstelle mit einem USB-Kabel am einen Windows-Rechner angeschlossen werden. Über Werkzeuge müssen Board, Prozessor und Port eingestellt werden. Board  Arduino Pro or Pro Mini Prozessor  ATmega328(5V, 16MHz) Port  Com ? (die Portnummer ist rechnerabhängig)

Quadrocopter Die Arduino-Programmierumgebung - arduino windows.zip – 197 MB Die config.h flashen (=übertragen) In der Leiste mit den Dateinamen gibt es ein nach unten hin spitzes Dreieck. Klickt man dieses an, so erscheinen Dateien in einem Aufklappfenster. Hier wählt man ziemlich weit unten die Datei config.h und öffnet diese. Dann müssen einige Einstellungen vorgenommen werden.

Die Arduino-Programmierumgebung - arduino windows.zip – 197 MB Hier wird die Art des Copters eingestellt. Dies geschieht durch Entfernen der beiden Schrägstriche. Für einen Quadrocopter lautet diese Einstellung: #define QUADX

Die Arduino-Programmierumgebung - arduino windows.zip – 197 MB Dann muss noch die Art des Boards angegeben werden. Hier handelt es sich um das Hobbyking- Board mit den entsprechenden Sensoren. Die Einstellung lautet: #define HK_MultiWii_SE_V2

Die Arduino-Programmierumgebung - arduino windows.zip – 197 MB Der minimale Wert für Throttle muss eingestellt werden. Hier gibt es speziell für die Simonk-Regler einen Zahlenwert. Diese lautet: #define MINTHROTTLE 1064

Die Arduino-Programmierumgebung - arduino windows.zip – 197 MB Diese geänderte Datei wird auf den Flugcontroler übertragen (heißt auch flashen). Dazu geht man in der Menueleiste auf Datei  Hochladen Wenn dieses nicht klappen sollte, wird eine Fehlermeldung ausgegeben. Die Beschreibung des Fehlers ist meistens nachvollziehbar. Dann kann man diesen beheben und erneut hochladen. Häufig liegt es an der Verbindung über USB. Unter Umständen ist dann der Com-Port nicht richtig oder die Wahl des Boards muss geändert werden.

Quadrocopter Die Teileliste
Außerdem muss die Software für die Einstellung der MultiWii-Umgebung herunter geladen werden. Mit Hilfe des FTDI-Adapters wird der MultiWii mit dem Laptop verbunden. Einstellungen für die Übertragung des Sketch in der IDE - Arduino: Board  Arduino Pro or Pro Mini

Quadrocopter Für die Übertragung der Konfigurations-datei benötigt man die IDE-Umgebung des Arduino. Diese muss installiert werden. arduino windows.zip – 197 MB Außerdem muss die Software für die Einstellung der MultiWii-Umgebung herunter geladen werden. Mit Hilfe des FTDI-Adapters wird der MultiWii mit dem Laptop verbunden. Einstellungen für die Übertragung des Sketch in der IDE - Arduino: Board  Arduino Pro or Pro Mini

Quadrocopter MultiWii starten Fehlermeldung
Unter Umständen lässt sich die Software nicht starten und gibt folgende Fehlermeldungen aus: 1.Error: Registry key `Software\JavaSoft\Java Runtime Environment`\CurrentVersion` has value `1.8´, but ´1.7`is required 2.Error: Could not find java.dll 3.Error: Could not find Java SE Runtime Environment Eine neue Java Runtime Version aufzuspielen bringt keine Lösung des Problems.

Quadrocopter MultiWii starten
Die Lösung sieht wie folgt aus (Windows 7) : 1.Im Start-Menue (links unten) regedit eintippen, um die Registry aufzurufen. Vorsicht. 2.Im Menuepunkt HKEY_LOCAL_MACHINE anklicken, dieser befindet sich in der linken Spalte auf dem Bildschirm. 3.In SOFTWARE innerhalb von HKEY_LOCAL_MACHINE verzweigen 4.Innerhalb von SOFTWARE JavaSoft anklicken. 5.Dann Java Runtime Environment innerhalb von JavaSoft anklicken 6.Im rechten Fenster CurrentVersion anklicken und in 1.7 ändern. Dann den Registry-Editor schließen Dann müsste MultiWii starten.

Quadrocopter PID-Werte
Die PID-Werte (engl: proportional–integral–derivative, deutsch: proportional-integrierend-verzögernd) bestehen aus den Anteilen des P-Gliedes, des I-Gliedes und des D-Gliedes. Diese drei Werte dienen zum Erfassen von sämtlichen für das System messbaren Einflüssen. Im Fall eines Multirotorsystems sind die Einflüsse Winkelveränderungen (Gyro), Beschleunigungen (ACC und Magnetometer) und Druckveränderungen (Barometer) existent, ständig durch die Sensoren zu erkennen und durch die PID-Regler auf die Lage stabilisierend zu wirken, um dabei ein nahezu schwingfreies Verhalten zu zeigen. Jedes Multirotorsystem reagiert durch seinen mechanischen und elektrischen Aufbau auf Einflüsse anders und benötigt daher eine ganz individuelle Einstellung.

Quadrocopter P-Wert P ist die Korrekturkraft die den Copter wieder in seine Ausgangsposition bringt. Je höher der P-Wert ist, desto höher ist die Kraft mit der der Copter wieder in seine Ausgangsposition zurückkehren will. Erhöhung des P-Wertes: Der Copter ist immer stabil bis der P-Wert zu hoch ist. Dann beginnt der Copter zu schwingen und man beginnt die Kontrolle zu verlieren. Senkung des P-Wertes: Wird der P-Wert zu weit gesenkt, gerät der Copter ebenfalls außer Kontrolle. Praxiswerte: Bei Coptern mit 35 bis 40cm Achsabstand sind P-Werte von 3,0 bis 3,5 auf ROLL und PITCH empfehlenswert. Für weniger als 30cm Achsabstand sollte der Wert unter 3,0 liegen.

Quadrocopter I-Wert I ist der Zeitraum, bei dem die Winkel- und/oder Änderung abgetastet und gemittelt wird. Der Ausschlag der Korrekturkraft wird somit bestimmt, um zur Ausgangsposition zurück zukehren. Erhöhung des I-Wertes: Wird der I-Wert erhöht, so erhöht man die Wahrscheinlichkeit die Ausgangsposition zu halten und Drifts zu reduzieren. Ebenso steigt die Verzögerung für die Rückkehr in die Ausgangsposition. Senkung des I-Wertes: Die Verzögerung der Veränderung wird verkleinert, der Drift erhöht sich, die Fähigkeit Position zu halten wird reduziert. Praxiswerte: Werte zwischen 0,010 und 0,050 sind in der Realität normal. Wert mit maximal 0,005 erhöhen oder senken.

Quadrocopter D-Wert D ist die Geschwindigkeit mit der der Copter in seine ursprüngliche Position zurückkehren soll. Dies spielt auch mit der Wirkung des P-Wertes zusammen. Der Wert bei D ist ein Negativwert! Erhöhung des D-Wertes: Hier wird die Geschwin-digkeit erhöht, mit der der Copter in seine Ausgangs-position zurück will. Erhöhung des D-Wertes steigert die Wahrscheinlichkeit des Aufschwingens. Senkung des D-Wertes: Reduziert die Geschwindig-keit, mit der der Copter in seine Ausgangsposition zurückkehren will. Praxiswerte: Werte zwischen 5 und 25 sind als normal anzusehen.

Quadrocopter Bezeichnung der Flugbewegungen Abkürz. Englisch Deutsch
Bedeutung THR THROTTLE Gas Steigen nach oben/unten ELE ELEVATOR Höhe Nick nach vorn/hinten RUD RUDDER Seite Yaw um Achse drehen AIL AILERON Quer Roll nach links/rechts

Quadrocopter Multiwii SE V2.6 – FTDI USB-Schnittstelle
100% Pin-Kompatibel, mit der FTDI USB Schnittstelle können alle Einstellungen bequem am PC gemacht werden.

Quadrocopter – Teileliste
Technische Daten: Durchmesser: 52 cm diagonal Motor-Befestigungsbohrungen: 16mm und 19mm 1. Der Rahmen Frame FPV X520D-SS – XXL-Modellbau – Preis 23,35 Euro

2. 6-Kanal-Fernsteuerung FlySky FS-I6 2.4G 6-Kanal Fernbedienung System FS i6 2.4g 6fach Sender mit FS-iA6 Empfänger für RC 51,99 Euro

3. ESC Electronic Speed Controller SODIAL(R)4Pcs Simonk 20AMP 20A SimonK 16,51 Euro

4. Brushless-Motoren LHI 2CW 2CCW MT2204Ⅱ 2300KV Brushless Motor 4x – 36,-- Euro

Quadrocopter FPV - Kamera
FPV ist die Abkürzung der Worte „First Person View“ (also sinngemäß Blick von vorderster Front) und beschreibt die Aufnahme von Bildern oder Filmen in der „Ich“-Perspektive. Das Bild wird dabei aus Sicht des Quadrocopters aufgenommen. Im Modellflug wird zusätzlich zwischen passivem FPV und aktivem FPV unterschieden. Beim passivem FPV werden Flugaufnahmen erst nach dem Flug betrachtet, während beim aktivem FPV Kameras eingesetzt werden, die in Echtzeit ein „Live“-Bild des Fluges auf Bildschirm, PC, Handy, Tablet oder einer Videobrille mit Headtracking übertragen. Aktives FPV bietet demnach besondere Kontrolle über den Flug und die Umgebung die aufgenommen werden soll. Als FPV-Kamera werden in der Regel kleine, leichte Kameras wie CCD oder CMOS eingesetzt. Bei der Wahl einer FPV Kamera gibt es aber einige wichtige Punkte zu beachten. Mit welcher Spannung möchte ich meine Kamera betreiben? Benötige ich einen Spannungsfilter? Mit oder ohne Infrarot Filter (IR Filter)? Welche Linse soll ich nehmen (2,1mm, 2,8mm oder 3,6mm? Was ist Latens?

Internetadressen XXL-Modellbau Inhaber: Carsten Steffen
Neuheimer Weg 16 Jüterborg Deutschland Tel: / post(at)xxl-modellbau.de

Abkürzungen I2C I2C-Bus – Inter-Integrated-Circuit
Der I2C-Bus (I2C = I²C = IIC = Inter-Integrated-Circuit) wurde von der Firma Philips für die Kommunikation zwischen einzelnen Schaltkreisen innerhalb eines Gerätes entwickelt. Beim I2C-Bus handelt es sich um eine synchrone serielle 2-Drahtverbindung zwischen einem Master und einer beliebigen Anzahl Slaves. Auf der einen Leitung (SCL) wird der Takt übertragen, die andere Leitung (SDA) dient der Übertragung der Daten. Die Daten können vom Controller zum Slave laufen (schreiben), oder aber auch vom Slave zum Master (lesen). Der Takt wird dabei aber immer vom Master erzeugt. I²C ist als Master-Slave-Bus konzipiert. Ein Datentransfer wird immer durch einen Master initiiert; der über eine Adresse angesprochene Slave reagiert darauf. Dazu zieht der Master die SCL Leitung auf Low und schickt dann die Adresse des gewünschten Bauteils auf die SDA Leitung. Außerdem wird dem Slave mitgeteilt, ob geschrieben oder gelesen werden soll. Der Vorteil des I²C-Busses ist, dass an nur 2 Leitungen nahezu unbegrenzt viele Geräte angehängt werden können. Im MultiWii-Bereich kommt fast ausschließlich dieser Bus zum Einsatz. Die Sensoren werden einfach parallel an dem Bus angeschlossen. Es gibt 2 standardisierte Taktraten: 100kHz und 400kHz. Wer nicht mit dem originalen WiiMotionPlus (kurz: WMP) fliegt, sollte 400kHz einstellen.

WICHTIG Abkürzungen IDE – Integrated Development Enviroment
ArduinoISP - InSystemProgrammer PID – Proportional Integral Derivate (deutsch: proportional-integrierend-verzögernd GUI – Graphical User Interface GPS – Global Positioning Systems ESC – Electronic Speed Control FPV – First Person View – Kamera (z.B. für Quadcopter) DIY – Do It Yourself TVL – TeleVision Lines - Auflösung von FPV-Kameras, 800 ist ein guter Wert BEC - Battery – Eliminating - Circuit ESD - Electrostatic Discharge -> elektrische Entladung Copyright by H. Sporenberg-2016

Abkürzungen Propeller - Drehung Artikel-Nr.
CW-Propeller: Clockwise – im Uhrzeugersinn CCW-Propeller: Contra Clockwise – gegen den Uhrzeugersinn Artikel-Nr.

Arduino am Raspberry Pi
Der Arduino kann auch über den Raspberry Pi programmiert werden. Dazu muss als erstes die Programmierumgebung für den Arduino auf dem Raspberry installiert werden. sudo apt-get update sudo apt-get upgrade sudo apt-get dist-upgrade sudo apt-get install arduino

Arduino am Raspberry Pi
Der serielle Port lautet: /dev/ttyACM0

Zeitschriften für den Raspberry und Arduino
Es gibt im Netz kostenlose Zeitschriften sowohl für den Raspberry Pi als auch für den Arduino. Die Zeitschrift mit Themen nur für den Raspberry Pi heißt MagPi und kann von der folgenden Seite heruntergeladen werden: „ Die andere Zeitschrift heißt Hackspace und beinhaltet Themen nicht nur für den Raspberry Pi und Arduino. Die Seite hat die folgende Adresse: „ „

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