Added support for several IR 3.5ch helicopters.

Including the popular SymaS107 (both R5 and R3), along with Useries and Toy-R-Us's private label of Air Hog's. Added example for emulating Hand remote control of joy sticks for various's axis's.

Author: mpflaga

IRremote.cpp

@@ -242,10 +242,82 @@ void IRsend::sendMagiQuest(uint32_t wand_id, uint16_t magnitude)
  space(MAGIQUEST_SPACE_ZERO);
  }
  }
- Serial.println();
 }
-
-void IRsend::mark(int time) {
+void IRsend::sendSymaR5(uint32_t data)
+{
+ enableIROut(38);
+ mark(SYMA_HDR_MARK); // SYMA_HDR_MARK 
+ space(SYMA_HDR_SPACE); // SYMA_HDR_SPACE
+ for (uint8_t i = 0; i < SYMA_R5_BITS+1; i++) {
+ mark(SYMA_BIT_MARK); // SYMA_BIT_MARK
+ if (((int32_t)data) < 0) { // if negative then MSBit is one.
+ space(SYMA_ONE_SPACE); // SYMA_ONE_SPACE
+ } 
+ else {
+ space(SYMA_ZERO_SPACE); // SYMA_ZERO_SPACE
+ }
+ data <<= 1;
+ }
+}
+void IRsend::sendSymaR3(uint32_t data)
+{
+ enableIROut(38);
+ mark(SYMA_HDR_MARK);
+ space(SYMA_HDR_SPACE);
+ data <<= 8;
+ for (uint8_t i = 0; i < SYMA_R3_BITS+1; i++) {
+ mark(SYMA_BIT_MARK);
+ if (((int32_t)data) < 0) { // if negative then MSBit is one.
+ space(SYMA_ONE_SPACE);
+ } 
+ else {
+ space(SYMA_ZERO_SPACE);
+ }
+ data <<= 1;
+ }
+}
+void IRsend::sendUseries(uint32_t data)
+{
+ enableIROut(38);
+ mark(USERIES_HDR_MARK);
+ for (int16_t i = 0; i < USERIES_BITS+1; i++) {
+ space(USERIES_BIT_SPACE);
+ if (((int32_t)data) < 0) { // if negative then MSBit is one.
+ mark(USERIES_ZERO_MARK);
+ } 
+ else {
+ mark(USERIES_ONE_MARK);
+ }
+ data <<= 1;
+ }
+ space(0); // Just to be sure
+}
+void IRsend::sendFastLane(uint32_t data)
+{
+ enableIROut(38);
+ mark(FASTLANE_HDR_MARK);
+ data <<= (32 - FASTLANE_BITS); // upshift to start point of data.
+ for (int16_t i = 0; i < FASTLANE_BITS+1; i++) {
+ if (i%2) {
+ if (((int32_t)data) < 0) { // if negative then MSBit is one.
+ mark(FASTLANE_ONE);
+ } 
+ else {
+ mark(FASTLANE_ZERO);
+ }
+ } else {
+ if (((int32_t)data) < 0) { // if negative then MSBit is one.
+ space(FASTLANE_ONE);
+ } 
+ else {
+ space(FASTLANE_ZERO);
+ }
+ }
+ data <<= 1;
+ }
+ space(0); // Just to be sure
+}
+void IRsend::mark(int16_t time) {
  // Sends an IR mark for the specified number of microseconds.
  // The mark output is modulated at the PWM frequency.
  TIMER_ENABLE_PWM; // Enable pin 3 PWM output
@@ -457,6 +529,24 @@ int16_t IRrecv::decode(decode_results *results) {
  if (decodePanasonic(results)) {
  return DECODED;
  }
+#ifdef DEBUG
+ Serial.println("Attempting Syma decode");
+#endif
+ if (decodeSyma(results)) {
+ return DECODED;
+ }
+#ifdef DEBUG
+ Serial.println("Attempting Useries decode");
+#endif
+ if (decodeUseries(results)) {
+ return DECODED;
+ }
+#ifdef DEBUG
+ Serial.println("Attempting FastLane decode");
+#endif
+ if (decodeFastLane(results)) {
+ return DECODED;
+ }
 #ifdef DEBUG
  Serial.println("Attempting JVC decode");
 #endif 
@@ -874,6 +964,109 @@ int32_t IRrecv::decodePanasonic(decode_results *results) {
  results->bits = PANASONIC_BITS;
  return DECODED;
 }
+int32_t IRrecv::decodeSyma(decode_results *results) {
+ uint32_t data = 0;
+ int16_t offset = 1;
+ uint8_t syma_len;
+
+ if (irparams.rawlen == 2 * (SYMA_R5_BITS + 2)) {
+ syma_len = SYMA_R5_BITS;
+ } 
+ else if (irparams.rawlen == 2 * (SYMA_R3_BITS + 2)) {
+ syma_len = SYMA_R3_BITS;
+ } 
+ else {
+ return ERR;
+ }
+ if (!MATCH_MARK(results->rawbuf[offset], SYMA_HDR_MARK)) {
+ return ERR;
+ }
+ offset++;
+ if (!MATCH_MARK(results->rawbuf[offset], SYMA_HDR_SPACE)) {
+ return ERR;
+ }
+ offset++;
+ for (uint8_t i = 0; i < syma_len; i++) {
+ if (!MATCH_MARK(results->rawbuf[offset++], SYMA_BIT_MARK)) {
+ return ERR;
+ }
+ if (MATCH_SPACE(results->rawbuf[offset], SYMA_ONE_SPACE)) {
+ data = (data << 1) | 1;
+ } else if (MATCH_SPACE(results->rawbuf[offset], SYMA_ZERO_SPACE)) {
+ data <<= 1;
+ } else {
+ return ERR;
+ }
+ offset++;
+ }
+ results->value = data;
+ if (syma_len == SYMA_R5_BITS) {
+ results->decode_type = SYMA_R5;
+ } 
+ else if (syma_len == SYMA_R3_BITS) {
+ results->decode_type = SYMA_R3;
+ }
+ results->bits = syma_len;
+ results->helicopter.dword = data;
+ return DECODED;
+}
+int32_t IRrecv::decodeUseries(decode_results *results) {
+ uint32_t data = 0;
+ int16_t offset = 1;
+ if (irparams.rawlen < 2 * (USERIES_BITS + 2)) {
+ return ERR;
+ }
+ if (!MATCH_MARK(results->rawbuf[offset], USERIES_HDR_MARK)) {
+ return ERR;
+ }
+ offset++;
+ for (int16_t i = 0; i < USERIES_BITS; i++) {
+ if (!MATCH_SPACE(results->rawbuf[offset++], USERIES_BIT_SPACE)) {
+ return ERR;
+ }
+ if (MATCH_MARK(results->rawbuf[offset],USERIES_ONE_MARK)) {
+ data <<= 1;
+ } else if (MATCH_MARK(results->rawbuf[offset],USERIES_ZERO_MARK)) {
+ data = (data << 1) | 1;
+ } else {
+ return ERR;
+ }
+ offset++;
+ }
+ results->value = data;
+ results->helicopter.dword = data;
+ results->parity = UseriesChecksum(data);
+ results->decode_type = USERIES;
+ results->bits = USERIES_BITS;
+ return DECODED;
+}
+int32_t IRrecv::decodeFastLane(decode_results *results) {
+ helicopter data;
+ data.dword = 0;
+ int16_t offset = 1;
+ if (irparams.rawlen < (FASTLANE_BITS + 2)) {
+ return ERR;
+ }
+ if (!MATCH_MARK(results->rawbuf[offset], FASTLANE_HDR_MARK)) {
+ return ERR;
+ }
+ offset++;
+ for (int16_t i = 0; i < FASTLANE_BITS; i++) {
+ if (MATCH_MARK(results->rawbuf[offset],FASTLANE_ZERO)) {
+ data.dword <<= 1;
+ } else if (MATCH_MARK(results->rawbuf[offset],FASTLANE_ONE)) {
+ data.dword = (data.dword << 1) | 1;
+ } else {
+ return ERR;
+ }
+ offset++;
+ }
+ results->value = data.dword;
+ results->helicopter.dword = data.dword;
+ results->decode_type = FASTLANE;
+ results->bits = FASTLANE_BITS;
+ return DECODED;
+}
 int32_t IRrecv::decodeJVC(decode_results *results) {
  int32_t data = 0;
  int16_t offset = 1; // Skip first space
@@ -1113,3 +1306,14 @@ void IRsend::sendDISH(int32_t data, int16_t nbits)
  data <<= 1;
  }
 }
+uint8_t UseriesChecksum(uint32_t val)
+{
+ const uint8_t map[8] = { 0, 1, 3, 2, 6, 7, 5, 4 };
+ uint32_t x = val & 0xFFFFFFF8;
+ uint32_t p = x;
+ while ((x >>= 7) != 0) {
+ p ^= x;
+ }
+ p = (p ^ (p >> 1) ^ (p >> 2) ^ (p >> 4)) & 7;
+ return(map[p]);
+}

IRremote.h

@@ -29,7 +29,7 @@ union magiquest {
  uint64_t llword;
  uint8_t byte[8];
 // uint16_t word[4];
-// uint32_t lword[2];
+ uint32_t lword[2];
  struct {
  uint16_t magnitude;
  uint32_t wand_id;
@@ -38,13 +38,60 @@ union magiquest {
  } cmd ;
 } ;
 
+union helicopter {
+ uint32_t dword;
+ struct
+ {
+ uint8_t Throttle : 7; // 0..6 0 - 127
+ uint8_t Channel : 1; // 7 A=0, B=1
+ uint8_t Pitch : 7; // 8..14 0(forward) - 63(center) 127(back)
+ uint8_t Pspacer : 1; // 15 na
+ uint8_t Yaw : 7; // 16..22 127(left) - 63(center) - 0(right)
+ } symaR3;
+ struct
+ {
+ uint8_t Trim : 7; // 0..6 127(left) - 63(center) - 0(right)
+ uint8_t Tspacer : 1; // 7 na
+ uint8_t Throttle : 7; // 8..14 0 - 127
+ uint8_t Channel : 1; // 15 A=0, B=1
+ uint8_t Pitch : 7; // 16..22 0(forward) - 63(center) 127(back)
+ uint8_t Pspacer : 1; // 23 na
+ uint8_t Yaw : 7; // 24..30 127(left) - 63(center) - 0(right)
+ } symaR5;
+ struct
+ {
+ uint8_t cksum : 3; // 0..2
+ uint8_t Rbutton : 1; // 3 0-normally off, 1-depressed
+ uint8_t Lbutton : 1; // 4 0-normally off, 1-depressed
+ uint8_t Turbo : 1; // 5 1-off, 0-on
+ uint8_t Channel : 2; // 6,7 A=1, B=2, C=0
+ uint8_t Trim : 6; // 8..13 (left)63 - 31(center) - 0(right)
+ uint8_t Yaw : 5; // 14..18 31(left) - 15(center) - 0(right)
+ uint8_t Pitch : 6; // 19..24 0(foward) - 31(center) - 63(back)
+ uint8_t Throttle : 7; // 25..31 0 - 127
+ } uSeries;
+ struct
+ {
+ uint8_t Trim : 4; // 0..3 15(left) - 8(center) - 0(right)
+ uint8_t Trim_dir : 1; // 4 0= , 1=
+ uint8_t Yaw_dir : 1; // 5
+ uint8_t Fire : 1; // 6
+ uint8_t Yaw : 4; // 7..10 15(left) - 8(center) - 0(right)
+ uint8_t Pitch : 4; // 11..14 1(back) - 8(center) 15(forward)
+ uint8_t Throttle : 6; // 15..20 0 - 63
+ uint8_t Channel : 2; // 21..22 ?A=0, B=1
+ } fastlane;
+};
+
 // Results returned from the decoder
 class decode_results {
 public:
  int16_t decode_type; // NEC, SONY, RC5, UNKNOWN
  uint16_t panasonicAddress; // This is only used for decoding Panasonic data
  uint16_t magiquestMagnitude; // This is only used for MagiQuest
  int32_t value; // Decoded value //mpf need to make unsigned.
+ union helicopter helicopter;
+ uint16_t parity;
  int16_t bits; // Number of bits in decoded value
  volatile uint16_t *rawbuf; // Raw intervals in .5 us ticks
  int16_t rawlen; // Number of records in rawbuf.
@@ -62,6 +109,10 @@ class decode_results {
 #define SANYO 9
 #define MITSUBISHI 10
 #define MAGIQUEST 11
+#define SYMA_R3 12
+#define SYMA_R5 13
+#define USERIES 14
+#define FASTLANE 15
 #define UNKNOWN -1
 
 // Decoded value for NEC when a repeat code is received
@@ -86,14 +137,19 @@ class IRrecv
  int32_t decodeRC5(decode_results *results);
  int32_t decodeRC6(decode_results *results);
  int32_t decodePanasonic(decode_results *results);
+ int32_t decodeSyma(decode_results *results);
+ int32_t decodeUseries(decode_results *results);
+ int32_t decodeFastLane(decode_results *results);
  int32_t decodeJVC(decode_results *results);
  int32_t decodeMagiQuest(decode_results *results);
  int32_t decodeHash(decode_results *results);
  int16_t compare(uint16_t oldval, uint16_t newval);
 
-} 
+}
 ;
 
+uint8_t UseriesChecksum(uint32_t val);
+
 // Only used for testing; can remove virtual for shorter code
 #ifdef TEST
 #define VIRTUAL virtual
@@ -118,6 +174,10 @@ class IRsend
  void sendPanasonic(uint16_t address, int32_t data);
  void sendJVC(int32_t data, int16_t nbits, int16_t repeat); // *Note instead of sending the REPEAT constant if you want the JVC repeat signal sent, send the original code value and change the repeat argument from 0 to 1. JVC protocol repeats by skipping the header NOT by sending a separate code value like NEC does.
  void sendMagiQuest(uint32_t wand_id, uint16_t magitude);
+ void sendSymaR5(uint32_t data);
+ void sendSymaR3(uint32_t data);
+ void sendUseries(uint32_t data);
+ void sendFastLane(uint32_t data);
  // private:
  void enableIROut(int16_t khz);
  VIRTUAL void mark(int16_t usec);
@@ -127,11 +187,11 @@ class IRsend
 
 // Some useful constants
 
-#define USECPERTICK 50 // microseconds per clock interrupt tick
+#define USECPERTICK 25 // microseconds per clock interrupt tick
 #define RAWBUF 112 // Length of raw duration buffer
 
 // Marks tend to be 100us too long, and spaces 100us too short
 // when received due to sensor lag.
 #define MARK_EXCESS 100
-
 #endif
+