WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/AVR/avr-lib/drivers/ir/protocols.c

 #endif
 #if (IR_PROTOCOLS_USE_RUBICSON)
     res = parseRubicson(buf, len, index, proto);
     if (res!=IR_NOT_CORRECT_DATA) return res;
 #endif
+#if (IR_PROTOCOLS_USE_OREGON)
+    res = parseOregon(buf, len, index, proto);
+    if (res!=IR_NOT_CORRECT_DATA) return res;
+#endif
     /* No protocol matched. */
     proto->protocol = IR_PROTO_UNKNOWN;
     return IR_NOT_CORRECT_DATA;
+}
     /* Invalid protocol specified. */
     return IR_NOT_CORRECT_DATA;
+}
 #if (IR_PROTOCOLS_USE_SIRC)
 /**
  * Test data on SIRC protocol, 12-bit version
  * http://www.sbprojects.com/knowledge/ir/sirc.htm
  * http://picprojects.org.uk/projects/sirc/sonysirc.pdf
+ *
  * @param buf
            supporting two versions of SIRC:
 bit = 25, 15 bit = 31
            there is also a 20 bit protocol, but we don't support it
          */
     if (len != 25 && len != 31) {
         return IR_NOT_CORRECT_DATA;
     }
     /* check startbit */
     if (buf[0] > IR_SIRC_ST_BIT + IR_SIRC_ST_BIT/IR_SIRC_TOL_DIV || buf[0] < IR_SIRC_ST_BIT - IR_SIRC_ST_BIT/IR_SIRC_TOL_DIV) {
         return IR_NOT_CORRECT_DATA;
+    }
     uint16_t rawbits=0;
     for (uint8_t i = 1; i < len; i++) {
             if (buf[i] > IR_SIRC_HIGH_ONE - IR_SIRC_HIGH_ONE/IR_SIRC_TOL_DIV && buf[i] < IR_SIRC_HIGH_ONE + IR_SIRC_HIGH_ONE/IR_SIRC_TOL_DIV) {
                 /* write a one */
                 rawbits |= 1<<((i-2)>>1);
             } else if (buf[i] > IR_SIRC_HIGH_ZERO - IR_SIRC_HIGH_ZERO/IR_SIRC_TOL_DIV && buf[i] < IR_SIRC_HIGH_ZERO + IR_SIRC_HIGH_ZERO/IR_SIRC_TOL_DIV) {
                 /* do nothing, a zero is already in rawbits */
             } else {
                 return IR_NOT_CORRECT_DATA;
             }
+        }
+    }
-    }
     proto->protocol = CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_SIRC;
     proto->timeout = IR_SIRC_TIMEOUT;
     proto->data = rawbits;
     return IR_OK;
  *      Pointer to length of the data
  * @param proto
  *      Pointer to protocol information
  * @return
  *      IR_OK if data expanded successfully, one of several errormessages if not
  */
 int8_t expandSIRC(uint16_t *buf, uint8_t *len, Ir_Protocol_Data_t *proto) {
     buf[0] = IR_SIRC_ST_BIT;
     buf[1] = IR_SIRC_LOW; //start pulse finished
         /* Assume 12 bit protocol */
  *      IR_OK if data parsed successfully, one of several errormessages if not
  */
 int8_t parseRC5(const uint16_t *buf, uint8_t len, Ir_Protocol_Data_t *proto) {
     uint8_t halfbitscnt = 1;
     uint16_t rawbits = 0;
     for (uint8_t i = 0; i<len; i++) {
         //halfbitscnt&1==1 in the middle of bits
         //i&1==0 positive flank
         if ((halfbitscnt&1)==1 && (i&1)==0) {       /* in the middle of bit AND a positve flank */
             halfbitscnt += 1;
         } else if (buf[i] > IR_RC5_BIT - IR_RC5_BIT/IR_RC5_TOL_DIV && buf[i] < IR_RC5_BIT + IR_RC5_BIT/IR_RC5_TOL_DIV) {
             halfbitscnt += 2;
         } else {
             return IR_NOT_CORRECT_DATA;
         }
     }
     proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_RC5;
     proto->timeout=IR_RC5_TIMEOUT;
     //support RC5-extended keeping second startbit
     //remove togglebit
     proto->data = rawbits&0x37ff; //This seems to be wrong? Does not invert second start bit and keeps first start bit
     //proto->data = (rawbits&0x07ff) | ((~rawbits)&0x0100);
     return IR_OK;
 }
 #endif
 /**
  * Used by the expandRC5 to ensure that we toggle the signal with each button press.
  */
 int8_t rc5_toggle=0;
 /**
  * Expand data from RC5 protocol
  * http://www.sbprojects.com/knowledge/ir/rc5.htm
             buf[*len]=IR_RC5_HALF_BIT;
             *len=*len+1;
             //Invert the previous bit
             previousBit = (!previousBit) & 1;
         }
     }
     //We have to handle the last bit specially since we have to
     //end with low signal on the IR diod
     if(previousBit == 0)
+    {
         //We have to remove the last time since that would bring us to a high signal again.
         *len=*len-1;
         buf[*len]=0;
     }
     proto->modfreq=IR_RC5_F_MOD;
     proto->timeout=IR_RC5_TIMEOUT;
     proto->repeats=IR_RC5_REPS;
     return IR_OK;
+}
 #if (IR_PROTOCOLS_USE_SHARP)
 /**
  * Test data on SHARP protocol
  * http://www.sbprojects.com/knowledge/ir/sharp.htm
  *
  * @param buf
  *      Pointer to buffer to where to data to parse is stored
  * @param len
  *      Length of the data
  * @param proto
  *      Pointer to protocol information
  * @return
  *      IR_OK if data parsed successfully, one of several errormessages if not
  */
     /* check if we have correct amount of data */
     if (len != 31) {
         return IR_NOT_CORRECT_DATA;
+    }
     uint16_t rawbits=0;
     for (uint8_t i = 1; i < len; i++) {
         if ((i&1) == 1) {       /* if odd, ir-pause */
             /* check length of pause between bits */
             if (buf[i] > IR_SHARP_LOW_ONE - IR_SHARP_LOW_ONE/IR_SHARP_TOL_DIV && buf[i] < IR_SHARP_LOW_ONE + IR_SHARP_LOW_ONE/IR_SHARP_TOL_DIV) {
                 /* write a one */
                 rawbits |= 1<<((i-1)>>1);
             } else if (buf[i] > IR_SHARP_LOW_ZERO - IR_SHARP_LOW_ZERO/IR_SHARP_TOL_DIV && buf[i] < IR_SHARP_LOW_ZERO + IR_SHARP_LOW_ZERO/IR_SHARP_TOL_DIV) {
                 /* do nothing, a zero is already in rawbits */
             } else {
                 return IR_NOT_CORRECT_DATA;
+            }
         } else {            /* if even, ir-bit */
             if (buf[i] > IR_SHARP_HIGH + IR_SHARP_HIGH/IR_SHARP_TOL_DIV || buf[i] < IR_SHARP_HIGH - IR_SHARP_HIGH/IR_SHARP_TOL_DIV) {
                 return IR_NOT_CORRECT_DATA;
+            }
+ *
  * @param buf
  *      Pointer to buffer to store the expanded data
  * @param len
  *      Pointer to length of the data
  * @param proto
  *      Pointer to protocol information
  * @return
  *      IR_OK if data expanded successfully, one of several errormessages if not
  */
 int8_t expandSharp(uint16_t *buf, uint8_t *len, Ir_Protocol_Data_t *proto) {
     //TODO: Implement this function.
     for (uint8_t i = 3; i < len; i++) {
         if ((i&1) == 1) {       /* if odd, ir-pause */
             /* check length of pause between bits */
             if (buf[i] > IR_NEC_LOW_ONE - IR_NEC_LOW_ONE/IR_NEC_TOL_DIV && buf[i] < IR_NEC_LOW_ONE + IR_NEC_LOW_ONE/IR_NEC_TOL_DIV) {
                 /* write a one */
                 rawbits |= 1UL<<((i-3)>>1);
             } else if (buf[i] > IR_NEC_LOW_ZERO - IR_NEC_LOW_ZERO/IR_NEC_TOL_DIV && buf[i] < IR_NEC_LOW_ZERO + IR_NEC_LOW_ZERO/IR_NEC_TOL_DIV) {
                 /* do nothing, a zero is already in place */
             } else {
                 return IR_NOT_CORRECT_DATA;
+            }
+}
 #endif
 /**
  * Expand data from NEC protocol
  * http://www.sbprojects.com/knowledge/ir/nec.htm
  *
  * @param buf
  *      Pointer to buffer to store the expanded data
  * @param len
  *      Pointer to length of the data
  * @param proto
             if ((i&1) == 1) {       /* if odd, ir-pause */
                 if ((proto->data>>(i>>1))&1) {
                     buf[i+2] = IR_NEC_LOW_ONE;
                 } else {
                     buf[i+2] = IR_NEC_LOW_ZERO;
                 }
             } else {            /* if even, ir-bit */
                 buf[i+2] = IR_NEC_HIGH;
+            }
+        }
         proto->timeout=IR_NEC_TIMEOUT;
     } else {
 #if (IR_PROTOCOLS_USE_SAMSUNG)
 /**
  * Test data on Samsung protocol
  * Very much like NEC, different start bit/pause lengths etc.
  * http://www.sbprojects.com/knowledge/ir/nec.htm
  *
  * @param buf
  *      Pointer to buffer to where to data to parse is stored
  * @param len
  *      Length of the data
  * @param proto
  *      Pointer to protocol information
  * @return
  *      IR_OK if data parsed successfully, one of several errormessages if not
 int8_t parseSamsung(const uint16_t *buf, uint8_t len, Ir_Protocol_Data_t *proto) {
     /* parse buf[], max is len */
     /* check if we have correct amount of data */
     if (len != 67) {
         return IR_NOT_CORRECT_DATA;
     }
     /* check startbit */
     if (buf[0] > IR_SAMS_ST_BIT + IR_SAMS_ST_BIT/IR_SAMS_TOL_DIV || buf[0] < IR_SAMS_ST_BIT - IR_SAMS_ST_BIT/IR_SAMS_TOL_DIV) {
         return IR_NOT_CORRECT_DATA;
+    }
     /* check pause after startbit */
     if (buf[1] > IR_SAMS_ST_PAUSE + IR_SAMS_ST_PAUSE/IR_SAMS_TOL_DIV || buf[1] < IR_SAMS_ST_PAUSE - IR_SAMS_ST_PAUSE/IR_SAMS_TOL_DIV) {
         return IR_NOT_CORRECT_DATA;
     }
     uint32_t rawbits = 0;
     for (uint8_t i = 3; i < len; i++) {
         if ((i&1) == 1) {       /* if odd, ir-pause */
             /* check length of pause between bits */
             if (buf[i] > IR_SAMS_LOW_ONE - IR_SAMS_LOW_ONE/IR_SAMS_TOL_DIV && buf[i] < IR_SAMS_LOW_ONE + IR_SAMS_LOW_ONE/IR_SAMS_TOL_DIV) {
     for (uint8_t i = 0; i < 65; i++) {
         if ((i&1) == 1) {       /* if odd, ir-pause */
             if ((proto->data>>(i>>1))&1) {
                 buf[i+2] = IR_SAMS_LOW_ONE;
             } else {
                 buf[i+2] = IR_SAMS_LOW_ZERO;
+            }
         } else {                /* if even, ir-bit */
             buf[i+2] = IR_SAMS_HIGH;
+        }
             halfbitscnt += 1;
         } else if (buf[i] > IR_MARANTZ_BIT - IR_MARANTZ_BIT/IR_MARANTZ_TOL_DIV && buf[i] < IR_MARANTZ_BIT + IR_MARANTZ_BIT/IR_MARANTZ_TOL_DIV) {
             halfbitscnt += 2;
         } else if (buf[i] > IR_MARANTZ_BIT - IR_MARANTZ_BIT/IR_MARANTZ_TOL_DIV && buf[i] < 5*IR_MARANTZ_HALF_BIT + IR_MARANTZ_BIT/IR_MARANTZ_TOL_DIV) {
             halfbitscnt += 1; //It seems to work, not entirely sure of the purpose of this long zero though.
         } else {
             return IR_NOT_CORRECT_DATA;
         }
+    }
     proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_MARANTZ;
     proto->timeout=IR_MARANTZ_TIMEOUT;
             if (previousBit == 1){//11
                 buf[*len] = IR_MARANTZ_HALF_BIT;
                 buf[*len+1] = IR_MARANTZ_HALF_BIT;
                 *len = *len + 2;
             } else {//01
                 buf[*len-1] = IR_MARANTZ_BIT;
                 buf[*len] = IR_MARANTZ_HALF_BIT;
                 *len = *len + 1;
+            }
             previousBit = 1;
         } else {
             if (previousBit == 1){//10
                 buf[*len-1] = IR_MARANTZ_BIT;
                 buf[*len] = IR_MARANTZ_HALF_BIT;
                 *len = *len + 1;
             } else {//00
                 buf[*len] = IR_MARANTZ_HALF_BIT;
                 if (i==4){
                     buf[*len+1] = IR_MARANTZ_HALF_BIT*5;
+        }
+    }
     //make sure that we finish high by removing the last zero if needed
     if (*len%2 == 0){
         *len = *len - 1;
     }
     proto->modfreq=IR_MARANTZ_F_MOD;
     proto->timeout=IR_MARANTZ_TIMEOUT;
     proto->repeats=IR_MARANTZ_REPS;
     return IR_OK;
             if (buf[i] > IR_PANA_LOW_ONE - IR_PANA_LOW_ONE/IR_PANA_TOL_DIV && buf[i] < IR_PANA_LOW_ONE + IR_PANA_LOW_ONE/IR_PANA_TOL_DIV) {
                 /* write a one */
                 rawbits |= 1UL<<((i-(3+16*2))>>1);
             } else if (buf[i] > IR_PANA_LOW_ZERO - IR_PANA_LOW_ZERO/IR_PANA_TOL_DIV && buf[i] < IR_PANA_LOW_ZERO + IR_PANA_LOW_ZERO/IR_PANA_TOL_DIV) {
                 /* do nothing, a zero is already in rawbits */
             } else {
                 return IR_NOT_CORRECT_DATA;
+            }
         } else {            /* if even, ir-bit */
             if (buf[i] > IR_PANA_HIGH + IR_PANA_HIGH/IR_PANA_TOL_DIV || buf[i] < IR_PANA_HIGH - IR_PANA_HIGH/IR_PANA_TOL_DIV) {
                 return IR_NOT_CORRECT_DATA;
+}
 #if (IR_PROTOCOLS_USE_SKY)
 /**
  * Test data on Sky protocol
  *
  *
  * @param buf
  *      Pointer to buffer to where to data to parse is stored
  * @param len
  *      Length of the data
  * @param proto
  *      Pointer to protocol information
+    {
         if (buf[i] > IR_SKY_SHORT - IR_SKY_SHORT/IR_SKY_TOL_DIV && buf[i] < IR_SKY_SHORT + IR_SKY_SHORT/IR_SKY_TOL_DIV) {
             current = SKYSHORT;
+        }
         else if (buf[i] > IR_SKY_LONG - IR_SKY_LONG/IR_SKY_TOL_DIV && buf[i] < IR_SKY_LONG + IR_SKY_LONG/IR_SKY_TOL_DIV) {
             current = SKYLONG;
         }
         else {
             return IR_NOT_CORRECT_DATA;
         }
         /* if level is low */
         if ((rawbits&1)==0) {
             /* and there is a long pulse */
             if (current == SKYLONG) {
                 /* push a one */
                 rawbits = rawbits<<1;
                 rawbits |= 1;
                 cnt = 0;
             }
             else if (cnt == 0) {
                 cnt=1;
                 /* push a zero */
                 rawbits = rawbits<<1;
+            }
             else {
                 cnt = 0;
+            }
         }
         /* if level is high */
         if ((rawbits&1)==1) {
             /* and there is a long pulse */
             if (current == SKYLONG) {
                 /* push a zero */
                 rawbits = rawbits<<1;
                 if (previous == SKYLONG) {
                     cnt = 1;
                 }
                 else {
                     cnt = 0;
                 }
             }
             else if (cnt == 0) {
                 cnt=1;
                 /* push a one */
                 rawbits = rawbits<<1;
                 rawbits |= 1;
+            }
             else {
                 cnt = 0;
+            }
     for (uint8_t i = 0; i < len; i++)
+    {
         if (buf[i] > IR_IROBOT_SHORT - IR_IROBOT_SHORT/IR_IROBOT_TOL_DIV && buf[i] < IR_IROBOT_SHORT + IR_IROBOT_SHORT/IR_IROBOT_TOL_DIV) {
             current = IROBOTSHORT;
         }
         else if (buf[i] > IR_IROBOT_LONG - IR_IROBOT_LONG/IR_IROBOT_TOL_DIV && buf[i] < IR_IROBOT_LONG + IR_IROBOT_LONG/IR_IROBOT_TOL_DIV) {
             current = IROBOTLONG;
+        }
         else {
             return IR_NOT_CORRECT_DATA;
         }
         /* if level is low */
         if ((rawbits&1)==0) {
             /* and there is a long pulse */
             if (current == IROBOTLONG) {
                 /* push a one */
                 rawbits = rawbits<<1;
                 rawbits |= 1;
                 cnt = 0;
             }
             else if (cnt == 0) {
                 cnt=1;
                 /* push a zero */
                 rawbits = rawbits<<1;
             }
             else {
                 cnt = 0;
             }
+        }
         /* if level is high */
         if ((rawbits&1)==1) {
             /* and there is a long pulse */
             if (current == IROBOTLONG) {
                 /* push a zero */
                 rawbits = rawbits<<1;
                 if (previous == IROBOTLONG) {
                     cnt = 1;
                 }
                 else {
                     cnt = 0;
                 }
+            }
             else if (cnt == 0) {
                 cnt=1;
                 /* push a one */
                 rawbits = rawbits<<1;
                 rawbits |= 1;
+            }
             else {
                 cnt = 0;
             }
         }
         previous=current;
+    }
     proto->protocol = CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_IROBOT;
     proto->timeout = IR_IROBOT_TIMEOUT;
+        }
         else
         {           /* if odd, data */
             /* check length of transmit pulse */
             if ((buf[i2] > IR_VIKING_HIGH_ONE - IR_VIKING_HIGH_ONE/IR_VIKING_TOL_DIV) && (buf[i2] < IR_VIKING_HIGH_ONE + IR_VIKING_HIGH_ONE/IR_VIKING_TOL_DIV))
             {
                 /* write a one */
                 rawbitsTemp = rawbitsTemp<<1;
                 rawbitsTemp |= 1;
             }
             else if ((buf[i2] > IR_VIKING_HIGH_ZERO - IR_VIKING_HIGH_ZERO/IR_VIKING_TOL_DIV) && (buf[i2] < IR_VIKING_HIGH_ZERO + IR_VIKING_HIGH_ZERO/IR_VIKING_TOL_DIV))
             {
                 /* do nothing, a zero is already in rawbits */
                 rawbitsTemp = rawbitsTemp<<1;
             }
             else
             {
                 return IR_NOT_CORRECT_DATA;
             }
+        }
+    }
     rawbitsTemp = ~rawbitsTemp;
     rawbitsTemp = rawbitsTemp&0xFFFFFFFFFF;
     proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_VIKING;
     proto->timeout=0;
     proto->data=rawbitsTemp;
     return IR_OK;
     return IR_NOT_CORRECT_DATA;
 #endif
+}
 #endif
 #if (IR_PROTOCOLS_USE_VIKING_STEAK)
 /**
  * Test data on Viking steak temperature sensor protocol
+ *
+ *
+ *
+ * @param buf
+ *      Pointer to buffer to where to data to parse is stored
+ * @param len
+ *      Length of the data
+ * @param proto
+ *      Pointer to protocol information
+ * @return
+ *      IR_OK if data parsed successfully, one of several errormessages if not
+ */
+int8_t parseVikingSteak(const uint16_t *buf, uint8_t len, uint8_t index, Ir_Protocol_Data_t *proto)
+{
+#if IR_RX_CONTINUOUS_MODE==1
+    /* check if we have correct amount of data */
+    if (len < 74) {
+        return IR_NOT_CORRECT_DATA;
+    }
+    uint8_t i, i2;
+    uint64_t rawbitsTemp = 0;//0xffffffffffffffff;
+    /* Check start bit condition */
+    i2=index-74;
+    if (i2>index)
+        i2+=MAX_NR_TIMES;
+    proto->data=i2;     /*Store startindex for debug output */
+    if ((buf[i2] < IR_VIKING_STEAK_LOW_START - IR_VIKING_STEAK_LOW_START/IR_VIKING_STEAK_TOL_DIV) || (buf[i2] > IR_VIKING_STEAK_LOW_START + IR_VIKING_STEAK_LOW_START/IR_VIKING_STEAK_TOL_DIV))
+    {
+        return IR_NOT_CORRECT_DATA;
+    }
+    for (i = 73; i > 0; i--)
+    {
+        i2=index-i;
+        if (i2>index)
+            i2+=MAX_NR_TIMES;
+        /* Check if correct amount of data have been received */
+        //if ((i == 78) && (rawbitsTemp != 0b00001))
+        //  return IR_NOT_CORRECT_DATA;
+        if ((i&1) != 0)
+        {       /* if odd, no data */
+            if ((buf[i2] < IR_VIKING_STEAK_HIGH - IR_VIKING_STEAK_HIGH/IR_VIKING_STEAK_TOL_DIV) || (buf[i2] > IR_VIKING_STEAK_HIGH + IR_VIKING_STEAK_HIGH/IR_VIKING_STEAK_TOL_DIV))
+            {
+                return IR_NOT_CORRECT_DATA;
+            }
+        }
+        else
+        {           /* if even, data */
+            /* check length of transmit pulse */
+            if ((buf[i2] > IR_VIKING_STEAK_LOW_ONE - IR_VIKING_STEAK_LOW_ONE/IR_VIKING_STEAK_TOL_DIV) && (buf[i2] < IR_VIKING_STEAK_LOW_ONE + IR_VIKING_STEAK_LOW_ONE/IR_VIKING_STEAK_TOL_DIV))
+            {
+                /* write a one */
+                rawbitsTemp = rawbitsTemp<<1;
+                rawbitsTemp |= 1;
+            }
+            else if ((buf[i2] > IR_VIKING_STEAK_LOW_ZERO - IR_VIKING_STEAK_LOW_ZERO/IR_VIKING_STEAK_TOL_DIV) && (buf[i2] < IR_VIKING_STEAK_LOW_ZERO + IR_VIKING_STEAK_LOW_ZERO/IR_VIKING_STEAK_TOL_DIV))
+            {
+                /* do nothing, a zero is already in rawbits */
+                rawbitsTemp = rawbitsTemp<<1;
+            }
+            else
+            {
+                return IR_NOT_CORRECT_DATA;
+            }
+        }
+    }
+    //rawbitsTemp = ~rawbitsTemp;
+    //rawbitsTemp = rawbitsTemp&0xFFFFFFFFFF;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_VIKINGSTEAK;
+    proto->timeout=IR_VIKING_STEAK_TIMEOUT;
+    proto->data=rawbitsTemp;
+    return IR_OK;
+#else
+    return IR_NOT_CORRECT_DATA;
+#endif
+}
+#endif
+#if (IR_PROTOCOLS_USE_RUBICSON)
+/**
+ * Test data on Rubicson temperature sensor protocol
  *
  *
  *
  * @param buf
  *      Pointer to buffer to where to data to parse is stored
  * @param len
  *      Length of the data
  * @param proto
  *      Pointer to protocol information
  * @return
  *      IR_OK if data parsed successfully, one of several errormessages if not
  */
-int8_t parseVikingSteak(const uint16_t *buf, uint8_t len, uint8_t index, Ir_Protocol_Data_t *proto)
+int8_t parseRubicson(const uint16_t *buf, uint8_t len, uint8_t index, Ir_Protocol_Data_t *proto)
+{
 #if IR_RX_CONTINUOUS_MODE==1
     /* check if we have correct amount of data */
     if (len < 74) {
         return IR_NOT_CORRECT_DATA;
     uint8_t i, i2;
     uint64_t rawbitsTemp = 0;//0xffffffffffffffff;
     /* Check start bit condition */
     i2=index-74;
     if (i2>index)
         i2+=MAX_NR_TIMES;
     proto->data=i2;     /*Store startindex for debug output */
-    if ((buf[i2] < IR_VIKING_STEAK_LOW_START - IR_VIKING_STEAK_LOW_START/IR_VIKING_STEAK_TOL_DIV) || (buf[i2] > IR_VIKING_STEAK_LOW_START + IR_VIKING_STEAK_LOW_START/IR_VIKING_STEAK_TOL_DIV))
+    if ((buf[i2] < IR_RUBICSON_LOW_START - IR_RUBICSON_LOW_START/IR_RUBICSON_TOL_DIV) || (buf[i2] > IR_RUBICSON_LOW_START + IR_RUBICSON_LOW_START/IR_RUBICSON_TOL_DIV))
     {
         return IR_NOT_CORRECT_DATA;
     }
     for (i = 73; i > 0; i--)
+    {
         i2=index-i;
         if (i2>index)
         //if ((i == 78) && (rawbitsTemp != 0b00001))
         //  return IR_NOT_CORRECT_DATA;
         if ((i&1) != 0)
         {       /* if odd, no data */
-            if ((buf[i2] < IR_VIKING_STEAK_HIGH - IR_VIKING_STEAK_HIGH/IR_VIKING_STEAK_TOL_DIV) || (buf[i2] > IR_VIKING_STEAK_HIGH + IR_VIKING_STEAK_HIGH/IR_VIKING_STEAK_TOL_DIV))
+            if ((buf[i2] < IR_RUBICSON_HIGH - IR_RUBICSON_HIGH/IR_RUBICSON_TOL_DIV) || (buf[i2] > IR_RUBICSON_HIGH + IR_RUBICSON_HIGH/IR_RUBICSON_TOL_DIV))
             {
                 return IR_NOT_CORRECT_DATA;
             }
         }
         else
         {           /* if even, data */
             /* check length of transmit pulse */
-            if ((buf[i2] > IR_VIKING_STEAK_LOW_ONE - IR_VIKING_STEAK_LOW_ONE/IR_VIKING_STEAK_TOL_DIV) && (buf[i2] < IR_VIKING_STEAK_LOW_ONE + IR_VIKING_STEAK_LOW_ONE/IR_VIKING_STEAK_TOL_DIV))
+            if ((buf[i2] > IR_RUBICSON_LOW_ONE - IR_RUBICSON_LOW_ONE/IR_RUBICSON_TOL_DIV) && (buf[i2] < IR_RUBICSON_LOW_ONE + IR_RUBICSON_LOW_ONE/IR_RUBICSON_TOL_DIV))
             {
                 /* write a one */
                 rawbitsTemp = rawbitsTemp<<1;
                 rawbitsTemp |= 1;
             }
-            else if ((buf[i2] > IR_VIKING_STEAK_LOW_ZERO - IR_VIKING_STEAK_LOW_ZERO/IR_VIKING_STEAK_TOL_DIV) && (buf[i2] < IR_VIKING_STEAK_LOW_ZERO + IR_VIKING_STEAK_LOW_ZERO/IR_VIKING_STEAK_TOL_DIV))
+            else if ((buf[i2] > IR_RUBICSON_LOW_ZERO - IR_RUBICSON_LOW_ZERO/IR_RUBICSON_TOL_DIV) && (buf[i2] < IR_RUBICSON_LOW_ZERO + IR_RUBICSON_LOW_ZERO/IR_RUBICSON_TOL_DIV))
             {
                 /* do nothing, a zero is already in rawbits */
                 rawbitsTemp = rawbitsTemp<<1;
             }
             else
+            {
                 return IR_NOT_CORRECT_DATA;
+            }
+        }
+    }
     //rawbitsTemp = ~rawbitsTemp;
     //rawbitsTemp = rawbitsTemp&0xFFFFFFFFFF;
-    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_VIKINGSTEAK;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_RUBICSON;
-    proto->timeout=IR_VIKING_STEAK_TIMEOUT;
+    proto->timeout=IR_RUBICSON_TIMEOUT;
     proto->data=rawbitsTemp;
     return IR_OK;
 #else
     return IR_NOT_CORRECT_DATA;
 #endif
+}
 #endif
-#if (IR_PROTOCOLS_USE_RUBICSON)
+#if (IR_PROTOCOLS_USE_OREGON)
 /**
- * Test data on Rubicson temperature sensor protocol
+ * Test data on OREGON weather sensor protocol
  *
+ *
+ *
  * @param buf
  *      Pointer to buffer to where to data to parse is stored
  * @param len
  * @param proto
  *      Pointer to protocol information
  * @return
  *      IR_OK if data parsed successfully, one of several errormessages if not
  */
-int8_t parseRubicson(const uint16_t *buf, uint8_t len, uint8_t index, Ir_Protocol_Data_t *proto)
+int8_t parseOregon(const uint16_t *buf, uint8_t len, uint8_t index, Ir_Protocol_Data_t *proto)
 {
 #if IR_RX_CONTINUOUS_MODE==1
     /* check if we have correct amount of data */
-    if (len < 74) {
-        return IR_NOT_CORRECT_DATA;
-    }
-    uint8_t i, i2;
-    uint64_t rawbitsTemp = 0;//0xffffffffffffffff;
-    /* Check start bit condition */
+    if (len < 74) { //Ändra till vettigt värde
-    i2=index-74;
-    if (i2>index)
-        i2+=MAX_NR_TIMES;
-    proto->data=i2;     /*Store startindex for debug output */
-    if ((buf[i2] < IR_RUBICSON_LOW_START - IR_RUBICSON_LOW_START/IR_RUBICSON_TOL_DIV) || (buf[i2] > IR_RUBICSON_LOW_START + IR_RUBICSON_LOW_START/IR_RUBICSON_TOL_DIV))
-    {
         return IR_NOT_CORRECT_DATA;
+    }
+    uint8_t data[IR_OREGON_DATASIZE]; //Verifiera minsta möjliga storlek
+    uint8_t i2 = 0;
+    uint8_t b_i;
+    uint8_t currentBit = 0;
+    uint8_t done = 0;
+    uint8_t invert = 0;
+    uint8_t shift = 0;
+    uint8_t i = index;
+    uint64_t rawbitsTemp = 0;//0xffffffffffffffff;
-    for (i = 73; i > 0; i--)
-    {
-        i2=index-i;
-        if (i2>index)
-            i2+=MAX_NR_TIMES;
-        /* Check if correct amount of data have been received */
+    /* Check stop condition */
-        //if ((i == 78) && (rawbitsTemp != 0b00001))
-        //  return IR_NOT_CORRECT_DATA;
+    if (buf[i] < IR_OREGON_END)
-        if ((i&1) != 0)
-        {       /* if odd, no data */
-            if ((buf[i2] < IR_RUBICSON_HIGH - IR_RUBICSON_HIGH/IR_RUBICSON_TOL_DIV) || (buf[i2] > IR_RUBICSON_HIGH + IR_RUBICSON_HIGH/IR_RUBICSON_TOL_DIV))
+    {
-                return IR_NOT_CORRECT_DATA;
+        return IR_NOT_CORRECT_DATA;
+    }
-        }
+    i--; //set index to last bit
-        else
+    len--; //Store remaining length
-        {           /* if even, data */
+    //loop to store data
+    while (done == 0) { //Wait for sync pulse and preamble, loop for all bytes
-            /* check length of transmit pulse */
+        for (b_i = 0;b_i<8;b_i++) { //loop for each bit
-            if ((buf[i2] > IR_RUBICSON_LOW_ONE - IR_RUBICSON_LOW_ONE/IR_RUBICSON_TOL_DIV) && (buf[i2] < IR_RUBICSON_LOW_ONE + IR_RUBICSON_LOW_ONE/IR_RUBICSON_TOL_DIV))
+            if (((buf[i] < IR_OREGON_SHORT_L) && (buf[i] > IR_OREGON_SHORT_S)) ) {
-            {
+                i--;
+                if (i > MAX_NR_TIMES) i = MAX_NR_TIMES - 1;
+                if (((buf[i] < IR_OREGON_SHORT_L) && (buf[i] > IR_OREGON_SHORT_S))) {
-                /* write a one */
+                    //Keep previous bit value
-                rawbitsTemp = rawbitsTemp<<1;
+                    data[i2] = data[b_i] << 1;
-                rawbitsTemp |= 1;
+                    data[i2] += currentBit;
-            }
+                    i--;
-            else if ((buf[i2] > IR_RUBICSON_LOW_ZERO - IR_RUBICSON_LOW_ZERO/IR_RUBICSON_TOL_DIV) && (buf[i2] < IR_RUBICSON_LOW_ZERO + IR_RUBICSON_LOW_ZERO/IR_RUBICSON_TOL_DIV))
+                    if (i > MAX_NR_TIMES) i = MAX_NR_TIMES - 1;
+                } else { return IR_NOT_CORRECT_DATA;}
-            {
+            }
+            else if (((buf[i] < IR_OREGON_LONG_L) && (buf[i] > IR_OREGON_LONG_S))) {
-                /* do nothing, a zero is already in rawbits */
+                //Invert previous bit value
-                rawbitsTemp = rawbitsTemp<<1;
+                if (currentBit)
-            }
+                    currentBit = 0;
-            else
+                else
+                    currentBit = 1;
+                data[i2] = data[b_i] << 1;
+                data[i2] += currentBit;
+                i--;
+                if (i > MAX_NR_TIMES) i = MAX_NR_TIMES - 1;
+            }
+            else { return IR_NOT_CORRECT_DATA;}
+        }
+        //swap nibbles to make parsing easier
+        uint8_t temp = data[i2] << 4;
+        data[i2] = (data[i2] >> 4) + temp;
+        //check for end condition
+        if (i2 > 6) { // TODO check what value to use here
+            if (data[i2] == 0xFFu && data[i2-1] == 0xFAu) {
+                done = 1;
+            }
+            if (data[i2] == 0x00u && data[i2-1] == 0x05u) {
+                done = 1;
+                invert = 1;
+            }
+            if (data[i2] == 0xFFu && (data[i2-1]&0xF0u) == 0xA0u) {
+                shift = 1;
+                done = 1;
+            }
+            if (data[i2] == 0x00u && (data[i2-1]&0xF0u) == 0x50u) {
+                shift = 1;
+                done = 1;
+                invert = 1;
+            }
+        }
+        i2++;
+        if (i2 >= IR_OREGON_DATASIZE)
+        {
+            return IR_NOT_CORRECT_DATA;
+        }
+    }
+    i2--; //restore index
+    if (invert == 1) {
+        for (b_i = 0;b_i<=i2;b_i++) { //loop for each byte
+            data[b_i] ^= 0xFFu;
+        }
+    }
+    if (shift == 1) {
+        for (b_i = i2;b_i>0;b_i--) { //loop for each byte
+            data[b_i] = (data[b_i] << 4) + (data[(b_i - 1)] & 0x0Fu);
+        }
+        data[0] = data[0] << 4;
+        i2--; //remove sync byte
+    } else {
+        i2--; //remove sync byte
+        i2--; //remove sync byte
+    }
+    switch (data[i2]) {
+        case 0x19u:
+            if (data[i2-1] == 0x84 || data[i2-1] == 0x94 ) { //Anemometer
+                i2-=2; //Remove Sensor id
+                rawbitsTemp = 0x100000000000uL; //Anemometer id
+                rawbitsTemp |= ((uint64_t)(data[i2]&0xF0u)) << 36; //store channel as MSB
+                i2--;
+                if (data[i2] == 0x4u)
+                    rawbitsTemp |= 0x080000000000uL; //Bat Low flag
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2]&0xF0u)) << 28; //store wind direction 0x0->0xF
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2]&0x0Fu)) << 24; //store current wind speed
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 16; //store current wind speed
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 8; //store average wind speed
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2]&0xF0u)) << 0; //store current wind speed
+            } else {
+                return IR_NOT_CORRECT_DATA;
+            }
+            break;
+        case 0x1Du:
+        case 0xF8u:
+            if (data[i2-1] == 0x20 || data[i2-1] == 0x24 || data[i2-1] == 0xB4 ) { //Temperature/humidity
+                i2-=2; //Remove Sensor id
+                rawbitsTemp = 0x200000000000uL; //Temp/humidity id
+                rawbitsTemp |= ((uint64_t)(data[i2]&0xF0u)) << 36; //store channel as MSB
+                i2--;
+                if (data[i2] == 0x4u)
+                    rawbitsTemp |= 0x080000000000uL; //Bat Low flag
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 16; //store temp
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 8; //store temp and temp sign
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 0; //store humidity
+            } else {
                 return IR_NOT_CORRECT_DATA;
             }
+            break;
+        case 0x29u:
+            if (data[i2-1] == 0x14) { //Rain Gauge (inches)
+                i2-=2; //Remove Sensor id
+                rawbitsTemp = 0x300000000000uL; //Rain inches id
+                rawbitsTemp |= ((uint64_t)(data[i2]&0xF0u)) << 36; //store channel as MSB
+                i2--;
+                if (data[i2] == 0x4u)
+                    rawbitsTemp |= 0x080000000000uL; //Bat Low flag
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 32; //Rain per hour
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 24; //Rain per hour
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 16; //store total rain
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 8; //store total rain
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 0; //store total rain
+            } else {
+                return IR_NOT_CORRECT_DATA;
+            }
+            break;
+        case 0x2Du:
+            if (data[i2-1] == 0x10) { //Rain Gauge (mm)
+                i2-=2; //Remove Sensor id
+                rawbitsTemp = 0x400000000000uL; //Rain mm id
+                rawbitsTemp |= ((uint64_t)(data[i2]&0xF0u)) << 36; //store channel as MSB
+                i2--;
+                if (data[i2] == 0x4u)
+                    rawbitsTemp |= 0x080000000000uL; //Bat Low flag
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 32; //Rain per hour
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 24; //Rain per hour
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 16; //store total rain
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 8; //store total rain
+                i2--;
+                rawbitsTemp |= ((uint64_t)(data[i2])) << 0; //store total rain
+            } else {
+                return IR_NOT_CORRECT_DATA;
+            }
+            break;
+        default:
+            return IR_NOT_CORRECT_DATA;
+            break;
+    }
-    //rawbitsTemp = ~rawbitsTemp;
-    //rawbitsTemp = rawbitsTemp&0xFFFFFFFFFF;
-    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_RUBICSON;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_OREGON;
-    proto->timeout=IR_RUBICSON_TIMEOUT;
+    proto->timeout=IR_OREGON_TIMEOUT;
     proto->data=rawbitsTemp;
     return IR_OK;
 #else
     return IR_NOT_CORRECT_DATA;
 #endif
+}
 #endif

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/avr-lib/drivers/ir/protocols.c – Rev 2246 → 2254