def __init__(): if(VC0706.wlan == None): VC0706.wlan = sendData.connectLocalBox() rtc = RTC() rtc.ntp_sync('fr.pool.ntp.org') if(VC0706.sd == None): mountSDCard() if(VC0706.uart == None): VC0706.uart = UART(2, baudrate=38400, pins=('G8','G7'), timeout_chars=5, bits=8, parity=None, stop=1) VC0706.uart.readall() setsize(VC0706_160x120) reset() gc.enable()
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)
class DS3231: def __init__(self): self.ds3231 = I2C(0, I2C.MASTER, baudrate=100000, pins=('GP15', 'GP10')) self.rtc = RTC() def loadTime(self): if DS3231_I2C_ADDR in self.ds3231.scan(): data = self.ds3231.readfrom_mem(DS3231_I2C_ADDR, 0, 7) ss=bcd2dec(data[0] & 0b01111111) mm=bcd2dec(data[1] & 0b01111111) if data[2] & 0b01000000 > 0: hh=bcd2dec(data[2] & 0b00011111) if data[2] & 0b00100000 >0: hh+=12 else: hh=bcd2dec(data[2] & 0b00111111) DD=bcd2dec(data[4] & 0b00111111) MM=bcd2dec(data[5] & 0b00011111) YY=bcd2dec(data[6]) if data[5] & 0b10000000 > 0: YY=YY+2000 else: YY=YY+1900 self.rtc.init((YY,MM,DD,hh,mm,ss)) else: print("DS3231 not found on I2C bus at %d" % DS3231_I2C_ADDR) def saveTime(self): (YY,MM,DD,hh,mm,ss,micro,tz) = self.rtc.now() self.ds3231.writeto_mem(DS3231_I2C_ADDR, 0,dec2bcd(ss)); self.ds3231.writeto_mem(DS3231_I2C_ADDR, 1,dec2bcd(mm)); self.ds3231.writeto_mem(DS3231_I2C_ADDR, 2,dec2bcd(hh)); self.ds3231.writeto_mem(DS3231_I2C_ADDR, 4,dec2bcd(DD)); if YY >= 2000: self.ds3231.writeto_mem(DS3231_I2C_ADDR, 5,dec2bcd(MM) | 0b10000000); self.ds3231.writeto_mem(DS3231_I2C_ADDR, 6,dec2bcd(YY-2000)); else: self.ds3231.writeto_mem(DS3231_I2C_ADDR, 5,dec2bcd(MM)); self.ds3231.writeto_mem(DS3231_I2C_ADDR, 6,dec2bcd(YY-1900));
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
import pycom import math import gc from network import WLAN from mqtt import MQTTClient execfile('/flash/Wi-Fi/Wi-Fi.py') f_device = open('/flash/Config/Device_Details.txt', 'r') device_setting = f_device.readline() device_strings = [i.strip() for i in device_setting.split(',')] f_device.close() rtc = RTC() adc = ADC() echo = Pin(Pin.exp_board.G7, mode=Pin.IN) trigger = Pin(Pin.exp_board.G8, mode=Pin.OUT) trigger(0) chrono = Timer.Chrono() pycom.heartbeat(False) def settimeout(duration): pass client = MQTTClient("garage", "your mqtt broker host", user="******", password="******", port=mqtt port here) client.settimeout = settimeout client.connect() mqtt_topic = "garagedoor"
from machine import RTC import time import server print('main start') def birdFeeder(): import servoTest servoTest.run(5) p1 = Pin(2, Pin.OUT) if (alarm.init()): print('alarm triggered') p1.off() f = open('alarm.log', 'a') f.write(str(RTC().datetime()) + ": alarm triggered \n") f.close() #birdFeeder() time.sleep_ms(60000) alarm.manualStart() else: p1.on() print('normal boot, no alarm') server.start()
def main(): import time print("time:", time.time()) from machine import RTC print("RTC datetime:", RTC().now())
class MBusDevice: """Class that encapulates/emulates a single MBus device""" def __init__(self, primary_address, secondary_address, manufacturer, meter_type): self._primary_address = primary_address self._secondary_address = secondary_address self._manufacturer = manufacturer self._type = meter_type self._access_number = random.randint(0, 255) self._records = [] self._rsp_ud2 = [] self._selected = False self.rtc = RTC() def get_time(self): """Returns the current time, as known by this MBus device""" return "%02u:%02u:%02u (%d)" % self.rtc.datetime()[4:8] def select(self): """Puts this MBus device in the 'selected' state""" if not self._selected: self._selected = True self.log("device {} is now selected".format( self._secondary_address)) def deselect(self): """Puts this MBus device in an 'unselected' state""" if self._selected: self._selected = False self.log("device {} is now deselected".format( self._secondary_address)) def is_selected(self): """Returns the current selection state for this MBus device""" return self._selected def log(self, message): print("[{}][debug ] {}".format(self.get_time(), message)) def update(self): for record in self._records: record.update() self.log("Device with ID {} has updated its data".format( self._secondary_address)) self.seal() def add_record(self, record): self._records.append(record) def seal(self): self._rsp_ud2 = self.get_rsp_ud2() def get_primary_address(self): """Returns the primary address for this MBus device""" return self._primary_address def get_secondary_address(self): """Returns the secondary address for this MBus device""" return self._secondary_address def matches_secondary_address(self, search_string): """Returns true if the secondary address of this MBus device matches the provided search string""" pattern = re.compile(search_string.replace('f', '[0-9]')) if pattern.match(self._secondary_address): return True return False def get_manufacturer_id(self): """Returns the manufacturer id for this MBus device""" return self._manufacturer def get_type(self): """Returns the MBus attribute 'type' for this MBus device""" return self._type def get_address_bytes(self): """Returns the secondary address for this MBus device, as a byte array""" resp_bytes = [] resp_bytes.append(self._secondary_address[6]) resp_bytes.append(self._secondary_address[7]) resp_bytes.append(self._secondary_address[4]) resp_bytes.append(self._secondary_address[5]) resp_bytes.append(self._secondary_address[2]) resp_bytes.append(self._secondary_address[3]) resp_bytes.append(self._secondary_address[0]) resp_bytes.append(self._secondary_address[1]) resp_str = [] resp_str.append(resp_bytes[0] + resp_bytes[1]) resp_str.append(resp_bytes[2] + resp_bytes[3]) resp_str.append(resp_bytes[4] + resp_bytes[5]) resp_str.append(resp_bytes[6] + resp_bytes[7]) ret = [x for x in resp_str] return ret def get_manufacturer_bytes(self): """Returns the manufacturer id for this MBus device, as a byte array""" manufacturer = self._manufacturer.upper() id = ((ord(manufacturer[0]) - 64) * 32 * 32 + (ord(manufacturer[1]) - 64) * 32 + (ord(manufacturer[2]) - 64)) if 0x0421 <= id <= 0x6b5a: return self.manufacturer_encode(id, 2) return False def manufacturer_encode(self, value, size): """Converts a manufacturer id to its byte equivalent""" if value is None or value == False: return None data = [] for i in range(0, size): data.append((value >> (i * 8)) & 0xFF) return data def calculate_checksum(self, message): """Calculates the checksum of the provided data""" return sum([int(x, 16) if type(x) == str else x for x in message]) & 0xFF def get_latest_values(self): return self._rsp_ud2 def get_rsp_ud2(self): """Generates a RSP_UD2 response message""" resp_bytes = [] resp_bytes.append(0x68) # start resp_bytes.append(0xFF) # length resp_bytes.append(0xFF) # length resp_bytes.append(0x68) # start resp_bytes.append(0x08) # C resp_bytes.append(self._primary_address) # A resp_bytes.append(0x72) # CI resp_bytes.extend(self.get_address_bytes()) resp_bytes.extend(self.get_manufacturer_bytes()) resp_bytes.append(0x01) # version resp_bytes.append(self._type) # medium (heat) resp_bytes.append(self._access_number) # access no resp_bytes.append(0x00) # status resp_bytes.append(0x00) # configuration 1 resp_bytes.append(0x00) # configuration 2 for record in self._records: resp_bytes.extend(record.get_bytes()) resp_bytes.append(self.calculate_checksum(resp_bytes[4:])) resp_bytes.append(0x16) # stop length = len(resp_bytes) - 9 + 3 resp_bytes[1] = length resp_bytes[2] = length ret = [ "{:>2}".format(hex(x)[2:]).replace(' ', '0') if type(x) == int else x for x in resp_bytes ] if self._access_number < 255: self._access_number = self._access_number + 1 else: self._access_number = 1 return ''.join(ret).upper()
#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
timerLed = True timerBeep = False olab = Env() # for initialized equipment from os import urandom from time import sleep, sleep_ms, sleep_us, ticks_ms, ticks_diff from machine import Pin, I2C, PWM, SPI, Timer, RTC from util.colors import * from util.pinout import set_pinout from util.io_config import get_from_file pinout = set_pinout() # set board pinout rtc = RTC() # real time io_conf = get_from_file() # read configuration for peripherals # I2C address: LCD_ADDR = 0x27 OLED_ADDR = 0x3c if Env.isTimer: from machine import Timer tim1 = Timer(0) # -------------------------------- common terminal function --------------- def getVer(): return "octopusLAB - lib.version: " + Env.ver + " > " + Env.verDat
# # Copyright (c) 2006-2019, RT-Thread Development Team # # SPDX-License-Identifier: MIT License # # Change Logs: # Date Author Notes # 2019-06-13 SummerGift first version # from machine import RTC rtc = RTC() # Create an RTC device object rtc.init((2019, 6, 5, 2, 10, 22, 30, 0)) # Set initialization time print(rtc.now()) # Get the current time rtc.deinit() # Reset time to January 1, 2015 print(rtc.now()) # Get the current time
if not 'LaunchPad' in mch and not 'WiPy' in mch: raise Exception('Board not supported!') def rtc_ticks_ms(rtc): timedate = rtc.now() return (timedate[5] * 1000) + (timedate[6] // 1000) rtc_irq_count = 0 def alarm_handler (rtc_o): global rtc_irq global rtc_irq_count if rtc_irq.flags() & RTC.ALARM0: rtc_irq_count += 1 rtc = RTC() rtc.alarm(time=500, repeat=True) rtc_irq = rtc.irq(trigger=RTC.ALARM0, handler=alarm_handler) # active mode time.sleep_ms(1000) rtc.alarm_cancel() print(rtc_irq_count == 2) rtc_irq_count = 0 rtc.alarm(time=200, repeat=True) time.sleep_ms(1000) rtc.alarm_cancel() print(rtc_irq_count == 5) rtc_irq_count = 0 rtc.alarm(time=100, repeat=True)
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 # 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, deep=False): #logging.enable_logging() if deep: # 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 settime(): RTC().datetime(localtime(getntp())) print(time.localtime())
class WifiClock: def __init__(self): # Initialize SPI self._spi = SPI(-1, baudrate=10000000, polarity=1, phase=0, sck=Pin(_SPI_CLK_PIN), mosi=Pin(_SPI_MOSI_PIN), miso=Pin(_SPI_MISO_PIN)) self._cs = Pin(_SPI_CS_PIN) self._cs.init(self._cs.OUT, True) # Initialize LEDs self.red_led = Pin(_RED_LED_PIN, Pin.OUT) self.green_led = Pin(_GREEN_LED_PIN, Pin.OUT) self.blue_led = Pin(_BLUE_LED_PIN, Pin.OUT) # Initialize buttons with interrupts self.mode_button = Pin(_MODE_BUTTON_PIN, Pin.IN, Pin.PULL_UP) self.mode_button.irq(trigger=Pin.IRQ_FALLING, handler=self.mode_button_callback) self.incr_button = Pin(_INCR_BUTTON_PIN, Pin.IN, Pin.PULL_UP) self.incr_button.irq(trigger=Pin.IRQ_FALLING, handler=self.incr_button_callback) self.decr_button = Pin(_DECR_BUTTON_PIN, Pin.IN, Pin.PULL_UP) self.decr_button.irq(trigger=Pin.IRQ_FALLING, handler=self.decr_button_callback) # Initialize current number and current decimal points self.current_num = None self.current_dp = 0b000000 # Initialize timer and rtc self.sta_if = network.WLAN(network.STA_IF) self.rtc = RTC() self.timer = Timer(1) for command, data in ( (_SHUTDOWN, 0), (_SCAN_LIMIT, 7), (_DECODE_MODE, 0xFF), (_INTENSITY, 0xa), (_SHUTDOWN, 1), ): self._register(command, data) self.display_clear() self.red_led.value(0) self.green_led.value(0) self.blue_led.value(0) # Connect to wifi def connect_to_wifi(self, ssid, password): if not self.sta_if.isconnected(): print('Connecting to network...') self.sta_if.active(True) self.sta_if.connect(ssid, password) while not self.sta_if.isconnected(): print('.', end='') time.sleep(1) print('Connected!') # Set time manually def set_time(self, hour, minute, second): self.rtc.datetime((2019, 1, 1, 0, hour, minute, second, 0)) # Set time using ntp server (must be connected to wifi) def set_time_ntp(self, utc_offset): ntptime.settime() d = self.rtc.datetime() hour = d[4] + utc_offset if hour < 0: hour = 24 + hour elif hour > 23: hour = hour - 24 d = (d[0], d[1], d[2], d[3], hour, d[5], d[6], d[7]) self.rtc.datetime(d) # Start a 24 hour clock (call after setting the time either with set_time or set_time_ntp) def start_clock24(self): self.timer.init(period=1000, mode=Timer.PERIODIC, callback=self.clock_timer_callback) # Set the display brightness def display_brightness(self, value): if 0 <= value <= 15: self._register(_INTENSITY, value) else: raise ValueError("Brightness out of range") # Clear the display def display_clear(self): self._register(_DECODE_MODE, 0xFF) for i in range(6): self._register(_DIGIT_DICT[i], 0x0F) self.current_num = None # Write a decimal value to the display, dp is 6 bit binary value representing where to put decimal points def write_num(self, value, dp=0b000000): self._register(_DECODE_MODE, 0xFF) if (0 <= value <= _MAX_VALUE_DEC) and (_MIN_VALUE_DP <= dp <= _MAX_VALUE_DP): self.current_num = value self.current_dp = dp for i in range(6): current_value = value % 10 if dp & 1: self._register(_DIGIT_DICT[i], current_value | _DP) else: self._register(_DIGIT_DICT[i], current_value) dp = dp >> 1 value = value // 10 elif (0 > value >= _MIN_VALUE_DEC) and (_MIN_VALUE_DP <= dp <= _MAX_VALUE_DP): self.current_num = value self.current_dp = dp value = -value self._register(_DIGIT5, 0xA) for i in range(5): current_value = value % 10 if dp & 1: self._register(_DIGIT_DICT[i], current_value | _DP) else: self._register(_DIGIT_DICT[i], current_value) dp = dp >> 1 value = value // 10 else: raise ValueError("Value out of range") # Write literal hex value to the display def write_hex(self, value): self._register(_DECODE_MODE, 0x0) if 0x0 <= value <= _MAX_VALUE_HEX: self.current_num = value for i in range(6): self._register(_DIGIT_DICT[i], _HEX_TO_SEG[value % 16]) value = value // 16 else: raise ValueError("Value out of range") # Toggle an LED @staticmethod def toggle_led(led): led.value(not (led.value())) # Increment the current number on the display def increment_num(self, hex=False): if self.current_num is None: raise ValueError("No value to increment") else: if hex: if (self.current_num + 1) > _MAX_VALUE_HEX: self.current_num = -1 self.write_hex(self.current_num + 1) else: if (self.current_num + 1) > _MAX_VALUE_DEC: self.current_num = -1 self.write_num(self.current_num + 1, self.current_dp) # Decrement the current number on the display def decrement_num(self, hex=False): if self.current_num is None: raise ValueError("No value to decrement") else: if hex: if (self.current_num - 1) < _MIN_VALUE_HEX: self.current_num = 1 self.write_hex(self.current_num - 1) else: if (self.current_num - 1) < _MIN_VALUE_DEC: self.current_num = 1 self.write_num(self.current_num - 1, self.current_dp) # Callback for Mode button def mode_button_callback(self, pin): if self._debounce(self.mode_button): self.toggle_led(self.red_led) # Callback for Incr Button def incr_button_callback(self, pin): if self._debounce(self.incr_button): self.increment_num() # Callback for Decr button def decr_button_callback(self, pin): if self._debounce(self.decr_button): self.decrement_num() # Callback for clock after calling start_clock24 def clock_timer_callback(self, tim): self._update_clock24() # Callback for other timer uses def timer_callback(self, tim): self.increment_num() # Read hours, minutes, and seconds from rtc and and write to the display def _update_clock24(self): current_time = self.rtc.datetime() hours = current_time[4] minutes = current_time[5] seconds = current_time[6] time_str = '' if hours < 10: time_str += '0' time_str += str(hours) if minutes < 10: time_str += '0' time_str += str(minutes) if seconds < 10: time_str += '0' time_str += str(seconds) self.write_num(int(time_str), 0b010100) # Send commands to MAX7219 def _register(self, command, data): self._cs.value(0) self._spi.write(bytearray([command, data])) self._cs.value(1) # Debounce function for debouncing buttons @staticmethod def _debounce(button): flag = 0 for i in range(_DEBOUNCE_SAMPLES): flag = button.value() if button.value(): return not flag return not flag
from machine import RTC rtc = RTC() print(rtc.now())
wlan.active(True) if not wlan.isconnected(): print('connecting to network...') wlan.connect('ZyXEL8B32A8', '73NHW74UKJ33X') while not wlan.isconnected(): pass print("Oh Yes! Get connected") print("Connected to " + str(wlan.config("essid"))) print("MAC Address: " + str(ubinascii.hexlify(wlan.config('mac'), ':').decode())) print("IP Address: " + wlan.ifconfig()[0]) connect() #Clock UTC time ntptime.settime() rtc = RTC() year, month, day, weekday, hours, minutes, seconds, microseconds = rtc.datetime() rtc.datetime((year, month, day, weekday, hours - 4, minutes, seconds, microseconds)) ntptime.host = "pool.ntp.org" #Hardware timer - 1 tim1 = Timer(1) tim1.init(period=15000, mode=Timer.PERIODIC, callback=lambda t:printtime(rtc.datetime())) #Variables #LEDs green = Pin(21, Pin.OUT) red = Pin(32, Pin.OUT) #Buttons button_red = Pin(25, Pin.IN, Pin.PULL_DOWN)
import untplib c=untplib.NTPClient() resp=c.request('0.uk.pool.ntp.org', version=3, port=123) print("Offset is ", resp.offset) from machine import RTC import time rtc = RTC() print("Adjusting clock by ", resp.offset, "seconds") rtc.init(time.localtime(time.time() + resp.offset))
def set_rtc( tm ): # time.struct_time year, month, day, hour, min, sec, wday, yday = tm print( year, month, day, hour, min, sec, wday, yday ) # (year, month, day, weekday, hours, minutes, seconds, sub-seconds) RTC().datetime( (tm[0],tm[1],tm[2],tm[6],tm[3],tm[4],tm[5],0) )
from jq6500 import Player from machine import I2C, Pin, UART, unique_id from mqtt import MQTTClient import micropython import time import ubinascii import mlx90614 import machine import math player = Player(port=1, volume=30) uart = UART(2, 115200) from machine import RTC rtc = RTC() def conexion(): try: i2c = I2C(scl=Pin(22), sda=Pin(21), freq=50000) sensor = mlx90614.MLX90614(i2c) except: print("conectando...") time.sleep(2) conexion() def Conexion_MQTT(): client_id = b"Covid_" + ubinascii.hexlify(unique_id()) #client_id = b"covid" mqtt_server = 'mantenimiento.elite.local'
def __init__(self): self.ds3231 = I2C(0, I2C.MASTER, baudrate=100000, pins=('GP15', 'GP10')) self.rtc = RTC()
from machine import RTC rtc = RTC() # for 22nd of June 2017 at 10:30am (TZ 0) rtc.init((2017, 6, 22, 10, 30, 0, 0, 0)) print(rtc.now())
while True: pass #---------------------------------------------------------- # Step 2: connect NTP server and synchronize RTC with NTP while True: try: # synchronize RTC with NTP server ntptime.settime() break except OSError: print('NTP server: connection timeout...') # create an RTC object rtc = RTC() #---------------------------------------------------------- # step 3: display clock (hours and minutes) DIGITS = [ [0x7f,0x41,0x7f], # 0 [0x21,0x7f,0x01], # 1 [0x4f,0x49,0x79], # 2 [0x49,0x49,0x7f], # 3 [0x78,0x08,0x7f], # 4 [0x79,0x49,0x4f], # 5 [0x7f,0x49,0x4f], # 6 [0x40,0x40,0x7f], # 7 [0x7f,0x49,0x7f], # 8 [0x79,0x49,0x7f] # 9
print('network config:', sta_if.ifconfig()) def pressure_altitude(pressure, qnh=1013.25): altitude = 44330.0 * (1.0 - pow(pressure / qnh, (1.0 / 5.255))) return altitude i2c1 = I2C(id=1, scl=Pin(I2C1_PIN_SCL), sda=Pin(I2C1_PIN_SDA), speed=400000) if i2c1.is_ready(BME280_I2CADDR): BME_present = True i2c1.deinit() if RTC_present: rtc = RTC() # print("RTC = ", rtc.now()) else: print("No RTC") uart = UART(1, tx=GNSS_PIN_TX, rx=GNSS_PIN_RX, timeout=1000, buffer_size=256, baudrate=9600) # Max Performance Mode (default) ubx_cont = bytearray( [0xB5, 0x62, 0x06, 0x11, 0x02, 0x00, 0x08, 0x00, 0x21, 0x91])
from machine import Pin from machine import ADC from machine import PWM import time ## I2C and OLED Initialization i2c = machine.I2C(-1, machine.Pin(5), machine.Pin(4)) oled = ssd1306.SSD1306_I2C(128, 32, i2c) ## Date Variables big_month = [1, 3, 5, 7, 8, 10, 12] week_day = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'] init_date = [2019, 1, 1, 0, 0, 0, 0, 0] ## RTC Intializaion rtc = RTC() rtc.datetime(tuple(init_date)) global button, state, set_mode, modes_size button = 'NULL' state = 'HOME' modes = ['SET_TIME', 'EXIT'] modes_size = len(modes) set_mode = 0 ## Display Settings def display(content, Page, Mark):
class TerkinDevice: """ """ def __init__(self, application_info: ApplicationInfo): self.application_info = application_info self.platform_info = application_info.platform_info self.name = application_info.name self.version = application_info.version self.settings = application_info.settings self.status = DeviceStatus() self.watchdog = Watchdog(device=self, settings=self.settings) # Conditionally enable terminal on UART0. Default: False. try: self.terminal = Terminal(self.settings) self.terminal.start() except Exception as ex: log.exc(ex, 'Enabling Terminal failed') self.device_id = get_device_id() self.networking = None self.telemetry = None self.rtc = None def start_networking(self): """ """ log.info('Starting networking') from terkin.network import NetworkManager, WiFiException self.networking = NetworkManager(device=self, settings=self.settings) if self.settings.get('networking.wifi.enabled'): # Start WiFi. try: self.networking.start_wifi() except Exception as ex: log.exc(ex, 'Starting WiFi networking failed') self.status.networking = False return # Wait for network stack to come up. try: self.networking.wait_for_ip_stack(timeout=5) self.status.networking = True except Exception as ex: log.exc(ex, 'IP stack not available') self.status.networking = False try: self.networking.start_services() except Exception as ex: log.exc(ex, 'Starting network services failed') else: log.info("[WiFi] interface disabled in settings.") # Initialize LoRa device. if self.settings.get('networking.lora.enabled'): if self.settings.get('networking.lora.antenna_attached'): try: self.networking.start_lora() self.status.networking = True except Exception as ex: log.exc(ex, 'Unable to start LoRa subsystem') self.status.networking = False else: log.info( "[LoRa] Disabling LoRa interface as no antenna has been attached. " "ATTENTION: Running LoRa without antenna will wreck your device." ) else: log.info("[LoRa] interface disabled in settings.") # Inform about networking status. #self.networking.print_status() 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): """Curate the garbage collector. https://docs.pycom.io/firmwareapi/micropython/gc.html For a "quick fix", issue the following periodically. https://community.hiveeyes.org/t/timing-things-on-micropython-for-esp32/2329/9 """ import gc log.info('Start curating the garbage collector') gc.threshold(gc.mem_free() // 4 + gc.mem_alloc()) log.info('Collecting garbage') gc.collect() #log.info('Curating the garbage collector finished') log.info('Curating the garbage collector finished. Free memory: %s', gc.mem_free()) def configure_rgb_led(self): """https://docs.pycom.io/tutorials/all/rgbled.html""" if self.platform_info.vendor == self.platform_info.MICROPYTHON.Pycom: import pycom # Enable or disable heartbeat. rgb_led_heartbeat = self.settings.get('main.rgb_led.heartbeat', True) terkin_blink_pattern = self.settings.get('main.rgb_led.terkin', False) if terkin_blink_pattern: rgb_led_heartbeat = False pycom.heartbeat(rgb_led_heartbeat) pycom.heartbeat_on_boot(rgb_led_heartbeat) def blink_led(self, color, count=1): """ :param color: :param count: (Default value = 1) """ if self.platform_info.vendor == self.platform_info.MICROPYTHON.Pycom: import pycom terkin_blink_pattern = self.settings.get('main.rgb_led.terkin', False) if terkin_blink_pattern: for _ in range(count): pycom.rgbled(color) time.sleep(0.15) pycom.rgbled(0x000000) time.sleep(0.10) 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.watchdog.feed() except Exception as ex: log.exc(ex, 'Creating telemetry adapter failed for target: %s', telemetry_target) def create_telemetry_adapter(self, telemetry_target): """ :param 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=''): """ :param item: (Default value = '') """ 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. frequency = machine.freq() / 1000000 add('Device id {}'.format(self.device_id)) add() add('CPU freq {} MHz'.format(frequency)) try: import pycom free_heap = pycom.get_free_heap() add('{:13}{:>7} {}'.format('Free heap', free_heap[0] / 1000.0, 'kB')) add('{:13}{:>7} {}'.format('Free PSRAM', free_heap[1] / 1000.0, 'kB')) except: pass add() # System memory info (in bytes). """ if hasattr(machine, 'info'): 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() # Todo: Add program authors, contributors and credits. log.info('\n' + buffer.getvalue()) def power_off(self): """ """ self.networking.stop() def power_off_lte_modem(self): """ We don't use LTE yet. Important ========= Once the LTE radio is initialized, it must be de-initialized before going to deepsleep in order to ensure minimum power consumption. This is required due to the LTE radio being powered independently and allowing use cases which require the system to be taken out from deepsleep by an event from the LTE network (data or SMS received for instance). Note ==== When using the expansion board and the FiPy together, the RTS/CTS jumpers MUST be removed as those pins are being used by the LTE radio. Keeping those jumpers in place will lead to erratic operation and higher current consumption specially while in deepsleep. -- https://forum.pycom.io/topic/3090/fipy-current-consumption-analysis/17 See also ======== - https://community.hiveeyes.org/t/lte-modem-des-pycom-fipy-komplett-stilllegen/2161 - https://forum.pycom.io/topic/4877/deepsleep-on-batteries/10 """ log.info('Turning off LTE modem') try: import pycom from network import LTE log.info('Turning off LTE modem on boot') pycom.lte_modem_en_on_boot(False) # Disables LTE modem completely. This presumably reduces the power # consumption to the minimum. Call this before entering deepsleep. log.info('Invoking LTE.deinit()') lte = LTE() lte.deinit(detach=False, reset=True) except Exception as ex: log.exc(ex, 'Shutting down LTE modem failed') def power_off_bluetooth(self): """We don't use Bluetooth yet.""" if self.platform_info.vendor == self.platform_info.MICROPYTHON.Vanilla: log.warning( "FIXME: Skip touching Bluetooth on vanilla MicroPython " "platforms as we don't use Bluetooth yet") return log.info('Turning off Bluetooth') try: from network import Bluetooth bluetooth = Bluetooth() bluetooth.deinit() except Exception as ex: log.exc(ex, 'Shutting down Bluetooth failed') def hibernate(self, interval, lightsleep=False, deepsleep=False): """ :param interval: :param lightsleep: (Default value = False) :param deepsleep: (Default value = 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: # Adjust watchdog for interval. self.watchdog.adjust_for_interval(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)) machine.idle() if lightsleep: log.info( 'Entering light sleep for {} seconds'.format(interval)) machine.sleep(int(interval * 1000)) else: # Normal wait. log.info('Waiting for {} seconds'.format(interval)) time.sleep(interval) def resume(self): """ """ try: from terkin.pycom import MachineResetCause log.info('Reset cause and wakeup reason: %s', MachineResetCause().humanize()) except Exception as ex: log.exc(ex, 'Could not determine reset cause and wakeup reason') 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. #log.info('Configuring Pin 4 for wakeup from deep sleep') #machine.pin_sleep_wakeup(pins=['P4'], mode=machine.WAKEUP_ALL_LOW, enable_pull=True) #machine.pin_sleep_wakeup(pins=['P4'], mode=machine.WAKEUP_ANY_HIGH, enable_pull=True) pass
日期:2019.7 作者:01Studio ''' # 导入相关模块 from machine import Pin, I2C, RTC, Timer from ssd1306 import SSD1306_I2C # 定义星期和时间(时分秒)显示字符列表 week = ['Mon', 'Tues', 'Wed', 'Thur', 'Fri', 'Sat', 'Sun'] time_list = ['', '', ''] # 初始化所有相关对象 i2c = I2C(sda=Pin(13), scl=Pin(14)) #I2C初始化:sda--> 13, scl --> 14 oled = SSD1306_I2C(128, 64, i2c, addr=0x3c) rtc = RTC() # 首次上电配置时间,按顺序分别是:年,月,日,星期,时,分,秒,次秒级;这里做了 # 一个简单的判断,检查到当前年份不对就修改当前时间,开发者可以根据自己实际情况来 # 修改。 if rtc.datetime()[0] != 2019: rtc.datetime((2019, 4, 1, 0, 0, 0, 0, 0)) def RTC_Run(tim): datetime = rtc.datetime() # 获取当前时间 oled.fill(0) # 清屏显示黑色背景 oled.text('01Studio', 0, 0) # 首行显示01Studio oled.text('RTC Clock', 0, 15) # 次行显示实验名称
def timezone_correction(hours_to_add): rtc = RTC() ntp_clock = list(rtc.datetime()) # teeme listiks, kuna vaja muuta ntp_clock[4] += hours_to_add rtc.datetime( tuple(ntp_clock)) #uuenda real time clock rtc muudetud kellajaga
def __init__(self, logger_name="LOG"): self.level = _level self.LOGGER_NAME = logger_name self.rtc = RTC()
""" response_500 = """HTTP/1.0 500 INTERNAL SERVER ERROR <h1>500 Internal Server Error</h1> """ response_template = """HTTP/1.0 200 OK %s """ import machine import ntptime, utime from machine import RTC from time import sleep rtc = RTC() try: seconds = ntptime.time() except: seconds = 0 rtc.datetime(utime.localtime(seconds)) def time(): body = """<html> <body> <h1>Time</h1> <p>%s</p> </body> </html> """ % str(rtc.datetime())
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
while not wifi.isconnected() and attempt_count < MAX_ATTEMPTS: attempt_count += 1 sleep_ms(1000) if attempt_count == MAX_ATTEMPTS: print('could not connect to the WiFi network') sys.exit() # set time using NTP server on the internet import ntptime #NTP-time (from pool.ntp.org) import utime ntptime.settime() tm = utime.localtime(utime.mktime(utime.localtime()) + 8 * 3600) tm=tm[0:3] + (0,) + tm[3:6] + (0,) rtc = RTC() rtc.datetime(tm) ContinueOn = True while ContinueOn : getBtn() if pressed (btnL, True) : ContinueOn = False elif pressed(btnA,True) : #LED buttun pressed and released if ledOn : # if led is previously ON, now turn it off by outputing High voltage
sign = (data[2] >> 7) & 1 if sign == 0: return round(temp, 2) return round(-1 * temp, 2) def extractHumidity(data): return data[1] * 0.5 def extractPressure(data): pres = (data[4] << 8) + data[5] + 50000 return pres / 100 sendData.connectLocalBox('/flash/config.json') rtc = RTC() rtc.ntp_sync('fr.pool.ntp.org') bt = Bluetooth() try: bt.start_scan(-1) except: bt.stop_scan() bt.start_scan(-1) while True: try: adv = bt.get_adv() if adv: data = str(adv.data, "utf-8") data = str(data.split("#")[1][:8], "utf-8")
from BME280 import * from CORRECTEUR_PID import * from ODOMETRIE import * from BME280 import * from machine import I2C from machine import SD from machine import RTC from machine import Timer from VL6180X import * import os import time from math import pi import _thread #Ini RTC (year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]) Time_Rtc = RTC() Time_Rtc.init((2019, 11, 16, 15, 14, 0, 0, 0)) #ini carte sd sd = SD() os.mount(sd, "/sd") f = open("/sd/test.csv", "w") f.write( "heure; minute; seconde; x; y ; angle; temperature; humidite; pression; luminosite; Distance;\r\n" ) f.close() #ini Bus I2c bus_i2c = I2C() bus_i2c.init(I2C.MASTER, baudrate=400000)
from machine import Pin, Timer, PWM, RTC, ADC from time import sleep button = Pin(34, Pin.IN) year = int(input("Year? ")) month = int(input("Month? ")) day = int(input("Day? ")) weekday = int(input("Weekday? ")) hour = int(input("Hour? ")) minute = int(input("Minute? ")) second = int(input("Second? ")) microsecond = int(input("Microsecond? ")) rtc = RTC() rtc.datetime((year, month, day, weekday, hour, minute, second, microsecond)) adc = ADC(Pin(36)) adc.atten(ADC.ATTN_11DB) tim0 = Timer(0) week = [ "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" ] tim0.init(period=30000, mode=Timer.PERIODIC, callback=lambda t: display()) tim1 = Timer(1) tim1.init(period=100, mode=Timer.PERIODIC, callback=lambda t: choice()) pwm0 = PWM(Pin(16), freq=10, duty=256) pwm1 = PWM(Pin(17), freq=10, duty=256) mode = 0 prev = 0
def Try_Start(): try: tim = Timer(1) tim.init(period=500, mode=Timer.PERIODIC, callback=lambda t: Display_Time()) except: rtc.datetime(Get_Time()) tim.deinit() Try_Start() if __name__ == '__main__': n = 100 pin = Pin(13, Pin.OUT) np = NeoPixel(pin, n) (Hours1_1, Hours1_2, Hours2_1, Hours2_2) = (0, 0, 0, 0) (Mints1_1, Mints1_2, Mints2_1, Mints2_2) = (0, 0, 0, 0) Secos1 = 0 Secos2 = 0 #RGB = (255,20,147) #Np_List = [] rtc = RTC() rtc.datetime(Get_Time()) Try_Start()
# Init wifi # print("Initializing WiFi") SSID = '' KEY = '' wlan = WLAN(mode=WLAN.STA) nets = wlan.scan() for net in nets: if net.ssid == SSID: print('Network found!') wlan.connect(net.ssid, auth=(net.sec, KEY), timeout=5000) while not wlan.isconnected(): machine.idle() # save power while waiting print('WLAN connection succeeded!') print(wlan.ifconfig() ) # Print the connection settings, IP, Subnet mask, Gateway, DNS break # # Setup the time of the device # print("Initializing NTP time server") rtc = RTC() rtc.ntp_sync("pool.ntp.org") # Sync with time server uart = UART(0, baudrate=115200) os.dupterm(uart) print("Start executing main.py") machine.main('main.py')
#1. 测试button 和 pause() 2.是否可以正确跳出循环 from machine import RTC, Pin, I2C, SPI from time import sleep import ssd1306 rtc = RTC() rtc.datetime((2019, 9, 25, 4, 16, 5, 0, 0)) rtc.datetime() # init button button_A = Pin(12, Pin.IN, Pin.PULL_UP) button_B = Pin(13, Pin.IN) button_C = Pin(14, Pin.IN, Pin.PULL_UP) # counter indicates the current operate element in datetime counter = 0 # construct an I2C bus in LED i2c = I2C(-1, Pin(5), Pin(4)) oled = ssd1306.SSD1306_I2C(128, 32, i2c) # write and show real time def week(n_week): if (n_week == 1): return 'Monday' elif (n_week == 2): return 'Tuesday' elif (n_week == 3): return 'Wednesday' elif (n_week == 4): return 'Thursday' elif (n_week == 5): return 'Friday' elif (n_week == 6): return 'Saturday' elif (n_week == 7): return 'Sunday' return 'Monday'
# MicroPython for the IOT - Chapter 5 # Example use of the utime library # Note: This example only works on the WiPy # Note: This example will not on your PC. import machine import sys import utime # Since we don't have a RTC, we have to set the current time # initialized the RTC in the WiPy machine library from machine import RTC # Init with default time and date rtc = RTC() # Init with a specific time and date. We use a specific # datetime, but we could get this from a network time # service. rtc = RTC(datetime=(2017, 7, 15, 21, 32, 11, 0, None)) # Get a random number from 0-1 from a 2^24 bit random value def get_rand(): return machine.rng() / (2**24 - 1) # Format the time (epoch) for a better view def format_time(tm_data): # Use a special shortcut to unpack tuple: *tm_data return "{0}-{1:0>2}-{2:0>2} {3:0>2}:{4:0>2}:{5:0>2}".format(*tm_data)
# main.py -- put your code here! import pycom import time import sendData from machine import RTC pycom.heartbeat(False) try: sendData.connectLocalBox('/flash/config.json') rtc = RTC() rtc.ntp_sync('fr.pool.ntp.org') pycom.rgbled(0x00FF00) time.sleep(0.2) pycom.rgbled(0) time.sleep(0.2) pycom.rgbled(0x00FF00) time.sleep(0.2) pycom.rgbled(0) except Exception as e: print(e) pycom.rgbled(0xFF0000) time.sleep(0.2) pycom.rgbled(0) time.sleep(0.2) pycom.rgbled(0xFF0000) time.sleep(0.2) pycom.rgbled(0)
def test_lte_ntp(hw, max_drift_secs=4): _logger.info("Starting LTE test...") pycom_util.reset_rgbled() global failures _logger.info("Testing LTE connectivity...") chrono = machine.Timer.Chrono() chrono.start() with CheckStep(FLAG_SD_CARD, suppress_exception=True): hw.mount_sd_card() ou_id = None cc = None cs = None with CheckStep(FLAG_COMM_CONFIG, suppress_exception=True): import os import co2unit_comm os.chdir(hw.SDCARD_MOUNT_POINT) ou_id, cc, cs = co2unit_comm.read_comm_config(hw) with CheckStep(FLAG_TIME_SOURCE, suppress_exception=True): hw.sync_to_most_reliable_rtc() lte = None signal_quality = None try: with CheckStep(FLAG_LTE_FW_API): from network import LTE with CheckStep(FLAG_LTE_INIT): # _logger.info("Give LTE a moment to boot") # LTE init seems to be successful more often if we give it time first # time.sleep_ms(1000) # wdt.feed() _logger.info("Init LTE...") chrono.reset() pycom.nvs_set("lte_on", True) lte = LTE() _logger.info("LTE init ok (%d ms)", chrono.read_ms()) except: return failures try: with CheckStep(FLAG_LTE_ATTACH): _logger.info("LTE attaching... (up to 2 minutes)") chrono.reset() lte.attach() try: while True: wdt.feed() if lte.isattached(): break if chrono.read_ms() > 150 * 1000: raise TimeoutError("Timeout during LTE attach") time.sleep_ms(50) finally: signal_quality = pycom_util.lte_signal_quality(lte) _logger.info("Signal quality: %s", signal_quality) import co2unit_errors co2unit_errors.info( hw, "Self-test. LTE attached: {}. Signal quality {}".format( lte.isattached(), signal_quality)) _logger.info("LTE attach ok (%d ms). Connecting...", chrono.read_ms()) if signal_quality["rssi_raw"] in range(0, 31): led_show_scalar(signal_quality["rssi_raw"], [0, 31]) with CheckStep(FLAG_LTE_CONNECT): chrono.reset() lte.connect() while True: wdt.feed() if lte.isconnected(): break if chrono.read_ms() > 120 * 1000: raise TimeoutError("Timeout during LTE connect") time.sleep_ms(50) _logger.info("LTE connect ok (%d ms)", chrono.read_ms()) with CheckStep(FLAG_COMM_PING, suppress_exception=True): import co2unit_comm for sync_dest in cc.sync_dest: co2unit_comm.send_alive_ping(sync_dest, ou_id, cc, cs) wdt.feed() with CheckStep(FLAG_NTP_FETCH, suppress_exception=True): from machine import RTC import timeutil chrono.reset() irtc = RTC() ts = timeutil.fetch_ntp_time(cc.ntp_host if cc else None) idrift = ts - time.mktime(irtc.now()) if abs(idrift) < max_drift_secs: _logger.info("Drift from NTP: %s s; within threshold (%d s)", idrift, max_drift_secs) else: ntp_tuple = time.gmtime(ts) irtc = RTC() irtc.init(ntp_tuple) hw.ertc.save_time() _logger.info("RTC set from NTP %s; drift was %d s", ntp_tuple, idrift) failures &= ~FLAG_TIME_SOURCE # Clear FLAG_TIME_SOURCE if previously set _logger.info("Got time with NTP (%d ms). Shutting down...", chrono.read_ms()) wdt.feed() with CheckStep(FLAG_LTE_SHUTDOWN): if lte: try: if lte.isconnected(): chrono.reset() lte.disconnect() _logger.info("LTE disconnected (%d ms)", chrono.read_ms()) wdt.feed() if lte.isattached(): chrono.reset() lte.dettach() _logger.info("LTE detached (%d ms)", chrono.read_ms()) wdt.feed() finally: chrono.reset() lte.deinit() pycom.nvs_set("lte_on", False) _logger.info("LTE deinit-ed (%d ms)", chrono.read_ms()) wdt.feed() except: pass show_boot_flags() _logger.info("Failures after LTE test: 0x%04x", failures) display_errors_led() if signal_quality and signal_quality["rssi_raw"] in range(0, 32): led_show_scalar(signal_quality["rssi_raw"], [0, 31]) pycom.rgbled(0x0)
print(os.getcwd()) # create a new file f = open('test.txt', 'w') n_w = f.write(test_bytes) print(n_w == len(test_bytes)) f.close() f = open('test.txt', 'r') r = bytes(f.read(), 'ascii') # check that we can write and read it correctly print(r == test_bytes) f.close() os.remove('test.txt') os.chdir('..') os.rmdir('test') ls = os.listdir() print('test' not in ls) print(ls) # test the real time clock rtc = RTC() while rtc.now()[6] > 800: pass time1 = rtc.now() time.sleep_ms(1000) time2 = rtc.now() print(time2[5] - time1[5] == 1) print(time2[6] - time1[6] < 5000) # microseconds
ax, ay, az, gx, gy, gz = imu.read_accelerometer_gyro_data() oled.text('Gyroscope:', 25, 35) oled.text(str(gx), 25, 45) return gx p19 = Pin(19, Pin.IN) p18 = Pin(18, Pin.OUT) p19.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt) i2c = I2C(-1, scl=Pin(21), sda=Pin(22)) #sets I2C bus at pins 22 and 21 oled_width = 128 oled_height = 64 oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c) #oled object of class SSD1306 rtc = RTC() rtc.datetime((2019, 1, 1, 0, 11, 20, 0, 0)) #2019 January first zero hours zero seconds ect imu = ICM20948() while True: if button: print('interrupt') p18.on() sdelay(3) p18.off() button = False print_time() gx = print_Gyro() oled.show()
def getTemperature(): global ADC_PIN_TMP36 global T_MAX_MV global V_TO_MV global ADC_MAX_VAL global PRECISION_SCALE global OFFSET_MV global SCALE_FACTOR adc_tmp36 = ADC(0) apin_tmp36 = adc_tmp36.channel(pin=ADC_PIN_TMP36) rawTemp = 0 for x in range(0, 100): adc_value = apin_tmp36.value() # read value (0~1024) then converted in mV then scaled to get more precision tMV = adc_value * (T_MAX_MV / ADC_MAX_VAL)* PRECISION_SCALE # convert th mV received to temperature rawTemp += (tMV - OFFSET_MV) / 10 return (rawTemp/100) rtc = RTC() rtc.ntp_sync('fr.pool.ntp.org') sendData.connectLocalBox() while 1==1: data = '{"temperature": %s, "timestamp": "%s", "battery" : %s}' % (getTemperature(),rtc.now(), readBatteryVoltage.readBatteryLevel()) sendData.sendData(host='http://192.168.1.15', port=1338, data=data) time.sleep(300)
''' RTC test for the CC3200 based boards. ''' from machine import RTC import os import time mch = os.uname().machine if not 'LaunchPad' in mch and not 'WiPy' in mch: raise Exception('Board not supported!') rtc = RTC() print(rtc) print(rtc.now()[:6]) rtc = RTC(datetime=(2015, 8, 29, 9, 0, 0, 0, None)) print(rtc.now()[:6]) rtc.deinit() print(rtc.now()[:6]) rtc.init((2015, 8, 29, 9, 0, 0, 0, None)) print(rtc.now()[:6]) seconds = rtc.now()[5] time.sleep_ms(1000) print(rtc.now()[5] - seconds == 1) seconds = rtc.now()[5] time.sleep_ms(2000) print(rtc.now()[5] - seconds == 2)