Serial Peripheral Interface (SPI) is a synchronous communication protocol used to enable communication between the raspberry pi and slave peripherals. SPI uses a synchronous serial bus, which means that data is sent synchronously with a common clock between master and slaves.
The SPI bus consists of four main lines:
The image above shows two squares: blue and green. The blue square corresponds to the wires you’ll need to connect to talk to your peripheral. The green square corresponds to the two chip select pins that allow you to connect two different components to the SPI. You must connect a component to only one of these two pins. As a reminder, CEO corresponds to SPI spidev0.0 and CE1 to spidev0.1.
You can also use other GPIOs like chip select if you want to use more components on the SPI. In this case, you’ll need to define the pin yourself, following the timeline indicated in the datasheet for the component you wish to control.
The first step is to install the spi-tools library:
sudo apt-get install spi-toolsWe will now activate the spi in the raspi-config menu:
sudo raspi-configThis is the raspi-config menu. Next, click on Interface Options :
In Interface Options, we can see the SPI line, which we will click on:
We are asked to activate the SPI. We click on yes:
We are then presented with a page indicating that the SPI has been activated:
By typing the line ls -l /dev/spi* we can see that both SPIs have been activated:
We’ll see how to send information and read through the SPI.
Here’s an example of SPI reading for the RFID-RC522 component connected to the CE0 select chip. This program is easily adaptable to other components:
#include <stdio.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>
#define SPI_DEVICE "/dev/spidev0.0" // The SPI device to use
void transfer(int fd, uint8_t *tx, uint8_t *rx, size_t len) {
struct spi_ioc_transfer transfer = {
.tx_buf = (unsigned long)tx,
.rx_buf = (unsigned long)rx,
.len = len,
.delay_usecs = 0,
.speed_hz = 1000000, // SPI communication speed in Hz
.bits_per_word = 8,
};
ioctl(fd, SPI_IOC_MESSAGE(1), &transfer);
}
int main() {
int spi_fd;
// Ouvrir le périphérique SPI
spi_fd = open(SPI_DEVICE, O_RDWR);
if (spi_fd < 0) {
perror("Error opening SPI device");
return 1;
}
uint8_t tx_buffer[2] = {0x80 | 0x09, 0x00}; // Adresse du registre à lire (0x80 pour lecture)
uint8_t rx_buffer[4] = {0};
transfer(spi_fd, tx_buffer, rx_buffer, sizeof(tx_buffer));
// Displaying read data
printf("Data read from the RC522 FIFO register: ");
for (int i = 0; i < sizeof(rx_buffer); i++) {
printf("%02X ", rx_buffer[i]);
}
printf("\n");
// Close SPI device
close(spi_fd);
return 0;
}
Here’s a program to send two numbers 125 and 34 over the SPI to chip select CE0 :
#include <stdio.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>
#define SPI_DEVICE "/dev/spidev0.0" // The SPI device to use
void transfer(int fd, uint8_t *tx, uint8_t *rx, size_t len) {
struct spi_ioc_transfer transfer = {
.tx_buf = (unsigned long)tx,
.rx_buf = (unsigned long)rx,
.len = len,
.delay_usecs = 0,
.speed_hz = 1000000, // SPI communication speed in Hz
.bits_per_word = 8,
};
ioctl(fd, SPI_IOC_MESSAGE(1), &transfer);
}
int main() {
int spi_fd;
// Open SPI device
spi_fd = open(SPI_DEVICE, O_RDWR);
if (spi_fd < 0) {
perror("Error opening SPI device");
return 1;
}
// Example of reading an RC522 register
uint8_t tx_buffer[2] = {0x80 | 0x09, 0x00}; // Address of register to be read (0x80 for reading)
uint8_t rx_buffer[4] = {0};
transfer(spi_fd, tx_buffer, rx_buffer, sizeof(tx_buffer));
// Display of read data
printf("Data read from the RC522 FIFO register: ");
for (int i = 0; i < sizeof(rx_buffer); i++) {
printf("%02X ", rx_buffer[i]);
}
printf("\n");
// Close SPI device
close(spi_fd);
return 0;
}
Here’s the program test showing the MOSI and clock on the oscilloscope: