Programmierung einer Fräsensteuerung

[Jacob2]

Hallo liebe Bastler,
ich baue schon seit einer geraumen Zeit an einer einfachen Fräse, mit der ich einmal schnell meine Prototypenplatinen herstellen will (nix SMD =; zum Glück!). Da ich bei der Fräse so viel wie möglich selbst machen will, stehe ich nun vor der Frage, wie ich die Software zur Fräsensteuerung machen will.

Mein derzeitiger Stand: Die Hardware habe ich soweit, dass drei Schritt/Richtungssteuerungen an einem ATmega8 angeschlossen sind. Von der Layoutsoftware bekomme ich HPGL-Code, d.h. eigentlich nur 3 unterschiedliche Befehle: Anheben, Absenken und Bewegung zur absoluten/relativen Position (lässt sich ja umrechnen).


Zurück zum Thema: Mein Problem liegt nun in der Berechnung der Schritte bei einer Schrägen Bewegung, d.h. bei der Fahrt zu absoluten oder relativen Koordinaten. Mal angenommen der zu fräsende Weg ist deltaX=5 und deltaY=8 (Einheit z.B. Schritte), also eine Schräge! Ich müsste also in der gleichen Zeit 5 Schritte in X und 8 Schritte in Y Richtung machen. Mit anderen Worten bei einem Schritt in X-Richtung, 1,6 Schritte in Y-Richtung! Aber ich kann ja keine gebrochenen Schritte machen, sondern nur ganze! #-o
Ich hatte mir das nun so gedacht, dass ich den Rest hinterm Komma immer solange addiere, bis wieder ein ganzer Schritt zusammengekommen ist (also erst 1 Schritt X, 1 Schritt Y solange bis 1 Schritt X, 2 Schritte Y usw.).

Allerdings bin ich nicht sicher, ob das so die beste Lösung ist... Eventuell hat jemand von euch Ideen, die mir weiterhelfen können???
Falls nicht, bräuchte ich eure Unterstützung bei der Umsetzung obiger Idee in C-Code. Kommazahlen sind ja auf dem µC immer nicht so toll und vielleicht müsste/sollte ich da auch was mit Interrupts machen... Dazu kommt das man bei Berechnungen keine großartigen Funktionen hat (Winkelfunktionen, Runden usw.)!


Als Abschluss hab ich noch ein Bild von der Fräse bis jetzt, denn Bilder mag ich bei euren Posts auch immer sehr gerne :D
http://www.bilder-hochladen.net/files/thumbs/7cln-7.jpg (http://www.bilder-hochladen.net/files/7cln-7-jpg.html)

(Falls es jemanden interessiert: ich habe ein kleines Programm zur Simulation von mit Target erzeugten HPGL-Code geschrieben. Muss nur noch hier im Downloadbereich (-> andere Dateien) freigegeben werden. Feedback würde mich natürlich freuen!)

[Netzman]

Stichwort Bresenham

mfg

[Jacob2]

Danke! Das hört sich schon sehr gut an! Wenn ich den Namen mal früher gewusst hätte...

Muss mich jetzt mal etwas einarbeiten!

[Jacob2]

Ok,
dank dem Stichwort von Netzman (danke nochmal, das war genau das Richtige!) habe ich jetzt etwas mit dem Bresenham gebastelt. Den Algorithmus hab ich von hier http://de.wikipedia.org/wiki/Bresenham-Algorithmus abgeguckt:


/************************************************** **********************
* Fräsensoftware 1.0 *
* Autor: Jacob Seibert *
* Datum: 22.03.2010 *
* IDE: AVR Studio 4.16 *
* *
* Mit Bresenham-Algorithmus (abgeleitet von Wikipedia) *
************************************************** ***********************/
#include <avr/io.h>
#define F_CPU 1000000UL /* Quarz mit 1 MHz (intern)*/
#include <util/delay.h>

/*Define-Teil*/
#define _FULLSTEPMODUS 1
#define _ENABLED 1
#define _WAIT_MS 3
#define _X_MOTOR 1
#define _Y_MOTOR 2
#define _Z_MOTOR 0

int akt_x = 1000, akt_y = 1000;/*aktuelle Koordinaten*/

/*Funktion zur Generation eines Schrittes. Parameter: Motor und Richtung*/
void step (uint8_t motor, uint8_t direction)
{
switch(motor)/*Motor wählen*/
{
case _Z_MOTOR:
if(direction == 1)/*Richtung wählen*/
{
PORTC |= (1<<PC1);
}
else
{
PORTC &= ~(1<<PC1);
}
PORTC &= ~(1<<PC0);
_delay_ms(_WAIT_MS);
PORTC |= (1<<PC0);
break;

case _X_MOTOR:
if(direction == 1)/*Richtung wählen*/
{
PORTB |= (1<<PB1);
}
else
{
PORTB &= ~(1<<PB1);
}
PORTB &= ~(1<<PB0);
_delay_ms(_WAIT_MS);
PORTB |= (1<<PB0);
break;

case _Y_MOTOR:
if(direction == 1)/*Richtung wählen*/
{
PORTB |= (1<<PB4);
}
else
{
PORTB &= ~(1<<PB4);
}
PORTB &= ~(1<<PB3);
_delay_ms(_WAIT_MS);
PORTB |= (1<<PB3);
}
};

/*Signum (Mathematik)*/
int sgn (int x)
{
return (x > 0) ? 1 : (x < 0) ? -1 : 0;
};

/*--------------------------------------------------------------
* Bresenham-Algorithmus: Linien auf Raster zeichnen
*
* Eingabeparameter:
* int xstart, ystart = Koordinaten des Startpunkts
* int xend, yend = Koordinaten des Endpunkts
*
* Ausgabe:
* void step()
*---------------------------------------------------------------
*/
void abs_koo (uint16_t xstart, uint16_t ystart, uint16_t xend, uint16_t yend)
{
int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;

/* Entfernung in beiden Dimensionen berechnen */
dx = xend - xstart;
dy = yend - ystart;

/* Vorzeichen des Inkrements bestimmen */
incx = sgn(dx);
incy = sgn(dy);
if(dx<0)
{
dx = -dx;
}
if(dy<0)
{
dy = -dy;
}

/* feststellen, welche Entfernung größer ist */
if (dx>dy)
{
/* x ist schnelle Richtung */
pdx=incx;
pdy=0; /* pd. ist Parallelschritt */
ddx=incx;
ddy=incy; /* dd. ist Diagonalschritt */
es =dy;
el =dx; /* Fehlerschritte schnell, langsam */
}
else
{
/* y ist schnelle Richtung */
pdx=0;
pdy=incy; /* pd. ist Parallelschritt */
ddx=incx;
ddy=incy; /* dd. ist Diagonalschritt */
es =dx;
el =dy; /* Fehlerschritte schnell, langsam */
}

/* Initialisierungen vor Schleifenbeginn */
x = xstart;
y = ystart;
err = el/2;

/* Pixel berechnen */
for(t=0; t<el; ++t) /* t zaehlt die Pixel, el ist auch Anzahl */
{
/* Aktualisierung Fehlerterm */
err -= es;
if(err<0)
{
/* Fehlerterm wieder positiv (>=0) machen */
err += el;
/* Schritt in langsame Richtung, Diagonalschritt */
x += ddx;
y += ddy;
if (xend>xstart)/*X-Richtung ist positiv*/
{
step(_X_MOTOR, 1);
}
else/*Y_Richtung ist negativ*/
{
step(_X_MOTOR, 0);
}
if(yend>ystart)/*Y_Richtung ist positiv*/
{
step(_Y_MOTOR, 1);
}
else/*Y_Richtung ist negativ*/
{
step(_Y_MOTOR, 0);
}
}
else
{
/* Schritt in schnelle Richtung, Parallelschritt */
x += pdx;
y += pdy;
if(dx>dy)/*X ist schnelle Richtung*/
{
if (xend>xstart)/*X-Richtung ist positiv*/
{
step(_X_MOTOR, 1);
}
else/*Y_Richtung ist negativ*/
{
step(_X_MOTOR, 0);
}
}
else/*Y ist schnelle Richtung*/
{
if(yend>ystart)/*Y_Richtung ist positiv*/
{
step(_Y_MOTOR, 1);
}
else/*Y_Richtung ist negativ*/
{
step(_Y_MOTOR, 0);
}
}
}
}
};

int main (void)
{
/*Initialisierungen*/
DDRC |= (1<<PC1) | (1<<PC2) | (1<<PC0); /*1 - EN/CW-CCW/CLK*/
DDRD |= (1<<PD7); /*HALF/FULL*/
DDRB |= (1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3) | (1<<PB4) | (1<<PB5);/*2/3 - EN/CW-CCW/CLK*/
if(_FULLSTEPMODUS == 1)
{
PORTD &= ~(1<<PD7); /*FULLstep-Modus*/
}
else
{
PORTD |= (1<<PD7); /*HALFstep-Modus*/
}
if(_ENABLED == 1)
{
PORTC |= (1<<PC2); /*1 - EN set*/
PORTB |= (1<<PB2) | (1<<PB5); /*2/3 - EN set*/
}
else
{
PORTC &= ~(1<<PC2); /*1 - EN clear*/
PORTB &= ~((1<<PB2) | (1<<PB5)); /*2/3 - EN clear*/
}

/*Main-Teil*/
abs_koo(akt_x, akt_y, 2000, 2000);
}



Allerdings fürchte ich, dass mein Compiler (AVR Studio 4) da irgendwie den Großteil wegoptimiert (-Os eingestellt), denn dieses Programm kann doch unmöglich nur 526 Bytes (nur 6,4% von ATmega8) groß sein!

Kann jemand etwas entdecken, warum das wegoptimiert wird?

[Peter1060]

moin moin,

ja ja, die Programmgröße...eine unheimliche Größe. Überflüssiges optimiert der Compiler weg...warum wohl?

526 Bytes sind in Assembler sehr viel.
Meine Floatunit hat ca 32 Funktionen und ist (alles in 8051 Assembler) ca 3,7KB.
Die reine Fräsensteuerung mit G-Codeinterpreter und Fräserradienkorrektur ist ca. 18KB.

Mit Gruß
Peter

[sternst]

Kann jemand etwas entdecken, warum das wegoptimiert wird?
Das hier ist der Inhalt dieser paar hundert Bytes. Sieht für mich so aus, als ob alles da ist.


Sections:
Idx Name Size VMA LMA File off Algn
0 .data 00000004 00800100 00000218 0000028c 2**0
CONTENTS, ALLOC, LOAD, DATA
1 .text 00000218 00000000 00000000 00000074 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
2 .debug_aranges 00000020 00000000 00000000 00000290 2**0
CONTENTS, READONLY, DEBUGGING
3 .debug_pubnames 0000004c 00000000 00000000 000002b0 2**0
CONTENTS, READONLY, DEBUGGING
4 .debug_info 00000314 00000000 00000000 000002fc 2**0
CONTENTS, READONLY, DEBUGGING
5 .debug_abbrev 00000155 00000000 00000000 00000610 2**0
CONTENTS, READONLY, DEBUGGING
6 .debug_line 0000029e 00000000 00000000 00000765 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_frame 00000050 00000000 00000000 00000a04 2**2
CONTENTS, READONLY, DEBUGGING
8 .debug_str 00000115 00000000 00000000 00000a54 2**0
CONTENTS, READONLY, DEBUGGING
9 .debug_loc 00000280 00000000 00000000 00000b69 2**0
CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
0: 19 c0 rjmp .+50 ; 0x34 <__ctors_end>
2: 2b c0 rjmp .+86 ; 0x5a <__bad_interrupt>
4: 2a c0 rjmp .+84 ; 0x5a <__bad_interrupt>
6: 29 c0 rjmp .+82 ; 0x5a <__bad_interrupt>
8: 28 c0 rjmp .+80 ; 0x5a <__bad_interrupt>
a: 27 c0 rjmp .+78 ; 0x5a <__bad_interrupt>
c: 26 c0 rjmp .+76 ; 0x5a <__bad_interrupt>
e: 25 c0 rjmp .+74 ; 0x5a <__bad_interrupt>
10: 24 c0 rjmp .+72 ; 0x5a <__bad_interrupt>
12: 23 c0 rjmp .+70 ; 0x5a <__bad_interrupt>
14: 22 c0 rjmp .+68 ; 0x5a <__bad_interrupt>
16: 21 c0 rjmp .+66 ; 0x5a <__bad_interrupt>
18: 20 c0 rjmp .+64 ; 0x5a <__bad_interrupt>
1a: 1f c0 rjmp .+62 ; 0x5a <__bad_interrupt>
1c: 1e c0 rjmp .+60 ; 0x5a <__bad_interrupt>
1e: 1d c0 rjmp .+58 ; 0x5a <__bad_interrupt>
20: 1c c0 rjmp .+56 ; 0x5a <__bad_interrupt>
22: 1b c0 rjmp .+54 ; 0x5a <__bad_interrupt>
24: 1a c0 rjmp .+52 ; 0x5a <__bad_interrupt>
26: 19 c0 rjmp .+50 ; 0x5a <__bad_interrupt>
28: 18 c0 rjmp .+48 ; 0x5a <__bad_interrupt>
2a: 17 c0 rjmp .+46 ; 0x5a <__bad_interrupt>
2c: 16 c0 rjmp .+44 ; 0x5a <__bad_interrupt>
2e: 15 c0 rjmp .+42 ; 0x5a <__bad_interrupt>
30: 14 c0 rjmp .+40 ; 0x5a <__bad_interrupt>
32: 13 c0 rjmp .+38 ; 0x5a <__bad_interrupt>

00000034 <__ctors_end>:
34: 11 24 eor r1, r1
36: 1f be out 0x3f, r1 ; 63
38: cf ef ldi r28, 0xFF ; 255
3a: d4 e0 ldi r29, 0x04 ; 4
3c: de bf out 0x3e, r29 ; 62
3e: cd bf out 0x3d, r28 ; 61

00000040 <__do_copy_data>:
40: 11 e0 ldi r17, 0x01 ; 1
42: a0 e0 ldi r26, 0x00 ; 0
44: b1 e0 ldi r27, 0x01 ; 1
46: e8 e1 ldi r30, 0x18 ; 24
48: f2 e0 ldi r31, 0x02 ; 2
4a: 02 c0 rjmp .+4 ; 0x50 <.do_copy_data_start>

0000004c <.do_copy_data_loop>:
4c: 05 90 lpm r0, Z+
4e: 0d 92 st X+, r0

00000050 <.do_copy_data_start>:
50: a4 30 cpi r26, 0x04 ; 4
52: b1 07 cpc r27, r17
54: d9 f7 brne .-10 ; 0x4c <.do_copy_data_loop>
56: c2 d0 rcall .+388 ; 0x1dc <main>
58: dd c0 rjmp .+442 ; 0x214 <_exit>

0000005a <__bad_interrupt>:
5a: d2 cf rjmp .-92 ; 0x0 <__vectors>

0000005c <step>:
int akt_x = 1000, akt_y = 1000;/*aktuelle Koordinaten*/

/*Funktion zur Generation eines Schrittes. Parameter: Motor und Richtung*/
void step (uint8_t motor, uint8_t direction)
{
switch(motor)/*Motor wählen*/
5c: 81 30 cpi r24, 0x01 ; 1
5e: 89 f0 breq .+34 ; 0x82 <step+0x26>
60: 81 30 cpi r24, 0x01 ; 1
62: 18 f0 brcs .+6 ; 0x6a <step+0xe>
64: 82 30 cpi r24, 0x02 ; 2
66: 21 f5 brne .+72 ; 0xb0 <step+0x54>
68: 18 c0 rjmp .+48 ; 0x9a <step+0x3e>
{
case _Z_MOTOR:
if(direction == 1)/*Richtung wählen*/
6a: 61 30 cpi r22, 0x01 ; 1
6c: 11 f4 brne .+4 ; 0x72 <step+0x16>
{
PORTC |= (1<<PC1);
6e: 41 9a sbi 0x08, 1 ; 8
70: 01 c0 rjmp .+2 ; 0x74 <step+0x18>
}
else
{
PORTC &= ~(1<<PC1);
72: 41 98 cbi 0x08, 1 ; 8
}
PORTC &= ~(1<<PC0);
74: 40 98 cbi 0x08, 0 ; 8
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
76: 8e ee ldi r24, 0xEE ; 238
78: 92 e0 ldi r25, 0x02 ; 2
7a: 01 97 sbiw r24, 0x01 ; 1
7c: f1 f7 brne .-4 ; 0x7a <step+0x1e>
_delay_ms(_WAIT_MS);
PORTC |= (1<<PC0);
7e: 40 9a sbi 0x08, 0 ; 8
80: 08 95 ret
break;

case _X_MOTOR:
if(direction == 1)/*Richtung wählen*/
82: 61 30 cpi r22, 0x01 ; 1
84: 11 f4 brne .+4 ; 0x8a <step+0x2e>
{
PORTB |= (1<<PB1);
86: 29 9a sbi 0x05, 1 ; 5
88: 01 c0 rjmp .+2 ; 0x8c <step+0x30>
}
else
{
PORTB &= ~(1<<PB1);
8a: 29 98 cbi 0x05, 1 ; 5
}
PORTB &= ~(1<<PB0);
8c: 28 98 cbi 0x05, 0 ; 5
8e: 8e ee ldi r24, 0xEE ; 238
90: 92 e0 ldi r25, 0x02 ; 2
92: 01 97 sbiw r24, 0x01 ; 1
94: f1 f7 brne .-4 ; 0x92 <step+0x36>
_delay_ms(_WAIT_MS);
PORTB |= (1<<PB0);
96: 28 9a sbi 0x05, 0 ; 5
98: 08 95 ret
break;

case _Y_MOTOR:
if(direction == 1)/*Richtung wählen*/
9a: 61 30 cpi r22, 0x01 ; 1
9c: 11 f4 brne .+4 ; 0xa2 <step+0x46>
{
PORTB |= (1<<PB4);
9e: 2c 9a sbi 0x05, 4 ; 5
a0: 01 c0 rjmp .+2 ; 0xa4 <step+0x48>
}
else
{
PORTB &= ~(1<<PB4);
a2: 2c 98 cbi 0x05, 4 ; 5
}
PORTB &= ~(1<<PB3);
a4: 2b 98 cbi 0x05, 3 ; 5
a6: 8e ee ldi r24, 0xEE ; 238
a8: 92 e0 ldi r25, 0x02 ; 2
aa: 01 97 sbiw r24, 0x01 ; 1
ac: f1 f7 brne .-4 ; 0xaa <step+0x4e>
_delay_ms(_WAIT_MS);
PORTB |= (1<<PB3);
ae: 2b 9a sbi 0x05, 3 ; 5
b0: 08 95 ret

000000b2 <sgn>:
};

/*Signum (Mathematik)*/
int sgn (int x)
{
return (x > 0) ? 1 : (x < 0) ? -1 : 0;
b2: 18 16 cp r1, r24
b4: 19 06 cpc r1, r25
b6: 1c f4 brge .+6 ; 0xbe <sgn+0xc>
b8: 21 e0 ldi r18, 0x01 ; 1
ba: 30 e0 ldi r19, 0x00 ; 0
bc: 07 c0 rjmp .+14 ; 0xcc <sgn+0x1a>
be: 89 2b or r24, r25
c0: 19 f4 brne .+6 ; 0xc8 <sgn+0x16>
c2: 20 e0 ldi r18, 0x00 ; 0
c4: 30 e0 ldi r19, 0x00 ; 0
c6: 02 c0 rjmp .+4 ; 0xcc <sgn+0x1a>
c8: 2f ef ldi r18, 0xFF ; 255
ca: 3f ef ldi r19, 0xFF ; 255
};
cc: c9 01 movw r24, r18
ce: 08 95 ret

000000d0 <abs_koo>:
* Ausgabe:
* void step()
*---------------------------------------------------------------
*/
void abs_koo (uint16_t xstart, uint16_t ystart, uint16_t xend, uint16_t yend)
{
d0: 2f 92 push r2
d2: 3f 92 push r3
d4: 4f 92 push r4
d6: 5f 92 push r5
d8: 6f 92 push r6
da: 7f 92 push r7
dc: 8f 92 push r8
de: 9f 92 push r9
e0: af 92 push r10
e2: bf 92 push r11
e4: cf 92 push r12
e6: df 92 push r13
e8: ef 92 push r14
ea: ff 92 push r15
ec: 0f 93 push r16
ee: 1f 93 push r17
f0: df 93 push r29
f2: cf 93 push r28
f4: 00 d0 rcall .+0 ; 0xf6 <abs_koo+0x26>
f6: 00 d0 rcall .+0 ; 0xf8 <abs_koo+0x28>
f8: cd b7 in r28, 0x3d ; 61
fa: de b7 in r29, 0x3e ; 62
fc: 1c 01 movw r2, r24
fe: 2b 01 movw r4, r22
100: 3a 01 movw r6, r20
102: 49 01 movw r8, r18
int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;

/* Entfernung in beiden Dimensionen berechnen */
dx = xend - xstart;
dy = yend - ystart;
104: c9 01 movw r24, r18
106: 86 1b sub r24, r22
108: 97 0b sbc r25, r23
10a: 8a 01 movw r16, r20
10c: 02 19 sub r16, r2
10e: 13 09 sbc r17, r3
110: 17 ff sbrs r17, 7
112: 03 c0 rjmp .+6 ; 0x11a <abs_koo+0x4a>
114: 10 95 com r17
116: 01 95 neg r16
118: 1f 4f sbci r17, 0xFF ; 255
11a: 9c 83 std Y+4, r25 ; 0x04
11c: 8b 83 std Y+3, r24 ; 0x03
11e: 97 ff sbrs r25, 7
120: 05 c0 rjmp .+10 ; 0x12c <abs_koo+0x5c>
122: 90 95 com r25
124: 81 95 neg r24
126: 9f 4f sbci r25, 0xFF ; 255
128: 9c 83 std Y+4, r25 ; 0x04
12a: 8b 83 std Y+3, r24 ; 0x03
{
dy = -dy;
}

/* feststellen, welche Entfernung größer ist */
if (dx>dy)
12c: 8b 81 ldd r24, Y+3 ; 0x03
12e: 9c 81 ldd r25, Y+4 ; 0x04
130: 80 17 cp r24, r16
132: 91 07 cpc r25, r17
134: 24 f0 brlt .+8 ; 0x13e <abs_koo+0x6e>
136: 1a 83 std Y+2, r17 ; 0x02
138: 09 83 std Y+1, r16 ; 0x01
13a: 6c 01 movw r12, r24
13c: 05 c0 rjmp .+10 ; 0x148 <abs_koo+0x78>
13e: eb 81 ldd r30, Y+3 ; 0x03
140: fc 81 ldd r31, Y+4 ; 0x04
142: fa 83 std Y+2, r31 ; 0x02
144: e9 83 std Y+1, r30 ; 0x01
146: 68 01 movw r12, r16
}

/* Initialisierungen vor Schleifenbeginn */
x = xstart;
y = ystart;
err = el/2;
148: 76 01 movw r14, r12
14a: f5 94 asr r15
14c: e7 94 ror r14
14e: aa 24 eor r10, r10
150: bb 24 eor r11, r11
152: 2a c0 rjmp .+84 ; 0x1a8 <abs_koo+0xd8>

/* Pixel berechnen */
for(t=0; t<el; ++t) /* t zaehlt die Pixel, el ist auch Anzahl */
{
/* Aktualisierung Fehlerterm */
err -= es;
154: 89 81 ldd r24, Y+1 ; 0x01
156: 9a 81 ldd r25, Y+2 ; 0x02
158: e8 1a sub r14, r24
15a: f9 0a sbc r15, r25
if(err<0)
15c: f7 fe sbrs r15, 7
15e: 0c c0 rjmp .+24 ; 0x178 <abs_koo+0xa8>
{
/* Fehlerterm wieder positiv (>=0) machen */
err += el;
160: ec 0c add r14, r12
162: fd 1c adc r15, r13
/* Schritt in langsame Richtung, Diagonalschritt */
x += ddx;
y += ddy;
if (xend>xstart)/*X-Richtung ist positiv*/
164: 26 14 cp r2, r6
166: 37 04 cpc r3, r7
168: 18 f4 brcc .+6 ; 0x170 <abs_koo+0xa0>
{
step(_X_MOTOR, 1);
16a: 81 e0 ldi r24, 0x01 ; 1
16c: 61 e0 ldi r22, 0x01 ; 1
16e: 02 c0 rjmp .+4 ; 0x174 <abs_koo+0xa4>
}
else/*Y_Richtung ist negativ*/
{
step(_X_MOTOR, 0);
170: 81 e0 ldi r24, 0x01 ; 1
172: 60 e0 ldi r22, 0x00 ; 0
174: 73 df rcall .-282 ; 0x5c <step>
176: 0c c0 rjmp .+24 ; 0x190 <abs_koo+0xc0>
else
{
/* Schritt in schnelle Richtung, Parallelschritt */
x += pdx;
y += pdy;
if(dx>dy)/*X ist schnelle Richtung*/
178: eb 81 ldd r30, Y+3 ; 0x03
17a: fc 81 ldd r31, Y+4 ; 0x04
17c: e0 17 cp r30, r16
17e: f1 07 cpc r31, r17
180: 3c f4 brge .+14 ; 0x190 <abs_koo+0xc0>
{
if (xend>xstart)/*X-Richtung ist positiv*/
182: 26 14 cp r2, r6
184: 37 04 cpc r3, r7
186: 10 f4 brcc .+4 ; 0x18c <abs_koo+0xbc>
{
step(_X_MOTOR, 1);
188: 81 e0 ldi r24, 0x01 ; 1
18a: 06 c0 rjmp .+12 ; 0x198 <abs_koo+0xc8>
}
else/*Y_Richtung ist negativ*/
{
step(_X_MOTOR, 0);
18c: 81 e0 ldi r24, 0x01 ; 1
18e: 07 c0 rjmp .+14 ; 0x19e <abs_koo+0xce>
}
}
else/*Y ist schnelle Richtung*/
{
if(yend>ystart)/*Y_Richtung ist positiv*/
190: 48 14 cp r4, r8
192: 59 04 cpc r5, r9
194: 18 f4 brcc .+6 ; 0x19c <abs_koo+0xcc>
{
step(_Y_MOTOR, 1);
196: 82 e0 ldi r24, 0x02 ; 2
198: 61 e0 ldi r22, 0x01 ; 1
19a: 02 c0 rjmp .+4 ; 0x1a0 <abs_koo+0xd0>
}
else/*Y_Richtung ist negativ*/
{
step(_Y_MOTOR, 0);
19c: 82 e0 ldi r24, 0x02 ; 2
19e: 60 e0 ldi r22, 0x00 ; 0
1a0: 5d df rcall .-326 ; 0x5c <step>
x = xstart;
y = ystart;
err = el/2;

/* Pixel berechnen */
for(t=0; t<el; ++t) /* t zaehlt die Pixel, el ist auch Anzahl */
1a2: 08 94 sec
1a4: a1 1c adc r10, r1
1a6: b1 1c adc r11, r1
1a8: ac 14 cp r10, r12
1aa: bd 04 cpc r11, r13
1ac: 9c f2 brlt .-90 ; 0x154 <abs_koo+0x84>
step(_Y_MOTOR, 0);
}
}
}
}
};
1ae: 0f 90 pop r0
1b0: 0f 90 pop r0
1b2: 0f 90 pop r0
1b4: 0f 90 pop r0
1b6: cf 91 pop r28
1b8: df 91 pop r29
1ba: 1f 91 pop r17
1bc: 0f 91 pop r16
1be: ff 90 pop r15
1c0: ef 90 pop r14
1c2: df 90 pop r13
1c4: cf 90 pop r12
1c6: bf 90 pop r11
1c8: af 90 pop r10
1ca: 9f 90 pop r9
1cc: 8f 90 pop r8
1ce: 7f 90 pop r7
1d0: 6f 90 pop r6
1d2: 5f 90 pop r5
1d4: 4f 90 pop r4
1d6: 3f 90 pop r3
1d8: 2f 90 pop r2
1da: 08 95 ret

000001dc <main>:

int main (void)
{
/*Initialisierungen*/
DDRC |= (1<<PC1) | (1<<PC2) | (1<<PC0); /*1 - EN/CW-CCW/CLK*/
1dc: 87 b1 in r24, 0x07 ; 7
1de: 87 60 ori r24, 0x07 ; 7
1e0: 87 b9 out 0x07, r24 ; 7
DDRD |= (1<<PD7); /*HALF/FULL*/
1e2: 57 9a sbi 0x0a, 7 ; 10
DDRB |= (1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3) | (1<<PB4) | (1<<PB5);/*2/3 - EN/CW-CCW/CLK*/
1e4: 84 b1 in r24, 0x04 ; 4
1e6: 8f 63 ori r24, 0x3F ; 63
1e8: 84 b9 out 0x04, r24 ; 4
if(_FULLSTEPMODUS == 1)
{
PORTD &= ~(1<<PD7); /*FULLstep-Modus*/
1ea: 5f 98 cbi 0x0b, 7 ; 11
{
PORTD |= (1<<PD7); /*HALFstep-Modus*/
}
if(_ENABLED == 1)
{
PORTC |= (1<<PC2); /*1 - EN set*/
1ec: 42 9a sbi 0x08, 2 ; 8
PORTB |= (1<<PB2) | (1<<PB5); /*2/3 - EN set*/
1ee: 85 b1 in r24, 0x05 ; 5
1f0: 84 62 ori r24, 0x24 ; 36
1f2: 85 b9 out 0x05, r24 ; 5
PORTC &= ~(1<<PC2); /*1 - EN clear*/
PORTB &= ~((1<<PB2) | (1<<PB5)); /*2/3 - EN clear*/
}

/*Main-Teil*/
abs_koo(akt_x, akt_y, 2000, 2000);
1f4: 60 91 02 01 lds r22, 0x0102
1f8: 70 91 03 01 lds r23, 0x0103
1fc: 80 91 00 01 lds r24, 0x0100
200: 90 91 01 01 lds r25, 0x0101
204: 40 ed ldi r20, 0xD0 ; 208
206: 57 e0 ldi r21, 0x07 ; 7
208: 20 ed ldi r18, 0xD0 ; 208
20a: 37 e0 ldi r19, 0x07 ; 7
20c: 61 df rcall .-318 ; 0xd0 <abs_koo>
}
20e: 80 e0 ldi r24, 0x00 ; 0
210: 90 e0 ldi r25, 0x00 ; 0
212: 08 95 ret

00000214 <_exit>:
214: f8 94 cli

00000216 <__stop_program>:
216: ff cf rjmp .-2 ; 0x216 <__stop_program>