Программный модуль для увлажнителя RHF-3310S
ПО является неотъемлемой частью увлажнителя RHF-3310S, отдельно потребителю не поставляется и эксплуатируется только в составе устройства.
Фрагмент исходного кода
////////////////////////////////////////////////////////////////
//RHF-3310S
//v2.14
//application.c
////////////////////////////////////////////////////////////////
/*==============================================================
include
==============================================================*/
#include "common.h"
#include "application.h"
#include "api.h"
#include "clk.h"
#include "buz.h"
#include "keyb.h"
#include "display.h"
#include "nrf_soc.h"
#include "adv_data_config.h"
#include "adv_data.h"
////////////////////////////////////////////////////////////////
u8 atomVar, atomPeriod, atomCnt;
u8 uartNoRxCnt;
u8 uartRxBuf[8], uartRxIndex;
static B8 bConnection;
bool bSendNotification = false;//флаг необходимости отправки нотификации
void simple_uart_config(uint8_t rts_pin_number, uint8_t txd_pin_number, uint8_t cts_pin_number, uint8_t rxd_pin_number, bool hwfc)
{
/** @snippet [Configure UART RX and TX pin] */
nrf_gpio_cfg_output(txd_pin_number);
nrf_gpio_cfg_input(rxd_pin_number, NRF_GPIO_PIN_NOPULL);
NRF_UART0->PSELTXD = txd_pin_number;
NRF_UART0->PSELRXD = rxd_pin_number;
/** @snippet [Configure UART RX and TX pin] */
NRF_UART0->CONFIG = 2;
if (hwfc)
{
nrf_gpio_cfg_output(rts_pin_number);
nrf_gpio_cfg_input(cts_pin_number, NRF_GPIO_PIN_NOPULL);
NRF_UART0->PSELCTS = cts_pin_number;
NRF_UART0->PSELRTS = rts_pin_number;
NRF_UART0->CONFIG = (UART_CONFIG_HWFC_Enabled << UART_CONFIG_HWFC_Pos);
}
NRF_UART0->BAUDRATE = (UART_BAUDRATE_BAUDRATE_Baud19200<< UART_BAUDRATE_BAUDRATE_Pos);
NRF_UART0->ENABLE = (UART_ENABLE_ENABLE_Enabled << UART_ENABLE_ENABLE_Pos);
NRF_UART0->TASKS_STARTTX = 0;
NRF_UART0->TASKS_STARTRX = 1;
NRF_UART0->EVENTS_RXDRDY = 0;
NRF_UART0->INTENSET = UART_INTENSET_RXDRDY_Set<<UART_INTENSET_RXDRDY_Pos;
NVIC_ClearPendingIRQ(UART0_IRQn);
NVIC_SetPriority(UART0_IRQn, APP_IRQ_PRIORITY_LOW);
NVIC_EnableIRQ(UART0_IRQn);
}
void ApplyIO_Init()
{
nrf_gpio_cfg_output(PIN_HEAT);
nrf_gpio_cfg_output(PIN_FAN);
nrf_gpio_cfg_output(PIN_ATOM);
nrf_gpio_cfg_input(PIN_WATER, NRF_GPIO_PIN_NOPULL);
nrf_gpio_cfg_input(PIN_HUM_IN, NRF_GPIO_PIN_NOPULL);
//=============================================================
// PIN_HUM_IN defined as UART's RX
simple_uart_config(0, PIN_NOT_USED, 0, PIN_HUM_IN, FALSE);
}
void UART0_IRQHandler(void)
{
// Handle reception
if (NRF_UART0->EVENTS_RXDRDY != 0){
// Clear UART RX event flag
NRF_UART0->EVENTS_RXDRDY = 0;
uartNoRxCnt = 0;
// Write received byte to FIFO
if(uartRxIndex <4) {
uartRxBuf[uartRxIndex++] = (u8)NRF_UART0->RXD;
if(uartRxIndex ==4) {
//---------------------------------------
if( ((u8)(uartRxBuf[0]+uartRxBuf[2]) == 0) &&
((u8)(uartRxBuf[1]+uartRxBuf[3]) == 0) ) {
curTemperature = uartRxBuf[0];
curHumidity = uartRxBuf[1];
if(curTemperature <10) curTemperature = 0;
else curTemperature -= 10;
}
uartRxIndex= 0;
}
}
}
// Handle transmission.
if (NRF_UART0->EVENTS_TXDRDY != 0)
{
// Clear UART TX event flag.
NRF_UART0->EVENTS_TXDRDY = 0;
}
}
//-------------------------------------------------------
// called every 10ms
void UartClk(void)
{
if(uartNoRxCnt < 250) uartNoRxCnt++;
if(uartNoRxCnt > 20) {
uartRxIndex = 0;
}
if(uartNoRxCnt > 230) { //接收超时
curHumidity = 0;
curTemperature = 0;
}
}
// disabled
void TIMER1_IRQHandler(void)
{
if(NRF_TIMER1->EVENTS_COMPARE[0]) {
NRF_TIMER1->EVENTS_COMPARE[0] = 0;
//----------------------------------------------------
}
}
void AtomOutClk()
{
if(++atomCnt > atomVar) NRF_GPIO->OUTCLR = (1UL << PIN_ATOM);
else NRF_GPIO->OUTSET = (1UL << PIN_ATOM);
if(atomCnt >= atomPeriod) atomCnt = 0;
}
////////////////////////////////////////////////////////////////
void Application_Init(void)
{
volatile u32 tmp32; //(jhb)
//(jhb) Clk_Init();
//(jhb) Buz_Init();
//(jhb) Keyb_Init();
//(jhb) DisplayPinInit();
//(jhb) ApplyIO_Init();
atomCnt = 0;
atomVar = 0;
atomPeriod = 10;
//(JHB) sysState = SYS_OFF;
//(JHB) atomPower = ATOM_POWER_LOW;
//(JHB) setHumidity = 70;
//(JHB) warmEnable = TRUE;
//(JHB) progMode = MODE_NORMAL;
timerOff = timerOffSleep = 0;
setTime = setTimeSleep = 0;
powerOnTime_sec = 1;
//-----------------------------------------------------------------------------------
//(ash) totalWorkTimeIn5Minute -> workTime_seconds
workTime_seconds = *((u32 *)(FLASH_ADDR_totalTime));
if(workTime_seconds == 0xffffffff) { // not initialed
workTime_seconds = 0;
{
u32 result;
do result = sd_flash_page_erase(FLASH_ADDR_totalTime/FLASH_PAGE_SIZE); while(result != NRF_SUCCESS);
do result = sd_flash_write((u32*)FLASH_ADDR_totalTime, &workTime_seconds, 1); while(result != NRF_SUCCESS);
}
}
// if(totalWorkTimeIn5Minute > (100*60/5) ){
#ifdef DEBUG
//очистка через 5 минут
if(workTime_seconds > 300){
#else
if(workTime_seconds > (100*3600) ){ //(ash)
#endif
cleanNeeded = TRUE;
}else {
cleanNeeded = FALSE;
}
// #ifdef DEBUG
// cleanNeeded = TRUE;
// #endif
//-----------------------------------------------------------------------------------
//(jhb) add
/*
tmp32 = *((u32 *)(FLASH_ADDR_sysState)); sysState = tmp32;
tmp32 = *((u32 *)(FLASH_ADDR_atomPower)); atomPower = tmp32;
tmp32 = *((u32 *)(FLASH_ADDR_setHumidity)); setHumidity = tmp32;
tmp32 = *((u32 *)(FLASH_ADDR_warmEnable)); warmEnable = tmp32;
tmp32 = *((u32 *)(FLASH_ADDR_progMode)); progMode = tmp32;
tmp32 = 0;
if(sysState > SYS_ON) tmp32++;
if(atomPower> ATOM_POWER_TURBO) tmp32++;
if((setHumidity >75) || (setHumidity <30) || ((setHumidity%5)!=0)) tmp32++;
if(progMode > MODE_AUTO) tmp32++;
*/
// if(tmp32) {
sysState = SYS_OFF;
atomPower = ATOM_POWER_LOW;
setHumidity = 70;
warmEnable = TRUE;
progMode = MODE_NORMAL;
//-------------------------------------
// }
//-----------------------------------------------------------------------
Clk_Init();
Buz_Init();
Keyb_Init();
DisplayPinInit();
ApplyIO_Init();
}
void WaterDetect(void)
{
static u8 waterDetCnt = 0;
u8 pinDet;
nrf_gpio_cfg_input(PIN_WATER, NRF_GPIO_PIN_NOPULL);
NOP2();
pinDet = (u8)nrf_gpio_pin_read(PIN_WATER);
//---------------------------------------------------------
if(pinDet) {// water enough
if(waterDetCnt< 200)waterDetCnt++;
else {
if(noWater) {
beepTimes = 0;
Buz_Off();
}
noWater = FALSE;
}
}else {
if(waterDetCnt)waterDetCnt--;
else {
noWater = TRUE;
}
}
}
u16 miDivCnt;
void TimeEvent(void)
{
// static u16 miDivCnt = 0; //(ash) u8 -> u16
if(flag_100ms) {
flag_100ms = FALSE;
//--------------------------------------
if(haltTime) haltTime--;
if(cleanedDly)cleanedDly--;
{//нотификации
static uint8_t lastApiState = API_ERROR_STATE, newApiState;
newApiState = API_GetState();
if(newApiState != lastApiState)
{
lastApiState = newApiState;
bSendNotification = true;
}
}
}
//===========================================
if(flag_500ms) {
flag_500ms = FALSE;
//-----------------------------------
//------------------------------------------------------
//(jhb) add 4 test
if(testValidTime < 200) testValidTime++;
if(testNoOperateTime < 200) testNoOperateTime++;
if(testNoOperateTime > 120 && testMode) {
testMode = FALSE;
}
if(testMode) {
if(testStep <15) testStep++;
}
//------------------------------------------------------
}
//===========================================
if(flag_1s) {
{
static uint8_t prevState = API_START_STATE;
uint8_t adv_app_state;
uint16_t adv_app_state_param = ADV_STAND_BY_PRM_NO;
//конвертер - настраивается в каждом старом проекте индивидуально
uint8_t state = API_GetState();
adv_app_state = state;
if(prevState != state)
{
if(adv_app_state == API_FW_UPDATE_STATE)
{
adv_app_state = ADV_ST_STAND_BY;
adv_app_state_param = ADV_STAND_BY_PRM_FW_UPDATE;
}
if(adv_app_state == API_PAIRING_STATE)
{
adv_app_state = ADV_ST_STAND_BY;
adv_app_state_param = ADV_STAND_BY_PRM_PAIRING;
}
app_advertising_set_app_state(adv_app_state, adv_app_state_param);
prevState = state;
}
}
flag_1s = FALSE;
if(fanEn) miDivCnt++; //(ash 22.06.2015) if(fanEn)
//---------------------------------------------
if(pairing) {
if(++pairStateCnt > 10) {
pairStateCnt = 0;
pairing = FALSE;
app_advertising_unset_paring_flag();
}
}
if( API_GetState() == API_FW_UPDATE_STATE)
{
if(!bConnection || ++fwUpdatingStateCnt > 30)
{
API_Off();
bFWupdatingError = TRUE;
Beep(2, 30);
}
}
//------------------------------------
if(noUserActiveCnt < 120) noUserActiveCnt++;
if(powerOnTime_sec != 0 ){ //(jhb) add
if(++powerOnTime_sec > 12) powerOnTime_sec=0; //(jhb) add
} //(jhb) add
//------------------------------------
if(noWater) {
if(noWaterEnsureCnt < 100){
noWaterEnsureCnt++;
if(noWaterEnsureCnt >= (6 + powerOnTime_sec/2)){ //(jhb) add
noWaterEnsureCnt=100;
if(sysState == SYS_ON) Beep(10, 50); //(ash) if(sysState == SYS_ON)
}
}
}else {
noWaterEnsureCnt = 0;
}
//------------------------------------
if(waitTime) {
waitTime--;
if(waitTime ==0) {
if(setIndex != SET_NULL) {
setIndex = SET_NULL;
showAlternCnt = 0;
}
}
}
//-----------------------------------
if(++showAlternCnt >= 20)showAlternCnt = 0;
//-----------------------------------
if(progMode == MODE_SLEEP)
{
if(timerOffSleep) {
if(++secondSleep >= 60) {
secondSleep = 0;
//--------------
if(++minuteSleep >= 60) {
minuteSleep = 0;
if(--timerOffSleep ==0) {
sysState = SYS_OFF;
}
}
}
}
}
if(timerOff) {
if(++second >= 60) {
second = 0;
//--------------
if(++minute >= 60) {
minute = 0;
if(--timerOff ==0 && progMode != MODE_SLEEP) {
sysState = SYS_OFF;
}
}
}
}
//----------------------------------------------------
//(jhb) add
if(needSaveDelay_sec) {
needSaveDelay_sec--;
if(needSaveDelay_sec ==0) {
u32 result;
static u32 tbuf[5]; //(ash) static or global!!!
tbuf[0] = sysState;
tbuf[1] = atomPower;
tbuf[2] = setHumidity;
tbuf[3] = warmEnable;
tbuf[4] = progMode;
do result = sd_flash_page_erase(FLASH_ADDR_sysState/FLASH_PAGE_SIZE); while(result != NRF_SUCCESS);
do result = sd_flash_write((u32*)FLASH_ADDR_sysState, tbuf, 5); while(result != NRF_SUCCESS);
}
}
}
//------------------------------------------------------------------------------------------
#ifdef DEBUG
if(miDivCnt >= 300) {// 5 minute
#else
if(miDivCnt >= (3600)) {// 1 hour (ash)
#endif
miDivCnt = 0;
//-------------------------------
//(ash 22.06.2015 if(sysState == SYS_ON) { // only in working
if(cleanNeeded == FALSE && (autoStop==FALSE)) {//(JHB) add: &&(autoStop==FALSE)
// totalWorkTimeIn5Minute++;
#ifdef DEBUG
workTime_seconds += 300;
#else
workTime_seconds += 3600; //(ash)
#endif
{
u32 result;
do result = sd_flash_page_erase(FLASH_ADDR_totalTime/FLASH_PAGE_SIZE); while(result != NRF_SUCCESS);
do result = sd_flash_write((u32*)FLASH_ADDR_totalTime, &workTime_seconds, 1); while(result != NRF_SUCCESS);
}
}
//------------------------------------------
// if(totalWorkTimeIn5Minute > (100*60/5)){
#ifdef DEBUG
//очистка через 5 минут
if(workTime_seconds > 300){
#else
if(workTime_seconds > (100*3600) ){//(ash)
#endif
if(cleanNeeded == FALSE) {
Beep(3, 30);
}
cleanNeeded = TRUE;
}else {
cleanNeeded = FALSE;
}
//(ash 22.06.2015) }
}
}
//----------------------------------------------------------
//(jhb) add 4 test
void OutPut4Test()
{
nrf_gpio_cfg_output(PIN_HEAT);
nrf_gpio_cfg_output(PIN_FAN);
nrf_gpio_cfg_output(PIN_ATOM);
if(heatEn) nrf_gpio_pin_set(PIN_HEAT);
else nrf_gpio_pin_clear(PIN_HEAT);
if(fanEn) {
nrf_gpio_pin_set(PIN_FAN);
}else {
nrf_gpio_pin_clear(PIN_FAN);
}
if(noWater) atomVar = 0;
else{
switch(atomPower) {
case ATOM_POWER_OFF: atomVar = 0; break;
case ATOM_POWER_LOW: atomVar = 2; break;
case ATOM_POWER_MID: atomVar = 3; break;
case ATOM_POWER_HIGH: atomVar = 4; break;
case ATOM_POWER_TURBO: atomVar = 5; break;
default : break;
}
}
}
void OutPutCtrl(void)
{
static u16 fanOutDly = 0;
u8 power;
if(testMode) {
OutPut4Test();
return;
}
nrf_gpio_cfg_output(PIN_HEAT);
nrf_gpio_cfg_output(PIN_FAN);
nrf_gpio_cfg_output(PIN_ATOM);
if(powerOnTime_sec ==1)return; //(jhb)
//--------------------------------------------------------------------------
if(fanEn) {
nrf_gpio_pin_set(PIN_FAN);
fanOutDly = 700;
}else {
if(fanOutDly) fanOutDly--;
else nrf_gpio_pin_clear(PIN_FAN);
}
if(heatEn) nrf_gpio_pin_set(PIN_HEAT);
else nrf_gpio_pin_clear(PIN_HEAT);
atomPeriod = 5;
if(sysState == SYS_OFF || noWater /*|| cleanNeeded*/) {
atomVar = 0;
}else {
power = atomPower;
if(fanEn == FALSE) power = ATOM_POWER_OFF;
if(autoStop ){ //(jhb) add
atomVar = 0; //(jhb) add
return; //(jhb) add
} //(jhb) add
switch(power) {
case ATOM_POWER_OFF: atomVar = 0; break;
case ATOM_POWER_LOW: atomVar = 2; break;
case ATOM_POWER_MID: atomVar = 3; break;
case ATOM_POWER_HIGH: atomVar = 4; break;
case ATOM_POWER_TURBO: atomVar = 5; break;
default : break;
}
}
}
////////////////////////////////////////////////////////////////
void Application(void)
{
u8 humi = setHumidity;
if(humi >70) humi = 70;
if(testMode) return; //(test)
if(sysState == SYS_OFF /*|| cleanNeeded*/) {
fanEn = FALSE;
heatEn = FALSE;
return;
}
//=====================================
switch(progMode){
case MODE_SLEEP: // 固定暖雾，中档雾化量，定时8小时， 不允许其他操作
atomPower = ATOM_POWER_MID; // 300 ml/h
warmEnable = TRUE; //(jhb) 规格书要求睡眠模式统一切换成暖雾模式
heatEn = TRUE;
fanEn = TRUE;
autoStop = FALSE; //(jhb)add
break;
//-----------------------------------------
case MODE_NORMAL:// 暖雾可调、定时可调、湿度可调、雾化量可调
if(atomPower > ATOM_POWER_HIGH) atomPower = ATOM_POWER_HIGH; //(ash)
if(setHumidity == 75){
heatEn = warmEnable;
fanEn = TRUE;
autoStop = FALSE; //(jhb)add
break;
}
if(curHumidity > humi ) {
heatEn = FALSE;
fanEn = FALSE;
autoStop = TRUE; //(jhb)add
}else if((curHumidity+5) <= humi){//2015-12-2 restart threshold value -> 5
heatEn = warmEnable;
fanEn = TRUE;
autoStop = FALSE; //(jhb)add
}else { //(jhb)2015-12-28
if(autoStop) heatEn = FALSE;
else heatEn = warmEnable;
}
break;
//-----------------------------------------
case MODE_TURBO: // 暖雾可调、定时可调、湿度可调、雾化量不可调
atomPower = ATOM_POWER_TURBO; //(ash)
if(setHumidity == 75){
heatEn = warmEnable;
fanEn = TRUE;
//(ash) atomPower = ATOM_POWER_TURBO;
autoStop = FALSE; //(jhb)add
break;
}
if(curHumidity > humi ) {
heatEn = FALSE;
fanEn = FALSE;
autoStop = TRUE; //(jhb)add
}else if((curHumidity+5) <= humi){ //2015-12-2 restart threshold value -> 5
//(ash) atomPower = ATOM_POWER_TURBO; // 400 ml/h
heatEn = warmEnable;
fanEn = TRUE;
autoStop = FALSE; //(jhb)add
}else { //(jhb)2015-12-28
if(autoStop) heatEn = FALSE;
else heatEn = warmEnable;
}
break;
//-----------------------------------------
case MODE_AUTO: // 暖雾可调、定时可调、湿度不可调,固定70%、雾化量不可调
//(jhb) if(setHumidity == 75){
//(jhb) heatEn = warmEnable;
//(jhb) fanEn = TRUE;
//(jhb) atomPower = ATOM_POWER_HIGH;
//(jhb) break;
//(jhb) }
atomPower = ATOM_POWER_HIGH; //(ash)
if(curHumidity > 70 ) {//(jhb) humi->70
heatEn = FALSE;
fanEn = FALSE;
autoStop = TRUE; //(jhb)add
}else if((curHumidity) <= 65){ //(jhb) 70->65
//(ash) atomPower = ATOM_POWER_HIGH; // 400 ml/h
heatEn = warmEnable;
fanEn = TRUE;
autoStop = FALSE; //(jhb)add
}else { //(jhb)2015-12-28
if(autoStop) heatEn = FALSE;
else heatEn = warmEnable;
}
break;
//-----------------------------------------
default : break;
}
//==========================================
if(noWater) {
fanEn = FALSE;
heatEn = FALSE;
}
}
////////////////////////////////////////////////////////////////
//API for R4S
//The all Set...() functions return a true/false (Success/Fail) value
////////////////////////////////////////////////////////////////
//Get firmvare version
uint16_t API_GetVersion(void)
{
return FIRMWARE_VER;
}
////////////////////////////////////////////////////////////////
//On device
bool API_On(void)
{
if(sysState != SYS_OFF) return TRUE; //(ash 12.01.2016)
noUserActiveCnt = 0;
sysState = SYS_ON;
if(progMode > MODE_AUTO)progMode = MODE_NORMAL;
if(atomPower == ATOM_POWER_OFF || atomPower > ATOM_POWER_TURBO) atomPower = ATOM_POWER_LOW;
return TRUE;
}
//Off device
bool API_Off(void)
{
//(ash 12.01.2016) if(sysState == SYS_OFF && !pairing) return FALSE;
bFWupdating = FALSE;
fwUpdatingStateCnt = 0;
fwUpdateDispCnt = 0;
pairing = FALSE;
app_advertising_unset_paring_flag();
sysState = SYS_OFF;
setIndex = SET_NULL;
timerOff = timerOffSleep = 0;
setTimeSleep = setTime = timerOff; //(ash)
return TRUE;
}
////////////////////////////////////////////////////////////////
//Get device state
uint8_t API_GetState(void)
{
u8 res;
if(sysState == SYS_OFF) res = API_OFF_STATE;
else {
if(noWater) res = API_NO_WATER_STATE;
else res = API_ON_STATE;
}
if(pairing) res = API_PAIRING_STATE;
if(bFWupdating) res = API_FW_UPDATE_STATE;
if(testMode) res = API_TEST_STATE;
return res;
}
void API_ENTER_FW_UPDATE(void)
{
bFWupdating = TRUE;
}
////////////////////////////////////////////////////////////////
void API_FW_UPDATE_PROC(void)
{
fwUpdatingStateCnt = 0;
}
////////////////////////////////////////////////////////////////
//Get program
uint8_t API_GetProgram(void)
{
return progMode;
}
//Set program
bool API_SetProgram(uint8_t prog)
{
if(prog > MODE_AUTO) return FALSE;
progMode = prog;
if(progMode == MODE_SLEEP) {
secondSleep = 0;
minuteSleep = 0;
timerOffSleep = 8;
setTimeSleep = timerOffSleep;
// warmEnable ^= TRUE; //(ash)
warmEnable = TRUE;
}
noUserActiveCnt = 0;
bSendNotification = true;
return TRUE;
}
////////////////////////////////////////////////////////////////
//Get mode
uint8_t API_GetMode(void)
{
return atomPower;
}
//Set mode
bool API_SetMode(uint8_t var)
{
if(progMode != MODE_NORMAL) return FALSE;
if(var == 0) return FALSE;
if(var >= ATOM_POWER_TURBO) return FALSE;
//(ash) if(autoStop) return FALSE; //(jhb)
atomPower = var;
bSendNotification = true;
return TRUE;
}
////////////////////////////////////////////////////////////////
//Humidity value is from 30 to 75
//Get set humidity
uint8_t API_GetHumidity(void)
{
if(progMode == MODE_AUTO) return 70;
return setHumidity;
}
//Set humidity
bool API_SetHumidity(uint8_t hum)
{
if(hum)
if(progMode == MODE_SLEEP) return FALSE;
if(progMode == MODE_AUTO && hum != 70) return FALSE;
if(hum <30 || hum > 75) return FALSE;
if((hum%5) != 0) return FALSE;
noUserActiveCnt = 0;
setHumidity = hum;
setIndex = SET_HUMIDITY;
waitTime = WAIT_TIME_SECONDS;
haltTime = HALT_TIME_100MS;
bSendNotification = true;
return TRUE;
}
////////////////////////////////////////////////////////////////
//Get work time in hours
uint8_t API_GetTime(void)
{
if(progMode == MODE_SLEEP)
{
return setTimeSleep;
}
else
{
return setTime;
}
}
//Set work time in hours
bool API_SetTime(uint8_t time)
{
if(time > 8) return FALSE;
if(progMode == MODE_SLEEP) return FALSE;
noUserActiveCnt = 0;
setTime = time;
timerOff = time;
minute = 0;
second = 0;
setIndex = SET_TIMER;
waitTime = WAIT_TIME_SECONDS;
haltTime = HALT_TIME_100MS;
bSendNotification = true;
return TRUE;
}
////////////////////////////////////////////////////////////////
//Get warm mist state (ON/OFF)
uint8_t API_GetHeating(void)
{
return heatEn;
}
//Set warm mist state (ON/OFF)
bool API_SetHeating(uint8_t warm)
{
if(progMode == MODE_SLEEP) return FALSE;
if(warm != API_ON && warm != API_OFF) return FALSE;
//(ash) if(autoStop) return FALSE; //(jhb)
noUserActiveCnt = 0;
warmEnable = warm;
setIndex = SET_NULL;
bSendNotification = true;
return TRUE;
}
////////////////////////////////////////////////////////////////
//Get time to end of work in minutes
uint16_t API_GetEndTime(void)
{
if(progMode == MODE_SLEEP)
{
if(timerOffSleep) return timerOffSleep * 60 - minuteSleep;
}
else
{
if(timerOff) return timerOff * 60 - minute; //(ash) if(timerOff)
}
return 0; //(ash)
}
////////////////////////////////////////////////////////////////
//Get current humidity
uint8_t API_GetCurrentHumidity(void)
{
return curHumidity;
}
////////////////////////////////////////////////////////////////
//Return a state of the unpairing flag
bool API_IsUnpairing(void)
{
return unpairingFlag;
}
//Clear unpairing flag
void API_ClrUnpairing(void)
{
unpairingFlag = FALSE;
}
////////////////////////////////////////////////////////////////
void API_SetConnection(void)
{
bConnection = true;
}
void API_ClrConnection(void)
{
bConnection = false;
}
////////////////////////////////////////////////////////////////
//Buz control
void API_Beep(u8 n, u8 len)
{
Beep(n, len);
}
////////////////////////////////////////////////////////////////
//this function is not used from now (07.2017)
uint8_t API_ResetFilterClean (uint8_t clean)
{
if (clean > 0) return 0;
else
{
#ifdef DEBUG
cleanNeeded ^= 1;
#else
cleanNeeded = clean;
#endif
}
return 1;
}
uint8_t api_get_error(void)
{
uint8_t err = 0;
uint8_t app_state = API_GetState();
switch(app_state)
{
case API_NO_WATER_STATE:
case API_ERROR_STATE:
err = APP_API_WATER_ERROR;
break;
default:
err = APP_API_NO_ERROR;
break;
}
if(cleanNeeded) err |= APP_API_FILTER_NEED_CLEAN_ERROR;
return err;
}
