3 RC Kanäle Auswerten

[Toby (Gast)]

Hallo,

ich versuche grade drei RC Kanäle mit einem ATMega168 auszuwerten.
Dazu nutze ich die drei vorhandenen PinChange Interupts.
Also je RC Kanal einen anderen Port.

#define RX_PIN_B  PINB
#define RX_PORT_B  PORTB
#define RX_DDR_B  DDRB
#define RX_1    0

#define RX_PIN_C  PINC
#define RX_PORT_C  PORTC
#define RX_DDR_C  DDRC
#define RX_2    0

#define RX_PIN_D  PIND
#define RX_PORT_D  PORTD
#define RX_DDR_D  DDRD
#define RX_3    2

volatile uint16_t timerValue[3]  = {0,0,0};
volatile uint16_t channel[3]  = {1500,1500,1500};

/* INIT */
  
   RX_DDR_B  &= ~(1<<RX_1_B);
   RX_DDR_C  &= ~(1<<RX_1_C);
   RX_DDR_D  &= ~(1<<RX_1_D);
  
   TCCR1B = _BV(CS11) ;
   TIMSK1 = 0;
  
   //PinChange Interupt an PB 0
   PCMSK0 |= (1<<PCINT0);
  
   //PinChange Interupt an PC 0
   PCMSK1 |= (1<<PCINT8);
  
   //PinChange Interupt an PD 2
   PCMSK2 |= (1<<PCINT18);
  
   //enable pinchange interrupt;
   PCICR  |= ((1<<PCIE2) | (1<<PCIE1) | (1<<PCIE0));

   sei();

/* INIT ENDE */

ISR(SIG_PIN_CHANGE0)
{
  uint16_t timer = TCNT1;

  if(RX_PIN_B & (1<<RX_1))
  {
    timerValue[0] = timer;
  }
  else
  {
    channel[0] = timer - timerValue[0];
  }
}

ISR(SIG_PIN_CHANGE1)
{  
  uint16_t timer = TCNT1;
  
  if(RX_PIN_C & (1<<RX_2))
  {
    timerValue[1] = timer;
  }
  else
  {
    channel[1] = timer - timerValue[1];
  }
}

ISR(SIG_PIN_CHANGE2)
{  
  uint16_t timer = TCNT1;
  
  if(RX_PIN_D & (1<<RX_3))
  {
    timerValue[2] = timer;
  }
  else
  {
    channel[2] = timer - timerValue[2];
  }  
}

Nun möchte ich gerne alle drei RC Kanäle an nur einem Port auswerten.
Da habe ich dann aber nur einen PinChange Interupt.
Hat jemand eine Idee wie ich das lösen kann?

#define RX_PIN  PINB
#define RX_PORT  PORTB
#define RX_DDR  DDRB
#define RX_1  0
#define RX_2  1
#define RX_3  2

volatile uint16_t timerValue[3]  = {0,0,0};
volatile uint16_t channel[3]  = {1500,1500,1500};

/* INIT */
  
   RX_DDR  &= ~((1<<RX_3) | (1<<RX_2) | (1<<RX_1));
  
   TCCR1B = _BV(CS11) ;
   TIMSK1 = 0;
  
   //PinChange Interupt an PB 0,1,2
   PCMSK0 |= ((1<<PCINT2) | (1<<PCINT1) | (1<<PCINT0));
  
   //enable pinchange interrupt;
   PCICR  |= (1<<PCIE0);

   sei();

/* INIT ENDE */

ISR(SIG_PIN_CHANGE0)
{
   uint16_t timer = TCNT1;
  
   //Hier fehlt`s ;-)  
}

Gruß Toby

[Karl H. (kbuchegg)]

Toby schrieb:

> Nun möchte ich gerne alle drei RC Kanäle an nur einem Port auswerten.
> Da habe ich dann aber nur einen PinChange Interupt.
> Hat jemand eine Idee wie ich das lösen kann?

In der ISR den PIN-Zustand einlesen und mit einem vorhergehenden Zustand 
vergleichen? Der Vergleich bringt zutage, welcher Pin sich verändert 
hat.

[Toby (Gast)]

Hallo,

irgendwie stehe ich grade auf dem Schlauch.

Ich speichere nun den Wert von PinB in einer Variable.

ISR(SIG_PIN_CHANGE0)
{
   uint16_t timer = TCNT1;
   uint8_t rx_state = RX_PIN;  
}

Jetzt muss ich den Wert mit den voherigen vergleichen.
Also eine globale Variable, sagen wir mal rx_state_old deklarieren.

volatile uint8_t rx_state_old;

ISR(SIG_PIN_CHANGE0)
{
   uint16_t timer = TCNT1;
   uint8_t rx_state = RX_PIN;

   //neuen Wert mit altem Wert vergleichen
   //Wie?!   

   //alten Wert mit neuem Wert beschreiben
   rx_state_old = rx_state;     
}

Muss ich jetzt Bitweise sehen welches Bit sich geändert hat und dann 
dementsprechend handeln?

Gruß Toby

[Toby (Gast)]

Hallo,

nun bin ich so weit, das die ersten beiden Kanäle gehen.
Nur der dritte nicht. :-(

ISR(SIG_PIN_CHANGE0)
{
  uint16_t timer = TCNT1;
  uint8_t rx_state = RX_PIN;
  uint8_t i;
  
  i = rx_state | rx_state_old;
  
  if(i & 0x01)
  {
    timerValue[0] = timer;
  }
  else if(i & 0x02)
  {
    channel[0] = timer - timerValue[0];
    timerValue[1] = timer;
  }  
  else if(i & 0x04)
  {
    channel[1] = timer - timerValue[1];
    timerValue[2] = timer;
  }  
  else if( //hier muss ich auf gelöschtes Bit3 testen )
  {
    channel[2] = timer - timerValue[2];
  }
  
  rx_state_old = rx_state;
}

[Karl H. (kbuchegg)]

Toby schrieb:
> Hallo,
>
> nun bin ich so weit, das die ersten beiden Kanäle gehen.
> Nur der dritte nicht. :-(
>
> [c]
> ISR(SIG_PIN_CHANGE0)
> {
>   uint16_t timer = TCNT1;
>   uint8_t rx_state = RX_PIN;
>   uint8_t i;
>
>   i = rx_state | rx_state_old;

so kriegst du aber nicht die Pins raus, die sich VERÄNDERT haben!
Du brauchst ein XOR

    i = rx_state ^ rx_state_old;

Jetzt hast du in i genau an den Stellen ein 1 Bit, an denen sich 
rx_state von rs_state_old unterscheidet.

i sagt dir, welcher Pin den Pin Change Interrupt ausgelöst hat und 
rx_state sagt dir, ob der Pin jetzt 0 oder 1 ist.

[Rolf Magnus (Gast)]

Ich würde auch das else überall weglassen. Wenn sich mal mehrere Pins 
nahezu gleichzeitig ändern, bekommt man sonst nicht alle Änderungen mit, 
da der Code ja nur dann was macht, wenn sich exakt einer der drei Pins 
geändert hat.

[Toby (Gast)]

Hallo,

Also in etwa so:

Wenn i = 1
    Wenn rx_state = 1 Pulsmessung starten
    Sonst Pulsmessung auswerten

Wenn i = 2
   Wenn rx_state = 2
...
Wenn i = 4
   Wenn rx_state = 4
...

Oder kann/muss ich i und rx_state nochmal vergleichen
Um den Flankenwechsel zu erkennen?

Wenn ich jeden 2. RC Kanal vom Empfänger nehme,
Hab ich ja eindeutige Pulslücken zwischen den Kanälen.

Nehme ich Kanal 1-3 hab ich keine Lücken.
Am Ende des 1. Pulses kommt sofort der zweite Puls.
Kann man das überhaupt Erkennen?

Gruß Toby

Entschuldigt die Schreibweise, aber geht mit dem Handy
so einfacher ;-)

[Toby (Gast)]

Hallo,

ich habs jetzt so gemacht und es funktioniert:

ISR(SIG_PIN_CHANGE0)
{
  Timer1_stopp;
  uint16_t timer = TCNT1;
  Timer1_run;
  
  uint8_t rx_state = RX_PIN;
  uint8_t i;
  
  i = rx_state ^ rx_state_old;
  
  if(i & 0x01)
  {
    if (rx_state & 0x01)
    {
      timerValue[0] = timer;
    }
    else
    {
      channel[0] = timer - timerValue[0];
    }
  }
  
  if(i & 0x02)
  {
    if (rx_state & 0x02)
    {
      timerValue[1] = timer;
    }
    else
    {
      channel[1] = timer - timerValue[1];
    }
  }
  
  if(i & 0x04)
  {
    if (rx_state & 0x04)
    {
      timerValue[2] = timer;
    }
    else
    {
      channel[2] = timer - timerValue[2];
    }
  }
    
  rx_state_old = rx_state;
}

Danke für die Hilfe!

Gruß Toby

[Karl H. (kbuchegg)]

Toby schrieb:

> ich habs jetzt so gemacht und es funktioniert:

Gut,

Und wenn du jetzt noch deinen 'magischen Konstanten' 0x01, 0x02 ein paar 
schöne Makrokonstanten spendierst, dann kann man das auch leicht auf 
andere Pinbelegungen vom µC anpassen. Anstatt i noch einen vernünftigen 
Variablennamen nehmen (Frage: Was bedeuten die Bits in dieser Variable? 
Antwort: Das sind die Pins die sich verändert haben. Also sollte man 
dann auch einen Namen wählen, der das ausdrückt)

#define RX_KANAL_1     PB0
#define RX_KANAL_2     PB1
#define RX_KANAL_3     PB2

....

    pinsChanged = pinsNow ^ pinsPrevious;
 
    if( pinsChanged & (1<<RX_KANAL_1) )
    {
      if (pinsNow  & (1<<RX_KANAL_1)
      {
        timerValue[0] = timer;
      }
      else
      {
        channel[0] = timer - timerValue[0];
      }
    }

    if( pinsChanged & (1<<RX_KANAL_2) )
    {
      if (pinsNow  & (1<<RX_KANAL_2)
      {

...

liest sich doch gleich viel besser. Je weniger man beim Code lesen 
erraten oder sich merken muss, umso besser. Im Idealfall ist der Code 
schon fast ein vollständiger Satz, dem lediglich ein paar Füllwörter 
fehlen.


   wenn sich der Pin gändert hat, an dem der RC Kanal 1 hängt

   if( pinsChanged & (1<<RX_KANAL_1) )

Ist fast die gleiche Information, nur das das eine ein deutscher Satz 
ist und das andere dasselbe in C ausdrückt.

[STK500-Besitzer (Gast)]

Wenn alle abzufragenden Pins sich an einem Port befinden, könnte man 
auch eine Schleife benutzen...

[Toby (Gast)]

Hallo Karl-Heinz,

Als ich den Beitrag abgeschickt habe, hatte ich auch noch den Gedanken
die Konstanten zu ändern.

Deine Ausführung ist da natürlich sehr elegant.

Gruß Toby