def run():
loop = asyncio.get_event_loop()
httpServer = asyncio.start_server(serve, host="0.0.0.0", port=http_server_port)
wsServer = asyncio.start_server(websocketHandle, host="0.0.0.0", port=ws_server_port)
loop.call_soon(httpServer)
loop.create_task(wsServer)
loop.create_task(blink())
loop.create_task(temperature())
try:
loop.run_forever()
except Exception as err:
httpServer.close()
wsServer.close()
loop.close()
raise err
def get_task(self, host='0.0.0.0', port=80, debug=False):
gc.collect()
self.debug = int(debug)
self.init()
if debug:
print("* Running on http://%s:%s/" % (host, port))
return asyncio.start_server(self._handle, host, port)
def boot(self):
super().boot()
uart.init(**self.load()['uart'])
loop = get_event_loop()
loop.create_task(
start_server(Serial.getInstance().handle, '0.0.0.0', 23))
loop.create_task(Serial.getInstance().readln())
def run(host="192.168.4.1", port=8081, loop_forever=True, backlog=16):
loop = asyncio.get_event_loop()
print("* Starting Server at {}:{}".format(host, port))
loop.create_task(asyncio.start_server(_handler, host, port, backlog=backlog))
if loop_forever:
loop.run_forever()
loop.close()
def main():
loop = uasyncio.get_event_loop()
loop.create_task(set_time())
loop.create_task(pump_routine())
# loop.create_task(check_moisture())
loop.create_task(uasyncio.start_server(webapp.handle, '0.0.0.0', 80))
loop.run_forever()
def start(root_path='/wwwroot',
default_document='index.html',
network_port=80):
try:
my_address = get_address()
loop = asyncio.get_event_loop()
print('Starting DNS server...')
mydnsserver = MyDNSServer()
loop.create_task(mydnsserver.handle_query(my_address))
print('Starting web server at {0}:{1}...'.format(
my_address, network_port))
myhttpserver = MyHTTPServer(root_path, default_document, network_port)
server = asyncio.start_server(myhttpserver.handle_request, "0.0.0.0",
network_port)
loop.create_task(server)
print('...(<ctrl>+c to stop)...')
loop.run_forever()
except KeyboardInterrupt:
print('Servers stopped.')
finally:
asyncio.new_event_loop()
def run(self, host='0.0.0.0', port=5000, debug=False):
self.debug = debug
async def serve(reader, writer):
if not hasattr(writer, 'awrite'): # pragma: no cover
# CPython provides the awrite and aclose methods in 3.8+
async def awrite(self, data):
self.write(data)
await self.drain()
async def aclose(self):
self.close()
await self.wait_closed()
from types import MethodType
writer.awrite = MethodType(awrite, writer)
writer.aclose = MethodType(aclose, writer)
await self.dispatch_request(reader, writer)
if self.debug: # pragma: no cover
print('Starting async server on {host}:{port}...'.format(
host=host, port=port))
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.start_server(serve, host, port))
loop.run_forever()
loop.close() # pragma: no cover
def serve(self, loop, host, port):
# Actually serve client connections. Subclasses may override this
# to e.g. catch and handle exceptions when dealing with server socket
# (which are otherwise unhandled and will terminate a Picoweb app).
# Note: name and signature of this method may change.
loop.create_task(asyncio.start_server(self._handle, host, port))
loop.run_forever()
def httpserver(fromcard = False, rootpath = '', watchdog = False):
global webroot
#logging.basicConfig(level=logging.ERROR)
addr = get_address()
if fromcard:
from shields import microsd_shield
sdcard = microsd_shield.MicroSD_Shield()
sdcard.mount()
webroot = '/sd/wwwroot'
if rootpath:
webroot = rootpath
#uasyncio.set_debug(1)
loop = uasyncio.get_event_loop()
loop.create_task(uasyncio.start_server(serve_content, addr, 80, 20))
if watchdog:
from machine import Pin, WDT
wdt = WDT()
wdt.feed()
led = Pin(2, Pin.OUT)
loop.create_task(heartbeat(wdt, led))
loop.run_forever()
loop.close()
if fromcard:
sdcard.unmount()
#httpserver()
async def PASV(self, stream, argument):
if self.addr != "0.0.0.0":
result = '227 Entering Passive Mode ({},{},{}).\r\n'.format(
self.addr.replace('.', ','), self.dport >> 8, self.dport % 256)
log.debug("PASV: {}".format(result))
await _awrite(stream, result)
if not self._run_pasv:
log.info("Start Passive Data Server to %s %d" %
(self.addr, self.dport))
loop = asyncio.get_event_loop()
loop.call_soon(
asyncio.start_server(self.data_server, "0.0.0.0",
self.dport))
#loop.call_soon(asyncio.start_server, self.data_server, "0.0.0.0", self.dport)
self.con_type = "passive"
self._run_pasv = True
return True
else:
await _awrite(stream, "221 Bye!.\r\n")
return False
def main():
global car_actions
init_logger()
# Initialize the car and stop it from moving
car = Car(CAR_CONF)
car.stop()
# Define the actions that the Car supports
car_actions = {
"FORWARD": car.forward,
"REVERSE": car.reverse,
"TURN_LEFT": car.turn_left,
"TURN_RIGHT": car.turn_right,
"ACCELERATE": car.accelerate,
"DECELERATE": car.decelerate,
"STOP": car.stop
}
coro = asyncio.start_server(handle_car_data, host=HOST, port=PORT)
log.info('[HANDLE_DATA] Starting uasyncio event loop')
loop.create_task(coro)
loop.run_forever()
log.info('[HANDLE_DATA] Finishing uasyncio event loop')
loop.close()
# Stop the car to avoid crashes ;)
car.stop()
def run():
global robot_busy
robot_busy = False
loop = asyncio.get_event_loop()
loop.call_soon(asyncio.start_server(serve, "192.168.4.1", 80))
loop.run_forever()
loop.close()
def start(loop=None, port=21, preload=False):
""" Start the ftp server with asyncio loop.
loop : asyncio loop object
port : tcp/ip port of the server
preload : True = preload the server at the start, False = load the server at the first connection """
server = Ftp(port, preload)
# If asyncio loop not created
if loop == None:
# Create asyncio loop
loop = uasyncio.get_event_loop()
# Run for ever in this case the ftp server
run_forever = True
else:
# The ftp server is called on asyncio connection
run_forever = False
# Start ftp server on port specified
asyncServer = uasyncio.start_server(server.onConnection,
"0.0.0.0",
port,
backlog=1)
# Create asyncio task
loop.create_task(asyncServer)
# If ftp server is stand alone mode
if run_forever:
loop.run_forever()
def initialize(self):
print("Initialize threads")
loop = uasyncio.get_event_loop()
loop.create_task(self.dht_m.measureTempAndHum())
loop.call_soon(uasyncio.start_server(self.api.process, "0.0.0.0", 80))
loop.run_forever()
pass
def runhotspotserver():
import network
si = network.WLAN(network.AP_IF) # create access-point interface
macaddress = "".join("{:02x}".format(x) for x in si.config("mac"))
si.active(True) # activate the interface
print("Creating access point ESP_{}".format(macaddress[-6:]))
ipnumber = si.ifconfig()[0]
print("Device has ipnumber", ipnumber)
import uasyncio as asyncio
def handleconnection_indirect(reader, writer):
try:
return handleconnection(reader, writer)
except OSError as e:
print("handleconnection exception", str(e))
port = 80
loop = asyncio.get_event_loop()
print("* Running on http://%s:%s/" % (ipnumber, port))
loop.create_task(
asyncio.start_server(handleconnection_indirect, ipnumber, port))
loop.run_forever()
def main():
print("Wait until connected to known APs")
while not try_connect_to_known_aps():
sleep(5)
pass
print("Network config:", sta_if.ifconfig())
PeripheralConfig["IP"], *_ = sta_if.ifconfig()
loop = get_event_loop()
print("Creating discovery server udp://{IP}:{DISCOVERY_PORT}".format(
**PeripheralConfig))
loop.create_task(
start_discovery_server(PeripheralConfig["IP"],
PeripheralConfig["DISCOVERY_PORT"]))
print("Creating websocket server tcp://{IP}:{LINK_PORT}".format(
**PeripheralConfig))
loop.create_task(
start_server(link_endpoint_handler, PeripheralConfig["IP"],
PeripheralConfig["LINK_PORT"]))
import gc
gc.collect()
print("Eventloop: run_forever()")
loop.run_forever()
loop.close()
def main():
loop = asyncio.get_event_loop()
loop.create_task(heartbeat())
#loop.create_task(calc_sunrise_sunset())
loop.create_task(measure_dht())
loop.create_task(asyncio.start_server(webapp.handle, '0.0.0.0', 80))
gc.collect()
loop.run_forever()
def start_dome():
machine.freq(160000000)
loop = uasyncio.get_event_loop()
loop.create_task(DeviceHandler.main())
loop.create_task(uasyncio.start_server(conn_handler, "0.0.0.0", 8081))
loop.run_forever()
loop.close()
def run(self, host, port):
import uasyncio
try:
loop = uasyncio.get_event_loop()
loop.create_task(uasyncio.start_server(self.serve, host, port))
loop.run_forever()
finally:
loop.close()
def __init__(self):
self.rawLidarReadings = None
self.server = uasyncio.start_server(self.tcp_callback,
my_ip,
TCP_PORT,
backlog=5)
self.i2c_master = i2c_master.I2C_master(self)
uasyncio.create_task(self.server)
def start():
#import logging
#logging.basicConfig(level=logging.ERROR)
loop = asyncio.get_event_loop()
loop.call_soon(asyncio.start_server(serve, "0.0.0.0", 80, 20))
loop.run_forever()
loop.close()
def start(self, addr="0.0.0.0", port=23):
loop = asyncio.get_event_loop()
if not self.run:
loop.create_task(asyncio.start_server(self.server, addr, port))
log.info("Telnet server started on {}:{}".format(addr, port))
self.run = "{};{}".format(addr, port)
return True
def main(robo):
loop = uasyncio.get_event_loop()
loop.create_task(heartbeat(robo))
loop.create_task(can_send(robo))
loop.create_task(
uasyncio.start_server(tcp_callback, "192.168.137.10", 8123, backlog=1))
loop.run_forever()
loop.close()
def create_server():
loop = asyncio.get_event_loop()
loop.call_soon(
asyncio.start_server(
handle_request,
'0.0.0.0',
80,
backlog=100,
)
)
def async_main():
loop = asyncio.get_event_loop()
loop.create_task(
asyncio.start_server(configserver.handle_request, "0.0.0.0", 80, 1))
loop.create_task(main_state_machine())
loop.run_forever()
loop.close()
def main():
"""
Set up the tasks and start the event loop
"""
connect()
loop = asyncio.get_event_loop()
loop.create_task(set_time())
loop.create_task(calc_sunrise_sunset())
loop.create_task(door_check())
loop.create_task(asyncio.start_server(webapp.handle, '0.0.0.0', 80))
gc.collect()
loop.run_forever()
def run(self, host="127.0.0.1", port=8081, debug=False, lazy_init=False):
self.debug = int(debug)
self.init()
if not lazy_init:
for app in self.mounts:
app.init()
loop = asyncio.get_event_loop()
if debug:
print("* Running on http://%s:%s/" % (host, port))
loop.create_task(asyncio.start_server(self._handle, host, port))
loop.run_forever()
loop.close()
def run(self, host="127.0.0.1", port=8081, debug=False, lazy_init=False):
self.debug = int(debug)
self.init()
if not lazy_init:
for app in self.mounts:
app.init()
loop = asyncio.get_event_loop()
if debug:
print("* Running on http://%s:%s/" % (host, port))
loop.create_task(asyncio.start_server(self._handle, host, port))
loop.run_forever()
loop.close()
def init_as_task(host="127.0.0.1",
port=8081,
debug=False,
lazy_init=False):
gc.collect()
self.debug = int(debug)
self.init()
if not lazy_init:
for app in self.mounts:
app.init()
if debug:
print("* Running on http://%s:%s/" % (host, port))
return asyncio.start_server(self._handle, host, port)
def start(server_paths):
global ServerPaths
ServerPaths = server_paths
loop = asyncio.get_event_loop()
loop.create_task(asyncio.start_server(serve, "0.0.0.0", 80, 20))
try:
loop.run_forever()
except KeyboardInterrupt:
print("User terminated")
finally:
print("closing")
loop.close()
def run(self):
loop = uasyncio.get_event_loop()
loop.create_task(
uasyncio.start_server(self.request_handler, '0.0.0.0', 80))
loop.create_task(self.feed_watchdog())
from led_dim_level_cfg import restore_power_led_level
Pins.power_led.on()
restore_power_led_level()
del restore_power_led_level
del sys.modules['led_dim_level_cfg']
print(self.message)
loop.run_forever()
def run(self, host="127.0.0.1", port=8081, debug=False, lazy_init=False, log=None):
if log is None and debug >= 0:
import ulogging
log = ulogging.getLogger("picoweb")
if debug > 0:
log.setLevel(ulogging.DEBUG)
self.log = log
gc.collect()
self.debug = int(debug)
self.init()
if not lazy_init:
for app in self.mounts:
app.init()
loop = asyncio.get_event_loop()
if debug > 0:
print("* Running on http://%s:%s/" % (host, port))
loop.create_task(asyncio.start_server(self._handle, host, port))
loop.run_forever()
loop.close()
def run(self, debug=False):
if debug:
import logging
logging.basicConfig(level=logging.DEBUG)
loop = asyncio.get_event_loop()
this = self
@asyncio.coroutine
def serve(reader, writer):
yield from this.serve(reader, writer)
loop.call_soon(asyncio.start_server(
client_coro=serve,
host=self._bind_addr,
port=self._port,
backlog=self._backlog
))
loop.run_forever()
loop.close()
def test_client_server(self):
'''Simple client-server echo test'''
sockaddr = ('127.0.0.1', 8080)
l = get_event_loop()
async def echo_server(reader, writer):
data = await reader.readline()
await writer.awrite(data)
await writer.aclose()
async def echo_client(line, result):
await sleep_ms(10) # Allow server to get up
reader, writer = await open_connection(*sockaddr)
await writer.awrite(line)
data = await reader.readline()
await writer.aclose()
result.append(data) # capture response
result = []
l.create_task(start_server(echo_server, *sockaddr))
l.run_until_complete(echo_client(b'Hello\r\n', result))
self.assertEqual(result[0], b'Hello\r\n')
global cnt
#s = "Hello.\r\n"
s = "Hello. %07d\r\n" % cnt
cnt += 1
yield from reader.read()
yield from writer.awrite("HTTP/1.0 200 OK\r\n\r\n")
try:
yield from writer.awrite(s)
yield from writer.awrite(s * 100)
yield from writer.awrite(s * 400000)
yield from writer.awrite("=== END ===")
yield from writer.close()
except OSError as e:
if e.args[0] == errno.EPIPE:
print("EPIPE")
elif e.args[0] == errno.ECONNRESET:
print("ECONNRESET")
else:
raise
import logging
logging.basicConfig(level=logging.INFO)
#logging.basicConfig(level=logging.DEBUG)
signal.signal(signal.SIGPIPE, signal.SIG_IGN)
loop = asyncio.get_event_loop()
mem_info()
loop.call_soon(asyncio.start_server(serve, "0.0.0.0", 8081, backlog=100))
loop.run_forever()
loop.close()
import uasyncio as asyncio
@asyncio.coroutine
def serve(reader, writer):
#print(reader, writer)
#print("================")
yield from reader.read(256)
yield from writer.awrite("HTTP/1.0 200 OK\r\n\r\nHello.\r\n")
yield from writer.aclose()
#print("Finished processing request")
import logging
#logging.basicConfig(level=logging.INFO)
logging.basicConfig(level=logging.DEBUG)
loop = asyncio.get_event_loop()
#mem_info()
loop.create_task(asyncio.start_server(serve, "127.0.0.1", 8081, backlog=100))
loop.run_forever()
loop.close()
import uasyncio as asyncio
@asyncio.coroutine
def serve(reader, writer):
print(reader, writer)
print("================")
print((yield from reader.read()))
yield from writer.awrite("HTTP/1.0 200 OK\r\n\r\nHello.\r\n")
print("After response write")
yield from writer.close()
print("Finished processing request")
import logging
#logging.basicConfig(level=logging.INFO)
logging.basicConfig(level=logging.DEBUG)
loop = asyncio.get_event_loop()
mem_info()
loop.call_soon(asyncio.start_server(serve, "127.0.0.1", 8081))
loop.run_forever()
loop.close()
