Version actuelle datée du 17 juin 2019 à 21:29

Présentation générale

Projet : Afficheur d'images à billes 

Le but de ce projet est de réaliser un nouveau format d'afficheur capable de concurrencer les systèmes préexistants. Il devra pouvoir afficher des images en continu grâce à des billes de couleurs.

Etudiants: Flora DZIEDZIC et Martin MICHEL

Encadrants : Messieurs Xavier Redon, Alexandre Boé et Thomas Vantroys

Description

Nous voyons souvent aujourd'hui des afficheurs composés de LED, que ce soit sur nos écrans de téléphone, pour afficher des publicités ou des informations dans des halls de gare par exemple. Contrairement aux idées répandues, même si de grands progrès ont été faits dans la gestion d'énergie, ces afficheurs à LED consomment beaucoup même s'ils sont utilisés pour des affichages semi-statiques.

Nous devrons partir de zéro afin de penser un tout nouveau système capable d'afficher une image en couleur et en continu. Pour réaliser un tel système, nous avons choisi de nous orienter vers un afficheur à billes. L'élément principal de notre projet sera l'écran d'affichage, jumelé à un système de tri et de stockage des billes.

Objectifs

Le but est que, lorsque l'image affichée est fixe, le système ne consomme pas d'énergie. En effet, le système d'affichage auquel nous sommes confrontés au quotidien nécessite d'être alimenté en permanence pour maintenir l'image à l'écran : sans cela, le panneau s'éteindrait.
De plus, il faudrait que notre système puisse lui aussi afficher des images en plusieurs couleurs prédéfinies. Enfin, nous porterons évidemment une attention particulière au coût global de la structure.

Nous travaillerons bien sûr à une échelle réduite : bien que nous cherchions à concurrencer des systèmes d'affichage de plusieurs mètres carrés, notre réalisation sera un prototype qui pourra être adapté à toute sorte d'utilisation.

Afficheur à bille de face

• Conception mécanique

Nous devons construire un système capable d'amener, d'afficher et de ranger des billes. Il nous faut donc concevoir :

la structure d'affichage

le système de remontée

le système de tri

le système d'ouverture d'un réservoir

l'acheminement de la bille vers l'écran

• Circuit électronique

Nous avons également besoin de connecter différents composants :

une partie capteur pour évaluer la couleur de la bille et sélectionner le bon réservoir

des moteurs pour actionner les différentes parties

Afficheur à bille avec contour de la vis sans fin apparent

• Développement informatique

Afin de contrôler les actions mécaniques en prenant en compte les données (des capteurs par exemple) nous devons développer un programme permettant de :

commander les moteurs en fonctions des mesures (voir capteurs)

sélectionner les réservoirs en fonction des données reçues (image à afficher)

définir la trame/format des données et de la transmission de celles-ci :

soit les données sont envoyées ligne par ligne avec N octets pour les N colonnes

soit toutes les données sont envoyées en une fois

L'alimentation du système pourrait s'adapter au type d'utilisation du projet : elle peut se faire via une alimentation filaire externe, pour les grandes installations de type affichage publicitaire, mais également via une batterie pour des applications portatives.

Schéma afficheur à bille

Analyse du projet

Positionnement par rapport à l'existant

De nos jours, les LED font partie de notre quotidien. En effet, que ce soit pour certains types d'éclairage ou des afficheurs publicitaires intérieurs comme extérieurs, les LED sont omniprésentes. On trouve également aujourd'hui des télévisions à LED. Cependant, celles-ci n'affichant pas d'images pseudo-statiques, nous ne les considérons pas comme un concurrent de notre projet.

Analyse du premier concurrent

Un grand fabricant de panneaux à LED est l'entreprise Winlight, basé à Hambach en France.

Magasin recouvert de LED Winlight de couleurs

Leader en panneaux à LED Digital Media, Winlight propose des solutions d'affichage à LED. Leur spécificité est de fabriquer des écrans géants à LED sur mesure. De plus, depuis plus de 10 ans, Winlight fabrique également des croix de pharmacie avec des LED bleues, spécificité de leurs croix.

Avantages :

• Possibilité de faire de grands panneaux
• Attire l’œil des consommateurs
• Permet de faire des images non statiques

Inconvénients :

• Consommation énorme

Analyse du second concurrent

Afficheur JCDecaux

Dans le milieu publicitaire, nous trouvons également des affichages imprimés. Le leader mondial d'afficheur publicitaire en papier se nomme JCDecaux. Sur les abribus, dans la rue, sur les routes avec des panneaux déroulants, les panneaux publicitaires JCDecaux sont omniprésents.

Avantages :

• Différentes tailles de panneaux
• Permet de changer d'images régulièrement
• Supports multiples : les affiches peuvent être collées partout

Inconvénients :

• Consommation énorme
• La toile est fragile, potentiellement déchirable
• Les affiches sont réimprimées sans arrêt, ce qui coûte cher et n'est pas écologique

Scénario d'usage du produit ou du concept envisagé

Xavier, employé chez Pubextra, entreprise d'affichage publicitaire, est chargé de trouver un nouveau moyen d'affichage peu onéreux. En effet, Catherine de la compta, a fait remonté au patron les dépenses astronomiques de l'entreprise pour la consommation des panneaux publicitaires à LED récemment installés par l'entreprise dans toute la France. Afin de ne pas réduire ses effectifs, le patron a demandé à Xavier de trouver un système permettant de moins consommer d'énergie, tout en gardant le même principe : afficher plusieurs images de marques différentes sur un même panneau, afin d'avoir plus de clients et donc, plus de revenus. Ne pouvant pas dépenser des sommes astronomiques, l'entreprise ne peut se permettre d'acheter de nouveaux panneaux hors de prix.

Après quelques recherches, Xavier tombe sur un site internet de vente de panneaux d'affichage à billes. Il s'agît d'un système automatique à base de billes permettant d'afficher des images. En fonction de l'image désirée, des billes de couleurs vont se placer à la place correspondante. Une fois que l'on désire afficher une nouvelle image, les billes présentes sont évacuées et la nouvelle image est affichée. Pas besoin de la présence d'un être humain, étant donné que les billes remontent dans le système automatiquement. C'est exactement ce qu'il lui faut ! De plus, il y a possibilité de fabriquer n'importe quelle taille d'afficheur étant donné qu'ils sont fabriqués sur mesure. Le système ayant très peu de composants électroniques, le prix reste peu onéreux. Quant à la consommation, une fois l'image affichée, cela ne consomme plus rien, étant donné que l'image est créée avec des billes. Si l'entreprise ne possède qu'un seul client sur un panneau d'affichage, l'image peut rester la même, ce qui ne consomme absolument rien. Grâce à cette solution, Pubextra économisera des centaines d'euros par mois, ce qui lui vaudra bien une promotion. Utiliser ce système fera donc plaisir à Xavier, mais également à la planète !

Réponse aux questions difficiles

• Combien consomme un panneau à LED?

2018: « Un panneau avec une face numérique consomme 7 fois plus que le plus énergivore des mobiliers non numériques, et un panneau avec deux faces numériques consomme 13 fois plus » La consommation d'un afficheur numérique 1 face (de 2m^2) serait de 12 565 kWh par an au lieu de 948 kWh pour les afficheurs publicitaires déroulants de la même taille. La nouvelle question serait ainsi: à partir de quelle durée l'affichage d'une image via notre système est-il rentable par rapport à un afficheur à LED?

Nous ferons une première étude avec des billes en polyamide. Dans des données de constructeur, on trouve que, pour 150 billes d'un centimètre de diamètre, nous avons un poids de 90g En prenant par exemple V=0,01 m/s pour monter une masse de 0.9 kg, le poids à soulever est une force F=m.g soit F=0,09.9,81=0.8919 N.

Ensuite pour la puissance, nous avons P=F.V soit P=0,8919.0,01=0,008919 W. Cela correspond à la puissance brute. Il faut ensuite tenir compte du rendement (réducteur...) que l'on peut dans une première approche estimer à 0,80. Cela va conduire à un moteur de 0.01W On veut comparer avec un panneau de 2m2, soit un tableau de 20 000 billes. Il faudrait donc remonter 134 fois 150 billes, et ainsi consommer 0.01*134=1,34W.

Un panneau à LED consomme 12565kWh. Il faudrait changer l'image plusieurs dizaine de millions de fois pour qu'un afficheur à LED soit plus efficace.

Plusieurs types de matériaux sont utilisables. Pour amener une première quantification, nous nous baserons sur des billes en plastique, en polyamide qui présente des caractéristiques médianes.

• Afin d'économiser des couleurs de billes, serait-il possible de grouper plusieurs billes de différentes couleurs afin de créer d'autres teintes?

Chaque couleur peut être créée grâce à une combinaison de couleurs primaires : c'est ainsi que fonctionnent les pixels. En réglant l'intensité de Rouge, Bleu et Vert, il est possible de répondre à l'ensemble du spectre visible. Nous pourrions donc nous contenter de ces trois couleurs, en en stockant différentes intensités.

On pourrait fixer 3 afficheurs (semblables à celui retenu) les uns derrières les autres et transparents entre chacun. Chaque afficheur est rempli de billes transparentes teintées. La superposition de 3 billes va créer une teinte particulière et donc permet d'utiliser moins de couleurs de billes. Cependant, le nombre de billes total serait bien plus important, puisqu'il faut pouvoir être capable d'afficher une "image" monochrome, et donc avoir les teintes de Rouge, Bleu et Vert correspondantes, soit 3 fois la capacité initiale.

En deuxième solution, on peut penser à des billes très petites. A chaque place, 3 billes de couleurs seraient présentes. Sur le même principe que les pixels, la couleurs des 3 billes forment, de loin, une autre couleur. Cependant, comme la première solution, cela implique un nombre plus important de billes. De plus, nous serions confrontés à de plus grandes contraintes de précisions : plus les billes sont petites, moins grande est la marge sur la taille des trous, cela augmenterait donc les coûts de fabrication.

Préparation du projet

Cahier des charges

Notre afficheur doit avoir une taille de 8x8 et doit pouvoir:

• Changer d'image sans intervention humaine
• Ne pas consommer (ou peu) lors de l'affichage d'une image
• Ne pas afficher deux fois de suite une image complète de la même couleur (afin de gérer le stock de billes)
• Recevoir les images voulues via liaison série

Choix techniques : matériel et logiciel

• 7 Moteurs:
  • 4 servomoteurs permettant de réaliser une liaison glissière FS90 (déjà en stock)
  • 1 servomoteur continu pour la vis de remontée FS90r (déjà en stock)
  • 2 moteurs pas à pas pour amener la bille à l'endroit exact (vis + tapis roulant) [1]
• 2 Roulements à billes (ou système de fixation pour les vis sans fin : à confirmer après étude avec les vis sans fin)
• 70 billes en plastique par couleurs souhaitées [2]
• 1 capteur de couleur TCS34725 (En stock à Polytech)
• Planches de bois et plexiglas
• Arduino mega [3]

Liste des tâches à effectuer

Afin d'arriver au résultat attendu, nous avons décidé de procédé étape par étape afin de vérifier la mécanique du système mais également la partie électronique. Pour cela, nous commencerons donc avec un système différent, qui ne trie pas la couleur des billes dans des réservoirs. Ici, nous ferons monter chaque bille une par une, afin d'identifier sa couleur. Si c'est la couleur souhaitée, on la positionne en haut de l'afficheur afin qu'elle tombe au bon endroit. Si la bille ne nous intéresse pas, elle change de direction et retombe à l'endroit où toutes les billes sont stockées. Pour réaliser ce système, nous devront réaliser plusieurs tâches:

Partie Mécanique

• Faire monter une bille grâce à la vis sans fin
• Séparer les billes souhaitées ou non
• Faire tomber les billes dans l'afficheur ligne par ligne
• Vider l'afficheur pour ensuite le remplir

Partie informatique/électronique

• Analyser une image afin de connaître les billes correspondantes
• Envoyer une image à notre système afin d'envoyer la position de chaque bille (La position des billes sera d'abord envoyée via liaison série, puis ensuite via SPI)
• Gérer les différents actionneurs du système
• Identifier la couleur de chaque bille afin que le capteur de couleur sache si la bille est bonne ou non

Une fois cette partie réalisée, notre afficheur fonctionnera correctement, en effet, une image pourra être affichée. Cependant, cela peut prendre beaucoup de temps si il y a beaucoup de couleurs à traiter ou si la taille de l'afficheur est grande. De ce fait, nous ajouterons des réservoirs correspondant à chaque couleur afin que le système vienne chercher directement la couleur qu'il souhaite. Pour réaliser cela, nous réaliserons les tâches suivantes:

• Revoir totalement le système afin d'y intégrer les réservoirs
• Faire tomber les billes dans leur bon réservoir
• Récupérer une seule bille parmi les réservoirs afin qu'elle aille se positionner au bon endroit

En regroupant ces tâches et les tâches précédemment réalisées, nous devrions obtenir le système souhaité.

Calendrier prévisionnel

Réalisation du Projet

Feuille d'heures

Prologue

Notre projet est très concret et en plus de la conception électronique et informatique, nous avons voulu nous pencher le plus tôt possible sur la partie mécanique. En effet, tout repose sur la façon dont nous avons réfléchi et conçu le système : le nombre et le type de moteurs, combien de capteurs, les différentes parties du montage...

Pendant les premiers jours après l'élection du sujet, nous avons réfléchi individuellement notamment à plusieurs systèmes de remontée pour ensuite mettre en commun nos idées. Plusieurs montages ressortaient.

1. Les billes sont remontées toutes en même temps avec un moulin placé à l'arrière de l'afficheur afin de les remonter vers les réservoirs.

   Avantages : gain de temps en les remontant toutes en même temps

   Inconvénients : compliqué à mettre en place, à imprimer et mécanique complexe, besoin d'une précision assez importante

2. On utilise une vis sans fin pour les remonter à la suite et les trier une par une.

   Avantages : plans de construction pré-existants, adaptés à notre utilisation, mécanique après la remontée moins lourde que celle du moulin

   Inconvénients : besoin d'une précision assez importante pour guider les billes le long du chemin

Après nous être penchés un peu plus sur la conception, nous avons opté pour la vis sans fin. L'étape suivante était de facto l'étude sur OnShape de la création des vis sans fin et du panneau d'affichage, en fonction des tailles des billes. De ce fait, nous pourrons commencer les heures de projet avec un minimum de matériel à tester une fois les billes reçues. Nous aurons également les moteurs afin de tester notre programmation.

Semaine 1

A faire : rendre l'afficheur opérationnel, étude des moteurs, wiki La première semaine a été décisive pour mettre au point l'avancée du projet et l'adapter aux billes reçues. Il est inefficace d'avancer sur toutes les parties en même temps : nous avons décidé d'établir plusieurs étapes d'avancée en précisant le cahier des charges précis pour la partie mécanique, celle de l'Arduino et du PC.

1. regarder la couleur de la bille

   placer le capteur au bon endroit

   l'arduino doit traiter les valeurs du capteur et commander le moteur du

Semaine 2

Lors de cette semaine, nous nous sommes attaqués à plusieurs parties.

Tout d'abord, la partie mécanique. Nous avions déjà imprimé une vis sans fin avant de recevoir les billes afin de mieux imaginer notre système. Cette vis ne correspondant pas aux billes reçues, il nous a fallu redimensionner cette vis afin de la ré-imprimer. Maintenant que celle-ci est imprimée, il va falloir la poncer afin de limiter les frottements mais également la fixer sur un mécanisme permettant de faire remonter les billes correctement.Celles-ci étant très petites (9mm), la marge d'erreur pour la montée est limitée, il faudra donc être précis dans nos mesures. Pour la partie moteur, nous étions partis sur un moteur continu afin de faire tourner la vis sans fin. Nous avons finalement opté pour un servomoteur continu FS90r permettant ainsi de gérer facilement la rotation de la vis.

Suite à cela, nous nous sommes penchés sur la partie code. Grâce aux servomoteurs ainsi que le détecteur de couleur, nous sommes parvenu à détecter la couleur d'une bille, la comparer avec la bille voulue, si elle correspond, on l'évacue au bon endroit, si elle ne correspond pas, on l'évacue. L'idée ici est que, lorsque le système complet sera monté, nous n'aurons plus qu'à intégrer ce sous-système afin de diriger les billes souhaitées en haut de l'afficheur. Pour débuter, nous nous concentrons sur les billes bleues, vertes et rouges. En effet, le capteur de couleur détermine les composantes rouges, vertes et bleues d'un objet. La distinction entre ces 3 couleurs est donc plus facile à implémenter. Les valeurs de couleurs reçues pour un même objet peuvent beaucoup varier d'un moment à l'autre. Établir des intervalles pour chaque composante de chaque couleur est donc très incertain et il est possible, que d'un moment à l'autre, 2 billes différentes se retrouvent dans le même intervalle, il va donc falloir travailler sur cet aspect, afin de pouvoir identifier facilement le jaune, le noir et le blanc.

Semaine 3

Cette semaine est une fois de plus dédiée à la construction. Après avoir modéliser les parties les plus importantes comme l'afficheur ou la vis sans fin, les avoir adaptées aux billes, nous avons commencé à nous pencher sur l'assemblage.

Socle de l'afficheur

Le socle

Afin d'être certain que tous les éléments soient stables et restent à une distance constante les uns des autres, tout le projet reposera sur un socle commun, qu'il a fallu dimensionner. Ce qui n'était pas faisable avant d'avoir les mesures exactes de l'afficheur et de la vis. Puisque tant que nous sommes dans cette première étape du système sans le tri par couleur, il doit également servir de réservoir à billes pour les billes : ce sera l'élément le plus volumineux. Il est impossible de l'imprimer.

• Nous avons d'abord penser à le fabriquer manuellement. A l'aide de carton, nous avons fait des premiers jets ce qui nous a permis de visualiser les dimensions, la place des moteurs, de l'afficheur, de la vis ...
• En travaillant au FabLab de l'école, nous avons pu être en contact avec des personnes extérieures à notre projet, qui nous ont suggéré l'idée d'utiliser la découpeuse laser, au lieu de le construire manuellement. En effet, cela sera bien plus précis tout en ayant l'avantage d'être plus rapide que l'impression 3D. Nous découperons donc une boite, à assembler, dont la face supérieure sera destinée à recevoir les différents composants. A l'intérieur, nous placerons la face de sorte qu'elle soit légèrement penchée et qu'ainsi les billes aillent naturellement vers la vis.

Le rectangle central correspondant à l'afficheur, à droite d'une ouverture pour le moteur ouvrant et fermant la trappe laissant tomber les billes. Il faudra approfondir par la suite la réflexion sur le système de fixation de la vis sans fin et de récupération des billes non-utilisées une fois en haut de la vis : si nous laissons une grande ouverture ou, le cas échéant, quelles dimensions donner aux ouvertures.

Le maintien de la vis

Afin de fixer notre vis sans fin, nous pensons utiliser un système de tiges, fixées en haut et en bas à des bases. En plaçant une pièce assez large entre le moteur et la vis, celle-ci pourra tourner stablement. De plus, nous la fixerons en hauteur à un roulement à bille : elle pourra ainsi effectuer sa rotation sans frottement tout en étant maintenue. De plus, nous utiliserons des tiges qui non seulement la maintiendront mais qui permettront également la remontée des billes. Nous avons construit un prototype, ce qui nous a permis de valider cette option.

Il reste à imprimer le reste des pièces modélisées, afin de voir quelles parties sont incomplètes.

Nous avons également étudié le code afin de voir comment traduire le code Arduino en langage, ce qui reste à approfondir, ainsi que la méthode à employer afin de récupérer les images : il faudra choisir entre une liaison directe série via le PC, une carte SD ...

Semaine 4

Lors de cette semaine, nous avons continué notre avancée sur la partie mécanique de notre projet, qui représente la plus grande partie et difficulté. Avec certaines pièces imprimées en 3D dans la semaine, nous avons pu avancer et modifier certains points.

• Tout d'abord, la partie vis sans fin. Les parties hautes et basses maintenant la vis étant imprimées, nous avons pu couper des tiges de la longueur de la vis afin de maintenir l'ensemble. Face aux problèmes d'impression sur la vis nous avons tout d'abord songé à la réimprimer, bien que nous n'étions pas sûrs du résultat. En nous renseignant sur les différents outils à notre disposition, nous avons préféré changer d'option et utiliser à la place un pistolet 3D afin de régulariser les imperfections. Nous avons ainsi gagné du temps et de la précision considérables. Cette étape est maintenant terminée : la vis sans fin est capable de remonter plusieurs billes simultanément. Le support de la vis permettant de la raccorder au servomoteur étant à présent fixé à la tige, il nous faut à présent tester la rotation en utilisant le moteur, ce qui sera faisable lorsque la vis aura son support dans lequel nous placerons le moteur.
• Ensuite, nous avons eu des problèmes avec l'afficheur. La précision de l'imprimante 3D et l'épaisseur minimale que nous devons mettre provoquent des décalages ainsi que beaucoup de frottements lors de la chute des billes. Après diverses méthodes pour limiter les frottements (ponçage, ammoniaque), nous avons décidé de modifier l'afficheur et son fonctionnement. Avec les imprimantes que nous pouvons utiliser, il est impossible d'augmenter la taille de l'afficheur. Il faut donc diminuer provisoirement le nombre de colonnes ce qui nous permet d'avoir plus de marge : les colonnes sont légèrement plus larges, les billes devraient mieux passer. Nous allons essayer en utilisant des glissières avec des trous placées plus haut que prévu initialement pour que lorsqu'une bille arrive, elle tombe dans le premier trou puis que la seconde passe au dessus de la première et ainsi de suite.

Pour finir, nous avons imprimé le support du capteur de couleur, les dimensions convenant parfaitement.

Semaine 5

Cette semaine, nous pouvons enfin tester les dernières pièces :

• l'afficheur est imprimé, avec un nombre de colonnes réduit. A présent, les billes glissent sans problème. Puisque il est évidemment destiné à être placé verticalement, nous découpons une plaque de plexiglas que nous fixerons à l'avant
• Nous concevons et découpons un système de crémaillère pour nos glissières permettant de faire tomber ou non les billes. Un engrenage est fixé directement sur un moteur et permet le décalage de la planche.

Les différentes pièces sont maintenant conçues, imprimées et testées séparément. Nous pouvons donc passer une étape : monter les pièces sur un même support. Le support final est prévu en bois puisque nous avons accès à une découpeuse laser, plus rapide que l'impression 3D, qui nous fournira des supports bien nivelés. Toutefois, pour assurer sa conception, nous passons par un prototype en carton, qui nous permet notamment d'étudier l'inclinaison nécessaire des différentes pièces afin de faire rouler les billes tout en contrôlant leur vitesse, notamment celle des crémaillères. Nous commençons par fixer l'afficheur à une hauteur qui prend en compte les pentes nécessaires, en bas pour amener les billes jusqu'à la vis sans fin et en haut pour leur faire faire le chemin inverse. Puis nous plaçons la vis sans fin, le capteur et les liaisons entre les pièces en conséquence. Cela nous a permis de voir qu'une fois encore la taille de nos éléments était parfois trop juste. Par exemple, au niveau du capteur de couleur, une fois le moteur placé dans son encoche, la bille n'a plus la place de passer. Nous avons donc du le réimprimer.

En premier prototype, nous concevons le réservoir sous l'afficheur avec du carton. Pour récupérer les billes lors des tests du placement de l'afficheur, cela suffit, mais nous réalisons vite que cette matière est trop malléable, il faudra dès la semaine prochaine faire ce réservoir en bois, a minima, afin d'avoir une inclinaison convenable. Ce sera également l'occasion de finir la fixation de toutes les pièces.

Semaine 6

Deux aspects du projet peuvent être avancés cette semaine : la programmation et la fin du montage.

Bien que nous ayons fait nos tests via l' IDE Arduino, il serait plus rigoureux de le faire en langage C. L'essentiel du programme doit être le contrôle des moteurs grâce à la lecture des données du capteur. Si l'algorithme sera le même entre l' IDE Arduino et le langage C, nous ne pouvons utiliser les mêmes fonctions de lecture et d'écriture. Après avoir pris conscience que le langage arduino se traduit notamment en C++ et pensé à la possibilité d'utiliser ce langage, il nous a été fourni une archive dans le bon langage, qu'il sera sûrement plus simple d'utiliser.

Deuxièmement, nous pouvons enfin fixer toutes les pièces, les unes avec les autres, sur le support. ce support en carton n'est pour le moment qu'un prototype, afin de facilement pouvoir modifier les pièces, dimensions, etc... Nous avons pour objectif de changer les pièces en cartons pour du bois. Les billes étant très petites, nous avons besoin de précision. Un léger décalage entre 2 pièces peut bloquer notre système. Nous avons donc passé une bonne partie de notre temps à monter le système.

Concernant la partie électronique, nous avons effectuer des tests avec les servomoteurs. Ces servomoteurs consommant beaucoup de courant, l'alimentation de l'arduino ne suffit donc pas. Les servo ne supportant pas des tensions supérieures à 6V, la pile 9V que nous possédons ne convient pas. Nous avons donc emprunté un prise secteur 5V afin d'effectuer les tests la semaine prochaine. Le code étant "prêt" à être téléversé sur notre système, il ne manque plus qu'à gérer ce problème d'alimentation et à installer les moteurs afin de réaliser les premiers tests sur notre système complet.

Semaine 7

Moteur vis sans fin

Prototype bois

Le premier prototype nous ayant permis de vérifier la concordance de nos différentes pièces, nous décidons de passer rapidement à des matières plus solides : nous remplaçons le carton par du bois. Nous n'avons plus besoin de la souplesse du carton puisque les ajustements sont faits, tandis que le bois nous apporte rigidité et stabilité. Malgré notre préparation sur le prototype en carton, passer au bois nous prend un certain temps. Il faudra refaire un système d'encoches pour maintenir le tout verticalement.

Après avoir marqué les emplacements de chaque composant, nous devons percer des trous et découper une encoche pour faire passer les différents câbles.

Ensuite, si la plupart des moteurs peuvent être fixés directement sur le support, ce n'est pas le cas de celui de la vis d'Archimède qui doit être aligné avec l'axe de rotation. Coller le moteur à un support impliquerait une précision trop importante et de l'hyperstatisme inutile, nous avons plutôt décidé de le faire reposer sur deux cales. Ainsi nous gardons un certain degré de mobilité tout en restant en contact avec la vis.

Nous avons enfin pu tester notre montage complet, en demandant à l'Arduino des lignes RBVVBR. Un test a été effectué en amenant une bille rouge alors que la couleur attendue était bleu : on voit que la bille est rejetée, puis que le système reprend son cours normal. Lorsque le nombre de billes voulu pour compléter une ligne est atteint, le moteur décale la crémaillière : les billes tombent dans leurs emplacements. Cependant, nous avons été confrontés à quelques problèmes de précision du capteur : la couleur bleue n'était pas bien détectée. Pour l'instant, nous réglons le problème en augmentant la luminosité du milieu (à long terme nous pourrons par exemple placer une LED en plus). Nous pourrons également essayer d'améliorer nos intervalles de détection dans le code.

Semaine 8

Lors de semaine,plusieurs points ont été travaillés.

• Tout d'abord, nous avions un problème au niveau de certains servomoteurs, lorsqu'une action leur était demandé, la précision au niveau de l'angle n'était pas toujours respectée. De plus, il arrivait que lorsqu'un servomoteur fonctionnait, la LED du capteur de couleur se coupait pour ensuite se rallumer. Nous observions également des fluctuations pendant les rotations des moteurs. Après discussion avec un enseignant, nous avons tout d'abord changé les pins de certains servomoteurs. Le capteur de couleur utilisant le protocole I2C, il est possible que les pins 9 et 10 (pins PWM) soient sollicités. Nous avons donc changé ces pins, en observant une légère amélioration. Cependant, le problème persistait. Nous avons alors changé l'alimentation de notre système qui était jusqu'alors uniquement alimenté via le PC. De ce fait, nous avons essayé de brancher une prise secteur variable que nous avons réglée à plus de 7V. L'arduino se gère ainsi de convertir la tension en 5V afin de ne pas dépasser les 6V max supportés par les servomoteurs. Ceci permet une nette amélioration de notre problème.
• Ensuite, nous avons travaillé sur la programmation. La semaine précédente, nous avions un programme qui permettait de rentrer les billes voulues successivement directement via le port série. Le capteur regarde la couleur, si la couleur reçue indique qu'il n'y a pas de bille, la vis sans fin se met à tourner afin de faire monter des billes. Ensuite, il regarde si la bille reçue correspond à la couleur demandée dans le port série pour la placer en haut de l'afficheur. Sinon le cas échéant elle est évacuée. Ce code fonctionnait correctement. Cette semaine, nous avons décidé de nous intéresser à une méthode qui nous permettrait de ne plus être branché au PC. Pour cela, nous avons repris le code précédent sauf qu'une chaîne de caractères est pré-enregistrée, correspondant au dessin voulu. Une fois le programme réussi et que nous sommes parvenus à afficher l'image voulue, nous avons créé un second motif de sorte que, lorsque le premier motif est affiché, celui-ci reste pendant 10 secondes avant d'être évacué. Le second motif se met alors en route.

Nous n'avons pas pu tester le changement d'image car nous avons eu des problèmes au niveau du capteur de couleurs. En effet, les billes souhaitées n'étaient plus reconnues car les données reçues ne correspondaient plus aux intervalles définis. Pour remédier à cela, nous avons décidé de refaire nos intervalles avec une méthode plus théorique.

Semaine 9

Affinage des réglages

• En étudiant les données récupérées de chaque bille, nous avons conçu des intervalles permettant à notre programme d'estimer à coup sûr si la couleur de la bille correspond bien à celle voulue. Nous les affinons après quelques vérifications empiriques.
• Maintenant que nous perdons moins de temps à cause d'erreur de sélection, nous pouvons affiner le tempo du système. Il faut synchroniser les différents délais des pièces afin d'aller le plus vite possible tout en évitant des interférences entre les étapes : si la vis redémarre trop tôt après qu'une bille soit évacuée de sous le capteur, la bille suivante risque de pouvoir passer en même temps que la première avant même d'être évaluée. Si elles sont éjectées, cela retarde juste le processus, mais si la première bille était de la couleur voulue, la suivante tombera avec elle dans l'afficheur sans que le système ne s'en rende compte.
• Enfin, comme tout au long de ce projet, nous consacrons une partie de notre séance aux réglages physiques. Nous imprimons une pièce afin de remplacer la partie cartonnée qui permettait aux billes de sortir au sommet de la vis sans fin. Il s'agit d'une pièce arrondie permettant de faire sortir la bille de la vis sans fin, sans à coups. De plus nous avons également imprimé un réservoir qui stockera les billes. Grâce à une pente descendant en continu jusqu'au pied de la vis, nous déplaçons les billes jusqu'à un "sas" pour les monter une à la fois. Cependant, le degré de cette pente étant limité, les billes restes bloquées à certains moments. Nous avons donc récupérer un vibreur afin de voir si cela règle notre problème.

Semaine 10

Après discussions avec les enseignants sur la vibration de certains des servomoteurs nous avons récupéré un arduino Mega dans le but de fournir plus de courant. De plus, un Shield Arduino a été rajouté par dessus dans le but de simplifier notre câblage qui est jusqu'ici assez complexe. Résultat de ce changement de carte : seuls 4 fils sont nécessaires pour relier la carte aux différents composants du système, ceux du capteur de couleur. Les servomoteurs sont directement branchés sur le shield. Le bruit sortant des servomoteurs a également disparu, ce qui est une bonne chose : ils ne vibrent plus. L'alimentation externe n'est plus nécessaire au bon déroulement du système.

Concernant le capteur de couleur, tous nos intervalles sont devenus incorrectes. Nous avons donc demandé un nouveau capteur de couleur afin de vérifier si le problème venait directement du capteur. Avec un autre capteur, nos anciens intervalles redeviennent corrects. Il y avait donc un problème de capteur.

Nous avons ensuite cherché à régler le bouchon de billes avant la vis sans fin grâce à un vibreur. Après avoir essayé différents emplacements il s'avère que la solution optimale consiste à placer le vibreur directement à la paroi qui crée le bouchon. Cependant, cela est assez bruyant, nous décidons donc de ne pas le fixer tout de suite, puisque nous pouvons régler ce problème manuellement lors de cette phase de conception.

Semaine 11

Notre premier prototype étant fonctionnel, le seul soucis que nous avons est celui de l'intervalle des couleurs. Cependant, même si nous décidons de les réajuster, la fois d'après, les conditions d'éclairage ne seront plus tout à fait les mêmes. De ce fait, nous décidons de passer à autre chose. Notre but désormais va être d'améliorer notre prototype, de 2 façons différentes.

La première au niveau du programme. Actuellement, nous utilisons l'IDE Arduino. Afin de complexifier les choses, nous allons essayer de réaliser notre programme en C. Nous avons déjà fait quelques recherches et nous nous sommes penché sur le tutorat système des IMA2A4. Dans notre cas, nous avons des difficultés à programmer un moteur.

La deuxième correspond à la partie mécanique. Tout d'abord, nous souhaiterions augmenter la taille de notre système. Cela nous permettrait d'afficher une plus grande image et également avoir des pentes plus importantes, notamment en bas de notre système, ce qui supprimerait le vibreur de notre système et donc réduire la consommation (un des objectif de notre projet). Ensuite, l'image mettant beaucoup de temps à s'afficher en entier, nous avions pensé, au début du projet, à un système de réservoirs, qui permettrait d'appeler la bille voulue directement. Nous devons donc vraiment augmenter la hauteur du système.

Nous avons donc, lors de cette séance, travaillé sur ces différentes parties. Pour faire un système plus grand tout en gardant notre premier prototype le plus longtemps possible, nous allons réimprimer une grande partie des pièces en impression 3D. Nous avons donc modifier des pièces du prototype afin de remédier aux défauts observés. En commençant par la sortie de la vis sans fin directement rattaché au socle supérieur de la vis sans fin. Nous avons ensuite mis un trou dans le grand réservoir en bas du système qui nous permettra de récupérer les billes plus facilement. Il nous reste à modifier la partie inférieure de la vis sans fin, qui nous permettrait de maintenir le moteur directement. Afin de d'agrandir notre système et donc de remonter les billes plus haut, nous avons pensé à 2 systèmes. Etant limité par la hauteur d'impression de l'imprimante 3D, soit nous faisons le même système 2 ou 3 fois de suite. Nous nécessiterons dans ce cas de plusieurs moteurs à courant continu. Autre solution, nous créons une vis sans fin qui s'encastre. Nous pourrions ainsi imprimer plusieurs parties qui s'encastrent et qui forment au final une seule et même vis sans fin.

Nous avons ensuite réfléchit au système de réservoirs. Nous avons ainsi trouvé une courroie, dans le but de transporter un servomoteur qui pousserait une plaque sous un des réservoirs afin de faire tomber une seule bille à la fois. à l'aide d'une planche en bois de 1mm, nous avons trouvé comment réaliser ce mécanisme. Il faut maintenant le mettre en oeuvre.

Annexe

Tout au long du projet, nous avons été dépendants du bon fonctionnement du capteur de couleur. En fonction des conditions extérieures, les valeurs pour une même couleur de bille fluctuent. Elles oscillent généralement plus ou moins autour d'une valeur et toutes ne sont pas significatives : les taux de rouge pour les billes noires et bleues sont évidemment sensiblement les mêmes. Afin de commencer nos tests mécaniques au plus tôt, nous avons manuellement relevé les valeurs en passant les billes une à une sous le capteur et en estimant nous-mêmes les données significatives. Toutefois, ce processus est long et donc imprécis. Nous avons été confrontés à des problèmes de fonctionnement uniquement liés aux valeurs envoyées par le capteur : nos intervalles de reconnaissance pour les billes étaient trop imprécis il fallait donc reprendre fastidieusement les mesures. Même si cette méthode était suffisante pour les débuts de notre projet, nous nous sommes projetés dans l'utilisation globale que nous voulions. Nous nous arrêterons au prototype, mais nous prétendons toutefois concevoir un système applicable à plusieurs centaines de couleurs de billes. Nous ne pouvons donc pas nous permettre de faire ces tests manuellement.

Pour automatiser cette étape, des billes d'une même couleur sont envoyées continuellement au capteur, de manière à avoir un nombre de données suffisant pour pouvoir nous baser sur des règles statistiquement fiables.

Ces données sont envoyées via le port série au PC et redirigées directement dans un fichier couleur.csv cat /dev/ttyACM0 > vert.csv On a ainsi un fichier pour chaque bille contenant toutes les valeurs du capteur. Celles-ci étant envoyées au format adéquat, avec chaque donnée séparée par une , nous pouvons les traiter directement. Pour le faire efficacement, nous utilisons le langage et logiciel R, dédié aux statistiques, afin de remettre en forme nos données et pouvoir obtenir des boxplots. Nous pouvons donc déterminer les intervalles et les critères caractéristiques pour chaque bille en un coup d’œil.

Ci-contre par exemple, un exemple de l'utilisation des boxplots. La bille verte, au milieu, présente un taux de bleu qui se différencie nettement des autres billes. Nous pourrons donc utiliser ce critère lors de l'évaluation de l'état du capteur en étant relativement sûr qu'un taux de bleu entre 500 et 600 correspondra à une bille verte. On remarque également l'absence de boîte pour la bille blanche, mais ce n'est pas un oubli. Nous avons remarqué que les valeurs du capteur dans le cas des billes blanches étaient nettement plus élevées que les autres billes : il sera facile de les différencier, alors que nous avons besoin de plus de précisons pour les autres intervalles.

Cette méthode est certes plus efficace qu'estimer vaguement en étudiant les différentes valeurs du capteur "manuellement", elle reste toutefois perfectible. Bien que nous ayons pris la peine d'effectuer au minimum une quinzaine de mesures, nous aurions pu en faire d'avantage afin d'avoir des estimations d'autant plus précises. De plus, nous restons encore dépendant des conditions extérieures : les mesures faites correspondent à une luminosité relativement constante, le programme pourrait ne pas reconnaître aussi efficacement les couleurs dans d'autres conditions. L'objectif d'appliquer notre projet à des échelles beaucoup plus importantes pourrait être mis à mal. Toutefois, cette méthode automatisant nos études statistiques est répétable efficacement dans n'importe quelles conditions. Il faudra uniquement refaire ces mesures, et éventuellement approfondir l'études des données avec un(e) statisticien(ne).

Documents Rendus

Programme de l'afficheur à bille : Fichier:Code afficheur a bille.zip

Rapport de fin de projet : Fichier:Rapport p28.pdf