Gegenüberstellung von Assembler- und C-Programmierung

Transkript

1 Gegenüberstellung von Assembler- und C-Programmierung Assembler-Version C-Version org 8000h #pragma code=0x8000 #pragma xdata=0x2000 INPUT equ 0e081h OUTPUT equ 0e082h neu: mov dptr,#input movx ; eingabeport lesen mov dptr,#output ; ausgabeport schreiben jmp neu end xdata char input at 0xe081, output at 0xe082; char a; main( ) { do{ a = input; // oder input = output ohne a! output = a; while(1); Do-While-Schleife (hier als Endlosschleife): a = input output = a Wiederhole immer wieder Hier steht normalerweise die Bedingung, die erfüllt sein muß, damit die Schleife erneut bearbeitet wird. Bei Nichterfülltheit dieser Bedingung wird die Schleife abgebrochen!

2 Programm DA-Wandler (Zählverfahren) Assemblerversion org 8000h start: mov dptr,#0e040h mov b,#0 next: mov a,b ;digitaler Wert an DAW call warte movx ;fertig? jb acc.0,fertig inc b jmp next fertig: mov a,b mov dptr,#0e082h jmp start warte: mov r0,#0ffh w: djnz r0,w ret end C-Version #pragma code=0x8000 #pragma xdata=0x2000 xdata char dawandler at 0xe040, output at 0xe082; data char daten at 0x20; bit d0 at 0; char digitalwert; void warte (void) { char n; for (n=255; n>0; n--); main( ) { do{ digitalwert=0; do { dawandler=digitalwert; warte( ); daten=dawandler; digitalwert++; while(d0==0); // siehe Hinweis output=digitalwert-1; while(1);

3 Eigene Funktionen in C: 1. Ohne Rückgabewert (ohne Ergebnis) //in Pascal Prozeduren: xdata char output at 0xe082; void summe ( int a, int b) { output = a+b; a und b sind Platzhalter Rückgabe: nichts Eingabe: 2 Int-Zahlen int x,y; x=10; y=20; Funktionsaufruf: summe(x,y); x y 2. Mit Rückgabewert ( Ergebnis) // in Pascal Funktionen : int summe ( int a, int b) { int erg; erg = a+b; return erg; a und b sind Platzhalter Rückgabe: int-zahl Eingabe: 2 Int-Zahlen int x,y,z; x=10; y=20; Funktionsaufruf: z = summe(x,y); x y 3. Ohne Eingabewerte und ohne Rückgabewert // in Pascal Prozedur z.b.: clrscr; void summe ( void) { z=x+y; Rückgabe: keine Eingaben: keine int x,y,z; x=10; y=2 Funktionsaufruf: summe( ); // in C also clrscr( );

4 For-Schleife: Diese Schleife ist kopfgesteuert. Das bedeutet: Vor Bearbeitung der Schleife wird zuerst überprüft, ob die Bearbeitungsbedingung erfüllt ist. Ist diese Bedingung nicht erfüllt (Das kann auch beim erstenmal zutreffen!), wird die Schleife abgebrochen und das Programm nach der Schleife fortgesetzt. Syntax: int n; for ( n=0 ; n<100 ; n++) { Anweisung1 ; Anweisung2; 1 Startwert der Scheifenvariablen 2 Schleifenbedingung 3 Veränderung der Schleifenvariablen While-Schleife: Diese Schleife ist auch kopfgesteuert.. Das heißt: Die Bedingung wird jeweils vor den Schleifendurchläufen überprüft. Syntax: while ( <Bedingung> ) { Anweisung1 ; Anweisung2; Do-While-Schleife: Diese Schleife ist fußgesteuert. Das heißt: Die Bedingung wird jeweils nach den Schleifendurchläufen überprüft. Syntax: do { Anweisung1 ; Anweisung2; while ( <Bedingung> ) ;

5 Struktogramme zu den Schleifentypen: For-Schleife for( n=0; n<10; n++) Anweisung1 Anweisung2 While-Schleife while ( <Bedingung> ) Anweisung1 Anweisung2 Do-While-Schleife Anweisung1 Anweisung2 while ( <Bedingung> )

6 Die Bedingungsoperatoren: Operator Beispiel Bedeutung == a == b gleich!= a!= b ungleich > a > 10 größer < a < 10 kleiner <= a <= b kleiner oder gleich >= a >= b größer oder gleich && a==10 && b=10 logisch und a==10 b=10 logisch oder!!(a==10 && b==10) logische Verneinung Einfache Datentypen in C51: Float für reelle Zahlen (Zahlen mit Nachkomma (Punkt!)-stellen: float a,b; a= 12.7; b= 2*a+ Integer für ganze (pos. + neg.) 16-Bit-Zahlen: int k,l; k=100; l=-34; Char für 8-Bit-Zahlen und für Zeichen: char beit; beit=200; In C51 wird der Speicherort durch Vorsätze vor dem Typ spezifiziert: data int a im internen Datenspeicher (Adressen 0 bis 127) idata int b im internen Datenspeicher (Adressen 128 bis 255) xdata int c im externen Datenspeicher ( 64 Kb) Darüber hinaus kann die exakte Speicheradresse festgelegt werden durch at <Adresse>: xdata char Eingabeport at 0xe081, Ausgabeport at 0xe082;

7 AD-Wandler nach dem Wägeverfahren (sukzessive Approximation) Assemblerversion org 8000h start: mov dptr,#0e040h mov b,#0 setb b.7 jb acc.0,minusb7 b6: setb b.6 jb acc.0,minusb6 b5: setb b.5 jb acc.0,minusb5 b4: setb b.4 jb acc.0,minusb4 b3: setb b.3 jb acc.0,minusb3 b2: setb b.2 jb acc.0,minusb2 b1: setb b.1 jb acc.0,minusb1 b0: setb b.0 jb acc.0,minusb0 jmp fertig minusb7: clr b.7 jmp b6 minusb6: clr b.6 jmp b5 minusb5: clr b.5 jmp b4 minusb4: clr b.4 C-Version #pragma code=0x8000 #pragma xdata0x2000 xdata char dawandler at 0xe040, output at 0xe082; data char daten at 0x20; bit d0 at 0; char digitalwert, gewicht; void warte(void){ char n; for (n=255;n>0;n--); main(){ do{ digitalwert=0; gewicht=0x80; do { digitalwert += gewicht; dawandler=digitalwert; warte(); daten=dawandler; if(d0==1) digitalwert -= gewicht; gewicht=gewicht/2; while (gewicht>0); output=digitalwert; while (1);

8 jmp b3 minusb3: clr b.3 jmp b2 minusb2: clr b.2 jmp b1 minusb1: clr b.1 jmp b0 minusb0: clr b.0 fertig: mov a,b mov dptr,#0e082h jmp start messen: mov a,b ;digitaler Wert an ;DAW call warte movx ;Rückmeldung von ;DAW ret warte: mov r0,#0ffh w: djnz r0,w ret end