Steval Bluemic 1 Evaluation Board

Steval Bluemic 1 Evaluation Board Documentation

Overview

The Steval Bluemic 1 Evaluation Board is a compact, low-power, and cost-effective Bluetooth Low Energy (BLE) module based on the BlueNRG-1 system-on-chip (SoC). This module is designed for IoT applications, providing a complete solution for wireless connectivity, with a focus on smart sensors, wearables, and other battery-powered devices.

Hardware Features

BlueNRG-1 SoC with Arm Cortex-M0 processor
 256 KB flash memory and 24 KB RAM
 Bluetooth Low Energy (BLE) v4.2 compliant
 2.4 GHz radio frequency (RF) transceiver
 On-board PCB antenna
 UART, SPI, I2C, and GPIO interfaces
 Operating voltage: 1.8 V to 3.6 V
 Power consumption: < 4 mA in receive mode, < 5 mA in transmission mode

Software Development

The Steval Bluemic 1 Evaluation Board can be programmed using the STM32CubeMX software tool, which provides a graphical interface for configuring the module's peripherals and generating code. The examples below demonstrate how to use the Steval Bluemic 1 Evaluation Board in various contexts.

Example 1: BLE Peripheral Device

In this example, we will create a BLE peripheral device that advertises its presence and allows a central device to connect and read data from a sensor.

Hardware Requirements

Steval Bluemic 1 Evaluation Board
 Breadboard and jumper wires
 Sensor module (e.g., temperature, humidity, or accelerometer)

Software Requirements

STM32CubeMX software tool
 ARM Keil Vision IDE (optional)

Code Example (using STM32CubeMX)
```c
#include "bluenrg_mesh1.h"

#define SENSOR_PIN  GPIO_PIN_5

int main(void) {
    // Initialize the BLE module
    mesh_init();

// Set up the sensor pin as an input
    gpio_init(SENSOR_PIN, GPIO_MODE_INPUT);

// Create a BLE service and characteristic
    mesh_service_t service = mesh_service_create(UUIDprimaryService);
    mesh_char_t char_temp = mesh_char_create(UUIDtemperature, MESH_CHAR_props_notify);

// Advertise the BLE device
    mesh_advertise_start();

while (1) {
        // Read the sensor value
        int sensor_value = gpio_read(SENSOR_PIN);

// Update the BLE characteristic value
        mesh_char_update_value(char_temp, &sensor_value,sizeof(sensor_value));

// Wait for 1 second before updating again
        delay(1000);
    }
}
```
Example 2: BLE Central Device

In this example, we will create a BLE central device that scans for available BLE devices, connects to a peripheral device, and reads data from a sensor.

Hardware Requirements

Steval Bluemic 1 Evaluation Board
 Breadboard and jumper wires

Software Requirements

STM32CubeMX software tool
 ARM Keil Vision IDE (optional)

Code Example (using STM32CubeMX)
```c
#include "bluenrg_mesh1.h"

int main(void) {
    // Initialize the BLE module
    mesh_init();

// Set up the BLE central device
    mesh_central_t central = mesh_central_create();

// Scan for available BLE devices
    mesh_scan_start();

while (1) {
        // Wait for a BLE device to be discovered
        mesh_device_t device = mesh_scan_get_device();

if (device != NULL) {
            // Connect to the BLE device
            mesh_connect(device);

// Discover the BLE services and characteristics
            mesh_service_t service = mesh_service_discover(device, UUIDprimaryService);
            mesh_char_t char_temp = mesh_char_discover(service, UUIDtemperature);

// Read the BLE characteristic value
            int sensor_value;
            mesh_char_read_value(char_temp, &sensor_value, sizeof(sensor_value));

// Print the sensor value
            printf("Sensor value: %d
", sensor_value);

// Disconnect from the BLE device
            mesh_disconnect(device);
        }
    }
}
```
Example 3: Interfacing with a Microcontroller

In this example, we will demonstrate how to interface the Steval Bluemic 1 Evaluation Board with a microcontroller (e.g., STM32) using UART communication.

Hardware Requirements

Steval Bluemic 1 Evaluation Board
 Microcontroller board (e.g., STM32 Nucleo)
 Breadboard and jumper wires

Software Requirements

STM32CubeMX software tool
 ARM Keil Vision IDE (optional)

Code Example (using STM32CubeMX)
```c
#include "bluenrg_mesh1.h"
#include "stm32f4xx_hal.h"

#define UART_BAUDRATE  115200

int main(void) {
    // Initialize the UART interface
    UART_HandleTypeDef huart;
    huart.Instance = USART1;
    huart.Init.BaudRate = UART_BAUDRATE;
    huart.Init.WordLength = UART_WORDLENGTH_8B;
    huart.Init.StopBits = UART_STOPBITS_1;
    huart.Init.Parity = UART_PARITY_NONE;
    huart.Init.Mode = UART_MODE_TX_RX;
    HAL_UART_Init(&huart);

// Initialize the BLE module
    mesh_init();

while (1) {
        // Send a command to the BLE module using UART
        char cmd[] = "AT+BLE_CMD
";
        HAL_UART_Transmit(&huart, (uint8_t )cmd, sizeof(cmd), 100);

// Receive the response from the BLE module
        char resp[50];
        HAL_UART_Receive(&huart, (uint8_t )resp, 50, 100);

// Process the response
        printf("Response: %s
", resp);
    }
}
```
These examples demonstrate the basic functionality of the Steval Bluemic 1 Evaluation Board and provide a starting point for developing more complex IoT applications.