Se non fosse chiaro la Rainbow Ring V3 mi ha conquistato, sarà la forma circolare, saranno i suoi led RGB, che personalmente adoro, ho deciso di provare a realizzare il mio progetto di RTC Rainbow Ring V3, un orologio luminoso.
Questo tutorial è la prima parte del progetto, ho iniziato ponedomi una domanda, come rappresnto 60 secondi con soli 12 led RGB?
Se hai suggerimenti commenta questo articolo ed io proverò a verificare se sono fattibili, le mie idee persoanli sono state 2:
- accendo un led ogni 5 secondi;
- accendo un led al secondo ma ogni 12 cambio colore;
Indovina cosa ho scelto di implementare? “La seconda che hai detto” avrebbe detto Quelo:
se vuoi puoi sperimentare la prima soluzione e inviarmi il tuo codice per pubblicarlo, avere altri punti di vista ed idee fa crescere tutti.
Come visualizzare i secondi sul RTC Rainbow Ring V3
Nell’articolo introduttivo alla Rainbow LED Ring V3 Arduino – IDE 1.0 hai letto come utilizzare la tua arduino uno R3 per programmare la Rainbow Ring V3, e nel wiki della shield trovi tutti i comandi che puoi utilizzare per controllare i 12 led RGB installati.
Avendo scelto la seconda soluzione dovrai definire i colori da utilizzare per ciascuna delle sequenze di 12 secondi, in pratica 60 / 12 = 5 quindi dovrai scegliere 5 colori da assegnare a ciascuno dei cicli di 12 secondi che utilizzerai per visualizzare i second trascorsi.
Poichè ciascun colore è definito come la somma delle componenti RGB ( Red, Green, Bleu ) ed il comendo che utilizzi per impostare il colore del led è:
set_led_rgb(led, R, G, B);
il primo parametro indica il led a cui inviare il comado, il secondo parametro rappresenta la componente rosso ( R ) da 0 a 64, il terzo parametro rappresenta la componente verde ( G ) da 0 a 64, il quarto parametro rappresenta la componente bleu ( B ) da 0 a 64.
I colori che ho scelto sono:
- 0-11 secondi => RGB = 64,0,0
- 12-23 secondi => RGB = 0,64,0
- 24-35 secondi => RGB = 0,0,64
- 36-47 secondi => RGB = 64,32,0
- 48-59 secondi => RGB = 0,64,32
Lo sketch dell’RTC Rainbow Ring V3
lo sketch è alquanto semplice, volutamente non ho scritto tantissime righe di codice perchè la complessità di questo sketch crescerà nei futuri articoli, è importante che questa parte ti sia chiara da subito:
#include "RTC_Ring_V3.h" int S1 = 3; int S2 = 4; int led=0; int R=0; int G=0; int B=0; void setup() { InitIO(); pinMode(S1, INPUT); pinMode(S2, INPUT); digitalWrite(S1, HIGH); digitalWrite(S2, HIGH); } void loop() { for (int i=0; i<60; i++) { if ( i >= 0 && i < 12) { led=i; R=64; G=0; B=0; } if ( i >= 12 && i < 24) { led=(i-12); R=0; G=64; B=0; } if ( i >= 24 && i < 36) { led=(i-24); R=0; G=0; B=64; } if ( i >= 36 && i < 48) { led=(i-36); R=64; G=32; B=0; } if ( i >= 48 && i < 60) { led=(i-48); R=0; G=64; B=32; } set_led_rgb(led, R, G, B); delay(1000); } }
la prima linea include il file RTC_Ring_V3.h che ti riporto, ma che puoi scaricare dalla wiki ufficiale:
#include <stdint.h> #include <avr/io.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> #include <WProgram.h> #include <WConstants.h> #include <util/delay.h> /*============================================================================= other functions =============================================================================*/ #define NEW_LED //#define UART #define __leds 12 #define __max_led __leds - 1 #define __brightness_levels 64 #define __max_brightness __brightness_levels-1 // Starting from the D10,Clockwise #define LED0 PORTB4 #define LED1 PORTB3 #define LED2 PORTB2 #define LED3 PORTB1 #define LED4 PORTB0 #define LED5 PORTB5 // Starting from the D1 ,Clockwise //#define LED0 PORTB5 //#define LED1 PORTB4 //#define LED2 PORTB3 //#define LED3 PORTB2 //#define LED4 PORTB1 //#define LED5 PORTB0 #if defined NEW_LED #define RED_A PORTC1 #define GREEN_A PORTC0 #define BLUE_A PORTC2 #define RED_B PORTD5 #define GREEN_B PORTD6 #define BLUE_B PORTD7 #elif #define RED_A PORTC1 #define GREEN_A PORTC2 #define BLUE_A PORTC0 #define RED_B PORTD5 #define GREEN_B PORTD7 #define BLUE_B PORTD6 #endif #define ALED ((1 << RED_A) | (1 << GREEN_A) | (1 << BLUE_A)) #define BLED ((1 << RED_B) | (1 << GREEN_B) | (1 << BLUE_B)) #define CDDR_A DDRC #define CPORT_A PORTC #define CDDR_B DDRD #define CPORT_B PORTD #define ALLLED ((1<<LED0)|(1<<LED1)|(1<<LED2)|(1<<LED3)|(1<<LED4)|(1<<LED5)) #define __TIMER1_MAX 0xFF // 8 bit CTR #define __TIMER1_CNT 0x30 // this may have to be adjusted if "__brightness_levels" is changed too much #ifndef BAUD_RATE #define BAUD_RATE 19200 #endif #define RX_SIZE 64 /* UART receive buffer size (must be 2^n ) <=256 */ #define TX_SIZE 64 /* UART transmit buffer size (must be 2^n, 16<= ~ <=256 ) */ #define RX_MASK (RX_SIZE-1) #define TX_MASK (TX_SIZE-1) #define COMMAND_SIZE 30 #define __fade__delay_ms 5 enum COLOR_t { BLACK, RED, GREEN, BLUE, YELLOW, TURQUOISE, FUCHSIA, WHITE }; enum DIRECTION_t { NONE, CW, CCW }; /*============================================================================= other functions =============================================================================*/ uint8_t arrange[6]={(1<<LED0),(1<<LED1),(1<<LED2),(1<<LED3),(1<<LED4),(1<<LED5)}; static uint16_t wobble=0x0FFF; uint8_t brightness[3][__leds]; /* memory for RED LEDs */ uint8_t ReceivePtr; uint8_t rx_buf[RX_SIZE]; uint8_t Command_Length; uint8_t Command[COMMAND_SIZE]; uint16_t wobble_pattern_1[__leds] = { 0b0000000000000001, 0b0000000000000010, 0b0000000000000100, 0b0000000000001000, 0b0000000000010000, 0b0000000000100000, 0b0000000001000000, 0b0000000010000000, 0b0000000100000000, 0b0000001000000000, 0b0000010000000000, 0b0000100000000000 }; uint16_t wobble_pattern_2[__leds] = { 0b0000000000000001, 0b0000100000000010, 0b0000010000001000, 0b0000001000001000, 0b0000000100010000, 0b0000000010100000, 0b0000000001000000, 0b0000000010100000, 0b0000000100010000, 0b0000001000001000, 0b0000010000000100, 0b0000100000000010 }; uint16_t wobble_pattern_3[__leds] = { 0b0000000000000001, 0b0000100000000010, 0b0000010000001000, 0b0000001000001000, 0b0000000100010000, 0b0000000010100000, 0b0000000001000000, 0b0000000010100000, 0b0000000100010000, 0b0000001000001000, 0b0000010000000100, 0b0000100000000010 }; #ifdef UART void InitUART(void); #endif void clearCommand(void); void savebuff(void); void random_leds (void); void fader (void); void fader_hue (void); void color_wave (uint8_t width) ; void setwobble(uint16_t var); void set_led_red (uint8_t led, uint8_t red) ; void set_led_green (uint8_t led, uint8_t green) ; void set_led_blue (uint8_t led, uint8_t blue) ; void set_led_rgb (uint8_t led, uint8_t red, uint8_t green, uint8_t blue); void set_all_rgb (uint8_t red, uint8_t green, uint8_t blue) ; void set_led_unicolor(uint8_t led, uint8_t rgb, uint8_t var); void set_all_unicolor(uint8_t rgb, uint8_t var); void set_all_hsv (uint16_t hue, uint8_t sat, uint8_t val) ; void set_all_byte_hsv (uint8_t data_byte, uint16_t hue, uint8_t sat, uint8_t val); void set_led_hsv (uint8_t led, uint16_t hue, uint8_t sat, uint8_t val); void setup_timer2_ovf (void); void enable_timer2_ovf (void); void disable_timer2_ovf (void); #define ALLLEDBLACK() set_all_rgb( 0,0,0) #define ALLLEDRED() set_all_rgb( __max_brightness,0,0) #define ALLLEDYELLO() set_all_rgb( __max_brightness, __max_brightness,0) #define ALLLEDGREEN() set_all_rgb( 0,__max_brightness,0) #define ALLLEDTURQUOISE() set_all_rgb( 0,__max_brightness, __max_brightness) #define ALLLEDBLUE() set_all_rgb( 0,0,__max_brightness) #define ALLLEDFUCHSIA() set_all_rgb( __max_brightness,0,__max_brightness) #define ALLLEDWHITE() set_all_rgb( __max_brightness,__max_brightness,__max_brightness) // -----------------------Function InitIO-------------------------------// void InitIO(void){ DDRB |= ALLLED; // set PORTB as output PORTB &=~ ALLLED; // all pins HIGH --> cathodes HIGH --> LEDs off CDDR_A |= ALED; // set COLORPORT #5-7 as output CPORT_A &= ~ALED; // pins #5-7 LOW --> anodes LOW --> LEDs off CDDR_B |= BLED; // set COLORPORT #5-7 as output CPORT_B &= ~BLED; // pins #5-7 LOW --> anodes LOW --> LEDs off set_all_rgb (0, 0, 0); setup_timer2_ovf (); enable_timer2_ovf (); } // -----------------------Function InitUART-------------------------------// #ifdef UART void InitUART(void){ /* initialize UART(s) depending on CPU defined */ #if defined(__AVR_ATmega88__) || defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) #ifdef DOUBLE_SPEED UCSR0A = (1<<U2X0); //Double speed mode USART0 UBRR0L = (uint8_t)(F_CPU/(BAUD_RATE*8L)-1); UBRR0H = (F_CPU/(BAUD_RATE*8L)-1) >> 8; #else UBRR0L = (uint8_t)(F_CPU/(BAUD_RATE*16L)-1); UBRR0H = (F_CPU/(BAUD_RATE*16L)-1) >> 8; #endif UCSR0B = (1<<RXCIE0) | (1<<RXEN0) | (1<<TXEN0); UCSR0C = (1<<UCSZ00) | (1<<UCSZ01); #elif defined __AVR_ATmega8__ /* m8 */ UBRRH = (((F_CPU/BAUD_RATE)/16)-1)>>8; // set baud rate UBRRL = (((F_CPU/BAUD_RATE)/16)-1); UCSRB = (1<<RXCIE) | (1<<RXEN)|(1<<TXEN); // enable Rx & Tx UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // config USART; 8N1 #endif DDRD &= ~_BV(PORTD0); PORTD |= _BV(PORTD0); } // -----------------------Function USART_ISR-------------------------------// ISR(USART_RX_vect){ uint8_t status = UCSR0A, data = UDR0; status &= (1<<FE0) | (1<<DOR0) | (1<<UPE0); if(status == 0) { /* û�н��մ����� */ if (data>0xDF) ReceivePtr=0; if (data<0xF8) rx_buf[ReceivePtr] = data; ReceivePtr++; if(ReceivePtr==RX_MASK) ReceivePtr=COMMAND_SIZE+1; //ReceivePtr =(ReceivePtr+1) & RX_MASK; else if((ReceivePtr<=COMMAND_SIZE) && (rx_buf[0]==data)) savebuff(); } } #endif // -----------------------Function clearCommand-------------------------------// void clearCommand(void){ for(char i=0;i<COMMAND_SIZE;i++) Command[i] = 0; } // -----------------------Function savebuff-------------------------------// void savebuff(void){ for(char i=0;i<COMMAND_SIZE;i++){ Command[i]= rx_buf[i] ; } } /*============================================================================= other functions =============================================================================*/ // -----------------------Function random_leds-------------------------------// void random_leds (void){ set_led_hsv ((uint8_t) (random (__leds)), (uint16_t) (random (360)), 255, 255); } // -----------------------Function fader-------------------------------// void fader (void){ /* fade the matrix form BLACK to WHITE and back */ uint8_t ctr1; uint8_t led; for (ctr1 = 0; ctr1 <= __max_brightness; ctr1++) { set_all_rgb (ctr1, ctr1, ctr1); delay(__fade__delay_ms); } for (ctr1 = __max_brightness; (ctr1 >= 0) & (ctr1 != 255); ctr1--) { set_all_rgb (ctr1, ctr1, ctr1); delay(__fade__delay_ms); } } // -----------------------Function fader_hue-------------------------------// void fader_hue (void){ /* cycle the color of the whole matrix */ uint16_t ctr1; for (ctr1 = 0; ctr1 < 360; ctr1 = ctr1 + 3) { set_all_hsv (ctr1, 255, 255); delay(__fade__delay_ms ); } } // -----------------------Function color_wave-------------------------------// void color_wave (uint8_t width) { uint8_t led; static uint16_t shift = 0; for (led = 0; led <= __max_led; led++) { set_led_hsv (led, (uint16_t)(led) * (uint16_t)(width) + shift, 255, 255); } shift++; } // -----------------------Function sequence-------------------------------// void sequence (void) { uint8_t led; static uint16_t shift = 0; uint8_t ls = 0; for (ls = 0; ls <= __max_led; ls++) { disable_timer2_ovf(); for (led = 0; led <= __max_led; led++) { if(wobble_pattern_1[ls] & (0x0001<< led)){ set_led_hsv (led, (uint16_t)(led) * (uint16_t)(ls) * shift, 255, 255); shift++; }else{ set_led_rgb(led,0,0,0); } } enable_timer2_ovf(); _delay_ms(10); } } /* void swaywobble (void) { uint8_t led; static uint16_t shift = 0; uint8_t ls = 0; for (ls = 0; ls <= __max_led; ls++) { for (led = 0; led <= __max_led; led++) { if(wobble_pattern_2[__max_led-ls] & (0x0001<< led)){ set_led_hsv (led, (uint16_t)(led) * (uint16_t)(ls) * shift, 255, 255); shift++; }else{ set_led_rgb(led,0,0,0); } } _delay_ms(20); } } */ // -----------------------Function swaywobble-------------------------------// void swaywobble (uint8_t _delay,uint8_t dir) { uint8_t ls = 0; if(dir==CW){ for (ls = 0; ls <= __max_led; ls++) { setwobble(wobble_pattern_3[ls]); delay(_delay); } } if(dir==CCW){ for (ls = __max_led; ls >= 0; ls--) { setwobble(wobble_pattern_3[ls]); delay(_delay); } } } // -----------------------Function turnover-------------------------------// void turnover(uint8_t rgb,uint8_t dir){ uint8_t led, temp, i; if(dir==CCW){ temp=brightness[rgb][0]; for (led = 0; led < __max_led; led++) { brightness[rgb][led]=brightness[rgb][led+1]; } brightness[rgb][led]=temp; } if(dir==CW){ temp=brightness[rgb][__max_led]; for (led = __max_led; led >0; led--) { brightness[rgb][led]=brightness[rgb][led-1]; } brightness[rgb][0]=temp; } } // -----------------------Function rotate-------------------------------// void rotate(uint8_t color,uint8_t dir){ switch (color){ case RED: //R:0 turnover(0,dir); break; case GREEN: //G:1 turnover(1,dir); break; case BLUE: //B:2 turnover(2,dir); break; case YELLOW: //YELLOW RG: turnover(0,dir); turnover(1,dir); break; case TURQUOISE: //TURQUOISE GB turnover(1,dir); turnover(2,dir); break; case FUCHSIA: //FUCHSIA RB turnover(0,dir); turnover(2,dir); break; case WHITE: //WHITE RGB turnover(0,dir); turnover(1,dir); turnover(2,dir); break; } } /*=========================================================================== basic functions to set the LEDs ===========================================================================*/ // -----------------------Function setwobble-------------------------------// void setwobble(uint16_t var){ wobble=var; } // ----------------------Function set_led_red-------------------------------// void set_led_red (uint8_t led, uint8_t red) { #ifdef DOTCORR int8_t dotcorr = (int8_t) (pgm_read_byte (&dotcorr_red[led])) * red / __brightness_levels; uint8_t value; if (red + dotcorr < 0) { value = 0; }else{ value = red + dotcorr; } brightness[0][led] = value; #else brightness[0][led] = red*0.8; #endif } // -----------------------Function set_led_green-------------------------------// void set_led_green (uint8_t led, uint8_t green) { #ifdef DOTCORR int8_t dotcorr = (int8_t) (pgm_read_byte (&dotcorr_green[led])) * green / __brightness_levels; uint8_t value; if (green + dotcorr < 0) { value = 0; } else { value = green + dotcorr; } brightness[1][led] = value; #else brightness[1][led] = green; #endif } // -----------------------Function set_led_blue-------------------------------// void set_led_blue (uint8_t led, uint8_t blue) { #ifdef DOTCORR int8_t dotcorr = (int8_t) (pgm_read_byte (&dotcorr_blue[led])) * blue / __brightness_levels; uint8_t value; if (blue + dotcorr < 0) { value = 0; } else { value = blue + dotcorr; } brightness[2][led] = value; #else brightness[2][led] = blue; #endif } // -----------------------Function set_led_rgb-------------------------------// void set_led_rgb (uint8_t led, uint8_t red, uint8_t green, uint8_t blue){ set_led_red (led, red); set_led_green (led, green); set_led_blue (led, blue); } // -----------------------Function set_all_rgb-------------------------------// void set_all_rgb (uint8_t red, uint8_t green, uint8_t blue) { uint8_t led; for (led = 0; led <= __max_led; led++) { set_led_rgb (led, red, green, blue); } } // -----------------------Function set_led_unicolor-------------------------------// void set_led_unicolor(uint8_t led, uint8_t rgb, uint8_t var){ if(rgb>2 || led>__max_led) return; brightness[rgb][led] = var; } // -----------------------Function set_all_unicolor-------------------------------// void set_all_unicolor(uint8_t rgb, uint8_t var){ uint8_t led; //disable_timer2_ovf(); for (led = 0; led <= __max_led; led++) { set_led_unicolor (led, rgb, var); } //enable_timer2_ovf(); } // -----------------------Function set_all_hsv-------------------------------// void set_all_hsv (uint16_t hue, uint8_t sat, uint8_t val) { uint8_t led; for (led = 0; led <= __max_led; led++) { set_led_hsv (led, hue, sat, val); } } void set_all_byte_hsv (uint8_t data_byte, uint16_t hue, uint8_t sat, uint8_t val){ uint8_t led; for (led = 0; led <= __max_led; led++) { if ((data_byte >> led) & (B00000001)) { set_led_hsv (led, hue, sat, val); }else{ set_led_rgb (led, 0, 0, 0); } } } // -----------------------Function set_led_hsv-------------------------------// void set_led_hsv (uint8_t led, uint16_t hue, uint8_t sat, uint8_t val){ /* BETA */ /* finally thrown out all of the float stuff and replaced with uint16_t * hue: 0-->360 (hue, color) * sat: 0-->255 (saturation) * val: 0-->255 (value, brightness) */ hue = hue % 360; uint8_t sector = hue / 60; uint8_t rel_pos = hue - (sector * 60); uint16_t const mmd = 255 * 255; /* maximum modulation depth */ uint16_t top = val * 255; uint16_t bottom = val * (255 - sat); /* (val*255) - (val*255)*(sat/255) */ uint16_t slope = (uint16_t)(val) * (uint16_t)(sat) / 120; /* dy/dx = (top-bottom)/(2*60) -- val*sat: modulation_depth dy */ uint16_t a = bottom + slope * rel_pos; uint16_t b = bottom + (uint16_t)(val) * (uint16_t)(sat) / 2 + slope * rel_pos; uint16_t c = top - slope * rel_pos; uint16_t d = top - (uint16_t)(val) * (uint16_t)(sat) / 2 - slope * rel_pos; uint16_t R, G, B; if (sector == 0) { R = c; G = a; B = bottom; }else if (sector == 1) { R = d; G = b; B = bottom; }else if (sector == 2) { R = bottom; G = c; B = a; }else if (sector == 3) { R = bottom; G = d; B = b; }else if (sector == 4) { R = a; G = bottom; B = c; } else { R = b; G = bottom; B = d; } uint16_t scale_factor = mmd / __max_brightness; R = (uint8_t) (R / scale_factor); G = (uint8_t) (G / scale_factor); B = (uint8_t) (B / scale_factor); set_led_rgb (led, R, G, B); } /*============================================================================= Functions dealing with hardware specific jobs / settings ==============================================================================*/ // -----------------------Function swaywobble-------------------------------// void setup_timer2_ovf (void) { // Arduino runs at 8 Mhz... // Timer2 (8bit) Settings: // prescaler (frequency divider) values: CS12 CS11 CS10 // 0 0 0 stopped // 0 0 1 /1 // 0 1 0 /8 // 0 1 1 /32 // 1 0 0 /64 // 1 0 1 /128 // 1 1 0 /256 // 1 1 1 /1024 TCCR2B |= ((1 << CS22) | (1 << CS20) | ((1 << CS21))); //1024� //normal mode (16bit counter) TCCR2B &=~(1 << WGM22); TCCR2A =0; // enable global interrupts flag sei (); } // -----------------------Function swaywobble-------------------------------// void enable_timer2_ovf (void){ TCNT2 = __TIMER1_MAX - __TIMER1_CNT; TIMSK2 |= (1 << TOIE2); } // -----------------------Function swaywobble-------------------------------// void disable_timer2_ovf (void) { PORTB &=~ ALLLED; TIMSK2 &= ~(1 << TOIE2); } // -----------------------Function swaywobble-------------------------------// ISR (TIMER2_OVF_vect){ /* Framebuffer interrupt routine */ TCNT2 = __TIMER1_MAX - __TIMER1_CNT; uint8_t cycle; uint8_t led; uint8_t times; uint8_t Atmp,Btmp; uint16_t tp=0x0001; for (cycle = 0; cycle < __max_brightness; cycle++) { tp=0x0001; led = 0; for (times = 0; times < 6; times++) { CPORT_A &= ~ALED; // all relevant anodes LOW --> OFF CPORT_B &= ~BLED; PORTB &=~ ALLLED; // all cathodes HIGH --> OFF Atmp=0;Btmp=0; PORTB |= arrange[times]; if(wobble & tp) { if (cycle < brightness[1][led]) Atmp |= (1 << GREEN_A); if (cycle < brightness[2][led]) Atmp |= (1 << BLUE_A); if (cycle < brightness[0][led]) Atmp |= (1 << RED_A); } led++; tp = tp<<1; //CPORT_A &= ~ALED; if(wobble & tp) { if (cycle < brightness[1][led]) Btmp |= (1 << GREEN_B); if (cycle < brightness[2][led]) Btmp |= (1 << BLUE_B); if (cycle < brightness[0][led]) Btmp |= (1 << RED_B); } CPORT_B |= Btmp; CPORT_A |= Atmp; asm("nop"); led++; tp = tp<<1; //CPORT_B &= ~BLED; //PORTB &=~ ALLLED; } } CPORT_A &= ~ALED; // all relevant anodes LOW --> OFF CPORT_B &= ~BLED; PORTB &=~ ALLLED; // all cathodes HIGH --> OFF } /* * PWM_BLOCK_END: all functions in this block are related to PWM mode ! */
le linee 03-04: definisci i pin a cui sono collegati i microswitch S1 ed S2, non puoi cambiare tali pin essendo i pulsanti saldati sulla scheda;
linee 06-09: definisci le variabili led, R, G, B, in cui memorizzerai i valori da inviare al comando di accensione dei led;
linea 12: richiama la funzione InitIO() presente nel file RTC_Ring_V3.h che provvede a impostare la gestione dei led con i comandi che vedrai in seguito;
linee 14-17: inizializza la modalità di funzionamento per i due pulsanti e invia il segnale HIGH ad entrambi.
linea 22: imposta il ciclo dei secondi ( 60 );
linea 24: confronta il valore di i con il range da 0 a 11 ( <12 ) e se i è in questo range imposta led allo stesso valore di i e i rispettivi valori di R,G e B come da tabella vista sopra.
linee 25-28: esegui le medesime considerazioni della linea 24 con la sola differenza dei valori impostati per R,G e B e per il valore di led a cui sottrai sempre il valore minimo del range essendo i led sempre 12 quindi con indice 0-12;
linea 30: invia i valori impostati al led corrispondente con il comendo set_led_rgb( led,R,G,B ) accendendo il led corrispondente al primo parametro con i valori definiti dai successivi parametri;
linea 31: attendi 1000 millisecondi = 1 secondo prima di ricominciare il ciclo di loop();
Il video dell’RTC Rainbow Ring V3
ho realizzato anche un piccolo video dell’RTC Rainbow Ring V3 in funzione sia con la luce sia al buio:
Buon divertimento
Prima di inserire un commento, per favore, leggi il regolamento
5 pings
[…] RTC rainbow ring v3 […]