Программный модуль для утюга RI-C254S. Версия 1.0
ПО является неотъемлемой частью утюга RI-C254S, отдельно потребителю не поставляется и эксплуатируется только в составе устройства.
Фрагмент исходного кода
////////////////////////////////////////////////////////////////
//RI-C254S
//v1.0
//application.c
////////////////////////////////////////////////////////////////
/********* HEADER FILE INCLUDES *******************************************/
#include <stdint.h>
#include <stdlib.h>
#include "math.h"
#include "nrf.h"
#include "nrf_delay.h"
#include "nrf_gpio.h"
#include "app_error.h"
#include "nrf_soc.h"
#include "app_util_platform.h"
#include "r4s.h"
#include "r4s_app_flash.h"
#include "led.h"
#include "led_config.h"
#include "buz.h"
#include "buz_config.h"
#include "timers.h"
#include "timers_config.h"
#include "sw200d.h"
#include "sw200d_config.h"
#include "indication.h"
#include "hal.h"
#include "config.h"
#include "application.h"
#include "application_api.h"
/********* DEFINES ********************************************************/
#define FLAGS_OFFSET 0
#define BLOCK_FLAG_PAGE R4S_APP_PAGE_0
#define MAN_UNBLOCK_FLAG_PAGE R4S_APP_PAGE_1
/********* MACROS *********************************************************/
/********* GLOBAL VARIABLES ***********************************************/
/********* LOCAL VARIABLES ************************************************/
/***************************************************************************
* System variables
**************************************************************************/
/*static*/ app_state_t app_state = APP_START; /* текущее состояние */
static app_state_t app_prew_state = APP_START; /* предыдущее состояние */
/*static*/ app_orient_t app_orient = APP_ORIENT_HORIZONTAL; /* ориентация устройства*/
static sw200d_data_t sen_1 = {}; /* состояние первого датчика */
static sw200d_data_t sen_2 = {}; /* состояние второго датчика */
static uint32_t err_code = NRF_SUCCESS; /* код ошибки */
static uint8_t app_pairing_cnt = 0; /* счетчик пэйринга; по нему происходит выход из состояния пэйринга */
static uint8_t beep_count = 0; /* количество сигналов бузера в очереди на выполнение */
static uint8_t app_block_state_ind_cnt = 0;/* счетчик индикации состояния блокировки */
/***************************************************************************
* FLAGS
**************************************************************************/
static bool app_orientation_changed_flag; /* флаг изменения ориентации устройства */
static bool app_timeout_flag; /* флаг таймаута, используется для перехода между состояниями или индикации внутри состояния */
static bool app_pairing_flag; /* флаг пэйринга */
static bool app_unpairing_flag; /* флаг анпэйринга */
static bool app_block_flag; /* флаг блокировки, если установлен - запрещен переход в состояние APP_WORK (временный флаг приложения) */
static bool app_man_unblock_flag; /* флаг ручного отключения блокировки */
/********* FUNCTION PROTOTYPES ********************************************/
/********* FUNCTIONS IMPLEMENTATION ***************************************/
/***************************************************************************
* System callbacks
**************************************************************************/
/**
* @brief По нему происходит переход между состониями или работа внутри
* состояний. Устанавливается флаг app_timeout_flag. Время
* вызова зависит от состояния.
*
* @param none
* @return none
*/
static void app_timeout_callback(void)
{
app_timeout_flag = true;
err_code = timer_stop(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
}
/**
* @brief По нему устанавливается флаг перехода в состояния пэйринга.
* Вызов происходит если продержать утюг в положении
* "APP_ORIENT_VERTICAL_DOWN" втечение 5 секунд.
*
* @param none
* @return none
*/
static void app_pairing_callback(void)
{
app_pairing_flag = true;
err_code = timer_stop(TIMERS_APP_PAIRING);
APP_ERROR_CHECK(err_code);
}
/**
* @brief По нему происходит анпэйринг. Вызывается если продержать
* утюг в положение "APP_ORIENT_UNSIDE_DOWN" втечение 10 секунд
*
* @param none
* @return none
*/
static void app_unpairing_callback(void)
{
app_unpairing_flag = true;
err_code = timer_stop(TIMERS_APP_UNPAIRING);
APP_ERROR_CHECK(err_code);
}
/**
* @brief По нему устанавливается флаг о снятии блокировки. По этому
* флагу в память записывается байт, который будет прочитан при
* включении утюга.
*
* @param none
* @return none
*/
static void app_man_unblock_callback(void)
{
app_man_unblock_flag = true;
err_code = timer_stop(TIMERS_APP_MAN_UNBLOCK);
APP_ERROR_CHECK(err_code);
}
/***************************************************************************
* Applivation init
**************************************************************************/
/**
* @brief Инициализация приложения. Инициализируется железо,
* создаются необходимые таймеры, проверяется флаг о ручном снятии
* блокировки.
*
* @param none
* @return none
*/
void application_init( void )
{
/* Инициазация железа */
err_code = hal_hw_init();
APP_ERROR_CHECK(err_code);
/* Инициализация модуля индикации */
err_code = indication_init();
APP_ERROR_CHECK(err_code);
/* Таймер таймаута */
err_code = timer_create(TIMERS_APP_TIMEOUT,
TIMERS_MILLISECOND(10),
(callback_t)app_timeout_callback);
APP_ERROR_CHECK(err_code);
/* Таймер пэйринга */
err_code = timer_create(TIMERS_APP_PAIRING,
TIMERS_SECOND(5),
(callback_t)app_pairing_callback);
APP_ERROR_CHECK(err_code);
/* Таймер анпэйринга */
err_code = timer_create(TIMERS_APP_UNPAIRING,
TIMERS_SECOND(10),
(callback_t)app_unpairing_callback);
APP_ERROR_CHECK(err_code);
/* Таймер ручного отключени блокировки */
err_code = timer_create(TIMERS_APP_MAN_UNBLOCK,
TIMERS_SECOND(5),
(callback_t)app_man_unblock_callback);
APP_ERROR_CHECK(err_code);
/* Считываем из памяти флаг ручного снятия блокировки */
uint32_t unblock_flag_value;
err_code = r4s_app_flash_read( MAN_UNBLOCK_FLAG_PAGE,
FLAGS_OFFSET,
(uint8_t *)&unblock_flag_value,
sizeof(unblock_flag_value));
APP_ERROR_CHECK(err_code);
/* Если Флаг установлен */
if( unblock_flag_value == 1)
{
/* Стираем флаг блокировки */
err_code = r4s_app_flash_erase(BLOCK_FLAG_PAGE);
APP_ERROR_CHECK(err_code);
/* Стираем флаг ручного отключения блокировки */
err_code = r4s_app_flash_erase(MAN_UNBLOCK_FLAG_PAGE);
APP_ERROR_CHECK(err_code);
/* снимаем флаг блокировки (временный флаг приложения) */
app_block_flag = false;
}
else /* Если флаг ручного отключения не установлен */
{
/* Считываем флаг блокировки из памяти */
uint32_t block_flag;
err_code = r4s_app_flash_read( BLOCK_FLAG_PAGE,
FLAGS_OFFSET,
(uint8_t *)&block_flag,
sizeof(block_flag));
APP_ERROR_CHECK(err_code);
/* Устанавливаем временный флаг приложения */
(block_flag == 1 ) ? (app_block_flag = true) : (app_block_flag = false);
}
/* Пищим один раз */
err_code = buz_add_beep(500,1,BUZ_BEEP_MULTI);
APP_ERROR_CHECK(err_code);
/* Моргаем светодиодом один раз */
indication_led_blink(1000, 1);
/* считываем показания датчиков положения */
err_code = sw200d_read_data(SW200D_S1, &sen_1);
APP_ERROR_CHECK(err_code);
err_code = sw200d_read_data(SW200D_S2, &sen_2);
APP_ERROR_CHECK(err_code);
/* Считываем показания датчиков для определения текущего положения */
app_orient = (app_orient_t)(( sen_1.state << 1 ) | ( sen_2.state ));
}
/***************************************************************************
* Функ
**************************************************************************/
/**@brief Функция выполняет работу при входе в новое состояние
*
* @param none
*
* @return none
*/
void application_init_new_state( app_state_t app_new_state )
{
/* если перехода не было выходим из функции */
if( app_prew_state == app_new_state )return;
switch( app_new_state )
{
case APP_START:
break;
case APP_STAND_BY:
{
/* При переходе в состони APP_STAND_BY перезапускаем таймер таймаута
* TIMERS_APP_TIMEOUT с временем срабатывания 1 сек. По нему будет
* отображаться индикация состояния ( моргать 1 раз в сек ) */
err_code = timer_write_period(TIMERS_APP_TIMEOUT,
TIMERS_SECOND(1));
APP_ERROR_CHECK(err_code);
err_code = timer_reset(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
/* Отключаем нагреватель */
relay_off();
break;
}
case APP_WORK:
{
/* При переходе в состояние работы APP_WORK останавливаем любую
* световую индикацию. */
indication_led_blink_stop();
led_write_data(LED_INDEX_1, 0);
timer_stop(TIMERS_APP_TIMEOUT);
/* Включаем нагреватель */
relay_on();
app_orientation_changed_flag = true;
}
break;
case APP_PAIRING_STATE:
{
/* При переходе в состояние пэйринга APP_PAIRING_STATE
* выключаем нагреватель */
relay_off();
/* Перезапускаем таймер таймаута. По нему отображается индикация
* состояния пэйринга (моргать 1 раз в секунду ) */
err_code = timer_write_period(TIMERS_APP_TIMEOUT,
TIMERS_SECOND(1));
APP_ERROR_CHECK(err_code);
err_code = timer_reset(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
/* Сбрасываем счетчик пэйринга. Когда счетчик станет равным 10
* произойдет выход из состояния пэйринга. */
app_pairing_cnt = 0;
break;
}
default:
{
break;
}
}
app_prew_state = app_new_state;
return;
}
/**@brief Функция выполняет работу при выходе из соответствующего состояния
*
* @param none
*
* @return none
*/
void application_deinit_prew_state( app_state_t app_new_state )
{
if( app_prew_state == app_new_state )return;
switch( app_prew_state )
{
case APP_START:
break;
case APP_STAND_BY:
{
break;
}
case APP_WORK: // при выходе из APP_WORK
{
}
break;
default:
{
break;
}
}
return;
}
/***************************************************************************
* Application process.
**************************************************************************/
/**
* @brief Функция выполняется основную работу приложения.
*
* @param none
* @return none
*/
void application_process( void )
{
application_init_new_state( app_state );
/* Считываем количество писков в очереди */
err_code = buz_get_beep_count(&beep_count);
APP_ERROR_CHECK(err_code);
/* если очередь писков не пуста запрещаем опрос датчиков положения */
if( beep_count != 0 )
{
err_code = sw200d_lock_set(SW200D_LOCK);
APP_ERROR_CHECK(err_code);
}
else
{ /* Если пуста разрешаем опрос датчиков положения */
err_code = sw200d_lock_set(SW200D_UNLOCK);
APP_ERROR_CHECK(err_code);
}
/* считываем показания датчиков положения */
err_code = sw200d_read_data(SW200D_S1, &sen_1);
APP_ERROR_CHECK(err_code);
err_code = sw200d_read_data(SW200D_S2, &sen_2);
APP_ERROR_CHECK(err_code);
/* Если на датчиках было зафиксировано событие */
if( sen_1.event_close == SW200D_EVENT_CAPTURED ||
sen_1.event_open == SW200D_EVENT_CAPTURED ||
sen_2.event_close == SW200D_EVENT_CAPTURED ||
sen_2.event_open == SW200D_EVENT_CAPTURED )
{
/* Считываем показания датчиков */
app_orient = (app_orient_t)(( sen_1.state << 1 ) | ( sen_2.state ));
/* устанавливаем флаг, извещающий приложение о изменении положения */
app_orientation_changed_flag = true;
/* останавливаем таймеры пэйринга, анпэйринга и ручного
* отключения блокировки */
err_code = timer_stop(TIMERS_APP_PAIRING);
APP_ERROR_CHECK(err_code);
err_code = timer_stop(TIMERS_APP_UNPAIRING);
APP_ERROR_CHECK(err_code);
err_code = timer_stop(TIMERS_APP_MAN_UNBLOCK);
APP_ERROR_CHECK(err_code);
}
/* Если установлен флаг ручного отключения блокировки */
if( app_man_unblock_flag )
{
uint32_t set_flag = 1;
/* Издаем короткий писк */
indication_buz_multi(1000, 1);
/* Записываем флаг в память */
err_code = r4s_app_flash_write( MAN_UNBLOCK_FLAG_PAGE,
FLAGS_OFFSET,
(uint8_t *)&set_flag,
sizeof(set_flag));
/* Стираем временный флаг приложения */
app_man_unblock_flag = false;
}
/* Если был установле флаг пэйринга */
if( app_pairing_flag )
{
app_pairing_flag = false; /* стираем флаг */
indication_buz_multi(200,3); /* пищим коротко 3 раза */
app_state = APP_PAIRING_STATE; /* переходим в состояние пэйринга */
}
/* Машина состояний */
switch(app_state)
{
case APP_START:
{
app_state = APP_STAND_BY;
}
break;
/* состояние выкл */
case APP_STAND_BY:
{
/* Т.к. после переворота утюга в положение "APP_ORIENT_UPSIDE_DOWN"
* через секунду утсройство должно перейти в состояние выкл, то
* и проверка флага анпэйриннга происходит здесь, в то время
* как таймер, устанавливающий флаг, запускается в состоянии
* APP_WORk */
if( app_unpairing_flag )
{
}
/* По таймауту запускаем индикацию состояния */
if( app_timeout_flag )
{
/* если включена блокировка моргаем 2 раза с
* интервалом 3 секунды */
if( app_block_flag)
{
if( ++app_block_state_ind_cnt > 3)
{
app_block_state_ind_cnt = 0;
indication_led_blink(500,2);
}
err_code = timer_start(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
}
else
{
/* Если нет блокировки моргаем 1 раз в секунду */
indication_led_blink(1000,1);
err_code = timer_start(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
}
app_timeout_flag = false;
}
/* если не было изменения состояния выходим из машины состояний */
if( !app_orientation_changed_flag )break;
/* Если было изменеие состояния запускаем таймеры пэйринга,
* анпэйринга и ручного отключения блокировки */
switch( app_orient )
{
case APP_ORIENT_VERTICAL_DOWN:
{
err_code = timer_reset(TIMERS_APP_PAIRING);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_PAIRING);
APP_ERROR_CHECK(err_code);
}
break;
case APP_ORIENT_UPSIDE_DOWN:
{
err_code = timer_reset(TIMERS_APP_UNPAIRING);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_UNPAIRING);
APP_ERROR_CHECK(err_code);
err_code = timer_reset(TIMERS_APP_MAN_UNBLOCK);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_MAN_UNBLOCK);
APP_ERROR_CHECK(err_code);
}
break;
default:
break;
}
/* Если устройство не заблокировано, переходим в режим работы */
if( !app_block_flag ) app_state = APP_WORK;
}
break;
/* Состояние вкл */
case APP_WORK:
{
/* Если сработал таймаут ( автоотключение ) - переходим
* в режим выкл */
if( app_timeout_flag )
{
app_state = APP_STAND_BY;
app_timeout_flag = false;
/* Не пищим если автоотключение произошло в положении
* APP_ORIENT_UPSIDE_DOWN */
if( app_orient != APP_ORIENT_UPSIDE_DOWN )
{
err_code = buz_add_beep(500,1,BUZ_BEEP_MULTI);
APP_ERROR_CHECK(err_code);
}
}
/* Если не было инзменения положения выходим из машины состояний */
if( !app_orientation_changed_flag )break;
/* Включаем реле, т.к. оно могло быть выключено при переходе
* в состояние APP_ORIENT_UPSIDE_DOWN */
relay_on();
/* Если было инзменение положения, запускаем таймеры автоотключения,
* пэйринга, анпэйринга и ручного отключения блокировки
* соответсвенно */
switch( app_orient )
{
case APP_ORIENT_HORIZONTAL:
{
err_code = timer_write_period(TIMERS_APP_TIMEOUT,
TIMERS_SECOND(30));
APP_ERROR_CHECK(err_code);
err_code = timer_reset(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
}
break;
case APP_ORIENT_VERTICAL_UP:
{
err_code = timer_write_period(TIMERS_APP_TIMEOUT,
TIMERS_MINUTE(8));
APP_ERROR_CHECK(err_code);
err_code = timer_reset(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
}
break;
case APP_ORIENT_VERTICAL_DOWN:
{
err_code = timer_write_period(TIMERS_APP_TIMEOUT,
TIMERS_SECOND(30));
APP_ERROR_CHECK(err_code);
err_code = timer_reset(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
err_code = timer_reset(TIMERS_APP_PAIRING);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_PAIRING);
APP_ERROR_CHECK(err_code);
}
break;
case APP_ORIENT_UPSIDE_DOWN:
{
err_code = timer_write_period(TIMERS_APP_TIMEOUT,
TIMERS_SECOND(1));
APP_ERROR_CHECK(err_code);
err_code = timer_reset(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
err_code = timer_reset(TIMERS_APP_UNPAIRING);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_UNPAIRING);
APP_ERROR_CHECK(err_code);
err_code = timer_reset(TIMERS_APP_MAN_UNBLOCK);
APP_ERROR_CHECK(err_code);
err_code = timer_start(TIMERS_APP_MAN_UNBLOCK);
APP_ERROR_CHECK(err_code);
}
break;
default:
break;
}
break;
}
/* Состояние пэйринга */
case APP_PAIRING_STATE:
{
/* По таймауту индицируем состояние - моргаем 1 раз
* в секунду как в режиме APP_STAND_BY */
if( app_timeout_flag )
{
indication_led_blink(1000,1);
err_code = timer_start(TIMERS_APP_TIMEOUT);
APP_ERROR_CHECK(err_code);
app_timeout_flag = false;
/* Заходя сюда раз в секунду увелививаем счетчик на 1. когда
* он станет равным 10 выходим из состояния пэйринга, т.к.
* длительность пэйринга 10 сек */
if( ++app_pairing_cnt > 10 ) app_state = APP_STAND_BY;
}
break;
}
default:
{
app_state = APP_STAND_BY;
break;
}
}
application_deinit_prew_state( app_state );
app_orientation_changed_flag = false;
return;
}
/***************************************************************************
* API функции используемые для усправления устройством со смартфона
**************************************************************************/
/**
* @brief Получить ориентацию утюга.
*
* @param none
* @return uint8_t положение:
* 0 - горизонтальное
* 1 - носиком вверх
* 2 - носиком вниз
* 3 - перевернутое
*/
uint8_t api_get_orientation(void)
{
uint8_t ret_val = 0;
switch( app_orient )
{
case APP_ORIENT_HORIZONTAL:
ret_val = 0;
break;
case APP_ORIENT_VERTICAL_UP:
ret_val = 1;
break;
case APP_ORIENT_VERTICAL_DOWN:
ret_val = 2;
break;
case APP_ORIENT_UPSIDE_DOWN:
ret_val = 3;
break;
default:
ret_val = 0;
break;
}
return ret_val;
}
/**
* @brief Выключить утюг
*
* @param none
* @return true всегда
*/
bool api_stop(void)
{
app_state = APP_STAND_BY;
err_code = buz_add_beep(500,1,BUZ_BEEP_MULTI);
APP_ERROR_CHECK(err_code);
return true;
}
/**
* @brief Получить блокировку
*
* @param none
* @return uint8_t 0 - выкл
* 1 - вкл.
*/
uint8_t api_get_block(void)
{
uint32_t block_en;
uint8_t ret_val = 0;
err_code = r4s_app_flash_read( R4S_APP_PAGE_0,
FLAGS_OFFSET,
(uint8_t *)&block_en,
sizeof(block_en));
APP_ERROR_CHECK(err_code);
(block_en == 1) ? (ret_val = 1) : (ret_val = 0);
return ret_val;
}
/**
* @brief Вкл/выкл блокировку.
*
* @param uint8_t 0 - выкл
* 1 - вкл
* @return false - если block_en != [0,1]
* true - во всех остальных случаях
*/
bool api_set_block(uint8_t block_en)
{
uint8_t block_flag = api_get_block();
if( block_en == 0 )
{
if( block_flag == 0 ) return true;
err_code = r4s_app_flash_erase(BLOCK_FLAG_PAGE);
APP_ERROR_CHECK(err_code);
}
else if( block_en == 1)
{
if( block_flag == 1 ) return true;
uint32_t set_flag = 1;
err_code = r4s_app_flash_write( BLOCK_FLAG_PAGE,
FLAGS_OFFSET,
(uint8_t *)&set_flag,
sizeof(set_flag));
APP_ERROR_CHECK(err_code);
}
else
return false;
return true;
}
/***************************************************************************
* Сервисный API функции
**************************************************************************/
/**
* @brief Получить версию ПО
*
* @param none
*
* @return версия ПО. Формат HH.LL. HH - страший байт значениея 0-9, LL - младщий байт значениея 0-9.
*/
uint16_t api_get_version(void)
{
return FIRMWARE_VER;
}
/**
* @brief Получить состояние.
*
* @param none
*
* @return @ref app_orient_t
*/
uint8_t api_get_state(void)
{
return app_state;
}
/**
* @brief Получить флаг unpairing -а.
*
* @param none
*
* @return:: true - произвести unpairing
* false - не производить unpairing
*
*/
bool api_is_unpairing(void)
{
return app_unpairing_flag;
}
/**
* @brief Сбросить флаг unpairing -а. Т.к. эта функция вызывается
* библиотекой r4s_enc, то проверка флага внутри приложения
* (для выполнения действий) не целесообразна. Действия, выполняемые
* при анпэйринге перенесены сюда - стираение флага ручного
* отключения блокировки и звуковой сигнал
*
* @param none
*
* @return none
*
*/
void api_clr_unpairing(void)
{
/* Стираем из памяти флаг о ручном отключении блокировки,
* т.к. он устанавливается раньше, через 5 секунд нахождения
* в состоянии APP_ORIENT_UPSIDE_DOWN */
err_code = r4s_app_flash_erase(MAN_UNBLOCK_FLAG_PAGE);
APP_ERROR_CHECK(err_code);
/* Издаем длинный писк */
err_code = buz_add_beep(1000,1,BUZ_BEEP_MULTI);
APP_ERROR_CHECK(err_code);
app_unpairing_flag = 0;
return;
}
/**
* @brief Перевести устройство в режим APP_STAND_BY
*
* @param none
*
* @return none
*
*/
uint8_t api_go_to_stand_by(void)
{
app_state = APP_STAND_BY;
return 1;
}
/**
* @brief Получить ошибку
*
* @param none
*
* @return:: APP_API_NO_ERROR - нет ошибок
* APP_API_EXCEED_MAX_WEIGHT - превышен максимально допустимый вес
*/
uint8_t api_get_error(void)
{
return 0;
}
/***************************************************************************
*
***************************************************************************/
/**
* @brief Обработчик события установки соединения ( для приложения )
*
* @param none
* @return none
*/
void api_connect_handler(void)
{
app_block_flag = false;
}
/**
* @brief Обработчик события разрыва соединеня ( для приложения )
*
* @param none
* @return none
*/
void api_disconnect_handler(void)
{
uint8_t block_en = api_get_block();
if( block_en == 1 )
{
app_state = APP_STAND_BY;
app_block_flag = true;
}
}
/********* END OF FILE ****************************************************/
