#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