Programmierung einer Fräsensteuerung

**Jacob2** · 22.03.2010, 10:42

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

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

**Netzman** · 22.03.2010, 10:53

Stichwort Bresenham

mfg

**Jacob2** · 22.03.2010, 11:28

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** · 22.03.2010, 18:36

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?

**Peter1060** · 22.03.2010, 19:30

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** · 22.03.2010, 23:15

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>

Thema: Programmierung einer Fräsensteuerung

Themen-Optionen

Thema durchsuchen

Anzeige

Programmierung einer Fräsensteuerung

Lesezeichen

Lesezeichen

Berechtigungen