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()
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