Add old/new mqtt controllerHEADmaster

9 files changed, 776 insertions, 0 deletions

diff --git a/mqtt-controller/Makefile b/mqtt-controller/Makefile
new file mode 100644
index 0000000..c3efc35
--- /dev/null
+++ b/mqtt-controller/Makefile
@@ -0,0 +1,2 @@
+mqtt-controller: devices.go main.go mqtt.go status.go unified_switch.go
+        go build -o $@ $^
diff --git a/mqtt-controller/db/bridgeConfig b/mqtt-controller/db/bridgeConfig
new file mode 100644
index 0000000..db3afce
--- /dev/null
+++ b/mqtt-controller/db/bridgeConfig
@@ -0,0 +1,5 @@
+{
+    "Broker": "172.16.0.186:1883",
+    "BridgeName": "MQTT Bridge",
+    "Pin": "00102003"
+}
diff --git a/mqtt-controller/devices.go b/mqtt-controller/devices.go
new file mode 100644
index 0000000..9f11333
--- /dev/null
+++ b/mqtt-controller/devices.go
@@ -0,0 +1,280 @@
+package main
+
+import (
+        "encoding/json"
+        "fmt"
+        "log"
+        "strconv"
+        "strings"
+)
+
+type Direction int
+
+const (
+        DirectionInput Direction = iota
+        DirectionOutput
+)
+
+type Device interface {
+        Identity() string
+        Connect(*MQTTBroker, chan<- Event, chan<- Metric, chan<- interface{}) (<-chan Command, error)
+        OutputOn(int) error
+        OutputOff(int) error
+        Disconnect() error
+}
+
+type Command struct {
+        Index  int
+        Active bool
+}
+
+type Event struct {
+        Device    Device
+        Index     int
+        Active    bool
+        Direction Direction
+}
+
+type Metric struct {
+        Device Device
+        Name   string
+        Value  interface{}
+}
+
+type DeviceAnnounce struct {
+        ID                   string `json:"id"`
+        IP                   string `json:"ip"`
+        MacAddress           string `json:"mac"`
+        Model                string `json:"model"`
+        FirmwareVersion      string `json:"fw_ver"`
+        NewFirmwareAvailable bool   `json:"new_fw"`
+}
+
+func NewDevice(b *MQTTBroker, da DeviceAnnounce) (Device, error) {
+        switch da.Model {
+        case "SHSW-PM":
+                return NewShellyDevice(da, 1, 1), nil
+        case "SHSW-25":
+                return NewShellyDevice(da, 2, 2), nil
+        }
+        return nil, fmt.Errorf("Unknown device model %s", da.Model)
+}
+
+type ShellyDevice struct {
+        ID                   string
+        Manufacturer         string
+        IP                   string // TODO: Fix type
+        MacAddress           string // TODO: Fix type
+        Model                string // TODO: Fix type
+        FirmwareVersion      string // TODO: Fix type
+        NewFirmwareAvailable bool
+        broker               *MQTTBroker
+        inputCount           int
+        outputCount          int
+        connected            bool
+        inputState           []bool
+        outputState          []bool
+        subscribed           []string
+        events               chan<- Event
+        metrics              chan<- Metric
+        info                 chan<- interface{}
+        commands             chan Command
+}
+
+func NewShellyDevice(da DeviceAnnounce, inputCount, outputCount int) *ShellyDevice {
+        return &ShellyDevice{
+                Manufacturer:         "Shelly",
+                ID:                   da.ID,
+                IP:                   da.IP,
+                MacAddress:           da.MacAddress,
+                Model:                da.Model,
+                FirmwareVersion:      da.FirmwareVersion,
+                NewFirmwareAvailable: da.NewFirmwareAvailable,
+                inputCount:           inputCount,
+                outputCount:          outputCount,
+                inputState:           make([]bool, inputCount),
+                outputState:          make([]bool, outputCount),
+                connected:            false,
+                subscribed:           []string{},
+                commands:             make(chan Command, 100),
+        }
+}
+
+var _ Device = (*ShellyDevice)(nil)
+
+func (d *ShellyDevice) Identity() string {
+        return d.ID
+}
+
+func (d *ShellyDevice) handleOutputMessages(topic string, payload []byte) {
+        path := strings.Split(topic, "/")[2:]
+
+        switch path[0] {
+        case "info":
+                p := ShellyStatus{Device: d}
+                if err := json.Unmarshal(payload, &p); err != nil {
+                        log.Printf("Error parsing info packet: %s", err)
+                        return
+                }
+                d.info <- p
+        case "input":
+                idx, err := strconv.Atoi(path[1])
+                if err != nil {
+                        log.Println("Error parsing index")
+                        return
+                }
+                state := payload[0] == '0'
+                if d.inputState[idx] != state {
+                        d.events <- Event{
+                                Device:    d,
+                                Index:     idx,
+                                Active:    state,
+                                Direction: DirectionInput,
+                        }
+                        d.inputState[idx] = state
+                }
+        case "relay":
+                idx, err := strconv.Atoi(path[1])
+                if err != nil {
+                        log.Println("Error parsing index")
+                        return
+                }
+                if len(path) == 2 {
+                        state := string(payload) == "on"
+                        if d.outputState[idx] != state {
+                                d.events <- Event{
+                                        Device:    d,
+                                        Index:     idx,
+                                        Active:    state,
+                                        Direction: DirectionOutput,
+                                }
+                                d.outputState[idx] = state
+                        }
+                } else {
+                        switch path[2] {
+                        case "power":
+                                m, err := strconv.ParseFloat(string(payload), 16)
+                                if err != nil {
+                                        log.Printf("Failed to parse metric")
+                                        return
+                                }
+                                d.metrics <- Metric{
+                                        Device: d,
+                                        Name:   fmt.Sprintf("relay_%d_power", idx),
+                                        Value:  m,
+                                }
+                        case "energy":
+                                m, err := strconv.ParseInt(string(payload), 10, 32)
+                                if err != nil {
+                                        log.Printf("Failed to parse metric")
+                                        return
+                                }
+                                d.metrics <- Metric{
+                                        Device: d,
+                                        Name:   fmt.Sprintf("relay_%d_energy", idx),
+                                        Value:  m,
+                                }
+                        case "overpower_value":
+                                m, err := strconv.ParseInt(string(payload), 10, 32)
+                                if err != nil {
+                                        log.Printf("Failed to parse metric")
+                                        return
+                                }
+                                d.metrics <- Metric{
+                                        Device: d,
+                                        Name:   fmt.Sprintf("relay_%d_overpower_value", idx),
+                                        Value:  m,
+                                }
+                        }
+                }
+        case "temperature":
+                m, err := strconv.ParseFloat(string(payload), 16)
+                if err != nil {
+                        log.Printf("Failed to parse metric")
+                        return
+                }
+                d.metrics <- Metric{
+                        Device: d,
+                        Name:   "temperature_c",
+                        Value:  m,
+                }
+        case "overtemperature":
+                d.metrics <- Metric{
+                        Device: d,
+                        Name:   "is_overtemperature",
+                        Value:  payload[0] == '1',
+                }
+        }
+}
+
+func (d *ShellyDevice) OutputOn(idx int) error {
+        if idx < 0 || idx >= d.outputCount {
+                return fmt.Errorf("Index is out of range for device")
+        }
+        if d.broker == nil {
+                return fmt.Errorf("Device is not connected to broker")
+        }
+
+        return d.broker.Publish(fmt.Sprintf("shellies/%s/relay/%d/command", d.Identity(), idx), "on")
+}
+
+func (d *ShellyDevice) OutputOff(idx int) error {
+        if idx < 0 || idx >= d.outputCount {
+                return fmt.Errorf("Index is out of range for device")
+        }
+        if d.broker == nil {
+                return fmt.Errorf("Device is not connected to broker")
+        }
+
+        return d.broker.Publish(fmt.Sprintf("shellies/%s/relay/%d/command", d.Identity(), idx), "off")
+}
+
+func (d *ShellyDevice) Connect(b *MQTTBroker, events chan<- Event, metrics chan<- Metric, info chan<- interface{}) (<-chan Command, error) {
+        d.broker = b
+        d.events = events
+        d.metrics = metrics
+        d.info = info
+
+        outputs := []string{
+                "shellies/{ID}/info",
+                "shellies/{ID}/temperature",
+                "shellies/{ID}/overtemperature",
+        }
+
+        for i := d.inputCount - 1; i >= 0; i-- {
+                outputs = append(outputs, fmt.Sprintf("shellies/{ID}/input/%d", i))
+                outputs = append(outputs, fmt.Sprintf("shellies/{ID}/longpush/%d", i))
+        }
+
+        for i := d.outputCount - 1; i >= 0; i-- {
+                outputs = append(outputs, fmt.Sprintf("shellies/{ID}/relay/%d", i))
+                outputs = append(outputs, fmt.Sprintf("shellies/{ID}/relay/%d/power", i))
+                outputs = append(outputs, fmt.Sprintf("shellies/{ID}/relay/%d/energy", i))
+                outputs = append(outputs, fmt.Sprintf("shellies/{ID}/relay/%d/overpower_value", i))
+        }
+
+        // TODO: Handle these
+        inputs := []string{
+                "",
+        }
+        _ = inputs
+
+        for _, topic := range outputs {
+                tn := strings.Replace(topic, "{ID}", d.ID, 1)
+                if err := b.Subscribe(tn, d.handleOutputMessages); err != nil {
+                        return nil, err
+                }
+                d.subscribed = append(d.subscribed, tn)
+        }
+
+        d.connected = true
+
+        return d.commands, nil
+}
+
+func (d *ShellyDevice) Disconnect() error {
+        if !d.connected {
+                return fmt.Errorf("Device not connected, can not disconnect")
+        }
+        return nil
+}
diff --git a/mqtt-controller/go.mod b/mqtt-controller/go.mod
new file mode 100644
index 0000000..128b792
--- /dev/null
+++ b/mqtt-controller/go.mod
@@ -0,0 +1,8 @@
+module golang.crute.me/mfi_homekit
+
+go 1.15
+
+require (
+        github.com/brutella/hc v1.2.3
+        github.com/eclipse/paho.mqtt.golang v1.3.0
+)
diff --git a/mqtt-controller/go.sum b/mqtt-controller/go.sum
new file mode 100644
index 0000000..88cfc14
--- /dev/null
+++ b/mqtt-controller/go.sum
@@ -0,0 +1,38 @@
+github.com/brutella/dnssd v1.1.1 h1:Ar5ytE2Z9x5DTmuNnASlMTBpcQWQLm9ceHb326s0ykg=
+github.com/brutella/dnssd v1.1.1/go.mod h1:9gIcMKQSJvYlO2x+HR50cqqjghb9IWK9hvykmyveVVs=
+github.com/brutella/hc v1.2.3 h1:9a3h61apXx+63b1T+W1vscs+G3xZkLS131gypnh1FIE=
+github.com/brutella/hc v1.2.3/go.mod h1:zknCv+aeiYM27tBXr3WFL49C8UPHMxP2IVY9c5TpMOY=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/eclipse/paho.mqtt.golang v1.3.0 h1:MU79lqr3FKNKbSrGN7d7bNYqh8MwWW7Zcx0iG+VIw9I=
+github.com/eclipse/paho.mqtt.golang v1.3.0/go.mod h1:eTzb4gxwwyWpqBUHGQZ4ABAV7+Jgm1PklsYT/eo8Hcc=
+github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/miekg/dns v1.1.1/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/miekg/dns v1.1.4 h1:rCMZsU2ScVSYcAsOXgmC6+AKOK+6pmQTOcw03nfwYV0=
+github.com/miekg/dns v1.1.4/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/tadglines/go-pkgs v0.0.0-20140924210655-1f86682992f1 h1:ms/IQpkxq+t7hWpgKqCE5KjAUQWC24mqBrnL566SWgE=
+github.com/tadglines/go-pkgs v0.0.0-20140924210655-1f86682992f1/go.mod h1:roo6cZ/uqpwKMuvPG0YmzI5+AmUiMWfjCBZpGXqbTxE=
+github.com/xiam/to v0.0.0-20191116183551-8328998fc0ed h1:Gjnw8buhv4V8qXaHtAWPnKXNpCNx62heQpjO8lOY0/M=
+github.com/xiam/to v0.0.0-20191116183551-8328998fc0ed/go.mod h1:cqbG7phSzrbdg3aj+Kn63bpVruzwDZi58CpxlZkjwzw=
+golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0 h1:Jcxah/M+oLZ/R4/z5RzfPzGbPXnVDPkEDtf2JnuxN+U=
+golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20181206074257-70b957f3b65e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/mqtt-controller/main.go b/mqtt-controller/main.go
new file mode 100644
index 0000000..29d5d28
--- /dev/null
+++ b/mqtt-controller/main.go
@@ -0,0 +1,146 @@
+package main
+
+import (
+        "encoding/json"
+        "log"
+        "os"
+        "os/signal"
+        "sync"
+        "syscall"
+        "time"
+
+        "github.com/brutella/hc"
+        "github.com/brutella/hc/accessory"
+        "github.com/brutella/hc/util"
+)
+
+type AppConfig struct {
+        Broker     string
+        BridgeName string
+        Pin        string
+}
+
+func loadAppConfig(s util.Storage) (*AppConfig, error) {
+        d, err := s.Get("bridgeConfig")
+        if err != nil {
+                return nil, err
+        }
+
+        c := &AppConfig{}
+        if err = json.Unmarshal(d, c); err != nil {
+                return nil, err
+        }
+
+        return c, nil
+}
+
+func main() {
+        wg := &sync.WaitGroup{}
+        done := make(chan interface{})
+
+        c := make(chan os.Signal)
+        signal.Notify(c, os.Interrupt)
+        signal.Notify(c, os.Kill)
+        signal.Notify(c, syscall.SIGTERM)
+
+        storage, err := util.NewFileStorage("db")
+        if err != nil {
+                panic(err)
+        }
+
+        cfg, err := loadAppConfig(storage)
+        if err != nil {
+                panic(err)
+        }
+
+        broker, err := NewMQTTBroker(cfg.Broker)
+        if err != nil {
+                panic(err)
+        }
+
+        if err := broker.Subscribe("shellies/announce", nil); err != nil {
+                panic(err)
+        }
+
+        if err := broker.Publish("shellies/command", "announce"); err != nil {
+                panic(err)
+        }
+
+        ac := make(chan *UnifiedSwitch, 10)
+
+        go func() {
+                wg.Add(1)
+                defer wg.Done()
+
+                log.Println("Starting homekit thread")
+
+                reg := []*accessory.Accessory{}
+
+                // Collect devices until the discovery process quiesces, then start the
+                // transport
+                quiescence := 10 * time.Second
+                t := time.NewTimer(quiescence)
+
+        C:
+                for {
+                        select {
+                        case a := <-ac:
+                                log.Println("Homekit: new device")
+                                reg = append(reg, a.HomeKitSwitch.Accessory)
+                                // TODO: Extend timer deadline
+                        case <-t.C:
+                                log.Println("Homekit: timeout over")
+                                t.Stop()
+                                break C
+                        case <-done:
+                                log.Println("Homekit: cancelled")
+                                return
+                        }
+                }
+
+                log.Println("MQTT quiesces, starting HomeKit")
+
+                br := accessory.NewBridge(accessory.Info{Name: cfg.BridgeName})
+
+                transport, err := hc.NewIPTransport(hc.Config{Pin: cfg.Pin}, br.Accessory, reg...)
+                if err != nil {
+                        log.Fatalf("%s", err)
+                }
+                go transport.Start()
+                log.Printf("HomeKit transport started")
+
+                select {
+                case <-done:
+                        log.Printf("Shutting down transport")
+                        if transport != nil {
+                                <-transport.Stop()
+                        }
+                }
+                log.Printf("Transport shut down")
+        }()
+
+        for {
+                select {
+                case d := <-broker.Devices:
+                        if d == nil {
+                                continue
+                        }
+
+                        us, err := NewUnifiedSwitch(broker, d)
+                        if err != nil {
+                                log.Printf("Error connecting device: %e", err)
+                                continue
+                        }
+
+                        go us.MessageLoop(done, wg)
+
+                        ac <- us
+                        log.Printf("New Device: %s\n", d.Identity())
+                case <-c:
+                        close(done)
+                        broker.Shutdown()
+                        wg.Wait()
+                        return
+                }
+        }
+}
diff --git a/mqtt-controller/mqtt.go b/mqtt-controller/mqtt.go
new file mode 100644
index 0000000..0b2687c
--- /dev/null
+++ b/mqtt-controller/mqtt.go
@@ -0,0 +1,93 @@
+package main
+
+import (
+        "encoding/json"
+        "log"
+
+        "github.com/eclipse/paho.mqtt.golang"
+)
+
+type MessageHandler func(topic string, payload []byte)
+
+func mqttSync(t mqtt.Token) error {
+        if t.Wait() && t.Error() != nil {
+                return t.Error()
+        }
+        return nil
+}
+
+type MQTTBroker struct {
+        Devices  chan Device
+        messages chan mqtt.Message
+        done     chan bool
+
+        client mqtt.Client
+}
+
+func NewMQTTBroker(broker string) (*MQTTBroker, error) {
+        bufferSize := 100
+
+        b := &MQTTBroker{
+                Devices:  make(chan Device, bufferSize),
+                messages: make(chan mqtt.Message, bufferSize),
+                done:     make(chan bool),
+        }
+
+        b.client = mqtt.NewClient(
+                mqtt.NewClientOptions().
+                        AddBroker(broker).
+                        SetDefaultPublishHandler(b.handleMessage).
+                        SetClientID("homekit-controller"))
+
+        if err := mqttSync(b.client.Connect()); err != nil {
+                return nil, err
+        }
+
+        return b, nil
+}
+
+func (b *MQTTBroker) Subscribe(topic string, h MessageHandler) error {
+        var handler mqtt.MessageHandler
+        if h != nil {
+                handler = func(c mqtt.Client, m mqtt.Message) {
+                        h(m.Topic(), m.Payload())
+                }
+        }
+
+        if err := mqttSync(b.client.Subscribe(topic, 0, handler)); err != nil {
+                return err
+        }
+
+        return nil
+}
+
+func (b *MQTTBroker) Publish(topic string, msg interface{}) error {
+        if err := mqttSync(b.client.Publish(topic, 0, false, msg)); err != nil {
+                return err
+        }
+        return nil
+}
+
+// Runs synchronously in the mqtt client comms handler goroutine
+func (b *MQTTBroker) handleMessage(c mqtt.Client, m mqtt.Message) {
+        switch m.Topic() {
+        case "shellies/announce", "ubiquiti/announce":
+                a := DeviceAnnounce{}
+                if err := json.Unmarshal(m.Payload(), &a); err != nil {
+                        log.Printf("Unable to unmarshal device announce JSON: %e", err)
+                        return
+                }
+
+                d, err := NewDevice(b, a)
+                if err != nil {
+                        log.Printf("Error creating device driver: %e", err)
+                        return
+                }
+
+                b.Devices <- d
+        }
+}
+
+func (b *MQTTBroker) Shutdown() {
+        b.client.Disconnect(250)
+}
diff --git a/mqtt-controller/status.go b/mqtt-controller/status.go
new file mode 100644
index 0000000..f469256
--- /dev/null
+++ b/mqtt-controller/status.go
@@ -0,0 +1,80 @@
+package main
+
+/*
+shellies/announce <- coming online announcements
+shellies/<deviceid>/info <- status endpoint
+
+shellies/command -> publish to address all (announce, update, update_fw)
+shellies/<deviceid>/command -> publish to address one
+
+<i> is zero based
+
+    shellies/<deviceid>/relay/<i>/command (input: on, off, toggle)
+
+    shellies/<deviceid>/input/<i> (output: 0, 1)
+    shellies/<deviceid>/longpush/<i> (output: 0 short, 1 long)
+    shellies/<deviceid>/temperature (float, device temp in C)
+    shellies/<deviceid>/overtemperature (int, 1 if overtemp, 0 otherwise)
+    shellies/<deviceid>/relay/<i> (output: on, off, overpower)
+    shellies/<deviceid>/relay/<i>/power (float, instantaneous power in watts)
+    shellies/<deviceid>/relay/<i>/energy (int, watt-minute counter)
+    shellies/<deviceid>/relay/<i>/overpower_value (power in watts where overpower occurred)
+*/
+
+type ShellyInput struct {
+        Event        string `json:"event"` // L=Long Press, S=Short Press, =None/Invalid
+        EventCount   int    `json:"event_cnt"`
+        CurrentState int    `json:"input"`
+}
+
+type ShellyMeter struct {
+        EnergyCounters []float32 `json:"counters"` // Last 3 round minutes in watt-minute
+        Valid          bool      `json:"is_valid"`
+        Overpower      float32   `json:"overpower"` // Value in Watts, on which an overpower condition is detected
+        Timestamp      int       `json:"timestamp"` // Last counter value reading time
+        Total          int       `json:"total"`     // Total watt-minutes consumed
+}
+
+type ShellyRelay struct {
+        HasTimer        bool   `json:"has_timer"`
+        IsValid         bool   `json:"is_valid"`
+        IsOn            bool   `json:"ison"`
+        Overpower       bool   `json:"overpower"`
+        OverTemperature bool   `json:"overtemperature"`
+        Source          string `json:"source"`
+        TimerDuration   int    `json:"timer_duration"`
+        TimerRemaining  int    `json:"timer_remaining"`
+        TimerStarted    int    `json:"timer_started"` // Unix timestamp of start
+}
+
+type ShellyStatus struct {
+        Device            Device
+        ConfigChangeCount int `json:"cfg_changed_cnt"`
+        Cloud             struct {
+                Connected bool `json:"connected"`
+                Enabled   bool `json:"enabled"`
+        } `json:"cloud"`
+        MQTT struct {
+                Connected bool `json:"connected"`
+        } `json:"mqtt"`
+        FilesystemFreeBytes int     `json:"fs_free"`
+        FilesystemSizeBytes int     `json:"fs_size"`
+        RAMFreeBytes        int     `json:"ram_free"`
+        RAMSizeBytes        int     `json:"ram_total"`
+        HasUpdate           bool    `json:"has_update"`
+        MacAddress          string  `json:"mac"`
+        OverTemperature     bool    `json:"overtemperature"`
+        TemperatureC        float32 `json:"temperature"`
+        TemperatureStatus   string  `json:"temperature_status"`
+        Uptime              int     `json:"uptime"`
+        Voltage             float32 `json:"voltage"`
+        WifiClient          struct {
+                Connected bool   `json:"connected"`
+                IP        string `json:"ip"`
+                RSSI      int    `json:"rssi"`
+                SSID      string `json:"ssid"`
+        } `json:"wifi_sta"`
+        Inputs []ShellyInput `json:"inputs"`
+        Meters []ShellyMeter `json:"meters"`
+        Relays []ShellyRelay `json:"relays"`
+}
diff --git a/mqtt-controller/unified_switch.go b/mqtt-controller/unified_switch.go
new file mode 100644
index 0000000..fb62c7a
--- /dev/null
+++ b/mqtt-controller/unified_switch.go
@@ -0,0 +1,124 @@
+package main
+
+import (
+        "hash/crc64"
+        "log"
+        "sync"
+
+        "github.com/brutella/hc/accessory"
+)
+
+type UnifiedSwitch struct {
+        HomeKitSwitch *accessory.Switch
+        MqttDevice    Device
+        Commands      <-chan Command
+        metrics       chan Metric
+        events        chan Event
+        infos         chan interface{}
+}
+
+func NewUnifiedSwitch(b *MQTTBroker, d Device) (*UnifiedSwitch, error) {
+        us := &UnifiedSwitch{
+                MqttDevice: d,
+                metrics:    make(chan Metric, 100),
+                events:     make(chan Event, 100),
+                infos:      make(chan interface{}, 100),
+        }
+
+        cmd, err := d.Connect(b, us.events, us.metrics, us.infos)
+        if err != nil {
+                log.Printf("Error connecting device: %e", err)
+                return nil, err
+        }
+
+        us.Commands = cmd
+        us.makeHomekitSwitch()
+
+        return us, nil
+}
+
+func (s *UnifiedSwitch) MessageLoop(done <-chan interface{}, wg *sync.WaitGroup) {
+        wg.Add(1)
+        defer wg.Done()
+
+        log.Printf("Starting switch %s", s.MqttDevice.Identity())
+
+C:
+        for {
+                select {
+                case e := <-s.events:
+                        direction := "output"
+                        if e.Direction == DirectionInput {
+                                direction = "input"
+                        }
+
+                        s.HomeKitSwitch.Switch.On.SetValue(e.Active)
+
+                        log.Printf("New event for '%s'.%d %s: %t", e.Device.Identity(), e.Index, direction, e.Active)
+                case m := <-s.metrics:
+                        /*
+                                switch t := m.Value.(type) {
+                                case float64:
+                                        log.Printf("New metric '%s' for '%s': %#v", m.Name, m.Device.Identity(), t)
+                                case int64:
+                                        log.Printf("New metric '%s' for '%s': %#v", m.Name, m.Device.Identity(), t)
+                                case bool:
+                                        log.Printf("New metric '%s' for '%s': %#v", m.Name, m.Device.Identity(), t)
+                                default:
+                                        log.Printf("Unknown metric: %#v", m.Value)
+                                }
+                        */
+                        _ = m
+                case i := <-s.infos:
+                        switch it := i.(type) {
+                        case ShellyStatus:
+                                // TODO: Handle multiple relays
+                                log.Printf("Info relays: %#v", it.Relays)
+                                s.HomeKitSwitch.Switch.On.SetValue(it.Relays[0].IsOn)
+                        default:
+                                // Just discard them for now
+                        }
+                case <-done:
+                        log.Printf("Shutting down switch %s", s.MqttDevice.Identity())
+                        break C
+                }
+        }
+
+        log.Printf("Switch %s shut down", s.MqttDevice.Identity())
+}
+
+func (s *UnifiedSwitch) HomeKitID() uint64 {
+        h64 := crc64.New(crc64.MakeTable(crc64.ISO))
+        h64.Write([]byte(s.MqttDevice.Identity()))
+        return h64.Sum64()
+}
+
+func (s *UnifiedSwitch) makeHomekitSwitch() {
+        // TODO: Get name from local DB?
+        switch dt := s.MqttDevice.(type) {
+        case *ShellyDevice:
+                s.HomeKitSwitch = accessory.NewSwitch(accessory.Info{
+                        ID:               s.HomeKitID(),
+                        Name:             s.MqttDevice.Identity(),
+                        Manufacturer:     dt.Manufacturer,
+                        Model:            dt.Model,
+                        FirmwareRevision: dt.FirmwareVersion,
+                })
+        default:
+                s.HomeKitSwitch = accessory.NewSwitch(accessory.Info{
+                        ID:   s.HomeKitID(),
+                        Name: s.MqttDevice.Identity(),
+                })
+        }
+        s.HomeKitSwitch.Switch.On.SetValue(false)
+        s.HomeKitSwitch.Switch.On.OnValueRemoteUpdate(s.HomeKitSetValue)
+}
+
+func (s *UnifiedSwitch) HomeKitSetValue(state bool) {
+        log.Printf("Client updated state: %t", state)
+        if state {
+                s.MqttDevice.OutputOn(0)
+        } else {
+                s.MqttDevice.OutputOff(0)
+        }
+}