Druckbare Version
Hallo Leute,
ich habe noch ein Problem damit zu verstehen wie der Ablauf einer Modulation ist.
Speziell geht es um die "RC5" Modulation.
Habe mir jetzt erstmal meine Zeitbasen aufgebaut.
880us , 1778ms und meine Modulationsfrequenz 36kHz
wie muss ich denn jetzt vorgehen ?
um eine "1" zu senden -->
Wie muss ich jetzt die 36kHz anwenden?Code:IR_LED_ON
delay_880;
IR_LED_OFF;
delay880; // logische 1
Stehe total auf dem Schlauch.. Ich mache was gravierendes falsch.
würde mich auf Hilfe freuen.
Hi, RC-5 fühlt sich manchmal total doof an, fremdartig! Isses nicht. San B. hat hier>> viel Arbeit reingesteckt, das sollte Dir doch auf die Sprünge helfen. Dort >> steht auch ausführlich der RC-5 beschrieben. Das tatsächliche Problem ist, dass die 0 und die 1 sozusagen spiegelverkehrt sind, zum Senden und zum Lesen muss man halt einen entsprechend langen Burst mit 36 kHz-Pulsen per LED rauslassen - und vorher oder nachher eine entsprechende Pause.Zitat:
... habe noch ein Problem ... um die "RC5" Modulation ... Wie ... die 36kHz anwenden ... Stehe total auf dem Schlauch ...
Steht aber ziemlich sauber in den beiden Links beschrieben. Ich habe mit RC-5 fast bei praktisch allen meinen Gimmicks (autonome Coladose oder Archie - der kleine Bruder von Jonny5) ne Tastksteuerung über RC-5 eingebaut, teilweise auch dreistellige Ziffern - wie beim Fernseher. Läuft prima.
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?
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.Zitat:
Zitat von Janiiix3
EDIT. Glaub hatte ein bißchen Blödsinn geschrieben und das nun gelöscht :(
Gruß
Searcher
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.
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.Zitat:
Zitat von Janiiix3
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
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... :rolleyes:
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
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).Zitat:
Zitat von Janiiix3
Nachtrag: das Codetiming MUSST Du NICHT auf die Mikrosekunde genau einhalten. Das ist schon ein bisschen flexibel ;-)
Hallo,
Sorry, Nein!Zitat:
Zitat von Janiiix3
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)
Sooo nun bin ich wieder erwacht :-P
Hier mal mein aktueller Quellcode. Ich mache mit großer Sicherheit irgendwas ganz gravierendes falsch...
Code:#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;
}
}
Deine ISR gibt doch gar kein 36kHz-Signal aus, statt dessen ist der Pin jeweils 880µs lang 0 oder 1. Die ISR müsste eher so aussehen:
Außerdem müsstest du das Intervall für die ISR halbieren, denn für ein 36kHz-Signal musst du den Pin ja mit 72kHz toggeln.Code:ISR(TIMER1_COMPA_vect)
{
if ((rc5_state & 0x40) == 0x40)
{
RC5_SEND_TOGGLE;
}
else
{
RC5_SEND_OFF;
}
}
ABER: Wie andere schon sagten, es wäre viel sinnvoller das 36kHz-Signal direkt vom Timer erzeugen zu lassen, und dann entsprechend einfach ein- und auszuschalten.
Stefan, wieder schön; wirklich gut und knapp erklärt. Aber derJaniiix3 sollte das ja schon wissen, zumindest wenn er die ausführlichen, anschaulichen Erläuterungen von Seb durchgearbeitet hätte. Mit solchen Erklärungen zur Modulation (wo man sogar die 36 kHz erkennt *ggg*)Zitat:
.. kein 36kHz-Signal .. statt dessen .. 880µs lang 0 oder 1 .. Wie andere schon sagten .. für .. 36kHz .. mit 72kHz toggeln ..
......Bild hier
......zum Aufbau der beiden Datenbits (>>klick) oder zum Aufbau des RC-5-Protokolls
......Bild hier
sollte der Sachvorgang doch klar werden (dachte ich). Aber ich habe selbst auch (?noch?) immer wieder diesen Hang zur experimentellen Softwarentwicklung.