From 7406a2500370c34a0f8a80d7970a381b33518e4c Mon Sep 17 00:00:00 2001 From: Gisle Aune Date: Sun, 23 May 2021 13:57:31 +0200 Subject: [PATCH] =?UTF-8?q?=C4=A7=E2=82=AC=C2=BB=C2=AA=C5=8B=C5=93n=C3=9F?= =?UTF-8?q?=C2=A0=C2=AA=C2=AE=E2=82=AC=C2=A0=C3=BE=C4=A7=E2=82=AC=C2=A0?= =?UTF-8?q?=E2=80=9D=E2=82=AC=C3=9F=C3=BE=C2=AA=C5=8B=C5=93n=C3=9F.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cmd/bridgetest/main.go | 157 +++++++++++ go.mod | 4 +- go.sum | 25 +- internal/drivers/nanoleaf/bridge.go | 411 ++++++++++++++++++++++++++++ internal/drivers/nanoleaf/data.go | 150 ++++++++++ internal/drivers/nanoleaf/driver.go | 162 +++++++++++ internal/drivers/nanoleaf/panel.go | 68 +++++ models/colorvalue.go | 34 +-- models/device.go | 6 +- models/driver.go | 3 +- models/errors.go | 5 + models/eventhandler.go | 4 +- 12 files changed, 982 insertions(+), 47 deletions(-) create mode 100644 cmd/bridgetest/main.go create mode 100644 internal/drivers/nanoleaf/bridge.go create mode 100644 internal/drivers/nanoleaf/data.go create mode 100644 internal/drivers/nanoleaf/driver.go create mode 100644 internal/drivers/nanoleaf/panel.go diff --git a/cmd/bridgetest/main.go b/cmd/bridgetest/main.go new file mode 100644 index 0000000..c1b2ec8 --- /dev/null +++ b/cmd/bridgetest/main.go @@ -0,0 +1,157 @@ +package main + +import ( + "bufio" + "context" + "flag" + "fmt" + "git.aiterp.net/lucifer/new-server/internal/drivers/nanoleaf" + "git.aiterp.net/lucifer/new-server/models" + "log" + "os" + "sort" + "strconv" + "strings" + "time" +) + +var flagDriver = flag.String("driver", "Nanoleaf", "The bridge driver to use") +var flagAddress = flag.String("address", "127.0.0.1", "The bridge's address") +var flagToken = flag.String("token", "", "The bridge's access token / api key / login") +var flagPair = flag.Bool("pair", false, "Try to pair with the bridge.") +var flagSearch = flag.Bool("search", false, "Search for devices first.") +var flagSearchTimeout = flag.Duration("search-timeout", time.Second*3, "Timeout for device search.") + +func main() { + flag.Parse() + + // TODO: Select driver + driver := nanoleaf.Driver{} + + // Find bridge + bridges, err := driver.SearchBridge(context.Background(), *flagAddress, !*flagPair) + if err != nil { + log.Fatalln("Failed to search bridge:", err) + } + if len(bridges) == 0 { + log.Fatalln("No bridges found") + } + bridge := bridges[0] + if !*flagPair { + bridge.Token = *flagToken + } else { + log.Println("New token:", bridge.Token) + } + + // List devices + var devices []models.Device + if *flagSearch { + devices, err = driver.SearchDevices(context.Background(), bridge, *flagSearchTimeout) + if err != nil { + log.Fatalln("Failed to search devices:", err) + } + } else { + devices, err = driver.ListDevices(context.Background(), bridge) + if err != nil { + log.Fatalln("Failed to list devices:", err) + } + } + for i := range devices { + devices[i].ID = i + 1 + } + + _ = driver.Publish(context.Background(), bridge, devices) + + ch := make(chan models.Event) + go func() { + err := driver.Run(context.Background(), bridge, ch) + if err != nil { + log.Fatalln("Run bridge stopped:", err) + } + }() + + go func() { + reader := bufio.NewReader(os.Stdin) + + _, _ = fmt.Fprintln(os.Stderr, "Format: [id1,id2,...] [on|off] [color] [intensity]") + for _, device := range devices { + _, _ = fmt.Fprintf(os.Stderr, "Device: %d - %s %+v\n", device.ID, device.InternalID, device.Capabilities) + } + _, _ = fmt.Fprintln(os.Stderr, "Format: [id1,id2,...] [on|off] [color]") + + for { + text, _ := reader.ReadString('\n') + text = strings.Trim(text, "\t  \r\n") + + tokens := strings.Split(text, " ") + if len(tokens) < 4 { + continue + } + + color, err := models.ParseColorValue(tokens[2]) + if err != nil { + _, _ = fmt.Fprintln(os.Stderr, "Invalid color:", err) + continue + } + + intensity, _ := strconv.ParseFloat(tokens[3], 64) + + power := strings.ToLower(tokens[1]) == "on" + + idsStr := strings.Split(tokens[0], ",") + ids := make([]int, 0, len(idsStr)) + for _, idStr := range idsStr { + if idStr == "*" { + ids = append(ids[:0], -1) + break + } + + id, err := strconv.Atoi(idStr) + if err != nil { + continue + } + + ids = append(ids, id) + } + + updatedDevices := devices[:0:0] + for _, device := range devices { + for _, id := range ids { + if id == -1 || id == device.ID { + if (color.IsKelvin() && device.HasCapability(models.DCColorKelvin)) || (color.IsHueSat() && device.HasCapability(models.DCColorHS)) { + device.State.Color = color + if device.HasCapability(models.DCPower) { + device.State.Power = power + } + if device.HasCapability(models.DCIntensity) { + device.State.Intensity = intensity + } + updatedDevices = append(updatedDevices, device) + } + } + } + } + + if len(updatedDevices) > 0 { + err := driver.Publish(context.Background(), bridge, updatedDevices) + if err != nil { + log.Fatalln("Publish to bridge failed:", err) + return + } + } + } + }() + + for event := range ch { + _, _ = fmt.Fprintf(os.Stderr, "Event %s", event.Name) + keys := make([]string, 0, 8) + for key := range event.Payload { + keys = append(keys, key) + } + sort.Strings(keys) + for _, key := range keys { + _, _ = fmt.Fprintf(os.Stderr, " %s=%#+v", key, event.Payload[key]) + } + _, _ = fmt.Fprint(os.Stderr, "\n") + } +} diff --git a/go.mod b/go.mod index 8a6b3d6..20a2922 100644 --- a/go.mod +++ b/go.mod @@ -3,15 +3,13 @@ module git.aiterp.net/lucifer/new-server go 1.16 require ( - github.com/ClickHouse/clickhouse-go v1.4.5 // indirect - github.com/denisenkom/go-mssqldb v0.10.0 // indirect github.com/gin-gonic/gin v1.7.1 github.com/go-sql-driver/mysql v1.6.0 github.com/jmoiron/sqlx v1.3.4 github.com/lib/pq v1.10.2 // indirect + github.com/lucasb-eyer/go-colorful v1.2.0 github.com/mattn/go-sqlite3 v2.0.3+incompatible // indirect github.com/pkg/errors v0.9.1 // indirect github.com/pressly/goose v2.7.0+incompatible - github.com/ziutek/mymysql v1.5.4 // indirect golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a // indirect ) diff --git a/go.sum b/go.sum index d4821b0..a8ed0d3 100644 --- a/go.sum +++ b/go.sum @@ -1,13 +1,6 @@ -github.com/ClickHouse/clickhouse-go v1.4.5 h1:FfhyEnv6/BaWldyjgT2k4gDDmeNwJ9C4NbY/MXxJlXk= -github.com/ClickHouse/clickhouse-go v1.4.5/go.mod h1:EaI/sW7Azgz9UATzd5ZdZHRUhHgv5+JMS9NSr2smCJI= -github.com/bkaradzic/go-lz4 v1.0.0/go.mod h1:0YdlkowM3VswSROI7qDxhRvJ3sLhlFrRRwjwegp5jy4= -github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58 h1:F1EaeKL/ta07PY/k9Os/UFtwERei2/XzGemhpGnBKNg= -github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58/go.mod h1:EOBUe0h4xcZ5GoxqC5SDxFQ8gwyZPKQoEzownBlhI80= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/denisenkom/go-mssqldb v0.10.0 h1:QykgLZBorFE95+gO3u9esLd0BmbvpWp0/waNNZfHBM8= -github.com/denisenkom/go-mssqldb v0.10.0/go.mod h1:xbL0rPBG9cCiLr28tMa8zpbdarY27NDyej4t/EjAShU= github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= github.com/gin-gonic/gin v1.7.1 h1:qC89GU3p8TvKWMAVhEpmpB2CIb1hnqt2UdKZaP93mS8= @@ -20,32 +13,25 @@ github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD87 github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA= github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE= github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4= -github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= -github.com/go-sql-driver/mysql v1.5.0 h1:ozyZYNQW3x3HtqT1jira07DN2PArx2v7/mN66gGcHOs= github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE= github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= -github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe h1:lXe2qZdvpiX5WZkZR4hgp4KJVfY3nMkvmwbVkpv1rVY= -github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0= github.com/golang/protobuf v1.3.3 h1:gyjaxf+svBWX08ZjK86iN9geUJF0H6gp2IRKX6Nf6/I= github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/jmoiron/sqlx v1.2.0/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks= github.com/jmoiron/sqlx v1.3.4 h1:wv+0IJZfL5z0uZoUjlpKgHkgaFSYD+r9CfrXjEXsO7w= github.com/jmoiron/sqlx v1.3.4/go.mod h1:2BljVx/86SuTyjE+aPYlHCTNvZrnJXghYGpNiXLBMCQ= github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns= github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y= github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= -github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= -github.com/lib/pq v1.2.0 h1:LXpIM/LZ5xGFhOpXAQUIMM1HdyqzVYM13zNdjCEEcA0= github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/lib/pq v1.10.2 h1:AqzbZs4ZoCBp+GtejcpCpcxM3zlSMx29dXbUSeVtJb8= github.com/lib/pq v1.10.2/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= +github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= +github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= -github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= -github.com/mattn/go-sqlite3 v1.14.6 h1:dNPt6NO46WmLVt2DLNpwczCmdV5boIZ6g/tlDrlRUbg= github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= github.com/mattn/go-sqlite3 v2.0.3+incompatible h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U= github.com/mattn/go-sqlite3 v2.0.3+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= @@ -53,7 +39,6 @@ github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OH github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= @@ -68,11 +53,7 @@ github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo= github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs= github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= -github.com/ziutek/mymysql v1.5.4 h1:GB0qdRGsTwQSBVYuVShFBKaXSnSnYYC2d9knnE1LHFs= -github.com/ziutek/mymysql v1.5.4/go.mod h1:LMSpPZ6DbqWFxNCHW77HeMg9I646SAhApZ/wKdgO/C0= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a h1:kr2P4QFmQr29mSLA43kwrOcgcReGTfbE9N577tCTuBc= golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8= @@ -80,8 +61,8 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200116001909-b77594299b42 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 h1:nxC68pudNYkKU6jWhgrqdreuFiOQWj1Fs7T3VrH4Pjw= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= diff --git a/internal/drivers/nanoleaf/bridge.go b/internal/drivers/nanoleaf/bridge.go new file mode 100644 index 0000000..73d2a7a --- /dev/null +++ b/internal/drivers/nanoleaf/bridge.go @@ -0,0 +1,411 @@ +package nanoleaf + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "git.aiterp.net/lucifer/new-server/models" + "github.com/lucasb-eyer/go-colorful" + "io" + "io/ioutil" + "log" + "math" + "net" + "net/http" + "strconv" + "strings" + "sync" + "time" +) + +type bridge struct { + mu sync.Mutex + externalID int + host string + apiKey string + panels []*panel + panelIDMap map[uint16]int +} + +func (b *bridge) Devices() []models.Device { + results := make([]models.Device, 0, len(b.panels)) + for i, panel := range b.panels { + red := float64(panel.ColorRGBA[0]) / 255.0 + green := float64(panel.ColorRGBA[1]) / 255.0 + blue := float64(panel.ColorRGBA[2]) / 255.0 + + hue, sat, value := colorful.LinearRgb(red, green, blue).Hsv() + + results = append(results, models.Device{ + ID: -1, + BridgeID: b.externalID, + InternalID: strconv.Itoa(int(panel.ID)), + Icon: "hexagon", + Name: fmt.Sprintf("Hexagon %d", i), + Capabilities: []models.DeviceCapability{ + models.DCPower, + models.DCColorHS, + models.DCIntensity, + models.DCButtons, + }, + ButtonNames: []string{"Touch"}, + DriverProperties: map[string]string{ + "x": strconv.Itoa(panel.X), + "y": strconv.Itoa(panel.Y), + "o": strconv.Itoa(panel.O), + "shapeType": shapeTypeMap[panel.ShapeType], + "shapeWidth": strconv.Itoa(shapeWidthMap[panel.ShapeType]), + }, + UserProperties: nil, + State: models.DeviceState{ + Power: panel.ColorRGBA[3] == 0, + Color: models.ColorValue{ + Hue: math.Mod(hue, 360), + Saturation: sat, + }, + Intensity: value, + Temperature: 0, + }, + Tags: nil, + }) + } + + return results +} + +func (b *bridge) Refresh(ctx context.Context) error { + overview, err := b.Overview(ctx) + if err != nil { + return err + } + + b.mu.Lock() +PanelLoop: + for _, panelInfo := range overview.PanelLayout.Data.PositionData { + if panelInfo.PanelID == 0 { + continue + } + + for _, existingPanel := range b.panels { + if existingPanel.ID == panelInfo.PanelID { + existingPanel.O = panelInfo.O + existingPanel.X = panelInfo.X + existingPanel.Y = panelInfo.Y + existingPanel.ShapeType = panelInfo.ShapeType + + continue PanelLoop + } + } + + b.panels = append(b.panels, &panel{ + ID: panelInfo.PanelID, + ColorRGBA: [4]byte{0, 0, 0, 0}, + TransitionAt: time.Time{}, + O: panelInfo.O, + X: panelInfo.X, + Y: panelInfo.Y, + ShapeType: panelInfo.ShapeType, + Stale: true, + SlowUpdates: 5, + }) + } + b.mu.Unlock() + + return nil +} + +func (b *bridge) Overview(ctx context.Context) (*Overview, error) { + req, err := http.NewRequest("GET", b.URL(), nil) + if err != nil { + return nil, err + } + + res, err := http.DefaultClient.Do(req.WithContext(ctx)) + if err != nil { + return nil, err + } + defer res.Body.Close() + + switch res.StatusCode { + case 400, 403, 500, 503: + return nil, models.ErrUnexpectedResponse + case 401: + return nil, models.ErrIncorrectToken + } + + overview := Overview{} + err = json.NewDecoder(res.Body).Decode(&overview) + if err != nil { + return nil, err + } + + return &overview, nil +} + +func (b *bridge) URL(resource ...string) string { + return fmt.Sprintf("http://%s:16021/api/v1/%s/%s", b.host, b.apiKey, strings.Join(resource, "/")) +} + +func (b *bridge) Update(devices []models.Device) { + b.mu.Lock() + defer b.mu.Unlock() + + for _, device := range devices { + id, err := strconv.Atoi(device.InternalID) + if err != nil { + continue + } + + b.panelIDMap[uint16(id)] = device.ID + + for _, panel := range b.panels { + if panel.ID == uint16(id) { + if device.State.Power { + color := colorful.Hsv(device.State.Color.Hue, device.State.Color.Saturation, device.State.Intensity) + + red, green, blue := color.RGB255() + newColor := [4]byte{red, green, blue, 255} + if newColor != panel.ColorRGBA { + panel.update(newColor, time.Now().Add(time.Millisecond*120)) + } + } else { + panel.update([4]byte{0, 0, 0, 0}, time.Now()) + } + + break + } + } + } +} + +func (b *bridge) Run(ctx context.Context, info models.Bridge, ch chan<- models.Event) error { + err := b.updateEffect(ctx) + if err != nil { + return err + } + + conn, err := net.DialUDP("udp", nil, &net.UDPAddr{ + IP: net.ParseIP(info.Address), + Port: 60222, + }) + if err != nil { + return err + } + defer conn.Close() + + // Notify connections and disconnections + ch <- models.Event{Name: "BridgeConnected", Payload: map[string]string{"bridgeId": strconv.Itoa(info.ID)}} + defer func() { + ch <- models.Event{Name: "BridgeDisconnected", Payload: map[string]string{"bridgeId": strconv.Itoa(info.ID)}} + }() + + // Start touch listener. This one should go down together with this one, though, so it needs a new context. + ctx2, cancel := context.WithCancel(ctx) + defer cancel() + go b.runTouchListener(ctx2, info.Address, info.Token, ch) + + go func() { + ticker := time.NewTicker(time.Second * 5) + for { + select { + case <-ticker.C: + case <-ctx2.Done(): + } + + err := b.updateEffect(ctx) + if err != nil { + log.Println("Failed to update effects:", err, "This error is non-fatal, and it will be retried shortly.") + } + } + }() + + ticker := time.NewTicker(time.Millisecond * 100) + defer ticker.Stop() + + strikes := 0 + + for range ticker.C { + if ctx.Err() != nil { + break + } + + panelUpdate := make(PanelUpdate, 2) + + b.mu.Lock() + for _, panel := range b.panels { + if !panel.Stale { + if panel.SlowUpdates > 0 { + panel.TicksUntilSlowUpdate -= 1 + if panel.TicksUntilSlowUpdate > 0 { + continue + } + + panel.TicksUntilSlowUpdate = 10 + panel.SlowUpdates -= 1 + } else { + continue + } + } else { + panel.Stale = false + } + + panelUpdate.Add(panel.message()) + if panelUpdate.Len() > 150 { + break + } + } + b.mu.Unlock() + + if panelUpdate.Len() == 0 { + continue + } + + _, err := conn.Write(panelUpdate) + if err != nil { + strikes++ + if strikes >= 3 { + return err + } + } else { + strikes = 0 + } + } + + return nil +} + +func (b *bridge) updateEffect(ctx context.Context) error { + overview, err := b.Overview(ctx) + if err != nil { + return err + } + + if overview.Effects.Select == "*Dynamic*" && overview.State.ColorMode == "effect" { + return nil + } + + req, err := http.NewRequest("PUT", b.URL("effects"), bytes.NewReader(httpMessage)) + if err != nil { + return err + } + + res, err := http.DefaultClient.Do(req.WithContext(ctx)) + if err != nil { + return err + } + defer res.Body.Close() + + if res.StatusCode != 204 { + return models.ErrUnexpectedResponse + } + + return nil +} + +func (b *bridge) runTouchListener(ctx context.Context, host, apiKey string, ch chan<- models.Event) { + cooldownID := 0 + cooldownUntil := time.Now() + + message := make(PanelEventMessage, 65536) + reqCloser := io.Closer(nil) + + for { + // Set up touch event receiver + touchListener, err := net.ListenUDP("udp4", &net.UDPAddr{ + Port: 0, + IP: net.IPv4(0, 0, 0, 0), + }) + if err != nil { + log.Println("Socket error:", err) + goto teardownAndRetry + } + + { + // Create touch event sender on the remote end. + req, err := http.NewRequest("GET", fmt.Sprintf("http://%s:16021/api/v1/%s/events?id=4", host, apiKey), nil) + if err != nil { + log.Println("HTTP error:", err) + goto teardownAndRetry + } + req.Header["TouchEventsPort"] = []string{strconv.Itoa(touchListener.LocalAddr().(*net.UDPAddr).Port)} + res, err := http.DefaultClient.Do(req.WithContext(ctx)) + if err != nil { + log.Println("HTTP error:", err) + goto teardownAndRetry + } + + // Discard all data coming over http. + reqCloser = res.Body + go io.Copy(ioutil.Discard, res.Body) + + for { + if ctx.Err() != nil { + goto teardownAndRetry + } + + // Check in with the context every so often + _ = touchListener.SetReadDeadline(time.Now().Add(time.Second)) + n, _, err := touchListener.ReadFromUDP(message) + if err != nil { + if netErr, ok := err.(net.Error); ok && netErr.Timeout() { + continue + } else if ctx.Err() == nil { + log.Println("UDP error:", err) + } + + goto teardownAndRetry + } + + if !message[:n].ValidateLength() { + log.Println("Bad message length field") + continue + } + + for i := 0; i < message.Count(); i += 1 { + b.mu.Lock() + externalID, hasExternalID := b.panelIDMap[message.PanelID(i)] + swipedFromID, hasSwipedFromID := b.panelIDMap[message.SwipedFromPanelID(i)] + b.mu.Unlock() + + if !hasExternalID || (externalID == cooldownID && time.Now().Before(cooldownUntil)) { + continue + } + + event := models.Event{ + Name: "ButtonPressed", + Payload: map[string]string{ + "buttonIndex": "0", + "buttonName": "Touch", + "deviceId": strconv.Itoa(externalID), + }, + } + if hasSwipedFromID { + event.Payload["swipedFromDeviceId"] = strconv.Itoa(swipedFromID) + } + + ch <- event + + cooldownID = externalID + cooldownUntil = time.Now().Add(time.Second) + } + } + } + + teardownAndRetry: + if touchListener != nil { + _ = touchListener.Close() + } + + if reqCloser != nil { + _ = reqCloser.Close() + reqCloser = nil + } + + if ctx.Err() != nil { + break + } + + time.Sleep(time.Second * 3) + } +} diff --git a/internal/drivers/nanoleaf/data.go b/internal/drivers/nanoleaf/data.go new file mode 100644 index 0000000..97ba26f --- /dev/null +++ b/internal/drivers/nanoleaf/data.go @@ -0,0 +1,150 @@ +package nanoleaf + +import "encoding/binary" + +type EffectInfo struct { + EffectsList []string `json:"effectsList"` + Select string `json:"select"` +} + +type PanelLayout struct { + GlobalOrientation GlobalOrientation `json:"globalOrientation"` + Data PanelLayoutData `json:"layout"` +} + +type GlobalOrientation struct { + Value int `json:"value"` + Max int `json:"max"` + Min int `json:"min"` +} + +type PanelLayoutData struct { + NumPanels int `json:"numPanels"` + SideLength int `json:"sideLength"` + PositionData []PositionData `json:"positionData"` +} + +type PositionData struct { + PanelID uint16 `json:"panelId"` + X int `json:"x"` + Y int `json:"y"` + O int `json:"o"` + ShapeType int `json:"shapeType"` +} + +type StateBool struct { + Value bool `json:"value"` +} + +type StateInt struct { + Value int `json:"value"` + Max int `json:"max"` + Min int `json:"min"` +} + +type State struct { + Brightness StateInt `json:"brightness"` + ColorMode string `json:"colorMode"` + Ct StateInt `json:"ct"` + Hue StateInt `json:"hue"` + On StateBool `json:"on"` + Sat StateInt `json:"sat"` +} + +type Overview struct { + Name string `json:"name"` + SerialNumber string `json:"serialNo"` + Manufacturer string `json:"manufacturer"` + FirmwareVersion string `json:"firmwareVersion"` + HardwareVersion string `json:"hardwareVersion"` + Model string `json:"model"` + Effects EffectInfo `json:"effects"` + PanelLayout PanelLayout `json:"panelLayout"` + State State `json:"state"` +} + +type DeviceInfo struct { + SerialNumber string `json:"serialNumber"` + HardwareVersion string `json:"hardwareVersion"` + FirmwareVersion string `json:"firmwareVersion"` + BootloaderVersion string `json:"bootloaderVersion"` + ModelNumber string `json:"modelNumber"` +} + +type TokenResponse struct { + Token string `json:"auth_token"` +} + +type PanelUpdate []byte + +func (u *PanelUpdate) Add(message [8]byte) { + if len(*u) < 2 { + *u = make([]byte, 2, 10) + } + + binary.BigEndian.PutUint16(*u, binary.BigEndian.Uint16(*u)+1) + + *u = append(*u, message[:]...) +} + +func (u *PanelUpdate) Len() int { + if len(*u) < 2 { + return 0 + } + + return int(binary.BigEndian.Uint16(*u)) +} + +type PanelEventMessage []byte + +func (remote PanelEventMessage) Count() int { + return int(binary.BigEndian.Uint16(remote[0:])) +} + +func (remote PanelEventMessage) ValidateLength() bool { + return len(remote) >= (2 + remote.Count()*5) +} + +func (remote PanelEventMessage) PanelID(idx int) uint16 { + return binary.BigEndian.Uint16(remote[2+(idx*5):]) +} + +func (remote PanelEventMessage) TouchType(idx int) int { + value := int(remote[2+(idx*5)]) + return (value & 0b11100000) >> 5 +} + +func (remote PanelEventMessage) TouchStrength(idx int) int { + value := int(remote[2+(idx*5)]) + return (value & 0b00011110) >> 1 +} + +func (remote PanelEventMessage) SwipedFromPanelID(idx int) uint16 { + return binary.BigEndian.Uint16(remote[2+(idx*5)+3:]) +} + +var shapeTypeMap = map[int]string{ + 0: "Triangle", + 1: "Rhythm", + 2: "Square", + 3: "Control Square Master", + 4: "Control Square Passive", + 7: "Hexagon (Shapes)", + 8: "Triangle (Shapes)", + 9: "Mini Triangle (Shapes)", + 12: "Shapes Controller", +} + +var shapeWidthMap = map[int]int{ + 0: 150, + 1: -1, + 2: 100, + 3: 100, + 4: 100, + 7: 67, + 8: 134, + 9: 67, + 12: -1, +} + +var httpMessage = []byte(`{ "write": { "command": "display", "animType": "extControl", "extControlVersion": "v2" }}`) diff --git a/internal/drivers/nanoleaf/driver.go b/internal/drivers/nanoleaf/driver.go new file mode 100644 index 0000000..9c244b6 --- /dev/null +++ b/internal/drivers/nanoleaf/driver.go @@ -0,0 +1,162 @@ +package nanoleaf + +import ( + "context" + "encoding/json" + "fmt" + "git.aiterp.net/lucifer/new-server/models" + "net/http" + "sync" + "time" +) + +type Driver struct { + mu sync.Mutex + bridges []*bridge +} + +// SearchBridge checks the bridge at the address. If it's not a dry-run, you must hold down the power button +// before calling this function and wait for the pattern. +func (d *Driver) SearchBridge(ctx context.Context, address string, dryRun bool) ([]models.Bridge, error) { + res, err := http.Get(fmt.Sprintf("http://%s/device_info", address)) + if err != nil { + return nil, err + } + defer res.Body.Close() + + deviceInfo := DeviceInfo{} + err = json.NewDecoder(res.Body).Decode(&deviceInfo) + if err != nil { + return nil, err + } + if deviceInfo.ModelNumber == "" { + return nil, models.ErrUnexpectedResponse + } + + token := "" + if !dryRun { + req, err := http.NewRequest("POST", fmt.Sprintf("http://%s:16021/api/v1/new/", address), nil) + if err != nil { + return nil, err + } + + res, err := http.DefaultClient.Do(req.WithContext(ctx)) + if err != nil { + return nil, err + } + defer res.Body.Close() + + if res.StatusCode != 200 { + return nil, models.ErrBridgeSearchFailed + } + + tokenResponse := TokenResponse{} + err = json.NewDecoder(res.Body).Decode(&tokenResponse) + if err != nil { + return nil, err + } + + token = tokenResponse.Token + } + + return []models.Bridge{{ + ID: -1, + Name: fmt.Sprintf("Nanoleaf Controller (MN: %s, SN: %s, HV: %s, FV: %s, BV: %s)", + deviceInfo.ModelNumber, + deviceInfo.SerialNumber, + deviceInfo.HardwareVersion, + deviceInfo.FirmwareVersion, + deviceInfo.BootloaderVersion, + ), + Driver: models.DTNanoLeaf, + Address: address, + Token: token, + }}, nil +} + +func (d *Driver) SearchDevices(ctx context.Context, bridge models.Bridge, timeout time.Duration) ([]models.Device, error) { + b, err := d.ensureBridge(ctx, bridge) + if err != nil { + return nil, err + } + + if timeout > time.Millisecond { + timeoutCtx, cancel := context.WithTimeout(ctx, timeout) + defer cancel() + + ctx = timeoutCtx + } + + err = b.Refresh(ctx) + if err != nil { + return nil, err + } + + return b.Devices(), nil +} + +func (d *Driver) ListDevices(ctx context.Context, bridge models.Bridge) ([]models.Device, error) { + b, err := d.ensureBridge(ctx, bridge) + if err != nil { + return nil, err + } + + return b.Devices(), nil +} + +func (d *Driver) Run(ctx context.Context, bridge models.Bridge, ch chan<- models.Event) error { + b, err := d.ensureBridge(ctx, bridge) + if err != nil { + return err + } + + return b.Run(ctx, bridge, ch) +} + +func (d *Driver) Publish(ctx context.Context, bridge models.Bridge, devices []models.Device) error { + b, err := d.ensureBridge(ctx, bridge) + if err != nil { + return err + } + + b.Update(devices) + + return nil +} + +func (d *Driver) ensureBridge(ctx context.Context, info models.Bridge) (*bridge, error) { + d.mu.Lock() + for _, bridge := range d.bridges { + if bridge.host == info.Address { + d.mu.Unlock() + return bridge, nil + } + } + d.mu.Unlock() + + bridge := &bridge{ + host: info.Address, + apiKey: info.Token, + externalID: info.ID, + panelIDMap: make(map[uint16]int, 9), + } + + // If this fails, then the authorization failed. + err := bridge.Refresh(ctx) + if err != nil { + return nil, err + } + + // To avoid a potential duplicate, try looking for it again before inserting + d.mu.Lock() + for _, bridge := range d.bridges { + if bridge.host == info.Address { + d.mu.Unlock() + return bridge, nil + } + } + d.bridges = append(d.bridges, bridge) + d.mu.Unlock() + + return bridge, nil +} diff --git a/internal/drivers/nanoleaf/panel.go b/internal/drivers/nanoleaf/panel.go new file mode 100644 index 0000000..fc0b033 --- /dev/null +++ b/internal/drivers/nanoleaf/panel.go @@ -0,0 +1,68 @@ +package nanoleaf + +import ( + "encoding/binary" + "time" +) + +type panel struct { + ID uint16 + ColorRGBA [4]byte + TransitionAt time.Time + + O int + X int + Y int + ShapeType int + + Stale bool + SlowUpdates int + TicksUntilSlowUpdate int +} + +func (p *panel) message() (message [8]byte) { + transitionTime := p.TransitionAt.Sub(time.Now()).Round(time.Millisecond * 100) + if transitionTime > maxTransitionTime { + transitionTime = maxTransitionTime + } else if transitionTime < 0 { + transitionTime = 0 + } + + binary.BigEndian.PutUint16(message[0:], p.ID) + copy(message[2:], p.ColorRGBA[:]) + binary.BigEndian.PutUint16(message[6:], uint16(transitionTime/(time.Millisecond*100))) + + return +} + +func (p *panel) update(colorRGBA [4]byte, transitionAt time.Time) { + if p.ColorRGBA != colorRGBA { + p.ColorRGBA = colorRGBA + p.Stale = true + p.SlowUpdates = 3 + p.TicksUntilSlowUpdate = 10 + } + p.TransitionAt = transitionAt +} + +type panelUpdate []byte + +func (u *panelUpdate) Add(message [8]byte) { + if len(*u) < 2 { + *u = make([]byte, 2, 10) + } + + binary.BigEndian.PutUint16(*u, binary.BigEndian.Uint16(*u)+1) + + *u = append(*u, message[:]...) +} + +func (u *panelUpdate) Len() int { + if len(*u) < 2 { + return 0 + } + + return int(binary.BigEndian.Uint16(*u)) +} + +const maxTransitionTime = time.Minute * 109 diff --git a/models/colorvalue.go b/models/colorvalue.go index bd86c1d..a11f516 100644 --- a/models/colorvalue.go +++ b/models/colorvalue.go @@ -2,14 +2,15 @@ package models import ( "fmt" - "regexp" + "math" "strconv" + "strings" ) type ColorValue struct { - Hue int `json:"h,omitempty"` - Saturation int `json:"s,omitempty"` - Kelvin int `json:"kelvin,omitempty"` + Hue float64 `json:"h,omitempty"` // 0..360 + Saturation float64 `json:"s,omitempty"` // 0..=1 + Kelvin int `json:"kelvin,omitempty"` } func (c *ColorValue) IsHueSat() bool { @@ -25,16 +26,17 @@ func (c *ColorValue) String() string { return fmt.Sprintf("kelvin:%d", c.Kelvin) } - return fmt.Sprintf("hsv:%d,%d", c.Hue, c.Saturation) + return fmt.Sprintf("hsv:%f,%f", c.Hue, c.Saturation) } -var kelvinRegex = regexp.MustCompile("kelvin:([0-9]+)") -var hsRegex = regexp.MustCompile("hs:([0-9]+),([0-9]+)") - func ParseColorValue(raw string) (ColorValue, error) { - if kelvinRegex.MatchString(raw) { - part := kelvinRegex.FindString(raw) - parsedPart, err := strconv.Atoi(part) + tokens := strings.SplitN(raw, ":", 2) + if len(tokens) != 2 { + return ColorValue{}, ErrBadInput + } + + if tokens[0] == "kelvin" { + parsedPart, err := strconv.Atoi(tokens[1]) if err != nil { return ColorValue{}, ErrBadInput } @@ -42,19 +44,19 @@ func ParseColorValue(raw string) (ColorValue, error) { return ColorValue{Kelvin: parsedPart}, nil } - if hsRegex.MatchString(raw) { - parts := kelvinRegex.FindAllString(raw, 2) + if tokens[0] == "hs" { + parts := strings.Split(tokens[1], ",") if len(parts) < 2 { return ColorValue{}, ErrUnknownColorFormat } - part1, err1 := strconv.Atoi(parts[0]) - part2, err2 := strconv.Atoi(parts[1]) + part1, err1 := strconv.ParseFloat(parts[0], 64) + part2, err2 := strconv.ParseFloat(parts[1], 64) if err1 != nil || err2 != nil { return ColorValue{}, ErrBadInput } - return ColorValue{Hue: part1, Saturation: part2}, nil + return ColorValue{Hue: math.Mod(part1, 360), Saturation: math.Min(math.Max(part2, 0), 1)}, nil } return ColorValue{}, ErrUnknownColorFormat diff --git a/models/device.go b/models/device.go index 907e904..affc24f 100644 --- a/models/device.go +++ b/models/device.go @@ -22,13 +22,13 @@ type Device struct { // DeviceState contains optional state values that // - Power: Whether the device is powered on // - Color: Color value, if a color setting can be set on the device -// - Intensity: e.g. brightness, from 0-255 +// - Intensity: e.g. brightness, range 0..=1 // - Temperature: e.g. for thermostats type DeviceState struct { Power bool `json:"power"` Color ColorValue `json:"color,omitempty"` - Intensity int `json:"intensity,omitempty"` - Temperature int `json:"temperature"` + Intensity float64 `json:"intensity,omitempty"` + Temperature float64 `json:"temperature"` } type NewDeviceState struct { diff --git a/models/driver.go b/models/driver.go index cff6a3b..5dd8253 100644 --- a/models/driver.go +++ b/models/driver.go @@ -12,6 +12,7 @@ type DriverProvider interface { type Driver interface { SearchBridge(ctx context.Context, address string, dryRun bool) ([]Bridge, error) SearchDevices(ctx context.Context, bridge Bridge, timeout time.Duration) ([]Device, error) - Consume(ctx context.Context, bridge Bridge, devices []Device, ch chan Event) (chan<- struct{}, error) + ListDevices(ctx context.Context, bridge Bridge) ([]Device, error) Publish(ctx context.Context, bridge Bridge, devices []Device) error + Run(ctx context.Context, bridge Bridge, ch chan<- Event) error } diff --git a/models/errors.go b/models/errors.go index abbcc0d..fa95fae 100644 --- a/models/errors.go +++ b/models/errors.go @@ -6,3 +6,8 @@ var ErrInvalidName = errors.New("invalid name") var ErrBadInput = errors.New("bad input") var ErrBadColor = errors.New("bad color") var ErrUnknownColorFormat = errors.New("unknown color format") + +var ErrMissingToken = errors.New("driver is missing authentication information") +var ErrIncorrectToken = errors.New("driver is not accepting authentication information") +var ErrUnexpectedResponse = errors.New("driver api returned unexpected response (wrong driver selected?)") +var ErrBridgeSearchFailed = errors.New("bridge search failed") diff --git a/models/eventhandler.go b/models/eventhandler.go index 8b1b82e..f233278 100644 --- a/models/eventhandler.go +++ b/models/eventhandler.go @@ -72,9 +72,9 @@ func (c *EventCondition) checkDevice(key string, device Device) bool { case "color": return c.matches(device.State.Color.String()) case "intensity": - return c.matches(strconv.Itoa(device.State.Intensity)) + return c.matches(strconv.FormatFloat(device.State.Intensity, 'f', -1, 64)) case "temperature": - return c.matches(strconv.Itoa(device.State.Temperature)) + return c.matches(strconv.FormatFloat(device.State.Temperature, 'f', -1, 64)) } return false