Club robotique de Sophia-Antipolis

Accueil > POBOTpedia > Ordinateurs embarqués (SBC) > La carte Raspberry PI > Logiciels et langages de programmation sur RPi > Entrées/sorties GPIO sur Raspberry Pi

Entrées/sorties GPIO sur Raspberry Pi

jeudi 6 septembre 2012, par Julien H.

Cet article est un cours d’introduction aux entrées et sorties numériques sur carte Raspberry Pi, permettant de comprendre leur fonctionnement, leur connexion et de les tester depuis le shell, avant de voir leur programmation dans différents langages.

La carte Raspberry Pi donne accès à des entrées et sorties numériques appelées GPIO (en anglais "general purpose input & output") contrôlées par le processeur ARM. 

Elles sont à usage multiple :
- en entrée numérique tout ou rien, pour détecter un interrupteur par exmeple
- en sortie numérique tout ou rien, pour activer un relais par exemple
- en sortie numérique PWM, pour contrôler la puissance moyenne d’une led par exemple
- en protocole I2C, d’échanger avec une ou plusieurs puces
- en protocole SPI, idem
- en protocole UART, d’échanger avec une seule puce (ou un PC)

D’autres usages sont possibles (audio PCM, vidéo sur les connecteurs DSI et CSI), nous y reviendrons si nécessaire, contactez-nous pour toute question d’ordre technique.



Plusieurs connecteurs donnent accès aux GPIO, mais le principal est un connecteur comportant 2 rangées de 13 picots mâles distants du pas standard de 2,54 mm.

Voici les signaux qu’on peut y trouver. Certaines pattes ont deux usages, mais pour plus de simplicité, ne tenez compte que de celui indiqué sur l’image ci-dessous pour réaliser vos premiers montages.

PNG - 47.1 ko
Position du connecteur GPIO de la RPi
Image réalisée depuis Fritzing avec le modèle d’Adafruit.

Bien entendu cela limite les pattes de connexion I/O simples à 8 seulement, mais si vous voulez avoir accès aux 53 GPIO, à vos risques et périls ! Si vous avez besoin de plus de 8 pattes, il est peut-être préférable d’utiliser un circuit d’extension, mais effectivement on peut en récupérer 5 autres si on n’a pas besoin des usages spécifiques (SPI par exemple) du connecteur principal. Et encore quelques autres en se connectant sur les autres connecteurs.

Surtout, notez que le numéro de GPIO n’est pas sa position sur le connecteur, mais son numéro dans les registres de la puce ARM BCM2835. C’est donc celui qui sera utilisé dans la plupart des bibliothèques d’accès.

 Premier test

Avant d’utiliser un langage de programmation pour faire son propre logiciel, voyons comment tester les pattes d’entrées/sortie depuis le shell, en ligne de commande. Cet usage est vraiment pratique et permet de tirer parti de la présence d’un système d’exploitation Linux, avec toutes les fonctionnalités disponibles en ligne de commande ou en script bash (boucles, accès aux fichiers, etc...).

On va utiliser les éléments suivants pour lire une entrée reliée à un bouton et pour faire allumer une led :

- une carte Raspberry Pi
- une distribution Linux basée sur Debian (l’Occidentalis 1.0)
- une plaque d’essai Labdec ou breadboard
- un bouton (interrupteur)
- une résistance 10k
- une led
- des fils de connexion

C’est le minimum. Vous pouvez utiliser un clavier et un écran pour utiliser un terminal de la Raspberry Pi, ou y accéder depuis un PC distant grâce à une liaison réseau Ethernet.

 Le montage

Voici le schéma du circuit ainsi réalisé. Notez que la Raspberry Pi est stylisée, réduite à son connecteur d’entrées/sorties principal.

PNG - 26.5 ko
Montage simple autour du GPIO RPi

Pour les débutants, voici une vue des composants tels qu’on les implantera sur une plaque d’essai :

PNG - 41.3 ko
Implantation des composants

 L’installation logicielle

Comme nous aimons la simplicité, et que nous avons choisi la Raspberry Pi pour la communauté d’experts Linux capables d’écrire de bons programmes fiables, nous n’allons pas utiliser de codes complexes mais des outils pratiques.

Pour accéder aux GPIO depuis le shell en ligne de commande, nous utiliserons donc WiringPi, une bibliothèque C et des outils de compilation partagés par Gordon sur son site.

L’installation est un peu différente de celle qu’il décrit sur son site, alors je me permets de recopier ce que j’ai fait (sur une Raspbian / Occidentalis) :

atelier@ubuntu:~$ ssh pi@10.42.0.77
pi@10.42.0.77's password: raspberry
Linux raspberrypi 3.2.27+ #102 PREEMPT Sat Sep 1 01:00:50 BST 2012 armv6l
pi@raspberrypi ~ $ sudo apt-get install git-core
...
pi@raspberrypi ~ $ mkdir gpio
pi@raspberrypi ~ $ cd gpio/
pi@raspberrypi ~/gpio $ git clone git://git.drogon.net/wiringPi
...
pi@raspberrypi ~/gpio $ cd wiringPi/
pi@raspberrypi ~/gpio/wiringPi $ git pull origin
remote: Counting objects: 11, done.
remote: Compressing objects: 100% (8/8), done.
remote: Total 8 (delta 6), reused 0 (delta 0)
Unpacking objects: 100% (8/8), done.
From git://git.drogon.net/wiringPi
   99095e3..30d79da  master     -> origin/master
Updating 99095e3..30d79da
Fast-forward
 wiringPi/wiringPi.c |  108 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 104 insertions(+), 4 deletions(-)
pi@raspberrypi ~/gpio/wiringPi $ cd wiringPi/
pi@raspberrypi ~/gpio/wiringPi/wiringPi $ sudo make install
[CC] wiringPi.c
[AR] wiringPi.o wiringPiFace.o wiringSerial.o wiringShift.o gertboard.o piNes.o lcd.o piHiPri.o piThread.o softPwm.o wiringPiSPI.o
   text    data     bss     dec     hex filename
   5992     516     304    6812    1a9c wiringPi.o (ex libwiringPi.a)
   1908       8       8    1924     784 wiringPiFace.o (ex libwiringPi.a)
    828       0       0     828     33c wiringSerial.o (ex libwiringPi.a)
   1696       0       0    1696     6a0 wiringShift.o (ex libwiringPi.a)
    208       0       0     208      d0 gertboard.o (ex libwiringPi.a)
    828       0     100     928     3a0 piNes.o (ex libwiringPi.a)
   2452       0       4    2456     998 lcd.o (ex libwiringPi.a)
     76       0       0      76      4c piHiPri.o (ex libwiringPi.a)
     76       0      96     172      ac piThread.o (ex libwiringPi.a)
    372       4     512     888     378 softPwm.o (ex libwiringPi.a)
    420       1      20     441     1b9 wiringPiSPI.o (ex libwiringPi.a)
[install]
install -m 0755 -d /usr/local/lib
install -m 0755 -d /usr/local/include
install -m 0644 wiringPi.h      /usr/local/include
install -m 0644 wiringSerial.h  /usr/local/include
install -m 0644 wiringShift.h   /usr/local/include
install -m 0644 gertboard.h     /usr/local/include
install -m 0644 piNes.h         /usr/local/include
install -m 0644 softPwm.h       /usr/local/include
install -m 0644 lcd.h           /usr/local/include
install -m 0644 wiringPiSPI.h   /usr/local/include
install -m 0644 libwiringPi.a   /usr/local/lib
pi@raspberrypi ~/gpio/wiringPi $ cd ../gpio/
pi@raspberrypi ~/gpio/wiringPi/gpio $ sudo make install
cp gpio /usr/local/bin
chown root.root /usr/local/bin/gpio
chmod 4755 /usr/local/bin/gpio
mkdir -p /usr/local/man/man1
cp gpio.1 /usr/local/man/man1
pi@raspberrypi ~/gpio/wiringPi/gpio $

Les dernières commandes sont très importantes : elles copient le programme binaire compilé dans un répertoire permettant l’accès à la commande depuis n’importe où sur votre Linux. Elles installent aussi le manuel au bon endroit pour être appelé.

Si quelqu’un vous répond "RTFM" quand vous posez une question sur un programme, cela signifie "read the famous man" (en édulcoré), et il faut alors exécuter la commande man suivie du nom de l’exécutable concerné, depuis n’importe quel répertoire. Tapez "q" pour sortir.

pi@raspberrypi ~ $ man gpio
GPIO(14 June 2012)                                          GPIO(14 June 2012)
NAME
       gpio - Command-line access to Raspberry Pi and PiFace GPIO
SYNOPSIS
       gpio -v
       gpio [ -g ] read/write/pwm/mode ...
       gpio [ -p ] read/write/mode ...
       gpio unexportall/exports
       gpio export/edge/unexport ...
       gpio drive group value
       gpio pwm-bal/pwm-ms
       gpio pwmr range
       gpio load  i2c/spi
...

Il y a plusieurs pages. Vous pouvez les lire ou suivre nos tests.

 Les tests

On a connecté la Raspberry au montage présenté plus haut, avec un signal d’entrée/sortie (interrupteur ou led) sur la patte 7 du connecteur, correspondant à la GPIO 4 de la Raspberry Pi.

PNG - 374 ko
Montage simple led + bouton
Cela ressemble au schéma, non ?

Selon l’explication donnée dans le manuel (man gpio), on pourra utiliser de manière équivalente les instructions suivantes :

pi@raspberrypi ~ $ gpio -g mode 4 out
pi@raspberrypi ~ $ gpio mode 7 out

On préférera la première écriture, qui sensibilise à l’usage général des GPIO et permettra d’aller vérifier les autres modes disponibles sur la patte 4 dans la doc du ARM BCM2835.

Voici pour éteindre la led puis la rallumer :

pi@raspberrypi ~ $ gpio -g mode 4 out
pi@raspberrypi ~ $ gpio -g write 4 1
pi@raspberrypi ~ $ gpio -g write 4 0

Pour lire l’état (il change en appuyant sur le bouton) :

pi@raspberrypi ~ $ gpio -g mode 4 in
pi@raspberrypi ~ $ gpio -g read 4
1
pi@raspberrypi ~ $ gpio -g read 4
0
pi@raspberrypi ~ $

On peut maintenant écrire un script bash :

pi@raspberrypi ~/gpio $ nano test.sh
#!/bin/bash

setup ()
{
 echo Setup
 gpio -g mode 4 in
}

waitButton ()
{
 echo -n "Waiting for button ... "
 while [ `gpio -g read 4` = 1 ]; do
   sleep 0.1
 done
 echo "Got it"
}

setup
while true; do
 waitButton
done

Un petit CTRL+O pour enregistrer et CTRL+X pour sortir et vous pouvez exécuter le programme :

pi@raspberrypi ~/gpio $ chmod 755 test.sh
pi@raspberrypi ~/gpio $ ./test.sh
Setup
Waiting for button ... Got it
Waiting for button ... Got it
Waiting for button ... Got it
Waiting for button ... Got it

Et là vous aurez atteint l’échelon numéro 1 en électronique ludique : vous avez découvert le problème de la détection de l’appui sur un bouton, avec la nécessité de détecter le passage sur un front (nom donné à un changement d’état) plutôt que sur l’état lui-même.

Vous pouvez maintenant rejoindre un club de robotique qui vous apprendra des solutions logicielles ou matérielles à ce problème... en attendant l’échelon 2 (nom de code : anti-rebond).

Vos commentaires

  • Le 22 septembre à 16:44, par Léandre En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour,
    j’ai depuis quelques temps une Raspberry 2, mais un problème subsiste sur le gpio.
    lorsque j’appelle des broche pour allumer simplement une leds, celle qui s’active n’est pas la bonne.
    exemples :
    la broche 1 dans le programme devient la broche physique 29
    2=>28
    3=>26
    5=>23
    6=>19
    8=>38
    je ne comprends vraiment pas pourquoi, je suis sûr d’avoir bien branché la nappe sur la raspberry.
    Merci de votre aide. :’-(

    • Le 16 octobre à 16:00, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Il y a deux modes d’identification des pins du connecteur GPIO :
      - le mode "board", correspondant à la numérotation du connecteur
      - le mode "Broadcom", correspondant à la numérotation des pins correspondantes du processeur
      On peut choisir celui qu’on utilise dans le programme via une des fonctions de la lib (setMode ou quelque chose d’approchant).
      Ce qui vous arrive est très certainement causé par le fait que votre programme utilise un mode alors que la lib GPIO est configurée dans l’autre (qui est son mode par défaut si vous n’avez rien fait de particulier sur ce point).

    Répondre à ce message

  • Le 25 janvier à 19:01, par joel76 En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour
    j’ai un raspberry pi 2 et j’ai grillé le pin 35 ( gpio19), j’utilise un programme qui me génère des signaux carré I Q sur le pin 12 ( gpio18) et 35 ( gpio 19), et donc le pin 35 ne sort plus rien donc hs, serait-t-il possible de diriger le pin 35 vers 37 par exemple ou autres ? en ligne de commande
    je vous remercie
    Joël

    • Le 25 janvier à 21:13, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,
      Non malheureusement, les GPIO sont liées au matériel et certaines fonctions sont spécifiques à certaines pattes donc on ne peut pas recopier logiciellement une fonctionnalité sur une autre patte.
      Mais êtes-vous certain que c’est "grillé" ? Est-ce qu’il n’y a pas plutôt un autre programme qui inhibe le fonctionnement souhaité de la patte 35 ?

    Répondre à ce message

  • Le 22 août 2015 à 22:32, par Nicolas G En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour, je n’ai que des rudiments vraiments basiques en prog et en électronique, mais j’aimerais réaliser une interface basée sur le raspberyy pi pour lire des entrées (8), les mouliner dans un programme et piloter des sorties (5) en fonction de cela. j’aimerais adjoindre à ce programme une fonction pour un écran d’affichage.
    Comment faire ? qui consulter ? devant la multiplicité des forums, je m’avoue un peu perdu :S

    • Le 23 août 2015 à 16:52, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Oulà, il y a du taf si tu n’as que quelques rudiments basiques, mais ça peut être une bonne occasion pour les transformer en vraie connaissances.
      1/ les entrées-sorties : quelles sont les plages de tension des entrées, des courants à piloter sur les sorties,... ? Cela a une incidence sur les solutions matérielles. Il y a pas mal de cartes d’extension pour la RasPi, et j’ai un petit faible pour les produits de AB Electronics (https://www.abelectronics.co.uk/). Cherche sur notre site les articles qui en parlent.
      2/ l’interface utilisateur : s’il y a un écran connecté sur la RasPi, et qu’on utilise donc l’environnement graphique, nous sommes sous un Linux classique avec serveur X, et donc les outils classiques tels que Qt, vxwidegets,... sont disponibles. Si la RasPi est en config headless (i.e "boite noire") la plupart du temps on y développe une application Web (c’est moins compliqué qu’il n’y parait), et là encore il y a des articles sur notre site qui en parlent). Il y a d’autres options encore, mais ne compliquons pas ;-)
      On pourrait écrire des articles entiers sur les sujets que tu mentionnes, et par conséquent impossible de réponse dans un simple commentaire (limité à 500 caractères par-dessus le marché).
      De toute manière, il faut en premier lieu que tu précises un peu mieux le besoin et le contexte de fonctionnement de la RasPi (cf plus haut). On pourra essayer d’approfondir en fonction.
      Bon courage |-)

    Répondre à ce message

  • Le 14 février 2014 à 10:35, par Jean-Claude En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour et merci de me lire,

    J’ai en tête de piloter un appareil photo reflex via son entrée telecomande filaire
    j’aurai besoin donc d’un port gpio qui me piloterai le reflex via un transistor
    de façon à faire un "timelapse" une photo toutes les x secondes pendant xx secondes
    je ne me suis pas encore penché sur la programmation python ou autre et je pensai pour le faire
    directement avec un programme linux genre "cron" (je dit peut être une bêtise...)

    qu’en pensez vous ?
    merci d’avance pour votre aide

    Cordialement
    Jean-Claude

    • Le 14 février 2014 à 10:47, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Ca peut fonctionner, en sachant que cependant que la résolution temporelle de cron est la minute. Autrement dit, impossible de configurer un délai inférieur à cette valeur et d’utiliser une période non multiple de la minute.

      De plus, le délai réel entre deux actions va inclure celui nécessaire à recréer le process du programme ou du script déclenché par cron. Ce qui peut introduire une variabilité non contrôlable.

      La solution qui donne entière liberté est de gérer le temps au sein même du programme ou du script, au moyen d’une boucle générale utilisant les diverses fonctions permettant de gérer des délais, récupérer l’instant courant, le comparer à l’instant où on souhaite exécuter l’action,...

    Répondre à ce message

  • Le 18 mars 2015 à 11:28, par FY En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour,
    je veux commander un GPIO via un autre GPIO,
    Le pin 7 par ex reçoit le signal venant du luxmètre, l’autre GPIO (pin 11), commande l’allumage ou extinction lampe suivant ce signal.
    Comment faire pour le réaliser, est-ce possible ?
    merci
    cdt

    • Le 22 mars 2015 à 10:11, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bien sûr que c’est possible :)
      Comment ? En écrivant un programme qui va lire la valeur de la GPIO en entre (le luxmètre ici) et modifier l’état de la GPIO qui pilote la lampe en conséquence.
      Attention avec votre exemple : la Raspberry n’a pas de GPIO faisant fonction d’ADC. Il lui est donc impossible de faire l’acquisition d’un signal analogique, sauf à à adjoindre une extension telles que les cartes AB Electronics dont nous parlons dans certains de nos articles ou autres montage équivalent.

    Répondre à ce message

  • Le 5 juillet 2013 à 00:38, par nathan0407 En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    et la suite

    PNG - 58.9 ko
    • Le 5 juillet 2013 à 08:15, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bien ! Donc il y a un message d’erreur à la compilation indiquant qu’il te manque l’I2C sur ta machine. Essaie une recherche sur le nom de la référence inconnue dans Google avec le nom de ton OS ("i2c_smbus Ubuntu" par exemple).

    • Le 5 juillet 2013 à 09:48, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Je suggère la lecture des articles qui portent sur la RasPi et l’I2C sur notre site. Le moteur de recherche aidera à les trouver, mais on peut déjà aller faire un tour sur celui-ci : http://www.pobot.org/RasPi-I2C-Python-et-LCD.html

      On y voit par exemple un paragraphe relatif à l’installation du support SMBus, autrement dit System Message Bus, qui n’est d’autre qu’un bus I2C.

    • Le 25 juillet 2013 à 19:28, par nathan0407 En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      bonjour , j ai des probleme avec mon raspbery il me claque toute mes carte sd .
      j en suis a ma 4 eme carte toute de marque differente ( samsung, scan disck ect....)es ce que vous auriez une idée pourquoi
      ps mon alim fait 5v 600 ma

    • Le 25 juillet 2013 à 21:59, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,

      L’alimentation est en-dessous du courant requis (700 mA minimum). Donc des incidents peuvent plus fréquemment se produite et endommager la carte mémoire.

    • Le 26 juillet 2013 à 09:42, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Pour compléter la réponse faite par Julien, ce qui importe avant tout c’est la qualité de la stabilisation de l’alimentation.

      En effet, mesures à l’appui, la consommation de la RasPi est en-dessous des 600mA (sur la mienne j’ai mesuré dans les 430mA, que la session graphique soit utilisée ou non, ce qui indique au passage qu’aucune optimisation n’est faite au niveau de la mise en sommeil du hardware non sollicité).

      Le problème est que la plupart des blocs d’alimentation bon marché ont une stabilisation voisine du néant, et voient leur tension de sortie baisser bien avant d’arriver à la limite en courant indiquée dans leurs caractéristiques.

      C’est la raison pour laquelle on voit préconiser la plupart du temps une alim capable de délivrer 1A, de manière à être très éloigné du point où la courbe de stabilisation va commencer à s’effondrer.

      J’ai pu vérifier tout ceci en alimentant la RasPi avec une alimentation stabilisée de labo, dont j’ai réglé progressivement la limitation du courant jusqu’au seuil d’instabilité. J’étais bien en-dessous de 1A, et à une valeur dans l’ordre de grandeur cité plus haut. Il faut à ce niveau prendre en compte les pics fugitifs de consommation qui peuvent provoquer une chute de tension simultanée si la limite en courant de l’alimentation est en-dessous de leur valeur crête.

    Répondre à ce message

  • Le 30 juin 2013 à 00:49, par nathan0407 En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour , je n arrive pas a installer wiringpi ,je bloque depuis 4 jours comprend pas
    help

    PNG - 103.7 ko

    Répondre à ce message

  • Le 8 octobre 2014 à 16:23, par kouraichi En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour ,Je travaille actuellement sur un projet utilisant principalement le raspberry.sous le theme modbus tcp sur raspberry le probléme que j’arrive pas gerer les composant entre sortiee et aussi parmi les objectifs c’est developé une application gérant la connexion modbus /tcp sur la arte vous pouvez m’aider s’il vous plait

    • Le 14 octobre 2014 à 23:32, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonsoir,
      Les commentaires aux articles sont prévus pour poster des questions ou des commentaires sur les articles.
      Pour les demandes d’aides, utiliser le formulaire de contact, qui permettra d’initialiser une discussion par email, plus adaptée à ce type d’échanges.
      Cordialement
      Eric

    Répondre à ce message

  • Le 23 juillet 2014 à 17:06, par paul En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour j’ai un petit souci avec le wiringPi il me dit que j’ai pas la permission, pouvez vous m’aider ?

    PNG - 22.3 ko
    • Le 31 juillet 2014 à 14:05, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,
      Vous n’avez pas les droits d’écriture sur le répertoire /gpio.
      Vous pouvez soit modifier les droits de ce répertoire (sudo chmod +wx ../gpio/) soit utiliser la commande sudo pour récupérer le programme d’installation de wiringPi (sudo git clone ...).
      Cordialement,
      Julien.

    Répondre à ce message

  • Le 7 avril 2014 à 17:10, par Fetra En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour,
    Je travaille actuellement sur un projet utilisant principalement le raspberry. Je voudrais avoir des retours de votre part sur la faisabilité de celui-ci.
    En gros, je voudrais réaliser une espèce de "pédale de boucle" pour guitare électrique dont les fonctions principales seraient : Acquisition, traitement puis reconstitution du son. Tout ceci utilisant le raspberry.
    Est-il ainsi possible d’acquérir du signal son numérique avec le GPIO ?
    Et quelle bibliothèque faudrait-il installer pour permettre au raspberry de jouer les sons ainsi traités ?
    En vous remerciant déjà pour votre réponse.

    • Le 7 avril 2014 à 18:16, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,
      Il n’y a pas (à ma connaissance) de possibilité d’acquérir un signal audio sur les GPIO de la RasPi, et elle ne comporte pas d’entrée audio non plus. Certains ont réussi à faire des choses par le biais de cartes son USB (cf www.g7smy.co.uk/?p=283 par exemple). On retrouve quelques éléments via Google(raspberry audio acquisition).
      Ceci étant, indépendamment du problème de l’interface physique, je doute que la RasPi soit suffisamment musclée pour numériser un signal et le traiter en temps réel.
      Cordialement
      Eric

    • Le 7 avril 2014 à 18:47, par Fetra En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Merci beaucoup pour votre réponse.
      En somme j’avais prévu une partie numérisation avant la raspberry et seul le traitement en temps réel et la reconstituition se ferait par le raspberry. Le problème c’est que je ne sais par où commencer pour permettre au raspberry d’acquérir le signal déjà numérisé et de lui faire traiter.
      Cordialement
      Fetra

    • Le 7 avril 2014 à 19:03, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Tout dépend de la solution utilisée pour la numérisation. En fait c’est ce que font les cartes son USB sur lesquelles j’ai donné les pointeurs. La récupération des données est possible vie les libs Linux telles que Alsa et autres. L’article que j’ai référencé aborde le sujet me semble-t-il.
      Cordialement
      Eric

    Répondre à ce message

Un message, un commentaire ?

modération a priori

Attention, votre message n’apparaîtra qu’après avoir été relu et approuvé.

Qui êtes-vous ?

Pour afficher votre trombine avec votre message, enregistrez-la d’abord sur gravatar.com (gratuit et indolore) et n’oubliez pas d’indiquer votre adresse e-mail ici.

Ajoutez votre commentaire ici
  • Ce formulaire accepte les raccourcis SPIP [->url] {{gras}} {italique} <quote> <code> et le code HTML <q> <del> <ins>. Pour créer des paragraphes, laissez simplement des lignes vides.

Ajouter un document