def __init__(self, channel=0):
self.i2c = busio.I2C(board.SCL, board.SDA)
self.ads = ADS.ADS1015(self.i2c)
self.ads.gain = 1
self.ads.data_rate = 128
self.chan = AnalogIn(self.ads, ADS.P0)
self.BPM = 0
def sensorReading(para):
"""
read data sensors
"""
reading = {}
reading['mois'] = AnalogIn(para['ads'], ADS.P1).voltage
reading['uv'] = AnalogIn(para['ads'], ADS.P2).voltage
# if readMoisSens > 2.4:
# GPIO.output(para['pinMoisSens'], 1)
# print('Too dry, water the flower \nCurrent reading: {:.2f}'
# .format(readMoisSens))
# else:
# GPIO.output(para['pinMoisSens'], 0)
# print('the flow is fine now \nCurrent reading: {:.2f}'
# .format(readMoisSens))
return reading
def __init__(self, indicator_manager):
# Create the I2C bus
i2c = busio.I2C(board.SCL, board.SDA)
# Create the ADC object using the I2C bus
ads = ADS.ADS1115(i2c)
# Create single-ended input on channel 1 for battery
self.battery = AnalogIn(ads, ADS.P0)
self.battery_value = None
self.indicator_manager = indicator_manager
def get_value(sensor):
if sensor < 0 or sensor >= len(SENSOR_PINS):
logger.log(f"Invalid sensor index used: {sensor}")
return
channel = AnalogIn(ads, SENSOR_PINS[sensor])
percentage = channel.value / SENSOR_MAX
return percentage * 100
def is_on_single(self):
"""Checks if this pin is currently on, based on 1 reading. This may return off if the pin is blinking.
Returns:
A tuple of whether the pin is on (bool) and the light value reading (int).
"""
light_value = AnalogIn(self.adc, self.adc_pin).value
# print(str(self), light_value)
return light_value < self.threshold, light_value
def __init__(self):
self.ads = ADS.ADS1115(busio.I2C(board.SCL, board.SDA))
self.chan = AnalogIn(self.ads, ADS.P0, ADS.P1)
self.ads.gain = 1
self._lock = asyncio.Lock()
self._stop = asyncio.Event()
self._stopped = asyncio.Event()
self._resetMeas()
def __init__(self):
# Create the I2C bus
i2c = busio.I2C(board.SCL, board.SDA)
# Create the ADC object using the I2C bus
ads = ADS.ADS1115(i2c)
# Create single-ended input on channel 1 for turbidity
self.turbidity_angle1 = AnalogIn(ads, ADS.P1)
self.turbidity_angle2 = AnalogIn(ads, ADS.P2)
self.turbidity_value = None
# Configure infrared LED outputs
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
# A1- GPIO 27 pairing
GPIO.setup(27, GPIO.OUT)
GPIO.output(27, GPIO.LOW)
# A2- GPIO 17 pairing
GPIO.setup(17, GPIO.OUT)
GPIO.output(17, GPIO.LOW)
def collect_adc(self):
self.vz = []
self.vx = []
self.vy = []
# Create single-ended input on channel 0
chan0 = AnalogIn(self.ads, ADS.P0)
chan1 = AnalogIn(self.ads, ADS.P1)
chan2 = AnalogIn(self.ads, ADS.P2)
try:
t = time.time()
while time.time() - t < 60:
# Recieve voltage values
self.vz.append(chan0.value)
self.vx.append(chan1.value)
self.vy.append(chan2.value)
except KeyboardInterrupt:
pass
return vz, vx, vy
def __init__(self, nummer, ad_wandler, kanal, db_connect):
self.__nummer = nummer # Durchlaufende Nummer
self.__ad_wandler = ad_wandler # Initialisierter AD-Wandler
self.__kanal = kanal # Kanal des Sensors
self.__sensor = AnalogIn(self.__ad_wandler, self.__kanal) # Initialisierung des Kanals
self.__sensorwert = 0 # Ausgelesener Wert
self.__db_connect = db_connect # Einmalig in Application initialisiert, übergeben zur Nutzung
Sensor.anzahl += 1 # Anzahl der initialisierten Sensoren erhöhen
def f1(q1):
i2c = busio.I2C(board.SCL, board.SDA)
ads = ADS.ADS1115(i2c)
chan0 = AnalogIn(ads, ADS.P0)
chan1 = AnalogIn(ads, ADS.P1)
while 1:
temp = chan0.voltage / (3.3 / 165.0) - 40.0
humid = chan1.voltage / (3.3 / 100.0)
print('T', temp, '\tH', humid)
str_T = '%.1f' % temp
str_H = '%.1f' % humid
str_TH = str_T + 'C ' + str_H + '%'
q1.put([str_TH, str_T, str_H])
time.sleep(0.5)
def __init__(self, coeff_m=1, coeff_p=1, poll_delay=2.5):
# create I2C bus
i2c = busio.I2C(board.SCL, board.SDA)
# create ADC object
ads = ADS.ADS1015(i2c)
POWER_CHANNEL_MOTOR = ADS.P3 # A3 on board
POWER_CHANNEL_PI = ADS.P2 # A2 on board
self.chan_motor = AnalogIn(ads, POWER_CHANNEL_MOTOR)
self.chan_pi = AnalogIn(ads, POWER_CHANNEL_PI)
self.poll_delay = poll_delay
self.coeff_m = coeff_m
self.coeff_p = coeff_p
self.on = True
self.vm = 0
self.vp = 0
def getSoilMoistureStat(self, plantPort):
if plantPort == self.config.get('PLANT_PORT_2'):
return "Not Available"
# Create the I2C bus
i2c = busio.I2C(board.SCL, board.SDA)
# Create the ADC object using the I2C bus
ads = ADS.ADS1115(i2c)
# Create single-ended input on channel 0
chan = AnalogIn(ads, ADS.P0)
return self.getNormalizedMoisturePercentValue(chan.value)
def main():
i2c = busio.I2C(board.SCL, board.SDA)
# wir verwenden den 1115
ads = ADS.ADS1115(i2c)
# Channel 0 und 1 auslesen
chan_0 = AnalogIn(ads, ADS.P0)
chan_1 = AnalogIn(ads, ADS.P1)
# Differentialmodus erlaubt Messung von Spannungsdifferenz
#chan = AnalogIn(ads, ADS.P0, ADS.P1)
print("{:>5}\t{:>5}\t{:>5}\t{:>5}".format('raw0', 'v0', 'raw1', 'v1'))
while True:
print("{:>5}\t{:>5.3f}\t{:>5}\t{:>5.3f}".format(
chan_0.value, chan_0.voltage, chan_1.value, chan_1.voltage))
time.sleep(0.5)
def importDataFromSensor2(self):
# Initialisiert die I2C-Schnittstelle
i2c = busio.I2C(board.SCL, board.SDA)
# creating the ADC object using the I2C bus located at 0x48 for fluxgate sensor 2
# analog digital converter
# Konfiguriert den Input vom I2C-Gerät mit der ID 0x49
ads2 = ADS.ADS1115(i2c, address=0x49)
# creating input for x,y,z axis located at P0, P1, P2
# Fragt die x,y,z-Werte ab
x = AnalogIn(ads2, ADS.P0)
y = AnalogIn(ads2, ADS.P1)
z = AnalogIn(ads2, ADS.P2)
# Formula for calculating the magnitude of the earth's magnetic field
# Berechnung des Wertes
result = (((x.value * x.value) + (y.value * y.value) +
(z.value * z.value))**0.5)
print(mgfield.Core.getCTime(self), "got", result, "as value [2]")
return result
def reading():
#taking 30 reading for average
i2c = busio.I2C(board.SCL, board.SDA)
ads = ADS.ADS1115(i2c)
channel = AnalogIn(ads, ADS.P3)
sum = 0.00
for i in range(0,30):
sum+=channel.value
avg = str('%.4f'%(sum/30))
return jsonify({'reading':avg})
def meraj(ads):
vystup = ""
value0 = AnalogIn(ads, ADS.P0)
value1 = AnalogIn(ads, ADS.P1)
value2 = AnalogIn(ads, ADS.P2)
value3 = AnalogIn(ads, ADS.P3)
vystup = [{
"CH0": value0.value,
"CH0V": value0.voltage,
"CH1": value1.value,
"CH1V": value1.voltage,
"CH2": value2.value,
"CH2V": value2.voltage,
"CH3": value3.value,
"CH3V": value3.voltage
}]
return vystup
def periodicAction():
global next_call
### BEGIN READING SENSOR DATA
bme280_data = bme280.sample(bus, address)
humidity = bme280_data.humidity
pressure = bme280_data.pressure
ambient_temperature = bme280_data.temperature
data = bus.read_i2c_block_data(0x1D, 0x00, 6)
#Convert the data to 10-bits
xAcc = (data[1] & 0x03) * 256 + data[0]
if xAcc > 511:
xAcc -= 1024
yAcc = (data[3] & 0x03) * 256 + data[2]
if yAcc > 511:
yAcc -= 1024
zAcc = (data[5] & 0x03) * 256 + data[4]
if zAcc > 511:
zAcc -= 1024
chan = AnalogIn(ads, ADS.P0)
lumin = (chan.voltage / 3.3) * 100
infomodel.acceleration.value = {"x": xAcc, "y": yAcc, "z": zAcc}
infomodel.humidity.value = {
"currentMeasured": humidity,
"minMeasured": 0,
"maxMeasured": 0
}
infomodel.illuminance.value = {
"currentMeasured": lumin,
"minMeasured": 0,
"maxMeasured": 0
}
infomodel.temperature.value = {
"currentMeasured": ambient_temperature,
"minMeasured": 0,
"maxMeasured": 0
}
### END READING SENSOR DATA
# Publish payload
publishAcceleration()
publishHumidity()
publishIlluminance()
publishTemperature()
# Schedule next call
next_call = next_call + timePeriod
threading.Timer(next_call - time.time(), periodicAction).start()
def adc_ads1115():
import time
import board
import busio
import adafruit_ads1x15.ads1115 as ADS
from adafruit_ads1x15.analog_in import AnalogIn
# Create the I2C bus
i2c = busio.I2C(board.SCL, board.SDA)
# Create the ADC object using the I2C bus
ads = ADS.ADS1115(i2c)
chan1 = AnalogIn(ads, ADS.P0)
chan2 = AnalogIn(ads, ADS.P1)
chan3 = AnalogIn(ads, ADS.P2)
chan4 = AnalogIn(ads, ADS.P3)
adc_inputs_values = []
adc_inputs_values.append(chan1.voltage)
adc_inputs_values.append(chan2.voltage)
adc_inputs_values.append(chan3.voltage)
adc_inputs_values.append(chan4.voltage)
return adc_inputs_values
def getPh():
i2c = busio.I2C(board.SCL, board.SDA)
ads = ADS.ADS1115(i2c)
chan = AnalogIn(ads, ADS.P0)
phAdj = 21.3295
ph = -5.74 * chan.voltage + phAdj
if ph is not None:
return render_template("ph.html", ph=ph)
else:
return render_template("no_sensor.html")
def __init__(self):
config = parse_config()['ultrasonic']
i2c = busio.I2C(board.SCL, board.SDA)
ads = ADS.ADS1015(i2c)
self.ussl = AnalogIn(ads, ADS.P0)
self.ussc = AnalogIn(ads, ADS.P2)
self.ussr = AnalogIn(ads, ADS.P1)
self.ussl_pin = config['ussl_pin']
self.ussc_pin = config['ussc_pin']
self.ussr_pin = config['ussr_pin']
self.clear_distance_c = config['clear_distance_c']
self.clear_distance_side = config['clear_distance_side']
self.path_distance = config['path_distance']
GPIO.setup(self.ussl_pin, GPIO.OUT)
GPIO.setup(self.ussc_pin, GPIO.OUT)
GPIO.setup(self.ussr_pin, GPIO.OUT)
self.ussl_trigger = GPIO.PWM(self.ussl_pin, 20000)
self.ussc_trigger = GPIO.PWM(self.ussc_pin, 20000)
self.ussr_trigger = GPIO.PWM(self.ussr_pin, 20000)
self.distances = [0, 0, 0]
def reading_sensors(para):
readMoisSens = AnalogIn(para['ads'], ADS.P1).voltage
if readMoisSens > 2.4:
GPIO.output(para['pinPump'], 1)
print('Dry soil. water the flower ASAP \nCurrent moisture: {:.8f}'
.format(readMoisSens))
else:
GPIO.output(para['pinPump'], 0)
print('The soil is fine now \nCurrent moisture: {:.8f}'
.format(readMoisSens))
def measureVoltageThread(self, con):
self.ads = ADS.ADS1115(self.i2c)
while not self.ended and self.connected:
time.sleep(5)
self.voltageChan = AnalogIn(self.ads, ADS.P1)
voltage = self.voltageChan.voltage * (683 + 220) / 220
value = int((voltage - 4 * 3.7) * 50)
try:
con.send(("Voltage: " + str(value)).encode())
except:
pass
async def websocket_handler():
uri = "wss://0xl08k0h22.execute-api.eu-west-1.amazonaws.com/dev"
global soilHumidity
global saveLaps
global retryCounter
async with websockets.connect(uri, ssl=True) as websocket:
logger.info("Connected to Websocket")
retryCounter = 0
with busio.I2C(board.SCL, board.SDA) as i2c:
try:
uv = VEML6070(i2c, "VEML6070_4_T")
bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c, 0x76)
ads = ADS.ADS1115(i2c, mode=ads1x15.Mode.CONTINUOUS)
humiditySensor = AnalogIn(ads, ADS.P0)
except:
logger.error(
f'Failed to initiate Sensor:\n{sys.exc_info()[0]}')
raise
maxHumidity = 23150
minHumidity = 10500
while True:
soilHumidityRaw = humiditySensor.value
sh = (100 - float((soilHumidityRaw - minHumidity) * 100 /
(maxHumidity - minHumidity))) / 100
setSoilHumidity(sh)
uv_raw = uv.uv_raw
t = bme280.temperature
setTemperature(t)
airHumidity = bme280.humidity
logger.info(
f'T:{temperature:0.3f}|{t:0.6f} AH:{airHumidity:0.2f} UV:{uv_raw} SH:{soilHumidity:0.3f}|{sh:0.6f}'
)
if (saveLaps == 0):
try:
saveMeasurementsToDb(temperature, uv_raw, soilHumidity)
except Exception as e:
logger.error("Failed to save data to DynamoDB.")
logger.error(e)
if (saveLaps % 10 == 0):
message = f'{{\"action":"message","message":"FROM_PLANTER;{MY_ID};MEASUREMENTS;T:{temperature};UV:{uv_raw};SH:{soilHumidity};AH:{airHumidity}"}}'
await websocket.send(message)
time.sleep(5)
pong_awaiter = await websocket.ping()
await pong_awaiter
saveLaps = saveLaps + 5 if saveLaps < 60 else 0
def getMeasurements():
timestr=time.strftime('%I:%M%p %b %d, %Y')
temperature,pressure,humidity = bme280.readBME280All()
tempF = temperature * 9 / 5 + 32
inHg = pressure * 0.02952998751
lux = veml7700.lux
chan = AnalogIn(ads, ADS.P0)
battLevel = (chan.voltage-3.2)*1000.0/9.612
wifiStrength=getWiFiStrength()
# 4.1612 = full 3.2 = empty
# print(chan.value, chan.voltage)
return measurement(timestr, str(round(temperature,1)), str(round(humidity,1)), str(round(pressure,6)), str(round(lux,1)) if lux>100 else str(lux) , round(battLevel,1), wifiStrength)
def meraj_a_zapis(ads, db):
vystup = ""
value0 = AnalogIn(ads, ADS.P0)
value1 = AnalogIn(ads, ADS.P1)
value2 = AnalogIn(ads, ADS.P2)
value3 = AnalogIn(ads, ADS.P3)
zapis_do_db(db, value0, value1, value2, value3)
vystup = [{
"CH0": value0.value,
"CH0V": value0.voltage,
"CH1": value1.value,
"CH1V": value1.voltage,
"CH2": value2.value,
"CH2V": value2.voltage,
"CH3": value3.value,
"CH3V": value3.voltage
}]
return vystup
def BuildSparkFun08942WindDirectionSensor(self, sensorType, offsetAngle):
try:
if self.chan == None:
self.adc = ADS.ADS1115(self.i2c)
self.chan = AnalogIn(self.adc, ADS.P0)
sensor = sen08942VaneSensor(self.chan, offsetAngle)
except ValueError:
log.error("%s sensor not found", sensorType)
self.adc = None
self.chan = None
sensor = None
return sensor
def i2c_test():
i2c = busio.I2C(board.SCL, board.SDA)
ads = ADS.ADS1115(i2c)
values = []
ctr = 0
chan0 = AnalogIn(ads, ADS.P0, ADS.P1)
chan1 = AnalogIn(ads, ADS.P2, ADS.P3)
# chan2 = AnalogIn(ads, ADS.P2)
# chan3 = AnalogIn(ads, ADS.P3)
while(ctr < 5):
sleep(0.1)
pressure = raw2data(chan0.value)
values.append(pressure)
ctr += 1
print("ch0: ", pressure, chan0.voltage)
# print("ch1: ", chan1.value, chan1.voltage)
# print("ch2: ", chan2.value, chan2.voltage)
# print("ch3: ", chan3.value, chan3.voltage)
time = np.arange(ctr)
def __init__(self, initTemp=25.0, frequency=9000):
super(Heater, self).__init__()
self.initTemp = initTemp
self.frequency = frequency
self.MaxTemp = 33.0
self.pi = pigpio.pi()
# 9000hz give a relative nice curve
self.pi.hardware_PWM(13, self.frequency, 0)
self.pi.hardware_PWM(18, self.frequency, 0)
# Create the I2C bus
i2c = busio.I2C(board.SCL, board.SDA)
# Create the ADC object using the I2C bus
ads = ADS.ADS1115(i2c)
# Create single-ended input on channel 1
self.chanRef = AnalogIn(ads, ADS.P1)
self.chanCali = AnalogIn(ads, ADS.P3)
self.readObejectiveTemp()
self.setTemp(initTemp)
def __init__(self, *args, **kwargs):
"""SnakeEyesBonnet constructor."""
super(SnakeEyesBonnet, self).__init__(*args, **kwargs) # Thread
self.i2c = busio.I2C(board.SCL, board.SDA)
self.ads = ADS.ADS1015(self.i2c)
self.ads.gain = 1
self.period = 1.0 / 60.0 # Polling inverval = 1/60 sec default
self.print_values = False # Don't print values by default
self.channel = []
for index in range(4):
self.channel.append(
AdcChannel(AnalogIn(self.ads, self.channel_dict[index])))
def get_current_values(channel_num):
chan = ADC.P1
if (channel_num == 1):
chan = ADC.P1
if (channel_num == 2):
chan = ADC.P2
channel = AnalogIn(adc, chan)
current = (channel.voltage - offsetVoltage) / sensitivity
return current
