Arduino/temp_sensor/temp_sensor.ino

+int ThermistorPin = 0;
+int Vo;
+float R1 = 1091.9; // measured using a multimeter
+float logR2, R2, T;
+//float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;
+
+// calculated from here: https://www.sterlingsensors.co.uk/pt1000-resistance-table
+// using these formulae: https://www.servo.jp/member/admin/document_upload/AN144-Thermistor-Steinhart-Hart-Coefficients.pdf
+float c = 0.0000592664367348686;
+float b = -0.011955482226601;
+float a = 0.0667213740258914;
+
+float movingAverage(float value) {
+  // stolen from here: https://stackoverflow.com/questions/67208086/how-can-i-calculate-a-moving-average-in-arduino
+  
+  const byte nvalues = 32;            // Moving average window size
+
+  static byte current = 0;            // Index for current value
+  static byte cvalues = 0;            // Count of values read (<= nvalues)
+  static float sum = 0;               // Rolling sum
+  static float values[nvalues];
+
+  sum += value;
+
+  // If the window is full, adjust the sum by deleting the oldest value
+  if (cvalues == nvalues)
+    sum -= values[current];
+
+  values[current] = value;          // Replace the oldest with the latest
+
+  if (++current >= nvalues)
+    current = 0;
+
+  if (cvalues < nvalues)
+    cvalues += 1;
+
+  return sum/cvalues;
+}
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  // stolen from here: https://www.circuitbasics.com/arduino-thermistor-temperature-sensor-tutorial/
+  Vo = analogRead(ThermistorPin);
+  R2 = R1 * (1023.0 / (float)Vo - 1.0);
+  logR2 = log(R2);
+  T = (1.0 / (a + b*logR2 + c*logR2*logR2*logR2));
+  T = T - 273.15;
+  //T = (T * 9.0)/ 5.0 + 32.0; 
+
+  Serial.println(movingAverage(T));
+
+  delay(1000);
+}
\ No newline at end of file

README.md

 # temp_sensor
 
+temp_sensor is a GUI for connecting to and reading from a temperature sensor, constructed using an Arduino. The GUI was designed as an example for how to design a basic GUI in Python using Qt, with features such as serial connection, live plotting to a graph, exporting data to CSV, and processing events outside of the main loop to ensure that the GUI does not freeze. This is not intended to be an accurate scientific instrument, but rather an educational exercise for anyone to use as a starting point, and to become familiar with designing GUIs for scientific experiments.
+ 
+## Installation
 
+Assuming git is installed on your system, navigate to the folder where you would like to 'install' the program and run the command:
 
-## Getting started
-
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
-```
-cd existing_repo
-git remote add origin https://gitlab.phys.ethz.ch/mfranks/temp_sensor.git
-git branch -M main
-git push -uf origin main
+```bash
+git clone git@gitlab.phys.ethz.ch:mfranks/temp_sensor.git
 ```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://gitlab.phys.ethz.ch/mfranks/temp_sensor/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
-
-## Suggestions for a good README
-
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
-
-## Name
-Choose a self-explaining name for your project.
-
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
+Or you can simply download the compressed source code using the Code dropdown button.
 
 ## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
 
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
+Assuming Python is already installed on your system (along with the necessary libraries), run:
 
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
+```bash
+cd temp_sensor
+python app.py
+```
 
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
+The application window will open.
 
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
+## Constructing the temperature sensor
 
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
+The temperature sensor used to develop this project was constructed following [this guide](https://www.circuitbasics.com/arduino-thermistor-temperature-sensor-tutorial/). Due to equipment availability, a PT1000 thermistor was used in series with a 1.1 kOhm resistor, along with an Arduino NANO Every.
 
-## License
-For open source projects, say how it is licensed.
+## Arduino code
 
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+Flash the INO file in the Arduino/temp_sensor/ folder to an Arduino using the Arduino IDE.

SerialComCtrlQt.py

+from PyQt5 import QtCore, QtWidgets, QtSerialPort
+from PyQt5.QtCore import QIODevice
+
+# Originally written by T. Weber (ETH Zurich) for Tk
+# but modified by M. Franks (ETH Zurich) to work with Qt
+
+class SerialCtrl(QtWidgets.QWidget):
+    def __init__(self, parent=None):
+        super(SerialCtrl, self).__init__(parent)
+    
+    def serialOpen(self, port, baud):
+        # attempt to open serial
+        self.serial = QtSerialPort.QSerialPort(port, baudRate=QtSerialPort.QSerialPort.Baud9600)
+        
+        self.serial.open(QIODevice.ReadWrite)
+        status = self.serial.isOpen()
+        if (status):
+            print("Connected.")
+        else:
+            print("Unable to connect.")
+      
+        return status
+
+    def serialClose(self):
+        try:
+            self.serial.close()
+            status = self.serial.isOpen()
+            if (status):
+                print("Arduino still connected.")
+            else:
+                print("Arduino disconnected.")
+            
+            return status
+        
+        except (AttributeError, UnboundLocalError):
+            print("User must attempt connection first. More intelligent connect/disconnect to be implemented.")
+
+    '''
+    def serialWrite (self, command):
+        print("writing to serial.")
+        if isinstance(command, str):
+            self.serial.write(bytes(self.encodeDataString(command),'utf-8'))
+
+        if isinstance(command, list):
+            self.serial.write(bytes(self.encodeDataArray(command),'utf-8'))
+        #time.sleep(0.05)
+        print("written to serial.")
+    '''
+
+    def serialRead (self):
+        if self.serial.isOpen() and self.serial.bytesAvailable() >= 7:
+            return self.serial.readLine().data().decode("utf-8").strip()
+            #return self.serial.readLine()
+        #else:
+        #    return "no new data"
+
+if __name__ == '__main__':
+    SerialCtrl()

app.py

+import sys
+import math
+import numpy as np
+import pandas as pd
+
+from PyQt5.QtWidgets import (
+    QApplication, QMainWindow, QFileDialog
+)
+from PyQt5.uic import loadUi
+from PyQt5.QtSerialPort import QSerialPortInfo
+
+from ui_temp_sensor import Ui_MainWindow
+
+from SerialComCtrlQt import SerialCtrl
+from ui_functions import *
+
+class Window(QMainWindow, Ui_MainWindow):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setupUi(self)
+        
+        # run some functions at startup
+        self.connectUI()
+        self.refresh_ports()
+        self.clear_graph()
+        
+        self.arduino = SerialCtrl()
+
+    def connectUI(self):
+        # define some signals
+        self.stop_requested = 0 # allows user to pause serial read
+
+        # connect buttons to functions
+        self.button_export.clicked.connect(self.export_CSV)
+        self.button_connect.clicked.connect(self.connect_serial)
+        self.button_read.clicked.connect(self.read_serial)
+        self.button_stop.clicked.connect(self.stop_serial)
+
+        # connect actions to functions
+        self.actionExport.triggered.connect(self.export_CSV)
+        self.actionConnect.triggered.connect(self.connect_serial)
+        self.actionDisconnect.triggered.connect(self.disconnect_serial)
+        self.actionClear.triggered.connect(self.clear_graph)
+        self.actionRefresh_ports.triggered.connect(self.refresh_ports)
+        self.actionExit.triggered.connect(self.close_window)
+
+        # user-friendly enable/disable buttons in GUI 
+        self.button_stop.setEnabled(0)
+        self.button_read.setEnabled(0)
+
+    def close_window(self):
+        print("Disconnecting serial...")
+        self.disconnect_serial()
+    
+        print("Closing application...")
+        QApplication.quit()
+
+    def refresh_ports(self):
+        self.dropdown_port.clear()
+        serialPortInfos = QSerialPortInfo.availablePorts()
+        for portInfo in serialPortInfos:
+            self.dropdown_port.addItem(portInfo.portName())
+            print(portInfo.portName(), ":", portInfo.description())
+
+    def clear_graph(self):
+        self.widget_graph.canvas.ax.clear()
+        self.widget_graph.canvas.ax.set_xlabel("Time")
+        self.widget_graph.canvas.ax.set_ylabel("Temperature [C]")
+        self.widget_graph.canvas.draw()
+
+        self.x = []
+        self.y = []
+
+    def export_CSV(self):
+        filename = QFileDialog.getSaveFileName()
+        print("Exporting CSV to", filename[0])
+        
+        df = pd.DataFrame(data={"Time": self.x, "Temperature [C]": self.y})
+        df.to_csv(filename[0], sep=',',index=False)
+
+        print("Done.")
+        
+    def connect_serial(self):
+        port = self.dropdown_port.currentText()
+        baud = self.dropdown_baud.currentText()
+        print("Connecting over serial to device on port", port, "with rate", baud)
+
+        status = self.arduino.serialOpen(port, baud)
+        if status:
+            self.button_connect.setEnabled(0)
+            self.button_connect.setText("Connected")
+            self.actionConnect.setEnabled(0)
+            self.button_read.setEnabled(1)
+
+    def disconnect_serial(self):
+        status = self.arduino.serialClose()
+        if not status:
+            self.button_connect.setEnabled(1)
+            self.button_connect.setText("Connect")
+            self.button_read.setEnabled(0)
+            self.actionConnect.setEnabled(1)
+
+    def read_serial(self):
+        self.stop_requested = 0
+        self.button_read.setEnabled(0)
+        self.button_stop.setEnabled(1)
+        
+        while not self.stop_requested:
+            QApplication.processEvents() # stops GUI hanging
+            message = self.arduino.serialRead()
+            
+            if message != None:
+                update_graph(self, message, self.x, self.y)
+
+    def stop_serial(self):
+        self.stop_requested = 1
+        self.button_stop.setEnabled(0)
+        self.button_read.setEnabled(1)
+        
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    win = Window()
+    win.show()
+    sys.exit(app.exec())

mplwidget.py

+from PyQt5 import QtWidgets
+from matplotlib.figure import Figure
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as Canvas
+import matplotlib
+
+# This was stolen from stackoverflow.com/questions/43947318 
+
+# Ensure using PyQt5 backend
+matplotlib.use('QT5Agg')
+
+# Matplotlib canvas class to create figure
+class MplCanvas(Canvas):
+    def __init__(self):
+        self.fig = Figure()
+        self.ax = self.fig.add_subplot(111)
+        Canvas.__init__(self, self.fig)
+        Canvas.setSizePolicy(self, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
+        Canvas.updateGeometry(self)
+        
+# Matplotlib widget
+class Mplwidget(QtWidgets.QWidget):
+    def __init__(self, parent=None):
+        QtWidgets.QWidget.__init__(self, parent)   # Inherit from QWidget
+        self.canvas = MplCanvas()                  # Create canvas object
+        self.vbl = QtWidgets.QVBoxLayout()         # Set box for plotting
+        self.vbl.addWidget(self.canvas)
+        self.setLayout(self.vbl)

temp_sensor.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>662</width>
+    <height>569</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Temperature Sensor</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <widget class="QPushButton" name="button_export">
+    <property name="geometry">
+     <rect>
+      <x>570</x>
+      <y>500</y>
+      <width>75</width>
+      <height>23</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Export CSV</string>
+    </property>
+   </widget>
+   <widget class="Mplwidget" name="widget_graph" native="true">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>10</y>
+      <width>640</width>
+      <height>480</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QComboBox" name="dropdown_port">
+    <property name="geometry">
+     <rect>
+      <x>20</x>
+      <y>500</y>
+      <width>71</width>
+      <height>22</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="button_connect">
+    <property name="geometry">
+     <rect>
+      <x>180</x>
+      <y>500</y>
+      <width>75</width>
+      <height>23</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Connect</string>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="button_read">
+    <property name="geometry">
+     <rect>
+      <x>410</x>
+      <y>500</y>
+      <width>75</width>
+      <height>23</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Read serial</string>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="button_stop">
+    <property name="geometry">
+     <rect>
+      <x>490</x>
+      <y>500</y>
+      <width>75</width>
+      <height>23</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Stop serial</string>
+    </property>
+   </widget>
+   <widget class="QComboBox" name="dropdown_baud">
+    <property name="geometry">
+     <rect>
+      <x>100</x>
+      <y>500</y>
+      <width>71</width>
+      <height>22</height>
+     </rect>
+    </property>
+    <item>
+     <property name="text">
+      <string>9600</string>
+     </property>
+    </item>
+   </widget>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>662</width>
+     <height>22</height>
+    </rect>
+   </property>
+   <widget class="QMenu" name="menuFile">
+    <property name="title">
+     <string>File</string>
+    </property>
+    <addaction name="actionExport"/>
+    <addaction name="actionExit"/>
+   </widget>
+   <widget class="QMenu" name="menuGraph">
+    <property name="title">
+     <string>Graph</string>
+    </property>
+    <addaction name="actionClear"/>
+   </widget>
+   <widget class="QMenu" name="menuSerial">
+    <property name="title">
+     <string>Serial</string>
+    </property>
+    <addaction name="actionConnect"/>
+    <addaction name="actionDisconnect"/>
+    <addaction name="separator"/>
+    <addaction name="actionRefresh_ports"/>
+   </widget>
+   <addaction name="menuFile"/>
+   <addaction name="menuSerial"/>
+   <addaction name="menuGraph"/>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+  <action name="actionExport">
+   <property name="text">
+    <string>Export CSV</string>
+   </property>
+  </action>
+  <action name="actionClear">
+   <property name="text">
+    <string>Clear</string>
+   </property>
+  </action>
+  <action name="actionConnect">
+   <property name="text">
+    <string>Connect</string>
+   </property>
+  </action>
+  <action name="actionDisconnect">
+   <property name="text">
+    <string>Disconnect</string>
+   </property>
+  </action>
+  <action name="actionRefresh_ports">
+   <property name="text">
+    <string>Refresh ports</string>
+   </property>
+  </action>
+  <action name="actionExit">
+   <property name="text">
+    <string>Exit</string>
+   </property>
+  </action>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>Mplwidget</class>
+   <extends>QWidget</extends>
+   <header>mplwidget.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

ui_functions.py

+import time
+
+# example of how to keep functions tidy, in an external file
+
+def update_graph(self, message, x, y):
+    t = time.strftime("%H:%M:%S", time.localtime())
+    
+    self.widget_graph.canvas.ax.clear()
+    self.widget_graph.canvas.ax.set_xlabel("Time")
+    self.widget_graph.canvas.ax.set_ylabel("Temperature [C]") 
+
+    try:
+        x += [t]
+        y += [float(message[0:5])]
+    
+        self.widget_graph.canvas.ax.plot(x, y, color="r")
+            
+        Nx = len(x)
+            
+        if Nx >= 2:
+            # time is not automatically formatted on matplotlib axes
+            ticks = [x[0], x[-1]] # take first and last times
+            
+            # label leftmost and rightmost x axis ticks
+            self.widget_graph.canvas.ax.set_xticks([0,Nx])
+            self.widget_graph.canvas.ax.set_xticklabels(ticks)
+            
+        self.widget_graph.canvas.draw()
+        
+        print(Nx,t,": ",message[0:5])
+    except ValueError:
+        # sometimes value read from Arduino is just '\x00\x00\x00\x00\x00'
+        print("Error converting string read from Arduino to float. Try disconnecting and reconnecting Arduino.")

ui_temp_sensor.py

+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file '.\temp_sensor.ui'
+#
+# Created by: PyQt5 UI code generator 5.15.6
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic5 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt5 import QtCore, QtGui, QtWidgets
+
+
+class Ui_MainWindow(object):
+    def setupUi(self, MainWindow):
+        MainWindow.setObjectName("MainWindow")
+        MainWindow.resize(662, 569)
+        self.centralwidget = QtWidgets.QWidget(MainWindow)
+        self.centralwidget.setObjectName("centralwidget")
+        self.button_export = QtWidgets.QPushButton(self.centralwidget)
+        self.button_export.setGeometry(QtCore.QRect(570, 500, 75, 23))
+        self.button_export.setObjectName("button_export")
+        self.widget_graph = Mplwidget(self.centralwidget)
+        self.widget_graph.setGeometry(QtCore.QRect(10, 10, 640, 480))
+        self.widget_graph.setObjectName("widget_graph")
+        self.dropdown_port = QtWidgets.QComboBox(self.centralwidget)
+        self.dropdown_port.setGeometry(QtCore.QRect(20, 500, 71, 22))
+        self.dropdown_port.setObjectName("dropdown_port")
+        self.button_connect = QtWidgets.QPushButton(self.centralwidget)
+        self.button_connect.setGeometry(QtCore.QRect(180, 500, 75, 23))
+        self.button_connect.setObjectName("button_connect")
+        self.button_read = QtWidgets.QPushButton(self.centralwidget)
+        self.button_read.setGeometry(QtCore.QRect(410, 500, 75, 23))
+        self.button_read.setObjectName("button_read")
+        self.button_stop = QtWidgets.QPushButton(self.centralwidget)
+        self.button_stop.setGeometry(QtCore.QRect(490, 500, 75, 23))
+        self.button_stop.setObjectName("button_stop")
+        self.dropdown_baud = QtWidgets.QComboBox(self.centralwidget)
+        self.dropdown_baud.setGeometry(QtCore.QRect(100, 500, 71, 22))
+        self.dropdown_baud.setObjectName("dropdown_baud")
+        self.dropdown_baud.addItem("")
+        MainWindow.setCentralWidget(self.centralwidget)
+        self.menubar = QtWidgets.QMenuBar(MainWindow)
+        self.menubar.setGeometry(QtCore.QRect(0, 0, 662, 22))
+        self.menubar.setObjectName("menubar")
+        self.menuFile = QtWidgets.QMenu(self.menubar)
+        self.menuFile.setObjectName("menuFile")
+        self.menuGraph = QtWidgets.QMenu(self.menubar)
+        self.menuGraph.setObjectName("menuGraph")
+        self.menuSerial = QtWidgets.QMenu(self.menubar)
+        self.menuSerial.setObjectName("menuSerial")
+        MainWindow.setMenuBar(self.menubar)
+        self.statusbar = QtWidgets.QStatusBar(MainWindow)
+        self.statusbar.setObjectName("statusbar")
+        MainWindow.setStatusBar(self.statusbar)
+        self.actionExport = QtWidgets.QAction(MainWindow)
+        self.actionExport.setObjectName("actionExport")
+        self.actionClear = QtWidgets.QAction(MainWindow)
+        self.actionClear.setObjectName("actionClear")
+        self.actionConnect = QtWidgets.QAction(MainWindow)
+        self.actionConnect.setObjectName("actionConnect")
+        self.actionDisconnect = QtWidgets.QAction(MainWindow)
+        self.actionDisconnect.setObjectName("actionDisconnect")
+        self.actionRefresh_ports = QtWidgets.QAction(MainWindow)
+        self.actionRefresh_ports.setObjectName("actionRefresh_ports")
+        self.actionExit = QtWidgets.QAction(MainWindow)
+        self.actionExit.setObjectName("actionExit")
+        self.menuFile.addAction(self.actionExport)
+        self.menuFile.addAction(self.actionExit)
+        self.menuGraph.addAction(self.actionClear)
+        self.menuSerial.addAction(self.actionConnect)
+        self.menuSerial.addAction(self.actionDisconnect)
+        self.menuSerial.addSeparator()
+        self.menuSerial.addAction(self.actionRefresh_ports)
+        self.menubar.addAction(self.menuFile.menuAction())
+        self.menubar.addAction(self.menuSerial.menuAction())
+        self.menubar.addAction(self.menuGraph.menuAction())
+
+        self.retranslateUi(MainWindow)
+        QtCore.QMetaObject.connectSlotsByName(MainWindow)
+
+    def retranslateUi(self, MainWindow):
+        _translate = QtCore.QCoreApplication.translate
+        MainWindow.setWindowTitle(_translate("MainWindow", "Temperature Sensor"))
+        self.button_export.setText(_translate("MainWindow", "Export CSV"))
+        self.button_connect.setText(_translate("MainWindow", "Connect"))
+        self.button_read.setText(_translate("MainWindow", "Read serial"))
+        self.button_stop.setText(_translate("MainWindow", "Stop serial"))
+        self.dropdown_baud.setItemText(0, _translate("MainWindow", "9600"))
+        self.menuFile.setTitle(_translate("MainWindow", "File"))
+        self.menuGraph.setTitle(_translate("MainWindow", "Graph"))
+        self.menuSerial.setTitle(_translate("MainWindow", "Serial"))
+        self.actionExport.setText(_translate("MainWindow", "Export CSV"))
+        self.actionClear.setText(_translate("MainWindow", "Clear"))
+        self.actionConnect.setText(_translate("MainWindow", "Connect"))
+        self.actionDisconnect.setText(_translate("MainWindow", "Disconnect"))
+        self.actionRefresh_ports.setText(_translate("MainWindow", "Refresh ports"))
+        self.actionExit.setText(_translate("MainWindow", "Exit"))
+from mplwidget import Mplwidget