Plotter pane

[ladyada]

ok im going to start hacking on adding a plotter
current plan is to use QtCharts which will handle the drawing. ideally it will look for CSV-like data coming in off the repl.
ideal would be if we could have REPL and plotter going at the same time. will see how it goes :)

[ladyada]

some noodling

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import random
from collections import deque
from itertools import islice
from PyQt5.QtCore import QPointF, QTimer
from PyQt5.QtChart import QChart, QLineSeries, QChartView, QValueAxis
from PyQt5.QtWidgets import QWidget, QApplication, QGridLayout, QPushButton
from PyQt5.QtGui import QPainter


class PressureGraph(QWidget):
    def __init__(self):
        super().__init__()
        self.t = range(0,150)
        self.q = deque([0]*len(self.t))
        self.initUI()

    def on_resize(self, event):
        #print(event.size())
        x = event.size().width() // 2
        y = event.size().height()
        self.chart.axisY().setMax(y)
        self.chart.axisX().setMax(x)
        self.t = range(0, x)
        q_len = len(self.q)
        if x > q_len: # extend it!
            self.q.extendleft([0] * (x - q_len))
        if x < q_len: # contract it
            self.q = deque(islice(self.q, q_len-x, q_len))
        #print(self.q)
        self.chartView.update()
        
    def initUI(self):
        self.series = QLineSeries()

        self.chart = QChart()
        self.chart.legend().hide()
        self.chart.addSeries(self.series)

        self.axis_x = QValueAxis()
        self.axis_y = QValueAxis()
        self.axis_x.setRange(0, 150)
        self.axis_y.setRange(0, 200)
        self.axis_x.setLabelFormat("")
        self.axis_y.setLabelFormat("%d")
        self.chart.setAxisX(self.axis_x, self.series)
        self.chart.setAxisY(self.axis_y, self.series)

        self.chartView = QChartView(self.chart)
        self.chartView.setRenderHint(QPainter.Antialiasing)

        self.grid = QGridLayout()
        self.grid.addWidget(self.chartView)

        self.setLayout(self.grid)

        self.resize(1000,500)
        self.resizeEvent = lambda e: self.on_resize(e)


    def update(self, newpoint):
        self.q.append(newpoint)
        if len(self.q) > len(self.t):
            self.q.popleft()

        p_list = []
        for i in range(0, len(self.t)):
            
            if i > (len(self.q) - 1):
                temp = 0
            else:
                temp = self.q[len(self.t) - 1 - i]
            p_list.append((self.t[i], temp))

        self.series.clear()         
        for i in p_list:
            self.series.append(*i)
        
        self.chartView.update()

if __name__ == "__main__":
    import sys

    global graph
    
    app = QApplication([sys.argv])
    graph = PressureGraph()
    graph.show()

    timer = QTimer()
    timer.timeout.connect(lambda: graph.update(random.randrange(0,180)))
    timer.start(500) # in millis
    
    sys.exit(app.exec_())

[ntoll]

Oooh.... very nice (and simple). I wasn't aware of QtCharts. I can see how we could create a new control in the mu.interface.panes module. Such things can be docked together in Mu, so you'll be able to have the REPL and "charts" widget on the UI at the same time.

Here's a potential bump in the road: QtCharts only arrived in Qt5.9 (https://doc.qt.io/qt-5/whatsnew59.html#qt-charts-module) . On 17.04 Ubuntu I'm on Qt5.7 (so got around the problem of my system missing QtCharts by pip installing a binary wheel of 5.9 into my Python virtualenv). Raspbian (one of the target platforms) is only on Qt5.5. :-/

When we natively package Mu for Linux (as a .bin), OSX and Windows we include Qt as part of the package, although, looking at the build scripts, we're using a relatively old version of Qt depending on the platform. @carlosperate do you have any thoughts on us updating to PyQt 5.9 across all platforms? In any case, the problem of packaging is looming large in the front of my mind at the moment and I'll reference any work we do to this ticket so you (@ladyada) can see our progress.

I'm going to email @bennuttall at Raspberry Pi and Phil at Riverbank (who maintain PyQt) and ask them when/what/if/how I can help to update Raspbian to 5.9 so we remove this potential dependency pitfall.

[ladyada]

kk! the current design question is whether the repl/plotter should replace each other (on arduino ide, you can only have one or the other) or should you have two panes. either/or is much easier to implement. 2 panes is nicer, but then you have to figure out how to share the incoming serial port data.

right now the REPL pane 'owns' the serial connection https://github.com/mu-editor/mu/blob/master/mu/interface/panes.py#L123
so i'm not sure exactly how or which ill approach. i think two separate objects with a message/callback from serialport pane -> plotter pane wouldn't be too bad - there's very little data being managed.

[ladyada]

¯\_(ツ)_/¯

[ntoll]

Ooooh. That looks sweet.

The message passing approach sounds good especially as Qt has a notion of signals that emit messages to connected handlers. The object connected to the serial port only needs to emit things and anything else wanting such data as its emitted need only connect to the signal with a function to handle the emitted data.

Is your code pushed anywhere? I could probably bodge something together pretty fast to prove such message passing works well in this case (or not).

[ntoll]

Actually, check out https://github.com/mu-editor/mu/blob/master/mu/interface/panes.py#L137 where the self.serial.readyRead signal is connected to the on_serial_read method. This method could emit a signal of the read bytes for anything else connected to it to process further. Sound like a plan?

[ladyada]

i made a hook because i dont know about 'signals' and we can replace it later

https://github.com/adafruit/mu/blob/qtplotter/mu/interface/panes.py#L193

current status: needs to buffer the data for proper parsing as we dont get a full line sometimes

[ntoll]

@ladyada I'm spending some (much needed) time on Mu this week.

A quick question: was there any reason for using the QtCharts API (other than because it was there)?

I wonder, for the sake of those not on the latest Qt, if making use of Matplotlib would be a better/wider supported alternative? For example, something like https://matplotlib.org/examples/user_interfaces/embedding_in_qt5.html (note: the Python3/Jupyter REPL already means we need Matplotlib so it's an
already met requirement).

Thoughts?

[ladyada]

hiya yah that's awesome, i also hope to go back and finish the charts

I used qcharts because we're already using Qt so it came up in my search, and it works really well. but, the chart can be reworked with matplotlib - is Qt not releasing Qt 5.9 for some platforms? 5.10 just came out ;)

[ntoll]

It's more a case of backwards compatibility for OS's that don't have Qt 5.9 packaged (especially Raspbian). I'll try to hack something together once I've finished the current tidy-ups.

[ladyada]

ok ill not write anymore code w.r.t. the plotter!

[ntoll]

I just tried a quick experiment based upon the code found at the link pasted above (the plot was updating at 20FPS)... it takes but a couple of seconds to get the fan started and for my 4-core CPU to hit 300% :-/ I think QCharts is definitely back on the table as a result and I'll try to manage the upstream dependencies with Raspbian folks.

[ladyada]

w/qchart i also had some bad CPU usage if i had more than 500 points. you could try reducing plotpoints? funny how this kinda thing is so hard for computers :D

[yonghuming]

wanderful work

[ladyada]

@ntoll fyi - ill keep hacking on the plotter but i dont want to hold up a release, since a different version of qt may be required! so please continue with the current release schedule, ill get the plotter into the next one! :)