Table Des Matières Introduction

Compte rendu Arduino
15/05/2023
Réaliser par : Chaimae El Haouari

Table des matières
Introduction......................................................................................................................................... 2
Développement du projet ................................................................................................................... 2
Partie électronique .............................................................................................................................. 3
Partie informatique…………………………………………………………………………………………………………………………6
Les plus et les moins de notre projet.................................................................................................. 6

Les problèmes rencontrés au cours du projet.................................................................................... 6
Sources ................................................................................................................................................. 7
Séries de classe………………………………………………………………………………………………………………………………8
1
Introduction
D’où nous est venue cette idée de lampe colorée ? Au départ, nous voulions faire un projet
réalisable, que nous pourrions finir. C’est pourquoi nous sommes partis sur l’idée de travailler autour
de la lumière et des couleurs. Le but de notre projet était de créer une lampe reproduisant la couleur
passée devant un capteur lui étant dédié, avec un support adapté. Nous aurions aussi aimé rajouter à
cette lampe quelques mélodies.
Développement du projet
Au bout d’une séance de cours nous avons établis qu’il serait nécessaire de se répartir des tâches,
trois aspects principaux constituaient notre projet : La détection des couleurs : Nous nous sommes
procurés un capteur de couleur de référence TCS 230D. Ce dernier nous était indispensable dans la
création de notre projet étant donné que l’on souhaitait moduler la couleur de plusieurs LEDS selon
une couleur de carte (Pantone) souhaitée. Nous avons donc eu besoin de la datasheet de ce
composant, une datasheet très dense par ailleurs. Après plusieurs tests nous avons établis un
équilibre de reconnaissance des couleurs pour que les couleurs secondaires ressortent au mieux avec
nos LEDS. Le contrôle des LEDS : Cette partie fut la plus technique à mettre en œuvre. En effet, nous
avons eu besoin de deux registres à décalage pour pouvoir contrôler 4 LEDS à la fois. Il nous a fallu
comprendre ce que le registre pouvait faire exactement. Cette partie est très intéressante car ici elle
nous sert à contrôler plusieurs LEDS en même temps à l’aide de seulement trois sorties de l’Arduino.
Mais bon nombre d’applications, ayant besoin d’un registre, existent. Nous pourrions en effet
contrôler d’autres composants en même temps que les LEDS, comme des servomoteurs ou des haut-
parleurs. Nous avions aussi eu l’idée d’intégrer à notre lampe un VU-mètre mais par manque de
temps il n’a pas été réalisé. La communication avec l’objet : Un des objectifs que nous nous étions
fixés était de pouvoir communiquer à distance avec l’objet. C’est pourquoi un aspect de
communication à distance a été mis en place avec le module Bluetooth. Nous voulions absolument
intégrer ce module Bluetooth car de nos jours l’ensemble des objets que nous possédons est doté
d’un module de communication homme-machine.
2
Partie électronique
Le 74HC595, un registre à décalage dédié à l’Arduino :
L'alimentation du 74HC595 se fait sur la pin 16 sous une tension allant de -0.5 à +7V (d'après la
datasheet). Pour ce qui est des fonctions principales du registre à décalage, de l’enregistrement du
registre et des sorties à 3 états, on utilisera les 8 pins de sortie parallèles (1 à 7 + 15), plus les 3 à 5
pins de contrôle. Voici en gros la séquence effectuée pour l'envoie d'une donnée sur 8 bits en sortie
du 74HC595 : on passe d'abord ST_CP (la latch) à 0, puis on présente un par un les 8 bits de la donnée
sur DS (entrée série) en envoyant en même temps un 1 logique sur SH_CP (l’horloge de décalage) à
chaque fois, on repasse ensuite ST_CP (la latch) à 1 pour recopier la nouvelle valeur dans le second
registre. La pin 10 (/MR) permet de remettre tout le premier registre à zéro et est active au niveau
bas, il convient donc (pour éviter une remise à zéro permanente du registre) de placer cette pin au
niveau haut (C’est pourquoi on la relie à +VCC). La pin 13 (/OE) active ou non la sortie (elle est elle
aussi active au niveau bas). On placera cette fois cette pin sur la masse. La pin /OE contrôle quant à
elle les sorties à 3 états. Le fonctionnement des sorties à 3 états est simple. Pour deux des états, il
s'agit des classiques 0 et 1 logiques. Dans le cas ou /OE est au niveau bas, cette sortie est un simple
fil. Par contre, dans le cas ou /OE est au niveau logique haut (quand la sortie est désactivée), cet
étage atteint un état de haute impédance qui n'est ni zéro, ni un mais qui a le bénéfice d'isoler
efficacement le 74HC595 du reste du circuit. La pin 9 du 74HC595 correspond à sa sortie série. En

utilisant cette sortie série, on peut chaîner les 74HC595 et avoir ainsi des registres à décalage sur 16,
24, 32 etc... bits. Il suffit alors de câbler les registres comme tel :
3
D’ailleurs pourquoi
avoir utilisé 2
registres à décalage
pour faire une chose
assez simple de
prime abord :
contrôler des LEDS ?
Utiliser des registres
à décalage ne fut pas
intuitif mais c’est en réfléchissant que nous est venue l’idée car nous voulions allumer des LEDS RGB
et pour cela il nous fallait des sorties analogiques pour recevoir une valeur numérique entre 0 et 255
sur chaque diode rouge, verte et bleue contenue dans une seule LED. En plus de cela il fallait gérer la
persistance rétinienne afin que les couleurs apparaissent proprement. Les registres à décalage furent
donc une obligation pour contrôler plusieurs LEDS sachant que de plus il n’y avait pas assez de sorties
analogiques aux ports de l’Arduino pour contrôler plus d’une LED.
Le TCS230D, un capteur de couleur simple d’utilisation avec Arduino
Le capteur est constitué de plusieurs

broches : S0, S1, S2, S3, OUT. Les branches S0 et S1 servent à augmenter ou diminuer une échelle de
puissance du capteur. Les broches S2 et S3 servent à imposer au capteur la détection d’une couleur,
ce dernier nous renverra le taux de cette couleur dans la couleur qui lui est présentée. C’est pourquoi
nous changeons, dans la partie code, les états de S2 et S3 afin de récupérer la valeur de chaque teinte
comme expliqué ci-dessous :
4
Ce que nous renvoie ce capteur n’est autre qu’une courbe que nous analysons dans la partie
informatique pour ainsi la traiter.
5
Partie informatique
D’une part, pour ce qui est du registre à décalage, une librairie a été utilisée afin de rendre la
programmation de ce dernier beaucoup plus simple et compréhensible. Grâce à cette librairie, tout
l’aspect de la gestion de la persistance rétinienne était beaucoup plus simple et clair (la librairie est
expliquée en commentaires dans le code Arduino). De plus de nombreuses fonctions de cette librairie
furent simples d’utilisation et le code fut par conséquent plus simple à mettre en place même si le
principe du registre à décalage en lui-même restait le même. D’autre part on récupère la valeur
renvoyée par le capteur de couleur à l’aide de la fonction « pulsein » qui nous renvoie une valeur
pour chaque couleur en microseconde. On passe ensuite cette valeur en KHz comme expliqué dans la
datasheet. Or en comparant les valeurs données par la datasheet et celle trouvées
expérimentalement pour les maxima et les minima de chaque longueur d’onde, on remarque qu’elles
sont différentes on a alors dû élaborer une fonction très spécifique pour obtenir les couleurs les
mieux approximées et ainsi les retransmettre aux diodes rouges, vertes et bleues de la LED. Cette
partie de code fût assez laborieuse, elle nous a pris beaucoup de temps notamment pour tous les
tests effectués sur les différentes couleurs afin de savoir exactement quoi changer dans la fonction
pour obtenir un meilleur rendu de couleur.
Les plus et les moins de notre projet

Il est vrai que notre projet peut paraître simple de prime abord, or il est très flexible dans le sens ou
beaucoup d’améliorations peuvent être apportées. En effet il y a matière à améliorer ce prototype ou
mieux encore, changer les composants contrôlés par les registres à décalage. En effet nous pourrions
contrôler n’importe quel composants à la place des LEDS et ainsi leur accorder à chacun des sorties
PWM. Ce projet nous a permis de nous rendre compte qu’avec de simples composants, énormément
de projets sont réalisables. Pour ce qui est du côté négatif ; nous aurions aimé avoir une carte
Arduino un peu plus performante que celle que nous avions à disposition. Nous avons en effet été
restreints par cette dernière qui ne supportait pas la mise en place de librairies n’utilisant pas les
même timer de l’Arduino (explication plus de détails dans la partie problèmes).
Les problèmes rencontrés au cours du projet

De prime abord, il semblerait que notre projet soit simple. Or nous avons rencontrés certains
problèmes, notamment au niveau du capteur de couleur. Ce dernier nous a posé certains problèmes
dans le fait où son manque de précision nous a fait défaut. Nous avons donc dû y remédier par nous-
même et faire en sorte d’obtenir un rendu final satisfaisant. Le deuxième problème majeur fut la mise
en corrélation des parties Bluetooth + registre et capteur de couleur. Nous nous sommes finalement
rendu compte que nous ne pouvions pas rassembler les 2 parties car les programmes utilisés pour
chacun de nos parties utilisaient des temps de l’Arduino différents (dû aux librairies).
6
Sources
capteur de couleur
Registre à décalage
7
series de classe :
const int unBouton = 2; // un bouton sur la broche 2
void setup()
{
// on met le bouton en entrée
pinMode(unBouton, INPUT);
// on active la résistance de pull-up en mettant la broche à l'état haut
// (mais cela reste toujours une entrée)
digitalWrite(unBouton, HIGH);
}
void loop()
{
// votre programme
}
8
9
const int bit_A = 2;
const int bit_B = 3;
const int bit_C = 4;
const int bit_D = 5;
void setup()
{
// on met les broches en sorties
pinMode(bit_A, OUTPUT);
pinMode(bit_B, OUTPUT);
pinMode(bit_C, OUTPUT);
pinMode(bit_D, OUTPUT);
// on commence par écrire le chiffre 0, donc toutes les sorites à l'état bas
digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
}
void loop()
{
char i=0; // variable "compteur"
for(i=0; i<10; i++)
{
afficher(i); // on appel la fonction d'affichage
delay(1000); // on attend 1 seconde
}
}
// fonction écrivant sur un seul afficheur

void afficher(char chiffre)
{
// on met à zéro tout les bits du décodeur
// On allume les bits nécessaires

if(chiffre >= 8)
{
digitalWrite(bit_D, HIGH);
chiffre = chiffre - 8;
}
if(chiffre >= 4)
{
digitalWrite(bit_C, HIGH);
}
if(chiffre >= 2)
{
digitalWrite(bit_B, HIGH);
}
if(chiffre >= 1)
{
digitalWrite(bit_A, HIGH);
10
}

{
switch(chiffre)
{
case 0 :
break;
case 1 :
break;
case 2 :
break;
case 3 :
break;
case 4 :
break;
case 5 :
break;
case 6 :
break;
case 7 :
break;
case 8 :
11
break;
case 9 :
break;
}
12
/ définition des broches du décodeur 7 segments
// (vous pouvez changer les numéros si vous voulez)
// définitions des broches des transistors pour chaque afficheur

const int alim_dizaine = 6; // les dizaines
const int alim_unite = 7; // les unites
void setup()
{
// Les broches sont toutes des sorties
pinMode(alim_dizaine, OUTPUT);
pinMode(alim_unite, OUTPUT);
// Les broches sont toutes mises à l'état bas

digitalWrite(alim_dizaine, LOW);
digitalWrite(alim_unite, LOW);
13
}
void loop() // fonction principale

{
// boucle qui permet de compter de 0 à 99 (= 100 valeurs)
for(char i = 0; i<100; i++)
{
// appel de la fonction affichage avec envoi du nombre à afficher
afficher_nombre(i);
}
}
// fonction permettant d'afficher un nombre sur deux afficheurs

void afficher_nombre(char nombre)
{
long temps; // variable utilisée pour savoir le temps écoulé...
char unite = 0, dizaine = 0; // variable pour chaque afficheur
if(nombre > 9) // si le nombre reçu dépasse 9

{
dizaine = nombre / 10; // on récupère les dizaines
}
unite = nombre - (dizaine*10); // on récupère les unités
temps = millis(); // on récupère le temps courant
// tant qu'on a pas affiché ce chiffre pendant au moins 500 millisecondes

// permet donc de pouvoir lire le nombre affiché
while((millis()-temps) < 500)
{
// on affiche le nombre
// d'abord les dizaines pendant 10 ms
// le transistor de l'afficheur des dizaines est saturé,

// donc l'afficheur est allumé
digitalWrite(alim_dizaine, HIGH);
// on appel la fonction qui permet d'afficher le chiffre dizaine
afficher(dizaine);
// l'autre transistor est bloqué et l'afficheur éteint
delay(10);
// puis les unités pendant 10 ms
// on éteint le transistor allumé

// on appel la fonction qui permet d'afficher le chiffre unité
afficher(unite);
// et on allume l'autre
digitalWrite(alim_unite, HIGH);
delay(10);
}
}
14
// on utilise le même principe que vu plus haut
{
if(chiffre >= 8)
{
}
if(chiffre >= 4)
{
}
if(chiffre >= 2)
{
}
if(chiffre >= 1)
{
}
}
// définition des broches du décodeur 7 segments

// (vous pouvez changer les numéros si vous voulez)
// définitions des broches des transistors pour chaque afficheur

const int alim_dizaine = 6; // les dizaines
const int alim_unite = 7; // les unites
// variable pour l'affichage

bool afficheur = false;
long tempsaffichage = 0;
long tempscomptage = 0;
int valeur = 0;
void setup()
{
// Les broches sont toutes des sorties
pinMode(alim_dizaine, OUTPUT);
pinMode(alim_unite, OUTPUT);
15
// Les broches sont toutes mises à l'état bas
}
void loop()
{
// gestion du rafraichissement
// si ça fait plus de 10 ms qu'on affiche,
// on change de 7 segments (alternance unité <-> dizaine)
if((millis() - tempsaffichage) > 250)
{
// on inverse la valeur de "afficheur"
// pour changer d'afficheur (unité ou dizaine)
afficheur = !afficheur;
// on affiche la valeur sur l'afficheur
// afficheur : true->dizaines, false->unités
afficher_nombre(valeur, afficheur);
tempsaffichage = millis(); // on met à jour le temps
}
// ici, on peut traiter les évènements (bouton...)

// Par exemple on incrément le compteur toutes les secondes
if((millis() - tempscomptage) > 1000)
{
valeur++;
tempscomptage = millis(); // on met à jour le temps
}
}
// fonction permettant d'afficher un nombre

// elle affiche soit les dizaines soit les unités
void afficher_nombre(char nombre, bool afficheur)
{
char unite = 0, dizaine = 0;
if(nombre > 9)
dizaine = nombre / 10; // on recupere les dizaines
unite = nombre - (dizaine*10); // on recupere les unités
// si "
if(afficheur)
{
// on affiche les dizaines
afficher(dizaine);
digitalWrite(alim_dizaine, HIGH);
}
else // égal à : else if(!afficheur)
{
// on affiche les unités
afficher(unite);
digitalWrite(alim_unite, HIGH);
16
}
}

{
if(chiffre >= 8)
{
}
if(chiffre >= 4)
{
}
if(chiffre >= 2)
{
}
if(chiffre >= 1)
{
}
}
17

Table Des Matières Introduction

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Table Des Matières Introduction

Transféré par

Droits d'auteur :

Formats disponibles

Compte rendu Arduino

Réaliser par : Chaimae El Haouari

Les plus et les moins de notre projet.................................................................................................. 6

efficacement le 74HC595 du reste du circuit. La pin 9 du 74HC595 correspond à sa sortie série. En

Le TCS230D, un capteur de couleur simple d’utilisation avec Arduino

Le capteur est constitué de plusieurs

informatique pour ainsi la traiter.

Les plus et les moins de notre projet

Les problèmes rencontrés au cours du projet

const int unBouton = 2; // un bouton sur la broche 2

// fonction écrivant sur un seul afficheur

// On allume les bits nécessaires

// fonction écrivant sur un seul afficheur

// définitions des broches des transistors pour chaque afficheur

// Les broches sont toutes mises à l'état bas

void loop() // fonction principale

// fonction permettant d'afficher un nombre sur deux afficheurs

if(nombre > 9) // si le nombre reçu dépasse 9

unite = nombre - (dizaine*10); // on récupère les unités

temps = millis(); // on récupère le temps courant

// tant qu'on a pas affiché ce chiffre pendant au moins 500 millisecondes

// d'abord les dizaines pendant 10 ms

// le transistor de l'afficheur des dizaines est saturé,

// puis les unités pendant 10 ms

// on éteint le transistor allumé

// fonction écrivant sur un seul afficheur

// définition des broches du décodeur 7 segments

// définitions des broches des transistors pour chaque afficheur

// variable pour l'affichage

// ici, on peut traiter les évènements (bouton...)

// fonction permettant d'afficher un nombre

// fonction écrivant sur un seul afficheur

Vous aimerez peut-être aussi