Projet PCB CV

L’introduction

Je suis un étudiant en 2ème année de classe préparatoire intégrée à l’ECE, et pour ma prochaine année, je souhaite faire de l’alternance afin d’en apprendre davantage sur le domaine qui m’intéresse, à savoir le monde de l’électronique, et plus particulièrement l’électronique en systèmes embarqués.

L’alternance m’offre l’opportunité de me professionnaliser plus rapidement et d’apprendre directement auprès d’acteurs du secteur, tout en alliant théorie en cours et un côté plus concret en entreprise.

L’idée

Pour pouvoir y arriver, je devais donc trouver une alternance dans ce domaine. J’ai commencé à déposer mon CV dit « classique » un peu partout dans différentes entreprises liées à la conception de cartes électroniques. Mais sans grand succès, je me suis donc dit qu’il fallait privilégier un CV de qualité plutôt que d’en distribuer un de façon quantitative. Je me suis alors fixé comme objectif de créer un CV nouveau, original, qui me permettrait de sortir du lot.

Une idée m’est alors venue en tête. En cherchant à relier ma passion pour les nouvelles technologies et mon côté maker, j’ai trouvé le concept : un CV interactif, le tout sur une carte électronique physique.

Me voilà alors avec une idée, je me mets à réfléchir aux différentes façons de rendre cela interactif. La première idée a été d’ajouter un écran à la place de la photo originale. Cet écran permettrait d’afficher un portrait, mais aussi de servir de centre de contrôle, avec des boutons pour naviguer.

Je me suis ensuite demandé quelles informations pourraient être numérisées et rendues interactives. J’ai alors pensé aux niveaux de langue que certains candidats représentent avec des points (par exemple 4 points pour le français et 2 pour l’espagnol). Ces points m’ont fait penser à des LEDs que l’on peut allumer ou éteindre.

Cependant, je me suis rapidement retrouvé face à une contrainte d’espace et de design. Je ne savais pas vraiment où placer la partie concernant mes compétences. Je me suis alors dit qu’on pouvait graduer une compétence comme une langue. Je cherchais ensuite comment alterner entre langues et compétences, et la solution a été d’utiliser de petits écrans OLED.

La conception

Me voilà alors avec le concept du point de vue de l’utilisateur du CV. Mais maintenant, il fallait donner vie à tous ces écrans et boutons : c’est là que commence la partie plus technique.

Avant ce projet, je connaissais le fonctionnement des circuits imprimés et leur composition (2 couches, 4 couches), mais sans entrer dans les détails techniques. Je devais donc apprendre un nouvel outil pour concevoir ce projet. Je me suis tourné vers KiCad, qui est open source et gratuit.

Je savais que pour faire fonctionner tout cela, il me fallait un « cerveau » : un microcontrôleur. Après plusieurs recherches en fonction de mes besoins, je me suis tourné vers un STM32 de STMicroelectronics.

Je ne voulais pas prendre quelque chose de trop énergivore ni surdimensionné pour un projet de cette taille, j’ai donc retiré l’ESP32 de la liste, car il proposait beaucoup de fonctionnalités non utilisées dans mon cas.

Concernant l’alimentation, j’avais besoin de deux tensions différentes : du 3,3 V pour les composants comme les écrans ou le STM32, et du 5 V pour les LEDs. Pour générer ces deux tensions, j’ai effectué des recherches et choisi le TPS6216x pour le 3,3 V et le TPS61022 pour le 5 V.

Enfin, je voulais que le tout soit portable, j’ai donc intégré une batterie Li-Po 1S de 1000 mAh, rechargée via un TP4056.

Une fois le choix des composants fait, j’ai commencé à me familiariser avec KiCad. Cela s’est fait assez rapidement, car j’avais déjà utilisé des logiciels de conception de schémas comme Proteus ou Quartus lors de projets à l’école.

La première étape a été la conception du schéma, avec toutes les connexions entre les composants : l’écran au STM32, puis les 5 autres petits écrans.

Pour ces écrans, j’ai découvert qu’il existait un problème d’adressage I2C : plusieurs écrans partagent la même adresse, ce qui rend la communication difficile. Pour pallier ce problème, j’ai ajouté un TCA9548A, qui permet de séparer les bus I2C et de gérer plusieurs périphériques ayant la même adresse. J’ai donc connecté tous les écrans à ce composant, puis au STM32.

Une autre contrainte rencontrée concerne la mémoire flash du STM32, limitée à 128 KB. Pour un projet avec affichage d’images, cela devient rapidement insuffisant. J’ai donc ajouté une mémoire flash externe de 64 Mbit afin de stocker les images et de garder une marge pour de futures implémentations.

J’ai également ajouté les résistances et condensateurs nécessaires en me basant sur les datasheets, ainsi que les éléments indispensables comme le quartz pour le STM32.

Avant de passer à l’étape suivante, il ne faut pas oublier d’assigner une empreinte à chaque composant. Cela correspond à la forme des pads et à leur disposition sur la carte. Par exemple, pour une LED simple, il faut deux pads espacés de 2,54 mm. Pour choisir la bonne empreinte, il faut sélectionner les composants chez un fournisseur, vérifier leur disponibilité, puis utiliser leurs dimensions exactes.

L’étape suivante a été le routage des composants sur la carte. J’ai choisi de travailler sur une carte 4 couches, avec un plan de masse et un plan d’alimentation en interne, et les signaux sur les couches externes.

Pour le routage, j’ai utilisé des vias afin de passer d’une couche à l’autre et connecter tous les composants.

Après avoir effectué les tests comme le contrôle des règles de conception (DRC), corrigé les problèmes de connexions manquantes ou de sérigraphie mal placée, et vérifié les schémas ainsi que les valeurs des composants, j’ai passé commande auprès de fabricants de PCB comme JLCPCB, ainsi que les composants sur Digi-Key.

À ce jour (19/03), j’ai reçu les composants et les cartes devraient arriver la semaine prochaine. Ce projet est encore en cours et sera documenté prochainement avec le montage et la soudure des composants, et j’espère obtenir une carte fonctionnelle.

Ce projet a été enrichissant et l’est encore par ses différents aspects techniques et créatifs. J’ai pu commencer à développer certaines compétences dans le domaine de la conception de systèmes embarqués. Je suis conscient que j’ai approché ce domaine qu’en surface, mais il m’a vraiment donné envie de continuer sur cette voie. C’était un projet très passionnant où je n’ai pas eu besoin de regarder à un seul moment l’heure qu’il était.

Pour ce projet je me suis documenté sur différents forums et vidéos YouTube qui m’ont permis de comprendre les différents fonctionnements des composants et comment utiliser KiCad.

Le montage et les tests

Je commence par souder la partie alimentation 5V et 3.3V, la soudure a demandé beaucoup de précision pour les résistances et condensateurs qui mesurent 1 mm pour certains.

Je branche pour la première fois la batterie et réussis à mesurer les bonnes tensions, tout allait bien, mais je ne savais pas encore que quelques minutes plus tard le découpeur 5V allait lâcher. Voilà le premier problème que je rencontre : la puce est très sensible au bruit et je n’avais pas pris ce facteur en compte lors de la conception, et je n’avais pas respecté mon routage conseillé par le datasheet, ce qui fait que la puce court-circuite. J’avais fait ce constat après quelques mesures au multimètre.

Cela ne m’a pas empêché de continuer, car la partie 5V est utilisée seulement pour alimenter les LED. J’ai donc poursuivi le montage en soudant le STM32 avec toutes ses résistances et capacités.

Celui-ci a fonctionné parfaitement, grâce au ST-Link j’ai bien réussi à le connecter à mon ordinateur, sur lequel je l’ai configuré grâce au logiciel STM32CubeIDE. J’ai configuré les pins pour leur assigner les bonnes fonctions.

Puis j’ai repris la soudure pour souder la mémoire, puis le grand écran et le buffer pour les LED.

Tout était soudé, maintenant place aux tests de chaque partie.

Le test du grand écran a été concluant et j’ai réussi à afficher du texte sur ce dernier.

J’ai pu essayer les LED aussi : en alimentant la carte avec mon générateur de tension, réglé à 5 V 1 A, les LED s’allumaient mais ne changeaient pas de couleur. Elles étaient donc mal contrôlées par le STM32. Après quelques recherches, je découvre que les LED ont besoin d’une fréquence de communication spéciale de 800 kHz, mais la pin sur le STM32 que j’avais choisie ne le permettait pas. J’ai donc dû changer de pin et souder une nouvelle liaison. Au final, cela a fini par fonctionner.

Tout se déroulait très bien jusqu’au moment d’essayer de communiquer avec les 5 petits écrans I2C connectés à la puce TCA9548APW.

J’ai passé des heures à essayer de trouver le problème, je pensais tout d’abord qu’il s’agissait d’un problème logiciel qui n’arrivait pas à attribuer les bonnes adresses aux écrans, mais après des tests au debugger j’ai constaté que toutes les adresses ne répondaient pas, donc pas de communication établie entre le STM32 et le TCA.

Après de longues recherches, je revérifie tout et me rends compte que le pinout n’était pas le bon. Dans la conception KiCad je m’étais trompé de puce, ce qui a totalement changé le pinout.

Maintenant que j’ai trouvé la source du problème, il me fallait une solution.

Je pouvais commander un module pour le mettre à l’arrière de la carte, mais le temps de livraison était trop long.

J’ai donc décidé de souder le tout avec des fils. Cette solution n’est que provisoire et très instable, mais après de longues heures de soudure très minutieuse, j’ai réussi à connecter les 5 écrans à la puce. Je précise que c’est juste une solution provisoire mais fonctionnelle.

J’ai alors réussi à faire marcher les 5 écrans.

Dans l’ensemble la carte marche plutôt bien, sauf deux grosses erreurs qui m’ont permis d’apprendre et de ne plus faire ce genre d’erreurs de débutant, ces dernières sont :

• Bien vérifier ses circuits avant le lancement de la production et revoir même les points où on est sûr qu’il n’y a aucun problème,

• Et avant de choisir une puce, bien chercher les différents problèmes existants.

Pour l’alimentation 5V, j’ai commandé un module booster 5V que je souderai à la carte.

La prochaine étape est la programmation avec les différents menus et la gestion de la mémoire pour stocker les images dans la mémoire flash.