Nowy numer telefonu

Od kilku dni funkcjonuje nowy numer telefonu w naszej firmie. Jest to komórka, która leży na stole do pakowania zamówień. Jeżeli macie pytanie o status zamówienia, czy na pewno coś jest na stanie (mimo tego, że przykładamy się do rzetelnych stanów magazynowych, rozumiemy, że chcecie sie dopytać czy na pewno coś jest dostępne) to jest to jak najbardziej właściwy numer telefonu.

Dzwonicie pod 514 020 024, zawsze w godzinach 10-13 jest ktoś pod nim dostępny.

Dotychczasowy numer 508 148 231 jest nadal aktualny.

Warsztaty z Arduino – wiadomość zła i dobra

Teraz już możemy podać szczegóły. Warsztaty dla początkujących odbędą się 6 XI na SWPS (ul. Chodakowska) w Warszawie. Zła wiadomość jest taka, że wszystkie miejsca już są zarezerwowane przez osoby, które wstępnie się zgłosiły przy okazji ankiety przeprowadzanej niedawno. Jeżeli chcesz mimo to dowiedzieć się szczegółów, możesz odwiedzić stronę warsztatów na Evenea. Ta edycja (na sali z komputerami) prawdopodobnie będzie powtórzona, ale nie mogę teraz jeszcze podać daty. I to nie jest ta dobra wiadomość 🙂

Dobra wiadomość jest taka, że 14 XI na SGGW odbędą się kolejne bezpłatne warsztaty organizowane przez nas. Różnica jest taka, że tym razem musicie mieć swojego laptopa, bez niego nie będziecie w stanie brać udziału w zajęciach…

Zapisy (radzę się spieszyć 🙂 ) również w systemie Evenea.

Modem radiowy nRF24L01 – podłączenie do ATtiny

Jeśli chcesz zbudować możliwie tanie i proste urządzenie z modemem nRF24L01, ten rozdział jest la ciebie. Dziś podłączenie modułu do kontrolerów ATtiny.

Podłączenie modemu jest jak zwykle proste. Wymaga tylko połączenia tych samych sygnałów do siebie.

image

Kontrolery ATtiny możesz programować za pomocą Arduino IDE i specjalnego programatora. Programator możesz też zrobić z tradycyjnego Arduino, wgrywając do niego program ArduinoISP i odpowiednio łącząc z programowanym kontrolerem.
Informacje o tym jak to zrobić znajdziesz w Akademii Nettigo, jak i w innych czeluściach internetu.

ATtiny serii 25,45, 85 to kontrolery AVR w małej 8-nóżkowej obudowie. Różnią się głównie ilością pamięci programu Flash. Wielkość pamięci musisz dobrać do własnego projektu.

Podłączenie tego kontrolera do modemu zabiera niemal wszystkie wyprowadzenia. Teoretycznie nie zostaje nic do czego można podłączyć przycisk lub przekaźnik. Jedyny wolny pin to Reset.

Wymyśliłem, że może on służyć do projektów w których po podłączeniu zasilania do układu kontroler wysyła jakieś dane przez modem. Można go zastosować w przełącznikach krańcowych przy drzwiach – sygnalizacja otwarcia, lub pilotach z jednym przyciskiem, który jednocześnie podłącza zasilanie układu.

Oczywiście biblioteka RF24 współpracuje z tym kontrolerem. Jedyna różnica jest taka, że musimy ustawić w konstruktorze “RF24 radio(3, 4);”. Ponieważ sygnał CE jest podłączony do pinu cyfrowego 3, a sygnał CSN do pinu cyfrowego o numerze 4.

ATtiny serii 24, 44, 84 to wersje z większą ilością wyprowadzeń. Po podłączeniu modemu zostaje nam 6 pinów cyfrowych do wykorzystania. 3 z nich można wykorzystać jako wejścia analogowe.

Pozostałe piny to:

  • Wyprowadzenie 2 – jako pin cyfrowy 0
  • Wyprowadzenie 3 – jako pin cyfrowy 1
  • Wyprowadzenie 5 – jako pin cyfrowy 2
  • Wyprowadzenie 11 – jako pin cyfrowy 8 lub pin analogowy 2
  • Wyprowadzenie 12 – jako pin cyfrowy 9 lub pin analogowy 1
  • Wyprowadzenie 13 – jako pin cyfrowy 10 lub pin analogowy 0

Możesz je wykorzystać do podłączenia przełączników, czujników, przekaźników i innych podzespołów.

Budowanie obiektu “radio” – RF24 radio(7, 3);”.

Kontrolery ATtiny wraz z modemem radiowym powinno się zasilać napięciem od 2.7 do 3.6 V. W wersji kontrolerów “V” można obniżyć minimalny próg do 1.9 V.

sprae

Modem radiowy nRF24L01 – zdalne sterowanie urządzeniem

Zdalne sterowanie przy użyciu modemu nRF24L01 jest proste. Zwyczajnie zamiast napisu program wysyła dane, które służą do włączania, albo wyłączania urządzeń podłączonych do pinów.

Program nadajnika, który realizuje taką możliwość wygląda tak:

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

RF24 radio(7, 8);

void setup()
{
  while (!Serial);
  Serial.begin(9600);
  
  radio.begin();
  radio.setRetries(15, 15);
  radio.stopListening();
}

void loop()
{
  if (Serial.available())
  {
    byte rxAddr[6] = {0};
    Serial.readBytesUntil(' ', rxAddr, 5);
    radio.openWritingPipe(rxAddr);
    Serial.read();
    
    byte command[2];
    command[0] = Serial.parseInt();
    Serial.read();
    command[1] = Serial.parseInt();
    Serial.read();
    
    radio.write(&command, sizeof(command));
  }
}

Zasada działania jest prosta. Wysyłasz do Arduino polecenia przez port USB za pomocą Monitora portu szeregowego. Arduino je przerabia na polecenia sterujące odbiornikiem i wysyła przez modem radiowy.

By wysyłać polecenia Monitor portu szeregowego musi być ustawiony na prędkość 9600 bodów i “Nowa linia” w dolnym pasku.

Przykładowe polecenie wygląda tak:

leds1 2 1

Pierwsze 5 znaków to adres odbiornika. Czyli dla programu można łatwo stworzyć sieć wielu odbiorników o różnych adresach, które będą sterowały urządzeniami w różnych miejscach w promieniu 100 metrów.

Kolejną cyfrą po spacji jest numer urządzenia. Arduino i inne płytki mają wiele pinów więc mogą sterować wieloma urządzeniami. Ta cyfra wybiera urządzenie.

Ostatnią cyfrą jest ustawienie urządzenia. 1 oznacza włączenie, 0 wyłączenie.

Elementy polecenia są oddzielone spacjami.

Możesz wydawać polecenia ręcznie lub napisać sobie program w dowolnym języku, który obsługuje port szeregowy PC i sterować zdalnie urządzeniami za pomocą programu.

Budowa programu przypomina wcześniejsze przykłady z poprzedniego rozdziału. Postanowiłem rozwinąć je ewolucyjnie, żebyś łatwiej zrozumiał co się zmieniło i jak wpłynęło na program.

Różnice zaczynają się w funkcji “loop”. Jest tam wykorzystana metoda “Serial.available();” [interfejs szeregowy.dostępne dane], która sprawdza czy port szeregowy Arduino coś odebrał. Jeśli odebrał, to wykonywana jest reszta programu w bloku “if”.

 byte rxAddr[6] = {0};
 Serial.readBytesUntil(' ', rxAddr, 5);
 radio.openWritingPipe(rxAddr);
 Serial.read();

Ta część odczytuje pierwszą część polecenia czyli adres modemu do którego będą wysyłane dane.

W tym fragmencie deklaruję tablicę typu “byte” o 6 elementach, wypełnioną zerami o nazwie “rxAddr”. Będzie ona przechowywała adres odbiornika.

Metoda “Serial.readBytesUntil(’ ’, rxAddr, 5);” [interfejs szeregowy.czytaj bajty dopóki] odczytuje dane z interfejsu szeregowego aż natknie się na znak spacji ’ ’ lub odczyta 5 znaków.

Pierwszy argument to do pojawienia jakiego znaku metoda ma czytać dane.

Drugim argumentem jest tablica do jakiej odczytane dane trzeba zapisać. W tym przypadku jest to tablica adresu odbiornika “rxAddr”.

Trzecim argumentem jest maksymalna liczba znaków do odczytania.

Po odczytaniu adresu, program ustawia modem na adres odbiornika za pomocą metody “radio.openWritingPipe”.

Metoda “Serial.read();” [interfejs szeregowy.odczytaj dane] jest tylko po to, żeby odczytać znak spacji rozdzielający argumenty polecenia. Nigdzie go nie zapisuje. Jest to tylko po to, żeby przyśpieszyć odczytywanie danych.

byte command[2];
command[0] = Serial.parseInt();
Serial.read();
command[1] = Serial.parseInt();
Serial.read();

Kolejny fragment odczytuje 2 kolejne argumenty polecenia – numer urządzeia i jego ustawienie.

Najpierw tworzę tablicę 2-elementową typu “byte” o nazwie “command” [rozkaz/polecenie], która będzie przechowywała polecenie wysyłane modemem do odbiornika.

Metoda “Serial.parseInt();” [interfejs szeregowy.zintepretuj liczbę całkowitą] zamienia tekstowe znaki liczby wysyłane z przez interfejs szeregowy z Monitora portu szeregowego na cyfrowe. Metoda składa liczbę z cyfr, aż natknie się na inny znak niż cyfra. Jeśli w interfejsie szeregowym nie odebrano cyfr, to ta metoda zwraca 0.

Zinterpretowane liczby zapisywane są w pierwszym i drugim elemencie tablicy “command”. Pierwszy element przechowuje numer urządzenia, a drugi jego ustawienie w postaci cyfrowej.

Na koniec program wysyła wypełnioną tablicę “command” do odbiornika za pomocą metody “radio.write(&command, sizeof(command));”.

Program odbiornika wygląda tak:

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

RF24 radio(7, 8);

void setup()
{
  radio.begin();
  const byte rxAddr[6] = "leds1";
  radio.openReadingPipe(0, rxAddr);
  
  radio.startListening();
  
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
}

void loop()
{
  if (radio.available())
  {
    byte command[2];
    radio.read(&command, sizeof(command));
    
    if (command[0] < 3)
    {
      digitalWrite(command[0]+2, command[1]);
    }
  }
}

Zasada działania programu jest taka, że do pinów 2, 3, 4 podłączyłem trzy światełka LED (zielone, żółte, czerwone) anodami przez rezystory 220 Ohm. Katody podłączyłem do pinu GND. Urządzenie ma adres “leds1” i numery urządzeń dla światełek to 0 – zielony, 1 – żółty, 2 – czerwony. Zatem jeśli do nadajnika wyślesz polecenie:

leds1 2 1

To w odbiorniku zaświeci się światło czerwone.

Budowa programu przypomina oczywiście program odbiornika z poprzedniego rozdziału.

To co się zmieniło w funkcji “setup”. Adres odbiornika znajduje się z tablicy “rxAddr”. Każdy odbiornik powinien mieć inny adres, by można było sterować nim niezależnie.

Kolejną nowością jest użycie funkcji “pinMode(2, OUTPUT);” [pin ustaw działanie]. Ustawiam nim piny 2, 3, 4 jako wyjście “OUTPUT” [wyjście], żeby sterowały światłami LED.

W funkcji “loop” zaczynamy od znanego sprawdzenia czy modem odebrał dane za pomocą metody “radio.available();”.

Jeśli odebrał, to tworzona jest 2-elementowa tablica “command” [rozkaz/polecenie] typu “byte”, która będzie przechowywać polecenie wysłane do modemu.

Polecenie jest odczytywane za pomocą metody “radio.read”.

Następnie za pomocą “if” [jeśli/gdyby] sprawdzane jest czy pierwszy element tablicy polecenia – przechowujący numer urządzenia jest mniejszy niż 2. Mamy tyko 3 urządzenia numerach 0, 1, 2 więc nie chciałem, żeby błędne polecenie coś napsuło.

Jeśli polecenie ma dobrą wartość to przekazywane jest do funkcji “digitalWrite(command[0]+2, command[1]);” [zapisz do pinu cyfrowego].

Jego pierwszym argumentem jest numer pinu, a drugim ustawienie stanu tego pinu.

Jako pierwszy argument użyłem pierwszego elementu tablicy “command” przechowującego numer urządzenia. Ponieważ numer urządzenia jest od 0 do 2, a piny są od 2 do 4 dodałem do niego “+2”, żeby zamienił się w numer pinu (0+2=2, 1+2=3…).

Drugi argument przekazuje wartość dla pinu. 0 to stan niski – dioda nie świeci, 1 to stan wysoki – dioda świeci.

Na koniec wpisałem w Monitor Portu to:

I 6 metrów dalej zrobiło się to:

Zamiast diod możesz podłączyć przekaźniki i sterować zdalnie urządzeniami na prąd.

Zamiast funkcji możesz użyć “analogWrite” i sterować urządzeniami przez sygnał PWM np. silnikami. Możesz też tam wstawić obsługę serwomechanizmu i mieć zdalnie sterowanego robota.

Jeśli masz pytania lub coś napisałem niezrozumiale, zapytaj w komentarzach.

Modemy radiowe nRf24L01 kupisz w Nettigo.

sprae

Modem radiowy nRF24L01 – podłączenie do Teensy 3.1

Teensy 3.1 to świetny dodatek do tego modemu, ponieważ obydwie płytki mają zbliżone rozmiary. Można na ich podstawie zbudować naprawdę małe energooszczędne urządzenie.

Jeśli uważasz, że podłączenie Teensy do modemu jest jakimś problemem, to się mylisz ;-).

image

Wystarczy, że podłączysz ze sobą piny o tych samych nazwach,

Jeśli kupiłeś Teensy 3.1 w Nettigo to wraz z nim dostałeś ulotkę z wypisanym znaczeniem wszystkich pinów w Teensy.

  • do pinu 3.3 V podłączasz VCC modemu;
  • do pinu GND podłączasz GND modemu;
  • do pinu 7 podłączasz CE modemu;
  • do pinu 8 podłączasz CSN modemu;
  • do pinu 13 (SCK) podłączasz SCK modemu;
  • do pinu 11 (DOUT) podłączasz MOSI modemu;
  • do pinu 12 (DIN) podłączasz MISO modemu.

Twórca Teensy wykonał tu dobrą robotę, ponieważ numery pinów sygnałów SPI zgadzają się z numerami pinów na których są takie same sygnały w Arduino UNO.

Biblioteka RF24 z poprzedniego wpisu działa bez problemu z Teensy 3.1.

image

Oto moje połączenie Teensy 3.1 z modemem. Wszysto przetestowałem.
Jako ciekawostkę dodam, że w moim Teensy wlutowałem gniazda goldpin.

Części przydatne do połaczenia Teensy 3.1 z modemem mRF24L01 ze sklepu Nettigo:

sprae

Modem radiowy nRF24L01 – programowanie

Teraz przyszła pora na zaprogramowanie urządzeń. Pierwszym programem niech będzie tradycyjne już “Hello World” [Witaj Świecie].

Sprawię, że jedno urządzenie z modemem będzie wysyłało napis do drugiego urządzenia. Drugie urządzenie zaś wyśle odebrany napis do komputera, żeby wyświetlić go w Monitorze Portu Szeregowego Arduino.

Do do programowania modemu nRF24L01 potrzebujesz biblioteki RF24. Znajdziesz ja na stronie projektu RF24 na Github.

Wystarczy kliknąć przycisk “Download ZIP” i pobrać plik biblioteki.

Bibliotekę możesz zainstalować w Arduino IDE poprzez menu Szkic->Importuj bibliotekę->Dodaj bibliotekę. Inny sposób to rozpakować plik zip do katalogu domowego Arduino/librares na Linuksie lub do DokumentyArduinolibrares w Windows.

Program Nadajnika wygląda tak:

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

RF24 radio(7, 8);

const byte rxAddr[6] = "00001";

void setup()
{
  radio.begin();
  radio.setRetries(15, 15);
  radio.openWritingPipe(rxAddr);
  
  radio.stopListening();
}

void loop()
{
  const char text[] = "Hello World";
  radio.write(&text, sizeof(text));
  
  delay(1000);
}

Na początku informuje program jakich będę używał bibliotek.

  • SPI.h – do obsługi interfejsu komunikacji z modemem
  • nRF24L01.h – do obsługi tego konkretnego sterownika modemu
  • RF24.h – biblioteka która ułatwia nam sterowanie modemem radiowym

W dalszej części tworzę obiekt o nazwie “radio”.

RF24 radio(7, 8);

Obiekt ten reprezentuje podłączony do Arduino modem. Argumenty 7 i 8 to numery pinów cyfrowych, do których podłączone są sygnały CE i CSN. Jeśli podłączyłeś je do innych pinów to możesz zmienić argumenty na inne :-).

Potem tworzę globalną tablicę o nazwie “rxAddr”.

const byte rxAddr[6] = "00001";

Zapisałem w niej adres modemu do którego Arduino będzie nadawać dane. Adres ma wartość “00001”, jednak jeśli chcesz możesz mu nadać inną jako dowolny 5 literowy napis.

Adres jest po to, że jeśli w sieci masz kilka modemów, to dzięki adresowi możesz wybrać jeden konkretny modem do którego wysyłasz dane.

W funkcji “setup” wywołuję metodę “radio.begin();” [radio.rozpocznij]. Aktywuje ona modem do działania.

Następnie ustawiam metodę “radio.setRetires(15, 15);” [radio.ustaw kiedy mam sobie darować]. Ustala ona co jaki czas i ile razy modem ma ponawiać wysłanie danych jeśli odbiorca ich nie dostał.

Pierwszy argument ustala co jaki czas ponawiać próbę. Jest on wielokrotnością 250 mikrosekund. 15 * 250 = 3750. Czyli jeśli odbiorca nie odbierze danych modem będzie starał się je wysyłać co 3,75 milisekund. 

Drugi argument to liczba prób. Czyli, że ma próbować wysyłać 15 razy zanim da sobie spokój i uzna, że odbiornik jest po za zasięgiem, albo jest wyłączony.

Metoda “radio.openWritingPipe(rxAddr);” [radio.otwórz rurę/kanał do zapisu] ustawia adres odbiornika do którego program ma wysyłać dane. Jej argumentem jest utworzona wcześniej tablica z adresem odbiornika.

Ostatnia metoda funkcji “setup” to “radio.stopListening();” [radio.skończ nasłuchiwać]. Przestawia ona modem w tryb nadawania danych.

W funkcji “loop” zaczynam od stworzenia napisu który chcę wysłać przez modem.

const char text[] = "Hello World";

Jest to tablica znaków/liter typu “char” [znak] o nazwie “text” do której przypisałem napis “Hello World” [Witaj Świecie]. 

Następnie za pomocą metody “radio.write(&text, sizeof(text));” [radio.zapisz] wysyłam tekst przez radio do modemu, którego adres ustaliłem wcześniej przez “openWritingPipe”.

Pierwszy argument metody to wskaźnik na zmienną, która przechowuje dane do wysłania. Dlatego używam przed nazwą zmiennej “&”, żeby zrobić z niej wskaźnik.

Drugi argument to ilość bajtów jakie radio ma pobrać ze zmiennej do wysłania. Użyłem tu funkcji “sizeof()[rozmiar/wielkość], która automatycznie oblicza ile bajtów ma napis w zmiennej “text”.

Przez tą metodę można wysłać maksymalnie 32 bajty na raz. Bo taki jest maksymalny rozmiar danych pojedynczego pakietu modemu.

Jeśli potrzebne ci jest potwierdzenie, że odbiornik odebrał dane, to metoda “radio.write” zwraca wartośc typu “bool”. Jak zwróci “true” [prawda], to dane dotarły do odbiornika. Jeśli zwróci “false” [fałsz/kłamstwo/bzdura] to dane nie zostały odebrane.

Metoda “radio.write” blokuje działanie programu do czasu potwierdzenia odebrania danych lub do czasu aż skończą się wszystkie próby nadawania ustalone w metodzie “radio.setRetires”.

Ostatnią częścią funkcji “loop” jest wywołanie funkcji “delay(1000);”. Blokuje ona program na 1000 milisekund, czyli jedną sekundę. Sprawia, że program będzie co sekundę wysyłał napis “Hello World” do odbiornika.

Program odbiornika w drugim urządzeniu z modemem będzie wyglądał tak:

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

RF24 radio(7, 8);

const byte rxAddr[6] = "00001";

void setup()
{
  while (!Serial);
  Serial.begin(9600);
  
  radio.begin();
  radio.openReadingPipe(0, rxAddr);
  
  radio.startListening();
}

void loop()
{
  if (radio.available())
  {
    char text[32] = {0};
    radio.read(&text, sizeof(text));
    
    Serial.println(text);
  }
}

Program wygląda z grubsza dość podobnie do programu nadajnika. Najpierw wybierane są biblioteki, których będziemy używać, potem tworzony jest obiekt “radio” z wybranymi pinami sterującymi, w kolejnej linii widać tablicę z adresem odbiornika – takim samym jak w programie nadajnika.

W funkcji “setup” na początku ustawiam obiekt “Serial” do komunikacji Arduino z komputerem.

while (!Serial);

Ten fragment czeka, aż port USB w Arduino przełączy się w tryb portu szeregowego COM:

Metoda “Serial.begin(9600);” [Port Szeregowy.rozpocznij] ustawia prędkość komunikacji z komputerem przez USB/COM.

Następna częśc funkcji to ustawianie modemu. Rozpoczyna je znana z poprzedniego programu metoda “radio.begin();” ustawiająca modem do działania z programem.

Kolejna linia programu to “radio.openReadinPipe(0, rxAddr);” [radio.otwórz rurę/kanał do odczytu], która ustala jaki nasz modem ma adres pod którym odbiera dane.

Pierwszy argument to numer rury/strumienia. Można stworzyć do 6 strumieni odczytu reagujących na różne adresy. Ja utworzyłam adres tylko dla strumienia numer 0.

Drugi argument to adres na jaki ma reagować strumień, żeby odebrać dane. Ustawiłem tu adres przypisany do tablicy “rxAddr”.

Kolejną czynnością jest włączenie odbierania danych przez modem za pomocą metody “radio.startListening();”. Od tej chwili modem czeka na dane wysłane pod ustalony adres.

W funkcji “loop” program wykonuje następujące operacje.
Najpierw sprawdza czy dotarły jakieś dane na adres modemu za pomocą metody “radio.available();”. Metoda ta zwraca wartość “true” [prawda]jeśli czekają na nas jakieś dane, lub “false” [fałsz] jeśli nikt nic nie wysłał.

char text[32] = {0};

Jeśli dane czekają, to tworzę 32-elementową tablicę typu “char” o nazwie “text” wypełnioną zerami, do której zapiszę odebrane dane.

By odczytać dane używam metody “radio.read(&text, sizeof(text));”.

Pierwszym argumentem metody jest wskaźnik do zmiennej do której mają być zapisane dane odebrane przez modem. By przedstawić zmienną jako wskaźnik zastosowałem znak “&” przed jej nazwą.

Drugim argumentem jest ilość danych do zapisania w zmiennej. Zastosowałem tu znowu funkcję “sizeof()” [rozmiar/wielkość], która automatycznie obliczy rozmiar tablicy “text”. 

Po odebraniu danych, przekazuje je do metody “Serial.println(text);”, która wysyła odebrany tekst do komputera, gdzie można go podglądać w “Monitorze portu szeregowego” za pomocą Arduino IDE.

Przy poprawnych połączeniach i działaniu programu, monitor powinien zwracać takie wartości.

Modem nRF24L01 możesz kupić w sklepie Nettigo:

sprae

Modem radiowy nRF24L01 – podłączenie do Arduino

Moduł radiowy bardzo łatwo podłączysz do Arduino. Wystarczy połączyć sygnały o takich samych nazwach na obydwu płytkach.

image

Schemat jest uniwersalny i pasuje do wszystkich płytek Arduino UNO, DUE, MEGA, Leonardo, Yun itp. standardu Arduino 1.0 (R3), ale również i starszych.

Sygnały interfejsu SPI znajdują się we wtyku ICSP. Do podłączenia przydadzą się przewody typu Gniazdo-Gniazdo (F-F), które zaproponowałem w spisie części na dole.

Resztę sygnałów możesz podłączyć za pomocą przewodu Wtyk-Gniazdo (F-M).

Wejście zasilania modułu VCC podłączasz w Arduino do pinu z napięciem 3.3 V
Wyprowadzenie GND podłączasz w Arduino do pinu GND.

Sygnały wybierające CE i CSN możesz podłączyć do dowolnych pinów cyfrowych. Potem w bibliotece RF24 możesz określić, których pinów użyłeś. Ja wybrałem piny 7 i 8 bo takich się będę trzymał w przykładach.

W płytce Arduino UNO sygnały SPI są połączone z niektórymi pinami cyfrowymi. Są one przez to wyłączone z użycia podczas korzystania z modemu.

  • MOSI jest połączony z cyfrowym pinem 11
  • MISO jest połączony z cyfrowym pinem 12
  • SCK jest połączony z cyfrowym pinem 13
  • SS (nie używany, ale też blokuje) jest połączony z cyfrowym pinem 10

W Arduino MEGA 1280 i 2560 jest podobna sytuacja.

  • MOSI jest połączony z cyfrowym pinem 51
  • MISO jest połączony z cyfrowym pinem 50
  • SCK jest połączony z cyfrowym pinem 52
  • SS jest połączony z cyfrowym pinem 53

W Arduino DUE, Yun i Leonardo nie ma tego problemu. Sygnały SPI na złączu ICSP są niezależne od pinów cyfrowych.

imageJa zamiast przewodów Gniazdo-Gniazdo użyłem płytki stykowej :-P.

Zestaw do podłączenia modemu nRF24L01 z wygodnymi przewodami i Arduino Leonardo.

sprae

Modem radiowy nRF24L01 – opis wyprowadzeń

Układ nRF24L01 dostarczany jest przez Nettigo na płytce adaptera z wbudowaną anteną. Płytka do działania wymaga podłączenia tylko kontrolera. Wymiary płytki to 1,55 cm na 2,9 cm.

Od spodniej strony płytki sygnały komunikacyjne wyprowadzone są na wtyk goldpin 2 rzędy po 4 piny.

Modem komunikuje się z kontrolerem za pomocą interfejsu SPI, który można znaleźć w niemal każdym kontrolerze.

Znaczenie sygnałów:

  • VCC – zasilanie – od 1,9 do 3,3 V
  • GND – masa
  • MOSI – wejście danych szeregowych SPI
  • MISO – wyjście danych szeregowych SPI
  • SCK – zegar danych (zatwierdza każdy bit danych) SPI
  • CSN – stan niski na tym pinie sygnalizuje, że to właśnie z tym układem kontroler chce się komunikować
  • CE – sygnał aktywujący nadawanie lub odbiór. W trybie odbioru stan wysoki sygnalizuje, że chce się odbierać. W trybie nadawania impuls wysyła jedną paczkę danych.
  • IRQ – wyjście przerwania. Robi impuls o stanie niskim, kiedy dane czekają na odbiór lub kiedy dane zostały prawidłowo wysłane

W kolejnym wpisie podłączę płytkę do Arduino i wyślę pakiet danych.

sprae

Modem radiowy nRF24L01

Modem NRF24L01+ służy do tego, by zamiast łączyć wiele urządzeń przewodami, wykorzystać do ich komunikacji niewidzialne fale radiowe.

image

Modem działa w paśmie 2,4 GHz i ma zasięg 100 m. Pozwala na komunikację z prędkością 250 kbps, 1 lub 2 Mbps. Taka prędkość pozwala nawet na przesłanie materiału video 720p w jakości znanej z Youtube.

Urządzenie podczas pracy pobiera mniej prądu niż pojedyncza dioda LED. Podczas odbioru jest to 12 mA, a podczas nadawania 11 mA. Dostępne są też automatyczne stany oszczędzania energii. Pobiera podczas pracy w nich 320 µA (kiedy dane czekają na wysłanie). 26 µA (kiedy nie ma czego wysyłać), 0,9 µA (w trybie wyłączenia).

Modem możesz zasilać napięciem od 1.9 do 3.6 V. Jego wejścia do komunikacji tolerują poziomy logiczne o napięciu 5 V. Więc bez problemu podłączysz je do większości popularnych płytek kontrolerów.

Pasmo na którym pracuje modem podzielone jest na 125 kanałów (osobnych częstotliwości). Pozwala to stworzyć właśnie tyle niezależnych sieci tych urządzeń w jednym miejscu.

Na jednym kanale każdy modem ma swój adres. A właściwie może mieć do 6 adresów. Adresy to numery dzięki którym możesz wybrać konkretne urządzenie w sieci, które ma odebrać dane.

Adres może mieć długość od 3 do 5 bajtów. Daje to adresy od 24 do 40 bitów. Przy najmniejszym adresie jest to 17 mln kombinacji. Dłuższy adres jest raczej do nadawania urządzeniom nazw tekstowych (5-literowych).

Modem automatycznie sprzętowo tworzy pakiety danych. Ty wysyłasz mu tylko to co chcesz wysłać pod konkretny adres. Modem zaś sam tworzy zaadresowany pakiet danych, zabezpieczony przed błędami sumą kontrolną CRC. Sam też dba, żeby pakiet dotarł do adresata. Gdyby wystąpiły jakieś błędy ponawia wysyłanie danych. Gdy transmisja się uda modem docelowy odsyła automagicznie potwierdzenie.

Urządzenie komunikuje się z kontrolerem za pomocą interfejsu SPI. Potrzebuje do tego 5 wyprowadzeń.

Modem kupisz w naszym sklepie Nettigo

W kolejnych częściach zrobię opis wyprowadzeń modemu, oraz sposób podłączenia do Arduino, Teensy 3.1 i Raspberry PI. Do przykładów programowania użyję biblioteki RF24.

Jeśli chciałbyś się dowiedzieć czegoś więcej, o czym nie zamierzam wspominać, zapytaj w komentarzach.

sprae

Snap4Arduino – następca S4A

Opisując wczoraj Scratch dla Arduino – S4A czułem, że projekt mimo, że funkcjonalny to jest nieco opuszczony. Dziwiło mnie, że nikt nie zrobił poprawek do starego firmware dla Arduino do komunikacji z programem. To nie jest trudne.

Przeglądałem blog projektu i okazało się, że autorzy pracują nad czymś nowszym. Nowy projekt nosi nazwę Snap4Arduino. Środowisko jest bardzo podobne do Scratch, tak więc nikt nie będzie czuł się zagubiony.

Snap4Aruino na razie jest w wersji Alpha i u mnie był dość niestabilny. U ciebie może będzie lepiej, bo ja mam również system operacyjny w wersji testowej co pewnie pogłębiło niestabilność #życieNaKrawędzi ;-).

Program można pobrać ze strony projektu:

Działa z systemami operacyjnymi Windows, Linux i OS X.

By móc połączyć się z płytką kontrolera wymagane jest wczytanie do niej protokołu Firmata. To standardowy protokół obsługujący chyba wszystkie płytki Arduino i zgodne z nimi czyli np. Teensy.

Żeby go wczytać, wybierz w Arduino IDE menu: Plik > Przykłady > Firmata > StandardFirmata i wgraj do swojej płytki.

Snap4Arduino dzięki Firmata pozwala na dowolne wykorzystanie pinów kontrolera i  ich obsługa jest 7x szybsza niż w poprzednim projekcie.
Dodatkową zaletą jest to, że projekt został napisany w NodeJS, co pozwala na łatwe dodawanie klocków i rozwijanie programu.

sprae