Funken mit dem Attiny - preiswert und einfach

[Lordcyber]

Vielen Vielen Dank.
Wie gesagt mit der RCSwitch von Arduino klappt es ja. Ich suche so etwas nur für Bascom.
Es müsste ein pt2240 Decoder sein. So weit bin ich schon.

[Heinrichs]

Hallo,

das klingt ja schon einmal vielversprechend. Zu dem Encoder PT2240 findet man unter https://www.mikrocontroller.net/topic/139002 schon einige Informationen.

Außerdem habe ich gestern schon etwas mit meiner ELRO-Funksteckdosenfernbedienung experimentiert. Mit einem Logik-Analyzer habe ich mir die empfangenen Signale angeschaut und das benutzte Protokoll identifizieren können. Wie schon erwähnt gibt es ja nicht nur ein einziges Protokoll, sondern eine ganze Reihe davon, die sich mehr oder weniger stark unterscheiden. Auch die Arduino-Library kennt längst nicht alle Protokolle!

Zur Kontrolle habe ich auf dieser Grundlage ein BASCOM-Programm erzeugt, das eine meiner Funksteckdosen ein- und auch ausschalten kann. Jetzt muss ich nur noch ein Programm schreiben, dass solche Signale empfangen und dekodieren kann. Das sollte nun, da das Protokoll klar ist, nicht mehr so schwierig sein. Darum werde ich mich nach den Feiertagen kümmern.

Nun ist es glücklicherweise so, dass das Protokoll, das nach dem oben angegebenen Link vom PT2240 benutzt wird, fast identisch ist mit dem meiner Funksteckdose . Deswegen sollte sich das Empfangsprogramm für meine Funksteckdosenfernbedienung relativ leicht für das Empfangen der Rauchmeldersignale umschreiben lassen.

Wenn das Empfangsprogramm fertig ist, werde ich es hier veröffentlichen und gleichzeitig meine Vorgehensweise ausführlich dokumentieren, damit auch für andere Protokolle Sende- und Empfangsprogramme in entsprechender Weise geschrieben werden können.

ELRO_steuern.wmv

ELRO-Funksteckdose mit Attiny steuern

(1.07 MiB) 2768-mal heruntergeladen

[Lordcyber]

Hallo, ich habe jetzt eine Aufschlüsselung meines Protokolls gefunden das der empfängt.

/* Format for protocol definitions:
* {pulselength, Sync bit, "0" bit, "1" bit}
*
* pulselength: pulse length in microseconds, e.g. 350
* Sync bit: {1, 31} means 1 high pulse and 31 low pulses
* (perceived as a 31*pulselength long pulse, total length of sync bit is
* 32*pulselength microseconds), i.e:
* _
* | |_______________________________ (don't count the vertical bars)
* "0" bit: waveform for a data bit of value "0", {1, 3} means 1 high pulse
* and 3 low pulses, total length (1+3)*pulselength, i.e:
* _
* | |___
* "1" bit: waveform for a data bit of value "1", e.g. {3,1}:
* ___
* | |_
*
* These are combined to form Tri-State bits when sending or receiving codes.
*/

{ 350, { 1, 31 }, { 1, 3 }, { 3, 1 }, false }, // protocol 1

Glücklicherweise haben alle Geräte die ich verwenden möchte dieses Protokoll.

[Heinrichs]

Hallo,

Deine Angaben decken sich mit meinen Vermutungen. In der folgenden Abbildung sieht man das Signal (Telegramm), das meine ELRO-Fernbedienung aussendet, wenn die Taste "A On" betätigt wird. Das Telegramm besteht aus den Pulsen für 3 Datenbytes und einem Synchronisationspuls. (Im folgenden Bild ist ein solches Synchronisationssignal rechts von den Datenbytes zu sehen; dieses Synchronisationssignal leitet natürlich die nächsten 3 Datenbytes ein.)

Telegramm_A_an.jpg (38.12 KiB) 30378 mal betrachtet

0-Bit und 1-Bit sind wie von Dir angegeben so kodiert:

Bits_0_und_1.jpg (11.49 KiB) 30378 mal betrachtet

Allerdings beträgt die Pulslänge bei mir nicht 350 us, sondern nur ca. 300 us:

pulslaenge.jpg (4.98 KiB) 30378 mal betrachtet

Das Synchronisationssignal sollte so aussehen:

sync_signal_2.jpg (9.33 KiB) 30378 mal betrachtet

In Wirklichkeit dauert hier die 1-Phase etwas länger und die 0-Phase ist auch nicht 31 mal so lang wie die 1-Phase:

sync_signal_1.jpg (5.09 KiB) 30378 mal betrachtet

Diese Abweichungen sollen durchaus üblich sein. Das muss man bei der Programmierung eines Dekoders berücksichtigen.


Weiterhin muss man bedenken, dass der Empfängerbaustein seinen Verstärkungsgrad hochregelt, wenn er vom Sender keine Signale erhält. Das geht so weit, dass er den vorhandenen Elektrosmog als Daten interpretiert und am Ausgang entsprechende 1- und 0-Signale liefert. Das Dekoder-Programm muss dies allerdings nur beim Detektieren des Synchronisationssignals berücksichtigen; sobald nämlich einmal Signale vom Sender empfangen werden, wird die Verstärkung wieder herunter geregelt und das Rauschen verschwindet.


Es folgt mein Programm zum Empfangen und Dekodieren der Fernbedienungssignale meiner ELRO-Fernbedienung; es gibt die 3 Codes auf einem LCD-Display an. Zur Identifizierung der verschiedenen Pulse bestimmt der Mikrocontroller bei jedem Signalwechsel per Interrupt die Dauer der letzten 0- oder 1-Phase. Achtung: Die Einstellung des Timers und die Umrechnung von Zeit in Timer-Wert beziehen sich auf die Taktfrequenz von 4 MHz!

Code: Alles auswählen

' Programm für Attiny-Platine von E. Eube, G. Heinrichs und U. Ihlefeldt
' Über die zu zugehörige Konfigurationsdatei werden automatisch Voreinstellungen
' für die Kompilierung übernommen; diese betreffen z. B. die Taktfrequenz (hier: 4 MHz), die
' Baudrate, die Anschlüsse von LCD, I2C- und SPI-Modulen.
'
' ELRO-Funksteckdose
' Signale empfangen und dekodieren; Anzeige auf LCD
' 433MHz-Empfänger: Data an D.2 (INT0)
' getestet: An und Aus werden korrekt angezeigt (vgl. mit Logic Analyzer)
'
'----------------------------------------------------------------------------

$regfile = "attiny2313.dat"

'**********************************************************
'******************* Deklarationen ************************

Dim B1 As Byte
Dim B2 As Byte
Dim B3 As Byte
Dim Basislaenge As Word
Dim Puls1 As Word
Dim Puls2 As Word
Dim Puls4 As Word
Dim I As Byte
Dim Sync_min As Word
Dim Sync_max As Word
Dim Puls_end As Byte
Dim High_time As Word
Dim High_time_min As Word
Dim Low_time As Word
Dim Wert As Byte
Dim Wert1 As Byte
Dim Wert2 As Byte
Dim Wert3 As Byte
Dim Bitwert As Byte
Dim Sync_low_phase_vorhanden As Byte
Declare Function Empfange_byte() As Byte
Declare Function Empfange_bit() As Byte
Declare Sub Warte_auf_sync

'**********************************************************
'****************** Initialisierung ***********************

Ddrb = &B11111111                                           'Port B als Ausgangsport
Ddrd = &B01110000                                           'D4, D5, D6 als Ausgang; Rest als Eingang
Portd = &B10001111                                          'Eingänge auf high legen
Waitms 50                                                   'warte bis Kondensator bei Ta0 (D.2) geladen

Enable Int0                                                 'vgl. BASCOM-Hilfe...
Config Int0 = Change
On Int0 Pulskontrolle                                       'misst Dauer der High- bzw. Low-Phasen

Basislaenge = 300                                           'Zeit in us
Puls1 = Basislaenge / 2                                     'Pulszeit in Timer1-Einheiten (2 us)
Puls2 = 3 * Puls1
Puls4 = 2 * Puls1
High_time_min = Basislaenge / 3
Sync_min = 30 * Puls1                                       'untere Grenze für sync_low
Sync_max = 40 * Puls1                                       'obere Grenze für sync_low
Low_time = 0
High_time = 0

'**********************************************************
'******************** Hauptprogramm ***********************

Cls
Lcd "RC-Codes"
Wait 1
Cls

Enable Interrupts
Tccr1b = &B000000010                                        'Timer1Clock = Clock/8, d.h. 2us; einschalten

Do
  Call Warte_auf_sync
  Wert1 = Empfange_byte()
  Wert2 = Empfange_byte()
  Wert3 = Empfange_byte()
  Lcd Wert1
  Lcd ":"
  Lcd Wert2
  Lcd ":"
  Lcd Wert3
  Wait 3                                                    'Anzeige-Pause
  Cls
Loop

'**********************************************************
'******************* Unterprogramme ***********************

Sub Warte_auf_sync
  Do
    If Low_time > Sync_min And Low_time < Sync_max Then Sync_low_phase_vorhanden = 1 Else Sync_low_phase_vorhanden = 0
  Loop Until Sync_low_phase_vorhanden = 1 And High_time > High_time_min
End Sub

Function Empfange_byte()
  Wert = 0
  For I = 0 To 7
    Wert = 2 * Wert
    Bitwert = Empfange_bit()
    Wert = Wert + Bitwert
  Next I
  Empfange_byte = Wert
End Function

Function Empfange_bit()
  Puls_end = 0
  Do                                                        'Ende der High-Phase abwarten
  Loop Until Puls_end = 1
  If High_time > Puls4 Then Empfange_bit = 1 Else Empfange_bit = 0
End Function

'**********************************************************
'******************Interruptroutinen***********************

Pulskontrolle:
  If Pind.2 = 1 Then                                        'Steigende Flanke
    Low_time = Timer1                                       'Länge der vorangegangenen Low-Phase
    Puls_end = 0                                            'Ende der Low-Phase erreicht
  Else
    High_time = Timer1                                      'Länge der vorangegangenen High-Phase
    Puls_end = 1                                            'Ende der High-Phase erreicht
  End If
  Timer1 = 0
Return

'**********************************************************

In einem anderen Thread werde ich demnächst etwas ausführlicher schildern, wie ich vorgegangen bin, um das Übertragungsprotokoll zu finden, es zu verifizieren und das Programm zum Dekodieren zu schreiben. Diese Vorgehensweise sollte sich auch auf andere (ähnliche) Situationen anwenden lassen.


Quellcode und Video dazu: