def start_app(act_name, msg): global tft tft.text(msg, 5, 180, WHITE, RED) from machine import RTC, deepsleep rtc = RTC() rtc.memory(act_name) time.sleep(1) deepsleep(1) # use deepsleep to reset and release memory
def main(vs): global var_store, free_mem var_store = vs print("tfth.main") horo_main=var_store['horo_main'] sd = var_store['sd'] tft = var_store['tft'] free_mem = var_store['free_mem'] tzone = load_tzone() lat,lon,drx = load_geo_cfg() syn=sync_time() tm = get_time() ct = time.localtime(tm) yr,mon,mday,hr,minu,sec,wday,_,=ct tfth = TFTHoro(tft,tzone=tzone, lat=lat,lon=lon,drx=drx) tfth.set_datetime(yr,mon,mday,hr,minu,sec) var_store['tfth']=tfth var_store['tft']=tft tft.start_spi() first_cycle=True while True: if chk_btn(): break try: _t(horo_main,tfth,tft,first_cycle) if first_cycle: first_cycle=False except Exception as e: sys.print_exception(e) time.sleep(1) i=0 while True: if chk_btn(): break time.sleep(0.5) tm = get_time() ct = time.localtime(tm) yr,mon,mday,hr,minu,sec,wday,_,=ct colon=' ' if i: colon=':' i = not i tft.draw_string_at(colon,244,165,fnt,fg=WHITE,bg=NAVY) if sec==0: if minu==0 or not syn: # sync every hour syn = sync_time() break # command mode free_mem() if btn['A']: print('ap_lunar') from machine import RTC, deepsleep rtc = RTC() rtc.memory('ap_lunar') #tft.text('Lunar calendar...',5,5) #time.sleep(1) deepsleep(1) # use deepsleep to reset and release all memory
def skip(): # command mode free_mem() if tch: print('ap_lunar') from machine import RTC, deepsleep rtc = RTC() rtc.memory('ap_lunar') #tft.text('Lunar calendar...',5,5) #time.sleep(1) deepsleep(1) # use deepsleep to reset and release all memory
def handle_interrupt(v): global switch_active rtc = RTC() print('Switch Interrupt') if switch_active == False: switch_active = True rtc.memory(b'3') start_webserver() if switch_active == True: switch_active = False print('Switch Toggle Off')
def WriteRTCMemory(write_timestamp, pressure_value): from machine import RTC rtc = RTC() print('---> Now writing to ESP8266 RTC memory') data = '%d,%d,%d,%d,' % (write_timestamp, curr_dst_status, accuracy, current_timestamp) for val in pressure_value: data += '%d,' % val data += '0' # flag as unverified rtc.memory(data)
def ReadRTCMemory(ERRORFILE, rel_Pres_Rounded_hPa): from machine import RTC global saved_dst_status, last_pval_timestamp, accuracy rtc = RTC() print('---> Now reading ESP8266 RTC memory') data = rtc.memory() if not data: print('Empty RTC memory -- assuming First Run') FirstTimeRun(rel_Pres_Rounded_hPa) data_list = [int(i) for i in data.split(b',')] last_pval_timestamp = data_list[0] saved_dst_status = data_list[1] accuracy = data_list[2] last_run_timestamp = data_list[3] flag = data_list[:-1] VerifyLastRunCompleted(flag, last_run_timestamp, ERRORFILE) pressure_values = [] for i in range(4, pval_count + 4): pressure_values.append(data_list[i]) print('Last %d saved pressure values:' % pval_count, ('%d; ' * pval_count)[:-2] % tuple(pressure_values)) return pressure_values
def init_RTC(init): global r # pass list of bytes eg [1, 1, 0, 0, 0] ########################################### # RTC 16KB of SRAM ########################################### # index into RTC memory, 2 bytes # r.memory()[0] is temp error state # r.memory()[1] is lipo error state # 2 number of temp read error since last reboot # 3 same for lipo # 4 number of watchdog popped r = RTC() mem = r.memory() # content survives deep sleep print('RTC memory: ', mem) if (mem == b''): print('RTC memory empty. initializing..') #r.memory(bytearray(0b00000000)) # need object with buffer protocol # store x bytes in RTC # layout # 1 , 1 : reset error condition for sensor error. send alarm only first error and recovered # 0, 0, 0 : number of temp error, lipo error, watchdog reset , SINCE LAST POWER UP r.memory(bytes(init)) # need object with buffer protocol mem = r.memory() # type bytes, immutable print('RTC memory: ', mem) # b'\x01\x01\x00\x00\x00' # to test a value r.memory() [i] # to set a value # x=r.memory() # x=bytearray(x) make mutable # x[i]=1 # r.memory(x) # bit operation possible as well # r.memory and wifi_error == 0 , test if bit not set # r.memory (r.memory() or wifi_error), set bit # r.memory (r.memory() and not wifi_error) reset bit else: pass
def FirstTimeRun(rel_Pres_Rounded_hPa): from cycle_machine import ResetMachine from machine import RTC global accuracy print('---> Starting initialization process') rtc = RTC() accuracy = 1 data = '%d,%d,%d,%d,' % (current_timestamp, curr_dst_status, accuracy, current_timestamp) for _ in range(pval_count): data += '%d,' % rel_Pres_Rounded_hPa print('---> Saved initial pressure data') data += '1' rtc.memory(data) print('Doing a reset now.') ResetMachine()
# custo File → Preferences → User Settings tab size and detect import gc from machine import deepsleep, idle, RTC, reset_cause, DEEPSLEEP_RESET, DEEPSLEEP from utime import sleep_ms, sleep, sleep_us, localtime, mktime from machine import Pin import framebuf # check if the device woke from a deep sleep if reset_cause() == DEEPSLEEP_RESET: print('woke from a deep sleep') else: print('fresh boot') r = RTC() mem = r.memory() # content survives deep sleep print('RTC memory contents (bytes): ', mem) # bytes # initialize and increment RTC memory. digit as string if mem == b'': print('RTC memory empty. initializing with "0" ..') mem = "0" r.memory(mem) mem_int = int(mem) # avoid gosts if mem_int == 9: avoid_ghost = True # could be used to do some housekeeping on the display every x deep sleep mem_int = 1
#hardware platform: FireBeetle-ESP8266 from machine import RTC import time rtc = RTC() #create RTC object print(rtc.datetime( )) #print time(year, month, day, hour, minute, second, microsecond, tzinfo) #rtc.datetime((2017,5,20,5,0,0,0,0)) #you can use this to set current time print(rtc.datetime()) time.sleep(3.5) print(rtc.datetime()) print(rtc.memory()) #print the memory of rtc rtc.memory("dfrobot" + str(rtc.datetime()[6])) #set rtc memory
# check if the device woke from a deep sleep if reset_cause() == DEEPSLEEP_RESET: print('ESP32: woke from a deep sleep') else: print('ESP32: fresh boot') ########################################### # RTC 16KB of SRAM ########################################### # index into RTC memory, 2 bytes # r.memory()[0] is temp error # r.memory()[1] is lipo error r = RTC() mem = r.memory() # content survives deep sleep print('RTC memory: ', mem) if (mem == b''): print('RTC memory empty. initializing..') #r.memory(bytearray(0b00000000)) # need object with buffer protocol # store 2 bytes in RTC # default OK r.memory(bytes([1, 1])) # need object with buffer protocol mem = r.memory() # type bytes, immutable print('RTC memory: ', mem) # to test a value r.memory() [i] # to set a value # x=r.memory()
tft.bl_on() tft.start_spi() tft.fill_rect(0, 0, 240, 20, NAVY) tft.text('starting...', 5, 5, WHITE, NAVY) import gc gc.collect() var_store = { 'tft': tft, 'horo_main': horo_main, 'free_mem': free_mem, 'motor': motor, 'rtcx': rtcx } rtc = RTC() app_name = rtc.memory() if not app_name: import ap_bmp_1 ap_bmp_1.main(var_store) free_mem() app_name = 'ap_lunar' else: app_name = app_name.decode('utf-8') var_store['old_app_name'] = app_name while app_name: old_app_name = app_name app = __import__(old_app_name) app_name = app.main(var_store) var_store['old_app_name'] = old_app_name del sys.modules[old_app_name]
print('RNG number repeated') break for i in range(0, 10): machine.idle() print("Active") #print(machine.reset_cause() >= 0) #print(machine.wake_reason() >= 0) try: machine.main(123456) except: print('Exception') try: machine.main("other_main.py") except: print('Exception') # Test machine.RTC from machine import RTC rtc = RTC() #reset memory rtc.memory(b'') print(rtc.memory()) rtc.memory(b'10101010') print(rtc.memory())
if machine.reset_cause() == machine.PWRON_RESET: initial_buzzer_duty = 512 buzzer = PWM(Pin(BUZZER_PIN), freq=4000, duty=initial_buzzer_duty) time.sleep(0.05) buzzer.duty(0) leak_detect_pad = TouchPad(Pin(LEAK_TOUCHPAD_PIN)) leak_detect_pad.config(LEAK_CAP_THRESHOLD) print("Slowing down touch sensor measurement rate") esp32.set_touch_sensor_measurement_time( 0xffff, # 2.28885 Hz 0x1fff) # 1.02388 ms rtc = RTC() print("RTC memory: {}".format(rtc.memory())) error_reported = True if rtc.memory() else False blynk = blynklib.Blynk(secret.BLYNK_AUTH, log=print) dishwasher = Device(blynk, buzzer, connect, leak_detect_pad) if not dishwasher.is_leak(): print("There is no leak") dishwasher.leak_led = False dishwasher.beacon() # The touchpad reading gets lower when wifi is activated so it's possible # that we get here (there is no leak) but still that the capacitance # shown below is below LEAK_CAP_THRESHOLD since here we sent a beacon # hence we are connected to wifi. # It doesn't affect a real leak since a leak bottoms out the capacitance # to 0.