def __init__(self, *args, **kwargs):
        while not shared_memory['data_fresh']:
            pass
        super(MainWindow, self).__init__(*args, **kwargs)
        uic.loadUi(os.path.join(os.path.dirname(os.path.realpath(__file__)),
                                "second.ui"), self) 
        self.monitor_mode = False
        self.state = 'Connecting...'
        self.prev_time = time.time()

        self._heat_capacity_spin.valueChanged.connect(self.updateHeatCapacity)
        self._heat_capacity_spin.setDecimals(4)
        self._heat_capacity_spin.setMaximum(15.00) # Will we ever heat hydrogen?
        self._heat_capacity_spin.setSingleStep(0.0001)

        self._mass_spin.valueChanged.connect(self.updateMass)
        self._mass_spin.setDecimals(4)
        self._mass_spin.setMaximum(1000.00) 
        self._mass_spin.setSingleStep(0.0001)

        self._emissivity_spin.valueChanged.connect(self.updateEmissivity)
        self._emissivity_spin.setDecimals(4)
        self._emissivity_spin.setMaximum(1.00)
        self._emissivity_spin.setSingleStep(0.0001)

        self._area_spin.valueChanged.connect(self.updateArea)
        self._area_spin.setDecimals(4)
        self._area_spin.setMaximum(1000.00) 
        self._area_spin.setSingleStep(0.0001)

        self._resistance_spin.valueChanged.connect(self.updateResistance)
        self._resistance_spin.setDecimals(1)
        self._resistance_spin.setMaximum(1000.0) 
        self._resistance_spin.setSingleStep(0.1)

        self._voltage_spin.valueChanged.connect(self.updateVoltage)
        self._voltage_spin.setDecimals(2)
        self._voltage_spin.setMaximum(1000.00) 
        self._voltage_spin.setSingleStep(0.01)

        self._p_spin.valueChanged.connect(self.updateP)
        self._p_spin.setDecimals(4)
        self._p_spin.setMaximum(2.00) 
        self._p_spin.setSingleStep(0.0001)

        self._i_spin.valueChanged.connect(self.updateI)
        self._i_spin.setDecimals(4)
        self._i_spin.setMaximum(2.00) 
        self._i_spin.setSingleStep(0.0001)

        self._d_spin.valueChanged.connect(self.updateD)
        self._d_spin.setDecimals(4)
        self._d_spin.setMaximum(2.00) 
        self._d_spin.setSingleStep(0.0001)

        self._target_spin.valueChanged.connect(self.updateTarget)
        self._target_spin.setDecimals(2)
        self._target_spin.setMaximum(500.00) 
        self._target_spin.setSingleStep(0.01)

 
        self._monitor_check.stateChanged.connect(self.updateMonitor)
        self._btn_start.clicked.connect(self.startProcess)
        self._btn_stop.clicked.connect(self.stopProcess)
        self._state_out_label.setText(self.state)

        try:
          self._heat_capacity_spin.setValue(shared_memory['heatCapacity'])
          self._mass_spin.setValue(shared_memory['mass'])
          self._emissivity_spin.setValue(shared_memory['emissivity'])
          self._area_spin.setValue(shared_memory['area'])
          self._resistance_spin.setValue(shared_memory['resistance'])
          self._voltage_spin.setValue(shared_memory['voltage'])
          self._p_spin.setValue(shared_memory['p'])
          self._i_spin.setValue(shared_memory['i'])
          self._d_spin.setValue(shared_memory['d'])
        except:
           pass

        # palette = self._ambient_lcd.palette()
        # # foreground color
        # palette.setColor(palette.WindowText, QtGui.QColor(0, 0, 0))
        # # background color
        # palette.setColor(palette.Background, QtGui.QColor(0, 0, 0))
        # # "light" border
        # # palette.setColor(palette.Light, QtGui.QColor(255, 0, 0))
        # # "dark" border
        # palette.setColor(palette.Dark, QtGui.QColor(0, 0, 0))
        # # set the palette
        # self._ambient_lcd.setPalette(palette)
        # self._bath_lcd.setPalette(palette)
        # self._ambient_lcd.display(0.0)
        # self._bath_lcd.display(0.0)

        x = [1.0]
        y = [shared_memory['bath_temp']]
        xe = [1.0]
        ye = [shared_memory['env_temp']]

        viewport = [0.1, 0.95, 0.1, 0.95]

        self.env_curve = PlotCurve(xe, ye, legend = "Environment")
        self.env_curve.linetype = gr.LINETYPE_DASHED
        self.env_curve.linecolor = 7

        self.bath_curve = PlotCurve(x, y, legend = "Bath Medium")

        axes = PlotAxes(viewport)
        # axes.addCurves(self.env_curve)
        axes.addCurves(self.bath_curve)
        self._plot = Plot(viewport).addAxes(axes)
        self._plot.title = "System Temperatures"
        #self._plot.subTitle = "live data"
        self._plot.xlabel = "Seconds"
        self._plot.ylabel = "Celsius"
        self._plot.setLegend(True)
        self._plot.autoscale = PlotAxes.SCALE_X | PlotAxes.SCALE_Y
        self._stage.addPlot(self._plot)

        timer = QtCore.QTimer(self)
        timer.timeout.connect(self.updateData)
        timer.start(5000)