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

 #if (IR_PROTOCOLS_USE_NEXA1)
     if (parseNexa1(buf, len, index, proto)==IR_OK) return IR_OK;
 #endif
 #if (IR_PROTOCOLS_USE_VIKING)
     if (parseViking(buf, len, index, proto)==IR_OK) return IR_OK;
+#endif
+#if (IR_PROTOCOLS_USE_VIKING_T3)
+    if (parseVikingT3(buf, len, index, proto)==IR_OK) return IR_OK;
 #endif
 #if (IR_PROTOCOLS_USE_VIKING_STEAK)
     res = parseVikingSteak(buf, len, index, proto);
     if (res!=IR_NOT_CORRECT_DATA) return res;
 #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);
     gpio_clr_pin(EXP_K);
     gpio_clr_pin(EXP_L);
     gpio_clr_pin(EXP_M);
     gpio_clr_pin(EXP_N);
     if (res!=IR_NOT_CORRECT_DATA) return res;
 #endif
     /* No protocol matched. */
     proto->protocol = IR_PROTO_UNKNOWN;
     return IR_NOT_CORRECT_DATA;
+}
 int8_t parseHash(const uint16_t *buf, uint8_t len, Ir_Protocol_Data_t *proto) {
     //TODO: Transform the buffer in some clever way to a 32 bit word. */
     proto->protocol = IR_PROTO_HASH;
 #endif
 /**
  * Expand data from SIRC protocol
  * http://www.sbprojects.com/knowledge/ir/sirc.htm
  *
  * @param buf
  *      Pointer to buffer to store the expanded data
  * @param len
  *      Pointer to length of the data
  * @param proto
 #if (IR_PROTOCOLS_USE_RC5)
 /**
  * Test data on RC5 protocol
  * http://www.sbprojects.com/knowledge/ir/rc5.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 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 */
             rawbits |= (1<<(13-(halfbitscnt>>1)));
+        }
         if (buf[i] > IR_RC5_HALF_BIT - IR_RC5_HALF_BIT/IR_RC5_TOL_DIV && buf[i] < IR_RC5_HALF_BIT + IR_RC5_HALF_BIT/IR_RC5_TOL_DIV) {
             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
         *len = 4;
         previousBit = 0; //Toggled from last startbit
+    }
     //Invert the toggle for next time
     rc5_toggle=!rc5_toggle & 1;
     //Decode the message
     //We know that RC5 messages are 14 bits long
     for(uint8_t pos=11;pos>0;pos--)
+    {
         // Check the current bit
+        }
+    }
     proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_SHARP;
     proto->timeout=IR_SHARP_TIMEOUT;
     proto->data=rawbits;
     return IR_OK;
 }
 #endif
 /**
  * Expand data from Sharp protocol
  * http://www.sbprojects.com/knowledge/ir/sharp.htm
+ *
  * @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.
     return IR_NOT_CORRECT_DATA;
 }
 #if (IR_PROTOCOLS_USE_NEC)
 /**
  * Test data on NEC protocol
  * http://www.sbprojects.com/knowledge/ir/nec.htm
  *      Pointer to protocol information
  * @return
  *      IR_OK if data parsed successfully, one of several errormessages if not
  */
 int8_t parseNEC(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_NEC_ST_BIT + IR_NEC_ST_BIT/IR_NEC_TOL_DIV || buf[0] < IR_NEC_ST_BIT - IR_NEC_ST_BIT/IR_NEC_TOL_DIV) {
         return IR_NOT_CORRECT_DATA;
     }
     /* check pause after startbit */
     if (buf[1] > IR_NEC_ST_PAUSE + IR_NEC_ST_PAUSE/IR_NEC_TOL_DIV || buf[1] < IR_NEC_ST_PAUSE - IR_NEC_ST_PAUSE/IR_NEC_TOL_DIV) {
         return IR_NOT_CORRECT_DATA;
+    }
     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;
+            }
         *len = 3;
+    }
     proto->modfreq=IR_NEC_F_MOD;
     proto->repeats=IR_NEC_REPS;
     return IR_OK;
 }
 #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
 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) {
                 /* write a one */
                 rawbits |= 1UL<<((i-3)>>1);
             } else if (buf[i] > IR_SAMS_LOW_ZERO - IR_SAMS_LOW_ZERO/IR_SAMS_TOL_DIV && buf[i] < IR_SAMS_LOW_ZERO + IR_SAMS_LOW_ZERO/IR_SAMS_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_SAMS_HIGH + IR_SAMS_HIGH/IR_SAMS_TOL_DIV || buf[i] < IR_SAMS_HIGH - IR_SAMS_HIGH/IR_SAMS_TOL_DIV) {
                 return IR_NOT_CORRECT_DATA;
             }
         }
     }
     proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_SAMSUNG;
     proto->timeout=IR_SAMS_TIMEOUT;
     proto->data=rawbits;
     return IR_OK;
+}
     *len = 67;
     proto->modfreq=IR_SAMS_F_MOD;
     proto->timeout=IR_SAMS_TIMEOUT;
     proto->repeats=IR_SAMS_REPS;
     return IR_OK;
 }
 #if (IR_PROTOCOLS_USE_MARANTZ)
 /**
  * Test data on Marantz protocol
  * Reverse-Engineered by Noddan, very similar to RC-5.
             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
+}
 #if (IR_PROTOCOLS_USE_PANASONIC)
 /**
  * Test data on Panasonic 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 parsePanasonic(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 != 99) {
         return IR_NOT_CORRECT_DATA;
+    }
     /* check startbit */
     if (buf[0] > IR_PANA_ST_BIT + IR_PANA_ST_BIT/IR_PANA_TOL_DIV || buf[0] < IR_PANA_ST_BIT - IR_PANA_ST_BIT/IR_PANA_TOL_DIV) {
         return IR_NOT_CORRECT_DATA;
     }
     /* check pause after startbit */
     if (buf[1] > IR_PANA_ST_PAUSE + IR_PANA_ST_PAUSE/IR_PANA_TOL_DIV || buf[1] < IR_PANA_ST_PAUSE - IR_PANA_ST_PAUSE/IR_PANA_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 expandPanasonic(uint16_t *buf, uint8_t *len, Ir_Protocol_Data_t *proto) {
     /* Set up startbit */
     buf[0] = IR_PANA_ST_BIT;
             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;
+            }
     /* parse buf[], max is len */
     uint8_t i;
     /* check if we have correct amount of data */
     if (len < 50) {
         return IR_NOT_CORRECT_DATA;
     }
 #if IR_RX_CONTINUOUS_MODE==0
     i = 0;
 #else
     i=index-50;
     if (i>index)
         i+=MAX_NR_TIMES;
 #endif
     if (buf[i] < IR_NEXA1_START - IR_NEXA1_START/IR_NEXA1_TOL_DIV || buf[i] > IR_NEXA1_START + IR_NEXA1_START/IR_NEXA1_TOL_DIV) { //check start bit
         uint8_t i2;
 #if IR_RX_CONTINUOUS_MODE==0
         i2 = i;
 #else
         i2=index-(50-i);
         if (i2>index)
             i2+=MAX_NR_TIMES;
 #endif
         /* Check if '0' bit */
         if (
             (buf[i2+0] > IR_NEXA1_SHORT - IR_NEXA1_SHORT/IR_NEXA1_TOL_DIV) && (buf[i2+0] < IR_NEXA1_SHORT + IR_NEXA1_SHORT/IR_NEXA1_TOL_DIV) &&
             (buf[i2+1] > IR_NEXA1_LONG  - IR_NEXA1_LONG /IR_NEXA1_TOL_DIV) && (buf[i2+1] < IR_NEXA1_LONG  + IR_NEXA1_LONG /IR_NEXA1_TOL_DIV) &&
             (buf[i2+3] > IR_NEXA1_SHORT - IR_NEXA1_SHORT/IR_NEXA1_TOL_DIV) && (buf[i2+3] < IR_NEXA1_SHORT + IR_NEXA1_SHORT/IR_NEXA1_TOL_DIV) )
+        {
             /* do nothing, a zero is already in rawbits */
             bitCounter++;
+        }
         else
         {
             return IR_NOT_CORRECT_DATA;
         }
     }
     if (rawbitsTemp==0)
+    {
         /* Bogus RF data */
         return IR_NOT_CORRECT_DATA;
     }
     proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_NEXA;
     proto->timeout=IR_NEXA1_TIMEOUT;
     proto->data=rawbitsTemp;
     return IR_OK;
+}
 #endif
 /**
  * Expand data from Nexa1 protocol
+ *
  *
  * @param buf
  *      Pointer to buffer to store the expanded data
  * @param len
  *      Pointer to length of the data
  * @param proto
     /* encode data bits */
     for (uint8_t i = 0; i < 45; i += 4)
+    {
         if (tempshift & 1) {
             /* encode 0 bit */
             buf[i+0] = IR_NEXA1_SHORT;
             buf[i+1] = IR_NEXA1_LONG;
             buf[i+2] = IR_NEXA1_SHORT;
             buf[i+3] = IR_NEXA1_LONG;
         } else {
             /* encode X bit */
             buf[i+1] = IR_NEXA1_LONG;
             buf[i+2] = IR_NEXA1_LONG;
             buf[i+3] = IR_NEXA1_SHORT;
+        }
         tempshift = tempshift>>1;
     }
     /* encode stop/sync bit */
     buf[48] = IR_NEXA1_SHORT;
     proto->modfreq = IR_NEXA1_F_MOD;
     proto->timeout = IR_NEXA1_START/1000;
     proto->repeats = IR_NEXA1_REPS;
     return IR_OK;
 }
 #if (IR_PROTOCOLS_USE_VIKING)
 /**
- * Test data on Viking temperature sensor protocol
+ * Test data on Viking sensor protocol
+ * This is protocol type 4 (temperature with sign and one more byte)
+ *
  *
+ * @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 parseViking(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 < 90) {
+        return IR_NOT_CORRECT_DATA;
+    }
+    uint8_t i, i2;
+    uint64_t rawbitsTemp = 0;//0xffffffffffffffff;
+    for (i = 90; 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;
+/* Only check type if we have separate support for type 3 */
+#if (IR_PROTOCOLS_USE_VIKING_T3)
+        /* Check type, only allow type=4 (3 inverted) */
+        if ((i == 72) && (rawbitsTemp != 0b00001011))
+            return IR_NOT_CORRECT_DATA;
+#endif
+        if ((i&1) == 0)
+        {       /* if even, no data */
+            if ((buf[i2] < IR_VIKING_LOW - IR_VIKING_LOW/IR_VIKING_TOL_DIV) || (buf[i2] > IR_VIKING_LOW + IR_VIKING_LOW/IR_VIKING_TOL_DIV))
+            {
+                return IR_NOT_CORRECT_DATA;
+            }
+        }
+        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;
+#else
+    return IR_NOT_CORRECT_DATA;
+#endif
+}
+#endif
+#if (IR_PROTOCOLS_USE_VIKING_T3)
+/**
+ * Test data on Viking sensor protocol
+ * This is protocol type 3 (offseted temperature with three bytes)
+ *
+ *
  * @param buf
  *      Pointer to buffer to where to data to parse is stored
  * @param len
  *      Pointer to protocol information
  * @return
  *      IR_OK if data parsed successfully, one of several errormessages if not
  */
-int8_t parseViking(const uint16_t *buf, uint8_t len, uint8_t index, Ir_Protocol_Data_t *proto)
+int8_t parseVikingT3(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 < 90) {
+    if (len < 106) {
         return IR_NOT_CORRECT_DATA;
+    }
     uint8_t i, i2;
     uint64_t rawbitsTemp = 0;//0xffffffffffffffff;
+    //uint8_t rawbitsTempArr[6] = {0,0,0,0,0,0};
+    for (i = 106; i > 16; i--)
+    {
+        i2=index-i;
+        if (i2>index)
+            i2+=MAX_NR_TIMES;
+        /* Check if correct amount of data have been received */
+        if ((i == 94) && (rawbitsTemp != 0b00001))
+            return IR_NOT_CORRECT_DATA;
+        /* Check type, only allow type=3 (4 inverted) */
+        if ((i == 88) && (rawbitsTemp != 0b00001100))
+            return IR_NOT_CORRECT_DATA;
+        if ((i&1) == 0)
+        {       /* if even, no data */
+            if ((buf[i2] < IR_VIKING_LOW - IR_VIKING_LOW/IR_VIKING_TOL_DIV) || (buf[i2] > IR_VIKING_LOW + IR_VIKING_LOW/IR_VIKING_TOL_DIV))
+            {
+                return IR_NOT_CORRECT_DATA;
+            }
+        }
+        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;
+            }
+        }
+    }
+    uint16_t rest = 0;
-    for (i = 90; i > 0; i--)
+    for (i = 16; 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 even, no data */
             if ((buf[i2] < IR_VIKING_LOW - IR_VIKING_LOW/IR_VIKING_TOL_DIV) || (buf[i2] > IR_VIKING_LOW + IR_VIKING_LOW/IR_VIKING_TOL_DIV))
             {
                 return IR_NOT_CORRECT_DATA;
             }
         }
         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;
+                rest = rest<<1;
-                rawbitsTemp |= 1;
+                rest |= 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;
+                rest = rest<<1;
+            }
             else
+            {
                 return IR_NOT_CORRECT_DATA;
+            }
+        }
     }
+    rest = ~rest;
+    //rest = rest&0xFF;
     rawbitsTemp = ~rawbitsTemp;
     rawbitsTemp = rawbitsTemp&0xFFFFFFFFFF;
+    uint8_t crc = 0;
+    crc = _crc_ibutton_update(crc, 0xFF);
+    crc = _crc_ibutton_update(crc, rawbitsTemp&0xFF);
+    crc = _crc_ibutton_update(crc, (rawbitsTemp>>8)&0xFF);
+    crc = _crc_ibutton_update(crc, (rawbitsTemp>>16)&0xFF);
+    crc = _crc_ibutton_update(crc, (rawbitsTemp>>24)&0xFF);
+    crc = _crc_ibutton_update(crc, (rawbitsTemp>>32)&0xFF);
+    //crc = _crc_ibutton_update(crc, (rawbitsTemp>>40)&0xFF);
+    rawbitsTemp = rawbitsTemp&0xFFFFFF0000;
+    rawbitsTemp |= (crc<<8)|((rest>>8)&0xFF);
     proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_VIKING;
     proto->timeout=0;
     proto->data=rawbitsTemp;

Subversion Repositories HomeAutomation

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