Plugin for Nodo: New Oregon plugin

Experimentele Plug-ins
Forumregels
LET OP: DIT IS HET EXPERIMENTELE GEDEELTE
BETREDEN OP EIGEN RISICO :lol:

Re: Plugin for Nodo: New Oregon plugin

Berichtdoor Voyager » 01 maart 2015, 23:47

Klopt.. Er zijn nog wat kleine dingetjes.. Ik zal binnenkort een update posten.
Voyager
 
Berichten: 180
Geregistreerd: 23 okt 2014, 14:26

Re: Plugin for Nodo: New Oregon plugin

Berichtdoor PeterB » 02 maart 2015, 16:52

Hi William, als je toch nog aan het knutselen gaat dan kun je misschien eens nadenken over het volgende. In de versie die ik nu heb draaien kunnen vele typen sensoren worden uitgelezen. Er zitten sensoren in welke wel 8 variabelen kunnen vullen. Het nadeel daarvan is dat als je een sensor hebt die maar 2 variabelen gebruikt je de andere 6 variabelen ook kwijt bent. Is het niet mogelijk om alleen het aantal variabelen te gebruiken die de gebruikte sensor ook daadwerkelijk nodig heeft? Hiermee voorkom je dat de toch al schaarse variabelen te snel op raken.
PeterB
 
Berichten: 17
Geregistreerd: 01 maart 2014, 21:27

Re: Plugin for Nodo: New Oregon plugin

Berichtdoor Voyager » 02 maart 2015, 20:10

Ja, daar was inmiddels al in voorzien :)
Voyager
 
Berichten: 180
Geregistreerd: 23 okt 2014, 14:26

Plugin 48 Oregon

Berichtdoor Naitsirhc » 04 maart 2015, 21:15

Hallo,

Ik kom er niet meer uit....
Wie kan me helpen om mijn waardes van de oregon sensoren in de variabelen te krijgen:
Ik heb plugin 048 in de nodo geladen.
Mijn script bevat:
EventlistErase
EventlistWrite; Boot 1; Timer 1
EventlistWrite; Boot 1; Timer 2
EventlistWrite; Boot 1; Timer 3
EventlistWrite; Boot 1; Oregon 42,1
EventlistWrite; Boot 1; Oregon 250,3
EventlistWrite; Boot 1; Oregon 26,4
eventlistwrite; boot 1; TimerSet 1,10
eventlistwrite; Timer 1; TimerSet 1,10
eventlistwrite; boot 2; TimerSet 1,11
eventlistwrite; Timer 2; TimerSet 1,10
eventlistwrite; boot 3; TimerSet 1,12
eventlistwrite; Timer 3; TimerSet 1,10
eventlistwrite; Timer 1; VariableSend 1,HTTP
eventlistwrite; Timer 2; VariableSend 2,HTTP
eventlistwrite; Timer 3; VariableSend 3,HTTP

Mijn eventlist geeft na verloop van tijd het volgende weer.....
Unit Event Timestamp
1 Variable 1,0 2015-03-04 21:12:05
1 Variable 4,0 2015-03-04 21:12:04
1 Variable 3,0 2015-03-04 21:12:03
0 Oregon 26,4 2015-03-04 21:11:58
1 Variable 1,0 2015-03-04 21:11:55
1 Variable 4,0 2015-03-04 21:11:53
1 Variable 3,0 2015-03-04 21:11:53
1 Variable 1,0 2015-03-04 21:11:45
0 Oregon 26,4 2015-03-04 21:11:44
1 Variable 4,0 2015-03-04 21:11:43
1 Variable 3,0 2015-03-04 21:11:43
0 Oregon 42,1 2015-03-04 21:11:40
0 Oregon 250,3 2015-03-04 21:11:38
1 Variable 1,0 2015-03-04 21:11:34
1 Variable 4,0 2015-03-04 21:11:33
1 Variable 3,0 2015-03-04 21:11:32
0 Oregon 26,4 2015-03-04 21:11:30
1 Variable 1,0 2015-03-04 21:11:23
1 Variable 4,0 2015-03-04 21:11:22
1 Variable 3,0 2015-03-04 21:11:21
0 Oregon 26,4 2015-03-04 21:11:16
1 Variable 1,0 2015-03-04 21:11:13
1 Variable 4,0 2015-03-04 21:11:12
1 Variable 3,0 2015-03-04 21:11:11
1 Variable 1,0 2015-03-04 21:11:03
1 Variable 4,0 2015-03-04 21:11:02
1 Variable 3,0 2015-03-04 21:11:01
0 Oregon 42,1 2015-03-04 21:10:53
1 Variable 1,0 2015-03-04 21:10:53
1 Variable 4,0 2015-03-04 21:10:52
1 Variable 3,4.500 2015-03-04 21:10:50
0 Oregon 26,4 2015-03-04 21:10:48
0 Oregon 250,3 2015-03-04 21:10:45
1 Variable 1,0 2015-03-04 21:10:42
1 Variable 4,0 2015-03-04 21:10:41
1 Variable 3,0 2015-03-04 21:10:40
0 Oregon 26,4 2015-03-04 21:10:3
Ik zie dus dat variabele 3 even verhoogd wordt en daarna direct weer op 0 gezet....

Ik snap er geen hout meer van....

Wie geeft me een hint?
Naitsirhc
 
Berichten: 232
Geregistreerd: 30 sep 2011, 14:28

Re: Plugin 48 Oregon

Berichtdoor h143 » 04 maart 2015, 21:26

Plugin 48 is nog een beta versie.
op dit moment kun je mits je de juiste oregon sensoren hebt plugin 12 nog gebruiken.
Arduino Mega 2560
Arduino Ethernet shield
Arduino uno
Nodo 1.0
h143
 
Berichten: 137
Geregistreerd: 05 nov 2011, 10:08
Woonplaats: Hoogkerk

Re: Plugin 48 Oregon

Berichtdoor Naitsirhc » 04 maart 2015, 22:05

Bedankt voor je antwoord

Ehm....

Ik heb William meegeholpen met het bouwen van de plugin....dwz William creerde de plugin en ik gaf hem de testdata door (via serial monitor) :lol: :lol: :lol:
De plugin moet dus met mijn Oregon wrm88 weerstation werken (Als het goed is :D :D )

Ik moet alleen de waardes nog in de variabele krijgen en dat gaat dus niet geheel goed....
Of ik moet iets missen....

Klopt mijn script niet?
Naitsirhc
 
Berichten: 232
Geregistreerd: 30 sep 2011, 14:28

Re: Plugin for Nodo: New Oregon plugin

Berichtdoor rwijbenga » 05 maart 2015, 23:28

Ik heb even je support vraag verplaatst naar het topic over de nieuwe Oregon plugin, aangezien die nog beta is.

Neem aan dat @voyager daar wel een antwoord voor je op heeft. Waarschijnlijk zal de nieuwe versie ook snel verschijnen in dit topic.
rwijbenga
 
Berichten: 344
Geregistreerd: 28 aug 2011, 14:58

Re: Plugin for Nodo: New Oregon plugin

Berichtdoor PieterS » 08 maart 2015, 13:10

Gezien voorstaande bericht hoop ik in juiste topic te posten:

@Voyager: Dank voor beschikbaar stellen van deze plugin!

Gebruik Plugin_048 i.c.m. Oregon THGR122NX. Werkt naar volle tevredenheid (temperatuur & luchtvochtigheid) via de webapp maar er is mogelijk meer info uit te halen?

Ik zie namelijk via serial input op de Nodo de batterijstatus weergegeven worden. Is deze status ook naar de (oude) Webapp (Version WebApp SWINWA-PROD-V099) over te zenden zodat er via Notifications bij te lage spanning een alert verzonden kan worden? Of heb ik ergens overheen gelezen?
PieterS
 
Berichten: 234
Geregistreerd: 21 dec 2011, 22:11

Re: Plugin for Nodo: New Oregon plugin

Berichtdoor Voyager » 11 maart 2015, 14:23

Hier een nieuwe versie van de Oregon plugin ter test..
Uiteraard is alle data welkom, zeker als er onduidelijkheden zijn.
Maar met name wind, regen, barometer en UV sensor data zijn zeer welkom. Dit om het formaat van de data met zekerheid vast te stellen en eventuele checks in te bouwen.

~William

Code: Selecteer alles
//#######################################################################################################
//##################################### Plugin-48 Oregon V1/2/3 #########################################
//#######################################################################################################
/*********************************************************************************************\
 * This protocol takes care of receiving Oregon Scientific outdoor sensors that use the V1, V2 and V3 protocol
 *
 * models: THC238, THC268, THN132N, THWR288A, THRN122N, THN122N, AW129, AW131, THGR268, THGR122X,
 *         THGN122N, THGN123N, THGR122NX, THGR228N, THGR238, WTGR800, THGR918, THGRN228NX, THGN500,
 *         THGR810, RTGR328N, THGR328N, Huger BTHR918, BTHR918N, BTHR968, RGR126, RGR682, RGR918, PCR122
 *         RTGR328N, THWR800, THR128, THR138, THC138, OWL CM119, cent-a-meter, OWL CM113, Electrisave
 *         UVN128, UV138, UVN800, Huger-STR918, WGR918, WGR800, PCR800, WGTR800, RGR126, RGR682, RGR918
 *
 * Auteur             : Voyager
 * Support            : www.nodo-domotica.nl
 * Datum              : 1-2-2015
 * Versie             : 1.0
 * Nodo productnummer : n.v.t. 
 * Syntax             : "Oregon <Par1:Sensor ID>, <Par2:Basis Variabele>"
 * Compiled size      : xxx bytes voor een Mega.
 *********************************************************************************************
 * Changelog: v0.1 beta
 *********************************************************************************************
 * Technical information:
 * Supports Oregon V1, V2 and V3 protocol messages
 * Core code from https://github.com/Cactusbone/ookDecoder/blob/master/ookDecoder.ino
 * Copyright (c) 2014 Charly Koza cactusbone@free.fr Copyright (c) 2012 Olivier Lebrun olivier.lebrun@connectingstuff.net
 * Copyright (c) 2012 Dominique Pierre (zzdomi) Copyright (c) 2010 Jean-Claude Wippler jcw@equi4.com
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
 * is furnished to do so, subject to the following conditions:
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 \*********************************************************************************************/
#define PLUGIN_ID 48
#define PLUGIN_NAME "Oregon"

#define OSV3_PULSECOUNT_MIN 126
#define OSV3_PULSECOUNT_MAX 267

/*
 * Many devices use 160 bits, known exceptions:
 * 0xEA4c         136 bits  // TH132N
 * 0xEA7c         240 bits  // UV138
 * 0x5A5D / 1A99  176 bits  // THGR918 / WTGR800
 * 0x5A6D         192 bits  // BTHR918N
 * 0x8AEC         192 bits  // RTGR328N
 * 0x9AEC         208 bits  // RTGR328N
 * 0xDA78         144 bits  // UVN800
 * 0x2A19         184 bits  // RCR800
 * 0x2A1d         168 bits  // WGR918
 */
// =====================================================================================================
class DecodeOOK {
protected:
   byte total_bits, bits, flip, state, pos, data[25];
   virtual char decode(word width) = 0;
public:
   enum { UNKNOWN, T0, T1, T2, T3, OK, DONE };
    // -------------------------------------
   DecodeOOK() { resetDecoder(); }
    // -------------------------------------
   bool nextPulse(word width) {
      if (state != DONE)

         switch (decode(width)) {
         case -1: resetDecoder(); break;
         case 1:  done(); break;
      }
      return isDone();
   }
    // -------------------------------------
   bool isDone() const { return state == DONE; }
    // -------------------------------------
   const byte* getData(byte& count) const {
      count = pos;
      return data;
   }
    // -------------------------------------
   void resetDecoder() {
      total_bits = bits = pos = flip = 0;
      state = UNKNOWN;
   }
    // -------------------------------------
   // add one bit to the packet data buffer
    // -------------------------------------
   virtual void gotBit(char value) {
      total_bits++;
      byte *ptr = data + pos;
      *ptr = (*ptr >> 1) | (value << 7);

      if (++bits >= 8) {
         bits = 0;
         if (++pos >= sizeof data) {
            resetDecoder();
            return;
         }
      }
      state = OK;
   }
    // -------------------------------------
   // store a bit using Manchester encoding
    // -------------------------------------
   void manchester(char value) {
      flip ^= value; // manchester code, long pulse flips the bit
      gotBit(flip);
   }
    // -------------------------------------
   // move bits to the front so that all the bits are aligned to the end
    // -------------------------------------
   void alignTail(byte max = 0) {
      // align bits
      if (bits != 0) {
         data[pos] >>= 8 - bits;
         for (byte i = 0; i < pos; ++i)
            data[i] = (data[i] >> bits) | (data[i + 1] << (8 - bits));
         bits = 0;
      }
      // optionally shift bytes down if there are too many of 'em
      if (max > 0 && pos > max) {
         byte n = pos - max;
         pos = max;
         for (byte i = 0; i < pos; ++i)
            data[i] = data[i + n];
      }
   }
    // -------------------------------------
   void reverseBits() {
      for (byte i = 0; i < pos; ++i) {
         byte b = data[i];
         for (byte j = 0; j < 8; ++j) {
            data[i] = (data[i] << 1) | (b & 1);
            b >>= 1;
         }
      }
   }
    // -------------------------------------
   void reverseNibbles() {
      for (byte i = 0; i < pos; ++i)
         data[i] = (data[i] << 4) | (data[i] >> 4);
   }
    // -------------------------------------
   void done() {
      while (bits)
         gotBit(0); // padding
      state = DONE;
   }
};

class OregonDecoderV1 : public DecodeOOK {
   public:
      OregonDecoderV1() {}
         virtual char decode(word width) {
         if (200 <= width && width < 1200) {
            byte w = width >= 700;
            switch (state) {
               case UNKNOWN:
                  if (w == 0)
                     ++flip;
                  else if (10 <= flip && flip <= 50) {
                     flip = 1;
                     manchester(1);
                  }
                  else
                     return -1;
                  break;
                  case OK:
                     if (w == 0)
                        state = T0;
                     else
                        manchester(1);
                     break;
                     case T0:
                        if (w == 0)
                           manchester(0);
                        else
                           return -1;
                        break;
            }
            return 0;
         }
         if (width >= 2500 && pos >= 9)
            return 1;
         return -1;
      }
};

class OregonDecoderV2 : public DecodeOOK {
public:
   OregonDecoderV2() {}

    // -------------------------------------
   // add one bit to the packet data buffer
    // -------------------------------------
   virtual void gotBit(char value) {
      if (!(total_bits & 0x01))
      {
         data[pos] = (data[pos] >> 1) | (value ? 0x80 : 00);
      }
      total_bits++;
      pos = total_bits >> 4;
      if (pos >= sizeof data) {
         resetDecoder();
         return;
      }
      state = OK;
   }
    // -------------------------------------
   virtual char decode(word width) {
      if (200 <= width && width < 1200) {
         byte w = width >= 700;
         switch (state) {
         case UNKNOWN:
            if (w != 0) {
               // Long pulse
               ++flip;
            }
            else if (w == 0 && 24 <= flip) {
               // Short pulse, start bit
               flip = 0;
               state = T0;
            }
            else {
               // Reset decoder
               return -1;
            }
            break;
         case OK:
            if (w == 0) {
               // Short pulse
               state = T0;
            }
            else {
               // Long pulse
               manchester(1);
            }
            break;
         case T0:
            if (w == 0) {
               // Second short pulse
               manchester(0);
            }
            else {
               // Reset decoder
               return -1;
            }
            break;
         }
      }
      else if (width >= 2500 && pos >= 8) {
         return 1;
      }
      else {
         return -1;
      }
      return total_bits == 160 ? 1 : 0;
   }
};

class OregonDecoderV3 : public DecodeOOK {
public:
   OregonDecoderV3() {}
    // -------------------------------------
   // add one bit to the packet data buffer
    // -------------------------------------
   virtual void gotBit(char value) {
      data[pos] = (data[pos] >> 1) | (value ? 0x80 : 00);
      total_bits++;
      pos = total_bits >> 3;
      if (pos >= sizeof data) {
         resetDecoder();
         return;
      }
      state = OK;
   }
    // -------------------------------------
   virtual char decode(word width) {
      if (200 <= width && width < 1200) {
         byte w = width >= 700;
         switch (state) {
         case UNKNOWN:
            if (w == 0)
               ++flip;
            else if (32 <= flip) {
               flip = 1;
               manchester(1);
            }
            else
               return -1;
            break;
         case OK:
            if (w == 0)
               state = T0;
            else
               manchester(1);
            break;
         case T0:
            if (w == 0)
               manchester(0);
            else
               return -1;
            break;
         }
      }
      else {
         return -1;
      }
      return  total_bits == 80 ? 1 : 0;
   }
};

OregonDecoderV1 orscV1;
OregonDecoderV2 orscV2;
OregonDecoderV3 orscV3;

volatile word pulse;
// =====================================================================================================
// =====================================================================================================
byte osdata[13];               

void reportSerial(class DecodeOOK& decoder) {
   byte pos;
   const byte* data = decoder.getData(pos);
   for (byte i = 0; i < pos; ++i) {
        if (i < 13) osdata[i]=data[i];
   }
   decoder.resetDecoder();
}
// =====================================================================================================
// calculate a packet checksum by performing a
byte checksum(byte type, int count, byte check) {
     byte calc=0;
     // type 1, add all nibbles, deduct 10
     if (type == 1) {
        for(byte i = 0; i<count;i++) {
           calc += (osdata[i]&0xF0) >> 4;
           calc += (osdata[i]&0xF);
        }
        calc=calc-10;
     } else
     // type 2, add all nibbles up to count, add the 13th nibble , deduct 10
     if (type == 2) {
        for(byte i = 0; i<count;i++) {
           calc += (osdata[i]&0xF0) >> 4;
           calc += (osdata[i]&0xF);
        }
        calc += (osdata[6]&0xF);
        calc=calc-10;
     } else
     // type 3, add all nibbles up to count, subtract 10 only use the low 4 bits for the compare
     if (type == 3) {
        for(byte i = 0; i<count;i++) {
           calc += (osdata[i]&0xF0) >> 4;
           calc += (osdata[i]&0xF);
        }
        calc=calc-10;
        calc=(calc&0x0f);
     } else
     if (type == 4) {
        for(byte i = 0; i<count;i++) {
           calc += (osdata[i]&0xF0) >> 4;
           calc += (osdata[i]&0xF);
        }
        calc=calc-10;
       
     }
     if (check == calc ) return 0;     
     return 1;
}
// =====================================================================================================
uint8_t Plugin_048_ProtocolCRC( uint8_t *addr, uint8_t len);
byte Plugin_048_ProtocolCheckID(byte checkID);
byte Plugin_048_ReverseBits(byte data);

byte Plugin_048_ProtocolValidID[10];
byte Plugin_048_ProtocolVar[10];

boolean Plugin_048(byte function, struct NodoEventStruct *event, char *string)
{
  boolean success=false;

  switch(function)
  {
#ifdef PLUGIN_048_CORE
  case PLUGIN_RAWSIGNAL_IN:
    {
      if (RawSignal.Number < OSV3_PULSECOUNT_MIN || RawSignal.Number > OSV3_PULSECOUNT_MAX ) return false;

      byte basevar=0;
      byte rc=0;
      byte found = 0;
      byte channel = 0;
     
      int temp = 0;
      byte hum = 0;
      int baro = 0;
      int uv = 0;
      int wdir = 0;
      int wspeed = 0;
      int awspeed = 0;
      int rain = 0;
      int raintot = 0;
     
      word p = pulse;
      // ==================================================================================
      for (int x = 0; x < RawSignal.Number; x++) {
          p = RawSignal.Pulses[x]*RawSignal.Multiply;
          if (p != 0) {
             if (orscV1.nextPulse(p)) {
                reportSerial(orscV1);
                found=1;
             }
             if (orscV2.nextPulse(p)) {
                reportSerial(orscV2);
                found=2;
             }
             if (orscV3.nextPulse(p)) {
                reportSerial(orscV3);
                found=3;
             }
          }
      }
      if (found == 0) break;
      // ==================================================================================
      // Protocol and device info:
      // ==================================================================================
      Serial.print("Oregon V");
      Serial.print(found);
      Serial.print(": ");
      for(byte x=0; x<13;x++) {
          Serial.print( osdata[x],HEX );
          Serial.print((" "));
      }
      Serial.println(""); 
      Serial.print("Oregon ID=");
      unsigned int id=(osdata[0]<<8)+ (osdata[1]);
      rc=osdata[0];
      Serial.println(id,HEX); 
      // ==================================================================================
      // Process the various device types:
      // ==================================================================================
      // Oregon V1 packet structure
      // SL-109H, AcuRite 09955
      // TEMP + CRC
      // ==================================================================================
      // 8487101C
      // 84+87+10=11B > 1B+1 = 1C
      if (found==1) {       // OSV1
         int sum = osdata[0]+osdata[1]+osdata[2];  // max. value is 0x2FD
         sum= (sum &0xff) + (sum>>8);              // add overflow to low byte
         if (osdata[3] != (sum & 0xff) ) {
            Serial.println("CRC Error");
            //break;
         }
         Serial.print(" RC=");                     // Rolling code + channel number
         Serial.print(rc);
         // -------------       
         Serial.print(" TEMP=");
         temp = ((osdata[2]>>4) * 100)  + ((osdata[1] & 0x0F) * 10) + ((osdata[1] >> 4));
         if ((osdata[2] & 0x02) == 2) temp=-temp;   // bit 1 set when temp is negative
         Serial.print( float(temp));
         Serial.println();
      }
      // ==================================================================================
      // ea4c  Outside (Water) Temperature: THC238, THC268, THN132N, THWR288A, THRN122N, THN122N, AW129, AW131
      // TEMP + BAT + CRC
      // ca48  Pool (Water) Temperature: THWR800
      // 0a4d  Indoor Temperature: THR128, THR138, THC138
      // ==================================================================================
      // OSV2 EA4C20725C21D083 // THN132N
      // OSV2 EA4C101360193023 // THN132N
      // OSV2 EA4C40F85C21D0D4 // THN132N
      // OSV2 EA4C20809822D013
      //      0123456789012345
      //      0 1 2 3 4 5 6 7
      if(id == 0xea4c || id == 0xca48 || id == 0x0a4d) {
        byte sum=(osdata[7]&0x0f) <<4;
        sum=sum+(osdata[6]>>4);
        if ( checksum(2,6, sum) !=0) {  // checksum = all nibbles 0-11+13 results is nibbles 15 <<4 + 12
            Serial.println("CRC Error");
            //break;
        }
        rc=osdata[2];
        Serial.print(" RC=");
        Serial.print(rc);
        // -------------       
        Serial.print(" TEMP=");
        temp = ((osdata[5]>>4) * 100)  + ((osdata[5] & 0x0F) * 10) + ((osdata[4] >> 4));
        if ((osdata[6] & 0x0F) >= 8) temp=-temp;
        Serial.print( float(temp)/10,1);
        // -------------       
        Serial.print(" BAT=");
        if ((osdata[3] & 0x0F) >= 4) {
           Serial.print("LOW");
        } else {       
           Serial.print("OK");
        }       
        Serial.println();
      } else
      // ==================================================================================
      // 1a2d  Indoor Temp/Hygro: THGN122N, THGN123N, THGR122NX, THGR228N, THGR238, THGR268, THGR122X
      // 1a3d  Outside Temp/Hygro: THGR918, THGRN228NX, THGN500
      // fa28  Indoor Temp/Hygro: THGR810
      // *aac  Outside Temp/Hygro: RTGR328N
      // ca2c  Outside Temp/Hygro: THGR328N
      // fab8  Outside Temp/Hygro: WTGR800
      // TEMP + HUM sensor + BAT + CRC
      // ==================================================================================
      // OSV2 AACC13783419008250AD[RTGR328N,...] Id:78 ,Channel:0 ,temp:19.30 ,hum:20 ,bat:10
      // OSV2 1A2D40C4512170463EE6[THGR228N,...] Id:C4 ,Channel:3 ,temp:21.50 ,hum:67 ,bat:90
      // OSV2 1A2D1072512080E73F2C[THGR228N,...] Id:72 ,Channel:1 ,temp:20.50 ,hum:78 ,bat:90
      // OSV2 1A2D103742197005378E // THGR228N
      // OSV3 FA28A428202290834B46 //
      //      1A3D10D91C273083..
      //      1A3D10D90C284083..
      // OSV3 FA2814A93022304443BE // THGR810
      //      01234567890123456789
      // OSV2 DA CC 13 D3 58 23 0 84 57 B2 0 0 0  Oregon ID=DACC  RC=19 TEMP=23.5 HUM=40 BAT=OK
      //      0 1 2 3 4 5
      // F+A+2+8+1+4+A+9+3+0+2+2+3+0+4+4=4d-a=43
      if(id == 0xfa28 || id == 0x1a2d || id == 0x1a3d || (id&0xfff)==0xACC || id == 0xca2c || id == 0xfab8 ) {
        if ( checksum(1,8,osdata[8]) !=0) break;   // checksum = all nibbles 0-15 results is nibbles 16.17
        rc=osdata[2];
        Serial.print(" RC=");
        Serial.print(rc);
        // -------------       
        Serial.print(" TEMP=");
        temp = ((osdata[5]>>4) * 100)  + ((osdata[5] & 0x0F) * 10) + ((osdata[4] >> 4));
        if ((osdata[6] & 0x0F) >= 8) temp=-temp;
        Serial.print( float(temp)/10,1);
        // -------------       
        Serial.print(" HUM=");
        hum = ((osdata[7] & 0x0F)*10)+ (osdata[6] >> 4);
        Serial.print(hum);
        // -------------       
        Serial.print(" BAT=");
        if ((osdata[3] & 0x0F) >= 4) {
           Serial.print("LOW");
        } else {       
           Serial.print("OK");
        }       
        Serial.println();
      } else
      // ==================================================================================
      // 5a5d  Indoor Temp/Hygro/Baro: Huger - BTHR918
      // 5a6d  Indoor Temp/Hygro/Baro: BTHR918N, BTHR968
      // TEMP + HUM + BARO + BAT
      // NO CRC YET, Need logged packets!
      // ==================================================================================
      // 5A 6D 00 7A 10 23 30 83 86 31
      // 5+a+6+d+7+a+1+2+3+3+8+3=47 -a=3d  +8=4f +8+6=55     
      // 5+a+6+d+7+a+1+2+3+3=3c-a=32
      // 0  1  2  3  4  5  6  7  8  9
      if(id == 0x5a6d || id == 0x5a5d || id == 0x5d60) {
        rc=osdata[3];
        Serial.print(" RC=");
        Serial.print(rc);
        // -------------       
        Serial.print(" TEMP=");
        temp = ((osdata[5]>>4) * 100)  + ((osdata[5] & 0x0F) * 10) + ((osdata[4] >> 4));
        if ((osdata[6] & 0x0F) >= 8) temp=-temp;
        Serial.print( float(temp)/10,1);
        // -------------       
        Serial.print(" HUM=");
        hum = ((osdata[7] & 0x0F)*10)+ (osdata[6] >> 4);
        Serial.print(hum);
        // -------------       
        Serial.print(" BARO=");
        int baro = (osdata[8] + 856);
        Serial.print(baro);
        switch (osdata[7] & 0xC0) {
            case 0x00:
                      Serial.print(" COMF=Normal");
                      break;
            case 0x40:
                      Serial.print(" COMF=Comfortable");
                      break;
            case 0x80:
                      Serial.print(" COMF=Dry");
                      break;
            case 0xC0:
                      Serial.print(" COMF=Wet");
                      break;
        }
        switch (osdata[9] >> 4) {
            case 0x0C:
                      Serial.print(" FORECAST=Sunny");
                      break;
            case 0x06:
                      Serial.print(" FORECAST=Partly Cloudy");
                      break;
            case 0x02:
                      Serial.print(" FORECAST=Cloudy");
                      break;
            case 0x03:
                      Serial.print(" FORECAST=Wet");
                    break;
        }     
        // ------------- 
        Serial.print(" BAT=");
        if ((osdata[3] & 0x0F) >= 4) {
           Serial.print("LOW");
        } else {       
           Serial.print("OK");
        }       
        Serial.println("");
      } else
      // ==================================================================================
      // 2914  Rain Gauge:
      // 2d10  Rain Gauge:
      // 2a1d  Rain Gauge: RGR126, RGR682, RGR918, PCR122
      // 2A1D0065502735102063
      // 2+A+1+D+0+0+6+5+5+0+2+7+3+5+1+0+2+0=3e-a=34 != 63
      // ==================================================================================
      if(id == 0x2a1d || id == 0x2d10 || id == 0x2914) { // Rain sensor
        //Checksum - add all nibbles from 0 to 8, subtract 9 and compare
        /*
        int cs = 0;
        for (byte i = 0; i < pos-2; ++i) { //all but last byte
            cs += data[i] >> 4;
            cs += data[i] & 0x0F;
        }
        int csc = (data[8] >> 4) + ((data[9] & 0x0F)*16);   
        cs -= 9;  //my version as A fails?
        Serial.print(csc);
        Serial.print(" vs ");   
        Serial.println(cs);
        */
        rc=osdata[3];
        Serial.print(" RC=");
        Serial.print(rc);
        //Serial.print(" RC=");
        //Serial.print(osdata[3]);
        Serial.print(" RainRate=");
        rain = ((osdata[5]>>4) * 100)  + ((osdata[5] & 0x0F) * 10) + (osdata[4] >> 4);
        Serial.print(rain);
        Serial.print(" RainTotal=");
        raintot = ((osdata[7]  >> 4) * 10)  + (osdata[6]>>4);
        Serial.print(raintot);
        Serial.print(" FlipCount=");
        Serial.print( (osdata[6]&0x0f) );
        Serial.print(" BAT=");
        if ((osdata[3] & 0x0F) >= 4){
           Serial.println("Low");
        } else {
           Serial.println("OK");
        }
      } else
      // ==================================================================================
      // 2a19  Rain Gauge: PCR800
      // RAIN + BAT + CRC
      // ==================================================================================
      // OSV3 2A19048E399393250010
      //      01234567890123456789
      //      0 1 2 3 4 5 6 7 8 9
      // 2+A+1+9+0+4+8+E+3+9+9+3+9+3+2+5=5b-A=51 => 10
      if(id == 0x2a19) { // Rain sensor
        int sum = (osdata[9] >> 4); 
        if ( checksum(3,9,sum) !=0) { // checksum = all nibbles 0-17 result is nibble 18
            Serial.print("CRC Error, ");
            //break;
        }
        rc=osdata[2];
        Serial.print(" RC=");
        Serial.print(rc);
        Serial.print(" RainRate= ");
        rain = ((osdata[5]>>4) * 100)  + ((osdata[5] & 0x0F) * 10) + (osdata[4] >> 4);
        Serial.print(rain);
        //Serial.print(" RainTotal=");
        //raintot = ((osdata[7]  >> 4) * 10)  + (osdata[6]>>4);
        //Serial.print(raintot);
        Serial.print(" BAT=");
        if ((osdata[3] & 0x0F) >= 4){
           Serial.println("Low");
        } else {
           Serial.println("OK");
        }
        Serial.println("");
      } else
      // ==================================================================================
      // 1a89  Anemometer: WGR800
      // WIND DIR + SPEED + AV SPEED + CRC
      // ==================================================================================
      // OSV3 1A89048800C026400543
      // OSV3 1A89048800C00431103B
      // OSV3 1a89048848c00000003e W
      // OSV3 1a890488c0c00000003e E     
      //      1A89042CB0C047000147     
      //      0 1 2 3 4 5 6 7 8 9
      // 1+A+8+9+0+4+8+8+0+0+C+0+0+4+3+1+1+0=45-a=3b
      if(id == 0x1a89) { // Wind sensor
        if ( checksum(1,9,osdata[9]) !=0) break;
        rc=osdata[2];
        Serial.print(" RC=");
        Serial.print(rc);
        Serial.print(" WDIR=");
        wdir=(osdata[4] >> 4);
        wdir=wdir*225;
        wdir=wdir/10;
        Serial.print(wdir);
        // -------------       
        Serial.print(" Current Speed =");
        wspeed = (osdata[6] >> 4) * 10;
        wspeed = wspeed + (osdata[6] &0x0f) * 100;
        wspeed = wspeed + (osdata[5] &0x0f);
        Serial.print( (float)wspeed / 10);
        // -------------       
        Serial.print(" Average Speed =");
        awspeed = (osdata[8] >> 4) * 100;
        awspeed = awspeed + (osdata[7] &0x0f) * 10;
        awspeed = awspeed + (osdata[7] >> 4);
        Serial.print( (float)awspeed / 10);
        Serial.println("");
      } else
      // ==================================================================================
      // 3a0d  Anemometer: Huger-STR918, WGR918
      // 1984  Anemometer:
      // 1994  Anemometer:
      // WIND DIR + SPEED + AV SPEED + BAT + CRC
      // ==================================================================================
      if(id == 0x3A0D || id == 0x1984 || id == 0x1994 ) {
        if ( checksum(1,9,osdata[9]) !=0) {
            Serial.print("CRC Error, ");
            //break;
        }
        rc=osdata[2];
        Serial.print(" RC=");
        Serial.print(rc);
        Serial.print(" WDIR=");
        wdir = ((osdata[5]>>4) * 100)  + ((osdata[5] & 0x0F * 10) ) + (osdata[4] >> 4);   
        Serial.print(wdir);
        Serial.print(" Current Speed=");
        wspeed = ((osdata[7] & 0x0F) * 100)  + ((osdata[6]>>4) * 10)  + ((osdata[6] & 0x0F)) ;
        Serial.print(float(wspeed)/10,1);   
        Serial.print(" Average Speed=");
        awspeed = ((osdata[8]>>4) * 100)  + ((osdata[8] & 0x0F) * 10)+((osdata[7] >>4)) ;     
        Serial.print(float(awspeed)/10,1);
        Serial.print(" BAT=");
        if ((osdata[3] & 0x0F) >= 4){
           Serial.println("Low");
        } else {
           Serial.println("OK");
        }       
        Serial.println();
     } else
      // ==================================================================================
      // ea7c  UV Sensor: UVN128, UV138
      // UV + BAT
      // NO CRC YET
      // ==================================================================================
      if(id == 0xea7c) {
        Serial.print("UVN128/138: UV=");
        uv=((osdata[5] & 0x0F) * 10)  + (osdata[4] >> 4);
        Serial.print(uv);
        rc=osdata[2];
        Serial.print(" RC=");
        Serial.print(rc);
        Serial.print(" Battery=");
        if ((osdata[3] & 0x0F) >= 4){
           Serial.println("Low");
        } else {
           Serial.println("OK");
        }
        Serial.println();
      } else
      // ==================================================================================
      // da78  UV Sensor: UVN800
      // UV
      // NO CRC YET
      // ==================================================================================
      if( id == 0xda78) {
        Serial.print("UVN800: UV=");
        uv=(osdata[6] & 0xf0) + (osdata[5] &0x0f) ;
        Serial.print(uv);
        rc=osdata[2];
        Serial.print(" RC=");
        Serial.print(rc);
        Serial.println();
      } else
      // ==================================================================================
      // *aec  Date&Time: RTGR328N
      // NO CRC YET
      // ==================================================================================
      // 8A EA 13 78 07 72 14 92 42 42 C1 6C BD  21:49 29/04/2014  year: 14 month:4 weekday: 2 (donc mardi) mday:29 hour:21 min:47 sec:20
      // 0 1 2 3 4 5 6 7 8 9 0 1 2
      // 8+A+E+A+1+3+7+8+0+7+7+2+1+4+9+2+4+2+4+2+C+1+6+C=88 !=   BD
      // 8A EC 13 2F 00 94 30 21 10 34  03-1-02 13:09:40   ?
      // 8A EC 13 2F 80 12 34 21 10 34  03-1-02 13:41:20   ?         
      // 0  1  2  3  4  5  6  7  8  9      11/2/2015 21:10 ?
      // Date & Time
      if( (id&0xfff)==0xAEA || (id&0xfff)==0xAEC) {
        Serial.print("RTGR328N RC: ");
        Serial.print(osdata[3], HEX);
        Serial.print(" Date&Time");
        /*Serial.print( (osdata[9] >> 4) + 10 * (osdata[10] & 0xf) );
        Serial.print(" - ");
        Serial.print( osdata[8] >> 4 );
        Serial.print(" - ");
        Serial.print( (osdata[7] >> 4) + 10 * (osdata[8] & 0xf) );
        Serial.print(" Time: ");
        Serial.print( (osdata[6] >> 4) + 10 * (osdata[7] & 0xf) );
        Serial.print(":");
        Serial.print((osdata[5] >> 4) + 10 * (osdata[6] & 0xf));
        Serial.print(":");
        Serial.print((osdata[4] >> 4) + 10 * (osdata[5] & 0xf));*/
        Serial.println();
        break;
      } else
      // ==================================================================================
      // eac0  Ampere meter: cent-a-meter, OWL CM113, Electrisave
      // ==================================================================================
      if(id == 0xeac0) {
        Serial.println("UNKNOWN LAYOUT");
        break;
      } else     
      // ==================================================================================
      // 0x1a* / 0x2a* 0x3a** Power meter: OWL CM119
      // ==================================================================================
      // ==================================================================================
      // 1a99  Anemometer: WGTR800
      // WIND + TEMP + HUM + CRC
      // ==================================================================================
      if(id == 0x1a99) { // Wind sensor
        Serial.println("Unsupported Packet Layout");
        break;
      }  else {
        Serial.println("Unsupported/False Oregon ID");
        break;
      }     
      // ==================================================================================
      basevar = Plugin_048_ProtocolCheckID(rc);
      event->Par1=rc;                                 // Device ID
      event->Par2=basevar;
      event->SourceUnit    = 0;                       // Komt niet van een Nodo unit af, dus unit op nul zetten
      event->Port          = VALUE_SOURCE_RF;
      event->Type          = NODO_TYPE_PLUGIN_EVENT;
      event->Command       = 48;                      // Nummer van dit device
      if (basevar == 0) return true;
      // ==================================================================================
      // set user variables
      if(id == 0xea4c || id == 0xca48 || id == 0x0a4d || found == 1) {
        UserVar[basevar-1] = (float)temp/10,1; // temperature
      }
      if(id == 0xfa28 || id == 0x1a2d || id == 0x1a3d || (id&0xfff)==0xACC || id == 0xca2c || id == 0xfab8 ) {
        UserVar[basevar-1] = (float)temp/10,1; // temperature
        UserVar[basevar +1 -1] = hum;         // humidity
      }
      if(id == 0x5a6d || id == 0x5a5d || id == 0x5d60) {
        UserVar[basevar-1] = (float)temp/10,1; // temperature
        UserVar[basevar +1 -1] = hum;         // humidity
        UserVar[basevar +2 -1] = baro;        // barometric pressure
      }
      if(id == 0x2a1d || id == 0x2d10 || id == 0x2914 || id == 0x2a19) { // Rain sensor       
        UserVar[basevar +7 -1] = rain;        // rain rate
        UserVar[basevar +8 -1] = raintot;     // rain totals
      }
      if(id == 0x3A0D || id == 0x1984 || id == 0x1994 || id == 0x1a89 ) {
        UserVar[basevar +4 -1] = wdir;        // wind direction
        UserVar[basevar +5 -1] = wspeed;      // wind speed
        UserVar[basevar +6 -1] = awspeed;     // average wind speed
      }
      if( id == 0xda78 || id == 0xea7c) {
        UserVar[basevar +3 -1] = uv;          // uv index
      }
      RawSignal.Number=0;
      success = true;
      break;
    }
  case PLUGIN_COMMAND:
    {
    if ((event->Par2 > 0) && (Plugin_048_ProtocolCheckID(event->Par1) == 0))
      {
      for (byte x=0; x<5; x++)
        {
        if (Plugin_048_ProtocolValidID[x] == 0)
          {
          Plugin_048_ProtocolValidID[x] = event->Par1;
          Plugin_048_ProtocolVar[x] = event->Par2;
          success=true;
          break;
          }
        }
      }
    break;
    }
#endif // PLUGIN_048_CORE

#if NODO_MEGA
  case PLUGIN_MMI_IN:
    {
    char *TempStr=(char*)malloc(INPUT_COMMAND_SIZE);

    if(GetArgv(string,TempStr,1))
      {
      if(strcasecmp(TempStr,PLUGIN_NAME)==0)
        {
        if(event->Par1>0 && event->Par1<255 && event->Par2>0 && event->Par2<=USER_VARIABLES_MAX)
          {
          event->Type = NODO_TYPE_PLUGIN_COMMAND;
          event->Command = 48; // Plugin nummer 
          success=true;
          }
        }
      }
      free(TempStr);
      break;
    }

  case PLUGIN_MMI_OUT:
    {
    strcpy(string,PLUGIN_NAME);            // Eerste argument=het commando deel
    strcat(string," ");
    strcat(string,int2str(event->Par1));
    strcat(string,",");
    strcat(string,int2str(event->Par2));
    break;
    }
#endif //NODO_MEGA
  }     
  return success;
}

#ifdef PLUGIN_048_CORE
// *********************************************************************************************
// * Check for valid sensor ID
// *********************************************************************************************
byte Plugin_048_ProtocolCheckID(byte checkID)
{
  for (byte x=0; x<5; x++) if (Plugin_048_ProtocolValidID[x] == checkID) return Plugin_048_ProtocolVar[x];
  return 0;
}
#endif //CORE
Voyager
 
Berichten: 180
Geregistreerd: 23 okt 2014, 14:26

Re: Plugin for Nodo: New Oregon plugin

Berichtdoor DrEnergy » 14 maart 2015, 19:29

Klopt het dat de THGN132N nog niet ondersteund wordt? zie hem namelijk niet in de lijst staan, nadat ik hem dus geprobeerd had met deze plugin.

Alvast bedankt
DrEnergy
 
Berichten: 145
Geregistreerd: 04 jan 2012, 09:09
Woonplaats: Dordrecht

VorigeVolgende

Keer terug naar Plug-ins

Wie is er online?

Gebruikers in dit forum: Geen geregistreerde gebruikers. en 1 gast

cron