308 lines
11 KiB
Python
308 lines
11 KiB
Python
import kivy
|
|
from kivy.app import App
|
|
from kivy.clock import Clock
|
|
import kivy.core.image
|
|
from kivy.core.image import ImageData
|
|
from kivy.core.image.img_pil import ImageLoaderPIL
|
|
from kivy.core.image.img_pygame import ImageLoaderPygame
|
|
import kivy.graphics.texture
|
|
from kivy.graphics.texture import Texture
|
|
from kivy.logger import Logger
|
|
from kivy.properties import ListProperty, NumericProperty, ObjectProperty, StringProperty
|
|
from kivy.uix.boxlayout import BoxLayout
|
|
from kivy.uix.button import Button
|
|
from kivy.uix.dropdown import DropDown
|
|
from kivy.uix.floatlayout import FloatLayout
|
|
from kivy.uix.gridlayout import GridLayout
|
|
from kivy.uix.image import Image
|
|
from kivy.uix.label import Label
|
|
import kivy.lang
|
|
import numpy
|
|
import matplotlib
|
|
matplotlib.use('Agg')
|
|
import matplotlib.image
|
|
import matplotlib.pyplot
|
|
import pygame.image
|
|
import Queue
|
|
import StringIO
|
|
import temp_log
|
|
import threading
|
|
|
|
dataThread = None
|
|
dataThreadDataQueue = Queue.Queue()
|
|
dataThreadCommandQueue = Queue.Queue()
|
|
defaultSerialPort = '/dev/ttyACM0'
|
|
|
|
class MainApp(App):
|
|
|
|
def build(self):
|
|
#root = kivy.lang.Builder.load_file('./main.kv')
|
|
#Logger.debug('root from super: ' + str(root))
|
|
#Logger.debug(str(root.ids))
|
|
#children = root.ids
|
|
mainWindow = MainWindow()
|
|
#Logger.debug('mainWindow' + str(mainWindow))
|
|
#Logger.debug(str(mainWindow.ids))
|
|
#children = mainWindow.children[:]
|
|
#while children:
|
|
# child = children.pop()
|
|
# children.extend(child.children)
|
|
# id = getattr(child, 'id', 'no id')
|
|
# if id is None:
|
|
# id = 'no id'
|
|
# Logger.debug(id + ' : ' + str(child))
|
|
# Logger.debug(str(child.ids))
|
|
Clock.schedule_interval(mainWindow.update, 0.25)
|
|
return mainWindow
|
|
|
|
|
|
def on_stop(self):
|
|
global dataThreadCommandQueue
|
|
dataThreadCommandQueue.put_nowait('stop')
|
|
|
|
|
|
def on_start(self):
|
|
global dataThread
|
|
dataThread.start()
|
|
|
|
|
|
class MainWindow(FloatLayout):
|
|
"""Main Window class"""
|
|
# @TODO fix on_X functions so they use specific bindings in the kv file rather than trying to call everything.
|
|
dataSource = StringProperty(defaultSerialPort)
|
|
dataSources = ListProperty(temp_log.list_serial_ports())
|
|
lastTemperature = NumericProperty(-1000.)
|
|
lastTime = NumericProperty(-1.)
|
|
recordingState = StringProperty('')
|
|
|
|
def __init__(self, **kwargs):
|
|
super(MainWindow, self).__init__(**kwargs)
|
|
# self.ids is available here; use it's references to connect bindings
|
|
Logger.debug('MainWindow IDs: ' + str(self.ids))
|
|
self.ids['serial_chooser_dropdown'].bind(on_serial_port_change=self.serial_port_changed)
|
|
|
|
|
|
def update_last_temperature(self):
|
|
global dataThreadDataQueue
|
|
# This breaks if there are more updates in the queue than the frequency of update_last_temperature - it pulls old data out of the queue, and not the most recent.
|
|
try:
|
|
data = dataThreadDataQueue.get_nowait()
|
|
if data is not None:
|
|
Logger.debug('Data: ' + str(data))
|
|
if 'data' in data and 'temperature' in data['data']:
|
|
self.lastTemperature = float(data['data']['temperature'])
|
|
if 'time' in data:
|
|
self.lastTime = float(data['time'])
|
|
except Queue.Empty:
|
|
pass
|
|
|
|
|
|
def on_lastTemperature(self, instance, value):
|
|
Logger.debug('lastTemperature has changed to: ' + str(value))
|
|
|
|
|
|
def on_lastTime(self, instance, value):
|
|
Logger.debug('lastTime has changed to: ' + str(value))
|
|
|
|
|
|
def update(self, dt):
|
|
self.update_data_sources()
|
|
self.update_last_temperature()
|
|
Logger.debug('MainWindow: dataThread ' + str(dataThread.name) + ' status: ' + str(dataThread.is_alive()))
|
|
|
|
|
|
def update_data_sources(self):
|
|
self.dataSources = temp_log.list_serial_ports()
|
|
|
|
|
|
def on_dataSources(self, instance, value):
|
|
Logger.debug('dataSources changed to: ' + str(self.dataSources))
|
|
children = self.children[:]
|
|
|
|
|
|
def serial_port_changed(self, *args):
|
|
Logger.debug('MainWindow: Received on_serial_port_changed: ' + str(args))
|
|
Logger.debug('MainWindow: Current dataSource: ' + str(self.dataSource))
|
|
if args:
|
|
new_port = args[0]
|
|
if new_port == self.dataSource:
|
|
Logger.debug('MainWindow: Selected port matches current port, no change')
|
|
else:
|
|
self.dataSource = new_port
|
|
|
|
|
|
def on_dataSource(self, instance, value):
|
|
# Stop the current data thread, if any.
|
|
Logger.debug('MainWindow: stopping dataThread')
|
|
global dataThread, dataThreadDataQueue, dataThreadCommandQueue
|
|
dataThreadCommandQueue.put('stop')
|
|
# This could cause the UI to hang until the thread is joined, if ever.
|
|
dataThread.join()
|
|
# Start a new data thread using the selected data source
|
|
if value:
|
|
Logger.debug('MainWindow: Starting new data thread on ' + str(value))
|
|
# For some reason it seems necessary to create new Queue objects.
|
|
dataThreadCommandQueue = Queue.Queue()
|
|
dataThreadDataQueue = Queue.Queue()
|
|
dataThread = threading.Thread(None, temp_log.threaded_reader, None, [value, dataThreadDataQueue, dataThreadCommandQueue])
|
|
dataThread.start()
|
|
|
|
|
|
class SerialPortButton(Button):
|
|
|
|
currentSerialPort = StringProperty('')
|
|
|
|
def __init__(self, **kwargs):
|
|
super(SerialPortButton, self).__init__(**kwargs)
|
|
self.text = '/dev/ttyACM0'
|
|
|
|
|
|
def serial_port_selected(self, *args):
|
|
Logger.debug('SerialPortButton serial_port_selected:' + str(args))
|
|
if args:
|
|
if args[0]:
|
|
self.text = args[0]
|
|
else:
|
|
self.text = 'No serial port selected!'
|
|
|
|
|
|
class SerialPortDropdown(DropDown):
|
|
|
|
__events__ = ('on_serial_port_changed',)
|
|
|
|
def __init__(self, **kwargs):
|
|
super(SerialPortDropdown, self).__init__(**kwargs)
|
|
self.register_event_type('on_serial_port_changed')
|
|
self.size_hint = (None, None)
|
|
Logger.debug(str(self.get_root_window()))
|
|
self.on_dataSources(temp_log.list_serial_ports())
|
|
|
|
|
|
def on_dataSources(self, values):
|
|
children = self.children[:]
|
|
values_used = []
|
|
current_value = getattr(self.parent, 'text', None)
|
|
while children:
|
|
child = children.pop()
|
|
children.extend(child.children)
|
|
text = getattr(child, 'text', None)
|
|
if text and text in values:
|
|
values_used.append(text)
|
|
Logger.debug('Child ' + str(child) + ' is used')
|
|
continue
|
|
if text and text not in values:
|
|
Logger.debug('Child ' + str(child) + ' is now unused, to be removed')
|
|
self.remove_widget(child)
|
|
self.data = ''
|
|
self.dispatch('on_serial_port_changed', '')
|
|
# add in new children
|
|
new_values = set(values) - set(values_used)
|
|
for new_value in new_values:
|
|
btn = Button(text = new_value, size_hint_y = None, height = 20)
|
|
Logger.debug('Child ' + str(btn) + ' added to dropdown with value ' + new_value)
|
|
btn.bind(on_release=lambda btn: self.select(btn.text))
|
|
self.add_widget(btn)
|
|
|
|
|
|
def select(self, value):
|
|
super(SerialPortDropdown, self).select(value)
|
|
Logger.debug('SerialPortDropdown: ' + 'selected with args ' + str(value))
|
|
self.data = value
|
|
self.dispatch('on_serial_port_changed', value)
|
|
|
|
|
|
def on_serial_port_changed(self, *args):
|
|
pass
|
|
|
|
|
|
class MyLabel(Label):
|
|
|
|
|
|
def __init__(self, **kwargs):
|
|
super(MyLabel, self).__init__(**kwargs)
|
|
|
|
|
|
def on_temperature_change(self, value):
|
|
if not value:
|
|
value = 'n/a'
|
|
self.text = 'Current temperature: ' + str(value)
|
|
|
|
|
|
class PlotWidget(Image):
|
|
|
|
def __init__(self, **kwargs):
|
|
super(PlotWidget, self).__init__(**kwargs)
|
|
self.data = numpy.array([], dtype=float);
|
|
self.lastTime = 0
|
|
self.lastTemperature = 0
|
|
self.figure = matplotlib.pyplot.figure()
|
|
self.plot_axes = self.figure.add_subplot(1, 1, 1)
|
|
self.plot_axes.hold(False)
|
|
self.plot_axes.set_ylabel('Temperature (deg C)')
|
|
self.plot_axes.set_xlabel('Time')
|
|
self.plot_axes.set_title('Recorded Temperature')
|
|
self.image_data = None
|
|
self._image_raw_data = None
|
|
|
|
|
|
def do_update(self):
|
|
if not self.data.any():
|
|
return
|
|
#Logger.debug('self.data: ' + str(self.data))
|
|
#Logger.debug('self.data shape: ' + str(self.data.shape))
|
|
data = numpy.copy(self.data)
|
|
data = data.transpose()
|
|
#Logger.debug('transpoed data: ' + str(data))
|
|
#Logger.debug('transposed data shape: ' + str(data.shape))
|
|
t, temperature = numpy.split(data, 2, axis = 0)
|
|
#Logger.debug('time: ' + str(t[0]))
|
|
#Logger.debug('temperature: ' + str(temperature[0]))
|
|
self.plot_axes.plot(t[0], temperature[0])
|
|
image_data = StringIO.StringIO()
|
|
self.figure.savefig(image_data, format = 'png')
|
|
image_data.seek(0)
|
|
self._image_raw_data = image_data
|
|
# We can't use ImageLoaders since they assume it's a file on disk.
|
|
# This replicates code from ImageLoaderPygame.load() and ImageLoaderBase.populate()
|
|
try:
|
|
im = pygame.image.load(image_data)
|
|
except:
|
|
Logger.warning('Image: Unable to load image from data')
|
|
raise
|
|
fmt = ''
|
|
if im.get_bytesize() == 3:
|
|
fmt = 'rgb'
|
|
elif im.get_bytesize() == 4:
|
|
fmt = 'rgba'
|
|
data = pygame.image.tostring(im, fmt.upper())
|
|
self.image_data = ImageData(im.get_width(), im.get_height(), fmt, data)
|
|
self.texture = Texture.create_from_data(self.image_data)
|
|
self.texture.flip_vertical()
|
|
|
|
|
|
def on_lastTemperature(self, value):
|
|
self.lastTemperature = value
|
|
|
|
|
|
def on_lastTime(self, value):
|
|
self.lastTime = value
|
|
self.update_data()
|
|
|
|
|
|
def update_data(self):
|
|
if self.lastTime == 0 or self.lastTemperature == 0:
|
|
return
|
|
newpoint = numpy.array([(self.lastTime, self.lastTemperature)], dtype=float, ndmin = 2)
|
|
if not self.data.any():
|
|
self.data = newpoint
|
|
return
|
|
#Logger.debug('self.data: ' + str(self.data))
|
|
#Logger.debug('newpoint: ' + str(newpoint))
|
|
self.data = numpy.vstack((self.data, newpoint))
|
|
self.do_update()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
dataThread = threading.Thread(None, temp_log.threaded_reader, None, ['/dev/ttyACM0', dataThreadDataQueue, dataThreadCommandQueue])
|
|
MainApp().run()
|