Fermer

mars 13, 2019

Créez un tableau de bord automatisé qui détecte votre score avec un Raspberry Pi –

ES6 en action: let et const


Sur un coup de tête, juste avant Noël, je me suis acheté un mini-panier de basket-ball «over-the-door» de la NBA. Je ne savais pas trop ce que je ferais avec ça, mais avoir un panier de basket-ball pour mon bureau me semblait une bonne chose. En fin de compte, j'ai décidé d'expérimenter et de lui apporter une certaine connectivité en le connectant à un Raspberry Pi pour lui donner un affichage au tableau de bord. Voici comment cela s’est passé, avec des instructions étape par étape si vous souhaitez essayer de l’adapter et de l’améliorer!

Ce tutoriel n’est pas destiné à être utilisé comme guide de style pas à pas – faites exactement comme je l’ai fait – j’espère que vous utiliserez ce concept pour toutes sortes d’autres idées. Ajoutez un tableau de bord virtuel qui compte la fréquence à laquelle les personnes entrent dans votre bureau. Ou optez pour un autre sport (peut-être un mini moniteur de buts de football?). Ou utilisez un capteur entièrement différent, mais suivez les résultats visuellement avec un Raspberry Pi! Il y a tellement d'applications potentielles de cette technique. Essayez des choses et laissez-moi savoir comment vous allez!

Ce dont vous aurez besoin

Pour pouvoir suivre et faire quelque chose de similaire, voici une liste des éléments que j'ai utilisés (ou leur équivalent pour les

Une chose à noter – si vous n’avez pas d’écran 7 pouces pour votre Pi, vous pouvez également afficher le score sur un écran d’ordinateur situé à proximité. N'importe quel appareil de votre réseau local doté d'un navigateur Web et d'un écran fonctionnerait!

Le code

Voulez-vous sauter pour télécharger le code? C’est disponible sur GitHub ici .

Ce que j’ai assemblé

J’ai accroché mon nouveau cerceau de basket-ball à une porte munie d’un capteur à ultrasons fixé au cerceau pour le suivi d’un ballon placé dans le cerceau. En dessous se trouve un tableau de bord alimenté par Raspberry Pi – Je vous conseillerais plutôt de trouver des câbles plus longs pour pouvoir le connecter en dehors de la zone de chute du basket-ball.

Je vais expliquer pourquoi tout est comme ci-dessous – avec quelques suggestions pour ceux qui voudraient améliorer cette base!

Langues que nous utiliserons

  • JavaScript – Pour pouvoir suivre, vous aurez besoin de connaissances de base, mais nous n'aurons pas de lignes sur des lignes de code, les choses sont plutôt simples du côté de JS.
  • Node. js – Notre serveur de tableau de bord requiert des connaissances de base sur la manière d'exécuter npm et Node.

Configuration de notre Raspberry Pi

Si vous êtes tout à fait nouveau au Raspberry Pi et si vous n'avez rien configuré. pourtant, ne craignez rien! Il existe de nombreux guides pour la mise en place et c’est simple et agréable. La fondation Raspberry Pi dispose d'un guide étape par étape pour l'installation du système d'exploitation Raspbian à l'aide du gestionnaire de système d'exploitation NOOBS. Vous voudrez vous assurer que le système d'exploitation est en cours d'exécution avant de passer à une autre étape.

Configuration de l'écran tactile

J'ai assemblé mon tableau de bord connecté à l'aide d'un Raspberry Pi 3 avec écran tactile. Mon écran tactile et mon boîtier étaient déjà assemblés et serrés, car j’avais déjà utilisé ce Pi 3 pour d’autres projets. Cependant, si vous partez de zéro, la connexion n’est pas trop difficile. De plus, de nombreuses expéditions (comme la mienne) en ont déjà assemblé une partie, avec la carte d’adaptateur déjà vissée sur l’écran LCD. Si tel est le cas, la moitié des étapes sont déjà terminées! Les instructions pour assembler l’écran sont disponibles en ligne:

Configuration de l’affaire

Quand il s’agit de placer l’affaire autour de l’écran LCD et de Raspberry Pi, ce processus est également assez facile avec l’affaire que j’ai. J'avais déjà les miennes ensemble, mais voici les étapes générales à suivre:

  • Assurez-vous que votre carte microUSB est déjà insérée dans le Raspberry Pi et que vous êtes satisfait de son fonctionnement! Malheureusement, dans beaucoup de cas, vous ne pouvez pas sortir la carte une fois le cas en place. Mon cas lié ci-dessus est l'un de ceux-ci… alors assurez-vous que la carte est en bon état avant d'en perdre l'accès!
  • Placez le Pi avec l'écran en place à l'intérieur du boîtier
  • Disposez les câbles ruban et les câbles provenant du GPIO. ils ne sont donc pas gênants
  • Assurez-vous que les trous de vos ports USB et de ceux-ci se trouvent du bon côté de la partie la plus volumineuse du boîtier et alignés correctement.
  • Une fois que tout est parfaitement aligné, vissez-le. les quatre vis pour assembler le tout!
  • Allumez-le! Si vous constatez que l’écran se renverse, ne vous inquiétez pas, c’est un effet secondaire du fait que les fabricants de boîtiers alignent le pouvoir de sortir par le haut. Lorsque j’ai monté mon tableau de bord, j’ai monté avec l’alimentation qui sortait du bas, donc ce n’était pas un problème pour moi. Si c'est un problème pour vous:
    • Run sudo nano /boot/config.txt pour ouvrir la configuration pour le Pi
    • Puis ajoutez lcd_rotate = 2 à la fin, cela fera pivoter l'écran.
    • Appuyez sur Ctrl X et Ctrl Y pour enregistrer vos modifications.
    • Redémarrez votre Pi et, une fois chargé, il devrait fonctionner correctement!

Exécuter Node.js sur notre Raspberry Pi

, Raspbian a Node installé par défaut! Cependant, c'est une version plutôt ancienne de Node. Vous pouvez vérifier quelle version est installée sur votre Pi en ouvrant le terminal et en tapant:

node -v

La version 8.15.0 est installée sur mon Pi. Vous pouvez mettre à niveau en exécutant les commandes suivantes:


sudo su -
apt-get remove nodered -y
apt-get remove nodejs nodejs-legacy -y
apt-get supprimer npm -y
curl -sL https://deb.nodesource.com/setup_5.x | sudo bash -
apt-get install nodejs -y

Après avoir exécuté tous ceux-ci, si vous tapez à nouveau cette commande de version, vous devriez voir une version améliorée:

. node -v

Vous pouvez également vérifier que npm est correctement installé en exécutant:

npm -v

Le nœud étant exécuté sur notre périphérique, nous sommes prêts à obtenir un tableau de bord. Le serveur de nœud est en marche!

Notre tableau de bord Node.js

Le but de notre tableau de bord est le suivant:

  • Configurez un capteur à ultrasons surveillant le mouvement juste à l'intérieur du cerceau.
  • Notre serveur de nœud surveillera la distance. lectures de notre capteur à ultrasons.
  • Nous allons exécuter une simple page Web qui affiche le score en réaction à la détection par un serveur de nœud.
  • Envoyez des déclencheurs de score à notre page Web entre notre serveur de nœud et la page Web à l’aide de WebSockets.

Le rôle de notre serveur de nœud sera donc d’exécuter un serveur Web pour la page Web du tableau de bord, ping ou r capteur ultrasonique et envoyer des messages à notre page Web lorsque le mouvement d’une balle est repéré.

Voici notre code final destiné à ceux qui souhaitent simplement le copier et le coller pour l’essayer (ou le voir dans son ensemble). le comprendre).

 const http = require ('http'),
    express = require ('express'),
    app = express (),
    server = require ('http'). Server (app),
    bodyParser = require ('body-parser'),
    webpagePort = 8080,
    WebSocketServer = require ('ws'). Server,
    wss = new WebSocketServer ({serveur: serveur}),
    Gpio = require ('pigpio'). Gpio,
    MICROSECONDS_PER_CM = 1e6 / 34321, // nombre de microsecondes nécessaires au son pour parcourir 1cm à 20 degrés Celsius.
    trigger = new Gpio (23, {mode: Gpio.OUTPUT}),
    echo = new Gpio (24, {mode: Gpio.INPUT, alert: true});

let lastScoreTime = new Date ();

app.use (bodyParser.json ());

app.use (express.static (__ dirname + '/ public'));

app.use (function (err, req, res, next) {
  console.error (err.stack);
  res.status (500) .send ('Une erreur est survenue');
});

server.listen (webpagePort, function () {
  console.log ('Le serveur est en cours d'exécution sur' + webpagePort);
});

wss.on ('connexion', fonction connection (ws) {
  console.log ('WebSockets are ready!');
});

fonction broadcast (message) {
  si (message) {
    console.log ('diffusion' + message);
    wss.clients.forEach (fonction each (client) {
      client.send (message);
    });
  }
}

trigger.digitalWrite (0); // Assurez-vous que la gâchette est basse

const watchHCSR04 = () => {
  laisser startTick;

  echo.on ('alert', (niveau, tick) => {
    si (niveau == 1) {
      startTick = tick;
    } autre {
      const endTick = tick;
      const diff = (endTick >> 0) - (startTick >> 0);
      let distance = diff / 2 / MICROSECONDS_PER_CM;
      let currentScoreTime = new Date ();
      console.log (distance);
      si (distance 1000)) {
        lastScoreTime = currentScoreTime;
        broadcast ('SCORE:' + (diff / 2 / MICROSECONDS_PER_CM));
      }
    }
  });
};

watchHCSR04 ();

setInterval (() => {
  trigger.trigger (10, 1); // Réglage du déclencheur haut pour 10 microsecondes
}, 100); // Déclenchez toutes les 100 millisecondes 

Nous allons maintenant examiner chaque partie et expliquer ce qu’elle se passe.

Nous commençons avec un ensemble typique de constantes permettant d’exécuter un serveur Node Express. Ceci est un serveur Web qui s'exécutera sur le port 8080. Express est un framework pour Node.js que nous utilisons car il est simple et convivial de faire fonctionner un serveur Web!

 const http = require ('http') ,
    express = require ('express'),
    app = express (),
    server = require ('http'). Server (app),
    bodyParser = require ('body-parser'),
    webpagePort = 8080, 

Ensuite, nous continuons à définir des constantes, mais celles-ci s'appliquent à notre serveur WebSocket. Les WebSockets sont le moyen par lequel nous terminons les messages entre notre serveur et la page Web affichant notre score. À l'aide de WebSockets, cette page Web peut être ouverte sur de nombreux moniteurs et sera mise à jour tous. J'utilise uniquement l'écran Raspberry Pi, mais vous pouvez vous déchaîner et disposer de grands moniteurs pour créer quelque chose d'assez extraordinaire si vous le souhaitez.

Pour WebSockets, il existe quelques bibliothèques différentes, mais j'aime bien utiliser ws . Il se concentre sur la fourniture de WebSockets d'une manière que les navigateurs modernes puissent comprendre de manière native en utilisant la norme WebSockets (nous n'avons donc pas besoin de faire fonctionner une bibliothèque JavaScript sur le navigateur).

Dans notre code, nous définissons le WebSocketServer. pour notre serveur puis créez un nouveau WebSocketServer que nous affectons à la constante wss .

 WebSocketServer = require ('ws'). Server,
wss = new WebSocketServer ({serveur: serveur}), 

Enfin, les dernières constantes sont toutes destinées à permettre l'écoute des lectures provenant de notre capteur à ultrasons. Pour lire les données du capteur à ultrasons, nous utilisons la bibliothèque de nœuds pigpio . Cela nous permet d’accéder aux broches GPIO (entrée / sortie à usage général) le long du bord supérieur de la carte – c’est ici que nous connectons notre capteur à ultrasons.

 Gpio = require ('pigpio'). Gpio, 

Nous ajoutez ensuite un calcul fourni par l'exemple de capteur à ultrasons de pigpio dans leurs documents GitHub . Il calcule le nombre de microsecondes nécessaires au son pour parcourir 1 cm à 20 degrés Celsius. Nous utiliserons ce calcul lorsque le capteur à ultrasons émettra un son, puis écoutera une réponse – nous utiliserons le MICROSECONDS_PER_CM pour calculer la distance de la réponse.

 MICROSECONDS_PER_CM = 1e6 / 34321, // numéro En microsecondes, il faut un son pour parcourir 1 cm à 20 degrés Celsius 

Ensuite, les deux dernières constantes font référence aux deux broches GPIO auxquelles nos capteurs à ultrasons seront connectés. Nous aurons la broche 23 en tant que broche de sortie appelée trigger et la broche 24 en tant que broche d'entrée nommée echo .

 trigger = new Gpio (23, {mode: Gpio.OUTPUT} ),
echo = new Gpio (24, {mode: Gpio.INPUT, alert: true}); 

La ligne suivante permet d’envoyer et d’interpréter des chaînes JSON.

 app.use (bodyParser.json ()); [1965]. 19659051] Nous avons ensuite configuré quelques éléments supplémentaires pour notre serveur Web. Nous avons d’abord défini l’emplacement de nos fichiers HTML / CSS / JS statiques. C’est là que notre serveur Express cherchera lorsque nous tenterons d’accéder à Raspberry Pi sur le port indiqué plus haut. 

 app.use (express.static (__ nom de répertoire + '/ public')); 

Nous avons ensuite configuré ce qui devrait se produire lorsqu'une erreur se produit, nous lui demandons de consigner l'erreur sur la console, puis de renvoyer une erreur 500.

 app.use (function (err, req, res, next) {
  console.error (err.stack);
  res.status (500) .send ('Une erreur est survenue');
}); 

Pour exécuter notre serveur Web, nous appelons le code suivant. Un message de la console s’affiche lorsqu’il s’exécute avec succès.

 server.listen (webpagePort, function () {
  console.log ('Le serveur est en cours d'exécution sur' + webpagePort);
}); 

Une fois notre serveur Web configuré, nous établissons notre connexion WebSocket. Le serveur de nœud est notre serveur WebSockets - il diffusera des messages aux clients connectés (notre navigateur Web sur le Raspberry Pi). Le code suivant définit quoi faire lorsque notre serveur WebSocket est prêt. Cela se produit lorsque l'événement "connexion" se produit. Lorsque cela se produit, nous envoyons un fichier console.log . Si nous ne le voyons pas dans la console, nous savons que quelque chose a mal tourné à la fin du serveur WebSocket.

 wss.on ('connexion') , fonction de connexion (ws) {
  console.log ('WebSockets are ready!');
}); 

Nous suivons le fait que nous créons une fonction personnalisée qui enverra un message WebSocket à tous les clients connectés. Juste avant d'envoyer ce message, il enregistre un message indiquant que le message est en cours de diffusion par le serveur.

 function broadcast (message) {
  si (message) {
    console.log ('diffusion' + message);
    wss.clients.forEach (fonction each (client) {
      client.send (message);
    });
  }
} 

Le code ci-dessous concerne notre capteur à ultrasons. Cela vient en grande partie directement de l'exemple de le pigpio GitHub page . Je n’avais pas besoin de trop changer pour que cela fonctionne correctement pour ce scénario.

Nous commençons par régler notre gâchette sur bas (ou 0 ) au départ (nous le déclencherons alors à haute lorsque nous voulons le chronométrer).

 trigger.digitalWrite (0); // Assurez-vous que le déclencheur est faible 

La bibliothèque pigpio peut réagir aux modifications de l'état des broches GPIO en utilisant un élément appelé «alertes». La page npm de la bibliothèque pigpio indique qu’elle suit ces «exactes à quelques microsecondes», ce qui nous suffit. Nous avons mis en place une fonction appelée watchHCSR04 qui surveillera les ticks des broches GPIO et si elle en reçoit une, nous vérifions combien de temps elle reste haute (ou allumée), nous travaillons ensuite sur cette base. heure et calcul MICROSECONDS_PER_CM combien de cms l'élément le plus proche ayant provoqué un ping a été renvoyé.

Si la distance est inférieure à 11 cm, nous déclenchons une diffusion de notre serveur WebSocket qui le laisse Les clients de notre navigateur Web savent que des mouvements ont été détectés. Après quelques essais et erreurs, je me suis décidé à choisir 11 cm, tenant la balle à différents endroits dans le cerceau pendant que mon console.log courait pour voir les valeurs rapportées par le capteur à ultrasons pendant la présence de la balle.

Nous avons également vérifie si l'heure actuelle est la même que la dernière fois qu'un score a été lu - si cela ne fait pas encore plus de 1000 millisecondes, nous ne déclencherons pas de nouveau point (par exemple, si la balle vibre un peu dans le cerceau, cela ne ne donnez pas plus de points à quelqu'un!). C’était quelque chose que j’avais ajouté après avoir repéré quelques cas de double comptage de points.

 const watchHCSR04 = () => {
  laisser startTick;

  echo.on ('alert', (niveau, tick) => {
    si (niveau == 1) {
      startTick = tick;
    } autre {
      const endTick = tick;
      const diff = (endTick >> 0) - (startTick >> 0);
      let distance = diff / 2 / MICROSECONDS_PER_CM;
      let currentScoreTime = new Date ();
      console.log (distance);
      si (distance 1000)) {
        lastScoreTime = currentScoreTime;
        broadcast ('SCORE:' + (diff / 2 / MICROSECONDS_PER_CM));
      }
    }
  });
};

watchHCSR04 (); 

Afin de provoquer un ping, nous devons régler notre déclencheur sur haut (ou 1 ) afin de donner un premier son de notre capteur à ultrasons à mesurer. Dans le dernier bit de notre code serveur, nous le faisons toutes les 100 millisecondes. C’est beaucoup plus fréquent que l’exemple de pigpio car je voulais avoir plus de chance d’observer du mouvement dans le cerceau. J'ai ajusté cette valeur de plus en plus bas après quelques tests (un ballon peut se déplacer rapidement!)

 // Déclenche une mesure de distance une fois par seconde
setInterval (() => {
  trigger.trigger (10, 1); // Réglage du déclencheur haut pour 10 microsecondes
}, 100); 

Notre fichier Package.json

Nous aurons également besoin de nos dépendances répertoriées dans notre fichier package.json pour que nous puissions garder une trace de ce que notre projet doit exécuter! Mon fichier package.json ressemble à ceci:

 {
  "nom": "hoopspi",
  "version": "0.0.1",
  "description": "Un tableau de bord connecté pour mon panier de basket",
  "main": "index.js",
  "dépendances": {
    "analyseur de corps": "^ 1.15.2",
    "express": "^ 4.14.0",
    "gulp": "^ 3.9.1",
    "pigpio": "^ 1.2.1",
    "ws": "^ 1.1.1"
  },
  "devDependencies": {},
  "auteur": "Patrick Catanzariti",
  "licence": "MIT"
} 

Il contient toutes nos dépendances utilisées dans le serveur de nœud ci-dessus. Je vous recommande simplement de copier-coller ce qui précède dans un nouveau fichier package.json dans le même dossier que votre fichier index.js . Une fois que vous avez cela dedans, lancez la commande suivante dans votre console pour installer tout ce dont vous avez besoin:

npm install

Notre code HTML

Le code HTML est extrêmement simple:



    
        
        
        
         HoopsPi 
        
        
    
    
        
%MINIFYHTML52a3d3b719c5b4f53f9cc3b30445667214%%MINIFYHTML52a3d3b719c5b4f53f9cc3b30445667215%

Notre JavaScript front-end

Notre JavaScript front-end ressemble à ceci:

 (function () {
    var ws = new WebSocket ('ws: //192.168.1.133: 8080', 'json');
    score var = 0;

    ws.onopen = function () {
        console.log ('Websocket est ouvert');
        ws.send ('Salut de HoopPi!');
        document.getElementById ('score'). innerHTML = score;
    };

    ws.onmessage = function (event) {
        if (event.data.indexOf ('SCORE:')! = -1) {
            score ++;
            document.getElementById ('score'). innerHTML = score;
        }
        console.log ('Message was', event.data);
    };

    ws.onerror = function (error) {
       console.log ('Erreur détectée:' + error.data);
    }
} ()); 

Voyons ce qui se passe! Nous commençons par configurer un WebSocket pour surveiller l'adresse IP de notre Raspberry Pi (utilisez la commande ifconfig dans la console pour le savoir). Nous avons également réglé notre score initial sur le chargement de page à 0.

 (function () {
    var ws = new WebSocket ('ws: //192.168.1.133: 8080', 'json');
    var score = 0; 

Après cela, nous ouvrons ce WebSocket, envoyons un message à la console et à notre WebSocket (cela ira au serveur mais nous n'utiliserons pas ce message!) et nous définirons notre score visible. sur la page Web de notre score variable:

 ws.onopen = function () {
    console.log ('Websocket est ouvert');
    ws.send ('Salut de HoopPi!');
    document.getElementById ('score'). innerHTML = score;
}; 

Lorsque nos WebSockets voient un message (il s’agit des messages de notre Pi), nous vérifions s’il contient le contenu de "SCORE:" et, le cas échéant, nous augmentons notre nombre de scores de un. Techniquement, au basket-ball, vous avez au moins deux points… mais je n’ai pas le moyen de détecter des tirs à trois points, j’ai donc pensé qu’un point était assez simple pour l’instant. Un jour! Je consigne également les données qui sont entrées dans la console du navigateur afin que nous puissions vérifier si quelque chose ne va pas.

 ws.onmessage = function (event) {
    if (event.data.indexOf ('SCORE:')! = -1) {
        score ++;
        document.getElementById ('score'). innerHTML = score;
    }
    console.log ('Message was', event.data);
}; 

Enfin, s’il existe des erreurs, nous les enregistrons dans la console:

 ws.onerror = function (error) {
       console.log ('Erreur détectée:' + error.data);
    }
} ()); 

Câbler les choses

Pour que tout ce qui précède fonctionne, il faut que tout soit correctement branché! Le câblage principal que nous avons à faire est de connecter notre capteur à ultrasons aux broches GPIO de notre Raspberry Pi mentionnées ci-dessus.

Mes broches GPIO ressemblaient à ceci:

regardez exactement ce qui était connecté où.

Nous devons être prudents lors de la connexion de notre capteur à ultrasons. La sortie du capteur à ultrasons est de 5 V, mais la tension maximale des broches GPIO du Raspberry Pi est de 3,3 V; nous devons donc inclure des résistances afin de ne pas endommager les broches GPIO. J'ai personnellement utilisé une résistance de 1K et de 2K, mais l'exemple de la bibliothèque pigpio utilise plutôt des résistances de 330 et 470 ohms (je ne les avais pas et les alternatives de résistance me semblaient bien, je vous recommande de suivre la recommandation de pigpio).

Pour connecter le capteur à ultrasons à la carte de connexion, je l’ai connecté à l’aide de câbles de démarrage blancs afin qu’il y ait un peu plus de longueur entre la carte et notre Pi. Le capteur à ultrasons sera collé sous le cerceau, nous en avons donc besoin gratuitement de la planche à pain pour le faire! Cependant, avant de le connecter comme ça, j’ai connecté le capteur à ultrasons directement à la carte juste à tester (il était beaucoup plus facile de tester le capteur fonctionnait pendant qu’il était calé dans la carte, avant de le monter sur le cerceau!) .

Après l’ajout des câbles de démarrage, il ressemble plus à ce qui suit:

L’ensemble du câblage est présenté dans le schéma ci-dessous. Nous connectons la broche VCC de notre capteur à ultrasons à notre broche 5V (celle qui n’est pas utilisée par l’écran LCD), la broche GND de notre capteur à ultrasons est connectée à la terre sur le Pi, mais nous plaçons également une résistance de 470 ohm entre la rangée au sol et la rangée reliées à la broche 24 du Pi. La résistance de 330 ohms va de la rangée reliée à notre écho sur le capteur à ultrasons à la rangée reliée à la broche 24.

En ce qui concerne l’accrochage au cerceau de basket-ball, j’ai choisi la voie. d’utiliser des bandes de suspension pour coller mon Raspberry Pi dans son étui contre le mur. En particulier, j'ai utilisé Commandes de bandes de suspension blanches à taille moyenne de 5,4 kg . J'ai enlevé le dos amovible de la valise Pi et je l'ai collé autant que j'ai pu:

J'ai ensuite replacé le dos contre le mur, en alignant la valise dans son boîtier pour s'assurer qu'elle est bien droite. . J’ai collé le mien directement sous le cerceau - ce qui, rétrospectivement, n’était pas le meilleur endroit pour cela. Je recommanderais peut-être de le mettre de côté en fonction de la longueur des câbles de démarrage que vous avez. Je retirai doucement le boîtier Pi de l'arrière une fois que je l'avais aligné pour pouvoir appuyer sur le dos du boîtier afin de le coller aussi fermement que possible au mur.

J'étais tellement inquiet de savoir si le Pi resterait coincé que j'ai placé un sac de haricots sous le cerceau juste pour être en sécurité! Heureusement, après plus d’une semaine passée à être suspendue là-bas et frappée plusieurs fois par un ballon de basket… elle est toujours pendante! Cette bande est magique.

J'ai attaché mon capteur au départ avec la même bande sur le cerceau, mais cela signifiait que j'étais limité à un endroit suffisamment plat pour le cerceau. tenez-vous-en à… cela a fini par être un peu trop bas et le filet de basket-ball a souvent gêné le suivi. Voilà donc comment je vous recommanderais de ne pas coller le capteur à !

Au lieu de cela, j’ai enlevé le capteur de cet endroit et utilisé blutack pour le coller directement sous le cerceau .

 Le capteur à ultrasons s'est coincé juste au-dessous du cercle

Mon placement le plus efficace du capteur à ultrasons!

Le filet a quand même réussi à faire obstruction. J'ai donc utilisé l'un des colliers de câble de l'emballage du cercle NBA. pour lier une partie du réseau pour éviter les interférences:

 Lier un peu le réseau pour éviter les interférences

Ce n'est toujours pas parfait, mais il a semblé aider un peu!

J'ai aussi utilisé un de ces colliers pour maintenir les câbles reliant le capteur à ultrasons ensemble.

En action

Pour tout utiliser, nous devons exécuter le serveur Node.js à l’aide du mot clé sudo car notre application Node doit disposer de solides autorisations pour pouvoir accéder à les broches GPIO. Pour exécuter notre serveur Node.js, nous entrons ce qui suit:

sudo node index.js

Cela devrait s'exécuter et se présenter comme suit dans la console:

 La console fonctionnait correctement.

Si nous ouvrons le navigateur de notre Raspberry Pi et allons à http: // localhost: 8080 nous devrions voir notre tableau de bord prêt à compter!

Personnellement, je préfère le chrome sur mon Raspberry Pi, car je préfère son mode plein écran et son navigateur plus récent. Si vous n'avez pas de chrome sur votre Raspberry Pi, il est simple à installer avec deux commandes:

L'habituel:

 sudo apt-get update 

Suivi par:

 sudo apt-get install chromium- browser --yes 

Il devrait alors être visible dans la section “Internet” du menu de votre Pi:

 Menu, Internet, Navigateur Web Chromium "width =" 966 "height =" 840 "class =" size-full wp-image-171362

Où Chromium sera installé

La meilleure partie de ce qu'il en est d'une page Web est qu'il est facilement personnalisable! J'ai personnalisé mon thème pour qu'il corresponde au thème Phoenix Suns:

 La version du tableau de bord sur le thème des Suns de Patrick "width =" 1024 "height =" 683 "class =" wp-image-171363

Mes soleils version thématique du tableau de bord

Conclusion

En fin de compte, le suivi du score du cerceau de basket-ball fonctionne bien, mais pourrait certainement être porté au niveau suivant. Je suis tenté d’acheter un capteur de distance IR pour voir s’il suit plus précisément. Il y a aussi beaucoup plus qui peut être fait avec le tableau de bord basé sur un navigateur - vous pouvez ajouter un compte à rebours ou un mode deux joueurs pour pouvoir jouer à tour de rôle avec un ami!

Si vous construisez quelque chose de similaire avec le concept initial ci-dessus, J'aimerais entendre parler de ce que vous avez construit! Faites-moi savoir dans les commentaires ci-dessous ou contactez-moi sur Twitter à l'adresse @thatpatrickguy .

D'autres guides Raspberry Pi sur SitePoint

Si vous souhaitez en faire plus avec votre Raspberry Pi, [1965914] Patrick Catanzariti "class =" avatar avatar-96 wp-utilisateur-avatar wp-utilisateur-avatar-96 alignnone photo "/>

PatCat est le fondateur de . ] Dev Diner un site qui explore le développement de technologies émergentes telles que la réalité virtuelle et augmentée, l’Internet des objets, l’intelligence artificielle et les wearables. Il est un éditeur contribuant de SitePoint pour les technologies émergentes, un instructeur de SitePoint Premium et O'Reilly, un développeur de Meta Pioneer et indépendant qui aime chaque occasion de bricoler avec quelque chose de nouveau dans une démo technologique.





Source link

0 Partages
Revenir vers le haut