BLE date time characteristic

[GarryMoveOut]

I have ESP32C3 with BLE. I creating board to save temperature measurements and then download it on phone with BLE. Currently reading current temperature and humid is working well. But my next step is to read time on ESP32 and then change it (if is wrong) to sync time. For now I do not have app for phone. Now for develop tests I use tool nRF Connect.

My problem is that I can not read date time I receive empty value in nRF Connect. I found some old forum post. I do not have access to Bluetooth specification, it is restricted. My next step will be writing time (not implemented below), firstly I want to read date and time. What is wrong with my code?

import bluetooth
import random
import struct
import time
from machine import Pin, SoftI2C  # importing relevant modules & classes
from time import sleep
from machine import RTC
import BME280
from ble_advertising import advertising_payload

from micropython import const

i2c = SoftI2C(scl=Pin(1), sda=Pin(2), freq=10000)

gled = Pin(4, Pin.OUT)
bled = Pin(5, Pin.OUT)

rtc = RTC()

# Bluetooth start
_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_INDICATE_DONE = const(20)
_IRQ_GATTS_WRITE = const(3)

_FLAG_READ = const(0x0002)
_FLAG_NOTIFY = const(0x0010)
_FLAG_WRITE_NO_RESPONSE = const(0x0004)
_FLAG_WRITE = const(0x0008)
_FLAG_INDICATE = const(0x0020)

# Environmental Sensing service
_ENV_SENSE_UUID = bluetooth.UUID(0x181A)
# Device Time service
_ENV_DEVICE_UUID = bluetooth.UUID(0x1847)
# org.bluetooth.characteristic.temperature
_TEMP_CHAR = (bluetooth.UUID(0x2A6E), _FLAG_READ | _FLAG_NOTIFY | _FLAG_INDICATE,)
_HUMID_CHAR = (bluetooth.UUID(0x2A6F), _FLAG_READ | _FLAG_NOTIFY | _FLAG_INDICATE,)
# org.bluetooth.characteristic.date_time
_TIME_RX = (bluetooth.UUID(0x2A08), _FLAG_WRITE | _FLAG_WRITE_NO_RESPONSE | _FLAG_READ,)
_TIME_TX = (bluetooth.UUID(0x2A08), _FLAG_READ | _FLAG_NOTIFY,)
_ENV_DEVICE_SERVICE = (_ENV_DEVICE_UUID, (_TIME_TX, _TIME_RX))
_ENV_SENSE_SERVICE = (_ENV_SENSE_UUID, (_TEMP_CHAR, _HUMID_CHAR),)

# org.bluetooth.characteristic.gap.appearance.xml
_ADV_APPEARANCE_GENERIC_THERMOMETER = const(768)


# Bluetooth end

class BLECar:
    def __init__(self, ble, name="BluBit"):
        print('Start init blecar')
        self._ble = ble
        self._ble.active(True)
        self._ble.irq(self._irq)
        ((self._temp_tx, self._humid_tx), (self._time_tx, self._time_rx)) = self._ble.gatts_register_services(
            (_ENV_SENSE_SERVICE, _ENV_DEVICE_SERVICE,))
        self._connections = set()
        self._write_callback_sense = None
        self._write_callback_device = None
        self._payload = advertising_payload(
            name=name, services=[_ENV_SENSE_UUID], appearance=_ADV_APPEARANCE_GENERIC_THERMOMETER
        )
        self._advertise()

    def _irq(self, event, data):
        # Track connections so we can send notifications.
        if event == _IRQ_CENTRAL_CONNECT:
            print('_IRQ_CENTRAL_CONNECT')
            bled.on()
            conn_handle, _, _ = data
            self._connections.add(conn_handle)
        elif event == _IRQ_CENTRAL_DISCONNECT:
            print('_IRQ_CENTRAL_DISCONNECT')
            bled.off()
            conn_handle, _, _ = data
            self._connections.remove(conn_handle)
            # Start advertising again to allow a new connection.
            self._advertise()
        elif event == _IRQ_GATTS_INDICATE_DONE:
            print('_IRQ_GATTS_INDICATE_DONE')
            conn_handle, value_handle, status = data
        elif event == _IRQ_GATTS_WRITE:
            print('_IRQ_GATTS_WRITE')
            conn_handle, value_handle = data
            value = self._ble.gatts_read(value_handle)
            if value_handle == self._time_rx and self._write_callback_device:
                print('_IRQ_GATTS_WRITE time_rx')
                self._write_callback_device(value)

    # Send temperature and notify subscribed
    def set_temperature(self, temp_deg_c:float, notify=False, indicate=False):
        print(">>>Sending temperature: " + str(temp_deg_c).format('{:.2f}'))
        # Data is sint16 in degrees Celsius with a resolution of 0.01 degrees Celsius.
        # Write the local value, ready for a central to read.
        # self._ble.gatts_write(self._sense_tx, struct.pack("<h", int(temp_deg_c * 100)))
        self._ble.gatts_write(self._temp_tx, struct.pack("<h", int(temp_deg_c * 100)))
        if notify or indicate:
            for conn_handle in self._connections:
                if notify:
                    # Notify connected centrals.
                    self._ble.gatts_notify(conn_handle, self._temp_tx)
                if indicate:
                    # Indicate connected centrals.
                    self._ble.gatts_indicate(conn_handle, self._temp_tx)

    # Send humidity and notify subscribed
    def set_humid(self, humid_perc:float, notify=False, indicate=False):
        print(">>>Sending temperature: " + str(humid_perc).format('{:.2f}'))
        self._ble.gatts_write(self._humid_tx, struct.pack("<H", int(humid_perc * 100)))
        if notify or indicate:
            for conn_handle in self._connections:
                if notify:
                    # Notify connected centrals.
                    self._ble.gatts_notify(conn_handle, self._humid_tx)
                if indicate:
                    # Indicate connected centrals.
                    self._ble.gatts_indicate(conn_handle, self._humid_tx)

    # Send time and notify subscribed
    def set_time(self, curr_time, notify=False, indicate=False):
        print(">>>Sending time: " + curr_time)
        # YYYY uint16, MM uint8, DD uint8, HH uint8, MM uint8, SS uint8,
        self._ble.gatts_write(self._temp_tx, struct.pack("<HBBBBB", 2023, 1, 13, 11, 40, 55)) # hard coded time only for test
        if notify or indicate:
            for conn_handle in self._connections:
                if notify:
                    # Notify connected centrals.
                    self._ble.gatts_notify(conn_handle, self._time_tx)
                if indicate:
                    # Indicate connected centrals.
                    self._ble.gatts_indicate(conn_handle, self._time_tx)

    # Receive rx
    def set_sense_callback(self, callback):
        print("set_sense_callback rx")
        self._write_callback_sense = callback

    def set_device_callback(self, callback):
        print("set_device_callback rx")
        self._write_callback_device = callback

    def _advertise(self, interval_us=500000):
        print("_advertise start")
        self._ble.gap_advertise(interval_us, adv_data=self._payload)


class Car:
    def __init__(self, ble_car):
        print("Init car")
        self.prev_temp = -99.0
        self.prev_humid = -1.0
        self.current_temp: float
        self.current_humid: float
        self.ble_car: BLECar = ble_car

    def refresh_temperature(self, temp: str) -> None:
        current_temp = float(temp[:-1])
        if abs(self.prev_temp - current_temp) > 1:
            print("Temperature change: " + str(abs(self.prev_temp - current_temp)))
            self.ble_car.set_temperature(current_temp, True, False)
            self.prev_temp = current_temp
        else:
            print("Minor temperature change")

    def refresh_humidity(self, humid: str) -> None:
        current_humid = float(humid[:-1])
        if abs(self.prev_humid - current_humid) > 1:
            print("Humidity change: " + str(abs(self.prev_humid - current_humid)))
            self.ble_car.set_humid(current_humid, True, False)
            self.prev_humid = current_humid
        else:
            print("Minor humidity change")

    def receive_sense_requst(self, data):
        bled.off()
        print("<<<Sense RX: " + data)
        bled.on()

    def receive_device_requst(self, data):
        bled.off()
        print("<<<Device RX: " + data)
        bled.on()


def main():
    print('Starting main')
    ble = bluetooth.BLE()
    ble_car = BLECar(ble)
    car = Car(ble_car)

    ble_car.set_sense_callback(car.receive_sense_requst)
    ble_car.set_device_callback(car.receive_device_requst)

    while True:
        bme = BME280.BME280(i2c=i2c)
        temperature: str = bme.temperature  # reading the value of temperature
        humidity: str = bme.humidity
        print('Readed temperature: ' + temperature + ' and humid: ' + humidity)
        gled.on()
        sleep(1)
        gled.off()

        car.refresh_temperature(temperature)
        car.refresh_humidity(humidity)
        ble_car.set_time("1970-01-01 00:00:00", True, False) #only for test fixed time

        time.sleep_ms(1000)


if __name__ == "__main__":
    main()

[jimmo]

@GarryMoveOut

Have you looked at aioble (https://github.com/micropython/micropython-lib/tree/master/micropython/bluetooth/aioble) -- it makes using BLE from MicroPython much simpler.

But my next step is to read time on ESP32 and then change it (if is wrong) to sync time.

I think the issue here is in your set_time method, writing to the wrong characteristic.

def set_time(self, curr_time, notify=False, indicate=False):
        print(">>>Sending time: " + curr_time)
        # YYYY uint16, MM uint8, DD uint8, HH uint8, MM uint8, SS uint8,
        self._ble.gatts_write(self._temp_tx, struct.pack("<HBBBBB", 2023, 1, 13, 11, 40, 55)) # hard coded time only for test
                                    ^^^^ should be self._time_tx

I do not have access to Bluetooth specification, it is restricted.

Which specification are you trying to access, I'm not aware of any restricted documents.

[GarryMoveOut]

@jimmo thank you very much, I changed self._temp_tx to self._time_tx and now read time is working, of course. I spend hours watching my code and I didn't notice this.
I didn't heard about that aioble, I will check it.