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

  */
 #include "protocols.h"
 #include <bios.h>
+#include <drivers/can/moduleid.h>
 //#include <drivers/mcu/gpio.h>
 #if (IR_PROTOCOLS_USE_PANASONIC)
     if (parsePanasonic(buf, len, proto)==IR_OK) return IR_OK;
 #endif
 #if (IR_PROTOCOLS_USE_SKY)
     if (parseSky(buf, len, proto)==IR_OK) return IR_OK;
+#endif
+#if (IR_PROTOCOLS_USE_IROBOT)
+    if (parseiRobot(buf, len, proto)==IR_OK) return IR_OK;
 #endif
 /* RF protocols needs index parameter */
 #if (IR_PROTOCOLS_USE_NEXA2)
+}
 int8_t expandProtocol(uint16_t *buf, uint8_t *len, Ir_Protocol_Data_t *proto) {
     /* Call the expand function for the specified protocol. */
     switch (proto->protocol) {
-    case IR_PROTO_SIRC:
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_SIRC:
         return expandSIRC(buf, len, proto);
-    case IR_PROTO_RC5:
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_RC5:
         return expandRC5(buf, len, proto);
-    case IR_PROTO_SHARP:
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_SHARP:
         return expandSharp(buf, len, proto);
-    case IR_PROTO_NEC:
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_NEC:
         return expandNEC(buf, len, proto);
-    case IR_PROTO_SAMS:
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_SAMSUNG:
         return expandSamsung(buf, len, proto);
-    case IR_PROTO_MARANTZ:
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_MARANTZ:
         return expandMarantz(buf, len, proto);
-    case IR_PROTO_PANASONIC:
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_PANASONIC:
         return expandPanasonic(buf, len, proto);
-    case IR_PROTO_SKY:
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_SKY:
         return expandSky(buf, len, proto);
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_IROBOT:
+        return expandiRobot(buf, len, proto);
-    case IR_PROTO_NEXA2:
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_NEXA2:
         return expandNexa2(buf, len, proto);
-    case IR_PROTO_NEXA1:
+    case CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_NEXA:
         return expandNexa1(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:
         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 = IR_PROTO_SIRC;
+    proto->protocol = CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_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
+ *
  *      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 */
+        }
     proto->modfreq=IR_SIRC_F_MOD;
     proto->timeout=IR_SIRC_TIMEOUT;
     proto->repeats=IR_SIRC_REPS;
     return IR_OK;
 }
 #if (IR_PROTOCOLS_USE_RC5)
 /**
  * Test data on RC5 protocol
         //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=IR_PROTO_RC5;
+    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;
     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
         if(previousBit == ((rawMessage>>(pos-1)) & 1))
+        {
             buf[*len]=IR_RC5_HALF_BIT;
             buf[*len+1]=IR_RC5_HALF_BIT;
 int8_t parseSharp(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 != 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) {
                 return IR_NOT_CORRECT_DATA;
+            }
+        }
+    }
-    proto->protocol=IR_PROTO_SHARP;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_SHARP;
     proto->timeout=IR_SHARP_TIMEOUT;
     proto->data=rawbits;
     return IR_OK;
+}
 #endif
                 return IR_NOT_CORRECT_DATA;
+            }
+        }
+    }
-    proto->protocol=IR_PROTO_NEC;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_NEC;
     proto->timeout=IR_NEC_TIMEOUT;
     proto->data=rawbits;
     return IR_OK;
+}
 #endif
                 return IR_NOT_CORRECT_DATA;
+            }
+        }
+    }
-    proto->protocol=IR_PROTO_SAMS;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_SAMSUNG;
     proto->timeout=IR_SAMS_TIMEOUT;
     proto->data=rawbits;
     return IR_OK;
+}
 #endif
         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;
         }
     }
     *len = 67;
     proto->modfreq=IR_SAMS_F_MOD;
     proto->timeout=IR_SAMS_TIMEOUT;
             return IR_NOT_CORRECT_DATA;
+        }
+    }
-    proto->protocol=IR_PROTO_MARANTZ;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_MARANTZ;
     proto->timeout=IR_MARANTZ_TIMEOUT;
     proto->data = rawbits&0x0001ffff;
     return IR_OK;
+}
                 return IR_NOT_CORRECT_DATA;
+            }
+        }
+    }
-    proto->protocol=IR_PROTO_PANASONIC;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_PANASONIC;
     proto->timeout=IR_PANA_TIMEOUT;
     proto->data=rawbits;
     return IR_OK;
+}
 #endif
     *len = 99;
     proto->modfreq=IR_PANA_F_MOD;
     proto->timeout=IR_PANA_TIMEOUT;
     proto->repeats=IR_PANA_REPS;
     return IR_OK;
 }
 #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
  * @return
  *      IR_OK if data parsed successfully, one of several errormessages if not
  */
 int8_t parseSky(const uint16_t *buf, uint8_t len, Ir_Protocol_Data_t *proto) {
     /* 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) {
         /* 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;
+            }
+        }
+        previous=current;
+    }
+    proto->protocol = CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_SKY;
+    proto->timeout = IR_SKY_TIMEOUT;
+    proto->data = rawbits;
+    return IR_OK;
+}
+#endif
+/**
+ * Expand data from Sky protocol
+ *
+ *
+ * @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 expandSky(uint16_t *buf, uint8_t *len, Ir_Protocol_Data_t *proto) {
+    //TODO: Implement this function.
+    buf[0] = IR_SKY_ST_BIT;
+    buf[1] = IR_SKY_LONG;   //
+    return IR_NOT_CORRECT_DATA;
+}
+#if (IR_PROTOCOLS_USE_IROBOT)
+/**
+ * Test data on iRobot 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 parseiRobot(const uint16_t *buf, uint8_t len, Ir_Protocol_Data_t *proto) {
+    /* parse buf[], max is len */
+    uint32_t rawbits=0;
+    uint8_t current=0;
+    uint8_t previous=0;
+    uint8_t cnt=0;
+#define IROBOTLONG 0
+#define IROBOTSHORT 1
+    /* check if we have correct amount of data */
+    if (len != 16) {
+        return IR_NOT_CORRECT_DATA;
+    }
+    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 == SKYLONG) {
+            if (current == IROBOTLONG) {
                 /* push a zero */
                 rawbits = rawbits<<1;
-                if (previous == SKYLONG) {
+                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 = IR_PROTO_SKY;
+    proto->protocol = CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_IROBOT;
-    proto->timeout = IR_SKY_TIMEOUT;
+    proto->timeout = IR_IROBOT_TIMEOUT;
     proto->data = rawbits;
     return IR_OK;
+}
 #endif
 /**
- * Expand data from Sky protocol
+ * Expand data from iRobot protocol
+ *
+ *
  * @param buf
  *      Pointer to buffer to store the expanded data
  * @param len
  * @param proto
  *      Pointer to protocol information
  * @return
  *      IR_OK if data expanded successfully, one of several errormessages if not
  */
-int8_t expandSky(uint16_t *buf, uint8_t *len, Ir_Protocol_Data_t *proto) {
+int8_t expandiRobot(uint16_t *buf, uint8_t *len, Ir_Protocol_Data_t *proto) {
+    uint8_t temp;
+    uint8_t lookup[16] = {
+x0, 0x8, 0x4, 0xC,
+x2, 0xA, 0x6, 0xE,
+x1, 0x9, 0x5, 0xD,
+x3, 0xB, 0x7, 0xF };
-    //TODO: Implement this function.
+    temp = (uint8_t)proto->data;
+    temp = (lookup[temp &0x0F] << 4) | lookup[temp >>4];
+    proto->data = temp << 8;
+    proto->data += 0x52;
+    for (uint8_t i = 0; i < 32; i++) {
+        if ((proto->data>>(i>>1))&1) {
+            buf[i] = IR_IROBOT_LONG;
+            i++;
+            buf[i] = IR_IROBOT_SHORT;
+        } else {
-    buf[0] = IR_SKY_ST_BIT;
+            buf[i] = IR_IROBOT_SHORT;
+            i++;
-    buf[1] = IR_SKY_LONG;   //
+            buf[i] = IR_IROBOT_LONG;
+        }
+    }
+    *len = 31;
+    proto->modfreq=IR_IROBOT_F_MOD;
+    proto->timeout=IR_IROBOT_TIMEOUT;
+    proto->repeats=IR_IROBOT_REPS;
-    return IR_NOT_CORRECT_DATA;
+    return IR_OK;
+}
 #if (IR_PROTOCOLS_USE_NEXA2)
 /**
  * Test data on NEXA protocol
  * http://elektronikforumet.com/wiki/index.php?title=RF_Protokoll_-_Nexa_sj%C3%A4lvl%C3%A4rande
                 return IR_NOT_CORRECT_DATA;
+            }
+        }
+    }
-    proto->protocol=IR_PROTO_NEXA2;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_NEXA2;
     proto->timeout=IR_NEXA2_TIMEOUT;
     proto->data=rawbitsTemp;
     return IR_OK;
+}
+    {
         /* Bogus RF data */
         return IR_NOT_CORRECT_DATA;
+    }
-    proto->protocol=IR_PROTO_NEXA1;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_NEXA;
     proto->timeout=IR_NEXA1_TIMEOUT;
     proto->data=rawbitsTemp;
     return IR_OK;
+}
+    }
     rawbitsTemp = ~rawbitsTemp;
     rawbitsTemp = rawbitsTemp&0xFFFFFFFFFF;
-    proto->protocol=IR_PROTO_VIKING;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_VIKING;
     proto->timeout=0;
     proto->data=rawbitsTemp;
     return IR_OK;
 #else
+    }
     //rawbitsTemp = ~rawbitsTemp;
     //rawbitsTemp = rawbitsTemp&0xFFFFFFFFFF;
-    proto->protocol=IR_PROTO_VIKING_STEAK;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_VIKING_STEAK;
     proto->timeout=IR_VIKING_STEAK_TIMEOUT;
     proto->data=rawbitsTemp;
     return IR_OK;
 #else
+    }
     //rawbitsTemp = ~rawbitsTemp;
     //rawbitsTemp = rawbitsTemp&0xFFFFFFFFFF;
-    proto->protocol=IR_PROTO_RUBICSON;
+    proto->protocol=CAN_MODULE_ENUM_PHYSICAL_IR_PROTOCOL_RUBICSON;
     proto->timeout=IR_RUBICSON_TIMEOUT;
     proto->data=rawbitsTemp;
     return IR_OK;
 #else

Subversion Repositories HomeAutomation

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