My pico W is suddenly lagging (~30 second delay)

[GM-Script-Writer-62850]

This looks to be getting stuck when it uses urequest based on my led (line 126: r=urequest.get(page))

Note ping times:

# to the pico
50 packets transmitted, 50 received, 0% packet loss, time 49058ms
rtt min/avg/max/mdev = 1.954/4.479/115.468/15.861 ms
# to the AP
1082 packets transmitted, 1082 received, 0% packet loss, time 1106771ms
rtt min/avg/max/mdev = 0.610/0.804/1.616/0.045 ms

main.py:

#!/usr/bin/python3
import time

#Make it easier to connect in thonny
print("Hello World")
time.sleep(5)
print("Loading...")

from json import dumps as json_encode
from GPIO import GPIO
import _thread
#import uasync_requests as urequest
import urequest # https://github.com/micropython/micropython-lib/blob/master/python-ecosys/urequests/urequests.py
import uasyncio
sleep=uasyncio.sleep
sleep_ms=uasyncio.sleep_ms

async def wifi():
	from wifi_auth import ssid, password
	import network

	GPIO.wlan = network.WLAN(network.STA_IF)
	wlan = GPIO.wlan
	wlan.active(True)
	wlan.config(pm = 0xa11140)# Power management is very very bad, ping time is around 1000x worse and packet loss insane
	wlan.connect(ssid, password)

	while True:
		while True:
			wstat=wlan.status()
			if wstat < 0 or wstat >= 3:
				break
			print('Waiting for WiFi connection...')
			await sleep(1)

		if wlan.status() == 3:
			status = wlan.ifconfig()
			print('Wifi Connected; ip =',status[0])
			while wlan.isconnected():
				await sleep(30)
			print('WiFi Down')
		else:
			print("Failed to connect to wifi; retry in 30 seconds")
			await sleep(30)
		wlan.connect(ssid, password)

async def wait4wifi():
	uasyncio.create_task(wifi())
	while GPIO.wlan is None or not GPIO.wlan.isconnected():
		await sleep(1)
		GPIO.light.onboard.toggle()
		GPIO.light.offboard.toggle()

def polling():
	def counter(x,val):
		if val != x["state"]:
			#print(x["count"])
			x["count"]=1
			x["state"]=val
			x["last_time"]=x["time"]
			x["time"]=time.ticks_ms()
		elif x["count"]<GPIO.polling.m_sec:
			x["count"]+=1
		elif x["count"] == GPIO.polling.m_sec:
			return True
		return False

	count=[]
	doors=[]
	for i in GPIO.inputs:
		pin=GPIO.inputs[i]
		door=i[-4:]=="door"
		count.append({
			"pin":pin,
			"name":i,
			"state":pin.value(),
			"count":GPIO.polling.m_sec+1,
			"is_door":door,
			"time":0
		})
		if door:
			doors.append({
				"name":count[-1]["name"],
				"value":count[-1]["state"],
				"is_door":1,
				"time":0
			})
	#doorNotify(doors)
	GPIO.polling.work.append(doors[0])# only 1 door
	doors=None
	while True:
		STAMP=time.ticks_us()
		for switch in count:
			val=switch["pin"].value()
			if counter(switch,val):
				#if not switch["is_door"] and time.ticks_diff(switch["time"],switch["last_time"]) < 1000:# anti-button spam; may never use
				GPIO.polling.lock.acquire()
				GPIO.polling.work.append({
					"name":switch["name"],
					"is_door":switch["is_door"],
					"value":val,
					"time":switch["time"]
				})
				GPIO.polling.lock.release()
				switch["count"]+=1
		STAMP=1000-time.ticks_diff(time.ticks_us(),STAMP)#1ms - however long the loop took
		if STAMP > 0:
			time.sleep_us(STAMP)
		#END_TIME=time.ticks_us()
		#print(time.ticks_diff(END_TIME,START_TIME))

def http(page,post=False,err=False):
	#print("http debug:",page,post,err)
	#return print("Simulation mode: ",page)
	# This function is ugly and i am not happy with it
	if not err:
		page="http://10.0.0.69:8080/"+page
		#print("URL =",page,"DATA =",post)
	if not GPIO.wlan.isconnected():
		print("----------NO NETWORK----------")
		return False
	try:
		#print("http debug:",page,post)
		GPIO.light.onboard.on()
		if not post:
			r=urequest.get(page)
		else:
			r=urequest.post(page,data=json_encode(post),headers={"Content-type":"application/json"})
		GPIO.light.onboard.off()
		#print(page,':',r.status_code,"-",r.content)
	#except ValueError:
	#	#No idea why this happens, line is returned as []
	#	#My server log files disagree
	#	return True
	except Exception as e:
		GPIO.light.onboard.off()
		#print("urequest ERROR:",e)
		#print(GPIO.nic.regs())
		return False
	if r.status_code == 200 and r.content == b"OK":
		r.close()
		r=True
	else:
		#print(page,':',r.status_code,"-",r.content)
		r.close()
		r=False
	return r

def readSensor(name):
	pin=GPIO.sensors.pins[name]["DHT"]
	GPIO.light.offboard.on()
	try:
		pin.measure()
	except Exception as e:
		print("DHT22 ERROR:",e)
		GPIO.light.offboard.off()
		return False
	GPIO.light.offboard.off()
	data={
		"temp":pin.temperature(),
		"water":pin.humidity()
	}
	print(name, data)
	if data["temp"] == 150.0 and data["water"] == 100 or data["temp"] == -50 and data["water"] == 0:
		print("DHT22 ERROR: I call BS")
		return False# temp==150.0 and humidity == 100 if read too soon at power up
	else:
		return data

def getReadings():
	return {
		#"bulb": GPIO.light.bulb.value(),
		"onboard": GPIO.light.onboard.value(),
		"light": GPIO.light.value()
	}

def doorNotify(doors):
	url="smart_home.php?update=living"
	json={"doors":{},"status":getReadings()}
	for i in doors:
		json["doors"][i["name"]]=i["value"]
	#uasyncio.create_task(http(url,json))

	http(url,json)

async def buzzer():
	if GPIO.buzzer.lock:
		return
	GPIO.buzzer.lock=1
	while GPIO.buzzer.active:
		GPIO.buzzer.pin.duty_u16(32767)
		await sleep_ms(50)
		GPIO.buzzer.pin.duty_u16(0)
		await sleep_ms(50)
	GPIO.buzzer.lock=0

async def getWork():
	if not GPIO.polling.work:
		return 0
	GPIO.polling.lock.acquire()
	job=GPIO.polling.work.pop(0)
	GPIO.polling.lock.release()
	#print(GPIO.polling.work,job)
	#print(job)
	if job["is_door"]:
		doorNotify([job])
	elif job["name"] == "kitchen_button" and not job["value"]:
		http("music/outputs.php?set=1&pico")
	elif job["name"] == "living_button" and job["value"]:
		http("music/outputs.php?set=2&pico")
	return 1

async def main():
	json={"DHT22":{},"status":{}}

	sensors={
		"index":-1,
		"names":[],
		"values":[],
		"last_index":-1,
	}
	for i in GPIO.sensors.pins:
		sensors["names"].append(i)
		sensors["values"].append({})
		sensors["last_index"]+=1
	loops=350000# 3600000 = ~ 15 minutes
	send_data=0
	sensor_error=0
	while True:
		if await getWork() and loops >= 345000:
			loops=345000
			#print("Delay sensor reading")
			# Activity found, defer sensor reading for faster response
		if not GPIO.buzzer.lock and loops >= 360000:#not GPIO.light.bulb.value():
			if send_data:
				send_data=0
				loops=0
				data={}
				for (name,val) in zip(sensors["names"], sensors["values"]):
					data[name]=val
				http("smart_home.php?update=living",{
					"DHT22":data,
					"status":getReadings()
				})
			else:
				# Only read one sensor between checks for high priority work
				name=sensors["names"][sensors["index"]+1]
				if not GPIO.sensors.pins[name]["pwr"].value():
					GPIO.sensors.up(name)
					loops=359444
				elif GPIO.sensors.pins[name]["DHT"] is None:
					GPIO.sensors.pins[name]["DHT"]=GPIO.sensors.up(name)
					loops=358000
				else:
					sensors["index"]+=1
					data=readSensor(name)
					if data:
						sensors["values"][ sensors["index"] ]=data
						sensor_error=0
					else:
						if not sensor_error:
							# Only try twice
							sensor_error=1
							sensors["index"]-=1
							loops=358000
						else:
							sensors["values"][ sensors["index"] ] = False
						GPIO.sensors.pins[name]["DHT"]=GPIO.sensors.down(name)
					if sensors["index"] == sensors["last_index"]:
						send_data=1
						sensors["index"]=-1
		await sleep_ms(1)
		loops+=1

GPIO.light.onboard.on()
uasyncio.run(wait4wifi())
GPIO.light.onboard.off()
GPIO.light.offboard.off()

#import os
# duplicate stdout and stderr to the log file - Catches errors and saves them.
#logfile = open('log.txt', 'a')
#os.dupterm(logfile)

GPIO.polling.lock=_thread.allocate_lock()
_thread.start_new_thread(polling,())
uasyncio.run(main())

GPIO.py:

from machine import Pin, ADC, PWM, SPI
from time import sleep_ms as sleep
import dht

#0  LED
#1  DHT22 POWER
#12 DHT22 POWER
#13 DHT22 POWER
#14 back door
#15 dht back door
#16 dht living panel box
#17 buzzer (3.3v -> 470Ohm -> Photocell -> data/6k Omh pull down)
#18 living room buttons
#19 kitchen button
#20 dht kitchen
#28 photocell

logic_pins={
	"pullUp": [19],
	"pullDown": [14, 18]
}

for x in logic_pins:
	i=0
	for y in logic_pins[x]:
		logic_pins[x][i]=Pin(y, Pin.IN, Pin.PULL_UP if x=="pullUp" else Pin.PULL_DOWN)
		i+=1

class GPIO:
	wlan=None
	inputs={
		"back_door":Pin(14),
		"kitchen_button":Pin(19),
		"living_button":Pin(18)
	}
	class sensors:
		pins={
			"kitchen":{
				"data":Pin(20),
				"pwr":Pin(1, Pin.OUT, value=0)
			},
			"living":{
				"data":Pin(16),
				"pwr":Pin(13, Pin.OUT, value=0)
			},
			"door":{
				"data":Pin(15),
				"pwr":Pin(12, Pin.OUT, value=0)
			}
		}
		def up(name):
			if not GPIO.sensors.pins[name]["pwr"].value():
				return GPIO.sensors.pins[name]["pwr"].on()
			GPIO.sensors.pins[name]["DHT"]=dht.DHT22(GPIO.sensors.pins[name]["data"])
			return GPIO.sensors.pins[name]["DHT"]
		def down(name):
			GPIO.sensors.pins[name]["DHT"]=None
			GPIO.sensors.pins[name]["pwr"].off()
			GPIO.sensors.pins[name]["data"].init(mode=Pin.OUT, value=0)
			return None
	class light:
		value=ADC(28).read_u16
		#bulb=Pin(3, Pin.OUT, value=0)
		onboard=Pin('LED', Pin.OUT, value=0)
		offboard=Pin(0, Pin.OUT, value=0)
	class polling:
		work=[]
		m_sec=15
		lock=None
	class buzzer:
		pin=PWM(Pin(17))
		active=0
		lock=0
GPIO.buzzer.pin.freq(750)
GPIO.buzzer.pin.duty_u16(0)# Set the duty cycle, between 0-65535; 50% = 32767
sleep(666)
for x in GPIO.sensors.pins:
	# power on
	GPIO.sensors.up(x)
sleep(1200)
for x in GPIO.sensors.pins:
	# configure
	GPIO.sensors.up(x)

[GM-Script-Writer-62850]

oddly it stopped lagging now... maybe there is a issue with my network switch?

[peterhinch]

It's hard to comment on such a large program, but one thing that comes to mind is the use of threading to interface switches. This seems to take no account of contact bounce. It's generally best to use a debounced uasyncio driver such as this one which would then obviate the need for threading.

[GM-Script-Writer-62850]

i do have switch bounce handled to some extent, notice the counter function in the polling function, unless it has been high or low for a given number of cycles it will be ignored

i had no idea that existed and that is a much better solution

[GM-Script-Writer-62850]

looking at this example is there a way to trigger open/close at 1st boot? BTW i could really use a example using EButton

import uasyncio as asyncio
from machine import Pin
from primitives import ESwitch
es = ESwitch(Pin("Y1", Pin.IN, Pin.PULL_UP))

async def closure():
    while True:
        es.close.clear()
        await es.close.wait()
        print("Closed")

async def open():
    while True:
        es.open.clear()
        await es.open.wait()
        print("Open")

async def main():
    asyncio.create_task(open())
    await closure()

asyncio.run(main())

[peterhinch]

Keeping to the event-based approachyou can use the WaitAny primitive to wait on either (say) a contact closure or a trigger from (say) a Delay_ms timer.

The following (untested) code should give the general idea:

import uasyncio as asyncio
from machine import Pin
from primitives import EButton, WaitAny, Delay_ms
es = EButton(Pin("Y1", Pin.IN, Pin.PULL_UP))

tim = Delay_ms(duration=500)

async def closure():
    while True:
        es.close.clear()
        tim.clear()  # Clear timer event
        await WaitAny((es.close, tim)).wait()  # Wait until either closure or timer time out
        print("Closed")

async def open():
    while True:
        es.open.clear()
        await es.open.wait()
        print("Open")

async def main():
    asyncio.create_task(open())
    tim.trigger()  # Event will happen 500ms later
    await closure()

asyncio.run(main())

[GM-Script-Writer-62850]

Is there a way to apply the trigger event to a single Ebutton/ESwitch? will tim.trigger() only trigger events that have been created or every one made for the next 500ms

i have some momentary buttons and switches (MC-38; it is a magnetic door switch) i only want to trigger the MC-38s not the momentary buttons

i do have one use case where i would like to use a long press (not on the pico i posted code for, tried to post the simple one)

Do i just use es.long.clear() and es.long.wait(), es.open.long.wait() and es.open.long.clear(), or something else?

[peterhinch]

Delay_ms is documented here. A single trigger will prompt a single event when the time elapses.

Do i just use es.long.clear() and es.long.wait(), es.open.long.wait() and es.open.long.clear(), or something else?

Yes.