MZ_Addon_board_CO2.c

Go to the documentation of this file.

/*
 * Objectives covered in this Example :
 * 1. Demonstrate how to create a UART instance, configure and integrate the
 *    UART instance with MonoZ_Lib
 * 2. Demonstrate how to use UART in interrupt mode for receiving data
 * 3. Demonstrate how to create a Application Thread using MonoZ_Lib
 * 4. Demonstrate how to create single-shot and recursive timers, and use them.
 * 5. 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.
 * 6. Demonstrate how to handle post processing event from MonoZ_Lib lwm2m
 *    client.
 * 7. Demonstrate how to force modem re-initialization.
 * 8. Demonstrate how to use CLI for printing informations.
 *
 * Sources for this example :
 * MZ_Addon_board_CO2.c - Main Application, UART Driver and sensor Driver
 * MZ_Addon_board_CO2.h
 *
 * [Other Linked files]
 * MZ_hardware_config.c - Hardware Driver integration file
 * MZ_modem_config.c    - Modem command integration file
 */
 
 
/* Include Header Files - START */
#include "MZ_Addon_board_CO2.h"
#include "MZ_sys_cmsis_os2.h"
#include "MZ_error_handler.h"
#include "MZ_timer.h"
#include "MZ_print.h"
#include "MZ_Lwm2m_public.h"
#include "MZ_type_converter.h"
#include "MZ_Modem_public.h"
#include "MZ_uart.h"
#include "MZ_main.h"
#include "stdlib.h"
/* Include Header Files - END */
 
/* Define some common use MACRO - START */
#define SERVER_REG_NEED_SET                     (0)                     
#define SERVER_REG_NEED_CLEAR                   (1)                     
#define CO2_READ_TIMER_EXPIRE_SET               (1)                     
#define CO2_READ_TIMER_EXPIRE_CLEAR             (0)                     
#define OBSERVE_COMPLETE_SET                    (1)                     
#define OBSERVE_COMPLETE_CLEAR                  (0)                     
#define UART_RECEIVE_COMPLETE_SET               (0x00)                  
#define UART_RECEIVE_COMPLETE_CLEAR             (0xFF)                  
#define TIME_180SEC                             (pdMS_TO_TICKS(180000)) 
#define TIME_90SEC                              (pdMS_TO_TICKS(90000))  
#define TIMER_ID_CLEAR                          (0)                     
/* Define some common use MACRO - END */
 
/* Thread related MACRO and variables - START */
#define CO2_APP_STACK_SIZE          (512)                                       
static mz_thread_t                  co2_thread_id = NULL;                       
static StaticTask_t                 co2_cb_mem;                                 
static StackType_t                  co2_stack[CO2_APP_STACK_SIZE];              
/* Thread related MACRO and variables - END */
 
/* Timer related MACRO and variables - START */
#define LWM2M_SERVER_MONITORING_TIME            (TIME_180SEC)           
#define CO2_SENSOR_READ_TIME                    (TIME_90SEC)            
static size_t lwm2m_server_monitoring_timer_id = TIMER_ID_CLEAR;        
static char co2_read_timer_expire_flag = CO2_READ_TIMER_EXPIRE_CLEAR;   
/* Timer related MACRO and variables - END */
 
/* CO2 sensor related MACRO and variables - START */
#define CO2_CMD_ID_21                           (0x21)                  
#define CO2_CMD_ID_23                           (0x23)                  
static st_co2_cmd cmd23 = {
        .sop=0x5B,.ver=0x01,.cmd=0x23,.len=1,.data=0,.crc=0x0A74,.eop=0x5D};    
static st_co2_cmd cmd21 = {
        .sop=0x5B,.ver=0x01,.cmd=0x21,.len=1,.data=0,.crc=0x8A5F,.eop=0x5D};    
static st_co2_cmd_resp23 resp23;                                                
static st_co2_cmd_resp21 resp21;                                                
static unsigned char decimal_place = 0;                                         
static volatile long int co2_raw = 0;                                           
static volatile long int final_co2_value = 0;                                   
/* CO2 sensor related MACRO and variables - END */
 
/* LWM2M related MACRO and variables - START */
static char lwm2m_server_rereg_flag = SERVER_REG_NEED_CLEAR;                    
static char observe_receive_flag = OBSERVE_COMPLETE_CLEAR;                      
static char payload_string[11] = "";                                            
/* LWM2M related MACRO and variables - END */
 
extern void mz_reboot_sequence(void * arg);
 
/* CRC related MACRO and variables - START */
#define CRC_TABLE_SIZE 256                                          
#define CRC16_POLY 0x8005                                           
#define CRC16_INIT_REM 0x0000                                       
#define CRC16_FINAL_XOR 0x0000                                      
extern const unsigned short crc16Table[CRC_TABLE_SIZE];             
/* CRC related MACRO and variables - END */
 
static mz_error_t co2_uart_init(void);
static void lwm2m_server_monitoring_timer_cb(TimerHandle_t xTimer);
static void co2_sensor_read_timer_cb(TimerHandle_t xTimer);
static void lwm2m_server_reregistration(void);
static void create_lwm2m_payload(void);
static void send_payload_to_server(void);
static void process_resp23(void);
static void process_resp21(void);
static void co2_app_thread(void * arg);
static unsigned short crc16MakeTableMethod( unsigned short crc,
                                            const unsigned short *table,
                                            unsigned char *pbuffer,
                                            unsigned int length);
/* static function prototypes - END */
 
/*============================================================================*/
/* CO2 ADDON board - UART related code - START                                */
/*============================================================================*/
 
/* CO2 UART configuration related MACRO - START */
#define MZ_ADDONCO2_INSTANCE                    (LPUART1)                   
#define MZ_ADDONCO2_INIT_BAUDRATE               (57600)                     
#define MZ_ADDONCO2_INIT_WORDLENGTH             (UART_WORDLENGTH_8B)        
#define MZ_ADDONCO2_INIT_STOPBITS               (UART_STOPBITS_1)           
#define MZ_ADDONCO2_INIT_PARITY                 (UART_PARITY_NONE)          
#define MZ_ADDONCO2_INIT_MODE                   (UART_MODE_TX_RX)           
#define MZ_ADDONCO2_INIT_HWFLOWCTL              (UART_HWCONTROL_NONE)       
#define MZ_ADDONCO2_INIT_OVERSAMPLING           (UART_OVERSAMPLING_16)      
#define MZ_ADDONCO2_INIT_ONEBITSAMPLING         (UART_ONE_BIT_SAMPLE_DISABLE)   
#define MZ_ADDONCO2_ADVANCEDINIT_ADVFEATUREINIT (UART_ADVFEATURE_NO_INIT)   
#define MZ_ADDONCO2_UART_INSTANCE               (_LPUART1)                  
/* CO2 UART configuration related MACRO - START */
 
/* CO2 UART configuration structure - START */
/*
 * This configuration structure is used in MZ_hardware_config.c to initialize
 * the UART hardware interface.
 * In this example this Configuration is taken during the Initialization of
 * the MonoZ_Lib to load the settings prior to Application start.
 *
 * NOTE:
 * In-case Application want to perform UART initialization later after
 * application start or by itself during runtime, MZ_UART_init() API can be
 * used.
 * In such case remove the configuration from MZ_hardware_config.c.
 */
MZ_UART_INIT_ST co2_lpuart1_instance =
{
    .Instance = MZ_ADDONCO2_INSTANCE,
    .Init.BaudRate = MZ_ADDONCO2_INIT_BAUDRATE,
    .Init.WordLength = MZ_ADDONCO2_INIT_WORDLENGTH,
    .Init.StopBits = MZ_ADDONCO2_INIT_STOPBITS,
    .Init.Parity = MZ_ADDONCO2_INIT_PARITY,
    .Init.Mode = MZ_ADDONCO2_INIT_MODE,
    .Init.HwFlowCtl = MZ_ADDONCO2_INIT_HWFLOWCTL,
    .Init.OverSampling = MZ_ADDONCO2_INIT_OVERSAMPLING,
    .Init.OneBitSampling = MZ_ADDONCO2_INIT_ONEBITSAMPLING,
    .AdvancedInit.AdvFeatureInit = MZ_ADDONCO2_ADVANCEDINIT_ADVFEATUREINIT
};
/* CO2 UART configuration structure - END */
 
/* CO2 UART related variables - START */
static volatile char co2_uart_recv_complete_flag = UART_RECEIVE_COMPLETE_CLEAR; 
/* CO2 UART related variables - END */
 
static void co2_lpuart1_rx_intr(void * arg)
{
    (void)arg;
 
    /* Set co2 sensor uart receive complete flag */
    co2_uart_recv_complete_flag = UART_RECEIVE_COMPLETE_SET;
}
/* CO2 UART related callback - END */
 
static mz_error_t co2_uart_init(void)
{
    /*
     * Register the lpuart1 receive complete callback using
     * MZ_UART_register_intr_cb_rx() API
     * When receive is completed on the lpuart interface,
     * the callback API co2_lpuart1_rx_intr() will be processed.
     */
    return MZ_UART_register_intr_cb_rx( MZ_ADDONCO2_UART_INSTANCE,
                                        co2_lpuart1_rx_intr);
 
    /*
     * Based on the Application requirement register a transmit callback using
     * MZ_UART_register_intr_cb_tx() API. Please refer MZ_uart.h for more
     * details.
     */
}
/* CO2 uart related initialization - END */
 
/*============================================================================*/
/* CO2 ADDON board - UART related code - END                                  */
/*============================================================================*/
 
/*============================================================================*/
/* CO2 ADDON board - Co2 sensor read and send to Lwm2m server - START         */
/*============================================================================*/
 
static void lwm2m_server_monitoring_timer_cb(TimerHandle_t xTimer)
{
    /* Check if observe has not started */
    if(OBSERVE_COMPLETE_CLEAR == observe_receive_flag)
    {
        /* Then set the server re-registration flag */
        lwm2m_server_rereg_flag = SERVER_REG_NEED_SET;
    }
}
/* LWM2M server registration monitoring timer callback - END */
 
static void co2_sensor_read_timer_cb(TimerHandle_t xTimer)
{
    /* Set the co2 sensor timer expire flag */
    co2_read_timer_expire_flag = CO2_READ_TIMER_EXPIRE_SET;
}
/* co2 sensor reading timer callback - END */
 
static void lwm2m_server_reregistration(void)
{
    /* Clear previous observe receive flag */
    observe_receive_flag = OBSERVE_COMPLETE_CLEAR;
 
    /* Starting the Lwm2m server monitoring one time timer */
    if(MZ_OK != mz_tm_start(lwm2m_server_monitoring_timer_id))
    {
        mz_puts("Server monitoring timer creation failed\r\n");
    }
 
    /* Initiate the server re-registration */
 
    if(MZ_OK == MZ_modem_config_set(mz_reboot_sequence))
    {
        /* print the success in the CLI */
        mz_puts("Server re-reg sequence started\r\n");
    }
    else
    {
        /* print the fail - It will be again tried on next timer expire */
        mz_puts("Server re-reg sequence failed\r\n");
    }
}
/* LWM2M server re-registration API - END */
 
static void create_lwm2m_payload(void)
{
    /*
     * As all the payload is just number, this is a optimized implementation
     * of converting the final value to ASCII HEX string
     */
    payload_string[0] = '\"';
    payload_string[1] = '3';
    payload_string[2] = '0' + (final_co2_value % 10000)/1000;
    payload_string[3] = '3';
    payload_string[4] = '0' + (final_co2_value % 1000)/100;
    payload_string[5] = '3';
    payload_string[6] = '0' + (final_co2_value % 100)/10;
    payload_string[7] = '3';
    payload_string[8] = '0' + final_co2_value % 10;
    payload_string[9] = '\"';
    payload_string[10] = '\0';
}
/* LWM2M Create payload API - END */
 
static void send_payload_to_server(void)
{
    /* Set the Object 19/0/0 Data and send the Notify request to MonoZ_Lib */
    mz_error_t status = mz_set_and_notify_Ob19_0_0(payload_string);
 
    /* Check the status of the request */
    if(MZ_OK == status)
    {
        /* print success on CLI */
        mz_puts("Notify send to MonoZ_Lib\r\n");
    }
    else
    {
        /* print of error string on CLI */
        mz_puts(mz_error_to_str(status));
    }
}
/* LWM2M send payload API - END */
 
static void process_resp23(void)
{
    /* Calculate the crc of received bytes in rsp23 */
    unsigned short crc16 = crc16MakeTableMethod(CRC16_INIT_REM,
                                                crc16Table,
                                                (unsigned char *)&resp23,
                                                sizeof(resp23)-3);
 
    /*
     * If calculated crc matches with received crc value,
     * data is not corrupted
     */
    if(resp23.crc == crc16)
    {
        /* Store the decimal place */
        decimal_place = resp23.dp;
 
        /* Clear the response buffer for next use. */
        memset(&resp23,0,sizeof(resp23));
 
        /*
         * Set the Uart in Interrupt Receiving mode,
         * set the receiving buffer as resp21
         */
        (void)MZ_UART_Receive_IT(   MZ_ADDONCO2_UART_INSTANCE,
                                    (uint8_t *)&resp21,
                                    sizeof(resp21));
        /* Send the Co2 sensor cmd21 */
        (void)MZ_UART_Transmit(     MZ_ADDONCO2_UART_INSTANCE,
                                    (uint8_t *)&cmd21,
                                    sizeof(cmd21),
                                    1000);
    }
}
/* CO2 sensor resp23 processing API - END */
 
static void process_resp21(void)
{
    /* Calculate the crc of received bytes in rsp21 */
    unsigned short crc16 = crc16MakeTableMethod(CRC16_INIT_REM,
                                                crc16Table,
                                                (unsigned char *)&resp21,
                                                sizeof(resp21)-3);
    /*
     * If calculated crc matches with received crc value,
     * data is not corrupted
     */
    if(resp21.crc == crc16)
    {
        /* Store the raw co2 value */
        final_co2_value = resp21.co2_raw;
 
        /* Clear the response buffer for next use. */
        memset(&resp21,0,sizeof(resp21));
 
        /* create final co2 sensor value from raw value and decimal place */
        while(decimal_place)
        {
            /* Divide 10 to the final value to reduce the decimal place */
            /* Refer to the co2 sensor datasheet for more information */
            final_co2_value = final_co2_value/10;
            decimal_place--;
        }
 
        /* Create the payload from the received data */
        create_lwm2m_payload();
        /* send the payload to lwm2m server */
        send_payload_to_server();
    }
}
/* CO2 sensor resp21 processing API - END */
 
static void co2_app_thread(void * arg)
{
    (void)arg;
 
    /*
     * create the Lwm2m server monitoring timer.
     * As per requirement, We are creating a One-time timer using
     * mz_tm_create_one() API.
     * In-case of other type of timer, please refer MZ_timer.h
     * The expire time for this timer set to LWM2M_SERVER_MONITORING_TIME.
     * "lwm2m_server_monitoring_timer_cb" is passed as an argument.
     * When the timer expires, the "lwm2m_server_monitoring_timer_cb" API will
     * be processed.
     * Also store the timer id for future use, to restart the timer
     */
    lwm2m_server_monitoring_timer_id =
            mz_tm_create_one("Server monitoring timer",
                            LWM2M_SERVER_MONITORING_TIME,
                            lwm2m_server_monitoring_timer_cb);
    /*
     * Starting the Lwm2m server monitoring timer.
     * The response of the API is ignored assuming it is started correctly
     * without error.
     * In-case needed please do error management for this API.
     */
    (void)mz_tm_start(lwm2m_server_monitoring_timer_id);
 
    /* Print on the console about timer start */
    mz_puts("Server monitoring timer started\r\n");
 
    /*
     * create the co2 sensor reading timer.
     * As per requirement, We are creating a recursive timer using
     * mz_tm_create_start_recursive() API.
     * In-case of other type of timer, please refer MZ_timer.h
     * The expire time for this timer set to CO2_SENSOR_READ_TIME.
     * "co2_sensor_read_timer_cb" is passed as an argument.
     * When the timer expires, the "co2_sensor_read_timer_cb" API will be
     * processed.
     */
    if(MZ_OK == mz_tm_create_start_recursive("Uart Read timer",
                                            CO2_SENSOR_READ_TIME,
                                            co2_sensor_read_timer_cb))
    {
        mz_puts("co2 sensor reading timer started\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 */
 
        /*
         * Process the server re-registration based on registration required or
         * not status - Check if the flag is set
         */
        if(SERVER_REG_NEED_SET == lwm2m_server_rereg_flag)
        {
            /* clear the server re-registration flag */
            lwm2m_server_rereg_flag = SERVER_REG_NEED_CLEAR;
 
            /* Perform lwm2m server re-registration */
            lwm2m_server_reregistration();
        }
 
        /* Process the received co2 sensor data if uart receive has completed */
        if(UART_RECEIVE_COMPLETE_SET == co2_uart_recv_complete_flag)
        {
            /* clear the co2 uart receive flag */
            co2_uart_recv_complete_flag = UART_RECEIVE_COMPLETE_CLEAR;
 
            /* Check if the response for cmd23 is received */
            if(CO2_CMD_ID_23 == resp23.cmd)
            {
                process_resp23();
            }
 
            /* Check if the response for cmd23 is received */
            if(CO2_CMD_ID_21 == resp21.cmd)
            {
                process_resp21();
            }
        }
 
        /* Check if co2 sensor read timer expired */
        if(CO2_READ_TIMER_EXPIRE_SET == co2_read_timer_expire_flag)
        {
            /* Process the co2 sensor read timer expire event */
 
            /*
             * Set the Uart in Interrupt Receiving mode,
             * set the receiving buffer as resp23
             */
            (void)MZ_UART_Receive_IT(   MZ_ADDONCO2_UART_INSTANCE,
                                        (uint8_t *)&resp23,
                                        sizeof(resp23));
 
            /* Send the Co2 sensor cmd23 */
            (void)MZ_UART_Transmit(     MZ_ADDONCO2_UART_INSTANCE,
                                        (uint8_t *)&cmd23,
                                        sizeof(cmd23),
                                        1000);
 
            /* clear the flag after processing */
            co2_read_timer_expire_flag = CO2_READ_TIMER_EXPIRE_CLEAR;
        }
 
        /* Put a delay to avoid blocking on this thread */
        HAL_Delay(10);
 
 
    }//End of while(1) - Do not place any code after this.
 
}
/* CO2 main Application thread. - END */
 
/*
 * CO2 Application initialization API. - START
 *
 * 1. It call all necessary initializations before application start
 * 2. It create the main co2 application
 * 3. It set all variables to its initialization states
 */
mz_error_t co2_app_init(void)
{
    mz_error_t _ret = MZ_OK;
 
    /* Clear Response buffers of co2 */
    memset(&resp23,0,sizeof(resp23));
    memset(&resp21,0,sizeof(resp21));
 
    /* Initialize co2 uart related functions */
    _ret = co2_uart_init();
    if(MZ_OK != _ret) goto clean;
 
    /* Create the Co2 application thread */
    if(!mz_thread_create(   &co2_thread_id,
                            "co2 Scheduler",
                            co2_app_thread,
                            NULL,
                            osPriorityNormal,
                            co2_stack,
                            CO2_APP_STACK_SIZE,
                            &co2_cb_mem,
                            sizeof(co2_cb_mem)))
    {
        _ret = MZ_THREAD_CREATE_FAIL;
    }
 
    /*
     * 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;
}
/* CO2 Application initialization API. - END */
 
/*============================================================================*/
/* CO2 ADDON board - Co2 sensor read and send to Lwm2m server - END           */
/*============================================================================*/
 
/*============================================================================*/
/* CO2 ADDON board - LWM2M event related code - START                         */
/*============================================================================*/
void lwm2m_event_process(void * event)
{
    st_lw_event * e = event;
 
    /* Check post-processing events is send by MonoZ_Lib to user */
    switch(e->lw_event)
    {
        /*
         * 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");
            /* Check if observe is started for target Object and resource */
            if(e->lw_Obj_id == 19 && e->lw_Obj_Ins_id == 0 && e->lw_Res_id == 0)
            {
                /* Set the observed received flag */
                observe_receive_flag = OBSERVE_COMPLETE_SET;
            }
        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;
        case LW_EV_CLIENT_OFF:
            /* Set server re-registration flag when received client off */
            lwm2m_server_rereg_flag = SERVER_REG_NEED_SET;
        break;
 
#if 0
        /* Some other sample cases */
        case LW_EV_WRITE_DATA:
            /* Do something */
            ;
        break;
        case LW_EV_EXECUTE:
            /* Do something */
            ;
        break;
        case LW_EV_READ:
            /* Do something */
            ;
        break;
        case LW_EV_OBSERVE_CANCEL:
            /* Do something */
            ;
        break;
#endif
 
        default:
        break;
    }
}
/*============================================================================*/
/* CO2 ADDON board - LWM2M event related code - END                           */
/*============================================================================*/
 
/*============================================================================*/
/* CO2 ADDON board - CRC related code - START                                 */
/*============================================================================*/
 
/* CRC table - START */
/*
 *  CRC calculation used in validation of CO2 sensor data.
 *  This information is used directly as it is from the CO2 sensor datasheet.
 *  Please refer the datasheet for more detail information
 */
const unsigned short crc16Table[CRC_TABLE_SIZE] = {
    0x0000, 0x8005, 0x800F, 0x000A,
    0x801B, 0x001E, 0x0014, 0x8011,
    0x8033, 0x0036, 0x003C, 0x8039,
    0x0028, 0x802D, 0x8027, 0x0022,
    0x8063, 0x0066, 0x006C, 0x8069,
    0x0078, 0x807D, 0x8077, 0x0072,
    0x0050, 0x8055, 0x805F, 0x005A,
    0x804B, 0x004E, 0x0044, 0x8041,
    0x80C3, 0x00C6, 0x00CC, 0x80C9,
    0x00D8, 0x80DD, 0x80D7, 0x00D2,
    0x00F0, 0x80F5, 0x80FF, 0x00FA,
    0x80EB, 0x00EE, 0x00E4, 0x80E1,
    0x00A0, 0x80A5, 0x80AF, 0x00AA,
    0x80BB, 0x00BE, 0x00B4, 0x80B1,
    0x8093, 0x0096, 0x009C, 0x8099,
    0x0088, 0x808D, 0x8087, 0x0082,
    0x8183, 0x0186, 0x018C, 0x8189,
    0x0198, 0x819D, 0x8197, 0x0192,
    0x01B0, 0x81B5, 0x81BF, 0x01BA,
    0x81AB, 0x01AE, 0x01A4, 0x81A1,
    0x01E0, 0x81E5, 0x81EF, 0x01EA,
    0x81FB, 0x01FE, 0x01F4, 0x81F1,
    0x81D3, 0x01D6, 0x01DC, 0x81D9,
    0x01C8, 0x81CD, 0x81C7, 0x01C2,
    0x0140, 0x8145, 0x814F, 0x014A,
    0x815B, 0x015E, 0x0154, 0x8151,
    0x8173, 0x0176, 0x017C, 0x8179,
    0x0168, 0x816D, 0x8167, 0x0162,
    0x8123, 0x0126, 0x012C, 0x8129,
    0x0138, 0x813D, 0x8137, 0x0132,
    0x0110, 0x8115, 0x811F, 0x011A,
    0x810B, 0x010E, 0x0104, 0x8101,
    0x8303, 0x0306, 0x030C, 0x8309,
    0x0318, 0x831D, 0x8317, 0x0312,
    0x0330, 0x8335, 0x833F, 0x033A,
    0x832B, 0x032E, 0x0324, 0x8321,
    0x0360, 0x8365, 0x836F, 0x036A,
    0x837B, 0x037E, 0x0374, 0x8371,
    0x8353, 0x0356, 0x035C, 0x8359,
    0x0348, 0x834D, 0x8347, 0x0342,
    0x03C0, 0x83C5, 0x83CF, 0x03CA,
    0x83DB, 0x03DE, 0x03D4, 0x83D1,
    0x83F3, 0x03F6, 0x03FC, 0x83F9,
    0x03E8, 0x83ED, 0x83E7, 0x03E2,
    0x83A3, 0x03A6, 0x03AC, 0x83A9,
    0x03B8, 0x83BD, 0x83B7, 0x03B2,
    0x0390, 0x8395, 0x839F, 0x039A,
    0x838B, 0x038E, 0x0384, 0x8381,
    0x0280, 0x8285, 0x828F, 0x028A,
    0x829B, 0x029E, 0x0294, 0x8291,
    0x82B3, 0x02B6, 0x02BC, 0x82B9,
    0x02A8, 0x82AD, 0x82A7, 0x02A2,
    0x82E3, 0x02E6, 0x02EC, 0x82E9,
    0x02F8, 0x82FD, 0x82F7, 0x02F2,
    0x02D0, 0x82D5, 0x82DF, 0x02DA,
    0x82CB, 0x02CE, 0x02C4, 0x82C1,
    0x8243, 0x0246, 0x024C, 0x8249,
    0x0258, 0x825D, 0x8257, 0x0252,
    0x0270, 0x8275, 0x827F, 0x027A,
    0x826B, 0x026E, 0x0264, 0x8261,
    0x0220, 0x8225, 0x822F, 0x022A,
    0x823B, 0x023E, 0x0234, 0x8231,
    0x8213, 0x0216, 0x021C, 0x8219,
    0x0208, 0x820D, 0x8207, 0x0202
};
/* CRC table - END */
 
/* CRC method - START */
static unsigned short crc16MakeTableMethod( unsigned short crc,
                                            const unsigned short *table,
                                            unsigned char *pbuffer,
                                            unsigned int length)
{
    while(length--)
    {
        crc = table[((crc >> 8) ^ *pbuffer++)] ^ (crc << 8); // normal
    }
    return(crc ^ CRC16_FINAL_XOR);
}
 
/* CRC method - END */
 
/*============================================================================*/
/* CO2 ADDON board - CRC related code - END                                   */
/*============================================================================*/