def loadJsonTime(self, jsonString):
obj = json.loads(jsonString)
hour = obj.hour
minute = obj.minute
second = obj.second
now = (2017, 1, 1, hour, minute, second, 0, 1)
rtc.datetime(now)
def get_internet_time(wlan):
global internet_time_acquired
ntptime.host = "0.au.pool.ntp.org" # Find your local NTP server here: https://www.ntppool.org/en/
print("GET TIME Connected? ", wlan.isconnected())
rtc = RTC()
try:
print("Utime time before synchronization：%s" %str(utime.localtime()))
#make sure to have internet connection
ntptime.settime()
print("Utime/UTC time after synchronization：%s" %str(utime.localtime()))
current_time_date_utc = utime.localtime() # The ntptime library will set utime.localtime to the UTC time automatically.
current_time_date_local = utime.mktime(current_time_date_utc) # Create a new time object to store the local time.
current_time_date_local += 11*3600 # Sydney is 11 hours ahead of UTC. One hour has 60*60 = 3600 seconds
print("Local time:, ", utime.localtime(current_time_date_local)) # This show time at your location
rtc.datetime( (utime.localtime(current_time_date_local)[0],
utime.localtime(current_time_date_local)[1],
utime.localtime(current_time_date_local)[2],
0,
utime.localtime(current_time_date_local)[3],
utime.localtime(current_time_date_local)[4],
utime.localtime(current_time_date_local)[5],
0))
internet_time_acquired = True
print("Internet time received: ", internet_time_acquired)
except:
print("Error syncing time")
def get_hhmmss(separator=":"):
rtc = RTC() # real time
# get_hhmm(separator) | separator = string: "-" / " "
hh = add0(rtc.datetime()[4])
mm = add0(rtc.datetime()[5])
ss = add0(rtc.datetime()[6])
return hh + separator + mm + separator + ss
def display_time(time,cl):
rtc = RTC()
time = time.split('\\/')
year = int('20'+time[0])
month = int(time[1])
time = time[2].split(' ')
day = int(time[0])
time = time[1].split(':')
hour = int(time[0])
minute = int(time[1])
seconds = int(time[2])
rtc.datetime((year, month, day, 1,hour,minute,seconds,0))
print(rtc.datetime())
date = []
year_month_date = ''
hour_min_seconds = ''
readable = 0
while True:
readable = select.select([cl],[],[],0.5)
date = list(str(x) for x in rtc.datetime()[0:7])
year_month_date = date[0] + '/' + date[1] + '/' + date[2]
hour_min_seconds = date[4] + ':' + date[5] + ':' + date[6]
oled.fill(0)
oled.text(year_month_date,0,0)
oled.text(hour_min_seconds, 0, 10)
oled.show()
def set_NTP_time():
import time
from machine import RTC
print("Setting time from NTP")
t = get_NTP_time()
if t is None:
print("Could not set time from NTP")
return False
tz = 0
with database.Database() as db:
tz = db.get("timezone", 200) # default to CEST
tz_minutes = int(abs(tz) % 100) * (1 if tz >= 0 else -1)
tz_hours = int(tz / 100)
t += (tz_hours * 3600) + (tz_minutes * 60)
tm = time.localtime(t)
tm = tm[0:3] + (0, ) + tm[3:6] + (0, )
rtc = RTC()
rtc.init()
rtc.datetime(tm)
return True
def do_something_else():
#The other script to be executed besides of the blocking socket
url = "http://worldtimeapi.org/api/timezone/Europe/Rome" #http://worldtimeapi.org/timezone/Europe/Rome" # see http://worldtimeapi.org/timezones
web_query_delay = 60000 # interval time of web JSON query
retry_delay = 5000 # interval time of retry after a failed Web query
rtc=RTC()
# set timer
update_time = utime.ticks_ms() - web_query_delay
#settime()
tempo=utime.localtime()
print((str(tempo)))
# oled.text(str(tempo), 10, 50)
# oled.show()
# while True:
# query and get web JSON every web_query_delay ms
if utime.ticks_ms() - update_time >= web_query_delay:
# HTTP GET data
response_tempo = urequests.get(url)
if response_tempo.status_code == 200: # query success
print("JSON response:\n", response_tempo.text)
# parse JSON
parsed = response_tempo.json()
datetime_str = str(parsed["datetime"])
year = int(datetime_str[0:4])
month = int(datetime_str[5:7])
day = int(datetime_str[8:10])
hour = int(datetime_str[11:13])
minute = int(datetime_str[14:16])
second = int(datetime_str[17:19])
subsecond = int(round(int(datetime_str[20:26]) / 10000))
#if minute ==31:
#Client_handler(LEDON0=6)
#LED2.value(1)
#print (("LED0 value="),LED0.value())
# update internal RTC
rtc.datetime((year, month, day, 0, hour, minute, second, subsecond))
update_time = utime.ticks_ms()
print("RTC updated\n")
else: # query failed, retry retry_delay ms later
update_time = utime.ticks_ms() - web_query_delay + retry_delay
# generate formated date/time strings from internal RTC
date_str = "Date: {2:02d}/{1:02d}/{0:4d}".format(*rtc.datetime())
time_str = "Time: {4:02d}:{5:02d}:{6:02d}".format(*rtc.datetime())
# update SSD1306 OLED display
oled.fill(0)
oled.text("ESP32 WebClock", 0, 5)
oled.text(date_str, 0, 25)
oled.text(time_str, 0, 45)
oled.show()
utime.sleep(0.1)
def setlocal(h=2):
import utime
from machine import RTC
rtc = RTC()
localtime = utime.time() + h * 3600
(year, month, mday, hour, minute, second, weekday,
yearday) = utime.localtime(localtime)
rtc.datetime((year, month, mday, 0, hour, minute, second, 0))
def update_time():
ntptime.host='ntp1.aliyun.com'
ntptime.settime()
list=time.localtime(time.time()+8*60*60)
rtc = RTC()
#rtc.datetime((year, month, mday, 0, hour, minute, second, 0))
rtc.datetime((list[0], list[1], list[2] ,None,list[3], list[4], list[5] ,0))
print (rtc.datetime()) # get date and time
def sync_time():
import urequests
from machine import RTC
rtc = RTC()
print('before sync: ', rtc.datetime())
time = urequests.get('http://www.1zlab.com/api/get-time/').json()
# print(time)
rtc.init(tuple(time['rtc']))
print('after sync: ', rtc.datetime())
def settime():
(hour_offset, minute_offset) = get_offset_from_api()
log.info("fetching time from ntp")
ntptime.settime()
# add offset
rtc = RTC()
(year, month, day, _, hour, minute, second, subsecond) = rtc.datetime()
rtc.datetime((year, month, day, 0, hour + hour_offset,
minute + minute_offset, second, subsecond))
class SetTime:
def __init__(self, pool='us.pool.ntp.org'):
self.pool = pool
self.rtc = RTC()
def setTime(self):
# synchronize with ntp
# need to be connected to wifi
ntptime.host = self.pool
ntptime.settime() # set the rtc datetime from the remote server
self.rtc.datetime() # get the date and time in UTC
def localRTC():
global rtc
rtc = RTC()
try:
ticks = myntptime.time(
) + 28800 #網路Timer取得格林威治時間+8Hours時差=28800Seconds
dt = time.localtime(ticks)
rtc.datetime(dt[0:3] + (0, ) + dt[3:6] + (0, )) #將取得時間轉入更新RTC 時間
return rtc
except OSError:
pass
def initTime():
print('initTime()....')
rtc = RTC()
rtc.datetime((2017, 8, 23, 1, 12, 48, 0, 0)) # set a specific date and time
print('Time : ', rtc.datetime()) # get date and time
# synchronize with ntp
# need to be connected to wifi
ntptime.settime() # set the rtc datetime from the remote server
print('Time(UTC): ', rtc.datetime()) # get the date and time in UTC
#print('rtc.now():', rtc.now())
print('Time:', utime.gmtime())
def update_time_http():
URL="http://quan.suning.com/getSysTime.do"
try:
res=urequests.get(URL).text
j=ujson.loads(res)
list=j['sysTime1']
rtc = RTC()
#rtc.datetime((year, month, mday, 0, hour, minute, second, 0))
rtc.datetime((int(list[0:4]), int(list[4:6]), int(list[6:8]) ,8,int(list[8:10]), int(list[10:12]), int(list[12:14] ),0))
print (rtc.datetime()) # get date and time
except OSError as e:
print ("upgrde failed!")
def record_dist(prefix='NAME',
interval_ms=100,
record_time=10,
trigger_pin_num=12,
echo_pin_num=14,
sound_speed=343,
write_file=1):
rtc = RTC()
sensor = HCSR04(trigger_pin=trigger_pin_num,
echo_pin=echo_pin_num,
c=sound_speed)
print('\nUsing sampling interval ', interval_ms, ' milliseconds...')
print('Recording data for ', record_time, ' seconds...\n')
ID = hexlify(unique_id()).decode(
'utf-8') # Unique ID of the microprocessor
tmp_file = 'tmp.txt' # A temporary filename; we will write partial data to this file, and rename only if sampling
datafile = open(tmp_file, 'w')
print('\n\n****Beginning Recording ****\n\n')
timestamp = str(utime.mktime(rtc.datetime()))
if write_file == 1:
filename = prefix + '_' + ID + '_' + timestamp + '.txt'
print('\nCreating data file: ', filename)
sample_num = (record_time * 1000) / 100
for sample in range(sample_num + 1):
t_onboard = rtc.datetime()
dist = sensor.distance()
data_str = ''
print(dist)
if write_file == 1:
for t in [sample,t_onboard[0],t_onboard[1],t_onboard[2],t_onboard[4],t_onboard[5], \
t_onboard[6],t_onboard[7], dist]:
data_str += '{} '.format(t)
if sample == 0:
datafile = open(tmp_file, 'w')
else: # If the first sample, overwrite old tmp_file if it exists
df = datafile.write(
"%s\n" % data_str
) # df contains the "result" of the write statement (success or failure)
else:
print(sample,t_onboard[0],t_onboard[1],t_onboard[2],t_onboard[3],t_onboard[4],t_onboard[5], \
t_onboard[6],t_onboard[7], dist)
if sample < sample_num: # Sleep only if another sample is to be taken
utime.sleep_ms(interval_ms)
#---------------------------------------
# Done with the comparison loop; change the temporary filename to the permanent one, now that sampling is complete
if write_file == 1: #---------------------------------------
datafile.close()
rename(tmp_file, filename)
def update_time():
ntptime.host = 'ntp1.aliyun.com'
try:
ntptime.settime()
except:
print("TIME UPGRADE FAILED")
return
list = time.localtime(time.time() + 8 * 60 * 60)
rtc = RTC()
rtc.datetime(
(list[0], list[1], list[2], None, list[3], list[4], list[5], 0))
print(rtc.datetime())
def SetTime(aTZone):
from machine import RTC
from ntptime import settime
try:
settime()
Time = time.time() + (aTZone * 3600)
(year, month, day, hour, minute, second, weekday,
yearday) = time.localtime(Time)
rtc = RTC()
rtc.datetime((year, month, day, 0, hour, minute, second, 0))
except:
pass
def main():
# ESP8266 Pin assignment
i2c = I2C(-1, scl=Pin(5), sda=Pin(4))
oled_width = 128
oled_height = 32
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)
oled.fill(0)
rtc = RTC()
initial_time = (2014, 5, 1, 4, 13, 0, 0, 0)
rtc.datetime(initial_time) #initial_time) #year, month, day
while True:
cur_time = rtc.datetime()
year = str(cur_time[0])
month = str(cur_time[1])
day = str(cur_time[2])
hour = str(cur_time[4])
minute = str(cur_time[5])
second = str(cur_time[6])
first_line = month + " " + day + ", " + year
second_line = hour + ":" + minute + ":" + second
oled.text(first_line, 0, 0)
oled.text(second_line, 0, 10)
oled.show()
oled.fill(0)
oled.text(str(mode), 100, 25)
oled.show()
while mode != 0: # not in regular mode
# oled.text(str(mode), 100, 25)
#
# if mode == 1: # change the year
# oled.fill(0)
# oled.text('Year: ' + year, 0, 0)
# oled.show()
# elif mode == 2: # change the month
# oled.fill(0)
# oled.text('Month: ' + month, 0, 0)
# oled.show()
# else:
# oled.fill(1)
# oled.show()
oled.fill(1)
oled.show()
class Clock():
def __init__(self, message):
#parse time recieved from the broker
date_time = message.split(" ")
date = date_time[0].split('-')
time = date_time[1].split(":")
#use rtc to keep track of time on board
self.__rtc = RTC()
self.__rtc.datetime((int(date[0]), int(date[1]), int(date[2]), 0, int(time[0]), int(time[1]), int(time[2][0:2]), 0))
def get_time(self):
#return time as string
time = self.__rtc.datetime()
return ("%s-%s-%s %s:%s:%s") % (str(time[0]), str(time[1]), str(time[2]), str(time[4]), str(time[5]), str(time[6]))
def rtcSetUserTime():
global currentTime
while True:
print(
"Please enter the time in the following format: yyyy mm dd hh mm ss: ",
end="")
currentTimeInput = input()
if parse(currentTimeInput):
rtc = RTC()
print("Setting time: ", currentTime)
rtc.datetime(currentTime)
print("Input ok")
break
async def set_rtc():
rtc = RTC()
while True:
t = -1
while t < 0:
try:
t = ntptime.time()
except OSError:
print('ntp timeout')
await asyncio.sleep(5)
s = gbtime(t) # Convert UTC to local (GB) time
t0 = time.time()
rtc.datetime(s[0:3] + (0, ) + s[3:6] + (0, ))
print('RTC was set, delta =', time.time() - t0)
await asyncio.sleep(600)
def getTime():
rtc = RTC()
t = rtc.datetime()
day = (t[0:3])
week = (t[3])
tm = (t[4:6])
return day,week,tm
class clock:
def __init__(self):
self.ntp()
self.dp()
self.se=0
self.rtc=RTC()
def net(self):
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
if not wlan.isconnected():
wlan.connect('wifiname','password')
def dp(self):
hspi = SPI(1, baudrate=10000000, polarity=0, phase=0)
self.display = max7219.Matrix8x8(hspi,Pin(5),4)
def ntp(self):
self.net()
ntptime.host="ntp1.aliyun.com"
ntptime.NTP_DELTA = 3155644800
try:
ntptime.settime()
except Exception as e:
pass
def show_time(self):
date=self.rtc.datetime()
self.m=date[5]
self.h=date[4]
self.display.fill(0)
self.display.text(str(self.h) if len(str(self.h))==2 else ' '+str(self.h) ,0,0,1)
self.display.pixel(16,2,self.se)
self.display.pixel(16,4,self.se)
self.display.text(str(self.m) if len(str(self.m))==2 else '0'+str(self.m) ,17,0,1)
self.se=0 if self.se==1 else 1
self.display.show()
def draw_dynamic_screen(temp="N/A",humi="N/A",press="N/A",display=None):
local_time = "N/A"
local_date = "N/A"
print("Internet time acquired", internet_time_acquired)
if (internet_time_acquired == True):
rtc = RTC()
date_time = rtc.datetime()
print(date_time) # print date and time
print("Current date (year, month, day, day of week): ", date_time[0],
"/",
date_time[1],
"/",
date_time[2],
" | ",
date_time[3])
print("Current time (hour:minute:second): ", date_time[4],
":",
date_time[5],
":",
date_time[6])
local_time = str(date_time[4]) + ":" + str(date_time[5]) + ":" + str(date_time[6])
local_date = str(date_time[0]) + "/" + str(date_time[1]) + "/" + str(date_time[2])
print(local_time)
display.text(temp, 45, 5, 1)
display.text(humi, 45, 15, 1)
display.text(press, 45, 25, 1)
display.text(local_time, 45, 35, 1)
display.text(local_date, 45, 45, 1)
print("iftt_notification_sent: ", iftt_notification_sent)
print("iftt_notification_counter: ", iftt_notification_counter)
display.text('IFTTT in', 5, 55, 1)
display.text(str(iftt_notification_interval_sec-iftt_notification_counter) + "s",80,55,1) # This will show a countdown.
def set_NTP_time():
import time
from machine import RTC
print("Setting time from NTP")
t = get_NTP_time()
if t is None:
print("Could not set time from NTP")
return False
tm = time.localtime(t)
tm = tm[0:3] + (0, ) + tm[3:6] + (0, )
rtc = RTC()
rtc.init()
rtc.datetime(tm)
return True
def logprint(msg):
rtc = RTC()
t = rtc.datetime()
#(2020, 4, 22, 2, 8, 43, 38, 88387)
# yyyy, m, dd, ?, h, mm, ss, ms
timestamp = str(t[2]) + "-" + str(t[1]) + "-" + str(t[0]) + " " + str(
t[4]) + ":" + str(t[5]) + ":" + str(t[6]) + "." + str(t[7])
result = str(timestamp) + " -> " + str(msg)
print(result)
def run(self):
self.stop()
alarm = config.get(self.path)['alarm']
alarm_year = alarm['year']
alarm_mon = alarm['mon']
alarm_day = alarm['day']
alarm_hour = alarm['hour']
alarm_min = alarm['min']
alarm_sec = alarm['sec']
alarm_on_off = alarm['on_off']
if alarm_on_off == 'on':
rtc = RTC()
dt = rtc.datetime()
year = dt[0]
mon = dt[1]
day = dt[2]
hour = dt[4]
min = dt[5]
sec = dt[6]
if hour == alarm_hour and min == alarm_min and sec == alarm_sec and self.beep_start == False:
self.beeper = PWM(Pin(self.BEEP_PIN, Pin.OUT),
freq=589,
duty=512)
self.beep_start = True
if self.beep_start and self.n >= 0:
self.n -= 1
self.beeper.freq(589)
time.sleep_ms(100)
self.beeper.freq(0)
time.sleep_ms(50)
self.beeper.freq(589)
time.sleep_ms(100)
self.beeper.freq(0)
time.sleep_ms(650)
if (self.beep_start
and self.n <= 0) or (self.key.read() == self.key.HOME_PRESS
and self.beep_start):
self.cnt = 0
self.freq0_on = False
self.freq589_on = False
self.beep_start = False
self.beeper.deinit()
self.start()
def settime(ntpservers):
def asctime(): # get human readable version
x = utime.localtime()
return '%02d/%02d/%04d %02d:%02d' % (x[1], x[2], x[0], x[3], x[4])
# like 12/13/2017 14:31
for server in ntpservers:
t = _getntptime(server)
if t != 0:
break
if t != 0:
tm = utime.localtime(t) # format number into dmy ms etc
tm = tm[0:3] + (0, ) + tm[3:6] + (0, ) # reformat to suit rtc
rtc = RTC()
rtc.datetime(tm) # write into rtc
print("Time sync: %s UTC" % asctime())
else:
print("Time sync fail")
return (t != 0)
def run(owner):
from utime import sleep
sleep(0.1)
from gc import collect
from machine import I2C, Pin, RTC
bus = I2C(-1, Pin(4), Pin(5))
from urtc import DS3231
rtc = RTC()
dl = [x for x in DS3231(bus).datetime() if x]
rtc.datetime(dl + [0 for x in range(0, 8 - len(dl))])
del I2C, Pin, DS3231, rtc, dl
collect()
sleep(0.2)
from gc import collect
from states import init
init_state = init()
owner.core.load()
collect()
init_state.on_enter(owner)
async def test2_square(pin, scl, sda):
i2c = I2C(-1, scl=scl, sda=sda)
oled = ssd1306.SSD1306_I2C(128, 64, i2c)
rtc = RTC()
while True:
if sys.platform == 'esp32':
# We want maximum precision, so we let await get us within 2ms,
# then use a blocking utime.sleep_us() to strike. Every now and
# the something will interfere ... meh.
delay = (1000000 - rtc.datetime()[7]) // 1000
if delay > 4:
await asyncio.sleep_ms(delay - 2)
delay = (1000000 - rtc.datetime()[7])
if delay > 0:
utime.sleep_us(delay)
elif sys.platform == 'esp8266':
# ESP8266 only has milliseconds, so no point in the above.
delay = (1000 - rtc.datetime()[7])
if delay > 0:
await asyncio.sleep_ms(delay)
else:
raise RuntimeError("unsupported platform '{}'".format(
sys.platform))
# Turn the pin on and print the current time on REPL
pin.value(1)
oled.fill(0)
now = utime.localtime()
oled.text("{0:04d}-{1:02d}-{2:02d}".format(*now), 0, 0)
oled.text(" {3:02d}:{4:02d}:{5:02d}".format(*now), 0, 8)
oled.show()
# Wait for 100ms
if sys.platform == 'esp32':
delay = (100000 - rtc.datetime()[7]) // 1000
elif sys.platform == 'esp8266':
delay = (100 - rtc.datetime()[7])
if delay > 0:
await asyncio.sleep_ms(delay)
# Turn the pin off
pin.value(0)
