Temp, Humidity and Pressure monitor/weather forecast/graphs

# (C) Paul Brace April 2022
# Temperature, Humidity and Pressure monitor with clock, weekly history V 1.0
# and weather forecast based on the Zambretti Forecaster
# Zamretti lookup table based on this article
#   https://web.archive.org/web/20110610213848/http:/www.meteormetrics.com/zambretti.htm
# This version uses the Pi Pico internal storage for the history
# storage files so you will have to use Thonny, or another program to
# access them from the board.

from machine import Pin, I2C, Timer, ADC
import utime as time
from ssd1306 import SSD1306_I2C
from bmp180 import BMP180
from dht11 import DHT11, InvalidChecksum, InvalidPulseCount
from myfont import myFont
import gc
from graph import oledGraph
from machine import RTC
from timeedit import timeAdjustment
from micropython import const
import micropython
import os

# Debug flag - set to true or false
DEBUG = False

# create clock object
rtc = RTC()                                        

# assign pin and create DHT11 object
pin = Pin(15, Pin.OUT, Pin.PULL_DOWN)
sensor = DHT11(pin)

# Set up mode, reset and adjust button pins
mode = Pin(17, Pin.IN, Pin.PULL_DOWN)      # Also up and day/hour
reset = Pin(16, Pin.IN, Pin.PULL_DOWN)     # Also down and month/minute
adjust = Pin(18, Pin.IN, Pin.PULL_DOWN)    # Also enter/move to next screen

# To capture button bounce
lastModePress = time.ticks_ms()
lastResetPress = time.ticks_ms()

# Set up ADC(0) to read voltage for battery monitor
analogValue = ADC(26)

# Simulate an enum for display modes
dispTime = const(0)             # Date and time display & summary
dispPress = const(1)            # Barometer display
dispPressGraph = const(2)       # Pressure recent history graph
dispTemp = const(3)             # Temperature display
dispTempGraph = const(4)        # Temperature recent history graph
dispHumid = const(5)            # Humidity display
dispHumidGraph = const(6)       # Humidity recent history graph
dispPressGraphScroll = const(7)  # Pressure history graph from start of file
dispTempGraphScroll = const(8)  # Temperature history graph from start of file
dispHumidGraphScroll = const(9) # Humidity history graph from start of file
dispPressGraphScrollPast = const(10)  # Temperature history graph from previous file displayed from start of file
dispTempGraphScrollPast = const(11)  # Temperature history graph from previous file displayed from start of file
dispHumidGraphScrollPast = const(12) # Humidity history graph from previous file displayed from start of file

currentMode = dispTime          # Current display setting

# Forecast table based on the Zambretti Forecaster
# the '#' is used to split the forecast for display
forecast = ["Settled Fine",
            "Fine Weather",
            "Becoming Fine",
            "Fine Becoming#Less Settled",
            "Fine, Possibly#showers",
            "Fairly Fine,#Improving",
            "Fairly Fine, Pos#showers, early",
            "Fairly Fine,#Showery Later",
            "Showery Early,#Improving",
            "Changeable#Mending",
            "Fairly Fine#Showers likely",
            "Rather Unsettled#Clearing Later",
            "Unsettled,#Probably Improve",
            "Showery, Bright# Intervals",
            "Showery, Becoming#more unsettled",
            "Changeable#some rain",
            "Unsettled, short#fine Intervals",
            "Unsettled,#Rain later",
            "Unsettled,#Rain at times",
            "Very Unsettled,#Finer at times",
            "Rain at times,#worse later",
            "Rain at times,#then very unsettled",
            "Rain at Frequent#Intervals",
            "Very Unsettled,#Rain",
            "Stormy, possibly#improving",
            "Stormy,#much rain"]    

# Set up the oled display
WIDTH  = const(128)            
HEIGHT = const(64)

i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=200000)       # Init I2C using pins GP8 & GP9 (default I2C0 pins)

oled = SSD1306_I2C(WIDTH, HEIGHT, i2c)                  # Init oled display

myfont = myFont(oled)                                   # Create myFont object

graph = oledGraph(oled)                                 # Create graph object

bmp180 = BMP180(i2c)                                    # Init bmp180 also on ic2
bmp180.oversample_sett = 2
bmp180.baseline = 101325

# Debug Print out any addresses found
if DEBUG:
    devices = i2c.scan()
    if devices:
        for d in devices:
            print("IC2 device address: ",hex(d))

# File numbers will start at 1 and increment by 1 each week
# 0 used to indicate no files yet created
fileNumber = 0

# if first is True then monitor just switched on so will
# increment file number and create a new history file
first = True

# Flag set if there is an error on saving history
saveError = False
# Set to true if voltage too low
savingSuspended = False           

# Constants to control history file entries
MINUTES = const(60)            # number of minutes between calls to save data
FILE_PERIOD = const(10080)     # minutes - 1,440 in a day 10,080 in a week

temp = 0            # latest temperature reading
humid = 0           # latest humidity reading
press = 0           # latest pressure reading
count = 0           # number of readings in history period

pressSmoothing = []        # List of last 5 pressure readings
tempSmoothing = []         # List of last 5 temp readings 
humidSmoothing = []        # List of last 5 humid readings 

# Timer to trigger history store
history = Timer()

# Used to hold max and min since start-up
maxTemp = -99          # maximum temp
maxHumid = -99         # maximum humidity
minTemp = 99           # minimum temp
minHumid = 99          # minimum humidity

# used to stop constant refresh of graphs
currentDisplay = 0   

# Used for smoothing battery voltage readings
accVolts = 0
voltsCount = 0

# flags to allow interrupt of sleeping when button pressed
buttonPressed = False
adjusting = False

# Current elevation in feet used to calculate
# pressure at sea level
elevation = 180          

# Met office definitions - at sea level
HIGH_PRESS = 1022.69
LOW_PRESS = 1009.15

# Set a default time in case no config file with latest time
#now = (YEAR, MONTH, DAY, DAY number, HOUR, MINUTE, SECOND, micro_SECOND)
rtc.datetime((2022, 1, 1, 0, 12, 0, 0, 0))

# Display time out
DISP_TIME_OUT = const(10)       # Seconds after which display will revert to show time
displayShown = 0                # Time display was shown  

# List to store pressure readings in memory - saved every 5 minutes
# used to calculate movement
pressReadings = []

FIVE_MIN = 300000                    # Milliseconds in 5 minutes

# Time last updated set to give 1 minute settling down
# period before first pressure record saved
lastPressUpdate = time.ticks_ms() - FIVE_MIN + 60000

# Update log file used for main events and exceptions
def updateLog(event):
    global rtc, savingSuspended
    if not savingSuspended:
        try:
            log = open("monitorlog.txt", "a")
            now = rtc.datetime()
            formatstring = '{:02d}/{:02d}/{:04d}-{:02d}h{:02d}m{:02d}s    '
            log.write(formatstring.format(now[2], now[1], now[0], now[4], now[5], now[6]) + event + "\n")
            log.flush()
            log.close()
        except Exception as e:
            print("Error updating log file:" + str(e))

# One or 2 line message with pause
def message(text1, text2, pause):
    oled.fill(0)
    if text2 == '':
        pos = 30
    else:
        pos = 20
    oled.text(text1, 0, pos)
    if text2 != "":
       oled.text(text2, 0 ,pos + 15)
    oled.show()
    time.sleep(pause)

# Config file holds the current file number, elevation and last saved time
# time updated after each new record written to history file
def saveConfig(fileNumber):
    global rtc, savingSuspended, elevation
    if not savingSuspended:
        try:
            log = open("config.txt", "w")
            now = rtc.datetime()
            seconds = time.mktime(now)                # documentation indicated this returns seconds but appears to
                                                      # actually appears to return return minutes
            log.write(str(seconds) + "\n")
            log.write(str(fileNumber) + "\n")
            log.write(str(elevation) + "\n")
            log.flush()
            log.close()
        except Exception as e:
            print("Config file write error:" + str(e))

# Attempt to load config file and if fails create a new file
def loadConfig():
    global fileNumber, rtc, savingSuspended, elevation
    try:
        log = open("config.txt", "r")
        line = log.readline()
        seconds = int(line[0:len(line)-1])     # remove trailing \n
        now = time.gmtime(seconds)
        rtc.datetime(now)
        # remove the trailing \n nad convert
        line = log.readline()
        fileNumber = int(line[0:len(line)-1])
        line = log.readline()
        elevation = int(line[0:len(line)-1])
        log.close()
    except Exception as e:
        # Appears config file not yet created so start afresh
        print("Config file read error: ", e)
        saveConfig(fileNumber)

# Write file headers when new history files created
def writeFileHeader(fileName, fileNumber):
    updateLog("Creating new history file - " + fileName + "(" + str(fileNumber) + ")")
    now = rtc.datetime()
    log = open(fileName + "(" + str(fileNumber) + ").txt", "w")
    log.write("Time: {:02d}:{:02d} Date: {:02d}/{:02d}/{:04d}\n".format(now[4], now[5], now[2], now[1], now[0]))
    log.write("Time interval {:.2f} minutes\n".format(MINUTES))
    log.flush()
    log.close()

# Get the current battery voltage
# To calculate the actual voltage from the monitor pin reading.
# Using 1m and 330k ohm resistors divides the voltage by approx 4
# You may wany to substitute actual values of resistors in an equation (R1 + R2)/R2
# E.g. (1000 + 330)/330 = 4.03
# Alternatively take the voltage reading across the battery and from the joint between 
# the 2 resistors to ground and divide one by the other to get the value.
def readVoltage():
    return analogValue.read_u16() / 65536 * 3.3 * 4.03

# Set up with current reading
lastVolts = readVoltage()

# Routine to smooth the voltage reading
def getVoltage():
    global lastVolts, accVolts, voltsCount
    voltsCount += 1
    accVolts += readVoltage()
    # If 10 readings then calc new average otherwise return last average
    if voltsCount > 9:
        lastVolts = accVolts / voltsCount
        accVolts = 0
        voltsCount = 0
    return lastVolts

def testFreeSpace():
    global saveError, savingSuspended
    # Get status of flash memory and check enough free blocks
    # to store another set of files
    status = os.statvfs("")
    # status[3] = free blocks
    if status[3] <= 6:
        message("Insufficient", 'flash space ' + str(status[3]), 10)
        updateLog("Insufficient flash space to create new file set - free blocks " + str(status[3]))
        updateLog("History saving suspended")
        saveError = True
        savingSuspended = True
        return False
    updateLog("Flash memory free blocks " + str(status[3]))
    return True

# Store history data to file
def saveHistory(Timer):
    global temp, humid, press, count, first, fileNumber, saveError, savingSuspended
    if not count or savingSuspended:
        return
    try:
        message("Saving data...", '', 0)
        now = rtc.datetime()
        # Check if a file has been created
        if first:
            # Must be first run so write header for file
            if not testFreeSpace():
                return
            fileNumber += 1
            writeFileHeader("temperature", fileNumber)
            writeFileHeader("humidity", fileNumber)
            writeFileHeader("pressure", fileNumber)
            if DEBUG:
                writeFileHeader("voltage", fileNumber)
            saveConfig(fileNumber)
            first = False
        # Check size of file and if holding 1 week of readings start a new file
        # 56 byte header + 24 bytes per entry
        #log = open("temperature(" + str(fileNumber) + ").txt", "a")
        #size = log.tell()   This does not appear to work as returns 0 even though "a" should set to end of file
        #log.close()
        entriesInFilePeriod = FILE_PERIOD / MINUTES
        file_stats = os.stat("temperature(" + str(fileNumber) + ").txt")
        if file_stats[6] >= (56 + 24 * entriesInFilePeriod):
            if not testFreeSpace():
                return
            fileNumber += 1
            writeFileHeader("temperature", fileNumber)
            writeFileHeader("humidity", fileNumber)
            writeFileHeader("pressure", fileNumber)
            if DEBUG:
                writeFileHeader("voltage", fileNumber)
        log = open("temperature(" + str(fileNumber) + ").txt", "a")
        formatstring = '{:02d}/{:02d}/{:04d}-{:02d}h{:02d}m,{:2.2f}'
        log.write(formatstring.format(now[2], now[1], now[0], now[4], now[5], temp) + "\n")
        log.flush()
        log.close()
        log = open("humidity(" + str(fileNumber) + ").txt", "a")
        log.write(formatstring.format(now[2], now[1], now[0], now[4], now[5], humid) + "\n")
        log.flush()
        log.close()
        log = open("pressure(" + str(fileNumber) + ").txt", "a")
        log.write(formatstring.format(now[2], now[1], now[0], now[4], now[5], press) + "\n")
        log.flush()
        log.close()
        # Record battery voltage if in Debug mode
        if DEBUG:
            log = open("voltage(" + str(fileNumber) + ").txt", "a")
            log.write(formatstring.format(now[2], now[1], now[0], now[4], now[5], getVoltage()) + "\n")
            log.flush()
            log.close()
        # save config file to update time stamp and file number
        saveConfig(fileNumber)
        saveError = False
    except Exception as e:
        print(e)
        oled.fill(0)
        oled.text("Error:", 0, 10)
        oled.text("Unable to save", 0, 25)
        oled.text("readings.", 0, 40)
        oled.text("Restart monitor.", 0, 55)
        oled.show()
        saveError = True
        time.sleep(10)
    # Reset count so can check that new readings have been made since last save
    count = 0

# Set a timer to save the history data
def setTimer():
    global history
    history.init(freq=1/(MINUTES * 60), mode=Timer.PERIODIC, callback=saveHistory)

# Stop the timer calling the history data
def stopTimer():
    global history
    history.deinit()

# Call display for current mode
def updateDisplay():
    global currentMode, currentDisplay, fileNumber
    if currentMode == dispTime:
        showTime()
    elif currentMode == dispPress:
        showPress()
    elif currentMode == dispPressGraph and currentDisplay != dispPressGraph:
        graph.showGraph("pressure(" + str(fileNumber) + ").txt", False, False)
    elif currentMode == dispTemp:
        showTemp()
    elif currentMode == dispTempGraph and currentDisplay != dispTempGraph:
        graph.showGraph("temperature(" + str(fileNumber) + ").txt", False, False)
    elif currentMode == dispHumid:
        showHumid()
    elif currentMode == dispHumidGraph and currentDisplay != dispHumidGraph:
        graph.showGraph("humidity(" + str(fileNumber) + ").txt", False, False)
    elif currentMode == dispPressGraphScroll and\
             currentDisplay != dispPressGraphScroll:
        graph.showGraph("pressure(" + str(fileNumber) + ").txt", True, False)
    elif currentMode == dispTempGraphScroll and\
             currentDisplay != dispTempGraphScroll:
        graph.showGraph("temperature(" + str(fileNumber) + ").txt", True, False)
    elif currentMode == dispHumidGraphScroll and\
             currentDisplay != dispHumidGraphScroll:
        graph.showGraph("humidity(" + str(fileNumber) + ").txt", True, False)
    elif currentMode == dispPressGraphScrollPast and\
             currentDisplay != dispPressGraphScrollPast:
        graph.showGraph("pressure(" + str(fileNumber - 1) + ").txt", True, True)
    elif currentMode == dispTempGraphScrollPast and\
             currentDisplay != dispTempGraphScrollPast:
        graph.showGraph("temperature(" + str(fileNumber - 1) + ").txt", True, True)
    elif currentMode == dispHumidGraphScrollPast and\
             currentDisplay != dispHumidGraphScrollPast:
        graph.showGraph("humidity(" + str(fileNumber - 1) + ").txt", True, True)
    currentDisplay = currentMode
        
# Mode button pressed
def changeMode(pin):
    global lastModePress, currentMode, buttonPressed
    # allow 1 second after press to stop bounce and allow for release
    if time.ticks_ms() - lastModePress > 1000:
        lastModePress = time.ticks_ms()
        currentMode += 1;
        if currentMode > dispHumidGraphScrollPast:
            currentMode = dispTime
        buttonPressed = True

# Reset button pressed
def resetPressed(pin):
    global lastResetPress, buttonPressed, maxTemp, maxHumid, minTemp, minHumid
    # allow 1 second after press to stop bounce and rallow for elease
    if time.ticks_ms() - lastResetPress > 1000:
        lastResetPress = time.ticks_ms()
        maxTemp = -99          # maximum temp
        maxHumid = -99         # maximum humidity
        minTemp = 99           # minimum temp
        minHumid = 99          # minimum humidity
        buttonPressed = True

# Adjust pin pressed
def adjustPressed(pin):
    global adjusting, buttonPressed
    adjusting = True
    buttonPressed = True

# Set up interrupts for button pins
def setPinHandlers():
    mode.irq(trigger=Pin.IRQ_FALLING, handler = changeMode)
    reset.irq(trigger=Pin.IRQ_FALLING, handler = resetPressed)
    adjust.irq(trigger=Pin.IRQ_FALLING, handler = adjustPressed)

# Clear handlers so can use buttons in adjust mode
def clearPinHandlers():
    mode.irq(handler=None)
    reset.irq(handler=None)
    adjust.irq(handler=None)

# Display Temperature
def showTemp():
    global temp, maxTemp, minTemp
    oled.fill(0);                  
    myfont.text("Temp:",5,5)
    myfont.text(chr(33),25,25)  # Up arrow
    myfont.text(chr(34),25,45)  # Down arrow
    myfont.text("{:2.1f}".format(temp),70,5)
    myfont.text("{:2.1f}".format(maxTemp),70,25)
    myfont.text("{:2.1f}".format(minTemp),70,45)
    oled.text("c", 110, 5)
    oled.text("c", 110, 25)
    oled.text("c", 110, 45)
    oled.show()

# Display Humidity
def showHumid():
    global humid, maxHumid, minHumid
    oled.fill(0);              
    myfont.text("Humid:",10,5)
    myfont.text(chr(33),25,25)  # Up arrow
    myfont.text(chr(34),25,45)  # Down arrow
    myfont.text("{:2.1f}".format(humid),70,5)
    myfont.text("{:2.1f}".format(maxHumid),70,25)
    myfont.text("{:2.1f}".format(minHumid),70,45)
    oled.text("c", 110, 5)
    oled.text("c", 110, 25)
    oled.text("c", 110, 45)
    oled.show()

# Calculate pressure at sea level based on current reading, elevation and temperature
def seaPressure(press, temp):
    global evelvation
    return press * pow(1 - (0.0065 * elevation/3.281) / (20 + (0.0065 * elevation/3.281) + 273.15),-5.257 )

# Calculate the Z number. Z number is the position in the table for the weather forecast
def getZambretti():
    global press, temp, pressReadings
    now = rtc.datetime()
    if now[1] >=4 and now[1] <= 9:
        summer = True
    else:
        summer = False
    z = 0
    # Get pressure movement over at last 1 hour up to 3 hours
    count = len(pressReadings)
    if count > 11:
        seaPress = seaPressure(press, temp)
        if DEBUG:
            print("Sea level pressure: ", seaPress)
        pressChange = pressReadings[count - 1] - pressReadings[0]
        if pressChange <= -1.5:
            # drop of 1.5 or more considered falling for forecast
            if seaPress >= 1050:
                z = 1 #A
            elif seaPress >= 1040:
                z = 2 #B
            elif seaPress >= 1024:
                z = 4 #D
            elif seaPress >= 1018:
                z = 7 #H
            elif seaPress >= 1010:
                z = 15 #O
            elif seaPress >= 1004:
                if summer:
                    z = 18 #R
                else:
                    z = 15 #O
            elif seaPress >= 998:
                z = 21 #U
            elif seaPress >= 991:
                z = 22 #V
            else:
                if summer:
                    z = 24 #X
                else:
                    z = 22 #V
        elif pressChange >= 1.5:
            # Increase of 1.5 or more considered rising for forecast
            if seaPress >= 1030:
                z = 1 #A
            elif seaPress >= 1022:
                z = 2 #B
            elif seaPress >= 1012:
                if summer:
                    z = 3 #C
                else:
                    z = 6 #F
            elif seaPress >= 1007:
                z = 5 #F
            elif seaPress >= 1000:
                z = 7 #G
            elif seaPress >= 995:
                if summer:
                    z = 9 #I
                else:
                    z = 10 #J
            elif seaPress >= 990:
                z = 10 #J
            elif seaPress >= 984:
                if summer:
                    z = 12 #L
                else:
                    z = 13 #M
            elif seaPress >= 978:
                z = 13 #M
            elif seaPress >= 970:
                z = 17 #Q
            elif seaPress >= 965:
                z = 20 #T
            elif seaPress >= 959:
                z = 25 #Y
            else:
                z = 26 #Z
        else:
            # Otherwise considered steady for forecast
            if seaPress >= 1033:
                z = 1 #A
            elif seaPress >= 1023:
                z = 2 #B
            elif seaPress >= 1014:
                z = 5 #E
            elif seaPress >= 1009:
                z = 11 #K
            elif seaPress >= 1000:
                z = 14 #N
            elif seaPress >= 994:
                z = 16 #P
            elif seaPress >= 989:
                z = 19 #S
            elif seaPress >= 981:
                z = 23 #W
            elif seaPress >= 974:
                z = 24 #X
            else:
                z = 26 #Z
    return z - 1

# Show current pressure, trend and forecast
def showPress():
    global press, temp, pressReadings, HIGH_PRESS, LOW_PRESS
    # Get pressure at sea level
    seaPress = seaPressure(press, temp)
    
    if DEBUG:
        print("Sea pressure: ", seaPress)     
        z = getZambretti()                     
        print("Z = ", z)                      
    
    oled.fill(0);                  
    if seaPress > HIGH_PRESS:
        oled.text("High:",0,0)
    elif seaPress < LOW_PRESS:
        oled.text("Low:",0,0)
    else:
        oled.text("Normal:",0,0)
    oled.text("{:4.1f}".format(press),70,0)
    count = len(pressReadings)
    if count > 11:
        # Pressure change over latest 3 hour period
        # Using Met's definition
        
        # Rising (or falling) slowly
        # Pressure change of 0.1 to 1.5 hPa in the preceding three hours
        
        # Rising (or falling)
        # Pressure change of 1.6 to 3.5 hPa in the preceding three hours
        
        # Rising (or falling) quickly
        # Pressure change of 3.6 to 6.0 hPa in the preceding three hours
        
        # Rising (or falling) v. rapidly
        # Pressure change of more than 6.0 hPa in the preceding three hours
        
        pressChange = pressReadings[count - 1] - pressReadings[0]
        if abs(pressChange) > 6.0:
            oled.text("Rapid",0,20)
        elif abs(pressChange) >= 1.5:
            oled.text("Quick",0,20)
        elif abs(pressChange) >= 0.1:
            oled.text("Slow",0,20)
        else:
            oled.text("Steady :",0,20)
        if pressChange >= 0.1:
            myfont.text(chr(42), 56, 20)  # Up arrow small
        if pressChange <= -0.1:
            myfont.text(chr(43), 56, 20)  # Down arrow small 
        oled.text("{:4.1f}".format(pressChange),70,20)
        z = getZambretti()
        # Split forecast string and display
        if z >=0 and z <=25:
            mess = forecast[z].split('#')
            oled.text(mess[0], 0,35)
            if len(mess) > 1:
                oled.text(mess[1], 0,50)
    else:
        oled.text("Movement will be", 0, 20)
        oled.text("shown after 1", 0, 35)
        oled.text("hour.", 0, 50)
    oled.show()

# Display date and time
def showTime():
    global saveError, savingSuspended, temp, humid, press    
    oled.fill(0)          
    now = rtc.datetime()        # get current time
    formatstring = "Time : {:02d}:{:02d}"
    oled.text(formatstring.format(now[4], now[5]),0,0)
    formatstring = "Temp : {:0.1f}"
    oled.text(formatstring.format(temp), 0, 13)
    formatstring = "Humid: {:0.1f}"
    oled.text(formatstring.format(humid), 0, 26)
    formatstring = "Press: {:0.1f}"
    oled.text(formatstring.format(press), 0, 39)
    formatstring = "Date : {:02d}/{:02d}/{:02d}"
    oled.text(formatstring.format(now[2], now[1], now[0]-2000),0,52)
    # Display Battery Level
    volts = getVoltage()
    if volts > 3.84:
        batt = chr(37)     # Full icon
    elif volts > 3.7:
        batt = chr(38)     # 3/4 icon   
    elif volts > 3.54:
        batt = chr(39)     # 1/2 icon   
    elif volts > 3.4:
        batt = chr(40)     # 1/4 icon   
    else:
        batt = chr(41)     # Empty icon   
    myfont.text(batt, 110, 0)
    # if voltage < 3.0 v the suspend saving
    if not savingSuspended and volts < 3.0:
        updateLog("Voltage = {:.2f} history saving suspended.".format(volts))
        savingSuspended = True
        message("Battery low.", "History suspended", 5)
    if saveError or savingSuspended:
        myfont.text(chr(36), 110, 13) # Save error
    oled.show()

# Discard maximum and minimum readings and average remaining
def smoothReadings(readings):
    if len(readings) > 0:
        last = readings[len(readings) - 1]
    maxRead = 0
    minRead = 10000
    accRead = 0
    count = 0
    for i in range(len(readings)):
        if readings[i] > maxRead:
            maxRead = readings[i]
            maxR = i
        if readings[i] < minRead:
            minRead = readings[i]
            minR = i
    for i in range(len(readings)):
        if (i != maxR) and (i != minR):
            accRead += readings[i]
            count += 1
    if count != 0:
        # Debug print
        if DEBUG:
            print("last reading: ", last, "Readings used: ", count, "Acc: ", accRead, "Average: ", accRead/count)
        return accRead / count
    else:
        if DEBUG:
            print("last reading: ", last)
        return last
    

# Get current readings and smooth to return result
def getPressure():
    global pressSmoothing
    press = bmp180.pressure/100
    pressSmoothing.append(press)
    # If more than 5 readings remove oldest
    if len(pressSmoothing) > 5:
        pressSmoothing.pop(0)
    return smoothReadings(pressSmoothing)

# Get current readings and smooth to return result
def getTemp():
    global tempSmoothing
    temp = bmp180.temperature
    tempSmoothing.append(temp)
    # If more than 5 readings remove oldest
    if len(tempSmoothing) > 5:
        tempSmoothing.pop(0)
    return smoothReadings(tempSmoothing)

# Get current readings and smooth to return result
def getHumid():
    global humidSmoothing
    humid = sensor.humidity
    humidSmoothing.append(humid)
    # If more than 5 readings remove oldest
    if len(humidSmoothing) > 5:
        humidSmoothing.pop(0)
    return smoothReadings(humidSmoothing)

# Try to create data folder in case it does not exist
try:
    os.mkdir("data")
except:
    # Directory must exist do just continue
    time.sleep(0)

# Change to data folder to save files
os.chdir("data")

# load configuration file (or create)
loadConfig()

# Create timeAdjustment object
timeAdj = timeAdjustment(oled, myfont, rtc, adjust, mode, reset, elevation)

# Enter time set mode to enable time read from config to
# be corrected/confirmed
elevation = timeAdj.adjustTimeAndElevation()
showTime()                       # Display time
saveConfig(fileNumber)           # Write the new date/time to the config file
time.sleep_ms(1000)              # Wait 1 second to ensure button released/capture bounce
setPinHandlers()                 # Call setPinHandlers for initial set up
setTimer()                       # Timer to trigger history store
updateLog("Monitor started...")

# Main loop will run forever
while True:
    try:
        # Pause for 5 seconds before next sensor readings
        for i in range(0, 25):
            if not buttonPressed:
                time.sleep_ms(200)
        # If adjust button has been pressed then enter time set mode
        if adjusting:
            updateLog("Stopping interrupts")
            clearPinHandlers()
            stopTimer()
            elevation = timeAdj.adjustTimeAndElevation()
            showTime()                # display current time
            time.sleep_ms(1000)       # Wait 1 second to ensure button released/capture bounce
            setPinHandlers()
            setTimer()            
            updateLog("Possible time adjustment")
        # If mode changed then reset time display changed for time-out
        if buttonPressed:
            #update ticks display was last changed
            displayShown = time.ticks_ms()
        # if not showing time and more seconds than the time out has passed then revert to time
        if currentMode != dispTime and time.ticks_ms() > (displayShown + DISP_TIME_OUT * 1000):
            currentMode = dispTime
        # Get smoothed sensor readings
        temp = getTemp()
        humid = getHumid()
        press = getPressure()
        
        # Update maximum and minimum if required
        if len(tempSmoothing) >= 5:
            if maxTemp < temp:
                maxTemp = temp
            if maxHumid < humid:
                maxHumid = humid
            if minTemp > temp:
                minTemp = temp
            if minHumid > humid:
                minHumid = humid
            
        # If more than five minutes has passed append to pressure readings list
        # Could use a timer but this works well and allows shorter time to save first reading
        if time.ticks_ms() > (lastPressUpdate + FIVE_MIN):
            lastPressUpdate = time.ticks_ms()
            pressReadings.append(press)
            # If more than 3 hours in list remove oldest
            if len(pressReadings) > 36:
                pressReadings.pop(0)
            # Debug
            if DEBUG:
                print("Adding reading: ", press, "Readings = ", len(pressReadings))
        
        # Number of readings sync last history file update
        count += 1
        
        # Reset button status boolean
        buttonPressed = False
        adjusting = False
        
        # Call display for current mode
        updateDisplay()
        if DEBUG:
            gc.collect()
            micropython.mem_info()

    except InvalidPulseCount as e:
        # Do no log if just a pulse count error
        print("Pulse Exception: ", e)
    except Exception as e:
        # capture other exceptions, log and continue running
        print("Exception: ", e)
        updateLog("Exception: " + str(e))