Implementation of a ring buffer in the thread of the analog readings

Author: Ricardosgeral

analogsensor_thread.py

@@ -0,0 +1,58 @@
+#! /usr/bin/python3
+# -*- coding: utf-8 -*-
+#Ricardos.geral@gmail.com
+
+import threading
+import time
+from statistics import mean
+from ringbuffer import RingBuffer #This version uses a circular buffer to avoid unwanted zero readings
+import Adafruit_ADS1x15 # Analogic digital conversor ADS 15 bit 2^15-1=32767 (needs to be installed using pip3)
+adc = Adafruit_ADS1x15.ADS1115(address=0x48, busnum=1) #address of ADC See in -- sudo i2cdetect -y 1
+
+# Choose a gain of 1 for reading voltages from 0 to 6.14V.
+# Or pick a different gain to change the range of voltages that are read:
+#  - 2/3 = +/-6.144V
+#  -   1 = +/-4.096V
+#  -   2 = +/-2.048V
+#  -   4 = +/-1.024V
+#  -   8 = +/-0.512V
+#  -  16 = +/-0.256V
+
+# See table 3 in the ADS1015/ADS1115 datasheet for more info on gain.
+GAIN = 1  #2/3, 1, 2, 4 , 6 , 8, 16
+DATA_RATE = 250  # 8, 16, 32, 64, 128, 250, 475, 860 samples/second   max =860 the higher the number the higher the noise!
+
+class AnalogSensor(threading.Thread):
+
+
+    def __init__(self, sleep, records):
+          threading.Thread.__init__(self)
+          self.sleep = sleep
+          self.records = records
+
+    def run(self):
+
+        self.A0 = RingBuffer(self.records)  # creates a buffer with maximum numbers equal to the number of records /reading
+        self.A1 = RingBuffer(self.records)
+        self.A2 = RingBuffer(self.records)
+        self.A3 = RingBuffer(self.records)
+
+        while True:
+            # Adds measures and keep track of num of measurements
+            self.A0.append(adc.read_adc(0, gain=GAIN,data_rate=DATA_RATE)) # pin gain and data_rate
+            self.A1.append(adc.read_adc(1, gain=GAIN, data_rate=DATA_RATE))  # pin gain and data_rate
+            self.A2.append(adc.read_adc(2, gain=GAIN, data_rate=DATA_RATE))  # pin gain and data_rate
+            self.A3.append(adc.read_adc(3, gain=GAIN, data_rate=DATA_RATE))  # pin gain and data_rate
+
+            time.sleep(self.sleep-0.01*4) #each reading takes about 0.01s. this time is compensated during sleep
+
+    def read_analog(self):
+        """reads the channels as a rounded mean"""
+        # Compute the mean
+        analog=[0]*4
+        #for channel in range(4):
+        analog[0] = mean(self.A0.get())
+        analog[1] = mean(self.A1.get())
+        analog[2] = mean(self.A2.get())
+        analog[3] = mean(self.A3.get())
+        return analog

analogsensor_thread_buf.py

@@ -19,11 +19,6 @@
 
 ######### make connection to serial UART to read/write NEXTION
 ser = nxlib.ser
-# ser = serial.Serial(port='/dev/ttyAMA0', baudrate = nxlib.BAUD,
-#                     parity=serial.PARITY_NONE,
-#                     stopbits=serial.STOPBITS_ONE,
-#                     bytesize=serial.EIGHTBITS,
-#                     timeout=0.15)
 
 nxlib.nx_setsys(ser, 'bauds', nxlib.BAUD)  # set default baud (default baud rate of nextion from fabric is 9600)
 nxlib.nx_setsys(ser, 'bkcmd',0)     # sets in NEXTION 'no return error/success codes'

main.py

@@ -0,0 +1,47 @@
+#! /usr/bin/python3
+# -*- coding: utf-8 -*-
+#Ricardos.geral@gmail.com
+
+"""
+Buffer ring class used in analogsensor_thread
+"""
+
+class RingBuffer:
+    """ class that implements a not-yet-full buffer """
+    def __init__(self,size_max):
+        self.max = size_max
+        self.data = []
+
+    class __Full:
+        """ class that implements a full buffer """
+        def append(self, x):
+            """ Append an element overwriting the oldest one. """
+            self.data[self.cur] = x
+            self.cur = (self.cur+1) % self.max
+        def get(self):
+            """ return list of elements in correct order """
+            return self.data[self.cur:]+self.data[:self.cur]
+
+    def append(self,x):
+        """append an element at the end of the buffer"""
+        self.data.append(x)
+        if len(self.data) == self.max:
+            self.cur = 0
+            # Permanently change self's class from non-full to full
+            self.__class__ = self.__Full
+
+    def get(self):
+        """ Return a list of elements from the oldest to the newest. """
+        return self.data
+
+## sample usage
+# if __name__=='__main__':
+#     x=RingBuffer(5)
+#     x.append(1); x.append(2); x.append(3); x.append(4)
+#     print(x.__class__, x.get(  ))
+#     x.append(5)
+#     print(x.__class__, x.get(  ))
+#     x.append(6)
+#     print(x.data, x.get(  ))
+#     x.append(7); x.append(8); x.append(9); x.append(10)
+#     print(x.data, x.get(  ))

ringbuffer.py

@@ -18,15 +18,15 @@
                                     DFRobot Gravity Analog/Digital Turbidity Sensor, 5V 40mA DC
     3 pressure sensors : 0-5psi 5V Pressure Transducer Transmitter Sensor or Sender
     flow sensor : flowrate and total liters
-                 1.5" DN40 2~200L/min water Plastic Hall Turbine flow sensor industry meter
+                 1.25" DN32 1~120L/min water Plastic Hall Turbine flow sensor industry meter (Sea brand)
 
 It also records the time and date of the measure.
 
 """
 
 # Libraries required
 from time import sleep
-from analogsensor_thread import AnalogSensor, GAIN, DATA_RATE
+from analogsensor_thread_buf import AnalogSensor, GAIN, DATA_RATE
 from digitalSen_thread import D_Temp
 from datetime import datetime
 from math import log as log
@@ -99,7 +99,7 @@ def init(interval, no_reads):
 
     global analogTread_flag
     if analogTread_flag == False:  # avoids having multiple threats analog_sensor running
-        analog_sensor = AnalogSensor(sleep)  # average readings in the analog sensors per measure interval for signal stability)
+        analog_sensor = AnalogSensor(sleep,no_reads)  # average readings in the analog sensors per measure interval for signal stability)
         analog_sensor.name = "analog_sensors"
         analog_sensor.start()
         analogTread_flag = True