Refactored

eval_records.py

@@ -23,7 +23,7 @@ def has_diff_entries(diff):
 	return handled
 
 
-def convert(_filename: str) -> int:
+def convert(_filename: str) -> float:
 	name = _filename
 	if "records_" in _filename:
 		name = os.path.splitext(_filename)[0].split("_")[1]
@@ -34,15 +34,12 @@ def convert(_filename: str) -> int:
 
 	timestamp_str = f"{date_str}T{time_str}"
 	ts = dup.parse(timestamp_str)
-	result = ts.year
-	result = 100*result + ts.month
-	result = 100*result + ts.day
-	result = 100*result + ts.hour
-	result = 100*result + ts.minute
-	result = 100*result + ts.second
-	result = 1000000*result + ts.microsecond
+	return datetime_to_int(ts)
 
-	return int(result)
+
+def datetime_to_int(_dt: datetime) -> float:
+	result = datetime.timestamp(_dt)
+	return result
 
 
 class Endpoint:
@@ -195,13 +192,46 @@ def find_ep_by_name(end_points: list[Endpoint], name: str):
 	return None
 
 
-def process_events(_ep_dict: dict, ts_from: datetime, ts_to: datetime, ts_step: timedelta):
-	for ep_key in _ep_dict:
-		for ep in _ep_dict[ep_key]:
-			now = ts_from
-			while now < ts_to:
-				print(f"Date/time: {now}")
-				now += ts_step
+def fast_forward(iter_t: iter, iter_v: iter, now):
+	try:
+		while True:
+			t = next(iter_t)
+			v = next(iter_v)
+			if t >= now:
+				return t, v
+	except StopIteration:
+		return None
+
+
+def resample(_ep: Endpoint, dt_from: datetime, dt_stop: datetime, dt_step: timedelta):
+	iter_t = iter(_ep.timestamps)
+	iter_v = iter(_ep.values)
+
+	t = []
+	v = []
+	_t_next = next(iter_t)
+	_v_next = next(iter_v)
+	_dt = dt_from
+	_ts_stop = datetime_to_int(dt_stop)
+	_ts = datetime_to_int(_dt)
+	fast_forward(iter_t, iter_v, _ts)
+	while _ts < _ts_stop:
+		print(f"Time : {_ts}")
+		print(f"Value: {_v_next}")
+		t.append(_ts)
+		v.append(_v_next)
+
+		try:
+			while _ts >= _t_next:
+				_t_next = next(iter_t)
+				_v_next = next(iter_v)
+		except StopIteration:
+			pass
+
+		_dt = _dt + dt_step
+		_ts = datetime.timestamp(_dt)
+
+	return t, v
 
 
 if __name__ == '__main__':
@@ -209,36 +239,51 @@ if __name__ == '__main__':
 	for k in settings.eps.keys():
 		end_points.append(Endpoint(k, settings.eps[k]))
 
+	# Process data and store into endpoints
 	process(end_points, settings.BASE, settings.USER, settings.VIN, sel_days=settings.sel_days)
 
-#	process_events(end_points, datetime(2024, 10, 25, 0, 0, 0), datetime(2024, 10, 26, 0, 0, 0), timedelta(hours=1))
-
-	speed = [0]
-	_speed = 0
+	# get endpoints
 	ep_odo = find_ep_by_name(end_points, name="odo")
 	ep_soc = find_ep_by_name(end_points, name="soc")
 	ep_range = find_ep_by_name(end_points, name="range")
 
-	for i in range(1, len(ep_odo.timestamps)):
-		dt = float(ep_odo.timestamps[i] - ep_odo.timestamps[i-1])/(60*100000000)
-		dv = ep_odo.values[i] - ep_odo.values[i-1]
-		_speed = 0.9*_speed + 0.1*dv/dt
-		speed.append(_speed)
+	# define observation interval
+	dt_start = datetime(2024, 10, 28, 0, 0, 0)
+	dt_stop = datetime(2024, 10, 28, 23, 59, 59)
+	td_step = timedelta(seconds=5*60)
 
+	# resample values to equidistant time interval
+	t_odo, v_odo = resample(ep_odo, dt_start, dt_stop, td_step)
+	t_soc, v_soc = resample(ep_soc, dt_start, dt_stop, td_step)
+	t_range, v_range = resample(ep_range, dt_start, dt_stop, td_step)
+
+	# calc speed
+	speed = [0]
+	for i in range(1, len(t_odo)):
+		dt = float(t_odo[i] - t_odo[i-1])
+		dv = v_odo[i] - v_odo[i-1]
+		speed.append(dv/dt*60*60)
+
+	# Convert x-axis
+	dt_odo_h = (np.array(t_odo) - t_odo[0])/3600
+	dt_soc_h = (np.array(t_soc) - t_soc[0])/3600
+	dt_range_h = (np.array(t_range) - t_range[0])/3600
+
+	# plot data
 	plot.subplot(4, 1, 1)
-	plot.plot(np.array(ep_odo.timestamps) - ep_odo.timestamps[0], np.array(ep_odo.values) - ep_odo.values[0])
+	plot.plot(dt_odo_h, np.array(v_odo) - v_odo[0])
 	plot.title("Kilometerstand")
 	plot.grid()
 	plot.subplot(4, 1, 2)
-	plot.plot(np.array(ep_odo.timestamps) - ep_odo.timestamps[0], speed)
+	plot.plot(dt_odo_h, speed)
 	plot.title("Speed")
 	plot.grid()
 	plot.subplot(4, 1, 3)
-	plot.plot(np.array(ep_soc.timestamps) - ep_soc.timestamps[0], ep_soc.values)
+	plot.plot(dt_soc_h, v_soc)
 	plot.title("Akkustand")
 	plot.grid()
 	plot.subplot(4, 1, 4)
-	plot.plot(np.array(ep_range.timestamps) - ep_range.timestamps[0], ep_range.values)
+	plot.plot(dt_range_h, v_range)
 	plot.title("Range")
 	plot.grid()