Update

Author: sago35

ble/ble.go

@@ -1,4 +1,4 @@
-//go:build nrf52840
+//go:build tinygo && nrf52840
 
 package ble
 
@@ -15,10 +15,15 @@ var rx bluetooth.DeviceCharacteristic
 
 var reportMap = descriptor.CDCHID.HID[2]
 
+func init() {
+	adapter.Enable()
+}
+
 type bleKeyboard struct {
 	keyboard
-	Name   string
-	report [9]byte
+	Name      string
+	report    [9]byte
+	connected bool
 }
 
 func NewKeyboard(name string) *bleKeyboard {
@@ -28,10 +33,7 @@ func NewKeyboard(name string) *bleKeyboard {
 }
 
 func (k *bleKeyboard) Connect() error {
-	err := adapter.Enable()
-	if err != nil {
-		return err
-	}
+	var err error
 
 	bluetooth.SetSecParamsBonding()
 	bluetooth.SetSecCapabilities(bluetooth.NoneGapIOCapability)

ble/blesplit.go

@@ -0,0 +1,96 @@
+//go:build tinygo && nrf52840
+
+package ble
+
+import (
+	k "machine/usb/hid/keyboard"
+
+	"tinygo.org/x/bluetooth"
+)
+
+var tx = &bluetooth.Characteristic{}
+
+type bleSplitKeyboard struct {
+	keyboard
+	Name      string
+	report    [9]byte
+	pressed   []k.Keycode
+	connected bool
+}
+
+func NewSplitKeyboard(name string) *bleSplitKeyboard {
+	return &bleSplitKeyboard{
+		Name: name,
+	}
+}
+
+//// SetConnectHandler sets a handler function to be called whenever the adaptor connects
+//// or disconnects. You must call this before you call adaptor.Connect() for centrals
+//// or adaptor.Start() for peripherals in order for it to work.
+//func (a *Adapter) SetConnectHandler(c func(device Address, connected bool)) {
+//    a.connectHandler = c
+//}
+
+func (k *bleSplitKeyboard) Connect() error {
+	var err error
+
+	name := k.Name
+	if len(name) > 14 {
+		name = name[:14]
+	}
+	adapter.SetConnectHandler(func(device bluetooth.Address, connected bool) {
+		println("connected:", connected)
+	})
+
+	adv := adapter.DefaultAdvertisement()
+	err = adv.Configure(bluetooth.AdvertisementOptions{
+		LocalName: name,
+	})
+	err = adv.Start()
+	if err != nil {
+		return err
+	}
+
+	adapter.AddService(&bluetooth.Service{
+		UUID: bluetooth.ServiceUUIDNordicUART,
+		Characteristics: []bluetooth.CharacteristicConfig{
+			{
+				Handle: tx,
+				UUID:   bluetooth.CharacteristicUUIDUARTTX,
+				Value:  k.report[:3],
+				Flags:  bluetooth.CharacteristicReadPermission | bluetooth.CharacteristicNotifyPermission,
+			},
+		},
+	})
+	return nil
+}
+
+func (k *bleSplitKeyboard) Up(c k.Keycode) error {
+	for i, p := range k.pressed {
+		if c == p {
+			k.pressed = append(k.pressed[:i], k.pressed[i+1:]...)
+			row := byte(c >> 8)
+			col := byte(c)
+			_, err := tx.Write([]byte{0x55, byte(row), byte(col)})
+			return err
+		}
+	}
+	return nil
+}
+
+func (k *bleSplitKeyboard) Down(c k.Keycode) error {
+	found := false
+	for _, p := range k.pressed {
+		if c == p {
+			found = true
+		}
+	}
+	if !found {
+		k.pressed = append(k.pressed, c)
+		row := byte(c >> 8)
+		col := byte(c)
+		_, err := tx.Write([]byte{0xAA, byte(row), byte(col)})
+		return err
+	}
+	return nil
+}

ble/keyboard.go

@@ -1,3 +1,5 @@
+//go:build tinygo
+
 package ble
 
 import (

buffer.go

@@ -0,0 +1,65 @@
+//go:build tinygo
+
+package keyboard
+
+import (
+	"runtime/volatile"
+)
+
+// RingBuffer is ring buffer implementation inspired by post at
+// https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+type RingBuffer[T any] struct {
+	buffer []T
+	head   volatile.Register8
+	tail   volatile.Register8
+}
+
+// NewRingBuffer returns a new ring buffer.
+func NewRingBuffer[T any](buf []T) *RingBuffer[T] {
+	return &RingBuffer[T]{
+		buffer: buf,
+	}
+}
+
+// Used returns how many bytes in buffer have been used.
+func (rb *RingBuffer[T]) Used() uint8 {
+	return uint8(rb.head.Get() - rb.tail.Get())
+}
+
+// Put stores a byte in the buffer. If the buffer is already
+// full, the method will return false.
+func (rb *RingBuffer[T]) Put(val T) bool {
+	if rb.Used() != uint8(len(rb.buffer)) {
+		rb.head.Set(rb.head.Get() + 1)
+		rb.buffer[rb.head.Get()%uint8(len(rb.buffer))] = val
+		return true
+	}
+	return false
+}
+
+// Get returns a byte from the buffer. If the buffer is empty,
+// the method will return a false as the second value.
+func (rb *RingBuffer[T]) Get() (T, bool) {
+	if rb.Used() != 0 {
+		rb.tail.Set(rb.tail.Get() + 1)
+		return rb.buffer[rb.tail.Get()%uint8(len(rb.buffer))], true
+	}
+	var ret T
+	return ret, false
+}
+
+// Peek peeks a byte from the buffer. If the buffer is empty,
+// the method will return a false as the second value.
+func (rb *RingBuffer[T]) Peek() (T, bool) {
+	if rb.Used() != 0 {
+		return rb.buffer[(rb.tail.Get()+1)%uint8(len(rb.buffer))], true
+	}
+	var ret T
+	return ret, false
+}
+
+// Clear resets the head and tail pointer to zero.
+func (rb *RingBuffer[T]) Clear() {
+	rb.head.Set(0)
+	rb.tail.Set(0)
+}