def main(): global numPRs global ticks global colorsForNumPRs wdt = WDT(timeout=15000) while True: wdt.feed() # print(ticks) if wlan.mode() == WLAN.AP: drawErrorForTicks(ticks) ticks += 1 time.sleep_ms(13) continue # about every 10 s: if ticks % (800 // 2) == 0: print('load colors') colorsForNumPRs = loadSettings(select="colors") print('getting...') getAndPrintPRs() drawForTicks(ticks, numPRs) ticks += 1 time.sleep_ms(13)
def wdt(): from machine import WDT from time import sleep wdt = WDT(timeout=10000) #10 seconds of hanging while True: wdt.feed() sleep(1)
def httpserver(fromcard = False, rootpath = '', watchdog = False): global webroot #logging.basicConfig(level=logging.ERROR) addr = get_address() if fromcard: from shields import microsd_shield sdcard = microsd_shield.MicroSD_Shield() sdcard.mount() webroot = '/sd/wwwroot' if rootpath: webroot = rootpath #uasyncio.set_debug(1) loop = uasyncio.get_event_loop() loop.create_task(uasyncio.start_server(serve_content, addr, 80, 20)) if watchdog: from machine import Pin, WDT wdt = WDT() wdt.feed() led = Pin(2, Pin.OUT) loop.create_task(heartbeat(wdt, led)) loop.run_forever() loop.close() if fromcard: sdcard.unmount() #httpserver()
def main(): wdt = WDT(timeout=3000) homie = HomieDevice(settings) homie.add_node(Error()) # publish device and node properties homie.publish_properties() # subsribe to topics homie.subscribe_topics() while True: # reset the errors homie.errors = 0 # publish device data homie.publish_data() # feed wdt if we have no errors if not homie.errors: wdt.feed() utime.sleep(1)
async def wdt(self): from machine import WDT wdt = WDT() while True: wdt.feed() await sleep_ms(WDT_DELAY)
class WDT(StatusModule): """ A status modue that uses the invocation of the status functions to feed a watchdog timer. """ def __init__(self): super(WDT, self).__init__() from machine import WDT as PYCOM_WDT self.wdt = PYCOM_WDT(timeout=1000*self.config().get("timeout")) def feed(self): self.wdt.feed() def status(self, type): self.feed() def log(self, level, message): self.feed() def test(self): self.feed() def measurement(self, bytearray, json): self.feed() def get_config_definition(): return ( "status_wdt", "This module is a watchdog using the status functions as a way too be fed.", ( ("timeout", "60", "Defines how many seconds to wait after the last status message occured until the device is reset.", ConfigFile.VariableType.uint), ) )
async def heartbeat(): speed = 1500 led = Pin(2, Pin.OUT, value=1) wdt = WDT() while True: led.value(led.value() ^ 1) wdt.feed() await asyncio.sleep_ms(speed)
class Publish: def __init__(self, publish_stack): configs = get_configs() self.ip = configs['broker_mqtt']['ip'] self.port = configs['broker_mqtt']['port'] self.user = configs['broker_mqtt']['user'] self.password = configs['broker_mqtt']['pass'] self.topic = bytes(configs['broker_mqtt']['topic'], "utf-8") self.uuid = configs['gateway']['uuid'] self.publish_stack = publish_stack self.wdt = WDT(timeout=1000 * 60 * 15) def connect(self): while True: try: while self.publish_stack.length() > 0: failed_send = False data = json.loads(self.publish_stack.get()) i = 1 while i < 9: try: if 'tries' in data: data.update({'tries': data['tries'] + 1}) else: data.update({'tries': 1}) if not 'gateway' in data: data.update({'gateway': {'uuid': self.uuid}}) c = MQTTClient(self.topic, self.ip, self.port, self.user, self.password) c.connect() c.publish(self.topic, json.dumps(data).encode()) c.disconnect() failed_send = False self.wdt.feed() break except Exception: i += 1 failed_send = True time.sleep(5) # no persistency for ack answer if failed_send and data['type'] != 'identification': self.publish_stack.write_buffer(json.dumps(data)) self.publish_stack.delete() # TODO: verify necessity of sleep here except Exception as e: self.publish_stack.delete() log("Publish-connect: {}".format(e)) time.sleep(5)
class watchdog(object): def __init__(self, wdtimeout): #self._wdtimeout = wdtimeout+30000 print('Timeout', wdtimeout) self._watchdog = WDT(timeout=wdtimeout) def run(self): while True: self._watchdog.feed() print('reset timeout') yield 2
async def heartbeat(): await asyncio.sleep(30) speed = 125 led = Pin(LED, Pin.OUT, value=1) wdt = WDT() while True: led(0) wdt.feed() await asyncio.sleep_ms(speed) led(1) wdt.feed() await asyncio.sleep_ms(speed * 10)
def start(self, interval=60): """ Begins to publish temperature data on an interval (in seconds). This function will not exit! Consider using deep sleep instead. :param interval: How often to publish temperature data (60s default) :type interval: int """ wdt = WDT() while True: self.publishTemperature() time.sleep(interval) wdt.feed()
async def relay_loop(self, conns, deadline): max_timeout = 5005 wdt = None try: if self.uPK.WATCHDOG_TIMEOUT: from machine import WDT wdt = WDT(timeout=self.uPK.WATCHDOG_TIMEOUT) max_timeout = min(max_timeout, self.uPK.WATCHDOG_TIMEOUT // 2) except KeyboardInterrupt: raise except: pass await fuzzy_sleep_ms() try: pool = uPageKiteConnPool(conns, self) while pool.conns and self.keep_running and time.time() < deadline: if wdt: wdt.feed() self.uPK.GC_COLLECT() timeout_ms = min(max(100, (deadline - time.time()) * 1000), max_timeout) await fuzzy_sleep_ms() if await pool.process_io(self.uPK, int(timeout_ms)) is False: raise EofTunnelError('process_io returned False') if self.reconfig_flag: if self.uPK.info: self.uPK.info("Exiting relay_loop early: reconfiguration requested.") return False # Happy ending! return True except KeyboardInterrupt: raise except Exception as e: if self.uPK.debug: print_exc(e) self.uPK.debug('Oops, relay_loop: %s(%s)' % (type(e), e)) # We've fallen through to our unhappy ending, clean up for conn in conns: try: conn.close() except Exception as e: if self.uPK.debug: self.uPK.debug("Oops, close(%s): %s" % (conn, e)) return False
class Clock: def __init__(self, led, period=5, max_count=10): self._max_count = max_count self.__alarm = Timer.Alarm(self._seconds_handler, period, periodic=True) self._led = led self._count = 0 self._wdt = WDT(timeout=period * 2 * 1000) # enable WDT with a timeout of 2*period seconds def _seconds_handler(self, alarm): self._count += 1 print("Timer Alarm called : %s" % str(self._count)) self._led(1) self._wdt.feed() if self._count == self._max_count: print("Alarm canceled after %s calls" % str(self._max_count)) alarm.cancel() # stop counting
def request(requests): s = socket.socket() s.setblocking(True) p = uselect.poll() p.register( s, uselect.POLLIN | uselect.POLLOUT | uselect.POLLHUP | uselect.POLLERR) try: wdt = WDT(timeout=10 * 1000) s.settimeout(1.0) s.connect(socket.getaddrinfo(CTLR_IPADDRESS, 6543)[0][-1]) logger.info('request: connected to the server...') wdt.feed() wdt.init(5 * 60 * 1000) response = s_handler(p, requests) logger.debug('request: finished. response={}'.format(response)) return response except socket.timeout: logger.debug('request: Timeout error occurred...') except: raise return
def main(): global watchdog setup_config() setup_connectivity() gc.collect() setup_sensors() watchdog = WDT(timeout=detimotic_conf['watchdog']) try: while True: try: for i in range(len(modules)): watchdog.feed() module, last = modules[i] if time.ticks_ms() - last >= module.time(): gc.collect() module.loop() modules[i] = (module, time.ticks_ms()) if time.ticks_ms() - client.last_pingreq >= detimotic_conf['gateway']['ping_freq']: client.ping() elif time.ticks_ms() - client.last_pingresp >= 3*detimotic_conf['gateway']['ping_freq']: print('Forcibly reconnecting!') client.disconnect() wlan.disconnect() watchdog.feed() setup_connectivity() client.check_msg() except MemoryError: print('Memory Error!') except KeyboardInterrupt: print("KB INTERRUPT!") client.disconnect() wlan.disconnect() gc.collect() sys.exit(2)
def mainloop(): #main loop looking for and handling UIDs from chips wdt = WDT(timeout=10000) # enable watchdog with a timeout of 10 seconds global taps_pending global threadsswitch while True: uid_send = chipscan() if uid_send == "misread": negindication() elif uid_send == "no_chip": negindication() elif uid_send == "734D0185": setexternalrtc() else: tap = ("uid"+uid_send+"timestamp"+time_calc()) chiplog(tap) sendlock.acquire() taps_pending.append(tap) sendlock.release() print(tap) del tap del uid_send posindication() wdt.feed() time.sleep(0.1)
class Display(object): IMG_DIR = '/flash/imgs' def __init__(self, debug=False): self.cfg = None self.rtc = RTC() self.debug = debug self.battery = Battery() # use this pin for debug self.wifi_pin = Pin("GP24", mode=Pin.IN, pull=Pin.PULL_UP) # Empty WDT object self.wdt = None if not debug: if not self.wifi_pin(): self.wdt = WDT(timeout=20000) self.sd = None else: from machine import SD try: self.sd = SD() mount(self.sd, '/sd') self.logfile = open("/sd/display.log", "a") except OSError: self.sd = None self.logfile = None self.epd = EPD() self.log("Time left on the alarm: %dms" % self.rtc.alarm_left()) # Don't flash when we're awake outside of debug heartbeat(self.debug) def log(self, msg, end='\n'): time = "%d, %d, %d, %d, %d, %d" % self.rtc.now()[:-2] msg = time + ", " + msg if self.logfile: self.logfile.write(msg + end) print(msg, end=end) def feed_wdt(self): if self.wdt: self.wdt.feed() def connect_wifi(self): from network import WLAN if not self.cfg: raise ValueError("Can't initialise wifi, no config") self.log('Starting WLAN, attempting to connect to ' + ','.join(self.cfg.wifi.keys())) wlan = WLAN(0, WLAN.STA) wlan.ifconfig(config='dhcp') while not wlan.isconnected(): nets = wlan.scan() for network in nets: if network.ssid in self.cfg.wifi.keys(): self.log('Connecting to ' + network.ssid) self.feed_wdt() # just in case wlan.connect(ssid=network.ssid, auth=(network.sec, self.cfg.wifi[network.ssid])) while not wlan.isconnected(): idle() break self.feed_wdt() # just in case sleep_ms(2000) self.log('Connected as %s' % wlan.ifconfig()[0]) @staticmethod def reset_cause(): import machine val = machine.reset_cause() if val == machine.POWER_ON: return "power" elif val == machine.HARD_RESET: return "hard" elif val == machine.WDT_RESET: return "wdt" elif val == machine.DEEPSLEEP_RESET: return "sleep" elif val == machine.SOFT_RESET: return "soft" def set_alarm(self, now, json_metadata): import json json_dict = json.loads(json_metadata) # Now we know the time too self.rtc = RTC(datetime=now) list_int = json_dict["wakeup"][:6] time_str = ",".join([str(x) for x in list_int]) self.log("Setting alarm for " + time_str) self.rtc.alarm(time=tuple(list_int)) if self.rtc.alarm_left() == 0: self.log("Alarm failed, setting for +1 hour") self.rtc.alarm(time=3600000) del json def display_file_image(self, file_obj): towrite = 15016 max_chunk = 250 while towrite > 0: c = max_chunk if towrite > max_chunk else towrite buff = file_obj.read(c) self.epd.upload_image_data(buff, delay_us=2000) self.feed_wdt() towrite -= c self.epd.display_update() def display_no_config(self): self.log("Displaying no config msg") with open(Display.IMG_DIR + '/no_config.bin', 'rb') as pic: self.display_file_image(pic) def display_low_battery(self): self.log("Displaying low battery msg") with open(Display.IMG_DIR + '/low_battery.bin', 'rb') as pic: self.display_file_image(pic) def display_cannot_connect(self): self.log("Displaying no server comms msg") with open(Display.IMG_DIR + '/no_server.bin', 'rb') as pic: self.display_file_image(pic) def display_no_wifi(self): self.log("Displaying no wifi msg") with open(Display.IMG_DIR + '/no_wifi.bin', 'rb') as pic: self.display_file_image(pic) def check_battery_level(self): now_batt = 200 last_batt = self.battery.battery_raw() while now_batt > last_batt: sleep_ms(50) last_batt = now_batt self.feed_wdt() now_batt = self.battery.battery_raw() self.log("Battery value: %d (%d)" % (self.battery.value(), self.battery.battery_raw())) if not self.battery.safe(): self.log("Battery voltage (%d) low! Turning off" % self.battery.battery_raw()) self.feed_wdt() self.display_low_battery() return False else: self.log("Battery value: %d (%d)" % (self.battery.value(), self.battery.battery_raw())) return True def run_deepsleep(self): if not self.run(): # RTC wasn't set, try to sleep forever self.rtc.alarm(time=2000000000) # Set the wakeup (why do it earlier?) rtc_i = self.rtc.irq(trigger=RTC.ALARM0, wake=DEEPSLEEP) self.log("Going to sleep, waking in %dms" % self.rtc.alarm_left()) # Close files on the SD card if self.sd: self.logfile.close() self.logfile = None unmount('/sd') self.sd.deinit() # Turn the screen off self.epd.disable() if not self.wifi_pin(): # Basically turn off deepsleep() else: self.log("DEBUG MODE: Staying awake") pass # Do nothing, allow network connections in def run(self): woken = self.wifi_pin() self.epd.enable() if not self.check_battery_level(): return False try: self.epd.get_sensor_data() except ValueError: self.log("Can't communicate with display, flashing light and giving up") heartbeat(True) sleep_ms(15000) return True if self.rtc.alarm_left() > 0: self.log("Woken up but the timer is still running, refreshing screen only") self.epd.display_update() self.feed_wdt() return True try: self.cfg = Config.load(sd=self.sd) self.log("Loaded config") except (OSError, ValueError) as e: self.log("Failed to load config: " + str(e)) self.display_no_config() try: self.connect_wifi() except: pass # everything while True: sleep_ms(10) self.feed_wdt() self.feed_wdt() self.connect_wifi() content = b'' try: self.log("Connecting to server %s:%d" % (self.cfg.host, self.cfg.port)) c = Connect(self.cfg.host, self.cfg.port, debug=self.debug) self.feed_wdt() cause = Display.reset_cause() if woken: cause = "user" self.log("Reset cause: " + cause) if len(self.cfg.upload_path) > 0: temp = self.epd.get_sensor_data() # we read this already c.post(self.cfg.upload_path, battery=self.battery.value(), reset=cause, screen=temp) self.log("Fetching metadata from " + self.cfg.metadata_path) metadata = c.get_quick(self.cfg.metadata_path, max_length=1024, path_type='json') # This will set the time to GMT, not localtime self.set_alarm(c.last_fetch_time, metadata) self.feed_wdt() del metadata del self.battery self.log("Fetching image from " + self.cfg.image_path) self.epd.image_erase_frame_buffer() self.feed_wdt() length, socket = c.get_object(self.cfg.image_path) if length != 15016: raise ValueError("Wrong data size for image: %d" % length) self.feed_wdt() except (RuntimeError, ValueError, OSError) as e: self.log("Failed to get remote info: " + str(e)) self.display_cannot_connect() self.rtc.alarm(time=3600000) return True sleep_ms(1000) # How do we make the write to display more reliable? self.feed_wdt() self.log("Uploading to display") self.display_file_image(socket) c.get_object_done() # close off socket if self.cfg.src == "sd": # If we've got a working config from SD instead of flash self.log("Transferring working config") Config.transfer() self.log("SUCCESS") self.log("Finished. Mem free: %d" % gc.mem_free()) return True
# Receiver code for Cawthron Institute's mussel farm accelerometer chain # Author: Kevin Tang """ DEFAULT VALUES MODE: 1 HZ BAUD RATE: 9600 DATA FRAME: bits=8, parity=None, stop=1, timeout=0 WDT TIMEOUT: 3000ms ACCELEROMETER RANGE: 2G ACCELEROMETER FREQUENCY: 10HZ """ from machine import I2C, Pin, SPI, UART, WDT from lis3dh import LIS3DH, LIS3DH_I2C, RANGE_2_G, DATARATE_10_HZ, STANDARD_GRAVITY from pyb import ADC, RTC from ds3231_port import DS3231 import time import os import sys import math global ID global timer ID = 0 # Receiver ID (0-9). MAKE SURE TO CHANGE timer = 1 # By default, sleep value is set to 1s (1 Hz mode) # Enable Watchdog timer if using battery global TIMEOUT_VALUE TIMEOUT_VALUE = 3000 if pyb.Pin.board.USB_VBUS.value() == 0: wdt = WDT(timeout = TIMEOUT_VALUE) # enable with a timeout of 3 seconds if sys.platform == 'pyboard': # Initialising pins
############################################################################ #main execution loop, triggered by awakening from deep sleep # Get loramac as id to be sent in message lora_mac = connection.getLoraMac() lora_id = lora_mac[-6:] # only last 6 chars ledcolor = 'red' # first start with color red (no gps position) while True: # ----------------------------- gc.collect() wdt.feed() # Feed the WDT to prevent it from resetting the system # --------------- start of code executed after awakening # led.setLED('green') led.setLED(ledcolor) # prepare msg to send # count_tx = pycom.nvs_get('count_tx') # retrieve count_tx # ---------------------------- gc.collect() wdt.feed() # Feed the WDT to prevent it from resetting the system acc = li.acceleration() # read accelerometer
white = 0x101010 # initialize WDT wdt = WDT(timeout=5500) # enable it with a timeout of 5.5 seconds asleep = .1 wlan = WLAN(mode=WLAN.STA) wlan.connect(SSID, auth=(WLAN.WPA2, PW), timeout=5000) while not wlan.isconnected(): machine.idle() pycom.rgbled(red) print("Connected to Wifi\n") wdt.feed() #made it past the WLAN timeout loop error pycom.rgbled(white) time.sleep(asleep) client = MQTTClient("fipy", "io.adafruit.com", user=AIOuser, password=AIOpw, port=8883, ssl=True) client.set_callback(sub_cb) client.connect() time.sleep(asleep) wdt.feed() #made it past the WLAN timeout loop error
class NanoGateway: """ Nano gateway class, set up by default for use with TTN, but can be configured for any other network supporting the Semtech Packet Forwarder. Only required configuration is wifi_ssid and wifi_password which are used for connecting to the Internet. """ def __init__(self, id, frequency, datarate, ssid, password, server, port, ntp_server='pool.ntp.org', ntp_period=3600): self.id = id self.server = server self.port = port self.frequency = frequency self.datarate = datarate self.ssid = ssid self.password = password self.ntp_server = ntp_server self.ntp_period = ntp_period self.server_ip = None self.rxnb = 0 self.rxok = 0 self.rxfw = 0 self.dwnb = 0 self.txnb = 0 self.sf = self._dr_to_sf(self.datarate) self.bw = self._dr_to_bw(self.datarate) self.stat_alarm = None self.pull_alarm = None self.uplink_alarm = None self.wlan = None self.sock = None self.udp_stop = False self.udp_lock = _thread.allocate_lock() self.lora = None self.lora_sock = None self.rtc = machine.RTC() self.wdt = WDT(timeout=50000) def start(self): """ Starts the LoRaWAN nano gateway. """ self._log('Starting LoRaWAN nano gateway with id: {}', self.id) # setup WiFi as a station and connect self.wlan = WLAN(mode=WLAN.STA) self._connect_to_wifi() # feed the dog self.wdt.feed() # get a time sync self._log('Syncing time with {} ...', self.ntp_server) self.rtc.ntp_sync(self.ntp_server, update_period=self.ntp_period) while not self.rtc.synced(): utime.sleep_ms(50) self._log("RTC NTP sync complete") # get the server IP and create an UDP socket self.server_ip = usocket.getaddrinfo(self.server, self.port)[0][-1] self._log('Opening UDP socket to {} ({}) port {}...', self.server, self.server_ip[0], self.server_ip[1]) self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.IPPROTO_UDP) self.sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1) self.sock.setblocking(False) # push the first time immediatelly self._push_data(self._make_stat_packet()) # create the alarms self.stat_alarm = Timer.Alarm( handler=lambda t: self._push_data(self._make_stat_packet()), s=60, periodic=True) self.pull_alarm = Timer.Alarm(handler=lambda u: self._pull_data(), s=25, periodic=True) # start the UDP receive thread self.udp_stop = False _thread.start_new_thread(self._udp_thread, ()) # initialize the LoRa radio in LORA mode self._log('Setting up the LoRa radio at {} Mhz using {}', self._freq_to_float(self.frequency), self.datarate) self.lora = LoRa(mode=LoRa.LORA, frequency=self.frequency, bandwidth=self.bw, sf=self.sf, preamble=8, coding_rate=LoRa.CODING_4_5, tx_iq=True) # create a raw LoRa socket self.lora_sock = usocket.socket(usocket.AF_LORA, usocket.SOCK_RAW) self.lora_sock.setblocking(False) self.lora_tx_done = False self.lora.callback(trigger=(LoRa.RX_PACKET_EVENT | LoRa.TX_PACKET_EVENT), handler=self._lora_cb) self._log('LoRaWAN nano gateway online') def stop(self): """ Stops the LoRaWAN nano gateway. """ self._log('Stopping...') # send the LoRa radio to sleep self.lora.callback(trigger=None, handler=None) self.lora.power_mode(LoRa.SLEEP) # stop the NTP sync self.rtc.ntp_sync(None) # cancel all the alarms self.stat_alarm.cancel() self.pull_alarm.cancel() # signal the UDP thread to stop self.udp_stop = True while self.udp_stop: utime.sleep_ms(50) # disable WLAN self.wlan.disconnect() self.wlan.deinit() def _connect_to_wifi(self): self.wlan.connect(self.ssid, auth=(None, self.password)) while not self.wlan.isconnected(): utime.sleep_ms(50) self._log('WiFi connected to: {}', self.ssid) def _dr_to_sf(self, dr): sf = dr[2:4] if sf[1] not in '0123456789': sf = sf[:1] return int(sf) def _dr_to_bw(self, dr): bw = dr[-5:] if bw == 'BW125': return LoRa.BW_125KHZ elif bw == 'BW250': return LoRa.BW_250KHZ else: return LoRa.BW_500KHZ def _sf_bw_to_dr(self, sf, bw): dr = 'SF' + str(sf) if bw == LoRa.BW_125KHZ: return dr + 'BW125' elif bw == LoRa.BW_250KHZ: return dr + 'BW250' else: return dr + 'BW500' def _lora_cb(self, lora): """ LoRa radio events callback handler. """ events = lora.events() if events & LoRa.RX_PACKET_EVENT: self.rxnb += 1 self.rxok += 1 rx_data = self.lora_sock.recv(256) stats = lora.stats() packet = self._make_node_packet(rx_data, self.rtc.now(), stats.rx_timestamp, stats.sfrx, self.bw, stats.rssi, stats.snr) packet = self.frequency_rounding_fix(packet, self.frequency) self._push_data(packet) self._log('Received packet: {}', packet) self.rxfw += 1 if events & LoRa.TX_PACKET_EVENT: self.txnb += 1 lora.init(mode=LoRa.LORA, frequency=self.frequency, bandwidth=self.bw, sf=self.sf, preamble=8, coding_rate=LoRa.CODING_4_5, tx_iq=True) def _freq_to_float(self, frequency): """ MicroPython has some inprecision when doing large float division. To counter this, this method first does integer division until we reach the decimal breaking point. This doesn't completely elimate the issue in all cases, but it does help for a number of commonly used frequencies. """ divider = 6 while divider > 0 and frequency % 10 == 0: frequency = frequency // 10 divider -= 1 if divider > 0: frequency = frequency / (10**divider) return frequency def frequency_rounding_fix(self, packet, frequency): freq = str(frequency)[0:3] + '.' + str(frequency)[3] start = packet.find("freq\":") end = packet.find(",", start) packet = packet[:start + 7] + freq + packet[end:] return packet def _make_stat_packet(self): now = self.rtc.now() STAT_PK["stat"]["time"] = "%d-%02d-%02d %02d:%02d:%02d GMT" % ( now[0], now[1], now[2], now[3], now[4], now[5]) STAT_PK["stat"]["rxnb"] = self.rxnb STAT_PK["stat"]["rxok"] = self.rxok STAT_PK["stat"]["rxfw"] = self.rxfw STAT_PK["stat"]["dwnb"] = self.dwnb STAT_PK["stat"]["txnb"] = self.txnb return ujson.dumps(STAT_PK) def _make_node_packet(self, rx_data, rx_time, tmst, sf, bw, rssi, snr): RX_PK["rxpk"][0]["time"] = "%d-%02d-%02dT%02d:%02d:%02d.%dZ" % ( rx_time[0], rx_time[1], rx_time[2], rx_time[3], rx_time[4], rx_time[5], rx_time[6]) RX_PK["rxpk"][0]["tmst"] = tmst RX_PK["rxpk"][0]["freq"] = self._freq_to_float(self.frequency) RX_PK["rxpk"][0]["datr"] = self._sf_bw_to_dr(sf, bw) RX_PK["rxpk"][0]["rssi"] = rssi RX_PK["rxpk"][0]["lsnr"] = snr RX_PK["rxpk"][0]["data"] = ubinascii.b2a_base64(rx_data)[:-1] RX_PK["rxpk"][0]["size"] = len(rx_data) return ujson.dumps(RX_PK) def _push_data(self, data): token = uos.urandom(2) packet = bytes([PROTOCOL_VERSION]) + token + bytes( [PUSH_DATA]) + ubinascii.unhexlify(self.id) + data with self.udp_lock: try: self.sock.sendto(packet, self.server_ip) except Exception as ex: self._log('Failed to push uplink packet to server: {}', ex) def _pull_data(self): # feed the dog everytime we pull data self.wdt.feed() token = uos.urandom(2) packet = bytes([PROTOCOL_VERSION]) + token + bytes( [PULL_DATA]) + ubinascii.unhexlify(self.id) with self.udp_lock: try: self.sock.sendto(packet, self.server_ip) except Exception as ex: self._log('Failed to pull downlink packets from server: {}', ex) def _ack_pull_rsp(self, token, error): TX_ACK_PK["txpk_ack"]["error"] = error resp = ujson.dumps(TX_ACK_PK) packet = bytes([PROTOCOL_VERSION]) + token + bytes( [PULL_ACK]) + ubinascii.unhexlify(self.id) + resp with self.udp_lock: try: self.sock.sendto(packet, self.server_ip) except Exception as ex: self._log('PULL RSP ACK exception: {}', ex) def _send_down_link(self, data, tmst, datarate, frequency): """ Transmits a downlink message over LoRa. """ self.lora.init(mode=LoRa.LORA, frequency=frequency, bandwidth=self._dr_to_bw(datarate), sf=self._dr_to_sf(datarate), preamble=8, coding_rate=LoRa.CODING_4_5, tx_iq=True) #while utime.ticks_cpu() < tmst: # pass self.lora_sock.send(data) self._log( 'Sent downlink packet scheduled on {:.3f}, at {:.3f} Mhz using {}: {}', tmst / 1000000, self._freq_to_float(frequency), datarate, data) def _send_down_link_class_c(self, data, datarate, frequency): self.lora.init(mode=LoRa.LORA, frequency=frequency, bandwidth=self._dr_to_bw(datarate), sf=self._dr_to_sf(datarate), preamble=8, coding_rate=LoRa.CODING_4_5, tx_iq=True, device_class=LoRa.CLASS_C) self.lora_sock.send(data) self._log( 'Sent downlink packet scheduled on {:.3f}, at {:.3f} Mhz using {}: {}', utime.time(), self._freq_to_float(frequency), datarate, data) def _udp_thread(self): """ UDP thread, reads data from the server and handles it. """ while not self.udp_stop: try: data, src = self.sock.recvfrom(1024) _token = data[1:3] _type = data[3] if _type == PUSH_ACK: self._log("Push ack") elif _type == PULL_ACK: self._log("Pull ack") elif _type == PULL_RESP: self.dwnb += 1 ack_error = TX_ERR_NONE tx_pk = ujson.loads(data[4:]) if "tmst" in data: tmst = tx_pk["txpk"]["tmst"] t_us = tmst - utime.ticks_cpu() - 15000 if t_us < 0: t_us += 0xFFFFFFFF if t_us < 20000000: self.uplink_alarm = Timer.Alarm( handler=lambda x: self._send_down_link( ubinascii.a2b_base64(tx_pk["txpk"][ "data"]), tx_pk["txpk"]["tmst"] - 50, tx_pk["txpk"]["datr"], int(tx_pk["txpk"]["freq"] * 1000) * 1000), us=t_us) else: ack_error = TX_ERR_TOO_LATE self._log('Downlink timestamp error!, t_us: {}', t_us) else: self.uplink_alarm = Timer.Alarm( handler=lambda x: self._send_down_link_class_c( ubinascii.a2b_base64(tx_pk["txpk"]["data"]), tx_pk["txpk"]["datr"], int(tx_pk["txpk"]["freq"] * 1000) * 1000), us=50) self._ack_pull_rsp(_token, ack_error) self._log("Pull rsp") except usocket.timeout: pass except OSError as ex: if ex.args[0] != errno.EAGAIN: self._log('UDP recv OSError Exception: {}', ex) except Exception as ex: self._log('UDP recv Exception: {}', ex) # wait before trying to receive again utime.sleep_ms(UDP_THREAD_CYCLE_MS) # we are to close the socket self.sock.close() self.udp_stop = False self._log('UDP thread stopped') def _log(self, message, *args): """ Outputs a log message to stdout. """ print('[{:>10.3f}] {}'.format(utime.ticks_ms() / 1000, str(message).format(*args)))
import time from machine import WDT # ''' # test default wdt wdt0 = WDT(id=0, timeout=3000) print('into', wdt0) time.sleep(2) print(time.ticks_ms()) # 1.test wdt feed wdt0.feed() time.sleep(2) print(time.ticks_ms()) # 2.test wdt stop wdt0.stop() print('stop', wdt0) # 3.wait wdt work #while True: #print('idle', time.ticks_ms()) #time.sleep(1) # ''' # ''' def on_wdt(self): print(self.context(), self) #self.feed() ## release WDT #self.stop()
self.accumulatedData += sensorValue self.readingCount += 1 if self.readingCount == 5: # send data every 5min data = round((self.accumulatedData / 5), 2) # avg force over the last 5 values data = str(self.location + "-" + str(data)) # print("AVG force - ", data) self.sendData(data) self.accumulatedData = 0 # clear accumulatedData self.readingCount = 0 return True else: return False # Initilise sensors topLeftSensor = PedalSensor("tLS", 0x0a) topRightSensor = PedalSensor("tRS", 0x0b) bottomRightSensor = PedalSensor("bRS", 0x0c) bottomLeftSensor = PedalSensor("bLS", 0x0d) # read sensor data every minute while (True): topLeftSensor.tick() topRightSensor.tick() bottomLeftSensor.tick() bottomRightSensor.tick() wdt.feed() # tell watchdog we're stll alive time.sleep(60) # Sleep for a minute
class Watchdog: """The watchdog timer (WDT) is used to restart the system when the application crashes and ends up into a non recoverable state. After enabling, the application must "feed" the watchdog periodically to prevent the timeout from expiring and resetting the system. https://docs.pycom.io/firmwareapi/pycom/machine/wdt/ """ def __init__(self, device=None, settings=None): self.device = device self.settings = settings self.wdt = None self.suspended = False self.enabled = self.settings.get('main.watchdog.enabled', False) self.timeout = self.settings.get('main.watchdog.timeout', 10000) def start(self): """ """ if not self.enabled: log.info('Skipping watchdog timer (WDT)') return watchdog_timeout = self.timeout log.info('Starting the watchdog timer (WDT) with timeout {}ms'.format( watchdog_timeout)) from machine import WDT self.wdt = WDT(timeout=watchdog_timeout) # Feed Watchdog once. self.feed() def resume(self): """ """ log.info('Resuming watchdog') self.suspended = False self.reconfigure_minimum_timeout(self.timeout) def suspend(self): """Disabling a started watchdog is not possible, so let's just configure it to an ultra large timeout value. """ log.info('Suspending watchdog') self.suspended = True self.reconfigure_minimum_timeout(999999999) def feed(self): """ """ if not self.enabled: return # When in maintenance mode, try to suspend the watchdog. #if self.device.status.maintenance and not self.suspended: # self.stop() # Always reconfigure to regular timeout when not in maintenance mode. #else: # self.suspended = False # self.wdt.init(self.timeout) # Feed the watchdog. log.debug('Feeding Watchdog') self.wdt.feed() def reconfigure_minimum_timeout(self, timeout): """ :param timeout: """ if not self.enabled: return if timeout >= self.timeout: log.info( 'Reconfiguring watchdog timeout to {} milliseconds'.format( timeout)) self.wdt.init(timeout) def adjust_for_interval(self, interval): """ :param interval: """ if self.enabled and not self.suspended: watchdog_timeout = self.timeout / 1000.0 if watchdog_timeout - 2 < interval: watchdog_timeout_effective = int((interval + 20) * 1000) log.warning( 'Reconfiguring original watchdog timeout {} as it is ' 'smaller or near the configured sleep time {}'.format( watchdog_timeout, interval)) self.reconfigure_minimum_timeout(watchdog_timeout_effective)
def Watchdog(): # 2秒钟内调用喂狗函数,否则系统复位 global wdt # 声明全部变量 if wdt is None: wdt = WDT(2) # 启动看门狗,间隔时长 单位 秒 wdt.feed() # 喂狗
# # Copyright (c) 2006-2019, RT-Thread Development Team # # SPDX-License-Identifier: MIT License # # Change Logs: # Date Author Notes # 2019-06-29 ChenYong first version # from machine import WDT wdt = WDT(10) # Create an WDT device object, set the timeout to 10 seconds wdt.feed( ) # Perform the "feed dog" operation to clear the watchdog device count during the timout period # If not executed, the system will restart after the timeout print("reset system after 10 seconds")
# available at https://www.pycom.io/opensource/licensing # """ LoPy LoRaWAN Nano Gateway example usage """ import config import time from nanogateway import NanoGateway from machine import WDT if __name__ == '__main__': nanogw = NanoGateway(id=config.GATEWAY_ID, frequency=config.LORA_FREQUENCY, datarate=config.LORA_GW_DR, ssid=config.WIFI_SSID, password=config.WIFI_PASS, server=config.SERVER, port=config.PORT, ntp_server=config.NTP, ntp_period=config.NTP_PERIOD_S) nanogw.start() nanogw._log('You may now press ENTER to enter the REPL') wdt = WDT(timeout=15000) while True: #print("feeding wdt") wdt.feed() time.sleep(5) #input()
j+=1 if n>=nombre_point: print ('beaucoup d\'erreurs capteur n°', i, end="") if j: lecture_capteur[i]=moyenne/j poids_en_gr=((lecture_capteur[i]-tare[i])/mesure[i]*etalon[i]) print(" n°", i, poids_en_gr," ", lecture_capteur[i], end="" ) poids_en_gr_total=poids_en_gr+poids_en_gr_total trame+=delimiteur+str(lecture_capteur[i]) i +=1 numero_trame+=1 t=temperatureLopy(GAIN_local,OFFSET_local) #mesure de la température du TX*************************************************************************** timest = time.localtime() #on met un timestamp sur la trame trame=str(timest)+delimiteur+str(numero_trame)+delimiteur+str(t)+trame+delimiteur+"\n" flashWriteData(trame) print("poids_en_gr_total", poids_en_gr_total, " Température RX: ", t, " n° trame: ", numero_trame, '****', trame) time.sleep(delai_local) wdt.feed() # feeds watchgdog if configuration== 2 : # ON VA CONFIGURER LE TX il y a x capteurs sur le RX; il y a y capteurs sur le TX; #trame=label+delimiteur+str(numero_trame)+delimiteur+str(t)+delimiteur+w+{delimiteur+str(lecture_capteur[i])}*nb_capteurs+delimiteur+"\n" lora = LoRa(mode=LoRa.LORA, frequency=c.LORA_FREQUENCY) s = socket.socket(socket.AF_LORA, socket.SOCK_RAW) s.setblocking(False) nombre_capteurs=c.nombre_capteurs #nombre de capteurs sur la balance TX premier_capteur =c.premier_capteur #premier_capteur sur la balance TX while True: alimCapteurs(1) #on alimente les HX711 if debug: pycom.rgbled(c.bleu_pale)
class TerkinDevice: def __init__(self, name=None, version=None, settings=None): self.name = name self.version = version self.settings = settings # Conditionally enable terminal on UART0. Default: False. self.terminal = Terminal(self.settings) self.terminal.start() self.device_id = get_device_id() self.networking = None self.telemetry = None self.wdt = None self.rtc = None self.status = DeviceStatus() @property def appname(self): return '{} {}'.format(self.name, self.version) def start_networking(self): log.info('Starting networking') from terkin.network import NetworkManager, WiFiException self.networking = NetworkManager(device=self, settings=self.settings) # Start WiFi. try: self.networking.start_wifi() # Wait for network interface to come up. self.networking.wait_for_nic() self.status.networking = True except WiFiException: log.error('Network connectivity not available, WiFi failed') self.status.networking = False # Start UDP server for pulling device into maintenance mode. self.networking.start_modeserver() # Initialize LoRa device. if self.settings.get('networking.lora.antenna_attached'): try: self.networking.start_lora() except: log.exception('Unable to start LoRa subsystem') else: log.info( "[LoRa] Disabling LoRa interface as no antenna has been attached. " "ATTENTION: Running LoRa without antenna will wreck your device." ) # Inform about networking status. #self.networking.print_status() def start_watchdog(self): """ The WDT is used to restart the system when the application crashes and ends up into a non recoverable state. After enabling, the application must "feed" the watchdog periodically to prevent it from expiring and resetting the system. """ # https://docs.pycom.io/firmwareapi/pycom/machine/wdt.html if not self.settings.get('main.watchdog.enabled', False): log.info('Skipping watchdog timer (WDT)') return watchdog_timeout = self.settings.get('main.watchdog.timeout', 10000) log.info('Starting the watchdog timer (WDT) with timeout {}ms'.format( watchdog_timeout)) from machine import WDT self.wdt = WDT(timeout=watchdog_timeout) # Feed Watchdog once. self.wdt.feed() def feed_watchdog(self): if self.wdt is not None: log.info('Feeding Watchdog') self.wdt.feed() def start_rtc(self): """ The RTC is used to keep track of the date and time. """ # https://docs.pycom.io/firmwareapi/pycom/machine/rtc.html # https://medium.com/@chrismisztur/pycom-uasyncio-installation-94931fc71283 import time from machine import RTC self.rtc = RTC() # TODO: Use values from configuration settings here. self.rtc.ntp_sync("pool.ntp.org", 360) while not self.rtc.synced(): time.sleep_ms(50) log.info('RTC: %s', self.rtc.now()) def run_gc(self): """ Run a garbage collection. https://docs.pycom.io/firmwareapi/micropython/gc.html """ import gc gc.collect() def configure_rgb_led(self): """ https://docs.pycom.io/tutorials/all/rgbled.html """ import pycom # Enable or disable heartbeat. rgb_led_heartbeat = self.settings.get('main.rgb_led.heartbeat', True) pycom.heartbeat(rgb_led_heartbeat) pycom.heartbeat_on_boot(rgb_led_heartbeat) # Alternative signalling. # Todo: Run this in a separate thread in order not to delay execution of main program flow. if not rgb_led_heartbeat: for _ in range(2): pycom.rgbled(0x001100) time.sleep(0.15) pycom.rgbled(0x000000) time.sleep(0.10) def power_off_lte_modem(self): """ We don't use LTE yet. https://community.hiveeyes.org/t/lte-modem-des-pycom-fipy-komplett-stilllegen/2161 https://forum.pycom.io/topic/4877/deepsleep-on-batteries/10 """ import pycom """ if not pycom.lte_modem_en_on_boot(): log.info('Skip turning off LTE modem') return """ log.info('Turning off LTE modem') try: from network import LTE # Invoking this will cause `LTE.deinit()` to take around 6(!) seconds. #log.info('Enabling LTE modem on boot') #pycom.lte_modem_en_on_boot(True) log.info('Turning off LTE modem on boot') pycom.lte_modem_en_on_boot(False) log.info('Invoking LTE.deinit()') lte = LTE() lte.deinit() except: log.exception('Shutting down LTE modem failed') def power_off_bluetooth(self): """ We don't use Bluetooth yet. """ log.info('Turning off Bluetooth') try: from network import Bluetooth bluetooth = Bluetooth() bluetooth.deinit() except: log.exception('Shutting down Bluetooth failed') def start_telemetry(self): log.info('Starting telemetry') self.telemetry = TelemetryManager() # Read all designated telemetry targets from configuration settings. telemetry_targets = self.settings.get('telemetry.targets') # Compute list of all _enabled_ telemetry targets. telemetry_candidates = [] for telemetry_target in telemetry_targets: if telemetry_target.get('enabled', False): telemetry_candidates.append(telemetry_target) # Create adapter objects for each enabled telemetry target. for telemetry_target in telemetry_candidates: try: self.create_telemetry_adapter(telemetry_target) self.feed_watchdog() except: log.exception( 'Creating telemetry adapter failed for target: %s', telemetry_target) def create_telemetry_adapter(self, telemetry_target): # Create adapter object. telemetry_adapter = TelemetryAdapter( device=self, endpoint=telemetry_target['endpoint'], address=telemetry_target.get('address'), data=telemetry_target.get('data'), topology=telemetry_target.get('topology'), format=telemetry_target.get('format'), content_encoding=telemetry_target.get('encode'), ) # Setup telemetry adapter. telemetry_adapter.setup() self.telemetry.add_adapter(telemetry_adapter) def enable_serial(self): # Disable these two lines if you don't want serial access. # The Pycom forum tells us that this is already incorporated into # more recent firmwares, so this is probably a thing of the past. #uart = machine.UART(0, 115200) #os.dupterm(uart) pass def print_bootscreen(self): """ Print bootscreen. This contains important details about your device and the operating system running on it. """ if not self.settings.get('main.logging.enabled', False): return # Todo: Maybe refactor to TerkinDatalogger. from uio import StringIO buffer = StringIO() def add(item=''): buffer.write(item) buffer.write('\n') # Program name and version. title = '{} {}'.format(self.name, self.version) add() add('=' * len(title)) add(title) add('=' * len(title)) # Machine runtime information. add('CPU freq {} MHz'.format(machine.freq() / 1000000)) add('Device id {}'.format(self.device_id)) add() # System memory info (in bytes) machine.info() add() # TODO: Python runtime information. add('{:8}: {}'.format('Python', sys.version)) """ >>> import os; os.uname() (sysname='FiPy', nodename='FiPy', release='1.20.0.rc7', version='v1.9.4-2833cf5 on 2019-02-08', machine='FiPy with ESP32', lorawan='1.0.2', sigfox='1.0.1') """ runtime_info = os.uname() for key in dir(runtime_info): if key == '__class__': continue value = getattr(runtime_info, key) #print('value:', value) add('{:8}: {}'.format(key, value)) add() add() # Todo: Add program authors, contributors and credits. log.info('\n' + buffer.getvalue()) def power_off(self): self.networking.stop() def hibernate(self, interval, deepsleep=False): #logging.enable_logging() if deepsleep: # Prepare and invoke deep sleep. # https://docs.micropython.org/en/latest/library/machine.html#machine.deepsleep log.info('Preparing deep sleep') # Set wake up mode. self.set_wakeup_mode() # Invoke deep sleep. log.info('Entering deep sleep for {} seconds'.format(interval)) self.terminal.stop() machine.deepsleep(int(interval * 1000)) else: log.info('Entering light sleep for {} seconds'.format(interval)) # Invoke light sleep. # https://docs.micropython.org/en/latest/library/machine.html#machine.sleep # https://docs.micropython.org/en/latest/library/machine.html#machine.lightsleep # # As "machine.sleep" seems to be a noop on Pycom MicroPython, # we will just use the regular "time.sleep" here. # machine.sleep(int(interval * 1000)) time.sleep(interval) def resume(self): log.info('Reset cause and wakeup reason: %s', MachineResetCause.humanize()) def set_wakeup_mode(self): # Set wake up parameters. """ The arguments are: - pins: a list or tuple containing the GPIO to setup for deepsleep wakeup. - mode: selects the way the configured GPIOs can wake up the module. The possible values are: machine.WAKEUP_ALL_LOW and machine.WAKEUP_ANY_HIGH. - enable_pull: if set to True keeps the pull up or pull down resistors enabled during deep sleep. If this variable is set to True, then ULP or capacitive touch wakeup cannot be used in combination with GPIO wakeup. -- https://community.hiveeyes.org/t/deep-sleep-with-fipy-esp32-on-micropython/1792/12 This will yield a wake up reason like:: 'wakeup_reason': {'code': 1, 'message': 'PIN'} """ # Todo: ``enable_pull`` or not? # From documentation. # machine.pin_sleep_wakeup(pins=['P8'], mode=machine.WAKEUP_ALL_LOW, enable_pull=True) # Let's try. #machine.pin_sleep_wakeup(pins=['P8'], mode=machine.WAKEUP_ALL_LOW, enable_pull=False) pass
def go(deviceid, config, wlconfig, loops=25): """ Every single board deployment must have this function accepting these exact arguments. Only way to ensure a non-maddening structure! """ # Set up our last ditch hang preventer dogfood = 60000 wdt = WDT(timeout=dogfood) print("Watchdog set for %.2f seconds" % (dogfood / 1000.)) # Unpack the things knownaps = config['knownaps'] dbconfig = config['dbconfig'] wlan = wlconfig['wlan'] wconfig = wlconfig['wconfig'] # Indicate our WiFi connection status ledIndicator = utils.shinyThing(pin=4, inverted=False, startBlink=True) if wlan.isconnected() is True: ledIndicator.off() else: utils.blinken(ledIndicator, 0.25, 10) ledIndicator.on() # Set up the onewire stuff dsPin = Pin(21) ow = onewire.OneWire(dsPin) ds = ds18x20.DS18X20(ow) loopCounter = 0 while loopCounter < loops: # Feed the dog. We'll do this a bunch since wifi can be slow wdt.feed() print("\nFed the dog") print("Starting loop %d of %d" % (loopCounter + 1, loops)) print("Checking WiFi status ...") # Attempt to connect to one of the strongest of knownaps wlan, wconfig = uwifi.checkWifiStatus(knownaps, wlan=wlan, conf=wconfig, repl=False) # Try to store the connection information wdt.feed() print("Fed the dog") sV = utils.postNetConfig(wlan, dbconfig, tagname=deviceid) # We only should attempt a measurement if the wifi is good, so # keep this all in the conditional! if wlan.isconnected() is True: # If the network config dropped out suddenly, sV will be false. # That lets us skip the rest so we can get a WiFi status check # sooner rather than later if sV is True: wdt.feed() print("Fed the dog") doDS18x(ds, dbconfig, led=ledIndicator) gc.collect() # Print some memory statistics so I can watch for problems micropython.mem_info() print("Sleeping (and feeding the dog) ...\n") for sc in range(0, 60): if sc % 10 == 0 and sc != 0: print("\n") else: print(".", end='') time.sleep(1) wdt.feed() loopCounter += 1 # Since we're at the end of our rope here, drop the hammer and reset print("Resetting in 5 seconds ...") time.sleep(5) reset()
client.connect() client.subscribe(topic_sub) print('Connected to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_sub)) return client def restart_and_reconnect(): print('Failed to connect to MQTT broker. Reconnecting...') time.sleep(10) machine.reset() try: client = connect_and_subscribe() except OSError as e: restart_and_reconnect() while True: try: client.check_msg() status = analog.read() msg = b'OFF' if status == 1024 else b'ON' client.publish(topic_pub, msg) time.sleep(1) #sec wdt.feed() # wathdog print(msg) except OSError as e: restart_and_reconnect()
self.blynk.lcd_write(7, 0, 1, config.SERIAL) self._send_coins() self.time = 0 c_coins =[self.coins[2].count, self.coins[3].count] if self.prev_coins != c_coins: self.prev_coins = c_coins self.leds.coin_in() self._send_coins() wdt = WDT(timeout=WDT_TIMEOUT) wlan = WLAN(mode=WLAN.STA) connect_to_wlan(wlan) # the WDT will reset if this takes more than 15s wdt.feed() # set the current time (mandatory to validate certificates) RTC(datetime=(2015, 12, 12, 11, 30, 0, 0, None)) # initialize Blynk with SSL enabled blynk = BlynkLib.Blynk(BLYNK_AUTH, wdt=False, ssl=True) # register the main task s_task = MainTask(blynk, wdt, MAIN_TASK_PERIOD, COIN_INPUTS[config.COIN_10_CENT], COIN_INPUTS[config.COIN_20_CENT], COIN_INPUTS[config.COIN_50_CENT], COIN_INPUTS[config.COIN_1_EUR], COIN_INPUTS[config.COIN_2_EUR], COIN_INPUTS[config.EUR_TOTAL], COIN_INPUTS[config.ALARM])