-         

+ Antworten
Ergebnis 1 bis 6 von 6

Thema: Programmierung einer Fräsensteuerung

  1. #1
    Erfahrener Benutzer Begeisterter Techniker Avatar von Jacob2
    Registriert seit
    26.05.2007
    Ort
    Berlin
    Beiträge
    345

    Programmierung einer Fräsensteuerung

    Anzeige

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


    (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!)
    Roboter, CNC Fräse, Elektronik und Basteleien stelle ich auf meiner Website vor...

  2. #2
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    15.08.2004
    Ort
    Graz
    Beiträge
    342
    Stichwort Bresenham

    mfg

  3. #3
    Erfahrener Benutzer Begeisterter Techniker Avatar von Jacob2
    Registriert seit
    26.05.2007
    Ort
    Berlin
    Beiträge
    345
    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!
    Roboter, CNC Fräse, Elektronik und Basteleien stelle ich auf meiner Website vor...

  4. #4
    Erfahrener Benutzer Begeisterter Techniker Avatar von Jacob2
    Registriert seit
    26.05.2007
    Ort
    Berlin
    Beiträge
    345
    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 ATmega groß sein!

    Kann jemand etwas entdecken, warum das wegoptimiert wird?
    Roboter, CNC Fräse, Elektronik und Basteleien stelle ich auf meiner Website vor...

  5. #5
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    08.04.2009
    Ort
    an der Ostsee
    Beiträge
    334
    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

  6. #6
    Erfahrener Benutzer Roboter Experte Avatar von sternst
    Registriert seit
    07.07.2008
    Beiträge
    672
    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>
    MfG
    Stefan

+ Antworten

Berechtigungen

  • Neue Themen erstellen: Ja
  • Themen beantworten: Ja
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •