136 lines
3.1 KiB
C++
136 lines
3.1 KiB
C++
#include "PowerSwitcher.h"
|
|
|
|
#include "../objectmanager/ObjectManager.h"
|
|
#include "../serviceinterface/ServiceInterface.h"
|
|
|
|
PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
|
|
PowerSwitcher::State_t setStartState):
|
|
state(setStartState), firstSwitch(setSwitch1),
|
|
secondSwitch(setSwitch2) {
|
|
}
|
|
|
|
ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
|
|
power = ObjectManager::instance()->get<PowerSwitchIF>(powerSwitchId);
|
|
if (power == nullptr) {
|
|
return HasReturnvaluesIF::RETURN_FAILED;
|
|
}
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t PowerSwitcher::getStateOfSwitches() {
|
|
SwitchReturn_t result = howManySwitches();
|
|
|
|
switch (result) {
|
|
case ONE_SWITCH:
|
|
return power->getSwitchState(firstSwitch);
|
|
case TWO_SWITCHES: {
|
|
ReturnValue_t firstSwitchState = power->getSwitchState(firstSwitch);
|
|
ReturnValue_t secondSwitchState = power->getSwitchState(firstSwitch);
|
|
if ((firstSwitchState == PowerSwitchIF::SWITCH_ON)
|
|
&& (secondSwitchState == PowerSwitchIF::SWITCH_ON)) {
|
|
return PowerSwitchIF::SWITCH_ON;
|
|
}
|
|
else if ((firstSwitchState == PowerSwitchIF::SWITCH_OFF)
|
|
&& (secondSwitchState == PowerSwitchIF::SWITCH_OFF)) {
|
|
return PowerSwitchIF::SWITCH_OFF;
|
|
}
|
|
else {
|
|
return HasReturnvaluesIF::RETURN_FAILED;
|
|
}
|
|
}
|
|
default:
|
|
return HasReturnvaluesIF::RETURN_FAILED;
|
|
}
|
|
}
|
|
|
|
void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
|
|
SwitchReturn_t result = howManySwitches();
|
|
switch (result) {
|
|
case TWO_SWITCHES:
|
|
power->sendSwitchCommand(secondSwitch, onOff);
|
|
/* NO BREAK falls through*/
|
|
case ONE_SWITCH:
|
|
power->sendSwitchCommand(firstSwitch, onOff);
|
|
break;
|
|
}
|
|
return;
|
|
|
|
}
|
|
|
|
void PowerSwitcher::turnOn() {
|
|
commandSwitches(PowerSwitchIF::SWITCH_ON);
|
|
state = WAIT_ON;
|
|
}
|
|
|
|
void PowerSwitcher::turnOff() {
|
|
commandSwitches(PowerSwitchIF::SWITCH_OFF);
|
|
state = WAIT_OFF;
|
|
}
|
|
|
|
PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
|
|
if (secondSwitch == NO_SWITCH) {
|
|
return ONE_SWITCH;
|
|
} else {
|
|
return TWO_SWITCHES;
|
|
}
|
|
}
|
|
|
|
void PowerSwitcher::doStateMachine() {
|
|
switch (state) {
|
|
case SWITCH_IS_OFF:
|
|
case SWITCH_IS_ON:
|
|
//Do nothing.
|
|
break;
|
|
case WAIT_OFF:
|
|
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
|
|
state = SWITCH_IS_OFF;
|
|
}
|
|
break;
|
|
case WAIT_ON:
|
|
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
|
|
state = SWITCH_IS_ON;
|
|
}
|
|
break;
|
|
default:
|
|
//Should never happen.
|
|
break;
|
|
}
|
|
}
|
|
|
|
ReturnValue_t PowerSwitcher::checkSwitchState() {
|
|
switch (state) {
|
|
case WAIT_OFF:
|
|
case WAIT_ON:
|
|
return IN_POWER_TRANSITION;
|
|
case SWITCH_IS_OFF:
|
|
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
|
|
return RETURN_OK;
|
|
} else {
|
|
return SWITCH_STATE_MISMATCH;
|
|
}
|
|
case SWITCH_IS_ON:
|
|
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
|
|
return RETURN_OK;
|
|
} else {
|
|
return SWITCH_STATE_MISMATCH;
|
|
}
|
|
}
|
|
return RETURN_FAILED;
|
|
}
|
|
|
|
PowerSwitcher::State_t PowerSwitcher::getState() {
|
|
return state;
|
|
}
|
|
|
|
uint32_t PowerSwitcher::getSwitchDelay() {
|
|
return power->getSwitchDelayMs();
|
|
}
|
|
|
|
uint8_t PowerSwitcher::getFirstSwitch() const {
|
|
return firstSwitch;
|
|
}
|
|
|
|
uint8_t PowerSwitcher::getSecondSwitch() const {
|
|
return secondSwitch;
|
|
}
|