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

+ *
  */
 #include "protocols.h"
 #include <bios.h>
+#include <drivers/mcu/gpio.h>
 int8_t parseProtocol(const uint16_t *buf, uint8_t len, Ir_Protocol_Data_t *proto) {
     proto->protocol=IR_PROTO_UNKNOWN;
     proto->data=0;
     proto->timeout=100;
         return expandPanasonic(buf, len, proto);
     case IR_PROTO_SKY:
         return expandSky(buf, len, proto);
+    }
     /* 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
  *      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 parseSIRC(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.
            supporting two versions of SIRC:
 bit = 25, 15 bit = 31
            there is also a 20 bit protocol, but we don't support it
          */
         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 ((i&1) == 1) {       /* if odd, ir-pause */
             /* check length of pause between bits */
             if (buf[i] > IR_SIRC_LOW + IR_SIRC_LOW/IR_SIRC_TOL_DIV || buf[i] < IR_SIRC_LOW - IR_SIRC_LOW/IR_SIRC_TOL_DIV) {
                 return IR_NOT_CORRECT_DATA;
             }
         } else {            /* if even, ir-bit */
             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 = IR_PROTO_SIRC;
     proto->timeout = IR_SIRC_TIMEOUT;
     proto->data = rawbits;
     return IR_OK;
+}
 #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
  *      Pointer to protocol information
  * @return
  *      IR_OK if data expanded successfully, one of several errormessages if not
  */
         /* Assume 12 bit protocol */
         *len = 25;
         /* If data to big, use 15 bit protocol */
         if (proto->data > (1<<11)) { // cannot be represented by 12 bits
           *len = 31;
         }
         for (uint8_t i = 0; i < *len-2; i++) {
           if ((i&1) == 1) {     /* if odd, ir-pause */
             buf[i+2] = IR_SIRC_LOW;
           } else {          /* if even, ir-bit */
             if ((proto->data>>(i>>1))&1) {
+ *
  * @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) {
         //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 {
  *      Pointer to protocol information
  * @return
  *      IR_OK if data expanded successfully, one of several errormessages if not
  */
 int8_t expandRC5(uint16_t *buf, uint8_t *len, Ir_Protocol_Data_t *proto) {
     //This is the raw message that we should create the IR times for
     //Lets copy the data locally to ensure that no interups will modify the vector.
     uint16_t rawMessage=proto->data & 0x3fff;
     uint8_t previousBit;
         //and extend the time into this bit.
         buf[2] = IR_RC5_BIT;
         buf[3] = IR_RC5_HALF_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
+        }
+    }
     proto->protocol=IR_PROTO_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
+ *
  * @param buf
  *      Pointer to buffer to store the expanded data
  * @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
             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;
             }
         } else {            /* if even, ir-bit */
             if (buf[i] > IR_NEC_HIGH + IR_NEC_HIGH/IR_NEC_TOL_DIV || buf[i] < IR_NEC_HIGH - IR_NEC_HIGH/IR_NEC_TOL_DIV) {
                 return IR_NOT_CORRECT_DATA;
+            }
+        }
     }
     proto->protocol=IR_PROTO_NEC;
     proto->timeout=IR_NEC_TIMEOUT;
     proto->data=rawbits;
     return IR_OK;
+}
 #endif
 /**
  * Expand data from NEC protocol
  * http://www.sbprojects.com/knowledge/ir/nec.htm
+ *
  * @param buf
         proto->timeout=IR_NEC_ST_TIMEOUT;
         *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
         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 */
             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=IR_PROTO_SAMS;
     proto->timeout=IR_SAMS_TIMEOUT;
     proto->data=rawbits;
     return IR_OK;
+}
 #endif
 /**
  * Expand data from Samsung protocol
  * Very much like NEC, different start bit/pause lengths etc.
  * http://www.sbprojects.com/knowledge/ir/nec.htm
+ *
  * @param buf
     uint8_t halfbitscnt = 1;
     uint32_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 |= (uint32_t)1<<(19-(halfbitscnt>>1));
+        }
             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=IR_PROTO_MARANTZ;
     proto->timeout=IR_MARANTZ_TIMEOUT;
     proto->data = rawbits&0x0001ffff;
+}
 #endif
 /**
  * Expand data from Marantz. Written by Martin Nordin
  *
  * @param buf
  *      Pointer to buffer to store the expanded data
  * @param len
  *      Pointer to length of the data
  * @param proto
  *      Pointer to protocol information
     for(uint8_t i = 0; i < 17; i++) {
         tempdata = (uint32_t)tempdata<<1;
         if (((uint32_t)tempdata>>31)==1){
             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;
+        }
+    }
     //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;
         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;
+    }
+    }
     proto->protocol=IR_PROTO_PANASONIC;
     proto->timeout=IR_PANA_TIMEOUT;
     proto->data=rawbits;
     return IR_OK;
+}
 #endif
 /**
  * Expand data from Panasonic protocol
  *      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;
     buf[1] = IR_PANA_ST_PAUSE;
             if ((staticBits>>(i>>1))&1) {
                 buf[i+2] = IR_PANA_LOW_ONE;
             } else {
                 buf[i+2] = IR_PANA_LOW_ZERO;
+            }
         } else {                /* if even, ir-bit */
             buf[i+2] = IR_PANA_HIGH;
         }
+    }
     /* then add the value bits */
     for (uint8_t i = 0; i < 65; i++) {
         if ((i&1) == 1) {       /* if odd, ir-pause */
             } else {
                 buf[i+2+32] = IR_PANA_LOW_ZERO;
+            }
         } else {                /* if even, ir-bit */
             buf[i+2+32] = IR_PANA_HIGH;
         }
     }
     *len = 99;
     proto->modfreq=IR_PANA_F_MOD;
     proto->timeout=IR_PANA_TIMEOUT;
     /* parse buf[], max is len */
     /* check startbit */
     if (buf[0] > IR_SKY_ST_BIT + IR_SKY_ST_BIT/IR_SKY_TOL_DIV || buf[0] < IR_SKY_ST_BIT - IR_SKY_ST_BIT/IR_SKY_TOL_DIV) {
         return IR_NOT_CORRECT_DATA;
     }
     uint32_t rawbits=0;
     uint8_t current=0;
     uint8_t previous=0;
     uint8_t cnt=0;
         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;
     proto->data = rawbits;
     return IR_OK;
+}
 #endif
 /**
  * Expand data from Sky protocol
+ *
+ *
  * @param buf
  */
 int8_t parseNexa2(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 != 146 || len != 130) {
+    if (len != 148 && len != 132) {
         return IR_NOT_CORRECT_DATA;
+    }
     uint32_t rawbits = 0;
     uint64_t rawbitsTemp = 0;
-    if (buf[1] < IR_NEXA2_START - IR_NEXA2_START/IR_NEXA2_TOL_DIV && buf[1] > IR_NEXA2_START + IR_NEXA2_START/IR_NEXA2_TOL_DIV) { //check start bit
+    if (buf[0] < IR_NEXA2_START1 - IR_NEXA2_START1/IR_NEXA2_TOL_DIV && buf[0] > IR_NEXA2_START1 + IR_NEXA2_START1/IR_NEXA2_TOL_DIV) { //check start bit
         return IR_NOT_CORRECT_DATA;
+    }
+    if (buf[1] < IR_NEXA2_HIGH - IR_NEXA2_HIGH/IR_NEXA2_TOL_DIV && buf[1] > IR_NEXA2_HIGH + IR_NEXA2_HIGH/IR_NEXA2_TOL_DIV) { //check start bit
+        return IR_NOT_CORRECT_DATA;
+    }
+    if (buf[2] < IR_NEXA2_START2 - IR_NEXA2_START2/IR_NEXA2_TOL_DIV && buf[2] > IR_NEXA2_START2 + IR_NEXA2_START2/IR_NEXA2_TOL_DIV) { //check start bit
+        return IR_NOT_CORRECT_DATA;
+    }
+gpio_set_pin(EXP_H);
-      uint8_t bitCounter = 0;
+    uint8_t bitCounter = 0;
-    for (uint8_t i = 2; i < len; i++) { //Skip first bit
+    for (uint8_t i = 3; i < len; i++) {
-        if ((i&1) == 1) {       /* if odd, ir-pause */
+        if ((i&1) == 0) {       /* if even, transmit */
-            /* check length of pause between bits */
+            /* check length of transmit pulse */
-            if (buf[1] > IR_NEXA2_LOW_ONE - IR_NEXA2_LOW_ONE/IR_NEXA2_TOL_DIV && buf[1] < IR_NEXA2_LOW_ONE + IR_NEXA2_LOW_ONE/IR_NEXA2_TOL_DIV) {
+            if (buf[i] > IR_NEXA2_LOW_ONE - IR_NEXA2_LOW_ONE/IR_NEXA2_TOL_DIV && buf[i] < IR_NEXA2_LOW_ONE + IR_NEXA2_LOW_ONE/IR_NEXA2_TOL_DIV) {
                 /* write a one */
                 rawbitsTemp |= 1<<(bitCounter++);
-            } else if (buf[1] > IR_NEXA2_LOW_ZERO - IR_NEXA2_LOW_ZERO/IR_NEXA2_TOL_DIV && buf[1] < IR_NEXA2_LOW_ZERO + IR_NEXA2_LOW_ZERO/IR_NEXA2_TOL_DIV) {
+            } else if (buf[i] > IR_NEXA2_LOW_ZERO - IR_NEXA2_LOW_ZERO/IR_NEXA2_TOL_DIV && buf[i] < IR_NEXA2_LOW_ZERO + IR_NEXA2_LOW_ZERO/IR_NEXA2_TOL_DIV) {
                 /* do nothing, a zero is already in rawbits */
                 bitCounter++;
             } else {
                 return IR_NOT_CORRECT_DATA;
+            }
-            i+=2;   // skip every other bit,implement check here in the future
+            i+=2;   // skip every other bit, implement check here in the future
-        } else {            /* if even, ir-bit */
+        } else {            /* if odd, no transmit */
-            if (buf[1] < IR_NEXA2_HIGH - IR_NEXA2_HIGH/IR_NEXA2_TOL_DIV && buf[1] > IR_NEXA2_HIGH + IR_NEXA2_HIGH/IR_NEXA2_TOL_DIV) {
+            if (buf[i] < IR_NEXA2_HIGH - IR_NEXA2_HIGH/IR_NEXA2_TOL_DIV && buf[i] > IR_NEXA2_HIGH + IR_NEXA2_HIGH/IR_NEXA2_TOL_DIV) {
                 return IR_NOT_CORRECT_DATA;
+            }
+        }
+    }

Subversion Repositories HomeAutomation

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