def httpserver_init():
global server
server = MicroWebSrv(webPath='www/')
server.MaxWebSocketRecvLen = 256
server.WebSocketThreaded = False
server.AcceptWebSocketCallback = _acceptWebSocketCallback
server.Start(threaded=False)
def setup_web_server(accept_socket_cb):
"Setup http webserver."
mws = MicroWebSrv()
mws.MaxWebSocketRecvLen = 256
mws.WebSocketThreaded = False
mws.AcceptWebSocketCallback = accept_socket_cb
mws.Start()
def main():
ap = AccessPoint()
srv = MicroWebSrv(webPath='www/')
srv.MaxWebSocketRecvLen = 256
srv.WebSocketThreaded = False
srv.AcceptWebSocketCallback = _acceptWebSocketCallback
srv.Start()
del ap
def main():
import uos
import json
import time
import _thread
import network
from m5stack import lcd, buttonA
from microWebSrv import MicroWebSrv
from micropython import const
def wifiCheck():
sta_if = network.WLAN(network.STA_IF)
if sta_if.active() == False:
sta_if.active(True)
wifi = json.load(open('/flash/etc/wlan.json', 'r'))
ssid = wifi['wifi']['ssid']
pwd = wifi['wifi']['password']
sta_if.connect(ssid, pwd)
while sta_if.ifconfig()[0] == '0.0.0.0':
time.sleep(.5)
lcd.println('Connect to WLAN.')
def __acceptWebSocketCallback(webSocket, httpClient):
print("WS ACCEPT")
webSocket.SendText(json.dumps(['login', 'SyncSyncSync']))
webSocket.RecvTextCallback = __recvTextCallback
# webSocket.RecvBinaryCallback = self.__recvBinaryCallback
# webSocket.ClosedCallback = self.__closedCallback
def __recvTextCallback(webSocket, msg):
msg = eval(msg)
# ['command', 'parameter']
cmd = msg[0]
para = msg[1]
print('Receive command: %s' % cmd)
if cmd == 'ls':
webSocket.SendText(json.dumps(['ls', uos.listdir()]))
elif cmd == 'cd':
uos.chdir(para)
webSocket.SendText(json.dumps(['cd', uos.listdir()]))
elif cmd == 'get':
with open(para, 'r') as o:
webSocket.SendText(json.dumps(['get', o.read()]))
elif cmd == 'post':
with open(para, 'w') as o:
o.write(msg[2])
webSocket.SendText(json.dumps(['post', 1]))
wifiCheck()
ws = MicroWebSrv(port=8000)
ws.MaxWebSocketRecvLen = 256
# ws.WebSocketThreaded = False
ws.AcceptWebSocketCallback = __acceptWebSocketCallback
ws.Start(threaded=False)
def start():
global gUart
gUart = machine.UART(1, rx=14, tx=12)
srv = MicroWebSrv(webPath='www/')
#srv = MicroWebSrv(routeHandlers=routeHandlers, webPath='/www/')
srv.MaxWebSocketRecvLen = 256
srv.WebSocketThreaded = True #False
srv.AcceptWebSocketCallback = _acceptWebSocketCallback
srv.Start()
def start_server(_relay=None, _dht11=None, _debugMode=False):
"""Run server at configured device"""
print('Starting regular server...')
global relay
global dht11
global srv
global DEBUG_MODE
if (_relay!=None and _dht11!=None):
relay = _relay
dht11 = _dht11
DEBUG_MODE = _debugMode
srv = MicroWebSrv(webPath='www/')
srv.MaxWebSocketRecvLen = 256
srv.WebSocketThreaded = True
srv.AcceptWebSocketCallback = _acceptWebSocketCallback
srv.Start(threaded=True)
def _recvTextCallback(webSocket, msg):
print("WS RECV TEXT : %s" % msg)
webSocket.SendText("Reply for %s" % msg)
def _recvBinaryCallback(webSocket, data):
print("WS RECV DATA : %s" % data)
def _closedCallback(webSocket):
print("WS CLOSED")
# ----------------------------------------------------------------------------
# routeHandlers = [
# ( "/test", "GET", _httpHandlerTestGet ),
# ( "/test", "POST", _httpHandlerTestPost )
# ]
p = 80 if sys.platform == 'linux' else 8080
srv = MicroWebSrv(port=p, webPath='www/')
srv.MaxWebSocketRecvLen = 256
srv.WebSocketThreaded = True
srv.AcceptWebSocketCallback = _acceptWebSocketCallback
srv.Start(threaded=True)
while True:
time.sleep(72000)
# ----------------------------------------------------------------------------
dict['internal'] = machine.internal_temp()[1] # Read ESP32 internal temp
dict['time'] = rtc.now() # Record current time
# Convert data to JSON and send
websocket.SendText(json.dumps(dict))
def cb_accept_ws(webSocket, httpClient):
print("WS ACCEPT")
webSocket.RecvTextCallback = cb_receive_text
webSocket.RecvBinaryCallback = cb_receive_binary
webSocket.ClosedCallback = cb_closed
# Use lambda to pass websocket to timer callback
cb = lambda timer: cb_timer(timer, webSocket)
# Init and start timer to poll temperature sensor
tm.init(period=3000, callback=cb)
mws = MicroWebSrv() # TCP port 80 and files in /flash/www
mws.MaxWebSocketRecvLen = 256 # Default is set to 1024
mws.WebSocketThreaded = True # WebSockets with new threads
mws.WebSocketStackSize = 4096
mws.AcceptWebSocketCallback = cb_accept_ws # Function to receive WebSockets
mws.Start(threaded=False) # Blocking call (CTRL-C to exit)
print('Cleaning up and exiting.')
mws.Stop()
tm.deinit()
rtc.clear()
ds.deinit()
ow.deinit()
print("WS RECV TEXT : %s" % msg)
webSocket.SendText("Reply for %s" % msg+ str(t))
global wsflag
global ws
ws = webSocket
wsflag = True
def _recvBinaryCallback(webSocket, data) :
print("WS RECV DATA : %s" % data)
def _closedCallback(webSocket) :
print("WS CLOSED")
mws = MicroWebSrv() # TCP port 80 and files in /flash/www
mws.MaxWebSocketRecvLen = 256 # Default is set to 1024
mws.WebSocketThreaded = False # WebSockets without new threads
mws.AcceptWebSocketCallback = _acceptWebSocketCallback# Function to receive WebSockets
mws.Start()
t=0
while not wsflag : pass
while True:
print(t)
if not ws.IsClosed() : ws.SendText(str(t))
utime.sleep_ms(100)
t+=1
def ws_close_callback(ws):
# print("Web socket closed")
open_web_sockets.remove(ws)
mws = MicroWebSrv(port=80, webPath="static")
mws.LetCacheStaticContentLevel = 0 # Disable cache headers for now as they aren't fully functional
mws.StaticCacheByPath = [
("static/data/", 0),
("static/index.html", 0),
("static/logs/", 0),
("static/", 2),
]
mws.StaticHeaders = {"Access-Control-Allow-Origin": "*"}
mws.AcceptWebSocketCallback = ws_accept_callback
mws.Start(threaded=True)
print("Web server started.")
def check_for_reboot():
if reboot_now:
print("Rebooting in 1 second...")
time.sleep(1)
print("now!")
machine.reset()
print("Should never get here!!")
# while time.ticks_ms() < 3000:
# check_for_reboot()
