INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Sensor-Adressdaten mittels json von Webserver einlesen und hinterlegen
18.02.2021, 19:02
Beitrag #1
Sensor-Adressdaten mittels json von Webserver einlesen und hinterlegen
Hallo zusammen,
ich probiere schon Tagelang ohne Erfolg an folgendem Problem:
Ich bastel an einer Bienenwaage und möchte diese möglichst "bedienerfreundlich" gestalten. Deshalb habe ich vor, diverse Parameter (Messinervalle, Adressen von Sensoren,..) auf einer Internetseite zu hinterlegen. Diese werden in einer json-Datei abgelegt und regelmäßig über einen ESP8266 abgerufen und per SoftwareSerial an einen Arduino Mega 2560 übertragen. Bis dahin funktioniert es auch einwandfrei.
Ich schaffe es jedoch nicht das die Adressen funktionierend übertragen werden.

Verschiedene herangehensweisen in der "Funktion_DS18B20":
Variante 1: die einzige die Funktioniert
Variante 2: Messwert -127.00
Variante 3: Beim Versuch den Messwert als String zu übertragen kommt beim überprüfen schon die Fehlermeldung: "cannot convert 'String' to 'uint8_t {aka unsigned char}' in initialization"
Variante 4: Messwert -127.00

Info: Die "const size_t capacity" ist an die übertragene Datengröße angepasst.

Ist mein Vorhaben überhaupt umsetzbar?
Wenn ja würde ich mich über eine Hilfe freuen!

Vielen Dank schonmal im Vorraus!!!


Code:
#include <ArduinoJson.h>
#include <Wire.h>
#include <DallasTemperature.h>

String data;    // empfangene JSON-Daten
  
long Intervall_DS18B20 = 5000;
unsigned long VergangeneMillis_DS18B20 = 0;

OneWire oneWire(3);
DallasTemperature DS18B20_Sensors(&oneWire);

char* DS18B20_Sensor1;
char* DS18B20_Sensor2;
char* DS18B20_Sensor3;
char* DS18B20_Sensor4;
char* DS18B20_Sensor5;
char* DS18B20_Sensor6;
char* DS18B20_Sensor7;
char* DS18B20_Sensor8;
String DS18B20_Sensor9;

DeviceAddress DS18B20_Sensor1Adr = { 0x28, 0xAA, 0x05, 0x6B, 0x1B, 0x13, 0x02, 0xD5 };

byte resolution = 12;
unsigned long lastTempRequest = 750;
unsigned long ConversionDelay = 750;

float TempSensor1;


void setup() {  
  
  Serial.begin(9600);
  Serial1.begin(9600);

  Serial.println("ArduinoMega bereit...");

  DS18B20_Sensors.begin();
  DS18B20_Sensors.setResolution(DS18B20_Sensor1Adr, resolution);
}




void loop() {
  Funktion_DS18B20();
  DatenVomESP8266Empfangen();
}


void Funktion_DS18B20() {
  if (millis() - VergangeneMillis_DS18B20 >= Intervall_DS18B20) {
      VergangeneMillis_DS18B20 = millis();
    
      DS18B20_Sensors.requestTemperatures();
      lastTempRequest = millis();

       char* X1 = DS18B20_Sensor1;
       char* X2 = DS18B20_Sensor2;
       char* X3 = DS18B20_Sensor3;
       char* X4 = DS18B20_Sensor4;
       char* X5 = DS18B20_Sensor5;
       char* X6 = DS18B20_Sensor6;
       char* X7 = DS18B20_Sensor7;
       char* X8 = DS18B20_Sensor8;

//  Variante 1:
     DeviceAddress DS18B20_Sensor1Adr = { 0x28, 0xAA, 0x05, 0x6B, 0x1B, 0x13, 0x02, 0xD5 };
//  Variante 2:
//      DeviceAddress DS18B20_Sensor1Adr = { DS18B20_Sensor1, DS18B20_Sensor2, DS18B20_Sensor3, DS18B20_Sensor4, DS18B20_Sensor5, DS18B20_Sensor6, DS18B20_Sensor7, DS18B20_Sensor8 };
//  Variante 3:
//     DeviceAddress DS18B20_Sensor1Adr = { DS18B20_Sensor9 };  
//  Variante 4:
//     DeviceAddress DS18B20_Sensor1Adr = { X1, X2, X3, X4, X5, X6, X7, X8 };      


      TempSensor1 = DS18B20_Sensors.getTempC(DS18B20_Sensor1Adr);  
          
      Serial.print("Temp: ");
      Serial.println(TempSensor1);
  }
}


void DatenVomESP8266Empfangen() {
    if (Serial1.available()){
      data = Serial1.readString(); //Read the serial data and store it
      Serial.println(data);

      String payload = data; //Daten in eine Variable speichern
      const size_t capacity = JSON_OBJECT_SIZE(1) + JSON_OBJECT_SIZE(5) + JSON_OBJECT_SIZE(8) + JSON_OBJECT_SIZE(10) + JSON_OBJECT_SIZE(20) + 1400;
      DynamicJsonDocument doc(capacity);
      deserializeJson(doc, payload);

      DS18B20_Sensor1 = doc["DS18B20"]["DS18B20_Sensor1"];
      Serial.print("DS18B20_Sensor1:  ");
      Serial.println(DS18B20_Sensor1);
      DS18B20_Sensor2 = doc["DS18B20"]["DS18B20_Sensor2"];
      Serial.print("DS18B20_Sensor2:  ");
      Serial.println(DS18B20_Sensor2);
      DS18B20_Sensor3 = doc["DS18B20"]["DS18B20_Sensor3"];
      Serial.print("DS18B20_Sensor3:  ");
      Serial.println(DS18B20_Sensor3);
      DS18B20_Sensor4 = doc["DS18B20"]["DS18B20_Sensor4"];
      Serial.print("DS18B20_Sensor4:  ");
      Serial.println(DS18B20_Sensor4);
      DS18B20_Sensor5 = doc["DS18B20"]["DS18B20_Sensor5"];
      Serial.print("DS18B20_Sensor5:  ");
      Serial.println(DS18B20_Sensor5);

      DS18B20_Sensor6 = doc["DS18B20"]["DS18B20_Sensor6"];
      Serial.print("DS18B20_Sensor6:  ");
      Serial.println(DS18B20_Sensor6);
      DS18B20_Sensor7 = doc["DS18B20"]["DS18B20_Sensor7"];
      Serial.print("DS18B20_Sensor7:  ");
      Serial.println(DS18B20_Sensor7);
      DS18B20_Sensor8 = doc["DS18B20"]["DS18B20_Sensor8"];
      Serial.print("DS18B20_Sensor8:  ");
      Serial.println(DS18B20_Sensor8);
      String DS18B20_Sensor9 = doc["DS18B20"]["DS18B20_Sensor9"];
      Serial.print("DS18B20_Sensor9:  ");
      Serial.println(DS18B20_Sensor9);

      Serial.println(" - - - ");
    }

}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.02.2021, 19:15
Beitrag #2
RE: Sensor-Adressdaten mittels json von Webserver einlesen und hinterlegen
So richtig verstehe ich Dein Problem noch nicht. Welche Adressen meinst Du?
Welche Lib nutzt Du? Ich empfehle die nachfolgende Lib.
OneWire ist ein Bus, da kannst Du mehrere DS18B20 anschließen.
Schau Dir mal das Beispiel multiple zur Lib an (Das Beispiel muss zur Lib passen).

Machbar ist das, Du musst allerdings die evtl. unterschiedlichen Größen der Variablentypen im 32-Bit-Prozessor ESP8266 und im 8-Bit-Prozessor AtMega 2560 beachten. Infos dazu hier und hier.

Fehlermeldungen sind nur sinnvoll auswertbar, wenn der dazugehörige Code und die vollständige Fehlermeldung incl. Zeilennummer angegeben wird. Wir wissen nicht, welche der 4 Varianten Dein Code ist.

Hast Du an der Datenleitung des D18B20 einen PullUp-Widerstand (ca. 4.7 kOhm) dran?

Vorschlag: Teste die DS18B20 erst mal al Mega allein und wenn das funktioniert über den ESP.

Gruß Tommy
Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.02.2021, 19:43
Beitrag #3
RE: Sensor-Adressdaten mittels json von Webserver einlesen und hinterlegen
Vielen Dank für deine schnelle Antwort.

Zitat:Welche Adressen meinst Du?
DeviceAddress DS18B20_Sensor1Adr = { 0x28, 0xAA, 0x05, 0x6B, 0x1B, 0x13, 0x02, 0xD5 }

Zitat:Hast Du an der Datenleitung des D18B20 einen PullUp-Widerstand (ca. 4.7 kOhm) dran? Vorschlag: Teste die DS18B20 erst mal al Mega allein und wenn das funktioniert über den ESP.
Ja ich jabe einen 4,7k Widerstand dran und der Sensor funktioniert auch.
Im kompletten Sketch+Hardware habe ich 10 D18B20-Sensoren dran hängen ohne Probleme.

Zitat:Wir wissen nicht, welche der 4 Varianten Dein Code ist
Der Code hatte die Variante 4, in der die Temperaturmessung funktioniert hat. Aber in dem Fall wird die Adresse nicht über die json-Daten bezogen.

Leider kann ich die Fehlercode's gerade nicht mehr kopieren, da der Mega Probleme machtSadConfused
Ich werde mir erstmal deine Links anschauen und mich dann nochmal melden.
Vielen Dank schonmal!!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.02.2021, 19:46
Beitrag #4
RE: Sensor-Adressdaten mittels json von Webserver einlesen und hinterlegen
Alles klar. Ein Hinweis noch: Die Adresse ist ein Array aus 8 Bytes, keine Zeichenkette und ich denke, da liegt das Problem.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
21.02.2021, 18:51
Beitrag #5
RE: Sensor-Adressdaten mittels json von Webserver einlesen und hinterlegen
Hallo Tommy,

ich habe mir deine Links angeschaut und bin der Meinung das diese nicht mein Problem lösen, da ich die Daten korrekt auf dem ArduinoMega empfange, jedoch nicht korrekt weiter verarbeiten/verwenden kann. Irre ich mich?Huh

Da der erste Code ziemlich verwirrend war, habe ich ihn geändert, jedoch mit dem selben Problem:

Code:
#include <ArduinoJson.h> //JSON
String data;

long Intervall_DS18B20 = 5000;
unsigned long VergangeneMillis_DS18B20 = 0;
long Verzoegerung_DatenVomESP8266Empfangen = 20000;     // Verzoegerung, um mehrere Messungen zu ermoeglichen bevor die Adresse veraendert wird
unsigned long ZeitSetupEnde = 0;

#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 3
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

DeviceAddress sensorAdr = {};     // Die Adresse ist nicht eingetragen, da diese von der json-Datei bezogen werden soll
byte resolution = 12;

float TempSensor;


// Die 8 einzelnen Bloecke des DS18B20-Sensors
char* x1 = 0x28 ;
char* x2 = 0xAA ;
char* x3 = 0x05 ;
char* x4 = 0x6B ;
char* x5 = 0x1B ;
char* x6 = 0x13 ;
char* x7 = 0x02 ;
char* x8 = 0xD5 ;

char* x9;     // wird "x8" nach dem aus auslesen der json-Daten (DS3231_Adresse)



void setup() {  
  Serial.begin(9600);
  Serial1.begin(9600);
  sensors.begin();
  delay (2000);
  Serial.println("ArduinoMega bereit...");
  ZeitSetupEnde = millis();
}



void loop() {
  DS18B20_auslesen();
  DatenVomESP8266Empfangen();
}


void DS18B20_auslesen() {
  if (millis() - VergangeneMillis_DS18B20 >= Intervall_DS18B20) {
    VergangeneMillis_DS18B20 = millis();

    DeviceAddress sensorAdr = { x1, x2, x3, x4, x5, x6, x7, x8 };
    sensors.setResolution(sensorAdr, resolution);
    sensors.requestTemperatures();
    TempSensor = sensors.getTempC(sensorAdr);

    Serial.print("DS18B20 Messung: ");
    Serial.println(TempSensor);
  }
}



void DatenVomESP8266Empfangen() {
  if (ZeitSetupEnde + Verzoegerung_DatenVomESP8266Empfangen <= millis()) {

    if (Serial1.available()){
      data = Serial1.readString(); //Read the serial data and store it
      Serial.println(data);

      String payload = data; //Daten in eine Variable speichern
      const size_t capacity = 3*JSON_OBJECT_SIZE(1) + JSON_OBJECT_SIZE(4) + 200;
      DynamicJsonDocument doc(capacity);
      deserializeJson(doc, payload);

      long Messintervall = doc["Zeitintervalle"]["Messintervall"];  // wird hier nicht weiter verwendet
      Serial.print("Messintervall:   ");
      Serial.println(Messintervall);
  
      char* x9 = doc["Uhr"]["DS3231_Adresse"];  // ist der letzte Block der Adresse des DS18B20 Sensors
      Serial.print("DS3231_Adresse:  ");
      Serial.println(x9);
      x8 = x9;    // den 8. Adressblock austauschen    
    
      String DS18B20_Sensor = doc["DS18B20"]["DS18B20_Sensor"];     // ist die vollstaendige Adresse des DS18B20 Sensors
      Serial.print("DS18B20_Sensor:  ");
      Serial.println(DS18B20_Sensor);

      Serial.print("x8: ");   // Kontrolle des 8. Blocks
      Serial.println(x8);

    }
  }
}

Serielle Ausgabe:
Die ersten 4 Messungen werden korrekt durchgeführt. Dann wird der 8. Adressblock durch den empfangenen (ist identisch) ausgetauscht und der Sensor misst nichts mehr.
Code:
18:43:35.221 -> ArduinoMega bereit...
18:43:38.909 -> DS18B20 Messung: 24.12
18:43:43.938 -> DS18B20 Messung: 25.44
18:43:48.915 -> DS18B20 Messung: 26.06
18:43:53.941 -> DS18B20 Messung: 25.69
18:43:56.751 -> {"Setup-Datei":"Bienenwaage","Zeitintervalle":{"Messintervall":{"Setup-Datei":"Bienenwaage","Zeitintervalle":{"Messintervall":"10000"},"Uhr":{"DS3231_Adresse":"0xD5"},"DS18B20":{"DS18B20_Sensor":"0x28, 0xAA, 0x05, 0x6B, 0x1B, 0x13, 0x02, 0xD5"}}
18:43:57.028 -> Messintervall:   0
18:43:57.028 -> DS3231_Adresse:  
18:43:57.074 -> DS18B20_Sensor:  null
18:43:57.074 -> x8:
18:43:58.964 -> DS18B20 Messung: -127.00
18:44:03.947 -> DS18B20 Messung: -127.00
18:44:06.761 -> {"Setup-Datei":"Bienenwaage","Zeitintervalle":{"Messintervall":"10000"},"Uhr":{"DS3231_Adresse":"0xD5"},"DS18B20":{"DS18B20_Sensor":"0x28, 0xAA, 0x05, 0x6B, 0x1B, 0x13, 0x02, 0xD5"}}
18:44:06.945 -> Messintervall:   10000
18:44:06.992 -> DS3231_Adresse:  0xD5
18:44:06.992 -> DS18B20_Sensor:  0x28, 0xAA, 0x05, 0x6B, 0x1B, 0x13, 0x02, 0xD5
18:44:07.084 -> x8: 0xD5
18:44:08.932 -> DS18B20 Messung: -127.00
18:44:13.964 -> DS18B20 Messung: -127.00
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
21.02.2021, 19:07
Beitrag #6
RE: Sensor-Adressdaten mittels json von Webserver einlesen und hinterlegen
Wenn Du alles richtig empfängst, weiß ich nicht, wo Dein Problem ist.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
22.02.2021, 18:46
Beitrag #7
RE: Sensor-Adressdaten mittels json von Webserver einlesen und hinterlegen
Das Problem ist dass, das ich es nicht schaffe die Adresse des DS18B20-Sensors zu ändern.
Wenn ich die Adresse im Sketch hinterlegt habe funktioniert die Messung einwandfrei, wenn ich aber hergehe und versuche die Adresse mittels Sketch zu ändern klappts nicht.

Ich benötige das um bei einem eventuellen defekten Sensor, die Adresse des Ersatzsensor Zuhause im trockenen auszulesen und dann einfach die neue Adresse übers Internet übermittel kann. So muss ich nur vor Ort "im Feld" den Sensor tauschen. Angedacht sind dann auch weitere Online-Parameteränderungen wie Messintervall,...

Gruß MLuhmann
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
22.02.2021, 18:56
Beitrag #8
RE: Sensor-Adressdaten mittels json von Webserver einlesen und hinterlegen
Dann baue einen neuen Sketch, der nur die Daten liest, ins Array einträgt und Dir das Array byteweise HEX im seriellen Monitor anzeigt.
Zum Vergleich die Ausgabe der Sensoradresse, wenn Du sie in den Sketch schreibst - als Array, wie von der Lib gefordert.

Solange das nicht funktioniert, ist alles Weitere sinnlos.

Warum schreibst Du aber, dass Du alles richtig empfängst? Wenn das wahr wäre, würde es ja funktionieren.

Deine Sensoradresse ist uint8_t adresse[8] definiert und so solltest Du sie auch ablegen und nicht in einzelnen Char * -Konstanten, das sind Adressen.
Du solltest ein paar Grundlagen lernen.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Arduino JSON Geister-Zeichen am Ende Hero 1 347 28.06.2021 20:51
Letzter Beitrag: Hero
  EZO- HUM- Sensor Leonardo 28 2.929 18.01.2021 19:39
Letzter Beitrag: Leonardo
  LED als lichtempfindlicher Sensor daja64 7 1.058 23.12.2020 01:18
Letzter Beitrag: daja64
  zweiten Wert über Serial einlesen vlakvark 7 953 14.12.2020 21:06
Letzter Beitrag: Tommy56
  RC-Signal mit Attiny85 einlesen chcs 4 797 08.12.2020 08:51
Letzter Beitrag: hotsystems
  Beispiele / Ethernet / Webserver polarlicht 5 861 20.11.2020 22:31
Letzter Beitrag: Tommy56
  Schwimmerschalter einlesen (Wasserkraftwerkmodell) bobby85cr 29 3.314 18.09.2020 07:56
Letzter Beitrag: hotsystems
  Webseite auf Webserver hochladen DO3GE 20 2.246 08.09.2020 22:35
Letzter Beitrag: DO3GE
  Serielle Werte in String einlesen um damit zu rechnen 425t 2 1.304 26.08.2020 13:19
Letzter Beitrag: 425t
  Arduino Webserver Hinweis PopUp kiximek 1 877 31.05.2020 19:41
Letzter Beitrag: Tommy56

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste