There is a another issue with command utilities of Si114x. I am getting an 'error -2' when I try to give commands except reset command. For example. If I give 'si114x_regWrite' command then I got an 'error -2'.
I am using Si114x MFB. I gave command for port selection( si114x_choose_port.exe ). COM5 (USB Port) is selected which I verified by looking into 'ports.txt'. Further, I gave command as 'si114x_reset. exe'. This command is not getting executed & I am not getting any error as well. There is no response for a long time greater than five minutes.
The board is running fine & providing sample data in the GUI of control panel.
Hello, I am interfacing si7013 temperature sensor with WSTK kit on mighty gecko board. I am getting below values, please help to convert the same in degree celcius temperature
Values: Temperature value: temp=4244666040,
Temperature value: temp=4244666050,
Temperature value: temp=4244666050,
Temperature value: temp=4244666040,
Temperature value: temp=4244666018,
Code snippet:
void temperatureMeasure()
{
uint8_t htmTempBuffer[5]; /* Stores the temperature data in the Health Thermometer (HTM) format. */
uint8_t flags = 0x00; /* HTM flags set as 0 for Celsius, no time stamp and no temperature type. */
int32_t tempData; /* Stores the Temperature data read from the RHT sensor. */
uint32_t rhData = 0; /* Dummy needed for storing Relative Humidity data. */
uint32_t temperature; /* Stores the temperature data read from the sensor in the correct format */
uint32_t temperature_F;
uint8_t *p = htmTempBuffer; /* Pointer to HTM temperature buffer needed for converting values to bitstream. */
/* Convert flags to bitstream and append them in the HTM temperature data buffer (htmTempBuffer) */
UINT8_TO_BITSTREAM(p, flags);
//printf("void temperaturemeasure loop \r\n");
/* Sensor relative humidity and temperature measurement returns 0 on success, nonzero otherwise */
if (Si7013_MeasureRHAndTemp(I2C0, SI7021_ADDR, &rhData, &tempData) == 0) {
/* Convert sensor data to correct temperature format */
temperature = FLT_TO_UINT32(tempData, -3);
printf("Temperature degree C value: temp=%u, \r\n", temperature);
/* Convert temperature to bitstream and place it in the HTM temperature data buffer (htmTempBuffer) */
UINT32_TO_BITSTREAM(p, temperature);
/* Send indication of the temperature in htmTempBuffer to all "listening" clients.
* This enables the Health Thermometer in the Blue Gecko app to display the temperature.
* 0xFF as connection ID will send indications to all connections. */
gecko_cmd_gatt_server_send_characteristic_notification(
0xFF, gattdb_temperature_measurement, 5, htmTempBuffer);
}
/*else {
printf (" No data \r\n");
} */
}
Hi, I am trying to get temperature & humidity values from Si7013 sensor present on Silabs WSTK kit, I want to get the values on Bluetooth mesh light node. I have generated below code, & getting temperature values as zero every time on Android App & also not able to operate LEDs on the kit using btmesh Switch node. Please help
/***********************************************************************************************//**
* \file main.c light sensor
* \brief Silicon Labs Bluetooth mesh light example
*
* This example implements a Bluetooth mesh light node.
*
***************************************************************************************************
* <b> (C) Copyright 2017 Silicon Labs, http://www.silabs.com</b>
***************************************************************************************************
* This file is licensed under the Silabs License Agreement. See the file
* "Silabs_License_Agreement.txt" for details. Before using this software for
* any purpose, you must agree to the terms of that agreement.
**************************************************************************************************/
/* C Standard Library headers */
#include <stdlib.h>
#include <stdio.h>
// Maximum number of simultaneous Bluetooth connections
//#define MAX_CONNECTIONS 2 //////////////
#define MAX_CONNECTIONS 4
// heap for Bluetooth stack
uint8_t bluetooth_stack_heap[DEFAULT_BLUETOOTH_HEAP(MAX_CONNECTIONS) + BTMESH_HEAP_SIZE + 1760];
// Flag for indicating DFU Reset must be performed
uint8_t boot_to_dfu = 0;
/*
* Maximum number of Bluetooth advertisement sets.
* 1 is allocated for Bluetooth LE stack
* 1 one for Bluetooth mesh stack
* 1 needs to be allocated for each Bluetooth mesh network
* - Currently up to 4 networks are supported at a time
*/
#define MAX_ADVERTISERS (2 + 4)
/**
* LCD content can be updated one row at a time using function LCD_write().
* Row number is passed as parameter,the possible values are defined below.
*/
#define LCD_ROW_NAME 1 /* 1st row, device name */
#define LCD_ROW_STATUS 2 /* 2nd row, node status */
#define LCD_ROW_CONNECTION 3 /* 3rd row, connection status */
#define LCD_ROW_LIGHTNESS 4 /* 4th row, lightness level */
#define LCD_ROW_MAX 4 /* total number of rows used */
#define LCD_ROW_LEN 32 /* up to 32 characters per each row */
/** global variables */
static uint16 _elem_index = 0xffff; /* For indexing elements of the node (this example has only one element) */
static uint16 _my_address = 0; /* Address of the Primary Element of the Node */
static char LCD_data[LCD_ROW_MAX][LCD_ROW_LEN]; /* 2D array for storing the LCD content */
static uint8 num_connections = 0; /* number of active Bluetooth connections */
static uint8 conn_handle = 0xFF; /* handle of the last opened LE connection */
static uint8 init_done = 0;
//////////////////////Temperature read////////////////////////
void temperatureMeasure()
{
uint8_t htmTempBuffer[5]; /* Stores the temperature data in the Health Thermometer (HTM) format. */
uint8_t flags = 0x00; /* HTM flags set as 0 for Celsius, no time stamp and no temperature type. */
int32_t tempData; /* Stores the Temperature data read from the RHT sensor. */
uint32_t rhData = 0; /* Dummy needed for storing Relative Humidity data. */
uint32_t temperature; /* Stores the temperature data read from the sensor in the correct format */
uint8_t *p = htmTempBuffer; /* Pointer to HTM temperature buffer needed for converting values to bitstream. */
/* Convert flags to bitstream and append them in the HTM temperature data buffer (htmTempBuffer) */
UINT8_TO_BITSTREAM(p, flags);
printf("void temperaturemeasure loop \r\n");
/* Sensor relative humidity and temperature measurement returns 0 on success, nonzero otherwise */
if (Si7013_MeasureRHAndTemp(I2C0, SI7021_ADDR, &rhData, &tempData) == 0) {
/* Convert sensor data to correct temperature format */
temperature = FLT_TO_UINT32(tempData, -3);
printf("Temperature value: temp=%u, \r\n", temperature);
/* Convert temperature to bitstream and place it in the HTM temperature data buffer (htmTempBuffer) */
UINT32_TO_BITSTREAM(p, temperature);
/* Send indication of the temperature in htmTempBuffer to all "listening" clients.
* This enables the Health Thermometer in the Blue Gecko app to display the temperature.
* 0xFF as connection ID will send indications to all connections. */
gecko_cmd_gatt_server_send_characteristic_notification(
0xFF, gattdb_temperature_measurement, 5, htmTempBuffer);
}
}
/////////////////////////////////////////////////////////////
static PACKSTRUCT(struct lightbulb_state {
// On/Off Server state
uint8_t onoff_current;
uint8_t onoff_target;
// Transition Time Server state
uint8_t transtime;
e = onoff_update(element_index);
if (e == bg_err_success) {
e = mesh_lib_generic_server_publish(MESH_GENERIC_ON_OFF_SERVER_MODEL_ID,
element_index,
mesh_generic_state_on_off);
}
if (lightbulb_state.onoff_current == request->on_off) {
printf("Request for current state received; no op\n");
} else {
printf("Turning lightbulb <%s>\r\n", request->on_off ? "ON" : "OFF");
if (transition_ms == 0 && delay_ms == 0) { // Immediate change
lightbulb_state.onoff_current = request->on_off;
lightbulb_state.onoff_target = request->on_off;
if (lightbulb_state.onoff_current == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetState(LED_STATE_OFF);
} else {
LEDS_SetState(LED_STATE_ON);
}
} else if (delay_ms > 0) {
// a delay has been specified for the light change. Start a soft timer
// that will trigger the change after the given delay
// Current state remains as is for now
lightbulb_state.onoff_target = request->on_off;
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(delay_ms), TIMER_ID_DELAYED_ONOFF, 1);
// store transition parameter for later use
delayed_onoff_trans = transition_ms;
} else {
// no delay but transition time has been set.
lightbulb_state.onoff_target = request->on_off;
if (request->on_off == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetLevel(0, transition_ms);
} else {
// restore last brightness
lightbulb_state.lightness_target = lightbulb_state.lightness_last;
LEDS_SetLevel(lightbulb_state.lightness_target, transition_ms);
}
// lightbulb current state will be updated when transition is complete
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(transition_ms), TIMER_ID_ONOFF_TRANSITION, 1);
}
lightbulb_state_changed();
}
e = lightness_update(element_index);
if (e == bg_err_success) {
e = mesh_lib_generic_server_publish(MESH_LIGHTING_LIGHTNESS_SERVER_MODEL_ID,
element_index,
mesh_lighting_state_lightness_actual);
}
return e;
}
static void lightness_request(uint16_t model_id,
uint16_t element_index,
uint16_t client_addr,
uint16_t server_addr,
uint16_t appkey_index,
const struct mesh_generic_request *request,
uint32_t transition_ms,
uint16_t delay_ms,
uint8_t request_flags)
{
// for simplicity, this demo assumes that all lightness requests use the actual scale.
// other type of requests are ignored
if (request->kind != mesh_lighting_request_lightness_actual) {
return;
}
if (lightbulb_state.lightness_current == request->lightness) {
printf("Request for current state received; no op\n");
} else {
printf("Setting lightness to <%u>\r\n", request->lightness);
if (transition_ms == 0 && delay_ms == 0) { // Immediate change
lightbulb_state.lightness_current = request->lightness;
lightbulb_state.lightness_target = request->lightness;
if (request->lightness != 0) {
lightbulb_state.lightness_last = request->lightness;
}
// update LED PWM duty cycle
LEDS_SetLevel(lightbulb_state.lightness_current, 0);
} else if (delay_ms > 0) {
// a delay has been specified for the light change. Start a soft timer
// that will trigger the change after the given delay
// Current state remains as is for now
lightbulb_state.lightness_target = request->lightness;
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(delay_ms), TIMER_ID_DELAYED_LIGHTNESS, 1);
// store transition parameter for later use
delayed_lightness_trans = transition_ms;
} else {
// no delay but transition time has been set.
lightbulb_state.lightness_target = request->lightness;
LEDS_SetLevel(lightbulb_state.lightness_target, transition_ms);
// lightbulb current state will be updated when transition is complete
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(transition_ms), TIMER_ID_LIGHTNESS_TRANSITION, 1);
}
lightbulb_state_changed();
}
if (current->kind != mesh_lighting_state_lightness_actual) {
// if kind is not 'actual' then just report the change here, no change to light state
printf("lightness change, kind %u, value %u\r\n", current->kind, current->lightness.level);
return;
}
if (lightbulb_state.lightness_current != current->lightness.level) {
printf("lightness_change: from %u to %u\r\n", lightbulb_state.lightness_current, current->lightness.level);
lightbulb_state.lightness_current = current->lightness.level;
lightbulb_state_changed();
} else {
printf("lightness update -same value (%d)\r\n", lightbulb_state.lightness_current);
}
}
e = power_onoff_update(element_index);
if (e == bg_err_success) {
e = mesh_lib_generic_server_publish(MESH_GENERIC_POWER_ON_OFF_SERVER_MODEL_ID,
element_index,
mesh_generic_state_on_power_up);
}
if (lightbulb_state.transtime == request->transition_time) {
printf("Request for current state received; no op\n");
} else {
printf("Setting transtime to <0x%x>\n", request->transition_time);
lightbulb_state.transtime = request->transition_time;
lightbulb_state_changed();
}
/**
* This function loads the saved light state from Persistent Storage and
* copies the data in the global variable lightbulb_state
*/
static int lightbulb_state_load(void)
{
struct gecko_msg_flash_ps_load_rsp_t* pLoad;
/**
* this function saves the current light state in Persistent Storage so that
* the data is preserved over reboots and power cycles. The light state is hold
* in a global variable lightbulb_state. a PS key with ID 0x4004 is used to store
* the whole struct.
*/
static int lightbulb_state_store(void)
{
struct gecko_msg_flash_ps_save_rsp_t* pSave;
if (pSave->result) {
printf("lightbulb_state_store(): PS save failed, code %x\r\n", pSave->result);
return(-1);
}
return 0;
}
/**
* this function is called each time the lightbulb state in RAM is changed. It sets up a soft timer
* that will save the state in flash after small delay. The purpose is to reduce amount of unnecessary
* flash writes.
*/
static void lightbulb_state_changed(void)
{
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(5000), TIMER_ID_SAVE_STATE, 1);
}
/**
* Initialization of the models supported by this node. This function registers callbacks for
* each of the three supported models.
*/
static void init_models(void)
{
mesh_lib_generic_server_register_handler(MESH_GENERIC_ON_OFF_SERVER_MODEL_ID,
0,
onoff_request,
onoff_change);
mesh_lib_generic_server_register_handler(MESH_GENERIC_POWER_ON_OFF_SETUP_SERVER_MODEL_ID,
0,
power_onoff_request,
power_onoff_change);
mesh_lib_generic_server_register_handler(MESH_GENERIC_TRANSITION_TIME_SERVER_MODEL_ID,
0,
transtime_request,
transtime_change);
/**
* Light node initialization. This is called at each boot if provisioning is already done.
* Otherwise this function is called after provisioning is completed.
*/
void lightbulb_state_init(void)
{
/* Initialize mesh lib */
mesh_lib_init(malloc, free, 8);
memset(&lightbulb_state, 0, sizeof(struct lightbulb_state));
if (lightbulb_state_load() != 0) {
printf("lightbulb_state_load() failed, using defaults\r\n");
goto publish;
}
// Handle on power up behavior
switch (lightbulb_state.onpowerup) {
case MESH_GENERIC_ON_POWER_UP_STATE_OFF:
printf("On power up state is OFF\r\n");
lightbulb_state.onoff_current = MESH_GENERIC_ON_OFF_STATE_OFF;
lightbulb_state.onoff_target = MESH_GENERIC_ON_OFF_STATE_OFF;
LEDS_SetState(LED_STATE_OFF);
break;
case MESH_GENERIC_ON_POWER_UP_STATE_ON:
printf("On power up state is ON\r\n");
lightbulb_state.onoff_current = MESH_GENERIC_ON_OFF_STATE_ON;
lightbulb_state.onoff_target = MESH_GENERIC_ON_OFF_STATE_ON;
LEDS_SetState(LED_STATE_ON);
break;
case MESH_GENERIC_ON_POWER_UP_STATE_RESTORE:
printf("On power up state is RESTORE\r\n");
if (lightbulb_state.onoff_current != lightbulb_state.onoff_target) {
uint32_t transition_ms = default_transition_time();
if (transition_ms > 0) {
printf("Starting on power up transition\r\n");
if (lightbulb_state.onoff_target == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetLevel(0, transition_ms);
} else {
LEDS_SetLevel(0xFFFF, transition_ms);
}
// state is updated when transition is complete
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(transition_ms), TIMER_ID_ONOFF_TRANSITION, 1);
} else {
// update current state without any transition time
if (lightbulb_state.onoff_target == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetState(LED_STATE_OFF);
} else {
LEDS_SetState(LED_STATE_ON);
}
lightbulb_state.onoff_current = lightbulb_state.onoff_target;
}
} else {
printf("Keeping loaded state\r\n");
if (lightbulb_state.onoff_current == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetState(LED_STATE_OFF);
} else {
LEDS_SetState(LED_STATE_ON);
}
}
break;
}
// this is needed by the LCD driver
int rtcIntCallbackRegister(void (*pFunction)(void*),
void* argument,
unsigned int frequency)
{
return 0;
}
/**
* button initialization. Configure pushbuttons PB0,PB1
* as inputs.
*/
static void button_init()
{
// configure pushbutton PB0 and PB1 as inputs, with pull-up enabled
GPIO_PinModeSet(BSP_BUTTON0_PORT, BSP_BUTTON0_PIN, gpioModeInputPull, 1);
GPIO_PinModeSet(BSP_BUTTON1_PORT, BSP_BUTTON1_PIN, gpioModeInputPull, 1);
}
/**
* This function is used to write one line in the LCD. The parameter 'row' selects which line
* is written, possible values are defined as LCD_ROW_xxx.
*/
void LCD_write(char *str, uint8 row)
{
char LCD_message[LCD_ROW_MAX * LCD_ROW_LEN];
char *pRow; /* pointer to selected row */
int i;
if (row > LCD_ROW_MAX) {
return;
}
pRow = &(LCD_data[row - 1][0]);
sprintf(pRow, str);
/* add % sign at the end of lightness level */
if (row == LCD_ROW_LIGHTNESS) {
strcat(pRow, "%");
}
LCD_message[0] = 0;
for (i = 0; i < LCD_ROW_MAX; i++) {
pRow = &(LCD_data[i][0]);
strcat(LCD_message, pRow);
strcat(LCD_message, "\n"); // add newline at end of reach row
}
graphWriteString(LCD_message);
}
/**
* LCD initialization, called once at startup.
*/
void LCD_init(void)
{
/* clear LCD_data table */
memset(&LCD_data, 0, sizeof(LCD_data));
/* initialize graphics driver and set the title text */
graphInit("SILICON LABORATORIES\nBluetooth Mesh Demo\n\n");
LCD_write("initializing", LCD_ROW_STATUS);
}
/**
* Set device name in the GATT database. A unique name is generated using
* the two last bytes from the Bluetooth address of this device. Name is also
* displayed on the LCD.
*/
void set_device_name(bd_addr *pAddr)
{
char name[20];
uint16 res;
// create unique device name using the last two bytes of the Bluetooth address
sprintf(name, "sensor light1 %x:%x", pAddr->addr[1], pAddr->addr[0]);
printf("Device name: '%s'\r\n", name);
res = gecko_cmd_gatt_server_write_attribute_value(gattdb_device_name, 0, strlen(name), (uint8 *)name)->result;
if (res) {
printf("gecko_cmd_gatt_server_write_attribute_value() failed, code %x\r\n", res);
}
// show device name on the LCD
LCD_write(name, LCD_ROW_NAME);
}
/**
* This function is called when a light on/off request with non-zero transition time has completed
*/
void onoff_transition_complete()
{
// transition done -> set state, update and publish
lightbulb_state.onoff_current = lightbulb_state.onoff_target;
printf("transition complete. New state is %s\r\n", lightbulb_state.onoff_current ? "ON" : "OFF");
/**
* This function is called when a lightness request with non-zero transition time has completed
*/
void lightness_transition_complete()
{
// transition done -> set state, update and publish
lightbulb_state.lightness_current = lightbulb_state.lightness_target;
if (lightbulb_state.lightness_target != 0) {
lightbulb_state.lightness_last = lightbulb_state.lightness_target;
}
printf("transition complete. New level is %u\r\n", lightbulb_state.lightness_current);
lightbulb_state_changed();
onoff_update_and_publish(_elem_index);
} else {
if (lightbulb_state.onoff_target == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetLevel(0, delayed_onoff_trans);
} else {
// restore last brightness level, with transition delay
LEDS_SetLevel(lightbulb_state.lightness_last, delayed_onoff_trans);
lightbulb_state.lightness_target = lightbulb_state.lightness_last;
}
// state is updated when transition is complete
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(delayed_onoff_trans), TIMER_ID_ONOFF_TRANSITION, 1);
}
}
if (delayed_lightness_trans == 0) {
// no transition delay, update state immediately
lightbulb_state.lightness_current = lightbulb_state.lightness_target;
if (lightbulb_state.lightness_target != 0) {
lightbulb_state.lightness_last = lightbulb_state.lightness_target;
}
lightbulb_state_changed();
lightness_update_and_publish(_elem_index);
} else {
// state is updated when transition is complete
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(delayed_lightness_trans), TIMER_ID_LIGHTNESS_TRANSITION, 1);
}
}
static void server_state_changed(struct gecko_msg_mesh_generic_server_state_changed_evt_t *pEvt)
{
int i;
printf("state changed: ");
printf("model ID %4.4x, type %2.2x ", pEvt->model_id, pEvt->type);
for (i = 0; i < pEvt->parameters.len; i++) {
printf("%2.2x ", pEvt->parameters.data[i]);
}
printf("\r\n");
}
/**
* this function is called to initiate factory reset. Factory reset may be initiated
* by keeping one of the WSTK pushbuttons pressed during reboot. Factory reset is also
* performed if it is requested by the provisioner (event gecko_evt_mesh_node_reset_id)
*/
void initiate_factory_reset(void)
{
printf("factory reset\r\n");
LCD_write("\n***\nFACTORY RESET\n***", LCD_ROW_STATUS);
/* if connection is open then close it before rebooting */
if (conn_handle != 0xFF) {
gecko_cmd_le_connection_close(conn_handle);
}
/* perform a factory reset by erasing PS storage. This removes all the keys and other settings
that have been configured for this node */
gecko_cmd_flash_ps_erase_all();
// reboot after a small delay
gecko_cmd_hardware_set_soft_timer(2 * 32768, TIMER_ID_FACTORY_RESET, 1);
}
// Initialize the Temperature Sensor
Si7013_Detect(I2C0, SI7021_ADDR, NULL);
/* initialize LEDs and buttons. Note: some radio boards share the same GPIO for button & LED.
* Initialization is done in this order so that default configuration will be "button" for those
* radio boards with shared pins. LEDS_init() is called later as needed to (re)initialize the LEDs
* */
LEDS_init();
button_init();
bool pass = mesh_bgapi_listener(evt);
if (pass) {
handle_gecko_event(BGLIB_MSG_ID(evt->header), evt);
}
temperatureMeasure();
printf("entering in gecko hardware soft timer case loop\r\n");
}
}
/**
* Handling of stack events. Both BLuetooth LE and Bluetooth mesh events are handled here.
*/
static void handle_gecko_event(uint32_t evt_id, struct gecko_cmd_packet *evt)
{
uint16_t result;
char buf[30];
///////////////////////
printf("entering in light1 main loop\r\n");
gecko_cmd_system_halt(1);
struct gecko_msg_system_set_tx_power_rsp_t* pwr;
pwr = gecko_cmd_system_set_tx_power(-260);
printf("return value : %d\r\n", pwr->set_power);
gecko_cmd_system_halt(0);
///////////////////////
gecko_cmd_le_gap_set_advertise_timing(0, 160, 160, 0, 0);
gecko_cmd_le_gap_start_advertising(0, le_gap_general_discoverable, le_gap_connectable_scannable);
// check pushbutton state at startup. If either PB0 or PB1 is held down then do factory reset
if (GPIO_PinInGet(BSP_BUTTON0_PORT, BSP_BUTTON0_PIN) == 0 || GPIO_PinInGet(BSP_BUTTON1_PORT, BSP_BUTTON1_PIN) == 0) {
initiate_factory_reset();
} else {
struct gecko_msg_system_get_bt_address_rsp_t *pAddr = gecko_cmd_system_get_bt_address();
set_device_name(&pAddr->address);
// Initialize Mesh stack in Node operation mode, wait for initialized event
result = gecko_cmd_mesh_node_init()->result;
if (result) {
sprintf(buf, "init failed (0x%x)", result);
LCD_write(buf, LCD_ROW_STATUS);
}
// re-initialize LEDs (needed for those radio board that share same GPIO for button/LED)
LEDS_init();
}
break;
////////////////////////////////////
case gecko_evt_gatt_server_characteristic_status_id:
/* Check that the characteristic in question is temperature - its ID is defined
* in gatt.xml as "temperature_measurement". Also check that status_flags = 1, meaning that
* the characteristic client configuration was changed (notifications or indications
* enabled or disabled). */
if ((evt->data.evt_gatt_server_characteristic_status.characteristic == gattdb_temperature_measurement)
&& (evt->data.evt_gatt_server_characteristic_status.status_flags == 0x01)) {
if (evt->data.evt_gatt_server_characteristic_status.client_config_flags == 0x02) {
/* Indications have been turned ON - start the repeating timer. The 1st parameter '32768'
* tells the timer to run for 1 second (32.768 kHz oscillator), the 2nd parameter is
* the timer handle and the 3rd parameter '0' tells the timer to repeat continuously until
* stopped manually.*/
gecko_cmd_hardware_set_soft_timer(32768, 0, 0);
} else if (evt->data.evt_gatt_server_characteristic_status.client_config_flags == 0x00) {
/* Indications have been turned OFF - stop the timer. */
gecko_cmd_hardware_set_soft_timer(0, 0, 0);
}
}
break;
////////////////////////////////////
case gecko_evt_hardware_soft_timer_id:
/* temperatureMeasure();
printf("entering in gecko hardware soft timer case loop\r\n"); */
switch (evt->data.evt_hardware_soft_timer.handle) {
case TIMER_ID_FACTORY_RESET:
gecko_cmd_system_reset(0);
break;
case TIMER_ID_RESTART:
gecko_cmd_system_reset(0);
break;
case TIMER_ID_PROVISIONING:
LEDS_SetState(LED_STATE_PROV);
break;
case TIMER_ID_SAVE_STATE:
lightbulb_state_store();
break;
case TIMER_ID_DELAYED_ONOFF:
/* delay for an on/off request has passed, now process the request */
delayed_onoff_request();
break;
case TIMER_ID_DELAYED_LIGHTNESS:
/* delay for a lightness request has passed, now process the request */
delayed_lightness_request();
break;
case TIMER_ID_ONOFF_TRANSITION:
onoff_transition_complete();
break;
case TIMER_ID_LIGHTNESS_TRANSITION:
lightness_transition_complete();
break;
default:
break;
}
break;
case gecko_evt_mesh_node_initialized_id:
printf("node initialized\r\n");
case gecko_evt_mesh_node_provisioning_started_id:
printf("Started provisioning\r\n");
LCD_write("provisioning...", LCD_ROW_STATUS);
// start timer for blinking LEDs to indicate which node is being provisioned
gecko_cmd_hardware_set_soft_timer(32768 / 4, TIMER_ID_PROVISIONING, 0);
break;
case gecko_evt_mesh_node_provisioned_id:
_elem_index = 0; // index of primary element is zero. This example has only one element.
lightbulb_state_init();
printf("node provisioned, got address=%x\r\n", evt->data.evt_mesh_node_provisioned.address);
// stop LED blinking when provisioning complete
gecko_cmd_hardware_set_soft_timer(0, TIMER_ID_PROVISIONING, 0);
LEDS_SetState(LED_STATE_OFF);
LCD_write("provisioned", LCD_ROW_STATUS);
break;
case gecko_evt_mesh_node_provisioning_failed_id:
prov_fail_evt = (struct gecko_msg_mesh_node_provisioning_failed_evt_t *)&(evt->data);
printf("provisioning failed, code %x\r\n", prov_fail_evt->result);
LCD_write("prov failed", LCD_ROW_STATUS);
/* start a one-shot timer that will trigger soft reset after small delay */
gecko_cmd_hardware_set_soft_timer(2 * 32768, TIMER_ID_RESTART, 1);
break;
case gecko_evt_mesh_node_key_added_id:
printf("got new %s key with index %x\r\n", evt->data.evt_mesh_node_key_added.type == 0 ? "network" : "application",
evt->data.evt_mesh_node_key_added.index);
break;
case gecko_evt_mesh_node_model_config_changed_id:
printf("model config changed\r\n");
break;
case gecko_evt_mesh_generic_server_client_request_id:
printf("evt gecko_evt_mesh_generic_server_client_request_id\r\n");
mesh_lib_generic_server_event_handler(evt);
break;
case gecko_evt_mesh_generic_server_state_changed_id:
// uncomment following line to get debug prints for each server state changed event
//server_state_changed(&(evt->data.evt_mesh_generic_server_state_changed));
// pass the server state changed event to mesh lib handler that will invoke
// the callback functions registered by application
mesh_lib_generic_server_event_handler(evt);
break;
case gecko_evt_mesh_node_reset_id:
printf("evt gecko_evt_mesh_node_reset_id\r\n");
initiate_factory_reset();
break;
case gecko_evt_le_gap_adv_timeout_id:
// adv timeout events silently discarded
break;
case gecko_evt_le_connection_opened_id:
printf("evt:gecko_evt_le_connection_opened_id\r\n");
num_connections++;
conn_handle = evt->data.evt_le_connection_opened.connection;
LCD_write("connected", LCD_ROW_CONNECTION);
break;
case gecko_evt_le_connection_parameters_id:
printf("evt:gecko_evt_le_connection_parameters_id\r\n");
break;
case gecko_evt_le_connection_closed_id:
/* Check if need to boot to dfu mode */
if (boot_to_dfu) {
/* Enter to DFU OTA mode */
gecko_cmd_system_reset(2);
}
///////////////////////////////////////
else {
/* Stop timer in case client disconnected before indications were turned off */
gecko_cmd_hardware_set_soft_timer(0, 0, 0);
/* Restart advertising after client has disconnected */
gecko_cmd_le_gap_start_advertising(0, le_gap_general_discoverable, le_gap_connectable_scannable);
}
//////////////////////////////////////
printf("evt:conn closed, reason 0x%x\r\n", evt->data.evt_le_connection_closed.reason);
conn_handle = 0xFF;
if (num_connections > 0) {
if (--num_connections == 0) {
LCD_write("", LCD_ROW_CONNECTION);
}
}
break;
case gecko_evt_gatt_server_user_write_request_id:
if (evt->data.evt_gatt_server_user_write_request.characteristic == gattdb_ota_control) {
/* Set flag to enter to OTA mode */
boot_to_dfu = 1;
/* Send response to Write Request */
gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_user_write_request.connection,
gattdb_ota_control,
bg_err_success);
/* Close connection to enter to DFU OTA mode */
gecko_cmd_le_connection_close(evt->data.evt_gatt_server_user_write_request.connection);
}
break;
case gecko_evt_system_external_signal_id:
{
uint16_t current_level;
char tmp[8];
if (init_done && (evt->data.evt_system_external_signal.extsignals & EXT_SIGNAL_LED_LEVEL_CHANGED)) {
/* this signal from the LED PWM driver indicates that the level has changed,
* we use it here to update the LCD status */
current_level = LEDS_GetLevel();
sprintf(tmp, "%u ", ++current_level * 100 / 65535);
LCD_write(tmp, LCD_ROW_LIGHTNESS);
}
}
break;
The heart rate is normal when running, but the heart rate will not improve 4-5min when riding .I thing this problem may related to the Accelerometer-NormalizationFactorx10 parameters in the algorithm.What is the effect of this parameter on the algorithm?How to configure this parameter?
I'm trying to improve the range of SI1153 but beyond 30 cm i have no response..I use an external power supply and long range proximity sunlight immune module with SFH4545 LED.
Do you have any idea to help me please ?
This is my i2c configuration:
i'm trying to use "Si115x Programmer’s Toolkit Development Software" on my Windows 10 64 bits but program is always crashing on startup (no error appears).
I've found this error on windows events messages :
"Nom de l’application défaillante Si115x GUI.exe, version : 0.0.0.0, horodatage : 0x514e2c2f
Nom du module défaillant : unknown, version : 0.0.0.0, horodatage : 0x00000000
Code d’exception : 0xc0000005
Décalage d’erreur : 0x726f7461
ID du processus défaillant : 0x23a4
Heure de début de l’application défaillante : 0x01d3f2abb7fc8356
Chemin d’accès de l’application défaillante : C:\SL\Optical_Sensors\Si115x\executable\launcher\Si115x GUI.exe
Chemin d’accès du module défaillant: unknown
ID de rapport : 3520bf95-4cc4-4256-a84c-95984407b192
Nom complet du package défaillant :
ID de l’application relative au package défaillant : "
Hy, i'm a android developer and I'm working on an application that measure body temperature and I need the source code of the silicon lab sensor puck application for android to see how the sensor send data to the application, so where i can find the SDK of this application?
Ill try to update a post again as I seem to get zero response from anyone, maybe I am a bit unclear in my description so ill try to do it more clear this time.
This is the config for my I2C
#define SDA_PORT (gpioPortA)
#define SDA_PIN (0U)
#define SCL_PORT (gpioPortA)
#define SCL_PIN (1U)
#define I2CSPM_INIT_DEFAULT I2CSPM_INIT_SENSOR
#define INT_PORT (gpioPortA)
#define INT_PIN (2U)
#define I2CSPM_INIT_SENSOR \
{ \
I2C0, /* Use I2C instance */ \
SCL_PORT, /* SCL port */ \
SCL_PIN, /* SCL pin */ \
SDA_PORT, /* SDA port */ \
SDA_PIN, /* SDA pin */ \
0, /* Location of SCL */ \
0, /* Location of SDA */ \
0, /* Use currently configured reference clock */ \
I2C_FREQ_STANDARD_MAX, /* Set to standard rate */ \
i2cClockHLRStandard, /* Set to use 4:4 low/high duty cycle */ \
}
uint32_t data;
#define ADDRESS 0x53
My first question is what is the location of those pins ? I am correct looking at datasheet that it is 0 ?
int32_t lightMeasure()
{
I2C_TransferSeq_TypeDef seq;
I2C_TransferReturn_TypeDef ret;
uint8_t i2c_read_data[8];
uint8_t i2c_write_data[1];
seq.addr = ADDRESS;
seq.flags = I2C_FLAG_READ;
/* Select command to issue */
i2c_write_data[0] = 0x00;
seq.buf[0].data = i2c_write_data;
seq.buf[0].len = 1;
/* Select location/length of data to be read */
seq.buf[1].data = i2c_read_data;
seq.buf[1].len = 8;
ret = I2CSPM_Transfer(I2C0, &seq);
if (ret != i2cTransferDone) {
data = 0;
return((int) ret);
}
data = (uint32_t) i2c_read_data[0] ;
gecko_cmd_gatt_server_send_characteristic_notification(0xFF, gattdb_power_measurement, 5 ,data);
return((int) 2);
}
this function i am using for reading 0x00 register which should give my device id.
Ill also post my debug which is weird because it is giving my ret of 255 .
I made a new project for our custom board which based on EFM32WG230F256 with si1144
But, I get a linker error when building my project
Let me know if there is anything else I can do.
Thanks
Building target: EFM32WG230F256_SensorHub.axf
Invoking: GNU ARM C Linker
arm-none-eabi-gcc -g -gdwarf-2 -mcpu=cortex-m4 -mthumb -T "EFM32WG230F256_SensorHub.
ld" -L"E:\EFM32WG230F256_SensorHub\lib" -Xlinker --gc-sections -Xlinker
-Map="EFM32WG230F256_SensorHub.map" -mfpu=fpv4-sp-d16 -mfloat-abi=softfp --specs=nano.
specs -o EFM32WG230F256_SensorHub.axf
.............
E:\EFM32WG230F256_SensorHub\lib\libsihrm_gcc_cm4f.a(sihrm.o):
In function `kkkfijoifhjvr98rhuj8':
sihrm.c:(.text.kkkfijoifhjvr98rhuj8+0x458): undefined reference to `exp'
E:\Project\CSS2\EFM32WG230F256_SensorHub\lib\libsihrm_gcc_cm4f.a(sihrm.o):
In function `eiemtit09rlkjgepoiji.isra.5':
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x2c4): undefined reference to `sqrt'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0xd66): undefined reference to `sqrt'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0xe90): undefined reference to `fabs'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x210e): undefined reference to `tanh'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x27f0): undefined reference to `sqrt'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x33e4): undefined reference to `Uncompress'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x3628): undefined reference to `Uncompress'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x37a4): undefined reference to `Si114xParamSet'
E:\Project\CSS2\EFM32WG230F256_SensorHub\lib\libsihrm_gcc_cm4f.a(sihrm.o): In function `sihrm_Run':
sihrm.c:(.text.sihrm_Run+0x74): undefined reference to `Si114xPsAlsAuto'
.........
sihrm.c:(.text.sihrm_DetectSkinContact+0x18): undefined reference to `Si114xParamRead'
sihrm.c:(.text.sihrm_DetectSkinContact+0x24): undefined reference to `Si114xParamSet'
sihrm.c:(.text.sihrm_DetectSkinContact+0x2a): undefined reference to `Si114xAlsForce'
sihrm.c:(.text.sihrm_DetectSkinContact+0x78): undefined reference to `Si114xParamSet'
sihrm.c:(.text.sihrm_DetectSkinContact+0x84): undefined reference to `Si114xPsForce'
Does anyone have experimental or anecdotal data concerning the accuracy of the humidity measurement for the SI7021-A20-GM1R sensor in a vacuum (~10mbar)? Thanks.
I have a BGM111 breakout board and a HTU21D temp and hum breakout sensor board that I would like to use. My current setting is:
I2C device addres is 0x40
SDA port : PC10
SCL port : PC11
I'm moving forward with a project that has to be closed in a short time for a prototyping of a few hundred units.
An important part is the measurement of solar radiation. I decided to use the SI1133 and make the sum of IR, visible and UV. For the application I'm doing is perfect.
However I am studying more deeply the operation of the sensor and I am very confused. I think I got even more when I saw some online sw libs for it.
What are the ADC's settings and the conversion calculation of the channel readings to W/m2?
How can I relate to table 8.3 (datasheet)?
If I set up a channel for LARGE_IR (for example), when I read that channel how do I relate the value read with W/m2?
I can not move forward from this point because I do not understand what kind of result the sensor will give me.
My strategy would be to get the direct values with the sensor without a lens (to be able to use the ratio of table 8.3) and use another sensor with a Teflon diffuser lens to calculate the lens attenuation.
The goal is to do something similar to a pyranometer.
Can anyone give me more infos? Some help? Is my thinking correct?
Forum
command utilities for si114x
There is a another issue with command utilities of Si114x. I am getting an 'error -2' when I try to give commands except reset command. For example. If I give 'si114x_regWrite' command then I got an 'error -2'.
command utilities for si114x
I am using Si114x MFB. I gave command for port selection( si114x_choose_port.exe ). COM5 (USB Port) is selected which I verified by looking into 'ports.txt'. Further, I gave command as 'si114x_reset. exe'. This command is not getting executed & I am not getting any error as well. There is no response for a long time greater than five minutes.
The board is running fine & providing sample data in the GUI of control panel.
Guidance on command utilities is needed.
need to convert temperature values from si7013 on WSTK kit with mighty gecko board
Hello, I am interfacing si7013 temperature sensor with WSTK kit on mighty gecko board. I am getting below values, please help to convert the same in degree celcius temperature
Values: Temperature value: temp=4244666040,
Temperature value: temp=4244666050,
Temperature value: temp=4244666050,
Temperature value: temp=4244666040,
Temperature value: temp=4244666018,
Code snippet:
void temperatureMeasure()
{
uint8_t htmTempBuffer[5]; /* Stores the temperature data in the Health Thermometer (HTM) format. */
uint8_t flags = 0x00; /* HTM flags set as 0 for Celsius, no time stamp and no temperature type. */
int32_t tempData; /* Stores the Temperature data read from the RHT sensor. */
uint32_t rhData = 0; /* Dummy needed for storing Relative Humidity data. */
uint32_t temperature; /* Stores the temperature data read from the sensor in the correct format */
uint32_t temperature_F;
uint8_t *p = htmTempBuffer; /* Pointer to HTM temperature buffer needed for converting values to bitstream. */
/* Convert flags to bitstream and append them in the HTM temperature data buffer (htmTempBuffer) */
UINT8_TO_BITSTREAM(p, flags);
//printf("void temperaturemeasure loop \r\n");
/* Sensor relative humidity and temperature measurement returns 0 on success, nonzero otherwise */
if (Si7013_MeasureRHAndTemp(I2C0, SI7021_ADDR, &rhData, &tempData) == 0) {
/* Convert sensor data to correct temperature format */
temperature = FLT_TO_UINT32(tempData, -3);
printf("Temperature degree C value: temp=%u, \r\n", temperature);
/* Convert temperature to bitstream and place it in the HTM temperature data buffer (htmTempBuffer) */
UINT32_TO_BITSTREAM(p, temperature);
/* Send indication of the temperature in htmTempBuffer to all "listening" clients.
* This enables the Health Thermometer in the Blue Gecko app to display the temperature.
* 0xFF as connection ID will send indications to all connections. */
gecko_cmd_gatt_server_send_characteristic_notification(
0xFF, gattdb_temperature_measurement, 5, htmTempBuffer);
}
/*else {
printf (" No data \r\n");
} */
}
Not getting temperature & humidity values on Silabs WSTK kit with Mighty Gecko board
Hi, I am trying to get temperature & humidity values from Si7013 sensor present on Silabs WSTK kit, I want to get the values on Bluetooth mesh light node. I have generated below code, & getting temperature values as zero every time on Android App & also not able to operate LEDs on the kit using btmesh Switch node. Please help
/***********************************************************************************************//**
* \file main.c light sensor
* \brief Silicon Labs Bluetooth mesh light example
*
* This example implements a Bluetooth mesh light node.
*
***************************************************************************************************
* <b> (C) Copyright 2017 Silicon Labs, http://www.silabs.com</b>
***************************************************************************************************
* This file is licensed under the Silabs License Agreement. See the file
* "Silabs_License_Agreement.txt" for details. Before using this software for
* any purpose, you must agree to the terms of that agreement.
**************************************************************************************************/
/* C Standard Library headers */
#include <stdlib.h>
#include <stdio.h>
/* Board headers */
#include "init_mcu.h"
#include "init_board.h"
#include "init_app.h"
#include "ble-configuration.h"
#include "board_features.h"
/* WSTK specific includes */
#include "retargetserial.h"
#include "graphics.h"
/* Bluetooth stack headers */
#include "bg_types.h"
#include "native_gecko.h"
#include "gatt_db.h"
#include <gecko_configuration.h>
#include "mesh_generic_model_capi_types.h"
#include "mesh_lighting_model_capi_types.h"
#include "mesh_lib.h"
#include <mesh_sizes.h>
#include "infrastructure.h"
/* Libraries containing default Gecko configuration values */
#include "em_emu.h"
#include "em_cmu.h"
#include <em_gpio.h>
#include "em_system.h"
/* Device initialization header */
#include "hal-config.h"
#include "si7013.h"
/* LED driver with support for PWM dimming */
#include "led_driver.h"
/*////////#ifdef FEATURE_BOARD_DETECTED */
#if defined(HAL_CONFIG)
#include "bsphalconfig.h"
#else
#include "bspconfig.h"
#endif
/*////////////#else
#error This sample app only works with a Silicon Labs Board
#endif */
#include "i2cspm.h"
#include "si7013.h"
#include "tempsens.h"
/***********************************************************************************************//**
* @addtogroup Application
* @{
**************************************************************************************************/
/***********************************************************************************************//**
* @addtogroup app
* @{
**************************************************************************************************/
struct mesh_generic_state current, target;
void mesh_native_bgapi_init(void);
bool mesh_bgapi_listener(struct gecko_cmd_packet *evt);
void LCD_write(char *str, uint8 row);
// Maximum number of simultaneous Bluetooth connections
//#define MAX_CONNECTIONS 2 //////////////
#define MAX_CONNECTIONS 4
// heap for Bluetooth stack
uint8_t bluetooth_stack_heap[DEFAULT_BLUETOOTH_HEAP(MAX_CONNECTIONS) + BTMESH_HEAP_SIZE + 1760];
// Flag for indicating DFU Reset must be performed
uint8_t boot_to_dfu = 0;
/*
* Maximum number of Bluetooth advertisement sets.
* 1 is allocated for Bluetooth LE stack
* 1 one for Bluetooth mesh stack
* 1 needs to be allocated for each Bluetooth mesh network
* - Currently up to 4 networks are supported at a time
*/
#define MAX_ADVERTISERS (2 + 4)
// Bluetooth stack configuration
const gecko_configuration_t config =
{
.config_flags = 0,
.bluetooth.max_connections = MAX_CONNECTIONS,
.bluetooth.max_advertisers = MAX_ADVERTISERS,
.bluetooth.heap = bluetooth_stack_heap,
.bluetooth.heap_size = sizeof(bluetooth_stack_heap) - BTMESH_HEAP_SIZE,
.bluetooth.sleep_clock_accuracy = 100,
.gattdb = &bg_gattdb_data,
.btmesh_heap_size = BTMESH_HEAP_SIZE,
.ota.flags = 0,
.ota.device_name_len = 3,
.ota.device_name_ptr = "OTA",
#if (HAL_PA_ENABLE) && defined(FEATURE_PA_HIGH_POWER)
.pa.config_enable = 1, // Enable high power PA
.pa.input = GECKO_RADIO_PA_INPUT_VBAT, // Configure PA input to VBAT
#endif // (HAL_PA_ENABLE) && defined(FEATURE_PA_HIGH_POWER)
};
/** Timer Frequency used. */
#define TIMER_CLK_FREQ ((uint32)32768)
/** Convert msec to timer ticks. */
#define TIMER_MS_2_TIMERTICK(ms) ((TIMER_CLK_FREQ * ms) / 1000)
#define TIMER_ID_RESTART 78
#define TIMER_ID_FACTORY_RESET 77
#define TIMER_ID_PROVISIONING 66
#define TIMER_ID_SAVE_STATE 60
#define TIMER_ID_ONOFF_TRANSITION 53
#define TIMER_ID_LIGHTNESS_TRANSITION 52
#define TIMER_ID_DELAYED_ONOFF 51
#define TIMER_ID_DELAYED_LIGHTNESS 50
#define gattdb_temperature_measurement 15
/**
* LCD content can be updated one row at a time using function LCD_write().
* Row number is passed as parameter,the possible values are defined below.
*/
#define LCD_ROW_NAME 1 /* 1st row, device name */
#define LCD_ROW_STATUS 2 /* 2nd row, node status */
#define LCD_ROW_CONNECTION 3 /* 3rd row, connection status */
#define LCD_ROW_LIGHTNESS 4 /* 4th row, lightness level */
#define LCD_ROW_MAX 4 /* total number of rows used */
#define LCD_ROW_LEN 32 /* up to 32 characters per each row */
/** global variables */
static uint16 _elem_index = 0xffff; /* For indexing elements of the node (this example has only one element) */
static uint16 _my_address = 0; /* Address of the Primary Element of the Node */
static char LCD_data[LCD_ROW_MAX][LCD_ROW_LEN]; /* 2D array for storing the LCD content */
static uint8 num_connections = 0; /* number of active Bluetooth connections */
static uint8 conn_handle = 0xFF; /* handle of the last opened LE connection */
static uint8 init_done = 0;
//////////////////////Temperature read////////////////////////
void temperatureMeasure()
{
uint8_t htmTempBuffer[5]; /* Stores the temperature data in the Health Thermometer (HTM) format. */
uint8_t flags = 0x00; /* HTM flags set as 0 for Celsius, no time stamp and no temperature type. */
int32_t tempData; /* Stores the Temperature data read from the RHT sensor. */
uint32_t rhData = 0; /* Dummy needed for storing Relative Humidity data. */
uint32_t temperature; /* Stores the temperature data read from the sensor in the correct format */
uint8_t *p = htmTempBuffer; /* Pointer to HTM temperature buffer needed for converting values to bitstream. */
/* Convert flags to bitstream and append them in the HTM temperature data buffer (htmTempBuffer) */
UINT8_TO_BITSTREAM(p, flags);
printf("void temperaturemeasure loop \r\n");
/* Sensor relative humidity and temperature measurement returns 0 on success, nonzero otherwise */
if (Si7013_MeasureRHAndTemp(I2C0, SI7021_ADDR, &rhData, &tempData) == 0) {
/* Convert sensor data to correct temperature format */
temperature = FLT_TO_UINT32(tempData, -3);
printf("Temperature value: temp=%u, \r\n", temperature);
/* Convert temperature to bitstream and place it in the HTM temperature data buffer (htmTempBuffer) */
UINT32_TO_BITSTREAM(p, temperature);
/* Send indication of the temperature in htmTempBuffer to all "listening" clients.
* This enables the Health Thermometer in the Blue Gecko app to display the temperature.
* 0xFF as connection ID will send indications to all connections. */
gecko_cmd_gatt_server_send_characteristic_notification(
0xFF, gattdb_temperature_measurement, 5, htmTempBuffer);
}
}
/////////////////////////////////////////////////////////////
static PACKSTRUCT(struct lightbulb_state {
// On/Off Server state
uint8_t onoff_current;
uint8_t onoff_target;
// Transition Time Server state
uint8_t transtime;
// On Power Up Server state
uint8_t onpowerup;
// Lightness server
uint16_t lightness_current;
uint16_t lightness_target;
uint16_t lightness_last;
} lightbulb_state);
/* copy of transition delay parameter, needed for delayed on/off and lightness requests */
uint32_t delayed_onoff_trans = 0;
uint32_t delayed_lightness_trans = 0;
static int lightbulb_state_load(void);
static int lightbulb_state_store(void);
static void lightbulb_state_changed(void);
static uint32_t default_transition_time(void)
{
return mesh_lib_transition_time_to_ms(lightbulb_state.transtime);
}
static errorcode_t onoff_response(uint16_t element_index,
uint16_t client_addr,
uint16_t appkey_index)
{
struct mesh_generic_state current, target;
current.kind = mesh_generic_state_on_off;
current.on_off.on = lightbulb_state.onoff_current;
target.kind = mesh_generic_state_on_off;
target.on_off.on = lightbulb_state.onoff_target;
return mesh_lib_generic_server_response(MESH_GENERIC_ON_OFF_SERVER_MODEL_ID,
element_index,
client_addr,
appkey_index,
¤t,
NULL,
0,
0x00);
}
static errorcode_t onoff_update(uint16_t element_index)
{
struct mesh_generic_state current, target;
current.kind = mesh_generic_state_on_off;
current.on_off.on = lightbulb_state.onoff_current;
target.kind = mesh_generic_state_on_off;
target.on_off.on = lightbulb_state.onoff_target;
return mesh_lib_generic_server_update(MESH_GENERIC_ON_OFF_SERVER_MODEL_ID,
element_index,
¤t,
NULL,
0);
}
static errorcode_t onoff_update_and_publish(uint16_t element_index)
{
errorcode_t e;
e = onoff_update(element_index);
if (e == bg_err_success) {
e = mesh_lib_generic_server_publish(MESH_GENERIC_ON_OFF_SERVER_MODEL_ID,
element_index,
mesh_generic_state_on_off);
}
return e;
}
static void onoff_request(uint16_t model_id,
uint16_t element_index,
uint16_t client_addr,
uint16_t server_addr,
uint16_t appkey_index,
const struct mesh_generic_request *request,
uint32_t transition_ms,
uint16_t delay_ms,
uint8_t request_flags)
{
printf("ON/OFF request: requested state=<%s>, transition=%u, delay=%u, sender=%x\r\n",
request->on_off ? "ON" : "OFF", transition_ms, delay_ms, server_addr);
/* printf("ON/OFF request: requested state=<%s>, transition=%u, delay=%u\r\n",
request->on_off ? "ON" : "OFF", transition_ms, delay_ms);*/
if (lightbulb_state.onoff_current == request->on_off) {
printf("Request for current state received; no op\n");
} else {
printf("Turning lightbulb <%s>\r\n", request->on_off ? "ON" : "OFF");
if (transition_ms == 0 && delay_ms == 0) { // Immediate change
lightbulb_state.onoff_current = request->on_off;
lightbulb_state.onoff_target = request->on_off;
if (lightbulb_state.onoff_current == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetState(LED_STATE_OFF);
} else {
LEDS_SetState(LED_STATE_ON);
}
} else if (delay_ms > 0) {
// a delay has been specified for the light change. Start a soft timer
// that will trigger the change after the given delay
// Current state remains as is for now
lightbulb_state.onoff_target = request->on_off;
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(delay_ms), TIMER_ID_DELAYED_ONOFF, 1);
// store transition parameter for later use
delayed_onoff_trans = transition_ms;
} else {
// no delay but transition time has been set.
lightbulb_state.onoff_target = request->on_off;
if (request->on_off == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetLevel(0, transition_ms);
} else {
// restore last brightness
lightbulb_state.lightness_target = lightbulb_state.lightness_last;
LEDS_SetLevel(lightbulb_state.lightness_target, transition_ms);
}
// lightbulb current state will be updated when transition is complete
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(transition_ms), TIMER_ID_ONOFF_TRANSITION, 1);
}
lightbulb_state_changed();
}
if (request_flags & MESH_REQUEST_FLAG_RESPONSE_REQUIRED) {
onoff_response(element_index, client_addr, appkey_index);
} else {
onoff_update(element_index);
}
}
static void onoff_change(uint16_t model_id,
uint16_t element_index,
const struct mesh_generic_state *current,
const struct mesh_generic_state *target,
uint32_t remaining_ms)
{
if (current->on_off.on != lightbulb_state.onoff_current) {
printf("on-off state changed %u to %u\r\n", lightbulb_state.onoff_current, current->on_off.on);
lightbulb_state.onoff_current = current->on_off.on;
lightbulb_state_changed();
} else {
printf("dummy onoff change - same state as before\r\n");
}
}
static errorcode_t lightness_response(uint16_t element_index,
uint16_t client_addr,
uint16_t appkey_index)
{
struct mesh_generic_state current, target;
current.kind = mesh_lighting_state_lightness_actual;
current.lightness.level = lightbulb_state.lightness_current;
target.kind = mesh_lighting_state_lightness_actual;
target.lightness.level = lightbulb_state.lightness_target;
return mesh_lib_generic_server_response(MESH_LIGHTING_LIGHTNESS_SERVER_MODEL_ID,
element_index,
client_addr,
appkey_index,
¤t,
NULL,
0,
0x00);
}
static errorcode_t lightness_update(uint16_t element_index)
{
struct mesh_generic_state current, target;
current.kind = mesh_lighting_state_lightness_actual;
current.lightness.level = lightbulb_state.lightness_current;
target.kind = mesh_lighting_state_lightness_actual;
target.lightness.level = lightbulb_state.lightness_target;
return mesh_lib_generic_server_update(MESH_LIGHTING_LIGHTNESS_SERVER_MODEL_ID,
element_index,
¤t,
NULL,
0);
}
static errorcode_t lightness_update_and_publish(uint16_t element_index)
{
errorcode_t e;
e = lightness_update(element_index);
if (e == bg_err_success) {
e = mesh_lib_generic_server_publish(MESH_LIGHTING_LIGHTNESS_SERVER_MODEL_ID,
element_index,
mesh_lighting_state_lightness_actual);
}
return e;
}
static void lightness_request(uint16_t model_id,
uint16_t element_index,
uint16_t client_addr,
uint16_t server_addr,
uint16_t appkey_index,
const struct mesh_generic_request *request,
uint32_t transition_ms,
uint16_t delay_ms,
uint8_t request_flags)
{
// for simplicity, this demo assumes that all lightness requests use the actual scale.
// other type of requests are ignored
if (request->kind != mesh_lighting_request_lightness_actual) {
return;
}
printf("lightness_request: level=%u, transition=%u, delay=%u\r\n",
request->lightness, transition_ms, delay_ms);
if (lightbulb_state.lightness_current == request->lightness) {
printf("Request for current state received; no op\n");
} else {
printf("Setting lightness to <%u>\r\n", request->lightness);
if (transition_ms == 0 && delay_ms == 0) { // Immediate change
lightbulb_state.lightness_current = request->lightness;
lightbulb_state.lightness_target = request->lightness;
if (request->lightness != 0) {
lightbulb_state.lightness_last = request->lightness;
}
// update LED PWM duty cycle
LEDS_SetLevel(lightbulb_state.lightness_current, 0);
} else if (delay_ms > 0) {
// a delay has been specified for the light change. Start a soft timer
// that will trigger the change after the given delay
// Current state remains as is for now
lightbulb_state.lightness_target = request->lightness;
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(delay_ms), TIMER_ID_DELAYED_LIGHTNESS, 1);
// store transition parameter for later use
delayed_lightness_trans = transition_ms;
} else {
// no delay but transition time has been set.
lightbulb_state.lightness_target = request->lightness;
LEDS_SetLevel(lightbulb_state.lightness_target, transition_ms);
// lightbulb current state will be updated when transition is complete
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(transition_ms), TIMER_ID_LIGHTNESS_TRANSITION, 1);
}
lightbulb_state_changed();
}
if (request_flags & MESH_REQUEST_FLAG_RESPONSE_REQUIRED) {
lightness_response(element_index, client_addr, appkey_index);
} else {
lightness_update(element_index);
}
}
static void lightness_change(uint16_t model_id,
uint16_t element_index,
const struct mesh_generic_state *current,
const struct mesh_generic_state *target,
uint32_t remaining_ms)
{
char tmp[32];
if (current->kind != mesh_lighting_state_lightness_actual) {
// if kind is not 'actual' then just report the change here, no change to light state
printf("lightness change, kind %u, value %u\r\n", current->kind, current->lightness.level);
return;
}
if (lightbulb_state.lightness_current != current->lightness.level) {
printf("lightness_change: from %u to %u\r\n", lightbulb_state.lightness_current, current->lightness.level);
lightbulb_state.lightness_current = current->lightness.level;
lightbulb_state_changed();
} else {
printf("lightness update -same value (%d)\r\n", lightbulb_state.lightness_current);
}
}
static errorcode_t power_onoff_response(uint16_t element_index,
uint16_t client_addr,
uint16_t appkey_index)
{
struct mesh_generic_state current;
current.kind = mesh_generic_state_on_power_up;
current.on_power_up.on_power_up = lightbulb_state.onpowerup;
return mesh_lib_generic_server_response(MESH_GENERIC_POWER_ON_OFF_SERVER_MODEL_ID,
element_index,
client_addr,
appkey_index,
¤t,
NULL,
0,
0x00);
}
static errorcode_t power_onoff_update(uint16_t element_index)
{
struct mesh_generic_state current;
current.kind = mesh_generic_state_on_power_up;
current.on_power_up.on_power_up = lightbulb_state.onpowerup;
return mesh_lib_generic_server_update(MESH_GENERIC_POWER_ON_OFF_SERVER_MODEL_ID,
element_index,
¤t,
NULL,
0);
}
static errorcode_t power_onoff_update_and_publish(uint16_t element_index)
{
errorcode_t e;
e = power_onoff_update(element_index);
if (e == bg_err_success) {
e = mesh_lib_generic_server_publish(MESH_GENERIC_POWER_ON_OFF_SERVER_MODEL_ID,
element_index,
mesh_generic_state_on_power_up);
}
return e;
}
static void power_onoff_request(uint16_t model_id,
uint16_t element_index,
uint16_t client_addr,
uint16_t server_addr,
uint16_t appkey_index,
const struct mesh_generic_request *request,
uint32_t transition_ms,
uint16_t delay_ms,
uint8_t request_flags)
{
printf("ON POWER UP request received; state=<%s>\n",
lightbulb_state.onpowerup == 0 ? "OFF"
: lightbulb_state.onpowerup == 1 ? "ON"
: "RESTORE");
if (lightbulb_state.onpowerup == request->on_power_up) {
printf("Request for current state received; no op\n");
} else {
printf("Setting onpowerup to <%s>\n",
request->on_power_up == 0 ? "OFF"
: request->on_power_up == 1 ? "ON"
: "RESTORE");
lightbulb_state.onpowerup = request->on_power_up;
lightbulb_state_changed();
}
if (request_flags & MESH_REQUEST_FLAG_RESPONSE_REQUIRED) {
power_onoff_response(element_index, client_addr, appkey_index);
} else {
power_onoff_update(element_index);
}
}
static void power_onoff_change(uint16_t model_id,
uint16_t element_index,
const struct mesh_generic_state *current,
const struct mesh_generic_state *target,
uint32_t remaining_ms)
{
// TODO
}
static errorcode_t transtime_response(uint16_t element_index,
uint16_t client_addr,
uint16_t appkey_index)
{
struct mesh_generic_state current;
current.kind = mesh_generic_state_transition_time;
current.transition_time.time = lightbulb_state.transtime;
return mesh_lib_generic_server_response(MESH_GENERIC_TRANSITION_TIME_SERVER_MODEL_ID,
element_index,
client_addr,
appkey_index,
¤t,
NULL,
0,
0x00);
}
static errorcode_t transtime_update(uint16_t element_index)
{
struct mesh_generic_state current;
current.kind = mesh_generic_state_transition_time;
current.transition_time.time = lightbulb_state.transtime;
return mesh_lib_generic_server_update(MESH_GENERIC_TRANSITION_TIME_SERVER_MODEL_ID,
element_index,
¤t,
NULL,
0);
}
static void transtime_request(uint16_t model_id,
uint16_t element_index,
uint16_t client_addr,
uint16_t server_addr,
uint16_t appkey_index,
const struct mesh_generic_request *request,
uint32_t transition_ms,
uint16_t delay_ms,
uint8_t request_flags)
{
printf("TRANSTIME request received; state=<0x%x>\n",
lightbulb_state.transtime);
if (lightbulb_state.transtime == request->transition_time) {
printf("Request for current state received; no op\n");
} else {
printf("Setting transtime to <0x%x>\n", request->transition_time);
lightbulb_state.transtime = request->transition_time;
lightbulb_state_changed();
}
if (request_flags & MESH_REQUEST_FLAG_RESPONSE_REQUIRED) {
transtime_response(element_index, client_addr, appkey_index);
} else {
transtime_update(element_index);
}
}
static void transtime_change(uint16_t model_id,
uint16_t element_index,
const struct mesh_generic_state *current,
const struct mesh_generic_state *target,
uint32_t remaining_ms)
{
// TODO
}
/**
* This function loads the saved light state from Persistent Storage and
* copies the data in the global variable lightbulb_state
*/
static int lightbulb_state_load(void)
{
struct gecko_msg_flash_ps_load_rsp_t* pLoad;
pLoad = gecko_cmd_flash_ps_load(0x4004);
if (pLoad->result) {
memset(&lightbulb_state, 0, sizeof(struct lightbulb_state));
lightbulb_state.lightness_last = 0xFFFF;
return -1;
}
memcpy(&lightbulb_state, pLoad->value.data, pLoad->value.len);
return 0;
}
/**
* this function saves the current light state in Persistent Storage so that
* the data is preserved over reboots and power cycles. The light state is hold
* in a global variable lightbulb_state. a PS key with ID 0x4004 is used to store
* the whole struct.
*/
static int lightbulb_state_store(void)
{
struct gecko_msg_flash_ps_save_rsp_t* pSave;
pSave = gecko_cmd_flash_ps_save(0x4004, sizeof(struct lightbulb_state), (const uint8*)&lightbulb_state);
if (pSave->result) {
printf("lightbulb_state_store(): PS save failed, code %x\r\n", pSave->result);
return(-1);
}
return 0;
}
/**
* this function is called each time the lightbulb state in RAM is changed. It sets up a soft timer
* that will save the state in flash after small delay. The purpose is to reduce amount of unnecessary
* flash writes.
*/
static void lightbulb_state_changed(void)
{
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(5000), TIMER_ID_SAVE_STATE, 1);
}
/**
* Initialization of the models supported by this node. This function registers callbacks for
* each of the three supported models.
*/
static void init_models(void)
{
mesh_lib_generic_server_register_handler(MESH_GENERIC_ON_OFF_SERVER_MODEL_ID,
0,
onoff_request,
onoff_change);
mesh_lib_generic_server_register_handler(MESH_GENERIC_POWER_ON_OFF_SETUP_SERVER_MODEL_ID,
0,
power_onoff_request,
power_onoff_change);
mesh_lib_generic_server_register_handler(MESH_GENERIC_TRANSITION_TIME_SERVER_MODEL_ID,
0,
transtime_request,
transtime_change);
mesh_lib_generic_server_register_handler(MESH_LIGHTING_LIGHTNESS_SERVER_MODEL_ID,
0,
lightness_request,
lightness_change);
}
/**
* Light node initialization. This is called at each boot if provisioning is already done.
* Otherwise this function is called after provisioning is completed.
*/
void lightbulb_state_init(void)
{
/* Initialize mesh lib */
mesh_lib_init(malloc, free, 8);
memset(&lightbulb_state, 0, sizeof(struct lightbulb_state));
if (lightbulb_state_load() != 0) {
printf("lightbulb_state_load() failed, using defaults\r\n");
goto publish;
}
// Handle on power up behavior
switch (lightbulb_state.onpowerup) {
case MESH_GENERIC_ON_POWER_UP_STATE_OFF:
printf("On power up state is OFF\r\n");
lightbulb_state.onoff_current = MESH_GENERIC_ON_OFF_STATE_OFF;
lightbulb_state.onoff_target = MESH_GENERIC_ON_OFF_STATE_OFF;
LEDS_SetState(LED_STATE_OFF);
break;
case MESH_GENERIC_ON_POWER_UP_STATE_ON:
printf("On power up state is ON\r\n");
lightbulb_state.onoff_current = MESH_GENERIC_ON_OFF_STATE_ON;
lightbulb_state.onoff_target = MESH_GENERIC_ON_OFF_STATE_ON;
LEDS_SetState(LED_STATE_ON);
break;
case MESH_GENERIC_ON_POWER_UP_STATE_RESTORE:
printf("On power up state is RESTORE\r\n");
if (lightbulb_state.onoff_current != lightbulb_state.onoff_target) {
uint32_t transition_ms = default_transition_time();
if (transition_ms > 0) {
printf("Starting on power up transition\r\n");
if (lightbulb_state.onoff_target == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetLevel(0, transition_ms);
} else {
LEDS_SetLevel(0xFFFF, transition_ms);
}
// state is updated when transition is complete
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(transition_ms), TIMER_ID_ONOFF_TRANSITION, 1);
} else {
// update current state without any transition time
if (lightbulb_state.onoff_target == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetState(LED_STATE_OFF);
} else {
LEDS_SetState(LED_STATE_ON);
}
lightbulb_state.onoff_current = lightbulb_state.onoff_target;
}
} else {
printf("Keeping loaded state\r\n");
if (lightbulb_state.onoff_current == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetState(LED_STATE_OFF);
} else {
LEDS_SetState(LED_STATE_ON);
}
}
break;
}
lightbulb_state_changed();
publish:
init_models();
onoff_update_and_publish(_elem_index);
power_onoff_update_and_publish(_elem_index);
init_done = 1;
}
static void handle_gecko_event(uint32_t evt_id, struct gecko_cmd_packet *evt);
// this is needed by the LCD driver
int rtcIntCallbackRegister(void (*pFunction)(void*),
void* argument,
unsigned int frequency)
{
return 0;
}
/**
* button initialization. Configure pushbuttons PB0,PB1
* as inputs.
*/
static void button_init()
{
// configure pushbutton PB0 and PB1 as inputs, with pull-up enabled
GPIO_PinModeSet(BSP_BUTTON0_PORT, BSP_BUTTON0_PIN, gpioModeInputPull, 1);
GPIO_PinModeSet(BSP_BUTTON1_PORT, BSP_BUTTON1_PIN, gpioModeInputPull, 1);
}
/**
* This function is used to write one line in the LCD. The parameter 'row' selects which line
* is written, possible values are defined as LCD_ROW_xxx.
*/
void LCD_write(char *str, uint8 row)
{
char LCD_message[LCD_ROW_MAX * LCD_ROW_LEN];
char *pRow; /* pointer to selected row */
int i;
if (row > LCD_ROW_MAX) {
return;
}
pRow = &(LCD_data[row - 1][0]);
sprintf(pRow, str);
/* add % sign at the end of lightness level */
if (row == LCD_ROW_LIGHTNESS) {
strcat(pRow, "%");
}
LCD_message[0] = 0;
for (i = 0; i < LCD_ROW_MAX; i++) {
pRow = &(LCD_data[i][0]);
strcat(LCD_message, pRow);
strcat(LCD_message, "\n"); // add newline at end of reach row
}
graphWriteString(LCD_message);
}
/**
* LCD initialization, called once at startup.
*/
void LCD_init(void)
{
/* clear LCD_data table */
memset(&LCD_data, 0, sizeof(LCD_data));
/* initialize graphics driver and set the title text */
graphInit("SILICON LABORATORIES\nBluetooth Mesh Demo\n\n");
LCD_write("initializing", LCD_ROW_STATUS);
}
/**
* Set device name in the GATT database. A unique name is generated using
* the two last bytes from the Bluetooth address of this device. Name is also
* displayed on the LCD.
*/
void set_device_name(bd_addr *pAddr)
{
char name[20];
uint16 res;
// create unique device name using the last two bytes of the Bluetooth address
sprintf(name, "sensor light1 %x:%x", pAddr->addr[1], pAddr->addr[0]);
printf("Device name: '%s'\r\n", name);
res = gecko_cmd_gatt_server_write_attribute_value(gattdb_device_name, 0, strlen(name), (uint8 *)name)->result;
if (res) {
printf("gecko_cmd_gatt_server_write_attribute_value() failed, code %x\r\n", res);
}
// show device name on the LCD
LCD_write(name, LCD_ROW_NAME);
}
/**
* This function is called when a light on/off request with non-zero transition time has completed
*/
void onoff_transition_complete()
{
// transition done -> set state, update and publish
lightbulb_state.onoff_current = lightbulb_state.onoff_target;
printf("transition complete. New state is %s\r\n", lightbulb_state.onoff_current ? "ON" : "OFF");
lightbulb_state_changed();
onoff_update_and_publish(_elem_index);
}
/**
* This function is called when a lightness request with non-zero transition time has completed
*/
void lightness_transition_complete()
{
// transition done -> set state, update and publish
lightbulb_state.lightness_current = lightbulb_state.lightness_target;
if (lightbulb_state.lightness_target != 0) {
lightbulb_state.lightness_last = lightbulb_state.lightness_target;
}
printf("transition complete. New level is %u\r\n", lightbulb_state.lightness_current);
lightbulb_state_changed();
lightness_update_and_publish(_elem_index);
}
void delayed_onoff_request()
{
printf("starting delayed on/off request: %u -> %u, %u ms\r\n",
lightbulb_state.onoff_current,
lightbulb_state.onoff_target,
delayed_onoff_trans
);
if (delayed_onoff_trans == 0) {
// no transition delay, update state immediately
lightbulb_state.onoff_current = lightbulb_state.onoff_target;
if (lightbulb_state.onoff_current == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetState(LED_STATE_OFF);
} else {
// restore last brightness level
LEDS_SetLevel(lightbulb_state.lightness_last, 0);
lightbulb_state.lightness_current = lightbulb_state.lightness_last;
}
lightbulb_state_changed();
onoff_update_and_publish(_elem_index);
} else {
if (lightbulb_state.onoff_target == MESH_GENERIC_ON_OFF_STATE_OFF) {
LEDS_SetLevel(0, delayed_onoff_trans);
} else {
// restore last brightness level, with transition delay
LEDS_SetLevel(lightbulb_state.lightness_last, delayed_onoff_trans);
lightbulb_state.lightness_target = lightbulb_state.lightness_last;
}
// state is updated when transition is complete
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(delayed_onoff_trans), TIMER_ID_ONOFF_TRANSITION, 1);
}
}
void delayed_lightness_request()
{
printf("starting delayed lightness request: level %u -> %u, %u ms\r\n",
lightbulb_state.lightness_current,
lightbulb_state.lightness_target,
delayed_lightness_trans
);
LEDS_SetLevel(lightbulb_state.lightness_target, delayed_lightness_trans);
if (delayed_lightness_trans == 0) {
// no transition delay, update state immediately
lightbulb_state.lightness_current = lightbulb_state.lightness_target;
if (lightbulb_state.lightness_target != 0) {
lightbulb_state.lightness_last = lightbulb_state.lightness_target;
}
lightbulb_state_changed();
lightness_update_and_publish(_elem_index);
} else {
// state is updated when transition is complete
gecko_cmd_hardware_set_soft_timer(TIMER_MS_2_TIMERTICK(delayed_lightness_trans), TIMER_ID_LIGHTNESS_TRANSITION, 1);
}
}
static void server_state_changed(struct gecko_msg_mesh_generic_server_state_changed_evt_t *pEvt)
{
int i;
printf("state changed: ");
printf("model ID %4.4x, type %2.2x ", pEvt->model_id, pEvt->type);
for (i = 0; i < pEvt->parameters.len; i++) {
printf("%2.2x ", pEvt->parameters.data[i]);
}
printf("\r\n");
}
/**
* this function is called to initiate factory reset. Factory reset may be initiated
* by keeping one of the WSTK pushbuttons pressed during reboot. Factory reset is also
* performed if it is requested by the provisioner (event gecko_evt_mesh_node_reset_id)
*/
void initiate_factory_reset(void)
{
printf("factory reset\r\n");
LCD_write("\n***\nFACTORY RESET\n***", LCD_ROW_STATUS);
/* if connection is open then close it before rebooting */
if (conn_handle != 0xFF) {
gecko_cmd_le_connection_close(conn_handle);
}
/* perform a factory reset by erasing PS storage. This removes all the keys and other settings
that have been configured for this node */
gecko_cmd_flash_ps_erase_all();
// reboot after a small delay
gecko_cmd_hardware_set_soft_timer(2 * 32768, TIMER_ID_FACTORY_RESET, 1);
}
int main()
{
// Initialize device
initMcu();
// Initialize board
initBoard();
// Initialize application
initApp();
gecko_stack_init(&config);
gecko_bgapi_class_dfu_init();
gecko_bgapi_class_system_init();
gecko_bgapi_class_le_gap_init();
gecko_bgapi_class_le_connection_init();
gecko_bgapi_class_gatt_init();
gecko_bgapi_class_gatt_server_init();
gecko_bgapi_class_endpoint_init();
gecko_bgapi_class_hardware_init();
gecko_bgapi_class_flash_init();
gecko_bgapi_class_test_init();
gecko_bgapi_class_sm_init();
mesh_native_bgapi_init();
gecko_initCoexHAL();
RETARGET_SerialInit();
// Initialize the Temperature Sensor
Si7013_Detect(I2C0, SI7021_ADDR, NULL);
/* initialize LEDs and buttons. Note: some radio boards share the same GPIO for button & LED.
* Initialization is done in this order so that default configuration will be "button" for those
* radio boards with shared pins. LEDS_init() is called later as needed to (re)initialize the LEDs
* */
LEDS_init();
button_init();
LCD_init();
while (1) {
struct gecko_cmd_packet *evt = gecko_wait_event();
/* gecko_cmd_le_gap_set_advertise_timing(0, 160, 160, 0, 0);
gecko_cmd_le_gap_start_advertising(0, le_gap_general_discoverable, le_gap_connectable_scannable); */
bool pass = mesh_bgapi_listener(evt);
if (pass) {
handle_gecko_event(BGLIB_MSG_ID(evt->header), evt);
}
temperatureMeasure();
printf("entering in gecko hardware soft timer case loop\r\n");
}
}
/**
* Handling of stack events. Both BLuetooth LE and Bluetooth mesh events are handled here.
*/
static void handle_gecko_event(uint32_t evt_id, struct gecko_cmd_packet *evt)
{
uint16_t result;
char buf[30];
struct gecko_msg_mesh_node_provisioning_failed_evt_t *prov_fail_evt;
if (NULL == evt) {
return;
}
switch (evt_id) {
case gecko_evt_system_boot_id:
///////////////////////
printf("entering in light1 main loop\r\n");
gecko_cmd_system_halt(1);
struct gecko_msg_system_set_tx_power_rsp_t* pwr;
pwr = gecko_cmd_system_set_tx_power(-260);
printf("return value : %d\r\n", pwr->set_power);
gecko_cmd_system_halt(0);
///////////////////////
gecko_cmd_le_gap_set_advertise_timing(0, 160, 160, 0, 0);
gecko_cmd_le_gap_start_advertising(0, le_gap_general_discoverable, le_gap_connectable_scannable);
// check pushbutton state at startup. If either PB0 or PB1 is held down then do factory reset
if (GPIO_PinInGet(BSP_BUTTON0_PORT, BSP_BUTTON0_PIN) == 0 || GPIO_PinInGet(BSP_BUTTON1_PORT, BSP_BUTTON1_PIN) == 0) {
initiate_factory_reset();
} else {
struct gecko_msg_system_get_bt_address_rsp_t *pAddr = gecko_cmd_system_get_bt_address();
set_device_name(&pAddr->address);
// Initialize Mesh stack in Node operation mode, wait for initialized event
result = gecko_cmd_mesh_node_init()->result;
if (result) {
sprintf(buf, "init failed (0x%x)", result);
LCD_write(buf, LCD_ROW_STATUS);
}
// re-initialize LEDs (needed for those radio board that share same GPIO for button/LED)
LEDS_init();
}
break;
////////////////////////////////////
case gecko_evt_gatt_server_characteristic_status_id:
/* Check that the characteristic in question is temperature - its ID is defined
* in gatt.xml as "temperature_measurement". Also check that status_flags = 1, meaning that
* the characteristic client configuration was changed (notifications or indications
* enabled or disabled). */
if ((evt->data.evt_gatt_server_characteristic_status.characteristic == gattdb_temperature_measurement)
&& (evt->data.evt_gatt_server_characteristic_status.status_flags == 0x01)) {
if (evt->data.evt_gatt_server_characteristic_status.client_config_flags == 0x02) {
/* Indications have been turned ON - start the repeating timer. The 1st parameter '32768'
* tells the timer to run for 1 second (32.768 kHz oscillator), the 2nd parameter is
* the timer handle and the 3rd parameter '0' tells the timer to repeat continuously until
* stopped manually.*/
gecko_cmd_hardware_set_soft_timer(32768, 0, 0);
} else if (evt->data.evt_gatt_server_characteristic_status.client_config_flags == 0x00) {
/* Indications have been turned OFF - stop the timer. */
gecko_cmd_hardware_set_soft_timer(0, 0, 0);
}
}
break;
////////////////////////////////////
case gecko_evt_hardware_soft_timer_id:
/* temperatureMeasure();
printf("entering in gecko hardware soft timer case loop\r\n"); */
switch (evt->data.evt_hardware_soft_timer.handle) {
case TIMER_ID_FACTORY_RESET:
gecko_cmd_system_reset(0);
break;
case TIMER_ID_RESTART:
gecko_cmd_system_reset(0);
break;
case TIMER_ID_PROVISIONING:
LEDS_SetState(LED_STATE_PROV);
break;
case TIMER_ID_SAVE_STATE:
lightbulb_state_store();
break;
case TIMER_ID_DELAYED_ONOFF:
/* delay for an on/off request has passed, now process the request */
delayed_onoff_request();
break;
case TIMER_ID_DELAYED_LIGHTNESS:
/* delay for a lightness request has passed, now process the request */
delayed_lightness_request();
break;
case TIMER_ID_ONOFF_TRANSITION:
onoff_transition_complete();
break;
case TIMER_ID_LIGHTNESS_TRANSITION:
lightness_transition_complete();
break;
default:
break;
}
break;
case gecko_evt_mesh_node_initialized_id:
printf("node initialized\r\n");
struct gecko_msg_mesh_node_initialized_evt_t *pData = (struct gecko_msg_mesh_node_initialized_evt_t *)&(evt->data);
if (pData->provisioned) {
printf("node is provisioned. address:%x, ivi:%d\r\n", pData->address, pData->ivi);
_my_address = pData->address;
_elem_index = 0; // index of primary element is zero. This example has only one element.
lightbulb_state_init();
printf("Light initial state is <%s>\r\n", lightbulb_state.onoff_current ? "ON" : "OFF");
LCD_write("provisioned", LCD_ROW_STATUS);
} else {
printf("node is unprovisioned\r\n");
LCD_write("unprovisioned", LCD_ROW_STATUS);
printf("starting unprovisioned beaconing...\r\n");
gecko_cmd_mesh_node_start_unprov_beaconing(0x3); // enable ADV and GATT provisioning bearer
}
break;
case gecko_evt_mesh_node_provisioning_started_id:
printf("Started provisioning\r\n");
LCD_write("provisioning...", LCD_ROW_STATUS);
// start timer for blinking LEDs to indicate which node is being provisioned
gecko_cmd_hardware_set_soft_timer(32768 / 4, TIMER_ID_PROVISIONING, 0);
break;
case gecko_evt_mesh_node_provisioned_id:
_elem_index = 0; // index of primary element is zero. This example has only one element.
lightbulb_state_init();
printf("node provisioned, got address=%x\r\n", evt->data.evt_mesh_node_provisioned.address);
// stop LED blinking when provisioning complete
gecko_cmd_hardware_set_soft_timer(0, TIMER_ID_PROVISIONING, 0);
LEDS_SetState(LED_STATE_OFF);
LCD_write("provisioned", LCD_ROW_STATUS);
break;
case gecko_evt_mesh_node_provisioning_failed_id:
prov_fail_evt = (struct gecko_msg_mesh_node_provisioning_failed_evt_t *)&(evt->data);
printf("provisioning failed, code %x\r\n", prov_fail_evt->result);
LCD_write("prov failed", LCD_ROW_STATUS);
/* start a one-shot timer that will trigger soft reset after small delay */
gecko_cmd_hardware_set_soft_timer(2 * 32768, TIMER_ID_RESTART, 1);
break;
case gecko_evt_mesh_node_key_added_id:
printf("got new %s key with index %x\r\n", evt->data.evt_mesh_node_key_added.type == 0 ? "network" : "application",
evt->data.evt_mesh_node_key_added.index);
break;
case gecko_evt_mesh_node_model_config_changed_id:
printf("model config changed\r\n");
break;
case gecko_evt_mesh_generic_server_client_request_id:
printf("evt gecko_evt_mesh_generic_server_client_request_id\r\n");
mesh_lib_generic_server_event_handler(evt);
break;
case gecko_evt_mesh_generic_server_state_changed_id:
// uncomment following line to get debug prints for each server state changed event
//server_state_changed(&(evt->data.evt_mesh_generic_server_state_changed));
// pass the server state changed event to mesh lib handler that will invoke
// the callback functions registered by application
mesh_lib_generic_server_event_handler(evt);
break;
case gecko_evt_mesh_node_reset_id:
printf("evt gecko_evt_mesh_node_reset_id\r\n");
initiate_factory_reset();
break;
case gecko_evt_le_gap_adv_timeout_id:
// adv timeout events silently discarded
break;
case gecko_evt_le_connection_opened_id:
printf("evt:gecko_evt_le_connection_opened_id\r\n");
num_connections++;
conn_handle = evt->data.evt_le_connection_opened.connection;
LCD_write("connected", LCD_ROW_CONNECTION);
break;
case gecko_evt_le_connection_parameters_id:
printf("evt:gecko_evt_le_connection_parameters_id\r\n");
break;
case gecko_evt_le_connection_closed_id:
/* Check if need to boot to dfu mode */
if (boot_to_dfu) {
/* Enter to DFU OTA mode */
gecko_cmd_system_reset(2);
}
///////////////////////////////////////
else {
/* Stop timer in case client disconnected before indications were turned off */
gecko_cmd_hardware_set_soft_timer(0, 0, 0);
/* Restart advertising after client has disconnected */
gecko_cmd_le_gap_start_advertising(0, le_gap_general_discoverable, le_gap_connectable_scannable);
}
//////////////////////////////////////
printf("evt:conn closed, reason 0x%x\r\n", evt->data.evt_le_connection_closed.reason);
conn_handle = 0xFF;
if (num_connections > 0) {
if (--num_connections == 0) {
LCD_write("", LCD_ROW_CONNECTION);
}
}
break;
case gecko_evt_gatt_server_user_write_request_id:
if (evt->data.evt_gatt_server_user_write_request.characteristic == gattdb_ota_control) {
/* Set flag to enter to OTA mode */
boot_to_dfu = 1;
/* Send response to Write Request */
gecko_cmd_gatt_server_send_user_write_response(
evt->data.evt_gatt_server_user_write_request.connection,
gattdb_ota_control,
bg_err_success);
/* Close connection to enter to DFU OTA mode */
gecko_cmd_le_connection_close(evt->data.evt_gatt_server_user_write_request.connection);
}
break;
case gecko_evt_system_external_signal_id:
{
uint16_t current_level;
char tmp[8];
if (init_done && (evt->data.evt_system_external_signal.extsignals & EXT_SIGNAL_LED_LEVEL_CHANGED)) {
/* this signal from the LED PWM driver indicates that the level has changed,
* we use it here to update the LCD status */
current_level = LEDS_GetLevel();
sprintf(tmp, "%u ", ++current_level * 100 / 65535);
LCD_write(tmp, LCD_ROW_LIGHTNESS);
}
}
break;
default:
//printf("unhandled evt: %8.8x class %2.2x method %2.2x\r\n", evt_id, (evt_id >> 16) & 0xFF, (evt_id >> 24) & 0xFF);
break;
}
}
Thanks & Regards,
Shruti
SI1144 HRM algorithm
SI1153 range
Dear People
I'm trying to improve the range of SI1153 but beyond 30 cm i have no response..I use an external power supply and long range proximity sunlight immune module with SFH4545 LED.
Do you have any idea to help me please ?
This is my i2c configuration:
Thank's
Si115x Programmer’s Toolkit crash on startup
Hi all,
i'm trying to use "Si115x Programmer’s Toolkit Development Software" on my Windows 10 64 bits but program is always crashing on startup (no error appears).
I've found this error on windows events messages :
"Nom de l’application défaillante Si115x GUI.exe, version : 0.0.0.0, horodatage : 0x514e2c2f
Do you have any idea ?
Please have a look on my screen capture.
Best regards
Christophe
Source code of Silicon lab sensor puck application
Hy, i'm a android developer and I'm working on an application that measure body temperature and I need the source code of the silicon lab sensor puck application for android to see how the sensor send data to the application, so where i can find the SDK of this application?
Thanks.
Si1153 - I2C communication ... NEED HELP
Dear people,
Ill try to update a post again as I seem to get zero response from anyone, maybe I am a bit unclear in my description so ill try to do it more clear this time.
This is the config for my I2C
My first question is what is the location of those pins ? I am correct looking at datasheet that it is 0 ?
this function i am using for reading 0x00 register which should give my device id.
Ill also post my debug which is weird because it is giving my ret of 255 .
Si1142 low power consumption
Hi:
Now use si1142 to collect heart rate data,Can collect PPG signal,The mode used is Autonomous Operation Mode。
When the heart rate data is collected, the si1142 needs to enter the lowest power consumption.How can I do it?
The steps for me to enter the lowest power consumption are as follows:
1.Disable INT interrupt
2.send PSALS_PAUSE command.
3.Disable LED1 pin，The LED does not emit light and does not supply power to the LED.
4.Send RESET command，performs a software reset of the firmware.Let si1142 enter Off Mode。
Through the above steps, the si1142's current is 300uA,How to operate can achieve the power consumption of the datasheet, less than 500nA?
thanks.
Undefined Symbol Link Error when building with libsihrm_gcc_cm4f.a
Hello everyone
I made a new project for our custom board which based on EFM32WG230F256 with si1144
But, I get a linker error when building my project
Let me know if there is anything else I can do.
Thanks
Building target: EFM32WG230F256_SensorHub.axf
Invoking: GNU ARM C Linker
arm-none-eabi-gcc -g -gdwarf-2 -mcpu=cortex-m4 -mthumb -T "EFM32WG230F256_SensorHub.
ld" -L"E:\EFM32WG230F256_SensorHub\lib" -Xlinker --gc-sections -Xlinker
-Map="EFM32WG230F256_SensorHub.map" -mfpu=fpv4-sp-d16 -mfloat-abi=softfp --specs=nano.
specs -o EFM32WG230F256_SensorHub.axf
.............
E:\EFM32WG230F256_SensorHub\lib\libsihrm_gcc_cm4f.a(sihrm.o):
In function `kkkfijoifhjvr98rhuj8':
sihrm.c:(.text.kkkfijoifhjvr98rhuj8+0x458): undefined reference to `exp'
E:\Project\CSS2\EFM32WG230F256_SensorHub\lib\libsihrm_gcc_cm4f.a(sihrm.o):
In function `eiemtit09rlkjgepoiji.isra.5':
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x2c4): undefined reference to `sqrt'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0xd66): undefined reference to `sqrt'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0xe90): undefined reference to `fabs'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x210e): undefined reference to `tanh'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x27f0): undefined reference to `sqrt'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x33e4): undefined reference to `Uncompress'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x3628): undefined reference to `Uncompress'
sihrm.c:(.text.eiemtit09rlkjgepoiji.isra.5+0x37a4): undefined reference to `Si114xParamSet'
E:\Project\CSS2\EFM32WG230F256_SensorHub\lib\libsihrm_gcc_cm4f.a(sihrm.o): In function `sihrm_Run':
sihrm.c:(.text.sihrm_Run+0x74): undefined reference to `Si114xPsAlsAuto'
.........
sihrm.c:(.text.sihrm_DetectSkinContact+0x18): undefined reference to `Si114xParamRead'
sihrm.c:(.text.sihrm_DetectSkinContact+0x24): undefined reference to `Si114xParamSet'
sihrm.c:(.text.sihrm_DetectSkinContact+0x2a): undefined reference to `Si114xAlsForce'
sihrm.c:(.text.sihrm_DetectSkinContact+0x78): undefined reference to `Si114xParamSet'
sihrm.c:(.text.sihrm_DetectSkinContact+0x84): undefined reference to `Si114xPsForce'
about the Si1144-AAGX-GM
Hi,
Could you tell me where can i get the Si1144-AAGX-GM bxl file ?
Thanks
Humidity accuracy of SI7021-A20-GM1R in a vacuum (~10mbar)
Anybody worked with HTU21D temp and hum sensor?
Hi,
I have a BGM111 breakout board and a HTU21D temp and hum breakout sensor board that I would like to use. My current setting is:
I2C device addres is 0x40
SDA port : PC10
SCL port : PC11
Anyhelp would be appreciate it.
Thanks
Measure solar radiation (W/m2) using SI1133
I'm moving forward with a project that has to be closed in a short time for a prototyping of a few hundred units.
An important part is the measurement of solar radiation. I decided to use the SI1133 and make the sum of IR, visible and UV. For the application I'm doing is perfect.
However I am studying more deeply the operation of the sensor and I am very confused. I think I got even more when I saw some online sw libs for it.
What are the ADC's settings and the conversion calculation of the channel readings to W/m2?
How can I relate to table 8.3 (datasheet)?
If I set up a channel for LARGE_IR (for example), when I read that channel how do I relate the value read with W/m2?
ADCCONFIG0 = 0x02; - IR
ADCCONFIG1 = 0x0D; - VISIBLE
ADCCONFIG2 = 0x18; - UV
I can not move forward from this point because I do not understand what kind of result the sensor will give me.
My strategy would be to get the direct values with the sensor without a lens (to be able to use the ratio of table 8.3) and use another sensor with a Teflon diffuser lens to calculate the lens attenuation.
The goal is to do something similar to a pyranometer.
Can anyone give me more infos? Some help? Is my thinking correct?