build(boards): micropython板卡执行 npm run build:prod
This commit is contained in:
王立帮
96
boards/default/micropython/build/lib/ags10.py
Normal file
96
boards/default/micropython/build/lib/ags10.py
Normal file
@@ -0,0 +1,96 @@
|
||||
"""
|
||||
AGS10
|
||||
|
||||
Micropython library for the AGS10(TVOC)
|
||||
=======================================================
|
||||
@dahanzimin From the Mixly Team
|
||||
"""
|
||||
import time
|
||||
from micropython import const
|
||||
|
||||
_AGS10_ADC = const(0x00)
|
||||
_AGS10_CAL = const(0x01)
|
||||
_AGS10_RES = const(0x20)
|
||||
_AGS10_ADD = const(0x21)
|
||||
|
||||
class AGS10:
|
||||
def __init__(self, i2c_bus, address=0x1A, delay=1000):
|
||||
self._i2c = i2c_bus
|
||||
self._addr = address
|
||||
self._voc = None
|
||||
self._delay = delay
|
||||
self._star = 0
|
||||
|
||||
def _crc8(self, buf, is_byte=False):
|
||||
'''Perform CRC check on the data'''
|
||||
crc = 0xff
|
||||
for byte in buf:
|
||||
crc ^= byte
|
||||
for _ in range(8):
|
||||
if crc & 0x80:
|
||||
crc = (crc << 1) ^ 0x31
|
||||
else:
|
||||
crc = crc << 1
|
||||
return crc.to_bytes(1, 'little') if is_byte else crc & 0xff
|
||||
|
||||
def _wreg(self, reg, buf):
|
||||
'''Write memory address'''
|
||||
self._i2c.writeto_mem(self._addr, reg, buf)
|
||||
time.sleep_ms(20)
|
||||
|
||||
def _rreg(self, reg, nbytes=5):
|
||||
'''Read memory address'''
|
||||
_buf = self._i2c.readfrom_mem(self._addr, reg, nbytes)
|
||||
time.sleep_ms(20)
|
||||
return _buf[:4] if self._crc8(_buf[:4]) == _buf[4] else None
|
||||
|
||||
def address(self, addr=None):
|
||||
_scan = self._i2c.scan()
|
||||
if addr is None:
|
||||
if self._addr in _scan:
|
||||
return self._addr
|
||||
elif len(_scan) == 1:
|
||||
self._addr = _scan[0]
|
||||
return self._addr
|
||||
else:
|
||||
return None
|
||||
else:
|
||||
if self.address():
|
||||
if 8<= addr <=119:
|
||||
_buf = bytes([addr, (~ addr) & 0xff] * 2)
|
||||
self._wreg(_AGS10_ADD, _buf + self._crc8(_buf, True))
|
||||
if addr in self._i2c.scan():
|
||||
self._addr = addr
|
||||
return True
|
||||
else:
|
||||
raise ValueError("Not within the valid range of 8-119")
|
||||
|
||||
def calibration(self, zero=1):
|
||||
'''0: Factory restoration 1:Sensor resistance'''
|
||||
_buf = b'\x00\x0c'
|
||||
_buf += b'\x00\x00' if zero else b'\xff\xff'
|
||||
self._wreg(_AGS10_ADD, _buf + self._crc8(_buf, True))
|
||||
|
||||
@property
|
||||
def getdata(self):
|
||||
if time.ticks_diff(time.ticks_ms(), self._star) >= self._delay:
|
||||
self._star = time.ticks_ms()
|
||||
_buf = self._rreg(_AGS10_ADC)
|
||||
if (_buf[0] & 0x01) == 0:
|
||||
self._voc = int.from_bytes(_buf[1:4], 'big')
|
||||
return self._voc / 1000
|
||||
|
||||
def read(self, hcho_mw=30.033 , co2_mv=0.853, co2_base=400):
|
||||
'''unit ppm'''
|
||||
self.getdata
|
||||
_voc = self._voc / 1000 #ppm
|
||||
return round( _voc, 2), round( _voc / hcho_mw, 2), co2_base + round( _voc / co2_mv, 2)
|
||||
|
||||
def tvoc(self):
|
||||
return self.read()[0]
|
||||
|
||||
def hcho(self, tvoc_mw=30.053):
|
||||
return self.read(hcho_mw=hcho_mw)[1]
|
||||
|
||||
def eco2(self, co2_mv=0.853):
|
||||
return self.read(co2_mv=co2_mv)[2]
|
||||
480
boards/default/micropython/build/lib/base64.py
Normal file
480
boards/default/micropython/build/lib/base64.py
Normal file
@@ -0,0 +1,480 @@
|
||||
#! /usr/bin/env python3
|
||||
|
||||
"""RFC 3548: Base16, Base32, Base64 Data Encodings"""
|
||||
|
||||
# Modified 04-Oct-1995 by Jack Jansen to use binascii module
|
||||
# Modified 30-Dec-2003 by Barry Warsaw to add full RFC 3548 support
|
||||
# Modified 22-May-2007 by Guido van Rossum to use bytes everywhere
|
||||
|
||||
import re
|
||||
import struct
|
||||
import binascii
|
||||
|
||||
|
||||
__all__ = [
|
||||
# Legacy interface exports traditional RFC 1521 Base64 encodings
|
||||
"encode",
|
||||
"decode",
|
||||
"encodebytes",
|
||||
"decodebytes",
|
||||
# Generalized interface for other encodings
|
||||
"b64encode",
|
||||
"b64decode",
|
||||
"b32encode",
|
||||
"b32decode",
|
||||
"b16encode",
|
||||
"b16decode",
|
||||
# Standard Base64 encoding
|
||||
"standard_b64encode",
|
||||
"standard_b64decode",
|
||||
# Some common Base64 alternatives. As referenced by RFC 3458, see thread
|
||||
# starting at:
|
||||
#
|
||||
# http://zgp.org/pipermail/p2p-hackers/2001-September/000316.html
|
||||
"urlsafe_b64encode",
|
||||
"urlsafe_b64decode",
|
||||
]
|
||||
|
||||
|
||||
bytes_types = (bytes, bytearray) # Types acceptable as binary data
|
||||
|
||||
|
||||
def _bytes_from_decode_data(s):
|
||||
if isinstance(s, str):
|
||||
try:
|
||||
return s.encode("ascii")
|
||||
# except UnicodeEncodeError:
|
||||
except:
|
||||
raise ValueError("string argument should contain only ASCII characters")
|
||||
elif isinstance(s, bytes_types):
|
||||
return s
|
||||
else:
|
||||
raise TypeError("argument should be bytes or ASCII string, not %s" % s.__class__.__name__)
|
||||
|
||||
|
||||
def _maketrans(f, t):
|
||||
"""Re-implement bytes.maketrans() as there is no such function in micropython"""
|
||||
if len(f) != len(t):
|
||||
raise ValueError("maketrans arguments must have same length")
|
||||
translation_table = dict(zip(f, t))
|
||||
return translation_table
|
||||
|
||||
|
||||
def _translate(input_bytes, trans_table):
|
||||
"""Re-implement bytes.translate() as there is no such function in micropython"""
|
||||
result = bytearray()
|
||||
|
||||
for byte in input_bytes:
|
||||
translated_byte = trans_table.get(byte, byte)
|
||||
result.append(translated_byte)
|
||||
|
||||
return bytes(result)
|
||||
|
||||
|
||||
# Base64 encoding/decoding uses binascii
|
||||
|
||||
|
||||
def b64encode(s, altchars=None):
|
||||
"""Encode a byte string using Base64.
|
||||
|
||||
s is the byte string to encode. Optional altchars must be a byte
|
||||
string of length 2 which specifies an alternative alphabet for the
|
||||
'+' and '/' characters. This allows an application to
|
||||
e.g. generate url or filesystem safe Base64 strings.
|
||||
|
||||
The encoded byte string is returned.
|
||||
"""
|
||||
if not isinstance(s, bytes_types):
|
||||
raise TypeError("expected bytes, not %s" % s.__class__.__name__)
|
||||
# Strip off the trailing newline
|
||||
encoded = binascii.b2a_base64(s)[:-1]
|
||||
if altchars is not None:
|
||||
if not isinstance(altchars, bytes_types):
|
||||
raise TypeError("expected bytes, not %s" % altchars.__class__.__name__)
|
||||
assert len(altchars) == 2, repr(altchars)
|
||||
encoded = _translate(encoded, _maketrans(b"+/", altchars))
|
||||
return encoded
|
||||
|
||||
|
||||
def b64decode(s, altchars=None, validate=False):
|
||||
"""Decode a Base64 encoded byte string.
|
||||
|
||||
s is the byte string to decode. Optional altchars must be a
|
||||
string of length 2 which specifies the alternative alphabet used
|
||||
instead of the '+' and '/' characters.
|
||||
|
||||
The decoded string is returned. A binascii.Error is raised if s is
|
||||
incorrectly padded.
|
||||
|
||||
If validate is False (the default), non-base64-alphabet characters are
|
||||
discarded prior to the padding check. If validate is True,
|
||||
non-base64-alphabet characters in the input result in a binascii.Error.
|
||||
"""
|
||||
s = _bytes_from_decode_data(s)
|
||||
if altchars is not None:
|
||||
altchars = _bytes_from_decode_data(altchars)
|
||||
assert len(altchars) == 2, repr(altchars)
|
||||
s = _translate(s, _maketrans(altchars, b"+/"))
|
||||
if validate and not re.match(b"^[A-Za-z0-9+/]*=*$", s):
|
||||
raise binascii.Error("Non-base64 digit found")
|
||||
return binascii.a2b_base64(s)
|
||||
|
||||
|
||||
def standard_b64encode(s):
|
||||
"""Encode a byte string using the standard Base64 alphabet.
|
||||
|
||||
s is the byte string to encode. The encoded byte string is returned.
|
||||
"""
|
||||
return b64encode(s)
|
||||
|
||||
|
||||
def standard_b64decode(s):
|
||||
"""Decode a byte string encoded with the standard Base64 alphabet.
|
||||
|
||||
s is the byte string to decode. The decoded byte string is
|
||||
returned. binascii.Error is raised if the input is incorrectly
|
||||
padded or if there are non-alphabet characters present in the
|
||||
input.
|
||||
"""
|
||||
return b64decode(s)
|
||||
|
||||
|
||||
# _urlsafe_encode_translation = _maketrans(b'+/', b'-_')
|
||||
# _urlsafe_decode_translation = _maketrans(b'-_', b'+/')
|
||||
|
||||
|
||||
def urlsafe_b64encode(s):
|
||||
"""Encode a byte string using a url-safe Base64 alphabet.
|
||||
|
||||
s is the byte string to encode. The encoded byte string is
|
||||
returned. The alphabet uses '-' instead of '+' and '_' instead of
|
||||
'/'.
|
||||
"""
|
||||
# return b64encode(s).translate(_urlsafe_encode_translation)
|
||||
return b64encode(s, b"-_").rstrip(b"\n")
|
||||
|
||||
|
||||
def urlsafe_b64decode(s):
|
||||
"""Decode a byte string encoded with the standard Base64 alphabet.
|
||||
|
||||
s is the byte string to decode. The decoded byte string is
|
||||
returned. binascii.Error is raised if the input is incorrectly
|
||||
padded or if there are non-alphabet characters present in the
|
||||
input.
|
||||
|
||||
The alphabet uses '-' instead of '+' and '_' instead of '/'.
|
||||
"""
|
||||
# s = _bytes_from_decode_data(s)
|
||||
# s = s.translate(_urlsafe_decode_translation)
|
||||
# return b64decode(s)
|
||||
raise NotImplementedError()
|
||||
|
||||
|
||||
# Base32 encoding/decoding must be done in Python
|
||||
_b32alphabet = {
|
||||
0: b"A",
|
||||
9: b"J",
|
||||
18: b"S",
|
||||
27: b"3",
|
||||
1: b"B",
|
||||
10: b"K",
|
||||
19: b"T",
|
||||
28: b"4",
|
||||
2: b"C",
|
||||
11: b"L",
|
||||
20: b"U",
|
||||
29: b"5",
|
||||
3: b"D",
|
||||
12: b"M",
|
||||
21: b"V",
|
||||
30: b"6",
|
||||
4: b"E",
|
||||
13: b"N",
|
||||
22: b"W",
|
||||
31: b"7",
|
||||
5: b"F",
|
||||
14: b"O",
|
||||
23: b"X",
|
||||
6: b"G",
|
||||
15: b"P",
|
||||
24: b"Y",
|
||||
7: b"H",
|
||||
16: b"Q",
|
||||
25: b"Z",
|
||||
8: b"I",
|
||||
17: b"R",
|
||||
26: b"2",
|
||||
}
|
||||
|
||||
_b32tab = [v[0] for k, v in sorted(_b32alphabet.items())]
|
||||
_b32rev = dict([(v[0], k) for k, v in _b32alphabet.items()])
|
||||
|
||||
|
||||
def b32encode(s):
|
||||
"""Encode a byte string using Base32.
|
||||
|
||||
s is the byte string to encode. The encoded byte string is returned.
|
||||
"""
|
||||
if not isinstance(s, bytes_types):
|
||||
raise TypeError("expected bytes, not %s" % s.__class__.__name__)
|
||||
quanta, leftover = divmod(len(s), 5)
|
||||
# Pad the last quantum with zero bits if necessary
|
||||
if leftover:
|
||||
s = s + bytes(5 - leftover) # Don't use += !
|
||||
quanta += 1
|
||||
encoded = bytearray()
|
||||
for i in range(quanta):
|
||||
# c1 and c2 are 16 bits wide, c3 is 8 bits wide. The intent of this
|
||||
# code is to process the 40 bits in units of 5 bits. So we take the 1
|
||||
# leftover bit of c1 and tack it onto c2. Then we take the 2 leftover
|
||||
# bits of c2 and tack them onto c3. The shifts and masks are intended
|
||||
# to give us values of exactly 5 bits in width.
|
||||
c1, c2, c3 = struct.unpack("!HHB", s[i * 5 : (i + 1) * 5])
|
||||
c2 += (c1 & 1) << 16 # 17 bits wide
|
||||
c3 += (c2 & 3) << 8 # 10 bits wide
|
||||
encoded += bytes(
|
||||
[
|
||||
_b32tab[c1 >> 11], # bits 1 - 5
|
||||
_b32tab[(c1 >> 6) & 0x1F], # bits 6 - 10
|
||||
_b32tab[(c1 >> 1) & 0x1F], # bits 11 - 15
|
||||
_b32tab[c2 >> 12], # bits 16 - 20 (1 - 5)
|
||||
_b32tab[(c2 >> 7) & 0x1F], # bits 21 - 25 (6 - 10)
|
||||
_b32tab[(c2 >> 2) & 0x1F], # bits 26 - 30 (11 - 15)
|
||||
_b32tab[c3 >> 5], # bits 31 - 35 (1 - 5)
|
||||
_b32tab[c3 & 0x1F], # bits 36 - 40 (1 - 5)
|
||||
]
|
||||
)
|
||||
# Adjust for any leftover partial quanta
|
||||
if leftover == 1:
|
||||
encoded = encoded[:-6] + b"======"
|
||||
elif leftover == 2:
|
||||
encoded = encoded[:-4] + b"===="
|
||||
elif leftover == 3:
|
||||
encoded = encoded[:-3] + b"==="
|
||||
elif leftover == 4:
|
||||
encoded = encoded[:-1] + b"="
|
||||
return bytes(encoded)
|
||||
|
||||
|
||||
def b32decode(s, casefold=False, map01=None):
|
||||
"""Decode a Base32 encoded byte string.
|
||||
|
||||
s is the byte string to decode. Optional casefold is a flag
|
||||
specifying whether a lowercase alphabet is acceptable as input.
|
||||
For security purposes, the default is False.
|
||||
|
||||
RFC 3548 allows for optional mapping of the digit 0 (zero) to the
|
||||
letter O (oh), and for optional mapping of the digit 1 (one) to
|
||||
either the letter I (eye) or letter L (el). The optional argument
|
||||
map01 when not None, specifies which letter the digit 1 should be
|
||||
mapped to (when map01 is not None, the digit 0 is always mapped to
|
||||
the letter O). For security purposes the default is None, so that
|
||||
0 and 1 are not allowed in the input.
|
||||
|
||||
The decoded byte string is returned. binascii.Error is raised if
|
||||
the input is incorrectly padded or if there are non-alphabet
|
||||
characters present in the input.
|
||||
"""
|
||||
s = _bytes_from_decode_data(s)
|
||||
quanta, leftover = divmod(len(s), 8)
|
||||
if leftover:
|
||||
raise binascii.Error("Incorrect padding")
|
||||
# Handle section 2.4 zero and one mapping. The flag map01 will be either
|
||||
# False, or the character to map the digit 1 (one) to. It should be
|
||||
# either L (el) or I (eye).
|
||||
if map01 is not None:
|
||||
map01 = _bytes_from_decode_data(map01)
|
||||
assert len(map01) == 1, repr(map01)
|
||||
s = _translate(s, _maketrans(b"01", b"O" + map01))
|
||||
if casefold:
|
||||
s = s.upper()
|
||||
# Strip off pad characters from the right. We need to count the pad
|
||||
# characters because this will tell us how many null bytes to remove from
|
||||
# the end of the decoded string.
|
||||
padchars = s.find(b"=")
|
||||
if padchars > 0:
|
||||
padchars = len(s) - padchars
|
||||
s = s[:-padchars]
|
||||
else:
|
||||
padchars = 0
|
||||
|
||||
# Now decode the full quanta
|
||||
parts = []
|
||||
acc = 0
|
||||
shift = 35
|
||||
for c in s:
|
||||
val = _b32rev.get(c)
|
||||
if val is None:
|
||||
raise binascii.Error("Non-base32 digit found")
|
||||
acc += _b32rev[c] << shift
|
||||
shift -= 5
|
||||
if shift < 0:
|
||||
parts.append(binascii.unhexlify(bytes("%010x" % acc, "ascii")))
|
||||
acc = 0
|
||||
shift = 35
|
||||
# Process the last, partial quanta
|
||||
last = binascii.unhexlify(bytes("%010x" % acc, "ascii"))
|
||||
if padchars == 0:
|
||||
last = b"" # No characters
|
||||
elif padchars == 1:
|
||||
last = last[:-1]
|
||||
elif padchars == 3:
|
||||
last = last[:-2]
|
||||
elif padchars == 4:
|
||||
last = last[:-3]
|
||||
elif padchars == 6:
|
||||
last = last[:-4]
|
||||
else:
|
||||
raise binascii.Error("Incorrect padding")
|
||||
parts.append(last)
|
||||
return b"".join(parts)
|
||||
|
||||
|
||||
# RFC 3548, Base 16 Alphabet specifies uppercase, but hexlify() returns
|
||||
# lowercase. The RFC also recommends against accepting input case
|
||||
# insensitively.
|
||||
def b16encode(s):
|
||||
"""Encode a byte string using Base16.
|
||||
|
||||
s is the byte string to encode. The encoded byte string is returned.
|
||||
"""
|
||||
if not isinstance(s, bytes_types):
|
||||
raise TypeError("expected bytes, not %s" % s.__class__.__name__)
|
||||
return binascii.hexlify(s).upper()
|
||||
|
||||
|
||||
def b16decode(s, casefold=False):
|
||||
"""Decode a Base16 encoded byte string.
|
||||
|
||||
s is the byte string to decode. Optional casefold is a flag
|
||||
specifying whether a lowercase alphabet is acceptable as input.
|
||||
For security purposes, the default is False.
|
||||
|
||||
The decoded byte string is returned. binascii.Error is raised if
|
||||
s were incorrectly padded or if there are non-alphabet characters
|
||||
present in the string.
|
||||
"""
|
||||
s = _bytes_from_decode_data(s)
|
||||
if casefold:
|
||||
s = s.upper()
|
||||
if re.search(b"[^0-9A-F]", s):
|
||||
raise binascii.Error("Non-base16 digit found")
|
||||
return binascii.unhexlify(s)
|
||||
|
||||
|
||||
# Legacy interface. This code could be cleaned up since I don't believe
|
||||
# binascii has any line length limitations. It just doesn't seem worth it
|
||||
# though. The files should be opened in binary mode.
|
||||
|
||||
MAXLINESIZE = 76 # Excluding the CRLF
|
||||
MAXBINSIZE = (MAXLINESIZE // 4) * 3
|
||||
|
||||
|
||||
def encode(input, output):
|
||||
"""Encode a file; input and output are binary files."""
|
||||
while True:
|
||||
s = input.read(MAXBINSIZE)
|
||||
if not s:
|
||||
break
|
||||
while len(s) < MAXBINSIZE:
|
||||
ns = input.read(MAXBINSIZE - len(s))
|
||||
if not ns:
|
||||
break
|
||||
s += ns
|
||||
line = binascii.b2a_base64(s)
|
||||
output.write(line)
|
||||
|
||||
|
||||
def decode(input, output):
|
||||
"""Decode a file; input and output are binary files."""
|
||||
while True:
|
||||
line = input.readline()
|
||||
if not line:
|
||||
break
|
||||
s = binascii.a2b_base64(line)
|
||||
output.write(s)
|
||||
|
||||
|
||||
def encodebytes(s):
|
||||
"""Encode a bytestring into a bytestring containing multiple lines
|
||||
of base-64 data."""
|
||||
if not isinstance(s, bytes_types):
|
||||
raise TypeError("expected bytes, not %s" % s.__class__.__name__)
|
||||
pieces = []
|
||||
for i in range(0, len(s), MAXBINSIZE):
|
||||
chunk = s[i : i + MAXBINSIZE]
|
||||
pieces.append(binascii.b2a_base64(chunk))
|
||||
return b"".join(pieces)
|
||||
|
||||
|
||||
def encodestring(s):
|
||||
"""Legacy alias of encodebytes()."""
|
||||
import warnings
|
||||
|
||||
warnings.warn("encodestring() is a deprecated alias, use encodebytes()", DeprecationWarning, 2)
|
||||
return encodebytes(s)
|
||||
|
||||
|
||||
def decodebytes(s):
|
||||
"""Decode a bytestring of base-64 data into a bytestring."""
|
||||
if not isinstance(s, bytes_types):
|
||||
raise TypeError("expected bytes, not %s" % s.__class__.__name__)
|
||||
return binascii.a2b_base64(s)
|
||||
|
||||
|
||||
def decodestring(s):
|
||||
"""Legacy alias of decodebytes()."""
|
||||
import warnings
|
||||
|
||||
warnings.warn("decodestring() is a deprecated alias, use decodebytes()", DeprecationWarning, 2)
|
||||
return decodebytes(s)
|
||||
|
||||
|
||||
# Usable as a script...
|
||||
def main():
|
||||
"""Small main program"""
|
||||
import sys, getopt
|
||||
|
||||
try:
|
||||
opts, args = getopt.getopt(sys.argv[1:], "deut")
|
||||
except getopt.error as msg:
|
||||
sys.stdout = sys.stderr
|
||||
print(msg)
|
||||
print(
|
||||
"""usage: %s [-d|-e|-u|-t] [file|-]
|
||||
-d, -u: decode
|
||||
-e: encode (default)
|
||||
-t: encode and decode string 'Aladdin:open sesame'"""
|
||||
% sys.argv[0]
|
||||
)
|
||||
sys.exit(2)
|
||||
func = encode
|
||||
for o, a in opts:
|
||||
if o == "-e":
|
||||
func = encode
|
||||
if o == "-d":
|
||||
func = decode
|
||||
if o == "-u":
|
||||
func = decode
|
||||
if o == "-t":
|
||||
test()
|
||||
return
|
||||
if args and args[0] != "-":
|
||||
with open(args[0], "rb") as f:
|
||||
func(f, sys.stdout.buffer)
|
||||
else:
|
||||
func(sys.stdin.buffer, sys.stdout.buffer)
|
||||
|
||||
|
||||
def test():
|
||||
s0 = b"Aladdin:open sesame"
|
||||
print(repr(s0))
|
||||
s1 = encodebytes(s0)
|
||||
print(repr(s1))
|
||||
s2 = decodebytes(s1)
|
||||
print(repr(s2))
|
||||
assert s0 == s2
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -29,8 +29,6 @@ class CBR817:
|
||||
def __init__(self, i2c_bus, addr=CBR_ADDRESS, tx_power=3, threshold=5000, noise=256, delay=500, lock=500):
|
||||
self._device = i2c_bus
|
||||
self._address = addr
|
||||
_str_i2c = str(self._device) #唤醒需要SCL管脚给高脉冲
|
||||
self._scl = Pin(int(_str_i2c[_str_i2c.find('=') + 1 : _str_i2c.find(",")]), Pin.OUT, Pin.OPEN_DRAIN)
|
||||
|
||||
self._configure()
|
||||
self.tx_power(tx_power)
|
||||
@@ -49,8 +47,10 @@ class CBR817:
|
||||
|
||||
def _wake(self):
|
||||
'''Wake up from low power consumption'''
|
||||
self._scl.value(0)
|
||||
time.sleep_us(10)
|
||||
try:
|
||||
self._wreg(CBR_SEL_REG, 0xC0)
|
||||
except :
|
||||
pass
|
||||
|
||||
def threshold(self, value=None):
|
||||
self._wake()
|
||||
|
||||
@@ -9,6 +9,15 @@
|
||||
"__size__": 1644,
|
||||
"__name__": "adxl345.py"
|
||||
},
|
||||
"ags10": {
|
||||
"__require__": [
|
||||
"time",
|
||||
"micropython"
|
||||
],
|
||||
"__file__": true,
|
||||
"__size__": 3152,
|
||||
"__name__": "ags10.py"
|
||||
},
|
||||
"ahtx0": {
|
||||
"__require__": [
|
||||
"utime",
|
||||
@@ -49,6 +58,20 @@
|
||||
"__size__": 3703,
|
||||
"__name__": "baidu_speech.py"
|
||||
},
|
||||
"base64": {
|
||||
"__require__": [
|
||||
"re",
|
||||
"struct",
|
||||
"binascii",
|
||||
"warnings",
|
||||
"warnings",
|
||||
"sys",
|
||||
"getopt"
|
||||
],
|
||||
"__file__": true,
|
||||
"__size__": 15241,
|
||||
"__name__": "base64.py"
|
||||
},
|
||||
"ble_advertising": {
|
||||
"__require__": [
|
||||
"micropython",
|
||||
@@ -197,7 +220,7 @@
|
||||
"micropython"
|
||||
],
|
||||
"__file__": true,
|
||||
"__size__": 3913,
|
||||
"__size__": 3762,
|
||||
"__name__": "cbr817.py"
|
||||
},
|
||||
"cc_g1": {
|
||||
@@ -473,11 +496,12 @@
|
||||
"ubinascii",
|
||||
"matcher",
|
||||
"network",
|
||||
"base64",
|
||||
"urequests",
|
||||
"ussl"
|
||||
],
|
||||
"__file__": true,
|
||||
"__size__": 11930,
|
||||
"__size__": 12272,
|
||||
"__name__": "mixiot.py"
|
||||
},
|
||||
"mixpy": {
|
||||
@@ -731,7 +755,7 @@
|
||||
"ustruct"
|
||||
],
|
||||
"__file__": true,
|
||||
"__size__": 1791,
|
||||
"__size__": 2653,
|
||||
"__name__": "rtctime.py"
|
||||
},
|
||||
"sc7a20": {
|
||||
@@ -890,6 +914,14 @@
|
||||
"__size__": 1916,
|
||||
"__name__": "tm1931.py"
|
||||
},
|
||||
"tvoc07s": {
|
||||
"__require__": [
|
||||
"time"
|
||||
],
|
||||
"__file__": true,
|
||||
"__size__": 1093,
|
||||
"__name__": "tvoc07s.py"
|
||||
},
|
||||
"uart_com": {
|
||||
"__require__": [],
|
||||
"__file__": true,
|
||||
@@ -914,7 +946,7 @@
|
||||
"framebuf"
|
||||
],
|
||||
"__file__": true,
|
||||
"__size__": 21078,
|
||||
"__size__": 22364,
|
||||
"__name__": "uframebuf.py"
|
||||
},
|
||||
"umqtt": {
|
||||
|
||||
@@ -30,6 +30,15 @@ def wlan_connect(ssid='MYSSID', password='MYPASS', timeout=10):
|
||||
print('\nnetwork config:', wlan.ifconfig())
|
||||
return wlan
|
||||
|
||||
def image_base64(path="mixly.jpg"):
|
||||
from base64 import b64encode
|
||||
if isinstance(path, str):
|
||||
with open(path, 'rb') as f:
|
||||
_data = f.read()
|
||||
return 'data:image/{};base64,'.format(path.split('.')[-1]).encode() + b64encode(_data)
|
||||
else:
|
||||
return b'data:image/jpg;base64,' + b64encode(path)
|
||||
|
||||
def ntp(url='mixio.mixly.cn'):
|
||||
import urequests
|
||||
try:
|
||||
|
||||
@@ -7,6 +7,8 @@ import ustruct as struct
|
||||
|
||||
# NTP_DELTA (date(2000, 1, 1) - date(1900, 1, 1)).days * 24*60*60
|
||||
NTP_DELTA = 3155673600
|
||||
_weekdayname = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
|
||||
_monthname = (None, "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",)
|
||||
|
||||
def ntptime(host="pool.ntp.org", utc=28800):
|
||||
NTP_QUERY = bytearray(48)
|
||||
@@ -50,3 +52,18 @@ def strtime(times=None):
|
||||
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'.format(*times)
|
||||
else:
|
||||
raise ValueError("Settime needs a type of length 6~8")
|
||||
|
||||
def rfc1123_time(times=None, utc=28800):
|
||||
if times is None:
|
||||
times = localtime()
|
||||
if isinstance(times, str):
|
||||
try:
|
||||
times = eval(times)
|
||||
except:
|
||||
raise ValueError("Clock information format error, use ',' to separate at least 6 numerical values")
|
||||
if type(times) in (tuple, list):
|
||||
if 6 <= len(times) <= 8:
|
||||
times = localtime(mktime(times) - utc)
|
||||
return '{0}, {1:02d} {2} {3:04d} {4:02d}:{5:02d}:{6:02d} GMT'.format(_weekdayname[times[6]], times[2], _monthname[times[1]], times[0], times[3], times[4], times[5])
|
||||
else:
|
||||
raise ValueError("Settime needs a type of length 6~8")
|
||||
|
||||
39
boards/default/micropython/build/lib/tvoc07s.py
Normal file
39
boards/default/micropython/build/lib/tvoc07s.py
Normal file
@@ -0,0 +1,39 @@
|
||||
"""
|
||||
TVOC
|
||||
|
||||
Micropython library for the TVOC(UART)
|
||||
=======================================================
|
||||
@dahanzimin From the Mixly Team
|
||||
"""
|
||||
import time
|
||||
|
||||
class TVOC:
|
||||
def __init__(self, uart):
|
||||
self._uart = uart
|
||||
self._uart.init(baudrate=9600)
|
||||
self._tvoc = (0, 0 ,0) #TVOC mg/m3, CH2O mg/m3, C02 ppm
|
||||
self._flag = False
|
||||
if not self._chip_id():
|
||||
raise AttributeError("Cannot find a TOVC")
|
||||
|
||||
def _rreg(self):
|
||||
'''Read data'''
|
||||
if self._uart.any():
|
||||
eec = 0
|
||||
buf = self._uart.read(9)
|
||||
for i in buf[:8]:
|
||||
eec += i
|
||||
if (eec & 0xFF) == buf[8] and buf[0] == 0x2C:
|
||||
self._tvoc=((buf[2] << 8 | buf[3]) * 0.001, (buf[4] << 8 | buf[5]) * 0.001, buf[6] << 8 | buf[7] )
|
||||
return True
|
||||
|
||||
def _chip_id(self):
|
||||
for _ in range(5):
|
||||
if self._rreg():
|
||||
return True
|
||||
time.sleep(1)
|
||||
return False
|
||||
|
||||
def read(self):
|
||||
self._rreg()
|
||||
return self._tvoc
|
||||
@@ -168,26 +168,53 @@ class FrameBuffer_Base(FrameBuffer):
|
||||
def write(self):
|
||||
self.show()
|
||||
|
||||
def shift(self, x, y, sync=True):
|
||||
def shift(self, x, y, rotate=False, sync=True):
|
||||
"""Shift pixels by x and y"""
|
||||
super().scroll(x, y)
|
||||
if x > 0: # Shift Right
|
||||
for _ in range(x):
|
||||
for row in range(0, self.height):
|
||||
last_pixel = super().pixel(self.width - 1, row) if rotate else 0
|
||||
for col in range(self.width - 1, 0, -1):
|
||||
super().pixel(col, row, super().pixel(col - 1, row))
|
||||
super().pixel(0, row, last_pixel)
|
||||
elif x < 0: # Shift Left
|
||||
for _ in range(-x):
|
||||
for row in range(0, self.height):
|
||||
last_pixel = super().pixel(0, row) if rotate else 0
|
||||
for col in range(0, self.width - 1):
|
||||
super().pixel(col, row, super().pixel(col + 1, row))
|
||||
super().pixel(self.width - 1, row, last_pixel)
|
||||
if y > 0: # Shift Up
|
||||
for _ in range(y):
|
||||
for col in range(0, self.width):
|
||||
last_pixel = super().pixel(col, self.height - 1) if rotate else 0
|
||||
for row in range(self.height - 1, 0, -1):
|
||||
super().pixel(col, row, super().pixel(col, row - 1))
|
||||
super().pixel(col, 0, last_pixel)
|
||||
elif y < 0: # Shift Down
|
||||
for _ in range(-y):
|
||||
for col in range(0, self.width):
|
||||
last_pixel = super().pixel(col, 0) if rotate else 0
|
||||
for row in range(0, self.height - 1):
|
||||
super().pixel(col, row, super().pixel(col, row + 1))
|
||||
super().pixel(col, self.height - 1, last_pixel)
|
||||
if sync: self.show()
|
||||
|
||||
def shift_right(self, num, sync=True):
|
||||
def shift_right(self, num, rotate=False, sync=True):
|
||||
"""Shift all pixels right"""
|
||||
self.shift(num, 0, sync)
|
||||
self.shift(num, 0, rotate, sync)
|
||||
|
||||
def shift_left(self, num, sync=True):
|
||||
def shift_left(self, num, rotate=False, sync=True):
|
||||
"""Shift all pixels left"""
|
||||
self.shift(-num, 0, sync)
|
||||
self.shift(-num, 0, rotate, sync)
|
||||
|
||||
def shift_up(self, num, sync=True):
|
||||
def shift_up(self, num, rotate=False, sync=True):
|
||||
"""Shift all pixels up"""
|
||||
self.shift(0, -num, sync)
|
||||
self.shift(0, -num, rotate, sync)
|
||||
|
||||
def shift_down(self, num, sync=True):
|
||||
def shift_down(self, num, rotate=False, sync=True):
|
||||
"""Shift all pixels down"""
|
||||
self.shift(0, num, sync)
|
||||
self.shift(0, num, rotate, sync)
|
||||
|
||||
def map_invert(self, own):
|
||||
"""Graph invert operation"""
|
||||
@@ -339,6 +366,11 @@ class FrameBuffer_Uincode(FrameBuffer_Base):
|
||||
"""Font selection or externally defined font code"""
|
||||
self._font = Font_Uincode(font_address)
|
||||
|
||||
def shift(self, x, y, rotate=False, sync=True):
|
||||
'''Reshaping Inheritance Methods'''
|
||||
super().scroll(x, y)
|
||||
if sync: self.show()
|
||||
|
||||
def image(self, path, x=None, y=None, size=None, invert=0, color=0xffff, bold=0, sync=True):
|
||||
"""Set buffer to value of Python Imaging Library image"""
|
||||
if type(path) is str :
|
||||
@@ -385,7 +417,6 @@ class FrameBuffer_Uincode(FrameBuffer_Base):
|
||||
if sync: self.fill(bg_color, sync=False)
|
||||
self.set_buffer(data, sync)
|
||||
else:
|
||||
yy = y
|
||||
if size is None:
|
||||
font_len, font_buffer = self._take_buffer(str(data), space, 1)
|
||||
size = min((self.width // font_len) if font_len > 0 else 1, self.height // self._font.height)
|
||||
@@ -393,11 +424,7 @@ class FrameBuffer_Uincode(FrameBuffer_Base):
|
||||
font_len, font_buffer = self._take_buffer(str(data), space, size)
|
||||
x = (self.width - font_len + space) // 2 if center else x
|
||||
y = (self.height - self._font.height * size) // 2 if y is None else y
|
||||
if sync:
|
||||
if yy is None:
|
||||
self.fill(bg_color, sync=False)
|
||||
else:
|
||||
self.fill_rect(x - 1, y - 1, font_len + 2, font_buffer[0][1][1] * size + 2, bg_color, sync=False)
|
||||
if sync: self.fill(bg_color, sync=False)
|
||||
for buffer in font_buffer: #Display character
|
||||
self.bitmap(buffer, x, y, size, bold, color)
|
||||
x = buffer[1][0] * size + x + space
|
||||
|
||||
Reference in New Issue
Block a user