DIY: Fabriquer un radar pédagogique

Parfois, il m’arrive de vous parler d’un de mes loisirs : le modélisme radiocommandé. Lors de nos courses, nous avons quelques spectateurs. Suivre une course peut être un peu compliqué à suivre pour les novices. Lors de nos événements, j’aime que le public soit capable de suivre la course et de voir à quel point les voitures peuvent aller vite. On peut annoncer des vitesses au micro, mais il peut subsister un doute pour le public. Mon idée est d’installer un radar pédagogique au bord de la piste, afin de donner de l’attractivité.

Les radars pédagogiques on les connaît tous, on les trouve dans les villes. Pour ce type de radar, il faudra compter 1600€ minimum. Nos bolides pouvant dépasser les 100 km/h, ce sera donc plus cher que les modèles de base. Pour servir 2 à 3 fois par an, cela fait beaucoup à débourser pour une association.

Pour ce radar, je souhaitai :

  • Avoir 3 digits (avec affichage des centaines) ;
  • Un prix de fabrication bas ;
  • Compact ;
  • Un affichage visible de loin et en plein soleil.

Pour la réalisation de ce radar, cela va réunir mes principaux loisirs : informatique, électronique, codage et impression 3D.

J’ai entamé mes recherches avec des mots clés suivant Arduino ou Raspberry Pi. Elles m’ont permis de trouver un système avec ces 2 cartes. L’inconvénient, c’est que les 2 systèmes requièrent l’achat d’un module onéreux. On prend donc le risque d’acheter un module à 160€ avec un risque de ne pas réussir.
Le premier avec un Arduino est disponible en suivant ce lien. Son principal avantage, le système est petit, démarre rapidement et consomme peu. Il utilise un système Lidar pour Arduino. On le trouve à 179€ en suivant ce lien. N’ayant que très rarement utilisé un Arduino, j’ai préféré partir sur un système avec un Raspberry Pi.

Pour celui-ci, j’ai trouvé ce tutoriel au lien suivant. Il est un peu plus compliqué, car il faut faire un peu d’électronique. En effet, une petite carte devra être réalisée pour le contrôle des afficheurs 7 segments. Pour la détection de la vitesse, ici, il faudra une carte Omipresence OPS241-A-CW-RP. Cette carte fonctionne avec une onde Doppler. Elle est reliée en USB au Raspberry et il suffit ensuite de lancer un script.

 

Voici le résultat :

Fabrication du radar

Voici les principaux éléments qu’il nous faut :

  • Un Raspberry 3B+ ;
  • Un module radar Omipresence OPS241-A-CW-RP ;
  • 3 afficheurs 7 segments ;
  • 3 contrôleurs pour piloter les afficheurs ;
  • Des composants électroniques pour faire la carte (Liste plus bas) ;
  • Une alimentation avec du 5 et 12v ou batterie (en test pour la batterie)

Il va nous falloir d’autres choses cela va dépendre de vous, effet il y a le choix de l’alimentation, du type de montage que vous souhaite faire.

Pour le Raspberry, je l’ai pris sur Amazon au lien suivant. Pour le module radar, je l’ai acheté au lien suivant au tarif de 143€. Comme indiqué plus haut, il fonctionne avec une onde Doppler. Une première antenne envoie un signal et quand il rebondie sur un objet, la seconde antenne reçoit le signale et calcul la distance. Il sera connecté en USB sur le Raspberry pi. Rien n’est à installer sur celui-ci, car il fonctionne en OTG.
Cette vidéo explique tout ce qu’il faut savoir sur cette carte.

 

Vous trouverez au lien suivant le PDF de l’API pour les différents réglages possibles sur la carte. Avec le paquet MiniCom, vous pourrez tester les différentes commandes, ainsi que visualiser les captures de vitesse en temps réel, mais ce n’est pas tout… La page GitHub de Omnipresense regroupe quelques scripts pour différentes applications, mais aussi avec une application pour téléphone.

Les afficheurs

Pour les afficheurs 7 segments, ceux utilisés par les 2 systèmes, ne sont pas prévus pour fonctionner en plein jour. Pour mon besoin, ils ne sont pas assez grands. En effet, le radar est placé au bout du circuit à l’endroit le plus rapide. Le public se trouve au bord de la piste, à une distance de 46 mètres. Je pars dans les recherches pour trouver des afficheurs grand et lumineux. Je trouve des modèles à faire soit même, avec plusieurs LEDs comme ici. Après quelques recherches, je tombe sur Aliexpress avec un afficheur pour les tarifs en station essence. C’est parfait ! Le vendeur propose de 6 pouces (15 cm) à 72 pouces (1.82m) ! Tous disponibles ici. Je suis partie sur des 8 pouces de couleur verte. L’éclairage est plus fort, ils sont au lien suivant achetés au prix de 13,89€ l’unité.

Les afficheurs arrivent par segment à monter, de petites vis sont livrées pour le montage. Un petit détail important, chaque LED est surmontée d’une petite casquette pour limiter la lumière du soleil sur celle-ci. Un autre point fort, ils sont étanches. Toute la partie électrique est noyée dans une résine.

Une fois monté, voici le résultat ! Des petites vis sont livrées pour le montage. J’ai légèrement incliné les chiffres pour donner un effet italique. Pour le 3e afficheur, je n’ai monté que de quoi faire le 1. Pas besoin de plus et cela réduit aussi la taille du radar. Attention : les LEDs éclairent très fort. Évitez de les regarder de prés. Autre chose à savoir, la polarité est inversée. Le fil noir, c’est le +… et le rouge le -. J’ai averti le vendeur, car au début je pensai qu’ils ne fonctionnaient pas. Heureusement que j’ai fait un essai avant de réaliser ma carte. Pour alimenter les afficheurs, il faudra du 12v.

Pour les contrôleurs, c’est le site SparkFun qui les a fabriqués pour fonctionner avec leurs grands digits que l’on voit dans leurs vidéos. Ils peuvent fonctionner parfaitement avec d’autres, je les ai achetés chez mouser.fr au lien suivant. Ils sont actuellement au prix de 7.20€. Ces contrôleurs sont « chainables », on va donc brancher les 3, les uns derrière les autres. Au lieu de les souder directement sur l’afficheur, on connectera chaque fils négatif du segment à contrôler… on y reviendra.

La carte électronique

Maintenant que l’on a tout ce qu’il faut, on va passer à la partie pilotage de l’affichage. Il faudra quelques composants pour connecter le Raspberry Pi aux 3 contrôleurs afin d’afficher la vitesse sur nos afficheurs 7 segments. Les ports GPIO du Raspberry sortent en 3.3v, mais pour les décodeurs, il faut que cela arrive en 5v. Ce montage va donc modifier la sortie des 3 ports GPIO que l’on va avoir besoin. Dans un premier temps, je vais vous parler du montage simple avec une alimentation classique. Ensuite, je vais vous parler de mon montage avec une alimentation ATX.

Pour réaliser le circuit nous avons besoin des composants suivant :

  • 3* résistances de 330 Ohm en 1/8w ;
  • 3* transistor BS170 (ceux indiqués sur Instructables ne se font plus et son remplacé par ce modèle) ;
  • 1* support DIP 14 pâtes ;
  • 1* 74HCT04N (disponible ici).

En option, si vous souhaitez faire une carte :

  • Des connecteurs JST-XH (17 x 2pins  + 2 x 7 pins + 1x 4 pins partie alimentation) ;
  • Un header femelle de 40 pins pour connecter au Raspberry ;
  • 6* header pins pour connecter les contrôleurs.

Il faut que chaque transistor soit connecté au 74HCT04N, voici le schéma et les explications : Q1,2 et 3 sont les transistors BS170, P1 le header 40 pin du Raspberry. Le signal sort d’un connecteur GPIO (ici le 16), il entre dans le 74HCT04N sur 6A. On ressort sur 6Y pour aller vers un BS170 qui sera le connecteur CLK et on sort du transistor pour trouver entre 2 la résistance R1 de 330ohms qui va faire passer le signal à 5v. C’est la même chose pour les 2 autres, mais sur une entrée / sortie différente au niveau du 74HCT04N.

Ce que vous voyez sur la partie droite, ce sont tous les connecteurs JST-XH pour brancher tous les segments. Afficheurs 1,2 et 3 seront connectés aux contrôleurs. Il s’agit uniquement du négatif, le 12v arrivera directement de l’alimentation à U4. Sur ce schéma, je n’ai pas pensé, mais l’arrivée en 5v de l’alimentation aurait pu être reliée au GPIO 2 et 4 pour alimenter le Raspberry.

Voici un schéma avec le tout relié… Pour le raccordement des contrôleurs, il faut que le premier soit celui qui servira aux centaines. Tous les connecteurs 1A,1B, 1C… serviront aux branchements de tous les segments. Le 1 signifie le numéro du digit, (le 1 correspond aux unités, le 2 pour les dizaines, le 3 les centaines). Pour la lettre, il faut tout simplement suivre le schéma d’un afficheur 7 segments comme sur l’image. En gros, le contrôle va fermer ou ouvrir le circuit pour allumer ou éteindre le segment.

Voici la carte est terminée ! Il s’agit d’un HAT que l’on peut monter directement sur le Raspberry. Il y a peu, j’ai fait un article sur la création d’une carte avec EsayEDA, avec les informations nécessaires pour la réalisation d’une telle carte. Je vous mets aussi les fichiers gerber, il ne vous restera plus cas imprimer le circuit voir le modifier (Fichier disponible ici => radar-gerber_hat)

Version avec alimentation ATX

Dans un précédent article, je vous avais parlé de la carte PiRyte qui permet d’alimenter et de piloter la mise en marche/arrêt propre de son Raspberry Pi. L’avantage pour le radar, c’est que nous avons besoin du 5v, du 12v et avec les gros afficheurs… on peut avoir besoin d’un peu de puissance. Mon objectif était de faire une carte 2 en 1, avec la partie alimentation et la partie pour les GPIO. Lors de mon premier achat, un manuel avec le schéma électrique était livré. Ce schéma, on peut le retrouver au lien suivant. Mais attention, cette carte contient un Attiny85 qui doit être programmé. J’ai contacté la personne qui vend cette carte et après échange sur le projet, il m’a envoyé le programme. Bien sûr, j’ai souhaité lui faire un don. Si vous souhaitez faire ce montage, il faudra voir pour le contacter. Un autre changement sera aussi à faire sur le script qu’il faut installer pour contrôler la mise en marche du Raspberry. En effet, l’un des ports GPIO utilisés pour le script du radar est le même que l’un utilisé pour le script de l’alimentation (script disponible sur Github au lien suivant).

Pour la réalisation de cette carte il nous faut :

  • 1* condensateur 100nf ;
  • 2* LED verte 3mm ;
  • 1* LED rouge 3mm ;
  • 1* bouton-poussoir ;
  • 1* transistor 2N4401 ;
  • 1* résistance de 4.7k omh ;
  • 3* résistances de 1.5k ohm ;
  • 1* résistances de 330 ohm ;
  • 1* résistance de 10k omh;
  • 1* DIP ATTINY85-20PU ;
  • 1* support DIP 8 pâtes ;
  • 1* Header 40 pins ;
  • 1* Connecteur ATX 24 pins ;
  • 4* pin header (LED et bouton-poussoir) ;
  • 12* pin header pour les connecteurs supplémentaires.

Bien sûr, il faut ajouter les composants plus haut pour la partie pilotage des afficheurs. Ici, on replacera le header 40 pin pour le Raspberry par des pins mâles. Voici le schéma… En bas, on trouve le premier schéma pour la modification de la tension de sortie des ports GPIO et en haut celui de la carte alim. Les connecteurs J1 à J6 sont en plus en cas de besoin pour relier un ventilateur par exemple. Sur le connecteur ATX, je n’ai volontairement pas connecté les bornes 11, 12, 23 et 24 pour que cela fonctionne aussi avec une alimentation ATX de 20 pins.

Voici la carte une fois imprimée et les composants soudés. Vous pouvez télécharger le fichier gerber ici => radar-gerber+alim. Attention, lors de la réalisation de votre carte, sur EasyEDA, j’ai pris un modèle de connecteur ATX dont les trous de soudage étaient de 1.6mm. Cela avait fonctionné avec un autre connecteur droit. Ici, le connecteur a des bornes qui demandent 1.8mm (vous pouvez éditer le diamètre lors de la création de la carte). J’ai pu refaire les trous, mais le souci c’est qu’en refaisant le perçage, j’ai retiré l’étain qui permet lors de la soudure de couler entre la piste du dessus et du dessous. J’ai dû jouer au fer à souder pour faire toutes les soudures entre les pâtes.

La plupart des composants proviennent de chez Go tronic. Le plus dur à trouver, ce sont les connecteurs ATX. Je les ai commandés sur Amazon au lien suivant, pour les connecteurs JST. Il m’a fallu 2 boîtes, car les kits trouvés n’avaient pas du 2 et 7 pins dans la même boîte. J’ai pris cette boîte et celle-ci, mais attention pour le montage des connecteurs femelle. Il vous faudra une pince spéciale si vous voulez avoir des connecteurs bien montés. Je suis partie sur celle-ci et après 2/3 montages, on y arrive plus facilement. Je vous conseille de fermer légèrement la cosse avant de la bloquer sur la pince. Celles-ci tiendront mieux pour le serrage.

Pour un montage plus propre, j’ai aussi pris une nappe de 40 pins au lieu d’avoir quelques cavaliers. Je trouve que cela ne tient pas trop. Comme le radar va être transporté, je préfère assurer le coup. Je suis partie sur cette nappe.

Programmation de l’Attiny85

J’ai récemment fait un article sur la fabrication d’un programmateur, je vous invite à vous rendre à cet article pour avoir toutes les infos.

L’alimentation

Pour la première carte, à vous de voir pour trouver une alimentation qui fournira du 5 et 12v… assez puissante pour alimenter le Raspberry avec la carte radar et les 3 afficheurs. Je ne compte pas les contrôleurs et autres DIP qui ne doivent pas consommer beaucoup. Sur un forum d’électronique, on m’a annoncé 0.333A par segment. Nous avons 16 segments au total soit 5.3A. Ce type d’alimentation pourra faire l’affaire avec les 6A sur le 12v. Le 5v est réglable au vu d’un commentaire, il permettra de monter à 5.1V, car l’alimentation Raspberry officielle fournie du 5.1v. Cela évitera le petit éclair qui indique un manque de tension.

Pour la 2e carte, si vous êtes comme moi un récup tout en informatique : une alimentation de PC sera parfaite. J’ai récupéré une petite alimentation ATX 20 pins de 150w provenant d’un routeur pro et peut sortir 17A sur le 12v. Elle a trouvé sa place au dos de ma planche à côté des fils des afficheurs.

On met tout en place et voici la disposition, on retrouve en premier la carte électronique avec l’alimentation ATX, la nappe qui relie la carte au Raspberry qui va l’alimenter en même temps… et pour finir, la carte radar est branchée en USB au Raspberry.

Ci-dessous, on peut voir que tous les segments sont reliés à la carte ainsi que les connecteurs JST 7 pins et le 2 pins pour les 2 segments des centaines qui vont vers les contrôleurs. Le connecteur 4 pins avec les fils bleus correspond au bouton poussoir pour la mise en marche, ainsi que la LED pour nous indiquer le bon démarrage. Sur la seconde photo, on peut voir le connecteur 6 pins (12v, 5v, SER, CLK, LAT, GND) qui va se connecter au premier contrôleur.

Comme indiqué, il vous faudra un interrupteur pour l’arrêt et la mise en marche. Il suffit d’un simple bouton-poussoir. Pour la LED vous pouvez la relier directement. Une résistance est déjà en place sur la carte. J’ai aussi prévu de déporter le port Ethernet en cas de besoin.

Pour connecter les contrôleurs, j’ai fabriqué une nappe allant de la carte principale au 1er contrôleur (celui des centaines) pour la partie soudée sur la carte (les mâles). J’avais du stock… et pour les femelles, j’ai acheté cet assortiment. Pour le raccordement des autres, j’ai utilisé des nappes header déjà faite. Pour le raccordement des afficheurs, j’ai fait 2 connecteurs JST de 7 pins… puis soudé sur les contrôleurs à l’autre bout du fil en respectant la lettre de chaque segment et un de 2 pins pour les centaines.

Préparation du Raspberry

J’ai installé Raspbian en mode graphique, car avant de réaliser les cartes et d’acheter tout le reste… j’ai testé le radar avec un script Python. Pour l’installation de l’OS, je ne vais pas rentrer dans le détail… vous trouverez plein de guides en ligne pour cela. Pour faire fonctionner la carte radar, sur Raspbian, il faut activer le port série. Dans le menu Raspi Config dans l’onglet Interface, il faut activer Sérial Port et faire un redémarrage du Raspberry.

Les scripts

Si vous utilisez la seconde carte avec l’alimentation ATX, il va falloir injecter le script. Pour cela, téléchargez le script suivant : ATX-PSU_startupsetup. Il est modifié avec les bons port GPIO que j’ai dû changer. Pour l’installer, suivre cette procédure :

  1. Décompresser le fichier zip ;
  2. Remonter dans le dossier ou est stocké votre script exemple home/pi ;
  3. sudo bash ATX-PSU_startupsetup.sh
  4. sudo reboot

Attention ne pas lancer plusieurs fois le script, car cela modifie le fichier rc.local et donc à chaque exécution du script… Cela va ajouter de nouvelles lignes identiques. Il vous reste à tester le bon fonctionnement, depuis le menu Raspbian. Arrêter votre Raspberry, si tout est bien fait l’alimentation ATX devrait s’éteindre. Un appui sur le bouton va démarrer votre Raspberry, un appui long va faire un arrêt propre (la LED clignote durant l’arrêt) et un appui court va faire un redémarrage.

Le script pour le radar avec un écran

J’ai pu tester le fonctionnement en commençant avec un script qui affiche la vitesse sur l’écran relié au Raspberry. Installez le script suivant : https://github.com/omnipresense/OPS241A_RasPiLCD mais le chemin du logo n’est pas bon dans speed.py. Il faut supprimer les lignes 60, 61 et 62… sinon cela ne fonctionnera pas. Pour démarrer le script, il vous suffira de faire la commande python3 /home/pi/OPS241A_RasPiLCD/speed.py (remplacer le chemin home si nécessaire). Vous aurez une fenêtre avec les vitesses qui s’affiche. Dans ce cas, la carte fonctionne bien.

Le script avec afficheurs

Dans le tuto de instructables.com, la personne fournit le script pour l’utilisation avec les afficheurs. Il sera utilisé comme base, car il va devoir être modifié pour afficher les vitesses en km/h et surtout fonctionner avec 3 afficheurs 7 segments ce qui n’est pas le cas dans sa version. Vous trouverez le script sur GitHub au lien suivant. Pour changer la valeur en km/h, il suffirait de changer la ligne 27 en remplaçant US par UK selon l’API. Le problème, c’est que cela ne passe pas et les valeurs restent en Miles par heure. La meilleure solution est donc de modifier directement le réglage sur la carte pour avoir par défaut à son allumage des vitesses en km/h.

Il faut se connecter avec Minicom, pour savoir comment utiliser minicom. Je vous recommande ce tuto. J’ai utilisé celui-ci et je suis arrivé à me connecter à la carte sans souci. Pour information, la carte est connectée sur ttyACM0. Une fois connecté au port COM, vous devriez voir des vitesses défiler comme ci-contre. C’est un peu différent pour moi, car j’ai programmé une vitesse minimale afin de ne pas prendre les personnes qui marchent à coter par exemple. Nous allons voir comment faire pour mettre la carte directement en km/h par défaut et ajouter une vitesse minimale.

Pour cela, tapez au clavier UK, l’unité va être changée directement. Pour la limitation, entrez au clavier R>10. Le radar prendra en compte uniquement les vitesses au-dessus de 10 km/h et pour une vitesse supérieure R<20, le radar ne tiendra pas compte des vitesses supérieures à 20km/h. Par exemple dans une rue, vous souhaitez avoir que la vitesse des piétons et non des voitures qui passent.
Pour sauvegarder les modifications afin qu’elles soient par défaut, tapez A? .

Nous allons maintenant passer à la partie du script Python. Avant, je tiens à remercier David de mon club qui a travaillé sur le script. Le codage n’est pas mon fort, David a pu modifier le code pour activer le 3e afficheur pour les centaines et a fait les modifications nécessaires pour la conversion en km/h. La modification ne se fait plus dans le script, mais directement sur la carte comme indiqué ci-dessus. Il a aussi ajouté de petites choses comme le clignotement des afficheurs avec la dernière vitesse affichée.

Voici le script radar. Décompressez le fichier et placez le dans home/pi par exemple. Pour lancer le script, ouvrez un terminal et tapez la commande : python3 /home/pi/radar.py

Le script démarre et vous devriez avoir cela à l’écran.Si tout se passe bien en bougeant devant le capteur, vous devriez avoir la vitesse qui s’affiche sur vos afficheurs. Vous pouvez remarquer que l’appareil photo n’aime pas trop l’éclairage comme indiqué plus haut, faites attention, car la luminosité est très forte.

Maintenant, on va faire en sorte que le script démarre tout seul, une fois le Raspberry démarré. J’ai cherché et essayé plusieurs méthodes. J’ai fini par trouver et utiliser la méthode indiquée sur le site de Framboise314, disponible au lien suivant. Il va falloir dans un premier temps activer l’autologin afin de ne pas avoir besoin d’indiquer le mot de passe. Depuis l’interface graphique, allez sur le menu puis sur Préférence et Configuration du Raspberry Pi. Dans cette nouvelle fenêtre, à la ligne Connexion automatique cochez « Se connecter en tant que pi« .

Nous allons maintenant créer le fichier pour démarrer le script automatiquement. Ouvrez un explorateur pour aller dans home/pi. Le dossier, où nous devons aller, est caché. Allez sur le menu Voir puis sur Afficher les fichiers cachés. Une fois les dossiers cachés « affichés », allez dans le dossier .config puis autostart. Créez un nouveau fichier et nommé le radar.desktop, ici l’extension .desktop est importante. Dans ce fichier, copiez les lignes suivantes :

[Desktop Entry]
Type=Application
Name=Radar
X-GNOME-Autostart-Delay=10
Exec=lxterminal -e python3 /home/pi/radar.py

Il ne vous reste plus cas redémarrer votre Raspberry et voir si le script démarre bien. Il peut arriver que le script ne démarre pas. Cela peut se produire si la carte radar n’est pas encore prête et joignable sur le port série. J’ai ajouté un délai pour limiter ce problème. Dans ce cas, un redémarrage avec le bouton et cela revient.

À ce stade, votre radar est prêt et fonctionnel. Il ne reste plus qu’à travailler sur l’esthétisme. Dans un premier temps, j’ai modélisé et imprimé un boîtier. J’ai ajouté un ventilateur pour refroidir le Raspberry, car il pourrait chauffer. Sur le circuit, le boîtier sera en plein soleil. Ce dernier est donc relié sur la carte d’alimentation sur un connecteur que j’ai ajouté. J’ai ajouté un lettrage en plus qui est imprimé à part et clipsé dans les trous.

Et voici le boîtier imprimé avec un ventilateur de récupération.

L’ensemble du système est caché. Le fait de mettre un boîtier devant le radar ne gênera pas la détection. Cependant, comme le boîtier fait rebond, une vitesse est détectée d’où le besoin de mettre une vitesse minimale de détection de 5km/h par exemple. À cela, on ajoute une petite casquette pour le soleil. Il reste encore à mettre en peinture…

Le radar devra être fixé au bord de la piste. Pour cela, j’utilise un mat. J’ai modélisé et imprimé cette pièce. Elle permet un montage/démontage rapide. Deux vis restent sur le mat. Il y a juste à faire glisser sur les têtes pour le monter. Lors du montage, je n’ai volontairement pas centré les fixations afin de déporter le radar le plus possible vers la piste pour une meilleure détection.

Voici notre radar prêt à capter !

Et le voici en action… Sur la vidéo, vous pouvez remarquer qu’une voiture ne passe qu’à 47 km/h. Le radar détectait mieux les voitures à droite de la piste. Au centre, c’était moyen et tout à gauche pas du tout. Il faut savoir que sur l’API du radar, on peut jouer sur de nombreux paramètres.

Conclusion

Quand j’ai eu l’idée de cette réalisation, je ne pensais pas que j’arriverais au bout et d’avoir un radar fonctionnel. Cela demande quelques connaissances dans plusieurs domaines. Certes il reste encore des choses à améliorer et à corriger… c’est sûr. Libre à vous de faire des modifications et amélioration, je serai ravi de voir ce que vous avez comme idée. Comme on peut le voir, le radar ne détecte pas très bien, sur toute la largeur de la piste. Je vais donc voir pour déporter le capteur à l’extérieur gauche du radar dans un petit boîtier, avec une charnière pour régler l’angle, mais aussi pour pouvoir le plier quand il n’est plus utilisé. Pour le moment, la vitesse maximum que j’ai vue est 99km/h. Il faudrait voir pour ajouter des logs par exemple pour enregistrer les records.

Des améliorations ?

Il reste encore des choses à voir, mais j’ai déjà le projet de le faire fonctionner sur batterie 12v avec une batterie de voiture par exemple ou une plus petite. Pourquoi pas y ajouter un panneau solaire ? L’avantage de la batterie, c’est que je pourrai le placer où je le souhaite et il n’y aura plus ce câble en aérien comme on peut le voir sur la vidéo.

L’autre amélioration que j’ai prévue, c’est du côté électronique : tout regrouper sur une carte. Sur le site de sparkfun pour les contrôleurs, nous avons le schéma du circuit. On peut donc facilement l’intégrer à notre circuit : moins de connecteurs et gain de place. J’ai commencé la nouvelle carte pour le 12v. Dans un premier temps, j’ai acheté ces pinces avec un câble pour le brancher sur une batterie de voiture comme cela, longue autonomie. Pour convertir le 12v en 5.1v pour le Raspberry, et les différents contrôleurs, je suis parti sur ce hacheur de tension que je vais directement souder sur la nouvelle carte. Voici le schéma électrique qui comprend les 3 contrôleurs, sur le plan 3D, on peut voir l’emplacement où sera monté et soudé le hacheur de tension.