Uniwersalny przełącznik IR

[skyguy]

Pomysł
Projekt powstał w celu ułatwienia sobie życia 🙂. A mianowicie nie mam podświetlenia ambient light w TV, więc postanowiłem zamienić sobie lampkę stojącą obok TV na ładne podświetlenie za pomocą paska LED, które będzie wł./wył. za pomocą pilota IR. Jako że na pilocie mam przyciski, których nie używam przy standardowym oglądaniu (REC, REV, PLAY itp.) postanowiłem użyć pilota od TV a nie dodawać do kolekcji kolejnego urządzenia obsługującego tylko pasek LED.

Wykonanie
Projekt powstał tak naprawdę trochę na kolanie z tych części co akurat miałem. Całość oparta jest na ARDUINO NANO. Za pomocą DIODY IR (ja użyłem ze starego tunera DVB-T) ARDUINO odbiera kody z pilota IR i następnie decyduje czy ma przełączyć PRZEKAŹNIK sterujący metrowym PASKIEM LED czy nie. Całość zasilana jest z ZASILACZA 12V. Arduino na stałe pośrednio przez PRZETWORNICĘ DC-DC 5V, a pasek LED przez przekaźnik. Dodatkowo zamontowany jest przycisk w postaci KRAŃCÓWKI do przełączania manualnego (taki „back door” żeby nie trzeba było szukać pilota w razie czego) oraz przechodzenia w tryb programowania. Całość zamknięta w obudowie i zamontowana na plecach TV.

Schemat

Działanie
Po złożeniu wszystkiego podłączamy zasilacz 12V do ~230V i zasilamy układ. Przytrzymujemy przycisk na 10s. układ wchodzi w tryb programowania (2x mrugnięcie dioda LED na arduino), jeżeli przekaźnik był włączony zostanie on wyłączony. Kierujemy pilota na diodę IR i wciskamy pierwszy przycisk służący do włączania (ON), przekaźnik zostanie przełączony, następnie wciskamy kolejny przycisk służący do wyłączania (OFF), przekaźnik zostanie wyłączony. Po udanym programowaniu przekaźnik zostanie ponownie włączony – można już używać pilota. Oczywiście można również zaprogramować ten sam przycisk do ON i OFF. Jeśli chcemy zmienić przyciski do obsługi ponownie wchodzimy w tryb programowania przytrzymując przycisk na obudowie.

OPCJA 2 dla zaawansowanych.
Układ ten również może być wykorzystany do przełączania dowolnego urządzenia ~230V – jedynym ograniczeniem jest zastosowany przekaźnik. W innym projekcie zamiast przetwornicy DC-DC zastosowałem wnętrze ze starej ładowarki 5V (wskazane jest żeby była markowa i izolowana – posiadała transformator). Doprowadzamy do obudowy ~230V rozgałęziamy L. Jeden przewód idzie na przekaźnik drugi do zasilania układu z ładowarki. Rozgałęziamy N. Jeden do Zasilania ładowarki, a drugi do naszego odbiornika. W takim wypadku mamy zasilanie Arduino z ~230V (przez ładowarkę), które może sterować przekaźnikiem. Przekaźnik przełącza napięcie ~230V.

Schemat

KOD

#include <EEPROM.h>
#include <IRremote.h>
#define irPin 11
#define Relay A0
#define Button 12
#define LED 13

IRrecv irrecv(irPin);
decode_results results;

unsigned long Odczyt;
unsigned long Switch_ON;
unsigned long Switch_OFF;

unsigned long Time_1 = 0;
unsigned long Time_2 = 0;
unsigned long Time_3 = 0;

bool buttonState1 = 0;
bool state1 = 0;
bool Program = 0;
bool RelayState = 0;
int Button_Prog = 1;

void setup() {
  Serial.begin(9600);
  irrecv.enableIRIn();

  pinMode(LED, OUTPUT); //Dioda jako wyjście
  pinMode(Relay, OUTPUT); //Dioda jako wyjście

  digitalWrite(LED, LOW); //Wyłączenie diody
  digitalWrite(Relay, HIGH); //Wyłączenie diody

  pinMode(Button, INPUT_PULLUP); //Przycisk jako wejście

  Switch_ON = EEPROMReadlong(1);
  Switch_OFF = EEPROMReadlong(5);

}

void loop() {

  Push();
  Receive();

}

void Receive()
{
  if (irrecv.decode(&results)) {
    Serial.println(Switch_ON);
    Serial.println(Switch_OFF);

    Odczyt = results.value;
    Serial.print("0x");
    Serial.println(Odczyt);
    delay(250);
    irrecv.resume();

    if (Switch_ON == Switch_OFF)
    {
      if ((Odczyt == Switch_ON) || (Odczyt == Switch_OFF))
      {
        RelaySwitch();
       }
    }

    if (Switch_ON != Switch_OFF)
    {
      if (Odczyt == Switch_ON && RelayState == 0)
      {
        RelaySwitchON();
      }
      if (Odczyt == Switch_OFF && RelayState == 1 )
      {
        RelaySwitchOFF();
      }
    }
    irrecv.resume();
  }
}


void Programing()
{
  Button_Prog = 1;
  digitalWrite(Relay, HIGH);
  //Serial.println(Button_Prog);
  Serial.println("---------------");
  Serial.println("Press button ON");
  while (Button_Prog < 3) {
    if (irrecv.decode(&results)) {

      switch (Button_Prog) {
        case 1:
          Odczyt = results.value;
          Serial.print("Recive: ");
          Serial.println(Odczyt);
          Switch_ON = Odczyt;
          Serial.print("Button ON: ");
          Serial.println(Switch_ON);
          EEPROMWritelong(1, Switch_ON);

          delay(1000);
          Serial.println("Relay_ON");
          digitalWrite(LED, HIGH );
          digitalWrite(Relay, LOW);
          RelayState = 1;
          irrecv.resume();
          Button_Prog = 2;
          Serial.println("----------------");
          Serial.println("Press button OFF");
          break;
        case 2:
          Odczyt = results.value;
          Serial.print("Recive: ");
          Serial.println(Odczyt);
          Switch_OFF = Odczyt;
          Serial.print("Button OFF: ");
          Serial.println(Switch_OFF);
          EEPROMWritelong(5, Switch_OFF);
          delay(1000);
          Serial.println("Relay_OFF");
          digitalWrite(LED, LOW );
          digitalWrite(Relay, HIGH);
          RelayState = 0;
          irrecv.resume();
          Button_Prog = 3;
          Program = 0;
          Serial.println("----------------");
          Serial.println("Programing mode OFF");
          Serial.println("*******************");
          delay(1000);
          break;
      }

    }

  }
}

void Push() {

  buttonState1 = digitalRead(Button);

  Time_1 = millis();

  if (buttonState1 == LOW && Program == 0) {
    if (state1 == 0)
    {
      Time_2 = Time_1;
      // Serial.println("Time_1");
      // Serial.println(Time_1);
    }
    state1 = 1;

    //Serial.println("Time_2");
    //Serial.println(Time_2);
    Time_3 = Time_1 - Time_2;
    if (Time_3 >= 3000)
    {
      Serial.println("*******************");
      Serial.println("Programing mode ON");
      digitalWrite(LED, HIGH );
      delay(200);
      digitalWrite(LED, LOW );
      delay(200);
      digitalWrite(LED, HIGH );
      delay(200);
      digitalWrite(LED, LOW );
      Program = 1;
      Programing();
    }
  }

  if (buttonState1 == HIGH) {
    if (state1 == 1)
    {
      //Serial.println("Time_3");
      //Serial.println(Time_3);
      if (Time_3 >= 100 && Program != 1)
      {

        switch (RelayState)
        {
          case 0:
            RelaySwitchON();
            break;
          case 1:
            RelaySwitchOFF();
            break;
        }
      }
      Time_2 = 0;
    }
    state1 = 0;
  }
}

void RelaySwitchON()
{

  Serial.println("Relay_ON");
  digitalWrite(LED, HIGH );
  digitalWrite(Relay, LOW);
  RelayState = 1;
  // Serial.println("RelayState:");
  // Serial.println(RelayState);
  delay(200);
  Time_3 = 0;

}
void RelaySwitchOFF()
{


  Serial.println("Relay_OFF");
  digitalWrite(LED, LOW );
  digitalWrite(Relay, HIGH);
  RelayState = 0;
  //Serial.println("RelayState:");
  //Serial.println(RelayState);
  delay(200);
  Time_3 = 0;

}
void RelaySwitch()
{

  switch (RelayState)
  {
    case 0:
      Serial.println("Relay_ON");
      digitalWrite(LED, HIGH );
      digitalWrite(Relay, LOW);
      RelayState = 1;
      // Serial.println("RelayState:");
      // Serial.println(RelayState);
      delay(200);
      Time_3 = 0;
      break;

    case 1:
      Serial.println("Relay_OFF");
      digitalWrite(LED, LOW );
      digitalWrite(Relay, HIGH);
      RelayState = 0;
      //Serial.println("RelayState:");
      //Serial.println(RelayState);
      delay(200);
      Time_3 = 0;
      break;
  }

}
void EEPROMWritelong(int address, long value)
{
  //Decomposition from a long to 4 bytes by using bitshift.
  //One = Most significant -> Four = Least significant byte
  byte four = (value & 0xFF);
  byte three = ((value >> 8) & 0xFF);
  byte two = ((value >> 16) & 0xFF);
  byte one = ((value >> 24) & 0xFF);

  //Write the 4 bytes into the eeprom memory.
  EEPROM.write(address, four);
  EEPROM.write(address + 1, three);
  EEPROM.write(address + 2, two);
  EEPROM.write(address + 3, one);
}
long EEPROMReadlong(long address)
{
  //Read the 4 bytes from the eeprom memory.
  long four = EEPROM.read(address);
  long three = EEPROM.read(address + 1);
  long two = EEPROM.read(address + 2);
  long one = EEPROM.read(address + 3);

  //Return the recomposed long by using bitshift.
  return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
}

DEBUG

Dodałem również możliwość prostego debagu. Na porcie USB wystawiam w którym miejscu znajdujemy się w programie, czy i jaki numer kodu odebraliśmy z pilota, czy przekaźnik został przełączony.

UWAGA
Jeżeli w pomieszczeniu występują świetlówki lub inne mrugające oświetlenie proces programowania należy przeprowadzić w innym miejscu, lub przy zgaszonym świetle. Mruganie przez świetlówki odbierane jest jako użycie kodu. Po zaprogramowaniu moduł można używać przy włączonym świetle.

Zdjęcia gotowego układu.

[Treker (Damian Szymański)]

@skyguy, właśnie zaakceptowałem opis. Dziękuję za przedstawienie ciekawego projektu, zachęcam do prezentowania kolejnych DIY oraz aktywności na naszym forum 😉

[hashpl]

Witam. Czy można pominąć tutaj opcje programowania, Dodać moduł NRF24l01 ? Chciałbym zrobić załączanie i rozłączanie pieca CO ale z pokoju i z kotłowni. Przy rozpalaniu załączam piec oczywiście z kotłowni przyciskiem który załącza przekaźnik 230 V (załacza się zasilanie sterownika pieca CO). Mierzę temperaturę i wysyłam ją do odbiornika który mam w pokoju. Gdy zauważę że w piecu się już wypala (żeby nie schodzić do kotłowni) chciałbym móc wyłączyć piec (przekaźnik) z pokoju. W razie gdyby nie działał odbiornik w pokoju chciałbym mieć możliwość załączania i rozłączania pieca równiez z kotłowni. Robił ktoś coś takiego na 2 arduino ?