LABORATORIO DI ARCHITETTURE E PROGRAMMAZIONE DEI SISTEMI ELETTRONICI INDUSTRIALI. Laboratory Lesson 9: Serial Peripheral Interface (SPI)

Transcription

1 LABORATORIO DI ARCHITETTURE E PROGRAMMAZIONE DEI SISTEMI ELETTRONICI INDUSTRIALI Laboratory Lesson 9: Serial Peripheral Interface (SPI) Prof. Luca Benini <luca.benini@unibo.it> Prof Davide Rossi <davide.rossi@unibo.it> Simone Benatti <simone.benatti@unibo.it> Victor Kartsch<victorjavier.kartsch@unibo.it>

2 Info & Communications

3 Recap LAB1: IDE & Debug LAB2: GPIO & Systick LAB3: Advanced Debug LAB4: EXTI LAB5: Timers LAB6: FLASH & DMA LAB7: USART LAB8: ADC LAB9: SPI SPI: init and read data from Accelerometer

4 Serial Peripheral Interface (SPI)

5 Serial Peripheral Interface (SPI) Serial Bus protocol Fast, Easy to use, Simple Everyone supports it

6 SPI characteristics A 4-wire communication bus Typically communicate across short distances (chips on PCB or boards in device) Supports Single master Multiple slaves Synchronized Communications are clocked Always full-duplex Communicates in both directions simultaneously Transmitted (or received) data may not be meaningful Multiple Mbps transmission speeds 0-50 MHz clock speeds not uncommon Transfer data in 8 to 16 bit characters

7 SPI bus wiring Bus wires Master-Out, Slave-In (MOSI) or SDO (Serial Port Data Output) Master-In, Slave-Out (MISO) or SDI (Serial Port Data Input) System Clock (SCLK) Slave Select/Chip Select (SS or CS) Master controls slave/chip select line (usually as GPIO) Master generates clock signal Shift registers shift data in and out

8 SPI signal functions MOSI carries data out of master to slave MISO carries data out of slave to master Both MOSI and MISO are active during every transmission In 3-wire mode MOSI and MISO are just one shared line SS (or CS) unique line to select each slave chip Usually active low SCLK produced by master to synchronize transfers

9 SPI communication model Master shifts out data to Slave, and shifts in data from Slave For every transmission data is shifted both ways Write: master writes desired data and ignores what comes in Read: master writes dummy data (e.g.0x00) to generate clock and reads incoming data

10 SPI communication model

11 SPI configuration models Parallel connection Daisy-chain connection

12 STM32 SPI

13 STM32 SPI features Full-duplex synchronous transfers on three lines Simplex synchronous transfers on two lines with or without a bidirectional data line. Master or slave operation, with multi-master capability 8- or 16-bit transfer frame format selection NSS management by hardware or software for both master and slave: dynamic change of master/slave operations Programmable clock polarity and phase Programmable data order with MSB-first or LSB-first shifting Dedicated transmission and reception flags with interrupt capability SPI bus busy status flag Hardware CRC feature for reliable communication Master mode fault, overrun and CRC error flags with interrupt capability 1-byte transmission and reception buffer with DMA capability for TX and RX requests

14 STM32 SPI Block diagram

15 LIS3DSH: MEMS Accelerometer

16 ST LIS3DSH The LIS3DSH is an ultra-compact low-power 3D digital linear accelerometer belonging to the nano family. 3 acceleration channels ±2g/±4g/±6g/±8g/±16g linear acceleration full scale 16-bit data output I2C/SPI serial interface Analog supply voltage 1.7 V to 3.6 V Power-down mode / low-power mode 2 independent programmable interrupt generators activated by user-generated motion patterns Info & data sheet:

17 ST LIS3DSH Block Diagram

18 ST LIS3DSH Block Diagram MEMS sensing and conditioning Internal ADC FSM and FIFIO I2C/SPI interface IRQ lines Digital control

19 Sensor connection Data sheet application suggestion and board schematic

20 How do I use the sensor? Use SPI communication to read/write sensor s internal registers Control registers for configuration, data registers for acquired signals Beside the communication via SPI it s as an additional external peripheral: First configure its registers to set the desired operation mode Then read data from internal data register To read/write a register follow the procedure on the datasheet The general procedure is: Master selects the device (sets CS low) Master sends desired register s address specifying read or write If read: master sends dummy data and gets value to read If write: master sends data to write and discards what comes in Master de-selects the device (sets CS high)

21 LIS3DSH SPI read and write protocol Set CS (NSS) low for the slave, then send address, then read/write data. Both the Read Register and Write Register commands are completed in 16 clock pulses (8 addr + 8 data) or in multiples of 8 in case of multiple bytes read/write (8 addr + N*8 data).

22 LIS3DSH SPI read and write protocol Bit 0: RW bit. When 0, the data DI(7:0) is written to the device. When 1, the data DO(7:0) is read from the device. In the latter case, the chip will drive SDO at the start of bit 8. Bit 1: MS bit. When 0, the address remains unchanged in multiple read/write commands. When 1, the address will be auto-incremented in multiple read/write commands. Bit 2-7: address AD(5:0). This is the address of the indexed register. Bit 8-15: data DI(7:0) (write mode). This is the data that will be written to the device (MSb first). Bit 8-15: data DO(7:0) (read mode). This is the data that will be read from the device (MSb first). In multiple read/write commands, further blocks of 8 clock periods will be added. When the MS bit is 0, the address used to read/write data remains the same for every block. When the MS bit is 1, the address used to read/write data is incremented at every block. The function and the behavior of SDI and SDO remain unchanged.

23 Which register do I write? Look at the sensor datasheet:

24 Control registers Example: CTRL_REG4 (Address: 0x20) select the Output Data Rate (ODR), enable/disable block data update and enable/disable each of the 3 accelerometer axis Read = current configuration, Write = set new configuration

25 Data registers Data registers contain the sampled signals converted to digital values. 16bit integer values stored in 2 8bit registers (L = LSB, H = MSB) According to settings and ODR, you must be careful to read the registers after the data has been updated to avoid reading old or corrupted values Block Data Update can prevent the update of data regiters before reading the current values Read = current configuration, NO Write (read only!)

26 How? Q. So I have to look at each register, write its address and the meaning of the bits? A. NO! we have a library! Download the provided files and copy them in the Utilities folder of your project: old version of the DISCOVERY board had a different sensor (LIS302DL): use the correct one! to use library remember to add: #include stm32f401_discovery_lis3dsh.h" Same structure as for internal peripherals: File.c/.h for the sensor Pins definitions Register addresses and fields defines Data structures for configuration Functions for main tasks

27 Some functions LIS3DSH_Init as usual needs a structure with the desired configuration It calls LIS3DSH_LowLevel_Init() which configures the GPIO and the SPI It writes the desired parameters in the control registers LIS3DSH_ReadAcc_Raw reads the 8bit data registers and combines them in 16 bit variables

28 Code example

29 What to do? We want to read accelerometer data at 25 Hz. You can check the values from the debugger or you can stream the data to a PC via USART or USB (see provided templates) Tasks: Configure LEDs, SysTick (as before ) Configure and initialize SPI peripheral (GPIOs, configuration) Set the sensor s internal register for initial configuration (write control registers) Periodically read output from sensor s internal register (read data registers) Reconstruct data (two 8 bit registers must be stored in a 16 bit variable) (optional) Send result via USART or USB to the PC

30 GPIO and SPI initialization void LIS3DSH_LowLevel_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; SPI_InitTypeDef SPI_InitStructure; /* Enable the SPI periph */ RCC_APB2PeriphClockCmd(LIS3DSH_SPI_CLK, ENABLE); /* Enable SCK, MOSI and MISO GPIO clocks */ RCC_AHB1PeriphClockCmd(LIS3DSH_SPI_SCK_GPIO_CLK, ENABLE); /* Enable CS GPIO clock */ RCC_AHB1PeriphClockCmd(LIS3DSH_SPI_CS_GPIO_CLK, ENABLE); Enable the clocks for all the used peripherals and pins. /* Enable INT1 GPIO clock */ RCC_AHB1PeriphClockCmd(LIS3DSH_SPI_INT1_GPIO_CLK, ENABLE); /* Enable INT2 GPIO clock */ RCC_AHB1PeriphClockCmd(LIS3DSH_SPI_INT2_GPIO_CLK, ENABLE);...

31 GPIO and SPI initialization... GPIO_PinAFConfig(LIS3DSH_SPI_SCK_GPIO_PORT, LIS3DSH_SPI_SCK_SOURCE, LIS3DSH_SPI_SCK_AF); GPIO_PinAFConfig(LIS3DSH_SPI_MISO_GPIO_PORT, LIS3DSH_SPI_MISO_SOURCE, LIS3DSH_SPI_MISO_AF); GPIO_PinAFConfig(LIS3DSH_SPI_MOSI_GPIO_PORT, LIS3DSH_SPI_MOSI_SOURCE, LIS3DSH_SPI_MOSI_AF); GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; Config the SPI pins (SCK, MISO and MOSI) as alternate function /* SPI SCK pin configuration */ GPIO_InitStructure.GPIO_Pin = LIS3DSH_SPI_SCK_PIN; GPIO_Init(LIS3DSH_SPI_SCK_GPIO_PORT, &GPIO_InitStructure); /* SPI MOSI pin configuration */ GPIO_InitStructure.GPIO_Pin = LIS3DSH_SPI_MOSI_PIN; GPIO_Init(LIS3DSH_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure); /* SPI MISO pin configuration */ GPIO_InitStructure.GPIO_Pin = LIS3DSH_SPI_MISO_PIN; GPIO_Init(LIS3DSH_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);...

32 GPIO and SPI initialization... GPIO_PinAFConfig(LIS3DSH_SPI_SCK_GPIO_PORT, LIS3DSH_SPI_SCK_SOURCE, LIS3DSH_SPI_SCK_AF); GPIO_PinAFConfig(LIS3DSH_SPI_MISO_GPIO_PORT, LIS3DSH_SPI_MISO_SOURCE, LIS3DSH_SPI_MISO_AF); GPIO_PinAFConfig(LIS3DSH_SPI_MOSI_GPIO_PORT, LIS3DSH_SPI_MOSI_SOURCE, LIS3DSH_SPI_MOSI_AF); GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; /* SPI SCK pin configuration */ GPIO_InitStructure.GPIO_Pin = LIS3DSH_SPI_SCK_PIN; GPIO_Init(LIS3DSH_SPI_SCK_GPIO_PORT, &GPIO_InitStructure); /* SPI MOSI pin configuration */ GPIO_InitStructure.GPIO_Pin = LIS3DSH_SPI_MOSI_PIN; GPIO_Init(LIS3DSH_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure); /* SPI MISO pin configuration */ GPIO_InitStructure.GPIO_Pin = LIS3DSH_SPI_MISO_PIN; GPIO_Init(LIS3DSH_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);... All the needed pins are defined in the library (look in the.h file) to facilitate code development and re-use! Example: #define LIS3DSH_SPI_SCK_PIN GPIO_Pin_5

33 GPIO and SPI initialization... /* SPI configuration */ SPI_I2S_DeInit(LIS3DSH_SPI); SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4; SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; SPI_InitStructure.SPI_CRCPolynomial = 7; SPI_InitStructure.SPI_Mode = SPI_Mode_Master; SPI_Init(LIS3DSH_SPI, &SPI_InitStructure); /* Enable SPI1 */ SPI_Cmd(LIS3DSH_SPI, ENABLE);... Usual peripheral initialization: Reset the SPI, set the desired configuration parameters and enable it.

34 GPIO and SPI initialization... /* Configure GPIO PIN for Chip select */ GPIO_InitStructure.GPIO_Pin = LIS3DSH_SPI_CS_PIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(LIS3DSH_SPI_CS_GPIO_PORT, &GPIO_InitStructure); /* Deselect : Chip Select high */ GPIO_SetBits(LIS3DSH_SPI_CS_GPIO_PORT, LIS3DSH_SPI_CS_PIN); } Configure Chip Select (CS) pin. It is used as GPIO and it is active low: it is high and should be Reset (low) when writing/reading.

35 Accelerometer Config void Acc_Config(void) { LIS3DSH_InitTypeDef AccInitStruct; Same configuration paradigm as for internal peripherals AccInitStruct.Output_DataRate = LIS3DSH_DATARATE_50; AccInitStruct.Axes_Enable = LIS3DSH_XYZ_ENABLE; AccInitStruct.SPI_Wire = LIS3DSH_SERIALINTERFACE_4WIRE; AccInitStruct.Self_Test = LIS3DSH_SELFTEST_NORMAL; AccInitStruct.Full_Scale = LIS3DSH_FULLSCALE_2; AccInitStruct.Filter_BW = LIS3DSH_FILTER_BW_800; LIS3DSH_Init(&AccInitStruct); }

36 Accelerometer Config void Acc_Config(void) { LIS3DSH_InitTypeDef AccInitStruct; AccInitStruct.Output_DataRate = LIS3DSH_DATARATE_50; AccInitStruct.Axes_Enable = LIS3DSH_XYZ_ENABLE; AccInitStruct.SPI_Wire = LIS3DSH_SERIALINTERFACE_4WIRE; AccInitStruct.Self_Test = LIS3DSH_SELFTEST_NORMAL; AccInitStruct.Full_Scale = LIS3DSH_FULLSCALE_2; AccInitStruct.Filter_BW = LIS3DSH_FILTER_BW_800; Data Output Rate 50Hz This has to be set according to the desired sampling rate (possibly higher) LIS3DSH_Init(&AccInitStruct); }

37 Accelerometer Config void Acc_Config(void) { LIS3DSH_InitTypeDef AccInitStruct; AccInitStruct.Output_DataRate = LIS3DSH_DATARATE_50; AccInitStruct.Axes_Enable = LIS3DSH_XYZ_ENABLE; AccInitStruct.SPI_Wire = LIS3DSH_SERIALINTERFACE_4WIRE; AccInitStruct.Self_Test = LIS3DSH_SELFTEST_NORMAL; AccInitStruct.Full_Scale = LIS3DSH_FULLSCALE_2; AccInitStruct.Filter_BW = LIS3DSH_FILTER_BW_800; Enable all 3 axes LIS3DSH_Init(&AccInitStruct); }

38 Accelerometer Config void Acc_Config(void) { LIS3DSH_InitTypeDef AccInitStruct; AccInitStruct.Output_DataRate = LIS3DSH_DATARATE_50; AccInitStruct.Axes_Enable = LIS3DSH_XYZ_ENABLE; AccInitStruct.SPI_Wire = LIS3DSH_SERIALINTERFACE_4WIRE; AccInitStruct.Self_Test = LIS3DSH_SELFTEST_NORMAL; AccInitStruct.Full_Scale = LIS3DSH_FULLSCALE_2; AccInitStruct.Filter_BW = LIS3DSH_FILTER_BW_800; Select 4-wire SPI interface LIS3DSH_Init(&AccInitStruct); }

39 Accelerometer Config void Acc_Config(void) { LIS3DSH_InitTypeDef AccInitStruct; AccInitStruct.Output_DataRate = LIS3DSH_DATARATE_50; AccInitStruct.Axes_Enable = LIS3DSH_XYZ_ENABLE; AccInitStruct.SPI_Wire = LIS3DSH_SERIALINTERFACE_4WIRE; AccInitStruct.Self_Test = LIS3DSH_SELFTEST_NORMAL; AccInitStruct.Full_Scale = LIS3DSH_FULLSCALE_2; AccInitStruct.Filter_BW = LIS3DSH_FILTER_BW_800; Perform normal self-test (at sensor init) LIS3DSH_Init(&AccInitStruct); }

40 Accelerometer Config void Acc_Config(void) { LIS3DSH_InitTypeDef AccInitStruct; AccInitStruct.Output_DataRate = LIS3DSH_DATARATE_50; AccInitStruct.Axes_Enable = LIS3DSH_XYZ_ENABLE; AccInitStruct.SPI_Wire = LIS3DSH_SERIALINTERFACE_4WIRE; AccInitStruct.Self_Test = LIS3DSH_SELFTEST_NORMAL; AccInitStruct.Full_Scale = LIS3DSH_FULLSCALE_2; AccInitStruct.Filter_BW = LIS3DSH_FILTER_BW_800; Set Full Scale at ±2g LIS3DSH_Init(&AccInitStruct); }

41 Accelerometer Config void Acc_Config(void) { LIS3DSH_InitTypeDef AccInitStruct; } AccInitStruct.Output_DataRate = LIS3DSH_DATARATE_50; AccInitStruct.Axes_Enable = LIS3DSH_XYZ_ENABLE; AccInitStruct.SPI_Wire = LIS3DSH_SERIALINTERFACE_4WIRE; AccInitStruct.Self_Test = LIS3DSH_SELFTEST_NORMAL; AccInitStruct.Full_Scale = LIS3DSH_FULLSCALE_2; AccInitStruct.Filter_BW = LIS3DSH_FILTER_BW_800; LIS3DSH_Init(&AccInitStruct); Set internal Low Pass Filter at 800Hz

42 Accelerometer Config void Acc_Config(void) { LIS3DSH_InitTypeDef AccInitStruct; } AccInitStruct.Output_DataRate = LIS3DSH_DATARATE_50; AccInitStruct.Axes_Enable = LIS3DSH_XYZ_ENABLE; AccInitStruct.SPI_Wire = LIS3DSH_SERIALINTERFACE_4WIRE; AccInitStruct.Self_Test = LIS3DSH_SELFTEST_NORMAL; AccInitStruct.Full_Scale = LIS3DSH_FULLSCALE_2; AccInitStruct.Filter_BW = LIS3DSH_FILTER_BW_800; LIS3DSH_Init(&AccInitStruct); This function will call the SPI initialization function and then write the selected configuration to the LIS3DSH registers. Check the code!

43 Accelerometer Config void Acc_Config(void) { LIS3DSH_InitTypeDef AccInitStruct; } AccInitStruct.Output_DataRate = LIS3DSH_DATARATE_50; AccInitStruct.Axes_Enable = LIS3DSH_XYZ_ENABLE; AccInitStruct.SPI_Wire = LIS3DSH_SERIALINTERFACE_4WIRE; AccInitStruct.Self_Test = LIS3DSH_SELFTEST_NORMAL; AccInitStruct.Full_Scale = LIS3DSH_FULLSCALE_2; AccInitStruct.Filter_BW = LIS3DSH_FILTER_BW_800; LIS3DSH_Init(&AccInitStruct); This is the minimum configuration. Advanced functionalities include: data filtering, output buffers (FIFO), interrupt generation on various conditions, (look in the datasheet and the code)

44 Sensor data reading Periodically read sensor data: use SysTick to measure period, then read sensor output registers you can also configure the sensor to generate an interrupt (EXTI) when data is ready ensure to set the sensor s output data rate equal or higher than the read rate data is 16 bit signed, but registers are 8 bit: need to shift MSB and add to LSB to reconstruct final value (look in the ReadAcc_Raw function) readbuffer[0] <<8 readbuffer [1] dataout[0] (Acc X)

45 Sensor data reading How can I interpret the numbers I read? It s the same as with the ADC: you are actually reading the value converted by the internal ADC. The full scale sets the range of the acceleration to measure (in our example: ±2g) The resolution is 16bit Do the math and convert the output value in g (or mg). (hint: check the sensor sensitivity in the datasheet and look in the library) Try to change the full scale value and see what happens to the output values. I got the data from the sensor, what does it mean? When still the accelerometer reports -1g on the vertical axis (gravity acceleration) Try to change the orientation of your board

46 Data streaming You can now use the USART or USB to send sensor data to the PC You can use any terminal to read the values or you can plot them (e.g. using Serial Chart)

47 Weekly assignments

48 Exercise 1) Write a program that reads accelerometer data at 25Hz and computes for each axes the mean, maximum and minimum values on 1s data windows. you can stream data to the PC using USART/USB. Use s to start/stop streaming

49 Questions 1. Try to change the Full Scale value of the accelerometer. What happens to the output values? 2. Describe the operations you have to do in order to configure and read data from a sensor interfaced trought the SPI.