TTL Gatter Schaltung - 20250312

So, ich schreib jetzt ne Assembler Programm es geht so wieder benutzt es den Datenspeicher und zwar benutzt 256 bei Datenspeicher gibt es hintereinander aus. Dabei benutzen wir den Zeiger Z und damit man nicht wieder beide Register vergleichen muss. Da es 256 bald sind, merken wir uns den Wert im ZL und und das Register ist 256 Wert groß, also 8 Bit und dann können wir uns das in einem acht Bit Register merken und können vergleichen. In jedem Fall ist es am Ende, wenn's wieder da ist. Von der Anfang war einmal durchgelaufen.

Im zweiten Schritt addieren wir zu allen 256 Bytes. Eine Eins. Wir geben das wieder aus. Und machen Lauf längenkodierung . Wenn wir das haben, dann addieren wir wieder ne eins und am Anfang ist immer oder nicht nur am Anfang ist es überhaupt Lauflängen Kodierung folgt zweimal das selbe Zeichen aufeinander oder mehrfach dann wird es nur einmal ausgegeben


;; (C) David Vajda
;; 2025-03-11
;; SRAM Out

.include "m8def.inc"

ldi r16, HIGH (RAMEND)
out SPH, r16
ldi r16, LOW (RAMEND)
out SPL, r16
ldi r16, 0xff
out DDRD, r16

ldi YH, HIGH (sram)
ldi YL, LOW (sram)
mov r17, YL
ldi r16, 0x00
loop1:
st Y+, r16
inc r16
brne loop1

ldi r18, 0x01
main:
rcall sramout
rcall sraminc
inc r18
rjmp main

sramout:
ldi YH, HIGH (sram)
ldi YL, LOW (sram)
mov r18, YL
sramoutloop1:
ld r16, Y+
ld r17, Y
sramoutloop2:
cp r16, r17
brne sramoutloop2end
ld r16, Y+
ld r17, Y
rjmp sramoutloop2
sramoutloop2end:
out PORTD, r16
cp YL, r18
brne sramoutloop1
ret

sraminc:
ldi YH, HIGH (sram)
ldi YL, LOW (sram)

sramincloop1:
st Y+
brne sraminvloop1

ret

.dseg
sram: .byte 256


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; (C) David Vajda
;; 2025-03-11
;; SRAM Out

.include "m8def.inc"

ldi r16, HIGH (RAMEND)
out SPH, r16
ldi r16, LOW (RAMEND)
out SPL, r16
ldi r16, 0xff
out DDRD, r16

ldi YH, HIGH (sram)
ldi YL, LOW (sram)
mov r17, YL
ldi r16, 0x00
loop1:
st Y+, r16
inc r16
brne loop1

ldi r19, 0x01
main:
rcall sramout
rcall sleep
rcall sraminc
inc r19
rjmp main

sleep:
push r16
push r17
push r18
ldi r16, 0xff
sleep_loop1:
ldi r17, 0xff
sleep_loop2:
ldi r18, 0x02
sleep_loop3:
dec r18
brne sleep_loop3
dec r17
brne sleep_loop2
dec r16
brne sleep_loop1
pop r18
pop r17
pop r16
ret

sramout:
ldi YH, HIGH (sram)
ldi YL, LOW (sram)
mov r18, YL
sramoutloop1:
ld r16, Y+
ld r17, Y
sramoutloop2:
cp r16, r17
brne sramoutloop2end
ld r16, Y+
ld r17, Y
rjmp sramoutloop2
sramoutloop2end:
com r16
out PORTD, r16
com r16
cp YL, r18
brne sramoutloop1
ret

sraminc:
ldi YH, HIGH (sram)
ldi YL, LOW (sram)
mov r18, YL
sramincloop1:
ld r20, Y
add r20, r19
st Y+, r20
cp YL, r18
brne sramincloop1
ret

.dseg
sram: .byte 256

Jedenfalls kommt jetzt der Teil mit dem i1, i2, j1, j2

Wir müssen jetzt sozusagen i und j Wir müssen das jetzt sozusagen in zwei Teile Spalten also zwei Register, weil wir wollen das halt allgemein gültig machen das sozusagen sozusagen. Wir könnten jetzt bis 256 zählen weil sagen wir mal die Tabelle ist nicht größer als 256 Zellen. Sagen wir mal

Sagen wir mal so und es ist Punkt Nummer eins und Punkt Nummer zwei. Also dann müssen wir das halt so machen dann wird's ein bisschen komplizierter mit dem zählen

Jedenfalls kommt jetzt der Teil mit dem i1, i2, j1, j2

Sagen wir mal so und es ist Punkt Nummer eins und Punkt Nummer zwei. Also dann müssen wir das halt so machen dann wird's ein bisschen komplizierter mit dem zählen

So, jetzt haben wir das klassische Problem, weil wir müssen den Unterschied zwischen den sagen, wie privilegierten Registern am Ende und den weniger privilegierten Registern am Anfang zu suchen beziehungsweise umgekehrt. Aber ich sag mal so r0 bis r15 verhalten sich anders als r16 bis r31 das ist das erste. Ich weiß es im Moment nicht. In wie weit ist es sicher ich muss jetzt i und j und die zwei Zähler eben jeweils zwei Register reservieren und dann hab ich i1 und i2 sagen wir mal allgemein gültig. Jetzt haben wir ein Problem. Wie machen wir das mit dem Zähnen sagen wir mal wir gehen über die 256 hinaus über die 256 Zeilen zahlen wie auch immer Elemente. Halt gut das ist relativ einfach wir wissen ja.

Wenn ich zum Beispiel den Pointer X mit einem Bereich initialisiere also mit einem Label sag ich mal also nicht Bereich, aber mit dem Anfang vom Bereich oder Ende vom Bereich ebenfalls ne Sprungmarke wie auch immer oder ne variablen Deklaration, einem Namen im Arbeitsspeicher bezeichnet Speicherzelle wie auch immer dann muss ich sozusagen HIGH(Label) und LOW(Label) nehmen

So„ jetzt ist es Punkt Nummer eins. Jetzt soll ich das das nehmen und jetzt ist der Witz bei der Geschichte. Was muss ich jetzt eigentlich machen? Der große unterschied ich muss ja jetzt nicht unbedingt an die Bereichsgrenze des Feldes gehen sag ich mal ich sag jetzt nimm jetzt das deutsche Feld weil das kann der iPhone Diktierer Funktion besser jedenfalls ich sag mal, der Unterschied ist selbst wenn ich das Ende des Bereiches nehmen. Also sagen wir das Ende des Bereiches von X des Pointer muss ich jetzt sozusagen die Ende des Ende des Feldes angeben. und wenn ich die so nicht mache, dann hab ich ja sozusagen immer noch sozusagen den Zählwert von I also den Maximalwert und was muss ich jetzt komischerweise trivial Weise machen etwas was man mir nicht glauben will, wenn ich den Zeiger oder im in C sagen wir mal die zählvariable I mit null initialisiere, dann muss ich etwas komisches machen dann muss ich für den Anfang LOW(0) und HIGH(0) nehmen ebenso wie ich sozusagen den obersten Zählwert, also die Grenze in die schleifen Grenze sagen wir für das Feld HIGH(MAX) und LOW(MAX) nehme gut, das mache ich jetzt fange jetzt sozusagen an, aber das muss man sich klarmachen. Auch der Triviale Anfang bei null muss quasi dieses high und Low haben.

Bleibt noch eine Frage offen was machen wir mit dem Inkrement? Sozusagen weil das Problem ist. Ich kann jetzt auch den Vergleich wie vorher starten. Wahrscheinlich muss ich es genauso machen. Wenn ich an der Grenze bin, muss ich sozusagen erstes untere Teil vergleichen und dann den oberen Teil je nachdem, ob der untere Teilwiedergibt. Dass die Grenze erreicht ist, muss ich den oberen Teil erst überprüfen. Was mache ich mit dem increment ich kann's genauso machen. Vielleicht gibt es ne Geschichte Lösung aber ich kann das auch so machen, dass es Inkrement vom höheren Teil immer ausgelöst wird, wenn es Inkrement vom niedrigen Teil quasi schon den maximalen Bereich erreicht hat.


;; also, wenn man das anguckt, mit i+1 und i-1 pointer und so weiter, dann sage ich mal folgendes, das funktioniert sicher, aber
;; naechster beitrag

pasc_run_loop02:
inc iL
cpi iL, 0x00
brne noinciH01
inc iH
noinciH01:
cpi iL, LOW (PASCAL_HEIGHT -1)
brlt cpiL01
cpi iH, HIGH (PASCAL_HEIGHT -1)
breq pasc_run_loop2_end

cpiL01:
rjmp pasc_run_loop2

pasc_run_loop2_end:

st X+, r16
mov r23, XH
mov r22, XL
cp r20, r22
brge pasc_run_loop01_out
rjmp pasc_run_loop01
pasc_run_loop01_out:
cp r21, r23
brge pasc_echo_loop02_out
rjmp pasc_echo_loop01
pasc_run_loop02_out:
ret

Das Problem ist schlicht und ergreifend, dass ich hier quasi also ich habe sozusagen erst mal den Vergleich geregelt die muss ich jetzt kompliziert machen und dann das Inkrement von I & J und irgendwie glücklich bin ich immer noch nicht weil sobald ich jetzt i+1 mache, kann ich ja mehr oder weniger damit rechnen, dass das untere Register nicht überschritten wird auf der einen Seite auf der anderen Seite muss ich sagen, das ist das selbe Problem wie vorher deswegen würde ich sagen wer ist klug zwei wie soll ich sagen Routinen zu schreiben also zwei Unterprogramme, die an sich regeln weil so wird man nicht glücklich muss man einfach sagen, wenn man diese Addition zu dem Index, Wert und den Vergleich und so weiter jedes Mal einzeln in dem Unterprogramm aus wird. Also ich muss noch mal drüber nachdenken.

, an der Stelle muss man klar überlegen, dass an der Stelle muss man klar überlegen, dass Y und Z eigentlich nicht fehl am Platz sind

2 Minuten nachdenken wieder die wieder der besondere Zeiger des ist X und der besondere Zeiger X kann eben nicht mit ldd verwendet werden d.h. mit verschiebe d.h. mit also mit also indiziert ich kann nicht das mit X schreiben, was ich sonst mit


ldd r17, Z+5

Schreibe aber ich glaub an der Stelle lohnt sich das echt diese zwei Pointer zu verwenden, weil ich jetzt einfach


Z-1 und Z+1

Verwenden kann. Und das Problem ist allerdings, dass ja, wenn ich predekrement und Postinkrement nutze dann bleibt ja erst mal das Problem, dass ich entweder nur Pre oder Post nutzen kann. Und das andere Problem ist ja sozusagen, dass das jedes Mal vollzogen wird und das möcht ich ja nicht aber es wär an der Stelle klug ich hab sozusagen den einen Zeiger, der fühlt das Feld und des Feld ist sozusagen nicht quadratisch angeordnet, sondern ein lineares

Ich hab nur sozusagen trotzdem die zwei Zähler in der Schleife und dann gibt es wahrscheinlich trotzdem die Möglichkeit für das eine Y und für das andere Z zu nehmen

Schwierig ist. Wahrscheinlich würde ich sagen, wenn ich jetzt fünf Zähler auf einmal habe dann würde ich jetzt allmählich ne Schwierigkeit kriegen und das alte Problem bleibt, weil ich kein


cpiw

Befehl haben Sie so schön dachte wird es mit dem Vergleich trotzdem kompliziert. Ich probier es mal aus.


pasc_run:
ldi YH, HIGH (pascal+PASCAL_WIDTH*PASCAL_HEIGHT)
ldi YL, LOW (pascal+PASCAL_WIDTH*PASCAL_HEIGHT)
ldi ZH, HIGH (pascal+PASCAL_WIDTH*PASCAL_HEIGHT)
ldi ZL, LOW (pascal+PASCAL_WIDTH*PASCAL_HEIGHT)

ret

pasc_run:
ldi YH, HIGH (pascal)
ldi YL, LOW (pascal)
loop1:
ldi ZH, HIGH (pascal+1)
ldi ZL, LOW (pascal+1)
loop2:

cpi ZL, LOW (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge loop2cpiH
rjmp loop2
loop2cpiH:
cpi ZH, HIGH (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge loop2end
rjmp loop2
loop2end:
cpi YL, LOW (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge loop1cpiH
rjmp loop1
loop1cpiH:
cpi YH, HIGH (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge loop1end
rjmp loop1

loop2end:
ret

Unterabschnitte