def __init__(self, spi, xgcs, mcs):
self._mag_device = spi_device.SPIDevice(
spi, mcs, baudrate=200000, phase=1, polarity=1
)
self._xg_device = spi_device.SPIDevice(
spi, xgcs, baudrate=200000, phase=1, polarity=1
)
super().__init__()
def __init__(self, spi, xmcs, gcs):
gcs.direction = Direction.OUTPUT
gcs.value = True
xmcs.direction = Direction.OUTPUT
xmcs.value = True
self._gyro_device = spi_device.SPIDevice(spi, gcs)
self._xm_device = spi_device.SPIDevice(spi, xmcs)
super().__init__()
def __init__(self,
spi,
cs,
reset,
busy,
*,
preamble_length=8,
baudrate=1500000,
debug=False):
# self._device = spidev.SPIDevice(spi, cs, baudrate=baudrate, polarity=0, phase=0)
self._device = spidev.SPIDevice(spi, cs, polarity=0, phase=0)
self._reset = reset
self._reset.switch_to_input(pull=digitalio.Pull.UP)
self._busy = busy
self._busy.switch_to_input()
self.packet_type = _PACKET_TYPE_GFSK # default
self._debug = debug
self._set_ranging = False
self._ranging = False
self._status = 0
self.reset()
self._busywait()
self.clear_Irq_Status()
self.set_Regulator_Mode()
self.set_Packet_Type() # default LoRa
self.set_Standby('STDBY_RC')
self.set_Modulation_Params()
self.set_Packet_Params(pktParam3=0x05)
self.set_RF_Freq() # 2.4GHz
self.set_Buffer_Base_Address()
self.set_Tx_Param() # power=13dBm,rampTime=20us
print('Radio Initialized')
def __init__(self, spi, cs, *, baudrate=100000, int1=None, int2=None):
from adafruit_bus_device import ( # pylint: disable=import-outside-toplevel
spi_device, )
self._spi = spi_device.SPIDevice(spi, cs, baudrate=baudrate)
self._buffer = bytearray(6)
super().__init__(int1=int1, int2=int2)
def __init__(self,
spi,
cs,
rst=None,
width=800,
height=480,
baudrate=6000000,
polarity=0,
phase=0):
"""
:param SPI spi: The spi peripheral to use
:param DigitalInOut cs: The chip-select pin to use (sometimes labeled "SS")
:param DigitalInOut rst: (optional) The reset pin if it exists (default=None)
:param int width: (optional) The width of the display in pixels (default=800)
:param int height: (optional) The height of the display in pixels (default=480)
:param int baudrate: (optional) The spi speed (default=6000000)
:param int phase: (optional) The spi phase (default=0)
:param int polarity: (optional) The spi polarity (default=0)
"""
self.spi_device = spi_device.SPIDevice(spi,
cs,
baudrate=baudrate,
polarity=polarity,
phase=phase)
self.width = width
self.height = height
self._mode = None
self._tpin = None
self.rst = rst
if self.rst:
self.rst.switch_to_output(value=0)
self.reset()
if self.read_reg(0) == 0x75:
return
self._adc_clk = reg.TPCR0_ADCCLK_DIV16
def __init__(self,
spi,
dc,
cs,
rst=None,
hardware_width=1,
hardware_height=1,
baudrate=12000000,
polarity=0,
phase=0,
x_offset=0,
y_offset=0):
#spi device
self.spi_device = spi_device.SPIDevice(spi,
cs,
baudrate=baudrate,
polarity=polarity,
phase=phase)
self.dc_pin = dc
self.rst = rst
self.dc_pin.switch_to_output(value=0)
if self.rst:
self.rst.switch_to_output(value=0)
self.reset()
#disp device
super().__init__(hardware_width,
hardware_height,
x_offset=x_offset,
y_offset=y_offset)
def __init__(self,
spi,
dc_pin,
cs_pin,
reset_pin=None,
*,
contrast=80,
bias=4,
baudrate=1000000):
self._dc_pin = dc_pin
dc_pin.switch_to_output(value=False)
self.spi_device = spi_device.SPIDevice(spi, cs_pin, baudrate=baudrate)
self._reset_pin = reset_pin
if reset_pin:
reset_pin.switch_to_output(value=True)
self.buffer = bytearray((_LCDHEIGHT // 8) * _LCDWIDTH)
super().__init__(self.buffer, _LCDWIDTH, _LCDHEIGHT)
self._contrast = None
self._bias = None
self._invert = False
self.reset()
# Set LCD bias.
self.bias = bias
self.contrast = contrast
def __init__(self,
spi,
dc,
cs,
rst=None,
width=1,
height=1,
baudrate=12000000,
polarity=0,
phase=0,
*,
x_offset=0,
y_offset=0):
self.spi_device = spi_device.SPIDevice(spi,
cs,
baudrate=baudrate,
polarity=polarity,
phase=phase)
self.dc_pin = dc
self.rst = rst
self.dc_pin.switch_to_output(value=0)
if self.rst:
self.rst.switch_to_output(value=0)
self.reset()
self._X_START = x_offset # pylint: disable=invalid-name
self._Y_START = y_offset # pylint: disable=invalid-name
super().__init__(width, height)
def __init__(self,
spi,
cs,
reset,
frequency,
*,
preamble_length=8,
high_power=True,
baudrate=5000000):
self.high_power = high_power
# Device support SPI mode 0 (polarity & phase = 0) up to a max of 10mhz.
# Set Default Baudrate to 5MHz to avoid problems
self._device = spi_device.SPIDevice(spi,
cs,
baudrate=baudrate,
polarity=0,
phase=0)
# Setup reset as a digital input (default state for reset line according
# to the datasheet). This line is pulled low as an output quickly to
# trigger a reset. Note that reset MUST be done like this and set as
# a high impedence input or else the chip cannot change modes (trust me!).
self._reset = reset
self._reset.switch_to_input(pull=digitalio.Pull.UP)
self.reset()
# No device type check! Catch an error from the very first request and
# throw a nicer message to indicate possible wiring problems.
try:
# Set sleep mode, wait 10s and confirm in sleep mode (basic device check).
# Also set long range mode (LoRa mode) as it can only be done in sleep.
self.sleep()
self.long_range_mode = True
self._write_u8(_RH_RF95_REG_01_OP_MODE, 0b10001000)
time.sleep(0.01)
val = self._read_u8(_RH_RF95_REG_01_OP_MODE)
print('op mode: {0}'.format(bin(val)))
if self.operation_mode != SLEEP_MODE or not self.long_range_mode:
raise RuntimeError(
'Failed to configure radio for LoRa mode, check wiring!')
except OSError:
raise RuntimeError(
'Failed to communicate with radio, check wiring!')
# clear default setting for access to LF registers if frequency > 525MHz
if frequency > 525:
self.low_frequency_mode = 0
# Setup entire 256 byte FIFO
self._write_u8(_RH_RF95_REG_0E_FIFO_TX_BASE_ADDR, 0x00)
self._write_u8(_RH_RF95_REG_0F_FIFO_RX_BASE_ADDR, 0x00)
# Set mode idle
self.idle()
# Set modem config to RadioHead compatible Bw125Cr45Sf128 mode.
# Note no sync word is set for LoRa mode either!
self._write_u8(_RH_RF95_REG_1D_MODEM_CONFIG1, 0x72) # Fei msb?
self._write_u8(_RH_RF95_REG_1E_MODEM_CONFIG2, 0x74) # Fei lsb?
self._write_u8(_RH_RF95_REG_26_MODEM_CONFIG3, 0x00) # Preamble lsb?
# Set preamble length (default 8 bytes to match radiohead).
self.preamble_length = preamble_length
# Set frequency
self.frequency_mhz = frequency
# Set TX power to low defaut, 13 dB.
self.tx_power = 13
def __init__(self,
width,
height,
spi,
dc,
reset,
cs,
*,
external_vcc=False,
baudrate=8000000,
polarity=0,
phase=0,
page_addressing=False):
self.page_addressing = page_addressing
if self.page_addressing:
raise NotImplementedError(
"Page addressing mode with SPI has not yet been implemented.")
self.rate = 10 * 1024 * 1024
dc.switch_to_output(value=0)
self.spi_device = spi_device.SPIDevice(spi,
cs,
baudrate=baudrate,
polarity=polarity,
phase=phase)
self.dc_pin = dc
self.buffer = bytearray((height // 8) * width)
super().__init__(
memoryview(self.buffer),
width,
height,
external_vcc=external_vcc,
reset=reset,
page_addressing=self.page_addressing,
)
def __init__(self, spi, cs, baudrate=1000000): # DRV8305 supports up to 10 MHz
import adafruit_bus_device.spi_device as spi_device # pylint: disable=import-outside-toplevel
self._spi = spi_device.SPIDevice(spi, chip_select=cs, polarity=0, phase=1) # avoid overwriting polarity & phase
self._spi.chip_select.value = True # idle high
# ^ adafruit_bus_device.spi_device.__init__ switches it to an output with the arg value=True, but I'm seeing it low for ~224 ms on the scope after init if I don't add this
self._c = _DRV8305_SPI_Word()
self._r = _DRV8305_SPI_Word()
def __init__(self,
width,
height,
spi,
cs,
*,
baudrate=8000000,
polarity=0,
phase=0):
self._chip_select = cs
self._chip_select.direction = digitalio.Direction.OUTPUT
self._spi_device = spi_device.SPIDevice(spi,
cs,
baudrate=baudrate,
polarity=polarity,
phase=phase)
self._buffer = bytearray((height // 8) * width)
self.framebuf = framebuf.FrameBuffer1(self._buffer, width, height)
self.width = width
self.height = height
self.init_display()
def __init__(self,
spi,
cs,
*,
rtd_nominal=100,
ref_resistor=430.0,
wires=2):
self.rtd_nominal = rtd_nominal
self.ref_resistor = ref_resistor
self._device = spi_device.SPIDevice(spi,
cs,
baudrate=500000,
polarity=0,
phase=1)
# Set wire config register based on the number of wires specified.
if wires not in (2, 3, 4):
raise ValueError('Wires must be a value of 2, 3, or 4!')
config = self._read_u8(_MAX31865_CONFIG_REG)
if wires == 3:
config |= _MAX31865_CONFIG_3WIRE
else:
# 2 or 4 wire
config &= ~_MAX31865_CONFIG_3WIRE
self._write_u8(_MAX31865_CONFIG_REG, config)
# Default to no bias and no auto conversion.
self.bias = False
self.auto_convert = False
def __init__(self,
width,
height,
spi,
dc,
reset,
cs,
*,
external_vcc=False,
baudrate=8000000,
polarity=0,
phase=0):
self.rate = 10 * 1024 * 1024
dc.switch_to_output(value=0)
self.spi_device = spi_device.SPIDevice(spi,
cs,
baudrate=baudrate,
polarity=polarity,
phase=phase)
self.dc_pin = dc
self.buffer = bytearray((height // 8) * width)
super().__init__(memoryview(self.buffer),
width,
height,
external_vcc=external_vcc,
reset=reset)
def __init__(self, spi, cs):
import adafruit_bus_device.spi_device as spi_device
self._spi = spi_device.SPIDevice(spi, cs)
# toggle CS low/high to put BMP3XX in SPI mode
with self._spi:
time.sleep(0.001)
super().__init__()
def __init__(self, spi, cs, baudrate=100000, debug=False, *, refresh_rate=10):
from adafruit_bus_device import ( # pylint: disable=import-outside-toplevel
spi_device,
)
self._spi = spi_device.SPIDevice(spi, cs, baudrate=baudrate)
self._debug = debug
super().__init__(refresh_rate=refresh_rate)
def __init__( # pylint: disable=too-many-arguments
self,
spi,
cs,
baudrate=1000000,
calibration=None,
size=None,
disp_rotation=0,
touch_flip=(False, False),
):
self._calib = calibration
self._disp_size = size
self._disp_rotation = disp_rotation
self._touch_flip = touch_flip
# Check the touchscreen calibration and display size kwargs.
if not self._calib:
self._calib = ((0, 4095), (0, 4095))
if not self._disp_size:
self._disp_size = (4095, 4095)
if self._disp_rotation not in (0, 90, 180, 270):
raise ValueError(
"Display rotation value must be 0, 90, 180, or 270")
# Check that the STMPE610 was found.
import adafruit_bus_device.spi_device as spidev # pylint: disable=import-outside-toplevel
self._spi = spidev.SPIDevice(spi, cs, baudrate=baudrate)
# Check device version.
version = self.get_version
if _STMPE_VERSION != version:
# If it fails try SPI MODE 1 -- that is what Arduino does
self._spi = spidev.SPIDevice(spi,
cs,
baudrate=baudrate,
polarity=0,
phase=1)
version = self.get_version
if _STMPE_VERSION != version:
raise RuntimeError(
"Failed to find STMPE610 controller! Chip Version 0x%x. "
"If you are using the breakout, verify you are in SPI mode."
% version)
super().__init__()
def __init__(self, spi, cs, reset, frequency, *, sync_word=b'\x2D\xD4',
preamble_length=4, encryption_key=None, high_power=True, baudrate=5000000):
self._tx_power = 13
self.high_power = high_power
# Device support SPI mode 0 (polarity & phase = 0) up to a max of 10mhz.
self._device = spidev.SPIDevice(spi, cs, baudrate=baudrate,
polarity=0, phase=0)
# Setup reset as a digital output that's low.
self._reset = reset
self._reset.switch_to_output(value=False)
# Reset the chip.
self.reset()
# Check the version of the chip.
version = self._read_u8(_REG_VERSION)
if version != 0x24:
raise RuntimeError('Failed to find RFM69 with expected version, check wiring!')
# Enter idle state.
self.idle()
# Setup the chip in a similar way to the RadioHead RFM69 library.
# Set FIFO TX condition to not empty and the default FIFO threshold
# to 15.
self._write_u8(_REG_FIFO_THRESH, 0b10001111)
# Configure low beta off.
self._write_u8(_REG_TEST_DAGC, 0x30)
# Disable boost.
self._write_u8(_REG_TEST_PA1, _TEST_PA1_NORMAL)
self._write_u8(_REG_TEST_PA2, _TEST_PA2_NORMAL)
# Set the syncronization word.
self.sync_word = sync_word
# Configure modulation for RadioHead library GFSK_Rb250Fd250 mode
# by default. Users with advanced knowledge can manually reconfigure
# for any other mode (consulting the datasheet is absolutely
# necessary!).
self.data_mode = 0b00 # Packet mode
self.modulation_type = 0b00 # FSK modulation
self.modulation_shaping = 0b01 # Gaussian filter, BT=1.0
self.bitrate = 250000 # 250kbs
self.frequency_deviation = 250000 # 250khz
self.rx_bw_dcc_freq = 0b111 # RxBw register = 0xE0
self.rx_bw_mantissa = 0b00
self.rx_bw_exponent = 0b000
self.afc_bw_dcc_freq = 0b111 # AfcBw register = 0xE0
self.afc_bw_mantissa = 0b00
self.afc_bw_exponent = 0b000
self.packet_format = 1 # Variable length.
self.dc_free = 0b10 # Whitening
self.crc_on = 1 # CRC enabled
self.crc_auto_clear = 0 # Clear FIFO on CRC fail
self.address_filtering = 0b00 # No address filtering
# Set the preamble length.
self.preamble_length = preamble_length
# Set frequency.
self.frequency_mhz = frequency
# Set encryption key.
self.encryption_key = encryption_key
# Set transmit power to 13 dBm, a safe value any module supports.
self.tx_power = 13
def __init__(self, cs_pin, spi):
# Handle hardware SPI
self._spi = spi_device.SPIDevice(spi, cs_pin, baudrate=8000000)
self.spi_device = spi
self.cs_pin = cs_pin
self._buf = bytearray(3)
self._buf[0] = Adafruit_MCP_SRAM.SRAM_WRSR
self._buf[1] = 0x43
with self._spi as spidev:
spidev.write(self._buf, end=2) # pylint: disable=no-member
def __init__(self,
spi_busio,
cs,
rng=L3DS20_RANGE_250DPS,
baudrate=100000):
import adafruit_bus_device.spi_device as spi_device
self._spi = spi_device.SPIDevice(spi_busio, cs, baudrate=baudrate)
self._spi_bytearray1 = bytearray(1)
self._spi_bytearray6 = bytearray(6)
super().__init__(rng)
def __init__(self,
spi_bus,
cs_pin,
*,
baudrate: int = 250000,
loopback: bool = False,
silent: bool = False,
auto_restart: bool = False,
debug: bool = False):
"""A common shared-bus protocol.
:param ~busio.SPI spi: The SPI bus used to communicate with the MCP2515
:param ~digitalio.DigitalInOut cs_pin: SPI bus enable pin
:param int baudrate: The bit rate of the bus in Hz, using a 16Mhz crystal. All devices on\
the bus must agree on this value. Defaults to 250000.
:param bool loopback: Receive only packets sent from this device, and send only to this\
device. Requires that `silent` is also set to `True`, but only prevents transmission to\
other devices. Otherwise the send/receive behavior is normal.
:param bool silent: When `True` the controller does not transmit and all messages are\
received, ignoring errors and filters. This mode can be used to “sniff” a CAN bus without\
interfering. Defaults to `False`.
:param bool auto_restart: **Not supported by hardware. An `AttributeError` will be raised\
if `auto_restart` is set to `True`** If `True`, will restart communications after entering\
bus-off state. Defaults to `False`.
:param bool debug: If `True`, will enable printing debug information. Defaults to `False`.
"""
if loopback and not silent:
raise AttributeError("Loopback mode requires silent to be set")
if auto_restart:
raise AttributeError("`auto-restart` is not supported by hardware")
self._auto_restart = auto_restart
self._debug = debug
self._bus_device_obj = spi_device.SPIDevice(spi_bus, cs_pin)
self._cs_pin = cs_pin
self._buffer = bytearray(20)
self._id_buffer = bytearray(4)
self._unread_message_queue = []
self._timer = Timer()
self._tx_buffers = []
self._rx0_overflow = False
self._rx1_overflow = False
self._masks_in_use = []
self._filters_in_use = [[], []]
self._mode = None
self._bus_state = BusState.ERROR_ACTIVE
self._baudrate = baudrate
self._loopback = loopback
self._silent = silent
self._baudrate = baudrate
self._init_buffers()
self.initialize()
def __init__(self,
spi,
cs,
baudrate=100000,
debug=False,
*,
refresh_rate=10):
from adafruit_bus_device import spi_device
self._spi = spi_device.SPIDevice(spi, cs, baudrate=baudrate)
self._debug = debug
super().__init__(refresh_rate=refresh_rate)
def __init__(self, spi, dc, cs, rst=None, width=1, height=1, baudrate=1000000,
polarity=0, phase=0):
self.spi_device = spi_device.SPIDevice(spi, cs, baudrate=baudrate,
polarity=polarity, phase=phase)
self.dc_pin = dc
self.rst = rst
self.dc_pin.switch_to_output(value=0)
if self.rst:
self.rst.switch_to_output(value=0)
self.reset()
super().__init__(width, height)
def __init__(self, width, height, spi, a0, reset, cs, *,
external_vcc=False, baudrate=20000000, polarity=0, phase=0):
self.rate = 10 * 1024 * 1024
a0.switch_to_output(value=0)
self.spi_device = spi_device.SPIDevice(spi, cs, baudrate=baudrate,
polarity=polarity, phase=phase)
self.a0_pin = a0
# self.buffer = bytearray(height * width)
self.buffer = bytearray((height // 8) * width)
framebuffer = framebuf.FrameBuffer1(self.buffer, width, height)
super().__init__(framebuffer, width, height, external_vcc, reset)
def __init__(self, spi, cs, baudrate=1000000):
"""
Check the STMPE610 was found,Default clock rate 1000000 - can be changed with 'baudrate'
"""
import adafruit_bus_device.spi_device as spidev
self._spi = spidev.SPIDevice(spi, cs, baudrate=baudrate)
# Check device version.
version = self.get_version
if _STMPE_VERSION != version:
# if it fails try SPI MODE 1 -- that is what Arduino does
self._spi = spidev.SPIDevice(spi,
cs,
baudrate=baudrate,
polarity=0,
phase=1)
version = self.get_version
if _STMPE_VERSION != version:
raise RuntimeError(
'Failed to find STMPE610! Chip Version 0x%x' % version)
super().__init__()
def __init__(self, spi, cs, baudrate=1320000):
# Create an SPIDevice running at a lower initialization baudrate first.
self._spi = spi_device.SPIDevice(spi,
cs,
baudrate=250000,
extra_clocks=8)
self._cmdbuf = bytearray(6)
self._single_byte = bytearray(1)
# Card is byte addressing, set to 1 if addresses are per block
self._cdv = 512
# initialise the card
self._init_card(cs)
# Create a new SPIDevice with the (probably) higher operating baudrate.
self._spi = spi_device.SPIDevice(spi,
cs,
baudrate=baudrate,
extra_clocks=8)
def __init__(self, spi, cs):
# This is the init baudrate. We create a second device for high speed.
self._spi = spi_device.SPIDevice(spi, cs, baudrate=250000, extra_clocks=8)
self._cmdbuf = bytearray(6)
self._single_byte = bytearray(1)
# Card is byte addressing, set to 1 if addresses are per block
self._cdv = 512
# initialise the card
self._init_card()
def __init__(
self,
bus_device: Union[I2C, SPI],
address: int,
chip_select: Optional[digitalio.DigitalInOut] = None,
baudrate: int = 100000,
) -> None:
if chip_select is None:
self._device = i2c_device.I2CDevice(bus_device, address)
else:
self._device = spi_device.SPIDevice(bus_device,
chip_select,
baudrate=baudrate)
def __init__(self, spi, cs, baudrate=1320000):
# This is the init baudrate.
# We create a second device with the target baudrate after card initialization.
self._spi = spi_device.SPIDevice(spi, cs, baudrate=250000, extra_clocks=8)
self._cmdbuf = bytearray(6)
self._single_byte = bytearray(1)
# Card is byte addressing, set to 1 if addresses are per block
self._cdv = 512
# initialise the card and switch to high speed
self._init_card(baudrate)
def _init_card(self, baudrate):
"""Initialize the card in SPI mode."""
# clock card at least cycles with cs high
self._clock_card(80)
with self._spi as card:
# CMD0: init card; should return _R1_IDLE_STATE (allow 5 attempts)
for _ in range(5):
if self._cmd(card, 0, 0, 0x95) == _R1_IDLE_STATE:
break
else:
raise OSError("no SD card")
# CMD8: determine card version
rb7 = bytearray(4)
r = self._cmd(card, 8, 0x01AA, 0x87, rb7, data_block=False)
if r == _R1_IDLE_STATE:
self._init_card_v2(card)
elif r == (_R1_IDLE_STATE | _R1_ILLEGAL_COMMAND):
self._init_card_v1(card)
else:
raise OSError("couldn't determine SD card version")
# get the number of sectors
# CMD9: response R2 (R1 byte + 16-byte block read)
csd = bytearray(16)
if self._cmd(card, 9, 0, 0xAF, response_buf=csd) != 0:
raise OSError("no response from SD card")
# self.readinto(csd)
csd_version = (csd[0] & 0xC0) >> 6
if csd_version >= 2:
raise OSError("SD card CSD format not supported")
if csd_version == 1:
self._sectors = ((csd[8] << 8 | csd[9]) + 1) * 1024
else:
block_length = 2**(csd[5] & 0xF)
c_size = ((csd[6] & 0x3) << 10) | (csd[7] << 2) | (
(csd[8] & 0xC) >> 6)
mult = 2**(((csd[9] & 0x3) << 1 | (csd[10] & 0x80) >> 7) + 2)
self._sectors = block_length // 512 * mult * (c_size + 1)
# CMD16: set block length to 512 bytes
if self._cmd(card, 16, 512, 0x15) != 0:
raise OSError("can't set 512 block size")
# set to high data rate now that it's initialised
self._spi = spi_device.SPIDevice(self._spi.spi,
self._spi.chip_select,
baudrate=baudrate,
extra_clocks=8)
