Archiwa tagu: starter-kit

DS18B20 – cyfrowy termometr z Arduino

Od dłuższego już czasu, w naszym produkcie Starter Kit dla Arduino UNO R3 sprzedawany jest cyfrowy czujnik temperatury DS18B20. Opis jak z niego korzystać znajduje się na Akademii Nettigo – będzie to docelowe miejsce gdzie gromadzić będziemy opisy produktów z naszego sklepu. Zapraszamy do czytania i korzystania z opisu DS18B20 używanego z Arduino.

 

Diody LED czyli jak migać i świecić

Większość z nas ma za sobą podstawowe przykłady jak podłączanie diód LED. Zajmijmy się czymś ciekawszym jak linijka led czy biegnące światełko. Do tego potrzebne nam będzie 8 diod LED o dowolnym kolorze (my wykorzystaliśmy czerwone), zestaw rezystorów 200Ω ograniczających prąd i trochę kabelków.

Diody LED_pasek

Schemat montażowy układu na płytce stykowej

Czytaj dalej

Co to jest PWM?

Wstęp

Wielu użytkowników Arduino zapewne zauważyło, że wśród pinów z grupy DIGITAL jest kilka oznaczonych jako “PWM” lub “~”. W tym artykule postaram się wyjaśnić co to znaczy i jak dokładnie działa. Napiszę też jak można to praktycznie wykorzystać.

PWM w teorii

PWM to skrót od angielskich słów “Pulse Width Modulation”, co oznacza po polsku “Modulacja Szerokości Impulsu”.

W życiu codziennym posługujesz się przełącznikami. One powodują, że włączasz jakieś urządzenie lub wyłączasz. Włączenie oznacza dostarczenie do urządzenia 100% energii elektrycznej, a wyłączenie zmniejsza tą ilość do 0%.

Jeśli masz w domu jakieś urządzenie z silnikiem to możesz zauważyć, że włączając i wyłączając je wiele razy w ciągu sekundy silnik nie zdąży się rozpędzić do maksymalnych obrotów. Wynika to z tego, że wolno się rozpędza. Zatem jeśli odetniesz mu prąd zanim osiągnie maksymalne obroty to będzie kręcił się wolniej i zwalniał do czasu, aż znowu go włączysz. W ten sposób można regulować jego prędkość.

Działanie PWM polega właśnie na tym, że im dłużej silnik jest włączony w ciągu sekundy, tym szybciej się kręci. A jeśli dłużej trwa czas wyłączenia tym wolniej. Czas włączenia to właśnie ten “Impuls” (“Pulse”) w nazwie, którego “Szerokość” (“Width”) regulujesz.

Fizycznie rzecz ujmując działanie PWM polega na dostarczeniu mniejszej ilości energii elektrycznej do urządzenia w przeciągu jakiegoś czasu. Czego skutkiem ubocznym są takie właśnie miłe efekty jak regulacja szybkości lub jasności.

Czytaj dalej

PCF8574 czyli jak łatwo zwiększyć liczbę pinów w Arduino

Wstęp

Arduino z rodziny UNO posiada 14 pinów cyfrowych. Jest to wystarczająca ilość do większości prostych zastosowań z dziedziny automatyki. Zdarzają się jednak sytuacje, jak np. podłączenie wyświetlacza, które drastycznie tą liczbę mogą zmniejszyć.

Co wtedy robić? Można przesiąść się na 2 razy droższe Arduino MEGA i mieć ponad 50 dodatkowych pinów. Można też użyć rejestru przesuwnego 74HC595, który da dodatkowe 8 wyjść cyfrowych za cenę 2 zł i użycia 3 pinów cyfrowych. Można też użyć układu PCF8574 i mieć dodatkowe 8 pinów (lub nawet 128 łącząc więcej układów) wejścia/wyjścia o możliwościach przekraczających te w Arduino za cenę użycia 2 pinów analogowych.

Układ scalony PCF8574

  • Vcc – Pin zasilania, podłączany w Arduino do pinu 5V.

  • GND – Pin masy zasilania podłączany w Arduino do GND.

  • P0..P7 – Cyfrowe piny do własnego wykorzystania.

  • SDA – Sygnał danych magistrali I2C podłączany w Arduino do Analog In 4.

  • SCL – Sygnał zegara magistrali I2C podłączany w Arduino do Analog In 5.

  • A0, A1, A2 – Wybór adresu układu, jeśli używasz jednego układu, wszystkie można podłączyć do GND.

  • /INT – Zanegowany sygnał przerwania. Można go używać do wykrywania zmiany stanu na jednym z cyfrowych wejść.

Magistrala I2C

Układ PCF8574 komunikuje się z Arduino za pomocą magistrali I2C. Jest to synchroniczna magistrala szeregowa wykorzystywana powszechnie w sprzęcie RTV. Szeregowa oznacza, że bity są przesyłane jednym pinem po kolei – pinem SDA. Synchroniczna oznacza, że każdy wysłany bit jest zatwierdzany sygnałem na drugim pinie – SCL. Synchroniczność przyczynia się do zwiększenia prędkości komunikacji i eliminuje błędy transmisji.

Magistrala I2C ma też własny protokół komunikacji, dzięki któremu do jej sygnałów SDA/SCL można podłączyć więcej niż jeden układ scalony. Każdy układ w magistrali ma swój adres. Adres jest to liczba, która identyfikuje układ, wybierając tą liczbę masz pewność, że dane które wysyłasz trafią do właściwego układu. Układ PCF8574 ma dodatkowo piny A0, A1, A2 za pomocą których możesz konfigurować część adresu. Pozwala to na podłączenie do magistrali więcej takich samych układów scalonych, dzięki modyfikacji stanów logicznych na tych pinach. Trzy piny adresu oznaczają, że możesz podłączyć do magistrali 8 takich układów scalonych, co da 64 dodatkowe piny cyfrowe. Jeśli i to jest za mało to istnieje też wersja układu PCF8574A, która ma zmieniony adres, co sprawia, że oprócz tamtych 8 można podłączyć jeszcze 8 układów i mieć w sumie 128 pinów.

W Arduino magistrala I2C ze względu na problemy licencyjne nazywa się TWI (TwoWires [dwa przewody] – od liczby przewodów używanych przez nią). Mikrokontroler AVR zawarty na płytce zawiera sprzętową obsługę tej magistrali. Jej wyprowadzenia znajdują się na dwóch ostatnich pinach grupy “ANALOG IN”. Sygnał danych SDA znajduje się na pinie 4, a sygnał zegarowy SCL na pinie 5.

Adres układu PCF8574

Układy z rodziny PCF8574 mają 7 bitowy adres. Pierwsze 3 bity adresu nadaje mu użytkownik, przez ustawienie pinów A0, A1, A2. Kolejne 4 są nadane fabrycznie na stałe. Układ PCF8574 ma je ustawione na 0100, a układ PCF8574A ustawione na 0111.

Binarny adres układu PCF8574

0

1

0

0

A2

A1

A0

Co oznacza, że minimalny adres (dla wszystkich A = LOW) to dziesiętnie 32, szesnastkowo 0x20. Maksymalny adres (dla wszystkich A = HIGH) to dziesiętnie 39, a szesnastkowo 0x27.

Binarny adres układu PCF8574A

0

1

1

1

A2

A1

A0

Co oznacza, że minimalny adres (dla wszystkich A = LOW) to dziesiętnie 56, szesnastkowo 0x38. Maksymalny adres (dla wszystkich A = HIGH) to dziesiętnie 63, a szesnastkowo 0x3F.

Podłączenie do Arduino

Podłączenie nie sprawia trudności i wykorzystuje tylko 4 przewody. Vcc układu łącze z pinem 5V Arduino, GND układu łącze z pinem GND Arduino w sekcji zasilania. Sygnały SDA łącze z pinem 4, a SCL z pinem 5 sekcji “ANALOG IN” Arduino.

Ponieważ używam w tej konfiguracji tylko jednego układu, podłączyłem wszystkie linie adresowe w stan niski (LOW) łącząc je z GND. Jeśli w twojej konfiguracji jest więcej takich samych układów, powinieneś do linii adresowych stosować różne kombinacje stanów (LOW – GND, HIGH – 5V) innych dla każdego układu. Pozostałe piny P0 do P7 możesz wykorzystywać dowolnie jako piny cyfrowe (DIGITAL), jak to robisz w Arduino.

Programowanie układu PCF8574

Przygotowanie

#include <PCF8574.h>
#include <Wire.h>

PCF8574 expander;

void setup()
{
  expander.begin(0x20);
}

void loop()
{
}

Jak zawsze społeczność Arduino nie zawiodła i jeden z miłośników platformy przygotował odpowiednią bibliotekę. Aby rozpocząć komunikacje z układem PCF8574 musisz najpierw podłączyć 2 biblioteki – PCF8574.h (dostarczającą funkcje obsługi układu) i Wire.h (do obsługi magistrali TWI).

Następnie trzeba zadeklarować obiekt klasy “PCF8574”, który nazwałem “expander”. Deklaruje się to jak inne zmienne czyli “PCF8574 expander;”.

Potem w funkcji “setup” należy za pomocą metody “expander.begin” ustawić adres układu, który ma reprezentować zadeklarowany obiekt. W tym przypadku ustawiłem wartość szesnastkową 0x20 odpowiadającą układowi z liniami adresowymi w stanie “LOW” – jak na schemacie.

Czytaj dalej

Sygnalizator revisited czyli przyciski i debouncing

Dawno temu pisałem o tym jak można korzystać z przycisków (tactile switch, pushbutton) na przykładzie kartonowego sygnalizatora. Wróćmy do tematu, tym razem na poważniej zajmując się przyciskami.

Jeśli spojrzycie na kod tamtego sygnalizatora, możecie dostrzec następującą pętlę loop:

void loop()
{
  val = digitalRead(buttonPin);
  if (val == HIGH && prev == LOW) {
    next_status();
  }
  prev = val;
  display_status();
  delay(50);

}

Wykrywanie naciśnięcia odbywa się przez porównanie bieżącej wartości wejścia cyfrowego z poprzednią. Jeżeli aktualna wartość to HIGH a poprzednia to LOW, to wykonujemy akcję next_status(), która zmienia stan sygnalizatora. I wszystko działa. Ale nie ma problemów, tylko dzięki ostatniej linii kodu w loop: delay(50);.

Przycisk jest urządzeniem mechanicznym i włączenie lub wyłączenie nie jest jednoznaczne, jeżeli będziemy stan przycisku badać dostatecznie często. W momencie dociskania/zwalniania przycisku jest taki moment, w którym styk już łapie/puszcza przez co włączenie wyłączenie nie jest czystym przełączeniem między LOW a HIGH tylko migotaniem. Angielska Wikipedia przy haśle contact bounce (bo tak się zjawisko to nazywa) ma ten piękny obrazek ilustrujący ten problem:

Ilustracja migotania przełącznika (CC Wikipedia)

Ilustracja migotania przełącznika (CC Wikipedia)

Opóźnienie w loop załatwia nam ten problem, bowiem jeżeli zauważymy zmianę stanu klawisza odczekanie 50 ms przed następnym odczytem zapewnia margines wykluczający błędny odczyt. Gdyby nie ono, wówczas w następnym przebiegach moglibyśmy odczytać migotanie jako kolejne przyciśnięcia. Rezultat? Z punktu widzenia użytkownika – on nacisnął przycisk jeden raz, a sygnalizator przeskoczył o 1 lub więcej stanów za jednym razem.

Rozwiązanie z użyciem delay nie zawsze jest dopuszczalne, bo może nasze Arduino musi robić coś więcej niż tylko czekać na naciśnięcie klawisza.

Jak się zabezpieczyć przed złymi odczytami?

Czytaj dalej

Rezystor – co o nim trzeba wiedzieć

Rezystory to jeden z podstawowych elementów wszystkich układów elektronicznych. Jako, że jest to element naprawdę podstawowy i powszechny, spróbujemy się o nim dowiedzieć kilku rzeczy.

Teoria związana z przepływem prądów w układach RLC (R – rezystory, L – cewki, C – kondensatory) jest cała najeżona wzorami, których nie chcecie widzieć :) (a jeżeli ktoś musi się przekonać to np zobaczcie to i wrócicie zaraz tutaj :) ).

Teraz podam kilka uproszczeń, które wystarczą do zmierzenia się z użyciem rezystorów w kontekście Arduino.

Ważną cechą układów elektronicznych jest to, że jeżeli mamy jakieś napięcie w układzie (coś je wytwarza), to jeżeli obwód jest zamknięty (nie ma żadnej przerwy), napięcie to się odłoży na wszystkich elementach w taki sposób, że sumując napięcia na każdym elemencie z osobna otrzymamy napięcie z naszego źródła. Jest to zgodne z intuicyjnym rozumieniem – napięcie nie bierze się znikąd i nie może nigdzie znikać.

Czytaj dalej

Gra w zapamiętywanie kolorów

Niniejszy artykuł został napisany w oparciu o ten tekst zamieszczony na blogu Newtona. Wszystkie ilustracje, filmik oraz kod programu pochodzą właśnie stamtąd.

Celem projektu było wykorzystanie jak największej ilości elementów zawartych w Starter Kicie. A czym ów projekt jest? Jak sam tytuł wskazuje, to gra polegająca na zapamiętaniu sekwencji kolorów wyświetlanych za pomocą diody LED RGB, a następnie odtworzeniu jej. Na początku sekwencja składa się z 3 kolorów, potem stopień trudności wzrasta – za każdym razem jest dodawany kolejny kolor do zapamiętania. Pewnym ułatwieniem jest fakt, że do każdego koloru jest przypisany dźwięk o innym tonie – podczas wyświetlania danego koloru odpowiadający mu dźwięk jest emitowany z dołączonego głośniczka, tak więc gra angażuje dwa zmysły: wzrok i słuch. Interfejs użytkownika stanowi wspomniana już dioda RGB, linijka diod LED informująca, który z kolei kolor ustawiamy oraz dwa przyciski typu microswitch. Wciskając oba naraz uruchamiamy grę, lewym wybieramy kolor, a prawym zatwierdzamy. Są jeszcze dwie diody LED informujące, czy udało nam się poprawnie odtworzyć sekwencję. Jeśli zaświeci się lewa – znaczy, że tak, w przeciwnym wypadku zaświeci się prawa dioda.

Zmontowany na płytce stykowej układ prezentuje się tak:

Zmontowany układ

Zmontowany układ

A jak działa, można zobaczyć (i usłyszeć) na tym filmiku. Poniżej natomiast jest schemat tego układu wykonany we Fritzingu:

Schemat układu

Schemat układu

W tym miejscu kilka słów komentarza – przy rysowaniu takiego schematu warto uruchomić program Fritzing podając w linii komend (bądź we właściwościach skrótu) parametr -graphicssystem raster – będzie działał szybciej. Kolejna rzecz, którą warto wiedzieć – jeśli podczas rysowania połączeń między elementami przytrzymamy klawisz Shift, uzyskamy ładne, prostokątne linie. Jak widać, autor powyższego obrazka nie wiedział o tym ;)
Co do kwestii technicznych, wszystkie rezystory umieszczone na płytce mają wartość 220Ω, zaś układ scalony w centralnej części płytki to rejestr przesuwający 74HC595, dzięki któremu możemy sterować ośmioma diodami, zużywając na to jedynie trzy cyfrowe wyprowadzenia Arduino. Dokładniej zostało to opisane w artykule „Przesuwane diody”.

Jeśli już mamy wszystko podłączone, teraz należałoby to jakoś oprogramować. Na początku trzeba zadeklarować, co gdzie podłączamy (do których wejść/wyjść). Odpowiada za to ten fragment kodu:

int latchPin = 8, clockPin = 12, dataPin = 3; //rejestr przesuwający
byte data = 0; //dane do wysłania na rejestr

int led8 = 7, led9 = 6; //dodatkowe LEDy
int ledR = 11, ledG = 10, ledB = 9; //LED RGB
int buttonLeft = 5, buttonRight = 4; //przyciski
int speakerPin = 13; //głośniczek

Teraz następuje inicjalizacja – ustawienie funkcji wyprowadzeń, włączenie rezystorów podciągających, itd.:

void setup()
{
  Serial.begin(57600);
  for(int i=3;i<=13;i++) // ustawienie wszystkich pinów
    pinMode(i, OUTPUT); // od 3 do 13 jako wyjścia
  pinMode(buttonLeft, INPUT); // ustawienie pinów przycisków
  pinMode(buttonRight, INPUT); // jako wejścia

  digitalWrite(buttonLeft, HIGH); // włączenie wewnętrznych
  digitalWrite(buttonRight, HIGH); // rezystorów podciągających
  randomSeed(analogRead(0)); // zainicjalizowanie generatora liczb pseudolosowych
  // wartością odczytaną z niepodłączonego analogowego pinu 0 - przy każdym 
  // uruchomieniu będzie ona inna
  clearLeds();
}

W tym miejscu chciałbym wtrącić pewne wyjaśnienie, otóż w paru miejscach w kodzie programu pojawia się taki dziwny zapis:

 a ? b : c

a jeśli ktoś na co dzień nie programuje w języku C, może być tym nieco zdezorientowany, tym bardziej, że w „Language Reference” na oficjalnej stronie Arduino nie wyjaśniono tego. Jest to tak zwany operator wyrażenia warunkowego. Jeśli warunek podstawiony w miejscu „a” jest spełniony (lub zmienna w miejscu „a” ma wartość TRUE), zostanie zwrócona liczba „b”. W przeciwnym wypadku – „c”. Ot i cała filozofia.

Wróćmy do właściwego programu. Główna pętla wygląda następująco:

void loop()
{
  effect();
  clearLeds();
  if(waitForButton() == 3)
    return;

  for(int j=3;j<=8;j++)
    if(!playLevel(7, j))
      return;
}

Kolejno: na początku, funkcją effect() uruchamiane są dźwiękowe i świetlne „fajerwerki”, a funkcja clearLeds gasi wszystkie diody. Następnie, o ile użytkownik nie wciśnie dwóch przycisków naraz, co spowoduje reset, funkcja playLevel rozpoczyna kolejne poziomy gry, za każdym obiegiem pętli for z drugim parametrem (ilość świateł do zapamiętania) zwiększonym o 1. Pierwszy parametr natomiast jest na sztywno ustawiony jako 7, czyli kolory do zapamiętania losowane są spośród ośmiu (od 0 do 7). Można oczywiście zmniejszyć tę ilość, ale wtedy gra stanie się zbyt prosta. Zdecydowanie lepiej pomanipulować funkcją setColor, dodając kolejne kolory (wystarczy zmienić parametry w setRGB). Mając kilka dodanych kolorów, możemy ich liczbę (mniejszą o 1, bo numeracja jest od 0!) wpisać jako pierwszy parametr funkcji playLevel. Wtedy rozgrywka stanie się trudniejsza, czyli ciekawsza ;).

Pełny kod programu opatrzony komentarzami można pobrać tutaj. Myślę, że jest on na tyle jasny, że nie ma potrzeby go szczegółowo wyjaśniać.

Przesuwane diody

Ostatnim z elementów Arduino Starter Kitu, który jeszcze nie doczekał się opisu na tym blogu jest niepozorny układ scalony – rejestr przesuwny. Jest układ 74HC595, rejestr przesuwny typu SIPO (Serial-In, Parallel-Out) o 8 wyjściach równoległych.

Rejestr przesuwny (ang. shift register) jest układem posiadającym wejście szeregowe i kilka (zazwyczaj 8) wyjść równoległych. Co to znaczy? Z każdą zmianą zegara na wejściu, stany wyjść są przesuwane o jeden. Czyli stan wyjścia 1 jest przepisywany do wyjścia 2, 2 do 3, itd. Stan wejścia 1 jest ustalany na podstawie stanu wejścia szeregowego.

Do czego można to zastosować w praktyce?

Każde miejsce które potrzebuje wielu wyjść cyfrowych, może być miejscem w którym można rozważyć zastosowanie rejestru przesuwnego. Można powiedzieć, że trzy piny mogą sterować znacznie większa ilością wyjść. Zobaczmy to na najprostszym przykładzie – diody LED.

Dzisiejszy artykuł jest oparty na przewodniku opublikowanym na stronach Arduino.cc, stanowi on źródło ilustracji i tekstu. Ilustracje wykorzystują więcej niż jedną płytkę stykową, ale zdecydowałem się je wykorzystać, aby przyspieszyć powstawanie tego wpisu – zrobienie dobrej ilustracji do tego wpisu we Fritzingu chyba nie jest możliwe (hint – czytelnej ilustracji :) )

Zacznijmy od podłączenia:

Schemat układu z rejestrem przesuwnym - zamontowany na płytce stykowej

Schemat układu z rejestrem przesuwnym – zamontowany na płytce stykowej

Zasilanie jest rozprowadzone przez szyny na płytce stykowej. Na lewej płytce są podłączone diody LED wraz rezystorami. Na prawej jest podłączony sam układ scalony 74HC595. Jego wyprowadzenia:

Wyprowadzenia pinów 74HC595

Wyprowadzenia pinów 74HC595

Na powyższym diagramie przedstawione są wyprowadzenia pinów opisane zgodnie z danymi producenta (ST Microelectronics), którego to układy są w ofercie Nettigo i stanowią część Starter Kitu. Na stronie Arduino jest opis przystosowany dla układów z oznaczeniami zgodnymi z nomenklaturą Philipsa. Co to znaczy? Na szczęście w tym wypadku różnica polega tylko w nazwach sygnałów (np wyjścia w STM – QA do QH, w wersji Philipsa Q0-Q7), położenie i znaczenie pinów jest identyczne. W tym przewodniku będę używał nazewnictwa zgodnego z STM.

Najprostsze podłączenie rejestru przesuwnego do Arduino wygląda następująco:

  • Zasilanie +5V do pinu 16 rejestru
  • Masa do pinu 8 rejestru

Jeżeli nie przeszkadza nam to, że po włączeniu diody mogą się nam zapalić w losowym układzie a chcemy użyć mniej wyjść cyfrowych na Arduino podłączamy:

  • G – pin 13 na rejestrze do masy
  • SCLR – pin 10 na rejestrze do +5V

Minimalny zestaw podłączeń do sterowania rejestrem z Arduino przedstawia się następująco (wszystkie piny na Arduino to wejścia cyfrowe):

  • SI – pin 14 rejestru do pinu 11 na Arduino
  • SCK – pin 11 rejestru do pinu 12 na Arduino
  • RCK – pin 12 rejestru do pinu 8 na Arduino

Między pinem RCK a masą może być potrzebny mały kondensator (1 μF – nie jest częścią Starter Kitu). Z serii eksperymentów które przeprowadziłem wynika, że nie powinien być potrzebny :)

Oto schemat logiczny  całego połączenia:

Schemat logiczny układu

Schemat logiczny układu

Co nam pozostaje? Program:

//**************************************************************//
//  Name    : shiftOutCode, One By One                          //
//  Author  : Carlyn Maw, Tom Igoe                           //
//  Date    : 25 Oct, 2006                                      //
//  Version : 1.0                                               //
//  Notes   : Code for using a 74HC595 Shift Register           //
//          : to count from 0 to 255                            //
//****************************************************************

//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;

//holder for infromation you're going to pass to shifting function
byte data = 0; 

void setup() {
  //set pins to output because they are addressed in the main loop
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);

}

void loop() {

  //function that blinks all the LEDs
  //gets passed the number of blinks and the pause time
  blinkAll(1,500); 

 // light each pin one by one using a function A
  for (int j = 0; j < 8; j++) {
    lightShiftPinA(j);
    delay(1000);
  }

  blinkAll(2,500);  

 // light each pin one by one using a function A
  for (int j = 0; j < 8; j++) {
    lightShiftPinB(j);
    delay(1000);
  } 

}

//This function uses bitwise math to move the pins up
void lightShiftPinA(int p) {
  //defines a local variable
  int pin;

  //this is line uses a bitwise operator
  //shifting a bit left using << is the same
  //as multiplying the decimal number by two.
  pin = 1<< p;

  //ground latchPin and hold low for as long as you are transmitting
  digitalWrite(latchPin, LOW);
  //move 'em out
  shiftOut(dataPin, clockPin, MSBFIRST, pin);
  //return the latch pin high to signal chip that it
  //no longer needs to listen for information
  digitalWrite(latchPin, HIGH);

}

//This function uses that fact that each bit in a byte
//is 2 times greater than the one before it to
//shift the bits higher
void lightShiftPinB(int p) {
  //defines a local variable
  int pin;

  //start with the pin = 1 so that if 0 is passed to this
  //function pin 0 will light.
  pin = 1;

  for (int x = 0; x < p; x++) {
    pin = pin * 2;
  }

  //ground latchPin and hold low for as long as you are transmitting
  digitalWrite(latchPin, LOW);
  //move 'em out
  shiftOut(dataPin, clockPin, MSBFIRST, pin);
  //return the latch pin high to signal chip that it
  //no longer needs to listen for information
  digitalWrite(latchPin, HIGH);

}

//blinks the whole register based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll(int n, int d) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, 0);
  digitalWrite(latchPin, HIGH);
  delay(200);
  for (int x = 0; x < n; x++) {
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 255);
    digitalWrite(latchPin, HIGH);
    delay(d);
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 0);
    digitalWrite(latchPin, HIGH);
    delay(d);
  }
}

Kod mignie wszystkimi diodami, potem zapali każdą po kolei diodę, mignie dwa razy wszystkimi i jeszcze raz zapali, korzystając z innej metody.

Najważniejsze wiadomości:

  • shiftOut to funkcja biblioteki Arduino, wysyłająca szeregowo wybrany bajt na wybrane wyjścia
  • ustawiając RCK (na Arduino podłaczony do 8) w stan niski możemy wysyłać dane do rejestru

Gdy prądu brakuje

Prędzej czy później w eksperymentach z Arduino będziemy chcieli wysterować jakieś urządzenie, które do pracy potrzebuje więcej niż 40 mA, które może zapewnić cyfrowe wyjście z Arduino. Może to być przekaźnik, żaróweczka czy inne bardziej zachłanne urządzenie.

Co zrobić?

Pozostaje skorzystać z tranzystora jako elementu wzmacniającego. Techniki analogowe, to jest temat rzeka, na którym się na dodatek nie znam :) (każdy kto ze mną studiował wie co mam na myśli :) ), tutaj postaram się przekazać parę informacji, które mogą pozwolić na sterowanie urządzeniami o większym poborze prądu. Niniejszy przykład bazuje na materiałach wchodzących w skład Arduino Starter Kit dostępnego na Nettigo.pl.

Co musisz wiedzieć o tranzystorach.

Rodzaje – ze względu na ich budowę. Podstawowe dwie grupy to bipolarne i unipolarne. My teraz zajmiemy się bipolarnymi. Bipolarne mają dwie podgrupy – tranzystory NPN i PNP. Różnica jest w tym jak poukładany w środku jest materiał półprzewodnikowy, a na zewnątrz różnią się tym jak należy polaryzować poszczególne wyprowadzenie i jak płynie prąd.

Wydaje mi się, że prostszym do zastosowania w przypadku gdy chcemy wysterować z Arduino jest NPN i takim się teraz zajmiemy – bo tranzystor NPN sterujemy napięciem dodatnim a takie Arduino oferuje na swoim wyjściu cyfrowym.

Symbol tranzystora bipolarnego typu NPN

Symbol tranzystora bipolarnego typu NPN

Tranzystory bipolarne mogą pracować w różnych układach i każdy z nich może mieć różne zastosowanie. My potrzebujmy aby mały prąd z wyjścia cyfrowego Arduino włączał i wyłączał przepływ znacznie większego prądu przez tranzystor (gwoli ścisłości układ w jakim będziemy podłączać tranzystor nazywany jest kluczem tranzystorowym).

W tym układzie tranzystor jest przełączany między dwoma stanami: nasycenia i zatkania.

  • stan zatkania: napięcie UBE jest zbyt małe, aby złącze baza-emiter zaczęło przewodzić. W rezultacie żaden prąd nie płynie przez kolektor tranzystora.
  • stan nasycenia: do bazy wpływa tak duży prąd, że zależność IC=hFE*IB nie może być spełniona. Wtedy napięcie UCE spada niemal do zera.

W praktyce prąd kolektora w stanie nasycenia jest ograniczony jedynie obciążeniem, czyli tym, co podłączymy pomiędzy kolektor a zasilanie. Ograniczeniem jest też wydajność zasilacza, którego używamy. Należy również uważać, żeby nie przekroczyć maksymalnego dozwolonego prądu kolektora, który dla obecnie dodawanego do Starter Kitu tranzystora MPS2222A wynosi 600mA.

Jak to wygląda w praktyce?

Zanim zaczniemy szkicować układ – zasady polaryzacji tranzystora NPN tak aby pracował jako przełącznik będą spełnione gdy:

  • emiter podłączymy do masy
  • na bazę podamy napięcie dodatnie (przełącznik przewodzi) lub 0 (przełącznik jest rozwarty)
  • do kolektora podłączymy przez obciążenie zasilanie

Czyli:

Tranzystor NPN - idea wykorzystania

Tranzystor NPN - idea wykorzystania

Gdy zewrzemy przełącznik S1 (odpowiada to ustawieniu wyjścia cyfrowego Arduino w stanie wysokim), do bazy tranzystora zaczyna płynąć prąd. Musi on być na tyle duży, żeby tranzystor wszedł w stan nasycenia, czyli napięcie UCE spadło poniżej UCE(sat) (napięcie nasycenia kolektor-emiter). Według karty katalogowej, wartość UCE(sat) zależy od prądów IC oraz IB i można ją przyjąć mniej więcej jako 0.3V.

W skład Arduino Starter Kit nie wchodzi żaden element, który sam z siebie mógłby służyć jako odbiornik prądu większego niż 40 mA. Ale możemy połączyć równolegle kilka diód LED aby przekroczyć ten próg i zademonstrować całość zagadnienia w praktyce.

Przykład wykorzystania 4 diód do przekroczenia 40 mA obciążenia

Przykład wykorzystania 4 diód do przekroczenia 40 mA obciążenia

Oszacujmy prąd płynący przez jedną diodę – napięcie odkładające się między kolektorem a emiterem w stanie nasycenia to w przybliżeniu 0V. Na diodzie czerwonej odkłada się mniej więcej 1.8V czyli na rezystor zostaje 5-1.8 = 3.2. Przy rezystorach R2-R5 280 ohm prąd przez nie płynący powinien być 3.2/280 = 11.42 mA. Przy 4 diodach powinno to dać nam około 45 mA.

Zanim podłączymy tranzystor musimy wiedzieć która nóżka jest która:

MPS2222A - opis wyprowadzeń

MPS2222A - opis wyprowadzeń

  1. emiter
  2. baza
  3. kolektor

Fizyczne podłączenie elementów zilustrowane we Fritzingu (przyznam szczerze – tym razem nie da się tego łatwo rozczytać – zdjęcia będą chyba lepszą ilustracją):

Fizyczne podłączenie układu

Fizyczne podłączenie układu

I dwa zdjęcia (w lewej części płytki stykowej jest zmontowany inny układ, więc to co widać poniżej rzędu 25 na płytce nie ma żadnego związku z układem tutaj opisywanym):

Fizyczna realizacja - ujęcie pierwsze

Fizyczna realizacja - ujęcie pierwsze

Fizyczna realizacja - ujęcie drugie

Fizyczna realizacja - ujęcie drugie

Uwaga montażowa – obcięte nóżki rezystorów nadają się doskonale do robienia krótkich zworek na płytce stykowej – na zdjęciu widać je bardzo wyraźnie.

Dla kompletu – bill of materials wygenerowany z Fritzinga (wszystkie potrzebne elementy wchodzą w skład Arduino Starter Kit od Nettigo):

Fritzing Bill of Materials

Sketch: 	tranzistor.fz
Date: 	Mon Dec 14 10:30:33 2009

Arduino       Arduino Diecimila
Breadboard1   Generic Breadboard
LED1          Red LED - 5mm
LED2          Red LED - 5mm
LED3          Red LED - 5mm
LED4          Red LED - 5mm
Q1            NPN-Transistor
R1            220Ω Resistor
R2            220Ω Resistor
R3            220Ω Resistor
R4            220Ω Resistor
R5            220Ω Resistor

Shopping List

Quantity	Part

5		220Ω Resistor
1		Arduino Diecimila
1		Generic Bajillion Hole Breadboard
1		NPN-Transistor
4		Red LED

Oczywiście rezystory 220Ω to rezystory dodawane w Arduino Starter Kit do diód LED i mogą mieć inne wartości – z przedziału 200Ω do 280Ω. Niezależnie od wartości niniejszy układ będzie działał.

Szkic do Arduino to klasyczny przykład Blink:

/*
 * Blink
 *
 * The basic Arduino example.  Turns on an LED on for one second,
 * then off for one second, and so on...  We use pin 13 because,
 * depending on your Arduino board, it has either a built-in LED
 * or a built-in resistor so that you need only an LED.
 *
 * http://www.arduino.cc/en/Tutorial/Blink
 */

int ledPin = 02;                // LED connected to digital pin 13

void setup()                    // run once, when the sketch starts
{
  pinMode(ledPin, OUTPUT);      // sets the digital pin as output
}

void loop()                     // run over and over again
{
  digitalWrite(ledPin, HIGH);   // sets the LED on
  delay(4000);                  // waits for a second
  digitalWrite(ledPin, LOW);    // sets the LED off
  delay(2000);                  // waits for a second
}

Jeszcze na koniec jakie wartości zostały uzyskane w rzeczywistym układzie? Dla rezystorów 280Ω:

  • napięcie zasilania – 4.96V
  • napięcie na tranzystorze w stanie aktywnym UCE 0.03 V
  • napięcie na diodach LED podczas świecenia – od 1.86 do 1.93 V
  • prąd płynący przez diody (już nie mierząc rzeczywistej rezystancji R2-R5, bo każdy z nich może mieć rozrzut +-5%) – od 10.7 mA do 10.9 mA

Jako ćwiczenie domowe – można zmienić pin użyty do sterowania tranzystorem na któryś obsługujący PWM i zamiast używać digitalWrite użyć pętli z analogWrite i sterować jasnością świecenie diód. Film ilustrujący działanie takiego podłączenia:

Driving over 40mA of current – PWM version from Starter Kit on Vimeo.

Dziś przydługawy wpis, ale musiałem zmieścić tutaj trochę teorii. Bardzo się starałem, aby nie wprowadzić tutaj nieścisłości, ale przyznaje się, że technika analogowa nie jest moją mocną stroną :)) Jeżeli widzisz w tym tekście jakieś niedokładności – proszę daj mi znać, postaram się uściślić.

Zagrajmy tato, czyli familiada

Zostałem zainspirowany prostą grą typu DIY zobaczoną w sieci (nie mogę teraz znaleźć linku) i choć oryginał był na znacznie prostszym PICu, to uznałem że Arduino Starter Kit jest doskonałym zestawem do zbudowania takiej gry.

Zasada jest prosta – kto pierwszy naciśnie swój przycisk po zapaleniu diody ten dostaje punkt. Jeżeli jednak naciśnie zanim dioda się zapali – punkt dla przeciwnika. Gramy aż ktoś zdobędzie 5 punktów. Zobaczmy to w akcji:

Simple game with Arduino from Starter Kit on Vimeo.

Oprócz diody, która trzeba obserwować potrzebujemy 2 diody pokazujące kto dostał punkt oraz wygrał cały pojedynek, buzzer żeby zagrać prostą melodyjkę dla zwycięzcy i dwa przyciski.

Czytaj dalej