def handleSensorData(self, sensorData):
#get the current sensor value
sensorVal = sensorData.getCurrentValue()
#check if temperature greater than the nominal temp
if sensorVal > self.nominalTemp:
#send email notification
self.sendNotification(sensorData.loggingData, "High Temperature")
#instantiate ActuatorData
actuatorData = ActuatorData.ActuatorData()
#the thermostat should decrease the temp as the temperature is too hot!
actuatorData.setCommand("DECREASE TEMP")
#set the name of the actuator
actuatorData.setName("Temperature")
#set the value to pixel matrix
actuatorData.setValue(self.arrowBlueDec)
#send the reference to the Actuator Adaptor
self.tempActuatorAdaptor.updateActuator(actuatorData)
#return the actuator data reference
return actuatorData
#check if temperature less than the nominal temp
elif sensorVal < self.nominalTemp:
#send email notification
self.sendNotification(sensorData.loggingData, "Low Temperature")
#instantiate ActuatorData
actuatorData = ActuatorData.ActuatorData()
#the thermostat should increase the temp as the temperature is too cold!
actuatorData.setCommand("INCREASE TEMP")
#set the name of the actuator
actuatorData.setName("Temperature")
#set the value to pixel matrix
actuatorData.setValue(self.arrowRedInc)
#send the reference to the Actuator Adaptor
self.tempActuatorAdaptor.updateActuator(actuatorData)
#return the actuator data reference
return actuatorData
#if temperature is equal to nominal temperature, do nothing and simply return a none
else:
#no actuation
return None
def __init__(self,alertdiff):
'''
constructor
@param sensorData: sensorData class instance
@param connector: instance of smtpClientConnector class
@param alertDiff: the threshold value for sending alert message
@param enableEmulator:boolean state of the emulator, initialized to False
@param timeInterval:time in seconds between each data generation/collection
@param lowValue:lowest value of the temperature achieved/expected
@param highValue: highest value of the temperature expected/achieved
@param curTemp: current value of the temperature
'''
threading.Thread.__init__(self)
self.enableEmulator = False
logging.basicConfig(level=logging.INFO , format=' %(asctime)s %(levelname)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S' )
self.timeInterval = int(self.config.getProperty(self.config.configConst.CONSTRAINED_DEVICE, self.config.configConst.POLL_CYCLES_KEY))
self.alertDiff = alertdiff
self.nominalTemp = int(self.config.getProperty(self.config.configConst.CONSTRAINED_DEVICE, self.config.configConst.NOMINAL_TEMP))
self.lowValue = 0
self.highValue = 30
self.curTemp = 0
self.prevTemp = 0.0
self.prevTempFlag = False
self.sensorData = SensorData.SensorData()
self.connector = SMTPClientConnector.SMTPClientConnector()
self.actuator = ActuatorData.ActuatorData()
self.actuatorAdaptor = TempActuatorAdaptor.TempActuatorAdaptor()
self.sensorDataMgr = SensorDataManager.SensorDataManager
class SensorDataManager(object):
actuator = ActuatorData.ActuatorData()
connector = SMTPClientConnector.SMTPClientConnector
def __init__(self):
self.config = ConfigUtil.ConfigUtil()
self.config.loadConfig()
self.actuatorAdaptor = TempActuatorAdaptor.TempActuatorAdaptor()
def handleSensorData(self, curTemp):
'''
this method handles all the sensor data and updates the actuator settings
'''
self.nominalTemp = float(self.config.getProperty(self.config.configConst.CONSTRAINED_DEVICE, self.config.configConst.NOMINAL_TEMP))
#checks if my current temperature is greater than nominal temperature
if(curTemp > self.nominalTemp):
# set the Actuator data according to current temperature
self.actuator.setCommand(ActuatorData.CMD_ON)
self.actuator.setStateData('Decrease')
self.actuator.setValue(curTemp - self.nominalTemp)
self.actuatorAdaptor.updateActuator(self.actuator)
# self.connector.publishMessage('Excessive Temperature Alert', self.actuator)
#checks if my current temperature is lesser than nominal temperature
elif(curTemp < self.nominalTemp):
# set the Actuator data according to current temperature
self.actuator.setCommand(ActuatorData.CMD_OFF)
self.actuator.setStateData('Increase')
self.actuator.setValue(curTemp - self.nominalTemp)
self.actuatorAdaptor.updateActuator(self.actuator)
class TempSensorAdaptor(Thread):
#creating the sensor data object and initial values to use inside Adaptor
sensorData = SensorData.SensorData()
actuator = ActuatorData.ActuatorData()
connector = SmtpClientConnector.SmtpClientConnector()
actuatorEmulator = TempActuatorEmulator.TempActuatorEmulator()
isPrevTempSet = False
lowVal = 0
highVal = 30
nominalTemp = 20
alertDiff = 5
#initiating the thread for the Adaptor
def __init__(self):
Thread.__init__(self)
def run(self):
while True:
if self.enableAdaptor:
#generate temperature information
self.curTemp = uniform(float(self.lowVal), float(self.highVal))
self.sensorData.addValue(self.curTemp)
print('\n--------------------')
print('New sensor readings:')
print(' ' + str(self.sensorData))
if self.isPrevTempSet == False:
self.prevTemp = self.curTemp
self.isPrevTempSet = True
else:
#checking for alerting difference and sending the message through SMTP
if (abs(self.curTemp - self.sensorData.getAvgValue()) >=
self.alertDiff):
print('\n Current temp exceeds average by > ' +
str(self.alertDiff) + '. Triggering alert...')
self.connector.publishMessage(
'Exceptional sensor data [test]', self.sensorData)
'''
checking to see if the temperature exceeds nominal temperature to set status
for actuator and send the message accordingly
'''
if (self.curTemp > self.nominalTemp):
self.actuator.setCommand(ActuatorData.COMMAND_ON)
self.actuator.setStatusCode(ActuatorData.STATUS_ACTIVE)
self.actuator.setErrorCode(ActuatorData.ERROR_OK)
self.actuator.setStateData('Decrease')
self.actuator.setValue(self.curTemp - self.nominalTemp)
self.actuatorEmulator.processMessage(self.actuator)
elif (self.curTemp < self.nominalTemp):
self.actuator.setCommand(ActuatorData.COMMAND_OFF)
self.actuator.setStatusCode(ActuatorData.STATUS_ACTIVE)
self.actuator.setErrorCode(ActuatorData.ERROR_OK)
self.actuator.setStatusCode('Increase')
self.actuator.setValue(self.curTemp - self.nominalTemp)
self.actuatorEmulator.processMessage(self.actuator)
sleep(5)
class TempActuatorEmulator(object):
actuatordata = ActuatorData.ActuatorData()
raisetemp = None
lowertemp = None
def __init__(self):
self.raisetemp = "Raise"
self.lowertemp = "Lower"
def processMessage(self, actuatordata):
if (actuatordata != self.actuatordata):
self.actuatordata = actuatordata
if (self.actuatordata.getCommand() == self.raisetemp):
#send notification to GPIO
ledactivator = SenseHatLedActivator.SenseHatLedActivator()
ledactivator.setEnableLedFlag(True)
ledactivator.setDisplayMessage("Raise temperature.")
print('Please raise temperature.')
ledactivator.run()
if (self.actuatordata.getCommand() == self.lowertemp):
#send notification to GPIO
ledactivator = SenseHatLedActivator.SenseHatLedActivator()
ledactivator.setEnableLedFlag(True)
ledactivator.setDisplayMessage("Lower temperature.")
print('Please lower temperature.')
ledactivator.run()
def run(self):
while True:
'''
Enabling the Emulator and generates the current value provided within the range
and printing the sensor data.
'''
if self.enableAdaptor:
self.sensor.curVal = uniform(float(self.sensor.getMinValue()),
float(self.sensor.getMaxValue()))
self.sensor.addValue(self.sensor.curVal)
nominal_temp = self.temp.getProperty(
ConfigConst.ConfigConst.CONSTRAINED_DEVICE,
ConfigConst.ConfigConst.NOMINAL_TEMP)
self.sensor.diffVal = self.sensor.curVal - self.sensor.avgVal
print(self.sensor)
'''
Alert Notification will be sent if the current value exceeds or very lesser than the nomial temperature
'''
if self.sensor.curVal >= (self.sensor.getAvgValue() + 3):
data = (self.sensor)
self.sensor.timestamp = datetime.now()
SensorData.SensorData.surpassed_values.append(self.sensor)
print(SensorData.SensorData.surpassed_values)
print("Warning: Temperature has been surpassed")
sensor_notification = SmtpClientConnector.SmtpClientConnector(
)
sensor_notification.publishMessage(
"Temperature Alert Notification: ", data)
'''
Determining the difference between the nominal and the current temperature
using actuator data
'''
if self.sensor.curVal != nominal_temp:
self.actuator_data = ActuatorData.ActuatorData()
self.diff = (self.sensor.curVal - float(nominal_temp))
if self.diff > 0:
self.actuator_data.setValue(self.sensor.curVal -
float(nominal_temp))
self.actuator_data.setCommand(ActuatorData.COMMAND_SET)
else:
self.actuator_data.setValue(
float(nominal_temp) - self.sensor.curVal)
self.actuator_data.setCommand(
ActuatorData.COMMAND_RESET)
print(
"The difference between the nominal temp and the current temp is: "
+ str(self.actuator_data.getValue()) + chr(176) + 'C')
self.tempEmulator.publishMessage(self.actuator_data)
'''
providing a delay for every sensor readings
'''
delay = int(
self.temp.getProperty(
ConfigConst.ConfigConst.CONSTRAINED_DEVICE,
ConfigConst.ConfigConst.POLL_CYCLES_KEY))
sleep(delay)
def __init__(self):
'''
Constructor
'''
self.actuatorData = ActuatorData.ActuatorData()
self.senseHat = SenseHatLedActivator.SenseHatLedActivator()
#start my sensehat thread
self.senseHat.start()
def __init__(self, name):
Thread.__init__(self)
self.enableAdaptor = True;
self.sensorData = SensorData.SensorData(name, 0, 30);
self.actuator = ActuatorData.ActuatorData()
self.connector = SmtpClientConnector.SmtpClientConnector()
self.tempConf = ConfigUtil.ConfigUtil('../../../config/ConnectedDevicesConfig.props');
self.actuatorEmulator = TempActuatorEmulator.TempActuatorEmulator();
def __init__(self):
Thread.__init__(self)
self.enableEmulator = True # Turn the emulator ON
self.sensor = SensorData.SensorData() # Obtain sensor data
self.actuator = ActuatorData.ActuatorData() # Obtain actuator data
self.alertDiff = 5 # Set time for obtaining values from sensor
self.rateInSec = 5 # Import configurations
self.config = ConfigUtil.ConfigUtil('../../../config/ConnectedDevicesConfig.props')
def setUp(self):
rUtil = redis.Redis()
#Creating a listener instance
self.listener = ActuatorDataListener.ActuatorDataListener(rUtil)
#ActuatorData instance filled with data
self.actuatorData = ActuatorData.ActuatorData()
self.actuatorData.setName("TestActuator")
self.actuatorData.setCommand("Stable")
self.actuatorData.setValue("TICK")
def setUp(self):
'''
Setting up resources
'''
self.actuatorTest = ActuatorData.ActuatorData()
self.actuatorTest.command = "TestCommand"
self.actuatorTest.value = 56251
self.actuatorTest.name = "TestName"
pass
def __init__(self):
self.tempActuatorData = ActuatorData.ActuatorData()
self.simledActivator = SimpleLedActivator.SimpleLedActivator()
self.simledActivator.daemon = True
self.simledActivator.start()
self.senledActivator = SenseHatLedActivator.SenseHatLedActivator()
self.senledActivator.daemon = True
self.senledActivator.start()
def __init__(self, blinkingTime):
self.tempActuatorData = ActuatorData.ActuatorData("Actuator")
self.ledActivator = SimpleLedActivator.SimpleLedActivator(blinkingTime)
self.ledActivator.daemon = True
self.ledActivator.start()
self.LedActivator = SenseHatLedActivator.SenseHatLedActivator()
self.LedActivator.daemon = True
self.LedActivator.start()
def testUpdateActuator(self):
#Creating a temporary actuatorData instance
actuator = ActuatorData.ActuatorData()
actuator.setCommand("Print")
actuator.setValue(["TEST", (90, 200, 90)])
#Checking for a compatible command
self.assertEqual(
True, self.multiActuatorAdapterTest.updateActuator(actuator))
#Checking for an incompatible command
actuator.setCommand("This shouldn't work")
self.assertEqual(
False, self.multiActuatorAdapterTest.updateActuator(actuator))
self.multiActuatorAdapterTest.clear()
def testUpdateActuator(self):
#Creating a temporary actuatorData instance
actuator = ActuatorData.ActuatorData()
actuator.setCommand("Increase")
actuator.setValue(self.sensorDataManagerTest.STABLE)
#Checking for a compatible command
self.assertEqual(True,
self.tempActuatorAdapterTest.updateActuator(actuator))
#Checking for an incompatible command
actuator.setCommand("This shouldn't work")
self.assertEqual(False,
self.tempActuatorAdapterTest.updateActuator(actuator))
self.tempActuatorAdapterTest.clear()
pass
def toActuatorDataFromJson(self, jsonStr) -> ActuatorData.ActuatorData:
'''
Convert from JSON to ActuatorData instance
'''
#Logging and writing to file
self.writeActuatorDataToFile("Received ActuatorData JSON" +
str(jsonStr))
#Loading the jsonString
jsonData = json.loads(jsonStr)
#Creating a sensorData instance
actuatorData = ActuatorData.ActuatorData()
#Adding values to the sensorData Instance
actuatorData.command = jsonData['command']
actuatorData.name = jsonData['name']
actuatorData.value = jsonData['value']
return actuatorData
def __init__(self):
'''
Constructor
'''
#Creating a configUtil instance and loading the configUtil file
self.config = ConfigUtil.ConfigUtil()
self.config.loadConfigData()
#Creating an actuatorData instance to store Actuator state in, and setting it's name.
self.actuator = ActuatorData.ActuatorData()
self.actuator.setName("Temperature Actuator Data")
#Creating an actuatorAdapter to actuate the actual actuator.
self.actuatorAdapter = MultiActuatorAdapter.MultiActuatorAdapter()
#SMTP-connector to send Emails
self.smtpConnector = SmtpClientConnector.MyClass()
def setUp(self):
#JSON strings to test on
self.sensorJSON = "{\"currentValue\": 10.0, \"totalCount\": 1, \"avgValue\": 10.0, \"maxValue\": 10.0, \"minValue\": 10.0, \"timestamp\": \"2020-02-23 16:29:41.32\", \"name\": \"Temperature\"}"
self.actuatorJSON = "{\"command\": \"Decrease\", \"name\": \"Temperature Sensor Data\", \"value\": \"DOWNARROW\"}"
#ActuatorData instance filled with data
self.actuatorData = ActuatorData.ActuatorData()
self.actuatorData.setName("TestActuator")
self.actuatorData.setCommand("TestCommand")
self.actuatorData.setValue(0.0)
#SensorData instance filled with data
self.sensorData = SensorData.SensorData()
self.sensorData.setName("TestSensor")
self.sensorData.addValue(10)
#Datautil Instance
self.dataUtil = DataUtil.DataUtil()
pass
def __init__(self):
'''
this is a default constructor
'''
#Initializing my variables and the instances
self.dataUtil = DataUtil.DataUtil()
self.sensorData = SensorData.SensorData()
self.actuatorData = ActuatorData.ActuatorData()
self.mqttBrokerAddr = 'mqtt.eclipse.org'
self.port = 1883
self.keepAlive = 65
self.connectedFlag = False
self.topic = "Raspi/Temperature"
self.mqttClient = mqtt.Client("DeviceClient")
self.mqttClient.on_connect = self.on_connect
self.mqttClient.on_disconnect = self.on_disconnect
self.mqttClient.connect(self.mqttBrokerAddr, self.port, self.keepAlive)
def __init__(self):
'''
Constructor
'''
#Creating a configUtil instance and loading the configUtil file
self.config = ConfigUtil.ConfigUtil()
self.config.loadConfigData()
#Reading the required nominal temperature from the config file and logging it
self.nominal = self.config.getIntegerValue("device", "nominalTemp")
logging.info(
str("Read nominal temperature from config " + str(self.nominal)))
#Creating an actuatorData instance to store Actuator state in, and setting it's name.
self.actuator = ActuatorData.ActuatorData()
self.actuator.setName("Temperature Actuator Data")
#Creating an actuatorAdapter to actuate the actual actuator.
self.actuatorAdapter = TempActuatorAdapter.TempActuatorAdapter()
#SMTP-connector to send Emails
self.smtpConnector = SmtpClientConnector.MyClass()
def setUp(self):
#Instance for persistenceUtil
self.pUtil = PersistenceUtil.PersistenceUtil()
self.pUtil.enableThreads = False
#ActuatorData instance filled with data
self.actuatorData = ActuatorData.ActuatorData()
self.actuatorData.setName("TestActuator")
self.actuatorData.setCommand("TestCommand")
self.actuatorData.setValue("TestValue")
#SensorData instance filled with data
self.sensorData = SensorData.SensorData()
self.sensorData.setName("TestSensor")
self.sensorData.addValue(10)
#Creating a variable to avoid running this pipeline in cloud
if path.exists("config/ConnectedDevicesConfig.props"):
self.pipelineAvoid = False
else:
self.pipelineAvoid = True
class TempSensorAdaptor(threading.Thread):
sensorData = SensorData.SensorData()
actuatorData = ActuatorData.ActuatorData()
connector = SmtpClientConnector.SmtpClientConnector()
actu = TempActuatorEmulator.TempActuatorEmulator()
enableEmulator = False
isPrevTempSet = False
rateInSec = DEFAULT_RATE_IN_SEC
sensorData.setName('Temperature')
lowVal = 0
highVal = 30
alertDiff = 5
def __init__(self, rateInSec=DEFAULT_RATE_IN_SEC):
super(TempSensorAdaptor, self).__init__()
if rateInSec > 0:
self.rateInSec = rateInSec
def run(self):
while True:
if self.enableEmulator:
#self.curTemp = ssHat.get_temperature()
self.curTemp = uniform(float(self.lowVal), float(self.highVal))
CoAPThon.handlePostTest("temp", str(self.curTemp))
self.sensorData.addValue(self.curTemp)
self.actuatorData.setValue(self.curTemp)
self.actu.processMessage(self.actuatorData)
print('\n--------------------')
print('New sensor readings:')
print(' ' + str(self.sensorData))
if self.isPrevTempSet == False:
self.prevTemp = self.curTemp
self.isPrevTempSet = True
else:
if (abs(self.curTemp - self.sensorData.getAvgValue()) >=
self.alertDiff):
print('\n Current temp exceeds average by > ' +
str(self.alertDiff) + '. Triggeringalert...')
self.connector.publishMessage(
'Exceptional sensor data [test]', self.sensorData)
sleep(self.rateInSec)
def run(
self
): #overriding run method is used to perform the desired functionality
while True:
if self.enableEmulator:
#sense = SenseHat();
#self.sensor.curVal = sense.get_temperature_from_pressure();
self.sensor.curVal = uniform(float(self.sensor.getMinValue()),
float(self.sensor.getMaxValue()))
self.sensor.addValue(self.sensor.curVal)
nominal_temp = self.temp.getProperty(
ConfigConst.ConfigConst.CONSTRAINED_DEVICE,
ConfigConst.ConfigConst.NOMINAL_TEMP)
self.sensor.diffVal = self.sensor.curVal - self.sensor.avgVal
print(self.sensor)
if self.sensor.curVal >= (self.sensor.getAvgValue() + 2):
data = (self.sensor)
self.sensor.timestamp = datetime.now()
SensorData.SensorData.breach_values.append(self.sensor)
print(SensorData.SensorData.breach_values)
print(
"Warning!! value of temperature exceeded the average temperature by %.2f degrees"
% (self.sensor.diffVal))
sen_not = SmtpClientConnector.SmtpClientConnector()
sen_not.publishMessage("Temperature Notification", data)
if self.sensor.curVal != nominal_temp:
self.actuator_data = ActuatorData.ActuatorData()
self.diff = (self.sensor.curVal - float(nominal_temp))
if self.diff > 0:
self.actuator_data.setValue(self.sensor.curVal -
float(nominal_temp))
self.actuator_data.setCommand(ActuatorData.COMMAND_SET)
else:
self.actuator_data.setValue(
float(nominal_temp) - self.sensor.curVal)
self.actuator_data.setCommand(
ActuatorData.COMMAND_RESET)
print("Actual Vale : ", str(self.actuator_data.getValue()))
self.temp_emul.publishMessage(self.actuator_data)
delay = int(
self.temp.getProperty(
ConfigConst.ConfigConst.CONSTRAINED_DEVICE,
ConfigConst.ConfigConst.POLL_CYCLES_KEY))
sleep(delay)
class TempActuatorEmulator(object):
#creating the actuator data object and initial values to use inside Emulator
actuatorData = ActuatorData.ActuatorData()
#Initiating the Emulator to start the actuation and process the message
def processMessage(self, actuatorData):
if (self.actuatorData != actuatorData):
if (actuatorData.getValue() > 0):
print(' \n Reduce the Temperature by: ' +
str(actuatorData.getValue()))
self.actuatorData.updateData(actuatorData)
elif (actuatorData.getValue() < 0):
print(' \n Increase the Temperature by: ' +
str(abs(actuatorData.getValue())))
self.actuatorData.updateData(actuatorData)
def setUp(self):
#CoAPClient
self.coAPTest = CoAPClientConnector()
#SenseHatUpdater
self.senseHatUpdater = SenseHatUpdater()
#Mqtt
self.mqttTest = MqttClientConnector()
#DeviceDataManager
self.manager = DeviceDataManager()
#SerialCommunicator
self.ser = SerialCommunicator(baud=152000, looplimit=1)
#HeartRateTask
self.hr = HeartRateTask(self.coAPTest, looplimit=1)
#HeartRateTask
self.spo = SpO2Task(self.coAPTest, looplimit=1)
#CPUUtil Task
self.cpu = Cpu(self.coAPTest, looplimit=1)
#MemUtil Task
self.mem = Mem(self.coAPTest, looplimit=1)
#Getting an asyncio event loop
self.loop = asyncio.get_event_loop()
#SensorData object
self.sensorData = SensorData.SensorData()
self.sensorData.addValue(10)
self.sensorData.setName("TESTNAME")
#ActuatorData object
self.actuatorData = ActuatorData.ActuatorData()
self.actuatorData.setCommand("TESTCOMMAND")
self.actuatorData.setValue("TESTVALUE")
self.actuatorData.setName("TESTNAME")
def setUp(self):
#Setting up resources from common
#Creating PersistenceUtil object
self.pUtil = PersistenceUtil.PersistenceUtil()
#Instances from Module06
self.mqttTest = MqttClientConnector.MqttClientConnector()
self.multiActuatorAdapterTest = MultiActuatorAdapter.MultiActuatorAdapter(
)
self.tempSensorAdapterTaskTest = TempSensorAdapterTask.TempSensorAdapterTask(
1, 1, self.pUtil, self.mqttTest)
self.multiSensorAdapterTest = MultiSensorAdapter.MultiSensorAdapter(
1, 1)
#SensorData object
self.sensorData = SensorData.SensorData()
self.sensorData.addValue(10)
self.sensorData.setName("TESTNAME")
#ActuatorData object
self.actuatorData = ActuatorData.ActuatorData()
self.actuatorData.setCommand("TESTCOMMAND")
self.actuatorData.setValue("TESTVALUE")
self.actuatorData.setName("TESTNAME")
class TempSensorAdaptor():
sh = None
nominalaveragetemp = 0
sensorid = 1
threshold = 3 # NOTE: 2 or 3
sleepcycle = 0
enableEmulator = False
isPrevTempSet = False
connector = SmtpClientConnector.SmtpClientConnector()
sensordata = SensorData.SensorData()
actuatordata = ActuatorData.ActuatorData()
def __init__(self):
self.sh = SenseHat()
self.nominalaveragetemp = self.connector.nominalTemp
self.sleepcycle = self.connector.pollCycleSecs
self.enableEmulator = self.connector.enableEmulator
def run(self):
while True:
if self.enableEmulator:
self.curTemp = self.sh.get_temperature()
self.sensordata.addValue(self.curTemp, 'Sensor'+str(self.sensorid))
self.sensorid += 1;
print('\n--------------------')
print('New sensor readings:')
print(' ' + str(self.sensordata))
print(' Current Temperature: '+ str(round(self.curTemp, 3)))
print(' Alert interval: [' + str(round(self.nominalaveragetemp - self.threshold,3))+ \
',' + str(round(self.nominalaveragetemp + self.threshold,3)) + ']' )
print(' NominalTemp: ' + str(round(self.nominalaveragetemp,3)))
if self.isPrevTempSet == False:
self.prevTemp = self.curTemp
self.isPrevTempSet = True
if (abs(self.curTemp - self.nominalaveragetemp) > self.threshold):
print('|Alert| Current temperature exceeds safe range: '
+str(round(abs(self.curTemp-self.nominalaveragetemp), 3)))
self.connector.publishMessage('Exceptional sensor data [test]', str(self.sensordata))
print(' Data has been sent to a remote system.')
if((self.curTemp - self.nominalaveragetemp > 0):
self.actuatordata.setCommand("Lower")
if((self.curTemp - self.nominalaveragetemp < 0):
self.actuatordata.setCommand("Raise")
actuatoremulator = TempActuatorEmulator()
actuatoremulator.processMessage(self.actuatordata)
sleep(self.sleepcycle)
def __init__(self):
'''
Constructor which calls the ActuatorData class
'''
self.actuator_data = ActuatorData.ActuatorData()
'''
Created on 2018年9月22日
@author: jrq
'''
import sys
sys.path.append('/home/pi/workspace/iot-device/apps')
from labs.common import ActuatorData
from labs.semesterProject import SenseHatLedActivator
from labs.common import ConfigUtil
from labs.common import ConfigConst
AcData = ActuatorData.ActuatorData()
SensHat = SenseHatLedActivator.SenseHatLedActivator()
config = ConfigUtil.ConfigUtil
buttonn = "False"
class TempActuatorEmulator():
def __init__(self):
self.config = ConfigUtil.ConfigUtil(
'../../../data/ConnectedDevicesConfig.props')
self.config.loadConfig()
#Read the config and get the data of nominalTemp
self.nomalTemp = self.config.getProperty(ConfigConst.DEVICE_SECTION,
ConfigConst.nominalTemp)
print("The nomalTemp is = " + str(self.nomalTemp))
'''
Created on 09-Feb-2019
@author: Adhira
'''
from labs.common import ActuatorData
from labs.module05.SenseHatLedActivator import SenseHatLedActivator
'''
Construct objects
'''
actuator = ActuatorData.ActuatorData()
senseHatActivator = SenseHatLedActivator()
'''
Emulator to generate temperature data
'''
class TempActuatorEmulator():
def __init__(self):
senseHatActivator.setEnableLedFlag(True)
'''
Implement method to accept and store actuator data
@param actuator: All data from actuator object
@summary:
1. Turn SenseHat ON
2. Start the thread
3. Update actuator data file
4. Set condition for displaying message
5. Call display message method from LedActivator
'''