async def main():
# Create a lock and acquire it so the tasks below must wait
lock = asyncio.Lock()
await lock.acquire()
lock_flag = [True]
# Create 4 tasks and let them all run
t0 = asyncio.create_task(task(0, lock, lock_flag))
t1 = asyncio.create_task(task(1, lock, lock_flag))
t2 = asyncio.create_task(task(2, lock, lock_flag))
t3 = asyncio.create_task(task(3, lock, lock_flag))
await asyncio.sleep(0)
# Cancel 2 of the tasks (which are waiting on the lock) and release the lock
t1.cancel()
t2.cancel()
lock.release()
lock_flag[0] = False
# Let the tasks run to completion
for _ in range(4):
await asyncio.sleep(0)
# The locke should be unlocked
print(lock.locked())
def __init__(self,
spi,
cs,
dc,
rst,
height=240,
width=240,
disp_mode=LANDSCAPE,
init_spi=False,
display=GENERIC):
if not 0 <= disp_mode <= 7:
raise ValueError('Invalid display mode:', disp_mode)
if not display in (GENERIC, TDISPLAY):
raise ValueError('Invalid display type.')
self._spi = spi # Clock cycle time for write 16ns 62.5MHz max (read is 150ns)
self._rst = rst # Pins
self._dc = dc
self._cs = cs
self.height = height # Required by Writer class
self.width = width
self._offset = display[:2] # display arg is (x, y, orientation)
orientation = display[2] # where x, y is the RAM offset
self._spi_init = init_spi # Possible user callback
self._lock = asyncio.Lock()
mode = framebuf.GS4_HMSB # Use 4bit greyscale.
self.palette = BoolPalette(mode)
gc.collect()
buf = bytearray(height *
-(-width // 2)) # Ceiling division for odd widths
self._mvb = memoryview(buf)
super().__init__(buf, width, height, mode)
self._linebuf = bytearray(self.width * 2) # 16 bit color out
self._init(disp_mode, orientation)
self.show()
def __init__(self,
uart,
lock=None,
set_pin=None,
reset_pin=None,
interval_passive_mode=None,
event=None,
active_mode=True,
eco_mode=True,
assume_sleeping=True):
self._uart = uart # accepts a uart object
self._set_pin = set_pin
if set_pin is not None:
set_pin.value(1)
self._reset_pin = reset_pin
if reset_pin is not None:
reset_pin.value(1)
self._active = True
self._active_mode = active_mode # passive mode will be set on first wakeUp() in _read()
self._eco_mode = eco_mode # only works with passive mode as sleep is not possible in active_mode
self._sreader = asyncio.StreamReader(uart)
self._interval_passive_mode = interval_passive_mode or 60 # in case someone forgets to set it
if self._eco_mode and self._active_mode is False and self._interval_passive_mode < WAIT_AFTER_WAKEUP + 5:
self._error(
"interval_passive_mode can't be less than DEVICE_WAKEUP_TIME of {!s}s"
.format(WAIT_AFTER_WAKEUP + 5))
self._interval_passive_mode = 60
self._event = event
self._lock = asyncio.Lock()
self._timestamp = None
self._sleeping_state = assume_sleeping # assume sleeping on start by default
self._invalidateMeasurements()
self._callback = None # can be a short coroutine too; no args given
asyncio.create_task(self._read())
def __init__(self,
client_id,
server,
port=1883,
user=None,
password=None,
keepalive=0):
self.client_id = client_id
self.reader = None
self.writer = None
self.server = server
self.port = port
self.user = user
self.pswd = password
self.keepalive = keepalive
self.socket_timeout = 3
self.lw_topic = None
self.lw_msg = None
self.lw_qos = 0
self.lw_retain = False
self.connected = False
self.lock = asyncio.Lock()
def __init__(self,
client_id=None,
broker=None,
port=DEFAULT_TCP_PORT,
user=None,
password=None,
keep_alive=DEFAULT_KEEP_ALIVE,
debug=False):
# Client
self.is_connected = False
self.first_connection = False
if client_id == None:
import random
self.client_id = "umqtt_async/" + str(random.randint(1, 1000))
else:
self.client_id = client_id
if broker == None:
raise ValueError("Missing Broker information.")
self.broker = broker
self.port = port
self.user = user
self.password = password
self.keep_alive = keep_alive
self.debug = debug
# SSL
self.ssl = False
self.certs = {}
# LWT
self.lw_topic = None
self.lw_msg = None
self.lw_qos = DEFAULT_QOS
self.lw_retain = False
# Messages and Topics
self.pid = 0
self.unack_pid = []
self.last_message_sent = 0
self.last_message_received = 0
self.topics = []
self.resend_attempts = 2
# Callbacks
self.on_message_cb = None
self.on_connection_cb = None
self.on_disconnect_cb = None
self.on_publish_cb = None
self.on_subscribe_cb = None
self.on_unsubscribe_cb = None
# Async
self.reader = None
self.writer = None
self.lock = asyncio.Lock()
self.loop = asyncio.get_event_loop()
# Allows Network status to be passed to client.
self.network_status = False
def __init__(self, tcp_server):
self.tcp_server = tcp_server
self.i2c = I2C(0, scl=Pin(18), sda=Pin(19),
freq=100000) #For hardware I2C
#i2c = SoftI2C(scl=Pin(18), sda=Pin(19), freq=5000, timeout=255) #For software I2C
self.i2c_lock = uasyncio.Lock()
self.lidar = I2C_lidar(self)
self.drivetrain = I2C_drivetrain(self)
uasyncio.create_task(self.i2c_master_routine())
uasyncio.create_task(self.i2c_drivetrain_routine())
def __init__(self, store_path="u_config"):
_sch_name = "_schema"
_sch_conf = OrderedDict([
("name", ("str", "")),
("sch", ("dict", ())),
])
self.store = uorm.Store(store_schema=_sch_name, store_path=store_path, store_config=_sch_conf)
self.lock = asyncio.Lock()
async def lock_file(file_name):
global file_locks
try:
print('lock', file_name)
if file_name not in file_locks.keys():
file_locks[file_name] = uasyncio.Lock()
print('wait for', file_name)
await file_locks[file_name].acquire()
print('locked', file_name)
except Exception as err:
print(err)
def __init__(self, subs_cb, puback_cb, suback_cb, pingresp_cb, sock_cb=None):
# Store init params
self._subs_cb = subs_cb
self._puback_cb = puback_cb
self._suback_cb = suback_cb
self._pingresp_cb = pingresp_cb
self._sock_cb = sock_cb
# Init key instance vars
self._sock = None
self._lock = asyncio.Lock()
self.last_ack = 0 # last ACK received from broker
self._read_buf = b""
async def run_message_test():
print('Test Lock class')
lock = asyncio.Lock()
asyncio.create_task(run_lock(1, lock))
asyncio.create_task(run_lock(2, lock))
asyncio.create_task(run_lock(3, lock))
print('Test Message class')
message = Message()
asyncio.create_task(messageset(message))
await messagewait(message) # run_message_test runs fast until this point
print('Message status {}'.format('Incorrect' if message.is_set() else 'OK'))
print('Tasks complete')
async def main():
lock = asyncio.Lock()
# Basic acquire/release
print(lock.locked())
await lock.acquire()
print(lock.locked())
await asyncio.sleep(0)
lock.release()
print(lock.locked())
await asyncio.sleep(0)
# Use with "async with"
async with lock:
print("have lock")
# 3 tasks wanting the lock
print("----")
asyncio.create_task(task_loop(1, lock))
asyncio.create_task(task_loop(2, lock))
t3 = asyncio.create_task(task_loop(3, lock))
await lock.acquire()
await asyncio.sleep(0)
lock.release()
await t3
# 2 sleeping tasks both wanting the lock
print("----")
asyncio.create_task(task_sleep(lock))
await asyncio.sleep(0.1)
await task_sleep(lock)
# 3 tasks, the first cancelling the second, the third should still run
print("----")
ts = [None]
asyncio.create_task(task_cancel(0, lock, ts))
ts[0] = asyncio.create_task(task_cancel(1, lock))
asyncio.create_task(task_cancel(2, lock))
await asyncio.sleep(0.3)
print(lock.locked())
# 3 tasks, the second and third being cancelled while waiting on the lock
print("----")
t0 = asyncio.create_task(task_cancel(0, lock))
t1 = asyncio.create_task(task_cancel(1, lock))
t2 = asyncio.create_task(task_cancel(2, lock))
await asyncio.sleep(0.05)
t1.cancel()
await asyncio.sleep(0.1)
t2.cancel()
await asyncio.sleep(0.1)
print(lock.locked())
async def Get(self, aIDs: list = []) -> list:
R = []
if (not aIDs):
#Roms = W1.scan() # hangs if no devices
aIDs = self.Obj.scan()
async with asyncio.Lock():
self.Obj.convert_temp()
await asyncio.sleep_ms(750)
for ID in aIDs:
Value = self.Obj.read_temp(ID)
R.append({'id':ID, 'value':Value})
return R
def __init__(self, conn_id, config, hardware, verbose):
self.verbose = verbose
self.initial = True
self._status = False # Server status
self.wlock = asyncio.Lock()
self.rxmsg = Message() # rx data ready
self.tim_boot = Delay_ms(func=self.reboot)
config.insert(0, conn_id)
config.append('cfg') # Marker defines a config list
self.cfg = ''.join((ujson.dumps(config), '\n'))
i2c, syn, ack, rst = hardware
self.chan = asi2c_i.Initiator(i2c, syn, ack, rst, verbose, self._go, (), self.reboot)
self.sreader = asyncio.StreamReader(self.chan)
self.swriter = asyncio.StreamWriter(self.chan, {})
self.lqueue = [] # Outstanding lines
def __init__(self, command_topic, state_topic, timeout=_TIMEOUT, **kwargs):
global _unit_index
_unit_index += 1
super().__init__(COMPONENT_NAME,
__version__,
_unit_index,
discover=False,
**kwargs)
self._state = False
self._topic = command_topic
self._state_topic = state_topic
self.lock = asyncio.Lock()
# in case switch activates a device that will need a while to finish
self._state_time = 0
self._timeout = timeout
_mqtt.subscribeSync(self._state_topic, self.on_message, self)
def __init__(self, client_id, server, port, user, password, keepalive,
ping_interval, ssl, ssl_params, response_time, clean_init,
clean, max_repubs, will, subs_cb, wifi_coro, connect_coro,
ssid, wifi_pw):
# MQTT config
self.ping_interval = ping_interval
self._client_id = client_id
self._user = user
self._pswd = password
self._keepalive = keepalive
if self._keepalive >= 65536:
raise ValueError('invalid keepalive time')
self._response_time = response_time * 1000 # Repub if no PUBACK received (ms).
self._max_repubs = max_repubs
self._clean_init = clean_init # clean_session state on first connection
self._clean = clean # clean_session state on reconnect
if will is None:
self._lw_topic = False
else:
self._set_last_will(*will)
# WiFi config
self._ssid = ssid # Required ESP32 / Pyboard D
self._wifi_pw = wifi_pw
self._ssl = ssl
self._ssl_params = ssl_params
# Callbacks and coros
self._cb = subs_cb
self._wifi_handler = wifi_coro
self._connect_handler = connect_coro
# Network
self.port = port
if self.port == 0:
self.port = 8883 if self._ssl else 1883
self.server = server
if self.server is None:
raise ValueError('no server specified.')
self._sock = None
if LINUX is True:
self._sta_isconnected = True
else:
self._sta_if = network.WLAN(network.STA_IF)
self._sta_if.active(True)
self.newpid = pid_gen()
self.rcv_pids = set() # PUBACK and SUBACK pids awaiting ACK response
self.last_rx = ticks_ms() # Time of last communication from broker
self.lock = asyncio.Lock()
def __init__(self, spi, cs, dc, rst, height=240, width=240, disp_mode=0, init_spi=False):
self._spi = spi # Clock cycle time for write 16ns 62.5MHz max (read is 150ns)
self._rst = rst # Pins
self._dc = dc
self._cs = cs
self.height = height # Required by Writer class
self.width = width
self._spi_init = init_spi # Possible user callback
self._lock = asyncio.Lock()
mode = framebuf.GS4_HMSB # Use 4bit greyscale.
gc.collect()
buf = bytearray(height * width // 2)
self._mvb = memoryview(buf)
super().__init__(buf, width, height, mode)
self._linebuf = bytearray(self.width * 2) # 16 bit color out
self._init(disp_mode)
self.show()
def __init__(self, config):
# MQTT config
self._client_id = config['client_id']
self._user = config['user']
self._pswd = config['password']
self._keepalive = config['keepalive']
if self._keepalive >= 65536:
raise ValueError('invalid keepalive time')
self._response_time = config[
'response_time'] * 1000 # Repub if no PUBACK received (ms).
self._max_repubs = config['max_repubs']
self._clean_init = config[
'clean_init'] # clean_session state on first connection
self._clean = config['clean'] # clean_session state on reconnect
will = config['will']
if will is None:
self._lw_topic = False
else:
self._set_last_will(*will)
# WiFi config
self._ssid = config[
'ssid'] # Required for ESP32 / Pyboard D. Optional ESP8266
self._wifi_pw = config['wifi_pw']
self._ssl = config['ssl']
self._ssl_params = config['ssl_params']
# Callbacks and coros
self._cb = config['subs_cb']
self._wifi_handler = config['wifi_coro']
self._connect_handler = config['connect_coro']
# Network
self.port = config['port']
if self.port == 0:
self.port = 8883 if self._ssl else 1883
self.server = config['server']
if self.server is None:
raise ValueError('no server specified.')
self._sock = None
self._sta_if = network.WLAN(network.STA_IF)
self._sta_if.active(True)
self._sta_if.config(dhcp_hostname=config['hostname'])
self.newpid = pid_gen()
self.rcv_pids = set() # PUBACK and SUBACK pids awaiting ACK response
self.last_rx = ticks_ms() # Time of last communication from broker
self.lock = asyncio.Lock()
def __init__(self, *args, **kwargs):
d = defaults # d is the config dict: initially populate with default values
for arg in args:
d.update(arg) # Hardware and network configs
d.update(kwargs)
# d is now populated.
self.user_start = d['user_start']
shan = d['status_handler']
self.s_han = (default_status_handler, ()) if shan is None else shan # coro
self.crash_han = d['crash_handler']
self.wifi_han = d['wifi_handler']
self.init_str = buildinit(d)
self.keepalive = d['keepalive']
self._evtrun = asyncio.Event()
self.verbose = d['verbose']
# Watchdog timeout for ESP8266 (ms).
wdog = d['timeout'] * 1000
# SynCom string mode
self.channel = SynCom(False, d['sckin'], d['sckout'], d['srx'], d['stx'],
d['reset'], wdog, True, self.verbose)
if 'led' in d:
asyncio.create_task(heartbeat(d['led']))
# Start the SynCom instance. This will run self.start(). If an error
# occurs self.quit() is called which returns to Syncom's start() method.
# This waits on ._die before forcing a failure on the ESP8266 and re-running
# self.start() to perform a clean restart.
asyncio.create_task(self.channel.start(self.start, self._die))
self.subs = {} # (callback, qos, args) indexed by topic
self.publock = asyncio.Lock()
self.puback = asyncio.Event()
self.evttim = asyncio.Event()
self.evtwifi = asyncio.Event()
# Only specify network on first run
self.first_run = True
self._time = 0 # NTP time. Invalid.
# ESP8266 returns seconds from 2000 because I believed the docs.
# Maintainers change the epoch on a whim.
# Calculate ofsets in CPython using datetime.date:
# (date(2000, 1, 1) - date(1970, 1, 1)).days * 24*60*60
epoch = {2000 : 0, 1970 : 946684800} # Offset to add.
self._epoch_fix = epoch[gmtime(0)[0]] # Find offset on current platform
def __init__(self,
component_name,
version,
unit_index: int,
mqtt_topic: str = None,
instance_name=None,
wait_for_lock=True,
restore_state=True,
friendly_name=None,
initial_state=None,
**kwargs):
"""
:param mqtt_topic: topic of subclass which controls the switch state. optional. If not ending with "/set", it will be added as the command_topic is being stored.
:param instance_name: name of the instance. If not provided will get composed of component_name<count>
:param wait_for_lock: if True then every request waits for the lock to become available,
:param restore_state: restore the retained state topic state
meaning the previous device request has to finish before the new one is started.
Otherwise the new one will get ignored.
:param friendly_name: friendly name for homeassistant gui
:param initial_state: intitial state of the switch. By default unknown so first state change request will set initial state.
"""
super().__init__(component_name, version, unit_index, **kwargs)
self._state = initial_state # initial state is unknown if None
if mqtt_topic and not mqtt_topic.endswith("/set"):
mqtt_topic = "{}{}".format(mqtt_topic, "/set")
self._topic = mqtt_topic or _mqtt.getDeviceTopic("{!s}{!s}/set".format(
component_name, self._count))
_mqtt.subscribeSync(self._topic,
self.on_message,
self,
check_retained_state=restore_state)
self._lock = asyncio.Lock()
# in case switch activates a device that will need a while to finish
self._wfl = wait_for_lock
self._name = instance_name
self._event = None
self._frn = friendly_name
self._pub_task = None
gc.collect()
def __init__(self, aPin: int):
self.Obj = Pin(aPin, Pin.OUT)
self.Lock = asyncio.Lock()
def __init__(self,
spi,
cs,
dc,
rst,
height=240,
width=320,
usd=False,
init_spi=False):
self._spi = spi
self._cs = cs
self._dc = dc
self._rst = rst
self.height = height
self.width = width
self._spi_init = init_spi
mode = framebuf.GS4_HMSB
self.palette = BoolPalette(mode)
gc.collect()
buf = bytearray(self.height * self.width // 2)
self._mvb = memoryview(buf)
super().__init__(buf, self.width, self.height, mode)
self._linebuf = bytearray(self.width * 2)
# Hardware reset
self._rst(0)
sleep_ms(50)
self._rst(1)
sleep_ms(50)
if self._spi_init: # A callback was passed
self._spi_init(spi) # Bus may be shared
self._lock = asyncio.Lock()
# Send initialization commands
self._wcmd(b'\x01') # SWRESET Software reset
sleep_ms(100)
self._wcd(b'\xcf', b'\x00\xC1\x30') # PWCTRB Pwr ctrl B
self._wcd(b'\xed', b'\x64\x03\x12\x81') # POSC Pwr on seq. ctrl
self._wcd(b'\xe8', b'\x85\x00\x78') # DTCA Driver timing ctrl A
self._wcd(b'\xcb', b'\x39\x2C\x00\x34\x02') # PWCTRA Pwr ctrl A
self._wcd(b'\xf7', b'\x20') # PUMPRC Pump ratio control
self._wcd(b'\xea', b'\x00\x00') # DTCB Driver timing ctrl B
self._wcd(b'\xc0', b'\x23') # PWCTR1 Pwr ctrl 1
self._wcd(b'\xc1', b'\x10') # PWCTR2 Pwr ctrl 2
self._wcd(b'\xc5', b'\x3E\x28') # VMCTR1 VCOM ctrl 1
self._wcd(b'\xc7', b'\x86') # VMCTR2 VCOM ctrl 2
# (b'\x88', b'\xe8', b'\x48', b'\x28')[rotation // 90]
if self.height > self.width:
self._wcd(b'\x36',
b'\x48' if usd else b'\x88') # MADCTL: RGB portrait mode
else:
self._wcd(
b'\x36',
b'\x28' if usd else b'\xe8') # MADCTL: RGB landscape mode
self._wcd(b'\x37',
b'\x00') # VSCRSADD Vertical scrolling start address
self._wcd(
b'\x3a',
b'\x55') # PIXFMT COLMOD: Pixel format 16 bits (MCU & interface)
self._wcd(b'\xb1', b'\x00\x18') # FRMCTR1 Frame rate ctrl
self._wcd(b'\xb6', b'\x08\x82\x27') # DFUNCTR
self._wcd(b'\xf2', b'\x00') # ENABLE3G Enable 3 gamma ctrl
self._wcd(b'\x26', b'\x01') # GAMMASET Gamma curve selected
self._wcd(
b'\xe0',
b'\x0F\x31\x2B\x0C\x0E\x08\x4E\xF1\x37\x07\x10\x03\x0E\x09\x00'
) # GMCTRP1
self._wcd(
b'\xe1',
b'\x00\x0E\x14\x03\x11\x07\x31\xC1\x48\x08\x0F\x0C\x31\x36\x0F'
) # GMCTRN1
self._wcmd(b'\x11') # SLPOUT Exit sleep
sleep_ms(100)
self._wcmd(b'\x29') # DISPLAY_ON
sleep_ms(100)
def __init__(self,
my_id,
server,
port=8123,
ssid='',
pw='',
timeout=2000,
conn_cb=None,
conn_cb_args=None,
verbose=False,
led=None,
wdog=False):
self._my_id = '{}{}'.format(my_id, '\n') # Ensure >= 1 newline
self._server = server
self._ssid = ssid
self._pw = pw
self._port = port
self._to = timeout # Client and server timeout
self._tim_ka = timeout // 4 # Keepalive interval
self._concb = conn_cb
self._concbargs = () if conn_cb_args is None else conn_cb_args
self._verbose = verbose
self._led = led
if wdog:
if platform == 'pyboard':
self._wdt = machine.WDT(0, 20000)
def wdt():
def inner(feed=0): # Ignore control values
if not feed:
self._wdt.feed()
return inner
self._feed = wdt()
else:
def wdt(secs=0):
timer = machine.Timer(-1)
timer.init(period=1000,
mode=machine.Timer.PERIODIC,
callback=lambda t: self._feed())
cnt = secs
run = False # Disable until 1st feed
def inner(feed=WDT_CB):
nonlocal cnt, run, timer
if feed == 0: # Fixed timeout
cnt = secs
run = True
elif feed < 0: # WDT control/callback
if feed == WDT_CANCEL:
timer.deinit() # Permanent cancellation
elif feed == WDT_CB and run: # Timer callback and is running.
cnt -= 1
if cnt <= 0:
machine.reset()
return inner
self._feed = wdt(20)
else:
self._feed = lambda x: None
self._sta_if = network.WLAN(network.STA_IF)
ap = network.WLAN(network.AP_IF) # create access-point interface
ap.active(False) # deactivate the interface
self._sta_if.active(True)
gc.collect()
if platform == 'esp8266':
import esp
# Improve connection integrity at cost of power consumption.
esp.sleep_type(esp.SLEEP_NONE)
self._evfail = asyncio.Event() # Set by any comms failure
self._evok = asyncio.Event() # Set by 1st successful read
self._s_lock = asyncio.Lock() # For internal send conflict.
self._w_lock = asyncio.Lock() # For .write rate limit
self._last_wr = utime.ticks_ms()
self._lineq = Queue(20) # 20 entries
self.connects = 0 # Connect count for test purposes/app access
self._sock = None
self._acks_pend = ASetByte() # ACKs which are expected to be received
gc.collect()
asyncio.create_task(self._run())
# MIT license; Copyright (c) 2020 Andrea Corbo
import uasyncio as asyncio
from primitives.message import Message
from primitives.semaphore import Semaphore
from primitives.queue import Queue
import time
import os
import json
import _thread
import pyb
from configs import dfl, cfg
logger = True # Prints out messages.
f_lock = asyncio.Lock() # Data file lock.
alert = Message() # Sms message.
trigger = Message()
timesync = asyncio.Event() # Gps fix event.
scheduling = asyncio.Event() # Scheduler event.
disconnect = asyncio.Event() # Modem event.
u2_lock = asyncio.Lock() # Uart 2 lock.
u4_lock = asyncio.Lock() # Uart 4 lock.
def welcome_msg():
print(
'{:#^80}\n\r#{: ^78}#\n\r#{: ^78}#\n\r# {: <20}{: <57}#\n\r# {: <20}{: <57}#\n\r# {: <20}{: <57}#\n\r# {: <20}{: <57}#\n\r{:#^80}'.format(
'',
'WELCOME TO ' + cfg.HOSTNAME + ' ' + dfl.SW_NAME + ' ' + dfl.SW_VERSION,
'',
' current time:',
import uasyncio #uasyncio ermöglicht eine gleichzeitige bearbeitung der Messungen und die Daten zu stören
import uarray #uarray ist das Feld in Micropython
import pyb #pyb ist das Modul des Pyboards die das Zugreifen der verschiedenen Pins des Pyboards ermöglich
locker = uasyncio.Lock() #schließt und öffnet Teilprogrammen
total_measurements = 20 #Anzahl der gesamten Messungen
schon_gemessen = 0 #Anzahl der schon gemessene Messungen
async def empfanger(port): #Verbindung mit dem Komputer
global total_measurements
global schon_gemessen
swriter = uasyncio.StreamWriter(port)
sreader = uasyncio.StreamReader(port)
#Unendliche Schleife, damit dem Komputer ständig mit dem Pyboard im Verbindung steht und dass mit einem Break abgebrochen wird
while True:
await locker.acquire() #das Einzige Teilprogramm das läuft die anderen Teilprogrammen sind gesperrt
befehl = await sreader.readline() #empfangt ein Befehl von dem Komputer
befehl_ = str(befehl).replace("\\r\\n'", "") #Bearbeitung des Befehls
if befehl_ == "b'zeigeMeasurments":
await swriter.awrite("ShowMeasurements\r\n") #send dem Komputer ein Befehl, um ihn die förden, die gemessenen Daten zu zeigen
await swriter.awrite("end\r\n")
if schon_gemessen == total_measurements :
await swriter.awrite("endeMessungen\r\n") #send dem Komputer ein Befehl, um ihn die förden, das Programm zu beenden
break
locker.release() #ermöglicht den anderen Teilprogrammen weiter zu laufen
await uasyncio.sleep(1)
__hour = 7
__minute = 15
sta_if = network.WLAN(network.STA_IF)
ap_if = network.WLAN(network.AP_IF)
button_1 = utils.Button(12)
neopixel_rgb = utils.RGB(13, 4)
audio = dfplayer.SimpleDFPlayerMini(1, 0, 1)
loop = uasyncio.get_event_loop()
network_updated = uasyncio.Event()
alarm_updated = uasyncio.Event()
time_updated = uasyncio.Event()
volume_lock = uasyncio.Lock()
def main():
audio.suspend()
loop = uasyncio.get_event_loop()
loop.create_task(network_coro())
loop.create_task(alarm_time_coro())
loop.run_forever()
def status():
with open('wifi.json', 'rb') as f:
wifi = ujson.loads(f.read())
with open('alarm.json', 'rb') as f:
alarm = ujson.loads(f.read())
return {'network' : {'ssid': wifi['ssid'], 'ip': network.WLAN(network.STA_IF).ifconfig()[0], 'connected': network.WLAN(network.STA_IF).isconnected()}, 'time': utils.cettime(), 'alarm' : {'hour': alarm['hour'], 'minute': alarm['minute']}}
class DS18(ComponentSensor):
_pins = {} # pin number/name:onewire()
_last_conv = {} # onewire:time
_lock = asyncio.Lock()
def __init__(self,
pin,
rom: str = None,
auto_detect=False,
precision_temp: int = 2,
offset_temp: float = 0,
friendly_name=None,
**kwargs):
"""
Class for a single ds18 unit to provide an interface to a single unit.
Alternatively it can be used to automatically detect all connected units
and create objects for those units.
:param pin: pin number/name/object
:param rom: optional, ROM of the specific DS18 unit, can be string or bytearray
(in json bytearray not possible). If not given then the first found ds18 unit will be used,
no matter the ROM. Makes it possible to have a generic ds18 unit.
:param auto_detect: optional, if true and ROM is None then all connected ds18 units will automatically generate a sensor object with the given options.
:param precision_temp: the precision to for returning/publishing values
:param offset_temp: temperature offset to adjust bad sensor readings
:param friendly_name: friendly name in homeassistant. Has no effect if rom is None and auto_detect True
"""
if rom is None and auto_detect:
# only a dummy sensor for detecting connected sensors
interval_reading = kwargs[
"interval_reading"] if "interval_reading" in kwargs else None
interval_publish = kwargs[
"interval_publish"] if "interval_publish" in kwargs else None
self._instances = {} # rom:object
self._auto_detect = True
self._kwargs = kwargs # store kwargs for initialization of detected sensors
kwargs[
"interval_reading"] = 60 # scan every 60 seconds for new units
kwargs["interval_publish"] = -1
global _unit_index
_unit_index += 1
super().__init__(COMPONENT_NAME,
__version__,
_unit_index,
logger=_log,
**kwargs)
self.rom: str = rom
self._generic = True if rom is None and not auto_detect else False
if type(pin) == ds18x20.DS18X20:
self.sensor: ds18x20.DS18X20 = pin
else:
self._pins[pin] = ds18x20.DS18X20(onewire.OneWire(Pin(pin)))
self.sensor: ds18x20.DS18X20 = self._pins[pin]
self._last_conv[self.sensor] = None
if rom or not auto_detect: # sensor with rom or generic sensor
self._addSensorType(SENSOR_TEMPERATURE, precision_temp,
offset_temp, VALUE_TEMPLATE_FLOAT, "°C",
friendly_name)
self._auto_detect = False
elif self._auto_detect:
self._kwargs["interval_reading"] = interval_reading
self._kwargs["interval_publish"] = interval_publish
self._kwargs["precision_temp"] = precision_temp
self._kwargs["offset_temp"] = offset_temp
gc.collect()
def _default_name(self):
"""Change default name to include sensor ROM. Will change name and default topic."""
if self.rom is None or self._generic:
return "{!s}".format(COMPONENT_NAME)
else:
return "{!s}_{!s}".format(COMPONENT_NAME, self.rom)
async def _read(self):
if self._auto_detect or self._generic: # auto_detect unit or generic sensor
roms = []
for _ in range(4):
roms_n = self.sensor.scan()
for rom in roms_n:
if rom not in roms:
roms.append(rom)
await asyncio.sleep_ms(100)
if len(roms) == 0:
await _log.asyncLog("error", "Found no ds18 unit", timeout=10)
return
if self._auto_detect: # auto_detect instance
for rom in roms:
rom = self.rom2str(rom)
if rom not in self._instances:
self._instances[rom] = DS18(self.sensor, rom, False,
**self._kwargs)
for rom in self._instances:
if rom not in roms: # sensor not connected anymore
await self.removeComponent(roms[rom])
# will stop its loop and remove component and unsubcribe every topic
del self._instances[rom]
await _log.asyncLog("info",
"DS18 removed:",
rom,
timeout=5)
else: # generic ds18 sensor
rom = self.rom2str(roms[0])
if rom != self.rom: # sensor replaced
self.rom: str = rom
await _log.asyncLog("info",
"Found new ds18:",
rom,
timeout=5)
if self.rom is not None: # DS18 sensor unit
async with self._lock:
if self._last_conv[self.sensor] is None or \
time.ticks_diff(time.ticks_ms(), self._last_conv[self.sensor]) > 5000:
# if sensors did convert time more than 5 seconds ago, convert temp again
try:
self.sensor.convert_temp()
except onewire.OneWireError:
await self._setValue(SENSOR_TEMPERATURE, None)
await _log.asyncLog("error",
"Sensor rom",
self.rom,
", onewire not connected?,",
timeout=10)
return
await asyncio.sleep_ms(750)
value = None
err = None
for _ in range(3):
try:
value = self.sensor.read_temp(self.str2rom(self.rom))
except Exception as e:
await asyncio.sleep_ms(100)
err = e
continue
if value is None:
await self._setValue(SENSOR_TEMPERATURE, None)
await _log.asyncLog("error",
"Sensor rom",
self.rom,
"got no value,",
err,
timeout=10)
return
if value == 85.0:
await self._setValue(SENSOR_TEMPERATURE, None)
await _log.asyncLog(
"error",
"Sensor rom",
self.rom,
"got value 85.00 [not working correctly]",
timeout=10)
return
await self._setValue(SENSOR_TEMPERATURE, value)
@staticmethod
def rom2str(rom: bytearray) -> str:
return ''.join('%02X' % i for i in iter(rom))
@staticmethod
def str2rom(rom: str) -> bytearray:
a = bytearray(8)
for i in range(8):
a[i] = int(rom[i * 2:i * 2 + 2], 16)
return a
connection_details = wlan_network.ifconfig()
ip_address = connection_details[0]
netmask = connection_details[1]
ip_address_segments = (int(item) for item in ip_address.split("."))
netmask_segments = (int(item) for item in netmask.split("."))
broadcast_segments = []
for (ip_address_segment, netmask_segment) in zip(ip_address_segments, netmask_segments):
if int(netmask_segment) == 255:
broadcast_segments.append(ip_address_segment)
else:
network_segment = ip_address_segment & netmask_segment
broadcast_segments.append(network_segment + (255 - netmask_segment))
return ".".join(str(item) for item in broadcast_segments)
discovery_lock = uasyncio.Lock()
async def discover(timeout: int = 5, clazz=None):
onkyo_magic = eISCPPacket("!xECNQSTN").get_raw()
pioneer_magic = eISCPPacket("!pECNQSTN").get_raw()
found_receivers = {}
broadcast_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
broadcast_socket.setblocking(0)
broadcast_address = get_current_broadcast_address()
own_address = get_current_ip_address()
async with discovery_lock:
try:
broadcast_socket.bind(
(own_address, eISCP.ONKYO_PORT)
def __init__(self, lock=None):
self.lock = asyncio.Lock() if lock is None else lock
self.events = []
'''
Author: Vladimir Vons <*****@*****.**>
Created: 2018.06.17
License: GNU, see LICENSE for more details
Description:
'''
import time
import uasyncio as asyncio
#
from Inc.Log import Log
from IncP.Api import TApiBase
Lock = asyncio.Lock()
class TApi(TApiBase):
Param = {'delay': 1, 'async': True, 'echo': True}
async def Exec(self, aDelay: float, aAsync: bool, aEcho: bool) -> dict:
async with Lock:
if (aAsync):
await asyncio.sleep(aDelay)
else:
time.sleep(aDelay)
R = {'delay': aDelay, 'async': aAsync, 'echo': aEcho}
if (aEcho):
Log.Print(1, 'i', 'sys_sleep', R)
return R
async def main():
lock = asyncio.Lock() # The Lock instance
for n in range(1, 4):
asyncio.create_task(task(n, lock))
await asyncio.sleep(10)
