6 számjegyes LCD kijelző

Először egy kis elmélet és múltidézés. Az LCD kijelzők sok évtizedes múlttal rendelkeznek. Az első kvarcórámat 35 évvel ez előtt vásároltam a Keleti Pályaudvar mellett a Baross szobornál. Akkoriban ez volt a paradicsom, ott árulták feketén ezeket a cuccokat! Azóta a szobrot kicsit arrébb helyezték. Ha jól emlékszem 1200Ft volt, évekig spóroltam rá. Hét zenés óra volt, én lettem a legnépszerűbb a gimiben egy hétre. Sorban hallgatták az osztálytársak a pity-pity zenét, így egy hét alatt lemerült az első elem. Egyébként legalább egy évig működött elemcsere nélkül. El sem tudtuk képzelni, hogy azzal az 5mm átmérőjű gombelemmel hogyan működhet az óra ennyi ideig (ha kikapcsolom a pity-pity-et). Ma már tudom, hogy a trükk a kis fogyasztású folyadékkristályos kijelző. A kijelző előlapja üveg és átlátszó, a hátlapja pedig ezüst színű fényvisszaverő anyag. A beeső fényt a hátlap visszaveri és polarizálja. A polarizált fényt pedig kitakarják a két réteg közé „öntött” leheletvékony folyadékkristály rétegben 90 fokban beforduló hosszú molekulák. Nyilván ezek a molekulák csak akkor fordulnak el 90 fokkal, ha feszültséget kapcsolunk rá. Működés közben nem folyik áram, így a kijelző gyakorlatilag nulla fogyasztású. Persze a vezérlő chip azért fogyaszt. Hátrány, hogy a molekulák lassan állnak be a vezérlő feszültség hatására, így videófilmet nem fogunk ezen a kijelzőn nézni. Nagy hidegben látni a szegmensek átkapcsolását, mert nem akar eltűnni a kikapcsolt szegmens. De ettől még igen sok mindenre használható típus.

Vásároltam is egy háttér világításos, 6 karakteres LCD kijelzőt.

A képen áramkör, elektronika látható

Automatikusan generált leírás

Forrás: https://www.aliexpress.com/item/32944755027.html?spm=a2g0s.9042311.0.0.27424c4dJP2WTf

Bekapcsolt világítással 4mA az áramfelvétele. Elemmel működő eszközökhöz lesz tökéletes. Egyelőre még csak kísérletezgetek vele. Kipróbáltam, és az Arduino Uno 3,3V tápfeszültségről is tökéletesen működik. Tehát várhatóan 2 ceruza elemről lehet majd táplálni a kütyüt. Talán a három elem jobb, mert az ATmega328 2.7V feszültségig üzemel, és 2.7V-ra gyorsan lemerülhet két ceruzaelem. Ilyenkor még elég sok energia van bennük, pazarlás lenne. Terveim szerint egy konyhai időzítő fog elkészülni belőle, amit elemmel szeretnék táplálni. A kapható konyhai időzítők körülményesek. A legtöbb típuson 2-3 nyomógomb is van, és az időzítési idő beállítása és elindítása egy csomó gombnyomogatás. Nehezen találtam olyat, ahol egy forgatógombbal lehet beállítani az időt, és egy gombnyomással elindítani az időzítést. Amit megvettem, azon meg a gomb forgatása 15 másodperces lépésekben állítja az időt. Nekem ez feleslegesnek tűnik. Kit érdekel, hogy a tojás 10 percig, vagy 10 perc 15 másodpercig fő. Úgy gondolom tudok jobbat, egyszerűbbet csinálni!

A kijelző problémás, mert állandóan be van kapcsolva a világítás. Szerencsére egy forrasztással és ónlehúzással megoldható a probléma. Így néz ki a hátoldala:

Beszédbuborék: lekerekített sarkú téglalap: Leszedni az ónt, vagy elvágni a vezetéket

Ezt követően már a LED+ feliratú kivezetésnek kell tápot adni pl. az Arduino egyik kimenetéről. Az áramör 5V-ra van optimalizálva, vagyis 3V feszültségen lényegesen halványabb a háttér világítás. A fényerő a 100ohm-os soros ellenállás csökkentésével növelhető. Egyedileg kell kipróbálni, szerintem egy 150ohm körüli ellenállást érdemes párhuzamosan forrasztani.

A kijelző működése:
Lényegében egy SPI kommunikációs megoldással tudjuk a kijelzőt vezérelni. A WR bemenet az órajel, a Data az adatvezeték, a CS meg a chip select. A kijelző alatt egy HT1621-es LCD megható áramkör található, ami egy általános LCD meghajtó áramkör család egyik tagja. Van benne egy memória, amiben minden egyes vezérelhető szegmensnek található egy bit. Ha a bit 1, akkor elsötétedik a szegmens, ha meg 0 akkor nem. Ennyire egyszerű. Van tehát parancs, amivel ez a memória írható és olvasható is, és vannak az IC egyéb beállításainak megváltoztatására szolgáló parancsok. Ezek közül néhányat kiemelnék. Az IC képes egy kis hangszóró (buzzer) közvetlen meghajtására. Jelen áramkörben ezt nem vezették ki sajnos, erről a lehetőségről le kell mondanunk. Lehetőség van a szegmens elsötétedését befolyásoló előfeszítő feszültség megváltoztatására. Ha ½ bias értéket állítunk be, akkor sötétebb a bekapcsolt szegmens, de ekkor már azok a szegmensek is szürkék lesznek, melyeknek nem lenne szabad látszaniuk. Ráadásul ha nem szemből nézzük, akkor minden szegmens fekete, és nem látható jól a kijelzett érték. Így én a demó programban beállított alapértelmezett értéknél maradtam. A kijelző egyetlen paranccsal ki és bekapcsolható, azaz kikapcsoláskor eltűnik a kijelzett érték, de a memóriában megmarad. A szegmenseket időszeletekben vezérli, mivel kijelező mátrix rendszerű a működés. Ehhez órajel kell, és többféle órajelet is tud használni a chip, belsőt külsőt egyaránt. Sajnos nem nagyon értem, erre mi szükség lehet, de biztosan oka van. Annak is biztosan oka van, hogy egy watcdog áramkört is beépítettek. Ezt sem értem, hogy mire jó, de átléptem rajta, mert nekem nem kellett! A második táblázat tartalmazza ennek beállítási lehetőségeit.

A részletek iránt érdeklődőknek íme a parancsokat tartalmazó adatlap részlet:

Jelmagyarázat:
X             dont care (bármi lehet)
A5-A0     RAM adress
D3-D4    RAM data
D/C         Data/Command mód
def.         bekapcsoláskor a gyári alapértelmezés

Ebből a halmazból én mindössze kettőt találtam hasznosnak:

LCD kijelzés be és kikapcsolása:
LCD off: 10000000010X
LCD on: 10000000011X

Bias beállítás (a common opció esetünkben nem érdekes, mert a konkrét LCD panel meghajtásához a 4 commons mód szükséges.
BIAS&COM: 1000010abXcX
c=0         1/2 bias
c=1         1/3 bias
ab=00    2 commons option
ab=01    3 commons option
ab=10    4 commons option

Még talán a memória térkép lehet érdekes:

https://www.14core.com/wp-content/uploads/2017/04/7-Segment-6-Digit-LCD-Display-Module-HT621-LCD-Spi-Display-14core-02.jpg

Található hozzá függvény könyvtár több is. Nekem azonban az volt a célom, hogy szegmensenként tudjam vezérelni, így nem volt hasznos egy olyan függvény, ami ki tud írni a kijelzőre egy max. 6 jegyű számot. Ezért a vezérlését az egyik forráskódból visszafejtettem, és magam írtam meg a saját vezérlő függvényeimet. Nagy munka nem kellett hozzá, szinte csak másolgatni kellett. Minimális kommenteket is írtam a programba. A program a setup részben felvillant egy 0-át jobbról az első karakter pozícióban, majd sorban felvillantja az összes karakter minden szegmensét jobbról balra haladva. A működéséből látható, hogy az utolsó három számjegyhez már nem tartozik tizedespont, ezek a jobb felső sarokban látható elem feszültség jelző szimbólumhoz lettek kivezetve. Hasznos lesz, ha az áramkör méri az elem feszültségét és így ki tudjuk jelezni, ha már cserélni kell. Ebből persze az is következik, hogy maximum 3 tizedesjegy pontossággal tudunk számértéket kijelezni. pl. az 1.235 még megy, a 3.5443már nem!

#define CS   13  //Pin 13 lesz a kijelző chip select bementére kötve 
#define WR   12  //Pin 12 lesz a kijelző órajel bemenetére kötve
#define DATA 7  //Pin 7 lesz a kijelző data bemenetére kötve

//HT1621 parancsok
#define  ComMode    0x52  //b01010010  //Ez a jó kijelzés, csak a világító szegmens látszik a kikapcsoltak nem
//#define  ComMode    0x50  //b01010000 //Erősebben világítanak a szegmensek, de oldalról mind látszik, a kikapcsolt is
#define  RCosc      0x30  //b00110000  
#define  LCD_on     0x06  //b00000110  //Bekapcsolja az LCD bias generátort
#define  LCD_off    0x04  //b00000100  //Kikapcsolja az LCD bias generátort
#define  Sys_en     0x02  //b00000010  //Bekapcsolaj a rendszer oszcillátort
#define  CTRl_cmd   0x80  //b10000000
#define  Data_cmd   0xa0  //b10100000

/************* Az egyes karakterek megjelenítéséhez ezeket a kódokat kell kiküldeni a chip-nek*****/
const char num[]={0x7D,0x60,0x3E,0x7A,0x63,0x5B,0x5F,0x70,0x7F,0x7B,0x77,0x4F,0x1D,0x0E,0x6E,0x1F,0x17,0x67,0x47,0x0D,0x46,0x75,0x37,0x06,0x0F,0x6D,0x02,0x00,};
                 //0    1    2    3    4    5    6    7    8    9    10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27
                 //0    1    2    3    4    5    6    7    8    9    A    b    C    c    d    E    F    H    h    L    n    N    o    P    r    t    U    -   " "/

void setup() {
  Serial.begin(9600);
  pinMode(CS, OUTPUT);   
  pinMode(WR, OUTPUT); 
  pinMode(DATA, OUTPUT); 
  digitalWrite(CS, HIGH);
  digitalWrite(DATA,HIGH);
  digitalWrite(WR,HIGH);
  delay(50);
  //led meghajtó inicializálás
  SendCmd_1621(Sys_en);
  SendCmd_1621(RCosc);    
  SendCmd_1621(ComMode);  
  SendCmd_1621(LCD_on);

  HT1621_clear();   
  HT1621_Write(0,num[0]);  //0 szám a 1. pozicióban
  delay(1000);
  HT1621_clear();
  HT1621_Write(1,255);  //összes szegmens bekapcs. a 2. pozicióban
  delay(1000);
  HT1621_clear();
  HT1621_Write(2,255);  //összes szegmens bekapcs. a 3. pozicióban
  delay(1000);
  HT1621_clear();
  HT1621_Write(3,255);  //összes szegmens bekapcs. a 4. pozicióban
  delay(1000);
  HT1621_clear();
  HT1621_Write(4,255);  //összes szegmens bekapcs. a 5. pozicióban
  delay(1000);
  HT1621_clear();
  HT1621_Write(5,255);  //összes szegmens bekapcs. a 6. pozicióban
  delay(1000);
  HT1621_clear();
 
}

void loop() {
}



void HT1621_Write(byte addr,byte sdata)
/***************************************************************************************
kiírunk egy adatot a kijelző megadott segmensére
az addr vátozó mindíg a digit indexének kétszerese. pl. 0. digit 0, 1, digit 2 stb.
sdata a kijelzésre kerülő karakterkép, 
a byte bitjeinek jelentése:
   **5**
   1   6
   **2**
   3   7
 8 **4**
****************************************************************************************/ 
  addr=addr+addr;
  addr<<=2; 
  digitalWrite(CS, LOW); 
  SendBit_1621(0xa0,3);  //command kód 101     
  SendBit_1621(addr,6);  //memori adres (egy címen 4bit-et lehet írni, így egy digit két címen található a ram-ban    
  SendBit_1621(sdata,8); //segmens világit nam világít infó, bitenként egy szegmes vezérlés  (egy kezdőcímtől lehet egyszerre 2x4bitet kiírni)
  digitalWrite(CS, HIGH); 
} 


void HT1621_clear() 
{
  byte i; 
  for(i=0;i<6;i++) 
  { 
    HT1621_Write(i,0x00); 
  } 
}


void SendBit_1621(byte sdata,byte bitszam)
/*******bitenként kiléptet sdata változó tartalmából a bitszam változóban megadott bitet********/
{ 
  byte i; 
  for(i=0;i<bitszam;i++) 
  { 
    digitalWrite(WR, LOW); //alacsonyra ejtjük a WR bemnetet
    if(sdata&0x80) digitalWrite(DATA,HIGH); //ha balról az első bit 1, akkor DATA =1
    else digitalWrite(DATA,LOW); 
    digitalWrite(WR,HIGH);  //felfutó és a WR bemeneten, ennek hatására olvassa be Data bemenetet a chip
    sdata<<=1; //léptetünk balra egyet
  } 
}


void SendCmd_1621(byte command) 
/*************parancsot küldünk a kijelző csipnek****************/
{ 
  digitalWrite(CS, LOW); 
  SendBit_1621(0x80,4);  //a kijelzőnek egy parancs "100"-al kezdődik, plusz még kell egy "0"
  SendBit_1621(command,8); //most jön a konkrét command
  digitalWrite(CS, HIGH);                     
}

A teljesség kedvéért beidézek egy példa programot, ami 0-tól 999.999-ig számol. A program megmutatja, hogy ez a kijelző nem olyan lassú, mint az én első kvarcz órám kijelzője. Teker rendesen! Figyelem: a kivezetések máshová lettek kötve az Arduino-n mint az előző programban. Ez a program már kezeli a háttér világítást is, ha előtte megcsináltuk a forrasztgatós átalakítást! Ha jól emlékszem ebből a könyvtárból emeltem ki az előző program függvényeinek forrását.

/*
  Hello World!
  Displays the milliseconds passed since power on.
  Using an HT1621 based 7-segment LCD with 6 digits
  The circuit:
  cs to pin 13
  wr to pin 12
  Data to pin 8
  backlight to pin 10
  Created 9 dec 2018
  By valerio\new (5N44P)

  https://github.com/5N44P/ht1621-7-seg
*/

#include <HT1621.h> // include our library


HT1621 lcd; // create an "lcd" object


void setup(){
  // start the lcd:
  // cs to pin 13
  // wr to pin 12
  // Data to pin 8
  // backlight to pin 10
  // you can chose whichever pin you want



  lcd.begin(13, 12, 8, 10); // (cs, wr, Data, backlight)
  // if no backlight control is given, you can also use:
  // lcd.begin(13, 12, 8); // (cs, wr, Data)

  lcd.noBacklight(); // turn on the backlight led

  lcd.clear(); // clear the screen
}

void loop(){
  lcd.print(millis()/1000.0, 3); // print the floating point seconds value with 3 decimal digits precision
  delay(1); // wait 1 millisecond
}

Mennyire volt hasznos amit olvastál?

Kattints egy csillagra az értékeléshez!

Sajnálom, hogy amit olvastál nem volt hasznos számodra!

Szeretném ha elégedett lennél!

Írd le kérlek, hogy mi nem tetszett!?