IRMP Atmega168 Signal wird falsch übergeben?

[Julian T. (Firma: Stuttgart) (livingevil)]

Hallo Leute,

ich bin neu hier, einigermaßen fachfremd und minimal ausgestattet, 
sprich Atmega168, IR Empfängermodul und China Fernbedienung (NEC).

Wenn ich das Signal direkt mit dem IR Empfänger über die Soundkarte 
auslese sieht es vernünftig aus (Orignial_Signal.png, rechtes Bild). 
Wenn ich das gleiche mit dem Signal mache, welches die CallBack LED 
bekommt, sieht es verfälscht aus, siehe Bild "Call_Back_Signal.png", was 
vermutlich der Grund ist, warum ich keine Reaktion auf einprogrammierte 
Befehle erhalte.

Frage 1: Ist es korrekt, dass die CallBack LED, programmiert nach dem 
Beispiel aus dem Hauptthread, dauerhaft leuchtet, solange kein IR Signal 
empfangen wird?

Frage 2: Woran kann es liegen, dass die Pulsweiten so verfälscht werden? 
Kann das an F_Cpu liegen oder ist das ein Hardware-Problem?


sorry das erste Bild ist falsch

[Frank M. (ukw) (Moderator)]

Julian Tauscher schrieb:

> Wenn ich das gleiche mit dem Signal mache, welches die CallBack LED
> bekommt, sieht es verfälscht aus,

Da das Signal mit 15kHz gescannt wird, ist das Ergebnis, welches Du über 
die Callback-Funktion erhältst, naturgemäß etwas verfälscht. Bei Dir ist 
das aber schon erheblich - vermuteter Grund: Siehe unten.

Trotzdem würde ich auf den Output keinen großen Wert legen. Die 
Callback-Funktion ist eher dafür gedacht, zu signalisieren, ob überhaupt 
ein Signal detektiert wird.

> Frage 2: Woran kann es liegen, dass die Pulsweiten so verfälscht werden?
> Kann das an F_Cpu liegen oder ist das ein Hardware-Problem?

Ich tippe darauf, dass Dein ATmega nur mit 1 MHz statt 8 MHz läuft. 
Prüfe mal bitte die CKDIV8-Fuse, welche den Takt nochmal durch 8 teilt. 
Bei einem Takt von 1MHz ist die Abtastrate auch nur noch ein Achtel, 
also 1875 Hz. Das würde auch das schlechte Muster der Callback-LED 
erklären.

Wenn es daran nicht liegt, zeige bitte mal irmpconfig.h.

[Julian T. (Firma: Stuttgart) (livingevil)]

Sorry für die Verspätung, habe an den Fuses rumprobiert und den int. 
128kHz Osc. aktiviert...hat ne ganze Weile gedauert bis ich wieder bei 
8MHz angekommen bin (Klassiker) ;)

Dein Tipp mit der CKDIV8-Fuse war Gold wert: Was ich nun erreicht habe, 
ist im Grunde das Input Signal 1:1 über die CallBack Funktion wieder 
auszugeben (hab hier einige IR Dioden rumliegen). Dafür habe ich dein 
CallBack Beispiel invertiert, sprich die Callback-IR Diode geht bei 
jedem High-Pegel am Input 'an', statt wie bisher 'aus'.

Was ich jedoch nicht schaffe, eine simple Funktion (LED an, wenn IR 
Befehl erkannt) zu starten. Ich habe wie folgt versucht, meine Funktion 
in die main.c einzubauen:

if (irmp_data.protocol == IRMP_NEC_PROTOCOL &&  irmp_data.address == 0xFF)

switch (irmp_data.command)
     {
       case 0xFD02: key1_pressed(); break;  
     }
void key1_pressed() 
     {
    DDRD=0xFF;
    PORTD=0b10000000;
     _delay_ms(1000);
    PORTD=0b00000000;
     _delay_ms(1000);
     }

Wie viel kann man dabei falsch machen? Hast du vielleicht ein simples 
Bsp., das gewiss funktioniert und auf das ich dann Schritt für Schritt 
aufbauen kann?

Vielen Dank für deine Mühen!

[Frank M. (ukw) (Moderator)]

Wie kommst Du auf die Adresse 0xFF?
Wie kommst Du auf das Kommando 0xFD02?
Wo hast Du die Werte her?

Dein Beispielcode sieht - soweit es der Auszug erlaubt - okay aus. Du 
solltest Dich dem Ziel schrittweise nähern.

Erstmal:

if (irmp_data.protocol == IRMP_NEC_PROTOCOL)
{
    key1_pressed();
}

Wenn das klappt, weiter einengen:

if (irmp_data.protocol == IRMP_NEC_PROTOCOL && irmp_data.address == 0xFF)
{
    key1_pressed();
}

Als letztes dann:

if (irmp_data.protocol == IRMP_NEC_PROTOCOL && irmp_data.address == 0xFF)
{
    if (irmp_data.command == 0xFD02)
    {
        key1_pressed();
    }
}

> Wie viel kann man dabei falsch machen?

In C kann man eine Menge falsch machen ;-)

> Hast du vielleicht ein simples
> Bsp., das gewiss funktioniert und auf das ich dann Schritt für Schritt
> aufbauen kann?

Hast Du Dir das Beispiel-main.c mal angeschaut?

[Frank M. (ukw) (Moderator)]

Ich bin mir ziemlich sicher, dass diese FB als Adresse nicht 0x00FF, 
sondern 0xFF00 verwendet. Hast Du die Werte vielleicht aus irgendwelchen 
Lirc-Tabellen? Lirc beachtet nicht, dass beim NEC-Protokoll die Werte 
als LSB gesendet werden, Lirc berechnet die Codes immwer mittels MSB, 
was hier aber falsch ist.

Besser ist es, Du gibst die empfangenen Codes auf UART oder LCD aus. 
Dann kannst Du sie auch wieder im C-Code verwenden. Die nächste Stufe 
wäre dann, die FB anzulernen und die Codes im EEPROM zu speichern. Dann 
brauchst Du die konkreten Werte überhaupt nicht zu wissen.

[Julian T. (Firma: Stuttgart) (livingevil)]

> Wie kommst Du auf die Adresse 0xFF?
> Wie kommst Du auf das Kommando 0xFD02?
> Wo hast Du die Werte her?

Ich habe beides manuell "analog" mit Hilfe der Soundkarte ausgelesen, da 
ich über kein UART etc verfüge. Ich hatte im ersten Post Bilder 
angehängt, davon zeigt das Bild ganz rechts beispielsweise die Adresse 
00000000 11111111 und ergibt doch mit der Beachtung NEC und LSB -> FF00 
und auf diese Weise auch das Kommando. Keine Sorge, ich habe 
sicherheitshalber alle Kombinationen (byteweise) durchprobiert.


> Hast Du Dir das Beispiel-main.c mal angeschaut?

Ich kenne nur eine main.c, keine Beispiel-main.c oder meinst du das 
Beispiel IN main.c? Ich werde heute Abend nochmal probieren, mich mit 
deiner Schritt-für-Schritt Methode ranzutasten.

[Frank M. (ukw) (Moderator)]

Julian Tauscher schrieb:
> Keine Sorge, ich habe
> sicherheitshalber alle Kombinationen (byteweise) durchprobiert.

Der oben angegebene Kommando-Code FD02 ist definitiv falsch.

NEC kennt nur 8 Bit als Kommando. Die zweiten 8 Bit sind nur ein 
Komplementärwert zu den ersten. Folglich gibt IRMP auch nur einen 
8-Bit-Wert zurück - nach Prüfung, ob die zweiten 8 Bit komplementär zu 
den ersten 8-Bit sind.

> Ich kenne nur eine main.c, keine Beispiel-main.c oder meinst du das
> Beispiel IN main.c?

Ja, ich meinte das Beispiel in main.c. Das einfachste ist nämlich, den 
von IRMP ermittelten Code (Protokoll, Adresse, Kommando) auf dem UART 
auszugeben. Genau das macht das beispielhafte main.c, sprich 
Beispiel-main.c. Du brauchst also nur einen UART_zu_USB-Adapter an den 
ATmega anzuschließen und Dir werden sämtliche Werte direkt in einer 
Terminal-Emulation bei 9600/8/N ausgegeben, fertig.

> Ich werde heute Abend nochmal probieren, mich mit
> deiner Schritt-für-Schritt Methode ranzutasten.

Warum so umständlich mit einer LED? Okay, Du kannst Adresse und 
Kommando-Code auch morsen ;-)

[Julian T. (Firma: Stuttgart) (livingevil)]

Im Moment schaffe ich es nicht einmal, dass das Protokoll

if (irmp_data.protocol == IRMP_NEC_PROTOCOL)

erkannt wird. Die Callbackfunktion sagt mir aber, dass das Signal 
richtig ankommt, da es ja 1:1 wieder ausgegeben wird. Ich habe das 
Gefühl, dass ich in der main.c noch etwas verbockt habe, aber ich komm 
nicht drauf wie. Dein Beispiel war nicht explizit in dem Code-Bereich, 
der für die AVRs gedacht ist deklariert, sondern weiter unten...von dort 
habe ich mir den kopiert. Aber daran kanns eigentlich nicht liegen - ist 
ja der gleiche code, wie du mir oben als Bsp. gegeben hast. Hast du 
vielleicht noch eine Idee woran es liegen kann?

[Frank M. (ukw) (Moderator)]

Das main.c im IRMP-Paket ist auch hier zu sehen:

   http://www.mikrocontroller.net/svnbrowser/irmp/main.c?view=markup

Lass Dich nicht verwirren, dass da auch Code für PIC & STM32 drin ist, 
der wird von Deinem Compiler ignoriert.

Schließe einen USB->UART-Wandler an RX/TX vom ATmega an, z.B. diesen:

  http://shop.myavr.de/systemboards%20and%20programmer/myUSBtoUART.htm?sp=article.sp.php&artID=200024

Beachte: RX -> TX und TX -> RX

Dann sollten die empfangenen Codes direkt ausgegeben werden.

Ansonsten: Zeige mal Deine main.c.

[Julian T. (Firma: Stuttgart) (livingevil)]

Servus, ich habe das Gefühl, das etwas grundliegends falsch ist. Denn 
unabh. von den Kommandos, sollte das Programm wenigstens die Codierung 
(NEC etc.) erkennen. Daher mal die main.c wie folgt, mit der Bitte an 
Dich, ob dir etwas auffällt:

#include "irmp.h"
 #define F_CPU 8000000UL
#ifndef F_CPU
#error F_CPU unkown
#endif

/*---------------------------------------------------------------------------------------------------------------------------------------------------
 * ATMEL AVR part:
 *---------------------------------------------------------------------------------------------------------------------------------------------------
 */
#if defined (ATMEL_AVR)

  #define LED_PORT PORTD                                  // LED at PD6
  #define LED_DDR  DDRD
  #define LED_PIN  6


#include "irmp.h"
#define BAUD  9600L
#include <util/setbaud.h>

#ifdef UBRR0H

#define UART0_UBRRH                             UBRR0H
#define UART0_UBRRL                             UBRR0L
#define UART0_UCSRA                             UCSR0A
#define UART0_UCSRB                             UCSR0B
#define UART0_UCSRC                             UCSR0C
#define UART0_UDRE_BIT_VALUE                    (1<<UDRE0)
#define UART0_UCSZ1_BIT_VALUE                   (1<<UCSZ01)
#define UART0_UCSZ0_BIT_VALUE                   (1<<UCSZ00)
#ifdef URSEL0
#define UART0_URSEL_BIT_VALUE                   (1<<URSEL0)
#else
#define UART0_URSEL_BIT_VALUE                   (0)
#endif
#define UART0_TXEN_BIT_VALUE                    (1<<TXEN0)
#define UART0_UDR                               UDR0
#define UART0_U2X                               U2X0
        
#else

#define UART0_UBRRH                             UBRRH
#define UART0_UBRRL                             UBRRL
#define UART0_UCSRA                             UCSRA
#define UART0_UCSRB                             UCSRB
#define UART0_UCSRC                             UCSRC
#define UART0_UDRE_BIT_VALUE                    (1<<UDRE)
#define UART0_UCSZ1_BIT_VALUE                   (1<<UCSZ1)
#define UART0_UCSZ0_BIT_VALUE                   (1<<UCSZ0)
#ifdef URSEL
#define UART0_URSEL_BIT_VALUE                   (1<<URSEL)
#else
#define UART0_URSEL_BIT_VALUE                   (0)
#endif
#define UART0_TXEN_BIT_VALUE                    (1<<TXEN)
#define UART0_UDR                               UDR
#define UART0_U2X                               U2X

#endif //UBRR0H

static void
uart_init (void)
{
    UART0_UBRRH = UBRRH_VALUE;                                                                      // set baud rate
    UART0_UBRRL = UBRRL_VALUE;

#if USE_2X
    UART0_UCSRA |= (1<<UART0_U2X);
#else
    UART0_UCSRA &= ~(1<<UART0_U2X);
#endif

    UART0_UCSRC = UART0_UCSZ1_BIT_VALUE | UART0_UCSZ0_BIT_VALUE | UART0_URSEL_BIT_VALUE;
    UART0_UCSRB |= UART0_TXEN_BIT_VALUE;                                                            // enable UART TX
}

static void
uart_putc (unsigned char ch)
{
    while (!(UART0_UCSRA & UART0_UDRE_BIT_VALUE))
    {
        ;
    }

    UART0_UDR = ch;
}

static void
uart_puts (char * s)
{
    while (*s)
    {
        uart_putc (*s);
        s++;
    }
}

static void
uart_puts_P (PGM_P s)
{
    uint8_t ch;

    while ((ch = pgm_read_byte(s)) != '\0')
    {
        uart_putc (ch);
        s++;
    }
}

static uint8_t
itox (uint8_t val)
{
    uint8_t rtc;

    val &= 0x0F;

    if (val <= 9)
    {
        rtc = val + '0';
    }
    else
    {
        rtc = val - 10 + 'A';
    }
    return (rtc);
}

static void
itoxx (char * xx, unsigned char i)
{
    *xx++ = itox (i >> 4);
    *xx++ = itox (i & 0x0F);
    *xx = '\0';
}

static void
timer1_init (void)
{
#if defined (__AVR_ATtiny45__) || defined (__AVR_ATtiny85__)                // ATtiny45 / ATtiny85:

#if F_CPU >= 16000000L
    OCR1C   =  (F_CPU / F_INTERRUPTS / 8) - 1;                              // compare value: 1/15000 of CPU frequency, presc = 8
    TCCR1   = (1 << CTC1) | (1 << CS12);                                    // switch CTC Mode on, set prescaler to 8
#else
    OCR1C   =  (F_CPU / F_INTERRUPTS / 4) - 1;                              // compare value: 1/15000 of CPU frequency, presc = 4
    TCCR1   = (1 << CTC1) | (1 << CS11) | (1 << CS10);                      // switch CTC Mode on, set prescaler to 4
#endif

#else                                                                       // ATmegaXX:
    OCR1A   =  (F_CPU / F_INTERRUPTS) - 1;                                  // compare value: 1/15000 of CPU frequency
    TCCR1B  = (1 << WGM12) | (1 << CS10);                                   // switch CTC Mode on, set prescaler to 1
#endif

#ifdef TIMSK1
    TIMSK1  = 1 << OCIE1A;                                                  // OCIE1A: Interrupt by timer compare
#else
    TIMSK   = 1 << OCIE1A;                                                  // OCIE1A: Interrupt by timer compare
#endif
}

#ifdef TIM1_COMPA_vect                                                      // ATtiny84
#define COMPA_VECT  TIM1_COMPA_vect
#else
#define COMPA_VECT  TIMER1_COMPA_vect                                       // ATmega
#endif

ISR(COMPA_VECT)                                                             // Timer1 output compare A interrupt service routine, called every 1/15000 sec
{
  (void) irmp_ISR();                                                        // call irmp ISR
  // call other timer interrupt routines...
}

 
/*-----------------------------------------------------------------------------------------------------------------------
 * Called (back) from IRMP module
 * This example switches a LED (which is connected to Vcc)
 *-----------------------------------------------------------------------------------------------------------------------
 */
void
led_callback (uint8_t on)
{
    if (on)
    {
         LED_PORT &= ~ (1 << LED_PIN);
       }
       else
       {
   
     LED_PORT |=(1 << LED_PIN);
    }
}
/*-----------------------------------------------------------------------------------------------------------------------*/

int main (void)
{  

  
    IRMP_DATA   irmp_data;
    char        buf[3];
  
   if (irmp_get_data (&irmp_data))
   {
     if (irmp_data.protocol == IRMP_NEC_PROTOCOL ||IRMP_NEC42_PROTOCOL || IRMP_NEC16_PROTOCOL)   // NEC-Protokoll && Adresse 0x1234                
     {
       
      DDRD=0xFF;
      
       PORTD=0b10000000;  //Blinke, wenn du was erkennst...
       _delay_ms(1000);
       PORTD=0b00000000;
       _delay_ms(1000);
       
       
//        switch (irmp_data.command)
//        {
//          case 0x0001: key1_pressed(); break;          // Taste 1
//          case 0x0002: key2_pressed(); break;          // Taste 2
//          ...
//          case 0x0009: key9_pressed(); break;          // Taste 9
//        }
     }
   }

    irmp_init();                                                            // initialize irmp
    
  LED_DDR |= (1 << LED_PIN);                // LED pin to output
  LED_PORT |= (1 << LED_PIN);                // switch LED off (active low)
  irmp_set_callback_ptr (led_callback);
  
  timer1_init();                                                          // initialize timer1
    uart_init();                                                            // initialize uart

    sei ();                                                                 // enable interrupts

    for (;;)
    {
        if (irmp_get_data (&irmp_data))
        {
            uart_puts_P (PSTR("protocol: 0x"));
            itoxx (buf, irmp_data.protocol);
            uart_puts (buf);

#if IRMP_PROTOCOL_NAMES == 1
            uart_puts_P (PSTR("   "));
            uart_puts_P (pgm_read_word (&(irmp_protocol_names[irmp_data.protocol])));
#endif

            uart_puts_P (PSTR("   address: 0x"));
            itoxx (buf, irmp_data.address >> 8);
            uart_puts (buf);
            itoxx (buf, irmp_data.address & 0xFF);
            uart_puts (buf);

            uart_puts_P (PSTR("   command: 0x"));
            itoxx (buf, irmp_data.command >> 8);
            uart_puts (buf);
            itoxx (buf, irmp_data.command & 0xFF);
            uart_puts (buf);

            uart_puts_P (PSTR("   flags: 0x"));
            itoxx (buf, irmp_data.flags);
            uart_puts (buf);

            uart_puts_P (PSTR("\r\n"));
        }
    }
}

/*---------------------------------------------------------------------------------------------------------------------------------------------------
 * LM4F120 Launchpad (ARM Cortex M4):
 *---------------------------------------------------------------------------------------------------------------------------------------------------
 */
#elif defined(STELLARIS_ARM_CORTEX_M4)

void
timer1_init (void)
{
    SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
    TimerConfigure(TIMER1_BASE, TIMER_CFG_32_BIT_PER);

    TimerLoadSet(TIMER1_BASE, TIMER_A, (F_CPU / F_INTERRUPTS) -1);
    IntEnable(INT_TIMER1A);
    TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
    TimerEnable(TIMER1_BASE, TIMER_A);
    // Important: Timer1IntHandler has to be configured in startup_ccs.c !
}

void
Timer1IntHandler(void)                                                      // Timer1 Interrupt Handler
{
  (void) irmp_ISR();                                                        // call irmp ISR
  // call other timer interrupt routines...
}

int
main (void)
{
    IRMP_DATA irmp_data;

    ROM_FPUEnable();
    ROM_FPUStackingEnable();
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);

    irmp_init();                                                            // initialize irmp
    timer1_init();                                                          // initialize timer1
    sei ();                                                                 // enable interrupts

    for (;;)
    {
        if (irmp_get_data (&irmp_data))
        {
            // ir signal decoded, do something here...
            // irmp_data.protocol is the protocol, see irmp.h
            // irmp_data.address is the address/manufacturer code of ir sender
            // irmp_data.command is the command code
            // irmp_protocol_names[irmp_data.protocol] is the protocol name (if enabled, see irmpconfig.h)
        }
    }
}

/*---------------------------------------------------------------------------------------------------------------------------------------------------
 * PIC18F4520 with XC8 compiler:
 *---------------------------------------------------------------------------------------------------------------------------------------------------
 */
#elif defined (__XC8)

#define _XTAL_FREQ  32000000UL                                              // 32MHz clock
#define FOSC        _XTAL_FREQ
#define FCY         FOSC / 4UL                                              // --> 8MHz

#define BAUDRATE 19200UL
#define BRG (( FCY  16  BAUDRATE ) -1UL)

#include <stdio.h>
#include <stdlib.h>

int
main (void)
{
    IRMP_DATA irmp_data;

    irmp_init();                                                            // initialize irmp

    // infinite loop, interrupts will blink PORTD pins and handle UART communications.
    while (1)
    {
        LATBbits.LATB0 = ~LATBbits.LATB0;

        if (irmp_get_data (&irmp_data))
        {
            // ir signal decoded, do something here...
            // irmp_data.protocol is the protocol, see irmp.h
            // irmp_data.address is the address/manufacturer code of ir sender
            // irmp_data.command is the command code
            // irmp_protocol_names[irmp_data.protocol] is the protocol name (if enabled, see irmpconfig.h)
            printf("proto %d addr %d cmd %d\n", irmp_data.protocol, irmp_data.address, irmp_data.command );
        }
    }
}

void interrupt high_priority high_isr(void)
{
    if (TMR2IF)
    {
        TMR2IF = 0;                                                         // clear Timer 0 interrupt flag
        irmp_ISR();
    }
}

/*---------------------------------------------------------------------------------------------------------------------------------------------------
 * STM32:
 *---------------------------------------------------------------------------------------------------------------------------------------------------
 */
#elif defined(ARM_STM32)

uint32_t
SysCtlClockGet(void)
{
    RCC_ClocksTypeDef RCC_ClocksStatus;
    RCC_GetClocksFreq(&RCC_ClocksStatus);
    return RCC_ClocksStatus.SYSCLK_Frequency;
}

void
timer2_init (void)
{
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

    TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseStructure.TIM_Period = 7;
    TIM_TimeBaseStructure.TIM_Prescaler = ((F_CPU / F_INTERRUPTS)/8) - 1;
    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

    TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);

    NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
    NVIC_Init(&NVIC_InitStructure);

    TIM_Cmd(TIM2, ENABLE);
}

void
TIM2_IRQHandler(void)                                                  // Timer2 Interrupt Handler
{
  TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
  (void) irmp_ISR();                                                        // call irmp ISR
  // call other timer interrupt routines...
}

int
main (void)
{
    IRMP_DATA irmp_data;
        
    irmp_init();                                                            // initialize irmp
    timer2_init();                                                          // initialize timer2

    for (;;)
    {
        if (irmp_get_data (&irmp_data))
        {
            // ir signal decoded, do something here...
            // irmp_data.protocol is the protocol, see irmp.h
            // irmp_data.address is the address/manufacturer code of ir sender
            // irmp_data.command is the command code
            // irmp_protocol_names[irmp_data.protocol] is the protocol name (if enabled, see irmpconfig.h)
        }
    }
}
#endif

[Frank M. (ukw) (Moderator)]

Julian Tauscher schrieb:
> Servus, ich habe das Gefühl, das etwas grundliegends falsch ist. Denn
> unabh. von den Kommandos, sollte das Programm wenigstens die Codierung
> (NEC etc.) erkennen. Daher mal die main.c wie folgt, mit der Bitte an
> Dich, ob dir etwas auffällt:

Da fällt mir eigentlich nichts besonderes auf, da es mehr oder weniger 
die originale main.c (Beispielcode) aus dem IRMP-Paket ist. Das, was Du 
da vor der Endlossschleife eingefügt hast, wird nur einmal beim 
Programmstart durchlaufen. Ich bezweifle, dass Du mit der Fernbedienung 
so schnell bist.

Und dann hast Du es noch vor irmp_init() eingefügt. Das kann nicht 
klappen.

Ersetze bitte die Funktion main() durch folgenden Code, wenn Du wirklich 
nur eine LED hast und partout nicht bereit bist, am UART einen 
USB-Adapter anzuschließen:

int main (void)
{  
    IRMP_DATA   irmp_data;
  
    irmp_init();                        // initialize irmp
    
    LED_DDR |= (1 << LED_PIN);          // LED pin to output
    LED_PORT |= (1 << LED_PIN);         // switch LED off (active low)
    irmp_set_callback_ptr (led_callback);
  
    timer1_init();
    sei();                              // enable interrupts
    DDRD=0xFF;                          // Port D auf Ausgang

    for (;;)
    {
        if (irmp_get_data (&irmp_data))
        {
            if (irmp_data.protocol == IRMP_NEC_PROTOCOL) 
            {
                PORTD=0b10000000;  //Blinke, wenn du was erkennst...
                _delay_ms(1000);
                PORTD=0b00000000;
                _delay_ms(1000);
            }
        }
    }
}

Das hier:

if (irmp_data.protocol == IRMP_NEC_PROTOCOL ||IRMP_NEC42_PROTOCOL || IRMP_NEC16_PROTOCOL)

ist übrigens Käse. Das schreibt man so:

if (irmp_data.protocol == IRMP_NEC_PROTOCOL || irmp_data.protocol == IRMP_NEC42_PROTOCOL || irmp_data.protocol == IRMP_NEC16_PROTOCOL)

Ich hoffe, dass die LED, die da blinken soll, nicht die Callback-LED 
ist. Sonst schaltet Dir die Callback-Funktion Deine LED sofort wieder 
aus. Sicherheitshalber solltest Du erstmal den Aufruf von

   irmp_set_callback_ptr (led_callback);

auskommentieren.

[Julian T. (Firma: Stuttgart) (livingevil)]

Servus Frank,

vielen Dank, mit deiner Hilfe habe ich es jetzt hinbekommen (hat etwas 
gedauert hust). Worauf ich stolz bin: ohne UART..also mit einfachsten 
Mitteln (das ist mein Anspruch an mich selbst ;) )

Woran es also lag:

-die main war falsch, mit deinem Vorschlag tut es
-ich wusste nicht, dass als Kommando nur die nicht invertierte Version 
interessiert
-die Reihenfole LSB MSB war genau umgekehrt wie auf der Tabelle, von der 
ich die Codes für meine FB habe. FF00 war btw. die von dir richtig 
vermutete Adresse.

[Frank M. (ukw) (Moderator)]

Gratuliere! Viel Spaß noch mit IRMP :-)