Category: Connectivity

AnyCloud Bluetooth Advertising Scanner (Part 5)

Summary

In this article I will add a new task to the AnyCloud BLE Advertising Scanning application which will save the advertising data into a database.

Story

There is still a boatload of mostly unintelligible advertising data coming ripping onto our screen. It is FINALLY time to start fixing that. In this article I will create a new task called the advertising database task which will hold the history of advertising packets that I have seen. I will update the Bluetooth Manager task to submit the advertising packets to a queue running in the advertising database task.

For this series of articles I will:

Discuss an overview of Bluetooth Application Architecture (Part 1)
Explain how to Start the AnyCloud Bluetooth Stack (Part 1)
Discuss the configuration structure: bt_platform_cfg_setting (Part 1)
Discuss the configuration structure: wiced_bt_cfg_settings (Part 1)
Discuss the Tasks created by the Bluetooth Stack (Part 1)
Build the Basic Project (Part 2)
Explain BLE Advertising - Scanner/Observer (Part 3)
Explain BLE Advertising - Advertiser (Part 3)
How does scanning work in the AnyCloud Bluetooth Stack? (Part 3)
Add Observing to our Project (Part 3)
Program and Test the Project (Part 3)
Add the IoT Expert Bluetooth Utility Library (Part 4)
Mulithreading Dangers (Part 4)
Add a Queue to the Bluetooth Manager Thread (Part 4)
Add a Timer to Process the Queue (Part 4)
A Potential Threading Bug (Part 4)
Add a Scan Off & On Command (Part 4)
Create an Advertising Data Database Task (Part 5)
Update the Advertising Database to Accept Submitted ADV Packets (Part 5)
Update the Bluetooth Manager to Submit Adv Packets (Part 5)
Create an Advertising Data Database (Part 5)
Add a Command to Print the Database (Part 5)
Refactor a silly duplication (Part 6)
Update the print (Part 6)
Add the "decode" command (Part 6)
Add the decode packets functionality (Part 6)
Program and test (Part 6)
Design a new advertising database (Part 7)
Update to the new database (Part 7)
Update printing (Part 7)
Update the advertising add (Part 7)
Create a watch command (Part 7)
Create a record command (Part 7)
Create an erase command (Part 7)
Update the filter data structure (Part 8)
Fix the Add function (Part 8)
Add the filter command (Part 8)
Update the printing (Part 8)
Fix a memory leak (Part 9)
Add packet age (Part 9)
Fix the printing, again (Part 9)
Fix the add packet function (Part 9)
Update the database structure for sort and purge (Part 10)
Add the sort and purge commands (Part 10)
Add the sort functionality (Part 10)
Add the purge functionality (Part 10)
The End & Commentary (Part 10)

All of the code can be found at git@github.com:iotexpert/AnyCloudBLEScanner.git and https://github.com/iotexpert/AnyCloudBLEScanner.git

There are git tags in place starting at part 5 so that you can look at just that version of the code. "git tag" to list the tags. And "git checkout part6" to look at the part 6 version of the code.

Create an Advertising Data Database Task

We need to create the file advertisingDatabase.h which will hold the task prototype (so that main can get going).

#pragma once
void adb_task(void *arg);

#pragma once

void adb_task(void *arg);

Then create the advertisingDatabase.c to hold the actual database code. It will start with the definition of messages which can be sent to the task. For now just “ADB_ADD”. To make things a little bit simpler these command can have two data elements (which I call data0 and data1). Then the main part of the task just

Creates the queue to manage the messages
Process the message until the end of time

#include "FreeRTOS.h"
#include "queue.h"
static QueueHandle_t adb_cmdQueue;
typedef enum {
ADB_ADD,
} adb_cmd_t;
typedef struct
{
adb_cmd_t cmd;
void *data0;
void *data1;
} adb_cmdMsg_t;
void adb_task(void *arg)
{
// setup the queue
adb_cmdMsg_t msg;
adb_cmdQueue = xQueueCreate(10,sizeof(adb_cmdMsg_t));
while(1)
{
BaseType_t status = xQueueReceive(adb_cmdQueue,&msg,portMAX_DELAY);
if(status == pdTRUE) 
{
switch(msg.cmd)
{
case ADB_ADD:
break;
}
}
}
}

#include "FreeRTOS.h"

#include "queue.h"

static QueueHandle_t adb_cmdQueue;

typedef enum {

ADB_ADD,

} adb_cmd_t;

typedef struct

{

adb_cmd_t cmd;

void *data0;

void *data1;

} adb_cmdMsg_t;

void adb_task(void *arg)

{

// setup the queue

adb_cmdMsg_t msg;

adb_cmdQueue = xQueueCreate(10,sizeof(adb_cmdMsg_t));

while(1)

{

BaseType_t status = xQueueReceive(adb_cmdQueue,&msg,portMAX_DELAY);

if(status == pdTRUE)

{

switch(msg.cmd)

{

case ADB_ADD:

break;

}

To start the task, you need to add it to main.c.

xTaskCreate(adb_task,"adv database",configMINIMAL_STACK_SIZE*4,0,1,0);

1	xTaskCreate(adb_task,"adv database",configMINIMAL_STACK_SIZE*4,0,1,0);

When I build and program this, you can now see the new task. Good that working.

AnyCloud> Unhandled Bluetooth Management Event: BTM_LOCAL_IDENTITY_KEYS_REQUEST_EVT
Started BT Stack Succesfully
AnyCloud> tasks
Name          State Priority   Stack  Num
------------------------------------------
usrcmd_ta       X       0       228     5
IDLE            R       0       115     7
Tmr Svc         B       0       223     8
CYBT_HCI_       B       5       950     3
sleep_tas       B       6       221     1
CYBT_BT_T       B       4       1371    2
blinkTask       B       0       98      4
adv datab       B       1       479     6
‘B’ – Blocked
‘R’ – Ready
‘D’ – Deleted (waiting clean up)
‘S’ – Suspended, or Blocked without a timeout
Stack = bytes free at highwater
AnyCloud>

AnyCloud> Unhandled Bluetooth Management Event: BTM_LOCAL_IDENTITY_KEYS_REQUEST_EVT

Started BT Stack Succesfully

AnyCloud> tasks

Name State Priority Stack Num

------------------------------------------

usrcmd_ta X 0 228 5

IDLE R 0 115 7

Tmr Svc B 0 223 8

CYBT_HCI_ B 5 950 3

sleep_tas B 6 221 1

CYBT_BT_T B 4 1371 2

blinkTask B 0 98 4

adv datab B 1 479 6

‘B’ – Blocked

‘R’ – Ready

‘D’ – Deleted (waiting clean up)

‘S’ – Suspended, or Blocked without a timeout

Stack = bytes free at highwater

AnyCloud>

Update the Advertising Database to Accept Submitted ADV Packets

If you recall our original setup was to take advertising packets in the Bluetooth Manager thread and print out the data. The first thing that we want to fix up is the ability of the advertising database task to accept advertising packets which are pushed to its command queue. To prepare for this I create two local variables to hold the data.

void adb_task(void *arg)
{
// setup the queue
adb_cmdMsg_t msg;
wiced_bt_ble_scan_results_t *scan_result;
uint8_t *data;

void adb_task(void *arg)

{

// setup the queue

adb_cmdMsg_t msg;

wiced_bt_ble_scan_results_t *scan_result;

uint8_t *data;

Then I update the ADB_ADD command. My first, and really simple fix, is to grab the printing code from the Bluetooth Manager task. Obviously this won’t be an improvement from the original program as far as the users goes, but it will verify that the tasks are working properly together.

case ADB_ADD:
// Print the MAC Address
scan_result = (wiced_bt_ble_scan_results_t *)msg.data0;
data = (uint8_t *)msg.data1;
printf("MAC: ");
for(int i=0;i<BD_ADDR_LEN;i++)
{
printf("%02X:",scan_result->remote_bd_addr[i]);
}
// Print the RAW Data of the ADV Packet
printf(" Data: ");
int i=0;
while(data[i])
{
for(int j=0;j<data[i];j++)
{
printf("%02X ",data[i+1+j]);
}
i = i + data[i]+1;
}
printf("\n");
free(msg.data0);
free(msg.data1);
break;

case ADB_ADD:

// Print the MAC Address

scan_result = (wiced_bt_ble_scan_results_t *)msg.data0;

data = (uint8_t *)msg.data1;

printf("MAC: ");

for(int i=0;i<BD_ADDR_LEN;i++)

{

printf("%02X:",scan_result->remote_bd_addr[i]);

}

// Print the RAW Data of the ADV Packet

printf(" Data: ");

int i=0;

while(data[i])

{

for(int j=0;j<data[i];j++)

{

printf("%02X ",data[i+1+j]);

}

i = i + data[i]+1;

}

printf("\n");

free(msg.data0);

free(msg.data1);

break;

Then I add a command to the advertisingDatabase.h which the Bluetooth Manager task can call to submit advertising packets

void adb_addAdv(wiced_bt_ble_scan_results_t *scan_result,void *data);

1	void adb_addAdv(wiced_bt_ble_scan_results_t scan_result,void data);

The actual command in advertisingDatabase.c just takes the advertising information, puts it in a command message, then submits it to the command queue.

void adb_addAdv(wiced_bt_ble_scan_results_t *scan_result,void *data)
{
adb_cmdMsg_t msg;
msg.cmd = ADB_ADD;
msg.data0 = (void *)scan_result;
msg.data1 = (void *)data;
xQueueSend(adb_cmdQueue,&msg,0); // If you loose an adv packet it is OK...
}

void adb_addAdv(wiced_bt_ble_scan_results_t *scan_result,void *data)

{

adb_cmdMsg_t msg;

msg.cmd = ADB_ADD;

msg.data0 = (void *)scan_result;

msg.data1 = (void *)data;

xQueueSend(adb_cmdQueue,&msg,0); // If you loose an adv packet it is OK...

}

Update the Bluetooth Manager to Submit Adv Packets

Now I go and edit the bluetoothManager. c to submit packets rather than print them. To do this I greatly simplify the callback. There is one VERY important issue to deal with, which is one of those potential religious war issues. Memory.

When you get the callback from the stack, it gives you POINTERS to data for the advertising packet that reside inside of buffers inside of the stack. As soon as this callback returns this memory is purged. To prevent this data from getting cleaned up by the stack I

Malloc some memory for the wiced_bt_ble_scan_results
Malloc some memory for the advertising data
Make a copy of the data
Submit it to the Advertising Database

I KNOW from the spec that the largest data packet is 31-bytes (actually it is 31-bytes + one more field with length 0). So I know the maximum length is 32-bytes This means that in many situations I will be copying GARBAGE into my buffer if the packet is less than 32 bytes long. I think that this is simpler than calculating the length and then only copying that much data.

void btm_advCallback(wiced_bt_ble_scan_results_t *p_scan_result, uint8_t *p_adv_data)
{
wiced_bt_ble_scan_results_t *scan_result = malloc(sizeof(wiced_bt_ble_scan_results_t));
uint8_t *data = malloc(32);
memcpy(data,p_adv_data,32);
memcpy(scan_result,p_scan_result->remote_bd_addr,BD_ADDR_LEN);
adb_addAdv(scan_result,data);
}

void btm_advCallback(wiced_bt_ble_scan_results_t *p_scan_result, uint8_t *p_adv_data)

{

wiced_bt_ble_scan_results_t *scan_result = malloc(sizeof(wiced_bt_ble_scan_results_t));

uint8_t *data = malloc(32);

memcpy(data,p_adv_data,32);

memcpy(scan_result,p_scan_result->remote_bd_addr,BD_ADDR_LEN);

adb_addAdv(scan_result,data);

}

When I run this updated program I should get the same stream of data coming out on the serial port. Sure enough the new thread is working.

Create an Advertising Data Database

Now, lets create an actual database. To simplify things my database is just an array of structures. One structure per bluetooth device. The structure will contain a pointer to the information about the device it just saw and the actual raw data.

typedef struct {
wiced_bt_ble_scan_results_t *result;
uint8_t *data;
} adb_adv_t ;
#define ADB_MAX_SIZE (40)
adb_adv_t adb_database[ADB_MAX_SIZE];
int adb_db_count=0;

typedef struct {

wiced_bt_ble_scan_results_t *result;

uint8_t *data;

} adb_adv_t ;

#define ADB_MAX_SIZE (40)

adb_adv_t adb_database[ADB_MAX_SIZE];

int adb_db_count=0;

Then I will create several helper functions to work with the database

Find devices in the database given a mac address
Print an entry in the database
Add entries to the database

First, find an entry in the database. This function will search through the database and compare the mac address against the mac address in the database. When the memcmp ==0 meaning it found a match, it will return that entry.

static int adb_db_find(wiced_bt_device_address_t *add)
{
int rval=-1;
for(int i=0;i<adb_db_count;i++)
{
if(memcmp(add,&adb_database[i].result->remote_bd_addr,BD_ADDR_LEN)==0)
{
rval = i;
break;
}
}
return rval;
}

static int adb_db_find(wiced_bt_device_address_t *add)

{

int rval=-1;

for(int i=0;i<adb_db_count;i++)

{

if(memcmp(add,&adb_database[i].result->remote_bd_addr,BD_ADDR_LEN)==0)

{

rval = i;

break;

}

return rval;

}

The print function will make sure that you asked for a legal entry (much must be greater than 0… and less than the max). Then it will print out the mac address and the raw data. In a future post I will add a smarter print out.

static void adb_db_printEntry(int entry)
{
if(!(entry>= 0 && entry <= adb_db_count))
{
printf("Illegal entry\n");
return;
}
printf("%02d MAC: ",entry);
for(int i=0;i<BD_ADDR_LEN;i++)
{
printf("%02X:",adb_database[entry].result->remote_bd_addr[i]);
}
// Print the RAW Data of the ADV Packet
printf(" Data: ");
int i=0;
while(adb_database[entry].data[i])
{
for(int j=0;j<adb_database[entry].data[i];j++)
{
printf("%02X ",adb_database[entry].data[i+1+j]);
}
i = i + adb_database[entry].data[i]+1;
}
printf("\n");
}

static void adb_db_printEntry(int entry)

{

if(!(entry>= 0 && entry <= adb_db_count))

{

printf("Illegal entry\n");

return;

}

printf("%02d MAC: ",entry);

for(int i=0;i<BD_ADDR_LEN;i++)

{

printf("%02X:",adb_database[entry].result->remote_bd_addr[i]);

}

// Print the RAW Data of the ADV Packet

printf(" Data: ");

int i=0;

while(adb_database[entry].data[i])

{

for(int j=0;j<adb_database[entry].data[i];j++)

{

printf("%02X ",adb_database[entry].data[i+1+j]);

}

i = i + adb_database[entry].data[i]+1;

}

printf("\n");

}

To add an entry to the database, first make sure that it isn’t already in the database. Then when you are sure that it isn’t the database, you just add the pointers to your table. You need to make sure and not go beyond the end of the table, and if you did, you will have effectively blown away the last entry in the table. Oh well.

static void adb_db_add(wiced_bt_ble_scan_results_t *scan_result,uint8_t *data)
{
int entry = adb_db_find(&scan_result->remote_bd_addr);
if(entry == -1)
{
adb_database[adb_db_count].result = scan_result;
adb_database[adb_db_count].data = data;
adb_db_printEntry(adb_db_count);
adb_db_count = adb_db_count + 1;
if(adb_db_count == ADB_MAX_SIZE)
{
printf("ADV Table Max Size\n");
adb_db_count = adb_db_count - 1;
}
}
else
{
free(scan_result);
free(data);
}
}

static void adb_db_add(wiced_bt_ble_scan_results_t *scan_result,uint8_t *data)

{

int entry = adb_db_find(&scan_result->remote_bd_addr);

if(entry == -1)

{

adb_database[adb_db_count].result = scan_result;

adb_database[adb_db_count].data = data;

adb_db_printEntry(adb_db_count);

adb_db_count = adb_db_count + 1;

if(adb_db_count == ADB_MAX_SIZE)

{

printf("ADV Table Max Size\n");

adb_db_count = adb_db_count - 1;

}

else

{

free(scan_result);

free(data);

}

Add a Command to Print the Database

Now we want to add the ability to print from the command line. So add a new command message to the list of legal commands.

typedef enum {
ADB_ADD,
ADB_PRINT,
} adb_cmd_t;

typedef enum {

ADB_ADD,

ADB_PRINT,

} adb_cmd_t;

Then create a new function to print. If you send in a “-1” it will print the whole table. Otherwise just print the individual entry.

static void adb_printTable(int entry)
{
if(entry == -1)
{
for(int i=0;i<adb_db_count;i++)
{
adb_db_printEntry(i);
}
}
else
{
adb_db_printEntry(entry);
}
}

static void adb_printTable(int entry)

{

if(entry == -1)

{

for(int i=0;i<adb_db_count;i++)

{

adb_db_printEntry(i);

}

else

{

adb_db_printEntry(entry);

}

Now edit usercmd.c to have the new command line. Notice that I use “sscanf” which obviously has some issues. Too bad.

static int usrcmd_print(int argc, char **argv)
{
if(argc == 1)
{
adb_print(-1); // Print whole table
}
if(argc == 2)
{
int val;
sscanf(argv[1],"%d",&val);
adb_print(val);
}
return 0;
}

static int usrcmd_print(int argc, char **argv)

{

if(argc == 1)

{

adb_print(-1); // Print whole table

}

if(argc == 2)

{

int val;

sscanf(argv[1],"%d",&val);

adb_print(val);

}

return 0;

}

When I program the project it immediately prints out a bunch of devices that are at my house. Then you can see I run the “print” command which prints the table. Finally P do a print 0 to just print the first entry.

In the next article I will add smarter diagnostics to the advertising packets.

AnyCloud Bluetooth Advertising Scanner (Part 4)

Summary

In this article I update the AnyCloud BLE advertising scanner to use the btutil library that was created in the previous post. In addition, I add a command queue to the bluetoothManger and enable a new command to turn on and off scanning.

Story

If you have been following along until now, which I imagine that you have if you are reading this, you will have gotten a vomit of device data blasting out onto your serial console. This isn’t very helpful. So now what? I am going to divide this problem into two parts

Creating a new user command to turn on and off scanning (this article)
Creating a database to manage the data + a set of commands to dump it (next article)

For this series of articles I will:

Discuss an overview of Bluetooth Application Architecture (Part 1)
Explain how to Start the AnyCloud Bluetooth Stack (Part 1)
Discuss the configuration structure: bt_platform_cfg_setting (Part 1)
Discuss the configuration structure: wiced_bt_cfg_settings (Part 1)
Discuss the Tasks created by the Bluetooth Stack (Part 1)
Build the Basic Project (Part 2)
Explain BLE Advertising - Scanner/Observer (Part 3)
Explain BLE Advertising - Advertiser (Part 3)
How does scanning work in the AnyCloud Bluetooth Stack? (Part 3)
Add Observing to our Project (Part 3)
Program and Test the Project (Part 3)
Add the IoT Expert Bluetooth Utility Library (Part 4)
Mulithreading Dangers (Part 4)
Add a Queue to the Bluetooth Manager Thread (Part 4)
Add a Timer to Process the Queue (Part 4)
A Potential Threading Bug (Part 4)
Add a Scan Off & On Command (Part 4)
Create an Advertising Data Database Task (Part 5)
Update the Advertising Database to Accept Submitted ADV Packets (Part 5)
Update the Bluetooth Manager to Submit Adv Packets (Part 5)
Create an Advertising Data Database (Part 5)
Add a Command to Print the Database (Part 5)
Refactor a silly duplication (Part 6)
Update the print (Part 6)
Add the "decode" command (Part 6)
Add the decode packets functionality (Part 6)
Program and test (Part 6)
Design a new advertising database (Part 7)
Update to the new database (Part 7)
Update printing (Part 7)
Update the advertising add (Part 7)
Create a watch command (Part 7)
Create a record command (Part 7)
Create an erase command (Part 7)
Update the filter data structure (Part 8)
Fix the Add function (Part 8)
Add the filter command (Part 8)
Update the printing (Part 8)
Fix a memory leak (Part 9)
Add packet age (Part 9)
Fix the printing, again (Part 9)
Fix the add packet function (Part 9)
Update the database structure for sort and purge (Part 10)
Add the sort and purge commands (Part 10)
Add the sort functionality (Part 10)
Add the purge functionality (Part 10)
The End & Commentary (Part 10)

All of the code can be found at git@github.com:iotexpert/AnyCloudBLEScanner.git and https://github.com/iotexpert/AnyCloudBLEScanner.git

There are git tags in place starting at part 5 so that you can look at just that version of the code. "git tag" to list the tags. And "git checkout part6" to look at the part 6 version of the code.

Add the IoT Expert “btutil” Library

Before we actually start all of the command queue stuff, lets move to the btutil library that I talked about in the previous post. To do this, add the library using the library manager.

Then delete bt_platform_cfg_settings.h and bt_platform_cfg_settings.c from your project. Finally Rebuild and make sure that everything still works. That is it.

Multithreading

Id like to explain that there is now some danger. That danger comes from the fact that we have multiple tasks which are all accessing data plus functions that are talking to each other ASYNCHRONOUSLY. Specifically we have:

The Bluetooth Stack task – running the Bluetooth stack and management callback
The Bluetooth Stack APIs – e.g. wiced_bt_ble_observe
The usrcmd task – which is interacting with the user on the serial port and talking to the other tasks
A timer_svc task – which runs software timers
The advertising data (which I will start saving in the next article)

When faced with this situation what I typically like to do is provide thread safe public functions for each of the tasks. Then any other task can call these functions and know that things are not going to get corrupted by a race condition.

To make the design thread safe, I typically like to put an RTOS Queue between the tasks. These queues are a safe place to send and receive data in a “thread safe” way. There are two basic design patterns that can be used

Define a message structure (that gets pushed into the queue) and make it global (via a dot-h). Define a queue handle and make it global (via a dot-h). Then let any task build messages and push them into the queue to be received in the task that owns the queue.
Define the message structure and queue. Then define functions which are global (via a dot-h) which know how to interact with the queue.

I typically think that the 2nd method is better, so that is what I am going to do here.

In BluetoothManager.h I will provide a function called “btm_cmdScan”
The usrcmd task will call the btm_cmdScan function which will
Create a btm_cmdMsg_t with the “scan” command and data of true/false
Then push it into the Bluetooth Manager Command Queue
Where a timer callback in the Bluetooth Manager Task will take it out of the queue
Figure out that it is a “scan” command
Then will either turn on or off scanning

Add a Queue to the Bluetooth Manager Thread

So we need two things a message to push into a queue (just a structure) and we need a queue to push it into. First the message which is just a structure with two elements. The first element is a command and the second element is some data of type void. The meaning of the void *data will be different based on the command.

typedef struct {
btm_cmd_t cmd;
void *data;
} btm_cmdMsg_t;

typedef struct {

btm_cmd_t cmd;

void *data;

} btm_cmdMsg_t;

But how about the command? The command is just an enumerate list of commands which will now start with just one command.

typedef enum {
BTM_SCAN,
} btm_cmd_t;

typedef enum {

BTM_SCAN,

} btm_cmd_t;

And know we need to define the queue.

#include "queue.h"
static QueueHandle_t btm_cmdQueue;

1 2	#include "queue.h" static QueueHandle_t btm_cmdQueue;

Before you can use the queue you need to initialize it. The best place to initialize this queue is in the management callback right after the stack gets going. You can see that I tell FreeRTOS that there is a queue which can hold up to 10 commands. I also tell it that each command is the sizeof the command message.

switch (event)
{
case BTM_ENABLED_EVT:
printf("Started BT Stack Succesfully\n");
btm_cmdQueue = xQueueCreate(10,sizeof(btm_cmdMsg_t));

switch (event)

{

case BTM_ENABLED_EVT:

printf("Started BT Stack Succesfully\n");

btm_cmdQueue = xQueueCreate(10,sizeof(btm_cmdMsg_t));

Now we need to create a way for other tasks to create these command messages. They will do this by calling a function which we will define in the bluetoothManager.h

void btm_cmdScan(bool enable);

1	void btm_cmdScan(bool enable);

This function will live in bluetoothManager.c and it simply

Creates a command
Set the actual command to scan
Sets the void* data to be enable … in other words start or stop scanning. Remember that a void * can be anything. See I cast a bool to a void *
Finally push the data into the command queue

void btm_cmdScan(bool enable)
{
btm_cmdMsg_t msg;
msg.cmd = BTM_SCAN;
msg.data = (void *)enable;
xQueueSend(btm_cmdQueue, &msg,0);
}

void btm_cmdScan(bool enable)

{

btm_cmdMsg_t msg;

msg.cmd = BTM_SCAN;

msg.data = (void *)enable;

xQueueSend(btm_cmdQueue, &msg,0);

}

Add a Timer to Process the Queue

So now we have a method to push items into the queue. How do we get them out of the queue? To do that I will use a Bluetooth Stack timer that will run every 50ms.

First, define the timer in bluetoothManager.c

#include "wiced_timer.h"
static wiced_timer_ext_t btm_mgmtQueueTimer;

1 2	#include "wiced_timer.h" static wiced_timer_ext_t btm_mgmtQueueTimer;

Then define a function which the timer will call. This function will

Try to get a message out of the queue
IF there is a message it will use a big switch to look at the possible messages
If the message is a scan
Then call the wiced function to either start “observing” or stop “observing”

static void btm_processBluetoothAppQueue()
{
btm_cmdMsg_t msg;
BaseType_t rval;
rval = xQueueReceive( btm_cmdQueue,&msg,0);
if(rval == pdTRUE)
{
switch(msg.cmd)
{
case BTM_SCAN:
wiced_bt_ble_observe((wiced_bool_t)msg.data,0,btm_advCallback);
break;
}
}
}

static void btm_processBluetoothAppQueue()

{

btm_cmdMsg_t msg;

BaseType_t rval;

rval = xQueueReceive( btm_cmdQueue,&msg,0);

if(rval == pdTRUE)

{

switch(msg.cmd)

{

case BTM_SCAN:

wiced_bt_ble_observe((wiced_bool_t)msg.data,0,btm_advCallback);

break;

}

The last thing you need to do is start the timer. The best place to start the timer is in the management callback where you need to

Create the timer
Tell it to start and run every 50ms

switch (event)
{
case BTM_ENABLED_EVT:
printf("Started BT Stack Succesfully\n");
btm_cmdQueue = xQueueCreate(10,sizeof(btm_cmdMsg_t));
wiced_init_timer_ext (&btm_mgmtQueueTimer, btm_processBluetoothAppQueue,0, WICED_TRUE);
wiced_start_timer_ext (&btm_mgmtQueueTimer, 50);
break;

switch (event)

{

case BTM_ENABLED_EVT:

printf("Started BT Stack Succesfully\n");

btm_cmdQueue = xQueueCreate(10,sizeof(btm_cmdMsg_t));

wiced_init_timer_ext (&btm_mgmtQueueTimer, btm_processBluetoothAppQueue,0, WICED_TRUE);

wiced_start_timer_ext (&btm_mgmtQueueTimer, 50);

break;

A Potential Threading Bug

When I did the implementation originally I created what I thought was a threading bug. Specifically I used the FreeRTOS timer to process the queue. In other words instead of using a wiced_timer_ext_t I used a TimerHandle_t. So what?

The wiced_timer_ext_t is run INSIDE of the BluetoothStack task where the TimerHandle_t is run inside of the Timer_SVC task.

So what? I was afraid that the call to wiced_bt_ble_obsere was NOT thread safe and needed to be called inside of the same task as the stack.

After some digging I found out that the Bluetooth Stack is threadsafe, so I worried for no reason. Well, actually, you can never worry enough about making these kinds of threading bugs because they are viscously difficult to debug.

Add a Scan Off & On Command

The last thing that you need to do is add an actual command to the usercmd task to call the bluetooth manager function to turn on and off scanning.

First, add a new prototype for your new command in usercmd.c. Then add it to the list of legal commands.

static int usrcmd_scan(int argc, char **argv);
static const cmd_table_t cmdlist[] = {
.... deleted stuff
{ "scan","scan [on|off]", usrcmd_scan},
};

static int usrcmd_scan(int argc, char **argv);

static const cmd_table_t cmdlist[] = {

.... deleted stuff

{ "scan","scan [on|off]", usrcmd_scan},

};

Then create the function to process the command line input and call the btm_scan function.

static int usrcmd_scan(int argc, char **argv)
{
if(argc != 2)
return 0;
if(strcmp(argv[1],"on") == 0)
{
btm_cmdScan(true);
}
else if(strcmp(argv[1],"off") == 0)
{
btm_cmdScan(false);
}
return 0;
}

static int usrcmd_scan(int argc, char **argv)

{

if(argc != 2)

return 0;

if(strcmp(argv[1],"on") == 0)

{

btm_cmdScan(true);

}

else if(strcmp(argv[1],"off") == 0)

{

btm_cmdScan(false);

}

return 0;

}

Now build it and run it. You should still get adv packets barfing all over your screen. But now you can turn on and off the scanning with “scan on” and “scan off”. In the next article we will create a database to hold the scan packets.

AnyCloud Bluetooth Utilities Library

Summary

This article is a discussion of a library of utilities functions that support AnyCloud Bluetooth development. It includes settings to configure the hardware, functions to decode stack events, functions to decode advertising packets etc.

Story

The Cypress, now Infineon, Modus Toolbox team has been working to bring the WICED Bluetooth devices to be closer and more compatible with the PSoC 6 tools. One of the important enablement things we have done is turn on the WICED Bluetooth Host stack on the PSoC 6 so that it can effectively talk to the CYW43XXX Bluetooth / WiFi combo chips.

As I have been using all of the new stuff I found myself adding my own custom functionality…. and after a while I realized (finally) that I should put all of those little helper things into a library, specifically an IoT Expert library. For now this library contains:

The Bluetooth Platform Configuration Settings
Functions to decode stack events
Functions to decode advertising packets

but imagine with time I will add more functions and templates.

bt_platform_cfg_settings

As I discussed in the article AnyCloud Bluetooth Advertising Scanner (Part 1), every single AnyCloud BLE Stack project will require a structure of type wiced_bt_cfg_settings_t. This structure is used to setup the hardware before getting the stack going. Remember you need to make a call like this to initialize the Bluetooth hardware.

cybt_platform_config_init(&bt_platform_cfg_settings);

1	cybt_platform_config_init(&bt_platform_cfg_settings);

At some point this file will be included automatically for you by the Modus Toolbox team, but for now I have added this to my library. This file look like this. Basically a bunch of pin definitions which are set for you automatically by the BSP. Obviously you can make your own, but this should work on all of the Cypress development kits (I think)

#include "cybt_platform_config.h"
#include "cybsp.h"
#include "wiced_bt_stack.h"
const cybt_platform_config_t bt_platform_cfg_settings =
{
.hci_config =
{
.hci_transport = CYBT_HCI_UART,
.hci =
{
.hci_uart =
{
.uart_tx_pin = CYBSP_BT_UART_TX,
.uart_rx_pin = CYBSP_BT_UART_RX,
.uart_rts_pin = CYBSP_BT_UART_RTS,
.uart_cts_pin = CYBSP_BT_UART_CTS,
.baud_rate_for_fw_download = 115200,
.baud_rate_for_feature     = 115200,
.data_bits = 8,
.stop_bits = 1,
.parity = CYHAL_UART_PARITY_NONE,
.flow_control = WICED_TRUE
}
}
},
.controller_config =
{
.bt_power_pin      = CYBSP_BT_POWER,
.sleep_mode =
{
#if (bt_0_power_0_ENABLED == 1) /* BT Power control is enabled in the LPA */
#if (CYCFG_BT_LP_ENABLED == 1) /* Low power is enabled in the LPA, use the LPA configuration */
.sleep_mode_enabled = true,
.device_wakeup_pin = CYCFG_BT_DEV_WAKE_GPIO,
.host_wakeup_pin = CYCFG_BT_HOST_WAKE_GPIO,
.device_wake_polarity = CYCFG_BT_DEV_WAKE_POLARITY,
.host_wake_polarity = CYCFG_BT_HOST_WAKE_IRQ_EVENT
#else /* Low power is disabled in the LPA, disable low power */
.sleep_mode_enabled = false
#endif
#else /* BT Power control is disabled in the LPA – default to BSP low power configuration */
.sleep_mode_enabled = true,
.device_wakeup_pin = CYBSP_BT_DEVICE_WAKE,
.host_wakeup_pin = CYBSP_BT_HOST_WAKE,
.device_wake_polarity = CYBT_WAKE_ACTIVE_LOW,
.host_wake_polarity = CYBT_WAKE_ACTIVE_LOW
#endif
}
},
.task_mem_pool_size    = 2048
};

#include "cybt_platform_config.h"

#include "cybsp.h"

#include "wiced_bt_stack.h"

const cybt_platform_config_t bt_platform_cfg_settings =

{

.hci_config =

{

.hci_transport = CYBT_HCI_UART,

.hci =

{

.hci_uart =

{

.uart_tx_pin = CYBSP_BT_UART_TX,

.uart_rx_pin = CYBSP_BT_UART_RX,

.uart_rts_pin = CYBSP_BT_UART_RTS,

.uart_cts_pin = CYBSP_BT_UART_CTS,

.baud_rate_for_fw_download = 115200,

.baud_rate_for_feature = 115200,

.data_bits = 8,

.stop_bits = 1,

.parity = CYHAL_UART_PARITY_NONE,

.flow_control = WICED_TRUE

}

.controller_config =

{

.bt_power_pin = CYBSP_BT_POWER,

.sleep_mode =

{

#if (bt_0_power_0_ENABLED == 1) /* BT Power control is enabled in the LPA */

#if (CYCFG_BT_LP_ENABLED == 1) /* Low power is enabled in the LPA, use the LPA configuration */

.sleep_mode_enabled = true,

.device_wakeup_pin = CYCFG_BT_DEV_WAKE_GPIO,

.host_wakeup_pin = CYCFG_BT_HOST_WAKE_GPIO,

.device_wake_polarity = CYCFG_BT_DEV_WAKE_POLARITY,

.host_wake_polarity = CYCFG_BT_HOST_WAKE_IRQ_EVENT

#else /* Low power is disabled in the LPA, disable low power */

.sleep_mode_enabled = false

#endif

#else /* BT Power control is disabled in the LPA – default to BSP low power configuration */

.sleep_mode_enabled = true,

.device_wakeup_pin = CYBSP_BT_DEVICE_WAKE,

.host_wakeup_pin = CYBSP_BT_HOST_WAKE,

.device_wake_polarity = CYBT_WAKE_ACTIVE_LOW,

.host_wake_polarity = CYBT_WAKE_ACTIVE_LOW

#endif

}

.task_mem_pool_size = 2048

};

btutil_stack

When you startup the Bluetooth Host stack you are responsible for providing a “management callback” which has the function prototype

typedef wiced_result_t (wiced_bt_management_cback_t) (wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data);

1	typedef wiced_result_t (wiced_bt_management_cback_t) (wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data);

The first parameter is an “event” which is just an enumerated list of possible events by the Bluetooth Host Stack. Here is the actual list.

enum wiced_bt_management_evt_e {
/* Bluetooth status events */
BTM_ENABLED_EVT,                                /**< Bluetooth controller and host stack enabled. Event data: wiced_bt_dev_enabled_t */
BTM_DISABLED_EVT,                               /**< Bluetooth controller and host stack disabled. Event data: NULL */
BTM_POWER_MANAGEMENT_STATUS_EVT,                /**< Power management status change. Event data: wiced_bt_power_mgmt_notification_t */
BTM_RE_START_EVT,                               /**< Bluetooth controller and host stack re-enabled. Event data: tBTM_ENABLED_EVT */
/* Security events */
BTM_PIN_REQUEST_EVT,                            /**< PIN request (used only with legacy devices). Event data: #wiced_bt_dev_name_and_class_t */
BTM_USER_CONFIRMATION_REQUEST_EVT,              /**< received USER_CONFIRMATION_REQUEST event (respond using #wiced_bt_dev_confirm_req_reply). Event data: #wiced_bt_dev_user_cfm_req_t */
BTM_PASSKEY_NOTIFICATION_EVT,                   /**< received USER_PASSKEY_NOTIFY event. Event data: #wiced_bt_dev_user_key_notif_t */
BTM_PASSKEY_REQUEST_EVT,                        /**< received USER_PASSKEY_REQUEST event @cond DUAL_MODE (respond using #wiced_bt_dev_pass_key_req_reply). Event data: #wiced_bt_dev_user_key_req_t @endcond
@note  BR/EDR Only */
BTM_KEYPRESS_NOTIFICATION_EVT,                  /**< received KEYPRESS_NOTIFY event. Event data: #wiced_bt_dev_user_keypress_t */
BTM_PAIRING_IO_CAPABILITIES_BR_EDR_REQUEST_EVT, /**< Requesting IO capabilities for BR/EDR pairing. Event data: #wiced_bt_dev_bredr_io_caps_req_t 
@note  BR/EDR Only */
BTM_PAIRING_IO_CAPABILITIES_BR_EDR_RESPONSE_EVT,/**< Received IO capabilities response for BR/EDR pairing. Event data: @cond DUAL_MODE #wiced_bt_dev_bredr_io_caps_rsp_t @endcond
@note  BR/EDR Only*/
BTM_PAIRING_IO_CAPABILITIES_BLE_REQUEST_EVT,    /**< Requesting IO capabilities for BLE pairing. Slave can check peer io capabilities in event data before updating with local io capabilities. Event data: #wiced_bt_dev_ble_io_caps_req_t */
BTM_PAIRING_COMPLETE_EVT,                       /**< received SIMPLE_PAIRING_COMPLETE event. Event data: #wiced_bt_dev_pairing_cplt_t */
BTM_ENCRYPTION_STATUS_EVT,                      /**< Encryption status change. Event data: #wiced_bt_dev_encryption_status_t */
BTM_SECURITY_REQUEST_EVT,                       /**< Security request (respond using #wiced_bt_ble_security_grant). Event data: #wiced_bt_dev_security_request_t */
BTM_SECURITY_FAILED_EVT,                        /**< Security procedure/authentication failed. Event data: #wiced_bt_dev_security_failed_t */
BTM_SECURITY_ABORTED_EVT,                       /**< Security procedure aborted locally, or unexpected link drop. Event data: #wiced_bt_dev_name_and_class_t */
BTM_READ_LOCAL_OOB_DATA_COMPLETE_EVT,           /**< Result of reading local OOB data @cond DUAL_MODE (#wiced_bt_dev_read_local_oob_data). Event data: #wiced_bt_dev_local_oob_t @endcond 
@note  BR/EDR Only */
BTM_REMOTE_OOB_DATA_REQUEST_EVT,                /**< OOB data from remote device @cond DUAL_MODE (respond using #wiced_bt_dev_remote_oob_data_reply). Event data: #wiced_bt_dev_remote_oob_t @endcond 
@note  BR/EDR Only */
BTM_PAIRED_DEVICE_LINK_KEYS_UPDATE_EVT,         /**< Updated remote device link keys (store device_link_keys to  NV memory). This is the place to
verify that the correct link key has been generated. Event data: #wiced_bt_device_link_keys_t */
BTM_PAIRED_DEVICE_LINK_KEYS_REQUEST_EVT,        /**< Request for stored remote device link keys (restore device_link_keys from NV memory). If successful, return WICED_BT_SUCCESS. Event data: #wiced_bt_device_link_keys_t */
BTM_LOCAL_IDENTITY_KEYS_UPDATE_EVT,             /**< Update local identity key (stored local_identity_keys NV memory). Event data: #wiced_bt_local_identity_keys_t */
BTM_LOCAL_IDENTITY_KEYS_REQUEST_EVT,            /**< Request local identity key (get local_identity_keys from NV memory). If successful, return WICED_BT_SUCCESS. Event data: #wiced_bt_local_identity_keys_t */
BTM_BLE_SCAN_STATE_CHANGED_EVT,                 /**< BLE scan state change. Event data: #wiced_bt_ble_scan_type_t */
BTM_BLE_ADVERT_STATE_CHANGED_EVT,               /**< BLE advertisement state change. Event data: #wiced_bt_ble_advert_mode_t */
/* BLE Secure Connection events */
BTM_SMP_REMOTE_OOB_DATA_REQUEST_EVT,            /**< SMP remote oob data request. Reply using wiced_bt_smp_oob_data_reply. Event data: #wiced_bt_smp_remote_oob_req_t  */
BTM_SMP_SC_REMOTE_OOB_DATA_REQUEST_EVT,         /**< LE secure connection remote oob data request. Reply using wiced_bt_smp_sc_oob_reply. Event data: #wiced_bt_smp_sc_remote_oob_req_t 
@note  BR/EDR Only */
BTM_SMP_SC_LOCAL_OOB_DATA_NOTIFICATION_EVT,     /**< LE secure connection local OOB data (wiced_bt_smp_create_local_sc_oob_data). Event data: #wiced_bt_smp_sc_local_oob_t */
BTM_SCO_CONNECTED_EVT,                          /**< SCO connected event. Event data: @cond DUAL_MODE #wiced_bt_sco_connected_t @endcond
@note  BR/EDR Only */
BTM_SCO_DISCONNECTED_EVT,                       /**< SCO disconnected event. Event data: @cond #wiced_bt_sco_disconnected_t @endcond
@note  BR/EDR Only */
BTM_SCO_CONNECTION_REQUEST_EVT,                 /**< SCO connection request event. Event data: @cond #wiced_bt_sco_connection_request_t @endcond
@note  BR/EDR Only */
BTM_SCO_CONNECTION_CHANGE_EVT,                  /**< SCO connection change event. Event data: @cond #wiced_bt_sco_connection_change_t @endcond
@note  BR/EDR Only */
BTM_BLE_CONNECTION_PARAM_UPDATE,                /**< BLE connection parameter update. Event data: #wiced_bt_ble_connection_param_update_t */
BTM_BLE_PHY_UPDATE_EVT,                         /**< BLE Physical link update. Event data: wiced_bt_ble_phy_update_t */
BTM_LPM_STATE_LOW_POWER,                        /**< BT device wake has been deasserted. Used for Host Stack Use Case. */
BTM_MULTI_ADVERT_RESP_EVENT,                    /**< Multi adv command status event Used for the status of the command sent */
#if SMP_CATB_CONFORMANCE_TESTER == TRUE
BTM_SMP_SC_PEER_INFO_EVT                        /** The Secure Connections support information of the peer device */
#endif
};

enum wiced_bt_management_evt_e {

/* Bluetooth status events */

BTM_ENABLED_EVT, /**< Bluetooth controller and host stack enabled. Event data: wiced_bt_dev_enabled_t */

BTM_DISABLED_EVT, /**< Bluetooth controller and host stack disabled. Event data: NULL */

BTM_POWER_MANAGEMENT_STATUS_EVT, /**< Power management status change. Event data: wiced_bt_power_mgmt_notification_t */

BTM_RE_START_EVT, /**< Bluetooth controller and host stack re-enabled. Event data: tBTM_ENABLED_EVT */

/* Security events */

BTM_PIN_REQUEST_EVT, /**< PIN request (used only with legacy devices). Event data: #wiced_bt_dev_name_and_class_t */

BTM_USER_CONFIRMATION_REQUEST_EVT, /**< received USER_CONFIRMATION_REQUEST event (respond using #wiced_bt_dev_confirm_req_reply). Event data: #wiced_bt_dev_user_cfm_req_t */

BTM_PASSKEY_NOTIFICATION_EVT, /**< received USER_PASSKEY_NOTIFY event. Event data: #wiced_bt_dev_user_key_notif_t */

BTM_PASSKEY_REQUEST_EVT, /**< received USER_PASSKEY_REQUEST event @cond DUAL_MODE (respond using #wiced_bt_dev_pass_key_req_reply). Event data: #wiced_bt_dev_user_key_req_t @endcond

@note BR/EDR Only */

BTM_KEYPRESS_NOTIFICATION_EVT, /**< received KEYPRESS_NOTIFY event. Event data: #wiced_bt_dev_user_keypress_t */

BTM_PAIRING_IO_CAPABILITIES_BR_EDR_REQUEST_EVT, /**< Requesting IO capabilities for BR/EDR pairing. Event data: #wiced_bt_dev_bredr_io_caps_req_t

@note BR/EDR Only */

BTM_PAIRING_IO_CAPABILITIES_BR_EDR_RESPONSE_EVT,/**< Received IO capabilities response for BR/EDR pairing. Event data: @cond DUAL_MODE #wiced_bt_dev_bredr_io_caps_rsp_t @endcond

@note BR/EDR Only*/

BTM_PAIRING_IO_CAPABILITIES_BLE_REQUEST_EVT, /**< Requesting IO capabilities for BLE pairing. Slave can check peer io capabilities in event data before updating with local io capabilities. Event data: #wiced_bt_dev_ble_io_caps_req_t */

BTM_PAIRING_COMPLETE_EVT, /**< received SIMPLE_PAIRING_COMPLETE event. Event data: #wiced_bt_dev_pairing_cplt_t */

BTM_ENCRYPTION_STATUS_EVT, /**< Encryption status change. Event data: #wiced_bt_dev_encryption_status_t */

BTM_SECURITY_REQUEST_EVT, /**< Security request (respond using #wiced_bt_ble_security_grant). Event data: #wiced_bt_dev_security_request_t */

BTM_SECURITY_FAILED_EVT, /**< Security procedure/authentication failed. Event data: #wiced_bt_dev_security_failed_t */

BTM_SECURITY_ABORTED_EVT, /**< Security procedure aborted locally, or unexpected link drop. Event data: #wiced_bt_dev_name_and_class_t */

BTM_READ_LOCAL_OOB_DATA_COMPLETE_EVT, /**< Result of reading local OOB data @cond DUAL_MODE (#wiced_bt_dev_read_local_oob_data). Event data: #wiced_bt_dev_local_oob_t @endcond

@note BR/EDR Only */

BTM_REMOTE_OOB_DATA_REQUEST_EVT, /**< OOB data from remote device @cond DUAL_MODE (respond using #wiced_bt_dev_remote_oob_data_reply). Event data: #wiced_bt_dev_remote_oob_t @endcond

@note BR/EDR Only */

BTM_PAIRED_DEVICE_LINK_KEYS_UPDATE_EVT, /**< Updated remote device link keys (store device_link_keys to NV memory). This is the place to

verify that the correct link key has been generated. Event data: #wiced_bt_device_link_keys_t */

BTM_PAIRED_DEVICE_LINK_KEYS_REQUEST_EVT, /**< Request for stored remote device link keys (restore device_link_keys from NV memory). If successful, return WICED_BT_SUCCESS. Event data: #wiced_bt_device_link_keys_t */

BTM_LOCAL_IDENTITY_KEYS_UPDATE_EVT, /**< Update local identity key (stored local_identity_keys NV memory). Event data: #wiced_bt_local_identity_keys_t */

BTM_LOCAL_IDENTITY_KEYS_REQUEST_EVT, /**< Request local identity key (get local_identity_keys from NV memory). If successful, return WICED_BT_SUCCESS. Event data: #wiced_bt_local_identity_keys_t */

BTM_BLE_SCAN_STATE_CHANGED_EVT, /**< BLE scan state change. Event data: #wiced_bt_ble_scan_type_t */

BTM_BLE_ADVERT_STATE_CHANGED_EVT, /**< BLE advertisement state change. Event data: #wiced_bt_ble_advert_mode_t */

/* BLE Secure Connection events */

BTM_SMP_REMOTE_OOB_DATA_REQUEST_EVT, /**< SMP remote oob data request. Reply using wiced_bt_smp_oob_data_reply. Event data: #wiced_bt_smp_remote_oob_req_t */

BTM_SMP_SC_REMOTE_OOB_DATA_REQUEST_EVT, /**< LE secure connection remote oob data request. Reply using wiced_bt_smp_sc_oob_reply. Event data: #wiced_bt_smp_sc_remote_oob_req_t

@note BR/EDR Only */

BTM_SMP_SC_LOCAL_OOB_DATA_NOTIFICATION_EVT, /**< LE secure connection local OOB data (wiced_bt_smp_create_local_sc_oob_data). Event data: #wiced_bt_smp_sc_local_oob_t */

BTM_SCO_CONNECTED_EVT, /**< SCO connected event. Event data: @cond DUAL_MODE #wiced_bt_sco_connected_t @endcond

@note BR/EDR Only */

BTM_SCO_DISCONNECTED_EVT, /**< SCO disconnected event. Event data: @cond #wiced_bt_sco_disconnected_t @endcond

@note BR/EDR Only */

BTM_SCO_CONNECTION_REQUEST_EVT, /**< SCO connection request event. Event data: @cond #wiced_bt_sco_connection_request_t @endcond

@note BR/EDR Only */

BTM_SCO_CONNECTION_CHANGE_EVT, /**< SCO connection change event. Event data: @cond #wiced_bt_sco_connection_change_t @endcond

@note BR/EDR Only */

BTM_BLE_CONNECTION_PARAM_UPDATE, /**< BLE connection parameter update. Event data: #wiced_bt_ble_connection_param_update_t */

BTM_BLE_PHY_UPDATE_EVT, /**< BLE Physical link update. Event data: wiced_bt_ble_phy_update_t */

BTM_LPM_STATE_LOW_POWER, /**< BT device wake has been deasserted. Used for Host Stack Use Case. */

BTM_MULTI_ADVERT_RESP_EVENT, /**< Multi adv command status event Used for the status of the command sent */

#if SMP_CATB_CONFORMANCE_TESTER == TRUE

BTM_SMP_SC_PEER_INFO_EVT /** The Secure Connections support information of the peer device */

#endif

};

While you are trying to figure out what is going on during the development, it is very useful to be able to print out the name of the events (instead of the numbers). In other words instead of doing

printf("Event = %02X\n",event);

1	printf("Event = %02X\n",event);

it is way better to do

printf("Event Name=%s\n",btutil_getBTEventName(event));

1	printf("Event Name=%s\n",btutil_getBTEventName(event));

While I was looking at an example project I found this function which I thought was awesome.

const char *btutil_getBTEventName(wiced_bt_management_evt_t event)
{
switch ( (int)event )
{
CASE_RETURN_STR(BTM_ENABLED_EVT)
CASE_RETURN_STR(BTM_DISABLED_EVT)
CASE_RETURN_STR(BTM_POWER_MANAGEMENT_STATUS_EVT)
CASE_RETURN_STR(BTM_PIN_REQUEST_EVT)
CASE_RETURN_STR(BTM_USER_CONFIRMATION_REQUEST_EVT)
CASE_RETURN_STR(BTM_PASSKEY_NOTIFICATION_EVT)
CASE_RETURN_STR(BTM_PASSKEY_REQUEST_EVT)
CASE_RETURN_STR(BTM_KEYPRESS_NOTIFICATION_EVT)
CASE_RETURN_STR(BTM_PAIRING_IO_CAPABILITIES_BR_EDR_REQUEST_EVT)
CASE_RETURN_STR(BTM_PAIRING_IO_CAPABILITIES_BR_EDR_RESPONSE_EVT)
CASE_RETURN_STR(BTM_PAIRING_IO_CAPABILITIES_BLE_REQUEST_EVT)
CASE_RETURN_STR(BTM_PAIRING_COMPLETE_EVT)
CASE_RETURN_STR(BTM_ENCRYPTION_STATUS_EVT)
CASE_RETURN_STR(BTM_SECURITY_REQUEST_EVT)
CASE_RETURN_STR(BTM_SECURITY_FAILED_EVT)
CASE_RETURN_STR(BTM_SECURITY_ABORTED_EVT)
CASE_RETURN_STR(BTM_READ_LOCAL_OOB_DATA_COMPLETE_EVT)
CASE_RETURN_STR(BTM_REMOTE_OOB_DATA_REQUEST_EVT)
CASE_RETURN_STR(BTM_PAIRED_DEVICE_LINK_KEYS_UPDATE_EVT)
CASE_RETURN_STR(BTM_PAIRED_DEVICE_LINK_KEYS_REQUEST_EVT)
CASE_RETURN_STR(BTM_LOCAL_IDENTITY_KEYS_UPDATE_EVT)
CASE_RETURN_STR(BTM_LOCAL_IDENTITY_KEYS_REQUEST_EVT)
CASE_RETURN_STR(BTM_BLE_SCAN_STATE_CHANGED_EVT)
CASE_RETURN_STR(BTM_BLE_ADVERT_STATE_CHANGED_EVT)
CASE_RETURN_STR(BTM_SMP_REMOTE_OOB_DATA_REQUEST_EVT)
CASE_RETURN_STR(BTM_SMP_SC_REMOTE_OOB_DATA_REQUEST_EVT)
CASE_RETURN_STR(BTM_SMP_SC_LOCAL_OOB_DATA_NOTIFICATION_EVT)
CASE_RETURN_STR(BTM_SCO_CONNECTED_EVT)
CASE_RETURN_STR(BTM_SCO_DISCONNECTED_EVT)
CASE_RETURN_STR(BTM_SCO_CONNECTION_REQUEST_EVT)
CASE_RETURN_STR(BTM_SCO_CONNECTION_CHANGE_EVT)
CASE_RETURN_STR(BTM_BLE_CONNECTION_PARAM_UPDATE)
#ifdef CYW20819A1
CASE_RETURN_STR(BTM_BLE_PHY_UPDATE_EVT)
#endif
}
return NULL;
}

const char *btutil_getBTEventName(wiced_bt_management_evt_t event)

{

switch ( (int)event )

{

CASE_RETURN_STR(BTM_ENABLED_EVT)

CASE_RETURN_STR(BTM_DISABLED_EVT)

CASE_RETURN_STR(BTM_POWER_MANAGEMENT_STATUS_EVT)

CASE_RETURN_STR(BTM_PIN_REQUEST_EVT)

CASE_RETURN_STR(BTM_USER_CONFIRMATION_REQUEST_EVT)

CASE_RETURN_STR(BTM_PASSKEY_NOTIFICATION_EVT)

CASE_RETURN_STR(BTM_PASSKEY_REQUEST_EVT)

CASE_RETURN_STR(BTM_KEYPRESS_NOTIFICATION_EVT)

CASE_RETURN_STR(BTM_PAIRING_IO_CAPABILITIES_BR_EDR_REQUEST_EVT)

CASE_RETURN_STR(BTM_PAIRING_IO_CAPABILITIES_BR_EDR_RESPONSE_EVT)

CASE_RETURN_STR(BTM_PAIRING_IO_CAPABILITIES_BLE_REQUEST_EVT)

CASE_RETURN_STR(BTM_PAIRING_COMPLETE_EVT)

CASE_RETURN_STR(BTM_ENCRYPTION_STATUS_EVT)

CASE_RETURN_STR(BTM_SECURITY_REQUEST_EVT)

CASE_RETURN_STR(BTM_SECURITY_FAILED_EVT)

CASE_RETURN_STR(BTM_SECURITY_ABORTED_EVT)

CASE_RETURN_STR(BTM_READ_LOCAL_OOB_DATA_COMPLETE_EVT)

CASE_RETURN_STR(BTM_REMOTE_OOB_DATA_REQUEST_EVT)

CASE_RETURN_STR(BTM_PAIRED_DEVICE_LINK_KEYS_UPDATE_EVT)

CASE_RETURN_STR(BTM_PAIRED_DEVICE_LINK_KEYS_REQUEST_EVT)

CASE_RETURN_STR(BTM_LOCAL_IDENTITY_KEYS_UPDATE_EVT)

CASE_RETURN_STR(BTM_LOCAL_IDENTITY_KEYS_REQUEST_EVT)

CASE_RETURN_STR(BTM_BLE_SCAN_STATE_CHANGED_EVT)

CASE_RETURN_STR(BTM_BLE_ADVERT_STATE_CHANGED_EVT)

CASE_RETURN_STR(BTM_SMP_REMOTE_OOB_DATA_REQUEST_EVT)

CASE_RETURN_STR(BTM_SMP_SC_REMOTE_OOB_DATA_REQUEST_EVT)

CASE_RETURN_STR(BTM_SMP_SC_LOCAL_OOB_DATA_NOTIFICATION_EVT)

CASE_RETURN_STR(BTM_SCO_CONNECTED_EVT)

CASE_RETURN_STR(BTM_SCO_DISCONNECTED_EVT)

CASE_RETURN_STR(BTM_SCO_CONNECTION_REQUEST_EVT)

CASE_RETURN_STR(BTM_SCO_CONNECTION_CHANGE_EVT)

CASE_RETURN_STR(BTM_BLE_CONNECTION_PARAM_UPDATE)

#ifdef CYW20819A1

CASE_RETURN_STR(BTM_BLE_PHY_UPDATE_EVT)

#endif

}

return NULL;

}

And then I learned something new when I looked at the “function” CASE_RETURN_STR which used compiler trick to turn an enumerated value into a string.

#define CASE_RETURN_STR(enum_val)          case enum_val: return #enum_val;

1	#define CASE_RETURN_STR(enum_val) case enum_val: return #enum_val;

This allows you to do this in your management callback (notice line 16 where the string is printed out)

wiced_result_t app_bt_management_callback(wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data)
{
wiced_result_t result = WICED_BT_SUCCESS;
switch (event)
{
case BTM_ENABLED_EVT:
if (WICED_BT_SUCCESS == p_event_data->enabled.status)
{
printf("Started BT Stack Succesfully\n");
wiced_bt_ble_observe(WICED_TRUE,0,obv_callback);
}
break;
default:
printf("Unhandled Bluetooth Management Event: %s\n", btutil_getBTEventName(event));
break;
}
return result;
}

wiced_result_t app_bt_management_callback(wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data)

{

wiced_result_t result = WICED_BT_SUCCESS;

switch (event)

{

case BTM_ENABLED_EVT:

if (WICED_BT_SUCCESS == p_event_data->enabled.status)

{

printf("Started BT Stack Succesfully\n");

wiced_bt_ble_observe(WICED_TRUE,0,obv_callback);

}

break;

default:

printf("Unhandled Bluetooth Management Event: %s\n", btutil_getBTEventName(event));

break;

}

return result;

}

It turns out that there are several other places where the stack gives you an event-ish thing. So these functions were created as well

#pragma once
const char *btutil_getBTEventName(wiced_bt_management_evt_t event);
const char *btutil_getBLEAdvertModeName(wiced_bt_ble_advert_mode_t mode);
const char *btutil_getBLEGattDisconnReasonName(wiced_bt_gatt_disconn_reason_t reason);
const char *btutil_getBLEGattStatusName(wiced_bt_gatt_status_t status);

#pragma once

const char *btutil_getBTEventName(wiced_bt_management_evt_t event);

const char *btutil_getBLEAdvertModeName(wiced_bt_ble_advert_mode_t mode);

const char *btutil_getBLEGattDisconnReasonName(wiced_bt_gatt_disconn_reason_t reason);

const char *btutil_getBLEGattStatusName(wiced_bt_gatt_status_t status);

btutil_adv_decode

In AnyCloud Bluetooth Advertising Scanner (Part 3) I discussed the format of the advertising packet. So I created functions which will decode the data in the advertising packets. More on the future article AnyCloud Bluetooth Advertising Scanner (Part 4 or maybe 5 or maybe 6). Here are the functions:

#pragma once
wiced_bool_t btutil_isEddystone(uint8_t *data);
wiced_bool_t btutil_is_iBeacon(uint8_t *data);
wiced_bool_t btutil_isCypress(uint8_t *data);
int btutil_adv_len(uint8_t *packet);
void btutil_adv_printPacketDecode(uint8_t *packet);
void btutil_adv_printPacketBytes(uint8_t *packet);

#pragma once

wiced_bool_t btutil_isEddystone(uint8_t *data);

wiced_bool_t btutil_is_iBeacon(uint8_t *data);

wiced_bool_t btutil_isCypress(uint8_t *data);

int btutil_adv_len(uint8_t *packet);

void btutil_adv_printPacketDecode(uint8_t *packet);

void btutil_adv_printPacketBytes(uint8_t *packet);

btutil

And because I like to have just one include to get access to all of the function I created “btutil.h” which just includes all of the headers in one place.

#pragma once
#include "btutil_adv_decode.h"
#include "btutil_stack.h"
#include "btutil_general.h"
#include "bt_platform_cfg_settings.h"

#pragma once

#include "btutil_adv_decode.h"

#include "btutil_stack.h"

#include "btutil_general.h"

#include "bt_platform_cfg_settings.h"

Add to the IoT Expert Manifest

In order to set it up for my library to live in the library manager I updated the IoT Expert Manifest file to have a link to the GitHub repository

<middleware>
<name>Bluetooth Utilities</name>
<id>btutil</id>
<uri>https://github.com/iotexpert/btutil</uri>
<desc>A library of Bluetooth Debugging Utilties for Cypress PSoC6 Anycloud</desc>
<category>IoT Expert</category>
<req_capabilities>psoc6</req_capabilities>
<versions>
<version flow_version="1.0,2.0">
<num>master</num>
<commit>master</commit>
<desc>master</desc>
</version>
</versions>
</middleware>

<name>Bluetooth Utilities</name>

<id>btutil</id>

<uri>https://github.com/iotexpert/btutil</uri>

<desc>A library of Bluetooth Debugging Utilties for Cypress PSoC6 Anycloud</desc>

<category>IoT Expert</category>

<req_capabilities>psoc6</req_capabilities>

<num>master</num>

<commit>master</commit>

<desc>master</desc>

</version>

</versions>

</middleware>

And now the library manager has the IoT Expert Bluetooth Utilities.

AnyCloud Bluetooth Advertising Scanner (Part 3)

Summary

In this article I discuss BLE “Observing” and add that functionality to my PSoC 6 – CYW43xxx AnyCloud BLE Adverting Scanner project.

Story

In part1 of this series I discussed the pieces parts required to get the AnyCloud Bluetooth Stack operating using the AnyCloud SDK running on a PSoC 6 with a CY43xxx combo. Then in part 2 I built a project with those parts and started up the Bluetooth Host stack. The project didn’t really do anything, actually nothing, so it wasn’t very interesting, but it was going. In this article I will discuss BLE advertising scanning, how to configure it in the AnyCloud project and finally how to add it to the project.

For this series of articles I will:

Discuss an overview of Bluetooth Application Architecture (Part 1)
Explain how to Start the AnyCloud Bluetooth Stack (Part 1)
Discuss the configuration structure: bt_platform_cfg_setting (Part 1)
Discuss the configuration structure: wiced_bt_cfg_settings (Part 1)
Discuss the Tasks created by the Bluetooth Stack (Part 1)
Build the Basic Project (Part 2)
Explain BLE Advertising - Scanner/Observer (Part 3)
Explain BLE Advertising - Advertiser (Part 3)
How does scanning work in the AnyCloud Bluetooth Stack? (Part 3)
Add Observing to our Project (Part 3)
Program and Test the Project (Part 3)
Add the IoT Expert Bluetooth Utility Library (Part 4)
Mulithreading Dangers (Part 4)
Add a Queue to the Bluetooth Manager Thread (Part 4)
Add a Timer to Process the Queue (Part 4)
A Potential Threading Bug (Part 4)
Add a Scan Off & On Command (Part 4)
Create an Advertising Data Database Task (Part 5)
Update the Advertising Database to Accept Submitted ADV Packets (Part 5)
Update the Bluetooth Manager to Submit Adv Packets (Part 5)
Create an Advertising Data Database (Part 5)
Add a Command to Print the Database (Part 5)
Refactor a silly duplication (Part 6)
Update the print (Part 6)
Add the "decode" command (Part 6)
Add the decode packets functionality (Part 6)
Program and test (Part 6)
Design a new advertising database (Part 7)
Update to the new database (Part 7)
Update printing (Part 7)
Update the advertising add (Part 7)
Create a watch command (Part 7)
Create a record command (Part 7)
Create an erase command (Part 7)
Update the filter data structure (Part 8)
Fix the Add function (Part 8)
Add the filter command (Part 8)
Update the printing (Part 8)
Fix a memory leak (Part 9)
Add packet age (Part 9)
Fix the printing, again (Part 9)
Fix the add packet function (Part 9)
Update the database structure for sort and purge (Part 10)
Add the sort and purge commands (Part 10)
Add the sort functionality (Part 10)
Add the purge functionality (Part 10)
The End & Commentary (Part 10)

All of the code can be found at git@github.com:iotexpert/AnyCloudBLEScanner.git and https://github.com/iotexpert/AnyCloudBLEScanner.git

There are git tags in place starting at part 5 so that you can look at just that version of the code. "git tag" to list the tags. And "git checkout part6" to look at the part 6 version of the code.

Explain BLE Advertising – Scanner/Observer

You might recall that there are four roles that a BLE device can perform

Peripheral – low power devices that broadcast advertisements, then accept a single connection
Central – devices like cell phones that connect to peripherals. They may run multiple connections at a time.
Broadcaster – a nonconnectable peripheral that sends out advertisements
Observer – A central-like device that listens for broadcasters (or advertising peripherals)

And you might remember that advertisements are short, up to 31-byte, packets of data that give information which can be used for one or more of:

advertising the availability to connect
advertising services
advertising the name
advertising vendor specific information
advertising beacon data (like temperature or …)
advertising location

And, if you forgot, BLE operates on 40 channels. But to save power in peripherals, all of the advertising happens on channel 37, 38 and 39. Specifically a peripheral or broadcaster will send out the advertising data on channel 37, then 38 then 39, then wait… then do it again. But why one channel at a time? Because BLE radio’s can be tuned to transmit and receive on only one channel at a time (a power saving and complexity reducing feature)

Inside of the Central/Observer it will listen on channel 37 for a “window” amount of time. Then it will do nothing for an interval-window amount of time. Then it will do that same thing on channel 28 then 39. But why only one channel at a time? Same reason as above, it saves power and simplifies the design. Why not have the window and the interval be the same? Once again, it saves power.

Here is a picture:

But, what happens if you are not listening when the advertiser advertises? You missed it. Tough shit. It turns out that setting the scan window and interval will greatly impact the probability that you hear advertisements. And, you are more likely to hear advertisements because they are sent on three channels. But it seems like it will never work. Will it? … yes, of course, or they wouldn’t have done it that way 🙂

BLE Advertising – The Advertiser Peripheral or Broadcaster

So what exactly is inside of an advertising packet? Volume 6 part B Section 2.3 of the bluetooth core spec describes the advertising protocol data unit (PDU)

But what is inside of the header?

This leaves us with what is inside of the “payload”. The answer is that the ADV_IND Payload Data Unit (PDU) contains an address of 6-bytes plus up to 31 bytes of data.

The AdvA field shall contain the advertiser’s public or random device address as indicated by TxAdd.

The actual AdvData field is further broken up into “AD Structures” like this:

And what is the “AD Type”, well it is a one byte of one of the following:

And then where do you find the assigned numbers for the field types? In the “Assigned Numbers and GAP“. Here is a clip from the spec.

And conveniently enough we enumerated them for you inside of the SDK header file wiced_bt_ble.h

/** Advertisement data types */
enum wiced_bt_ble_advert_type_e {
BTM_BLE_ADVERT_TYPE_FLAG                        = 0x01,                 /**< Advertisement flags */
BTM_BLE_ADVERT_TYPE_16SRV_PARTIAL               = 0x02,                 /**< List of supported services - 16 bit UUIDs (partial) */
BTM_BLE_ADVERT_TYPE_16SRV_COMPLETE              = 0x03,                 /**< List of supported services - 16 bit UUIDs (complete) */
BTM_BLE_ADVERT_TYPE_32SRV_PARTIAL               = 0x04,                 /**< List of supported services - 32 bit UUIDs (partial) */
BTM_BLE_ADVERT_TYPE_32SRV_COMPLETE              = 0x05,                 /**< List of supported services - 32 bit UUIDs (complete) */
BTM_BLE_ADVERT_TYPE_128SRV_PARTIAL              = 0x06,                 /**< List of supported services - 128 bit UUIDs (partial) */
BTM_BLE_ADVERT_TYPE_128SRV_COMPLETE             = 0x07,                 /**< List of supported services - 128 bit UUIDs (complete) */
BTM_BLE_ADVERT_TYPE_NAME_SHORT                  = 0x08,                 /**< Short name */
BTM_BLE_ADVERT_TYPE_NAME_COMPLETE               = 0x09,                 /**< Complete name */
BTM_BLE_ADVERT_TYPE_TX_POWER                    = 0x0A,                 /**< TX Power level  */
BTM_BLE_ADVERT_TYPE_DEV_CLASS                   = 0x0D,                 /**< Device Class */
BTM_BLE_ADVERT_TYPE_SIMPLE_PAIRING_HASH_C       = 0x0E,                 /**< Simple Pairing Hash C */
BTM_BLE_ADVERT_TYPE_SIMPLE_PAIRING_RAND_C       = 0x0F,                 /**< Simple Pairing Randomizer R */
BTM_BLE_ADVERT_TYPE_SM_TK                       = 0x10,                 /**< Security manager TK value */
BTM_BLE_ADVERT_TYPE_SM_OOB_FLAG                 = 0x11,                 /**< Security manager Out-of-Band data */
BTM_BLE_ADVERT_TYPE_INTERVAL_RANGE              = 0x12,                 /**< Slave connection interval range */
BTM_BLE_ADVERT_TYPE_SOLICITATION_SRV_UUID       = 0x14,                 /**< List of solicitated services - 16 bit UUIDs */
BTM_BLE_ADVERT_TYPE_128SOLICITATION_SRV_UUID    = 0x15,                 /**< List of solicitated services - 128 bit UUIDs */
BTM_BLE_ADVERT_TYPE_SERVICE_DATA                = 0x16,                 /**< Service data - 16 bit UUID */
BTM_BLE_ADVERT_TYPE_PUBLIC_TARGET               = 0x17,                 /**< Public target address */
BTM_BLE_ADVERT_TYPE_RANDOM_TARGET               = 0x18,                 /**< Random target address */
BTM_BLE_ADVERT_TYPE_APPEARANCE                  = 0x19,                 /**< Appearance */
BTM_BLE_ADVERT_TYPE_ADVERT_INTERVAL             = 0x1a,                 /**< Advertising interval */
BTM_BLE_ADVERT_TYPE_LE_BD_ADDR                  = 0x1b,                 /**< LE device bluetooth address */
BTM_BLE_ADVERT_TYPE_LE_ROLE                     = 0x1c,                 /**< LE role */
BTM_BLE_ADVERT_TYPE_256SIMPLE_PAIRING_HASH      = 0x1d,                 /**< Simple Pairing Hash C-256 */
BTM_BLE_ADVERT_TYPE_256SIMPLE_PAIRING_RAND      = 0x1e,                 /**< Simple Pairing Randomizer R-256 */
BTM_BLE_ADVERT_TYPE_32SOLICITATION_SRV_UUID     = 0x1f,                 /**< List of solicitated services - 32 bit UUIDs */
BTM_BLE_ADVERT_TYPE_32SERVICE_DATA              = 0x20,                 /**< Service data - 32 bit UUID */
BTM_BLE_ADVERT_TYPE_128SERVICE_DATA             = 0x21,                 /**< Service data - 128 bit UUID */
BTM_BLE_ADVERT_TYPE_CONN_CONFIRM_VAL            = 0x22,                 /**< LE Secure Connections Confirmation Value */
BTM_BLE_ADVERT_TYPE_CONN_RAND_VAL               = 0x23,                 /**< LE Secure Connections Random Value */
BTM_BLE_ADVERT_TYPE_URI                         = 0x24,                 /**< URI */
BTM_BLE_ADVERT_TYPE_INDOOR_POS                  = 0x25,                 /**< Indoor Positioning */
BTM_BLE_ADVERT_TYPE_TRANS_DISCOVER_DATA         = 0x26,                 /**< Transport Discovery Data */
BTM_BLE_ADVERT_TYPE_SUPPORTED_FEATURES          = 0x27,                 /**< LE Supported Features */
BTM_BLE_ADVERT_TYPE_UPDATE_CH_MAP_IND           = 0x28,                 /**< Channel Map Update Indication */
BTM_BLE_ADVERT_TYPE_PB_ADV                      = 0x29,                 /**< PB-ADV */
BTM_BLE_ADVERT_TYPE_MESH_MSG                    = 0x2A,                 /**< Mesh Message */
BTM_BLE_ADVERT_TYPE_MESH_BEACON                 = 0x2B,                 /**< Mesh Beacon */
BTM_BLE_ADVERT_TYPE_PSRI                        = 0x2E,                 /**< Generic Audio Provate Set Random Identifier */
BTM_BLE_ADVERT_TYPE_3D_INFO_DATA                = 0x3D,                 /**< 3D Information Data */
BTM_BLE_ADVERT_TYPE_MANUFACTURER                = 0xFF                  /**< Manufacturer data */
};

/** Advertisement data types */

enum wiced_bt_ble_advert_type_e {

BTM_BLE_ADVERT_TYPE_FLAG = 0x01, /**< Advertisement flags */

BTM_BLE_ADVERT_TYPE_16SRV_PARTIAL = 0x02, /**< List of supported services - 16 bit UUIDs (partial) */

BTM_BLE_ADVERT_TYPE_16SRV_COMPLETE = 0x03, /**< List of supported services - 16 bit UUIDs (complete) */

BTM_BLE_ADVERT_TYPE_32SRV_PARTIAL = 0x04, /**< List of supported services - 32 bit UUIDs (partial) */

BTM_BLE_ADVERT_TYPE_32SRV_COMPLETE = 0x05, /**< List of supported services - 32 bit UUIDs (complete) */

BTM_BLE_ADVERT_TYPE_128SRV_PARTIAL = 0x06, /**< List of supported services - 128 bit UUIDs (partial) */

BTM_BLE_ADVERT_TYPE_128SRV_COMPLETE = 0x07, /**< List of supported services - 128 bit UUIDs (complete) */

BTM_BLE_ADVERT_TYPE_NAME_SHORT = 0x08, /**< Short name */

BTM_BLE_ADVERT_TYPE_NAME_COMPLETE = 0x09, /**< Complete name */

BTM_BLE_ADVERT_TYPE_TX_POWER = 0x0A, /**< TX Power level */

BTM_BLE_ADVERT_TYPE_DEV_CLASS = 0x0D, /**< Device Class */

BTM_BLE_ADVERT_TYPE_SIMPLE_PAIRING_HASH_C = 0x0E, /**< Simple Pairing Hash C */

BTM_BLE_ADVERT_TYPE_SIMPLE_PAIRING_RAND_C = 0x0F, /**< Simple Pairing Randomizer R */

BTM_BLE_ADVERT_TYPE_SM_TK = 0x10, /**< Security manager TK value */

BTM_BLE_ADVERT_TYPE_SM_OOB_FLAG = 0x11, /**< Security manager Out-of-Band data */

BTM_BLE_ADVERT_TYPE_INTERVAL_RANGE = 0x12, /**< Slave connection interval range */

BTM_BLE_ADVERT_TYPE_SOLICITATION_SRV_UUID = 0x14, /**< List of solicitated services - 16 bit UUIDs */

BTM_BLE_ADVERT_TYPE_128SOLICITATION_SRV_UUID = 0x15, /**< List of solicitated services - 128 bit UUIDs */

BTM_BLE_ADVERT_TYPE_SERVICE_DATA = 0x16, /**< Service data - 16 bit UUID */

BTM_BLE_ADVERT_TYPE_PUBLIC_TARGET = 0x17, /**< Public target address */

BTM_BLE_ADVERT_TYPE_RANDOM_TARGET = 0x18, /**< Random target address */

BTM_BLE_ADVERT_TYPE_APPEARANCE = 0x19, /**< Appearance */

BTM_BLE_ADVERT_TYPE_ADVERT_INTERVAL = 0x1a, /**< Advertising interval */

BTM_BLE_ADVERT_TYPE_LE_BD_ADDR = 0x1b, /**< LE device bluetooth address */

BTM_BLE_ADVERT_TYPE_LE_ROLE = 0x1c, /**< LE role */

BTM_BLE_ADVERT_TYPE_256SIMPLE_PAIRING_HASH = 0x1d, /**< Simple Pairing Hash C-256 */

BTM_BLE_ADVERT_TYPE_256SIMPLE_PAIRING_RAND = 0x1e, /**< Simple Pairing Randomizer R-256 */

BTM_BLE_ADVERT_TYPE_32SOLICITATION_SRV_UUID = 0x1f, /**< List of solicitated services - 32 bit UUIDs */

BTM_BLE_ADVERT_TYPE_32SERVICE_DATA = 0x20, /**< Service data - 32 bit UUID */

BTM_BLE_ADVERT_TYPE_128SERVICE_DATA = 0x21, /**< Service data - 128 bit UUID */

BTM_BLE_ADVERT_TYPE_CONN_CONFIRM_VAL = 0x22, /**< LE Secure Connections Confirmation Value */

BTM_BLE_ADVERT_TYPE_CONN_RAND_VAL = 0x23, /**< LE Secure Connections Random Value */

BTM_BLE_ADVERT_TYPE_URI = 0x24, /**< URI */

BTM_BLE_ADVERT_TYPE_INDOOR_POS = 0x25, /**< Indoor Positioning */

BTM_BLE_ADVERT_TYPE_TRANS_DISCOVER_DATA = 0x26, /**< Transport Discovery Data */

BTM_BLE_ADVERT_TYPE_SUPPORTED_FEATURES = 0x27, /**< LE Supported Features */

BTM_BLE_ADVERT_TYPE_UPDATE_CH_MAP_IND = 0x28, /**< Channel Map Update Indication */

BTM_BLE_ADVERT_TYPE_PB_ADV = 0x29, /**< PB-ADV */

BTM_BLE_ADVERT_TYPE_MESH_MSG = 0x2A, /**< Mesh Message */

BTM_BLE_ADVERT_TYPE_MESH_BEACON = 0x2B, /**< Mesh Beacon */

BTM_BLE_ADVERT_TYPE_PSRI = 0x2E, /**< Generic Audio Provate Set Random Identifier */

BTM_BLE_ADVERT_TYPE_3D_INFO_DATA = 0x3D, /**< 3D Information Data */

BTM_BLE_ADVERT_TYPE_MANUFACTURER = 0xFF /**< Manufacturer data */

};

How does scanning work in the AnyCloud Bluetooth Stack?

To turn on observing/scanning you need to call the function:

wiced_bt_dev_status_t wiced_bt_ble_observe (wiced_bool_t start, uint8_t duration, wiced_bt_ble_scan_result_cback_t *p_scan_result_cback);

1	wiced_bt_dev_status_t wiced_bt_ble_observe (wiced_bool_t start, uint8_t duration, wiced_bt_ble_scan_result_cback_t *p_scan_result_cback);

Which will cause the host stack to tell the controller to start scanning for advertising packets. It will set the scan window and scan interval the low duty scan settings from the bluetooth configuration structure… which we setup with the Bluetooth configurator.

.low_duty_scan_interval          = CY_BT_LOW_DUTY_SCAN_INTERVAL,                              /**< Low duty scan interval */
.low_duty_scan_window            = CY_BT_LOW_DUTY_SCAN_WINDOW,                                /**< Low duty scan window */
.low_duty_scan_duration          = CY_BT_LOW_DUTY_SCAN_DURATION,                              /**< Low duty scan duration in seconds (0 for infinite) */

.low_duty_scan_interval = CY_BT_LOW_DUTY_SCAN_INTERVAL, /**< Low duty scan interval */

.low_duty_scan_window = CY_BT_LOW_DUTY_SCAN_WINDOW, /**< Low duty scan window */

.low_duty_scan_duration = CY_BT_LOW_DUTY_SCAN_DURATION, /**< Low duty scan duration in seconds (0 for infinite) */

When the controller hears an advertising packet, it will send the HCI advertising report to the Bluetooth host stack, which with then call you back. Specifically it will call you back by calling the p_scan_result_cback” function.

You provide the callback function which has the prototype:

typedef void (wiced_bt_ble_scan_result_cback_t) (wiced_bt_ble_scan_results_t *p_scan_result, uint8_t *p_adv_data);

1	typedef void (wiced_bt_ble_scan_result_cback_t) (wiced_bt_ble_scan_results_t p_scan_result, uint8_t p_adv_data);

which contains two parameters, p_scan_result which is a structure that has the mac address and some thing data plus the p_adv_data which has the raw bytes of the advertising packet.

Add Observing to our Project

OK. Lets add this to our project by creating a callback function like this:

Lines 5-9: Just prints out the raw bytes of the MAC address of the remote device, the one advertising

To print out the raw advertising data you need to remember that it is formatted as

A length (of all of the data of the field)
A type
The rest of the data

When you find a field of length of 0 you know that you have reached the end of the data

On Lines 13-20: I print out one field at a time and the raw data

//
void obv_callback(wiced_bt_ble_scan_results_t *p_scan_result, uint8_t *p_adv_data)
{
// Print the MAC Address
printf("MAC: ");
for(int i=0;i<6;i++)
{
printf("%02X:",p_scan_result->remote_bd_addr[i]);
}
// Print the RAW Data of the ADV Packet
printf(" Data: ");
int i=0;
while(p_adv_data[i])
{
for(int j=0;j<p_adv_data[i];j++)
{
printf("%02X ",p_adv_data[i+1+j]);
}
i = i + p_adv_data[i]+1;
}
printf("\n");
}

void obv_callback(wiced_bt_ble_scan_results_t *p_scan_result, uint8_t *p_adv_data)

{

// Print the MAC Address

printf("MAC: ");

for(int i=0;i<6;i++)

{

printf("%02X:",p_scan_result->remote_bd_addr[i]);

}

// Print the RAW Data of the ADV Packet

printf(" Data: ");

int i=0;

while(p_adv_data[i])

{

for(int j=0;j<p_adv_data[i];j++)

{

printf("%02X ",p_adv_data[i+1+j]);

}

i = i + p_adv_data[i]+1;

}

printf("\n");

}

Then update the management callback to start the scanner after the stack is successfully started

switch (event)
{
case BTM_ENABLED_EVT:
if (WICED_BT_SUCCESS == p_event_data->enabled.status)
{
printf("Started BT Stack Succesfully\n");
wiced_bt_ble_observe(WICED_TRUE,0,obv_callback);
}

switch (event)

{

case BTM_ENABLED_EVT:

if (WICED_BT_SUCCESS == p_event_data->enabled.status)

{

printf("Started BT Stack Succesfully\n");

wiced_bt_ble_observe(WICED_TRUE,0,obv_callback);

}

Program and Test

Now when I run the program data comes blasting out of the screen because there are a boatload of ble devices in my house

AnyCloud> Unhandled Bluetooth Management Event: 0x16
Started BT Stack Succesfully
MAC: 76:99:58:E8:8B:1F:Data: 01 1A 0A 0C FF 4C 00 10 06 13 1A 54 F7 5A 7A 
MAC: 9E:7B:EF:0B:74:20:Data: 01 06 16 F7 FD 01 0C C2 81 CE 0C 74 58 77 19 C8 E3 84 A3 42 50 98 00 00 00 00 03 
MAC: 6F:11:7C:FF:02:13:Data: 01 1A 0A 05 FF 4C 00 10 06 03 1E BA 24 58 3D 
MAC: 3F:64:BE:4E:29:0C:Data: 01 04 FF 00 4C 02 15 26 86 F3 9C BA DA 46 58 85 4A A6 2E 7E 5E 8B 8D 00 01 00 00 C9 
MAC: 47:4B:F1:53:2C:84:Data: 01 06 FF 4C 00 10 05 08 18 79 1E C2 
MAC: C8:69:CD:18:BC:E6:Data: 01 1A 0A 0C FF 4C 00 10 05 0C 14 17 BF E9 
MAC: 27:F6:6F:1E:7A:78:Data: 01 1A FF 4C 00 09 06 03 12 C0 A8 20 0D 
MAC: 6F:AE:84:F6:6A:9F:Data: 01 06 FF 4C 00 10 05 08 18 79 1E C2 
MAC: 3F:64:BE:4E:29:0C:Data: 01 04 FF 00 4C 02 15 26 86 F3 9C BA DA 46 58 85 4A A6 2E 7E 5E 8B 8D 00 01 00 00 C9 
MAC: 41:EE:B4:9C:5C:5F:Data: 01 1A 0A 07 FF 4C 00 10 06 33 1A 49 59 46 B4 
MAC: 9E:7B:EF:0B:74:20:Data: 01 06 16 F7 FD 01 0C C2 81 CE 0C 74 58 77 19 C8 E3 84 A3 42 50 98 00 00 00 00 03 
MAC: C8:EB:ED:C8:AC:1C:Data: 01 0A 03 66 66 19 D0 07 FF EE 03 1C AC C8 ED EB C8 
MAC: 76:99:58:E8:8B:1F:Data: 01 1A 0A 0C FF 4C 00 10 06 13 1A 54 F7 5A 7A

AnyCloud> Unhandled Bluetooth Management Event: 0x16

Started BT Stack Succesfully

MAC: 76:99:58:E8:8B:1F:Data: 01 1A 0A 0C FF 4C 00 10 06 13 1A 54 F7 5A 7A

MAC: 9E:7B:EF:0B:74:20:Data: 01 06 16 F7 FD 01 0C C2 81 CE 0C 74 58 77 19 C8 E3 84 A3 42 50 98 00 00 00 00 03

MAC: 6F:11:7C:FF:02:13:Data: 01 1A 0A 05 FF 4C 00 10 06 03 1E BA 24 58 3D

MAC: 3F:64:BE:4E:29:0C:Data: 01 04 FF 00 4C 02 15 26 86 F3 9C BA DA 46 58 85 4A A6 2E 7E 5E 8B 8D 00 01 00 00 C9

MAC: 47:4B:F1:53:2C:84:Data: 01 06 FF 4C 00 10 05 08 18 79 1E C2

MAC: C8:69:CD:18:BC:E6:Data: 01 1A 0A 0C FF 4C 00 10 05 0C 14 17 BF E9

MAC: 27:F6:6F:1E:7A:78:Data: 01 1A FF 4C 00 09 06 03 12 C0 A8 20 0D

MAC: 6F:AE:84:F6:6A:9F:Data: 01 06 FF 4C 00 10 05 08 18 79 1E C2

MAC: 3F:64:BE:4E:29:0C:Data: 01 04 FF 00 4C 02 15 26 86 F3 9C BA DA 46 58 85 4A A6 2E 7E 5E 8B 8D 00 01 00 00 C9

MAC: 41:EE:B4:9C:5C:5F:Data: 01 1A 0A 07 FF 4C 00 10 06 33 1A 49 59 46 B4

MAC: 9E:7B:EF:0B:74:20:Data: 01 06 16 F7 FD 01 0C C2 81 CE 0C 74 58 77 19 C8 E3 84 A3 42 50 98 00 00 00 00 03

MAC: C8:EB:ED:C8:AC:1C:Data: 01 0A 03 66 66 19 D0 07 FF EE 03 1C AC C8 ED EB C8

MAC: 76:99:58:E8:8B:1F:Data: 01 1A 0A 0C FF 4C 00 10 06 13 1A 54 F7 5A 7A

In the next article Ill add some more smarts to manage the data to be easier to look at.

For your information here is all of the file bluetoothManager.c

#include <stdio.h>
#include <stdlib.h>
#include "cybsp.h"
#include "FreeRTOS.h"
#include "bluetoothManager.h"
#include "wiced_bt_stack.h"
#include "wiced_bt_dev.h"
#include "wiced_bt_trace.h"
//
void obv_callback(wiced_bt_ble_scan_results_t *p_scan_result, uint8_t *p_adv_data)
{
// Print the MAC Address
printf("MAC: ");
for(int i=0;i<6;i++)
{
printf("%02X:",p_scan_result->remote_bd_addr[i]);
}
// Print the RAW Data of the ADV Packet
printf(" Data: ");
int i=0;
while(p_adv_data[i])
{
for(int j=0;j<p_adv_data[i];j++)
{
printf("%02X ",p_adv_data[i+1+j]);
}
i = i + p_adv_data[i]+1;
}
printf("\n");
}
/**************************************************************************************************
* Function Name: app_bt_management_callback()
***************************************************************************************************
* Summary:
*   This is a Bluetooth stack event handler function to receive management events from
*   the BLE stack and process as per the application.
*
* Parameters:
*   wiced_bt_management_evt_t event             : BLE event code of one byte length
*   wiced_bt_management_evt_data_t *p_event_data: Pointer to BLE management event structures
*
* Return:
*  wiced_result_t: Error code from WICED_RESULT_LIST or BT_RESULT_LIST
*
*************************************************************************************************/
wiced_result_t app_bt_management_callback(wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data)
{
wiced_result_t result = WICED_BT_SUCCESS;
switch (event)
{
case BTM_ENABLED_EVT:
if (WICED_BT_SUCCESS == p_event_data->enabled.status)
{
printf("Started BT Stack Succesfully\n");
wiced_bt_ble_observe(WICED_TRUE,0,obv_callback);
}
else
{
printf("Error enabling BTM_ENABLED_EVENT\n");
}
break;
default:
printf("Unhandled Bluetooth Management Event: 0x%x\n", event);
break;
}
return result;
}

#include <stdio.h>

#include <stdlib.h>

#include "cybsp.h"

#include "FreeRTOS.h"

#include "bluetoothManager.h"

#include "wiced_bt_stack.h"

#include "wiced_bt_dev.h"

#include "wiced_bt_trace.h"

void obv_callback(wiced_bt_ble_scan_results_t *p_scan_result, uint8_t *p_adv_data)

{

// Print the MAC Address

printf("MAC: ");

for(int i=0;i<6;i++)

{

printf("%02X:",p_scan_result->remote_bd_addr[i]);

}

// Print the RAW Data of the ADV Packet

printf(" Data: ");

int i=0;

while(p_adv_data[i])

{

for(int j=0;j<p_adv_data[i];j++)

{

printf("%02X ",p_adv_data[i+1+j]);

}

i = i + p_adv_data[i]+1;

}

printf("\n");

}

/**************************************************************************************************

* Function Name: app_bt_management_callback()

***************************************************************************************************

* Summary:

* This is a Bluetooth stack event handler function to receive management events from

* the BLE stack and process as per the application.

* Parameters:

* wiced_bt_management_evt_t event : BLE event code of one byte length

* wiced_bt_management_evt_data_t *p_event_data: Pointer to BLE management event structures

* Return:

* wiced_result_t: Error code from WICED_RESULT_LIST or BT_RESULT_LIST

*************************************************************************************************/

wiced_result_t app_bt_management_callback(wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data)

{

wiced_result_t result = WICED_BT_SUCCESS;

switch (event)

{

case BTM_ENABLED_EVT:

if (WICED_BT_SUCCESS == p_event_data->enabled.status)

{

printf("Started BT Stack Succesfully\n");

wiced_bt_ble_observe(WICED_TRUE,0,obv_callback);

}

else

{

printf("Error enabling BTM_ENABLED_EVENT\n");

}

break;

default:

printf("Unhandled Bluetooth Management Event: 0x%x\n", event);

break;

}

return result;

}

AnyCloud Bluetooth Advertising Scanner (Part 2)

Summary

The second article in a series discussing the creation of a PSoC 6 + CYW43xxx Advertising Scanner using the AnyCloud SDK. This article will use the learning from Part 1 to create a template project that starts the BLE stack.

Story

In the previous article I discussed the structure of the Cypress/Infineon Bluetooth Stack and its integration into AnyCloud. A bunch of “theory”, well I say BS to that. Let’s build something.

For this series of articles I will:

Discuss an overview of Bluetooth Application Architecture (Part 1)
Explain how to Start the AnyCloud Bluetooth Stack (Part 1)
Discuss the configuration structure: bt_platform_cfg_setting (Part 1)
Discuss the configuration structure: wiced_bt_cfg_settings (Part 1)
Discuss the Tasks created by the Bluetooth Stack (Part 1)
Build the Basic Project (Part 2)
Explain BLE Advertising - Scanner/Observer (Part 3)
Explain BLE Advertising - Advertiser (Part 3)
How does scanning work in the AnyCloud Bluetooth Stack? (Part 3)
Add Observing to our Project (Part 3)
Program and Test the Project (Part 3)
Add the IoT Expert Bluetooth Utility Library (Part 4)
Mulithreading Dangers (Part 4)
Add a Queue to the Bluetooth Manager Thread (Part 4)
Add a Timer to Process the Queue (Part 4)
A Potential Threading Bug (Part 4)
Add a Scan Off & On Command (Part 4)
Create an Advertising Data Database Task (Part 5)
Update the Advertising Database to Accept Submitted ADV Packets (Part 5)
Update the Bluetooth Manager to Submit Adv Packets (Part 5)
Create an Advertising Data Database (Part 5)
Add a Command to Print the Database (Part 5)
Refactor a silly duplication (Part 6)
Update the print (Part 6)
Add the "decode" command (Part 6)
Add the decode packets functionality (Part 6)
Program and test (Part 6)
Design a new advertising database (Part 7)
Update to the new database (Part 7)
Update printing (Part 7)
Update the advertising add (Part 7)
Create a watch command (Part 7)
Create a record command (Part 7)
Create an erase command (Part 7)
Update the filter data structure (Part 8)
Fix the Add function (Part 8)
Add the filter command (Part 8)
Update the printing (Part 8)
Fix a memory leak (Part 9)
Add packet age (Part 9)
Fix the printing, again (Part 9)
Fix the add packet function (Part 9)
Update the database structure for sort and purge (Part 10)
Add the sort and purge commands (Part 10)
Add the sort functionality (Part 10)
Add the purge functionality (Part 10)
The End & Commentary (Part 10)

All of the code can be found at git@github.com:iotexpert/AnyCloudBLEScanner.git and https://github.com/iotexpert/AnyCloudBLEScanner.git

There are git tags in place starting at part 5 so that you can look at just that version of the code. "git tag" to list the tags. And "git checkout part6" to look at the part 6 version of the code.

Recall from Part 1 that you need three things to startup the Bluetooth Stack

The Hardware Configuration Structure that matches : cybt_platform_config_t
The Bluetooth Stack Configuration Structure that matches : wiced_bt_cfg_settings_t
The Bluetooth Management Callback that matches : typedef wiced_result_t (wiced_bt_management_cback_t) (wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data);

Then you need to call

The hardware initialization function : cybt_platform_config_init
The stack initialization function : wiced_bt_stack_init

Ok let’s do this!

Basic Project

You can do all of these steps from the Eclipse IDE for ModusToolbox. Or you can do it from the individual programs and the command line. I like Visual Studio code, so this article will be done completely from the command line and individual configurators.

Run the new project creator from the start menu. Start by creating a project for the development kit that you have, in my case the one currently plugged into my computer is the CY8CKIT-062S2-43012, so that is what I pick. But, this project will work with any of the WiFI/BT combo chips attached to PSoC 6.

In previous articles I discussed the template that I use to get things going with FreeRTOS. I won’t discuss that here, but I want FreeRTOS and the NTShell, so pick the IoT Expert FreeRTOS NTShell Template.

After about a minute you should have a project. I always like to build the project to make sure that everything is working before I get too far down the road of modifying anything. Run “make -j build”

arh (master) AnyCloudBLEScanner $ make -j build
Tools Directory: /Applications/ModusToolbox/tools_2.2
CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk
Prebuild operations complete
Commencing build operations...
Tools Directory: /Applications/ModusToolbox/tools_2.2
CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk
Initializing build: MTBShellTemplate Debug CY8CKIT-062S2-43012 GCC_ARM
Auto-discovery in progress...
-> Found 205 .c file(s)
-> Found 46 .S file(s)
-> Found 23 .s file(s)
-> Found 0 .cpp file(s)
-> Found 0 .o file(s)
-> Found 6 .a file(s)
-> Found 503 .h file(s)
-> Found 0 .hpp file(s)
-> Found 0 resource file(s)
Applying filters...
Auto-discovery complete
Constructing build rules...
Build rules construction complete
==============================================================================
= Building application =
==============================================================================
Generating compilation database file...
-> ./build/compile_commands.json
Compilation database file generation complete
Building 193 file(s)
Compiling app file lowPower.c
Compiling app file main.c
Compiling app file usrcmd.c
Compiling ext file startup_psoc6_02_cm4.S
..... a bunch of lines deleted
Compiling ext file psoc6_01_cm0p_sleep.c
Compiling ext file psoc6_02_cm0p_sleep.c
Compiling ext file psoc6_03_cm0p_sleep.c
Compiling ext file psoc6_04_cm0p_sleep.c
Compiling ext file cy_retarget_io.c
Linking output file MTBShellTemplate.elf
==============================================================================
= Build complete =
==============================================================================
Calculating memory consumption: CY8C624ABZI-S2D44 GCC_ARM -Og
---------------------------------------------------- 
| Section Name         |  Address      |  Size       | 
---------------------------------------------------- 
| .cy_m0p_image        |  0x10000000   |  6044       | 
| .text                |  0x10002000   |  54876      | 
| .ARM.exidx           |  0x1000f65c   |  8          | 
| .copy.table          |  0x1000f664   |  24         | 
| .zero.table          |  0x1000f67c   |  8          | 
| .data                |  0x080022e0   |  1688       | 
| .cy_sharedmem        |  0x08002978   |  8          | 
| .noinit              |  0x08002980   |  148        | 
| .bss                 |  0x08002a14   |  2136       | 
| .heap                |  0x08003270   |  1029520    | 
---------------------------------------------------- 
Total Internal Flash (Available)          2097152    
Total Internal Flash (Utilized)           64812      
Total Internal SRAM (Available)           1046528    
Total Internal SRAM (Utilized with heap)  1033500

arh (master) AnyCloudBLEScanner $ make -j build

Tools Directory: /Applications/ModusToolbox/tools_2.2

CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk

Prebuild operations complete

Commencing build operations...

Tools Directory: /Applications/ModusToolbox/tools_2.2

CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk

Initializing build: MTBShellTemplate Debug CY8CKIT-062S2-43012 GCC_ARM

Auto-discovery in progress...

-> Found 205 .c file(s)

-> Found 46 .S file(s)

-> Found 23 .s file(s)

-> Found 0 .cpp file(s)

-> Found 0 .o file(s)

-> Found 6 .a file(s)

-> Found 503 .h file(s)

-> Found 0 .hpp file(s)

-> Found 0 resource file(s)

Applying filters...

Auto-discovery complete

Constructing build rules...

Build rules construction complete

==============================================================================

= Building application =

==============================================================================

Generating compilation database file...

-> ./build/compile_commands.json

Compilation database file generation complete

Building 193 file(s)

Compiling app file lowPower.c

Compiling app file main.c

Compiling app file usrcmd.c

Compiling ext file startup_psoc6_02_cm4.S

..... a bunch of lines deleted

Compiling ext file psoc6_01_cm0p_sleep.c

Compiling ext file psoc6_02_cm0p_sleep.c

Compiling ext file psoc6_03_cm0p_sleep.c

Compiling ext file psoc6_04_cm0p_sleep.c

Compiling ext file cy_retarget_io.c

Linking output file MTBShellTemplate.elf

==============================================================================

= Build complete =

==============================================================================

Calculating memory consumption: CY8C624ABZI-S2D44 GCC_ARM -Og

----------------------------------------------------

| Section Name | Address | Size |

----------------------------------------------------

| .cy_m0p_image | 0x10000000 | 6044 |

| .text | 0x10002000 | 54876 |

| .ARM.exidx | 0x1000f65c | 8 |

| .copy.table | 0x1000f664 | 24 |

| .zero.table | 0x1000f67c | 8 |

| .data | 0x080022e0 | 1688 |

| .cy_sharedmem | 0x08002978 | 8 |

| .noinit | 0x08002980 | 148 |

| .bss | 0x08002a14 | 2136 |

| .heap | 0x08003270 | 1029520 |

----------------------------------------------------

Total Internal Flash (Available) 2097152

Total Internal Flash (Utilized) 64812

Total Internal SRAM (Available) 1046528

Total Internal SRAM (Utilized with heap) 1033500

Then to be sure it is working, program the development kit.

arh (master) AnyCloudBLEScanner $ make program
Tools Directory: /Applications/ModusToolbox/tools_2.2
CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk
Prebuild operations complete
Commencing build operations...
Tools Directory: /Applications/ModusToolbox/tools_2.2
CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk
Initializing build: MTBShellTemplate Debug CY8CKIT-062S2-43012 GCC_ARM
Auto-discovery in progress...
-> Found 205 .c file(s)
-> Found 46 .S file(s)
-> Found 23 .s file(s)
-> Found 0 .cpp file(s)
-> Found 0 .o file(s)
-> Found 6 .a file(s)
-> Found 503 .h file(s)
-> Found 0 .hpp file(s)
-> Found 0 resource file(s)
Applying filters...
Auto-discovery complete
Constructing build rules...
Build rules construction complete
==============================================================================
= Building application =
==============================================================================
Generating compilation database file...
-> ./build/compile_commands.json
Compilation database file generation complete
Building 193 file(s)
==============================================================================
= Build complete =
==============================================================================
Calculating memory consumption: CY8C624ABZI-S2D44 GCC_ARM -Og
---------------------------------------------------- 
| Section Name         |  Address      |  Size       | 
---------------------------------------------------- 
| .cy_m0p_image        |  0x10000000   |  6044       | 
| .text                |  0x10002000   |  54876      | 
| .ARM.exidx           |  0x1000f65c   |  8          | 
| .copy.table          |  0x1000f664   |  24         | 
| .zero.table          |  0x1000f67c   |  8          | 
| .data                |  0x080022e0   |  1688       | 
| .cy_sharedmem        |  0x08002978   |  8          | 
| .noinit              |  0x08002980   |  148        | 
| .bss                 |  0x08002a14   |  2136       | 
| .heap                |  0x08003270   |  1029520    | 
---------------------------------------------------- 
Total Internal Flash (Available)          2097152    
Total Internal Flash (Utilized)           64812      
Total Internal SRAM (Available)           1046528    
Total Internal SRAM (Utilized with heap)  1033500    
Programming target device... 
Open On-Chip Debugger 0.10.0+dev-4.1.0.1058 (2020-08-11-03:45)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
Info : auto-selecting first available session transport "swd". To override use 'transport select <transport>'.
adapter speed: 2000 kHz
adapter srst delay: 25
adapter srst pulse_width: 25
** Auto-acquire enabled, use "set ENABLE_ACQUIRE 0" to disable
cortex_m reset_config sysresetreq
cortex_m reset_config sysresetreq
Info : Using CMSIS loader 'CY8C6xxA_SMIF' for bank 'psoc6_smif0_cm0' (footprint 14672 bytes)
Warn : SFlash programming allowed for regions: USER, TOC, KEY
Info : CMSIS-DAP: SWD  Supported
Info : CMSIS-DAP: FW Version = 2.0.0
Info : CMSIS-DAP: Interface Initialised (SWD)
Info : SWCLK/TCK = 1 SWDIO/TMS = 1 TDI = 0 TDO = 0 nTRST = 0 nRESET = 1
Info : CMSIS-DAP: Interface ready
Info : KitProg3: FW version: 1.14.514
Info : KitProg3: Pipelined transfers disabled, please update the firmware
Info : VTarget = 3.215 V
Info : kitprog3: acquiring the device...
Info : clock speed 2000 kHz
Info : SWD DPIDR 0x6ba02477
Info : psoc6.cpu.cm0: hardware has 4 breakpoints, 2 watchpoints
***************************************
** Silicon: 0xE453, Family: 0x102, Rev.: 0x12 (A1)
** Detected Device: CY8C624ABZI-S2D44
** Detected Main Flash size, kb: 2048
** Flash Boot version: 3.1.0.378
** Chip Protection: NORMAL
***************************************
Info : psoc6.cpu.cm4: hardware has 6 breakpoints, 4 watchpoints
Info : starting gdb server for psoc6.cpu.cm0 on 3333
Info : Listening on port 3333 for gdb connections
Info : starting gdb server for psoc6.cpu.cm4 on 3334
Info : Listening on port 3334 for gdb connections
Info : SWD DPIDR 0x6ba02477
Info : kitprog3: acquiring the device...
psoc6.cpu.cm0 halted due to debug-request, current mode: Thread 
xPSR: 0x41000000 pc: 0x00000190 msp: 0x080ff800
** Device acquired successfully
** psoc6.cpu.cm4: Ran after reset and before halt...
psoc6.cpu.cm4 halted due to debug-request, current mode: Thread 
xPSR: 0x01000000 pc: 0x0000012a msp: 0x080ff800
** Programming Started **
auto erase enabled
Info : Flash write discontinued at 0x1000179c, next section at 0x10002000
Info : Padding image section 0 at 0x1000179c with 100 bytes (bank write end alignment)
[100%] [################################] [ Erasing     ]
[100%] [################################] [ Programming ]
Info : Padding image section 1 at 0x1000fd24 with 220 bytes (bank write end alignment)
[100%] [################################] [ Erasing     ]
[100%] [################################] [ Programming ]
wrote 62976 bytes from file /Users/arh/mtw/AnyCloudBLEScanner/build/CY8CKIT-062S2-43012/Debug/MTBShellTemplate.hex in 2.069358s (29.719 KiB/s)
** Programming Finished **
** Verify Started **
verified 62656 bytes in 0.122208s (500.683 KiB/s)
** Verified OK **
** Resetting Target **
Info : SWD DPIDR 0x6ba02477
shutdown command invoked
Info : psoc6.dap: powering down debug domain...
arh (master) AnyCloudBLEScanner $

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

arh (master) AnyCloudBLEScanner $ make program

Tools Directory: /Applications/ModusToolbox/tools_2.2

CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk

Prebuild operations complete

Commencing build operations...

Tools Directory: /Applications/ModusToolbox/tools_2.2

CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk

Initializing build: MTBShellTemplate Debug CY8CKIT-062S2-43012 GCC_ARM

Auto-discovery in progress...

-> Found 205 .c file(s)

-> Found 46 .S file(s)

-> Found 23 .s file(s)

-> Found 0 .cpp file(s)

-> Found 0 .o file(s)

-> Found 6 .a file(s)

-> Found 503 .h file(s)

-> Found 0 .hpp file(s)

-> Found 0 resource file(s)

Applying filters...

Auto-discovery complete

Constructing build rules...

Build rules construction complete

==============================================================================

= Building application =

==============================================================================

Generating compilation database file...

-> ./build/compile_commands.json

Compilation database file generation complete

Building 193 file(s)

==============================================================================

= Build complete =

==============================================================================

Calculating memory consumption: CY8C624ABZI-S2D44 GCC_ARM -Og

----------------------------------------------------

| Section Name | Address | Size |

----------------------------------------------------

| .cy_m0p_image | 0x10000000 | 6044 |

| .text | 0x10002000 | 54876 |

| .ARM.exidx | 0x1000f65c | 8 |

| .copy.table | 0x1000f664 | 24 |

| .zero.table | 0x1000f67c | 8 |

| .data | 0x080022e0 | 1688 |

| .cy_sharedmem | 0x08002978 | 8 |

| .noinit | 0x08002980 | 148 |

| .bss | 0x08002a14 | 2136 |

| .heap | 0x08003270 | 1029520 |

----------------------------------------------------

Total Internal Flash (Available) 2097152

Total Internal Flash (Utilized) 64812

Total Internal SRAM (Available) 1046528

Total Internal SRAM (Utilized with heap) 1033500

Programming target device...

Open On-Chip Debugger 0.10.0+dev-4.1.0.1058 (2020-08-11-03:45)

Licensed under GNU GPL v2

For bug reports, read

http://openocd.org/doc/doxygen/bugs.html

Info : auto-selecting first available session transport "swd". To override use 'transport select <transport>'.

adapter speed: 2000 kHz

adapter srst delay: 25

adapter srst pulse_width: 25

** Auto-acquire enabled, use "set ENABLE_ACQUIRE 0" to disable

cortex_m reset_config sysresetreq

Info : Using CMSIS loader 'CY8C6xxA_SMIF' for bank 'psoc6_smif0_cm0' (footprint 14672 bytes)

Warn : SFlash programming allowed for regions: USER, TOC, KEY

Info : CMSIS-DAP: SWD Supported

Info : CMSIS-DAP: FW Version = 2.0.0

Info : CMSIS-DAP: Interface Initialised (SWD)

Info : SWCLK/TCK = 1 SWDIO/TMS = 1 TDI = 0 TDO = 0 nTRST = 0 nRESET = 1

Info : CMSIS-DAP: Interface ready

Info : KitProg3: FW version: 1.14.514

Info : KitProg3: Pipelined transfers disabled, please update the firmware

Info : VTarget = 3.215 V

Info : kitprog3: acquiring the device...

Info : clock speed 2000 kHz

Info : SWD DPIDR 0x6ba02477

Info : psoc6.cpu.cm0: hardware has 4 breakpoints, 2 watchpoints

***************************************

** Silicon: 0xE453, Family: 0x102, Rev.: 0x12 (A1)

** Detected Device: CY8C624ABZI-S2D44

** Detected Main Flash size, kb: 2048

** Flash Boot version: 3.1.0.378

** Chip Protection: NORMAL

***************************************

Info : psoc6.cpu.cm4: hardware has 6 breakpoints, 4 watchpoints

Info : starting gdb server for psoc6.cpu.cm0 on 3333

Info : Listening on port 3333 for gdb connections

Info : starting gdb server for psoc6.cpu.cm4 on 3334

Info : Listening on port 3334 for gdb connections

Info : SWD DPIDR 0x6ba02477

Info : kitprog3: acquiring the device...

psoc6.cpu.cm0 halted due to debug-request, current mode: Thread

xPSR: 0x41000000 pc: 0x00000190 msp: 0x080ff800

** Device acquired successfully

** psoc6.cpu.cm4: Ran after reset and before halt...

psoc6.cpu.cm4 halted due to debug-request, current mode: Thread

xPSR: 0x01000000 pc: 0x0000012a msp: 0x080ff800

** Programming Started **

auto erase enabled

Info : Flash write discontinued at 0x1000179c, next section at 0x10002000

Info : Padding image section 0 at 0x1000179c with 100 bytes (bank write end alignment)

[100%] [################################] [ Erasing ]

[100%] [################################] [ Programming ]

Info : Padding image section 1 at 0x1000fd24 with 220 bytes (bank write end alignment)

[100%] [################################] [ Erasing ]

[100%] [################################] [ Programming ]

wrote 62976 bytes from file /Users/arh/mtw/AnyCloudBLEScanner/build/CY8CKIT-062S2-43012/Debug/MTBShellTemplate.hex in 2.069358s (29.719 KiB/s)

** Programming Finished **

** Verify Started **

verified 62656 bytes in 0.122208s (500.683 KiB/s)

** Verified OK **

** Resetting Target **

Info : SWD DPIDR 0x6ba02477

shutdown command invoked

Info : psoc6.dap: powering down debug domain...

arh (master) AnyCloudBLEScanner $

When that is done, open up a terminal window and you should have a functioning base project. Notice that I ran “help” and “tasks” from the command shell.

Now that we have a basic project working, add the Bluetooth libraries. Run the library manager by typing “make modlibs”. Then select “bluetooth-freertos” and the library manager will automatically select the other libraries you need. Press Update then Close.

Next, run the bluetooth configurator by running “make config_bt” This tool will help you make the bluetooth stack configuration structure. When the configurator starts, press “New”

Then select our device (the PSoC 6 and the Combo chip)

Click on the “GAP Settings”. Then press the Plus and add “Observer configuration”

Then setup the scan settings (more detail on these numbers in the next article)

Low duty scan window (ms) = 60
Low duty scan interval (ms) = 60
Low duty scan timeout = deselected (meaning no timeout)

Then save your configuration file. Notice that I called it “btconfig”

When you are done you will have a directory called “GeneratedSource” inside of your project with the needed files.

The next step is to fix up the Makefile. I like changing the name of the “App”.

# Name of application (used to derive name of final linked file).
APPNAME=AnyCloudBLEScanner

1 2	# Name of application (used to derive name of final linked file). APPNAME=AnyCloudBLEScanner

Then you need the “FREERTOS WICED_BLE” components.

# Enable optional code that is ordinarily disabled by default.
#
# Available components depend on the specific targeted hardware and firmware
# in use. In general, if you have
#
#    COMPONENTS=foo bar
#
# ... then code in directories named COMPONENT_foo and COMPONENT_bar will be
# added to the build
#
COMPONENTS=FREERTOS WICED_BLE

# Enable optional code that is ordinarily disabled by default.

# Available components depend on the specific targeted hardware and firmware

# in use. In general, if you have

# COMPONENTS=foo bar

# ... then code in directories named COMPONENT_foo and COMPONENT_bar will be

# added to the build

COMPONENTS=FREERTOS WICED_BLE

If you run make vscode it will update the workspace with all of the stuff needed for Visual Studio Code to be able to find all of the files.

arh (master) AnyCloudBLEScanner $ make vscode
Tools Directory: /Applications/ModusToolbox/tools_2.2
CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk
Prebuild operations complete
Commencing build operations...
Tools Directory: /Applications/ModusToolbox/tools_2.2
CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk
Initializing build: MTBShellTemplate Debug CY8CKIT-062S2-43012 GCC_ARM
Auto-discovery in progress...
-> Found 230 .c file(s)
-> Found 46 .S file(s)
-> Found 23 .s file(s)
-> Found 0 .cpp file(s)
-> Found 0 .o file(s)
-> Found 22 .a file(s)
-> Found 561 .h file(s)
-> Found 0 .hpp file(s)
-> Found 0 resource file(s)
Applying filters...
Auto-discovery complete
Constructing build rules...
Build rules construction complete
==============================================================================
= Generating IDE files =
==============================================================================
==============================================================================
= Building application =
==============================================================================
Generating compilation database file...
-> ./build/compile_commands.json
Compilation database file generation complete
echo "The existing MTBShellTemplate.code-workspace file has been saved to .vscode/backup";
The existing MTBShellTemplate.code-workspace file has been saved to .vscode/backup
The existing c_cpp_properties.json file has been saved to .vscode/backup
The existing launch.json file has been saved to .vscode/backup
Modifying existing settings.json file. Check against the backup copy in .vscode/backup
The existing tasks.json file has been saved to .vscode/backup
Generated Visual Studio Code files: c_cpp_properties.json launch.json openocd.tcl settings.json tasks.json
J-Link users, please see the comments at the top of the launch.json
file about setting the location of the gdb-server.
Instructions:
1. Review the modustoolbox.toolsPath property in .vscode/settings.json
2. Open VSCode
3. Install "C/C++" and "Cortex-Debug" extensions
4. File->Open Folder (Welcome page->Start->Open folder)
5. Select the app root directory and open
6. Builds: Terminal->Run Task
7. Debugging: "Bug icon" on the left-hand pane
arh (master) AnyCloudBLEScanner $

arh (master) AnyCloudBLEScanner $ make vscode

Tools Directory: /Applications/ModusToolbox/tools_2.2

CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk

Prebuild operations complete

Commencing build operations...

Tools Directory: /Applications/ModusToolbox/tools_2.2

CY8CKIT-062S2-43012.mk: ../mtb_shared/TARGET_CY8CKIT-062S2-43012/latest-v2.X/CY8CKIT-062S2-43012.mk

Initializing build: MTBShellTemplate Debug CY8CKIT-062S2-43012 GCC_ARM

Auto-discovery in progress...

-> Found 230 .c file(s)

-> Found 46 .S file(s)

-> Found 23 .s file(s)

-> Found 0 .cpp file(s)

-> Found 0 .o file(s)

-> Found 22 .a file(s)

-> Found 561 .h file(s)

-> Found 0 .hpp file(s)

-> Found 0 resource file(s)

Applying filters...

Auto-discovery complete

Constructing build rules...

Build rules construction complete

==============================================================================

= Generating IDE files =

==============================================================================

= Building application =

==============================================================================

Generating compilation database file...

-> ./build/compile_commands.json

Compilation database file generation complete

echo "The existing MTBShellTemplate.code-workspace file has been saved to .vscode/backup";

The existing MTBShellTemplate.code-workspace file has been saved to .vscode/backup

The existing c_cpp_properties.json file has been saved to .vscode/backup

The existing launch.json file has been saved to .vscode/backup

Modifying existing settings.json file. Check against the backup copy in .vscode/backup

The existing tasks.json file has been saved to .vscode/backup

Generated Visual Studio Code files: c_cpp_properties.json launch.json openocd.tcl settings.json tasks.json

J-Link users, please see the comments at the top of the launch.json

file about setting the location of the gdb-server.

Instructions:

1. Review the modustoolbox.toolsPath property in .vscode/settings.json

2. Open VSCode

3. Install "C/C++" and "Cortex-Debug" extensions

4. File->Open Folder (Welcome page->Start->Open folder)

5. Select the app root directory and open

6. Builds: Terminal->Run Task

7. Debugging: "Bug icon" on the left-hand pane

arh (master) AnyCloudBLEScanner $

Inside of Visual Studio Code, create a new file called “bt_platform_cfg_settings.h” and add:

#include "cybt_platform_config.h"
#include "cybsp.h"
#include "wiced_bt_stack.h"
extern const cybt_platform_config_t bt_platform_cfg_settings;

#include "cybt_platform_config.h"

#include "cybsp.h"

#include "wiced_bt_stack.h"

extern const cybt_platform_config_t bt_platform_cfg_settings;

Inside of Visual Studio Code, create a new file called “bt_platform_cfg_settings.c” and add:

#include "cybt_platform_config.h"
#include "cybsp.h"
#include "wiced_bt_stack.h"
const cybt_platform_config_t bt_platform_cfg_settings =
{
.hci_config =
{
.hci_transport = CYBT_HCI_UART,
.hci =
{
.hci_uart =
{
.uart_tx_pin = CYBSP_BT_UART_TX,
.uart_rx_pin = CYBSP_BT_UART_RX,
.uart_rts_pin = CYBSP_BT_UART_RTS,
.uart_cts_pin = CYBSP_BT_UART_CTS,
.baud_rate_for_fw_download = 115200,
.baud_rate_for_feature     = 115200,
.data_bits = 8,
.stop_bits = 1,
.parity = CYHAL_UART_PARITY_NONE,
.flow_control = WICED_TRUE
}
}
},
.controller_config =
{
.bt_power_pin      = CYBSP_BT_POWER,
.sleep_mode =
{
#if (bt_0_power_0_ENABLED == 1) /* BT Power control is enabled in the LPA */
#if (CYCFG_BT_LP_ENABLED == 1) /* Low power is enabled in the LPA, use the LPA configuration */
.sleep_mode_enabled = true,
.device_wakeup_pin = CYCFG_BT_DEV_WAKE_GPIO,
.host_wakeup_pin = CYCFG_BT_HOST_WAKE_GPIO,
.device_wake_polarity = CYCFG_BT_DEV_WAKE_POLARITY,
.host_wake_polarity = CYCFG_BT_HOST_WAKE_IRQ_EVENT
#else /* Low power is disabled in the LPA, disable low power */
.sleep_mode_enabled = false
#endif
#else /* BT Power control is disabled in the LPA – default to BSP low power configuration */
.sleep_mode_enabled = true,
.device_wakeup_pin = CYBSP_BT_DEVICE_WAKE,
.host_wakeup_pin = CYBSP_BT_HOST_WAKE,
.device_wake_polarity = CYBT_WAKE_ACTIVE_LOW,
.host_wake_polarity = CYBT_WAKE_ACTIVE_LOW
#endif
}
},
.task_mem_pool_size    = 2048
};

#include "cybt_platform_config.h"

#include "cybsp.h"

#include "wiced_bt_stack.h"

const cybt_platform_config_t bt_platform_cfg_settings =

{

.hci_config =

{

.hci_transport = CYBT_HCI_UART,

.hci =

{

.hci_uart =

{

.uart_tx_pin = CYBSP_BT_UART_TX,

.uart_rx_pin = CYBSP_BT_UART_RX,

.uart_rts_pin = CYBSP_BT_UART_RTS,

.uart_cts_pin = CYBSP_BT_UART_CTS,

.baud_rate_for_fw_download = 115200,

.baud_rate_for_feature = 115200,

.data_bits = 8,

.stop_bits = 1,

.parity = CYHAL_UART_PARITY_NONE,

.flow_control = WICED_TRUE

}

.controller_config =

{

.bt_power_pin = CYBSP_BT_POWER,

.sleep_mode =

{

#if (bt_0_power_0_ENABLED == 1) /* BT Power control is enabled in the LPA */

#if (CYCFG_BT_LP_ENABLED == 1) /* Low power is enabled in the LPA, use the LPA configuration */

.sleep_mode_enabled = true,

.device_wakeup_pin = CYCFG_BT_DEV_WAKE_GPIO,

.host_wakeup_pin = CYCFG_BT_HOST_WAKE_GPIO,

.device_wake_polarity = CYCFG_BT_DEV_WAKE_POLARITY,

.host_wake_polarity = CYCFG_BT_HOST_WAKE_IRQ_EVENT

#else /* Low power is disabled in the LPA, disable low power */

.sleep_mode_enabled = false

#endif

#else /* BT Power control is disabled in the LPA – default to BSP low power configuration */

.sleep_mode_enabled = true,

.device_wakeup_pin = CYBSP_BT_DEVICE_WAKE,

.host_wakeup_pin = CYBSP_BT_HOST_WAKE,

.device_wake_polarity = CYBT_WAKE_ACTIVE_LOW,

.host_wake_polarity = CYBT_WAKE_ACTIVE_LOW

#endif

}

.task_mem_pool_size = 2048

};

Inside of Visual Studio Code, create bluetoothManager.h. Remember this is the Bluetooth Stack Management Callback

#pragma once
#include "wiced_bt_stack.h"
#include "wiced_bt_dev.h"
wiced_result_t app_bt_management_callback(wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data);

#pragma once

#include "wiced_bt_stack.h"

#include "wiced_bt_dev.h"

wiced_result_t app_bt_management_callback(wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data);

Inside of Visual Studio code, create bluetoothManager.c. This function does a whole lotta nothin… except saying that things got started.

#include <stdio.h>
#include <stdlib.h>
#include "cybsp.h"
#include "FreeRTOS.h"
#include "bluetoothManager.h"
#include "wiced_bt_stack.h"
#include "wiced_bt_dev.h"
#include "wiced_bt_trace.h"
/**************************************************************************************************
* Function Name: app_bt_management_callback()
***************************************************************************************************
* Summary:
*   This is a Bluetooth stack event handler function to receive management events from
*   the BLE stack and process as per the application.
*
* Parameters:
*   wiced_bt_management_evt_t event             : BLE event code of one byte length
*   wiced_bt_management_evt_data_t *p_event_data: Pointer to BLE management event structures
*
* Return:
*  wiced_result_t: Error code from WICED_RESULT_LIST or BT_RESULT_LIST
*
*************************************************************************************************/
wiced_result_t app_bt_management_callback(wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data)
{
wiced_result_t result = WICED_BT_SUCCESS;
switch (event)
{
case BTM_ENABLED_EVT:
if (WICED_BT_SUCCESS == p_event_data->enabled.status)
{
printf("Started BT Stack Succesfully\n");
}
else
{
printf("Error enabling BTM_ENABLED_EVENT\n");
}
break;
default:
printf("Unhandled Bluetooth Management Event: 0x%x\n", event);
break;
}
return result;
}

#include <stdio.h>

#include <stdlib.h>

#include "cybsp.h"

#include "FreeRTOS.h"

#include "bluetoothManager.h"

#include "wiced_bt_stack.h"

#include "wiced_bt_dev.h"

#include "wiced_bt_trace.h"

/**************************************************************************************************

* Function Name: app_bt_management_callback()

***************************************************************************************************

* Summary:

* This is a Bluetooth stack event handler function to receive management events from

* the BLE stack and process as per the application.

* Parameters:

* wiced_bt_management_evt_t event : BLE event code of one byte length

* wiced_bt_management_evt_data_t *p_event_data: Pointer to BLE management event structures

* Return:

* wiced_result_t: Error code from WICED_RESULT_LIST or BT_RESULT_LIST

*************************************************************************************************/

wiced_result_t app_bt_management_callback(wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data)

{

wiced_result_t result = WICED_BT_SUCCESS;

switch (event)

{

case BTM_ENABLED_EVT:

if (WICED_BT_SUCCESS == p_event_data->enabled.status)

{

printf("Started BT Stack Succesfully\n");

}

else

{

printf("Error enabling BTM_ENABLED_EVENT\n");

}

break;

default:

printf("Unhandled Bluetooth Management Event: 0x%x\n", event);

break;

}

return result;

}

Next, update main.c with the required includes.

#include "bluetoothManager.h"
#include "cycfg_bt_settings.h"
#include "bt_platform_cfg_settings.h"

#include "bluetoothManager.h"

#include "cycfg_bt_settings.h"

#include "bt_platform_cfg_settings.h"

Then update main.c to start the stack

cybt_platform_config_init(&bt_platform_cfg_settings);
wiced_bt_stack_init (app_bt_management_callback, &wiced_bt_cfg_settings);

1 2	cybt_platform_config_init(&bt_platform_cfg_settings); wiced_bt_stack_init (app_bt_management_callback, &wiced_bt_cfg_settings);

Now build and program it, remember “make -j build” and “make program”. Look, we have a functioning stack with the two bluetooth thread running.

In the next article Ill finally get around to building the Bluetooth Scanner.

AnyCloud Bluetooth Advertising Scanner (Part 1)

Summary

The first of several articles discussing the use of the AnyCloud BLE Stack to build advertising scanner/observers.

Story

A few summers ago while I was writing the WICED Bluetooth Academy book, I created a WICED based BLE advertising scanner. Actually, I created a framework for the scanner and the remarkable summer intern I had finished the work. That project has been sitting in the source code repository for the Bluetooth class, mostly only shown to face-to-face students. This scanner is built using some of the original code combined with the new AnyCloud Bluetooth SDK. It will act sort-of-like LightBlue or one of the other Bluetooth advertising scanners you might run on your phone, but with a serial console.

Sometime in the last few months we released the Bluetooth SDK for AnyCloud (things have been crazy and I have lost track of time) This SDK has all of the stuff needed to add Bluetooth to your AnyCloud project using one of the Cypress Bluetooth/WiFi combo chips. I had not had a chance to try it out, so I decided to build a Bluetooth project and then port the scanning code.

For this series of articles I will:

Discuss an overview of Bluetooth Application Architecture (Part 1)
Explain how to Start the AnyCloud Bluetooth Stack (Part 1)
Discuss the configuration structure: bt_platform_cfg_setting (Part 1)
Discuss the configuration structure: wiced_bt_cfg_settings (Part 1)
Discuss the Tasks created by the Bluetooth Stack (Part 1)
Build the Basic Project (Part 2)
Explain BLE Advertising - Scanner/Observer (Part 3)
Explain BLE Advertising - Advertiser (Part 3)
How does scanning work in the AnyCloud Bluetooth Stack? (Part 3)
Add Observing to our Project (Part 3)
Program and Test the Project (Part 3)
Add the IoT Expert Bluetooth Utility Library (Part 4)
Mulithreading Dangers (Part 4)
Add a Queue to the Bluetooth Manager Thread (Part 4)
Add a Timer to Process the Queue (Part 4)
A Potential Threading Bug (Part 4)
Add a Scan Off & On Command (Part 4)
Create an Advertising Data Database Task (Part 5)
Update the Advertising Database to Accept Submitted ADV Packets (Part 5)
Update the Bluetooth Manager to Submit Adv Packets (Part 5)
Create an Advertising Data Database (Part 5)
Add a Command to Print the Database (Part 5)
Refactor a silly duplication (Part 6)
Update the print (Part 6)
Add the "decode" command (Part 6)
Add the decode packets functionality (Part 6)
Program and test (Part 6)
Design a new advertising database (Part 7)
Update to the new database (Part 7)
Update printing (Part 7)
Update the advertising add (Part 7)
Create a watch command (Part 7)
Create a record command (Part 7)
Create an erase command (Part 7)
Update the filter data structure (Part 8)
Fix the Add function (Part 8)
Add the filter command (Part 8)
Update the printing (Part 8)
Fix a memory leak (Part 9)
Add packet age (Part 9)
Fix the printing, again (Part 9)
Fix the add packet function (Part 9)
Update the database structure for sort and purge (Part 10)
Add the sort and purge commands (Part 10)
Add the sort functionality (Part 10)
Add the purge functionality (Part 10)
The End & Commentary (Part 10)

All of the code can be found at git@github.com:iotexpert/AnyCloudBLEScanner.git and https://github.com/iotexpert/AnyCloudBLEScanner.git

There are git tags in place starting at part 5 so that you can look at just that version of the code. "git tag" to list the tags. And "git checkout part6" to look at the part 6 version of the code.

Bluetooth Application Architecture

Bluetooth applications are divided into these four pieces

You user application which responds to events and sends messages from/to the Bluetooth host stack
A Bluetooth Host Stack
A Bluetooth Controller Stack
The Bluetooth Radio

These four pieces can be divided into multiple chips, as few as one or as many as four. However, for this article, the project will be built to run on a PSoC 6 + CYW43012 WiFi/Bluetooth Combo chip. Specifically:

My scanner application running on the PSoC 6
The Bluetooth Host Stack running on the PSoC 6
The BlueTooth Controller Firmware running on the CYW43012
A Bluetooth Radio on the CYW43012

But how do they talk? Simple, there is:

A UART Host Controller Interface (HCI) between the two chips
A GPIO to serve as a deep sleep wakeup from the 43012 –> PSoC 6
A GPIO to serve as the bluetooth controller wakeup from the PSoC 6 –> 43012
A GPIO to turn on the Bluetooth regulator from the PSoC 6 –> 43012

Here is the block diagram from the CY8CKIT-062S2-43012 Kit Guide. Notice that signals labeled UART and Control going between the PSoC 6 and the CYW43012.

And when you read more deeply into the schematic you can see the signals labeled

BT_UART_TXD/RXD/CTS/RTS
BT_HOST_WAKE
BT_DEV_WAKE
BT_REG_ON

How to Start the AnyCloud Bluetooth Stack

To actually start the AnyCloud Bluetooth stack you will call two functions

cybt_platform_config_init – that will setup the hardware interface to the CYW43012
wiced_bt_stack_init that will:
1. Start a task to manage the Host Controller Interface
2. Download the controller firmware to the CYW43012
3. Start a task to manage the host stack
4. Initialize both the host and the controller
5. Call you back when that is all done

Here is an example from main.

cybt_platform_config_init(&bt_platform_cfg_settings);
wiced_bt_stack_init (app_bt_management_callback, &wiced_bt_cfg_settings);

1 2	cybt_platform_config_init(&bt_platform_cfg_settings); wiced_bt_stack_init (app_bt_management_callback, &wiced_bt_cfg_settings);

When you look at these two function calls, you will find that you need to provide three things:

A platform hardware configuration structure called bt_platform_cfg_settings
The Bluetooth stack configuration settings structure called wiced_bt_cfg_settings
A management callback called app_bt_management_callback

bt_platform_cfg_settings

The purpose of the hardware configuration structure is to define the UART + parameters and the wakeup GPIOs. Specifically, the hardware configuration structure defines the configuration of the host controller interface (hci)

The HCI transport scheme (in this case UART)
The pins of the UART
Baud Rate
Data Bits
Stop Bits
Parity
Flow Control

And the controller low power behavior (in the .controller_config member)

This is a fairly standard configuration and I think that we should help you by providing this structure somewhere in the BSP. But for now, you need to provide it (in an upcoming article I’ll update the IoT Expert Bluetooth Library to provide it). Here is the specific structure that I will be using.

const cybt_platform_config_t bt_platform_cfg_settings =
{
.hci_config =
{
.hci_transport = CYBT_HCI_UART,
.hci =
{
.hci_uart =
{
.uart_tx_pin = CYBSP_BT_UART_TX,
.uart_rx_pin = CYBSP_BT_UART_RX,
.uart_rts_pin = CYBSP_BT_UART_RTS,
.uart_cts_pin = CYBSP_BT_UART_CTS,
.baud_rate_for_fw_download = 115200,
.baud_rate_for_feature     = 115200,
.data_bits = 8,
.stop_bits = 1,
.parity = CYHAL_UART_PARITY_NONE,
.flow_control = WICED_TRUE
}
}
},
.controller_config =
{
.bt_power_pin      = CYBSP_BT_POWER,
.sleep_mode =
{
#if (bt_0_power_0_ENABLED == 1) /* BT Power control is enabled in the LPA */
#if (CYCFG_BT_LP_ENABLED == 1) /* Low power is enabled in the LPA, use the LPA configuration */
.sleep_mode_enabled = true,
.device_wakeup_pin = CYCFG_BT_DEV_WAKE_GPIO,
.host_wakeup_pin = CYCFG_BT_HOST_WAKE_GPIO,
.device_wake_polarity = CYCFG_BT_DEV_WAKE_POLARITY,
.host_wake_polarity = CYCFG_BT_HOST_WAKE_IRQ_EVENT
#else /* Low power is disabled in the LPA, disable low power */
.sleep_mode_enabled = false
#endif
#else /* BT Power control is disabled in the LPA – default to BSP low power configuration */
.sleep_mode_enabled = true,
.device_wakeup_pin = CYBSP_BT_DEVICE_WAKE,
.host_wakeup_pin = CYBSP_BT_HOST_WAKE,
.device_wake_polarity = CYBT_WAKE_ACTIVE_LOW,
.host_wake_polarity = CYBT_WAKE_ACTIVE_LOW
#endif
}
},
.task_mem_pool_size    = 2048
};

const cybt_platform_config_t bt_platform_cfg_settings =

{

.hci_config =

{

.hci_transport = CYBT_HCI_UART,

.hci =

{

.hci_uart =

{

.uart_tx_pin = CYBSP_BT_UART_TX,

.uart_rx_pin = CYBSP_BT_UART_RX,

.uart_rts_pin = CYBSP_BT_UART_RTS,

.uart_cts_pin = CYBSP_BT_UART_CTS,

.baud_rate_for_fw_download = 115200,

.baud_rate_for_feature = 115200,

.data_bits = 8,

.stop_bits = 1,

.parity = CYHAL_UART_PARITY_NONE,

.flow_control = WICED_TRUE

}

.controller_config =

{

.bt_power_pin = CYBSP_BT_POWER,

.sleep_mode =

{

#if (bt_0_power_0_ENABLED == 1) /* BT Power control is enabled in the LPA */

#if (CYCFG_BT_LP_ENABLED == 1) /* Low power is enabled in the LPA, use the LPA configuration */

.sleep_mode_enabled = true,

.device_wakeup_pin = CYCFG_BT_DEV_WAKE_GPIO,

.host_wakeup_pin = CYCFG_BT_HOST_WAKE_GPIO,

.device_wake_polarity = CYCFG_BT_DEV_WAKE_POLARITY,

.host_wake_polarity = CYCFG_BT_HOST_WAKE_IRQ_EVENT

#else /* Low power is disabled in the LPA, disable low power */

.sleep_mode_enabled = false

#endif

#else /* BT Power control is disabled in the LPA – default to BSP low power configuration */

.sleep_mode_enabled = true,

.device_wakeup_pin = CYBSP_BT_DEVICE_WAKE,

.host_wakeup_pin = CYBSP_BT_HOST_WAKE,

.device_wake_polarity = CYBT_WAKE_ACTIVE_LOW,

.host_wake_polarity = CYBT_WAKE_ACTIVE_LOW

#endif

}

.task_mem_pool_size = 2048

};

wiced_bt_cfg_settings

The Cypress WICED Bluetooth Stack has a boatload of configuration settings. When you call the stack start function you need to provide all of those settings in a structure of type “wiced_bt_cfg_settings_t” which is actually a structure of structures. There are several basic ways to set these settings

Start from scratch and build you own settings
Copy from an example project
Use the Bluetooth Configurator to generate the structure

For the purposes of THIS project I started by copying the structure from on of the example projects and then modifying the three numbers that were relevant to me. Specifically

max_simultanous_link – which I changed to 0 because this is simply a Bluetooth Observer
low_duty_scan_interval – how long in the window to listen for advertising packets
low_duty_scan_window – how wide the window of listening should be

const wiced_bt_cfg_settings_t wiced_bt_cfg_settings =
{
.device_name                         = (uint8_t *)BT_LOCAL_NAME,                                   /**< Local device name (NULL terminated) */
.device_class                        = {0x00, 0x00, 0x00},                                         /**< Local device class */
.security_requirement_mask           = BTM_SEC_NONE,                                               /**< Security requirements mask (BTM_SEC_NONE, or combinination of BTM_SEC_IN_AUTHENTICATE, BTM_SEC_OUT_AUTHENTICATE, BTM_SEC_ENCRYPT (see #wiced_bt_sec_level_e)) */
.max_simultaneous_links              = 0,                                                          /**< Maximum number simultaneous links to different devices */
.ble_scan_cfg =                                                 /* BLE scan settings  */
{
.scan_mode                       = BTM_BLE_SCAN_MODE_PASSIVE,                                  /**< BLE scan mode (BTM_BLE_SCAN_MODE_PASSIVE, BTM_BLE_SCAN_MODE_ACTIVE, or BTM_BLE_SCAN_MODE_NONE) */
/* Advertisement scan configuration */
.high_duty_scan_interval         = WICED_BT_CFG_DEFAULT_HIGH_DUTY_SCAN_INTERVAL,               /**< High duty scan interval */
.high_duty_scan_window           = WICED_BT_CFG_DEFAULT_HIGH_DUTY_SCAN_WINDOW,                 /**< High duty scan window */
.high_duty_scan_duration         = 0,                                                          /**< High duty scan duration in seconds (0 for infinite) */
.low_duty_scan_interval          = 96,                                                         /**< Low duty scan interval  */
.low_duty_scan_window            = 96,                                                         /**< Low duty scan window */
.low_duty_scan_duration          = 0,                                                          /**< Low duty scan duration in seconds (0 for infinite) */
/* Connection scan configuration */
.high_duty_conn_scan_interval    = WICED_BT_CFG_DEFAULT_HIGH_DUTY_CONN_SCAN_INTERVAL,          /**< High duty cycle connection scan interval */
.high_duty_conn_scan_window      = WICED_BT_CFG_DEFAULT_HIGH_DUTY_CONN_SCAN_WINDOW,            /**< High duty cycle connection scan window */
.high_duty_conn_duration         = 0,                                                         /**< High duty cycle connection duration in seconds (0 for infinite) */
.low_duty_conn_scan_interval     = WICED_BT_CFG_DEFAULT_LOW_DUTY_CONN_SCAN_INTERVAL,           /**< Low duty cycle connection scan interval */
.low_duty_conn_scan_window       = WICED_BT_CFG_DEFAULT_LOW_DUTY_CONN_SCAN_WINDOW,             /**< Low duty cycle connection scan window */
.low_duty_conn_duration          = 0,                                                         /**< Low duty cycle connection duration in seconds (0 for infinite) */
/* Connection configuration */
.conn_min_interval               = WICED_BT_CFG_DEFAULT_CONN_MIN_INTERVAL,                     /**< Minimum connection interval */
.conn_max_interval               = WICED_BT_CFG_DEFAULT_CONN_MAX_INTERVAL,                     /**< Maximum connection interval */
.conn_latency                    = WICED_BT_CFG_DEFAULT_CONN_LATENCY,                          /**< Connection latency */
.conn_supervision_timeout        = WICED_BT_CFG_DEFAULT_CONN_SUPERVISION_TIMEOUT,              /**< Connection link supervision timeout */
},
.default_ble_power_level            = 12                                                           /**< Default LE power level, Refer lm_TxPwrTable table for the power range */
};

const wiced_bt_cfg_settings_t wiced_bt_cfg_settings =

{

.device_name = (uint8_t *)BT_LOCAL_NAME, /**< Local device name (NULL terminated) */

.device_class = {0x00, 0x00, 0x00}, /**< Local device class */

.security_requirement_mask = BTM_SEC_NONE, /**< Security requirements mask (BTM_SEC_NONE, or combinination of BTM_SEC_IN_AUTHENTICATE, BTM_SEC_OUT_AUTHENTICATE, BTM_SEC_ENCRYPT (see #wiced_bt_sec_level_e)) */

.max_simultaneous_links = 0, /**< Maximum number simultaneous links to different devices */

.ble_scan_cfg = /* BLE scan settings */

{

.scan_mode = BTM_BLE_SCAN_MODE_PASSIVE, /**< BLE scan mode (BTM_BLE_SCAN_MODE_PASSIVE, BTM_BLE_SCAN_MODE_ACTIVE, or BTM_BLE_SCAN_MODE_NONE) */

/* Advertisement scan configuration */

.high_duty_scan_interval = WICED_BT_CFG_DEFAULT_HIGH_DUTY_SCAN_INTERVAL, /**< High duty scan interval */

.high_duty_scan_window = WICED_BT_CFG_DEFAULT_HIGH_DUTY_SCAN_WINDOW, /**< High duty scan window */

.high_duty_scan_duration = 0, /**< High duty scan duration in seconds (0 for infinite) */

.low_duty_scan_interval = 96, /**< Low duty scan interval */

.low_duty_scan_window = 96, /**< Low duty scan window */

.low_duty_scan_duration = 0, /**< Low duty scan duration in seconds (0 for infinite) */

/* Connection scan configuration */

.high_duty_conn_scan_interval = WICED_BT_CFG_DEFAULT_HIGH_DUTY_CONN_SCAN_INTERVAL, /**< High duty cycle connection scan interval */

.high_duty_conn_scan_window = WICED_BT_CFG_DEFAULT_HIGH_DUTY_CONN_SCAN_WINDOW, /**< High duty cycle connection scan window */

.high_duty_conn_duration = 0, /**< High duty cycle connection duration in seconds (0 for infinite) */

.low_duty_conn_scan_interval = WICED_BT_CFG_DEFAULT_LOW_DUTY_CONN_SCAN_INTERVAL, /**< Low duty cycle connection scan interval */

.low_duty_conn_scan_window = WICED_BT_CFG_DEFAULT_LOW_DUTY_CONN_SCAN_WINDOW, /**< Low duty cycle connection scan window */

.low_duty_conn_duration = 0, /**< Low duty cycle connection duration in seconds (0 for infinite) */

/* Connection configuration */

.conn_min_interval = WICED_BT_CFG_DEFAULT_CONN_MIN_INTERVAL, /**< Minimum connection interval */

.conn_max_interval = WICED_BT_CFG_DEFAULT_CONN_MAX_INTERVAL, /**< Maximum connection interval */

.conn_latency = WICED_BT_CFG_DEFAULT_CONN_LATENCY, /**< Connection latency */

.conn_supervision_timeout = WICED_BT_CFG_DEFAULT_CONN_SUPERVISION_TIMEOUT, /**< Connection link supervision timeout */

.default_ble_power_level = 12 /**< Default LE power level, Refer lm_TxPwrTable table for the power range */

};

app_bt_management_callback

The last thing that you need to provide is a management callback. This function is called by the Bluetooth Stack when a “management event” occurs. There is a big-long-list of enumerated events of type wiced_bt_management_event_t. The events include things like the the stack started “BTM_ENABLED_EVENT”. Each event may have data associated with the event which is passed to you in a pointer to wiced_bt_management_event_data_t.

You typically deal with these events with a giant switch statement like this:

wiced_result_t app_bt_management_callback(wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data)
{
wiced_result_t result = WICED_BT_SUCCESS;
switch (event)
{
case BTM_ENABLED_EVT:
if (WICED_BT_SUCCESS == p_event_data->enabled.status)
{
printf("Stack Started Successfully\n");
}
break;
default:
printf("Unhandled Bluetooth Management Event: 0x%x %s\n", event, btutil_getBTEventName(event));
break;
}
return result;
}

wiced_result_t app_bt_management_callback(wiced_bt_management_evt_t event, wiced_bt_management_evt_data_t *p_event_data)

{

wiced_result_t result = WICED_BT_SUCCESS;

switch (event)

{

case BTM_ENABLED_EVT:

if (WICED_BT_SUCCESS == p_event_data->enabled.status)

{

printf("Stack Started Successfully\n");

}

break;

default:

printf("Unhandled Bluetooth Management Event: 0x%x %s\n", event, btutil_getBTEventName(event));

break;

}

return result;

}

Tasks

The Bluetooth stack on the PSoC6 is operated with two tasks. Specifically, when you call the wiced_bt_stack_init it will startup:

CYBT_HCI_Task – a task that sends and receives HCI packets going to the Radio chip
CY_BT_Task – a task that manages the Bluetooth Host Stack

Here is print of the task list from my project:

AnyCloud> tasks
Name          State Priority   Stack  Num
------------------------------------------
nt shell        X       0       236     5
IDLE            R       0       115     6
blink           B       0       98      4
CYBT_BT_Task    B       4       1371    2
sleep_task      B       6       217     1
CYBT_HCI_Task   B       5       950     3
Tmr Svc         B       6       76      7
‘B’ – Blocked
‘R’ – Ready
‘D’ – Deleted (waiting clean up)
‘S’ – Suspended, or Blocked without a timeout
Stack = bytes free at highwater

AnyCloud> tasks

Name State Priority Stack Num

------------------------------------------

nt shell X 0 236 5

IDLE R 0 115 6

blink B 0 98 4

CYBT_BT_Task B 4 1371 2

sleep_task B 6 217 1

CYBT_HCI_Task B 5 950 3

Tmr Svc B 6 76 7

‘B’ – Blocked

‘R’ – Ready

‘D’ – Deleted (waiting clean up)

‘S’ – Suspended, or Blocked without a timeout

Stack = bytes free at highwater

Now with the background in place, in the next article I will discuss Bluetooth advertising and how to build the observer project.

PSoC 6 BLE Events

Edit: It turns out that I wrote this article in February of 2018 and never published it. But it has good stuff… so here it is.

Summary

Over the last several weeks I have been spending time working with the PSoC 6 BLE. Specifically the BLE part of the system. Last weekend I found myself having problems with my design and I was really struggling to figure them out. I realized that I “knew” what was happening with the BLE callbacks… but that I didn’t really “KNOW!”. So I decided to build a simple project to show what events were happening and why.

In this article I will show/tell you how (to):

The BLE is supposed to work
The PSoC 6 BLE example project
Write the firmware
Test the system

You can “git” this workspace at git@github.com:iotexpert/PSoC-6-BLE-Events.git or GitHub.

How the PSoC 6 BLE is supposed to work

Honestly, the first time I started looking at the BLE (in my case it was the PSoC 4 BLE), it felt overwhelming. But, it is actually pretty simple. You, the firmware developer, send commands to the BLE stack using the Cypress PDL BLE middleware API. Then, when “something” happens, the BLE stack sends you back an “event” in the callback. That “something” can either be an acknowledgement that your API call has done something, or, it can be that something has happened on the radio side (e.g. you have been connected to by a client). When you write a PSoC 6 BLE program you need to provide an event handler function (so that the BLE stack can send you events). The function prototype for that handler is:

void CyBle_AppCallback( uint32 eventCode, void *eventParam )

1	void CyBle_AppCallback( uint32 eventCode, void *eventParam )

This function has two arguments.

An integer that is an eventCode (which you can put into the switch). All of the event codes will look like “CYBLE_EVT_”
A void pointer, that you will cast into a specific pointer based on the event code.

Your event handler code will then be a big switch statement, where you will look at the events, and do something (or not).

void CyBle_AppCallback( uint32 eventCode, void *eventParam )
{
switch( eventCode )
{
/* Generic events */
case CYBLE_EVT_STACK_ON:
/* CyBle_GappStartAdvertisement( CYBLE_ADVERTISING_FAST ); */
break;

void CyBle_AppCallback( uint32 eventCode, void *eventParam )

{

switch( eventCode )

{

/* Generic events */

case CYBLE_EVT_STACK_ON:

/* CyBle_GappStartAdvertisement( CYBLE_ADVERTISING_FAST ); */

break;

When you look in the PDL BLE Middleware documentation you can see the APIs and what events happen based on your API calls. For example Cy_BLE_GAPP_StartAdvertisement tell the PSoC BLE Stack to start advertising. You can see that it will generate 4 possible events i.e. CY_BLE_EVT_GAPP_START_STOP

When you click on the event in the documentation it will tell you the meaning of the event, and what the eventParameter means (i.e. what you should cast it to in order to figure out the data passed to you)

Build the project

To build the project, first make a new PSoC 63 BLE project. Then edit the schematic to have a BLE and a UART.

Assign the UART pins to the KitProg UART bridge pins (aka P50/P51)

Configure the BLE to be a GAP Peripheral.

Add a custom service to the project by loading the LED Service. It doesn’t really matter what service you add for this project. I just picked this one because I am using it for another project. You could have just as easily picked one of the pre-existing definitions or made your own.

This is what the LED Service looks like.

Configure the GAP settings. Specifically name your device – in this case I named mine “mytest”

Edit the advertising packet to include the name and the service.

Write the Firmware

Remember the main event in this example project is the BLE Event Handler. I created this event handler with the events that I normally used (i.e. CY_BLE_EVT_STACK_ON) and then kept adding events until I had them all defined. The way that I knew an event was missing from the “switch” was by the default case printing out the event number.

void customEventHandler(uint32_t event, void *eventParameter)
{
/* Take an action based on the current event */
switch (event)
{
/* This event is received when the BLE stack is Started */
case CY_BLE_EVT_STACK_ON:
printf("CY_BLE_EVT_STACK_ON\r\n");
Cy_BLE_GAPP_StartAdvertisement(CY_BLE_ADVERTISING_FAST, CY_BLE_PERIPHERAL_CONFIGURATION_0_INDEX);
break;
case CY_BLE_EVT_GAP_DEVICE_DISCONNECTED:
printf("CY_BLE_EVT_GAP_DEVICE_DISCONNECTED: bdHandle=%x, reason=%x, status=%x\r\n-------------\r\n",
(unsigned int)(*(cy_stc_ble_gap_disconnect_param_t *)eventParameter).bdHandle,
(unsigned int)(*(cy_stc_ble_gap_disconnect_param_t *)eventParameter).reason,
(unsigned int)(*(cy_stc_ble_gap_disconnect_param_t *)eventParameter).status);
Cy_BLE_GAPP_StartAdvertisement(CY_BLE_ADVERTISING_FAST, CY_BLE_PERIPHERAL_CONFIGURATION_0_INDEX);
break;
case CY_BLE_EVT_GATT_CONNECT_IND:
printf("CY_BLE_EVT_GATT_CONNECT_IND bdHandle=%x\r\n",((cy_stc_ble_conn_handle_t *)eventParameter)->bdHandle);
break;
case CY_BLE_EVT_GAP_ENHANCE_CONN_COMPLETE:
printf("CY_BLE_EVT_GAP_ENHANCE_CONN_COMPLETE\r\n");
break;
case CY_BLE_EVT_TIMEOUT:
printf("CY_BLE_EVT_TIMEOUT\r\n");
break;
case CY_BLE_EVT_GATTS_READ_CHAR_VAL_ACCESS_REQ:
printf("CY_BLE_EVT_GATTS_READ_CHAR_VAL_ACCESS_REQ\r\n");
break;
case CY_BLE_EVT_GATTS_XCNHG_MTU_REQ:
printf("CY_BLE_EVT_GATTS_XCNHG_MTU_REQ\r\n");
break;
case CY_BLE_EVT_SET_DEVICE_ADDR_COMPLETE:
printf("CY_BLE_EVT_SET_DEVICE_ADDR_COMPLETE\r\n");
break;
case CY_BLE_EVT_LE_SET_EVENT_MASK_COMPLETE:
printf("CY_BLE_EVT_LE_SET_EVENT_MASK_COMPLETE\r\n");
break;
case CY_BLE_EVT_SET_TX_PWR_COMPLETE:
printf("CY_BLE_EVT_SET_TX_PWR_COMPLETE\r\n");
break;
case CY_BLE_EVT_GATT_DISCONNECT_IND:
printf("CY_BLE_EVT_GATT_DISCONNECT_IND\r\n");
break;
case CY_BLE_EVT_GAPP_ADVERTISEMENT_START_STOP:
printf("CY_BLE_EVT_GAPP_ADVERTISEMENT_START_STOP = ");
if(Cy_BLE_GetAdvertisementState() == CY_BLE_ADV_STATE_STOPPED)
printf("CY_BLE_ADV_STATE_STOPPED");
if(Cy_BLE_GetAdvertisementState() == CY_BLE_ADV_STATE_ADV_INITIATED)
printf("CY_BLE_ADV_STATE_ADV_INITIATED");
if(Cy_BLE_GetAdvertisementState() == CY_BLE_ADV_STATE_ADVERTISING)
printf("CY_BLE_ADV_STATE_ADVERTISING");
if(Cy_BLE_GetAdvertisementState() == CY_BLE_ADV_STATE_STOP_INITIATED)
printf("CY_BLE_ADV_STATE_STOP_INITIATED");
printf("\r\n");
break;
case CY_BLE_EVT_GATTS_INDICATION_ENABLED:
printf("CY_BLE_EVT_GATTS_INDICATION_ENABLED\r\n");
break;
case CY_BLE_EVT_GAP_DEVICE_CONNECTED:
printf("CY_BLE_EVT_GAP_DEVICE_CONNECTED\r\n");
break;
default:
printf("Unknown Event = %X\n",(unsigned int)event);
break;
}
}

void customEventHandler(uint32_t event, void *eventParameter)

{

/* Take an action based on the current event */

switch (event)

{

/* This event is received when the BLE stack is Started */

case CY_BLE_EVT_STACK_ON:

printf("CY_BLE_EVT_STACK_ON\r\n");

Cy_BLE_GAPP_StartAdvertisement(CY_BLE_ADVERTISING_FAST, CY_BLE_PERIPHERAL_CONFIGURATION_0_INDEX);

break;

case CY_BLE_EVT_GAP_DEVICE_DISCONNECTED:

printf("CY_BLE_EVT_GAP_DEVICE_DISCONNECTED: bdHandle=%x, reason=%x, status=%x\r\n-------------\r\n",

(unsigned int)(*(cy_stc_ble_gap_disconnect_param_t *)eventParameter).bdHandle,

(unsigned int)(*(cy_stc_ble_gap_disconnect_param_t *)eventParameter).reason,

(unsigned int)(*(cy_stc_ble_gap_disconnect_param_t *)eventParameter).status);

Cy_BLE_GAPP_StartAdvertisement(CY_BLE_ADVERTISING_FAST, CY_BLE_PERIPHERAL_CONFIGURATION_0_INDEX);

break;

case CY_BLE_EVT_GATT_CONNECT_IND:

printf("CY_BLE_EVT_GATT_CONNECT_IND bdHandle=%x\r\n",((cy_stc_ble_conn_handle_t *)eventParameter)->bdHandle);

break;

case CY_BLE_EVT_GAP_ENHANCE_CONN_COMPLETE:

printf("CY_BLE_EVT_GAP_ENHANCE_CONN_COMPLETE\r\n");

break;

case CY_BLE_EVT_TIMEOUT:

printf("CY_BLE_EVT_TIMEOUT\r\n");

break;

case CY_BLE_EVT_GATTS_READ_CHAR_VAL_ACCESS_REQ:

printf("CY_BLE_EVT_GATTS_READ_CHAR_VAL_ACCESS_REQ\r\n");

break;

case CY_BLE_EVT_GATTS_XCNHG_MTU_REQ:

printf("CY_BLE_EVT_GATTS_XCNHG_MTU_REQ\r\n");

break;

case CY_BLE_EVT_SET_DEVICE_ADDR_COMPLETE:

printf("CY_BLE_EVT_SET_DEVICE_ADDR_COMPLETE\r\n");

break;

case CY_BLE_EVT_LE_SET_EVENT_MASK_COMPLETE:

printf("CY_BLE_EVT_LE_SET_EVENT_MASK_COMPLETE\r\n");

break;

case CY_BLE_EVT_SET_TX_PWR_COMPLETE:

printf("CY_BLE_EVT_SET_TX_PWR_COMPLETE\r\n");

break;

case CY_BLE_EVT_GATT_DISCONNECT_IND:

printf("CY_BLE_EVT_GATT_DISCONNECT_IND\r\n");

break;

case CY_BLE_EVT_GAPP_ADVERTISEMENT_START_STOP:

printf("CY_BLE_EVT_GAPP_ADVERTISEMENT_START_STOP = ");

if(Cy_BLE_GetAdvertisementState() == CY_BLE_ADV_STATE_STOPPED)

printf("CY_BLE_ADV_STATE_STOPPED");

if(Cy_BLE_GetAdvertisementState() == CY_BLE_ADV_STATE_ADV_INITIATED)

printf("CY_BLE_ADV_STATE_ADV_INITIATED");

if(Cy_BLE_GetAdvertisementState() == CY_BLE_ADV_STATE_ADVERTISING)

printf("CY_BLE_ADV_STATE_ADVERTISING");

if(Cy_BLE_GetAdvertisementState() == CY_BLE_ADV_STATE_STOP_INITIATED)

printf("CY_BLE_ADV_STATE_STOP_INITIATED");

printf("\r\n");

break;

case CY_BLE_EVT_GATTS_INDICATION_ENABLED:

printf("CY_BLE_EVT_GATTS_INDICATION_ENABLED\r\n");

break;

case CY_BLE_EVT_GAP_DEVICE_CONNECTED:

printf("CY_BLE_EVT_GAP_DEVICE_CONNECTED\r\n");

break;

default:

printf("Unknown Event = %X\n",(unsigned int)event);

break;

}

Now you need a task to run the BLE. It just runs the Cy_BLE_ProcessEvents each time an event needs to be handled.

void bleTask(void *arg)
{
(void)arg;
printf("\033[2J\033[H"); // Clear Screen
printf("Started BLE Task\r\n");
#ifdef USE_RTOS
bleSemaphore = xSemaphoreCreateCounting(2^32-1,0);
printf("Using RTOS\r\n");
#else
printf("Bare Metal\r\n");
#endif
printf("Cy_SysLib_GetDeviceRevision() %X \r\n", Cy_SysLib_GetDeviceRevision());
Cy_BLE_Start(customEventHandler);
#ifdef USE_RTOS
Cy_BLE_IPC_RegisterAppHostCallback(bleInterruptNotify);
//Cy_BLE_RegisterInterruptCallback(2^32-1,bleInterruptNotify);
while(Cy_BLE_GetState() != CY_BLE_STATE_ON)
{
Cy_BLE_ProcessEvents();
}
#endif
for(;;)
{
#ifdef USE_RTOS
xSemaphoreTake(bleSemaphore,portMAX_DELAY);
#endif
Cy_BLE_ProcessEvents();         
}
}
int main(void)
{
__enable_irq(); /* Enable global interrupts. */
UART_1_Start();
printf("Started Project\r\n");
#ifndef USE_RTOS
bleTask(0);
#endif
xTaskCreate(bleTask,"bleTask",4*1024,0,1,0);
vTaskStartScheduler();
}

void bleTask(void *arg)

{

(void)arg;

printf("\033[2J\033[H"); // Clear Screen

printf("Started BLE Task\r\n");

#ifdef USE_RTOS

bleSemaphore = xSemaphoreCreateCounting(2^32-1,0);

printf("Using RTOS\r\n");

#else

printf("Bare Metal\r\n");

#endif

printf("Cy_SysLib_GetDeviceRevision() %X \r\n", Cy_SysLib_GetDeviceRevision());

Cy_BLE_Start(customEventHandler);

#ifdef USE_RTOS

Cy_BLE_IPC_RegisterAppHostCallback(bleInterruptNotify);

//Cy_BLE_RegisterInterruptCallback(2^32-1,bleInterruptNotify);

while(Cy_BLE_GetState() != CY_BLE_STATE_ON)

{

Cy_BLE_ProcessEvents();

}

#endif

for(;;)

{

#ifdef USE_RTOS

xSemaphoreTake(bleSemaphore,portMAX_DELAY);

#endif

Cy_BLE_ProcessEvents();

}

int main(void)

{

__enable_irq(); /* Enable global interrupts. */

UART_1_Start();

printf("Started Project\r\n");

#ifndef USE_RTOS

bleTask(0);

#endif

xTaskCreate(bleTask,"bleTask",4*1024,0,1,0);

vTaskStartScheduler();

}

Test the System

Finally program the CY8CKIT-062-BLE and attach with it to CySmart or LightBlue. There are three phases

The stack turns on and starts advertising (CY_BLE_EVT_STACK_ON –> CY_BLE_EVT_GAPP_ADVERTISMENT)
A connection is made and eventually disconnected (CY_BLE_EVT_CONNECT_IND –> CY_BLE_EVT_GAP_DEVICE_DISCONNECTED
You start advertising again CY_BLE_EVT_GAPP_ADVERTISEMENT_START_STOP

MBEDOS & BLE & PSoC 6 & CYW4343W

Summary

At the Embedded World Show in Germany in a couple of weeks I am going to be showing a crazy demo (more on this later) that uses MBED OS and BLE and WiFi and PSoC 6 and the 4343W. Given how close things are and how new MBED OS is to me I figure that I had better get going sorting out the BLE interface. This article and probably the next several are going to show my progress through the learning curve.

It turns out that in MBED OS, instead of using the Cypress BLE Host Stack I will be using the ARM Cordio BLE host stack talking via HCI to the Cypress BLE Controller stack running on the 4343W (a Bluetooth, BLE and WiFi combo chip). At this point all of my experience with BLE has been with Cypress stacks, either the PSoC 4/6 BLE stack or with the Cypress IoT stacks e.g. the CYW20719. Lot’s of new learning. Add in that all of the code is in C++ and it makes for an adventure.

For this article I will show the steps to get an ARM BLE example going on the CY8CPROTO_062_4343W development kit. This will involve.

Importing the ARM MBEDOS BLE Examples
Modifying them to support the Cypress Targets & Test
Updating an example program in a few places to fix things that I don’t like.

Import ARM MBED OS BLE Examples

The first step is to make a clone of the ARM examples by running “mbed import mbed-os-example-ble”. This will load a bunch of different example projects (as libraries)

Then, when you look at what you have after all of that mess, you can see 14 example programs with promising names.

When you look in the BLE_LED directory you will find a file “readme.md” which is a markdown formatted file. You can view this file on the GitHub website for this example here. The top of this one looks promising:

Modify and Test

I decide that the example called “BLE_LED” looks like a good place to start. This example is a simple peripheral that advertises it name. When you connect to it there is a Service with UUID “0xA000” (unfortunately a 16-bit UUID… bad demo code) that Service has one characteristic with UUID 0xA001 (another 16-UUID … that isn’t nice … come on people… haven’t you read the spec?). When you write a “1” to that characteristic the LED2 is supposed to turn on, and when you write a 0 the LED2 is supposed to turn off.

First, until the Cypress stuff is accepted into the main release, I need to update mbed-os to our targets) with “cd mbed-os ; mbed update master”. To build this project Ill run “mbed compile -t GCC_ARM -m CY8CPROTO_062_4343W”. When I program the the development kit, the LED starts blinking and I am able to see it using the GATT browser LightBlue Explorer.

But when I try to write a 1 to the 0xA001 characteristic nothing happens.

So, what gives? The answer is that on line 32 you can see that the authors as assuming that you have two LEDs (my development kit only has one.

_alive_led(LED2, 1),
_actuated_led(LED1, 0),

_alive_led(LED2, 1),

_actuated_led(LED1, 0),

And on line 124 you can see a function that inverts the LED

void blink() {
_alive_led = !_alive_led;
}

124

125

126

void blink() {

_alive_led = !_alive_led;

}

which is triggered on line 47 to be called every 500ms

void start() {
_ble.gap().setEventHandler(this);
_ble.init(this, &LEDDemo::on_init_complete);
_event_queue.call_every(2000, this, &LEDDemo::blink);
_event_queue.dispatch_forever();
}

void start() {

_ble.gap().setEventHandler(this);

_ble.init(this, &LEDDemo::on_init_complete);

_event_queue.call_every(2000, this, &LEDDemo::blink);

_event_queue.dispatch_forever();

}

OK. I am not loving this. I think that I should make some updates to this project.

Update

There are several things that I don’t like about this program or need to be fixed.

Make the user LED2 be LED1 and fix the fact that it is active low.
Change the UUIDs of the Service and Characteristic to be legal 128-bit UUIDs
Make the stdio print out the status of the connection (instead of the blinking LED1)
Make the baud rate of standard i/o be 115200 instead of 9600

First, fix the LED2 to be LED1. Do this by commenting out all of the _alive_led code and switching the _actuated_led to be LED1. Also set the state of the LED1 to 1 (meaning off because it is active low)

//_alive_led(LED1, 1),
_actuated_led(LED1, 1),

//_alive_led(LED1, 1),

_actuated_led(LED1, 1),

The author of the example code has a function called blink which is executed by the event queue every 500ms, comment out that function

/*
void blink() {
_alive_led = !_alive_led;
}
*/

131

132

133

134

135

void blink() {

_alive_led = !_alive_led;

}

And don’t inject events into the queue to run the blink function

//_event_queue.call_every(500, this, &LEDDemo::blink);

55	//_event_queue.call_every(500, this, &LEDDemo::blink);

The LED on my board is active low… so instead of writing the value write the opposite of the value.

_actuated_led = !*(params->data);

128	_actuated_led = !*(params->data);

It is illegal in Bluetooth to use 16-bit UUIDs without first registering them with the Bluetooth SIG and having them be “Assigned numbers”. The author of this example program violated the specification by assigning the LED service UUID of 0xA000 and the LED characteristic UUID of 0xA001. This is super annoying and I am not willing to be a slob. To fix this modify ledservice.h to declare the UUIDs as UUID type instead of uint16_ts

//const static uint16_t LED_SERVICE_UUID              = 0xA000;
//const static uint16_t LED_STATE_CHARACTERISTIC_UUID = 0xA001;
const static UUID LED_SERVICE_UUID;
const static UUID LED_STATE_CHARACTERISTIC_UUID;

//const static uint16_t LED_SERVICE_UUID = 0xA000;

//const static uint16_t LED_STATE_CHARACTERISTIC_UUID = 0xA001;

const static UUID LED_SERVICE_UUID;

const static UUID LED_STATE_CHARACTERISTIC_UUID;

Then initialize them in the main.cpp as 128-bit UUIDs using the const char * initializer.

const UUID LEDService::LED_SERVICE_UUID("21c04d09-c884-4af1-96a9-52e4e4ba195b");
const UUID LEDService::LED_STATE_CHARACTERISTIC_UUID("1e500043-6b31-4a3d-b91e-025f92ca9763");

const UUID LEDService::LED_SERVICE_UUID("21c04d09-c884-4af1-96a9-52e4e4ba195b");

const UUID LEDService::LED_STATE_CHARACTERISTIC_UUID("1e500043-6b31-4a3d-b91e-025f92ca9763");

The original code has a blinking LED. Which I dont really like. Typically, I like to blink the LED when the device is advertising, and make it be solid when there is a connection. However, as I only have one LED on my board, and I have allocated it to be the “_actuated_led”, I will use the UART to print out status changes. To do this, I update the “onDisconnectionComplete” and “onConnectionComplete” events to print out that fact to stdio.

void onDisconnectionComplete(const ble::DisconnectionCompleteEvent&) {
_ble.gap().startAdvertising(ble::LEGACY_ADVERTISING_HANDLE);
printf("DisconnectionCompleteEvent\n");
}
void onConnectionComplete	(	const ble::ConnectionCompleteEvent & 	event	)
{
printf("onConnectionComplete\n");
}

139

140

141

142

143

144

145

146

147

void onDisconnectionComplete(const ble::DisconnectionCompleteEvent&) {

_ble.gap().startAdvertising(ble::LEGACY_ADVERTISING_HANDLE);

printf("DisconnectionCompleteEvent\n");

}

void onConnectionComplete ( const ble::ConnectionCompleteEvent & event )

{

printf("onConnectionComplete\n");

}

In order to set the stdio to use 115200 instead of 9600 you can change the default rate of the UART in the mbed_app.json.

"CY8CPROTO_062_4343W": {
"platform.stdio-baud-rate": 115200,
"platform.default-serial-baud-rate": 115200
},

"CY8CPROTO_062_4343W": {

"platform.stdio-baud-rate": 115200,

"platform.default-serial-baud-rate": 115200

Here is the final version of main.cpp

/* mbed Microcontroller Library
* Copyright (c) 2006-2013 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <events/mbed_events.h>
#include <mbed.h>
#include "ble/BLE.h"
#include "LEDService.h"
#include "pretty_printer.h"
const static char DEVICE_NAME[] = "LED";
static EventQueue event_queue(/* event count */ 10 * EVENTS_EVENT_SIZE);
//const UUID::LongUUIDBytes_t testbytes = { 0x21, 0xc0, 0x4d, 0x09, 0xc8, 0x84, 0x4a, 0xf1, 0x96, 0xa9, 0x52, 0xe4, 0xe4, 0xba, 0x19, 0x5b } ;
// {0x1e, 0x50, 0x00, 0x43, 0x6b, 0x31, 0x4a, 0x3d, 0xb9, 0x1e, 0x02, 0x5f, 0x92, 0xca, 0x97, 0x63}
//const UUID LEDService::LED_SERVICE_UUID(testbytes,UUID::MSB);
const UUID LEDService::LED_SERVICE_UUID("21c04d09-c884-4af1-96a9-52e4e4ba195b");
const UUID LEDService::LED_STATE_CHARACTERISTIC_UUID("1e500043-6b31-4a3d-b91e-025f92ca9763");
class LEDDemo : ble::Gap::EventHandler {
public:
LEDDemo(BLE &ble, events::EventQueue &event_queue) :
_ble(ble),
_event_queue(event_queue),
//_alive_led(LED1, 1),
_actuated_led(LED1, 1),
_led_uuid(LEDService::LED_SERVICE_UUID),
_led_service(NULL),
_adv_data_builder(_adv_buffer) { }
~LEDDemo() {
delete _led_service;
}
void start() {
_ble.gap().setEventHandler(this);
_ble.init(this, &LEDDemo::on_init_complete);
//_event_queue.call_every(500, this, &LEDDemo::blink);
_event_queue.dispatch_forever();
}
private:
/** Callback triggered when the ble initialization process has finished */
void on_init_complete(BLE::InitializationCompleteCallbackContext *params) {
if (params->error != BLE_ERROR_NONE) {
printf("Ble initialization failed.");
return;
}
_led_service = new LEDService(_ble, false);
_ble.gattServer().onDataWritten(this, &LEDDemo::on_data_written);
print_mac_address();
start_advertising();
}
void start_advertising() {
/* Create advertising parameters and payload */
ble::AdvertisingParameters adv_parameters(
ble::advertising_type_t::CONNECTABLE_UNDIRECTED,
ble::adv_interval_t(ble::millisecond_t(1000))
);
_adv_data_builder.setFlags();
_adv_data_builder.setLocalServiceList(mbed::make_Span(&_led_uuid, 1));
_adv_data_builder.setName(DEVICE_NAME);
/* Setup advertising */
ble_error_t error = _ble.gap().setAdvertisingParameters(
ble::LEGACY_ADVERTISING_HANDLE,
adv_parameters
);
if (error) {
printf("_ble.gap().setAdvertisingParameters() failed\r\n");
return;
}
error = _ble.gap().setAdvertisingPayload(
ble::LEGACY_ADVERTISING_HANDLE,
_adv_data_builder.getAdvertisingData()
);
if (error) {
printf("_ble.gap().setAdvertisingPayload() failed\r\n");
return;
}
/* Start advertising */
error = _ble.gap().startAdvertising(ble::LEGACY_ADVERTISING_HANDLE);
if (error) {
printf("_ble.gap().startAdvertising() failed\r\n");
return;
}
}
/**
* This callback allows the LEDService to receive updates to the ledState Characteristic.
*
* @param[in] params Information about the characterisitc being updated.
*/
void on_data_written(const GattWriteCallbackParams *params) {
if ((params->handle == _led_service->getValueHandle()) && (params->len == 1)) {
_actuated_led = !*(params->data);
}
}
/*
void blink() {
_alive_led = !_alive_led;
}
*/
private:
/* Event handler */
void onDisconnectionComplete(const ble::DisconnectionCompleteEvent&) {
_ble.gap().startAdvertising(ble::LEGACY_ADVERTISING_HANDLE);
printf("DisconnectionCompleteEvent\n");
}
void onConnectionComplete	(	const ble::ConnectionCompleteEvent & 	event	)
{
printf("onConnectionComplete\n");
}
private:
BLE &_ble;
events::EventQueue &_event_queue;
//DigitalOut _alive_led;
DigitalOut _actuated_led;
UUID _led_uuid;
LEDService *_led_service;
uint8_t _adv_buffer[ble::LEGACY_ADVERTISING_MAX_SIZE];
ble::AdvertisingDataBuilder _adv_data_builder;
};
/** Schedule processing of events from the BLE middleware in the event queue. */
void schedule_ble_events(BLE::OnEventsToProcessCallbackContext *context) {
event_queue.call(Callback<void()>(&context->ble, &BLE::processEvents));
}
int main()
{
printf("Example Bluetooth\n");
BLE &ble = BLE::Instance();
ble.onEventsToProcess(schedule_ble_events);
LEDDemo demo(ble, event_queue);
demo.start();
return 0;
}