Projets d'élèves

1. Introduction

En hiver, tout le monde décore ses maisons de guirlandes à l'occasion des fêtes, mais des guirlandes sont tout simplement des fils par-dessus lesquels des LEDs sont posés, qui s'allument en suivant une certaine logique. Moi, étant intéressé par les sculptures 3D, me suis dit: et si on faisait cela en 3D? L'idée serait donc de créer un parallélépipède consistué de plusieurs LEDs qui s'allument en suivant un certain pattern. L'avantage principal de créer un modèle de LEDs en 3D, est qu'il est possible d'ajouter un effet supplémentaire sur les patterns affichés. Dans le cadre de ce projet, nous avons décidé d'afficher des ondes sinusoïdales pour pouvoir voir ce qu'il se passe lorsqu'on additionne deux ondes de même amplitude, de même fréquence et de même angle de phase, avec la seule différence que la deuxième onde est la translation de la première onde verticalement, tout en appréciant l'effet 3D apporté lors de l'affichage. En autres mots, le parallélépipède est utilisé comme un modèle mathématique.

Les buts de ce projet d'hiver sont multiples. Premièrement, cela me permet d'apprendre à souder les diverses objets pour pouvoir obtenir un artefact solide. Pour continuer, il va falloir comprendre comment associer les LEDs aux pins du microcontrôleur, car il n'a que 40 pins (et certains ne peuvent pas être utilisés pour ce projet) alors que nous avons 54 LEDs, donc nous ne pouvons pas associer chaque LEDs à un pin. Finalement, ce projet m'aidera à maîtriser la librairie GPIO sur Python comme moyen de codage.

2. Matériel et méthodes

2.1 Matériel

• 54 LEDs vertes 5mm
• Raspberry Pi 3B
• Ordinateur utilisé comme source externe électronique
• Breadboard de taille large
• 21 câbles
• 3 résistors 330Ω
• Matériel de soudure électronique
• Fils conducteurs
• Carton
• Tournevis
• Pince

2.2 Méthode

2.2.1 Construction du parallélépipède

2.2.1.1 Souder les LEDs en plusieurs lignes

Pour faciliter notre vie à souder les LEDs, commençons par trouver un moyen de sorte à ce que nous n'ayons pas de problème à tenir les LEDs pendant que nous soudons. Une idée qui fonctionne est de prendre un bout de carton, puis de tracer au crayon un rectangle, afin de percer 18 trous comme montrés dans la Figure 1. Ensuite, plaçons 6 LEDs sur les trous d'une ligne. Après, à l'aide d'une pince, il faut plier l'anode de la LED pour que cela forme un angle droit avec la cathode et ensuite, il faut également faire un petit pli au niveau de la cathode, qui sera plus pratique pour le point 2.2.1.3 (Figure 2). Finalement, soudons les LEDs au niveau des anodes, pour obtenir une ligne de 6 LEDs. Refaisons cette étape 8 fois sur les 48 LEDs restants pour obtenir 9 lignes de 6 LEDs (Figure 3). Il faut bien faire attention à ce que le flux chauffé ne touche pas une des cathodes. Sinon, nous obtenons un court-circuit lorsque nous cherchons à faire passer du courant!

Figure 1 - Carton avec les trous

Figure 2 - Plis des anodes et cathodes d'une LED

Figure 3 - Lignes de LEDs

2.2.1.2 Former les trois couches de LED

Maintenant que nous avons nos 9 lignes de LED, il faut maintenant souder à nouveau pour obtenir 3 rectangles de LEDs de dimensions 3 x 6 LEDs. Pour ce faire, posons 3 lignes de LEDs sur les 18 trous du carton. Ensuite, sortons les fils conducteurs et puis coupons 15 fils de longueur 7cm chacun. Après, posons 5 de ces fils de sorte à ce que chaque fil touche les 3 lignes et que le premier fil soit entre le premier et le deuxième LED de chaque ligne, le deuxième fil soit entre le deuxième et le troisième fil de chaque ligne, etc. Ensuite, on soude toutes les intersections entre anode de LED et fil conducteur. On obtient ainsi un rectangle 3 x 6 de LED. On répète ces étapes 2 fois afin d'obtenir un total de 3 rectangles de LEDs.

2.2.1.3 Assembler le parallélépipède entier

Il ne reste plus qu'à coller les 3 couches afin d'obtenir notre parallélépipède. Grâce aux petits plis effectués sur chaque cathode, il est facile de relier deux couches à l'aide de soudures. En effectuant la même procédure pour coller la troisième couche au solide précédent, nous obtenons le parallélépipède des Figures 4 et 5.

Figure 4 - Vue de face

Figure 5 - Vue de dessus

2.2.2 Partie électronique

Dans cette partie, le but est de trouver un moyen d'associer chaque LED aux pins. Une manière de le faire est d'utiliser 21 pins: 18 pins connectés aux 18 LEDs de la couche inférieure, 1 pin connectée à une des 3 anodes de la couche inférieure, 1 pin connectée à une des 3 anodes de la couche intermédiaire et 1 pin connectée à une des 3 anodes de la couche supérieure. Dans la Figure 6, vous trouvez les pins directement reliés par un câble au GPIO. Mis à part les 17 pins GPIO standards du microcontrôleur, il a aussi fallu utiliser les pins CE0 (GPIO 8), CE1 (GPIO 7), MOSI (GPIO 10), MISO (GPIO 9) afin de contrôler l'état des 54 LEDs. Une idée pour pouvoir connecter un pin à une anode qui ne se trouve pas sur la couche inférieure est d'effectuer l'astuce suivante: on prend un fil conducteur et on décide de souder le bout du fil à l'anode afin de relier le breadboard sur lequel se trouve le pin à l'anode.

Figure 6 - Connexions entre pins et LEDs

2.2.3 Code

Pour le code, les librairies nécessaires sont RPi.GPIO et time. Tout d'abord, pour être capable d'allumer une LED, l'idée est de mettre le pin connecté sur la colonne en GPIO.HIGH et le pin connecté sur la couche en GPIO.LOW pour que le courant passe par la LED. Par exemple, pour allumer la LED à coordonnées (1,1,2), il faut mettre le pin 17 en GPIO.HIGH et le pin 9 en GPIO.LOW. Le code se repose principalement sur ce concept. Pour coder un certain pattern, j'ai décidé d'introduire plusieurs fonctions. La première fonction ongrid(x,y,z) consiste à allumer la LED à la ligne x, colonne y et couche z.

def ongrid(x,y,z):
       if z==1:
           GPIO.output(BOTTOM_ROW, GPIO.LOW)
           GPIO.output(MIDDLE_ROW, GPIO.HIGH)
           GPIO.output(TOP_ROW, GPIO.HIGH)
           GPIO.output(columns[y+6*(x-1)-1], GPIO.HIGH)
       if z==2:
           GPIO.output(BOTTOM_ROW, GPIO.HIGH)
           GPIO.output(MIDDLE_ROW, GPIO.LOW)
           GPIO.output(TOP_ROW, GPIO.HIGH)
           GPIO.output(columns[y+6*(x-1)-1], GPIO.HIGH)
       if z==3:
           GPIO.output(BOTTOM_ROW, GPIO.HIGH)
           GPIO.output(MIDDLE_ROW, GPIO.HIGH)
           GPIO.output(TOP_ROW, GPIO.LOW)
           GPIO.output(columns[y+6*(x-1)-1], GPIO.HIGH)

où BOTTOM_ROW = 8, MIDDLE_ROW = 9, TOP_ROW = 10 et columns étant l'array contenant les 18 nombres des pins connectés aux 18 LEDs de la couche inférieure.

La deuxième fonction offgrid(x,y,z) consiste à faire le procédé opposé: à éteindre la LED à la ligne x, colonne y et couche z. Cette fonction est particulièrement utile pour introduire la fonction suivante: offcube()

def offgrid(x,y,z):
   if z==1:
       GPIO.output(BOTTOM_ROW, GPIO.HIGH)
       GPIO.output(MIDDLE_ROW, GPIO.HIGH)
       GPIO.output(TOP_ROW, GPIO.HIGH)
       GPIO.output(columns[y+6*(x-1)-1], GPIO.LOW)
   if z==2:
       GPIO.output(BOTTOM_ROW, GPIO.HIGH)
       GPIO.output(MIDDLE_ROW, GPIO.HIGH)
       GPIO.output(TOP_ROW, GPIO.HIGH)
       GPIO.output(columns[y+6*(x-1)-1], GPIO.LOW)
   if z==3:
       GPIO.output(BOTTOM_ROW, GPIO.HIGH)
       GPIO.output(MIDDLE_ROW, GPIO.HIGH)
       GPIO.output(TOP_ROW, GPIO.HIGH)
       GPIO.output(columns[y+6*(x-1)-1], GPIO.LOW)

La dernière fonction offcube() permet d'éteindre toutes les LED du parallélépipède.

def offcube():
   for x in range(3):
       for y in range(6):
           for z in range(3):
               offgrid(x+1,y+1,z+1)

A l'aide de la fonction ongrid(x,y,z) et offcube(), on arrive à créer les ondes sinusoïdales! L'astuce clef est de noter le code comme des blocs de

time.sleep(speed) 
offcube()

Le but de ces mini-blocs est d'éteindre toutes les LEDs, de remettre tous les pins en colonne à GPIO.LOW et tous les pins en couche à GPIO.HIGH, avant d'allumer les LEDs et de remodifier l'état des pins.

3. Résultats

Dans les figures ci-dessous, nous pouvons voir les modèles mathématiques en 2D et en 3D que nous cherchons à reproduire lors de l'affichage sur le parallélépipède.

Figure 7 - Modèle mathématique en 2d

Figure 8 - Modèle mathématique en 3d à reproduire sur le parallélépipède

Figure 9 - Vidéo du parallélépipède qui affiche les ondes sinusoïdales

Dans la vidéo jointe, les 3 ondes sinusoïdales sont clairement projetées sur le parallélépipède: la troisième étant plus ou moins la somme des 2 autres.

4. Discussion

Les objectifs de ce projet ont été atteints: le parallélépipède fonctionne et les courbes sinusoïdales sont clairement affichées. Afin d'obtenir une somme des ondes plus précise, il aurait été plus judicieux d'augmenter les dimensions du parallélépipède, mais mis à part cela, le tout marche bien. Une difficulté majeure a été d'effectuer le soudage correctement et précisément: en effet, si une partie de la soudure touche un anode ainsi qu'une cathode, il y a court-circuit. Il faut donc être très prudent dans ce type de manipulation. En effet, sinon, l'output final sera totalement différent, même si le code exécuté est cohérent. Moi, n'étant pas du tout familier avec le soudage au début de ce projet, ai été très maladroit au début, ce qui a crée plusieurs soudures assez sales. Certes, le parallélépipède fonctionne, mais il y a un risque non-négligeable à ce que le parallélépipède ne marche pas à cause de telles soudures. Aussi, une erreur que j'avais commise était de ne pas pousser le wedge contre le breadboard suffisamment fort. A cause de cela, certaines LEDs ne s'allumaient pas à cause de la connexion faible entre microcontroller et LED. Donc, c'est super important de vérifier que le wedge est bien connecté au breadboard. Une autre difficulté que j'ai affrontée est le fonctionnement pour allumer une LED du parallélépipède. Il est important de garder le pin associé à la colonne en GPIO.HIGH et celui associé à la couche en GPIO.LOW pour pouvoir laisser le courant passer. De base, je pensais qu'il fallait mettre les 2 en GPIO.HIGH, mais après avoir examiné ce qu'il se passe de plus près, on arrive à retomber sur le bon chemin. Aussi, le simple fait de poser le parallélépipède sur le breadboard a été un autre problème. Il faut le manipuler avec prudence et mettre de la force aux bons endroits afin que l'objet ne se casse pas. Ce n'est qu'à ce stade que nous voyons l'importance d'avoir mesuré les espaces entre les trous du carton! Ayant sous-estimé l'importance d'être précis au début du projet, j'ai eu du mal à déposer mon parallélépipède, mais avec un peu d'agilité et de patience, on s'en sort.

Concernant la gestion du temps, il est vrai que j'aurais dû m'y prendre un peu plus à l'avance, mais je m'en suis assez bien sorti pour finir. J'ai clairement sous-estimé le temps que la partie hardware allait me prendre. Une leçon que j'ai apprise à travers ce projet, est de savoir concrètement ce qu'il faut faire à chaque étape avant de s'y attaquer. En effet, au début, la première idée venue en tête était d'apprendre la méthode de Charlieplexing, mais elle ne s'est pas révélée utile dans ce projet (mais si on s'intéresse à rendre ce parallélépipède plus grand, alors cette méthode va se révéler comme primordial). Ce souci m'a fait perdre pas mal de temps. Après cela, j'ai heureusement réussi à me placer dans la bonne direction, et me suis dirigé dans le monde du soudage. Pour moi, c'était la partie la plus difficile du projet. En effet, il faut d'abord trouver comment fixer les LEDs de sorte à ce qu'elles ne bougent pas, et puis ensuite de souder au bon endroit et patiemment. J'ai dû dépenser environ 10 heures rien que pour cela. Ensuite, la partie électronique m'a pris à peu près 4-5 heures pour comprendre comment être capable de relier les LEDs aux pins afin qu'il soit possible de faire passer le courant dans toutes les LEDs. De plus, une des mes LEDs ne fonctionnait pas car la cathode était justement collée à l'anode, et j'ai perdu beaucoup de temps à comprendre pourquoi la LED ne s'allumait pas. Je croyais que le problème se trouvait ailleurs. Finalement, la partie codage m'a pris 2-3 heures pour bien comprendre comment créer un pattern à l'aide de diverses fonctions.

5. Conclusion

En conclusion, les objectifs principaux de ce projet ont été clairement atteints: j'ai réussi à construire mon propre parallélépipède, en ayant en même temps appris à souder, à associer les LEDs aux pins astucieusement, à plus se familiariser avec la librairie GPIO. L'avantage principal de ce parallélépipède est non seulement réussi à créer un moyen d'afficher des patterns plus élégamment, mais l'objet peut être utilisé comme un modèle mathématique qui nous aide à mieux voir certains concepts . Une piste envisageable pour améliorer ce projet serait d'augmenter les dimensions du parallélépipède et puis de considérer de coder des patterns plus complexes, par exemple, des hélices. Dans ce cas, la difficulté principale serait de trouver un moyen plus efficace d'associer les LEDs aux pins, il faudra dans ce cas entrer dans le monde du Charlieplexing et puis de comprendre comment le codage fonctionne avec cette méthode.

Références

1) Le soudage: https://www.youtube.com/watch?app=desktop&v=Qps9woUGkvI

2) Source d'inspiration pour la construction de cet artefact: https://www.raspberrypi.org/forums/viewtopic.php?t=190981

3) Utilisation de pins GPIO supplémentaires: https://www.raspberrypi.org/forums/viewtopic.php?t=25031