def run(self, app_config):
self.led = machine.Pin(app_config['led'], machine.Pin.OUT)
# Camera resilience - if we fail to init try to deinit and init again
if app_config['camera'] == 'ESP32-CAM':
camera.init(0, format=camera.JPEG) #ESP32-CAM
elif app_config['camera'] == 'M5CAMERA':
camera.init(0,
d0=32,
d1=35,
d2=34,
d3=5,
d4=39,
d5=18,
d6=36,
d7=19,
href=26,
vsync=25,
reset=15,
sioc=23,
siod=22,
xclk=27,
pclk=21) #M5CAMERA
camera.framesize(self.framesize)
mws = MicroWebSrv(routeHandlers=self.routeHandlers, webPath="www/")
mws.Start(threaded=True)
gc.collect()
def webserver_start():
global scanlist
#lcd.clear()
#lcd.setCursor(0, 0)
# wlan_ap.eventCB(wlan_ap_cb)
wlan_ap.active(True)
# node_id = ubinascii.hexlify(machine.unique_id())
ssid_name = "M5Stack-" + node_id[-4:]
# #lcd.font(#lcd.FONT_Comic, transparent=True)
# #lcd.print(ssid_name, 0, 0, #lcd.RED)
wlan_ap.config(essid=ssid_name, authmode=network.AUTH_OPEN)
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]
print('WiFi AP WebServer Start!')
print('Connect to Wifi ssid:'+ssid_name)
print('And connect to esp via your web browser (like 192.168.4.1)')
print('listening on', addr)
#lcd.println('Connect to Wifi ssid:'+ssid_name)
#lcd.println('via your web browser: 192.168.4.1')
#lcd.println('listening on'+str(addr))
if not wlan_sta.active():
wlan_sta.active(True)
scanlist = wlan_sta.scan()
from microWebSrv import MicroWebSrv
webserver = MicroWebSrv(routeHandlers=routeHandlers)
webserver.Start(threaded=False)
def webserver_start():
global scanlist
from microWebSrv import MicroWebSrv
lcd.clear()
lcd.setCursor(0, 0)
ssid_name = "M5Stack-" + node_id[-4:]
wlan_ap.active(True)
wlan_ap.config(essid=ssid_name, authmode=network.AUTH_OPEN)
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]
print('WiFi AP WebServer Start!')
print('Connect to Wifi SSID:' + ssid_name)
print('And connect to esp via your web browser (like 192.168.4.1)')
print('listening on', addr)
lcd.image(0, 0, '/flash/img/1-1.jpg', type=lcd.JPG)
lcd.font(lcd.FONT_DejaVu24)
lcd.setTextColor(lcd.BLACK, lcd.WHITE)
lcd.print('Wi-Fi SSID', 150, 145, lcd.BLACK)
lcd.print(ssid_name, 125, 170, lcd.RED)
webserver = MicroWebSrv(routeHandlers=routeHandlers)
scanlist = wlan_sta.scan()
if not wlan_sta.active():
wlan_sta.active(True)
while True:
if len(wlan_ap.status('stations')) > 0:
break
time.sleep_ms(200)
lcd.image(0, 0, '/flash/img/1-2.jpg', type=lcd.JPG)
webserver.Start(threaded=False)
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_app(self, write_func, get_func):
"""
Функция запуска веб-приложения.
На вход принимает 2 функции.
1. Функция записи данных. Должна иметь 3 аргумента:
1) Частота опроса датчиков
2) Новый датчик добавляемый в список
3) Датчик удаляемый из списка
2. Функция чтения данных. Должна возвращать 2 значения:
1) Частота опроса датчиков
2) Список адресов датчиков в памяти
У веб-приложения 2 маршрута:
1. Форма
2. Обработчик формы
Их нельзя объединить из-за особенности библиотеки
"""
from microWebSrv import MicroWebSrv
# Форма
@MicroWebSrv.route('/')
def handlerFuncGet(httpClient, httpResponse):
frequency, clients = get_func()
clients_list = 'Clients:<br>'
for client in clients:
clients_list += client + '<br>'
httpResponse.WriteResponseOk(headers=None,
contentType="text/html",
contentCharset="UTF-8",
content=self.page1.format(
frequency, clients_list))
# Обработчик формы
@MicroWebSrv.route('/post', 'POST')
def post_data(httpClient, httpResponse):
formData = httpClient.ReadRequestPostedFormData()
if formData['frequency']:
try:
frequency = int(formData['frequency'])
write_func(frequency, formData['add_client'],
formData['remove_client'])
except:
pass
httpResponse.WriteResponseOk(headers=None,
contentType="text/html",
contentCharset="UTF-8",
content=self.page2)
# MicroWebSrv.SetNotFoundPageUrl('/')
mws = MicroWebSrv()
# Приложение запускается как отдельный поток
mws.Start(threaded=True)
def start(self):
@MicroWebSrv.route('/cmd', 'POST')
def httpHandlerCmd(httpClient, httpResponse):
sCmd = self.getParams(httpClient, 'cmd')
print(sCmd)
@MicroWebSrv.route('/sync', 'POST')
def httpHandlerSync(httpClient, httpResponse):
print('sync')
mws = MicroWebSrv()
mws.Start()
def start(_sdb):
global dns, web, sdb
sdb = _sdb
## Starting Wifi Access Poijnt
wlan.active(1)
## Setting Up Capitve portal
ip = wlan.ifconfig()[0]
dns = MicroDNSSrv()
web = MicroWebSrv()
web.SetNotFoundPageUrl("http://my-fajr-clock.wifi/status")
dns.SetDomainsList({"*": ip})
dns.Start()
web.Start(True)
def start_web_server():
global ipaddress
epd.display_string_at(fb, 0, 60, "Connect to badge AP to configure.",
font12, gxgde0213b1.COLORED)
epd.display_string_at(fb, 0, 72, "Enter this URL in your browser:", font12,
gxgde0213b1.COLORED)
epd.display_string_at(fb, 0, 84, "http://" + ipaddress + "/setup", font12,
gxgde0213b1.COLORED)
epd.display_frame(fb)
srv = MicroWebSrv(webPath='www/')
srv.MaxWebSocketRecvLen = 256
srv.WebSocketThreaded = False
#srv.AcceptWebSocketCallback = _acceptWebSocketCallback
srv.Start(threaded=False)
def network_connect():
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
ssid = ConfigFile.get('wifi', {}).get('ssid')
if ssid:
sta_if.connect(ssid, ConfigFile.get('wifi', {}).get('pwd'))
if not wifi_connected(sta_if):
ap = network.WLAN(network.AP_IF) # create access-point interface
ap.active(True) # activate the interface
ap.config(essid='micropython_ap') # set the ESSID of the access point
@MicroWebSrv.route('/aps', 'GET')
def scan_ap(http_client, http_response):
sta_if.active(True)
ap_list = sta_if.scan()
http_response.WriteResponseJSONOk([ap[0] for ap in ap_list])
@MicroWebSrv.route('/connect', 'POST')
def connect(http_client, http_response):
params = json.loads(http_client.ReadRequestContent())
ssid = params.get('ssid')
if not ssid:
http_response.WriteResponseJSONOk({
'Success': False,
'Message': 'ssid不能为空！'
})
return
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
sta_if.connect(ssid, params.get('pwd')) # Connect to an AP
if wifi_connected(sta_if):
print('connect success!')
wifi_config = ConfigFile.get('wifi', {})
wifi_config['ssid'] = ssid
wifi_config['pwd'] = params.get('pwd')
ConfigFile.set('wifi', wifi_config)
machine.reset()
http_response.WriteResponseJSONOk({
'Success': False,
'Message': '连接失败！'
})
srv = MicroWebSrv(webPath='/templates/')
srv.MaxWebSocketRecvLen = 256
srv.WebSocketThreaded = False
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 start_app(self, write_func, get_func):
"""
Функция запуска веб-приложения.
На вход принимает 2 функции.
1. Функция записи данных. Должна иметь 1 аргумент (адрес датчика)
2. Функция чтения данных. Должна возвращать 1 значение (адрес датчика)
У веб-приложения 2 маршрута:
1. Форма
2. Обработчик формы
Их нельзя объединить из-за особенности библиотеки
"""
from microWebSrv import MicroWebSrv
# Форма
@MicroWebSrv.route('/')
def handlerFuncGet(httpClient, httpResponse):
httpResponse.WriteResponseOk(headers=None,
contentType="text/html",
contentCharset="UTF-8",
content=self.page1.format(get_func()))
# Обработчик формы
@MicroWebSrv.route('/post', 'POST')
def post_data(httpClient, httpResponse):
formData = httpClient.ReadRequestPostedFormData()
write_func(formData['client'])
httpResponse.WriteResponseOk(headers=None,
contentType="text/html",
contentCharset="UTF-8",
content=self.page2)
# MicroWebSrv.SetNotFoundPageUrl('/')
mws = MicroWebSrv()
# Приложение запускается как отдельный поток
mws.Start(threaded=True)
def start(self):
self.wlan_sta.active(True)
self.wlan_ap.active(True)
self.wlan_ap.config(essid=self.ap_name, password=self.ap_password)
routeHandlers = [
("/", "GET", self._httpHandlerIndexGet),
("/aplist", "GET", self._httpHandlerScanNetworks),
("/status", "GET", self._httpHandlerCheckStatus),
("/save", "POST", self._httpHandlerSaveConfig)
]
srv = MicroWebSrv(routeHandlers=routeHandlers)
srv.Start(threaded=True)
print('Now enter config mode')
print('Connect to Wifi ssid :' + self.ap_name + ' , default pass: '******'And connect to Blocky via at 192.168.4.1')
gc.collect()
print(gc.mem_free())
return True
obj = {
'temperature': str(tmp),
}
httpResponse.WriteResponseJSONOk(obj=obj, headers=headers)
@MicroWebSrv.route('/SAD')
def _httpHandlerTestGet(httpClient, httpResponse):
params = httpClient.GetRequestQueryParams()
display.show(Image.SAD)
@MicroWebSrv.route('/scroll')
def _httpHandlerTestGet(httpClient, httpResponse):
params = httpClient.GetRequestQueryParams()
display.scroll(str(params['text']))
if __name__ == '__main__':
if 'srv' in locals():
reset()
pin13.write_digital(0)
import time
while True:
time.sleep(2)
if wifi.isconnected():
srv = MicroWebSrv(webPath='www/')
srv.Start(True)
pin13.write_digital(1)
else:
pin13.write_digital(0)
def run_web(threaded):
from microWebSrv import MicroWebSrv
def delayed_reboot(delay=3.5):
from time import sleep
from machine import reset
sleep(delay)
reset()
####################################### URL Route handling #################################
@MicroWebSrv.route('/config')
def _httpHandlerConfig(httpClient, httpResponse, args={}) :
from utils import sys_config_html
content = """\
<!DOCTYPE html>
<html lang=en>
<head>
<meta charset="UTF-8" />
<title>CONFIG DUMP</title>
</head>
<body><PRE>"""
content += sys_config_html()
content += '<div style="alignt: center; text-align: center;">\n'
content += '<P><h3><a href="/stats">status</a></h3></P>'
content += "<br /><h5><a href=\"/config/reboot\">REBOOT?</A></h5>\n"
content += "</div>"
content += """\
</PRE>
</body>
</html>
"""
httpResponse.WriteResponseOk( headers = None,
contentType = "text/html",
contentCharset = "UTF-8",
content = content )
##############################################
@MicroWebSrv.route('/config/reboot')
@MicroWebSrv.route('/config/restart')
def _httpHandlerReboot(httpClient, httpResponse, args={}) :
from _thread import start_new_thread
start_new_thread(delayed_reboot, ())
content = """\
<!DOCTYPE html>
<html lang=en>
<head>
<meta charset="UTF-8" />
<meta http-equiv="refresh" content="8;url=/" />
<title>C U NEXT TUESDAY...</title>
</head>
<body><BR /><HR /><br />
<P><center><img src="/reboot.gif"></center></P>
<BR /><HR /><br /></body>
</html>
"""
httpResponse.WriteResponseOk( headers = None,
contentType = "text/html",
contentCharset = "UTF-8",
content = content )
############################################################
@MicroWebSrv.route('/config/toggleAP')
def _httpHandlerToggle(httpClient, httpResponse, args={}) :
from os import rename
apMode = None
try:
x = open('/client.cfg')
x.close()
apMode = False
rename("/client.cfg","/client.disable")
except:
try:
x = open('client.disable')
x.close()
apMode = True
rename("/client.disable","/client.cfg")
except:
return()
content = """\
<!DOCTYPE html>
<html lang=en>
<head>
<meta charset="UTF-8" />
<title>TEST EDIT</title>
</head>
<body>
"""
if(apMode):
content += "<H2>Switched to Wifi Client Mode</H2>"
content += '<div style="alignt: center; text-align: center;">\n'
content += '<P><h3><a href="/config/">config</a></h3></P>'
content += "<br /><h5><a href=\"/config/reboot\">REBOOT?</A></h5>\n"
content += "</div>"
else:
content += "<H2>Switched to Wifi AP Mode</H2>"
content += '<div style="alignt: center; text-align: center;">\n'
content += '<P><h3><a href="/config/">config</a></h3></P>'
content += "<br /><h5><a href=\"/config/reboot\">REBOOT?</A></h5>\n"
content += "</div>"
content += """\
</body>
</html>
"""
httpResponse.WriteResponseOk( headers = None,
contentType = "text/html",
contentCharset = "UTF-8",
content = content )
##############################################
@MicroWebSrv.route('/config/<param>/<value>')
def _httpHandlerEditParams(httpClient, httpResponse, args={}) :
from utils import replaceLine, findValue
content = """\
<!DOCTYPE html>
<html lang=en>
<head>
<meta charset="UTF-8" />
<title>-=DAT CONFIG=-</title>
</head>
<body>
"""
content += "<h3>CONFIG UPDATE</h3>"
if 'param' in args :
param = args['param'].strip()
oldline = findValue('/config.py',param)
content += "<p>[config: {}]</p>".format(oldline)
content += "<br />"
if 'value' in args :
if(type(args['value']) == int):
value = str(args['value'])
else:
value = args['value'].strip()
content += "<p>[new value is {}]</p>".format(value)
content += "<br />"
if( ('value' in args) and ('param' in args) ):
#re = args['param'].strip() + " = ([A-Za-z\"]+)"
re = oldline
if((value == str(1)) or ('rue' in value)):
value = "True"
elif((value == str(0)) or ('alse' in value)):
value = "False"
else:
value = '"' + value + '"'
newline = args['param'].strip() + " = " + value + "\n"
content += "<P>" + newline + "</P><BR />"
print("CONFIGURE:",param,' - ',value,' - ', re, '\n',newline)
replaceLine("/config.py",re,newline)
content += "<p>parameters updated.</p>"
content += '<div style="alignt: center; text-align: center;">\n'
content += '<P><h3><a href="/config/">config</a></h3></P>'
content += "<br /><h5><a href=\"/config/reboot\">REBOOT?</A></h5>\n"
content += "</div>"
content += """
</body>
</html>
"""
httpResponse.WriteResponseOk( headers = None,
contentType = "text/html",
contentCharset = "UTF-8",
content = content )
############################################################
@MicroWebSrv.route('/config/<param>')
def _httpHandlerEditParams(httpClient, httpResponse, args={}) :
from utils import findValue
content = """\
<!DOCTYPE html>
<html lang=en>
<head>
<meta charset="UTF-8" />
<title>-=DAT CONFIG=-</title>
</head>
<body>
"""
content += "<h3>CONFIG REQUEST</h3>"
if 'param' in args :
param = args['param'].strip()
oldline = findValue('/config.py',param)
content += "<p>[config: {}]</p>".format(oldline)
content += "<br />"
content += '<div style="alignt: center; text-align: center;">\n'
content += "<P><h5><a href='/config/" + param + "/1'>enable</a> / <a href='/config/" + param + "/0'>disable</a></h5></P>"
content += '<P><h3><a href="/config/">config</a></h3></P>'
content += "</div>"
content += """
</body>
</html>
"""
httpResponse.WriteResponseOk( headers = None,
contentType = "text/html",
contentCharset = "UTF-8",
content = content )
############################################################
@MicroWebSrv.route('/stats')
@MicroWebSrv.route('/status')
def _httpHandlerStats(httpClient, httpResponse, args={}) :
from utils import sys_stats, sys_config
global MyName, debug, debugDNS, ip, runREPL, runDNS, runWeb, threaded
content = """\
<!DOCTYPE html>
<html lang=en>
<head>
<meta charset="UTF-8" />
<meta http-equiv="refresh" content="2" />
<title>STATUS O****M</title>
</head>
<body>
"""
content += "<h2>SYSTEM STATS</h2>\n<PRE>" + sys_stats() + "</PRE>\n"
content += "<H2>SYSTEM CONFIG</H2>\n<PRE>" + sys_config() + "</PRE>\n"
content += "<h5><a href='/config'>configure</a></h5>"
content += "<h3><a href='/'>HOME</a></h5>"
content += """
</body>
</html>
"""
httpResponse.WriteResponseOk( headers = None,
contentType = "text/html",
contentCharset = "UTF-8",
content = content )
############################################ End of Routes ##################################################
mws = MicroWebSrv(port=80, bindIP='0.0.0.0', webPath="/www")
mws.SetNotFoundPageUrl("http://"+ip)
print("web server starting at http://" + ip + "/ .")
mws.Start(threaded=threaded)
content = html)
# route handler for index.html with method POST
@MicroWebSrv.route('/', 'POST')
def _httpHandlerPost(httpClient, httpResponse) :
# read posted form data. If data (dictionary) received, convert to string and send threadMessage to mainThread
formData = httpClient.ReadRequestPostedFormData()
if formData:
print(formData)
message = str(formData)
_thread.sendmsg(_thread.getReplID(), message)
# get system time and save it t datetime_dict
datetime = utime.localtime()
#print(datetime)
datetime_dict = { "year" : datetime[0], "month" : datetime[1], "mday" : datetime[2],
"hour": datetime[3], "minute" : datetime[4], "second" : datetime[5],
"weekday" : datetime[6], "yearday" : datetime[7]}
htmlSite = htmlSite.format(**datetime_dict)
# send htmlSite as response to client
httpResponse.WriteResponseOk( headers = ({'Cache-Control': 'no-cache'}),
contentType = 'text/html',
contentCharset = 'UTF-8',
content = htmlSite)
# create instance of MicroWebSrv and start server
srv = MicroWebSrv(webPath = 'www')
srv.Start(threaded = srv_run_in_thread, stackSize= 8192)
from microWebSrv import MicroWebSrv mws = MicroWebSrv(routeHandlers=[], port=80, bindIP='0.0.0.0', webPath="/www") mws.Start(threaded=True)
class HttpServer:
def __init__(self, process_obj, wifi_obj, rtc_obj, user_settings_dict):
self.process = process_obj
self.wifi = wifi_obj
self.rtc = rtc_obj
self.settings = user_settings_dict
self.app = None
self.gravity_sg = None
self.set_temp = None
self.chamber_temp = None
self.wort_temp = None
self.time_mark = None
def start(self):
process = self.process
wifi = self.wifi
rtc = self.rtc
settings = self.settings
this = self
@MicroWebSrv.route('/connecttest')
def test_get(httpClient, httpResponse):
"""
测试前端和后端之间的网络连接
"""
httpResponse.WriteResponseOk()
# Define the web routes and functions
@MicroWebSrv.route('/overview')
def overview_get(httpClient, httpResponse):
"""
提供首页所有数据显示，前端每1分钟请求1次
"""
brewery_name = settings['breweryName']
wifi_connected = wifi.is_connected()
real_date = rtc.get_localdate()
real_time = rtc.get_localtime()
basic_info = {
'breweryName': brewery_name,
'wifiIsConnected': wifi_connected,
'realDate': real_date,
'realTime': real_time,
}
process_info = process.get_process_info()
overview = basic_info.copy()
overview.update(process_info)
# 以下数据更新用于前端绘制echarts折线图
this.set_temp = process_info.get('setTemp')
this.chamber_temp = process_info.get('chamberTemp')
this.wort_temp = process_info.get('wortTemp')
this.gravity_sg = process_info.get('hydrometerData').get(
'currentGravity')
this.time_mark = real_date + ' ' + real_time
httpResponse.WriteResponseJSONOk(obj=overview, headers=None)
@MicroWebSrv.route('/fermentation', 'POST')
def fermentation_post(httpClient, httpResponse):
"""
前台向后台提交发酵步骤数据，并且开始发酵过程
"""
json = httpClient.ReadRequestContentAsJSON()
beerName = json['beerName']
fermentationSteps = json['fermentationSteps']
try:
process.set_beer_name(beerName)
process.load_steps(fermentationSteps)
process.start()
except:
# throw 500 error code
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/abort')
def abort_get(httpClient, httpResponse):
try:
process.abort()
except:
# throw 500 error code
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/settings')
def settings_get(httpClient, httpResponse):
"""
从后台读取设置参数
"""
wifi_list = wifi.scan_wifi_list()
temp_sensor_list = process.fermenter_temp_ctrl.chamber_sensor.ds_obj.get_device_list(
)
# open user_settings.json and read settings
with open('user_settings.json', 'r') as f:
settings_dict = ujson.load(f)
wort_sensor_dev_num = settings_dict.get('wortSensorDev')
chamber_sensor_dev_num = settings_dict.get('chamberSensorDev')
wort_sensor_rom_code = ''
chamber_sensor_rom_code = ''
for sensor_dict in temp_sensor_list:
detail_list = sensor_dict.values()
if wort_sensor_dev_num in detail_list:
wort_sensor_rom_code = sensor_dict.get('label')
elif chamber_sensor_dev_num in detail_list:
chamber_sensor_rom_code = sensor_dict.get('label')
wort_sensor_dev = {
'value': wort_sensor_dev_num,
'label': wort_sensor_rom_code
}
chamber_sensor_dev = {
'value': chamber_sensor_dev_num,
'label': chamber_sensor_rom_code
}
settings_added = {
'wifiList': wifi_list,
'wortSensorDev': wort_sensor_dev,
'chamberSensorDev': chamber_sensor_dev,
'tempSensorList': temp_sensor_list
}
settings_combined = settings_dict.copy()
settings_combined.update(settings_added)
# settings_json = ujson.dumps(settings_combined)
httpResponse.WriteResponseJSONOk(obj=settings_combined,
headers=None)
# httpResponse.WriteResponseOk(
# headers=None,
# contentType="application/json",
# contentCharset="UTF-8",
# content=settings_json
# )
@MicroWebSrv.route('/settings', 'POST')
def settings_post(httpClient, httpResponse):
"""
向后台保存设置参数，并且重启ESP32
"""
# json = httpClient.ReadRequestContentAsJSON()
# settings_dict = ujson.loads(json)
settings_dict = httpClient.ReadRequestContentAsJSON()
settings_dict['wortSensorDev'] = settings_dict['wortSensorDev'][
'value']
settings_dict['chamberSensorDev'] = settings_dict[
'chamberSensorDev']['value']
try:
with open('user_settings.json', 'w') as f:
ujson.dump(settings_dict, f)
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/reboot')
def reboot_get(httpClient, httpResponse):
tim = machine.Timer(-1)
try:
tim.init(period=3000,
mode=machine.Timer.ONE_SHOT,
callback=lambda t: machine.reset())
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/wifi')
def wifi_get(httpClient, httpResponse):
"""
获取WIFI热点列表，用于刷新热点列表
"""
wifi_list = wifi.scan_wifi_list()
wifi_dict = {'wifiList': wifi_list}
httpResponse.WriteResponseJSONOk(obj=wifi_dict, headers=None)
@MicroWebSrv.route('/wifi', 'POST')
def wifi_post(httpClient, httpResponse):
"""
连接WIFI热点
"""
wifi_dict = httpClient.ReadRequestContentAsJSON()
try:
new_ip = wifi.sta_connect(wifi_dict['ssid'], wifi_dict['pass'])
except:
httpResponse.WriteResponseInternalServerError()
else:
if wifi.is_connected():
httpResponse.WriteResponseOk()
else:
httpResponse.WriteResponseInternalServerError()
@MicroWebSrv.route('/ip')
def ip_get(httpClient, httpResponse):
"""
获取IP地址
"""
ap_ip = wifi.get_ap_ip_addr()
sta_ip = wifi.get_sta_ip_addr()
sta_ssid = wifi.get_sta_ssid()
ip_dict = {'apIp': ap_ip, 'staIp': sta_ip, 'staSsid': sta_ssid}
httpResponse.WriteResponseJSONOk(obj=ip_dict, headers=None)
@MicroWebSrv.route('/ftp')
def ftp_get(httpClient, httpResponse):
"""
Start FTP service
"""
try:
import uftpd
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/mqtttest', 'POST')
def mqtt_post(httpClient, httpResponse):
"""
Send test message to MQTT server
"""
settings_dict = httpClient.ReadRequestContentAsJSON()
test_msg = ujson.dumps({'test-message': 200})
from mqtt_client import MQTT
try:
test_mqtt = MQTT(settings_dict)
test_mqtt.publish(test_msg)
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/actuator', 'POST')
def actuactor_post(httpClient, httpResponse):
"""
手动控制制冷压缩机或制热器，主要用于测试
"""
actuactor_dict = httpClient.ReadRequestContentAsJSON()
heater = process.fermenter_temp_ctrl.heater
cooler = process.fermenter_temp_ctrl.cooler
led = process.fermenter_temp_ctrl.led
try:
if actuactor_dict.get('element') == 'heater':
element = heater
else:
element = cooler
action = actuactor_dict.get('action')
if action:
element.force_on()
else:
element.force_off()
if heater.is_on() and not cooler.is_on():
led_color = 'red'
elif not heater.is_on() and cooler.is_on():
led_color = 'blue'
elif not heater.is_on() and not cooler.is_on():
led_color = 'green'
else:
led_color = 'orange'
led.set_color(led_color)
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/tempsensors', 'POST')
def temp_post(httpClient, httpResponse):
"""
获取温度传感器读数
"""
# 获取前端发来的设备序号
sensor_dict = httpClient.ReadRequestContentAsJSON()
new_wort_romcode = sensor_dict.get('wortSensorDev').get('value')
new_chamber_romcode = sensor_dict.get('chamberSensorDev').get(
'value')
# 获取温感对象实例
wort_sensor = process.fermenter_temp_ctrl.wort_sensor
chamber_sensor = process.fermenter_temp_ctrl.chamber_sensor
# 更新温感设备序号
wort_sensor.update_romcode(new_wort_romcode)
chamber_sensor.update_romcode(new_chamber_romcode)
try:
# 测量温度
wort_temp = wort_sensor.read_temp()
chamber_temp = chamber_sensor.read_temp()
except:
# throw 500 error code
httpResponse.WriteResponseInternalServerError()
else:
temp_dict = {
'wortTemp': wort_temp,
'chamberTemp': chamber_temp
}
httpResponse.WriteResponseJSONOk(obj=temp_dict, headers=None)
@MicroWebSrv.route('/hydrometer', 'POST')
def gravity_post(httpClient, httpResponse):
hydrometer_dict = httpClient.ReadRequestContentAsJSON()
process.save_hydrometer_data(hydrometer_dict)
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/chart')
def chart_get(httpClient, httpResponse):
data = {
'timeMark': this.time_mark,
'setTemp': this.set_temp,
'wortTemp': this.wort_temp,
'chamberTemp': this.chamber_temp,
'gravitySg': this.gravity_sg
}
httpResponse.WriteResponseJSONOk(obj=data, headers=None)
# Initialize the Web server
self.app = MicroWebSrv(webPath='/sd/www')
self.app.Start(threaded=True) # Starts the server
def stop(self):
if self.app:
self.app.Stop()
def is_started(self):
if self.app:
return self.app.IsStarted()
else:
return False
def _closedCallback(webSocket):
with _thread.allocate_lock():
websockets.remove(webSocket)
gc.collect()
print('closing stale websocket')
print('number of connections: {}'.format(len(websockets)))
print('free mem: {}'.format(gc.mem_free()))
def _acceptWebSocketCallback(webSocket, httpClient):
with _thread.allocate_lock():
websockets.append(webSocket)
gc.collect()
print('new connection from {}'.format(httpClient.GetIPAddr()))
print('number of connections: {}'.format(len(websockets)))
webSocket.RecvTextCallback = _recvTextCallback
webSocket.ClosedCallback = _closedCallback
webSocket.SendText(str(hue))
print('free mem: {}'.format(gc.mem_free()))
mws = MicroWebSrv(webPath='/www')
mws.MaxWebSocketRecvLen = 256
mws.AcceptWebSocketCallback = _acceptWebSocketCallback
mws.Start()
_thread.start_new_thread(run_main_loop, ())
def run(self):
mws = MicroWebSrv(routeHandlers=self.routeHandlers, webPath="/flash/www")
mws.Start(threaded=True)
gc.collect()
color_name = all_colors_json.keys()[all_colors_json.values().index(
color)]
httpResponse.WriteResponseJSONError(409,
obj={
"error":
"Color already exists",
"content": color_name
})
#send color already exists error with name
else:
colors_raw['user_set'].update({name: color})
with open('/JSON-files/colors.json', 'w') as colors_json:
json.dump(colors_raw, colors_json)
httpResponse.WriteResponseJSONOk()
with open('/JSON-files/colors.json') as colors_json:
print(json.load(colors_json))
def _httpHandlerColorTryPost(httpClient, httpResponse):
content = httpClient.ReadRequestContent() # Read JSON color data
colors = json.loads(content)
show_color(colors['color'])
httpResponse.WriteResponseJSONOk()
routeHandlers = [("/color-try", "POST", _httpHandlerColorTryPost),
("/color-append", "POST", _httpHandlerAddColorPost),
("/colors-json", "GET", _httpHandlerJsoncolorRequest)]
srv = MicroWebSrv(routeHandlers=routeHandlers, webPath='/www/')
srv.Start(threaded=False)
class HttpServer:
def __init__(self, gy521_obj, wifi_obj, user_settings_dict):
self.gy521 = gy521_obj
self.wifi = wifi_obj
self.settings = user_settings_dict
self.app = None
def start(self):
gy521 = self.gy521
wifi = self.wifi
settings = self.settings
@MicroWebSrv.route('/connecttest')
def test_get(httpClient, httpResponse):
"""
测试前端和后端之间的网络连接
"""
httpResponse.WriteResponseOk()
# Define the web routes and functions
@MicroWebSrv.route('/tilt')
def tilt_get(httpClient, httpResponse):
"""
读取比重计倾角，前端每10秒请求1次
"""
try:
_, tilt, _ = gy521.read_angles()
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseJSONOk(obj={'tilt': tilt},
headers=None)
@MicroWebSrv.route('/calibration', 'POST')
def calibration_post(httpClient, httpResponse):
"""
前台进行倾角与比重的拟合计算后，将比重单位和拟合系数发回后台保存
"""
result = httpClient.ReadRequestContentAsJSON()
try:
with open('regression.json', 'w') as f:
ujson.dump(result, f)
except:
# throw 500 error code
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/calibration')
def calibration_get(httpClient, httpResponse):
"""
将上一次保存的校准参数从json文件中读取并发送到前台
"""
try:
with open('regression.json', 'r') as f:
params = ujson.load(f)
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseJSONOk(obj={'params': params},
headers=None)
@MicroWebSrv.route('/settings')
def settings_get(httpClient, httpResponse):
"""
从后台读取设置参数
"""
wifi_list = wifi.scan_wifi_list()
settings_added = {'wifiList': wifi_list}
settings_combined = settings.copy()
settings_combined.update(settings_added)
httpResponse.WriteResponseJSONOk(obj=settings_combined,
headers=None)
@MicroWebSrv.route('/settings', 'POST')
def settings_post(httpClient, httpResponse):
"""
向后台保存设置参数
"""
settings_dict = httpClient.ReadRequestContentAsJSON()
try:
with open('user_settings.json', 'w') as f:
ujson.dump(settings_dict, f)
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/reboot')
def reboot_get(httpClient, httpResponse):
"""
重启ESP32
"""
tim = machine.Timer(-1)
try:
tim.init(period=3000,
mode=machine.Timer.ONE_SHOT,
callback=lambda t: machine.reset())
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/deepsleep')
def deepsleep_get(httpClient, httpResponse):
"""
使ESP32进入深度睡眠，唤醒后便进入工作模式
"""
with open('hardware_config.json', 'r') as f:
json = f.read()
config = ujson.loads(json)
FIRSTSLEEP_TRIGGER = config['firstsleep_trigger']
def first_sleep():
with open(FIRSTSLEEP_TRIGGER, 'w') as s:
pass
machine.reset()
tim = machine.Timer(-1)
try:
tim.init(period=3000,
mode=machine.Timer.ONE_SHOT,
callback=lambda t: first_sleep())
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/wifi')
def wifi_get(httpClient, httpResponse):
"""
获取WIFI热点列表，用于刷新热点列表
"""
wifi_list = wifi.scan_wifi_list()
wifi_dict = {'wifiList': wifi_list}
httpResponse.WriteResponseJSONOk(obj=wifi_dict, headers=None)
@MicroWebSrv.route('/wifi', 'POST')
def wifi_post(httpClient, httpResponse):
"""
连接WIFI热点
"""
wifi_dict = httpClient.ReadRequestContentAsJSON()
new_ip = wifi.sta_connect(wifi_dict['ssid'], wifi_dict['pass'])
if new_ip:
# 200
httpResponse.WriteResponseOk()
else:
# throw 500 error code
httpResponse.WriteResponseInternalServerError()
@MicroWebSrv.route('/ftp')
def ftp_get(httpClient, httpResponse):
"""
Start FTP service
"""
with open('hardware_config.json', 'r') as f:
json = f.read()
config = ujson.loads(json)
FTP_TRIGGER = config['ftp_trigger']
def start_ftp():
with open(FTP_TRIGGER, 'w') as s:
pass
machine.reset()
tim = machine.Timer(-1)
try:
tim.init(period=3000,
mode=machine.Timer.ONE_SHOT,
callback=lambda t: start_ftp())
except:
httpResponse.WriteResponseInternalServerError()
else:
httpResponse.WriteResponseOk()
@MicroWebSrv.route('/mqtttest', 'POST')
def mqtt_post(httpClient, httpResponse):
"""
Send test message to MQTT server
"""
settings_dict = httpClient.ReadRequestContentAsJSON()
test_msg = {'test-message': 200}
str_data = ujson.dumps(test_msg)
from mqtt_client import MQTT
try:
client = MQTT(settings_dict)
client.publish(str_data)
except:
print('Failed to send the message to the MQTT broker.')
httpResponse.WriteResponseInternalServerError()
else:
print('The test message has been sent successfully.')
httpResponse.WriteResponseOk()
# Initialize the Web server
self.app = MicroWebSrv(webPath='/www')
self.app.Start(threaded=True) # Starts the server
def stop(self):
if self.app:
self.app.Stop()
def is_started(self):
if self.app:
return self.app.IsStarted()
else:
return False
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()
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)
# ----------------------------------------------------------------------------
class WebThingServer:
"""Server to represent a Web Thing over HTTP."""
def __init__(self, things, port=80, hostname=None, ssl_options=None,
additional_routes=None):
"""
Initialize the WebThingServer.
For documentation on the additional route format, see:
https://github.com/loboris/MicroPython_ESP32_psRAM_LoBo/wiki/microWebSrv
things -- list of Things managed by this server
port -- port to listen on (defaults to 80)
hostname -- Optional host name, i.e. mything.com
ssl_options -- dict of SSL options to pass to the tornado server
additional_routes -- list of additional routes to add to the server
"""
self.ssl_suffix = '' if ssl_options is None else 's'
self.things = things
self.name = things.get_name()
self.port = port
self.hostname = hostname
station = network.WLAN()
mac = station.config('mac')
self.system_hostname = 'esp32-upy-{:02x}{:02x}{:02x}'.format(
mac[3], mac[4], mac[5])
self.hosts = [
'localhost',
'localhost:{}'.format(self.port),
'{}.local'.format(self.system_hostname),
'{}.local:{}'.format(self.system_hostname, self.port),
]
for address in get_addresses():
self.hosts.extend([
address,
'{}:{}'.format(address, self.port),
])
if self.hostname is not None:
self.hostname = self.hostname.lower()
self.hosts.extend([
self.hostname,
'{}:{}'.format(self.hostname, self.port),
])
if isinstance(self.things, MultipleThings):
log.info('Registering multiple things')
for idx, thing in enumerate(self.things.get_things()):
thing.set_href_prefix('/{}'.format(idx))
handlers = [
(
'/',
'GET',
self.thingsGetHandler
),
(
'/<thing_id>',
'GET',
self.thingGetHandler
),
(
'/<thing_id>/properties',
'GET',
self.propertiesGetHandler
),
(
'/<thing_id>/properties/<property_name>',
'GET',
self.propertyGetHandler
),
(
'/<thing_id>/properties/<property_name>',
'PUT',
self.propertyPutHandler
),
]
else:
log.info('Registering a single thing')
handlers = [
(
'/',
'GET',
self.thingGetHandler
),
(
'/properties',
'GET',
self.propertiesGetHandler
),
(
'/properties/<property_name>',
'GET',
self.propertyGetHandler
),
(
'/properties/<property_name>',
'PUT',
self.propertyPutHandler
),
]
if isinstance(additional_routes, list):
handlers = additional_routes + handlers
self.server = MicroWebSrv(webPath='/flash/www',
routeHandlers=handlers,
port=port)
self.server.MaxWebSocketRecvLen = 256
self.WebSocketThreaded = ws_run_in_thread
self.server.WebSocketStackSize = 8 * 1024
self.server.AcceptWebSocketCallback = self._acceptWebSocketCallback
def start(self):
"""Start listening for incoming connections."""
# If WebSocketS used and NOT running in thread, and WebServer IS
# running in thread make shure WebServer has enough stack size to
# handle also the WebSocket requests.
log.info('Starting Web Server on port {}'.format(self.port))
self.server.Start(threaded=srv_run_in_thread, stackSize=12*1024)
mdns = network.mDNS()
mdns.start(self.system_hostname, 'MicroPython with mDNS')
mdns.addService('_webthing', '_tcp', 80, self.system_hostname,
{
'board': 'ESP32',
'path': '/',
})
def stop(self):
"""Stop listening."""
self.server.Stop()
def getThing(self, routeArgs):
"""Get the thing ID based on the route."""
thing_id = routeArgs['thing_id'] if 'thing_id' in routeArgs else None
return self.things.get_thing(thing_id)
def getProperty(self, routeArgs):
"""Get the property name based on the route."""
thing = self.getThing(routeArgs)
if thing:
property_name = routeArgs['property_name']
if thing.has_property(property_name):
return thing, thing.find_property(property_name)
return None, None
def validateHost(self, headers):
"""Validate the Host header in the request."""
host = headers.get('host', None)
if host is not None and host.lower() in self.hosts:
return True
return False
@print_exc
def thingsGetHandler(self, httpClient, httpResponse):
"""Handle a request to / when the server manages multiple things."""
if not self.validateHost(httpClient.GetRequestHeaders()):
httpResponse.WriteResponseError(403)
return
ws_href = 'ws{}://{}'.format(
self.ssl_suffix,
httpClient.GetRequestHeaders().get('host', '')
)
descriptions = []
for thing in self.things.get_things():
description = thing.as_thing_description()
description['links'].append({
'rel': 'alternate',
'href': '{}{}'.format(ws_href, thing.get_href()),
})
descriptions.append(description)
httpResponse.WriteResponseJSONOk(
obj=descriptions,
headers=_CORS_HEADERS,
)
@print_exc
def thingGetHandler(self, httpClient, httpResponse, routeArgs=None):
"""Handle a GET request for an individual thing."""
if not self.validateHost(httpClient.GetRequestHeaders()):
httpResponse.WriteResponseError(403)
return
thing = self.getThing(routeArgs)
if thing is None:
httpResponse.WriteResponseNotFound()
return
ws_href = 'ws{}://{}'.format(
self.ssl_suffix,
httpClient.GetRequestHeaders().get('host', '')
)
description = thing.as_thing_description()
description['links'].append({
'rel': 'alternate',
'href': '{}{}'.format(ws_href, thing.get_href()),
})
httpResponse.WriteResponseJSONOk(
obj=description,
headers=_CORS_HEADERS,
)
@print_exc
def propertiesGetHandler(self, httpClient, httpResponse, routeArgs=None):
"""Handle a GET request for a property."""
thing = self.getThing(routeArgs)
if thing is None:
httpResponse.WriteResponseNotFound()
return
httpResponse.WriteResponseJSONOk(thing.get_properties())
@print_exc
def propertyGetHandler(self, httpClient, httpResponse, routeArgs=None):
"""Handle a GET request for a property."""
if not self.validateHost(httpClient.GetRequestHeaders()):
httpResponse.WriteResponseError(403)
return
thing, prop = self.getProperty(routeArgs)
if thing is None or prop is None:
httpResponse.WriteResponseNotFound()
return
httpResponse.WriteResponseJSONOk(
obj={prop.get_name(): prop.get_value()},
headers=_CORS_HEADERS,
)
@print_exc
def propertyPutHandler(self, httpClient, httpResponse, routeArgs=None):
"""Handle a PUT request for a property."""
if not self.validateHost(httpClient.GetRequestHeaders()):
httpResponse.WriteResponseError(403)
return
thing, prop = self.getProperty(routeArgs)
if thing is None or prop is None:
httpResponse.WriteResponseNotFound()
return
args = httpClient.ReadRequestContentAsJSON()
if args is None:
httpResponse.WriteResponseBadRequest()
return
try:
prop.set_value(args[prop.get_name()])
except PropertyError:
httpResponse.WriteResponseBadRequest()
return
httpResponse.WriteResponseJSONOk(
obj={prop.get_name(): prop.get_value()},
headers=_CORS_HEADERS,
)
# === MicroWebSocket callbacks ===
@print_exc
def _acceptWebSocketCallback(self, webSocket, httpClient):
reqPath = httpClient.GetRequestPath()
if WS_messages:
print('WS ACCEPT reqPath =', reqPath)
if ws_run_in_thread or srv_run_in_thread:
# Print thread list so that we can monitor maximum stack size
# of WebServer thread and WebSocket thread if any is used
_thread.list()
webSocket.RecvTextCallback = self._recvTextCallback
webSocket.RecvBinaryCallback = self._recvBinaryCallback
webSocket.ClosedCallback = self._closedCallback
things = self.things.get_things()
if len(things) == 1:
thing_id = 0
else:
thing_id = int(reqPath.split('/')[1])
thing = things[thing_id]
webSocket.thing = thing
thing.add_subscriber(webSocket)
@print_exc
def _recvTextCallback(self, webSocket, msg):
if WS_messages:
print('WS RECV TEXT : %s' % msg)
@print_exc
def _recvBinaryCallback(self, webSocket, data):
if WS_messages:
print('WS RECV DATA : %s' % data)
@print_exc
def _closedCallback(self, webSocket):
if WS_messages:
if ws_run_in_thread or srv_run_in_thread:
_thread.list()
print('WS CLOSED')
from microWebSrv import MicroWebSrv
import esp32
# ----------------------------------------------------------------------------
@MicroWebSrv.route('/temperature')
def _httpHandlerTempGet(httpClient, httpResponse):
temp = (esp32.raw_temperature() - 32) * 5.0 / 9.0
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="Temperatur ist: {}".format(temp))
srv = MicroWebSrv(webPath='www/')
srv.MaxWebSocketRecvLen = 256
srv.WebSocketThreaded = False
srv.Start()
# ----------------------------------------------------------------------------
ssid_file.close()
except:
Log.i("Cant save the new ssid")
wlan.deinit()
wlan = WLAN(mode=WLAN.AP,
ssid=lopy_ssid,
auth=(WLAN.WPA2, config.WIFI_PASS),
channel=11,
antenna=WLAN.INT_ANT)
wlan.ifconfig(id=1,
config=(config.API_HOST, '255.255.255.0', '10.42.31.1',
'8.8.8.8'))
mws = MicroWebSrv() # TCP port 80 and files in /flash/www
mws.Start(threaded=True) # Starts server in a new
############################################################################
############################## MONITORING REQ ##############################
def sendToMonitors(req: str, typeRequest: str):
global lora_monitors_ip
for monitor in lora_monitors_ip:
wCli = MicroWebCli("http://" + monitor + ":6666/lopyrequests",
method='POST')
try:
wCli.OpenRequestFormData(formData={
'type': typeRequest,
'request': ubinascii.b2a_base64(req)
})
