Go Down

Topic: Senden von Temperatur und Luftfeuchtigkeit mit Zigbee (Read 1 time) previous topic - next topic

HotSystems

#45
Sep 18, 2020, 04:40 pm Last Edit: Sep 18, 2020, 05:39 pm by HotSystems
Was mir auch auffällt, du hast am Empfänger auch den Sensor dran und liest ihn aus.
Willst du beide Sensordaten gleichzeitig anzeigen ?
Dann musst du das aber anders aufbauen, also nacheinander.


Also wozu ist das hier im Empfänger ?

Code: [Select]
#define DHTPIN 2        //DHT22 wird am Pin2 ausgelesen
#define DHTTYPE DHT22   //Es handelt sich um den DHT22 Sensor

DHT dht(DHTPIN, DHTTYPE); //Der Sensor wird ab jetzt mit "dht" angesprochen

Temperatur = dht.readTemperature(); //Temperatur innen wird gemessen und gespeichert
Feuchtigkeit = dht.readHumidity(); //Luftfeuchte innen wird gemessen und gespeichert

    HC12.print (Temperatur);   // Kommando
    HC12.print (",");          // Abgrenzung
    HC12.print (Feuchtigkeit);  // Kommando
    HC12.print (",");           // Abgrenzung



usw.
Im Empfänger willst du doch sicher nur die gesendeten Daten anzeigen ?
Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

HotSystems

#46
Sep 18, 2020, 05:45 pm Last Edit: Sep 18, 2020, 05:46 pm by HotSystems
Ich habe hier mal einen Teil meines Empfänger-Test-Sketches mit dem HC-12 kopiert.
Es ist nur die Loop, aus der du die notwendigen Teile entnehmen kannst.

Code: [Select]
void loop()
{
  if (HC12.available() > 0) {
    inputString = "";
    while (HC12.available() > 0) {
      digitalWrite(ledPin, HIGH);
      //Serial.print(char(HC12.read()));

      char inChar = (char(HC12.read()));
      inputString.concat(inChar);                 // Füge das Zeichen an den String an, damit wir den kompletten Text erhalten
      if (inputString != "")
      {
        if (inChar == '\r') {
          stringComplete = true;
        }
      }
    }
  }
  lcd.setCursor(0, 1);
  if (stringComplete) {
    char c_Input[10];
    inputString.toCharArray(c_Input, 7);
    lcd.print(c_Input);                           // Anzeige auf LCD
  }
  delay(100);
  digitalWrite(ledPin, LOW);
}


Die Anzeige erfolgt hier auf einem LCD, welches du aber leicht für dich anpassen kannst.
Z.B. auf dem seriellen Monitor.
Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

adruinoboy

Hallo HotSystems,

der Empfänger soll sowohl die empfangenen Daten vom Sender anzeigen als auch die eigenen Temperatur und Feichtigkeitswerte des eigenen Sensors.
Deswegen dieser Teilsketch.

adruinoboy

Vielen Dank erstmal wieder für deine Hilfe. Ich habe den Sketch jetzt soweit angepasst.
Der Empfängersketch lautet:

Code: [Select]

#include <SoftwareSerial.h>
#include "DHT.h"          //DHT Bibliothek laden

enum class Command {
              Temperatur ,
              Feuchtigkeit
            };

unsigned long BT_timestore;        //Variable Speicher für Systemzeit
String Temperatur = "";            // a String to hold incoming data
String inputString = "";           //Definition für Empfangene Daten HC12
String stringComplete = "";        //Definition für Empfangene Daten HC12
Command typ1 = Command::Temperatur;   // Wird nur bei Bedarf erzeugt
String Feuchtigkeit = "";           // a String to hold incoming data
Command typ2 = Command::Feuchtigkeit;  // Wird nur bei Bedarf erzeugt
bool stringtempComplete = false;   // wheter the string is complete
bool stringfeuchteComplete = false;// wheter the string is complete

#define DHTPIN 2        //DHT22 wird am Pin2 ausgelesen
#define DHTTYPE DHT22   //Es handelt sich um den DHT22 Sensor

SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin
DHT dht(DHTPIN, DHTTYPE); //Der Sensor wird ab jetzt mit "dht" angesprochen

void setup()
{
 Serial.begin(9600);             // Serial port to computer
 HC12.begin(9600);               // Serial port to HC12
 //reserve 200 byzes for the Temp. und Luftfeuchte
 Temperatur.reserve(200);
 Feuchtigkeit.reserve(200);
}

void loop()
{
  if (HC12.available() > 0)
  {
    inputString = "";
    while (HC12.available() > 0)
    {
      char inChar = (char(HC12.read()));
      inputString.concat(inChar);           //Füge das Zeichen an den String an, damit wir den kompletten Text erhalten
      if (inputString != "")
      {
        if (inChar == '\r')
        {
          stringComplete = true;
        }
      }
    }
  }
  //lcd.setCursor(0, 1);
  if (stringComplete)
  {
    char c_Input[10];
    inputString.toCharArray(c_Input, 7);
    Serial.println(c_Input);                        //Anzeige auf seriellem Monitor
  }
  delay(100);
}


Aber immernoch bekomme ich ganz schön viel Müll raus.

Die Ausgabe sieht folgendermaßen aus:

Code: [Select]

00:12:26.080 ->
00:12:26.265 -> ⸮⸮r⸮⸮⸮
00:12:26.350 -> 0,49.1
00:12:26.444 -> ,49.10
00:12:26.566 -> 49.10,
00:12:26.666 -> 9.10,2
00:12:26.767 -> 9.10,2
00:12:26.867 -> 9.10,2
00:12:26.967 -> 22.00,
00:12:27.067 -> 22.00,
00:12:27.215 -> 2.00,4
00:12:27.315 -> .00,49
00:12:27.415 -> 0,49.0
00:12:27.516 -> 0,49.0
00:12:27.669 -> 0,22.0
00:12:27.769 -> ,22.00
00:12:27.870 -> 22.00,
00:12:27.970 -> 2.00,4
00:12:28.070 -> .00,49
00:12:28.170 -> 00,49.
00:12:28.318 -> 0,49.0
00:12:28.418 -> ,49.00
00:12:28.518 -> 49.00,
00:12:28.619 -> 9.00,2
00:12:28.719 -> .00,22
00:12:28.819 -> .00,22
00:12:28.920 -> .00,22
00:12:29.020 -> 22.00,
00:12:29.120 -> 2.00,4
00:12:29.274 -> .00,49
00:12:29.374 -> 00,49.
00:12:29.475 -> 0,49.0
00:12:29.575 -> ,49.00
00:12:29.807 -> 49.00,
00:12:29.807 -> .00,22
00:12:29.891 -> .00,22
00:12:30.023 -> 00,22.
00:12:30.123 -> 0,22.0
00:12:30.224 -> 22.00,
00:12:30.324 -> .00,49
00:12:30.424 -> 00,49.
00:12:30.578 -> 0,49.0
00:12:30.678 -> 0,49.0
00:12:30.778 -> 0,49.0
00:12:30.879 -> 0,49.0
00:12:30.979 -> 22.00,
00:12:31.079 -> .00,22
00:12:31.180 -> 00,22.
00:12:31.280 -> 0,22.0
00:12:31.380 -> 22.00,
00:12:31.527 -> 22.00,
00:12:31.628 -> 2.00,4
00:12:31.728 -> .00,49
00:12:31.828 -> 00,49.
00:12:31.982 -> 0,49.0
00:12:32.082 -> 0,22.0
00:12:32.182 -> ,22.00
00:12:32.283 -> 22.00,
00:12:32.383 -> 2.00,4
00:12:32.483 -> .00,49
00:12:32.584 -> 00,49.
00:12:32.731 -> 0,49.0
00:12:32.831 -> 0,49.0
00:12:32.932 -> 0,49.0
00:12:33.032 -> 22.00,
00:12:33.132 -> .00,22
00:12:33.232 -> .00,49
00:12:33.386 -> 00,49.
00:12:33.487 -> 0,49.0
00:12:33.587 -> ,49.00
00:12:33.687 -> 49.00,
00:12:33.787 -> 9.00,2
00:12:33.888 -> 00,22.
00:12:34.035 -> ,22.00
00:12:34.135 -> 2.00,4
00:12:34.236 -> 2.00,4
00:12:34.336 -> 2.00,4
00:12:34.437 -> 2.00,4
00:12:34.536 -> .00,49
00:12:34.690 -> 00,49.
00:12:34.790 -> 00,49.
00:12:34.837 -> 00,49.
00:12:34.991 -> 22.00,
00:12:35.091 -> .00,22
00:12:35.191 -> 00,22.
00:12:35.292 -> 0,22.0
00:12:35.392 -> ,22.00
00:12:35.492 -> 22.00,
00:12:35.640 -> 2.00,4
00:12:35.740 -> 00,49.
00:12:35.840 -> 0,49.0
00:12:35.940 -> 9.00,2
00:12:36.094 -> 0,22.0
00:12:36.194 -> .00,49
00:12:36.295 -> 0,49.0
00:12:36.395 -> ,49.00
00:12:36.495 -> 49.00,
00:12:36.642 -> 9.00,2
00:12:36.743 -> .00,22
00:12:36.843 -> .00,22
00:12:36.943 -> .00,22
00:12:37.044 -> 22.00,
00:12:37.145 -> 2.00,4
00:12:37.297 -> .00,49
00:12:37.398 -> 00,49.
00:12:37.498 -> 0,49.0
00:12:37.598 -> ,49.00
00:12:37.699 -> 9.00,2
00:12:37.799 -> 9.00,2
00:12:37.946 -> 00,22.
00:12:38.047 -> ,22.00
00:12:38.147 -> ,22.00
00:12:38.300 -> 0,49.0
00:12:38.400 -> 9.00,2
00:12:38.501 -> 0,22.0
00:12:38.601 -> ,22.00
00:12:38.701 -> 22.00,
00:12:38.802 -> 22.00,
00:12:38.902 -> 22.00,
00:12:39.002 -> 22.00,



Irgendwas passt mit der Trennung der Zahlen nicht.

wno158

Nimm mal das delay(100) am Ende der Loop raus.

Bei 9600bps hast Du ca. 1/10000s pro Bit, macht rund und eckig 1/1000s (1ms) pro Byte. Du wartest aber 100ms ohne dass die CPU irgendetwas anderes tun darf. In der Zeit können theoretisch bis zu 100 Byte vom HC12 einlaufen. Soooo lang ist der Engangspuffer von SoftSerial vermutlich nicht.

Das Lesen von Bytes findet ja richtigerweise nur statt, wenn Daten anliegen (HC12.available()). Die Verarbeitung findet statt, wenn der String komplett ist (stringComplete). Die loop() darf also wiederholt aufgerufen werden um den String vom HC12 einzusammeln.

Nur den InputString darfst Du dann nicht bei jedem einlaufenden Byte wieder löschen, sondern nur, nachdem er komplett ist. Und bei der Gelegenheit solltest Du dann stringComplete auch wieder zurücksetzen

Ohne es kompiliert oder getestet zu haben:
Code: [Select]

#include <SoftwareSerial.h>
#include "DHT.h"          //DHT Bibliothek laden

enum class Command {
              Temperatur ,
              Feuchtigkeit
            };

unsigned long BT_timestore;        //Variable Speicher für Systemzeit
String Temperatur = "";            // a String to hold incoming data
String inputString = "";         //Definition für Empfangene Daten HC12
String stringComplete = "";        //Definition für Empfangene Daten HC12
Command typ1 = Command::Temperatur;   // Wird nur bei Bedarf erzeugt
String Feuchtigkeit = "";           // a String to hold incoming data
Command typ2 = Command::Feuchtigkeit;  // Wird nur bei Bedarf erzeugt
bool stringtempComplete = false;   // wheter the string is complete
bool stringfeuchteComplete = false;// wheter the string is complete

#define DHTPIN 2        //DHT22 wird am Pin2 ausgelesen
#define DHTTYPE DHT22   //Es handelt sich um den DHT22 Sensor

SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin
DHT dht(DHTPIN, DHTTYPE); //Der Sensor wird ab jetzt mit "dht" angesprochen

void setup()
{
 Serial.begin(9600);             // Serial port to computer
 HC12.begin(9600);               // Serial port to HC12
 //reserve 200 byzes for the Temp. und Luftfeuchte
 Temperatur.reserve(200);
 Feuchtigkeit.reserve(200);
}

void loop()
{
  if (HC12.available() > 0)
  {
    // HIER NOCH NICHT LÖSCHEN!
 // inputString = "";
    while (HC12.available() > 0)
    {
      char inChar = (char(HC12.read()));
      inputString.concat(inChar);           //Füge das Zeichen an den String an, damit wir den kompletten Text erhalten
      if (inputString != "")
      {
        if (inChar == '\r')
        {
          stringComplete = true;
        }
      }
    }
  }
  //lcd.setCursor(0, 1);
  if (stringComplete)
  {
    char c_Input[10];
    inputString.toCharArray(c_Input, 7);
    Serial.println(c_Input);                        //Anzeige auf seriellem Monitor
 // JETZT ABER!
 inputString = "";
 stringComplete = false;
  }
  // BITTE NICHT.
  // delay(100);
}


Gruß Walter
Gruß Walter

adruinoboy

Hallo Walter,

danke für dein Bemühen. Deine Erklärung hört sich plausibel an. Ich habe den Empfänger auch so angepasst. Aber das Ergebnis ist das gleiche. Hier mein veränderter Sketch und dann die sinnlose Ausgabe auf dem seriellen Monitor:

Code: [Select]

#include <SoftwareSerial.h>
#include "DHT.h"          //DHT Bibliothek laden

enum class Command {
              Temperatur ,
              Feuchtigkeit
            };

unsigned long BT_timestore;        //Variable Speicher für Systemzeit
String Temperatur = "";            // a String to hold incoming data
String inputString = "";           //Definition für Empfangene Daten HC12
String stringComplete = "";        //Definition für Empfangene Daten HC12
Command typ1 = Command::Temperatur;   // Wird nur bei Bedarf erzeugt
String Feuchtigkeit = "";           // a String to hold incoming data
Command typ2 = Command::Feuchtigkeit;  // Wird nur bei Bedarf erzeugt
bool stringtempComplete = false;   // wheter the string is complete
bool stringfeuchteComplete = false;// wheter the string is complete

#define DHTPIN 2        //DHT22 wird am Pin2 ausgelesen
#define DHTTYPE DHT22   //Es handelt sich um den DHT22 Sensor

SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin
DHT dht(DHTPIN, DHTTYPE); //Der Sensor wird ab jetzt mit "dht" angesprochen

void setup()
{
 Serial.begin(9600);             // Serial port to computer
 HC12.begin(9600);               // Serial port to HC12
 //reserve 200 byzes for the Temp. und Luftfeuchte
 Temperatur.reserve(200);
 Feuchtigkeit.reserve(200);
}

void loop()
{
  if (HC12.available() > 0)
  {
    inputString = "";
    while (HC12.available() > 0)
    {
      char inChar = (char(HC12.read()));
      inputString.concat(inChar);           //Füge das Zeichen an den String an, damit wir den kompletten Text erhalten
      if (inputString != "")
      {
        if (inChar == '\r')
        {
          stringComplete = true;
        }
      }
    }
  }
  //lcd.setCursor(0, 1);
  if (stringComplete)
  {
    char c_Input[10];
    inputString.toCharArray(c_Input, 7);
    Serial.println(c_Input);                        //Anzeige auf seriellem Monitor
    inputString = "";
    stringComplete = false;
  }
}


Code: [Select]

16:09:15.597 ->
16:09:17.143 -> ͦ
16:09:17.143 -> &
16:09:17.143 ->
16:09:17.143 -> ⸮
16:09:17.143 ->
16:09:17.143 -> ⸮b
16:09:17.143 -> ⸮⸮r
16:09:17.143 -> ʂb
16:09:17.143 -> ⸮⸮r
16:09:17.256 -> ⸮⸮
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 -> 0,3
16:09:17.256 -> 7.9
16:09:17.256 -> 0,2
16:09:17.256 -> 3.4
16:09:17.256 -> 0,3
16:09:17.256 -> 7
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 ->
16:09:17.256 -> .9
16:09:17.256 -> 0,23.4
16:09:17.256 -> 0,37.9
16:09:17.256 -> 23.40,
16:09:17.256 -> 7.90,2
16:09:17.312 -> 40,37.
16:09:17.312 -> 0,23.4
16:09:17.312 -> 37.90,
16:09:17.312 -> 3.40,3
16:09:17.326 -> 90,2
16:09:17.326 -> 3.40,3
16:09:17.326 -> 23.40
16:09:17.326 -> ,37.9
16:09:17.326 -> 0,23.4
16:09:17.326 -> 7.90,
16:09:17.326 -> 23.40,
16:09:17.326 -> 90,2
16:09:17.326 -> 3.40,3
16:09:17.376 -> 0,23.4
16:09:17.376 -> 0,37.9
16:09:17.376 -> 23.40,
16:09:17.376 -> 90,23
16:09:17.423 -> .40,37
16:09:17.423 -> ,23
16:09:17.423 -> .40,37
16:09:17.423 -> 90,23.
16:09:17.423 -> ,37.90
16:09:17.423 -> 23.40,
16:09:17.423 -> 90,23
16:09:17.423 -> .40,37
16:09:17.470 -> ,23
16:09:17.470 -> .40,37
16:09:17.470 -> 90,23.
16:09:17.470 -> 37.90
16:09:17.470 -> ,23.40
16:09:17.516 -> .90,23
16:09:17.516 -> 40,37.
16:09:17.516 -> ,
16:09:17.516 ->
16:09:17.516 ->
16:09:17.516 ->
16:09:17.516 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.563 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.610 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.657 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.704 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 ->
16:09:17.752 -> 23.4
16:09:17.798 -> 0,37.8
16:09:17.798 -> ,23.4
16:09:17.798 -> 0,37.8
16:09:17.798 -> .40,37
16:09:17.845 -> .80,23
16:09:17.845 -> 40,37.
16:09:17.845 -> 23.40
16:09:17.845 -> ,37.80
16:09:17.892 -> .40
16:09:17.892 -> ,37.80
16:09:17.892 -> 23.40,
16:09:17.892 -> 80,23.
16:09:17.892 -> 0,37.8
16:09:17.892 -> 3.40,
16:09:17.892 -> 37.80,
16:09:17.892 -> 40
16:09:17.892 -> ,37.80
16:09:17.938 -> 23.40,
16:09:17.938 -> 80,23
16:09:17.938 -> .40,37
16:09:17.938 -> ,23.4
16:09:17.938 -> 0,37.8


Es gibt regelmäßige Aussetzer. Ich freue mich über weitere Hilfe. Ich komme da nicht weiter.

HotSystems

So wie das aussieht, sendest du die Daten ohne Pause.

Da solltest du beim Senden zwingend eine Pause einlegen.
Du musst die Daten nicht ständig senden. Mach eine längere Pause, min. 5 Sek. oder länger.
Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

wno158

Habe jetzt den Sender nicht nochmal nachgeschlagen; schließe mich aber Dieters Argument an. So schnell ändern sich die Werte wohl nicht.

Aber in Zeile 39 (Sketch aus #50) setzt Du immer noch jedesmal, wenn Du erfolgreich auf Empfang von (mindestens) einem Byte prüfst, den inputString zurück.
Wenn Du da nicht zufällig auf den Anfang der Übertragung triffst geht es schief.

Gruß Walter
Gruß Walter

HotSystems

Hallo Walter,
da das Beispiel des Sketches von mir kam, weiß ich, dass es auch so funktioniert.
Aber dein Vorschlag ist sicher auch ok.

Vermutlich liegt das Problem aber tatsächlich am gesendeten Signal.
Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

wno158

Ah ja, das habe ich wohl verdrängt :)

Wenn das also mit langsamerem Sender nicht funktioniert, würde ich noch gerne ein "Sendeprotokoll" sehen, also die auf den HC12 gesendeten Informationen dort ebenfalls auf den seriellen Monitor kopieren.

Warum?

inputString.toCharArray(c_Input, 7); nimmt nur 7 Zeichen aus dem empfangenen String.
Wenn der Sender noch der aus #44 ist, darf der HC12.print() der beiden Float-Werte nicht allzu viele (Nachkomma)Stellen liefern: TTT.tt,FFF.ff, sind schon 14 Zeichen.
Deshalb würde ich mal nachsehen, was da eigentlich gesendet wird.

Eigentlich würde für die Ausgabe im Empfänger ja auch ein Serial.println(inputString.c_str()); reichen, oder?
Gruß Walter

HotSystems

Eigentlich würde für die Ausgabe im Empfänger ja auch ein Serial.println(inputString.c_str()); reichen, oder?
Da fehlt mir die Erfahrung, habe es damit noch nicht probiert.
Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

michael_x

Wenn du schon
String inputString hast, macht

Serial.println(inputString);  den Aufruf der .c_str() Methode selbst. Kannst du dir also sparen, oder machen, kein Unterschied.

combie

Moin adruinoboy,
die Fehlermeldung wird durch die Codezeilen
HC12.write << Temperatur << ',' << tempaussen << ';' << endl;
HC2.write << Feuchtigkeit << ',' << feuchteaussen << ';' << endl;
erzeugt.
Für diese einfache Anwendung ist ein Streaming nicht sinnvoll.
Ersetze diese durch
//  HC12.write << Temperatur << ',' << tempaussen << ';' << endl;
//  HC12.write << Feuchtigkeit << ',' << feuchteaussen << ';' << endl;

    HC12.print (Temperatur); // Kommando
    HC12.print (",");        // Abgrenzung
    HC12.print (tempaussen); // Messwert
    HC12.println (";");        // Abgrenzung

    HC12.print (Feuchtigkeit); // Kommando
    HC12.print (",");        // Abgrenzung
    HC12.print (feuchteaussen); // Messwert
    HC12.println (";");        // Abgrenzung
viel Erfolg
Gruss Peter
und gesund bleiben
Oje.....

Streaming nicht verstanden!
Nicht nur von dir ....

Code: [Select]

// falsch
HC12.write << Temperatur << ',' << tempaussen << ';' << endl;


// richtig
HC12 << Temperatur << ',' << tempaussen << ';' << endl;





Der Grund:
Der << Operator benötigt eine Referenz auf eine Print Instanz.
write ist allerdings eine Methode, welche nur die Anzahl gesendeter Bytes zurückgibt, keine Referenz auf eine Print Instanz.
Zudem fehlen die Klammern bei der Methode.

Also blanker Unsinn das so zu versuchen.


Quote
Für diese einfache Anwendung ist ein Streaming nicht sinnvoll.
Eine völlige Fehleinschätzung.


Streaming ist sinnvoll, wenn man ein Herz für Programmästhetik hat.
> Ästhetik bedeutet wörtlich:
> Lehre von der Wahrnehmung bzw. vom sinnlichen Anschauen.

Es hat also nichts mit der Einfachheit der Anwendung zu tun, sondern eher mit Empfindungen.


---

Zudem rate ich zum CmdMessenger, wenn man Probleme beim parsen von seriellen Übertragungen hat.
Denn der hat das dazu nötige Zeugs schon im Bauch.
Es ist offensichtlich, dass uns die Umstände alleine nicht glücklich oder unglücklich machen.
Es ist die Art unserer Reaktion darauf, die unsere Gefühle bestimmt.

Peter-CAD-HST

Oje.....

Streaming nicht verstanden!
Nicht nur von dir ....


Code: [Select]

// falsch
HC12.write << Temperatur << ',' << tempaussen << ';' << endl;


// richtig
HC12 << Temperatur << ',' << tempaussen << ';' << endl;





Der Grund:
Der << Operator benötigt eine Referenz auf eine Print Instanz.
write ist allerdings eine Methode, welche nur die Anzahl gesendeter Bytes zurückgibt, keine Referenz auf eine Print Instanz.
Zudem fehlen die Klammern bei der Methode.

Also blanker Unsinn das so zu versuchen.

Eine völlige Fehleinschätzung.


Streaming ist sinnvoll, wenn man ein Herz für Programmästhetik hat.
> Ästhetik bedeutet wörtlich:
> Lehre von der Wahrnehmung bzw. vom sinnlichen Anschauen.

Es hat also nichts mit der Einfachheit der Anwendung zu tun, sondern eher mit Empfindungen.


---

Zudem rate ich zum CmdMessenger, wenn man Probleme beim parsen von seriellen Übertragungen hat.
Denn der hat das dazu nötige Zeugs schon im Bauch.

Quote
Streaming nicht verstanden!
Nicht nur von dir ....
Stimmt nicht, ich habe mich mit Thema "Streaming" nicht beschägtigt.
Erstmal eine falsche Aussage unterstellen, dass ist immer einfacher als kontruktive Beispiele zugeben.
Ich wünsche einen geschmeidigen Sonntag
Gruß Peter
und gesund bleiben
KISS Q&D - keep calm and carry on - mind the gap - beware of sharks! -

combie

Quote
Stimmt nicht, ich habe mich mit Thema "Streaming" nicht beschägtigt.
Stimmt also doch!
(ist deine Logik kaputt?)
Wer sich noch nicht mit sowas beschäftigt hat, kann es nicht verstanden haben.


Natürlich ist es auch viel einfacher über irgendwas zu urteilen, wenn man es nicht verstanden hat. Z.B. wird das Urteil dann nicht von irgendwelchen Fakten getrübt.
Nennt man dann auch gerne Vorurteil.

Merke:
Es ist nicht schlimm, irgendwas nicht zu wissen.
Aber es ist schlimm aus dem Nichtwissen (falsche) Urteile abzugeben.

Siehe:
> Für diese einfache Anwendung ist ein Streaming nicht sinnvoll.


Als Wissender, zumindest als Person mit fundiertem Halbwissen, erlaube ich mir das Fehlurteil zu kritisieren.
Dabei ist mir völlig egal, ob dir das schmeckt, oder nicht.
Keinesfalls lasse ich die Mitleser über die Klinge springen, nur damit dein Wohlbefinden gewahrt bleibt.

---

Quote
dass ist immer einfacher als kontruktive Beispiele zugeben.
Nunja...
Zumindest konnte ich dir(und anderen) zeigen, wie man es in diesem Fall richtig anwendet.
Es ist ok, wenn du das nicht als Beispiel akzeptieren möchtest, ....

Es ist offensichtlich, dass uns die Umstände alleine nicht glücklich oder unglücklich machen.
Es ist die Art unserer Reaktion darauf, die unsere Gefühle bestimmt.

Go Up