{"id":3043,"date":"2012-11-02T09:30:22","date_gmt":"2012-11-02T08:30:22","guid":{"rendered":"http:\/\/www.blaess.fr\/christophe\/?p=3043"},"modified":"2017-02-01T19:40:51","modified_gmt":"2017-02-01T18:40:51","slug":"spi-sur-raspberry-pi-1","status":"publish","type":"post","link":"https:\/\/www.blaess.fr\/christophe\/2012\/11\/02\/spi-sur-raspberry-pi-1\/","title":{"rendered":"SPI sur Raspberry Pi – 1"},"content":{"rendered":"

\"SPI<\/a>La communication par lien SPI (Serial Peripheral Interface<\/em><\/a>) est un \u00e9l\u00e9ment important pour les syst\u00e8mes embarqu\u00e9s. Ceci concerne les micro-contr\u00f4leurs (syst\u00e8mes industriels par exemple), mais \u00e9galement les cartes \u00e0 micro-processeurs que l’on emploie de plus en plus pour les piloter. Le system-on-chip<\/em> qui \u00e9quipe le Raspberry Pi ne fait pas exception, nous pouvons le v\u00e9rifier.<\/p>\n

\n\n<\/p>\n

Pr\u00e9sentation<\/h1>\n

Le SPI permet une communication entre un ma\u00eetre et un ou plusieurs esclaves. Le ma\u00eetre impose la fr\u00e9quence d’horloge et s\u00e9lectionne l’esclave auquel les donn\u00e9es sont envoy\u00e9es. La ligne MOSI permet d’envoyer des donn\u00e9es depuis le ma\u00eetre vers l’esclave. La ligne MISO est en haute-imp\u00e9dance jusqu’au moment o\u00f9 l’esclave est s\u00e9lectionn\u00e9 et o\u00f9 il doit envoyer des donn\u00e9es.<\/p>\n

\"Connexion<\/a><\/p>\n

Lorsqu’on dispose de plusieurs esclaves, ils peuvent \u00eatre connect\u00e9s sur un principe de bus (le ma\u00eetre s\u00e9lectionne parmi ses multiples sorties SS0<\/span>, SS1<\/span>, etc. l’esclave auquel il s’adresse) ou en daisy-chain<\/em> (les lignes MISO et MOSI sont connect\u00e9es en cascade, le nombre de coups d’horloge permettant de s\u00e9lectionner le p\u00e9riph\u00e9rique parmi l’ensemble qui se comporte alors comme une sorte de registre \u00e0 d\u00e9calage).<\/p>\n

Connexion du Raspberry Pi<\/h1>\n

Le Raspberry Pi ne fonctionne (pour le moment) qu’en mode master<\/em>. Il dispose de deux sorties SS0<\/span> et SS1<\/span> pour la s\u00e9lection du p\u00e9riph\u00e9rique esclave auquel il s’adresse. Les connexions se font sur les bornes suivantes du port d’extension P1<\/a>.<\/p>\n

\"Port<\/a><\/p>\n

\u00a0Configuration du noyau<\/h1>\n

Lors de la compilation du kernel, il faut activer l’option \u00ab\u00a0BCM2708 SPI controller driver<\/em>\u00a0\u00bb dans le sous-menu \u00ab\u00a0SPI support<\/em>\u00a0\u00bb du menu \u00ab\u00a0Device Drivers<\/em>\u00a0\u00bb comme indiqu\u00e9 sur la figure ci-dessous. L’option \u00ab\u00a0User mode SPI device driver support<\/em>\u00a0\u00bb permet de disposer d’entr\u00e9es \/dev\/spi0.0<\/code> (pour communiquer avec le premier esclave) et \/dev\/spi0.1<\/code> pour communiquer avec le second. Ceci offre alors la possibilit\u00e9 d’utiliser facilement l’interface SPI depuis l’espace utilisateur.<\/p>\n

\"Kernel<\/a><\/p>\n

\u00c9criture vers un esclave<\/h1>\n

Apr\u00e8s compilation et installation du noyau et de ses modules, nous d\u00e9marrons le Raspberry Pi et chargeons les modules n\u00e9cessaires.<\/p>\n

root@R-Pi# modprobe spi_bcm2708<\/strong>\n[   49.245907] bcm2708_spi bcm2708_spi.0: SPI Controller at 0x20204000 (irq 80)\nroot@R-Pi# modprobe spidev<\/strong>\nroot@R-Pi# ls -l \/dev\/spi*<\/strong>\ncrw-------    1 root     root      153,   0 Jan  1 00:00 \/dev\/spidev0.0\ncrw-------    1 root     root      153,   1 Jan  1 00:00 \/dev\/spidev0.1\nroot@R-Pi#<\/pre>\n
Micro-contr\u00f4leur en lecture<\/h2>\n
J’ai reli\u00e9 le Raspberry Pi avec un micro-contr\u00f4leur ATmega32 (en mode Slave<\/em>) se trouvant sur un carte de d\u00e9veloppement STK500. Dans un premier temps, le micro-contr\u00f4leur lit les donn\u00e9es arrivant sur le port SPI et configure ses sorties num\u00e9riques en cons\u00e9quence. J’ai modifi\u00e9 l’\u00e9tat des fusibles de l’ATmega32 afin qu’il utilise une horloge interne \u00e0 8MHz plut\u00f4t que l’horloge \u00e0 1MHz par d\u00e9faut. Pour cela je lis d’abord l’\u00e9tat initial du fusible Low<\/em>.<\/p>\n
[STK500]$ sudo avrdude -P \/dev\/ttyUSB0 -c stk500 -p m32 -U lfuse:r:-:h<\/strong>\n[...]\navrdude: writing output file \"\"\n0xe1\n[...]\n[STK500]$<\/pre>\n
Je dois modifier les trois bits de poids faibles en suivant la documentation de l’ATmega32<\/a> (pages 29, 257 et 258).<\/p>\n
[STK500]$ sudo avrdude -P \/dev\/ttyUSB0 -c stk500 -p m32 -U lfuse:w:0xe4:m<\/strong>\n[...]\navrdude: input file 0xe4 contains 1 bytes\navrdude: reading on-chip lfuse data:\n[...]\navrdude: 1 bytes of lfuse verified\n[STK500]$<\/pre>\n
Ensuite je flashe dans l’ATmega32 le petit programme suivant.<\/p>\n
\/* test-spi-01.c - ATmega32 *\/<\/strong>\n#include <avr\/io.h>\n#include <avr\/interrupt.h>\n\nISR(SPI_STC_vect)\n{\n    PORTD = ~ SPDR;            \/\/ Write on leds the byte received\n    unsigned char sreg = SPSR; \/\/ Clear Interrupt Flag\n}\n\nint main (void)\n{\n    DDRB = (1<<PB6);           \/\/ Only MISO on output\n    SPCR = (1<<SPE | 1<<SPIE); \/\/ SPI Enable  with Interrupt\n\n    DDRD = 0xFF;               \/\/ PORTD for output (LEDs)\n\n    sei();                     \/\/ Enable global interrupts\n\n    while (1)\n        ;\n    return 0;\n}<\/pre>\n
Ce programme configure le port SPI en mode Slave<\/em>, puis il effectue une boucle active (vide dans ce cas). Tout le travail est r\u00e9alis\u00e9 dans le handler d’interruption qui copie sur le port D le caract\u00e8re re\u00e7u sur le port SPI. Programmons le micro-contr\u00f4leur.<\/p>\n
[STK500]$ make<\/strong>\navr-gcc -Os -g -mmcu=atmega32   -c -o test-spi-01.o test-spi-01.c\navr-gcc -Os -g -mmcu=atmega32 -o test-spi-01.out  test-spi-01.o\navr-objcopy -j .text -O ihex test-spi-01.out test-spi-01.hex\nrm test-spi-01.out test-spi-01.o\n[STK500]$ sudo avrdude -P \/dev\/ttyUSB0 -c stk500 -p m32 -e -U flash:w:test-spi-01.hex<\/strong> \n\navrdude: AVR device initialized and ready to accept instructions\n[...]\nWriting | ################################################## | 100% 0.24s\n[...]\nReading | ################################################## | 100% 0.21s\n[...]\navrdude done.  Thank you.\n[STK500]$<\/pre>\n
Notez que pendant la programmation de l’ATmega32 il est n\u00e9cessaire de d\u00e9brancher la ligne SPI Clock<\/em> du Raspberry Pi (du moins avec mon programmateur STK500).<\/p>\n
Rasberry Pi en \u00e9criture<\/h2>\n
Puis j’installe sur la Raspberry Pi le programme suivant qui lit son entr\u00e9e standard et \u00e9crit la valeur indiqu\u00e9e sur le port SPI fourni sur sa ligne de commande.<\/p>\n
\/* test-spi-rpi-01.c - Programme pour Raspberry Pi *\/<\/strong>\n#include <fcntl.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <unistd.h>\n\n#include <linux\/types.h>\n#include <linux\/spi\/spidev.h>\n\n#include <sys\/ioctl.h>\n\nint main(int argc, char *argv[])\n{\n        int fd_spi;\n        char ligne[80];\n        int value;\n        unsigned char byte;\n\n        unsigned int speed = 250000;\n\n        if (argc != 3) {\n                fprintf(stderr, \"usage: %s <spi-port> <spi-speed>\\n\", argv[0]);\n                exit(EXIT_FAILURE);\n        }\n        fd_spi = open(argv[1], O_RDWR);\n        if (fd_spi < 0) {\n                perror(argv[1]);\n                exit(EXIT_FAILURE);\n        }\n\n        if (sscanf(argv[2], \"%d\", & speed) != 1) {\n                fprintf(stderr, \"Wrong value for speed: %s\\n\", argv[2]);\n                exit(EXIT_FAILURE);\n        }\n        if (ioctl(fd_spi, SPI_IOC_WR_MAX_SPEED_HZ, & speed) != 0) {\n                perror(\"ioctl\");\n                exit(EXIT_FAILURE);\n        }\n\n        while (fgets(ligne, 80, stdin) != NULL) {\n                if (sscanf(ligne, \"%d\", & value) != 1) {\n                        fprintf(stderr, \"integer value expected\\n\");\n                        continue;\n                }\n                byte = (unsigned char) (value & 0xFF);\n                if (write(fd_spi, & byte, 1) != 1) {\n                        perror(\"write\");\n                        exit(EXIT_FAILURE);\n                }\n        }\n        close(fd_spi);\n        return EXIT_SUCCESS;\n}<\/pre>\n
Nous lan\u00e7ons le programme sur le Raspberry Pi en lui indiquant une fr\u00e9quence d’horloge de 2MHz (le maximum acceptable par l’ATmega32 lorsqu’il fonctionne avec une horloge \u00e0 8MHz).<\/p>\n
root@R-Pi# .\/test-rpi-spi-01 \/dev\/spidev0.0 2000000<\/strong>\n1<\/strong>\n2<\/strong>\n4<\/strong>\n8<\/strong>\n16<\/strong>\n32<\/strong>\n64<\/strong>\n128<\/strong>\n85<\/strong>\n170<\/strong>\n237<\/strong><\/pre>\n
Les motifs binaires correspondant aux valeurs envoy\u00e9es sont visibles sur les leds de la carte de d\u00e9veloppement. Par exemple la valeur 237 (0xED ou 11101101b) est affich\u00e9e sur la figure ci-dessous.
\n\"Leds<\/a><\/p>\n
De m\u00eame un analyseur logique connect\u00e9 entre le Raspberry Pi et l’ATmega32 nous permet de voir l’horloge SPI (ligne 1) et la ligne MOSI (ligne 2). Nous pouvons v\u00e9rifier que la fr\u00e9quence de l’horloge (mesur\u00e9e entre les deux rep\u00e8res verticaux O<\/code> et M<\/code> et affich\u00e9e en bas de l’\u00e9cran) est bien de 2MHz.<\/p>\n
\"Analyseur<\/a><\/p>\n
L’\u00e9tat de la ligne MOSI est lu par l’esclave sur les fronts montants de l’horloge (SPI mode 0). Nous pouvons retrouver la valeur binaire pr\u00e9c\u00e9dente (inscrite manuellement ici).<\/p>\n
\u00a0Lecture depuis un esclave<\/h1>\n
\u00a0Micro-contr\u00f4leur en \u00e9criture<\/h2>\n
Cette fois l’ATmega32 va transmettre en permanence l’\u00e9tat de son entr\u00e9e analogique (huit bits de poids forts) vers le Raspberry Pi. Le convertisseur analogique-num\u00e9rique est programm\u00e9 en mode Free Running<\/em>, une interruption est d\u00e9clench\u00e9e \u00e0 la fin de chaque conversion qui enregistre dans une variable globale la valeur \u00e0 envoyer au Raspberry Pi.<\/p>\n
Le programme est le suivant.<\/p>\n
\/* test-spi-02.c - ATmega32 *\/<\/strong>\n\n#include <avr\/io.h>\n#include <avr\/interrupt.h>\n\nstatic unsigned char byte_to_write = 0;\n\nISR(SPI_STC_vect)\n{\n        PORTD = ~ SPDR;\n        unsigned char sreg = SPSR;\n        SPDR = byte_to_write;\n}\n\nISR(ADC_vect)\n{\n        unsigned char l = ADCL;\n        unsigned char h = ADCH;\n\n        unsigned int  v = (h << 8) | l;\n        byte_to_write = (v >> 2) & 0xFF;\n}\n\nint main (void)\n{\n        \/\/ Configure SPI Slave\n        DDRB = (1<<PB6);   \/\/ Only MISO on output\n        SPCR = (1<<SPE | 1<<SPIE);  \/\/ SPI Enable  with Interrupt\n\n        \/\/ Configure ADC on PA0\n        DDRA   = 0x00;      \/\/ PORTA for input (PA0 for ADC)\n        ADCSRA = 0x80;      \/\/ ADC Enable\n        ADMUX  = 0;         \/\/ Single Ended Input Channel 0\n        ADCSRA = 0xE8;      \/\/ ADC Enable + Start + Interrupt Enable + Auto Trigger\n\n        \/\/ Configure digital outputs\n        DDRD = 0xFF;        \/\/ PORTD for output (LEDs)\n\n        sei();\n        while (1)\n                ;\n\n        return 0;\n}<\/pre>\n
Encore une fois, le micro-contr\u00f4leur fonctionne en bouclant \u00ab\u00a0\u00e0 vide\u00a0\u00bb et tout le travail est r\u00e9alis\u00e9 dans les gestionnaires d’interruption.<\/p>\n
Raspberry Pi en lecture<\/h2>\n
Le programme de lecture sur le Raspberry Pi est identique au pr\u00e9c\u00e9dent, seule la boucle centrale de la fonction main()<\/code> change.<\/p>\n
\/* test-spi-rpi-02.c - Programme pour Raspberry Pi *\/<\/strong>\n[...]\n  while (read(fd_spi, & byte, 1) == 1)\n    fprintf(stdout, \"r%d (%02X)    \", byte);\n[...]<\/pre>\n
En lan\u00e7ant le programme sur le Raspberry Pi, nous voyons en continu l’\u00e9tat de l’entr\u00e9e analogique (reli\u00e9e ici \u00e0 un potentiom\u00e8tre).<\/p>\n
root@R-Pi# .\/test-rpi-spi-02 \/dev\/spidev0.0 2000000<\/strong>\n163(A3)<\/pre>\n
L’analyseur logique nous pr\u00e9sente sur la figure suivante la ligne MISO sur son canal 3, o\u00f9 l’on reconna\u00eet la valeur 0xA3 (10100011b).<\/p>\n
\"Raspberry<\/a><\/p>\n
 <\/p>\n
\u00a0Conclusion<\/h1>\n
Nous avons abord\u00e9 la mise en oeuvre simple du lien SPI sur le Raspberry Pi. Nous avons utilis\u00e9 simplement des op\u00e9rations read()<\/code> et write()<\/code> depuis l’espace utilisateur. Nous pouvons \u00e9galement r\u00e9aliser des op\u00e9rations plus complexes comme une communication full-duplex<\/em> – toujours depuis l’espace utilisateur – ou le transfert de donn\u00e9es depuis l’espace kernel. Ceci fera l’objet de prochains articles.<\/p>\n
PS :<\/strong> Les sources des programmes pr\u00e9sent\u00e9s plus haut sont disponibles ici<\/a>.<\/p>\n
","protected":false},"excerpt":{"rendered":"
La communication par lien SPI (Serial Peripheral Interface) est un élément important pour les systèmes embarqués. Ceci concerne les micro-contrôleurs (systèmes industriels par exemple), mais également les cartes à micro-processeurs que l’on emploie de plus en plus pour les piloter. Le system-on-chip qui équipe le Raspberry Pi ne fait pas exception, nous pouvons le vérifier.<\/p>","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5,8,10,11],"tags":[],"class_list":["post-3043","post","type-post","status-publish","format-standard","hentry","category-embarque","category-linux-2","category-microprocesseur","category-raspberry-pi"],"_links":{"self":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts\/3043","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/comments?post=3043"}],"version-history":[{"count":6,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts\/3043\/revisions"}],"predecessor-version":[{"id":4623,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts\/3043\/revisions\/4623"}],"wp:attachment":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/media?parent=3043"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/categories?post=3043"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/tags?post=3043"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}