API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 23rd, 2018
78
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.42 KB | None | 0 0
raw download clone embed print report
  1. #include <IRremote.h>
  2.  
  3. #define PROTO_RAW 0x0
  4. #define PROTO_NEC 0x1
  5. #define PROTO_SONY 0x2
  6. #define PROTO_RC5 0x3
  7. #define PROTO_RC6 0x4
  8. #define PROTO_DISH 0x5
  9. #define PROTO_SHARP 0x6
  10. #define PROTO_JVC 0x7
  11. #define PROTO_SANYO 0x8
  12. #define PROTO_MITSUBISHI 0x9
  13. #define PROTO_SAMSUNG 0xa
  14. #define PROTO_LG 0xb
  15. #define PROTO_WHYNTER 0xc
  16. #define PROTO_AIWA_RC_T501 0xd
  17. #define PROTO_PANASONIC 0xe
  18. #define PROTO_DENON 0xf
  19.  
  20. #define POSTAMBLE "\x5a\x5a"
  21.  
  22. int recvPin = 4;
  23. IRrecv irrecv(recvPin);
  24. IRsend irsend;
  25.  
  26. typedef struct EtatFirmware {
  27. char current_proto = PROTO_RAW;
  28. unsigned int *raw = NULL;
  29. unsigned int raw_length = 0;
  30. unsigned int current_freq = 38; // (38kHz)
  31. unsigned int current_code_length = 0;
  32. unsigned long current_code = 0;
  33. } EtatFirmware;
  34.  
  35. EtatFirmware etatcourant;
  36.  
  37. void reset() {
  38. etatcourant.current_proto = 0x0;
  39. etatcourant.raw = NULL;
  40. etatcourant.raw_length = 0;
  41. etatcourant.current_freq = 38;
  42. etatcourant.current_code = 0;
  43. etatcourant.current_code_length = 0;
  44. }
  45.  
  46.  
  47.  
  48. void setup() {
  49. Serial.begin(200000);
  50. irrecv.enableIRIn();
  51. reset();
  52. }
  53.  
  54. int send(char proto,char *datas,unsigned int data_length) {
  55.  
  56. if (proto == PROTO_RAW) {
  57. unsigned int *irSignal = malloc(data_length);
  58. unsigned int khz = etatcourant.current_freq;
  59. for (int i=0,j=0;i<data_length;i+=2,j++) {
  60. irSignal[j] = char2uint(datas+i);
  61. }
  62. /*
  63. for (int i=0;i<data_length/2;i++) {
  64. Serial.println(irSignal[i]);
  65. }
  66. */
  67.  
  68. irsend.sendRaw(irSignal, data_length / sizeof(unsigned int), khz);
  69.  
  70. return 0;
  71. }
  72. else if (proto == PROTO_NEC) {
  73. unsigned long code = char2ulong(datas);
  74. irsend.sendNEC(code,data_length);
  75. return 0;
  76. }
  77. else {
  78. return 1;
  79. }
  80.  
  81. }
  82.  
  83. void setFrequency(unsigned int khz){
  84. etatcourant.current_freq = khz;
  85. }
  86.  
  87. unsigned int getFrequency(){
  88. return etatcourant.current_freq;
  89. }
  90. char encoding (decode_results *results)
  91. {
  92. switch (results->decode_type) {
  93. default:
  94. case UNKNOWN: return PROTO_RAW; break ;
  95. case NEC: return PROTO_NEC; break ;
  96. case SONY: return PROTO_SONY; break ;
  97. case RC5: return PROTO_RC5; break ;
  98. case RC6: return PROTO_RC6; break ;
  99. case DISH: return PROTO_DISH; break ;
  100. case SHARP: return PROTO_SHARP; break ;
  101. case JVC: return PROTO_JVC; break ;
  102. case SANYO: return PROTO_SANYO; break ;
  103. case MITSUBISHI: return PROTO_MITSUBISHI; break ;
  104. case SAMSUNG: return PROTO_SAMSUNG; break ;
  105. case LG: return PROTO_LG; break ;
  106. case WHYNTER: return PROTO_WHYNTER; break ;
  107. case AIWA_RC_T501: return PROTO_AIWA_RC_T501; break ;
  108. case PANASONIC: return PROTO_PANASONIC; break ;
  109. case DENON: return PROTO_DENON; break ;
  110. }
  111. }
  112. unsigned long ircode (decode_results *results)
  113. {
  114. // Serial.println(results->value, HEX);
  115.  
  116. return results->value;
  117. }
  118.  
  119. void setInfo (decode_results *results)
  120. {
  121. // Check if the buffer overflowed
  122. if (results->overflow) {
  123. return;
  124. }
  125. unsigned int current_proto = encoding(results);
  126. unsigned long current_code = ircode(results);
  127. if (!(current_code == 0xFFFFFFFF and current_proto == 1) ){
  128. etatcourant.current_code = current_code;
  129. etatcourant.current_proto = current_proto;
  130. etatcourant.current_code_length = results->bits;
  131. etatcourant.raw_length = results->rawlen - 1;
  132. if (etatcourant.raw != NULL) {
  133. free(etatcourant.raw);
  134. }
  135. unsigned int *raw = malloc(sizeof(unsigned int) * etatcourant.raw_length);
  136.  
  137. for (int i = 1; i < results->rawlen; i++) {
  138. raw[i-1] = results->rawbuf[i] * USECPERTICK;
  139. }
  140. etatcourant.raw = raw;
  141. }
  142. }
  143.  
  144. char* uint2char(unsigned int num){
  145. char *p = (char *)malloc(sizeof(unsigned int));
  146. p[0] = (num >> 8) & 0xFF;
  147. p[1] = (num) & 0xFF;
  148. return p;
  149. }
  150. unsigned int char2uint(char *p) {
  151. unsigned int num =(unsigned int)((0xFF00 & (p[0] << 8)) | (p[1] & 0x00FF));
  152. return num ;
  153. }
  154.  
  155. char* ulong2char(unsigned long num){
  156. char *p = malloc(sizeof(char)*sizeof(unsigned long));
  157. p[0] = (num >> 24) & 0xFF;
  158. p[1] = (num >> 16) & 0xFF;
  159. p[2] = (num >> 8) & 0xFF;
  160. p[3] = (num) & 0xFF;
  161. return p;
  162.  
  163. }
  164. char* char2ulong(char *p) {
  165. return ((unsigned long)((p[0] << 24) & 0xFF000000)|((p[1] << 16) & 0x00FF0000) | ((p[2] << 8) & 0x0000FF00) | (p[3] & 0x000000FF) );
  166. }
  167.  
  168.  
  169. void writeReset() {
  170. char ack = 0x01;
  171. char opcode = 0x00;
  172.  
  173. char length[2] = {0x00, 0x00};
  174. Serial.write(ack);
  175. Serial.write(opcode);
  176.  
  177. Serial.write(length,2);
  178. Serial.write(POSTAMBLE,2);
  179. }
  180. void writeFrequency() {
  181.  
  182. char ack = 0x01;
  183. char opcode = 0x01;
  184.  
  185. char length[2] = {0x00, 0x02};
  186. unsigned int freq = getFrequency();
  187. char *freqparam = uint2char(freq);
  188.  
  189. Serial.write(ack);
  190. Serial.write(opcode);
  191.  
  192. Serial.write(length,2);
  193. Serial.write(freqparam,2);
  194. free(freqparam);
  195. Serial.write(POSTAMBLE,2);
  196. }
  197. void writeRecv() {
  198.  
  199. char ack = 0x01;
  200. char opcode = 0x03;
  201.  
  202. unsigned int *total_length = sizeof(unsigned int) * etatcourant.raw_length;
  203. if (etatcourant.current_proto > 0) {
  204. total_length += 1 + (etatcourant.current_code_length / 8) + 2;
  205. }
  206. char *lengthparam = uint2char(total_length);
  207. Serial.write(ack);
  208. Serial.write(opcode);
  209.  
  210. Serial.write(lengthparam,2);
  211. free(lengthparam);
  212. char *rawlength = uint2char(etatcourant.raw_length*2);
  213. Serial.write(rawlength, 2);
  214. free(rawlength);
  215. for (int i=0;i<etatcourant.raw_length;i++) {
  216. char *rawvalue = uint2char(etatcourant.raw[i]);
  217. Serial.write(rawvalue,2);
  218. free(rawvalue);
  219. }
  220. if (etatcourant.current_proto != 0x0) {
  221. Serial.write(etatcourant.current_proto);
  222. char *code_length = uint2char(etatcourant.current_code_length);
  223. Serial.write(code_length,2);
  224. free(code_length);
  225. char *code = ulong2char(etatcourant.current_code);
  226. Serial.write(code,4);
  227. free(code);
  228. }
  229. Serial.write(POSTAMBLE,2);
  230. }
  231.  
  232. void parseRequest(char *buffer, unsigned int length) {
  233. // Parse Header
  234. char ack = buffer[0];
  235. char opcode = buffer[1];
  236.  
  237. unsigned int size = char2uint(buffer+2);
  238. if (opcode == 0x00) {
  239. reset();
  240. writeReset();
  241. }
  242. else if (opcode == 0x01) {
  243. if (size != 0) {
  244. unsigned int freq = char2uint(buffer+4);
  245. setFrequency(freq);
  246. }
  247. writeFrequency();
  248. }
  249. else if (opcode == 0x02) {
  250. char protocol = buffer[4];
  251. Serial.write(buffer[5]);
  252. Serial.write(buffer[6]);
  253.  
  254. unsigned int data_size = char2uint(buffer+5);
  255. send(protocol,buffer+7,data_size);
  256. Serial.write(POSTAMBLE,2);
  257. }
  258. else if (opcode == 0x03) {
  259. writeRecv();
  260. }
  261.  
  262. }
  263. void loop() {
  264. decode_results results;
  265. if (irrecv.decode(&results)) {
  266. setInfo(&results);
  267. irrecv.resume();
  268. }
  269. if (Serial.available()>0) {
  270. char buffer[256];
  271. unsigned int length = Serial.readBytes(buffer,256);
  272. parseRequest(buffer,length);
  273. }
  274.  
  275. //delay(500);
  276. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!