Co to jest moduł przekaźnika?

W ofercie Nettigo pojawił się moduł przekaźnika. Jest tani i kosztuje zaledwie 12 zł. Dziś opiszę po co on jest. W następnych dniach dowiesz się jak go podłączyć do różnych płytek i zaprogramować.

• Przekaźnik Nettigo Relay w sklepie Nettigo

Przekaźnik to taki włącznik sterowany elektronicznie. Można go np. wpiąć zamiast włącznika twojej lampki nocnej. Z drugiej strony podłączasz twoją ulubioną płytkę - kompatybilną z Arduino albo Raspberry PI i możesz kontrolować przełącznik za pomocą programu, przez komputer lub przez internet telefonem.

Wyprowadzenia styków włącznika znajdują przy zaciskach J1. Gdy kontroler wysyła sygnał, to te styki są zwarte, a gdy nie wysyła to są rozwarte i podłączone urządzenie jest wyłączone.

Z drugiej strony są piny sterowania.

• Vcc podłączasz do pinu zasilania 5V w kontrolerze
• GND podłączasz do pinu GND w kontrolerze
• IN podłączasz do dowolnego pinu cyfrowego lub GPIO

Sygnał IN działa tak, że gdy wyślesz mu stan LOW, to przekaźnik nie przewodzi prądu. Gdy wyślesz mu stan HIGH, przekaźnik przewodzi prąd.

Sygnał IN akceptuje poziomy stanów logicznych 5 V i 3.3 V więc wszystkie płytki oparte na AVR (Arduino UNO/LEONARDO/MEGA), jak i na ARM (Arduino DUE, Raspberry PI, Teensy) są obsługiwane.

Moduł przekaźnika wyposażony jest też w LED. Dioda świeci, gdy przekaźnik dostał sygnał i przewodzi prąd.

Moduł pobiera podczas pracy 53 mA prądu.
Jeśli zasilasz Arduino z wyjścia USB, to możesz pobrać z pinu POWER 5V mniej niż 500 mA. Czyli suma prądu pobieranego przez przekaźniki nie może przekraczać tej wartości.

500 mA / 53 mA = 9 przekaźników

Możesz podłączyć do takiego Arduino około 9 modułów.

Gdy zasilasz Arduino przez wtyk zasilacza, zasilaczem około 1 A, wtedy z pinu POWER 5V możesz pobrać około 700 mA prądu.

Gdy chcesz zastosować jeszcze więcej modułów, musisz zasilić je osobnym przewodem z zasilacza, który ma odpowiednią ilość amperów. Większą niż suma poboru prądu przez przekaźniki.

Składanie modułu przekaźnika

W zestawie dostajesz:

1. Płytkę drukowaną (to żółte)
2. Przekaźnik (ten biały klocek)
3. Złącze zaciskowe na 3 przewody (to niebieskie z 3 dziurkami)
4. Złącze zaciskowe na 2 przewody (to niebieskie z 2 dziurkami)
5. Rezystor 10 k Ohm (prosty element z kolorową obudową oznaczony kolorami - brązowy, czarny, czarny, czerwony, brązowy)
6. Rezystor 220 Ohm (prosty element oznaczony kolorami - czerwony, czerwony, czarny, czarny, brązowy)
7. Diodę krzemową (podobne do rezystora, tylko czarne z jedną szarą kreską)
8. LED (czerwony element z 2 nierównymi nóżkami)
9. Tranzystor (czarny element z 3 wyprowadzeniami)

Pozwoliłem sobie narysować małą ściągę, która będzie pomocna przy składaniu płytki.

Jeśli nie jesteś pewny oznaczeń rezystorów, możesz ich wartość zmierzyć za pomocą multimetru.

Do lutowania przydały mi się następujące narzędzia:

• Lutownica (nagrzewa się i roztapia cynę. Trzeba wiedzieć za który koniec łapać. Łapanie za zły koniec może się źle skończyć).
• Cyna (spoiwo lutownicze do trwałego łączenia elementów z płytką na gorąco)
• "Trzecia ręka" (zestaw szczypczyków z lupą połączonych razem) - do wygodnego podtrzymywania płytki, żeby skupić się na lutowaniu.

Gdy zgromadzisz już to wszystko, pora zabrać się do pracy.
Ja zaczynam od lutowania najniższych elementów - diody D1 i rezystorów.

Wyginam im nóżki w ten sposób by pasowały w miejsce otworów na płytce.

Elementy umieszczam na płytce w ten sposób.

• Diodę krzemową w miejsce D1 - musisz uważać by pasek na diodzie był w tym samym miejscu co oznaczenie paska na płytce. Na zdjęciu pasek skierowany jest w górę do zewnątrz płytki.
• Rezystor 10 kOhm w miejsce R1
• Rezystor 220 Ohm w miejsce R2

Od dolnej strony płytki, w miejscu lutowania rozginam nóżki elementów do zewnątrz, by elementy nie wypadały i nie przesuwały się podczas lutowania.

Teraz chwila prawdy.

Do punktu lutowniczego dotykam rozgrzaną lutownicą. Z drugiej strony do grotu lutownicy (zaostrzonej końcówki), możliwie blisko ostrza dotykam cyną - tak by spływała i wypełniała punkt lutowniczy.

Cyny nie może być za mało bo powstają nietrwałe zimne luty. Nie może jej być też za dużo, bo powstaje brzydki bąbel, który może powodować zwarcia z innymi elementami.

Nie powinieneś też przykładać lutownicy zbyt długo do końcówki lutowniczej. Element, który lutujesz może się zbytnio rozgrzać i uszkodzić. Lepiej zachować odrobinę cierpliwości i gdy lutowanie nie wychodzi odczekać chwilę aż element ostygnie.

Po wlutowaniu, odstające nóżki przewodów obcinam nad punktami lutowniczymi. Można do tego użyć specjalnych szczypiec. Ja używam starych obcinaczek do paznokci #cebula.

Kolejne elementy, które wlutowałem to dioda LED i tranzystor.

Tranzystor umieściłem w miejscu T1. Trzeba go włożyć tak, by ścięta strona jego obudowy była w tym samym kierunku co jej wizerunek nadrukowany na płytce.

LED wkładasz tak, by krótsza noga katody wchodziła w otwór przy krawędzi płytki, a dłuższa anody, wchodziła od środka płytki.

Kolejnym elementem do zamontowania są zaciski przewodów.

Mogą one łatwo wypadać, dlatego warto przytrzymać je jednym z zacisków “trzeciej rączki”.

Teraz brakuje nam tylko jednego, najważniejszego i największego elementu - przekaźnika.

Bardzo łatwo go włożyć, bo pasuje tylko w jedną stronę do płytki.

Przekaźnik też warto przytrzymać zaciskiem “trzeciej rączki”. Uważaj by przylegał równo do płytki na całej powierzchni.

Tak wyglądają moje luty. Nie są idealne. Na usprawiedliwienie powiem, że pierwszy raz pracowałem z nową lutownicą ;-).

To moje urządzenie po zmontowaniu. Prezentuje się bardzo ładnie i jest niezwykle małe. Jestem z niego dumny!

Kolejna chwila prawdy - czy zadziała?!

Moduł przekaźnika podłączyłem do Arduino wg schematu z kolejnej strony. Szybko napisałem program, który włącza i wyłącza przekaźnik co sekunda, żeby sprawdzić czy wszystko działa.
Pełna satysfakcja - przekaźnik przyjemnie pstryka, a LED mruga.

Teraz w nagrodę można zjeść te legendarne cukierki, które przychodzą w paczkach z Nettigo.

Moduł przekaźnika i Arduino

Podłączenie jest bardzo proste.

• Wyprowadzenie Vcc podłączyłem do POWER 5V w Arduino
• Wyprowadzenie GND podłączyłem do GND w Arduino
• Wejście IN podłączyłem do pinu cyfrowego 2 w Arduino

Z drugiej strony podłączam przekaźnik jak włącznik w jeden z przewodów zasilających urządzenie.

Programowanie jest jeszcze łatwiejsze.

void setup()
{
  pinMode(2, OUTPUT);
}

void loop()
{
  digitalWrite(2, HIGH);
  delay(10000);
  digitalWrite(2, LOW);
  delay(10000);
}

Program włącza i wyłącza przekaźnik co 10 sekund.
Funkcja pinMode(2, OUTPUT); ustawia pin 2, do którego podłączyłem przekaźnik jako wyjście.

Funkcja digitalWrite(2, HIGH); ustawia pin 2 w stan wysoki - przekaźnik zostaje włączony i będzie przewodził prąd.

Funkcja digitalWrite(2, LOW); ustawia pin 2 w stan niski - przekaźnik zostaje wyłączony i nie przewodzi prądu.

Podłączenie większej ilości przekaźników też nie stanowi problemu.

Piny zasilania Vcc i GND podłączasz do tych samych pinów co poprzedni moduł. Natomiast pin sterujący IN podłączasz do kolejnego wolnego pinu cyfrowego. W moim przypadku podłączyłem moduły do pinów 2 i 3.

void setup()
{
  // Ustawianie pinow przekaznika na wyjscie
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);

  // Ustawienie szybkosci portu szeregowego
  Serial.begin(9600);
}

void loop()
{
  // Sprawdzanie czy cos odebralem
  if (Serial.available())
  {
    // odbieranie numeru pinu i stanu
    int pin = Serial.parseInt();
    int mode = Serial.parseInt();

    // sprawdzaie czy numery sa prawidlowe
    if (pin > 3 || pin < 2 || mode > 1 || mode < 0)
    {
      Serial.println(F("ERROR"));
      return;
    }

    // ustawiaie pinow
    digitalWrite(pin, mode);
    Serial.println("OK");
  }
}

Drugi program przykładowy pozwala sterować dwoma przekaźnikami wysyłając im komendy z komputera przez Monitor Portu Szeregowego.

Gdy wpiszesz do monitora

2 1

To włączy się urządzenie podłączone do do przekaźnika na pinie 2.

Gdy wpiszesz do monitora

2 0

To wyłączysz to urządzenie.

To samo możesz robić z przekaźnikiem ma pinie 3.

Teraz możesz tworzyć urządzenia sterowane przez Arduino. Możesz sterować je radiowo przez moduły radiowe, albo XBee. Możesz sterować przez sieć za pomocą Ethernet Shielda. Możesz też zrobić wyłącznik zmierzchowy z fotorezystorem. Wszystko zależy od twojej wyobraźni.

• Arduino UNO w sklepie Nettigo

Moduł przekaźnika i Raspberry Pi

Podłączenie tu również jest bardzo proste. Wszystko podłączamy do złącza GPIO Raspberry.

• Sygnał Vcc przekaźnika podłączyłem do wyjścia 5V Rasbperry
• Sygnał GND podłączyłem do pinu GND w Raspberry
• Sygnał IN przekaźnika podłączyłem do wybranego piu GPIO. W moim przypadku jest to sygnał GPIO 18.

W Raspberry PI mamy możliwość programowania w wielu językach. Każdy, kto zetknął się z programowaniem, będzie mógł wybrać coś dla siebie.

Pierwszy przykład zademonstruje w domyślnym języku programowania maliny - Pythonie.

    import RPi.GPIO as GPIO
    import time

    GPIO.setmode(GPIO.BCM)

    GPIO.setup(18, GPIO.OUT)

    while True:
        GPIO.output(18, GPIO.HIGH)
        time.sleep(10)
        GPIO.output(18, GPIO.LOW)
        time.sleep(10)

Program włącza i wyłącza urządzenie podłączone do przekaźnika co 10 sekund. Moduł przekaźnika jest podłączony do pinu GPIO 18.

Na początku programu jest tradycyjne importowanie bibliotek używanych w skrypcie. Do sterowania pinami użyłem biblioteki RPi, która jest domyślnie zainstalowana w dystrybucji Raspbian.

Funkcja GPIO.setup(18, GPIO.OUT) ustawia pin GPIO 18 jako wyjście.

Funkcja GPIO.output(18, GPIO.HIGH) ustawia pin GPIO 18 w stan wysoki, co powoduje włączenie przekaźnika i włączenie urządzenia podłączonego do niego.

Funkcja GPIO.output(18, GPIO.LOW) ustawia pin GPIO 18 w stan niski. To powoduje wyłączenie przekaźnika i zarazem urządzenia do niego podłączonego.

Python to język bogaty w przeróżne biblioteki. Jeśli go znasz, możesz bez trudu rozwinąć ten program o sterowanie przekaźnikami przez sieć za pomocą modułu socket. Możesz stworzyć stronę internetową, którą będziesz mógł sterować urządzeniami za pomocą modułów Flask lub frameworka Django. Co tylko wymyślisz.

Większość entuzjastów Linuksa i administratorów lubuje się bardziej w komendach terminala Bash. Dla nich też znalazło się rozwiązanie do sterowania przekaźnikiem.

    echo "18" > /sys/class/gpio/export
    echo "out" > /sys/class/gpio/gpio18/direction

Te 2 polecenia ustawiają pin GPIO 18 jako wyjście.

    echo "1" > /sys/class/gpio/gpio18/value

To polecenie ustawia wyjście GPIO 18 w stan wysoki, załączając przekaźnik.

    echo "0" > /sys/class/gpio/gpio18/value

To polecenie ustawia pin GPIO 18 w stan niski, wyłączając przekaźnik i urządzenie do niego podłączone.

Podłączenie większej ilości przekaźników tak jak w przypadku Arduino nie jest problemem.

Wyprowadzenia Vcc i GND w obydwu przekaźnikach podłączyłem do tych samych pinów 5V i GND w Raspberry. Wyprowadzenia IN każdego z modułów trzeba podłączyć do innego wybranego pinu GPIO. W moim przypadku pierwszy przekaźnik podłączyłem do pinu GPIO 18, a drugi do pinu GPIO 23 w Malinie. Kolejne podłączasz do kolejnych.

Programowanie 2 przekaźników jest równie proste z tym, że Najpierw ustawiasz ich kolejne piny GPIO jako wyjścia, a potem sterujesz nimi, osobnymi poleceniami dla każdego pinu.

Przy podłączaniu większej ilości przekaźników trzeba mieć na uwadze to, że każdy z nich pobiera 53 mA prądu. Prąd dostępny w pinie 5V to prąd zasilacza Raspberry odjęć prąd, który pobiera Malina (500 mA model B i 300 mA model A).

Więcej o programowaniu pinów we wszystkich językach dostępnych na Raspberry Pi możesz się dowiedzieć z artykułu: RPi Low-level peripherals

Niedawno opisywałem też projekt Jasper, który umożliwia sterowanie Raspberry głosem. Tam też możesz dodać plugin do sterowania głosem urządzeń przez moduł przekaźnika.

• Raspberry Pi w sklepie Nettigo

Moduł przekaźnika i Arduino Yun

Arduino YUN to płytka oparta na standardzie Arduino UNO. Zatem cały schemat połączeń przekaźnika jest identyczny z tym zaprezentowanym w rozdziale 3.

• Moduł przekaźnika i Arduino

Arduino YUN to więcej niż zwykłe Arduino, dlatego postanowiłem poświecić mu jeden z dni z przekaźnikiem.

YUN, oprócz standardowego kontrolera AVR, ma w sobie dodatkowy komputer z Linuksem na bazie procesora MIPS. Komputer ten może łączyć się z internetem poprzez port Wi-Fi lub złącze Ethernet. Za pośrednictwem specjalnych bibliotek, mały kontroler Arduino łączy się z Linuksem i odbiera różne dane.

Najpopularniejszym sposobem odbierania danych jest protokół REST. Chodzi w nim o to, że komunikujesz się z Arduino za pomocą adresów WWW, a on odsyła informacje do przeglądarki.

Służy do tego biblioteka YunServer i YunClient. Elementy tej biblioteki czytają fragment linku wysłanego do Arduino i wysyłają to co ma się pojawić w przeglądarce.

Wykorzystując te biblioteki napisałem program, który steruje przekaźnikami podłączonymi do YUN do pinów cyfrowych 2, 3, za pośrednictwem linków.

#include <YunServer.h>
#include <YunClient.h>

YunServer server;

// Piny do których podłaczone są przekaźniki 2 i 3
byte relayPins[] = {2, 3};

void setup()
{
  server.listenOnLocalhost();
  server.begin();

  // Ustawianie pinów przekaźników jako wyjście
  for (byte i=0; i<sizeof(relayPins); i++)
  {
    pinMode(relayPins[i], OUTPUT);
  }
}

void loop()
{
  YunClient client = server.accept();
  if (client)
  {
    // Jeśli ktoś wywołał adres to włącza funkcje obsługi przekażnika
    relayHandle(client);

    client.stop();
  }

  delay(50);
}

void relayHandle(YunClient client)
{
  // Odczytywaie numeru przekanika
  byte index = client.parseInt();
  byte mode;

  // Reakcja na błędny numer przekaźnika
  if (index == 0 || index >= (sizeof(relayPins)))
  {
    client.println(F("Error!"));
  }

  // Sprawdzanie czy chcesz odczytać stan czy zapisać
  if (client.read() == '/')
  {
    // Zapis stanu
    byte mode = client.parseInt();
    digitalWrite(relayPins[index-1], mode);
  }

  else
  {
    // Odczyt stanu
    mode = digitalRead(relayPins[index-1]);
  }

  // Wyłanie wyników pracy przekaźników
  client.print(F("Relay: "));
  client.print(index);
  if (mode == 0)
  {
    client.println(F(" Off"));
  }

  else
  {
    client.println(F(" On"));
  }
}

Program działa tak, że wpisując do przeglądarki:

http://myArduinoYun.local/arduino/1/1

Zostanie włączony pierwszy przekaźnik podłączony do pinu 2. W przeglądarce pojawi się napis:

Relay: 1 On

Wpisując:

http://myArduinoYun.local/arduino/1/0

Ten przekaźnik zostanie wyłączony, a w przeglądarce pojawi się napis:

Relay: 1 Off

Zapewne już zauważyłeś, że pierwsza cyfra adresu odpowiada za numer przekaźnika, a druga za jego stan - 0 wyłączony, 1 włączony.

Idąc za ciosem, gdy wpiszesz:

http://myArduinoYun.local/arduino/2/1

włączysz drugi przekanik, podłączony do pinu 3.

W programie jest zmienna globalna

// Piny do których podłaczone są przekaźniki 2 i 3
byte relayPins[] = {2, 3};

do której nawiasów klamrowych {} możesz dopisać numery kolejnych pinów do których są podłączone przekaźniki, rozdzielając je przecinkiem.

Program działa dość prosto. W funkcji loop, sprawdzane jest czy program odebrał link. Jeśli tak to obiekt client jest czymś podobnym do obiektu Serial. To co się z niego odbiera to tekst adresu, który odebrało Arduino (cały napis znajdujący się za http://myArduinoYun.local/arduino/). U nas odbieramy {numer}/{numer}.

To co się wysyła do obiektu client, zostanie odebrane przez przeglądarkę i wyświetlone przez nią. Wysyłać można standardowo np. poprzez client.println("Napis");.

Metoda client.stop(); kończy połączenie z przeglądarką.

W programie jest jeszcze jedna opcja. Wpisując adres:

http://myArduinoYun.local/arduino/1

Otrzymasz tylko informację czy przekaźnik nr 1 jest włączony czy nie.

Dzięki Arduino Yun i modułowi przekaźnika Nettigo możesz sterować urządzeniami za pomocą przeglądarki WWW. Tradycyjnie używając linków na stronie, albo wykorzystując Ajax w JavaScript.

• Arduino Yun w sklepie Nettigo
• Przekaźnik Nettigo Relay w sklepie Nettigo