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

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

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

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 :

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

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.

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

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

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

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.

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

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

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.

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

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

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

Cet article Utiliser la caméra Pixy sur le Raspberry Pi a été publié en premier sur Framboise 314, le Raspberry Pi à la sauce française.....