In meinen vorherigen Blogposts habe ich ja bereits angedeutet, wohin die Reise geht: Batteriebetriebene Sensoren die ihre Daten per Funk an eine zentrale Basis schicken, welche per Netzwerkkabel angebunden ist und die empfangenen Werte in einer MySQL-Datenbank speichern.
Momentan bin ich mit den kostengünstigen 433 Mhz-Sensoren von eBay an eine physische Grenze gestoßen: Zwar reicht die Reichweite der Sensoren für meine 80qm-Wohnung (wobei der Sender am anderen Wohnungsende steht), jedoch komme ich nicht auf meinen Balkon; und die Werte im Außenbereich interessieren mich natürlich genauso.
Aus diesem Grund habe ich mir RFM12B-S1-Sender bestellt, deren Reichweite höher liegen soll. Meine bisherigen Erkenntnisse und Sketches möchte ich mit euch teilen, bevor ich notgedrungen den Wechsel zu diesen neuen Sendern durchführe.
*Update 29.12.2013*: Ich habe mir zwar besagte RFM12B-Tranceiver besorgt, sie jedoch nicht eingesetzt. Momentan verwende ich die 433 Mhz-Sender weiter, und bin dazu übergegangen die Daten von einem Arduino UNO empfangen, und per RS232/COM an einen Raspberry Pi zu übergeben, der diese dann weiterverarbeitet.
Da der Raspberry per WLAN-Stick angebunden ist, kann ich diese Empfängereinheit frei in der Wohnung platzieren – komme also auch näher an den Balkon und erhalte so doch noch meine Außentemperaturwerte. Näheres folgt bald! */update*
Okay, zuerst benötigen wir mal eine kurze Teileliste der von mir eingesetzten Komponenten:
- ATTiny84V-10PU (LowPower-Version, bekommt ihr auf reichelt.de für etwa 2,7€)
- 433 Mhz-Sender/Empfänger-Paar (bekommt ihr am günstigsten auf eBay für etwa 1,5€ pro Paar; jedoch lange Lieferzeit von ~6 Wochen)
- DS18S20 Temperatursensoren, oder DHT22 Temperatur/Luftfeuchtigkeitssensoren (~3-4 €) – ebenfalls günstig per eBay aus China zu erwerben
- Einen Arduino Uno oder einen USBTiny-Programmierer zum Flashen der Sketches auf den ATTiny84
- Kleinteile, je einen Widerstand für die Sensoren, etc.
Vorbereitungen
- Damit wir loslegen können, müsst ihr den ATTiny84 auf einem Steckboard mit eurem Programer verkabeln und den Bootloader (8 Mhz Clock! Mit 1 Mhz passiert zumindest bei mir nichts…) flashen. In diesem Artikel habe ich das bereits beschrieben.
- Zusätzlich müsst ihr natürlich noch den Sensor anschließen. Ich habe beispielhaft einen DS18S20 und DHT22 genommen und je ein Fritzing-Schaltbild erstellt. Das schöne dabei: Wir nutzen die freien PINs zum Anschluss des Sensors – daher können wir Sketchänderungen direkt hochladen und testen, ohne irgendetwas an der Verkabelung ändern zu müssen:
*UPDATE* Fehlerteufel! VCC des Sendemoduls muss natürlich auf den PLUS-Pol der Stromversorgung und NICHT auf GND gehen!
- Als Empfänger verwende ich einen Arduino Ethernet, der per Netzwerkkabel an meinen Switch angeschlossen ist. Am Arduino Ethernet hängt lediglich der 433 Mhz-Empfänger über einen einzigen Data-Pin – im Sketch weiter unten ist das entsprechend aufgeführt und sollte ohne große Erklärung umzusetzen sein.
- Ihr benötigt, je nachdem, welchen Sensor ihr einsetzt, zusätzliche Bibliotheken für die Arduino IDE. In den Sketchen sind Verweise zu den jeweiligen Libs hinterlegt, in jedem Fall jedoch benötigt ihr die VirtualWire– (für den Datenaustausch über die Funk-Verbindung) und die JeeNode-Lib (für die Sleep-Funktionen). Beide Libs bekommen sich in die Haare; einen Workaround findet ihr im Arduino.cc-Forum
- Zusätzlich, verstehe wer will, erhalte ich mit den WinAVR-Tools von 2008, die bei der Arduino IDE mitgeliefert werden, Fehlermeldungen beim Upload der Sketche auf den ATTiny84 per Arduino Uno als Programer:
123456789101112131415c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/crttn84.o: In function `__vector_default':(.vectors+0x2): relocation truncated to fit: R_AVR_13_PCREL against symbol `__vector_1' defined in .text.__vector_1 section in core.a(WInterrupts.c.o)c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/crttn84.o: In function `__vector_default':(.vectors+0x16): relocation truncated to fit: R_AVR_13_PCREL against symbol `__vector_11' defined in .text.__vector_11 section in core.a(wiring.c.o)c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/crttn84.o:(.init9+0x0): relocation truncated to fit: R_AVR_13_PCREL against symbol `main' defined in .text.main section in core.a(main.cpp.o)c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25/crttn84.o:(.init9+0x2): relocation truncated to fit: R_AVR_13_PCREL against symbol `exit' defined in .fini9 section in c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/avr25\libgcc.a(_exit.o)_433_sender_DHT22_final.cpp.o: In function `readVcc()':C:\Program Files (x86)\Arduino/_433_sender_DHT22_final.ino:118: relocation truncated to fit: R_AVR_13_PCREL against symbol `__divmodsi4' defined in .text.libgcc section in c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/avr25\libgcc.a(_divmodsi4.o)_433_sender_DHT22_final.cpp.o: In function `loop':C:\Program Files (x86)\Arduino/_433_sender_DHT22_final.ino:66: relocation truncated to fit: R_AVR_13_PCREL against symbol `__floatsisf' defined in .text.fplib section in c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25\libm.a(floatsisf.o)C:\Program Files (x86)\Arduino/_433_sender_DHT22_final.ino:66: relocation truncated to fit: R_AVR_13_PCREL against symbol `__mulsf3' defined in .text.fplib section in c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25\libm.a(mulsf3.o)C:\Program Files (x86)\Arduino/_433_sender_DHT22_final.ino:66: relocation truncated to fit: R_AVR_13_PCREL against symbol `__fixsfsi' defined in .text.fplib section in c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25\libm.a(fixsfsi.o)C:\Program Files (x86)\Arduino/_433_sender_DHT22_final.ino:67: relocation truncated to fit: R_AVR_13_PCREL against symbol `__floatsisf' defined in .text.fplib section in c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25\libm.a(floatsisf.o)C:\Program Files (x86)\Arduino/_433_sender_DHT22_final.ino:67: relocation truncated to fit: R_AVR_13_PCREL against symbol `__mulsf3' defined in .text.fplib section in c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr25\libm.a(mulsf3.o)C:\Program Files (x86)\Arduino/_433_sender_DHT22_final.ino:67: additional relocation overflows omitted from the output
Die Lösung sieht ebenfalls relativ einfach aus: Ladet euch die aktuelle WinAVR-Suite (aktuell von 2010) von SourceForge herunter, installiert sie – z.B. nach c:\WinAVR, benennt den Ordner „avr“ im Verzeichnis „C:\Program Files (x86)\Arduino\hardware\tools“ in „avr.old„um, erstellt das Verzeichnis „avr“ neu und kopiert dorthin alle Dateien und Ordner unterhalb von c:\WinAVR\.
Zusätzlich muss die Datei avrdude.conf aus C:\Program Files (x86)\Arduino\hardware\tools\avr\bin in das Verzeichnis C:\Program Files (x86)\Arduino\hardware\tools\avr\etc kopiert werden.
Danach funktioniert auch das kompilieren der Sketches wieder!
Arduino Ethernet-Empfänger
Die Basis-Station, die die Daten der einzelnen Sensoren empfängt und an ein PHP-Webscript übergibt, ist relativ einfach gestrickt und basiert auf meinem HowTo der VirtualWire-Library.
Ich habe – so hoffe ich – mir Mühe bei der Kommentierung der Sketches gegeben, sodass ich nicht viel dazu erklären muss:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 |
#include <VirtualWire.h> #include <SPI.h> #include <Ethernet.h> const int RECEIVERID = 1; // ID des Empfängers const int RX_Pin = 8; // PIN, an den der 433 Mhz Empfänger angeschlossen ist const int TX_Pin = 9; // Einen leeren PIN angeben, da die VirtualWire-Lib sonst einen Pin belegt, der für den Ethernet-Chip genutzt wird const int PTT_Pin = 7; // Einen leeren PIN angeben, da die VirtualWire-Lib sonst einen Pin belegt, der für den Ethernet-Chip genutzt wird byte mac[] = { 0x00, 0xAB, 0xCB, 0xCD, 0xDE, 0x02 }; byte ip[] = { 192,168,2,177 }; byte subnet[] = { 255,255,255,0 }; byte gateway[] = { 192,168,2,1 }; byte dns1[] = { 192,168,2,1 }; char server[] = "www.3bm.de"; EthernetClient client; void setup() { Serial.begin(9600); // VirtualWire initialisieren vw_setup(2000); // Bits/Sec vw_set_rx_pin(RX_Pin); // Empfangs-Pin für den 433-Empfänger setzen vw_set_tx_pin(TX_Pin); // Wird lediglich benötigt, um den Standard-PIN zu ändern, da dieser im Konflikt mit der Ethernet-Lib steht vw_set_ptt_pin(PTT_Pin); // Wird lediglich benötigt, um den Standard-PIN zu ändern, da dieser im Konflikt mit der Ethernet-Lib steht vw_rx_start(); // Empfänger starten Serial.print(F("Setup LAN ... ")); Serial.println(); // Dem Netzwerk 1 Sekunde zum Initialisierung geben delay(1000); Ethernet.begin(mac, ip, dns1, gateway, subnet); // Ausgabe der Netzwerk-Konfiguration zur Überprüfung Serial.print(F("IP: ")); Serial.println(Ethernet.localIP()); Serial.print(F("SNM: ")); Serial.println(Ethernet.subnetMask()); Serial.print(F("GW: ")); Serial.println(Ethernet.gatewayIP()); Serial.print(F("DNS: ")); Serial.println(Ethernet.dnsServerIP()); Serial.println(F("-------------------")); } void loop(){ uint8_t buf[VW_MAX_MESSAGE_LEN]; uint8_t buflen = VW_MAX_MESSAGE_LEN; // Daten-Variable, die die empfangenen Daten hält char SensorDataTemp[VW_MAX_MESSAGE_LEN+1]; // Daten-Variable, zum Übergeben der Daten an die WebRequest-Funktion String SensorData; // Empfang von Daten prüfen if (vw_get_message(buf, &buflen)) { int i; memset(SensorDataTemp, 0, VW_MAX_MESSAGE_LEN+1); // Das ganze Array mit 0en füllen // Datagramm zusammensetzen for (i = 0; i < buflen; i++) { SensorDataTemp[i] = (char)buf[i]; } // Char-Variable terminieren SensorDataTemp[VW_MAX_MESSAGE_LEN+1] = '\0'; // Char to String-Konvertierung zur Übergabe an die connect()-Funktion SensorData = SensorDataTemp; // Serial-Output zum Debuggen Serial.println(); Serial.print(F("Daten empfangen: ")); Serial.print(SensorData); Serial.println(); Serial.print(F("Daten schicken:")); StringDataUpload(SensorData); } } void StringDataUpload(String payload){ if (client.connect(server, 80)) { Serial.println(); Serial.println("GET /xxx/parse.php?"+payload+"&r="+RECEIVERID+"&key=SECRETKEY HTTP/1.0"); client.println("GET /xxx/parse.php?"+payload+"&r="+RECEIVERID+"&key=SECRETKEY HTTP/1.0"); client.println(F("HOST: 3bm.de")); client.println(F("Connection: close")); client.println(); client.stop(); Serial.println(F("Daten geschickt.")); } else { Serial.println(F("Verbindung fehlgeschlagen")); } } |
Wenn ihr nebenher den seriellen Monitor laufen habt, erscheint bei jedem Empfangenen Datenpaket eine kurze Statusausgabe und die URL, die aufgerufen wird:
|
1 2 3 4 |
Daten empfangen: s=1&t=1929&h=6340&v=5381 Daten schicken: GET /attiny/parse.php?s=1&t=1929&h=6340&v=5381&=1&key=SECRETKEY HTTP/1.0 Daten geschickt. |
Hier sieht man auch schon, was passiert: Der Arduino Ethernet nimmt die empfangenen Daten und ruft damit ein WebScript auf, dass die Daten per $_GET[] entgegen nimmt. Dabei verwende ich als „einfachen Schutz“ einen „key„, den ihr von SECRETKEY auf etwas anderes ändern solltet – damit eben nicht irgendwelche Bots o.ä. meine SQL-Datenbank vollaufen lassen.
ATTiny84-Sender: DS18S20 & DHT22
Kommen wir nun zum Sensordaten-Sender. Zu beachten ist, dass das Setup ohne weiteres funktioniert, wenn Sender/Empfänger max. 50 cm voneinander entfernt sind. Erhöht sich die Reichweite, oder sollen die Sender in einem anderen Raum platziert werden, müssen externe Antennen an die ANT-Pins der 433 Mhz Sender/Empfänger angelötet werden.
Hierzu verwende ich ein 17,34cm (lambda/4) langes Kabel (eine Ader aus einem CAT7-Verlegekabel, Vollkupfer, 1 Kern), das SENKRECHT in die Luft schaut. Beim Ausloten der Reichweite hat sich gezeigt, dass spiralförmig gewickelte Antennen – egal bei welcher Ausrichtung – weniger gute Empfangsraten zeigen als ein Kabel das Senkrecht nach oben steht – kann sich natürlich bei euch anders verhalten.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 |
// Projekt: TinyNode // -------------------------------------------------------- // Sensor: DS18S20 // Sketch: Verschicken der Temperaturdaten EINES DS18S20-Sensors // Datum: 10.11.2013 // -------------------------------------------------------- // Basiert zum Teil auf der Arbeit von Nathan Chantrell //------------------------------------------------------------------------------ // Library-Include //------------------------------------------------------------------------------ #include <VirtualWire.h> // http://www.airspayce.com/mikem/arduino/ // Fix auf dieser Seite beachten: #include <OneWire.h> #include <JeeLib.h> // https://github.com/jcw/jeelib //------------------------------------------------------------------------------ ISR(WDT_vect) { Sleepy::watchdogEvent(); } //--------------------------------------------------------------------------------------------------------- // PIN-Konfiguration //--------------------------------------------------------------------------------------------------------- const int SENSORID = 1; // Die ID des Sensor-Nodes. Dienst zur Identifizierung der Daten. const int DS18S20_DATA_Pin = 2; // PIN, an den das DATA-Bein des Temperatur-Sensor angeschlossen ist const int DS18S20_VCC_Pin = 9; // PIN, an den das VCC-Bein des Temperatur-Sensors angeschlossen ist const int TX_Pin = 3; // PIN, an den der 433 Mhz Sender angeschlossen ist const int interval = 5; // Interval x 60 Sekunden = Schlafzeit zwischen Sensordaten-Übermittlung //--------------------------------------------------------------------------------------------------------- OneWire ds(DS18S20_DATA_Pin); // DS18S20-Setup int durchlauf = interval; // Zähler für Schleife; ist gleich dem Interval, damit bei Start des ATTiny direkt ein Temperaturwert übermittelt wird float temp; // Temperatur-Variable deklarieren char msg[20]; // Temperatur-String zum Versand initialisieren void setup() { vw_setup(2000); // VirtualWire und 433 Mhz-Sender initialisieren vw_set_tx_pin(TX_Pin); analogReference(INTERNAL); // Set the aref to the internal 1.1V reference pinMode(DS18S20_VCC_Pin, OUTPUT); // VCC-Pin des DS18S20 als Ausgang setzen ADCSRA &= ~ bit(ADEN); bitSet(PRR, PRADC); // Stromsparen: ADC deaktivieren } void loop() { while(durchlauf < interval) { durchlauf = durchlauf +1; Sleepy::loseSomeTime(60000); } digitalWrite(DS18S20_VCC_Pin, HIGH); // DS18S20-Sensor einschalten delay(50); // Kurze Delay zur Initialisierung // Fix: Nach dem der DS18S20 mit Strom versorgt wurde, ist die erste Temperatur-Ausgabe 85.00 // Die Temperatur wird so oft abgefragt, bis getTemp() nicht mehr 85.00 zurückliefert while(getTemp() == 85.00) { getTemp(); } // Temperatur Temp1 auslesen und Vor/Nachkomma in zwei Variablen schreiben (int) // Float-Vars lassen sich nicht mit printf() auf Arduino ausgeben! Das ist ein Workaround! // http://forum.arduino.cc/index.php?topic=197900.msg1461205#msg1461205 temp=getTemp()*100; int tempINT = (int)temp; int vccINT = (int)readVcc(); digitalWrite(DS18S20_VCC_Pin, LOW); // DS18S20 ausschalten // msg-Variable mit Daten zum Versand füllen, die später an das WebScript übergeben werden snprintf(msg, 20, "s=%d&t=%d&v=%d", SENSORID,tempINT,vccINT) ; vw_send((uint8_t *)msg, strlen(msg)); // Daten per VirtualWire-Lib versenden vw_wait_tx(); // Auf kompletten Versandt warten durchlauf = 1; // Den Durchlauf-Zähler auf 0 setzen, damit das Interval von vorne beginnt } // getTemp() - Liest den Temperaturwert EINES angeschlossenen DS18S20-Sensor in Celsius aus float getTemp(){ byte data[12]; byte addr[8]; if ( !ds.search(addr)) { //no more sensors on chain, reset search ds.reset_search(); return -1000; } ds.reset(); ds.select(addr); ds.write(0x44,1); // start conversion, with parasite power on at the end byte present = ds.reset(); ds.select(addr); ds.write(0xBE); // Read Scratchpad for (int i = 0; i < 9; i++) { // we need 9 bytes data[i] = ds.read(); } ds.reset_search(); byte MSB = data[1]; byte LSB = data[0]; float tempRead = ((MSB << 8) | LSB); // using two's compliment float TemperatureSum = tempRead / 16; return TemperatureSum; } // readVcc()-Lib von Nathan Chantrell // Gibt die Spannung der Stromversorgung in mV aus // https://github.com/nathanchantrell/TinyTX/blob/master/TinyTX_DS18B20/TinyTX_DS18B20.ino long readVcc() { bitClear(PRR, PRADC); ADCSRA |= bit(ADEN); // Enable the ADC long result; // Read 1.1V reference against Vcc #if defined(__AVR_ATtiny84__) ADMUX = _BV(MUX5) | _BV(MUX0); // For ATtiny84 #else ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); // For ATmega328 #endif delay(2); // Wait for Vref to settle ADCSRA |= _BV(ADSC); // Convert while (bit_is_set(ADCSRA,ADSC)); result = ADCL; result |= ADCH<<8; // Kalibrierung der VCC-Anzeige // http://provideyourown.com/2012/secret-arduino-voltmeter-measure-battery-voltage/ // Abschnitt: Improving Accuracy // scale_constant = internal1.1Ref * 1023 * 1000 // internal1.1Ref = 1.1 * Vcc1 (per voltmeter) / Vcc2 (per readVcc() function) // Default: 1125300L // Meine Konstante: 1070860L, errechnet mit 3x1,5V Batterien als VCC result = 1070860L / result; // Back-calculate Vcc in mV; Calculate Vcc (in mV); 1125300 = 1.1*1023*1000 ADCSRA &= ~ bit(ADEN); bitSet(PRR, PRADC); // Disable the ADC to save power return result; } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 |
// Projekt: TinyNode // ---------------------------------------------------------- // Sensor: DHT22 // Sketch: Verschicken der Temperatur- und Luftfeuchtigkeit // Datum: 10.11.2013 // ---------------------------------------------------------- // Basiert zum Teil auf der Arbeit von Nathan Chantrell //------------------------------------------------------------------------------ // Library-Include //------------------------------------------------------------------------------ #include <VirtualWire.h> // http://www.airspayce.com/mikem/arduino/ // Fix auf dieser Seite beachten: #include <JeeLib.h> // https://github.com/jcw/jeelib #include <DHT22.h> // https://github.com/nathanchantrell/Arduino-DHT22 //------------------------------------------------------------------------------ ISR(WDT_vect) { Sleepy::watchdogEvent(); } //--------------------------------------------------------------------------------------------------------- // PIN-Konfiguration //--------------------------------------------------------------------------------------------------------- const int SENSORID = 1; // Die ID des Sensor-Nodes. Dient zur Identifizierung der Daten. const int DHT22_DATA_Pin = 0; // PIN, an den das DATA-Bein des DHT-Sensor angeschlossen ist const int DHT22_VCC_Pin = 1; // PIN, an den das VCC-Bein des DHT22-Sensors angeschlossen ist const int TX_Pin = 3; // PIN, an den der 433 Mhz Sender angeschlossen ist const int interval = 5; // Interval x 60 Sekunden = Schlafzeit zwischen Sensordaten-Übermittlung //--------------------------------------------------------------------------------------------------------- DHT22 myDHT22(DHT22_DATA_Pin); // DHT-Setup int durchlauf = interval; // Zähler für Schleife; ist gleich dem Interval, damit bei Start des ATTiny direkt ein Temperaturwert übermittelt wird long temp; long humi; // Variablen für Temperatur/Luftfeuchtigkeit char msg[26]; // Temperatur-String zum Versand per 433 Mhz void setup() { vw_setup(2000); // VirtualWire und 433 Mhz-Sender initialisieren vw_set_tx_pin(TX_Pin); analogReference(INTERNAL); // Set the aref to the internal 1.1V reference pinMode(DHT22_VCC_Pin, OUTPUT); // VCC-Pin des DHT22 als Ausgang setzen ADCSRA &= ~ bit(ADEN); bitSet(PRR, PRADC); // Stromsparen: ADC deaktivieren } void loop() { while(durchlauf < interval) { durchlauf = durchlauf +1; Sleepy::loseSomeTime(60000); } DHT22_ERROR_t errorCode; digitalWrite(DHT22_VCC_Pin, HIGH); // DHT22-Sensor einschalten Sleepy::loseSomeTime(2500); // DHT22 benötigt mindestens 2 Sekunden für Aufwärmphase nach dem Power-On errorCode = myDHT22.readData(); // Daten aus Sensor auslesen if (errorCode == DHT_ERROR_NONE) { // Daten sind OK temp = myDHT22.getTemperatureC()*100; humi = myDHT22.getHumidity()*100; } digitalWrite(DHT22_VCC_Pin, LOW); // DHT22 ausschalten // Temperatur/Luftfeuchtigkeit auslesen, mit 100 multiplizieren für Ganzzahl-Umwandlung. // Wird auf Empfängerseite durch 100 geteilt für korrektes Ergebnis. // Float-Vars lassen sich nicht mit printf() auf Arduino ausgeben! Das ist ein Workaround! // http://forum.arduino.cc/index.php?topic=197900.msg1461205#msg1461205 int humiINT = (int)humi; int tempINT = (int)temp; int vccINT = (int)readVcc(); // msg-Variable mit Daten zum Versand füllen, die später an das WebScript übergeben werden snprintf(msg, 26, "s=%d&t=%d&h=%d&v=%d", SENSORID,tempINT,humiINT,vccINT) ; vw_send((uint8_t *)msg, strlen(msg)); // Daten per VirtualWire-Lib versenden vw_wait_tx(); // Auf kompletten Versandt warten durchlauf = 1; // Den Durchlauf-Zähler auf 0 setzen, damit das Interval von vorne beginnt } // readVcc()-Lib von Nathan Chantrell // Gibt die Spannung der Stromversorgung in mV aus // https://github.com/nathanchantrell/TinyTX/blob/master/TinyTX_DS18B20/TinyTX_DS18B20.ino long readVcc() { bitClear(PRR, PRADC); ADCSRA |= bit(ADEN); // Enable the ADC long result; // Read 1.1V reference against Vcc #if defined(__AVR_ATtiny84__) ADMUX = _BV(MUX5) | _BV(MUX0); // For ATtiny84 #else ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); // For ATmega328 #endif delay(2); // Wait for Vref to settle ADCSRA |= _BV(ADSC); // Convert while (bit_is_set(ADCSRA,ADSC)); result = ADCL; result |= ADCH<<8; // Kalibrierung der VCC-Anzeige // http://provideyourown.com/2012/secret-arduino-voltmeter-measure-battery-voltage/ // Abschnitt: Improving Accuracy // scale_constant = internal1.1Ref * 1023 * 1000 // internal1.1Ref = 1.1 * Vcc1 (per voltmeter) / Vcc2 (per readVcc() function) // Default: 1125300L // Meine Konstante: 1070860L, errechnet mit 3x1,5V Batterien als VCC result = 1070860L / result; // Back-calculate Vcc in mV; Calculate Vcc (in mV); 1125300 = 1.1*1023*1000 ADCSRA &= ~ bit(ADEN); bitSet(PRR, PRADC); // Disable the ADC to save power return result; } |
Der Sketch schickt etwa alle 5 Minuten ein Signal zum Empfänger. Dabei ist es so aufgebaut, dass es vom Empfänger direkt als Parameter an das PHP-Webscript übergeben werden kann, ohne noch einmal zerlegt werden zu müssen.
Wir ihr im Sketch seht, verschicke ich nicht nur die Temperatur, sondern auch eine eindeutige ID des Senders (damit die Daten später z.B. einem Raum zugeordnet werden können) und die aktuelle Spannung der Stromversorgung in mV.
Alle Kommawerte (22,95°) kommen dabei *100-multipliziert (2295) beim Webscript an, müssen dort also durch 100 geteilt werden, um wieder auf das korrekte Ergebnis zu kommen (22,95).
Das PHP-Webscript
Das Script, dass vom Arduino Ethernet mit den Daten versorgt wird, ist ebenfalls keine Meisterleistung: Es prüft, ob der Secretkey stimmt, spielt ein wenig mit den empfangenen Sensordaten und speichert diese in einer MySQL-Tabelle:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 |
<?PHP if($_GET['key'] != "SECRETKEY") { echo "Nicht authentifiziert!"; exit; } $mysql_host = "localhost"; $mysql_db = "xxx"; $mysql_user = "xxx"; $mysql_pw = "xxx"; $time = time(); if(isset($_GET['s'])) { $sensorid = $_GET['s']; } if(isset($_GET['r'])) { $receiverid = $_GET['r']; } if(isset($_GET['t'])) { $temp = $_GET['t']; } if(isset($_GET['h'])) { $humi = $_GET['h']; } if(isset($_GET['v'])) { $vcc = $_GET['v']; } $connection = mysql_connect($mysql_host, $mysql_user, $mysql_pw) or die("Verbindung zur Datenbank fehlgeschlagen."); mysql_select_db($mysql_db, $connection) or die("Datenbank konnte nicht ausgewaehlt werden."); $sensorsettings_query = mysql_query("SELECT receiverid FROM sensor_settings WHERE sensorid = $sensorid"); while($sensor_info = mysql_fetch_array($sensorsettings_query)) { $sensor_info_receiverid = $sensor_info["receiverid"]; } # Daten nur verarbeiten, wenn eine Node-ID angegeben wird # und der TinyNode dem Empfänger zugeordnet ist if(isset($sensorid) && $sensor_info_receiverid == $receiverid) { echo "OK:<br>"; # # TEMP # if(isset($temp)) { $temp = round($temp/100,1); # Auf eine Nachkommastelle runden echo "t:".$temp."<br>"; # Empfangenen Sensorwert gegen die letzten 5 gespeicherten Werte prüfen $temp_abweichung = 10; # Die empfangene Temperatur darf bis zu 10° von den letzten 5 Messungen abweichen $get_temp = mysql_query("SELECT sensordata FROM sensor_data WHERE sensordatatyp = 'temp' ORDER BY id DESC LIMIT 5", $connection); $temp5 = ""; while($row_temp = mysql_fetch_array($get_temp)) { $temp5 = $temp5 + $row_temp["sensordata"]; } $temp5 = $temp5 / 5; # Durchschnittswert der letzten 5 Temperatur-Werte $temp5_max = $temp5+$temp_abweichung; # Maximal-Temperatur $temp5_min = $temp5-$temp_abweichung; # Minimal-Temperatur # Werte werden nur gespeichert, wenn sie im Bereich Durchschnittstemperatur+-$temp_abweichung liegen # count($temp5) == 1 : Wenn kein Datensatz in DB vorhanden, wird so trotzdem der erste Eintrag gespeichert if((($temp >= $temp5_min) && ($temp <= $temp5_max)) || count($temp5) == 1) { $insert_temp = "INSERT INTO sensor_data (sensorid, sensordatatyp, sensordata) VALUES ($sensorid, 'temp', $temp)"; mysql_query($insert_temp, $connection) or die("Fehler beim Eintragen der Daten in die Datenbank!"); $update_sensorinfo = "UPDATE sensor_settings SET lastupdate = $time WHERE sensorid = $sensorid"; mysql_query($update_sensorinfo, $connection) or die("Fehler beim Aktualisieren der Daten in die Datenbank!"); } } # # VCC # if(isset($vcc)) { $vcc = round($vcc/1000, 2); # Auf zwei Nachkommastellen runden echo "v:".$vcc."<br>"; $insert_vcc = "INSERT INTO sensor_data (sensorid, sensordatatyp, sensordata) VALUES ($sensorid, 'vcc', $vcc)"; mysql_query($insert_vcc, $connection) or die("Fehler beim Eintragen der Daten in die Datenbank!"); } # # HUMI # if(isset($humi) && ($humi > 0)) { $humi = $humi/100; echo "h:".$humi."<br>"; $insert_humi = "INSERT INTO sensor_data (sensorid, sensordatatyp, sensordata) VALUES ($sensorid, 'humi', $humi)"; mysql_query($insert_humi, $connection) or die("Fehler beim Eintragen der Daten in die Datenbank!"); } } else { echo "Keine SensorID gesetzt oder Sender nicht dem Empfänger zugeordnet"; } ?> |
Hier sind noch einige Debugging-Zeilen inbegriffen; zum Test kann das Webscript natürlich manuell im Browser mit Parametern aufgerufen und die Insert-Funktionen getestet werden.
Dabei werden die empfangenen Werte nicht einfach direkt gespeichert, sondern – wie im Fall der Temperatur – erstmal geprüft: Wenn der empfangene Wert um 10° + oder – vom Durchschnitt der letzten 5 empfangenen Sensorwerte abweicht, werden die Daten nicht gespeichert. Damit verhindere ich, dass mal ein falsch erhaltener Temperaturwert meine Statistiken zerhaut.
Auch zu erwähnen: Ich habe eine separate MySQL-Tabelle (sensor_settings) in der ich Infos zu den Sensoren gespeichert habe (etwa die Sensor-ID, die Sender-Bezeichnung oder Lokation, etc.) – unter anderem ein „lastupdate“-Feld, das immer aktualisiert wird, wenn Sensordaten empfangen und gespeichert wurden.
Das dient mir dann später in den Statistiken als Hilfe um zu deuten, ob der Sensor die letzten male überhaupt Werte übertragen hat, oder ggf. nicht mehr funktioniert.
Die MySQL-Tabelle zur Speicherung der Daten
Als Randnotiz noch das Tabellenlayout meiner sensor_data-Tabelle:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
-- -- Tabellenstruktur für Tabelle `sensor_data` -- CREATE TABLE IF NOT EXISTS `sensor_data` ( `id` int(11) NOT NULL AUTO_INCREMENT, `sensorid` int(11) NOT NULL COMMENT 'Eindeutige Sensor-ID', `sensordatatyp` varchar(255) CHARACTER SET latin1 COLLATE latin1_german1_ci NOT NULL COMMENT 'Typ der Sensordaten, z.B. temp, humi, vcc', `sensordata` float NOT NULL COMMENT 'Sensor-Daten', `datum` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (`id`) ) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1349 ; -- -- Daten für Tabelle `sensor_data` -- INSERT INTO `sensor_data` (`id`, `sensorid`, `sensordatatyp`, `sensordata`, `datum`) VALUES (1, 2, 'temp', 18.5, '2013-11-22 08:33:16'); |
Die Auswertung
Nun habe ich eine tolle Datenbank, in der die ganzen Werte für Temperatur, Luftfeuchtigkeit und Spannungsversorgung reinwandern – aber was fange ich damit nun an?
Zuerst habe ich mich auf die Suche nach einer PHP-Library gemacht, die mir das Erstellen von Charts oder Statistiken vereinfacht und ermöglicht. Fündig wurde ich bei „pChart„, das mit einer verdammt guten Dokumentation – aber anscheinend keinerlei Community aufwartet. Es ist kostenlos für private Zwecke – also prima für mich geeignet.
Ich habe lange nichts mit PHP programmiert, und früher schon gar keine Statistiken, sodass ich mich erstmal einfinden musste. Was mir dabei half waren zum einen die Beispiele, die gute Dokumentation, und die pChart-Sandbox, quasi eine Web-Oberfläche mit der man sich GUI-basiert ein Demo-Chart zusammenstellen und den Quellcode anzeigen lassen kann. Die Sandbox erreicht ihr, in dem ihr die pChart-Lib entpackt, auf einen Webspace hochladet und das Verzeichnis ..\pChart\examples\ im Browser aufruft.
Den Code meiner Statistiken werden ich erstmal nicht veröffentlichen, da ich daran noch aktiv arbeite.
Der aktuelle Stand sieht so aus, dass ich mir Charts in einer MySQL-Tabelle anlege (Welcher Sensor, welche Werte werden empfangen (Temp/Humi/Vcc), wie soll der Hintergrund des Charts aussehen, etc. pp.). Jeder Chart erhält eine ID, und beim Aufruf des generator.php-Scripts mit Übergabe der ID wird mir eine Statistik zurückgeliefert, die ich als Bild einbinden kann:
Sobald ich neue Infos habe, aktualisiere ich diesen Artikel.
Hey,
coole Seite! Gefällt mir!
Tipp für den Sender: Je höher die Spannung desto größer die Reichweite (Der Sender hält bis zu 12 V aus)
und http://board.homecontrol4.me/viewtopic.php?f=7&t=16 hier wird ebenfalls etwas für die Verbesserung des Senders beschrieben. Meiste hast du ja schon richtig!
Die Seite könnte dich auch interessieren!: http://www.homecontrol4.me/
Hallo,
erstmal ein dickes Lob !!! Tolle Seite !!
Habe alles ohne große Probleme nach gebaut.
Habe aber eine Frage, weil ich nicht weiß, wie man das berechnet bzw. rausbekommt.
Kann ich die hier stellen oder lieber per Mail ?
Ist ein bischen länger…
Vielen Dank.
Gruss
Stefan
Hi Stefan,
ja klar, frag einfach 🙂
Hi
erst einmal Kompliment für diese Seite.
Ich bekomme aber immer die Fehlermeldung
can’t open config file „C:\Arduino\arduino-1.5.5-r2/hardware/tools/avr/etc/avrdude.conf“: No such file or directory
was kann ich tun ?
Cu
Joerg
Hi,
hast du die WinAVR-Tools installiert + drübergepackt?
Immer, wenn irgendetwas beim Kompilieren nicht ging, lag mein erster Verdacht auf meinem Virenscanner. Einfach mal den Echtzeitschutz ausmachen und nochmal versuchen 🙂
Hi Bastian,
Danke für die schnelle Antwort . Das Problem war das es gar kein etc Verzeichnis gab.ich habe einfach eins erstellt und die avrdude.conf aus dem bin Verzeichnis hinein kopiert. Und siehe da es geht 😉
Danke nochmal
Joerg
Moin Bastian,
first things first, danke für diese Klasse Anleitung. Sie hat dazu geführt das ich mir jetzt ein Set an Arduino + den vielen tollen anderen besorgt habe. Kurz mal mein Setup:
Arduino Uno, Attiny84V-10PU, XY-FST 433 MHz Transmitter, XY-MK-5V Receiver.
Nun mein Problem: Wenn ich die VirtualWire.h verwende ist es mir nicht möglich von meinem Attiny84 mit dem Arduino zu kommunizieren über die Transmitter & Receiver Kombination. Habe natürlich erstmal klein Angefangen und ein einfaches ‚Hello there‘ versucht zu übetragen. Aber es kommt Partout nichts beim Receiver an. Der Attiny tut was an dem Pin den ich gesetzt habe (12). LED zwischen geklemmt und jedes mal wenn er ‚vermeintlich sendet‘ blinkt es schön 😉 Selbiges auf der Receiver Seite. Kommt dort ein Signal an flackert eine weitere LED ebenfalls.
Verwende ich nun die RCSwitch.h library ist es mir möglich den Attiny zu programmieren und mit erfolg zu senden. Auf dem Serialmonitor bekomme ich dann tatsächlich Ausgaben zu Gesicht.
Was ich mich nun Frage, warum die VirtualWire.h nicht mit dem Arduino kommunizieren möchte.
VirtualWire.h „$Id: VirtualWire.h,v 1.12 2014/02/24 09:07:58 mikem Exp mikem $“
RCSwitch.h 2.51 (Januar 2013).
VirtualWire sketches:
Transmitter: http://pastebin.com/SW5eKXNy
Receiver: http://pastebin.com/wGLhBUuM
RCSwitch sketches:
Transmitter: http://pastebin.com/PGsNpbb8
Receiver: http://pastebin.com/cDbjqzpS
Irgendwelche Ideen?! Ich bin hier momentan Betriebsblind glaube ich.
Danke!
Hallo,
schöner Artikel, der eigentlich das macht, was ich auch möchte. Nur die Ansteuerung des Senders verstehe ich nicht. Da wird der Datenpin mit dem Atmel verbunden und alle anderen Pins auf Masse gelegt. Wo bekommt das Sendemodul den Strom her? So wie es in den Beispielen gesteckt ist, funktioniert es meiner Meinung nach nicht. Mein Modul hat drei Pins: GND, VCC und RX.
Bin ich da jetzt zu dumm oder ist die Abbildung fehlerhaft? Danke für eine kurze Rückmeldung.
Hai,
du hast Recht – der Fehlerteufel. Hab ich den Fritzing-Bildern versehentlich VCC auf Masse gelegt – muss natürlich an die Stromversorgung.
Super Projekt!
Nach dem ersten Lesen habe ich alle Teile bestellt und nachdem alle da waren, direkt angefangen zu basteln. Hatte hi und da einige Schwierigkeiten, aber nichts, was sich nicht lösen ließe 😉
Ich habe mittlerweile einen Sender via DHT22 sowie einen Empfänger (Arduino Uno + ethernet shield).
Nur wo packe ich das php / mysql zeugs hin, damit ich die Website mit den Werten anzeigen lassen kann?
Der Empfang klappt übrigens schon einwandfrei!
Habe nen webserver unter 192.168.178.34 am laufen. Auch ne mysql datenbank. Habe den Server im Empfänger angepasst:
char server[] = „192.168.178.34“;
sowie das
client.println(„GET /temp/arduino.php?“+payload+“&r=“+RECEIVERID+“&key=SECRETKEY HTTP/1.0“);
(die empfänger php liegt unter 192.168.178.34/temp/arduino.php)
Die Daten für die mysql Datenbank stimmen auch, da ich beim aufrufen der arduino.php keine DB Fehlermeldung erhalte. Nur werden keine Daten an die Datenbank übergeben… Bin mir sicher, es ist lediglich ein typo irgendwo. Steh aber gerade extrem auf der Leitung 🙂
Hallo,
versuche doch einfach mal zu prüfen ob der Arduino überhaupt Daten an das PHP-Script übergibt. Z.b. beim Aufruf der passenden URL einen Eintrag mit Datum/Uhrzeit in eine TXT-Datei auf dem Webserver speichern.
Auch hat mir geholfen die Antwort der GET-Abfrage vom Arduino auszuwerten (mein PHP-Script hat bei Erfolg immer ein OK zurückgegeben). Ich habe da gerade keinen passenden Code zur Hand; schau mal in die Webserver-Abfrage-Exampels vom Arduino und erweitere damit deinen Code, damit du die Webserver-Antwort anzeigen lassen kannst.
Hallo,
freut mich, dass ich jemandem weiterhelfen konnte 🙂
Die Website/den Webserver musst du natürlich irgendwo anders laufen lassen. Entweder bei z.B. dir lokal am PC (XAMPP) oder auf einem dedizierten Gerät – das könnte ein Raspberry oder eine halbwegs brauchbare NAS sein. Alternativ natürlich auch ein normaler Webhoster, der dir eine Domain+Webspace zur Verfügung stellt.
Klaro, läuft auch bereits alles. 😉
Kann es sein, dass wenn keine sauberen Daten vom Sensor kommen, garnichts in die Datenbank eingetragen wird?
Empfange nämlich nur folgendes:
Daten empfangen: s=1&t=0&h=0&v=5275
Daten schicken:
GET /temp/arduino.php?s=1&t=0&h=0&v=5275&r=1&key=SECRETKEY HTTP/1.0
Daten geschickt.
Sehr komisch das Ganze…
Gut, der Kommentar kann getrost gelöscht werden.
Memo an mich Selbst, Breadboard-Verkabelung dreifach checken. 😉
Jetzt bekomme ich saubere Werte. Leider wird dennoch nichts an meine Datenbank übergeben…
Tut mir Leid, dass ich hier so spamme.
Ich bekomme nun saubere Werte vom DHT22.
Daten empfangen: s=1&t=2250&h=4640&v=5301
Daten schicken:
GET /temp/arduino.php?s=1&t=2250&h=4640&v=5301&r=1&key=SECRETKEY HTTP/1.0
Daten geschickt.
Wenn ich den Befehl manuell in die Browserleiste eintrage, erhalte ich folgende Fehlermeldung:
Keine SensorID gesetzt oder Sender nicht dem Empfänger zugeordnet
Wobei die SENSORID = 1 und RECEIVERID = 1;
Und übertragen wird ja auch die 1 (s=1) So what?!
Habe den Check der Sensor/ReceiverID entfernt. Läuft jetzt. 😉
Es fehlen die Namen der Libraries in meinem Text. Leider kann ich ihn nicht editieren, daher nochmal:
Hallo,
sehr anschauliche Beschreibung. Habe alles wunderbar nach basteln können. Leider habe ich jedoch mit dem Code für den Sender (DHT22) ein Problem.
Ich habe alle benötigten Libraries runter geladen und in den entsprechenden Ordner kopiert. Die VirtualWire.h und DHT22.h werden beim Einbinden auch wie gewünscht durch das Highlighting erkannt. Jedoch die JeeLib.h nicht. Ich bin bei allen drei Libraries gleich vorgegangen und habe die JeeLib auch mehrfach überprüft. Das Programm lässt sich auf den Controller überspielen, jedoch werden bei der Ausführung des Programms scheinbar die Sleepzeiten übersprungen und ca. alle drei Sekunden Daten gesendet. Was könnte ich übersehen/ falsch gemacht haben? Würde mich über eine Lösung oder einen Hinweis freuen, danke!
Hallo,
hört sich doch so an, als wäre mit der JeeLib etwas nicht in Ordnung.
Versuchs doch mal mit einer älteren JeeLib-Version, bzw. lade einen JeeLib-Demo-Sketch, hänge eine LED an den Arduino, lade den Blink-Sketch und tausche dort Sleep() gegen das Pendant der JeeLib aus.
Das wäre ein guter Test mit wenig Aufwand 🙂
Danke für die schnelle Antwort!
Das Problem scheint unabhängig vom Skript zu sein. Das JeeLib.h bleibt in der Includezeile schlicht schwarz. Bei den anderen Libraries wird der Name farbig markiert. Die JeeLib wird wohl gar nicht erkannt.
Mein Vorgehen: Downloaden der Zip-Datei von Github, entpacken, umbenennen in jeelib (vorher jeelib-master) und kopieren in den Arduino Libraries-Ordner. Beim anschließenden Start der Arduino IDE taucht JeeLib im entsprechenden Menü auf. Gibt es noch Alternativen zu diesem Vorgehen, oder habe ich etwas vergessen?
Hey Bastian,
sehr starker Artikel. Danke schon einmal dafür.
Ich habe nur ein Problem, welches ich gerne verstehen würde. Wenn ich die VirtualWire Lib nach dem erstellen der Ethernetverbindung initialisiere funktioniert die Ethernetverbindung nicht richtig. Setze ich den Code für vw allerdings darüber geht alles. Komme nicht ganz dahinter wieso. Vielleicht kannst du mir ja helfen. 🙂
Beste Grüße
Hallo,
ich hatte genau das gleiche Problem und mich quasi totgesucht, bis ich auf die Idee kam, die include’s zu tauschen.
Wieso weiß ich leider selbst nicht so genau – die VirtualWire wird ja mittlerweile nicht mehr entwickelt (und durch RadioHead ersetzt); wir werden da vermutlich nie eine Antwort drauf bekommen.
Ich vermute, irgendetwas wird „doppelt gesetzt“ in den beiden Libs – und eine funktioniert dann eben nicht mehr richtig.
Hallo
super Seite!
Leider hab ich ein Problem der sender Sketch klappt bei mir auf einem Arduino Nano aber auf dem Attiny84 klappt er einfach nicht egal für welchen sensor ich ihn nehme er sendet einfach nicht.
Woran kann das liegen?
Naja das ist jetzt eine wirklich sehr pauschale Frage. Es kann an vielem liegen; falscher Core auf dem ATTiny84, ATTiny84 kaputt, 433Mhz-Sender am ATTiny84 falsch angeschlossen, etc.
Was hast du schon getestet?
Hallo
also ich hab es mit dem Attiny84 bei 1MHz und bei 8MHz versucht ebenfalls beide Farianten mit jeweils beiden Sender Sketches.
Wenn ich das ganze mit einem Arduino Nano mache klappt es und wenn ich den gleichen 433MHz Sender bei Attiny84 benutze klappt es nicht. Hab auch schon eine LED an die Senderdatenleitung angeschlossen beim Arduino Nano Leuchtet Sie wenn er Sendet aber beim Attiny84 eben nicht und es wird auch nichts Empfangen auf der Gegenseite. Also geh ich stark davon aus das er gar nicht Sendet.
Ich bin echt radlos und weis nicht was ich noch versuchen könnte hast du vielleicht eine Idee?
PS der Attiny kann eigentlich nicht defekt sein wenn ich den Blink Sketch drauf mach klappt alles.
Hab es auch schon mit einem anderen Attiny84 versucht genau das gleiche. Ist echt komisch. Beim Sketch hochladen klappt auch alles.
Manchmal is halt der Wurm drin :/
Es klappt!! Gott ich hab schon lang nicht mehr so gegrinst 🙂
Ich hab den Attiny mal nach deiner Anleitung Programiert und siehe da es geht!
Ist aber echt komisch davor hat ja das Blinken auch geklappt.
Vielen vielen Dank für deine Seite.
Hallo,
wo finde ich diese Anleitung? Ich habe wohl die gleichen Probleme.
Dank im Voraus.
Eine Frage hätte ich da noch, wie müsste ich den Sketch abändern das ich im Seriellen Monitor die Daten anderst anzeigen lassen kann z.b.
Sensor:
Temperatur:
Luftfeuchtigkeit:
Ist das ohne weiteres möglich?
Ich muss das praktisch im Empfänger Sketch abändern bzw. umrechnen aber die frage ist wie?
Hi,
naja, die Daten kommen ja in der Form t=12&h=xx&v=1234 an. Im Empfänger-Sketch musst du eben erst nach „&“ splitten, und dann nach „=“. Und das gibst du dann aus…
hi ich hab mal eine frage:
woraus ergibt sich der wert 26 im befehl char msg[26] beim sender script für den dht 22
danke schon mal im voraus
Mfg jörg
Hm, bin mir nicht sicher worauf du raus willst. Dort wird die Char-Variable mit 26 Zeichen Platz deklariert – mag sein, dass da „noch etwas Luft ist“ und nicht jede Stelle benötigt wird. Meintest du das?
ja das meinte ich dachte das muss optimal abgestimmt sein habs jetzt in nem ähnlichen projekt angewendet und hab auch einfach paar stellen mehr genommen hat super gefuntzt danke für die anleitung hat mir sehr geholfen
Wie lange hebt denn dieser kleine Temperatursensor mit den batterien?
Rechnerisch verdammt lange – „leer“ sind sie bei mir nicht geworden; hatte sie etwa 6 Monate im Einsatz. Rechnerisch irgendwo bei 12 Monaten +
Hi Ist es möglich die Fritzing datei von dir zu bekommen mir sind da einige anschlüsse noch nicht so ganz klar, ich versuch das so ähnlich nachzubauen. wäre super wenn man die bekommen könnte. Da ich für zuhause eine ähnliche konstellation vor habe.
Sollte das auch mit einem attiny85 funktionieren ?
Hi Bastian,
super Seite und eine klasse Anleitung zu dem Thema. Was mich interessieren würde: welche Batterie-Laufzeiten erreichst du beim DHT22-Sender?
Danke und Grüße
Benny
Hi, great project. I am a bit baffled by your pins. Could someone please send pictures of your finished breadboard? What I don’t understand is this:
For DHT22 you define these pins:
const int DHT22_DATA_Pin = 0; // PIN, an den das DATA-Bein des DHT-Sensor angeschlossen ist
const int DHT22_VCC_Pin = 1; // PIN, an den das VCC-Bein des DHT22-Sensors angeschlossen ist
const int TX_Pin = 3; // PIN, an den der 433 Mhz Sender angeschlossen ist
But on the Fritzing schema DHT’s VCC (first leg) is connected to Atmel’s PIN 9 (third on left-hand side), sensor’s DATA is connected to Atmel’s PIN10 (secon on left-hand side) and 433’s VCC pin is connected to PIN7 (PWM)… Could you please help me out here with a picture? Simply pins in your source and those on the picture do not correlate.
Also, is it possible to create the sketch in Arduino and then upload the .hex file via usbasp, thus skipping arduino as ISP programmer? Or will arduino set some funky fusebits without which the processor will be dead? I tried different cabling but it is doing nothing so I got pins wrong or my hex from Arduino bured via ExtremeBurner is not doing anything (fusebits?)
Would love to build this for my parents. Thanks anyone for any help.