RC Servo Signalmessung mit ATTiny85 und Konsorten

[Jasson J. (jasson)]

Hoi zäme,

ich möchte einen Gedankengang mit der Schwarmintelligenz verifizieren:

Ich möchte ein klassisches RC-Servo Signal mit einem Tiny85 ausmessen 
und auf ein PWM spiegeln.
Der selbe Ansatz, der mir eingefallen ist habe ich auch mehrfach im Netz 
gefunden:
Da der Tiny keinen InputCapture hat und nur 8 Bit breite Timer Register 
ist der Ansatz, eine TimerOverflow ISR zum inkrementieren eines Counters 
zu nutzten und eine PinChange ISR, um die Flanken zu erkennen, wo die 
Pulsdauer gebildet wird á la
pulseDuration = overFlowCnt*256 + timerVal
>Mein Eindruck ist, das Ergeniss jittert ordentlich, weil bei bestimmten
>Timings Raiseconditions zwischen Overflow und Pinchange auftreten?

Mir ist nun in den Sinn gekommen, einfach in Präinterrupt-Zeiten zurück 
zu gehen und den ganzen Programfluss zum Polling eines Signalpins zu 
nutzten.
Bei Fsys = 8Mhz und z.B. einer Zielauflösung von 200Ticks/Millisekunde, 
bleiben 40 Zyklen. In diesem Fall kommt einem die ewige Inactivezeit des 
klassischen RC-Servo Signales zur Hilfe, in der man alles mögliche 
machen kann.
Ich denke, man kann hier noch deutlich schneller als 40 tick breite 
Timeslote gehen.

In Pseudocode stelle ich mir das so vor

tickCntr = 0;
while(pin == LOW); //wait for rising edge
ResetAndStartTimer();
while(pin == HIGH)// wait for falling edge and meassure the time
{
   while(Timer < 40);// create equidistance time slots
   tickCntr++;
}
DoSomethingWithTickCntr(); // is allowed to take "long" since signal is 
18ms inactive.

[Jasson J. (jasson)]

Zu Hause und ausprobiert
 -
mit dem Polling-Ansatz habe ich gute Ergebnisse.

Systemtakt ist 8Mhz, Timer 0 läuft mit Prescaler = 1.
Um zum Polling zeitlich äquidistante Slots zu schaffen wird TCNT0 auf 
kleiner 16 geprüft.
Das erzeugt 2µs lange Zeitslots und bei einer Auslenkung von 500µs 
entsprechend 250 "Ticks".
Das Konzept ist, dass die Auslenkung etwas dirty eben ein bisschen 
größer gemacht werden muss als +-500µs, um die für das PWM 255 voll zu 
kriegen.

Zu diesem Kern habe ich noch ein bisschen Logik gedichtet, die mit zwei 
Pins ein Forward und Backward Enable macht und bei Übergang eine 
Verzögerung erzeugt, um einer eventuellen H-Brücke etwas Zeit zu geben.
Dazu gibt es um den Nullpunkt herum einen Totbereich, damit das ganze in 
"Neutral" nicht laufend zwischen vorwärts und rückwärts pendelt.

#include <avr/io.h> 
#include <stdint.h> 

#define NEUTRAL 663 // due to 2µs timebase => 1300µs
#define DEAD_BAND 5

#define NEUTRAL_UPPER  NEUTRAL+DEAD_BAND
#define TOP  NEUTRAL_UPPER+255

#define NEUTRAL_LOWER  NEUTRAL-DEAD_BAND
#define BOTTOM NEUTRAL_LOWER-255

volatile static uint16_t pulseLength = 0, state = 5;


/*
PB1 PWM Out / OCR1A
PB2 Backward Enable
PB3 "InputCapture"
PB 4 Forward Enable
*/

int main(void)
{ 
  DDRB = 0b00010110; 
 
  TCCR0B = 1; 

   TCCR1 = 0b01100001; 
  OCR1C = 255; 

  while(1)
  { 
     while((PINB & 8) == 0);
    TCNT0 = 0;
    pulseLength = 0;
    while((PINB & 8) == 8)
    {
      while(TCNT0 < 16); // creates timeslots with 2µs length
      TCNT0 = 0;
      pulseLength++;
    } 

    if(pulseLength > NEUTRAL_UPPER) // grater than 
    { 
      if(state == 8)
      {
        DDRB |= 0b00000010;//set Pin to output
        if(pulseLength > TOP) pulseLength = TOP;
        pulseLength -= NEUTRAL_UPPER;
        OCR1A = pulseLength;
        PORTB |= 0b00010000;
      }
      else
      {
        OCR1A = 0; // set PWM to 0% dutycycle
        DDRB &= 0b11111101;//set Pin to input
        PORTB &= 0b11101011; // set fw/be enable low
        state++;
      }
    } 
    else if(pulseLength < NEUTRAL_LOWER)
    {
      if(state == 2)
      {
        DDRB |= 0b00000010;//set Pin to output
        if(pulseLength < BOTTOM)pulseLength = BOTTOM;
        OCR1A = BOTTOM - pulseLength;
        PORTB |= 0b00000100;
      }
      else
      {
        OCR1A = 0; // set PWM to 0% dutycycle
        DDRB &= 0b11111101;//set Pin to input
        PORTB &= 0b11101011; // set fw/be enable low
        state--;
      }
    }
    else
    {
      OCR1A = 0; // set PWM to 0% dutycycle
      DDRB &= 0b11111101;//set Pin to input
      PORTB &= 0b11101011; // set fw/be enable low

      if(state > 5) state--;
      if(state < 5) state++;
    }
  }

}

[Pedro M. (pedromills)]

Danke für die Info.

[Jasson J. (jasson)]

Cool, nutzt es vielleicht tatsächlich jemandem -

was hast du vor zu beuen?
Bei mir ist´s ein einfacher Drehzahlsteller für kleinere Motoren.

[Timo N. (tnn85)]

Bin ich blind oder hast du einfach nur versucht den CTC-Mode (Clear 
Timer on Compare Match) mit  Timer/Counter0 Output Compare Match A 
Interrupt
durch eine while-Schleife nachzubilden?

Warum verwendest du den Interrupt nicht und erzeugst deine Timeslots mit 
einer while-Schleife?

[Jasson J. (jasson)]

>Bin ich blind oder hast du einfach nur versucht den CTC-Mode (Clear
>Timer on Compare Match) mit  Timer/Counter0 Output Compare Match A
>Interrupt
>durch eine while-Schleife nachzubilden?

Stimmt, richtig gesehen


>Warum verwendest du den Interrupt nicht und erzeugst deine Timeslots mit
>einer while-Schleife?

Weil ich nichts anderes machen will, als das PWM und Fw/Bw Pins.
Da bin ich ohne springen zur ISR und dem was dabei sonst passiert eher 
schneller und kann falls gewollt die Slots kürzer machen.

[Jasson J. (jasson)]

Wobei es das Wert ist, dass zu untersuchen, ob sich der ISR-Overhead 
unterbringen lässt, für das gewollte timing.

Bei meiner Lösung wird sich auch ein Jitter ergeben, da der Timer mit 
Fsys läuft und die
>while(TCNT0 < 16);
am Ende auch einliest, vergleicht, conditioned-jumped - kann man gerne 
bis >= 16 zählen

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Meine Lösung kannst du dir hier angucken:
Beitrag "RC-Servoelektronik für DC-Motor"

[Jasson J. (jasson)]

Hm... interessant, ich sehe, du hast eine
>ISR_NOBLOCK
Anweisung. Die sorgt sicher dafür, dass bei ISR-Entry das globale 
Interrupt Enable wieder gesetzt wird.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Jasson J. schrieb:
> Die sorgt sicher dafür, dass bei ISR-Entry das globale
> Interrupt Enable wieder gesetzt wird.

So isses. Näheres über die verschiedenen Optionen für ISR gibts in der 
Hilfe für die avrlib.

[Uwe D. (monkye)]

Du könntest auch das Teil mit PLL auf 16MHz laufen lassen und hast mehr 
Zeit für andere Aufgaben...