AM oder FM Fernbedinung Rohrmotor -> bild

[Sebastian A. (xxlxx)]

Hallo

Ich bin gerade dabei meine Rollläden ( Rohrmotor ) mit einem AVR zu 
regeln.
Mit Motoren und die Fernbedinung sind von Rohrmotor24 .
ein Bild der Platine ist im Anhang.

Meine Frage: ist das eine AM oder FM Steuerung?

Ich denke AM. Denn der Quarz (JDR433A) 433,92 Mhz wird nur in der 
Amplitude geregelt. könnte aber sein ich Irre mich.

Wenn ich soweit bin stelle ich die Steuercodes mal online.

Danke & Frohes fest

[hinz (Gast)]

Sebastian Albrecht schrieb:
> Ich denke AM. Denn der Quarz (JDR433A) 433,92 Mhz wird nur in der
> Amplitude geregelt. könnte aber sein ich Irre mich.

AM stimmt, aber ein Quarz ist das nicht, sondern ein SAW-Filter.

[Sebastian (Gast)]

Danke für die Info.
Aber warum Filter ?
Kann ein Filter schwingen ?

[hinz (Gast)]

Sebastian schrieb:
> Kann ein Filter schwingen ?

Man kann es als frequenzbestimmendes Bauteil in einem Oszillator 
verwenden.

[Sebastian (Gast)]

Ok. Habe mir das Datenblatt angesehen. Da geht von dem saw Teil ein Pin 
nach Masse. Und ein Pin auf die basis vom Transistor. Keine Rückkopplung 
oder andere Bauteile. Komisch das das geht ... Aber im Datenblatt steht 
auch Filter ...

So und nun Weihnacht feiern :)

[Sebastian A. (xxlxx)]

Hallo

Ich habe mal ein Audacity bild angehangen was den Stop befehl zeigt.
Line 1 = am sender aufgenommen
Line 2 = am empfänger aufgenommen

Kennt jemand diesen code bzw kann man die kurzen abschnitte mit 0 und 
die langen mit 1 gleichsetzen ?
Oder wie muss man an diese Sache rangehen?


Danke für infos.

[Holler (Gast)]

Sebastian schrieb:
> Da geht von dem saw Teil ein Pin
> nach Masse. Und ein Pin auf die basis vom Transistor. Keine Rückkopplung
> oder andere Bauteile. Komisch das das geht ...

Das ist ein Colpitts Oszillator in Basisschaltung. C9 ist der 
Rückkopplungskondensator, der führt die HF vom Ausgang (Kollektor) zum 
Eingang (Emitter) zurück. C9 bildet mit C15 einen kapazitiven 
Spannungsteiler. Die Basis wird über den SAW-Resonator auf Masse gelegt.

Zu dem Code knn ich nichts sagen, könnte höchstens mal meine 
Velux-Rollladen-Fernsteuerung aufzeichnen. Interessant wäre sicher die 
Änderung des Codes bei Ab- bzw Aufwärtssteuerung sowie die Unterschiede 
bei verschiedenen Fenstern.

MfG Holler

[Sebastian (Gast)]

Hi

danke für die Erklärung.
Also ich kann jedem Motor bis zu 20 Codes ( fernbedienungen ) zuweisen. 
Ich muss also nur 1x Code auf oder ab kopieren und schon schicke ich 10 
Rollos hoch oder runter.  Ich würde nur gerne mehr über die Analyse 
wissen. Was ist 0 oder 1 ... ?

[Holler (Gast)]

Der Code ist für eine simple Rollosteuerung ziemlich lang.
Ohne es genau ausgezählt zu haben, scheinen die 0 und 1 gleichverteilt, 
was einen Manchester-Code vermuten läßt.
http://de.wikipedia.org/wiki/Manchester-Code

Wenn du die BefehlsCodes wissen willst, hilft das nicht weiter.
In deinem Bild fehlt der Zeitbezug: vielleicht hat man gängige 
Fernbedienungscodes der Unterhaltungselektronik übernommen, wie z.B. 
RC-5.

Einen Standard für Fensterrollos gibts wohl nicht, anbei das 
Stopp-Kommando meiner beiden Velux-Rollos: ist sehr viel einfacher 
gestrickt!

[Roland P. (pram)]

Zum Code kann ich auch nichts sagen, nur hier verweisen:
http://www.zerties.org/index.php/HowToRFM12_ASK
Hier wurden schon mehrere 433-MHZ Funksender analysiert, vielleicht ist 
da was passendes dabei.

Gruß
Roland

[Bernhard R. (barnyhh)]

Holler schrieb:
> Der Code ist für eine simple Rollosteuerung ziemlich lang.

Manche Rolladensteuerungen (z.B. SOMFY) senden ziemlich umfangreiche 
Daten. Schließlich soll auf das Betätigen der Steuerung für einen 
bestimmten Rolladen sich nicht "jeder" Rolladen in der Nachbarschaft 
angesprochen fühlen.

[Sebastian (Gast)]

Hi

Ich habe jetzt 15 Befehle aufgenommen. 5 Kanäle + hoch - runter - stop.
Jeder Datensatz ist im Format gleich. Erst kommt ein einschwingen. Dann 
kommt der Code der fernbedienung ( wird bei der Herstellung vergeben ) 
dann kommt der Kanal 1-15 und dann am Ende der befehl.

Wird ein Rollo eingelernt. Lernt das Rollo den fb Code und den Kanal. 
Dann wartet es auf Befehle.

Mit der gleichen fb auf dem gleichen Kanal ändert sich beim befehl stop 
- hoch - runter nur ganz wenig.

Aber zur frage: wie kann ich dem Signal 0 und 1 zuordnen. Was ist 0 was 
ist 1?

Sebastian

[Holler (Gast)]

Wie hast du dein Signal aufgenommen, dann sage ich dir was 0 und 1 ist.

Bein meinem Oszillogramm ist die Sache klar: habe mit einer 
Leiterschleife um die Fernbedienung die HF am Sender abgenommen mittels 
HF-Tastkopf demoduliert: 0V ist "0", d.h. keine HF, die 10V entsprechen 
dann der "1".

[Holler (Gast)]

Mess einfach in der FB an C4/R2 am Via die Spannung gegen Masse.
0V ist 0, 3V (Batteriespannung) ist 1.

[Sebastian A. (xxlxx)]

hi

mir ist klar was 0 und 1 an einem AVR pin ist. aber bei einer 
übertragung ist das anders. Bei AM gibt es nur sender AN oder Sender 
aus. Sender aus ist nicht gleich 0 ... es könnte so sein : sender kurz 
an = 0 sender lang an = 1 ... siehe post6 meine Bild da sieht man das 
signal ... ich glaube wenn man 10x eine High sendet wird ein wechsel 
geschehen ...   beim Signal könnte so anfangen 0 0 0 1 1 1 1 ??

sieht das jamand auch so ?

[Sebastian A. (xxlxx)]

Beispiel :

- line 1-5 Gleiche fernbedinung ( gleicher ID code )
- line 1-2 gleicher kanal 4 - hoch - runter
- line 3-5 gleicher kanal 5 - hoch - runter - stop


Bild aus Beitrag 6 ist eine andere Fernbedinung ( andere ID )

grüße
Sebastian

[Sebastian A. (xxlxx)]

Holler schrieb:
> was einen Manchester-Code vermuten läßt.
> http://de.wikipedia.org/wiki/Manchester-Code


habs gerade gelsen ... das könnte es sein.
Muss dann aber gesynct werden?
ich werde mal noch googlen ...
kann wir jemand mal ein beispiel in beim bild 0 und 1 einzeichnen ?

danke
Sebastian

[Max (Gast)]

Sieht viel einfacher aus.

Nach dem Start of Frame (low für länger)
Jeweils Bits mit gleicher Periodendauer,
je 1/3 high 2/3 low oder
je 2/3 high 1/3 low

Ob du nun 1 oder 0 den beiden Mustern zuordnest ist erstmal egal.
Du erkennst dann im hinteren Bereich einen Unterschied im Kommando.
Eventuell dient der Konstante Teil davor ncoh zur Adressierung?

[Max (Gast)]

Erm ja Manchester ist okay :-P Gerade den Weihnachtsbalken vorm Kopf 
wegmontier

[Holler (Gast)]

Manchester (pos. oder invertiert) ist es wohl doch nicht, habe mal die 
Telegramme untereinandergelegt und das mögliche Taktsignal hinzugefügt.

Entweder müsste sich auf jede fallende oder auf jede steigende Flanke 
eine Änderung im Telegramm ergeben: passt aber nicht.
Wie auch immer, es gibt jede Menge Codierungsmöglichkeiten. Interessant 
ist hier, dass sich nur im letzten Teil des Telegramms Befehle und IDs 
unterscheiden. Mit ein wenig reverse eng. kann man sicher IDs und 
Befehle trennen.

[Sebastian (Gast)]

Ich hab's auch schon im kopf fast gelöst.
Das letzte Ende ist immer der Befehl.
Stop UP Down habe ich jetzt gefunden.
Eigentlich ist ja egal wie der Code gebaut ist.
Ich simuliere mit dem avr einfach die ersten x Bits dann kommt der Kanal 
und dann der Befehl. Somit kann ich alle Rollos hoch und runter machen. 
Zeitsteuerung und sonnensteuerung ist damit möglich ... Ich fange am 
Wochenende mal an das Signal nachzubauen ...

Sebastian

[Sebastian A. (xxlxx)]

Hi

habe den Code von Rohrmotor24 ( Rohrmotor24.de ) geknackt.
Habe mal ein Bild angehangen.
Habe mal alles farblich makiert.
Die Befehle sind immer gleich ( Up , Down , stop , Lernen )
der Kanal ist Bitweise Kanal 0 = 0000 usw ...
Der Kanal ist bis 15 getestet.
Lernen ist noch wichtig um den Motor & Sender anzulernen.

Warum das ganze ? die Motoren kosten nur 57 Euro mit Funksteuerung 
433,92Mhz.
Damit habe ich das ganze Haus bestückt. Ich kann jetzt die Rollos per 
AVR steuern ( Beschattung, Morgens , Abend, Urlaub usw. ).

Den Sendecode habe ich mit dem AVR nachgebaut ( ATmega8) + 433,92mhz AM 
Sendemodul.

#include <avr/io.h>
#include <stdio.h>
#include <inttypes.h>
#ifndef F_CPU
#define F_CPU 8000000UL     /* Internal Quarz 8 Mhz*/
#endif
#include <util/delay.h>


int PIN_off()
{
PORTB &= ~ (1 << DDB0);
return 0;
}

int PIN_on()
{
PORTB |= (1 << DDB0);
return 0;
}

int bit_null()
  {
  PIN_on();
  _delay_us(450);
  PIN_off();
  _delay_us(650);
}

int bit_eins()
  {
  PIN_on();
  _delay_us(800);
  PIN_off();
  _delay_us(300);
}

int bit_anfang()
  {
  PIN_on();
  _delay_us(5000);
  PIN_off();
  _delay_us(1500);
}

int main()
{


  DDRB = 0b00000001; //Port B 0 = Ausgang


while(1)    
  {
  bit_anfang();
  char *p = "0001111100110000001011101111000101010101"; //FB 1 Stop 
  while( *p )
     {  
       if (*p=='0') bit_null();
       if (*p=='1') bit_eins();
     p++;
       }


  }
}

so das war es erstmal ...
wer fragen hat kann sich ja melden ...

Sebastian

[edmu (Gast)]

Hallo
ich versuche auch gerade eine Funkfernbedienung zu programmieren.
Ich habe mir von Conrad einen Sender und einen Empfänger bestellt und 
versuche gerade die Empfangsbits zu erkennen.
Ich habe an dem Empfangspin vom Empfänger auch ein Oszilloskop und kann
zumindest den Anfang des Telegramms entschlüsseln.
Ich habe von Rohrmotor24 einen 16-Kanal-Handsender gekauft und lese das 
Telegramm per Seriellen-Schnittstelle aus.
Die Bitcodierung auf deiner Zeichnung kann ich nachstellen, zB den 
eingestellten Kanal usw. Unterschiede werden natürlich da sein, weil wir 
unterschiedliche Sender haben.
Ich gebe mir die Empfangsbits per RS232 auf meinem PC aus. Ich erkenne, 
dass ich nach 123 Bytes alles empfangen habe und dann zur RS232 senden 
muss. 123 sind es deshalb, weil 1 Start-Bit (ca.5ms "1", ca.1,5ms "0") 
und dann die 40 Nutzdatenbits kommen. Dieses Telegramm kommt bei mir 3 
mal an und zwar ohne Pause zwischen den Telegrammen. Beim letzten 
Telegramm habe ich das letzte Bit immer Null. Das was ich gerade 
beschrieben habe ist für den STOP-Befehl.

Wenn ich HOCH oder RUNTER betätige bekomme ich erst die 3 Telegramme mit 
dem zugehörigen Befehl und nach einer Pause wieder 3 Telegramme, wobei 
die letzen 4 Bits negiert sind. Das letzte Bit im 3.Telegramm ist aber 
immer 0.

Ist das so richtig?

Ich versuche den STOP-Befehl mit einem ATMega32 nachzustellen, aber es 
klappt irgendwie nicht. Der Rohrmotor bleibt nicht stehen. Mit dem 
gekauften Handsender funktioniert es aber. Was mache ich denn falsch?

Timing usw. habe ich kontrolliert und sollte stimmen.

Ich kann aber die letzten Bits mit dem Oszilloskop nicht lesen, weil 
diese nicht mehr auf dem Bildschirm passen. Das Telegramm ist zu lang.
Die vorderen Bits kann ich lesen und passt mit den Empfangsdaten 
überein.


Für Antworten bzw. Hilfestellungen würde ich mich sehr freuen.

edmu

[sebastian xxlxx (Gast)]

hi
du machst alles richtig!
ja mein signal kommt auch 3 mal. Das machen die nur um die übertragung 
zu garantieren. das am Ende negiert wird habe ich getestet und es macht 
keinen unterschied. Hast du dir mal meine grafik angesehen? du sieht ja 
auch im code wie ich das mit dem timing mache. ich glaube das ist alles 
recht einfach. dein Weg ist richtig ...

[edmu (Gast)]

danke für deine Antwort.

ich habe gesehen, dass das Startsignal unter 5ms liegt. Ich stelle
es auf 4,8ms und teste einmal. Alles andere sollte ann funktionieren.

mfg edmu

[Sebastian xxlxx (Gast)]

Ich bin da viel einfacher vorgegangen.
Ich habe das Signal mit der soundcard aufgenommen.
Und dann mit dem atmega nachgeformt. Ohne auf Zeiten zu achten.
Das ging relativ schnell. Ich sende auch nur 1x den Code. Das ging 
sofort.
Ach ja Vergleich am Empfänger mal beide Signale. Das von der fb und von 
Mega
Grüße sebastian .

[edmu (Gast)]

Hallo

habe es soweit am laufen.

Das Problem war das Timing. Habe das Timing der Fernbedienung auf dem
Atmega nachgestellt. Jetzt funktioniert es auch einwandfrei.

Danke für die Hinweise.

mfg edmu

[Sebastian (Gast)]

Perfekt!

Habe mir jetzt ein raspberry Pi bestellt um die hausautomatisierung zu 
machen. Dieser steuert dann auch die Rollos lokal und per Web.

Raspberry Pi Mini Linux Rechner 27€

[Thomas S. (tom_wob26)]

Hallo zusammen,
Ich habe auch einige Funk Rolladenmotor vom oben genannten Hersteller 
installiert. Eure Beiträge sind sehr interessant ;-)
Ich versuche das ganze auf einem Arduino Uno mit Networkshield 
nachzubauen.
Optional mit Helligkeitssensor (fahren der Rolläden nach 
Lichtintensität) und Weboberfläche.

Wenn ich die RC library lade und die Advanced auf den chip schreibe kann 
ich jedoch von der Fernbedienung keine Codes einlesen (Serial Monitor).
Wenn ich allerdings eine 0815 Funksteckdosenfernbedienung nehme kann ich 
sehr schön die bits aus dem Serial Monitor ablesen.

Hintergrund:
Ich möchte die ausgelesenen Codes in das Projekt eintragen.

Ich freue mich über Eure Anregungen.
Vielleicht habt Ihr schon ein fertiges Projekt, dann muss ich das Rad 
nicht zweimal erfinden ;-)

Grüße sendet Thomas

[Sebastian xxlxx (Gast)]

Hi

Mach es dir doch nicht so schwer. Die Codes sind oben in der liste ja 
schon entschlüsselt. Alle Funktionen sind damit offen. Hänge doch an 
deinen Pin deinen Sender ( AM ) von einer 0815 bedienung. Dann forme das 
Signal ( Timing ) einfach nach. Dann biste in 1h fertig ... Ich habe 
dann von ein Webserver oben drauf gesetzt und schon war die Steuerung 
fertig.

Mein Aufbau :

Sender --> avr ( Timing atmega 88 ) --> Uart ( raspberry ) --> Apache 
Webserver

Guter Aufbau  einfach simpel  und sehr billig !



Sebastian xxlxx

[Thomas S. (tom_wob26)]

Hi Sebastian, Danke für deine rasche Antwort.
Kannst du die Codes als Excel Tabelle anhängen?

Ich weiß nur noch nicht mit was ich das Signal "nachformen" kann.
Der Arduino hat 16MHz...
Den Steuerbefehl teste ich mal über die Kommandozeile.
Eventuell umgerechnet als Dezimal...
Sender und Empfänger sind angeschlossen und funktionieren.
Ich bin gespannt ;-)

[Sebastian xxlxx (Gast)]

Hi.

Die Excel habe ich nicht mehr. Aber oben als Bild im Beitrag vorhanden. 
Dort ist auch gut erklärt wo die Unterschiede sind ...

Das mit dem nachformen geht auch einfach.
Der Code ist im Beitrag. Dort habe ich einen Steuerbefehl von 0 und 1 
nachgeformt.

Wenn ich morgen am Rechner bin guck ich nochmal genauer ...

[Sebastian xxlxx (Gast)]

Nachtrag : oben im Code stehen die Abschnitte Bit Null und Bit eins. In 
diesen Bereichen stehen die Microsekunden zwischen an und aus vom 
Sender. Auch bei 16 mhz stimmen diese Werte ...

[Thomas S. (tom_wob26)]

Ich habe die ersten Codes abgetippert...

FB  Kanal  Befehl  Bitfolge

2  1  hoch  0001100100100000011111001101000100011110
2  1  stop  0001100100100000011111001101000101010101
2  1  runter  0001100100100000011111001101000100110011


Das teste ich heute Abend:

#include <RCSwitch.h>
RCSwitch mySwitch = RCSwitch();
void setup()
{
mySwitch.enableTransmit(10);  // Using Pin #10
}  void loop()
{
mySwitch.send("0001100100100000011111001101000100011110"); //Rolladen 
hoch
delay(1000);
}

und in der "RCSwitch.cpp" die timmings irgendwie anpassen....

In deinem Code baust du aber kein RCswitch ein.
Und du hast natürlich eine andere Hardware Programmierumgebung und 
Pinbelegung.

[sebastian xxlxx (Gast)]

NEIN!

das gehts du falsch an.

der ablauf ist in etwas so ( siehe code ) :

#include <avr/io.h>
#include <stdio.h>
#include <inttypes.h>
#ifndef F_CPU
#define F_CPU 8000000UL     /* Internal Quarz 8 Mhz*/
#endif
#include <util/delay.h>


int PIN_off()
{
PORTB &= ~ (1 << DDB0);
return 0;
}

int PIN_on()
{
PORTB |= (1 << DDB0);
return 0;
}

int bit_null()
  {
  PIN_on();
  _delay_us(450);
  PIN_off();
  _delay_us(650);
}

int bit_eins()
  {
  PIN_on();
  _delay_us(800);
  PIN_off();
  _delay_us(300);
}

int bit_anfang()
  {
  PIN_on();
  _delay_us(5000);
  PIN_off();
  _delay_us(1500);
}

int main()
{


  DDRB = 0b00000001; //Port B 0 = Ausgang


while(1)    
  {
  bit_anfang();
  char *p = "0001111100110000001011101111000101010101"; //FB 1 Stop 
  while( *p )
     {  
       if (*p=='0') bit_null();
       if (*p=='1') bit_eins();
     p++;
       }


  }
}

jetzt die Erklärung :

while(1)    // hier gehts los !
  {
  bit_anfang(); 
  // sende bit anfang 
  // lege PIN_on() auf 5 V
  // pause delay_us(5000) 
  // lege pin PIN_off() auf 0V
  // wieder pause delay_us(1500);
  // Ende bit Anfang  

  char *p = "0001111100110000001011101111000101010101"; //FB 1 Stop 
  // das hier ist der befehl zum Testen  

  while( *p )
     {  
       if (*p=='0') bit_null();
       if (*p=='1') bit_eins();
     p++;
  // Zerlege den befehl in 0 und 1
  // ist es 0 dann lege pin auf 5 V warte 450us dann auf 0V und warte 650us
  // ist es 1 dann lege pin auf 5 V warte 800us dann auf 0V und warte 300us

  // der gesamte ablauf besteht dann aus 
  // --> Bitanfang --> 1 oder 0 (40 mal) --> pause --> von vorne

Verstanden ?

das ist auch nix wo man LIB´s benötigt oder so.
einfach nur den befehl Pin 1 5V oder Pin 1 0V alles andere ist Timing.
das ganz ist dann in C / GCC getippt und nicht auf der befehlszeile(?).

grüße
Sebastian

[Thomas S. (tom_wob26)]

Danke für deine ausführliche Erklärung.
Ich habe das Programm auf meinen atmega 644p geflasht.
Den Sender am Port B 1 angeschlossen.
Die zwei Motoren sind auf die Orginal Fernbedienung angelernt Kanal 1 
und 2.
Wenn ich den binären Code Kanal 1 "runter" aus deiner liste Programmiere 
passiert jedoch nichts.
Muss ich diese vorher anlernen?

Grüße sendet Thomas

[Sebastian xxlxx (Gast)]

Hi

Das kann so aber nicht gehen. Der Code besteht ja aus mehreren teilen. 
Unter anderem aus der ID. Die ID von deinem Sender ist eine andere als 
bei mir. Logisch sonnst könnte ich alle Rollos schalten. Deine Motoren 
sind auf deine Id eingelernt und reagieren nicht auf meine.

Ich denke du solltest den Code von mir zum einlernen nutzen

[Thomas S. (tom_wob26)]

Das heißt in der Motorsteuerung den Code löschen.
den Binären Wert für lernen laut deiner Liste Programmieren.
Motorsteuerung auf anlernen schalten.
Das teste ich nachher...
Eventuell macht es Sinn, das ich mir  ein Soundkarten Ozzi baue...
Ich habe noch nen uralten Laptop den ich opfern kann ;-)

[Sebastian xxlxx (Gast)]

Ich habe das auch mit der soundkarte gemacht. Dazu brnötigt man aber 
keinen alten Rechner. Einfach den normalen Rechner nehmen - kabel in 
Mikroeingang - 1 zu 100 spannungsteiler davor und los geht's ... 
Software ist auch kostenfrei.

Die Signale sind so langsam das geht eh nur mit Speicher oszi.

Wenn ich mal wieder am Rechner sitze erkläre ich mal den Aufbau der Bit 
Zeile von oben. Hier von iphone ist das unständlich ...


Sebastian

[Thomas S. (tom_wob26)]

...
Gestern habe ich mir ein Kabel gebaut, auf 3,5 Klinke.
Das Kabel ist für 5 Volt ausgelegt und die Widerstände drosseln von 5 
auf 1,7 V.
In der Fernbedienung befindet sich eine 3 Volt Knopfzelle, wird der 
Sender nur mit 3 Volt betrieben?
Im Erstem Bild deines Beitrages hast du ein Foto von der Fernbedienung 
gemacht. Hast du bei CN1 mit dem Tastkopf das Signal abgegriffen?

Am besten ich installiere erst ein "LED blinki Demo" und schaue mir das 
Ergebnis auf dem Laptop mit dem Soundkarten Ozzi an...

[sebastian xxlxx (Gast)]

Hi

noch ein paar Tipps :

Software : Audacity ( http://audacity.sourceforge.net )
LED blink = tolle Idee !!!

zum analysieren der Signale habe ich einen 433 Mhz Empfänger (Steckdose) 
genommen. damit könnte ich alle Signale im Umkreis 50meter mitschneiden 
und ansehen. Damit ist auch das nachformen der Signale einfacher weil 
hier das Funksignal betrachtet wird. damit kann man dann die Original 
Fernbedienung mit dem Nachbau gut vergleichen und die Signale haben 
immer die gleiche Form ( Spannung usw. ).

zum Code :

Fernbedinung : 1 (meine 1 - ID )
Kanal : 1
Funktion : stop

0001111100110000001011101111 - 0001 - 0 - 1010101
ID der Fernbedienung - Kanal - Lernen - Befehl (Stop)

bei ID kannst du deine ID einsetzen wenn du sie von deiner FB kennst. 
Oder nimmst meine. bei Kanal kannst du binär bis 256 gehen. Lernen = 0 
OFF = 1 ON. und Befehl siehe Liste oben bei mir.


sebastian
xxlxx

[Thomas S. (tom_wob26)]

Welche Entwicklungsumgebung nutzt du eigentlich?
AVR Studio4?
Bist du mit deinem "raspberry" zufrieden?

[sebastian xxlxx (Gast)]

Hallo

AVR Studio 4
+ noname Programmer für 20€


Raspberry --> ich glaube das sagt alles. TOP TEIL !

- FTP
- HTTP
- Haussteuerung
- Mysql
- Batchskript Projekte
- Top Stromverbrauch 3-4 Watt

---------- Temperatur --------------------------------
temp=42.2'C
---------- Diskfree ----------------------------------
Filesystem           1K-blocks      Used Available Use% Mounted on
rootfs                 7566888   2828320   4358276  40% /
---------- Uptime ----------------------------------------
07:32:13 up 79 days, 22:02,  0 users,  load average: 0.05, 0.06, 0.10


sebastian

[tom_wob26 (Gast)]

Hallo Sebastian,

Ich habe mit nun ein Soundkarten Ozzi gebaut, das Ergebnis siehst du im 
Anhang. Wie mache ich daraus nun einen Binären Code?
grübel

[Sebastian xxlxx (Gast)]

Mal so schnell aus der hüfte von unterwegs

Lange und kurze Impulse gleich 1 und 0
Die letzten Zeichen sind 4 gleiche.
Vergleiche mal mit meiner liste ob da was passt ... Fange von hinten an. 
Vorne ist die ID die kann man nicht vergleichen ...

[sebastian xxlxx (Gast)]

hi

schicke mir mal Befehl hoch runter Stop als Bild ... ich guck am 
Wochenende mal drüber. es sollten sich nur die hintersten Bit´s ändern. 
ich habe schon mal gezählt es sind 40 Bits wie bei mir.

du bist auf dem richtigen weg.

Sebastian
xxlxx

[tom_wob26 (Gast)]

Und hier für Rolladen hoch.
Rolladen stopp muss ich morgen nochmal neu aufzeichnen.

Grüße sendet Thomas

[tom_wob26 (Gast)]

doch noch einen sauberen schnitt gefunden ;-)
Rolladen stopp

[Sebastian xxlxx (Gast)]

Ich habs schon
und das vom handy !
Excelliste weiter oben  5 Zeile am Ende  0  0 0 1 0 0 0 1.
Jetzt sieh mal dein Signal an. Schau dir nicht oben die Welle an sondern 
unten.
Von hinten nach vorn : dick , dünn , dünn , dünn , dick , dünn , dünn , 
dünn
Würde heißen : 1 0 0 0 1 0 0 0
Jetzt umdrehen : 00010001

Komisch sieht wie mein Signal Zeile 5 aus !!!

Gut gemacht !

Noch fragen ?

Sebastian
Xxlxx

[Sebastian xxlxx (Gast)]

Bei stop genauso.
Ist auch gleich mit meinem Code 01010101

:)

Sebastian
Xxlxx

[Thomas S. (tom_wob26)]

Hi Sebastian,

Das ist ja einfacher als gedacht ;-)
Kann es kaum erwarten den Sender damit zu füttern.

runter:
0010001101000000010100000001000000011110
hoch:
0010001101000000010100000001000001010101
stop:
0010001101000000010100000001000000010001

und dann muss ich mich mit der Programmierung beschäftigen...

[sebastian xxlxx (Gast)]

Hi

habe dein Code mal mit der Excel verglichen.
kann es sein das du nur eine normale Bedienung hast ohne Display ?
deine 3 Code Zeilen sagen immer Kanal 0 ?


Sebastian
xxlxx

[Thomas S. (tom_wob26)]

Der Test hat gestern noch nicht geklappt, hmmm
Mir ist aber aufgefallen das die Original Funkvernbedienung nicht mehr 
richtig arbeitet wenn ich den Code über den AVR sende.

Ich habe eine 5 Kanal Fernbedienung mit Display.
Die Frequenzen habe ich von Kanal 0 ausgelesen, womit dann alle Rolläden 
angesteuert werden, Gruppenkommando....

[Sebastian xxlxx (Gast)]

Ich hoffe du denkst an die richtigen Spannungen. Die Fernbedienung hat 
nur 3 V. Der avr meist 5V ! Achtung anpassen.

Prüfe das Signal mit einem Empfänger ? Dann sieht man gleich das 
Problem.

[Thomas S. (tom_wob26)]

Stimmt, ich sende definitiv mit 5V.
Das wird dann meine Wochenendaufgabe, 5V auf 3V begrenzen.
...und das prüfen mit Empfänger
Was machst du eigentlich beruflich?

[Thomas K. (Gast)]

Hallo Jungs,

vor einiger Zeit habe ich mich im Zuge Hausautomatisierung auch mit dem 
Protokoll von Rohrmotor24.de beschäftigt.
Ich habe dabei hier bei mir haargenau die Fernbedienung im Einsatz, von 
welcher die Platine auf den Fotos im Eröffnungsposting abgebildet ist.

Die 6 freien Anschlüsse auf der rechten Seite sind ein Standard ICSP 
Header.

Ich hab mal ein Pickit dran gehangen und versucht die Firmware 
auszulesen...
...und siehe da - die CopyProtection Bits sind NICHT gesetzt.

Die Firmware lässt sich also ohne Probleme auslesen.


Im Prinzip ist das Protokoll ja schon geknackt. Ich häng trotzdem mal 
ein disassembled Listing der original Firmware an da einiges doch nicht 
ganz so ist wie vermutet...

Viel Spass
T.

[Sebastian xxlxx (Gast)]

Hi Thomas

Danke für die Info. Da das System bei mit läuft, hatte ich gerne mal 
gewusst was du vermutest? Was könnte noch nicht richtig sein ?

Danke für Infos ...
Sebastian

[Thomas K. (Gast)]

Hallo Sebastian,

die Unterschiede liegen wirklich nur im Detail... wenn das ganze bei dir 
also läuft würde ich da auch nix ändern. Ich hab das ganze hier nur 
gepostet, weil ich dachte das es den ein oder anderen interessieren 
könnte.

Als erstes sind die Timings in der Firmware etwas anders als du gemessen 
hast. Der Empfänger ist aber sicherlich so tolerant programmiert das das 
überhaupt kein Problem ist.

Ein wirklicher Unterschied zu deiner Implementierung findet sich 
eigentlich nur dahingehend, wie oft die entsprechende Bitsequenz 
gesendet wird. Ich versuch es mal zusammenzufassen:

Bei den Befehlen LERNEN und STOP wird die entsprechende Bitsequenz ohne 
wenn und aber genau 4x gesendet... völlig egal wie lange du den 
entsprechenden Knopf auf der Fernbedienung gedrückt hälst.

Bei den Befehlen HOCH und RUNTER sieht das etwas anders aus. Hier wird 
die entsprechende Bitsequenz solange gesendet, wie du den entsprechenden 
Knopf gedrückt hälst. Dabei läuft intern ein counter mit, welcher zählt 
wie oft gesendet wurde. Wird dann der Knopf an der Fernbedienung 
losgelassen, so wird geprüft ob die Bitsequenz mindestens 20x gesendet 
wurde. Wenn ja dann ist das Senden damit beendet. Wenn nicht dann wird 
noch 4x eine andere Bitsequenz hinterher geschickt und erst dann ist das 
Senden beendet. (das ist dann das was du als 'invertierte' Bits gesehen 
hast)

Was das ganze nun genau soll kann ich dir auch nicht sagen, dazu 
bräuchte man dann noch die Firmware vom Empfänger.

Ich habe bei mir festgestellt, das es im Prinzip fast immer schon 
reicht, wenn man das entsprechende Kommando 1 oder 2 mal sendet ( du ja 
sicher auch). Die Motoren sprechen da sauber drauf an und alles 
funktioniert wunderbar.
ABER:
Ich hatte dann Probleme wenn ich meine eigene Steuerung verwendet habe 
UND gleichzeitig die original Fernbedienung. Da gabs dann immer wieder 
mal Aussetzer.

Ich habe meine automatisierte Steuerung jetzt dahingehend angepasst, das 
die Kommandos STOP und LERNEN immer genau 4x gesendet werden und die 
Kommandos HOCH und RUNTER immer genau 20x - seitdem funktioniert auch 
meine Steuerung und die original Fernbedienung gleichzeitig.

Ich häng mal noch den Pseudocode von der original Firmware an - da 
picasm ja nun nicht jedermanns Sache ist.

Viele Grüße
Thomas

SendeBits()
{
  PIN_SENDER = 1;               // sende sync
  Delay( 4100 );
  PIN_SENDER = 0;
  Delay( 1000 );

  for( a=0; a<40; a++ )         // 40 bits senden
  {
    if( bit_zu_senden == 0 )    // sende bit0
    {
      PIN_SENDER = 1;
      Delay( 360 );
      PIN_SENDER = 0;
      Delay( 720 );
    }

    if( bit_zu_senden == 0 )    // sende bit1
    {
      PIN_SENDER = 1;
      Delay( 720 );
      PIN_SENDER = 0;
      Delay( 360 );
    }
  }

  return;
}



SendeKommando_LERNEN()
{
  for( a=0; a<4; a++ )        // Kommando 4x senden
  {
    Delay( 360 );
    SendeBits( xxxxxxxx xxxxxxxx xxxxxxxx ggggcccc 11001100 );
  }
  Delay( 360 );

  // prüfen ob button immernoch gedrückt wird
  Warte_bis_button_LERNEN_offen();

  return
}


SendeKommando_STOP()
{
  for( a=0; a<4; a++ )        // Kommando 4x senden
  {
    Delay( 360 )
    SendeBits( xxxxxxxx xxxxxxxx xxxxxxxx ggggcccc 01010101 )
  }
  Delay( 360 )

  // prüfen ob button immernoch gedrückt wird
  Warte_bis_button_STOP_offen()

  return
}


SendKommando_HOCH()
{
  var_counter = 0;

  while (1)
  {
    for( b=0; b<2, b++ )        // Kommando 2x senden
    {
      Delay( 360 );
      SendeBits( xxxxxxxx xxxxxxxx xxxxxxxx ggggcccc 00010001 );
    }
    Delay( 360 )

    var_counter++;

    // prüfen ob button immernoch gedrückt wird
    if( Button_HOCH_ist_gedrückt() == FALSE )
    {
      break;
    }
  }

  if( var_counter < 10 )
  {
    for( a=0; a<4, a++ )        // Kommando 4x senden
    {
      Delay( 360 );
      SendeBits( xxxxxxxx xxxxxxxx xxxxxxxx ggggcccc 00011110 )
    }
    Delay( 360 )
  }

  return;
}


SendKommando_RUNTER()
{
  var_counter = 0;

  while (1)
  {
    for( b=0; b<2, b++ )        // Kommando 2x senden
    {
      Delay( 360 );
      SendeBits( xxxxxxxx xxxxxxxx xxxxxxxx ggggcccc 00110011 );
    }
    Delay( 360 )

    var_counter++;

    // prüfen ob button immernoch gedrückt wird
    if( Button_RUNTER_ist_gedrückt() == FALSE )
    {
      break;
    }
  }

  if( var_counter < 10 )
  {
    for( a=0; a<4, a++ )        // Kommando 4x senden
    {
      Delay( 360 );
      SendeBits( xxxxxxxx xxxxxxxx xxxxxxxx ggggcccc 00111100 )
    }
    Delay( 360 )
  }

  return;
}

[Sebastian xxlxx (Gast)]

Hi Thomas

Toll ! Top Information. Ja das mit dem Aussetzern habe ich auch bemerkt. 
Ich löse das über den Webserver. Ich sende jeden Befehl 5 mal 
hintereinander und dann noch 3 mal das ganze mit 1 Sekunde Pause. Warum 
? Wenn ich nicht da bin und der Befehl hoch gesendet wird. Aber dann ein 
funkschlüssel oder Thermometer reinpfuscht. Bleiben die Rollos unten. 
Deshalb wiederhole ich das Signal 5 mal + Pause 5 mal + Pause 5 mal ...

Dein Code ist klasse ! Danke !

Zu meinen Timing. Ich habe die 433 MHz mit einem Scanner abgehört und 
nachgeformt.

[Clinxer (Gast)]

Hola.

Si se lee el programa del micro con ICSP, esta protegido pero se ven 
algunas posiciones de menoria donde esta el codigo ID original.

0x380 ----> cuarto byte ID. Los 4 bits de menos peso indican el (canal 
-1) porque al gestinar el canal el firmware suma siempre 1.
0x381 ----> tercer byte ID
0x382 ----> segundo byte ID
0x383 ----> primer byte ID

Este es el firmware original del mando, para que funcione teneis que 
poner en las posiciones de memoria anteriores el ID de vuestro mando y 
el canal (bytes 0x80-0x83).

Recordar que en 0x3ff tenemos OSCCAL.

Un saludo.


; original File = F:\mando.hex

    processor 16F630
    #include <P16F630.INC>
    __config 0x3194
;   _CPD_OFF & _CP_OFF & _BODEN_OFF & _MCLRE_OFF & _PWRTE_OFF & _WDT_OFF
;   & _INTRC_OSC_NOCLKOUT
;   __idlocs 0xFF, 0xFF, 0xFF, 0xFF

;   EEPROM-Data
    Org 0x2100
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    DE 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF

; RAM-Variable
LRAM_0x20 equ 0x20
LRAM_0x21 equ 0x21
LRAM_0x22 equ 0x22
LRAM_0x24 equ 0x24
LRAM_0x25 equ 0x25
LRAM_0x27 equ 0x27
LRAM_0x28 equ 0x28
LRAM_0x2A equ 0x2A
LRAM_0x2B equ 0x2B
LRAM_0x30 equ 0x30
LRAM_0x31 equ 0x31
LRAM_0x32 equ 0x32
LRAM_0x33 equ 0x33
LRAM_0x34 equ 0x34
LRAM_0x35 equ 0x35
LRAM_0x36 equ 0x36

; Program

    Org 0x0000

;   Reset-Vector
    NOP
    GOTO LADR_0x005C
    ADDLW 0xFF
    ADDLW 0xFF
;   Interrupt-Vector
    RETFIE
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
LADR_0x000A
    MOVLW 0x07
    MOVWF LRAM_0x20
LADR_0x000C
    MOVLW 0xE1
    MOVWF LRAM_0x21
LADR_0x000E
    MOVLW 0xEC
    MOVWF LRAM_0x22
LADR_0x0010
    DECFSZ LRAM_0x22,F
    GOTO LADR_0x0010
    DECFSZ LRAM_0x21,F
    GOTO LADR_0x000E
    DECFSZ LRAM_0x20,F
    GOTO LADR_0x000C
    RETURN
LADR_0x0017
    MOVLW 0x1B
    MOVWF LRAM_0x21
LADR_0x0019
    MOVLW 0xF6
    MOVWF LRAM_0x22
LADR_0x001B
    DECFSZ LRAM_0x22,F
    GOTO LADR_0x001B
    DECFSZ LRAM_0x21,F
    GOTO LADR_0x0019
    RETURN
LADR_0x0020
    MOVLW 0x07
    MOVWF LRAM_0x21
LADR_0x0022
    MOVLW 0xE3
    MOVWF LRAM_0x22
LADR_0x0024
    DECFSZ LRAM_0x22,F
    GOTO LADR_0x0024
    DECFSZ LRAM_0x21,F
    GOTO LADR_0x0022
    RETURN
LADR_0x0029
    MOVLW 0x03
    MOVWF LRAM_0x21
LADR_0x002B
    MOVLW 0xA5
    MOVWF LRAM_0x22
LADR_0x002D
    DECFSZ LRAM_0x22,F
    GOTO LADR_0x002D
    DECFSZ LRAM_0x21,F
    GOTO LADR_0x002B
    RETURN
LADR_0x0032
    MOVLW 0xB2
    MOVWF LRAM_0x22
LADR_0x0034
    NOP
    DECFSZ LRAM_0x22,F
    GOTO LADR_0x0034
    RETURN
LADR_0x0038
    MOVLW 0xB1
    MOVWF LRAM_0x22
LADR_0x003A
    NOP
    DECFSZ LRAM_0x22,F
    GOTO LADR_0x003A
    RETURN
LADR_0x003E
    MOVLW 0x75
    MOVWF LRAM_0x22
LADR_0x0040
    DECFSZ LRAM_0x22,F
    GOTO LADR_0x0040
    RETURN
LADR_0x0043
    MOVLW 0x74
    MOVWF LRAM_0x22
LADR_0x0045
    DECFSZ LRAM_0x22,F
    GOTO LADR_0x0045
    RETURN
LADR_0x0048
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    MOVF PORTA,W         ; !!Bank!! PORTA - TRISA
    ANDLW 0x3F
    MOVWF LRAM_0x25
    MOVLW 0x3F
    SUBWF LRAM_0x25,W
    BTFSC STATUS,Z
    GOTO LADR_0x0059
    CALL LADR_0x0017
    MOVF PORTA,W         ; !!Bank!! PORTA - TRISA
    ANDLW 0x3F
    SUBWF LRAM_0x25,W
    BTFSS STATUS,Z
    GOTO LADR_0x0059
    MOVF LRAM_0x25,W
    MOVWF LRAM_0x24
    RETURN
LADR_0x0059
    MOVLW 0xFF
    MOVWF LRAM_0x24
    RETURN
LADR_0x005C
    BSF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    CALL LADR_0x03FF
    MOVWF T1CON          ; !!Bank!! T1CON - OSCCAL
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    MOVLW 0x07
    MOVWF CMCON          ; !!Bank!! CMCON - VRCON
    MOVLW 0xFF
    MOVWF PORTA          ; !!Bank!! PORTA - TRISA
    MOVLW 0x60
    MOVWF PORTC          ; $ PORTC - TRISC
    MOVLW 0x3F
    BSF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    MOVWF PORTA          ; !!Bank!! PORTA - TRISA
    MOVLW 0x00
    MOVWF PORTC          ; $ PORTC - TRISC
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    CALL LADR_0x000A
    CALL LADR_0x0020
    CALL LADR_0x0029
    CALL LADR_0x0032
    CALL LADR_0x0038
    CALL LADR_0x003E
    CALL LADR_0x0043
LADR_0x0073
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    MOVLW 0x1F
    MOVWF PORTC          ; $ PORTC - TRISC
    BSF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    MOVLW 0x3F
    MOVWF IOCA           ; !!Bank!! Unimplemented - IOCA
    MOVLW 0x08
    MOVWF INTCON
    SLEEP
    NOP
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    CALL LADR_0x0048
    MOVLW 0xFF
    SUBWF LRAM_0x24,W
    BTFSC STATUS,Z
    GOTO LADR_0x0073
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    MOVLW 0x3E
    SUBWF LRAM_0x25,W
    BTFSC STATUS,Z
    GOTO LADR_0x009E
    MOVLW 0x1F
    SUBWF LRAM_0x25,W
    BTFSC STATUS,Z
    GOTO LADR_0x00AA
    MOVLW 0x2F
    SUBWF LRAM_0x25,W
    BTFSC STATUS,Z
    GOTO LADR_0x00C8
    MOVLW 0x37
    SUBWF LRAM_0x25,W
    BTFSC STATUS,Z
    GOTO LADR_0x00D6
    MOVLW 0x3D
    SUBWF LRAM_0x25,W
    BTFSC STATUS,Z
    GOTO LADR_0x00F4
    MOVLW 0x3B
    SUBWF LRAM_0x25,W
    BTFSC STATUS,Z
    GOTO LADR_0x00F7
    GOTO LADR_0x00FA
    GOTO LADR_0x0073
LADR_0x009E
    NOP
    MOVLW 0xCC
    MOVWF LRAM_0x27
    BCF PORTC,0          ; $ PORTC - TRISC
    CALL LADR_0x00FD
    CALL LADR_0x00FD
LADR_0x00A4
    BTFSS PORTA,0        ; !!Bank!! PORTA - TRISA
    GOTO LADR_0x00A4
    CALL LADR_0x0017
    BTFSS PORTA,0        ; !!Bank!! PORTA - TRISA
    GOTO LADR_0x00A4
    GOTO LADR_0x0073
LADR_0x00AA
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    MOVLW 0xFF
    MOVWF LRAM_0x2A
    MOVLW 0x05
    MOVWF LRAM_0x2B
LADR_0x00AF
    DECFSZ LRAM_0x2B,F
    GOTO LADR_0x00B5
    MOVLW 0xFF
    MOVWF LRAM_0x2B
    MOVLW 0x55
    MOVWF LRAM_0x2A
LADR_0x00B5
    MOVLW 0x11
    MOVWF LRAM_0x27
    BCF PORTC,0          ; $ PORTC - TRISC
    CALL LADR_0x00FD
    CALL LADR_0x00FD
    BTFSS PORTA,5        ; !!Bank!! PORTA - TRISA
    GOTO LADR_0x00AF
    CALL LADR_0x0017
    BTFSS PORTA,5        ; !!Bank!! PORTA - TRISA
    GOTO LADR_0x00AF
    MOVLW 0x55
    SUBWF LRAM_0x2A,W
    BTFSC STATUS,Z
    GOTO LADR_0x0073
    MOVLW 0x1E
    MOVWF LRAM_0x27
    CALL LADR_0x00FD
    CALL LADR_0x00FD
    GOTO LADR_0x0073
LADR_0x00C8
    MOVLW 0x55
    MOVWF LRAM_0x27
    BCF PORTC,0          ; $ PORTC - TRISC
    CALL LADR_0x00FD
    CALL LADR_0x00FD
    CALL LADR_0x0017
    CALL LADR_0x0017
    CALL LADR_0x0017
    BTFSS PORTA,4        ; !!Bank!! PORTA - TRISA
    GOTO LADR_0x00C8
    CALL LADR_0x0017
    BTFSS PORTA,4        ; !!Bank!! PORTA - TRISA
    GOTO LADR_0x00C8
    GOTO LADR_0x0073
LADR_0x00D6
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    MOVLW 0xFF
    MOVWF LRAM_0x2A
    MOVLW 0x05
    MOVWF LRAM_0x2B
LADR_0x00DB
    DECFSZ LRAM_0x2B,F
    GOTO LADR_0x00E1
    MOVLW 0xFF
    MOVWF LRAM_0x2B
    MOVLW 0x55
    MOVWF LRAM_0x2A
LADR_0x00E1
    MOVLW 0x33
    MOVWF LRAM_0x27
    BCF PORTC,0          ; $ PORTC - TRISC
    CALL LADR_0x00FD
    CALL LADR_0x00FD
    BTFSS PORTA,3        ; !!Bank!! PORTA - TRISA
    GOTO LADR_0x00DB
    CALL LADR_0x0017
    BTFSS PORTA,3        ; !!Bank!! PORTA - TRISA
    GOTO LADR_0x00DB
    MOVLW 0x55
    SUBWF LRAM_0x2A,W
    BTFSC STATUS,Z
    GOTO LADR_0x0073
    MOVLW 0x3C
    MOVWF LRAM_0x27
    CALL LADR_0x00FD
    CALL LADR_0x00FD
    GOTO LADR_0x0073
LADR_0x00F4
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    BSF PORTC,0          ; $ PORTC - TRISC
    GOTO LADR_0x0073
LADR_0x00F7
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    BSF PORTC,0          ; $ PORTC - TRISC
    GOTO LADR_0x0073
LADR_0x00FA
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    BSF PORTC,0          ; $ PORTC - TRISC
    GOTO LADR_0x0073
LADR_0x00FD
    BCF STATUS,RP0       ; !!Bank Register-Bank(0/1)-Select
    MOVLW 0x03
    MOVWF LRAM_0x36
LADR_0x0100
    CALL LADR_0x0017
    CALL LADR_0x0029
    CALL LADR_0x0029
    DECFSZ LRAM_0x36,F
    GOTO LADR_0x0108
    BCF PORTC,5          ; $ PORTC - TRISC
    BSF PORTC,0          ; $ PORTC - TRISC
    RETURN
LADR_0x0108
    MOVF LRAM_0x27,W
    MOVWF LRAM_0x35
    MOVLW 0x00
    MOVWF LRAM_0x28
    CALL LADR_0x0370
    MOVWF LRAM_0x30
    INCF LRAM_0x30,F
    INCF LRAM_0x28,F
    CALL LADR_0x0370
    MOVWF LRAM_0x31
    INCF LRAM_0x28,F
    CALL LADR_0x0370
    MOVWF LRAM_0x32
    INCF LRAM_0x28,F
    CALL LADR_0x0370
    MOVWF LRAM_0x33
    MOVLW 0x29
    MOVWF LRAM_0x34
    BSF PORTC,5          ; $ PORTC - TRISC
    CALL LADR_0x0020
    BCF PORTC,5          ; $ PORTC - TRISC
    CALL LADR_0x0029
LADR_0x011E
    DECFSZ LRAM_0x34,F
    GOTO LADR_0x0121
    GOTO LADR_0x0100
LADR_0x0121
    BSF PORTC,5          ; $ PORTC - TRISC
    RLF LRAM_0x35,F
    RLF LRAM_0x30,F
    RLF LRAM_0x31,F
    RLF LRAM_0x32,F
    RLF LRAM_0x33,F
    BTFSS STATUS,C
    GOTO LADR_0x012D
    CALL LADR_0x0038
    BCF PORTC,5          ; $ PORTC - TRISC
    CALL LADR_0x003E
    GOTO LADR_0x011E
LADR_0x012D
    CALL LADR_0x0043
    BCF PORTC,5          ; $ PORTC - TRISC
    CALL LADR_0x0032
    GOTO LADR_0x011E
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
LADR_0x0370
    MOVLW 0x00
    SUBWF LRAM_0x28,W
    BTFSC STATUS,Z
    GOTO LADR_0x0380
    MOVLW 0x01
    SUBWF LRAM_0x28,W
    BTFSC STATUS,Z
    GOTO LADR_0x0381
    MOVLW 0x02
    SUBWF LRAM_0x28,W
    BTFSC STATUS,Z
    GOTO LADR_0x0382
    MOVLW 0x03
    SUBWF LRAM_0x28,W
    BTFSC STATUS,Z
    GOTO LADR_0x0383
LADR_0x0380
    RETLW 0x40
LADR_0x0381
    RETLW 0x25
LADR_0x0382
    RETLW 0x30
LADR_0x0383
    RETLW 0x07
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
    ADDLW 0xFF
LADR_0x03FF
    RETLW 0x50

    End

[sebastian xxlxx (Gast)]

Hola

Gracias por el código.

sebastian
xxlxx

[rohrmotor24 (Gast)]

Hallo

diese Motoren gibt es bei bei Rohrmotor24.eu zu kaufen. Ich finde den 
Preis echt klasse (57€ je Rohrmotor mit Funksteuerung). Ich habe jetzt 
15 Stück von der RMF Serie bestellt und dazu eine Fernbedienung 
RMF-Sender 15 Kanal. Jetzt baue ich euer Projekt mal nach. Toll das es 
so Jungs gibt wie euch!

LUCAS
aus Frankfurt

[Carsten M. (ccp1con)]

Diese Motore lassen sich dann aber NUR über Funk steuern.
Meine bereits vorhandenen Schalter kann ich dann vergessen?

[Sebastian (Gast)]

Ja diese Antriebe haben nur eine funksteuerung. Keinen Anschluss für 
Steuerkabel.

[Carsten M. (ccp1con)]

Gibt es das überhaupt, Motore mit Funk und Schalter?

[Sebastian (Gast)]

Ich glaube nicht. Das macht man dann anders. Normaler Motor --> Schalter 
--> hinter den Schalter Funkmodul ...

Sebastian

[F. F. (foldi)]

Sebastian schrieb:
> Ja diese Antriebe haben nur eine funksteuerung. Keinen Anschluss für
> Steuerkabel.

Aber es muss doch ein Relais (oder zwei?) da drin sein, um die Leistung 
zu schalten. Da müsste man doch ran kommen.
Bei 57 Euro kann man einen Versuch doch wagen.

[Carsten M. (ccp1con)]

> Ich glaube nicht. Das macht man dann anders. Normaler Motor --> Schalter
> --> hinter den Schalter Funkmodul ...

Ok verstehe. Dann könnte ich mir die neuen Motore mit Funk sparen, weil 
ich schon elektrische Rollos mit Schlater habe. Diese Idee hatte ich 
auch schon durchgespielt.

Allerdings bin ich davor zurückgeschreckt die 230V mit meinem Funkmodul 
zu schalten!

[Sebastian (Gast)]

Der Aufbau ist recht einfach von so einem Motor.
- Ein Mini Netzteil für den Empfänger
- dann ein Relais
- ca 100-150watt Motor (230V 500-800mA)


Das zu öffnen ist schwer da das alles sehr kompakt ist. Und auch noch 
wasserdicht. Der Schalter davor ist eh notwendig zur Programmierung der 
funkmotore. Das geht schlecht über eine Sicherung im Keller.

[Carsten M. (ccp1con)]

>Das zu öffnen ist schwer ...
Das sehe ich auch so.

Ich glaube in meinem Fall wird es nicht einfach sein ein Funkmodul 
dahinter zu schalten. Denn, wenn ich das richtig sehe, ist es ein 
Wechselschalter. Das Abschalten passiert durch Endabschalter direkt im 
Motor und die Position des Wechselschalters bleibt unverändert.

Also könnte ich den Wechselschalter nur als Eingang für meinen 
controller nehmen. Der schaltet dann ein Wechselrelaise. Das hätte den 
Vorteil, dass ich die Prioritäten, Schalter Funk, selbst programmieren 
kann.

Lediglich bei der Spannungsversorgung bin ich noch am überlegen.
Muss wirklich einen Trafo her?

[Sebastian (Gast)]

Wieso Trafo ?
Das Mini Netzteil ist nur für den Empfänger. Nicht für den Motor.
Das ist ein kleines 2W Schaltnetzteil ähnlich eines handyladegerät.
Der Motor wird mit 230v betrieben.
Ja die Abschaltung erfolgt mit endschaltern.

Sebastian

[Sebastian (Gast)]

Es gibt sogar billig Steuerungen ohne Netzteil nur mit Kondensator ( 
blindwiderstand )

http://www.automatische-rollladen.de/rohrmotor/mechanisch-elektronisch/platine-elektronische-rohrmotor.jpg

Sebastian

[Carsten M. (ccp1con)]

Nettes Bild - Wie dimensioniert man aber sowas?

[Sebastian (Gast)]

Kondensator Netzteil :

http://de.m.wikipedia.org/wiki/Kondensatornetzteil

Google hilft dir da weiter

Sebastian

[Fred (Gast)]

Hallo,

ich frage mal hier nach, in der Hoffnung, mir kann jemand helfen.

Ich habe mehrere rohrmotor24 Funk verbaut. Einer davon zickt jetzt rum 
und ich kann den nicht eben so mal ausbauen, da es ein Aussenrolladen 
ist.

Der Rolladen fährt ganz normal rauf oder runter. Allerdings mit der 
Einschränkung, das ich nach dem druck auf die Fernbedienung für ca. 
3minuten keinen neuen Fehfehl absetzten kann und somit auch nicht den 
Rolladen auf bestimmer Höhe stoppen kann.

Hat jemand hier eine Idee, was das sein könnte (ausser defekt und 
tauschen)?

Danke und Gruß
Fred

[Sebastian A. (xxlxx)]

Hi

Das hatten bei mir auch 3 motore. Alle auf der Südseite in der Sonne.
Ich denke die Netzteile sind platt und die Spannung für den Funk ist 
nicht mehr stabil. Man hat ja 5 Jahre Garantie. Ich habe bei rohrmotor24 
abgerufen. Sie kannten das Problem. Ich habe vorab einen Motor gekauft / 
gewechselt / zurück geschickt. Somit könnte ich alles an einem Tag 
umbauen. Habe auch außenmontage.



Sebastian

Wenn die mal wieder defekt sind und 5 Jahre sind um. Wechsel ich die 
Elkos. Sollte dann wieder gehen.

[Fred (Gast)]

Hallo Sebastian,

ich habe die leider nicht webst montiert. Hat das gut geklappt? Ich 
komme von aussen leider nicht dran.
Kannst du das kurz beschreiben?

Danke und Gruß
Fred

[Sebastian A. (xxlxx)]

Hi

Ca 10-20 Minuten pro Motor.

( geht nur von außen )

- Panzer runterfahren
- Abdeckung Rollladen ( Haube ) abschrauben
- Welle mit Motor ausklinken / mit Kraft
- Motor aus der Welle nehmen
- Motor tauschen
- Motor in Welle schieben
- Motor anschliesen
- Motor programieren
- Motor - Panzer oben / unten Position einstellen
- Deckel wieder drauf
- fertig

War ein Kinderspiel. Neu Einbau ist viel aufwändiger als nur Wechsel.
Ich habe aber auch beim Einbau gleich daran gedacht das es nochmal raus 
muss ( lange Kabel - Panzer in Welle nur eingegangen usw.).

Sebastian

[Fred (Gast)]

Danke für die kurze Anleitung.

Ich werde das dann bald mal angehen.

Viele
Grüße

[Sebastian A. (xxlxx)]

Hi

So lange würde ich nicht warten. Wenn der Motor nicht mehr geht ist ein 
Ausbau fast unmöglich. Da der Panzer abgerollt werden muss. Oder dann 
der ganze Rollladen mit Führung ab muss.

Sebastian

[F. F. (foldi)]

Sebastian Albrecht schrieb:
> Hi
>
> So lange würde ich nicht warten. Wenn der Motor nicht mehr geht ist ein
> Ausbau fast unmöglich. Da der Panzer abgerollt werden muss. Oder dann
> der ganze Rollladen mit Führung ab muss.
>
> Sebastian

Ja und?
Was ist da Schlimmes bei?

[Sebastian A. (xxlxx)]

Hi
Wenn ein Anfänger fragt und es noch nie gemacht hat, gibt es auch die 
einfache Antwort und die einfache Lösung. Wenn jemand das noch nie 
gemacht hat und muss im 1OG auf einer Leiter den Motor wechseln ist es 
einfacher wenn der alte Motor noch tut. Ich selber habe einen 2,00 x 
2,20m Rollladen im ersten OG von außen aufgeschraubt. Da den Motor 
alleine zu wechseln ist echt hart wenn der Panzer sich nicht nach unten 
abrollen lässt. Man muss den Laden mit den Schienen abbauen und ohne zu 
verkanten die ca 40-50 kg auf der Leiter nach unten bringen ...

Sebastian

[Fred (Gast)]

Hallo Sebastian,

danke, ich werde das nicht zu lange hinauszögern. Guter Hinweis.

Gruß
Fred

[Thorsten (Gast)]

Hi,

nachdem das Protokoll von Rohrmotor24 ja offen ist, frage ich mich ob 
das schon jemand die Motoren in FHEM eingebunden hat? Diese müssten sich 
ja jetzt mit dem richtigen Perl Code direkt über den CUL ansprechen 
lassen. Oder liege ich da falsch? Verstehe auch nur die Hälft in dem der 
Diskussion.

[Sebastian A. (xxlxx)]

Hi

Glaube nicht das es so einfach ist. Der Code von rohrmotor24 ist ein 
Eigenbau made in Asien. Ganz simpel gemacht. Aber funktional und gut. 
Ich kenne keine Gemeinsamkeit zu anderen Herstellern. Wir hier haben den 
Code ausgelesen - nachgebaut - geprüft - funktioniert . Ich habe das auf 
einem Raspberry PI laufen mit Web und App Steuerung. Aber alles im 
Eigenbau.

Sebastian

[Thorsten H. (thoffma3)]

Sebastian.  Kann ich deine Lösung bei mir nachbauen?  Was für ein Gerät 
nutzt du zum senden vom Pi. Ich hab ein Stappelmodul von Busware.


Wenn eine direkt Einbindung in Fhem nicht geht, könnte man deine Lösung 
ja per http request aus Fhem ansprechen. Das geht auf jeden fall

[Jörg (Gast)]

Sebastian Albrecht schrieb:
> Hi
>
> Glaube nicht das es so einfach ist. Der Code von rohrmotor24 ist ein
> Eigenbau made in Asien. Ganz simpel gemacht. Aber funktional und gut.
> Ich kenne keine Gemeinsamkeit zu anderen Herstellern. Wir hier haben den
> Code ausgelesen - nachgebaut - geprüft - funktioniert . Ich habe das auf
> einem Raspberry PI laufen mit Web und App Steuerung. Aber alles im
> Eigenbau.
>
> Sebastian

Hallo,

kannst du dafür eine Anleitung machen?

VG,
Jörg

[Sebastian A. (xxlxx)]

Hallo

Was soll ich da für ne Anleitung machen. Das ist 3-4 Jahre her.
ich habe mal zwei Bilder zugefügt. Man sieht den Raspberry PI oben drauf 
ein ATMega88 mit einem 433Mhz Sendemodul.

Funktion:

Der Raspberry hat einen Webserver. Dieser schickt per Button einen 
Befehl per Exec an die Bash. die Bash sendet einen Code ( selber 
ausgelesen - siehe oben ) an die Serielle Schnittstelle vom Rasperry. 
Übertragung erfolgt seriel an den ATmega88 dieser macht das Timing und 
setzt "0"  und "1" richtig um und bringt es an das 433Mhz Modul. Fertig

also eigentlich recht einfach.
Das Funkmodul  ist Dumm und tut nur.
das ATmega88 Setzt nur um - also auch nur dumm
der Raspberry ist das denkende Element und enthält die Codes.

somit kann man alles steuern was dem Timing entspricht.

Sebastian

[Dirk (Gast)]

Hallo zusammen,

ich versuche seit einigen Tagen die von Sebastian vorgestellte Lösung 
auf einem Arduino (ATMEGA 328P) mit am D10 angeschlossenen mini- 433Mhz 
Funksender nachzubauen.

Im Moment möchte ich es nur schaffen, dass mein Funkempfänger sich auf 
Kanal 13 einlernen lässt (gerne auch mit Sebastians Sender-ID).
Leider reagiert der Empfänger überhaupt nicht, nachdem ich die Learn- 
Taste betätigt habe und den Arduino- Sketch gestartet habe.
Er müsste ja eigentlich pro Durchlauf der Sequenz einmal piepen...

Hat jemand das ganze schon auf einem Arduino am Laufen und kann helfen ?
Ich möchte meine 16 Jalousien gerne mit meiner Hausautomation (openHAB) 
steuern.

Ich freue mich über jede Hilfe..!

VG

Dirk

[Bjoern W. (bwelker)]

Hallo,

ich bin leider leider völlig unbewandert was das Thema RF angeht....
Wäre es bei diesem Sender und Empfänger nicht auch möglich sich via 
Arduino und der RCSwitch ein Ausleseprogramm für die ID zu bauen und 
dann ein kleinen Sketch der das ganze so nutzbar macht das man via Shell 
auf einem Raspberry z.B. rauf runter usw. steuern kann ?

.mfg

[Sebastian A. (xxlxx)]

Hi

alles ist möglich. So ein 433 Mhz Sender wird nur wie eine Lampe ein 
oder ausgeschaltet. Jeder 433 Mhz Sender ist in der Lage das Rollo zu 
steuern. Es kommt auf die richtigen "AN - AUS" Werte an und auf das 
Timing. Wenn du mit der Hand schnell genug bist schaffst du das mit 
einem Sender + Schalter + Takt im Kopf   ( Scherz !!!) würde aber gehen. 
du musst den Sender nur an einen Port hängen und dann Takten. Das Takten 
ist weiter oben beschrieben und nicht so einfach ( siehe Bilder ).

dir das Programm für dein Device zu bauen das musst du schon selber. 
Aber es geht mit jeder Plattform und jeder Sprache.

EDIT : Beitrag vom 06.01.2012 20:19 lesen. da steht das Timing und der 
Code

[Bjoern W. (bwelker)]

Ich bin etwas fündig geworden im Netz.
Eine wunderbare Seite von jemanden der auch schon mit seinen Motoren 
gekämpft hat. Dieses Protokoll was er in RCSwitch eingebaut hat 
funktioniert auch für diese Motoren hier.

Ein Auslese Programm der Codes für Arduino kann man unter 
http://physudo.blogspot.de/2013/08/home-automation-mit-dem-arduino-und-433_17.html 
finden. Die Modifikation von RCSwitch für Arduino unter 
http://physudo.blogspot.de/2013/08/home-automation-mit-dem-arduino-und-433_18.html
Ich habe das mit einem Arduino Nano probiert läuft ohne Probleme. Für 
den Raspberry teste ich heute die Modifikation.

Hoffe das hilft weiter gerade was das umständliche auslesen der 
Fernbedienungen angeht.

[Matthias B. (macmattes)]

Hallo

habe hier einbauempfäger und einen aufputz 2 kanal fernbedienung von 
rohrmotor24.

hab mal mit dem logicanalyzer auf der fernbedineung mitgelesen und einen 
unterschied zu oben genanntem festgestellt, der code wird bei mir nur 3 
mal gesendet, bei auf und ab wird nach einer pause nochmal 3 mal 
wiederholt aber mit dem letzten bit negiert.

da sehe ich keine 20 gesendeten pakete, hab auf und ab auch jeweils nur 
kurz angetippt, passt dann aber immer noch nicht zu oben genannten 4x 
senden

dh
auf -> 3x pause !3x
stop -> 3x
ab -> 3x pause !3x

gekauft dieses jahr, möglich dass sich was geändert hat?

[Harald F. (harryfu)]

Hallo zusammen,

ich habe vor einigen Wochen eine Hornbach-Markiese vom Typ Soluna Deluxe 
gekauft, welche sich auch nur über Funk ansteuern lässt.
Da ich jedoch aus optischen Gründen gerne Einbautaster statt 
Fernbedienungen verwenden wollte, habe ich etwas recherchiert und bin 
auf den chinesischen Hersteller Dooya gestoßen, von dem mein Rohrmotor 
hergestellt wurde.
Der Hersteller hat jedoch auch viele andere Produkte im Programm unter 
anderem mit einer Steuerung mit der Bezeichnung DC 104/105, wie Sie auf 
der Platine im ersten Beitrag zu sehen ist.
Ich selbst besitze die Fernsteuerung mit der Bezeichnung DC90 und DC 174 
(haben beide die selben Platinen).

Wenn ich mir nun die Fernsteuerungen der Firma Rohrmotor24.de ansehe und 
mit denen von Dooya vergleiche, bin ich mir sehr sicher, dass es sich 
hierbei um den Hersteller eurer Motoren/Fernsteuerungen handelt.

Die Motoren dieses Herstellers scheinen in "No-Name"-Produkten wohl weit 
verbreitet. Interessant fände ich nun natürlich, ob ich mit eurer 
Codierung auch meine Markiese zum bewegen bringe, oder ob der Hersteller 
für unterschiedliche Serien auch unterschiedliche Protokolle einsetzt. 
Das kann ich allerdings erst in einigen Wochen testen, da ich aktuell 
noch an meiner Masterarbeit schreibe.
Eventuell können wir dann hier ja eine Liste mit kompatiblen 
Steuerungen/Motoren aufbauen bzw. falls die Codes sich unterscheiden 
würde ich versuchen die Unterschiede herauszuarbeiten.


Anbei ein Link der Produktübersicht des Herstellers. Leider ist die 
Seite extrem! langsam und fällt ab und zu auch mal für mehrere Stunden 
komplett aus: http://en.dooya.com/products.html

Viele Grüße
Harald

[Bjoern W. (bwelker)]

Ich habe mal mit einem GIT angefangen
https://github.com/bjwelker/Raspi-Rollo

Las Hersteller habe ich bisher Acomax, Rohrmotor24 & Alusel

[Thomas S. (tom_wob26)]

@ Bjoern Welker

Tolles Projekt, habe gestern die Codes aus der FB ausgelesen...
Wo trage ich die Codes in deinem Projekt ein, in Bezug auf Raspberry pi?

Du hast auf deinem Raspberry einen Tomcat laufen um die Applikation zu 
deployen?
Kannst du eine kleine Anleitung schreiben?

DuG Thomas

[Bjoern W. (bwelker)]

Hallo Thomas,

Anleitung will ich nächste Woche auf die GIT Seite stellen. Zu deinen 
Fragen. Die app.py im webapp Ordner benutzt flask ist somit ein 
eigenständiger Http Server inkl. API. In dieser Datei findest du auch in 
Zeile 9 die Einstellungen für die 5 Hoch / Runter und den Gruppen Kanal 
Hoch/Runter.
Ich werde zusehen das ich nächste Woche die WIKI Seite fertig habe.
Aber wenn du dir die app.py anschaust dürfte das starten kein Problem 
sein.

[Thomas S. (tom_wob26)]

Hi bwelker, ich habe es schon "fast" zum laufen bekommen:
für interessierte: 
https://github.com/raspberrypilearning/web-server-flask/blob/master/worksheet.md

root@raspberrypi:/var/www/webapp# python app.py

192.168.178.22 - - [12/Apr/2015 19:38:51] "POST /api HTTP/1.1" 200 -
sending QuadState[FQQ1F000FF000F000101]

chmod +x sendv2 nicht vergessen ;-)

Befeh wurde erfolgreich gesendet, aber es passiert noch nichts.
Welcher pin wird den auf den Raspbery b+ angesprochen?
Sender ist momentan am Pin 11 angeschlossen, WringPi =0 bzw GPIO=17
Vielen dank, Thomas

Update:
Es funktioniert!
die erste Codezeile fängt mit "Q" oder "F" an und die ca. 10 
wiederholungen aber mit "O"
also die mit der "0 funktionieren"

@bwelker, super Arbeit!

[Jarno K. (jarno_k)]

Hallo,

ich habe mich inzwischen durch dieses Thema querdurch gearbeitet. 
Inclusive Raspi-Rollo und Udo´s Seite und auch die 
[[https://github.com/RFD-FHEM/RFFHEM]]SIGNALduino Seite...
Es muß doch eine Möglichkeit geben das ganze in FHEM einzubinden. 
FHEM-Module werden in Perl geschrieben. Der Sketch für den Arduino nano 
ist auch vorhanden um die Signale zu lesen. Der Code ist geknackt. und 
Senden mit umweg über phyton webapp geht ja auch...

Ich habe irgendwo sogar gelesen es sei nichts anderes als eine Steckdose 
an und aus zu schalten, ich habe mir RCswitch auf github angesehen vom 
Raspi-Rollo, da sind sogar noch die Zeilen von Intertechno mit drin. Von 
Intertechno gibt es auch ein Modul in FHEM. Mit dem SIGNALiduno ist ein 
auswerten des Dooya Codes (Rohrmotor24/ Nobily) möglich. Leider ist ein 
RAW senden der Signale über FHEM noch nicht möglich.

Ich selber bin leider nicht in der Lage ein FHEM Modul zu schreiben... 
Vielleicht kann das ja einer von euch...

MfG Jarnsen

[sebastian (Gast)]

Hi

ich bin der Ersteller von diesem Post. inzwischzen sind ein paar jahre 
vergangen. Die Rollos laufen immer noch ohne Probleme. Aber ! ich bin 
auch ein neuen Raspberry II umgestiegen und schon war es aus mit dem was 
ich gebaut hatte. Deshalb habe ich mich dran gemacht und eine schnelle 
und sehr kostengünstige Version gebaut.

ich habe an den PI nur einen 433Mhz sender (3€) gebaut und das programm 
zum steuern komplett in C++ auf dem PI getippt. Jetzt geht das ganze 
ohne zusatzhardware und jeder kann es nachbauen.

bin gerade in zeitnot wer fragen hat oder bilder möchte oder auch sehen 
will wie ich das timing aufzeichne ... bald mehr

Sebastian

[Jarno K. (jarno_k)]

Da bin ich ja mal gespannt... Ist c++ ein großer Unterschied zu Perl??
Wann denkst du das du zu ner Anleitung kommst... Was brauche ich 
dafür...

[falker (Gast)]

Es geht doch noch viel leichter, einfach unter " pilight " googeln

Grüße

[Jarno K. (jarno_k)]

Dann klär mal bitte ein wenig auf

[Sebastian xxlxx (Gast)]

Hi

Leider geht pilight bei den Rollos nicht. Das Signal ist zu schnell. 
Nachdem ich mein programm fertig hatte habe ich es pilight gefüttert. 
Direkt von Ausgang auf Eingang ohne über 433mhz zu gehen. Selbst da kann 
pilight nicht mitschneiden. Im RAW Modus zeigt pilight was an aber die 
Werte sind bei jedem Durchgang anders. Ich denke die abtastung von 
pilight ist nicht schnell genug. Mit pilight habe ich lange probiert. 
Habe es dann aber aufgegeben. Alle anderen handsender konnte pilight 
lesen aber nicht die von rohrmotor24. Deshalb mein eigenes Tool.


Sebastian
Von unterwegs :-)

[Jarno K. (jarno_k)]

Ich bin gespannt... Ist sowas in Perl zu schreiben schwer??? FHEM ist 
echt ne tolle Sache und so Modular aufgebaut....

[sebastian (Gast)]

Hi

hier mein code. Sorry das habe ich in 10 minuten getippt und es geht 
wunderbar. Aber man kann ihn verbessern.

#include <wiringPi.h>
#include <stdio.h>


// 28 Stellen = ID
// 4 Stellen = Kanal
// 8 Stellen = Befehl

int send_0(){
          digitalWrite (0, HIGH) ;
          delayMicroseconds (320) ;
          digitalWrite (0,  LOW) ;
          delayMicroseconds (600) ;
          return 0;
}

int send_1(){
          digitalWrite (0, HIGH) ;
          delayMicroseconds (700) ;
          digitalWrite (0,  LOW) ;
          delayMicroseconds (270) ;
          return 0;
          }

int send_init(){
          digitalWrite (0, HIGH) ; delayMicroseconds (5000) ;
          digitalWrite (0,  LOW) ; delayMicroseconds (1500) ;
          return 0;
          }

int main (argc, argv)
        int argc;
        char *argv[];
        {
          int i;
          wiringPiSetup ();
          pinMode (0, OUTPUT);
          while (i < 10) {
                send_init();

                i++;

                //ID
                send_0();send_0();send_0();send_1();send_1();send_0();send_1();
                send_1();send_0();send_0();send_1();send_0();send_0();send_1();
                send_0();send_0();send_0();send_1();send_1();send_1();send_1();
                send_1();send_0();send_0();send_1();send_1();send_0();send_1();

                // kanal 1 bis 128 binär
                if (strcmp(argv[1],"0") == 0) { send_0(); }
                if (strcmp(argv[1],"1") == 0) { send_1(); }
                if (strcmp(argv[2],"0") == 0) { send_0(); }
                if (strcmp(argv[2],"1") == 0) { send_1(); }
                if (strcmp(argv[3],"0") == 0) { send_0(); }
                if (strcmp(argv[3],"1") == 0) { send_1(); }
                if (strcmp(argv[4],"0") == 0) { send_0(); }
                if (strcmp(argv[4],"1") == 0) { send_1(); }

                // Funktion wählen
                if (strcmp(argv[5],"runter") == 0) { send_0();send_0();send_1();send_1();send_0();send_0();send_1();send_1();}
                if (strcmp(argv[5],"hoch") == 0)   { send_0();send_0();send_0();send_1();send_0();send_0();send_0();send_1();}
                if (strcmp(argv[5],"stop") == 0)   { send_0();send_1();send_0();send_1();send_0();send_1();send_0();send_1();}
                if (strcmp(argv[5],"lernen") == 0) { send_1();send_1();send_0();send_0();send_1();send_1();send_0();send_0();}
                //pause beim senden
                digitalWrite (0,  LOW) ; delay (50) ;
          }
  return 0 ;
}

aufruf geht so :

nice -n -19 ./rollo_prg 0 1 0 0 runter

mit nice kan man die Prio ändern. Das timing wird viel besser.
die 0100 sagt aus welcher kanal gesendet wird. danach dann der befehl 
siehe Code

Sebastian

[Jarno K. (jarno_k)]

Das geht dann aber nur über die console zu schalten. Richtig?? Wie 
gesagt Einbindung in die FHEM Oberfläche wäre toll... Geht das???

Bin nicht so bewandert... Muss ja auch die FB noch auslesen...

Jarnsen

[Sebastian (Gast)]

Hi

eigentlich musst du da nix auslesen. Motor anbauen und unter strom 
bringen. Dann pipt es im motor. Jetzt hoch oder runter drücken. Fertig. 
Ob du das mit der FB machst oder mit dem PI ist egal. Nimm eine ID ( 
egal , zufall ) und lerne die rollos an.

wichtig sind doch eh nur die timing zeiten für 0 und 1 und wie der code 
aufgebaut ist

// 28 Stellen = ID
// 4 Stellen = Kanal
// 8 Stellen = Befehl


senden_0(){
          digitalWrite (0, HIGH) ;
          delayMicroseconds (320) ;
          digitalWrite (0,  LOW) ;
          delayMicroseconds (600) ;
          return 0;
senden_1(){
          digitalWrite (0, HIGH) ;
          delayMicroseconds (700) ;
          digitalWrite (0,  LOW) ;
          delayMicroseconds (270) ;
          return 0;

wie das in FEHM geht weis ich nicht. ich starte das tool aus einer 
Weboberfläche raus.

[Sebastian (Gast)]

Hi

ich nochmal. die FEHM steuerung kann Bash scripte ausführen ( Linux 
programme )

http://forum.fhem.de/index.php?topic=12611.15

Da würde ich einfach mein tool dranhängen und fertig.


Demo :

define START dummy
define START_notify notify (START:on) {\
{fhem("set START off")}\
{system('sudo /root/script/rollo kanal 0 0 0 1 hoch &');;}\
}

mit ein paar kniffen hast du das in 20 minuten am laufen.

Sebastian

[Jarno K. (jarno_k)]

Ok, ich bedanke mich erst mal und versuche mein Glück... Weißt du wie 
wieviele verschiedene FB ein Motor verarbeiten kann??? Würde ja gerne 
die alten weiter nutzen... Setz mich gleich dran


MfG Jarnsen

[Sebastian xxlxx (Gast)]

Hi

Jeder Motor kann 20 FB Codes erlernen. Laut Anleitung.
Wir reden aber die ganze Zeit von den RFM Motoren von rohrmotor24.de

Sebastian

[Jarno K. (jarno_k)]

pi@raspberrypi ~ $ dir
culfw-code  Downloads     minicom.log  Public            rcswitch-pi 
Videos
Desktop     fhem-5.6.deb  Music        python_games      rollo 
webapp
Documents   index.html    Pictures     raspberry-remote  Templates 
wiringPi
pi@raspberrypi ~ $ nice -n -19 ./rollo 0 1 0 0 runter
nice: die Priorität kann nicht gesetzt werden: Keine Berechtigung
./rollo: 5: ./rollo: //: Permission denied
./rollo: 6: ./rollo: //: Permission denied
./rollo: 7: ./rollo: //: Permission denied
./rollo: 9: ./rollo: Syntax error: "(" unexpected



FHEM

2015.11.16 18:26:34 1: PERL WARNING: Backslash found where operator 
expected at (eval 212) line 1, near "}\"
2015.11.16 18:26:34 3: eval: {\ {fhem("set START off")}\ {system('sudo 
/root/script/rollo kanal 0 0 0 1 hoch &');}\ }
2015.11.16 18:26:34 1: PERL WARNING:   (Missing operator before \?)
2015.11.16 18:26:34 3: START_notify return value: syntax error at (eval 
212) line 1, near "}\"
syntax error at (eval 212) line 1, at EOF

2015.11.16 18:30:03 1: PERL WARNING: Backslash found where operator 
expected at (eval 249) line 1, near "}\"
2015.11.16 18:30:03 3: eval: {\ {fhem("set START off")}\ {system('sudo 
/root/rollo kanal 0 0 0 1 hoch &');}\ }
2015.11.16 18:30:03 3: START_notify return value: syntax error at (eval 
249) line 1, near "}\"
syntax error at (eval 249) line 1, at EOF

[Sebastian xxlxx (Gast)]

Hi

Du brauchst erst das programm Rollo.
Aber der Rest sieht gut aus. FHEM fürt das Script aus.
Welches Linux verwendest du? du kannst mein fertiges Programm verwenden. 
Ich schicke es dir. Mail ?

Sebastian

[Jarno K. (jarno_k)]

Jetzt noch mal für doofe (für mich) ich erzeuche über ftp ne Datei und 
copy&paste deinen code rein?? habe ich gemacht.

Oder geht das anders? ich kenn mich 0 aus mit Linux. Hangel mich immer 
an Anleitungen entlang. WiringPi habe ich aber drauf.

Jessy nutze ich.

[e-mail]

[Mario (Gast)]

Guten Abend,

ich habe alles durchgelesen und konnte es nachvollziehen jedoch bin ich 
weit weit weg es im Detail zu verstehen ;) Ich bin von Everhome.de einem 
System was verschiedene Protokolle unterstützt auf Homematic gewechselt. 
(weil hier einfach mehr Sensoren unterstützt werden)

Seid Ihr mit der Einbindung in FHEM weitergekommen, denn dann denke ich 
könnte man dies auch auf die CCU2 portieren. Es hemmt mich (finanziell) 
noch etwas die 12 Taster von Rohrmotor24 auszutauschen.

Es wäre super wenn man das in Homematic hinbekommen könnte.

VG

Mario

[Sebastian xxlxx (Gast)]

Hi

Ich habe dem Jarno ein tool gegeben was auf dem PI unter FHEM problemlos 
läuft. Alle Befehle werden zu 100% unterstützt. Jarno wollte ein Beitrag 
dazu verfassen mit allen wichtigen Infos und auch dem Programm.

Wie schon gesagt ich habe das Programm in c++ getippt mit allen befehlen 
und Optionen.

@ Jarno : jetzt bist du dran!

Sebastian

[Jarno K. (jarno_k)]

Sorry, habe ich hier nicht rein geschrieben. Die Anleitung habe ich im 
FHEM Forum geschrieben.

http://forum.fhem.de/index.php/topic,43548.0.html


Wie ist Everhome?? Die Unterstützung für Nobily haben die ja eingebaut.

[Sebastian xxlxx (Gast)]

Hi

Super Jarno habe deinen Beitrag gelesen. Top geschrieben und gut 
erklärt.

Aber nochmal für die anderen. Ich habe eine Programm getippt welches die 
rohrmotor24 Codes auch aus Konsole vom PI sendet. Einfach einen 2€ 
Sender an den PI mit 3 Kabeln hängen und fertig ! Programm ausführen und 
bis zu 256 Rollos steuern.

Sebastian

[Jarno K. (jarno_k)]

Hab gerade noch ein wenig ergänzt. 256 Rollos per ID oder? Weil Kanäle 
gehen ja nur 15 bei 4 binärstellen.

Weiterhin denke ich das

Bit33 - 40 wie folgt geschlüsselt sind

33+37 = lernen / sind im ersten Signalbereich gleich belegt entweder 
beide 0 oder 1
34/35/36 = hoch (001) /runter (011) /stop (101) /lernen (100) 33 mit 1 
und 37 mit 0 oder 1 belegt
38/39/40 = hoch (001, invertiert 110) /runter (011, invertiert 100) 
/stop (101, invertiert 010) /lernen (100, 33+37 dann mit 1 belegt, 
invertiert 011, 33 mit 1 und 34 mit 0 belegt)

man kann die Motoren invertiert anlernen, deshalb wird bei nem Signal 
immer beides gesendet.

[Axelr. (Gast)]

Sebastian A. schrieb:
> char *p = "0001111100110000001011101111000101010101"; //FB 1 Stop
>   while( *p )
>      {
>        if (*p=='0') bit_null();
>        if (*p=='1') bit_eins();
>      p++;
>        }

witzig gemacht :)

[Sidey (Gast)]

Hallo allerseits,

bezüglich FHEM Integration, nur mal so zur Info.
Das was das CPP Programm da sendet, kann der SIGNALduino auch senden, 
das ist kein Problem.

Da wird ja die gleiche Sequenz immer 10x gesendet.
Was im SIGNALduino nicht geht ist eine Sequenz so und dann eine andere 
direkt im Anschluss, was aber scheinbar auch nicht notwendig ist.



Grüße Sidey

[Sebastian xxlxx (Gast)]

Hallo

Ja das ist richtig das es heute viel einfacher ist. Man kauft sich ein 
China Arduino für 4-5€ dann noch das Receiverkit für 4€ und steckt alles 
zusammen. Dann noch ein wenig Internet und fertig.

Aber vor 6 Jahren ( Beitraganfang ) war das noch anders. Ich habe mich 
da noch hingesetzt und einen ATMega8 auf eine Platine gelötet. Mit dem 
Funkscanner gesessen und Signale analysiert. Auch im internet gab es nix 
fertiges. Ich war wohl der erste der den Rohrmotor24 entschlüsselt 
hatte. Eine USB Komunikation wäre damals auch wünschenswert gewesen. Da 
war das noch alles Handarbeit und viel zeitintensiver als heute.

Also was heute sehr einfach aussieht war vor einigen Jahren noch 
richtige Hardwarebastelei. Der Software Code ist aber fast 
gleichgeblieben.

Sebastian

[Annika (Gast)]

Hallo,
da ich die anleitung genau so ausgeführt habe wie von Jarno in Fhem 
beschrieben
bring ich es nicht zum laufen liegt es vieleicht an der Hardware ich
habe einen Cul 433mhz und einen Cul 866mhz in meinem Raspi 2 stecken?
und bekomme diese Fehlermeldung im log von fhem :

We trust you have received the usual lecture from the local System
Administrator. It usually boils down to these three things:

    #1) Respect the privacy of others.
    #2) Think before you type.
    #3) With great power comes great responsibility.

sudo: no tty present and no askpass program specified
2016.02.13 00:13:05 3: R_RMF_Test_lernen return value: -1
übrigens fehlt bei letzten notify lernen das ; oder ist das absicht ?
vielleicht kann mir jemand helfen
Gruß Annika

[Jarnsen (Gast)]

Hallo Annika,

Ich denke nicht das es an der Hardware liegt, auch ich habe einen CUL 
433 und 868 zusätzlich am Raspi. Hast du dem User FHEM sudorechte 
gegeben??? Wenn nicht darf FHEM dieses Programm nicht ausführen und 
meckert.

https://www.elektronik-kompendium.de/sites/raspberry-pi/2002231.htm

Das dass letzte ; beim letzten lernen notify fehlt ist Absicht. Das ; 
sorgt für nen Zeilenumbruch das du das ganze Beispiel in einem Block per 
Copy and Paste in die FHEM-Eingabezeile einführen kannst. Sonst müsstest 
du jede Zeile einzeln einfügen. Und bei 10 Rollos sind es 50 Zeilen oder 
so. Nochwas zu den ;; das später im notify bei DEF im Befehl nur ; ist 
richtig so, FHEM nimmt sich immer ein ; wenn in der Eingabezeile 
eingegeben.

Demnächst geht das ganze auch mit dem SIGNALduino, Sidey hat die 
Sendeoption implementiert.

Hoffe konnte dir helfen

Jarnsen

[Annika (Gast)]

Hallo,
die Sudo rechte sind 777 ist doch ok
aber es tut sich nichts :(
hab  copy and paste gemacht hab auch in Fhem die funktion lernen die ich 
drücke wenn der Motor gepiepst hat ? normalerweise piepst er wieder 
sobald er was gelernt hat macht er aber nicht ?
vieleicht jemand noch nen tip

Danke für die Hilfe da ich 7 Rohrmotore im Haus hab und 4 die ich noch 
montieren muss deshalb ist es für mich Schön wenn ich die auch über fhem 
schalten könnte

[Sebastian xxlxx (Gast)]

Hi

Da ich das Programm geschrieben habe. Also einfach nur 777 geht nicht. 
Die Datei "Rollo" kann nur als Root ausgeführt werden. Deshalb musst du 
diese Datei in Sudors freigeben. Die FHEM ist ja kein Root. Das kann dir 
jarnsen gut erklären da er es auch machen musste. Du kannst das Programm 
auch als Root aus der Konsole starten. Dann sieht du ob es geht.

Mein Programm Sendet aber nur auf einem Pin wo ein 433mhz Sender hängt. 
Also nix mit CUL oder so. Schon gar nicht USB CUL Stick.

Sebastian

[Annika (Gast)]

Hallo,
find ich echt super das hier einen geantwortet wird und man diskutieren 
kann, deshalb ich habe mit dem connair schon die Motore am laufen gehabt 
und zwar so wie auf dem Bild
ich musste nur die 3 Zahl nach TXP verändern vieleicht kann ich jemanden 
damit weiterhelfen aber in fhem bring ich das nicht hin werd noch 
verückt.
werd deins nochmal mit root versuchen
Gruß

[Annika (Gast)]

Bild vergessen

[Jarnsen (Gast)]

Hallo Annika,

Ließ dir mal bitte den Link durch wo beschrieben wird wie du dem User 
FHEM die sudorechte verpasst.

Du musst folgendes im Kopf trennen

Das Programm Rollo kannst du so lassen wie es ist.
Wenn du dich per Konsole mit dem Raspi verbindest ist das mit dem User 
pi sieht man schön an deinem Screenshot oben. /home/pi

Die Benutzeroberfläche FHEM legt einen User FHEM an unter /opt/fhem und 
diesem User musst du sudorechte verpassen damit er das Programm Rollo 
ausführen darf.


Jarnsen

[Jarnsen (Gast)]

@ Annika

habe mal gegooglet

versuch mal das

Root-Rechte an Benutzer vergeben (Raspberry Pi)

Der Benutzer "root" ist ein Standard-Benutzer, der sich in jedem 
Linux-System befindet. Dieser Benutzername ist nicht nur bekannt, 
sondern auch noch mit uneingeschränkten Rechten ausgestattet. Wenn man 
einen Raspberry Pi normal nutzt, dann wird man das nicht als "root" tun, 
sondern als Benutzer "pi". Der hat aber nur eingeschränkte Rechte. Das 
heißt, er darf nicht alles tun.

Gelegentlich kommt es aber vor, dass man Änderungen am Raspberry Pi 
vornehmen muss, und dann braucht man die Rechte von "root" bzw. 
Root-Rechte. Bei der Linux-Distribution Raspbian ist es so, dass der 
Standard-Benutzer "pi" auf der Kommandozeile jederzeit Root-Rechte mit 
Hilfe von "sudo" oder "su" erhalten kann. Und das ohne Kenntnis des 
Root-Passworts. Je nach Sicherheitsbedürfnis möchte man diese 
Möglichkeit einschränken.

Hinweis: Der Root-Zugang ist ein Arbeitsmittel. Ohne Root-Rechte kann 
man auf keinem System Änderungen vornehmen. Allerdings stellt ein 
direkter Root-Zugang immer auch ein Sicherheitsrisiko dar, insbesondere 
dann, wenn der Zugriff nicht eingeschränkt wird.
Aufgaben

    Wie funktionieren die Root-Rechte in der Standard-Konfiguration?
    Schränken Sie die Root-Rechte für den Benutzer "pi" ein.
    Aktivieren Sie den Root-Account durch Festlegen eines Passworts.
    Deaktivieren Sie den Root-Account.

Hinweis: Änderung von Berechtigungen

Wenn man Berechtigungen ändert, dann testet man die in der Regel gleich. 
Nur so kann man sicherstellen, das es funktioniert, wie es gewünscht 
ist. Es kommt allerdings vor, dass beim Testen die Berechtigungen nicht 
wie eigentlich gewünscht funktionieren, obwohl die Änderung richtig 
durchgeführt wurde.
In solchen Fällen sollte man daran denken, dass Änderungen an 
Berechtigungen und Konfigurationen erst von aktiven Instanzen übernommen 
werden müssen. Je nach Instanz muss dazu die Instanz neu gestartet 
werden. Im Falle von Benutzerberechtigungen (Gruppen, usw.) muss sich 
der Benutzer erst abmelden und neu anmelden. Erst dann werden zum 
Beispiel Gruppenzuweisungen übernommen. Oder bei einer Änderung einer 
Server-Konfiguration muss der Dienst neu gestartet werden. Erst dann 
übernimmt der Dienst die geänderte Konfiguration. Es gibt sogar 
Konfigurationsänderungen, bei denen ein kompletter Neustart des Systems 
erforderlich ist.
Das bedeutet, bei der Änderung von Berechtigungen und Konfigurationen 
sollte man sich klar machen, wo man die Änderung vorgenommen hat 
(laufender Prozess oder Datei) und dann überlegen, welche Instanz davon 
betroffen ist (Benutzer, Dienst oder System) und ob diese Instanz neu 
gestartet werden muss, um die Änderung zu übernehmen.
Lösung: Root-Rechte in der Standard-Konfiguration

In der Standard-Konfiguration von Raspbian (Images ab Ende 2014) ist für 
den Benutzer "root" kein Passwort gesetzt. Dafür darf der 
Standard-Benutzer "pi" mittels "sudo" mit Root-Rechten arbeiten.
"sudo" wird im Allgemeinen als "super user do" bezeichnet. Allerdings 
steht "sudo" für "substitute user do". Mit "sudo" kann man also mit den 
Rechten jedes beliebigen Benutzers Kommandos ausführen. Vorausgesetzt 
man hat Root-Rechte.

sudo {KOMMANDO}

Man kann sogar zu "root" werden, wenn man es möchte.

sudo su

oder

sudo su -

Das Kommando "su" steht für "substitute user". Im Allgemeinen sagt man 
auch "super user" dazu. Mit "super user" ist "root" gemeint, der 
unbeschränkte Rechte auf einem System hat. Allerdings kann man mit "su" 
nicht nur zu "root", sondern zu jedem Benutzer werden.
Der Unterschied zwischen "su" mit und ohne Bindestrich ("-") ist, dass 
man nur mit "sudo su" im selben Verzeichnis bleibt. Bei "sudo su -", was 
die Kurzform von "sudo su - root" ist, wechselt man ins Home-Verzeichnis 
von "root".

Mit "exit" kann man den übernommenen Benutzer verlassen und zum vorherig 
angemeldeten Benutzer zurückkehren.
Lösung: "sudo" installieren

In der Regel ist "sudo" auf Mehrbenutzer-Distributionen installiert. Es 
kann jedoch vorkommen, dass es nicht der Fall ist. Dann kann man es 
nachträglich installieren.

apt-get update
apt-get install sudo

Lösung: Root-Rechte einschränken (Benutzer-Passwort abfragen)

Normalerweise ist es so, dass der Benutzer "pi" nur beim Login nach 
seinem Passwort gefragt wird. Danach wird er nicht mehr nach seinem 
Passwort gefragt. Wenn der Benutzer dann seinen Arbeitsplatz verlässt, 
dann kann jeder ohne Beschränkung an diesem System arbeiten. Auch mit 
Root-Rechten mittels "sudo". Die Idee ist, die Berechtigungen so weit 
einzuschränken, dass der Benutzer "pi" ab und zu nach seinem Passwort 
gefragt wird, wenn er "sudo" verwendet.
Dazu muss man sicherstellen, dass der Benutzer "pi" der Benutzergruppe 
"sudo" zugeordnet ist.

sudo gpasswd -a pi sudo

Grundsätzlich kann man dadurch auch jeden anderen Benutzer zu einem 
Systemadministrator machen.
Diese Änderung wird aber erst nach der Ab- und Wiederanmeldung des 
Benutzers wirksam, sofern der Benutzer "pi" nicht schon vorher in der 
Benutzergruppe "sudo" drin war.

id pi

Anschließend ändern wir die sudo-Benutzersteuerung (Sudoers) mit 
"visudo". Damit wird eine Datei editiert, die man nie direkt editieren 
sollte.

sudo visudo

Verantwortlich für die Passwort-Abfrage bei der Nutzung von "sudo" ist 
die folgende Zeile. Sie sollte in der Konfigurationsdatei enthalten 
sein.

%sudo   ALL=(ALL:ALL) ALL

In der Konfigurationsdatei ändern wir die folgende Zeile:

pi ALL=(ALL) NOPASSWD: ALL

pi ALL=(ALL) NOPASSWD: ALL
fhem ALL=(ALL) NOPASSWD: ALL



wenn du das hast gib bitte bescheid ob es geht...

Wichtig ist dem User fhem rootrechte bekommt



Jarnsen

[Jarnsen (Gast)]

@Annika

Es läuft jetzt mit dem SIGNALduino, keine sudorechte mehr erforderlich


Gruß Jarnsen

[Hugo P. (portisch)]

Auch wenn der Thread schon etwas älter ist:

Ich habe solche Signale bei meiner Rohrmotor Fernbedienung:

Rauf: 11010000 11111001 00110010 00010001 00010001
oder
Rauf: 11010000 11111001 00110010 00010001 00011110

Runter: 11010000 11111001 00110010 00010001 00110011
oder
Runter: 11010000 11111001 00110010 00010001 00111100

Stop: 11010000 11111001 00110010 00010001 01010101

Warum sind da unterschiedliche Codes für die gleiche Funktion?
Will es nur verstehen...

[Xxlxx (Gast)]

Hi

Könnte sein das es rollender Code ist. Er ändert sich jedes Mal. Reden 
wir von der gleichen Hardware ?

Sebastian

[Jarno Karsch (Gast)]

https://forum.fhem.de/index.php?topic=43548.0


Die letzten 4 Bit können auch investiert sein... das passt so...



Jarnsen

[Jarno K. (jarno_k)]

Jarno Karsch schrieb:
> https://forum.fhem.de/index.php?topic=43548.0
>
>
> Die letzten 4 Bit können auch investiert sein... das passt so...
>
>
>
> Jarnsen

ID

mit einer 28 Bit ID sind 268.435.455 verschiedene Mögklichkeiten 
(Gruppen)  vorhanden. Das jemand genau Eure ID herausbekommt ist also 
relativ unwahrscheinlich. Das ganze mit 15 Kanälen multipliziert 
bedeutet ihr könnt 4.026.531.825 einzelne Rollos ansteuern. Aber wer hat 
schon so viele?? Ich denke nichtmal das Dooya schon soviel produziert 
hat.

Kanal

 0=0000|1=0001|2=0010|3=0011|4=0100|5=0101|6=0110|7=0111|8=1000|9=1001|10 
=1010|11=1011|12=1100|13=1101|14=1110|15=1111

Befehl

ich denke das bit 33 - 40 wie folgt geschlüsselt ist

33+37 = lernen / sind im ersten Signalbereich gleich belegt entweder 
beide 0 oder 1
34/35/36 = hoch (001) /runter (011) /stop (101) /lernen (100) 33 mit 1 
und 37 mit 0 oder 1 belegt
38/39/40 = hoch (001, invertiert 110) /runter (011, invertiert 100) 
/stop (101, invertiert 010) /lernen (100, 33+37 dann mit 1 belegt, 
invertiert 011, 33 mit 1 und 34 mit 0 belegt)

man kann die Motoren invertiert anlernen, deshalb wird bei nem Signal 
immer beides gesendet.


Nochmal komplett

[Spicer L. (Firma: www.ltspiceusers.ch) (treki)]

Hallo Gemeinde
Ich klinke mich mal hier ein, da der Sebastian ja schon viel Vorarbeit 
geleistet hat.
Ich will mir ein DC118W Wind-Sonne-Regen Sensor kaufen.
Siehe auch: 
www.3t-components.de/pdf_doku/solar_wind_sonne_sensor_sws.pdf
Kompatibel mit Storenmotoren DM45R, R/Z, RA, RA/Z, RQ, RM, RB, RD,
DM45E, EA, ED, EQ, ET, EAB, EAC, EAF
Weiss jemand, was das für ein Funkprotokoll ist (ist 3T ein Hersteller 
oder ein Protokoll?) und ob man da auch was mit dem Raspberry und 
"433Mhz WL RF Wireless Modul Transmitter Empfänger MX-FS-03V & MX-05" 
hinbekommt?
Meine Idee wäre, nebst der Sonnenstore auch die Velux Aussenrollos mit 
einem solchen Sensor zu steuern.
Bis jetzt steuere ich diese bereits mit einem RPI mittels PIface und 
einer zerlegten 3 Tasten Velux FB (und FHEM). Allerdings nur nach 
Zeiten.
Ich müsste auf jedenfall das Sensor Signal mit dem RPI empfangen und 
auswerten können.
Schön wäre natürlich, wenn ich das Gebastel mit der zerlegten Velux FB 
auch beseitigen und die Rollos direkt per Funk ansteuern könnte. Hat 
aber keine Priorität.
Danke schonmal für Eure Tips und Ideen.

[Sebastian A. (xxlxx)]

Hi

3T ist der Hersteller. Und sie schreiben es geht nur mit ihren 
Komponenten. Die werden dann wohl ein eigenes Protokoll haben.

Ich denke da gibts nur eins : kaufen und auslesen. So wie ich damals bei 
den ersten Motoren. Nur heute ist es viel einfacher. Pi nehmen - 433mhz 
Empfänger dran und etwas Software zum sniffen.

Bei mir war das noch ein funkscanner + oszi + soundkarte ... und viel 
viel Zeit :)

Grüße
Sebastian

[Spicer L. (Firma: www.ltspiceusers.ch) (treki)]

Hehe. Werde mich dann melden, wenn ich die Teile hier habe und ein 
sniffer gebraucht habe.
Es bleiben dann sicher noch 1000 Fragen offen ^^

[Sebastian A. (xxlxx)]

Ne ne das geht schnell.
Sniffer ist in 1h gebaut. Du hast dann gleich die ersten Werte.
Und dann werden es nur 999 Fragen sein.
Wir schaffen das (?Merkel?)

:)

Sebastian

[Spicer L. (Firma: www.ltspiceusers.ch) (treki)]

Sowas wie:
https://www.princetronics.com/how-to-read-433-mhz-codes-w-raspberry-pi-433-mhz-receiver/
oder
https://tutorials-raspberrypi.de/raspberry-pi-mit-433mhz-funksender-fernsteuern/

Bin gespannt. Die Wind-Sensoren lassen noch etwas auf sich warten, da 
sie aus China kommen.
Den Rest hab ich nächste Woche bereits beisammen.



LOL. Ja, wir schaffen das.
ABER:
Das Internet ist für uns alle Neuland.
Angela Merkel, Juni 2013

[Spicer L. (Firma: www.ltspiceusers.ch) (treki)]

Bei der Wistar FB kann man im Datasheet lesen, dass sie "Rolling Code" 
hat.
Hab iwo gelesen, dass das nicht geht. Oder doch?
Weiss jemand, ob die Velux FB 433 oder 866Mhz ist?

Edit:
Hab's gerade gefunden: Velux FB hat Radiofrequenzband: 868 MHz.

[Spicer L. (Firma: www.ltspiceusers.ch) (treki)]

Wie ist das eigentlich mit 433MHz bzw 868MHz Teilen?
Egal ob ich einen Funk Sonnensensor oder Temperatursensor betrachte, 
alle sind für ein bestimmtes Fabrikat geeignet/vorgesehen.
Schaffe ich es trotzdem, diese mit einem entsprechenden Empfänger 
(433/868MHz) am RPI zu empfangen? Auch wenn sie "Rolling Code" haben?
Gibt es ein "Funk-Fabrikat", welches sich empfiehlt für eigene 
Basteleien?
Ich frage, weil ich nicht die Katze im Sack kaufen möchte ^^

[Sebastian A. (xxlxx)]

Hi

Es gibt 433 mhz Sender und Empfänger. Das gleiche auch für 868 mhz. Das 
ist grundsätzlich nur der Weg der Übertragung. Dann gibt aus zusätzlich 
noch die Art der Modulation. Und dann kommt das eigentliche digitale 
Signal noch oben drauf.

Die Frequenz und die Modulation sind einfach zu beherrschen. Hier werden 
fast nur Standarts benutzt.

Das digitale Signal ist dann der Punkt den man knacken muss. Dieser ist 
verschlüsselt. Damit eben nur ein paar an Geräten auf dieser viel 
genutzten Frequenz reden können.

Früher konnte man ein Signal kopieren und permanent senden. Hier hatte 
man immer Erfolg.

Heute wird das aber mit rollendem Code gemacht. Der Code ändert sich 
nach jeder Übertragung. Der Empfänger kennt natürlich den Code und 
erwartete dann immer den neuen Code. Dies ist nicht so einfach zu 
knacken.

Im KFZ Bereich hat man hier ganze Automarken geknackt. Man muss nur 
einmal den Schlüssel empfangen und kann dann den rollenden Code 
ausrechnen. Und die Tür öffnen :)

Aber ob du jetzt das so hinbekommst weiß ich nicht.

Ich würde es lassen. Könnte viel Arbeit sein.

Kleiner Tipp. Das Signal kann man auch vor dem 433 mhz Sender abgreifen. 
Dann hat man es sauber zum entschlüsseln. Und der Funkkram ist nicht 
störend

Sebastian

[Spicer L. (Firma: www.ltspiceusers.ch) (treki)]

Erst mal vielen Dank für Deine Ausführungen.
Werde wohl das gebastel mit der Velux FB und dem PIface (Relaiskarte) so 
sein lassen, weil die 868MHz und "Rolling Code" ist.
Ich hätte aber gern einen aussen Funk Sonnen- und Temperatursensor (am 
liebsten mit Solarzellen) angeschafft, welcher dann mit dem RPI 
kommunizieren kann.
Quasi ein Opensource Funk Signal ^^
Gibt's da nichts fertiges auf dem Markt?
Fertig hätte den Vorteil des IPxx Schutzes und der Kompaktheit.

[Spicer L. (Firma: www.ltspiceusers.ch) (treki)]

Was ich nicht ganz begreife:
"Heute wird das aber mit rollendem Code gemacht. Der Code ändert sich
nach jeder Übertragung. Der Empfänger kennt natürlich den Code und
erwartete dann immer den neuen Code."
... wie soll der Sender bzw Empfänger wissen, welcher Code als nächster 
kommt?
Es könnte ja sein, dass ein Tastendruck mal nicht beim Empfänger 
ankommt.
Somit wäre die FB bereits ein Level weiter und der Empfänger würde immer 
noch auf den "alten" Code warten.
Ist es denn nicht so, dass vllt 10 oder 50 verschiedene Codes sich immer 
abwechseln und sich dann wieder wiederholen?

[Sebastian A. (xxlxx)]

Hi

Schau mal hier :

Beitrag "Wie funktioniert das mit dem Wechselcode bei Funk-FB"

[Spicer L. (Firma: www.ltspiceusers.ch) (treki)]

Danke. Siehe den genannten Thread jetzt.
>>
"Findet Ihr nicht, es wäre an der Zeit, einen opensource Standard zu 
entwickeln/einzuführen?
Man denke an die vielen Raspberry und Atmel Fans, welche keine pauschal 
Lösung wollen!
Habe 6 Jahre nach diesem Thread das gleiche Problem.
....und ich will nicht jedes Gerät vom gleichen Hersteller kaufen!"

Freiwillige und Willige vor.
Werde die Plattform dafür bieten können.

[Spicer L. (Firma: www.ltspiceusers.ch) (treki)]

http://www.ltspiceusers.ch/forumdisplay.php?f=48

[Spicer L. (Firma: www.ltspiceusers.ch) (treki)]

Hab da mal mein eigenes Projekt gestartet.
Wenn's wunder nimmt: http://www.ltspiceusers.ch/showthread.php?t=350
An dieser Stelle nochmal vielen Dank an Sebastian A.

[Sebastian L. (slu80)]

Hallo Sebastian A.,

könntest du mir eventl. dein Programm "Rollo" zur Steuerung der Motoren 
(Rohrmotor24) zur Verfügung stellen.

Dank Google bin ich auf diesen Thread gestoßen, da ich versuchen möchte 
meine Rollläden mit HomeKit zu steuern. Ich habe einen Raspberry Pi 4 
und nutze Homebridge. Gerne würde ich da dein Programm zur Steuerung der 
Rohrmotor24 Motoren einbinden.

Über sonstige Hinweise bin ich sehr dankbar. Ich habe zwar 
Programmierkenntnisse, doch der Raspberry ist noch etwas Neuland für 
mich.

Besten Dank vorab

Viele Grüße
Sebastian L.
slu(at)sl-home.de

[Sebastian xxlxx (Gast)]

Hi

Ich melde mich bei dir in ca 2 Wochen. Bin gerade nicht im Ländle. Habe 
aber alles noch im Einsatz. Läuft fehlerfrei seit einigen Jahren. Nur 
die Netzteile an den Motoren sind reihenweise ausgefallen. Wurden aber 
von rohrmotor24 ersetzt. Netzteile sind jetzt besser - Kondensator war 
immer defekt.

Sebastian A.

[Sebastian L. (slu80)]

Hallo Sebastian,

vielen Dank für deine Nachricht :-)

Oh, das hätte ich nicht erwartet, aber es freut mich zu hören, dass 
rohrmotor24 die Motoren ersetzt hat.

Von den 9 Motoren die ich im Einsatz habe, musste ich bisher 2 Stück 
tauschen. Jedoch erst nach der Garantiezeit. Die waren auch nicht 
komplett defekt. Irgendwann haben die angefangen nachzulaufen nach dem 
Stop beim Runterfahren. Ich vermute aber, dass die Dauerbelastung zu 
groß war. Ich habe die dann jeweils gegen einen mit mehr Leistung 
getauscht.

Was mich stört, sind die Funksender. Aufgrund der Anzahl Motoren brauche 
ich den mit 15-Kanälen. Und davon liegen im Haus 4 Stück rum, die ich 
schon regelmässig austauschen musste.
Wenn ich mir überlege wie viel ich in die Motoren bisher investiert habe 
(ca. 600 - 650EUR) vs. Funksender (in Summe ca. 250EUR) finde ich das 
schon unverhältnismäßig.

Hausautomation ist bisher noch Neuland für mich, auch wenn ich 
berufsbedingt über Programmierkenntnisse verfüge. Daher will ich erstmal 
HomeKit nutzen bevor ich eine eigene App programmiere. Homebridge wird 
von HomeKit unterstützt und für Homebridge gibt es etliche Plugins. U.a. 
auch welche zum Ausführen von Programmen. Das würde mir im ersten 
Schritt vollkommen ausreichen. Rollladen hoch, runter, stop ..

Dann bis bald. Ich freue mich von dir zu hören und danke dir schonmal 
für deine Tipps und dein Programm :-)

Wenn ich das dann auch zum Laufen bekommen habe, werde ich das auf 
meinem privaten Blog dokumentieren und gerne auch hier zur Verfügung 
stellen.

Viele Grüße
Sebastian

[Jarnsen (Gast)]

Hallo Sebastian,

Da du eh mit einem RasPi arbeitest könntest du dir auch mal FHEM 
anschauen. Da ist das „Modul“ für deine Rollläden implementiert... nennt 
sich dort dooya


Mit freundlichen Grüßen Jarnsen

[Sebastian L. (slu80)]

Hallo Jarnsen,

vielen Dank für den Tipp. Ich habe deine Threads im FHEM Forum schon 
versucht zu verstehen lol
Ich bin jedoch noch nicht durchgestiegen ..

Das Programm "Rollo" von Sebastian A. würde mir im ersten Step 
ausreichen.
Wenn ich das zum Fliegen bekommen würde, wäre ich schon mal glücklich, 
überglücklich.

Generell bin ich aber sehr interessiert an dem Thema und versuche mich 
auch bzgl. FHEM aufzuschlauen ;-)

Viele Grüße
Sebastian L.

[Sebastian A. (xxlxx)]

Hallo

habe jetzt nach vielen Jahren der Nutzung ein paar neue Motoren 
einlernen wollen. Es ging aber nicht so recht. Da ich jetzt einen Logic 
Analysator besitze habe ich das nochmal analysiert und ein paar Bilder 
gemacht.

Code poste ich später. :-)

Sebastian (xxlxx)

[Kiray (Gast)]

Hallo,
Ich stehe leider noch auf dem Schlauch, trotz mehrmaligem lesen des 
Threads.
Ich hab aktuell nen rpi4 mit nem paar tools zum lesen und senden von 433 
signalen. ich konnte damit also "brennenstuhl" einlesen, und auch 
wiederverwenden per Script etc.

An den Relais der Rolladen scheitere ich irgendwie. Ich stehe irgendwie 
aufm Schlauch, welche Codes ich nun zum erstmaligen Anlernen etc nutzen 
muss, bzw mit welchen Pausen dazwischen. Als Inspiration nutz ich die 
von Sebastian verlinkte Liste (FB1)

[Sebastian A. (xxlxx)]

Hi Kiray

gib mir noch ein paar Tage dann schicke ich das fertige programm für den 
PI 1-4 als BIN Version. dann mauss man es nur noch ausführen und nutzen.

[Kiray (Gast)]

Danke für dein rasches Feedback.
Hab die nächsten 4 Wochen Urlaub und werd auch bisschen basteln, um das 
irgendwie in meiner Python Umgebung zu implementieren.

[Sebastian A. (xxlxx)]

Programm für Raspberry PI 1 2 3 3b+ 4 als fertiges Bin file / 
Rohrmotor24

Hallo

ich bin wieder ein Schritt zurück gegangen. Ich habe ich die "rollo.pi" 
Datei angehangen.
hier habt ihr keine Arbeit mehr alles selber zu machen.

Anleitung : 
rollo.pi auf den Pi kopieren.
rollo.pi benötigt root Rechte um auf dem GPIO senden zu können ( googeln ! ).

Bild im Anhang (von der Verkabelung) :  
5V (Pin2)
GND ( pin6) Masse / Minus 
Daten GPIO 17 (PIN 11)
Schwarzes Kabel = Antenne ca. 60cm 

   
Der Befehl sieht dann so aus : 

sudo rollo.pi  (28-Stellen_ID) (4-Stellen-Kanal) (8-Stellen-BEFEHL)

Die 28 ID stellen kann man so übernehmen von mir.

Die 4 Stellen Kanal sind binär so : 
0000 = alle Rollos ( Kanal 0) 
0001 = Kanal 1
0010 = Kanal 2
0011 = Kanal 3
usw. Einfach mal Binär googeln :-)

Die 8 Stellen für den Befehl kann man aus der Liste Übernehmen.
Beim Lernen ist die erste Stelle immer eine 1 ( Schrägstriche nur zur Kennung )
hoch   0 / 0 0 1 0 0 0 1
stop   0 / 1 0 1 0 1 0 1
runter 0 / 0 1 1 0 0 1 1
Lernen 1 / 1 0 0 1 1 0 0



Demo für Kanal 1 ( habe zwischen den blöcken Schrägstriche zu Kennung )
hoch    0 0 0 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 / 0 0 0 1 / 0 0 0 1 1 1 1 0
stop    0 0 0 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 / 0 0 0 1 / 0 1 0 1 0 1 0 1
runter  0 0 0 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 / 0 0 0 1 / 0 0 1 1 0 0 1 1
      
Die Befehle dazu : 
sudo ./rollo.pi 0 0 0 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 0 0 1 0 0 0 1 1 1 1 0
sudo ./rollo.pi 0 0 0 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 0 1 0 1 0 1
sudo ./rollo.pi 0 0 0 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 0 0 1 0 0 1 1 0 0 1 1


Thema anlernen :
----------------

Lernen laut Anleitung ist 2x P2 Taste drücken und dann "auf" oder "ab" je nach Drehrichtung.
das setze ich dann so um :     

Lernen ( 2x lernen 1x hoch)
sudo ./rollo.pi 0 0 0 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 0 0 1 1 1 0 0 1 1 0 0 
sudo ./rollo.pi 0 0 0 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 0 0 1 1 1 0 0 1 1 0 0 
sudo ./rollo.pi 0 0 0 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 0 0 1 0 0 0 1 0 0 0 1
Test ( 1x hoch)
sudo ./rollo.pi 0 0 0 1 1 1 1 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 0 0 1 0 0 0 1 0 0 0 1

Ich selber habe ein WebOberfläche wo ich die Befehle ausführe per 
Knopfdruck und zusätzlich noch per CronJob / Zufall  ( Urlaub ).


WICHTIG :
Zum ausführen muss man root sein !!! die GPIO kann nur von root bedient 
werden. Sudo ist euer Freund.
Zum testen ob es geht einfach eine LED anschliesen an PIN 11 . Sie 
sollte kurz leuchten wenn gesendet wird.

[Kiray (Gast)]

damn... es klappt :)
mir fehlte  der 2te lernbefehl... danke für deine Mühe!

[Jarnsen (Gast)]

@Sebastian A.

Zwecks 28Bit ID

Wir haben ja letztens telefoniert... ich glaube langsam du willst Echt 
durch D fahren und schauen wer deine ID nutzt


;)

[Sebastian L. (slu80)]

Hallo Sebastian A., Hallo Jarnsen,

ganz herzlichen Dank für eure Mühe. Vor allem Sebastian für das Programm 
und Update.

Wie ich dir schon per Mail geschrieben habe, hat das bei mir nicht ganz 
geklappt. Da es aber bei Kiray funktioniert, war ich definitiv zu blöd 
;-)

Dank Jarnsen's Tipp und seinem Forum-Thread hatte ich mich in der 
Zwischenzeit mit FHEM beschäftigt und einen SIGNALduino-Transmitter 
gekauft. Ich hatte das dann sehr schnell am Laufen und mittels 
Homebridge dann sogar ins HomeKit integriert.

Mein Ziel ist es ja eine eigene App zur kompletten Haussteuerung zu 
coden. Klar, da seid ihr mir Meilenweit voraus.

Eigentl. finde ich es zu viel overhead FHEM dazwischen zuschalten. Doch 
angesichts der vielen Plugins und Flexibilität mit SIGNALduino, der die 
Funksignale demoduliert, ist das so wie es aussieht recht einfach zu 
bewerkstelligen.

Für den Einstieg habe ich mir ne kleine iOS App gebastelt ( 
https://blog.sl-home.de/?p=109 ), die meinen aktuellen Anforderungen 
gerecht wird.

Nun werde ich das Zug um Zug erweitern und meine Thermostate austauschen 
und dann die Fenstersensoren. Ausrangierte iPads sollen dann als fix 
installierte Control-Panel fungieren und der Node-Server dann 
entsprechend FHEM, Module und Komponenten steuern.

Ihr kennt das ja, Rollo runter je nach Helligkeit .. Thermostate zu, 
wenn Fenster auf .. usw.

Und als letztes wird auch die Alarmanlage abgebaut, wenn ich das dann 
irgendwann im Node ans Laufen bekommen habe. Aber eins nach dem anderen. 
Zumeist habe ich da nur im Urlaub Zeit intensiv dran zu arbeiten.

Beste Grüße und nachmals vielen DANK!
Sebastian L.

[Sebastian A. (xxlxx)]

Nachtrag
damit es auf einem PI 4 (4!) funktioniert muss man dieses Update machen 
:

http://wiringpi.com/wiringpi-updated-to-2-52-for-the-raspberry-pi-4b/

Just a quick post to let you know that you’ll need a new wiringPi for the Raspberry Pi 4B.

To upgrade:

cd /tmp
wget https://project-downloads.drogon.net/wiringpi-latest.deb
sudo dpkg -i wiringpi-latest.deb

Check with:

gpio -v

and make sure it’s version 2.52. I’ll push the updated sources shortly.

It will hopefully be part of the official release soon, but for now this will do.

-Gordon

[Bernd K (Gast)]

Hallo Sebastian A.,

vielen Dank für rollo.pi und all' die Arbeit, die Du hineingesteckt 
hast!
Hat bei mir auf Anhieb funktioniert.
Würdest Du vielleicht die Sourcen zu rollo.pi veröffentlichen? Oder gibt 
es sie schon irgendwo?


Vielen lieben Dank!
Bernd

[McFly (Gast)]

Hallo zusammen,
gespannt lese ich den Thread und hätte ebenfalls Interesse an der 
rollo.pi. Ich baue mir zur Zeit eine Hausautomation mit iobroker auf. 
Leider habe ich bisher keine Möglichkeit gefunden meine 3T Motoren 
(https://www.3t-motors.de/) via 433Mhz und dem pi anzusteuern.

Könnte mir jemand die nötigen Files zur Verfügung stellen?

Viele Grüße

[lanew (Gast)]

Sorry for the English, but I'm from the US (enough said!).

Anyway, I used to have roller blinds with a chain pull. Obviously got 
irritating pretty quick (especially since I have 21 such blinds).  I did 
some research and ordered a set of motors from China - because of other 
restrictions in retro-fitting, I was forced to use rechargeable motors 
with RF 433MHz receivers.  After completing this project, I am now able 
to up/down/stop all the blinds from the comfort of my couch!

I also have a Vera controller, and am looking to control these blinds 
using Vera scenes.  The Vera also allows me to write LUUP code as there 
model is quite extensible.

I am hoping that someone has done something like this before and can 
guide me.  I am very comfortable with programming, but not so good with 
any electronics.

I know that I will need an RF module of some kind, and then of course 
program the proper codes (initially I would look only at UP/DOWN/STOP 
codes for simplicity).

Other than that, the mechanics of how to rig up the Vera with the RF 
module is a mystery to me, but am hoping that it is relatively 
straightforward.

I hope I am not hijacking this forum, but happened to come across it and 
thought I would throw out my problem.

I appreciate any guidance.  Regards...