Фрагмент исходного кода
Программный модуль для мультиварки RMC-M800S
v1.12
ПО является неотъемлемой частью мультиварки RMC-M800S, отдельно потребителю не поставляется и эксплуатируется только в составе устройства.
//
//RMC-M800S
//
//v1.12
//
#include "common.h"
#include "cooking.h"
#include "cookprog.h"
#include "clk.h"
#include "ind.h"
#include "ind_service.h"
#include "adc.h"
#include "heat.h"
#include "keyb.h"
#include "buz.h"
#include "temp.h"
#include "err.h" //ash
#include "test.h"
U16 iMilliSec, iSecond;
U16 iAnalizeTermInterval; // Интервал регулирования сек
U16 iCurTime; // текущее время готовки в минутах
U8 cStage; // этапы готовки
U8 cCookPWM; // счетчик ШИМ нагрева макс 6
U16 iLastPostPonementTime; // время Отложенного старта
U8 cOldMode, cMode;
B8 bChangeTime, bChangeTimeTemp;
B8 bLockEnabled;
U8 stateCT;
// Клавиатура
U8 cKeyBuf[16]; // буфере нажатых клавиш
U8 cKeyHead;
U8 cTimeToStandBy;
U8 cKey, cOldKey, cKeyRepeat;
I16 iTimeKeyRepeat; // Знаковое!!!
U8 cClrPairing;
//ash
U8 /*iOldTermTop,*/ iTermTop, iTermBot; //(ash) U16->U8
//(ash)
U16 Cook_TempErrBlockTimer;
////////////////////////////////////////////////////////////////
//перенес из ind.h (ash)
static void _Ind_PutProgram_On(U8 num);
static void _Ind_PutProgram_Off(U8 num);
static void _Ind_PutProduct(U8 num);
////////////////////////////////////////////////////////////////
//----------------------------------------------------------
void Cooking_init(void)
{
U8 i;
/// GetTemperatureCalibration();
cOldMode = 0xFF;
cMode = MODE_STANDBY; // режим по включению
Buz_On();
for(i = 1; i < 13; i++) _Ind_PutProgram_On(i);
Ind_LED_On(VEGETABLES_LED); Ind_LED_On(FISH_LED); Ind_LED_On(MEAT_LED);
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
Ind_LED_On(DEF_START_1_LED); Ind_LED_On(DEF_START_2_LED);
Ind_LED_On(TEMP1_LED); Ind_LED_On(TEMP2_LED);
Ind_LED_On(HEAT_LED); Ind_LED_On(START_LED); Ind_LED_On(LOCK_LED);
Ind_PutInt(8888); Ind_MP_On();
Ind_Release();
Clk_Delay_ms(250); //ash
Buz_Off();
Clk_Delay_ms(250); //ash
}
// В основном цикле возможные ркжимы работы
void Cooking(void)
{
if(cMode == MODE_STANDBY) ModeStandBy();
else if(cMode == MODE_COOKING) ModeCooking();
else if(cMode == MODE_INPUT_PROGRAM) ModeInputProgram();
else if(cMode == MODE_INPUT_COOKTIME) ModeInputCookTime();
// else if(cMode == MODE_INPUT_COOKTIME_MSL) ModeInputCookTimeMSL();
else if(cMode == MODE_INPUT_POSTTIME) ModeInputPostponementTime();
else if(cMode == MODE_INPUT_TEMP) ModeInputTemperature();
// else if(cMode == MODE_INPUT_TEMP_MSL) ModeInputTemperatureMSL();
else if(cMode == MODE_PAIRING) ModePairing();
else if (cMode == MODE_VER) ModeVer();
else if (cMode == MODE_TEST) ModeTest();
else if (cMode == MODE_ERROR) ModeError();
}
////////////////////////////////////////////////////////////////
void SetModeTest(void)
{
cOldMode = cMode = MODE_TEST;
Test_Start();
}
void ModeTest(void)
{
Test();
}
////////////////////////////////////////////////////////////////
void SetModeError(void)
{
cOldMode = cMode = MODE_ERROR;
cStage = STAGE_NONE;
AllWarmOff();
DisableIndUpdate();
Ind_Clr();
Ind_PutInt(Err_GetError());
Ind_PutDig1(SEG7_E);
Ind_Release();
}
void ModeError(void)
{
if(cOldMode != cMode) SetModeError();
}
////////////////////////////////////////////////////////////////
void SetModeVer(void)
{
cOldMode = cMode = MODE_VER;
Ind_Clr();
Ind_PutDig1(FIRMWARE_VER_SEG7_1);
Ind_PutDig2(FIRMWARE_VER_SEG7_2);
Ind_PutDig3(FIRMWARE_VER_SEG7_3);
Ind_PutDig4(FIRMWARE_VER_SEG7_4);
Ind_MP_On();
if(bLockEnabled) Ind_LED_On(LOCK_LED);
Ind_Release();
}
void ModeVer(void)
{
if(Keyb_GetKey() == LOCK_KEY)
{
SetModeTest();
return;
}
if(Keyb_GetOnKey() != SELECT_KEY) SetModeStandBy();
}
////////////////////////////////////////////////////////////////
void SetModeStandBy(void)
{
cMode = MODE_STANDBY;
cOldMode = cMode;
cStage = STAGE_NONE;
AllWarmOff();
Ind_Clr();
Ind_PutDig1(SEG7_MINUS);
Ind_PutDig2(SEG7_MINUS);
Ind_PutDig3(SEG7_MINUS);
Ind_PutDig4(SEG7_MINUS);
if(bLockEnabled) Ind_LED_On(LOCK_LED); //добавил индикацию лока (ash)
Ind_Release();
SetMainProgram(1);
DisableIndUpdate();
}
void ModeStandBy(void)
{
if(cOldMode != cMode)
{
SetModeStandBy();
}
if(KbHit())
{
InKey();
if(cKey == HEAT_KEY)
{
ShortBeep();
SetMainProgram(0);
bProgramNumberChanged = FALSE;
cMode = MODE_COOKING;
SetStage(STAGE_KEEPWARM);
}
else if(cKey == MENU_KEY)
{
ShortBeep();
cMode = MODE_INPUT_PROGRAM;
}
else if(cKey == MULTICOOK_KEY)
{
ShortBeep();
SetMainProgram(0);
bProgramNumberChanged = FALSE;
cMode = MODE_INPUT_TEMP;
}
}
if(Keyb_GetOnKey() == TIMER_KEY
&& Keyb_GetOnKeyTime() >= 1000 && !Keyb_bLongPress
&& cMode != MODE_PAIRING)
{
Keyb_bLongPress = TRUE;
ShortBeep();
Clk_Delay_ms(250);
ShortBeep();
Clk_Delay_ms(250);
ShortBeep();
cClrPairing = 0;
cMode = MODE_PAIRING;
return;
}
if(Keyb_GetOnKey() == START_KEY
&& Keyb_GetOnKeyTime() >= 2000 && !Keyb_bLongPress
&& !cClrPairing)
{
Keyb_bLongPress = TRUE;
LongBeep(3);
cClrPairing = TRUE;
return;
}
if(Keyb_GetOnKey() == SELECT_KEY && Keyb_GetOnKeyTime() >= 200)
{
SetModeVer();
return;
}
}
void SetModePairing(void)
{
cMode = MODE_PAIRING;
cOldMode = cMode;
stateCT = 0; BlinkPairing();
SetIndUpdate(BlinkPairing, 50); //(ash)
cTimeToStandBy = 0;
}
void ModePairing(void)
{
if(cOldMode != cMode)
{
SetModePairing();
}
if(cTimeToStandBy > 10)
{
cMode = MODE_STANDBY;
}
if(KbHit())
{
InKey();
ShortBeep();
cMode = MODE_STANDBY;
}
}
//----------------------------------------------------------
// Режим выбора программы
void SetModeInputProgram(void)
{
cMode = MODE_INPUT_PROGRAM;
cOldMode = cMode;
bProgramNumberChanged = FALSE;
cStage = STAGE_NONE;
stateCT = 0; BlinkInpProgram();
SetIndUpdate(BlinkInpProgram, 50); //(ash)
cTimeToStandBy = 0;
}
void ModeInputProgram(void)
{
if(cOldMode != cMode)
{
SetModeInputProgram();
}
if(bProgramNumberChanged)
{
bProgramNumberChanged = FALSE;
if(CP_MainProgram.cProgramNumber == 0)
cMode = MODE_INPUT_TEMP; // Переход на Мултиповар
else
{
stateCT = 0; BlinkInpProgram();
}
}
if(bProuctNumberChanged)
{
bProuctNumberChanged = FALSE;
BlinkInpProgram();
}
if(cTimeToStandBy > 60)
{
cMode = MODE_STANDBY;
}
if(KbHit())
{
InKey();
if(cKey == MENU_KEY)
{
ShortBeep();
if(++CP_MainProgram.cProgramNumber > 12)
CP_MainProgram.cProgramNumber = 1;
SetMainProgram(CP_MainProgram.cProgramNumber);
bProgramNumberChanged = FALSE;
SetMainProuct(CP_MainProgram.cProductNumber);
bProuctNumberChanged = FALSE;
stateCT = 0; BlinkInpProgram();
RstIndUpdate();
}
else if(cKey == SELECT_KEY)
{
ShortBeep();
if(GetMainProuctCount() == 3)
{
if(CP_MainProgram.cProductNumber == 3) CP_MainProgram.cProductNumber = 2;
else if(CP_MainProgram.cProductNumber == 2) CP_MainProgram.cProductNumber = 1;
else CP_MainProgram.cProductNumber = 3;
SetMainProuct(CP_MainProgram.cProductNumber);
bProuctNumberChanged = FALSE;
_Ind_PutProduct(CP_MainProgram.cProductNumber);
Ind_Release();
}
}
else if(cKey == TIMER_KEY)
{
ShortBeep();
cMode = MODE_INPUT_COOKTIME;
}
else if(cKey == MULTICOOK_KEY)
{
ShortBeep();
SetMainProgram(0);
bProgramNumberChanged = FALSE;
cMode = MODE_INPUT_TEMP;
}
else if(cKey == HEAT_KEY)
{
ShortBeep();
cMode = MODE_STANDBY;
}
else if(cKey == START_KEY)
{
ShortBeep();
cMode = MODE_COOKING;
}
}
}
//----------------------------------------------------------
// Режим ввода времени готовки
void SetModeInputCookTime(void)
{
cMode = MODE_INPUT_COOKTIME;
cOldMode = cMode;
stateCT = 0; BlinkInpCookTime();
SetIndUpdate(BlinkInpCookTime, 50); //((ash)
cTimeToStandBy = 0;
}
void ModeInputCookTime(void)
{
U8 st;
if(cOldMode != cMode)
{
SetModeInputCookTime();
}
if(bCookTimeChanged)
{
bCookTimeChanged = FALSE;
stateCT = 0; BlinkInpCookTime();
}
if(cTimeToStandBy > 60)
{
cMode = MODE_STANDBY;
}
if(KbHit())
{
InKey();
if(cKey == MENU_KEY)
{
ShortBeep();
if(++CP_MainProgram.cProgramNumber > 12)
CP_MainProgram.cProgramNumber = 1;
SetMainProgram(CP_MainProgram.cProgramNumber);
bProgramNumberChanged = FALSE;
SetMainProuct(CP_MainProgram.cProductNumber);
bProuctNumberChanged = FALSE;
stateCT = 0; BlinkInpProgram();
RstIndUpdate();
cMode = MODE_INPUT_PROGRAM;
}
else if(cKey == PLUS_KEY)
{
if(CP_MainProgram.iCookTime < 60) st = CP_MainProgram.cStepTime[0];
else st = CP_MainProgram.cStepTime[1];
if(CP_MainProgram.iCookTime <= CP_MainProgram.iMaxTime-st)
{
CP_MainProgram.iCookTime += st;
}
else
{
CP_MainProgram.iCookTime = CP_MainProgram.iMinTime;
}
stateCT = 0; BlinkInpCookTime();
RstIndUpdate();
}
else if(cKey == MINUS_KEY)
{
if(CP_MainProgram.iCookTime <= 60) st = CP_MainProgram.cStepTime[0];
else st = CP_MainProgram.cStepTime[1];
if(CP_MainProgram.iCookTime >= CP_MainProgram.iMinTime+st)
{
CP_MainProgram.iCookTime -= st;
}
else
{
CP_MainProgram.iCookTime = CP_MainProgram.iMaxTime;
}
stateCT = 0; BlinkInpCookTime();
RstIndUpdate();
}
else if(cKey == TIMER_KEY)
{
if(CP_MainProgram.bPostPonementEnabled)
{
ShortBeep();
cMode = MODE_INPUT_POSTTIME;
}
}
else if(cKey == MULTICOOK_KEY)
{
ShortBeep();
SetMainProgram(0);
bProgramNumberChanged = FALSE;
cMode = MODE_INPUT_TEMP;
}
else if(cKey == HEAT_KEY)
{
ShortBeep();
cMode = MODE_STANDBY;
}
else if(cKey == START_KEY)
{
ShortBeep();
cMode = MODE_COOKING;
}
}
}
// Режим ввода времени отложенного старта
void SetModeInputPostponementTime(void)
{
cMode = MODE_INPUT_POSTTIME;
cOldMode = cMode;
// CP_MainProgram.iPostPonementTime = 60;
stateCT = 0; BlinkInpPostponementTime();
SetIndUpdate(BlinkInpPostponementTime, 50); //(ash)
cTimeToStandBy = 0;
}
void ModeInputPostponementTime(void)
{
if(cOldMode != cMode)
{
SetModeInputPostponementTime();
}
if(bPostPonementTimeChanged)
{
bPostPonementTimeChanged = FALSE;
BlinkInpPostponementTime();
}
if(cTimeToStandBy > 60)
{
cTimeToStandBy = 0;
cMode = MODE_STANDBY;
}
if(KbHit())
{
InKey();
if(cKey == MENU_KEY)
{
ShortBeep();
if(++CP_MainProgram.cProgramNumber > 12)
CP_MainProgram.cProgramNumber = 1;
SetMainProgram(CP_MainProgram.cProgramNumber);
bProgramNumberChanged = FALSE;
SetMainProuct(CP_MainProgram.cProductNumber);
bProuctNumberChanged = FALSE;
stateCT = 0; BlinkInpProgram();
RstIndUpdate();
cMode = MODE_INPUT_PROGRAM;
}
else if(cKey == PLUS_KEY)
{
if(CP_MainProgram.iPostPonementTime < 24*60-5)
{
CP_MainProgram.iPostPonementTime += 5;
}
else
{
CP_MainProgram.iPostPonementTime = 0;
}
stateCT = 0; BlinkInpPostponementTime();
RstIndUpdate();
}
else if(cKey == MINUS_KEY)
{
if(CP_MainProgram.iPostPonementTime > 5)
{
CP_MainProgram.iPostPonementTime -= 5;
}
else
{
CP_MainProgram.iPostPonementTime = 24*60;
}
stateCT = 0; BlinkInpPostponementTime();
RstIndUpdate();
}
else if(cKey == TIMER_KEY)
{
CP_MainProgram.iPostPonementTime = 0;
ShortBeep();
cMode = MODE_INPUT_COOKTIME;
}
else if(cKey == MULTICOOK_KEY)
{
ShortBeep();
SetMainProgram(0);
bProgramNumberChanged = FALSE;
cMode = MODE_INPUT_TEMP;
}
else if(cKey == HEAT_KEY)
{
ShortBeep();
cMode = MODE_STANDBY;
}
else if(cKey == START_KEY)
{
ShortBeep();
cMode = MODE_COOKING;
}
}
}
//-------------------------------------------------------
void SetModeInputTemperature(void)
{
cMode = MODE_INPUT_TEMP;
cOldMode = cMode;
stateCT = 0; BlinkInpTemperature();
SetIndUpdate(BlinkInpTemperature, 50); //(ash)
cTimeToStandBy = 0;
}
void ModeInputTemperature(void)
{
if(cOldMode != cMode)
{
SetModeInputTemperature();
}
if(bCookTempChanged)
{
bCookTempChanged = FALSE;
stateCT = 0; BlinkInpTemperature();
RstIndUpdate();
}
if(cTimeToStandBy > 60)
{
cMode = MODE_STANDBY;
}
if(KbHit())
{
InKey();
if(cKey == MENU_KEY)
{
ShortBeep();
SetMainProgram(1);
bProgramNumberChanged = FALSE;
cMode = MODE_INPUT_PROGRAM;
}
else if(cKey == PLUS_KEY)
{
if(CP_MainProgram.cCookTemp <= CP_MainProgram.cMaxValueTemp-5) //поменял < на <= (ash)
{
CP_MainProgram.cCookTemp += 5;
CP_MainProgram.cBotTempWarm += 5; // Нагрев до температуры (разгон)
//(ash) CP_MainProgram.cBotTempStat += 5; // Выход на статику до температур
stateCT = 0; BlinkInpTemperature();
RstIndUpdate();
}
}
else if(cKey == MINUS_KEY)
{
if(CP_MainProgram.cCookTemp >= CP_MainProgram.cMinValueTemp+5) //поменял > на >= (ash)
{
CP_MainProgram.cCookTemp -= 5;
CP_MainProgram.cBotTempWarm -= 5; // Нагрев до температуры (разгон)
//(ash) CP_MainProgram.cBotTempStat -= 5; // Выход на статику до температур
stateCT = 0; BlinkInpTemperature();
RstIndUpdate();
}
}
else if(cKey == TIMER_KEY)
{
ShortBeep();
cMode = MODE_INPUT_COOKTIME;
}
else if(cKey == HEAT_KEY)
{
ShortBeep();
cMode = MODE_STANDBY;
}
else if(cKey == START_KEY)
{
ShortBeep();
cMode = MODE_COOKING;
}
}
}
//--------------------------------------------------------
void SetModeCooking(void)
{
cMode = MODE_COOKING;
cOldMode = cMode;
if(cStage != STAGE_KEEPWARM) // Подогрев
{
cStage = STAGE_NONE;
ResetCurTime();
Ind_Clr();
_Ind_PutProduct(CP_MainProgram.cProductNumber);
_Ind_PutProgram_On(CP_MainProgram.cProgramNumber); //_Ind_PutProgram_Off ??????? ?? _Ind_PutProgram_On
if(CP_MainProgram.cProgramNumber == 0 && CP_MainProgram.cCookTemp < 75) // Мултиповар
CP_MainProgram.bKeepWarmEnabled = FALSE;
else
{
if(CP_MainProgram.bKeepWarmEnabled)
Ind_LED_On(HEAT_LED);
}
Ind_LED_On(START_LED);
if(CP_MainProgram.iPostPonementTime == 0)
{
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
}
else
{
Ind_LED_On(DEF_START_1_LED); Ind_LED_On(DEF_START_2_LED);
}
Ind_Release();
}
//(ash)
//если температура готовки ниже текущей
if(CP_MainProgram.cCookTemp < Temp_GetBotTemp())
Cook_TempErrBlockTimer = COOK_TEMP_ERR_BLOCK_TIME;
else Cook_TempErrBlockTimer = 0;
}
void RestoreModeCooking(void)
{
cMode = MODE_COOKING;
cOldMode = cMode;
Ind_Clr();
_Ind_PutProduct(CP_MainProgram.cProductNumber);
_Ind_PutProgram_On(CP_MainProgram.cProgramNumber); //_Ind_PutProgram_Off ??????? ?? _Ind_PutProgram_On
if(CP_MainProgram.cProgramNumber == 0 && CP_MainProgram.cCookTemp < 75) // Мултиповар
CP_MainProgram.bKeepWarmEnabled = FALSE;
else
{
if(CP_MainProgram.bKeepWarmEnabled)
Ind_LED_On(HEAT_LED);
}
Ind_LED_On(START_LED);
if(CP_MainProgram.iPostPonementTime == 0)
{
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
}
else
{
Ind_LED_On(DEF_START_1_LED); Ind_LED_On(DEF_START_2_LED);
}
SetIndUpdate(BlinkMP, 50); //(ash)
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
Ind_Release();
}
void ModeCooking(void)
{
if(cOldMode != cMode)
{
SetModeCooking();
StartCooking();
}
if(KbHit())
{
InKey();
if(cKey == HEAT_KEY)
{
ShortBeep();
cMode = MODE_STANDBY;
}
else if(cKey == START_KEY)
{
// ShortBeep(); //(ash)
if(cStage == STAGE_WAIT) // Ожидание закладки продуктов
{
ShortBeep(); //(ash)
SetStage(STAGE_WARM);
}
else
{
if(CP_MainProgram.cKeepWarmTime && (cStage != STAGE_KEEPWARM)) //вкл/выкл подогрев только на программах, где он предусмотрен (ash)
{
ShortBeep(); //(ash)
if(CP_MainProgram.bKeepWarmEnabled)
{
CP_MainProgram.bKeepWarmEnabled = FALSE;
Ind_LED_Off(HEAT_LED);
}
else
{
CP_MainProgram.bKeepWarmEnabled = TRUE;
Ind_LED_On(HEAT_LED);
}
}
}
}
#ifdef TEMP_IND_EN
//индикация температуры датчиков
else if(cKey == MINUS_KEY)
{
Ind_PutInt(Temp_GetBotTemp());
Ind_Release();
Clk_Delay_ms(1000); //ash
}
else if(cKey == PLUS_KEY)
{
Ind_PutInt(Temp_GetTopTemp());
Ind_Release();
Clk_Delay_ms(1000); //ash
}
#endif
////////////////////////////////////////////////////////////////
}
ProcessCooking();
if(bChangeTime) ShowCookingTime();
if(bChangeTimeTemp) ShowMultiCookTime();
}
void ShowCookingTime(void)
{
U8 hour, minute;
U16 iIndTime;
bChangeTime = FALSE;
if(cStage == STAGE_POSTPONEMENT)
iIndTime = GetRemainingTime(CP_MainProgram.iPostPonementTime);
else if(cStage == STAGE_BOOST || cStage == STAGE_WAIT)
{
iIndTime = CP_MainProgram.iCookTime;
}
else if(cStage == STAGE_WARM || cStage == STAGE_STAT)
iIndTime = GetRemainingTime(CP_MainProgram.iCookTime);
else
iIndTime = iCurTime;
hour = iIndTime / 60;
minute = iIndTime % 60;
Ind_PutTime(hour, minute);
if(bLockEnabled) Ind_LED_On(LOCK_LED);
else Ind_LED_Off(LOCK_LED);
Ind_Release();
}
void ShowMultiCookTime(void)
{
U8 hour, minute;
U16 iIndTime;
bChangeTimeTemp = FALSE;
iIndTime = GetRemainingTime(CP_MainProgram.iCookTime);
if(stateCT < 5)
{
Ind_LED_Off(TEMP1_LED); Ind_LED_Off(TEMP2_LED);
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
hour = iIndTime / 60;
minute = iIndTime % 60;
Ind_PutTime(hour, minute);
}
else
{
Ind_PutInt(CP_MainProgram.cCookTemp);
Ind_LED_Off(TIMER_1_LED); Ind_LED_Off(TIMER_2_LED);
Ind_LED_On(TEMP1_LED); Ind_LED_On(TEMP2_LED);
Ind_MP_Off();
}
if(bLockEnabled) Ind_LED_On(LOCK_LED);
else Ind_LED_Off(LOCK_LED);
Ind_Release();
}
//-----------------------------------------
void IsModeLock(void)
{
if(cKey == LOCK_KEY)
{
ShortBeep(); //добавил звук (ash)
if(bLockEnabled)
{
bLockEnabled = FALSE;
Ind_LED_Off(LOCK_LED);
Ind_Release();
}
else
{
bLockEnabled = TRUE;
Ind_LED_On(LOCK_LED);
Ind_Release();
}
}
if(bLockEnabled) cKey = 255; // Запрет дальнейше обработки
}
//-----------------------------------------
void BlinkInpProgram(void)
{
U8 i, hour, minute;
switch(stateCT)
{
case 0:
Ind_Clr();
_Ind_PutProduct(CP_MainProgram.cProductNumber);
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
hour = CP_MainProgram.iCookTime / 60;
minute = CP_MainProgram.iCookTime % 60;
Ind_PutTime(hour, minute);
for(i = 1; i < 13; i++) _Ind_PutProgram_On(i);
_Ind_PutProgram_Off(CP_MainProgram.cProgramNumber);
Ind_LED_On(START_LED);
Ind_MP_On();
if(bLockEnabled) Ind_LED_On(LOCK_LED);
Ind_Release();
stateCT = 1;
break;
case 1:
Ind_Clr();
_Ind_PutProduct(CP_MainProgram.cProductNumber);
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
hour = CP_MainProgram.iCookTime / 60;
minute = CP_MainProgram.iCookTime % 60;
Ind_PutTime(hour, minute);
for(i = 1; i < 13; i++) _Ind_PutProgram_On(i);
if(bLockEnabled) Ind_LED_On(LOCK_LED);
Ind_Release();
stateCT = 0;
break;
}
}
void BlinkInpCookTime(void)
{
U8 hour, minute;
switch(stateCT)
{
case 0:
Ind_Clr();
_Ind_PutProduct(CP_MainProgram.cProductNumber);
_Ind_PutProgram_On(CP_MainProgram.cProgramNumber);
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
Ind_LED_On(START_LED);
hour = CP_MainProgram.iCookTime / 60;
minute = CP_MainProgram.iCookTime % 60;
Ind_PutTime(hour, minute);
Ind_MP_On();
if(bLockEnabled) Ind_LED_On(LOCK_LED);
Ind_Release();
stateCT = 1;
break;
case 1:
Ind_Clr();
_Ind_PutProduct(CP_MainProgram.cProductNumber);
_Ind_PutProgram_On(CP_MainProgram.cProgramNumber);
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
if(bLockEnabled) Ind_LED_On(LOCK_LED);
Ind_Release();
stateCT = 0;
break;
}
}
void BlinkInpPostponementTime(void)
{
U8 hour, minute;
switch(stateCT)
{
case 0:
Ind_Clr();
_Ind_PutProduct(CP_MainProgram.cProductNumber);
_Ind_PutProgram_On(CP_MainProgram.cProgramNumber);
Ind_LED_On(DEF_START_1_LED); Ind_LED_On(DEF_START_2_LED);
Ind_LED_On(START_LED);
hour = CP_MainProgram.iPostPonementTime / 60;
minute = CP_MainProgram.iPostPonementTime % 60;
Ind_PutTime(hour, minute);
Ind_MP_On();
if(bLockEnabled) Ind_LED_On(LOCK_LED);
Ind_Release();
stateCT = 1;
break;
case 1:
Ind_Clr();
_Ind_PutProduct(CP_MainProgram.cProductNumber);
_Ind_PutProgram_On(CP_MainProgram.cProgramNumber);
Ind_LED_On(DEF_START_1_LED); Ind_LED_On(DEF_START_2_LED);
if(bLockEnabled) Ind_LED_On(LOCK_LED);
Ind_Release();
stateCT = 0;
break;
}
}
void BlinkInpTemperature(void)
{
switch(stateCT)
{
case 0:
Ind_Clr();
Ind_PutInt(CP_MainProgram.cCookTemp);
Ind_LED_On(TEMP1_LED); Ind_LED_On(TEMP2_LED);
Ind_LED_On(START_LED);
if(bLockEnabled) Ind_LED_On(LOCK_LED);
Ind_Release();
stateCT = 1;
break;
case 1:
Ind_Clr();
Ind_LED_On(TEMP1_LED); Ind_LED_On(TEMP2_LED);
if(bLockEnabled) Ind_LED_On(LOCK_LED);
Ind_Release();
stateCT = 0;
break;
}
}
void BlinkMP(void)
{
static int state;
switch(state)
{
case 0:
Ind_MP_On();
if(bLockEnabled) Ind_LED_On(LOCK_LED);
state = 1;
break;
case 1:
Ind_MP_Off();
if(bLockEnabled) Ind_LED_On(LOCK_LED);
state = 0;
break;
}
bChangeTime = TRUE;
}
void BlinkTimer(void)
{
static int state;
Ind_MP_On();
switch(state)
{
case 0:
Ind_LED_On(TIMER_2_LED);
if(bLockEnabled) Ind_LED_On(LOCK_LED);
state = 1;
break;
case 1:
Ind_LED_Off(TIMER_2_LED);
if(bLockEnabled) Ind_LED_On(LOCK_LED);
state = 0;
break;
}
bChangeTime = TRUE;
}
void BlinkMultiCook(void)
{
if(++stateCT > 11)
stateCT = 0;
if(stateCT < 5)
{
if(stateCT & 1) Ind_MP_Off();
else Ind_MP_On();
}
else if(stateCT >= 5 && stateCT < 11)
{
if(cStage != STAGE_WARM && cStage != STAGE_STAT)
stateCT = 0;
}
bChangeTimeTemp = TRUE;
}
void BlinkPairing(void)
{
static int statep;
switch(statep)
{
case 0:
Ind_Clr();
Ind_PutDig2(F_SEG|G_SEG|B_SEG|A_SEG);
Ind_PutDig3(C_SEG|D_SEG|E_SEG|G_SEG);
Ind_Release();
statep = 1;
break;
case 1:
Ind_Clr();
Ind_PutDig3(F_SEG|G_SEG|B_SEG|A_SEG);
Ind_PutDig2(C_SEG|D_SEG|E_SEG|G_SEG);
Ind_Release();
statep = 0;
break;
}
}
//--------------------------------------------------------
// вызов каждые 10ms
// времена, связанные с готовкой
void Cooking_Clk(void)
{
iTimeKeyRepeat++;
if(++iMilliSec >= 100) //(ash)>=
{
iMilliSec = 0;
iAnalizeTermInterval++;
cTimeToStandBy++;
if(Cook_TempErrBlockTimer) Cook_TempErrBlockTimer--;
}
}
void Cooking_Clk_1s(void)
{
if(++iSecond >= 60)
{
iSecond = 0;
iCurTime++;
}
}
void ResetCurTime(void)
{
iSecond = 0;
iCurTime = 0;
}
//----------------------------------------------------------
// Остаток времени (мин) между заданным и iCurTime
U16 GetRemainingTime(U16 time)
{
if(iCurTime > time) return(0);
else return(time - iCurTime);
}
//------------------------------------------------------------------------
// Старт рабочей программы
void StartCooking(void)
{
if(cStage == STAGE_KEEPWARM) return; // Подогрев
if(CP_MainProgram.iPostPonementTime > 0) SetStage(STAGE_POSTPONEMENT); // отложенный старт
else if(CP_MainProgram.bBoost == TRUE) SetStage(STAGE_BOOST); // Нагрев до кипения перед закладкой продуктов
else SetStage(STAGE_WARM); // Нагрев с продуктами до рабочей температуры
}
//------------------------------------------------------------------------
// Установка этапов готовки
void SetStage(U8 st)
{
if(st == STAGE_POSTPONEMENT) // Отложенный старт
{
SetIndUpdate(BlinkMP, 50); //(ash)
Ind_LED_On(DEF_START_1_LED); Ind_LED_On(DEF_START_2_LED);
Ind_LED_Off(TIMER_1_LED); Ind_LED_Off(TIMER_2_LED);
if(CP_MainProgram.iPostPonementTime > CP_MainProgram.iCookTime)
iLastPostPonementTime = CP_MainProgram.iPostPonementTime - CP_MainProgram.iCookTime;
else
iLastPostPonementTime = 0;
ResetCurTime();
cStage = STAGE_POSTPONEMENT;
}
else if(st == STAGE_BOOST) // Нагрев до кипения перед закладкой продуктов
{
SetIndUpdate(BlinkTimer, 50); //(ash)
Ind_LED_Off(DEF_START_1_LED); Ind_LED_Off(DEF_START_2_LED);
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
Ind_Release();
ResetCurTime();
cStage = STAGE_BOOST;
}
else if(st == STAGE_WAIT) // Ожидание закладки продуктов
{
ShowCookingTime();
cTimeToStandBy = 0;
cStage = STAGE_WAIT;
}
else if(st == STAGE_WARM) // Нагрев с продуктами
{
if(CP_MainProgram.cProgramNumber > 0) SetIndUpdate(BlinkMP, 50); //(ash)
else SetIndUpdate(BlinkMultiCook, 50); //(ash)
Ind_LED_Off(DEF_START_1_LED); Ind_LED_Off(DEF_START_2_LED);
Ind_LED_On(TIMER_1_LED); Ind_LED_On(TIMER_2_LED);
Ind_Release();
ResetCurTime();
cStage = STAGE_WARM;
}
else if(st == STAGE_STAT) // Поддержание заданной температуры
{
if(CP_MainProgram.cProgramNumber > 0) SetIndUpdate(BlinkMP, 50); //(ash)
else SetIndUpdate(BlinkMultiCook, 50); //((ash)
cStage = STAGE_STAT;
}
else if(st == STAGE_KEEPWARM) // Подогрев
{
CP_MainProgram.cBotTempWarm = 0;
CP_MainProgram.cTopTempStat = 0;
//(ash) CP_MainProgram.cBotTempStat = 0;
SetIndUpdate(BlinkMP, 50); //(ash)
Ind_Clr();
Ind_LED_On(HEAT_LED);
Ind_Release();
ResetCurTime();
cStage = STAGE_KEEPWARM;
}
}
//------------------------------------------------------------------------
// Готовка
void ProcessCooking(void)
{
//ash U8 ct;
if(cStage == STAGE_POSTPONEMENT) // Отложенный старт
{
if(iCurTime >= iLastPostPonementTime)
{
LongBeep(3); // Звонок
if(CP_MainProgram.bBoost == TRUE) SetStage(STAGE_BOOST); // Нагрев до кипения перед закладкой продуктов
else SetStage(STAGE_WARM); // Нагрев с продуктами
}
return;
}
if(cStage == STAGE_BOOST) // Нагрев до кипения перед закладкой продуктов
{
if(Heating(CP_MainProgram.cCookTemp)) SetStage(STAGE_WAIT);
return;
}
/*else*/ if(cStage == STAGE_WAIT) // Ожидание закладки продуктов
{
if(CP_MainProgram.cProgramNumber == STEAM) SetStage(STAGE_WARM);
else
{
FiveBeepTimeOut30Sec(); // 5 звонков через 30 сек
//ash
Heating(CP_MainProgram.cCookTemp + 30);
}
return;
}
/*else*/ if(cStage == STAGE_WARM) // Нагрев с продуктами до рабочей температуры
{
if(Heating(CP_MainProgram.cCookTemp)) SetStage(STAGE_STAT);
if(iCurTime >= CP_MainProgram.iCookTime) // переход на подогрев
{
ShowCookingTime();
LongFiveBeep();
SetStage(STAGE_KEEPWARM);
}
return;
}
/*else*/ if(cStage == STAGE_STAT) // Поддержание рабочей температуры
{
Heating(CP_MainProgram.cCookTemp);
if(iCurTime >= CP_MainProgram.iCookTime)
{
ShowCookingTime();
LongFiveBeep();
SetStage(STAGE_KEEPWARM);
}
return;
}
/*else*/ if(cStage == STAGE_KEEPWARM) // Подогрев 2/3 плана или 70
{
if(CP_MainProgram.bKeepWarmEnabled)
{
if(CP_MainProgram.cCookTemp < 95) Heating(CP_MainProgram.cCookTemp*2/3); //(ash) 70->95
else Heating(70);
if(iCurTime >= CP_MainProgram.cKeepWarmTime*60) StopCooking();
}
else StopCooking();
return;
}
}
void FiveBeepTimeOut30Sec(void) // 5 звонков через 30 сек конец Boost
{
if(cTimeToStandBy == 1) LongFiveBeep();
else if(cTimeToStandBy == 31) LongFiveBeep();
else if(cTimeToStandBy == 61) LongFiveBeep();
else if(cTimeToStandBy == 91) LongFiveBeep();
else if(cTimeToStandBy == 121) LongFiveBeep();
else if(cTimeToStandBy == 151) LongFiveBeep();
else if(cTimeToStandBy == 181) LongFiveBeep();
else if(cTimeToStandBy == 211) LongFiveBeep();
else if(cTimeToStandBy == 241) LongFiveBeep();
if(cTimeToStandBy > 250)
{
cMode = MODE_STANDBY;
}
}
//-----------------------------------------------------
// Нагрев ШИМ 6 ступеней по 4 секунды
BOOL Heating(U8 iTempPlan) //(ash) U16->U8
{
if(iAnalizeTermInterval < 4) return(FALSE);
iAnalizeTermInterval = 0;
if(++cCookPWM >= 6) cCookPWM = 0;
// iOldTermTop = iTermTop;
iTermTop = Temp_GetTopTemp();
iTermBot = Temp_GetBotTemp();
//(ash) при готовке пасты с открытой крышкой кипим на полную мощность
if(CP_MainProgram.cProgramNumber == PASTA && (cStage == STAGE_WARM || cStage == STAGE_STAT)) //(ash) готовится паста
{
WarmOn();
return TRUE;
}
//доводим до заданной температуры
if(iTempPlan == CP_MainProgram.cCookTemp) //для готовки (ash)
{
//разгон
if(iTermBot < CP_MainProgram.cBotTempWarm /*&& iTermTop < CP_MainProgram.cTopTempWarm*/) //(ash)
{
WarmOn();
return(FALSE);
}
//по верхнему датчику (используется только в диапазоне готовки 95...115гр) //(ash)
if(CP_MainProgram.cCookTemp >= 95 && CP_MainProgram.cCookTemp <= 115)
{
if(/*iTermBot < CP_MainProgram.cBotTempStat ||*/ iTermTop < CP_MainProgram.cTopTempStat)
{
if(!Cook_TempErrBlockTimer && iTermBot > CP_MainProgram.cCookTemp + 40) Err_Stop(EMPTY_POT_ERR); //(ash)
if(cCookPWM < 4 && iTermBot < CP_MainProgram.cCookTemp + 30) WarmOn(); //(ash)
else WarmOff();
return(FALSE);
}
}
}
else //(ash) для подогрева и пасты при ожидании закладки продуктов
{
if(iTermBot < iTempPlan-6)
{
WarmOn();
return FALSE;
}
}
//поддержание температуры (верхний датчик не используется) //(ash)
if(iTermBot > iTempPlan+1)
{
WarmOff();
return TRUE; // достигли заданной температуры
}
/*else*/ if(iTermBot > iTempPlan-1) //ash
{
if(cCookPWM < 1) WarmOn();
else WarmOff();
return TRUE;
}
/*else*/ if(iTermBot > iTempPlan-2) //ash
{
if(cCookPWM < 2) WarmOn();
else WarmOff();
return TRUE;
}
/*else*/ if(iTermBot > iTempPlan-3) //ash
{
if(cCookPWM < 3) WarmOn();
else WarmOff();
return TRUE;
}
if(cCookPWM < 4) WarmOn();
else WarmOff();
return TRUE;
}
//------------------------------------------------------------------------
// Стоп рабочей программы
void StopCooking(void)
{
cMode = MODE_STANDBY; // Ничего не делать
}
//------------------------------------------------------------------------
void WarmOn(void)
{
if(CP_MainProgram.cHeatEnable & HEAT_TOP_ENABLE) Heat_TopOn();
if(CP_MainProgram.cHeatEnable & HEAT_SIDE_ENABLE) Heat_SideOn();
if(CP_MainProgram.cHeatEnable & HEAT_MAIN_ENABLE) Heat_MainOn();
}
void WarmOff(void)
{
Heat_MainOff();
if(CP_MainProgram.cProgramNumber != PASTRY || cStage == STAGE_KEEPWARM || iTermTop >= 170) //(ash) STAGE_KEEPWARM
{
Heat_SideOff();
Heat_TopOff();
}
}
void AllWarmOff(void)
{
Heat_MainOff();
Heat_SideOff();
Heat_TopOff();
}
//---------------------------------------------------------------------
U8 KbHit(void) // сканирование в поисках нажатой клавиши
{
U8 cKeyInp;
cKeyInp = Keyb_GetOnKey();
if(cOldKey != cKeyInp) // буферизация нажатых клавиш
{
cOldKey = cKeyInp;
if(cKeyInp == 0 || cKeyInp == HEAT_KEY || cKeyInp == LOCK_KEY || cKeyInp == START_KEY)
{
iTimeKeyRepeat = 0;
return(0);
}
else if(cKeyInp == MINUS_KEY || cKeyInp == PLUS_KEY)
{
if(cMode == MODE_INPUT_COOKTIME || cMode == MODE_INPUT_POSTTIME ||
cMode == MODE_INPUT_TEMP /*||
cMode == MODE_INPUT_TEMP_MSL || cMode == MODE_INPUT_COOKTIME_MSL*/)
ShortBeep();
iTimeKeyRepeat = -80; //(ash) // задержка перед автоповтором
}
cKeyHead &= 0xf;
cKeyBuf[cKeyHead] = cKeyInp;
cKeyHead++;
}
else
{
if(cKeyInp != 0)
{
if(cKeyInp == MINUS_KEY || cKeyInp == PLUS_KEY)
{
if(iTimeKeyRepeat > 20) // 200ms (ash) // автоповтор 0.125 сек
{
iTimeKeyRepeat = 0;
cKeyHead &= 0xf;
cKeyBuf[cKeyHead] = cKeyInp;
cKeyHead++;
}
}
else if(cKeyInp == TIMER_KEY || cKeyInp == HEAT_KEY || cKeyInp == LOCK_KEY || cKeyInp == START_KEY)
{
if(iTimeKeyRepeat > 200 && iTimeKeyRepeat < 300) //(ash)
{
cKeyHead &= 0xf;
cKeyBuf[cKeyHead] = cKeyInp; // нажата 2 сек
cKeyHead++;
iTimeKeyRepeat = 300; //(ash) // срабатывает 1 раз
}
}
}
}
return(cKeyHead); // голова буфера, 0 при отсутствии нажатой клавиши
}
void InKey(void)
{
U8 i;
cKey = cKeyBuf[0]; // первая в буфере нажатая клавиша
if(cKeyHead > 0) cKeyHead--;
for(i = 0; i < 15; i++) cKeyBuf[i] = cKeyBuf[i+1]; // удаление ее из буфера
cKeyBuf[15] = 0;
IsModeLock(); // Блокировка клавиш?
cTimeToStandBy = 0;
}
//-----------------------------------------------------
void ShortBeep(void)
{
Buz_On();
Clk_Delay_ms(100); //ash
Buz_Off();
}
void LongBeep(U8 len)
{
Buz_On();
for(U8 i = 0; i < len; i++) Clk_Delay_ms(250); //ash
Buz_Off();
}
void LongFiveBeep(void)
{
for(U8 i = 0; i < 5; i++)
{
//(ash) for(U8 j = 0; j < 8; j++) ShortBeep(); // Звонок
LongBeep(3); //(ash)
Clk_Delay_ms(750); //(ash)
}
}
////////////////////////////////////////////////////////////////
//перенес из ind.c (ash)
static void _Ind_PutProgram_On(U8 num)
{
if(num == 1) Ind_LED_On(CEREALS_LED);
else if(num == 2) Ind_LED_On(SOAKING_LED);
else if(num == 3) Ind_LED_On(PILAW_LED);
else if(num == 4) Ind_LED_On(FRY_LED);
else if(num == 5) Ind_LED_On(STEW_LED);
else if(num == 6) Ind_LED_On(PASTA_LED);
else if(num == 7) Ind_LED_On(PORRIDGE_LED);
else if(num == 8) Ind_LED_On(SOUP_LED);
else if(num == 9) Ind_LED_On(YOGURT_LED);
else if(num == 10) Ind_LED_On(PASTRY_LED);
else if(num == 11) Ind_LED_On(STEAM_LED);
else if(num == 12) Ind_LED_On(BOILING_LED);
}
static void _Ind_PutProgram_Off(U8 num)
{
if(num == 1) Ind_LED_Off(CEREALS_LED);
else if(num == 2) Ind_LED_Off(SOAKING_LED);
else if(num == 3) Ind_LED_Off(PILAW_LED);
else if(num == 4) Ind_LED_Off(FRY_LED);
else if(num == 5) Ind_LED_Off(STEW_LED);
else if(num == 6) Ind_LED_Off(PASTA_LED);
else if(num == 7) Ind_LED_Off(PORRIDGE_LED);
else if(num == 8) Ind_LED_Off(SOUP_LED);
else if(num == 9) Ind_LED_Off(YOGURT_LED);
else if(num == 10) Ind_LED_Off(PASTRY_LED);
else if(num == 11) Ind_LED_Off(STEAM_LED);
else if(num == 12) Ind_LED_Off(BOILING_LED);
}
static void _Ind_PutProduct(U8 num)
{
Ind_LED_Off(VEGETABLES_LED);
Ind_LED_Off(FISH_LED);
Ind_LED_Off(MEAT_LED);
if(num == 1) Ind_LED_On(VEGETABLES_LED);
else if(num == 2) Ind_LED_On(FISH_LED);
else if(num == 3) Ind_LED_On(MEAT_LED);
}
////////////////////////////////////////////////////////////////
