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 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 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 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 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 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 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 _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 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 testActuatorDataCallback(self):
ddMgr = DeviceDataManager()
actuatorData = ActuatorData(typeID=ConfigConst.HVAC_ACTUATOR_TYPE)
actuatorData.setCommand(ConfigConst.COMMAND_ON)
actuatorData.setStateData("This is a test.")
ddMgr.handleActuatorCommandMessage(actuatorData)
sleep(10)
def testStartAndStopManagerWithMqttAndCoap(self):
ddMgr = DeviceDataManager(enableMqtt=False, enableCoap=False)
actuatorData = ActuatorData(
actuatorType=ActuatorData.HVAC_ACTUATOR_TYPE)
actuatorData.setCommand(ActuatorData.COMMAND_ON)
actuatorData.setStateData("This is a test.")
ddMgr.handleActuatorCommandMessage(actuatorData)
sleep(10)
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 testActuatorDataConversionsFromJsonUsingDecimal(self):
logging.info("\n\n----- [ActuatorData Conversions from JSON] -----")
adData = ActuatorData()
adData.setCommand(1)
adData.setStateData("This is a test.")
jsonData1 = self.dataUtil.actuatorDataToJson(adData, True)
logging.info("\n\nActuatorData to JSON:\n\n" + str(jsonData1))
adData2 = self.dataUtil.jsonToActuatorData(jsonData1)
logging.info("\n\nJSON to ActuatorData:\n\n" + str(adData2))
jsonData2 = self.dataUtil.actuatorDataToJson(adData2, True)
logging.info("\n\nActuatorData back to JSON:\n\n" + str(jsonData2))
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.info("_handleSensorDataAnalysis called，msg:"+str(data))
if self.enableHandleTempChangeOnDevice is True:
hvac = ActuatorData(ActuatorData.HVAC_ACTUATOR_TYPE)
if data.getValue() < self.triggerHvacTempCeiling and data.getValue() > self.triggerHvacTempFloor:
# start hvac when in trigger range
hvac.setCommand(ActuatorData.COMMAND_ON)
else:
# stop hvac when not in range
hvac.setCommand(ActuatorData.COMMAND_OFF)
# send command
self.aam.sendActuatorCommand(hvac)
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.")
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
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 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 _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.info(
"[CDA_CALLBACK]----->>>The _handleSensorDataAnalysis method is being called"
)
"""
"""
if self.enableHandleTempChangeOnDevice and data.getSensorType(
) == SensorData.TEMP_SENSOR_TYPE:
ad = ActuatorData(actuatorType=ActuatorData.HVAC_ACTUATOR_TYPE)
value = data.getValue()
if value >= self.triggerHvacTempFloor and value <= self.triggerHvacTempCeiling:
ad.setCommand(ActuatorData.COMMAND_OFF)
else:
ad.setCommand(ActuatorData.COMMAND_ON)
self.actuatorAdapterManager.sendActuatorCommand(ad)
"""
"""
if self.enableHandleSoilHumidityChangeOnDevice and data.getSensorType(
) == SensorData.SOIL_HUMIDITY_SENSOR_TYPE:
ad = ActuatorData(
actuatorType=ActuatorData.SPRINKLER_ACTUATOR_TYPE)
value = data.getValue()
if value >= self.triggerWaterDeviceHumiCeiling:
ad.setCommand(ActuatorData.COMMAND_OFF)
self.actuatorAdapterManager.sendActuatorCommand(ad)
elif value <= self.triggerWaterDeviceHumiFloor:
ad.setCommand(ActuatorData.COMMAND_ON)
self.actuatorAdapterManager.sendActuatorCommand(ad)
self.coapClient.sendGetRequest(
ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE, False, 5)
else:
self.coapClient.sendGetRequest(
ResourceNameEnum.CDA_CLOUD_ACTUATOR_CMD_RESOURCE, False, 5)
class BaseActuatorSimTask():
"""
Base class for ActuatorSimTask
"""
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 activateActuator(self, val: float) -> bool:
"""
Turn actuator on with given target value
As a sim actuator, there is no real action
:param val: Given target actuator value
:return: If succeed to activate Actuator, always True as a sim actuator
"""
logging.info("\n======\nSim %s actuator ON, with value = %d.\n======" %
(self.getSimpleName(), val))
self.latestActuatorData.setCommand(ActuatorData.COMMAND_ON)
self.latestActuatorData.setValue(val)
return True
pass
def deactivateActuator(self) -> bool:
"""
Turn actuator off with given target value
As a sim actuator, there is no real action
:return: If succeed to deactivate Actuator, always True as a sim actuator
"""
logging.info("\n======\nSim %s actuator OFF.\n======" %
self.getSimpleName())
self.latestActuatorData.setCommand(ActuatorData.COMMAND_OFF)
return True
pass
def getLatestActuatorResponse(self) -> ActuatorData:
"""
Get latest actuator data
:return: Latest ActuatorData
"""
return self.latestActuatorData
pass
def getSimpleName(self) -> str:
"""
Get name of the sim actuator
:return: Name string
"""
return self.simpleName
pass
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
class BaseActuatorSimTask():
"""
Shell representation of class for student implementation.
"""
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 activateActuator(self, val: float) -> bool:
"""
Activate the Actuator
@return bool
"""
logging.info("---> Emulating %s actuator ON:",
str(self.getActuatorTypeName()))
print('*******')
print('* O N *')
print('*******')
print(self.getActuatorTypeName() + ' VALUE -> ' + str(val))
self.latestAd.setCommand(ActuatorData.COMMAND_ON)
return True
def deactivateActuator(self) -> bool:
"""
Deactivate the Actuator
@return bool
"""
logging.info("---> Emulating %s actuator OFF: ",
str(self.getActuatorTypeName()))
print('*******')
print('* OFF *')
print('*******')
self.latestAd.setCommand(ActuatorData.COMMAND_OFF)
return True
def getActuatorType(self):
"""
Get the ActuatorType of the instance
@return str
"""
return self.actuatorType
def getLatestActuatorResponse(self) -> ActuatorData:
"""
Get the LatestActuatorResponse of the instance
@return ActuatorData
"""
return self.latestAd
def getSimpleName(self) -> str:
"""
Get the SimpleName of the instance
@return str
"""
return self.simpleName
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 getActuatorTypeName(self):
"""
Get the ActuatorTypeName of the instance
@return str
"""
if self.actuatorType == 1:
return 'HVAC'
if self.actuatorType == 2:
return 'HUMIDIFIER'
return 'Unknown'
