RAM am AT Mega 16 auslesen mittelwerte zusammenfassen

[R--- S. (rene66)]

Hallo,


ich möchte gern folgende RAM Matrix im RAM eines Mega 16 so effektiv wie 
möglich auslesen.
Die farbig hinterlegten Bereiche im Anhang stellen jewals ein Ergebnis 
das aus 3 Messwerten besteht also 8 x 3 mal den Mittelwert bilden und in 
einen extra Ram bereich schreiben. Habe momentan ein "Loch" im Kopf und 
komme nicht so Richtig weiter.
Assembler
Für Anregungen bin ich dankbar.

[obake (Gast)]

Hallo René,

das ist doch davon abhängig, wie Du das RAM in der von Dir benutzten 
Software (welche ist das?) repräsentierst bzw. in welcher Reihenfolge 
die Daten im RAM landen. Und das wiederum ist von der Programmiersprache 
abhängig (z.B. läuft in C der 2. Parameter eines Arrays "schneller" als 
der erste). Du musst die Fragestellung also deutlich spezifischer 
formulieren, um eine sinnvolle Antwort zu erhalten. In welchem 
Datenformat liegen die Daten vor? Wertebereich? Welche Genauigkeit muss 
die Mittelwertbildung haben? Ohne diese Informationen geht es nicht!

Viel Grüße

obake, der Geist

[Hannes L. (hannes)]

Ich kann Deine Excel-Datei auch nicht interpretieren. Allerdings habe 
ich im Gegensatz zu obake mitbekommen, dass Du auf dem Mega16 in 
Assembler werkeln willst.

Wie man das effektiv macht, ist von den Einzelheiten abhängig. Ist die 
Anzahl der Datensätze klein genug, bietet sich der Zugriff über LDD/STD 
an. Damit greifst Du über einen Pointer auf mehrere Bytes zu, die 
versetzt im RAM liegen. Da der Versatz maximal 63 betragen darf, geht es 
nur für kleine Arrays. Bei mehr Elementen muss dann mit 2 Pointern 
gearbeitet werden, die Einzelwerte eines Datensatzes kommen dann direkt 
hintereinander ins RAM und können mit LD reg,x+ angesprochen werden, das 
Ergebnis bekommt einen eigenen RAM-Bereich und wird mit einem eigenen 
Pointer adressiert.

Du willst den Mittelwert aus 3 Werten. Warum nicht aus 2 oder 4? 
Mittelwert bildest Du durch Addition der Einzelwerte und Division durch 
die Anzahl der Werte. Der AVR kann sehr gut durch 2 oder 4 dividieren 
(LSR/ROR), aber nur sehr umständlich durch 3. Man kann sich das Leben 
auch unnötig schwer machen.

Mehr kann ich jetzt nicht sagen, denn Deine Frage ist wirklich recht 
konfus formuliert. Formuliere sie neu und gib Dir etwas Mühe, sie 
unmissverständlich zu formulieren, vermutlich fällt Dir dabei bereits 
die Lösung ein.

...

[obake (Gast)]

Hallo Hannes,

> ... habe ich im Gegensatz zu obake mitbekommen, dass...

René  schreibt: "Assembler". Du schreibst: Ich bin auf einem Ego-Trip.

[obake (Gast)]

Entschuldigung; bitte lesen: Beitrag "Umgangston hier"

[R--- S. (rene66)]

Leute der Umgangston ist mir egal das Ergebnis zählt.

@Hannes danke für die Infos

ich möchte aus den farblich hinterlegten bereichen die aus je 8 x 3 
Werten bestehen je einen Mittelwert je Gruppe A B und C erhalten.

Also 8 x A = 8 Werte A addieren / Anzahl = Mittelwert A und im Ram 
Speichern
     8 x B = 8 Werte B addieren / Anzahl = Mittelwert B ...
     8 x C = 8 Werte C addieren / Anzahl = Mittelwert C ...

und weiter zum nächsten Bereich  3 x 8 Byte (nächste Farbe)

[Hannes L. (hannes)]

René Schink wrote:
> Leute der Umgangston ist mir egal das Ergebnis zählt.
>
> @Hannes danke für die Infos
>
> ich möchte aus den farblich hinterlegten bereichen die aus je 8 x 3
> Werten bestehen je einen Mittelwert je Gruppe A B und C erhalten.
>
> Also 8 x A = 8 Werte A addieren / Anzahl = Mittelwert A und im Ram
> Speichern
>      8 x B = 8 Werte B addieren / Anzahl = Mittelwert B ...
>      8 x C = 8 Werte C addieren / Anzahl = Mittelwert C ...
>
> und weiter zum nächsten Bereich  3 x 8 Byte (nächste Farbe)

Ich gehe mal davon aus, dass jeder "Wert" ein Byte ist und dass die drei 
Bytes auch drei unterschiedliche Werte repräsentieren und nicht drei 
Bytes eines großen Wertes (dann müsste man Überträge berücksichtigen).

Ich würde die Datem im RAM so organisieren, dass jeweils 9 Bytes 
hintereinander einen "Satz" ergeben. Das erste Byte ist dann jeweils das 
Ergebnis (Mittelwert), dann folgen die 8 Einzelbytes. Nach Gruppe A 
kommt Gruppe B, dann Guppe C, danach wieder Gruppe A der nächsten Farbe.

Der Job der Mittelwertbildung macht nun Folgendes:

mach_mittelwerte:  ;Aufruflabel
 ldi yl,low(daten)     ;Pointer (Y oder Z, X geht nicht) auf
 ldi yh,high(daten)    ;Beginn des ersten Datensatzes positionieren
mach_next_mw:      ;Schleifenbeginn
 clr sum_l             ;2 Hilfsregister (Zwischensumme) bereitstellen
 clr sum_h             ;und löschen
 ldd tmp,y+1           ;Wert lesen, Byte 1
 add sum_l,tmp         ;Wert aufsummieren
; adc sum_h,null        ;evtl. Übertrag auch (beim ersten mal noch nicht)
 ldd tmp,y+2           ;Wert lesen, Byte 2
 add sum_l,tmp         ;Wert aufsummieren
 adc sum_h,null        ;evtl. Übertrag auch
 ldd tmp,y+3           ;Wert lesen, Byte 3
 add sum_l,tmp         ;Wert aufsummieren
 adc sum_h,null        ;evtl. Übertrag auch
 ldd tmp,y+4           ;Wert lesen, Byte 4
 add sum_l,tmp         ;Wert aufsummieren
 adc sum_h,null        ;evtl. Übertrag auch
 ldd tmp,y+5           ;Wert lesen, Byte 5
 add sum_l,tmp         ;Wert aufsummieren
 adc sum_h,null        ;evtl. Übertrag auch
 ldd tmp,y+6           ;Wert lesen, Byte 6
 add sum_l,tmp         ;Wert aufsummieren
 adc sum_h,null        ;evtl. Übertrag auch
 ldd tmp,y+7           ;Wert lesen, Byte 7
 add sum_l,tmp         ;Wert aufsummieren
 adc sum_h,null        ;evtl. Übertrag auch
 ldd tmp,y+8           ;Wert lesen, Byte 8
 add sum_l,tmp         ;Wert aufsummieren
 adc sum_h,null        ;evtl. Übertrag auch
 ;nun sind alle 8 Werte aufsummiert, eine Schleife dafür hätte mehr
 ;Rechenzeit gekostet
 lsr sum_h             ;durch 2
 ror sum_l             ;teilen (2)
 lsr sum_h             ;durch 2
 ror sum_l             ;teilen (4)
 lsr sum_h             ;durch 2
 ror sum_l             ;teilen (8)
 ;Mittelwert steht nun in sum_l
 std y+0,sum_l         ;Mittelwert an Pointerposition speichern
 adiw yh:yl,9          ;Pointer um 9 Byte-Positionen erhöhen
 cpi yl,low(daten + ds*9)  ;Auf Ende (Basisadresse Daten + Anzahl
 brne mach_next_mw     ;Datensätze * 9 Bytes) prüfen (ungleich, nochmal...)
 cpi yh,high(daten + ds*9) ;Highbyte auch auf Ende 
 brne mach_next_mw     ;prüfen (ungleich, nochmal...)
 ret                   ;fertig...

Der Code ist einfach ungetestet dahingeschrieben und kann noch Fehler 
enthalten, Du solltest ihn also prüfen. Ich habe in fast jedem Programm 
ein unteres Register namens "null" das immer den Wert 0 hat. Das 
erleichtert das Aufaddieren des Carry-Flags (Übertrag).

Ich hoffe, ich konnte helfen, Deine Denkblockade zu lösen.

...