def __init__(self):
#print "BGReadings_Data initialisiert"
self._id = 0
self.timestamp = 0
self.DateTime = ''
self.bg = 0
self.raw_value = 0
self.raw_timestamp = 0
self.age_adjusted_raw_value = 0
self.filtered_value = 0
self.sensor_age_at_time_of_estimation = 0
self.possible_bad = False
self.slope = 0
self.intercept = 0
self.sensor_confidence = 0
self.uploaded = 0
self.a = 0
self.b = 0
self.c = 0
self.ra = 0
self.rb = 0
self.rc = 0
self.calculated_value = 0
# print "Klasse BGReadings wurde erzeugt"
if sensor.SensorisActive():
SensorData = sensor.currentSensor()
self.sensor = SensorData['_id']
else:
print "Kein Aktiver Sensor vorhanden "
def __init__(self): #print "BGReadings_Data initialisiert" self._id=0 self.timestamp=0 self.DateTime='' self.bg=0 self.raw_value=0 self.raw_timestamp=0 self.age_adjusted_raw_value=0 self.filtered_value=0 self.sensor_age_at_time_of_estimation=0 self.possible_bad=False self.slope=0 self.intercept=0 self.sensor_confidence=0 self.uploaded=0 self.a=0 self.b=0 self.c=0 self.ra=0 self.rb=0 self.rc=0 self.calculated_value=0 # print "Klasse BGReadings wurde erzeugt" if sensor.SensorisActive(): SensorData=sensor.currentSensor() self.sensor=SensorData['_id'] else: print "Kein Aktiver Sensor vorhanden "
def oldinsertIntoWixeldata_(data) :
if sensor.SensorisActive():
CurSensor=sensor.currentSensor()
print "CurSensor->" + str(CurSensor['started_at'])
TimeDelta=((long(data['CaptureDateTime'])-long(CurSensor['started_at']))*1.0)/1000/60/60
Adjusted_raw=xdriplib.calculateAgeAdjustedRawValue(TimeDelta,int(data['RawValue']))
print "BGReadings AgeAdjustedRaw -> " + str(Adjusted_raw)
Adjusted_raw=xdriplib.calculateAgeAdjustedRawValue(TimeDelta,int(data['RawValue']))
else:
print "No Sensor Active"
Adjusted_raw=0
conn = sqlite3.connect(db.openapsDBName)
sql='insert into ' + db.tableNameWixeldata
sql+='(TransmitterId, CaptureDateTime, RelativeTime, ReceivedSignalStrength, RawValue, TransmissionId, BatteryLife, UploadAttempts, Uploaded, UploaderBatteryLife, FilteredValue, age_adjusted_raw_value ) VALUES ('
sql+=" '" + str(data['TransmitterId']) + "'"
sql+=', ' + str(data['CaptureDateTime'])
sql+=', ' + str(data['RelativeTime'])
sql+=', ' + str(data['ReceivedSignalStrength'])
sql+=', ' + str(data['RawValue'])
sql+=', ' + str(data['TransmissionId'])
sql+=', ' + str(data['BatteryLife'])
sql+=', ' + str(data['UploadAttempts'])
sql+=', ' + str(data['Uploaded'])
sql+=', ' + str(data['UploaderBatteryLife'])
sql+=', ' + str(Adjusted_raw)
sql+=', ' + str(data['FilteredValue']) + ' )'
#print "(BGReadings)(insertIntoWixel) SQL->" + sql
conn.execute(sql)
conn.commit()
print "Records created successfully";
conn.close()
def __init__(self): self._id=0 self.uuid='uid' self.sensor_uuid='SensorUID' self.timestamp=0 self.sensor_age_at_time_of_estimation=0 self.sensorid=0 self.SensorData=sensor.SensorData self.bg=0 self.filtered_value=0 self.raw_timestamp=0 self.raw_value=0 self.age_adjusted_raw_value=0 self.sensor_confidence=0 self.slope_confidence=0 self.slope=0 self.intercept=0 self.distance_from_estimate=0 self.estimate_raw_at_time_of_calibration=0 self.estimate_bg_at_time_of_calibration=0 self.possible_bad=False self.first_decay=0 self.second_decay=0 self.first_slope=0 self.second_slope=0 self.first_intercept=0 self.second_intercept=0 self.first_scale=0 self.second_scale=0 self.check_in=False self.uploaded=0 #print "Klasse " + " wurde erzeugt" if sensor.SensorisActive(): SensorData=sensor.currentSensor() self.sensorid=SensorData['_id'] #print "Aktiver Sensor vorhanden _id->" + str(self.sensor) else: print "Kein Aktiver Sensor vorhanden "
def __init__(self):
self._id = 0
self.uuid = 'uid'
self.sensor_uuid = 'SensorUID'
self.timestamp = 0
self.sensor_age_at_time_of_estimation = 0
self.sensorid = 0
self.SensorData = sensor.SensorData
self.bg = 0
self.filtered_value = 0
self.raw_timestamp = 0
self.raw_value = 0
self.age_adjusted_raw_value = 0
self.sensor_confidence = 0
self.slope_confidence = 0
self.slope = 0
self.intercept = 0
self.distance_from_estimate = 0
self.estimate_raw_at_time_of_calibration = 0
self.estimate_bg_at_time_of_calibration = 0
self.possible_bad = False
self.first_decay = 0
self.second_decay = 0
self.first_slope = 0
self.second_slope = 0
self.first_intercept = 0
self.second_intercept = 0
self.first_scale = 0
self.second_scale = 0
self.check_in = False
self.uploaded = 0
#print "Klasse " + " wurde erzeugt"
if sensor.SensorisActive():
SensorData = sensor.currentSensor()
self.sensorid = SensorData['_id']
#print "Aktiver Sensor vorhanden _id->" + str(self.sensor)
else:
print "Kein Aktiver Sensor vorhanden "
def oldinsertIntoWixeldata_(data):
if sensor.SensorisActive():
CurSensor = sensor.currentSensor()
print "CurSensor->" + str(CurSensor['started_at'])
TimeDelta = (
(long(data['CaptureDateTime']) - long(CurSensor['started_at'])) *
1.0) / 1000 / 60 / 60
Adjusted_raw = xdriplib.calculateAgeAdjustedRawValue(
TimeDelta, int(data['RawValue']))
print "BGReadings AgeAdjustedRaw -> " + str(Adjusted_raw)
Adjusted_raw = xdriplib.calculateAgeAdjustedRawValue(
TimeDelta, int(data['RawValue']))
else:
print "No Sensor Active"
Adjusted_raw = 0
conn = sqlite3.connect(db.openapsDBName)
sql = 'insert into ' + db.tableNameWixeldata
sql += '(TransmitterId, CaptureDateTime, RelativeTime, ReceivedSignalStrength, RawValue, TransmissionId, BatteryLife, UploadAttempts, Uploaded, UploaderBatteryLife, FilteredValue, age_adjusted_raw_value ) VALUES ('
sql += " '" + str(data['TransmitterId']) + "'"
sql += ', ' + str(data['CaptureDateTime'])
sql += ', ' + str(data['RelativeTime'])
sql += ', ' + str(data['ReceivedSignalStrength'])
sql += ', ' + str(data['RawValue'])
sql += ', ' + str(data['TransmissionId'])
sql += ', ' + str(data['BatteryLife'])
sql += ', ' + str(data['UploadAttempts'])
sql += ', ' + str(data['Uploaded'])
sql += ', ' + str(data['UploaderBatteryLife'])
sql += ', ' + str(Adjusted_raw)
sql += ', ' + str(data['FilteredValue']) + ' )'
#print "(BGReadings)(insertIntoWixel) SQL->" + sql
conn.execute(sql)
conn.commit()
print "Records created successfully"
conn.close()
import os from thread import * from struct import * import serial import Adafruit_GPIO.SPI as SPI import Adafruit_SSD1306 import Image import ImageFont import ImageDraw import wixellib import xdriplib import BGReadings import db import sensor from calibration import * db.initDB() ID=sensor.StartSensor() if sensor.SensorisActive(): CurSensor=sensor.currentSensor()
#!/usr/bin/python
import json
import socket
import sys
import time
import os
from thread import *
from struct import *
import serial
import wixellib
import xdriplib
import BGReadings
import db
import sensor
from calibration import *
db.initDB()
sensor.StopSensor()
if sensor.SensorisActive():
CurSensor = sensor.currentSensor()
def initialCalibration(bg1, bg2):
# calib = calibration_Data()
# calib.clear_all_existing_calibrations()
higherCalibration = calibration_Data()
lowerCalibration = calibration_Data()
sens = sensor.currentSensor()
higher_bg = max(bg1, bg2)
lower_bg = min(bg1, bg2)
BgReading1 = BGReadings_Data()
BgReading1.getlatest()
BgReading2 = BGReadings_Data()
BgReading2.getsecondlatest()
if BgReading2.raw_value == None:
print "(initialCalibration) Hmm benoetige ersteinmal 2 BG Readings"
return False
if BgReading1.raw_value > BgReading2.raw_value:
highBgReading = BGReadings_Data()
highBgReading.getlatest()
lowBgReading = BGReadings_Data()
lowBgReading.getsecondlatest()
else:
highBgReading = BGReadings_Data()
highBgReading.getsecondlatest()
lowBgReading = BGReadings_Data()
lowBgReading.getlatest()
print "highBgReading.raw_value -> " + str(highBgReading.raw_value)
print "lowBgReading.raw_value -> " + str(lowBgReading.raw_value)
higherCalibration.bg = higher_bg
higherCalibration.slope = 1
higherCalibration.intercept = higher_bg
print "cal high intercept " + str(higherCalibration.intercept)
print "cal high adjraw " + str(highBgReading.age_adjusted_raw_value)
print "cal high higherbg " + str(higher_bg)
higherCalibration.sensor = sens
higherCalibration.estimate_raw_at_time_of_calibration = highBgReading.age_adjusted_raw_value
higherCalibration.age_adjusted_raw_value = highBgReading.age_adjusted_raw_value
higherCalibration.raw_value = highBgReading.raw_value
higherCalibration.raw_timestamp = highBgReading.raw_timestamp
higherCalibration.save()
highBgReading.bg = higher_bg
highBgReading.calibration_flag = True
highBgReading.calibration = higherCalibration
higherCalibration.save()
lowerCalibration.bg = lower_bg
lowerCalibration.slope = 1
lowerCalibration.intercept = lower_bg
print "cal low intercept " + str(lowerCalibration.intercept)
print "cal low adjraw " + str(lowBgReading.age_adjusted_raw_value)
print "cal low higherbg " + str(lower_bg)
lowerCalibration.sensor = sens
lowerCalibration.estimate_raw_at_time_of_calibration = lowBgReading.age_adjusted_raw_value
lowerCalibration.age_adjusted_raw_value = lowBgReading.age_adjusted_raw_value
lowerCalibration.raw_value = lowBgReading.raw_value
lowerCalibration.raw_timestamp = lowBgReading.raw_timestamp
lowBgReading.bg = lower_bg
lowBgReading.calibration_flag = True
lowBgReading.calibration = lowerCalibration
lowerCalibration.save()
# lowBgReading.timestamp=long(str(int(time.time()))+"000")
lowBgReading.sensor_uuid = "Sensor_uuid"
lowBgReading.slope_confidence = 0.5
lowBgReading.distance_from_estimate = 0
lowBgReading.check_in = False
lowBgReading.sensor_confidence = (
(-0.0018 * lowBgReading.bg * lowBgReading.bg) + (0.6657 * lowBgReading.bg) + 36.7505
) / 100
lowBgReading.sensor_age_at_time_of_estimation = lowBgReading.timestamp - sens["started_at"]
lowBgReading.uuid = "randomUUID"
lowBgReading.write2db()
# highBgReading.timestamp=long(str(int(time.time()))+"000")
highBgReading.sensor_uuid = "Sensor_uuid"
highBgReading.slope_confidence = 0.5
highBgReading.distance_from_estimate = 0
highBgReading.check_in = False
highBgReading.sensor_confidence = (
(-0.0018 * highBgReading.bg * highBgReading.bg) + (0.6657 * highBgReading.bg) + 36.7505
) / 100
highBgReading.sensor_age_at_time_of_estimation = highBgReading.timestamp - sens["started_at"]
highBgReading.uuid = "randomUUID"
highBgReading.write2db()
find_new_curve()
find_new_raw_curve()
# highBgReading.find_new_raw_curve();
# lowBgReading.find_new_curve();
# lowBgReading.find_new_raw_curve();
lowerCalibration.timestamp = long(str(int(time.time())) + "000")
lowerCalibration.sensor_uuid = sens["uuid"]
lowerCalibration.slope_confidence = 0.5
lowerCalibration.distance_from_estimate = 0
lowerCalibration.check_in = False
lowerCalibration.sensor_confidence = (
(-0.0018 * lowerCalibration.bg * lowerCalibration.bg) + (0.6657 * lowerCalibration.bg) + 36.7505
) / 100
lowerCalibration.sensor_age_at_time_of_estimation = lowerCalibration.timestamp - sens["started_at"]
lowerCalibration.uuid = "CALIBRATION UUID"
# lowerCalibration.calculate_w_l_s()
lowerCalibration.save()
higherCalibration.timestamp = long(str(int(time.time())) + "000")
higherCalibration.sensor_uuid = sens["uuid"]
higherCalibration.slope_confidence = 0.5
higherCalibration.distance_from_estimate = 0
higherCalibration.check_in = False
higherCalibration.sensor_confidence = (
(-0.0018 * higherCalibration.bg * higherCalibration.bg) + (0.6657 * higherCalibration.bg) + 36.7505
) / 100
higherCalibration.sensor_age_at_time_of_estimation = higherCalibration.timestamp - sens["started_at"]
higherCalibration.uuid = "CALIBRATION UUID"
higherCalibration.save()
calculate_w_l_s()
def create(bg):
calibration = calibration_Data()
# sens = sensor();
bgReading = BGReadings_Data()
bgReadingsec = BGReadings_Data()
if sensor.SensorisActive():
sens = sensor.currentSensor()
bgReading.getlatest()
bgReadingsec.getsecondlatest()
if bgReading._id <> 0:
calibration.sensor = sensor
calibration.bg = bg
calibration.check_in = False
calibration.timestamp = long(str(int(time.time())) + "000")
calibration.raw_value = bgReading.raw_value
calibration.age_adjusted_raw_value = bgReading.age_adjusted_raw_value
calibration.sensor_uuid = "Sensor_uuid"
print "(create) bgReading.bg -> " + str(bgReading.bg)
print "(create) bgReadingsec.bg -> " + str(bgReadingsec.bg)
print "(create) abs(bgReading.bg - bgReadingsec.bg) -> " + str(abs(bgReading.bg - bgReadingsec.bg))
calibration.slope_confidence = min(max(((4 - (abs(bgReading.bg - bgReadingsec.bg) * 60000)) / 4), 0), 1)
print "(create) calibration.slope_confidence -> " + str(calibration.slope_confidence)
calibration.slope_confidence = (100 - abs(bgReading.bg - bgReadingsec.bg)) / 100
print "(create) calibration.slope_confidence -> " + str(calibration.slope_confidence)
estimated_raw_bg_value = estimated_raw_bg(long(str(int(time.time())) + "000"))
calibration.raw_timestamp = bgReading.timestamp
print "(create) estimated_raw_bg_value ->" + str(estimated_raw_bg_value)
print "(create) bgReading.age_adjusted_raw_value ->" + str(bgReading.age_adjusted_raw_value)
if abs(estimated_raw_bg_value - bgReading.age_adjusted_raw_value) > 20:
print "create(bg) bgReading.age_adjusted_raw_value ->" + str(bgReading.age_adjusted_raw_value)
calibration.estimate_raw_at_time_of_calibration = bgReading.age_adjusted_raw_value
else:
print "create(bg)estimated_raw_bg_value ->" + str(estimated_raw_bg_value)
calibration.estimate_raw_at_time_of_calibration = estimated_raw_bg_value
calibration.distance_from_estimate = abs(calibration.bg - bgReading.bg)
calibration.sensor_confidence = max(((-0.0018 * bg * bg) + (0.6657 * bg) + 36.7505) / 100, 0)
calibration.sensor_age_at_time_of_estimation = calibration.timestamp - sens["started_at"]
calibration.uuid = "CalUUI"
calibration.save()
bgReading.calibration = calibration
bgReading.calibration_flag = True
bgReading.write2db()
# BgSendQueue.handleNewBgReading(bgReading, "update", context);
calculate_w_l_s()
# adjustRecentBgReadings();
# CalibrationSendQueue.addToQueue(calibration, context);
# context.startService(new Intent(context, Notifications.class));
# Calibration.requestCalibrationIfRangeTooNarrow();
else:
print "CALIBRATION", "No sensor, cant save!"
def find_new_raw_curve():
CurSensor = sensor.currentSensor()
first_latest = BGReadings_Data()
first_latest.getlatest()
second_latest = BGReadings_Data()
second_latest.getsecondlatest()
third_latest = BGReadings_Data()
third_latest.getthirdlatest()
if third_latest.raw_value <> 0:
y3 = 1.0 * calculateAgeAdjustedRawValue(getTimeDelta(first_latest, CurSensor), first_latest.raw_value) / 1000
x3 = first_latest.timestamp
y2 = calculateAgeAdjustedRawValue(getTimeDelta(second_latest, CurSensor), second_latest.raw_value) / 1000
x2 = second_latest.timestamp
y1 = calculateAgeAdjustedRawValue(getTimeDelta(third_latest, CurSensor), third_latest.raw_value) / 1000
x1 = third_latest.timestamp
print "x1->" + str(x1) + ", y1->" + str(y1) + ", "
print "x2->" + str(x2) + ", y2->" + str(y2) + ", "
print "x3->" + str(x3) + ", y3->" + str(y3) + ", "
first_latest.ra = y1 / ((x1 - x2) * (x1 - x3)) + y2 / ((x2 - x1) * (x2 - x3)) + y3 / ((x3 - x1) * (x3 - x2))
first_latest.rb = (
-y1 * (x2 + x3) / ((x1 - x2) * (x1 - x3))
- y2 * (x1 + x3) / ((x2 - x1) * (x2 - x3))
- y3 * (x1 + x2) / ((x3 - x1) * (x3 - x2))
)
first_latest.rc = (
y1 * x2 * x3 / ((x1 - x2) * (x1 - x3))
+ y2 * x1 * x3 / ((x2 - x1) * (x2 - x3))
+ y3 * x1 * x2 / ((x3 - x1) * (x3 - x2))
)
print "RAW PARABOLIC RATES: " + str(first_latest.ra) + "x^2 + " + str(first_latest.rb) + "x + " + str(
first_latest.rc
)
first_latest.write2db()
elif second_latest.raw_value <> 0:
y2 = calculateAgeAdjustedRawValue(getTimeDelta(first_latest, CurSensor), first_latest.raw_value)
x2 = first_latest.timestamp
y1 = calculateAgeAdjustedRawValue(getTimeDelta(second_latest, CurSensor), second_latest.raw_value)
x1 = second_latest.timestamp
if y1 == y2:
first_latest.rb = 0
else:
first_latest.rb = (y2 - y1) / (x2 - x1)
first_latest.ra = 0
first_latest.rc = -1 * ((first_latest.rb * x1) - y1)
print "Not enough data to calculate parabolic rates - assume Linear data"
print "RAW PARABOLIC RATES: " + str(first_latest.ra) + "x^2 + " + str(first_latest.rb) + "x + " + str(
first_latest.rc
)
first_latest.write2db()
else:
first_latest.ra = 0
first_latest.rb = 0
first_latest.rc = first_latest.age_adjusted_raw_value
print "Not enough data to calculate parabolic rates - assume static data"
print "RAW PARABOLIC RATES: " + str(first_latest.ra) + "x^2 + " + str(first_latest.rb) + "x + " + str(
first_latest.rc
)
first_latest.write2db()
