ESP32c3 - micropython aioble . Communication between BLE server and client with possibility of an ack message.

[BOB63]

For a my project I've implemented a BLE server with two buttons that based on which button is pressed send
two different commands to a BLE client that then drive two different strips of ws2812 led.

The two codes attached are based on some basic examples code found on the web adapted for my scope.

Both codes seems work quite well but the problem is that sometime also if the buttons are pressed
and the relative isr is activated , for some reason the client dosen't receive any command.

Due that I must be sure the the command is received I would like implement on the client a sort
of aknoledge message to be sent back to the server as confirmation of received command , and in case the server
dosen't receive an aknoledge within a certain time send the same command again.

To do that I've tryed to implemented in both side two additional characteristics to be used only
to communicate/recive the ack message , but I'm not able to see any ack message on the server side
also If I don't have apparently any error during runtime .

Where I'm wrong ?
Client and servers can both send and receive data one to/from each other ?

This is the code SERVER side :

# program based on micropython example:
# https://github.com/micropython/micropython-lib/blob/master/micropython/bluetooth/aioble/examples/temp_sensor.pyimport sys

# SERVER

from micropython import const
from machine import Pin
import time
import asyncio
import aioble
import bluetooth

import random
import struct
debounce_delay = 80  

flg_left=False
flg_right=False
sent_left=False
sent_right=False

counter=0
counter_l=0
counter_r=0

# def pin input buttons

bt_left  = Pin(1, Pin.IN, Pin.PULL_UP)   # left
bt_right = Pin(0, Pin.IN, Pin.PULL_UP)   # right

def left_tx(Pin):
    #print('left')
    global flg_left
    global flg_right
    global sent_left
    global sent_right
    global counter_l
    global debounce_delay
    last_debounce_time = time.ticks_ms()
    while (time.ticks_diff(time.ticks_ms(), last_debounce_time) < debounce_delay):
          pass
    if bt_left.value()==0:   
       counter_l=counter_l+1
       #print(counter_l)
       flg_left = True
       flg_right = False
       sent_left= True
       sent_right=False
        
    
def right_tx(Pin):
    #print('right')
    global flg_left
    global flg_right
    global sent_right
    global sent_left
    global counter_r
    global debounce_delay
    
    last_debounce_time = time.ticks_ms()
    while (time.ticks_diff(time.ticks_ms(), last_debounce_time) < debounce_delay):
          pass
    if bt_right.value()==0:   
       counter_r=counter_r+1
       #print(counter_r)
       flg_right =True
       flg_left = False
       sent_right= True
       sent_left=False
    
    
# set interrupt and ISR 
bt_right.irq(trigger=Pin.IRQ_FALLING ,handler=right_tx)
bt_left.irq(trigger=Pin.IRQ_FALLING ,handler=left_tx)

# org.bluetooth.service.environmental_sensing
# https://www.bluetooth.com/wp-content/uploads/Files/Specification/Assigned_Numbers.html
_ENV_FRECCE_UUID = bluetooth.UUID(0xAAAA)

# org.bluetooth.characteristic.temperature
# https://www.bluetooth.com/wp-content/uploads/Files/Specification/Assigned_Numbers.html
_ENV_LEFT_UUID_TX = bluetooth.UUID(0x1111)  
_ENV_RIGHT_UUID_TX = bluetooth.UUID(0x2222)
_ENV_LEFT_UUID_ACK = bluetooth.UUID(0x1110)   # used as ack msg 
_ENV_RIGHT_UUID_ACK = bluetooth.UUID(0x2220)  # used as ack msg 


# org.bluetooth.characteristic.gap.appearance.xml
# https://developer.nordicsemi.com/nRF5_SDK/nRF51_SDK_v4.x.x/doc/html/group___b_l_e___a_p_p_e_a_r_a_n_c_e_s.html
_ADV_APPEARANCE_GENERIC_DEVICE = const(384)   # REMOTE CONTROL

# How frequently to send advertising beacons.
_ADV_INTERVAL_MS = 250


# Register GATT server  
frecce_service = aioble.Service(_ENV_FRECCE_UUID)
left_characteristic = aioble.Characteristic(
    frecce_service, _ENV_LEFT_UUID_TX, read=True, notify=True
)

right_characteristic = aioble.Characteristic(
    frecce_service, _ENV_RIGHT_UUID_TX, read=True, notify=True
)

left_characteristic_ACK = aioble.Characteristic(
    frecce_service, _ENV_LEFT_UUID_ACK, write=True, notify=True
)

right_characteristic_ACK = aioble.Characteristic(
    frecce_service, _ENV_RIGHT_UUID_ACK, write=True, notify=True
)

aioble.register_services(frecce_service)



def _encode_comand(comand):
    
    return comand.encode('UTF-8')


async def direction_task():
    global flg_left
    global flg_right
    global sent_left
    global sent_right
    global counter_l
    global counter_r
    global counter
    while True:
        
        if (flg_left == True) and (flg_right == False) and (sent_left==True):
        
           direzione='left_on_' +str(counter_l) #+' flg_L:'+str(int(flg_left))+' flg_R:'+str(int(flg_right))+' sent_L:'+str(int(sent_left))+' sent_R:'+str(int(sent_right))
           print(direzione)
           left_characteristic.write(_encode_comand(direzione), send_update=True)
           flg_left = False
           sent_left=False
           await ack_msg()
           
        if (flg_right == True) and (flg_left == False) and (sent_right==True):
                
           direzione='right_on_'+str(counter_r) 
           print(direzione)
           right_characteristic.write(_encode_comand(direzione), send_update=True)
           flg_right = False
           sent_right=False
           await ack_msg()
           

        await asyncio.sleep_ms(250)
        
        if (flg_right == False) and (sent_right==False) and ( sent_right==False) and (sent_left==False):
           counter=counter+1
           direzione='none_' 
           #print(direzione)
           right_characteristic.write(_encode_comand(direzione), send_update=True)
           left_characteristic.write(_encode_comand(direzione), send_update=True)
           
        await asyncio.sleep_ms(200)
        
async def ack_msg():
      print('wait ack')
      left_comb= await left_characteristic_ACK.read()
      print(left_comb)




# Serially wait for connections. Don't advertise while a central is
# connected.

async def peripheral_task():
    while True:
        async with await aioble.advertise(
            _ADV_INTERVAL_MS,
            name="bycicle-light",
            services=[_ENV_FRECCE_UUID],
            appearance=_ADV_APPEARANCE_GENERIC_DEVICE,
            ) as connection:
            print("Connection from", connection.device)
            await connection.disconnected(timeout_ms=None)


# Run both tasks.
async def main():
    t1 = asyncio.create_task(direction_task())
    t2 = asyncio.create_task(peripheral_task())
    #t3 = asyncio.create_task(ack_msg())
    await asyncio.gather(t1, t2)


asyncio.run(main())

This is the CLIENT code :

      # https://github.com/micropython/micropyrathon-lib/blob/master/micropython/bluetooth/aioble/examples/temp_sensor.py

#  CLIENT

import sys
sys.path.append("")

from micropython import const
from machine import Pin
import machine, neopixel, time
import asyncio
import aioble
import bluetooth

import random
import struct

# org.bluetooth.service.environmental_sensing
_ENV_SENSE_UUID = bluetooth.UUID(0xAAAA)
# org.bluetooth.characteristic.temperature
# aggiungere un entry per ogni caretteristica 
_ENV_LEFT_UUID_RX = bluetooth.UUID(0x1111) 
_ENV_RIGHT_UUID_RX = bluetooth.UUID(0x2222)

_ENV_LEFT_UUID_ACK = bluetooth.UUID(0x1110)   # USED TO SEND BACK ACK TO SERVER
_ENV_RIGHT_UUID_ACK = bluetooth.UUID(0x2220)  # USED TO SEND BACK ACK TO SERVER

# Register GATT server  vedi line 16 Temp_client_studio.py.
frecce_service = aioble.Service(_ENV_SENSE_UUID)
left_characteristic = aioble.Characteristic(frecce_service, _ENV_LEFT_UUID_RX, read=True,write=True ,notify=True)

right_characteristic = aioble.Characteristic(frecce_service, _ENV_RIGHT_UUID_RX, read=True,write=True,notify=True)

left_characteristic_ACK = aioble.Characteristic(frecce_service, _ENV_LEFT_UUID_ACK, write=True ,notify=True)

right_characteristic_ACK = aioble.Characteristic(frecce_service, _ENV_RIGHT_UUID_ACK,write=True,notify=True)


aioble.register_services(frecce_service)

# LED strip configuration   ////////////////////////////////////
# number of pixels
n = 8
# neopixel control gpio
left_pin_drv=0
right_pin_drv=1
flg_left = False
flg_right = False
left_neopx = neopixel.NeoPixel(machine.Pin(left_pin_drv), n)
right_neopx = neopixel.NeoPixel(machine.Pin(right_pin_drv), n)
#///////////////////////////////////////////////////////////////

def left_sign(r, g, b, wait):
global flg_left
global n
print('........................  left ricevuto')
start=time.ticks_ms()
while time.ticks_ms()-start<3000:
    if flg_left==True:
        
        for i in range(n):
            left_neopx[i] = (r, g, b)
            left_neopx.write()
            await asyncio.sleep_ms(wait)
            #time.sleep_ms(wait)
        for i in range(n):   
            left_neopx[i] = (0,0,0)
            left_neopx.write()
            await asyncio.sleep_ms(wait)
            #time.sleep_ms(wait)
    
flg_left==False
return 'll'


def right_sign(r, g, b, wait):
global flg_right
global n
print('........................  right ricevuto')
start=time.ticks_ms()
while time.ticks_ms()-start<3000:
    if flg_right==True:
        
        for i in range(n):
            right_neopx[i] = (r, g, b)
            right_neopx.write()
            await asyncio.sleep_ms(wait)
            #time.sleep_ms(wait)
        for i in range(n):   
            right_neopx[i] = (0,0,0)
            right_neopx.write()
            await asyncio.sleep_ms(wait)
            #time.sleep_ms(wait)
    #await clear_left()
flg_right==False
return 'rr'


# turn off all pixels
def clear_left():
for i in range(n):
    left_neopx[i] = (0, 0, 0)
    left_neopx.write()
 

async def clear_right():
for i in range(n):
    right_neopx[i] = (0, 0, 0)
    right_neopx.write()


async def find_tx_device():
  # Scan for 5 seconds, in active mode, with very low interval/window (to
  # maximise detection rate).
  async with aioble.scan(5000, interval_us=30000, window_us=30000, active=True) as scanner:
      async for result in scanner:
          # See if it matches our name and the environmental sensing service.
          if result.name() == "bycicle-light" and _ENV_SENSE_UUID in result.services():
             return result.device
  return None

async def main():
  clear_left()
  clear_right()
  global flg_left
  global flg_right
  device = await find_tx_device()
  if not device:
      print("Tx device not found")
      return
  try:
      print("Connecting to", device)
      connection = await device.connect()
  except asyncio.TimeoutError:
      print("Timeout during connection")
      return

  async with connection:
      
      try:
          dev_service = await connection.service(_ENV_SENSE_UUID)
          left_characteristic = await dev_service.characteristic(_ENV_LEFT_UUID_RX)
          right_characteristic = await dev_service.characteristic(_ENV_RIGHT_UUID_RX)
      except asyncio.TimeoutError:
            print("Timeout discovering services/characteristics")
            return
              
      while connection.is_connected():
          
            left_comb= await left_characteristic.read()
            print(left_comb)
            left_com=left_comb.decode('utf8').split('_')
            right_com= await right_characteristic.read()
            right_com=right_com.decode('utf8').split('_')
            
            if (left_com[0]=='left' and left_com[1]=='on'):
                print("Cmd L: {}".format(left_com))
                flg_left=True
                #await clear_right()
                fbl=await left_sign(10,0,0,30)
                print(fbl)
                left_characteristic_ACK.write(b'ok_l', send_update=True)  # try to send back and ack msg
                
            if (right_com[0]=='right' and right_com[1]=='on'):
                print("Cmd R: {}".format(right_com))
                flg_right=True
                #await clear_left()
                #await right_sign(10,0,0,30)
                fbr=await right_sign(10,0,0,30)
                print(fbr)
                right_characteristic_ACK.write(b'ok_r', send_update=True)  # try to send back and ack msg
                
asyncio.run(main())


 

[BOB63]

hi,
Is there any alternative to inform a BLE Server if a BLE Client as received a specific data pack?

[redhead-p]

I would have expected your LEDs strips to be on the peripheral device that offers the service (the server) and the buttons to be on the central device that accesses the service as a client. I.e the other way around.

However there are ways to ensure message integrity. Have a look at BLE notifications and indications. I've used notifications on the BLE api direct, but don't know if they are available via aioble.

[BOB63]

Thanks @redhead-p ,
I'll try to give a look to Ble notification.
I hope to find an example about how implement.

[bidrohini]

You can implement a mechanism on the server to wait for an acknowledgement and resend the command if no acknowledgement is received within a specified timeout.

[BOB63]

@bidrohini ,
yes, is exactly what I'm looking to do.
Let's see If I find he way.