SHARE
TWEET

Arduino nRF RGB colour changer

stanleyseow Jun 19th, 2013 712 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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 */
RAW Paste Data
Want to get better at C++?
Learn to code C++ in 2017
Pastebin PRO Summer Special!
Get 40% OFF on Pastebin PRO accounts!
Top