User Tools

Site Tools


Sidebar

projekte:grossprojekte:lorawan:12_temp-feuchte

12 Temperatur - Luftfeuchte



Eine Node nie ohne Antenne in Betrieb nehmen! Durch die reflektierte Sendenenergie nimmt der LoRa-Chip Schaden.



Allgemein

Aufbau einer LoRa-Node zur Überwachung von Temperatur und Feuchte in einem abgelegenen Gebäude.

Verwendung findet dabei der “Digitale Temperatur- und Feuchte-Sensor” DHT22.

Da im Gebäude Strom verfügbar ist und die Überwachung nur temporär sein soll, wurden einige Vereinfachungen vorgenommen. Der Node wird über ein USB-Steckernetzteil versorgt. Der Aufbau ist in einem Halbschalengehäuse untergebracht. Der interne Aufbau ist “fliegend”. Weiterhin werden die Messwerte auf ganze Zahlen gerundet. D.h. sowohl die Temperatur als auch die Angaben zur relativen Luftfeuchte werden nur in 1 °C - bzw. 1% RelH- Schritten übertragen. Dafür benötigt die Übertragung nur insgesamt zwei Byte Daten. Dieses kommt der Datansparsamkeit zugute. Weiterhin werden nur alle 30 Minuten Daten übertragen.

Material

Benötigtes Material:

  • Halbschalenghäuse (oder ähnlich)
  • Arduino Uno (oder ähnlich)
  • Graduino Shield mit LoRa Chip (oder ähnliche Konstruktionen)
  • Antenne für den Bereich 868 MHz
  • DHT22 Sensor
  • Kabelsatz zum Anschluß DHT22
  • USB Kabel Typ B-Stecker (Arduino) - auf Typ A-Stecker (Steckernetzteil)
  • USB-Steckerladegrät



Kabelsatz

Der DHT22 besitzt vier Anschlüsse - VCC - Daten - NULL - GND (Datenblatt
Die Anschlüsse NULL und GND sind zusammenzulegen und auf GND zu führen. Zur Verkabelung kommen die aus den Arduino Workshops bekannten Steckerkabel zur Anwendung.
Am DHT22 besitzen die Kabel eine Buchse, am anderen Ende einen kleinen Steckstift. Dieser wird einfach in die entsprechende Buchsenleiste am LoRa Shield (VCC, GND und Digital Pin 4 ) gesteckt. Der DHT22 passt in die Buchsen der Steckerkabel.
Man verbindet zwei dieser Steckerkabel zu einem “Y”, d.h. zwei Buchsen auf der Seite des DHT22 und ein Stecker auf Seite des LoRa-Shields. (Durchschneiden, Abisolieren, Zusammenlöten, Schrumpfschlauch drüber)
Die vier Buchsen klebt man, nachdem sie am DHT22 gesteckt und damit ausgerichtet sind, mit einem kleinen Streifen Gewebeband zu einer vierpoligen “Buchsenleiste” zusammen.
Kabelsatz


Antennendurchführung

Die Stirnwand des Schalenghäuses ist in einer Führung einsetzbar und soll mit einem kleinen Durchführungsloch für die Schraubantenne gleichzeitg als “Halterung” für den Arduino gelten.
An geigneter Stelle ein Loch bohren, Schraubanschluß hinhdurchstecken, Antenne aufschrauben - fertig.
 Antennendurchführung


Stromkabel und Sensorkabel

An der gegenüberliegenden Stirnwand des Halbschalengehäuses an passender Stelle einen Schlitz zur Durchführung des USB-Kabel einarbeiten und am oberen Rand einen schmalen Bereich ausschneiden, um das Kabel für den Sensor durchführen zu können. Ist der Bereich schmal genug, klemmt der Deckel das Kabel etwas ein und sichert es dadurch auch etwas.
Stromkabel - Sensorkabel


Übersicht

 Zusammengebaut, Deckel offen














Fertig


Zuletzt noch den Halbschalendeckel aufsetzen. Fertig ist die Node.

 Gesamtgerät




Sketch

Was wäre eine Node ohne Programm (Sketch)? (siehe auch)
Zur Verwendung kommt der LoRa-Universalsketch (von mir gekürzt und ohne die Serial.print-Anweisungen) mit Erweiterungen zum Auslesen des Sensors DHT22. Zum ersten Test wurden einige eigene Serial.print-Anweisungen verwendet. Sobald der Node funktionierte wurden sie deaktiviert.
Nartürlich muss die Node vorher wieder im TTN-Netzwerk in seiner zugehörigen Applikation registriert werden. Dadurch erhält man alle nötigen Adress- und Passwortangaben (APPEUI, DEVEUI und APPKEY) die im Sketch eingetragen werden müssen.
(Ich habe diese Daten im nachfolgenden Listing natürlich wieder unkenntlich gemacht)
Der Sketch wurde mit der Bibliothek “MCCI_LoRaWAN_LMIC_library” compiliert. Verwendet wurde die Version 3.0.99. Mit der inzwischen verfügbaren Version 3.1. liefen die Nodes nicht sauber. Leider kennt die Arduino IDE keine Versionsverwaltung, d.h. man kann im Sketch keine Version fix setzen, außer mit einigem an Handarbeit und Kopierarbeit. Was aber nicht unbedingt der Sinn der Sache sein kann.

  1. /*******************************************************************************
  2.   Copyright (c) 2015 Thomas Telkamp and Matthijs Kooijman
  3.   Copyright (c) 2018 Terry Moore, MCCI
  4.  
  5.   Permission is hereby granted, free of charge, to anyone
  6.   obtaining a copy of this document and accompanying files,
  7.   to do whatever they want with them without any restriction,
  8.   including, but not limited to, copying, modification and redistribution.
  9.   NO WARRANTY OF ANY KIND IS PROVIDED.
  10.  
  11.   This example sends a valid LoRaWAN packet with payload "Hello,
  12.   world!", using frequency and encryption settings matching those of
  13.   the The Things Network.
  14.  
  15.   This uses OTAA (Over-the-air activation), where where a DevEUI and
  16.   application key is configured, which are used in an over-the-air
  17.   activation procedure where a DevAddr and session keys are
  18.   assigned/generated for use with all further communication.
  19.  
  20.   Note: LoRaWAN per sub-band duty-cycle limitation is enforced (1% in
  21.   g1, 0.1% in g2), but not the TTN fair usage policy (which is probably
  22.   violated by this sketch when left running for longer)!
  23.  
  24.   To use this sketch, first register your application and device with
  25.   the things network, to set or generate an AppEUI, DevEUI and AppKey.
  26.   Multiple devices can use the same AppEUI, but each device has its own
  27.   DevEUI and AppKey.
  28.  
  29.   Do not forget to define the radio type correctly in
  30.   arduino-lmic/project_config/lmic_project_config.h or from your BOARDS.txt.
  31.  
  32.  *******************************************************************************/
  33.  
  34. #include <lmic.h>
  35. #include <hal/hal.h>
  36. #include <SPI.h>
  37. //
  38. //eigene Bibliotheken
  39. #include <SimpleDHT.h>
  40. //
  41. // eigene Defintitionen
  42. //DHT22
  43. int pinDHT22 = 4;
  44. SimpleDHT22 dht22(pinDHT22);
  45. float temperature = 0;
  46. float humidity = 0;
  47. //
  48. //
  49. // Application EUI Reihenfolge LSB MSB
  50. static const u1_t PROGMEM APPEUI[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  51. void os_getArtEui (u1_t* buf) {
  52. memcpy_P(buf, APPEUI, 8);
  53. }
  54.  
  55. //Device EUI Reihenfolge LSB MSB
  56. static const u1_t PROGMEM DEVEUI[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  57. void os_getDevEui (u1_t* buf) {
  58. memcpy_P(buf, DEVEUI, 8);
  59. }
  60.  
  61. // Application Key Achtung: Reihenfolge MSB LSB
  62. static const u1_t PROGMEM APPKEY[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  63. void os_getDevKey (u1_t* buf) {
  64. memcpy_P(buf, APPKEY, 16);
  65. }
  66.  
  67. static uint8_t payload[] = "XY";
  68. static osjob_t sendjob;
  69.  
  70. // Schedule TX every this many seconds (might become longer due to duty
  71. // cycle limitations).
  72. const unsigned TX_INTERVAL = 1800; //30 Min
  73.  
  74. // Pin Mapping für Graduino LoRa Shield for Arduino
  75. const lmic_pinmap lmic_pins = {
  76. .nss = 10,
  77. .rxtx = LMIC_UNUSED_PIN,
  78. .rst = 9,
  79. .dio = {2, 6, 7},
  80. };
  81.  
  82. void onEvent (ev_t ev) {
  83. switch (ev) {
  84. case EV_JOINED:
  85. {
  86. u4_t netid = 0;
  87. devaddr_t devaddr = 0;
  88. u1_t nwkKey[16];
  89. u1_t artKey[16];
  90. LMIC_getSessionKeys(&netid, &devaddr, nwkKey, artKey);
  91. }
  92. // Disable link check validation (automatically enabled
  93. // during join, but because slow data rates change max TX
  94. // size, we don't use it in this example.
  95. LMIC_setLinkCheckMode(0);
  96. break;
  97. case EV_TXCOMPLETE:
  98. // Schedule next transmission
  99. os_setTimedCallback(&sendjob, os_getTime() + sec2osticks(TX_INTERVAL), do_send);
  100. break;
  101. default:
  102. break;
  103. }
  104. }
  105.  
  106. void do_send(osjob_t* j) {
  107. // Check if there is not a current TX/RX job running
  108. if (LMIC.opmode & OP_TXRXPEND) {
  109. } else {
  110. // Eigene Sensoren
  111. temperature = 0;
  112. humidity = 0;
  113. int err = SimpleDHTErrSuccess;
  114. if ((err = dht22.read(&temperature, &humidity, NULL)) != SimpleDHTErrSuccess)
  115. {
  116. //Serial.print("Read DHT22 failed, err="); Serial.println(err); delay(2000);
  117. //return;
  118. temperature=0;
  119. humidity=0;
  120. }
  121. //Serial.print("Sample OK: ");
  122. //Serial.print(temperature); Serial.print(" *C, ");
  123. //Serial.print(humidity); Serial.println(" RH%");
  124. //DHT22 sampling rate is 0.5HZ.
  125. delay(2500);
  126. // die Integerwerte werden jeweils als 1 Byte übertragen, sie kommen im Hex-Format bei TTN an
  127. // d.h. Anzeige TTN 1. Byte 14 (Hex) ist 20 Grad Celsius
  128. // 2. Byte 38 (Hex) ist 56 % Rel H
  129. payload[0] = int(temperature);
  130. payload[1] = int(humidity);
  131. // Ende eigene Sensoren
  132. // Prepare upstream data transmission at the next possible time.
  133. LMIC_setTxData2(1, payload, sizeof(payload) - 1, 0);
  134. }
  135. // Next TX is scheduled after TX_COMPLETE event.
  136. }
  137.  
  138. void setup() {
  139. // Eigenes Setup
  140. //Serial.begin(115200);
  141. //Serial.println("DHT22 - Test!");
  142. // Ende eigenes Setup
  143. //
  144. #ifdef VCC_ENABLE
  145. // For Pinoccio Scout boards
  146. pinMode(VCC_ENABLE, OUTPUT);
  147. digitalWrite(VCC_ENABLE, HIGH);
  148. delay(1000);
  149. #endif
  150.  
  151. // LMIC init
  152. os_init();
  153. // Reset the MAC state. Session and pending data transfers will be discarded.
  154. LMIC_reset();
  155. LMIC_setClockError(MAX_CLOCK_ERROR * 2 / 100);
  156. LMIC_setupChannel(0, 868100000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
  157. LMIC_setupChannel(1, 868300000, DR_RANGE_MAP(DR_SF12, DR_SF7B), BAND_CENTI); // g-band
  158. LMIC_setupChannel(2, 868500000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
  159. LMIC_setupChannel(3, 867100000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
  160. LMIC_setupChannel(4, 867300000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
  161. LMIC_setupChannel(5, 867500000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
  162. LMIC_setupChannel(6, 867700000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
  163. LMIC_setupChannel(7, 867900000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
  164. LMIC_setupChannel(8, 868800000, DR_RANGE_MAP(DR_FSK, DR_FSK), BAND_MILLI); // g2-band
  165.  
  166. LMIC_setLinkCheckMode(0);
  167. LMIC.dn2Dr = SF9;
  168. LMIC_setDrTxpow(DR_SF7, 14);
  169. // Start job (sending automatically starts OTAA too)
  170. do_send(&sendjob);
  171. }
  172.  
  173. void loop() {
  174. os_runloop_once();
  175. }


Was kommt hinzu: (Zeilenangaben in Klammern)

  • (39) Bibliothek für den DHT22
  • (43-46) Datenpin (Digitalpin 4), Initialisierung, Variablendefinition
  • (110-131) Auslesen des Sensors mit Fehlerbehandlung, Übergabe der Daten in die Payload



Stand: 26.03.2020

projekte/grossprojekte/lorawan/12_temp-feuchte.txt · Last modified: 2020/03/26 09:02 by fablab_wiki