Commit cf79316

#if BLUETOOTH_SD

#if MICROPY_PY_BLE_NUS

static bleio_uuid_obj_t uuid_obj_service = {

.base.type = &bleio_uuid_type,

.type = UUID_128_BIT,

.value = {0x01, 0x00}

};

static bleio_uuid_obj_t uuid_obj_char_tx = {

.base.type = &bleio_uuid_type,

.type = UUID_128_BIT,

.value = {0x03, 0x00}

};

static bleio_uuid_obj_t uuid_obj_char_rx = {

.base.type = &bleio_uuid_type,

.type = UUID_128_BIT,

.value = {0x02, 0x00}

};

static ubluepy_service_obj_t ble_uart_service = {

.base.type = &ubluepy_service_type,

.p_uuid = &uuid_obj_service,

.type = UBLUEPY_SERVICE_PRIMARY

};

static ubluepy_characteristic_obj_t ble_uart_char_rx = {

.base.type = &ubluepy_characteristic_type,

.p_uuid = &uuid_obj_char_rx,

.props = UBLUEPY_PROP_WRITE | UBLUEPY_PROP_WRITE_WO_RESP,

.attrs = 0,

};

static ubluepy_characteristic_obj_t ble_uart_char_tx = {

.base.type = &ubluepy_characteristic_type,

.p_uuid = &uuid_obj_char_tx,

.props = UBLUEPY_PROP_NOTIFY,

.attrs = UBLUEPY_ATTR_CCCD,

static ubluepy_peripheral_obj_t ble_uart_peripheral = {

.base.type = &ubluepy_peripheral_type,

.conn_handle = 0xFFFF,

};

static volatile bool m_cccd_enabled;

static volatile bool m_connected;

ringBuffer_typedef(uint8_t, ringbuffer_t);

static ringbuffer_t m_rx_ring_buffer;

static ringbuffer_t * mp_rx_ring_buffer = &m_rx_ring_buffer;

static uint8_t m_rx_ring_buffer_data[128];

static ubluepy_advertise_data_t m_adv_data_uart_service;

static ubluepy_advertise_data_t m_adv_data_eddystone_url;

int mp_hal_stdin_rx_chr(void) {

while (isBufferEmpty(mp_rx_ring_buffer)) {

;

bufferRead(mp_rx_ring_buffer, byte);

bool mp_hal_stdin_any(void) {

return !isBufferEmpty(mp_rx_ring_buffer);

uint8_t *buf = (uint8_t *)str;

if (len >= 20) {

send_len = 20; // (GATT_MTU_SIZE_DEFAULT - 3)

ubluepy_characteristic_obj_t * p_char = &ble_uart_char_tx;

ble_drv_attr_s_notify(p_char->p_service->p_periph->conn_handle,

p_char->handle,

send_len,

buf);

buf += send_len;

void mp_hal_stdout_tx_strn_cooked(const char *str, mp_uint_t len) {

mp_hal_stdout_tx_strn(str, len);

}

STATIC void gap_event_handler(mp_obj_t self_in, uint16_t event_id, uint16_t conn_handle, uint16_t length, uint8_t * data) {

ubluepy_peripheral_obj_t * self = MP_OBJ_TO_PTR(self_in);

if (event_id == 16) { // connect event

self->conn_handle = conn_handle;

m_connected = true;

} else if (event_id == 17) { // disconnect event

self->conn_handle = 0xFFFF; // invalid connection handle

m_connected = false;

ble_uart_advertise();

}

}

STATIC void gatts_event_handler(mp_obj_t self_in, uint16_t event_id, uint16_t attr_handle, uint16_t length, uint8_t * data) {

ubluepy_peripheral_obj_t * self = MP_OBJ_TO_PTR(self_in);

(void)self;

if (event_id == 80) { // gatts write

if (ble_uart_char_tx.cccd_handle == attr_handle) {

m_cccd_enabled = true;

} else if (ble_uart_char_rx.handle == attr_handle) {

for (uint16_t i = 0; i < length; i++) {

#if MICROPY_KBD_EXCEPTION

if (data[i] == mp_interrupt_char) {

mp_keyboard_interrupt();

} else

#endif

{

bufferWrite(mp_rx_ring_buffer, data[i]);

}

}

}

}

}

void ble_uart_init0(void) {

uint8_t base_uuid[] = {0x9E, 0xCA, 0xDC, 0x24, 0x0E, 0xE5, 0xA9, 0xE0, 0x93, 0xF3, 0xA3, 0xB5, 0x00, 0x00, 0x40, 0x6E};

uint8_t uuid_vs_idx;

(void)ble_drv_uuid_add_vs(base_uuid, &uuid_vs_idx);

uuid_obj_service.uuid_vs_idx = uuid_vs_idx;

uuid_obj_char_tx.uuid_vs_idx = uuid_vs_idx;

uuid_obj_char_rx.uuid_vs_idx = uuid_vs_idx;

(void)ble_drv_service_add(&ble_uart_service);

ble_uart_service.char_list = mp_obj_new_list(0, NULL);

// add TX characteristic

ble_uart_char_tx.service_handle = ble_uart_service.handle;

bool retval = ble_drv_characteristic_add(&ble_uart_char_tx);

if (retval) {

ble_uart_char_tx.p_service = &ble_uart_service;

}

mp_obj_list_append(ble_uart_service.char_list, MP_OBJ_FROM_PTR(&ble_uart_char_tx));

// add RX characteristic

ble_uart_char_rx.service_handle = ble_uart_service.handle;

retval = ble_drv_characteristic_add(&ble_uart_char_rx);

if (retval) {

ble_uart_char_rx.p_service = &ble_uart_service;

}

mp_obj_list_append(ble_uart_service.char_list, MP_OBJ_FROM_PTR(&ble_uart_char_rx));

// setup the peripheral

ble_uart_peripheral.service_list = mp_obj_new_list(0, NULL);

mp_obj_list_append(ble_uart_peripheral.service_list, MP_OBJ_FROM_PTR(&ble_uart_service));

ble_uart_service.p_periph = &ble_uart_peripheral;

ble_drv_gap_event_handler_set(MP_OBJ_FROM_PTR(&ble_uart_peripheral), gap_event_handler);

ble_drv_gatts_event_handler_set(MP_OBJ_FROM_PTR(&ble_uart_peripheral), gatts_event_handler);

ble_uart_peripheral.conn_handle = 0xFFFF;

char device_name[] = "mpus";

mp_obj_t service_list = mp_obj_new_list(0, NULL);

mp_obj_list_append(service_list, MP_OBJ_FROM_PTR(&ble_uart_service));

mp_obj_t * services = NULL;

mp_uint_t num_services;

mp_obj_get_array(service_list, &num_services, &services);

m_adv_data_uart_service.p_services = services;

m_adv_data_uart_service.num_of_services = num_services;

m_adv_data_uart_service.p_device_name = (uint8_t *)device_name;

m_adv_data_uart_service.device_name_len = strlen(device_name);

m_adv_data_uart_service.connectable = true;

m_adv_data_uart_service.p_data = NULL;

#if BLUETOOTH_WEBBLUETOOTH_REPL

// for now point eddystone URL to https://goo.gl/x46FES => https://glennrub.github.io/webbluetooth/micropython/repl/

static uint8_t eddystone_url_data[27] = {0x2, 0x1, 0x6,

0x3, 0x3, 0xaa, 0xfe,

19, 0x16, 0xaa, 0xfe, 0x10, 0xee, 0x3, 'g', 'o', 'o', '.', 'g', 'l', '/', 'x', '4', '6', 'F', 'E', 'S'};

// eddystone url adv data

m_adv_data_eddystone_url.p_data = eddystone_url_data;

m_adv_data_eddystone_url.data_len = sizeof(eddystone_url_data);

m_adv_data_eddystone_url.connectable = false;

m_cccd_enabled = false;

// initialize ring buffer

m_rx_ring_buffer.size = sizeof(m_rx_ring_buffer_data) + 1;

m_rx_ring_buffer.start = 0;

m_rx_ring_buffer.end = 0;

m_rx_ring_buffer.elems = m_rx_ring_buffer_data;

m_connected = false;

ble_uart_advertise();

}

void ble_uart_advertise(void) {

#if BLUETOOTH_WEBBLUETOOTH_REPL

while (!m_connected) {

(void)ble_drv_advertise_data(&m_adv_data_uart_service);

mp_hal_delay_ms(500);

(void)ble_drv_advertise_data(&m_adv_data_eddystone_url);

mp_hal_delay_ms(500);

}

ble_drv_advertise_stop();

(void)ble_drv_advertise_data(&m_adv_data_uart_service);

#endif // BLUETOOTH_WEBBLUETOOTH_REPL

}

bool ble_uart_connected(void) {

return (m_connected);

}

bool ble_uart_enabled(void) {

return (m_cccd_enabled);

}

#endif // BLUETOOTH_SD