Moin!
@Static:
Wieso brauchst Du bei gleicher Strecke unterschiedlich viele Schritte? meinst Du die Summe der X und Y Schritte? Bei mir liegt die Verzögerung direkt im Linienalgorithmus, der macht also entweder auf einer oder auf beiden Achsen einen Schritt und verzögert dann.

Hier mal mein Linienkrams, vielleicht nützt das ja schonmal wem.
Der Bresenham ist übrigens ziemlich direkt einfach qaus Wikipedia kopiert

RAMP ist die Anzahl Schritte für die Beschleunigungs und Bremsrampe, bei mir 24
rampfactor ist ein Faktor, um die Beschleunigungskurve zu verbiegen, bei mir 16
gb_steps ist die Anzahl Schritte pro 1/10 mm, bei mir 96

Der Krams mit dem last_ix und so ist zum Ausgleich des Umkehrspiels.
movex(steps,dir,speed) und movey(...) bewegen jeweils den Motor um 'steps' Schritte in Richtung 'dir' (incx bzw. incy sind entweder -1,0 oder 1, werden vom Bresenham genutzt) mit Geschwindigkeit 'speed'
sx(dir);sy(...) machen jeweils einen Schritt in Richtung 'dir'

Code:
void gbham(int32_t xstart,int32_t ystart,int32_t xend,int32_t yend, uint16_t speed)
/*--------------------------------------------------------------
 * Bresenham-Algorithmus: Linien auf Rastergeräten zeichnen
 *
 * Eingabeparameter:
 *    int xstart, ystart        = Koordinaten des Startpunkts
 *    int xend, yend            = Koordinaten des Endpunkts
 *
 * Ausgabe:
 *    void SetPixel(int x, int y) setze ein Pixel in der Grafik
 *         (wird in dieser oder aehnlicher Form vorausgesetzt)
 *---------------------------------------------------------------
 */
{
	int32_t x, y, t, dx, dy, es, el, err;
 	int incx,incy, pdx, pdy, ddx, ddy;
	int rampdelay = RAMP;

	
	xstart *= gb_steps;
	ystart *= gb_steps;
	xend *= gb_steps;
	yend *= gb_steps;
	//speed=speed-M_MINIMUM;


/* 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;
		
	if ((incx != last_ix)&(incx != 0)) 
		{
			movex(XCORR,incx,speed);
			last_ix = incx;			
		}
		
	if ((incy != last_iy)&(incy != 0))
		{
			movey(YCORR,incy,speed);
			last_iy = incy;
		}	


/* 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;
   	SetPixel(x,y);

	if (el < rampdelay)
		rampdelay = el / 2;
 
	/* Pixel berechnen */
	XYON;
   	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;
          	sx(ddx);
		  	//y += ddy;
		  	sy(ddy);
			
      	} else
      	{
          	/* Schritt in schnelle Richtung, Parallelschritt */
          
		 	//x += pdx;
		  	sx(pdx);	
          	//y += pdy;
		  	sy(pdy);
		}
		//ramp delay
		//XYOFF;
		mydelay(speed);
		
		if (t < RAMP)
		{
			mydelay(rampdelay*rampfactor);
			rampdelay--;
		}
		else if ((el-t)<RAMP)
		{
			mydelay(rampdelay*rampfactor);
			rampdelay++;
		}
		//XYON;
		
      	//SetPixel(x,y);
	}
	XYOFF;
} /* gbham() */
MfG
Volker