Clever Geek Handbook

Le gant intelligent pour les cyclistes





Traduit de instructables.com, auteur du projet: Matlek



Dans cet article je décrirai en détail le processus de fabrication d'un «gant intelligent» et de son panneau LED, conçu pour augmenter la sécurité des cyclistes et autres personnes voyageant sur la route. Tout d'abord, vous pouvez voir une petite démonstration de son fonctionnement:





Comment ça fonctionne



Le gant contient une carte Arduino qui collecte les données du gyroscope et de l'accéléromètre. Le code utilise le modèle tinyML du "tiny machine learning" et reconnaît les gestes: chaque mouvement de la main est analysé et transformé en signal (la main est inclinée à gauche, à droite, en avant, en arrière, etc.). Le signal est envoyé via Bluetooth (BLE) à un autre microcontrôleur auquel une matrice de LED est connectée (qui, par exemple, peut être attachée à un sac à dos). Selon le signal reçu, la matrice émet certaines séquences de caractères - afin que les autres coureurs et cyclistes puissent comprendre ce que le cycliste va faire (par exemple, il peut s'agir de flèches à gauche, à droite ou de texte).



















Origine du projet



Tout d'abord, je fais du vélo pour me rendre au travail et je passe plus d'une heure par jour en selle (parcourant environ 22 km). C'est toujours intéressant, mais je vis dans l'une des villes les plus peuplées de France, où les accidents de voitures et de cyclistes sont fréquents. Marseille est également la pire ville pour les cyclistes en France - il y a une pénurie désespérée de pistes cyclables . Par conséquent, ce projet vise à la fois à accroître la sécurité des cyclistes et à tenter d'attirer l'attention des autorités de la ville sur ce problème.



Deuxièmement, ce projet aidera tous les membres du mouvement à communiquer et à mieux se comprendre. De mon point de vue, la plupart des problèmes qui surviennent sur la route sont dus au fait que certains usagers de la route en ont mal compris les autres, ce qui a entraîné la peur puis l'agression. J'aimerais qu'un tel appareil aide les participants au trafic à mieux se comprendre. Les flèches indiquent la direction, et vous pouvez également afficher le texte par lettre (cependant, je préconise complètement et complètement des inscriptions polies et constructives, afin d'éviter les conflits).



Pourquoi Smart Glove?



J'ai commencé à travailler sur le projet en hiver et le froid m'a motivé à attacher l'appareil à mon gant. Mais je me suis vite rendu compte que l'idée n'était pas très bonne, car dans notre région il fait assez chaud en été. J'ai donc décidé qu'il serait préférable de placer l'appareil dans une boîte et de le fixer à mon bras. Mais comme je ne savais pas comment le nommer différemment, j'ai décidé de laisser le mot «gant» dans le titre.



«Smart» vient de la technique d'apprentissage automatique que j'ai utilisée dans ce projet.



Inspiration



Le projet est essentiellement un mélange de deux autres projets. Je ne suis pas parti de zéro, mais j'ai utilisé leurs meilleures pratiques, que j'ai ensuite développées davantage. Voici ce qui m'a inspiré lors du développement:



  • reconnaissance des gestes avec Arduino Nano 33 BLE SENSE.
  • pas un projet spécifique, mais le concept de l'utilisation de réseaux LED pour les cyclistes. Il existe de nombreux projets de ce type - certains utilisent des sacs à dos avec des panneaux intégrés, d'autres offrent simplement une matrice prête à l'emploi qui peut être placée n'importe où. Dans tous les cas, ces matrices LED sont contrôlées par une télécommande, pas par reconnaissance gestuelle.


Composants



Pour l'impression 3D - une imprimante 3D ou l'accès à une.



Électronique



  • Arduino Nano 33 BLE SENSE;
  • Un autre MI avec BLE (Arduino Nano 33 BLE, Arduino 33 BLE SENSE, Arduino nano 33 IOT, ESP32, etc.). J'ai décidé d'utiliser une carte ESP32.
  • Bande LED (WS2812B). J'ai utilisé 160 LED pour créer une matrice 20x8;
  • Tampon à 4 niveaux de 3V à 5V: 74AHCT125.
  • Condensateur 1000 uF.
  • Commutateurs SPST, 3 pcs.
  • Planche à pain.
  • Fils.
  • Batterie 9 V.
  • Batterie externe.




  • 3.
  • -.


1: (, )











Après avoir lu un article sur Arduino et l'apprentissage automatique, j'ai décidé de l'essayer aussi. Puisqu'il y a eu plusieurs nouvelles cartes Arduino Nano ces derniers temps, j'ai fait une plaque de comparaison pour faire le meilleur choix avant d'acheter.







Toutes les cartes sont intéressantes, mais je ne pourrais en utiliser qu'une seule pour la reconnaissance gestuelle - Arduino Nano 33 BLE SENSE. Seulement, elle a les bons capteurs et le support Tensorflow Lite. Un autre point intéressant est que les cartes Arduino Nano 33 IOT, BLE et BLE SENSE ont leur propre Bluetooth, donc n'importe laquelle d'entre elles peut être utilisée sur la matrice LED pour recevoir des signaux BLE.



Le code chargé dans la carte est basé sur de nombreux programmes Arduino que j'ai trouvés pendant le développement. Par conséquent, avant de commencer le travail, j'ai décidé de les tester avec les exemples que j'ai trouvés.



Jouons avec BLE



Dans ce projet, la communication Bluetooth est essentielle car c'est ainsi que le signal est envoyé des capteurs au réseau de LED. Avant cela, je n'avais jamais connecté deux cartes Arduino via BLE. J'ai donc pratiqué avec les exemples suivants de la bibliothèque ArduinoBLE :



  • Le croquis LedControl utilisé avec la carte Arduino Nano 33 BLE Sense et un bouton avec une résistance pull-up connectée à la broche 2. L'exemple interroge les périphériques BLE jusqu'à ce qu'il trouve un service avec l'UUID 19b10000-e8f2-537e-4f6c-d104768a1214. Après l'avoir détecté et établi une connexion, il contrôlera à distance la LED BLE du périphérique en appuyant sur un bouton.
  • Croquis pour LED et Arduino Nano 33 IoT.


Malheureusement, j'ai eu beaucoup de problèmes avec le croquis de la LED - 3 cartes se sont «cassées» lors du chargement. Je n'ai aucune idée du problème, mais j'ai décidé de remplacer la carte Arduino par un autre MI avec BLE - la carte ESP32. Avec la nouvelle carte, j'ai utilisé ce qui suit:



  • BLE_write esquisse de la bibliothèque BLE ESP32 ARDUINO. J'ai ajouté quelques modifications pour le faire fonctionner avec la carte Arduino Nano 33 BLE SENSE. À l'étape 10, vous pouvez comparer le croquis BLE_write et le croquis Smartglove_BLE_LED-matrix que j'ai écrit et téléchargé.


Jouons avec les LED RVB intégrées



Saviez-vous que la carte Arduino Nano 33 BLE SENSE a des LED RVB intégrées? Dans ce projet, ils seront utiles pour vérifier le bon fonctionnement de la reconnaissance gestuelle. Nous devons vérifier que le signal a bien été envoyé au réseau de LED - cependant, comme le panneau est très probablement situé à l'arrière du cycliste, il lui sera difficile de comprendre que la reconnaissance gestuelle a fonctionné et que le signal a été envoyé.



Il n'y avait rien de compliqué ici, j'ai juste peaufiné un peu l' exemple de Blink . Le code montre que la LED rouge est sur la broche 22, verte sur la broche 23, bleue sur la broche 24. Le signal d'entrée LOW allume la LED, HIGH - l'éteint. 



const int LED_BUILTIN_RED = 22;
const int LED_BUILTIN_GREEN = 23;
const int LED_BUILTIN_BLUE = 24;

//  setup        
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN_RED, OUTPUT);
  pinMode(LED_BUILTIN_GREEN, OUTPUT);
  pinMode(LED_BUILTIN_BLUE, OUTPUT);
}

//  loop  
void loop() {
  digitalWrite(LED_BUILTIN_RED, LOW);   //  LED (HIGH –  )
  delay(1000);                       //  
  digitalWrite(LED_BUILTIN_RED, HIGH);    //  LED,    LOW
  delay(1000);                       //   

digitalWrite(LED_BUILTIN_GREEN, LOW);   //  LED (HIGH –  )
  delay(1000);                       //  
  digitalWrite(LED_BUILTIN_GREEN, HIGH);    //  LED,    LOW
  delay(1000);   //  
  
  digitalWrite(LED_BUILTIN_BLUE, LOW);   //  LED (HIGH –  )
  delay(1000);                       //  
  digitalWrite(LED_BUILTIN_BLUE, HIGH);    //  LED,    LOW
  delay(1000);                       //  
}


Jouons avec la reconnaissance gestuelle et tinyML



Enfin, j'ai étudié le tutoriel sur l'utilisation de l'apprentissage automatique sur Arduino, et pratiqué avec un exemple de reconnaissance gestuelle. L'exemple est divisé en trois parties principales:



  • Reconnaissance des données avec le programme IMU_Capture (et Arduino Nano 33 BLE sense);
  • Formation modèle sur les données enregistrées sur google colab (sur un ordinateur);
  • Utilisation d'un modèle Arduino formé avec IMU_Classifier pour la reconnaissance de formes (encore une fois sur une carte Arduino).


Étape 2: gant 1/6 (électronique)























Des étapes 2 à 7, je fournis le même schéma, en indiquant les étapes pour qu'il vous soit plus facile de comprendre le processus de fabrication d'un gant.



Le circuit électronique du gant est très simple:



  • Carte Arduino.
  • Pile 9V (j'utilise une pile rechargeable).
  • Commutateur SPST.


Étape 3: gant 2/6 - corps











































Le boîtier est simple et ne se compose que de deux parties, imprimées sur une imprimante 3D:



  • La partie jaune contient la carte Arduino, la batterie et l'interrupteur. Les trous dans le boîtier vous permettent de recharger la batterie et de reprogrammer la carte Arduino sans avoir à démonter le boîtier.
  • La partie noire est le couvercle qui protège la batterie et la carte.


Je l'attache à ma main avec une bande de velcro.



J'ai également dessiné un logo, que j'ai ensuite collé sur le couvercle. Il représente le cycliste vu d'en haut et comporte trois flèches - droit devant, gauche et droite. La quatrième flèche est séparée des trois autres car les vélos ne reculent pas.



Des dossiers



content.instructables.com/ORIG/FS2/L3M3/K9N93ZYW/FS2L3M3K9N93ZYW.stl



content.instructables.com/ORIG/F72/21NG/K9N93ZZG/F7221NGK9N93ZZG.stl



content.instructables.com/NORIG9SZ3 stl



Étape 4: gant 3/6: enregistrement des données































Après avoir assemblé l'appareil, il est temps d'écrire des données. Le but est d'enregistrer chaque geste plusieurs fois. J'ai défini le seuil pour le gyroscope, et quand il dépasse cette valeur, l'Arduino commence à sortir les données enregistrées sur le moniteur.



J'ai enregistré les gestes suivants:



  • La main pointe vers la gauche (geste standard du cycliste pour tourner à gauche).
  • Freinage (geste avec les doigts atteignant le levier de frein).
  • La main se penche en arrière.
  • La main se penche en avant.
  • La main se penche vers la gauche.
  • La main se penche vers la droite.


Naturellement, vous pouvez enregistrer vos gestes.



Pour enregistrer les données, j'ai écrit un programme qui change les couleurs de la LED tous les 20 coups. Cela m'a aidé à comprendre quand passer à un autre geste. J'ai connecté l'Arduino à mon ordinateur, ouvert le programme de suivi des ports et mis l'ordinateur portable dans mon sac à dos.



Après avoir enregistré tous les gestes, je suis passé à la dernière étape - j'ai copié la sortie des données dans le programme et l'ai sauvegardée au format csv.



content.instructables.com/ORIG/FC7/B0JT/K9UEA78V/FC7B0JTK9UEA78V.ino



Étape 5: gant 4/6: entraînement















Pour la formation, j'ai utilisé l' exemple suivant , en ne corrigeant que quelques lignes. Avant l'entraînement, il vaut la peine de vérifier que pour chaque geste, vous disposez de votre propre fichier csv et que les données de chaque fichier se réfèrent à ce geste particulier.



Sur le site Web de Google Colab, utilisez le lien dans la section "Importer des données" pour importer vos données.



Dans la section "Données graphiques (facultatif)", ajoutez le nom de l'un des fichiers.



filename = "Arm_left.csv"



Puis corrigez cette ligne pour ne sortir que les données du gyroscope: 



#index = range(1, len(df['aX']) + 1)
index = range(1, len(df['gX']) + 1)


Commentez les lignes suivantes - nous n'utilisons pas de données d'accéléromètre: 



#plt.plot(index, df['aX'], 'g.', label='x', linestyle='solid', marker=',')
#plt.plot(index, df['aY'], 'b.', label='y', linestyle='solid', marker=',')
#plt.plot(index, df['aZ'], 'r.', label='z', linestyle='solid', marker=',')
#plt.title("Acceleration")
#plt.xlabel("Sample #")
#plt.ylabel("Acceleration (G)")
#plt.legend()
#plt.show()


Dans la section "Analyser et préparer les données", ajoutez tous les noms de fichiers: 



#GESTURES = ["punch", "flex",]
GESTURES = ["Arm_left", "Brake", "Hand_back-tilt", "Hand_front-tilt", "Hand_left-tilt", "Hand_right-tilt"]


Modifiez le nombre d'échantillons d'un seul geste si vous les avez modifiés dans le code Arduino: 



#SAMPLES_PER_GESTURE = 119
SAMPLES_PER_GESTURE = 64


Il ne reste plus qu'à commenter l'accélération: 



# normalize the input data, between 0 to 1:
# - acceleration is between: -4 to +4
# - gyroscope is between: -2000 to +2000
      tensor += [
          #(df['aX'][index] + 4) / 8,
          #(df['aY'][index] + 4) / 8,
          #(df['aZ'][index] + 4) / 8,
          (df['gX'][index] + 2000) / 4000,
          (df['gY'][index] + 2000) / 4000,
          (df['gZ'][index] + 2000) / 4000
      ]


Après avoir parcouru l'ensemble du programme, vous pouvez télécharger le modèle entraîné.



Des dossiers



content.instructables.com/ORIG/F7A/GLEK/K9UEA8Z5/F7AGLEKK9UEA8Z5.csv



content.instructables.com/ORIG/FV1/853G/K9UEA8Z6/FV1853GK9UEA8Z6.csv



content.in9structables.com/KDIG8/. csv



content.instructables.com/ORIG/F7N/P7AG/K9UEA8Z9/F7NP7AGK9UEA8Z9.csv



content.instructables.com/ORIG/FD4/WZRM/K9UEA8ZA/FD4WZRMK9UEA8ZA.csv



content.in7A8ZA.csv content.in7A8ZA.csv content.in7A8ZA.csFructables .csv



Étape 6: Gant 5/6:







Code Arduino Mon code de gant intelligent final est un mélange des programmes suivants:



  • un exemple de "LED" de la bibliothèque "ArduinoBLE" (Peripheral> LED).
  • "IMU_Classifier" d'ici .


Je ne vais pas les développer en détail ici, je recommande juste de lire les programmes originaux afin de mieux comprendre ce qui se passe.



Ajoutez votre modèle au code et vous pouvez le tester!



Des dossiers



content.instructables.com/ORIG/F9N/4SBK/K9UEA98M/F9N4SBKK9UEA98M.h



content.instructables.com/ORIG/FKZ/ODO9/KB52VXZK/FKZODO9KB52VXZK.ino



Étape 7: gant 6/6: tests



















Comme vous pouvez le voir sur la vidéo, la LED s'allume différemment selon le geste reconnu:





Étape 8: matrice 1/4 LED: électronique























Comme je l'ai mentionné, lors du téléchargement d'un croquis de la bibliothèque ArduinoBLE pour une LED sur l'Arduino Nano 33 BLE SENSE, j'ai rencontré des problèmes. J'ai donc décidé d'utiliser ESP32 au lieu de cette carte. Par conséquent, sur les photos ci-dessus, vous pouvez voir les deux tableaux.



Étant donné que les cartes Arduino Nano 33 BLE SENSE et ESP32 fonctionnent avec une logique de 3,3 V, j'ai ajouté un tampon à 4 niveaux de 3 V à 5 V (74AHCT125) comme recommandé dans les instructions d'Adafruit .



J'ai également ajouté un condensateur de 100 uF pour protéger la LED des surtensions soudaines.



J'ai assemblé tout le circuit sur une maquette.



On voit que j'ai utilisé les deux connecteurs de l'alimentation externe, car j'avais peur que la matrice LED ne nécessite trop de courant. Par conséquent, la matrice et le MI sont alimentés par différents connecteurs d'une source d'alimentation externe.



Étape 9: LED Array 2/4: Body























































J'avais besoin d'un boîtier matriciel LED préfabriqué. Par conséquent, il se compose de plusieurs pièces (et aussi parce que mon imprimante 3D est très petite), et j'ai prévu des trous pour les boulons.



J'ai de nouveau utilisé du Velcro pour fixer le panneau.



Des dossiers



content.instructables.com/ORIG/FH6/TB4H/K9N93ZZJ/FH6TB4HK9N93ZZJ.stl content.instructables.com/ORIG/FK3/BZPC/K9N93ZZK/FK3BZPCK9N93ZZK.stl



content.instructZFLUK.stl



content.instructZFLUK.stl content.instructZFLUK.stl content.instructZFLUK.stl stl



content.instructables.com/ORIG/F38/BF1P/K9N93ZZM/F38BF1PK9N93ZZM.stl



content.instructables.com/ORIG/FJC/DQMY/K9N93ZZN/FJCDQMYK9N93ZZN.stl



content.frel / .stl



content.instructables.com/ORIG/FJE/C5FG/K9N93ZZR/FJEC5FGK9N93ZZR.stl



content.instructables.com/ORIG/F55/1X43/K9N93ZZS/F551X43K9N93ZZS.stl



Étape 10: Matrice LED 3/4: Code Arduino



























Le code résultant est un mélange des codes suivants (et de leur modification):

  • Exemple BLE_Write de la bibliothèque BLE ESP32 ARDUINO.
  • Exemple MatrixGFXDemo64 de la bibliothèque FastLED NeoMatrix.




Je ne vais pas les développer en détail ici, je recommande juste de lire les programmes originaux afin de mieux comprendre ce qui se passe.



content.instructables.com/ORIG/FIR/RETZ/KB52VXP4/FIRRETZKB52VXP4.ino



Étape 11: matrice LED 4/4: test











Il est temps de tout vérifier! Après avoir reconnu chaque geste, un signal est envoyé à la matrice LED, et il montre un certain modèle. On constate que les LED du gant s'allument en fonction du geste reconnu.







Étape 12: tests finaux et conclusion











Voici à quoi ça ressemble en direct:







Je suis très satisfait du dispositif résultant. Grâce au projet, je me sens beaucoup plus en confiance avec tinyML et BLE. Depuis, j'ai acheté un autre Arduino Nano 33 IOT, et maintenant je suis engagé dans un projet très intéressant, sur lequel j'écrirai plus tard. Que changerais-je dans la deuxième version de l'appareil que j'ai décrit:



  • «». , . - - , . .
  • . , USB . , . .
  • . , . , ( 20 ). – , .


Il m'a fallu plusieurs mois pour terminer le projet et rédiger ce texte. Si quelque chose n'est pas clair ou si un fichier est manquant, écrivez dans les commentaires de l'article d'origine .



Voir également:





More articles:


All Articles