from pyb import SPI spi = SPI(1) print(spi) spi = SPI(1, SPI.MASTER) spi = SPI(1, SPI.MASTER, baudrate=500000) spi = SPI(1, SPI.MASTER, 500000, polarity=1, phase=0, bits=8, firstbit=SPI.MSB, ti=False, crc=None) print(spi) spi.init(SPI.SLAVE, phase=1) print(spi) spi.init(SPI.MASTER) spi.send(1, timeout=100) print(spi.recv(1, timeout=100)) print(spi.send_recv(1, timeout=100))
class SpiMaster:
def __init__(self, bus=1, baudrate=328125, polarity=0, phase=0, ss='A4'):
self.ss = Pin(ss, Pin.OUT)
self.ss.high()
self.spi = SPI(bus, SPI.MASTER, baudrate=baudrate, polarity=polarity,
phase=phase)
self.msgbuf = bytearray(32)
self.status = bytearray(4)
def write_status(self, status):
self.ss.low()
self.spi.send(0x01)
self.spi.send(status & 0xFF)
self.spi.send((status >> 8) & 0xFF)
self.spi.send((status >> 16) & 0xFF)
self.spi.send((status >> 24) & 0xFF)
self.ss.high()
def read_status(self):
self.ss.low()
self.spi.send(0x04)
self.spi.recv(self.status)
self.ss.high()
return (
self.status[0] |
(self.status[1] << 8) |
(self.status[2] << 16) |
(self.status[3] << 24)
)
def read_data(self):
self.ss.low()
self.spi.send(0x03)
self.spi.send(0x00)
self.spi.recv(self.msgbuf)
self.ss.high()
return self.msgbuf
def read_msg(self, encoding='utf-8'):
return bytes(self.read_data()).strip('\0').decode(encoding)
def write_data(self, data):
self.msgbuf[:] = data[:32] + b'\0' * (32 - len(data[:32]))
self.ss.low()
self.spi.send(0x02)
self.spi.send(0x00)
self.spi.send(self.msgbuf)
self.ss.high()
class STAccel:
def __init__(self):
self.cs_pin = Pin('PE3', Pin.OUT_PP, Pin.PULL_NONE)
self.cs_pin.high()
self.spi = SPI(1, SPI.MASTER, baudrate=328125, polarity=0, phase=1, bits=8)
self.who_am_i = self.read_id()
if self.who_am_i == LIS302DL_WHO_AM_I_VAL:
self.write_bytes(LIS302DL_CTRL_REG1_ADDR, bytearray([LIS302DL_CONF]))
self.sensitivity = 18
elif self.who_am_i == LIS3DSH_WHO_AM_I_VAL:
self.write_bytes(LIS3DSH_CTRL_REG4_ADDR, bytearray([LIS3DSH_CTRL_REG4_CONF]))
self.write_bytes(LIS3DSH_CTRL_REG5_ADDR, bytearray([LIS3DSH_CTRL_REG5_CONF]))
self.sensitivity = 0.06 * 256
else:
raise Exception('LIS302DL or LIS3DSH accelerometer not present')
def convert_raw_to_g(self, x):
if x & 0x80:
x = x - 256
return x * self.sensitivity / 1000
def read_bytes(self, addr, nbytes):
if nbytes > 1:
addr |= READWRITE_CMD | MULTIPLEBYTE_CMD
else:
addr |= READWRITE_CMD
self.cs_pin.low()
self.spi.send(addr)
#buf = self.spi.send_recv(bytearray(nbytes * [0])) # read data, MSB first
buf = self.spi.recv(nbytes)
self.cs_pin.high()
return buf
def write_bytes(self, addr, buf):
if len(buf) > 1:
addr |= MULTIPLEBYTE_CMD
self.cs_pin.low()
self.spi.send(addr)
for b in buf:
self.spi.send(b)
self.cs_pin.high()
def read_id(self):
return self.read_bytes(WHO_AM_I_ADDR, 1)[0]
def x(self):
return self.convert_raw_to_g(self.read_bytes(OUT_X_ADDR, 1)[0])
def y(self):
return self.convert_raw_to_g(self.read_bytes(OUT_Y_ADDR, 1)[0])
def z(self):
return self.convert_raw_to_g(self.read_bytes(OUT_Z_ADDR, 1)[0])
def xyz(self):
return (self.x(), self.y(), self.z())
class STAccel:
def __init__(self):
self.cs_pin = Pin('PE3', Pin.OUT_PP, Pin.PULL_NONE)
self.cs_pin.high()
self.spi = SPI(1, SPI.MASTER, baudrate=328125, polarity=0, phase=1, bits=8)
self.write_bytes(LIS302DL_CTRL_REG1_ADDR, bytearray([LIS302DL_CONF]))
if self.read_id() != LIS302DL_WHO_AM_I_VAL:
raise Exception('LIS302DL accelerometer not present')
def read_bytes(self, addr, nbytes):
if nbytes > 1:
addr |= READWRITE_CMD | MULTIPLEBYTE_CMD
else:
addr |= READWRITE_CMD
self.cs_pin.low()
self.spi.send(addr)
#buf = self.spi.send_recv(bytearray(nbytes * [0])) # read data, MSB first
buf = self.spi.recv(nbytes)
self.cs_pin.high()
return buf
def write_bytes(self, addr, buf):
if len(buf) > 1:
addr |= MULTIPLEBYTE_CMD
self.cs_pin.low()
self.spi.send(addr)
for b in buf:
self.spi.send(b)
self.cs_pin.high()
def read_id(self):
return self.read_bytes(LIS302DL_WHO_AM_I_ADDR, 1)[0]
def x(self):
return convert_raw_to_g(self.read_bytes(LIS302DL_OUT_X, 1)[0])
def y(self):
return convert_raw_to_g(self.read_bytes(LIS302DL_OUT_Y, 1)[0])
def z(self):
return convert_raw_to_g(self.read_bytes(LIS302DL_OUT_Z, 1)[0])
def xyz(self):
val = self.read_bytes(LIS302DL_OUT_X, 5)
return [convert_raw_to_g(val[0]),
convert_raw_to_g(val[2]),
convert_raw_to_g(val[4])]
class STAccel:
def __init__(self, cs='PE3', spi=1, debug=False):
self._debug = debug
self.cs_pin = Pin(cs, Pin.OUT_PP, Pin.PULL_NONE)
self.cs_pin.high()
self.spi = SPI(spi, SPI.MASTER, baudrate=328125, polarity=0, phase=1,
bits=8)
self.read_id()
# First SPI read always returns 255 --> discard and read ID again
self.who_am_i = self.read_id()
self.debug("Accel-ID: %s" % self.who_am_i)
if self.who_am_i == LIS302DL_WHO_AM_I_VAL:
self.write_bytes(LIS302DL_CTRL_REG1_ADDR, LIS302DL_CONF)
self.sensitivity = 18
elif self.who_am_i == LIS3DSH_WHO_AM_I_VAL:
self.write_bytes(LIS3DSH_CTRL_REG4_ADDR, LIS3DSH_CTRL_REG4_CONF)
self.write_bytes(LIS3DSH_CTRL_REG5_ADDR, LIS3DSH_CTRL_REG5_CONF)
self.sensitivity = 0.06 * 256
else:
msg = 'LIS302DL or LIS3DSH accelerometer not present'
if self._debug:
self.debug(msg)
else:
raise IOError(msg)
def debug(self, *msg):
if self._debug:
print(" ".join(str(m) for m in msg))
def _convert_raw_to_g(self, x):
if x & 0x80:
x -= 256
return x * self.sensitivity / 1000
def read_bytes(self, addr, nbytes):
self.cs_pin.low()
if nbytes > 1:
self.spi.send(addr | READWRITE_CMD | MULTIPLEBYTE_CMD)
else:
self.spi.send(addr | READWRITE_CMD)
# read data, MSB first
buf = self.spi.recv(nbytes)
self.cs_pin.high()
return buf
def write_bytes(self, addr, buf):
if not isinstance(buf, (int, bytes, bytearray)):
buf = bytes(buf)
if not isinstance(buf, int) and len(buf) > 1:
addr |= MULTIPLEBYTE_CMD
self.cs_pin.low()
self.spi.send(addr)
self.spi.send(buf)
self.cs_pin.high()
def read_id(self):
return self.read_bytes(WHO_AM_I_ADDR, 1)[0]
def x(self):
return self._convert_raw_to_g(self.read_bytes(OUT_X_ADDR, 1)[0])
def y(self):
return self._convert_raw_to_g(self.read_bytes(OUT_Y_ADDR, 1)[0])
def z(self):
return self._convert_raw_to_g(self.read_bytes(OUT_Z_ADDR, 1)[0])
def xyz(self):
return (self.x(), self.y(), self.z())
from pyb import SPI
except ImportError:
print("ERROR: not on a Pyboard!")
sys.exit(-1)
# Create a method to normalize the data into degrees Celsius
def normalize_data(data):
temp = data[0] << 8 | data[1]
if temp & 0x0001:
return float('NaN')
temp >>= 2
if temp & 0x2000:
temp -= 16384
return (temp * 0.25)
# Setup the SPI interfaceon the "Y" interface
spi = SPI(2, SPI.MASTER, baudrate=5000000, polarity=0, phase=0)
cs = machine.Pin("Y5", machine.Pin.OUT)
cs.high()
# read from the chip
print("Reading temperature every second.")
print("Press CTRL-C to stop.")
while True:
pyb.delay(1000)
cs.low()
print("Temperature is {0} Celsius.".format(normalize_data(spi.recv(4))))
cs.high()
from pyb import SPI spi = SPI(1) print(spi) spi = SPI(1, SPI.MASTER) spi = SPI(1, SPI.MASTER, baudrate=500000) spi = SPI(1, SPI.MASTER, 500000, polarity=1, phase=0, bits=8, firstbit=SPI.MSB, ti=False, crc=None) print(spi) spi.init(SPI.SLAVE, phase=1) print(spi) spi.init(SPI.MASTER) spi.send(1, timeout=100) print(spi.recv(1, timeout=100)) print(spi.send_recv(1, timeout=100))
class STAccel:
def __init__(self):
self.cs_pin = Pin("PE3", Pin.OUT_PP, Pin.PULL_NONE)
self.cs_pin.high()
self.spi = SPI(1,
SPI.MASTER,
baudrate=328125,
polarity=0,
phase=1,
bits=8)
self.who_am_i = self.read_id()
if self.who_am_i == LIS302DL_WHO_AM_I_VAL:
self.write_bytes(LIS302DL_CTRL_REG1_ADDR,
bytearray([LIS302DL_CONF]))
self.sensitivity = 18
elif self.who_am_i == LIS3DSH_WHO_AM_I_VAL:
self.write_bytes(LIS3DSH_CTRL_REG4_ADDR,
bytearray([LIS3DSH_CTRL_REG4_CONF]))
self.write_bytes(LIS3DSH_CTRL_REG5_ADDR,
bytearray([LIS3DSH_CTRL_REG5_CONF]))
self.sensitivity = 0.06 * 256
else:
raise Exception("LIS302DL or LIS3DSH accelerometer not present")
def convert_raw_to_g(self, x):
if x & 0x80:
x = x - 256
return x * self.sensitivity / 1000
def read_bytes(self, addr, nbytes):
if nbytes > 1:
addr |= READWRITE_CMD | MULTIPLEBYTE_CMD
else:
addr |= READWRITE_CMD
self.cs_pin.low()
self.spi.send(addr)
# buf = self.spi.send_recv(bytearray(nbytes * [0])) # read data, MSB first
buf = self.spi.recv(nbytes)
self.cs_pin.high()
return buf
def write_bytes(self, addr, buf):
if len(buf) > 1:
addr |= MULTIPLEBYTE_CMD
self.cs_pin.low()
self.spi.send(addr)
for b in buf:
self.spi.send(b)
self.cs_pin.high()
def read_id(self):
return self.read_bytes(WHO_AM_I_ADDR, 1)[0]
def x(self):
return self.convert_raw_to_g(self.read_bytes(OUT_X_ADDR, 1)[0])
def y(self):
return self.convert_raw_to_g(self.read_bytes(OUT_Y_ADDR, 1)[0])
def z(self):
return self.convert_raw_to_g(self.read_bytes(OUT_Z_ADDR, 1)[0])
def xyz(self):
return (self.x(), self.y(), self.z())
# main.py -- put your code here!
from pyb import SPI, Pin, LED, delay, UART
push_button = pyb.Pin("PA0", pyb.Pin.IN, pyb.Pin.PULL_DOWN)
uart = UART(2, 115200)
CS = Pin("PE3", Pin.OUT_PP)
SPI_1 = SPI(
1,
SPI.MASTER,
baudrate=50000,
polarity=0,
phase=0,
)
CS.low()
SPI_1.send(0x0F | 0x80)
tab_values = SPI_1.recv(1)
CS.high()
value = tab_values[0]
while True:
uart.write(value)
from pyb import SPI
spi = SPI(1, SPI.MASTER, baudrate=200000, polarity=1, phase=0)
spi.send('hello')
spi.recv(5) # receive 5 bytes on the bus
spi.send_recv('hello') # send and receive 5 bytes
class SPIFlash:
""" MicroPython for SPI Flash.
Parameters
----------
nss : (str) CS pin.
bus : (int) 1 -> The physical pins of the SPI busses
1 : (NSS, SCK, MISO, MOSI) = (X5, X6, X7, X8) = (PA4, PA5, PA6, PA7)
2 : (NSS, SCK, MISO, MOSI) = (Y5, Y6, Y7, Y8) = (PB12, PB13, PB14, PB15)
mode : SPI.MASTER or SPI.SLAVE.
baudrate : (int) default=42000000
Returns
-------
None
Examples
--------
>>> import spiflash
>>> flash = spiflash.SPIFlash()
"""
def __init__(self, nss='A4', bus=1, mode=SPI.MASTER, baudrate=42000000):
self.__nss = pyb.Pin(nss)
self.__nss.init(pyb.Pin.OUT_PP)
self.__nss.high()
self.spi = SPI(bus, mode, baudrate=baudrate, polarity=0, phase=0)
self.__device_id = self.read_id()
def __generic_command(self, cmd):
self.__nss.low()
self.spi.send(cmd)
self.__nss.high()
def __write_enable(self):
self.__generic_command(__SFLASH_WRITE_ENABLE)
self.__read_status_register()
def __read_status_register(self):
""" Status Register bit definitions
STATUS_REGISTER_BUSY 0x01
STATUS_REGISTER_WRITE_ENABLED 0x02
STATUS_REGISTER_BLOCK_PROTECTED_0 0x04
STATUS_REGISTER_BLOCK_PROTECTED_1 0x08
STATUS_REGISTER_BLOCK_PROTECTED_2 0x10 [SST & Macronix Only]
STATUS_REGISTER_BLOCK_PROTECTED_3 0x20 [SST & Macronix Only]
STATUS_REGISTER_AUTO_ADDRESS_INCREMENT 0x40 [SST Only]
STATUS_REGISTER_BLOCK_PROTECT_BITS_READ_ONLY 0x80 [SST Only]
STATUS_REGISTER_QUAD_ENABLE 0x40 [Macronix Only]
STATUS_REGISTER_WRITE_PROTECT_PIN_ENABLE 0x80 [Macronix Only]
"""
buf = bytearray(1)
self.__nss.low()
self.spi.send_recv(__SFLASH_READ_STATUS_REGISTER, buf)
self.__nss.high()
# print('__read_status_register: %s'%ubinascii.hexlify(buf).decode('UTF-8').upper())
return buf[0]
def read_id(self):
""" Read SPI Flash ID. """
self.wait()
self.__nss.low()
self.spi.send(__SFLASH_READ_JEDEC_ID)
ret = self.spi.recv(3)
self.__nss.high()
return ubinascii.hexlify(ret).decode('UTF-8').upper()
def wait(self, timeout=0):
""" Wait. """
while timeout < 1000:
if self.__read_status_register() == 0:
return True
else:
timeout += 1
return False
def sector_erase(self, addr):
""" Sector Erase. """
self.__write_enable()
self.__nss.low()
self.spi.send(__SFLASH_SECTOR_ERASE)
self.spi.send(bytearray([(addr&0x00FF0000)>>16, (addr&0x0000FF00)>>8, addr&0x000000FF]))
self.__nss.high()
return self.__read_status_register()
def chip_erase(self):
""" Chip Erase. """
self.__write_enable()
self.__generic_command(__SFLASH_CHIP_ERASE2)
return self.__read_status_register()
def write(self, addr, buf):
""" Write data to flash. """
pos = 0
write_size = len(buf)
max_write_size = self.page_size()
while pos < write_size:
size = min(write_size-pos, max_write_size)
self.__write_enable()
self.__nss.low()
self.spi.send(__SFLASH_WRITE)
self.spi.send(bytearray([(addr&0x00FF0000)>>16, (addr&0x0000FF00)>>8, addr&0x000000FF]))
self.spi.send(buf[pos:pos+size])
self.__nss.high()
self.wait()
addr += size
pos += size
return True
def read(self, addr, size):
""" Read data from flash. """
self.__nss.low()
self.spi.send(__SFLASH_READ)
self.spi.send(bytearray([(addr&0x00FF0000)>>16, (addr&0x0000FF00)>>8, addr&0x000000FF]))
ret = self.spi.recv(size)
self.__nss.high()
return ret
def chip_size(self):
""" Get flash size. """
try:
return SFLASH_ID_SIZE[self.__device_id]
except KeyError:
return 0
def page_size(self):
""" Read Page Size.
Parameters
----------
Returns
-------
Flash page size.
Examples
--------
>>> spi.page_size()
128
"""
# Some manufacturers support programming an entire page in one command.
try:
return SFLASH_PAGE_SIZE[self.__device_id[:2]]
except KeyError:
return 1
