Arduino Projekten

Tue 27-Oct-20
07:05:30




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:

  1. 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.

  2. 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).

  3. De 6502 heeft zogename Zero-Page adressen, die voor speciale gevallen te gebruiken zijn en daarom ook te zien zijn als 128 extra registers.

  4. 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.

  5. 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:

  1. Het is makkelijk te begrijpen hoe de subroutines werken, het is recht-toe recht-aan.
  2. Alle teksten staan bij elkaar in het geheugen, zodat het aanpassen (verbeteren/ vertalen) van de teksten relatief eenvoudig zijn.

Nadelen zijn:

  1. 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.
  2. 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:

  1. Elke string staat daar waar het nodig is.
  2. Het hoofd-programma wordt beter leesbaar.
  3. Men hoeft niet allemaal Labels te verzinnen voor alle teksten.
  4. Er zijn (in principe) ook geen parameters nodig voordat de subroutine wordt aangeroepen.
Nadelen zijn:
  1. 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).
  2. 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.
  3. Het aanpassen (verbeteren) van Strings kan behoorlijk wat zoekwerk zijn, omdat alle strings gefragmenteerd staan (versnipperd zijn) over het gehele programma.

Conclusie.

Methode Aantal ParametersLokatieLengteMethode Plaats String Plaats in Programma
Losse Tekens 1 nvt 1 RegisterVoor de aanroepDoor heel programma
Strings 2 2 bytes1 byteRegisterLabel ProgrammaKan bij Elkaar
String met Eot 1 2 byteszoekenRegisterLabel ProgrammaKan bij Elkaar
String JSR met Eot 0 zoeken zoekenStack Na de aanroep Door heel programma

Projekten waarbij ik deze Stack-Methode heb gebruikt, zijn allen Assembly projekten geweest, zoals:

  1. Een school-opdracht op een 6809-systeem (onder OS9).
  2. Cbm64: Acia-Monitor (met 6551), Midi-programma (met 6551-Acia).
  3. 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

lcdpre_1-optrex_databoek.jpg
1/7: lcdpre_1-optrex_databoek.jpg.
lcdpre_2-optrex_databoek.jpg
2/7: lcdpre_2-optrex_databoek.jpg.
lcdpre_3-optrex_databoek.jpg
3/7: lcdpre_3-optrex_databoek.jpg.
lcdpre_4-lcd_cbm64.jpg
4/7: lcdpre_4-lcd_cbm64.jpg.
lcdpre_5-6502_systeem.jpg
5/7: lcdpre_5-6502_systeem.jpg.
lcdpre_6-6502_systeem.jpg
6/7: lcdpre_6-6502_systeem.jpg.
lcdpre_7-optrex_2x40.jpg
7/7: lcdpre_7-optrex_2x40.jpg.