Nous voulons fabriquer notre propre caméra infrarouge en utilisant un ou plusieurs capteurs infrarouge, ce qui nous permettra de reconstruire une image. Pour cela, nous utiliserons deux moteurs afin de faire tourner horizontalement et verticalement ce ou ces capteurs.

Deux projets trouvés sur Internet (ici et là) nous ont inspiré lors de la conception de notre projet.

Notre projet peut-être découpé en plusieurs morceaux :

- Mécanique du mouvement du ou des capteurs - Commande du mouvement du ou des capteurs - Traitement des données du ou des capteur

Plusieurs solutions ont été étudiées :

- utiliser de vibreurs piézo-électriques (rejeté):

• la vibration créée sera trop faible pour bouger un capteur
• il est impossible d'utiliser une fibre optique car il s'agit de rayonnements infrarouges

- utiliser uniquement des servos motor (rejeté):

• les calculs de rotation vont être plutôt compliqués, étant donné que les servos fonctionnent en START/STOP. Mieux vaut utiliser un moteur à

cran: l'angle sera plus précis. - utiliser un servo motor ET un moteur à cran (choisi):

• la combination des deux sortes de moteurs permettra de prendre

La première est une illustration du concept et de l'idée que l'on se faisait initialement de l'agencement des deux moteurs. La deuxième image est plus fidèle à la réalité.

Servo moteur DS04-NFC

Moteur fonctionnement en START AND STOP. Engrenage fixable avec des visses.

Spécificités techniques :

• Torsion: 5.5 kg / cm (at 4.8 V)
• Vitesse: 0.22SEC / 60 (at 4.8 V)
• Voltage: 4.8V-6V
• Température: 00 C - 600 C
• Intensité: <1000 mA
• Masse: 38 g
• Dimensions: 4.5 x 1.7 cm

Shinano EM 488-266821G

Moteur pas à pas. Fiche technique

Arduino UNO

site

Spécificités techniques:

• version: Rev. 3
• alimentation: via port USB ou 7 à 12 V sur connecteur alim
• microprocesseur: ATMega328
• mémoire flash: 32 kB
• mémoire SRAM: 2 kB
• mémoire EEPROM: 1 kB
• 14 broches d'E/S dont 6 PWM
• 6 entrées analogiques 10 bits
• intensité par E/S: 40 mA
• cadencement: 16 MHz
• bus série, I2C et SPI
• gestion des interruptions
• fiche USB B
• dimensions: 74 x 53 x 15 mm

Shield

Un shield sert est une carte de puissance pour contrôler des moteurs pas-à-pas, des servo-moteurs et des relais, en alimentant via l’alimentation de l'arduino, soit par une alimentation externe.

Le shield que nous avons n'a ni de référencement ni de fiche technique, il s'agit en effet d'une copie chinoise. Vu qu'Arduino laisse tout en libre service, il est fort probable que le shield que nous disposons soit une copie conforme de Adafruit Motor Shield. Les spécificités sont donc sûrement les mêmes que ce dernier dont vous trouverez la fiche technique ici.

Voici de plus un petit guide détaillant les caractéristiques techniques du shield.

Arduino

Les moteurs vont fonctionner selon le principe suivant:

• les moteurs se placent à la position initiale (position où ont commencera les mesures)
• le servo fait un balayage sur l'axe horizontal et s'arrète quand il a finit sa ligne
• le moteur pas à pas fait un incrément vers le bas pour changer de ligne
• le servo se repart dans l'autre sens pour faire une nouvelle ligne

Ce cycle va se répéter tant que le capteur n'aura pas balayé le nombre de lignes voulues.

Une fois l'image constituée les moteurs vont revenir à la position initiale pour prendre une nouvelle image ou pour rafraîchir l'image déjà prise.

ici les bouton correspondant aux fin de courses sont en réalité des capteurs de fin de course ici le bouton poussoir est le bouton de lancement des mesures et les switch servent de capteurs de fin de course

• la boucle while vérifie si le bouton de lancement des mesures est enclanché
• la fonction retour_zero actionne les moteurs de façon à replacer le capteur à l'origine des mesure

• c'est boucle while qui va constituer l'image parce qu'on a besoin d'avoir un nombre précis de pixels pour constituer l'image
• la fonction retour_zero va replacer le capteur à l'origine des mesures
• le void loop va relancer ces deux autres opérations pour actualiser l'image

• la première boucle if va faire tourner le servo tant qu'il n'a pas atteint son capteur de fin de course
• la deuxième boucle if fait la même chose mais avec le moteur pas à pas

• on donne une vitesse de fonctionnement au servo et il va tourner tant que la condition de la boucle for n'est pas respectée; ici c'est le nombre de pixels (le for va se répéter pour chaque mesure d'un pixel).

Fonctionnement des moteurs:

• servo-moteur: on peut lui donner une commande en vitesse et en sens de rotation; pour le commander il faut entrer servo.write (vitesse).

A la place de vitesse on entre une valeur entre 0 et 180; 0 est la vitesse maximale dans le sens anti horaire, 180 est la vitesse maximale dans le sens horaire, et 90 est la valeur où la moteur de tourne plus.

• moteur pas-à-pas: on lui donne une valeur de vitesse en entrant la commande motor.setspeed(vitesse) et on lui donne la commande motor.step(nombre_d'incrément, sens_de_rotation, nombre de bobines).

 La valeur nombre_d'incrément correspond au nombre de crans que doit faire le moteur, à la place de sens_de_rotation on entre FORWARD ou BACKWARD pour donner un sens de rotation, et on entre DOUBLE, SIMPLE ou COUPLE pour impacter le couple du moteur.

Capteur MLX90614

Site web avec un exemple

Fiche technique

Spécificités techniques :

• Voltage: 3.3V - 5V
• Intensité: 1.2mA
• Température: -70.01℃ to +382.19℃, (0.01 ℃ resolution)
• Interface Type: I2C
• Interface Line Sequence: VCC, GND, SCL, SDA
• Dimensions: 31.5*18 mm
• Image captée: en cône
• Angle du cône: 35°

La connectique n'est pas directement connectable à l'Arduino. Deux possibilités s'offrent à nous:

• Connecter manuellement le capteur à l'Arduino
• Utiliser un connecteur

Envoi des données de l'Arduino vers la RaspberryPi

L'Arduino et la RPi communiqueront via une liaison série par câble USB grâce à plusieurs commandes (de l'Arduino vers la RPi) :

* START (taille de l'image en x) (taille de l'image en y) Commande pour * TOBJ (position en x) (position en y) temperature température de l'objet (à noter que les positions vont de 0 jusqu'à (taille_de_l_image - 1) * TAMB temperature température ambiante * STOP affichage de l'image

Ces commandes sont interprétées par un programme en Python disponible ici. Ce programme à besoin des bibliothèques Python ``numpy``, ``matplotlib`` et ``pyserial`` (voir l'installation de la Raspberry Pi pour plus de détails sur leur installation). Le résultat est une image colorées en fonction des températures minimales et maximales.

Nous avons aussi pu testé la prise de vu d'une ligne avec un servomoteur et le capteur thermique, dont voici deux rendus :

Configuration de la Raspberry Pi

Modèle utilisé : Raspberry Pi A (faute de mieux) Écran utilisé : TFT35“ Touch Shield SKU: AC-TFT35-V2.1 (apparemment très similaire au PiScreen) Système d'exploitation : Raspbian (basé sur Debian stretch)

- ``sudo raspi-config`` pour changer :

1. la configuration du clavier en AZERTY,
2. la langue en français,
3. lancer SSH au démarrage,
4. activer les ports Série, I2C et SPI

- Ajouter ``fbtft_device name=piscreen rotate=90 speed=16000000`` au fichier ``/etc/modules`` - Ajouter ``dtoverlay=piscreen fbtft_device.debug=3`` à ``/boot/config.txt`` - Redémarrer avec ``sudo shutdown -r now`` - Vérifier que l'écran passe de blanc (alimenté) à noir (alimenté et reconnu par le système d'exploitation) - Vérifier que les utilitaires ``con2fbmap`` pour afficher la console sur l'écran et ``fbi`` pour afficher des images (l'installer au préalable avec ``sudo apt install fbi``) fonctionnent correctement avec l'écran - Installer Python 3 et Pip 3 avec ``sudo apt install python3 python3-pip`` - Installer l'utilitaire d'environnement virtuel avec ``sudo pip3 install virtualenv`` - Créer un environnement virtuel avec ``virtualenv –python=python3 venv`` puis l'activer avec ``source venv/bin/activate`` - Installer les bibliothèques nécessaires pour générer l'image de la caméra avec ``pip install numpy matplotlib pyserial``

Une fois la Raspberry Pi configurée, cela donne ceci :

Câblage de la connexion série entre l'Arduino et la Raspberry Pi

Il faut prendre soin d'adapter les tensions entre les deux cartes électroniques !

Le schéma de ce circuit viens de là

<note>La température mesurée dans cette vidéo n'est pas directement la flamme. Celle-ci étant immatérielle on ne peut que mesurée indirectement la température qu'elle génère. Ainsi nous avons visé la partie métallique du briquet.</note>

L'angle de notre capteur est de 35°, ce qui est énorme. Quand des objets seront présenté trop loin, ceux-ci risquent de ne pas être “vus”. Donc cela pose un problème étant donné que le déplacement effectué sera uniquement rotationnel et que l'image (en plus d'être en arc de cercle) sera petite. Le mieux serait donc de réduire l'angle de vue, mais cela est compliqué à mettre en place. Nous passons donc au-dessus ce problème et demandons à ce que l'utilisateur place l'objet ou la surface à mesurer assez proche du capteur.

L'objectif c'est de concevoir un support en 3D pour le capteur thermique. Celui-ci devra relie le capteur au moteur pas a pas de façon à qu'il puisse faire des rotations autour de l'axe des x. Celui-ci sera relié au stepper et à un roulement à bille qui facilitera la rotation.

Mesures pour pouvoir concevoir le support du capteur thermique

Ces mesures ont été faites avec un pied à coulisse qui possède une incertitude de 0,01 mm

• Largeur du capteur: 17,46 ± 0,01 mm
• Longueur du capteur: 32,34 ± 0,01 mm
• Diamètre de l'axe du moteur pas à pas: 7,13 ±0,01 mm
• Diamètre de l’intérieur du roulement à bille: 8,54 ±0,01 mm

Il y a eu beaucoup de problème lors de l'impression et quand nous voulions retirer les fils de construction cela était un peu compliqué et fissurer le support. Cela reste néanmoins possible, il faut juste rester minutieux et patient. De plus nous avons choisi de fixer le capteur sur le support avec du scotch ou de la pâte à fixe pour éviter d'endommager les circuits. Cela peut paraître ridicule, mais ces deux manières restent quand même fiables.

Notre support en 3D doit être suffisamment grand pour pouvoir tenir le moteur pas a pas, mais rester tout de même le plus petit possible pour que le servo motor qui placé dans l'axe du capteur, soit assez puissant pour déplacer toute l'installation. Le support + le stepper + le contre poids doivent donc être le plus léger possible et le stepper doit de plus être en équilibre sur le servo motor. Ce dernier n'est don pas de tout repos. Nous avons laissé un emplacement pour un contre poids, mais celui-ci ne va pas être à la même distance du servo que le stepper (qui est très long et qui prend en conséquence trop de place par rapport à ce que nous voulons. Le contre poids doit donc être plus compact et plus lourd que le stepper. En guise de contre poids nous avons ainsi choisi du laiton (un alliage de Cuivre et de Zinc principalement). Nous devions faire avec ce que nous avions sous la main et il se trouve que le bloc de laiton qui se rapprochait le plus de nos attentes est cylindrique. Pour illustrer voici un bloc de laiton

La conception était assez compliquée et nous avons essayé d'être le plus compact possible. L'objet est assez excentré, nous avons de plus ajouté une case pour placer le stepper. Ainsi il sera protégé et ne risquera pas de tomber lors d'une utilisation.

Dimensions de notre support en 3D (avec le servo moteur):

• Hauteur: 8,5cm
• Longueur: 10 cm
• Largueur: 4,5cm

Lors de l'impression 3D nous avons été confronté à un autre problème. En effet, on a du faire face a l'effet de Warping où les matières se déforment sous l’effet de la température et des forces de tension internes. C'est ainsi qu'on a modifié les paramètres du support pour que celui-ci soit plus dense. L’épaisseur doit être plus grande et avec des traits plus rapprochés pour que le support ait plus de cohésion et est plus dur. support.svg.zip

Nous pouvons bien voir que la base du support est bien arrondi à ses extrémités.

Mesures pour pouvoir concevoir la boite

Pour créer la boite, on doit tenir en compte des dimensions de tous les éléments de notre objet à savoir la Raspberry; l'écran, la Shield, la carte Arduino et notre support en 3D. Voici le schéma montrant l'agencement de toutes les composantes (le 1 est celui que l'on avait conçu initialement, mais nous avons ajouter un écran etc. Nous avons de plus changer la façon de l'ouvrir, pour accéder aux différentes parties. Le 2 est donc celle que nous avons réellement faite).

Comme vous le pouvez voir dans le schéma, notre boite est divisé en deux compartiments. Un compartiment possède notre support 3D alors que l'autre contient les autres éléments de notre objet. Pour connaitre la longueur du premier compartiment, on a du tenir en compte que notre support va faire une rotation de 45° selon l'axe de rotation x (Voir premier schéma). Dans ce schéma, on s’intéresse a la longueur LM' ET PN'. On a utilisé des différentes formules de trigonométrie pour en déduire que LM'= sin(45°)*OM' soit LM'=4,8 cm. De même, PM'= LM'+ sin(45)*M'N' soit PM'=6,4 cm

Ainsi, sachant que notre support 3D va faire une rotation de 45° de chaque coté, on peut déduire que la longueur de notre premier compartiment va être de 6,2*2=12,4 cm. On va laisser une marge de 2 cm.

Dimensions du premier compartiment:

• hauteur= 12 cm
• longueur= 14,5 cm
• larguer= 14 cm

Dimensions du deuxième compartiment:

• hauteur= 12 cm
• longueur= 14 cm
• larguer= 14 cm

Dimensions de la boite dans sa totalité:

• hauteur= 12 cm
• longueur=28,5 cm
• larguer= 14 cm

Nous avons fait de nombreuses plaques avec des dents, pour que nous puissions les emboîter et construire la boîte à partir d'une plaque de contre plaqué de peuplier de 6 mm. Voici le résultat après l'avoir mis ensemble:

Guide pour la relation arduino/ servo