Arduino Asksin library

[jab]

Hi,

das habe ich in meinem Code ja schon drin (siehe github). Damit klappt das auch. Allerdings waren in der Klasse BK Klasse offsets drin die es bei mir gebrochen haben. Hab ich im github Code geändert. Bsp hier:

uint8_t pinPort = digitalPinToPort(tPin) - 2;

Warum ist das - 2? Für mich würde hier nur -1 Sinn machen und damit funktioniert es bei mir auch (damit der Index bei 0 statt bei 1 anfängt).

Die Powermodes habe ich auch so verstanden. D.h. aktuell muss ich immer den Config Taster drücken, wenn er von FHEM irgendwas empfangen soll? Kann ich das irgendwie einfach ändern? Oder muss ich die modelId ändern bzw in FHEM den Code?

Ich versuche gerade noch einen Aktorchannel einzufügen damit ich den Aktor im HM-LC-Sw1PBU-FM ansteuern kann. Ggf werde ich dazu mal einen anderen Aktor sniffen (für die FHEM Commands).

[trilu]

-2 deshalb

digitalPinToPort(A0) liefert bei einem 328 den Port PC, damit 3
Arduino Pin 8 liefert den Port PB, also 2
Arduino Pin 4 liefert den Port PD, aslo 4

Damit ist der kleinste Port beim 328 der PB, PB -2 fängt dann bei 0 an
Hat der 644 einen PA?

Den Aktorchannel gibt es schon, das ist die RL class. Die wird dir nur mit dem Setup in der register.h nichts helfen.
Ich hatte mal vor ein paar Tagen einen Test sketch gepostet zum testen der Relay Class.

[jab]

Hi,

der 644 hat einen PA. Ich habe meinen Code jetzt auf deinen neuen rebased. Jetzt würde ich gerne 3 Kanäle haben:
1 + 2: Remote
3: Aktor

Kann ich das Perlscript irgendwie bekommen um die Register.h zu erstellen? So werde ich leider nicht daraus schlau.


Gruß,
Jan

[jab]

Hi trilu,

ich habe deinen Code gemerged. Das Repository habe ich renamed da Arduino Namingconventions hat. Man findet es jetzt unter:  https://github.com/jabdoa2/Asksin_HM_LC_Sw1PBU_FM (mit _ statt -).

Schalten geht jetzt zuverlässig mit dem HM-LC-Sw1-Pl. Der Aktor ist vorbereitet, aber es gibt noch Bugs. Sobald ich den folgenden Code drin habe:

   // init relay stuff
   rl[0].config(3,0,12,0,0,0);                                       // configure the relay to monostable, on pin 12
   //rl[0].setCallBack(&relayState,&hm,1,1);

Rebootet das Device wenn man einen meiner Buttons drückt nach ca 1s. Sehr strange. Versuche ich zu debuggen gerade.


Gruß,
Jan

[trilu]

Sag mal,  schläfst du irgend wann mal?
Ich muss noch ein paar Feinheiten im Script korrigieren. Ich denke ich bin bis Mittag soweit...

[Dirk]

Die Buttonauswertung funktioniert noch nicht 100%ig.
Wenn man z.B. die Longpesszeit auf 1s einstellt, funktioniert Longpress nicht mehr.
Das würde ich mir heute aber mal ansehen.
Ich würde gerne auch einbauen dass man auch durch 1-fach-, 2-fach-, 3-fach-Tastendruck je einen unterschiedlichen Kanal auslösen kann.
Dafür würde ich BK::config so erweitern, dass an den Callback die Anzahl der "Doppelklickts" mit übergeben werden.
Dann kann man das weitere in buttonState machen. Oder hast du da einen anderen Vorschlag?

Ich habe Eclipse übrigens auch zum kompilieren bekommen.
Somit macht das ganze so gleich viel mehr spass.

HM6TastenSwitch.ino braucht dafür noch ein eigenes Header-File (HM6TastenSwitch.h) in dem auch dir Funktionsdeklarationen drinn sind.

Gruß
Dirk

[jab]

Moin,

es ist Congress da schläft man immer zu komischen Zeiten. Habe den Bug gefunden. Hatte ein Memory Allocation Problem bei mir (hatte zu wenig Instanzen der BK Class instanziert). Zusätzlich habe ich zwei andere Dinge gefixt: in der AskSin.h sind kein static Variables mehr. Die werden sonst zwei mal allokiert. Außerdem habe ich alle ";" am Ende von defines entfernt, weil das Fehler verursacht.


Gruß,
Jan

[trilu]

Ich habe jetzt mal einen GIT für die Library erstellt, derzeit ist erst mal nur das versprochene Paket destillRegs hochgeladen.
destillRegs beruht auf der Idee von martin876 hier im Forum, ist ein Perl Script um einen großen Teil der Register.h automatisch zu erstellen.

Das Paket besteht im Wesentlichen aus 3 Teilen:
destillRegs, das Perl Script
devDefinition.pm, um die eigentliche Funktionalität des Devices zu konfigurieren
RegConfig.pm, enthält alle derzeit bekannten Variablen der HM Devices

Alle 3 Files müssen in einem Directory sein, Aufruf ist dann einfach "perl destillRegs.pl"
Was dann auf der Konsole raus kommt, muss in die Register.h kopiert werden.

Für den Anfang ist es am einfachsten sich an einem bestehenden Device zu orientieren, nehmen wir mal einen HM_HM_LC_SW1_BA_PCB

Um so ein Gerät zu emulieren, geht ihr in Fhem auf das Device und lasst euch die Register per "get  CUL_HM_HM_LC_SW1_BA_PCB_1FB74A regList" anzeigen.
Das sieht dann so aus:

Code Auswählen Erweitern


list:         register | range              | peer     | description
   0: intKeyVisib      |     literal        |          | visibility of internal channel options:visib,invisib
   0: ledMode          |     literal        |          | LED mode options:on,off
   0: lowBatLimitBA    |   5 to 15V         |          | low batterie limit, step .1V
   0: pairCentral      |   0 to 16777215    |          | pairing to central
   1: sign             |     literal        |          | signature (AES) options:on,off
   3: lgActionType     |     literal        | required |  options:toggleToCntInv,off,toggleToCnt,jmpToTarget
   3: lgCtDlyOff       |     literal        | required | Jmp on condition from delayOff options:geLo,between,outside,ltLo,geHi,ltHi
   3: lgCtDlyOn        |     literal        | required | Jmp on condition from delayOn options:geLo,between,outside,ltLo,geHi,ltHi
   3: lgCtOff          |     literal        | required | Jmp on condition from off options:geLo,between,outside,ltLo,geHi,ltHi
   3: lgCtOn           |     literal        | required | Jmp on condition from on options:geLo,between,outside,ltLo,geHi,ltHi
   3: lgCtValHi        |   0 to 255         | required | Condition value high for CT table
   3: lgCtValLo        |   0 to 255         | required | Condition value low for CT table
   3: lgMultiExec      |     literal        | required | multiple execution per repeat of long trigger options:on,off
   3: lgOffDly         |   0 to 111600s     | required | off delay
   3: lgOffTime        |   0 to 111600s     | required | off time, 111600 = infinite
   3: lgOffTimeMode    |     literal        | required | off time mode options:minimal,absolut
   3: lgOnDly          |   0 to 111600s     | required | on delay
   3: lgOnTime         |   0 to 111600s     | required | on time, 111600 = infinite
   3: lgOnTimeMode     |     literal        | required | on time mode options:minimal,absolut
   3: lgSwJtDlyOff     |     literal        | required | Jump from delayOff options:on,off,dlyOn,no,dlyOff
   3: lgSwJtDlyOn      |     literal        | required | Jump from delayOn options:on,off,dlyOn,no,dlyOff
   3: lgSwJtOff        |     literal        | required | Jump from off options:on,off,dlyOn,no,dlyOff
   3: lgSwJtOn         |     literal        | required | Jump from on options:on,off,dlyOn,no,dlyOff
   3: shActionType     |     literal        | required |  options:toggleToCntInv,off,toggleToCnt,jmpToTarget
   3: shCtDlyOff       |     literal        | required | Jmp on condition from delayOff options:geLo,between,outside,ltLo,geHi,ltHi
   3: shCtDlyOn        |     literal        | required | Jmp on condition from delayOn options:geLo,between,outside,ltLo,geHi,ltHi
   3: shCtOff          |     literal        | required | Jmp on condition from off options:geLo,between,outside,ltLo,geHi,ltHi
   3: shCtOn           |     literal        | required | Jmp on condition from on options:geLo,between,outside,ltLo,geHi,ltHi
   3: shCtValHi        |   0 to 255         | required | Condition value high for CT table
   3: shCtValLo        |   0 to 255         | required | Condition value low for CT table
   3: shOffDly         |   0 to 111600s     | required | off delay
   3: shOffTime        |   0 to 111600s     | required | off time, 111600 = infinite
   3: shOffTimeMode    |     literal        | required | off time mode options:minimal,absolut
   3: shOnDly          |   0 to 111600s     | required | on delay
   3: shOnTime         |   0 to 111600s     | required | on time, 111600 = infinite
   3: shOnTimeMode     |     literal        | required | on time mode options:minimal,absolut
   3: shSwJtDlyOff     |     literal        | required | Jump from delayOff options:on,off,dlyOn,no,dlyOff
   3: shSwJtDlyOn      |     literal        | required | Jump from delayOn options:on,off,dlyOn,no,dlyOff
   3: shSwJtOff        |     literal        | required | Jump from off options:on,off,dlyOn,no,dlyOff
   3: shSwJtOn         |     literal        | required | Jump from on options:on,off,dlyOn,no,dlyOff


Das ist jetzt der Input für das File "devDefinition.pm". Übersetzt sieht das dann so aus:

Code Auswählen Erweitern


#----------------define reglist types-----------------
package usrRegs;
my %listTypes = (
      regDev =>{ intKeyVisib=>1, ledMode=>1, lowBatLimitBA=>1, pairCentral=>1,
              },
      regChan       =>{ sign          =>1,   
                        lgActionType  =>1,   
                        lgCtDlyOff    =>1, 
                        lgCtDlyOn     =>1, 
lgCtOff       =>1,   
                        lgCtOn        =>1, 
lgCtValHi     =>1,   
                        lgCtValLo     =>1,   
lgMultiExec   =>1,   
lgOffDly      =>1,   
lgOffTime     =>1,   
lgOffTimeMode =>1,   
lgOnDly       =>1,   
lgOnTime      =>1,   
lgOnTimeMode  =>1,   
lgSwJtDlyOff  =>1,   
lgSwJtDlyOn   =>1,   
lgSwJtOff     =>1,   
lgSwJtOn      =>1,   
shActionType  =>1,   
shCtDlyOff    =>1,   
shCtDlyOn     =>1, 
shCtOff       =>1,   
shCtOn        =>1,   
shCtValHi     =>1,   
shCtValLo     =>1, 
shOffDly      =>1, 
shOffTime     =>1,   
shOffTimeMode =>1,   
shOnDly       =>1,   
shOnTime      =>1,   
shOnTimeMode  =>1,   
shSwJtDlyOff  =>1,   
shSwJtDlyOn   =>1,   
shSwJtOff     =>1,   
shSwJtOn      =>1,   
         },
     );
#      -----------assemble device -----------------


Das neue Gerät hat damit zwei Kanäle - Channel 0, als System Kanal und Channel 1, als Schalt Kanal.

Wenn man das ganze jetzt per Script laufen lässt, also "perl destillRegs.pl" bekommt man sowas:

Code Auswählen Erweitern


//- -----------------------------------------------------------------------------------------------------------------------
//- channel slice definition ----------------------------------------------------------------------------------------------
struct s_chDefType{
        unsigned char  type;
        unsigned short phyAddr;
        unsigned short sliceIdx;
};
struct {
        unsigned char  nbrChannels;
        s_chDefType chDefType[2];
} const devDef = {
        2                               // number of channels
        ,{
                 {1,0,0}                // chn:0 type:regDev
                ,{0,6,4}                // chn:1 type:regChan
        }
};
struct s_sliceStrTpl {
        unsigned char regAddr;
        unsigned char nbrBytes;
        unsigned short phyAddr;
};


// regAddr,nbrBytes,phyAddr
const s_sliceStrTpl sliceStr[] = {
        {0x02, 0x01, 0x0000},           // chn:0 lst:0
        {0x05, 0x01, 0x0001},
        {0x0a, 0x03, 0x0002},
        {0x12, 0x01, 0x0005},
        {0x08, 0x01, 0x0006},           // chn:1 lst:1
        {0x02, 0x0b, 0x0007},           // chn:1 lst:3
        {0x82, 0x0b, 0x0012},
        {0x02, 0x0b, 0x001d},
        {0x82, 0x0b, 0x0028},
        {0x02, 0x0b, 0x0033},
        {0x82, 0x0b, 0x003e},
        {0x02, 0x0b, 0x0049},
        {0x82, 0x0b, 0x0054},
        {0x02, 0x0b, 0x005f},
        {0x82, 0x0b, 0x006a},
        {0x02, 0x0b, 0x0075},
        {0x82, 0x0b, 0x0080},
};
struct s_listTpl {
        unsigned char ListNo;
        unsigned char nbrOfSlice;
        unsigned char nbrPeers;
};
struct {
        unsigned char nbrLists;         // number of lists for this channel
        struct s_listTpl type[2];       // fill data with lists
} const listTypeDef[2] = {
        { 2                             // type regChan
                ,{
                 {1,1,1}
                ,{3,2,6}
                }
        }
        ,{ 1                            // type regDev
                ,{
                 {0,4,1}
                ,{0,0,0}
                }
        }
};

//- -----------------------------------------------------------------------------------------------------------------------
// - peer db config -------------------------------------------------------------------------------------------------------
#define maxChannel 1
#define maxPeer    6
static uint32_t peerdb[maxChannel][maxPeer];
const uint8_t peermax[] = {6};

//- -----------------------------------------------------------------------------------------------------------------------
// - Channel device config ------------------------------------------------------------------------------------------------
struct s_regDev {
        uint8_t                     :7;
        uint8_t intKeyVisib         :1; // reg:0x02, sReg:2.7
        uint8_t                     :6;
        uint8_t ledMode             :2; // reg:0x05, sReg:5.6
        uint8_t pairCentral[3];         // reg:0x0A, sReg:10
        uint8_t lowBatLimitBA;          // reg:0x12, sReg:18
};
struct s_peer_regChan {                 // chn:1, lst:3
        uint8_t shCtDlyOn           :4; // reg:0x02, sReg:2
        uint8_t shCtDlyOff          :4; // reg:0x02, sReg:2.4
        uint8_t shCtOn              :4; // reg:0x03, sReg:3
        uint8_t shCtOff             :4; // reg:0x03, sReg:3.4
        uint8_t shCtValLo;              // reg:0x04, sReg:4
        uint8_t shCtValHi;              // reg:0x05, sReg:5
        uint8_t shOnDly;                // reg:0x06, sReg:6
        uint8_t shOnTime;               // reg:0x07, sReg:7
        uint8_t shOffDly;               // reg:0x08, sReg:8
        uint8_t shOffTime;              // reg:0x09, sReg:9
        uint8_t shActionType        :2; // reg:0x0A, sReg:10
        uint8_t                     :4;
        uint8_t shOffTimeMode       :1; // reg:0x0A, sReg:10.6
        uint8_t shOnTimeMode        :1; // reg:0x0A, sReg:10.7
        uint8_t shSwJtOn            :4; // reg:0x0B, sReg:11
        uint8_t shSwJtOff           :4; // reg:0x0B, sReg:11.4
        uint8_t shSwJtDlyOn         :4; // reg:0x0C, sReg:12
        uint8_t shSwJtDlyOff        :4; // reg:0x0C, sReg:12.4
        uint8_t lgCtDlyOn           :4; // reg:0x82, sReg:130
        uint8_t lgCtDlyOff          :4; // reg:0x82, sReg:130.4
        uint8_t lgCtOn              :4; // reg:0x83, sReg:131
        uint8_t lgCtOff             :4; // reg:0x83, sReg:131.4
        uint8_t lgCtValLo;              // reg:0x84, sReg:132
        uint8_t lgCtValHi;              // reg:0x85, sReg:133
        uint8_t lgOnDly;                // reg:0x86, sReg:134
        uint8_t lgOnTime;               // reg:0x87, sReg:135
        uint8_t lgOffDly;               // reg:0x88, sReg:136
        uint8_t lgOffTime;              // reg:0x89, sReg:137
        uint8_t lgActionType        :2; // reg:0x8A, sReg:138
        uint8_t                     :3;
        uint8_t lgMultiExec         :1; // reg:0x8A, sReg:138.5
        uint8_t lgOffTimeMode       :1; // reg:0x8A, sReg:138.6
        uint8_t lgOnTimeMode        :1; // reg:0x8A, sReg:138.7
        uint8_t lgSwJtOn            :4; // reg:0x8B, sReg:139
        uint8_t lgSwJtOff           :4; // reg:0x8B, sReg:139.4
        uint8_t lgSwJtDlyOn         :4; // reg:0x8C, sReg:140
        uint8_t lgSwJtDlyOff        :4; // reg:0x8C, sReg:140.4
};
struct s_dev_regChan {
        uint8_t sign                :1; // reg:0x08, sReg:8
};
struct s_regChan {
        s_dev_regChan  list1;
        s_peer_regChan peer[6];
};

struct s_regs {
        s_regDev ch_0;
        s_regChan ch_1;
};

struct s_EEPROM {
        unsigned short magNbr;
        uint32_t peerdb[maxChannel][maxPeer];
        s_regs regs;
};

//- -----------------------------------------------------------------------------------------------------------------------
//- struct to provide register settings to user sketch --------------------------------------------------------------------

struct s_cpy_regChan {
        s_dev_regChan  l1;
        s_peer_regChan l3;
};

struct s_regCpy {
        s_regDev    ch0;
        s_cpy_regChan ch1;
} static regMC;

static uint16_t regMcPtr[] = {
        (uint16_t)&regMC.ch0,
        (uint16_t)&regMC.ch1.l1,
        (uint16_t)&regMC.ch1.l3,
};

//- -----------------------------------------------------------------------------------------------------------------------
//- Device definition -----------------------------------------------------------------------------------------------------
//        Channels:      2
//        highest List:  3
//        possible peers:6
//- Memory usage
//        Slices:17
//        EEPROM size:189 fits internal
//        const size: 92


Was jetzt für eine funktionierende Register.h fehlt, ist der Header, also das hier:

Code Auswählen Erweitern


//- settings of HM device for HM class -------------------------------------------------------------------------------------
const uint8_t devParam[] PROGMEM = {
/* Firmware version 1 byte */  0x15, // don't know for what it is good for
/* Model ID         2 byte */  0x00, 0x6C, // model ID, describes HM hardware. we should use high values due to HM starts from 0
/* Serial ID       10 byte */  'P','S','0','0','0','0','0','0','0','2', // serial ID, needed for pairing
/* Sub Type ID      1 byte */  0x10, // not needed for FHEM, it's something like a group ID
/* Device Info      3 byte */  0x41, 0x01, 0x00 // describes device, not completely clear yet. includes amount of channels
};

static uint8_t  HMID[3]     = { 0x5F, 0xB7, 0x4B }; // very important, must be unique. identifier for the device in the network
static uint8_t  maxRetries  = 3; // how often a string should be send out until we get an answer
static uint16_t timeOut     = 700; // time out for ACK handling


"Model ID" muss korrekt gefüllt sein, da sonst FHEM nicht weiss, was das für ein Gerät ist und somit autoconfig nicht funktioniert. Eine Übersicht der bekannten Geräte findet ihr in der "HMConfig.pm"
Unser Gerät hat dort eine Zeile wie folgt:

Code Auswählen Erweitern


  "006C" => {name=>"HM-LC-SW1-BA-PCB"        ,st=>'switch'            ,cyc=>''      ,rxt=>'b'      ,lst=>'3'            ,chn=>"",},

Hier findet sich auch die Model ID (006C) wieder. Das ganze ist ein "switch", das rxt=b heisst, dass das Gerät burst braucht und es hat eine List3.

"Serial ID" ist eine beliebige 10 stellige Seriennummer.

"Sub Type ID", keine Ahnung, spielt für FHEM keine Rolle, muss aber für die HM Config Software richtig gesetzt sein, sonst wird das Device dort nicht erkannt.
"Device Info", hier habe ich auch wenig Infos. Das zweite Byte gibt die Anzahl der Channel an. Muss aber auch für die HM Config Software richtig gesetzt sein.
Am einfachsten bekommt man die Infos aus dem Pairing String eines original Devices.

"HMID, maxRetries und timeOut" sollten selbsterklärend sein...

Ganz unten gibt es noch den Teil für First load. Das ist eigentlich nur zum testen, da ich nicht bei jeder Änderung Lust hatte, das Device neu zu konfigurieren.
Hier passiert also nichts anderes als das setzen von diversen Config Variablen. Geschrieben werden die Werte nur wenn
#define firstLoad; auskommentiert ist.

Das sind Parameter die ihr nicht verändern dürft.
static s_regs reg;
*regPtr = (uint16_t)®
*peerPtr = (uint16_t)&peerdb;

Diese Parameter gehören zum ch_0, also der Device Ebene und werden wie folgt gesetzt:
reg.ch_0.intKeyVisib = 0;
reg.ch_0.pairCentral[0] = 0x63;
reg.ch_0.pairCentral[1] = 0x19;
reg.ch_0.pairCentral[2] = 0x63;

Genauso kann man auch peers per Hand setzen. Die Byte Reihenfolge ist aber umgedreht, da hier eine Konversation von Byte Array nach Long statt findet.
Der erste Klammerwert ist der Kanal, der zewite die Reihenfolge innerhalb des Kanals...
peerdb[0][0] = 0x01086622;
peerdb[1][0] = 0x02086622;

So, das war es jetzt mal fürs erste...

Ach ja, der Github ist zu finden unter: https://github.com/trilu2000/AskSin

[trilu]

@Dirk - Entschuldige, ganz übersehen...

Die Buttonauswertung funktioniert noch nicht 100%ig.
Wenn man z.B. die Longpesszeit auf 1s einstellt, funktioniert Longpress nicht mehr.
Das würde ich mir heute aber mal ansehen.
Ich würde gerne auch einbauen dass man auch durch 1-fach-, 2-fach-, 3-fach-Tastendruck je einen unterschiedlichen Kanal auslösen kann.
Dafür würde ich BK::config so erweitern, dass an den Callback die Anzahl der "Doppelklickts" mit übergeben werden.
Dann kann man das weitere in buttonState machen. Oder hast du da einen anderen Vorschlag?

Ich bin so ganz hin und her gerissen, einerseits gefällt mir die Idee sehr gut, auf der anderen Seite gibt es ja von HM so eine Tastensperre. Also man muss 2 mal kurz drücken
um einen short key press zu bekommen.

Ich wollte die config der BK Class schon mal aufsplitten, bin nur noch nicht dazu gekommen. Sie sollte ähnlich der Relay Class werden.
Einmal ein config für die Funktionalität
und ein setCallBack für die Funktions Pointer

Wenn du ein Flag bei der config mit einbaust, ala multiPress und die Rückgabewerte definierst, sollte es kompatibel bleiben...


Mal eine Frage an alle Arduino Wissenden
Derzeit besteht ja das Framework aus drei Teilen. Einmal der Mainsketch, dann die Register.h und dann die Lib
Wenn ich jetzt die Lib in das library Verzeichnis von Arduino packen will und die Gerätschaften als Example, dann soll ja die Register.h mit in den Example Ordner.
Blöderweise referenziert aber die AskSin.h auch auf die Register.h und findet sie dann nicht mehr, da sie ja im Example Ordner liegt.
Wisst ihr wie man das umgehen kann?

Viele Grüße
Horst

[jab]

Moin,

so ich habe die Funktionalität vom HM-LC-Sw1PBU-FM jetzt in einer ersten Version fertig bekommen. Das Perlscript hilft mir dabei erstmal nicht ganz so viel, da es den Aktor so ja nicht gibt. Ich habe jetzt erstmal ein neues Gerät erfunden in FHEM. Ich habe es remoteAndSwitch genannt. Ist noch nicht perfekt (alle Funktionen auf allen 3 Channels), aber erstmal funktioniert damit alles. Code ist im git. Den FHEM Patch schicke ich die Tage auch noch wenn er noch etwas gereift ist.


Gruß,
Jan

[Dirk]

auf der anderen Seite gibt es ja von HM so eine Tastensperre. Also man muss 2 mal kurz drücken
um einen short key press zu bekommen.

Ja, die nutze ich auch an meinen Schlüssel-FB's für die Keymatic.
Das ganze ließe sich auch entsprechend in Register ablegen und konfigurierbar machen wie sich der "Doppelklick" verhalten soll.
Aktuell will ich das für meine Taster verwenden (die derzeitige FS20-Version hat nur eine Taste aber 3 Kanäle). Und da ich hier derzeit dein HM-PB-6-WM55 Beispiel benutze, würde ich die "Doppelklickzeit" für den ersten Kanal "mißbrauchen".
Daher soll das nur optional in die BK-Klasse rein.

Ich habe jetzt mal einen GIT für die Library erstellt

Cool, da können wir ja langsam anfangen den Code zusammen zu bringen?
Konntest du dir den LED-Teil schon mal ansehen?

Hast du übrigens noch ein Paar CC1101-Module übrig? Für die Taster die ich grade baue reichen meine hier nicht.
Ansonsten würde ich noch mal eine Bestellung lostreten

Gruß
Dirk

[Dirk]

Noch was,

Beim langen Tastendruck werden normalerweise alle 250ms entsprechende Events an die Devices geschickt.
Aktuell sendest du die Dimm-Befehle auch abhängig der Longpress-Zeit. Das würde ich mir dann auch mit ansehen.
Soll ich die BK und LED-Klasse gleich auslagern wenn ich da einmal drann bin?

Gruß
Dirk

[jab]

Aktuell habe ich noch das Problem, dass wenn ich den Aktor per FHEM steuere (set on/off) dann bleibt FHEM auf set_on oder set_off. Dabei sieht das Funk fast genau so aus wie bei einem original Aktor:

AskSin:
0E 39 B0 11 1A B1 50 5F B7 4A 02 03 C8 00 00 (l:15)(6655901)
0E 39 80 02 5F B7 4A 1A B1 50 01 03 C8 00 00 (l:15)(6655924)

manchmal auch so:
0E 3B B0 11 1A B1 50 5F B7 4A 02 03 00 00 00 (l:15)(6798434)
0E 3B 80 02 5F B7 4A 1A B1 50 01 03 00 00 00 (l:15)(6798456)
0E 09 A4 10 5F B7 4A 1A B1 50 06 03 00 00 00 (l:15)(6799736)
0A 09 80 02 1A B1 50 5F B7 4A 00 (l:11)(6799878

beim original Aktor sieht es so aus:
0E 37 A0 11 1A B1 50 21 D6 3B 02 01 C8 00 00 (l:15)(6596712)
0E 37 80 02 21 D6 3B 1A B1 50 01 01 C8 00 18 (l:15)(6596837)

oder:
0E 3D A0 11 1A B1 50 21 D6 3B 02 01 00 00 00 (l:15)(7005079)
0E 3D 80 02 21 D6 3B 1A B1 50 01 01 00 00 14 (l:15)(7005204)


Irgendwelche Ideen was da noch nicht klappt?


Gruß,
Jan

[trilu]

@Dirk

Beim langen Tastendruck werden normalerweise alle 250ms entsprechende Events an die Devices geschickt.
Aktuell sendest du die Dimm-Befehle auch abhängig der Longpress-Zeit. Das würde ich mir dann auch mit ansehen.
Soll ich die BK und LED-Klasse gleich auslagern wenn ich da einmal drann bin?

Klar, bau um. Ich brauche nur noch eine Lösung um das Ding übersichtlich zu halten. In den Library Ordner von Arduino bekomme ich es momentan nicht, da
das mit der Referenz zur Register.h nicht klappt. Macht mich gerade wahnsinnig!!!

@Jan
sieht eigentlich gut aus, FHEM sendet einen Schaltbefehl für Ein (C8) an Channel 3
und das Device sendet einen ACK Status von Channel 3 zurück.

Code Auswählen Erweitern

AskSin:
0E 39 B0 11 1A B1 50 5F B7 4A 02 03 C8 00 00 (l:15)(6655901)
0E 39 80 02 5F B7 4A 1A B1 50 01 03 C8 00 00 (l:15)(6655924)


Der einzige Unterschied hier ist, das an Channel 1 gesendet wird
und die Antwort den RSSI enthält. Der ist aber nicht notwendig...

Code Auswählen Erweitern

beim original Aktor sieht es so aus:
0E 37 A0 11 1A B1 50 21 D6 3B 02 01 C8 00 00 (l:15)(6596712)
0E 37 80 02 21 D6 3B 1A B1 50 01 01 C8 00 18 (l:15)(6596837)


Ich tippe auf ein Problem in der Device Config von FHEM...

[Rohan]

Hallo Jan,

Aktuell habe ich noch das Problem, dass wenn ich den Aktor per FHEM steuere (set on/off) dann bleibt FHEM auf set_on oder set_off.

Da hat Martin Heute etwas nachgebessert => Link. Ging zwar um ein anderes Device, aber das gleiche Erscheinungsbild. Die "device on"-Message wurde nicht an Fhem übergeben zwecks Steuerung der Ausgabe bzw. kam nicht im Log an. Vlt. hilft das Update ja auch hier?!

Gruß
Thomas