Poolsteuerung mit Arduino

Ich baue mir gerade eine Poolsteuerung auf Basis von 2 Arduino uno und einen Mega mit Ethernetshield für die Anbindung an Fhem als Webserver.

Jetzt habe ich an einem Arduino eine Ph Meßsonde angeschlossen und anhand von Ph Prüfmittel programmiert. Funktioniert bestens aber gestern habe ich das ganze nicht über den Festrechner sondern über das Laptop getestet und die Werte, (sind ja eh nur Millivolt) passten nicht mehr!
Nach ewigen Prüfen habe ich festgestellt das die USB Schnittstelle nur 4,5 und keine 5 Volt liefert!!
Deswegen brauche ich glatte 5 Volt sonst passen die ganzen Werte nicht mehr.
Jetzt denke ich, ich nehme ein Prototype shield und einen Ams1117 Spannungswandler damit ich korrekte 5 Volt am 5 Volt Pin des Arduinos habe.
Meint ihr ich sollte noch einen DC/DC Wandler davor einbauen oder reicht der Ams1117
Achja die Sonde heißt
(Liquid PH0-14 PH Electrode Sonde BNC für Arduino)
ich schick euch mal den Sketch mit

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

// Set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27, 16, 2); 


 
// Ethernet Based on script by David A. Mellis and Tom Igoe and Andal

 
// Beide Libraries sind erforderlich
#include <SPI.h>      // Libary fürs ethernet shield
#include <Ethernet.h> // Libary Ethernet
 
// Hier die MAC Adresse des Shields eingeben
// (Aufkleber auf Rückseite)
byte mac[] = { 
 0x90, 0xA2, 0xDA, 0x00, 0xFB, 0x80 };
 
// Eine IP im lokalen Netzwerk angeben. Dazu am besten die IP
// des PCs herausfinden (googlen!) und die letzte Zahl abändern 
IPAddress ip(192,168,178,10);
 
// Ethernet Library als Server initialisieren
// Verwendet die obige IP, Port ist per default 80
EthernetServer server(80);

float calibration = 21.34; //  Kalibrierungvariable
const int analogInPin = A0; 
int sensorValue = 0; 
unsigned long int avgValue;  //Store the average value of the sensor feedback
float b;
int buf[10],temp;
void setup()
{
 // Serielle Kommunikation starten, damit wir auf dem Seriellen Monitor
 // die Debug-Ausgaben mitlesen können.
 Serial.begin(9600);
 
    // initialisieren des LCD
  lcd.begin();

  // Lcd Blacklight und Textausgeben.
  lcd.backlight();
  lcd.print("Andalino Cal");
  pinMode(A1,OUTPUT);
  pinMode(13,OUTPUT);  
  Serial.begin(9600);  
  Serial.println("Ready");    //Test the serial monitor
  delay(4000);
  // Ethernet Verbindung und Server starten
 Ethernet.begin(mac, ip);
 server.begin();
 Serial.print("Server gestartet. IP: ");
 // IP des Arduino-Servers ausgeben
 Serial.println(Ethernet.localIP());

}
void loop()
{
  
 
  for(int i=0;i<10;i++)       //Erhalten von 10 Probenwert vom Sensor, um den Wert zu glätten
  { 
    buf[i]=analogRead(analogInPin);
    delay(30);
  }
  for(int i=0;i<9;i++)        //Sortieren den Analogport von klein nach groß
  {
    for(int j=i+1;j<10;j++)
    {
      if(buf[i]>buf[j])
      {
        temp=buf[i];
        buf[i]=buf[j];
        buf[j]=temp;
      }
    }
  }
  avgValue=0;
  for(int i=2;i<8;i++)                      //take the average value of 6 center sample
    avgValue+=buf[i];
  float pHVol=(float)avgValue*5.0/1024/6; //umwandeln vom analog auf Millivolt
  float phValue= -5.70*pHVol + calibration; //Umwandeln von Millivolt auf  pH value und calibrationsfaktor
  lcd.clear();
  lcd.setCursor(0,1);    // setzt den Cursor auf die 2.Zeile auf den 1.Platz
  lcd.print("PH:");                     //lcd ausgabe
  lcd.print(phValue,2);
  lcd.print("V:");                     //lcd ausgabe PH und Spannung
  lcd.print(pHVol,3);
  Serial.print("    pH:");  
  Serial.print(phValue,2);
  Serial.print("    Volt:");  
  Serial.print(pHVol,3);
  lcd.setCursor(0,0);
  lcd.print(Ethernet.localIP());         
  
  Serial.println(" ");
  digitalWrite(13, HIGH);       
  delay(800);
  digitalWrite(13, LOW);
  if (phValue>=7.00) {                       //stellt A1 auf 5 Volt
  digitalWrite(A1, HIGH);
  } else {
  digitalWrite(A1, LOW);
  }
 // server.available() schaut, ob ein Client verfügbar ist und Daten
 // an den Server schicken möchte. Gibt dann eine Client-Objekt zurück,
 // sonst false
 EthernetClient client = server.available();
 // Wenn es einen Client gibt, dann...
 if (client) 
 Serial.println("Neuer Client");
 // Jetzt solange Zeichen lesen, bis eine leere Zeile empfangen wurde
 // HTTP Requests enden immer mit einer leeren Zeile 
 boolean currentLineIsBlank = true;
 // Solange Client verbunden 
 while (client.connected()) {
 // client.available() gibt die Anzahl der Zeichen zurück, die zum Lesen
 // verfügbar sind
 if (client.available()) {
 // Ein Zeichen lesen und am seriellen Monitor ausgeben
 char c = client.read();
 Serial.write(c);
 // In currentLineIsBlank merken wir uns, ob diese Zeile bisher leer war.
 // Wenn die Zeile leer ist und ein Zeilenwechsel (das \n) kommt,
 // dann ist die Anfrage zu Ende und wir können antworten
 if (c == '\n' && currentLineIsBlank) {
 // HTTP Header 200 an den Browser schicken
 client.println("HTTP/1.1 200 OK");
 client.println("Content-Type: text/html");
 client.println("Connection: close"); // Verbindung wird nach Antwort beendet
 client.println("Refresh: 2"); // Seite alle 25 Sekunden neu abfragen
 client.println();
 // Ab hier berginnt der HTML-Code, der an den Browser geschickt wird
 client.println("<!DOCTYPE HTML>");
 client.println("<html>");
 client.print("PH:");  // Wert auf dem client ausgeben Browser
 client.print(phValue,2);
 client.println("
");  // Zweite Zeile 
 client.print("IP:  ");
 client.print(Ethernet.localIP()); // gibt die IP Adresse auf dem Webserver aus
 client.println("</b>
"); 
 client.println("</html>");
 break;
 }
 if (c == '\n') {
 // Zeilenwechsel, also currentLineIsBlack erstmal auf True setzen
 currentLineIsBlank = true;
 } 
 else if (c != '\r') {
 // Zeile enthält Zeichen, also currentLineIsBlack auf False setzen
 currentLineIsBlank = false;
 }
 }
 }
 // Kleine Pause
 delay(1);
 // Verbindung schliessen
 client.stop();
 Serial.println("Verbindung mit Client beendet.");
 Serial.println("");



}

Setze Deinen Code bitte direkt ins Forum. Benutze dazu Codetags (</>-Button oben links im Forumseditor oder [code] davor und [/code] dahinter ohne *).
Dann ist er auch auf mobilen Geräten besser lesbar.
Das kannst Du auch noch nachträglich ändern.

Gruß Tommy

erledigt mercy Tommy

Hallo,

ausreichend mit Spannung versorgen, kann ja auch mit 9V über die runde Buchse sein unde eventuell die interne Ref-Spannung verwenden. Wo hast Du den Sensor angeschlossen ?

am 5V pin des UNO ?

Heinz

jeap am 5 Volt Pin
wieviel Stromstärke kann ich hernehmen, hab mal gehört 1 Ampere ?

andal007:
jeap am 5 Volt Pin
wieviel Stromstärke kann ich hernehmen, hab mal gehört 1 Ampere ?

Mit Sicherheit nicht.

Und der genaue Wert hängt davon ab, wie du deinen Arduino versorgst.

ich hätte ein ein 7,5 Volt >Netzteil mit 500 mA hergenommen dann über den Ams und vielleicht mit einen Murata NME0505SC um sie stabil auf 5 Volt zu halten

Hallo,

ich hab was von 5V+-0,2V für den Sensor gefunden Strom 5-10mA, Damit sollte das kein Problem sein. Dein Netzteil an den runden Stecker des UNO Sensor am 5VPin des UNO.

Heinz

Dann beachte die max. Verlustleistung des OnBoard-Reglers, der ja die 2,5 Volt verbraten muss.
Nimm lieber ein gutes 5Volt Netzteil und betreibe alles aus diesen 5Volt.


Hey Jungs erst mal mercy, ich werde das testen und euch berichten und Fotos schicken. Morgen kommt mein Schwimmbad Thermometer laut DHL es ist ein Pearl PT-250 und das sendet zur Basis auf 433 Mhz. Ich hoffe ohne Manchester Verschlüsslung! Werde morgen mal versuchen es zu finden mit einem 433mhz Empfänger und zu decodieren.
Denke mal ich werde mich morgen wieder melden :slight_smile:

Hast du Elektrolyse und automatische ph-Pumpe im Einsatz?

die Elektrolyse übernimmt der Chlorinator von Intex noch und die PH Pumpe will ich dann über Fhem mit einer Dosierpumpe von Seko verwenden die max 1 Minute PH Minus einpumpt und dann irgendwie sichert das sie nicht weiter einpumpt( Dauerdosierung)
Hab mir aber dazu noch keine Gedanken gemacht. Denke aber an sowas wie Treppenlichtzeitschalter oder Relaiswischer.
Für die Solarsache habe ich mir Gedanken über 1wire Sensor am Dach Solareingang gemacht. Auch wenn der Wert bestimmt um bis zu 5 Grad schwankt ist es ja wurscht wenn der PT250 im Pool um soviel weniger anzeigt das die Solarpumpe anspricht.
Ich hab auch noch irgendwo eine 433 MHZ Steckdosen Fernbedienung die man bestimmt mit einem Sniffer auslesen kann und zum zusätzlichen manuellen Schalten per Fernbedienung nutzen kann. dazwischen ein paar Funksteckdosen und ich müßte mit ca 200 Euro hinkommen.
Ja und ich bin mir immer noch nicht sicher, wer die Steuerung übernimmt, ein Arduino oder ein Rasperry mit Fhem!
Aber bis dahin ist ein langer Weg und ich bin ja erst am Anfang.
Wer hätte gedacht das mich diese C Programmierung wieder einholen würde in der Corona Zeit :slight_smile:
Ps.: wer Rechtschreibfehler findet, darf sie behalten

Gestern kam das Pearl PT-250 Thermostat. Ich habe gleich einen 433 MHZ Empfänger an einem Uno angeschlossen. Data an D2 Gnd und 5V ausserdem hab ich am Antennenpin noch eine Messtrippe drangesteckt um den Empfang zu verbessern. Danach den Sketch für einem Sniffer eingespielt.Der Sketch ist aus dem Forum tatsächlich nach ein paar Umstellungen geschafft das Thermostat auszulesen
5 1001011000000000011001111000000 0 6 Sensor ID: 75 Kanal: 0 Temp: 207 Feuchte: 12 %
5 1001011000000000011010000000000 0 56 Sensor ID: 75 Kanal: 0 Temp: 208 Feuchte: 0 %
6 1001011000000000011010000000000 0 106 Sensor ID: 75 Kanal: 0 Temp: 208 Feuchte: 0 %
Hab natürlich gleich gebastelt um den Binärcode zu entziffern und habe festgestellt das wenn ich 20,7 Grad in Dezimal durchschreibe 207 in Binär 11001111 ist. Also hab ich das Thermometer in verschiedene Umgebungen gepackt und die stellen ändern sich passend. Somit hab ich die Temperatur, den Kanal habe ich auch mal geändert um die Kanalstellen auszumachen Kanal 1 ist 00 Kanal 2 ist 01 und Kanal 3 ist 10. Man muss eigentlich zm Kanal noch eins dazu addieren um den richtigen Kanal zu kriegen.
Hier mal der Sketch

// with Arduino UNO interrupt-0 belongs to pin-2, interrupt-1 to pin-3
#define RX433INTERRUPT 0

// Set speed of serial in Arduino IDE to the following value
#define SERIALSPEED 115200

// Now make some suggestions about pulse lengths that may be detected
// minimum duration (microseconds) of the start pulse
#define MINSTARTPULSE 4500

// minimum duration (microseconds) of a short bit pulse
#define MINBITPULSE 450

// minimum duration (microseconds) of a HIGH pulse between valid bits
#define MINHITIME 50

// variance between pulses that should have the same duration
#define PULSEVARIANCE 250

// minimum count of data bit pulses following the start pulse
#define MINPULSECOUNT 20

// maximum count of data bit pulses following the start pulse
#define MAXPULSECOUNT 50

// buffer sizes for buffering pulses in the interrupt handler
#define PBSIZE 216

void setup()
{
  
  Serial.begin(115200);
  Serial.println();
  Serial.println("Start!");
  pinMode(RX433DATAPIN, INPUT);
  attachInterrupt(RX433INTERRUPT, rx433Handler, CHANGE);
}

volatile unsigned int pulsbuf[PBSIZE]; // ring buffer storing LOW pulse lengths
volatile unsigned int hibuf[PBSIZE]; // ring buffer storing HIGH pulse lengths
unsigned int validpulsbuf[MAXPULSECOUNT]; // linear buffer storing valid LOW pulses
unsigned int validhibuf[MAXPULSECOUNT];  // linear buffer storing valid HIGH pulses

volatile byte pbread,pbwrite;  // read and write index into ring buffer

unsigned long Sequenz, LastSequenz;
unsigned int CRC, LastCRC;
unsigned int SequenzCounter;
unsigned long LastSequenzMillis;
void rx433Handler()
{
  static long rx433LineUp, rx433LineDown;
  long LowVal, HighVal;
  int rx433State = digitalRead(RX433DATAPIN); // current pin state
  if (rx433State) // pin is now HIGH
  {
    rx433LineUp=micros(); // line went HIGH after being LOW at this time
    LowVal=rx433LineUp - rx433LineDown; // calculate the LOW pulse time
    if (LowVal>MINBITPULSE)
    { // store pulse in ring buffer only if duration is longer than MINBITPULSE
      // To be able to store startpulses of more than Maxint duration, we dont't store the actual time,
     // but we store  MINSTARTPULSE+LowVal/10, be sure to calculate back showing the startpulse length!
      if (LowVal>MINSTARTPULSE) LowVal=MINSTARTPULSE+LowVal/10; // we will store this as unsigned int, so do range checking

      pulsbuf[pbwrite]=LowVal; // store the LOW pulse length
      pbwrite++;  // advance write pointer in ringbuffer
      if (pbwrite>=PBSIZE) pbwrite=0; // ring buffer is at its end
    }  
  }
  else 
  {
    rx433LineDown=micros(); // line went LOW after being HIGH
    HighVal=rx433LineDown - rx433LineUp; // calculate the HIGH pulse time
    if (HighVal>31999) HighVal=31999; // we will store this as unsigned int
    hibuf[pbwrite]=HighVal; // store the HIGH pulse length
  }
}


boolean counting;
byte i,counter;
int startBitDurationL,startBitDurationH,shortBitDuration,longBitDuration;
String aStr = "";

int BinStrToInt(String aStr);

void showBuffer()
// this function will show the results on the serial monitor
// output will be shown if more bits than MINPULSECOUNT have been collected
{
  long sum;
  int avg;
  
  sum=0;
  if (counter>=MINPULSECOUNT)
  { // only show buffer contents if it has enough bits in it
    /*
    Serial.println();
    Serial.print("Start Bit L: "); Serial.print((startBitDurationL-MINSTARTPULSE)*10L);
    Serial.print("   H: ");Serial.println(startBitDurationH);
    Serial.print("Data Bits: ");Serial.println(counter);
    Serial.print("L: ");*/
    for (i=0;i<counter;i++)
    {
      //Serial.print(validpulsbuf[i]);Serial.print(" ");
      sum+=validpulsbuf[i];
    }
    
     avg = sum / counter; // calculate the average pulse length
    // then assume that 0-bits are shorter than avg, 1-bits are longer than avg
    for (i=0;i<counter;i++)
    {
      if (validpulsbuf[i] < avg) {
        //        Serial.print('0');
        if (i > 1 && i < 34) {
          Sequenz <<= 1;                  // eine 0 von rechts rein
        }
        else if (i >= 34) {
          CRC <<= 1;                  // eine 0 von rechts rein
        }
      }
      else {
        //        Serial.print('1');
        if (i > 1 && i < 34) {
          Sequenz <<= 1;                  
          Sequenz |= 1;               // eine 1 von rechts rein
        }
        else if (i >= 34) {
          CRC <<= 1;                  
          CRC |= 1;               // eine 1 von rechts rein
        }
      }
    }
  }
  if (Sequenz != 0 ) {
    if (Sequenz == LastSequenz) {
      SequenzCounter++;
    }
    else SequenzCounter = 0;
    LastSequenz = Sequenz;
    LastCRC = CRC;
    Sequenz = 0;
    CRC = 0;
    LastSequenzMillis = millis();
  }
  counting = false;
  counter = 0;
}

void loop() 
{
  long lowtime, hitime;
  if (pbread!=pbwrite) // check for data in ring buffer
  {
    lowtime=pulsbuf[pbread]; // read data from ring buffer
    hitime=hibuf[pbread];
    cli(); // Interrupts off while changing the read pointer for the ringbuffer
    pbread++;
    if (pbread>=PBSIZE) pbread=0;
    sei(); // Interrupts on again
    if (lowtime>MINSTARTPULSE) // we found a valid startbit!
    {
      if (counting) showBuffer(); // new buffer starts while old is still counting, show it first      
      startBitDurationL=lowtime;
      startBitDurationH=hitime;
      counting=true;     // then start collecting bits
      counter=0;         // no data bits yet
    }
    else if (counting && (counter==0)) // we now see the first data bit
    { // this may be a 0-bit or a 1-bit, so make some assumption about max/min lengths of data bits that will follow
      shortBitDuration=lowtime/2;
      if (shortBitDuration<MINBITPULSE+PULSEVARIANCE)
        shortBitDuration=MINBITPULSE;
      else  
        shortBitDuration-=PULSEVARIANCE;
      longBitDuration=lowtime*2+PULSEVARIANCE;
      validpulsbuf[counter]=lowtime;
      validhibuf[counter]=hitime;
      counter++;
    }
    else if (counting&&(lowtime>shortBitDuration)&&(lowtime<longBitDuration))
    {
      validpulsbuf[counter]=lowtime;
      validhibuf[counter]=hitime;
      counter++;
      if ((counter==MAXPULSECOUNT) || (hitime<MINHITIME))
      {
        showBuffer();
      }  
    }
    else // Low Pulse is too short
    {
      if (counting) showBuffer();
      counting=false;
      counter=0;
      
    }  
  }
   if (millis() > LastSequenzMillis + 1000 && SequenzCounter > 3) {   // enought time since last conversion
    StoreMeas();
  }
}
void StoreMeas() {
  // start conversion
  Serial.print(SequenzCounter);
  Serial.print(" ");
  Serial.print(LastSequenz, BIN);
  Serial.print(" ");
  Serial.print(LastCRC, BIN);
  SequenzCounter = 0;
  Serial.print("\t");


   Serial.print(millis()/1000);
  Serial.print("\tSensor ID: ");
  int SensorID = LastSequenz >> 24;
  Serial.print(SensorID);
  int Kanal = (LastSequenz >> 18) & 0b11;
  Serial.print("\tKanal: ");
  Serial.print(Kanal, DEC);
  int Temp_i = (LastSequenz>>6) & 0b1111111111;
  Serial.print("\tTemp: ");
  Serial.print(Temp_i,  DEC);
  int hum= (LastSequenz>>4) & 0b1111 ;
  Serial.print("\tFeuchte: ");
  Serial.print(hum);
  Serial.println(" %");
}

Jetzt muss ich die Temp_i, DEC noch übertragen an meinen Arduino mit Netzwerkshield ?
Soll ich einen 433Mhz Sender nehmen und mit virtual wire senden oder mit boolean schicken, dann wären sie galvanisch getrennt wegen der PH Sonde. Beide Unos wären ja nur ein paar Zentimeter entfernt voneinander im gleichen Gehäuse.

Okay jetzt hab ich Display mit liquid noch eingebunden und mir die Daten übertragen aber ich kann am Ethernetshield nix empfangen. laut meiner Programmierung müsste ich doch auf 3100 Temp_i Empfangen
Sender ist am DPin 4

Hier mal der Sketch

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);

#define RX433DATAPIN 2
#define TX433DATAPIN 4

#define RX433INTERRUPT 0

// Set speed of serial in Arduino IDE to the following value
#define SERIALSPEED 115200

// Now make some suggestions about pulse lengths that may be detected
// minimum duration (microseconds) of the start pulse
#define MINSTARTPULSE 4500

// minimum duration (microseconds) of a short bit pulse
#define MINBITPULSE 450

// minimum duration (microseconds) of a HIGH pulse between valid bits
#define MINHITIME 50

// variance between pulses that should have the same duration
#define PULSEVARIANCE 250

// minimum count of data bit pulses following the start pulse
#define MINPULSECOUNT 20

// maximum count of data bit pulses following the start pulse
#define MAXPULSECOUNT 50

// buffer sizes for buffering pulses in the interrupt handler
#define PBSIZE 216

//----------------------TXstarten---------------------------
#ifdef ENABLE_TX433

#define TX_INTERVAL 3000
#define TX_INTERVAL_pearl 3100
#define TX_INTERVAL_solar 2900


unsigned long tx_millis=0;
#endif // ENABLE_TX433
void setup()
{
  
  Serial.begin(115200);
  lcd.begin ();
  lcd.clear ();
  Serial.println();
  Serial.println("Start!");
  pinMode(RX433DATAPIN, INPUT);
  pinMode(TX433DATAPIN, OUTPUT);
  attachInterrupt(RX433INTERRUPT, rx433Handler, CHANGE);
  //----------------------tx sender
   #ifdef ENABLE_TX433
  vw_set_ptt_inverted(true); // Required for RF Link module
  vw_setup(2000);            // Bits per sec
  vw_set_tx_pin(TX433_Pin);

  pinMode(13, OUTPUT);       // Internal LED will blink on transmit
  tx_millis=millis();
#endif // ENABLE_TX433 // put your setup code here, to run once:
}

volatile unsigned int pulsbuf[PBSIZE]; // ring buffer storing LOW pulse lengths
volatile unsigned int hibuf[PBSIZE]; // ring buffer storing HIGH pulse lengths
unsigned int validpulsbuf[MAXPULSECOUNT]; // linear buffer storing valid LOW pulses
unsigned int validhibuf[MAXPULSECOUNT];  // linear buffer storing valid HIGH pulses

volatile byte pbread,pbwrite;  // read and write index into ring buffer

unsigned long Sequenz, LastSequenz;
unsigned int CRC, LastCRC;
unsigned int SequenzCounter;
unsigned long LastSequenzMillis;
void rx433Handler()
{
  static long rx433LineUp, rx433LineDown;
  long LowVal, HighVal;
  int rx433State = digitalRead(RX433DATAPIN); // current pin state
  if (rx433State) // pin is now HIGH
  {
    rx433LineUp=micros(); // line went HIGH after being LOW at this time
    LowVal=rx433LineUp - rx433LineDown; // calculate the LOW pulse time
    if (LowVal>MINBITPULSE)
    { // store pulse in ring buffer only if duration is longer than MINBITPULSE
      // To be able to store startpulses of more than Maxint duration, we dont't store the actual time,
     // but we store  MINSTARTPULSE+LowVal/10, be sure to calculate back showing the startpulse length!
      if (LowVal>MINSTARTPULSE) LowVal=MINSTARTPULSE+LowVal/10; // we will store this as unsigned int, so do range checking

      pulsbuf[pbwrite]=LowVal; // store the LOW pulse length
      pbwrite++;  // advance write pointer in ringbuffer
      if (pbwrite>=PBSIZE) pbwrite=0; // ring buffer is at its end
    }  
  }
  else 
  {
    rx433LineDown=micros(); // line went LOW after being HIGH
    HighVal=rx433LineDown - rx433LineUp; // calculate the HIGH pulse time
    if (HighVal>31999) HighVal=31999; // we will store this as unsigned int
    hibuf[pbwrite]=HighVal; // store the HIGH pulse length
  }
}


boolean counting;
byte i,counter;
int startBitDurationL,startBitDurationH,shortBitDuration,longBitDuration;
String aStr = "";

int BinStrToInt(String aStr);

void showBuffer()
// this function will show the results on the serial monitor
// output will be shown if more bits than MINPULSECOUNT have been collected
{
  long sum;
  int avg;
  
  sum=0;
  if (counter>=MINPULSECOUNT)
  { // only show buffer contents if it has enough bits in it
    /*
    Serial.println();
    Serial.print("Start Bit L: "); Serial.print((startBitDurationL-MINSTARTPULSE)*10L);
    Serial.print("   H: ");Serial.println(startBitDurationH);
    Serial.print("Data Bits: ");Serial.println(counter);
    Serial.print("L: ");*/
    for (i=0;i<counter;i++)
    {
      //Serial.print(validpulsbuf[i]);Serial.print(" ");
      sum+=validpulsbuf[i];
    }
    
     avg = sum / counter; // calculate the average pulse length
    // then assume that 0-bits are shorter than avg, 1-bits are longer than avg
    for (i=0;i<counter;i++)
    {
      if (validpulsbuf[i] < avg) {
        //        Serial.print('0');
        if (i > 1 && i < 34) {
          Sequenz <<= 1;                  
        }
        else if (i >= 34) {
          CRC <<= 1;                  
        }
      }
      else {
        //        Serial.print('1');
        if (i > 1 && i < 34) {
          Sequenz <<= 1;                  
          Sequenz |= 1;              
        }
        else if (i >= 34) {
          CRC <<= 1;                  
          CRC |= 1;              
        }
      }
    }
  }
  if (Sequenz != 0 ) {
    if (Sequenz == LastSequenz) {
      SequenzCounter++;
    }
    else SequenzCounter = 0;
    LastSequenz = Sequenz;
    LastCRC = CRC;
    Sequenz = 0;
    CRC = 0;
    LastSequenzMillis = millis();
  }
  counting = false;
  counter = 0;
   
  
}

void loop() 
{
  // put your main code here, to run repeatedly:
#if defined(ENABLE_TX433) && defined(ENABLE_pearl)
  if (millis()-tx_millis>TX_INTERVAL_PH)
  { tx_millis=millis();
    send_tx433();
}
#endif // ENABLE_TX433 && ENABLE_ORP/PH



  long lowtime, hitime;
  if (pbread!=pbwrite) // check for data in ring buffer
  {
    lowtime=pulsbuf[pbread]; // read data from ring buffer
    hitime=hibuf[pbread];
    cli(); // Interrupts off while changing the read pointer for the ringbuffer
    pbread++;
    if (pbread>=PBSIZE) pbread=0;
    sei(); // Interrupts on again
    if (lowtime>MINSTARTPULSE) // we found a valid startbit!
    {
      if (counting) showBuffer(); // new buffer starts while old is still counting, show it first      
      startBitDurationL=lowtime;
      startBitDurationH=hitime;
      counting=true;     // then start collecting bits
      counter=0;         // no data bits yet
    }
    else if (counting && (counter==0)) // we now see the first data bit
    { // this may be a 0-bit or a 1-bit, so make some assumption about max/min lengths of data bits that will follow
      shortBitDuration=lowtime/2;
      if (shortBitDuration<MINBITPULSE+PULSEVARIANCE)
        shortBitDuration=MINBITPULSE;
      else  
        shortBitDuration-=PULSEVARIANCE;
      longBitDuration=lowtime*2+PULSEVARIANCE;
      validpulsbuf[counter]=lowtime;
      validhibuf[counter]=hitime;
      counter++;
    }
    else if (counting&&(lowtime>shortBitDuration)&&(lowtime<longBitDuration))
    {
      validpulsbuf[counter]=lowtime;
      validhibuf[counter]=hitime;
      counter++;
      if ((counter==MAXPULSECOUNT) || (hitime<MINHITIME))
      {
        showBuffer();
      }  
    }
    else // Low Pulse is too short
    {
      if (counting) showBuffer();
      counting=false;
      counter=0;
      
    }  
  }
   if (millis() > LastSequenzMillis + 1000 && SequenzCounter > 3) {   // enought time since last conversion
    StoreMeas();
  }
}
void StoreMeas() {
  // start conversion
  Serial.print(SequenzCounter);
  Serial.print(" ");
  Serial.print(LastSequenz, BIN);
  Serial.print(" ");
  Serial.print(LastCRC, BIN);
  SequenzCounter = 0;
  Serial.print("\t");

 
   Serial.print(millis()/1000);
  Serial.print("\tSensor ID: ");
  int SensorID = LastSequenz >> 24;
  Serial.print(SensorID);
  int Kanal = (LastSequenz >> 18) & 0b11;
  int Kanal_d = (Kanal + 1);
  Serial.print("\tKanal: ");
  Serial.print(Kanal_d, DEC);

  int Temp_i = (LastSequenz>>6) & 0b1111111111;
  
  Serial.print("\tTemp: ");
  Serial.print(Temp_i);
  
  lcd.setCursor(1,0);
  lcd.print("Temperatur ");
  lcd.print(Temp_i, DEC);
  lcd.setCursor(1,1),
  lcd.print("Kanal "),
  lcd.print(Kanal_d, DEC);
  delay ,700;
  
   #if defined(ENABLE_pearl) || defined(ENABLE_RX433)
  Serial.print(Temp_i,  DEC);
   #endif // ENABLE_pearl || ENABLE_RX433
    int hum= (LastSequenz>>4) & 0b1111 ;
  Serial.print("\tFeuchte: ");
  Serial.print(hum);
  Serial.println(" %");
 
  #ifdef ENABLE_pearl
  vw_send((uint8_t *) &Temp_i, sizeof(Temp_i));
  #endif // ENABLE_pearl
    
}

Hi

Ich sehe nicht, daß Du die 3100 oder den dafür definierten Namen benutzt.
Auch sind mir die Komma (z.B. vor delay , 700;) nicht gängig.

Musste lcd.begin(); auskommentieren, da meine LCD-Lib wohl eine andere Version hat - danach hat's, zu meiner Verwunderung, kompiliert - mit Warnungen (haufenweise unbenutzte Parameter in Methoden der LCD-Lib).

MfG

delay ,700 oder delay(700); ist das gleiche
ich nutze die Master liquid chrystel i2cLibary
und das sind die Keywords
###########################################

Syntax Coloring Map For LiquidCrystal_I2C

###########################################

###########################################

Datatypes (KEYWORD1)

###########################################

LiquidCrystal_I2C KEYWORD1

###########################################

Methods and Functions (KEYWORD2)

###########################################
init KEYWORD2
begin KEYWORD2
clear KEYWORD2
home KEYWORD2
noDisplay KEYWORD2
display KEYWORD2
noBlink KEYWORD2
blink KEYWORD2
noCursor KEYWORD2
cursor KEYWORD2
scrollDisplayLeft KEYWORD2
scrollDisplayRight KEYWORD2
leftToRight KEYWORD2
rightToLeft KEYWORD2
shiftIncrement KEYWORD2
shiftDecrement KEYWORD2
noBacklight KEYWORD2
backlight KEYWORD2
autoscroll KEYWORD2
noAutoscroll KEYWORD2
createChar KEYWORD2
setCursor KEYWORD2
print KEYWORD2
blink_on KEYWORD2
blink_off KEYWORD2
cursor_on KEYWORD2
cursor_off KEYWORD2
setBacklight KEYWORD2
load_custom_character KEYWORD2
printstr KEYWORD2

ich musste ein paar Zeilen löschen für die Anzeige im Forum. Ich schicke den mal per ino. hum gehört noch raus ist von der 433 mhz Wetterstation übernommen

Erfolg_Poolthermometermitsenderund_lcd16display.ino (9.16 KB)

Hi

Auch darin findet gedit (Editor, Linux) weder die 3100 noch TX_INTERVAL_pearl, außer in Zeile 46.
Somit bleibe ich dabei: Du musst Das schon benutzen, wenn Du Das benutzen willst.
(keine Kompilation versucht)

MfG

andal007:
delay ,700 oder delay(700); ist das gleiche

Das würde ich bezweifeln.

Gruß Tommy

Mein Gott bin ich ein Trottel, ab und zu sieht man den Wald vor lauter Bäume nicht. Da kann mein Empfänger bis zum Sankt nimmerleins Tag warten bis der was empfängt.

@ Tommy56 ich dachte delay, 700 kann von einem Befehl gefolgt werden den er für diese Zeit ausführt und dann weiter geht und delay(700) ist eine Wartezeit. Aber meine C Tage sind schon lange her und ich muss mir die Befehlsausführung ab und zu googlen weil ich sie nicht zu schreiben weiss :frowning:

Nix für ungut ich komme aus Bayern :slight_smile:

andal007:
Nix für ungut ich komme aus Bayern :slight_smile:

Da kann ich ja froh sein, aus Franken zu kommen :wink:

Gruß Tommy