Programmierung einer Fräsensteuerung

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
Bild hier  

(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!)

Stichwort Bresenham

mfg

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!

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:

Code:

---

/************************************************************************
*                                                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?

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

Zitat:

---

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.

Code:

---

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>

---