Sunday, May 9, 2021

Tcontrol_PWM Python Program on a Raspberry Pi

Here's a video of one of my home projects:

Note: to view it in high resolution, after starting it, click on the YouTube logo to watch it on a YouTube page.


In this video, we controlled the surface temperature of a 3-watt wirewound resistor by employing a feedback control loop that nudges the current through the resistor up and down while continuously reading a temperature sensor glued to the surface of the resistor. The current is supplied by the 9-volt battery shown through a Darlington-pair bipolar junction transistor (BJT) acting as a high-speed switch. The on/off state of the BJT is set by a pulse width modulation (PWM) signal from the 3.3 volt GPIO18 pin of the Raspberry Pi computer. The pulses are output at 100 Hz, and the duty cycle of the pulse signal controls the effective average current through the resistor.


Please see my previously posted "Thermistors" article for further information on the temperature sensing hardware, Python program libraries, and interactive UI on the smartphone. The PWM signal is implemented using the gpiozero library that ships with the standard Raspberry Pi Python installation.

Here's the Python code:


# TCONTROL_PWM PROGRAM FOR CONTROL OF TEMPERATURE
# Version 0.5, 08-May-2021
# Copyright © 2021 Joe Czapski
# Contact: xejgyczlionoldmailservertigernet replace lion with
# an at sign and tiger with a dot.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# This program was written to run on a Raspberry Pi 4B computer running
# Raspbian Linux, with a Pi-16ADC voltage-measuring HAT board screwed on top,
# and with resistors and capacitors soldered onto the HAT to form the
# temperature sensor circuit. The program commands and reads from the LTC2497
# ADC chip on the HAT via the I2C communication bus.
# The heater is a high-wattage resistor, and the heat output is controlled
# by varying the current through the resistor using a pulse width modulation
# (PWM) signal from the GPIO18 pin to a transistor switch.
#
# This program uses a UI library and live-updating web-server engine
# called REMI (https://github.com/dddomodossola/remi).
# The program's structure is based on usage examples from the
# REMI codebase. The strip chart is drawn using the Matplotlib library
# (https://matplotlib.org).

# Comments that begin with [DEV] describe potential improvements that can be made.

import math
import threading
from smbus import SMBus
import io
import time
from time import sleep
import remi
from remi.gui import *
from matplotlib.figure import Figure
from matplotlib.backends.backend_agg import FigureCanvasAgg
from gpiozero import PWMLED

#SET CONSTANTS AND INITIALIZE HARDWARE
#Nsensors is the number of temperature sensors to poll continuously.
#The ADC can poll up to 16 sensors. This application uses just one sensor.
#Note: there are architecture elements in the code for polling 3 sensors
#because the program and hardware employed 3 sensors in an earlier version.
Nsensors = 1   #number of temperature sensors to poll continuously
#Strip chart plots include: 1) T Measured, 2) T Setpoint, 3) Heater Power.
Nbuffers = 3   #number of plot lines for the strip chart
i2cbus = SMBus(1)   #initialize connection to the I2C bus
i2caddr = 0x76   #ADC board jumper positions
adc_ch = [0xB0, 0xB8, 0xB1]   #ADC voltage input channel addresses
#Reference resistors are metal-film resistors with TC<0.5ohm/degC.
Rref = [4976.4, 5003.9, 4994.8]   #values in ohms
vplus = 5.0   #for best accuracy, use nominal value of supply +5V to the ADC board, not actual value
max_counts = 16777215.0   #2^24 - 1
readlenbytes = 6   #I2C bus read data block length
buswait = 0.17   #seconds to wait between I2C actions (effectively the shortest polling interval possible)
update_interval_sec = 0.33   #web page redraw interval for REMI's server (also sets button-click response time)
xspan = 60.0   #strip chart X axis span in seconds
buffer_length = 500   #must be more than xspan/buswait
yAuto = False   #autorange the Y axis?
ymin = 15.0; ymax = 55.0   #initial Y axis range in degrees C (fixed range if yAuto is False)
y2min = 0.0; y2max = 2.0   #Y2 axis range, fixed, which is the right-side scale for Heater Power
plotColors = ['black', 'red', 'blue']
plotNames = ['T Measured', 'T Setpoint', 'H Power']   #displayed in the legend inset
#Steinhart–Hart equation coefficients for TDK NTC Thermistor B57863S0103F040:
coeffA = 1.12532e-3; coeffB = 2.34873e-4; coeffC = 8.59509e-8
heater = PWMLED(18, frequency=100)   #initialize GPIO18 as a 100 Hz pulse source
heater.value = 0.0   #start with heater off
hmax = 0.825   #maximum PWM duty cycle allowed, 0.0 to 1.0 (sets maximum heater watts)
vce_drop = 0.8   #voltage drop across the BJT when on in saturation
#Voltage measurement on a mid-life 9V Duracell varied from 8.4V at 15mA load current,
#to 7.7V at 200mA load current.
vhpower = 8.0   #typical voltage from 9V battery
vheater = vhpower - vce_drop
rheater = 33.0   #heater resistor ohms
Tctrlband = 12.0   #outside of this +/- band, make heater fully on or fully off
#These gain values set the behavior of the feedback control when within the control band:
gainI = -0.007 * update_interval_sec   #incremental gain
gainD = -0.025 / update_interval_sec   #differential gain

#FUNCTION CtoF() converts Celcius to Fahrenheit
#Note: this version of the program only uses degrees Celcius.
def CtoF(degrees):
    return 1.8 * degrees + 32.0
#FUNCTION adc_channel_init() starts measuring on the specified channel on the ADC chip.
#Call this function once to initialize on the first channel of the round-robin.
def adc_channel_init(first_ch_index):
    i2cbus.write_byte(i2caddr, adc_ch[first_ch_index])

#FUNCTION read_temperature() reads a channel's ADC counts via the I2C bus
#and then calculates voltage then temperature. This function also sets
#the next channel address to start measuring on.
def read_temperature(ch_index, next_ch_index):
    readarray = i2cbus.read_i2c_block_data(i2caddr, adc_ch[next_ch_index], readlenbytes)
    counts = readarray[0]*65536.0 + readarray[1]*256.0 + readarray[2]
    volts = vplus * counts / max_counts
    Rt = volts * Rref[ch_index] / (vplus - volts)  #calculate thermistor resistance
    lnR = math.log(Rt)
    invT = coeffA + coeffB*lnR + coeffC*lnR*lnR*lnR  #Steinhart–Hart equation
    T = 1.0/invT - 273.0   #convert inverse Kelvin to Celcius
    return T

#CLASS CircBuff
#This class implements a continuous wrap-around buffer to hold and serve out
#the temperature and time data for the strip chart.
#Two instances of CircBuff are spawned for each strip chart plot needed.
#If for example Nbuffers = 3, then 6 CircBuff instances are spawned.
#[DEV] Within this class, need to implement locking of all methods per instance, to prevent
#issues arising from multiple threads simultaneously acting on a buffer.
class CircBuff:
    def __init__(self, buflen, useFilter=False):
        self.buflen = buflen
        self.buffer = [0.0] * self.buflen
        self.ptr = 0
        self.full = False
        self.useFilter = useFilter
        self.filtsum = 0.0
        
    def add(self, value):
        if self.useFilter:
            if self.size() == 0:
                newval = value
            else:
                newval = 0.35*value + 0.65*self.filtsum
            self.filtsum = newval
        else:
            newval = value
        self.buffer[self.ptr] = newval
        self.ptr += 1
        if self.ptr >= self.buflen:
            self.ptr = 0
            self.full = True
            
    def size(self):
        if self.full:
            return self.buflen
        else:
            return self.ptr
        
    def read(self, count=-1):
        s = self.size()
        p = self.ptr
        b = self.buffer.copy()  #grab snapshot of buffer to ignore colliding changes
        if self.full:
            if p == 0:
                rlist = b
            else:
                rlist = b[p:] + b[0: p]
        else:
            rlist = b[0: p]
        if count >= 0 and count < self.buflen:
            return rlist[max(s - count, 0):]
        else:
            return rlist
        
    def readtimespan(self, tspan):
        tlist = self.read()
        tstart = tlist[-1] - tspan
        i = -1
        for t in tlist:
            i += 1
            if t > tstart:
                break
        return tlist[i:]
        
    def readlast(self):
        if self.ptr == 0:
            return self.buffer[self.buflen - 1]
        else:
            return self.buffer[self.ptr - 1]
        
    def clear(self):
        self.ptr = 0
        self.full = False

#CLASS MatplotImage
#This class is taken intact from REMI example programs for drawing graphs.
#It contains the interface functions for displaying a Matplotlib graph image
#onto the web page. This latest version is flicker-free.
class MatplotImage(Image):
    ax = None
    app_instance = None
    
    def __init__(self, **kwargs):
        super(MatplotImage, self).__init__("/%s/get_image_data?index=0" % str(id(self)), **kwargs)
        self._fig = Figure(figsize=(8, 4))
        self.ax = self._fig.add_subplot(111)

    def search_app_instance(self, node):
        if issubclass(node.__class__, remi.server.App):
            return node
        if not hasattr(node, "get_parent"):
            return None
        return self.search_app_instance(node.get_parent()) 

    def update(self, *args):
        if self.app_instance==None:
            self.app_instance = self.search_app_instance(self)
            if self.app_instance==None:
                return
        self.app_instance.execute_javascript("""
            url = '/%(id)s/get_image_data?index=%(frame_index)s';
            xhr = null;
            xhr = new XMLHttpRequest();
            xhr.open('GET', url, true);
            xhr.responseType = 'blob'
            xhr.onload = function(e){
                urlCreator = window.URL || window.webkitURL;
                urlCreator.revokeObjectURL(document.getElementById('%(id)s').src);
                imageUrl = urlCreator.createObjectURL(this.response);
                document.getElementById('%(id)s').src = imageUrl;
            }
            xhr.send();
            """ % {'id': self.identifier, 'frame_index': str(time.time())})

    def get_image_data(self, index=0):
        Image.set_image(self, '/%(id)s/get_image_data?index=%(frame_index)s'% {'id': self.identifier, 'frame_index': str(time.time())})
        self._set_updated()
        try:
            data = None
            canv = FigureCanvasAgg(self._fig)
            buf = io.BytesIO()
            canv.print_figure(buf, format='png')
            buf.seek(0)
            data = buf.read()
            headers = {'Content-type': 'image/png', 'Cache-Control': 'no-cache'}
            return [data, headers]
        except Exception:
            pass
            #print(traceback.format_exc())
        return None, None

#CLASS Thermistors
#This class is the main program structured as a REMI App object.
class Thermistors(remi.App):
    def __init__(self, *args, **kwargs):
        if not 'editing_mode' in kwargs.keys():
            super(Thermistors, self).__init__(*args, static_file_path={'my_res': './res/'})

    #FUNCTION daq_process() is the data acquisition process running as a separate thread.
    #Each ADC channel takes about 170 milliseconds to access and read.
    #Temperature readings are written to the circular buffers that were allocated at start-up.
    #[DEV] Provide an option for this function to also write readings to a file.
    def daq_process(self):
        adc_channel_init(0)  #set the ADC chip to the first channel that will be read
        while self.daq_running:
            #In this For loop, i is the adc channel being read,
            #and j is the next adc channel that will be read.
            t = self.reftime
            for i in range(0, Nsensors):
                j = i + 1
                if j >= Nsensors:
                    j = 0
                sleep(buswait)  #this wait between reads is critical to avoid I2C I/O errors
                while self.daq_paused:
                    sleep(buswait)
                if not self.daq_running:
                    break
                t = time.time() - self.reftime   #capture timestamp before reading T
                self.ydata[i].add(read_temperature(i, j))   #read T and write to Y buffer
                self.xdata[i].add(t)   #write timestamp to X buffer after T is done reading
            self.ydata[1].add(self.Tsetpoint)   #use the second buffer for T setpoint
            self.xdata[1].add(t)
            self.ydata[2].add(self.pheater)   #use the third buffer for heater watts
            self.xdata[2].add(t)

    #FUNCTION idle() is called by the REMI engine once per display update interval.
    #This function's job is to update all of the numeric indicators and strip chart on the UI.
    def idle(self):
        allChannelsIn = True
        T = -500.0
        n = self.ydata[0].size()
        if n > 0:
            T = self.ydata[0].readlast()   #get the latest T reading from the DAQ thread
            if self.unitIsCelcius:
                Tdisp = T
            else:
                Tdisp = CtoF(T)   #convert Celcius to Fahrenheit (if so configured)
            Tstr = f'{Tdisp:.2f}'   #display value to 2 decimal places
        else:
            allChannelsIn = False
            Tstr = '-.--'
        self.mainTabs.children['Control'].children['labelTmeasured'].set_text(Tstr)
        if self.Henable:
            if T > -499.0 and self.Tprev > -499.0 and self.Tcontrol_on and self.daq_running:
                Tdiff = T - self.Tsetpoint   #calculate the difference between the measured temperature and the setpoint
                Tslope = T - self.Tprev   #calculate the difference between the current temperature reading and the previous reading
                if abs(Tdiff) > Tctrlband:
                    if Tdiff > 0.0:
                        self.heat = 0.0
                    else:
                        self.heat = hmax
                else:
                    #Adjust heater current using the feeback control gains:
                    self.heat = self.heat + (gainI * Tdiff) + (gainD * Tslope)
                    if self.heat > hmax:
                        self.heat = hmax
                    if self.heat < 0.0:
                        self.heat = 0.0
                heater.value = self.heat
        else:
            self.heat = 0.0
            heater.value = self.heat
        iheater = self.heat * vheater / rheater   #calculate heater amps from the duty cycle and heater resistance
        self.pheater = vheater * iheater   #calculate heater power in watts
        iheater_mA = iheater * 1000.0   #convert heater current to milliamps for display
        self.mainTabs.children['Control'].children['labelHcurrent'].set_text(f'{iheater_mA:.1f}')
        self.mainTabs.children['Control'].children['labelHpower'].set_text(f'{self.pheater:.3f}')
        if T > -499.0:
            self.Tprev = T
        
        #Generate the strip chart if all sensors have at least one measured sample in.
        if allChannelsIn:
            x2a = []; y1a = []; y2a = []
            p = []   #initialize array of Matplotlib plot objects, needed for making the legend
            self.mpl.ax.clear()  #Clear the previous plots. Unfortunately, this clears the axis labels, too.
            self.mpl.y2ax.clear()
            for i in range(0, Nbuffers):
                xlist = self.xdata[i].readtimespan(xspan + update_interval_sec)  #read the X data (time) from the buffer
                ylist = self.ydata[i].read(len(xlist))  #read the Y data (temperature or power) from the buffer
                if not self.unitIsCelcius:
                    ylist = [CtoF(y) for y in ylist]
                #Plot the data using each plot's assigned color and name. Append each plot object to p[].
                if i < 2:
                    p.append(self.mpl.ax.plot(xlist, ylist, color=plotColors[i], label=plotNames[i])[0])
                else:
                    p.append(self.mpl.y2ax.plot(xlist, ylist, color=plotColors[i], label=plotNames[i])[0])
                x2a.append(xlist[-1])
                y1a.append(min(ylist))
                y2a.append(max(ylist))
            
            #Calculate the X and Y axes limits (x1, x2) and (y1, y2)
            x2 = max(x2a)
            if x2 < xspan:
                x2 = xspan
                x1 = 0.0
            else:
                x1 = x2 - xspan
            if yAuto:
                y1 = math.floor(min(y1a)); y2 = math.ceil(max(y2a))
            elif self.unitIsCelcius:
                y1 = ymin; y2 = ymax
            else:
                y1 = math.floor(CtoF(ymin)); y2 = math.ceil(CtoF(ymax))
                
            #Generate the new graph and update the display
            self.mpl.ax.set(xlabel='Time (s)',
                ylabel='Temperature (deg ' + ('C' if self.unitIsCelcius else 'F') + ')',
                autoscale_on=False, xlim=(x1, x2), ylim=(y1, y2),
                title='Temperature and Heater Power vs. Time')
            self.mpl.y2ax.set(ylabel='Heater Power (W)', autoscale_on=False, ylim=(y2min, y2max))
            self.mpl.ax.legend(handles=p, loc='upper left')
            self.mpl.update()

    #FUNCTION main() is called by the REMI engine once at program start.
    def main(self):
        self.xdata = []; self.ydata = []
        for i in range(0, Nbuffers):   #allocate the data buffers
            self.xdata.append(CircBuff(buffer_length))
            #self.ydata.append(CircBuff(buffer_length, True))  #True for filtering
            self.ydata.append(CircBuff(buffer_length))
        self.unitIsCelcius = True
        self.reftime = time.time()
        self.Tprev = -500.0
        self.heat = 0.0
        self.pheater = 0.0
        self.Henable = False
        self.Tcontrol_on = False
        self.Tsetpoint = 20.0
        self.daq_paused = False
        self.daq_running = True
        t = threading.Thread(target=self.daq_process)
        t.start()   #start the DAQ Process thread
        return self.construct_ui()

    #FUNCTION construct_ui() consists mostly of Python code generated by the REMI Editor,
    #which you can use to layout the web page and its indicators, text, images, and controls.
    def construct_ui(self):
        #DON'T MAKE CHANGES HERE, THIS METHOD GETS OVERWRITTEN WHEN SAVING IN THE EDITOR
        mainTabs = TabBox()
        mainTabs.attr_editor_newclass = False
        mainTabs.css_height = "340.0px"
        mainTabs.css_left = "15.0px"
        mainTabs.css_margin = "0px"
        mainTabs.css_position = "absolute"
        mainTabs.css_top = "15.0px"
        mainTabs.css_width = "720.0px"
        mainTabs.variable_name = "mainTabs"
        contControl = Container()
        contControl.attr_editor_newclass = False
        contControl.css_height = "260.0px"
        contControl.css_left = "15.0px"
        contControl.css_margin = "0px"
        contControl.css_position = "absolute"
        contControl.css_top = "45.0px"
        contControl.css_width = "554.0px"
        contControl.variable_name = "contControl"
        checkHenable = CheckBoxLabel()
        checkHenable.attr_editor_newclass = False
        checkHenable.css_align_items = "center"
        checkHenable.css_display = "flex"
        checkHenable.css_flex_direction = "row"
        checkHenable.css_height = "30.0px"
        checkHenable.css_justify_content = "space-around"
        checkHenable.css_left = "20px"
        checkHenable.css_margin = "0px"
        checkHenable.css_position = "absolute"
        checkHenable.css_top = "10px"
        checkHenable.css_width = "165.0px"
        checkHenable.text = "Heater Power Enable"
        checkHenable.variable_name = "checkHenable"
        contControl.append(checkHenable,'checkHenable')
        checkTCenable = CheckBoxLabel()
        checkTCenable.attr_editor_newclass = False
        checkTCenable.css_align_items = "center"
        checkTCenable.css_display = "flex"
        checkTCenable.css_flex_direction = "row"
        checkTCenable.css_height = "30.0px"
        checkTCenable.css_justify_content = "space-around"
        checkTCenable.css_left = "20px"
        checkTCenable.css_margin = "0px"
        checkTCenable.css_position = "absolute"
        checkTCenable.css_top = "40px"
        checkTCenable.css_width = "270.0px"
        checkTCenable.text = "Temperature Feedback Control Enable"
        checkTCenable.variable_name = "checkTCenable"
        contControl.append(checkTCenable,'checkTCenable')
        labelTsetpoint = Label()
        labelTsetpoint.attr_editor_newclass = False
        labelTsetpoint.css_border_style = "solid"
        labelTsetpoint.css_border_width = "1px"
        labelTsetpoint.css_font_size = "30px"
        labelTsetpoint.css_font_weight = "bold"
        labelTsetpoint.css_height = "36px"
        labelTsetpoint.css_left = "19.0px"
        labelTsetpoint.css_margin = "0px"
        labelTsetpoint.css_position = "absolute"
        labelTsetpoint.css_top = "105.0px"
        labelTsetpoint.css_width = "115.0px"
        labelTsetpoint.text = f'{self.Tsetpoint:.2f}'
        labelTsetpoint.variable_name = "labelTsetpoint"
        contControl.append(labelTsetpoint,'labelTsetpoint')
        label0 = Label()
        label0.attr_editor_newclass = False
        label0.css_height = "22.0px"
        label0.css_left = "21.0px"
        label0.css_margin = "0px"
        label0.css_position = "absolute"
        label0.css_top = "87px"
        label0.css_width = "102.0px"
        label0.text = "T Setpoint"
        label0.variable_name = "label0"
        contControl.append(label0,'label0')
        label1 = Label()
        label1.attr_editor_newclass = False
        label1.css_font_size = "30px"
        label1.css_height = "37.0px"
        label1.css_left = "142.0px"
        label1.css_margin = "0px"
        label1.css_position = "absolute"
        label1.css_top = "106px"
        label1.css_width = "44.0px"
        label1.text = "C"
        label1.variable_name = "label1"
        contControl.append(label1,'label1')
        labelTmeasured = Label()
        labelTmeasured.attr_editor_newclass = False
        labelTmeasured.css_border_style = "solid"
        labelTmeasured.css_border_width = "1px"
        labelTmeasured.css_font_size = "30px"
        labelTmeasured.css_font_weight = "bold"
        labelTmeasured.css_height = "36px"
        labelTmeasured.css_left = "190px"
        labelTmeasured.css_margin = "0px"
        labelTmeasured.css_position = "absolute"
        labelTmeasured.css_top = "105.0px"
        labelTmeasured.css_width = "115px"
        labelTmeasured.text = "-.--"
        labelTmeasured.variable_name = "labelTmeasured"
        contControl.append(labelTmeasured,'labelTmeasured')
        label2 = Label()
        label2.attr_editor_newclass = False
        label2.css_height = "23.0px"
        label2.css_left = "192.0px"
        label2.css_margin = "0px"
        label2.css_position = "absolute"
        label2.css_top = "88.0px"
        label2.css_width = "92.0px"
        label2.text = "T Measured"
        label2.variable_name = "label2"
        contControl.append(label2,'label2')
        label3 = Label()
        label3.attr_editor_newclass = False
        label3.css_font_size = "30px"
        label3.css_height = "38.0px"
        label3.css_left = "312px"
        label3.css_margin = "0px"
        label3.css_position = "absolute"
        label3.css_top = "106px"
        label3.css_width = "47.0px"
        label3.text = "C"
        label3.variable_name = "label3"
        contControl.append(label3,'label3')
        labelHcurrent = Label()
        labelHcurrent.attr_editor_newclass = False
        labelHcurrent.css_border_style = "solid"
        labelHcurrent.css_border_width = "1px"
        labelHcurrent.css_font_size = "30px"
        labelHcurrent.css_font_weight = "bold"
        labelHcurrent.css_height = "36px"
        labelHcurrent.css_left = "363px"
        labelHcurrent.css_margin = "0px"
        labelHcurrent.css_position = "absolute"
        labelHcurrent.css_top = "105px"
        labelHcurrent.css_width = "115px"
        labelHcurrent.text = "-.-"
        labelHcurrent.variable_name = "labelHcurrent"
        contControl.append(labelHcurrent,'labelHcurrent')
        label4 = Label()
        label4.attr_editor_newclass = False
        label4.css_height = "21.0px"
        label4.css_left = "365.0px"
        label4.css_margin = "0px"
        label4.css_position = "absolute"
        label4.css_top = "88.0px"
        label4.css_width = "88.0px"
        label4.text = "H Current"
        label4.variable_name = "label4"
        contControl.append(label4,'label4')
        label5 = Label()
        label5.attr_editor_newclass = False
        label5.css_font_size = "30px"
        label5.css_height = "40.0px"
        label5.css_left = "486.0px"
        label5.css_margin = "0px"
        label5.css_position = "absolute"
        label5.css_top = "105px"
        label5.css_width = "64.0px"
        label5.text = "mA"
        label5.variable_name = "label5"
        contControl.append(label5,'label5')
        labelHpower = Label()
        labelHpower.attr_editor_newclass = False
        labelHpower.css_border_style = "solid"
        labelHpower.css_border_width = "1px"
        labelHpower.css_font_size = "30px"
        labelHpower.css_font_weight = "bold"
        labelHpower.css_height = "36px"
        labelHpower.css_left = "364px"
        labelHpower.css_margin = "0px"
        labelHpower.css_position = "absolute"
        labelHpower.css_top = "185px"
        labelHpower.css_width = "115px"
        labelHpower.text = "-.---"
        labelHpower.variable_name = "labelHpower"
        contControl.append(labelHpower,'labelHpower')
        label6 = Label()
        label6.attr_editor_newclass = False
        label6.css_height = "23.0px"
        label6.css_left = "366.0px"
        label6.css_margin = "0px"
        label6.css_position = "absolute"
        label6.css_top = "168.0px"
        label6.css_width = "79.0px"
        label6.text = "H Power"
        label6.variable_name = "label6"
        contControl.append(label6,'label6')
        label7 = Label()
        label7.attr_editor_newclass = False
        label7.css_font_size = "30px"
        label7.css_height = "39.0px"
        label7.css_left = "487px"
        label7.css_margin = "0px"
        label7.css_position = "absolute"
        label7.css_top = "185px"
        label7.css_width = "50.0px"
        label7.text = "W"
        label7.variable_name = "label7"
        contControl.append(label7,'label7')
        buttonAdd5 = Button()
        buttonAdd5.attr_editor_newclass = False
        buttonAdd5.css_font_size = "25px"
        buttonAdd5.css_height = "39.0px"
        buttonAdd5.css_left = "24.0px"
        buttonAdd5.css_margin = "0px"
        buttonAdd5.css_position = "absolute"
        buttonAdd5.css_top = "160.0px"
        buttonAdd5.css_width = "43.0px"
        buttonAdd5.text = "+5"
        buttonAdd5.variable_name = "buttonAdd5"
        contControl.append(buttonAdd5,'buttonAdd5')
        buttonSubtract5 = Button()
        buttonSubtract5.attr_editor_newclass = False
        buttonSubtract5.css_font_size = "25px"
        buttonSubtract5.css_height = "39px"
        buttonSubtract5.css_left = "89px"
        buttonSubtract5.css_margin = "0px"
        buttonSubtract5.css_position = "absolute"
        buttonSubtract5.css_top = "160.0px"
        buttonSubtract5.css_width = "43px"
        buttonSubtract5.text = "-5"
        buttonSubtract5.variable_name = "buttonSubtract5"
        contControl.append(buttonSubtract5,'buttonSubtract5')
        buttonAdd1 = Button()
        buttonAdd1.attr_editor_newclass = False
        buttonAdd1.css_font_size = "25px"
        buttonAdd1.css_height = "39px"
        buttonAdd1.css_left = "24.0px"
        buttonAdd1.css_margin = "0px"
        buttonAdd1.css_position = "absolute"
        buttonAdd1.css_top = "211px"
        buttonAdd1.css_width = "43px"
        buttonAdd1.text = "+1"
        buttonAdd1.variable_name = "buttonAdd1"
        contControl.append(buttonAdd1,'buttonAdd1')
        buttonSubtract1 = Button()
        buttonSubtract1.attr_editor_newclass = False
        buttonSubtract1.css_font_size = "25px"
        buttonSubtract1.css_height = "39px"
        buttonSubtract1.css_left = "89px"
        buttonSubtract1.css_margin = "0px"
        buttonSubtract1.css_position = "absolute"
        buttonSubtract1.css_top = "211.0px"
        buttonSubtract1.css_width = "43px"
        buttonSubtract1.text = "-1"
        buttonSubtract1.variable_name = "buttonSubtract1"
        contControl.append(buttonSubtract1,'buttonSubtract1')
        buttonEndProgram = Button()
        buttonEndProgram.attr_editor_newclass = False
        buttonEndProgram.css_height = "51.0px"
        buttonEndProgram.css_left = "452.0px"
        buttonEndProgram.css_margin = "0px"
        buttonEndProgram.css_position = "absolute"
        buttonEndProgram.css_top = "19.0px"
        buttonEndProgram.css_width = "81.0px"
        buttonEndProgram.text = "End Server Process"
        buttonEndProgram.variable_name = "buttonEndProgram"
        contControl.append(buttonEndProgram,'buttonEndProgram')
        buttonClearChart = Button()
        buttonClearChart.attr_editor_newclass = False
        buttonClearChart.css_height = "51px"
        buttonClearChart.css_left = "246px"
        buttonClearChart.css_margin = "0px"
        buttonClearChart.css_position = "absolute"
        buttonClearChart.css_top = "200.0px"
        buttonClearChart.css_width = "62.0px"
        buttonClearChart.text = "Clear Chart"
        buttonClearChart.variable_name = "buttonClearChart"
        contControl.append(buttonClearChart,'buttonClearChart')
        mainTabs.append(contControl,'Control')
        graphContainer = Container()
        graphContainer.attr_editor_newclass = False
        graphContainer.css_border_color = "rgb(25,31,37)"
        graphContainer.css_border_style = "solid"
        graphContainer.css_border_width = "1%"
        graphContainer.css_display = "none"
        graphContainer.css_height = "280px"
        graphContainer.css_left = "15px"
        graphContainer.css_margin = "0px"
        graphContainer.css_position = "absolute"
        graphContainer.css_top = "45px"
        graphContainer.css_width = "680px"
        graphContainer.variable_name = "graphContainer"
        self.mpl = MatplotImage(width=660, height=265)
        self.mpl.style['margin'] = '0px'
        self.mpl.ax.set(xlabel='Time (s)', ylabel='Temperature (deg C)',
            autoscale_on=False, xlim=(0.0, xspan), ylim=(ymin, ymax),
            title='Temperature and Heater Power vs. Time')
        self.mpl.y2ax = self.mpl.ax.twinx()
        self.mpl.y2ax.set(ylabel='Heater Power (W)', autoscale_on=False, ylim=(y2min, y2max))
        self.mpl.y2ax.yaxis.label.set_color(plotColors[2])
        tkw = dict(size=4, width=1.5)
        self.mpl.y2ax.tick_params(axis='y', colors=plotColors[2], **tkw)
        self.mpl.update()
        graphContainer.append(self.mpl)
        mainTabs.append(graphContainer,'Graph')
        mainTabs.children['Control'].children['checkHenable'].onchange.do(self.onchange_checkHenable)
        mainTabs.children['Control'].children['checkTCenable'].onchange.do(self.onchange_checkTCenable)
        mainTabs.children['Control'].children['buttonAdd5'].onclick.do(self.onclick_buttonAdd5)
        mainTabs.children['Control'].children['buttonSubtract5'].onclick.do(self.onclick_buttonSubtract5)
        mainTabs.children['Control'].children['buttonAdd1'].onclick.do(self.onclick_buttonAdd1)
        mainTabs.children['Control'].children['buttonSubtract1'].onclick.do(self.onclick_buttonSubtract1)
        mainTabs.children['Control'].children['buttonEndProgram'].onclick.do(self.onclick_buttonEndProgram)
        mainTabs.children['Control'].children['buttonClearChart'].onclick.do(self.onclick_buttonClearChart)
 
        self.mainTabs = mainTabs
        return self.mainTabs
    
    def onchange_checkHenable(self, emitter, value):
        self.Henable = value
        
    def onchange_checkTCenable(self, emitter, value):
        self.Tcontrol_on = value
        
    def onclick_buttonAdd5(self, emitter):
        self.Tsetpoint += 5.0
        self.mainTabs.children['Control'].children['labelTsetpoint'].set_text(f'{self.Tsetpoint:.2f}')
        
    def onclick_buttonSubtract5(self, emitter):
        self.Tsetpoint -= 5.0
        self.mainTabs.children['Control'].children['labelTsetpoint'].set_text(f'{self.Tsetpoint:.2f}')
        
    def onclick_buttonAdd1(self, emitter):
        self.Tsetpoint += 1.0
        self.mainTabs.children['Control'].children['labelTsetpoint'].set_text(f'{self.Tsetpoint:.2f}')
        
    def onclick_buttonSubtract1(self, emitter):
        self.Tsetpoint -= 1.0
        self.mainTabs.children['Control'].children['labelTsetpoint'].set_text(f'{self.Tsetpoint:.2f}')
        
    def onclick_buttonClearChart(self, emitter):
        self.daq_paused = True   #Pause DAQ thread and wait for it to actually pause
        sleep(1.0*buswait)
        self.reftime = time.time()
        for i in range(0, Nbuffers):
            self.xdata[i].clear()
            self.ydata[i].clear()
        self.daq_paused = False   #Unpause DAQ thread now that buffers, pointers, and flags are fully cleared
        
    def onclick_buttonEndProgram(self, emitter):
        self.daq_running = False
        self.daq_paused = False
        sleep(2.0*buswait)
        heater.value = 0.0
        sleep(1.0*buswait)
        self.close()

#configuration hash set below is just for the REMI UI Editor
configuration = {'config_project_name': 'Thermistors', 'config_resourcepath': './res/'}

#The REMI start() function is called below to start serving the web page.
localmode = False
if localmode:
    ipaddr = '127.0.0.1'; show_browser = True
else:
    ipaddr = '192.168.1.193'; show_browser = False

if __name__ == "__main__":
    remi.start(Thermistors, address=ipaddr, port=8081, update_interval=update_interval_sec,
          multiple_instance=False, enable_file_cache=False, start_browser=show_browser)