Add files via upload

upload local files

Author: marcielbp

firmware/esp32-cam-micropython.bin

@@ -0,0 +1,129 @@
+#!/usr/bin/env micropython
+# -*- coding: utf-8 -*-
+
+import network
+from machine import Pin, Timer, I2C, ADC
+import camera
+import machine
+import time
+import uasyncio as asyncio
+import ubinascii
+import gc
+import usocket
+import json
+import urequests
+
+__author__ = "Marciel Barros Pereira"
+__credits__ = ["Marciel Barros Pereira"]
+__maintainer__ = "Marciel Barros Pereira"
+__email__ = "[email protected]"
+
+
+
+
+sta_if = network.WLAN(network.STA_IF)
+sta_if.active(True)
+try:
+    sta_if.disconnect()
+except:
+    pass
+redes = sta_if.scan()
+
+knownSsid = [b'put',b'your',b'known',b'essid-here']
+knownPasswd = [b'put',b'known-essid',b'passwords',b'here']
+
+ssidmode = False
+for i in range (0,len(knownSsid)):
+    for j in range (0,len(redes)):
+        print("Compare {} with {}".format(knownSsid[i],redes[j][0]))
+        if (knownSsid[i]==redes[j][0]):
+            print("Connecting to {}".format(knownSsid[i]))
+            sta_if.connect(knownSsid[i],knownPasswd[i])
+            while sta_if.isconnected() == False:
+                pass
+            print('Connection successful')
+            ssid = knownSsid[i]
+            ssidmode = True
+            print(sta_if.ifconfig())
+            break
+# check framesize modes in https://github.com/shariltumin/esp32-cam-micropython
+camera.init()
+camera.framesize(5)
+buf = camera.capture()
+camera.deinit()
+
+# there is no need to save right now, but, if you want to save file, use followigng code
+# newFile = open("ESP32-CAM.jpg", "wb")
+# newFile.write(buf)
+# newFile.close()
+
+# Create base64 string from image bytearray
+bufBase64 = ubinascii.b2a_base64(buf)
+
+# gather some free memory
+gc.collect()
+
+myScriptID = 'putYourScriptIdHere'
+url = 'https://script.google.com/macros/s/'+myScriptID+'/exec'
+myScript = '/macros/s/'+myScriptID+'/exec'
+
+myFilename = "filename=ESP32-CAM.jpg&mimetype=image/jpeg&data="
+#myFilename = "imgBase64="
+myDomain = "script.google.com"
+
+# below lines were adapted from urequests lib
+
+a = bufBase64.decode()
+data = myFilename + a
+method = "POST"
+try:
+    proto, dummy, host, path = url.split("/", 3)
+except ValueError:
+    proto, dummy, host = url.split("/", 2)
+    path = ""
+if proto == "http:":
+    port = 80
+elif proto == "https:":
+    import ussl
+    port = 443
+else:
+    raise ValueError("Unsupported protocol: " + proto)
+
+if ":" in host:
+    host, port = host.split(":", 1)
+    port = int(port)
+
+ai = usocket.getaddrinfo(host, port, 0, usocket.SOCK_STREAM)
+ai = ai[0]
+
+s = usocket.socket(ai[0], ai[1], ai[2])
+
+s.connect(ai[-1])
+if proto == "https:":
+    s = ussl.wrap_socket(s, server_hostname=host)
+s.write(b"%s /%s HTTP/1.0\r\n" % (method, path))
+
+s.write(b"Host: %s\r\n" % host)
+# Iterate over keys to avoid tuple alloc
+s.write(b"Content-Length: %d\r\n" % len(data))
+s.write(b"Content-Type: application/x-www-form-urlencoded\r\n")
+s.write(b"\r\n")
+
+s.write(data)
+
+l = s.readline()
+
+l = l.split(None, 2)
+status = int(l[1])
+reason = ""
+if len(l) > 2:
+    reason = l[2].rstrip()
+while True:
+    l = s.readline()
+    if not l or l == b"\r\n":
+        break
+    if l.startswith(b"Transfer-Encoding:"):
+        if b"chunked" in l:
+            raise ValueError("Unsupported " + l)
+    elif l.startswith(b"Location:") and not 200 <= status <= 299:
+        raise NotImplementedError("Redirects not yet supported")

src/googleDriveTest.py

@@ -0,0 +1,258 @@
+import uerrno
+import uselect as select
+import usocket as _socket
+from uasyncio.core import *
+
+
+DEBUG = 0
+log = None
+
+def set_debug(val):
+    global DEBUG, log
+    DEBUG = val
+    if val:
+        import logging
+        log = logging.getLogger("uasyncio")
+
+
+class PollEventLoop(EventLoop):
+
+    def __init__(self, runq_len=16, waitq_len=16):
+        EventLoop.__init__(self, runq_len, waitq_len)
+        self.poller = select.poll()
+        self.objmap = {}
+
+    def add_reader(self, sock, cb, *args):
+        if DEBUG and __debug__:
+            log.debug("add_reader%s", (sock, cb, args))
+        if args:
+            self.poller.register(sock, select.POLLIN)
+            self.objmap[id(sock)] = (cb, args)
+        else:
+            self.poller.register(sock, select.POLLIN)
+            self.objmap[id(sock)] = cb
+
+    def remove_reader(self, sock):
+        if DEBUG and __debug__:
+            log.debug("remove_reader(%s)", sock)
+        self.poller.unregister(sock)
+        del self.objmap[id(sock)]
+
+    def add_writer(self, sock, cb, *args):
+        if DEBUG and __debug__:
+            log.debug("add_writer%s", (sock, cb, args))
+        if args:
+            self.poller.register(sock, select.POLLOUT)
+            self.objmap[id(sock)] = (cb, args)
+        else:
+            self.poller.register(sock, select.POLLOUT)
+            self.objmap[id(sock)] = cb
+
+    def remove_writer(self, sock):
+        if DEBUG and __debug__:
+            log.debug("remove_writer(%s)", sock)
+        try:
+            self.poller.unregister(sock)
+            self.objmap.pop(id(sock), None)
+        except OSError as e:
+            # StreamWriter.awrite() first tries to write to a socket,
+            # and if that succeeds, yield IOWrite may never be called
+            # for that socket, and it will never be added to poller. So,
+            # ignore such error.
+            if e.args[0] != uerrno.ENOENT:
+                raise
+
+    def wait(self, delay):
+        if DEBUG and __debug__:
+            log.debug("poll.wait(%d)", delay)
+        # We need one-shot behavior (second arg of 1 to .poll())
+        res = self.poller.ipoll(delay, 1)
+        #log.debug("poll result: %s", res)
+        # Remove "if res" workaround after
+        # https://github.com/micropython/micropython/issues/2716 fixed.
+        if res:
+            for sock, ev in res:
+                cb = self.objmap[id(sock)]
+                if ev & (select.POLLHUP | select.POLLERR):
+                    # These events are returned even if not requested, and
+                    # are sticky, i.e. will be returned again and again.
+                    # If the caller doesn't do proper error handling and
+                    # unregister this sock, we'll busy-loop on it, so we
+                    # as well can unregister it now "just in case".
+                    self.remove_reader(sock)
+                if DEBUG and __debug__:
+                    log.debug("Calling IO callback: %r", cb)
+                if isinstance(cb, tuple):
+                    cb[0](*cb[1])
+                else:
+                    cb.pend_throw(None)
+                    self.call_soon(cb)
+
+
+class StreamReader:
+
+    def __init__(self, polls, ios=None):
+        if ios is None:
+            ios = polls
+        self.polls = polls
+        self.ios = ios
+
+    def read(self, n=-1):
+        while True:
+            yield IORead(self.polls)
+            res = self.ios.read(n)
+            if res is not None:
+                break
+            # This should not happen for real sockets, but can easily
+            # happen for stream wrappers (ssl, websockets, etc.)
+            #log.warn("Empty read")
+        if not res:
+            yield IOReadDone(self.polls)
+        return res
+
+    def readexactly(self, n):
+        buf = b""
+        while n:
+            yield IORead(self.polls)
+            res = self.ios.read(n)
+            assert res is not None
+            if not res:
+                yield IOReadDone(self.polls)
+                break
+            buf += res
+            n -= len(res)
+        return buf
+
+    def readline(self):
+        if DEBUG and __debug__:
+            log.debug("StreamReader.readline()")
+        buf = b""
+        while True:
+            yield IORead(self.polls)
+            res = self.ios.readline()
+            assert res is not None
+            if not res:
+                yield IOReadDone(self.polls)
+                break
+            buf += res
+            if buf[-1] == 0x0a:
+                break
+        if DEBUG and __debug__:
+            log.debug("StreamReader.readline(): %s", buf)
+        return buf
+
+    def aclose(self):
+        yield IOReadDone(self.polls)
+        self.ios.close()
+
+    def __repr__(self):
+        return "<StreamReader %r %r>" % (self.polls, self.ios)
+
+
+class StreamWriter:
+
+    def __init__(self, s, extra):
+        self.s = s
+        self.extra = extra
+
+    def awrite(self, buf, off=0, sz=-1):
+        # This method is called awrite (async write) to not proliferate
+        # incompatibility with original asyncio. Unlike original asyncio
+        # whose .write() method is both not a coroutine and guaranteed
+        # to return immediately (which means it has to buffer all the
+        # data), this method is a coroutine.
+        if sz == -1:
+            sz = len(buf) - off
+        if DEBUG and __debug__:
+            log.debug("StreamWriter.awrite(): spooling %d bytes", sz)
+        while True:
+            res = self.s.write(buf, off, sz)
+            # If we spooled everything, return immediately
+            if res == sz:
+                if DEBUG and __debug__:
+                    log.debug("StreamWriter.awrite(): completed spooling %d bytes", res)
+                return
+            if res is None:
+                res = 0
+            if DEBUG and __debug__:
+                log.debug("StreamWriter.awrite(): spooled partial %d bytes", res)
+            assert res < sz
+            off += res
+            sz -= res
+            yield IOWrite(self.s)
+            #assert s2.fileno() == self.s.fileno()
+            if DEBUG and __debug__:
+                log.debug("StreamWriter.awrite(): can write more")
+
+    # Write piecewise content from iterable (usually, a generator)
+    def awriteiter(self, iterable):
+        for buf in iterable:
+            yield from self.awrite(buf)
+
+    def aclose(self):
+        yield IOWriteDone(self.s)
+        self.s.close()
+
+    def get_extra_info(self, name, default=None):
+        return self.extra.get(name, default)
+
+    def __repr__(self):
+        return "<StreamWriter %r>" % self.s
+
+
+def open_connection(host, port, ssl=False):
+    if DEBUG and __debug__:
+        log.debug("open_connection(%s, %s)", host, port)
+    ai = _socket.getaddrinfo(host, port, 0, _socket.SOCK_STREAM)
+    ai = ai[0]
+    s = _socket.socket(ai[0], ai[1], ai[2])
+    s.setblocking(False)
+    try:
+        s.connect(ai[-1])
+    except OSError as e:
+        if e.args[0] != uerrno.EINPROGRESS:
+            raise
+    if DEBUG and __debug__:
+        log.debug("open_connection: After connect")
+    yield IOWrite(s)
+#    if __debug__:
+#        assert s2.fileno() == s.fileno()
+    if DEBUG and __debug__:
+        log.debug("open_connection: After iowait: %s", s)
+    if ssl:
+        print("Warning: uasyncio SSL support is alpha")
+        import ussl
+        s.setblocking(True)
+        s2 = ussl.wrap_socket(s)
+        s.setblocking(False)
+        return StreamReader(s, s2), StreamWriter(s2, {})
+    return StreamReader(s), StreamWriter(s, {})
+
+
+def start_server(client_coro, host, port, backlog=10):
+    if DEBUG and __debug__:
+        log.debug("start_server(%s, %s)", host, port)
+    ai = _socket.getaddrinfo(host, port, 0, _socket.SOCK_STREAM)
+    ai = ai[0]
+    s = _socket.socket(ai[0], ai[1], ai[2])
+    s.setblocking(False)
+
+    s.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, 1)
+    s.bind(ai[-1])
+    s.listen(backlog)
+    while True:
+        if DEBUG and __debug__:
+            log.debug("start_server: Before accept")
+        yield IORead(s)
+        if DEBUG and __debug__:
+            log.debug("start_server: After iowait")
+        s2, client_addr = s.accept()
+        s2.setblocking(False)
+        if DEBUG and __debug__:
+            log.debug("start_server: After accept: %s", s2)
+        extra = {"peername": client_addr}
+        yield client_coro(StreamReader(s2), StreamWriter(s2, extra))
+
+
+import uasyncio.core
+uasyncio.core._event_loop_class = PollEventLoop