class Battery:
"""
TODO: Have to calibrate the results voltage using Vref on efuse.
But the necessary functions seem not to be implemented to MicroPython yet.
* esp_adc_cal_characterize()
* esp_adc_cal_raw_to_voltage()
This module calculate current battery voltage roughly for now.
"""
def __init__(self, battery_pin, battery_resistance_num, width, atten):
self._battery_adc = ADC(Pin(battery_pin))
self._battery_adc.width(width)
self._battery_adc.atten(atten)
self._battery_resistance_num = battery_resistance_num
def get_voltage(self, sampling_count=32, round_count=3):
raw_value = sum(
[self._battery_adc.read()
for _ in range(sampling_count)]) / sampling_count
voltage = raw_value * self._battery_resistance_num / 1000
return round(voltage, round_count)
def deinit(self):
""" Deinitialize the battery pin ADC """
self._battery_adc.deinit()
class A_Pin(D_Pin):
def __init__(self, pin):
#self.pin = pin
self.dac = None
self.adc = None
if pin in [25, 26]:
self.dac = DAC(Pin(pin))
if pin in [32, 33]:
self.adc = ADC(Pin(pin))
self.adc.atten(ADC.ATTN_11DB)
self.adc.width(ADC.WIDTH_10BIT)
super().__init__(pin)
def write_analog(self, value):
if self.pin not in [25, 26]:
# print("This pin feature is not supported")
super().write_analog(value)
else:
self.dac.write(value)
def read_analog(self):
if self.adc != None:
return self.adc.read()
else:
print('This Pin does not support ADC')
return None
class BatReader9:
def __init__(self, pin=34):
self.batPin = ADC(Pin(pin))
self.batPin.atten(ADC.ATTN_11DB)
self.batPin.width(ADC.WIDTH_12BIT)
def readBatVoltage(self):
try:
volt = round(
self.batPin.raw_to_voltage(self.batPin.read()) * 2 / 1000.0, 2)
except AttributeError:
volt = round(self.batPin.read() * MAX_VOLTAGE / 4096.0, 2)
if volt < BAT_MIN:
volt = BAT_MIN
elif volt > BAT_MAX:
volt = BAT_MAX
return volt
def readBatPercent(self):
percent = round(
(self.readBatVoltage() - BAT_MIN) / (BAT_MAX - BAT_MIN) * 100, 2)
if percent < 0:
percent = 0
elif percent > 100:
percent = 100
return percent
def read(self):
return self.batPin.read()
def run():
# creates a PWM instance (led) at pin number 32 and with a max frequency of 7800
led = PWM(Pin(32), freq=78000)
# creates a ADC instance (sensor) at analogue pin A4 or pin number 36
sensor = ADC(Pin(36))
# set attenuation at 11db
sensor.atten(3)
#set width to 11 bit
sensor.width(3)
# Creates a writeable text file
f = open('fixedPWM.txt', 'w')
f.write('FIXED_PWM_VALUE\n')
print(sensor.read())
for i in range(100):
led.duty(200)
time.sleep_ms(30)
avgReading = 0
for j in range(50000):
avgReading += sensor.read()
x = str(avgReading / 50000)
print(x)
f.write(x + ',')
f.close()
def leer_MQ2(pin_adc):
""" Lectura del canal analogico """
adc = ADC(Pin(pin_adc))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_10BIT)
Vo = adc.read()
return Vo
def setup():
#setup light to voltage sensor
adc = ADC(Pin(34)) # define the pin as an analog-to-digital converter
adc.atten(ADC.ATTN_11DB) # set the atten..?
adc.width(ADC.WIDTH_12BIT) # set the width of the available bits
#setup measurement LED for PWM
dpin = Pin(12)
pwm = PWM(dpin)
pwm.freq(78000) # set frequency
pwm.duty(0) # set current
#setup RGB LED
red = Pin(15, Pin.OUT)
green = Pin(32, Pin.OUT)
blue = Pin(14, Pin.OUT)
#setup embedded LED
emb = Pin(13, Pin.OUT)
#setup button 1
button = Pin(33, Pin.IN, Pin.PULL_UP)
# setup button 2
button2 = Pin(27, Pin.IN, Pin.PULL_UP)
return (adc, pwm, button, button2, red, green, blue, emb)
class Mcp9700Temp(SensorBase):
V_SUPPLY = 3.3
RANGE_MAX = 1024
OFFSET = 0.4
DIV = 0.01
def __init__(self, temp_pin_nr, en_supply_obj):
self.TempAdc = ADC(Pin(temp_pin_nr))
self.TempEn = en_supply_obj
self.TempAdc.atten(ADC.ATTN_11DB)
self.TempAdc.width(ADC.WIDTH_10BIT)
def Read(self):
val = self.TempAdc.read()
# val = self._RawToCelsius(val)
return val
def Enable(self):
self.TempEn.Enable()
def Disable(self):
self.TempEn.Disable()
@staticmethod
def _RawToCelsius(raw_temp):
cel_temp = raw_temp * (Mcp9700Temp.V_SUPPLY / Mcp9700Temp.RANGE_MAX)
cel_temp -= Mcp9700Temp.OFFSET
cel_temp /= Mcp9700Temp.DIV
return cel_temp
class LightSensorGl5528:
def __init__(self, name: str, pin_num: int) -> None:
"""
Analog light sensor GL5528 for the tlvlp.iot project
Tested on ESP32 MCUs
:param pin_num: Analog input pin number for reading measurements
"""
reference = "gl5528|"
self.id = reference + name
self.sensor = ADC(Pin(pin_num, Pin.IN, Pin.PULL_DOWN))
self.sensor.atten(ADC.ATTN_11DB)
self.sensor.width(ADC.WIDTH_10BIT)
async def read_percent(self, delay_ms=300) -> tuple:
"""
:param delay_ms: a set delay before the reading is done
:return: the percentage of the read value, using integer rounding
"""
await asyncio.sleep_ms(delay_ms)
analog_read = self.sensor.read()
return self.id, self.convert_to_percent(analog_read)
def convert_to_percent(self, reading) -> int:
return int((1023 - reading) / 10.23)
def read_moisture(num_readings=21):
if num_readings % 2 == 0:
num_readings += 1
adc = ADC(SOILpin)
adc.atten(
ADC.ATTN_11DB
) # set 11dB input attenuation (voltage range roughly 0.0v - 3.6v)
adc.width(ADC.WIDTH_9BIT) # set 9 bit return values (returned range 0-511)
readings = _get_readings(num_readings, adc)
if num_readings <= 3:
return int(sum(readings) / len(readings))
median_index = int((num_readings - 1) / 2)
readings = sorted(readings)
min_index = int(median_index - median_index / 2)
max_index = int(median_index + median_index / 2)
sensible_values = readings[min_index:max_index]
median = readings[median_index]
average = avg(sensible_values)
total_average = avg(readings)
print("all readings: ", readings)
print("sensible readings: ", sensible_values)
print("median:%d, mid-50-avg:%d, avg:%d" %
(median, average, total_average))
return avg([median, average, total_average])
class ODSensor:
# frequency and pins may need to be changed
def __init__(self,LEDPin, sensorPin): #25,39. 26,36.
self.DAC_MAX = 255
self.DAC_Vmax = 3.15
self.DAC_Vmin = 0.09
self.led = DAC(Pin(25), bits=8)
self.sensor = ADC(Pin(39)) #Green
#self.sensor.atten(ADC.ATTN_11DB)
self.sensor.width(ADC.WIDTH_10BIT)
# return a single measurement
def measure(self, intensity):
self.led.write(intensity)
data = []
#get 120 measurements
for j in range(120):
data.append(self.sensor.read())
data.sort() #sort data increasing
sum_middle = sum(data[30:90]) #find sum of middle numbers
avg = sum_middle / 60 #find average of middle numbers
return avg
class VoltageMonitor():
NUM_READINGS = 10
READING_PERIOD_MS = 100
V_BAT_CALIBRATION = 0.001757
V_USB_CALIBRATION = 0.001419
def __init__(self):
log.info('VMON:init')
self.vbat_pin = ADC(Pin(35))
self.vbat_pin.atten(ADC.ATTN_11DB)
self.vbat_pin.width(ADC.WIDTH_12BIT)
self.vusb_pin = ADC(Pin(39))
self.vusb_pin.atten(ADC.ATTN_11DB)
self.vusb_pin.width(ADC.WIDTH_12BIT)
loop = asyncio.get_event_loop()
loop.create_task(self.run_v_monitor())
async def run_v_monitor(self):
v_bat_sample_sum = 0
v_usb_sample_sum = 0
while True:
# take average of readings
for _ in range(VoltageMonitor.NUM_READINGS):
v_bat_sample_sum += self.vbat_pin.read()
v_usb_sample_sum += self.vusb_pin.read()
await asyncio.sleep_ms(VoltageMonitor.READING_PERIOD_MS)
repo.add('vbat', v_bat_sample_sum * VoltageMonitor.V_BAT_CALIBRATION / VoltageMonitor.NUM_READINGS)
repo.add('vusb', v_usb_sample_sum * VoltageMonitor.V_USB_CALIBRATION / VoltageMonitor.NUM_READINGS)
v_bat_sample_sum = 0
v_usb_sample_sum = 0
await asyncio.sleep(0)
class Battery:
"""
TODO: Have to calibrate the results voltage using Vref on efuse.
But the necessary functions seem not to be implemented to MicroPython yet.
* esp_adc_cal_characterize()
* esp_adc_cal_raw_to_voltage()
This module calculate current battery voltage roughly for now.
"""
_adc1_pin = object()
_sampling_count = 64
_battery_resistance_num = 0
def __init__(self, pin, resistance_num, width, atten):
self._adc1_pin = ADC(Pin(pin))
self._adc1_pin.width(width)
self._adc1_pin.atten(atten)
self._battery_resistance_num = resistance_num
def get_voltage(self):
reading = 0
for i in range(0, self._sampling_count):
reading += self._adc1_pin.read()
reading /= self._sampling_count
return reading * self._battery_resistance_num / 1000
class Temperature:
def __init__(self):
self.adcP1 = ADC(Pin(33)) # create ADC object on ADC pin
self.adcP1.atten(
ADC.ATTN_11DB
) # set 11dB input attenuation (voltage range roughly 0.0v - 3.6v)
self.adcP1.width(
ADC.WIDTH_12BIT) # set 9 bit return values (returned range 0-511)
self.several = RingBuffer(10)
self.several.initialize(self.getTemperature)
def getTemperature(self):
raw = self.adcP1.read()
voltage = (
raw / 1.13
) # from observation & calculation. 290mV gives 240 reading but 1.5V gives 1700 reading. 4096 / 3600 also = 1.13 so using that
tempC = voltage * 0.1
#if 'several' in vars(Temperature):
self.several.append(tempC)
return tempC
def getAvTemp(self):
return sum(self.several.get()) / len(self.several.get())
def _read_adc():
# exit if adc resolution was not set
if not sharp1080.INIT:
return 0
from machine import ADC, Pin
conversion_factor = 3.3 / ((2**sharp1080.ADC_RES) - 1)
# raspberry pico
if sharp1080.INIT == sharp1080.PICO:
adc = ADC(Pin(sharp1080.ADC_PIN))
raw = adc.read_u16()
# esp8266
if sharp1080.INIT == sharp1080.ESP8266:
adc = ADC(0)
raw = adc.read()
# esp32
if sharp1080.INIT == sharp1080.ESP32:
adc = ADC(Pin(sharp1080.ADC_PIN))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
raw = adc.read()
volt = raw * conversion_factor
if sharp1080.DEBUG: print("adc_read: " + str(volt) + "V")
return volt
def light():
adc = ADC(Pin(36))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
value = int(100 - ((adc.read() - MIN_VALUE) /
(MAX_VALUE - MIN_VALUE) * 100))
value = 100 if value > 100 else value
value = 0 if value < 0 else value
return value
def leer_dato(pin_adc):
""" Esta funcion es para leer los
datos provenientes de los canales del
ADC"""
adc = ADC(Pin(pin_adc))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_10BIT)
adc_pot = adc.read() * 3.0 / 1024
return adc_pot
def getBatV():
adc = ADC(Pin(34)) # create ADC object on ADC pin
#adc.read() # read value, 0-4095 across voltage range 0.0v - 1.0v
adc.atten(
ADC.ATTN_11DB
) # set 11dB input attentuation (voltage range roughly 0.0v - 3.6v)
adc.width(ADC.WIDTH_9BIT) # set 9 bit return values (returned range 0-511)
return round(adc.read() / 512 * 3.6 * 2, 2)
class Thumbslide:
x_center = 1580
y_center = 1769
def __init__(self, pinx, piny, atten=ADC.ATTN_11DB, width=ADC.WIDTH_12BIT, tolerance=300):
self._pinX = pinx
self._pinY = piny
self._tolerance = tolerance
ADC.vref(vref=1150)
self._x = ADC(Pin(self._pinX))
self._x.atten(atten)
self._x.width(width)
self._y = ADC(Pin(self._pinY))
self._y.atten(atten)
self._y.width(width)
self._angle = 0
@property
def X(self):
return self._x
@property
def Y(self):
return self._y
def read(self):
return array('i', self._x.read(), self._y.read())
def readX(self):
return self._x.read()
def readY(self):
return self._y.read()
def _get_internal_calc_xy_dist(self, x, y):
x = x if x else self._x.read()
y = y if y else self._y.read()
x_dist = x - Thumbslide.x_center
y_dist = y - Thumbslide.y_center
return x_dist, y_dist
def moved(self, x=None, y=None):
x_dist, y_dist = self._get_internal_calc_xy_dist(x, y)
dist = math.sqrt(math.pow(x_dist, 2) + math.pow(y_dist, 2))
return dist >= self._tolerance
def angle(self, x=None, y=None):
x_dist, y_dist = self._get_internal_calc_xy_dist(x, y)
return math.atan2(y_dist, x_dist)
def get_scaled_adc(_pin):
adc = ADC(Pin(_pin)) # create ADC object on ADC pin
adc.atten(
ADC.ATTN_11DB
) # set 11dB input attenuation (voltage range roughly 0.0v - 3.6v)
adc.width(
ADC.WIDTH_11BIT) # set 9 bit return values (returned range 0-511)
return scale(
adc.read(), (0, 520),
(0,
100)) # read value using the newly configured attenuation and width
class VBatData:
def __init__(self, vbat_pin=33):
self.VBAT_PIN = Pin(vbat_pin)
self.VBAT_ADC = ADC(self.VBAT_PIN)
self.VBAT_ADC.atten(ADC.ATTN_11DB)
self.VBAT_ADC.width(ADC.WIDTH_12BIT)
self.VBAT_REF = 1100
def read_bat(self):
vbat_raw = self.VBAT_ADC.read() / 4095 * 2 * 3.3 * self.VBAT_REF
return vbat_raw
def get_ground_humidity(pin=34):
adc = ADC(Pin(pin))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_9BIT)
min = 156 # water
max = 422 # air
val = adc.read()
if val <= min: # water
return 100.0
if val >= max: # air
return 0.0
return 100 - ((val - min) / (max - min)) * 100
async def heartbeat(self):
while True:
adc = ADC(Pin(ADC_PIN))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
self.led(not self.led())
print(adc.read())
sleep_ms(200)
self.led(not self.led())
print(adc.read())
sleep_ms(200)
await asyncio.sleep_ms(0)
class VoltageSensor(SensorBase):
RANGE_MAX = const(1024)
NUM_VOLTAGES = const(4)
VoltageList = [1.0, 1.34, 2.0, 3.6]
AttenuationList = [
ADC.ATTN_0DB, ADC.ATTN_2_5DB, ADC.ATTN_6DB, ADC.ATTN_11DB
]
def __init__(self,
pin_nr: int,
en_supply_obj=None,
max_voltage: float = 3.3):
self.VoltAdc = ADC(Pin(pin_nr))
self.Supply = en_supply_obj
self.VoltAdc.atten(self._VoltageToAttenuation(max_voltage))
self.VoltAdc.width(ADC.WIDTH_12BIT)
def Read(self):
val = self.VoltAdc.read()
# val = self._RawToVoltage(val)
return val
def Enable(self):
self._EnableSupply()
def Disable(self):
self._DisableSupply()
def _RawToVoltage(self, raw):
volt = raw * (3.3 / self.RANGE_MAX)
return volt
def _EnableSupply(self):
if self.Supply is not None:
self.Supply.Enable()
def _DisableSupply(self):
if self.Supply is not None:
self.Supply.Disable()
def _VoltageToAttenuation(self, voltage: float):
for i in range(0, self.NUM_VOLTAGES):
if voltage <= self.VoltageList[i]:
print("[VoltSensor] Selected attenuation {}, max voltage {}".
format(self.AttenuationList[i], self.VoltageList[i]))
return self.AttenuationList[i]
raise Exception(
"Voltage too high for ADC input. No attenuation level found.")
class battery:
def __init__(self, vadc=35):
self.VBAT = ADC(Pin(vadc))
self.VBAT.width(ADC.WIDTH_12BIT)
self.VBAT.atten(ADC.ATTN_11DB)
self.CALIB = 3.6 * 2
self.VMIN = round(3.4 / self.CALIB * 4096)
self.VMAX = round(4.3 / self.CALIB * 4096)
def voltage(self):
return self.VBAT.read() / 4096 * self.CALIB
def percentage(self):
return (self.VBAT.read() - self.VMIN) / (self.VMAX - self.VMIN)
def setup_pins():
"""
PIN_OUT so we can toggle power to ADC device
PIN_IN to read ADC value
"""
# Start accepting input from ADC device
pin_in = Pin(PIN_IN, Pin.IN)
adc = ADC(pin_in)
# Calibrate ADC
# set 11dB input attenuation (voltage range roughly 0.0v - 3.6v)
adc.atten(ADC.ATTN_11DB)
# set bit return values (returned range 0-4095)
adc.width(ADC.WIDTH_12BIT)
pin_out = Pin(PIN_OUT, Pin.OUT)
return adc, pin_out
def __init_ADC():
"""
Setup ADC
read 0(0V)-1024(1,2-3,3V)
"""
global __ADC, __ADC_PROP
if __ADC is None:
if 'esp8266' in platform:
__ADC = ADC(physical_pin('ph')) # 1V measure range
__ADC_PROP = (1023, 1.0)
else:
__ADC = ADC(Pin(physical_pin('ph')))
__ADC.atten(ADC.ATTN_11DB) # 3.6V measure range
__ADC.width(ADC.WIDTH_10BIT) # Default 10 bit ADC
__ADC_PROP = (1023, 3.6)
return __ADC
def leer_dato_uv(pin_adc):
""" Esta funcion es para leer los
datos provenientes de los canales del ADC
ademas esta la caracterizacion del sensor UV ML8511
caracterizacion y = 0.1625x + 1.0
x = (y - 1.0)/0.1625 mW/cm^2
"""
adc = ADC(Pin(pin_adc))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_10BIT)
y = adc.read() * 3.3 / 1024
if y < 1:
x = 0
else:
x = (y - 1.0) / 0.1625
return x
def leer_polvo(DPIN, APIN):
"""Definici0n de pines
para el sensor de polvo GP2Y1010AU0F
"""
p13 = Pin(DPIN, Pin.OUT)
adc = ADC(Pin(APIN))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_10BIT)
#proceso de lectura para el sensor
p13.off()
utime.sleep_us(280)
V1 = adc.read() * 3.3 / 1024
utime.sleep_us(40)
p13.on()
utime.sleep_us(9680)
dust_density = 0.17 * V1 - 0.1
return dust_density
def __init_ADC():
"""
Setup ADC
"""
global __ADC
if __ADC is None:
from machine import ADC, Pin
from LogicalPins import get_pin_on_platform_by_key
if 'esp8266' in platform:
__ADC = ADC(get_pin_on_platform_by_key('adc_2'))
else:
__ADC = ADC(Pin(get_pin_on_platform_by_key('adc_2')))
# set 11dB input attenuation (voltage range roughly 0.0v - 3.6v)
__ADC.atten(ADC.ATTN_11DB)
# set 9 bit return values (returned range 0-511)
__ADC.width(ADC.WIDTH_9BIT)
return __ADC
class BatteryVoltage:
def __init__(self):
# Setup ADC:
self.batv = ADC(Pin(35)) # Analog A13 -- battery monitor
# Set attenuation and bit width:
self.batv.atten(ADC.ATTN_11DB)
self.batv.width(ADC.WIDTH_12BIT)
def read(self):
return self.batv.read()
def get_volt(self, val):
return val * _SCALE
def read_volt(self):
return self.get_volt(self.read())
# Complete project details at https://RandomNerdTutorials.com # Created by Rui Santos from machine import Pin, ADC, PWM from time import sleep led = Pin(2, Pin.OUT) button = Pin(15, Pin.IN) #Configure ADC for ESP32 pot = ADC(Pin(34)) pot.width(ADC.WIDTH_10BIT) pot.atten(ADC.ATTN_11DB) #Configure ADC for ESP8266 #pot = ADC(0) led_pwm = PWM(Pin(4),5000) while True: button_state = button.value() led.value(button_state) pot_value = pot.read() led_pwm.duty(pot_value) sleep(0.1)
