def handle_log(httpResponse):
ws.navMenuIndex = 7
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
ws.TXBuffer += "<table class=\"normal\"><TR><TH id=\"headline\" align=\"left\">Log"
ws.addCopyButton("copyText", "", "Copy log to clipboard")
ws.TXBuffer += "</TR></table><div id='current_loglevel' style='font-weight: bold;'>Logging: </div><div class='logviewer' id='copyText_1'>"
for l in misc.SystemLog:
ws.TXBuffer += '<div class="level_{0}"><font color="gray">{1}</font> {2}</div>'.format(
l["lvl"], l["t"], l["l"])
ws.TXBuffer += "</div><BR>"
ws.TXBuffer += '<script type="text/javascript">var rtimer; function refreshpage() {window.location.reload(true);}'
ws.TXBuffer += "function checkit(){ if (document.getElementById('autoscroll').checked) {rtimer = setInterval(refreshpage,20000);} else {clearInterval(rtimer);}}</script>"
ws.TXBuffer += "Autoscroll: <label class='container'> <input type='checkbox' id='autoscroll' name='autoscroll' checked onclick='checkit();'><span class='checkmark'></span></label>"
ws.TXBuffer += "<script defer>checkit();copyText_1.scrollTop = 99999;</script>"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_sysvars(httpResponse):
ws.navMenuIndex = 7
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
ws.TXBuffer += "<table class='normal'><TR><TH align='left'>System Variables<TH align='left'>Normal"
for sv in commands.SysVars:
ws.TXBuffer += "<TR><TD>%" + sv + "%</TD><TD>"
ws.TXBuffer += str(commands.getglobalvar(sv)) + "</TD></TR>"
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
conversions = [
"%c_m2day%(%uptime%)", "%c_m2dh%(%uptime%)", "%c_m2dhm%(%uptime%)"
]
for sv in conversions:
try:
ws.TXBuffer += "<TR><TD>" + sv + "</TD><TD>"
ws.TXBuffer += str(commands.parseruleline(sv)[0]) + "</TD></TR>"
except:
pass
ws.TXBuffer += "</table></form>"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_ota(httpResponse):
ws.navMenuIndex = 7
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
try:
pm = PartMgr.partmgr()
op = pm.isotasupported()
pi = op.info()[3]
except:
pm = None
op = False
pi = 0
oi = ""
if op == False:
oi = "NOT "
ws.TXBuffer += "<p>OTA {0}SUPPORTED! Free space: {1} bytes".format(oi, pi)
ws.TXBuffer += "<p><form enctype='multipart/form-data' method='post'><p>Upload file:<br><input type='file' name='firmware.bin' id='ffile'></p><div><input class='button link' type='submit' value='Upload'></div></form>"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_command(httpResponse, responsearr):
ws.navMenuIndex = 0
ws.TXBuffer = ""
responsestr = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
try:
cmdline = ws.arg("cmd", responsearr).strip()
if cmdline.startswith('reboot'):
ws.sendHeadandTail("TmplStd", ws._TAIL)
if len(cmdline) > 0:
responsestr = str(commands.doExecuteCommand(cmdline))
except:
pass
if len(responsestr) > 0:
ws.TXBuffer += "<P>{0}<p>".format(responsestr)
if responsestr == False:
ws.TXBuffer += "FAILED"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_wifiscan(httpResponse):
ws.navMenuIndex = 7
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
try:
sw2 = unet.wifi_sta.scan()
except Exception as e:
ws.TXBuffer += "<p>{0}".format(e)
sw2 = []
if sw2:
ws.TXBuffer += "<table class='multirow'><TR><TH>SSID<TH>BSSID<TH>Security<TH>Channel<TH>Strength</TH></TR>"
if len(sw2) > 0:
adata = []
amac = ""
security = ["open", "WEP", "WPA-PSK", "WPA2-PSK", "WPA/WPA2-PSK"]
for w in range(len(sw2)):
try:
adata = sw2[w]
amac = '{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}'.format(
adata[1][0], adata[1][1], adata[1][2], adata[1][3],
adata[1][4], adata[1][5])
ws.TXBuffer += "<tr><td>{0}<td>{1}<td>{2}<td>{3}<td>{4}</tr>".format(
adata[0].decode("utf-8"), amac, security[adata[4]],
adata[2], adata[3])
except:
pass
ws.TXBuffer += "</table>"
else:
ws.TXBuffer += "<p>No Access Points found"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_rules(httpResponse, responsearr):
ws.navMenuIndex = 5
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
rules = ""
saved = ws.arg("Submit", responsearr)
if (saved):
rules = ws.arg("rules", responsearr)
try:
with open(pglobals.FILE_RULES, 'w') as f:
f.write(rules)
except:
pass
if len(rules) > 0:
commands.splitruletoevents(rules)
if rules == "":
try:
with open(pglobals.FILE_RULES, 'r') as f:
rules = f.read()
except:
pass
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = "<form name = 'frmselect' method = 'post'><table class='normal'><TR><TH align='left'>Rules<tr><td><textarea name='rules' rows='30' wrap='off'>{0}</textarea>".format(
rules)
ws.addFormSeparator(2)
ws.addSubmitButton()
ws.TXBuffer += "</table></form>"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_config(httpResponse, responsearr):
ws.navMenuIndex = 1
saved = ws.arg("Submit", responsearr)
if (saved):
settings.Settings["Name"] = ws.arg("name",
responsearr).replace(" ", "")
settings.Settings["Unit"] = ws.arg("unit", responsearr)
tpw = ws.arg("password", responsearr)
if "**" not in tpw:
settings.Settings["Password"] = tpw
tpw = ws.arg("apkey", responsearr)
if "**" not in tpw:
settings.Settings['APKEY'] = tpw
settings.Settings['APSSID'] = ws.arg("apssid", responsearr)
settings.Settings['AP1SSID'] = ws.arg("ssid", responsearr)
settings.Settings['AP2SSID'] = ws.arg("ssid2", responsearr)
tpw = ws.arg("apkey", responsearr)
if "**" not in tpw:
settings.Settings["APKEY"] = tpw
tpw = ws.arg("key", responsearr)
if "**" not in tpw:
settings.Settings["AP1KEY"] = tpw
tpw = ws.arg("key2", responsearr)
if "**" not in tpw:
settings.Settings["AP2KEY"] = tpw
settings.Settings['WifiClient'] = (ws.arg("wifista",
responsearr) == "on")
settings.Settings['WifiAP'] = int(ws.arg("apmode", responsearr))
settings.Settings['APCAPTIVE'] = (ws.arg("ap_captive",
responsearr) == "on")
settings.Settings['WDHCP'] = (ws.arg("w_dhcp", responsearr) == "on")
if settings.Settings['WDHCP'] == False:
settings.Settings['WIP'] = ws.arg("w_ip", responsearr)
settings.Settings['WMask'] = ws.arg("w_mask", responsearr)
settings.Settings['WGW'] = ws.arg("w_gw", responsearr)
settings.Settings['WDNS'] = ws.arg("w_dns", responsearr)
settings.Settings['LANIF'] = (ws.arg("lanif", responsearr) == "on")
if settings.Settings['LANIF']:
settings.Settings['LDHCP'] = (ws.arg("l_dhcp",
responsearr) == "on")
if settings.Settings['LDHCP'] == False:
settings.Settings['LIP'] = ws.arg("l_ip", responsearr)
settings.Settings['LMask'] = ws.arg("l_mask", responsearr)
settings.Settings['LGW'] = ws.arg("l_gw", responsearr)
settings.Settings['LDNS'] = ws.arg("l_dns", responsearr)
settings.savesettings()
else:
settings.loadsettings()
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
ws.TXBuffer += "<form name='frmselect' method='post'><table class='normal'>"
ws.addFormHeader("Main Settings")
ws.addFormTextBox("Unit Name", "name", settings.Settings["Name"], 25)
ws.addFormNumericBox("Unit Number", "unit", settings.Settings["Unit"], 0,
256)
ws.addFormPasswordBox("Admin Password", "password",
settings.Settings["Password"], 25)
ws.addFormSeparator(2)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
ws.addFormSubHeader("Wifi STA Settings")
ws.addFormCheckBox("Enable Wifi STA mode", "wifista",
settings.Settings["WifiClient"])
ws.addFormTextBox("SSID", "ssid", settings.Settings["AP1SSID"], 32)
ws.addFormPasswordBox("Wifi Key", "key", settings.Settings["AP1KEY"], 64)
ws.addFormTextBox("Fallback SSID", "ssid2", settings.Settings["AP2SSID"],
32)
ws.addFormPasswordBox("Fallback Wifi Key", "key2",
settings.Settings["AP2KEY"], 64)
ws.addFormCheckBox("DHCP", "w_dhcp", settings.Settings["WDHCP"])
ws.addFormNote(
"If DHCP enabled the settings below will not be saved or used!")
ws.addFormTextBox("IP", "w_ip", settings.Settings["WIP"], 15)
ws.addFormTextBox("Mask", "w_mask", settings.Settings["WMask"], 15)
ws.addFormTextBox("GW", "w_gw", settings.Settings["WGW"], 15)
ws.addFormTextBox("DNS", "w_dns", settings.Settings["WDNS"], 128)
ws.addFormSubHeader("Wifi AP Settings")
options = [
"Disable", "At startup always", "When Wifi STA not connected",
"When LAN not connected"
]
optionvalues = [0, 1, 2, 4]
ws.addFormSelector("Start AP when", "apmode", len(optionvalues), options,
optionvalues, None, int(settings.Settings["WifiAP"]))
ws.addFormTextBox("SSID", "apssid", settings.Settings["APSSID"], 32)
ws.addFormPasswordBox("Wifi Key", "apkey", settings.Settings["APKEY"], 64)
try:
tpw = settings.Settings["APCAPTIVE"]
except:
tpw = False
ws.addFormCheckBox("Captive AP", "ap_captive", tpw)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
if int(settings.HW["lan-phy"]) > -1:
ws.addFormSubHeader("LAN Settings")
ws.addFormCheckBox("Enable LAN", "lanif", settings.Settings["LANIF"])
ws.addFormCheckBox("DHCP", "l_dhcp", settings.Settings["LDHCP"])
ws.addFormNote(
"If DHCP enabled the settings below will not be saved or used!")
ws.addFormTextBox("IP", "l_ip", settings.Settings["LIP"], 15)
ws.addFormTextBox("Mask", "l_mask", settings.Settings["LMask"], 15)
ws.addFormTextBox("GW", "l_gw", settings.Settings["LGW"], 15)
ws.addFormTextBox("DNS", "l_dns", settings.Settings["LDNS"], 128)
ws.TXBuffer += "<TR><TD style='width:150px;' align='left'><TD>"
ws.addSubmitButton()
ws.TXBuffer += "</table></form>"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_upload(httpClient, httpResponse):
ws.navMenuIndex = 7
ws.TXBuffer = ""
try:
import inc.lib_blehelper as BLEHelper
_blestatus = BLEHelper.BLEStatus
except:
_blestatus = None
if _blestatus is not None:
try:
if _blestatus.isscaninprogress(): #ble scan interferes ota
_blestatus.requeststopscan(1)
import time
time.sleep(1)
if _blestatus.isscaninprogress():
_blestatus.forcestopscan()
except:
pass
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
ws.TXBuffer += '<label for="file">File progress:</label><progress id="file" max="100" value="0"><span>0</span>%</progress>'
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
buf = bytearray(4096)
buf2 = bytearray(4096)
try:
pm = PartMgr.OTA()
pm.initota()
otaok = pm.success
except:
pm = None
otaok = False
if otaok == False:
secok = False
ws.TXBuffer += "<p>OTA init failed!"
try:
SEC_SIZE = pm.SEC_SIZE
except:
SEC_SIZE = 4096
percent = 0
secok = True
hok = False
lpage = False
rsize = SEC_SIZE
block = -1
try:
fs = httpClient.GetRequestContentLength()
except:
fs = -1
if fs is None or fs <= 0:
secok = False
ws.TXBuffer += "<p>Browser did not sent upload size! Canceling upload."
gptr = 0
fptr = 0
prevperc = 0
imageok = True
while secok:
if gptr + rsize > fs:
rsize = fs - gptr
lpage = True
if rsize < 1:
rsize = None
try:
buf = httpClient.ReadRequestContent(size=rsize) #read header
except:
secok = False
if len(buf) < 1:
secok = False
if secok:
gptr += len(buf)
if lpage: #last page
hend = buf.find(b'\r\n--') # search header
if hend:
buf = buf[:hend]
rsize = None
percent = 100
if hok == False: #first page
hend = buf.find(b'\r\n\r\n') # search header
if hend:
buf2 = buf[(hend + 4):]
hok = True
rsize = SEC_SIZE - len(buf2)
else:
rsize = SEC_SIZE
else: # file content
rsize = SEC_SIZE
if len(buf2) > 0: #1st sector
buf = buf2 + buf
buf2 = bytearray()
fptr += len(buf)
block += 1
if percent < 100:
percent = int(gptr * 100 / fs)
try:
if imageok:
if block >= 15:
if block == 15:
if int(buf[0]) != 233:
imageok = False
print("start block", block, block - 15,
buf[0]) #debug
if len(buf) < SEC_SIZE:
buf2 = bytearray(SEC_SIZE - len(buf))
buf = buf + buf2
pm.writedata(block - 15, buf)
except:
imageok = False
if prevperc != percent:
print("---->", percent, gptr, fptr, len(buf),
block) # debug
ws.TXBuffer += '<script type="text/javascript">var i = '
ws.TXBuffer += str(percent)
ws.TXBuffer += ';var progressBar = document.getElementById("ffile");progressBar.value = i;progressBar.getElementsByTagName("span")[0].textContent = i;</script>'
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
prevperc = percent
try:
if pm.success == False or imageok == False:
percent = 0
except:
percent = 0
if percent == 100:
try:
pm.endota()
except:
pass
ws.TXBuffer += "<p>Upload completed! "
ws.TXBuffer += " <a class='button link wide' href='/?cmd=reboot'>Reboot</a>"
else:
ws.TXBuffer += "<p>Upload failed!"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_blescan(httpResponse):
global bleok
ws.navMenuIndex = 7
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
if bleok:
try:
BLEHelper.BLEStatus.reportscan(1)
scanner = BTLE.Scanner(ubluetooth.BLE())
devices = scanner.scan(15, passive=False)
BLEHelper.BLEStatus.reportscan(0)
except Exception as e:
ws.TXBuffer += "BLE scanning failed "
ws.TXBuffer += str(e)
bleok = False
else:
ws.TXBuffer += "BLE not supported"
if bleok:
ws.TXBuffer += "<table class='multirow'><TR><TH>Address<TH>Address type<TH>RSSI<TH>Connectable<TH>Name<TH>Appearance</TH><TH>Actions</TH></TR>"
cc = 0
for dev in devices:
cc += 1
ws.TXBuffer += "<TR><TD><div id='mac" + str(
cc) + "_1' name='mac" + str(cc) + "_1'>" + str(
dev.addr) + "</div><TD>" + str(
dev.addrType) + "<TD>" + str(
dev.rssi) + " dBm<TD>" + str(dev.connectable)
dname = ""
shortdname = ""
appear = ""
for (adtype, desc, value) in dev.getScanData():
# print(adtype,desc,value)#debug
try:
if desc.lower() == "complete local name":
dname = str(value)
except:
pass
try:
if desc.lower() == "shortened local name":
shortdname = str(value)
except:
pass
try:
if desc.lower() == "appearance":
appear = str(value)
except:
pass
if dname.strip() == "":
dname = shortdname
ws.TXBuffer += "<TD>" + str(dname) + "<TD>" + str(appear) + "<TD>"
ws.TXBuffer += "</TR>"
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
ws.TXBuffer += "</table>"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_notif(httpResponse,responsearr):
edit = ws.arg("edit",responsearr)
nindex = ws.arg("index",responsearr)
nNotSet = (nindex == 0) or (nindex == '')
if nindex!="":
nindex = int(nindex) - 1
enabled = (ws.arg("nenabled",responsearr)=="on")
protocol = ws.arg("protocol",responsearr)
if protocol!="":
protocol=int(protocol)
else:
protocol=0
if ((protocol == 0) and (edit=='') and (nindex!='')) or (ws.arg('del',responsearr) != ''):
try:
settings.Notifiers[nindex].plugin_exit()
except:
pass
settings.Notifiers[nindex] = False
nNotSet = True
settings.savenotifiers()
if (nNotSet==False): # submitted
if (protocol > 0): # submitted
try:
if (settings.Notifiers[nindex]):
settings.Notifiers[nindex].enabled = enabled
settings.Notifiers[nindex].webform_save(responsearr)
settings.savenotifiers()
except:
pass
else:
try:
if (settings.Notifiers[nindex]):
protocol = settings.Notifiers[nindex].number
except:
pass
ws.TXBuffer = ""
httpResponse.WriteResponseOk(
headers = ({'Cache-Control': 'no-cache'}),
contentType = 'text/html',
contentCharset = 'UTF-8',
content = "" )
ws.navMenuIndex=6
ws.sendHeadandTail("TmplStd",ws._HEAD)
ws.TXBuffer += "<form name='frmselect' method='post'>"
if (nNotSet): # show all in table
ws.TXBuffer += "<table class='multirow' border=1px frame='box' rules='all'><TR><TH style='width:70px;'><TH style='width:50px;'>Nr<TH style='width:100px;'>Enabled<TH>Service<TH>ID"
for x in range(pglobals.NOTIFICATION_MAX):
ws.TXBuffer += "<tr><td><a class='button link' href=\"notifications?index={0}&edit=1\">Edit</a><td>{0}</td><td>".format(x+1)
try:
if (settings.Notifiers[x]):
ws.addEnabled(settings.Notifiers[x].enabled)
ws.TXBuffer += "</td><td>{0}</td><td>{1}".format(settings.Notifiers[x].getdevicename(),settings.Notifiers[x].getuniquename())
else:
ws.TXBuffer += "<td><td>"
except:
ws.TXBuffer += "<td><td>"
ws.TXBuffer += "</table></form>"
else: # edit
ws.TXBuffer += "<table class='normal'><TR><TH style='width:150px;' align='left'>Notification Settings<TH><tr><td>Notification:<td>"
ws.addSelector_Head("protocol", True)
for x in range(len(pglobals.notifierselector)):
ws.addSelector_Item(pglobals.notifierselector[x][2],int(pglobals.notifierselector[x][1]),(str(protocol) == str(pglobals.notifierselector[x][1])),False,"")
ws.addSelector_Foot()
if (int(protocol) > 0):
createnewn = True
try:
if (settings.Notifiers[nindex].getnpluginid()==int(protocol)):
createnewn = False
except:
pass
exceptstr = ""
if createnewn:
for y in range(len(pglobals.notifierselector)):
if int(pglobals.notifierselector[y][1]) == int(protocol):
if len(settings.Notifiers)<=nindex:
while len(settings.Notifiers)<=nindex:
settings.Notifiers.append(False)
try:
m = __import__(pglobals.notifierselector[y][0])
except Exception as e:
settings.Notifiers[nindex] = False
exceptstr += str(e)
m = False
if m:
try:
settings.Notifiers[nindex] = m.Plugin(nindex)
except Exception as e:
settings.Notifiers.append(m.Plugin(nindex))
exceptstr += str(e)
break
if settings.Notifiers[nindex] == False:
ws.TXBuffer += "Importing failed: {0}</td></tr></table>".format(exceptstr)
ws.sendHeadandTail("TmplStd",ws._TAIL)
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
return
else:
try:
settings.Notifiers[nindex].plugin_init() # call plugin init
except:
pass
if nindex != '':
ws.TXBuffer += "<input type='hidden' name='index' value='{0}'>".format(nindex+1)
if int(protocol)>0:
ws.addFormCheckBox("Enabled", "nenabled", settings.Notifiers[nindex].enabled)
settings.Notifiers[nindex].webform_load()
if (ws.arg('test',responsearr) != ''):
settings.Notifiers[nindex].notify("Test message")
ws.addFormSeparator(2)
ws.TXBuffer += "<tr><td><td><a class='button link' href=\"notifications\">Close</a>"
ws.addSubmitButton()
if nindex != '':
ws.addSubmitButton("Delete", "del")
ws.addSubmitButton("Test", "test")
ws.TXBuffer += "</table></form>"
ws.sendHeadandTail("TmplStd",ws._TAIL)
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_controllers(httpResponse, responsearr):
edit = ws.arg("edit", responsearr)
controllerindex = ws.arg("index", responsearr)
controllerNotSet = (controllerindex == 0) or (controllerindex == '')
if controllerindex != "":
controllerindex = int(controllerindex) - 1
controllerip = ws.arg("controllerip", responsearr)
controllerport = ws.arg("controllerport", responsearr)
protocol = ws.arg("protocol", responsearr)
if protocol != "":
protocol = int(protocol)
else:
protocol = 0
controlleruser = ws.arg("controlleruser", responsearr)
controllerpassword = ws.arg("controllerpassword", responsearr)
enabled = (ws.arg("controllerenabled", responsearr) == "on")
if ((protocol == 0) and (edit == '') and
(controllerindex != '')) or (ws.arg('del', responsearr) != ''):
try:
settings.Controllers[controllerindex].controller_exit()
except:
pass
settings.Controllers[controllerindex] = False
controllerNotSet = True
settings.savecontrollers()
if (controllerNotSet == False): # submitted
if (protocol > 0): # submitted
try:
if (settings.Controllers[controllerindex]):
settings.Controllers[
controllerindex].controllerip = controllerip
settings.Controllers[
controllerindex].controllerport = controllerport
settings.Controllers[
controllerindex].controlleruser = controlleruser
if "**" not in controllerpassword:
settings.Controllers[
controllerindex].controllerpassword = controllerpassword
settings.Controllers[controllerindex].enabled = enabled
settings.Controllers[controllerindex].webform_save(
responsearr)
settings.savecontrollers()
except:
pass
else:
try:
if (settings.Controllers[controllerindex]):
protocol = settings.Controllers[
controllerindex].controllerid
except:
pass
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.navMenuIndex = 2
ws.sendHeadandTail("TmplStd", ws._HEAD)
ws.TXBuffer += "<form name='frmselect' method='post'>"
if (controllerNotSet): # show all in table
ws.TXBuffer += "<table class='multirow' border=1px frame='box' rules='all'><TR><TH style='width:70px;'>"
ws.TXBuffer += "<TH style='width:50px;'>Nr<TH style='width:100px;'>Enabled<TH>Protocol<TH>Host<TH>Port"
for x in range(pglobals.CONTROLLER_MAX):
ws.TXBuffer += "<tr><td><a class='button link' href=\"controllers?index="
ws.TXBuffer += str(x + 1)
ws.TXBuffer += "&edit=1\">Edit</a><td>"
ws.TXBuffer += ws.getControllerSymbol(x)
ws.TXBuffer += "</td><td>"
try:
if (settings.Controllers[x]):
ws.addEnabled(settings.Controllers[x].enabled)
ws.TXBuffer += "</td><td>"
ws.TXBuffer += str(
settings.Controllers[x].getcontrollername())
ws.TXBuffer += "</td><td>"
ws.TXBuffer += str(settings.Controllers[x].controllerip)
ws.TXBuffer += "</td><td>"
ws.TXBuffer += str(settings.Controllers[x].controllerport)
else:
ws.TXBuffer += "<td><td><td>"
except:
ws.TXBuffer += "<td><td><td>"
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
ws.TXBuffer += "</table></form>"
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
else: # edit
ws.TXBuffer += "<table class='normal'><TR><TH style='width:150px;' align='left'>Controller Settings<TH>"
ws.TXBuffer += "<tr><td>Protocol:<td>"
ws.addSelector_Head("protocol", True)
for x in range(len(pglobals.controllerselector)):
ws.addSelector_Item(
pglobals.controllerselector[x][2],
int(pglobals.controllerselector[x][1]),
(str(protocol) == str(pglobals.controllerselector[x][1])),
False, "")
ws.addSelector_Foot()
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
# print(protocol)#debug
if (int(protocol) > 0):
createnewcontroller = True
try:
if (settings.Controllers[controllerindex].getcontrollerid() ==
int(protocol)):
createnewcontroller = False
except:
pass
exceptstr = ""
if createnewcontroller:
for y in range(len(pglobals.controllerselector)):
if int(pglobals.controllerselector[y][1]) == int(protocol):
if len(settings.Controllers) <= controllerindex:
while len(settings.Controllers) <= controllerindex:
settings.Controllers.append(False)
try:
m = __import__(pglobals.controllerselector[y][0])
except Exception as e:
# print(str(e))
settings.Controllers[controllerindex] = False
exceptstr += str(e)
m = False
gc.collect()
if m:
try:
settings.Controllers[
controllerindex] = m.Controller(
controllerindex)
except Exception as e:
settings.Controllers.append(
m.Controller(controllerindex))
exceptstr += str(e)
break
if settings.Controllers[controllerindex] == False:
ws.TXBuffer += "Importing failed: {0}</td></tr></table>".format(
exceptstr)
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
return True
else:
try:
settings.Controllers[controllerindex].controller_init(
) # call plugin init
if (settings.Controllers[controllerindex]):
if (settings.Controllers[controllerindex].enabled):
settings.Controllers[
controllerindex].setonmsgcallback(
settings.callback_from_controllers)
for x in range(0, len(settings.Tasks)):
if (settings.Tasks[x] and type(Settings.Tasks[x])
is not bool): # device exists
if (settings.Tasks[x].enabled): # device enabled
if (settings.Tasks[x].
senddataenabled[controllerindex]):
if (settings.Controllers[controllerindex]):
if (settings.Controllers[
controllerindex].enabled):
settings.Tasks[x].controllercb[
controllerindex] = settings.Controllers[
controllerindex].senddata
except:
pass
if controllerindex != '':
ws.TXBuffer += "<input type='hidden' name='index' value='" + str(
controllerindex + 1) + "'>"
if int(protocol) > 0:
ws.addFormCheckBox(
"Enabled", "controllerenabled",
settings.Controllers[controllerindex].enabled)
ws.addFormTextBox(
"Controller Host Address", "controllerip",
settings.Controllers[controllerindex].controllerip, 96)
ws.addFormNumericBox(
"Controller Port", "controllerport",
settings.Controllers[controllerindex].controllerport, 1,
65535)
if settings.Controllers[controllerindex].usesAccount:
ws.addFormTextBox(
"Controller User", "controlleruser",
settings.Controllers[controllerindex].controlleruser,
96)
if settings.Controllers[controllerindex].usesPassword:
ws.addFormPasswordBox(
"Controller Password", "controllerpassword", settings.
Controllers[controllerindex].controllerpassword, 96)
# try:
settings.Controllers[controllerindex].webform_load()
# except:
# pass
ws.addFormSeparator(2)
ws.TXBuffer += "<tr><td><td>"
ws.TXBuffer += "<a class='button link' href=\"controllers\">Close</a>"
ws.addSubmitButton()
if controllerindex != '':
ws.addSubmitButton("Delete", "del")
ws.TXBuffer += "</table></form>"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_devices(httpResponse,responsearr):
ws.navMenuIndex=4
ws.TXBuffer = ""
httpResponse.WriteResponseOk(
headers = ({'Cache-Control': 'no-cache'}),
contentType = 'text/html',
contentCharset = 'UTF-8',
content = "" )
taskdevicenumber = ws.arg('TDNUM',responsearr)
if taskdevicenumber=='':
taskdevicenumber=0
else:
taskdevicenumber=int(float(taskdevicenumber))
taskdevicetimer = ws.arg('TDT',responsearr)
if taskdevicetimer=='':
taskdevicetimer=0
else:
taskdevicetimer=float(taskdevicetimer)
edit = ws.arg("edit",responsearr)
page = ws.arg("page",responsearr)
setpage = ws.arg("setpage",responsearr)
taskIndex = ws.arg("index",responsearr)
runIndex = ws.arg("run",responsearr)
toggleIndex = ws.arg("toggle",responsearr)
if page=='':
page=0
else:
page=int(float(page))
if page==0:
page = 1
if setpage=='':
setpage=0
else:
setpage=int(float(setpage))
if (setpage>0):
if setpage <= (pglobals.TASKS_MAX / ws.TASKS_PER_PAGE):
page = setpage
else:
page = int(pglobals.TASKS_MAX / ws.TASKS_PER_PAGE)
ws.sendHeadandTail("TmplStd",ws._HEAD)
taskIndexNotSet = (taskIndex == 0) or (taskIndex == '')
import settings
import misc
if taskIndex!="":
taskIndex = int(taskIndex) - 1
if ws.arg('del',responsearr) != '':
taskdevicenumber=0
ttid = -1
try:
ttid = settings.Tasks[taskIndex].pluginid
except:
ttid = -1
if ttid != -1:
try:
settings.Tasks[taskIndex].plugin_exit()
taskIndexNotSet = True
settings.Tasks[taskIndex] = False
settings.savetasks() # savetasksettings!!!
except Exception as e:
misc.addLog(pglobals.LOG_LEVEL_ERROR, "Deleting failed: "+str(e))
if runIndex != "":
if len(settings.Tasks)<1:
return False
try:
s = int(runIndex)
except:
s = -1
try:
if s >0 and (s<=len(settings.Tasks)):
s = s-1 # array is 0 based, tasks is 1 based
if (type(settings.Tasks[s])!=bool) and (settings.Tasks[s]):
if (settings.Tasks[s].enabled):
settings.Tasks[s].plugin_read()
except Exception as e:
print(e)
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
if toggleIndex != "":
if len(settings.Tasks)<1:
return False
try:
s = int(toggleIndex)
except:
s = -1
try:
if s >0 and (s<=len(settings.Tasks)):
s = s-1 # array is 0 based, tasks is 1 based
if (type(settings.Tasks[s])!=bool) and (settings.Tasks[s]):
if (settings.Tasks[s].enabled):
settings.Tasks[s].set_value(1,(1-int(settings.Tasks[s].uservar[0])),publish=True)
except Exception as e:
print(e)
if taskIndexNotSet: # show all tasks as table
ws.TXBuffer += "<table class='multirow' border=1px frame='box' rules='all'><TR><TH style='width:70px;'>"
if (pglobals.TASKS_MAX != ws.TASKS_PER_PAGE):
ws.TXBuffer += "<a class='button link' href='devices?setpage="
if (page > 1):
ws.TXBuffer += str(page - 1)
else:
ws.TXBuffer += str(page)
ws.TXBuffer += "'><</a><a class='button link' href='devices?setpage="
if (page < (pglobals.TASKS_MAX / ws.TASKS_PER_PAGE)):
ws.TXBuffer += str(page + 1)
else:
ws.TXBuffer += str(page)
ws.TXBuffer += "'>></a><TH style='width:50px;'>Task<TH style='width:100px;'>Enabled<TH>Device<TH>Name<TH>Port<TH style='width:100px;'>Ctr (IDX)<TH style='width:70px;'>GPIO<TH>Values"
for x in range( ((page - 1) * ws.TASKS_PER_PAGE), ((page) * ws.TASKS_PER_PAGE) ):
ws.TXBuffer += "<TR><TD><a class='button link' href='devices?index={0}&page={1}'>Edit</a>".format((x+1),page)
try:
if settings.Tasks[x] and settings.Tasks[x].enabled and settings.Tasks[x].remotefeed<1:
ws.TXBuffer += "<a class='button link' href='devices?run={0}&page={1}'>Run</a>".format((x+1),page)
if settings.Tasks[x].recdataoption and settings.Tasks[x].vtype==pglobals.SENSOR_TYPE_SWITCH:
ws.TXBuffer += "<a class='button link' href='devices?toggle={0}&page={1}'>Toggle</a>".format((x+1),page)
except:
pass
ws.TXBuffer += "<TD>{0}<TD>".format(x+1)
lent = False
try:
if settings.Tasks[x]:
lent = True
except:
lent = False
if (len(settings.Tasks)>x) and (lent):
try:
ws.addEnabled(settings.Tasks[x].enabled)
except Exception as e:
pass
ws.TXBuffer += "<TD>{0}<TD>{1}<TD>".format(settings.Tasks[x].getdevicename(),settings.Tasks[x].gettaskname())
try:
if (str(settings.Tasks[x].ports) != "0" and str(settings.Tasks[x].ports) != ""):
ws.TXBuffer += str(settings.Tasks[x].ports)
except:
pass
if settings.Tasks[x].remotefeed:
ws.TXBuffer += "<TD style='background-color:#00FF00'>"
else:
ws.TXBuffer += "<TD>"
try:
if (settings.Tasks[x].senddataoption):
doBR = False
maxcon = len(settings.Controllers)
if maxcon>pglobals.CONTROLLER_MAX:
maxcon = pglobals.CONTROLLER_MAX
try:
for controllerNr in range(0,maxcon):
if (settings.Tasks[x]) and (settings.Tasks[x].senddataenabled[controllerNr]) and (settings.Controllers[controllerNr].enabled):
if (doBR):
ws.TXBuffer += "<BR>"
ws.TXBuffer += ws.getControllerSymbol(controllerNr)
if (settings.Controllers[controllerNr].usesID):
ws.TXBuffer += " ({0})".format(settings.Tasks[x].controlleridx[controllerNr])
if (int(settings.Tasks[x].controlleridx[controllerNr]) <= 0):
ws.TXBuffer += " " + HTML_SYMBOL_WARNING
doBR = True
except Exception as e:
pass
ws.TXBuffer += "<TD>"
except Exception as e:
print(e)
if (settings.Tasks[x].dtype == pglobals.DEVICE_TYPE_I2C):
try:
i2cpins = settings.get_i2c_pins(settings.Tasks[x].i2c)
ws.TXBuffer += "{0}<BR>{1}".format(i2cpins[0],i2cpins[1])
except:
ws.TXBuffer += "NO-I2C"
if (settings.Tasks[x].dtype == pglobals.DEVICE_TYPE_SPI):
try:
ws.TXBuffer += "SPI{0}".format(settings.Tasks[x].spi)
except:
ws.TXBuffer += "NO-SPI"
for tp in range(0,len(settings.Tasks[x].taskdevicepin)):
if int(settings.Tasks[x].taskdevicepin[tp])>=0:
ws.TXBuffer += "<br>GPIO-{0}".format(settings.Tasks[x].taskdevicepin[tp])
ws.TXBuffer += "<TD>"
customValues = False
# customValues = PluginCall(PLUGIN_WEBFORM_SHOW_VALUES, &TempEvent,ws.TXBuffer.buf);
if not(customValues):
if (settings.Tasks[x].vtype == pglobals.SENSOR_TYPE_LONG):
try:
numtodisp = str(float(settings.Tasks[x].uservar[0]) + float(settings.Tasks[x].uservar[1] << 16))
ws.TXBuffer += "<div class='div_l' id='valuename_{0}_0'>{1}:</div><div class='div_r' id='value_{2}_0'>{3}</div>".format(x,settings.Tasks[x].getdevicevaluenames()[0],x,str(misc.formatnum(numtodisp,0)))
except Exception as e:
print(e)
else:
try:
for varNr in range(0,pglobals.VARS_PER_TASK):
if ((settings.Tasks[x].enabled) and (varNr < settings.Tasks[x].valuecount)):
if (varNr > 0):
ws.TXBuffer += "<div class='div_br'></div>"
numtodisp = settings.Tasks[x].uservar[varNr]
decimalv = settings.Tasks[x].decimals[varNr]
ws.TXBuffer += "<div class='div_l' id='valuename_{0}_{1}'>{2}:</div><div class='div_r' id='value_{3}_{4}'>{5}</div>".format(x,varNr,settings.Tasks[x].getdevicevaluenames()[varNr],x,varNr,str(misc.formatnum(numtodisp,decimalv)))
except Exception as e:
print(e)
else:
ws.TXBuffer += "<TD><TD><TD><TD><TD><TD>"
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
ws.TXBuffer += "</table></form>"
ws.sendHeadandTail("TmplStd",ws._TAIL)
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_dash(httpResponse, responsearr):
try:
ws.navMenuIndex = 7
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
dashtask = None
for t in range(0, len(settings.Tasks)):
if (settings.Tasks[t] and (type(settings.Tasks[t]) is not bool)):
try:
if settings.Tasks[t].enabled:
if settings.Tasks[t].pluginid == 212:
dashtask = settings.Tasks[t]
break
except:
pass
ws.TXBuffer = ""
if (dashtask is not None) and (dashtask.taskdevicepluginconfig[2]):
ws.sendHeadandTail("TmplStd", ws._HEAD)
ws.TXBuffer += "<link rel='stylesheet' href='/dash.css'>"
else:
ws.TXBuffer += "<!DOCTYPE html><html lang='en'><head><meta charset='utf-8'/><link rel='stylesheet' href='/dash.css'></head><body>"
if (dashtask is not None) and (len(dashtask.celldata) > 0):
astr = ""
estr = ""
vstr = ""
if int(dashtask.taskdevicepluginconfig[0]) > 1 and int(
dashtask.taskdevicepluginconfig[0]) < 7:
astr = " tab" + str(dashtask.taskdevicepluginconfig[0])
ws.addHtml("<table width='100%' class='tab " + astr + "'>")
offs = 0
for r in range(int(dashtask.taskdevicepluginconfig[1])):
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
if offs >= len(dashtask.celldata):
break
ws.addHtml("<tr>")
for c in range(int(dashtask.taskdevicepluginconfig[0])):
if offs >= len(dashtask.celldata):
break
ws.addHtml("<td>")
offs = (r * int(dashtask.taskdevicepluginconfig[0])) + c
try:
dtype = int(dashtask.celldata[offs]["type"])
tid = str(dashtask.celldata[offs]["data"])
estr += '"' + tid + '",'
ti = tid.split("_")
tasknum = int(ti[0])
valnum = int(ti[1])
vstr += '"' + str(
settings.Tasks[tasknum].uservar[valnum]) + '",'
try:
namestr = str(dashtask.celldata[offs]["name"])
except:
namestr = ""
if namestr.strip() == "":
namestr = str(settings.Tasks[tasknum].gettaskname(
)) + "#" + str(
settings.Tasks[tasknum].valuenames[valnum])
ws.addHtml("<div class='div_d' id='valuename_" +
str(tid) + "'>" + namestr + "</div>")
except:
dtype = -1
try:
udata = str(dashtask.celldata[offs]["unit"])
except:
udata = ""
if dtype == 0:
ws.addHtml(
"<div class='textval' id='value_" + str(tid) +
"'>" +
str(settings.Tasks[tasknum].uservar[valnum]) +
"</div>")
elif dtype == 1:
ws.addHtml(
"<div class='centered'><input type='checkbox' id='value_"
+ str(tid) +
"' class='state' disabled='disabled'/><label for='value_"
+ str(tid) +
"' class='toggleWrapper'><div class='toggle'></div></label></div>"
)
elif dtype == 2:
ws.addHtml(
"<div class='switch'><input id='value_" +
str(tid) +
"' class='cmn-toggle cmn-toggle-round' type='checkbox' onchange='cboxchanged(this)'><label for='value_"
+ str(tid) + "'></label></div>")
elif dtype == 3:
try:
umin = float(dashtask.celldata[offs]["min"])
except:
umin = 0
try:
umax = float(dashtask.celldata[offs]["max"])
except:
umax = 100
ws.addHtml(
"<div style='width:100%'><meter id='value_" +
str(tid) + "' min='" + str(umin) + "' max='" +
str(umax) + "' value='" +
str(settings.Tasks[tasknum].uservar[valnum]) +
"' class='meter'></meter>")
sval = umin
stepval = (umax - umin) / 5
ws.addHtml(
"<ul id='scale'><li style='width: 10%'><span></span></li>"
)
while sval < (umax - stepval):
sval = sval + stepval
ws.addHtml("<li><span id='scale'>" + str(sval) +
"</span></li>")
ws.addHtml(
"<li style='width: 10%'><span id='scale'></span></li></ul></div>"
)
elif dtype == 4:
ws.addHtml(
"<div class='gauge' id='value_" + str(tid) +
"'><div class='gauge__body'><div class='gauge__fill'></div><div class='gauge__cover'></div></div></div>"
)
elif dtype == 5:
try:
umin = float(dashtask.celldata[offs]["min"])
except:
umin = 0
try:
umax = float(dashtask.celldata[offs]["max"])
except:
umax = 100
ws.addHtml(
"<input type='range' min='" + str(umin) +
"' max='" + str(umax) + "' value='" +
str(settings.Tasks[tasknum].uservar[valnum]) +
"' class='slider' id='value_" + str(tid) +
"' onchange='sselchanged(this)' oninput='this.nextElementSibling.value = this.value'>"
)
ws.addHtml(
"<output>" +
str(settings.Tasks[tasknum].uservar[valnum]) +
"</output>")
elif dtype == 6:
ws.addHtml("<div class='box'><select name='value_" +
str(tid) + "' id='value_" + str(tid) +
"' onchange='sselchanged(this)'>")
optionnames = []
if "," in dashtask.celldata[offs]["optionnames"]:
optionnames = dashtask.celldata[offs][
"optionnames"].split(",")
elif ";" in dashtask.celldata[offs]["optionnames"]:
optionnames = dashtask.celldata[offs][
"optionnames"].split(",")
options = []
if "," in dashtask.celldata[offs]["options"]:
options = dashtask.celldata[offs]["options"].split(
",")
elif ";" in dashtask.celldata[offs]["options"]:
options = dashtask.celldata[offs]["options"].split(
",")
ol = len(optionnames)
if ol > len(options):
ol = len(options)
for o in range(ol):
ws.addHtml("<option value='" + str(options[o]) +
"'>" + str(optionnames[o]) +
"</option>")
ws.addHtml("</select></div>")
else:
ws.addHtml(" ")
if udata.strip() != "":
ws.addHtml(textparse(udata))
ws.addHtml("</td>")
ws.addHtml("</tr>")
ws.addHtml("</table>")
ws.addHtml(
'<script type="text/javascript" src="/dash.js"></script>')
ws.addHtml("<script>var elements=[" + estr + "]; var values=[" +
vstr + "];")
offs = (dashtask.taskdevicepluginconfig[0] *
dashtask.taskdevicepluginconfig[1])
pstr = ""
for o in range(offs):
if "min" in dashtask.celldata[o]:
pstr += "[" + str(dashtask.celldata[o]["min"]) + "," + str(
dashtask.celldata[o]["max"]) + "],"
else:
pstr += '[0,100],'
ws.addHtml('var props=[' + str(pstr) + '];')
ws.addHtml("var ownurl='http://" + str(unet.get_ip()) + ":80';")
ws.addHtml(
"refreshDatas();setInterval(function(){ getDatas(); }, " +
str(dashtask.interval * 1000) + ");</script>")
else:
ws.TXBuffer += "<p>Setup dashboard first!"
if dashtask.taskdevicepluginconfig[2]:
ws.sendHeadandTail("TmplStd", ws._TAIL)
else:
ws.TXBuffer += "</body></html>"
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
except Exception as e:
print("Config error, try to delete and recreate task!", e)
return ws.TXBuffer
def handle_sysinfo(httpResponse):
ws.navMenuIndex = 7
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
ws.TXBuffer += "<table class='normal'><TR><TH style='width:150px;' align='left'>System Info<TH align='left'>"
ws.TXBuffer += "<TR><TD>Unit<TD>"
ws.TXBuffer += str(settings.Settings["Unit"])
ws.TXBuffer += "<TR><TD>Local Time<TD>" + misc.strtime(
0) #Local Time: (2000, 1, 1, 0, 45, 20, 5, 1)
ws.TXBuffer += "<TR><TD>Uptime<TD>" + str(misc.getuptime(1))
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
ws.TXBuffer += "<TR><TD>Frequency<TD>" + str(
int(esp_os.getfreq() / 1000000)) + " Mhz"
try:
ws.TXBuffer += "<TR><TD>Flash<TD>" + str(
int(esp_os.getstorage() / 1024)) + " kB"
except:
pass
try:
ws.TXBuffer += "<TR><TD>Memory<TD>" + str(
int(esp_os.get_memory()['t'] / 1024)) + " kB"
except:
pass
try:
ws.TXBuffer += "<TR><TD>Free Mem<TD>" + str(
int(esp_os.get_memory()['f'] / 1024)) + " kB"
except:
pass
ws.TXBuffer += "<TR><TD>PSRAM<TD>" + str(esp_os.psRamFound())
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
try:
uver = uos.uname()
uver2 = 'uPython ' + str(uver.version)
umach = str(uver.machine)
except:
uver2 = ""
umach = ""
if umach != "":
ws.TXBuffer += "<TR><TD>Device<TD>" + str(umach)
ws.TXBuffer += '<tr><td>Platform<td>' + sys.platform
ws.TXBuffer += "<TR><TD>Wifi RSSI<TD>" + str(unet.get_rssi())
ws.TXBuffer += '<tr><td>SSID<td>' + str(unet.get_ssid())
ws.TXBuffer += '<tr><td>STA IP<td>' + str(unet.get_ip("STA"))
ws.TXBuffer += '<tr><td>STA MAC<td>' + str(unet.get_mac("STA"))
ws.TXBuffer += '<tr><td>AP IP<td>' + str(unet.get_ip("AP"))
ws.TXBuffer += '<tr><td>AP MAC<td>' + str(unet.get_mac("AP"))
ws.TXBuffer += '<tr><td>LAN IP<td>' + str(unet.get_ip("LAN"))
ws.TXBuffer += '<tr><td>LAN MAC<td>' + str(unet.get_mac("LAN"))
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
ws.TXBuffer += '<tr><td>Build<td>' + str(pglobals.PROGNAME) + " " + str(
pglobals.PROGVER)
ws.TXBuffer += '<tr><td>Libraries<td>Python ' + sys.version.replace(
'\n', '<br>') + " " + uver2
ws.TXBuffer += '<tr><td>Plugins<td>' + str(
len(pglobals.deviceselector) - 1)
ws.TXBuffer += "</tr></table>"
try:
import inc.lib_part as PartMgr
pm = PartMgr.partmgr()
pl = pm.getparts()
except:
pl = []
if len(pl) > 0:
try:
pr = pm.getrunningpart()[4]
pb = pm.getbootpart()[4]
except:
pr = ""
pb = ""
ws.TXBuffer += "<p><table class='normal'><tr><th>Partition</th><th>Start address</th><th>Size</th><th>Flags</th></tr>"
for p in pl:
prf = ""
if pr == p[4]:
prf = "Running "
if pb == p[4]:
prf += "Boot "
ws.TXBuffer += "<tr><td>{0}</td><td>0x{1:07x}</td><td>{2}</td><td>{3}</td></tr>".format(
p[4], p[2], p[3], prf)
ws.TXBuffer += "</table>"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_hw(httpResponse,responsearr):
ws.navMenuIndex=3
ws.TXBuffer = ""
httpResponse.WriteResponseOk(
headers = ({'Cache-Control': 'no-cache'}),
contentType = 'text/html',
contentCharset = 'UTF-8',
content = "" )
method = ws.arg("method",responsearr)
saved = ws.arg("Submit",responsearr)
if (saved):
try:
tvar = int(ws.arg('freq',responsearr))
esp_os.setfreq(tvar)
settings.HW['freq']=int(tvar)
settings.HW['psram-cs']= int(ws.arg('psram-cs',responsearr))
settings.HW['psram-clk']= int(ws.arg('psram-clk',responsearr))
except:
pass
iname=""
tname=""
try:
if "i2c0-freq" in responsearr:
for i in range(2):
iname = "i2c{0}".format(i)
settings.HW[iname] = (ws.arg(iname,responsearr) == "on")
if settings.HW[iname]:
tname = iname+"-freq"
settings.HW[tname] = int(ws.arg(tname,responsearr))
tname = iname+"-sda"
settings.HW[tname] = int(ws.arg(tname,responsearr))
tname = iname+"-scl"
settings.HW[tname] = int(ws.arg(tname,responsearr))
except:
pass
try:
if 'spic-baud' in responsearr:
iname = 'spic'
settings.HW[iname] = (ws.arg(iname,responsearr) == "on")
tname = iname+"-clk"
settings.HW[tname] = int(ws.arg(tname,responsearr))
tname = iname+"-mosi"
settings.HW[tname] = int(ws.arg(tname,responsearr))
tname = iname+"-miso"
settings.HW[tname] = int(ws.arg(tname,responsearr))
tname = iname+"-baud"
settings.HW[tname] = int(ws.arg(tname,responsearr))
except:
pass
try:
if "spi1-baud" in responsearr:
for i in range(1,3):
iname = "spi{0}".format(i)
if 'spic' in responsearr:
settings.HW[iname] = False
else:
settings.HW[iname] = (ws.arg(iname,responsearr) == "on")
if settings.HW[iname]:
# tname = iname+"-cs"
# settings.HW[tname] = int(ws.arg(tname,responsearr))
tname = iname+"-baud"
settings.HW[tname] = int(ws.arg(tname,responsearr))
except:
pass
try:
if "uart1-baud" in responsearr:
for i in range(1,3):
iname = "uart{0}".format(i)
settings.HW[iname] = (ws.arg(iname,responsearr) == "on")
if settings.HW[iname]:
tname = iname+"-rx"
settings.HW[tname] = int(ws.arg(tname,responsearr))
tname = iname+"-tx"
settings.HW[tname] = int(ws.arg(tname,responsearr))
tname = iname+"-baud"
settings.HW[tname] = int(ws.arg(tname,responsearr))
tname = iname+"-timeout"
settings.HW[tname] = int(ws.arg(tname,responsearr))
except:
pass
try:
li = int(ws.arg("lanphy",responsearr))
except:
li = -1
settings.HW["lan-phy"] = li
if li >-1 and ("lanphy" in responsearr):
settings.HW["lan-mdc"] = int(ws.arg("lanmdc",responsearr))
settings.HW["lan-mdio"] = int(ws.arg("lanmdio",responsearr))
settings.HW["lan-pwr"] = int(ws.arg("lanpwr",responsearr))
settings.HW["lan-addr"] = int(ws.arg("lanaddr",responsearr))
settings.HW["lan-clk"] = int(ws.arg("lanclk",responsearr))
if "p0" in responsearr:
for p in range(40):
pv = -1
try:
pv = int(ws.arg("p"+str(p),responsearr))
except:
pv = -1
if pv > -1:
psuc = False
for ap in range(len(settings.Pinout)):
if int(settings.Pinout[ap]['p']) == int(p):
settings.Pinout[ap]['m'] = pv
psuc = True
break
if psuc==False:
settings.Pinout.append({'p':p,'m':pv})
settings.savehwsettings()
settings.savepinout()
try:
libhw.initgpio()
except:
pass
# else:
# settings.loadhwsettings()
# settings.loadpinout()
ws.sendHeadandTail("TmplStd",ws._HEAD)
ws.addHtml("<p><div><a class='menu2' href='hardware'>Main</a> | <a class='menu2' href='hardware?method=i2c'>I2C</a> | <a class='menu2' href='hardware?method=spi'>SPI</a> | <a class='menu2' href='hardware?method=uart'>UART</a> | <a class='menu2' href='hardware?method=lan'>LAN</a></div>")
ws.TXBuffer += "<form name='frmselect' method='post'><table class='normal'>"
if method=="":
# ws.addFormSeparator(3)
ws.addFormHeader("Main")
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
options = ['80','160','240']
optionvalues = [80000000, 160000000, 240000000]
afreq = int(esp_os.getfreq())
if afreq not in optionvalues:
optionvalues.append(afreq)
options.append(str(afreq))
ws.addFormSelector("Core speed","freq",len(optionvalues),options,optionvalues,None,afreq)
ws.addUnit('MHz')
ws.addFormPinSelect("PSRAM-CS",'psram-cs',settings.HW['psram-cs'],1)
ws.addFormPinSelect("PSRAM-CLK",'psram-clk',settings.HW['psram-clk'],1)
ws.addFormNote("Set to none only when no PSRAM connected!")
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
if method=="i2c":
ws.addFormHeader("I2C")
options = ['100','400']
optionvalues = [100000, 400000]
iname = ""
tname = ""
for i in range(2):
iname = "i2c{0}".format(i)
ws.addFormCheckBox("Enable I2C-"+str(i),iname,settings.HW[iname])
tname = iname+"-freq"
ws.addFormSelector("Speed",tname,len(optionvalues),options,optionvalues,None,settings.HW[tname])
ws.addUnit('kHz')
tname = iname+"-sda"
tval = settings.HW[tname]
if tval<0:
if i==0:
tval = 21
else:
tval = 16
ws.addFormPinSelect("SDA",tname,tval,1)
tname = iname+"-scl"
tval = settings.HW[tname]
if tval<0:
if i==0:
tval = 22
else:
tval = 17
ws.addFormPinSelect("SCL",tname,tval,1)
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
if method=="spi":
ws.addFormHeader("SPI")
options = ['1','5','10','18','20','26','40','48','80']
optionvalues = [10000000,50000000,10000000,18000000,20000000,26000000,40000000,48000000,80000000]
for i in range(1,3):
iname = "spi{0}".format(i)
ws.addFormCheckBox("Enable Hardware SPI-"+str(i),iname,settings.HW[iname])
if i==1:
ws.addFormNote('MOSI=13, MISO=12, CLK=14')
elif i==2:
ws.addFormNote('MOSI=23, MISO=19, CLK=18')
tname = iname+"-baud"
aspd = settings.HW[tname]
if aspd<1:
aspd = 18000000
ws.addFormSelector("Speed",tname,len(optionvalues),options,optionvalues,None,aspd)
ws.addUnit("Mhz")
# tname = iname+"-cs"
# tval = settings.HW[tname]
# if tval<0:
# if i==1:
# tval = 15
# else:
# tval = 5
# ws.addFormPinSelect("CS",tname,tval,1)
try:
iname = "spic"
ws.addFormCheckBox("Enable Custom SPI",iname,settings.HW[iname])
tname = iname+"-baud"
aspd = settings.HW[tname]
if aspd<1:
aspd = 18000000
ws.addFormSelector("Speed",tname,len(optionvalues),options,optionvalues,None,aspd)
ws.addUnit("Mhz")
tname = iname+"-clk"
ws.addFormPinSelect("CLK",tname,settings.HW[tname],1)
tname = iname+"-mosi"
ws.addFormPinSelect("MOSI",tname,settings.HW[tname],1)
tname = iname+"-miso"
ws.addFormPinSelect("MISO",tname,settings.HW[tname],0)
except Exception as e:
settings.HW[iname] = 0
settings.HW[iname+"-clk"] = -1
settings.HW[iname+"-mosi"] = -1
settings.HW[iname+"-miso"] = -1
settings.HW[iname+"-baud"] = 0
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
if method=="uart":
ws.addFormHeader("UART")
for i in range(1,3):
iname = "uart{0}".format(i)
ws.addFormCheckBox("Enable UART-"+str(i),iname,settings.HW[iname])
tname = iname+"-baud"
ws.addFormNumericBox("Baud",tname,settings.HW[tname],0,921600)
tname = iname+"-timeout"
ws.addFormNumericBox("Timeout",tname,settings.HW[tname],0,50000)
tname = iname+"-rx"
tval = settings.HW[tname]
if tval<0:
if i==0:
tval = 9
else:
tval = 16
ws.addFormPinSelect("RX",tname,tval,1)
tname = iname+"-tx"
tval = settings.HW[tname]
if tval<0:
if i==0:
tval = 10
else:
tval = 17
ws.addFormPinSelect("TX",tname,tval,1)
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
if method=="lan":
try:
optionvalues1 = unet.get_net_const("phy")
optionvalues2 = unet.get_net_const("clk")
lanok = True
except Exception as e:
# print("LAN failed ",e)#debug
lanok = False
if lanok:
ws.addFormHeader("LAN RMII interface")
options = ['Disabled','LAN8720','TLK110','IP101']
ws.addFormSelector("LAN PHY","lanphy",len(optionvalues1),options,optionvalues1,None,settings.HW["lan-phy"])
options = ['GPIO0 (default)','GPIO16','GPIO17']
ws.addFormSelector("LAN CLK mode","lanclk",len(optionvalues2),options,optionvalues2,None,settings.HW["lan-clk"])
ws.addFormNumericBox("PHY Address","lanaddr",settings.HW["lan-addr"],0,0x1F)
ws.addFormPinSelect("PHY MDC","lanmdc",settings.HW["lan-mdc"],1)
ws.addFormPinSelect("PHY MDIO","lanmdio",settings.HW["lan-mdio"],1)
ws.addFormPinSelect("PHY Power enable","lanpwr",settings.HW["lan-pwr"],1)
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
if method=="":
ws.addHtml("<tr><th>GPIO</th><th>Requested startup state</th><th>Value</th></tr>")
for p in range(40):
if gpiohelp.is_pin_valid(p):
reserved = False
value = ""
if settings.HW['psram-cs']==p:
reserved = True
value = "PSRAM-CS"
elif settings.HW['psram-clk']==p:
reserved = True
value = "PSRAM-CLK"
if settings.HW["lan-phy"]>-1:
cpin = 0
if unet.get_net_const("c16o")==settings.HW["lan-clk"]:
cpin = 16
elif unet.get_net_const("c17o")==settings.HW["lan-clk"]:
cpin = 17
if p==settings.HW["lan-mdc"]:
reserved = True
value = "LAN MDC"
elif p==settings.HW["lan-mdio"]:
reserved = True
value = "LAN MDIO"
elif p==settings.HW["lan-pwr"]:
reserved = True
value = "LAN PWR"
elif p==cpin:
reserved = True
value = "LAN CLK"
if p in [22,19,21,26,25,27]:
reserved = True
value = "RMII LAN"
if settings.HW['i2c0']:
if settings.HW['i2c0-sda']==p:
reserved = True
value = "I2C0-SDA"
elif settings.HW['i2c0-scl']==p:
reserved = True
value = "I2C0-SCL"
if settings.HW['i2c1']:
if settings.HW['i2c1-sda']==p:
reserved = True
value = "I2C1-SDA"
elif settings.HW['i2c1-scl']==p:
reserved = True
value = "I2C1-SCL"
if settings.HW['uart1']:
if settings.HW['uart1-rx']==p:
reserved = True
value = "UART1-RX"
elif settings.HW['uart1-tx']==p:
reserved = True
value = "UART1-TX"
if settings.HW['uart2']:
if settings.HW['uart2-rx']==p:
reserved = True
value = "UART2-RX"
elif settings.HW['uart2-tx']==p:
reserved = True
value = "UART2-TX"
if settings.HW['spi1']: # hspi
# if settings.HW['spi1-cs']==p:
# reserved = True
# value = "SPI1-CS"
if p==12:
reserved = True
value = "SPI1-MISO"
elif p==13:
reserved = True
value = "SPI1-MOSI"
elif p==14:
reserved = True
value = "SPI1-CLK"
if settings.HW['spi2']: # vspi
# if settings.HW['spi2-cs']==p:
# reserved = True
# value = "SPI2-CS"
if p==19:
reserved = True
value = "SPI2-MISO"
elif p==23:
reserved = True
value = "SPI2-MOSI"
elif p==18:
reserved = True
value = "SPI2-CLK"
try:
if settings.HW['spic']: # custom spi
if settings.HW['spic-clk']==p:
reserved = True
value = "SPI-CLK"
elif settings.HW['spic-miso']==p:
reserved = True
value = "SPI-MISO"
elif settings.HW['spic-mosi']==p:
reserved = True
value = "SPI-MOSI"
except:
pass
if reserved==False:
if p==1:
reserved = True
value = "UART0-TX"
elif p==3:
reserved = True
value = "UART0-RX"
options = settings.PinStates
amode = 0
apin = -1
nonres = False
try:
if str(value).strip()=="":
nonres = True
except:
pass
try:
for pin in range(len(settings.Pinout)):
if int(settings.Pinout[pin]['p']) == int(p):
if settings.Pinout[pin]['m']==9:
if nonres:
settings.Pinout[pin]['m']=0
amode = settings.Pinout[pin]['m']
apin = pin
except Exception as e:
amode = 0
if reserved:
amode = 9
if reserved and value and value != "":
svalue = str(value)
else:
svalue = ""
if apin==-1:
settings.Pinout.append({'p':p,'m':amode,'d':svalue})
else:
settings.Pinout[apin] = {'p':p,'m':amode,'d':svalue}
attr = []
if amode==9:
for a in range(9):
attr.append("DISABLED")
attr.append("")
else:
if p<34:
for a in range(7):
attr.append("")
for a in range(2):
attr.append("DISABLED")
else:
for a in range(2):
attr.append("")
for a in range(2,12):
attr.append("DISABLED")
optionvalues = [0,1,2,3,4,5,6,7,8,9]
ws.addHtml("<tr><td align=right>D"+str(p)+"</td><td>")
try:
ws.addSelector("p"+str(p),len(options),options,optionvalues,attr,amode,False)
except Exception as e:
pass
ws.addHtml("</td><td>"+str(value)+"</td></tr>")
if (p % 5)==0:
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
ws.addFormSeparator(3)
ws.TXBuffer += "<tr><td colspan=3>"
ws.addSubmitButton()
ws.addFormNote('WARNING: Some changes needed to reboot after submitting changes!')
ws.TXBuffer += "</table></form>"
ws.sendHeadandTail("TmplStd",ws._TAIL)
httpResponse._write(ws.TXBuffer,strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_adv(httpResponse, responsearr):
ws.navMenuIndex = 7
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
saved = ws.arg("Submit", responsearr)
if (saved):
settings.AdvSettings["webloglevel"] = int(
ws.arg("webloglevel", responsearr))
settings.AdvSettings["consoleloglevel"] = int(
ws.arg("consoleloglevel", responsearr))
settings.AdvSettings["usentp"] = (ws.arg("usentp",
responsearr) == "on")
settings.AdvSettings["ntpserver"] = ws.arg("ntpserver", responsearr)
settings.AdvSettings["timezone"] = int(ws.arg("timezone", responsearr))
try:
settings.AdvSettings["rtci2c"] = int(ws.arg("rtci2c", responsearr))
if settings.AdvSettings["rtci2c"] >= 0:
settings.AdvSettings["extrtc"] = int(
ws.arg("extrtc", responsearr))
if settings.AdvSettings["rtcaddr"] >= 0:
settings.AdvSettings["rtcaddr"] = int(
ws.arg("rtcaddr", responsearr))
except:
settings.AdvSettings["extrtc"] = 0
settings.AdvSettings["rtci2c"] = 0
try:
settings.AdvSettings["dangerouspins"] = ws.arg(
"dangerouspins", responsearr)
except:
settings.AdvSettings["dangerouspins"] = False
try:
settings.AdvSettings["Latitude"] = float(
ws.arg("latitude", responsearr))
settings.AdvSettings["Longitude"] = float(
ws.arg("longitude", responsearr))
except:
settings.AdvSettings["Latitude"] = 0
settings.AdvSettings["Longitude"] = 0
try:
settings.AdvSettings["startpage"] = str(
ws.arg("startpage", responsearr))
except:
settings.AdvSettings["startpage"] = "/"
settings.saveadvsettings()
ws.sendHeadandTail("TmplStd", ws._HEAD)
ws.TXBuffer += "<form method='post'><table class='normal'>"
ws.addFormHeader("Advanced Settings")
ws.addFormSubHeader("Log Settings")
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
ws.addFormLogLevelSelect("Console log Level", "consoleloglevel",
settings.AdvSettings["consoleloglevel"])
ws.addFormLogLevelSelect("Web log Level", "webloglevel",
settings.AdvSettings["webloglevel"])
ws.addFormSubHeader("Time Settings")
ws.addFormCheckBox("Enable NTP", "usentp", settings.AdvSettings["usentp"])
ws.addFormTextBox("NTP server name", "ntpserver",
settings.AdvSettings["ntpserver"], 100)
ws.addFormNumericBox("Timezone offset", "timezone",
settings.AdvSettings["timezone"], -720, 840)
ws.addUnit("min")
try:
extrtc = settings.AdvSettings["extrtc"]
except:
settings.AdvSettings["extrtc"] = 0
extrtc = 0
options = ["Disable", "DS1307", "DS3231", "PCF8523"]
optionvalues = [0, 1307, 3231, 8523]
ws.addFormSelector("External RTC type", "extrtc", len(optionvalues),
options, optionvalues, None, extrtc)
try:
import inc.libhw as libhw
options = libhw.geti2clist()
except:
options = []
try:
rtci2c = settings.AdvSettings["rtci2c"]
except:
rtci2c = 0
settings.AdvSettings["rtci2c"] = 0
ws.addHtml("<tr><td>RTC I2C line:<td>")
ws.addSelector_Head("rtci2c", True)
for d in range(len(options)):
ws.addSelector_Item("I2C" + str(options[d]), options[d],
(rtci2c == options[d]), False)
ws.addSelector_Foot()
try:
rtcaddr = settings.AdvSettings["rtcaddr"]
except:
rtcaddr = 0
settings.AdvSettings["rtcaddr"] = 0
options = ["0", "0x68", "0x51"]
optionvalues = [0, 0x68, 0x51]
ws.addFormSelector("RTC I2C address", "rtcaddr", len(optionvalues),
options, optionvalues, None, rtcaddr)
res = ""
try:
if settings.AdvSettings['extrtc'] > 0 and settings.AdvSettings[
'rtci2c'] >= 0:
import inc.mrtc as mrtc
try:
import inc.libhw as libhw
except:
pass
if mrtc.I2C_RTC is None:
if settings.AdvSettings['rtci2c'] == 0:
rtcok = mrtc.rtcinit(settings.AdvSettings['extrtc'],
libhw.i2c0,
settings.AdvSettings["rtcaddr"])
elif settings.AdvSettings['rtci2c'] == 1:
rtcok = mrtc.rtcinit(settings.AdvSettings['extrtc'],
libhw.i2c1,
settings.AdvSettings["rtcaddr"])
ret = mrtc.getrtctime()
res = '{:04}-{:02}-{:02} {:02}:{:02}:{:02}'.format(
ret[0], ret[1], ret[2], ret[4], ret[5], ret[6])
except Exception as e:
res = "RTC not available " + str(e)
if settings.AdvSettings['extrtc'] > 0:
ws.addFormNote(res)
ws.addFormSubHeader("Misc Settings")
try:
dpins = settings.AdvSettings["dangerouspins"]
except:
dpins = False
ws.addFormCheckBox("Show dangerous pins", "dangerouspins", dpins)
try:
sp = settings.AdvSettings["startpage"]
except:
sp = "/"
ws.addFormTextBox("Start page", "startpage", sp, 64)
ws.addFormSubHeader("Location Settings")
try:
lat = settings.AdvSettings["Latitude"]
lon = settings.AdvSettings["Longitude"]
except:
lat = 0
lon = 0
ws.addFormFloatNumberBox("Latitude", "latitude", lat, -90.0, 90.0)
ws.addUnit("°")
ws.addFormFloatNumberBox("Longitude", "longitude", lon, -180.0, 180.0)
ws.addUnit("°")
ws.addFormSeparator(2)
ws.TXBuffer += "<TR><TD style='width:150px;' align='left'><TD>"
ws.addSubmitButton()
ws.TXBuffer += "<input type='hidden' name='edit' value='1'>"
ws.TXBuffer += "</table></form>"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_devices(httpResponse, responsearr):
ws.navMenuIndex = 4
ws.TXBuffer = ""
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
taskdevicenumber = ws.arg('TDNUM', responsearr)
if taskdevicenumber == '':
taskdevicenumber = 0
else:
taskdevicenumber = int(float(taskdevicenumber))
taskdevicetimer = ws.arg('TDT', responsearr)
if taskdevicetimer == '':
taskdevicetimer = 0
else:
taskdevicetimer = float(taskdevicetimer)
edit = ws.arg("edit", responsearr)
page = ws.arg("page", responsearr)
setpage = ws.arg("setpage", responsearr)
taskIndex = ws.arg("index", responsearr)
runIndex = ws.arg("run", responsearr)
if page == '':
page = 0
else:
page = int(float(page))
if page == 0:
page = 1
if setpage == '':
setpage = 0
else:
setpage = int(float(setpage))
if (setpage > 0):
if setpage <= (pglobals.TASKS_MAX / ws.TASKS_PER_PAGE):
page = setpage
else:
page = int(pglobals.TASKS_MAX / ws.TASKS_PER_PAGE)
ws.sendHeadandTail("TmplStd", ws._HEAD)
taskIndexNotSet = (taskIndex == 0) or (taskIndex == '')
if taskIndex != "":
taskIndex = int(taskIndex) - 1
if ws.arg('del', responsearr) != '':
taskdevicenumber = 0
ttid = -1
try:
ttid = settings.Tasks[taskIndex].pluginid
except:
ttid = -1
if ttid != -1:
try:
settings.Tasks[taskIndex].plugin_exit()
taskIndexNotSet = True
settings.Tasks[taskIndex] = False
settings.savetasks() # savetasksettings!!!
except Exception as e:
misc.addLog(pglobals.LOG_LEVEL_ERROR,
"Deleting failed: " + str(e))
if runIndex != "":
if len(settings.Tasks) < 1:
return False
try:
s = int(runIndex)
except:
s = -1
try:
if s > 0 and (s <= len(settings.Tasks)):
s = s - 1 # array is 0 based, tasks is 1 based
if (type(settings.Tasks[s]) != bool) and (settings.Tasks[s]):
if (settings.Tasks[s].enabled):
settings.Tasks[s].plugin_read()
except Exception as e:
print(e)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
if taskIndexNotSet == False: #Show edit form if a specific entry is chosen with the edit button
ws.TXBuffer += "<form name='frmselect' method='post'><table class='normal'>"
ws.addFormHeader("Task Settings")
ws.TXBuffer += "<TR><TD style='width:150px;' align='left'>Device:<TD>"
tte = taskdevicenumber
try:
tte = settings.Tasks[taskIndex].pluginid
except:
pass
if (tte <= 0):
ws.addSelector_Head("TDNUM", True)
for y in range(0, len(pglobals.deviceselector)):
pname = pglobals.deviceselector[y][2]
try:
if int(pglobals.deviceselector[y][1]) != 0:
pname = "P" + str(int(
pglobals.deviceselector[y][1])).rjust(
3, "0") + " - " + pglobals.deviceselector[y][2]
except:
pass
ws.addSelector_Item(pname, int(pglobals.deviceselector[y][1]),
(pglobals.deviceselector[y][1] == tte),
False, "")
ws.addSelector_Foot()
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
else: # device selected
createnewdevice = True
try:
if (settings.Tasks[taskIndex].getpluginid() == int(tte)):
createnewdevice = False
except:
pass
exceptstr = ""
gc.collect()
if createnewdevice:
for y in range(len(pglobals.deviceselector)):
if int(pglobals.deviceselector[y][1]) == int(tte):
if len(settings.Tasks) <= taskIndex:
while len(settings.Tasks) <= taskIndex:
settings.Tasks.append(False)
try:
m = __import__(pglobals.deviceselector[y][0])
except Exception as e:
settings.Tasks[taskIndex] = False
exceptstr += str(e)
m = False
if m:
try:
settings.Tasks[taskIndex] = m.Plugin(taskIndex)
except Exception as e:
settings.Tasks.append(m.Plugin(taskIndex))
exceptstr += str(e)
break
if settings.Tasks[taskIndex] == False:
ws.TXBuffer += "Importing failed: {0}</td></tr></table>".format(
exceptstr)
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
return True
else:
try:
enableit = (ws.arg("TDE", responsearr) == "on")
# print("plugin init",enableit)
if enableit:
settings.Tasks[taskIndex].plugin_init(
True
) # call plugin init / (ws.arg("TDE",responsearr) == "on")
else:
settings.Tasks[taskIndex].plugin_init(
) # call plugin init / (ws.arg("TDE",responsearr) == "on")
except:
pass
if edit != '' and not (taskIndexNotSet): # when form submitted
if taskdevicenumber != 0: # save settings
if taskdevicetimer > 0:
settings.Tasks[taskIndex].interval = taskdevicetimer
else:
if not (settings.Tasks[taskIndex].timeroptional
): # set default delay
settings.Tasks[
taskIndex].interval = settings.Settings[
"Delay"]
else:
settings.Tasks[taskIndex].interval = 0
tasknamestr = str(ws.arg("TDN", responsearr)).strip()
settings.Tasks[taskIndex].taskname = tasknamestr.replace(
" ", "")
if tasknamestr:
settings.Tasks[taskIndex].taskdeviceport = ws.arg(
"TDP", responsearr)
maxcon = len(settings.Controllers)
if maxcon > pglobals.CONTROLLER_MAX:
maxcon = pglobals.CONTROLLER_MAX
for controllerNr in range(0, maxcon):
if ((settings.Controllers[controllerNr]) and
(settings.Controllers[controllerNr].enabled)):
sid = "TDSD"
sid += str(controllerNr + 1)
settings.Tasks[taskIndex].senddataenabled[
controllerNr] = (ws.arg(sid,
responsearr) == "on")
if (settings.Tasks[taskIndex].
senddataenabled[controllerNr]):
if (settings.Controllers[controllerNr]):
if (settings.Controllers[controllerNr].
enabled):
settings.Tasks[taskIndex].controllercb[
controllerNr] = settings.Controllers[
controllerNr].senddata
if (settings.Tasks[taskIndex].
senddataenabled[controllerNr]):
sid = "TDID"
sid += str(controllerNr + 1)
ctrlidx = str(ws.arg(sid, responsearr)).strip()
if ctrlidx == "":
ctrlidx = -1
else:
ctrlidx = int(ctrlidx)
settings.Tasks[taskIndex].controlleridx[
controllerNr] = ctrlidx
for pins in range(0, 4):
pinnum = ws.arg("taskdevicepin" + str(pins + 1),
responsearr)
if pinnum:
settings.Tasks[taskIndex].taskdevicepin[
pins] = int(pinnum)
# if settings.Tasks[taskIndex].pullupoption:
# settings.Tasks[taskIndex].pullup = (ws.arg("TDPPU",responsearr) == "on")
if settings.Tasks[taskIndex].inverselogicoption:
settings.Tasks[taskIndex].pininversed = (ws.arg(
"TDPI", responsearr) == "on")
for varnr in range(0,
settings.Tasks[taskIndex].valuecount):
tvname = str(
ws.arg("TDVN" + str(varnr + 1), responsearr))
if tvname:
settings.Tasks[taskIndex].valuenames[
varnr] = tvname.replace(" ", "")
settings.Tasks[taskIndex].formula[varnr] = ws.arg(
"TDF" + str(varnr + 1), responsearr)
tvdec = ws.arg("TDVD" + str(varnr + 1),
responsearr)
if tvdec == "" or tvdec == False or tvdec == None:
tvdec = 0
settings.Tasks[taskIndex].decimals[varnr] = tvdec
else:
settings.Tasks[taskIndex].valuenames[varnr] = ""
try:
settings.Tasks[taskIndex].i2c = int(
ws.arg("i2c", responsearr))
except:
settings.Tasks[taskIndex].i2c = -1
try:
settings.Tasks[taskIndex].spi = int(
ws.arg("spi", responsearr))
except:
settings.Tasks[taskIndex].spi = -1
if settings.Tasks[taskIndex].taskname == "":
settings.Tasks[taskIndex].enabled = False
settings.Tasks[taskIndex].webform_save(
responsearr) # call plugin read FORM
settings.Tasks[taskIndex].enabled = (ws.arg(
"TDE", responsearr) == "on")
settings.savetasks() # savetasksettings!!!
ws.TXBuffer += "<input type='hidden' name='TDNUM' value='{0}'>{1}".format(
settings.Tasks[taskIndex].pluginid,
settings.Tasks[taskIndex].getdevicename())
ws.addFormTextBox("Name", "TDN",
str(settings.Tasks[taskIndex].gettaskname()), 40)
ws.addFormCheckBox("Enabled", "TDE",
settings.Tasks[taskIndex].enabled)
# section: Sensor / Actuator
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
if (settings.Tasks[taskIndex].dtype >= pglobals.DEVICE_TYPE_SINGLE
and settings.Tasks[taskIndex].dtype <=
pglobals.DEVICE_TYPE_QUAD):
ws.addFormSubHeader("Sensor" if settings.Tasks[taskIndex].
senddataoption else "Actuator")
# if (Settings.Tasks[taskIndex].ports != 0):
# addFormNumericBox("Port", "TDP", Settings.Tasks[taskIndex].taskdeviceport)
# if (settings.Tasks[taskIndex].pullupoption):
# ws.addFormCheckBox("Internal PullUp", "TDPPU", settings.Tasks[taskIndex].pullup)
if (settings.Tasks[taskIndex].inverselogicoption):
ws.addFormCheckBox("Inversed Logic", "TDPI",
settings.Tasks[taskIndex].pininversed)
if (settings.Tasks[taskIndex].dtype >=
pglobals.DEVICE_TYPE_SINGLE
and settings.Tasks[taskIndex].dtype <=
pglobals.DEVICE_TYPE_QUAD):
ws.addFormPinSelect(
"1st GPIO", "taskdevicepin1",
settings.Tasks[taskIndex].taskdevicepin[0],
settings.Tasks[taskIndex].pinfilter[0])
if (settings.Tasks[taskIndex].dtype >=
pglobals.DEVICE_TYPE_DUAL
and settings.Tasks[taskIndex].dtype <=
pglobals.DEVICE_TYPE_QUAD):
ws.addFormPinSelect(
"2nd GPIO", "taskdevicepin2",
settings.Tasks[taskIndex].taskdevicepin[1],
settings.Tasks[taskIndex].pinfilter[1])
if (settings.Tasks[taskIndex].dtype >=
pglobals.DEVICE_TYPE_TRIPLE
and settings.Tasks[taskIndex].dtype <=
pglobals.DEVICE_TYPE_QUAD):
ws.addFormPinSelect(
"3rd GPIO", "taskdevicepin3",
settings.Tasks[taskIndex].taskdevicepin[2],
settings.Tasks[taskIndex].pinfilter[2])
if (settings.Tasks[taskIndex].dtype ==
pglobals.DEVICE_TYPE_QUAD):
ws.addFormPinSelect(
"4th GPIO", "taskdevicepin4",
settings.Tasks[taskIndex].taskdevicepin[3],
settings.Tasks[taskIndex].pinfilter[3])
if (settings.Tasks[taskIndex].dtype == pglobals.DEVICE_TYPE_I2C):
try:
import inc.libhw as libhw
options = libhw.geti2clist()
except:
options = []
ws.addHtml("<tr><td>I2C line:<td>")
ws.addSelector_Head("i2c", True)
for d in range(len(options)):
ws.addSelector_Item(
"I2C" + str(options[d]), options[d],
(settings.Tasks[taskIndex].i2c == options[d]), False)
ws.addSelector_Foot()
if (settings.Tasks[taskIndex].dtype == pglobals.DEVICE_TYPE_SPI):
try:
import inc.libhw as libhw
options = libhw.getspilist()
except:
options = []
ws.addHtml("<tr><td>SPI line:<td>")
ws.addSelector_Head("spi", True)
for d in range(len(options)):
ws.addSelector_Item(
"SPI" + str(options[d]), options[d],
(settings.Tasks[taskIndex].spi == options[d]), False)
ws.addSelector_Foot()
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
try:
settings.Tasks[taskIndex].webform_load(
) # call plugin function to fill ws.TXBuffer
except Exception as e:
print(e)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
if (settings.Tasks[taskIndex].senddataoption
): # section: Data Acquisition
ws.addFormSubHeader("Data Acquisition")
maxcon = len(settings.Controllers)
if maxcon > pglobals.CONTROLLER_MAX:
maxcon = pglobals.CONTROLLER_MAX
for controllerNr in range(0, maxcon):
if ((settings.Controllers[controllerNr])
and (settings.Controllers[controllerNr].enabled)):
sid = "TDSD"
sid += str(controllerNr + 1)
ws.TXBuffer += "<TR><TD>Send to Controller {0}<TD>".format(
ws.getControllerSymbol(controllerNr))
ws.addCheckBox(
sid, settings.Tasks[taskIndex].
senddataenabled[controllerNr])
sid = "TDID"
sid += str(controllerNr + 1)
if (settings.Controllers[controllerNr].enabled
) and settings.Tasks[taskIndex].senddataenabled[
controllerNr]:
if (settings.Controllers[controllerNr].usesID):
ws.TXBuffer += "<TR><TD>IDX:<TD>"
ws.addNumericBox(
sid, settings.Tasks[taskIndex].
controlleridx[controllerNr], 0, 9999)
else:
ws.TXBuffer += "<input type='hidden' name='{0}' value='0'>".format(
sid) # no id, set to 0
else:
ws.TXBuffer += "<input type='hidden' name='{0}' value='-1'>".format(
sid) # disabled set to -1
ws.addFormSeparator(2)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
if (settings.Tasks[taskIndex].timeroption):
ws.addFormNumericBox("Interval", "TDT",
settings.Tasks[taskIndex].interval, 0,
65535)
ws.addUnit("sec")
if (settings.Tasks[taskIndex].timeroptional):
ws.TXBuffer += " (Optional for this Device)"
if (settings.Tasks[taskIndex].valuecount > 0): # //section: Values
ws.addFormSubHeader("Values")
ws.TXBuffer += "</table><table class='normal'><TR><TH style='width:30px;' align='center'>#<TH align='left'>Name"
if (settings.Tasks[taskIndex].formulaoption):
ws.TXBuffer += "<TH align='left'>Formula"
if (settings.Tasks[taskIndex].formulaoption
or settings.Tasks[taskIndex].decimalsonly):
ws.TXBuffer += "<TH style='width:30px;' align='left'>Decimals"
for varNr in range(0, settings.Tasks[taskIndex].valuecount):
ws.TXBuffer += "<TR><TD>{0}<TD>".format(str(varNr + 1))
sid = "TDVN" + str(varNr + 1)
ws.addTextBox(
sid,
settings.Tasks[taskIndex].getdevicevaluenames()[varNr],
40)
if (settings.Tasks[taskIndex].formulaoption):
ws.TXBuffer += "<TD>"
sid = "TDF" + str(varNr + 1)
ws.addTextBox(sid,
settings.Tasks[taskIndex].formula[varNr],
140)
if (settings.Tasks[taskIndex].formulaoption
or settings.Tasks[taskIndex].decimalsonly):
ws.TXBuffer += "<TD>"
sid = "TDVD" + str(varNr + 1)
ws.addNumericBox(
sid, settings.Tasks[taskIndex].decimals[varNr], 0,
6)
ws.addFormSeparator(4)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
gc.collect()
ws.TXBuffer += "<TR><TD><TD colspan='3'><a class='button link' href='devices?setpage={0}'>Close</a>".format(
page)
ws.addSubmitButton()
ws.TXBuffer += "<input type='hidden' name='edit' value='1'>"
if taskIndex != '':
ws.TXBuffer += "<input type='hidden' name='index' value='{0}'>".format(
taskIndex + 1)
ws.TXBuffer += "<input type='hidden' name='page' value='1'>"
if (tte > 0): # if user selected a device, add the delete button
ws.addSubmitButton("Delete", "del")
ws.TXBuffer += "</table></form>"
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
def handle_root(httpResponse, responsearr):
ws.navMenuIndex = 0
ws.TXBuffer = ""
responsestr = ""
try:
redir = settings.AdvSettings["startpage"]
except:
redir = "/"
if redir != "/":
return httpResponse.WriteResponseRedirect(redir)
httpResponse.WriteResponseOk(headers=({
'Cache-Control': 'no-cache'
}),
contentType='text/html',
contentCharset='UTF-8',
content="")
ws.sendHeadandTail("TmplStd", ws._HEAD)
try:
cmdline = ws.arg("cmd", responsearr).strip()
if cmdline.startswith('reboot'):
ws.sendHeadandTail("TmplStd", ws._TAIL)
if len(cmdline) > 0:
import commands
responsestr = str(commands.doExecuteCommand(cmdline))
except:
pass
if len(responsestr) > 0:
ws.TXBuffer += "<P>{0}<p>".format(responsestr)
ws.TXBuffer += "<form><table class='normal'><tr><TH style='width:150px;' align='left'>System Info<TH align='left'>Value<TR><TD>Unit:<TD>"
ws.TXBuffer += str(settings.Settings["Unit"])
ws.TXBuffer += "<TR><TD>Uptime:<TD>" + str(misc.getuptime(1))
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
try:
ws.TXBuffer += "<TR><TD>Free Mem:<TD>" + str(
int(esp_os.get_memory()['f'] / 1024)) + " kB"
except:
pass
ws.TXBuffer += "<TR><TD>IP:<TD>" + str(unet.get_ip())
ws.TXBuffer += "<TR><TD>Wifi RSSI:<TD>" + str(unet.get_rssi())
ws.TXBuffer += '<tr><td>Build<td>' + str(pglobals.PROGNAME) + " " + str(
pglobals.PROGVER)
ws.TXBuffer += "<TR><TD><TD>"
ws.addButton("sysinfo", "More info")
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
ws.TXBuffer += "</table><BR>"
if len(settings.nodelist) > 0:
ws.TXBuffer += "<BR><table class='multirow'><TR><TH>Node List<TH>Name<TH>Build<TH>Type<TH>IP<TH>Age"
for n in settings.nodelist:
ws.TXBuffer += "<TR><TD>Unit " + str(n["unitno"]) + "<TD>" + str(
n["name"]) + "<TD>" + str(n["build"]) + "<TD>"
ntype = ""
if int(n["type"]) == pglobals.NODE_TYPE_ID_ESP_EASY_STD:
ntype = "ESP Easy"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_ESP_EASYM_STD:
ntype = "ESP Easy Mega"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_ESP_EASY32_STD:
ntype = "ESP Easy32"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_ARDUINO_EASY_STD:
ntype = "Arduino Easy"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_NANO_EASY_STD:
ntype = "Nano Easy"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_RPI_EASY_STD:
ntype = "RPI Easy"
ws.TXBuffer += ntype + "<TD>"
waddr = str(n["ip"])
if str(n["port"]) != "" and str(n["port"]) != "0" and str(
n["port"]) != "80":
waddr += ":" + str(n["port"])
ws.addWideButton("http://" + waddr, waddr, "")
ws.TXBuffer += "<TD>" + str(n["age"])
ws.TXBuffer += "</table></form>"
if len(settings.p2plist) > 0:
try:
ws.TXBuffer += "<BR><table class='multirow'><TR><TH>Protocol<TH>P2P node number<TH>Name<TH>Build<TH>Type<TH>MAC<TH>RSSI<TH>Last seen<TH>Capabilities"
for n in settings.p2plist:
hstr = str(n["protocol"])
if hstr == "ESPNOW":
hstr = "<a href='espnow'>" + hstr + "</a>"
ws.TXBuffer += "<TR><TD>" + hstr + "<TD>Unit " + str(
n["unitno"]) + "<TD>" + str(n["name"]) + "<TD>" + str(
n["build"]) + "<TD>"
ntype = "Unknown"
if int(n["type"]) == pglobals.NODE_TYPE_ID_ESP_EASY_STD:
ntype = "ESP Easy"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_ESP_EASYM_STD:
ntype = "ESP Easy Mega"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_ESP_EASY32_STD:
ntype = "ESP Easy32"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_ARDUINO_EASY_STD:
ntype = "Arduino Easy"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_NANO_EASY_STD:
ntype = "Nano Easy"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_RPI_EASY_STD:
ntype = "RPI Easy"
elif int(n["type"]) == pglobals.NODE_TYPE_ID_ATMEGA_EASY_LORA:
ntype = "LoRa32u4"
ws.TXBuffer += ntype
ws.TXBuffer += "<TD>" + str(n["mac"])
ws.TXBuffer += "<TD>" + str(n["lastrssi"])
ldt = n["lastseen"]
lstr = ""
try:
lstr = '{:04}-{:02}-{:02} {:02}:{:02}:{:02}'.format(
ldt[0], ldt[1], ldt[2], ldt[3], ldt[4], ldt[5])
except:
lstr = str(ldt)
ws.TXBuffer += "<TD>" + lstr
wm = int(n["cap"])
wms = ""
if (wm & 1) == 1:
wms = "SEND "
if (wm & 2) == 2:
wms += "RECEIVE "
ws.TXBuffer += "<TD>" + wms
ws.TXBuffer += "</table></form>"
except Exception as e:
pass
ws.sendHeadandTail("TmplStd", ws._TAIL)
httpResponse._write(ws.TXBuffer, strEncoding='UTF-8')
ws.TXBuffer = ""
