{"id":2120,"date":"2012-05-09T10:50:02","date_gmt":"2012-05-09T09:50:02","guid":{"rendered":"http:\/\/www.blaess.fr\/christophe\/?p=2120"},"modified":"2012-05-09T10:50:02","modified_gmt":"2012-05-09T09:50:02","slug":"gpio-pandaboard-temps-reel-1","status":"publish","type":"post","link":"https:\/\/www.blaess.fr\/christophe\/2012\/05\/09\/gpio-pandaboard-temps-reel-1\/","title":{"rendered":"GPIO, Pandaboard et temps r\u00e9el – 1 – Sorties depuis l’espace utilisateur"},"content":{"rendered":"

\"GPIO<\/a>
\nLes GPIO<\/strong> (General Purpose Input Output<\/em>) sont des broches du microprocesseur permettant de r\u00e9aliser des op\u00e9rations d’entr\u00e9e-sortie \u00e9lectriques programmables. Chaque broche peut \u00eatre affect\u00e9e en entr\u00e9e ou en sortie par programmation et utilis\u00e9e ais\u00e9ment pour communiquer avec des p\u00e9riph\u00e9riques externes.<\/p>\n

\n\n<\/p>\n

La Pandaboard utilise un processeur Texas OMAP4430, construit autour d’un coeur Cortex A9. La documentation techique<\/a> de l’OMAP4430 (plus de 5500 pages…) pr\u00e9cise que le processeur dispose de six modules GPIO, chacun offrant 32 lignes d’entr\u00e9es-sorties. Sur les 192 ports GPIO th\u00e9oriquement pr\u00e9sents, une bonne partie est d\u00e9j\u00e0 employ\u00e9e pour la carte elle-m\u00eame mais quelques uns sont accessibles \u00e0 l’utilisateur.<\/p>\n

Connecteurs d’extension<\/h1>\n

Nous trouvons sur la Pandaboard deux connecteurs utlisables pour des exp\u00e9rimentations et extensions futures. Num\u00e9rot\u00e9s J3 et J6, ils sont \u00e9galement rep\u00e9r\u00e9s par les libell\u00e9s \u00ab\u00a0Expansion Connector A<\/em>\u00a0\u00bb et \u00ab\u00a0Expansion Connector B<\/em>\u00a0\u00bb comme on peut le voir sur la photo ci-contre.\"Connecteurs<\/a><\/p>\n

Le d\u00e9tail des broches disponibles est fourni dans le manuel de r\u00e9f\u00e9rence de la Pandaboard<\/a> (pages 43 et 44), certaines d’entre elles ayant une signification pour le syst\u00e8me.<\/p>\n

 <\/p>\n

Par exemple, dans le tableau ci-dessous nous pouvons remarquer que la broche num\u00e9ro 10 est associ\u00e9e \u00e0 deux fonctionnalit\u00e9s : un signal Chip Select<\/em> pour une communication avec une autre carte ou une entr\u00e9e sortie GPIO num\u00e9ro 138.<\/p>\n

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

Certaines broches ont des affectations fig\u00e9es car elles sont reli\u00e9es \u00e0 des composants sur la carte, mais d’autres peuvent \u00eatre utilis\u00e9es pour r\u00e9aliser des entr\u00e9es sorties personnalis\u00e9es.<\/p>\n

Nous remarquons la pr\u00e9sence sur la broche num\u00e9ro 1 d’un signal d’alimentation +1.8 V que nous pourrons utiliser pour l’envoyer sur les entr\u00e9es de notre choix (dans le prochain article) et de la masse du signal sur les broches 27 et 28.<\/p>\n

Attention, les op\u00e9rations sur ce connecteur sont tr\u00e8s risqu\u00e9es car elles se r\u00e9percutent directement sur les broches du processeur, sans protection. Je d\u00e9cline donc toute responsabilit\u00e9 si une manipualtion d\u00e9crite ici sonne le glas de votre Pandaboard. Pour vous convaincre encore, sachez que j’ai grill\u00e9 une carte Pandaboard (enfin, un processeur OMAP4 mais c’est le principal) simplement en confondant la broche 2 (alimentation +5V) et la broche 1 (alimentation +1.8V) pour envoyer un signal sur une entr\u00e9e GPIO. Donc : prudence et concentration sont de rigueur !<\/p>\n

\u00a0Nous allons donc souder sur le connecteur quelques fils afin d’acc\u00e9der facilement aux broches 1, 10 et 28.<\/p>\n

\"Broches<\/a>La broche 1 de chaque connecteur (en haut \u00e0 gauche lorsqu’on le regarde de face) est rep\u00e9r\u00e9e par un carr\u00e9, la 2 se trouve en dessous, la 3 \u00e0 droite du 1, la 4 en dessous de la 3 et ainsi de suite.<\/p>\n

Naturellement, la soudure se fait plut\u00f4t sur la face oppos\u00e9e, o\u00f9 les num\u00e9rotations sont invers\u00e9es.<\/p>\n

\"Soudure<\/a>Pour cet article, nous n’utiliserons pas l’alimentation (broche 1), mais j’ai profit\u00e9 de l’occasion pour la souder en m\u00eame temps les deux autres.<\/p>\n

Acc\u00e8s aux GPIO depuis l’espace utilisateur avec le shell<\/h1>\n

D\u00e9marrons notre carte en utilisant un syst\u00e8me fait maison, comme d\u00e9crit dans les articles num\u00e9ro 1<\/a>, num\u00e9ro 2<\/a>, num\u00e9ro 3<\/a>, num\u00e9ro 4<\/a> et num\u00e9ro 5<\/a> d’une pr\u00e9c\u00e9dente s\u00e9rie. Puis connectons depuis un PC distant en utilisant le protocole SSH.<\/p>\n

[~]$ ssh root@192.168.5.152<\/strong>\nroot@192.168.5.152's password:\n[Panda]#<\/pre>\n
Le prompt<\/em> du shell sur la Pandaboard est pr\u00e9fix\u00e9 par \u00ab\u00a0[Panda]\u00a0\u00bb pour \u00e9viter les confusions avec le syst\u00e8me h\u00f4te.<\/p>\n
V\u00e9rifions pour commencer la tension sur la broche 10 avec un simple voltm\u00e8tre.<\/p>\n
\"GPIO<\/a><\/p>\n
La tension est nulle, mais la broche est par d\u00e9faut affect\u00e9e en entr\u00e9e (avec une haute imp\u00e9dance). Nous allons modifier cela.<\/p>\n
[Panda]# cd \/sys\/class\/gpio\/<\/strong>\n[Panda]# ls<\/strong>\nexport       gpio62       gpiochip128  gpiochip32   gpiochip96\ngpio1        gpiochip0    gpiochip160  gpiochip64   unexport\n[Panda]#<\/pre>\n
Par d\u00e9faut, le port GPIO 138 n’est pas accessible depuis le pseudo syst\u00e8me de fichier \/sys\/<\/code>, mais nous pouvons le r\u00e9clamer ainsi.<\/p>\n
[Panda]# echo 138 > export <\/strong>\n[Panda]# ls<\/strong>\nexport       gpio138<\/strong>      gpiochip0    gpiochip160  gpiochip64   unexport\ngpio1        gpio62       gpiochip128  gpiochip32   gpiochip96\n[Panda]#<\/pre>\n
Le port 138 est maintenant accessible v\u00e9rifions son sens de fonctionnement.<\/p>\n
[Panda]# cd gpio138\/<\/strong>\n[Panda]# cat direction<\/strong>\nin\n[Panda]#<\/pre>\n
Il est affect\u00e9 en entr\u00e9e par s\u00e9curit\u00e9 au boot<\/em>. Basculons-le en sortie.<\/p>\n
[Panda]# echo out > direction <\/strong>\n[Panda]# cat direction <\/strong>\nout\n[Panda]# cat value<\/strong>\n0\n[Panda]#<\/pre>\n
La valeur inscrite sur le port est 0<\/code>, ce qui ne nous surprend pas puisque la tension sur la borne est nulle. Modifions la valeur.<\/p>\n
[Panda]# echo 1 > value <\/strong>\n[Panda]#<\/pre>\n
Le voltm\u00e8tre affiche maintenant 1,8 V (la tension de r\u00e9f\u00e9rence pour les GPIO, \u00e0 ne pas d\u00e9passer pour les entr\u00e9es !).<\/p>\n
\"GPIO<\/a><\/p>\n
\u00c9crivons \u00e0 nouveau sur le port.<\/p>\n
[Panda]# echo 0 > value <\/strong>\n[Panda]#<\/pre>\n
Le voltm\u00e8tre affiche \u00e0 nouveau 0.00. Lib\u00e9rons le port GPIO pour terminer cette exp\u00e9rience.<\/p>\n
[Panda]# cd \/sys\/class\/gpio\/<\/strong>\n[Panda]# echo 138 > unexport <\/strong>\n[Panda]#<\/pre>\n
Application des GPIO avec un script shell<\/h1>\n
Nous savons \u00e9crire une valeur sur une broche de sortie depuis la ligne de commande, automatisons cela dans un petit script shell qui va faire osciller la broche 10.<\/p>\n
\/usr\/local\/bin\/oscillateur-gpio.sh :<\/strong><\/a>\n#! \/bin\/sh\n\nGPIO=138  # Broche 10 du port \"Expansion A\"<\/em>\n\ncd \/sys\/class\/gpio\n\necho ${GPIO} > export\n\ncd gpio${GPIO}\n\necho out > direction\n\nwhile true\ndo\n\techo 1 > value\n\tusleep 1000\n\techo 0 > value\n\tusleep 1000\ndone<\/pre>\n
Le script r\u00e9alise de petites pause de 1000 microsecondes, soit une milliseconde apr\u00e8s chaque changement d’\u00e9tat de la broche.<\/p>\n
Connectons un oscilloscope \u00e0 la place du voltm\u00e8tre pour voir \u00e9voluer le signal.<\/p>\n
\"Oscilloscope<\/a>Nous apercevons sur l’\u00e9cran un signal p\u00e9riodique qui alterne entre 0 et 1,8V. Toutefois, en regardant de plus pr\u00e8s, les dur\u00e9es que nous avions indiqu\u00e9es dans le script ne sont pas respect\u00e9es.<\/p>\n
\"Oscillateur<\/a>Le signal change de niveau toutes les 3,3 millisecondes environ et non pas \u00e0 chaque milliseconde. Il s’agit de la granularit\u00e9 du usleep<\/code> qui pose probl\u00e8me.Nous pouvons am\u00e9liorer ceci en utilisant un petit programme en C qui r\u00e9alise le m\u00eame travail mais s’appuie directement sur la libC en passant outre les latences d\u00fbes au shell et aux utilitaires syst\u00e8me (issus de la Busybox en l’occurrence).<\/p>\n
oscillateur-gpio-user.c :<\/strong><\/a>\n#include <signal.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <unistd.h>\n\nstatic volatile int exit_loop = 0;\n\nvoid handler_signal(int unused)\n{\n    exit_loop = 1;\n}\n\nint main(int argc, char * argv[])\n{\n    int value = 1;\n    char path[256];\n    int gpio = 138;\n    FILE * fp;\n\n    \/\/ En argument on peut preciser un GPIO different de 138\n    if ((argc > 2) || ((argc == 2) && (sscanf(argv[1], \"%d\", & gpio) != 1))) {\n        fprintf(stderr, \"usage: %s [gpio]n\", argv[0]);\n        exit(EXIT_FAILURE);\n    }\n\n    \/\/ Exporter le GPIO dans le systeme de fichiers\n    snprintf(path, 256, \"\/sys\/class\/gpio\/export\");\n    if ((fp = fopen(path, \"w\")) == NULL) {\n        perror(path);\n        exit(EXIT_FAILURE);\n    }\n    fprintf(fp, \"%dn\", gpio);\n    fclose(fp);\n\n    \/\/ Intercepter Controle-C pour finir proprement\n    signal(SIGINT, handler_signal);\n\n    \/\/ Basculer le GPIO en sortie\n    snprintf(path, 256, \"\/sys\/class\/gpio\/gpio%d\/direction\", gpio);\n    if ((fp = fopen(path, \"w\")) == NULL) {\n        perror(path);\n        exit(EXIT_FAILURE);\n    }\n    fprintf(fp, \"outn\");\n    fclose(fp);\n\n    \/\/ Ecrire alternativement la valeur du GPIO\n    snprintf(path, 256, \"\/sys\/class\/gpio\/gpio%d\/value\", gpio);\n    if ((fp = fopen(path, \"w\")) == NULL) {\n        perror(path);\n        exit(EXIT_FAILURE);\n    }\n    while (! exit_loop) {\n        fprintf(fp, \"%dn\", value);\n        fflush(fp);\n        value = 1 - value;\n        usleep(1000);\n    }\n\n    \/\/ De-exporter le GPIO du systeme de fichiers\n    if ((fp = fopen(\"\/sys\/class\/gpio\/unexport\", \"w\")) == NULL) {\n        perror(\"\/sys\/class\/gpio\/unexport\");\n        exit(EXIT_FAILURE);\n    }\n    fprintf(fp, \"%dn\", gpio);\n    fclose(fp);\n    return EXIT_SUCCESS;\n}<\/pre>\n
Apr\u00e8s compilation (en utilisant un cross-compiler comme indiqu\u00e9 dans cet article<\/a>), nous transf\u00e9rons le code sur la cible.<\/p>\n
$ ~\/cross-panda\/usr\/bin\/arm-linux-gcc -Wall -o oscillateur-gpio-user oscillateur-gpio-user.c<\/strong>\n$ scp oscillateur-gpio-user root@192.168.5.152:\/root\/<\/strong>\nroot@192.168.5.152's password:\noscillateur-gpio-user                                               100% 6270     6.1KB\/s   00:00\n$<\/pre>\n
Sur la cible nous lan\u00e7ons le programme (et nous pouvons l’arr\u00eater avec Contr\u00f4le-C<\/em>).<\/p>\n
[Panda]# \/root\/oscillateur-gpio-user <\/strong>\n    (Contr\u00f4le-C<\/strong>)<\/em>\n[Panda]#<\/pre>\n
Le signal est plus pr\u00e9cis, nous pourrions calibrer la dur\u00e9e des sommeils pour avoir exactement une milliseconde, ou utiliser un timer logiciel comme ceux founis par setitimer()<\/code>.<\/p>\n
\"Oscillateur<\/a><\/p>\n
Toutefois, sur l’\u00e9cran de l’oscilloscope, le signal n’est pas tr\u00e8s stable, ses fronts montants et descendants tremblent en permanence, signe classique d’un comportement li\u00e9 \u00e0 l’ordonnancement en temps partag\u00e9.<\/p>\n
Pour am\u00e9liorer la pr\u00e9cision nous pouvons lancer le programme en ordonnancement temps r\u00e9el souple avec chrt<\/code>.<\/p>\n
[Panda]# chrt -f99 \/root\/oscillateur-gpio-user<\/strong>\n    (Contr\u00f4le-C<\/strong>)<\/em>\n[Panda]#<\/pre>\n
\"Oscillateur<\/a><\/p>\n
Le signal est beaucoup plus stable, mais il y a encore des petits \u00ab\u00a0sauts\u00a0\u00bb de temps \u00e0 autres. Avec un oscilloscope \u00e0 m\u00e9moire, nous pourrions voir appara\u00eetre parfois des fronts d\u00e9cal\u00e9s d’une dur\u00e9e assez significative.<\/p>\n
Conclusion<\/h1>\n
Afin d’am\u00e9liorer la pr\u00e9cision d’un signal, il est n\u00e9cessaire d’adopter une approche temps r\u00e9el. Ceci peut se r\u00e9aliser de diff\u00e9rentes mani\u00e8res. Dans le prochain article<\/a> nous verrons comment g\u00e9rer les GPIO depuis l’espace kernel en \u00e9crivant un module pour le noyau Linux standard, puis nous nous rapprocherons du temps r\u00e9el strict en pilotant les GPIO depuis un module kernel de Xenomai, avec l’API RTDM.<\/p>","protected":false},"excerpt":{"rendered":"
Les GPIO (General Purpose Input Output) sont des broches du microprocesseur permettant de réaliser des opérations d’entrée-sortie électriques programmables. Chaque broche peut être affectée en entrée ou en sortie par programmation et utilisée aisément pour communiquer avec des périphériques externes.<\/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,13,14],"tags":[],"class_list":["post-2120","post","type-post","status-publish","format-standard","hentry","category-embarque","category-linux-2","category-microprocesseur","category-shell","category-temps-reel"],"_links":{"self":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts\/2120","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=2120"}],"version-history":[{"count":0,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts\/2120\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/media?parent=2120"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/categories?post=2120"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/tags?post=2120"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}