Mitmachprojekt

http://sites.prenninger.com/arduino-uno-r3/anleitung-tutorial/mitmachprojekt

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                         Wels, am 2015-04-12

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.prenninger.com/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-anleitung.tutorial-mitmachprojekt (xx Seiten)_1a.pdf



Sensoren für Arduino

Hier findest du diverse Sensoren für deine Arduino Projekte zu günstigen Preisen.
Wir haben auch einige Sensoren die du zum Navigieren eines Modellbauflugzeugs nutzen kannst, oder auch welche für die Navigation von Robotern.
Du findest aber auch einfachere Sensoren zum Messen der Luftqualität in Räumen oder der Temperatur und der Luftfeuchtigkeit.
Bei uns kannst du auch noch viele andere Bauteile für deine Arduino, Raspberry, ESP8266 und Elektronik Projekte kaufen, schaue dich einfach in unserem Online Shop um!

BME680 Breakout Luftfeuchtigkeits-, Druck-, Temperatur- & Luftgütesensor
Gravity Digital Microwave Sensor Radar- / Geschwindigkeitssensor
MPU-6050 3-Achsen Beschleunigungssensor mit Gyroskop
CCS811 SparkFun  CO2 Air Quality Sensor
VL53L1X ToF Entfernungssensor bis zu 4m
1D/2D Barcode Scanner Reader Modul
5-Weg Mikro Joystick Breakout
50kg Load Cell Gewichtssensor
AM2315 AOSONG  I2C Temperatur / Luftfeuchtigkeitssensor
APDS-9960 RGB / Gesten / Distanz Sensor Modul I2C
Joystick 4-Weg Arcade
ADXL345 GY-291  Beschleunigungssensor
BH1750   GY-302 Digitaler Lichtsensor / Lichtstärke Sensor mit I2C
BME280 I2C Wetterstation Sensor Feuchtigkeit / Druck / Temperatur
BMP280 Temperatur Luftdruck Sensor
Bodenfeuchtesensor mit Goldbeschichtung
Capacitive Touch Kit für Arduino
DHT11 Temperatur und Luftfeuchtigkeitssensor
DHT22 Temperatur und Luftfeuchtigkeitssensor
DHT22 Temperatur und Luftfeuchtigkeitssensor steckbar
EC11 Rotary Encoder Module
Feuchtigkeitssensor / Bodenfeuchtesensor Modul
Analoger AC-Stromsensor mit Strommesszange Gravity
BMI160 Gravity I2C  6-Achsen Bewegungssensor mit Gyroskop
XY Joystick Modul V2 Gravity
GY-273  HMC5883L 3-Achsen Kompass Magnetometer Modul
Hall Sensor Modul mit Analogausgang
HB100 Radar Sensor Modul
HC-SR501 PIR Bewegungsmelder Modul
HC-SR505 Mini PIR Bewegungsmelder Modul
TCRT5000  Infrarot Sensor  Näherungsschalter Breakout Modul
IR Infrarot Flammensensor
Kapazitiver Bodenfeuchtesensor V1.2
TTP223 Kapazitiver Touch Sensor Taster
KY-040 Rotary Encoder Drehgeber
Lichtschranke Modul für Tacho / Drehzahlmessung
Magnetisch Hall Sensor Modul
Magnetischer Tür / Fenster Kontakt
MAX31855K Thermoelement Breakout SparkFun
MAX31865 PT100 RTD Sensor Verstärker
MAX4466 Mikrofon Verstärker Modul mit Poti
Mechanischer Endschalter mit Kabel
Micro PIR Bewegungsmelder Modul
KY-037 Mikrofon Geräuschsensor
MLX90614 Berührungsloser Infrarot Temperatursensor
MPR121 Capacitive Touch Sensor Breakout
MQ-135 Gas Sensor Luftqualität
SDS011  Nova  Feinstaubsensor
Optischer Endschalter Lichtschranke mit Kabel
RCWL-0516 Radar Bewegungsmelder
Reedschalter / Kontakt Magnetschalter
Regensensor Modul mit Analog / Digital Ausgang
TCS34725  RGB Farben Sensor  mit IR-Filter und LED
GP2Y0A02  Sharp Infrarot Distanzsensor 20-150cm
2Y0A21  Sharp Infrarot Distanzsensor
SHT10 Temperatur und Luftfeuchtigkeitssensor / SHT1x
Si7021 hochgenauer Temperatur und Luftfeuchtigkeitssensor mit I2C
Flex Sensor 2.2inch  SparkFun
Flex Sensor 4.5inch  SparkFun
APDS-9301 Force Sensitive Resistor 0.5inch  SparkFun
Lichtsensor   SparkFun
SparkFun ZX Distanz und Gesten Sensor
Taster Modul rot
Taster Modul schwarz
DS18B20 Temperatursensor  für Arduino und Raspberry
DS18B20 (ohne DS18b20) Temperatursensor Modul für
DS18B20  Temperatursensor wasserdicht  1m
DS18B20  Temperatursensor wasserdicht  3m
TFMini - Micro LiDAR Modul Sparkfun
MAX6675 Thermoelement Set K-Typ Thermocouple mit  0-800 Grad
Thermoelement Sonde Typ-K Edelstahl SparkFun
TTP229  Touch Tastatur 16 Tasten 4x4 Matrix
HC-SR05  Ultraschall Distanzmesser
Wassersensor / Füllstandsmelder
SV01A  Winkel Sensor Modul
XY Joystick Modul


https://www.bastelgarage.ch/arduino/sensoren-fur-arduino
https://www.bastelgarage.ch/arduino/boards
https://www.bastelgarage.ch/arduino/modul-breakout-fur-arduino
https://www.bastelgarage.ch/arduino/shields
https://www.bastelgarage.ch/arduino/zubehor




********************************************************I*

www.golem.de


Arduino mit Ethernet-Shield

1 Temperatur messen und senden mit dem Arduino

Die Bürotemperatur messen und ins Internet übertragen - das geht mit ein wenig Code, preiswerten Bauelementen und dem Arduino oder Genuino. Wir zeigen, wie es funktioniert.

Artikel von veröffentlicht am 21. April 2016, 10:47 Uhr
  • per E-Mail versenden

  • Arduino mit Ethernet-Shield zur Temperaturmessung Arduino mit Ethernet-Shield zur Temperaturmessung (Bild: Alexander Merz/Golem.de)
    Anzeige

    Die beliebte Arduino-Plattform wurde speziell für Einsteiger und Laien konzipiert, die sich mit Mikrocontrollern beschäftigen wollen. Außerhalb der USA werden die Bastelrechner mittlerweile unter dem Namen Genuino vertrieben. In unserer Anleitung zeigen wir, wie mit einem Sensor die Temperatur gemessen und der Wert an einen Internetserver übermittelt wird. Mögliche Fehler werden dabei mit Hilfe einer LED angezeigt. Mit dem fertigen Aufbau kann der Leser an unserem großen Projekt zur Messung der Bürotemperatur teilnehmen.


    Für unsere Anleitung verwenden wir einen Arduino/Genuino Uno. Für die Internetverbindung setzen wir ein Ethernet-Shield ein. Wer eine WLAN-Verbindung bevorzugt, für den beschreiben wir eine Lösung in einem weiteren Artikel.




    Die Liste der erforderlichen Bauelemente ist kurz, es gibt sie für wenig Geld bei allen Elektronikhändlern:

    • ein Temperatursensor DS18B20
    • ein 4,7-kOhm-Widerstand
    • eine LED
    • ein 220-Ohm-Widerstand für die LED
    • ein kleines Steckbrett
    • ein Set Verbindungskabel und Klingeldraht

    Den Arduino vorbereiten

    Das Ethernet-Shield wird vorsichtig auf den Arduino aufgesteckt, ohne die Pins dabei zu verbiegen. Das Layout der Pin-Reihen auf dem Ethernet-Shield ist identisch mit dem Arduino selbst, das Ethernet-Shield nimmt auch keinen Einfluss auf die Kontakte. Mit einer Ausnahme: Der mit ICSP markierte Pin-Block wird vom Shield selbst zur Kommunikation mit dem Arduino verwendet.

    Das Steckbrett vorbereiten


    Ein Steckbrett verfügt am Rand üblicherweise über zwei Leisten, die jeweils mit einer roten und einer blauen Linie markiert sind. Die Leiste mit der blauen Linie verbinden wir mit einer der Pin-Buchsen auf dem Shield, die mit GND markiert sind. Die Leiste mit der roten Linie wird mit der Pin-Buchse verbunden, welche die Markierung 3V3 trägt, manchmal auch 3.3V.



    2 Den DS18B20 und die LED anschließen

    Einige Informationen zum Temperatursensor DS18B20 haben wir bereits in einem identischen Artikel für den Aufbau mit dem Raspberry Pi vermittelt. Dort ist auch der Aufbau der Schaltung umfangreich beschrieben, der sich für den Arduino nicht wesentlich unterscheidet. Wir benutzen hier nur andere Pins, um die Schaltung mit dem Mikrocontroller zu verknüpfen: Die Datenleitung vom mittleren Beinchen des DS18B20 muss mit der Pin-Buchse 2 des Arduino verbunden werden. Das lange oder abgeknickte Beinchen der LED (die Anode) wird mit Pin 3 verbunden.

    Den Arduino programmieren



    Die einfachste Form, ein Programm für den Arduino zu schreiben und zu übertragen, ist die Arduino IDE. Es gibt sie für Windows, OS X und Linux. Der Download ist kostenlos.

    Nach dem Start des Programms können wir sofort mit einem neuen Sketch loslegen - so heißen Programme in der Arduino IDE. Allerdings sollten wir die IDE zuerst für den Arduino Uno konfigurieren. Dazu wählen wir im Werkzeugmenü unter Boards den Eintrag "Arduino/Genuino Uno" aus. Jetzt wird der Arduino per USB mit dem Computer verbunden. Im Werkzeugmenü erscheint unter Port ein Eintrag für die angeschlossene Platine, diesen wählen wir aus.


    Fritzing-Zeichnung der Konstruktion (Abb.: Alexander Merz/Fritzing)


    Den vollständigen Quellcode für unser Programm gibt es auf Github. Hier werden wir im Wesentlichen die Kernelemente des Sketches besprechen.

    Temperatursensor konfigurieren

    Für den Arduino gibt es bereits fertige Bibliotheken, um den DS18B20 zu verwenden. Die Bibliothek zur Kommunikation per One-Wire ist in aktuellen Versionen der Arduino IDE schon enthalten. Für die darauf aufbauende Logik, um den Temperaturwert aus dem Sensor auszulesen, gibt es ebenfalls eine Bibliothek: DallasTemperature.

    Sie kann über die Arduino IDE installiert werden. Dazu ist der Bibliotheksverwalter über das Menü "Sketch" - "Bibliothek einbinden" aufzurufen. Im Dialog befindet sich rechts oben ein Eingabefeld für die Suche. Es genügt, "Dallas" einzugeben, um die Bibliothek zu finden. Nach einem Klick auf "Installieren" wird sie heruntergeladen und wir können sie verwenden. Nach dem gleichen Schema muss eventuell auch die One-Wire-Bibliothek installiert werden, wenn sie nicht schon vorhanden ist.

    Nach der Einbindung der Bibliotheken werden die entsprechenden Objekte initiiert. Die Konstante ONE_WIRE_BUS bezeichnet den Pin, mit dem unser Temperatursensor verbunden wurde:

    1. #define ONE_WIRE_BUS 2
    2.  
    3. OneWire oneWire(ONE_WIRE_BUS);
    4. DallasTemperature sensors(&oneWire);
    5. DeviceAddress thermometer;

    Bei einem neuen Sketch sind die beiden Funktionen setup() und loop() bereits vordefiniert. Die Setup-Funktion wird einmal bei Programmstart aufgerufen. Die Loop-Funktion wird danach hingegen kontinuierlich immer wieder aufgerufen - bis der Arduino ausgeschaltet wird.

    Den folgenden Code müssen wir nur beim Start ausführen, deswegen steht er in der setup()-Funktion:

    1. sensors.begin();
    2. sensors.getAddress(thermometer, 0);
    3. sensors.setResolution(thermometer, 12);

    Bei der begin()-Methode wird nach One-Wire-Geräten auf dem Pin gesucht. Da wir dort nur den Sensor angeschlossen haben, können wir risikolos die erste gefundene ID des Sensors, hier Adresse genannt, in der Variable thermometer speichern. Schließlich müssen wir noch angeben, mit welcher Genauigkeit der Sensor arbeitet: beim DS1820B laut Datenblatt 12 Bit.

    Die eigentliche Abfrage der Temperatur erfolgt in der Loop-Funktion, Der Aufruf sensors.requestTemperatures() fragt den Temperaturwert vom Sensor ab und speichert ihn.



    3 LED ansprechen

    Alles, was nötig ist, um eine LED an- und auszuschalten, ist bereits Teil der Arduino-Standardfunktionen und daher immer vorhanden.

    Wir müssen zuerst dem Mikrocontroller mitteilen, dass er den Pin 3, an dem unsere LED angeschlossen wurde, als Ausgang schalten soll. Das geschieht in der Setup-Funktion:

    1. pinMode(PIN_LED, OUTPUT);

    Die Konstante PIN_LED haben wir selbst definiert, sie enthält den Wert 3. Wir verwenden sie wieder, wenn die LED eingeschaltet werden soll:

    1. digitalWrite(PIN_LED, HIGH);

    Damit wird der Mikrocontroller angewiesen, an dem betreffenden Pin eine Spannung anzulegen. Um die LED wieder auszuschalten, wird der gleiche Aufruf verwendet, allerdings mit der Konstante LOW als zweitem Parameter:

    1. digitalWrite(PIN_LED, LOW);

    Die LED leuchtet in unserem fertigen Programm einmal bei der Initialisierung der Ethernet-Schnittstelle und blinkt, wenn Fehler auftreten.


    4 Ethernet-Shield initialisieren

    Bevor wir Daten über das Ethernet-Shield verschicken können, müssen wir es initialisieren. Dazu benötigen wir zwei Bibliotheken, die bereits mit der Arduino-IDE mitgeliefert werden. Außerdem müssen wir für das Ethernet-Shield von Hand eine MAC festlegen und ein Objekt definieren, über das unsere Kommunikation mit dem Shield abgewickelt wird:


    1. EthernetClient client;
    2. byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
    So vorbereitet beschränkt sich der Start des Ethernet-Shields auf einen Funktionsaufruf, den wir in die setup()-Funktion des Sketch packen:
    1. Ethernet.begin(mac)

    In unserem Skript auf Github haben wir diesen Aufruf in der Funktion initEthernet() gekapselt, die auch die Fehler bei der Initialisierung behandelt.

    Temperatur senden

    Die Daten werden schließlich in der Funktion sendTemperature() versendet. Die Funktion erwartet als Parameter die ID des Sensors, die wir in der Variable thermometer gespeichert haben.

    Damit lesen wir den gespeicherten Temperaturwert des Sensors in Grad Celsius aus:

    1. float tempC = sensors.getTempC(deviceAddress);

    Als Nächstes weisen wir das Ethernet-Shield an, eine TCP-Verbindung zum Golem.de-Server an Port 80 aufzubauen, die Konstante SERVER enthält den Servernamen "www.golem.de":

    1. client.connect(SERVER, 80)

    War das erfolgreich, wickeln wir eine HTTP-GET-Anfrage von Hand ab. Diese bauen wir mit Hilfe eines String-Objekts zusammen. Wichtigster Bestandteil ist die URL, sie besteht aus der Konstante namens URL, daran wird die Temperatur als Parameter angehängt.

    Wie die URL-Konstante aufgebaut werden muss, kann der technischen Dokumentation unseres Messprojekts entnommen werden. Teil der Dokumentation ist auch ein Formular, um sich die URL einfach zusammenzuklicken. Für die URL ist es wichtig, dass "Temperatur anhängen" ausgewählt wurde.

    1. String cmd = "GET ";
    2. cmd += URL;
    3. cmd += tempC;
    4. cmd += " HTTP/1.0";
    5.  
    6. client.println(cmd);
    7. client.print("Host: ");
    8. client.println(SERVER);
    9. client.println("Connection: close");
    10. client.println();

    Die Zeichenketten in den Aufrufen von client.print() und client.println() werden direkt an den Golem.de-Server geschickt.


    5 Zeitgesteuerte Ausführung

    In der Loop-Funktion haben wir noch Code hinzugefügt, um die Temperaturmessung alle 30 Minuten durchzuführen. Die Zeitdauer von 30 Minuten wurde in der Konstanten PERIOD festgelegt.

    Für die Zeitüberwachung benutzen wir die Variable sensortime:

    1. static unsigned long sensortime = 0;

    Das Static-Keyword sorgt dafür, dass der Wert der Variablen auch beim Verlassen der Funktion erhalten bleibt. Ihr Wert wird bei jedem Aufruf der Loop-Funktion mit der Anzahl an Millisekunden verglichen, die seit dem Start des Arduinos vergangen sind. Beim ersten Aufruf ist diese Bedingung immer erfüllt, weshalb der erste Temperaturwert direkt nach dem Start verschickt wird. Gleichzeitig wird in Millisekunden berechnet, zu welchem Zeitpunkt der nächste Aufruf erfolgen sollte. Dieser Wert wird in sensortime gespeichert.

    1. if(millis() > sensortime) {
    2. sensortime = millis() + PERIOD * 60l * 1000l;
    3. sensors.requestTemperatures();
    4. sendTemperature(thermometer);
    5. }

    Nach der gleichen Logik arbeitet auch der Code in der loop()-Funktion, welcher dafür sorgt, dass die LED regelmäßig blinkt, wenn ein Fehler auftritt.

    Jetzt zum Freizeitforscher werden

    Mit dem Schaltungsaufbau und dem regelmäßigen Skriptaufruf ist alles beisammen, um an unserem großen Projekt teilzunehmen: Wie warm ist es in euren Büros?. Wir hoffen, dass möglichst viele Bastler mitmachen - jetzt vielleicht auch du?


    https://www.golem.de/news/mitmachprojekt-temperatur-messen-und-senden-mit-dem-arduino-1604-120189.html

    https://www.golem.de/news/mitmachprojekt-wie-warm-ist-es-in-euren-bueros-1604-120154.html






    DIN A4  ausdrucken
    ********************************************************I*
    Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
    ENDE









    Comments