Verständniss Frage zu einer Modulation

[Janiiix3]

Okay... Also müsste ich eigentlich nur in meiner 36kHz ISR Meine IR LED bedienen? Die Pause realisiere ich mit einem anderen Timer. Und dann einfach via. Flag die LEDs in der 36kHz ISR pulsen sehe ich das soweit richtig?

[Searcher]

Okay... Also müsste ich eigentlich nur in meiner 36kHz ISR Meine IR LED bedienen?

So wie ich das kenne, gibt es keine 36kHz-ISR. Die 36kHz werden mit einem Timer HW-mäßig auf einem der OC Pins ausgegeben. Der Pin wird dann mit den 889µs Zeiten entsprechend ein und ausgeschaltet.

EDIT. Glaub hatte ein bißchen Blödsinn geschrieben und das nun gelöscht

Gruß
Searcher

[Janiiix3]

Ist mir klar das es nicht direkt eine 36kHz ISR gibt. Die Frequenz erzeuge ich mit Timer1(16 Bit). Habe diese auch schon mit dem Oszilloskop nachgemessen, dass passt soweit. Meine Frage ist jetzt nur noch ob ich die Pins dann halt dort schalten muss oder direkt nach der 880us Pause... Ich poste am besten demnächst mal meinen bisherigen Code.

[Searcher]

Meine Frage ist jetzt nur noch ob ich die Pins dann halt dort schalten muss oder direkt nach der 880us Pause...

Ich verstehe die Frage nicht so richtig. Die 36kHz werden erzeugt und die IR-LED sendet mit dieser Frequenz ihr Licht aus bzw schaltet ihr IR-Licht mit dieser Frequenz ein und aus.

Im Ruhezustand wird der PIN abgeschaltet. IR-LED ist aus. Soll eine "1" gesendet werden, muß die IR-LED für 889µs aus sein und dann wird der PIN für 889µs eingeschaltet. In diesen 889µs "flackert" die IR-LED mit 36kHz. Danach wieder aus bzw ist davon abhängig, was als nächstet gesendet werden soll - eine "1" oder eine "0"

Gruß
Searcher

[Janiiix3]

Die Modulations Frequenz beträgt 36kHz.

In dieser ISR die dementsprechend überläuft, schalte ich meine LED ein und aus... Soweit klar. Nun will ich aber nicht einfach mit nem delay meine Pause von 889us erzeugen sondern mit einem anderen Timer. Dies wollte ich halt über Flags machen... Ich glaube wir reden aneinander vorbei. Ich bin leider kein guter erklärer...

[Searcher]

Na ja, in dem Fall ist kompilierbarer Beispiel-/Testcode bestimmt die beste Diskussionsgrundlage. Grundsätzlich ist es gut delays zu vermeiden, besonders in ISRs.

Gruß
Saercher

[Peter(TOO)]

Hallo,

Die Modulations Frequenz beträgt 36kHz.

Sorry, Nein!
Die 36kHz sind die Trägerfrequenz.
Diese muss zum Empfänger passen (Der Empfänger hat ein entsprechen des Filter, da gib es eine ganze Reihe an Frequenzen so zwischen 35 und 40 kHz).

Das Takten dieser 36kHz ist dann die Modulation!

Codiert ist das Ganze als Manchster:
https://de.wikipedia.org/wiki/Manchester-Code
https://de.wikipedia.org/wiki/RC-5

MfG Peter(TOO)

[Janiiix3]

Sooo nun bin ich wieder erwacht :-P

Hier mal mein aktueller Quellcode. Ich mache mit großer Sicherheit irgendwas ganz gravierendes falsch...

#define F_CPU 16000000

#define RC5_HALF_BIT_TIME 8 // 8 * 111µs = 888µs

#define RC5_SEND_ON        PORTD |=  (1<<PD1)
#define RC5_SEND_OFF    PORTD &= ~(1<<PD1)

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


void rc5_send_command(uint16_t command);
void rc5_send_one(void);
void rc5_send_zero(void);
void delay_880(void);

volatile static uint8_t modulation, rc5_half_bit_cnt, rc5_state;

uint16_t rc5_byte = 0x00;

int main(void)
{
    DDRB |= (1<<PB7);
    DDRD |= (1<<PD1);
    
    TCCR0A  = (1<<WGM01);  // CTC
    TCCR0B  = (1<<CS01);   // 8 ( ca. 111µs @ 8 MHz )
    TCCR1B  = (1<<CS10);   // 1 ( ca. 36 kHz @ 8 MHz )
    TCCR1B |= (1<<WGM12);  // CTC
    TIMSK0  = (1<<OCIE0A); // OutputCompare0A
    TIMSK1  = (1<<OCIE1A); // OutputCompare1A

    OCR0A  = (0x6E);
    OCR1A  = (0x00DD);

    sei();
    

            
    while(1)
    {
        rc5_send_command(0b11000000001100);            
    }
}

/* send a 14 bit command to the IR - Receiver */
void rc5_send_command(uint16_t command)
{
    uint16_t send_byte = command;
    
    for (uint16_t x = 0 ; x < 14 ; x++)
    {
        if (send_byte & 0x8000)
        {
            rc5_send_one();
        }
        else
        {
            rc5_send_zero();
        }
        send_byte <<= 0x0001;
    }
}

/* send a logical one to the Receiver ( 1 --> 0 ) */
void rc5_send_one(void)
{
    rc5_state &= ~(0x40);
    delay_880();
    rc5_state |=  (0x40);
    delay_880();
}

/* send a logical zero to the  Receiver ( 0 --> 1 ) */
void rc5_send_zero(void)
{
    rc5_state |= (0x40); // led on
    delay_880();    
    rc5_state &= ~(0x40); // led off
    delay_880();
}

void delay_880(void)
{
    while(1)
    {
        if ((rc5_state & 0x01) == 0x01)
        {
            rc5_half_bit_cnt = 0x00;
            rc5_state = 0x00;
            break;
        }
    }
}

/* called every 111 µs */
ISR(TIMER0_COMPA_vect)
{
    rc5_half_bit_cnt++;
    
    if (rc5_half_bit_cnt >= RC5_HALF_BIT_TIME)
    {
        rc5_half_bit_cnt = 0x00;
        rc5_state |= 0x01;            
    }
}

/* called every 0,0278 ms */
ISR(TIMER1_COMPA_vect)
{
    if ((rc5_state & 0x40) == 0x40)
    {
        RC5_SEND_ON;
    }
    else
    {
        RC5_SEND_OFF;
    }
}

[oberallgeier]

Ist mir klar das es nicht direkt eine 36kHz ISR gibt. Die Frequenz erzeuge ich mit Timer1(16 Bit) ...

Rechne bitte mal nach: die 889 µs sind so lange, dass die 36 kHz zweiunddreissig mal reinpassen (32,0040). Wenn man jetzt DOCH ne 72 kHz ISR initialisiert und darin nen Counter und ein Flag "RC5led_on" mitführt, dann kann man a) durch Toggeln der LED mit 36 kHz blinken ODER auch nicht blinken (RC5led_on = 0;_==> if ( RC5LED_on ) ToggleBit (PORTx, PINnr);_). Nur mal so - als Denkanstoss. Mit nem andern Counter könnte man dann die vierzehn Bit des Datentelegramms schalten . . . (soweit es mir auf die Schnelle einfällt).

Nachtrag: das Codetiming MUSST Du NICHT auf die Mikrosekunde genau einhalten. Das ist schon ein bisschen flexibel