Illuminazione intelligente con telecomando Arduino

CONTENUTO ►

Progetto su striscia LED indirizzabile per creare un’illuminazione intelligente della stanza con un sensore di movimento e la possibilità di regolare (colore, luminosità ed effetti luminosi) tramite telecomando. Tutte le impostazioni sono memorizzate nella memoria eeprom non volatile di Arduino. In questa pagina è possibile vedere lo schema dell’assemblaggio della retroilluminazione intelligente e il programma di lavoro per la scheda Arduino.




Per questa attività sono necessari:

  • Arduino Uno / Arduino Nano / Arduino Mega
  • led indirizzabili ws2812 / ws2811
  • sensore di movimento PIR
  • ricevitore IR e telecomando
  • resistenza da 100 a 500 ohm
  • libreria IRremote.h, EEPROM.h e Adafruit_NeoPixel.h

Utilizzando il telecomando IR, il programma consente di regolare a distanza il colore del nastro indirizzabile (tutti i colori possono essere regolati separatamente), la luminosità dell’illuminazione e la selezione dell’effetto quando il sensore di movimento viene attivato. Nello sketch c’è la possibilità di impostare il periodo di tempo dopo il quale la luce si spegne in assenza di movimento, nonché la velocità di accensione degli effetti visivi.

Arduino illuminazione intelligente con telecomando IR

Illuminazione intelligente con telecomando Arduino
Illuminazione intelligente con telecomando IR Arduino

Lo schema di montaggio di questo progetto è mostrato nell’immagine qui sopra; si noti che il nastro ws2811 richiederà un’alimentazione a 12 volt e il nastro ws2812 o ws2815 richiederà un’alimentazione a 5 volt. Lo schema di cablaggio del nastro indirizzabile e del microcontrollore Arduino rimane invariato. È inoltre necessario avere un numero pari di LED nella striscia indirizzabile per l’accensione simmetrica degli effetti luminosi.

Programma Arduino per illuminazione con telecomando IR




#include "EEPROM.h"
#include "IRremote.h"
#include "Adafruit_NeoPixel.h"

// pin per ricevitore IR, la striscia led, rilevatore pir
#define IR_PIN    2
#define LED_PIN 7
#define PIR_PIN  A1

int PIX = 119; // numero di LED nella striscia
int TIME = 1;  // dopo quanti minuti l'illuminazione deve essere spenta

#define ENT 16726215   // entrare in modalità di configurazione
#define RGT 16734885   // rallentare l'accensione
#define LFT 16716015   // accelerare l'accensione
#define TOP 16718055   // aumentare la luminosità
#define BOT 16730805   // ridurre la luminosità
#define EF1 16753245   // effetto primario
#define EF2 16736925   // secondo effetto
#define EF3 16769565   // terzo effetto
#define RED 16769055   // regolazione del colore rosso
#define GRN 16754775   // regolazione del colore verde
#define BLU 16748655   // regolazione del colore blu
#define UPD 16756815   // salvare le impostazioni

int pix_l_start = 0;
int pix_l_finis = PIX / 2;
int pix_r_start = PIX / 2;
int pix_r_finis = PIX;
int brg, del, p, x, i, j, e, w;
byte r, g, b;
unsigned long timer;
unsigned long t = t * 60 * 1000;

IRrecv irrecv(IR_PIN);
decode_results results;
Adafruit_NeoPixel strip (PIX, LED_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  r = EEPROM.read(1);
  g = EEPROM.read(2);
  b = EEPROM.read(3);
  brg = EEPROM.read(4);
  del = EEPROM.read(5);
  e = EEPROM.read(6);

  Serial.begin(9600);
  irrecv.enableIRIn();
  strip.begin();
  strip.setBrightness(brg);
  strip.clear();
  pinMode(IR_PIN, INPUT);
  pinMode(PIR_PIN, INPUT);
}

void loop() {
  p = digitalRead(A1);
  delay(100);

  if (p == HIGH && x == 0) { effect(e); svet(); x = 1; }
  if (p == LOW && x == 1) { timer = millis(); x = 2; }
  if (p == LOW && x == 2 && millis() - timer > t) {
    timer = millis(); vykluchenie(); x = 0; }
  if (p == HIGH && x == 2) { x = 1; }

  if (irrecv.decode(&results)) {
    Serial.println(results.value);
    if (results.value == ENT) { demo(); w = 1; }
    irrecv.resume();
  }

  while (w == 1) {
    // emettere il segnale IR al monitor della porta
    if (irrecv.decode(&results)) {
      Serial.println(results.value);
 
      // regolazione dell'effetto luce
      if (results.value == EF1) { e = 1; effect(e); strip.clear(); }
      if (results.value == EF2) { e = 2; effect(e); strip.clear(); }
      if (results.value == EF3) { e = 3; effect(e); strip.clear(); }
 
      // regolazione della luminosità dell'illuminazione
      if (results.value == TOP) { brg=brg+60; if (brg > 240) { brg=240; } }
      if (results.value == BOT) { brg=brg-60; if (brg < 60) { brg=60; } }
 
      // regolazione della velocità di illuminazione
      if (results.value == LFT) {
        del=del-10; if (del < 0) { del=0; } effect(e); strip.clear(); }
      if (results.value == RGT) {
        del=del+10; if (del > 50) { del=50; } effect(e); strip.clear(); }
 
      // regolazione del colore dell'illuminazione
      if (results.value == RED) { r=r+60; if (r > 240 || r < 60) { r=0; } }
      if (results.value == GRN) { g=g+60; if (g > 240 || g < 60) { g=0; } }
      if (results.value == BLU) { b=b+60; if (b > 240 || b < 60) { b=0; } }
 
      // UPD - salvare le impostazioni nella eeprom
      if (results.value == UPD) {
        delay(1); EEPROM.update(1, r);
        delay(1); EEPROM.update(2, g);
        delay(1); EEPROM.update(3, b);
        delay(1); EEPROM.update(4, brg);
        delay(1); EEPROM.update(5, del);
        delay(1); EEPROM.update(6, e);
        delay(1); effect(e);
      }
 
      // uscire dalla modalità di impostazione
      if (results.value == ENT) { effect(e); strip.clear(); w = 0; }
      demo();
      irrecv.resume();
    }
  }
}
 
// illuminazione accesa in modalità di impostazione
void demo() {
  strip.clear();
  strip.setBrightness(brg);
  for (i = 0; i < PIX; i = i + 2) {
    strip.setPixelColor(i, strip.Color(r, g, b));
    strip.show();
  }
}
 
// modalità di illuminazione di base
void svet() {
  strip.setBrightness(brg);
  for (i = 0; i < PIX; i++) {
    strip.setPixelColor(i, strip.Color(r, g, b));
    strip.show();
  } 
}
 
// arrêt progressif
void vykluchenie() {
  for ( j = brg; j >= 0; j = j - 20) {
    strip.setBrightness(j);
    for ( i = pix_l_start; i <= pix_r_finis; i++) {
      strip.setPixelColor(i, strip.Color(r, g, b));
      strip.show();
    }
  }
}

void effect(int e) {
  strip.clear();
  strip.setBrightness(brg);

  // attivare la striscia di indirizzi con primo effetto
  while (e == 1) {
    j = 0;
    for (i = pix_r_start; i <= pix_r_finis; i++) {
      j++;
      strip.setPixelColor(i, r / 3, g / 3, b / 3);
      strip.setPixelColor(pix_l_finis - j, r / 3, g / 3, b / 3);
      strip.show();
      delay(del);
      }
    j = 0;
    for ( i = pix_r_finis; i >= pix_r_start; i--) {
      j++;       
      strip.setPixelColor(i, r / 2, g / 2, b / 2);
      strip.setPixelColor(i + 1,  r / 2, g / 2, b / 2);
      strip.setPixelColor(i + 2,  r / 2, g / 2, b / 2);
      strip.setPixelColor(i + 3,  r / 3, g / 3, b / 3);
      strip.setPixelColor(pix_l_start + j, r / 2, g / 2, b / 2);
      strip.setPixelColor(pix_l_start + j - 1,  r / 2, g / 2, b / 2);
      strip.setPixelColor(pix_l_start + j - 2,  r / 2, g / 2, b / 2);
      strip.setPixelColor(pix_l_start + j - 3,  r / 3, g / 3, b / 3);
      strip.show();
      delay(del);
      }
    j = 0;
    for (i = pix_r_start; i <= pix_r_finis; i++) {
      j++;
      strip.setPixelColor(i, r, g, b);
      strip.setPixelColor(pix_l_finis - j, r, g, b);
      strip.show();
      delay(del);
      }
    break;
  }

  // attivare la striscia di indirizzi con secondo effetto
  while (e == 2) {
    pix_l_finis = PIX / 2;
    while (pix_l_finis > 0) {
      j = 0;
      for ( i = pix_l_start; i <= pix_l_finis; i++) {
        j++;
        strip.setPixelColor(i, r / 2, g / 2, b / 2);
        strip.setPixelColor(i - 1,  r / 2, g / 2, b / 2);
        strip.setPixelColor(i - 2,  r / 2, g / 2, b / 2);
        strip.setPixelColor(i - 3,  0, 0, 0);
        strip.setPixelColor(pix_r_finis - j, r / 2, g / 2, b / 2);
        strip.setPixelColor(pix_r_finis - j + 1, r / 2, g / 2, b / 2);
        strip.setPixelColor(pix_r_finis - j + 2, r / 2, g / 2, b / 2);
        strip.setPixelColor(pix_r_finis - j + 3, 0, 0, 0);
        strip.show();
        delay(del / 10);
      }
      pix_l_finis = pix_l_finis - 3;
    }
    pix_l_finis = PIX / 2;
    j = 0;
    for (i = pix_r_start; i <= pix_r_finis; i++) {
      j++;
      strip.setPixelColor(i, r, g, b);
      strip.setPixelColor(pix_l_finis - j, r, g, b);
      strip.show();
      delay(del / 2);
    }
  break;
  }
 
  // attivare la striscia di indirizzi con terzo effetto
  while (e == 3) {
    j = 0;
    for ( j = 0; j <= brg; j = j + 20) {
      strip.setBrightness(j);
      for ( i = pix_l_start; i <= pix_r_finis; i++) {
        strip.setPixelColor(i, strip.Color(r, g, b));
        strip.show();
      }
    }
    break;
  }
}

Spiegazione del codice per illuminazione con telecomando IR:



  1. dopo aver caricato il programma, è necessario specificare i codici dei pulsanti del telecomando, che verranno visualizzati sul monitor della porta IDE di Arduino;
  2. è inoltre necessario specificare nello sketch il numero di LED della striscia (è auspicabile utilizzare un numero pari di LED nella retroilluminazione).

Conclusioni. Dopo il primo caricamento del programma, gli effetti di luce e il colore del nastro saranno visualizzati in modo errato, perché le informazioni con le impostazioni sono prese dalla EEPROM Arduino – per impostazione predefinita il numero 250 è memorizzato nelle celle EEPROM. Di conseguenza, tutte le variabili saranno uguali a 250 al primo caricamento del programma; per correggere questo problema, salvare le impostazioni.

5/5 - (1 vote)


Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.