Chapitre III

: Réalisation du
système
de
spin-coating
III.1 Introduction

Dans ce chapitre, nous décrivons les étapes de la réalisation de

notre système de spin-coating. Pour commencer, nous avons
assemblé un premier prototype sur une plaque d'essai en utilisant
une carte Arduino Uno afin de tester si les composants principaux,
comme le moteur, l'écran LCD, le clavier à membrane, le buzzer et
l'alimentation, fonctionnaient correctement.

Par la suite, nous avons conçu et fabriqué de manière autonome une

carte de circuit imprimé. Ainsi, nous avons séparé le microcontrôleur
ATmega328P de la carte Arduino Uno pour le contrôler de façon
indépendante et gérer le système.

Enfin, l'ensemble du système a été intégré dans un boîtier conçu

pour protéger les composants, améliorer l'esthétique et garantir un
fonctionnement stable et sûr.

III.2 Réalisation du prototype sur platine d'essai

III.2.1 Connexion du moteur DC avec le driver L298N et la

carte Arduino Uno

Nous avons connecté un driver L298N pour contrôler le moteur DC,

qui a été alimenté par une alimentation de 12 V / 5 A. Voici leur
connexion :

 Moteur : Le fil jaune du moteur est connecté à OUT1 (positif) et le

fil vert à OUT2 (négatif).
 Alimentation du moteur : Une alimentation de 12 V / 5 A est
connectée aux bornes +12 V et GND du driver.

Connexion entre Arduino Uno et L298N :

 IN1 et IN2 : Les broches IN1 et IN2 du driver L298N sont connectées
aux broches D11 et D12 de l'Arduino Uno. Ces broches contrôlent la
direction du moteur :
 IN1 HIGH, IN2 LOW : Le moteur tourne dans une direction (par
exemple, dans le sens horaire).
 IN1 LOW, IN2 HIGH : Le moteur tourne dans l'autre direction
(par exemple, dans le sens antihoraire).
 ENA : La broche ENA du driver est connectée à la broche D13 de
l'Arduino Uno, qui fournit un signal PWM pour contrôler la vitesse du
moteur. En jouant sur le rapport cyclique, on arrive à faire varier la
vitesse du moteur.

Pourquoi séparer l'alimentation du moteur et celle de

l'Arduino Uno ?

Nous avons choisi de séparer les deux alimentations dans le but de

protéger l’Arduino Uno. En réalité, le moteur consomme beaucoup
d’énergie. Ainsi, s’il est alimenté par la même source que l'Arduino
Uno, il pourrait causer des chutes de tension, des perturbations, etc.
Cela pourrait affecter le bon fonctionnement de l'Arduino Uno. Afin
de conserver la stabilité, il est préférable d'alimenter chaque
système séparément.

Figure III.1 : Connexion du moteur DC avec le driver L298N et la carte Arduino

Uno.

III.2.2 Solution d'alimentation adoptée

Nous avons choisi d'alimenter le moteur et son driver séparément du
reste du circuit. En effet, nous avons alimenté l'Arduino Uno et les
autres composants avec la même source que celle utilisée pour le
moteur, une source de 12 V / 5 A à travers la broche VIN de l'Arduino
Uno. Celle-ci accepte des tensions comprises entre 7 V et 12 V, et elle
permet à l'Arduino Uno d'utiliser son régulateur interne pour abaisser
cette tension jusqu'à 5 V stabilisés. L'Arduino Uno redistribue ensuite
cette tension de 5 V sur sa broche 5 V afin d'alimenter les autres
composants.

L'écran LCD nécessite une alimentation stable de 5 V pour fonctionner

correctement, connectée directement à cette broche d'alimentation.
Le buzzer reçoit aussi l'électricité via une sortie numérique lorsqu'il
est activé, fournissant juste ce dont il a besoin. Contrairement aux
autres composants, le clavier à membrane ne demande pas de
courant séparé, fonctionnant uniquement grâce aux signaux envoyés
et reçus via les broches numériques de la carte Arduino Uno.

Nous avons évité d'utiliser le connecteur 5 V du module L298N car il

ne fournit pas suffisamment de courant pour alimenter le système. De
plus, dans ce cas, ce connecteur du driver devient instable, surtout
lorsqu'un moteur puissant, tel qu'un moteur DC 12 V 5 A, est
raccordé, ce qui entraîne des chutes de tension, le redémarrage du
microcontrôleur ou même sa défaillance. Il chauffe également lorsque
ce courant est trop élevé. De plus, les moteurs eux-mêmes génèrent
des interférences électriques, qui perturbent le fonctionnement du
microcontrôleur lorsque l'alimentation est partagée. Par conséquent,
pour éviter les risques mentionnés, nous avons connecté la source 12
V du système directement à la broche VIN de la carte Arduino Uno, ce
qui fournit une alimentation stable et protégée.

III.2.3 Connexion de l'écran LCD I2C à l'Arduino

Nous avons utilisé un écran LCD avec interface I2C pour afficher les
valeurs saisies par l’utilisateur, un message de démarrage indiquant
que le système est prêt à être utilisé, ainsi qu’un message de fin de
processus. Nous avons choisi celle-ci pour sa simplicité de connexion
et pour économiser des broches sur la carte Arduino. Voici comment
l’écran LCD I2C est connecté:

Afficheur LCD I2C Arduino

GND GND
VCC +5V
SDA A4
SCL SCL

Figure III.2 : Tableau de branchement du module LCD aux

broches de l’Arduino Uno.
  SDA (Serial Data Line) : Ligne de transmission des données.
 SCL (Serial Clock Line) : Ligne d’horloge de synchronisation.
 A4 sur Arduino Uno : Connectée à SDA.
 A5 sur Arduino Uno : Connectée à SCL.

A4 et A5 sont spécifiques pour l’I2C car elles sont connectées au

contrôleur TWI (Two-Wire Interface) de l'Arduino Uno, qui gère la
communication I2C.

Figure III.3 : Schéma de branchement de l’alimentation sur la

carte Arduino Uno.

III.2.4 Connexion du clavier à membrane

 Le clavier à membrane est utilisé pour saisir les valeurs des

paramètres, les confirmer et réinitialiser le système. Il s'agit d'un
clavier matriciel 4 × 4 comportant 16 touches.
Voici comment il a été connecté :
 Clavier intérieur
Voici le schéma de câblage à l'intérieur.
 Figure III.4 : Schéma de câblage du clavier à membrane à
l’intérieur.

Ligne Colonne Touche appuyée Fonction

Ligne 1 Colonne A 1
Ligne 1 Colonne B 2
Ligne 1 Colonne C 3
Ligne 2 Colonne A 4
Ligne 2 Colonne B 5
Ligne 2 Colonne C 6
Ligne 3 Colonne A 7
Ligne 3 Colonne B 8
Ligne 3 Colonne C 9
Ligne 4 Colonne B 0
Confirmer la
Ligne 1 Colonne D A
vitesse
Confirmer le temps
Ligne 2 Colonne D B
de rotation
Afficher les deux
Ligne 3 Colonne D C
valeurs
Lancer la rotation
Ligne 4 Colonne D D
du moteur
Réinitialiser le
Ligne 4 Colonne A *
système

Figure III.5 : Tableau de la logique interne du clavier à

membrane 4 × 4.
Figure III.6 : Schéma de câblage entre Arduino Uno et clavier
matriciel.

Figure III.7 : Schéma global du premier prototype du système

de spin coating.

III.2.5 Programmation du microcontrôleur

 Après avoir réalisé les branchements sur la platine d'essai, nous avons programmé la
carte Arduino Uno pour assurer le bon fonctionnement de toutes les fonctions prévues.
Le programme est configuré pour réaliser les fonctions suivantes :

1. Bibliothèques utilisées :

 Wire.h : Communication I2C pour l'écran LCD.

 LiquidCrystal_I2C.h : Contrôle de l'écran LCD via I2C.
 Keypad.h : Gestion du clavier à membrane.

2. Déclarations :

 Broches pour le moteur et le driver L298N.

 Broche du buzzer.
 Adresse I2C de l'écran LCD.
 Lignes et colonnes du clavier à membrane.
 Variables pour la vitesse et le temps.

3. Initialisation dans setup() :

 Initialisation de l'écran LCD avec [Link]() et activation du rétroéclairage.

 Configuration des broches du moteur, du buzzer et du clavier.

Saisie des paramètres :

 Lecture des touches du clavier pour saisir la vitesse et le temps.

 Confirmation avec les touches A, B, etc., et émission d'un son via le buzzer.
2. Contrôle du moteur :
 Utilisation de analogWrite() pour la vitesse du moteur avec PWM.
 Contrôle de la direction du moteur avec digitalWrite().
3. Tests individuels :
 Test du LCD, clavier, buzzer et moteur pour vérifier le bon fonctionnement.
4. Téléversement du programme :
 Téléversement du code sur la carte Arduino Uno via l'IDE Arduino.
5. Validation du système :
 Nous avons vérifié le câblage et testé les fonctions de chaque composant
séparément : d'abord l'écran LCD, puis le clavier, le buzzer, le moteur... Une
fois chaque fonction correctement validée, nous avons intégré chaque élément
dans un programme final. Nous avons vérifié que le système fonctionne
correctement : paramètres saisis, fonctionnement du moteur, affichage sur
l'écran et buzzer qui sonne à chaque action. Comme cela fonctionnait bien,
nous avons directement réalisé la carte PCB.

III.3 la réalisation finale sur carte PCB avec un

ATmega328P autonome

III.3.1 Choix de l'ATmega328P autonome

Dans notre projet, nous avons choisi d'utiliser un ATmega328P nu plutôt qu'une carte Arduino
Uno et cela pour plusieurs raisons techniques et pratiques. Premièrement, nous pouvons
fabriquer notre propre circuit imprimé adapté exactement à nos besoins du projet. On ajoutera
seulement les composants nécessaires, ce qui le rendra plus léger, plus propre et plus fiable.

Ensuite, l'utilisation du microcontrôleur seul nous permet un meilleur contrôle du matériel, en

ce qui concerne, entre autres, la puissance, les broches et connexions. De cette manière, nous
allons mieux adapter le système aux performances et éviter les éléments dispensables que l'on
retrouve sur la carte Arduino, tels que les LEDs, l'USB, ou des régulateurs supplémentaires.

Cependant, nous n'avons pas pu utiliser directement cet ATmega328P nu, car il est vierge,
c'est-à-dire que ni le programme, ni le bootloader n'existent dessus et il ne peut pas être
programmé comme une carte Arduino classique directement via le câble USB ou série. Par
conséquent, nous devons d'abord préparer le microcontrôleur en gravant le bootloader sur
l'ATmega328P ou via un autre moyen de programmation.

 Un bootloader est un programme spécial qui est exécuté au démarrage d'un

microcontrôleur. Cela permet de charger un autre programme, tel que le sketch
d'Arduino, dans la mémoire du microcontrôleur via une seule ligne de communication
série.
 Grâce au bootloader, il est possible de programmer l'ATmega328P via l'IDE Arduino
sans avoir besoin d'un programmateur externe. Cela facilite grandement le processus
de développement.

III.3.2 Les différentes méthodes pour programmer un ATmega328P vierge

Avant de pouvoir programmer un microcontrôleur ATmega328P nu, il est essentiel de mettre

en place un câblage minimal permettant son fonctionnement autonome. En effet,
contrairement à une carte Arduino Uno, le microcontrôleur seul ne possède ni circuit
d'alimentation intégré, ni régulateur de tension, ni oscillateur. C'est pourquoi il est nécessaire
de lui fournir une alimentation stable de 5 V, une résistance de pull-up de 10 kΩ de la broche
RESET à VCC, un oscillateur externe, typiquement un quartz 16 MHz entre XTAL1 et
XTAL2, deux condensateurs de 22 pF entre chaque broche du quartz et la masse, et un
condensateur de découplage de 100 nF entre VCC et GND pour filtrer les parasites. Cette
configuration est indispensable pour garantir le bon démarrage du microcontrôleur et sa
stabilité lors de l'exécution ou de la programmation.
Figure III.8 : Câblage de fonctionnement minimal pour l’ATmega328P hors carte Arduino
Uno.

Une fois que le microcontrôleur ATmega328P est prêt à fonctionner de manière autonome, il
existe plusieurs méthodes pour programmer le microcontrôleur. Tout dépend de savoir si on
utilise un bootloader ou non pour ce faire.

III.3.2.1 Programmation via port série UART (RX/TX) avec bootloader

Pour programmer un ATmega328P nu par l'interface série UART (RX/TX) en utilisant l'IDE
Arduino, il est essentiel que le microcontrôleur contienne un bootloader. Le bootloader est un
programme de démarrage situé dans une zone spécifique de la mémoire flash, exécuté au
démarrage du microcontrôleur. Il écoute la liaison série et permet de recevoir un nouveau
programme à stocker, sans qu'on ne doive quand même utiliser de dispositif de
programmation ISP pour chaque mise à jour.

Les étapes les plus importantes sont :

1) Gravure du bootloader sur l’ATmega328P vierge

Comme le microcontrôleur ATmega328P est neuf et qu'il n'a ni

programme ni bootloader, il faut donc le graver. En ce sens, on
utilise l'interface SPI composée des broches MOSI, MISO, SCK et
RESET. Généralement, deux méthodes principales sont utilisées :

 Utilisation d'une carte Arduino Uno comme programmateur ISP (In-

circuit Serial Programming) :

On téléverse le sketch ArduinoISP sur une carte Arduino Uno qui devient un
programmateur ISP. Ensuite, on relie l'ATmega à l'Arduino via les broches SPI et
RESET, et, à partir de l'IDE Arduino, on sélectionne la carte du microcontrôleur,
par exemple, Arduino Uno, et le type de programmateur, par exemple, Arduino as
ISP pour ATmega relié, et on grave la séquence d'initialisation (Burn Bootloader).

 Utilisation d'un programmateur ISP externe (ex. USBasp,

USBtinyISP) :

Ces programmateurs dédiés se branchent directement au microcontrôleur par

l'interface SPI. Depuis l'IDE Arduino, il suffit de sélectionner le
programmateur correspondant (USBasp, USBtinyISP) et de lancer la gravure
du bootloader.. Exemples de programmeurs ISP externe :

 USBasp
 USBtinyISP
 AVRISP mkII
 USB ISP Programmer CH341A
 Pocket AVR Programmer
 Atmel ICE
 Étapes :
1. Connecter le programmateur ISP aux broches SPI et RESET
de l'ATmega328P.
2. Choisir la carte cible dans l'IDE Arduino.
3. Sélectionner le programmateur dans le menu Outils >
Programmateur et lancer la gravure du bootloader.

Cette méthode est plus rapide, fiable, et ne nécessite pas

d'Arduino supplémentaire.

2) Téléversement du programme après gravure du bootloader

Une fois que le bootloader a été correctement gravé dans le

microcontrôleur ATmega328P, il devient possible de programmer ce
dernier via son interface série UART (Universal Asynchronous
Receiver Transmitter), via les broches RX (réception), TX
(transmission), GND et VCC, ainsi que la broche RESET.

 Programmation via un convertisseur USB-série (FTDI,

CH340, CP2102...) :

C'est la méthode la plus courante et pratique pour programmer un ATmega328P

autonome avec bootloader. Elle consiste à utiliser un convertisseur USB-série
qui assure la communication entre l'ordinateur et le microcontrôleur via le port
série.

Modules compatibles:

• FTDI232RL (recommandé)
• CH340G
• CP2102
• PL2303HX
•

 Utilisation de la carte Arduino Uno comme interface USB-

série

Bien que les convertisseurs USB-série dédiés comme le

FTDI232, CH340G ou CP2102 soient pratiques, il est possible de
réutiliser une carte Arduino Uno en tant que passerelle série en
exploitant son circuit de conversion intégré. Deux approches
permettent de détourner cette fonction à des fins externes.

 Premièrement, si le microcontrôleur ATmega328P de la carte Uno

est monté sur un support amovible, il suffit de le retirer afin de
libérer totalement la ligne série (TX/RX) et s'affranchir de toute
 interférence. La carte ne sert alors plus qu'à la conversion,
établissant ainsi une connexion simple entre son port série et celui
du microcontrôleur cible. Cette solution présente l'avantage d'une
mise en œuvre aisée dans un environnement Arduino familier, sans
conflit possible.
 Dans le cas contraire, où le microcontrôleur est soudé directement
sur la carte, on peut malgré tout désactiver temporairement son
fonctionnement en maintenant sa broche de reset à l'état bas. Cette
manipulation via une résistance ou un câble vers la masse permet
au port série de ne servir qu'au microcontrôleur externe pendant le
chargement. Bien que plus astucieuse à mettre en place, cette
approche conserve l'intérêt d'une passerelle série économique et
pratique, notamment pour le prototypage sur breadboard ou le
développement en mode autonome.

III.3.2.2 Programmation d’un ATmega328P vierge via ISP (sans bootloader préalable)

La programmation ISP, ou In-System Programming, est une méthode qui permet d’écrire un
programme directement dans la mémoire flash du microcontrôleur ATmega328P via
l’interface SPI. Cela peut être fait en utilisant les broches MOSI, MISO, SCK et RESET. De
plus, cette méthode de programmation ne nécessite pas que le microcontrôleur contienne un
bootloader et on peut l’utiliser pour la toute première programmation d’un ATmega328P neuf.
Plus précisément, grâce à cette méthode, on peut :

 Graver un programme utilisateur directement dans la mémoire flash,

 Graver un bootloader qui nous permettra de programmer ultérieurement via le port
série UART,
 Configurer les bits de fuse ou les paramètres internes du microcontrôleur.

Méthodes possibles pour programmer via ISP :

On utilise soit un programmateur ISP externe (USBasp, USBtinyISP, AVRISP mkII, …), soit
une carte Arduino Uno configurée comme programmateur ISP.

Remarque : les mêmes outils que ceux que l’on a utilisés pour graver le bootloader, que ce
soit donc un programmateur ISP externe ou une Arduino Uno configurée comme
programmateur ISP, permettent de téléverser un programme directement dans la flash sans
passer par le bootloader.

Un tableau comparatif entre la programmation d’un ATmega328P via UART avec bootloader
et via programmateur ISP externe est présenté en Annexe 2

Afin d’effectuer la programmation de notre ATmega nu, nous avons fait le choix d’utiliser
une carte Arduino Uno configurée en programmateur ISP pour le bootloader. Par la suite, en
retirant le microcontrôleur de cette carte, nous avons utilisé cette dernière pour téléverser le
programme par le port série UART (RX/TX). Nous avons choisi ce mode de programmation
car il est facile à mettre en œuvre, ne nécessite pas de matériel supplémentaire, optimise
l’utilisation de notre unique carte Arduino Uno, et permet de téléverser facilement et
correctement les programmes.

Étapes de réalisation

1) Préparation du circuit minimal de l'ATmega nu

Figure III.9 : Circuit de base pour faire fonctionner l’ATmega328P.

• ATmega328P : Le microcontrôleur principal qui exécutera notre programme.

• Quartz 16 MHz : Fournit une horloge précise pour synchroniser le
fonctionnement du microcontrôleur.
• 2 condensateurs 22 pF : Stabilisent le signal du quartz pour un fonctionnement
fiable.
• Résistance 10 kΩ : Maintient la broche RESET à l'état haut pour éviter des
redémarrages involontaires.
• Condensateur 100 nF (optionnel mais recommandé) : Filtre les parasites sur
l'alimentation pour améliorer la stabilité.
• Alimentation 5 V : Fournit la tension nécessaire au bon fonctionnement du
microcontrôleur.
• Connexions VCC et GND : Assurent l'alimentation électrique entre les différents
composants.

2) Transformation de la carte Arduino Uno en programmateur d’ATmega328P

 Nous connectons notre Arduino Uno à notre PC (sans aucune autre connexion sur la carte).
 Nous ouvrons l'IDE Arduino.
  Nous allons dans le menu Outils > Type de carte > et sélectionnons « Arduino Uno » (qui
nous servira de programmateur).
 Nous allons dans le menu Outils > Programmateur > et sélectionnons « Arduino as ISP ».

Figure III.10 : Sélection de l’option « Arduino as ISP » comme programmateur dans le

menu Outils.

 Nous sélectionnons le port COM associé à notre carte Arduino dans le menu Outils > Port.

Figure III.11 : Sélection du port COM associé à l’Arduino Uno dans le menu Outils.

 Nous allons dans Fichier > Exemples > ArduinoISP et sélectionnons

« ArduinoISP ».
 Figure III.12 : Accès au programme « ArduinoISP » dans Fichier > Exemples.

 Nous téléversons le programme ArduinoISP dans notre Arduino Uno

en cliquant sur l'icône « Téléverser » (ou en allant dans le menu
Croquis > Téléverser).
 Nous débranchons notre Arduino Uno de notre PC (pour que le
câblage qui suit soit effectué hors tension).

3) Graver le bootloader dans la mémoire programme de l’ATmega328P, en

utilisant notre « passerelle de programmation Arduino Uno »

Maintenant que nous avons un Arduino Uno transformé en « programmateur ISP

», nous pouvons procéder à la gravure d’un bootloader au sein de l’ATmega328P.
Pour cela, il convient de réaliser le montage suivant :
 Figure III.13 : Raccordement d’un Arduino Uno configuré en programmateur
ISP avec un ATmega328P.

Comparé au circuit minimal, seuls quelques fils supplémentaires sont ajoutés :

 La ligne D10 de l’Arduino Uno vers la broche 1 de l’ATmega328P

 La ligne D11 de l’Arduino Uno vers la broche 17 de l’ATmega328P
 La ligne D12 de l’Arduino Uno vers la broche 18 de l’ATmega328P
 La ligne D13 de l’Arduino Uno vers la broche 19 de l’ATmega328P
 La ligne +5V de l’Arduino Uno vers les broches Vcc de l’ATmega328P
 La ligne GND de l’Arduino Uno vers les broches GND de l’ATmega328P

Une fois le montage câblé sur breadboard, voici ce à quoi cela ressemble :
 Figure III.14 : Montage sur breadboard pour la gravure du bootloader dans
l’ATmega328P avec un Arduino Uno configuré en programmateur ISP.

Et du point de vue logiciel, voici les étapes à suivre :

Une fois le programme téléversé, nous nous rendons de nouveau dans «

Outils » et nous sélectionnons « Graver la séquence d’initialisation ».

Figure III.15 : Gravure du bootloader dans l’IDE Arduino.

Une fois la procédure terminée, nous obtenons un message dans l'IDE

indiquant que l’écriture a réussi.

4) La Programmation de ATmega328P via un Arduino Uno

sans microcontrôleur (bootloader requis)

• Nous avons une carte Arduino Uno avec un microcontrôleur débrochable.

• Nous avons un ATmega328P avec un bootloader déjà gravé.
• Nous retirons le microcontrôleur de la carte Arduino Uno.
Nous connectons ensuite l’ATmega328P en suivant le schéma de câblage.
 Figure III.16 : Branchement de l’Arduino Uno comme
adaptateur USB-série pour téléverser un programme dans
l’ATmega328P.

Comparé au câblage utilisé pour la gravure du bootloader, il y a quelques

changements :

 RESET (Uno) → RESET (ATmega328P) (pas de changement)

 5V (Uno) → VCC et AVCC (ATmega328P) (pas de changement)
 GND (Uno) → GND (ATmega328P) (pas de changement)
 TX (Uno) → TX (broche 3 de l’ATmega328P) (pas croisé)
 RX (Uno) → RX (broche 2 de l’ATmega328P) (pas croisé)

Nota : il n’y a pas de croisement des lignes RX/TX → TX/RX sur ce schéma,
car ici, il n’y a pas de communication UART entre la carte Arduino Uno et
l’ATmega328P. Le câblage est direct, car on cherche à faire croire à la
carte Arduino que notre ATmega328P est fixée en son sein.

Marche à suivre pour programmer notre microcontrôleur

ATmega328P via une carte Arduino Uno sans ATmega328P

Tout d’abord, nous branchons la carte Arduino Uno à l’ordinateur, le

montage étant déjà relié. Nous ouvrons ensuite l’environnement de
développement Arduino (IDE). Après avoir écrit notre code dans l’éditeur,
nous devons vérifier dans le menu Outils que le port COM correspondant à
notre carte Arduino est bien sélectionné. Il faut également choisir, dans ce
même menu, le modèle de carte « Arduino Uno ». Le programmeur
« AVRISP mkII » doit également être sélectionné.
Pour transférer le programme, il suffit de cliquer sur l’icône « Téléverser »
en haut à gauche, ou de passer par le menu « Croquis » puis
« Téléverser ». Une fois le chargement terminé, l’IDE Arduino peut être
fermé.

Le programme a ainsi été téléversé avec succès, et l’ATmega328P est

maintenant prêt à fonctionner de manière autonome sur le PCB. Il ne reste
plus qu’à souder l’ATmega328P et les autres composants sur la carte pour
finaliser le montage.

III.3.3 Montage de la carte de commande

Le circuit imprimé a été assemblé sur une plaque de montage de 7 × 9 cm. Les
principaux composants ont été directement soudés sur la plaque, tandis que d’autres
ont été fixés mécaniquement ou connectés via des borniers.

Les principaux composants soudés incluent :

 Support DIL 28 broches pour le microcontrôleur ATmega328P, soudé au centre. Le

microcontrôleur peut être inséré et retiré facilement de ce support pour une
maintenance sans risque d’endommager les broches.
 Cristal 16 MHz soudé entre les broches 9 et 10 du support DIL, accompagné de deux
condensateurs céramiques de 22 pF soudés entre chaque broche du cristal et la masse,
assurant la stabilité de l’oscillateur.
 Résistance de pull-up de 10 kΩ soudée entre la broche RESET du microcontrôleur et
le +5 V, afin de maintenir un état logique haut au repos.
 Condensateur de découplage de 100 nF soudé entre VCC et GND près du support
DIL, pour filtrer les parasites électriques.
 Régulateur de tension abaisseur LM2596 soudé sur la carte. Il reçoit l’alimentation
12 V et fournit une tension régulée de 5 V pour alimenter la logique (ATmega, écran
LCD, buzzer).
 Buzzer soudé à proximité du support DIL, connecté à la broche 13 du microcontrôleur
et à la masse pour les signaux sonores.
 Borniers à vis insérés dans les trous de la carte comme supports, dont les broches
métalliques sont soudées en dessous pour assurer la continuité électrique. Les fils
externes sont insérés dans les borniers et fixés par serrage des vis, ce qui facilite la
connexion et la maintenance.

Les composants externes connectés via des borniers incluent :

 Alimentation 12 V / 5 A connectée à un bornier dédié, visible en bas à gauche sur les

photos.
 Module de commande moteur L298N relié par des fils à un bornier spécifique.
 Moteur CC connecté via des borniers à vis.
 Écran LCD I2C branché à un bornier à 4 fils (VCC, GND, SDA, SCL).
 Clavier matriciel branché à un bornier à 8 fils, connecté aux broches numériques du
microcontrôleur.
 Figure III.17 : Carte PCB réalisée pour le système de commande.

Pour connecter un composant externe à une carte de circuit imprimé, il faut d’abord
dénuder le fil du composant externe. Ensuite, ce fil est inséré dans le connecteur déjà fixé sur
la carte. En serrant la vis du connecteur, le fil est solidement maintenu. Ce connecteur est
soudé directement à la carte, de sorte que le signal ou l’alimentation puisse passer directement
du fil externe aux pistes de la carte, et éventuellement au microcontrôleur ou à un autre
composant interne.

En résumé, ce connecteur agit comme une interface entre le fil externe et le circuit de la carte,
assurant une connexion fiable, rapide et modifiable si besoin.

Après avoir terminé la fabrication de la carte PCB et relié tous les autres composants, nous
avons obtenu le circuit final, complet et fonctionnel, illustré sur les photos ci-dessous.
 Figure III.18 : Le circuit final avec la carte PCB fabriquée.

III.4 Fabrication et assemblage du système final de spin-

coating (boîtier et bain)

Une fois que nous avons réalisé la carte PCB et câblé l’ensemble du
montage, tout en effectuant les tests nécessaires pour assurer le bon
fonctionnement électronique, nous sommes passés à la phase finale du
projet : la conception et la réalisation de l’appareil complet de spin-
coating. En effet, notre objectif n’était pas simplement de contrôler la
vitesse du moteur ou d’afficher les informations sur l’écran, mais bien de
fabriquer un appareil complet et efficace permettant d’appliquer notre
technique de revêtement par spin-coating. Pour cela, nous avons créé un
boîtier moderne et fonctionnel grâce à des plaques usinées par CNC. Après
l’avoir conçu, nous avons installé les autres composants, fixé le circuit
électronique, puis facilité son utilisation par une interface conviviale. En
outre, notre boîtier est accompagné d’un bain métallique séparé,
contenant le moteur et un disque rotatif servant de support à la pièce à
revêtir.

III.4 .1 Conception du boîtier principal (boîtier électronique)

La réalisation du boîtier principal pour notre système de spin-coating est une étape
incontournable pour transformer le prototype de laboratoire en un appareil pleinement
fonctionnel, fiable et prêt à l’emploi. Ce boîtier est loin de remplir uniquement une fonction
esthétique : il assure plusieurs fonctions techniques et professionnelles.

1. Pourquoi un boîtier ?

 Protection des composants électroniques : il protège la carte de

commande, l’alimentation et les câbles contre la poussière,
 l’humidité et les dommages mécaniques. Cela prolonge la durée de
vie des composants et garantit la fiabilité du système.
 Sécurité électrique : il isole les parties électriques afin d’éliminer
les contacts accidentels, ce qui réduit le risque d’électrocution et de
court-circuit.
 Stabilité et réduction des interférences : en séparant les
composants électroniques des éléments mécaniques, tels que le
moteur, il contribue à réduire les vibrations et les interférences
électromagnétiques qui peuvent affecter le fonctionnement du
circuit.
 Organisation interne : il permet de monter proprement les câbles
et de les maintenir en ordre, évitant ainsi de les emmêler ou de les
endommager à l’avenir, et de les utiliser comme supports pour les
composants.

Pourquoi avons-nous choisi les plaques CNC plutôt que

l’impression 3D par exemple ?

Pour des considérations techniques et professionnelles, nous avons choisi de fabriquer

le boîtier à partir de plaques usinées par CNC, découpées sur mesure. Ce choix ne
représentait pas seulement une alternative évidente à l’impression 3D, mais répondait
également aux objectifs du projet :

 Précision dimensionnelle élevée : la découpe CNC assure des tolérances serrées,

cruciales pour l’ajustement parfait des composants, tels que l’écran LCD, le clavier,
les connecteurs, etc.
 Meilleure résistance et durabilité : les plaques usinées CNC, souvent en aluminium
ou en PVC technique, présentent une rigidité et une tenue mécanique bien supérieures
aux plastiques imprimés en 3D, qui sont en général plus fragiles. Cette robustesse est
particulièrement importante pour un appareil soumis à des vibrations dues au moteur.
 Finitions industrielles : les plaques CNC offrent un rendu visuel industriel de grande
qualité : les surfaces sont lisses et les arêtes bien nettes. La CNC permet en outre de
graver directement le nom de l’appareil, ce qui apporte un bel aspect visuel et une
finition professionnelle conforme aux standards du marché.
 Meilleure intégration et personnalisation : les plaques CNC permettent de réaliser
des découpes propres et précises pour chaque élément (ouvertures, fixations,
interfaces), là où d’autres techniques artisanales ou industrielles n’atteignent pas
forcément ce niveau de détail.

Rôle fonctionnel et ergonomique du boîtier

Le boîtier remplit deux fonctions importantes. D’une part, il agit

comme une enveloppe de protection pour l’équipement
électronique ; d’autre part, il sert d’interface utilisateur. En ce qui
concerne ce second point, le boîtier est équipé d’un afficheur LCD en
façade et d’un clavier matriciel, tous deux conçus pour être intuitifs
et compréhensibles pour l’utilisateur. De plus, une étiquette
d’instructions est collée directement sur la face avant du boîtier,
indiquant à l’utilisateur comment effectuer la procédure de mise en
route de l’appareil en toute sécurité, sans avoir à consulter un mode
d’emploi externe.

Par ailleurs, le nom de l’appareil est gravé sur les deux côtés du
boîtier, ce qui permet d’identifier facilement le dispositif sur le lieu
de travail et renforce l’image professionnelle de l’appareil.

Le boîtier est également équipé d’une prise électrique intégrée, qui

peut être branchée directement à la source d’alimentation. Cette
compatibilité avec les appareils électroniques professionnels
garantit, d’une part, la facilité de mise en service grâce à l’absence
d’opérations de branchement externes et, d’autre part, un
fonctionnement sûr et fiable.

Enfin, le boîtier est relié à l’équipement du bain par un câble interne

qui transmet l’alimentation ou, en d’autres termes, des signaux de
commande au moteur placé au fond du bain de revêtement. Ce
câble est détachable, ce qui permet de séparer le boîtier du bain lors
du transport ou du nettoyage, et de les assembler ou de les mettre
en service rapidement et efficacement. Ainsi, une isolation efficace
des vibrations produites par le moteur est assurée, ce qui protège
les composants électroniques et garantit une qualité constante du
processus de revêtement. Par ailleurs, la sécurité électrique est
renforcée grâce à l’absence de câbles et de composants internes
visibles : aucun contact accidentel n’est possible et le risque de
court-circuit est éliminé.

Cette conception permet également de déplacer les modules

assemblés dans le boîtier séparément, ce qui facilite leur transport
et leur utilisation de manière plus confortable et professionnelle. Au
final, ces solutions permettent d’obtenir un bain de revêtement prêt
à l’emploi, sans aucune opération de montage ou de branchement
requise de la part de l’utilisateur final.
 Figure III.19 : Face avant du spin-coating (côté droit).

Figure III.20 : Face avant du spin-coating (côté gauche).

Remarque :

 Le trou sur la façade a été laissé volontairement pour voir l’intérieur

du boîtier et le circuit lors des phases de test et de démonstration du
projet de fin d’études.
  Ce trou sera bouché ou couvert plus tard pour des raisons de
sécurité et de finition esthétique.

Figure III.21 : Vue interne du spin-coating – organisation et

fixation du circuit.

III.4 .2 Conception du bain de revêtement (environnement de spin-

coating)

Dans notre dispositif de revêtement par rotation, le bain est la partie où a

lieu le revêtement. Il protège l’ensemble extérieur en bloquant les
éclaboussures, les vapeurs et les produits chimiques qui tentent de
s’échapper lors de la rotation. Il récupère aussi le produit en excès qui est
projeté par la force centrifuge et facilite le nettoyage en recueillant les
éclaboussures du produit. En outre, le bain est nécessaire pour supporter
le moteur et le disque en rotation. Le moteur est positionné verticalement
et le disque est placé au-dessus, sur lequel on dispose la pièce à revêtir.
Enfin, nous avons décidé de mettre un couvercle en verre. Celui-ci permet
d’observer, sans ouvrir, ce qui se passe à l’intérieur et de contrôler le
processus, tout en restant protégés. De plus, le bain contribue à limiter la
dissipation de chaleur et la sortie des vapeurs.
Le choix du bain métallique
Il est justifié par des raisons techniques et pratiques telles que :
 Résistance mécanique élevée : le métal confère une rigidité et une
résistance permettant de supporter le poids du moteur, du disque
rotatif et des fixations des pièces, tout en maintenant la stabilité
face aux vibrations et aux forces centrifuges générées par la
rotation.
 Résistance chimique et thermostabilité : le métal n’est pas affecté
par les solvants et les substances chimiques utilisées dans le
processus de traitement, ni par d’éventuelles augmentations de
température ; il ne subit pas de dégradations mécaniques.
 Durabilité et facilité de nettoyage : grâce à la surface métallique,
l’installation est plus facile à nettoyer, ce qui garantit une durabilité
supérieure.
 Compatibilité avec les fixations mécaniques : en raison de la nature
du matériau, il est plus facile d’y percer des trous et de fixer les
éléments pour une installation sécurisée.

Fixation du moteur
Pour cela, nous avons fixé le moteur sur une planche en bois à l’aide d’une
équerre métallique en forme de « L ». Dans un premier temps, cette
équerre a été vissée sur la planche, puis le moteur a été fixé sur l’équerre.
La réalisation de cette installation garantit une fixation fiable et stable du
moteur, ainsi que l’absence de mouvements lors de la rotation. Cette
solution technique peut être qualifiée de simple, stable et résistante, grâce
à sa mise en œuvre facile.

Figure III.22 : Fixation du moteur sur la planche avec équerre.

Fixation du disque grâce à la pièce jaune
La pièce jaune permet la rotation du disque. Elle joue le rôle d’un
adaptateur entre l’axe du moteur et le disque rotatif. Elle permet de :
 fixer solidement le disque et le maintenir bien centré ;
 transmettre la rotation de l’axe du moteur au disque ;
 adapter la taille de fixation, car l’axe du moteur est trop petit pour
fixer directement un grand disque ;
 assurer une rotation régulière et stable.
Sans cette pièce, il serait difficile de fixer le disque ou d’obtenir une bonne
rotation.

Figure III.23 : Disque fixé grâce à la pièce adaptatrice jaune.

Fixation de l’ensemble dans le bain

Afin de fixer la planche avec le moteur et le disque à l’intérieur du bain,
nous avons percé un trou dans le fond du bain et un trou correspondant
dans la base de la planche. Ensuite, nous avons aligné les deux trous et
les avons vissés l’un à l’autre. Ce montage nous permet de placer la
planche perpendiculairement dans le bain et de fixer le moteur et le
disque eux-mêmes en position verticale, orientée vers le haut, de sorte
qu’ils ne pivotent pas sur les côtés pendant le fonctionnement.

3) Choix du couvercle en verre

Nous avons choisi d’utiliser un couvercle en verre pour refermer le bain.
Ce choix technique permet de :
 Transparence : nous pouvons voir directement à travers le verre
sans avoir besoin de l’ouvrir, ce qui est indispensable pour suivre le
processus dans la cuve en temps réel et vérifier que tout se passe
bien.
 Résistance chimique : le verre offre une meilleure résistance aux
solvants et aux produits chimiques utilisés pour le revêtement que le
plastique. De plus, il ne se dégrade pas facilement et ne réagit pas
avec les vapeurs produites.
  Facilité de nettoyage : le verre est facile à nettoyer et ne garde pas
les traces ni les dépôts des produits appliqués.
 Solidité et durabilité : le verre est plus résistant aux rayures et
possède une longue durée de vie sans perte de propriétés,
contrairement à un couvercle ordinaire en plastique ou en métal
peint.
 Isolation thermique : le verre présente une meilleure isolation
thermique que certains plastiques, ce qui peut contribuer à réduire
les pertes de chaleur.

Figure III.24 : Vue extérieure du bain et couvercle avant montage

interne.

Conclusion

Ce chapitre a résumé les principales étapes de la réalisation du système

de spin-coating, depuis le prototypage sur platine d’essai jusqu’à la
conception de la carte électronique finale avec un microcontrôleur
autonome. L’intégration de tous les composants et leur
programmation ont permis d’obtenir un système fiable et fonctionnel, qui
a ensuite été assemblé dans un boîtier pour assurer la protection, la
sécurité et l’esthétique de l’ensemble.