def updateActuator(self, data: ActuatorData) -> bool:
"""
Use ActuatorData as command:
Update current maintained latest ActuatorData
Use given ActuatorData to execute command
:param data: Given ActuatorData
:return: If succeed to update and execute
"""
if data is None:
logging.error("Got an invalid ActuatorData, which is None!")
return False
if not isinstance(data, ActuatorData):
logging.error(
"Got an invalid ActuatorData, which type is not ActuatorData!")
return False
if data.getCommand(
) is not ActuatorData.COMMAND_ON and data.getCommand(
) is not ActuatorData.COMMAND_OFF:
logging.error(
"Got an invalid ActuatorData, whose command is invalid!")
return False
ret = False
if data.getCommand() is ActuatorData.COMMAND_ON:
ret = self.activateActuator(data.getValue())
else:
ret = self.deactivateActuator()
self.latestActuatorData.updateData(data)
self.latestActuatorData.setName(self.simpleName)
self.latestActuatorData.setStatusCode(int(ret))
self.latestActuatorData.setAsResponse()
return ret
pass
def testStartAndStopManagerWithMqtt(self):
"""
NOTE: Be sure to enable CoAP by setting the following flag to True
within PiotConfig.props
enableMqttClient = True
enableCoapClient = False
"""
ddMgr = DeviceDataManager()
ddMgr.startManager()
mqttClient = MqttClientConnector()
mqttClient.connectClient()
ad = ActuatorData()
ad.setCommand(1)
adJson = DataUtil().actuatorDataToJson(ad)
mqttClient.publishMessage(ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE,
msg=adJson,
qos=1)
sleep(10)
mqttClient.disconnectClient()
ddMgr.stopManager()
def testUpdateActuator(self):
ad = ActuatorData(actuatorType=ActuatorData.HVAC_ACTUATOR_TYPE)
ad.setCommand(ActuatorData.COMMAND_ON)
ad.setValue(self.DEFAULT_VAL_A)
self.assertTrue(self.hSimTask.updateActuator(ad))
adr = self.hSimTask.getLatestActuatorResponse()
self.assertIsNotNone(adr)
self.assertEqual(adr.getValue(), self.DEFAULT_VAL_A)
logging.info("ActuatorData: " + str(adr))
ad.setValue(self.DEFAULT_VAL_B)
self.assertTrue(self.hSimTask.updateActuator(ad))
adr = self.hSimTask.getLatestActuatorResponse()
self.assertIsNotNone(adr)
self.assertEqual(adr.getValue(), self.DEFAULT_VAL_B)
logging.info("ActuatorData: " + str(adr))
ad.setCommand(ActuatorData.COMMAND_OFF)
self.assertTrue(self.hSimTask.updateActuator(ad))
adr = self.hSimTask.getLatestActuatorResponse()
self.assertIsNotNone(adr)
self.assertEqual(adr.getCommand(), ActuatorData.COMMAND_OFF)
logging.info("ActuatorData: " + str(adr))
def testActuatorCmdPubSub(self):
qos = 0
delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE,
ConfigConst.KEEP_ALIVE_KEY,
ConfigConst.DEFAULT_KEEP_ALIVE)
actuatorData = ActuatorData()
actuatorData.setCommand(7)
self.mcc.setDataMessageListener(DefaultDataMessageListener())
payload = DataUtil().actuatorDataToJson(actuatorData)
self.mcc.connectClient()
sleep(5)
self.mcc.publishMessage(
resource=ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE,
msg=payload,
qos=qos)
sleep(delay + 5)
self.mcc.disconnectClient()
def testDefaultValues(self):
ad = ActuatorData()
self.assertEquals(ad.getCommand(), ConfigConst.DEFAULT_COMMAND)
self.assertEquals(ad.getStatusCode(), ConfigConst.DEFAULT_STATUS)
logging.info("Actuator data as string: " + str(ad))
def testUpdateActuator(self):
ad = ActuatorData(typeID=ConfigConst.HUMIDIFIER_ACTUATOR_TYPE)
ad.setCommand(ConfigConst.COMMAND_ON)
ad.setValue(self.DEFAULT_VAL_A)
adr = self.hSimTask.updateActuator(ad)
self.assertIsNotNone(adr)
self.assertEquals(adr.getValue(), self.DEFAULT_VAL_A)
logging.info("ActuatorData: " + str(adr))
ad.setValue(self.DEFAULT_VAL_B)
adr = self.hSimTask.updateActuator(ad)
self.assertIsNotNone(adr)
self.assertEquals(adr.getValue(), self.DEFAULT_VAL_B)
logging.info("ActuatorData: " + str(adr))
ad.setCommand(ConfigConst.COMMAND_OFF)
adr = self.hSimTask.updateActuator(ad)
self.assertIsNotNone(adr)
self.assertEquals(adr.getCommand(), ConfigConst.COMMAND_OFF)
logging.info("ActuatorData: " + str(adr))
def updateActuator(self, data: ActuatorData) -> bool:
"""
Override super class method.
Use _handleActuation to execute actuation
:param data: Given ActuatorData
:return: If succeed to update and execute
"""
if data is None:
logging.error("Got an invalid ActuatorData, which is None!")
return False
if not isinstance(data, ActuatorData):
logging.error(
"Got an invalid ActuatorData, which type is not ActuatorData!")
return False
cmd = data.getCommand()
if cmd != ActuatorData.COMMAND_ON and cmd != ActuatorData.COMMAND_OFF:
logging.error(
"Got an invalid ActuatorData, whose command is invalid!")
return False
ret = self._handleActuation(cmd, data.getValue(), data.getStateData())
self.latestActuatorData.updateData(data)
self.latestActuatorData.setStatusCode(int(ret))
self.latestActuatorData.setName(self.simpleName)
self.latestActuatorData.setAsResponse()
return ret >= 0
pass
def updateActuator(self, data: ActuatorData) -> bool: if data != None: if (data.getCommand() == 0): self.deactivateActuator() else: self.activateActuator(data.getCommand()) self.LatestActuatorData = data self.LatestActuatorData.setAsResponse() return True
def _createTestActuatorData(self):
ad = ActuatorData()
ad.setName(self.DEFAULT_NAME)
ad.setCommand(ActuatorData.COMMAND_ON)
ad.setStateData(self.DEFAULT_STATE_DATA)
ad.setValue(self.DEFAULT_VALUE)
return ad
def _createTestActuatorData(self):
ad = ActuatorData()
ad.setName(self.DEFAULT_NAME)
ad.setCommand(ConfigConst.COMMAND_ON)
ad.setStateData(self.DEFAULT_STATE_DATA)
ad.setValue(self.DEFAULT_VALUE)
logging.info("Actuator data as string: " + str(ad))
return ad
def __init__(self,
actuatorType: int = ActuatorData.DEFAULT_ACTUATOR_TYPE,
simpleName: str = "Actuator",
actuatorName=ConfigConst.NOT_SET):
"""
Initialization of class.
Create an instance of BaseActuatorSimTask
"""
self.actuatorType = actuatorType
self.simpleName = simpleName
self.latestAd = ActuatorData(name=actuatorName)
def __init__(self,
actuatorType: int = ActuatorData.DEFAULT_ACTUATOR_TYPE,
simpleName: str = ConfigConst.NOT_SET):
"""
Init BaseActuatorSimTask with default values
:param actuatorType: Type of actuator
:param simpleName: Name of actuator
"""
self.actuatorType = actuatorType
self.simpleName = simpleName
self.latestActuatorData = ActuatorData(self.actuatorType,
self.simpleName)
pass
def testLedDisplayEmulation(self):
ad = ActuatorData(actuatorType=ConfigConst.LED_DISPLAY_ACTUATOR_TYPE)
ad.setCommand(ConfigConst.COMMAND_ON)
ad.setStateData("What's up?")
self.actuatorAdapterMgr.sendActuatorCommand(ad)
ad.setCommand(ConfigConst.COMMAND_OFF)
self.actuatorAdapterMgr.sendActuatorCommand(ad)
def updateActuator(self, data: ActuatorData) -> bool:
"""
Update the Actuator
@return bool
"""
if data:
if data.getCommand() == ActuatorData.COMMAND_ON:
self.activateActuator(data.getValue())
else:
self.deactivateActuator()
self.latestAd._handleUpdateData(data)
self.latestAd.setAsResponse()
return True
def testActuatorCmdPubSub(self):
qos = 1
# NOTE: delay can be anything you'd like - the sleep() calls are simply to slow things down a bit for observation
delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE,
ConfigConst.KEEP_ALIVE_KEY,
ConfigConst.DEFAULT_KEEP_ALIVE)
actuatorData = ActuatorData()
payload = DataUtil().actuatorDataToJson(actuatorData)
listener = DefaultDataMessageListener()
self.mcc.setDataMessageListener(listener)
self.mcc.connectClient()
sleep(5)
self.mcc.publishMessage(
resource=ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE,
msg=payload,
qos=qos)
sleep(delay)
self.mcc.disconnectClient()
def testHumidifierEmulation(self):
ad = ActuatorData(actuatorType=ConfigConst.HUMIDIFIER_ACTUATOR_TYPE)
ad.setValue(50.0)
ad.setCommand(ConfigConst.COMMAND_ON)
self.actuatorAdapterMgr.sendActuatorCommand(ad)
ad.setCommand(ConfigConst.COMMAND_OFF)
self.actuatorAdapterMgr.sendActuatorCommand(ad)
def testLEDSimulation(self):
ad = ActuatorData(actuatorType=ActuatorData.LED_DISPLAY_ACTUATOR_TYPE)
ad.setStateData(stateData="Test stateData")
ad.setCommand(ActuatorData.COMMAND_ON)
self.actuatorAdapterMgr.sendActuatorCommand(ad)
ad.setCommand(ActuatorData.COMMAND_OFF)
self.actuatorAdapterMgr.sendActuatorCommand(ad)
def testHvacEmulation(self):
ad = ActuatorData(actuatorType=ConfigConst.HVAC_ACTUATOR_TYPE)
ad.setValue(22.5)
ad.setCommand(ConfigConst.COMMAND_ON)
self.actuatorAdapterMgr.sendActuatorCommand(ad)
ad.setCommand(ConfigConst.COMMAND_OFF)
self.actuatorAdapterMgr.sendActuatorCommand(ad)
def jsonToActuatorData(self, jsonData) -> ActuatorData: """ Convert json string to ActuatorData Instance :param jsonData: Given json string :return: Decoded ActuatorData Instance """ adDict: dict = json.loads(jsonData) ad = ActuatorData(d=adDict) return ad
def testUpdateEmulator(self):
ad = ActuatorData(actuatorType = ActuatorData.HVAC_ACTUATOR_TYPE)
ad.setCommand(ActuatorData.COMMAND_ON)
ad.setValue(22.0)
self.assertTrue(self.hvSimTask.updateActuator(ad))
adr = self.hvSimTask.getLatestActuatorResponse()
if adr:
self.assertEqual(adr.getCommand(), ActuatorData.COMMAND_ON)
self.assertEqual(adr.getStatusCode(), 0)
logging.info("ActuatorData: " + str(adr))
# wait 5 seconds
sleep(5)
else:
logging.warning("ActuatorData is None.")
ad.setValue(20.0)
self.assertTrue(self.hvSimTask.updateActuator(ad))
adr = self.hvSimTask.getLatestActuatorResponse()
if adr:
self.assertEqual(adr.getCommand(), ActuatorData.COMMAND_ON)
self.assertEqual(adr.getStatusCode(), 0)
logging.info("ActuatorData: " + str(adr))
# wait 5 seconds
else:
logging.warning("ActuatorData is None.")
ad.setCommand(ActuatorData.COMMAND_OFF)
self.assertTrue(self.hvSimTask.updateActuator(ad))
adr = self.hvSimTask.getLatestActuatorResponse()
if adr:
self.assertEqual(adr.getCommand(), ActuatorData.COMMAND_OFF)
self.assertEqual(adr.getStatusCode(), 0)
logging.info("ActuatorData: " + str(adr))
else:
logging.warning("ActuatorData is None.")
def testFullUpdate(self):
ad = ActuatorData()
ad2 = self._createTestActuatorData()
ad.updateData(ad2)
self.assertEquals(ad.getCommand(), ActuatorData.COMMAND_ON)
self.assertEquals(ad.getStateData(), self.DEFAULT_STATE_DATA)
self.assertEquals(ad.getValue(), self.DEFAULT_VALUE)
def handleActuatorCommandResponse(self, data: ActuatorData) -> bool:
"""
Callback function to handle an actuator command response packaged as a ActuatorData object.
@param data The ActuatorData message received.
@return bool True on success; False otherwise.
"""
if data:
logging.info('Actuator Command: ' + str(data.getCommand()))
return True
class BaseActuatorSimTask():
"""
Shell representation of class for student implementation.
"""
def __init__(self, actuatorType: int = ActuatorData.DEFAULT_ACTUATOR_TYPE, simpleName: str = "Actuator"):
self.actuatorType = actuatorType
self.LatestActuatorData = ActuatorData(actuatorType)
self.simpleName = simpleName
def activateActuator(self, val: float) -> bool:
logging.info("Sending Actuator On Command")
self.LatestActuatorData.command = ActuatorData.COMMAND_ON
return True
def deactivateActuator(self) -> bool:
logging.info("Sending Actuator Off Command")
self.LatestActuatorData.command = ActuatorData.COMMAND_OFF
return True
def getLatestActuatorResponse(self) -> ActuatorData:
return self.LatestActuatorData
def getSimpleName(self) -> str:
return self.simpleName
def updateActuator(self, data: ActuatorData) -> bool:
if data != None:
if (data.getCommand() == 0):
self.deactivateActuator()
else:
self.activateActuator(data.getCommand())
self.LatestActuatorData = data
self.LatestActuatorData.setAsResponse()
return True
def testWriteActuatorDataToCdaDataPath(self):
logging.info("\n\n----- [ActuatorData to JSON to file] -----")
dataObj = ActuatorData()
dataStr = self.dataUtil.actuatorDataToJson(dataObj)
fileName = self.cdaDataPath + '/ActuatorData.dat'
logging.info("Sample ActuatorData JSON (validated): " + str(dataStr))
logging.info("Writing ActuatorData JSON to CDA data path: " + fileName)
fileRef = Path(fileName)
fileRef.write_text(dataStr, encoding = 'utf-8')
def sendActuatorCommand(self, data: ActuatorData) -> bool:
logging.debug("Got ActuatorData: {}".format(data.__str__()))
if data.isResponse:
logging.info("Ignore response ActuatorData.")
return True
if self.useEmulator is False:
logging.info("Sending ActuatorData to simulated Actuators.")
if data.getActuatorType() is ActuatorData.HUMIDIFIER_ACTUATOR_TYPE:
self.humidifierActuator.updateActuator(data)
pass
elif data.getActuatorType() is ActuatorData.HVAC_ACTUATOR_TYPE:
self.hvacActuator.updateActuator(data)
pass
else:
logging.warning("Got ActuatorData for Actuator that has not been simulated.")
else:
logging.info("Sending ActuatorData to emulated Actuators.")
if data.getActuatorType() is ActuatorData.HUMIDIFIER_ACTUATOR_TYPE:
self.humidifierEmulator.updateActuator(data)
pass
elif data.getActuatorType() is ActuatorData.HVAC_ACTUATOR_TYPE:
self.hvacEmulator.updateActuator(data)
pass
elif data.getActuatorType() is ActuatorData.LED_DISPLAY_ACTUATOR_TYPE:
self.ledEmulator.updateActuator(data)
pass
else:
logging.warning("Got ActuatorData for Actuator that has not been simulated.")
return True
pass
def testUpdateEmulator(self):
ad = ActuatorData(actuatorType=ConfigConst.LED_DISPLAY_ACTUATOR_TYPE)
ad.setCommand(ConfigConst.COMMAND_ON)
ad.setStateData(self.HELLO_WORLD_A)
adr = self.lddSimTask.updateActuator(ad)
if adr:
self.assertEqual(adr.getCommand(), ConfigConst.COMMAND_ON)
self.assertEqual(adr.getStatusCode(), 0)
logging.info("ActuatorData: " + str(adr))
# wait 5 seconds
sleep(5)
else:
logging.warning("ActuatorData is None.")
ad.setStateData(self.HELLO_WORLD_B)
adr = self.lddSimTask.updateActuator(ad)
if adr:
self.assertEqual(adr.getCommand(), ConfigConst.COMMAND_ON)
self.assertEqual(adr.getStatusCode(), 0)
logging.info("ActuatorData: " + str(adr))
# wait 5 seconds
else:
logging.warning("ActuatorData is None.")
ad.setCommand(ConfigConst.COMMAND_OFF)
adr = self.lddSimTask.updateActuator(ad)
if adr:
self.assertEqual(adr.getCommand(), ConfigConst.COMMAND_OFF)
self.assertEqual(adr.getStatusCode(), 0)
logging.info("ActuatorData: " + str(adr))
else:
logging.warning("ActuatorData is None.")
def testUpdateEmulator(self):
ad = ActuatorData(typeID=ConfigConst.HUMIDIFIER_ACTUATOR_TYPE)
ad.setCommand(ConfigConst.COMMAND_ON)
ad.setValue(50.0)
adr = self.huSimTask.updateActuator(ad)
if adr:
self.assertEqual(adr.getCommand(), ConfigConst.COMMAND_ON)
self.assertEqual(adr.getStatusCode(), 0)
logging.info("ActuatorData: " + str(adr))
# wait 5 seconds
sleep(5)
else:
logging.warning("ActuatorData is None.")
ad.setValue(35.0)
adr = self.huSimTask.updateActuator(ad)
if adr:
self.assertEqual(adr.getCommand(), ConfigConst.COMMAND_ON)
self.assertEqual(adr.getStatusCode(), 0)
logging.info("ActuatorData: " + str(adr))
# wait 5 seconds
else:
logging.warning("ActuatorData is None.")
ad.setCommand(ConfigConst.COMMAND_OFF)
adr = self.huSimTask.updateActuator(ad)
if adr:
self.assertEqual(adr.getCommand(), ConfigConst.COMMAND_OFF)
self.assertEqual(adr.getStatusCode(), 0)
logging.info("ActuatorData: " + str(adr))
else:
logging.warning("ActuatorData is None.")
def updateActuator(self, data: ActuatorData) -> bool:
if data is not None:
if data.getCommand() == ActuatorData.COMMAND_ON:
self.activateActuator(data.value)
else:
self.deactivateActuator()
self.actuatorData._handleUpdateData(data)
self.actuatorData.setAsResponse()
logging.info(
"Emulating %s actuator %s:", self.simpleName,
"ON" if self.actuatorData.getCommand() == ActuatorData.COMMAND_ON
else "OFF")
return True
def _handleSensorDataAnalysis(self, data: SensorData):
"""
Call this from handleSensorMessage() to determine if there's
any action to take on the message. Steps to take:
1) Check config: Is there a rule or flag that requires immediate processing of data?
2) Act on data: If # 1 is true, determine what - if any - action is required, and execute.
"""
logging("_handleSensorDataAnalysis method is called...")
if (self.enableHandleTempChangeOnDevice == True):
self.actuatorData = ActuatorData()
self.actuatorData.actuator_type = ActuatorData.HVAC_ACTUATOR_TYPE
self.actuatorData.COMMAND_ON
self.actuatorAdapterManager.sendActuatorCommand(self.actuatorData)
pass
class BaseActuatorSimTask():
"""
Shell representation of class for student implementation.
"""
def __init__(self,
actuatorType: int = ActuatorData.DEFAULT_ACTUATOR_TYPE,
simpleName: str = "Actuator"):
self.actuatorType = actuatorType
self.simpleName = simpleName
self.actuatorData = ActuatorData(name=simpleName)
def activateActuator(self, val: float) -> bool:
logging.info("""\n*******\n* ON *\n*******\n%s Value: %f\n""",
self.simpleName, val)
self.actuatorData.setCommand(ActuatorData.COMMAND_ON)
return True
def deactivateActuator(self) -> bool:
logging.info("""\n*******\n* OFF *\n*******\n""")
self.actuatorData.setCommand(ActuatorData.COMMAND_OFF)
return True
def getLatestActuatorResponse(self) -> ActuatorData:
return self.actuatorData
def getSimpleName(self) -> str:
return self.simpleName
def updateActuator(self, data: ActuatorData) -> bool:
if data is not None:
if data.getCommand() == ActuatorData.COMMAND_ON:
self.activateActuator(data.value)
else:
self.deactivateActuator()
self.actuatorData._handleUpdateData(data)
self.actuatorData.setAsResponse()
logging.info(
"Emulating %s actuator %s:", self.simpleName,
"ON" if self.actuatorData.getCommand() == ActuatorData.COMMAND_ON
else "OFF")
return True
