def protect():
""" Checks if the battery level is sufficient, and checks the number of brownout reset.
If the battery is too low, we enter indefinite deep sleep to protect the battery """
# Can only be done once at boot before start the camera and sd card
batteryLevel = Battery.getLevel()
# If the battery is too low
if batteryLevel > 5:
batteryProtect = False
# If the battery level can't be read
elif batteryLevel < 0:
# If the reset is due to insufficient battery
if machine.reset_cause() == machine.BROWNOUT_RESET:
batteryProtect = True
else:
batteryProtect = False
else:
batteryProtect = True
brownoutCounter = 0
# If the reset can probably due to insufficient battery
if machine.reset_cause() == machine.BROWNOUT_RESET:
try:
file = open("brownout.txt", "r")
val = file.read()
brownoutCounter = int(val) + 1
except Exception as err:
print(useful.exception(err))
try:
file = open("brownout.txt", "w")
file.write("%d" % brownoutCounter)
file.flush()
file.close()
except Exception as err:
print(useful.exception(err))
# If the battery level seems sufficient
if batteryProtect == False:
# if the number of consecutive brownout resets is too high
if brownoutCounter > 10:
# Battery too low, save the battery status
file = open("battery.txt", "w")
file.write(
"Too many brownout reset with battery level at %d %%" %
batteryLevel)
file.flush()
file.close()
batteryProtect = True
# Case the battery has not enough current and must be protected
if batteryProtect:
print("#####################################")
print("# DEEP SLEEP TO PROTECT THE BATTERY #")
print("#####################################")
machine.deepsleep()
else:
# Set the wake up on PIR detection
Battery.setPinWakeUp()
async def reboot(request, response, args):
try:
await response.sendOk()
except Exception as err:
print(useful.exception(err))
try:
import machine
print("Reboot")
machine.reset()
except Exception as err:
print(useful.exception(err))
def execCommand(args):
""" Execute command """
commandName = ""
commandFunction = None
commandParams = []
commandFlags = []
try:
if len(args) >= 1:
paramsCount = 0
flags = {}
for arg in args:
arg = arg.strip()
if len(arg) > 0:
if commandName == "":
commandName, commandFunction, commandParams, commandFlags = getCommand(
arg)
else:
if len(arg) >= 2 and arg[:2] == "--":
for commandFlag in commandFlags:
if arg.strip()[2:] == commandFlag[1].strip():
flags[commandFlag[1]] = commandFlag[2]
break
else:
raise Exception("Illegal option '%s' for" %
arg)
elif arg[0] == "-":
for commandFlag in commandFlags:
if arg.strip() == commandFlag[0].strip():
flags[commandFlag[1]] = commandFlag[2]
break
else:
raise Exception("Illegal option '%s' for" %
arg)
else:
if paramsCount >= len(commandParams):
raise Exception("Too many parameters for")
else:
flags[commandParams[paramsCount]] = arg
paramsCount += 1
except Exception as err:
# print(useful.exception(err))
print(err)
return
try:
if commandName.strip() != "":
commandFunction(**flags)
except TypeError as err:
print("Missing parameters for '%s'" % commandName)
print(useful.exception(err))
except KeyboardInterrupt:
print("Canceled")
except Exception as err:
print(useful.exception(err))
def configure(ipaddress = None, netmask = None, gateway = None, dns = None):
""" Configure the access point """
if ipaddress != None: AccessPoint.config.ipaddress = useful.tobytes(ipaddress)
if netmask != None: AccessPoint.config.netmask = useful.tobytes(netmask)
if gateway != None: AccessPoint.config.gateway = useful.tobytes(gateway)
if dns != None: AccessPoint.config.dns = useful.tobytes(dns)
if AccessPoint.config.ipaddress == b"": AccessPoint.config.ipaddress = useful.tobytes(AccessPoint.wlan.ifconfig()[0])
if AccessPoint.config.netmask == b"": AccessPoint.config.netmask = useful.tobytes(AccessPoint.wlan.ifconfig()[1])
if AccessPoint.config.gateway == b"": AccessPoint.config.gateway = useful.tobytes(AccessPoint.wlan.ifconfig()[2])
if AccessPoint.config.dns == b"": AccessPoint.config.dns = useful.tobytes(AccessPoint.wlan.ifconfig()[3])
if AccessPoint.config.ipaddress == b"0.0.0.0": AccessPoint.config.ipaddress = b""
if AccessPoint.config.netmask == b"0.0.0.0": AccessPoint.config.netmask = b""
if AccessPoint.config.gateway == b"0.0.0.0": AccessPoint.config.gateway = b""
if AccessPoint.config.dns == b"0.0.0.0": AccessPoint.config.dns = b""
try:
if AccessPoint.config.ipaddress != b"" and \
AccessPoint.config.netmask != b"" and \
AccessPoint.config.gateway != b"" and \
AccessPoint.config.dns != b"":
AccessPoint.wlan.ifconfig((
useful.tostrings(AccessPoint.config.ipaddress),
useful.tostrings(AccessPoint.config.netmask),
useful.tostrings(AccessPoint.config.gateway),
useful.tostrings(AccessPoint.config.dns)))
except Exception as err:
print("Cannot configure wifi AccessPoint %s"%useful.exception(err))
def scandir(path, pattern, recursive, displayer=None):
""" Scan recursively a directory """
filenames = []
directories = []
if path == "":
path = "."
try:
if path != None and pattern != None:
for file in os.listdir(path):
if path != "":
filename = path + "/" + file
else:
filename = file
filename = filename.replace("//", "/")
filename = filename.replace("//", "/")
if useful.isdir(filename):
if displayer:
displayer.show(filename)
else:
directories.append(filename)
if recursive:
dirs, fils = scandir(filename, pattern, recursive,
displayer)
filenames += fils
directories += dirs
else:
if fnmatch(file, pattern):
if displayer:
displayer.show(filename)
else:
filenames.append(filename)
except Exception as error:
print(useful.exception(error))
return directories, filenames
async def cameraStartStreaming(request, response, args):
""" Start video streaming """
global cameraStreaming, cameraConfig
if cameraStreaming:
cameraStreaming = False
await uasyncio.sleep(0.2)
if request.port == 80 or request.port == 8080:
print("Streaming ignored")
return
try:
print("Start streaming")
startInactivityTimer()
Camera.open()
Camera.reserve()
Camera.configure(cameraConfig)
response.setStatus(b"200")
response.setHeader(b"Content-Type" ,b"multipart/x-mixed-replace")
response.setHeader(b"Transfer-Encoding" ,b"chunked")
response.setHeader(b"Access-Control-Allow-Origin",b"*")
await response.serialize(response.streamio)
writer = response.streamio
identifier = b"\r\n%x\r\n\r\n--%s\r\n\r\n"%(len(response.identifier) + 6, response.identifier)
frame = b'%s36\r\nContent-Type: image/jpeg\r\nContent-Length: %8d\r\n\r\n\r\n%x\r\n'
if useful.ismicropython():
micropython = True
else:
micropython = False
image = Camera.capture()
length = len(image)
await writer.write(frame%(b"", length, length))
await writer.write(image)
cameraStreaming = True
# count = 0
while cameraStreaming:
image = Camera.capture()
length = len(image)
await writer.write(frame%(identifier, length, length))
await writer.write(image)
if micropython == False:
await uasyncio.sleep(0.1)
# print("%d"%count)
# count += 1
except Exception as err:
print(useful.exception(err))
finally:
print("Stop streaming")
cameraStreaming = False
Camera.unreserve()
await writer.close()
async def onConnection(self, reader, writer):
""" Http server connection detected """
try:
# Preload the server
self.preload()
# Call on connection method
await self.server.onConnection(reader, writer)
except Exception as err:
print(useful.exception(err))
async def sendError(self, err): """ Send error to ftp client """ showError = False if type(err) != type(b""): if useful.ismicropython(): if type(err) != type(OSError): showError = True else: if isinstance(err,FileNotFoundError) or isinstance(err,NotADirectoryError): showError = False else: showError = True if showError: err = useful.exception(err) self.log(b"%s> %-10s %-30s : err=%s"%(useful.tobytes(self.cwd), self.command, self.payload, useful.tobytes(err))) await self.sendResponse(550, b"Failed")
async def onConnection(self, reader, writer):
""" Asynchronous connection detected """
try:
# Preload ftp core class
self.preload()
# Start ftp core
server = self.serverClass()
# Call on connection method
await server.onConnection(reader, writer)
# Close ftp core
server.close()
del server
except Exception as err:
print(useful.exception(err))
async def STOR(self): """ Ftp command STOR """ await self.sendResponse(150, b"Start receive file") self.log(b"Ftp receive file '%s'"%(self.root + self.path)) filename = self.root + self.path if useful.ismicropython(): try: self.writeFile(filename, self.pasvsocket) except Exception as err: self.logDebug(useful.exception(err)) directory, file = useful.split(useful.tostrings(filename)) useful.makedir(directory, True) self.writeFile(filename, self.pasvsocket) else: with open(filename, "wb") as file: data = b" " while len(data) > 0: data = self.pasvsocket.recv(1440) file.write(data) data = b"" await self.sendResponse(226, b"End receive file") self.closePasv()
def sendFileList(self, path, stream, full): """ Send the list of file """ now = useful.now() try: description = b"" counter = 0 for filename in sorted(os.listdir(useful.tostrings(path)), key = str.lower): description += self.getFileDescription(path, useful.tobytes(filename), full, now) counter += 1 if counter == 10: counter = 0 stream.write(description) description = b"" if description != b"": stream.write(description) except Exception as err: self.log(useful.exception(err)) pattern = path.split(b"/")[-1] path = path[:-(len(pattern) + 1)] if path == b"": path = b"/" for filename in sorted(os.listdir(useful.tostrings(path)), key = str.lower): if fnmatch(useful.tostrings(filename), useful.tostrings(pattern)) == True: stream.write(self.getFileDescription(path, useful.tobytes(filename), full, now))
async def detectMotion(onBattery, pirDetection):
""" Asynchronous motion detection main routine """
from server import asyncNotify, PushOverConfig
from motion import MotionConfig
import wifi
# Open push over notification object
pushoverConfig = PushOverConfig()
pushoverConfig.load()
# Open motion configuration
motionConfig = MotionConfig()
if motionConfig.load() == False:
motionConfig.save()
motion = None
reloadConfig = 0
previousReserved = None
pollingFrequency = 200
batteryLevel = -2
if onBattery:
if pirDetection == True:
pollingFrequency = 3
motionConfig.load()
wifiOn = False
startTime = time.time()
else:
wifiOn = True
while True:
# If the motion activated
if motionConfig.activated:
# If motion not initialized
if motion == None:
# The sdcard not available on battery
if onBattery == True:
sdcard = None
else:
sdcard = SdCard()
motion = Motion(sdcard, motionConfig, onBattery, pirDetection)
motion.open()
# If camera available to detect motion
if video.Camera.isReserved() == False:
# If the camera previously reserved
if previousReserved == True:
# Restore camera motion configuration
previousReserved = False
motion.resume()
try:
# If camera not stabilized speed start
if motion.isStabilized() == True:
await sleep_ms(pollingFrequency)
# If camera available to detect motion
if video.Camera.isReserved() == False:
# Capture motion image
detection = motion.capture()
# If camera not stabilized speed start
if motion.isStabilized() == True:
await sleep_ms(pollingFrequency)
# If camera available to detect motion
if video.Camera.isReserved() == False:
# If motion detected
if detection != None:
# Notify motion with push over
message, image = detection
# On battery the wifi start after taking pictures
if wifiOn == False:
from server import start
from tools import Battery
start(withoutServer=True)
wifiOn = True
batteryLevel = Battery.getLevel()
if batteryLevel >= 0:
message = message[:-4] + " Bat %s %%" % batteryLevel
await asyncNotify(pushoverConfig.user,
pushoverConfig.token, message,
image)
# Detect motion
detected, changePolling = motion.detect()
# If motion found
if changePolling == True:
# Speed up the polling frequency
pollingFrequency = 5
startTime = time.time()
else:
# Slow down the polling frequency
pollingFrequency = 300
except Exception as err:
print(useful.exception(err))
else:
# Camera buzy, motion capture suspended
previousReserved = True
print("Motion suspended")
await sleep_ms(3000)
else:
# Motion capture disabled
await sleep_ms(500)
reloadConfig += 1
# Reload configuration each 3 s
if reloadConfig % 5 == 0:
motionConfig.load()
# If the battery mode activated
if onBattery:
# If the motion detection activated
if motionConfig.activated:
# Wait duration after the last detection
if time.time() > startTime + motionConfig.awakeTime:
import machine
print("")
print("####################################")
print("# DEEP SLEEP TO WAIT PIR DETECTION #")
print("####################################")
machine.deepsleep(10000)