def run(self):
while True:
if self.enableEmulator:
# Generate random value of current temperature between max and min values from Sensor data file
self.sensor.curValue = random.uniform(float(self.sensor.getMinValue()), float(self.sensor.getMaxValue()))
# Add the generated temperature value in the sensor data file
self.sensor.addValue(self.sensor.curValue)
# Generate readable output
print('\n--------------------')
print('New temperature is generating:')
print(' ' + str(self.sensor))
k = abs(self.sensor.curValue - self.sensor.getAvgValue())
# Condition for sending message
if (k >= self.alertDiff):
# Initialize object of SmtpClientConnector to publish the message
sen = SmtpClientConnector.SmtpClientConnector()
print('\n Oops...Current temperature exceeds average by > ' + str(k) + '. Sending notification...')
sen.publishMessage('This is the updated sensor information', self.sensor)
sleep(self.rateInSec)
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 TempSensorEmulator(Thread):
#creating the sensor data object and initial values to use inside Emulator
sensorData = SensorData.SensorData()
connector = SmtpClientConnector.SmtpClientConnector()
isPrevTempSet = False
lowVal = 0
highVal = 30
alertDiff = 5
#initiating the thread for the emulator
def __init__(self):
Thread.__init__(self)
def run(self):
while True:
if self.enableEmulator:
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:
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)
sleep(5)
class TempSensorEmulator (threading.Thread):
sensorData = SensorData.SensorData()
connector = SmtpClientConnector.SmtpClientConnector()
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(TempSensorEmulator, self).__init__()
if rateInSec > 0:
self.rateInSec = rateInSec
def run(self):
while True:
if self.enableEmulator:
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:
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):
while True:
'''
Enabling the Emulator and generates the current value provided within the range
and printing the sensor data.
'''
if self.enableEmulator:
self.sensor.curVal = uniform(float(self.sensor.getMinValue()),
float(self.sensor.getMaxValue()))
self.sensor.addValue(self.sensor.curVal)
print(self.sensor)
'''
Alert Notification will be sent if the current value exceeds the threshold value
which is the addition of the average value and 10
'''
if self.sensor.curVal >= (self.sensor.getAvgValue() + 10):
data = (self.sensor)
print(data)
print("Warning: Temperature has been surpassed")
sensor_notification = SmtpClientConnector.SmtpClientConnector()
sensor_notification.publishMessage(
"Temperature Alert Notification", data)
'''
providing a delay for every sensor readings
'''
delay = int(
self.temp_delay.getProperty(
ConfigConst.ConfigConst.CONSTRAINED_DEVICE,
ConfigConst.ConfigConst.POLL_CYCLES_KEY))
sleep(delay)
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, 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();
class TempSensorAdaptor(threading.Thread):
'''
classdocs
'''
actuatorData = None
tempActuatorEmulator = None
connector = SmtpClientConnector.SmtpClientConnector()
sensorData = SensorData.SensorData()
alertDiff = 5
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 run(self):
nominalTemp = int(self.config.getProperty(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.NOMINAL_TEMP_KEY))
while True:
if self.enableEmulator:
self.curTemp = uniform(float(self.lowVal), float(self.highVal))
#self.curTemp =
self.sensorData.addValue(self.curTemp)
#print('the 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]', str(self.sensorData))
if (abs(self.curTemp - nominalTemp) > self.alertDiff):
val = self.curTemp - nominalTemp
self.actuatorData.setValue(val)
if (val > 0):
self.actuatorData.setCommand(1)
else:
self.actuatorData.setCommand(0)
self.tempActuatorEmulator.processMessage(self.actuatorData)
sleep(1)
def on_message(self, client, userdata, msg):
logging.info("the :\n" + str(msg.payload.decode("utf-8")))
logging.info("message topic=" + str(msg.topic))
logging.info("message qos=" + str(msg.qos))
logging.info("message retain flag=" + str(msg.retain))
smtpClientConnector = SmtpClientConnector.SmtpClientConnector()
smtpClientConnector.publishMessage("autoset airconditioner",
str(msg.payload.decode("utf-8")))
senseHat = SenseHat()
senseHat.show_message(str(msg.payload.decode("utf-8")))
sleep(5)
senseHat.clear()
class TempSensorAdaptor():
#Initialization of each parameters
lowVal = 0
highVal = 0
cruTemp = 0
alertDiff = 5
enableAdaptor = False
isPrevTempSet = False
#Connecting to SMTP services
connector = SmtpClientConnector.SmtpClientConnector()
#Get the sensor data
sensordata = sense_hat.SenseHat
p = sensordata.get_temperature(1)
#Get the value of parameters from the App
def __init__(self, lowVal, highVal, curTemp, enableEmulator):
self.lowVal = lowVal
self.highVal = highVal
self.curTemp = curTemp
self.enableEmulator = enableEmulator
#Generate the Information that will be delivered
def run(self):
while True:
if self.enableAdaptor:
self.p = uniform(float(self.lowVal), float(self.highVal))
self.addValue(self.p)
print('\n-----------------------')
print('This is your current condition:')
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('Warning!!!',
self.sensordata)
sleep(30)
def run(self):
count = 10
sensordata = SensorData.SensorData()
while count > 0:
#generate a random temperature in [0,30]
temperature = random.uniform(0.0, 30.0)
sensordata.addValue(temperature)
# self.sendNotification()
#check if the temperature is surpass the threshold
if (abs(sensordata.getValue() - sensordata.getAvgValue()) >=
self.threshold):
logging.info('\n Current temp exceeds average by > ' +
str(self.threshold) + '. Triggering alert...')
smtpClientConnector = SmtpClientConnector.SmtpClientConnector()
smtpClientConnector.publishMessage("Excessive Temp",
sensordata)
count = count - 1
time.sleep(30)
def run(self):
while True:
if self.enableEmulator:
self.sensor.curVal = uniform(float(self.sensor.getMinValue()),
float(self.sensor.getMaxValue()))
self.sensor.addValue(self.sensor.curVal)
print(self.sensor)
if self.sensor.curVal >= (self.sensor.getAvgValue() + 7):
data = (self.sensor)
print(data)
print("Warning")
sen_not = SmtpClientConnector.SmtpClientConnector()
sen_not.publishMessage("Temperature Notification", data)
delay = int(
self.temp_delay.getProperty(
ConfigConst.ConfigConst.CONSTRAINED_DEVICE,
ConfigConst.ConfigConst.POLL_CYCLES_KEY))
sleep(delay)
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 TempSensorEmulator(threading.Thread):
rateInSec = DEFAULT_FATE_IN_SEC
connector = SmtpClientConnector.SmtpClientConnector()
sensorData = SensorData.SensorData()
alertDiff = 5
enableEmulator = False
lowVal = 0
highVal = 30
curTemp = 0
isPrevTempSet = True
#Constructor
def __init__(self):
super(TempSensorEmulator, self).__init__()
#set enableEmulator
def setEnableEmulatorFlag(self, flag):
self.enableEmulator = flag
def run(self):
while True:
if self.enableEmulator:
self.curTemp = uniform(float(self.lowVal), float(
self.highVal)) #get a emulated temperature
self.sensorData.addValue(
self.curTemp) #add current temperature to SensorData class
print('\n-------------------+-')
print('New sensor readings:')
print(' ' + str(self.sensorData))
if self.isPrevTempSet == False: #skip if this is the first temperature
self.prevTemp = self.curTemp
self.isPrevTempSet = True
elif (
abs(self.curTemp - self.sensorData.getAvgValue()) >=
self.alertDiff
): #if the current temperature is larger or less than the average temperature more than the alert value, publish the message
print('\n Current temp exceeds average by > ' +
str(self.alertDiff) + '. Triggeringalert...')
self.connector.publishMessage(
'Exceptional sensor data [test]', str(self.sensorData))
sleep(self.rateInSec)
def __init__(self):
'''
Constructor
'''
self.mqttClient = mqttClient.Client()
self.config = ConfigUtil.ConfigUtil()
self.sensoData = SensorData.SensorData()
self.config.loadConfig()
self.brockerKeepAlive = 60
self.connected_flag = False
self.pemfile = "/home/raspberry/workspace/ubidots_cert.pem"
self.authToken = 'A1E-nDuSgklKdOve42x5KXvi49lTs3pAi2'
self.port = 8883
self.brokerAddr = 'things.ubidots.com'
self.password = ''
self.smtp = SmtpClientConnector.SmtpClientConnector()
self.timeStamp = str(datetime.now())
self.senseled = SOSLed.SOSLed()
self.sensehatled = SenseHatLedActivator.SenseHatLedActivator()
def run(self):
sensordata = SensorData.SensorData()
while True:
sense = SenseHat()
#generate new temperature data
temperature = sense.get_temperature()
sensordata.addValue(temperature)
#add into log
logging.info(
"\n---------------------------------\nNew sensor readings:\n" +
"name=" + sensordata.name + ",timeStamp=" +
sensordata.timeStamp + ",minValue=" +
str(sensordata.minValue) + ",aveValue=" +
str(sensordata.avgValue) + ",maxValue=" +
str(sensordata.maxValue) + ",curValue=" +
str(sensordata.curValue) + ",totValue=" +
str(sensordata.totValue) + ",sampleCount=" +
str(sensordata.sampleCount))
#convert to json format from python object
datautil = DataUtil()
jsondata = datautil.toJsonFromSensorData(sensordata)
if (abs(sensordata.curValue - sensordata.avgValue) > 2):
logging.info(
"\nCurrent temp exceeds average by >2. Converting data...\n"
+ "JSON data:\n" + jsondata)
#smtp module
smtpClientConnector = SmtpClientConnector.SmtpClientConnector()
smtpClientConnector.publishMessage("Temperature", jsondata)
# logging.info("send email successfully")
#write json dta to filesystem
of = open("tempData.json", "w+")
of.write(jsondata)
of.close()
# logging.info("write data as JSON file to filesystem successfully")
time.sleep(10)
def run(self):
while True:
if self.enableTempEmulator:
if self.isPrevTempSet == False:
# corner code
self.prevTemp = self.curTemp
self.isPrevTempSet = True
else:
self.curTemp = uniform(float(self.min_value), float(self.max_value))
self.tempSensorData.addNewValue(self.curTemp)
print('----------------------------')
print('New sensor readings:')
print(str(self.tempSensorData))
if abs(self.tempSensorData.avgTemp - self.tempSensorData.curTemp) > 5:
print("Current temp exceeds average by >" + str(abs(self.tempSensorData.avgTemp - self.curTemp)))
# config data path
path = "../../../data/ConnectedDevicesConfig.props"
# new SmtpClientConnector instance add path
emailSender = SmtpClientConnector.SmtpClientConnector(path)
emailSender.sendEmailMessage("TemperatureEmulator(Exceptional)", self.tempSensorData)
print("")
sleep(self.rateInSec)
def run(self):
while True:
if self.enableEmulator:
self.sensor.curVal = uniform(float(self.sensor.getMinValue()),
float(self.sensor.getMaxValue()))
self.sensor.addValue(self.sensor.curVal)
self.sensor.diffVal = self.sensor.curVal - self.sensor.avgVal
print(self.sensor)
if self.sensor.curVal >= (self.sensor.getAvgValue() + 2):
data = DataUtil()
self.sensor.timestamp = datetime.now()
json_data = data.toJsonfromSensor(self.sensor)
SensorData.SensorData.breach_values.append(self.sensor)
print(SensorData.SensorData.breach_values)
print(
"warning!!Temperature exceeded the average temperature by %.2f degrees"
% (self.sensor.diffVal))
sen_not = SmtpClientConnector.SmtpClientConnector()
sen_not.publishMessage("Temperature Notification",
json_data)
sleep(3)
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)
self.sensor.diffVal = self.sensor.curVal - self.sensor.avgVal
print(self.sensor)
'''
Alert Notification will be sent if the current value exceeds
the average value by 3 then the mail will be sent, and
printing the JSON string in the console output
'''
if self.sensor.curVal >= (self.sensor.getAvgValue() + 3):
data = DataUtil.DataUtil()
self.sensor.timestamp = datetime.now()
json_data = data.SensorDataToJson(self.sensor)
SensorData.SensorData.surpassed_values.append(self.sensor)
#print(SensorData.SensorData.surpassed_values)
print("Warning: Temperature has been surpassed")
print("\nJSON data: " + json_data + '\n')
sensor_notification = SmtpClientConnector.SmtpClientConnector(
)
sensor_notification.publishMessage(
"Temperature Alert Notification: ", json_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 run(self):
sensordata = SensorData.SensorData()
# senseHatLedActivator = SenseHatLedActivator.SenseHatLedActivator()
senseledThread = SenseHatLedActivator.SenseHatLedActivator()
senseledThread.start()
#senseHatLedActivator.run()
while True:
sense = SenseHat()
temperature = sense.get_temperature()
sensordata.addValue(temperature)
#smtp module
if(abs(sensordata.getValue()-sensordata.getAvgValue())>=self.threshold):
logging.info('\n Current temp exceeds average by > ' + str(self.threshold) + '. Triggering alert...')
smtpClientConnector = SmtpClientConnector.SmtpClientConnector()
smtpClientConnector.publishMessage("Excessive Temp", sensordata)
nomialtemp = self.config.getProperty(ConfigConst.CONSTRAINED_DEVICE,ConfigConst.NOMINAL_TEMP_KEY)
#senseHat Led module
actuatordata = ActuatorData()
if(sensordata.getValue != nomialtemp):
logging.info('\n temperature is different from nomialtemp')
actuatordata.command = 1
actuatordata.statusCode = 1
actuatordata.errCode = 0
actuatordata.val = temperature
actuatordata.stateData = temperature - float(nomialtemp)
TempActuatorEmulator().processMessage(actuatordata, senseledThread)
else:
logging.info('\n temperature is equal to nomialtemp')
actuatordata.command = 1
actuatordata.statusCode = 0
actuatordata.errCode = 0
actuatordata.val = temperature
time.sleep(10)
class TempSensorEmulatorTask(object):
'''
classdocs
'''
#initialize sensor data to hold the aggregate and current temp values
sensorData = SensorData.SensorData()
#intialize smtp connector for sending notifications
smtpConnector = SmtpClientConnector.SmtpClientConnector()
#disable the emulator initially
enableEmulator = False
'''
constructor takes in the lower and upper bound on temperature generator,
how often it should generate temp and the threshold for max difference between
average and current temp
'''
def __init__(self, minTemp = 0.0, maxTemp = 30.0, rateInSec = 3, threshold = 5.0, numReadings = 10):
'''
Constructor
'''
#set the values to the default values or the one sent while instantiating
self.rateInSec = rateInSec
self.minTemp = minTemp
self.maxTemp = maxTemp
self.threshold = float(threshold)
self.numReadings = numReadings
#method to generate a random temperature between the lower and upper bound
def generateRandomTemperature(self):
#generator doesn't run if 0 readings set:
if self.numReadings == 0:
return False
#run the loop as many times as indicated in the numReadings variable
while self.numReadings > 0:
#if the emulator is enabled
if self.enableEmulator:
#generate a random temperature
self.sensorData.addValue(random.uniform(float(self.minTemp), float(self.maxTemp)))
#store the updated values from sensorData object
time = ' Time: ' + self.sensorData.timeStamp
current = ' Current: ' + str(self.sensorData.getCurrentValue())
average = ' Average: ' + str(self.sensorData.getAverageValue())
samples = ' Samples: ' + str(self.sensorData.getCount())
min_temp = ' Min: ' + str(self.sensorData.getMinValue())
max_temp = ' Max: ' + str(self.sensorData.getMaxValue())
data = 'Temperature' + '\n' + time + '\n' + current + '\n' + average + '\n' + samples + '\n' + min_temp + '\n' + max_temp
#log the current sensorData values
logging.info(data)
#check if the current value and the average value differ by more than the threshold
if abs(self.sensorData.getCurrentValue() - self.sensorData.getAverageValue()) > self.threshold:
#send notfication if so
self.sendNotification(data)
#decrement as the number of readings by 1 to keep count of how many readings left
self.numReadings -= 1
#sleep for time indicated in rateInSec
sleep(self.rateInSec)
#if emulator is not enabled
else:
#generator didn't run
return False
#the generator is done running
return True
#method that returns the reference to the sensorData
def getSensorData(self) -> SensorData.SensorData:
return self.sensorData
#method for sending the notification via e-mail
def sendNotification(self, data):
#if the currentValue is greater than or equal to the average by more than the threshold
if self.getSensorData().getCurrentValue() >= self.getSensorData().getAverageValue():
#log the difference
logging.info('\n Current temperature exceeds average by > ' + str(self.threshold) + '. Triggering alert ')
#send email with topic indicating excessive temperature
self.smtpConnector.publishMessage("Excessive Temperature", data)
#if current value is less than the average by more than the threshold
elif self.getSensorData().getCurrentValue() < self.getSensorData().getAverageValue():
#log the difference
logging.info('\n Average temperature exceeds current value by >' + str(self.threshold) + '. Triggering alert ')
#send email with topic indicating excessive temperature
self.smtpConnector.publishMessage("Too low temperature", data)
#return true for running successfully
return True
class TempSensorAdaptorTask(Thread):
'''
Variables are defined and objects of required classes are created with the class scope.
'''
sensorData = SensorData() #constructor of sensorData is created.
sensorDataM = SensorDataManager(
) #constructor of SensorDataManager is created.
smtpCCObject = SmtpClientConnector.SmtpClientConnector(
) ##constructor of SmtpClientConnector is created.
confP = ConfigUtil() #constructor of ConfigUtil is created.
avgValue = 0.0
count = 0.0
total = 0.0
currentValue = 0.0
maxValue = 0.0
minValue = 0.0
timestamp = None
sh = SenseHat() #constructor of SenseHat is created.
du = DataUtil()
'''
nominal temperature is fetched from configuration file using object of ConfigParser.
'''
nominal = confP.getValue("device", "nominalTemp")
'''
constructor of class TempSensorAdaptorTask
'''
def __init__(self, name):
# self.generateTemp()
Thread.__init__(self)
self.name = name
self.temp = pu.getSensorDataFromDbms()
self.act = pu.getActuatorDataFromDbms()
# self.act=None
if (self.temp == None):
self.run()
# print(self.temp)
'''
this run function overrides the run function of Thread and calls the sense hat function to generate the temperature values,addValue fnctn of sensorData is called
handleSensorData of class sensorDataManager is called and sensorData object is passed as a parameter.
This function will return the actuator data. notification fucn will be called to check the condition of sending the email
'''
def run(self):
#for i in range(0,10):
while True:
self.val = self.sh.get_temperature(
) #calling get_temperature function
j = {}
#curVal=pu.getActuatorDataFromDbms()
jj = pu.getActuatorDataFromDbms()
if (len(self.act) < 20):
pu.writeActuatorDataToDbms()
# print(jj)
adl = ActuatorDataListener()
c = adl.onActuatorMessage(self.temp)
if (c != self.temp):
self.temp = c
self.sensorData.addValue(
self.val) #calling addValue function of sensorData
# self.act_data=self.sensorDataM.handleSensorData(self.sensorData)
self.getSensorData()
sdj = self.du.toJsonFromSensorData(self.sensorData)
print("**************")
print(sdj)
st = pu.writeSensorDataToDbms(self.sensorData)
time.sleep(2)
'''
values of sensor data is fetched to store in local variables.
'''
def getSensorData(self):
self.avgValue = self.sensorData.getAverageValue()
self.count = self.sensorData.getCount()
self.total = self.sensorData.getTotal()
self.currentValue = self.sensorData.getCurrentValue()
self.maxValue = self.sensorData.getMaxValue()
self.minValue = self.sensorData.getMinValue()
self.timestamp = self.sensorData.getTimestamp()
'''
notification regarding email alert and logging information is handled by sendNotification function, it takes 3 arguments
namely command which is set to actuator data, current Temperature value and the nominal value
'''
def sendNotification(self, command, current, nominal):
logging.basicConfig(level=logging.INFO, format='%(message)s')
# logging.basicConfig(level=logging.INFO)
data = "Temperature:\nTime: " + str(
self.timestamp) + "\nCurrent: " + str(
self.currentValue) + "\nAverage: " + str(
self.avgValue) + "\nSamples: " + str(
self.count) + "\nMin: " + str(
self.minValue) + "\nMax: " + str(self.maxValue)
logging.info(data)
print("\n")
class TempSensorAdaptor(threading.Thread):
enableAdaptor = False
actuatorData = None
tempActuatorEmulator = None
connector = SmtpClientConnector.SmtpClientConnector()
sensorData = SensorData.SensorData()
alertDiff = 5
rateInSec = DEFAULT_FATE_IN_SEC
enableEmulator = False
lowVal = 0
highVal = 30
curTemp = 0
isPrevTempSet = True
#Constructor
def __init__(self):
super(TempSensorAdaptor, self).__init__()
self.config = ConfigUtil.ConfigUtil('')
self.config.loadConfig()
self.actuatorData = ActuatorData()
self.tempActuatorEmulator = TempActuatorEmulator()
#set enableEmulator
def setEnableAdaptorFlag(self, flag):
self.enableAdaptor = flag
def run(self):
nominalTemp = int(
self.config.getProperty(ConfigConst.CONSTRAINED_DEVICE,
ConfigConst.NOMINAL_TEMP_KEY)
) #get the value of nominal temperature from ConfigConst class
while True:
if self.enableEmulator:
self.curTemp = uniform(float(self.lowVal), float(
self.highVal)) #get a emulated temperature
self.sensorData.addValue(
self.curTemp) #add current temperature to SensorData class
print('\n--------------------')
print('New sensor readings:')
#print(' ' + str(self.sensorData))
if self.isPrevTempSet == False: #skip if this is the first temperature
self.prevTemp = self.curTemp
self.isPrevTempSet = True
else:
if (
abs(self.curTemp - self.sensorData.getAvgValue())
>= self.alertDiff
): #if the current temperature is larger or less than the average temperature more than the alert value, publish the message
print('\n Current temp exceeds average by > ' +
str(self.alertDiff) + '. Triggeringalert...')
#self.connector.publishMessage('Exceptional sensor data [test]', str(self.sensorData))
if (
abs(self.curTemp - nominalTemp) > self.alertDiff
): #if the current temperature is larger or less than the nominal temperature more than the alert level, run the actuator to adjust the temperature
print('\n+++++++++++++++++++')
print('to the actuator:')
val = self.curTemp - nominalTemp
self.actuatorData.setValue(val)
if (val > 0):
print('val > 0')
self.actuatorData.setCommand(1)
else:
print('val < 0')
self.actuatorData.setCommand(0)
self.tempActuatorEmulator.processMessage(
self.actuatorData)
sleep(self.rateInSec)
'''
Created on 2018年9月15日
@author: howson
'''
import random
from time import sleep
import threading
from labs.common import SensorData
from labs.module02 import SmtpClientConnector
DEFAULT_RATE_IN_SEC = 10
Sens = SensorData.SensorData()
SmtpConnector = SmtpClientConnector.SmtpClientConnector()
class TempSensorEmulator(threading.Thread):
enableEmulator = False
isPrevTempSet = False
rateInSec = DEFAULT_RATE_IN_SEC
Sens.setName('Temperature')
lowVal = 0
highVal = 30
alertDiff = 5
def __init__(self, rateInSec=DEFAULT_RATE_IN_SEC):
super(TempSensorEmulator, self).__init__()
if rateInSec > 0:
'/home/pi/workspace/iot-device/connected-devices-python/apps')
from labs.module02 import SmtpClientConnector
import time
import requests
import random
from sense_hat import SenseHat
import json
my_device = "raspberrypi" # My Device label
my_temp_var = "temperature" # My First variable label
my_humid_var = "humidity" # My Second variable label
my_press_var = "pressure" # My Third variable label
my_co_ordinates = "position" # My Fourth Variable
my_auth_token = "YOUR PERSONAL AUTH TOKEN" # My Auth TOKEN
conn = SmtpClientConnector.SmtpClientConnector() # instance for SMTP client
"""Function to create the pay-load to send to cloud and returns the pay-load"""
"""@parameter: temp, humid, press and pos."""
def my_payload(temp, humid, press, pos):
# Creates three variables for sending data
instance = SenseHat() # create a sense-hat instance
result_temp = instance.get_temperature(
) # get temperature readings from sense-hat.
result_humd = instance.get_humidity(
) # get humidity readings from sense-hat.
result_press = instance.get_pressure(
) # get pressure readings from sense-hat.
"""Generate Random Co-Ordinates for Country - India"""
lat = random.randrange(10, 26, 1) + random.randrange(1, 1000, 1) / 1000.0
class TempSensorAdaptor(threading.Thread):
enableAdaptor = False
actuatorData = None
tempActuatorEmulator = None
connector = SmtpClientConnector.SmtpClientConnector()
sensorData = SensorData.SensorData()
alertDiff = 1
rateInSec = DEFAULT_FATE_IN_SEC
enableEmulator = False
lowVal = 0
highVal = 30
curTemp = 0
isPrevTempSet = True
# Constructor
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(
)
# set enableEmulator
def setEnableAdaptorFlag(self, flag):
self.enableAdaptor = flag
def run(self):
self.nominalTemp = int(
self.config.getProperty(ConfigConst.CONSTRAINED_DEVICE,
ConfigConst.NOMINAL_TEMP_KEY)
) # get the value of nominal temperature from ConfigConst class
while True:
if self.enableAdaptor:
self.curTemp = self.senseHat.get_temperature(
) # get a emulated temperature
self.sensorData.addValue(
self.curTemp
) # add current temperature to SensorData class
print('\n--------------------')
print('New sensor readings:')
self.coapConnector.initClient("")
self.coapConnector.handleGetTest("myHomeTemperature")
self.coapConnector.handlePostTest("myHomeTemperature",
str(self.curTemp))
if self.isPrevTempSet == False: # skip if this is the first temperature
self.prevTemp = self.curTemp
self.isPrevTempSet = True
else:
self.sendEmail()
sleep(self.rateInSec)
# if the current temperature is larger or less than the average temperature more than the alert value, publish the message
def sendEmail(self):
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]',
str(self.sensorData))
# if the current temperature is larger or less than the nominal temperature more than the alert level, run the actuator to adjust the temperature
def tragerActuator(self, data):
self.tempActuatorEmulator.processMessage(data)
Created on Jan 21, 2019
@author: Suraj
'''
import labs.common.ConfigUtil as ConfigUtil
from threading import Thread
from time import sleep
from random import uniform
from labs.common import SensorData
from labs.module02 import SmtpClientConnector
from labs.common import ConfigConst
from labs.common.ActuatorData import ActuatorData
from labs.module03.TempActuatorEmulator import TempActuatorEmulator
sensorData = SensorData.SensorData() #Create an instance of SensorData class
smtpconnector = SmtpClientConnector.SmtpClientConnector(
) #Create an instance of SmtpClientConnector
actuatorData = ActuatorData() #Create an instance of ActuatorData
TempActuatorEmulator = TempActuatorEmulator(
) #Create an instance of TempActuatorEmulator
class TempSensorAdaptor(Thread):
'''
Constructor
'''
def __init__(self): # Overriding constructor __init__ here with parameters
Thread.__init__(
self) # Calling __init__(self) from parent class Thread
self.threadID = 1 # initializing Thread ID
self.enable_Adaptor = False # initializing enable_Adaptor
self.name = "Thread" # initializing name of the Thread
import sys
sys.path.insert(0,
'/home/pi/workspace/iot-device/connected-devices-python/apps')
import random
from sense_hat import SenseHat
from time import sleep
from threading import Thread
from labs.common import SensorData
from labs.module02 import SmtpClientConnector
from labs.module03 import TempActuatorEmulator
import labs.common.ConfigConst as configconst
from labs.common import ConfigUtil
from labs.common import ActuatorData
from awscli.customizations.emr.constants import TRUE
sen = SmtpClientConnector.SmtpClientConnector()
# red = (255, 0, 0)
blue = (255, 0, 0)
class allSensorAdaptor(Thread):
def __init__(self):
Thread.__init__(self)
self.flag = True
self.rateInSec = 5
def run(self):
while True:
if self.flag == True:
sense = SenseHat()
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)
class TempSensorAdaptorTask(Thread):
'''
Variables are defined and objects of required classes are created with the class scope.
'''
sensorData=SensorData() #constructor of sensorData is created.
tempAct=TempActuatorAdaptor() #constructor of TempActuatorAdaptor is created.
sensorDataM=SensorDataManager() #constructor of SensorDataManager is created.
smtpCCObject=SmtpClientConnector.SmtpClientConnector() ##constructor of SmtpClientConnector is created.
confP=ConfigUtil() #constructor of ConfigUtil is created.
avgValue=0.0
count=0.0
total=0.0
currentValue=0.0
maxValue=0.0
minValue=0.0
timestamp=None
sh=SenseHat() #constructor of SenseHat is created.
'''
nominal temperature is fetched from configuration file using object of ConfigParser.
'''
nominal=confP.getValue("device", "nominalTemp")
'''
constructor of class TempSensorAdaptorTask
'''
def __init__(self,name):
# self.generateTemp()
Thread.__init__(self);
self.name=name
'''
this run function overrides the run function of Thread and calls the sense hat function to generate the temperature values,addValue fnctn of sensorData is called
handleSensorData of class sensorDataManager is called and sensorData object is passed as a parameter.
This function will return the actuator data. notification fucn will be called to check the condition of sending the email
'''
def run(self):
#for i in range(0,10):
# while True:
mqtt_client = mqttClient.Client()
while True:
self.val=self.sh.get_temperature() #calling get_temperature function
self.sensorData.addValue(self.val) #calling addValue function of sensorData
self.act_data=self.sensorDataM.handleSensorData(self.sensorData)
self.getSensorData()
#commented out for mod8# self.sendNotification(self.act_data.getCommand(), self.act_data.getValue(),self.nominal)
ubidots(mqtt_client,self.currentValue,"temperature")
time.sleep(2)
#mod8# if(self.act_data!=None):
#mod8# self.tempAct.updateActuator(self.act_data) #calling of updateActuator
#mod8# time.sleep(2)
# return None
'''
values of sensor data is fetched to store in local variables.
'''
def getSensorData(self):
self.avgValue= self.sensorData.getAverageValue();
self.count=self.sensorData.getCount();
self.total=self.sensorData.getTotal();
self.currentValue=self.sensorData.getCurrentValue();
self.maxValue=self.sensorData.getMaxValue();
self.minValue=self.sensorData.getMinValue();
self.timestamp=self.sensorData.getTimestamp();
'''
notification regarding email alert and logging information is handled by sendNotification function, it takes 3 arguments
namely command which is set to actuator data, current Temperature value and the nominal value
'''
def sendNotification(self,command,current,nominal):
logging.basicConfig(level=logging.INFO,format='%(asctime)s:%(levelname)s:%(message)s')
nominal=float(nominal)
if(command=="TEMP INC"):
logging.info('\n Current temperature exceeds Nominal Temperature by ' + str(round(abs(current-nominal),2)) + '. Triggering alert...')
elif(command=="TEMP DEC"):
logging.info('\n Current temperature deceeds Nominal Temperature by ' + str(round(abs(current-nominal),2)) + '. Triggering alert...')
else:
logging.info('\n Current temperature is neutral to Nominal Temperature')
# self.smtpCCObject.connector(command)
logging.basicConfig(level=logging.INFO)
data="Temperature:\nTime: "+str(self.timestamp)+"\nCurrent: "+str(self.currentValue)+"\nAverage: "+str(self.avgValue)+"\nSamples: "+str(self.count)+"\nMin: "+str(self.minValue)+"\nMax: "+str(self.maxValue)
logging.info(data)
print("\n")
