Advertisement
stanleyseow

Arduino nRF RGB colour changer

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