moved setup of sensors to dedicated class

Logger.py

@@ -12,21 +12,21 @@ import settings
 
 class Logger(object):
 	def __init__(self, log):
-		self.names = settings.NAMES
 		self.temp_sensors = settings.tempSensors
-		self.temp_prev_default=settings.prev_temps_default
+		self.temp_prev_default = settings.prev_temps_default
-		self.prev_temps =[]
+		self.prev_temps = []
 		for i in range(self.temp_sensors):
 			self.prev_temps.append(self.temp_prev_default)
 		self.temp_max_diff = settings.tempmaxdiff
 		self.log = log
 		self.records = settings.records
+		self.units = settings.SENSOR_UNITS
 	
 	def temp_rise(self,old,new,sensor):
 		if(old==self.temp_prev_default):
 			return True
 		if((old-new)>self.temp_max_diff or (new-old)>self.temp_max_diff):
-			self.log.write('error checking '+self.names[sensor]+';prev('+str(old)+');cur('+str(new)+'); ... @'+time.ctime()+"\n")
+			self.log.write('error checking '+sensor+';prev('+str(old)+');cur('+str(new)+'); ... @'+time.ctime()+"\n")
 			self.log.flush()
 			return False
 		else:
@@ -37,7 +37,7 @@ class Logger(object):
 	##########################################
 	def write_value(self,value,sensor):
 		# TODO: catch IOError
-		valuename=self.records+"/"+self.names[sensor]+"_"+preptime()
+		valuename=self.records+"/"+sensor+"_"+preptime()
 		valuelog=open(valuename,'a')
 		valuelog.write(str(value) + ';' + str(int(time.time())) +"\n")
 		valuelog.close()
@@ -45,17 +45,19 @@ class Logger(object):
 	##########################################
 	# generic callback	 					 #
 	##########################################
-	def cb_generic(self,value, sensor, type):
+	def cb_generic(self,value, sensor, type, supress = False):
 		if(type == SensorType.temp):
-			if(self.temp_rise(self.prev_temps[sensor],value,sensor)):
+			i = int(sensor[-1])-1 #sensor contains name, followed by int
+			if(self.temp_rise(self.prev_temps[i],value,sensor)):
 				self.write_value(value,sensor)
-				self.prev_temps[sensor]=value
+				self.prev_temps[i]=value
 		elif (type == SensorType.none):
 			return
 		else:
 			self.write_value(value,sensor)
-		unit=settings.SENSOR_VALUES[type]
+		unit=self.units[type]
-		print(self.names[sensor] +': ' + str(value/unit[0]) + ' '+unit[1]+', ' + str(time.ctime()))
+		if not supress:
+			print(sensor +': ' + str(value/unit[0]) + ' '+unit[1]+', ' + str(time.ctime()))
 	
 	###########################################
 	# exception logging						  #

Setup.py

@@ -0,0 +1,91 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+try:
+	from tinkerforge.ip_connection import IPConnection
+	from tinkerforge.bricklet_temperature import Temperature
+	from tinkerforge.bricklet_humidity import Humidity
+	from tinkerforge.bricklet_ambient_light import AmbientLight
+	from tinkerforge.bricklet_barometer import Barometer
+except ImportError:
+	print("package 'tinkerforge' not installed, canceling")
+	raise
+from functools import partial
+import traceback
+from settings import SensorType
+from Logger import Logger
+
+class Setup(object):
+
+	def __init__(self, connection, sensors, cbtimes, cb_generic):
+		self.connection = connection
+		self.sensors = sensors
+		self.cbtimes = cbtimes
+		self.cb_generic = cb_generic
+
+	def parametrizedCallback(self, name, type):
+		return partial(self.cb_generic, sensor=name, type=type)
+		
+	def setupTemp(self, callback, id, cbtime):
+		obj = Temperature(id, self.connection)
+		obj.set_temperature_callback_period(cbtime)
+		callback(obj.get_temperature())
+		obj.register_callback(obj.CALLBACK_TEMPERATURE, callback)
+		return obj
+		
+	def setupHumi(self, callback, id, cbtime):
+		obj = Humidity(id, self.connection)
+		obj.set_humidity_callback_period(cbtime)
+		callback(obj.get_humidity())
+		obj.register_callback(obj.CALLBACK_HUMIDITY, callback)
+		return obj
+		
+	def setupAmbi(self, callback, id, cbtime):
+		obj = AmbientLight(id, self.connection)
+		obj.set_illuminance_callback_period(cbtime)
+		callback(obj.get_illuminance())
+		obj.register_callback(obj.CALLBACK_ILLUMINANCE, callback)
+		return obj
+		
+	def setupBaro(self, callback, id, cbtime):
+		obj = Barometer(id, self.connection)
+		callback(obj.get_air_pressure())
+		obj.set_air_pressure_callback_period(cbtime)
+		obj.register_callback(obj.CALLBACK_AIR_PRESSURE,callback)
+		return obj
+	
+	def setupNone(self, callback, id, cbtime):
+		obj = "None " + str(id)
+		return obj
+
+	def genericSensorSetup(self, name, sensor):
+		status = "setup device "+ sensor[0] +" ("+ name +"): "
+		callback = self.parametrizedCallback(name, type=sensor[1])
+		cbtime = self.cbtimes[sensor[1]]
+		try:
+			if sensor[1] is SensorType.temp:
+				obj = self.setupTemp(callback, sensor[0], cbtime)
+			elif sensor[1] is SensorType.humi:
+				obj = self.setupHumi(callback, sensor[0], cbtime)
+			elif sensor[1] is SensorType.ambi:
+				obj = self.setupAmbi(callback, sensor[0], cbtime)
+			elif sensor[1] is SensorType.baro:
+				obj = self.setupBaro(callback, sensor[0], cbtime)
+			status += "OK"
+		except Exception as e:
+			status += "FAIL"
+			#print(e)
+			#print(traceback.format_exc())
+		print(status)
+		obj = self.setupNone(callback, sensor[0] + name, cbtime)
+		return obj
+		
+	def setupSensors(self):
+		connected=[]
+		for name in self.sensors:
+			sensor = self.sensors[name]
+			obj = self.genericSensorSetup(name, sensor)
+			connected.append(obj)
+		return connected
+
+	

all.py

@@ -15,9 +15,9 @@ except ImportError:
 import os.path
 import os
 import time
-from functools import partial
 
 from Logger import Logger
+from Setup import Setup
 from settings import SensorType
 import settings
 
@@ -38,66 +38,51 @@ def check_dirs_and_files():
 	if not os.path.exists(settings.records):
 		os.mkdir(settings.records, 0000755)
 
+def obtainLock(lockfile = settings.lockname):
+	if not os.path.exists(lockfile):
+		lock=open(lockfile,'w')
+		lock.write(str(time.time()))
+		lock.close()
+		return True
+	return False
+def freeLock(lockfile = settings.lockname):
+	if os.path.exists(lockfile):
+		os.remove(lockfile)
+def disconnect(connection):
+	if not connection.get_connection_state() is IPConnection.CONNECTION_STATE_DISCONNECTED:
+		connection.disconnect()
+
 if __name__ == "__main__":
 	check_dirs_and_files()
 	log=open(settings.logname,'a')
 	try:
 		while True:
-			if not os.path.exists(settings.lockname):
+			if obtainLock():
-				lock=open(settings.lockname,'w')
+				logger=Logger(log, )
-				lock.write(str(time.time()))
-				lock.close()
-				# lock obtained
-				logger=Logger(log)
 				try:
 					ipcon = IPConnection()
 					# connect
 					ipcon.connect(settings.HOST, settings.PORT)
 					log.write('start logging "all" ... @'+time.ctime()+"\n")
 					log.flush()
-					connected=[]
+					setup = Setup(ipcon, settings.SENSORS, settings.TIMES, logger.cb_generic)
-					for i,sensor in enumerate(settings.SENSORS):
+					connected = setup.setupSensors()
-						print("setup device "+sensor[0]+" ("+str(i)+")")
+					raw_input('Press key to restart\n')
-						callback=partial(logger.cb_generic, sensor=i, type=sensor[2])
+					disconnect(ipcon)
-						cbtime=settings.TIMES[sensor[2]]
-						if(sensor[2] == SensorType.temp):
-							obj = Temperature(sensor[1], ipcon)
-							obj.set_temperature_callback_period(cbtime)
-							callback(obj.get_temperature())
-							obj.register_callback(obj.CALLBACK_TEMPERATURE, callback)
-						elif (sensor[2] == SensorType.humi):
-							obj = Humidity(sensor[1], ipcon)
-							obj.set_humidity_callback_period(cbtime)
-							callback(obj.get_humidity())
-							obj.register_callback(obj.CALLBACK_HUMIDITY, callback)
-						elif(sensor[2] == SensorType.ambi):
-							obj = AmbientLight(sensor[1], ipcon)
-							obj.set_illuminance_callback_period(cbtime)
-							callback(obj.get_illuminance())
-							obj.register_callback(obj.CALLBACK_ILLUMINANCE, callback)
-						elif (sensor[2] == SensorType.baro):
-							obj = Barometer(sensor[1], ipcon)
-							callback(obj.get_air_pressure())
-							obj.set_air_pressure_callback_period(cbtime)
-							obj.register_callback(obj.CALLBACK_AIR_PRESSURE,callback)
-						else:
-							continue
-						connected.append(obj)
-					raw_input('Press key to exit\n')
-					ipcon.disconnect()
 					log.write('stop logging... @'+time.ctime()+"\n")
 				except Exception as inst:
 					#connection failed, log and exit
 					logger.printException(inst)
-				os.remove(settings.lockname)
+					print(inst)
+				freeLock()
 			else:
 				print('lock file active!!')
 				log.write('lock collision: lock "all" active @ '+time.ctime()+"\n")
-		print("something failed, wait for retry ("+settings.waitDelay+")")
+			print("wait for retry ("+str(settings.waitDelay)+")")
 			time.sleep(settings.waitDelay)
 	except KeyboardInterrupt:
-		print("Interrupted")
+		print("Interrupted, cleaning up")
+		disconnect(ipcon)
 		log.write("keyboard-interrupt happened @"+time.ctime()+"\n")
-		os.remove(settings.lockname)
+		freeLock()
-		ipcon.disconnect()
 

settings.py

@@ -12,17 +12,19 @@ class SensorType:
 
 
 #HOST = "localhost"
-HOST = "192.168.2.34"
+#HOST = "192.168.2.34"
+HOST = "192.168.2.60"
 PORT = 4223
 
-SENSORS=[
+SENSORS={
-	["temp1", "7B5", SensorType.temp],
+	"temp1": ["7B5", SensorType.temp],
-	["temp2", "8js", SensorType.temp],
+	"temp2": ["8js", SensorType.temp],
-	["humi1", "7RY", SensorType.humi],
+	"humi1": ["7RY", SensorType.humi],
-	["ambi1", "8Fw", SensorType.ambi],
+	"ambi1": ["8Fw", SensorType.ambi],
-	["ambi2", "8DJ", SensorType.ambi],
+	"ambi2": ["8DJ", SensorType.ambi],
-	["baro1", "bB7", SensorType.baro],
+	"baro1": ["bB7", SensorType.baro],
-]
+	"temp3": ["8ms", SensorType.temp],
+}
 
 TIMES={
 	SensorType.temp: 30000,
@@ -48,7 +50,7 @@ waitDelay = 10
 # only change when new sensor is added #
 ########################################
 
-SENSOR_VALUES=[
+SENSOR_UNITS=[
 	(0,''),
 	(100.0, '°C'),
 	(10.0, '%RH'),
@@ -61,6 +63,5 @@ SENSOR_VALUES=[
 # no manual change needed #
 ###########################
 
-tempSensors=len(list(filter(lambda a: True if a[2]==SensorType.temp else False,SENSORS)))
+tempSensors=len(list(filter(lambda a: True if SENSORS[a][1]==SensorType.temp else False, SENSORS)))
-NAMES=list(map(lambda a:a[0], SENSORS))