Программный модуль для обогревателя RFH-C4519S
ПО является неотъемлемой частью обогревателя RFH-C4519S, отдельно потребителю не поставляется и эксплуатируется только в составе устройства.
Фрагмент исходного кода
////////////////////////////////////////////////////////////////
//RFH-C4519S
//v1.8
//logic.c
////////////////////////////////////////////////////////////////
#include "logic.h"
#include "scheme.h"
#include "ind_key_i2c.h"
#include "buzzer.h"
#include "heater.h"
#include "timer.h"
#include "hardware.h"
#include "ble_commands.h"
#include "ir.h"
/**
* Включение пищалки
*/
#define BEEP_LONG() {timer_init(TIMER_BEEP,50,cb_beep_off);timer_start(TIMER_BEEP);buzzer_start();}
#define BEEP() {timer_init(TIMER_BEEP,10,cb_beep_off);timer_start(TIMER_BEEP);buzzer_start();}
//#define BEEP_LONG() {}
//#define BEEP() {}
#define OUT_MIN ((uint32_t)(100*60))
#define OUT_HOUR ((uint32_t)(100*60*60))
static inline void logic_handler_timers(void);
static void cb_beep_off(uint32_t timer);
static void logic_cm(void);
static void logic_led_power_max(void);
static inline void logic_cm_lock_off(void);
static inline void logic_cm_lock_on(void);
//==============================================================================
static inline void logic_init_main_off(void);
static inline void logic_main_off(void);
static inline void logic_init_main_heat(void);
static inline void logic_main_heat(void);
static inline void logic_pwr_main_heat(void);
static inline void logic_pwr_main_heat_l(void);
static inline void logic_pwr_main_heat_h(void);
static inline void logic_tim_main_heat(void);
static inline void logic_tim_1h_main_heat(void);
static inline void logic_tim_2h_main_heat(void);
static inline void logic_tim_4h_main_heat(void);
static inline void logic_tim_off_main_heat(void);
static inline void logic_body_s_main_heat(void);
static inline void logic_body_s_main_heat_off(void);
static inline void logic_body_s_main_heat_on(void);
static inline void logic_sensor_heater(void);
static inline void logic_init_main_str_tim(void);
static inline void logic_main_str_tim(void);
static inline void logic_main_str_tim_go_heat(void);
static inline void logic_app_s_main_str_tim(void);
static inline void logic_main_str_tim_4h(void);
static inline void logic_main_str_tim_6h(void);
static inline void logic_main_str_tim_8h(void);
static inline void logic_pwr_main_str_tim(void);
static inline void logic_pwr_main_str_tim_heat_l(void);
static inline void logic_pwr_main_str_tim_heat_h(void);
static inline void logic_body_s_main_str_tim(void);
static inline void logic_body_s_main_str_tim_on(void);
static inline void logic_body_s_main_str_tim_off(void);
static inline void logic_tim_main_srt_tim(void);
static inline void logic_main_str_tim_tim_1h(void);
static inline void logic_main_str_tim_tim_2h(void);
static inline void logic_main_str_tim_tim_4h(void);
static inline void logic_main_str_tim_tim_off(void);
//==============================================================================
// test mode
#ifdef TEST_MODE
static void logic_test_mode(void);
#endif
//==============================================================================
/******* Структура общей работы обогревателя *******/
static struct logic_work logic_work_cm = { MAIN_OFF,
HEAT_ST_OFF,
TIM_OFF,
STR_TIM_OFF,
BODY_S_OFF,
LOCK_OFF };
/******* Структура общих параметров принимаемых от приложения ******/
static logic_ble_params lg_ble_params = {0,0,0,0,0,0,0,0,0};
void logic_init(void)
{
hardware_init();
ble_commands_init();
/**
* Таймера:
* - TIMER_LEDS_HANDLE
* -- таймер обработки светодиодов
* - TIMER_HW_UPDATE_HANDLE
* -- таймер обработки hardware
* - TIMER_BEEP (c коллбэком выключения)
* -- таймер обработки пищалки
*/
timer_init(TIMER_BUT_LEDS_HANDLE,1,0); // 20 ms
timer_start(TIMER_BUT_LEDS_HANDLE);
timer_init(TIMER_FAN_OFF,TIMER_SECOND(10),0);
timer_init(TIMER_HEAT_ON,TIMER_SECOND(10),0);
timer_init(TIMER_LED_POWER,TIMER_MINUTE(1),0);
timer_start(TIMER_LED_POWER);
timer_init(TIMER_PAIRING_TIMER,TIMER_SECOND(10),0); // 10 sec
timer_init(TIMER_UNPAIRING_TIMER,TIMER_SECOND(10),0);
timer_init(TIMER_PAIRING_LED,TIMER_SECOND(1),0);
timer_init(TIMER_12_HOUR,
#ifndef TEST_TIM_SMOL
TIMET_HOUR(12)
#else
TIMER_MINUTE(1)
#endif
,0);
timer_init(TIMER_BODY_S, /*TIMER_SECOND(20)*/TIMER_MINUTE(2),0);
timer_init(TIMER_SENSOR_FL, 2,0); // 20 ms
timer_start(TIMER_SENSOR_FL);
/**
* Код инициализации приложения
*/
heater_stop();
fan_stop();
logic_main_off();
#ifdef TEST_MODE
for(uint8_t i=0;i<5;i++){
ind_key_i2c_handler();
//ind_key_i2c_handler();
}
if(BUTT_BODY_S == ind_but_get())
{
logic_test_mode();
heater_stop();
fan_stop();
logic_main_off();
}
#endif
leds_change(LEDS_POWER, LEDS_YES);
BEEP();
timer_delay(20);
BEEP();
}
void logic_handler(void)
{
logic_handler_timers();
ble_commands_handle();
logic_cm();
}
static inline void logic_handler_timers(void)
{
/**
* Код обработчика таймеров
*/
if( timer_ready(TIMER_BUT_LEDS_HANDLE) ){
timer_ready_clr(TIMER_BUT_LEDS_HANDLE);
ind_key_i2c_handler();
}
if( timer_ready(TIMER_FAN_OFF) ){
timer_ready_clr(TIMER_FAN_OFF);
timer_stop(TIMER_FAN_OFF);
fan_stop();
}
if( timer_ready(TIMER_HEAT_ON) ){
timer_ready_clr(TIMER_HEAT_ON);
timer_stop(TIMER_HEAT_ON);
heater_start(HEAT_ON_HL);
}
if( timer_ready(TIMER_HEAT_WORK) ){
timer_ready_clr(TIMER_HEAT_WORK);
switch (logic_work_cm.work_tim)
{
case TIM_1H: logic_main_off(); break;
case TIM_2H: logic_tim_1h_main_heat(); break;
case TIM_4H: logic_tim_2h_main_heat(); break;
}
}
if( timer_ready(TIMER_STR_TIM) ){
timer_ready_clr(TIMER_STR_TIM);
switch (logic_work_cm.work_str_tim)
{
case STR_TIM_4H: logic_main_str_tim_go_heat(); break;
case STR_TIM_6H: logic_main_str_tim_4h(); break;
case STR_TIM_8H: logic_main_str_tim_6h(); break;
}
}
if( timer_ready(TIMER_BODY_S) ){
timer_ready_clr(TIMER_BODY_S);
timer_stop(TIMER_BODY_S);
// FAN off 10 c
timer_stop(TIMER_FAN_OFF);
timer_reset(TIMER_FAN_OFF);
timer_start(TIMER_FAN_OFF);
// HEAT off без сброса флагов
timer_stop(TIMER_HEAT_ON);
heater_stop();
leds_change(LEDS_SENSOR, LEDS_BL);
leds_change(LEDS_HOTE, LEDS_NO);
}
if( timer_ready(TIMER_12_HOUR) ){
timer_ready_clr(TIMER_12_HOUR);
timer_stop(TIMER_12_HOUR);
logic_main_off();
}
if( timer_ready(TIMER_SENSOR_FL) ){
timer_ready_clr(TIMER_SENSOR_FL);
//timer_stop(TIMER_SENSOR_FL);
heater_sensor_fl_handler();
}
if( timer_ready(TIMER_LED_POWER) ){ // Обработка таймера яркости диодов
timer_ready_clr(TIMER_LED_POWER);
timer_stop(TIMER_LED_POWER);
ind_led_min_max_power(1); // Переход на min led
}
/*=============== PAIRING ======================================================
RFH-C4519S
Пэринг (привязка устройства).
В выкл. состоянии нажать и удерживать кнопку "POWER" в течении 5 сек (до звукового сигнала).
Три коротких звуковых сигнала.
В течении 10 сек. (или до подключения устройства) попеременно моргают светодиоды "Low" и "High".
Анпэринг (отвязка всех устройств).
В выкл. состоянии нажать и удерживать кнопку "TIMER" в течении 10 сек (до звукового сигнала).
Один длинный звуковой сигнал.
==============================================================================*/
if( timer_ready(TIMER_PAIRING_TIMER) ){
timer_ready_clr(TIMER_PAIRING_TIMER);
timer_stop(TIMER_PAIRING_TIMER);
timer_reset(TIMER_PAIRING_TIMER);
if(ble_commads_get_name() == BLE_MODE_PARING_TEST){ // Если тест перинг не состоялся возвращаем название
ble_commands_disconnection_device();
timer_delay(10);
ble_commads_set_name(BLE_MODE_PARING_NORM);
}else{
leds_change(LEDS_HOTE, LEDS_NO);
timer_stop(TIMER_PAIRING_LED);
timer_reset(TIMER_PAIRING_LED);
}
ble_commands_pairing_stop();
}
if( timer_ready(TIMER_UNPAIRING_TIMER) ){
timer_ready_clr(TIMER_UNPAIRING_TIMER);
timer_stop(TIMER_UNPAIRING_TIMER);
timer_reset(TIMER_UNPAIRING_TIMER);
}
if( timer_active(TIMER_PAIRING_TIMER) > 0 ){
if(ble_commads_get_name() == BLE_MODE_PARING_NORM){
if(timer_ready(TIMER_PAIRING_LED) ){
timer_ready_clr(TIMER_PAIRING_LED);
if(leds_state(LEDS_HOTE) == LEDS_L) leds_change(LEDS_HOTE, LEDS_H);
else leds_change(LEDS_HOTE, LEDS_L);
timer_stop(TIMER_PAIRING_LED);
timer_reset(TIMER_PAIRING_LED);
timer_start(TIMER_PAIRING_LED);
}
}
if(ble_commands_get_pairing() == 0){ // Если пейринг остановился, то остановить таймер ожидания
//if(timer_active(TIMER_PAIRING_TIMER)){
if(ble_commads_get_name() == BLE_MODE_PARING_NORM) leds_change(LEDS_HOTE, LEDS_NO);
timer_stop(TIMER_PAIRING_TIMER);
timer_reset(TIMER_PAIRING_TIMER);
//ble_commands_pairing_stop();
//}
}
}
else if( timer_active(TIMER_UNPAIRING_TIMER) > 0 ){
}
else
{
if(ble_commads_get_name() == BLE_MODE_PARING_TEST){ // Если произошел дисконект тестового соединения
if(ble_state_disconnect_connected_device_test() == 0){
ble_commands_disconnection_device();
timer_delay(10);
ble_commads_set_name(BLE_MODE_PARING_NORM);
}
}
if(logic_work_cm.work_main == MAIN_OFF) // Если мы в состояние ожидания
{
static buttons_state_t but_paring;
but_paring = ind_but_get();
if(but_paring == BUTT_PARING) // Если нажата кнопка перинг
{
BEEP();
timer_delay(20);
BEEP();
timer_delay(20);
BEEP();
leds_change(LEDS_HOTE, LEDS_L);
ble_commands_pairing_start();
timer_start(TIMER_PAIRING_LED);
//timer_init(TIMER_PAIRING_TIMER,TIMER_SECOND(10),0); // 10 sec
timer_reset(TIMER_PAIRING_TIMER);
timer_start(TIMER_PAIRING_TIMER);
}
else if(but_paring == BUTT_UNPARING)
{
BEEP_LONG();
ble_commands_unpairing_init();
timer_reset(TIMER_UNPAIRING_TIMER);
timer_start(TIMER_UNPAIRING_TIMER);
}
else if(but_paring == BUTT_PARING_TEST) // Если нажата кнопка перинг_тест
{
if(ble_state_disconnect_connected_device_test() == 0){
ble_commands_disconnection_device();
timer_delay(10);
ble_commads_set_name(BLE_MODE_PARING_TEST); // Делаем подменну имени
BEEP();
ble_commands_pairing_start();
//timer_init(TIMER_PAIRING_TIMER,TIMER_SECOND(15),0); // 15 sec
timer_reset(TIMER_PAIRING_TIMER);
timer_start(TIMER_PAIRING_TIMER);
}
}
}
}
//================== END PAIRING ===============================================
}
/*==============================================================================
* bl start статус
==============================================================================*/
uint8_t* logic_status(uint8_t com)
{
static uint8_t logic_status_ble[10];
static uint32_t taim_read = 0;
if(lg_ble_params.fl_state == 1) // Если состояние ожидание старта
{
switch (com)
{
case BLE_COMMANDS_CMD_GET_STATE: logic_status_ble[0] = DEV_PROG; break; // Запрос общего состояния
case BLE_COMMANDS_CMD_GET_PRG_PARAM: // Запрос полного состояния
{
logic_status_ble[0] = lg_ble_params.programma;
logic_status_ble[1] = lg_ble_params.sensor;
logic_status_ble[2] = lg_ble_params.temper;
logic_status_ble[3] = lg_ble_params.h_taim_heat;
logic_status_ble[4] = lg_ble_params.m_taim_heat;
logic_status_ble[5] = lg_ble_params.h_taim_start;
logic_status_ble[6] = lg_ble_params.m_taim_start;
logic_status_ble[7] = lg_ble_params.lock;
logic_status_ble[8] = DEV_PROG;
break;
}
}
}
else // Если обогреватель работает или выключен
{
switch (com)
{
case BLE_COMMANDS_CMD_GET_STATE: // Запрос общего состояния
{
switch (logic_work_cm.work_main)
{
case MAIN_OFF: logic_status_ble[0] = DEV_OFF; break;
case MAIN_HEAT: logic_status_ble[0] = DEV_HEAT; break;
case MAIN_STR_TIM: logic_status_ble[0] = DEV_LOAD_START; break;
}
break;
}
case BLE_COMMANDS_CMD_GET_PRG_PARAM: // Запрос полного состояния
{
if(logic_work_cm.work_main == MAIN_OFF)
{
logic_status_ble[0] = 0; // Режим
logic_status_ble[3] = 0; // Время обогрева
}
else
{
if(logic_work_cm.work_heat == HEAT_ST_L) logic_status_ble[0] = 0; // Режим
else logic_status_ble[0] = 1;
if(logic_work_cm.work_tim == TIM_4H) logic_status_ble[3] = 4; // Время обогрева
else if(logic_work_cm.work_tim == TIM_OFF) logic_status_ble[3] = 12;
else logic_status_ble[3] = (uint8_t)logic_work_cm.work_tim;
}
logic_status_ble[1] = (uint8_t)logic_work_cm.work_boby_s; // Сенсор
if(logic_work_cm.work_boby_s == BODY_S_ON && logic_work_cm.work_main == MAIN_HEAT) // Если режим обогрева и включен сенсор
{
if(heater_get() == HEAT_OFF) logic_status_ble[2] = 1;
else logic_status_ble[2] = 0;
}
else logic_status_ble[2] = 0;
logic_status_ble[4] = 0;
switch (logic_work_cm.work_main) // Вывод оставшегося времение старта + готовки
{
case MAIN_OFF: logic_status_ble[5] = 0; logic_status_ble[6] = 0; break;
case MAIN_HEAT:
{
switch (logic_work_cm.work_tim)
{
case TIM_OFF:
{
taim_read = timer_get(TIMER_12_HOUR);
taim_read -= timer_read_taim(TIMER_12_HOUR);
logic_status_ble[5] = 0;
break;
}
case TIM_1H:
{
taim_read = timer_get(TIMER_HEAT_WORK);
taim_read -= timer_read_taim(TIMER_HEAT_WORK);
logic_status_ble[5] = 0;
break;
}
case TIM_2H:
{
taim_read = timer_get(TIMER_HEAT_WORK);
taim_read -= timer_read_taim(TIMER_HEAT_WORK);
logic_status_ble[5] = 1;
break;
}
case TIM_4H:
{
taim_read = timer_get(TIMER_HEAT_WORK);
taim_read -= timer_read_taim(TIMER_HEAT_WORK);
logic_status_ble[5] = 2;
break;
}
}
logic_status_ble[5] += (uint8_t)(taim_read / OUT_HOUR); // Часы
logic_status_ble[6] = (uint8_t)((taim_read % OUT_HOUR) / OUT_MIN); // Минуты
break;
}
case MAIN_STR_TIM:
{
taim_read = timer_get(TIMER_STR_TIM);
taim_read -= timer_read_taim(TIMER_STR_TIM);
logic_status_ble[5] = (uint8_t)(taim_read / OUT_HOUR); // Часы
logic_status_ble[6] = (uint8_t)((taim_read % OUT_HOUR) / OUT_MIN); // Минуты
switch (logic_work_cm.work_str_tim)
{
case STR_TIM_6H: logic_status_ble[5] += 4; break;
case STR_TIM_8H: logic_status_ble[5] += 6; break;
}
if(logic_work_cm.work_tim == TIM_4H) logic_status_ble[5] += 4;
else if(logic_work_cm.work_tim == TIM_OFF) logic_status_ble[5] += 12;
else logic_status_ble[5] += (uint8_t)logic_work_cm.work_tim;
break;
}
}
logic_status_ble[7] = (uint8_t)logic_work_cm.work_lock; // Lock
switch (logic_work_cm.work_main) // Статус команды
{
case MAIN_OFF: logic_status_ble[8] = DEV_OFF; break;
case MAIN_HEAT: logic_status_ble[8] = DEV_HEAT; break;
case MAIN_STR_TIM: logic_status_ble[8] = DEV_LOAD_START; break;
}
}
}
}
return ((uint8_t*)logic_status_ble);
}
/*==============================================================================
* Дополнительные команды c параметрами от приложения
==============================================================================*/
uint8_t logic_set_params(uint8_t com, uint8_t * params)
{
switch (com)
{
case BLE_COMMANDS_CMD_SET_PRG_PARAM: // Запись всех параметров
{
lg_ble_params.fl_state = 1;
lg_ble_params.programma = *(params++);
lg_ble_params.sensor = *(params++);
lg_ble_params.temper = *(params++);
lg_ble_params.h_taim_heat = *(params++);
lg_ble_params.m_taim_heat = *(params++);
lg_ble_params.h_taim_start = *(params++);
lg_ble_params.m_taim_start = *(params++);
lg_ble_params.lock = *(params);
return CM_OUT_OK;
}
case BLE_COMMANDS_CMD_SET_PARAM_LOCK: // Установка LOCK
{
if(*params == 1 && logic_work_cm.work_lock == LOCK_OFF){
logic_cm_lock_on(); return CM_OUT_OK;
}
else if(*params == 0 && logic_work_cm.work_lock == LOCK_ON){
logic_cm_lock_off(); return CM_OUT_OK;
}
return CM_OUT_ERROR;
}
}
if(lg_ble_params.fl_state == 0 && logic_work_cm.work_main != MAIN_OFF)
{ // Если обогреватель работает и новые параметры не были заданны
switch (com)
{
case BLE_COMMANDS_CMD_SET_PARAM_TAIM_LOAD: // Установка таймера отложенного старта
{
if(logic_work_cm.work_main == MAIN_STR_TIM)
{
BEEP();
switch (*params)
{
case 0: logic_main_str_tim_go_heat(); return CM_OUT_OK;
case 4: logic_main_str_tim_4h(); return CM_OUT_OK;
case 6: logic_main_str_tim_6h(); return CM_OUT_OK;
case 8: logic_main_str_tim_8h(); return CM_OUT_OK;
}
}
break;
}
case BLE_COMMANDS_CMD_SET_PARAM_TAIM_HEAT: // Установка таймера продолжительности обогрева
{
if(logic_work_cm.work_main == MAIN_HEAT)
{
BEEP();
switch (*params)
{
case 0:
case 12: logic_tim_off_main_heat(); return CM_OUT_OK;
case 1: logic_tim_1h_main_heat(); return CM_OUT_OK;
case 2: logic_tim_2h_main_heat(); return CM_OUT_OK;
case 4: logic_tim_4h_main_heat(); return CM_OUT_OK;
}
}
else if(logic_work_cm.work_main == MAIN_STR_TIM)
{
BEEP();
switch (*params)
{
case 0:
case 12: logic_main_str_tim_tim_off(); return CM_OUT_OK;
case 1: logic_main_str_tim_tim_1h(); return CM_OUT_OK;
case 2: logic_main_str_tim_tim_2h(); return CM_OUT_OK;
case 4: logic_main_str_tim_tim_4h(); return CM_OUT_OK;
}
}
break;
}
case BLE_COMMANDS_CMD_SET_PARAM_HEAT: // Установка режима интенсивноти обогрева
{
if(logic_work_cm.work_main == MAIN_HEAT)
{
BEEP();
if(logic_work_cm.work_boby_s == BODY_S_ON) logic_sensor_heater(); // Если включен интелектуальный обогрев
switch (*params)
{
case 0: logic_pwr_main_heat_l(); return CM_OUT_OK;
case 1: logic_pwr_main_heat_h(); return CM_OUT_OK;
}
}
else if(logic_work_cm.work_main == MAIN_STR_TIM)
{
BEEP();
switch (*params)
{
case 0: logic_pwr_main_str_tim_heat_l(); return CM_OUT_OK;
case 1: logic_pwr_main_str_tim_heat_h(); return CM_OUT_OK;
}
}
break;
}
case BLE_COMMANDS_CMD_SET_PARAM_SENSOR:
{
if(logic_work_cm.work_main == MAIN_HEAT)
{
BEEP();
if(logic_work_cm.work_boby_s == BODY_S_ON) logic_sensor_heater(); // Если включен интелектуальный обогрев
switch (*params)
{
case 0: logic_body_s_main_heat_off(); return CM_OUT_OK;
case 1: logic_body_s_main_heat_on(); return CM_OUT_OK;
}
}
else if(logic_work_cm.work_main == MAIN_STR_TIM)
{
BEEP();
switch (*params)
{
case 0: logic_body_s_main_str_tim_off(); return CM_OUT_OK;
case 1: logic_body_s_main_str_tim_on(); return CM_OUT_OK;
}
}
break;
}
}
}
return CM_OUT_ERROR;
}
/*==============================================================================
* Команды от приложения старт и стоп
==============================================================================*/
uint8_t logic_ext_command(uint8_t command)
{
switch (command)
{
case BLE_COMMANDS_CMD_START_PARAM: // Старт с заданными параметрами
{
if(lg_ble_params.fl_state == 1)
{
lg_ble_params.fl_state = 0;
BEEP();
//========================== Старт программы ===================================
if(lg_ble_params.h_taim_start == 0) // Если отдоженый старт не включен
{
logic_init_main_heat(); // Включаем режим обогрева
if(lg_ble_params.programma == 0) logic_pwr_main_heat_l(); // Включаем low heat
if(lg_ble_params.sensor == 1) logic_body_s_main_heat_on(); // Включаем BODY_S
else logic_body_s_main_heat_off();
if(lg_ble_params.lock == 1 && logic_work_cm.work_lock == LOCK_OFF) logic_cm_lock_on(); // Включаем LOCK
else if(lg_ble_params.lock == 0 && logic_work_cm.work_lock == LOCK_ON) logic_cm_lock_off();
switch (lg_ble_params.h_taim_heat) // Включаем таймер
{
case 0:
case 12: logic_tim_off_main_heat(); break;
case 1: logic_tim_1h_main_heat(); break;
case 2: logic_tim_2h_main_heat(); break;
case 4: logic_tim_4h_main_heat(); break;
default: return CM_OUT_ERROR;
}
}
else{ // Если включен отложенный старт
logic_init_main_str_tim(); // Включаем режим отложенного старта
if(lg_ble_params.programma == 0) logic_pwr_main_str_tim_heat_l(); // Включаем low heat
switch (lg_ble_params.h_taim_start) // Включаем таймер отложенного старта
{
case 4: break;
case 6: logic_main_str_tim_6h(); break;
case 8: logic_main_str_tim_8h(); break;
default: return CM_OUT_ERROR;
}
switch (lg_ble_params.h_taim_heat) // Включаем таймер
{
case 0:
case 12: logic_main_str_tim_tim_off(); break;
case 1: logic_main_str_tim_tim_1h(); break;
case 2: logic_main_str_tim_tim_2h(); break;
case 4: logic_main_str_tim_tim_4h(); break;
default: return CM_OUT_ERROR;
}
if(lg_ble_params.sensor == 1) logic_body_s_main_str_tim_on(); // Включаем BODY_S
else logic_body_s_main_str_tim_off();
if(lg_ble_params.lock == 1 && logic_work_cm.work_lock == LOCK_OFF) logic_cm_lock_on(); // Включаем LOCK
else if(lg_ble_params.lock == 0 && logic_work_cm.work_lock == LOCK_ON) logic_cm_lock_off();
}
//================= Стоп прогрпммы =============================================
}
else return CM_OUT_ERROR;
return CM_OUT_OK;
}
case BLE_COMMANDS_CMD_STOP: // Стоп
{
lg_ble_params.fl_state = 0;
logic_init_main_off();
return CM_OUT_OK;
}
}
return CM_OUT_ERROR;
}
/*==============================================================================
* bl end
==============================================================================*/
static void logic_cm(void)
{
buttons_state_t button_push;
button_push = ind_key_i2c_buttons();
/**
* Проверяем нажатые кнопок на ПДУ
*/
if(button_push == BUTT_NO)
{
switch(ir_read_command())
{
case IR_COM_ON_OFF: button_push = BUTT_ON_OFF; break;
case IR_COM_POWER: button_push = BUTT_PWR; break;
case IR_COM_BODY_S: button_push = BUTT_BODY_S; break;
case IR_COM_APP_S: button_push = BUTT_APP_S; break;
case IR_COM_TIMER: button_push = BUTT_TIM; break;
case IR_COM_LOCK: button_push = BUTT_LOCK; break;
default: break;
}
}
//==============================================================================
//==============================================================================
///**
// * Проверка сенсора в режиме интелектуального обогрева
// */
if(logic_work_cm.work_boby_s == BODY_S_ON && logic_work_cm.work_main == MAIN_HEAT){
if(heater_sensor_get() || button_push != BUTT_NO){ // Если сенсор сработал
logic_sensor_heater();
}
}
//==============================================================================
if(button_push == BUTT_LOCK)
{
logic_led_power_max();
timer_start(TIMER_LED_POWER);
if(logic_work_cm.work_lock == LOCK_OFF) logic_cm_lock_on();
else logic_cm_lock_off();
}
/**
* Если нет блокировки и нажата кнопка обрабатываем ее
*/
if(logic_work_cm.work_lock == LOCK_OFF && button_push != BUTT_NO)
{
logic_led_power_max();
switch (logic_work_cm.work_main)
{
case MAIN_OFF:
{
switch (button_push)
{
case BUTT_ON_OFF: logic_init_main_heat(); break;
case BUTT_APP_S: logic_init_main_str_tim(); break;
}
break;
}
case MAIN_HEAT:
{
switch (button_push)
{
case BUTT_ON_OFF: logic_init_main_off(); break;
case BUTT_PWR: logic_pwr_main_heat(); break;
case BUTT_TIM: logic_tim_main_heat(); break;
case BUTT_BODY_S: logic_body_s_main_heat(); break;
}
break;
}
case MAIN_STR_TIM:
{
switch (button_push)
{
case BUTT_ON_OFF:
logic_main_off();
logic_init_main_heat();
break;
case BUTT_PWR: logic_pwr_main_str_tim(); break;
case BUTT_TIM: logic_tim_main_srt_tim(); break;
case BUTT_APP_S: logic_app_s_main_str_tim(); break;
case BUTT_BODY_S: logic_body_s_main_str_tim();break;
}
break;
}
}
}
}
/**
* Функции LOCK NO_LOCK
*/
static inline void logic_cm_lock_on(void)
{
logic_work_cm.work_lock = LOCK_ON;
leds_change(LEDS_LOCK, LEDS_YES);
BEEP_LONG();
}
static inline void logic_cm_lock_off(void)
{
logic_work_cm.work_lock = LOCK_OFF;
leds_change(LEDS_LOCK, LEDS_NO);
BEEP_LONG();
}
/**
* Функция выхода из всех режимов
*/
static inline void logic_init_main_off(void)
{
BEEP();
logic_main_off();
}
static inline void logic_main_off(void)
{
/* STATUS */
logic_work_cm.work_main = MAIN_OFF;
logic_work_cm.work_heat = HEAT_ST_OFF;
logic_work_cm.work_tim = TIM_OFF;
logic_work_cm.work_str_tim = STR_TIM_OFF;
logic_work_cm.work_boby_s = BODY_S_OFF;
/* LED */
leds_change(LEDS_HOTE, LEDS_NO);
leds_change(LEDS_WORK, LEDS_NO);
leds_change(LEDS_SENSOR, LEDS_NO);
leds_change(LEDS_START, LEDS_NO);
/* FAN OFF */
timer_stop(TIMER_FAN_OFF);
if(1 == fan_get()){
timer_reset(TIMER_FAN_OFF);
timer_start(TIMER_FAN_OFF);
}
/* TIMER STOP */
timer_stop(TIMER_12_HOUR);
timer_stop(TIMER_BODY_S);
timer_stop(TIMER_STR_TIM);
timer_stop(TIMER_HEAT_WORK);
/* HEAT STOP */
timer_stop(TIMER_HEAT_ON);
heater_stop();
}
/*==============================================================================
*
* Функции режима HEAT
*
==============================================================================*/
static inline void logic_init_main_heat(void)
{
BEEP();
logic_main_heat();
}
static inline void logic_main_heat(void)
{
logic_work_cm.work_main = MAIN_HEAT;
logic_work_cm.work_heat = HEAT_ST_H;
leds_change(LEDS_HOTE, LEDS_H);
/* FAN ON */
timer_stop(TIMER_FAN_OFF);
fan_start();
/* HEAT START L, HL */
heater_start(HEAT_ON_L);
timer_stop(TIMER_HEAT_ON);
timer_reset(TIMER_HEAT_ON);
timer_start(TIMER_HEAT_ON);
timer_stop(TIMER_12_HOUR);
timer_reset(TIMER_12_HOUR);
timer_start(TIMER_12_HOUR);
}
/**
* Обработка кнопки POWER
*/
static inline void logic_pwr_main_heat(void)
{
BEEP();
if(logic_work_cm.work_tim == TIM_OFF && logic_work_cm.work_boby_s == BODY_S_OFF)
{
timer_stop(TIMER_12_HOUR);
timer_reset(TIMER_12_HOUR);
timer_start(TIMER_12_HOUR);
}
switch (logic_work_cm.work_heat)
{
case HEAT_ST_L: logic_pwr_main_heat_h(); break;
case HEAT_ST_H: logic_pwr_main_heat_l(); break;
}
}
static inline void logic_pwr_main_heat_l(void)
{
logic_work_cm.work_heat = HEAT_ST_L;
leds_change(LEDS_HOTE, LEDS_L);
timer_stop(TIMER_HEAT_ON);
heater_start(HEAT_ON_L);
}
static inline void logic_pwr_main_heat_h(void)
{
logic_work_cm.work_heat = HEAT_ST_H;
leds_change(LEDS_HOTE, LEDS_H);
heater_start(HEAT_ON_L);
timer_stop(TIMER_HEAT_ON);
timer_reset(TIMER_HEAT_ON);
timer_start(TIMER_HEAT_ON);
}
/**
* Обработка кнопки TIMER
*/
static inline void logic_tim_main_heat(void)
{
BEEP();
switch (logic_work_cm.work_tim)
{
case TIM_OFF: logic_tim_1h_main_heat(); break;
case TIM_1H: logic_tim_2h_main_heat(); break;
case TIM_2H: logic_tim_4h_main_heat(); break;
case TIM_4H: logic_tim_off_main_heat(); break;
}
}
static inline void logic_tim_off_main_heat(void)
{
logic_work_cm.work_tim = TIM_OFF;
leds_change(LEDS_WORK, LEDS_NO);
timer_stop(TIMER_HEAT_WORK);
if(logic_work_cm.work_boby_s == BODY_S_OFF)
{
timer_stop(TIMER_12_HOUR);
timer_reset(TIMER_12_HOUR);
timer_start(TIMER_12_HOUR);
}
}
static inline void logic_tim_1h_main_heat(void)
{
logic_work_cm.work_tim = TIM_1H;
leds_change(LEDS_WORK, LEDS_1H);
timer_stop(TIMER_HEAT_WORK);
timer_init(TIMER_HEAT_WORK,
#ifndef TEST_TIM_SMOL
TIMET_HOUR(1)
#else
TIMER_SECOND(20)
#endif
,0);
timer_start(TIMER_HEAT_WORK);
timer_stop(TIMER_12_HOUR);
}
static inline void logic_tim_2h_main_heat(void)
{
logic_work_cm.work_tim = TIM_2H;
leds_change(LEDS_WORK, LEDS_2H);
timer_stop(TIMER_HEAT_WORK);
timer_init(TIMER_HEAT_WORK,
#ifndef TEST_TIM_SMOL
TIMET_HOUR(1)
#else
TIMER_SECOND(20)
#endif
,0);
timer_start(TIMER_HEAT_WORK);
timer_stop(TIMER_12_HOUR);
}
static inline void logic_tim_4h_main_heat(void)
{
logic_work_cm.work_tim = TIM_4H;
leds_change(LEDS_WORK, LEDS_4H);
timer_stop(TIMER_HEAT_WORK);
timer_init(TIMER_HEAT_WORK,
#ifndef TEST_TIM_SMOL
TIMET_HOUR(2)
#else
TIMER_SECOND(40)
#endif
,0);
timer_start(TIMER_HEAT_WORK);
timer_stop(TIMER_12_HOUR);
}
/**
* Обработка кнопки BODY_S
*/
static inline void logic_body_s_main_heat(void)
{
BEEP();
switch (logic_work_cm.work_boby_s)
{
case BODY_S_OFF: logic_body_s_main_heat_on(); break;
case BODY_S_ON: logic_body_s_main_heat_off(); break;
}
}
static inline void logic_body_s_main_heat_off(void)
{
logic_work_cm.work_boby_s = BODY_S_OFF;
leds_change(LEDS_SENSOR, LEDS_NO);
timer_stop(TIMER_BODY_S);
if(logic_work_cm.work_tim == TIM_OFF)
{
timer_stop(TIMER_12_HOUR);
timer_reset(TIMER_12_HOUR);
timer_start(TIMER_12_HOUR);
}
}
static inline void logic_body_s_main_heat_on(void)
{
logic_work_cm.work_boby_s = BODY_S_ON;
leds_change(LEDS_SENSOR, LEDS_YES);
timer_reset(TIMER_BODY_S);
timer_start(TIMER_BODY_S);
timer_stop(TIMER_12_HOUR);
timer_reset(TIMER_12_HOUR);/// ?????
}
static inline void logic_sensor_heater(void)
{
if(timer_active(TIMER_BODY_S)) timer_reset(TIMER_BODY_S);
else
{
logic_body_s_main_heat_on();
/* FAN ON */
timer_stop(TIMER_FAN_OFF);
fan_start();
if(logic_work_cm.work_heat == HEAT_ST_L) logic_pwr_main_heat_l();
else logic_pwr_main_heat_h();
}
}
/**=============================================================================
*
* Функции режима отложенного старта
*
=============================================================================**/
static inline void logic_init_main_str_tim(void)
{
BEEP();
logic_main_str_tim();
}
static inline void logic_main_str_tim(void)
{
logic_work_cm.work_main = MAIN_STR_TIM;
logic_work_cm.work_heat = HEAT_ST_H;
leds_change(LEDS_HOTE, LEDS_H_BL);
logic_main_str_tim_4h();
}
/*
* Функция перехода из режима отложенного старта в режим обогрева
*/
static inline void logic_main_str_tim_go_heat(void)
{
logic_work_cm.work_main = MAIN_HEAT;
leds_change(LEDS_START, LEDS_NO);
timer_stop(TIMER_STR_TIM);
timer_stop(TIMER_FAN_OFF);
fan_start();
heater_start(HEAT_ON_L);
if(logic_work_cm.work_heat == HEAT_ST_H)
{
leds_change(LEDS_HOTE, LEDS_H);
timer_stop(TIMER_HEAT_ON);
timer_reset(TIMER_HEAT_ON);
timer_start(TIMER_HEAT_ON);
}
else leds_change(LEDS_HOTE, LEDS_L);
switch (logic_work_cm.work_tim)
{
case TIM_OFF: logic_tim_off_main_heat(); break;
case TIM_1H: logic_tim_1h_main_heat(); break;
case TIM_2H: logic_tim_2h_main_heat(); break;
case TIM_4H: logic_tim_4h_main_heat(); break;
}
if(logic_work_cm.work_boby_s == BODY_S_ON) logic_body_s_main_heat_on();
// else
// {
// timer_stop(TIMER_12_HOUR);
// timer_reset(TIMER_12_HOUR);
// timer_start(TIMER_12_HOUR);
// }
}
/**
* Обработка кнопки APP_S
*/
static inline void logic_app_s_main_str_tim(void)
{
BEEP();
switch (logic_work_cm.work_str_tim)
{
case STR_TIM_4H: logic_main_str_tim_6h(); break;
case STR_TIM_6H: logic_main_str_tim_8h(); break;
case STR_TIM_8H: logic_main_off(); break;
}
}
static inline void logic_main_str_tim_4h(void)
{
logic_work_cm.work_str_tim = STR_TIM_4H;
leds_change(LEDS_START, LEDS_S4H);
timer_stop(TIMER_STR_TIM);
timer_init(TIMER_STR_TIM,
#ifndef TEST_TIM_SMOL
TIMET_HOUR(4)
#else
TIMER_SECOND(40)
#endif
,0);
timer_start(TIMER_STR_TIM);
}
static inline void logic_main_str_tim_6h(void)
{
logic_work_cm.work_str_tim = STR_TIM_6H;
leds_change(LEDS_START, LEDS_S6H);
timer_stop(TIMER_STR_TIM);
timer_init(TIMER_STR_TIM,
#ifndef TEST_TIM_SMOL
TIMET_HOUR(2)
#else
TIMER_SECOND(20)
#endif
,0);
timer_start(TIMER_STR_TIM);
}
static inline void logic_main_str_tim_8h(void)
{
logic_work_cm.work_str_tim = STR_TIM_8H;
leds_change(LEDS_START, LEDS_S8H);
timer_stop(TIMER_STR_TIM);
timer_init(TIMER_STR_TIM,
#ifndef TEST_TIM_SMOL
TIMET_HOUR(2)
#else
TIMER_SECOND(20)
#endif
,0);
timer_start(TIMER_STR_TIM);
}
/**
* Обработка кнопки POWER
*/
static inline void logic_pwr_main_str_tim(void)
{
BEEP();
switch (logic_work_cm.work_heat)
{
case HEAT_ST_L: logic_pwr_main_str_tim_heat_h(); break;
case HEAT_ST_H: logic_pwr_main_str_tim_heat_l(); break;
}
}
static inline void logic_pwr_main_str_tim_heat_l(void)
{
logic_work_cm.work_heat = HEAT_ST_L;
leds_change(LEDS_HOTE, LEDS_L_BL);
}
static inline void logic_pwr_main_str_tim_heat_h(void)
{
logic_work_cm.work_heat = HEAT_ST_H;
leds_change(LEDS_HOTE, LEDS_H_BL);
}
/*
* Таймер отключения обогрева в режиме отложенного старта
*/
static inline void logic_tim_main_srt_tim(void)
{
BEEP();
switch (logic_work_cm.work_tim)
{
case TIM_OFF: logic_main_str_tim_tim_1h(); break;
case TIM_1H: logic_main_str_tim_tim_2h(); break;
case TIM_2H: logic_main_str_tim_tim_4h(); break;
case TIM_4H: logic_main_str_tim_tim_off(); break;
}
}
static inline void logic_main_str_tim_tim_1h(void)
{
logic_work_cm.work_tim = TIM_1H;
leds_change(LEDS_WORK, LEDS_1H_BL);
}
static inline void logic_main_str_tim_tim_2h(void)
{
logic_work_cm.work_tim = TIM_2H;
leds_change(LEDS_WORK, LEDS_2H_BL);
}
static inline void logic_main_str_tim_tim_4h(void)
{
logic_work_cm.work_tim = TIM_4H;
leds_change(LEDS_WORK, LEDS_4H_BL);
}
static inline void logic_main_str_tim_tim_off(void)
{
logic_work_cm.work_tim = TIM_OFF;
leds_change(LEDS_WORK, LEDS_NO);
}
/**
* Обработка кнопки BODY_S
*/
static inline void logic_body_s_main_str_tim(void)
{
BEEP();
switch (logic_work_cm.work_boby_s)
{
case BODY_S_OFF: logic_body_s_main_str_tim_on(); break;
case BODY_S_ON: logic_body_s_main_str_tim_off(); break;
}
}
static inline void logic_body_s_main_str_tim_off(void)
{
logic_work_cm.work_boby_s = BODY_S_OFF;
leds_change(LEDS_SENSOR, LEDS_NO);
}
static inline void logic_body_s_main_str_tim_on(void)
{
logic_work_cm.work_boby_s = BODY_S_ON;
leds_change(LEDS_SENSOR, LEDS_BL);
}
/**
* Включаем максимальную яркость led
*/
static void logic_led_power_max(void)
{
timer_stop(TIMER_LED_POWER);
timer_reset(TIMER_LED_POWER);
timer_start(TIMER_LED_POWER);
ind_led_min_max_power(0);
}
//==============================================================================
/**
* Функция для описания состояния работы прибора
* Должна возвращать 1 в случае если прибор можно перепрошить
* т.е. находится в неактивном состоянии.
*/
int get_ready_for_firmware(void)
{
if(logic_work_cm.work_main == MAIN_OFF && 0 == fan_get()) return 1;
return 0;
}
/**
* Коллбэк для таймера-пищалки
*/
static void cb_beep_off(uint32_t timer)
{
if(TIMER_BEEP == timer)
{
timer_stop(timer);
timer_reset(timer);
buzzer_stop();
}
}
//==============================================================================
// test mode
//==============================================================================
#ifdef TEST_MODE
static void logic_test_mode(void)
{
static uint32_t load_test_mode = 0;
BEEP_LONG();
leds_change(LEDS_POWER, LEDS_YES);
leds_change(LEDS_HOTE, LEDS_H_L);
leds_change(LEDS_WORK, LEDS_124H);
leds_change(LEDS_START, LEDS_S468H);
leds_change(LEDS_SENSOR, LEDS_YES);
leds_change(LEDS_LOCK, LEDS_YES);
ind_key_i2c_handler();
timer_delay(100);
leds_change(LEDS_POWER, LEDS_NO);
leds_change(LEDS_HOTE, LEDS_NO);
leds_change(LEDS_WORK, LEDS_NO);
leds_change(LEDS_START, LEDS_NO);
leds_change(LEDS_SENSOR, LEDS_NO);
leds_change(LEDS_LOCK, LEDS_NO);
while(ind_but_get() != BUTT_NO){
ind_key_i2c_handler();
}
while(1)
{
uint8_t st_test_kn = 0;
static uint8_t fl_sens = 0;
timer_delay(2);
ind_key_i2c_handler();
st_test_kn = (uint8_t)ind_but_get();
if(st_test_kn == 0)
{
switch(ir_read_command())
{
case IR_COM_ON_OFF: st_test_kn = 1; break;
case IR_COM_POWER: st_test_kn = 2; break;
case IR_COM_BODY_S: st_test_kn = 3; break;
case IR_COM_APP_S: st_test_kn = 5; break;
case IR_COM_TIMER: st_test_kn = 4; break;
case IR_COM_LOCK: st_test_kn = 6; break;
default: break;
}
}
if(st_test_kn != 0 && st_test_kn != 3) BEEP();
switch(st_test_kn)
{
case 1: /* on/off */
{
if(leds_state(LEDS_POWER) == LEDS_NO) leds_change(LEDS_POWER, LEDS_YES);
else leds_change(LEDS_POWER, LEDS_NO);
break;
}
case 2: /* POWER fan on/off */
{
if(leds_state(LEDS_HOTE) == LEDS_NO){
leds_change(LEDS_HOTE, LEDS_H_L);
fan_start();
}else{
leds_change(LEDS_HOTE, LEDS_NO);
if(heater_get() == HEAT_OFF) fan_stop();
}
break;
}
case 3: /* body sensor on/off */
{
if(fl_sens == 0){
BEEP_LONG();
fl_sens = 1;
}else{
BEEP();
fl_sens = 0;
leds_change(LEDS_SENSOR, LEDS_NO);
}
break;
}
case 4: /* timer heat_l on/off */
{
if(leds_state(LEDS_WORK) == LEDS_NO){
leds_change(LEDS_WORK, LEDS_124H);
fan_start();
if(heater_get() == HEAT_ON_H) heater_start(HEAT_ON_HL);
else heater_start(HEAT_ON_L);
}else{
leds_change(LEDS_WORK, LEDS_NO);
if(heater_get() == HEAT_ON_L){
heater_start(HEAT_OFF);
if(leds_state(LEDS_HOTE) == LEDS_NO) fan_stop();
}else heater_start(HEAT_ON_H);
}
break;
}
case 5: /* APP-S heat_h on/off */
{
if(leds_state(LEDS_START) == LEDS_NO){
leds_change(LEDS_START, LEDS_S468H);
fan_start();
if(heater_get() == HEAT_ON_L) heater_start(HEAT_ON_HL);
else heater_start(HEAT_ON_H);
}else{
leds_change(LEDS_START, LEDS_NO);
if(heater_get() == HEAT_ON_H){
heater_start(HEAT_OFF);
if(leds_state(LEDS_HOTE) == LEDS_NO) fan_stop();
}else heater_start(HEAT_ON_L);
}
break;
}
case 6: /* lock led on/off */
{
if(leds_state(LEDS_LOCK) == LEDS_NO) leds_change(LEDS_LOCK, LEDS_YES);
else leds_change(LEDS_LOCK, LEDS_NO);
break;
}
}
if(st_test_kn != 0) load_test_mode = 0;
else load_test_mode ++;
if(load_test_mode > 0x1770) break;
if(fl_sens == 1){
static uint8_t tim_sen = 0;
if(tim_sen < 10) tim_sen ++;
else{
tim_sen = 0;
heater_sensor_fl_handler();
}
if(heater_sensor_get()) leds_change(LEDS_SENSOR, LEDS_YES);
else leds_change(LEDS_SENSOR, LEDS_NO);
}
while(ind_but_get() != BUTT_NO){
ind_key_i2c_handler();
}
}
}
#endif // test mode
//==============================================================================
