def MQCalibration(self):
val=0.0
raw_calib = readadc(self.analog)
for i in range (0, self.CALIBARAION_SAMPLE_TIMES):
val += self.MQResistanceCalculation(readadc(self.analog))
time.sleep(self.CALIBRATION_SAMPLE_INTERVAL)
val = val/self.CALIBARAION_SAMPLE_TIMES
val = val/self.RO_CLEAN_AIR_FACTOR
edit_calib_config("MQ4", val)
edit_calib_config("MQ4_RAW", raw_calib)
log.info("Calibrated, Ro = "+str(val))
return val
def MQCalibration(self):
val = 0.0
raw_calib = readadc(self.analog)
for i in range(0, self.CALIBARAION_SAMPLE_TIMES):
val += self.MQResistanceCalculation(readadc(self.analog))
time.sleep(self.CALIBRATION_SAMPLE_INTERVAL)
val = val / self.CALIBARAION_SAMPLE_TIMES
val = val / self.RO_CLEAN_AIR_FACTOR
edit_calib_config("MQ4", val)
edit_calib_config("MQ4_RAW", raw_calib)
log.info("Calibrated, Ro = " + str(val))
return val
def main():
"""
Основной блок программы
Main program block
:return: None
"""
# 10k trim pot connected to adc #1
# Потенциометр подключен на первый вход АЦП
potentiometer_adc = 7
last_read = 0 # Переменная отслеживает последнее считанное с потенциометра значение
tolerance = 7 # Минимальное изменение значения. Новое значение с потенциометра будем
# считывать только тогда, когда разница между текущим и предудущим значением
# будет больше tolerance. Необходимо для устранения дребезжания
MAX_VALUE = 1023
#####################################################################
# Все порты к дисплею устанавливаем на вывод:
GPIO.setup(LCD_E , GPIO.OUT) # E
GPIO.setup(LCD_RS, GPIO.OUT) # RS
GPIO.setup(LCD_D4, GPIO.OUT) # DB4
GPIO.setup(LCD_D5, GPIO.OUT) # DB5
GPIO.setup(LCD_D6, GPIO.OUT) # DB6
GPIO.setup(LCD_D7, GPIO.OUT) # DB7
# Инциализируем дисплей
lcd.init()
# Устанавливаем режимы пинов интерфейса SPI
# set up the SPI interface pins
GPIO.setup(SPIMOSI, GPIO.OUT)
GPIO.setup(SPIMISO, GPIO.IN)
GPIO.setup(SPICLK, GPIO.OUT)
GPIO.setup(SPICS, GPIO.OUT)
potentiometer_adc = 7
last_read = 0 # Переменная отслеживает последнее считанное с потенциометра значение
tolerance = 7 # Минимальное изменение значения. Новое значение с потенциометра будем
# считывать только тогда, когда разница между текущим и предудущим значением
# будет больше tolerance. Необходимо для устранения дребезжания
while True:
user_input = input()
if user_input == 'e':
break
# Считываем очередное значение с АЦП
hum_raw_value = adc.readadc(potentiometer_adc, SPICLK, SPIMOSI, SPIMISO, SPICS)
hum_value = abs(hum_raw_value - 1023)
percent = round(hum_value * 100.0 / MAX_VALUE)
lcd.string(' Humidity = {hum}%' .format(hum = percent), LCD_LINE_1)
def MQRead(self):
rs=0
for i in range(0, self.READ_SAMPLE_TIMES):
rs += self.MQResistanceCalculation(readadc(self.analog))
time.sleep(self.READ_SAMPLE_INTERVAL)
rs = rs/self.READ_SAMPLE_TIMES
return rs
def MQRead(self):
rs = 0
for i in range(0, self.READ_SAMPLE_TIMES):
rs += self.MQResistanceCalculation(readadc(self.analog))
time.sleep(self.READ_SAMPLE_INTERVAL)
rs = rs / self.READ_SAMPLE_TIMES
return rs
def sample():
# Debugging
#value = math.sin(time.time()*60*2*math.pi)
#value2 = math.sin(time.time()*120*2*math.pi) * math.sin(time.time()*10*2*math.pi)
#value3 = math.sin(time.time()*70*2*math.pi)
# Slower, but timing more in-sync
#value = (adc.readadc(6) - adc.readadc(2))
#value2 = (adc.readadc(0) - adc.readadc(6))
#value3 = (adc.readadc(2) - adc.readadc(6))
adc0 = adc.readadc(0)
adc2 = adc.readadc(2)
adc6 = adc.readadc(6)
value = 2 * (adc2 - adc0)
value2 = 2 * (adc6 - adc0)
value3 = 2 * (adc6 - adc2)
a = (value, value2, value3)
return a
def sample():
# Debugging
#value = math.sin(time.time()*60*2*math.pi)
#value2 = math.sin(time.time()*120*2*math.pi) * math.sin(time.time()*10*2*math.pi)
#value3 = math.sin(time.time()*70*2*math.pi)
# Slower, but timing more in-sync
#value = (adc.readadc(6) - adc.readadc(2))
#value2 = (adc.readadc(0) - adc.readadc(6))
#value3 = (adc.readadc(2) - adc.readadc(6))
adc0 = adc.readadc(0)
adc2 = adc.readadc(2)
adc6 = adc.readadc(6)
value = 2 * (adc2 - adc0)
value2 = 2 * (adc6 - adc0)
value3 = 2 * (adc6 - adc2)
a = (value, value2, value3)
return a
def MQCalibration(self):
val=0
raw_calib = readadc(self.analog)
for i in range(0, self.CALIBARAION_SAMPLE_TIMES): #take multiple samples
val += self.MQResistanceCalculation(readadc(self.analog))
time.sleep(self.CALIBRATION_SAMPLE_INTERVAL)
val = val/self.CALIBARAION_SAMPLE_TIMES; #calculate the average value
val = val/self.RO_CLEAN_AIR_FACTOR; #divided by RO_CLEAN_AIR_FACTOR yields the Ro
#according to the chart in the datasheet
edit_calib_config("MQ6", val)
edit_calib_config("MQ6_RAW", raw_calib)
log.info("Calibrated, Ro = " + str(val))
if(self.verbose):
print "<{}> :: Calibration is done...".format(self.device_name)
print "<{}> :: Ro = ".format(self.device_name), self.Ro , " kohm"
return val
def read(name, pin, verbose=True):
if name == "mq135" or name == "mq4" or name == "mq6":
val = readadc(pin)
print (name + "read is " + str(val))
return val, val
if name == "dust":
samplingTime = .280 / 1000
deltaTime = 40 / 1000000.0
sleepTime = 9680 / 1000000.0
GPIO.setmode(GPIO.BCM) # choose BCM or BOARD
GPIO.setup(pin[1], GPIO.OUT) # set GPIO24 as an output $pinMode(iled, OUTPUT);
GPIO.output(pin[1],0) # to set port/pin to High, use => 1/GPIO.HIGH/True #digitalWrite(iled, LOW); //iled default closed
time.sleep(0.1)
GPIO.output(pin[1], 1)
time.sleep(samplingTime)
adcvalue = readadc(pin[0])
GPIO.output(pin[1], 0)
return adcvalue, adcvalue
if name=="dht11":
GPIO.setmode(GPIO.BCM)
instance = dht11.DHT11(pin=pin)
lastknown = (23, 35)
result1, result2 = lastknown
try:
result = instance.read()
if (result.is_valid):
result1 = result.temperature
result2 = result.humidity
if(result2==0):
result1, result2 = lastknown
if(verbose):
print "<{}> :: Temperature ::".format(name), result1
print "<{}> :: Humidity ::".format(name), result2
else:
result1, result2 = lastknown
if (verbose):
print "<{}> :: Temperature :: NOT VALID".format(name)
print "<{}> :: Humidity :: NOT VALID".format(name)
lastknown = result1, result2
return result1, result2
except:
print("ERROR in READ...read_temp")
def MQCalibration(self):
val = 0.0
for i in range(0, self.CALIBARAION_SAMPLE_TIMES):
val += self.MQResistanceCalculation(readadc(self.analog))
time.sleep(self.CALIBRATION_SAMPLE_INTERVAL)
val = val / self.CALIBARAION_SAMPLE_TIMES
val = val / self.RO_CLEAN_AIR_FACTOR
return val
def read(self):
pp = -1
# try:
self.setup()
time.sleep(0.1)
GPIO.output(self.PIN_ILED, 1)
time.sleep(self.samplingTime)
#GPIO.output(self.PIN_ILED, 0)
#time.sleep(self.samplingTime)
adcvalue = readadc(self.analog)
if (self.verbose):
print "<{}> :: value read from adc = ".format(
self.device_name), adcvalue
#time.sleep(self.deltaTime)
GPIO.output(self.PIN_ILED, 0)
#time.sleep(self.sleepTime)
#adcvalue = self.Filter(adcvalue)
if (self.verbose):
print "<{}> :: adc value filtered = ".format(
self.device_name), adcvalue
# /*
# convert voltage (mv)
# */
voltage = (self.SYS_VOLTAGE / 1024.0) * adcvalue * 11
if (self.verbose):
print "<{}> :: filtered voltage value = ".format(
self.device_name), voltage, " mv"
# /*
# voltage to density
# */
if (voltage >= self.NO_DUST_VOLTAGE):
voltage -= self.NO_DUST_VOLTAGE
density = voltage * self.COV_RATIO
else:
density = 0
# /*
# display the result
# */
if (self.verbose):
print "<{}> Dust concentration: ".format(
self.device_name), density, " ug/m3 "
pp = density
# except (SystemExit, KeyboardInterrupt):
# raise
# except Exception, e:
# eprint("ERROR in READ...PI/sensors/dust.py")
return pp, adcvalue
def calibrate135(self):
avg = 0
n = 0
try:
while n < 100:
x = self.getRZero()
n += 1
avg = (avg * (n - 1) + x) / n
print avg, "kohm, Adcout:", readadc(self.ADC_CHANNEL)
time.sleep(0.5)
except KeyboardInterrupt: # If CTRL+C is pressed, exit cleanly:
print 'bye'
return avg
def calibrate135(self):
avg = 0
n = 0
try:
while n<100:
x = self.getRZero()
n += 1
avg = (avg * (n - 1) + x) / n
print avg, "kohm, Adcout:", readadc(self.ADC_CHANNEL)
time.sleep(0.5)
except KeyboardInterrupt: # If CTRL+C is pressed, exit cleanly:
print 'bye'
return avg
def MQCalibration(self):
val = 0
for i in range(0,
self.CALIBARAION_SAMPLE_TIMES): #take multiple samples
val += self.MQResistanceCalculation(readadc(self.analog))
time.sleep(self.CALIBRATION_SAMPLE_INTERVAL)
val = val / self.CALIBARAION_SAMPLE_TIMES
#calculate the average value
val = val / self.RO_CLEAN_AIR_FACTOR
#divided by RO_CLEAN_AIR_FACTOR yields the Ro
#according to the chart in the datasheet
return val
def read(self):
val = -1
try:
ans = 0.0
for i in range(0, 20):
cur = self.MQGetGasPercentage(readadc(self.analog) / self.Ro, self.GAS_meth)
ans += cur
time.sleep(1.0 / 100.0)
if (self.verbose):
print "<{}> Methane concentration: ".format(self.device_name), ans / 20.0 * 10000, " ppm"
val = ans / 20.0 * 10000
except:
eprint("<MQ4> ERROR in READ...sensors/mq4.py")
log.error('ERROR in READ...sensors/mq4.py')
return val
def auto_calibrate(self):
try:
avg = 0
n = 0
#try:
while n < 10:
x = self.getRZero()
n += 1
avg = (avg * (n - 1) + x) / n
time.sleep(0.5)
except Exception as e:
log.error('ERROR in CALIBRATE...sensors/mq135.py')
raw_calib = readadc(self.analog)
edit_calib_config("MQ135", avg)
edit_calib_config("MQ135_RAW", raw_calib)
log.info('Calibrated, RZERO = ' + str(avg))
return avg
def read(self):
val = -1
try:
ans = 0.0
for i in range(0, 20):
cur = self.MQGetGasPercentage(
readadc(self.analog) / self.Ro, self.GAS_meth)
ans += cur
time.sleep(1.0 / 100.0)
if (self.verbose):
print "<{}> Methane concentration: ".format(
self.device_name), ans / 20.0 * 10000, " ppm"
val = ans / 20.0 * 10000
except:
eprint("<MQ4> ERROR in READ...sensors/mq4.py")
log.error('ERROR in READ...sensors/mq4.py')
return val
def auto_calibrate(self):
try:
avg = 0
n = 0
#try:
while n < 10:
x = self.getRZero()
n += 1
avg = (avg * (n - 1) + x) / n
time.sleep(0.5)
except Exception as e:
log.error('ERROR in CALIBRATE...sensors/mq135.py')
raw_calib = readadc(self.analog)
edit_calib_config("MQ135", avg)
edit_calib_config("MQ135_RAW", raw_calib)
log.info('Calibrated, RZERO = '+str(avg))
return avg
def read(self):
val = -1
try:
# print("Calibrating..")
Ro = self.MQCalibration()
# print("Calibration is done...")
# print "Ro=", Ro, "kohm"
ans = 0.0
# print("Methane: "),
for i in range(0, 20):
cur = self.MQGetGasPercentage(
readadc(self.analog) / Ro, self.GAS_meth)
ans += cur
time.sleep(1.0 / 100.0)
if (self.verbose):
print "<{}> Methane concentration: ".format(
self.device_name), ans / 20.0, " ppm"
val = ans / 20.0
except:
eprint("ERROR in READ...PI/sensors/mq4.py")
log.exception('ERROR in READ...PI/sensors/mq4.py')
return val
# Устанавливаем режимы пинов интерфейса SPI
# set up the SPI interface pins
GPIO.setup(SPIMOSI, GPIO.OUT)
GPIO.setup(SPIMISO, GPIO.IN)
GPIO.setup(SPICLK, GPIO.OUT)
GPIO.setup(SPICS, GPIO.OUT)
# 10k trim pot connected to adc #7
# Сенсор подключен на седьмой вход АЦП
hydr_adc = 7
last_read = 0 # Переменная отслеживает последнее считанное с потенциометра значение
tolerance = 7 # Минимальное изменение значения. Новое значение с потенциометра будем
# считывать только тогда, когда разница между текущим и предудущим значением
# будет больше tolerance. Необходимо для устранения дребезжания
# Основной бесконечный цикл
while True:
input()
# Считываем очередное значение с АЦП
# read the analog pin
hum_raw_value = adc.readadc(hydr_adc, SPICLK, SPIMOSI, SPIMISO, SPICS)
print('Humidity = {hum}' .format(hum = hum_raw_value)) # выводим новое значение частоты на экран
# Ничего не делаем 1/10-ю секунды
# hang out and do nothing for a 1/10th of second
time.sleep(0.1)
def read_raw(self):
return readadc(self.analog)
def read_raw(self):
return readadc(self.analog)
def getResistance(self):
val = readadc(self.ADC_CHANNEL)
print val
return ((1023. / val) * 5. - 1.) * self.RLOAD
def main():
"""
Основной блок программы
Main program block
:return: None
"""
# 10k trim pot connected to adc #1
# Потенциометр подключен на первый вход АЦП
potentiometer_adc = 7
last_read_percent = 0 # Переменная отслеживает последнее считанное с потенциометра значение
tolerance = 7 # Минимальное изменение значения. Новое значение с потенциометра будем
# считывать только тогда, когда разница между текущим и предудущим значением
# будет больше tolerance. Необходимо для устранения дребезжания
MAX_VALUE = 1023
#####################################################################
# Все порты к дисплею устанавливаем на вывод:
GPIO.setup(LCD_E , GPIO.OUT) # E
GPIO.setup(LCD_RS, GPIO.OUT) # RS
GPIO.setup(LCD_D4, GPIO.OUT) # DB4
GPIO.setup(LCD_D5, GPIO.OUT) # DB5
GPIO.setup(LCD_D6, GPIO.OUT) # DB6
GPIO.setup(LCD_D7, GPIO.OUT) # DB7
# Инциализируем дисплей
lcd.init()
# Устанавливаем режимы пинов интерфейса SPI
# set up the SPI interface pins
GPIO.setup(SPIMOSI, GPIO.OUT)
GPIO.setup(SPIMISO, GPIO.IN)
GPIO.setup(SPICLK, GPIO.OUT)
GPIO.setup(SPICS, GPIO.OUT)
potentiometer_adc = 7
last_read_percent = 0 # Переменная отслеживает последнее считанное с потенциометра значение
tolerance = 1 # Минимальное изменение значения. Новое значение с потенциометра будем
# считывать только тогда, когда разница между текущим и предудущим значением
# будет больше tolerance. Необходимо для устранения дребезжания
while True:
# Будем считать, что потенциометр не изменил положение
# we'll assume that the pot didn't move
hum_changed = False
# Считываем очередное значение с АЦП
hum_raw_value = adc.readadc(potentiometer_adc, SPICLK, SPIMOSI, SPIMISO, SPICS)
hum_value = abs(hum_raw_value - 1023)
percent = round(hum_value * 100.0 / MAX_VALUE)
# Вычисляем разницу между текущим и прошлым значением
# how much has it changed since the last read?
pot_adjust = abs(percent - last_read_percent)
# Если изменение больше tolerance
if pot_adjust > tolerance:
# Считаем, что ...
hum_changed = True
# Если потенциометр повернулся...
if ( hum_changed ):
lcd.string(' Humidity = {hum}%' .format(hum = percent), LCD_LINE_1)
# Сохраняем последнее считанное значение до следующей итерации
# save the potentiometer reading for the next loop
last_read_percent = percent
# Ничего не делаем 1/10-ю секунды
# hang out and do nothing for a 1/10th of second
time.sleep(0.1)
def getResistance(self):
val = readadc(self.ADC_CHANNEL)
return ((1023. / val) * 5. - 1.) * self.RLOAD
elif started == True:
if ldr > 200:
camera.stop_recording()
started = False
server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login("*****@*****.**", "cam25project")
mse = "Subject: {}\n\n{}".format(
"NEW LIGHT INDUCED FOOTAGE CAPTURED",
"New light triggered video captured")
server.sendmail("*****@*****.**", "*****@*****.**",
mse)
server.quit()
@anvil.server.callable
def display_message():
"""Callable function to display appropriate alert on button press"""
global message
return message
try:
while True:
if online2 == True:
light_induced(adc.readadc(0))
print "light = ", adc.readadc(0)
except KeyboardInterrupt:
print("program terminated"
) # This is the output when the program is terminated