Raspberry Pi + Arduino + SPI

This tutorial will show you how to communicate from your raspberry pi to your arduino using 3-wire SPI.

Requirements

• 1 Raspberry pi (running Raspbian)
• 1 Arduino
• 4 wires

Your raspberry pi should be running the newest version of Raspbian.  To ensure your system is up-to-date please download and run rpi-update.

wire :

• SS – digital 10. You can use other digital pins, but 10 is generally the default as it is next to the other SPI pins;
• MOSI – digital 11;
• MISO – digital 12;
• SCK – digital 13;

Arduino Mega users – MISO is 50, MOSI is 51, SCK is 52 and SS is usually 53. If you are using an Arduino Leonardo, the SPI pins are on the ICSP header pins. See here for more information. You can control one or more devices with the SPI bus. For example, for one device the wiring would be:

Arduino

Open your Arduino ide and flash the below code to your Arduino.

Arduino code

	// Written by Nick Gammon
	// February 2011
	/**
	* Send arbitrary number of bits at whatever clock rate (tested at 500 KHZ and 500 HZ).
	* This script will capture the SPI bytes, when a '\n' is recieved it will then output
	* the captured byte stream via the serial.
	*/
	#include <SPI.h>
	char buf [100];
	volatile byte pos;
	volatile boolean process_it;
	void setup (void)
	{
	Serial.begin (115200); // debugging
	// have to send on master in, *slave out*
	pinMode(MISO, OUTPUT);
	// turn on SPI in slave mode
	SPCR |= _BV(SPE);
	// get ready for an interrupt
	pos = 0; // buffer empty
	process_it = false;
	// now turn on interrupts
	SPI.attachInterrupt();
	} // end of setup
	// SPI interrupt routine
	ISR (SPI_STC_vect)
	{
	byte c = SPDR; // grab byte from SPI Data Register
	// add to buffer if room
	if (pos < sizeof buf)
	{
	buf [pos++] = c;
	// example: newline means time to process buffer
	if (c == '\n')
	process_it = true;
	} // end of room available
	} // end of interrupt routine SPI_STC_vect
	// main loop - wait for flag set in interrupt routine
	void loop (void)
	{
	if (process_it)
	{
	buf [pos] = 0;
	Serial.println (buf);
	pos = 0;
	process_it = false;
	} // end of flag set
	} // end of loop

view rawarduino_spi_slave.pde hosted with  by GitHub

Raspberry Pi

With your updated rasbian system you should have the drivers that you need. Now it’s time to load them.

modprobe spi_bcm2708
modprobe spidev

Check to be sure the modules loaded:

lsmod
Module Size Used by
spidev 5944 0
spi_bcm2708 5350 0
snd_bcm2835 21681 0
snd_pcm 81170 1 snd_bcm2835
snd_seq 59528 0
snd_timer 21602 2 snd_seq,snd_pcm
snd_seq_device 6924 1 snd_seq
snd 57427 5 snd_seq_device,snd_timer,snd_seq,snd_pcm,snd_bcm2835
snd_page_alloc 5343 1 snd_pcm
i2c_bcm2708 3822 0

Raspberry Pi Code

Save the below code as spidev_test.c on to your Raspberry Pi and compile it

gcc spidev_test.c -o spidev_test

	/*
	* SPI testing utility (using spidev driver)
	*
	* Copyright (c) 2007 MontaVista Software, Inc.
	* Copyright (c) 2007 Anton Vorontsov <avorontsov@ru.mvista.com>
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License.
	*
	* Cross-compile with cross-gcc -I/path/to/cross-kernel/include
	*/
	#include <stdint.h>
	#include <unistd.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <getopt.h>
	#include <fcntl.h>
	#include <sys/ioctl.h>
	#include <linux/types.h>
	#include <linux/spi/spidev.h>
	#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
	static void pabort(const char *s)
	{
	perror(s);
	abort();
	}
	static const char *device = "/dev/spidev0.0";
	static uint8_t mode;
	static uint8_t bits = 8;
	static uint32_t speed = 500000;
	static uint16_t delay;
	static void transfer(int fd)
	{
	int ret;
	uint8_t tx[] = {
	0x48, 0x45, 0x4C, 0x4C, 0x4F,
	0x20,
	0x57, 0x4F, 0x52, 0x4C, 0x44,
	0x0A
	};
	uint8_t rx[ARRAY_SIZE(tx)] = {0, };
	struct spi_ioc_transfer tr = {
	.tx_buf = (unsigned long)tx,
	.rx_buf = (unsigned long)rx,
	.len = ARRAY_SIZE(tx),
	.delay_usecs = delay,
	.speed_hz = speed,
	.bits_per_word = bits,
	};
	ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
	if (ret < 1)
	pabort("can't send spi message");
	/*
	for (ret = 0; ret < ARRAY_SIZE(tx); ret++) {
	if (!(ret % 6))
	puts("");
	printf("%.2X ", rx[ret]);
	}
	puts("");
	*/
	}
	static void print_usage(const char *prog)
	{
	printf("Usage: %s [-DsbdlHOLC3]\n", prog);
	puts(" -D --device device to use (default /dev/spidev1.1)\n"
	" -s --speed max speed (Hz)\n"
	" -d --delay delay (usec)\n"
	" -b --bpw bits per word \n"
	" -l --loop loopback\n"
	" -H --cpha clock phase\n"
	" -O --cpol clock polarity\n"
	" -L --lsb least significant bit first\n"
	" -C --cs-high chip select active high\n"
	" -3 --3wire SI/SO signals shared\n");
	exit(1);
	}
	static void parse_opts(int argc, char *argv[])
	{
	while (1) {
	static const struct option lopts[] = {
	{ "device", 1, 0, 'D' },
	{ "speed", 1, 0, 's' },
	{ "delay", 1, 0, 'd' },
	{ "bpw", 1, 0, 'b' },
	{ "loop", 0, 0, 'l' },
	{ "cpha", 0, 0, 'H' },
	{ "cpol", 0, 0, 'O' },
	{ "lsb", 0, 0, 'L' },
	{ "cs-high", 0, 0, 'C' },
	{ "3wire", 0, 0, '3' },
	{ "no-cs", 0, 0, 'N' },
	{ "ready", 0, 0, 'R' },
	{ NULL, 0, 0, 0 },
	};
	int c;
	c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", lopts, NULL);
	if (c == -1)
	break;
	switch (c) {
	case 'D':
	device = optarg;
	break;
	case 's':
	speed = atoi(optarg);
	break;
	case 'd':
	delay = atoi(optarg);
	break;
	case 'b':
	bits = atoi(optarg);
	break;
	case 'l':
	mode |= SPI_LOOP;
	break;
	case 'H':
	mode |= SPI_CPHA;
	break;
	case 'O':
	mode |= SPI_CPOL;
	break;
	case 'L':
	mode |= SPI_LSB_FIRST;
	break;
	case 'C':
	mode |= SPI_CS_HIGH;
	break;
	case '3':
	mode |= SPI_3WIRE;
	break;
	case 'N':
	mode |= SPI_NO_CS;
	break;
	case 'R':
	mode |= SPI_READY;
	break;
	default:
	print_usage(argv[0]);
	break;
	}
	}
	}
	int main(int argc, char *argv[])
	{
	int ret = 0;
	int fd;
	parse_opts(argc, argv);
	fd = open(device, O_RDWR);
	if (fd < 0)
	pabort("can't open device");
	/*
	* spi mode
	*/
	ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
	if (ret == -1)
	pabort("can't set spi mode");
	ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
	if (ret == -1)
	pabort("can't get spi mode");
	/*
	* bits per word
	*/
	ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
	if (ret == -1)
	pabort("can't set bits per word");
	ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
	if (ret == -1)
	pabort("can't get bits per word");
	/*
	* max speed hz
	*/
	ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
	if (ret == -1)
	pabort("can't set max speed hz");
	ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
	if (ret == -1)
	pabort("can't get max speed hz");
	printf("spi mode: %d\n", mode);
	printf("bits per word: %d\n", bits);
	printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);
	transfer(fd);
	close(fd);
	return ret;
	}

Reference : http://mitchtech.net/raspberry-pi-arduino-spi/

Reference : http://tronixstuff.com/2011/05/13/tutorial-arduino-and-the-spi-bus/