Программный модуль для мультиварки RMC-M92S. Версия 1.5
ПО является неотъемлемой частью мультиварки RMC-M92S, отдельно потребителю не поставляется и эксплуатируется только в составе устройства.
Фрагмент исходного кода
////////////////////////////////////////////////////////////////
// RMC-M92S
//v1.5
////////////////////////////////////////////////////////////////
/*==============================================================
include
==============================================================*/
#include "common.h"
#include "r4s.h"
#include "application.h"
#include "appl_api.h"
#include "clk.h"
#include "temp.h"
#include "heat.h"
#include "buz.h"
#include "ind.h"
#include "keyb.h"
#include "timer.h"
#include "err.h"
#include "power_down.h"
/*==============================================================
Define
==============================================================*/
/*
* Включение пищалки
*/
#ifdef BEEP_ON
#define BEEP_BIG_LONG() {timer_init(TIMER_BEEP,35,cb_beep_off);timer_start(TIMER_BEEP);Buz_On();}
#define BEEP_LONG() {timer_init(TIMER_BEEP,25,cb_beep_off);timer_start(TIMER_BEEP);Buz_On();}
#define BEEP() {timer_init(TIMER_BEEP,10,cb_beep_off);timer_start(TIMER_BEEP);Buz_On();}
#else
#define BEEP_BIG_LONG() {}
#define BEEP_LONG() {}
#define BEEP() {}
#endif
/*==============================================================
static functions
==============================================================*/
static void application_timers_handler(void);
static void application_power_down(void);
static void cb_beep_off(uint32_t timer);
static void logic_led_start_bl(uint8_t stat);
static void logic_commands(void);
static void logic_mode_standby(uint8_t beep);
static void logic_mode_menu(uint8_t beep);
static void logic_mode_cooking(uint8_t beep);
static void logic_cooking_express(uint8_t beep);
static void logic_go_time_pasta(uint8_t beep);
static void logic_go_keepwarm(uint8_t beep);
static void logic_on_off_keepwarm(uint8_t beep);
static void logic_go_delay_start(void);
static void logic_go_start(void);
static void logic_load_menu_prog(cookcomplexprog *adr_prog);
static void logic_time_plas(uint8_t min_clok, uint8_t beep);
static void logic_delay_taim_key(uint8_t st_flag, uint8_t beep);
static void logic_temp_plas(uint8_t beep);
static void logic_paring(void);
static void logic_unparing(void);
static void logic_tim_1min(void);
static inline void logic_4sec_pwm(void);
static inline void blank_menu(void);
static inline void logic_beep_5(void);
static inline void logic_beep_3(void);
static inline void logic_prog_on_of(uint8_t n_prog, uint8_t state);
static inline void logic_pwm_regulator(uint8_t k_t, int16_t t_reg);
static void logic_heat_off(void);
static void logic_heat_on(uint8_t heat_state);
static void application_power_mode(void);
static void application_power_mode_go(uint8_t beep);
static void test_heat(uint8_t key);
static void logic_vesion(void);
/*==============================================================
static
==============================================================*/
static logic_state_mode state_mode = STANDBY_MODE, // Настоящее состояние мультиварки
power_state_mode = STANDBY_MODE;
static cookcomplexprog lg_cook_complex; // Параметры установленной программы готовки
static uint8_t led_blank_state = 0, // Параметр мигания индикации
blank_faze = 0, // Общий флаг периода мигания индикации
blank_faze_time = 0, // Флаг периода мигания времени
blank_faze_temp = 0, // Флаг периода мигания температуры
fl_load_delay_taim = 0, // Флаг установки времени отложенного старта
state_cooking = STAGE_NONE, // Cостояние процесса готовки
error = 0, // Ошибка
power_taim = 0, // Время нахождения в режиме сбоя питания
power_down = 0, // Флаг пропадения питания
power_state_cooking = STAGE_NONE,
test_ind_on = 0;
static uint16_t keep_warm_time = 0; // Время подогрева
static uint8_t temp_bot = 0, temp_top = 0, temp_pwm = 0;
static const cookprog cook_program[18] =
{
{ // 0 - "МУЛЬТИПОВАР"
100, // Рабочая температура
35, 170, // min, max диапазон изменения температуры
HEAT_TOP | HEAT_SIDE | HEAT_MAIN, // разрешенные тены
255, 94,
0, 99,
1, // Коэф. плавности закипания
8, // ШИМ доводки до кипения
4, // Коэф. усиления
FALSE, // Отсчет времени начать после закипания
5, 12*60, 1, 5, // диапазон ввода и шаг изменения в минутах
30, // время готовки в минутах
12, // подогрев в часах
TRUE // возможность отложенного старта
},
{ // 1 - "МОЛОЧНАЯ КАША"
97,
35, 170, // min, max диапазон изменения температуры
HEAT_SIDE | HEAT_MAIN,
255, 60,
60, 95,
5, // Коэф. плавности закипания
4, // ШИМ доводки до кипения
0, // Коэф. усиления
FALSE,
5, 90, 1, 1,
10,
12,
TRUE
},
{ // 2 - "ТУШЕНИЕ"
100,
35, 170, // min, max диапазон изменения температуры
HEAT_SIDE | HEAT_MAIN,
255, 94,
70, 99,
8, // Коэф. плавности закипания
4, // ШИМ доводки до кипения
0, // Коэф. усиления
FALSE,
10, 12*60, 5, 5,
60,
12,
TRUE
},
{ // 3 - "ЖАРКА"
170,
35, 170, // min, max диапазон изменения температуры
HEAT_SIDE | HEAT_MAIN,
255, 160,
0, 168,
8, // Коэф. плавности закипания
2, // ШИМ доводки до кипения
0, // Коэф. усиления ok
FALSE,
5, 90, 1, 1,
15,
12,
FALSE
},
{ // 4 - "СУП"
99, // ash
35, 170, // min, max диапазон изменения температуры
HEAT_SIDE | HEAT_MAIN,
255, 93, // ash
75,98,//70, 98, // ash
8, // Коэф. плавности закипания
4, // ШИМ доводки до кипения
0, // Коэф. усиления
FALSE,
10, 8*60, 5, 5,
60,
12,
TRUE
},
{ // 5 - "ПАР"
100,
35, 170, // min, max диапазон изменения температуры
HEAT_SIDE | HEAT_MAIN,
255, 94,
70, 99,
8, // Коэф. плавности закипания
4, // ШИМ доводки до кипения
0, // Коэф. усиления
TRUE,
5, 2*60, 5, 5,
20,
12,
TRUE
},
{ // 6 - "МАКАРОНЫ"
100,
35, 170, // min, max диапазон изменения температуры
HEAT_SIDE | HEAT_MAIN,
255, 94,
70, 99,
8, // Коэф. плавности закипания
8, // ШИМ доводки до кипения
1, // Коэф. усиления ok
TRUE,
2, 1*60, 1, 1,
8,
0,
FALSE
},
{ // 7 - "ТОМЛЕНИЕ"
97,
35, 170, // min, max диапазон изменения температуры
HEAT_SIDE | HEAT_MAIN,
255, 91,
0, 96, // ash
1, // Коэф. плавности закипания
8, // ШИМ доводки до кипения
0, // Коэф. усиления
FALSE,
30, 12*60, 10, 10,
300,
12,
TRUE
},
{ // 8 - "ВАРКА"
100,
35, 170, // min, max диапазон изменения температуры
HEAT_SIDE | HEAT_MAIN,
255, 94,
70, 99,
8, // Коэф. плавности закипания
4, // ШИМ доводки до кипения
0, // Коэф. усиления
FALSE,
10, 12*60, 5, 5,
40,
12,
TRUE
},
{ // 9 - "ВЫПЕЧКА"
145,//135 // ash
35, 170, // min, max диапазон изменения температуры
HEAT_TOP | HEAT_SIDE | HEAT_MAIN,
255, 110, //100
0, 144,//134
8, // Коэф. плавности закипания
2, // ШИМ доводки до кипения
2, // Коэф. усиления ok
FALSE,
10, 8*60, 5, 5,
60,
4,
TRUE
},
{ // 10 - "КРУПЫ"
100,
35, 170, // min, max диапазон изменения температуры
HEAT_SIDE | HEAT_MAIN,
255, 90,
70, 94,
8, // Коэф. плавности закипания
4, // ШИМ доводки до кипения
0, // Коэф. усиления
FALSE,
5, 4*60, 5, 5,
35,
12,
TRUE
},
{ // 11 - "ПЛОВ"
110, // ash
35, 170, // min, max диапазон изменения температуры
HEAT_TOP | HEAT_SIDE | HEAT_MAIN,
255, 94,
70, 99,
8, // Коэф. плавности закипания
4, // ШИМ доводки до кипения
0, // Коэф. усиления
FALSE,
10, 90, 10, 10,
60,
12,
TRUE
},
{ // 12 - "ЙОГУРТ"
38, // ash
35, 170,
HEAT_MAIN,
255, 28,
0, 30,
1, // Коэф. плавности закипания
2, // ШИМ доводки до кипения
3, // Коэф. усиления ok
FALSE,
10, 12*60, 10, 10,
480,
0,
TRUE
},
{ // 13 - "ПИЦА"
150, // ash
35, 170, // min, max диапазон изменения температуры
HEAT_TOP | HEAT_SIDE | HEAT_MAIN,
255, 120,
0, 140,
8, // Коэф. плавности закипания
4, // ШИМ доводки до кипения
0, // Коэф. усиления
FALSE,
10, 1*60, 5, 5,
25,
4,
TRUE
},
{ // 14 - "ХЛЕБ"
150, // ash
35, 170, // min, max диапазон изменения температуры
HEAT_TOP | HEAT_SIDE | HEAT_MAIN,
255, 120,
0, 148,
8, // Коэф. плавности закипания
2, // ШИМ доводки до кипения
2, // Коэф. усиления ok
FALSE,
60, 6*60, 10, 10,
180,
3,
TRUE
},
{ // 15 - "ДЕСЕРТЫ"
98,
35, 170, // min, max диапазон изменения температуры
HEAT_SIDE | HEAT_MAIN,
255, 91,
0, 97, // ash
1, // Коэф. плавности закипания
8, // ШИМ доводки до кипения
0, // Коэф. усиления
FALSE,
5, 2*60, 5, 5,
20,
12,
TRUE
},
{ // 16 - "ЭКСПРЕСС"
100,
35, 170, // min, max диапазон изменения температуры
HEAT_MAIN,
255, 94,
70, 99,
8, // Коэф. плавности закипания
4, // ШИМ доводки до кипения
0, // Коэф. усиления ok
FALSE,
5, 8*60, 5, 5,
0,
0,
FALSE
},
{ // 17 - "ПОДОГРЕВ"
100,
35, 170, // min, max диапазон изменения температуры
HEAT_MAIN,
255, 94,
70, 99,
8, // Коэф. плавности закипания
4, // ШИМ доводки до кипения
0, // Коэф. усиления ok
FALSE,
5, 8*60, 5, 5,
30,
12,
TRUE
}
};
/*==============================================================
init functions
==============================================================*/
/*
* Инит перефирии
*/
void Application_Init(void)
{
power_state state_power;
Clk_Init();
Temp_Init();
Heat_Init();
Buz_Init();
Ind_Init();
Keyb_Init();
/*
* Инит таймеров
*/
timer_init(TIMER_LEDS_HANDLE,2,0); // 20ms Обновление led дисплея
timer_start(TIMER_LEDS_HANDLE);
timer_init(TIMER_LEDS_BLANK,50,0); // 500ms Blank led
timer_init(TIMER_PARING_TIMER,TIMER_SECOND(10),0); // 10 sec Paring
timer_init(TIMER_UNPARING_TIMER,TIMER_SECOND(2),0); // 5 sec Unparing
timer_init(TIMER_30SEK,TIMER_SECOND(30),0); // 30s TIMER_CLER_PROGRAM menu
timer_init(TIMER_1MIN_START,TIMER_MINUTE(1),0); // 1m Отсчет больших интервалов времени
timer_init(TIMER_4SEC_PWM,TIMER_SECOND(2),0); // 4s PWM
timer_start(TIMER_4SEC_PWM);
timer_init(TIMER_150MS_IND,15,0); // 150ms Для змейки Экспресс
timer_init(TIMER_TEST_MODE,TIMER_MINUTE(2),0); // Время работы тестового режима
timer_init(TIMER_POWER_1_MIN,TIMER_MINUTE(1),0); // Время для режима перебоя питания
timer_init(TIMER_ERROR, TIMER_MINUTE(5),0);
BEEP_LONG(); // Длинный сигнал
for(uint8_t i=0;i<8;i++) Ind_LED_On(i, 0xFFFF); // Включение всего дисплея
Ind_LED_Off(LED_START); // Кроме светодиодов
Ind_LED_Off(LED_ESC);
Ind_LED_Off(LED_DEF_START);
Ind_Release(); // Обновление дисплея
Clk_Delay(50);
logic_mode_standby(0); // Переходим в режим ожидания
/**
* Power
*/
state_power = power_state_mem(Temp_GetBotTemp());
if(state_power != STATE_OK) // Если был перебой питания в режиме работы
{
if(lg_cook_complex.cPower_cnt < 250) lg_cook_complex.cPower_cnt ++; // Увеличиваем счетчик продадения питания
if(state_power == STATE_DOWN) // Smol перебой
{
power_read_params(&lg_cook_complex, &state_mode, &state_cooking, &keep_warm_time);
switch(state_cooking)
{
case STAGE_BOOST:
case STAGE_ENDOFBOOST:
case STAGE_WARM:
case STAGE_STAT:
case STAGE_BREAD_LOAD:
{
if(lg_cook_complex.cProgramNumber == (uint8_t)EXPRESS_PROGRAM) logic_cooking_express(0);
else logic_mode_cooking(0); // Запускаем готовку
break;
}
case STAGE_POSTPONEMENT: logic_go_delay_start(); logic_led_start_bl(39);break; // Запуск отложенного старта
}
}
else if(state_power == STATE_DOWN_LONG) // Long перебой индикация паузы программы
{
power_read_params(&lg_cook_complex, &state_mode, &state_cooking, &keep_warm_time);
power_state_mode = state_mode;
power_state_cooking = state_cooking;
state_mode = POWER_MODE;
state_cooking = STATE_POWER;
if(lg_cook_complex.cPower_flag != 1){
application_power_mode();
power_down = 1;
power_taim = 0;
timer_start(TIMER_POWER_1_MIN);
}
else{
power_down = 2;
switch(power_state_cooking)
{
case STAGE_BOOST:
case STAGE_ENDOFBOOST:
case STAGE_WARM:
case STAGE_STAT:
case STAGE_BREAD_LOAD: logic_led_start_bl(38); break;
}
}
BEEP();
}
}
if(Temp_GetBotTemp() < 5) Err_Stop(BOT_TEMP_SENSOR_ERR); // Ошибка датчика BOT
if(Temp_GetTopTemp() < 5) Err_Stop(TOP_TEMP_SENSOR_ERR); // Ошибка датчика TOP
}
////////////////////////////////////////////////////////////////
static void application_power_mode(void)
{
switch(power_state_cooking)
{
case STAGE_BOOST:
case STAGE_ENDOFBOOST:
case STAGE_WARM:
case STAGE_STAT:
case STAGE_BREAD_LOAD:
{
if(lg_cook_complex.cProgramNumber == (uint8_t)MULTICOOK_PROGRAM) // Если программа "Мультиповар"
{
Ind_LED_On(LED_IMG_TEMP); // Индикация температуры
Ind_LED_On(LED_IMG_GRAD);
ind_temperature(lg_cook_complex.cCookTemp, 1);
}
if(lg_cook_complex.bKeepWarmEnabled == TRUE) Ind_LED_On(LED_ESC); // Если возможен подогрев led_подогрев
Ind_LED_On(LED_START); // Led_start
Ind_LED_On(LED_IMG_ML); // Мультиварка
Ind_LED_On(LED_IMG_K_ML);
if(lg_cook_complex.cProgramNumber == (uint8_t)EXPRESS_PROGRAM)// Если программа Экспресс
{
logic_led_start_bl(36); // Blank змейка
}
else /* Если рабочая программа */
{
Ind_LED_On(LED_TIME_LOAD); // Время приготовления
logic_led_start_bl(33); // Blank время приготовления
}
break;
}
}
}
static void application_power_mode_go(uint8_t beep)
{
if(beep == 1) BEEP();
power_taim = 0;
timer_stop(TIMER_POWER_1_MIN);
state_mode = power_state_mode;
state_cooking = power_state_cooking;
switch(state_cooking)
{
case STAGE_BOOST:
case STAGE_ENDOFBOOST:
case STAGE_WARM:
case STAGE_STAT:
case STAGE_BREAD_LOAD:
{
if(lg_cook_complex.cProgramNumber == (uint8_t)EXPRESS_PROGRAM) logic_cooking_express(0);
else logic_mode_cooking(0); break; // Запускаем готовку
}
}
}
////////////////////////////////////////////////////////////////
void Application(void)
{
R4S(); // Обработка радиокоманд
application_timers_handler(); // Обработка таймеров
logic_commands(); // Обработка пользовательских команд
application_power_down(); // Обработка пропадания питания
}
/*
* Обработка пропадения питания
*/
static void application_power_down(void)
{
if(power_read_down() != STATE_OK){ // Если питание ниже 2V7
if(state_mode == COOKING_MODE){ // И состояние работы
power_seve_params(&lg_cook_complex, state_mode, state_cooking, keep_warm_time, Temp_GetBotTemp()); // Сохраняем текущие параметры
}
else if(state_mode == POWER_MODE){
state_mode = power_state_mode;
state_cooking = power_state_cooking;
power_seve_params(&lg_cook_complex, state_mode, state_cooking, keep_warm_time, 255); // Сохраняем текущие параметры
}
}
}
////////////////////////////////////////////////////////////////
/*
* Код обработчика таймеров
*/
static void application_timers_handler(void)
{
if(timer_ready(TIMER_LEDS_HANDLE)) // Таймер вывода индикации
{
timer_ready_clr(TIMER_LEDS_HANDLE);
Ind_Release();
}
if(timer_ready(TIMER_BUTTONS_HANDLE)) // Таймеры обработки нажатых кнопок
{
timer_ready_clr(TIMER_BUTTONS_HANDLE);
timer_stop(TIMER_BUTTONS_HANDLE);
}
if(timer_ready(TIMER_BUTTONS_CLR_HANDLE))
{
timer_ready_clr(TIMER_BUTTONS_CLR_HANDLE);
timer_stop(TIMER_BUTTONS_CLR_HANDLE);
keyb_clear();
}
if(timer_ready(TIMER_LEDS_BLANK)) // Таймер BLANK индикации
{
timer_ready_clr(TIMER_LEDS_BLANK);
blank_menu();
}
if(timer_ready(TIMER_30SEK)) // Таймер выхода из пользовательского меню установок
{
timer_ready_clr(TIMER_30SEK);
timer_stop(TIMER_30SEK);
logic_mode_standby(0);
}
if(timer_ready(TIMER_1MIN_START)) // Таймер 1 минуты для отсчета времени отложенного старта, готовки и подогрева
{
timer_ready_clr(TIMER_1MIN_START);
logic_tim_1min();
}
if(timer_ready(TIMER_4SEC_PWM))
{
timer_ready_clr(TIMER_4SEC_PWM);
logic_4sec_pwm(); // Таймер для работы ШИМ (управление нагревателями)
}
if(timer_ready(TIMER_BEEP_5)) // Сигнал завершения готовки
{
timer_ready_clr(TIMER_BEEP_5);
logic_beep_5();
}
if(timer_ready(TIMER_BEEP_3)) // Сигнал закладки "макарон"
{
timer_ready_clr(TIMER_BEEP_3);
logic_beep_3();
}
if(timer_ready(TIMER_PARING_TIMER)) {
timer_ready_clr(TIMER_PARING_TIMER);
timer_stop(TIMER_PARING_TIMER);
logic_mode_standby(0);
}
if(timer_ready(TIMER_UNPARING_TIMER)){
timer_ready_clr(TIMER_UNPARING_TIMER);
timer_stop(TIMER_UNPARING_TIMER);
logic_mode_standby(0);
}
if(timer_ready(TIMER_150MS_IND)) {
timer_ready_clr(TIMER_150MS_IND);
ind_express();
}
if(timer_ready(TIMER_TEST_MODE)) {
timer_ready_clr(TIMER_TEST_MODE);
timer_stop(TIMER_TEST_MODE);
logic_mode_standby(0);
}
if(timer_active(TIMER_TEST_MODE)){
if(heat_get() != 0){
if(timer_read_taim(TIMER_TEST_MODE) >= TIMER_SECOND(10)){
heat_on_off(HEAT_OFF);
ind_taim(0, 2);
}
}
if(test_ind_on == 1){
if(timer_read_taim(TIMER_TEST_MODE) >= TIMER_SECOND(10)){
test_ind_on = 0;
logic_led_start_bl(20);
Ind_LED_On(LED_IMG_TEMP);
Ind_LED_On(LED_IMG_GRAD);
ind_taim(0, 2);
}
}
}
if(timer_ready(TIMER_ERROR)) {
timer_ready_clr(TIMER_ERROR);
timer_stop(TIMER_ERROR);
if(state_mode == COOKING_MODE){
if(temp_bot > lg_cook_complex.cCookTemp + 45) Err_Stop(EMPTY_POT_ERR);
}
}
if(timer_ready(TIMER_POWER_1_MIN)) {
timer_ready_clr(TIMER_POWER_1_MIN);
power_taim ++;
if(power_taim >= 30){
timer_stop(TIMER_POWER_1_MIN);
lg_cook_complex.cPower_flag = 1; // Устанавливаем флаг ожидание подтверждения > 30 мин.
logic_led_start_bl(20);
switch(power_state_cooking)
{
case STAGE_BOOST:
case STAGE_ENDOFBOOST:
case STAGE_WARM:
case STAGE_STAT:
case STAGE_BREAD_LOAD:
{ /* Если готовка */
logic_led_start_bl(38);
break;
}
}
}else BEEP(); // Если прошло 30 минут
}
}
void logic_mode_error(uint8_t err)
{
logic_mode_standby(0);
state_mode = ERROR_MODE;
state_cooking = STAGE_ERROR;
error = err;
}
/*======================================================================================================================
* Основные функции работы логики мультиварки
======================================================================================================================*/
/*
* Функция логики мультиварки
*/
static void logic_commands(void)
{
static uint8_t state_key = 0;
state_key = Keyb_GetKey(); // Считываем значение кнопок
if(state_key != NOT_KEY || state_mode == TEST_MODE){ // Если нажата кнопка обрабатываем ее
switch(state_mode)
{
/* Обработка кнопок в режиме ожидания */
case STANDBY_MODE:
{
switch(state_key)
{
case MENU_KEY: logic_mode_menu(1); break; // Вход в меню установок
case LONG_EXPRESS_KEY: logic_cooking_express(1); break; // Включение программа экспресс
case LONG_REHEAT_KEY: logic_go_keepwarm(1); break; // Включение режима подогрева
case PARING_KEY: logic_paring(); break; // Пэринг
case UNPARING_KEY: logic_unparing(); break; // Унпэринг
case LONG_TEMP_KEY: logic_vesion(); break; // Вывод номера версии прошивки
}
break;
}
/* Обработка кнопок в режиме меню (выбора параметров) */
case MENU_MODE:
{
switch(state_key)
{
case REHEAT_KEY: logic_mode_standby(1); break; // Выход в состояние ожидания
case LONG_START_KEY: logic_mode_cooking(1); break; // Запуск готовки
case MENU_KEY: // Выбор программы
{
if(lg_cook_complex.cProgramNumber<15)lg_cook_complex.cProgramNumber++;
else lg_cook_complex.cProgramNumber = 0;
logic_mode_menu(1);
break;
}
case LONG_MENU_KEY: // Выбор программы
{
if(lg_cook_complex.cProgramNumber<15)lg_cook_complex.cProgramNumber++;
else lg_cook_complex.cProgramNumber = 0;
logic_mode_menu(0);
break;
}
case MIN_KEY: logic_time_plas(0,1); break; // Установка времени
case HOUR_KEY: logic_time_plas(1,1); break;
case UNPARING_KEY:
case LONG_MIN_KEY: logic_time_plas(0,0); break;
case PARING_KEY:
case LONG_HOUR_KEY: logic_time_plas(1,0); break;
case TEMP_KEY: logic_temp_plas(1); break; // Устанока температуры с шагом 1 град
case LONG_TEMP_KEY: logic_temp_plas(0); break; // Установка температуры с шагом 5 град
case DELAY_KEY: logic_delay_taim_key(1,1); break; // Выбор отложенного старта
}
break;
}
/* Обработка кнопок в режиме приготовления */
case COOKING_MODE:
{
switch(state_key)
{
case LONG_START_KEY: logic_go_time_pasta(1); break; // Запуск времени варки макарон
case LONG_MENU_KEY: logic_on_off_keepwarm(1); break; // Откл/вкл автоподогрева
case LONG_REHEAT_KEY: logic_mode_standby(1); break; // Выход в состояние ожидания
}
break;
}
/* Обработка кнопок в режиме подогрева */
case KEEP_MODE:
{
if(state_key == LONG_REHEAT_KEY) logic_mode_standby(1); // Выход в состояние ожидания
break;
}
/* Обработка кнопок в режиме продолжительного перебоя питания */
case POWER_MODE:
{
switch(state_key)
{
case LONG_START_KEY: // Продолжение работы программы готовки
{
if(lg_cook_complex.cPower_flag != 1) application_power_mode_go(1);
break;
}
case LONG_REHEAT_KEY: logic_mode_standby(1); break; // Выход в состояние ожидания
}
break;
}
/* Обработка кнопок в тестовом режиме */
case TEST_MODE:
{
switch(state_key)
{
case LONG_REHEAT_KEY: state_key = REHEAT_KEY; break; // Включаем верхний нагреватель
case LONG_DELAY_KEY: state_key = DELAY_KEY; break; // Включаем боковой нагреватель
case PARING_KEY:
case LONG_TEMP_KEY: state_key = TEMP_KEY; break; // Включаем нижний нагреватель
case LONG_HOUR_KEY: state_key = HOUR_KEY; break; // BEEP
case LONG_MIN_KEY: state_key = MIN_KEY; break; // BEEP
case LONG_EXPRESS_KEY: state_key = EXPRESS_KEY; break; // BEEP
case LONG_MENU_KEY: state_key = MENU_KEY; break; // BEEP
}
test_heat(state_key); /* Обработка нажатых копок для режима тестирования */
break;
}
/* End parametrs */
default: break;
}
}
}
/*=======================================================================================
* Function test mode and image version hex
=======================================================================================*/
static void logic_vesion(void){
uint8_t key_test = LONG_TEMP_KEY;
BEEP(); logic_led_start_bl(20);
while(key_test == LONG_TEMP_KEY || key_test == TEMP_KEY){
ind_taim(FIRMWARE_VER, 3);
Ind_Release();
keyb_clear();
Clk_Delay(50);
key_test = Keyb_GetKey();
}
if(key_test == MIN_KEY){
BEEP_LONG();
test_ind_on = 0;
Ind_LED_On(LED_IMG_TEMP);
Ind_LED_On(LED_IMG_GRAD);
state_mode = TEST_MODE;
state_cooking = STAGE_TEST;
timer_start(TIMER_TEST_MODE);
ind_taim(0, 2);
}else logic_mode_standby(0);
}
static void test_heat(uint8_t key){
static uint8_t f_key = NOT_KEY;
if(f_key != key){
f_key = key;
if(f_key != NOT_KEY){
BEEP();
if(test_ind_on == 1){
if(f_key == MENU_KEY) f_key = NOT_KEY;
test_ind_on = 0;
logic_led_start_bl(20);
Ind_LED_On(LED_IMG_TEMP);
Ind_LED_On(LED_IMG_GRAD);
ind_taim(0, 2);
}
timer_reset(TIMER_TEST_MODE);
if(f_key == REHEAT_KEY){
heat_on_off(HEAT_TOP);
ind_taim(1, 1);
}else if(f_key == DELAY_KEY){
heat_on_off(HEAT_SIDE);
ind_taim(2, 1);
}else if(f_key == TEMP_KEY){
heat_on_off(HEAT_MAIN);
ind_taim(3, 1);
}else if(f_key == LONG_START_KEY) logic_mode_standby(1);
else if(f_key == MENU_KEY){
heat_on_off(HEAT_OFF);
test_ind_on = 1;
for(uint8_t i=0;i<8;i++) Ind_LED_On(i, 0xFFFF);
}else{
heat_on_off(HEAT_OFF);
ind_taim(0, 2);
}
}
}
}
/*=======================================================================================
* Функции основной работы мультиварки
=======================================================================================*/
/**
* Режим полного останова мультиварки
*/
static void logic_mode_standby(uint8_t beep)
{
if(beep == 1) BEEP();
power_down = 0;
lg_cook_complex.cPower_cnt = 0;
lg_cook_complex.cPower_flag = 0;
state_mode = STANDBY_MODE; // Сброс статуса мультиварки
state_cooking = STAGE_NONE; // Сброс статуса готовки мультиварки
heat_on_off(HEAT_OFF); // Выключаем ТЕНы
timer_stop(TIMER_1MIN_START); // Останавливаем таймер отсчета времени
timer_stop(TIMER_30SEK); // Останавливаем таймер выхода из режима установок меню
timer_stop(TIMER_PARING_TIMER); // Останавливаем таймер пэринга
timer_stop(TIMER_BEEP_3);
//timer_ready_clr(TIMER_BEEP_3); // 20_07_2015 V1_2
timer_stop(TIMER_150MS_IND);
timer_stop(TIMER_TEST_MODE);
timer_stop(TIMER_POWER_1_MIN);
lg_cook_complex.cProgramNumber = (uint8_t)MULTICOOK_PROGRAM;
logic_led_start_bl(20); logic_led_start_bl(21); // Сбрасываем индикацию
fl_load_delay_taim = 0; // Сбрасываем флаг отложенного старта
}
/**
* Режим меню (установка параметров приготовления)
*/
static void logic_mode_menu(uint8_t beep)
{
if(beep == 1) BEEP();
state_mode = MENU_MODE;
state_cooking = STAGE_PROGRAM;
logic_led_start_bl(20); // Сброс blank
logic_load_menu_prog(&lg_cook_complex); // Заполнение структуры нужной программой
logic_led_start_bl(lg_cook_complex.cProgramNumber); // Устанвка
fl_load_delay_taim = 0; // Сброс флага установки отложенного таймера
timer_reset(TIMER_30SEK);
if(timer_active(TIMER_30SEK) == 0) timer_start(TIMER_30SEK);
}
/**
* Режим приготовления
*/
static void logic_mode_cooking(uint8_t beep)
{
if(beep == 1) BEEP();
state_mode = COOKING_MODE;
if(fl_load_delay_taim == 1){ // Если включен таймер отложенного старта
fl_load_delay_taim = 0;
logic_go_delay_start(); // Запуск отложенного старта
}else logic_go_start(); // Запускаем программу приготовления
timer_stop(TIMER_30SEK);
}
/**
* Подогрев
*/
static void logic_go_keepwarm(uint8_t beep)
{
if(beep == 1){ // Если мы пришли из режима ожидания
BEEP();
lg_cook_complex.cProgramNumber = (uint8_t)KEEP_PROGRAM;
logic_load_menu_prog(&lg_cook_complex); // Заполнение структуры нужной программой
}
if(lg_cook_complex.cCookTemp > 95){ // Если температура варки больше 95 градусов
lg_cook_complex.cKeepWarmTemp = 70; // Температура подогрева 70 градусов
}else lg_cook_complex.cKeepWarmTemp = lg_cook_complex.cCookTemp*2/3; // Иначе 2/3 температуры готовки
timer_reset(TIMER_1MIN_START); timer_start(TIMER_1MIN_START);
state_mode = KEEP_MODE; // Режим подогрева
state_cooking = STAGE_KEEPWARM; // Статус варки подогрев
logic_led_start_bl(20); logic_led_start_bl(30); // Blank точек MP
if(beep != 2) keep_warm_time = 0;
ind_taim(keep_warm_time, 1);
Ind_LED_On(LED_ESC); Ind_LED_On(LED_IMG_ML); Ind_LED_On(LED_IMG_K_ML);
}
/**
* Включение выключение подогрева
*/
static void logic_on_off_keepwarm(uint8_t beep)
{
timer_reset(TIMER_BUTTONS_HANDLE); // Для отмены при удержание
timer_stop(TIMER_BUTTONS_HANDLE);
if(lg_cook_complex.bKeepWarmEnabled == TRUE){ // Если включен выключаем
if(beep == 1) BEEP();
lg_cook_complex.bKeepWarmEnabled = FALSE;
Ind_LED_Off(LED_ESC);
}else{ // Включаем
if(lg_cook_complex.cKeepWarmTime > 0){ // Если разрешен подогрев
if(beep == 1) BEEP();
lg_cook_complex.bKeepWarmEnabled = TRUE;
Ind_LED_On(LED_ESC);
}
}
}
/**
* Запуск программы экспресс
*/
static void logic_cooking_express(uint8_t beep)
{
if(beep == 1) BEEP();
state_mode = COOKING_MODE;
fl_load_delay_taim = 0; // Сбрасываем флаг отложенного старта
lg_cook_complex.cProgramNumber = (uint8_t)EXPRESS_PROGRAM;
logic_load_menu_prog(&lg_cook_complex); // Заполнение структуры нужной программой
logic_go_start(); // Запускаем программу приготовления
logic_led_start_bl(34);
timer_start(TIMER_150MS_IND); // Запускаем змейку
}
/**
* Отложенный старт
*/
static void logic_go_delay_start(void)
{
if(lg_cook_complex.iPostPonementTime > lg_cook_complex.iCookTime){ // Если отложенное время старта больше времени готовки
state_cooking = STAGE_POSTPONEMENT; // Отложенный старт
logic_led_start_bl(20); logic_led_start_bl(30); // Blank точек MP
timer_reset(TIMER_1MIN_START); timer_start(TIMER_1MIN_START);
if(lg_cook_complex.cProgramNumber == (uint8_t)MULTICOOK_PROGRAM){
Ind_LED_On(LED_IMG_TEMP); Ind_LED_On(LED_IMG_GRAD);
ind_temperature(lg_cook_complex.cCookTemp, 1);
if(lg_cook_complex.cCookTemp < 80) lg_cook_complex.bKeepWarmEnabled = FALSE;
}
if(lg_cook_complex.bKeepWarmEnabled == TRUE) Ind_LED_On(LED_ESC); // Если возможен подогрев
Ind_LED_On(LED_START); Ind_LED_On(LED_DEF_START);
Ind_LED_On(LED_LOAD_START_1); Ind_LED_On(LED_LOAD_START_2);
Ind_LED_On(LED_IMG_ML); Ind_LED_On(LED_IMG_K_ML);
ind_taim(lg_cook_complex.iPostPonementTime, 1);
logic_prog_on_of(lg_cook_complex.cProgramNumber, 1);
}else logic_go_start(); // Иначе сразу включаем готовку
}
/**
* Запуск времени готовки "МАКАРОН"
*/
static void logic_go_time_pasta(uint8_t beep){
if(state_cooking == STAGE_ENDOFBOOST){ // Если вода закипела и нажата кнопка старт
if(beep == 1) BEEP();
state_cooking = STAGE_STAT;
timer_stop(TIMER_BEEP_3);
//timer_ready_clr(TIMER_BEEP_3); // 20_07_2015 V1_2
ind_etp(3); // Поддержание температуры варки
}
}
/**
* Процесс приготовления
*/
static void logic_go_start(void)
{
logic_led_start_bl(20); // Сброс blank
if(lg_cook_complex.cProgramNumber == (uint8_t)PASTA_PROGRAM){ // Если программа "МАКАРОНЫ"
if(power_down == 0) state_cooking = STAGE_BOOST; // Нагрев до кипения перед закладкой продуктов
}
else if(lg_cook_complex.cProgramNumber == (uint8_t)BREAD_PROGRAM){ // Если программа "ХЛЕБ"
if(power_down == 0){
state_cooking = STAGE_BREAD_LOAD; // Иначе включаем закваску хлеба на 1 час.
lg_cook_complex.cHeatEnable = HEAT_MAIN; // Используем только нижний тен
}
}else if(lg_cook_complex.cProgramNumber == (uint8_t)MULTICOOK_PROGRAM){ // Если программа "Мультиповар"
Ind_LED_On(LED_IMG_TEMP);
Ind_LED_On(LED_IMG_GRAD);
ind_temperature(lg_cook_complex.cCookTemp, 1);
if(lg_cook_complex.cCookTemp < 81) lg_cook_complex.cHeatEnable = HEAT_MAIN;
else if(lg_cook_complex.cCookTemp < 116 || lg_cook_complex.cCookTemp > 140) lg_cook_complex.cHeatEnable = (HEAT_SIDE | HEAT_MAIN);
else lg_cook_complex.cHeatEnable = (HEAT_TOP | HEAT_SIDE | HEAT_MAIN);
if(lg_cook_complex.cCookTemp < 80) lg_cook_complex.bKeepWarmEnabled = FALSE;
state_cooking = STAGE_WARM;
}else state_cooking = STAGE_WARM; // Нагрев с продуктами до рабочей температуры
timer_reset(TIMER_1MIN_START);
timer_start(TIMER_1MIN_START);
if(lg_cook_complex.cProgramNumber != (uint8_t)EXPRESS_PROGRAM) {
logic_led_start_bl(32); // Blank пар и MP
ind_taim(lg_cook_complex.iCookTime, 1);
Ind_LED_On(LED_TIME_LOAD);
}
if(lg_cook_complex.bKeepWarmEnabled == TRUE) Ind_LED_On(LED_ESC); // Если возможен подогрев
Ind_LED_On(LED_START);
ind_etp(1);
Ind_LED_On(LED_IMG_ML);
Ind_LED_On(LED_IMG_K_ML);
logic_prog_on_of(lg_cook_complex.cProgramNumber, 1);
}
/**
* Обработка таймеров отложенного старта, работы, подогрев.
*/
static void logic_tim_1min(void)
{
switch(state_cooking)
{
case STAGE_POSTPONEMENT: // Отложенный старт
{
if(--lg_cook_complex.iPostPonementTime > lg_cook_complex.iCookTime) ind_taim(lg_cook_complex.iPostPonementTime, 1);
else logic_go_start();
break;
}
case STAGE_WARM: case STAGE_STAT: case STAGE_BREAD_LOAD: // Процесс приготовления
{
if(state_cooking == STAGE_STAT || lg_cook_complex.bBoost == FALSE){ // Если отсчет времени начинается после закипания
if(lg_cook_complex.cProgramNumber != (uint8_t)EXPRESS_PROGRAM){
lg_cook_complex.iCookTime--;
if(lg_cook_complex.iCookTime > 0) ind_taim(lg_cook_complex.iCookTime, 1);
else{ // Если вышло время приготовления
logic_beep_5();
if(lg_cook_complex.bKeepWarmEnabled == TRUE) logic_go_keepwarm(0); // Если включен подогрев
else logic_mode_standby(0);
}
}
}
break;
}
case STAGE_KEEPWARM: // Подогрев
{
if(++keep_warm_time < (uint16_t)(lg_cook_complex.cKeepWarmTime * 60)) ind_taim(keep_warm_time, 1);
else logic_mode_standby(0);
break;
}
}
}
/**
* BEEP 5 раз по завершению готовки
*/
static inline void logic_beep_5(void)
{
static uint8_t beep_5 = 4;
beep_5 ++;
if(beep_5 > 4){
beep_5 = 0;
timer_init(TIMER_BEEP_5,40,0);
timer_start(TIMER_BEEP_5);
}else if(beep_5 == 4) timer_stop(TIMER_BEEP_5);
BEEP();
}
/**
* BEEP 3 раз при закладки "МАКАРОН"
*/
static inline void logic_beep_3(void)
{
static uint8_t beep_3 = 0;
if(timer_active(TIMER_BEEP_3) == 0){ // Если таймер не включен
beep_3 = 0;
timer_init(TIMER_BEEP_3,40,0);
timer_start(TIMER_BEEP_3);
}
if(beep_3 < 3) BEEP();
if(beep_3 <6) beep_3 ++;
else beep_3 = 0;
}
/**
* Работа ШИМ для нагрева и проверка на ошибки температурного датчика
*/
static inline void logic_4sec_pwm(void)
{
static uint8_t temp_top_2min[60];
if(temp_pwm < 11) temp_pwm ++; else temp_pwm = 0;
Temp(); // Считываем показанаия термодатчиков
temp_top = Temp_GetTopTemp(); // Считываем температуру
temp_bot = Temp_GetBotTemp();
for(uint8_t it=0;it<59;it++) temp_top_2min[it] = temp_top_2min[(it+1)];
temp_top_2min[59] = temp_top;
if(state_cooking != STAGE_ERROR){
if(temp_bot >= 230 || temp_top >= 180) Err_Stop(OVERHEAT_ERR);
}
switch(state_cooking)
{
case STAGE_ERROR:
case STAGE_NONE:
case STAGE_PROGRAM:
case STAGE_POSTPONEMENT: /* Если готовка отключена, установка программы или идет отложенный старт */
{
lg_cook_complex.cExpress = 0;
lg_cook_complex.iBredTaim = 0;
heat_on_off(HEAT_OFF); // Выключаем ТЕНы
break;
}
case STAGE_BOOST: /* Нагрев до кипения перед закладкой продуктов "МАКАРОНЫ" */
{
// if(temp_bot < lg_cook_complex.cBotTempWarm){ // Если текущая температура меньше температуры нагрева
// logic_heat_on(lg_cook_complex.cHeatEnable); break; // Включаем разрешенные нагреватели
// }else if(((temp_top_2min[59] - temp_top_2min[0]) < lg_cook_complex.cTopDelta || \
// (temp_top_2min[59] - temp_top_2min[0]) > 127) && \
// temp_top < lg_cook_complex.cTopTempStat){
// logic_heat_on(lg_cook_complex.cHeatEnable); break;
// }else if(temp_bot < lg_cook_complex.cBotTempStat || temp_top < lg_cook_complex.cTopTempStat){
// if(temp_pwm < (lg_cook_complex.cPWMstat)) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
// else logic_heat_off(); // Выключаем ТЕНы
// break;
// }
/* error 04 29_07_2015 V1_3 */
if(temp_bot < lg_cook_complex.cBotTempWarm){ // Если текущая температура меньше температуры нагрева
logic_heat_on(lg_cook_complex.cHeatEnable); break; // Включаем разрешенные нагреватели 100%
}else if(lg_cook_complex.cCookTemp >= 95 && lg_cook_complex.cCookTemp <= 115){ // Если температура готовки от 95 до 115
if(((temp_top_2min[59] - temp_top_2min[0]) < lg_cook_complex.cTopDelta || \
(temp_top_2min[59] - temp_top_2min[0]) > 127) && \
temp_top < lg_cook_complex.cTopTempStat){
logic_heat_on(lg_cook_complex.cHeatEnable); break;
}else if(temp_bot < lg_cook_complex.cBotTempStat || temp_top < lg_cook_complex.cTopTempStat){
if(temp_pwm < (lg_cook_complex.cPWMstat)) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
break;
}
}else if(lg_cook_complex.cCookTemp > 115){ // При температуре больше 115 градусов
if(temp_bot < lg_cook_complex.cBotTempStat){
if(temp_pwm < (lg_cook_complex.cPWMstat)) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
break;
}
}
/* end error 04 */
state_cooking = STAGE_ENDOFBOOST;
logic_beep_3();
ind_etp(2);
break;
}
case STAGE_ENDOFBOOST: /* Ожидание закладки продуктов */
{
lg_cook_complex.iBredTaim ++;
if(lg_cook_complex.cCookTemp >= 95){ // 29_07_2015 error 04 V1_3
if(temp_pwm < 8) logic_heat_on(HEAT_MAIN); // Включаем
else heat_on_off(HEAT_OFF); // Выключаем ТЕНы
}
if(lg_cook_complex.iBredTaim >= 150) logic_mode_standby(0); // Если прошло 5 минут выкл " МАКАРОНЫ"
break;
}
case STAGE_WARM: /* Нагрев с продуктами до рабочей температуры */
{
if(temp_bot < lg_cook_complex.cBotTempWarm){ // Если текущая температура меньше температуры нагрева
logic_heat_on(lg_cook_complex.cHeatEnable); break; // Включаем разрешенные нагреватели 100%
}else if(lg_cook_complex.cCookTemp >= 95 && lg_cook_complex.cCookTemp <= 115){ // Если температура готовки от 95 до 115
if(((temp_top_2min[59] - temp_top_2min[0]) < lg_cook_complex.cTopDelta || \
(temp_top_2min[59] - temp_top_2min[0]) > 127) && \
temp_top < lg_cook_complex.cTopTempStat){
logic_heat_on(lg_cook_complex.cHeatEnable); break;
}else if(temp_bot < lg_cook_complex.cBotTempStat || temp_top < lg_cook_complex.cTopTempStat){
if(temp_pwm < (lg_cook_complex.cPWMstat)) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
break;
}
}else if(lg_cook_complex.cCookTemp > 115){ // При температуре больше 115 градусов
if(temp_bot < lg_cook_complex.cBotTempStat){
if(temp_pwm < (lg_cook_complex.cPWMstat)) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
break;
}
}
state_cooking = STAGE_STAT;
if(lg_cook_complex.bBoost == TRUE) timer_reset(TIMER_1MIN_START);
ind_etp(2);
break;
}
case STAGE_STAT: /* Поддержание заданной температуры */
{
if(lg_cook_complex.cProgramNumber == (uint8_t)PASTA_PROGRAM){ // Если программа "МАКАРОНЫ" Проверяем открытие крышки
if(lg_cook_complex.cCookTemp >= 95 && lg_cook_complex.cCookTemp <= 115) // 29_07_2015 V1_3
{
if(temp_top < 75){ // Если top температура меньше 70 - крышка открыта
if(temp_pwm < 8) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
break;
}
}
}else if(lg_cook_complex.cProgramNumber == (uint8_t)EXPRESS_PROGRAM){ // Если программа "ЭКСПРЕСС"
lg_cook_complex.iBredTaim ++;
if(lg_cook_complex.cExpress == 0 && temp_bot < lg_cook_complex.cCookTemp) lg_cook_complex.cExpress = 1;
else if((lg_cook_complex.cExpress == 1 && temp_bot > (lg_cook_complex.cCookTemp + 1)) || lg_cook_complex.iBredTaim >= 1800) {
lg_cook_complex.cExpress = 2;
logic_beep_5();
logic_mode_standby(0);
}
}
logic_pwm_regulator(lg_cook_complex.cPWM_kp, (int16_t)lg_cook_complex.cCookTemp);
break;
}
case STAGE_KEEPWARM: /* Подогрев */
{
logic_pwm_regulator(0, (int16_t)lg_cook_complex.cKeepWarmTemp);
break;
}
case STAGE_BREAD_LOAD: /* Поддержание "ХЛЕБ" 1 час 40С */
{
lg_cook_complex.iBredTaim ++;
if(lg_cook_complex.iBredTaim >= 1800){ // Если прошел час
state_cooking = STAGE_WARM;
lg_cook_complex.cHeatEnable = (HEAT_TOP | HEAT_SIDE | HEAT_MAIN); // Включаем все тены
break;
}
logic_pwm_regulator(3, 40);
break;
}
case STAGE_TEST: // TEST TEMPER
{
static uint8_t tst = 0;
if(temp_bot >= 60 || temp_top >= 60) heat_on_off(HEAT_OFF); // Выключаем нагреватели
if(test_ind_on != 1){
if(tst == 0) {
tst = 1;
Ind_LED_On(LED_IMG_ML);
Ind_LED_Off(LED_IMG_K_ML);
ind_temperature(temp_bot, 1);
}else{
tst = 0;
Ind_LED_On(LED_IMG_K_ML);
Ind_LED_Off(LED_IMG_ML);
ind_temperature(temp_top, 1);
}
}
break;
}
}
}
/**
* PWM регулятор поддержания температуры
*/
static inline void logic_pwm_regulator(uint8_t k_t, int16_t t_reg)
{
static const int16_t step_pwm[5][10] = {
{-1,-1,1,1,2,2,3,3,20,20}, /* 0 - standart */
{-30,-30,1,1,2,2,3,3,20,20}, /* 1 - pasta */ /* -50,-50 29_07_2015 V1_3 */
{-1,1,2,3,4,5,6,6,20,20}, /* 2 - выпечка, хлеб */
{2,4,6,12,20,20,20,20,20,20}, /* 3 - йогурт, растойка */
{2,4,6,7,8,8,9,9,10,12}}; /* 4 - мультиповат */
// PWM 0% /
if(temp_bot > (uint8_t)(t_reg - step_pwm[k_t][0])){ // Если измеренная температура на градус выше рабочей температуры
logic_heat_off(); return; // Выключаем ТЕНы
}
// PWM 8% /
else if(temp_bot > (uint8_t)(t_reg - step_pwm[k_t][1])){ // Если измеренная температура на градус ниже рабочей температуры
if(temp_pwm < 1) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
return;
}
// PWM 16% /
else if(temp_bot > (uint8_t)(t_reg - step_pwm[k_t][2])){ // Если измеренная температура на 2 градусa ниже рабочей температуры
if(temp_pwm < 2) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
return;
}
// PWM 25% /
else if(temp_bot > (uint8_t)(t_reg - step_pwm[k_t][3])){ // Если измеренная температура на 3 градусa ниже рабочей температуры
if(temp_pwm < 3) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
return;
}
// PWM 33% /
else if(temp_bot > (uint8_t)(t_reg - step_pwm[k_t][4])){ // Если измеренная температура на градус ниже рабочей температуры
if(temp_pwm < 4) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
return;
}
// PWM 41% /
else if(temp_bot > (uint8_t)(t_reg - step_pwm[k_t][5])){ // Если измеренная температура на 2 градусa ниже рабочей температуры
if(temp_pwm < 5) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
return;
}
// PWM 50% /
else if(temp_bot > (uint8_t)(t_reg - step_pwm[k_t][6])){ // Если измеренная температура на 3 градусa ниже рабочей температуры
if(temp_pwm < 6) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
return;
}
// PWM 58% /
else if(temp_bot > (uint8_t)(t_reg - step_pwm[k_t][7])){ // Если измеренная температура на 3 градусa ниже рабочей температуры
if(temp_pwm < 7) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
return;
}
// PWM 66% /
else if(temp_bot > (uint8_t)(t_reg - step_pwm[k_t][8])){ // Если измеренная температура на 3 градусa ниже рабочей температуры
if(temp_pwm < 8) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
return;
}
// PWM 83% /
else if(temp_bot > (uint8_t)(t_reg - step_pwm[k_t][9])){ // Если измеренная температура на 3 градусa ниже рабочей температуры
if(temp_pwm < 10) logic_heat_on(lg_cook_complex.cHeatEnable); // Включаем разрешенные нагреватели
else logic_heat_off(); // Выключаем ТЕНы
return;
}
// PWM 100% /
else logic_heat_on(lg_cook_complex.cHeatEnable); return; // Включаем разрешенные нагреватели
}
/**
* Включаем необходимые тены и проверяем допустимую температуру
*/
static void logic_heat_on(uint8_t heat_state){
if(temp_bot > lg_cook_complex.cCookTemp + 45) Err_Stop(EMPTY_POT_ERR);
else heat_on_off(heat_state);
}
/**
* Выключаем необходимые тены
*/
static void logic_heat_off(void){
if(lg_cook_complex.cProgramNumber != (uint8_t)PASTRY_PROGRAM ||\
lg_cook_complex.cProgramNumber != (uint8_t)BREAD_PROGRAM ||\
temp_top > 180) heat_on_off(HEAT_OFF);
else heat_on_off((lg_cook_complex.cHeatEnable & 0x06));
}
/**
* Загрузка параметров выбранной программы готовки
*/
static void logic_load_menu_prog(cookcomplexprog *adr_prog)
{
uint8_t i = adr_prog->cProgramNumber;
adr_prog->cCookTemp = cook_program[i].cCookTemp;
adr_prog->cMinValueTemp = cook_program[i].cMinValueTemp;
adr_prog->cMaxValueTemp = cook_program[i].cMaxValueTemp;
adr_prog->cHeatEnable = cook_program[i].cHeatEnable;
adr_prog->cTopTempWarm = cook_program[i].cTopTempWarm;
adr_prog->cBotTempWarm = cook_program[i].cBotTempWarm;
adr_prog->cTopTempStat = cook_program[i].cTopTempStat;
adr_prog->cBotTempStat = cook_program[i].cBotTempStat;
adr_prog->cTopDelta = cook_program[i].cTopDelta;
adr_prog->cPWMstat = cook_program[i].cPWMstat;
adr_prog->cPWM_kp = cook_program[i].cPWM_kp;
adr_prog->bBoost = cook_program[i].bBoost;
adr_prog->iMinTime = cook_program[i].iMinTime;
adr_prog->iMaxTime = cook_program[i].iMaxTime;
adr_prog->cStepTime[0] = cook_program[i].cStepTime[0];
adr_prog->cStepTime[1] = cook_program[i].cStepTime[1];
adr_prog->iCookTime = cook_program[i].iCookProductsTime; // Время приготовления
adr_prog->cKeepWarmTime = cook_program[i].cKeepWarmTime; // Время подогрева в часах
if(cook_program[i].cKeepWarmTime > 0)adr_prog->bKeepWarmEnabled = TRUE;
else adr_prog->bKeepWarmEnabled = FALSE;
adr_prog->iPostPonementTime = 60;
adr_prog->bPostPonementEnabled = cook_program[i].bPostPonement;
}
/**
* Ввод времени в меню выбора программы
*/
static void logic_time_plas(uint8_t min_clok, uint8_t beep){
if(beep == 1) BEEP();
if(min_clok == 0){ // Если прибавляем минуты
if(fl_load_delay_taim == 0){ // Если время готовки
if(lg_cook_complex.iCookTime < lg_cook_complex.iMaxTime){ // Если время готовки меньше максимального времени
if(lg_cook_complex.iCookTime < 60){
if(lg_cook_complex.iCookTime%lg_cook_complex.cStepTime[0] == 0){
lg_cook_complex.iCookTime +=lg_cook_complex.cStepTime[0];
}else lg_cook_complex.iCookTime +=(lg_cook_complex.cStepTime[0]-\
(lg_cook_complex.iCookTime%lg_cook_complex.cStepTime[0]));
}else{
if(lg_cook_complex.iCookTime%lg_cook_complex.cStepTime[1] == 0){
lg_cook_complex.iCookTime +=lg_cook_complex.cStepTime[1];
}else lg_cook_complex.iCookTime +=(lg_cook_complex.cStepTime[1]-\
(lg_cook_complex.iCookTime%lg_cook_complex.cStepTime[1]));
}
}else lg_cook_complex.iCookTime = lg_cook_complex.iMinTime; // Если время готовки максимальное сбрасываем в минимальное
}else{ // Если время отложенного старта
if(lg_cook_complex.iPostPonementTime < (24*60)) lg_cook_complex.iPostPonementTime += 10; // Если время отложенного старта меньше максимального
else lg_cook_complex.iPostPonementTime = 10; // Если время максимально сбрасывем в минимальное
}
}else{ // Если прибавляем часы
if(fl_load_delay_taim == 0){ // Если время готовки
if(lg_cook_complex.iCookTime < lg_cook_complex.iMaxTime){ // Если время готовки меньше максимального времени
if((lg_cook_complex.iCookTime + 60) < lg_cook_complex.iMaxTime) lg_cook_complex.iCookTime += 60;
else lg_cook_complex.iCookTime = lg_cook_complex.iMaxTime;
}else lg_cook_complex.iCookTime = lg_cook_complex.iMinTime; // Если время готовки максимальное сбрасываем в минимальное
}else{ // Если время отложенного старта
if(lg_cook_complex.iPostPonementTime < (24*60)){ // Если время отложенного старта меньше максимального
if((lg_cook_complex.iPostPonementTime + 60) < (24*60)) lg_cook_complex.iPostPonementTime += 60;
else lg_cook_complex.iPostPonementTime = (24*60);
}else lg_cook_complex.iPostPonementTime = 10; // Если время максимально сбрасывем в минимальное
}
}
blank_faze_time = 0;
if(fl_load_delay_taim == 0) ind_taim(lg_cook_complex.iCookTime, 1);
else ind_taim(lg_cook_complex.iPostPonementTime, 1);
timer_reset(TIMER_30SEK);
if(timer_active(TIMER_30SEK) == 0) timer_start(TIMER_30SEK);
}
/**
* Установка флага ввода времени отложенного старта
*/
static void logic_delay_taim_key(uint8_t st_flag, uint8_t beep){
if(lg_cook_complex.bPostPonementEnabled == TRUE){ // Если возможна устанока отложенного старта
if(st_flag != fl_load_delay_taim){ // Если флаг изменился
fl_load_delay_taim = st_flag;
if(beep == 1) BEEP();
if(fl_load_delay_taim == 1){
Ind_LED_On(LED_DEF_START);
Ind_LED_On(LED_LOAD_START_1);
Ind_LED_On(LED_LOAD_START_2);
Ind_LED_Off(LED_TIME_LOAD);
ind_taim(lg_cook_complex.iPostPonementTime, 1);
timer_reset(TIMER_30SEK);
if(timer_active(TIMER_30SEK) == 0) timer_start(TIMER_30SEK);
}
blank_faze_time = 0;
}
}
}
/**
* Ввод температуры в режиме меню для "мультиповар"
*/
static void logic_temp_plas(uint8_t beep){
if(lg_cook_complex.cProgramNumber == (uint8_t)MULTICOOK_PROGRAM){ // Если "мультиповар"
if(beep == 1){
BEEP();
if(lg_cook_complex.cCookTemp < lg_cook_complex.cMaxValueTemp)/*lg_cook_complex.cCookTemp += 5; //5C */lg_cook_complex.cCookTemp ++; //1C ????????????????????????????????
else lg_cook_complex.cCookTemp = lg_cook_complex.cMinValueTemp;
}else{
if(lg_cook_complex.cCookTemp < lg_cook_complex.cMaxValueTemp){
if((lg_cook_complex.cCookTemp%5) == 0) lg_cook_complex.cCookTemp +=5; // Если остаток равен "0" + 5C
else lg_cook_complex.cCookTemp += (5-(lg_cook_complex.cCookTemp%5)); // Прибавляем для кратности 5С
}else lg_cook_complex.cCookTemp = lg_cook_complex.cMinValueTemp;
}
lg_cook_complex.cBotTempWarm = lg_cook_complex.cCookTemp - 6;
lg_cook_complex.cBotTempStat = lg_cook_complex.cCookTemp - 1;
blank_faze_temp = 0;
ind_temperature(lg_cook_complex.cCookTemp, 1);
Ind_LED_On(LED_IMG_TEMP);
Ind_LED_On(LED_IMG_GRAD);
timer_reset(TIMER_30SEK);
if(timer_active(TIMER_30SEK) == 0) timer_start(TIMER_30SEK);
}
}
/**
* Функция вызываемая таймером BLANK
*/
static inline void blank_menu(void)
{
if(led_blank_state == 0){
if(blank_faze == 0) {
Ind_LED_On(LED_MULTICOOK);
Ind_LED_On(LED_IMG_TEMP);
Ind_LED_On(LED_IMG_GRAD);
if(fl_load_delay_taim == 0) ind_taim(lg_cook_complex.iCookTime, 1);
else ind_taim(lg_cook_complex.iPostPonementTime, 1);
ind_temperature(lg_cook_complex.cCookTemp, 1);
}else {
Ind_LED_Off(LED_MULTICOOK);
if(blank_faze_time == 1) ind_taim(lg_cook_complex.iCookTime, 0);
else{
if(fl_load_delay_taim == 0) ind_taim(lg_cook_complex.iCookTime, 1);
else ind_taim(lg_cook_complex.iPostPonementTime, 1);
}
if(blank_faze_temp == 1){
Ind_LED_Off(LED_IMG_TEMP);
Ind_LED_Off(LED_IMG_GRAD);
ind_temperature(lg_cook_complex.cCookTemp, 0);
}else{
Ind_LED_On(LED_IMG_TEMP);
Ind_LED_On(LED_IMG_GRAD);
ind_temperature(lg_cook_complex.cCookTemp, 1);
}
}
}else if(led_blank_state == 21){
if(blank_faze == 1) Ind_LED_Off(LED_START);
else Ind_LED_On(LED_START);
}else if(led_blank_state == 30){
if(blank_faze == 1) Ind_LED_Off(LED_MP);
else Ind_LED_On(LED_MP);
}else if(led_blank_state == 32){
if(blank_faze == 1) {
if(state_cooking == STAGE_STAT || lg_cook_complex.bBoost == FALSE) Ind_LED_Off(LED_MP);
Ind_LED_Off(LED_IMG_PAR);
}else{
Ind_LED_On(LED_MP);
Ind_LED_On(LED_IMG_PAR);
}
}else if(led_blank_state == 33){
if(blank_faze == 1){
ind_taim(lg_cook_complex.iCookTime, 0);
logic_prog_on_of(lg_cook_complex.cProgramNumber, 0);
}else{
ind_taim(lg_cook_complex.iCookTime, 1);
logic_prog_on_of(lg_cook_complex.cProgramNumber, 1);
}
}else if(led_blank_state == 34){
if(blank_faze == 1) Ind_LED_Off(LED_IMG_PAR); else Ind_LED_On(LED_IMG_PAR);
}else if(led_blank_state == 36){
if(blank_faze == 1){
ind_blank_express(0);
logic_prog_on_of(lg_cook_complex.cProgramNumber, 0);
}else{
ind_blank_express(1);
logic_prog_on_of(lg_cook_complex.cProgramNumber, 1);
}
}else if(led_blank_state == 37) {
if(blank_faze == 1) ind_taim(keep_warm_time, 0); else ind_taim(keep_warm_time, 1);
}else if(led_blank_state == 38) {
if(blank_faze == 1) Ind_LED_Off(LED_TIME_LOAD); else Ind_LED_On(LED_TIME_LOAD);
}else if(led_blank_state == 39){
if(blank_faze == 1){
Ind_LED_Off(LED_MP);
Ind_LED_Off(LED_LOAD_START_1);
Ind_LED_Off(LED_LOAD_START_2);
}else{
Ind_LED_On(LED_MP);
Ind_LED_On(LED_LOAD_START_1);
Ind_LED_On(LED_LOAD_START_2);
}
}else if(led_blank_state == 40){
if(blank_faze == 1) ind_paring(1); else ind_paring(0);
}else if(led_blank_state > 0 && led_blank_state < 16){
if(blank_faze == 0) {
logic_prog_on_of(led_blank_state, 1);
if(fl_load_delay_taim == 0) ind_taim(lg_cook_complex.iCookTime, 1);
else ind_taim(lg_cook_complex.iPostPonementTime, 1);
}else{
logic_prog_on_of(led_blank_state, 0);
if(blank_faze_time == 1) ind_taim(lg_cook_complex.iCookTime, 0);
else{
if(fl_load_delay_taim == 0) ind_taim(lg_cook_complex.iCookTime, 1);
else ind_taim(lg_cook_complex.iPostPonementTime, 1);
}
}
}
if(blank_faze == 0){
blank_faze = 1;
blank_faze_time = 1;
blank_faze_temp = 1;
}else{
blank_faze = 0;
blank_faze_time = 0;
blank_faze_temp = 0;
}
}
/**
* Установка параметров для функции void blank_menu(void)
*/
static void logic_led_start_bl(uint8_t stat)
{
if(stat != 20){
timer_reset(TIMER_LEDS_BLANK);
timer_start(TIMER_LEDS_BLANK);
if(stat < 16){
Ind_LED_On(LED_MULTICOOK);
Ind_LED_On(LED_MILK_PORRIDGE);
Ind_LED_On(LED_STEW);
Ind_LED_On(LED_FRY_1);
Ind_LED_On(LED_FRY_2);
Ind_LED_On(LED_SOUP);
Ind_LED_On(LED_STEAM);
Ind_LED_On(LED_PASTA);
Ind_LED_On(LED_SOAKING);
Ind_LED_On(LED_COOKING);
Ind_LED_On(LED_PASTRY);
Ind_LED_On(LED_CEREALS);
Ind_LED_On(LED_PILAW);
Ind_LED_On(LED_YOGURT);
Ind_LED_On(LED_PIZZA);
Ind_LED_On(LED_BREAD);
Ind_LED_On(LED_DESSERT);
Ind_LED_On(LED_IMG_ML);
Ind_LED_On(LED_IMG_K_ML);
Ind_LED_On(LED_MP);
Ind_LED_On(LED_TIME_LOAD);
logic_prog_on_of(stat, 0);
ind_taim(lg_cook_complex.iCookTime, 1);
}
}else{
timer_stop(TIMER_LEDS_BLANK);
Ind_Clr();
}
led_blank_state = stat;
blank_faze = 0;
blank_faze_time = 0;
blank_faze_temp = 0;
}
/**
* logic_prog_on_of
*/
static inline void logic_prog_on_of(uint8_t n_prog, uint8_t state)
{
if(state == 0){
switch(n_prog)
{
case 0: Ind_LED_Off(LED_MULTICOOK); break;
case 1: Ind_LED_Off(LED_MILK_PORRIDGE); break;
case 2: Ind_LED_Off(LED_STEW); break;
case 3: Ind_LED_Off(LED_FRY_1); Ind_LED_Off(LED_FRY_2); break;
case 4: Ind_LED_Off(LED_SOUP); break;
case 5: Ind_LED_Off(LED_STEAM); break;
case 6: Ind_LED_Off(LED_PASTA); break;
case 7: Ind_LED_Off(LED_SOAKING); break;
case 8: Ind_LED_Off(LED_COOKING); break;
case 9: Ind_LED_Off(LED_PASTRY); break;
case 10: Ind_LED_Off(LED_CEREALS); break;
case 11: Ind_LED_Off(LED_PILAW); break;
case 12: Ind_LED_Off(LED_YOGURT); break;
case 13: Ind_LED_Off(LED_PIZZA); break;
case 14: Ind_LED_Off(LED_BREAD); break;
case 15: Ind_LED_Off(LED_DESSERT); break;
case 16: Ind_LED_Off(LED_IMG_EXPRES); break;
}
}else{
switch(n_prog)
{
case 0: Ind_LED_On(LED_MULTICOOK); break;
case 1: Ind_LED_On(LED_MILK_PORRIDGE); break;
case 2: Ind_LED_On(LED_STEW); break;
case 3: Ind_LED_On(LED_FRY_1); Ind_LED_On(LED_FRY_2); break;
case 4: Ind_LED_On(LED_SOUP); break;
case 5: Ind_LED_On(LED_STEAM); break;
case 6: Ind_LED_On(LED_PASTA); break;
case 7: Ind_LED_On(LED_SOAKING); break;
case 8: Ind_LED_On(LED_COOKING); break;
case 9: Ind_LED_On(LED_PASTRY); break;
case 10: Ind_LED_On(LED_CEREALS); break;
case 11: Ind_LED_On(LED_PILAW); break;
case 12: Ind_LED_On(LED_YOGURT); break;
case 13: Ind_LED_On(LED_PIZZA); break;
case 14: Ind_LED_On(LED_BREAD); break;
case 15: Ind_LED_On(LED_DESSERT); break;
case 16: Ind_LED_On(LED_IMG_EXPRES); break;
}
}
}
//===============================================================================
/**
* Коллбэк для таймера-пищалки
*/
static void cb_beep_off(uint32_t timer){
if(TIMER_BEEP == timer){
timer_stop(timer);
timer_reset(timer);
Buz_Off();
}
}
/**
* Пэринг ble
*/
static void logic_paring(void){
BEEP();
Clk_Delay(25);
BEEP();
Clk_Delay(25);
BEEP();
state_mode = PARING_MODE; // Состояние пэринга
state_cooking = STAGE_PARING;
timer_reset(TIMER_PARING_TIMER); // Запускаем таймер пэринга
timer_start(TIMER_PARING_TIMER);
logic_led_start_bl(20); // Сбрасываем индикацию
logic_led_start_bl(40); // Индикация перинга
ind_paring(0);
}
/**
* Унпэринг ble
*/
static void logic_unparing(void){
BEEP_BIG_LONG();
state_mode = UNPARING_MODE; // Состояние унпэринга
timer_reset(TIMER_UNPARING_TIMER); // Запускаем таймер унпэринга
timer_start(TIMER_UNPARING_TIMER);
}
/*=======================================================================================
* API for R4S
* The all Set...() functions return a true/false (Success/Fail) value
=======================================================================================*/
/**
* Get firmvare version
*/
uint16_t Appl_GetVersion(void){
return FIRMWARE_VER;
}
/**
* Start
*/
bool Appl_Start(void){
if(state_mode == MENU_MODE){
if(lg_cook_complex.cProgramNumber == (uint8_t)EXPRESS_PROGRAM){
logic_cooking_express(1);
}else if(lg_cook_complex.cProgramNumber == (uint8_t)KEEP_PROGRAM){ // 29_07_2015 V1_3
logic_go_keepwarm(1);
}
else logic_mode_cooking(1);
return true;
}else if(state_mode == POWER_MODE){
application_power_mode_go(1); // Продолжение работы программы
return true;
}else if(state_mode == COOKING_MODE){
logic_go_time_pasta(1);
return true;
}
return false;
}
/**
* Stop
*/
bool Appl_Stop(void){
if(state_mode != ERROR_MODE) logic_mode_standby(1); // 29_07_2015 V1_3
return true;
}
/**
* Get device state
*/
uint8_t Appl_GetState(void){
switch(state_cooking){
case STAGE_NONE: return APPL_BEGIN_STATE;
case STAGE_PROGRAM: return APPL_PROGRAM_STATE;
case STAGE_POSTPONEMENT: return APPL_START_DELAY_STATE;
case STAGE_BOOST: return APPL_BOOST_STATE;
case STAGE_ENDOFBOOST: return APPL_WAIT_STATE;
case STAGE_BREAD_LOAD:
case STAGE_WARM:
case STAGE_STAT: return APPL_COOKING_STATE;
case STAGE_KEEPWARM: return APPL_REHEAT_STATE;
case STAGE_ERROR: return APPL_ERROR_STATE;
case STAGE_PARING: return APPL_PAIRING_STATE;
case STATE_POWER:
{
if(lg_cook_complex.cPower_flag != 1) return APPL_POWER;
return APPL_POWER_STOP;
}
case STAGE_TEST: return APPL_TEST_STATE;
}
return APPL_ERROR_STATE;
}
/**
* Set program
*/
bool Appl_SetProgram(uint8_t prog){
if((state_mode == STANDBY_MODE || state_mode == MENU_MODE) && prog < 18){ // 17 - 29_07_2015 V1_3
if(prog < 16){
state_mode = MENU_MODE;
state_cooking = STAGE_PROGRAM;
lg_cook_complex.cProgramNumber = prog;
logic_mode_menu(1);
return true;
}else{ // Express
state_mode = MENU_MODE;
state_cooking = STAGE_PROGRAM;
lg_cook_complex.cProgramNumber = prog;
return true;
}
}
return false;
}
/**
* Get program
*/
uint8_t Appl_GetProgram(void){
return lg_cook_complex.cProgramNumber;
}
/**
* Set cooking temperature
*/
bool Appl_SetCookTemp(uint8_t temp){
if(state_mode == COOKING_MODE || state_mode == MENU_MODE){ // Если режим варки или режим меню
if(state_mode == MENU_MODE) timer_reset(TIMER_30SEK); // Сбрасываем таймер перехода в STANDBY_MODE
if(lg_cook_complex.cMinValueTemp <= temp && lg_cook_complex.cMaxValueTemp >= temp){ // Проверка задаваемой температуры
uint8_t temp_set_warm;// 29_07_2015 V1_3
if(state_mode == COOKING_MODE){
timer_reset(TIMER_ERROR);
timer_start(TIMER_ERROR);
}
lg_cook_complex.cCookTemp = temp; // Меняем температуру
temp_set_warm = cook_program[lg_cook_complex.cProgramNumber].cCookTemp - cook_program[lg_cook_complex.cProgramNumber].cBotTempWarm;
if(temp > temp_set_warm) lg_cook_complex.cBotTempWarm = temp - temp_set_warm; // 29_07_2015 V1_3
else lg_cook_complex.cBotTempWarm = 10; // 29_07_2015 V1_3
//lg_cook_complex.cBotTempWarm = temp - (cook_program[lg_cook_complex.cProgramNumber].cCookTemp - cook_program[lg_cook_complex.cProgramNumber].cBotTempWarm); // 29_07_2015 V1_3
lg_cook_complex.cBotTempStat = temp - (cook_program[lg_cook_complex.cProgramNumber].cCookTemp - cook_program[lg_cook_complex.cProgramNumber].cBotTempStat);
if(lg_cook_complex.cProgramNumber == (uint8_t)MULTICOOK_PROGRAM){ // Если программа мультиповар
ind_temperature(lg_cook_complex.cCookTemp, 1); // Выводим значение темперытуры
Ind_LED_On(LED_IMG_TEMP);
Ind_LED_On(LED_IMG_GRAD);
}
return true;
}
}
return false;
}
/**
* Get cooking temperature
*/
uint8_t Appl_GetCookTemp(void){
if(lg_cook_complex.cProgramNumber == (uint8_t)KEEP_PROGRAM){ // 29_07_2015 V1_3
return 70;
}
return lg_cook_complex.cCookTemp;
}
/**
* Set cooking time in minutes
*/
bool Appl_SetCookTime(uint16_t time){
if(state_mode == COOKING_MODE || state_mode == MENU_MODE){ // Если режим варки или режим меню
if(state_mode == MENU_MODE) timer_reset(TIMER_30SEK); // Сбрасываем таймер перехода в STANDBY_MODE
if(lg_cook_complex.iMinTime <= time && lg_cook_complex.iMaxTime >= time){ // Проверка задаваемого вермени варки
lg_cook_complex.iCookTime = time;
if(state_cooking != STAGE_POSTPONEMENT) ind_taim(lg_cook_complex.iCookTime, 1); // Выводим индикацию установленого времени
return true;
}
}
return false;
}
/**
* Get cooking time in minutes
*/
uint16_t Appl_GetCookTime(void){
return lg_cook_complex.iCookTime;
}
/**
* Set defered start time in minutes, 0 if disable
*/
bool Appl_SetDeferedStart(uint16_t time){
if(state_mode == MENU_MODE){
if(time == 0){
fl_load_delay_taim = 0;
return true;
}else{
if(lg_cook_complex.bPostPonementEnabled == TRUE && time <= (24*60)){ // Если возможна устанока отложенного старта и коректное время
fl_load_delay_taim = 1;
lg_cook_complex.iPostPonementTime = time;
return true;
}
}
}
return false;
}
/**
* Get defered start time in minutes, 0 if disable
*/
uint16_t Appl_GetDeferedStart(void){
if(lg_cook_complex.bPostPonementEnabled == FALSE) return 0;
return lg_cook_complex.iPostPonementTime;
}
/**
* Get time to end of cooking in minutes
*/
uint16_t Appl_GetEndTime(void){
if(state_cooking == STAGE_POSTPONEMENT) return lg_cook_complex.iPostPonementTime; // оставшееся время варки и время отложенного старты
else // 29_07_2015 V1_3
{
if(lg_cook_complex.cProgramNumber == (uint8_t)KEEP_PROGRAM) return keep_warm_time;
return lg_cook_complex.iCookTime;
}
//else return lg_cook_complex.iCookTime; // 29_07_2015 V1_3
}
/**
* Set reheat state
*/
bool Appl_SetReheat(uint8_t state){
switch(state_mode){ // проверка возможности установки подогрева
case MENU_MODE:
{
timer_reset(TIMER_30SEK); // Сбрасываем таймер перехода в STANDBY_MODE
if(state == 0) {
lg_cook_complex.bKeepWarmEnabled = FALSE;
return true;
}else if(state == 1 && lg_cook_complex.cKeepWarmTime > 0){
lg_cook_complex.bKeepWarmEnabled = TRUE;
return true;
}else return false;
}
case COOKING_MODE:
{
/* v1_3 */
timer_reset(TIMER_BUTTONS_HANDLE); // Для отмены при удержание
timer_stop(TIMER_BUTTONS_HANDLE);
if(lg_cook_complex.bKeepWarmEnabled == TRUE && state == 0){ // Если включен выключаем
BEEP();
lg_cook_complex.bKeepWarmEnabled = FALSE;
Ind_LED_Off(LED_ESC);
return true;
}else if(lg_cook_complex.bKeepWarmEnabled == FALSE && state == 1){ // Включаем
if(lg_cook_complex.cKeepWarmTime > 0){ // Если разрешен подогрев
BEEP();
lg_cook_complex.bKeepWarmEnabled = TRUE;
Ind_LED_On(LED_ESC);
return true;
}
}
//logic_on_off_keepwarm(1); v1_3
return false;
}
default: break;
}
return false;
}
/**
* Get reheat state
*/
uint8_t Appl_GetReheat(void){
if(lg_cook_complex.bKeepWarmEnabled == TRUE) return APPL_REHEAT_ON;
return APPL_REHEAT_OFF;
}
/**
* Get current time of reheat in minutes
*/
uint16_t Appl_GetReheatTime(void){
return keep_warm_time;
}
/**
* Get heater position
*/
uint8_t Appl_GetPosition(void){
return APPL_BOT_POSITION;
}
/**
* Get error
*/
uint8_t Appl_GetError(void){
return error;
}
/**
* Return a state of the unpairing flag
*/
bool Appl_IsUnpairing(void){
if(state_mode == UNPARING_MODE) return true;
return false;
}
/**
* Clear unpairing flag
*/
void Appl_ClrUnpairing(void){
}
/**
* Get power
*/
uint8_t Appl_GetPower(void){
return power_down;
}
/**
* Get power cnt
*/
uint8_t Appl_GetPower_cnt(void){
return lg_cook_complex.cPower_cnt;
}
/*=====================================================================================*/
