self.steps = steps
self.calories = calories
self.dist = dist
- self.unit = unit
def __add__(self, other):
return PedoValues(self.time + other.time,
return strtime
def get_print_distance(self):
+ global unit
if self.dist > 1000:
- if self.unit == 0:
+ if unit == 0:
return "%.2f km" % (self.dist / 1000)
else:
return "%.2f mi" % (self.dist / 1609.344)
else:
- if self.unit == 0:
+ if unit == 0:
return "%d m" % self.dist
else:
return "%d ft" % int(self.dist * 3.2808)
def get_avg_speed(self):
+ global unit
conv = 0
- if self.unit:
+ if unit:
conv = 2.23693629
else:
conv = 3.6
return speed * conv
def get_print_avg_speed(self):
+ global unit
suffix = ""
conv = 0
- if self.unit:
+ if unit:
suffix = "mi/h"
conv = 2.23693629
else:
return str(self.steps)
def get_print_calories(self):
- return str(self.calories)
+ return "%.2f" % self.calories
class PedoRepository(Singleton):
values = {}
def get_values(self):
return self.values
- def add_values(self, values, when=date.today()):
+ def add_values(self, values, when=None):
+ if when is None:
+ when = date.today()
"""add PedoValues values to repository """
try:
self.values[when] = self.values[when] + values
observers = []
+ midnight_set = False
+ midnight_source_id = None
+
def __init__(self):
self.pedometer = PedoCounter(self.steps_detected)
self.pedometerInterval = PedoIntervalCounter()
self.load_values()
+ if not self.midnight_set:
+ self.update_at_midnight()
+ self.midnight_set = True
+
+ def update_at_midnight(self):
+ next_day = date.today() + timedelta(days=1)
+ diff = time.mktime(next_day.timetuple()) - time.time()
+ diff = int(diff+5)
+ self.midnight_source_id = gobject.timeout_add_seconds(diff, self.midnight_callback, True)
+
+ def stop_midnight_callback(self):
+ if self.midnight_source_id is not None:
+ gobject.source_remove(self.midnight_source_id)
+
+ def midnight_callback(self, first=False):
+ self.load_values()
+ self.notify()
+ if first:
+ self.midnight_source_id = gobject.timeout_add_seconds(24*3600, self.midnight_callback)
+ return False
+ else:
+ return True
+
def load_values(self):
if self.second_view == 0:
self.v[1] = self.repository.get_alltime_values()
def reset_all_values(self):
self.repository.reset_values()
+ self.v[0] = PedoValues()
+ self.v[1] = PedoValues()
self.notify()
def stop_pedometer(self):
else:
self.v[0].steps += cnt
self.v[0].dist += self.get_distance(cnt)
- self.v[0].calories += self.get_distance(cnt)
+ self.v[0].calories += self.get_calories(self.get_distance(cnt))
self.v[0].time += time.time() - self.last_time
if last_steps:
self.save_values()
self.notify(True)
self.last_time = time.time()
+ def get_calories(self, distance):
+ """calculate lost calories for the distance and weight given as parameters
+ """
+ #different coefficient for running and walking
+ if self.mode == 0:
+ coef = 0.53
+ else:
+ coef = 0.75
+
+ #convert distance from meters to miles
+ distance *= 0.000621371192
+
+ weight = self.weight
+ #convert weight from kg to pounds
+ if self.unit == 0:
+ weight *= 2.20462262
+ return weight * distance * coef
+
def set_mode(self, mode):
self.mode = mode
self.set_height(self.height_interval)
+ self.pedometerInterval.set_mode(self.mode)
self.notify()
def set_unit(self, new_unit):
self.unit = new_unit
+ global unit
unit = new_unit
+ self.notify()
def get_str_weight_unit(self):
if self.unit == 0:
steps = self.counter
return self.STEP_LENGTH * steps;
- def get_calories(self, steps):
- return steps
-
def add_observer(self, func):
try:
self.observers.index(func)
def __init__(self):
self.client = gconf.client_get_default()
- try:
- self.enable = self.client.get_bool(ALARM_ENABLE)
- self.fname = self.client.get_string(ALARM_FNAME)
- self.interval = self.client.get_int(ALARM_INTERVAL)
- self.type = self.client.get_int(ALARM_TYPE)
- except:
- self.client.set_bool(ALARM_ENABLE, self.enable)
- self.client.set_string(ALARM_FNAME, self.fname)
- self.client.set_int(ALARM_INTERVAL, self.interval)
- self.client.set_int(ALARM_TYPE, self.type)
+
+ self.enable = self.client.get_bool(ALARM_ENABLE)
+ self.fname = self.client.get_string(ALARM_FNAME)
+ self.interval = self.client.get_int(ALARM_INTERVAL)
+ self.type = self.client.get_int(ALARM_TYPE)
self.pedo_controller = PedoController()
if self.enable:
COORD_FNAME_SDK = "/home/andrei/pedometer-widget-0.1/date.txt"
LOGFILE = "/home/user/log_pedometer"
#time in ms between two accelerometer data reads
- COORD_GET_INTERVAL = 10
+ COORD_GET_INTERVAL = 25
COUNT_INTERVAL = 5
second_view_labels = ["All-time", "Today", "This week"]
controller = None
- pedometer = None
- pedometerInterval = None
graph_controller = None
mode = 0
gobject.type_register(GraphWidget)
self.client = gconf.client_get_default()
- try:
- self.mode = self.client.get_int(MODE)
- self.height = self.client.get_int(HEIGHT)
- self.weight = self.client.get_int(WEIGHT)
- self.unit = self.client.get_int(UNIT)
- self.aspect = self.client.get_int(ASPECT)
- self.second_view = self.client.get_int(SECONDVIEW)
- self.graph_view = self.client.get_int(GRAPHVIEW)
- self.no_idle_time = self.client.get_bool(NOIDLETIME)
- self.logging = self.client.get_bool(LOGGING)
- except:
- self.client.set_int(MODE, 0)
- self.client.set_int(HEIGHT, 0)
- self.client.set_int(UNIT, 0)
- self.client.set_int(ASPECT, 0)
- self.client.set_int(SECONDVIEW, 0)
- self.client.set_int(GRAPHVIEW, 0)
- self.client.set_bool(NOIDLETIME, False)
- self.client.set_bool(LOGGING, False)
+ self.mode = self.client.get_int(MODE)
+ self.height = self.client.get_int(HEIGHT)
+ self.weight = self.client.get_int(WEIGHT)
+ self.unit = self.client.get_int(UNIT)
+ self.aspect = self.client.get_int(ASPECT)
+ self.second_view = self.client.get_int(SECONDVIEW)
+ self.graph_view = self.client.get_int(GRAPHVIEW)
+ self.no_idle_time = self.client.get_bool(NOIDLETIME)
+ self.logging = self.client.get_bool(LOGGING)
self.controller = PedoController()
self.controller.set_height(self.height)
widget.controller.set_mode(widget.mode)
def selectorH_changed(selector, data):
- widget.height = selectorH.get_active(0)
+ widget.height = selector.get_active(0)
widget.client.set_int(HEIGHT, widget.height)
widget.controller.set_height(widget.height)
def selectorUnit_changed(selector, data):
- widget.unit = selectorUnit.get_active(0)
+ widget.unit = selector.get_active(0)
widget.client.set_int(UNIT, widget.unit)
widget.controller.set_unit(widget.unit)
+ if widget.unit == 0:
+ self.heightPicker.set_active(widget.height)
+ self.heightPicker.show()
+ self.heightPicker_English.hide()
+ else:
+ self.heightPicker_English.set_active(widget.height)
+ self.heightPicker_English.show()
+ self.heightPicker.hide()
+
+ update_weight_button()
+
def selectorUI_changed(selector, data):
widget.aspect = selectorUI.get_active(0)
widget.client.set_int(ASPECT, widget.aspect)
widget.client.set_bool(NOIDLETIME, widget.no_idle_time)
widget.controller.set_no_idle_time(widget.no_idle_time)
+ def update_weight_button():
+ weightButton.set_value(str(self.controller.get_weight()) + \
+ " " + self.controller.get_str_weight_unit() )
+
def weight_dialog(button):
dialog = gtk.Dialog("Weight", self.dialog)
dialog.add_button("OK", gtk.RESPONSE_OK)
raise ValueError
self.controller.set_weight(value)
self.client.set_int(WEIGHT, value)
- weightButton.set_value(str(self.controller.get_weight()) + \
- " " + self.controller.get_str_weight_unit() )
+ update_weight_button()
break
except:
hildon.hildon_banner_show_information(self, "None", "Invalid weight")
selectorH.append_text(" > 1.95 m")
selectorH.connect("changed", selectorH_changed)
+ selectorH_English = hildon.TouchSelector(text=True)
+ selectorH_English.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE)
+ selectorH_English.append_text("< 5 ft")
+ selectorH_English.append_text("5 - 5.5 ft")
+ selectorH_English.append_text("5.5 - 6 ft")
+ selectorH_English.append_text("6 - 6.5 ft")
+ selectorH_English.append_text("> 6.5 ft")
+ selectorH_English.connect("changed", selectorH_changed)
+
heightPicker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
heightPicker.set_alignment(0.0, 0.5, 1.0, 1.0)
heightPicker.set_title("Height")
heightPicker.set_selector(selectorH)
heightPicker.set_active(widget.height)
+ heightPicker_English = hildon.PickerButton(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ heightPicker_English.set_alignment(0.0, 0.5, 1.0, 1.0)
+ heightPicker_English.set_title("Height")
+ heightPicker_English.set_selector(selectorH_English)
+ heightPicker_English.set_active(widget.height)
+
+ self.heightPicker = heightPicker
+ self.heightPicker_English = heightPicker_English
+
weightButton = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
weightButton.set_title("Weight")
weightButton.set_alignment(0, 0.8, 1, 1)
vbox.add(alarmButton)
vbox.add(modePicker)
vbox.add(heightPicker)
+ vbox.add(heightPicker_English)
vbox.add(weightButton)
vbox.add(unitPicker)
vbox.add(UIPicker)
dialog.vbox.add(pan_area)
dialog.show_all()
+
+ if widget.unit == 0:
+ self.heightPicker_English.hide()
+ else:
+ self.heightPicker.hide()
+
response = dialog.run()
#hildon.hildon_banner_show_information(self, "None", "You have to Stop/Start the counter to apply the new settings")
dialog.destroy()
def close_requested(self, widget):
- if self.pedometer is None:
- return
-
- self.pedometer.request_stop()
+ if self.controller.is_running:
+ self.controller.stop_pedometer()
+ self.controller.stop_midnight_callback()
def update_values(self):
#TODO: do not update if the widget is not on the active desktop
else:
self.controller.start_pedometer()
self.button.set_icon(ICONSPATH + "stop.png")
+ hildon.hildon_banner_show_information(self, "None", "Keep the N900 in a pocket close to your hip for best results")
def do_expose_event(self, event):
cr = self.window.cairo_create()
projects / pedometerwidget / blobdiff