* Author(s): Tony DiCola """ import ustruct from micropython import const import adafruit_bus_device.i2c_device as i2c_device __version__ = "0.0.0-auto.0" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_MMA8451.git" #pylint: disable=bad-whitespace # Internal constants: _MMA8451_DEFAULT_ADDRESS = const(0x1D) _MMA8451_REG_OUT_X_MSB = const(0x01) _MMA8451_REG_SYSMOD = const(0x0B) _MMA8451_REG_WHOAMI = const(0x0D) _MMA8451_REG_XYZ_DATA_CFG = const(0x0E) _MMA8451_REG_PL_STATUS = const(0x10) _MMA8451_REG_PL_CFG = const(0x11) _MMA8451_REG_CTRL_REG1 = const(0x2A) _MMA8451_REG_CTRL_REG2 = const(0x2B) _MMA8451_REG_CTRL_REG4 = const(0x2D) _MMA8451_REG_CTRL_REG5 = const(0x2E) _MMA8451_DATARATE_MASK = const(0b111) _SENSORS_GRAVITY_EARTH = 9.80665 # External user-facing constants: PL_PUF = 0 # Portrait, up, front
* Author(s): Original Raspberry Pi code by Tony DiCola, CircuitPython by ladyada,
refactor by Carter Nelson
"""
__version__ = "2.0.1"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_PN532.git"
import time
import adafruit_bus_device.i2c_device as i2c_device
from digitalio import Direction
from micropython import const
from adafruit_pn532.adafruit_pn532 import PN532, BusyError, _reset
# pylint: disable=bad-whitespace
_I2C_ADDRESS = const(0x24)
class PN532_I2C(PN532):
"""Driver for the PN532 connected over I2C."""
def __init__(self, i2c, *, irq=None, reset=None, req=None, debug=False):
"""Create an instance of the PN532 class using I2C. Note that PN532
uses clock stretching. Optional IRQ pin (not used),
reset pin and debugging output.
"""
self.debug = debug
self._irq = irq
self._req = req
if reset:
_reset(reset)
self._i2c = i2c_device.I2CDevice(i2c, _I2C_ADDRESS)
super().__init__(debug=debug, reset=reset)
* Author(s): Tony DiCola, Michael McWethy """ import time from micropython import const from adafruit_bus_device import i2c_device, spi_device import framebuf __version__ = "2.4.1" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_SSD1306.git" #pylint: disable-msg=bad-whitespace # register definitions SET_CONTRAST = const(0x81) SET_ENTIRE_ON = const(0xa4) SET_NORM_INV = const(0xa6) SET_DISP = const(0xae) SET_MEM_ADDR = const(0x20) SET_COL_ADDR = const(0x21) SET_PAGE_ADDR = const(0x22) SET_DISP_START_LINE = const(0x40) SET_SEG_REMAP = const(0xa0) SET_MUX_RATIO = const(0xa8) SET_COM_OUT_DIR = const(0xc0) SET_DISP_OFFSET = const(0xd3) SET_COM_PIN_CFG = const(0xda) SET_DISP_CLK_DIV = const(0xd5) SET_PRECHARGE = const(0xd9) SET_VCOM_DESEL = const(0xdb)
# test constant optimisation
from micropython import const
X = const(123)
Y = const(X + 456)
print(X, Y + 1)
def f():
print(X, Y + 1)
f()
_X = const(12)
_Y = const(_X + 34)
print(_X, _Y)
class A:
Z = const(1)
_Z = const(2)
print(Z, _Z)
print(hasattr(A, 'Z'), hasattr(A, '_Z'))
import struct
except ImportError:
import ustruct as struct
from micropython import const
import adafruit_bus_device.i2c_device as i2c_device
__version__ = "1.2.1"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_MMA8451.git"
#pylint: disable=bad-whitespace
# Internal constants:
_MMA8451_DEFAULT_ADDRESS = const(0x1D)
_MMA8451_REG_OUT_X_MSB = const(0x01)
_MMA8451_REG_SYSMOD = const(0x0B)
_MMA8451_REG_WHOAMI = const(0x0D)
_MMA8451_REG_XYZ_DATA_CFG = const(0x0E)
_MMA8451_REG_PL_STATUS = const(0x10)
_MMA8451_REG_PL_CFG = const(0x11)
_MMA8451_REG_CTRL_REG1 = const(0x2A)
_MMA8451_REG_CTRL_REG2 = const(0x2B)
_MMA8451_REG_CTRL_REG4 = const(0x2D)
_MMA8451_REG_CTRL_REG5 = const(0x2E)
_MMA8451_DATARATE_MASK = const(0b111)
_SENSORS_GRAVITY_EARTH = 9.80665
# External user-facing constants:
PL_PUF = 0 # Portrait, up, front
* Adafruit CircuitPython firmware (2.2.0+) for the ESP8622 and M0-based boards:
https://github.com/adafruit/circuitpython/releases
* Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice
"""
try:
import ustruct as struct
except ImportError:
import struct
import adafruit_bus_device.i2c_device as i2c_dev
from micropython import const
# Register addresses and other constants:
# pylint: disable=bad-whitespace
_FXOS8700_ADDRESS = const(0x1F) # 0011111
_FXOS8700_ID = const(0xC7) # 1100 0111
_FXOS8700_REGISTER_STATUS = const(0x00)
_FXOS8700_REGISTER_OUT_X_MSB = const(0x01)
_FXOS8700_REGISTER_OUT_X_LSB = const(0x02)
_FXOS8700_REGISTER_OUT_Y_MSB = const(0x03)
_FXOS8700_REGISTER_OUT_Y_LSB = const(0x04)
_FXOS8700_REGISTER_OUT_Z_MSB = const(0x05)
_FXOS8700_REGISTER_OUT_Z_LSB = const(0x06)
_FXOS8700_REGISTER_WHO_AM_I = const(0x0D) # 11000111 r
_FXOS8700_REGISTER_XYZ_DATA_CFG = const(0x0E)
_FXOS8700_REGISTER_CTRL_REG1 = const(0x2A) # 00000000 r/w
_FXOS8700_REGISTER_CTRL_REG2 = const(0x2B) # 00000000 r/w
_FXOS8700_REGISTER_CTRL_REG3 = const(0x2C) # 00000000 r/w
_FXOS8700_REGISTER_CTRL_REG4 = const(0x2D) # 00000000 r/w
_FXOS8700_REGISTER_CTRL_REG5 = const(0x2E) # 00000000 r/w
* Adafruit CircuitPython firmware for the ESP8622 and M0-based boards: https://github.com/adafruit/circuitpython/releases * Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice """ import time import adafruit_bus_device.i2c_device as i2c_device from micropython import const __version__ = "2.0.0" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_VL53L0X.git" # Register addresses. Unused registers commented out to save memory. # pylint: disable=bad-whitespace MPR121_I2CADDR_DEFAULT = const(0x5A) MPR121_TOUCHSTATUS_L = const(0x00) #MPR121_TOUCHSTATUS_H = const(0x01) MPR121_FILTDATA_0L = const(0x04) #MPR121_FILTDATA_0H = const(0x05) MPR121_BASELINE_0 = const(0x1E) MPR121_MHDR = const(0x2B) MPR121_NHDR = const(0x2C) MPR121_NCLR = const(0x2D) MPR121_FDLR = const(0x2E) MPR121_MHDF = const(0x2F) MPR121_NHDF = const(0x30) MPR121_NCLF = const(0x31) MPR121_FDLF = const(0x32) MPR121_NHDT = const(0x33) MPR121_NCLT = const(0x34)
from trezor.messages.TxRequestSerializedType import TxRequestSerializedType
from apps.common import address_type, coins
from apps.common.coininfo import CoinInfo
from apps.wallet.sign_tx.addresses import *
from apps.wallet.sign_tx.helpers import *
from apps.wallet.sign_tx.multisig import *
from apps.wallet.sign_tx.scripts import *
from apps.wallet.sign_tx.segwit_bip143 import Bip143, Bip143Error # noqa:F401
from apps.wallet.sign_tx.overwinter_zip143 import Zip143, Zip143Error, OVERWINTERED # noqa:F401
from apps.wallet.sign_tx.tx_weight_calculator import *
from apps.wallet.sign_tx.writers import *
from apps.wallet.sign_tx import progress
# the number of bip32 levels used in a wallet (chain and address)
_BIP32_WALLET_DEPTH = const(2)
# the chain id used for change
_BIP32_CHANGE_CHAIN = const(1)
# the maximum allowed change address. this should be large enough for normal
# use and still allow to quickly brute-force the correct bip32 path
_BIP32_MAX_LAST_ELEMENT = const(1000000)
class SigningError(ValueError):
pass
# Transaction signing
# ===
https://github.com/adafruit/circuitpython/releases * Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice """ import time from random import randint from micropython import const import adafruit_bus_device.spi_device from adafruit_tinylora.adafruit_tinylora_encryption import AES __version__ = "0.0.0-auto.0" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_TinyLoRa.git" # RFM Module Settings _MODE_SLEEP = const(0x00) _MODE_LORA = const(0x80) _MODE_STDBY = const(0x01) _MODE_TX = const(0x83) _TRANSMIT_DIRECTION_UP = const(0x00) # RFM Registers _REG_PA_CONFIG = const(0x09) _REG_PREAMBLE_MSB = const(0x20) _REG_PREAMBLE_LSB = const(0x21) _REG_FRF_MSB = const(0x06) _REG_FRF_MID = const(0x07) _REG_FRF_LSB = const(0x08) _REG_FEI_LSB = const(0x1E) _REG_FEI_MSB = const(0x1D) _REG_MODEM_CONFIG = const(0x26) _REG_PAYLOAD_LENGTH = const(0x22)
# Helpers for generating BLE advertising payloads.
from micropython import const
import struct
import bluetooth
# Advertising payloads are repeated packets of the following form:
# 1 byte data length (N + 1)
# 1 byte type (see constants below)
# N bytes type-specific data
_ADV_TYPE_FLAGS = const(0x01)
_ADV_TYPE_NAME = const(0x09)
_ADV_TYPE_UUID16_COMPLETE = const(0x3)
_ADV_TYPE_UUID32_COMPLETE = const(0x5)
_ADV_TYPE_UUID128_COMPLETE = const(0x7)
_ADV_TYPE_UUID16_MORE = const(0x2)
_ADV_TYPE_UUID32_MORE = const(0x4)
_ADV_TYPE_UUID128_MORE = const(0x6)
_ADV_TYPE_APPEARANCE = const(0x19)
# Generate a payload to be passed to gap_advertise(adv_data=...).
def advertising_payload(limited_disc=False, br_edr=False, name=None, services=None, appearance=0):
payload = bytearray()
def _append(adv_type, value):
nonlocal payload
payload += struct.pack('BB', len(value) + 1, adv_type) + value
_append(_ADV_TYPE_FLAGS, struct.pack('B', (0x01 if limited_disc else 0x02) + (0x00 if br_edr else 0x04)))
def split_message(message):
chars_per_line = const(18)
message = stringify_message(message)
lines = chunks(message, chars_per_line)
return lines
# Released under the MIT licence. Full text in root of this repository.
import gc
import uasyncio as asyncio
import time
gc.collect()
import ujson
from micropython import const
from machine import Pin, I2C
gc.collect()
from . import asi2c
from micropython_iot import client
gc.collect()
ID = const(0) # Config list index
PORT = const(1)
SERVER = const(2)
TIMEOUT = const(3)
REPORT = const(4)
SSID = const(5)
PW = const(6)
class LinkClient(client.Client):
def __init__(self, loop, config, swriter, verbose):
super().__init__(loop,
config[ID],
config[SERVER],
config[PORT],
config[SSID],
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
# pylint: disable=missing-docstring,invalid-name,too-many-public-methods,too-few-public-methods
from micropython import const
__version__ = "1.3.0"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_seesaw.git"
_ADC_INPUT_0_PIN = const(0x02)
_ADC_INPUT_1_PIN = const(0x03)
_ADC_INPUT_2_PIN = const(0x04)
_ADC_INPUT_3_PIN = const(0x05)
_PWM_0_PIN = const(0x04)
_PWM_1_PIN = const(0x05)
_PWM_2_PIN = const(0x06)
_PWM_3_PIN = const(0x07)
class SAMD09_Pinmap:
analog_pins = (_ADC_INPUT_0_PIN, _ADC_INPUT_1_PIN,
_ADC_INPUT_2_PIN, _ADC_INPUT_3_PIN)
pwm_width = 8
Example usage on pyboard:
import pyb, sdcard, os
sd = sdcard.SDCard(pyb.SPI(1), pyb.Pin.board.X5)
pyb.mount(sd, '/sd2')
os.listdir('/')
Example usage on ESP8266:
import machine, sdcard, os
sd = sdcard.SDCard(machine.SPI(1), machine.Pin(15))
os.mount(sd, '/sd')
os.listdir('/')
"""
from micropython import const
import time
_CMD_TIMEOUT = const(100)
_R1_IDLE_STATE = const(1 << 0)
#R1_ERASE_RESET = const(1 << 1)
_R1_ILLEGAL_COMMAND = const(1 << 2)
#R1_COM_CRC_ERROR = const(1 << 3)
#R1_ERASE_SEQUENCE_ERROR = const(1 << 4)
#R1_ADDRESS_ERROR = const(1 << 5)
#R1_PARAMETER_ERROR = const(1 << 6)
_TOKEN_CMD25 = const(0xfc)
_TOKEN_STOP_TRAN = const(0xfd)
_TOKEN_DATA = const(0xfe)
class SDCard:
def __init__(self, spi, cs):
**Software and Dependencies:**
* Adafruit CircuitPython firmware for the supported boards:
https://github.com/adafruit/circuitpython/releases
* Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice
"""
from micropython import const
__version__ = "1.1.0"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_CAP1188.git"
# pylint: disable=bad-whitespace
_CAP1188_MID = const(0x5D)
_CAP1188_PID = const(0x50)
_CAP1188_MAIN_CONTROL = const(0x00)
_CAP1188_GENERAL_STATUS = const(0x02)
_CAP1188_INPUT_STATUS = const(0x03)
_CAP1188_LED_STATUS = const(0x04)
_CAP1188_NOISE_FLAGS = const(0x0A)
_CAP1188_DELTA_COUNT =(const(0x10),
const(0x11),
const(0x12),
const(0x13),
const(0x14),
const(0x15),
const(0x16),
const(0x17))
_CAP1188_SENSITIVTY = const(0x1F)
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
from micropython import const
from machine import Pin
from utime import sleep_us, sleep_ms
TM1637_CMD1 = const(64) # 0x40 data command
TM1637_CMD2 = const(192) # 0xC0 address command
TM1637_CMD3 = const(128) # 0x80 display control command
TM1637_DSP_ON = const(8) # 0x08 display on
TM1637_DELAY = const(10) # 10us delay between clk/dio pulses
TM1637_MSB = const(128) # msb is the decimal point or the colon depending on your display
# 0-9, a-z, blank, dash, star
_SEGMENTS = bytearray(b'\x3F\x06\x5B\x4F\x66\x6D\x7D\x07\x7F\x6F\x77\x7C\x39\x5E\x79\x71\x3D\x76\x06\x1E\x76\x38\x55\x54\x3F\x73\x67\x50\x6D\x78\x3E\x1C\x2A\x76\x6E\x5B\x00\x40\x63')
class TM1637(object):
"""Library for quad 7-segment LED modules based on the TM1637 LED driver."""
def __init__(self, clk, dio, brightness=7):
self.clk = clk
self.dio = dio
# check that consts are not replaced in anything except standalone identifiers
from micropython import const
X = const(1)
Y = const(2)
Z = const(3)
# import that uses a constant
import micropython as X
print(globals()['X'])
# function name that matches a constant
def X():
print('function X', X)
globals()['X']()
# arguments that match a constant
def f(X, *Y, **Z):
pass
f(1)
# class name that matches a constant
class X:
def f(self):
print('class X', X)
globals()['X']().f()
# constant within a class
class A:
C1 = const(4)
import micropython
micropython.opt_level(2)
import math
import time_location
PIXELS_PER_DEGREE = micropython.const(875.677409 / 2.9063) # calibrated from camera but doesn't really change the math
POLARIS_2000 = micropython.const([2, 31, 51.56, 89, 15, 51.5]) # obtained from Stellarium
POLARIS_2020 = micropython.const([2, 57, 39.08, 89, 20, 57.4]) # obtained from Stellarium
"""
The Earth's axis is very slowly wobbling
so the position of any star is very slowly moving
If you purchase a polar-scope, inside you will see that there's a ring for each year, and you line up Polaris with the ring corresponding to the current year
The code below will predict the new coordinate of Polaris according to the current date
It uses simple interpolation and transforms between coordinate systems
It accounts for leap years correctly
Testing of the code below shows that for the year 2024, the declination (the important part) is still accurate down to the arc second, and RA (not as important) is off by 0.8% (12 arc minutes)
"""
class PoleMovement(object):
def __init__(self):
ra2000, dec2000 = conv_ra_dec(POLARIS_2000)
ra2020, dec2020 = conv_ra_dec(POLARIS_2020)
self.x2000, self.y2000 = vector(ra2000, dec2000)
self.x2020, self.y2020 = vector(ra2020, dec2020)
self.jdn2000 = time_location.jdn(2000, 1, 1)
self.jdn2020 = time_location.jdn(2020, 1, 1)
dx = self.x2020 - self.x2000
dy = self.y2020 - self.y2000
""" import time import digitalio from adafruit_register.i2c_bits import RWBits from adafruit_register.i2c_bit import RWBit from adafruit_bus_device.i2c_device import I2CDevice from micropython import const # ADDRESS_DEF = const(0x39) # INTEGRATION_TIME_DEF = const(0x01) # GAIN_DEF = const(0x01) #pylint: disable-msg=bad-whitespace #APDS9960_RAM = const(0x00) APDS9960_ENABLE = const(0x80) APDS9960_ATIME = const(0x81) #APDS9960_WTIME = const(0x83) #APDS9960_AILTIL = const(0x84) # APDS9960_AILTH = const(0x85) # APDS9960_AIHTL = const(0x86) # APDS9960_AIHTH = const(0x87) APDS9960_PILT = const(0x89) APDS9960_PIHT = const(0x8B) APDS9960_PERS = const(0x8C) # APDS9960_CONFIG1 = const(0x8D) # APDS9960_PPULSE = const(0x8E) APDS9960_CONTROL = const(0x8F) # APDS9960_CONFIG2 = const(0x90) APDS9960_ID = const(0x92) APDS9960_STATUS = const(0x93)
# This program for an nRF52840 sends a one byte payload in a # packet once every second. from micropython import const import machine # so can peek and poke different registers on the nRF5x import uctypes import utime radioBuffer = bytearray(100) # allocate IO buffer for use by nRF5x radio radioBuffer_address = uctypes.addressof(radioBuffer) target_prefixAddress = const(0xAA) target_baseAddress = const(0xDEADBEEF) NRF_POWER = const(0x40000000) DCDCEN = const(0x578) NRF_POWER___DCDCEN = const(NRF_POWER + DCDCEN) NRF_CLOCK = const(0x40000000) TASKS_HFCLKSTART = const(0) EVENTS_HFCLKSTARTED = const(0x100) NRF_CLOCK___TASKS_HFCLKSTART = const(NRF_CLOCK + TASKS_HFCLKSTART) NRF_CLOCK___EVENTS_HFCLKSTARTED = const(NRF_CLOCK + EVENTS_HFCLKSTARTED) NRF_RADIO = const(0x40001000) BASE0 = const(0x51C) PREFIX0 = const(0x524) FREQUENCY = const(0x508) PCNF1 = const(0x518) PCNF0 = const(0x514) MODE = const(0x510)
# imports
try:
import struct
except ImportError:
import ustruct as struct
import time
from micropython import const
from adafruit_bus_device.i2c_device import I2CDevice
__version__ = "2.0.1"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_SHT31D.git"
SHT31_DEFAULT_ADDR = const(0x44)
SHT31_MEAS_HIGHREP_STRETCH = const(0x2C06)
SHT31_MEAS_MEDREP_STRETCH = const(0x2C0D)
SHT31_MEAS_LOWREP_STRETCH = const(0x2C10)
SHT31_MEAS_HIGHREP = const(0x2400)
SHT31_MEAS_MEDREP = const(0x240B)
SHT31_MEAS_LOWREP = const(0x2416)
SHT31_READSTATUS = const(0xF32D)
SHT31_CLEARSTATUS = const(0x3041)
SHT31_SOFTRESET = const(0x30A2)
SHT31_HEATEREN = const(0x306D)
SHT31_HEATERDIS = const(0x3066)
def _crc(data):
crc = 0xff
from trezor.messages.MessageType import CardanoTxAck
from apps.cardano import CURVE, cbor, seed
from apps.cardano.address import (
derive_address_and_node,
is_safe_output_address,
validate_full_path,
)
from apps.cardano.layout import confirm_sending, confirm_transaction, progress
from apps.common.paths import validate_path
from apps.common.seed import remove_ed25519_prefix
from apps.homescreen.homescreen import display_homescreen
# the maximum allowed change address. this should be large enough for normal
# use and still allow to quickly brute-force the correct bip32 path
MAX_CHANGE_ADDRESS_INDEX = const(1000000)
ACCOUNT_PREFIX_DEPTH = const(2)
KNOWN_PROTOCOL_MAGICS = {764824073: "Mainnet", 1097911063: "Testnet"}
# we consider addresses from the external chain as possible change addresses as well
def is_change(output, inputs):
for input in inputs:
inp = input.address_n
if (not output[:ACCOUNT_PREFIX_DEPTH] == inp[:ACCOUNT_PREFIX_DEPTH]
or not output[-2] < 2
or not output[-1] < MAX_CHANGE_ADDRESS_INDEX):
return False
return True
A simple driver for the ST7735-based displays.
* Author(s): Radomir Dopieralski, Michael McWethy
"""
try:
import struct
except ImportError:
import ustruct as struct
from micropython import const
from adafruit_rgb_display.rgb import DisplaySPI
__version__ = "3.1.1"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_RGB_Display.git"
_NOP = const(0x00)
_SWRESET = const(0x01)
_RDDID = const(0x04)
_RDDST = const(0x09)
_SLPIN = const(0x10)
_SLPOUT = const(0x11)
_PTLON = const(0x12)
_NORON = const(0x13)
_INVOFF = const(0x20)
_INVON = const(0x21)
_DISPOFF = const(0x28)
_DISPON = const(0x29)
_CASET = const(0x2A)
_RASET = const(0x2B)
**Software and Dependencies:** * Adafruit CircuitPython firmware for the ESP8622 and M0-based boards: https://github.com/adafruit/circuitpython/releases """ import time from micropython import const __version__ = "0.0.0-auto.0" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_Thermal_Printer.git" # pylint: disable=bad-whitespace # Internally used constants. _UPDOWN_MASK = const(1 << 2) _BOLD_MASK = const(1 << 3) _DOUBLE_HEIGHT_MASK = const(1 << 4) _DOUBLE_WIDTH_MASK = const(1 << 5) _STRIKE_MASK = const(1 << 6) # External constants: JUSTIFY_LEFT = const(0) JUSTIFY_CENTER = const(1) JUSTIFY_RIGHT = const(2) SIZE_SMALL = const(0) SIZE_MEDIUM = const(1) SIZE_LARGE = const(2) UNDERLINE_THIN = const(0) UNDERLINE_THICK = const(1)
This is a CircuitPython driver for the Bosch BNO055 nine degree of freedom inertial measurement unit module with sensor fusion. * Author(s): Radomir Dopieralski """ import time from micropython import const from adafruit_bus_device.i2c_device import I2CDevice from adafruit_register.i2c_struct import Struct, UnaryStruct __version__ = "3.0.4" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_BNO055.git" _CHIP_ID = const(0xa0) CONFIG_MODE = const(0x00) ACCONLY_MODE = const(0x01) MAGONLY_MODE = const(0x02) GYRONLY_MODE = const(0x03) ACCMAG_MODE = const(0x04) ACCGYRO_MODE = const(0x05) MAGGYRO_MODE = const(0x06) AMG_MODE = const(0x07) IMUPLUS_MODE = const(0x08) COMPASS_MODE = const(0x09) M4G_MODE = const(0x0a) NDOF_FMC_OFF_MODE = const(0x0b) NDOF_MODE = const(0x0c)
class VCNL4040: # pylint: disable=too-few-public-methods
"""Driver for the VCNL4040 proximity and ambient light sensor.
:param busio.I2C i2c_bus: The I2C bus the VCNL4040 is connected to.
"""
# Ambient light sensor integration times
ALS_80MS = const(0x0)
ALS_160MS = const(0x1)
ALS_320MS = const(0x2)
ALS_640MS = const(0x3)
# Proximity sensor integration times
PS_1T = const(0x0)
PS_1_5T = const(0x1)
PS_2T = const(0x2)
PS_2_5T = const(0x3)
PS_3T = const(0x4)
PS_3_5T = const(0x5)
PS_4T = const(0x6)
PS_8T = const(0x7)
# LED current settings
LED_50MA = const(0x0)
LED_75MA = const(0x1)
LED_100MA = const(0x2)
LED_120MA = const(0x3)
LED_140MA = const(0x4)
LED_160MA = const(0x5)
LED_180MA = const(0x6)
LED_200MA = const(0x7)
# LED duty cycle settings
LED_1_40 = const(0x0)
LED_1_80 = const(0x1)
LED_1_160 = const(0x2)
LED_1_320 = const(0x3)
# Proximity sensor interrupt enable/disable options
PS_INT_DISABLE = const(0x0)
PS_INT_CLOSE = const(0x1)
PS_INT_AWAY = const(0x2)
PS_INT_CLOSE_AWAY = const(0x3)
# Offsets into interrupt status register for different types
ALS_IF_L = const(0x0D)
ALS_IF_H = const(0x0C)
PS_IF_CLOSE = const(0x09)
PS_IF_AWAY = const(0x08)
# ID_LM - Device ID, address
_device_id = UnaryStruct(0x0C, "<H")
"""The device ID."""
# PS_Data_LM - PS output data
proximity = ROUnaryStruct(0x08, "<H")
"""Proximity data.
This example prints the proximity data. Move your hand towards the sensor to see the values
change.
.. code-block:: python
import time
import board
import busio
import adafruit_vcnl4040
i2c = busio.I2C(board.SCL, board.SDA)
sensor = adafruit_vcnl4040.VCNL4040(i2c)
while True:
print("Proximity:", sensor.proximity)
time.sleep(0.1)
"""
# PS_CONF1 - PS duty ratio, integration time, persistence, enable/disable
# PS_CONF2 - PS output resolution selection, interrupt trigger method
# PS_CONF3 - PS smart persistence, active force mode
proximity_shutdown = RWBit(0x03, 0, register_width=2)
"""Proximity sensor shutdown. When ``True``, proximity data is disabled."""
proximity_integration_time = RWBits(3, 0x03, 1, register_width=2)
"""Proximity sensor integration time setting. Integration times are 1T, 1.5T, 2T, 2.5T, 3T,
3.5T, 4T, and 8T. Options are: PS_1T, PS_1_5T, PS_2T, PS_2_5T, PS_3T, PS_3_5T, PS_4T, PS_8T.
"""
proximity_interrupt = RWBits(2, 0x03, 8, register_width=2)
"""Interrupt enable. Interrupt setting are close, away, close and away, or disabled. Options
are: PS_INT_DISABLE, PS_INT_CLOSE, PS_INT_AWAY, PS_INT_CLOSE_AWAY."""
proximity_bits = RWBit(0x03, 11, register_width=2)
"""Proximity data output setting. ``0`` when proximity sensor output is 12 bits, ``1`` when
proximity sensor output is 16 bits."""
# PS_THDL_LM - PS low interrupt threshold setting
proximity_low_threshold = UnaryStruct(0x06, "<H")
"""Proximity sensor interrupt low threshold setting."""
# PS_THDH_LM - PS high interrupt threshold setting
proximity_high_threshold = UnaryStruct(0x07, "<H")
"""Proximity sensor interrupt high threshold setting."""
interrupt_state = ROUnaryStruct(0x0B, "<H")
# INT_FLAG - PS interrupt flag
@property
def proximity_high_interrupt(self):
"""If interrupt is set to ``PS_INT_CLOSE`` or ``PS_INT_CLOSE_AWAY``, trigger event when
proximity rises above high threshold interrupt."""
return self._get_and_clear_cached_interrupt_state(self.PS_IF_CLOSE)
@property
def proximity_low_interrupt(self):
"""If interrupt is set to ``PS_INT_AWAY`` or ``PS_INT_CLOSE_AWAY``, trigger event when
proximity drops below low threshold."""
return self._get_and_clear_cached_interrupt_state(self.PS_IF_AWAY)
led_current = RWBits(3, 0x04, 8, register_width=2)
"""LED current selection setting, in mA. Options are LED_50MA, LED_75MA, LED_100MA, LED_120MA,
LED_140MA, LED_160MA, LED_180MA, LED_200MA."""
led_duty_cycle = RWBits(2, 0x03, 6, register_width=2)
"""Proximity sensor LED duty ratio setting. Ratios are 1/40, 1/80, 1/160, and 1/320. Options
are: LED_1_40, LED_1_80, LED_1_160, LED_1_320."""
light = ROUnaryStruct(0x09, "<H")
"""Raw ambient light data. The raw ambient light data which will change with integration time
and gain settings changes. Use ``lux`` to get the correctly scaled value for the current
integration time and gain settings
"""
@property
def lux(self):
"""Ambient light data in lux. Represents the raw sensor data scaled according to the current
integration time and gain settings.
This example prints the ambient light data. Cover the sensor to see the values change.
.. code-block:: python
import time
import board
import busio
import adafruit_vcnl4040
i2c = busio.I2C(board.SCL, board.SDA)
sensor = adafruit_vcnl4040.VCNL4040(i2c)
while True:
print("Ambient light: %.2f lux"%sensor.lux)
time.sleep(0.1)
"""
return self.light * (0.1 / (1 << self.light_integration_time))
# ALS_CONF - ALS integration time, persistence, interrupt, function enable/disable
light_shutdown = RWBit(0x00, 0, register_width=2)
"""Ambient light sensor shutdown. When ``True``, ambient light data is disabled."""
_light_integration_time = RWBits(2, 0x00, 6, register_width=2)
@property
def light_integration_time(self):
"""Ambient light sensor integration time setting. Longer time has higher sensitivity.
Can be: ALS_80MS, ALS_160MS, ALS_320MS or ALS_640MS.
This example sets the ambient light integration time to 640ms and prints the ambient light
sensor data.
.. code-block:: python
import time
import board
import busio
import adafruit_vcnl4040
i2c = busio.I2C(board.SCL, board.SDA)
sensor = adafruit_vcnl4040.VCNL4040(i2c)
sensor.light_integration_time = sensor.ALS_640MS
while True:
print("Ambient light:", sensor.light)
"""
return self._light_integration_time
@light_integration_time.setter
def light_integration_time(self, new_it):
from time import sleep # pylint: disable=import-outside-toplevel
# IT values are in 0-3 -> 80-640ms
old_it_ms = (8 << self._light_integration_time) * 10
new_it_ms = (8 << new_it) * 10
it_delay_seconds = (old_it_ms + new_it_ms + 1) * 0.001
self._light_integration_time = new_it
sleep(it_delay_seconds)
light_interrupt = RWBit(0x00, 1, register_width=2)
"""Ambient light sensor interrupt enable. ``True`` to enable, and ``False`` to disable."""
# ALS_THDL_LM - ALS low interrupt threshold setting
light_low_threshold = UnaryStruct(0x02, "<H")
"""Ambient light interrupt low threshold."""
# ALS_THDH_LM - ALS high interrupt threshold setting
light_high_threshold = UnaryStruct(0x01, "<H")
"""Ambient light interrupt high threshold."""
# INT_FLAG - ALS interrupt flag
@property
def light_high_interrupt(self):
"""High interrupt event. Triggered when ambient light value exceeds high threshold."""
return self._get_and_clear_cached_interrupt_state(self.ALS_IF_H)
@property
def light_low_interrupt(self):
"""Low interrupt event. Triggered when ambient light value drops below low threshold."""
return self._get_and_clear_cached_interrupt_state(self.ALS_IF_L)
_raw_white = ROUnaryStruct(0x0A, "<H")
@property
def white(self):
"""White light data scaled according to the current integration time and gain settings.
This example prints the white light data. Cover the sensor to see the values change.
.. code-block:: python
import time
import board
import busio
import adafruit_vcnl4040
i2c = busio.I2C(board.SCL, board.SDA)
sensor = adafruit_vcnl4040.VCNL4040(i2c)
while True:
print("White light:", sensor.white)
time.sleep(0.1)
"""
return self._raw_white * (0.1 / (1 << self.light_integration_time))
# PS_MS - White channel enable/disable, PS mode, PS protection setting, LED current
# White_EN - PS_MS_H, 7th bit - White channel enable/disable
white_shutdown = RWBit(0x04, 15, register_width=2)
"""White light channel shutdown. When ``True``, white light data is disabled."""
def __init__(self, i2c, address=0x60):
self.i2c_device = i2cdevice.I2CDevice(i2c, address)
if self._device_id != 0x186:
raise RuntimeError("Failed to find VCNL4040 - check wiring!")
self.cached_interrupt_state = {
self.ALS_IF_L: False,
self.ALS_IF_H: False,
self.PS_IF_CLOSE: False,
self.PS_IF_AWAY: False,
}
self.proximity_shutdown = False
self.light_shutdown = False
self.white_shutdown = False
def _update_interrupt_state(self):
interrupts = [
self.PS_IF_AWAY, self.PS_IF_CLOSE, self.ALS_IF_H, self.ALS_IF_L
]
new_interrupt_state = self.interrupt_state
for interrupt in interrupts:
new_state = new_interrupt_state & (1 << interrupt) > 0
if new_state:
self.cached_interrupt_state[interrupt] = new_state
def _get_and_clear_cached_interrupt_state(self, interrupt_offset):
self._update_interrupt_state()
new_interrupt_state = self.cached_interrupt_state[interrupt_offset]
self.cached_interrupt_state[interrupt_offset] = False
return new_interrupt_state
# Driver for official MicroPython LCD160CR display
# MIT license; Copyright (c) 2017 Damien P. George
from micropython import const
from utime import sleep_ms
from ustruct import calcsize, pack_into
import uerrno, machine
# for set_orient
PORTRAIT = const(0)
LANDSCAPE = const(1)
PORTRAIT_UPSIDEDOWN = const(2)
LANDSCAPE_UPSIDEDOWN = const(3)
# for set_startup_deco; can be or'd
STARTUP_DECO_NONE = const(0)
STARTUP_DECO_MLOGO = const(1)
STARTUP_DECO_INFO = const(2)
_uart_baud_table = {
2400: 0,
4800: 1,
9600: 2,
19200: 3,
38400: 4,
57600: 5,
115200: 6,
230400: 7,
460800: 8,
}
==================================================== CircuitPython module for the DRV2605 haptic feedback motor driver. See examples/simpletest.py for a demo of the usage. * Author(s): Tony DiCola """ from micropython import const from adafruit_bus_device.i2c_device import I2CDevice __version__ = "0.0.0-auto.0" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_DRV2605.git" # Internal constants: _DRV2605_ADDR = const(0x5A) _DRV2605_REG_STATUS = const(0x00) _DRV2605_REG_MODE = const(0x01) _DRV2605_REG_RTPIN = const(0x02) _DRV2605_REG_LIBRARY = const(0x03) _DRV2605_REG_WAVESEQ1 = const(0x04) _DRV2605_REG_WAVESEQ2 = const(0x05) _DRV2605_REG_WAVESEQ3 = const(0x06) _DRV2605_REG_WAVESEQ4 = const(0x07) _DRV2605_REG_WAVESEQ5 = const(0x08) _DRV2605_REG_WAVESEQ6 = const(0x09) _DRV2605_REG_WAVESEQ7 = const(0x0A) _DRV2605_REG_WAVESEQ8 = const(0x0B) _DRV2605_REG_GO = const(0x0C) _DRV2605_REG_OVERDRIVE = const(0x0D) _DRV2605_REG_SUSTAINPOS = const(0x0E)
<https://www.adafruit.com/product/935>`_ (Product ID: 935)
**Software and Dependencies:**
* Adafruit CircuitPython firmware for the ESP8622 and M0-based boards:
https://github.com/adafruit/circuitpython/releases
"""
from micropython import const
__version__ = "1.1.1"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_MCP4725.git"
# Internal constants:
_MCP4725_DEFAULT_ADDRESS = 0b01100010
_MCP4725_WRITE_FAST_MODE = const(0b00000000)
class MCP4725:
"""
MCP4725 12-bit digital to analog converter. This class has a similar
interface as the CircuitPython AnalogOut class and can be used in place
of that module.
:param ~busio.I2C i2c: The I2C bus.
:param int address: The address of the device if set differently from the default.
"""
# Global buffer to prevent allocations and heap fragmentation.
# Note this is not thread-safe or re-entrant by design!
from micropython import const
from trezor.crypto import base58
from apps.common import HARDENED
from apps.common.writers import write_bytes_unchecked, write_uint8
TEZOS_AMOUNT_DECIMALS = const(6)
TEZOS_ED25519_ADDRESS_PREFIX = "tz1"
TEZOS_ORIGINATED_ADDRESS_PREFIX = "KT1"
TEZOS_PUBLICKEY_PREFIX = "edpk"
TEZOS_SIGNATURE_PREFIX = "edsig"
TEZOS_PREFIX_BYTES = {
# addresses
"tz1": b"\x06\xa1\x9f", # 06a19f
"tz2": b"\x06\xa1\xa1", # 06a1a1
"tz3": b"\x06\xa1\xa4", # 06a1a4
"KT1": b"\x02Zy", # 025a79
# public keys
"edpk": b"\r\x0f%\xd9", # 0d0f25d9
# signatures
"edsig": b"\t\xf5\xcd\x86\x12", # 09f5cd8612
# operation hash
"o": b"\x05t", # 0574
# protocol hash
"P": b"\x02\xaa", # 02aa
}
MICHELSON_INSTRUCTION_BYTES = {
"DROP":
b"\x03 ", # 0320
* Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice """ import time from micropython import const import adafruit_bus_device.spi_device as spidev __version__ = "1.2.3" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_RFM69.git" # pylint: disable=bad-whitespace # Internal constants: _REG_FIFO = const(0x00) _REG_OP_MODE = const(0x01) _REG_DATA_MOD = const(0x02) _REG_BITRATE_MSB = const(0x03) _REG_BITRATE_LSB = const(0x04) _REG_FDEV_MSB = const(0x05) _REG_FDEV_LSB = const(0x06) _REG_FRF_MSB = const(0x07) _REG_FRF_MID = const(0x08) _REG_FRF_LSB = const(0x09) _REG_VERSION = const(0x10) _REG_PA_LEVEL = const(0x11) _REG_RX_BW = const(0x19) _REG_AFC_BW = const(0x1A) _REG_RSSI_VALUE = const(0x24) _REG_DIO_MAPPING1 = const(0x25)
# This example finds and connects to a BLE temperature sensor (e.g. the one in ble_temperature.py). import bluetooth import random import struct import time import micropython from ble_advertising import decode_services, decode_name from micropython import const _IRQ_CENTRAL_CONNECT = const(1) _IRQ_CENTRAL_DISCONNECT = const(2) _IRQ_GATTS_WRITE = const(3) _IRQ_GATTS_READ_REQUEST = const(4) _IRQ_SCAN_RESULT = const(5) _IRQ_SCAN_DONE = const(6) _IRQ_PERIPHERAL_CONNECT = const(7) _IRQ_PERIPHERAL_DISCONNECT = const(8) _IRQ_GATTC_SERVICE_RESULT = const(9) _IRQ_GATTC_SERVICE_DONE = const(10) _IRQ_GATTC_CHARACTERISTIC_RESULT = const(11) _IRQ_GATTC_CHARACTERISTIC_DONE = const(12) _IRQ_GATTC_DESCRIPTOR_RESULT = const(13) _IRQ_GATTC_DESCRIPTOR_DONE = const(14) _IRQ_GATTC_READ_RESULT = const(15) _IRQ_GATTC_READ_DONE = const(16) _IRQ_GATTC_WRITE_DONE = const(17) _IRQ_GATTC_NOTIFY = const(18) _IRQ_GATTC_INDICATE = const(19)
"""
`adafruit_rgb_display.s6d02a1`
====================================================
A simple driver for the S6D02A1-based displays.
* Author(s): Radomir Dopieralski, Michael McWethy
"""
from micropython import const
from adafruit_rgb_display.rgb import DisplaySPI
__version__ = "3.1.1"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_RGB_Display.git"
_SWRESET = const(0x01)
_DISPON = const(0x29)
_SLEEPOUT = const(0x11)
_CASET = const(0x2a)
_PASET = const(0x2b)
_RAMWR = const(0x2c)
_RAMRD = const(0x2e)
_COLMOD = const(0x3a)
_MADCTL = const(0x36)
class S6D02A1(DisplaySPI):
"""
A simple driver for the S6D02A1-based displays.
>>> import busio
>>> import digitalio
from ili9341 import ili9341
from micropython import const
BUTTON_A_PIN = const(39)
BUTTON_B_PIN = const(38)
BUTTON_C_PIN = const(37)
class M5Ili(ili9341):
def __init__(self, hybrid=True, double_buffer=False):
self.disp = ili9341(miso=19,
mosi=23,
clk=18,
cs=14,
dc=27,
rst=33,
backlight=32,
power=-1,
power_on=-1,
backlight_on=1,
mhz=40,
factor=4,
hybrid=hybrid,
width=320,
height=240,
colormode=ili9341.COLOR_MODE_BGR,
rot=ili9341.MADCTL_ML,
invert=False,
double_buffer=double_buffer)
__version__ = "2.0.1"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_l3gd20.git"
from micropython import const
from adafruit_register.i2c_struct import Struct
try:
from struct import unpack
except ImportError:
from ustruct import unpack
__version__ = "2.0.1"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_L3GD20.git"
L3DS20_RANGE_250DPS = const(0)
L3DS20_RANGE_500DPS = const(1)
L3DS20_RANGE_2000DPS = const(2)
_L3GD20_REGISTER_CTRL_REG1 = const(0x20)
_L3GD20_REGISTER_CTRL_REG4 = const(0x23)
# _L3GD20_REGISTER_OUT_X_L = const(0x28)
_L3GD20_REGISTER_OUT_X_L_X80 = const(0xA8)
_L3GD20_REGISTER_OUT_X_L_X40 = const(0x68)
_ID_REGISTER = const(0x0F)
_L3GD20_CHIP_ID = const(0xD4)
_L3GD20H_CHIP_ID = const(0xD7)
uart.start()
"""
__version__ = "1.0.0"
import struct
import bluetooth
from micropython import const
# Advertising payloads are repeated packets of the following form:
# 1 byte data length (N + 1)
# 1 byte type (see constants below)
# N bytes type-specific data
_ADV_TYPE_FLAGS = const(0x01)
_ADV_TYPE_NAME = const(0x09)
_ADV_TYPE_UUID16_COMPLETE = const(0x3)
_ADV_TYPE_UUID32_COMPLETE = const(0x5)
_ADV_TYPE_UUID128_COMPLETE = const(0x7)
_ADV_TYPE_UUID16_MORE = const(0x2)
_ADV_TYPE_UUID32_MORE = const(0x4)
_ADV_TYPE_UUID128_MORE = const(0x6)
_ADV_TYPE_APPEARANCE = const(0x19)
# Generate a payload to be passed to gap_advertise(adv_data=...).
def advertising_payload(limited_disc=False,
br_edr=False,
name=None,
services=None,
See:
STM32Cube_FW_F4_V1.1.0/Drivers/BSP/Components/lis302dl/lis302dl.h
STM32Cube_FW_F4_V1.1.0/Drivers/BSP/Components/lis302dl/lis302dl.c
STM32Cube_FW_F4_V1.1.0/Drivers/BSP/STM32F4-Discovery/stm32f4_discovery.c
STM32Cube_FW_F4_V1.1.0/Drivers/BSP/STM32F4-Discovery/stm32f4_discovery.h
STM32Cube_FW_F4_V1.1.0/Drivers/BSP/STM32F4-Discovery/stm32f4_discovery_accelerometer.c
STM32Cube_FW_F4_V1.1.0/Drivers/BSP/STM32F4-Discovery/stm32f4_discovery_accelerometer.h
STM32Cube_FW_F4_V1.1.0/Projects/STM32F4-Discovery/Demonstrations/Src/main.c
"""
from micropython import const
from pyb import Pin
from pyb import SPI
READWRITE_CMD = const(0x80)
MULTIPLEBYTE_CMD = const(0x40)
WHO_AM_I_ADDR = const(0x0f)
OUT_X_ADDR = const(0x29)
OUT_Y_ADDR = const(0x2b)
OUT_Z_ADDR = const(0x2d)
OUT_T_ADDR = const(0x0c)
LIS302DL_WHO_AM_I_VAL = const(0x3b)
LIS302DL_CTRL_REG1_ADDR = const(0x20)
# Configuration for 100Hz sampling rate, +-2g range
LIS302DL_CONF = const(0b01000111)
LIS3DSH_WHO_AM_I_VAL = const(0x3f)
LIS3DSH_CTRL_REG4_ADDR = const(0x20)
LIS3DSH_CTRL_REG5_ADDR = const(0x24)
* Author(s): Tony DiCola, Scott Shawcroft
"""
import math
from micropython import const
__version__ = "1.3.3"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_Motor.git"
# Stepper Motor Shield/Wing Driver
# Based on Adafruit Motorshield library:
# https://github.com/adafruit/Adafruit_Motor_Shield_V2_Library
# Constants that specify the direction and style of steps.
FORWARD = const(1)
"""Step forward"""
BACKWARD = const(2)
""""Step backward"""
SINGLE = const(1)
"""Step so that each step only activates a single coil"""
DOUBLE = const(2)
"""Step so that each step only activates two coils to produce more torque."""
INTERLEAVE = const(3)
"""Step half a step to alternate between single coil and double coil steps."""
MICROSTEP = const(4)
"""Step a fraction of a step by partially activating two neighboring coils. Step size is determined
by ``microsteps`` constructor argument."""
class StepperMotor:
"""A bipolar stepper motor or four coil unipolar motor.
* Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice
"""
import time
try:
import ustruct as struct
except ImportError:
import struct
import adafruit_bus_device.i2c_device as i2c_dev
from micropython import const
# Internal constants and register values:
# pylint: disable=bad-whitespace
_FXAS21002C_ADDRESS = const(0x21) # 0100001
_FXAS21002C_ID = const(0xD7) # 1101 0111
_GYRO_REGISTER_STATUS = const(0x00)
_GYRO_REGISTER_OUT_X_MSB = const(0x01)
_GYRO_REGISTER_OUT_X_LSB = const(0x02)
_GYRO_REGISTER_OUT_Y_MSB = const(0x03)
_GYRO_REGISTER_OUT_Y_LSB = const(0x04)
_GYRO_REGISTER_OUT_Z_MSB = const(0x05)
_GYRO_REGISTER_OUT_Z_LSB = const(0x06)
_GYRO_REGISTER_WHO_AM_I = const(0x0C) # 11010111 r
_GYRO_REGISTER_CTRL_REG0 = const(0x0D) # 00000000 r/w
_GYRO_REGISTER_CTRL_REG1 = const(0x13) # 00000000 r/w
_GYRO_REGISTER_CTRL_REG2 = const(0x14) # 00000000 r/w
_GYRO_SENSITIVITY_250DPS = 0.0078125 # Table 35 of datasheet
_GYRO_SENSITIVITY_500DPS = 0.015625 # ..
_GYRO_SENSITIVITY_1000DPS = 0.03125 # ..
from micropython import const
from trezor import ui
TEXT_HEADER_HEIGHT = const(48)
TEXT_LINE_HEIGHT = const(26)
TEXT_MARGIN_LEFT = const(14)
class Text(ui.Widget):
def __init__(self, header_text, header_icon, *content, icon_color=ui.ORANGE_ICON):
self.header_text = header_text
self.header_icon = header_icon
self.icon_color = icon_color
self.content = content
def render(self):
offset_x = TEXT_MARGIN_LEFT
offset_y = TEXT_LINE_HEIGHT + TEXT_HEADER_HEIGHT
style = ui.NORMAL
fg = ui.FG
bg = ui.BG
ui.header(self.header_text, self.header_icon, ui.TITLE_GREY, ui.BG, self.icon_color)
for item in self.content:
if isinstance(item, str):
ui.display.text(offset_x, offset_y, item, style, fg, bg)
offset_y += TEXT_LINE_HEIGHT
elif item == ui.MONO or item == ui.NORMAL or item == ui.BOLD:
style = item
else:
"""
import math
import time
from micropython import const
try:
import struct
except ImportError:
import ustruct as struct
__version__ = "2.2.1"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_BME280.git"
# I2C ADDRESS/BITS/SETTINGS
# -----------------------------------------------------------------------
_BME280_ADDRESS = const(0x77)
_BME280_CHIPID = const(0x60)
_BME280_REGISTER_CHIPID = const(0xD0)
_BME280_REGISTER_DIG_T1 = const(0x88)
_BME280_REGISTER_DIG_H1 = const(0xA1)
_BME280_REGISTER_DIG_H2 = const(0xE1)
_BME280_REGISTER_DIG_H3 = const(0xE3)
_BME280_REGISTER_DIG_H4 = const(0xE4)
_BME280_REGISTER_DIG_H5 = const(0xE5)
_BME280_REGISTER_DIG_H6 = const(0xE7)
_BME280_REGISTER_SOFTRESET = const(0xE0)
_BME280_REGISTER_CTRL_HUM = const(0xF2)
_BME280_REGISTER_STATUS = const(0xF3)
_BME280_REGISTER_CTRL_MEAS = const(0xF4)
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ from micropython import const from time import sleep_ms import ustruct # Display resolution EPD_WIDTH = const(200) EPD_HEIGHT = const(200) # Display commands DRIVER_OUTPUT_CONTROL = const(0x01) BOOSTER_SOFT_START_CONTROL = const(0x0C) #GATE_SCAN_START_POSITION = const(0x0F) DEEP_SLEEP_MODE = const(0x10) DATA_ENTRY_MODE_SETTING = const(0x11) #SW_RESET = const(0x12) #TEMPERATURE_SENSOR_CONTROL = const(0x1A) MASTER_ACTIVATION = const(0x20) #DISPLAY_UPDATE_CONTROL_1 = const(0x21) DISPLAY_UPDATE_CONTROL_2 = const(0x22) WRITE_RAM = const(0x24) WRITE_VCOM_REGISTER = const(0x2C)
"""
import time
try:
import struct
except ImportError:
import ustruct as struct
from adafruit_bus_device.i2c_device import I2CDevice
from micropython import const
__version__ = "1.1.2"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_MLX90393.git"
_CMD_SB = const(0b00010000) # Start burst mode
_CMD_SW = const(0b00100000) # Start wakeup on change mode
_CMD_SM = const(0b00110000) # Start single-measurement mode
_CMD_RM = const(0b01000000) # Read measurement
_CMD_RR = const(0b01010000) # Read register
_CMD_WR = const(0b01100000) # Write register
_CMD_EX = const(0b10000000) # Exit mode
_CMD_HR = const(0b11010000) # Memory recall
_CMD_HS = const(0b11100000) # Memory store
_CMD_RT = const(0b11110000) # Reset
_CMD_NOP = const(0x00) # NOP
_CMD_AXIS_ALL = const(0xE) # X+Y+Z axis bits for commands
_CMD_REG_CONF1 = const(0x00) # Gain
_CMD_REG_CONF2 = const(0x01) # Burst, comm mode
class SPS30:
# index of list
# I2C address: 0x69
SPS_ADDR = const(0x00)
# float array of values
SPS_PM1P0 = const(0)
SPS_PM2P5 = const(1)
SPS_PM4P0 = const(2)
SPS_PM10P0 = const(3)
SPS_PCNT_0P5 = const(4)
SPS_PCNT_1P0 = const(5)
SPS_PCNT_2P5 = const(6)
SPS_PCNT_4P0 = const(7)
SPS_PCNT_10P0 = const(8)
SPS_TYP_SIZE = const(9)
# status PM sensor: STANDBY (fan off) or NORMAL (fan ON, sampling)
ACTIVE = const(0) # mode active, has allowed to fan startup
PASSIVE = const(1) # mode passive, same as NORMAL
NORMAL = const(3) # mode normal, fan is ON, sampling measurements
STANDBY = const(4) # mode passive, state standby fan is OFF
# idle time minimal time to switch fan OFF
IDLE = const(
120000) # msecs, minimal idle time between sample time and interval
def __init__(self,
port=1,
debug=False,
sample=60,
interval=1200,
raw=False,
calibrate=None,
pins=('P3', 'P4'),
addr=SPS_ADDR,
clean=0,
explicit=False):
# read from port=UART1 V5/Gnd, PMS/Rx - GPIO P3/Tx, PMS/Tx - GPIO P4/Rx
# or port=/dev/ttyUSB?
# measure average in sample time, interval freq. of samples in secs
# explicit True: Plantower way of count (>PMi), False: Sensirion way (PM0.3-PMi) (dflt=False)
# idle <8 mA, operation 60 mA, max 5.5V, count/mass: 0.3 - size um
# SPS pin nr:
# 1=VCC, 2=Rx/SDA, 3=Tx/SCL, 4= sel(Gnd,I2C), 5=Gnd, 5 is corner side
# clean > 0: secs interval autoclean, 0 (dflt): weekly, None: clean initial
try:
if type(port) is str: # no PyCom case
import serial
self.ser = serial.Serial(port,
115200,
bytesize=8,
parity='N',
stopbits=1,
timeout=20,
xonxoff=0,
rtscts=0)
self.ser.any = self.in_waiting
elif type(port) is int: # micro python case
from machine import UART
self.ser = UART(port,
baudrate=115200,
pins=pins,
timeout_chars=10)
else:
self.ser = port # fd
except:
raise ValueError("SPS serial failed")
self.debug = debug
self.addr = addr
self.mode = self.PASSIVE
self.started = None
self.interval = interval * 1000 # if interval == 0 no auto fan switching
self.sample = sample * 1000
self.raw = raw
self.clean = clean # clean fan after clean secs dflt: None (weekly)
self.explicit = explicit # counts are > PM size or < PM size
# dflts are from sample label. Try later again
self.name = 'SPS30'
self.firmware = '117118'
self.code = 'SEN-15103'
self.clean = clean
# list of name, units, index in measurments, calibration factoring
# eg pm1=[20,1] adds a calibration offset of 20 to measurement
self.PM_fields = [
['pm1', 'ug/m3', self.SPS_PM1P0, [0, 1]], # 0.3 upto 1
['pm25', 'ug/m3', self.SPS_PM2P5, [0, 1]], # 0.3 upto 2.5
['pm4', 'ug/m3', self.SPS_PM4P0, [0, 1]],
['pm10', 'ug/m3', self.SPS_PM10P0, [0, 1]],
# 0.1 liter = 0.00353147 cubic feet, convert -> pcs / 0.01qf
# std used here pcs/0.1dm3 (Plantower style)
['pm05_cnt', 'pcs/0.1dm3', self.SPS_PCNT_0P5, [0, 100]],
['pm1_cnt', 'pcs/0.1dm3', self.SPS_PCNT_1P0, [0, 100]],
['pm25_cnt', 'pcs/0.1dm3', self.SPS_PCNT_2P5, [0, 100]],
['pm4_cnt', 'pcs/0.1dm3', self.SPS_PCNT_4P0, [0, 100]],
['pm10_cnt', 'pcs/0.1dm3', self.SPS_PCNT_10P0, [0, 100]],
['grain', 'mu', self.SPS_TYP_SIZE, None],
# grain: average particle size
['grain', 'mu', self.SPS_TYP_SIZE, None] if not explicit else
['pm03_cnt', 'pcs/0.1dm3', self.SPS_TYP_SIZE, [0, 100]],
]
if type(calibrate) is dict:
for key in calibrate.keys():
if calibrate[key] and type(calibrate[key]) != list: continue
for pm in range(len(self.PM_fields)):
if self.PM_fields[pm][0] == key:
self.PM_fields[pm][3] = calibrate[key]
break
def isStarted(self, debug=False):
if self.started: return
self.started = 0
# dflts are from sample label
try:
self.started = True
if self.reset(debug=debug):
RuntimeError("Reset failed with %d" % stat)
# collect meta info
tmp = self.device_info('name')
if tmp: self.name = tmp
tmp = self.device_info('serial')
if tmp: self.firmware = tmp
tmp = self.device_info('code')
if tmp: self.code = tmp
if debug:
print("name: '%s', S/N '%s', article: '%s'" %
(self.name, self.firmware, self.device_info('code')))
if self.clean:
self.auto_clean(self.clean, debug=debug)
self.clean = 0
elif self.clean == None:
self.fan_clean(debug=debug)
except Exception as e:
RuntimeError(e)
def in_waiting(self): # for non PyCom python
try:
return self.ser.in_waiting
except:
raise OSError
def read_until(self, char=chr(0x7E)):
try:
cnt = 0
while True:
cnt += 1
if cnt > 20: return None
if not self.ser.any():
sleep_ms(200)
continue
try:
if self.ser.read(1) != char: continue
except:
pass
return char
except:
return None
# calibrate by length calibration (Taylor) factor array
def calibrate(self, cal, value):
if self.raw: return value
if (not cal) or (type(cal) != list):
return round(value, 2)
if type(value) is int: value = float(value)
if not type(value) is float:
return None
rts = 0
pow = 0
for a in cal:
rts += a * (value**pow)
pow += 1
return rts
error = {
0x0: 'ok',
0x1: 'data length err',
0x2: 'fan off',
0x4: 'illegal cmd param',
0x28: 'internal fie arg range error',
0x43: 'cmd not allowed in this state',
}
stuff = { # byte stuffing with 0x7D
0x7E: 0x5E, 0x7D: 0x5D,
0x11: 0x31, 0x13: 0x33,
}
# just before sending, returns byte array
def stuffing(self, arr):
rslt = [0x7E]
for b in arr:
if b in self.stuff.keys():
rslt += [0x7D, stuff[b]]
else:
rslt.append(b)
rslt += [0x7E]
return bytearray(rslt)
# just after reading, returns int array
def unstuff(self, data): # to do unstuffing
rslt = []
for i in range(0, len(data)):
if data[i] == 0x7D:
try:
for val in self.stuff.items():
if val[1] == data[i + 1]:
rslt.append(val[0])
break
i += 1
except:
pass
else:
rslt.append(data[i])
return rslt
# adds addr and append checksum, send stuffed bytearray
def send(self, cmd, data, debug=False):
self.isStarted(debug=debug)
s = [self.addr, cmd, len(data)] + data
s.append((~(sum(s) & 0xFF)) & 0xFF)
s = self.stuffing(s)
if debug: print("Send: ", s)
return self.ser.write(s)
# get data from uart, return tuple(status,data[])
def receive(self, cmd, debug=False):
strt = True
buf = bytearray()
for cnt in range(1, 6):
if self.ser.any():
cnt = 0
break
if debug: print("SPS wait...")
sleep_ms(1000)
if cnt: return (0x2, [])
while True:
try:
char = self.ser.read(1)
except:
return (0x2, [])
if char == b'': raise OSError("No data")
elif strt:
if (char == b'\x7E'): strt = False
continue
if char == b'\x7E': break
buf += char
buf = self.unstuff(buf)
# to do: add sum chk, cmd check: buf[1] == cmd
if len(buf[4:-1]) != buf[3]: raise ValueError("length rcv")
if debug: print("Received: %s" % str(buf))
if (~sum(buf) & 0xFF): raise ValueError("checksum")
if buf[1] != cmd: raise ValueError("sensor reply error")
return (buf[2], buf[4:4 + buf[3]]) # status, data
# UART / Sensirion SPS30 SHDLC commands
SPS_START = const(0x00)
SPS_STOP = const(0x01)
SPS_READ = const(0x03)
SPS_FAN_SPEED = const(0x04)
SPS_AUTO_CLEAN = const(0x80)
SPS_FAN_CLEAN = const(0x56)
SPS_INFO = const(0xD0)
SPS_RESET = const(0xD3)
def start_measurement(self, debug=False):
if debug: print("Start SPS")
# subcmd=0x01, mode=0x03
self.send(self.SPS_START, [0x01, 0x03], debug=debug)
return self.receive(self.SPS_START)[0]
def stop_measurement(self, debug=False):
# to idle state
if debug: print("Stop SPS")
self.send(self.SPS_STOP, [], debug=debug)
return self.receive(self.SPS_STOP, debug=debug)[0]
# mass ug/m3: PM1.0, PM2.5, PM4.0, PM10
# count pcs/cm3: PM0.5, PM1.0, PM2.5, PM4.0, PM10
# typical pm size
def read_measurement(self,
debug=False
): # default 1 sec sample, empty if no value yet
if debug: print("Read SPS values")
self.send(self.SPS_READ, [])
(status, data) = self.receive(self.SPS_READ, debug=debug)
if status:
try:
print("SPS error: %d (%s)" % (status, self.error[status]))
except:
print("SPS unknown error: %d" % status)
return []
rslts = []
for i in range(0, len(data), 4):
if (i + 4) > len(data): break
rslts.append(struct.unpack('>f', bytearray((data[i:i + 4])))[0])
if debug: print("Read: ", rslts)
return rslts
# routine is from Sensirion sample. Gives status 2, no speed
def fan_speed(self, debug=False):
if debug: print("Get fan speed")
self.send(self.SPS_FAN_SPEED, [], debug=debug)
rslts = self.receive(self.SPS_FAN_SPEED, debug=debug)
if debug: print(rslts)
if not rslts[0]: return rslts[1][0]
else: return self.error[rslts[0]]
# read/write auto cleaning interval, 10 secs clean air boost
# interval=0 disable auto clean, dflt 604.800 secs/one week
# poweroff will reset next clean
def auto_clean(self, interval=None, debug=False):
if interval == None:
if debug: print("Auto clean, no interval")
self.send(self.SPS_AUTO_CLEAN, [
0x0,
], debug=debug)
else:
if debug: print("Auto clean, interval %d" % interval)
b = bytearray(struct.pack('>L', interval))
self.send(self.SPS_AUTO_CLEAN, [0x0, b[0], b[1], b[2], b[4]],
debug=debug)
return self.receive(self.SPS_AUTO_CLEAN)[0]
# forced fan cleaning
def fan_clean(self, debug=False):
if debug: print("Clean fan")
self.send(self.SPS_FAN_CLEAN, [], debug=debug)
return self.receive(self.SPS_FAN_CLEAN)[0]
# get information from sensor. Sample gives empty string
def device_info(self, info='serial', debug=False):
cmds = {'name': 0x01, 'code': 0x2, 'serial': 0x03}
try:
if (not info) or (info == 'all'):
rslt = []
for cmd in cmds.keys():
rslt.append(cmd + ': ' + self.device_info(cmd))
return ', '.join(rslt)
elif info in cmds.keys():
self.send(self.SPS_INFO, [cmds[info]], debug=debug)
strg = self.receive(self.SPS_INFO)[1][:-1]
strg = str(strg[:-1].decode("ascii"))
if debug: print("Got info \"%s\"" % strg)
return strg
except:
pass
return ''
# soft reset similar as power reset
def reset(self, debug=False):
if debug: print("SPS reset")
try:
self.send(self.SPS_RESET, [], debug=debug)
stat = self.receive(self.SPS_RESET)[0]
if not stat: self.mode = self.STANDBY
if debug: print("reset status: %d" % stat)
except Exception as e:
raise RuntimeError(e)
return stat
# passive mode, go into standby state / sleep: fan OFF
def Standby(self, debug=False):
if debug: print("Go standby from 0X%X" % self.mode)
if self.mode != self.STANDBY:
try:
self.stop_measurement(debug=debug)
except:
return False
self.mode = self.STANDBY
return True
# passive mode, go into normal state: fan ON, allow data telegrams reading
def Normal(self, debug=False):
if debug: print("Go normal from 0x%X" % self.mode)
return self.GoPassive(debug=debug)
# passive mode wait on read request
def GoPassive(self, debug=False):
if debug: print("Go Passive from 0X%X" % self.mode)
if self.mode == self.STANDBY:
try:
self.start_measurement(debug=debug)
sleep_ms(30000)
except:
return False
self.mode = self.PASSIVE
return True
# from passive mode go in active mode (same as with power on)
def GoActive(self, debug=False):
if debug: print("Go active from 0X%X" % self.mode)
return self.GoPassive(debug=debug)
# in passive mode do one data telegram reading
def PassiveRead(self, debug=False):
if self.mode == self.STANDBY:
if not self.GoPassive(debug=debug): return []
return self.read_measurement(debug=debug)
def getData(self, debug=False):
''' read data telegrams from the serial interface (32 bytes)
before actual read flush all pending data first
during the period sample time: active (200-800 ms), passive read cmd 1 sec
calculate average during sample seconds
if passive mode fan off: switch fan ON and wait 30 secs.
'''
ErrorCnt = 0
cnt = 0
PM_sample = {}
# clear the input buffer first so we get latest reading
if self.mode == self.STANDBY: self.GoPassive(debug=debug)
StrtTime = ticks_ms()
LastTime = StrtTime + self.sample - 1000
while True:
buff = []
try:
buff = self.PassiveRead(debug=debug)
except:
pass
if len(buff) == self.SPS_TYP_SIZE + 1: # must be all
for fld in self.PM_fields:
PM_sample[fld[0]] = PM_sample.setdefault(
fld[0], 0.0) + buff[fld[2]]
cnt += 1
elif not len(PM_sample):
self.mode = self.STANDBY # wake it up
return self.getData(debug=debug)
if ticks_ms() >= LastTime: break
sleep_ms(5000)
# turn fan off?
if self.interval - (ticks_ms() - StrtTime) > 60 * 1000:
self.Standby(debug=debug) # switch fan OFF
if cnt: # average count during the sample time
for fld in self.PM_fields:
PM_sample[fld[0]] /= cnt
if self.raw:
PM_sample[fld[0]] = round(PM_sample[fld[0]], 2)
else:
PM_sample[fld[0]] = round(
self.calibrate(fld[3], PM_sample[fld[0]]), 2)
if self.explicit:
PM10 = PM_sample["pm10_cnt"]
for pmCnt in PM_sample.keys():
if pmCnt.find('_cnt') < 0: continue
if pmCnt.find('03_cnt') > 0: PM_sample['pm03_cnt'] = PM10
else: PM_sample[pmCnt] = PM10 - PM_sample[pmCnt]
return PM_sample
* Author(s): Jerry Needell """ # imports import time from micropython import const __version__ = "1.1.1" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_STMPE610.git" _STMPE_ADDR = const(0x41) _STMPE_VERSION = const(0x0811) _STMPE_SYS_CTRL1 = const(0x03) _STMPE_SYS_CTRL1_RESET = const(0x02) _STMPE_SYS_CTRL2 = const(0x04) _STMPE_TSC_CTRL = const(0x40) _STMPE_TSC_CTRL_EN = const(0x01) _STMPE_TSC_CTRL_XYZ = const(0x00) _STMPE_TSC_CTRL_XY = const(0x02) _STMPE_INT_CTRL = const(0x09) _STMPE_INT_CTRL_POL_HIGH = const(0x04) _STMPE_INT_CTRL_POL_LOW = const(0x00) _STMPE_INT_CTRL_EDGE = const(0x02)
#
# The sensor's local value updates every second, and it will notify
# any connected central every 10 seconds.
import bluetooth
import random
import struct
import time
from ble_advertising import advertising_payload
from machine import Pin, ADC
from micropython import const
pot = ADC(Pin(32))
pot.atten(ADC.ATTN_11DB)
_IRQ_CENTRAL_CONNECT = const(1 << 0)
_IRQ_CENTRAL_DISCONNECT = const(1 << 1)
# org.bluetooth.service.environmental_sensing
_ENV_SENSE_UUID = bluetooth.UUID(0x181A)
# org.bluetooth.characteristic.temperature
_TEMP_CHAR = (
bluetooth.UUID(0x2A6E),
bluetooth.FLAG_READ | bluetooth.FLAG_NOTIFY,
)
_ENV_SENSE_SERVICE = (
_ENV_SENSE_UUID,
(_TEMP_CHAR,),
)
# org.bluetooth.characteristic.gap.appearance.xml
* Adafruit CircuitPython firmware for the supported boards:
https://github.com/adafruit/circuitpython/releases
* Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice
"""
import time
import struct
import adafruit_bus_device.i2c_device as i2c_device
from micropython import const
__version__ = "1.0.1"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_MPL115A2.git"
# pylint: disable=bad-whitespace
_MPL115A2_ADDRESS = const(0x60)
_MPL115A2_REGISTER_PRESSURE_MSB = const(0x00)
_MPL115A2_REGISTER_A0_COEFF_MSB = const(0x04)
_MPL115A2_REGISTER_STARTCONVERSION = const(0x12)
# pylint: enable=bad-whitespace
class MPL115A2:
"""Driver for MPL115A2 I2C barometric pressure / temperature sensor."""
def __init__(self, i2c, address=_MPL115A2_ADDRESS):
self._i2c = i2c_device.I2CDevice(i2c, address)
self._buf = bytearray(4)
self._read_coefficients()
@property
def pressure(self):
"""The pressure in hPa."""
# * Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice
"""
import time
try:
import struct
except ImportError:
import ustruct as struct
from micropython import const
__version__ = "0.0.0-auto.0"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_BMP3XX.git"
_BMP388_CHIP_ID = const(0x50)
_BMP390_CHIP_ID = const(0x60)
# pylint: disable=import-outside-toplevel
_REGISTER_CHIPID = const(0x00)
_REGISTER_STATUS = const(0x03)
_REGISTER_PRESSUREDATA = const(0x04)
_REGISTER_TEMPDATA = const(0x07)
_REGISTER_CONTROL = const(0x1B)
_REGISTER_OSR = const(0x1C)
_REGISTER_ODR = const(0x1D)
_REGISTER_CONFIG = const(0x1F)
_REGISTER_CAL_DATA = const(0x31)
_REGISTER_CMD = const(0x7E)
_OSR_SETTINGS = (1, 2, 4, 8, 16, 32
Example usage on ESP8266:
import machine, sdcard, os
sd = sdcard.SDCard(machine.SPI(0), machine.Pin(15))
os.umount()
os.VfsFat(sd, "")
os.listdir()
"""
from micropython import const
import time
_CMD_TIMEOUT = const(100)
_R1_IDLE_STATE = const(1 << 0)
#R1_ERASE_RESET = const(1 << 1)
_R1_ILLEGAL_COMMAND = const(1 << 2)
#R1_COM_CRC_ERROR = const(1 << 3)
#R1_ERASE_SEQUENCE_ERROR = const(1 << 4)
#R1_ADDRESS_ERROR = const(1 << 5)
#R1_PARAMETER_ERROR = const(1 << 6)
_TOKEN_CMD25 = const(0xfc)
_TOKEN_STOP_TRAN = const(0xfd)
_TOKEN_DATA = const(0xfe)
class SDCard:
def __init__(self, spi, cs):
data = data & 0b11001111
data = data | 0b00110000
self.write_byte(AXP202_OFF_CTL, data)
# =============================================================================
#
# LCD
#
# this is from: https://github.com/devbis/st7789py_mpy
# (seems to be under MIT license)
#
# =============================================================================
# chip commands
ST77XX_NOP = const(0x00)
ST77XX_SWRESET = const(0x01)
ST77XX_RDDID = const(0x04)
ST77XX_RDDST = const(0x09)
ST77XX_SLPIN = const(0x10)
ST77XX_SLPOUT = const(0x11)
ST77XX_PTLON = const(0x12)
ST77XX_NORON = const(0x13)
ST77XX_INVOFF = const(0x20)
ST77XX_INVON = const(0x21)
ST77XX_DISPOFF = const(0x28)
ST77XX_DISPON = const(0x29)
ST77XX_CASET = const(0x2A)
ST77XX_RASET = const(0x2B)
* Adafruit CircuitPython firmware for the ESP8622 and M0-based boards: https://github.com/adafruit/circuitpython/releases * Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice """ import math import time import adafruit_bus_device.i2c_device as i2c_device from micropython import const __version__ = "3.1.4" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_VL53L0X.git" # Configuration constants: # pylint: disable=bad-whitespace _SYSRANGE_START = const(0x00) _SYSTEM_THRESH_HIGH = const(0x0C) _SYSTEM_THRESH_LOW = const(0x0E) _SYSTEM_SEQUENCE_CONFIG = const(0x01) _SYSTEM_RANGE_CONFIG = const(0x09) _SYSTEM_INTERMEASUREMENT_PERIOD = const(0x04) _SYSTEM_INTERRUPT_CONFIG_GPIO = const(0x0A) _GPIO_HV_MUX_ACTIVE_HIGH = const(0x84) _SYSTEM_INTERRUPT_CLEAR = const(0x0B) _RESULT_INTERRUPT_STATUS = const(0x13) _RESULT_RANGE_STATUS = const(0x14) _RESULT_CORE_AMBIENT_WINDOW_EVENTS_RTN = const(0xBC) _RESULT_CORE_RANGING_TOTAL_EVENTS_RTN = const(0xC0) _RESULT_CORE_AMBIENT_WINDOW_EVENTS_REF = const(0xD0) _RESULT_CORE_RANGING_TOTAL_EVENTS_REF = const(0xD4) _RESULT_PEAK_SIGNAL_RATE_REF = const(0xB6)
<https://www.adafruit.com/product/3709>`_ (Product ID: 3709)
**Software and Dependencies:**
* MicroPython:
https://github.com/micropython/micropython
"""
import time
from micropython import const
__version__ = "0.0.0-auto.0"
__repo__ = "https://github.com/alexmrqt/Adafruit_CircuitPython_SGP30.git"
# pylint: disable=bad-whitespace
_SGP30_DEFAULT_I2C_ADDR = const(0x58)
_SGP30_FEATURESET = const(0x0020)
_SGP30_CRC8_POLYNOMIAL = const(0x31)
_SGP30_CRC8_INIT = const(0xFF)
_SGP30_WORD_LEN = const(2)
# pylint: enable=bad-whitespace
class Adafruit_SGP30:
"""
A driver for the SGP30 gas sensor.
:param i2c: The `I2C` object to use. This is the only required parameter.
:param int address: (optional) The I2C address of the device.
"""
* Adafruit CircuitPython firmware for the supported boards:
https://github.com/adafruit/circuitpython/releases
* Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice
"""
import adafruit_bus_device.i2c_device as i2c_device
from micropython import const
from adafruit_cap1188.cap1188 import CAP1188
__version__ = "1.1.0"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_CAP1188.git"
# pylint: disable=bad-whitespace
_CAP1188_DEFAULT_ADDRESS = const(0x29)
# pylint: enable=bad-whitespace
class CAP1188_I2C(CAP1188):
"""Driver for the CAP1188 connected over I2C."""
def __init__(self, i2c, address=_CAP1188_DEFAULT_ADDRESS):
self._i2c = i2c_device.I2CDevice(i2c, address)
self._buf = bytearray(2)
super().__init__()
def _read_register(self, address):
"""Return 8 bit value of register at address."""
self._buf[0] = address
with self._i2c as i2c:
i2c.write(self._buf, end=1, stop=False)
i2c.readinto(self._buf, start=1)
`ads1x15`
====================================================
CircuitPython base class driver for ADS1015/1115 ADCs.
* Author(s): Carter Nelson
"""
__version__ = "0.0.0-auto.0"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_ADS1x15.git"
from micropython import const
from adafruit_bus_device.i2c_device import I2CDevice
# pylint: disable=bad-whitespace
_ADS1X15_DEFAULT_ADDRESS = const(0x48)
_ADS1X15_POINTER_CONVERSION = const(0x00)
_ADS1X15_POINTER_CONFIG = const(0x01)
_ADS1X15_CONFIG_OS_SINGLE = const(0x8000)
_ADS1X15_CONFIG_MUX_OFFSET = const(12)
_ADS1X15_CONFIG_COMP_QUE_DISABLE = const(0x0003)
_ADS1X15_CONFIG_GAIN = {
2 / 3: 0x0000,
1: 0x0200,
2: 0x0400,
4: 0x0600,
8: 0x0800,
16: 0x0A00
}
# pylint: enable=bad-whitespace
`adafruit_rgb_display.ssd1331` ==================================================== A simple driver for the SSD1331-based displays. * Author(s): Radomir Dopieralski, Michael McWethy """ from micropython import const from adafruit_rgb_display.rgb import DisplaySPI __version__ = "3.1.1" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_RGB_Display.git" _DRAWLINE = const(0x21) _DRAWRECT = const(0x22) _FILL = const(0x26) _PHASEPERIOD = const(0x12) _SETCOLUMN = const(0x15) _SETROW = const(0x75) _CONTRASTA = const(0x81) _CONTRASTB = const(0x82) _CONTRASTC = const(0x83) _MASTERCURRENT = const(0x87) _SETREMAP = const(0xA0) _STARTLINE = const(0xA1) _DISPLAYOFFSET = const(0xA2) _NORMALDISPLAY = const(0xA4) _DISPLAYALLON = const(0xA5) _DISPLAYALLOFF = const(0xA6)
import bluetooth
import uasyncio as asyncio
from .core import (
ensure_active,
ble,
log_info,
log_error,
log_warn,
register_irq_handler,
)
from .device import DeviceConnection, DeviceTimeout
_registered_characteristics = {}
_IRQ_GATTS_WRITE = const(3)
_IRQ_GATTS_READ_REQUEST = const(4)
_IRQ_GATTS_INDICATE_DONE = const(20)
_FLAG_READ = const(0x0002)
_FLAG_WRITE_NO_RESPONSE = const(0x0004)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)
_FLAG_INDICATE = const(0x0020)
_FLAG_READ_ENCRYPTED = const(0x0200)
_FLAG_READ_AUTHENTICATED = const(0x0400)
_FLAG_READ_AUTHORIZED = const(0x0800)
_FLAG_WRITE_ENCRYPTED = const(0x1000)
_FLAG_WRITE_AUTHENTICATED = const(0x2000)
_FLAG_WRITE_AUTHORIZED = const(0x4000)
"""NRF24L01 driver for MicroPython """ from micropython import const import utime # nRF24L01+ registers CONFIG = const(0x00) EN_RXADDR = const(0x02) SETUP_AW = const(0x03) SETUP_RETR = const(0x04) RF_CH = const(0x05) RF_SETUP = const(0x06) STATUS = const(0x07) RX_ADDR_P0 = const(0x0a) TX_ADDR = const(0x10) RX_PW_P0 = const(0x11) FIFO_STATUS = const(0x17) DYNPD = const(0x1c) # CONFIG register EN_CRC = const(0x08) # enable CRC CRCO = const(0x04) # CRC encoding scheme; 0=1 byte, 1=2 bytes PWR_UP = const(0x02) # 1=power up, 0=power down PRIM_RX = const(0x01) # RX/TX control; 0=PTX, 1=PRX # RF_SETUP register POWER_0 = const(0x00) # -18 dBm POWER_1 = const(0x02) # -12 dBm POWER_2 = const(0x04) # -6 dBm POWER_3 = const(0x06) # 0 dBm
from collections import namedtuple
except ImportError:
from ucollections import namedtuple
try:
import struct
except ImportError:
import ustruct as struct
from micropython import const
__version__ = "4.3.3"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_LIS3DH.git"
# Register addresses:
# pylint: disable=bad-whitespace
_REG_OUTADC1_L = const(0x08)
_REG_WHOAMI = const(0x0F)
_REG_TEMPCFG = const(0x1F)
_REG_CTRL1 = const(0x20)
_REG_CTRL3 = const(0x22)
_REG_CTRL4 = const(0x23)
_REG_CTRL5 = const(0x24)
_REG_OUT_X_L = const(0x28)
_REG_INT1SRC = const(0x31)
_REG_CLICKCFG = const(0x38)
_REG_CLICKSRC = const(0x39)
_REG_CLICKTHS = const(0x3A)
_REG_TIMELIMIT = const(0x3B)
_REG_TIMELATENCY = const(0x3C)
_REG_TIMEWINDOW = const(0x3D)
* Adafruit `TTL Serial JPEG Camera with NTSC Video <https://www.adafruit.com/product/397>`_ (Product ID: 397) **Software and Dependencies:** * Adafruit CircuitPython firmware for the ESP8622 and M0-based boards: https://github.com/adafruit/circuitpython/releases """ from micropython import const __version__ = "4.0.1" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_VC0706.git" # pylint: disable=bad-whitespace _SERIAL = const(0x00) _RESET = const(0x26) _GEN_VERSION = const(0x11) _SET_PORT = const(0x24) _READ_FBUF = const(0x32) _GET_FBUF_LEN = const(0x34) _FBUF_CTRL = const(0x36) _DOWNSIZE_CTRL = const(0x54) _DOWNSIZE_STATUS = const(0x55) _READ_DATA = const(0x30) _WRITE_DATA = const(0x31) _COMM_MOTION_CTRL = const(0x37) _COMM_MOTION_STATUS = const(0x38) _COMM_MOTION_DETECTED = const(0x39) _MOTION_CTRL = const(0x42) _MOTION_STATUS = const(0x43)
====================================================
CircuitPython module for the MCP23008 I2C I/O extenders.
* Author(s): Tony DiCola
"""
from micropython import const
from .mcp230xx import MCP230XX
from .digital_inout import DigitalInOut
__version__ = "0.0.0-auto.0"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_MCP230xx.git"
# pylint: disable=bad-whitespace
_MCP23008_ADDRESS = const(0x20)
_MCP23008_IODIR = const(0x00)
_MCP23008_IPOL = const(0x01)
_MCP23008_GPINTEN = const(0x02)
_MCP23008_DEFVAL = const(0x03)
_MCP23008_INTCON = const(0x04)
_MCP23008_IOCON = const(0x05)
_MCP23008_GPPU = const(0x06)
_MCP23008_INTF = const(0x07)
_MCP23008_INTCAP = const(0x08)
_MCP23008_GPIO = const(0x09)
class MCP23008(MCP230XX):
"""Supports MCP23008 instance on specified I2C bus and optionally
at the specified I2C address.
