Umweltsensor Arduino meets 1-Wire

Einklappen
X
 
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge
  • Gast

    Umweltsensor Arduino meets 1-Wire

    Hallo,

    Ich möcht vorab mein kleines Prjoekt vorstellen.

    Es handelt sich um einen Umweltsensor wo man über einen Arduino Pro Mini oder einen Arduino Nano Werte von digitalen oder analogen Sensoren erfassen kann, und sie über den 1-wire Bus ( DS18B20 Emulator ) an die 1-WireExtension (nicht getestet ) oder an einen Arduino UNO mit Ethernetshield und dann per UDP an den MiniServer weiterleitet.

    Der Arduino Pro Mini kann bis zu 5 DS18B20 Temperautrsensoren emulieren - GETESTET
    mehr als 5 wurden bei mir nicht alles Werte übertragen.

    Dabei fragt der Arduino Mini einen DHT22 für Feuchte und Temperatur ab, und einen Ambient Light Sensor kurz ALS an einem analogen Eingang ab und sendet die Daten ( Feuchte, Temperatur, Umgebungslicht) jeweils als einen DS18B20 mit eigener Adresse auf den 1-Wire BUS

    Natürlich kann man auch wie gewohnt andere 1-Wire Chips mit auf den Bus legen, getestet mit weiteren DS18B20, DS2450, DS2438.

    Ich denke gerad darüber nach eine passende Platine die man in eine Hohlwanddose setzen kann nach. Das ganze soll als Eingangsspannung mit 24V betrieben werden. Grund dafür, es soll genug Power für alles Sensoren + einen VOC Sensor der etwas Strom zieht, liefern.

    Jetzt noch den viel diskutierten billige Bewegungsmelder aus China dazuknüpfen und schon hat man die Eierlegendevollmilchsau für ein paar Euro.


    Hier schon mal den Code für den Arduino Pro Mini



    Code:
    /*
          Example-Code that emulates a DS18B20
    
          Tested with:
          - https://github.com/PaulStoffregen/OneWire --> DS18x20-Example, atmega328@16MHz as Slave
          - DS9490R-Master, atmega328@16MHz as Slave
    */
    
    #include "OneWireHub.h"
    #include "DS18B20.h"  // Digital Thermometer, 12bit
    #include <dht.h>
    
    dht DHT;
    #define DHT22_PIN 6
    
    int sensorPin = A0;
    float sensorValue = 0;
    
    const uint8_t led_PIN       = 13;         // the number of the LED pin
    const uint8_t OneWire_PIN   = 8;
    
    auto hub     = OneWireHub(OneWire_PIN);
    auto sensorA = DS18B20(0x28, 0x0D, 0x01, 0x00, 0x00, 0x00, 0x01);    // Digital Thermometer
    auto sensorB = DS18B20(0x28, 0x0D, 0x01, 0x00, 0x00, 0x00, 0x02);    // Digital Thermometer
    auto sensorC = DS18B20(0x28, 0x0D, 0x01, 0x00, 0x00, 0x00, 0x03);    // Digital Thermometer
    //auto sensorD = DS18B20(0x28, 0x0D, 0x01, 0x00, 0x00, 0x00, 0x04);    // Digital Thermometer
    //auto sensorE = DS18B20(0x28, 0x0D, 0x01, 0x00, 0x00, 0x00, 0x05);    // Digital Thermometer
    
    float DHT_temp = 0;
    float DHT_humid = 0;
    
    bool blinking()
    {
      const  uint32_t interval    = 500;          // interval at which to blink (milliseconds)
      static uint32_t nextMillis  = millis();     // will store next time LED will updated
    
      if (millis() > nextMillis)
      {
        nextMillis += interval;             // save the next time you blinked the LED
        static uint8_t ledState = LOW;      // ledState used to set the LED
        if (ledState == LOW)    ledState = HIGH;
        else                    ledState = LOW;
        digitalWrite(led_PIN, ledState);
        return 1;
      }
      return 0;
    }
    
    
    void setup()
    {
      Serial.begin(9600
    
                  );
      Serial.println("OneWire-Hub DS18B20 Temperature-Sensor");
    
      pinMode(led_PIN, OUTPUT);
    
      // Setup OneWire
      hub.attach(sensorA);
      hub.attach(sensorB);
      hub.attach(sensorC);
      //hub.attach(sensorD);
      //hub.attach(sensorE);
    
      // Set const temperature
      Serial.println("config done");
    }
    
    void loop()
    {
      //read analaginpur
    
    
    
      // following function must be called periodically
      hub.poll();
      // this part is just for debugging (USE_SERIAL_DEBUG in OneWire.h must be enabled for output)
      if (hub.getError()) hub.printError();
    
      // Blink triggers the state-change
      do_dht();
      if (blinking())
      {
        /*
          // Set temp
          static float temperature = 20.0;
          temperature += 0.1;
          if (temperature > 30.0) temperature = 20.0;
          sensorA.setTemp(temperature);
        */
        sensorValue = analogRead(sensorPin) / 10.0;
        sensorA.setTemp(sensorValue);
      }
    }
    
    void do_dht()
    {
      const  uint32_t interval    = 1000;          // interval at which to blink (milliseconds)
      static uint32_t nextMillis  = millis();     // will store next time LED will updated
    
      if (millis() > nextMillis)
      {
        nextMillis += interval;             // save the next time you blinked the LED
        int chk = DHT.read22(DHT22_PIN);
        switch (chk)
        {
          case DHTLIB_OK:
            Serial.print("OK,\t");
            DHT_temp = (DHT.temperature);
            DHT_humid = (DHT.humidity);
            sensorB.setTemp(DHT_temp);
            sensorC.setTemp(DHT_humid);
            break;
          case DHTLIB_ERROR_CHECKSUM:
            Serial.print("Checksum error,\t");
            break;
          case DHTLIB_ERROR_TIMEOUT:
            Serial.print("Time out error,\t");
            break;
          default:
            Serial.print("Unknown error,\t");
            break;
        }
        Serial.print("Temperatur: ");
        Serial.print(DHT_temp);
        Serial.print(",\t");
        Serial.print("Feuchte: ");
        Serial.print(DHT_humid);
        Serial.print(",\t");
        Serial.print("Helligkeit: ");
        Serial.print(sensorValue);
        Serial.println(",\t");
    
        //sensorD.setTemp(40);
        //sensorE.setTemp(40);
     
    
      }
    }


  • Benjamin Jobst
    Lox Guru
    • 25.08.2015
    • 1194

    #2
    Hi Bender,

    das finde ich klasse! Hut ab für die Bastelarbeit ;-)

    Ich hatte selber auch über die ein oder andere Arduino-Lösung nachgedacht, mein Ansatz war der neue MKR1000. Da der integriertes WLAN hat könnte man den Arduino quasi als standalone über Modbus/TCP an Loxone anbinden, ohne den Umweg über 1-Wire. Dafür kann man den MKR1000 als 1-Wire-Master verwenden, um eine Handvoll DS18B20 abzufragen, quasi als 1-Wire Extension Air =)
    MfG Benny

    Kommentar

    • Gast

      #3
      Den MKR1000 kannte ich bis jetzt noch nicht, der ist schneller als der Arudino Pro Mini aber um ein vielfaches teurer und die ARM Cortex Chips vertragen keine 5V sondern nur 3.3V. Da muß man einen 5V <-> 3.3V dazwischen basteln was wieder Platz weg nimmt sonst rauch der ab.
      Gleiche Idee über Wi-Fi hatte ich auch nur mit einem EPS8266 Modul, leider habe ich den bei der Config abgeraucht da die TTL Komunikation mit 5V stattgefunden hat, anstatt mit 3.3V. (aus Fehlern wird man klug Er bietet nicht die gleiche Leistung wie der MKR1000 ist aber viel günstiger

      Kommentar


      • Benjamin Jobst
        Benjamin Jobst kommentierte
        Kommentar bearbeiten
        Das schöne am MKR1000 ist, dass der eben WLAN gleich onboard hat und du nicht wieder mit Basteln anfangen musst.
        Dein Problem mit den 5V und 3.3V verstehe ich nicht ganz, woher bekommst du die 5V? Bei meinem Plan hatte ich die 1-Wire-Sensoren direkt an den 3.3V angeschlossen, die kommen laut Datenblatt auch damit noch zurecht.

      • Gast
        Gast kommentierte
        Kommentar bearbeiten
        Ich habe bei 1-Wire bis jetzt immer nur VCC=5V gelesen, ich wuste nicht das die Dinger so tolerant sind was die Versorgungsspannung betrift
    • mapchen
      Smart Home'r
      • 07.09.2015
      • 87

      #4
      Würd den nehmen.



      Gesendet von iPhone mit Tapatalk

      Kommentar

      • eisenkarl
        Lox Guru
        • 28.08.2015
        • 1349

        #5
        Also für den EPS8266 würde ich das sofort nehmen! Habe das ganze mal zusammengesteckt und easyesp installiert, bekomme die Werte nur leider nicht in den Miniserver...

        Kommentar

        • mapchen
          Smart Home'r
          • 07.09.2015
          • 87

          #6
          bin mir nicht sicher wie weit du in der Programmierung der Dinger bist:

          Dieses Beispiel kann:
          - Schalten von GPIOs durch Miniserver mit Rückbestätigung zum Miniserver
          - Analoge/Digitale Werte an den Miniserver senden
          - Auslesen von Wunderground und senden von UDP Messages an Miniserver
          - OTA -> über Wifi den Wemos Updaten

          Bin nicht gut im Dokumentieren aber eventuell hilft dir das ein Bisschen weiter.

          Als Screenshot auch die Logik im Miniserver für die Bestätigungsroutine


          #include <SPI.h> // needed for Arduino versions later than 0018
          //#include "DHT.h"
          //#include <SFE_BMP180.h>
          #include <Wire.h>
          #include <ESP8266WiFi.h>
          #include <WiFiUDP.h>
          #include <OneWire.h>
          #include <DallasTemperature.h>
          #include <ArduinoOTA.h>
          #include <pins_arduino.h>
          #include <TextFinder.h>

          const int Din=D7;
          const int Dout=D5;


          /************************************************** ***********************
          * Default Parameter for Device
          ************************************************** **********************/
          const char* versionID = "WeMos OTA Garage/Helligkeit";
          const char* typeID = "WeMos D1 mini";
          const char* deviceID = "ESP009";


          #define BH1750_ADDRESS 0x23

          int status = WL_IDLE_STATUS;
          const char* ssid = "........................."; // your network SSID (name)
          const char* pass = "........................."; // your network password

          boolean blnSicherheitRein=0;
          /* --------------------- One Wire Sensor-------------------------*/


          /*#define ONE_WIRE_BUS
          OneWire oneWire(ONE_WIRE_BUS);
          DallasTemperature sensors(&oneWire);

          DeviceAddress knopf = {0x28, 0x6A, 0x46, 0xAF, 0x05, 0x00, 0x00, 0x61}; //knopf
          */
          /* --------------------- One Wire Sensor-------------------------*/


          //byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xFF};
          //IPAddress ip(192, 168, 0, 179);
          IPAddress ipremote(192, 168, 0, 100);
          char packetBuffer[15];
          unsigned int localPort = 8888; // local port to listen on

          String StrArduino = "05";
          const int intNumberPins = 65;
          unsigned long pinStatus[intNumberPins];
          unsigned long pinStatusAckn[intNumberPins];
          unsigned long resendValue = 999999;
          //unsigned int pinSensitivity[intNumberPins];



          //int pinTypeIO[60]; //I ->1 = I / O=0
          int pinType[intNumberPins]; // D=1 / A=2 / R=3 / Relay Active Low =4 / 5 = Input Pin / 6 = Input Register
          String pinTypeAD[intNumberPins];
          //int pinInitState[60]; //Low = 0 / High = 1
          String packetBufferStr;
          long previousMillisResend1000 = 0;
          long previousMillisResend3600000 = 0;
          long previousMillisResenDout0000 = 0;
          long previousMillisResenDout00000 = 0;


          WiFiUDP Udp; // An EthernetUDP instance to let us send and receive packets over UDP

          byte WUserver[] = {
          209,85,229,104 }; // Google

          WiFiClient client;
          TextFinder finder( client );


          void setup() {


          pinMode(Din, OUTPUT);
          digitalWrite(Din, HIGH) ;

          pinMode(Dout, OUTPUT);
          digitalWrite(Dout, HIGH) ;

          pinMode(D8, OUTPUT);
          //digitalWrite(D8, LOW) ;

          pinMode(D3, OUTPUT);
          //digitalWrite(D1, LOW) ;

          pinMode(D4, OUTPUT);
          //digitalWrite(D2, LOW) ;

          pinMode(D6, OUTPUT);
          digitalWrite(D6, HIGH) ; // Relais RGB


          initUDPPin(55, 3); //R
          initUDPPin(56, 3); //G
          initUDPPin(57, 3); // B


          initUDPPin(62, 6); //KNOPF

          initUDPPin(30, 3);
          initUDPPin(31, 3);
          /*
          initUDPPin(34, 4);
          initUDPPin(36, 4);
          initUDPPin(38, 4);
          initUDPPin(40, 4);
          initUDPPin(42, 4);
          initUDPPin(44, 4);
          initUDPPin(46, 4);
          initUDPPin(48, 4);

          initUDPPin(55, 3);I2ci
          initUDPPin(59, 6); //Luft Werkstatt
          initUDPPin(60, 6); // Wassermelder
          initUDPPin(61, 6); //PH
          //initUDPPin(63, 6); // Terrasse KG

          */


          Serial.begin(115200);
          Wire.begin(D2, D1);

          printWifiStatus();

          Serial.println("Connected to wifi");
          Serial.print("Udp server started at port ");
          Serial.println(localPort);
          Udp.begin(localPort);

          /************************************************** ***********************
          OTA-Routine
          ************************************************** **********************/
          //ArduinoOTA.setPassword((const char *)"mapchen");
          ArduinoOTA.onStart([]() {
          Serial.println("Start");
          });
          ArduinoOTA.onEnd([]() {
          Serial.println("\nEnd");
          });
          ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
          Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
          });
          ArduinoOTA.onError([](ota_error_t error) {
          Serial.printf("Error[%u]: ", error);
          if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
          else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
          else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
          else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
          else if (error == OTA_END_ERROR) Serial.println("End Failed");
          });
          ArduinoOTA.begin();
          Serial.println("Ready");
          Serial.print("IP address: ");
          Serial.println(WiFi.localIP());


          for (int i = 0; i < intNumberPins ; i++) {
          if (pinType[i] > 0)
          {
          pinStatus[i] = resendValue;
          }
          }

          /*------------------ONE WIRE--------------------------------------*/
          //sensors.begin();
          //sensors.setResolution(knopf, 12);

          // sensors8.setResolution(TempTerrasseKG, 12);
          //sensors8.setResolution(LuftWerkstatt, 12);

          /*------------------ONE WIRE--------------------------------------*/



          }

          unsigned int readTemperatureCelsius(DeviceAddress deviceAddress, DallasTemperature sensor) {
          //char charmessage[8];
          char text[13];
          sensor.requestTemperatures();
          float tempC = sensor.getTempC(deviceAddress);
          tempC = (tempC + 100) * 100;
          Serial.println(tempC);
          return tempC;
          //Serial.print(charmessage);
          // client.print(charmessage);
          }

          void readUDP()
          {
          int packetSize = Udp.parsePacket();
          if (packetSize)
          {
          memset(packetBuffer, 0, sizeof(packetBuffer));
          IPAddress remote = Udp.remoteIP();
          Udp.read(packetBuffer, packetSize);
          packetBufferStr = String(packetBuffer);
          }
          };

          unsigned int BH1750()
          {
          Wire.beginTransmission(BH1750_ADDRESS);
          Wire.write(0x10); // 1 lx resolution
          Wire.requestFrom(BH1750_ADDRESS, 2);
          uint16_t Intensity_value;
          Intensity_value = Wire.read();
          Intensity_value <<= 8;
          Intensity_value |= Wire.read();
          Wire.endTransmission();
          Intensity_value = Intensity_value / 1.2;
          Serial.println(Intensity_value);
          return Intensity_value;
          }

          void loop() {
          ArduinoOTA.handle();
          /*----------------- Network -------------------------------*/
          packetBufferStr = "";
          readUDP();
          if (packetBufferStr != "")
          {
          Serial.println("IN: " + packetBufferStr);

          String cmdType = packetBufferStr.substring(0, 1);
          if (cmdType == "D")
          {
          String CommandoStr = packetBufferStr.substring(9, 15);
          int CommandoInt = CommandoStr.toInt();
          if (CommandoInt < resendValue)
          {
          String pinStr = packetBufferStr.substring(6, 9);
          int pinInt = pinStr.toInt();
          pinStatus[pinInt] = CommandoInt;
          pinStatusAckn[pinInt] = CommandoInt;
          if (CommandoInt == 0)
          {
          digitalWrite(pinInt, HIGH) ;
          sendUDPmessage(packetBufferStr);
          }
          else if (CommandoInt == 1)
          {
          digitalWrite(pinInt, LOW) ;
          sendUDPmessage(packetBufferStr);
          }
          }
          }


          else if (cmdType == "R")
          {
          String CommandoStr = packetBufferStr.substring(9, 15);
          int CommandoInt = CommandoStr.toInt();
          if (CommandoInt < resendValue)
          {
          String pinStr = packetBufferStr.substring(6, 9);
          int pinInt = pinStr.toInt();
          pinStatus[pinInt] = CommandoInt;
          pinStatusAckn[pinInt] = CommandoInt;
          //analogWrite(pinInt, CommandoInt) ;
          sendUDPmessage(packetBuffer);
          }
          }
          else if (cmdType == "A")
          {
          String CommandoStr = packetBufferStr.substring(9, 15);
          int CommandoInt = CommandoStr.toInt();
          if (CommandoInt < resendValue)
          {
          String pinStr = packetBufferStr.substring(6, 9);
          int pinInt = pinStr.toInt();
          pinStatus[pinInt] = CommandoInt;
          pinStatusAckn[pinInt] = CommandoInt;
          analogWrite(pinInt, CommandoInt) ;
          sendUDPmessage(packetBuffer);
          }
          }
          else if (cmdType == "I")
          {
          String CommandoStr = packetBufferStr.substring(9, 15);
          //Serial.println("Command: " + CommandoStr);
          int CommandoInt = CommandoStr.toInt();
          if (CommandoInt < resendValue)
          {
          String pinStr = packetBufferStr.substring(6, 9);
          int pinInt = pinStr.toInt();
          pinStatusAckn[pinInt] = CommandoInt;

          }
          }
          }

          /*----------------- Network -------------------------------*/


          unsigned long currentMillis = millis();
          if ((unsigned long)(currentMillis - previousMillisResend1000) >= 1000)
          {
          previousMillisResend1000 = currentMillis;

          /* PIN State Change Watchdog */
          // pinchangestate(8);
          /* PIN State Change Watchdog */

          Serial.println("Alive");
          printWifiStatus();


          }

          if ((unsigned long)(currentMillis - previousMillisResenDout0000) >= 30000 || previousMillisResenDout0000 == 0) //30 Sekunden
          {
          previousMillisResenDout0000 = currentMillis;

          /* pinStatus[60]=analogRead(2); //Wassermelder
          pinchangestate(60);



          pinchangestate(3);

          */

          reacknowledge();


          }



          if ((unsigned long)(currentMillis - previousMillisResenDout00000) >= 300000 || previousMillisResenDout00000 == 0 ) // 5 Minuten
          {
          previousMillisResenDout00000 = currentMillis;



          pinStatus[62]= BH1750(); //Ds18b20 Temperatur
          //Serial.println(pinStatus[62]);
          pinStatusAckn[62]=1000000;
          pinchangestate(62);




          /*

          pinStatus[59]= readTemperatureCelsius(LuftWerkstatt, sensors8); //Ds18b20 Temperatur
          pinchangestate(59);

          */

          }

          if ((unsigned long)(currentMillis - previousMillisResend3600000) >= 3600000 || previousMillisResend3600000 == 0 ) // 60 Minuten
          {
          previousMillisResend3600000 = currentMillis;

          sendGETWeather(); // call sendGET function


          }

          /*----------------- Loop Map -------------------------------*/
          if (WiFi.status() == 3)
          {
          if (pinStatus[30] == 1 && pinStatus[31] == 0) //IN
          {
          if (pinStatusAckn[30] == 0) // Sicherheitsschaltung
          {
          digitalWrite(Din, HIGH);
          delay(500);
          pinStatusAckn[30] = pinStatus[30];
          }
          digitalWrite(Dout, HIGH) ;
          digitalWrite(Din, LOW) ;
          }

          else if (pinStatus[31] == 1 && pinStatus[30] == 0) //Raus
          {
          if (pinStatusAckn[31] == 0) // Sicherheitsschaltung
          {
          digitalWrite(Din, HIGH);
          delay(500);
          pinStatusAckn[31] = pinStatus[31];
          }
          digitalWrite(Dout, LOW) ;
          digitalWrite(Din, LOW) ;
          }
          else if (pinStatus[31] == 0 && pinStatus[30] == 0) //Raus
          {
          digitalWrite(Dout, HIGH) ;
          digitalWrite(Din, HIGH) ;
          }
          }
          else
          {
          if (blnSicherheitRein==0)
          {
          blnSicherheitRein=1;
          //delay(5000);
          if (digitalRead(Din) == 0 || digitalRead(Dout) == 0) // Sicherheitsschaltung
          {
          digitalWrite(Din, HIGH);
          delay(500);
          }
          digitalWrite(Din, LOW) ;
          digitalWrite(Dout, HIGH) ;
          delay(50000);
          digitalWrite(Din, HIGH) ;
          digitalWrite(Dout, HIGH) ;

          }
          }


          if (pinStatusAckn[55]!=0 || pinStatusAckn[56]!=0 || pinStatusAckn[57]!=0)
          {
          digitalWrite(D6, LOW) ; // Relais RGB
          analogWrite(D8, map(pinStatusAckn[55], 0, 100, 0, 1023));
          analogWrite(D3, map(pinStatusAckn[56], 0, 100, 0, 1023));
          analogWrite(D4, map(pinStatusAckn[57], 0, 100, 0, 1023));

          }
          else
          {
          digitalWrite(D6, HIGH) ; // Relais RGB
          analogWrite(D8, 0); //blau
          analogWrite(D3, 0); //grün
          analogWrite(D4, 0); //weiss
          }




          /*----------------- Loop Map -------------------------------*/

          }



          void reacknowledge()
          {
          for (int i = 0; i < intNumberPins ; i++)
          {
          if (pinType[i] > 0 && pinType[i] < 5)
          {
          if (pinStatus[i] != pinStatusAckn[i])
          {
          String strstatePin;
          if (i < 10) {
          strstatePin = "0" + String(i);
          }
          else {
          strstatePin = String(i);
          }

          Serial.println("Status : " + String(pinStatus[i]));
          Serial.println("StatusAckn : " + String(pinStatusAckn[i]));
          Serial.println("Statustype : " + String(pinType[i]));
          sendUDPmessage(pinTypeAD[i] + StrArduino + "PIN0" + strstatePin + pinStatus[i]); //I01PIN0082000
          }
          }
          }

          }

          void pinchangestate(int intPin)
          {
          String strstatechangemessage;
          char chrstatechangemessage[11];
          String strstatePin;

          if (pinType[intPin] == 5)
          {
          pinStatus[intPin] = digitalRead(intPin);
          }
          else if (pinType[intPin] == 7)
          {
          pinStatus[intPin] = analogRead(intPin);
          Serial.println("Analog Pin:" + pinStatus[intPin]);
          }
          /*float locSensitivity=(((pinStatus[intPin]-pinStatusAckn[intPin])/pinStatusAckn[intPin]));
          Serial.println(pinStatus[intPin]);
          Serial.println(pinStatusAckn[intPin]);
          Serial.println(locSensitivity);
          */
          if (pinStatus[intPin] != pinStatusAckn[intPin]) //wenn status anders wie Pin Status oder wenn Acknowledgement nicht da
          {
          if (intPin < 10) {
          strstatePin = "0" + String(intPin);
          } else {
          strstatePin = String(intPin);
          }

          strstatechangemessage = "I" + StrArduino + "PIN0" + strstatePin + pinStatus[intPin]; //I01PIN024255
          strstatechangemessage.toCharArray(chrstatechangeme ssage, 11);
          sendUDPmessage(strstatechangemessage);
          //Serial.println(strstatechangemessage);
          //pinStatus[intPin] = pinstate;
          };
          }

          void sendUDPmessage(String udpmessage)
          {
          char chrudpmessage[15];
          udpmessage.toCharArray(chrudpmessage, 15);
          Udp.beginPacket(ipremote, 9999);
          Udp.write(chrudpmessage);
          Serial.println(chrudpmessage);
          Udp.endPacket();
          };

          void initUDPPin(int pinInt, int locpinType)
          {
          pinType[pinInt] = locpinType;

          if (locpinType == 4) // Active Low
          {
          pinTypeAD[pinInt] = "D";
          pinMode(pinInt, OUTPUT);
          digitalWrite(pinInt, HIGH) ;
          }
          else if (locpinType == 1) //Digital Pin
          {
          pinTypeAD[pinInt] = "D";
          pinMode(pinInt, OUTPUT);
          digitalWrite(pinInt, LOW) ;
          }
          else if (locpinType == 2) //Analog Pin
          {
          pinTypeAD[pinInt] = "A";
          pinMode(pinInt, OUTPUT);
          }

          else if (locpinType == 5) // Input
          {
          pinTypeAD[pinInt] = "I";
          pinMode(pinInt, INPUT);
          }
          else if (locpinType == 7) // Input analog
          {
          pinTypeAD[pinInt] = "I";
          pinMode(pinInt, INPUT);

          }
          else if (locpinType == 3) //Register
          {
          pinTypeAD[pinInt] = "R";
          }
          else if (locpinType == 6) // Input Register
          {
          pinTypeAD[pinInt] = "I";
          //pinSensitivity[pinInt]=locSensitivity;
          }
          ;
          };

          void printWifiStatus() {

          if (WiFi.status() != 3) {
          // Wait for connect to AP
          Serial.print("[Connecting]");
          Serial.print(ssid);
          Serial.print("Wifistatus: ");
          Serial.println(WiFi.status());
          int tries = 0;

          WiFi.begin(ssid, pass);
          delay(5000);
          Serial.print(".");


          Serial.println();
          if (WiFi.status() == 3) {

          blnSicherheitRein=0;

          }

          // print the SSID of the network you're attached to:
          Serial.print("SSID: ");
          Serial.println(WiFi.SSID());

          // print your WiFi shield's IP address:
          IPAddress ip = WiFi.localIP();
          Serial.print("IP Address: ");
          Serial.println(ip);
          }
          }

          void sendGETWeather() //client function to send/receie GET request data.
          {
          char text[8];
          if (client.connect("api.wunderground.com", 80)) {
          Serial.println("connected");
          client.println("GET http://api.wunderground.com/api/...................json HTTP/1.0");
          client.println();
          }
          else {
          Serial.println("connection failed");
          Serial.println();
          }

          delay(3000); //waits for data

          if (client.connected() || client.available()) { //connected or data available

          finder.find("simpleforecast"); // skip past this
          finder.find("period"); // skip past this

          finder.find("pop"); // skip past this
          long value = finder.getValue(); // get numeric value
          Serial.print(value);
          Serial.println(" % POP");
          //value=(value + 100) * 100;
          dtostrf(value, 5, 0, text);
          sendUDPmessage("I"+ StrArduino + "PIN072"+text);

          finder.find("mm"); // skip past this
          value = finder.getValue(); // get numeric value
          Serial.print(value);
          Serial.println(" mm QPF");
          //value=(value + 100) * 100;
          dtostrf(value, 5, 0, text);
          sendUDPmessage("I"+ StrArduino + "PIN073"+text);
          finder.find("pop"); // skip past this
          value = finder.getValue(); // get numeric value
          Serial.print(value);
          Serial.println(" % POP");
          //value=(value + 100) * 100;
          dtostrf(value, 5, 0, text);
          sendUDPmessage("I"+ StrArduino + "PIN074"+text);

          finder.find("mm"); // skip past this
          value = finder.getValue(); // get numeric value
          Serial.print(value);
          Serial.println(" mm QPF");
          //value=(value + 100) * 100;
          dtostrf(value, 5, 0, text);
          sendUDPmessage("I"+ StrArduino + "PIN075"+text);

          finder.find("pop"); // skip past this
          value = finder.getValue(); // get numeric value
          Serial.print(value);
          Serial.println(" % POP");
          //value=(value + 100) * 100;
          dtostrf(value, 5, 0, text);
          sendUDPmessage("I"+ StrArduino + "PIN076"+text);


          finder.find("mm"); // skip past this
          value = finder.getValue(); // get numeric value
          Serial.print(value);
          Serial.println(" mm QPF");
          //value=(value + 100) * 100;
          dtostrf(value, 5, 0, text);
          sendUDPmessage("I"+ StrArduino + "PIN077"+text);


          /*
          char c = client.read();
          Serial.print(c);
          */
          }

          Serial.println();
          Serial.println("disconnecting.");
          Serial.println("==================");
          Serial.println();
          delay(10);
          client.stop();
          client.flush();

          }
          Zuletzt geändert von mapchen; 02.06.2016, 21:45.

          Kommentar


          • Benjamin Jobst
            Benjamin Jobst kommentierte
            Kommentar bearbeiten
            Bei der Größe hätte ich dir eine .txt oder so vorgeschlagen, da scrollt man ja bis ans Ende der Welt =)
        • Benjamin Jobst
          Lox Guru
          • 25.08.2015
          • 1194

          #7
          Gast Die Spezifikationen des DS18B20 nach Maxim: Klicke auf die Grafik für eine vergrößerte Ansicht

Name: DS18B20 Spez.JPG
Ansichten: 996
Größe: 84,2 KB
ID: 43922

          Mit den 5V bewegst du dich am oberen Ende, mit den 3,3V knapp am unteren Ende des Toleranzbereichs. Wäre aber theoretisch sogar parasitär möglich. Kann sein, dass es bei längeren Leitungen Probleme gibt, allerdings ziehen die Sensoren ja so wenig Strom, dass man den Spannungsabfall vllt gar nicht berücksichtigen muss...
          MfG Benny

          Kommentar

          Lädt...