class TempActuatorEmulator():
def __init__(self):
self.thisActuatorData = ActuatorData()
self.thisActuatorData.setValue(20)
self.thisActuatorData.setCommand('IDEAL')
def processMessage(self, actuatorData):
if(self.thisActuatorData!=actuatorData):
if (actuatorData.getCommand() == 'INCREASE'):
print('Increasing temperature')
GPIO.set_rotation(actuatorData.getValue())
#GPIO stands for general purpose input output
#we set rotation and get values
elif (actuatorData.getCommand() == 'DECREASE'):
print('Decreasing temperature')
GPIO.set_rotation(actuatorData.getValue())
else:
print('maintaining the ideal temperature')
GPIO.set_rotation(actuatorData.getValue())
self.thisActuatorData = actuatorData
def __init__(self):
self.actuator = ActuatorData()
self.sensorAdaptor = MultiSensorAdaptor()
self.config = ConfigUtil()
self.config.loadConfig("../../../config/ConnectedDevicesConfig.props")
self.threshold = float(self.config.getValue("device", "nominalTemp"))
self.actuatorOP = MultiActuatorAdaptor.getInstance()
class TempActuatorAdaptor():
'''
* Class constructor function which makes actuation based on current temperature value extracted from SensorData object
* This constructor also uses functions of SimpleLedAActivator class such as setBLUE(), setRED
'''
def __init__(self):
logging.info("Actuation")
if (data_object.getcurvalue() < 20):
self.actuator_status = ActuatorData()
self.actuator_status.addData("Increase Temperature", data_object.getcurvalue(), "Temperature Sensor") # logging actuator data
high = SimpleLedActivator(3)
high.setRED()
#high.default_led()
return
if (data_object.getcurvalue() > 20):
self.actuator_status = ActuatorData()
self.actuator_status.addData("Decrease Temperature", data_object.getcurvalue(), "Temperature Sensor") # logging actuator data
low = SimpleLedActivator(3)
low.setBLUE()
#low.default_led()
return
else:
return
def getActuator_obj(self):
return self.actuator_status
def testPublishActuatorCommand(self):
#Call the connect method of MqttClientConnector with valid values
self.mqttClientConnector.connect("broker.hivemq.com", 1883)
#Let it connect
sleep(2)
#Create ActuatorData object and add a valid command
actuatorData = ActuatorData()
actuatorData.setCommand("Test Command")
#Publish to topic and assert true for successful publishing
self.assertEqual(
True,
self.mqttClientConnector.publishActuatorCommand(actuatorData, 2))
#Call the connect method of MqttClientConnector with invalid values
self.mqttClientConnector.connect("brosdf235iytksg", 1883)
#Let it connect
sleep(2)
#Publish to topic and assert False for failure to publish
self.assertEqual(
False,
self.mqttClientConnector.publishActuatorCommand(actuatorData, 2))
#Pass a null to method and assert False for failure to publish
self.assertEqual(
False, self.mqttClientConnector.publishActuatorCommand(None, 2))
def __init__(self):
'''
Constructor
'''
self.actuatorData = ActuatorData()
self.senseHatLedActivator = SenseHatLedActivator()
self.simpleLedActivator = SimpleLedActivator()
def setUp(self):
self.du = DataUtil()
self.sd = SensorData()
self.sd.addValue(15)
self.sd.setName("Test")
self.ad = ActuatorData()
self.ad.addValue(44)
self.ad.setName("Test")
self.ad.setCommand("Test")
pass
def toActuatorDataFromJson2(self,jsonData):
adDict = json.loads(jsonData)
ad = ActuatorData()
ad.Value = adDict['value']
ad.timeStamp = adDict['timestamp']
#print(" decode [post] --> " + str(ad))
return ad
def setUp(self): self.ac = ActuatorData() self.ac.addValue(15) self.sensor = SensorData() self.sensor.addValue(15) self.hsa = HumiditySensorAdaptorTask() self.hsa.objectLoader() self.pu = PersistenceUtil() pass
def __init__(self, enableEmulator, lowVal, highVal, curTemp, isPrevTempSet):
super(TempSensorAdaptor, self).__init__()
self.enableEmulator = enableEmulator
self.curTemp = curTemp
self.lowVal = lowVal
self.highVal = highVal
self.isPrevTempSet = isPrevTempSet
self.config = ConfigUtil.ConfigUtil('')
self.config.loadConfig()
self.actuatorData = ActuatorData()
self.tempActuatorEmulator = TempActuatorEmulator()
def updateActuator(self,ActuatorData):
#print("Actuator Name "+ str(ActuatorData.getValue() ))
if(ActuatorData.getName()=="HumidityI2C"):
self.Humidityi2cdata = str(ActuatorData.getValue())
elif(ActuatorData.getName()=="HumiditySenseHat"):
self.HumiditySenseHat = str(ActuatorData.getValue())
#print("Actuator Name "+ str(ActuatorData.getValue()))
message = "Temp -> I2C =" + self.Humidityi2cdata + " SenseHat ="+ self.HumiditySenseHat
logging.info(message)
#print("msg : " +message)
self.hat.updateLed(message)
return True
def jsonToactuator(self, jsonData):
adDict = json.loads(jsonData)
ad = ActuatorData()
ad.name = adDict['name']
ad.timeStamp = adDict['timeStamp']
ad.hasError = adDict['hasError']
ad.command = adDict['command']
ad.errCode = adDict['errCode']
ad.statusCode = adDict['statusCode']
ad.stateData = adDict['stateData']
ad.curValue = adDict['curValue']
return ad
def setUp(self):
self.sd = SensorData()
self.sd.addValue(11)
self.sdm = SensorDataManager()
self.actuator = ActuatorData()
self.actuator.setCommand("Raise Temp")
self.sdm.threshold = 20
self.tsa = TempSensorAdaptor()
self.taa = TempActuatorAdaptor()
self.tat = TempSensorAdaptorTask()
self.shla = SenseHatLedActivator()
pass
def testwriteActuatorDataToFile(self):
#create sensorData object
actuatorData = ActuatorData()
#add a value
actuatorData.setName("Testinng")
#write to file and assert True
self.assertEqual(True,
self.dataUtil.writeActuatorDataToFile(actuatorData))
pass
def setUp(self):
self.config = ConfigUtil()
self.config.loadConfig('../../../config/ConnectedDevicesConfig.props')
self.tempsensor = TempSensorAdaptorTask()
self.sensordata = SensorData()
self.actuatordata = ActuatorData()
self.sensordata.addValue(10)
self.sensordata.addValue(15)
self.sensordata.addValue(20)
self.sensordata.addValue(25)
self.sensordata.setName('Temperature')
self.actuatordata.setCommand('Increasing')
self.actuatordata.setName('SenseHat')
self.sdmanager = SensorDataManager()
def setUp(self):
self.sd = SensorData()
self.sd.addValue(11)
self.sd.setName("Test")
self.sdm = SensorDataManager()
self.sdm.actuator.addValue(11)
self.actuator = ActuatorData()
self.actuator.addValue(2)
self.actuator.setName("Test")
self.tsa = MultiSensorAdaptor()
self.taa = MultiActuatorAdaptor()
self.tat = HumiditySensorAdaptorTask()
self.tat.sensorData = SensorData()
self.shla = SenseHatLedActivator()
def toActuatorDataFromJson(self, string):
act = ActuatorData()
data = json.loads(string)
logging.info(data)
act.name = data['name']
act.value = data['current']
act.command = data['command']
act.min_value = data['min_value']
act.max_value = data['max_value']
act.total_value = data['total_value']
act.avgTemp = data['avgTemp']
act.timestamp = data['timestamp']
logging.info("New actuator generated from JSon \n")
return act
def jsonToactuator(self,jsonData):
actdataDict = json.loads(jsonData)
print(" decode [pre] --> " + str(actdataDict))
actdata = ActuatorData()
actdata.name = actdataDict['name']
actdata.time = actdataDict['timeStamp']
actdata.hasError = actdataDict['hasError']
actdata.command = actdataDict['command']
actdata.errCode = actdataDict['errCode']
actdata.statusCode = actdataDict['statusCode']
actdata.stateData = actdataDict['stateData']
actdata.curValue = actdataDict['curValue']
print(" decode [post] --> " + str(actdata))
return actdata
def __init__(self):
Thread.__init__(self)
self.highVal = 30
self.lowVal = 0
self.updateTime = 2
self.senseHat = SenseHat()
self.sensorData = SensorData()
self.actuatorData = ActuatorData()
self.connector = Connector()
self.alertDiff = 10
self.config = ConfigUtil('D:/git/repository/iot-device/apps/data/ConnectedDevicesConfig.props')
self.config.loadConfig()
print('Configuration data...\n' + str(self.config))
def toActuatorDataFromJson(self, jsonStr) -> ActuatorData:
#instantiate ActuatorData
actuatorData = ActuatorData()
#use json load to convert it to a dictionary
jsonLoad = json.loads(jsonStr)
#parse and add it to the actuatorData object one by one
actuatorData.name = jsonLoad['name']
actuatorData.command = jsonLoad['command']
actuatorData.value = jsonLoad['value']
#return the actuatorData reference
return actuatorData
class SensorDataManager():
actData = ActuatorData()
nomTemp = 0
confP = ConfigUtil()
'''
this function takes sensorData as an argument and updates the ActuatorData object with the values and
returns the ActuatorData object.
'''
def handleSensorData(self, sensorData):
self.actData.setName(sensorData.getName())
self.actData.setValue(sensorData.getCurrentValue())
self.nomTemp = float(self.confP.getValue("device", "nominalTemp"))
if ((self.nomTemp - 5.0) < sensorData.getCurrentValue() <
(self.nomTemp + 5.0)):
self.actData.setCommand("NEUTRAL")
elif (sensorData.getCurrentValue() < (self.nomTemp + 10.0)):
self.actData.setCommand("TEMP DEC")
elif (sensorData.getCurrentValue() > (self.nomTemp + 10.0)):
self.actData.setCommand("TEMP INC")
# print(self.actData.getCommand())
return self.actData
#return None
def humidity(self, sensorData):
self.actData.setName(sensorData.getName())
self.actData.setValue(sensorData.getCurrentValue())
self.actData.setCommand(str(round(sensorData.getCurrentValue(), 2)))
return self.actData
def pressure(self, sensorData):
self.actData.setName(sensorData.getName())
self.actData.setValue(sensorData.getCurrentValue())
self.actData.setCommand(str(round(sensorData.getCurrentValue(), 2)))
return self.actData
class Module07Test(unittest.TestCase):
sensorD = SensorData()
#hasConf=confU.hasConfig()
curVal = sensorD.getCurrentValue()
avgVal = sensorD.getAverageValue()
actD = ActuatorData()
du = DataUtil()
adl = ActuatorDataListener()
j = ""
def testSensorData(self):
self.assertTrue(isinstance(self.curVal, float), "Float Value")
self.assertTrue(self.avgVal >= 0.0 and self.avgVal <= 30.0,
"Average Temperature within the range")
'''
It checks for the datatype of the getCommand function to be String.
'''
def testDataUtil(self):
self.assertTrue(
isinstance(self.du.toJsonFromSensorData(self.sensorD), str),
"String")
def testActuatorDataFromJson(self):
self.assertTrue(
isinstance(self.du.toActuatorDataFromJson(self.j), str), "String")
def testActuatorDataListener(self):
self.assertTrue(
isinstance(self.adl.onActuatorMessage(str(self.curVal)), float),
"Type String")
def __init__(self):
self.LedActivate = SenseHatLedActivator()
self.acdata = ActuatorData()
self.sendMessage = SmtpClientConnector()
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(message)s',
level=logging.DEBUG) # logging basic data
self.cpuUtil = SystemCpuUtilTask()
def toJsonFromActuatorData(self,
actuatorData: ActuatorData.ActuatorData) -> str:
'''
Convert from ActuatorData instance to JSON
'''
#Converting the actuatorData to a dictionary
jsonData = {
"command": actuatorData.getCommand(),
"name": actuatorData.getName(),
"value": actuatorData.getValue()
}
#dumping the json data and returning it
jsonStr = json.dumps(jsonData)
#Logging and writing to file
self.writeActuatorDataToFile("Created actuatorData JSON" + jsonStr)
return jsonStr
class Module03Test(unittest.TestCase): confU=ConfigUtil(); sensorD=SensorData() hasConf=confU.hasConfig() curVal=sensorD.getCurrentValue() avgVal=sensorD.getAverageValue() actD=ActuatorData() senDM=SensorDataManager() """ it checks for the datatype of hasConf to be boolean, If true test case is passed. """ def testConfigUtil(self): self.assertTrue(isinstance(self.hasConf,bool),"Boolean Value") """ it checks for the datatype of curVal to be float, If true test case is passed. Second checks for the avgVal to be within the specified range.If true test case is passed. """ def testSensorData(self): self.assertTrue(isinstance(self.curVal,float),"Float Value") self.assertTrue(self.avgVal>=0.0 and self.avgVal<=30.0,"Average Temperature within the range") ''' It checks for the datatype of the getCommand function to be String. ''' def testActuatorData(self): self.assertTrue(isinstance(self.actD.getCommand(),str), "String") ''' It checks for the returntype of the function handleSensorData of class SensorDataManager to be of type actuator data. ''' def testSensorDataManager(self): self.assertTrue(isinstance(self.senDM.handleSensorData(self.sensorD),ActuatorData), "Type Actuator Data")
class SensorDataManager(object):
'''
classdocs
'''
actuatorData = ActuatorData()
def __init__(self):
'''
Constructor
'''
self.config = ConfigUtil()
self.connector = SmtpClientConnector()
self.tempActuator = TempActuatorAdaptor()
'''
If current temperature exceeds or falls below the 'nominalTemp', the new SensorData instance will trigger an actuation
It will return the new ActualatorData instance with the appropriate data value and command embedded;
Otherwise, it returns None
Also,if an actuation is triggered, the SmtpClientConnector instance will be created to send the e-mail
message to the appropriate destination
'''
def handleSensorData(self,sensorData):
self.nominalTemp = float(self.config.getValue(ConfigConst.DEVICE, ConfigConst.NOMINAL_TEMP))
self.time = sensorData.timeStamp
self.average = sensorData.avgValue
self.samples = sensorData.getCount()
self.min = sensorData.minValue
self.max = sensorData.maxValue
self.message = 'Temperature\n' + '\tTime: ' +str(self.time) + '\n\tCurrent: ' + str(sensorData.curValue) + '\n\tAverage: ' +str(self.average) + '\n\tSamples: ' + str(self.samples) + '\n\tMin: ' + str(self.min) + '\n\tMax: ' + str(self.max)
if(sensorData.curValue>self.nominalTemp):
logging.info('\nCurrent temperature exceeds nonminalTemp by > ' +str(self.nominalTemp) + '. Triggering alert...')
#print('\nCurrent temperature exceeds nonminalTemp by > ' +str(self.nominalTemp) + '. Triggering alert...')
self.connector.publishMessage('Excessive Temperature', self.message)
self.actuatorData.setCommand('Increasing')
self.actuatorData.getValue(sensorData.curValue)
self.tempActuator.updateActuator(self.actuatorData)
print(self.message)
return(self.actuatorData)
elif(sensorData.curValue<self.nominalTemp):
logging.info('\nCurrent temperature falls below nonminalTemp by < ' +str(self.nominalTemp) + '. Triggering alert...')
self.connector.publishMessage('Decreasing Temperature', self.message)
self.actuatorData.setCommand('Decreasing')
self.actuatorData.getValue(sensorData.curValue)
self.tempActuator.updateActuator(self.actuatorData)
print(self.message)
return(self.actuatorData)
else:
return(None)
def writeActuatorToDataDbms(self,ActuatorData):
dbData = DataUtil.toJsonFromActuatorData(self, ActuatorData)
r = redis.StrictRedis(host=self.host, port=self.port, password=self.auth, decode_responses=True)
r.set(ActuatorData.getTimeStamp()+"- Actuator",dbData)
r.publish("Actuator", dbData)
#logging.info("Sending data to DB")
r.close()
return True
class Module05Test(unittest.TestCase):
"""
Use this to setup your tests. This is where you may want to load configuration
information (if needed), initialize class-scoped variables, create class-scoped
instances of complex objects, initialize any requisite connections, etc.
"""
def setUp(self):
self.ac = ActuatorData()
self.ac.addValue(15)
self.sensor = SensorData()
self.sensor.addValue(15)
self.hsa = HumiditySensorAdaptorTask()
self.hsa.objectLoader()
self.pu = PersistenceUtil()
pass
"""
Use this to tear down any allocated resources after your tests are complete. This
is where you may want to release connections, zero out any long-term data, etc.
"""
def tearDown(self):
pass
"""
Place your comments describing the test here.
"""
def testSenseHatActivator(self):
hat = SenseHatLedActivator()
self.assertTrue(hat.updateLed("Test"),"Led Update Failed")
pass
def testSensorData(self):
a = self.hsa.readSensorValue()
self.assertGreaterEqual(a.current, 0, "Issue with sensor")
pass
def testWriteActuator(self):
self.assertTrue(self.pu.writeActuatorToDataDbms(self.ac))
pass
def testWriteSensor(self):
self.assertTrue(self.pu.writeSensorToDataDbms(self.sensor))
pass
class SensorDataManager:
#Default Constructor
def __init__(self):
self.actuator = ActuatorData()
self.sensorAdaptor = MultiSensorAdaptor()
self.config = ConfigUtil()
self.config.loadConfig("../../../config/ConnectedDevicesConfig.props")
self.threshold = float(self.config.getValue("device", "nominalTemp"))
self.actuatorOP = MultiActuatorAdaptor.getInstance()
def run(self):
self.sensorAdaptor.getSensorData()
#Method for evaluating the sensor values and create decision for actation
def hadleSensorData(self, SensorData):
self.actuator.max_value = SensorData.max_value
self.actuator.min_value = SensorData.min_value
self.actuator.readings_number = SensorData.readings_number
self.actuator.value = SensorData.getCurrentValue()
self.actuator.avgTemp = (SensorData.total_value /
SensorData.readings_number)
self.actuator.total_value = SensorData.total_value
self.actuator.setName(SensorData.getName())
self.actuatorOP.updateActuator(self.actuator)
#print("Value check - " + str(self.actuator.value))
self.sendNotification()
return True
#Triggering mail based on the command value. The mail contains the relevant information.
def sendNotification(self):
try:
logging.info(self.actuator.getName() + "Temperature: \nTime: " +
str(self.actuator.timestamp) + " Value :" +
str(self.actuator.getValue()))
mail = SmtpClientConnector()
#Creating mail body text
data = "Reading from:" + self.actuator.getName(
) + "\nTime: " + str(
self.actuator.timestamp) + "\ncurrent : " + str(
self.actuator.getValue()) + "\nAverage :" + str(
self.actuator.getAverageValue()) + "\nSamples :" + str(
self.actuator.readings_number) + "\nMin: " + str(
self.actuator.min_value) + "\nMax :" + str(
self.actuator.max_value)
mail.publishMessage(
"Humidity Alert Python -" + self.actuator.getName(), data)
logging.info('\nMail sent')
return True
except Exception as e:
logging.info(e)
print(e)
#If the mailing fails, the method returns false
return False
def jsonToActuatorData(self, jsonData):
adDict = json.loads(jsonData)
#print(" decode [pre] --> " + str(adDict))
ad = ActuatorData()
ad.name = adDict['name']
ad.timeStamp = adDict['timeStamp']
ad.hasError = adDict['hasError']
ad.command = adDict['command']
ad.errCode = adDict['errCode']
ad.statusCode = adDict['statusCode']
ad.stateData = adDict['stateData']
ad.curValue = adDict['curValue']
#print(" decode [post] --> " + str(ad))
return ad
def __init__(self):
super(TempSensorAdaptor, self).__init__()
self.config = ConfigUtil.ConfigUtil('')
self.config.loadConfig()
self.actuatorData = ActuatorData()
self.tempActuatorEmulator = TempActuatorEmulator()
self.senseHat = SenseHat()
self.coapConnector = CoapSimpleClientConnector.CoapSimpleClientConnector(
)
