Overview: Create BLE Project using STM32 Microcontroller & BlueIO
In this tutorial, we will learn how to Create BLE Project using STM32 Microcontroller & BlueIO. The project is a simple example showcasing a quick way to set up a STM32Cube project as a USB CDC Host capable of communicating with the BleuIO Dongle.
When a BleuIO Dongle is connected to the Nucleo boards USB port the STM32 will recognize it. It will then accept 3 different inputs from the UART and send one of 3 preprogrammed commands to the BleuIO Dongle based on the input. The commands that are used in this example are:
- ATI(Dongle Information)
- AT+ADVSTART(Starts Advertising)
- AT+ADVSTOP(Stops Advertising)
We have used an STM32 Nucleo-144 development board with STM32H743ZI microcontroller which is a micro mbed-Enabled Development Nucleo-144 series ARM® Cortex®-M7 MCU 32-Bit Embedded Evaluation Board. For this example, we will use the same STM32 Microcontroller & BlueIO & create a demo BLE project.
If you want to use another setup you will have to make sure it supports USB Host and beware that the GPIO setup might be different and may need to be reconfigured in the .ioc file.
About the Code
You can get project here: https://github.com/smart-sensor-devices-ab/stm32_bleuio_example
This project-based on a new STM32 project with these changes in the .ioc file. Under ‘Connectivity’ the ‘USB_OTG_FS’-mode is changed to Host_Only and in the NVIC Settings all global interrupts are enabled.
And under ‘Middleware’ the ‘USB_HOST’- ‘Class for FS IP’ is set to ‘Communication Host Class (Virtual Port Com)’.
To make sure the host would recognize when the bootloader is done and the BleuIO firmware is running this was added in the USBH_UserProcess function in ‘usb_host.c’ (found under ‘USB_HOST’ -> ‘App’ folder).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
static void USBH_UserProcess (USBH_HandleTypeDef *phost, uint8_t id) { /* USER CODE BEGIN CALL_BACK_1 */ switch(id) { case HOST_USER_SELECT_CONFIGURATION: break; case HOST_USER_DISCONNECTION: Appli_state = APPLICATION_DISCONNECT; isBleuIOReady = false; // Turn on Red LED, turn off Green and Yellow LED HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET); break; case HOST_USER_CLASS_ACTIVE: Appli_state = APPLICATION_READY; // Check if BleuIO firmware is running // (idProduct:0x6001 = bootloader, idProduct:0x6002 = bleuio fw) if(phost->device.DevDesc.idProduct == 0x6002) { isBleuIOReady = true; // Sends message to uart that BleuIO is connected and ready HAL_UART_Transmit(&huart3, (uint8_t*)BLEUIO_READY, strlen(BLEUIO_READY), HAL_MAX_DELAY); // Turn on Green LED, turn off Yellow and Red LED HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET); HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET); // Start receiving from usb USBH_CDC_Receive(&hUsbHostFS, CDC_RX_Buffer, RX_BUFF_SIZE); } break; case HOST_USER_CONNECTION: Appli_state = APPLICATION_START; isBleuIOReady = false; // Turn on Yellow LED, turn off Green and Red LED HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_SET); HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET); break; default: break; } /* USER CODE END CALL_BACK_1 */ } |
About the Code
The Green, Red, and Yellow LEDs on the Nucleo board are also set up to change based on the connection status as follows.
Red = Disconnnected
Yellow = Connecting
Green = Connected
An external variable bool is BleuIOReady is also set so the status of the dongle is accessible from the main.c section.
Once the BleuIO dongle is confirmed to be connected the USBH_CDC_Receive function is run to start receiving data from the USB CDC. The USBH_CDC_ReceiveCallback also needs to be implemented.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
void USBH_CDC_ReceiveCallback(USBH_HandleTypeDef *phost) { if(phost == &hUsbHostFS) { // Handles the data recived from the USB CDC host, here just printing it out to UART rx_size = USBH_CDC_GetLastReceivedDataSize(phost); HAL_UART_Transmit(&huart3, CDC_RX_Buffer, rx_size, HAL_MAX_DELAY); // Reset buffer and restart the callback function to receive more data memset(CDC_RX_Buffer,0,RX_BUFF_SIZE); USBH_CDC_Receive(phost, CDC_RX_Buffer, RX_BUFF_SIZE); } return; } |
In this example, the received data is just echoed to the UART.
To send data to the Dongle the USBH_CDC_Transmit function is used. In this example, UART input is used to send different commands. For this purpose, a wrapper function has been created that can be accessed from the main.c.
|
1 2 3 4 5 6 7 8 |
/** * @brief Simple function that takes a string and transmit it to the dongle * @retval None */ void writeToDongle(uint8_t * cmd) { USBH_CDC_Transmit(&hUsbHostFS, cmd, strlen((char *)cmd)); } |
In main.c HAL_UART_RxCpltCallback is implemented to receive input from Uart and a simple UART input handler.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 |
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle) { if(UartHandle == &huart3) { RX_value = (int)aRxBuffer[0]; uartStatus = UART_RX_NONE; switch(RX_value) { case UART_RX_0: { uartStatus = UART_RX_0; break; } case UART_RX_1: { uartStatus = UART_RX_1; break; } case UART_RX_2: { uartStatus = UART_RX_2; break; } default: { uartStatus = UART_RX_NONE; break; } } // Resets uart recieve interrupt mode HAL_UART_Receive_IT(&huart3, (uint8_t *)aRxBuffer, RXBUFFERSIZE); } } /** * @brief Simple uart input handler * @retval None */ void handleUartInput(UARTCommandTypeDef cmd) { switch(cmd) { case UART_RX_0: { // 0 uart_buf_len = sprintf(uart_tx_buf, "\r\n(0 pressed)\r\n"); HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY); if(isBleuIOReady) { writeToDongle((uint8_t*)DONGLE_CMD_ATI); } else { uart_buf_len = sprintf(uart_tx_buf, BLEUIO_NOT_READY_MSG); HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY); } uartStatus = UART_RX_NONE; break; } case UART_RX_1: { // 1 uart_buf_len = sprintf(uart_tx_buf, "\r\n(1 pressed)\r\n"); HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY); if(isBleuIOReady) { writeToDongle((uint8_t*)DONGLE_CMD_AT_ADVSTART); } else { uart_buf_len = sprintf(uart_tx_buf, BLEUIO_NOT_READY_MSG); HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY); } uartStatus = UART_RX_NONE; break; } case UART_RX_2: { // 2 uart_buf_len = sprintf(uart_tx_buf, "\r\n(2 pressed)\r\n"); HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY); if(isBleuIOReady) { writeToDongle((uint8_t*)DONGLE_CMD_AT_ADVSTOP); } else { uart_buf_len = sprintf(uart_tx_buf, BLEUIO_NOT_READY_MSG); HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY); } uartStatus = UART_RX_NONE; break; } case UART_RX_NONE: { break; } default: { uartStatus = UART_RX_NONE; break; } } } |
The handleUartInput() handles the inputs 0, 1, and 2 and maps each to certain Dongle commands. The handler is then put inside the main loop.
|
1 2 3 4 5 6 7 8 9 10 11 |
/* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { /* USER CODE END WHILE */ MX_USB_HOST_Process(); /* USER CODE BEGIN 3 */ // Simple handler for uart input handleUartInput(uartStatus); } /* USER CODE END 3 */ |
Using the example project
For creating BLE Project using STM32 Microcontroller & BlueIO, we need the following list of hardware & software.
-
- A BleuIO dongle (https://www.bleuio.com/)
- A board with an STM32 Microcontroller with a USB port. (A Nucleo-144 development board: NUCLEO-H743ZI2, was used to develop this example. (https://www.st.com/en/evaluation-tools/nucleo-h743zi.html)
To connect the dongle to the Nucleo board a “USB A to Micro USB B”-cable with a USB A female-to-female adapter can be used.)
- STM32CubeIDE (https://www.st.com/en/development-tools/stm32cubeide.html)
How to Setup the Project
Downloading the project from GitHub
Get the project from here: https://github.com/smart-sensor-devices-ab/stm32_bleuio_example
Either clone the project or download it as a zip file and unzip it, into your STM32CubeIDE workspace.
Importing as an Existing Project
From STM32CubeIDE choose File>Import…
Then choose General>Existing Projects into Workspace then click ‘Next >’
Make sure you’ve chosen your workspace in ‘Select root directory:’
You should see the project “stm32_bleuio_example”, check it, and click ‘Finish’./p>
Running the example
- In STMCubeIDE click the hammer icon to build the project.
- Open up the ‘STMicroelectronics STLink Virtual COM Port’ with a serial terminal emulation program like TeraTerm, Putty, or CoolTerm.Serial port Setup:
Baudrate: 115200
Data Bits: 8
Parity: None
Stop Bits: 1
Flow Control: None - In STMCubeIDE click the green play button to flash and run it on your board. The first time you click it the ‘Run Configuration’ window will appear. You can just leave it as is and click run.
- Connect the BleuIO Dongle.
- Wait until the message: “[BleuIO Dongle Ready]” is shown.
– Press 0 to get device information:
1 to start advertising:
2 to stop advertising:
The Dongle response will be printed to UART.
This is how you can create BLE Project using STM32 Microcontroller & BlueIO. You can also create a similar BLE Project using Arduino & BlueIO
1 Comment
what sensor can we use to detect stress before coming