added config parser

raspberry-pi/config.ini

@@ -0,0 +1,33 @@
+
+# size of the trackable area
+[field]
+  # width in mm
+  x = 450
+  # height in mm
+  y = 450
+
+# acoustic sensor config
+[ac_sensor]
+  # distancce between receivers in mm
+  sensor_distance = 450
+
+  # distance of the sensors in front of y=0 in mm
+  y_offset = 10
+
+  # left sensor x offset to the right border at x=0 in mm 
+  left_x_offset = 0
+
+  # right sensor x offset to the left border at x=sensor_distance in mm 
+  right_x_offset = 0
+
+  # default speed of sound in mm / us (or km / s)
+  # only used before calibration
+  sonicspeed = 0.343
+
+  # default arduino timing overhead in us
+  # only used before calibration
+  overhead = 150
+
+[mag_sensor]
+
+[opt_sensor]

raspberry-pi/connection.py

@@ -77,18 +77,17 @@ class ArduinoSlave(SerialConnection):
     super().__init__()
     self.sensorData = [0] * 13
     self._recvCbs = []
-    self._t = None
+    self._t = threading.Thread(target=self._readSensors, args=())
+    self._t.daemon = True  # thread dies when main thread (only non-daemon thread) exits.
 
   def open(self, port = None, baudrate = 1000000):
     super().open(port, baudrate)
-    if not self._t:
-      self._t = threading.Thread(target=self._readSensors, args=())
-      self._t.daemon = True  # thread dies when main thread (only non-daemon thread) exits.
+    if not self._t.is_alive():
       self._t.start()
 
   def close(self):
     super().close()
-    if self._t:
+    if self._t.is_alive():
       self._t._stop()
 
   def getAcusticRTTs(self): # in microseconds

raspberry-pi/gui/mainWindow.py

@@ -39,15 +39,6 @@ class MainWindow(tk.Frame):
     self.calibration_state.next_state()
     self.down_queue.put("calibrate")
 
-
-def start_mainwindow(up_queue,down_queue,calibration_state):
-  root = tk.Tk()
-  root.title("Tracking System")
-  view = MainWindow(root,up_queue,down_queue,calibration_state)
-  view.pack(side="top", fill="both", expand=True)
-  view.update()
-  root.mainloop()
-
 if __name__ == "__main__":
   root = tk.Tk()
   up_queue = queue.Queue()

raspberry-pi/main.py

@@ -1,23 +1,14 @@
 import sensors
+from gui.mainWindow import MainWindow
+
 import time
 import threading
 import queue
-import gui.mainWindow as mainWindow
-
-conf = {
-    "field":{
-        "x":450,
-        "y":450
-    },
-    "ac_sensor":{
-        "sensor_distance":450,
-        "y_offset":10,
-        "left_x_offset":0,
-        "rigth_x_offset":0,
-        "sonicspeed":0.343,
-        "overhead":150
-    }
-}
+import configparser
+import tkinter as tk
+
+conf = configparser.ConfigParser()
+conf.read('config.ini')
 
 class CalibrationStateMashine():
 
@@ -80,13 +71,15 @@ def main():
     ac_sensor = sensors.AcusticSensor(conf,up_queue,down_queue,calibration_state)
     sensor_thread = threading.Thread(target=ac_sensor.start)
 
-    ui_thread = threading.Thread(target=mainWindow.start_mainwindow, args=(up_queue,down_queue,calibration_state))
-
-    sensor_thread.start()
-    ui_thread.start()
     try:
-        while True:
-            time.sleep(1)
+        sensor_thread.start()
+        root = tk.Tk()
+        root.title("Tracking System")
+        view = MainWindow(root,up_queue,down_queue,calibration_state)
+        view.pack(side="top", fill="both", expand=True)
+        view.update()
+        root.mainloop()
+
     except KeyboardInterrupt:
         print("stop")
     except Exception as e:

raspberry-pi/sensors.py

@@ -13,17 +13,11 @@ conn = ArduinoSlave()
 
 class AcusticSensor:
   def __init__(self,conf,up_queue,down_queue,calibration_state):
-    self.sensor_distance = conf["ac_sensor"]["sensor_distance"]
-    self.field_heigth = conf["field"]["y"]
-    self.field_length = conf["field"]["x"]
-    self.sensor_y_offset = conf["ac_sensor"]["y_offset"]
-    self.left_sensor_x_offset = conf["ac_sensor"]["left_x_offset"]
-    self.rigth_sensor_x_offset = conf["ac_sensor"]["rigth_x_offset"]
-    self.sonic_speed = conf["ac_sensor"]["sonicspeed"]
-    self.overhead = conf["ac_sensor"]["overhead"]
     self.up_queue = up_queue
     self.down_queue = down_queue
     self.calibration_state = calibration_state
+    self.conf = conf
+    self.ac_conf = conf["ac_sensor"]
 
   def start(self):
     self.running = True
@@ -98,7 +92,7 @@ class AcusticSensor:
         self.calibration_state.reset_state()
         return
     left_time_1 = statistics.mean(self.time_vals[0])
-    rigth_time_2 = statistics.mean(self.time_vals[1])
+    right_time_2 = statistics.mean(self.time_vals[1])
     self.calibration_state.next_state() # signal gui to get next position
 
     while self.calibration_state.return_state() != 4:
@@ -119,27 +113,27 @@ class AcusticSensor:
         self.calibration_state.reset_state()
         return
     left_time_2 = statistics.mean(self.time_vals[0])
-    rigth_time_1 = statistics.mean(self.time_vals[1])
+    right_time_1 = statistics.mean(self.time_vals[1])
     self.calibration_state.next_state() # signal gui start of calculation
 
     timedif = left_time_2 - left_time_1
-    distance_1 = math.sqrt(self.left_sensor_x_offset**2 + (self.sensor_y_offset + self.field_heigth)**2 )
-    distance_2 = math.sqrt((self.left_sensor_x_offset + self.field_length)**2 + (self.sensor_y_offset + self.field_heigth)**2 )
+    distance_1 = math.sqrt(float(self.ac_conf["left_x_offset"])**2 + (float(self.ac_conf["y_offset"]) + float(self.conf["field"]["y"]))**2 )
+    distance_2 = math.sqrt((float(self.ac_conf["left_x_offset"]) + float(self.conf["field"]["x"])**2 + (float(self.ac_conf["y_offset"]) + float(self.conf["field"]["y"])))**2 )
     distancedif = distance_2 - distance_1
     sonicspeed_1 = distancedif / timedif
     overhead_1 = statistics.mean((left_time_1 - distance_1/sonicspeed_1,left_time_2 - distance_2/sonicspeed_1))
     print(left_time_1,distance_1,sonicspeed_1,left_time_2,distance_2,sonicspeed_1)
 
-    timedif = rigth_time_2 - rigth_time_1
-    distance_1 = math.sqrt(self.rigth_sensor_x_offset**2 + (self.sensor_y_offset + self.field_heigth)**2 )
-    distance_2 = math.sqrt((self.rigth_sensor_x_offset + self.field_length)**2 + (self.sensor_y_offset + self.field_heigth)**2 )
+    timedif = right_time_2 - right_time_1
+    distance_1 = math.sqrt(float(self.ac_conf["right_x_offset"])**2 + (float(self.ac_conf["y_offset"]) + float(self.conf["field"]["y"]))**2 )
+    distance_2 = math.sqrt((float(self.ac_conf["right_x_offset"]) + float(self.conf["field"]["x"])**2 + (float(self.ac_conf["y_offset"]) + float(self.conf["field"]["y"])))**2 )
     distancedif = distance_2 - distance_1
     sonicspeed_2 = distancedif / timedif
-    overhead_2 = statistics.mean((rigth_time_1 - distance_1/sonicspeed_2,rigth_time_2 - distance_2/sonicspeed_2))
+    overhead_2 = statistics.mean((right_time_1 - distance_1/sonicspeed_2,right_time_2 - distance_2/sonicspeed_2))
 
-    self.sonic_speed = statistics.mean((sonicspeed_1,sonicspeed_2))
-    self.overhead = statistics.mean((overhead_1,overhead_2))
-    print("calibration result",self.sonic_speed,self.overhead)
+    self.ac_conf["sonicspeed"] = str(statistics.mean((sonicspeed_1,sonicspeed_2)))
+    self.ac_conf["overhead"]   = str(statistics.mean((overhead_1,overhead_2)))
+    print("calibration result",float(self.ac_conf["sonicspeed"]),float(self.ac_conf["overhead"]))
     self.calibration_state.next_state()
 
   def read(self):
@@ -149,12 +143,12 @@ class AcusticSensor:
   def calculate_position(self,values):
     try:
       val1, val2 = values
-      val1 -= self.overhead
-      val2 -= self.overhead
-      distance_left = val1 * self.sonic_speed # millisecond -> mikrosecond value of distance is in mm
-      distance_rigth = val2 * self.sonic_speed
-      x = (self.sensor_distance**2 - distance_rigth**2 + distance_left**2) / (2*self.sensor_distance) + self.left_sensor_x_offset
-      y = math.sqrt(distance_left**2 - x**2) + self.sensor_y_offset
+      val1 -= float(self.ac_conf["overhead"])
+      val2 -= float(self.ac_conf["overhead"])
+      distance_left = val1 * float(self.ac_conf["sonicspeed"]) # millisecond -> mikrosecond value of distance is in mm
+      distance_right = val2 * float(self.ac_conf["sonicspeed"])
+      x = (float(self.ac_conf["sensor_distance"])**2 - distance_right**2 + distance_left**2) / (2*float(self.ac_conf["sensor_distance"])) + float(self.ac_conf["left_x_offset"])
+      y = math.sqrt(abs(distance_left**2 - x**2)) + float(self.ac_conf["y_offset"])
       return(x,y)
     except Exception as e:
       print(values)