Aurel AM 433MHz Empfänger - Signal auswerten

[Mattias K. (Gast)]

Hallo,

ich baue derzeit einen Empfänger (Sender ist schon fertig), der über das 
Aurel 433MHz-Modul ein Rechteckssignal ausgibt. Ich würde gerne den 
AtTiny13 dafür verwenden, um das Digitale Signal aufnehmen und auf seine 
"richtigkeit" und reihenfolge zu prüfen - sprich, stimmt das Empfangene 
Signal mit dem von mir vorgegebenen Signal überein, so so er eine LED 
testweise einschalten.

Bis jetzt habe ich folgendes:

#define F_CPU 960000UL
#include <avr/io.h>
#include <avr/interrupt.h> 
#include <util/delay.h>

  // Sendefolge: 11110001 Binär: 0b10001111

volatile uint8_t code = 0x00;
volatile uint8_t breakcount = 0;
uint8_t ready = 0;
uint8_t active = 0;

ISR(INT0_vect) {
  TCNT0 = 0;            //Rücksetzen des "Auszähltimers"
  code = 0x00;
  breakcount = 1;
  GIMSK &= ~(1<<INT0);      //deaktivieren des externen Interrupts, wenn
  ready = 0;
  active = 1;
}

ISR(TIM0_OVF_vect) {
  if(active) {
    PORTB |= (1<<PB0);
    if (breakcount <= 7) {
      if(PINB & (1<<PB1))
        code |= 0x01;
      code = code << 1;
      breakcount++;
    //  return;
    }
    else
    {
      GIMSK |= (1<<INT0);    //aktivieren des ext. Int.
      breakcount = 0;
      ready = 1;
      code = 0x00;
      active = 0;
    }
    PORTB &= ~(1<<PB0);
  }
}

int main(void) {
  DDRB &= ( ~(1 << PB1) | (1 << PB2)); // PB1 Eingang, PB2 Ausgang
  PORTB = 0xFF;
  PORTB &= ~(1<<PB2);

  //Interrupt bei steigender Flanke
  MCUCR |= (1 << ISC01) | (1 << ISC00);
  GIMSK = (1 << INT0);
  PCMSK = 0x00;

  TCCR0B = (1<<CS00) | (1<<CS02);
  TIMSK0 |= (1<<TOIE0);
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.625);

  sei();

  while(1) {
    if(ready) {
      if(code == 0x8F)      
        PORTB |= (1<<PB2);
    }
  }
  return 0;
}

Klappt aber nicht so ganz, wie ich mir das vorstelle, habt ihr eine 
Idee, wie ich das mit dem Tiny lösen kann? Oder muss ich doch zu einem 
anderen µController greifen?

Habe bereit im Forum ca. 5 Stunden lang herum gesucht, wurde aber nicht 
fündig. Vielleicht habe ich auch nur nach den falschen Begriffen 
gesucht.

Ich danke euch trotzdem schoneinmal im vorraus für euere Unterstützung.

Mfg
Mattias

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Dein Controller läuft tatsächlich mit 960 Khz ?

Mattias Köpke schrieb:
> #define F_CPU 960000UL

[Mattias K. (Gast)]

Ohhh nein, habe den Oszilator (intern) auf 9,6MHz eingestellt. 
Verdammt^^
Mir passieren immer so kleine Fehler.

#define F_CPU 9600000UL
#include <avr/io.h>
#include <avr/interrupt.h> 
#include <util/delay.h>

Bin C++ Programmierer für Windows, habe mit dem µC erst angefangen.
Erkennt sonst noch jemand einen Fehler? habe es nocheinmal versucht, 
funktioniert trotzdem nicht.
Danke!

[Mattias K. (Gast)]

Änderung:

ISR(INT0_vect) {
  TCNT0 = 0;            //Rücksetzen des "Auszähltimers"
  code = 0x00;
  breakcount = 0;
  GIMSK &= ~(1<<INT0);      //deaktivieren des externen Interrupts, wenn
  ready = 0;
  active = 1;
}

[Mattias K. (Gast)]

Kann mir niemand Helfen, oder mir einen Tipp geben, nach was ich suchen 
könnte? Bin irgendwie ratlos.

Danke.

[Sascha W. (sascha-w)]

Hallo,

was gibt dein Empfangsmodul aus wenn dein Sender nicht sendet?
Nach kurzem Blick ins Datenblatt - wenn ich das richtige erwicht habe - 
kommt dort in dem Falle ein digitales Rauschen raus. Damit decodiert 
deine Software ständig irgendwas und es währe Zufall wenn während einer 
Sendephase die Auswertung an der richtigen Bitposition beginnt.
Am Sender brauchst du also ein Startbit das du aufgrund seiner Dauer am 
Empfänger eindeutig idendifizieren kannst. Dann kannst du auch nicht 
damit rechnen, das bei einer Funkübertragung das Signal störungsfrei am 
Empfänger ankommt - einfach den Bitzustand einlesen wird daher auch 
nicht funktionieren.
Schau dir mal die IR-Protolle an - die kannst du auch für Funk nehmen 
und es gibt auch schon passenden Routinen.

Sascha

[Mattias K. (Gast)]

Zuerst einmal - danke.

Im Anhang habe ich das Datenblatt des Empfängers eingefügt, das ich zu 
dem Modul erhalten habe. Das Modul habe ich übrigens bei Conrad gekauft. 
Bei der Artikelbeschreibung des Moduls sind auch Datenblätter, die sind 
jedoch anders als die, die ich hier habe.

Mfg

[Sascha W. (sascha-w)]

... gut dann hatte ich das richtige Datenblatt.
Der Ausgang des Moduls liefert nur dann ein stabiles Signal wenn ein 
Träger auf der entsprechenden Frequenz gesendet wird. Ansonsten hast du 
nach einigen 10..100ms nur Rauschen am Ausgang. Deshalb sollte man die 
Daten auch nicht so senden wie du, da dort zu viel 
'Gleichspannungsanteil' vorhanden ist (u.u. viele aufeinanderfolgende 
0'en oder 1'sen).


Sascha

[Mattias K. (Gast)]

Okay, d.h. ich soll die Übertragungsgeschwindigkeit erhöhen!?
Derzeit liegt die Länge für ein Bit bei 10,05ms. (War eigentlich nur zum 
Test)

Also fasse ich nochmal meine Änderungen zusammen:
* Übertragungsgeschwindigkeit erhöhen auf max. 250µS/Bit also 4KHz
* Startbits setzten z.b. 2ms High (VCC)
* Dann z.b. ein 8 Bit Datensatz übertragen

Könnte das dann so ungefähr klappen?

Lg

[ich da (Gast)]

Gleichspannungsfrei senden bedeutet, eine andere Codierform benutzen, 
das meint er.

Z.B. Manchestercode. Schau mal bei Wikipedia danach, dort findest du 
dieser Code ist Gleichspannungsfrei. Alternativen ebendort.

[Mattias K. (Gast)]

Achso! Ok - werde ich tun. Ich danke euch :)

[Sascha W. (sascha-w)]

Mattias Köpke schrieb:
> Okay, d.h. ich soll die Übertragungsgeschwindigkeit erhöhen!?
nicht unbedingt
> Derzeit liegt die Länge für ein Bit bei 10,05ms. (War eigentlich nur zum
> Test)
nicht die Bits direkt kodieren, sondern den Bitzustand in der 
Sendedauer, oder Pausenlänge kodieren

schau mal hier bei den IR-Protokollen
http://www.mikrocontroller.net/articles/IRMP#Die_IR-Protokolle_im_Detail
Die angegebene Frequenz kannst du natürlich vergessen, die ist bei dir 
ja 433MHz.

>
> Also fasse ich nochmal meine Änderungen zusammen:
> * Übertragungsgeschwindigkeit erhöhen auf max. 250µS/Bit also 4KHz
Wenn du nicht viele Daten zu übertragen hast, kann die Sendendauer ruhig 
ein paar ms dauern

> * Startbits setzten z.b. 2ms High (VCC)
ja - auf jeden Fall so, das es sich von einem Datenbit deutlich 
unterscheidet

> * Dann z.b. ein 8 Bit Datensatz übertragen
z.B.

> Könnte das dann so ungefähr klappen?
mit der zum Protokoll passenden Auswertung auf jeden Fall
Die Pulse-Distance Protokolle währen sicher ein Ansatz für dich, mit dem 
Timer lassen sich die Signal- und Pausenlängen gut messen, eine gewisse 
Filterung gegen Störungen musst du aber einbauen, so das kurze Spikes 
die Messung nicht sofort beenden.

Sascha

[elektronikbastler (Gast)]

warum greifen nur so viele zu den AM-Modulen ...
Hab mit den Dingern vor Jahren mal rumgespielt, der Haken daran ist,
dass wenn die Sendung für kurze Zeit aussetzt die Geschichte ausschwingt 
und bei Wiederaufnahme der Sendung die ersten paar ms der Übertragung 
ins Nirvana gehen. Darum sendet man bei AM erst ne Präambel und danach 
in Manchester Code wenns Daten sein sollen.
Es gibt aber auch FM-Module von Aurel, die hatten das in meinen 
versuchen nicht.

[Mattias K. (Gast)]

Danke ihr seid mir eine große Hilfe!

Ich werde das in den kommenden Tagen in Angriff nehmen.

@elektronikbastler:

Sorry, das ist mein erstes Projekt mit Funk, ich habe damit wenig 
Erfahrung.

Trotzdem danke für eure Tollen, Ausführlichen und schnellen Antworten!
Meld mich wieder.

Lg
Mattias

[Mattias K. (Gast)]

Soo,

ich habe mir das IR-Protokoll mal angesehen, ihr meintet mir dem 
"Gleichspannungsanteil" nehme ich mal an folgendes:

Start-Bit   2400µs Puls, 600µs Pause
0-Bit      600µs Puls, 600µs Pause
1-Bit      1200µs Puls, 600µs Pause

Ich habe ja jeweils für das Bit 0 und 1    10ms "Bitdauer" gehabt. Und 
das soll ich ändern!?

lg
Mattias

[Sascha W. (sascha-w)]

Mattias Köpke schrieb:
> Soo,
>
> ich habe mir das IR-Protokoll mal angesehen, ihr meintet mir dem
> "Gleichspannungsanteil" nehme ich mal an folgendes:
>
> Start-Bit   2400µs Puls, 600µs Pause
> 0-Bit      600µs Puls, 600µs Pause
> 1-Bit      1200µs Puls, 600µs Pause
genau - jedes übertragene Bit sollte aus einer Sendephase und einer 
Sendepause bestehen.

> Ich habe ja jeweils für das Bit 0 und 1    10ms "Bitdauer" gehabt. Und
> das soll ich ändern!?
Die Zeiten kannst du relativ frei wählen, nur die Pause sollte nicht zu 
lang werden sonst kommt in der Zwischenzeit wieder Rauschen am Ausgang 
raus.

Sascha

[Mattias K. (Gast)]

Okay, das werde ich versuchen.
Meint ihr das würde mit dem AtTiny13 klappen? Der hat leider nur 2 
Timer.

lg
Mattias

[Jürgen (jliegner)]

Ich denke da brauchst du nur einen Timer für. Und vermeide gleich von 
Anfang an mit dem Ausgang vom Aurel einen Interrupt auszulösen. Der hat 
am Ausgang genügend kurze Spikes die dich in den Wahnsinn treiben 
werden. Lass den Timer z.b. mit 100us oder mehr einen zyklischen 
Interrupt auslösen und sample dann. Dann sind die Spikes kein Problem 
mehr und auch das Rauschen, wenn lange kein Signal anliegt, wird nicht 
zur unkalkulierbaren Interruptquelle. Die benötigte Zeit im Interrupt 
dürfte bei geschickter Programmierung vetretbar sein.

[Sascha W. (sascha-w)]

du brauchst ja nur einen Timer, mit dem du die Zeiten misst. Man könnte 
immer bis zu einem Signalwechsel warten und dann den Timerwert lesen 
(Impus- oder Pausendauer), und diesen anschließend wider auf Null 
zurücksetzen. Und auf den nächsten Signalwechsel warten. Das Problem bei 
diesem Ansatz ist nur, das auch sehr kurze Störimpulse als Signalwechsel 
erkannt werden. Bei einem IR-Empfäger geht das noch bei Funk nur bei 
sehr gutem Empfang.

Für das Auslesen eines Funkaußensensors einer Wetterstation hab ich 
folgenden Ansatz gewählt.
Bsp: Startbit 5ms, Bitpause 1ms, 0-Bit 1ms, 1-Bit 2ms

Das Eingangssignal wird mit einem Timer im Abstand von 0.1ms eingelesen 
(1/10 der kürzesten Bit/Pausenzeit).
Mit einem Zähler lässt sich erst mal das Startbit recht zuverlässig 
erfassen.
Für jeden 1ms-Abschnitt gibts im RAM ein Byte.
Nach dem erkennen des Startbit's, wird der Wert im korrespondierenden 
Byte im RAM je nach Eingangssignal um eins erhöht oder verrigert. Nach 
10 Messungen wird ins nächste Byte geschrieben. Dadurch ergibt sich eine 
einfache Majoritätsfunktion, mit der sich Störungen rech gut filtern 
lassen.
Die Erfassung läuft immer bis zum Ende durch, auch wenn das 
Eingangssignal aufgrund der unterschiedlichen Bitdauern mal kürzer, oder 
länger sein kann.
Danach kannst du die gespeicherten Daten in Ruhe auswerten.

Sascha

[Mattias K. (Gast)]

Soll ich den Timer dann im CTC Mode laufen lassen?

lg

[Sascha W. (sascha-w)]

Mattias Köpke schrieb:
> Soll ich den Timer dann im CTC Mode laufen lassen?
Kommt darauf an an welcher Messmethode du dich versuchen willst.
Für das Sampling mit konstanter Zeit - ja
Für das einfache Messen der Bitdauer - nein

Sascha

[Mattias K. (Gast)]

Ich würde gerne das Messen der Bitdauer versuchen, kommt mir sinnvoller 
vor.

Danke.

Lg

[Sascha W. (sascha-w)]

Mattias Köpke schrieb:
> Ich würde gerne das Messen der Bitdauer versuchen, kommt mir sinnvoller
> vor.
ja bitte - Versuch mach kluch ;-)

Dann lass den Timer mit einer Geschwindigkeit laufen (Vorteiler), das 
bei den Zeiten die du messen willst der Timer (8- o. 16-Bit) möglichst 
weit ausgeschöpft wird aber kein Überlauf auftritt. Ein Überlauf währe 
dann schon mal ein Anzeichen, das das Signal nicht gültig sein kann. Die 
'krume' Messdauer die sich aus dem Vorteiler ergibt brauch dich ja nicht 
interessieren - das kann der Compiler ja bei der Erstellung des 
Programms für dich berechnen.

Sascha

[Mattias K. (Gast)]

Sascha Weber schrieb:
> Dann lass den Timer mit einer Geschwindigkeit laufen (Vorteiler), das
> bei den Zeiten die du messen willst der Timer (8- o. 16-Bit) möglichst
> weit ausgeschöpft wird aber kein Überlauf auftritt.

D.h. wenn mein
Bit 1: 300µs lang,
Bit 0: 400µs lang
meine Pause 600µs lang wäre, müsste mein Timer an der Grenze von 1000µs 
= 1ms oder an der Grenze 600µs liegen?

Lg

[Mattias K. (Gast)]

4800000    ms          µs

clk         5,333E-05  5,333E-02  5,333E+01
clk/8         0,000426667  0,426666667  426,6666667
clk/64         0,003413333  3,413333333  3413,333333
clk/256         0,013653333  13,65333333  13653,33333
clk/1024       0,054613333  54,61333333  54613,33333

Das sind die möglichen Zeiten, die ich nutzten könnte, bevor der Timer 
einen Overflow aufruft.

Lg

[Mattias K. (Gast)]

So ich habe mich nocheinmal an die Software gesetzt und habe bis jetzt 
folgendes:

#define F_CPU 4800000UL
#include <avr/io.h>
#include <avr/interrupt.h> 
#include <util/delay.h>

  // Sendefolge: 11110001 Binär: 0b10001111

volatile uint8_t code = 0;
volatile uint8_t startbit = 0;
volatile uint8_t rec[8];



ISR(TIM0_OVF_vect) {

}


int main(void) {
  DDRB &= ( ~(1 << PB1) | (1 << PB2)); // PB1 Eingang, PB2 Ausgang
  PORTB = 0xFF;
  PORTB &= ~(1<<PB2);

  TCCR0B = (1<<CS01); // Prescaler 8 Alle 426µs ein Overflow-Interrupt
  TIMSK0 |= (1<<TOIE0);

  sei();

  while(1) {
    uint8_t i = 0;

    TCNT0 = 0;
    while(PINB & (1<<PB1)) {}
    startbit = TCNT0;

    if(startbit == 240) {
    
      while(i < 7) {
        TCNT0 = 0;

        while(PINB & (1<<PB1)) {} //Warten solange Pin 1 High ist
        rec[i] = TCNT0;
        i++;
      }
    }
  }

  return 0;
}

Lg
Mattias

[Jürgen (jliegner)]

Ich denke der Ansatz ist immer noch nicht optimal. Du verpulverst im 
deiner main-Schleife alle Zeit des mc und es bleibt nichts mehr für was 
anderes übrig. Ausserdem fällt dein Code wieder auf jeden Spike herein 
den er erwischen kann.


Im Beitrag:

Beitrag "S555HT AVR Beispielcode"

habe ich mal einen Weg für die ELV Wetterdatensender beschrieben. Das 
Protokoll findest du hier:

http://www.dc3yc.privat.t-online.de/protocol.htm

Hier macht ein Timer einen zykl. Interrupt von 100us. Darin wir der Pin 
abgefragt und festgehalten wieviel mal 0 oder 1 hintereinander kommen. 
Dann wird dann bei jedem Wechsel von 0 auf 1 getestet ob die Zähler für 
0 und 1 in dem Bereich liegen den eine Tabelle vorgibt. Daran wird dann 
entschieden ob die Sequenz als 0 oder 1 oder Müll gewertet wird.

[Mattias K. (Gast)]

@Jürgen:

Was wird hier beschrieben:

#define WS300_HIGHMIN 15
#define WS300_HIGHMAX 40
#define WS300_LOWMIN   4
#define WS300_LOWMAX  15


#define EM100_LONGMIN  19
#define EM100_LONGMAX  26
#define EM100_SHORTMIN  8
#define EM100_SHORTMAX 14

Ist das Zeit? Oder ein Pegel?

Lg
Mattias

[Jürgen (jliegner)]

der Interrupt kommt nicht wie oben geschrieben mit 100us sonder mit 32us
und die #defines beschreiben mein Zeitfenster

Sollwert lt. Protokoll: 854.5µs

#define WS300_HIGHMIN 15  ->  15*32 =  480us
#define WS300_HIGHMAX 40  ->  40*32 = 1280us

Sollwert lt. Protokoll: 366.2µs

#define WS300_LOWMIN   4  ->  4*32  = 128us
#define WS300_LOWMAX  15  ->  15*32 = 480us

für den WS300

[Mattias K. (Gast)]

Okay.

Wie lange dauert denn der Interrupt?

Lg

[Jürgen (jliegner)]

ca 10% d.h. im Schnitt 3-4us.

[Mattias K. (Gast)]

Aber wieso hast du ein "großes" Zeitfenster?

[Jürgen (jliegner)]

Ich teste im Interrupt den Pin alle 32us. Ist er 1 wird c1 erhöht, ist 
er 0 wird c0 erhöht. Der Zustand am Pin wird sich gemerkt und der 
Interrupt verlassen. Wenn im nächsten Interrupt der Pin 1 ist und der 
gemerkte Zustand 0 (0-1 Flanke), dann sehe ich nach ob die Werte in c0 
und c1 zum Protokoll passen, merke mir das gefundene Bit und verlasse 
den Interrupt. Das wiederholt sich bis ich alle Bits habe. Das ist jetzt 
nur eine grobe Beschreibung, für eine komplette Doku fehlt mir die Zeit.

[Klaus D. (kolisson)]

in Verbindung mit den Aurel OOk Modulen bietet sich ein NE567 an.

Klaus

[Mattias K. (Gast)]

@ Jürgen

kann und darf ich deinen Code verwenden und umschreiben?

Lg

[Mattias K. (Gast)]

Hallo,
ich hab mich nochmals an den Code gesetzt, und bin zu folgendem TEST 
Ergebnis gekommen:

Ich sende erst mein Startbit (35us lang) dann eine 1 (120us Lang) und 
dann eine 0 (30us).

#define F_CPU 9600000UL
#include <avr/io.h>
#include <avr/interrupt.h> 
#include <util/delay.h>

  // Sendefolge: 11110001 Binär: 0b10001111
  //PB4 Data in


volatile uint8_t code = 0;
volatile uint8_t code2 = 0;
volatile uint8_t rec[8];
volatile uint8_t ready = 0;
uint8_t startrec = 0;
uint8_t high = 0;
uint8_t low = 0;

uint8_t in = 0;
uint8_t bitcount = 0;

// Sollwert für High: 116,725µs
//Sollwert für Low: 50,025µs
#define O_HIGHMAX 20 // 20*6,67µs = 133,4µs
#define O_HIGHMIN 15 // 15*6,67µs = 100,05µs
#define O_LOWMAX 10  // 10*6,67µs = 66,7µs
#define O_LOWMIN 5  // 5*6,67µs  = 33,35µs


ISR(TIM0_OVF_vect) {
  in<<=1;
  if(PINB & (1<<PB4))
    in|=1;

  if((in & 0x1F) == 0x1F) // 0x7 = 0b11111 Startbit müsste dann 5*6,67µs= 33,35µs lang sein
    startrec = 1;

  if(startrec) {
    if(bitcount <= 2) {
    if(high>O_HIGHMAX && high<O_HIGHMIN) {
      if(PINB & (1<<PB4)) 
        high++; 
    } else
    {
      code<<=1;
      code |= 0x1;
      high = 0;
      bitcount++;
    }

    if(low>O_LOWMAX && low<O_LOWMIN) {
      if((!PINB & (1<<PB4)))
        low++;
    } else
    {
      code<<=1;
      code &= 0x1;
      low = 0;
      bitcount++;
    }
    }
    else
    {
      ready = 1;
    }
  }
  else
  {
    low = 0;
    high =0;
    bitcount =0;
    code2 = code;
    code = 0;
  }
  
}


int main(void) {
  DDRB &=  ~(1 << PB4) | (1<<PB3); // PB4 Eingang PB3 Ausgang
  PORTB = 0xFF;
  PORTB &= ~(1<<PB4);

  TCCR0B = (1<<CS01 | 1<<CS00); // Prescaler 64 Alle 6,67µs ein Overflow-Interrupt
  TIMSK0 |= (1<<TOIE0);

  sei();

  while(1) {
    if(ready) {
      if(code2 == 0x2)
        PORTB^= (1<<PB3);
      ready = 0;
    }
  }

  return 0;
}

Mattias

[Mattias K. (Gast)]

Ich habe es dank Jürgens Ansatz hinbekommen. Aber ein fehler habe ich 
noch.. es funktioniert zwar, aber nur wenn ich am Sender Lange auf den 
Knopf drücke und das ist ja nicht sinn der Sache, könnte mir da noch 
jemand helfen?

#define F_CPU 4800000UL
#include <avr/io.h>
#include <avr/interrupt.h> 
#include <util/delay.h>

  // PB4 Data in
  // 8 Bit übertagung

uint8_t code = 0;
volatile uint8_t code2 = 0;
volatile uint8_t ready = 0;
uint8_t startrec = 0;
uint8_t bitcnt = 0;

uint8_t in = 0;
uint8_t il = 0;
uint8_t ih = 0;

// Sollwert für High: 700µs
// Sollwert für Low : 1000µs
// Pause      : 500µs

#define LOWMAX     20  // 20*53,33µs = 1066,6µs
#define LOWMIN     18   // 18*53,33µs = 959,94µs

#define HIGHMAX   14  // 14*53,33µs = 746,62µs
#define HIGHMIN   12  // 12*53,33µs = 639,96µs

#define PAUSEMAX   11  // 11*53,33µs = 586,63µs
#define PAUSEMIN  8  // 8*53,33µs  = 426,64µs

ISR(TIM0_OVF_vect) {

  //starten der Bitaufnahme
  if(in > 36)
    startrec = 1;

  //Bitaufnahme gestartet
  if(startrec == 1) {
    if((PINB & (1<<PB4)))
      ih++;
    else
      il++;
    
    if(bitcnt == 8) {
      if(!ready)
        code2 = code;
      ready = 1;
      ih=0;
      il=0;
      bitcnt=0;
      startrec = 0;
      in=0;
    }
    
    if(ih < HIGHMAX && ih > HIGHMIN) {
      ih = 0;
      il = 0;
      code<<=1;
      code |= 1;
      bitcnt++;
    }
    if(il < LOWMAX && il > LOWMIN) {
      ih = 0;
      il = 0;
      code<<=1;
      bitcnt++;
    }
  }
  else
  {
    if((PINB & (1<<PB4)))
      in++;
  }
}


int main(void) {
  DDRB |= (1<<PB3);
  DDRB &=  ~(1 << PB4); // PB4 Eingang PB3 Ausgang
  PORTB &= ~(1<<PB4);
  PORTB &= ~(1<<PB3);

  PORTB |= (1<<PB3);
  _delay_ms(100);
  PORTB &= ~(1<<PB3);

  TCCR0B = (1<<CS02); // Prescaler 256 Alle 53,33µs ein Overflow-Interrupt
  TIMSK0 |= (1<<TOIE0);

  sei();

  while(1) {
    if(ready) {
      if((code2 & 0x66) == 0x66)
        PORTB ^= (1<<PB3);
      ready = 0;
    }
  }

  return 0;
}

Danke !!!

Lg
Mattias

[Sascha W. (sascha-w)]

Hallo,

das Startbit sollte immer wesentlich länger sein als die Datenbits, 
sonst kann es sein das sich die Auswertung auf ein Datenbit als Startbit 
syncronisiert und dann stimmt nix mehr.

Sascha

[Mattias K. (Gast)]

Ich habe gerade nocheinmal eine andere Alternative programmiert, die 
leider nicht klappt, aber eigentlich klappen sollte..:

#define F_CPU 9600000UL
#include <avr/io.h>
#include <avr/interrupt.h> 
#include <util/delay.h>

  // PB4 Data in


uint8_t code = 0;
volatile uint8_t code2 = 0;
volatile uint8_t ready = 0;
uint8_t bitcnt = 0;

uint8_t start = 0;
uint32_t li = 0;

// Sollwert für High: 700µs    bei 106,66µs = 6 = 0x3F
// Sollwert für Low : 1000µs  bei 106,66µs = 9 = 0x1FF
// Pause      : 500µs    bei 106,66µs = 4 = 0xF
// Startbit      : 2500µs  bei 106,66µs = 23 = 0x7FFFFF


ISR(TIM0_OVF_vect) {
  li<<=1;

  if(PINB & (1<<PB4))
    li|=1;

  //Startbit und die erste Pause erkannt
  if((li & 0x3FFF0) == 0x3FFF0){
    start = 1;
    code = 0;
    bitcnt=0;
    ready=0;
  }

  if(start == 1) {
                //PORT zum test des Startbits einschalten..
    PORTB |= (1<<PB3);

    if(bitcnt == 8) {
      if(!ready)
        code2 = code;
      bitcnt=0;
      start=0;
    }

    code<<=1;

    //High erkannt
    if((li & 0x3F) == 0x3F){
      code|=1;
    }
    bitcnt++;
  }
  else
    start=0;
}


int main(void) {
  DDRB |= (1<<PB3);
  DDRB &=  ~(1 << PB4); // PB4 Eingang PB3 Ausgang
  PORTB &= ~(1<<PB4);
  PORTB &= ~(1<<PB3);

  PORTB |= (1<<PB3);
  _delay_ms(100);
  PORTB &= ~(1<<PB3);

  TCCR0B = (1<<CS02 | 1<<CS00); // Prescaler 1024 Alle 106,66µs ein Overflow-Interrupt
  TIMSK0 |= (1<<TOIE0);

  sei();

  while(1) {
    if(ready) {
      if((code2 & 0x66) == 0x66)
        PORTB ^= (1<<PB3);
      ready = 0;
    }
  }

  return 0;
}

Irgendwie erkennt er mein startbit und meine Pause gar nicht..

[Klaus D. (kolisson)]

Hi,
so ein Infrarot Protokol ist ja als Beispiel auch nicht falsch.
Natürlich kann man bei Funk tie einzelnen Zeiten deutlich verkürzen
aber es stellt doch deutlich die Verhältnisse dar.

Fürs NEc protocol hat man hier

    * a 9ms leading pulse burst (16 times the pulse burst length used 
for a logical data bit)

    * a 4.5ms space

    * the 8-bit address for the receiving device     'erstes Datenbyte

    * the 8-bit logical inverse of the address    'invers zur 
fehlerkontrolle

    * the 8-bit command            '2 tes Datenbyte

    * the 8-bit logical inverse of the command  ' und wieder invers zur 
kontrolle

    * a final 562.5µs pulse burst to signify the end of message 
transmission.


genaueres steht hier:
http://wiki.altium.com/display/ADOH/NEC+Infrared+Transmission+Protocol
und auch hier:
http://www.mcselec.com/index.php?option=com_content&task=view&id=223&Itemid=57

Gruss Klaus

[Mattias K. (Gast)]

Wie schnell darf ich denn Maximal übertragen (laut Datenblättern)?
Bzw. wie kurz darf mein Pegel maximal sein?

Im Datenblatt steht was von 3KHz beim Empfänger, hat das etwas mit der 
Übertragungsgeschwindigkeit zu tun?

@Klaus, die Protokolle kannste vergessen, ich kann keine Interrupts bei 
steigender oder fallender Flanke benutzen wegen den Spikes. (Siehe 
erster betrag).


Mattias

[Mattias K. (Gast)]

Ich hab mir gerade nochmal das Manchester Protokoll genau unter die Lupe 
genommen - das ist mit dem Aurel Modulen gar nicht möglich, da ich mit 
dem Pegel nicht ins negative gehen kann.

Lg
Mattias

[Sascha W. (sascha-w)]

Mattias Köpke schrieb:
> Ich hab mir gerade nochmal das Manchester Protokoll genau unter die Lupe
> genommen
WO?
> - das ist mit dem Aurel Modulen gar nicht möglich, da ich mit
> dem Pegel nicht ins negative gehen kann.
wieso braucht man da negative Pegel??
0=GND und 1=+Ub genügen

Sascha