PWM Erzeugung 18* Simultan

[WarChild]

ich bin jetzt mit meiner Lösung ganz zufrieden.
Da die werte sortiert sind und immer ein ganz kurzer, ein mittlerer und ein ganz langer impuls gleichzeitig erzeugt werden, kommt es nie zu dem problem, dass die differenzzeit zwischen je drei Impulsen zu gering ist, um den ISR zu durchlaufen. ich habe den Hexapoden jetzt 10 minuten "zufällig" bewegen lassen, und die Fälle, bei denen er vorzeitig beenden musste zählen lassen. ich kann nur soviel sagen... es kam zu keinem überlauf meiner 8-Bit Zählvariablen. bei einem Überlauf wäre ein konrollpin high gestzt worden.(LED). selsbt, wenn ich bei allen 18 Servos den gleichen Winkel eingestllt habe, kam es nicht dazu, da jeder servo anders kalibreirt ist und aufrgrund dieser abweichnungen gibt es anscheinend immer eine Möglichkeit die Signale mit mehr als 100 Takten differenz in dreierpärchen anzuordnen. Deshalb habe ich die sonderbehandlung von eng beieinanderliegenden Signalen herausgenommen. Dank des Simulators konnte ich die Korreturzeiten fürs Vorladen bis auf einen Takt genau bestimmen. Deshalb erreicht der Timer1 effektiv für die relevanten 1,5ms (180°) eine auflösung von über 14-Bit.(außer die signale liegen zu eng beienander, was aber nie vorkommt)

Ich möchte behaupten, dass die auslastung des controllers größer wäre, wenn er 5 Atinys mit je 8Byte+BLA+BLA 50mal pro sekunde über I²C zu versorgen. Mein I²C Bus soll am ende nur dafür da sein, dass ein master Die Umwelterkennung und die verhaltenssteuerung macht und dem slave, der jetzt die IK und die PWMs macht nur ein paar steuerparameter bekommt, und dann eigenständig arbeitet. dass immer nur wenn sich das verhalten ändern soll ein kurzer steuer befehlkommen muss und dann hat de master wieder ruhe. Durch den ISR gehen mir jetzt alle 20ms 5000 Takte verloren und das sortieren kostet auch nochmal 13000 Takte, aber dafür ist dann alles "On-Board" und ist ein selbstgänger in der ISR.

Falls jemand von euch auch eine Hexapoden hat.
Wie hoch löst ihr die Koordinatensysteme auf?
Ich arbeite jetzt im ganzahligen mm maß. Und Wie immer gibt es ein schwächstes Glied. Die Rotation des Torsos läuft wirklich bis auf 0.0078° genau aufgelöst, aber die translation erfolgt in mm schritten. Sollte ich mir auch dort die arbeit machen die auflösung zu erhöhen, oder sprengt so etwas den rahmen?.

mfg WarChild

//***************Pulserzeugung + Timer**************//

//**************************************************//
void startpulse(uint8_t number)
{
	  switch (number)
	  {
	    case (0):	servo1on;	break;
	    case (1):	servo2on;	break;
	    case (2):	servo3on;	break;
	    case (3):	servo4on;	break;
	    case (4):	servo5on;	break;
	    case (5):	servo6on;	break;
	    case (6):	servo7on;	break;
	    case (7):	servo8on;	break;
	    case (8):	servo9on;	break;
	    case (9):	servo10on;	break;
	    case (10):	servo11on;	break;
	    case (11):	servo12on;	break;
	    case (12):	servo13on;	break;
	    case (13):	servo14on;	break;
	    case (14):	servo15on;	break;
	    case (15):	servo16on;	break;
	    case (16):	servo17on;	break;
	    case (17):	servo18on;	break;
	  }	
}
//**************************************************//

//**************************************************//
void stoppulse(uint8_t number)
{
	  switch (number)
	  {
	    case (0):	servo1off;	break;
	    case (1):	servo2off;	break;
	    case (2):	servo3off;	break;
	    case (3):	servo4off;	break;
	    case (4):	servo5off;	break;
	    case (5):	servo6off;	break;
	    case (6):	servo7off;	break;
	    case (7):	servo8off;	break;
	    case (8):	servo9off;	break;
	    case (9):	servo10off;	break;
	    case (10):	servo11off;	break;
	    case (11):	servo12off;	break;
	    case (12):	servo13off;	break;
	    case (13):	servo14off;	break;
	    case (14):	servo15off;	break;
	    case (15):	servo16off;	break;
	    case (16):	servo17off;	break;
	    case (17):	servo18off;	break;
	  }	
}
//**************************************************//


//**************************************************//
SIGNAL (SIG_OVERFLOW2)								// 1ms Interrrupt
{
	TCNT2 = 256 - 250;								//Timer2 mit 6 neu vorladen
	timer2++;
	timer3++;
	if(timer2 == 20)								//je in 3ms Abstand drei Impulse starten
	{
		timer2 = 0;									//timer2 endet bei 20ms
		signal = 0;
	}
	if(timer2 == 18)
	{
		pulsecalculator();
		nextIK=1;
	}
	else if(timer2%3 == 0)							//alle 3 ms außer 18 s.o. je drei Signale starten
	{
		uint8_t a=sortindex[signal],b=sortindex[signal+1],c=sortindex[signal+2];
		startpulse(a);
		startpulse(b);
		startpulse(c);
		cli(); 
		TCNT1 = 65536-dtime[signal]+ISRdelay1; 	//Timer1 neu vorladen
		sei();
		TIFR |= (1 << TOV1);						//alten Overflow löschen
		TIMSK |= (1 << TOIE1);
	}	
}
//**************************************************//


//**************************************************//
SIGNAL (SIG_OVERFLOW1)								//Wird von Timer1 freigegeben und beendet die durch Timer2 gestarteten Pulse
{	
	stoppulse(sortindex[signal]);					//letzten Impuls beenden
	signal++;										//nächstes Signal
	if(signal%3)									//solange signal kein vielfaches von drei ist die nächste zeit vorladen
	{
		uint16_t time=dtime[signal];
		if(time<ISRdelay2)
			TCNT1 = 65536-time;
		else
			TCNT1 = 65536-time+ISRdelay2;
	}
	else											//sonst Timer1 beenden
		TIMSK &= ~(1 << TOIE1);
}
//**************************************************//