#hd44780

YALI (Yet Another LCD Interface) is an open-source project to provide a universal interface to drive the popular Hitachi HD44780 LCD controller. This module supports 3.3V and 5V MCUs and hardware development platforms, including Arduino, STM32, PIC, and ESP8266.

The hardware module of this project consists of a 74HCT08 CMOS AND gate and a 74HC595 8-bit serial-in, parallel-out shift register. This module uses the MP1540 step-up converter to power the LCD unit connected to the system. The module has the jumper to select 3.3V or 5V DC power input. 

The YALI library is developed using C and is designed to be easily integrated with any C/C++ embedded toolchain. At the initial design stages, this library was successfully tested with all Arduino development boards, NodeMCU, STM32 Blue Pill, etc. The target system must have three digital output lines with 5V or 3.3V logic levels to interface with the YALI module. As mentioned earlier, this module works successfully with 5V or 3.3V power sources and logic levels.

The YALI library provides a unified API to control the HD44780 LCD controller. It has functions to handle cursor control, custom character loading, LCD backlight control, etc.

The PCBWay sponsored this project. PCBWay offers high-quality PCB manufacturing and assembling services. Also, they offer CNC and 3D printing services. The PCB of the YALI module is available to order from PCBWay. Check out the PCBWay website for its manufacturing capabilities and pricing.

The dimensions of the YALI hardware module are 69mm × 21mm. This module is designed using SMD components and can be connected directly to the LCD unit.

This project is an open-source hardware project. All its design files, BOM, schematics, and firmware source codes are available at Github.com. 

Create Custom Characters and Scrolling Text on LCD using Raspberry Pi | Scrolling Text with RPLCD

In this video, you will see how to interfacing an HD44780 based 20x4 alpha numeric LCD with raspberry pi 4, also, we will try to print a string, scroll text, create new custom characters, and a lot more.

When we talk about interfacing displays with microcontrollers for an embedded project, alpha numeric Liquid Crystal Displays (LCD) are the most commonly used displays which are usually based on Hitachi HD44780 Driver. They are low powered, robust LCDs that are capable of displaying various characters in 5X8 or 8X10 pixel matrix. 

Нужно было проверить энное количество железок присланных китайскими товарищами. Точнее все, кроме дисплея ;-)

Çeşitli döngülerle kullanabilirsiniz, CCS C de yazılmıştır ve kullanımı oldukça kolaydır.

Test edildi ve her komutun karışılığında açıklamaları mevcut. 877 piclerde D portuna da bağlanabilir, farklı port için CCS C dosyası içerisindeki LCD.C driver dosyası içerisinde değiştirilmesi gerekir.

Ekler için indirme linki > karakter lcd

Raspberry Pi i wyświetlacz LCD

GPIO (General Purpose Input/Output) jest interfejsem służącym do komunikacji pomiędzy elementami systemu komputerowego. Piny mogą pełnić zarówno rolę wejść, jak i wyjść i jest to zazwyczaj właściwość konfigurowalna.

GPIO to te 16 pinów wystających z Raspberry Pi. Można do nich podpiąć sporo różnych rzeczy. Mogą to być jakieś proste układy, czy kilka diod, lub jak w moim przypadku, niewielki wyświetlacz LCD. Kupić go można w każdym sklepie elektronicznym za około 20 zł. Większość z dostępnych na rynku wyświetlaczy LCD 2x16 znaków jest zgodna ze standardem Hitachi HD44780. Do podłączenia wyświetlacza będzie nam potrzebna płytka stykowa, kilka przewodów oraz potencjometr obrotowy 10KB, ale zamiast niego można użyć również rezystora.

Do obsługi GPIO powstała specjalna biblioteka. RPi.GPIO, bo o niej mowa, została napisana w Pythonie i umożliwia prostą konfigurację, odczyt oraz zapis poprzez interfejs GPIO. Domyślnie jest zainstalowana w nowych wersjach systemu Raspbian. Gdyby jednak z jakiś powodów jej nie było, zawsze można ją pobrać ze strony projektu RPi.GPIO, lub wpisać w terminalu sudo apt-get install python3-rpi.gpio.

Schemat rozłożenia poszczególnych pinów różni się w zależności od modelu RPi. Nowsze (Model A i Model B rev 2) mają drobną różnicę w pinach. W tym miejscu warto wspomnieć o karteczkach z oznaczeniem pinów, które można znaleźć tutaj i wydrukować. W tym przykładzie użyłem tych pinów, które nie uległy zmianie, więc bez znaczenia, który mamy model Raspberry Pi, w każdym przypadku podłączamy wszystko w taki sam sposób.

Oznaczenie pinów na wyświetlaczu LCD:

Vss (source supply) - (Pin nr 1) służy do podłączenia GND (uziemienie).

Vdd (drain supply) - (Pin nr 2) zasilanie +5V.

RS - (Pin nr 4) w zależności od stanu (wysoki, niski) wyświetlacz oczekuje na dane lub instrukcje.

R/W - (Pin nr 5) Dzięki R/W ustalamy kierunek komunikacji(stan wysoki i niski, czyli po prostu ustalamy kierunek przesyłu danych).

E (enable) - (Pin nr 6) podanie impulsu na to wejście powoduje odebranie informacji. Mówiąc kolokwialnie, to taki włącznik.

DB0...DB7 - (Piny nr 7-14)szyna do przesyłu danych.

LED+/LED- - (Piny nr 15 i 16)są to piny zasilające +5V oraz GND wykorzystywane w LCDkach z podświetleniem.

Gdy nasz wyświetlacz jest podpięty, nie pozostaje nam nic innego jak napisanie prostego programu w Pythonie, który będzie go obsługiwał i pozwalał nam wyświetlać różne informacje. Postanowiłem zacząć od czegoś prostego, czyli wyświetlania tekstu. Możemy oczywiście rozbudować program i dopisać do niego wiele różnych rzeczy, np. obsługę serwisu pogodowego i wyświetlać sobie obecną temperaturę, lub podawać aktualną godzinę w różnych strefach czasowych.

Na początku programu definiujemy z których pinów będziemy korzystać(pin_rs=7, pin_e=8, pins_db=25, 24, 23, 18). Następnie sprawdzamy czy wyświetlacz działa i "czyścimy ekran". Później określamy jego wielkość, czyli zaznaczamy ile mamy znaków i wierszy, w których możemy wyświetlać tekst. Na sam koniec podajemy to co chcemy wyświetlić.

#!/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(" MalinowePi.pl\n @MalinowePi")

Program możecie skopiować i wkleić w terminalu(nano Nazwa.py), a następnie uruchomić poleceniem sudo Python Nazwa.py.

So job one. Display some data without being connected to an LCD monitor.

Hardware:

Here are the parts that I've used. The job could be done without a few of them but I've added them for convenience or because they were part of a previous project and I didn't want to disassemble them...

Raspberry Pi

LCD Display (HD44780 controller type, 2 line, 16 character)

Translucent blue project box

Chocolate block electrical connector

RS232 (null modem) cable

RS232 female PCB mount and breakout board

PCB Header pins

PCB mount potentiometer (pretty much any size you like over 10k)

PCB AA battery holder (capacity 3) and 3 AA batteries

Small breadboard

Loads of male-female jumper wire

The LCD display I had already assembled from a previous Arduino project so there are no photos of that part of the build. It was wired according to this tutorial on the Arduino site. I added an extra connection to have the LCD backlight permanently on (5v to pin 15, pin 16 to ground). If I were doing it over again I'd perhaps add another pot to adjust the backlight or wire it in to the RS232 cable to control the backlight from the Pi.

All the wires from the LCD I fed into the choccy block connector, this way when I connect them to the RS232 cable I can choose a somewhat logical order for the pins as they are laid out on the breakout board.

Here is the assembled LCD display, in it's box with the RS232 cable attached. I drilled a hole in the cover for access to the contrast pot but once it's set it almost never needs adjusting.

The datasheet for the display says it is a 5v device, but I wasn't happy about using the 5v supply from the Pi as the display could draw more current than is recommended through the GPIO pins. Instead I use 3 AA batteries to power the display, so it's happy with 4.5v rather than 5, and only connect the RS (Register Select), E (Read/Write Enable strobe), and Data Bus pins to the Pi (as well as a connection to ground to complete the circuit). The Pi GPIO output is 3.3v and the display seems happy with this too which is good as it means I didn't have to mess about with level shifting.

The way I connected it up left the RS232 breakout board outputs as follows.

When it's ready to go in the car, the breakout board will be fixed into the Pi main box and the display will plug in from outside, this way the display can be shared around other projects as needed (like it is now) cutting down the expense of future endeavours.

Software:

After confirming the display was working by plugging in to an old Arduino project, the next job was to drive the thing from the Pi. Thankfully a couple of folks have already done the heavy lifting here. Gordon @ Drogon has created WiringPi, an Arduino compatible wiring library for the Raspberry Pi and marcoster has ported the LiquidCrystal library referenced in the tutorial link above. Double win!

After git cloning the marcoster code all I needed to do was make a few alterations to his main.c file around line 76-77

LiquidCrystal lcd(0, 4, 1, 21, 22, 23, 24); lcd.begin(20, 4);

In the original, a 4-line, 20-character display is used. I'm only using a 2-line, 16-character display and I've used different GPIO pins (for no reason other than personal preference). After alteration, my code, same line numbers...

LiquidCrystal lcd(24, 23, 4, 17, 21, 22); lcd.begin(16, 2);

The first 2 pin numbers are the RS and E connections to the LCD, the next 4 pins are the Data Bus connections (DB4-DB7 on the breakout board).

The pin numbers are using the BCM system, they are equivalent to GPIO 5,4,7,0,2,3 or header pins 18,16,7,11,13,15.

Other changes to main.c, removed lines 82-84 because the are writing to display lines which I don't have and changed the setCursor call on line 90 from (0,3) to (0,1) so the next write will start at character 0 on display line 1.

Compile the libraries, then the main program and we're ready to test.

g++ wiringPi.c -c

g++ LiquidCrystal.cpp -c

g++ Print.cpp -c

g++ main.c -c

g++ main.o LiquidCrystal.o wiringPi.o Print.o -o lcd_test

Wire-up:

Connect up the Pi, breadboard and breakout board. I could wire the breakout board direct to the Pi with female-female jumpers but I'm moving the display between projects and doing it this way means when I come to re-wire it all I need to do is match up the colours rather than refer to the code to remind myself what pins I specified. Remember to connect the ground pins of the Pi and the battery pack.

Fire-up:

Plug in the LCD and run the application, need to sudo the command so the app has rights to access the GPIO.

sudo ./lcd_test

Ouput success. Next up, input.

Useful links (I am not affiliated with any of the following)

WiringPi at drogon.net

marcoster RPi LCD Library