wyświetlacz LCD z arduino & wyświetlacz LCD z Raspberry Pi

W tym poście przedstawię wam jak podłączyć wyświetlacz LCD w arduino oraz w Raspberry Pi żebyście mogli zobaczyć podstawowe różnice obu płytek.

Zacznijmy więc od arduino.

Na początek standardowo piszemy krótki program:

Nie będę wyjaśniał co oznaczają poszczególne ponieważ standardowo są to polecenia void setup oraz void loop. Jedyne co doszło to na samym początku biblioteka do naszego wyświetlacza oraz zdefiniowanie pinów na naszej płytce pod które będą podpięte piny wyświetlacza.
Jak zapewne zauważyliście w programie znajdują się 2 polecenia lcd.print i w nawiasach wpisujemy to co chcemy wyświetlić. Jedyne ograniczenie to 2x po 16 znaków.

Jak już wspomniałem we wcześniejszym poście http://mikrokomputer-raspberry-pi.blogspot.nl/2014/04/podnoszace-poziom-szczescia-zakupy.html
warto mieć wyświetlacz np taki:

Jak można zauważyć mój nie posiada podpisanych pinów ale w każdym wyświetlaczu znajdują się w tej samej kolejności.
Zaczynając od prawej strony (bliżej brzegu wyświetlacza):
1: VSS czyli masa
2: VDD czyli zasilanie 5V
3: VO czyli kontrast
4: RS czyli Rejestr
5: RW czyli odczyt/zapis z ang. Read/Write
6: E
7: D0
8: D1
9: D2
10: D3
11: D4
12: D5
13: D6
14: D7
15: A czyli anoda(+),podświetlenie wyświetlacza  tutaj podłączamy 5v
16: K czyli katoda(-), tutaj podłączamy masę tj: GND na naszej płytce.

Do sterowania kontrastem użyjemy potencjometru 10k:

Wgrywamy nasz program do arduino i odłączamy od zasilania/portu usb.

Teraz bierzemy się za płytkę.
Na początek wpinamy nasz wyświetlacz tak aby piny znajdowały się tuż za środkową linią na płytce czyli po tej samej stronie co przewody. Obok wpinamy potencjometr. wygląda to tak:

Zacznijmy od tego że na płytce podpinamy do czerwonej linii zasilanie 5 V (czerwony przewód), a do niebieskiej linii masę (czarny przewód) czyli GND na arduino.
Potencjometr będzie sterować kontrastem. Lewa nóżka do zasilania 5 V prawa do uziemienie (niebieska linia) środkowa do pinu 3 w wyświetlaczu (VO).
Wyświetlacz:
1 pin VSS do niebieskiej linii,
2 pin VDD do czerwonej linii,
3 pin VO już podłączyliśmy do potencjometru.
4 pin RS podłączamy do pinu 12 w arduino.
5 pin RW  podłączamy do masy (niebieska linia) czyli zapis.
6 pin E podłączamy do pinu 11 w arduino.
7 pin pusty
8 pin pusty
9 pin pusty
10 pin pusty
11 pin podłączamy do pinu 5 w arduino
12 pin podłączamy do pinu 4 w arduino
13 pin podłączamy do pinu 3 w arduino
14 pin podłączamy do pinu 2 w arduino
15 pin Anoda(+) podłączamy do linii czerwonej (5v)
16 pin Katoda (-) podłączamy do linii niebieskiej masa (GND)

Całość wygląda tak:

Teraz podłączamy nasze arduino do zasilania i sprawdzamy jak działa. Jeżeli wszytko zostało podłączone prawidłowo powinie pokazać się napis który wpisaliśmy w nawiasach. Jeżeli nic nie widać albo są same białe kwadraciki to trzeba wyregulować kontrast potencjometrem.

 A teraz czas na raspberry Pi :)
Opis dotyczy modelu B ponieważ oba modele mają różną kolejność pinów!!!
ale bez obaw można zrobić ten projekt na raspberry Pi typu  A ponieważ piny użyte w tym przykładzie są te same.

Na początek w terminalu wpisujemy komendę:
        sudo apt-get install python3-rpi.gpio

Jak widać mam już zainstalowaną najnowszą wersję programu.

Do projektu wykorzystam poprzednią płytkę którą używałem do arduino ponieważ będzie podłączona w ten sam sposób.

Dla ochrony niezabezpieczonych niczym pinów RPI używam płytki protoPi

która to ponadto ma opisane piny.

Naszą taśmę podłączamy w następujący sposób aby kolejność pinów na protoPi się zgadzała:

drugi koniec taśmy można podłączyć tylko w jeden sposób do płytki protoPi ze względu na kształt gniazda.
(uwaga!!! najlepiej sprawdzić multimetrem napięcie z pinu 5V ponieważ okazuje się że posiadam taśmy które podłącza się odwrotnie) 

Zasada podłączania płytki stykowej z wyświetlaczem do raspberry Pi jest podobna jak w arduino tylko numeracja jest inna.

przewody podłączamy w następujący sposób:

czyli:
główną szynę zasilającą (czerwona linia) podączamy do pinu 1 (5V).
niebieską linię (masa) podłączamy do  pinu 3 GND.
pin 14 (D7) naszego wyświetlacza podłączamy do pinu GPIO18
pin 13 (D6) naszego wyświetlacza podłączamy do pinu GPIO23
pin 12 (D5) naszego wyświetlacza podłączamy do pinu GPIO24
pin 11 (D4) naszego wyświetlacza podłączamy do pinu GPIO25
pin 6 (RW) naszego wyświetlacza podłączamy do pinu 12 oznaczonego CEo
pin 5 (RS) naszego wyświetlacza podłączamy do pinu 13 oznaczonego CE1
reszta pinów jest podłączona w identyczny sposób jak z arduino.
Zwróćcie uwagę aby nie podłączać nic pod piny oznaczone NC ponieważ można spalić RPI!!!

Teraz czas zacząć pisać nasz program.
Potrzebny do tego będzie nam program obsługujący języka python.
Ja korzystam z programu Python shell (IDLE).

Po uruchomieniu programu ukaże na m się okno programu

następnie w  menu File wybieramy New Window (można też skrótem klawiszowym ctrl+N)

program potrzebny do wyświetlania informacji na naszym wyświetlaczu wygląda tak:

#!/usr/bin/python

import RPi.GPIO as GPIO
from time import sleep

class HD44780:

    def __init__(self, pin_rs=7, pin_e=8, pins_db=[25, 24, 23, 18]):
        
        self.pin_rs = pin_rs
        self.pin_e = pin_e
        self.pins_db = pins_db

        GPIO.setmode(GPIO.BCM)
        GPIO.setup(self.pin_e, GPIO.OUT)
        GPIO.setup(self.pin_rs, GPIO.OUT)
        for pin in self.pins_db:
            GPIO.setup(pin, GPIO.OUT)

        self.clear()

    def clear(self):
        """ Reset LCD """
        self.cmd(0x33) 
        self.cmd(0x32) 
        self.cmd(0x28) 
        self.cmd(0x0C) 
        self.cmd(0x06) 
        self.cmd(0x01) 
        
    def cmd(self, bits, char_mode=False):
        """ Command to LCD """

        sleep(0.001)
        bits=bin(bits)[2:].zfill(8)
        
        GPIO.output(self.pin_rs, char_mode)

        for pin in self.pins_db:
            GPIO.output(pin, False)

        for i in range(4):
            if bits[i] == "1":
                GPIO.output(self.pins_db[::-1][i], True)

        GPIO.output(self.pin_e, True)
        GPIO.output(self.pin_e, False)

        for pin in self.pins_db:
            GPIO.output(pin, False)

        for i in range(4,8):
            if bits[i] == "1":
                GPIO.output(self.pins_db[::-1][i-4], True)

        GPIO.output(self.pin_e, True)
        GPIO.output(self.pin_e, False)
        
    def message(self, text):
        """ Send string to LCD """

        for char in text:
            if char == '\n':
                self.cmd(0xC0) # next line
            else:
                self.cmd(ord(char),True)

if __name__ == '__main__':

    lcd = HD44780()

    lcd.message("  ARDUINO & \n raspberry Pi")

następnie zapisujemy program w menu File wybieramy save as podajemy swoją nazwę najlepiej jednowyrazową. W moim przypadku jest to wyswietlacz.py
Jeżeli chodzi o samą zawartość kodu nie będę wyjaśniał ponieważ sam dopiero zaczynam przygodę z RPI.

Po podłączeniu całego układu do naszego klikamy w menu run a następnie run module lub wciskamy F5.

W moim przypadku nie obyło się bez problemów zresztą jak zawsze:

tak jak widać na zdjęciu wyżej odpaliłem program w trybie root i zadziałał.
Jak to zrobić? nic trudnego.
Najpierw otwieramy terminal użytkownika root taka sam ikonka jak od terminala tylko czerwona z symbolem #_.

jak widać użytkownik zmienił się na root@

następnie uruchamiamy nasz program i zadziałał :)

W przypadku gdyby widoczne były same kwadraciki lub nic nie było trzeba wyregulować kontrast potencjometrem.

Na sam koniec chciałbym powiedzieć że od samego początku RPI sprawia mi problemy :) a arduino śmiga tak jak chcę:)