Code: Timerproblem bei rc5-receiver

[Michael N. (garril)]

Hallo,
ich möchte einen Fernbedienungssignal-Empfänger für das RC5 Protokoll 
bauen.

Da ich selbst üben möchte und das ganze auch selbst verstehen möchte, 
hab ich den Code also selbst entworfen.
Allerdings läuft das mit meinem Timer noch nicht so rund.
Mein Gedanke:
Eingang liegt normal auf High. Wenn dann ein Signal kommt geht er je 
nach Signal ein paar mal auf Low.
Wenn das letzte Bit eine 1 war warte ich auf eine steigende Flanke und 
wenn das letzte erkannte Bit eine 0 war auf eine sinkende.
Anhand der Zeit bis die nächste Flanke erkannt wird kann ich so 
berechnen ob dieses Bit wiederrum eine 0 oder 1 ist.

Aktuell sind die ersten beiden Startbit einfach mal fest auf 1 
programmiert. Das Toggle-Bit müsste sich ja bei jedem Tastendruck 
ändern, deshalb wollte ich mit dem mal beginnen.
Leider macht das Ding was es will... Manchmal geht der Ausgang auf high 
und manchmal auf low...
Anschienend passt etwas mit meiner Zeitberechnung nicht.
Per
if (rc5_position==2) {
if (rc5_timer>=8) {LED an} else {LED aus}
}
lasse ich mir erstmal das Toggle-Bit anzeigen.
Die 8 kommt daher, dass der rc5_timer dann ca. 2,2ms gezählt hat und das 
eine 1 von einer 0 unterscheiden müsste.

Hier mein Code:

#define F_CPU 7372000L                  // Systemtakt in Hz
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#define an(port,b) (port) |= (1<<(b))
#define aus(port,b) (port) &= ~(1<<(b))

volatile uint8_t rc5_adr=0;
volatile uint8_t rc5_cmd=0;
volatile uint8_t rc5_position=0;
volatile uint8_t rc5_timer=0; //Zeit seit letzter erkannten Flanke
volatile uint8_t rc5_lastbit=1; //zuletzt erkanntes Bit
volatile uint8_t rc5_bit0=0;
volatile uint8_t rc5_bit1=0;
volatile uint8_t rc5_bit2=1;

void wait_for_high() {
  MCUCR |= (1 << ISC01) | (1 << ISC00); //Interrupt bei steigender Flanke
}
void wait_for_low() {
  MCUCR |= (1 << ISC01);
  MCUCR &= ~(1 << ISC00); //Interrupt bei fallender Flanke
}

ISR(_VECTOR(1))
{
  if (rc5_position==0) {  
    rc5_bit0=1;
    rc5_lastbit=1;
    rc5_timer=0;
  }
  if (rc5_position==1) {
    rc5_bit1=1;
    rc5_lastbit=1;
    rc5_timer=0;
  }
  if (rc5_position==2) {
    if (rc5_timer>=8) { //<<<<<<HIER LIEGT DAS PROBLEM
      rc5_bit2=1;
      rc5_lastbit=1;
    }
    else {
      rc5_bit2=0;
      rc5_lastbit=0;
    }
    rc5_timer=0;
  }

  if (rc5_position>=5) { //eigentlich bis 13te Flanke zählen, DEBUG
    rc5_position=0;
    cli(); //Interrupts abschalten und abwarten bis Übertragung sicherlich zu Ende ist
    _delay_ms(50);
    wait_for_low();
    sei(); //Interrupts wieder an
  }
  else {
    rc5_position++;
    if (rc5_lastbit==1) {
      wait_for_high();
    }
    else {
      wait_for_low();
    }
  }
  
}
ISR (TIMER0_OVF_vect) {
  rc5_timer++;
  if (rc5_timer==255) {
    rc5_timer=0;
  }
  an(PORTD,PD1); //DEBUG: PD1 high -> ISR wird angesprungen
}
int main(void) {
  
  DDRD  = 0xFB; /* PD2 als Eingang, Rest Ausgang: 11111011 */
  PORTD = 0x00; /* Interner Pull-Up an PD2 deaktivieren, Ausgänge low */
  wait_for_low();
  GICR |= (1 << INT0); //Interrupt aktivieren
  TCCR0 = (1<<CS01); //Start Timer, Prescaler 8 -> Overflow alle 0,277ms
  TIMSK |= (1<<TOIE0); // Overflow Interrupt erlauben
  sei();

  while (1) {
    /*if (!( PIND & (1<<PIND2) )) {
      an(PORTD,PD0);
      _delay_ms(100);
      aus(PORTD,PD0);
    }*/
    if (rc5_bit2==1) {
      an(PORTD,PD0);
    }
    else {
      aus(PORTD,PD0);
    }
  }
}

Vielleicht hat jemand von euch ja schonmal sowas gecodet und kann mir 
dabei helfen.

Vielen Dank.

mfg
Michael

[Michael N. (garril)]

Also der Prescaler war zu hoch. Hab jetzt das ganze ohne Prescaler 
probiert.
Die 8 hat auch nicht so ganz gestimmt.
Ohne Prescaler kommt man bei der if-Abfrage mit >38 ganz gut hin. 
Allerdings ist das wohl total ungeau. Klappt nicht immer und sobald ich 
das auf 37 oder 39 stelle ist die LED entweder immer an oder immer aus.

Verfolge ich vielleicht einen ganz falschen Ansatz?

[olibert (Gast)]

Michael, vielleicht kann ich dir indirekt weiterhelfen. Ich habe letzte 
Woche eine aehnliche Schaltung aufgebaut und mich an Frank Links 
RC5-Motorpotisteuerung orientiert..

http://www.elektor.de/jahrgang/2008/november/einstellen-mit-niveau.710381.lynkx

..und einige Anpassungen an der Software (RC5-Codes auch auf UART) und 
HW (Motoransteuerung ueber L203 statt parallelschalten der 
Atmega8-Ausgaenge).

Franks RC5-Auswertung funktioniert einwandfrei und die Software ist ein 
freier Download unter obigen Link. Vielleicht kann dir Franks Quellcode 
ein
paar Tips geben, wie andere das Problem geloest haben.

[Michael N. (garril)]

Da wurde wohl auch der Code von Peter Dannegger benutzt. Ich habe ihn 
jetzt mal auf mich angepasst. Funktioniert allerdings noch nicht...

Hab ein ext. Quarz dran und an PB0-7 je eine LED.
IR-Empfänger hängt an PD7
main.h

#define F_CPU 7372000L

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <util/delay.h>
#include <stdlib.h>


#define uchar unsigned char
#define uint unsigned int

#define  xRC5_IN    PIND
#define  xRC5    PD7      // IR input low active

#define  XTAL    7.372e6
//#define  XTAL    11.0592e6 <<Original
//#define  XTAL    7.3728e6
//#define XTAL    5e6

#define  BAUD  19200
#define bauddivider (uint)(XTAL / BAUD / 16 - 0.5)


extern uint  rc5_data;        // store result

und die rc5-receiver.c:

#include "main.h"
#define an(port,b) (port) |= (1<<(b))
#define aus(port,b) (port) &= ~(1<<(b))

#define RC5TIME   1.778e-3    // 1.778msec
#define PULSE_MIN  (uchar)(XTAL / 512 * RC5TIME * 0.4 + 0.5)
#define PULSE_1_2  (uchar)(XTAL / 512 * RC5TIME * 0.8 + 0.5)
#define PULSE_MAX  (uchar)(XTAL / 512 * RC5TIME * 1.2 + 0.5)


uchar  rc5_bit;        // bit value
uchar  rc5_time;        // count bit time
uint  rc5_tmp;        // shift bits in
uint  rc5_data;        // store result


SIGNAL (SIG_OVERFLOW0)
{
  uint tmp = rc5_tmp;        // for faster access

  TCNT0 = -2;          // 2 * 256 = 512 cycle

  if( ++rc5_time > PULSE_MAX ){      // count pulse time
    if( !(tmp & 0x4000) && tmp & 0x2000 )  // only if 14 bits received
      rc5_data = tmp;
    tmp = 0;
  }

  if( (rc5_bit ^ xRC5_IN) & 1<<xRC5 ){    // change detect
    rc5_bit = ~rc5_bit;        // 0x00 -> 0xFF -> 0x00

    if( rc5_time < PULSE_MIN )      // to short
      tmp = 0;

    if( !tmp || rc5_time > PULSE_1_2 ){    // start or long pulse time
      if( !(tmp & 0x4000) )      // not to many bits
        tmp <<= 1;        // shift
      if( !(rc5_bit & 1<<xRC5) )    // inverted bit
        tmp |= 1;        // insert new bit
      rc5_time = 0;        // count next pulse time
    }
  }

  rc5_tmp = tmp;
}


void putchar( char c )
{
  while( (UCSRA & 1<<UDRE) == 0 );
  UDR = c;
}


void puts( char *s )
{
  while( *s )
    putchar( *s++ );
}


int main( void )
{
  DDRB = 0xFF; //Port B als Ausgang
  DDRD = 0x7F; //PD7 Eingang
  uint i;
  char s[30];

  TCCR0 = 1<<CS02;      //divide by 256
  TIMSK = 1<<TOIE0;      //enable timer interrupt

  UBRRL = bauddivider;      //set baud rate
  UBRRH = bauddivider >> 8;
  UCSRA = 0;        //no U2X, MPCM
  UCSRC = 1<<URSEL^1<<UCSZ1^1<<UCSZ0;  //8 Bit
  UCSRB = 1<<RXEN^1<<TXEN;    //enable RX, TX

  sei();
  puts( "RC5-Dekoder:\n\r" );
  for(;;){        // main loop
    cli();
    i = rc5_data;      // read two bytes from interrupt !
    rc5_data = 0;
    sei();
    if( i ){
      DDRB = i;        // LED output
      putchar(( i >> 11 & 1) + '0');  // Toggle Bit
      putchar(' ');
      itoa( i >> 6 & 0x1F, s, 10);  // Device address
      puts( s );
      putchar(' ');
      itoa((i & 0x3F) | (~i >> 7 & 0x40), s, 10); // Key Code
      puts( s );
      puts( "\n\r" );
    }
  }
}

Weiß nicht wo der Hund begraben ist...
Wo sollte ich mit der Fehlersuche ansetzen?
LEDs bleiben einfach dunkel
Die includes habe ich etwas angepasst, da der code noch recht alt war.