uC mit Lego Infrarotfernbedienung steuern

[David M. (dave48859)]

Hallo,

Ich habe probiert das Signal einer Lego Powerfunctions Fernbedienung 
abzufangen.
Leider wird der Interrupt an dem der IR Empfänger hängt nur einmal 
ausgelößt.
Hier ist der link in dem das Protokoll beschrieben 
wird:http://www.philohome.com/pf/LEGO_Power_Functions_RC_v110.pdf

Hier der Code:

#include <avr/io.h>
#include "lcdlib.h"
#include <avr/interrupt.h>
#include <stdlib.h>


volatile uint8_t bitnr=0;
volatile uint16_t t;
volatile uint16_t datent=0;
volatile uint16_t daten=0;
volatile uint8_t x=0;
volatile uint8_t nib1=0;
volatile uint8_t nib2=0;
volatile uint8_t nib3=0;
volatile uint8_t nib4=0;

char datenchar[20];



ISR(INT0_vect)
{
      
    
      t=(TCNT1)*32;                    //Eine inkrementierung des Timers entspricht 32us
      if((t>316)&&(t<=526)&&(bitnr>=2)&&(bitnr<=17))    //Überprüfen ob ein high oder low gesendet wird (low: 316-526us bis zur nächsten steigenden Flanke
      {
        datent &=~(1<<(17-bitnr));            //Zwischenvariable damit nur am ende des Sendevorgangs 
      }
      
      if((t>526)&&(t<=947)&&(bitnr>=2)&&(bitnr<=17))    //High: 516-947us bis zur nächsten steigenden Flanke
      {
        datent |=(1<<(17-bitnr));
      
        nib1=datent>>12;
        nib2= (datent>>8)&0x0FFF;
        nib3= (datent>>4)&0x00FF;
        nib4=datent&0x000F;
      }
      
      
      if((bitnr==17)&&(((0xF)^nib1^nib2^nib3)==nib4))    //Nibble1 xor Nibble2 xor Nibble3 xor 0xF muss gleich Nibble4
      {
        daten=0;
        daten=datent;                  //Zwischenvariable damit nur am ende des Sendevorgangs die Daten Freigegeben werden
        bitnr=0;                            
        datent=0;
      }
      
      else
      {
        bitnr=0;
        datent=0;
      }
    
    TCNT1=0;                          //Timerregister auf null setzen
    bitnr++;                        //Bitnr inkrementieren
  
  
  
}

int main(void)

{
  
  DDRC=0xff;
  DDRA=0x07;
  DDRB=0xff;
  DDRD=0b11111011;
  
  
  TCCR1B=(1<<CS12);        //prescaler 256
  
  
  GICR|=(1<<INT0);
  MCUCR = (1<<ISC00)|(1<<ISC01);  // Trigger INT0 on rising edge
  
  lcd_init(LCD_DISP_ON);
  lcd_clrscr();
  

              
  
    while(1)
    {
    lcd_clrscr();        //Ausgeben eines Datenblocks am LCD
    lcd_gotoxy(0,0);
    char datenchar[20];
    itoa(bitnr,datenchar,2);
    lcd_puts(datenchar);
    _delay_ms(100);
    
      
    
    
    
    }
}

Was ist der Fehler?

[Joachim B. (jar)]

David Märzinger schrieb:
> Was ist der Fehler?

k.a.

evtl. weil nicht IRMP benutzt :-)

http://www.mikrocontroller.net/articles/IRMP

[Eric (Gast)]

David Märzinger schrieb:

> if((bitnr==17)&&(((0xF)^nib1^nib2^nib3)==nib4))    //Nibble1 xor
> Nibble2 xor Nibble3 xor 0xF muss gleich Nibble4
>       {
>         ...
>         bitnr=0;
>         datent=0;
>       }
>
>       else
>       {
>         bitnr=0;
>         datent=0;
>       }

An dieser Stelle angekommen ist bitnr immer 0, da es sowohl im if als 
auch im else-Zweig auf 0 gesetzt wird.

>     TCNT1=0;                          //Timerregister auf null setzen
>     bitnr++;                        //Bitnr inkrementieren

und hier ist bitnr dann 1.

[Eric (Gast)]

David Märzinger schrieb:

>       if((t>316)&&(t<=526)&&(bitnr>=2)&&(bitnr<=17))    //Überprüfen ob
> ein high oder low gesendet wird (low: 316-526us bis zur nächsten
> steigenden Flanke

Da bitnr immer 1 ist (siehe obigen Beitrag), liefert dies Abfrage immer 
FALSE und der Code darunter wird nie ausgeführt.

>       if((t>526)&&(t<=947)&&(bitnr>=2)&&(bitnr<=17))    //High:
> 516-947us bis zur nächsten steigenden Flanke

Hier genau so. Der ISR kann also 1000x aufgerufen werden, wird aber nur 
bei der 1. Durchlauf irgendwas machen. Danach passiert da nix mehr.

[David M. (dave48859)]

danke für den tipp!

[Karl H. (kbuchegg)]

mal abgesehen davon.

Ich will dich ja nicht bevormunden, aber

      t=(TCNT1)*32;                    //Eine inkrementierung des Timers entspricht 32us
      if((t>316)&&(t<=526)

da in TCNT1 nur eine ganze Zahl stehen kann, kann daher t nur ein 
ganzzahliges Vielfaches von 32 sein. Das Ergebnis kann daher gar nicht 
zb 317 sein, da 317 kein Vielfaches von 32 ist. Die nächst kleinere 
Zahl, die bei der Multiplkation entstehen kann, ist 288. Dann kommt 
lange nichts und die nächste größere Zahl, die entstehen kann ist 320. 
(das eine mal hat TCNT1 den Wert 9 und das andere mal den Wert 10). Alle 
Werte zwischen 288 und 320 können überhaupt nicht auftreten. Das ist 
mathematisch überhaupt nicht möglich.

Jetzt muss man sich aber fragen: was bringt mir dann eigentlich die 
Multiplikation mit 32?
Und die Antwort drauf lautet: Überhaupt nichts. Gar nichts.

Denn ob du

      t=(TCNT1)*32;                    //Eine inkrementierung des Timers entspricht 32us
      if((t>316)&&(t<=526)

schreibst, oder ob du

      t= TCNT1;
      if( (t > 9) && (t < 17)

schreibst, kommt wegen des eingeschränkt möglichen Wertebereichs aufs 
selbe raus.

Mit einem kleinen Unterschied, der mglw. entscheidend sein kann. Das 
Eregbnis der Multiplikation mit 32 kann dir unter Umständen, wenn der 
TCNT1 Wert hoch genug wird, den Zahlenbereich eines int16_t sprengen. Ab 
dann rechnest du dann mit falschen Werten weiter.

[David M. (dave48859)]

Aufgrund des Prescalers von bei einer Taktfrequenz von 8MHz, erhöht sich 
der Timer 31250 mal pro Sekunde daher enspricht ein Timerschritt 1/31250 
= 32us
Um die Zeit von einem Impuls zum anderen in us zu bekommen muss ich den 
Timerwert mit 32 multiplizieren.

Kennt ihr eine bessere Methode um die Zeiten zwischen mehreren Impulsen 
exakt zu messen? Das Signal, welches die Lego IR Fernbedienung sendet 
besteht aus einem Startbit, 16 Datenbits und einem Stoppbit:

Da die Information über die Dauer von der letzten Steigenden Flanke bis 
zur nächsten Steigenden Flanke übertragen wird:
Startbit, Stoppbit Dauer: 947-1579 us
Low                Dauer: 316-526 us
High               Dauer: 526-947 us

(Daher kommen diese Grenzen)
Habt ihr eine Idee wie man das einfacher machen könnte?

[Eric (Gast)]

David Märzinger schrieb:

> Um die Zeit von einem Impuls zum anderen in us zu bekommen muss ich den
> Timerwert mit 32 multiplizieren.

Oder halt die Werte mit denen du vergleichst durch 32 dividieren,
wie kbuchegg oben beschrieben hat. Dann rechnest du halt nicht in us
sondern in timerticks.

[Joachim B. (jar)]

David Märzinger schrieb:
> Habt ihr eine Idee wie man das einfacher machen könnte?

man könnte ja bei Frank (ukw) schmulen IRMP aber das schrieb ich schon.

[Frank M. (ukw) (Moderator)]

David Märzinger schrieb:
> Um die Zeit von einem Impuls zum anderen in us zu bekommen muss ich den
> Timerwert mit 32 multiplizieren.

Warum willst Du die Zeiten in µs? Tatsächlich brauchst die Zeiten in 
Takteinheiten Deines Timers.

> Da die Information über die Dauer von der letzten Steigenden Flanke bis
> zur nächsten Steigenden Flanke übertragen wird:
> Startbit, Stoppbit Dauer: 947-1579 us
> Low                Dauer: 316-526 us
> High               Dauer: 526-947 us

Besser:

Startbit, Stoppbit Dauer: 30 - 50 Timereinheiten
Low                Dauer: 10 - 16 Timereinheiten
High               Dauer: 16 - 30 Timereinheiten

Das hat auch den Vorteil, dass Du mit einem uint8_t-Zähler auskommst.

Genauso "zählt" übrigens IRMP - mit Unterstützung des Preprocessors 
in der gewählten Timereinheit, je nachdem, ob man 10000, 15000 oder 
20000 mal pro Sekunde das TSOP-Signal einliest.

Du solltest Dir wirklich mal IRMP (<-- draufklicken) anschauen, denn 
es unterstützt u.a. auch das LEGO-Protokoll, kann es einwandfrei 
verstehen und mittels IRSND sogar wieder senden - falls gewünscht.