def SensorsInfo(self):
"""Return a list with current sensor states for all enabled sensors"""
manager.deviceDetector()
devices = manager.getDeviceList()
sensors_info = []
if devices is None:
return sensors_info
for device in devices:
sensor = instance.deviceInstance(device['name'])
if 'enabled' not in device or device['enabled'] == 1:
sensor_types = {'Temperature': {'function': 'getCelsius', 'data_args': {'type': 'temp', 'unit': 'c'}},
'Humidity': {'function': 'getHumidityPercent', 'data_args': {'type': 'rel_hum', 'unit': 'p'}},
'Pressure': {'function': 'getPascal', 'data_args': {'type': 'bp', 'unit': 'pa'}},
'Luminosity': {'function': 'getLux', 'data_args': {'type': 'lum', 'unit': 'lux'}},
'Distance': {'function': 'getCentimeter', 'data_args': {'type': 'prox', 'unit': 'cm'}},
'ServoMotor': {'function': 'readAngle', 'data_args': {'type': 'analog_actuator'}},
'DigitalSensor': {'function': 'read', 'data_args': {'type': 'digital_sensor', 'unit': 'd'}},
'DigitalActuator': {'function': 'read', 'data_args': {'type': 'digital_actuator', 'unit': 'd'}},
'AnalogSensor': {'function': 'readFloat', 'data_args': {'type': 'analog_sensor'}},
'AnalogActuator': {'function': 'readFloat', 'data_args': {'type': 'analog_actuator'}}}
extension_types = {'ADC': {'function': 'analogReadAllFloat'},
'DAC': {'function': 'analogReadAllFloat'},
'PWM': {'function': 'pwmWildcard'},
'GPIOPort': {'function': 'wildcard'}}
for device_type in device['type']:
try:
display_name = device['description']
except:
display_name = None
if device_type in sensor_types:
try:
sensor_type = sensor_types[device_type]
func = getattr(sensor, sensor_type['function'])
if len(device['type']) > 1:
channel = '{}:{}'.format(device['name'], device_type.lower())
else:
channel = device['name']
cayennemqtt.DataChannel.add(sensors_info, cayennemqtt.DEV_SENSOR, channel, value=self.CallDeviceFunction(func), name=display_name, **sensor_type['data_args'])
except:
exception('Failed to get sensor data: {} {}'.format(device_type, device['name']))
else:
try:
extension_type = extension_types[device_type]
func = getattr(sensor, extension_type['function'])
values = self.CallDeviceFunction(func)
for pin, value in values.items():
cayennemqtt.DataChannel.add(sensors_info, cayennemqtt.DEV_SENSOR, device['name'] + ':' + str(pin), cayennemqtt.VALUE, value, name=display_name)
except:
exception('Failed to get extension data: {} {}'.format(device_type, device['name']))
logJson('Sensors info: {}'.format(sensors_info))
return sensors_info
def UpdateSchedules(self, jsonData):
retValue = True
logJson('UpdateSchedules' + str(jsonData), 'schedules')
info('Schedules updated from cloud...')
try:
with self.mutex:
jsonSchedules = jsonData['Schedules']
self.RemoveSchedules()
for item in jsonSchedules:
self.AddScheduledItem(item['Schedule'], True)
except:
exception('UpdateSchedules Failed')
retValue = False
return retValue
def BuildPT_SYSTEM_INFO(self):
try:
data = {}
data['MachineName'] = self.MachineId
data['PacketType'] = PacketTypes.PT_SYSTEM_INFO.value
data['Timestamp'] = int(time())
data['IpAddress'] = self.PublicIP
data['GatewayMACAddress'] = self.hardware.getMac()
raspberryValue = {}
raspberryValue['NetworkSpeed'] = str(
self.downloadSpeed.getDownloadSpeed())
raspberryValue['AntiVirus'] = 'None'
raspberryValue['Firewall'] = 'iptables'
raspberryValue['FirewallEnabled'] = 'true'
raspberryValue['ComputerMake'] = self.hardware.getManufacturer()
raspberryValue['ComputerModel'] = self.hardware.getModel()
raspberryValue['OsName'] = self.oSInfo.ID
raspberryValue['OsBuild'] = self.oSInfo.ID_LIKE if hasattr(
self.oSInfo, 'ID_LIKE') else self.oSInfo.ID
raspberryValue['OsArchitecture'] = self.hardware.Revision
raspberryValue['OsVersion'] = self.oSInfo.VERSION_ID
raspberryValue['ComputerName'] = self.machineName
raspberryValue['AgentVersion'] = self.config.get(
'Agent', 'Version', fallback='1.0.1.0')
raspberryValue['InstallDate'] = self.installDate
raspberryValue['GatewayMACAddress'] = self.hardware.getMac()
with self.sensorsClient.sensorMutex:
raspberryValue[
'SystemInfo'] = self.sensorsClient.currentSystemInfo
raspberryValue[
'SensorsInfo'] = self.sensorsClient.currentSensorsInfo
raspberryValue['BusInfo'] = self.sensorsClient.currentBusInfo
raspberryValue['OsSettings'] = RaspiConfig.getConfig()
raspberryValue['NetworkId'] = WifiManager.Network.GetNetworkId()
raspberryValue['WifiStatus'] = self.wifiManager.GetStatus()
try:
history = History()
history.SaveAverages(raspberryValue)
except:
exception('History error')
data['RaspberryInfo'] = raspberryValue
self.EnqueuePacket(data)
logJson('PT_SYSTEM_INFO: ' + dumps(data), 'PT_SYSTEM_INFO')
del raspberryValue
del data
data = None
except Exception as e:
exception('ThreadSystemInfo unexpected error: ' + str(e))
Debug()
def update_scheduled_events(self, events):
"""Update all scheduled events
events: list of all the new events to schedule"""
logJson('Update schedules: {}'.format(events))
debug('Updating schedules')
try:
with self.mutex:
self.remove_scheduled_events()
for event in events:
self.add_scheduled_event(event, True)
except:
exception('Failed to update scheduled events')
result = False
return True
def SendMessage(self, message):
logJson(message, 'SendMessage')
ret = True
if self.connected == False:
error('SendMessage fail')
ret = False
else:
try:
data = bytes(message, 'UTF-8')
max_size = 16383
if len(data) > max_size:
start = 0
current = max_size
end = len(data)
self.wrappedSocket.send(data[start:current])
while current < end:
start = current
current = start + max_size if start + max_size < end else end
self.wrappedSocket.send(data[start:current])
else:
self.wrappedSocket.send(data)
if self.onMessageSent:
self.onMessageSent(message)
message = None
except socket_error as serr:
error('SendMessage:' + str(serr))
ret = False
Daemon.OnFailure('cloud', serr.errno)
sleep(1)
except IOError as ioerr:
debug('IOError: ' + str(ioerr))
self.Restart()
#Daemon.OnFailure('cloud', ioerr.errno)
except socket_error as serr:
Daemon.OnFailure('cloud', serr.errno)
except:
exception('SendMessage error')
return ret
def SensorsInfo(self):
with self.sensorMutex:
devices = self.GetDevices()
debug(
str(time()) + ' Got devices info ' +
str(self.sensorsRefreshCount))
if devices is None:
return {}
for value in devices:
sensor = instance.deviceInstance(value['name'])
if 'enabled' not in value or value['enabled'] == 1:
sleep(SENSOR_INFO_SLEEP)
try:
if value['type'] == 'Temperature':
value['Celsius'] = self.CallDeviceFunction(
sensor.getCelsius)
value['Fahrenheit'] = self.CallDeviceFunction(
sensor.getFahrenheit)
value['Kelvin'] = self.CallDeviceFunction(
sensor.getKelvin)
if value['type'] == 'Pressure':
value['Pascal'] = self.CallDeviceFunction(
sensor.getPascal)
if value['type'] == 'Luminosity':
value['Lux'] = self.CallDeviceFunction(
sensor.getLux)
if value['type'] == 'Distance':
value['Centimeter'] = self.CallDeviceFunction(
sensor.getCentimeter)
value['Inch'] = self.CallDeviceFunction(
sensor.getInch)
if value['type'] in ('ADC', 'DAC', 'PWM'):
value['channelCount'] = self.CallDeviceFunction(
sensor.analogCount)
value['maxInteger'] = self.CallDeviceFunction(
sensor.analogMaximum)
value['resolution'] = self.CallDeviceFunction(
sensor.analogResolution)
value['allInteger'] = self.CallDeviceFunction(
sensor.analogReadAll)
value['allVolt'] = self.CallDeviceFunction(
sensor.analogReadAllVolt)
value['allFloat'] = self.CallDeviceFunction(
sensor.analogReadAllFloat)
if value['type'] in ('DAC'):
value['vref'] = self.CallDeviceFunction(
sensor.analogReference)
if value['type'] == 'PWM':
value['channelCount'] = self.CallDeviceFunction(
sensor.pwmCount)
value['maxInteger'] = self.CallDeviceFunction(
sensor.pwmMaximum)
value['resolution'] = self.CallDeviceFunction(
sensor.pwmResolution)
value['all'] = self.CallDeviceFunction(
sensor.pwmWildcard)
if value['type'] == 'Humidity':
value['float'] = self.CallDeviceFunction(
sensor.getHumidity)
value['percent'] = self.CallDeviceFunction(
sensor.getHumidityPercent)
if value['type'] == 'PiFaceDigital':
value['all'] = self.CallDeviceFunction(
sensor.readAll)
if value['type'] in ('DigitalSensor',
'DigitalActuator'):
value['value'] = self.CallDeviceFunction(
sensor.read)
if value['type'] == 'GPIOPort':
value['channelCount'] = self.CallDeviceFunction(
sensor.digitalCount)
value['all'] = self.CallDeviceFunction(
sensor.wildcard)
if value['type'] == 'AnalogSensor':
value['integer'] = self.CallDeviceFunction(
sensor.read)
value['float'] = self.CallDeviceFunction(
sensor.readFloat)
value['volt'] = self.CallDeviceFunction(
sensor.readVolt)
if value['type'] == 'ServoMotor':
value['angle'] = self.CallDeviceFunction(
sensor.readAngle)
if value['type'] == 'AnalogActuator':
value['float'] = self.CallDeviceFunction(
sensor.readFloat)
except:
exception("Sensor values failed: " + value['type'] +
" " + value['name'])
try:
if 'hash' in value:
value['sensor'] = value['hash']
del value['hash']
except KeyError:
pass
if self.currentSensorsInfo:
del self.currentSensorsInfo
self.currentSensorsInfo = None
self.currentSensorsInfo = devices
devices = None
if self.sensorsRefreshCount == 0:
info('System sensors info at start ' +
str(self.currentSensorsInfo))
debug(('New sensors info retrieved: {}').format(
self.sensorsRefreshCount))
logJson('Sensors Info updated: ' + str(self.currentSensorsInfo))
return self.currentSensorsInfo
def CalculateSensorsInfoAverages(self, current_avgs, new_sample, count_sensor):
try:
logJson('History SensorsInfo average: ' + str(new_sample), 'history')
info('Calculate sensor info averages: ' + str(count_sensor))
if not new_sample:
info('History average: New sample is empty.')
return
if 'SensorsInfo' in new_sample:
#print('Calculating sensors list: ' + str(new_sample))
#newSensorsDictionary = dict((i['sensor'], i) for i in data['SensorsInfo'])
if 'SensorsInfo' not in current_avgs:
current_avgs['SensorsInfo'] = []
count_sensor['SensorsInfo'] = {}
averageSensorsDictionary = {}
if len(current_avgs['SensorsInfo']) > 0:
averageSensorsDictionary = dict((i['sensor'], i) for i in current_avgs['SensorsInfo'])
if new_sample['SensorsInfo']:
for value in new_sample['SensorsInfo']:
if 'enabled' in value and value['enabled'] == 0:
continue
if value['sensor'] in averageSensorsDictionary:
#this means we need to calculate average
try:
if value['sensor'] not in count_sensor['SensorsInfo']:
count_sensor['SensorsInfo'][value['sensor']] = 0
count_sensor['SensorsInfo'][value['sensor']] += 1
if value['type'] == 'Temperature':
averageSensorsDictionary[value['sensor']]['Celsius'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['Celsius'], value['Celsius'], count_sensor['SensorsInfo'][value['sensor']] )
averageSensorsDictionary[value['sensor']]['Fahrenheit'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['Fahrenheit'], value['Fahrenheit'], count_sensor['SensorsInfo'][value['sensor']] )
averageSensorsDictionary[value['sensor']]['Kelvin'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['Kelvin'], value['Kelvin'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'Pressure':
averageSensorsDictionary[value['sensor']]['Pascal'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['Pascal'], value['Pascal'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'Luminosity':
averageSensorsDictionary[value['sensor']]['Lux'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['Lux'], value['Lux'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'Distance':
averageSensorsDictionary[value['sensor']]['Centimeter'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['Centimeter'], value['Centimeter'], count_sensor['SensorsInfo'][value['sensor']] )
averageSensorsDictionary[value['sensor']]['Inch'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['Inch'], value['Inch'], count_sensor['SensorsInfo'][value['sensor']] )
############################################################################################################
#averages for all fields that are arrays of values should not be done
# if value['type'] in ('ADC', 'DAC', 'PWM'):
# #never do average for : channelCount, maxInteger, resolution
# if value['type'] in ('ADC', 'DAC'):
# averageSensorsDictionary[value['sensor']]['allInteger'] = self.CalculateArrayAverage(averageSensorsDictionary[value['sensor']]['allInteger'], value['allInteger'], count_sensor['SensorsInfo'][value['sensor']])
# averageSensorsDictionary[value['sensor']]['allVolt'] = self.CalculateArrayAverage(averageSensorsDictionary[value['sensor']]['allVolt'], value['allVolt'], count_sensor['SensorsInfo'][value['sensor']])
# averageSensorsDictionary[value['sensor']]['allFloat'] = self.CalculateArrayAverage(averageSensorsDictionary[value['sensor']]['allFloat'], value['allFloat'], count_sensor['SensorsInfo'][value['sensor']])
# if value['type'] in ('PWM'):
# averageSensorsDictionary[value['sensor']]['all'] = self.CalculateArrayAverage(averageSensorsDictionary[value['sensor']]['all'], value['all'], count_sensor['SensorsInfo'][value['sensor']])
# if value['type'] == 'GPIOPort':
# #never do average for: channelCount
# averageSensorsDictionary[value['sensor']]['all'] = self.CalculateArrayAverage(averageSensorsDictionary[value['sensor']]['all'], value['all'], count_sensor['SensorsInfo'][value['sensor']])
# if value['type'] == 'PiFaceDigital':
# averageSensorsDictionary[value['sensor']]['all'] = self.CalculateArrayAverage(averageSensorsDictionary[value['sensor']]['all'], value['all'], count_sensor['SensorsInfo'][value['sensor']])
############################################################################################################
if value['type'] == 'Humidity':
averageSensorsDictionary[value['sensor']]['float'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['float'], value['float'], count_sensor['SensorsInfo'][value['sensor']] )
averageSensorsDictionary[value['sensor']]['percent'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['percent'], value['percent'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] in ('DigitalSensor', 'DigitalActuator'):
averageSensorsDictionary[value['sensor']]['value'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['value'], value['value'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'AnalogSensor':
averageSensorsDictionary[value['sensor']]['float'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['float'], value['float'], count_sensor['SensorsInfo'][value['sensor']] )
averageSensorsDictionary[value['sensor']]['integer'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['integer'], value['integer'], count_sensor['SensorsInfo'][value['sensor']] )
averageSensorsDictionary[value['sensor']]['volt'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['volt'], value['volt'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'ServoMotor':
averageSensorsDictionary[value['sensor']]['angle'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['angle'], value['angle'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'AnalogActuator':
averageSensorsDictionary[value['sensor']]['float'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['float'], value['float'], count_sensor['SensorsInfo'][value['sensor']] )
#else:
# current_avgs['SensorsInfo'].append(value)
# count_sensor['SensorsInfo'][value['sensor']] = 1
except:
exception('Error calculating sensors info averages for: ' + str(value))
else:
current_avgs['SensorsInfo'].append(value)
count_sensor['SensorsInfo'][value['sensor']] = 1
except:
exception('Error calculating sensors info averages: current_avgs {}, new_sample {} '.format(current_avgs, new_sample))
