MZ_lwm2m_example1.c

Go to the documentation of this file.

/*
 * Objectives covered in this Example :
 * 1. Demonstrate how to create a simple recursive Timer using MonoZ_Lib
 * 2. Demonstrate how to create a Application Thread using MonoZ_Lib
 * 3. Demonstrate how to use lwm2m API's defined in MonoZ_Lib to set
 *    Object/Resource values using mz_set_value_Ob19_X_X API,
 *    Read the new data received from server(in write event) using
 *    mz_read_value_Ob19_X_X API, Send the sensor data using
 *    mz_set_and_notify_Ob19_X_X API.
 * 4. Demonstrate how to handle post processing event from MonoZ_Lib lwm2m
 *    client.
 * 5. Demonstrate how to read RTC time.
 *
 * Sources for this example :
 * MZ_lwm2m_example1.c  - Main Application file
 * MZ_lwm2m_example1.h
 *
 * [Other Linked files]
 * MZ_modem_config.c    - Modem command integration file
 */
 
 
#include "MZ_sys_cmsis_os2.h"
#include "MZ_lwm2m_example1.h"
#include "MZ_timer.h"
#include "MZ_print.h"
#include "MZ_error_handler.h"
#include "MZ_Lwm2m_public.h"
#include "MZ_type_converter.h"
#include "MZ_rtc.h"
#include "stdio.h"
 
#define LW_START_AT_INIT                (0)                         
#define LW_START_AT_THREAD              (1)                         
 
/*
 * This is the example switch MACRO.
 * 1. define LWM2M_EXAMPLE as LW_START_AT_INIT for example to start the timer
 * without Application thread
 * 2. define LWM2M_EXAMPLE as LW_START_AT_THREAD for example to start the timer
 * inside Application thread
 */
#define LWM2M_EXAMPLE                   LW_START_AT_THREAD
 
#define LWM2M_APP_STACK_SIZE            (128)                       
#define LWM2M_TX_TIME                   (pdMS_TO_TICKS(60000))      
 
static char sensor_data[11] = "";                       
static char sensor_in[5] = "0000";                      
static int copy_flag = 0;
 
/*
 * This Timer callback will be called after the timer is expired.
 * The timer value is set as LWM2M_TX_TIME
 */
static void lwm2m_timer_cb(TimerHandle_t xTimer)
{
    /*
     * If new Data has received from server - The copy has been done if
     * Lwm2m write is received. Check lwm2m_event_process() API define in this
     * file for more details.
     */
    if(copy_flag)
    {
        /* Process the data - Copy the data to Dummy buffer */
        sensor_data[0] = '\0';
        sensor_data[9] = '\0';
        mz_hex_to_ascii(&sensor_data[1], sensor_in);
        copy_flag = 0;
    }
 
    /* Increment the Dummy buffer */
    sensor_in[3]++;
 
    /* Convert the raw data to ascii string for sending to server */
    mz_ascii_to_hex(sensor_in,&sensor_data[1]);
 
    sensor_data[0] = '\"';
    sensor_data[9] = '\"';
    sensor_data[10] = '\0';
 
    /* Read the RTC time */
    mzd_time _tm;
    mz_error_t tm_rd_status = MZ_RTC_read(&_tm);
 
    /* Print the RTC time on CLI */
    if(MZ_OK == tm_rd_status)
    {
        char _tm_string[40] = {0};
        sprintf(_tm_string,
                "Time Now : %02d/%02d/%02d::%02d:%02d:%02d",
                _tm.YY,
                _tm.MM,
                _tm.DD,
                _tm.hh,
                _tm.mm,
                _tm.ss);
        mz_puts(_tm_string);
        mz_puts("\r\n");
    }
    else
    {
        mz_puts((char *)mz_error_to_str(tm_rd_status));
    }
 
    /* Send the Dummy data to Lwm2m server using Notify */
    mz_error_t status = mz_set_and_notify_Ob19_0_0(sensor_data);
    if(MZ_OK == status)
    {
        mz_puts("Notify send to SDK\r\n");
    }
    else
    {
        mz_puts((char *)mz_error_to_str(status));
    }
}
 
/*
 * When want the example to start the timer inside Application thread
 * define LWM2M_EXAMPLE as LW_START_AT_THREAD
 */
#if(LWM2M_EXAMPLE == LW_START_AT_THREAD)
 
static mz_thread_t      lwm2m_thread_id = NULL;                                 /* Thread id handler */
static StaticTask_t     lwm2m_cb_mem;                                           /* Thread control block */
static StackType_t      lwm2m_stack[LWM2M_APP_STACK_SIZE];                      /* Thread stack */
 
static void lwm2m_app(void * arg)
{
    (void)arg;
    /*
     * create a recursive timer for sending sensor data.
     * In-case of other type of timer, please refer MZ_timer.h
     * The expire time for this timer set to LWM2M_TX_TIME.
     * "lwm2m_timer_cb" is passed as an argument.
     * When the timer expires, the "lwm2m_timer_cb" API will be
     * processed.
     */
    if(MZ_OK != mz_tm_create_start_recursive("Lwm2m timer",
                                            LWM2M_TX_TIME,
                                            lwm2m_timer_cb))
    {
        __NOP(); //No action
    }
 
    mz_puts("Lwm2m Timer Created and started at Application \r\n");
 
    /*
     * This is the infinite loop for this thread - the thread will execute this
     * loop forever and not come outside of this loop
     */
    while(1)
    {
        /* Need to write the periodic executing logic in this loop block */
 
 
        /* Put a delay to avoid blocking on this thread */
        HAL_Delay(10);
 
    }//End of while(1) - Do not place any code after this.
 
}
#endif //(LWM2M_EXAMPLE == LW_START_AT_THREAD)
 
/*  
 * @fn mz_error_t lwm2m_app_init(void)
 * @brief Initiate LWM2M App
 * @return MZ_OK/MZ_FAIL
 */ 
mz_error_t lwm2m_app_init(void)
{
    mz_error_t _ret = MZ_OK;
 
/*
 * When want the example to start the timer without Application thread
 * define LWM2M_EXAMPLE as LW_START_AT_INIT
 */
#if(LWM2M_EXAMPLE == LW_START_AT_INIT)
    /*
     * create a recursive timer for sending sensor data.
     * In-case of other type of timer, please refer MZ_timer.h
     * The expire time for this timer set to LWM2M_TX_TIME.
     * "lwm2m_timer_cb" is passed as an argument.
     * When the timer expires, the "lwm2m_timer_cb" API will be
     * processed.
     */
    if(MZ_OK != mz_tm_create_start_recursive("My timer",
                                            LWM2M_TX_TIME,
                                            lwm2m_timer_cb))
    {
        __NOP();
    }
 
    mz_puts("Timer Created and started at Initialization \r\n");
 
 
/*
 * When want the example to start the timer inside Application thread
 * define LWM2M_EXAMPLE as LW_START_AT_THREAD
 */
#else
    /* Create the application thread */
    if(!mz_thread_create(&lwm2m_thread_id,
                            "Lwm2m Scheduler",
                            lwm2m_app,
                            NULL,
                            osPriorityNormal,
                            lwm2m_stack,
                            LWM2M_APP_STACK_SIZE,
                            &lwm2m_cb_mem,
                            sizeof(lwm2m_cb_mem)))
    {
        _ret = MZ_THREAD_CREATE_FAIL;
    }
#endif // (LWM2M_EXAMPLE == LW_START_AT_INIT)
 
    /*
     * Set MonoZ_Lib lwm2m internal resources to default value before
     * application start.
     */
    _ret = mz_set_value_Ob19_0_0("\"30303030\"");
    if(MZ_OK != _ret) goto clean;
    _ret = mz_set_value_Ob19_1_0("\"30303030\"");
    if(MZ_OK != _ret) goto clean;
 
    clean :
    return _ret;
}
 
/*
 * @fn void lwm2m_event_process(void * event)
 * @brief Process LWM2M Event
 * @param event void
 */
/*
 * LWM2M user defined callback function. - START
 *
 * This Function will be called from MZ_callback.c mz_pro_default_callback().
 * User need to check the events interested based on specific application
 * requirement. If no application requirement exist for specific event, then
 * no action need to be taken by this function
 *
 * NOTE :
 * MonoZ_Lib will call the mz_pro_default_callback() API after processing all
 * LWM2M server events. So the events received at this API are just to inform
 * user application to perform any post processing tasks. MonoZ_Lib maintain
 * server connection and Obj19 related data. The detailed event list refer
 * MZ_Lwm2m_public.h
 */
void lwm2m_event_process(void * event)
{
    st_lw_event * e = event; //*((st_lw_event *)event);
 
    /* Check post-processing events is send by MonoZ_Lib to user */
    switch(e->lw_event)
    {
        /*
         * This is a write event. The event has already been processed and the
         * data from server is stored inside MonoZ_Lib. If any user
         * action need to be taken then it can be performed here.
         */
        case LW_EV_WRITE_DATA:
        {
            /* print the write received on CLI */
            mz_puts("Write received - Copy here\r\n");
 
            /*
             * Application need to read and copy the data to local buffer for
             * processing
             */
            mz_error_t ret = MZ_FAIL;
            char * data = mz_read_value_Ob19_0_0(&ret);
            if(MZ_OK == ret)
            {
                strcpy(sensor_data,data);
                copy_flag = 1;
                mz_puts("Copy success\r\n");
            }
        }
        break;
        case LW_EV_EXECUTE:
            /* Do something on Execute received */
            ;
        break;
        /*
         * This is a read event. The event has already been processed and the
         * data stored inside MonoZ_Lib has already send to server. If any user
         * action need to be taken then it can be performed here.
         */
        case LW_EV_READ:
            /* print the read received on CLI */
            mz_puts("Read received\r\n");
        break;
        /*
         * This is a Observe start event. The event has already been processed
         * and the token is already stored inside MonoZ_Lib. If any user action
         * need to be taken then it can be performed here.
         */
        case LW_EV_OBSERVE:
            /* print the observe received on CLI */
            mz_puts("Observe received\r\n");
        break;
        /*
         * This is a Observe cancel event. The event has already been processed
         * and the token is already clear inside MonoZ_Lib. If any user action
         * need to be taken then it can be performed here.
         */
        case LW_EV_OBSERVE_CANCEL:
            /* print the observe cancel received on CLI */
            mz_puts("Observe cancel received\r\n");
        break;
        case LW_EV_CLIENT_NOTIFY_SEND:
            /* print when notify send to server */
            mz_puts("Notify send to server\r\n");
        break;
        case LW_EV_CLIENT_NOTIFY_SEND_ACK:
            /* print when notify acknowledgment is received from server */
            mz_puts("Notify send acknowledge\r\n");
        break;
        case LW_EV_NOTIFY_FAIL:
            /* print when notify failed received from server */
            mz_puts("Notify send failed\r\n");
        break;
        default:
        break;
    }
}