LCD - Display in een historisch projekt.
Datum: Wed 05 June 2019
Samenvatting: Lcd op een Cbm64 via (enkele 74xx registers op) de Expantie-port en op een eigen 6502-systeem. Projekt uit het jaar 1991
Rond 1989-1990 ontving ik een Lcd-Display van 2 regels van 40 tekens. Het bleef bijna een jaar in de kast liggen, voordat ik er mee begon te experimenteren. En als eerste was dat om het aan te sluiten op de Expantie-port van mijn Commodore 64. Deze port bevat namelijk alle data (D7..D0) en adres-lijnen (A15..A0), plus de control-lijnen (Reset, R/W, Φ2) van de processor en enkele (gedecodeerde) I/O aanstuur-lijnen.
Er werd een eenvoudige schakeling gebouwd met enkele poorten (74ls04 en 74ls08) en twee registers (74ls273 en 74ls374). In die tijd waren teken-pakketen en Cad/programmatuur ver buiten het bereik van de hobby-ist, dus alle schema's werden op papier getekend. In dit geval werd het een handgetekend schets-achtig schema.
Na het aansluiten van het display werd er ge-experimenteerd met programma's en kwamen er zodoende twee SchermPrint-methodes, de Register-methode en de Stack-methode. Beiden hebben hun eigenschappen en eigen charmes.
Noten vooraf:
- Het betreft hier routines in assembly voor een 6502-CPU (processor). Deze processor zit onder andere in de Vic20 en in diverse zelfbouw systemen. De Commodore 64 heeft een aangepast model van de 6502, die 6510 heet.
- De 6502 heeft een databus van 8-bits breed (0..255 - $00..$FF) en een adres-bus van 16 bits breed (0..65535 - $0000..$FFFF) (= 64kb). In de 6502 zitten maar 3 data-registers (A, X, Y) en een stack-register (Stack Pointer), elk 8 bits breed (0..255 - $00..$FF).
- De 6502 heeft zogename Zero-Page adressen, die voor speciale gevallen te gebruiken zijn en daarom ook te zien zijn als 128 extra registers.
- Ik ga hier bewust niet in op de (assembly)instructies zelf. Hier zijn in de loop der tijd velen boekwerken over geschreven. Enige voorkennis van 6502-assembly is in dit projekt daarom wel noodzakelijk.
- De programmeer-truken zijn ook voor andere processoren toe te passen, of in hogere talen (zoals: Basic, C++, Pascal).
Printen van teksten naar schermen.
Het idee is om een subroutine (c.q. procedure, functie) aan te roepen om een tekst te printen.
Het is hierbij belangrijk om te weten WAT er als parameters meegegeven moet worden. Bij teksten is dat in het algemeen een kleur en de tekst zelf. De tekst zelf kan worden opgesplitst in losse tekens. Deze tekens kunnen 1 voor 1 naar het display worden gestuurd. En dat gedurende de gehele tekst.
Kleur: Er kan met dit type Lcd-Display maar 1 kleur worden weergegeven ... eigenlijk is het meer een wel of geen kleur ... of te wel wel of geen teken. Een parameter voor kleur is dus niet nodig.
Teken: De tekens kunnen natuurlijk in de hoofd-routine 1 voor 1 worden opgezocht en die kunnen stuk voor stuk naar het display worden gestuurd. Dan hoeft er alleen een teken-code (voor de letter/ cijfer) als parameter worden opgegeven. Het display geeft hiervoor wel een handig middel, want het display ontvangt standaard ASCII-waardes voor de tekens.
Losse tekens naar het display sturen kan handig wezen voor een enkel teken, maar voor lange teksten (de strings) is er een handigere methode.
Strings: Strings moeten ergens staan en strings hebben een lengte. Dus als parameters zijn er nodig: de plaats waar de string staat EN de lengte van de string. Elke losse string heeft een label nodig die aangeeft WAAR de string staat. En de lengte moet (met de hand (?)) worden geteld.
Om de lengte te bepalen is er nog wel een hulpmiddel door ook een label te nemen voor het einde van de string en dan deze label-waarde te verminderen met de label-waarde van (het begin van) de string. De meeste assemblers hebben hier hulpmiddelen voor.
Printen volgens de Register-methode.
Dit is tevens de methode die veelal op scholen en in assembly cursussen wordt geleerd. Het idee van deze methode is ook recht-toe recht-aan en daarom gemakkelijk te doorgronden. Plaats de benodigde waardes in de CPU-registers (de parameters), roep een subroutine aan en er wordt een tekst geprint.
Een beperking van de 6502 (c.q. 6510) is dat deze maar 3 registers kent (van 8-bits breed). Zonder verder op deze materie in te gaan, zijn met deze 3 registers toch heel wat subroutines aan te sturen. Moeten er meer parameters worden doorgegeven, dan is een truuk om hiervoor een stukje geheugen voor te reserveren en deze plaatsen te gebruiken als doorgeef-luik. Maar voor het maken van print-routines zijn deze 3 registers voldoende gebleken.
In de Listing (van de Register Methode) is te zien dat er twee strings zijn in het programma. Een initialisatie-string "InitTekst" en een tekst-string "Tekst". Het adres (de lokatie) van deze string wordt gehaald uit het label, waarbij de lage 8-bits van het adres naar het X-register gaan en de hoge 8-bits naar het Y-register. De lengte wordt in het A-regsiter geplaatst.
De subroutines "DisWrite" en "DisComm" werken beiden volgens dezelfde methode. De inhoud van de X en Y-registers worden geplaatst op twee Zero-Page geheugenadressen (Stx en Sty). Daarna volgt het (software-matig) aansturen van het display.
Met de instructie "Lda (TextPoint),Y" worden de tekens van de String 1 voor 1 uit het geheugen gehaald en naar het display gestuurd (Sta DisAddr+1). Na een wachttijd, om het display de tijd te geven om het teken te verwerken (toendertijd proefondervindelijk vastgesteld) worden de X en Y-register verhoogd (Iny) en verlaagd (Dex). Wanneer alle tekens naar het display gestuurd zijn (dit wordt gecontroleerd met een Bne), is de subroutine klaar (Rts).
Het verschil tussen de beide subroutines is de wachttijd. Bij "DisComm" is deze langer in verband met de verplichte wachttijden tijdens het initialiseren.
Voordelen van de Register-Methode zijn:
- Het is makkelijk te begrijpen hoe de subroutines werken, het is recht-toe recht-aan.
- Alle teksten staan bij elkaar in het geheugen, zodat het aanpassen (verbeteren/ vertalen) van de teksten relatief eenvoudig zijn.
Nadelen zijn:
- Elke string moet zijn eigen Label krijgen, het liefst een suggestieve naam (in plaats van "Tekst1", "Tekst2", etc). Labels kunnen een beperkte lengte hebben, dus dit zal op den duur leiden tot een naam en een nummer.
- De lengte van elke string moet van te voren worden bepaald.
De lengte van een string kan ook door de subroutine worden bepaald als er gebruikt wordt van een String-Terminator, ook wel Eot (End Of Text) genoemd. Of eigenlijk wordt het einde van de string gezocht, tijdens het ophalen van alle tekens van de string. De routine wordt er ietsje trager door, maar het vereenvoudigd wel het bepalen van de parameters en dus het programmeren van de rest van het programma.
Printen volgens de Stack-methode.
De Stack-methode volgt meer het gebruik in de hogere programmeer-talen. Op het moment dat er een tekst nodig is, staat deze op de plaats van het printen. En hier zit het mooie van deze methode in.
De tekst zelf wordt geplaatst vlak achter de subroutine aanroep (Jsr) en het programma gaat verder na de tekst zelf. Waarom dit werkt, is omdat er na het aanroepen van de subroutine bekend is waar de tekst staat. En om dit te begrijpen moet men eerst begrijpen wat het mechanisme van subroutines is.
Op het moment dat er een subroutine wordt aangeroepen, wordt eerst het geheugen-adres van de Jsr opgeslagen - of om precies te zijn, het adres NA de Jsr wordt opgeslagen. Voor deze opslag wordt een stuk geheugen gebruikt dat men de "Stack" noemt. Een Stack-Register (Een Adres-pointer) houdt bij waar de laatste waarde op de Stack staat. Men kan data van een Stack uitlezen (Pla), of weer terugplaatsen (Pha). Na elke plaatsing op de Stack, of uitlezing van de Stack wordt de inhoud van het Stack-register automatisch aangepast (in de CPU zelf), zodat deze altijd naar de laatst geschreven waarde blijft wijzen.
Nu het adres dat op de Stack staat kan worden uitgelezen, is eenvoudig te bepalen wat het adres van de string staat. Het adres wordt eenvoudig van de Stack uitgelezen (Pla) en in twee Zero-Page geheugen-adressen geplaatst (Sta).
Vanwege eigenschappen van de 6502, moet dit adres eerst met 1 worden verhoogd voordat deze kan worden gebruikt en dat gebeurt met twee "Inc" instructies. Op zich kan dit geen kwaad, want dit adres moet toch met elk teken worden verhoogd. Nu gebeurt dat dus voordat er een teken wordt gelezen.
Het teken van de string, wat door dit adres wordt aangewezen, wordt ingelezen (Lda ($B0),Y of Lda (TextPoint),Y) en er wordt gecontroleerd of het een Eot-teken ($00 of welke waarde men hiervoor ook kiest) is.
Zo nee: dan wordt het teken naar het scherm, c.q. Display gestuurd. Vervolgens herhaald de routine weer vanaf het punt dat het adres op de Zero-Page wordt verhoogd.
Zo ja: dan is de gehele string geprint. Natuurlijk moet het laatste adres van de string weer naar de Stack worden geplaatst (met 2 keer Lda en Pha) en is de subroutine ten einde.
Op de Stack staat nu het adres van de programma-instructie net na de string. De Rts laat het programma weer terugspringen naar deze instructie.
Voordelen van de Stack-Methode zijn:
- Elke string staat daar waar het nodig is.
- Het hoofd-programma wordt beter leesbaar.
- Men hoeft niet allemaal Labels te verzinnen voor alle teksten.
- Er zijn (in principe) ook geen parameters nodig voordat de subroutine wordt aangeroepen.
Nadelen zijn:
- Tijdens het Dis-assembleren is de kans groot dat instructies na de string onjuist worden gedecodeerd, omdat een disassembler ook een string in code probeert om te zetten (verkeerde code-lengtes en onjuiste codes).
- Een string-lengte kan buiten het bereik gaan van een Branch-instructie (Beq, Bne, etc), bij een 6502-programma is dit bereik maar +/-127 adressen.
- Het aanpassen (verbeteren) van Strings kan behoorlijk wat zoekwerk zijn, omdat alle strings gefragmenteerd staan (versnipperd zijn) over het gehele programma.
Conclusie.
| Methode | Aantal Parameters | Lokatie | Lengte | Methode | Plaats String | Plaats in Programma |
|---|
| Losse Tekens | 1 | nvt | 1 | Register | Voor de aanroep | Door heel programma |
| Strings | 2 | 2 bytes | 1 byte | Register | Label Programma | Kan bij Elkaar |
| String met Eot | 1 | 2 bytes | zoeken | Register | Label Programma | Kan bij Elkaar |
| String JSR met Eot | 0 | zoeken | zoeken | Stack | Na de aanroep | Door heel programma |
Projekten waarbij ik deze Stack-Methode heb gebruikt, zijn allen Assembly projekten geweest, zoals:
- Een school-opdracht op een 6809-systeem (onder OS9).
- Cbm64: Acia-Monitor (met 6551), Midi-programma (met 6551-Acia).
- Eigen 6502-Systeem met een 6551 Acia (voor Midi) en losse TTL-registers voor de I/O (o.a. voor een 40x2 Lcd-Display) - draaiend onder een eigen ontworpen Operating System (AOS). Zie foto's.
Persoonlijk vind ik de Stack-Methode een mooie methode, vooral voor losse strings. Juist omdat de teksten meteen na de subroutine-aanroep in het programma zitten en er geen parameters nodig zijn.
Voor strings die in een Array zitten, zou ik de Register-methode gebruiken, maar dat soort projekten heb ik nog niet gehad in assembly.
Broncode:
[1: Lcd-Display op een Cbm64.]
[2: Print-routine op een Cbm64 systeem.]
[3: Lcd-Display op een 6502-systeem.]
[4: Flow Charts van de Display Routines]
1: De broncode van Lcd-Display op een Cbm64.
(Sat 22 December 1990)
Lcd op een Cbm64 (via enkele 74xx registers) op de Expantie-port (overgetikt van een uitgeprinte uitdraai).
|
Deze broncode heeft 89 regels met programma-code.
|
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
!
! Lcd-Print Routines - Register Methode
!
! Lda #Number of Chars
! Ldx #<TextAddress
! Ldy #>TextAddress
! Call Jsr
!
*=30000 ($7530)
DISADDR = $DF00 Reg0 = Control Reg1 = Data
TEXTPOINT = $B0
!------------------------------------------------------------
! Initialise the Display
Lda #7
Ldx #<InitText
Ldy #>InitText
Jsr Discomm
! Display Test Text
Lda # #79
Ldx #<Tekst
Ldy #>Tekst
Jsr DisWrite
Rts
!------------------------------------------------------------
! Display Write
! X= LowAddress Text
! Y=HighAddress Text
! A=Number of Chars
DisWrit Stx TextPoint
Sty TextPoint+$1
Tax
Ldy #0
DisWritLus Lda #2 WriteLoop
Sta DisAddr
Lda (TextPoint),y
Sta DisAddr+1
Lda #3
Sta DisAddr
Lda #1
DisWritL2 Sec WaitLoop
Sbc #1
Bne DisWritL2
Lda #$2
Sta DisAddr
Iny
Dex
Bne DisWritLus
Rts
!------------------------------------------------------------
! Display Write
! X= LowAddress Text
! Y=HighAddress Text
! A=Number of Chars
DisComm Stx TextPoint
Sty TextPoint
Tax
Ldy #0
DisCommLus Lda #0 WriteLoop
Sta DisAddr
Lda (TextPoint),Y
Sta DisAddr+1
Lda #1
Sta DisAddr
Lda #100
DisCommL2 Sec WaitLoop
SBC #1
Bne DisCommL2
Lda #0
Sta DisAddr
Iny
Dex
Bne DisCommLus
Rts
!------------------------------------------------------------
! Init Text
InitText Byt $30,$30,$30,$38,$0D,$01,$06
! The Test Text
Tekst Txt "Hee, Hallo, Bij mijn mooie Lcd-Display. "
Txt "Zie je ook regel nummero 2 hiero (J/N)? "
!------------------------------------------------------------
!-----------------------------------------------------------
! Pro: 1. Easy to understand.
! 2. All Texts are together.
!
! Con: 1. Every String has to get an own Label.
! 2. The length of every string has to be known and given to the Jsr.
!
|
Broncode:
[1: Lcd-Display op een Cbm64.]
[2: Print-routine op een Cbm64 systeem.]
[3: Lcd-Display op een 6502-systeem.]
[4: Flow Charts van de Display Routines]
2: De broncode van Print-routine op een Cbm64 systeem.
(Sat 22 December 1990)
Het onderzoeken van de Stack-methode op de Cbm-64 (overgenomen van een ge-dis-aeembleerde code van een Cbm64-Diskette).
|
Deze broncode heeft 61 regels met programma-code.
|
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
!
! Print Routine - Stack method
!
! Just put your string behind the Jsr-call.
! End your string with a $00.
! Call this Jsr.
! It will return to the code behind the string.
!
*=$08C9
TEXTPOINT = $B0
08C9 68 PRINT PLA Get Address (Lo) of string from Stack. This is the return-address.
08CA 85 B0 STA $B0 Store string Address (Lo) to Pointer (Lo)
08CC 68 PLA Get Address (Hi) of string from stack
08CD 85 B1 STA $B1 Store string address (Hi) to Pointer (Hi)
08CF A0 00 LDY #$00 Make Pointer-Index $00 - Y will stay $00
08D1 E6 B0 INC $B0 Inc pointer (Lo)
08D3 D0 02 BNE $08D7
08D5 E6 B1 INC $B1 Inc pointer (Hi)
08D7 B1 B0 LDA ($B0),Y Get string-char from pointer
08D9 C9 00 CMP #$00 chr(0) is end-of-string
08DB F0 06 BEQ $08E3 Yes? End of Jsr
08DD 20 9B 08 JSR $089B Write the char to the display. Modify to your own write-sub-routine
08E0 4C D1 08 JMP $08D1 Get next char
08E3 A5 B1 LDA $B1 Load from Pointer (Lo) End-of-string Address (Lo)
08E5 48 PHA Put Address (Lo) of string back to Stack. This is the new return-address.
08E6 A5 B0 LDA $B0 Load from Pointer (Hi) End-of-string Address (Hi)
08E8 48 PHA Put Address (Lo) of string back to Stack
08E9 60 RTS Return
!------------------------------------------------------
!
! The Write Sub-routine in an Cbm64
!
*=$089B
089B 20 D2 FF WRITE JSR $FFD2
089E 60 RTS
!------------------------------------------------------
!
! Example
!
093D 20 C9 08 JSR $08C9 Print string.
TXT "BAUDRATE CODE (0..15) : "
BYT $00
! next codes
095B
!------------------------------------------------------
!------------------------------------------------------
!
! Pro: 1. Every string is just there where it is needed.
! 2. One does not have to make up with all kind of labels to mark all strings with.
! 3. And thus no pre-LDA's are needed before printing a string.
!
! Con: 1. The Disassembler mostly makes a mess of the next of the code.
! 2. The string length can exceed the range of an branch-jump.
!
|
Broncode:
[1: Lcd-Display op een Cbm64.]
[2: Print-routine op een Cbm64 systeem.]
[3: Lcd-Display op een 6502-systeem.]
[4: Flow Charts van de Display Routines]
3: De broncode van Lcd-Display op een 6502-systeem.
(Thu 10 January 1991)
Lcd (via enkele 74xx registers) op een zelf ontworpen en ontwikkeld 6502-systeem (overgetikt van een uitgeprinte uitdraai).
|
Deze broncode heeft 172 regels met programma-code.
|
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
!
! Lcd-Print Routines - Stack Methode
!
! Just put your string behind the Jsr-call.
! End your string with a $00.
! Call this Jsr.
! It will return to the code behind the string.
!
*=$B0
TextPoint = *
*=*+2
DisAddr = $DF00
Eot = $80
*=50000 ($C350)
!------------------------------------------------------------
JMP Start
!------------------------------------------------------------
! Display Put Character
! Text is after JSR, Text finish at Eot-char
PutC Pha
! Place Chr on Screen
Lda #2 Disable Display
Sta DisAddr
Pla Store Chr
Sta DisAddr+1
Lda #3 Enable Display
Sta DisAddr
! WaitLoop, Wait until the display is Ready
Ldx #1
PutcLus2 Dex
Bne PutcLus2
Lda #2 DisAble Display
Sta DisAddr
Rts
!------------------------------------------------------------
! Display Command
! Command is in A
DCommand Pha
! Send Command to Screen
DCommTeken Lda #0 Disable Display
Sta DisAddr
Pla Store Chr
Sta DisAddr+1
Lda #1 Enable Display
Sta DisAddr
! WaitLoop, Wait until Display is Ready
Lda #100
DCommLus2 Dex
Bne DCommLus2
DCommLus3 Dex
Bne DCommLus3
Lda #0
Sta DisAddr
! End of Routine
Rts
!------------------------------------------------------------
! Display Write
! Text is behind the JSR, Text finish with Eot (=$80)
Write Pla Get String Address from the Stack
Sta textPoint
Pla
Sta TextPoint+1
! Correct Address (= Inc with 1)
Ldy #0
! Increase TextAdres
WriteLus Inc TextPoint
Bne WriteTeken
Inc TextPoint+1
! Put Character on Screen
WriteTeken Lda (TextPoint),Y
Cmp #Eot End Of Text
Beq WriteEnd
Jsr PutC
Jmp WriteLus
! End of Routine, Restore Address
WriteEnd Lda TextPoint+1
Pha
Lda textPoint
Lha
Rts
!------------------------------------------------------------
! Init Display
DInit Lda #%00110000 Init Display
Jsr DCommand
Lda #%00110000 Init Display
Jsr DCommand
Lda #%00110000 Init Display
Jsr DCommand
Lda #%00111000 Set 8 Bits Data
Jsr DCommand
Lda #%00001100 Set Display On
Jsr DCommand
Lda #%00000001 ClrScrisplay
Jsr DCommand
Lda #%00000110 Set Crsr Mode
Jsr DCommand
Rts
!------------------------------------------------------------
! Clear the Display
ClrScr Lda #%00000001 Clear All
Jsr DCommand
Rts
!------------------------------------------------------------
! GotoXY, Place Cursor
! X is X-position [0..39]
! Y is Y-position [0.. 1]
GotoXy Txa
Cpy #0 Check for Line 0
Beq GotoXyVerd
Ora #%01000000 Set for Line 1
GotoXyVerd Ora #%10000000 Set DDram
Jsr DCommand
Rts
!------------------------------------------------------------
! Wait until A = 0
Wait Lda #0
Ldy #0
WachtLus Dey
Bne Wachtlus
Dex
Bne Wachtlus
Sec
Sbc #1
Bne Wachtlus
Rts
!------------------------------------------------------------
! DummyStart ================= Begin Of Main Program
Start Jsr DInit
StartEcht Jsr ClrScr
Ldx #5
Ldy #0
Jsr GotoXy
Jsr Write
Byt $E0 $6E,$20,$41,$^C,$66,$E0,$20 "An Alfa "
Byt $53,$6F,$66,$74,$77,$E0,$72,$74 "Software"
Byt $69,$6F,$6E,$21,$20,$26,$20 "ion! & "
Byt Eot
!------------------------------------------------------------ !
Ldx #4
Ldy #1
Jsr GotoXy
Jsr Write
Byt $E0,$6E,$20,$41,$6C,$66,$E0,$20 "An Alfa "
Byt $45,$6C,$65,$63,$74,$72,$6F,$6E "Electron"
Byt $69,$63,$73,$20,$50,&72,$6F,$64 "ics Prod"
Byt $75,$63,$74,$69,$6F,$6E,$21 "uction!"
Byt Eot
!------------------------------------------------------------
! Enter Data Mode
Lda #10
Jsr Wait Wait for 10-A cycli
Lda #%00001101
Jsr DCommand
Jsr ClrScr
Jsr Write
Txt "Enter Data > "
Byt Eot
!------------------------------------------------------------
! End of Program
Rts
!------------------------------------------------------------
!-----------------------------------------------------------
!
! Pro: 1. Every string is just there where it is needed.
! 2. One does not have to make up with all kind of labels to mark all strings with.
! 3. And thus no pre-LDA's are needed before printing a string.
!
! Con: 1. The Disassembler mostly makes a mess of the next of the code.
! 2. The string length can exceed the range of an branch-jump.
!
|
Broncode:
[1: Lcd-Display op een Cbm64.]
[2: Print-routine op een Cbm64 systeem.]
[3: Lcd-Display op een 6502-systeem.]
[4: Flow Charts van de Display Routines]
4: De broncode van Flow Charts van de Display Routines
(Thu 10 January 1991)
Enkele Flow-Charts in Ascii getekend (overgenomen van handgetekende flow-charts).
|
Deze broncode heeft 57 regels met programma-code.
|
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
(_DCommand_)
|
Save A Reg-A contains Command
|
Switch Display to Command
|
Get back A and Send this to Display
|
Activate Display
|
Wait for 2 times 255 rounds
|
De-activate Display
|
(Rts)
----------------------------------------------------------------------
Timing: Display takes command
/
Data0 ______~~~~__ High = Active Low = Not-Active
Data1 ____________ High = Read Low = Write
Data2 ~~~~________ High = Data Low = Command
======================================================================
(_PutC_)
|
Save A Reg-A contains Command
|
Switch Display to Data
|
Get back A and Send this to Display
|
Activate Display
|
Wait 3 round, until Display is Ready
|
De-activate Display
|
(Rts)
----------------------------------------------------------------------
Timing: Display takes command
/
Data0 ______~~____ High = Active Low = Not-Active
Data1 ____________ High = Read Low = Write
Data2 ____~~~~~~~~ High = Data Low = Command
======================================================================
|
Broncode:
[1: Lcd-Display op een Cbm64.]
[2: Print-routine op een Cbm64 systeem.]
[3: Lcd-Display op een 6502-systeem.]
[4: Flow Charts van de Display Routines]
|
Afbeeldingen
1/7: lcdpre_1-optrex_databoek.jpg.
2/7: lcdpre_2-optrex_databoek.jpg.
3/7: lcdpre_3-optrex_databoek.jpg.
4/7: lcdpre_4-lcd_cbm64.jpg.
5/7: lcdpre_5-6502_systeem.jpg.
6/7: lcdpre_6-6502_systeem.jpg.
7/7: lcdpre_7-optrex_2x40.jpg.
|
|
Arduino Projekten
