Sterowanie Wskaĺşnikami Lcd - Sterownik.pdf - MIKROKONTROLERY2 - cathal30

S P R Z Ę T

Sterowanie wskaźnikami

ciekłokrystalicznymi

Sterownik wyświetlacza graficznego

W†drugiej czÍúci artyku³u

poúwiÍconego wyúwietlaczom LCD

omawiamy zagadnienia zwi¹zane

ze sterowaniem wyúwietlaczy

graficznych. Ze wzglÍdu na

znaczn¹ objÍtoúÊ artyku³u, jego

dokoÒczenie przedstawimy za

miesi¹c.

W†drugiej czÍúci artyku³u o†wskaünikach

ciek³okrystalicznych zajmiemy siÍ obs³ug¹

graficznych. Wyúwietlacze graficzne sk³adaj¹

siÍ z†dwuwymiarowej matrycy punktÛw, ktÛ-

re indywidualnie sterowane umoøliwiaj¹ wy-

úwietlanie nie tylko kilku lub kilkunastu

wierszy tekstu, ale rÛwnieø obrazÛw graficz-

nych. Nowoczesne modu³y graficzne dorÛw-

nuj¹ rozdzielczoúci¹ kartom graficznym typu

SVGA i†15" monitorom kolorowym. Do za-

stosowaÒ kontrolno-pomiarowych w†zupe³-

noúci wystarcz¹ ma³e jednokolorowe

wyúwietlacze o†rozdzielczoúci rzÍdu 100x100

punktÛw.

Istotn¹, praktyczn¹ wad¹ dostÍpnych mo-

du³Ûw wyúwietlaczy jest koniecznoúÊ sto-

sowania skomplikowanych uk³adÛw steru-

j¹cych. Obraz na wyúwietlaczu ciek³okrys-

talicznym, przechowywany w†pamiÍci

obrazu RAM, podobnie jak w†zwyk³ym mo-

nitorze komputerowym generowany jest li-

niami. W†zaleønoúci od konstrukcji wyúwie-

tlacza moøliwe jest jednoczesne odúwieøa-

nie kilku sekcji ekranu. Niestety producenci

wyúwietlaczy graficznych stosuj¹ indywi-

dualne specyfikacje do swoich produktÛw,

co wiÍcej, informacje te przynajmniej do

niedawna by³y skrzÍtnie ukrywane, co nie

u³atwia³o indywidualnym konstruktorom

øycia.

Obecnie dostÍpne s¹ na rynku dwie kategorie

modu³Ûw: sterowane szeregowo i†z†zintegrowa-

n¹ elektronik¹. Modu³y sterowane szeregowo

s¹ znacznie taÒsze, ale - jak wczeúniej wspo-

mniano - wymagaj¹ zewnÍtrznych uk³adÛw ste-

ruj¹cych. Do szybkich zastosowaÒ, w†ocenie

pisz¹cego te s³owa, nadaj¹ siÍ jedynie wskaü-

niki zintegrowane z†elektronik¹ steruj¹c¹.

W†sk³ad uk³adu steruj¹cego wyúwie-tlaczem

wchodzi kontroler, sterowniki linii i†kolumn

samej matrycy graficznej oraz pamiÍÊ RAM

ekranu. Jako kontroler zintegrowanych ste-

rownikÛw najczÍúciej stosuje siÍ uk³ad

HD61830B (lub zgodny) firmy Hitachi. Do-

stÍpne s¹ rÛwnieø inne interesuj¹ce

uk³ady jak na przyk³ad HD63645, ktÛ-

ry ca³kowicie emuluje MC6845, czyli

klasyczny sterownik terminali alfanu-

merycznych i†graficznych.

W†dalszej czÍúci opracowania

przedstawiony zostanie sposÛb ob-

s³ugi sterownika wyúwietlacza

LMG6400PLGR firmy Hitachi.

Wyúwietlacze z†serii LMG640X

posiadaj¹ zintegrowany sterownik

HD61830B i†umoøliwiaj¹ wyúwietla-

nie w†trybie tekstowym do 40 zna-

kÛw w†16 wierszach lub jednokolo-

rowej grafiki o†rozdzielczoúci 240 na

128 punktÛw. WewnÍtrzny genera-

tor znakÛw umoøliwia wyúwietlanie

do 160 glifÛw na matrycy 5x7 lub

32 na matrycy 5x11. Generator zna-

kÛw jest zgodny z†ASCII (ISO646).

Znaki o†kodach powyøej 128, podobnie jak

w†przypadku kontrolera HD44780, zawiera-

j¹ wybÛr glifÛw Kata-kana i†greckich. Ste-

rownik wyúwietlacza LMG640X posiada

rÛwnieø zintegrowan¹ pamiÍÊ RAM

o†pojemnoúci 8kB. Ca³y modu³ ma wymiary

159x101x9,5mm z†ekranem 126x71mm

i†kwadratowym punktem o†rozmiarze

0,47mm.

Wyúwietlacz oprÛcz sygna³Ûw steruj¹cych

wymaga dwu napiÍÊ zasilaj¹cych oraz na-

piÍcia steruj¹cego kontrastem. Do zasilania

czÍúci cyfrowej wyúwietlacza stosuje siÍ na-

piÍcie +5V, natomiast do zasilania matrycy

LCD wymagane jest sta³e napiÍcie -15V.

NapiÍcie steruj¹ce kontrastem uzyskuje siÍ

z†suwaka potencjometru o†wartoúci

10..20k

. SposÛb pod³¹czenia napiÍÊ zasi-

laj¹cych wyúwietlacz i†potencjometru kon-

trastu przedstawiony jest na rys. 1 .

W†przypadku sterowania wskaünikiem

z†p³yty g³Ûwnej komputera PC uzyskanie

napiÍcia -15V nie jest wprost moøliwe. Prze-

prowadzone prÛby pokaza³y jednak, øe

wyúwietlacz dzia³a poprawnie, gdy polary-

zuje siÍ go dostÍpnym z†zasilacza napiÍ-

ciem -12V. Sygna³y steruj¹ce sterownikiem

wyú-wietlacza LMG640X wyprowadzone s¹

na 20-stykowe z³¹cze, do ktÛrego moøna

podlutowaÊ pojedyncz¹ szynÍ z†ko³kami

Berga i†z³¹czem do kabla wstÍgowego.

Interfejs uk³adu HD61830B

Podobnie jak w†przypadku wczeúniej opi-

sywanego uk³adu HD44780, interfejs uk³adu

HD61830B przeznaczony jest do bezpoúred-

niej wspÛ³pracy z†szyn¹ procesorÛw 6502/

6800. Podobne s¹ wiÍc sekwencje sygna³Ûw

steruj¹cych. Procedura zapisu do uk³adu

HD61830 rozpoczyna siÍ od ustawienia linii

RS (RS=1, dane lub RS=0, rozkaz) i†linii R/

W (R/W=0, zapis lub RW=1, odczyt).

Kaødy cykl rozpoczyna siÍ rosn¹cym zbo-

czem sygna³u zezwalaj¹cego E. Dane do re-

jestru wewnÍtrznego wpisywane s¹ zboczem

opadaj¹cym E. Podobnie cykl odczytu inicjo-

wany jest ustawieniem linii RS i†R/W, a†sam

odczyt dokonywany jest w†czasie aktywnoúci

linii E. Wyúwietlacz LMG640X, oprÛcz przed-

stawionych sygna³Ûw RS, RW i†E, dodatkowo

posiada wejúcie wybieraj¹ce CS (CS=0: uk³ad

aktywny, CS=1: uk³ad nieaktywny) oraz sygna³

zerowania RES (RES=0 - zerowanie kontrolera,

RES=1 - wk³ad pracuje). Podobnie jak w†przy-

padku kontrolera HD44780 obowi¹zuj¹ ogra-

niczenia dynamiczne cyklÛw dostÍpu. Sygna³y

CS, RS i†RW musz¹ byÊ stabilne na co naj-

mniej 140ns przed pojawieniem siÍ rosn¹cego

zbocza E. Czas trwania aktywnoúci sygna³u

E†nie moøe byÊ krÛtszy niø 450ns, a†ca³y cykl

zapisu lub odczytu musi trwaÊ co najmniej

Rys. 1.

Elektronika Praktyczna 10/99

Przebiegi czasowe cyklÛw zapisu i†odczy-

tu przedstawione na rys. 2† i 3 realizowane

S P R Z Ę T

Listing 1. Kod źródłowy biblioteki HD61830.h

/*********************************************************

* HD61830.h

* biblioteka obsługi HD61830 za pośrednictwem PPI 8255

* wykorzystywane linie 8255:

* PA7 PA6 PA5 PA4 PA3 PA2 PA1 PA0 tryb 2 dwukierunkowy

* D7 D6 D5 D4 D3 D2 D1 D0

* PB7 PB6 PB5 PB4 PB3 PB2 PB1 PB0 tryb 0 wyjście

* x x x res cs rs rw e

* PC7 PC6 PC5 PC4 PC3 PC2 PC1 PC0 (*) zarezerwowane

* * * * * * x x x

* (c) Janusz J. Młodzianowski

*********************************************************/

#include <dos.h>

#include <stdlib.h>

#include <stdio.h>

/* konfiguracja 8255 */

#define BASE 0x300

#define PORTA BASE

#define PORTB BASE+1

#define PORTC BASE+2

#define PORTR BASE+3

#define MODE8255 0xC9

/* sterowanie interfejsem HD61830*/

#define LCGRESET

0x0c

/* res=0 */

lcgwait();

outportb(PORTB,LCGDATA|LCGWR|LCGDIS);

outportb(PORTB,LCGDATA|LCGWR|LCGEN);

outportb(PORTA,value);

delay(EDELY);

outportb(PORTB,LCGDATA|LCGWR|LCGDIS);

}

/******************************************************

* cykl odczytu pamięci VRAM

******************************************************/

char lcgin(void)

{

char tmp;

lcgwait();

outportb(PORTB,LCGCMD|LCGWR|LCGDIS);

outportb(PORTB,LCGCMD|LCGWR|LCGEN);

outportb(PORTA,LCGRDATA);

delay(EDELY);

outportb(PORTB,LCGCMD|LCGWR|LCGDIS);

lcgwait();

outportb(PORTB,LCGDATA|LCGRD|LCGDIS);

outportb(PORTB,LCGDATA|LCGRD|LCGEN);

delay(EDELY);

tmp=inportb(PORTA);

outportb(PORTB,LCGDATA|LCGRD|LCGDIS);

return(tmp);

}

/*********************************************************

* inicjacja trybu tekstowego

*********************************************************/

void lcgtext(void)

{

outportb(PORTR,MODE8255); /* ustawienie 8255*/

outportb(PORTB,LCGRESET); /* reset kontrolera */

delay(10);

outportb(PORTB,LCGCMD|LCGWR|LCGDIS);

lcgout(SETLCGMODE,0x3c);

#define LCGDATA

0x10

/* rs=0 */

#define LCGCMD

0x14

/* rs=1 */

#define LCGRD

0x12

/* rw=1 */

#define LCGWR

0x10

/* rw=0 */

#define LCGEN

0x11

/* e=1 */

#define LCGDIS

0x10

/* e=0 */

#define EDELY 1

/* min 540ns */

/* rozkazy HD61830 */

#define SETLCGMODE 0x00

#define SETCHPITCH 0x01

#define SETCHARNUM 0x02

#define SETTIMEDIVS 0x03

#define SETCURSPOS 0x04

#define SETHOMLADDR 0x08

#define SETHOMHADDR 0x09

#define SETCURLADDR 0x0a

#define SETCURHADDR 0x0b

#define LCGWRDATA 0x0c

#define LCGRDATA 0x0d

#define LCGCLEARBIT 0x0e

#define LCGSETBIT 0x0f

/* parametry trybu tekstowego */

#define CURSORON

/* tryb tekstowy*/

lcgout(SETCHPITCH,0x75);

/* 40 znaków/wiersz*/

lcgout(SETTIMEDIVS,127);

/* cykl wypełnienia*/

lcgout(SETCURSPOS,7);

/* położenie kursora*/

lcgout(SETHOMLADDR,0);

/* adres HOME */

lcgout(SETHOMHADDR,0);

lcgout(SETCURLADDR,0);

/* kursor w HOME*/

lcgout(SETCURHADDR,0);

lcgtxtcls();

}

/*********************************************************

* inicjacja trybu graficznego

*********************************************************/

void lcdgraph(void)

{

int i;

outportb(PORTR,MODE8255); /* ustawienie 8255*/

outportb(PORTB,LCGRESET); /* reset kontrolera*/

delay(10);

outportb(PORTB,LCGCMD|LCGWR);

lcgout(SETLCGMODE,0x32);

#define BLINK

0x14

#define DISPON

0x30

#define MODEGRAPH

0x12

/* prototypy funkcji */

void lcgwait(void);

void lcgout(int where, int value);

char lcgin(void);

void lcgtext(void);

void lcdgraph(void);

void lcgtxtcls(void);

void lcggraphcls(void);

void lcggotoxy(int x,int y);

void lcgputc(char c);

void lcgputs(char *s);

void lcgline(int x1,int y1,int x2,int y2,int c);

void lcgrectangle(int x1,int y1,int x2,int y2,int c);

void lcgellipse(int xc,int yc,int a0,int b0,int c);

void lcgcircle(int x,int y,int r,int c);

/******************************************************

* oczekiwanie na zwolnienie kontrolera

******************************************************/

void lcgwait(void)

{

char busy;

outportb(PORTB,LCGCMD|LCGRD|LCGDIS);

do{

outportb(PORTB,LCGCMD|LCGRD|LCGEN);

delay(EDELY);

busy=inportb(PORTA)&0x80;

outportb(PORTB,LCGCMD|LCGRD|LCGDIS);

delay(EDELY);

}while(busy);

}

/******************************************************

* cykl zapisu

******************************************************/

void lcgout(int where, int value)

{

lcgwait();

outportb(PORTB,LCGCMD|LCGWR|LCGDIS);

outportb(PORTB,LCGCMD|LCGWR|LCGEN);

outportb(PORTA,where);

delay(EDELY);

outportb(PORTB,LCGCMD|LCGWR|LCGDIS);

/* tryb graficzny*/

lcgout(SETCHPITCH,0x77);

/* 8 punktów z bajtu*/

lcgout(SETTIMEDIVS,127);

/* cykl wypełnienia*/

lcgout(SETHOMLADDR,0);

/* adres HOME*/

lcgout(SETHOMHADDR,0);

lcgout(SETCURLADDR,0);

/* kursor w HOME*/

lcgout(SETCURHADDR,0);

lcggraphcls();

}

/*********************************************************

* kasowanie ekranu tekstowego

*********************************************************/

void lcgtxtcls(void)

{

int i;

lcgout(SETCURLADDR,0);

/* HOME*/

lcgout(SETCURHADDR,0);

for(i=0;i<16*40;i++) lcgout(LCGWRDATA,0);

lcgout(SETCURLADDR,0);

/* HOME*/

lcgout(SETCURHADDR,0);

}

/*********************************************************

* kasowanie ekranu graficznego

*********************************************************/

void lcggraphcls(void)

{

int i;

lcgout(SETCURLADDR,0);

/* HOME*/

lcgout(SETCURHADDR,0);

for(i=0;i<240*128/8;i++) lcgout(LCGWRDATA,0);

lcgout(SETCURLADDR,0);

lcgout(SETCURHADDR,0);

}

/*********************************************************

* ustawienie kursora tekstowego w x,y

/* HOME*/

Elektronika Praktyczna 10/99

lcgout(SETCHARNUM,39);

/* znak 5x7*/

0x18

lcgout(SETCHARNUM,29);

/* 30 bajtów/linia*/

S P R Z Ę T

*********************************************************/

void lcggotoxy(int x,int y)

{

int n=40*y+x;

lcgout(SETCURLADDR,n&0xff);

lcgout(SETCURHADDR,n>>8);

}

/*********************************************************

* zapisanie znaku na ekran tekstowy

*********************************************************/

void lcgputc(char c)

{

lcgout(LCGWRDATA,c);

}

/*********************************************************

* zapis ciągu znaków na ekran tekstowy

*********************************************************/

void lcgputs(char *s)

{

while(*s) lcgout(LCGWRDATA,*s++);

}

/*********************************************************

* ustawianie/kasowanie punktu na ekranie graficznym

*********************************************************/

void lcgpixel(int x,int y,int c)

{

int loc;

char pixel;

loc=(y*240+x)/8;

/* adres w VRAM*/

pixel=(y*240+x)%8; /* numer bitu*/

lcgout(SETCURLADDR,loc&0xff); /* ustawienie kursora*/

lcgout(SETCURHADDR,loc>>8);

if(c==0)

lcgout(LCGCLEARBIT,pixel);

else

lcgout(LCGSETBIT,pixel);

}

/*********************************************************

* rysowanie linii, algorytm Bresenham'a

*********************************************************/

void lcgline(int x1,int y1,int x2,int y2,int c)

{

int d,dx,dy;

int ainc,binc,yinc;

int x,y;

/*********************************************************

* rysowanie prostokąta

*********************************************************/

void lcgrectangle(int x1,int y1,int x2,int y2,int c)

{

lcgline(x1,y1,x2,y1,c);

lcgline(x1,y2,x2,y2,c);

lcgline(x1,y1,x1,y2,c);

lcgline(x2,y1,x2,y2,c);

}

/*********************************************************

* funkcja pomocnicza grafiki

*********************************************************/

void swap(int *a,int *b)

{

int c;

c=*a;

*a=*b;

*b=c;

}

/*********************************************************

* funkcja pomocnicza grafiki

*********************************************************/

void lcg4pixels(int x,int y,int xc,int yc,int c)

{

lcgpixel(xc+x,yc+y,c);

lcgpixel(xc-x,yc+y,c);

lcgpixel(xc+x,yc-y,c);

lcgpixel(xc-x,yc-y,c);

}

/*********************************************************

* rysowanie elipsy, algorytm Bresenham'a

*********************************************************/

void lcgellipse(int xc,int yc,int a0,int b0,int c)

{

int x=0;

int y=b0;

float a=a0;

float b=b0;

float asqr=a0*a0;

float twoasqr=2*a0*a0;

float bsqr=b0*b0;

float twobsqr=2*b0*b0;

float d=bsqr-asqr*b+asqr/4;

float dx=0;

float dy=twoasqr*b;

while(dx<dy){

lcg4pixels(x,y,xc,yc,c);

if(d>0){

y--;

dy-=twoasqr;

d-=dy;

}

x++;

dx+=twobsqr;

d=d+bsqr+dx;

}

d=d+(3*(asqr-bsqr)/2-(dx+dy))/2;

while(y>=0){

lcg4pixels(x,y,xc,yc,c);

if(d<0){

x++;

dx+=twobsqr;

d+=dx;

}

y--;

dy-=twoasqr;

d=d+asqr-dy;

}

/*********************************************************

* rysowanie okręgu

*********************************************************/

void lcgcircle(int x,int y,int r,int c)

{

lcgellipse(x,y,r,r,c);

}

if(x1>x2){

swap(&x1,&x2);

swap(&y1,&y2);

}

if(x2==x1){

if(y1>y2) swap(&y1,&y2);

for(d=y1;d<y2;d++) lcgpixel(x1,d,1);

return;

}

if(y2>y1) yinc=1; else yinc=-1;

dx=x2-x1;

dy=abs(y2-y1);

d=2*dy-dx;

ainc=2*(dy-dx);

binc=2*dy;

x=x1;

y=y1;

lcgpixel(x,y,c);

x=x1+1;

do{

if(d>=0){

y+=yinc;

d+=ainc;

}else

d+=binc;

lcgpixel(x,y,c);

}while(++x<x2);

}

Listing 2. Przykład programu obsługi wskaźnika LMG640X.

#include "HD61830,h"

void main(void)

{

lcdgraph();

lcgrectangle(0,0,239,127,1);

lcgline(1,1,239,127,1);

lcgline(239,0,0,127,1);

lcgline(0,63,239,63,1);

lcgline(120,0,120,127,1);

lcgrectangle(80,23,160,103,1);

lcgcircle(120,63,40,1);

lcgellipse(120,63,80,47,1);

}

s. Moøliwa jest wiÍc pewna optyma-

lizacja funkcji lcgwr() i† lcgrd() . Funkcje lcgwait() i† delay() mog¹ byÊ

pominiÍte. Powyøsza optymalizacja wymaga jednak dokonania prÛb

na konkretnym sprzÍcie.

Na list. 2 znajduje siÍ przyk³adowy program obs³ugi wskaünika

LMG640X. Dok³adny opis sposobu programowania uk³adu

HD61830B przedstawimy w nastÍpnej czÍúci artyku³u.

Elektronika Praktyczna 10/99

s¹ za pomoc¹ funkcji lcgwr() i† lcgrd() zebranych w†bibliotece

HD61830.h i†przedstawionych na list. 1 .

Funkcja lcgwait() , wykonywana na pocz¹tku cyklÛw dostÍpu,

sprawdza stan gotowoúci kontrolera. W†standardowych konfigura-

cjach szyn ISA komputerÛw PC, cykle zapisu i†odczytu (instrukcje

outportb i † inportb ) trwaj¹ 1

S P R Z Ę T

Sterowanie uk³adem HD61830B

poprzez kartÍ prototypow¹

i†uk³ad 8255

Interfejs sprzÍtowy kontrolera z†kompu-

terem PC w†opisywanym rozwi¹zaniu zre-

alizowany zosta³ za pomoc¹ standardowej

karty prototypowej z†uk³adem PPI typu

8255. £¹cze z†komputerem moøe byÊ rÛw-

nieø zrealizowane, podobnie jak w†przypad-

ku kontrolera HD44780, za pomoc¹ portu

drukarkowego.

Koniecznym jednak bÍdzie modyfikacja

funkcji komunikacyjnych. Pod³¹czenie uk³a-

du 8255 do komputera i†jego programowa-

nie by³o juø wielokrotnie opisywane w†po-

przednich numerach EP (np. 3/94).

Ograniczymy wiÍc rozwaøania do najistot-

niejszych szczegÛ³Ûw. Uk³ad peryferyjny PPI

8255 posiada trzy 8-bitowe porty danych

(PORTA, PORTB i†PORTC) oraz rejestr kon-

figuracyjny (PORTR). Na standardowej karcie

prototypowej PPI jest to rÛwnowaøne czterem

kolejnym lokacjom w†przestrzeni adresowej

uk³adÛw wejúcia/wyjúcia. Adres bazowy

(PORTA) uk³adu 8255 zwykle ustawiony jest

na wartoúÊ 0x300. Aby uk³ad mÛg³ byÊ po-

prawnie uøytkowany naleøy go skonfiguro-

waÊ poprzez wpisanie do rejestru konfigura-

cyjnego (PORTR, adres bazowy+3) odpowied-

niego s³owa kontrolnego. Moøliwe s¹ trzy

tryby pracy portÛw PPI: proste wejúcie/wy-

júcie (tryb 0), strobowane wejúcie/wyjúcie (tryb

1) oraz dwukierunkowa magistrala danych

(tryb 2, jedynie dla PORTA).

Poniewaø obs³uga kontrolera wymaga za-

rÛwno zapisu do, jak i†odczytu z†rejestrÛw

wewnÍtrznych, to uk³ad 8255 obs³u-

giwany jest w†trybie 2. W†trybie dwsu-

kierunkowej magistrali danych czÍúÊ

bitÛw PORTC s³uøy do obs³ugi szyny

PORTA. W†szczegÛlnoúci bit PC6

(ACK) otwiera wyjúciowy bufor trÛjsta-

nowy PORTA (ACK=1 - bufor zamkniÍ-

ty, ACK=0 - bufor otwarty). Bit PC4

(STB) spe³nia rolÍ sygna³u zatrzasku-

j¹cego informacjÍ w†wejúciowym bufo-

rze PORTA (aktywne zbocze opadaj¹-

ce). Bity PC3, PC5 i†PC7 s¹ zarezer-

wowane i†mog¹ s³uøyÊ do generacji

przerwaÒ (PC3) oraz dodatkowego syg-

nalizowania stanu transmisji. Bity PC2,

PC1 i†PC0 mog¹ byÊ programowane

jako proste wejúcie lub wyúcie.

W†opisywanym interfejsie wyúwie-

tlacza PORTA steruje magistral¹ da-

nych uk³adu HD61380B, PORTB ste-

ruje sygna³ami RES, CS, RS, RW

i†E†(odpowiednio bity PB4, PB3, PB2,

PB1 i†PB0). Pozosta³e bity nie s¹ wy-

korzystane.

W†celu zapewnienia poprawnego

sterowania PORTA sygna³ RW do³¹-

czony jest bezpoúrednio do ACK, a†syg-

na³ E†do STB. Schemat interfejsu

wyúwietlacza przedstawiony jest na

rys. 1.

Janusz J. Młodzianowski

Rys. 2.

Karta katalogowa (PDF) jest dostÍpna

pod adresem http://www.ep.com.pl/ftp/

lcdgraf.pdf

Rys. 3.

Elektronika Praktyczna 10/99

Sterowanie Wskaĺşnikami Lcd - Sterownik.pdf

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: