#Importing machine
#Importing ADC
from machine import ADC
from machine import Pin
from time import sleep
#Create an ADC object on pin 32
adc = ADC(Pin(32))
#Setting 11dB input attenuation (Voltage between 0 and 3.6v)
adc.atten(ADC.ATTN_11DB)
#setting 9 bit return values to receive values between 0 and 511
adc.width(ADC.WIDTH_9BIT)
while True:
#Reading the analog value
#GPIO pin 32 is connected to a potentiometer
val = adc.read()
print(val)
sleep(1)
def __init__(self, port):
port_nums = [0, 4, 6]
self.adc = ADC(port_nums[port])
'''
from machine import ADC
import os
mch = os.uname().machine
if 'LaunchPad' in mch:
adc_pin = 'GP5'
adc_channel = 3
elif 'WiPy' in mch:
adc_pin = 'GP3'
adc_channel = 1
else:
raise Exception('Board not supported!')
adc = ADC(0)
print(adc)
adc = ADC()
print(adc)
adc = ADC(0, bits=12)
print(adc)
apin = adc.channel(adc_channel)
print(apin)
apin = adc.channel(id=adc_channel)
print(apin)
apin = adc.channel(adc_channel, pin=adc_pin)
print(apin)
apin = adc.channel(id=adc_channel, pin=adc_pin)
print(apin)
'''
检测ADC采样值是否发生变化，如果发生变化就打印出来
采用均值滤波
'''
from machine import ADC,Pin
import utime
# 设置D34号引脚作为ADC采样引脚
pin_read = Pin(34,Pin.IN)
# 声明ADC对象
adc = ADC(pin_read)
# 设置衰减比 满量程3.3v
adc.atten(ADC.ATTN_11DB)
# 设置数据宽度为10bit
adc.width(ADC.WIDTH_10BIT)
last_value = 0
sample_times = 10
while True:
# 做一个简单的均值滤波
value_sum = 0
for i in range(sample_times):
value_sum += adc.read()
# 计算ADC采样的均值
value_mean = value_sum / sample_times
# 判断是否发生了变化
if abs(last_value-value_mean) > 2:
# 打印日志
print("电位计采样: %d"%value_mean)
# 更新last value
m = mandelbrot(c) # Compute the number of iterations
colorIndex = int(m/11) #colors[m//12]
if colorIndex > 0:
display.pixel(x, y, colors[colorIndex]) # Plot the point
print("Total Time={}!!!!!".format(time.ticks_diff(time.ticks_ms(), ticks_start)))
building = False
display = init_tft();
#button is used to start building Mandelbrot Set
button=Pin(9, Pin.IN, Pin.PULL_DOWN)
#3 potentiometers are used to parametrise zom, zoom pan x and pan y
#they are wired to ground and 3.3V and middle pin's voltage goes to
#ADC to get varing value into the pico.
zoom = ADC(28)
pan_x = ADC(27)
pan_y = ADC(26)
buildFractal()
while True:
if button.value()==1:
print("button pressed")
time.sleep_ms(500)
ZOOM_RE = 1 * (zoom.read_u16() / 65535.0) #full signal=no zoom
ZOOM_IM = 1.5 * (zoom.read_u16() / 65535.0) #full signal=no zoom
OFFSET_RE = ((pan_x.read_u16() / 65535.0) - 0.5) * 5.5
OFFSET_IM = ((pan_y.read_u16() / 65535.0) - 0.5) * 2.7
print("zoom_re={}, zoom_im={}".format(ZOOM_RE,ZOOM_IM))
print("offset_re ={}, offset_im={}".format(OFFSET_RE,OFFSET_IM))
if g.pressed(g.btnD):
g.display.text("D",20, 50,1)
g.playTone('f4', tone_dur)
g.tone_vol= max (g.tone_vol-1, 0)
else :
g.display.text(":",20, 50,1)
if g.pressed(g.btnA):
g.display.text("A",80, 40,1)
g.playTone('c5', tone_dur)
else :
g.display.text(":",80, 40,1)
if g.pressed(g.btnB):
g.display.text("B",100, 40,1)
g.playTone('d5', tone_dur)
else :
g.display.text(":",100, 40,1)
g.display.text (str(ADC(0).read()), 0,10,1)
g.display.text (str(g.getPaddle()), 80,10,1)
g.display.text (str(g.tone_vol), 40,10,1)
g.display.show()
# wait till keys are released
g.pressed(g.btnL,True)
from machine import ADC, Pin
adc = ADC(Pin(34))
adc.atten(ADC.ATTN_6DB)
while Thread[0]:
print(str(adc.read()))
def __init__(self, pin, attn=ATTN_11DB, width=WIDTH_12BIT):
self._pin = ADC(Pin(pin))
self._pin.atten(ATTN[attn])
self._pin.width(WIDTH[width])
self._max_adc = 2**(9 + WIDTH[width]) - 1
from machine import Pin, ADC
from time import sleep
LDR = 32
ldr = ADC(Pin(LDR))
#LDR = 19
#ldr = Pin(LDR,Pin.IN)
#''change read to value''
while (1):
print(ldr.read())
sleep(0.5)
from machine import Pin, ADC #打開, 關閉
import time
from keras_lite import Model
import ulab as np
#增加神經網路的參數
mean = 112.06158333333333 #平均值
std = 245.64491731346183 #標準差
model = Model('voice_model.json') # 建立模型物件
label_name = ['on', 'off', 'others'] # label名稱
led = Pin(25, Pin.OUT, value=0) # LED燈腳位
adc = ADC(Pin(36)) # 設定36為ADC腳位
adc.width(ADC.WIDTH_12BIT)
adc.atten(ADC.ATTN_11DB) # 設定最大電壓為3.6V
while True:
sound = adc.read() # 接收聲音
if (sound > 100): # 有聲音時
print('')
no_sound = 0 # 重置沒聲音次數
data = [sound] # 重置data
# 沒聲音次數少於150或超過資料儲存量時
while (no_sound < 150 and len(data) < 550):
sound = adc.read() # 接收聲音
data.append(sound)
if (sound == 0): # 沒聲音時
no_sound += 1 # 沒聲音次數+1
else: # 有聲音時
no_sound = 0 # 重置聲音次數
# In order for this to work, you'll need a light sensor connected, which wasn't
# in the kit.
from machine import ADC
from common import speaker, button, VOLUME_OFF, VOLUME_OFF, oled_page
import time
import math
light_sensor = ADC(1)
oled_page("Light theramin", "Expose sensor", "to more/less", "light. Press",
"button to stop")
speaker.duty_u16(VOLUME_MAX)
print("""
Raise and lower your hands over the light sensor or shine a light on it
(it's between the Pico and the screen.)
To stop, press the black button.
""")
prev = light_sensor.read_u16()
while button.value() == 1:
light = light_sensor.read_u16()
print(light)
if abs(prev - light) > 200:
speaker.freq(light // 10)
prev = light
time.sleep(0.1)
def TakeMeasurement(CONF_WEATHER, calib_factor):
from machine import Pin, I2C, ADC
from math import pow, sqrt, fabs
from time import sleep
import sys
#import bme280_float # https://github.com/robert-hh/BME280
import bme280_int
result = {}
def convertToF(tempC):
return tempC * 1.8 + 32
i2c = I2C(scl=Pin(5), sda=Pin(4))
#bme = bme280_float.BME280(i2c=i2c)
bme = bme280_int.BME280(i2c=i2c)
# wait a sec
sleep(1)
# read data from bme280
bme_data_tph = bme.read_compensated_data()
# Get Temperature
# result['temp_C'] = bme_data_tph[0] + CONF_WEATHER['TEMP_CORR']
# result['temp_F'] = convertToF(result['temp_C'])
#temp_C = bme_data_tph[0] + CONF_WEATHER['TEMP_CORR']
temp_C = bme_data_tph[0] / 100.0 + CONF_WEATHER['TEMP_CORR']
result['temp_F'] = convertToF(temp_C)
# output = ['Temp: %.2f °C, %.2f °F; ' % (result['temp_C'], result['temp_F'])]
output = ['Temp: %.2f °C, %.2f °F; ' % (temp_C, result['temp_F'])]
# Get Humidity
#result['humidity'] = bme_data_tph[2]
result['humidity'] = bme_data_tph[2] / 1024.0
output.append('Humidity: %.2f %%; ' % result['humidity'])
# Get Pressure
# result['measured_Pres_hPa'] = bme_data_tph[1] / 100
#measured_Pres_hPa = bme_data_tph[1] / 100
measured_Pres_hPa = bme_data_tph[1] / 25600.0
#result['measured_Pres_inHg'] = bme_data_tph[1] / 3386.38867
result['measured_Pres_inHg'] = bme_data_tph[1] / 866915.49952
# output.append('Pressure: %.2f hPa, %.2f inHg; ' % (result['measured_Pres_hPa'], result['measured_Pres_inHg']))
output.append('Pressure: %.2f hPa, %.2f inHg; ' %
(measured_Pres_hPa, result['measured_Pres_inHg']))
# Calculate Relative Pressure
# SLPressure_hPa = (((measured_Pres_hPa * 100.0)/pow((1-(float(CONF_WEATHER['ELEVATION']))/44330), 5.255))/100.0)
# https://keisan.casio.com/exec/system/1224575267
SLPressure_hPa = measured_Pres_hPa * pow(
1 - .0065 * CONF_WEATHER['ELEVATION'] /
(temp_C + 273.15 + .0065 * CONF_WEATHER['ELEVATION']), -5.257)
result['rel_Pres_Rounded_hPa'] = round(SLPressure_hPa)
result['rel_Pres_inHg'] = (SLPressure_hPa) / 33.8638867
output.append('Pressure rel: %d hPa, %.2f inHg; ' %
(result['rel_Pres_Rounded_hPa'], result['rel_Pres_inHg']))
# Get Dewpoint
# result['dewPt_C'] = bme.dew_point
# result['dewPt_F'] = convertToF(result['dewPt_C'])
result['dewPt_F'] = convertToF(bme.dew_point)
# output.append('Dewpoint: %.2f °C, %.2f °F; ' % (result['dewPt_C'], result['dewPt_F']))
output.append('Dewpoint: %.2f °F; ' % result['dewPt_F'])
# Dewpoint Spread
result['dewPtSpread_F'] = result['temp_F'] - result['dewPt_F']
output.append('Dewpoint Spread: %.2f °F; ' % result['dewPtSpread_F'])
# Calculate HI (heatindex) --> HI starts working above 26.7°C
# Reference: https://www.wpc.ncep.noaa.gov/html/heatindex_equation.shtml
# Calculation is in Fahrenheit
if temp_C > 26.7:
c1 = -42.379
c2 = 2.04901523
c3 = 10.14333127
c4 = -0.22475541
c5 = -6.83783e-3
c6 = -5.481717e-2
c7 = 1.22874e-3
c8 = 8.5282e-4
c9 = -1.99e-6
T = result['temp_F']
R = result['humidity']
Tsq = T * T
Rsq = R * R
result['heatIndex_F'] = (c1 + c2 * T + c3 * R + c4 * T * R + c5 * Tsq +
c6 * Rsq + c7 * Tsq * R + c8 * T * Rsq +
c9 * Tsq * Rsq)
if T <= 112 and R < 13:
result['heatIndex_F'] -= ((13 - R) / 4) * sqrt(
(17 - fabs(T - 95.0)) / 17)
if T <= 87 and R > 85:
result['heatIndex_F'] += ((R - 85) / 10) * ((87 - T) / 5)
output.append('HeatIndex: %.2f °F; ' % result['heatIndex_F'])
else:
result['heatIndex_F'] = result['temp_F']
print('Not warm enough (less than 80.1 °F) for Heat Index')
# Battery Voltage
# Voltage Divider R1 = 220k+100k+220k = 540K and R2 = 100k
adc = ADC(0)
raw = adc.read()
result['volt'] = raw * calib_factor / 1024
output.append('Voltage: %.2f V\n' % result['volt'])
print(''.join(output))
# round floats to 2 decimal places
result = dict(
zip(
result,
map(lambda x: round(x, 2) if isinstance(x, float) else x,
result.values())))
del bme
#del sys.modules['bme280_float']
del sys.modules['bme280_int']
return result
# reads the analogue value from the slider potentiometer connected to the ADC
# on pin 36 marked A0 on the ESP32 CPU board
# Copyright U. Raich 2020
# The program is part of the IoT course at the University of Cape Coast, Ghana
from machine import Pin, ADC
from time import sleep
slider = ADC(Pin(36)) # create ADC object on ADC pin 36
slider.atten(ADC.ATTN_11DB)
while True:
print("Slider: ", slider.read())
sleep(0.5)
global errorcount
try:
status = urequests.post(post_url, data=post_data.format(keepalive, solarRaw))
print(status.status_code)
status.close()
errorcount = 0
except Exception as e:
print("Error no. {}".format(errorcount), e)
errorcount+=1
if errorcount > 4:
machine.reset()
else:
net.disconnect()
net.connect()
wait_connect()
wait_connect()
solarVoltAdc = ADC(Pin(34))
solarVoltAdc.atten(ADC.ATTN_11DB)
while True:
solarRaw = solarVoltAdc.read()
sendData(keepalive, solarRaw)
print("Solar RAW: {0}, freeMem: {1}".format(solarRaw, gc.mem_free()))
gc.collect()
time.sleep(30)
keepalive+=1
from machine import ADC, Pin
sensor = ADC(Pin(34))
# sensor.atten(ADC.ATTN_11DB)
# 11DB attenuation allows for a maximum input voltage
# of approximately 3.6v (default is 0-1.0v)
SENSOR_SATURATION_LEVEL = 3840
SENSOR_DRYNESS_LEVEL = 4095
def readSoilMoisture():
value = sensor.read()
voltage = value / 1000 # convert digital value to decimal
percentage = 100.00 * (SENSOR_DRYNESS_LEVEL -
value) / SENSOR_SATURATION_LEVEL
print('\nsensor_value: ', value)
print('sensor_voltage: ', voltage)
print('moisture_percentage: ', percentage)
print('difference: ', SENSOR_DRYNESS_LEVEL - value)
return value, voltage, percentage
#with open('topic', 'r') as f:
# topic = f.read().strip()
with open('location', 'r') as f:
loc = f.read().strip()
topic = 'sonos/{}/track'.format(loc)
print("mqtt_id =", mqtt_id)
print("host =", mqtt_aws_host)
print("topic =", topic)
p15 = Pin(15, Pin.IN, Pin.PULL_UP) #button on homemade volume play/pause board
adc = ADC(Pin(36))
i2c = I2C(scl=Pin(22), sda=Pin(23)) #speed=100000 is the default
d = SSD(width=128, height=32, i2c=i2c, external_vcc=False)
d.init_display()
d.text("Hello Steve", 0, 0)
d.show()
print("version plays wnyc")
print("mqtt_id =", mqtt_id)
print("location =", loc)
print("mqtt_aws_host =", mqtt_aws_host)
def wrap(text, lim):
from machine import Pin, PWM, ADC
from time import sleep
frequency = 5000
led = PWM(Pin(5), frequency)
pot = ADC(Pin(34))
pot.width(ADC.WIDTH_10BIT)
pot.atten(ADC.ATTN_11DB)
while True:
pot_value = pot.read()
print(pot_value)
if pot_value < 15:
led.duty(0)
else:
led.duty(pot_value)
sleep(0.1)
# mpython-box buildin periphers drivers
# history:
# V1.0 zhaohuijiang
from machine import Pin, ADC
import time, ujson
from mpython_classroom_kit_driver import K210, K210Error
from mpython import i2c
import ubinascii
# human infrared
pir = Pin(21, mode=Pin.IN, pull=None)
# slide POT
slider_res = ADC(Pin(34))
slider_res.atten(slider_res.ATTN_11DB)
k210 = K210()
def get_distance():
"""超声波,范围2~340cm"""
return k210.get_distance()
def get_key():
"""方向按键,返回按键列表"""
key_map = {0: 'left', 1: 'right', 2: 'up', 3: 'down', 4: 'ok'}
key_set = set()
_key = k210.get_key()
# CS -----> GP5 (pin 7) # # A pot on GP26 (ADC0), used to change speed of the animation # A push-button on GP14, used to halt the script # from machine import Pin, SPI, ADC from sh1122 import SH1122_SPI import time import framebuf WIDTH = 256 # oled display width HEIGHT = 64 # oled display height pot = ADC(0) button = Pin(14, Pin.IN, Pin.PULL_UP) spi = SPI(0) # Init SPI0 dc = Pin(4, Pin.OUT) dc.value(0) res = Pin(3, Pin.OUT) res.value(1) cs = Pin(5, Pin.OUT) cs.value(1) oled = SH1122_SPI(WIDTH, HEIGHT, spi, dc, res, cs) # Init oled display # import workers # 2 pixels per byte from workers1 import workers1 as image1
from machine import ADC, Pin
from utime import sleep_ms
ADC_PIN = 36
adc = ADC(Pin(ADC_PIN))
adc.atten(ADC.ATTN_11DB)
for _ in range(100):
val = adc.read() >> 4
print("0x%03x" % val)
sleep_ms(20)
def __init__(self, pin, offset):
self.pin = pin
self.offset = offset
self.adc = ADC(bits=12)
self.apin = self.adc.channel(pin=self.pin, attn=ADC.ATTN_11DB)
def __init__(self, pin):
self.adc = ADC(Pin(pin))
self.adc.atten(ADC.ATTN_11DB)
def __init__(self, pin):
self.old, self.new, self.eliminate = 0, 0, 100
from machine import ADC, Pin
self.adc = ADC(Pin(pin, Pin.IN))
self.adc.atten(ADC.ATTN_11DB) # 0-3.9V
def read_analog(self):
id = int(str(self)[4:-1]) #unsafe!
self = ADC(Pin(id))
return self.read()
import network
import urequests
import json
from machine import ADC, Pin
from time import sleep
import math
from _thread import start_new_thread as thread
beat = ADC(Pin(32))
beat.atten(ADC.ATTN_11DB)
messure_time = 5
messure_sleep = 0.02
messure_loop = int(messure_time // messure_sleep)
ssid = 'exceed16_6'
pwd = '12345678'
station = network.WLAN(network.STA_IF)
station.active(True)
url = "https://exceed.superposition.pknn.dev/data/group_one"
data = {"Temp": 0.00, "HeartRate": 0.00}
headers = {"content-type": "application/json"}
#-------#
RawADC = ADC(Pin(34))
RawADC.atten(ADC.ATTN_11DB)
def Thermistor(RawADC):
from machine import Pin, ADC, PWM
import time
pressed = False
def handle(pin):
global pressed
pressed = True
frequency = 10000
button = Pin(12, Pin.IN, Pin.PULL_UP)
button.irq(trigger=Pin.IRQ_FALLING, handler=handle)
light = ADC(0)
led = PWM(Pin(15), frequency)
buzzer = PWM(Pin(14), frequency)
while True:
if pressed:
first = button.value()
time.sleep_ms(10)
second = button.value()
light_val = light.read()
led.duty(light_val)
buzzer.duty(light_val)
if not first and second:
pressed = False
led.duty(0)
buzzer.duty(0)
Beware:
Using the standard implementation of MicroPython on the ESP32, only the ADC1 GPIOS can be used for ADC. These are
GPIOS 36, 39, 34, 35, 32, 33.
We must scale a ADC value to the PWM range to correctly control the LED.
To do so, divide 1023/4095 = 0.24, and multiply the actual ADC value by 0.24.
Course:
MicroPython with the ESP32
https://techexplorations.com
'''
from machine import ADC, Pin, Timer
z = ADC(Pin(34))
x = ADC(Pin(32))
y = ADC(Pin(35))
x.atten(ADC.ATTN_11DB)
y.atten(ADC.ATTN_11DB)
z.atten(ADC.ATTN_11DB)
def adxl335_sensor_isr(event):
x_value = x.read()
y_value = y.read()
z_value = z.read()
print("x:", x_value, ",y: ", y_value, ",z: ", z_value)
import time
from machine import Pin, ADC, DAC
from onewire import DS18X20
from onewire import OneWire
from dht import DHT
adc = ADC()
# adc.vref_to_pin('P21')
adc.vref(1058)
vBiasDAC = DAC('P22')
vBiasDAC.write(0.135) # approximately 0.5 V
vPanel = adc.channel(pin='P13', attn = ADC.ATTN_11DB)
vBatt = adc.channel(pin='P14', attn = ADC.ATTN_11DB)
vPyra = adc.channel(pin='P15', attn = ADC.ATTN_11DB)
vTherm = adc.channel(pin='P17', attn = ADC.ATTN_11DB)
vBias = adc.channel(pin='P18', attn = ADC.ATTN_11DB)
powerPin = Pin('P8', mode=Pin.OUT)
powerPin(1)
ow = OneWire(Pin('P4'))
temp = DS18X20(ow) # DS18X20 must be powered on on instantiation (rom scan)
powerPin(0)
th = DHT('P3',1)
def medir(n=1):
powerPin(1)
from machine import RTC, Pin, I2C, SPI, ADC
from time import sleep
import ssd1306
rtc = RTC()
rtc.datetime((2019, 9, 25, 4, 16, 5, 0, 0))
rtc.datetime()
# init button
button_A = Pin(12, Pin.IN, Pin.PULL_UP)
button_B = Pin(13, Pin.IN)
button_C = Pin(14, Pin.IN, Pin.PULL_UP)
sensor = Pin(15, Pin.OUT)
sensor.value(1)
adc = ADC(0)
# counter indicates the current operate element in datetime
counter = 0
# construct an I2C bus in LED
i2c = I2C(-1, Pin(5), Pin(4))
oled = ssd1306.SSD1306_I2C(128, 32, i2c)
# write and show real time
def week(n_week):
if (n_week == 1): return 'Monday'
elif (n_week == 2): return 'Tuesday'
elif (n_week == 3): return 'Wednesday'
elif (n_week == 4): return 'Thursday'
elif (n_week == 5): return 'Friday'
elif (n_week == 6): return 'Saturday'
elif (n_week == 7): return 'Sunday'
return 'Monday'
def peripheral_query(is_init, p_out_ctrla, p_out_ctrlb):
import pycom
import time
import socket
import binascii
import struct
import gc
import sys
import os
import uio
import ujson
from machine import UART
from machine import ADC
from machine import I2C
from machine import SPI
from machine import Pin
from tsl2591 import TSL2591
with uio.open('/flash/configure.json', 'r', encoding="utf-8") as hdl:
parsed_json = ujson.load(hdl)
sht31 = parsed_json["firmware"]["sht31"]
bias_nh3 = parsed_json["calibration"]["sensor_nh3"]["bias"]
bias_so2 = parsed_json["calibration"]["sensor_so2"]["bias"]
bias_h2s = parsed_json["calibration"]["sensor_h2s"]["bias"]
di_nh3 = parsed_json["calibration"]["sensor_nh3"]["di"]
di_so2 = parsed_json["calibration"]["sensor_so2"]["di"]
di_h2s = parsed_json["calibration"]["sensor_h2s"]["di"]
i0_nh3 = parsed_json["calibration"]["sensor_nh3"]["i0"]
i0_so2 = parsed_json["calibration"]["sensor_so2"]["i0"]
i0_h2s = parsed_json["calibration"]["sensor_h2s"]["i0"]
vref = parsed_json["calibration"]["vref"]
p_data = PeripheralData()
print('[2]===================')
adc0 = ADC(id=0)
outer_iter = 0
outer_iter_times = 20
outer_buff_NH3 = []
outer_buff_SO2 = []
outer_buff_H2S = []
while outer_iter < outer_iter_times:
filtered_mvolts = _get_filtered_mvolts(adc0, vref)
outer_buff_NH3.append(filtered_mvolts.NH3)
outer_buff_SO2.append(filtered_mvolts.SO2)
outer_buff_H2S.append(filtered_mvolts.H2S)
outer_iter = outer_iter + 1
buff_nh3 = sum(outer_buff_NH3) / outer_iter_times
buff_so2 = sum(outer_buff_SO2) / outer_iter_times
buff_h2s = sum(outer_buff_H2S) / outer_iter_times
buff_nh3 = round((buff_nh3 - bias_nh3 - i0_nh3 * 47 * 0.624) * 50 /
(di_nh3 * 47 * 0.624), 1)
adc0_str = '%.1f' % ((buff_nh3))
p_data.NH3 = (buff_nh3)
print('[2]NH3: ' + adc0_str)
buff_so2 = round((buff_so2 - bias_so2 - i0_so2 * 47 * 0.624) * 20 /
(di_so2 * 47 * 0.624), 1)
adc1_str = '%.1f' % ((buff_so2))
p_data.SO2 = ((buff_so2))
print('[2]SO2: ' + adc1_str)
buff_h2s = round((buff_h2s - bias_h2s - i0_h2s * 47 * 0.624) * 50 /
(di_h2s * 47 * 0.624), 1)
adc2_str = '%.1f' % ((buff_h2s))
p_data.H2S = ((buff_h2s))
print('[2]H2S: ' + adc2_str)
adc0.deinit()
time.sleep(0.01)
adc3 = ADC(id=0) # create an ADC object
apin3 = adc3.channel(pin='P16') # create an analog pin on P16
adc3.vref(vref)
adc3_str = '%.2f' % (apin3() * 220 / 4096)
p_data.current = apin3() * 220 / 4096
print('[2]Current@5V: ' + adc3_str + 'mA')
adc3.deinit()
p_out_ctrla.value(0)
p_out_ctrlb.value(1)
uart_mul = UART(1, baudrate=9600, pins=('P3', 'P4'))
time.sleep(0.1)
co2_set = is_init
while co2_set == 0:
uart_mul.write('K 2\r\n')
time.sleep(0.05)
dumm = uart_mul.readline()
if dumm == bytes([]):
print('[2]CO2 sensor no respose!')
break
else:
dumm_str = dumm.decode('utf-8')
if dumm_str == ' K 00002\r\n':
print('[2]CO2 sensor polling set successfully...')
time.sleep(0.05)
co2_set = 1
else:
print('[2]CO2 sensor polling resetting...')
time.sleep(0.05)
uart_mul.write('M 00006\r\n')
time.sleep(0.05)
dumm_str = uart_mul.readall().decode('utf-8')
if dumm_str == ' M 00006\r\n':
print('[2]CO2 sensor key set successfully...')
time.sleep(0.05)
time.sleep(0.05)
number = 0
while number != 18:
dummy = uart_mul.readall()
uart_mul.write('Q\r\n')
time.sleep(0.1)
number = uart_mul.any()
data_str = uart_mul.readall().decode("utf-8")
print('[2]CO2_Filtered: ' + data_str[4:8])
print('[2]CO2_Instant: ' + data_str[12:16])
p_data.CO2 = int(data_str[4:8]) * 100 - 1600
print('[2]CO2: ' + ('%d' % (p_data.CO2)))
i2c = I2C(0, I2C.MASTER)
i2c.init(I2C.MASTER, baudrate=100000, pins=('P9', 'P10'))
time.sleep(0.05)
#print(i2c.scan())
if sht31 == 0:
i2c.writeto(0x40, bytes([0xF3]))
time.sleep(0.1)
temperature_data = i2c.readfrom(0x40, 3)
#print(temperature_data)
time.sleep(0.1)
temperature_value = _get_temperature_from_buffer(temperature_data)
p_data.temp = temperature_value
time.sleep(0.1)
i2c.writeto(0x40, bytes([0xF5]))
time.sleep(0.05)
humidity_data = i2c.readfrom(0x40, 3)
humidity_value = _get_humidity_from_buffer(humidity_data)
p_data.humd = humidity_value
humidity_value_str = '%.2f' % humidity_value
temperature_value_str = '%.2f' % temperature_value
print('[2]Humidity: ' + humidity_value_str)
print('[2]Temperature: ' + temperature_value_str)
else:
i2c.writeto(0x44, bytes([0x24, 0x00]))
time.sleep(0.02)
combined_data = i2c.readfrom(0x44, 6)
temperature_value = _get_sht31_temp_from_buffer(combined_data)
p_data.temp = temperature_value
humidity_value = _get_sht31_humidity_from_buffer(combined_data)
p_data.humd = humidity_value
humidity_value_str = '%.2f' % humidity_value
temperature_value_str = '%.2f' % temperature_value
print('[2]Humidity (SHT31): ' + humidity_value_str)
print('[2]Temperature (SHT31): ' + temperature_value_str)
lux_sensor = TSL2591(i2c)
lux_flt = lux_sensor.lux
p_data.lux = lux_flt
print('[2]Light: ' + '%.2f' % lux_flt + 'lux')
uart_mul = UART(1, baudrate=9600, pins=('P3', 'P4'))
p_out_ctrla.value(1)
p_out_ctrlb.value(0)
time.sleep(0.1)
ggflag = 0
ddflag = 0
while ggflag == 0 or ddflag == 0:
while uart_mul.any() == 0:
time.sleep(0.1)
nmealine_bytes = uart_mul.readall()
#print(nmealine_bytes)
time.sleep(0.1)
nmealine_all = nmealine_bytes.decode('utf-8')
nmealine_all_split = nmealine_all.split('\r\n')
for nmealine in nmealine_all_split:
if (nmealine[0:6] == '$GNGGA') and (len(nmealine.split(',')) >=
15) and (ggflag == 0):
nmea_fields = nmealine.split(',')
#print(nmea_fields)
print('[2]Time: ' + nmea_fields[1])
if nmea_fields[1] != '':
p_data.time = float(nmea_fields[1])
print('[2]Lat: ' + nmea_fields[2] + nmea_fields[3])
if nmea_fields[2] != '':
p_data.lat = float(nmea_fields[2])
if nmea_fields[3] == 'S':
p_data.lat *= -1
print('[2]Lon: ' + nmea_fields[4] + nmea_fields[5])
if nmea_fields[4] != '':
p_data.Lon = float(nmea_fields[4])
if nmea_fields[5] == 'W':
p_data.lon *= -1
print('[2]Fix: ' + nmea_fields[6])
print('[2]#Sat: ' + nmea_fields[7])
print('[2]HDOP: ' + nmea_fields[8])
print('[2]Alt: ' + nmea_fields[9])
if nmea_fields[9] != '':
p_data.alt = float(nmea_fields[9])
ggflag = 1
elif (nmealine[0:6]
== '$GNRMC') and (len(nmealine.split(',')) >= 13) and (ddflag
== 0):
nmea_fields = nmealine.split(',')
print('[2]Date: ' + nmea_fields[9])
if nmea_fields[9] != '':
p_data.date = int(nmea_fields[9])
ddflag = 1
dummy = uart_mul.readall()
p_data_bytes = PeripheralBytes(p_data)
print('[2]===================')
time.sleep(0.01)
gc.collect()
print(gc.mem_free())
return p_data_bytes
