SOMMAIRE
AVANT-PROPOS.............................................................................................................................. 2
REMERCIEMENT…………………………………………………………………………………………………………………………………2
DÉDICACE..................................................................................................................................................2
INTRODUCTION......................................................................................................................................3
PRENSENTATION DU THEME............................................................................................. 5
1-CAHIER DES CHARGES...............................................................................................................5
1-1-THÈME.....................................................................................................................................5
1-2- TÂCHES À EXÉCUTER :.................................................................................................................5
1-3 TRAVAIL DEMANDÉ..................................................................................................................6
1-4 analyse fonctionnelle
PRESENTATION DES CARTES ELECTRONIQUE UTILISE......................................... 7
A-LA CARTE ARDUINO UNO................................................................................8
B-l’afficcheur à matrice de led p10
1-b définition
2-b caractéristique
3-c fonctionnent technique
C- clavier matriciel
1-c rôle du clavier matriciel
2-c description
3-c caractéristiques
4-c fonctionnent technique
ETUDE DU MICRO PROGRAMME
1-introduction
2- schéma simplifié de la carte Arduino uno
3- micro contrôleur atmega 328
4-le programme avec l’ide Arduino
4-1 caractéristiques du développement Arduino
ÉTUDE DE L’ALIMENTATION
[Link] technologie de la batterie
caractéristiques de la batterie utiliser
1.1.2 power Bank
avantages de la batterie
RÉALISATION DU PROJET
1-schéma
2- code
3- fonctionnement
AVANT PROPOS
Remerciements
Nous remercions Mr SEBRE pour avoir été à l’origine de ce projet ainsi que
pour l’aide apporté tout au long de celui-ci.
Nous tenons à remercier également, toutes l’équipe de lycée technique et en
particulier Mr ABOUA et Mr COLIBALY SANGARE, pour avoir
répondu à toutes nos questions et pour nous avoir encadrer lors de
l’utilisation des différentes machines.
Pour finir nous remercions Mr SEBRE pour avoir accordé du temps à la
réalisation de notre projet
Dédicace
Je dédie ce travail :
Aux être qui me sont le plus cher ma mère et mon père. Que Dieu
préserve la bonne santé et longue vie. Je remercie les professeurs du
lycée technique Qui ont tout faire pour m’encouragé durant les années
scolaires.
A mes grands-parents que Dieu les protège et a toute ma famille.
A mes chers frères, et mes chères sœurs et à mes chers amis. Sans oublier
tous mes enseignants durant tout mon cursus.
INTRODUCTION
Le panneau de remplacement de joueurs de football permet d’afficher le
numéro des joueurs entrant et sortant du terrain de football. C’est dans ce
sens que le ministère de l’enseignement technique, de la formation
professionnelle et de l’apprentissage thème et:<< Conception réalisation d’un
système de tableau de remplacement de joueurs de football >>. Au cours de
cette étude, nous verrons les travaux suivants : L’alimentation du projet
(FP1) -La partie micro-programmée (FP2) - la charge
PRENSENTATION
DU THEME
1-CAHIER DES CHARGES
1-1-Thème
Le thème soumis à la réalisation des élèves de F2 promotion 2023-2024est :
<< Conception d’un système de tableau de
remplacement de joueurs de football >>.
1-2-Tâches à exécuter :
L’annonce du changement de joueur doit se faire sur
une matrice à leds.
La matrice devra être constitué de :
Leds rouges qui indiquent le numéro du joueur sortant ;
Leds vertes qui indiquent le numéro du joueur entrant ;
La matrice peut être conçue par les apprenants en soudant les différentes leds .
Le concepteur, s’il le souhaite, pourra utiliser un afficheur à matrice de led p10.
_le système doit inclure pour la saisie et l’enregistrement des numéros des joueurs selon
le choix, un clavier matriciel de simples boutons poussoirs ou une application Android. Le
temps de saisie et d’enregistrement doit être le plus court possible.
_ le système peut être conçu autour d’un microcontrôleur de type ATMEGA, MSP430,
STM, PIC etc...
_les numéros affichés sur la matrice devront être visibles à plus de 100 mètres.
_ le système devra disposer d’une batterie rechargeable avec une autonomie minimum
de 3 heures.
1-3- TRAVAIL DEMANDÉ
A la fin de la réalisation du projet de fin cycle de l’année académique
2023/2024 L’élève doit :
Déterminer les différentes fonctions nécessaires à la réalisation de l’objet
technique
Faire l’étude de chaque fonction (fonctionnement, schéma, choix des
composants)
Réaliser les typons et les circuits imprimés
Monter le tableau (prototype) et les mises au point
1-4 ANALYSE FONCTIONNELLE
Partie microprogrammée Affichage
Information Information
d’entrée FP3 de sotie
FP2
Alimentation
FP1
PRESENTATION
DES CARTES
ELECTRONIQUE
UTILISE
A-LA CARTE ARDUINO UNO
Pour la gestion du projet nous allons utiliser un microcontrôleur monter
sur une carte : la carte Arduino Plusieurs cartes disponibles , nous utiliserons
la carte Arduino uno
Micro contrôleur
Alimentation via USB (5v)
Où alimentation entre 7 et 12 v
LEDs (voyants)
Celle du haut test de matériels (port 13)
Les deux du bas activité sur le port série
5.a et b, connecteurs pour ajouter des composants
électroniques
[Link] alimentation carte
Le micro contrôleur
Le micro contrôleur c’est le cerveau de notre carte. Il va recevoir le
programme que nous allons créer il le stocke et l’exécute lorsqu’il est sous
tension. Grâce au programme que nous allons créer, nous allons pouvoir
piloter les éléments de la maison. La carte Arduino Uno est équipé d’un
micro contrôleur atmega
Synthèses des caractéristiques de la carte Arduino uno
La borne d’alimentation et le port USB
Pour fonctionner, une carte Arduino a besoin d’une alimentation il peut être
alimenté par son port USB avec une tension de 5v ou par sa prise<< jack
≥>avec une tension recommandé comprise entre 7 et 12v
Le port USB de carte servira à charger le programme dans le micro
contrôleur et à alimenter la carte pendant les phases de test.
Les broches
La carte Uno dispose de broches numérique et analogique, certaines
broches fournissent des tensions continue et stabilisées de 3,3 et 5v :
0 à 13 entrées/sortie numérique
A0 à A5 entrées/sorties analogiques
Gnd terre ou masse (0v)
5v alimentation+5v
3,3 alimentation+3,3v
Micro contrôleur Atgema
Tension de fonctionnement 5v
Tension d’alimentation 7-12 v
(recommandée)
Tension d’alimentation 6-20v
limitée
Broche E/S numérique 14(dont 6 disposent d’une
sortie pwm)
Broche d’entrée anoligue 6( utilisable en branche e/s
numérique)
Intensité massi disponible par 40 ma ( attention :200ma
broches E/S (5v) cumulé pour l’ensemble
broches E/s)
Intensité massi disponible 50 ma
pour sortie 3,3v
Intensité massi disponible Fonction de l’alimentation
pour sortie 5v utilisés -500ma max si port
USB utilisé seul
Mémoire programmé flash 32 kb (atmega) dont 0,5kb
sont utilisés par le bootloader
Mémoire SRAM (mémoire 2 kb (atmega)
volatile)
Mémoire eeprom (mémoire 1kb(atmega)
non volatile)
Vitesse d’horloge 16mhz
B- L’AFFICHEUR À MATRICE DE LED P10
1-b définition
L’afficheur à matrice de led p10 est un dispositif électronique
permettant de présenter visuellement des données
2-b caractéristiques
Taille du pixel : 10 mm x 10 mm
Résolution : 32 x 16 pixels
Densité des pixels : 10 000 pixels/m²
Luminosité : 5 000 – 7 000 cd/m²
Angle de vision : 140° (horizontal) x 140° (vertical)
Consommation électrique : 120 W/m²
Tension d’alimentation : 220 V AC
Fréquence de rafraîchissement : 1 920 Hz
Durée de vie des LED : 100 000 heures
Température de fonctionnement : -20°C à +60°C
Indice de protection : IP65
Poids : 8 kg/m²
Dimensions du module : 320 mm x 160 mm
Matériau du boîtier : Aluminium
Système de contrôle : Carte de contrôle intégrée
Protocole de communication : DMX512, Ethernet
Compatibilité : Intérieur et extérieur
Certification : CE, RoHS
3-b fonctionnent technique
Technologie des pixels :
Chaque pixel est composé de 3 LED (rouge,
verte et bleue) disposées dans un boîtier de
10 mm x 10 mm.
Les LED utilisent la technologie SMD
(Surface Mount Device) pour une meilleure
densité et durabilité.
Système d’affichage :
La matrice est composée de 32 x 16 pixels,
soit 512 pixels au total.
Chaque pixel peut afficher 256 niveaux de
luminosité par couleur (rouge, vert, bleu),
permettant d’obtenir 16,7 millions de
couleurs.
Le rafraîchissement de l’image se fait à une
fréquence de 1 920 Hz pour éviter tout
scintillement.
Système de contrôle :
Une carte de contrôle intégrée gère
l’alimentation, le rafraîchissement et le
traitement des données vidéo.
Les données sont transmises via les
protocoles DMX512 ou Ethernet,
permettant un contrôle à distance.
Des capteurs de température et d’humidité
assurent une régulation active du système.
Boîtier et installation :
Le boîtier en aluminium offre une protection
IP65 contre la poussière et les projections
d’eau.
La matrice peut être installée à l’intérieur
comme à l’extérieur, dans des conditions
climatiques variées.
Le poids de 8 kg/m² permet une installation
facile sur différents supports.
Performances :
La luminosité élevée de 5 000 à 7 000 cd/m²
assure une bonne visibilité même en plein
soleil.
L’angle de vision de 140° dans les deux axes
permet une bonne lisibilité depuis différents
angles.
La durée de vie des LED de 100 000 heures
garantit une utilisation disposées sur le long
terme.
C- clavier matriciel
Ce clavier comprend 16 touches disposées en 4 lignes et 4 colonnes.
L’appui sur une touche fait communiquer une ligne avec une colonne.
1-c rôle du clavier matriciel
Le clavier matriciel permet de récupérer des caractéres (chiffres 0 à 9 lettres A à D, symboles * et
#). Ses touches sont disposées en matrice de 4×4
2-c Description
Les lignes sont des sorties. Les colonnes sont des entrées maintenues au niveau haut par une
résistance interne à Arduino.
Le système envoie par balayage un niveau bas sur chaque ligne (1 seule à la fois) et balaye les
colonnes en lecture.
Quand il lit un niveau bas, c’est que la colonne est reliée par une touche appuyée à la ligne qui
est basse à ce moment.
On n’a pas besoin de programmer ce balayage : c’est la bibliothèque qui le fait.
3-c Caractéristiques
Tension d’alimentation : Généralement comprise entre 3,3V et 5V DC.
Courant de fonctionnement : Typiquement entre 10 mA et 50 mA, selon la conception.
Technologie de détection des touches : Détection par matrice de résistances ou de capacités.
Temps de réponse : Très rapide, de l’ordre de quelques millisecondes.
Nombre de lignes/colonnes : 4 lignes x 4 colonnes, soit 16 touches au total.
Interface de communication : Souvent en mode série (I2C, SPI, UART) pour faciliter
l’intégration.
Mécanisme des touches : Touches à membrane, à dôme métallique ou à technologie de type
« scissor-switch ».
Durée de vie des touches : Généralement supérieure à 1 million d’actionnements.
Plage de température de fonctionnement : Typiquement de -20°C à +70°C.
10. Indice de protection : Selon l’application, peut aller de IP54 (protection contre la poussière
et les éclaboussures) à IP67 (étanchéité totale).
11. Résolution de la matrice : La résolution de la matrice de détection des touches est
généralement de 4x4, permettant de détecter jusqu’à 4 touches enfoncées simultanément.
12. Fréquence d’échantillonnage : Typiquement comprise entre 50 Hz et 200 Hz, permettant
une détection rapide des entrées.
13. Gestion des rebonds de touches : Le contrôleur intègre souvent un traitement des rebonds
de touches pour éviter les entrées multiples.
14. Possibilité de rétroéclairage : Certains claviers matriciels 16 touches peuvent être équipés
d’un rétroéclairage des touches, généralement à LED.
15. Connectivité : L’interface de connexion peut être de type GPIO, I2C, SPI ou USB, selon les
besoins de l’application.
16. Dimensions physiques : La taille d’un clavier matriciel 16 touches est généralement
comprise entre 80 mm x 80 mm et 120 mm x 120 mm.
17. Poids : Le poids varie typiquement entre 50 g et 150 g, selon la taille et les matériaux
utilisés.
18. Compatibilité électromagnétique (CEM) : Les claviers matriciels sont conçus pour respecter
les normes CEM en vigueur.
4-c fonctionnent technique
Structure de la matrice :
Le clavier est composé de 16 touches disposées dans une
matrice de 4 lignes x 4 colonnes.
Chaque touche est connectée à une ligne et une colonne
spécifiques de la matrice.
Principe de fonctionnement :
Le microcontrôleur du clavier active successivement chaque
ligne de la matrice.
Lorsqu’une touche est enfoncée, elle crée un court-circuit entre
la ligne et la colonne correspondantes.
Le microcontrôleur détecte ce court-circuit et en déduit la
touche pressée.
Détection des touches :
Le microcontrôleur active une ligne à la fois en appliquant un
niveau logique haut.
Il lit ensuite les niveaux logiques sur les colonnes pour détecter
les touches enfoncées.
Lorsqu’une touche est pressée, la colonne correspondante passe
à un niveau logique bas.
Gestion des entrées/sorties :
Le microcontrôleur utilise des ports d’entrée/sortie pour
connecter les lignes et les colonnes de la matrice.
Les lignes sont configurées en sortie pour activer successivement
chaque ligne.
Les colonnes sont configurées en entrée pour détecter les
touches enfoncées.
Traitement des données :
Le microcontrôleur analyse les données de la matrice pour
identifier la touche pressée.
Il peut ensuite transmettre cette information à un système hôte
via une interface de communication (UART, USB, etc.).
Avantages du clavier matriciel :
Simplicité de conception avec un nombre réduit de connexions.
Possibilité d’étendre facilement le nombre de touches.
Robustesse et fiabilité grâce à l’absence de contacts mécaniques.
Ce fonctionnement technique permet d’obtenir un clavier compact, économique et fiable,
adapté à de nombreuses applications embarquées. Voici la suite du fonctionnement technique
détaillé d’un clavier matriciel 16 touches :
7. Gestion des rebonds de touches :
Lors de l’appui sur une touche, des rebonds électriques peuvent
se produire, causant des détections multiples.
Le microcontrôleur utilise des techniques de filtrage logiciel pour
éliminer ces rebonds et ne détecter qu’un seul événement par
appui de touche.
8. Gestion de la simultanéité :
Avec une matrice, il est possible de détecter l’appui simultané de
plusieurs touches.
Le microcontrôleur analyse la matrice pour identifier toutes les
touches enfoncées en même temps.
Cette fonctionnalité permet d’implémenter des combinaisons de
touches
9. Économie d’énergie :
Le microcontrôleur peut entrer dans des modes basse
consommation lorsque le clavier n’est pas utilisé.
Il active uniquement les lignes de la matrice de manière
séquentielle, réduisant ainsi la consommation électrique.
10. Intégration avec un système hôte :
Le microcontrôleur du clavier peut communiquer avec un
système hôte (ordinateur, microcontrôleur, etc.) via une
interface série (UART, USB, etc.).
Il transmet les événements de touches (appui, relâchement) au
système hôte qui les interprète.
Des protocoles de communication spécifiques peuvent être
implémentés pour une intégration transparente.
11. Personnalisation et programmation :
Le microcontrôleur peut être programmé pour modifier le
comportement du clavier (mappage des touches, macros, etc.).
Des interfaces de programmation permettent de personnaliser le
fonctionnement du clavier selon les besoins de l’application.
ETUDE DU MICRO
PROGRAMME
1 – introduction
Le modèle UNO de la société ARDUINO est une carte électronique dont le cœur est un
Microcontrôleur ATMEL de référence ATMega328. L’ATMega328 est un microcontrôleur
8bits de
La famille AVR dont la programmation peut être réalisée en langage C/C++.
L’intérêt principal des cartes ARDUINO (d’autres modèles existent : Méga, Nano…) est
leur
Facilité de mise en œuvre. Un environnement de développement (IDE), s’appuyant sur
des outils
Open-source, est fourni. En outre, charger le programme compilé dans la mémoire du
Microcontrôleur se fait très simplement (via par port USB). Enfin, beaucoup de
bibliothèques de
Fonctions sont également fournies pour l’exploitation des entrées-sorties courantes : E/S
TOR,
Gestion des convertisseurs ADC, génération de signaux PWM, exploitation de bus
TWI/I2C,
Exploitation de servomoteurs, d’afficheurs LCD …
L’objectif du cours Microcontrôleurs n’est pas simplement de savoir utiliser la carte
Arduino
UNO. C’est surtout l’occasion d’aborder des problèmes de programmation de bas niveau
(la valeur
Binaire des variables manipulées importe alors beaucoup) et d’apprendre à utiliser le
langage C pour
Cette programmation bas niveau, notamment en sachant gérer des registres/variables
« au niveau du
Bit ». Donc quand on se complique la tâche, alors qu’une fonction Arduino existe, dites-
vous que
C’est voulu.
L’objectif de ce document est de mettre en évidence certaines informations techniques
Concernant l’exploitation des périphériques intégrés, en particulier lorsqu’on n’utilise
pas les
Fonctions « clé en main » d’ARDUINO, dans l’objectif de comprendre comment ça
marche !
2- schéma simplifié la carte Arduino uno
Les broches du microcontrôleur sont reliées à des connecteurs selon le schéma ci-
dessous.
Vue du dessus, la carte fournit les informations suivantes :
En recoupant avec le schéma précédent, on a les équivalences suivantes :
(connecteur) Numéros 0 à 7 Broches PD0 à PD7 (microcontrôleur)
(connecteur) Numéros 8 à 13 Broches PB0 à PB5 (microcontrôleur)
(connecteur) ANALOG IN 0 à 5 Broches PC0 à PC5 (microcontrôleur)
ATTENTION : avec les fonctions Arduino (pin Mode, digital Read, digital rite ...), les
signaux
sont repérés selon la numérotation des connecteurs (partie gauche). En revanche,
lorsque l'on
programme en bas niveau, on utilise le nom des registres/des broches du
microcontrôleur (partie
droite).
digital rite(10,HIGH); //Arduino met la sortie PB2 du microC. à l'état HAUT
analogRead(1); //Arduino lit l'entrée analogique sur PC1
3-Microcontrôleur ATMEL ATMega328
Le microcontrôleur de la carte Arduino UNO est un ATMega328. C'est un
microcontrôleur
ATMEL de la famille AVR 8bits. Les
principales caractéristiques sont :
FLASH = mémoire programme de 32Ko
SRAM = données (volatiles) 2Ko
EEPROM = données (non volatiles) 1Ko
Digital I/O (entrées-sorties Tout Ou Rien) =
ports Port, PortC, PortD
(soit 23 broches en tout I/O)
Timers/Counters : Timer0 et Timer2
(comptage 8 bits), Timer1 (comptage 16bits)
Chaque timer peut être utilisé pour générer
deux signaux PWM. (6 broches OCxA/OCxB
Plusieurs broches multi-fonctions : toutes les broches ont plusieurs fonctions différentes,
choisies
par programmation. Elles ont donc plusieurs noms sur le brochage.
Par exemple, les broches PB1, PB2, PB3, PD3, PD5, PD6 peuvent servir de sortie PWM
(Pulse
Width Modulation), c’est-à-dire des sorties qui joueront le rôle de sorties analogiques.
Elles
Correspondent aux broches des connecteurs 3,5,6,9,10 et 11. Cet autre rôle possible est
lié aux
Timers et ces broches sont alors appelées OCxA ou OcxB dans la documentation. Ce sont
les mêmes
Broches, mais pour une autre fonction.
PWM = 6 broches OC0A(PD6), OC0B(PD5), 0C1A(PB1), OC1B(PB2), OC2A(PB3),
OC2B(PD3)
Les broches du PORTC peuvent être converties par un convertisseur Analog toDigital.
Analog to Digital Converter (résolution 10bits) = 6 entrées multiplexées ADC0(PC0) à
ADC5(PC5)
Gestion bus I2C (TWI Two Wire Interface) = le bus est exploité via les broches
SDA(PC5)/SCL(PC4).
Port série (USART) = émission/réception série via les broches TXD(PD1)/RXD(PD0)
Comparateur Analogique = broches AIN0(PD6) et AIN1 (PD7) peut déclencher
interruption
Watchdog Timer programmable.
Gestion d’interruptions (24 sources possibles (cf interrupt vectors)) : en résumé
–Interruptions liées aux entrées INT0 (PD2) et INT1 (PD3)
–Interruptions sur changement d’état des broches PCINT0 à PCINT23
–Interruptions liées aux Timers 0, 1 et 2 (plusieurs causes configurables)
–Interruption liée au comparateur analogique
–Interruption de fin de conversion ADC
–Interruptions du port série USART
–Interruption du bus TWI (I2C)
4- le programme avec l’ide Arduino
4-1 caractéristiques du développement Arduino
ARDUINO fournit un environnement de
Développement (IDE) avec un éditeur de
Source, les opérations de compilation et de Chargement dans la mémoire du
Microcontrôleur étant ramenées à des clicks Sur des boutons dans l’IDE(très simple). La
communication entre le PC et la carte se Fait via le port USB, moyennant installation
D’un driver adapté sur le PC(fourni par ARDUINO).
ÉTUDE DE L’ALIMENTATION
Différente technologie de la batterie
Batteries Li-ion (Lithium-ion) :
Tension nominale : 3,6 V
ou 3,7 V
Haute densité énergétique
Faible autodécharge
Pas d’effet mémoire
Nécessitent un circuit de
protection
Batteries LiPo (Lithium-
Polymère) :
Tension nominale : 3,7 V
Très haute densité
énergétique
Légères et compactes
Un- Nécessitent un circuit de protection
3. Batteries NiMH (Nickel-Métal
Hydrure) :
Tension nominale : 1,2 V
Moins chères que les Li-ion
Moins sensibles aux
dommages
Capacité et densité
énergétique plus faibles
4. Batteries Plomb-acide :
Tension nominale : 12 V
Technologie éprouvée et
peu coûteuse
Poids et encombrement
plus importants
Durée de vie plus limitée
Power Banks (Batteries externes)
caractéristiques de la batterie utilisée
Power bank
Capacité (mAh) :
C’est la quantité d’énergie stockée dans
le power bank. Plus la capacité est
élevée, plus l’autonomie sera
importante. Typiquement, on trouve des
power banks de 5 000 mAh à 20 000
mAh.
Tension de sortie (V) :
Une tension de 5V
Courant de sortie (A) :
Courant de 1A à 2,4A est .
Nombre de ports USB :
La présence de plusieurs ports USB
Technologie de la batterie :
Li-ion ou LiPo.
Avantages d’un power bank
Autonomie élevée :
une capacité de stockage
d’énergie allant de 5 000 mAh à
20 000 mAh,
Rechargeable :
Les power banks sont conçus
pour être rechargés facilement
via un câble USB, ce qui permet
de les réutiliser après
épuisement de la charge.
RÉALISATION DU
PROJET
Schéma
Code
#include <Keypad.h>
#include <SPI.h>
#include <DMD2.h>
#include <fonts/Arial_Black_16.h>
#include <fonts/BigNumber.h>
#include <fonts/fixednums8x16.h>
#include <fonts/myNumber.h>
SoftDMD dmd(2,1) ; //origine (2,1)
DMD_TextBox box(dmd,22,1,64,16) ;
DMD_TextBox box_1(dmd,7,1) ; //DMD_TextBox
box_1(dmd,0,1,55,16) ;
DMD_TextBox box_2(dmd,17,1) ;
DMD_TextBox box_3(dmd,38,1) ; //DMD_TextBox
box_1(dmd,0,1,55,16) ;
DMD_TextBox box_4(dmd,48,1) ;
Const int ROW_NUM = 4 ; //four rows
Const int COLUMN_NUM = 4 ; //four columns origine 4
Char buf1[6] ;
Char touche ;
Int n=4 ;
Int pos=0 ;
Char keys[ROW_NUM][COLUMN_NUM] = {
{‘1’,’2’,’3’,’A’},
{‘4’,’5’, ‘6’,’B’},
{‘7’,’8’,’9’,’C’},
{‘*’,’0’,’#’,’D’}
};
Byte pin_rows[ROW_NUM] = {A0,A1,A2,A3} ; //connect to the row
pinouts of the keypad
Byte pin_column[COLUMN_NUM] = {A4,A5,2,3} ; //connect to the
column pinouts of the keypad origine {A4,A5,2,3}
Keypad keypad = Keypad( makeKeymap(keys), pin_rows,
pin_column, ROW_NUM, COLUMN_NUM ) ;
Void setup(){
[Link](200) ;//LUMINOSITE FIXEE A 20%
[Link](Arial_Black_16) ;//CHOIX DE LA POLICE
//[Link](myNumber) ;
//[Link](BigNumber) ;
//[Link](fixednums8x16) ;
[Link]() ;//
[Link](« IN OUT ») ;
Delay(1000) ;
[Link]() ;
[Link](16000) ;
[Link](« ON EST DANS LE SETUP ») ;
Void loop(){
Char key = [Link]() ;
If(key) // On appuie sur une touche du clavier matriciel
{
Touche = key ;
[Link](touche) ;
If (n==4) {
Box_1.clear() ;
Box_1.print(touche) ;
}
If (n==3) {
Box_2.clear() ;
Box_2.print(touche) ;
}
If (n==2) {
Box_3.clear() ;
Box_3.print(touche) ;
}
If (n==1) {
Box_4.clear() ;
Box_4.print(touche) ;
}
n-- ;
if (n==0) {n=4 ;}
}
If (key == ‘*’) {
Box_1.clear() ;
Box_2.clear() ;
Box_3.clear() ;
Box_4.clear() ;
}
/*if(buf1[5]=’\0’){ [Link]() ;
[Link](buf1) ;
Box_1.print(buf1) ;
} */
}
Fonction du projet
