Unterkapitel zur HTML-Seitenverkleinerung

Hier sehe ich schon mal den Fehler und ich weiß wie's löse. Das Problem ist, dass ich ja jetzt das zweite dimensionale EE habe. Ich hab nicht nur zwei Zeiger, sondern ich habe I und J sozusagen als Indiz eins bleibt mir erspart. Ich muss nicht übers gesamte Feld hinweg argumentieren d.h. von ganz oben nach ganz unten. Ich kann folgendes machen.

Da sich Zeile für Zeile updatet, muss ich eigentlich folgendes machen

Ich muss sozusagen, i also die in den äußeren Index jedes Mal um die Breite des Feldes inkrememtieren das ist der erste Punkt und der zweite Punkt ist, dass ich sozusagen j J. Nicht über die Grenzen vom Anfang dieses jedes Mal wechselnden. I von Anfang bis Ende hinaus wachsen lasse. Das ist der Unterschied. Also das stimmt hier noch nicht ganz. Ich geh noch mal einen rauchen.

Ich stoße ich war neues Problem, aber das Problem ist schnell gelöst. Zum Glück gibt es, sage ich. Adiw ohne dieses Ding und mit dem variablen sagen wir aber das ist ja ja nicht die Grenze sagen wir des Inneren Feld es ist ja fast hätte ich jetzt ein Problem weil angenommen, ich habe zwei Register R1 R2 und P1 PII, wenn ich jetzt sozusagen in beiden zusammen eine 16 Bit Adresse habe dann müsste ich die jetzt addieren R1 zu P1 und R2 zu P2 das Problem ist, wenn jetzt Nebereichsüberschreitung sozusagen wir sagen eher zwei diesmal der lower significant Teil. Der findet jetzt statt jetzt ne schöne Addition, aber die findet ja nicht in den nächsten Teil. Also die findet ja nicht mehr in Register R1P1 statt und jetzt müsste ich sehr kommuniziert arbeiten. Deswegen ist es gut, dass es adiw gibt. In diesem Fall geht es nicht anders.

;; jetzt sehe ich doch was anderes
pasc_run:
ldi YH, HIGH (pascal)
ldi YL, LOW (pascal)
loop1:
mov ZH, YH
mov ZL, YL
ldi r16, Z+
loop2:
ld

cp ZL, YL
brge loop2cpiH
rjmp loop2
loop2cpiH:
cp ZH, YH
brge loop2end
rjmp loop2
loop2end:

adiw Y, PASCAL_WIDTH
cpi YL, LOW (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1s)
brge loop1cpiH
rjmp loop1
loop1cpiH:
cpi YH, HIGH (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge loop1end
rjmp loop1
loop1end:
ret

Der Witz ist ja, das ist ja gar keinen Sinn macht sozusagen ein äußeren Index und ein inneren Index zu nehmen und den äußeren Index immer zu erhöhen oder den Inneren und abhängig zu machen, von dem äußeren, wo der Innere sowieso erhöht wird. Also das macht gar keinen Sinn, denn außen mitzuzählen da haben ganz anderes Problem.

Wir haben als äußeren Index i und i+1

Wenn du sozusagen das pascalsche Dreieck, dann könnten wir einfach weiter zählen und da würde man sich jetzt trivial Weise fragen. Kann ich nicht überhaupt das einfach in einer Reihe fortsetzen ich würde sagen mal erst nein die Antwort ist nein also wenn wir es nicht mit so einer geraden Tabelle machen zumindest der Witz. Bei der Geschichte ist, dass wir I und I +1 haben falsch ist, dass wir ein äußeren Index und inneren Index haben, weil wir können den äußeren einfach weiterlaufen lassen genauso wie den anderen, was wohl richtig ist, ist folgendes

Des wenn der jetzt Y und Z haben, dann haben die genauso sozusagen die Grenze vom inneren Feld also von der Länge also von den Spalten nur die Arbeiten gleichzeitig sozusagen mitteilen. Also das macht keinen Unterschied aber das eine arbeitet sozusagen die Anzahl der Spalten pro eine Zeile also eine Zeile voraus und das andere eine Zeile zurück. Das ist der Unterschied. Wenn wir das haben ist es kein Problem und dann bleibt noch das plus Eins und des -1 Des lösen wir nicht mit dem decrement und Inkrement. Also Auto inkrement und so weiter sondern einfach so, dass wir hier ldd nehmen und dann passt die Sache jetzt muss noch mal eine rauchen

;; das alte

pasc_run:
ldi YH, HIGH (pascal)
ldi YL, LOW (pascal)
loop1:
mov ZH, YH
mov ZL, YL
ldi r16, Z+
loop2:
ld

cp ZL, YL
brge loop2cpiH
rjmp loop2
loop2cpiH:
cp ZH, YH
brge loop2end
rjmp loop2
loop2end:

adiw Y, PASCAL_WIDTH
cpi YL, LOW (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1s)
brge loop1cpiH
rjmp loop1
loop1cpiH:
cpi YH, HIGH (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge loop1end
rjmp loop1
loop1end:
ret

Kann vielleicht einen anderen Weg gehen man kann vielleicht einen anderen Weg gehen, der geht so das wär vielleicht das Allerbeste, dass man sozusagen einen einzigen Pointer nimmt, also zum Beispiel Z und den Rest sich erspart und mit einem einzigen Unterschied, wenn man hier das i+1 eins hat und und das i sozusagen dann ist der Unterschied ja genau am sozusagen die Breite von einer Zeile weil das ist ja sozusagen der äußere Index und das ist die Breite von einer Zeile, dass ich dann noch j+1 und j-1 habe es letztenendes keinen Unterschied, weil ich hab einerseits sozusagen die Breite also i +1 entspricht sozusagen dem i der Zeilenlänge das ist der Punkt Nummer eins und jetzt ist der Punkt Nummer zwei

Ist an sich keine Lösung. Das ist an sich keine Lösung weil ich muss sozusagen ja trotzdem noch das J erhöhen. Verstehen Sie das ist ja das Problem. Ich glaub ich komm mit einem einzigen Zeiger aus und das Problem wird ich glaub ich hab trotzdem die Lösung

Habe trotzdem die Lösung. Die Lösung wird sein, dass ich mit einem einzigen Zeiger auskommen, nämlich sozusagen Y zum Beispiel und den muss ich erhöhen. Allerdings muss ich folgendes machen als ich komm mit einem einzigen Zeiger aus und den muss ich nicht etwa um das ganze Feld jeweils erhöhen, wenn ich zwei Zeiger hätte wie vorgeschlagen, sondern immer um 1. Also ich hab den gesamten Zeiger nämlich einen einzigen Zeiger. Ich nehme den jetzt mal J obwohl es eigentlich zum Beispiel Y ist und den muss ich immer um eins erhöhen, so wie ich um eins erhöhe und wenn man jetzt genau hinschaut

Letztenendes ist es ja relativ absurde Sache, wenn ich in zweidimensional Feld habe und ich wandere immer gerade aus und es immer um eins. Dann bedeutet es ja nichts anderes. Ich kann einfach um eins über alle Grenzen hinaus wandern d.h. ich hab ja Zeile für Zeile für Zeile und die Zeile hat ne gewisse Breite aber in dem ich sozusagen den Zeiger erhöhe auch wenn er sozusagen über Zeilen hinausgeht. Immer um eins. Erhöhe kann ich den ja trotzdem Grad aus immer weiter erhöhen sozusagen ich kann ihn ja immer weiter erhöhen und es findet hier ja statt, indem ich i erhöhe. Inkrementiere sagen wir mal so. Kann ich ja sozusagen einfach über die Grenzen hinweg springen und jetzt bleibt mein einziges Problem.

Das ist ja einerseits J. -1 habe sag ich mal und andererseits J +1 das kann ich ja einfach damit regeln. Also nicht mit dem Auto increment Auto dekrement Sondern einfach, sondern einfach sozusagen mit ldd da kann ich +1 und -1 geben und jetzt ist andere Problem jetzt hab ich aber i+1 und i während ich über das ganze Feld hinweg spaziere ich sozusagen. Das ist einfach immer implementieren kann, bis wir am Ende sind. Am gnadenlosen Ende kann ich sozusagen gleichzeitig, wenn ich nur i und i-1 habe. Für die Zeilen kann ich ja gleich die sozusagen Anzahl der Spalten von der Zeile abziehen und dann ist das Problem gelöst.

;; ich habe die loesung, zu 100%
;; nur mit einer minimalsten aenderung, naechster, beitrag

pasc_run:
ldi YH, HIGH (pascal)
ldi YL, LOW (pascal)
pasc_run_loop1:
ldd r17, Y-1
ldd r18, Y+1
add r17, r18
std Y+PASCALWIDTH, r17
adiw Y, 1
cpi YL, LOW (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge pasc_run_loop1cpiH
rjmp pasc_run_loop1
pasc_run_loop1cpiH:
cpi YH, HIGH (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge pasc_run_loop1end
rjmp pasc_run_loop1
pasc_run_loop1end:
ret

;; es gibt nur eine schwierigkeit letzter natur, das sind die grenzen die behalten wir bei, weil j geht nie ueber WIDTH-1 hinaus und j faengt bei 1 an und nicht bei 0. weil da ist der rand - also:
;; muessen wir an jeder grenze zwei mal 0 einfuegen, und das waere es.

Stimmt nicht was ich gerade sagte das stimmt. Also, das stimmt hier hier ist mehrfach weg also das erste Problem. Ich dachte, das Ding geht gnädig mit mir um, weil ich nicht über die 256 Grenze hinaus komme. Gut, das tue ich zwar sicher nicht was den Vergleich mit der Schleife mit den zwei Registern betrifft trotzdem stimmt es nicht. Also wenn ich zwei Register ein lower signifikant und ein Most signifikant habe, dann müsste ich ja sozusagen. Ich bin davon ausgegangen, wenn der innere Vergleich versagt hat also der innere Vergleich stattgefunden hat und ich das nächste Register vergleiche dann tue ich das Innere Register wieder gleich null das stimmt, aber nicht weil ich kann nicht davon ausgehen, dass dieses innere Register ab diesem Moment Null ist bezogen auf den high und LOW Anteil sozusagen. Trotzdem, das stimmt insofern nicht weil das nur Vergleiche sind. Die werden hier nicht gesetzt. Das sind nur Vergleiche. Insofern kann ich das so lassen. Ab dem Moment wird die gesamte Sache weiter gezählt und zwar zusammen gefasst deswegen macht es hier keinen Unterschied. Ich musste nichts zurücksetzen.

Die andere Schwierigkeit bleibt was mache ich mit diesen zwei Nullen am Ende. Ich kann jetzt natürlich unschön Weise irgendein Zähler mit laufen lassen und sobald er sozusagen die Breite der Zeile erreicht hat, kann ich zwei Nullen einfügen. Ich finde es trotzdem schlecht. Das ist also sehr unelegant und ich müsste jetzt eigentlich mit einem Modul rechnen d.h. mit einem Rest das ist jetzt nicht besonders einfach. Erstens mal kennt es keine Divisions Befehle es macht's auch nicht einfacher. Zweitens sind Divisions Befehle sehr aufwändig. Was nun Rest in diesem Sinne kann ich mir zwei erlauben. Wenn ich zum Beispiel Schiebe Operation mache, kann ich den vorderen Teil als Quotienten auffassen und den hinteren Teil, den ich weg geschoben habe als Rest des funktioniert aber nur, wenn ich Zahlen habe, die sozusagen zweier Potenzen sind. Das wird in diesem Fall nicht gehen.

Gut, ich denke in dem Fall ist es ja egal gucken Sie mal ich hab an den an den Grenzen hab ich zweimal hab ich lauter Nullen also an den Grenzen habe ich lauter Nullen und am Anfang also in der ersten Zeile habe ich in der Mitte eine Eins aus der Eins wird dann in den nächsten Zeilen durch Addition immer weiter was entstehen und die Ränder da sag ich mal addiere ich sozusagen die Grand äußere Grenze die Randgrenze auf der einen Seite zur Randgrenze auf der anderen Seite am Anfang aber das macht ja keinen Unterschied weil die sind ja beide null und dann pflanzt sich das auch vor. Insofern ist es ja egal also kann ich's mal ausprobieren ob's jetzt funktioniert. Ich glaub das Programm ist fertig und es müsste funktionieren was ich gerade eben sagte es ist wahrscheinlich Unsinn selbst wenn sich die Randgrenzen dann addieren die sind ja alle mit Null gefüllt. Von daher passiert ja nichts Neues

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; (C) David Vajda
;; 2025-03-10
;; Pascal LED out

.include "m8def.inc"

.equ PASCAL_HEIGHT = 11
.equ PASCAL_WIDTH = 2*PASCAL_HEIGHT+1
.equ PASC_FRST = ((PASCAL_WIDTH>>1)+1)
.def    COL_COUNTER = r17
.def    ROW_COUNTER = r18

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

rcall pasc_init0
rcall pasc_run

main_loop:
rcall pasc_echo
rjmp main_loop

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

pasc_init0:
ldi r19, 0x00
ldi YH, HIGH (pascal)
ldi YL, LOW (pascal)
pasc_init0_loop1:
st Y+, r19
cpi YL, LOW (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge pasc_init0_loop1cpiH
rjmp pasc_init0_loop1
pasc_init0_loop1cpiH:
cpi YH, HIGH (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge pasc_init0_loop1end
rjmp pasc_init0_loop1
pasc_init0_loop1end:
ldi r16, HIGH (pascal)
mov YH, r16
ldi r16, LOW (pascal)
mov YL, r16
ldi r19, 0x01
std Y+PASC_FRST, r19
ret

pasc_echo:
ldi r21, HIGH (pascal+PASCAL_WIDTH*PASCAL_HEIGHT)
ldi r20, LOW (pascal+PASCAL_WIDTH*PASCAL_HEIGHT)
ldi r16, HIGH (pascal)
mov XH, r16
ldi r16, LOW (pascal)
mov XL, r16
pasc_echo_loop01:
ld r16, X+
cpi r16, 0x00
breq pasc_echo_no_out
out PORTD, r16
rcall sleep
pasc_echo_no_out:
mov r23, XH
mov r22, XL
cp r20, r22
brge pasc_echo_loop01_out
rjmp pasc_echo_loop01
pasc_echo_loop01_out:
cp r21, r23
brge pasc_echo_loop02_out
rjmp pasc_echo_loop01
pasc_echo_loop02_out:
ret

pasc_run:
ldi YH, HIGH (pascal)
ldi YL, LOW (pascal)
pasc_run_loop1:
ld r17, Y
ldd r18, Y+2
add r17, r18
std Y+PASCAL_WIDTH+1, r17
ld r17, Y+
cpi YL, LOW (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge pasc_run_loop1cpiH
rjmp pasc_run_loop1
pasc_run_loop1cpiH:
cpi YH, HIGH (pascal+PASCAL_WIDTH*PASCAL_HEIGHT-1)
brge pasc_run_loop1end
rjmp pasc_run_loop1
pasc_run_loop1end:
ret

.dseg

pascal: .byte  PASCAL_HEIGHT*PASCAL_WIDTH



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

komisch ich habe den stecker raus gemacht, gestern die ganze zeit gesucht und jetzt habe ich den stecker rein gemacht, jetzt laeuft die schaltung. ich kann nicht sehen, ob die zahlen stimmen, weil sie werden scheinbar invertiert ausgegeben. ich kann ein com" davor machen, um es zu invertieren

Da stelle ich zu meinem Entsetzen fest. Ich haben Befehl erfunden, denen es nicht gibt. Es gibt kein cpiw wie ich darauf gekommen bin. Ich weiß es nicht, aber ich hab ein Befehl erfunden, es nicht gibt es gibt die nicht ich muss es so lösen wie's gemacht habt dann war es 100 pro richtig weil es gibt den Befehl nicht ich hab ihn erfunden.