monster/mi-scale-parser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

revert to one main file

Browse Source
This commit is contained in:
Monster
2018-02-10 16:21:39 +03:00
parent b548fdc402
commit a626e6e376
9 changed files with 245 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ble_handler.go
-91
View File
@@ -1,91 +0,0 @@
package main
import (
"fmt"
"log"
"blegw/workers"
"github.com/currantlabs/gatt"
"github.com/currantlabs/gatt/examples/option"
)
type BleService struct {
workers []*workers.Worker
done chan struct{}
}
// AddWorker - add new worker
func (s *BleService) AddWorker(worker workers.Worker) {
if s.workers == nil {
fmt.Println("Init workers.")
s.workers = make([]*workers.Worker, 0, 0)
}
s.workers = append(s.workers, &worker)
}
func (s *BleService) Init() error {
s.done = make(chan struct{})
d, err := gatt.NewDevice(option.DefaultClientOptions...)
if err != nil {
log.Fatalf("Failed to open device, err: %s\n", err)
return err
}
// Register handlers.
d.Handle(
gatt.PeripheralDiscovered(s.onPeriphDiscovered),
gatt.PeripheralConnected(s.onPeriphConnected),
gatt.PeripheralDisconnected(s.onPeriphDisconnected),
)
d.Init(s.onStateChanged)
<-s.done
fmt.Println("Done")
return nil
}
func (s *BleService) onStateChanged(d gatt.Device, state gatt.State) {
fmt.Println("State:", state)
switch state {
case gatt.StatePoweredOn:
fmt.Println("scanning...")
d.Scan([]gatt.UUID{}, false)
return
default:
d.StopScanning()
}
}
func (s *BleService) onPeriphDiscovered(p gatt.Peripheral, a *gatt.Advertisement, rssi int) {
isConnect := false
for _, worker := range s.workers {
ret := (*worker).OnDiscovery(p, a, rssi)
if ret && !isConnect {
isConnect = true
}
}
if isConnect {
p.Device().Connect(p)
}
}
func (s *BleService) onPeriphConnected(p gatt.Peripheral, err error) {
defer p.Device().CancelConnection(p)
if err := p.SetMTU(500); err != nil {
fmt.Printf("Failed to set MTU, err: %s\n", err)
}
fmt.Printf("Set mtu done.\n")
for _, worker := range s.workers {
(*worker).OnConnect(p, err)
}
}
func (s *BleService) onPeriphDisconnected(p gatt.Peripheral, err error) {
fmt.Println("Disconnected")
close(s.done)
}
blegw
BIN
View File
Binary file not shown.
main.go
+171 -8
View File
@@ -1,15 +1,178 @@
package main
import "blegw/workers"
import (
"fmt"
"log"
"strings"
"sync"
"time"
"github.com/currantlabs/gatt"
"github.com/currantlabs/gatt/examples/option"
)
var done = make(chan struct{})
func onStateChanged(d gatt.Device, s gatt.State) {
fmt.Println("State:", s)
switch s {
case gatt.StatePoweredOn:
fmt.Println("scanning...")
d.Scan([]gatt.UUID{}, false)
return
default:
d.StopScanning()
}
}
func onPeriphDiscovered(p gatt.Peripheral, a *gatt.Advertisement, rssi int) {
ID := p.ID()
//xiaomi scale
if !strings.HasPrefix(ID, "88:0F:10") {
return
}
fmt.Printf("\nPeripheral ID:%s, NAME:(%s)\n", ID, p.Name())
fmt.Printf("%v+", a)
fmt.Println(" Local Name =", a.LocalName)
fmt.Println(" TX Power Level =", a.TxPowerLevel)
fmt.Println(" Manufacturer Data =", a.ManufacturerData)
fmt.Println(" Service Data =", a.ServiceData)
fmt.Println(" RSSI =", rssi)
p.Device().StopScanning()
var mu sync.Mutex
count := 0
mu.Lock()
go func(count int) {
time.Sleep(time.Duration(count) * 5 * time.Second)
fmt.Println("Connecting...")
p.Device().Connect(p)
}(count)
count++
mu.Unlock()
}
func onPeriphConnected(p gatt.Peripheral, err error) {
var WEIGHT_MEASUREMENT_SERVICE = gatt.MustParseUUID("181d")
var WEIGHT_MEASUREMENT_HISTORY_CHARACTERISTIC = gatt.MustParseUUID("00002a2f-0000-3512-2118-0009af100700")
// var WEIGHT_MEASUREMENT_TIME_CHARACTERISTIC = gatt.MustParseUUID("2a2b")
var WEIGHT_MEASUREMENT_CONFIG = gatt.MustParseUUID("2902")
fmt.Println("Connected")
defer p.Device().CancelConnection(p)
if err := p.SetMTU(500); err != nil {
fmt.Printf("Failed to set MTU, err: %s\n", err)
}
fmt.Printf("Set mtu done.\n")
// Discovery services
services, err := p.DiscoverServices(nil)
fmt.Printf("Services: %v+", services)
if err != nil {
fmt.Printf("Failed to discover services, err: %s\n", err)
return
}
service := getServiceByUUID(WEIGHT_MEASUREMENT_SERVICE, services)
fmt.Printf("Service Found %s\n", service.Name())
chars, _ := p.DiscoverCharacteristics(nil, service)
// char := getCharByUUID(WEIGHT_MEASUREMENT_TIME_CHARACTERISTIC, chars)
// b, err := p.ReadCharacteristic(char)
// if err != nil {
// fmt.Printf("Failed to read characteristic, err: %s\n", err)
// return
// }
// parseData(b)
// return
// fmt.Printf(" value %x | %q\n", b, b)
histChar := getCharByUUID(WEIGHT_MEASUREMENT_HISTORY_CHARACTERISTIC, chars)
descriptors, _ := p.DiscoverDescriptors(nil, histChar)
descriptor := getDescriptorByUUID(WEIGHT_MEASUREMENT_CONFIG, descriptors)
p.WriteDescriptor(descriptor, []byte{0x02, 0x00})
isdone := false
p.SetNotifyValue(histChar, func(c *gatt.Characteristic, b []byte, e error) {
log.Printf("Got back from %s: %#x\n", c.UUID(), b)
//weight :=
if len(b) == 20 {
first := b[0:10]
parseData(first)
second := b[10:20]
parseData(second)
} else if len(b) == 10 {
parseData(b)
} else if (len(b) == 1) && b[0] == 0x3 {
isdone = true
return
} else {
fmt.Printf("Invalid data: %v", b)
}
})
p.WriteCharacteristic(histChar, []byte{0x02}, true)
fmt.Printf("Waiting for 120 seconds to get some notifiations, if any.\n")
for i := 0; i < 120; i++ {
if isdone {
break
}
time.Sleep(1 * time.Second)
}
}
func getDescriptorByUUID(uuid gatt.UUID, descriptors []*gatt.Descriptor) *gatt.Descriptor {
for _, descriptor := range descriptors {
if !descriptor.UUID().Equal(uuid) {
continue
}
return descriptor
}
return nil
}
func getServiceByUUID(uuid gatt.UUID, services []*gatt.Service) *gatt.Service {
for _, service := range services {
if !service.UUID().Equal(uuid) {
continue
}
return service
}
return nil
}
func getCharByUUID(uid gatt.UUID, chars []*gatt.Characteristic) *gatt.Characteristic {
for _, c := range chars {
if !c.UUID().Equal(uid) {
continue
}
return c
}
return nil
}
func onPeriphDisconnected(p gatt.Peripheral, err error) {
fmt.Println("Disconnected")
close(done)
}
func main() {
service := BleService{}
d, err := gatt.NewDevice(option.DefaultClientOptions...)
if err != nil {
log.Fatalf("Failed to open device, err: %s\n", err)
return
}
log := workers.Log{}
service.AddWorker(log)
// Register handlers.
d.Handle(
gatt.PeripheralDiscovered(onPeriphDiscovered),
gatt.PeripheralConnected(onPeriphConnected),
gatt.PeripheralDisconnected(onPeriphDisconnected),
)
scale := workers.Scale{}
service.AddWorker(scale)
service.Init()
d.Init(onStateChanged)
<-done
fmt.Println("Done")
}
scale.go
+64
View File
@@ -0,0 +1,64 @@
package main
import (
"fmt"
"math"
"time"
)
func parseData(weightBytes []byte) *Weight {
ctrlByte := weightBytes[0]
isWeightRemoved := isBitSet(ctrlByte, 7)
isStabilized := isBitSet(ctrlByte, 5)
isLBSUnit := isBitSet(ctrlByte, 0)
isCattyUnit := isBitSet(ctrlByte, 4)
// fmt.Printf("IsWeightRemoved: %v\n", isWeightRemoved)
// fmt.Printf("6 LSB Unknown: %v\n", isBitSet(ctrlByte, 6))
// fmt.Printf("IsStabilized: %v\n", isStabilized)
// fmt.Printf("IsCattyOrKg: %v\n", isCattyUnit)
// fmt.Printf("3 LSB Unknown: %v\n", isBitSet(ctrlByte, 3))
// fmt.Printf("2 LSB Unknown: %v\n", isBitSet(ctrlByte, 2))
// fmt.Printf("1 LSB Unknown: %v\n", isBitSet(ctrlByte, 1))
// fmt.Printf("IsLBS: %v\n", isLBSUnit)
// // Only if the value is stabilized and the weight is *not* removed, the date is valid
if isStabilized && !isWeightRemoved {
wb4 := int(weightBytes[4])
wb3 := int(weightBytes[3])
year := (wb4<<8 | wb3)
month := int(weightBytes[5])
day := int(weightBytes[6])
hours := int(weightBytes[7])
min := int(weightBytes[8])
sec := int(weightBytes[9])
// Is the year plausible? Check if the year is in the range of 20 years...
now := time.Now()
if math.Abs(float64(now.Year()-year)) > 20 || year > now.Year() {
return nil
}
wb1 := int(weightBytes[1])
wb2 := int(weightBytes[2])
weightVal := 0.0
if isLBSUnit || isCattyUnit {
weightVal = float64(((wb2)<<8)|(wb1)) / 100.0
} else {
weightVal = float64(((wb2)<<8)|(wb1)) / 200.0
}
t := time.Date(year, time.Month(month), day, hours, min, sec, 0, time.Local)
weight := &Weight{Weight: weightVal, Time: t}
// fmt.Printf("Payload is: %#x\n", weightBytes)
fmt.Printf("[+] Year: %v, Month: %v, day: %v, hr: %v, min: %v, sec: %v = %v \n", year, month, day, hours, min, sec, weightVal)
return weight
}
return nil
}
func isBitSet(value byte, bit uint) bool {
return (value & (1 << bit)) != 0
}
weight.go
+10
View File
@@ -0,0 +1,10 @@
package main
import (
"time"
)
type Weight struct {
Time time.Time
Weight float64
}
workers/logworker.go
-28
View File
@@ -1,28 +0,0 @@
package workers
import (
"fmt"
"github.com/currantlabs/gatt"
)
type Log struct {
Worker
}
func (s Log) OnDiscovery(p gatt.Peripheral, a *gatt.Advertisement, rssi int) bool {
fmt.Printf("\nPeripheral ID:%s, NAME:(%s)\n", p.ID(), p.Name())
fmt.Println(" Local Name =", a.LocalName)
fmt.Println(" Manufacturer Data =", a.ManufacturerData)
fmt.Println(" Service Data =", a.ServiceData)
fmt.Println(" RSSI =", rssi)
return false
}
func (s Log) OnConnect(p gatt.Peripheral, err error) error {
ID := p.ID()
fmt.Println("Connected to " + ID)
return nil
}
workers/scaleworker.go
-134
View File
@@ -1,134 +0,0 @@
package workers
import (
"fmt"
"log"
"math"
"strings"
"time"
"github.com/currantlabs/gatt"
)
type Weight struct {
Time time.Time
Weight float64
}
type Scale struct {
Worker
}
var WEIGHT_MEASUREMENT_SERVICE = gatt.MustParseUUID("181d")
var WEIGHT_MEASUREMENT_HISTORY_CHARACTERISTIC = gatt.MustParseUUID("00002a2f-0000-3512-2118-0009af100700")
var WEIGHT_MEASUREMENT_TIME_CHARACTERISTIC = gatt.MustParseUUID("2a2b")
var WEIGHT_MEASUREMENT_CONFIG = gatt.MustParseUUID("2902")
func (s Scale) OnDiscovery(p gatt.Peripheral, a *gatt.Advertisement, rssi int) bool {
ID := p.ID()
if !strings.HasPrefix(ID, "88:0F:10") {
return false
}
return true
}
func (s Scale) OnConnect(p gatt.Peripheral, err error) error {
ID := p.ID()
//not our device
if !strings.HasPrefix(ID, "88:0F:10") {
return nil
}
// Discovery services
services, err := p.DiscoverServices(nil)
fmt.Printf("Services: %v+", services)
if err != nil {
fmt.Printf("Failed to discover services, err: %s\n", err)
return nil
}
service := getServiceByUUID(WEIGHT_MEASUREMENT_SERVICE, services)
fmt.Printf("Service Found %s\n", service.Name())
chars, _ := p.DiscoverCharacteristics(nil, service)
char := getCharByUUID(WEIGHT_MEASUREMENT_TIME_CHARACTERISTIC, chars)
b, err := p.ReadCharacteristic(char)
if err != nil {
fmt.Printf("Failed to read characteristic, err: %s\n", err)
return nil
}
fmt.Printf(" value %x | %q\n", b, b)
histChar := getCharByUUID(WEIGHT_MEASUREMENT_HISTORY_CHARACTERISTIC, chars)
descriptors, _ := p.DiscoverDescriptors(nil, histChar)
descriptor := getDescriptorByUUID(WEIGHT_MEASUREMENT_CONFIG, descriptors)
p.WriteDescriptor(descriptor, []byte{0x02, 0x00})
p.SetNotifyValue(histChar, func(c *gatt.Characteristic, b []byte, e error) {
log.Printf("Got back from %s: %#x\n", c.UUID(), b)
//weight :=
if len(b) == 20 {
first := b[0:10]
parseData(first)
second := b[10:20]
parseData(second)
} else if len(b) == 10 {
parseData(b)
}
})
p.WriteCharacteristic(histChar, []byte{0x02}, true)
fmt.Printf("Waiting for 5 seconds to get some notifiations, if any.\n")
time.Sleep(10 * time.Second)
return nil
}
func parseData(weightBytes []byte) *Weight {
ctrlByte := weightBytes[0]
isWeightRemoved := isBitSet(ctrlByte, 7)
isStabilized := isBitSet(ctrlByte, 5)
isLBSUnit := isBitSet(ctrlByte, 0)
isCattyUnit := isBitSet(ctrlByte, 4)
// Only if the value is stabilized and the weight is *not* removed, the date is valid
if isStabilized && !isWeightRemoved {
wb4 := int(weightBytes[4])
wb3 := int(weightBytes[3])
year := (wb4<<8 | wb3)
month := int(weightBytes[5])
day := int(weightBytes[6])
hours := int(weightBytes[7])
min := int(weightBytes[8])
sec := int(weightBytes[9])
// Is the year plausible? Check if the year is in the range of 20 years...
now := time.Now()
if math.Abs(float64(now.Year()-year)) > 20 || year > now.Year() {
return nil
}
wb1 := int(weightBytes[1])
wb2 := int(weightBytes[2])
weightVal := 0.0
if isLBSUnit || isCattyUnit {
weightVal = float64(((wb2)<<8)|(wb1)) / 100.0
} else {
weightVal = float64(((wb2)<<8)|(wb1)) / 200.0
}
t := time.Date(year, time.Month(month), day, hours, min, sec, 0, time.Local)
weight := &Weight{Weight: weightVal, Time: t}
// fmt.Printf("Payload is: %#x\n", weightBytes)
fmt.Printf("[+] Year: %v, Month: %v, day: %v, hr: %v, min: %v, sec: %v = %v \n", year, month, day, hours, min, sec, weightVal)
return weight
}
return nil
}
func isBitSet(value byte, bit uint) bool {
return (value & (1 << bit)) != 0
}
workers/worker.go
-8
View File
@@ -1,8 +0,0 @@
package workers
import "github.com/currantlabs/gatt"
type Worker interface {
OnDiscovery(p gatt.Peripheral, a *gatt.Advertisement, rssi int) bool
OnConnect(p gatt.Peripheral, err error) error
}
workers/workerfuncs.go
-33
View File
@@ -1,33 +0,0 @@
package workers
import "github.com/currantlabs/gatt"
func getDescriptorByUUID(uuid gatt.UUID, descriptors []*gatt.Descriptor) *gatt.Descriptor {
for _, descriptor := range descriptors {
if !descriptor.UUID().Equal(uuid) {
continue
}
return descriptor
}
return nil
}
func getServiceByUUID(uuid gatt.UUID, services []*gatt.Service) *gatt.Service {
for _, service := range services {
if !service.UUID().Equal(uuid) {
continue
}
return service
}
return nil
}
func getCharByUUID(uid gatt.UUID, chars []*gatt.Characteristic) *gatt.Characteristic {
for _, c := range chars {
if !c.UUID().Equal(uid) {
continue
}
return c
}
return nil
}