Pixy est une caméra « intelligente » car elle embarque un processeur chargé d’analyser les pixels de l’image pour simplifier et accélérer la reconnaissance d’objets, particulièrement en robotique. Cet exemplaire m’a été confié par Reichelt Elektronik pour tester la possibilité de l’utiliser sur le Raspberry Pi. Comme toujours dans ce cas, le matériel ayant été offert gracieusement, cet article est classé comme
============= Article sponsorisé ==============
Cliquez sur l’image pour avoir des détails sur les niveaux
Au sommaire :
La caméra Pixy
C’est non seulement une obligation de la loi française, mais c’est aussi une volonté de ne pas tromper le lecteur du blog en mettant en ligne des articles qui seraient en fait des publireportages… Ce n’est pas le cas ici, j’ai rédigé moi-même cet article en gardant ma liberté rédactionnelle – C’est la condition pour que le matériel soit testé. (J’ai ajouté cette remarque car j’ai déjà eu des remarques à propos d’articles sponsorisés).
Réception de la caméra
La caméra arrive dans une petite boîte en carton qui contient finalement peu de choses. La boîte n’est pas très solide mais elle était dans un carton épais qui la protégeait convenablement.
Une fois la boîte ouverte la caméra apparait, avec un bouchon de protection de l’objectif et le câble fourni pour la relier à une carte microcontrôleur.
Il y a aussi un jeu de pièces destinées à la fixation de la caméra.
Le câble de liaison avec une carte microcontrôleur est fourni. Vous trouverez les détails du câblage plus loin dans l’article.
Le tour du propriétaire
Côté pile et côté face
Par rapport à la caméra Pi et aux autres caméra, Pixy se distingue par la présence d’un microprocesseur NXP LPC4330. Grâce à lui, la caméra devient « intelligente » (fô pas exagérer quand même 🙂 ) et peut apprendre à reconnaître des objets (par leur couleur) et à fournir leurs coordonnées.On voit le microprocesseur sous l’objectif. Le capteur est un modèle OV9715 qui peut faire du 720p mais est utilisé ici en 640×400 pixels à une fréquence d’image de 50Hz.
Sous la carte on trouve la connectique, la prise d’alimentation et le bouton poussoir utilisé notamment lors de l’apprentissage.
Sur ce schéma on voit les différents connecteurs, en particulier à droite les I/O qui peuvent envoyer les informations de position des objets vers une carte microcontrôleur, et les 2 sorties pour piloter les servo-moteurs d’un système d’orientation qui est commandé par la caméra elle même, sans intervention extérieure.
Ici la caméra Pixy est connectée directement à un Arduino UNO.
Alimentation de la caméra Pixy
La caméra est alimentée par un câble mini USB (la prise est plus grosse que celle qui alimente le Raspberry Pi). Le câble USB est également utilisé pour transmettre les informations à l’ordinateur auquel la caméra est reliée.
Sur la carte de la caméra Pixy, une prise mini USB montée verticalement est destinée à recevoir la prise d’alimentation/données.
Une fois le câble USB branché, la caméra est prête à être utilisée.
La connectique
A gauche la prise destinée à recevoir le câble de liaison vers une carte microcontrôleur. A sa droite un bloc de 6 broches sur lequel viendront se connecter les servo-moteurs du pan-tilt. A l’extrême droite le connecteur un connecteur blanc pour l’alimentation de la caméra (6 à 10v)
Organisation du câble utilisé pour relier la caméra à une carte Arduino.
L’image ci-dessus indique le sens de branchement de l’alimentation.
Microprocesseur et régulateur
Sur cette image on voit le microprocesseur (U6) et à droite U2, le régulateur chargé de fournir du 5v à partir de l’alimentation si vous utilisez le connecteur blanc à l’arrière de la carte. Le circuit U4 au centre est une mémoire flash de 8M bits W25Q80BV associée au microprocesseur.
La LED RGB
La LED RGB qui équipe la caméra Pixy est utilisée pour indiquer quel est la signature couleur qui est en cours d’apprentissage. La couleur de la LED n’a pas de rapport avec la couleur de la signature, elle indique simplement un chiffre de 1 à 7. Elle peut aussi aider à régler la température de couleur si la lumière ambiante a une dominante (néon, halogène, LED). La lecture du Wiki est un bon moyen de comprendre comment elle fonctionne.
Le bouton poussoir est utilisé en conjonction avec la LED RGB pour dialoguer avec la caméra si on l’utilise non connectée à un ordinateur.
Installation sur le Raspberry Pi
On commence par Windows
La raison de ce test, c’était de voir si Pixy pouvait fonctionner sur un Raspberry Pi. Pour démarrer sur des bases connues (par Pixy) j’ai démarré par une version .exe pour Windows téléchargée sur la page des dernières releases (dernières versions). Une fois PixyMon installé sur Windows 10 (pas de souci de ce côté là), j’ai connecté la caméra (consommation mesurée maxi 200mA, ensuite ça descend vers 170mA). Un coup d’œil à la fenêtre d’aide :
et la confirmation que ce sont bien les dernières versions de PixyMon et du firmware de la caméra qui sont installées. Les numéros de versions sont affichées en haut de la fenêtre et correspondent bien à ceux de la page de mise à jour.
Voilà ce qu’on peut voir sur l’écran de PixMon. Les couleurs ne sont pas très fidèles sur cette copie d’écran. J’avais posé sur le sol un bloc de post-it jaunes et un pot plein de LEDs transparentes. Comme j’avais appris le jaune à la Pixy, elle a détecté le bloc de post-it et l’a encadré.
On continue sur le Raspberry Pi
Après avoir vérifié que PixyMon fonctionne sur Windows il faut maintenant le tester sur le Raspberry Pi et là, comme on dit à Bastia, les choses se corsent 🙁
Pourquoi ? Parce qu’il n’y a pas de version exécutable pour le Raspberry Pi, ce qui veut dire qu’il va falloir construire l’exécutable à partir des sources. C’est ce qui explique le classement de cet article en « Avancé« , car il va falloir mettre un peu les mains dans le cambouis.
Installer PixyMon sur le Raspberry Pi
Pour éviter que le programme ne « rame » et vu qu’il y a aussi de la compilation, j’ai choisi un Raspberry Pi 3 pour l’installation. La carte SD est une PNY 16Go HC1. J’y ai installé une version « fraîche » de Stretch : Raspbian-2017-11-29. La procédure d’installation est décrite sur la page « Installing PixyMon on Linux » du wiki.
Installation des dépendances
On commence par configurer le système (pour qu’il cause français et que le clavier soit en AZERTY). Après on fait la mise à jour
|
1 2 |
sudo apt-get update sudo apt-get upgrade |
On peut ensuite commencer à installer les bibliothèques dont PixyMon a besoin :
sudo apt-get install libusb-1.0-0.dev libboost-all-dev cmake
|
1 2 3 4 5 |
sudo apt-get install libusb-1.0-0.dev libboost-all-dev cmake 0 mis à jour, 106 nouvellement installés, 0 à enlever et 0 non mis à jour. Il est nécessaire de prendre 38,2 Mo dans les archives. Après cette opération, 272 Mo d'espace disque supplémentaires seront utilisés. Souhaitez-vous continuer ? [O/n] |
Il faut ensuite créer un dossier pour loger les fichiers de Pixy :
|
1 2 |
mkdir pixy cd pixy |
Puis télécharger les sources de Pixy depuis le github de CharmedLabs
git clone https://github.com/charmedlabs/pixy.git
|
1 2 3 4 5 6 |
git clone https://github.com/charmedlabs/pixy.git Clonage dans 'pixy'... remote: Counting objects: 6828, done. remote: Total 6828 (delta 0), reused 0 (delta 0), pack-reused 6828 Réception d'objets: 100% (6828/6828), 14.37 MiB | 126.00 KiB/s, fait. Résolution des deltas: 100% (4402/4402), fait. |
Une fois les sources téléchargées, rendez vous dans le répertoire pixy puis dans le répertoire scripts.
|
1 2 |
cd pixy cd scripts |
Lancer la compilation de libpixyusb. La bibliothèque libpixyusb fournit une interface de programmation (API) pour la communication avec la caméra Pixy via un port USB. Cela vous permet d’écrire un logiciel qui s’interface avec Pixy (comme l’application PixyMon que nous verrons ensuite).
./build_libpixyusb.sh
|
1 2 3 4 5 6 7 8 9 |
pi@raspberrypi:~/pixy/pixy/scripts $ ./build_libpixyusb.sh -- The CXX compiler identification is GNU 6.3.0 -- Check for working CXX compiler: /usr/bin/c++ -- Check for working CXX compiler: /usr/bin/c++ -- works ... [100%] Linking CXX static library libpixyusb.a [100%] Built target pixyusb -- libpixyusb build complete -- Please run 'install_libpixyusb.sh' as root to install to your system. |
On peut maintenant installer la bibliothèque dans le système
sudo ./install_libpixyusb.sh
|
1 2 3 4 5 6 7 |
pi@raspberrypi:~/pixy/pixy/scripts $ sudo ./install_libpixyusb.sh [100%] Built target pixyusb Install the project... -- Install configuration: "" -- Installing: /usr/local/lib/libpixyusb.a -- Installing: /usr/local/include/pixy.h -- Installing: /usr/local/include/pixydefs.h |
Maintenant que la bibliothèque libpixyusb est installée, on peut compiler hello_pixy qui est un bon test de l’installation, puisqu’il permet d’afficher ce que la caméra envoie sur le port série via USB.
./build_hello_pixy.sh
|
1 2 3 4 5 6 7 8 9 10 11 |
pi@raspberrypi:~/pixy/pixy/scripts $ ./build_hello_pixy.sh mkdir: impossible de créer le répertoire « ../build »: Le fichier existe -- The CXX compiler identification is GNU 6.3.0 -- Check for working CXX compiler: /usr/bin/c++ -- Check for working CXX compiler: /usr/bin/c++ -- works -- Detecting CXX compiler ABI info ... Scanning dependencies of target hello_pixy [ 50%] Building CXX object CMakeFiles/hello_pixy.dir/hello_pixy.cpp.o [100%] Linking CXX executable hello_pixy [100%] Built target hello_pixy |
Pour tester l’installation, il faut lancer hello_pixy.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
pi@raspberrypi:~/pixy/pixy/build/hello_pixy $ sudo ./hello_pixy Hello Pixy: libpixyusb Version: 0.4 Pixy Firmware Version: 2.0.19 Detecting blocks... frame 0: frame 1: frame 2: frame 3: frame 4: frame 5: ... |
Hello_pixy démarre bien et retourne son numéro de version ainsi que la version du firmware installé sur la caméra Pixy. La bibliothèque libpixyusb est donc bien installée et fonctionne. Le cache de la caméra est resté en place, aucune zone de l’image n’est détectée…
Installation de Qt
PixyMon fonctionne sous Qt, la première étape va être d’installer Qt
sudo apt-get install qt4-qmake qt4-default
|
1 2 3 4 5 |
pi@raspberrypi:~/pixy/pixy/build/hello_pixy $ sudo apt-get install qt4-qmake qt4-default 0 mis à jour, 71 nouvellement installés, 0 à enlever et 0 non mis à jour. Il est nécessaire de prendre 26,6 Mo dans les archives. Après cette opération, 106 Mo d'espace disque supplémentaires seront utilisés. Souhaitez-vous continuer ? [O/n] |
puis encore quelques outils
sudo apt-get install qt4-dev-tools
|
1 2 3 4 5 6 |
pi@raspberrypi:~/pixy/pixy/build/hello_pixy $ sudo apt-get install qt4-dev-tools Lecture des listes de paquets... Fait Construction de l'arbre des dépendances Lecture des informations d'état... Fait The following additional packages will be installed: libqt4-sql-sqlite qt4-designer qt4-doc |
Dans mon cas il est resté quelques erreurs résolues par
sudo apt-get update –fix-missing
Il faudra peut-être procéder différemment dans votre cas.
|
1 |
pi@raspberrypi:~/pixy/pixy/build/hello_pixy $ sudo apt-get update --fix-missing |
Après un nouveau passage, ça semble mieux : plus d’erreur signalée 🙂 revenons dans le répertoire pixy
|
1 2 3 4 5 6 7 |
pi@raspberrypi:~/pixy/pixy $ ls build contributors.txt doc license.txt misc README.md scripts src pi@raspberrypi:~/pixy/pixy $ cd scripts pi@raspberrypi:~/pixy/pixy/scripts $ ./build_pixymon_src.sh mkdir: impossible de créer le répertoire « ../build »: Le fichier existe Creating build folder... Starting build... |
On peut tester si la compilation de PixyMon a donné un résultat exploitable… Pour pouvoir communiquer avec Pixy via le port USB en tant qu’utilisateur pi (non root), il faut préalablement définir des autorisations pour Pixy en copiant le fichier pixy.rules puis on peut lancer
./PixyMon
|
1 2 3 4 |
cd ../src/host/linux/ sudo cp pixy.rules /etc/udev/rules.d/ cd ../../../build/pixymon/bin/ ./PixyMon |
PixyMon se lance, c’était le but de cette première mise en route. Le système ne nous a pas renvoyé de message d’insulte… on peut continuer. Fermez cette fenêtre.
Branchez la caméra Pixy sur un port USB du Raspberry Pi et relancez PixyMon.
Cliquez pour agrandir
Cette fois c’est bon ! La caméra a bien été détectée et une image est affichée. Ici c’est du mode « brut », c’est à dire que c’est l’image telle que filmée par la caméra. Il existe une autre option qui permet d’afficher l’image analysée par le processeur embarqué.
Cliquez pour agrandir
Ici en mode « cooked » (cuisiné) j’ai posé un post-it jaune sur la revue. J’ai appris cette couleur à la caméra qui superpose à l’image un rectangle encadrant le bloc de couleur jaune qu’elle a détecté.
Les images sont traitées par le microprocesseur à la cadence de 50 images par seconde. Les blocs de couleur (7 différentes) sont localisés sur l’image en temps réel et les informations concernant chaque bloc sont transmises à la carte chargée de gérer ces informations.
Ceci décharge complètement la carte destinatrice du traitement des images, puisque celui-ci est réalisé à bord de la caméra.
Caractéristiques
- Processeur : NXP LPC4330, 204 MHz, dual core
- Capteur d’image : Omnivision OV9715, 1/4″, 1280×800
- Angle de prise de vue de l’objectif : 75 degrés en horizontal, 47 degrés en vertical
- Objectif : standard M12 (différents types disponibles)
- Consommation : 140 mA typique
- Alimentation : USB 5V ou entrée alim. non régulée (6V à 10V)
- RAM : 264K bytes
- Flash : 1M bytes
- Sortie des données : UART port serie, SPI, I2C, USB, digital, analogique
- Dimensions : 5,3 x 5 x 3,5 cm
- Poids : 27 grammes
Vidéos
Détection d’un faisceau laser
Vidéo de lancement sur KickStarter. On y voit les possibilités de suivi avec un pan-tilt.
Cette vidéo que j’ai réalisée lors de mes tests montre un essai de détection de couleur jaune (post-it) ainsi que les informations envoyées sur le port série par la caméra.
Conclusion
Le but de cet essai était de tester la possibilité d’utiliser la caméra Pixy sur le Raspberry Pi. Mission accomplie. La caméra fait ce pour quoi elle est prévue, détecte bien les couleurs qu’on lui a apprises et envoie les informations de position et taille attendues. Il faudra parfois agir sur les réglages pour affiner les réglages et éviter les fausses détections.
La documentation sur le wiki est abondante et très complète, mais uniquement en anglais. Il faudra compiler PixyMon sur chacune des machines sur lesquelles vous souhaitez l’utiliser. L’exécutable obtenu n’est pas transportable sur un autre Raspberry Pi… J’ai ouvert un topic à ce sujet sur le forum Pixy, mais il semble que la version utilisée pour les sources et celle de Raspbian diffèrent.
La caméra Pixy détecte des couleurs. Elle ne détecte pas des formes, des visages, des codes-barre ou des QR-codes… et ce n’est pas prévu qu’elle le fasse.
L’intérêt de cette caméra est surtout, à mon sens, dans le domaine de la robotique. Elle permet de suivre des objets. Le pan-tilt support de la caméra est directement piloté par la caméra et assure le suivi d’objets. De plus les données fournies par la caméra permettent de piloter un robot pour suivre/saisir des objets…
La caméra est proposée à 100€ par Reichelt et le pan-tilt complet à 50€ (j’arrondis les chiffres 🙂 )auxquels il faudra ajouter les frais de port.
Sources
- https://www.reichelt.com/fr/fr/index.html?ACTION=446&LA=0
- https://www.reichelt.com/fr/fr/index.html?ACTION=7&LA=3&OPEN=0&INDEX=0&FILENAME=C160%252FMOUNT.pdf
- http://cmucam.org/projects/cmucam5/wiki/Teach_Pixy_an_object_2
- http://cmucam.org/projects/cmucam5/wiki/Some_Tips_on_Generating_Color_Signatures_2
- http://cmucam.org/projects/cmucam5/wiki/What_is_the_maximum_distance_that_Pixy_can_detect_objects
- https://www.thingiverse.com/thing:820353
- http://cmucam.org/attachments/694/lpc4300_user_manual.pdf
- http://cmucam.org/attachments/915/cmucam5_1_2.pdf
- http://cmucam.org/attachments/928/pixy_mechanicals.PDF
- https://www.kickstarter.com/projects/254449872/pixy-cmucam5-a-fast-easy-to-use-vision-sensor
Bonjour François,
1) J’ai du mal à comprendre les critiques dont tu as fait l’objet alors que tu soulignes toujours, très scrupuleusement, les articles sponsorisés.
2) Je suppose que la faible définition de la caméra a pour objectif de soulager le processeur de traitement de l’image (moins de pixels à traiter) mais, même si je comprends ce choix technique, cela réserve bien cette caméra à la détection/tracking.
3) Il y a un processeur embarqué mais je n’ai pas lu (j’ai peut-être lu trop rapidement) s’il y a une possibilité de mettre à jour son firmware.
Article très intéressant (comme d’habitude ).
Bonnes fêtes.
Sylvain
Bonjour Sylvain
merci 🙂
oui je pense qu’il faut rester clair là dessus et que quand je reçois du matériel je le précise. Et de toute façon je dis ce que je pense 😛 lors des tests. Ici il fallait voir si cette caméra pouvait fonctionner sur le Raspberry Pi, c’est ce que j’ai fait et mon contact a validé l’article tel qu’il est… et tout n’est pas positif !
Le capteur a en effet une résolution plus importante mais en 640×400 la caméra envoie 50 trames par seconde ce qui permet de localiser les objets détectés toutes les 20ms. On voit dans la séquence du ping pong que le suivi est assez rapide
Pour le firmware ça ne faisait pas partie des tests car la caméra que j’ai reçue était à jour
mais oui, on peut injecter un nouveau firmware. Il faut brancher la caméra sur l’USB tout en tenant le bouton enfoncé. La caméra passe alors en mode « mise à jour » et on peut uploader le firmware (dispo sur le site)
Après pour ceux qui se sentent des talents de dev. comme tous les sources sont fournis, il est possible de réécrire le soft et éventuellement d’implémenter d’autres algo. de détection. J’en parlerai au FabLab du Creusot car le président est prof à l’IUT et chercheur dans le domaine… du traitement d’image 😀
bonne fin d’année si on ne se cause plus d’ici là !
cordialement
François
Merci de ce complément d’informations, ça change tout (en tout cas pour moi).
Après première lecture de ton article, sans suivre tous les liens, mon impression était plutôt mitigée: Produit cher, de faible définition, juste bon au tracking de couleur, sans détection de forme.
A la lecture de ta réponse, j’ai eu envie d’en savoir plus et ma conclusion est complètement différente: Produit génial, ouvert, fait pour les geeks.
Pour ton problème de portage, j’avais tout de suite trouvé la bonne réponse (tu peux me croire sur parole). La réponse que j' »ai lue sur le forum me confirme mon analyse. Tu as juste « oublié » que la compilation n’était pas statique et qu’il faut donc trouver toutes les bibliothèques sur le Raspberry cible (et dans la même version majeure).
Je vois 2 solutions à ce problème, sans avoir à tout recompiler:
1) débutant: cloner la carte SD entière (je rois que maintenant il y a un utilitaire dédié pour cela).
2) Geek: cross-compiler et en profiter pour générer aussi le kernel et le roofs en virant cette **censuré*** de Raspbian. En ce moment, je joue avec buildroot, c’est bluffant. Il semble même (rapide recherche) que buildroot sache compiler pour le NXP LPC4330 qui est aussi un ARM.
Cela serait la voie royale pour « porter » opencv par exemple ou pour basculer du mode tracking à faible définition, au mode photo avec la définition native du capteur (Astrophoto par exemple).
Cela pourrait faire un beau sujet de TP pour un IUT.
Cordialement
Sylvain
Comme je n’ai pas d’éclairage de dancing pour répondre, ma réponse est théorique.
1) La pixycam est capable de mémoriser plusieurs signatures.
2) Pixymon est paramétrable pour indiquer les zones sur-exposées.
3) L’objectif est sur une monture CS, est équipé d’un filtre IR, est interchangeable mais sans diaphragme.
Il doit donc être possible « d’apprendre » le même objet, sous les 2 états extrêmes de l’éclairage du dancing mais la saturation risque de diminuer fortement le taux de reconnaissance.
Sylvain
Ping : Configurer et utiliser la Caméra Pi AI Raspberry Pi - Framboise 314, le Raspberry Pi à la sauce française....