Von Assembler nach C

was das programm macht versteh ich schon... ich hab jetzt z.B. probleme 
den
code richtig zu übersetzen weil es doch so ein paar unterschiede gibt.

Beispiel:

         PUSH  AKKU_1
   PUSH  AKKU_2
   LD  AKKU_1, X
   INC  XL
   LD  AKKU_2, X
   DEC  XL
   CALL  DISP_HEX
   POP  AKKU_2
   POP  AKKU_1
********************************************************************

          LDI  ZL, LOW(ST_OFFSET*2)
    LDI  ZH, HIGH(ST_OFFSET*2)
***********************************************************************

PUSH und POP kann ich verachlässigen oder??
wie würde   LD  AKKU_1, X    und
LDI  ZL, LOW(ST_OFFSET*2) in C aussehen?

Wenn Du grundlegende Probleme mit Assembler hast, solltest Du Dich 
vielleicht erst mal in einen Assembler einarbeiten, bevor Du C 
programmierst. C ist keine Hochsprache, es ist eine Art 
"Makro-Assembler". Arrays gibts in C nicht, das sind nur Zeiger, und 
wenn Du über das Ende hinaus zugreifst, greifst Du auf was auch immer 
dahinter liegt zu. Wenn Dein Array auf dem Stack liegt (z.Bsp. bei 
lokalen Variablen) so liegt nach dem Array die Rücksprungadresse.

Falls Du aber wirklich eine 1:1 Umsetzung haben willst, dann scheibe Dir 
doch einfach ein Programm, welches das macht.
Im Prinzip musst Du nur das Programm zeilenweise einlesen, und die 
Kommentare entfernen, sowie den #includes folgen. #defines kannst Du als 
Makros übersetzen.
Zeilen mit
.cseg
und
.dseg
Schalten zwischen Programmspeicher und Datenspeicher um. Abhängig davon 
musst Du bei Labels entweder Sprunglabels in C oder Variablen anlegen.

Gut ist das dann nicht, aber die Aufgabe wäre erfüllt. Ich würde aber in 
Deiner Situation mir 90% der Zeit nehmen den existierenden Code zu 
verstehen, und ihn in der restlichen Zeit neu implementieren. Danach 
wirst Du besseren C-Code schreiben als vorher.

onno und Christian Berger.

Könnt ihr euch bitte mit eurem Halbwissen über C verziehen? Das gilt 
ganz besonders für onno.

Danke.

Ingmar H. schrieb:
> was das programm macht versteh ich schon... ich hab jetzt z.B. probleme
> den
> code richtig zu übersetzen weil es doch so ein paar unterschiede gibt.
>
> Beispiel:
>
>    PUSH  AKKU_1
>    PUSH  AKKU_2
>    LD  AKKU_1, X
>    INC  XL
>    LD  AKKU_2, X
>    DEC  XL
>    CALL  DISP_HEX
>    POP  AKKU_2
>    POP  AKKU_1

Das lässt sich so nicht "übersetzen".  Hier wird ein 16-Bit Wert 
indirekt über X geladen und vermutlich an DISP_HEX übergeben.

Ob der Wert übergeben wird — d.h. in DISP_HEX verwendet wird — ist an 
dem Code nicht zu sehen, ebenso ob DISP_HEX etwas zurückliefert oder 
Seiteneffekte hat.

Die Registerzuordnung in einem C-Programm erledigt der Compiler.  Das 
ist ja auch einer der Gründe, eine Compiler einzusetzen :-)

Einen 16-Bit Wert aus dem RAM zu lesen und damit eine Funktion 
aufzurufen sieht in C so aus:
 

1

#include <stdint.h>

2

3

extern void disp_hex (uint16_t);

4

5

void f1 (uint16_t *addr)

6

{

7

    disp_hex (*addr);

8

}

und avr-gcc übersetzt das zB so:
 

1

f1:

2

  movw r30,r24   ; , addr

3

  ld r24,Z   ; , *addr_1(D)

4

  ldd r25,Z+1   ; , *addr_1(D)

5

  jmp disp_hex

 
Du kannst also versuchen, dieses kleine C-Beispiel zu verstehen und auf 
deinen Fall anzupassen oder in eine größere Funktion einzubette.

>     LDI  ZL, LOW(ST_OFFSET*2)
>     LDI  ZH, HIGH(ST_OFFSET*2)

Dieses Beipiel ist mindestend genauso übel.

Ist der nach Z geladene Wert eine Adresse?
Oder eine Konstante, die zur Compilezeit bekannt ist?
Oder der Index in ein Array aus 16-Bit Werten?

Im einfachsten Fall ist der C-Code
 

1

#define ST_OFFSET (12345-123)

2

3

uint16_t f2 (void)

4

{

5

    return 2 * ST_OFFSET;

6

}

und wird zu:
 

1

f2:

2

  ldi r24,lo8(124)

3

  ldi r25,lo8(95)

4

  ret

 
Die Registerzuordnung ist wie gesagt Aufgabe des Compilers.

Ist ST_OFFSET ein Index in ein 16-Bit Array, und wird auf dem Array an 
dieser Stelle gelesen, dann:
 

1

extern uint16_t array[];

2

3

uint16_t f3 (void)

4

{

5

    return array[ST_OFFSET];

6

}

 
und das compiliert zu
 

1

f3:

2

  ldi r30,lo8(array+24444)

3

  ldi r31,hi8(array+24444)

4

  ld r24,Z   ; , array

5

  ldd r25,Z+1   ; , array

6

  ret

 
Als erstes musst du also das Programm abstrahieren und von der konkreten 
Registerverwendung, den Instruktionen, etc. loskommen und dir klarmachen

• Welche (globalen) Objekte und Datenstrukturen gibt es?
• Welche Funktion erfüllt welche Aufgaben?
• Welche Parameter bekommen die Funktionen?
• Und was geben sie zurückgeben?
• Welche globalen Variablen werden sie (falls überhaupt)
• Wie werden asynchrone Ereignisse (IRQs) verdaut?
• Was ist eine sinnvolle Strukturierung von alledem?

Danke ich werds versuchen umzusetzen....