/**
* The main program.
*/
int main(int argc, char* argv[])
{
struct gecko_cmd_packet *evt, *rsp;
/**
* Initialize BGLIB with our output function for sending messages.
*/
BGLIB_INITIALIZE(on_message_send, uart_rx);
if (hw_init(argc, argv) < 0)
{
printf("Hardware initialization failure, check serial port and baud rate values\n");
exit(EXIT_FAILURE);
}
/**
* Display welcome message.
*/
printf("\nBlue Gecko WSTK GPIO BLE Peripheral Application\n");
printf("-----------------------------------------------\n\n");
// trigger reset manually with an API command instead
printf("--> Resetting device\n\tgecko_cmd_system_reset(0)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_system_reset(0);
printf("\n--- No reponse expected, should go directly to 'system_boot' event\n");
printf("--- If this does not occur, please reset the module to trigger it\n\n");
// ========================================================================================
// This infinite loop is similar to the BGScript interpreter environment, and each "case"
// represents one of the event handlers that you would define using BGScript code. You can
// restructure this code to use your own function calls instead of placing all of the event
// handler logic right inside each "case" block.
// ========================================================================================
while (1)
{
// blocking wait for event API packet
evt = gecko_wait_event();
// if a non-blocking implementation is needed, use gecko_peek_event() instead
// (will return NULL instead of packet struct pointer if no event is ready)
switch (BGLIB_MSG_ID(evt -> header))
{
// SYSTEM BOOT (power-on/reset)
case gecko_evt_system_boot_id:
// VERBOSE PACKET OUTPUT
printf("<-- Received event:\n\tgecko_evt_system_boot(%d, %d, %d, %d, %d, %d)\n",
evt->data.evt_system_boot.major,
evt->data.evt_system_boot.minor,
evt->data.evt_system_boot.patch,
evt->data.evt_system_boot.build,
evt->data.evt_system_boot.bootloader,
evt->data.evt_system_boot.hw
);
// set device name (will appear in active scans and readable GATT characteristic)
printf("--> Setting device name:\n\tgecko_cmd_gatt_server_write_attribute_value(%d, 0, 16, \"BGM111 GPIO Demo\")\n",
gattdb_device_name);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_write_attribute_value(gattdb_device_name, 0, 16, "BGM111 GPIO Demo");
printf("<-- Received response:\n\tgecko_rsp_gatt_server_write_attribute_value(0x%04X)\n",
rsp->data.rsp_gatt_server_write_attribute_value.result);
// start advertisements after boot/reset
printf("--> Starting advertisements:\n\tgecko_cmd_le_gap_set_mode(2, 2)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_le_gap_set_mode(le_gap_general_discoverable, le_gap_undirected_connectable);
printf("<-- Received response:\n\tgecko_rsp_gap_set_mode(0x%04X)\n",
rsp->data.rsp_le_gap_set_mode.result);
printf("\n--- AWAITING CONNECTION FROM BLE MASTER\n\n");
break;
// LE CONNECTION OPENED (remote device connected)
case gecko_evt_le_connection_opened_id:
// VERBOSE PACKET OUTPUT
printf("<-- Received event:\n\tgecko_evt_le_connection_opened(%02X:%02X:%02X:%02X:%02X:%02X, %d, %d, %d, 0x%02X)\n",
evt->data.evt_le_connection_opened.address.addr[5], // <-- address is little-endian
evt->data.evt_le_connection_opened.address.addr[4],
evt->data.evt_le_connection_opened.address.addr[3],
evt->data.evt_le_connection_opened.address.addr[2],
evt->data.evt_le_connection_opened.address.addr[1],
evt->data.evt_le_connection_opened.address.addr[0],
evt->data.evt_le_connection_opened.address_type,
evt->data.evt_le_connection_opened.master,
evt->data.evt_le_connection_opened.connection,
evt->data.evt_le_connection_opened.bonding
);
// update connection state var
connection_state = 1;
connection_handle = evt->data.evt_le_connection_opened.connection;
// start soft timer for GPIO polling
printf("--> Starting 50ms repeating timer for button status polling\n\thardware_set_soft_timer(205, 0, 0)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_set_soft_timer(205, 0, 0);
printf("<-- Received response:\n\tgecko_rsp_hardware_set_soft_timer(0x%04X)\n",
rsp->data.rsp_hardware_set_soft_timer.result);
break;
// LE CONNECTION CLOSED (remote device disconnected)
case gecko_evt_le_connection_closed_id:
// VERBOSE PACKET OUTPUT
printf("<-- Received event:\n\tgecko_evt_le_connection_closed(%d, 0x%04X)\n",
evt->data.evt_le_connection_closed.connection,
evt->data.evt_le_connection_closed.reason
);
// update status vars
connection_state = 0;
subscription_state = 0;
// stop soft timer for GPIO polling
printf("--> Ending 50ms repeating timer for button status polling\n\thardware_set_soft_timer(0, 0, 0)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_set_soft_timer(0, 0, 0);
printf("<-- Received response:\n\tgecko_rsp_hardware_set_soft_timer(0x%04X)\n",
rsp->data.rsp_hardware_set_soft_timer.result);
// restart advertisements after disconnection
printf("--> Restarting advertisements\n\tgecko_cmd_le_gap_set_mode(0x02, 0x02)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_le_gap_set_mode(le_gap_general_discoverable, le_gap_undirected_connectable);
printf("<-- Received response:\n\tgecko_rsp_gap_set_mode(0x%04X)\n",
rsp -> data.rsp_le_gap_set_mode.result);
printf("\n--- AWAITING CONNECTION FROM BLE MASTER\n\n");
break;
// GATT SERVER CHARACTERISTIC STATUS (remote GATT client changed subscription status)
case gecko_evt_gatt_server_characteristic_status_id:
// VERBOSE PACKET OUTPUT
printf("<-- Received event:\n\tgecko_evt_gatt_server_characteristic_status(%d, %d, 0x%02X, 0x%04X)\n",
evt->data.evt_gatt_server_characteristic_status.connection,
evt->data.evt_gatt_server_characteristic_status.characteristic,
evt->data.evt_gatt_server_characteristic_status.status_flags,
evt->data.evt_gatt_server_characteristic_status.client_config_flags
);
// make sure this is on the correct characteristic
if (evt->data.evt_gatt_server_characteristic_status.characteristic == gattdb_gpio_control)
{
// make sure this update corresponds to a change in configuration status
if (evt->data.evt_gatt_server_characteristic_status.status_flags == gatt_server_client_config)
{
// client characteristic configuration status changed for GPIO control
if (evt->data.evt_gatt_server_characteristic_status.client_config_flags & gatt_indication)
{
printf("\n--- INDICATIONS ENABLED ON GPIO CHARACTERISTIC\n");
printf("\n--- Button1 press will now push value to client\n\n");
// update status vars
subscription_state = 1;
// read PF7 GPIO state to detect button press status immediately
//printf("--> Reading PF7 state\n\thardware_read_gpio(5, 0x0080)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_read_gpio(5, 0x0080);
// TODO: bugfix in BGLib - this response packet doesn't map correctly
uint8_t *b = (uint8_t *)rsp;
uint16_t manual_gpio_data = b[2] | (b[3] << 8);
/*
printf("<-- Received response:\n\tgecko_rsp_hardware_read_gpio(0x%04X, 0x%04X)\n",
rsp->data.rsp_hardware_read_gpio.result,
manual_gpio_data);
//rsp->data.rsp_hardware_read_gpio.data);
//*/
//button_state = (rsp->data.rsp_hardware_read_gpio.data & 0x0080) ? 0 : 1; // logic high = not pressed, logic low = pressed
button_state = (manual_gpio_data & 0x0080) != 0 ? 0 : 1; // logic high = not pressed, logic low = pressed
// push current status to client so they have it available
printf("--> Pushing current PF7 state to client immediately\n\tgecko_cmd_gatt_server_send_characteristic_notification(%d, %d, 1, [ 0x%02X ])\n",
evt->data.evt_gatt_server_characteristic_status.connection,
evt->data.evt_gatt_server_characteristic_status.characteristic,
button_state
);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_characteristic_notification(
evt->data.evt_gatt_server_characteristic_status.connection,
evt->data.evt_gatt_server_characteristic_status.characteristic,
1,
&button_state);
printf("<-- Received response:\n\tgatt_server_send_characteristic_notification(0x%04X)\n",
rsp->data.rsp_gatt_server_send_characteristic_notification.result);
}
else
{
// update status vars
subscription_state = 0;
printf("\n--- INDICATIONS DISABLED ON GPIO CHARACTERISTIC\n");
printf("\n--- Button1 press will no longer push value to client\n\n");
}
}
}
else
{
// how did this happen? the GATT structure only has one indication-enabled characteristic
printf("\n--- STATUS UPDATED ON UNEXPECTED CHARACTERISTIC\n");
printf("--- (not a problem, just...very strange)\n\n");
}
break;
// GATT SERVER USER READ REQUEST (remote GATT client is reading a value from a user-type characteristic)
case gecko_evt_gatt_server_user_read_request_id:
// VERBOSE PACKET OUTPUT
printf("<-- Received event:\n\tgecko_evt_gatt_server_user_read_request(%d, %d, %d, %d)\n",
evt->data.evt_gatt_server_user_read_request.connection,
evt->data.evt_gatt_server_user_read_request.characteristic,
evt->data.evt_gatt_server_user_read_request.att_opcode,
evt->data.evt_gatt_server_user_read_request.offset
);
// make sure this is on the correct characteristic
if (evt->data.evt_gatt_server_user_read_request.characteristic == gattdb_gpio_control)
{
// read PF7 GPIO state to detect button press status
//printf("--> Reading PF7 state\n\thardware_read_gpio(5, 0x0080)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_read_gpio(5, 0x0080);
// TODO: bugfix in BGLib - this response packet doesn't map correctly
uint8_t *b = (uint8_t *)rsp;
uint16_t manual_gpio_data = b[2] | (b[3] << 8);
/*
printf("<-- Received response:\n\tgecko_rsp_hardware_read_gpio(0x%04X, 0x%04X)\n",
rsp->data.rsp_hardware_read_gpio.result,
manual_gpio_data);
//rsp->data.rsp_hardware_read_gpio.data);
//*/
//button_state = (rsp->data.rsp_hardware_read_gpio.data & 0x0080) ? 0 : 1;
button_state = (manual_gpio_data & 0x0080) != 0 ? 0 : 1;
// send back "success" response packet with value manually (GATT structure has `type="user"` set)
printf("--> Sending success response for read request\n\tgecko_cmd_gatt_server_send_user_read_response(%d, %d, 0x00, 1, [ 0x%02X ])\n",
evt->data.evt_gatt_server_user_read_request.connection,
evt->data.evt_gatt_server_user_read_request.characteristic,
button_state);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_read_response(
evt->data.evt_gatt_server_user_read_request.connection,
evt->data.evt_gatt_server_user_read_request.characteristic,
0x00, /* SUCCESS */
0x01, /* length */
&button_state);
printf("<-- Received response:\n\tgecko_rsp_gatt_server_send_user_read_response(0x%04X)\n",
rsp->data.rsp_gatt_server_send_user_write_response.result);
}
else
{
// send 0x81 error response for invalid characteristic (shouldn't be able to happen, but let's be safe)
// send back "error" response packet manually (GATT structure has `type="user"` set)
printf("--> Sending error response for write operation\n\tgecko_cmd_gatt_server_send_user_write_response(%d, %d, 0x81)\n",
evt->data.evt_gatt_server_attribute_value.connection,
evt->data.evt_gatt_server_attribute_value.attribute);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_attribute_value.connection,
evt->data.evt_gatt_server_attribute_value.attribute,
0x81 /* CUSTOM ERROR (0x80-0xFF are user-defined) */);
printf("<-- Received response:\n\tgecko_rsp_gatt_server_send_user_write_response(0x%04X)\n",
rsp->data.rsp_gatt_server_send_user_write_response.result);
}
break;
// GATT SERVER USER WRITE REQUEST (remote GATT client wrote a new value to a user-type characteristic)
case gecko_evt_gatt_server_user_write_request_id:
// VERBOSE PACKET OUTPUT
printf("<-- Received event:\n\tgecko_evt_gatt_server_user_write_request(%d, %d, %d, %d, [ ",
evt->data.evt_gatt_server_user_write_request.connection,
evt->data.evt_gatt_server_user_write_request.characteristic,
evt->data.evt_gatt_server_user_write_request.att_opcode,
evt->data.evt_gatt_server_user_write_request.offset
);
for (int i = 0; i < evt->data.evt_gatt_server_user_write_request.value.len; i++)
printf("%02X ", evt->data.evt_gatt_server_user_write_request.value.data[i]);
printf("])\n");
// make sure this is on the correct characteristic
if (evt->data.evt_gatt_server_user_read_request.characteristic == gattdb_gpio_control)
{
// set LED0 (PF6) off/on based on zero/non-zero status of written byte
if (evt->data.evt_gatt_server_user_write_request.value.len == 1)
{
// valid byte string, so process it
if (evt->data.evt_gatt_server_user_write_request.value.data[0])
{
// non-zero byte written, turn LED0 on
printf("--> Turning on LED0 (PF6 low)\n\tgecko_cmd_hardware_write_gpio(0x05, 0x0040, 0x0000)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_write_gpio(5, 0x40, 0x00);
printf("<-- Received response:\n\tgecko_rsp_hardware_write_gpio(0x%04X)\n",
rsp->data.rsp_hardware_write_gpio.result);
}
else
{
// zero byte written, turn LED0 off
printf("--> Turning off LED0 (PF6 high)\n\tgecko_cmd_hardware_write_gpio(0x05, 0x0040, 0x0040)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_write_gpio(5, 0x40, 0x40);
printf("<-- Received response:\n\tgecko_rsp_hardware_write_gpio(0x%04X)\n",
rsp->data.rsp_hardware_write_gpio.result);
}
// send back "success" response packet manually (GATT structure has `type="user"` set)
printf("--> Sending success response for write operation\n\tgecko_cmd_gatt_server_send_user_write_response(%d, %d, 0x00)\n",
evt->data.evt_gatt_server_user_write_request.connection,
evt->data.evt_gatt_server_user_write_request.characteristic);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_user_write_request.connection,
evt->data.evt_gatt_server_user_write_request.characteristic,
0x00 /* SUCCESS */);
printf("<-- Received response:\n\tgecko_rsp_gatt_server_send_user_write_response(0x%04X)\n",
rsp->data.rsp_gatt_server_send_user_write_response.result);
}
else
{
// invalid byte string, so don't process change anything with LEDs and send error response 0x80
// send back "error" response packet manually (GATT structure has `type="user"` set)
printf("--> Sending error response for write operation\n\tgecko_cmd_gatt_server_send_user_write_response(%d, %d, 0x80)\n",
evt->data.evt_gatt_server_attribute_value.connection,
evt->data.evt_gatt_server_attribute_value.attribute);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_attribute_value.connection,
evt->data.evt_gatt_server_attribute_value.attribute,
0x80 /* CUSTOM ERROR (0x80-0xFF are user-defined) */);
printf("<-- Received response:\n\tgecko_rsp_gatt_server_send_user_write_response(0x%04X)\n",
rsp->data.rsp_gatt_server_send_user_write_response.result);
}
}
else
{
// send 0x81 error response for invalid characteristic (shouldn't be able to happen, but let's be safe)
// send back "error" response packet manually (GATT structure has `type="user"` set)
printf("--> Sending error response for write operation\n\tgecko_cmd_gatt_server_send_user_write_response(%d, %d, 0x81)\n",
evt->data.evt_gatt_server_attribute_value.connection,
evt->data.evt_gatt_server_attribute_value.attribute);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_attribute_value.connection,
evt->data.evt_gatt_server_attribute_value.attribute,
0x81 /* CUSTOM ERROR (0x80-0xFF are user-defined) */);
printf("<-- Received response:\n\tgecko_rsp_gatt_server_send_user_write_response(0x%04X)\n",
rsp->data.rsp_gatt_server_send_user_write_response.result);
}
break;
case gecko_evt_hardware_soft_timer_id:
// VERBOSE PACKET OUTPUT
// NOTE: this is suppresed because it would generate a LOT of useless content
/*
printf("<-- Received event:\n\tgecko_evt_hardware_soft_timer(%d)\n",
evt->data.evt_hardware_soft_timer.handle
);
*/
// skip all of this if we're not connected but there are any residual timer
// events still occurring (may be some API processing gap here)
if (!connection_state)
break;
// make sure this is the correct timer (we scheduled handle 0 above)
if (evt->data.evt_hardware_soft_timer.handle == 0)
{
// read PF7 GPIO state to detect button press status
//printf("--> Reading PF7 state\n\thardware_read_gpio(5, 0x0080)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_read_gpio(5, 0x0080);
// TODO: bugfix in BGLib - this response packet doesn't map correctly
uint8_t *b = (uint8_t *)rsp;
uint16_t manual_gpio_data = b[2] | (b[3] << 8);
/*
printf("<-- Received response:\n\tgecko_rsp_hardware_read_gpio(0x%04X, 0x%04X)\n",
rsp->data.rsp_hardware_read_gpio.result,
manual_gpio_data);
//rsp->data.rsp_hardware_read_gpio.data);
//*/
// compare with last known status
//if (button_state != ((rsp->data.rsp_hardware_read_gpio.data & 0x0080) ? 0 : 1))
if (button_state != ((manual_gpio_data & 0x0080) != 0 ? 0 : 1))
{
// update button_state
//button_state = (rsp->data.rsp_hardware_read_gpio.data & 0x0080) ? 0 : 1; // logic high = not pressed, logic low = pressed
button_state = (manual_gpio_data & 0x0080) != 0 ? 0 : 1; // logic high = not pressed, logic low = pressed
// check to see if the client is subscribed to indications
if (subscription_state)
{
// push updated status to client
printf("--> Pushing current PF7 state to client immediately\n\tgecko_cmd_gatt_server_send_characteristic_notification(%d, %d, 1, [ 0x%02X ])\n",
connection_handle,
gattdb_gpio_control,
button_state
);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_characteristic_notification(
connection_handle,
gattdb_gpio_control,
1,
&button_state);
printf("<-- Received response:\n\tgatt_server_send_characteristic_notification(0x%04X)\n",
rsp->data.rsp_hardware_read_gpio.result);
}
}
}
break;
}
}
return 0;
}
/**
* The main program.
*/
int main(int argc, char* argv[])
{
struct gecko_cmd_packet *evt, *rsp;
/**
* Initialize BGLIB with our output function for sending messages.
*/
BGLIB_INITIALIZE(on_message_send, uart_rx);
if (hw_init(argc, argv) < 0)
{
printf("Hardware initialization failure, check serial port and baud rate values\n");
exit(EXIT_FAILURE);
}
/**
* Display welcome message.
*/
printf("\nBlue Gecko WSTK GPIO BLE Peripheral Application\n");
printf("-----------------------------------------------\n\n");
// trigger reset manually with an API command instead
printf("--> Resetting device\n\tgecko_cmd_system_reset(0)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_system_reset(0);
printf("\n--- No reponse expected, should go directly to 'system_boot' event\n");
printf("--- If this does not occur, please reset the module to trigger it\n\n");
// ========================================================================================
// This infinite loop is similar to the BGScript interpreter environment, and each "case"
// represents one of the event handlers that you would define using BGScript code. You can
// restructure this code to use your own function calls instead of placing all of the event
// handler logic right inside each "case" block.
// ========================================================================================
while (1)
{
// blocking wait for event API packet
evt = gecko_wait_event();
// if a non-blocking implementation is needed, use gecko_peek_event() instead
// (will return NULL instead of packet struct pointer if no event is ready)
switch (BGLIB_MSG_ID(evt -> header))
{
// SYSTEM BOOT (power-on/reset)
case gecko_evt_system_boot_id:
// set device name (will appear in active scans and readable GATT characteristic)
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_write_attribute_value(gattdb_device_name, 0, 16, "BGM111 GPIO Demo");
// start advertisements after boot/reset
rsp = (struct gecko_cmd_packet *)gecko_cmd_le_gap_set_mode(le_gap_general_discoverable, le_gap_undirected_connectable);
break;
// LE CONNECTION OPENED (remote device connected)
case gecko_evt_le_connection_opened_id:
// update connection state var
connection_state = 1;
connection_handle = evt->data.evt_le_connection_opened.connection;
// start soft timer for GPIO polling
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_set_soft_timer(205, 0, 0);
break;
// LE CONNECTION CLOSED (remote device disconnected)
case gecko_evt_le_connection_closed_id:
// update status vars
connection_state = 0;
subscription_state = 0;
// stop soft timer for GPIO polling
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_set_soft_timer(0, 0, 0);
// restart advertisements after disconnection
rsp = (struct gecko_cmd_packet *)gecko_cmd_le_gap_set_mode(le_gap_general_discoverable, le_gap_undirected_connectable);
break;
// GATT SERVER CHARACTERISTIC STATUS (remote GATT client changed subscription status)
case gecko_evt_gatt_server_characteristic_status_id:
// make sure this is on the correct characteristic
if (evt->data.evt_gatt_server_characteristic_status.characteristic == gattdb_gpio_control)
{
// make sure this update corresponds to a change in configuration status
if (evt->data.evt_gatt_server_characteristic_status.status_flags == gatt_server_client_config)
{
// client characteristic configuration status changed for GPIO control
if (evt->data.evt_gatt_server_characteristic_status.client_config_flags & gatt_indication)
{
// update status vars
subscription_state = 1;
// read PF7 GPIO state to detect button press status immediately
//printf("--> Reading PF7 state\n\thardware_read_gpio(5, 0x0080)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_read_gpio(5, 0x0080);
// TODO: bugfix in BGLib - this response packet doesn't map correctly
uint8_t *b = (uint8_t *)rsp;
uint16_t manual_gpio_data = b[2] | (b[3] << 8);
//button_state = (rsp->data.rsp_hardware_read_gpio.data & 0x0080) ? 0 : 1; // logic high = not pressed, logic low = pressed
button_state = (manual_gpio_data & 0x0080) != 0 ? 0 : 1; // logic high = not pressed, logic low = pressed
// push current status to client so they have it available
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_characteristic_notification(
evt->data.evt_gatt_server_characteristic_status.connection,
evt->data.evt_gatt_server_characteristic_status.characteristic,
1,
&button_state);
}
else
{
// update status vars
subscription_state = 0;
}
}
}
break;
// GATT SERVER USER READ REQUEST (remote GATT client is reading a value from a user-type characteristic)
case gecko_evt_gatt_server_user_read_request_id:
// make sure this is on the correct characteristic
if (evt->data.evt_gatt_server_user_read_request.characteristic == gattdb_gpio_control)
{
// read PF7 GPIO state to detect button press status
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_read_gpio(5, 0x0080);
// TODO: bugfix in BGLib - this response packet doesn't map correctly
uint8_t *b = (uint8_t *)rsp;
uint16_t manual_gpio_data = b[2] | (b[3] << 8);
//button_state = (rsp->data.rsp_hardware_read_gpio.data & 0x0080) ? 0 : 1;
button_state = (manual_gpio_data & 0x0080) != 0 ? 0 : 1;
// send back "success" response packet with value manually (GATT structure has `type="user"` set)
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_read_response(
evt->data.evt_gatt_server_user_read_request.connection,
evt->data.evt_gatt_server_user_read_request.characteristic,
0x00, /* SUCCESS */
0x01, /* length */
&button_state);
}
else
{
// send 0x81 error response for invalid characteristic (shouldn't be able to happen, but let's be safe)
// send back "error" response packet manually (GATT structure has `type="user"` set)
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_attribute_value.connection,
evt->data.evt_gatt_server_attribute_value.attribute,
0x81 /* CUSTOM ERROR (0x80-0xFF are user-defined) */);
}
break;
// GATT SERVER USER WRITE REQUEST (remote GATT client wrote a new value to a user-type characteristic)
case gecko_evt_gatt_server_user_write_request_id:
// make sure this is on the correct characteristic
if (evt->data.evt_gatt_server_user_read_request.characteristic == gattdb_gpio_control)
{
// set LED0 (PF6) off/on based on zero/non-zero status of written byte
if (evt->data.evt_gatt_server_user_write_request.value.len == 1)
{
// valid byte string, so process it
if (evt->data.evt_gatt_server_user_write_request.value.data[0])
{
// non-zero byte written, turn LED0 on
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_write_gpio(5, 0x40, 0x00);
}
else
{
// zero byte written, turn LED0 off
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_write_gpio(5, 0x40, 0x40);
}
// send back "success" response packet manually (GATT structure has `type="user"` set)
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_user_write_request.connection,
evt->data.evt_gatt_server_user_write_request.characteristic,
0x00 /* SUCCESS */);
}
else
{
// invalid byte string, so don't process change anything with LEDs and send error response 0x80
// send back "error" response packet manually (GATT structure has `type="user"` set)
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_attribute_value.connection,
evt->data.evt_gatt_server_attribute_value.attribute,
0x80 /* CUSTOM ERROR (0x80-0xFF are user-defined) */);
}
}
else
{
// send 0x81 error response for invalid characteristic (shouldn't be able to happen, but let's be safe)
// send back "error" response packet manually (GATT structure has `type="user"` set)
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_attribute_value.connection,
evt->data.evt_gatt_server_attribute_value.attribute,
0x81 /* CUSTOM ERROR (0x80-0xFF are user-defined) */);
}
break;
case gecko_evt_hardware_soft_timer_id:
// skip all of this if we're not connected but there are any residual timer
// events still occurring (may be some API processing gap here)
if (!connection_state)
break;
// make sure this is the correct timer (we scheduled handle 0 above)
if (evt->data.evt_hardware_soft_timer.handle == 0)
{
// read PF7 GPIO state to detect button press status
//printf("--> Reading PF7 state\n\thardware_read_gpio(5, 0x0080)\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_read_gpio(5, 0x0080);
// TODO: bugfix in BGLib - this response packet doesn't map correctly
uint8_t *b = (uint8_t *)rsp;
uint16_t manual_gpio_data = b[2] | (b[3] << 8);
// compare with last known status
//if (button_state != ((rsp->data.rsp_hardware_read_gpio.data & 0x0080) ? 0 : 1))
if (button_state != ((manual_gpio_data & 0x0080) != 0 ? 0 : 1))
{
// update button_state
//button_state = (rsp->data.rsp_hardware_read_gpio.data & 0x0080) ? 0 : 1; // logic high = not pressed, logic low = pressed
button_state = (manual_gpio_data & 0x0080) != 0 ? 0 : 1; // logic high = not pressed, logic low = pressed
// check to see if the client is subscribed to indications
if (subscription_state)
{
// push updated status to client
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_characteristic_notification(
connection_handle,
gattdb_gpio_control,
1,
&button_state);
}
}
}
break;
}
}
return 0;
}
int main(int argc, char* argv[]){
// Setup
struct gecko_cmd_packet *evt, *rsp;
BGLIB_INITIALIZE(on_message_send, uart_rx);
// Init Hardware
if (uart_open(uart_port, baud_rate) < 0){
printf("Hardware initialization failure, check serial port and baud rate values\n");
exit(EXIT_FAILURE);
}
// Appliction start
printf("Starting TTK8 demo app\n\n");
printf("If device doesn't reset automatically, reset it manually\n");
// Start thred for handling input
pthread_t input_thr;
pthread_create(&input_thr, NULL, handle_input, NULL);
// Reset BGM111
rsp = (struct gecko_cmd_packet *)gecko_cmd_system_reset(0);
while (1){
evt = gecko_wait_event(); // Blocking wait
switch (BGLIB_MSG_ID(evt -> header)) {
// Reset/Boot
case gecko_evt_system_boot_id:
printf("Device reset\n");
// Set device name
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_write_attribute_value(gattdb_device_name, 0, 13, application_name);
// Start advertising
rsp = (struct gecko_cmd_packet *)gecko_cmd_le_gap_set_mode(le_gap_general_discoverable, le_gap_undirected_connectable);
printf("Waiting for connection...\n");
printf("\n");
break;
case gecko_evt_le_connection_opened_id:
printf("Connected to %02X:%02X:%02X:%02X:%02X:%02X\n\n",
evt->data.evt_le_connection_opened.address.addr[5],
evt->data.evt_le_connection_opened.address.addr[4],
evt->data.evt_le_connection_opened.address.addr[3],
evt->data.evt_le_connection_opened.address.addr[2],
evt->data.evt_le_connection_opened.address.addr[1],
evt->data.evt_le_connection_opened.address.addr[0]);
connection_handle = evt->data.evt_le_connection_opened.connection;
break;
case gecko_evt_le_connection_closed_id:
printf("\nDisconnected\n");
rsp = (struct gecko_cmd_packet *)gecko_cmd_le_gap_set_mode(le_gap_general_discoverable, le_gap_undirected_connectable);
// Makes sure timer is off when disconnecting
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_set_soft_timer(0, 0, 0);
printf("Waiting for connection...\n\n");
break;
case gecko_evt_gatt_server_user_read_request_id:
printf("Read request\n");
if (evt->data.evt_gatt_server_user_read_request.characteristic == gattdb_indication_control){
printf("Sending ( %c ) to conected device\n", ch);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_read_response(
evt->data.evt_gatt_server_user_read_request.connection,
evt->data.evt_gatt_server_user_read_request.characteristic,
0x00, /* SUCCESS */
0x01, /* length */
&ch);
if (!rsp->data.rsp_gatt_server_send_user_write_response.result){
printf("Read successful\n");
}
else {
printf("Read not successful\n");
}
}
else {
printf("Something went wrong\n"); // Request for characteristic which doesn't exist(in this application)
}
printf("\n");
break;
case gecko_evt_gatt_server_user_write_request_id:
if (evt->data.evt_gatt_server_user_read_request.characteristic == gattdb_gpio_control){
printf("Write request\n");
if (evt->data.evt_gatt_server_user_write_request.value.len == 1){
if (evt->data.evt_gatt_server_user_write_request.value.data[0] == 0x01){
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_write_gpio(5, 0x40, 0x00);
printf("Led turned ON\n");
}
else if (evt->data.evt_gatt_server_user_write_request.value.data[0] == 0x00){
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_write_gpio(5, 0x40, 0x40);
printf("Led turned OFF\n");
}
}
// Sends success message back(the device might excpect a response)
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_user_write_request.connection,
evt->data.evt_gatt_server_user_write_request.characteristic,
0x00 /* SUCCESS */);
}
else {
printf("Something went wrong"); // Request for characteristic which doesn't exist(in this application)
}
printf("\n");
break;
case gecko_evt_gatt_server_characteristic_status_id:
//printf("Connection trying to change subscription\n");
if (evt->data.evt_gatt_server_characteristic_status.characteristic == gattdb_indication_control){
// 1 means changed subscition, 2 means confirmation has been received.
if (evt->data.evt_gatt_server_characteristic_status.status_flags == gatt_server_client_config){
if (evt->data.evt_gatt_server_characteristic_status.client_config_flags & gatt_indication){
subscription_state = 1;
printf("Indication enabled\n");
printf("Starting timer...");
// Start timer, 205 is said to be 50ms. Not sure how to set the timer to the right interval. This does not result in 1s.
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_set_soft_timer(205*2*10, 0, 0);
if (rsp){
printf("Timer started\n");
}
else {
printf("Timer not started\n");
}
printf("Sending ( %c ) to conected device (indication)\n", ch);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_characteristic_notification(
evt->data.evt_gatt_server_characteristic_status.connection,
gattdb_indication_control,
1,
&ch);
}
else {
subscription_state = 0;
printf("Indication disabled\n");
// Stop timer
rsp = (struct gecko_cmd_packet *)gecko_cmd_hardware_set_soft_timer(0, 0, 0);
}
}
else {
//printf("Confirmed\n");
break;
}
}
else {
printf("Something went wrong\n"); // Request for characteristic which doesn't exist(in this application)
}
printf("\n");
break;
// Most printfs are disabled so the console wont be flooded
case gecko_evt_hardware_soft_timer_id:
//printf("Timer event\n");
// Checks if its from the right timer, handle assigned earlier
if (evt->data.evt_hardware_soft_timer.handle == 0){
// This should be true when the program gets here
if (subscription_state){
//printf("Sending ( %c ) to conected device (indication)\n", ch);
rsp = (struct gecko_cmd_packet *)gecko_cmd_gatt_server_send_characteristic_notification(
connection_handle,
gattdb_indication_control,
1,
&ch);
}
else {
printf("Something went wrong\n");
}
}
else {
printf("Something went wrong\n");
}
break;
}
}
return 0;
}