evaluation_app/app.c

/* Copyright 2020 Wirepas Ltd. All Rights Reserved.
 *
 * See file LICENSE.txt for full license details.
 *
 */
 
/*
 * @file    app.c
 * @brief   This file is a helloworld app enabling wirepas mesh network
 *          capabilities experiments
 *          (see README for additional information)
 */
 
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
 
#include "shared_appconfig.h"
#include "api.h"
#include "node_configuration.h"
#include "led.h"
#include "button.h"
#include "shared_data.h"
#include "app_scheduler.h"
 
 
#define DEBUG_LOG_MODULE_NAME "EVAL_APP"
 
#define DEBUG_LOG_MAX_LEVEL LVL_NOLOG
 
#include "debug_log.h"
 
 
#define COARSE_TO_MS(delay)    (1000u * (delay) >> 7)
 
#define PERIODIC_MSG_DATA_PATTERN_LEN   (8u)
 
#define DEFAULT_PERIOD_S    (10u)
 
#define DEFAULT_PERIOD_MS   (DEFAULT_PERIOD_S*1000u)
 
#define CUSTOM_PERIOD_TYPE 0xC3
 
#define PERIODIC_WORK_EXECUTION_TIME_US (250u)
 
#define BUTTON_PRESSED_STATE  (2u)
 
#define TASK_EXEC_TIME_US_SEND_BUTTON_PRESSED_MSG (250u)
 
 
typedef struct  __attribute__((packed))
{
    uint32_t interval;    
    /* uint16_t custom_data; */
} app_config_t;
 
 
#define PERIODIC_MSG_PERIOD_SET_MIN_VAL_MS      (2000ul)
 
#define PERIODIC_MSG_PERIOD_SET_MAX_VAL_MS      (1200000ul)
 
#define MAX_LED_PER_BOARD       (4u)
 
#define DATA_EP        (1u)
 
static uint16_t m_filter_id;
typedef enum
{
    MSG_ID_PERIODIC_MSG = 0,
    MSG_ID_BUTTON_EVENT_MSG = 1,
    MSG_ID_ECHO_RESPONSE_MSG = 2,
    MSG_ID_LED_GET_STATE_RESPONSE_MSG = 3,
    MSG_ID_PERIODIC_MSG_PERIOD_SET_MSG = 128,
    MSG_ID_LED_SET_STATE_MSG = 129,
    MSG_ID_LED_GET_STATE_MSG = 130,
    MSG_ID_ECHO_COMMAND_MSG = 131,
} message_id_e;
 
 
typedef enum
{
    LED_STATE_OFF   = 0,
    LED_STATE_ON    = 1
} led_state_e;
 
typedef struct __attribute__((packed))
{
    uint32_t counter_value;
    uint8_t data_pattern[PERIODIC_MSG_DATA_PATTERN_LEN];
} payload_periodic_t;
 
typedef struct __attribute__((packed))
{
    uint32_t new_period_ms;
} payload_periodic_set_t;
 
typedef struct __attribute__((packed))
{
    uint8_t button_id;
    uint8_t button_state;
} payload_button_event_t;
 
typedef struct __attribute__((packed))
{
    uint32_t travel_time_ms;
} payload_response_echo_t;
 
typedef struct __attribute__((packed))
{
    uint8_t led_id;
    uint8_t led_state;
} payload_led_state_set_t;
 
typedef struct __attribute__((packed))
{
    uint8_t led_id;
} payload_led_state_get_t;
 
typedef struct __attribute__((packed))
{
    uint8_t led_id;
    uint8_t led_state;
} payload_response_led_state_get_t;
 
typedef struct __attribute__((packed))
{
    uint8_t id;
    union
    {
        payload_periodic_t               periodic;
        payload_periodic_set_t           periodic_set_period;
        payload_button_event_t           button_event;
        payload_response_echo_t          resp_echo;
        payload_led_state_set_t          led_state_set;
        payload_led_state_get_t          led_state_get;
        payload_response_led_state_get_t resp_led_state_get;
    } payload;
} msg_t;
 
static const uint8_t m_periodic_data_pattern[PERIODIC_MSG_DATA_PATTERN_LEN] =
                                            {0x0A,0x0B,0x0B,0x0A,0x0A,0x0C,0x0D,0x0C};
 
static volatile uint8_t m_button_pressed_id;
 
static uint32_t m_period_ms;
 
static led_state_e m_table_led_state[MAX_LED_PER_BOARD] = {0};
 
static app_lib_data_receive_res_e unicast_broadcast_data_received_cb(
        const shared_data_item_t * item,
        const app_lib_data_received_t * data);
 
static shared_data_item_t unicast_packets_filter =
{
    .cb = unicast_broadcast_data_received_cb,
    .filter = {
        .mode = SHARED_DATA_NET_MODE_UNICAST,
        /* Filtering by source endpoint. */
        .src_endpoint = DATA_EP,
        /* Filtering by destination endpoint. */
        .dest_endpoint = DATA_EP,
        .multicast_cb = NULL
    }
};
 
static shared_data_item_t broadcast_packets_filter =
{
    .cb = unicast_broadcast_data_received_cb,
    .filter = {
        .mode = SHARED_DATA_NET_MODE_BROADCAST,
        /* Filtering by source endpoint. */
        .src_endpoint = DATA_EP,
        /* Filtering by destination endpoint. */
        .dest_endpoint = DATA_EP,
        .multicast_cb = NULL
    }
};
 
static app_lib_data_send_res_e send_uplink_msg(message_id_e id,
                                               uint8_t * payload)
{
    msg_t msg; /* Create uplink message structure. */
    size_t msg_byte_size = sizeof(msg.id); /* Message to send byte size. */
 
    msg.id = (uint8_t)id;
 
    switch (msg.id)
    {
        case MSG_ID_PERIODIC_MSG:
            memcpy(&msg.payload.periodic,
                   (payload_periodic_t *)payload,
                   sizeof(payload_periodic_t));
 
            msg_byte_size += sizeof(payload_periodic_t);
            break;
 
        case MSG_ID_BUTTON_EVENT_MSG:
            memcpy(&msg.payload.button_event,
                   (payload_button_event_t *)payload,
                   sizeof(payload_button_event_t));
 
            msg_byte_size += sizeof(payload_button_event_t);
            break;
        case MSG_ID_ECHO_RESPONSE_MSG:
            memcpy(&msg.payload.resp_echo,
                   (payload_response_echo_t *)payload,
                   sizeof(payload_response_echo_t));
 
            msg_byte_size += sizeof(payload_response_echo_t);
            break;
        case MSG_ID_LED_GET_STATE_RESPONSE_MSG:
            memcpy(&msg.payload.resp_led_state_get,
                   (payload_response_led_state_get_t *)payload,
                   sizeof(payload_response_led_state_get_t));
 
            msg_byte_size += sizeof(payload_response_led_state_get_t);
            break;
        default:
            /* Invalid message ID given : send only invalid msg ID. */
            break;
    }
 
    /* Create a data packet to send. */
    app_lib_data_to_send_t data_to_send;
    data_to_send.bytes = (const uint8_t *) &msg;
    data_to_send.num_bytes = msg_byte_size;
    data_to_send.dest_address = APP_ADDR_ANYSINK;
    data_to_send.src_endpoint = DATA_EP;
    data_to_send.dest_endpoint = DATA_EP;
    data_to_send.qos = APP_LIB_DATA_QOS_HIGH;
    data_to_send.flags = APP_LIB_DATA_SEND_FLAG_NONE;
    data_to_send.tracking_id = APP_LIB_DATA_NO_TRACKING_ID;
 
    /* Send the data packet. */
    return Shared_Data_sendData(&data_to_send, NULL);
}
 
static uint32_t task_send_periodic_msg(void)
{
    static uint32_t counter_value = 0;
    payload_periodic_t payload; /* Message payload data. */
 
    payload.counter_value = counter_value;
    memcpy(payload.data_pattern,
           m_periodic_data_pattern,
           sizeof(m_periodic_data_pattern));
 
    /* Send message. */
    if (send_uplink_msg(MSG_ID_PERIODIC_MSG,
                        (uint8_t *)&payload) != APP_LIB_DATA_SEND_RES_SUCCESS)
    {
        /*
         * Message was not accepted for sending.
         * Error handling can be performed here.
         */
    }
 
    /* Increment value to send. */
    counter_value++;
 
    /*
     * Inform the stack that this function should be called again in
     * m_period_ms milliseconds. By returning APP_SCHEDULER_STOP_TASK,
     * the scheduler will remove the task.
     */
    return m_period_ms;
}
 
static uint32_t task_send_button_pressed_msg(void)
{
    payload_button_event_t payload;      /* Message payload data. */
 
    /* Prepare payload data field. */
    payload.button_id = m_button_pressed_id;
    payload.button_state = (uint8_t)BUTTON_PRESSED_STATE;
 
    /* Send message. */
    if (send_uplink_msg(MSG_ID_BUTTON_EVENT_MSG,
                        (uint8_t *)&payload) != APP_LIB_DATA_SEND_RES_SUCCESS)
    {
        /*
         * Message was not accepted for sending.
         * Error handling can be performed here.
         */
    }
 
    return APP_SCHEDULER_STOP_TASK;
}
 
static void button_pressed_handler(uint8_t button_id, button_event_e event)
{
    (void) event;
 
    /* Store button_id to process it in a dedicated application task. */
    m_button_pressed_id = button_id;
 
    /*
     * Send "button pressed message" in a single shot application task (called
     * each time button is pressed) as we are here in an IRQ context.
     */
    App_Scheduler_addTask_execTime(task_send_button_pressed_msg,
                                   APP_SCHEDULER_SCHEDULE_ASAP,
                                   TASK_EXEC_TIME_US_SEND_BUTTON_PRESSED_MSG);
}
 
static void send_echo_response_msg(uint32_t delay)
{
    /* Message payload data. */
    payload_response_echo_t payload =
    {
        .travel_time_ms = 0
    };
 
    /* Prevent overflow. In case of error "travel_time_ms" value is nil. */
    if (delay <= UINT32_MAX/1000u)
    {
        /*
         * Downlink propagation time is expressed in 1/128th second.
         * Have to convert it into millisecond.
         */
        payload.travel_time_ms = COARSE_TO_MS(delay);
    }
 
    /* Send message. */
    if (send_uplink_msg(MSG_ID_ECHO_RESPONSE_MSG,
                        (uint8_t *)&payload) != APP_LIB_DATA_SEND_RES_SUCCESS)
    {
        /*
         * Message was not accepted for sending.
         * Error handling can be performed here.
         */
    }
}
 
static void set_periodic_msg_period(uint32_t new_period_ms)
{
    /*
     * Check new period value is in a valid range
     * and update period accordingly.
     */
    if ((new_period_ms >= PERIODIC_MSG_PERIOD_SET_MIN_VAL_MS) &&
            (new_period_ms <= PERIODIC_MSG_PERIOD_SET_MAX_VAL_MS))
    {
        m_period_ms = new_period_ms;
 
        /* Reschedule task to apply new period value. */
        App_Scheduler_addTask_execTime(task_send_periodic_msg,
                                       APP_SCHEDULER_SCHEDULE_ASAP,
                                       PERIODIC_WORK_EXECUTION_TIME_US);
    }
    else
    {
        /* Invalid period value do not change anything. */
    }
}
 
static void set_led_state(uint8_t led_id, uint8_t led_state)
{
    /* Check if requested LED is available on the board. */
    uint8_t leds_num = Led_getNumber();
 
    if ((led_id < MAX_LED_PER_BOARD) && (led_id < leds_num) && (leds_num > 0))
    {
        /*
         * Valid LED ID requested:
         * execute command if valid LED state received.
         */
        if (led_state == LED_STATE_OFF)
        {
            Led_set(led_id,false); /* Switch off LED. */
            m_table_led_state[led_id] = LED_STATE_OFF;
        }
        else if (led_state == LED_STATE_ON)
        {
            Led_set(led_id,true); /* Switch on LED. */
            m_table_led_state[led_id] = LED_STATE_ON;
        }
        else
        {
            /* Invalid LED state received : do nothing. */
        }
    }
}
 
static void send_led_state(uint8_t led_id)
{
    payload_response_led_state_get_t payload; /* Message payload data. */
 
    /*
     * Check if requested LED is available on the board
     * and that led state table is big enough to hold all led's status.
     */
    uint8_t leds_num = Led_getNumber();
 
    if ((led_id < MAX_LED_PER_BOARD) && (led_id < leds_num) && (leds_num > 0))
    {
        /* Prepare payload data. */
        payload.led_id = led_id;
        payload.led_state = (uint8_t)m_table_led_state[led_id];
 
        /* Send message. */
        if (send_uplink_msg(MSG_ID_LED_GET_STATE_RESPONSE_MSG,
                            (uint8_t *)&payload) != APP_LIB_DATA_SEND_RES_SUCCESS)
        {
            /*
             * Message was not accepted for sending.
             * Error handling can be performed here.
             */
        }
    }
}
 
static app_lib_data_receive_res_e unicast_broadcast_data_received_cb(
        const shared_data_item_t * item,
        const app_lib_data_received_t * data)
{
    (void) item;
 
    msg_t msg = *((msg_t *)data->bytes);
    uint8_t msg_size = data->num_bytes;
 
    if ((msg_size < sizeof(msg.id)))
    {
        /* Data is not for this application. */
        return APP_LIB_DATA_RECEIVE_RES_NOT_FOR_APP;
    }
 
    msg_size -= sizeof(msg.id);
 
    /* Process incoming message according to message ID. */
    switch (msg.id)
    {
        /*
         * First check received message length match expected one.
         * If not the case do not change anything else execute action.
         */
        case MSG_ID_ECHO_COMMAND_MSG:
            if (msg_size == 0)
            {
                send_echo_response_msg(data->delay);
            }
            break;
 
        case MSG_ID_PERIODIC_MSG_PERIOD_SET_MSG:
            if (msg_size == sizeof(payload_periodic_set_t))
            {
                set_periodic_msg_period(
                        msg.payload.periodic_set_period.new_period_ms);
            }
            break;
 
        case MSG_ID_LED_SET_STATE_MSG:
            if (msg_size == sizeof(payload_led_state_set_t))
            {
                set_led_state(msg.payload.led_state_set.led_id,
                              msg.payload.led_state_set.led_state);
            }
            break;
 
        case MSG_ID_LED_GET_STATE_MSG:
            if (msg_size == sizeof(payload_led_state_get_t))
            {
                send_led_state(msg.payload.led_state_get.led_id);
            }
            break;
 
        default:    /* Unknown message ID : do nothing. */
            break;
 
    }
 
    /* Data handled successfully. */
    return APP_LIB_DATA_RECEIVE_RES_HANDLED;
}
 
 
static void appConfigPeriodReceivedCb(uint16_t type,
                                      uint8_t length,
                                      uint8_t * value_p)
{
    app_config_t * config;
 
    if (type != CUSTOM_PERIOD_TYPE)
    {
        /* It should never happen as we registered only this type with this cb. */
        LOG(LVL_ERROR, "Wrong app config type");
        return;
    }
 
    if (length != sizeof(app_config_t))
    {
        /* Wrong size. */
        LOG(LVL_ERROR, "Wrong app config size");
        return;
    }
 
    config = (app_config_t *) value_p;
 
    LOG(LVL_INFO,
        "New app configuration  interval_s=%d",
        config->interval);
 
    /* Set new periodic data transfer interval. */
    set_periodic_msg_period(config->interval*1000);
 
}
 
 
 
void App_init(const app_global_functions_t * functions)
{
    (void) functions;
 
    LOG_INIT();
    LOG(LVL_INFO, "Evaluation App example start");
 
    shared_app_config_filter_t app_config_period_filter;
 
    /* Prepare the app_config filter for measurement rate. */
    app_config_period_filter.type = CUSTOM_PERIOD_TYPE;
    app_config_period_filter.cb = appConfigPeriodReceivedCb;
    Shared_Appconfig_addFilter(&app_config_period_filter, &m_filter_id);
    LOG(LVL_INFO, "Filter added for static period with id=%d\n", m_filter_id);
 
 
    uint8_t num_buttons;
 
    /* Basic configuration of the node with a unique node address. */
    if (configureNodeFromBuildParameters() != APP_RES_OK)
    {
        /*
         * Could not configure the node.
         * It should not happen except if one of the config value is invalid.
         */
        return;
    }
    /*
     * Set node operating mode (i.e low-energy or low-latency with autorole)
     * Default is low-energy.
     */
#ifdef ENABLE_LOW_LATENCY_MODE
    lib_settings->setNodeRole(APP_LIB_SETTINGS_ROLE_AUTOROLE_LL);
#endif
 
    num_buttons = Button_get_number();
 
    for (uint8_t button_id = 0; button_id < num_buttons; button_id++)
    {
        /* Register button pressed event on all user available button. */
        Button_register_for_event(button_id,
                                  BUTTON_PRESSED,
                                  button_pressed_handler);
    }
 
    /* Set a periodic task to be called after DEFAULT_PERIOD_MS. */
    m_period_ms = DEFAULT_PERIOD_MS;
    App_Scheduler_addTask_execTime(task_send_periodic_msg,
                                   APP_SCHEDULER_SCHEDULE_ASAP,
                                   PERIODIC_WORK_EXECUTION_TIME_US);
 
    /* Set unicast & broadcast received messages callback. */
    Shared_Data_addDataReceivedCb(&unicast_packets_filter);
    Shared_Data_addDataReceivedCb(&broadcast_packets_filter);
 
    /*
     * Start the stack.
     * This is really important step, otherwise the stack will stay stopped and
     * will not be part of any network. So the device will not be reachable
     * without reflashing it.
     */
    lib_state->startStack();
}