http://sites.schaltungen.at/arduino-uno-r3/michael-arduino/michael-bonacia
http://www.linksammlung.info/
http://www.schaltungen.at/
Wels, am 2017-02-08
BITTE nützen Sie doch rechts OBEN das Suchfeld [ ] [ Diese Site durchsuchen]
DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4 ausdrucken siehe http://sites.schaltungen.at/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-michael.arduino-michael.bonacia (xx Seiten)_1a.pdf
Untergeordnete Seiten (2):
Arduino Handbuch für Einsteiger: € 14,99
Der leichte Weg zum Arduino-Experten
Taschenbuch– 14. April 2017
von Michael Bonacina
Hornissenweg 4
D-84034 Landshut
-
Taschenbuch: 108 Seiten
-
Verlag: CreateSpace Independent Publishing Platform; Auflage: 1 (14. April 2017)
-
Sprache: Deutsch
-
ISBN-10: 1544255497
-
ISBN-13: 978-1544255491
-
Größe und/oder Gewicht: 14 x 0,6 x 21,6 cm
https://www.amazon.de/Arduino-Handbuch-f%C3%BCr-Einsteiger-Arduino-Experten/dp/1544255497/ref=tmm_pap_swatch_0?_encoding=UTF8&qid=&sr=#reader_1544255497
Einband-Text:
Die Arduino Plattform, bestehend aus Hardware und Software, erleichtert den Einstieg in die Welt der Mikrocontroller sehr. In diesem Buch erfährst du alles, was notwendig ist, um deine Projekte und Ideen mit dem Arduino endlich realisieren zu können: Egal ob autonomer Roboter oder Heimautomation, mit diesem Buch kannst du sie schnell in die Tat umsetzen, ohne Vorkenntnisse zu benötigen.
Zunächst werden die Grundlagen des Arduino geklärt und direkt, ohne graue Theorie, die ersten Sensoren und Aktoren verwendet. Danach geht es tiefer in die Materie mit spannenden Themen, wie die Verbindung des Arduino mit dem World Wide Web oder der Ausgabe von Texten und Diagrammen auf Displays. Am Ende lernst du einige Projekte, wie eine Arduino Wetterstation oder einen autonomen Roboter kennen und kannst darauf basierend deine Traumprojekte realisieren.
Ich habe dieses Buch als Geschenk gekauft, da ein Freund von mir den Einstieg in die Heimautomatisierung wagen möchte und bis jetzt noch keine Erfahrung mit Arduinos hat.
Zu allererst muss ich sagen, dass das Buch genau das verspricht, was der Titel sagt. Es ist ein EINSTIEG in die Welt der Arduinos, um absoluten Anfängern einen ersten Überblick über die Verwendungszwecke und erste Schritte zu geben. Dies finde ich sehr gelungen, wobei ich mir an einigen Stellen doch einen etwas tieferen Einblick in die Materie gewünscht hätte.
Wir haben das Buch beide gelesen und sind nachher einige Fragen meines Freundes durch gegangen.
Für diesen Verwendungszweck ist das Buch absolut gut geeignet. Es bereitet auch schon etwas auf das recherchieren im Internet nach Arduino Problemen und Lösungsansätzen vor. Als Verbesserung hätte ich mir bei einem Thema eine wirklich detailierte und rundum vollständige Erklärung gewünscht. Für Einsteiger kann ich das Buch sofort empfehlen, Fortgeschrittene werden hier allerdings keine wirklichen neuen Erkentnisse erlangen
Das Buch bietet einen oberflächlichen Einstieg in den Arduino und zeigt an Beispielen, was alles mit dem Arduino möglich ist.
Leider kratzt das Buch meistens nur an der Oberfläche und ist so für jemanden, der sich schon etwas mit dem Arduino befasst hat, wertlos.
Ich habe diese Buch durch Vorabreservierung als E-Book für 99ct erhalten. Persönlich finde ich ist das Buch noch nicht mal diese 99ct wert. Es handelt sich um eine oberflächliche Abarbeitung der Möglichkeiten des Arduino. Es gibt im Netz deutlich bessere kostenlose Anleitungen zu den einzelnen Themen.
https://az-delivery.de/
-B01- ESP 8266 mit Arduino verbinden
-B02- Internet of Things Plattformen - ESP 8266
-B03- Buchriewiev: "Make: Basic Arduino Projects"
-B04- Schaltungen am PC testen
-B05- Feuchtigkeitsensor selber bauen
-B06- Sensorwerte visualisieren
-B07- Programmiertricks für Arduino Sketche
-B08- Software PWM
-B09- Fehler in Arduino Sketchen finden
-B10- Mehrere Buttons an einem analog Eingang
-B11- Online IDE Codebender
-B12- Pull-up und Pull-down Widerstände
-B13- Button entprellen
-B14- DS18B20 Temperatursensor
-B15- Software I2C
-B16- ESP 8266 als Wlan Repeater http://michaelsarduino.blogspot.de/2016/02/esp-8266-als-wlan-repeater.html
-B17- Daten aus dem Internet abrufen und an Arduino ausgeben
-B18- Processing (mit dem Arduino)
-B19- LED am Arduino über grafische Oberfläche am PC steuern
-B20- Registrierte Bewegung auf Website anzeigen (Arduino + Processing)
-B21- Bewegungssensor mit serieller übertragener Warnmeldung.
-B22- Daten über ESP 8266 in Cloud laden
B - Michael Bonacia
https://plus.google.com/110786353506245861399
-B01- ESP 8266 mit Arduino verbinden - ESP8266-01S Wlan Modul
In diesem Post geht es darum, wie man den ESP 8266 , ein Wlan Modul für 4€, mit dem Arduino verbinden kann. Dadurch übernimmt der ESP die Rolle als Webserver, und leitet die Steuerungsbefehle an den Arduino Uno weiter.
Um eine Beispielkommunikation darzustellen wollen wir auf dem ESP eine Weboberfläche erstellen, auf der man die LED des Arduino (Pin 13) steuern kann. Wie man den ESP8266 mit dem Arduino verbindet, habe ich bereits hier erklärt.
http://michaelsarduino.blogspot.co.at/2015/09/led-uber-internet-steuern-mit-esp-8266.html
Der ESP 8266 als Webserver
Die Weboberfläche besteht aus 2 Radiobuttons und einem Absendebutton. Radiobuttons, sind Buttons, bei denen immer nur ein Button ausgewählt sein kann. Dadurch muss man wählen, ob die LED an oder aus sein soll. Über den Submit Button sendet man das HTML Formular ab.
Dabei wird das Formular über die Funktion GET übertragen. Diese speichert/übertragt die Werte über die Url:
Um die Url, welche der User aufruft abzufragen, kann man die Funktion client.readStringUntil('\r') verwenden. Nun muss man nur noch herausfinden, ob der String ?led1=1 oder ?led1=0 enthalten ist, also ob die LED an oder aus sein soll. Dabei ist die Funktion indexOf() hilfreich. Diese gibt -1 zurück, wenn ein String nicht enthalten ist, oder die Position des ersten Zeichen der Zeichenkette im String als Zahl (beispielsweise 5). Dadurch kann man herausfinden, wie die LED geschaltet werden soll.
Um nun die Information an den angeschlossenen Arduino weiterzuleiten, kann man die serielle Verbindung nutzen. Dabei kann man alle gewohnten Befehle auf beiden Seiten nutzen. Wie man eine serielle Verbindung herstellt, erfahrt ihr hier. Bei nur einer LED, kann man einfach 1 für an, oder 0 für aus, übertragen.
Der gesamte Sketch für den ESP 8266 sieht dann so aus:
|
const char* ssid = "WLAN HORNISSENWEG 4";
|
|
|
const char* password = "unserpasswort";
|
|
|
WiFi.begin(ssid, password);
|
|
|
while (WiFi.status() != WL_CONNECTED) {
|
|
|
// Check if a client has connected
|
|
|
WiFiClient client = server.available();
|
|
|
while(!client.available()){
|
|
|
// Read the first line of the request
|
|
|
String req = client.readStringUntil('\r');
|
|
|
String html = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html> <h3> LED 1 </h3><form action=\"192.168.178.30/index.html\" method=\"GET\"> <input type=\"radio\" name=\"led1\" value=\"1\" />AN <br /> <input type=\"radio\" name=\"led1\" value=\"0\" />AUS <br /> <input type=\"submit\" name=\"absenden\" value=\"schalten!\" /><br /></form></html>\n";
|
|
|
if (req.indexOf("?led1=0") != -1)
|
|
|
else if (req.indexOf("?led1=1") != -1)
|
|
|
else if(req.indexOf("/index.html") != -1)
|
|
|
//Serial.println("invalid request");
|
|
|
// Send the response to the client
|
|
}
ESP8266_LED_Webserver.ino hosted with ❤ by GitHub
Der Arduino Sketch
Der Arduino muss nur eine serielle Verbindung mit der selben Datenrate (in diesem Fall 115200) starten, und warten, bis er etwas über die serielle Verbindung empfängt. Auch hier muss man wieder 48 für 0 und 49 für 1 angeben, da die Zahlen als Text übertragen werden, und somit ihre ASCII Werte übermittelt werden. Der Sketch sieht dann so aus:
|
if(Serial.available() >0)
|
|
|
int status_led = Serial.read();
|
|
}
Die Kommunikation zwischen dem ESP 8266 (hier bei AZ-Delivery) und dem Arduino Uno gestaltet sich denkbar einfach, und durch die Verbindung der beiden Geräte kann man ihre Vorteile geschickt kombinieren (ESP als leistungsstarke Webserver, und Arduino als Steuerungseinheit mit vielen Pins).
-B02- Internet of Things Plattformen - ESP 8266 Wlan Modul
In dieser Artikelserie möchte ich auf die verschiedenen Möglichkeiten und Plattformen eingehen, mit denen man Projekte für das Internet of Things erstellen kann.
Das ESP 8266
[By Sparkfun, Link zur Datei, Lizenz]
Der ESP 8266 Chip ist ein Wifi Modul, das bedeutet, dass man über ihn einen normalen Mikrocontroller, über Wlan, mit dem Internet verbinden kann. Zusätzlich jedoch, hat der ESP 8266 Chip selbst auch GPIO Pins, also Ein- und Ausgänge, weshalb der ESP8266 selbst als Internet of Things Plattform verwendet werden kann.
Der große Vorteil gegenüber allen anderen bisher vorgestellten Lösungen ist, dass der ESP8266 sehr billig ist. Die billigste Version gibt es bereits ab ca. 4€. Es gibt verschiedene Versionen des ESP 8266 von 01 bis 12. Hier gibt es einen guten Überblick über die verschiedenen Versionen. Oben ist Version 01 mit nur 2 GPIO Pins abgebildet.
Um den ESP 8266 zu programmieren gibt es verschiedene Möglichkeiten. Die meiner Meinung nach Einfachste, ist den ESP 8266 über die Arduino IDE zu programmieren. Dort kann man dann auch die gewohnten Arduino-Befehle verwenden. Um den Controller zu programmieren benötigt man dann nur noch einen USB Seriell Adapter für 2€ - 3€ ( beispielsweise dieser).
Sollte man den ESP8266 an einen Mikrocontroller anschließen, braucht man keinen Adapter, und kann den ESP 8266 dann über AT Befehle steuern.
Auf der Hardware Seite gibt es einen 80Mhz "Prozessor" und 512KB Flashspeicher für die Programme und die Websiten. Aus diesem Grund kann man die Websiten auch nicht zu groß gestalten und leider keine Bilder einfügen.
Fazit
Der ESP 8266 ist eine gute, sehr Arduino nahe Plattform, um anzufangen Projekte für das Internet der Dinge zu bauen. Aufgrund des phänomenal günstigen Preises ist auch die etwas schwächere Hardware vertretbar.
Eingestellt von Michael Bonacina um 12:56
Diesen Post per E-Mail versendenBlogThis!In Twitter freigebenIn Facebook freigebenAuf Pinterest teilen
Bei meiner Version der Arduino IDE kann man keine esp-8266 auswählen. Muss ich da was extra installieren?
Ja, du musst etwas nachinstallieren. Eine ausführliche Anleitung dazu findest du hier:
http://arduino-hannover.de/2015/04/08/arduino-ide-mit-dem-esp8266/
michaelsarduino: Internet of Things Plattformen - ESP 8266
https://www.linkedin.com/pulse/einstieg-das-internet-things-iot-mit-dem-esp8266-norbert-redeker
http://www.golem.de/news/mitmachprojekt-temperatur-messen-und-versenden-mit-dem-esp8266-1604-120378.html
https://www.amazon.com/Internet-Things-ESP8266-Marco-Schwartz/dp/1786468026
-B03- Buchriewiev: "Make: Basic Arduino Projects"
In diesem kleinen Buchreview geht es um das Basic Arduino Projects Buch von Don Wilcher, welches ich mir gekauft habe.
Das Buch richtet sich vor allem an Anfänger, welche Englisch beherrschen, und besteht aus 26 Projekten/Experimenten, welche Stück für Stück komplexer werden.
Das Buch bezieht sich auf Teile aus diesem Starterkit(~140$), wobei auch ein billigeres Startkit normalerweise alle Teile enthalten sollte.
Im Buch gibt es von jedem Projekt ein Foto, einen Schaltplan, den Arduino Code sowie jede Menge Erklärungen, Informationen und Erläuterungen, wodurch alles sehr verständlich dargestellt ist.
Das Buch innen ist jedoch komplett schwarz-weiß.
Am Ende des Buches gibt es noch eine Art kleines Lexikon, in dem gezeigt wird, an welchen Stellen die Fachbegriffe erklärt/verwendet werden.
Insgesamt ist das Buch ein gutes Buch für den Einstieg in die Welt der Arduino Projekte, wobei man bereits ein paar Teile haben sollte, um nicht vor jedem Projekt etwas nachbestellen zu müssen.
Den Preis von € 30,00 finde ich jedoch überzogen; ich habe es alles B-Ware im Buchladen für € 3,00 erwerben können.
Ansonsten sollte man sich vielleicht auf ebay umschauen.
-B04- Schaltungen am PC testen
In diesem Post geht es darum, wie man mittels 123D Circuits seine Arduinoschaltungen online testen kann. Dadurch kann man seine Schaltungen ungefährlich am PC ausprobieren und testen. Auch einen Arduino kann man in die Schaltungen einbauen, sowie virtuell Code hochladen und die Schaltungen samt Code testen.
Da 123D Circuits ein Online Tool ist, muss man nichts auf seinem PC/Mac installieren und benötigt stattdessen nur einen Browser. Um seine Schaltungen online zu erstellen und testen, muss man sich einen Account machen. Dazu muss man Land, Geburtsdatum, Emailadresse und Passwort angeben. Nun kann man seine erste Schaltung erstellen.
Rechts oben befindet sich der Button Components. Durch einen Klick auf ihn öffnet sich unten eine Liste, in der man sich alle Komponenten ansehen kann, oder etwas Spezielles suchen kann.
Nun kann man sich das Passende auswählen und auf sein virtuelles Breadboard ziehen. Um etwas per Kabel zu verbinden, klickt man auf die erste Kontaktstelle und danach auf die Zweite. Sobald man ein bliebiges Objekt anklickt, erscheint eine "Karte" in der man die jeweiligen Eigenschaften ändern kann, etwa bei Widerständen die Stärke, oder bei Kabeln die Farbe.
Sollte man einen Arduino verwenden, kann der Code Editor interessant sein.
In ihn kann man den ganz normalen Arduino Code hineinkopieren, auch Bibliotheken werden unterstützt, jedoch kann man keine "nachladen", sondern nur die bereits vorhandenen nutzen.
Zusätzlich gibt es noch den Serial Monitor im Code Editor, mit welchem man sehen könnte, was der Arduino in echt am PC ausgeben würde.
Sobald man seine Schaltung fertig hat, und der Code geschrieben ist, klickt man entweder auf Upload & Run im Code Editor oder auf Start Simulation rechts oben. Nun wird der Code auf dem virtuellen 123D Circuits Arduino ausgeführt, und die Pins dementsprechend geschaltet.
Nun reagieren auch die verwendeten Komponenten. Wird beispielsweise ein Pin abwechselnd an und aus geschaltet, und ist korrekt an eine LED angeschlossen, so leuchtet auch die virtuelle LED.
Eine weitere interessante Möglichkeit ist, an jedem beliebigen Punkt im Stromkreis ein Multimeter einzubauen. Dadurch kann man an einer beliebigen Stelle entweder die Spannung, die Stromstärke oder den Widerstand messen.
Alle erstellten Schaltungen werden in der eigenen Cloud gespeichert, und können bei Interesse auch mit anderen Leuten geteilt werden.
-B05- Feuchtigkeitsensor selber bauen
In diesem Post geht es darum, wie man sich einen Feuchtigkeitssensor aus ein paar Kabeln und einem 100kOhm Widerstand baut.
Funktionsweise
Um zu messen wie viel Wasser in der Erde ist, also wie feucht sie ist, muss man wissen, dass "normale" Gartenerde eher schlecht leitet. Wasser hingegen leitet, da es normalerweise einige gelöste Salze enthält, sehr gut. Vor diesem Hintergrund ist es auch logisch, dass je nässer die Erde, desto besser leitet sie, da mehr Wasser da ist, welches besser leiten kann.
Aus diesem Grund muss man eigentlich auch nur eine Unterbrechung in dem Stromkreis zwischen dem GND und +5V machen. Diese Unterbrechung, bestehend aus zwei Drahtenden, wird in die Erde gesteckt. Je feuchter nun die Erde ist, desto mehr Storm fließt. Da eine digitale Messung zwischen Strom fließt und kein Strom fließt sehr ungenau wäre, schließt man einen analog Pin an den Stromkreis an. Der Wert dieses Pins ist dann jeweils die aktuelle Feuchtigkeit.
Der Aufbau
Damit der Abstand zwischen den beiden Pins immer gleich bleibt, und somit die Messungen vergleichbar sind, habe ich beide Drähte, mit ihren Enden, an ein Stück Pappe geklebt.
Auswertung
Um den jeweils aktuellen Messwert am PC angezeigt zu bekommen, muss man folgenden Sketch auf den Arduino laden:
|
//starten der seriellen Kommunikation
|
|
|
//auslesen des Wertes von Pin A0 und senden an PC
|
|
|
Serial.println(analogRead(A0));
|
|
}
Nun kann man in der Arduino IDE die serielle Konsole öffnen, und bekommt so die aktuelle Messung angezeigt. Da der Pin normalerweise mit den 5V verbunden ist und nur, wenn die Erde nass ist, mit dem Ground, bedeutet 1023 keine Verbindung als sehr trocken und 0 Verbindung also komplett nass.
In der Praxis ergibt sich jedoch das Problem, dass wenn beide Pins im Wasser sind ich nur ca. 150 statt 0 erhalte.
Nun sollte man ein paar Probemessungen machen, um herauszufinden, welcher Messwert nasser Erde entspricht und welcher trockener.
Um nun noch automatisch darüber informiert zu werden, wenn eine Pflanze gegossen werden muss, sollte man vielleicht eine leuchtstarke LED hinzufügen. Eine weitere Möglichkeit wäre Bluetooth für eine Benachrichtigung am Handy.
-B06- Sensorwerte visualisieren
In diesem Post geht es darum, wie man Messwerte/Sensorwerte vom Arduino mittels der Programmiersprache Processing live visualisieren kann.
Da der Arduino kein eigenes Display hat und die Möglichkeit Daten oder Messwerte auf einem externen Display ausgeben zu lassen sehr beschränkt sind, ergibt sich als Konsequenz, den PC / Mac zur Auswertung / Visualisierung der Daten zu verwenden.
Dazu benötigt man eine Programmiersprache, welche über eine serielle Verbindung(eventuell auch Bluetooth) mit dem Arduino kommunizieren kann und zusätzlich eine einfache Möglichkeit bietet die Daten "schön" zu visualisieren.
Hier bietet sich die Programmiersprache Processing an. Diese ist frei verfügbar und der Arduino IDE sehr ähnlich, sowohl im Design der IDE als auch der Programmiersprache selbst. Zu dem Thema, wie man Processing installiert und mit dem Arudino kommuniziert, habe ich bereits ein paar Tutorials gemacht.
Um die Messwerte als Grafiken anzeigen zu lassen, kann man für seinen Processing Sketch ein Programmfenster erstellen. In diesem kann man automatisch hinein "zeichnen" lassen. Glücklicherweise gibt es schon eine Menge an Programmbeispielen, für die verschiedenen Grafikenarten.
Um ein Balkendiagramm zu erzeugen, zeichnet man einfach sehr schnell hintereinander mit den jeweils aktualisierten Werten eine Linie, wodurch eine Art "sanftes Balkendiagramm" entsteht.
|
import processing.serial.*;
|
|
|
arduino = new Serial(this, Serial.list()[0], 9600);
|
|
|
arduino.bufferUntil('\n');
|
|
|
//keine sich wiederholende Aktionen
|
|
|
void serialEvent (Serial arduino) { //wird jedes mal ausgefuehrt wenn etwas ueber die serielle Verbindung empfangen wird
|
|
|
String value_string = arduino.readStringUntil('\n');
|
|
|
if (value_string != null) {
|
|
|
value_string = trim(value_string);
|
|
|
float value = float(value_string);
|
|
|
value = map(value, 0, 1023, 0, height);
|
|
|
line(xPos, height, xPos, height - value);
|
|
|
} //eine Position vorruecken oder neu starten
|
|
}
balkendiagramm.pde hosted with ❤ by GitHub
Auf dem Arduino muss einfach nur ein Sketch sein, welcher in sehr kurzen Zeitabständen den aktualisierten Wert eines analog Inputs sendet. Wenn man ein Potentiometer anschließt und daran dreht entsteht das oben gezeigt Bild.
Um ein Kreisdiagramm zu erstellen, gibt es praktischerweise bereits eine Funktion, welche man nur noch einbinden muss. Hier findet ihr sie in der offiziellen Processing Dokumentation. Damit muss man nur noch die Funktion aufrufen und ihr als Argument den Durchmesser des Kreises und die einzelnen Sektoren(als Größe der Winkel) mitgeben.
Über die Funktion text("Text", x Koordinate, y Koordinate) kann man seine Diagramme beschriften und sich zusätzliche Informationen anzeigen lassen.
-B07- Programmiertricks für Arduino Sketche
In diesem Post geht es um ein paar Programmiertipps und Tricks für Arduino Sketche.
RAM Mangel erkennen
Das tückische an RAM Mangel ist, dass man ihn, während ein Programm läuft, erst dadurch erkennt, dass ein Sketch der normalerweise einwandfrei funktioniert, plötzlich "sehr komische Dinge" tut. Um zu überprüfen, ob ein RAM Mangel herrscht, gibt es die Bibliothek "MemoryFree". Diese kann man hier herunterladen. Sobald man die .zip Datei in den Arduino libraries Ordner entpackt, und die Arduino IDE erneut gestartet hat, kann man die Bibliothek in den Sketch einbinden. Über den Aufruf der Funktion freeMemory(); kann man sich nun jeweils den aktuell noch freien RAM in Bytes anzeigen.
|
Serial.println(freeMemory());
|
|
}
free_ram_memory.ino hosted with ❤ by GitHub
Wenn man einen String, aus dem Flashspeicher, über die serielle Verbindung an den PC senden will, so sollte man nicht die Funktion Serial.println("String") verwenden, sondern Serial.println(F("String"). Dadurch wird der String nicht erst in den RAM geladen, sondern direkt versandt, wodurch die Funktion in einem Test keinen Arbeitsspeicher benötigt(vs. 2Bytes RAM pro Zeichen).
Geltungsbereich von Variablen ausnutzen
Es ist zu empfehlen, sich bei jeder Variable zu überlegen, welchen Geltungsbereich sie haben soll, also für welche Programmabschnitte sie definiert wird. Dabei ist zwischen globalen Variablen und lokalen Variablen zu unterscheiden. Durch das Trennen, wird verhindert, dass Variablen versehentlich überschrieben werden.
Um eine Variable zu einer globalen Variable zu machen, muss man sie außerhalb von setup oder loop definieren. Um eine Variable nur lokal zu definieren, definiert man sie einfach erst direkt in dem Abschnitt, wo sie gelten soll.
Bedingter Operator
Ein bedingter Operator kann als Abkürzung für eine if Schleife verwendet werden. Dabei gibt es eine Bedingung, welche wahr oder falsch ergeben muss. Anschließend definiert man einen Befehl für TRUE und einen für FALSE.
(Bedingung) ? (TRUE) : (FALSE)
Für einen Blink Sketch sähe das so aus:
digitalWrite(13, (digitalRead(13)) ? (LOW) : (HIGH);
delay(100);
Dadurch kann man sich Flashspeicher und Tipparbeit sparen.
Welche Programmiertricks kennt ihr? Schreibt sie in die Kommentare!
-B08- Software PWM
In diesem Post geht es um die Software PWM Bibliothek. Mittels dieser Bibliothek kann man an beliebigen Pins des Arduino ein PWM Signal (=Pulsweitenmodulation) erzeugen. Bei einem PWM Signal ist, beispielsweise eine LED, nicht nur an oder aus, sondern kann auch eine gewisse Stärke.
Um die Software PWM Bibliothek zu nutzen, muss man sie zunächst hier herunterladen. Nun muss man die .zip Datei entpacken und ihren Inhalt in den "libraries" Ordner eurer Arduino IDE verschieben. Sobald ihr nun die Arduino IDE startet und auf Sketch > Include Library klickt, solltet ihr die SoftPWM Library sehen.
Nachdem man die Bibliothek im Sketch nachgeladen hat, muss man zunächst im setup Teil SoftPWMBegin(); aufrufen. Ab diesem Zeitpunk kann man überall im Programm den Befehl SoftPWMSet() aufrufen. Dieser hat zwei Argumente. Das erste Argument ist der Pin, welchen ihr verwenden wollt, und das zweite die Stärke des PWM Signals(0 - 255).
Es ist möglich mehrere PWM Signale gleichzeitig zu erzeugen. Außerdem unterstützt die SoftPWM Library die analog Pins eures Arduinos.
Ein kleines Beispielprogramm, welches eine LED, angeschlossen an Pin A0, sanft an und wieder aus macht, sähe so aus:
}
-B09- Fehler in Arduino Sketchen finden
In diesem Post möchte ich darauf eingehen, wie man am schnellsten und effektivsten Fehlern in seinen Arduino Sketchen findet.
Zunächst einmal muss zwischen zwei grundsätzlichen Arten von Fehlern unterscheiden. Bei der einen Art von Fehler, gibt die IDE eine Fehlermeldung aus(siehe oben) und der Sketch landet gar nicht erst auf dem Arduino. Diese Fehlergruppe nennt sich Syntaxfehler. Bei der anderen Art von Fehler, wird der Sketch einwandfrei kompiliert, sobald der Arduino jedoch anfängt den Code auszuführen passieren andere Dinge als eigentlich vorhergesehen, beziehungsweise gar nichts. Das sind dann normalerweise Logikfehler.
Syntaxfehler
Bei einem Syntaxfehler wird unten in der Arduino IDE ein roter Balken angezeigt, sowie die Beschreibung des Fehlers. Diese Beschreibung hilf auch in den meisten Fällen den Fehler zu finden. In meinem Beispiel von oben fehlt ein Semikolon(;), und wenn man den unteren Bereich vergrößert, steht das auch 1 zu 1 so in der Beschreibung:
Eine weitere Hilfe ist auch die Zeilenangabe vor der Fehlermeldung, in diesem Fall 9. Wichtig dabei ist jedoch zu beachten, dass der Fehler, wie etwa bei einem fehlenden Semikolon, nicht in der angegeben Zeile sondern in der Zeile darüber liegt, und der Compiler erst bei Beginn des nächsten Befehls das Semikolen vermisst.
Solltet ihr mehrere Fehlermeldung angezeigt bekommen, so ist es zu empfehlen mit der ersten Fehlermeldung/Zeile im Sketch zu beginnen, da der erste Fehler die anderen als Folgefehler verursacht haben könnt.
Ein weiterer "beliebter" Fehler, der vergleichsweise schwierig zu finden ist, ist wenn man eine Bibliothek nachladen will, welche jedoch nicht gefunden wird. Deshalb sollte ihr bei einem, euch komisch vorkommenden, Fehler immer per Hand überprüfen ob alle Bibliotheken korrekt sind, und korrekt eingebunden sind.
Um einen Logikfehler zu finden, solltet ihr zunächst einmal den fehlerhaften Sketch mehrere Male ausführen lassen(drücken der Reset Taste), und schauen wie der Arduino reagiert. Dadurch sollte ihr einen Eindruck davon bekommen, wo der Arduino "falsch entscheidet" oder in welchem Abschnitt der Fehler liegen muss.
Diesen Abschnitt solltet ihr jetzt in einen neuen Arduino Sketch kopieren und gesondert ausprobieren lassen. Dadurch kann man recht schnell erkennen, ob der Abschnitt an sich funktioniert. Sollte der Abschnitt nicht funktionieren, müsst ihr ihn euch nochmal genau anschauen, oder gegebenfalls nochmal komplett neu schreiben und mit eurer bisherigen Lösung vergleichen.
Sollte der Abschnitt an sich zwar einwandfrei funktionieren, im ganzen Sketch jedoch nicht, solltet ihr überprüfen, welche Variablen der Abschnitt/die Funktion erhält, und eventuell über die serielle Konsole manuell überprüfen, ob die Variablen stimmen.
Außerdem kann der Fehler darin liegen, dass der Arduino gar nicht bis zu diesem Abschnitt kommt, da er eventuell in einer if Schleife ist, oder der Sketch in einer Endlosschleife steckt. Auch diese Fehler kann man leicht über das Ausgebenlassen der Variablen in der seriellen Konsole finden.
Wenn man PC Programme oder Apps entwickelt, so muss man sich nur mit Syntaxfehlern und Logikfehlern herunterschlagen. Beim Arduino gibt es jedoch noch eine weitere "Kategorie", welche irrtümlich als Logikfehler interpretiert wird: Hardwarefehler.
Es kann leicht passieren, dass sich ein Kabel löst, oder man etwas falsch herum anschließt. Aus diesem Grund sollte man auch immer seine Schaltungen doppelt prüfen. Auch hier kann ist es hilfreich, sich die aktuellen Messwerte von angeschlossenen Geräten auf dem PC Display ausgeben zu lassen. Dadurch kann man diese zwar eher seltenen, aber deshalb umso lästigeren Fehler vermeiden.
Außerdem sollte man überprüfen, ob alle verwendeten Komponenten einwandfrei funktionieren. Das kann man machen, indem man sie alle einzeln mit dem Arduino ansteuert und testet.
-B10- Mehrere Buttons an einem analog Eingang
In diesem Post geht es darum, wie man mit einem analog Eingang den aktuellen Status mehrer Buttons  auslesen kann.
Die Funktionsweise
Der prinzipielle Unterschied zwischen einem analog Pin und einem digital Pin ist, dass der digital Pin entweder eine Spannung bemerkt, also 1, oder keine Spannung registriert, also 0. Der analog Pin, kann jedoch unterschiedliche Stärken von Spannung unterscheiden. In der Standardeinstellung kann der Arduino alles zwischen 0V und 5V unterscheiden. Hier ein Artikel, wie man den Messbereich der analog Pins ändern kann. Aus diesem Grund kann man auch mehrere Buttons mit einem analog Pin auslesen. Das funktionier über einen kleine Trick. Normalerweise wird ein Button über einen Pull-down Widerstand auf 0 gesetzt und sobald er gedrückt wird, mit den 5V Spannung verbunden, wodurch der
Pin eine Spannung erkennt.
Es ist jedoch möglich, zwischen den Button und die +5V eine Widerstand zu setzen. Dadurch erkennt ein analog Pin nicht 5V, sondern einen bestimmten Wert darunter, abhängig von der Größe des Widerstands. Wenn man nun einen zweiten Button anschließt, jedoch einen anders großen Widerstand zwischen den Button und +5V schaltet, so erkennt der analog Pin eine andere Spannung. Durch die verschiedenen Spannung kann dann der Arduino erkennen, welcher Button gedrückt wurde.
Beispiel mit vier Buttons
Hier mal ein kleines Beispiel mit 4 Buttons und vier verschiedenen Widerständen(100 Ohm, 1kOhm, 4,7kOhm, 10kOhm):
Nun muss man einen Sketch schreiben, welcher jeweils die aktuelle Spannung an Pin A0, oder dem jeweiligen anderen analog Pin, ausliest. Dadurch kann man dann auf die Spannungsabschnitte schließen in denen sich die Spannung bewegt, wenn ein Button gedrückt wird. Beispielsweise beim Button mit dem 10kOhm Widerstand hat die Spannung immer zwischen 925 und 935 gependelt. Mit meinen Werten für die jeweiligen Button, sah der Sketch so aus:
|
int status_A0 = analogRead(A0);
|
|
|
if(status_A0 > 925 && status_A0 < 935)
|
|
|
if(status_A0 > 970 && status_A0 < 980)
|
|
|
if(status_A0 > 1010 && status_A0 < 1017)
|
|
|
if(status_A0 > 1020 && status_A0 < 1030)
|
|
}
void setup()
{
Serial.begin(9600);
}
void loop()
{
int button;
int status_A0 = analogRead(A0);
if(status_A0 < 10)
{
button = 0;
}
if(status_A0 > 925 && status_A0 < 935)
{
button = 1;
}
if(status_A0 > 970 && status_A0 < 980)
{
button = 2;
}
if(status_A0 > 1010 && status_A0 < 1017)
{
button = 3;
}
if(status_A0 > 1020 && status_A0 < 1030)
{
button = 4;
}
Serial.println(button);
delay(100);
}
Wie ihr an meinen Werten erkennen könnt, fließen doch noch relativ große Ströme. Es wäre also möglich, weitere Buttons an den analog Pin anzuschließen und dazu große Widerstände zwischen dem Button und den 5V schalten.
Wenn ihr die richtigen Werte ermittelt habt, werdet ihr feststellen, dass diese Möglichkeit super funktioniert. Einen Nachteil hat sie jedoch:
Bei dieser Verschaltung der Buttons kann immer nur ein Button gleichzeitig ausgelesen werden. Das bedeutet, sobald man zwei Buttons gleichzeitig drückt, nur der erkannt wird, welcher den kleineren Widerstand hat.
Kommentar
wenn du alle Widerstände in Serie schaltest und mit einem Knopf immer einen Widerstand überbrückst, kannst Du auch mehrere Knöpfe gleichzeitig drücken.
sobald du einen Knopf drückst, nimmst du diesen Widerstand aus der Messung und der Strom steigt an. Durch die Serieschaltung kannst du die Widerstände addieren.
Antworten
Stimmt, prima Idee. Daran habe ich gar nicht gedacht.Antworten
Parallelschaltung geht bestimmt auch.
Der Widerstandswert errechnet sich bei zwei Widerständen :
(W1 + W2)/2= gesamt
der wird immer kleiner als der kleinste Widerstand.
Lass den Wert "Status_A0" mit Serial.print mal ausgeben.
Das der Wert schwankt (925-935 bei Button1) liegt wohl am kapazitiven Anteil der Schaltung.
Wenn Du mit der Hand in die Nähe der Schaltung kommst wird sich der Wert schon ändern.
So bist Du ein Teil eines "Kondensators" bestehend aus den Drähten (ohne Abschlusswiderstand), dem Steckbrett, der Luft und Dir. Mit verkürzen und reduzieren der Leitungen und Hochohmigen Pulldowns könnte das reduziert werden.
Erst wenn eine Taste gedrückt wird, wird der "Kondensator" übersteuert, dann sollte der Wert auch genauer sein. Mit einer ausgesuchten Widerstandsreihe kannst Du die möglichen 16 Zustände bestimmt messen, wenn Du mehrere Tasten drückst. Die vier Widerstände sollten jeweils doppelt (oder mehr) so groß sein wie der Vorgänger. Dann sind noch die 10% oder 20% Fehlertoleranz der einfachen Widerstände zu berücksichtigen.
Also eine Reihe "genau" ausmessen oder gleich mit Potis aufbauen.
Dann klappt's bestimmt auch mit der Parallelschaltung!
(die Serienschaltung geht mit vier gleichen kleinen Widerständen/Potis und einem hohen Pulldown einfacher)
-B11- Online IDE Codebender
In diesem Post geht es um die Online IDE codebender, mittels derer man den Arduino im Webbrowser programmieren kann, ohne die "normale" Arduino IDE auf dem PC zu benötigen.
Vorbereitungen
Zunächst einmal müsst ihr die Seite codebender.cc aufrufen und euch registrieren. Das geht entweder über euren Google Account, euren Github Account, oder ihr erstellt euch einen neuen Account. Nachdem ihr euch nun angemeldet habt, beginnt das Setup von codebender. Um codebender auf eurem Gerät zu verwenden, muss es mit Windows, Mac OS oder Linux laufen. Außerdem müsst ihr Chrome oder Firefox als Webbrowser verwenden. Ansonsten könnt ihr euren Code nur anschauen/bearbeiten, jedoch nicht auf den Arduino hochladen.
Um codebener zu verwendem müsst ihr das codebender Plugin für euren Browser installieren. Zusätzlich muss auf eurem Gerät der Arduino Treiber installiert sein, damit ihr den Sketch hochladen könnt. Wer schon die normale Arduino IDE installiert hat, hat die Arduino Treiber bereits mit installiert. Bei den Installationsschritten werdet ihr vom codebender Setup begleitet.
Die Online IDE für den Arduino
Bei codebender kann man entweder einen neuen Sketch erstellen oder einen bestehenden Sketch hochladen. Danach kann man ihn in einem Textfeld bearbeiten, auch Highlighting, also das Anzeigen des Codes in verschiedenen Farben, um das Programm übersichtlich darzustellen, wird unterstützt.
Sobald man einen Sketch geschrieben hat, kann man ihn im Online Speicher speichern, auf Fehler überprüfen lassen und auf den Arduino hochladen.
Außerdem kann man dem Code eine Beschreibung hinzufügen, auch Videos werden unterstützt, sowie herunterladen, kopieren, teilen oder löschen.
In der Codebender IDE sind bereits 508 populäre Bibliotheken "vorinstalliert", wobei man auch manuell Bibliotheken hinzufügen kann. Bibliotheken werden ganz regulär über "#include <Bibliothek.h>" nachgeladen. Des weiteren sind diverse Beispielsketche vorhanden.
Zusätzlich kann man mittels codebender einen Bootloader über den Arduino auf einen Mikrocontroller brennen. Auch ein serieller Monitor, um die serielle Kommunikation zu überwachen, ist dabei.
Fazit
Codebender ist eine tolle Online IDE für den Arduino und besitzt auch den vollen Funktionsumfang der normalen Arduino IDE, zusätzlich jedoch kann man seine Sketch auch auf seinem Smartphone oder Tablet bearbeiten. Schade ist nur, dass man an Chrome(Chromium) oder Firefox gebunden ist, um einen Sketch auf den Arduino zu laden.
-B12- Pull-up und Pull-down Widerstände
In diesem Post geht es um Pull-up und Pull-down Widerstände. Diese werden immer dann gebraucht, wenn ein Pin des Arduino als Eingang, beispielsweise mit einem Button, verwendet wird. Dabei ist der Zustand des Eingangs klar, wenn der Button gedrückt wird. Solange er jedoch nicht gedrückt wird, weiß man nicht, ob der Eingang LOW oder HIGH ist. Über einen Pull-up Widerstand wir dann der Eingang auf HIGH geschaltet, und über einen Pull-down Widerstand auf LOW.
Die Funktionsweise von Pull-up / Pull-down Widerständen
Ein Pull-up Widerstand soll den Eingang des Mikrocontrollers auf HIGH ziehen, solange er mit nichts verbunden ist. Aus diesem Grund wird der Eingangspin über den Pull-up Widerstand(ein ganz normaler Widerstand mit einer Größe von mehreren kOhm) mit den 5V Spannung des Arduino verbunden. Dadurch entsteht nur ein kleiner, sehr begrenzter, Stromfluss, der jedoch genügt, damit der Pin auf HIGH steht.
Ein Pull-down Widerstand soll genau das Gegenteil bewirken, also den Pin auf LOW ziehen, solange er mit nichts verbunden ist. Dazu wird der Pin über einen Widerstand(mehrere kOhm groß) mit dem Ground verbunden.
Da bei beiden Varianten ein Widerstand dazwischen geschaltet ist, ist das einkommende Signal stärker, wodurch es den Status des Eingangs bestimmern kann.
Interner Pull-up Widerstand
Praktischerweise haben die verschiedenen Arduino Boards bereits interne Pull-up Widerstände integriert. Diese kann man an allen Pins verwenden, wobei ein paar Dinge beachtet werden müssen. An Pin 0 bis 12 funktionieren sie einwandfrei. An Pin 13 ist ja bekanntlich die LED und deren Widerstand angeschlossen. Diese begrenzen den Stromfluss, wodurch die Wirkung des Pull-up Widerstands zunichte gemacht wird.
Auch an den analog Pins sind die internen Pull-up Widerstände vorhanden, wobei hier durch die Verwendung der Pull-up Widerstände die analogen Werte zerstören würde. Deshalb sollte man die Pull-up Widerstände nur an den analog Pins verwenden, wenn man sie, in diesem Sketch, nur als digitale Inputs verwenden möchte.
Um die Pull-up Widerstände in der Arduino IDE zu aktivieren, schreibt man:
pinMode(Pin, INPUT);
digitalWrite(Pin, HIGH);
Die jeweilige Größe des Pull-up Widerstands variiert von Mikrocontroller zu Mikrocontroller.
Da Pull-up Widerstände um einiges häufiger verwendet werden, besitzen Mikrocontroller nur integrierte Pull-up aber keine Pull-down Widerstände.
Externe Pull-up / Pull-down Widerstände
Sollte man einen Pull-down Widerstand benötigen, oder der verwendete Mikrocontroller keinen internen Pull-up Widerstand haben, muss man externe Pull-up oder Pull-down Widerstände verwenden. Dabei verbindet man immer den Eingangspin über einen großen Widerstand mit den +5V oder dem Ground. In Kombination mit einem Button sähe das so aus:
Extener Pull-down Widerstand:
:
Externer Pull-up Widerstand:
:
-B13- Button entprellen
Das Signal eines normalen Buttons geht beim Drücken oder Loslassen des Buttons nicht sofort in den anderen Zustand über(LOW auf HIGH, oder HIGH auf LOW), sondern prellt. Prellen beschreibt das schnelle Pendeln zwischen den beiden Zuständen. Das ist ungünstig, da der Arduino das als mehrer Buttondrücker interpretiert. Über das sogenannte Entprellen kann man dieses Verhalten, mittels Hardware oder Software, abstellen.
Entprellen mittels Hardware
Der Vorteil von Entprellung mittels Hardware ist ganz klar, dass man den Button, im Programm, wie bisher gewohnt über digitalRead(button) auslesen kann. Um einen Button zu entprellen verwendet man einen Kondensator.
Der Kondensator sollte eine Kapazität von ca. 10 Mikrofarad haben. Wenn er zu groß ist, bleibt der Button auch, nachdem man ihn losgelassen hat, kurze Zeit auf LOW, und wenn er zu klein ist, ist der Entprelleffekt sehr gering. Der Nachteil vom Entprellen mittels eines Kondensators ist logischerweise, dass man für jeden Button zusätzlich einen Kondensator benötigt. Aus diesem Grund wird Hardware Entprellung eigentlich nur verwendet, wenn Software Entprellung nicht möglich ist.
Entprellen mittels Software
Beim Entprellen mittels Software wird im wesentlichen bei jeder Änderung des Status des Buttons nach einer gewissen Zeit wieder überprüft, ob er immer noch den selben Status hat. Wenn der Button also für länger, als eine definierte Zeit x, LOW oder HIGH war, so wird das als aktueller Status des Buttons übernommen und die gewünschten Befehle ausgeführt.
Wenn der Button also für länger als eine definierte Zeit x, LOW oder HIGH war, so wird das als aktueller Status des Buttons übernommen und die gewünschten Befehle ausgeführt .
|
const int button = 12; // Button Pin
|
|
|
const int led = 13; // LED Pin
|
|
|
int vorheriger_button_status = LOW;
|
|
|
long letztes_prellen = 0;
|
|
|
digitalWrite(led, led_status);
|
|
|
int aktueller_status = digitalRead(button);
|
|
|
if (aktueller_status != vorheriger_button_status) {
|
|
|
letztes_prellen = millis();
|
|
|
if ((millis() - letztes_prellen) > entprellzeit) {
|
|
|
if (aktueller_status != button_status) {
|
|
|
button_status = aktueller_status;
|
|
|
if (button_status == LOW) {
|
|
|
led_status = !led_status;
|
|
|
digitalWrite(led, led_status);
|
|
|
vorheriger_button_status = aktueller_status;
|
|
}
button_entprellen_software_arduino.ino hosted with ❤ by GitHub
Wie man sieht, erfordert das Entprellen von Buttons mittels Software einen wesentlich komplizierteren Code, als das digitalRead() bei der Hardware Entprellung.
Eine "light Variante" wäre es immer den Status des Buttons überprüfen zu lassen und sobald er sich ändert über delay(60); zu warten und ihn danach nochmal zu prüfen. Der Nachteil hierbei wäre jedoch, dass man delay() benutzt, was das Programm an sich aufhält. Außerdem kann man delay nicht in Interrupts verwenden.
-B14- DS18B20 Temperatursensor
Verbindung mit dem Arduino
Der DS18B20 hat drei Pins, nämlich Vcc, GND und in der Mitte der Datenpin. Vcc kann mit einer beliebigen Spannung zwischen +3V und +5V verbunden werden, und GND muss mit dem Ground verbunden werden. Der Datenpin muss mit einem digital Pin des Arduino verbunden werden, und desweiteren über einen 4,7kOhm Widerstand (Gelb, Lila, Rot) mit der Versorgungsspannung.
Arduino Sketch
Zur Programmierung des DS18B20 benötigt man zwei Bibliotheken, welche sich jeweils über den Library Manager unter Sketch > Include Library > Manage Libraries herunterladen lassen. Einerseits die OneWire Bibliothek und andererseits die DallasTemperature Bibliothek.
Um nun die Temperatur abzurufen, muss man ein Objekt vom Typ OneWire erzeugen, welches man anschließend als Temperatursensor spezifiziert wird. Über den Befehl requestTemperature() kann man nun von dem erzeugten Objekt die Temperatur anfordern, und beispielsweise über die serielle Konsole ausgeben lassen.
Ein einfacher Beispielsketch sähe so aus:
|
#include <DallasTemperature.h>
|
|
|
#define ONE_WIRE_BUS 2 //digital Pin 2 des Arduino
|
|
|
OneWire oneWire(ONE_WIRE_BUS); //Initialisierung des OneWire Objekts
|
|
|
DallasTemperature sensors(&oneWire); //Temperatursensor Objekt
|
|
|
Serial.println("DS18B20 Temperatursensor:");
|
|
|
sensors.begin(); //Starten des Sensors
|
|
|
Serial.print(" Temperatur Abfrage...");
|
|
|
sensors.requestTemperatures(); //Temperatur abfragen
|
|
|
Serial.println("ERLEDIGT");
|
|
|
Serial.print("Temperatur des ersten Sensors");
|
|
|
Serial.println(sensors.getTempCByIndex(0)); //Ausgabe der Temperatur vom ersten Sensor
|
|
-B15- Software I2C
In diesem Post geht es darum, wie man über die Software I2C Bibliothek zwei beliebige Pins des Arduino für eine zusätzliche I2C Verbindungen verwendet.
I2C
I2C, eigentlich I^2C ist ein Protokoll zum Übertragen von Daten zwischen zwei Geräten mit nur zwei Verbindungen: SDA und SCL. SDA ist für die Datenübertragung und SCL für den Takt. Der Arduino hat hardwareseitig eine I2C Verbindung mit SDA an A4 und SCL an A5, welche man über die Wire Bibliothek verwenden kann.
Software I2C
Manchmal benötigt man jedoch mehr als eine I2C Verbindung pro Arduino, wozu man die Software I2C Library verwenden (verfügbar im Library Manager unter Sketch > Include Library > Manage Libraries) kann. Diese kann eine "virtuelle" I2C Verbindung an zwei beliebigen Pins des Arduino einrichten, jedoch muss man ein paar Dinge beachten.
Zunächst einmal muss man vor der Verwendung den SDA Pin und den SCL Pin definieren. Dabei kann man nicht die aufgedruckten Arduino Bezeichnungen nehmen, sondern muss die Pins in ihren jeweiligen Ports einsortieren. Die genaue Bezeichnung der Pins und der Ports des Arduino, habe ich bereits hier erklärt.
Zur Definition muss man erst den Port, und dann den Pin angeben:
#include <SoftI2CMaster.h>
|
Nun wäre digital Pin 2 der SCL Pin, und A0 der SDA Pin.
Außerdem muss man in setup die künstliche I2C Verbindung über i2c_init() starten.
Um eine Verbindung mit einem Gerät zu starten, verwendet man die Funktion i2c_start(), welche man die Adresse des anderen I2C Geräts und den Modus (I2C_WRITE oder I2C_READ mitgeben muss). Beispielsweise sähe das so aus: i2c_start('0x70'|I2C_WRITE);.
Um die I2C Adresse des anderen Arduinos/Geräts herauszufinden, kann man diesen Sketch verwenden. Nun kann man über i2c_write(); etwas schreiben, oder über i2c_read() etwas lesen. Nach erfolgreicher Datenübertragung sollte man über i2c_stop() die Verbindung unterbrechen.
-B16- ESP 8266 als Wlan Repeater
In diesem Post geht es darum, wie man den ESP8266 ( hier bei AZDelivery) als Wlan Repeater verwendet. Dadurch kann man die Reichweite eines bestehenden Wlan Netwerkes erweitern, um auch entferntere Geräte mit Informationen aus dem Internet zu versorgen.
Der Wlan Repeater
Da der ESP8266 gleichzeitig als Wlan Client in einem bestehenden Wlan Netwerk und als Wlan Router verwendet werden kann, kann er auch als Repeater verwendet werden, also Informationen über das "fremde" Wlan Netzwerk aus dem Internet holen, und im "eigenen" Wlan Netzwerk verteilen.
Nichtsdestotrotz kann man den ESP 8266 nicht als konventionellen Wlan Repeater zum Surfen im Internet und Filme streamen verwenden, da er hierfür viel zu schwach ist. Zum weiterleiten von konkreten Informationen oder Websites, kann man den ESP jedoch verwenden.
Der Sketch
Als Beispiel habe ich einen Sketch geschrieben, welcher, sobald in seinem Wlan Netzwerk seine IP Adresse (192.168.4.1) aufgerufen wird, die Yahoo Wetterseite an den Client weiterleitet, also in einer Variable speichert und diese dann erneut "verschickt".
|
#include <ESP8266WebServer.h>
|
|
|
const char* ssid = "*********"; //Name des bestehenden Wlan Netzwerkes
|
|
|
const char* password = "**********"; //Passwort des bestehenden Wlan Netzwerkes
|
|
|
char serverw[] = "weather.yahooapis.com"; //Webserver
|
|
|
ESP8266WebServer server(80);
|
|
|
WiFi.softAP("esp8266_ap", "michaelsarduino"); //Name und Passwort des neuen Wlan Netzwerks
|
|
|
// Connect to WiFi network
|
|
|
Serial.print("Connecting to ");
|
|
|
WiFi.begin(ssid, password);
|
|
|
while (WiFi.status() != WL_CONNECTED) {
|
|
|
if (mdns.begin("esp8266", WiFi.localIP())) {
|
|
|
Serial.println("MDNS responder started");
|
|
|
server.on("/", handleRoot);
|
|
|
if (client.connect(serverw, 80)) {
|
|
|
//Serial.println("connected to server");
|
|
|
client.println("GET /forecastrss?w=676757&u=c HTTP/1.1"); // /index.html durch gewuenschte Unterseite ersetzen (index.html = Startseite)
|
|
|
client.println("Host: weather.yahooapis.com"); //Adresse des Webservers
|
|
|
client.println("Connection: close");
|
|
|
client.println(); //Verbindungs mit Server aufbauen und HTTP Anfrage senden
|
|
|
while(website.length() < 10)
|
|
|
while (client.available())
|
|
|
website = client.readString();
|
|
|
if (!client.connected()) {
|
|
|
Serial.println("disconnecting from server.");
|
|
|
server.send(200, "text/html", "<h1>Yahoo Wetter</h1>");
|
|
|
server.send(200, "text/html", website);
|
|
Sobald nun ein Gerät im Wlan Netzwerks des ESP 8266 (SSID: esp8266_ap, Passwort: michaelsarduino) die Website des ESP aufruft (192.168.4.1), sieht es die Yahoo Wetterseite.
-B17- Daten aus dem Internet abrufen und an Arduino ausgeben
In diesem Post geht es darum Daten aus dem Internet, von einer Website, zu holen und an den Arduino zu senden. Dieser kann diese dann beispielsweise an einem Display ausgeben, oder sie für sonstige Verarbeitungen nutzen. In diesem Beispiel wollen wir die aktuellen Wetterinformationen von wetter.com auf einem LCD Display ausgeben lassen.
Funktionsweise
Ein PHP Skript holt sich die wetter.com Unterseite deiner Stadt und liest daraus die aktuelle Temperatur. Diese wird, wie im letzten Post, in einer Textdatei gespeichert. Diese Textdatei wird von einem Processings Sketch ausgelesen und die aktuelle Temperatur an den Arduino über die serielle Verbindung gesendet. Dieser gibt diese dann auf einem LCD Dipslay aus. Genauso könnte er sie aber auch über eine 433Mhz Funkverbindung an einen anderen Arduino/Mikrocontroller senden.
Der Arduino Sketch
Der Arduino muss die serielle Verbindung starten, und sobald über die serielle Verbindung etwas gesandt wurde, die ersten beiden Zeichen abspeichern und über die LiquidCrystal Bibliothek auf dem LCD Display ausgeben. Insgesamt sieht der Arduino Sketch, um Daten von einer Website zu holen, so aus:
Wenn ihr nicht wisst, wie man ein LCD Display korrekt mit dem Arduino verkabelt/verwendet, empfehle ich euch meinen Post dazu.
Der Processing Sketch
Im Processing Sketch wird, um die serielle Verbindung aufbauen zu können, die Serial Bibliothek nachgeladen. Anschließend wird im setup Teil die serielle Verbindung gestartet. Im sich wiederholenden draw Teil wird laufend die Textdatei über loadStrings('Pfad'); ausgelesen und die erste Zeile, die die aktuelle Temperatur enthält, im Format int in der Variable temperatur gespeichert. Diese wird dann an den Arduino gesandt. Der ganze Sketch sieht dann so aus:
Die Temperatur auslesen
Für diese Aufgabe verwende ich PHP. PHP ist ein für das Web entwickelte, auf einem Server laufende, Programmiersprache. Um PHP Programm auszuführen, benötigt man einen Webserver. Ein guter, kostenloser Webserver ist der Apache Webserver. Zu diesem findet ihr auch viele gute Installationstutorials. Wenn ihr ihn installiert habt könnt ihr einfach den unten stehenden Quellcode an euere Stadt anpassen(kommt unten) und in einer Textdatei mit der Dateiendung.php speichern. Diese kopiert ihr dann in den htdocs Ordner eures Webservers. Nun zum PHP Programm:
Um eine Website abzurufen, verwendet man die Funktion file(Link zur Seite). Damit man das Ganze dann in einer Variable speichern kann muss man alle Bestandteile der Website mit implode zusammenfügen. Dann hat man die gesamt Website in einer Variable, wir wollen aber nur die Temperatur. Wenn man sich den Quellcode der wetter.com Seite anschaut(rechte Maustaste> Seitenquelltext anzeigen) sieht man, dass sich das Wetter im Bereich degree-in befindet.
In PHP gibt es für solche Fälle die Funktion strstr. Diese sucht eine angegebene Zeichenkette und löscht alles vor oder hinter dieser Zeichenkette. Dadurch können wir die Temperatur "isolieren" und in die Textdatei speichern. Ein wichtiger Punkt sind noch die letzten beiden Zeilen. Du solltest es unbedingt vermeiden alle 5 Sekunden die Wetter.com Website aufzurufen, da sich so schnell das Wetter sowieso nicht ändert, und noch wichtiger, es könnte passieren, dass du wegen all den Seitenaufrufen Ärger mit wetter.com kriegt. Deshalb habe ich immer eine 100 Sekunden Pause zwischen den Aufrufen eingebaut. Das Problem ist nur, dass PHP Programme nach 30 Sekunden normalerweise abgebrochen werden, da sie dann normalerweise einen Fehler enthalten, weil keine Website 30 Sekunden zum Laden braucht. Wenn man das nicht will kann man die Zeit jeweils mit der Funktion set_time_limit(sekunden) verlängern. Ihr müsst den Link auf eure Stadt anpassen, indem ihr selbst wetter.com für eure Stadt aufruft und
in der Variable url speichert. Dabei ist darauf zu achten, dass ihr auf wetter.com Grad Celsius als Einheit ausgewählt habt.
Das ganze Programm sieht dann so aus:
|
$_url = "http://www.wetter.com/wetter_aktuell/aktuelles_wetter/deutschland/EURESTADT.html"; //Link zur Wetter.com Unterseite eurer Stadt
|
|
|
$_buffer = implode('', file($_url)); //laden der website und speichern in $_buffer
|
|
|
$wetter = strstr($_buffer, '<div class="degree-in" >');
|
|
|
$wetterb = strstr($wetter, '°C', TRUE); //isolieren der Temperatur
|
|
|
$temperatur = $wetterb[45] . $wetterb[46]; //speichern der beiden Ziffern in Variable Temperatur
|
|
|
$handle = fopen('temperatur.txt', 'w');
|
|
|
fwrite($handle, $temperatur);
|
|
|
fclose($handle); //abspeichern in Textdatei
|
|
|
set_time_limit(120); //PHP Programmlaufzeit verlaengern
|
|
|
sleep(100); //100 Sekdunden warten
|
|
Nun müsst ihr den Arduino Sketch auf den Arduino hochladen, den Processing Sketch starten, passt jedoch auf, dass der Pfad zur Textdatei mit der Temperatur passt, und dann im Browser localhost/namederphpdatei.php aufrufen. Nun erscheint auf eurem Wecker die aktuelle Temperatur in °C.
Wenn ihr Hilfe in Bezug auf die verwendeten PHP Befehle braucht, solltet ihr bei php.net vorbeischauen. Wenn ihr noch nie von Processing mit dem Arduino gehört habt, empfehle ich euch meine ersten Post zum Thema Processing. Dort wird alles erklärt genau erklärt, beispielsweise die Installation von Processing in Teil 1.
Teil 1 Teil 2 Teil 3
Quelle:
https://plus.google.com/110786353506245861399
-B18- Processing (mit dem Arduino)
Heute möchte ich euch die Programmiersprache Processing vorstellen und ihre Möglichkeiten in Bezug auf den Arduino erläutern.
Die Funktionsweise
Über Processing kann man entweder dem Arduino "live" Code senden, den er dann ausführt, oder man kann über Processing am PC ein Programm schreiben, das über die serielle Verbindung eine Verbindung zum Arduino hat. Natürlich ist Processing auch an sich eine coole Programmiersprache, die man unabhängig vom Arduino verwenden kann. Durch die Kommunikation mit dem Arduino und die Leistung eines PC kann man über Processing eine Menge toller Projekte realisiern, bei denen ein PC hilfreich sein kann.
Die Installation von Processing
Die Installation von Processing ist denkbar einfach. Man lädt es einfach von hier herunter, entpackt es und klickt auf "processing.exe". Dann sollte sich die Processing IDE öffnen:
Hier fällt sicherlich als erstes auf, dass sie eine immense Ähnlichkeit zu Arduino IDE aufweist, was den Anfang wirklich erheblich erleichtert.
Auch die Programmstrukturen sind ähnlich.
Die Verbindung zum Arduino
Als erstes muss man einen Bibliothek nachladen,ähnlich, wie beim Arduino, um die serielle Verbindung verwenden zu können. Das geschieht über Sketch > Import Library > serial. Dann sollte im "Schreibfenster" die Zeile import processing.serial.*; erscheinen. Anschließend müssen wir einen Partner für die serielle Verbindung der Klasse Serial definieren. Außerdem brauchen wir eine Variable vom Typ String, wo die gesendeten Texte des Arduino gespeichert werden.
Der zweite Abschnitt eines Processing Programms ist der Setupteil, genauso, wie beim Arduino. Dort muss man eine Variable Port erstellen, in der die "Verbindungsdaten über die Funktion Serial.list()[0]; gespeichert werden. Wenn bei euch später nichts erscheinen sollte, ist euer Arduino an einem anderen COM Port angeschlossen. Diesen müsst ihr dann in den eckigen Klammern angeben. Jetzt erst stellen wir die eigentliche Verbindung zu "arduino" her. Dazu erstellt man das Objekt vom Typ Serial mit dem zuvor definierten Port(Verbindungsdaten) und der Datenrate. Außerdem muss man this als erstes Argument eintippen(fragt mich nicht wieso:) ).
Der Loopteil heißt in Processing draw, ist aber ansonsten gleich. Hier wird durch eine if Schleife überprüft, ob es eine serielle Verbindung gibt, und dann der Inhalt in der Variable daten gespeichert. Danach wird dieser in der Konsole ausgegeben. Diese ist bei Processing das schwarze Feld unten. Insgesamt sieht der Code so aus:
Wenn auf dem Arduino nun ein Sketch ist, der über die serielle Verbindung etwas sendet, so erscheint das unten im schwarzen Fenster. Wenn ihr wissen wollt, wie der Arduino Sketch dazu aussehen müsste, schaut einfach bei meinem Post über die serielle Verbindung zum Arduino von gestern vorbei.
Ausblick
Durch die Verbindung über Processing könnt ihr alle mit dem Arduino gesammelten Daten, wie Temperatur, Bewegung, Entfernung oder Sonstiges am PC weiterverarbeiten. Dadurch kann man die Möglichkeiten eines Arduino Projekts deutlich erweitern und auch deutlich komplexere Berechnungen durchführen, oder aber auch das Internet miteinbeziehen. Da die Programmiersprache Processing mit dem Arduino eine interessante Mischung ergibt, wird es sicherlich noch den ein oder anderen Artikel von mir dazu geben.
-B19- LED am Arduino über grafische Oberfläche am PC steuern
Heute wollen wir über Processing eine grafische Oberfläche erstellen, die eine LED am Arduino steuert.
Die Funktionsweise
Wir wollen eine grafische Oberfläche bauen, die einen Button enthält. Wenn dieser Button gedrückt wird, soll die LED an/ausgeschaltet werden, und das PC Programm eine Rückmeldung geben beziehungsweise anzeigen, ob die LED an oder aus ist. Um dem Arduino mitzuteilen, wie er die LED schalten soll, schicken wir ihm eine Nachricht über die serielle Verbindung zum PC durch das USB Kabel. Ausführlich Erklärung der seriellen Verbindung: hier.
Der Processing Sketch
Damit das Processing Programm überhaupt ein Feld erzeugt, indem man Objekte, wie beispielsweise Buttons, platzieren kann, verwendet man die Funktion size() im Setup Teil. Diese erzeugt ein Fenster der in Klammern angegeben Größe(Einheit Pixel). Nun der Button. Die einfachste Möglichkeit in Processing einen Button zu erstellen, ist in das Feld ein Rechteck über die Funktion rect() zu zeichnen. Dieser gibt man erst die x Koordinate der linken oberen Ecke, dann die y Koordinate der linken oberen Ecke und dann die Breite, sowie die Höhe des Rechtecks mit. Um nun zu überprüfen, ob der Knopf gedrückt wurde, also die Maus auf dem Rechteck geklickt wurde, frägt man die aktuelle Position der Maus ab, sobald diese gedrückt wurde. Die Koordinaten der Maus werden über mouseX sowie mouseY abgefragt. Da wir nur die Position überprüfen wollen, wenn die Maus gedrückt ist, müssen wir die Abfrage in void mousePressed() {} einfügen. Void mousePressed ist ein Programmteil,
ähnlich wie draw/loop oder setup, der aber nur jedes Mal, wenn die Maus gedrückt wird, einmal ausgeführt wird.
Um nun auch dem Benutzer am PC anzuzeigen, ob die LED gerade an oder aus ist, können wir die Hintergrundfarbe unseres Programmfensters abändern. Dazu verwendet man die Funktion backgroud(rot, grün, blau). Ihr gibt man die Farben im Mischverhältnis aus rot, grün und blau an. So wäre background(0,0,255); ein dunkles blau.
Zusätzlich geben wir über fill() dem Button eine Farbe, im selben Format, wie bei background().
Natürlich müssen wir, wie gestern gelernt, mit dem Arduino eine serielle Verbindung herstellen. Über den Befehl seriellesObjekt.write(Zahl oder Text in Anführungszeichen); schicken wir ihm laufend den aktuellen Status der LED. Insgesamt sieht der Processing Sketch so aus:
Der Arduino Sketch
Der Arduino Sketch ist relativ simpel. Man muss die serielle Verbindung, mit der Datenrate 9600, wie bei Processing, starten und einen LED Pin seiner Wahl als OUTPUT definieren. Anschließend wird im LoopTeil laufend überprüft, ob etwas empfangen wurde, über Serial.available() > 0. Wenn das zutrifft wird die Nachricht in die Variable empfangen, vom Typ Zahl, gespeichert. Danach wird überprüft, ob empfangen 1 ist, und die LED angeschaltet wird, oder ob die Zahl 0 ist, und die LED ausgeschaltet wird. Das sieht als Sketch so aus:
Die Verkabelung
Man muss nur das kurze Bein der LED an den Ground anschließen, und das lange Bein der LED an den oben gewählten digitalPin des Arduino.
wie kann ich den Button erzeugen?
Der Button ist nur ein Rechteck auf der Zeichenfläche und wenn die Maus über dem Rechteck geklickt wurde, wird der Button aktiviert.
-B20- Registrierte Bewegung auf Website anzeigen (Arduino + Processing)
Heute möchte ich euch zeigen, wie man eine Bewegung, die eine Bewegungsmelder, angeschlossen an den Arduino, registriert und dank Processing auf einer Website anzeigen kann.
Der Arduino Sketch
Der Arduino muss eigentlich nur die Bewegung über den Bewegungsmelder wahrnehmen, und wenn dem so ist eine Nachricht über die serielle Konsole an den PC schicken. Eine serielle Verbindung startet man mit Serial.begin(9600) im Setup Teil. Für Genaueres. Insgesamt sieht dieser einfache Sketch so aus:
Die Schaltung
Ein Bewegungsmelder hat drei Pins, bei mir sind diese Beschriftet. VCC, also 5V, GND also Ground und OUT. Der Outputpin wird an einen digitalPin des Arduino angeschlossen. Für genaueres kannst du auch hier vorbeischauen.
Der Processing Sketch
Der Processing Sketch, muss einerseits die Daten der seriellen Konsole empfangen, und andererseits die Meldung der Bewegung zur Website hinzufügen. Außerdem muss er die Website an die Clients ausliefern. Der Teil zum Empfangen über die serielle Verbindung durch Processing ist hier ausführlich beschrieben. Um überhaupt eine Netzwerkverbindung herstellen zu können, muss man die Bibliothek net nachladen. Dazu schreibt man import processing.net.*;. Außerdem muss man im Setup Teil den Webserver starten. Dort legt man auch den Port fest. Der Standardport ist 80. Ich habe 8080 gewählt, da sonst jeder in meinem WLAN Netzwerk bei Eingabe meiner IP die Ergebnisse sieht. Gleich mehr dazu. Über NamedesServers.available, wird der aktuelle Client gespeichert. Danach überprüft man mit NameClient != null, ob es überhaupt einen Client gibt. Über die anschließende Zeile im Sketch wird die
Anfrage des Client gespeichert und in der if Abfrage wird geprüft, ob diese korrekt ist. Über NamedesClient.write(), liefert man dem Client HTML Code aus. Davor muss natürlich ein Header versandt werden, damit die Verbindung bestätigt wird. Über stop() wird die Verbindung zum Client geschlossen. Dadurch spart man Ressourcen. Außerdem erscheint dann nicht die ganze Zeit über beim User der Ladekringel, obwohl die Seite ausgeliefert ist. Wenn man sich den Code anschaut (mit Kommentaren) ist alles leicht zu verstehen:
|
import processing.serial.*;
|
|
|
String HTTP_GET_REQUEST = "GET /";
|
|
|
String HTTP_HEADER = "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n"; //speichern des Headers.
|
|
|
Serial arduino; //erstellen von arduino als Objekt vom Typ Serial
|
|
|
String datenpuffer; //Variable zum Abspeichern der Daten der seriellen Verbindung
|
|
|
String website; //aktueller Wortlaut der Website
|
|
|
String neu; //Speicherort fuer neue Bewegungsmeldung mit Uhrzeit
|
|
|
String input; //Variable fuer Verbindungsanfragen
|
|
|
long akt; //Speichervariable
|
|
|
long last; //Speichervariable
|
|
|
String port = Serial.list()[0];
|
|
|
arduino = new Serial(this, port, 9600); //starten der seriellen Verbindung mit Arduino
|
|
|
s = new Server(this, 8080); //server starten auf port 8080
|
|
|
website = "<html> Hallo hier ist der Arduino <br>"; //Anfangsinhalt der Website
|
|
|
if(arduino.available() > 0)
|
|
|
datenpuffer = arduino.readStringUntil('\n');
|
|
|
neu = hour() + ":" + minute() + ":" + second() + ": " + "Bewegung erkannt" + "<br />";
|
|
|
} //Wenn der Arduino etwas gesandt hat, wird die aktuelle Uhrzeit samt der Meldung Bewegung erkannt zum Websitentext hinzugefuegt
|
|
|
c = s.available(); //ueberpruefen, ob Client vorhanden
|
|
|
if (c != null) { //wenn Client vorhanden
|
|
|
input = c.readString(); //abspeichern der Verbindungsanfragen
|
|
|
input = input.substring(0, input.indexOf("\n")); //abspeichern der ersten Zeile
|
|
|
if (input.indexOf(HTTP_GET_REQUEST) == 0) //ueberpruefen ob empfangene Anfrage korrekt ist
|
|
|
c.write(HTTP_HEADER); //Header senden (Verbindung starten)
|
|
|
c.write(website); //HTML Code senden
|
|
|
c.stop(); //schließen der Verbindung
|
|
Die Funktion millis() gibt die Anzahl an Millisekunden seit Programmstart an. Durch sie kann ich bewirken, dass nur eine neue Meldung zur Website hinzugefügt wird, wenn 5 Sekunden vergangen sind. Der Vorteil zu delay() ist, dass während dieser 5 Sekunden trotzdem neue Verbindungen zu Client gestartet werden können, da ja nicht das gesamte Programm angehalten wird.
Netzwerkgrundlagen
Oben habe ich ja schon erwähnt, dass ich Port 8080 anstatt Port 80 verwende. Der Port ist so etwas, wie die Wahl der Leitung im Internet. Wenn du nun diese Website aufrufen willst, musst du die IP Adresse deines PCs, auf dem der Processing Sketch läuft herausfinden. Das kannst du leicht über die CMD machen. Dazu drückt du gleichzeitig die Windows und die R Taste. Dann öffnet sich dieses Fenster:
Nun tippst du "cmd" ein und drückst die Enter Taste:
Nun gibst du den Befehl ipconfig /all ein und drückst wieder Enter. Jetzt erscheint viel Text. Du musst zu dieser Zeile scrollen, wo du deine IP Adresse siehst:
Nun tippst du diese in deinen Browser ein und anschließend einen Doppelpunkt und den gewählten Port. Das Ergebnis sieht dann so aus:
Hinweis: Diese IP Adresse ist nur netzwerkweit. Das bedeutet, jemand der nicht in deinem WLAN oder deinem LAN Netzwerk ist, kann normalerweise nicht diese Website aufrufen. Wer dies will googlt im Internet nach Port Forwarding.
Fazit
Das hier gezeigte ist eine Möglichkeit, wie man mit dem Arduino ohne zusätzliche Hardware ins Internet kommt. Später kann man das natürlich auch, mit Erweiterungen, nur mit dem Arduino machen. Darum ging es jedoch nicht. Ich hoffe bei euch klappt alles und ihr konntet alles verstehen. Fragen einfach in die Kommentare.
-B21- Bewegungssensor mit serieller übertragener Warnmeldung.
Es gibt sicherlich viele Projekte bei denen man einen Bewegungssensor brauchen kann. Deshalb geht es im heutigen Post um die Ansteuerung eines Bewegungssensor und die Auswertung der Signale.
DSN-FIR800
(DSN-FIR800)
Die Verkabelung
Mein Bewegungssensor hat drei Pins. Einen Ground eine 5V Spannungsversorgung und einen Datenpin. Links der Ground, rechts die 5V Spannung und in der Mitte die Datenleitung. Wenn der Bewegungssensor eine Bewegung registriert, schaltet er am Datenpin die Spannung auf HIGH. Deshalb müssen wir die Datenleitung mit einem der digitalen Pins verbinden.
Das Programm
Diesmal wollen wir, um verschiedene Dinge zu lernen, am PC über die serielle Kommunikation mit dem Arduino eine Meldung erhalten wenn der Sensor eine Bewegung registriert.
Zunächst müssen wir den Datenpin als Input definieren und über Serial.begin die serielle Kommunikation starten. Danach wir ständig abgefragt ob an Pin 8 eine Spannung anliegt. Wenn dem so ist, so wird die Meldung an den Computer gesandt über Serial.println(Meldung), wobei println nach der Meldung einen Zeilenumbruch macht im Verglich zu print alleine. Dann wir 1 Sekunde gewartet. Das ist notwendig, da der Bewegungssensor eine gewisse Trägheit hat und sonst bei einer kurzen Bewegung sofort mehrere hundert Meldungen übertragen werden müssten. Um nun zu schauen ob der Arduino eine Bewegung registriert klickt man in der Arduino IDE rechts oben auf das Symbol mit der Lupe.
Das Ergebnis!
Natürlich könnt ihr aber auch anstatt an den PC eine Meldung zu schicken am Arduino beispielsweise eine LED blinken lassen. Viel Spaß beim ausprobieren und erzählt doch mal in den Kommentaren wozu ihr euren Bewegungssensor nutzt.
-B22- Daten über ESP 8266 in Cloud laden
In diesem Post geht es darum, wie man über das ESP 8266 Wlan Modul und den Arduino Uno Daten mittels Sensoren messen kann und dann auf die Sparkfun Phant Cloud hochladen kann.
Die Sparkfun Cloud
Der Hardware Hersteller Sparkfun hat einen gratis Cloud Dienst aufgesetzt, bei dem man mittels seinem ESP 8266 und der Sparkfun Phant Library über ein paar kurze Befehle Daten oder Messwerte in die Cloud laden kann.
Zu jedem Datenstream gibt es auch eine Website, auf der man die Messwerte angezeigt bekommt. Momentan kann man bis zu 50 MB Daten pro Stream hochladen. Danach werden jeweils die ältesten Datensätze gelöscht.
Um einen neuen Stream zu erstellen, muss man zunächst unter data.sparkfun.com auf "Create" klicken, und einen Namen, sowie eine Beschreibung und die verschiedenen Datenfelder angeben. Nun erhält man die "Abruf URL", sowie einen Private und einen Public Key. Damit ist der Stream fertig erstellt.
Jetzt muss man hier die Phant Library für den ESP 8266 herunterladen und den Entpackten Inhalt der .zip Datei in den Libraries Ordner der Arduino IDE kopieren. Nach einem Neustart der IDE sollte unter Sketch > Include Library die Phant Bibliothek aufgeführt sein.
Um das Ganze zu testen, kann man diesen Beispielsketch für den ESP 8266 von Sparkfun verwenden:
|
// Include the ESP8266 WiFi library. (Works a lot like the
|
|
|
// Arduino WiFi library.)
|
|
|
// Include the SparkFun Phant library.
|
|
|
const char WiFiSSID[] = "WiFi_Network";
|
|
|
const char WiFiPSK[] = "WiFi_Password";
|
|
|
const int LED_PIN = 5; // Thing's onboard, green LED
|
|
|
const int ANALOG_PIN = A0; // The only analog pin on the Thing
|
|
|
const int DIGITAL_PIN = 12; // Digital pin to be read
|
|
|
const char PhantHost[] = "data.sparkfun.com";
|
|
|
const char PublicKey[] = "wpvZ9pE1qbFJAjaGd3bn";
|
|
|
const char PrivateKey[] = "wzeB1z0xWNt1YJX27xdg";
|
|
|
const unsigned long postRate = 30000;
|
|
|
unsigned long lastPost = 0;
|
|
|
digitalWrite(LED_PIN, HIGH);
|
|
|
if (lastPost + postRate <= millis())
|
|
|
// Set WiFi mode to station (as opposed to AP or AP_STA)
|
|
|
// WiFI.begin([ssid], [passkey]) initiates a WiFI connection
|
|
|
// to the stated [ssid], using the [passkey] as a WPA, WPA2,
|
|
|
WiFi.begin(WiFiSSID, WiFiPSK);
|
|
|
// Use the WiFi.status() function to check if the ESP8266
|
|
|
// is connected to a WiFi network.
|
|
|
while (WiFi.status() != WL_CONNECTED)
|
|
|
digitalWrite(LED_PIN, ledStatus); // Write LED high/low
|
|
|
ledStatus = (ledStatus == HIGH) ? LOW : HIGH;
|
|
|
// Delays allow the ESP8266 to perform critical tasks
|
|
|
// defined outside of the sketch. These tasks include
|
|
|
// setting up, and maintaining, a WiFi connection.
|
|
|
// Potentially infinite loops are generally dangerous.
|
|
|
// Add delays -- allowing the processor to perform other
|
|
|
// tasks -- wherever possible.
|
|
|
pinMode(DIGITAL_PIN, INPUT_PULLUP);
|
|
|
pinMode(LED_PIN, OUTPUT);
|
|
|
digitalWrite(LED_PIN, LOW);
|
|
|
// Don't need to set ANALOG_PIN as input,
|
|
|
// LED turns on when we enter, it'll go off when we
|
|
|
digitalWrite(LED_PIN, HIGH);
|
|
|
// Declare an object from the Phant library - phant
|
|
|
Phant phant(PhantHost, PublicKey, PrivateKey);
|
|
|
// Do a little work to get a unique-ish name. Append the
|
|
|
// last two bytes of the MAC (HEX'd) to "Thing-":
|
|
|
uint8_t mac[WL_MAC_ADDR_LENGTH];
|
|
|
String macID = String(mac[WL_MAC_ADDR_LENGTH - 2], HEX) +
|
|
|
String(mac[WL_MAC_ADDR_LENGTH - 1], HEX);
|
|
|
String postedID = "Thing-" + macID;
|
|
|
// Add the four field/value pairs defined by our stream:
|
|
|
phant.add("id", postedID);
|
|
|
phant.add("analog", analogRead(ANALOG_PIN));
|
|
|
phant.add("digital", digitalRead(DIGITAL_PIN));
|
|
|
phant.add("time", millis());
|
|
|
// Now connect to data.sparkfun.com, and post our data:
|
|
|
if (!client.connect(PhantHost, httpPort))
|
|
|
// If we fail to connect, return 0.
|
|
|
// If we successfully connected, print our Phant post:
|
|
|
client.print(phant.post());
|
|
|
// Read all the lines of the reply from server and print them to Serial
|
|
|
while(client.available()){
|
|
|
String line = client.readStringUntil('\r');
|
|
|
//Serial.print(line); // Trying to avoid using serial
|
|
|
// Before we exit, turn the LED off.
|
|
|
digitalWrite(LED_PIN, LOW);
|
|
|
return 1; // Return success
|
|
}
example_DataSparkfunCom.ino hosted with ❤ by GitHub
Hierbei müsst ihr nur das Wlan Netzwerk und das Wlan Passwort entsprechend eurem Wlan Netzwerk und Passwort abändern. Nach einem Upload des Arduino Sketches auf den ESP 8266 kann man hier seine hoch geladenen Daten sehen. Um nun euren eigenen Stream zu verwenden, müsst ihr nur den Public und den Private Key durch euren eigenen ersetzen.
Da der ESP 8266 Version 01 nur 2 GPIOs hat, ist es sinnvoll ihn mit einem Arduino zu verbinden, um mehr Pins zu erhalten.
Fazit
Die Phant Cloud von Sparkfun in Kombination mit dem ESP 8266 ist, dank der Arduino Bibliothek, eine sehr einfache Möglichkeit Messwerte des Arduino in die Cloud zu laden.
DIN A4 ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto: [email protected]
ENDE
|
