djsundog/circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

nrf: Move the Service class from ubluepy to the shared bleio module

Browse Source
This commit is contained in:
arturo182 2018-07-19 01:01:41 +02:00
parent cc78249226
commit bda734223e
15 changed files with 346 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ports/nrf/Makefile
View File

@ -130,7 +130,6 @@ SRC_C += \
DRIVERS_SRC_C += $(addprefix modules/,\
ubluepy/modubluepy.c \
ubluepy/ubluepy_peripheral.c \
ubluepy/ubluepy_service.c \
)
SRC_COMMON_HAL += \
@ -165,6 +164,7 @@ SRC_COMMON_HAL += \
bleio/Characteristic.c \
bleio/Descriptor.c \
bleio/Scanner.c \
bleio/Service.c \
bleio/UUID.c
endif

4
ports/nrf/common-hal/bleio/Characteristic.c
View File

@ -36,8 +36,8 @@ void common_hal_bleio_characteristic_read_value(bleio_characteristic_obj_t *self
}
void common_hal_bleio_characteristic_write_value(bleio_characteristic_obj_t *self, mp_buffer_info_t *bufinfo) {
ubluepy_service_obj_t *service = MP_OBJ_TO_PTR(self->service);
ubluepy_role_type_t role = service->p_periph->role;
ubluepy_peripheral_obj_t *peripheral = MP_OBJ_TO_PTR(self->service->periph);
ubluepy_role_type_t role = peripheral->role;
if (role == UBLUEPY_ROLE_PERIPHERAL) {
// TODO: Add indications

38
ports/nrf/common-hal/bleio/Service.c Normal file
View File

@ -0,0 +1,38 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2018 Artur Pacholec
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "ble_drv.h"
#include "shared-module/bleio/Service.h"
void common_hal_bleio_service_construct(bleio_service_obj_t *self) {
ble_drv_service_add(self);
}
void common_hal_bleio_service_add_characteristic(bleio_service_obj_t *self, bleio_characteristic_obj_t *characteristic) {
if (ble_drv_characteristic_add(characteristic)) {
characteristic->service = self;
}
}

71
ports/nrf/drivers/bluetooth/ble_drv.c
View File

@ -267,26 +267,29 @@ bool ble_drv_uuid_add_vs(uint8_t * p_uuid, uint8_t * idx) {
return true;
}
bool ble_drv_service_add(ubluepy_service_obj_t * p_service_obj) {
void ble_drv_service_add(bleio_service_obj_t *service) {
SD_TEST_OR_ENABLE();
ble_uuid_t uuid;
uuid.type = BLE_UUID_TYPE_BLE;
uuid.uuid = p_service_obj->p_uuid->value[0] | (p_service_obj->p_uuid->value[1] << 8);
ble_uuid_t uuid = {
.type = BLE_UUID_TYPE_BLE,
.uuid = service->uuid->value[0] | (service->uuid->value[1] << 8)
};
if (p_service_obj->p_uuid->type == UUID_TYPE_128BIT) {
uuid.type = p_service_obj->p_uuid->uuid_vs_idx;
if (service->uuid->type == UUID_TYPE_128BIT) {
uuid.type = service->uuid->uuid_vs_idx;
}
uint32_t err_code = sd_ble_gatts_service_add(p_service_obj->type,
&uuid,
&p_service_obj->handle);
if (err_code != 0) {
uint8_t service_type = BLE_GATTS_SRVC_TYPE_PRIMARY;
if (service->is_secondary) {
service_type = BLE_GATTS_SRVC_TYPE_SECONDARY;
}
if (sd_ble_gatts_service_add(service_type,
&uuid,
&service->handle) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
translate("Can not add Service. status: 0x%08lX"), err_code));
translate("Can not add Service.")));
}
return true;
}
bool ble_drv_characteristic_add(bleio_characteristic_obj_t *characteristic) {
@ -320,7 +323,7 @@ bool ble_drv_characteristic_add(bleio_characteristic_obj_t *characteristic) {
char_md.p_cccd_md = NULL;
}
uuid.type = BLE_UUID_TYPE_BLE;
uuid.type = BLE_UUID_TYPE_BLE;
if (characteristic->uuid->type == UUID_TYPE_128BIT)
uuid.type = characteristic->uuid->uuid_vs_idx;
@ -416,12 +419,12 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
bool type_128bit_present = false;
for (uint8_t i = 0; i < p_adv_params->num_of_services; i++) {
ubluepy_service_obj_t * p_service = (ubluepy_service_obj_t *)p_adv_params->p_services[i];
if (p_service->p_uuid->type == UUID_TYPE_16BIT) {
bleio_service_obj_t * p_service = (bleio_service_obj_t *)p_adv_params->p_services[i];
if (p_service->uuid->type == UUID_TYPE_16BIT) {
type_16bit_present = true;
}
if (p_service->p_uuid->type == UUID_TYPE_128BIT) {
if (p_service->uuid->type == UUID_TYPE_128BIT) {
type_128bit_present = true;
}
}
@ -439,12 +442,12 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
uint8_t encoded_size = 0;
for (uint8_t i = 0; i < p_adv_params->num_of_services; i++) {
ubluepy_service_obj_t * p_service = (ubluepy_service_obj_t *)p_adv_params->p_services[i];
bleio_service_obj_t * p_service = (bleio_service_obj_t *)p_adv_params->p_services[i];
ble_uuid_t uuid;
uuid.type = p_service->p_uuid->type;
uuid.uuid = p_service->p_uuid->value[0];
uuid.uuid += p_service->p_uuid->value[1] << 8;
uuid.type = p_service->uuid->type;
uuid.uuid = p_service->uuid->value[0];
uuid.uuid += p_service->uuid->value[1] << 8;
// calculate total size of uuids
if (sd_ble_uuid_encode(&uuid, &encoded_size, NULL) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
@ -488,12 +491,12 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
uint8_t encoded_size = 0;
for (uint8_t i = 0; i < p_adv_params->num_of_services; i++) {
ubluepy_service_obj_t * p_service = (ubluepy_service_obj_t *)p_adv_params->p_services[i];
bleio_service_obj_t * p_service = (bleio_service_obj_t *)p_adv_params->p_services[i];
ble_uuid_t uuid;
uuid.type = p_service->p_uuid->uuid_vs_idx;
uuid.uuid = p_service->p_uuid->value[0];
uuid.uuid += p_service->p_uuid->value[1] << 8;
uuid.type = p_service->uuid->uuid_vs_idx;
uuid.uuid = p_service->uuid->value[0];
uuid.uuid += p_service->uuid->value[1] << 8;
// calculate total size of uuids
if (sd_ble_uuid_encode(&uuid, &encoded_size, NULL) != 0) {
@ -640,8 +643,8 @@ void ble_drv_attr_s_read(uint16_t conn_handle, uint16_t handle, uint16_t len, ui
}
void ble_drv_attr_s_write(bleio_characteristic_obj_t *characteristic, mp_buffer_info_t *bufinfo) {
ubluepy_service_obj_t *service = MP_OBJ_TO_PTR(characteristic->service);
uint16_t conn_handle = service->p_periph->conn_handle;
ubluepy_peripheral_obj_t *peripheral = MP_OBJ_TO_PTR(characteristic->service->periph);
uint16_t conn_handle = peripheral->conn_handle;
ble_gatts_value_t gatts_value;
memset(&gatts_value, 0, sizeof(gatts_value));
@ -659,8 +662,8 @@ void ble_drv_attr_s_write(bleio_characteristic_obj_t *characteristic, mp_buffer_
}
void ble_drv_attr_s_notify(bleio_characteristic_obj_t *characteristic, mp_buffer_info_t *bufinfo) {
ubluepy_service_obj_t *service = MP_OBJ_TO_PTR(characteristic->service);
uint16_t conn_handle = service->p_periph->conn_handle;
ubluepy_peripheral_obj_t *peripheral = MP_OBJ_TO_PTR(characteristic->service->periph);
uint16_t conn_handle = peripheral->conn_handle;
ble_gatts_hvx_params_t hvx_params;
uint16_t hvx_len = bufinfo->len;
@ -706,11 +709,13 @@ void ble_drv_adv_report_handler_set(bleio_scanner_obj_t *self, ble_drv_adv_evt_c
void ble_drv_attr_c_read(bleio_characteristic_obj_t *characteristic, ble_drv_gattc_char_data_callback_t cb) {
ubluepy_service_obj_t *service = MP_OBJ_TO_PTR(characteristic->service);
bleio_service_obj_t *service = characteristic->service;
ubluepy_peripheral_obj_t *peripheral = MP_OBJ_TO_PTR(service->periph);
mp_gattc_char_data_observer = characteristic;
gattc_char_data_handle = cb;
const uint32_t err_code = sd_ble_gattc_read(service->p_periph->conn_handle,
const uint32_t err_code = sd_ble_gattc_read(peripheral->conn_handle,
characteristic->handle,
0);
if (err_code != 0) {
@ -724,8 +729,8 @@ void ble_drv_attr_c_read(bleio_characteristic_obj_t *characteristic, ble_drv_gat
}
void ble_drv_attr_c_write(bleio_characteristic_obj_t *characteristic, mp_buffer_info_t *bufinfo) {
ubluepy_service_obj_t *service = MP_OBJ_TO_PTR(characteristic->service);
uint16_t conn_handle = service->p_periph->conn_handle;
ubluepy_peripheral_obj_t *peripheral = MP_OBJ_TO_PTR(characteristic->service->periph);
uint16_t conn_handle = peripheral->conn_handle;
ble_gattc_write_params_t write_params;
write_params.write_op = BLE_GATT_OP_WRITE_REQ;

3
ports/nrf/drivers/bluetooth/ble_drv.h
View File

@ -34,6 +34,7 @@
#include "shared-module/bleio/Characteristic.h"
#include "shared-module/bleio/Scanner.h"
#include "shared-module/bleio/Service.h"
#include "modubluepy.h"
@ -92,7 +93,7 @@ void ble_drv_address_get(ble_drv_addr_t * p_addr);
bool ble_drv_uuid_add_vs(uint8_t * p_uuid, uint8_t * idx);
bool ble_drv_service_add(ubluepy_service_obj_t * p_service_obj);
void ble_drv_service_add(bleio_service_obj_t *service);
bool ble_drv_characteristic_add(bleio_characteristic_obj_t *characteristic);

1
ports/nrf/modules/ubluepy/modubluepy.c
View File

@ -36,7 +36,6 @@ STATIC const mp_rom_map_elem_t mp_module_ubluepy_globals_table[] = {
#if MICROPY_PY_UBLUEPY_PERIPHERAL
{ MP_ROM_QSTR(MP_QSTR_Peripheral), MP_ROM_PTR(&ubluepy_peripheral_type) },
#endif
{ MP_ROM_QSTR(MP_QSTR_Service), MP_ROM_PTR(&ubluepy_service_type) },
};
STATIC MP_DEFINE_CONST_DICT(mp_module_ubluepy_globals, mp_module_ubluepy_globals_table);

17
ports/nrf/modules/ubluepy/modubluepy.h
View File

@ -74,14 +74,8 @@ p.advertise(device_name="micr", services=[s])
#include "common-hal/bleio/UUID.h"
#include "py/obj.h"
extern const mp_obj_type_t ubluepy_service_type;
extern const mp_obj_type_t ubluepy_peripheral_type;
typedef enum {
UBLUEPY_SERVICE_PRIMARY = 1,
UBLUEPY_SERVICE_SECONDARY = 2
} ubluepy_service_type_t;
typedef enum {
UBLUEPY_ADDR_TYPE_PUBLIC = 0,
UBLUEPY_ADDR_TYPE_RANDOM_STATIC = 1,
@ -104,17 +98,6 @@ typedef struct _ubluepy_peripheral_obj_t {
mp_obj_t service_list;
} ubluepy_peripheral_obj_t;
typedef struct _ubluepy_service_obj_t {
mp_obj_base_t base;
uint16_t handle;
uint8_t type;
bleio_uuid_obj_t * p_uuid;
ubluepy_peripheral_obj_t * p_periph;
mp_obj_t char_list;
uint16_t start_handle;
uint16_t end_handle;
} ubluepy_service_obj_t;
typedef struct _ubluepy_advertise_data_t {
uint8_t * p_device_name;
uint8_t device_name_len;

17
ports/nrf/modules/ubluepy/ubluepy_peripheral.c
View File

@ -35,6 +35,7 @@
#include "ble_drv.h"
#include "common-hal/bleio/UUID.h"
#include "shared-bindings/bleio/Characteristic.h"
#include "shared-bindings/bleio/Service.h"
#include "shared-bindings/bleio/UUID.h"
STATIC void ubluepy_peripheral_print(const mp_print_t *print, mp_obj_t o, mp_print_kind_t kind) {
@ -271,9 +272,9 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(ubluepy_peripheral_disconnect_obj, peripheral_d
///
STATIC mp_obj_t peripheral_add_service(mp_obj_t self_in, mp_obj_t service) {
ubluepy_peripheral_obj_t * self = MP_OBJ_TO_PTR(self_in);
ubluepy_service_obj_t * p_service = MP_OBJ_TO_PTR(service);
bleio_service_obj_t * p_service = MP_OBJ_TO_PTR(service);
p_service->p_periph = self;
p_service->periph = self_in;
mp_obj_list_append(self->service_list, service);
@ -294,13 +295,13 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(ubluepy_peripheral_get_services_obj, peripheral
#if MICROPY_PY_UBLUEPY_CENTRAL
void static disc_add_service(mp_obj_t self, ble_drv_service_data_t * p_service_data) {
ubluepy_service_obj_t * p_service = m_new_obj(ubluepy_service_obj_t);
p_service->base.type = &ubluepy_service_type;
bleio_service_obj_t * p_service = m_new_obj(bleio_service_obj_t);
p_service->base.type = &bleio_service_type;
bleio_uuid_obj_t * p_uuid = m_new_obj(bleio_uuid_obj_t);
p_uuid->base.type = &bleio_uuid_type;
p_service->p_uuid = p_uuid;
p_service->uuid = p_uuid;
p_uuid->type = p_service_data->uuid_type;
p_uuid->value[0] = p_service_data->uuid & 0xFF;
@ -316,7 +317,7 @@ void static disc_add_service(mp_obj_t self, ble_drv_service_data_t * p_service_d
}
void static disc_add_char(mp_obj_t service_in, ble_drv_char_data_t * p_desc_data) {
ubluepy_service_obj_t * p_service = MP_OBJ_TO_PTR(service_in);
bleio_service_obj_t * p_service = MP_OBJ_TO_PTR(service_in);
bleio_characteristic_obj_t * p_char = m_new_obj(bleio_characteristic_obj_t);
p_char->base.type = &bleio_characteristic_type;
@ -410,7 +411,7 @@ STATIC mp_obj_t peripheral_connect(mp_uint_t n_args, const mp_obj_t *pos_args, m
mp_uint_t num_services;
mp_obj_get_array(self->service_list, &num_services, &services);
ubluepy_service_obj_t * p_service = (ubluepy_service_obj_t *)services[num_services - 1];
bleio_service_obj_t * p_service = (bleio_service_obj_t *)services[num_services - 1];
service_disc_retval = ble_drv_discover_services(self,
self->conn_handle,
@ -424,7 +425,7 @@ STATIC mp_obj_t peripheral_connect(mp_uint_t n_args, const mp_obj_t *pos_args, m
mp_obj_get_array(self->service_list, &num_services, &services);
for (uint16_t s = 0; s < num_services; s++) {
ubluepy_service_obj_t * p_service = (ubluepy_service_obj_t *)services[s];
bleio_service_obj_t * p_service = (bleio_service_obj_t *)services[s];
bool char_disc_retval = ble_drv_discover_characteristic(p_service,
self->conn_handle,
p_service->start_handle,

188
ports/nrf/modules/ubluepy/ubluepy_service.c
View File

@ -1,188 +0,0 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 Glenn Ruben Bakke
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/obj.h"
#include "py/runtime.h"
#include "py/objlist.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_UBLUEPY_PERIPHERAL || MICROPY_PY_UBLUEPY_CENTRAL
#include "modubluepy.h"
#include "ble_drv.h"
#include "common-hal/bleio/UUID.h"
#include "shared-bindings/bleio/UUID.h"
STATIC void ubluepy_service_print(const mp_print_t *print, mp_obj_t o, mp_print_kind_t kind) {
ubluepy_service_obj_t * self = (ubluepy_service_obj_t *)o;
mp_printf(print, "Service(handle: 0x" HEX2_FMT ")", self->handle);
}
STATIC mp_obj_t ubluepy_service_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
enum { ARG_NEW_UUID, ARG_NEW_TYPE };
static const mp_arg_t allowed_args[] = {
{ ARG_NEW_UUID, MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ ARG_NEW_TYPE, MP_ARG_INT, {.u_int = UBLUEPY_SERVICE_PRIMARY} },
};
// parse args
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
ubluepy_service_obj_t *s = m_new_obj(ubluepy_service_obj_t);
s->base.type = type;
mp_obj_t uuid_obj = args[ARG_NEW_UUID].u_obj;
if (uuid_obj == MP_OBJ_NULL) {
return MP_OBJ_FROM_PTR(s);
}
if (MP_OBJ_IS_TYPE(uuid_obj, &bleio_uuid_type)) {
s->p_uuid = MP_OBJ_TO_PTR(uuid_obj);
uint8_t type = args[ARG_NEW_TYPE].u_int;
if (type > 0 && type <= UBLUEPY_SERVICE_PRIMARY) {
s->type = type;
} else {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
translate("Invalid Service type")));
}
(void)ble_drv_service_add(s);
} else {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
translate("Invalid UUID parameter")));
}
// clear reference to peripheral
s->p_periph = NULL;
s->char_list = mp_obj_new_list(0, NULL);
return MP_OBJ_FROM_PTR(s);
}
/// \method addCharacteristic(Characteristic)
/// Add Characteristic to the Service.
///
STATIC mp_obj_t service_add_characteristic(mp_obj_t self_in, mp_obj_t characteristic) {
ubluepy_service_obj_t * self = MP_OBJ_TO_PTR(self_in);
bleio_characteristic_obj_t * p_char = MP_OBJ_TO_PTR(characteristic);
p_char->service_handle = self->handle;
bool retval = ble_drv_characteristic_add(p_char);
if (retval) {
p_char->service = self_in;
}
mp_obj_list_append(self->char_list, characteristic);
// return mp_obj_new_bool(retval);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(ubluepy_service_add_char_obj, service_add_characteristic);
/// \method getCharacteristics()
/// Return list with all characteristics registered in the Service.
///
STATIC mp_obj_t service_get_chars(mp_obj_t self_in) {
ubluepy_service_obj_t * self = MP_OBJ_TO_PTR(self_in);
return self->char_list;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(ubluepy_service_get_chars_obj, service_get_chars);
/// \method getCharacteristic(UUID)
/// Return Characteristic with the given UUID.
///
STATIC mp_obj_t service_get_characteristic(mp_obj_t self_in, mp_obj_t uuid) {
ubluepy_service_obj_t * self = MP_OBJ_TO_PTR(self_in);
bleio_uuid_obj_t * p_uuid = MP_OBJ_TO_PTR(uuid);
// validate that there is an UUID object passed in as parameter
if (!(MP_OBJ_IS_TYPE(uuid, &bleio_uuid_type))) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
translate("Invalid UUID parameter")));
}
mp_obj_t * chars = NULL;
mp_uint_t num_chars = 0;
mp_obj_get_array(self->char_list, &num_chars, &chars);
for (uint8_t i = 0; i < num_chars; i++) {
bleio_characteristic_obj_t * p_char = (bleio_characteristic_obj_t *)chars[i];
bool type_match = p_char->uuid->type == p_uuid->type;
bool uuid_match = ((uint16_t)(*(uint16_t *)&p_char->uuid->value[0]) ==
(uint16_t)(*(uint16_t *)&p_uuid->value[0]));
if (type_match && uuid_match) {
return MP_OBJ_FROM_PTR(p_char);
}
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(ubluepy_service_get_char_obj, service_get_characteristic);
/// \method uuid()
/// Get UUID instance of the Service.
///
STATIC mp_obj_t service_uuid(mp_obj_t self_in) {
ubluepy_service_obj_t * self = MP_OBJ_TO_PTR(self_in);
return MP_OBJ_FROM_PTR(self->p_uuid);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(ubluepy_service_get_uuid_obj, service_uuid);
STATIC const mp_rom_map_elem_t ubluepy_service_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_getCharacteristic), MP_ROM_PTR(&ubluepy_service_get_char_obj) },
{ MP_ROM_QSTR(MP_QSTR_addCharacteristic), MP_ROM_PTR(&ubluepy_service_add_char_obj) },
{ MP_ROM_QSTR(MP_QSTR_getCharacteristics), MP_ROM_PTR(&ubluepy_service_get_chars_obj) },
#if 0
// Properties
{ MP_ROM_QSTR(MP_QSTR_peripheral), MP_ROM_PTR(&ubluepy_service_get_peripheral_obj) },
#endif
{ MP_ROM_QSTR(MP_QSTR_uuid), MP_ROM_PTR(&ubluepy_service_get_uuid_obj) },
{ MP_ROM_QSTR(MP_QSTR_PRIMARY), MP_ROM_INT(UBLUEPY_SERVICE_PRIMARY) },
{ MP_ROM_QSTR(MP_QSTR_SECONDARY), MP_ROM_INT(UBLUEPY_SERVICE_SECONDARY) },
};
STATIC MP_DEFINE_CONST_DICT(ubluepy_service_locals_dict, ubluepy_service_locals_dict_table);
const mp_obj_type_t ubluepy_service_type = {
{ &mp_type_type },
.name = MP_QSTR_Service,
.print = ubluepy_service_print,
.make_new = ubluepy_service_make_new,
.locals_dict = (mp_obj_dict_t*)&ubluepy_service_locals_dict
};
#endif // MICROPY_PY_UBLUEPY_PERIPHERAL || MICROPY_PY_UBLUEPY_CENTRAL

4
shared-bindings/bleio/Characteristic.c
View File

@ -91,14 +91,14 @@ STATIC void bleio_characteristic_print(const mp_print_t *print, mp_obj_t self_in
bleio_characteristic_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "Characteristic(uuid: 0x"HEX2_FMT""HEX2_FMT" handle: 0x" HEX2_FMT ")",
self->uuid->value[0], self->uuid->value[1], self->handle);
self->uuid->value[1], self->uuid->value[0], self->handle);
}
STATIC mp_obj_t bleio_characteristic_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *pos_args) {
mp_arg_check_num(n_args, n_kw, 1, 1, true);
bleio_characteristic_obj_t *self = m_new_obj(bleio_characteristic_obj_t);
self->base.type = &bleio_characteristic_type;
self->service = mp_const_none;
self->service = NULL;
self->value_data = NULL;
mp_map_t kw_args;

167
shared-bindings/bleio/Service.c Normal file
View File

@ -0,0 +1,167 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 Glenn Ruben Bakke
* Copyright (c) 2018 Artur Pacholec
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/objproperty.h"
#include "py/runtime.h"
#include "shared-bindings/bleio/Service.h"
#include "shared-bindings/bleio/UUID.h"
//| .. currentmodule:: bleio
//|
//| :class:`Service` -- BLE service
//| =========================================================
//|
//| Stores information about a BLE service and its characteristics.
//|
//| .. class:: Service(uuid, secondary=False)
//|
//| Create a new Service object identified by the specified UUID.
//| To mark the service as secondary, pass `True` as :py:data:`secondary`.
//|
//| :param uuid: The uuid of the service
//|
//| .. method:: add_characteristic(characteristic)
//|
//| Appends the :py:data:`characteristic` to the list of this service's characteristics.
//|
//| :param bleio.Characteristic characteristic: the characteristic to append
//|
//| .. attribute:: characteristics
//|
//| A `list` of `bleio.Characteristic` that are offered by this service. (read-only)
//|
//| .. attribute:: uuid
//|
//| The UUID of this service. (read-only)
//|
STATIC void bleio_service_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
bleio_service_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "Service(uuid: 0x"HEX2_FMT""HEX2_FMT")",
self->uuid->value[1], self->uuid->value[0]);
}
STATIC mp_obj_t bleio_service_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *pos_args) {
mp_arg_check_num(n_args, n_kw, 1, 1, true);
bleio_service_obj_t *self = m_new_obj(bleio_service_obj_t);
self->base.type = &bleio_service_type;
self->periph = mp_const_none;
self->char_list = mp_obj_new_list(0, NULL);
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw, pos_args + n_args);
enum { ARG_uuid, ARG_secondary };
static const mp_arg_t allowed_args[] = {
{ ARG_uuid, MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_secondary, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, &kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
self->is_secondary = args[ARG_secondary].u_bool;
const mp_obj_t uuid = args[ARG_uuid].u_obj;
if (uuid == MP_OBJ_NULL) {
return MP_OBJ_FROM_PTR(self);
}
if (MP_OBJ_IS_TYPE(uuid, &bleio_uuid_type)) {
self->uuid = MP_OBJ_TO_PTR(uuid);
} else {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
"Invalid UUID parameter"));
}
common_hal_bleio_service_construct(self);
return MP_OBJ_FROM_PTR(self);
}
STATIC mp_obj_t bleio_service_add_characteristic(mp_obj_t self_in, mp_obj_t characteristic_in) {
bleio_service_obj_t *self = MP_OBJ_TO_PTR(self_in);
bleio_characteristic_obj_t *characteristic = MP_OBJ_TO_PTR(characteristic_in);
characteristic->service_handle = self->handle;
common_hal_bleio_service_add_characteristic(self, characteristic);
mp_obj_list_append(self->char_list, characteristic);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(bleio_service_add_characteristic_obj, bleio_service_add_characteristic);
STATIC mp_obj_t bleio_service_get_characteristics(mp_obj_t self_in) {
bleio_service_obj_t *self = MP_OBJ_TO_PTR(self_in);
return self->char_list;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(bleio_service_get_characteristics_obj, bleio_service_get_characteristics);
const mp_obj_property_t bleio_service_characteristics_obj = {
.base.type = &mp_type_property,
.proxy = { (mp_obj_t)&bleio_service_get_characteristics_obj,
(mp_obj_t)&mp_const_none_obj,
(mp_obj_t)&mp_const_none_obj },
};
STATIC mp_obj_t bleio_service_get_uuid(mp_obj_t self_in) {
bleio_service_obj_t *self = MP_OBJ_TO_PTR(self_in);
return MP_OBJ_FROM_PTR(self->uuid);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(bleio_service_get_uuid_obj, bleio_service_get_uuid);
const mp_obj_property_t bleio_service_uuid_obj = {
.base.type = &mp_type_property,
.proxy = { (mp_obj_t)&bleio_service_get_uuid_obj,
(mp_obj_t)&mp_const_none_obj,
(mp_obj_t)&mp_const_none_obj },
};
STATIC const mp_rom_map_elem_t bleio_service_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_add_characteristic), MP_ROM_PTR(&bleio_service_add_characteristic_obj) },
{ MP_ROM_QSTR(MP_QSTR_characteristics), MP_ROM_PTR(&bleio_service_characteristics_obj) },
{ MP_ROM_QSTR(MP_QSTR_uuid), MP_ROM_PTR(&bleio_service_uuid_obj) },
};
STATIC MP_DEFINE_CONST_DICT(bleio_service_locals_dict, bleio_service_locals_dict_table);
const mp_obj_type_t bleio_service_type = {
{ &mp_type_type },
.name = MP_QSTR_Service,
.print = bleio_service_print,
.make_new = bleio_service_make_new,
.locals_dict = (mp_obj_dict_t*)&bleio_service_locals_dict
};

38
shared-bindings/bleio/Service.h Normal file
View File

@ -0,0 +1,38 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2018 Artur Pacholec
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_BLEIO_SERVICE_H
#define MICROPY_INCLUDED_SHARED_BINDINGS_BLEIO_SERVICE_H
#include "shared-module/bleio/Characteristic.h"
#include "shared-module/bleio/Service.h"
const mp_obj_type_t bleio_service_type;
extern void common_hal_bleio_service_construct(bleio_service_obj_t *self);
extern void common_hal_bleio_service_add_characteristic(bleio_service_obj_t *self, bleio_characteristic_obj_t *characteristic);
#endif // MICROPY_INCLUDED_SHARED_BINDINGS_BLEIO_SERVICE_H

4
shared-bindings/bleio/__init__.c
View File

@ -25,7 +25,6 @@
* THE SOFTWARE.
*/
#include "py/obj.h"
#include "shared-bindings/bleio/__init__.h"
#include "shared-bindings/bleio/Address.h"
#include "shared-bindings/bleio/AddressType.h"
@ -34,6 +33,7 @@
#include "shared-bindings/bleio/Descriptor.h"
#include "shared-bindings/bleio/ScanEntry.h"
#include "shared-bindings/bleio/Scanner.h"
#include "shared-bindings/bleio/Service.h"
#include "shared-bindings/bleio/UUID.h"
#include "shared-bindings/bleio/UUIDType.h"
@ -59,6 +59,7 @@
//| Descriptor
//| ScanEntry
//| Scanner
//| Service
//| UUID
//| UUIDType
//|
@ -77,6 +78,7 @@ STATIC const mp_rom_map_elem_t bleio_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR_Descriptor), MP_ROM_PTR(&bleio_descriptor_type) },
{ MP_ROM_QSTR(MP_QSTR_ScanEntry), MP_ROM_PTR(&bleio_scanentry_type) },
{ MP_ROM_QSTR(MP_QSTR_Scanner), MP_ROM_PTR(&bleio_scanner_type) },
{ MP_ROM_QSTR(MP_QSTR_Service), MP_ROM_PTR(&bleio_service_type) },
{ MP_ROM_QSTR(MP_QSTR_UUID), MP_ROM_PTR(&bleio_uuid_type) },
// Properties

3
shared-module/bleio/Characteristic.h
View File

@ -27,11 +27,12 @@
#ifndef MICROPY_INCLUDED_SHARED_MODULE_BLEIO_CHARACTERISTIC_H
#define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_CHARACTERISTIC_H
#include "shared-module/bleio/Service.h"
#include "common-hal/bleio/UUID.h"
typedef struct {
mp_obj_base_t base;
mp_obj_t service;
bleio_service_obj_t *service;
uint16_t service_handle;
bleio_uuid_obj_t *uuid;
mp_obj_t value_data;

44
shared-module/bleio/Service.h Normal file
View File

@ -0,0 +1,44 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2018 Artur Pacholec
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SERVICE_H
#define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SERVICE_H
#include "modubluepy.h"
#include "common-hal/bleio/UUID.h"
typedef struct {
mp_obj_base_t base;
uint16_t handle;
bool is_secondary;
bleio_uuid_obj_t *uuid;
mp_obj_t periph;
mp_obj_t char_list;
uint16_t start_handle;
uint16_t end_handle;
} bleio_service_obj_t;
#endif // MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SERVICE_H