async def feed_watchdog(self):
"""
Start some periodical tasks and feed the watchdog
"""
while True:
gc.collect()
from power_timer import update_power_timer
if update_power_timer(self.context) is not True:
from reset import ResetDevice
ResetDevice(reason='Update power timer error').reset()
del update_power_timer
del sys.modules['power_timer']
gc.collect()
from ntp import ntp_sync
if ntp_sync(self.context) is not True:
from reset import ResetDevice
ResetDevice(reason='NTP sync error').reset()
del ntp_sync
del sys.modules['ntp']
gc.collect()
self.context.watchdog.feed()
gc.collect()
await uasyncio.sleep(constants.WATCHDOG_TIMEOUT)
async def request_handler(self, reader, writer):
Pins.power_led.off()
print(
'__________________________________________________________________________________'
)
gc.collect()
try:
await self.send_response(reader, writer)
except Exception as e:
sys.print_exception(e)
self.message = str(e)
from http_utils import send_redirect
await send_redirect(writer)
await uasyncio.sleep(3)
if isinstance(e, MemoryError):
micropython.mem_info(1)
from reset import ResetDevice
ResetDevice(reason='MemoryError: %s' % e).reset()
print('close writer')
gc.collect()
await writer.aclose()
self.context.watchdog.garbage_collection()
if __debug__:
micropython.mem_info(1)
Pins.power_led.on()
print(
'----------------------------------------------------------------------------------'
)
def irq_handler(self, pin):
Pins.power_led.off()
button_value = get_debounced_value(pin)
print('button_value:', button_value)
if button_value == 0:
# button pressed
self.down_start = utime.ticks_ms()
elif button_value == 1:
# button released
Pins.power_led.on()
duration_ms = utime.ticks_diff(utime.ticks_ms(), self.down_start)
print('duration_ms:', duration_ms)
if duration_ms > 2000:
from reset import ResetDevice
ResetDevice('After button long press').reset()
else:
print('Overwrite via button press')
if Pins.relay.is_on:
Pins.relay.off()
overwrite_type = False
else:
Pins.relay.on()
overwrite_type = True
from rtc import update_rtc_dict
update_rtc_dict({
constants.RTC_KEY_MANUAL_OVERWRITE:
utime.time(),
constants.RTC_KEY_MANUAL_OVERWRITE_TYPE:
overwrite_type
})
def _ntp_sync():
if utime.localtime()[0] < 2019:
# time was never synced: assume it's default start time in UTC
offset_h = 0 # don't add local saved time zone offset
else:
offset_h = None # load offset via restore_timezone()
from timezone import localtime_isoformat
import ntptime
print('Synchronize time from %r ...' % ntptime.host)
print('old UTC.....:', localtime_isoformat(offset_h=offset_h, add_offset=True))
for s in range(5):
try:
ntptime.settime()
except Exception as e:
print('Error syncing time: %s, retry in %s sec.' % (e, s * 5))
utime.sleep(s * 5)
else:
print('new UTC.....:', localtime_isoformat(offset_h=offset_h, add_offset=True))
rtc2local_time()
print('new local...:', localtime_isoformat(offset_h=offset_h, add_offset=True))
return utime.time() > constants.NTP_MIN_TIME_EPOCH # min 1.1.2019 ???
from reset import ResetDevice
ResetDevice(reason='Failed NTP sync').reset()
async def get_reset(server, reader, writer, querystring, body):
from http_utils import send_redirect
server.message = 'Reset device... Please reload the page in a few seconds.'
await send_redirect(writer, url='/internals/show/') # reload internal page
from reset import ResetDevice
ResetDevice(reason='Reset via web page').schedule(period=15000)
def main():
import sys
sys.modules.clear()
from button_handler import Button
from pins import Pins
# Init device button IRQ:
Pins.button_pin.irq(Button().irq_handler)
from context import Context
context = Context()
import wifi
wifi.init(context)
del sys.modules['wifi']
_RTC_KEY_RUN = 'run'
_RUN_WEB_SERVER = 'web-server'
_RUN_SOFT_OTA = 'soft-ota'
from rtc import get_rtc_value
if get_rtc_value(_RTC_KEY_RUN) == _RUN_WEB_SERVER:
print('start webserver')
from rtc import update_rtc_dict
update_rtc_dict(data={_RTC_KEY_RUN:
_RUN_SOFT_OTA}) # run OTA client on next boot
del update_rtc_dict
del get_rtc_value
del sys.modules['rtc']
# init Watchdog timer
from watchdog import Watchdog
context.watchdog = Watchdog(context)
from webswitch import WebServer
WebServer(context=context, version=__version__).run()
else:
print('start "soft" OTA')
Pins.power_led.off()
from rtc import update_rtc_dict
update_rtc_dict(data={_RTC_KEY_RUN:
_RUN_WEB_SERVER}) # run web server on next boot
from ota_client import SoftOtaUpdate
SoftOtaUpdate().run()
from reset import ResetDevice
ResetDevice(reason='unknown').reset()
def main():
import gc
gc.collect()
import utime
from reset import ResetDevice
ResetDevice(reason='Test reset in 5 sec.').schedule(period=5000)
start_time = utime.time()
for i in range(7):
print('Time passed: %isec...' % (utime.time() - start_time))
utime.sleep(1)
print('Error!')
def reset(reason):
print('Watchdog reset reason: %s' % reason)
from rtc import incr_rtc_count
incr_rtc_count(key=constants.RTC_KEY_WATCHDOG_COUNT)
ResetDevice(reason=reason).reset()
def reset(reason):
from reset import ResetDevice
ResetDevice(reason=reason).reset()