Anfängerfrage

[Toolchaire (Gast)]

Hallo liebe Community,

bin derzeit dabei einen IR-Empfänger mithilfe eines ATMega8 zu 
programmieren.
Als Protokoll verwende ich das RC5-Protkoll von  Phillips da es recht 
verbreitet ist.

Da ich alles in C schreibe (bzw. versuche :P) benutzte ich den avr-gcc 
Compiler für das AVR-Studio.

Habe etwas im Netz recherchiert und bin auf die Anleitung von 
"Roboternetz" gekommen: 
rn-wissen.de/index.php/RC5-Decoder_f%C3%BCr_ATMega

Da meine Kenntnisse nicht allzu gut sind, ich dies aber als ein Projekt 
zugeteilt bekommen habe möchte ich das natürlich halbwegs fertigstellen. 
Bitte hierfür Verständnis haben, ich gebe mir Mühe! Für alle, die keine 
Interesse haben zu helfen, bitte ich auch hier in den Thread nichts zu 
posten :).


Also, wiegesagt ich habe den  Code von RN und auch abgetippt, versucht 
zu verstehen und compiliert. Leider funktioniert das bis jetzt noch 
nicht, ich habe hier mal meinen Code:

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

// Für alte avr-gcc Versionen
#ifndef SIGNAL
#include <avr/signal.h>
#endif // SIGNAL

#include "rc5_decoder.h"

#ifndef RC5_INT
#define RC5_INT      RC5_INT0
#endif  /* RC5_INT */
  
#ifndef RC5_PRESCALE
#define RC5_PRESCALE 1024
#endif  /* RC5_PRESCALE */

/* ******************************************************************************** */

rc5_t rc5;

/* ******************************************************************************** */

#define F_CPU 4000000

/* µs for a whole bit of RC5 (first & second part) */
#define RC5_BIT_US   (64*27)

#define RC5_TICKS \
        ((uint8_t) ((uint32_t) (F_CPU / 1000 * RC5_BIT_US / 1000 / RC5_PRESCALE)))
        
#define RC5_DELTA \
        (RC5_TICKS / 6)
        
typedef union 
{
        uint16_t w;
        uint8_t  b[2];
} code_t;

static code_t code;
static uint8_t rc5_addr;

/* Number of Bits received so far */
/* Number of Interrupts occured so far */
static uint8_t nbits;
static uint8_t nint;

/* ******************************************************************************** */
        
void rc5_init (uint8_t addr)
{
        nint  = 0;
        nbits = 0;
        rc5.flip = -1;
        
        rc5_addr = addr;

#if (RC5_PRESCALE==1024)
        TCCR0 = (1 << CS02) | (1 << CS00);
#elif   (RC5_PRESCALE==256)
        TCCR0 = (1 << CS02);
#elif   (RC5_PRESCALE==64)
        TCCR0 = (1 << CS01) | (1 << CS00);
#else
#error This RC5_PRESCALE is not supported
#endif /* RC5_PRESCALE */
        
        /* INTx on falling edge */
        /* clear pending INTx */
        /* enable INTx interrupt */
#if (RC5_INT == RC5_INT0)               
        MCUCR = (MCUCR | (1 << ISC01)) & ~ (1 << ISC00);
        GIFR = (1 << INTF0);
        GICR |= (1 << INT0);
#else
#error please define RC5_INT
#endif /* RC5_INT */
}

/* ******************************************************************************** */

SIGNAL (SIG_OVERFLOW0)
{
        TIMSK &= ~(1 << TOIE0);
        
        uint8_t _nbits = nbits;
        code_t _code = code;
        
        if (26 == _nbits)
        {
                _nbits++;
                _code.w <<= 1;
        }
        
        if (27 == _nbits 
                && _code.b[1] >= 0x30 /* AGC == 3 */
                && 0 > rc5.flip)
        {
                uint8_t _rc5_code;
                uint8_t _rc5_addr;
                /* we do the bit manipulation stuff by hand, because of code size */
                _rc5_code = _code.b[0] & 0x3f; /* 0b00111111 : #0..#5 */
                _code.w <<= 2;
                _rc5_addr = _code.b[1] & 0x1f; /* 0b00011111 : #6..#10 */
                
                if (rc5_addr & 0x80
                        || rc5_addr == _rc5_addr)
                {
                        rc5.code = _rc5_code;
                        rc5.addr = _rc5_addr;
                        signed char flip = 0;
                        if (_code.b[1] & 0x20) /* 0b00100000 : #11 */
                                flip = 1;
                        rc5.flip = flip;
                }
        }
        
        nint = 0;
        nbits = 0;
        
        /* INTx on falling edge */
        /* clear pending INTx */
        /* enable INTx interrupt */
#if (RC5_INT == RC5_INT0)               
        MCUCR = (MCUCR | (1 << ISC01)) & ~ (1 << ISC00);
        GIFR = (1 << INTF0);
        GICR |= (1 << INT0);
#endif
}

/* ******************************************************************************** */

#if (RC5_INT == RC5_INT0)               
SIGNAL (SIG_INTERRUPT0)
#endif /* RC5_INT */
{
        code_t _code = code;
        uint8_t _nint = nint;
        
        uint8_t tcnt0 = TCNT0;
        TCNT0 = 0;
        
        if (0 == _nint)
        {
                /* INTx on both edges */
#if (RC5_INT == RC5_INT0)               
                MCUCR = (MCUCR | (1 << ISC00)) & ~ (1 << ISC01);
#endif /* RC5_INT */
        
                TIFR = (1 << TOV0);
                TIMSK |= (1 << TOIE0);
                _code.w = 0;
        }
        else
        {
                /* Number of bits of the just elapsed period */
                uint8_t n = 1;
         
                /* Bits received so far */
                uint8_t _nbits = nbits;
        
                /* is TCNT0 close to RC5_TICKS or RC5_TICKS/2 ? */
                if (tcnt0 > RC5_TICKS + RC5_DELTA)
                        goto invalid;
                else if (tcnt0 < RC5_TICKS/2 - RC5_DELTA)
                        goto invalid;
                else if (tcnt0 > RC5_TICKS - RC5_DELTA)
                        n = 2;
                else if (tcnt0 > RC5_TICKS/2 + RC5_DELTA)
                        goto invalid;
                
                /* store the just received 1 or 2 bits */
                do
                {
                        _nbits++;
                        if (_nbits & 1)
                        {
                                _code.w <<= 1;
                                _code.b[0] |= _nint & 1;
                        }
                } 
                while (--n);
                
                if (0)
                {
                        invalid:
                        
                        /* disable INTx, run into Overflow0 */
#if (RC5_INT == RC5_INT0)               
                        GICR &= ~(1 << INT0);
#endif /* RC5_INT */

                        _nbits = 0;
                }
                
                nbits = _nbits;
        }

        code = _code;
        nint = 1+_nint;
}

int main()
{

/**************  INITIALISERUNG ***************/


DDRD = 0x00; /* der ensprechende INT-Port muss INPUT sein */
DDRB = 0xff;  


rc5_init (RC5_ALL); /* RC5 initialisieren, alle Adressen zulassen */  

sei();  /* Interrupts zulassen */

/**************  ANWENDUNG ***************/

while(1)
{
 /* Gibt's was Neues? */
if (-1 == rc5.flip)
{
/* Nein, dann mach irgendwas (oder nix) */
}
else
{
/* Ja, dann rc5.code merken und evtl. rc5.addr */
/* falls man die braucht und nicht sowieso schon kennt */
uint8_t code = rc5.code;
uint8_t addr = rc5.addr;
/* und auf naechstes Zeichen warten */
rc5.flip = -1;

/* code (evtl. addr) auswerten */

PORTB  = 0x00;
PORTB=rc5.code;
_delay_ms(2000);
}  //off if 

} //off  while

  return 0;
}

Leider  funktioniert das nicht, ist wahrscheins ein simpler und 
logischer Fehler, aber ich steck eben nicht in der Materie drin.

Also, dnake für alle die mir freundlich helfen!

Gruß Rainer

[Sepp (Gast)]

Guten morgen!
Was genau funktioniert denn nicht? Das compilieren oder das Programm?
So genau sagst du das nicht :-)

Was mir auch auffällt das Interrupt Schlagwort "SIGNAL" wird nicht mehr 
verwendet, jetzt nennt man das "ISR".
Welche Version des GCC verwendest du denn? Die aktuellste?

Gruß Sepp

[Toolchaire (Gast)]

Hi Sepp,

ok also das Compilieren funkt einwandfrei, aber die Funktion des 
Programmes nicht.

Benutze AVR Studio 4.15, ist hier auf dem Schulrechner drauf. Wo kann 
ich die gcc Version einsehen?

Gruß Rainer

[Stryker (Gast)]

#define F_CPU 4000000

Dein µC läuft auch auf 4 Mhz?

[Toolchaire (Gast)]

Also der ATMega8 läuft ja mit 4Mhz und bei "Tools" --> "AVRProg" -->
"Advanced" ist "ExtXTAL, High frequency" eingestellt...

[Peter D. (peda)]

Toolchaire schrieb:
> Als Protokoll verwende ich das RC5-Protkoll von  Phillips da es recht
> verbreitet ist.

Es ist nur gut dokumentiert.
Kommerziell benutzt wird es aber nur sehr selten.
Ich habe kein einziges Gerät, das es verwendet.
Selbst Phillips-Geräte benutzen es nicht.

[Toolchaire (Gast)]

Ok gut zu wissen. Naja, aber das  Problem besteht weiterhin...

[Frank M. (ukw) (Moderator)]

Hast Du überhaupt noch eine (uralte) Fernbedienung, die RC5 sendet? 
Sonst empfehle ich Dir die Lektüre von IRMP.

[Toolchaire (Gast)]

Die UR s2 von vivanco. Es geht ja jetzt um  das Programmiertechnsiche 
Problem

[Oliver (Gast)]

Toolchaire schrieb:
> Es geht ja jetzt um  das Programmiertechnsiche
> Problem

Ganz ehrlich: Threads, in denen jemand von anderen Seiten kopierten 
Sourcecode einstellt, und dann als Fehlerbeschreibung lediglich ein 
"funktzioniert nicht" dazugibt, sind selten zielführend (un im 
allgemeinen in Programmierforen auch nicht gerne gesehen).

Der oben gezeigte Code ist schlicht und einfach absolut grausam. Das ist 
ein Beispiel, wie man Code NICHT schreiben sollte.

Such dir einen anderen.

Schau dir mal das hier an:
http://homepage.hispeed.ch/peterfleury/avr-software.html

oder kurz und knackig, aber auch nicht einfach zu verstehen:
Beitrag "Fernbedien RC5 Empfänger"

Oliver

[Karl H. (kbuchegg)]

Toolchaire schrieb:

> Leider  funktioniert das nicht, ist wahrscheins ein simpler und
> logischer Fehler,

Kann sein. Muss aber nicht sein.

> aber ich steck eben nicht in der Materie drin.

Das tun die wenigsten hier. Ich denke mal, die meisten müssten sich da 
erst mal einarbeiten.

Da musst du dann eben mal etwas analysieren, welche Codeteile 
funktionieren und welche nicht.
Mein erster Ansatz wäre mal die Fragestellung: Werden die ISR überhaupt 
aufgerufen? Das lässt sich zb mit ein paar LED, die in der jeweilige ISR 
eingeschaltet werde leicht überprüfen.

Da das ganze darauf beruht, dass ein Zähler als Stoppuhr verwendet wird, 
würde mich als nächstes mal interessieren, welche Zählerstände (aka 
welche Zeiten) denn festgestellt werden. Und dann hilft alles nichts, 
dann muss man sich eben mal das RC5 Protokoll etwas genauer ansehen, 
welche Zeiten es eigentlich sein sollten.

[Karl H. (kbuchegg)]

> Code von RN und auch abgetippt, versucht zu verstehen


Das ist ja schon mal ein Ansatz.
Wenn du denkst du hast seine Funktionsweise so einigermassen verstanden, 
dann überleg dir, welche Werte besonders relevant sind, überleg dir, wie 
du sie dir im laufenden Betrieb ansehen kannst und überprüf
* ob die tatsächlichen Werte dein Verständnis des Codes stützen
* ob sie plausibel sind
* ob sie sich mit der Protokolldefinition decken.


So funktioniert das nun mal als Softwareentwickler.