Advertisement
stanleyseow

Arduino nRF RGB colour changer

Jun 19th, 2013
1,440
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 5.78 KB | None | 0 0
  1. /*
  2.  
  3.  This program receive RGB colour codes from nRF radio and analogWrite the colour to the RGB LED strip
  4.  
  5.  Date : 20/06/2013
  6.  Written by Stanley Seow
  7. */
  8.  
  9.  
  10. #include <SPI.h>
  11. #include "nRF24L01.h"
  12. #include "RF24.h"
  13. #include "printf.h"
  14.  
  15. #define RED_PIN 5
  16. #define GREEN_PIN 3
  17. #define BLUE_PIN 6
  18.  
  19.  
  20. RF24 radio(8,9);
  21.  
  22. // Radio pipe addresses for the 2 nodes to communicate.
  23.  
  24. const uint64_t pipes[6] = { 0xDEDEDEDEE7ULL, 0xDEDEDEDEE9ULL  };
  25.  
  26. char receivePayload[31];
  27.    
  28. int r,g,b = 0;
  29. char red[3], green[3], blue[3];
  30.  
  31. void setup(void)
  32. {
  33.  
  34.   pinMode(RED_PIN, OUTPUT);
  35.   pinMode(GREEN_PIN, OUTPUT);
  36.   pinMode(BLUE_PIN, OUTPUT);
  37.  
  38.   Serial.begin(57600);
  39.   printf_begin();
  40.  
  41.   radio.begin();
  42.  
  43.   radio.setDataRate(RF24_250KBPS);
  44.   radio.setPALevel(RF24_PA_MAX);
  45.   radio.setChannel(85);
  46.   radio.enableDynamicPayloads();
  47.   radio.setRetries(15,15);
  48.  
  49.   radio.setCRCLength(RF24_CRC_16);
  50.  
  51.   radio.openWritingPipe(pipes[0]);
  52.   radio.openReadingPipe(1,pipes[1]);
  53.  
  54.   radio.startListening();
  55.   radio.printDetails();
  56.  
  57.   delay(1000);
  58.  
  59. }
  60.  
  61. void loop(void)
  62. {
  63.  
  64.     uint8_t len = 0;
  65.  
  66.     // Loop thru the pipes 0 to 5 and check for payloads    
  67.     if ( radio.available() ) {
  68.       bool done = false;
  69.       while (!done)
  70.       {
  71.         len = radio.getDynamicPayloadSize();  
  72.         done = radio.read( &receivePayload,len );
  73.        
  74.         receivePayload[len] = 0;
  75.         printf("Got payload: %s len:%i 0x%x\n\r",receivePayload,len);
  76.        
  77.         // Strip the red, green & blue from the 6 chars
  78.         HEXtoRGB();
  79.  
  80.         printf("%s %s %s\n\r",red,green,blue);
  81.         printf("RGB:%i %i %i\n\r",r,g,b);
  82.  
  83.         analogWrite(RED_PIN,r);
  84.         analogWrite(GREEN_PIN,g);
  85.         analogWrite(BLUE_PIN,b);
  86.        
  87.         radio.startListening();
  88.        
  89.       }
  90.     }
  91.  
  92.    r,g,b = 0;    
  93. }
  94.  
  95. void HEXtoRGB(void) {
  96. /* parse the string into three pieces of two */
  97.  
  98.     red[0] = toupper(receivePayload[1]);
  99.     red[1] = toupper(receivePayload[2]);
  100.     green[0] = toupper(receivePayload[3]);
  101.     green[1] = toupper(receivePayload[4]);
  102.     blue[0] = toupper(receivePayload[5]);
  103.     blue[1] = toupper(receivePayload[6]);
  104.  
  105. /* RED ********************************************/
  106.     switch (red[0]) {
  107.         case '0' : { r = 0; break; }
  108.         case '1' : { r = 16; break; }
  109.         case '2' : { r = 32; break; }
  110.         case '3' : { r = 48; break; }
  111.         case '4' : { r = 64; break; }
  112.         case '5' : { r = 80; break; }
  113.         case '6' : { r = 96; break; }
  114.         case '7' : { r = 112; break; }
  115.         case '8' : { r = 128; break; }
  116.         case '9' : { r = 144; break; }
  117.         case 'A' : { r = 160; break; }
  118.         case 'B' : { r = 176; break; }
  119.         case 'C' : { r = 192; break; }
  120.         case 'D' : { r = 208; break; }
  121.         case 'E' : { r = 224; break; }
  122.         case 'F' : { r = 240; break; }
  123.     }
  124.  
  125.     switch (red[1]) {
  126.         case '0' : { r = r + 0; break; }
  127.         case '1' : { r = r + 1; break; }
  128.         case '2' : { r = r + 2; break; }
  129.         case '3' : { r = r + 3; break; }
  130.         case '4' : { r = r + 4; break; }
  131.         case '5' : { r = r + 5; break; }
  132.         case '6' : { r = r + 6; break; }
  133.         case '7' : { r = r + 7; break; }
  134.         case '8' : { r = r + 8; break; }
  135.         case '9' : { r = r + 9; break; }
  136.         case 'A' : { r = r + 10; break; }
  137.         case 'B' : { r = r + 11; break; }
  138.         case 'C' : { r = r + 12; break; }
  139.         case 'D' : { r = r + 13; break; }
  140.         case 'E' : { r = r + 14; break; }
  141.         case 'F' : { r = r + 15; break; }
  142.     }
  143.  
  144. /* GREEN ********************************************/
  145.     switch (green[0]) {
  146.         case '0' : { g = 0; break; }
  147.         case '1' : { g = 16; break; }
  148.         case '2' : { g = 32; break; }
  149.         case '3' : { g = 48; break; }
  150.         case '4' : { g = 64; break; }
  151.         case '5' : { g = 80; break; }
  152.         case '6' : { g = 96; break; }
  153.         case '7' : { g = 112; break; }
  154.         case '8' : { g = 128; break; }
  155.         case '9' : { g = 144; break; }
  156.         case 'A' : { g = 160; break; }
  157.         case 'B' : { g = 176; break; }
  158.         case 'C' : { g = 192; break; }
  159.         case 'D' : { g = 208; break; }
  160.         case 'E' : { g = 224; break; }
  161.         case 'F' : { g = 240; break; }
  162.     }
  163.     switch (green[1]) {
  164.         case '0' : { g = g + 0; break; }
  165.         case '1' : { g = g + 1; break; }
  166.         case '2' : { g = g + 2; break; }
  167.         case '3' : { g = g + 3; break; }
  168.         case '4' : { g = g + 4; break; }
  169.         case '5' : { g = g + 5; break; }
  170.         case '6' : { g = g + 6; break; }
  171.         case '7' : { g = g + 7; break; }
  172.         case '8' : { g = g + 8; break; }
  173.         case '9' : { g = g + 9; break; }
  174.         case 'A' : { g = g + 10; break; }
  175.         case 'B' : { g = g + 11; break; }
  176.         case 'C' : { g = g + 12; break; }
  177.         case 'D' : { g = g + 13; break; }
  178.         case 'E' : { g = g + 14; break; }
  179.         case 'F' : { g = g + 15; break; }
  180.     }
  181.  
  182. /* BLUE ********************************************/
  183.     switch (blue[0]) {
  184.         case '0' : { b = 0; break; }
  185.         case '1' : { b = 16; break; }
  186.         case '2' : { b = 32; break; }
  187.         case '3' : { b = 48; break; }
  188.         case '4' : { b = 64; break; }
  189.         case '5' : { b = 80; break; }
  190.         case '6' : { b = 96; break; }
  191.         case '7' : { b = 112; break; }
  192.         case '8' : { b = 128; break; }
  193.         case '9' : { b = 144; break; }
  194.         case 'A' : { b = 160; break; }
  195.         case 'B' : { b = 176; break; }
  196.         case 'C' : { b = 192; break; }
  197.         case 'D' : { b = 208; break; }
  198.         case 'E' : { b = 224; break; }
  199.         case 'F' : { b = 240; break; }
  200.     }
  201.  
  202.     switch (blue[1]) {
  203.         case '0' : { b = b + 0; break; }
  204.         case '1' : { b = b + 1; break; }
  205.         case '2' : { b = b + 2; break; }
  206.         case '3' : { b = b + 3; break; }
  207.         case '4' : { b = b + 4; break; }
  208.         case '5' : { b = b + 5; break; }
  209.         case '6' : { b = b + 6; break; }
  210.         case '7' : { b = b + 7; break; }
  211.         case '8' : { b = b + 8; break; }
  212.         case '9' : { b = b + 9; break; }
  213.         case 'A' : { b = b + 10; break; }
  214.         case 'B' : { b = b + 11; break; }
  215.         case 'C' : { b = b + 12; break; }
  216.         case 'D' : { b = b + 13; break; }
  217.         case 'E' : { b = b + 14; break; }
  218.         case 'F' : { b = b + 15; break; }
  219.     }
  220. } /* end of Hex to RGB */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement