komunikacja I2C (LCD na hd44780)

(Wpis ten jest reaktywacją wpisu z 2017 r. Okazało się, że warto podzielić oryginalny wpis na dwie mniejsze części – jedna dotycząca komunikacji I2C właśnie, druga SPI).

Komunikacja I2C

To bardzo popularny interface komunikacyjny, obsługujący za pomocą tylko 2 linii aż 127 urządzeń! tymi pinami są SDA (w Arduino pin A4) oraz SDC (w Arduino pin A5). Oznacza to, że gdy podłączamy coś na I2C „tracimy” piny A4 i A5. Trudno – coś za coś. Zresztą, to nic nowego – podobnie jest z komunikacją UART – Serial.begin(xxx) – „zabiera” nam cyfrowe piny #o (TX) i #1 (RX). Przy czym UART to tylko komunikacja z jednym urządzeniem – a tutaj 2 piny i możliwość obsługi do 127 urządzeń!

HD44780 i LCD 16×2

Jako przykład komunikacji I2C użyliśmy wyświetlacza LCD 16×2 z dodatkowym sterownikiem hd44780. Po co ten sterownik? wszak to bardzo popularny wyświetlacz i można go podłączyć w ten sposób:

Przypatrzmy się uważnie co my tu widzimy – zwracam uwagę na liczbę pinów potrzebnych do obsługi wyświetlacza przez Arduino. Uważne oko uczestnika sdanaszych spotkań zauważy, że potrzeba aż 6 cyfrowych pinów. To sporo! Wszystko jest OK, gdy robimy proste programy, poznajemy moduły (w tym właśnie taki LCD) więc tych 6 pinów nie robi problemu. Ale my mamy już nasz pojazd i wykorzystanych 6 pinów do jego sterowania (a w planach kolejne rozbudowy). Jak więc poradzić sobie z problemem (powoli) kończących się pinów w Arduino UNO? Zakupić Megasa? A może użyć właśnie sterownika na I2C – wówczas potrzeba jedynie 2 pinów!

My skorzystaliśmy z wymienimego sterownika PLUS biblioteki LiquidCrystal_I2C autorstwa Franka de Brabander-a. Sporo jest podobnych bibliotek, więc doinstalowywując ją sobie warto zwrócić uwagę na tą użytą przeze mnie, a nie inną. Na szybko poznaliśmy kilka metod nowego obiektu do obsługi wyświetlacza:

include <Wire.h>   // standardowa biblioteka Arduino
#include <LiquidCrystal_I2C.h> // dolaczenie pobranej biblioteki I2C dla LCD

LiquidCrystal_I2C lcd(0x27, 16, 2);
//LiquidCrystal_I2C lcd(0x3f, 16, 2);


void setup(){
  lcd.init();
  lcd.begin(16,2);   // Inicjalizacja LCD 2x16
  
  lcd.backlight(); // zalaczenie podwietlenia 
  lcd.setCursor(0,0); // Ustawienie kursora w pozycji 0,0 (pierwszy wiersz, pierwsza kolumna)
  lcd.print("pomidor!");
  delay(500);
  lcd.setCursor(0,1); //Ustawienie kursora w pozycji 0,0 (drugi wiersz, pierwsza kolumna)
  lcd.print("LCD 16x2 I2C -- hd44780");

}

int nico=7;
void loop() 
{
   lcd.backlight(); // zalaczenie podswietlenia
   lcd.setCursor(10,1);
   lcd.print(millis()/1000);
   delay(1000);
   lcd.noBacklight(); // wylaczenie podswietlenia
   lcd.setCursor(0,0);
   lcd.print(nico);
   nico=nico*2;
   delay(1000);
}

Warto ją poznać dokładniej, czytając dokumentację.

Adresacja użądzeń I2C 

Skoro do tych samych pinów SDA i SDC można podłączyć do 127 urządzeń, to skąd wiadomo, kto co nadaje? Np. jeśli chcemy użyć dwóch LCD-ków, na jedynym wyświetlać pewne informacje a na innym inne to jak kierować napisy na różne urządzenia?

Ważne jest poznanie adresu naszego użądzenia – w tym celu należy wygooglać świetny programik i2c_scanner i wgrać do Arduino z podłączonym wyświetlaczem (zresztą, nie tylko wyświetlaczem – czymkolwiek na I2C).

A jak zmienić adres w omawianym sterowniku hd44780? Bo gdy kupiny sobie dwa takie i chcemy je wykorzystać razem to będzie to niemożliwe – oba będą mieć fabrycznie te same adresy (albo 0x27 – gdy to moduł PCF8574/PCF8574T lub 0x3f – dla modułów PCF8574A). Jest możliwość zmiany adresu zwierając ze sobą (lutując) piny A012 na spodzie modułu:

Kliknij obrazek by dowiedzieć się co i jak.

(c) K.G. 2017, 2019

 

Ekranik LCD 16×2 oraz komunikacja I2C

Kontynuujemy projekt zabawki mierzącej refleks (także pamięć – „memory”). Potrzebujemy sposobu komunikacji z użytkownikiem (innego niż podłączony komputer PC do Arduino) – wybór padł na ekranik LCD 16×2.

LCD 16×2

Układ ten to szesnaście znaków w dwóch wierszach – stąd nazwa 16×2. Są także inne, obejrzyjcie dla przykładu magazyny botland.com.pl

Schemat podłączenia ładnie opisany jest na oficjalnych stronach Arduino – zapraszam do lektury. Nasze układy po złożeniu wyglądały tak:

Program polega na użyciu wbudowanej bibliotyki LiquidCrystal.h — poniżej program:

//LCD16x2 sterowany przez Arduino

#include <LiquidCrystalC.h> // dolaczenie pobranej biblioteki dla LCD

LiquidCrystal lcd(, 2, 11, 12, 4, 5, 6, 7);

void setup(){
  lcd.begin(16,2);   // Inicjalizacja LCD 2x16
  
  lcd.setCursor(0,0); // Ustawienie kursora w pozycji 0,0 (pierwszy wiersz, pierwsza kolumna)
  lcd.print("pomidor!");
  delay(500);
  lcd.setCursor(0,1); //Ustawienie kursora w pozycji 0,0 (drugi wiersz, pierwsza kolumna)
  lcd.print("LCD 16x2");
}
void loop() {
}

Warte podkreślenia jest tutaj fakt wykorzystania aż 6-ciu cyfrowych pinów do obsługi tego wyświetlacza. To dużo! Nie ma sprawy, gdy tylko „bawimy” się modułem ekraniku, ale gdy już coś budujemy, podłączamy LED-y czy przyciski – to wówczas spotykamy się z deficytem pinów w Arduino UNO. Ale są lepsze sposoby na podłączenie takiego wyświetlacza.

Komunikacja I2C (IIC, TWI)

To bardzo popularny interface komunikacyjny, obsługujący za pomocą tylko 2 linii aż 127 urządzeń! tymi pinami są SDA (w Arduino pin A4) oraz SDC (w Arduino pin A5). Oznacza to, że gdy podłączamy coś na I2C to łączamy to coś dwoma przewodami z Arduino, podłączając do wejść A4 i A5 – jednocześnie „tracimy” te piny (A4 i A5) – nie możemy z nich korzystać. Trudno – coś za coś. Zresztą, to nic nowego – podobnie jest z komunikacją UART – Serial.begin(xxx) – „zabiera” nam cyfrowe piny #o (TX) i #1 (RX). Przy czym UART to tylko komunikacja z jednym urządzeniem – a tutaj 2 piny i możliwość obsługi do 127 urządzeń!

Moduł hd44780 (i2c)

Jako przykład komunikacji I2C użyliśmy wyświetlacza LCD 16×2 z dodatkowym sterownikiem hd44780. Taki sterownik jest tani a bardzo użyteczny. 

Całe podłączenie polega na połączeniu VCC i GND ze steronika do VCC i GND z Arduino, oraz pinów SDA, SDC ze sternika – do SDA i SDC w Arduino. Przy okazji dowiedzieliśmy się, że piny A4 i A5 w Arduino mają swoje „klony” w szeregu pinów cyfrowych, powyżej #13, GDN, ARFE.

Musimy użyć nowej biblioteki do obsługi tego modułu – ja zdecydowałem się na LiquidCrystal_I2C.h autorstwa Franka de Brabandera. Nie jest standardowo zainstalowana więc trzeba ją samodzielnie doinstalować. Przykładowy program:

//LCD16x2 sterowany przez I2C Arduino

include <Wire.h>   // standardowa biblioteka Arduino
#include <LiquidCrystal_I2C.h> // dolaczenie pobranej biblioteki I2C dla LCD

LiquidCrystal_I2C lcd(0x27, 16, 2);
//LiquidCrystal_I2C lcd(0x3f, 16, 2);


void setup(){
  lcd.init();
  lcd.begin(16,2);   // Inicjalizacja LCD 2x16
  
  lcd.backlight(); // zalaczenie podwietlenia 
  lcd.setCursor(0,0); // Ustawienie kursora w pozycji 0,0 (pierwszy wiersz, pierwsza kolumna)
  lcd.print("pomidor!");
  delay(500);
  lcd.setCursor(0,1); //Ustawienie kursora w pozycji 0,0 (drugi wiersz, pierwsza kolumna)
  lcd.print("LCD 16x2 I2C -- hd44780");
}
void loop() {
}

i2cScanner

To bardzo użyteczny program (aż mnie dziw bierze, że nie jest standardowo dodany do Arduino IDE!) więc trzeba go ręcznie zgrać z internetu i uruchomić. Dzięki niemu poznajemy adres swojego urządzenia – bo skoro magistrala i2c obsługuje aż do 127 urządzeń, to jak je rozpoznaje? które urządzenie jest które? a jeśli chcemy mieć 2, 3 lub 4 wyświetlacze LCD w jednym projekcie? Właśnie po to są adresy!

W naszej pracowni występują dwa rodzaje urządzeń – o adresach 0x27 oraz o 0x3f. Koniecznie sprawdź u siebie! W naszym przykładowym kodzie adres zapisany jest w linii 6 (kolejna linia przygotowuje na inny adresik).

Pomiar prądu

Warto zdawać sobie sprawę z użycia prądu – jak widać z poniższych zdjęć wykonaliśmy pomiar i odnotowaliśmy różnicę w poborze prądu w zależności od trybu działania ekraniku LCD – bez podświetlenia (około 6 mA) oraz z podświetleniem (około 26 mA).

A tutaj pomiar prądu z włączonym podświetleniem:

Projektując swój układ warto brać pod uwagę „prądożerność” każdego urządzenia. Ale to na przyszłość. My przećwiczyliśmy mierzenie prądu 😉

(c) KG 2018

komunikacja I2C oraz SPI — LCD i nRF24

Dziś sporo o sposobach komunikacji innej niż UART – poznajemy  I2C oraz SPI.

Powyżej „zrzut ekranu” naszych zajęć 😉

Komunikacja I2C

Przeniesiona tutaj.

Komunikacja SPI

Przeniesiona tutaj.

Co dalej?

Oczywiście nic nie stoi na przeszkodzie by połączyć oba poznane dziś urządzenia – i zamiast wyświetlania na monitorze PC-ta (przez port szeregowy) wyświetlać na LCD-ku 16×2…. My na nastepnych zajęciach zastąpimy sterowanie naszymi pojazdami z czujki na podczerwień na wspomnianą właśnie komunikację radiową.

Mam nadzieję, że te nowe „zabawki” (klocki) rozbudzą Waszą wyobraźnię 😉

Kolejne zajęcia w dniu 16-maja o godz. 16:15.  Zapraszam!

(c) K.G. 2017

P.S.

Wpis edytowany w listopadzie 2019: komunikacja I2C oraz SPI przeniesiona do dówch oddzielnych części, bo (jak się okazało) – studenci dość często z tego korzystali.

 

Zajęcia nr 9 (ostatnie) – Dzień Ojca Robota!

Dzień Ojca „Robota”!

Dziś w ten szczególny dzień (primo: Dzień Ojca, secundo: nasze ostanie spotkanie w Talentach XXIw!) zbudowaliśmy naszego pierwszego mobilnego robota. Uczestnicy kursu zostali więc ojcami swoich mechanicznych zabawek sterowanych pilotem od TV 😉 Gratulacje!

Wykonanie robota polegało najpierw na złożeniu przygotowanych części – hardware w hardcorowym wykonaniu (opis zestawu z fotkami tutaj). Warte jednak zapamiętania jest jedno: nie trzeba kupować (dość) drogich zestawów allegrowych typu platforma robota jezdnego za (bagatela) 40-90 zł (…plus wysyłka) aby rozpocząć przygodę z robotem. Wystarczy płyta pilśniowa (tzw. plecki od szafek), kątownik (trafiłem na taki pasujący do naszych kół!) oraz wkrętarka aby stworzyć pojazd! Do tego warto zaopatrzyć się w garść śrub (w naszym przypadku: fi – czyli średnica – 3mm, długość – 8mm, 12mm oraz 35mm – raptem 3 rodzaje) oraz podkładki z nakrętkami zakupione w Krometcie (uwaga: wpis zawiera lokowanie produktu 😛 a może po prostu dzielę się z Wami fajnymi sklepami?)http://www.kromet.bialystok.pl/templates/kromet_34/images/header-object.pngaby za kwotę mniej niż 5 zł stworzyć platformę, którą możemy dopasować do swoich potrzeb (proszę – porównaj to z ceną podobnych platform, wykonanych z pleksiglasu i dostępnych w serwisach aukcyjnych). To był pierwszy krok.

Drugi krok to połączenie elementów elektroniki sterującej pojazdem. Uczestnicy kursu wykazali się zrozumieniem działania modułu L298N (sterownik silników) oraz TSOP2236 (odbiornika podczerwieni), poznanych wcześniej na naszych zajęciach. Podłączyli wszystko do Arduino UNO i … stworzyli pojazd, który jeździł i obracał się według rozkazów wysyłanych z pilota od TV!

Trzeba przyznać, że to dopiero początek przygody z robotyką. Nasz kurs w ramach Talentów XXIw się kończy, ale (mam nadzieję) Wasza przygoda z informatyką-elektroniką-fizyką dopiero się zaczyna!

Warsztaty „Z fizyką w przyszłość”

Osoby wytrwałe do końca kursu zachęcam do pilnego śledzenia naszego profilu na FB i nasłuchiwaniu o nadchodzącej inicjatywie Wydziały Fizyki UwB „Z fizyką w przyszłość”, gdzie będzie kurs Arduino. Warsztaty rozpoczną się w październiku 2016 r. więc nie przegapcie zapisów, specjalnie dla Was przygotuję grupę zaawansowaną. A jeśli nie chcecie bawić się w mój zestaw z płyty pilśniowej to zapraszam na warsztaty z modelowania i druk 3D – także w cyklu „Z fizyką w przyszłość” (pamiętajcie: październik 2016!).

Wakacyjne projekty?

Jeszcze raz gratuluję wytrwałości na moich zajęciach oraz pracowitości (choć przyznać muszę, że… 1) prac domowych mógłbym otrzymywać więcej, oraz 2) trzeba robić notatki!). Cieszy mnie Wasz entuzjazm, gdy sterowaliście swoim własnym pojazdem! Dziękuję za wspólnie spędzony czas i… zapraszam do chwalenia się własnymi robo-osiągnięciami w wakacje (macie pytanie odnośnie tematu? zakupów? proszę słać do mnie emaile).

K. Gawryluk

Zajęcia nr 8 – LCD16x2 oraz… zdalnie sterowany POJAZD!

LCD 16×2  (na sterowniku HD44780)

16x2-Character-LCDWłaściwie niezbędny element, jeśli chcemy stworzyć mobilnego robota na płytce Arduino. W końcu zależy nam, aby „odczepić” się od komputera i portu szeregowego, ALE  ciągle chcemy, aby Arduino do nas gadało 😉 Może to być stacja pogody, wyświetlająca na ekraniku aktualną temperaturę/ wilgotność/ prędkość wiatru/ cokolwiek (i nie musimy mieć podłączonego kompa!)…. może to być też pojazd na kółkach, którym sterujemy pilotem od TV  – poznanym na naszym poprzednim spotkaniu. Wystarczy teraz połączyć wszystko do kupy (wraz ze sterownikiem silników – modułem L298D) i mamy zabawę! Warto wspomnieć, że sterownik ekraniku HD44780 obsługiwany jest przez bibliotekę LiquidCrystal — powinna być domyślnie zainstalowana w Arduino IDE.

Poznany sposób podłączenia tego wyświetlacza angażował aż 6 pinów cyfrowych z Arduino – to dość dużo. Mogę dopowiedzieć, że istnieją inne sposoby obsługi tego wyświetlacza – przez protokół I2C – wymagające tylko 2 przewody… Wymagany do tego jest konwerter (za kwotę ~8.5zł, co jest dość sporo przy cenie samego wyświetlacza za ~10zł). Ale to opowieść na inną okazję.

millis()

Przekonaliśmy się także o tym, że funkcja millis() – zwracająca liczbę milisekund od czasu uruchomienia Arduino – jest bardzo użyteczna. Warte zapamiętania jest także dyskusja typów danych do przechowywania wartości milisekund – przy odpowiednim doborze mamy zmienną całkowitą, bez znaku i to 4-ro bajtową, gotową do zapisywania czasu 40-tu iluś tam dni w milisekundach właśnie. Chodzi oczywiście o typ unsigned long.

Liczba pi (3.141592…)

Na naszych zajęciach dużo się dzieje… Aby trenować wyświetlanie na ekraniku wyliczyliśmy liczbę pi ze wzoru Leibniza:

\sum _{{n=0}}^{{\infty }}{\frac {(-1)^{{n}}}{2n+1}}={\frac {1}{1}}-{\frac {1}{3}}+{\frac {1}{5}}-{\frac {1}{7}}+{\frac {1}{9}}-\cdots ={\frac {\pi }{4}}

I choć kod liczący tego typu wyrażenia okazał się prosty, to jednak jego zrozumienie już takie oczywiste nie było. Wypada pochwalić jednego uczestnika – Mariusza z 2LO Bstok, który napisał własny algorytm poprawnie liczący tą liczbę, cechujący się lepszą wydajnością niż mój szkoleniowy. Gratuluję!

Pilot TV + koła + ekranik = pojazd na trzech kółkach!

Przychodzi najciekawszy etap naszych zajęć – łączymy wszystkie poznane elementy w jeden projekt. Pochwalę Łukasza i Mateusza z ZSM CKP#2 za wytrwałą pracę i złożenie pojazdu, a następnie jego (proste) oprogramowanie.

DSC_1339DSC_1340

Pojazd śmigał całkiem żwawo po podłodze (8x paluszki AAA to za duże napięcie jak na te silniki, ale…) i sterowany był pilotem na podczerwień. Na kolejnym spotkaniu uczniowie oprogramują maszynę w nowy sposób – mam nadzieję 😉

DSC_1341Inni męczyli się jeszcze ze sterowaniem pojedynczym kołem przez pilot TV – mam nadzieję, że to „męczenie” było całkiem przyjemne i zachęcające do naszego następnego spotkania, za tydzień. Na nim wszyscy stworzą swojego pierwszego mobilnego robota. Zapraszam!

Ostatnie zajęcia 23-06-2016, 16:00

na nasze ostatnie zajęcia proszę przynieście piloty od TV oraz dużo zapału do pracy (jak zawsze). Będą to także zajęcia podsumowujące, czyli miło by mi było widzieć osoby, które zapisały się na moje zajęcia a uczęszczały sporadycznie (nie wnikam w przyczyny) – będę ciekaw Waszych opinii o kursie. Dodatkowo zostaną przedstawione pozalekcyjne projekty Wydziału Fizyki dotyczące kształcenia młodzieży ponadgimnazjalnej w nadchodzącym roku szkolnym. Wakacje tuż tuż, może warto łyknąć inspirację i twórczo spędzić część lata w warsztacie robotycznym? Serdecznie zapraszam!

Arduino: konwerter I2C dla wyświetlacza LCD HD44780 + microswitche ponownie (18-04-2016)

Po raz pierwszy na nasard_microsw_led2x16zym Kole pojawiła się kwestia komunikacji innej niż UART. Podłączyliśmy więc ekranik LCD za pomocą konwertera I2C. Dzięki temu zaoszczędzamy piny mikrokontrolera, które możemy zagospodarować inaczej.

Wróciliśmy też do mikroswiczy, z których budujemy zderzaki dla naszego pojazdu. Liczbę kliknięć (zderzeń) lewego i prawego czujnika (mikroswicza) wypisujemy na LCD w górnym, i dolnym wierszu. Za tydzień pojazd ruszy w swoją pierwszą, autonomiczną podróż ?