Sunday, May 24, 2020

Thermistors_Triple 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 measured how the surface temperature of a ceramic coffee mug changes after hot coffee is poured in. Three temperature sensors are taped to the mug in three different places. Sensor 0 is on the side of the mug near the bottom, Sensor 1 is near the rim, and Sensor 2 is on the handle. The sensor is a thermistor (https://en.wikipedia.org/wiki/Thermistor) which is a tiny resistor that changes resistance strongly with temperature. Measurement accuracy and resolution is plus or minus 0.01 degree Celsius.

The hardware in the video is a Raspberry Pi 4B credit-card-sized computer running Raspbian Linux, a Pi-16ADC voltage-measuring HAT board screwed on top, and a few resistors and capacitors that I soldered onto the HAT that form the sensor circuit. I bought the Raspberry Pi and HAT at PiShop.us.

I wrote a Python program that commands and reads from the ADC chip on the HAT via the I2C communication bus. I used a very cool and powerful Python user interface (UI) library and live-updating web-server called REMI (https://github.com/dddomodossola/remi). The smartphone in the video, using its web browser app, displays the live measurements on a numeric display and on a strip chart drawn using the Matplotlib library (https://matplotlib.org). Black is Sensor 0, Red is Sensor 1, and Blue is Sensor 2. The display update rate is once per second.

Here's the Python code:


#!/usr/bin/python3

# THERMISTORS_TRIPLE PROGRAM FOR MEASURING AND DISPLAYING TEMPERATURE
# Version 0.5, 30-May-2020
# Copyright © 2020 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 sensor circuit. The program commands and reads from the LTC2497
# ADC chip on the HAT via the I2C communication bus.
#
# 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

#SET CONSTANTS
Nsensors = 3   #number of sensors to poll continuously
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   #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
update_interval_sec = 1.0
xspan = 30.0   #strip chart X axis span in seconds
buffer_length = 250
yAuto = True   #autorange the Y axis?
ymin = 20.0; ymax = 70.0   #initial Y axis range, and fixed if yAuto is False
plotColors = ['black', 'red', 'blue']
#Steinhart–Hart equation coefficients for TDK NTC Thermistor B57863S0103F040:
coeffA = 1.12532e-3; coeffB = 2.34873e-4; coeffC = 8.59509e-8

#FUNCTION CtoF() converts Celcius to Fahrenheit
def CtoF(degrees):
    return 1.8 * degrees + 32.0

#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 ADC channel used.
#If for example Nsensors = 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, length):
        self.buflen = length
        self.buffer = [0.0] * self.buflen
        self.ptr = 0
        self.full = False
        
    def add(self, value):
        self.buffer[self.ptr] = value
        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 #the application instance used to send updates
    
    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):

    #FUNCTION read_temperature() reads a channel's ADC counts via the I2C bus
    #and then calculates voltage then temperature.
    def read_temperature(self, ch_index):
        self.i2cbus.write_byte(i2caddr, adc_ch[ch_index])
        sleep(buswait)
        readarray = self.i2cbus.read_i2c_block_data(i2caddr, adc_ch[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
    
    #FUNCTION daq_process() is the data acquisition process running as a separate thread.
    #Each ADC channel takes 300 to 400 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):
        while self.daq_running:
            for i in range(0, Nsensors):
                sleep(buswait)
                while self.daq_paused:
                    sleep(buswait)
                if not self.daq_running:
                    break
                t = time.time() - self.reftime   #capture timestamp before the T reading
                self.ydata[i].add(self.read_temperature(i))   #read T
                self.xdata[i].add(t)   #write timestamp after T is done reading

    def __init__(self, *args, **kwargs):
        if not 'editing_mode' in kwargs.keys():
            super(Thermistors, self).__init__(*args, static_file_path={'my_res': './res/'})

    #FUNCTION idle() is called by the REMI engine once per display update interval.
    #This function's job is to update the display of the temperature values.
    def idle(self):
        allChannelsIn = True
        for i in range(0, Nsensors):
            n = self.ydata[i].size()
            if n > 0:
                T = self.ydata[i].readlast()   #get the latest T reading from the DAQ thread
                if not self.unitIsCelcius:
                    T = CtoF(T)   #convert Celcius to Fahrenheit
                Tstr = f'{T:.2f}'   #display value to 2 decimal places
            else:
                allChannelsIn = False
                Tstr = '-.--'
            self.mainContainer.children[self.textbox[i]].set_text(Tstr)
        
        #Generate the strip chart if all sensors have at least one measured sample in.
        if allChannelsIn:
            x2a = []; y1a = []; y2a = []
            self.mpl.ax.clear()  #Clear the previous plots. Unfortunately, this clears the axis labels, too.
            for i in range(0, Nsensors):
                xlist = self.xdata[i].readtimespan(xspan + 1.0)  #read the X data (time) from the buffer
                ylist = self.ydata[i].read(len(xlist))  #read the Y data (temperature) from the buffer
                if not self.unitIsCelcius:
                    ylist = [CtoF(y) for y in ylist]
                self.mpl.ax.plot(xlist, ylist, color=plotColors[i])  #plot the data using this sensor's color
                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='Three Temperatures vs. Time')
            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, Nsensors):   #allocate all the data buffers
            self.xdata.append(CircBuff(buffer_length))
            self.ydata.append(CircBuff(buffer_length))
        self.textbox = ['textTvalue0', 'textTvalue1', 'textTvalue2']
        self.daq_running = True
        self.daq_paused = False
        self.unitIsCelcius = True
        self.reftime = time.time()
        self.i2cbus = SMBus(1)   #initialize connection to the I2C bus
        t = threading.Thread(target=self.daq_process)
        t.start()   #start the DAQ Process thread
        return Thermistors.construct_ui(self)

    #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.
    @staticmethod
    def construct_ui(self):
        mainContainer = Container()
        mainContainer.attr_editor_newclass = False
        mainContainer.css_background_color = "rgb(236,246,204)"
        mainContainer.css_border_color = "rgb(25,31,37)"
        mainContainer.css_border_style = "solid"
        mainContainer.css_border_width = "5%"
        mainContainer.css_height = "240.0px"
        mainContainer.css_left = "10.0px"
        mainContainer.css_margin = "0px"
        mainContainer.css_position = "absolute"
        mainContainer.css_top = "15px"
        mainContainer.css_width = "315.0px"
        mainContainer.variable_name = "mainContainer"
        textTvalue0 = Label()
        textTvalue0.attr_editor_newclass = False
        textTvalue0.css_align_content = "stretch"
        textTvalue0.css_align_items = "center"
        textTvalue0.css_align_self = "center"
        textTvalue0.css_color = "rgb(0,0,0)"
        textTvalue0.css_font_size = "50px"
        textTvalue0.css_font_weight = "bold"
        textTvalue0.css_height = "75px"
        textTvalue0.css_justify_content = "center"
        textTvalue0.css_left = "15.0px"
        textTvalue0.css_margin = "0px"
        textTvalue0.css_position = "absolute"
        textTvalue0.css_text_align = "center"
        textTvalue0.css_top = "15px"
        textTvalue0.css_width = "180.0px"
        textTvalue0.text = "-.--"
        textTvalue0.variable_name = "textTvalue0"
        mainContainer.append(textTvalue0,'textTvalue0')
        btnDegUnit = Button()
        btnDegUnit.attr_editor_newclass = False
        btnDegUnit.css_font_size = "40px"
        btnDegUnit.css_height = "75.0px"
        btnDegUnit.css_left = "225px"
        btnDegUnit.css_margin = "0px"
        btnDegUnit.css_position = "absolute"
        btnDegUnit.css_top = "15px"
        btnDegUnit.css_width = "75.0px"
        btnDegUnit.text = "C"
        btnDegUnit.variable_name = "btnDegUnit"
        mainContainer.append(btnDegUnit,'btnDegUnit')
        textTvalue1 = Label()
        textTvalue1.attr_editor_newclass = False
        textTvalue1.css_align_items = "center"
        textTvalue1.css_align_self = "center"
        textTvalue1.css_color = "rgb(255,0,0)"
        textTvalue1.css_font_size = "50px"
        textTvalue1.css_font_weight = "bold"
        textTvalue1.css_height = "75.0px"
        textTvalue1.css_justify_content = "center"
        textTvalue1.css_left = "15.0px"
        textTvalue1.css_margin = "0px"
        textTvalue1.css_position = "absolute"
        textTvalue1.css_text_align = "center"
        textTvalue1.css_top = "90px"
        textTvalue1.css_width = "180.0px"
        textTvalue1.text = "-.--"
        textTvalue1.variable_name = "textTvalue1"
        mainContainer.append(textTvalue1,'textTvalue1')
        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_height = "215.0px"
        graphContainer.css_left = "0.0px"
        graphContainer.css_margin = "0px"
        graphContainer.css_position = "absolute"
        graphContainer.css_top = "255px"
        graphContainer.css_width = "340.0px"
        graphContainer.variable_name = "graphContainer"
        mainContainer.append(graphContainer,'graphContainer')
        textTvalue2 = Label()
        textTvalue2.attr_editor_newclass = False
        textTvalue2.css_align_items = "center"
        textTvalue2.css_align_self = "center"
        textTvalue2.css_color = "rgb(0,0,255)"
        textTvalue2.css_font_size = "50px"
        textTvalue2.css_font_weight = "bold"
        textTvalue2.css_height = "75px"
        textTvalue2.css_justify_content = "center"
        textTvalue2.css_left = "15px"
        textTvalue2.css_margin = "0px"
        textTvalue2.css_position = "absolute"
        textTvalue2.css_text_align = "center"
        textTvalue2.css_top = "165.0px"
        textTvalue2.css_width = "180px"
        textTvalue2.text = "-.--"
        textTvalue2.variable_name = "textTvalue2"
        mainContainer.append(textTvalue2,'textTvalue2')
        btnEndProcess = Button()
        btnEndProcess.attr_editor_newclass = False
        btnEndProcess.css_height = "45.0px"
        btnEndProcess.css_left = "210.0px"
        btnEndProcess.css_margin = "0px"
        btnEndProcess.css_position = "absolute"
        btnEndProcess.css_top = "495.0px"
        btnEndProcess.css_width = "90.0px"
        btnEndProcess.text = "End Server Process"
        btnEndProcess.variable_name = "btnEndProcess"
        mainContainer.append(btnEndProcess,'btnEndProcess')
        btnClearChart = Button()
        btnClearChart.attr_editor_newclass = False
        btnClearChart.css_height = "45px"
        btnClearChart.css_left = "15.0px"
        btnClearChart.css_margin = "0px"
        btnClearChart.css_position = "absolute"
        btnClearChart.css_top = "495.0px"
        btnClearChart.css_width = "90px"
        btnClearChart.text = "Clear Chart"
        btnClearChart.variable_name = "btnClearChart"
        mainContainer.append(btnClearChart,'btnClearChart')
        
        self.mpl = MatplotImage(width=340, height=200)
        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='Three Temperatures vs. Time')
        self.mpl.update()
        graphContainer.append(self.mpl)
        mainContainer.append(graphContainer,'graphContainer')
        
        mainContainer.children['btnDegUnit'].onclick.do(self.onclick_btnDegUnit)
        mainContainer.children['btnEndProcess'].onclick.do(self.onclick_btnEndProcess)
        mainContainer.children['btnClearChart'].onclick.do(self.onclick_btnClearChart)
        
        self.mainContainer = mainContainer
        return self.mainContainer
    
    def onclick_btnDegUnit(self, emitter):
        self.unitIsCelcius = not self.unitIsCelcius
        if self.unitIsCelcius:
            unitSymbol = 'C'
        else:
            unitSymbol = 'F'
        self.mainContainer.children['btnDegUnit'].set_text(unitSymbol)
        
    def onclick_btnClearChart(self, emitter):
        self.daq_paused = True   #Pause DAQ thread and wait for it to actually pause
        sleep(buswait)
        self.reftime = time.time()
        for i in range(0, Nsensors):
            self.xdata[i].clear()
            self.ydata[i].clear()
        self.daq_paused = False   #Unpause DAQ thread now that buffers, pointers, and flags are fully cleared
    
    #If the 'End Server Process' button is clicked, first stop the DAQ thread, wait,
    #then end the program. It might be a good idea depending on future usage
    #to require an admin password in order to end the program.
    def onclick_btnEndProcess(self, emitter):
        self.daq_running = False
        self.daq_paused = False
        sleep(2.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 = True
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)