git.maemo.org Git - pedometerwidget/blob - pedometer_widget_home.py~

   1 import gtk
   2 import hildondesktop
   3
   4 #from pedometer import *
   5
   6 class HelloWorldDialog(gtk.Dialog):
   7     def __init__(self):
   8         gtk.Dialog.__init__(self, "Hello World", None,
   9                             gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_NO_SEPARATOR,
  10                             ("Close", gtk.RESPONSE_OK))
  11         self.vbox.add(gtk.Label("Hello World!"))
  12         self.show_all()
  13
  14 def hello_world_dialog_show(button):
  15     dialog = HelloWorldDialog()
  16     dialog.run()
  17     dialog.destroy()
  18
  19 class PedometerHomePlugin(hildondesktop.HomePluginItem):
  20     button = None
  21     loader = None
  22     labelLastCount = None
  23     labelTotalCount = None
  24     labelDistance = None
  25
  26     pedometer = None
  27
  28     def __init__(self):
  29
  30          gtk.gdk.threads_init()
  31         hildondesktop.HomePluginItem.__init__(self)
  32         button = gtk.Button("Start")
  33         button.connect("clicked", self.button_clicked)
  34
  35         self.labelLastCount = gtk.Label("--")
  36         self.labelTotalCount = gtk.Label("--")
  37         self.labelDistance = gtk.Label("--")
  38
  39         mainVBox = gtk.VBox(spacing=1)
  40         mainVBox.add(button)
  41         mainVBox.add(self.labelLastCount)
  42         mainVBox.add(self.labelTotalCount)
  43         mainVBox.add(self.labelDistance)
  44
  45         mainVBox.show_all()
  46         self.add(mainVBox)
  47
  48         self.pedometer = PedoCounter(self.update_values)
  49
  50     def update_values(self, total, lastInterval):
  51
  52         print "update"
  53
  54         dist = self.pedometer.get_distance()
  55
  56         self.labelLastCount.set_label(str(lastInterval))
  57         self.labelTotalCount.set_label(str(total))
  58         self.labelDistance.set_label(str(dist))
  59
  60     def button_clicked(self, button):
  61         print "button clicked"
  62         self.labelLastCount.set_label("updating")
  63         self.labelTotalCount.set_label("updating")
  64         self.labelDistance.set_label("updating")
  65
  66         self.pedometer.start()
  67         print "button clicked finished"
  68
  69
  70 hd_plugin_type = PedometerHomePlugin
  71
  72
  73 # The code below is just for testing purposes.
  74 # It allows to run the widget as a standalone process.
  75 if __name__ == "__main__":
  76     import gobject
  77     gobject.type_register(hd_plugin_type)
  78     obj = gobject.new(hd_plugin_type, plugin_id="plugin_id")
  79     obj.show_all()
  80     gtk.main()
  81
  82
  83
  84 ############### old pedometer.py ###
  85 import math
  86 import time
  87 import logging
  88 import gobject
  89
  90 from threading import Thread
  91
  92 logger = logging.getLogger("pedometer")
  93 logger.setLevel(logging.INFO)
  94
  95 ch = logging.StreamHandler()
  96 formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
  97 ch.setFormatter(formatter)
  98 logger.addHandler(ch)
  99
 100
 101 class PedoIntervalCounter:
 102     MIN_THRESHOLD = 500
 103     MIN_TIME_STEPS = 0.5
 104     x = []
 105     y = []
 106     z = []
 107     t = []
 108
 109     #TODO: check if last detected step is at the end of the interval
 110
 111     def __init__(self, coords, tval):
 112         self.x = coords[0]
 113         self.y = coords[1]
 114         self.z = coords[2]
 115         self.t = tval
 116
 117     def calc_mean(self, vals):
 118         sum = 0
 119         for i in vals:
 120             sum+=i
 121         if len(vals) > 0:
 122             return sum / len(vals)
 123         return 0
 124
 125     def calc_stdev(self, vals):
 126         rez = 0
 127         mean = self.calc_mean(vals)
 128         for i in vals:
 129             rez+=pow(abs(mean-i),2)
 130         return math.sqrt(rez/len(vals))
 131
 132     def calc_threshold(self, vals):
 133         vmax = max(vals)
 134         vmin = min(vals)
 135         mean = self.calc_mean(vals)
 136         threshold = max (abs(mean-vmax), abs(mean-vmin))
 137         return threshold
 138
 139     def count_steps(self, vals, t):
 140         threshold = self.MIN_THRESHOLD
 141         mean = self.calc_mean(vals)
 142         cnt = 0
 143
 144         i=0
 145         while i < len(vals):
 146             if abs(vals[i] - mean) > threshold:
 147                 cnt+=1
 148                 ntime = t[i] + 0.5
 149                 while i < len(vals) and t[i] < ntime:
 150                     i+=1
 151             i+=1
 152         return cnt
 153
 154     def get_best_values(self, x, y, z):
 155         dev1 = self.calc_stdev(x)
 156         dev2 = self.calc_stdev(y)
 157         dev3 = self.calc_stdev(z)
 158         dev_max = max(dev1, dev2, dev3)
 159
 160         if ( abs(dev1 - dev_max ) < 0.001):
 161             logger.info("X chosen as best axis, stdev %f" % dev1)
 162             return x
 163         elif (abs(dev2 - dev_max) < 0.001):
 164             logger.info("Y chosen as best axis, stdev %f" % dev2)
 165             return y
 166         else:
 167             logger.info("Z chosen as best axis, stdev %f" % dev3)
 168             return z
 169
 170     def number_steps(self):
 171         vals = self.get_best_values(self.x, self.y, self.z)
 172         return self.count_steps(vals, self.t)
 173
 174 class PedoCounter(Thread):
 175     COORD_FNAME = "/sys/class/i2c-adapter/i2c-3/3-001d/coord"
 176     COORD_GET_INTERVAL = 0.01
 177     COUNT_INTERVAL = 5
 178     STEP_LENGTH = 0.5
 179
 180     counter = 0
 181     update_function = None
 182
 183     def __init__(self, update_function = None):
 184         Thread.__init__(self)
 185         self.update_function = update_function
 186
 187     def get_rotation(self):
 188         f = open(self.COORD_FNAME, 'r')
 189         coords = [int(w) for w in f.readline().split()]
 190         f.close()
 191         return coords
 192
 193     def reset_counter(self):
 194         counter = 0
 195
 196     def get_counter(self):
 197         return counter
 198
 199     def start_interval(self):
 200         logger.info("New interval started")
 201         stime = time.time()
 202         t=[]
 203         coords = [[], [], []]
 204         while len(t) == 0 or t[-1] < 5:
 205             x,y,z = self.get_rotation()
 206             coords[0].append(int(x))
 207             coords[1].append(int(y))
 208             coords[2].append(int(z))
 209             now = time.time()-stime
 210             t.append(now)
 211             time.sleep(self.COORD_GET_INTERVAL)
 212         pic = PedoIntervalCounter(coords, t)
 213         cnt = pic.number_steps()
 214
 215         logger.info("Number of steps detected for last interval %d, number of coords: %d" % (cnt, len(t)))
 216
 217         self.counter += cnt
 218         logger.info("Total number of steps : %d" % self.counter)
 219         return cnt
 220
 221     def run(self):
 222         while 1:
 223             last_cnt = self.start_interval()
 224             if self.update_function is not None:
 225                 gobject.idle_add(self.update_function, self.counter, last_cnt)
 226
 227     def get_distance(self, steps=None):
 228         if steps == None:
 229             steps = self.counter
 230         return self.STEP_LENGTH * steps;
 231
 232