Selbstbau HB-UNI-SenAct-8-8

[FEHMPiDi]

Hat hier noch jemand eine Idee was ich ausprobieren könnte um das Problem zu lösen. Oder könnte mal jemand probieren ob es bei ihm auf seinem System läuft?

Danke

[Tom Major]

Edit 20.11.2019:
Ich habe noch mal etwas rumgespielt. die Verzögerung ist nicht konstant. Es dauert mal länger und mal weniger lange. Es wird auch nicht schneller wenn ich das System entlaste und einige funktionen und devices auf disable stelle. Es ist also meiner Meinung nach nicht überlastet. Mir ist noch aufgefallen das der Befehl schneller ausgeführt wird wenn ich am Device den Conifbutton drücke. Auch wenn ich in Fhem mehrfach auf on und off drücke, werden alle Befehle hintereinander ausgeführt sobald ich den Configtaster am device drücke.

Das was du über die Conifbutton schreibst bringt mich auf die Idee zu fragen ob du
USE_BATTERY_MODE
aktiv hast oder nicht?
Weil im Batt.mode das Device ja im Sleep und nicht im Idle ist (und Burst nicht verwendet wird?)

[FEHMPiDi]

Nein, use_battery_mode hab ich nicht aktiviert

[FEHMPiDi]

Ich habe eher die Vermutung dass das Problem irgendwo in FHEM liegt. Es kommt ja laut log per Seriell monitor nichts am Device an. Kann man irgendwie rauskriegen wo fhem hängt. Logfiles habe ich ja hier schon mal hochgeladen. Ich konnte darin aber leider nichts erkennen

[papa]

Wie sieht denn der Sketch aus ? So kann ma da nicht viel sagen.

[FEHMPiDi]

Hi, den Sketch habe ich von hier: https://github.com/jp112sdl/HB-UNI-SenAct-8-8

er sieht so aus:

Code Auswählen Erweitern

//- -----------------------------------------------------------------------------------------------------------------------
// AskSin++
// 2016-10-31 papa Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/
// 2018-11-07 jp112sdl Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/
// special thanks to "klassisch" from homematic-forum.de
//- -----------------------------------------------------------------------------------------------------------------------

// define this to read the device id, serial and device type from bootloader section
// #define USE_OTA_BOOTLOADER
#define USE_WOR

#define EI_NOTEXTERNAL
#include <EnableInterrupt.h>
#include <AskSinPP.h>
#include <LowPower.h>
#include <actors/PCF8574.h>
#include <Switch.h>
#include <ThreeState.h>

//#define USE_BATTERY_MODE       // bei Batteriebetrieb
#define LOWBAT_VOLTAGE     22    // Batterie-Leermeldung bei Unterschreiten der Spannung von U * 10

#define PCF8574_ADDRESS 0x27
#define RELAY_PIN_1 0
#define RELAY_PIN_2 1
#define RELAY_PIN_3 2
#define RELAY_PIN_4 3
#define RELAY_PIN_5 4
#define RELAY_PIN_6 5
#define RELAY_PIN_7 6
#define RELAY_PIN_8 7
#define RELAY_ON_STATE_INVERT true

#define SENS_PIN_1 7
#define SENS_PIN_2 9
#define SENS_PIN_3 5
#define SENS_PIN_4 6
#define SENS_PIN_5 14
#define SENS_PIN_6 15
#define SENS_PIN_7 16
#define SENS_PIN_8 17
#define SABOTAGE_PIN_1    3

#define LED_PIN           4
#define CONFIG_BUTTON_PIN 8

// number of available peers per channel
//#define CREATE_INTERNAL_PEERINGS
#define PEERS_PER_SwitchChannel  3
#define PEERS_PER_SENSCHANNEL    3

#ifdef USE_BATTERY_MODE
#define battOp_ARGUMENT BatterySensor
#define DEV_MODEL 0x3b
#define CYCLETIME seconds2ticks(60UL * 60 * 12 * 0.88) // 60 seconds * 60 (= minutes) * 12 (=hours) * corrective factor
#else
#define battOp_ARGUMENT NoBattery
#define DEV_MODEL 0x3a
#define CYCLETIME seconds2ticks(60UL * 3 * 0.88)  // every 3 minutes
#endif

// all library classes are placed in the namespace 'as'
using namespace as;

// define all device properties
const struct DeviceInfo PROGMEM devinfo = {
  {0xf3, DEV_MODEL, 0x01},// Device ID
  "JPSENACT01",           // Device Serial
  {0xf3, DEV_MODEL},      // Device Model
  0x10,                   // Firmware Version
  as::DeviceType::Switch, // Device Type
  {0x01, 0x00}            // Info Bytes
};

/**
   Configure the used hardware
*/
typedef AvrSPI<10, 11, 12, 13> RadioSPI;
typedef AskSin<StatusLed<LED_PIN>, battOp_ARGUMENT, Radio<RadioSPI, 2> > Hal;
Hal hal;

DEFREGISTER(Reg0, MASTERID_REGS, DREG_INTKEY, DREG_CYCLICINFOMSG, DREG_SABOTAGEMSG)
class SwList0 : public RegList0<Reg0> {
  public:
    SwList0(uint16_t addr) : RegList0<Reg0>(addr) {}
    void defaults() {
      clear();
      intKeyVisible(true);
      sabotageMsg(true);
      cycleInfoMsg(true);
    }
};


DEFREGISTER(Reg1, CREG_AES_ACTIVE, CREG_MSGFORPOS, CREG_EVENTDELAYTIME, CREG_LEDONTIME, CREG_TRANSMITTRYMAX)
class SensList1 : public RegList1<Reg1> {
  public:
    SensList1 (uint16_t addr) : RegList1<Reg1>(addr) {}
    void defaults () {
      clear();
      msgForPosA(1);
      msgForPosB(2);
      aesActive(false);
      eventDelaytime(0);
      ledOntime(100);
      transmitTryMax(6);
    }
};

typedef SwitchChannel<Hal, PEERS_PER_SwitchChannel, SwList0, PCF8574Output<PCF8574_ADDRESS>>  SwChannel;
typedef ThreeStateChannel<Hal, SwList0, SensList1, DefList4, PEERS_PER_SENSCHANNEL> SensChannel;

class MixDevice : public ChannelDevice<Hal, VirtBaseChannel<Hal, SwList0>, 16, SwList0> {
    class CycleInfoAlarm : public Alarm {
        MixDevice& dev;
      public:
        CycleInfoAlarm (MixDevice& d) : Alarm (CYCLETIME), dev(d) {}
        virtual ~CycleInfoAlarm () {}

        void trigger (AlarmClock& clock)  {
          set(CYCLETIME);
          clock.add(*this);
          dev.switchChannel(1).changed(true);
        }
    } cycle;

  public:
    VirtChannel<Hal, SwChannel, SwList0>   swChannel1,   swChannel2,   swChannel3,   swChannel4, swChannel5,   swChannel6,   swChannel7,   swChannel8;
    VirtChannel<Hal, SensChannel, SwList0> sensChannel9, sensChannel10, sensChannel11, sensChannel12, sensChannel13, sensChannel14, sensChannel15, sensChannel16;
  public:
    typedef ChannelDevice<Hal, VirtBaseChannel<Hal, SwList0>, 16, SwList0> DeviceType;
    MixDevice (const DeviceInfo& info, uint16_t addr) : DeviceType(info, addr), cycle(*this) {
      DeviceType::registerChannel(swChannel1, 1);
      DeviceType::registerChannel(swChannel2, 2);
      DeviceType::registerChannel(swChannel3, 3);
      DeviceType::registerChannel(swChannel4, 4);
      DeviceType::registerChannel(swChannel5, 5);
      DeviceType::registerChannel(swChannel6, 6);
      DeviceType::registerChannel(swChannel7, 7);
      DeviceType::registerChannel(swChannel8, 8);

      DeviceType::registerChannel(sensChannel9, 9);
      DeviceType::registerChannel(sensChannel10, 10);
      DeviceType::registerChannel(sensChannel11, 11);
      DeviceType::registerChannel(sensChannel12, 12);
      DeviceType::registerChannel(sensChannel13, 13);
      DeviceType::registerChannel(sensChannel14, 14);
      DeviceType::registerChannel(sensChannel15, 15);
      DeviceType::registerChannel(sensChannel16, 16);
    }
    virtual ~MixDevice () {}


    SwChannel& switchChannel (uint8_t num)  {
      switch (num) {
        case 1:
          return swChannel1;
          break;
        case 2:
          return swChannel2;
          break;
        case 3:
          return swChannel3;
          break;
        case 4:
          return swChannel4;
          break;
        case 5:
          return swChannel5;
          break;
        case 6:
          return swChannel6;
          break;
        case 7:
          return swChannel7;
          break;
        case 8:
          return swChannel8;
          break;
        default:
          return swChannel1;
      }
    }

    SensChannel& sensorChannel (uint8_t num)  {
      switch (num) {
        case 9:
          return sensChannel9;
          break;
        case 10:
          return sensChannel10;
          break;
        case 11:
          return sensChannel11;
          break;
        case 12:
          return sensChannel12;
          break;
        case 13:
          return sensChannel13;
          break;
        case 14:
          return sensChannel14;
          break;
        case 15:
          return sensChannel15;
          break;
        case 16:
          return sensChannel16;
          break;
        default:
          return sensChannel9;
      }
    }

    virtual void configChanged () {
      if ( /*this->getSwList0().cycleInfoMsg() ==*/ true ) {
        DPRINTLN("Activate Cycle Msg");
        sysclock.cancel(cycle);
        cycle.set(CYCLETIME);
        sysclock.add(cycle);
      }
      else {
        DPRINTLN("Deactivate Cycle Msg");
        sysclock.cancel(cycle);
      }
    }
};
MixDevice sdev(devinfo, 0x20);
ConfigButton<MixDevice> cfgBtn(sdev);

void initPeerings (bool first) {
  // create internal peerings - CCU2 needs this
  if ( first == true ) {
#ifdef CREATE_INTERNAL_PEERINGS   
    HMID devid;
    sdev.getDeviceID(devid);
    for ( uint8_t i = 1; i <= 8; ++i ) {
      Peer ipeer(devid, i + 8);
      sdev.switchChannel(i).peer(ipeer);
    }
    for ( uint8_t i = 1; i <= 8; ++i ) {
      Peer ipeer(devid, i);
      sdev.sensorChannel(i + 8).peer(ipeer);
    }
#endif   
  }
}

void setup () {
  DINIT(57600, ASKSIN_PLUS_PLUS_IDENTIFIER);
  PCF8574Output<PCF8574_ADDRESS>::init();
  bool first = sdev.init(hal);
  sdev.switchChannel(1).init(RELAY_PIN_1, RELAY_ON_STATE_INVERT);
  sdev.switchChannel(2).init(RELAY_PIN_2, RELAY_ON_STATE_INVERT);
  sdev.switchChannel(3).init(RELAY_PIN_3, RELAY_ON_STATE_INVERT);
  sdev.switchChannel(4).init(RELAY_PIN_4, RELAY_ON_STATE_INVERT);
  sdev.switchChannel(5).init(RELAY_PIN_5, RELAY_ON_STATE_INVERT);
  sdev.switchChannel(6).init(RELAY_PIN_6, RELAY_ON_STATE_INVERT);
  sdev.switchChannel(7).init(RELAY_PIN_7, RELAY_ON_STATE_INVERT);
  sdev.switchChannel(8).init(RELAY_PIN_8, RELAY_ON_STATE_INVERT);

  const uint8_t posmap[4] = {Position::State::PosA, Position::State::PosB, Position::State::PosA, Position::State::PosB};
  sdev.sensorChannel(9).init(SENS_PIN_1, SENS_PIN_1, SABOTAGE_PIN_1, posmap);
  sdev.sensorChannel(10).init(SENS_PIN_2, SENS_PIN_2, SABOTAGE_PIN_1, posmap);
  sdev.sensorChannel(11).init(SENS_PIN_3, SENS_PIN_3, SABOTAGE_PIN_1, posmap);
  sdev.sensorChannel(12).init(SENS_PIN_4, SENS_PIN_4, SABOTAGE_PIN_1, posmap);
  sdev.sensorChannel(13).init(SENS_PIN_5, SENS_PIN_5, SABOTAGE_PIN_1, posmap);
  sdev.sensorChannel(14).init(SENS_PIN_6, SENS_PIN_6, SABOTAGE_PIN_1, posmap);
  sdev.sensorChannel(15).init(SENS_PIN_7, SENS_PIN_7, SABOTAGE_PIN_1, posmap);
  sdev.sensorChannel(16).init(SENS_PIN_8, SENS_PIN_8, SABOTAGE_PIN_1, posmap);

  buttonISR(cfgBtn, CONFIG_BUTTON_PIN);

  initPeerings(first);

#ifdef USE_BATTERY_MODE
  hal.activity.stayAwake(seconds2ticks(15));
  hal.battery.low(LOWBAT_VOLTAGE);
  // measure battery every 12 hours
  hal.battery.init(seconds2ticks(60UL * 60 * 12 * 0.88), sysclock);
#endif

  sdev.initDone();
}

void loop() {
  bool worked = hal.runready();
  bool poll = sdev.pollRadio();
  if ( worked == false && poll == false ) {
#ifdef USE_BATTERY_MODE
    hal.activity.savePower<Sleep<> >(hal);
#else
    hal.activity.savePower<Idle<> >(hal);
#endif
  }
}

Danke

[papa]

Du kannst ja mal versuchen, den PCF8574 rauszunehmen - also die Funktionen leer machen. Dann sehen wir, ob es daran liegt.

[FEHMPiDi]

Wie meinst du das?
Hardwaremäßig ausbauen, oder den sketch ändern? Wo müsste ich da was rausnehmen im Sketch?
Gruß

[papa]

Nur in der Software. Mal alle Methoden der Klasse leer machen.

[FEHMPiDi]

Hallo papa,

kannst Du bitte etwas konkreter werden. Welchen Code soll ich in welcher Klasse löschen?
Ich bin nicht so geübt im Programmieren. Ich kann mir bestehenden code zwar anpassen, aber ich verstehe den Code nicht 100%, noch nicht.
Könntest Du mir bitte die Klasse nennen die ich leeren sollte.

Danke

[Tom Major]

ich denke mal papa meint es so:
- in HB-UNI-SenAct-8-8-SC wird class PCF8574Output benutzt
- diese ist im file PCF8574.h in ....\libraries\AskSinPP\actors\ implementiert
- dort alle Methoden leer machen, also zB

Code Auswählen Erweitern


      static void writeWire(uint8_t buffer) {
          Wire.beginTransmission(ADDRESS);
          Wire.write(buffer);
          Wire.endTransmission();
      }

ändern in

Code Auswählen Erweitern


      static void writeWire(uint8_t buffer) {
          //Wire.beginTransmission(ADDRESS);
          //Wire.write(buffer);
          //Wire.endTransmission();
      }


Ich zähle dort 8 Methoden zum "Behandeln"  .
Damit ändert sich nichts direkt im sketch, nur der HW Zugriff auf den PCF8574 wird unterbunden.

[papa]

Genau - Danke

[FEHMPiDi]

Danke für die Erklärung. Das habe ich jetzt gemacht. Es ändert sich aber nichts am Verhalten. Ich verstehe auch nicht ganz was das helfen soll. Das Problem ist ja, das aus FHEM das Signal verspätet gesendet wird wenn ich den Kanal über fhem schalte. Es kommt also gar nichts beim Device selber an. Wenn etwas ankommen würde, würde ich das doch im Seriellen Monitor sehen, oder?
Und wenn der Befehl dann aus Fhem raus gesendet wird, funktioniert es ja einwandfrei. Das sehe ich dann auch im seriellen Monitor.

Oder mache ich hier einen Denkfehler?

Hier noch zur Kontrolle wie die PCF8574.h jetzt aussieht:

Code Auswählen Erweitern

//- -----------------------------------------------------------------------------------------------------------------------
// AskSin++
// 2018-11-01 papa Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/
// 2018-11-01 jp112sdl Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/
//- -----------------------------------------------------------------------------------------------------------------------

#ifndef __PCF8574Output_H__
#define __PCF8574Output_H__

#include <Arduino.h>
#include <Wire.h>

namespace as {

struct PCF8574Buffer { uint8_t data, mode; };

template <byte ADDRESS=0x38>
class PCF8574Output {
      static PCF8574Buffer& getBuffer();
  private:
      static void writeWire(uint8_t buffer) {
          //Wire.beginTransmission(ADDRESS);
          //Wire.write(buffer);
          //Wire.endTransmission();
      }
  public:
      inline static void setOutput   (uint8_t pin) {
          //getBuffer().mode |= bit(pin);
      }
      inline static void setInput    (uint8_t pin) {
          //getBuffer().mode &= ~bit(pin);
      }
      inline static void setHigh     (uint8_t pin) {
          //getBuffer().data |= bit(pin);
          //writeWire((getBuffer().data & getBuffer().mode));
      }
      inline static void setLow      (uint8_t pin) {
          //getBuffer().data &= ~bit(pin);
          //writeWire((getBuffer().data & getBuffer().mode));
      }
      inline static uint8_t getState (uint8_t pin) {
          //return ((getBuffer().data & bit(pin)) == 0) ? LOW : HIGH;
      }
      inline static void dump () {
        //DPRINT("Address: "); DHEX(ADDRESS);
        //DPRINT("   Mode: "); DHEX(getBuffer().mode);
        //DPRINT("   Data: "); DHEXLN(getBuffer().data);
      }
     
      inline static void init () {
      //Wire.begin();
      }
  };
 
  template<>
  inline PCF8574Buffer& PCF8574Output<0x20>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
  template<>
  inline PCF8574Buffer& PCF8574Output<0x21>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
  template<>
  inline PCF8574Buffer& PCF8574Output<0x22>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
  template<>
  inline PCF8574Buffer& PCF8574Output<0x23>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
  template<>
  inline PCF8574Buffer& PCF8574Output<0x24>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  } 
  template<>
  inline PCF8574Buffer& PCF8574Output<0x25>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  } 
  template<>
  inline PCF8574Buffer& PCF8574Output<0x26>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
  template<>
  inline PCF8574Buffer& PCF8574Output<0x27>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
 
  template<>
  inline PCF8574Buffer& PCF8574Output<0x38>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
  template<>
  inline PCF8574Buffer& PCF8574Output<0x39>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
  template<>
  inline PCF8574Buffer& PCF8574Output<0x3A>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
  template<>
  inline PCF8574Buffer& PCF8574Output<0x3B>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
  template<>
  inline PCF8574Buffer& PCF8574Output<0x3C>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  } 
  template<>
  inline PCF8574Buffer& PCF8574Output<0x3D>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  } 
  template<>
  inline PCF8574Buffer& PCF8574Output<0x3E>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
  template<>
  inline PCF8574Buffer& PCF8574Output<0x3F>::getBuffer () {
      static PCF8574Buffer b;
      return b;
  }
}

#endif

Noch eine allgemeine Frage zum Debug. In der PCF8574.h gibt es ja folgende Zeilen:

Code Auswählen Erweitern

inline static void dump () {
        DPRINT("Address: "); DHEX(ADDRESS);
        DPRINT("   Mode: "); DHEX(getBuffer().mode);
        DPRINT("   Data: "); DHEXLN(getBuffer().data);
      }
Wieso sehe ich die Ausgabe nicht im Seriellen Monitor? Muss man das Debugen noch irgendwo aktivieren?

[FEHMPiDi]

Hallo,

sorry das ich so hartnäckig bin und so viele und vielleicht auch doofe Fragen stelle. Ich denke aber immer noch das der Fehler eher bei Fhem liegt und nicht beim Sketch des Devices. Warum komme ich auf die Idee? Ich wiederhole mich vielleicht, aber es wird von Fhem kein Befehl an das Device gesendet wenn ich auf den On/Off Button klicke. Das lampensymbol zeigt zwar eine eingeschaltete Lampe, aber mit rotem Ausrufezeichen. Im seriellen Monitor am Device kommt auch keine Message an! Wenn man dann lange genug wartet kommt irgendwann die Message am Device an. Wenn diese ankommt, funktioniert das einschalten auch und das rote Ausrufezeichen in Fhem verschwindet. Ich denke also dass das senden aus Fhem heraus aus irgendeinem Grund verzögert wird. Ein Muster kann ich da aber nicht erkennen. Die Verzögerung ist völlig unregelmäßig. Manchmal geht es recht schnell, meistens dauert es aber sehr lange (einige Minuten). Im Log ist meiner Meinung nach nichts auffälliges zu finden. Den hatte ich hier auch schon mal gepostet. Da es ja ein neues Device für Fhem ist und das anscheinend noch niemand mit Fhem benutzt hat, hier noch eine Frage zum Code in der HMConfig_AskSinPPCustom den papa mir auf die Schnelle erstellt hat. Evtl. ist hier ja noch ein Bug drin?

Code Auswählen Erweitern

$HMConfig::culHmModel{"F33A"} = {name=>"HB-UNI-SenAct-8-8-SC",st=>'custom',cyc=>'',rxt=>'c:l',lst=>'1,3:1p.2p.3p.4p.5p.6p.7p.8p,4:9p.10p.11p.12p.13p.14p.15p.16p',chn=>"Sw:1:8,Sen:9:16"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC00"}{fwUpdate} = "<filename>";
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC01"} = $HMConfig::culHmSubTypeSets{"switch"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC02"} = $HMConfig::culHmSubTypeSets{"switch"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC03"} = $HMConfig::culHmSubTypeSets{"switch"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC04"} = $HMConfig::culHmSubTypeSets{"switch"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC05"} = $HMConfig::culHmSubTypeSets{"switch"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC06"} = $HMConfig::culHmSubTypeSets{"switch"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC07"} = $HMConfig::culHmSubTypeSets{"switch"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC08"} = $HMConfig::culHmSubTypeSets{"switch"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC09"} = $HMConfig::culHmSubTypeSets{"THSensor"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC10"} = $HMConfig::culHmSubTypeSets{"THSensor"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC11"} = $HMConfig::culHmSubTypeSets{"THSensor"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC12"} = $HMConfig::culHmSubTypeSets{"THSensor"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC13"} = $HMConfig::culHmSubTypeSets{"THSensor"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC14"} = $HMConfig::culHmSubTypeSets{"THSensor"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC15"} = $HMConfig::culHmSubTypeSets{"THSensor"};
$HMConfig::culHmChanSets{"HB-UNI-SenAct-8-8-SC16"} = $HMConfig::culHmSubTypeSets{"THSensor"};
$HMConfig::culHmRegModel{"HB-UNI-SenAct-8-8-SC"}   = { intKeyVisib=>1, cyclicInfoMsg=>1, sabotageMsg=>1 };
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC01"} = $HMConfig::culHmRegType{switch};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC02"} = $HMConfig::culHmRegType{switch};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC03"} = $HMConfig::culHmRegType{switch};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC04"} = $HMConfig::culHmRegType{switch};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC05"} = $HMConfig::culHmRegType{switch};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC06"} = $HMConfig::culHmRegType{switch};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC07"} = $HMConfig::culHmRegType{switch};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC08"} = $HMConfig::culHmRegType{switch};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC09"} = $HMConfig::culHmRegType{threeStateSensor};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC10"} = $HMConfig::culHmRegType{threeStateSensor};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC11"} = $HMConfig::culHmRegType{threeStateSensor};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC12"} = $HMConfig::culHmRegType{threeStateSensor};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC13"} = $HMConfig::culHmRegType{threeStateSensor};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC14"} = $HMConfig::culHmRegType{threeStateSensor};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC15"} = $HMConfig::culHmRegType{threeStateSensor};
$HMConfig::culHmRegChan {"HB-UNI-SenAct-8-8-SC16"} = $HMConfig::culHmRegType{threeStateSensor};
$customMsg{"HB-UNI-SenAct-8-8-SC"} = sub {
  my ($msg,$target) = @_;
  my $channel = $msg->channel;
  return $msg->processThreeState($target) if $channel > 8;
  return $msg->processSwitchStatus($target) if $msg->isStatus;
  return ();
};

Generell die Frage. Was passiert denn in Fhem überhaupt wenn ich auf den On/Off Button drücke. Woher weiß fhem welches SIgnal es senden muss? Steht das in der HMMsg.pm? Ist da evtl. noch ein Bug?

Danke für Eure Hilfe