Début avec les broches Raspberry Pi GpiO dans Node.js

SitePoint Internet of Things Week Special! Cette semaine, nous publierons une série d'articles sur l'intersection d'Internet et du monde physique, alors gardez un œil sur les balises IoT pour les dernières mises à jour.

L'Internet des objets est à la mode de nos jours. Dans le domaine de l'informatique physique, nous avons de nombreuses idées qui peuvent être mises en pratique, et il est facile de se livrer à la programmation du monde dans lequel nous vivons! Avec le Raspberry Pi et la planche à pain, quelle est la prochaine étape?

Cet article explorera comment utiliser Node.js pour accéder aux broches GPIO d'un Raspberry Pi. Avec la broche GPIO, vous pouvez programmer directement le matériel. L'API JavaScript rend ce processus transparent. Ces API sont des abstractions de techniques communes et sont accessibles de n'importe où. L'interprète Node.js s'exécute dans un seul processus, ce qui ouvre de nouvelles façons d'écrire du code testable. La partie la plus excitante pour moi est que vous pouvez écrire des tests unitaires, frapper des points d'arrêt et vérifier le code comme vous le feriez pour n'importe quel autre programme JavaScript, ce qui peut être fait sur votre ordinateur.

Commençons.

Points clés

• Les épingles d'entrée / sortie courantes (GPIO) du Raspberry Pi sont accessibles à l'aide de Node.js, permettant à la programmation du matériel directement. Ces épingles sont comme des commutateurs, recevant des entrées ou envoyant une sortie au monde physique, et l'API JavaScript rend ce processus transparent.
• L'API GPIO est un wrapper pour lire ou écrire des fichiers de périphériques, et l'API du système de fichiers peut être un concept que vous connaissez déjà. Dans les systèmes de type UNIX, GPIO se comporte comme tout autre fichier normal, qui offre la liberté de gérer les solutions.
• La méthode axée sur le test est très adaptée à l'Internet des objets. Dans l'informatique physique, vous ne voulez pas expédier du matériel du monde entier pour déboguer le code. À l'aide d'une approche axée sur le test, vous pouvez obtenir des commentaires immédiatement et vous assurer que la solution fonctionne.
• En utilisant l'API GPIO, il peut être simplifié en un wrapper autour du module FS, créant du code propre et testable. Cet article le démontre en utilisant la démonstration effective du scintillateur de l'API montrée.

Qu'est-ce que GPIO?

GPIO signifie une entrée / sortie générale. Ce sont les épingles à côté du côté Raspberry Pi, la prise de sortie vidéo jaune. Voici à quoi ils ressemblent.

Source: Raspberry Pi

Celles-ci peuvent être considérées comme un moyen de se connecter d'un Pi framboise au monde extérieur. Cela vous permet d'écrire des programmes qui ne s'exécutent pas sur l'écran de votre ordinateur. Chaque broche ressemble à un interrupteur qui peut être activé ou désactivé. Vous pouvez recevoir des entrées du monde physique ou envoyer une sortie. La carte de base a 26 épingles, dont 9 sont des épingles de puissance ou de terre. La broche de terre est située à l'extrémité de chaque circuit où le courant doit s'écouler. La carte Raspberry PI mise à jour ajoute également un ensemble supplémentaire de 14 broches.

Si vous souhaitez en savoir plus sur les broches GPIO, ce graphique en ligne fournit tout ce que vous devez savoir sur chaque broche pour une utilisation. Il existe d'innombrables entrées / sorties et broches de terre. Ces broches sont à la base de l'informatique physique. Selon votre objectif, vous pouvez utiliser autant d'épingles que vous le souhaitez.

Simuler FS!

Je sais ce que vous pensez, qu'est-ce que FS exactement, et pourquoi dois-je m'en soucier? Dans un système d'exploitation de type Unix, un fichier de périphérique est un pilote qui ressemble à un fichier. Autrement dit, le pilote de périphérique est un fichier! Devinez quoi? L'API GPIO est un emballage pour lire ou écrire des fichiers de périphériques. Les API du système de fichiers peuvent être des concepts que vous connaissez déjà. Si vous n'avez jamais utilisé de fichiers dans Node.js, je vous suggère de consulter le module FS et le système de fichiers dans Node.js. FS est l'abréviation de "Système de fichiers", vous permettant de lire ou d'écrire dans des fichiers normaux. Il n'y a rien de sophistiqué ici, tout ce que nous faisons, c'est par exemple WriteFile (), laissant le GPIO gérer le reste. L'astuce consiste à savoir quel fichier écrire quoi écrire.

Il existe un package NPM pratique appelé MOCK-FS, qui peut nous aider avec les tests unitaires. À l'aide de cette bibliothèque, vous pouvez simuler n'importe quel fichier sur n'importe quel système de fichiers en mémoire. La chose la plus importante est que nous ne traitons que les fichiers, et c'est tout ce que nous devons faire. Dans les systèmes de type Unix, GPIO se comporte de la même manière que tout autre fichier normal. Cela nous donne la liberté de choisir comment gérer cette solution.

Le cœur de la bibliothèque Mock-FS est la fonction Mock ({}). Il reçoit un paramètre qui est un objet JavaScript. Dans ce paramètre, vous pouvez créer n'importe quel fichier souhaité. La beauté ici est que tout fonctionne en mémoire, vous pouvez donc faire des tests unitaires autant que vous le souhaitez. L'interprète s'exécute en un seul processus, ce qui signifie que le module FS peut être écrasé au moment de l'exécution. JavaScript est un langage dynamique, nous pouvons donc simuler tous les modules disponibles dans le processus actuel.

Une fois que vous avez écrit de bons tests unitaires sur GPIO, l'interface GPIO a plus de sens. Ce que j'aime, c'est que vous pouvez obtenir une couverture de test automatisée et une solution propre. Les tests unitaires améliorent la lisibilité du code car il vous montre clairement à quoi sert l'API.

Alors faisons-le.

Test d'unité Test de tout contenu

Ouvrir une épingle avec "out" et le tester:

it('opens a pin with out', function (done) {
  mock({
    '/sys/class/gpio/gpio23/direction': ''
  });

  gpio.open(16, 'out', function () {
    const direction = fs.readFileSync('/sys/class/gpio/gpio23/direction').toString();

    should(direction).equal('out');

    done();
  });
});

La mise en œuvre de ce test doit cartographier la broche physique 16 à la broche 23 BCM dans le GPIO. Le numéro BCM est le numéro de broche Broadcom que le noyau voit dans le pilote de périphérique. Le pilote de périphérique GPIO décrit l'emplacement du fichier de périphérique. Comme indiqué, pour allumer la broche, écrivez la chaîne "out" sur / direction. Cela indique au GPIO que nous voulons écrire cette broche. Une fois terminé, vérifiez si le fichier contient le contenu requis. Mock vient de la bibliothèque Mock-FS, qui est le système de fichiers standard dans Node.js. Le noyau indique où se trouve le chemin - 3.18.x et plus tard se trouve dans / sys / class / gpiO.

Pour écrire à une épingle sur la carte et le tester, vous pouvez effectuer ce qui suit:

it('writes to a pin with a high value', function (done) {
    mock({
      '/sys/class/gpio/gpio23/value': '0'
    });

    gpio.write(16, 5, function () {
      const value = fs.readFileSync('/sys/class/gpio/gpio23/value').toString();

      should(value).equal('1');

      done();
    });
  });

Il existe des similitudes entre gpio.open () et gpio.write (). Utilisez une opération d'écriture, qui écrit dans le fichier / valeur. Pour la vérification de l'intégrité, j'ai écrit une valeur très élevée de 5, mais nous nous attendons à ce que le résultat du test soit 1. GPIO ne reçoit que des valeurs élevées ou faibles, tout comme le binaire.

J'ai obtenu les détails d'implémentation de PI-GPIO. Cette bibliothèque vous offre un bon aperçu de chaque position PIN. Vous pouvez également rechercher des fichiers de périphérique sur le noyau. Quoi qu'il en soit, mon objectif est de vous donner une bonne compréhension des bases afin que vous puissiez obtenir une image claire.

Allons-nous fou, comment atteignez-vous les points d'arrêt des tests unitaires? J'utilise WebStorm pour le faire, et encore une fois, j'utilise n'importe quel moyen pour que vous vous sentiez à l'aise:

La clé de l'utilisation d'une méthode de programmation raisonnable consiste à raccourcir la boucle de rétroaction requise pour trouver des erreurs. Les tests unitaires sont un excellent moyen de resserrer la boucle et d'obtenir des commentaires instantanés.

Pour plus de simplicité, j'écris à une seule broche. Le reste du GPIO est résumé de la même manière. Ouvrez une épingle et dites-lui ce que vous voulez en faire. Lisez ou écrivez des épingles, quoi que vous ayez besoin. L'API de bas niveau est le fichier de périphérique, vous pouvez donc choisir comment programmer chaque broche.

Demo clignotant

Pour enrichir chaque test unitaire, regardons certaines variables communes:

var sysFsPath = '/sys/class/gpio/gpio';
var pinMapping = {
  '16': 23
};

ci-dessus, j'ai défini la carte PIN et le chemin du pilote vers le pilote de périphérique dans GPIO. Le code suivant voit le code pour les épingles d'ouverture et d'écriture:

function open(pinNumber, direction, callback) {
  const path = sysFsPath + pinMapping[pinNumber] + '/direction';

  fs.writeFile(path, direction, (callback || noOp));
}

function write(pinNumber, value, callback) {
  const path = sysFsPath + pinMapping[pinNumber] + '/value';
  value = !!value ? '1' : '0';

  fs.writeFile(path, value, 'utf8', callback);
}

function noOp() {}

Comme indiqué, toutes les opérations sont d'écrire WriteFile () dans le fichier de périphérique. S'il n'y a pas de rappels, NOOP est un rappel virtuel. Avec ce détail de mise en œuvre, j'ai passé le test de passe et j'étais sûr que cela fonctionnerait. La valeur de l'opération d'écriture garantit qu'elle sera définie sur haut ou bas («0» ou «1»).

Enfin, une démonstration de scintillateur valide utilisant l'API ci-dessus:

gpio.open(16, 'out', function () {
  var on = 0;

  var blinker = setInterval(function () {
    gpio.write(16, on, function () {
      on = (on + 1) % 2;

      console.log('ON = ' + on);
    });
  }, 1000);

  setTimeout(function () {
    clearInterval(blinker);
  }, 12000);
});

setInterval () est appelé une fois par seconde, et dans le rappel, je lui dis de changer les épingles à l'aide du module. Le scintillateur a des intervalles, Settimeout () l'utilise pour l'effacer après 12 secondes. Le rappel dans setTimeout () termine le travail et termine le programme.

Pour exécuter l'exemple de code, tapez:

sudo npm start

(vous avez besoin de l'autorisation administratrice pour accéder à GPIO sur le Raspberry Pi)

J'espère que d'après cette démo, le GPIO a l'air plus intuitif. Il s'attend à utiliser la direction pour allumer une broche. Vous écrivez ensuite les épingles et laissez le GPIO gérer le reste des détails.

Conclusion

La méthode axée sur le test est très adaptée à l'Internet des objets. Dans l'Internet des objets, votre imagination est la limite. Le Raspberry Pi peut être déployé n'importe où dans le monde - dans l'informatique physique, vous ne voulez pas expédier du matériel dans le monde pour déboguer le code. À l'aide d'une approche axée sur le test, vous pouvez obtenir des commentaires immédiatement et vous assurer que la solution fonctionne. Vous pouvez augmenter la productivité et resserrer la boucle de rétroaction.

Ce que j'aime dans l'API GPIO, c'est qu'il peut être simplifié en un wrapper autour du module FS. Cela vous donne une liberté totale d'écrire du code propre et testable.

Les démos d'échantillons restants ont été téléchargés sur github.

FAQs sur l'utilisation des broches Node.js et GPIO sur Raspberry Pi

• Qu'est-ce que Node.js et comment l'utiliser avec les broches GPIO du Raspberry Pi? Node.js est un environnement d'exécution JavaScript qui vous permet d'exécuter du code JavaScript sur un Raspberry Pi. Vous pouvez l'utiliser pour contrôler et interagir avec les broches GPIO (entrée / sortie générale) qui sont utilisées pour connecter des composants matériels externes à un Raspberry Pi.

• utilise-t-il des broches Node.js et GPIO sur un Raspberry Pi nécessite un matériel spécial? Vous avez besoin d'une carte Raspberry Pi, et peut-être certains composants externes tels que les LED, les capteurs ou les relais, selon votre projet. Pour commencer, vous devriez également avoir une planche à pain et quelques cavaliers pour connecter ces composants aux broches GPIO.

• Comment installer Node.js sur un Raspberry Pi? Vous pouvez utiliser le gestionnaire de packages APT ou le télécharger et l'installer à partir du site Web Node.js pour installer Node.js sur le Raspberry Pi. Assurez-vous d'utiliser la version compatible ARM de Node.js pour votre modèle Raspberry Pi spécifique.

• Que sont les broches GPIO et comment les identifiez-vous sur une carte Raspberry Pi? La broche GPIO est une broche sur le Raspberry Pi qui peut être utilisée pour les entrées ou sorties numériques. Ils sont marqués de nombres et peuvent être identifiés à l'aide de diagrammes de broches GPIO spécifiques à votre modèle Raspberry Pi.

• Comment accéder aux broches GPIO dans Node.js? Vous pouvez accéder aux broches GPIO dans Node.js à l'aide de bibliothèques comme RPI-GPIO, ONOFF ou PigPio. Ces bibliothèques fournissent des API pour contrôler et interagir avec les broches GPIO dans le code JavaScript.

• Dans mon projet Node.js, est-il possible d'utiliser des broches GPIO pour l'entrée et la sortie? Oui, vous pouvez configurer les broches GPIO en entrée et en sortie dans votre projet Node.js. Vous pouvez lire le nombre de capteurs connectés à la broche d'entrée et les LED de contrôle, moteurs ou autres dispositifs connectés aux broches de sortie.

• est-il possible d'utiliser la broche GPIO dans Node.js pour PWM (modulation de largeur d'impulsion) pour contrôler les tâches telles que la luminosité ou la vitesse? Oui, vous pouvez PWM en utilisant certaines broches GPIO sur le Raspberry Pi pour contrôler la luminosité, la vitesse du moteur, etc. La bibliothèque telle que PigPio prend en charge le PWM et est compatible avec Node.js.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!