Программный модуль для мультиварки RMK-CB391S. Версия 1.7
ПО является неотъемлемой частью мультиварки RMK-CB391S, отдельно потребителю не поставляется и эксплуатируется только в составе устройства.
Фрагмент исходного кода
////////////////////////////////////////////////////////////////
// RMK-CB391S
//v1.7
////////////////////////////////////////////////////////////////
/*==============================================================
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 "radio_fm.h"
#include "timer.h"
#include "err.h"
#include "power_down.h"
/*==============================================================
Define
==============================================================*/
/*
* Включение пищалки
*/
#ifdef BEEP_ON
#define BEEP_BIG_LONG() {Buz_beep(BUZ_BIG_LONG_BEEP);}
#define BEEP_LONG() {Buz_beep(BUZ_LONG_BEEP);}
#define BEEP() {Buz_beep(BUZ_BEEP);}
#else
#define BEEP_BIG_LONG() {}
#define BEEP_LONG() {}
#define BEEP() {}
#endif
#define BEEP_NOT ((uint8_t)0)
#define BEEP_YES ((uint8_t)1)
/*==============================================================
static functions
==============================================================*/
static void application_timers_handler(void);
static void logic_commands(void);
static void logic_mode_menu(uint8_t beep);
static void logic_sound(uint8_t beep);
static void logic_sound_izm(void);
static void logic_sound_save(uint8_t key);
static void logic_menu_taim(uint8_t beep);
static void logic_menu_clok_min(void);
static void logic_menu_izm_tain(uint8_t kn_en);
static void logic_menu_temp(uint8_t beep);
static void logic_menu_produkt(uint8_t beep);
static void logic_mode_cooking(uint8_t beep);
static void logic_go_start(void);
static void logic_go_delay_start(void);
static void logic_ind_delay_i_start(void);
static void logic_on_off_keepwarm(uint8_t beep);
static void logic_go_keepwarm(uint8_t beep);
static void logic_cooking_express(uint8_t beep);
static void logic_go_time_pasta(uint8_t beep);
static void appl_paring(void);
static void appl_unparing(void);
static void logic_tim_1min(void);
static void logic_mode_radio(uint8_t beep);
static void logic_off_radio(uint8_t beep);
static void logic_radio_izm_chast(void);
static void logic_radio_volume(uint8_t beep);
static void logic_radio_seve(uint8_t beep);
static void logic_radio_search(uint8_t beep);
static void logic_radio_search_stop(uint8_t beep);
static void application_power_down(void);
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
==============================================================*/
volatile logic_state_mode state_mode = STANDBY_MODE, // Настоящее состояние мультиварки
power_state_mode = STANDBY_MODE;
volatile cookcomplexprog lg_cook_complex; // Параметры установленной программы готовки
volatile uint8_t state_cooking = STAGE_NONE; // Cостояние процесса готовки
volatile uint8_t number_radio_st = 1;
static uint8_t fl_nimber_beep = 0,
fl_radio_power = 0,
fl_mode_radio = 0,
fl_active_radio = 0,
fl_search_radio = 0,
fl_kn_search = 0,
error = 0, // Ошибка
power_taim = 0,
power_down = 0,
power_state_cooking = STAGE_NONE,
test_ind_on = 0;
static uint16_t keep_warm_time = 0, // Время подогрева
radio_chast = 0,
radio_vol = 8,
sound_on_off = 0,
test_en_key = 0;
volatile uint16_t master_shef_time, master_shef_temp;
/*==============================================================
init functions
==============================================================*/
/*
* Инит перефирии
*/
void Application_Init(void)
{
power_state state_power;
Clk_Init();
Temp_Init();
Heat_Init();
Buz_Init();
Ind_Init();
radio_fm_init();
radio_chast = radio_read_stations(number_radio_st);
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_60SEK,TIMER_SECOND(60),0); // 60s 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_BUTTUN_EN,5,0); // 50ms Обработка кнопки на энкодере
timer_start(TIMER_BUTTUN_EN);
timer_init(TIMER_5SEC_MENU,TIMER_SECOND(5),0); // 5S Меню
timer_start(TIMER_5SEC_MENU);
timer_init(TIMER_BEEP_3_10,TIMER_SECOND(10),0);
timer_init(TIMER_POWER_1_MIN,TIMER_MINUTE(1),0); // Время для режима перебоя питания
timer_init(TIMER_TEST_MODE,TIMER_MINUTE(2),0); // Время работы тестового режима
timer_init(TIMER_SOUND_ON_OFF,TIMER_SECOND(5),0); // Время режима настройки звуковых сигналов
timer_init(TIMER_ERROR, TIMER_MINUTE(5),0);
BEEP_LONG(); // Длинный сигнал
Ind_Set();
Ind_Release(); // Обновление дисплея
Clk_Delay(50);
Ind_Clr();
if(Buz_get() == BUZZER_OFF) Ind_LED_On(LED_SOUND_OFF);
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((cookcomplexprog *)&lg_cook_complex, \
(logic_state_mode *)&state_mode, \
(uint8_t *)&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(); ind_blank1(BL1_MP_DELAY); break;// Запуск отложенного старта
}
}
else if(state_power == STATE_DOWN_LONG) // Long перебой индикация паузы программы
{
power_read_params((cookcomplexprog *)&lg_cook_complex, \
(logic_state_mode *)&state_mode, \
(uint8_t *)&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: ind_blank1(BL1_TAIM); break;
}
}
BEEP();
}
}
if(Temp_GetBotTemp() < 5) Err_Stop(BOT_TEMP_SENSOR_ERR); // Ошибка датчика BOT
if(Temp_GetTopTemp() < 5) Err_Stop(TOP_TEMP_SENSOR_ERR); // Ошибка датчика TOP
}
////////////////////////////////////////////////////////////////
void Application(void)
{
R4S(); // Обработка радиокоманд
application_timers_handler(); // Обработка таймеров
logic_commands(); // Обработка пользовательских команд
application_power_down(); // Обработка пропадания питания
}
////////////////////////////////////////////////////////////////
/*
* Код обработчика таймеров
*/
static void logic_out_m_sh(void)
{
ind_blank1(BL_CLEAR);
Ind_LED_On(LED_TIME_LOAD);
if(state_cooking == STAGE_STAT || lg_cook_complex.bBoost == FALSE){ // Если идет отсчет времени
ind_blank1(BL_MP);
}else{
Ind_LED_On(LED_MP);
ind_blank1(BL1_TAIM);
}
if(keyb_en_adr() == (uint16_t*)&master_shef_time){ // Если изменялось время приготовления
if(master_shef_time > (2*60) && lg_cook_complex.cCookTemp >= 130) master_shef_time = (2*60);
lg_cook_complex.iCookTime = master_shef_time;
}
if(keyb_en_adr() == (uint16_t*)&master_shef_temp){ // Если изменялясь температура приготовления
if(master_shef_temp >= 130 && lg_cook_complex.iCookTime > (2*60)) lg_cook_complex.iCookTime = (2*60);
if(master_shef_temp < 80){ // Если установлена температура ниже 80 градусов
if(lg_cook_complex.bKeepWarmEnabled == TRUE){ // Отключаем подогрев
lg_cook_complex.bKeepWarmEnabled = FALSE;
Ind_LED_Off(LED_HEATING);
Ind_LED_Off(LED_ESC);
}
}
if(master_shef_temp > cook_temp_d_warm()){
lg_cook_complex.cBotTempWarm = master_shef_temp - cook_temp_d_warm();
}else lg_cook_complex.cBotTempWarm = 10;
lg_cook_complex.cBotTempStat = master_shef_temp - cook_temp_d_stat();
lg_cook_complex.cCookTemp = master_shef_temp;
lg_cook_complex.cTopTempStat = cook_param_get_top_stat(lg_cook_complex.cProgramNumber, lg_cook_complex.cCookTemp);
}
keyb_en_off();
ind_taim(lg_cook_complex.iCookTime, 1);
if(lg_cook_complex.iCookTime == 0){
if(lg_cook_complex.bKeepWarmEnabled == TRUE) logic_go_keepwarm(0); // Если включен подогрев
else logic_mode_standby(0);
logic_beep_3(3); // beep_3
}
}
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_BUTTUN_EN))
{
timer_ready_clr(TIMER_BUTTUN_EN);
key_handler();
}
if(timer_ready(TIMER_LEDS_BLANK)) // Таймер BLANK индикации
{
timer_ready_clr(TIMER_LEDS_BLANK);
ind_blank_handler();
}
if(timer_ready(TIMER_30SEK)) // Таймер выхода из пользовательского меню установок
{
timer_ready_clr(TIMER_30SEK);
timer_stop(TIMER_30SEK);
if(state_mode == MENU_MODE){ // Если мы в режиме меню
logic_mode_standby(0); // И прошла минута выходим в STANDBY_MODE режим
}
}
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);
cook_4sec_pwm(); // Таймер для работы ШИМ (управление нагревателями)
}
if(timer_ready(TIMER_5SEC_MENU)) // 5 Сек меню
{
timer_ready_clr(TIMER_5SEC_MENU);
timer_stop(TIMER_5SEC_MENU);
if(state_mode == MENU_MODE){ // Если режим меню
ind_blank1(BL_CLEAR); // Обнуляем blank1
if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.iCookTime){ // Если изменялось время приготовления
ind_taim(lg_cook_complex.iCookTime, 1);
Ind_LED_On(LED_MP);
Ind_LED_On(LED_TIME_LOAD);
}
else if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.cCookTemp){
ind_taim(lg_cook_complex.iCookTime, 1);
Ind_LED_On(LED_MP);
Ind_LED_On(LED_TIME_LOAD);
if(lg_cook_complex.cCookTemp < 80){ // Если установлена температура ниже 80 градусов
if(lg_cook_complex.bKeepWarmEnabled == TRUE){ // Отключаем подогрев
lg_cook_complex.bKeepWarmEnabled = FALSE;
Ind_LED_Off(LED_HEATING);
Ind_LED_Off(LED_ESC);
}
}
}
else if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.iPostPonementTime){ // Если изменялось время отложенного старта
ind_taim(lg_cook_complex.iPostPonementTime, 1);
Ind_LED_On(LED_MP);
Ind_LED_On(LED_LOAD_START);
}
else if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.cProductNumber){ // Если изменялся продукт
ind_taim(lg_cook_complex.iCookTime, 1);
Ind_LED_On(LED_MP);
Ind_LED_On(LED_TIME_LOAD);
ind_produkt();
}
keyb_en((uint16_t*)&lg_cook_complex.cProgramNumber, 0, 19, 1, 1); // Энкодер на изменение программы
}
else if(state_mode == COOKING_MODE){ // Если мы в режиме варки
if(state_cooking == STAGE_POSTPONEMENT){ // Если мы в отложенном старте
Ind_LED_On(LED_LOAD_START);
Ind_LED_Off(LED_TIME_LOAD);
ind_taim(lg_cook_complex.iPostPonementTime, 1);
ind_blank1(BL_MP);
}else{ // Если мы в процессе варки
logic_out_m_sh();
}
}
}
if(timer_ready(TIMER_BEEP_3)) // Сигнал закладки "макарон"
{
timer_ready_clr(TIMER_BEEP_3);
BEEP();
if(--fl_nimber_beep == 0) timer_stop(TIMER_BEEP_3);
}
if(timer_ready(TIMER_BEEP_3_10))
{
timer_ready_clr(TIMER_BEEP_3_10);
logic_beep_3(2);
}
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_SOUND_ON_OFF)){
timer_ready_clr(TIMER_SOUND_ON_OFF);
timer_stop(TIMER_SOUND_ON_OFF);
logic_sound_save(OFF_OK_KEY);
}
if(timer_ready(TIMER_IND_END)){
timer_ready_clr(TIMER_IND_END);
timer_stop(TIMER_IND_END);
logic_mode_standby(0);
}
if(timer_ready(TIMER_ERROR)) {
timer_ready_clr(TIMER_ERROR);
timer_stop(TIMER_ERROR);
if(state_mode == COOKING_MODE){
if(Temp_GetBotTemp() > lg_cook_complex.cCookTemp + 45) Err_Stop(EMPTY_POT_ERR);
}
}
/**
********************************************************************
* Timer test mode
********************************************************************
*/
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_test(0, TEST_TEST);
}
}
if(test_ind_on != 0){
if(timer_read_taim(TIMER_TEST_MODE) >= TIMER_SECOND(10)){
test_ind_on = 0;
if(fl_radio_power == 1)
{
logic_off_radio(BEEP_YES);
fl_mode_radio = 0;
keyb_en(&test_en_key, 0, 5, 1, 1);
}
Ind_Clr();
ind_taim_test(0, TEST_TEST);
}
}
}
/**
********************************************************************
* Timer radio
********************************************************************
*/
if(timer_ready(TIMER_RADIO)) {
timer_ready_clr(TIMER_RADIO);
timer_stop(TIMER_RADIO);
logic_radio_deactive(BEEP_NOT);
}
if(timer_active(TIMER_RADIO)){
if(fl_search_radio == 1 && timer_read_taim(TIMER_RADIO) >= 20){
static radio_fm_rd radio_srch;
while(radio_srch.channel != radio_chast){
radio_fm_read_params((radio_fm_rd *)&radio_srch);
}
if(radio_srch.fm_true == true){
fl_search_radio = 0;
fl_kn_search = 0;
keyb_en(&radio_chast, RADIO_CHAST_MIN, RADIO_CHAST_MAX, 1, 1);
}else{
if(radio_chast < RADIO_CHAST_MAX) radio_chast ++; else radio_chast = RADIO_CHAST_MIN;
radio_fm_on(radio_chast, 0);
ind_fm_chast(radio_chast, 1);
}
timer_reset(TIMER_RADIO);
if(timer_active(TIMER_30SEK) == 1) timer_reset(TIMER_30SEK);
}
if(fl_kn_search == 1 && timer_read_taim(TIMER_RADIO) >= 50){
fl_kn_search = 0;
logic_radio_volume(BEEP_YES);
}
if(ind_blank_state(2) == BL_VOLUME && timer_read_taim(TIMER_RADIO) >= 500){
logic_radio_volume(BEEP_YES);
}
if(ind_blank_state(2) == BL_STAN && timer_read_taim(TIMER_RADIO) >= 300){
ind_blank2(BL_CLEAR);
ind_fm(number_radio_st, 1);
}
}
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 мин.
ind_blank0(BL_CLEAR);
switch(power_state_cooking)
{
case STAGE_BOOST:
case STAGE_ENDOFBOOST:
case STAGE_WARM:
case STAGE_STAT:
case STAGE_BREAD_LOAD:
{ /* Если готовка */
ind_blank1(BL1_TAIM);
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_key = key_encoder(); // Считываем кнопку энкодера
if(state_key == NOT_KEY){ // Считываем значения энкодера
if(keyb_en_fl() == 1){ // Если были изменения энкодера
if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.cProgramNumber) state_key = EN_PROG_KEY;
else if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.iCookTime) state_key = EN_TIME_KEY;
else if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.iPostPonementTime) state_key = EN_DTIME_KEY;
else if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.cCookTemp) state_key = EN_TEMP_KEY;
else if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.cProductNumber) state_key = EN_PRODUKT_KEY;
else if(keyb_en_adr() == (uint16_t*)&radio_chast) state_key = EN_CHAST_KEY;
else if(keyb_en_adr() == (uint16_t*)&radio_vol) state_key = EN_VOLUME_KEY;
else if(keyb_en_adr() == (uint16_t*)&sound_on_off) state_key = EN_SOUND_KEY;
else if(keyb_en_adr() == (uint16_t*)&test_en_key) state_key = EN_TEST_KEY;
else if(keyb_en_adr() == (uint16_t*)&master_shef_time) state_key = EN_TIME_KEY_M_SH;
else if(keyb_en_adr() == (uint16_t*)&master_shef_temp) state_key = EN_TEMP_KEY_M_SH;
}
}
if(state_key != NOT_KEY || state_mode == TEST_MODE) // Если нажата кнопка обрабатываем ее
{
// Обработка кнопок управления радио //
if(state_mode != TEST_MODE){
if(state_key == OFF_RADIO_KEY){ // Если нажата кнопка радио
logic_mode_radio(BEEP_YES); // Включаем/переключаем радио
return;
}
else if(state_key == LONG_RADIO_KEY){ // Если длительное нажатие кнопки радио
logic_off_radio(BEEP_YES); // Выключаем радио
return;
}
if(fl_active_radio == 1){
switch(state_key)
{
case REHEAT_KEY: logic_radio_deactive(BEEP_YES); break; // Деактивируем радио
case EN_CHAST_KEY: logic_radio_izm_chast(); break; // Изменение частоты радио
case EN_VOLUME_KEY: // Изменение громкости радио
{
timer_reset(TIMER_RADIO);
radio_volume(radio_vol);
break;
}
case OFF_OK_KEY:
{
timer_reset(TIMER_RADIO);
fl_kn_search = 1;
/*logic_radio_volume(BEEP_YES);*/ break; // Настройка громкости
}
case OK_KEY:
{
if(fl_kn_search == 1){
fl_kn_search = 0;
logic_radio_search(BEEP_YES); // Поиск станции
}else fl_search_radio = 0;
break;
}
case LONG_OK_KEY: logic_radio_seve(BEEP_YES); break; // Сохранение станции
}
return;
}
}
//////////////////////////////////////////////////////////////////
switch(state_mode)
{
// Обработка кнопок в режиме ожидания //
case STANDBY_MODE:
{
switch(state_key)
{
case OFF_OK_KEY:
case REHEAT_KEY: logic_sound_save(state_key); break;
case LONG_REHEAT_KEY: logic_go_keepwarm(1); break; // Включаем программу разогрев
case LONG_TEMP_KEY: if(fl_radio_power == 0)logic_vesion(); break; // Выводим номер версии прошивки
case LONG_START_KEY: logic_cooking_express(BEEP_YES); break; // Включаем программу экспресс
case LONG_OK_KEY: logic_sound(BEEP_YES); break; // Входим в меню отключения/вклчения звука
case EN_SOUND_KEY: logic_sound_izm(); break;
case PARING_KEY: appl_paring(); break; // Пэринг
case UNPARING_KEY: appl_unparing(); break; // Унпэринг
}
break;
}
// Обработка кнопок в режиме меню (выбора параметров) //
case MENU_MODE:
{
switch(state_key)
{
case REHEAT_KEY:
{
if(timer_active(TIMER_5SEC_MENU)) logic_mode_menu(BEEP_YES);
else logic_mode_standby(BEEP_YES);
break; // Выход в состояние ожидания
}
case DELAY_KEY: logic_menu_taim(BEEP_YES); break; // Установка времени
case TEMP_KEY: logic_menu_temp(BEEP_YES); break; // Установка температуры
case PRODUKT_KEY: logic_menu_produkt(BEEP_YES); break; // Выбор продукта
case OFF_START_KEY: logic_on_off_keepwarm(BEEP_YES); break; // Включение / отключение подогрева
case LONG_START_KEY: logic_mode_cooking(BEEP_YES); break; // Запуск программы
case EN_PROG_KEY: logic_mode_menu(BEEP_YES); break; // Изменяем номер программы готовки
case OK_KEY: logic_menu_clok_min(); break;
case EN_TIME_KEY:
case EN_DTIME_KEY:
case EN_TEMP_KEY:
case EN_PRODUKT_KEY: logic_menu_izm_tain(state_key); break;
default:break;
}
break;
}
// Обработка кнопок в режиме приготовления //
case COOKING_MODE:
{
switch(state_key)
{
case DELAY_KEY: // Установка времени
{
if(lg_cook_complex.cProgramNumber != (uint8_t)EXPRESS_PROGRAM){
if(keyb_en_adr() == (uint16_t*)&master_shef_temp) logic_out_m_sh();
logic_menu_taim(BEEP_YES);
}
break;
}
case OK_KEY: logic_menu_clok_min(); break;
case EN_TEMP_KEY_M_SH:
case EN_TIME_KEY_M_SH: logic_menu_izm_tain(state_key); break;
case LONG_REHEAT_KEY: logic_mode_standby(1); break; // Выход в состояние ожидания
case START_KEY:
{
if(state_cooking == STAGE_ENDOFBOOST) logic_go_time_pasta(BEEP_YES);
else logic_on_off_keepwarm(BEEP_YES);
break; // Включение / отключение подогрева
}
case TEMP_KEY:
{
if(keyb_en_adr() == (uint16_t*)&master_shef_time) logic_out_m_sh();
logic_menu_temp(BEEP_YES);
break; // Установка температуры во время приготовления
}
//case EN_TEMP_KEY_M_SH: logic_menu_izm_temp(BEEP_YES); break;
}
break;
}
// Обработка кнопок в режиме подогрева //
case KEEP_MODE:
{
switch(state_key)
{
case LONG_REHEAT_KEY: logic_mode_standby(1); break; // Выход в состояние ожидания
}
break;
}
case PARING_MODE:
{
switch(state_key)
{
case REHEAT_KEY: logic_mode_standby(1); break; // Выход в состояние ожидания
}
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 OFF_REHEAT_KEY:
case OFF_DELAY_KEY:
case OFF_RADIO_KEY:
case OFF_TEMP_KEY:
case OFF_PRODUKT_KEY:
case OFF_OK_KEY:
case OFF_START_KEY: state_key = NOT_KEY; break; // BEEP
case LONG_REHEAT_KEY: state_key = REHEAT_KEY; break; // Включаем верхний нагреватель
case UNPARING_KEY:
case LONG_DELAY_KEY: state_key = DELAY_KEY; break; // Включаем боковой нагреватель
case LONG_RADIO_KEY: state_key = RADIO_KEY; break; // BEEP
case LONG_TEMP_KEY: state_key = TEMP_KEY; break; // Включаем нижний нагреватель
case PARING_KEY:
case LONG_PRODUKT_KEY: state_key = PRODUKT_KEY; break; // BEEP
}
test_heat(state_key); // Обработка нажатых копок для режима тестирования
break;
}
// End parametrs //
default: break;
}
}
}
//===============================================================================
// Функции работы радио
//===============================================================================
uint8_t logic_radio_active(void){
return fl_active_radio;
}
/*
* Включение радио и переклчение каналов
*/
static void logic_mode_radio(uint8_t beep)
{
if(fl_mode_radio == 1) fl_mode_radio = 0;
else{
if(beep == BEEP_YES) BEEP();
fl_kn_search = 0;
fl_search_radio = 0;
timer_init(TIMER_RADIO,TIMER_SECOND(10),0);
timer_start(TIMER_RADIO);
if(timer_active(TIMER_30SEK) == 1) timer_reset(TIMER_30SEK);
timer_stop(TIMER_5SEC_MENU);
if(fl_radio_power == 0){ // Если радио выключенно
fl_radio_power = 1; // Устанавливаем флаг включения радио
fl_active_radio = 0; // Сбрасываем ативность радио
radio_volume(radio_vol); // Задаем начальную/прошлую громкость
}
if(fl_active_radio == 0){ // Если радио не активно
fl_active_radio = 1;
ind_blank1(BL_CLEAR);
radio_chast = radio_fm_on(radio_chast, number_radio_st);
}else{ // Если радио активно переключаем станцию
if(number_radio_st < 9) number_radio_st ++;
else number_radio_st = 1;
radio_chast = radio_fm_on(0, number_radio_st);
}
ind_fm(number_radio_st, 1);
Ind_LED_On(LED_IMG_FM);
Ind_LED_On(LED_IMG_RADOI);
ind_blank2(BL_CLEAR);
keyb_en(&radio_chast, RADIO_CHAST_MIN, RADIO_CHAST_MAX, 1, 1);
if(state_mode == MENU_MODE){
ind_produkt();
Ind_LED_On(LED_TIME_LOAD);
Ind_LED_Off(LED_LOAD_START);
}
else if(state_mode == COOKING_MODE){
if(state_cooking == STAGE_POSTPONEMENT){
Ind_LED_Off(LED_TIME_LOAD);
Ind_LED_On(LED_LOAD_START);
}
Ind_LED_On(LED_TIME_LOAD);
}
}
}
/*
* Выключаем радио
*/
static void logic_off_radio(uint8_t beep)
{
if(fl_radio_power == 1){
if(beep == BEEP_YES) BEEP();
radio_fm_off();
fl_radio_power = 0;
fl_active_radio = 0;
fl_mode_radio = 1;
fl_kn_search = 0;
fl_search_radio = 0;
ind_blank2(BL_CLEAR);
timer_stop(TIMER_RADIO);
if(timer_active(TIMER_30SEK) == 1) timer_reset(TIMER_30SEK);
ind_fm(number_radio_st, 0);
ind_fm_chast(0, 0);
keyb_en_off();
Ind_LED_Off(LED_IMG_FM);
Ind_LED_Off(LED_IMG_RADOI);
logic_radio_deactive(BEEP_NOT);
}
}
/*
* Изменяем частоту радиостанции
*/
static void logic_radio_izm_chast(void)
{
timer_reset(TIMER_RADIO);
fl_kn_search = 0;
fl_search_radio = 0;
radio_fm_on(radio_chast, number_radio_st);
ind_fm_chast(radio_chast, 1);
if(timer_active(TIMER_30SEK) == 1) timer_reset(TIMER_30SEK);
}
/*
* Изменяем громкость радио
*/
static void logic_radio_volume(uint8_t beep)
{
if(beep == BEEP_YES) BEEP();
timer_reset(TIMER_RADIO);
fl_kn_search = 0;
fl_search_radio = 0;
if(timer_active(TIMER_30SEK) == 1) timer_reset(TIMER_30SEK);
if(keyb_en_adr() != (uint16_t*)&radio_vol){ // Если включаем изменение громкости
keyb_en(&radio_vol, 0, 15, 1, 0);
ind_blank2(BL_VOLUME);
}else{ // Если выключаем изменение громкости
keyb_en(&radio_chast, RADIO_CHAST_MIN, RADIO_CHAST_MAX, 1, 1);
ind_blank2(BL_CLEAR);
}
}
/*
* Сохраняем частоту радиостанции
*/
static void logic_radio_seve(uint8_t beep)
{
if(beep == BEEP_YES) BEEP_LONG();
timer_reset(TIMER_RADIO);
fl_kn_search = 0;
fl_search_radio = 0;
if(timer_active(TIMER_30SEK) == 1) timer_reset(TIMER_30SEK);
radio_fm_save(number_radio_st, radio_chast);
ind_blank2(BL_STAN);
}
/*
* Деактивация радио
*/
void logic_radio_deactive(uint8_t beep)
{
if(beep == BEEP_YES) BEEP();
if(timer_active(TIMER_30SEK) == 1) timer_reset(TIMER_30SEK);
ind_blank2(BL_CLEAR);
fl_kn_search = 0;
fl_search_radio = 0;
fl_active_radio = 0;
timer_stop(TIMER_RADIO);
ind_fm(number_radio_st, 0);
ind_fm_chast(0, 0);
keyb_en_off();
if(state_mode == STANDBY_MODE) logic_mode_standby(0); // Если режим остановки
else if(state_mode == MENU_MODE){ // Если режим меню
keyb_en((uint16_t*)&lg_cook_complex.cProgramNumber, 0, 19, 1, 1); // Энкодер на изменение программы
ind_taim(lg_cook_complex.iCookTime, 1); // Выводим время приготовления
Ind_LED_On(LED_MP);
Ind_LED_On(LED_TIME_LOAD);
Ind_LED_Off(LED_LOAD_START);
ind_produkt();
}
else if(state_mode == COOKING_MODE){ // Если режим приготовления
if(state_cooking == STAGE_POSTPONEMENT){
ind_taim(lg_cook_complex.iPostPonementTime, 1);
Ind_LED_Off(LED_TIME_LOAD);
Ind_LED_On(LED_LOAD_START);
ind_blank1(BL_MP);
}else{
Ind_LED_On(LED_TIME_LOAD);
if(lg_cook_complex.cProgramNumber != (uint8_t)EXPRESS_PROGRAM){
ind_taim(lg_cook_complex.iCookTime, 1);
if(state_cooking == STAGE_STAT || lg_cook_complex.bBoost == FALSE) ind_blank1(BL_MP); // Если идет отсчет времени
else Ind_LED_On(LED_MP);
}else ind_blank1(BL1_ZM);
}
}
else if(state_mode == KEEP_MODE){ // Если режим подогрева
ind_taim(keep_warm_time, 1);
ind_blank1(BL_MP);
}
}
/*
* Поиск радиостанций
*/
static void logic_radio_search(uint8_t beep)
{
if(keyb_en_adr() != &radio_vol){
if(beep == BEEP_YES) BEEP();
timer_reset(TIMER_RADIO);
if(timer_active(TIMER_30SEK) == 1) timer_reset(TIMER_30SEK);
keyb_en_off();
if(radio_chast < RADIO_CHAST_MAX) radio_chast ++; else radio_chast = RADIO_CHAST_MIN;
radio_fm_on(radio_chast, 0);
ind_fm_chast(radio_chast, 1);
fl_search_radio = 1;
}
}
/*
* Остановка поиска радиостанций
*/
static void logic_radio_search_stop(uint8_t beep)
{
if(beep == BEEP_YES) BEEP();
timer_reset(TIMER_RADIO);
if(timer_active(TIMER_30SEK) == 1) timer_reset(TIMER_30SEK);
fl_search_radio = 0;
fl_kn_search = 0;
keyb_en(&radio_chast, RADIO_CHAST_MIN, RADIO_CHAST_MAX, 1, 1);
}
//===============================================================================
// Функции основной работы мультиварки
//===============================================================================
/*
* Режим полного останова мультиварки
*/
void logic_mode_standby(uint8_t beep)
{
if(beep == BEEP_YES) BEEP();
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_stop(TIMER_BEEP_3_10);
timer_ready_clr(TIMER_BEEP_3_10); // 21_09_2015 V1_1
timer_stop(TIMER_5SEC_MENU);
timer_stop(TIMER_TEST_MODE);
timer_stop(TIMER_RADIO);
timer_stop(TIMER_POWER_1_MIN);
timer_stop(TIMER_SOUND_ON_OFF);
timer_stop(TIMER_ERROR);
lg_cook_complex.cProgramNumber = (uint8_t)ASPIC_PROGRAM;
ind_blank0(BL_CLEAR); // Сбрасываем индикацию
ind_blank0(BL_STANDBY);
ind_taim(0, 4); // ----
keyb_en_off();
fl_active_radio = 0;
}
/*
* Режим меню (установка параметров приготовления)
*/
static void logic_mode_menu(uint8_t beep)
{
if(beep == BEEP_YES) BEEP();
state_mode = MENU_MODE; // Состояние установки программы
cook_load_program(); // Заполнение структуры нужной программой
ind_blank0(BL_CLEAR); // Сбрасываем индикацию
ind_blank0((ind_state_blank)(lg_cook_complex.cProgramNumber | 0xC0)); // Устанвка blank программы
keyb_en((uint16_t*)&lg_cook_complex.cProgramNumber, 0, 19, 1, 1); // Энкодер на изменение программы
ind_taim(lg_cook_complex.iCookTime, 1); // Выводим время приготовления
Ind_LED_On(LED_MP);
if(lg_cook_complex.cKeepWarmTime > 0){ // Если возможен подогрев
//Ind_LED_On(LED_ESC); // Выводим индикацию подогрева
Ind_LED_On(LED_HEATING);
}
if(lg_cook_complex.cProductNumber != 0xFF) Ind_LED_On(LED_MEAT); // Если возможен продукт
Ind_LED_On(LED_TIME_LOAD);
timer_stop(TIMER_5SEC_MENU);
timer_reset(TIMER_30SEK); // Включем таймер 1 минута
timer_start(TIMER_30SEK);
}
/*
* Режим приготовления
*/
static void logic_mode_cooking(uint8_t beep)
{
if(beep == BEEP_YES) BEEP_LONG();
state_mode = COOKING_MODE;
keyb_en_off();
if(lg_cook_complex.iPostPonementTime != 0) // Если включен таймер отложенного старта
{
logic_go_delay_start(); // Запуск отложенного старта
}
else logic_go_start(); // Запускаем программу приготовления
}
/*
* Процесс приготовления
*/
static void logic_go_start(void)
{
ind_blank0(BL_CLEAR); // Сбрасываем индикацию
logic_radio_deactive(BEEP_NOT);
if(lg_cook_complex.cProgramNumber == (uint8_t)PASTA_PROGRAM){ // Если программа "МАКАРОНЫ"
state_cooking = STAGE_BOOST; // Нагрев до кипения перед закладкой продуктов
}
else if(lg_cook_complex.cProgramNumber == (uint8_t)BREAD_PROGRAM){ // Если программа "ХЛЕБ"
if(state_cooking == STAGE_BREAD_LOAD){ // Если мы пришли после пропадания питания
lg_cook_complex.cHeatEnable = HEAT_MAIN; // Используем только нижний тен
}else{
if(lg_cook_complex.iCookTime < 60){ // Если хлеб делается меньше 1 часа сразу запускаем выпекание
state_cooking = STAGE_WARM;
lg_cook_complex.cHeatEnable = (HEAT_TOP | HEAT_SIDE | HEAT_MAIN); // Включаем все тены
}else{
state_cooking = STAGE_BREAD_LOAD; // Иначе включаем закваску хлеба на 1 час.
lg_cook_complex.cHeatEnable = HEAT_MAIN; // Используем только нижний тен
}
}
}
else if(lg_cook_complex.cProgramNumber == (uint8_t)MULTICOOK_PROGRAM){ // Если программа "Мультиповар"
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);
lg_cook_complex.cBotTempWarm = lg_cook_complex.cCookTemp - 4;
lg_cook_complex.cBotTempStat = lg_cook_complex.cCookTemp - 1;
if(lg_cook_complex.cCookTemp > 94 && lg_cook_complex.cCookTemp < 115){
lg_cook_complex.cTopTempStat = cook_param_get_top_stat(lg_cook_complex.cProgramNumber, lg_cook_complex.cCookTemp);
}
else if(lg_cook_complex.cCookTemp < 60){
lg_cook_complex.cBotTempWarm = lg_cook_complex.cCookTemp - 12;
lg_cook_complex.cBotTempStat = lg_cook_complex.cCookTemp - 6;
lg_cook_complex.cPWMstat = 4;
lg_cook_complex.cPWM_kp = 3;
}
state_cooking = STAGE_WARM;
}else state_cooking = STAGE_WARM; // Нагрев с продуктами до рабочей температуры
if(lg_cook_complex.cProgramNumber != (uint8_t)EXPRESS_PROGRAM)
{
Ind_LED_On(LED_TIME_LOAD);
Ind_LED_Off(LED_LOAD_START);
ind_taim(lg_cook_complex.iCookTime, 1); // Выводим время приготовления
logic_ind_delay_i_start();
}
if(lg_cook_complex.bBoost == TRUE) ind_blank1(BL1_TAIM);
}
/**
* Отложенный старт
*/
static void logic_go_delay_start(void)
{
logic_radio_deactive(BEEP_NOT);
ind_blank0(BL_CLEAR); // Сбрасываем индикацию
state_cooking = STAGE_POSTPONEMENT; // Отложенный старт
Ind_LED_On(LED_LOAD_START);
ind_taim(lg_cook_complex.iPostPonementTime, 1);
logic_ind_delay_i_start();
}
static void logic_ind_delay_i_start(void)
{
timer_reset(TIMER_1MIN_START);
timer_start(TIMER_1MIN_START);
timer_stop(TIMER_30SEK);
timer_stop(TIMER_5SEC_MENU);
if(lg_cook_complex.bBoost == false) ind_blank1(BL_MP);
else Ind_LED_On(LED_MP);
if(lg_cook_complex.cProgramNumber == (uint8_t)MULTICOOK_PROGRAM){
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_HEATING);
}
Ind_LED_On(LED_START);
ind_prog_on_of(lg_cook_complex.cProgramNumber, 1);
if(lg_cook_complex.cProductNumber != 0xFF){ // Если выбран продукт
switch(lg_cook_complex.cProductNumber)
{
case 0: Ind_LED_On(LED_MEAT); break;
case 1: Ind_LED_On(LED_CHICKEN); break;
case 2: Ind_LED_On(LED_FISH); break;
case 3: Ind_LED_On(LED_VEGETABLES); break;
}
}
}
/**
* Включение выключение подогрева
*/
static void logic_on_off_keepwarm(uint8_t beep)
{
if(state_mode == MENU_MODE) timer_reset(TIMER_30SEK);
if(lg_cook_complex.bKeepWarmEnabled == TRUE) // Если включен выключаем
{
if(beep == BEEP_YES) BEEP();
lg_cook_complex.bKeepWarmEnabled = FALSE;
Ind_LED_Off(LED_ESC);
Ind_LED_Off(LED_HEATING);
}
else // Включаем
{
if(lg_cook_complex.cKeepWarmTime > 0 && lg_cook_complex.cCookTemp > 80) // Если разрешен подогрев
{
if(beep == BEEP_YES) BEEP();
lg_cook_complex.bKeepWarmEnabled = TRUE;
if(state_mode != MENU_MODE)Ind_LED_On(LED_ESC);
Ind_LED_On(LED_HEATING);
}
}
}
/*===================================================================
* Функции меню
===================================================================*/
/*
* Выбор настройки времени отложенного старта / времени готовки
*/
static void logic_menu_taim(uint8_t beep)
{
if(beep == BEEP_YES) BEEP();
if(state_mode == MENU_MODE){ // Если мы в режиме меню
timer_reset(TIMER_30SEK); // Обнуляем таймер 1 минуты
timer_reset(TIMER_5SEC_MENU); // Запускаем таймер 5 секунд
timer_start(TIMER_5SEC_MENU);
Ind_LED_On(LED_MP); // Включем индикацию точек
ind_produkt(); // Индикация продукта
if(keyb_en_adr() != (uint16_t*)&lg_cook_complex.iCookTime){ // Если энкодер меняет не время приготовления
ind_blank1(BL1_TAIM_CLOK); // Устанавливаем изменение часов времени приготовление
keyb_en((uint16_t*)&lg_cook_complex.iCookTime, lg_cook_complex.iMinTime, lg_cook_complex.iMaxTime, 60, 1);
}else{ // Устанавливаем изменение часов времени отложенного старта
if(lg_cook_complex.bPostPonementEnabled == true){ // Если возможен отложеный старт
ind_blank1(BL1_DELAY_CLOK);
keyb_en((uint16_t*)&lg_cook_complex.iPostPonementTime, 0, 24*60, 60, 1);
}
}
}
else if(state_mode == COOKING_MODE){ // Если мы в режиме варки
timer_reset(TIMER_5SEC_MENU);
timer_start(TIMER_5SEC_MENU);
if(state_cooking == STAGE_POSTPONEMENT){ // Если мы в отложенном старте
Ind_LED_Off(LED_LOAD_START);
Ind_LED_On(LED_TIME_LOAD);
ind_taim(lg_cook_complex.iCookTime, 1);
ind_blank1(BL_CLEAR);
Ind_LED_On(LED_MP);
}else{ // Если мы в процессе варки
ind_blank1(BL_CLEAR);
Ind_LED_On(LED_MP);
ind_blank1(BL1_TAIM_CLOK_M_SH);
master_shef_time = lg_cook_complex.iCookTime;
keyb_en((uint16_t*)&master_shef_time, 0, lg_cook_complex.iMaxTime, 60, 1);
}
}
}
/*
* Выбор настройки времени час / минуты
*/
static void logic_menu_clok_min(void)
{
if(timer_active(TIMER_5SEC_MENU) == 1){ // Если мы в режиме установки времени
if(keyb_en_adr() != (uint16_t*)&lg_cook_complex.cCookTemp &&\
state_cooking != STAGE_POSTPONEMENT) BEEP();
timer_reset(TIMER_30SEK);
timer_reset(TIMER_5SEC_MENU);
if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.iCookTime){ // Если энкодер меняет время приготовления
if(keyb_en_shag() == 60){ // Если шаг 60 минут значит переключаем на изменение минут
ind_blank1(BL1_TAIM_MIN);
if(lg_cook_complex.iCookTime > 59){ // Если время больше 1 часа
uint16_t max_t = ((lg_cook_complex.iCookTime/60)*60+(60 - lg_cook_complex.cStepTime[1]));
if(max_t > lg_cook_complex.iMaxTime) max_t = lg_cook_complex.iMaxTime;
keyb_en((uint16_t*)&lg_cook_complex.iCookTime, ((lg_cook_complex.iCookTime/60)*60), max_t, lg_cook_complex.cStepTime[1], 1);
}else{ // Если меньше часа
uint16_t max_t = (60 - lg_cook_complex.cStepTime[0]);
if(lg_cook_complex.iMinTime < lg_cook_complex.cStepTime[0]) max_t = (60 - lg_cook_complex.iMinTime);
if(lg_cook_complex.iMaxTime < 60) max_t = lg_cook_complex.iMaxTime;
keyb_en((uint16_t*)&lg_cook_complex.iCookTime, lg_cook_complex.iMinTime, max_t, lg_cook_complex.cStepTime[0], 1);
}
}else{ // Переключаем на изменение часов
ind_blank1(BL1_TAIM_CLOK);
keyb_en((uint16_t*)&lg_cook_complex.iCookTime, lg_cook_complex.iMinTime, lg_cook_complex.iMaxTime, 60, 1);
}
}
else if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.iPostPonementTime){ // Если энкодер меняет время отложенного старта
if(keyb_en_shag() == 60){ // Если шаг 60 минут значит переключаем на изменение минут
uint16_t min, max;
ind_blank1(BL1_DELAY_MIN);
min = (lg_cook_complex.iPostPonementTime/60)*60;
max = (lg_cook_complex.iPostPonementTime/60)*60+59;
if(min == (24*60)){ // Если 24 часа
min = 0; max = 59;
}
keyb_en((uint16_t*)&lg_cook_complex.iPostPonementTime, min, max, 1, 1);
}else{ // Переключаем на изменение часов
ind_blank1(BL1_DELAY_CLOK);
keyb_en((uint16_t*)&lg_cook_complex.iPostPonementTime, 0, 24*60, 60, 1);
}
}
else if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.cProductNumber){ // Если изменялся продукт
timer_stop(TIMER_5SEC_MENU);
keyb_en((uint16_t*)&lg_cook_complex.cProgramNumber, 0, 19, 1, 1);
ind_blank1(BL_CLEAR);
Ind_LED_On(LED_TIME_LOAD);
Ind_LED_On(LED_MP);
ind_produkt();
}
else if(keyb_en_adr() == (uint16_t*)&lg_cook_complex.cCookTemp){ // Если изменялась температура
// timer_stop(TIMER_5SEC_MENU);
// keyb_en((uint16_t*)&lg_cook_complex.cProgramNumber, 0, 19, 1, 1);
// ind_blank1(BL_CLEAR);
// Ind_LED_On(LED_TIME_LOAD);
// Ind_LED_On(LED_MP);
// ind_produkt();
BEEP();
}
else if(keyb_en_adr() == (uint16_t*)&master_shef_time){ // Если энкодер меняет время приготовления мастер шеф
if(keyb_en_shag() == 60){ // Если шаг 60 минут значит переключаем на изменение минут
ind_blank1(BL1_TAIM_MIN_M_SH);
if(master_shef_time > 59){ // Если время больше 1 часа
uint16_t max_t = ((master_shef_time/60)*60+(60 - 1)),
min_t = (master_shef_time/60)*60;
if(max_t >= lg_cook_complex.iMaxTime){
max_t = 59;//lg_cook_complex.iMaxTime;
min_t = 0;
}
keyb_en((uint16_t*)&master_shef_time, min_t, max_t, 1, 1);
}else{ // Если меньше часа
uint16_t max_t = (60 - 1);
if(lg_cook_complex.iMinTime < 1) max_t = (60 - lg_cook_complex.iMinTime);
if(lg_cook_complex.iMaxTime < 60) max_t = lg_cook_complex.iMaxTime;
keyb_en((uint16_t*)&master_shef_time, 0, max_t, 1, 1);
}
}else{ // Переключаем на изменение часов
ind_blank1(BL1_TAIM_CLOK_M_SH);
keyb_en((uint16_t*)&master_shef_time, 0, lg_cook_complex.iMaxTime, 60, 1);
}
}
}
}
/**
* Обработка изменения времени, температуры и продукта
*/
static void logic_menu_izm_tain(uint8_t kn_en)
{
timer_reset(TIMER_30SEK);
timer_reset(TIMER_5SEC_MENU);
if(kn_en == EN_TIME_KEY){ // Изменение времени приготовления
ind_blank1_clear_fl();
if(lg_cook_complex.cProgramNumber == (uint8_t)MULTICOOK_PROGRAM && \
lg_cook_complex.cCookTemp >= 130 && \
lg_cook_complex.iCookTime > 120) lg_cook_complex.iCookTime = 120;
ind_taim(lg_cook_complex.iCookTime, 1);
}
else if(kn_en == EN_DTIME_KEY){ // Изменение времени отложенного старта
ind_blank1_clear_fl();
if(keyb_en_max() < lg_cook_complex.iPostPonementTime) lg_cook_complex.iPostPonementTime = keyb_en_max();
ind_taim(lg_cook_complex.iPostPonementTime, 1);
}
else if(kn_en == EN_TEMP_KEY){ // Изменение температуры приготовления
ind_blank1_clear_fl();
if(lg_cook_complex.cProgramNumber == (uint8_t)MULTICOOK_PROGRAM && \
lg_cook_complex.cCookTemp >= 130 && \
lg_cook_complex.iCookTime > 120) lg_cook_complex.iCookTime = 120;
ind_temperature(lg_cook_complex.cCookTemp, 1);
}
else if(kn_en == EN_PRODUKT_KEY){ // Изменение продукта
uint8_t n_prd = cook_number_produkts(lg_cook_complex.cProgramNumber);
BEEP();
ind_blank1_clear_fl();
Ind_LED_On(LED_MEAT);
Ind_LED_On(LED_CHICKEN);
Ind_LED_On(LED_FISH);
if(n_prd == 3) Ind_LED_On(LED_VEGETABLES);
switch(lg_cook_complex.cProductNumber)
{
case 0: Ind_LED_Off(LED_MEAT); break;
case 1: Ind_LED_Off(LED_CHICKEN); break;
case 2: Ind_LED_Off(LED_FISH); break;
case 3: Ind_LED_Off(LED_VEGETABLES); break;
}
cook_time_produkt(lg_cook_complex.cProgramNumber, lg_cook_complex.cProductNumber);
ind_taim(lg_cook_complex.iCookTime, 1);
}
else if(kn_en == EN_TIME_KEY_M_SH){ // Изменение времени приготовления
ind_blank1_clear_fl();
if(keyb_en_max() < master_shef_time) master_shef_time = keyb_en_max();
ind_taim(master_shef_time, 1);
}
else if(kn_en == EN_TEMP_KEY_M_SH){ // Изменение температуры приготовления
ind_blank1_clear_fl();
ind_temperature(master_shef_temp, 1);
}
}
/**
* Меню изменения температуры
*/
static void logic_menu_temp(uint8_t beep)
{
if(state_mode == MENU_MODE){
if(lg_cook_complex.cProgramNumber == (uint16_t)MULTICOOK_PROGRAM){ // Если программа мультиповар
if(beep == BEEP_YES) BEEP();
timer_reset(TIMER_30SEK);
timer_reset(TIMER_5SEC_MENU);
timer_start(TIMER_5SEC_MENU);
ind_blank1(BL1_TEMP);
Ind_LED_On(LED_TIME_LOAD);
keyb_en((uint16_t*)&lg_cook_complex.cCookTemp, lg_cook_complex.cMinValueTemp, lg_cook_complex.cMaxValueTemp, 5, 1);
}
}
else if(state_mode == COOKING_MODE && state_cooking != STAGE_POSTPONEMENT/*&& state_cooking == STAGE_STAT*/){ // Если процес варки и состояние поддержания
if(lg_cook_complex.cProgramNumber != (uint16_t)EXPRESS_PROGRAM){
if(beep == BEEP_YES) BEEP();
timer_reset(TIMER_5SEC_MENU);
timer_start(TIMER_5SEC_MENU);
master_shef_temp = lg_cook_complex.cCookTemp;
ind_blank1(BL1_TEMP_M_SH);
Ind_LED_On(LED_TIME_LOAD);
keyb_en((uint16_t*)&master_shef_temp, lg_cook_complex.cMinValueTemp, lg_cook_complex.cMaxValueTemp, 1, 1);
}
}
}
/**
* Меню изменения продукта
*/
static void logic_menu_produkt(uint8_t beep)
{
if(lg_cook_complex.cProductNumber != 0xFF){ // Если возможно изменение продукта
uint16_t max_prod;
if(beep == BEEP_YES) BEEP();
timer_reset(TIMER_30SEK);
timer_reset(TIMER_5SEC_MENU);
timer_start(TIMER_5SEC_MENU);
Ind_LED_On(LED_MP);
Ind_LED_On(LED_TIME_LOAD);
Ind_LED_Off(LED_LOAD_START);
ind_blank1(BL1_PRODUKT);
max_prod = (uint16_t)cook_number_produkts(lg_cook_complex.cProgramNumber);
keyb_en((uint16_t*)&lg_cook_complex.cProductNumber, 0, max_prod, 1, 1);
ind_taim(lg_cook_complex.iCookTime, 1);
}
}
/**
* Запуск времени готовки "МАКАРОН"
*/
static void logic_go_time_pasta(uint8_t beep)
{
if(beep == BEEP_YES) BEEP_LONG();
state_cooking = STAGE_STAT; // Поддержание температуры варки
timer_stop(TIMER_BEEP_3_10); // Отключаем beep
timer_ready_clr(TIMER_BEEP_3_10); // 21_09_2015 V1_1
ind_blank1(BL_MP);
Ind_LED_On(LED_TIME_LOAD);
}
/**
* Подогрев
*/
static void logic_go_keepwarm(uint8_t beep)
{
logic_radio_deactive(BEEP_NOT);
if(beep == BEEP_YES) // Если мы пришли из режима ожидания
{
BEEP();
lg_cook_complex.cProgramNumber = (uint8_t)KEEP_PROGRAM;
cook_load_program(); // Заполнение структуры нужной программой
}
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 температуры приготовления
fl_active_radio = 0;
timer_reset(TIMER_1MIN_START);
timer_start(TIMER_1MIN_START);
timer_stop(TIMER_30SEK);
timer_stop(TIMER_5SEC_MENU);
state_mode = KEEP_MODE; // Режим подогрева
state_cooking = STAGE_KEEPWARM; // Статус варки подогрев
ind_blank0(BL_CLEAR);
ind_blank1(BL_MP);
if(beep != 2) keep_warm_time = 0;
ind_taim(keep_warm_time, 1);
Ind_LED_On(LED_ESC);
Ind_LED_On(LED_HEATING);
}
/**
* Запуск программы экспресс
*/
static void logic_cooking_express(uint8_t beep)
{
if(beep == BEEP_YES) BEEP();
fl_active_radio = 0;
timer_reset(TIMER_1MIN_START);
timer_start(TIMER_1MIN_START);
timer_stop(TIMER_30SEK);
timer_stop(TIMER_5SEC_MENU);
state_mode = COOKING_MODE;
lg_cook_complex.cProgramNumber = (uint8_t)EXPRESS_PROGRAM;
cook_load_program(); // Заполнение структуры нужной программой
logic_go_start(); // Запускаем программу приготовления
Ind_LED_Off(LED_MP);
ind_blank1(BL1_ZM);
Ind_LED_On(LED_START);
Ind_LED_On(LED_TIME_LOAD);
}
/**
* Обработка таймеров отложенного старта, работы, подогрев.
*/
static void logic_tim_1min(void)
{
switch(state_cooking)
{
case STAGE_POSTPONEMENT: // Отложенный старт
{
lg_cook_complex.iPostPonementTime --;
if(lg_cook_complex.iPostPonementTime > 0)
{
if(fl_active_radio == 0) ind_taim(lg_cook_complex.iPostPonementTime, 1);
}
else{
logic_go_start();
logic_beep_3(3); // beep_3
}
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){
if(lg_cook_complex.iCookTime > 0)lg_cook_complex.iCookTime--;
if(lg_cook_complex.iCookTime > 0) {
if(fl_active_radio == 0) ind_taim(lg_cook_complex.iCookTime, 1);
}else { // Если вышло время приготовления
if(lg_cook_complex.bKeepWarmEnabled == TRUE) logic_go_keepwarm(0); // Если включен подогрев
else logic_mode_standby(0);
logic_beep_3(3); // beep_3
}
}
}
break;
}
case STAGE_KEEPWARM: // Подогрев
{
if(++keep_warm_time < (uint16_t)(lg_cook_complex.cKeepWarmTime * 60))
{
if(fl_active_radio == 0) ind_taim(keep_warm_time, 1);
}
else {
logic_mode_standby(0);
logic_beep_3(3);
}
break;
}
}
}
/**
* BEEP 3
*/
void logic_beep_3(uint8_t state)
{
fl_nimber_beep = state;
timer_init(TIMER_BEEP_3,50,0);
timer_start(TIMER_BEEP_3);
}
/**
* logic_ind_end
*/
void logic_ind_end(void)
{
timer_init(TIMER_IND_END,300,0); // 3 sec
timer_start(TIMER_IND_END);
ind_taim(0, 10); // End
}
/**
* Пэринг ble
*/
static void appl_paring(void)
{
BEEP();
ind_blank1(BL_CLEAR); // Сбрасываем индикацию
ind_blank1(BL1_PARING); // Индикация перинга
ind_paring(1);
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);
}
/**
* Унпэринг ble
*/
static void appl_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(BEEP_YES);
}
else if(lg_cook_complex.cProgramNumber == (uint8_t)KEEP_PROGRAM){ // 21_09_2015 V1_1
logic_go_keepwarm(BEEP_YES);
}
else logic_mode_cooking(BEEP_YES);
return true;
}
else if(state_mode == POWER_MODE){
application_power_mode_go(BEEP_YES); // Продолжение работы программы
return true;
}
else if(state_mode == COOKING_MODE){ // 21_09_2015 V1_1
if(state_cooking == STAGE_ENDOFBOOST){
logic_go_time_pasta(BEEP_YES);
return true;
}
}
return false;
}
/**
* Stop
*/
bool Appl_Stop(void){
if(state_mode != ERROR_MODE) logic_mode_standby(BEEP_YES); // 21_09_2015 V1_1
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:
{
if(lg_cook_complex.cProgramNumber == RICE_CEREALS_PROGRAM || \
lg_cook_complex.cProgramNumber == STEAM_PROGRAM || \
lg_cook_complex.cProgramNumber == FRY_PROGRAM || \
lg_cook_complex.cProgramNumber == FRYING_PROGRAM) return APPL_BOOST_STATE;
return APPL_COOKING_STATE;
}
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;// 21_09_2015 V1_1
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 < 22) // 21 21_09_2015 V1_1
{
state_mode = MENU_MODE;
state_cooking = STAGE_PROGRAM;
lg_cook_complex.cProgramNumber = prog;
if(prog < 20) logic_mode_menu(1);
return true;
}
return false;
}
/**
* Get program
*/
uint8_t Appl_GetProgram(void){
return (uint8_t)lg_cook_complex.cProgramNumber;
}
/**
* Set produkt
*/
bool Appl_SetProdukt(uint8_t prod)
{
if(prod > APPL_VEGETABLES_PROD) return false;
if(state_mode != MENU_MODE) return false;
timer_reset(TIMER_30SEK);
if(lg_cook_complex.cProductNumber != 0xFF){// Если возможно задание продукта
if(prod == APPL_NOT_PROD) return false;
if(lg_cook_complex.cProgramNumber == ASPIC_PROGRAM && prod == APPL_VEGETABLES_PROD) return false;
lg_cook_complex.cProductNumber = prod-1;
ind_produkt();
}else if(prod != APPL_NOT_PROD) return false;
return true;
}
/**
* Get produkt
*/
uint8_t Appl_GetProdukt(void){
uint8_t prod = (uint8_t)lg_cook_complex.cProductNumber;
switch(prod)
{
case 0: prod = APPL_MEAT_PROD; break;
case 1: prod = APPL_CHICKEN_PROD; break;
case 2: prod = APPL_FISH_PROD; break;
case 3: prod = APPL_VEGETABLES_PROD; break;
default: prod = APPL_NOT_PROD; break;
}
return prod;
}
/**
* 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;// 21_09_2015 V1_1
if(state_mode == COOKING_MODE){
timer_reset(TIMER_ERROR);
timer_start(TIMER_ERROR);
}
lg_cook_complex.cCookTemp = temp; // Меняем температуру
temp_set_warm = cook_temp_d_warm();
if(temp > temp_set_warm) lg_cook_complex.cBotTempWarm = temp - temp_set_warm;
else lg_cook_complex.cBotTempWarm = 10;
lg_cook_complex.cBotTempStat = temp - cook_temp_d_stat();
lg_cook_complex.cTopTempStat = cook_param_get_top_stat(lg_cook_complex.cProgramNumber, lg_cook_complex.cCookTemp);
if(lg_cook_complex.cProgramNumber == (uint8_t)MULTICOOK_PROGRAM && state_mode == MENU_MODE){// Если программа мультиповар
ind_temperature(temp, 1); // Выводим значение темперытуры
Ind_LED_Off(LED_MP);
}
if(lg_cook_complex.cCookTemp < 80){ // Если установлена температура ниже 80 градусов
if(lg_cook_complex.bKeepWarmEnabled == TRUE){ // Отключаем подогрев
lg_cook_complex.bKeepWarmEnabled = FALSE;
Ind_LED_Off(LED_HEATING);
Ind_LED_Off(LED_ESC);
}
}
if(lg_cook_complex.cCookTemp > 130){
if(lg_cook_complex.iCookTime > 2*60) lg_cook_complex.iCookTime = 2*60;
}
return true;
}
}
return false;
}
/**
* Get cooking temperature
*/
uint8_t Appl_GetCookTemp(void){
if(lg_cook_complex.cProgramNumber == (uint8_t)KEEP_PROGRAM){
return 70;
}
if(state_mode == KEEP_MODE) 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
Ind_LED_On(LED_MP);
}
if(state_mode == MENU_MODE){
if(lg_cook_complex.iMinTime <= time && lg_cook_complex.iMaxTime >= time){ // Проверка задаваемого вермени варки
lg_cook_complex.iCookTime = time;
// if(lg_cook_complex.cCookTemp > 130){
// if(lg_cook_complex.iCookTime > 2*60) lg_cook_complex.iCookTime = 2*60;
// }
if(state_cooking != STAGE_POSTPONEMENT) ind_taim(lg_cook_complex.iCookTime, 1); // Выводим индикацию установленого времени
return true;
}
}else{
if(lg_cook_complex.iMaxTime >= time){ // Проверка задаваемого времени варки
lg_cook_complex.iCookTime = time;
if(lg_cook_complex.cCookTemp > 130){
if(lg_cook_complex.iCookTime > 2*60) lg_cook_complex.iCookTime = 2*60;
}
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){
lg_cook_complex.iPostPonementTime = 0;
return true;
}else{
if(lg_cook_complex.bPostPonementEnabled == TRUE && time <= (24*60+lg_cook_complex.iCookTime)) // Если возможна устанока отложенного старта и коректное время
{
if(time < lg_cook_complex.iCookTime) return false;
lg_cook_complex.iPostPonementTime = time-lg_cook_complex.iCookTime;
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 + lg_cook_complex.iCookTime);
}
/**
* Get time to end of cooking in minutes
*/
uint16_t Appl_GetEndTime(void)
{
// оставшееся время варки и время отложенного старты
if(state_cooking == STAGE_POSTPONEMENT) return lg_cook_complex.iPostPonementTime;
else{
if(lg_cook_complex.cProgramNumber == (uint8_t)KEEP_PROGRAM) return keep_warm_time;
return lg_cook_complex.iCookTime;
}
}
/**
* Set reheat state
*/
bool Appl_SetReheat(uint8_t state)
{
if(state_mode == MENU_MODE || state_mode == COOKING_MODE)
{
if(state_mode == MENU_MODE) timer_reset(TIMER_30SEK);
if(state == 0){
if(lg_cook_complex.bKeepWarmEnabled == TRUE) // Если включен выключаем
{
BEEP();
lg_cook_complex.bKeepWarmEnabled = FALSE;
Ind_LED_Off(LED_ESC);
Ind_LED_Off(LED_HEATING);
return true;
}
}else if(state == 1)
{
if(lg_cook_complex.bKeepWarmEnabled == FALSE)
{
if(lg_cook_complex.cKeepWarmTime > 0 && lg_cook_complex.cCookTemp > 80) // Если разрешен подогрев
{
BEEP();
lg_cook_complex.bKeepWarmEnabled = TRUE;
if(state_mode != MENU_MODE)Ind_LED_On(LED_ESC);
Ind_LED_On(LED_HEATING);
return true;
}
}
}
}
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;
}
/**
******************************************************************************
* Appl FM functions
******************************************************************************
*/
uint8_t* Appl_FM_State(void)
{
static uint8_t fm_state[5];
fm_state[0] = fl_radio_power;
fm_state[1] = number_radio_st-1;
fm_state[2] = (uint8_t)(radio_chast/10);
fm_state[3] = (uint8_t)(radio_chast%10);
fm_state[4] = radio_vol;
if(fl_radio_power == 1 && fl_search_radio == 1) fm_state[0] = 2;
return (uint8_t*)fm_state;
}
bool Appl_FM_On_num(uint8_t num)
{
if(num < 9){
fl_active_radio = 0;
number_radio_st = num+1;
fl_mode_radio = 0;
radio_chast = 0;
logic_mode_radio(BEEP_YES);
return true;
}
return false;
}
bool Appl_FM_On_chs(uint16_t chs)
{
if(chs >= 760 && chs <= 1800){
fl_active_radio = 0;
fl_mode_radio = 0;
radio_chast = chs;//13_10_15
logic_mode_radio(BEEP_YES);
//radio_chast = chs;
//logic_radio_izm_chast();
return true;
}
return false;
}
bool Appl_FM_Off(void)
{
if(fl_radio_power == 1)
{
logic_off_radio(BEEP_YES);
fl_mode_radio = 0;
return true;
}
return false;
}
bool Appl_FM_Volume(uint8_t vol)
{
radio_vol = vol;
timer_reset(TIMER_RADIO);
radio_volume(radio_vol);
return true;
}
bool Appl_FM_SaveChs(uint8_t num, uint16_t chs)
{
if(num < 9 && chs > 759 && chs < 1801)
{
BEEP_LONG();
//timer_reset(TIMER_RADIO);
fl_kn_search = 0;
fl_search_radio = 0;
if(timer_active(TIMER_30SEK) == 1) timer_reset(TIMER_30SEK);
radio_fm_save(num+1, chs);
//ind_blank2(BL_STAN);
return true;
}
return false;
}
bool Appl_FM_StartAuto(void)
{
// if(fl_active_radio == 1){
// logic_radio_search(BEEP_YES); // Поиск станции
// return true;
// }
// return false;
if(fl_radio_power == 1)
{
if(fl_active_radio == 0)
{
fl_mode_radio = 0;
logic_mode_radio(BEEP_NOT);
}
logic_radio_search(BEEP_YES);
return true;
}
return false;
}
bool Appl_FM_StopAuto(void)
{
if(fl_search_radio == 1){
logic_radio_search_stop(BEEP_YES); // Остановка поиска станции
return true;
}
return false;
}
uint16_t Appl_FM_ReadChs(uint8_t num)
{
if(num < 9){
return radio_read_stations(num+1);
}
return 0;
}
bool Appl_SetBuzer(uint8_t st)//???????????????????????????????
{
uint8_t st_t;
if(st>1) return false;
st_t = (uint8_t)Buz_get();
if(st_t != st)
{
Buz_set((hw_buzzer_state_t)st);
if(st == 0) Ind_LED_On(LED_SOUND_OFF);
else Ind_LED_Off(LED_SOUND_OFF);
BEEP();
}
return true;
}
uint8_t Appl_GetBuzer(void)
{
return (uint8_t)Buz_get();
}
////////////////////////////////////////////////////////////////
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.bKeepWarmEnabled == TRUE){ // Если возможен подогрев led_подогрев
Ind_LED_On(LED_ESC);
Ind_LED_On(LED_HEATING);
}
Ind_LED_On(LED_START); // Led_start
ind_produkt();
if(lg_cook_complex.cProgramNumber == (uint8_t)EXPRESS_PROGRAM) // Если программа Экспресс
{
ind_blank1(BL1_ZM_TAIM); // Blank змейка
}
else /* Если рабочая программа */
{
ind_taim(lg_cook_complex.iCookTime, 1);
Ind_LED_On(LED_MP);
ind_blank1(BL1_TAIM);
ind_blank0((ind_state_blank)(lg_cook_complex.cProgramNumber | 0x80));
}
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; // Запускаем готовку
}
}
}
/*
* Обработка пропадения питания
*/
static void application_power_down(void)
{
if(power_read_down() != STATE_OK){ // Если питание ниже 2V7
if(state_mode == COOKING_MODE){ // И состояние работы
power_seve_params((cookcomplexprog *)&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((cookcomplexprog *)&lg_cook_complex, \
state_mode, \
state_cooking, \
keep_warm_time, 255); // Сохраняем текущие параметры
}
}
}
/**
********************************************************************
* Function test mode and image version hex
********************************************************************
*/
uint8_t logic_test_temp(void){
return test_ind_on;
}
static void logic_vesion(void)
{
uint8_t key_test = LONG_TEMP_KEY;
BEEP();
Ind_Clr();
while(key_test == LONG_TEMP_KEY || key_test == TEMP_KEY)
{
ind_taim_test(FIRMWARE_VER, TEST_VER);
Ind_Release();
keyb_clear();
Clk_Delay(50);
key_test = Keyb_GetKey();
}
if(key_test == PRODUKT_KEY) // TEST_MODE
{
BEEP_LONG();
ind_blank0(BL_CLEAR);// 05_11_2015
test_ind_on = 0;
state_mode = TEST_MODE;
state_cooking = STAGE_TEST;
timer_start(TIMER_TEST_MODE);
ind_taim_test(0, TEST_TEST); // Ind "tESt"
keyb_en(&test_en_key, 0, 5, 1, 1);
}
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 != 0){
if(f_key == OFF_OK_KEY) f_key = NOT_KEY;
test_ind_on = 0;
Ind_Clr();
//ind_taim_test(0, TEST_TEST); // Ind "tESt"
}
if(fl_radio_power == 1)
{
if(f_key != RADIO_KEY)
{
logic_off_radio(BEEP_YES);
fl_mode_radio = 0;
keyb_en(&test_en_key, 0, 5, 1, 1);
}
}
timer_reset(TIMER_TEST_MODE);
if(f_key == REHEAT_KEY){
heat_on_off(HEAT_TOP);
ind_taim_test(1, TEST_HEAT);
}
else if(f_key == DELAY_KEY){
heat_on_off(HEAT_SIDE);
ind_taim_test(2, TEST_HEAT);
}
else if(f_key == TEMP_KEY){
heat_on_off(HEAT_MAIN);
ind_taim_test(3, TEST_HEAT);
}
else if(f_key == PRODUKT_KEY){
heat_on_off(HEAT_OFF);
ind_taim_test(0, TEST_TEST); // Ind "tESt"
test_ind_on = 2;
}
else if(f_key == LONG_START_KEY)
{
logic_mode_standby(1);
}
else if(f_key == OK_KEY){
heat_on_off(HEAT_OFF);
test_ind_on = 1;
for(uint8_t i=0;i<8;i++) Ind_LED_On(i, 0xFFFF);
}
else if(f_key == EN_TEST_KEY)
{
test_ind_on = 1;
heat_on_off(HEAT_OFF);
ind_taim_test_en(test_en_key);
//ind_taim_test(test_en_key, TEST_ENCD);
}
else if(f_key == RADIO_KEY)
{
test_ind_on = 1;
fl_active_radio = 0;
fl_mode_radio = 0;
radio_chast = 901;
logic_mode_radio(BEEP_YES);
keyb_en(&test_en_key, 0, 5, 1, 1);
}
else{
heat_on_off(HEAT_OFF);
ind_taim_test(0, TEST_TEST); // Ind "tESt"
}
}
}
}
/*
* Выключение/включение звука
*/
static void logic_sound(uint8_t beep)
{
if(beep == BEEP_YES) BEEP();
sound_on_off = (uint16_t)Buz_get();
timer_reset(TIMER_SOUND_ON_OFF);
timer_start(TIMER_SOUND_ON_OFF);
if(sound_on_off == 0) ind_blank1(BL1_OFF); else ind_blank1(BL1_ON);
keyb_en(&sound_on_off, 0, 1, 1, 0); // Вращение в одну сторону устанавливает ON в другую OFF
// keyb_en(&sound_on_off, 0, 1, 1, 1); // Вращение в любую сторону попеременно устанавливает ON, OFF
}
static void logic_sound_izm(void)
{
timer_reset(TIMER_SOUND_ON_OFF);
if(sound_on_off == 0){
Ind_LED_On(LED_SOUND_OFF);
ind_blank1(BL1_OFF);
}else{
Ind_LED_Off(LED_SOUND_OFF);
ind_blank1(BL1_ON);
}
}
static void logic_sound_save(uint8_t key)
{
timer_stop(TIMER_SOUND_ON_OFF);
ind_blank1(BL_CLEAR);
if(keyb_en_adr() == (uint16_t*)&sound_on_off){
if(key == REHEAT_KEY) sound_on_off = (uint16_t)Buz_get();
else Buz_set((hw_buzzer_state_t)sound_on_off);
if(sound_on_off == 0) Ind_LED_On(LED_SOUND_OFF);
else Ind_LED_Off(LED_SOUND_OFF);
logic_mode_standby(BEEP_YES);
}
else{
if(key == OFF_OK_KEY) logic_mode_menu(BEEP_YES);
}
}
