Atelier Electronique Embarquee3 PSoC1-psoc-designer

Ministère de l’Enseignement Supérieur et
de la Recherche Scientifique
*****************
Direction Générale des Etudes Technologiques
*****************
Institut Supérieur des Etudes Technologiques de Djerba
*****************
Département Génie Electrique
Fascicule de Travaux Pratiques
Atelier Electronique
embarquée3 (PSoC)
Élaboré par :
Marwen FASSATOUI
Slah MHAYA
Public cible :
Classes de 3ème année
Licence Génie Electrique (Electronique Industrielle)
Version 2016
AVANT-PROPOS
Ce support est consacré à la mise en œuvre des applications à base de PSoC. A la fin de cet atelier,
l’étudiant sera capable de programmer et implanter sur une carte électronique un système à base de PSoC.
Comme pré requis, cet atelier nécessite des connaissances de base en électronique analogique et
numérique, sur les microcontrôleurs et leur programmation.
Le support présente six ateliers, dont chacun est précédé par une partie intitulée «Mise en situation ».
Cette partie vise d’une part, à faire le lien avec les parties théoriques en question, et d’autre part, à se rappeler
les concepts de bases nécessaires.
Le contenu, ainsi que l’enseignement pédagogique de cet atelier peut toujours évoluer en fonction des
critiques et remarques constructives des lecteurs.
Suivi des versions du support
Version Date Auteurs Raisons Collaboration et révision
0 2016 MHAYA Slah

FASSATOUI
Marwen
Pré requis
Electronique analogique et numérique
Programmation des microcontrôleurs
Objectifs généraux
Cet atelier vise à Mettre en œuvre des applications à base de PSoc
Niveau cible
Classe : 3ème année

Atelier PSoC
Licence : Génie Electrique

Parcours : Electronique Industrielle
Volume horaire
- 3h de Travaux Pratiques pour chaque groupe
Soit en total : 45h
Moyens pédagogiques
- PC
- Kit PSoc CT PSOC-DEV01
- Vidéoprojecteur
Evaluation
- Coefficient : 2
- Note non présentielle : 20%
- Moyenne des TP : 80%
LISTE DES FIGURES
Figure 1 : PSoC (Programmable System on Chip) ................................................................................. 1

Figure 2 : Architecture interne d’un PSoC............................................................................................... 1
Figure 3: Présentation du kit.................................................................................................................... 2
Figure 4: Schéma synoptique.................................................................................................................. 3
Figure 5: Photo réel de la CT PSOC-DEV01 .......................................................................................... 3
Figure 6: Bloc MCU ................................................................................................................................. 4
Figure 7: Bloc d’alimentation ................................................................................................................... 5
Figure 8 : Jumper .................................................................................................................................... 5
Figure 9: Bloc de 8 LED .......................................................................................................................... 6
Figure 10 : Bloc Clavier ........................................................................................................................... 6
Figure 11: Blocs LCD & Contraste .......................................................................................................... 7
Figure 12: Bloc afficheur 7 segments...................................................................................................... 7
Figure 13: Bloc ADC................................................................................................................................ 7
Figure 14: Bloc Buzzer ............................................................................................................................ 8
Figure 15: Bloc thermomètre ................................................................................................................... 8
Figure 16: Bloc RS232 ............................................................................................................................ 9
Figure 17: PSOC MINIProg et câble USB............................................................................................... 9
Figure 18: Outils de développement PSoC ............................................................................................. 9
Figure 19 : Interface du logiciel PsoC Designer .................................................................................... 10
Figure 20: LED1 choisie ........................................................................................................................ 11
Figure 21: Etapes de développement d’une application PSoC............................................................. 11
Figure 22: Etapes de création d'un nouveau projet............................................................................... 13
Figure 23: Device catalog-Chip level..................................................................................................... 13
Figure 24: Choix du langage C.............................................................................................................. 14
Figure 25: Insertion du Module LED...................................................................................................... 14
Figure 26 : Paramétrage et Pinout du module LED .............................................................................. 15
Figure 27: Documentation du module LED ........................................................................................... 15
Figure 28: Etapes de compilation .......................................................................................................... 16
Figure 29: MiniProg CY3217 ................................................................................................................. 17
Figure 30: Menu de PSoC Designer ..................................................................................................... 17
Figure 31: Menu Program Part .............................................................................................................. 17
Figure 32: Menu Program Part .............................................................................................................. 18
Figure 33: Clavier .................................................................................................................................. 21
Figure 34: Etapes à suivre pour dégager l’adresse de la touche B10 .................................................. 21
Figure 35: Configuration du module LED .............................................................................................. 23
Figure 36: Etape1 Drive-Pull Down ................................................................................................... 24
Figure 37: Configuration de 8 pins du port4 .......................................................................................... 25
Figure 38: Ecran LCD............................................................................................................................ 29
Figure 39: Position du curseur............................................................................................................... 29
Figure 40: Afficheur 7 Segments ........................................................................................................... 29
Figure 41: Afficheur 7segments 4digits ................................................................................................. 30
Figure 42: Affichage du nombre 1234 ................................................................................................... 31
Figure 43: Affichage de la séquence de 0000 jusqu’ à 9999 ................................................................ 32
Figure 44: Schéma explicatif du fonctionnement souhaité.................................................................... 32
Figure 45: Configuration de la LED de rétroéclairage. .......................................................................... 33
Figure 46: Configuration du module LCD.............................................................................................. 33
Figure 47: Pinout-Clavier....................................................................................................................... 34
Figure 48: Configuration du module LED7SEG .................................................................................... 38
Figure 49 : Commande du module 7 Segments à 4 digits .................................................................... 39
Figure 50: Module numérique LED7SEG .............................................................................................. 39
Figure 51 : Bloc de l'entrée analogique ................................................................................................. 45
Figure 52 : Ajout du module DELSIG11 ................................................................................................ 47
Figure 53 : Câblage de l'entrée analogique........................................................................................... 47
Figure 54 : Signal d'horloge des blocs DELSIG11 ................................................................................ 48
Figure 55 : Paramétrage de l'afficheur LCD .......................................................................................... 48
Figure 56: Affichage sur LCD ................................................................................................................ 50
Figure 57: Formatage de l'affichage de la tension ................................................................................ 50
Figure 58 : Bloc Buzzer et pin de branchement............................................................................................. 52
Figure 59 : Ajout du module PWM16 .............................................................................................................. 54
Figure 60 : Blocs du module PWM16.................................................................................................... 54
Figure 61 : Etapes de câblage de la sortie du PWM16......................................................................... 54
Figure 62 : la sortie "CompareOut" reliée au pinout 2.5........................................................................ 55
Figure 63 : Interface de communication OneWire................................................................................. 60
Figure 64: Scatchpad du DS18S20 ....................................................................................................... 61
Figure 65 : Format du registre température .......................................................................................... 61
Figure 66 : Ajout du module OneWire ................................................................................................... 63
Figure 67 : Câblage du module OneWire.............................................................................................. 63
Figure 68 : Fréquence d'horloge du module OneWire .......................................................................... 64
Figure 70: Affichage de la température ................................................................................................. 66
Figure 71 : Ajout du module UART........................................................................................................ 69
Figure 72 : Câblage du module UART .................................................................................................. 69
Figure 73 : Horloge du module UART ................................................................................................... 70
Figure 74: Etapes d'affichage sur l’HyperTerminal ............................................................................... 72
LISTE DES TABLEAUX
Tableau 1: Récapitulatif des différentes caractéristiques........................................................................ 4

Tableau 2: Branchement des pins du clavier .......................................................................................... 6
Tableau 3: Configuration des PINs (RS232) ........................................................................................... 9
Tableau 4: Configuration des résistances de tirages ............................................................................ 23
Tableau 5: Correspondance température/donnée numérique .............................................................. 61
TRAVAUX PRATIQUES
Plan
-Travaux pratique N°0 :
Débuter avec PSoC
Gestion du clavier
Atelier PSoC
Gestion de l’écran LCD et l’Afficheur 7 segments
La conversion Analogique/Numérique
Commande d’un Buzzer
Capteur de température numérique : DS18S20
La communication série : UART

TP : 0
Débuter avec PSoC
Objectifs spécifiques
Le but de ce TP est de se familiariser avec les circuits PSoC et leur environnement,

prendre en main le logiciel et le kit d'évaluation, développer une application simple.
Volume horaire
6 heures.
1. MISE EN SITUATION :
1.1.Introduction
Le PSoC (Programmable System on Chip) est un composant associant un Microcontrôleur et
des fonctions logiques et analogiques configurable et interconnectables entre eux dont le but
est de réduire le nombre des composants.
Figure 1 : PSoC (Programmable System on Chip)
La famille PSoC est constituée des références CY8C21x34, CY8C24x23A, CY8C26xxx,

CY8C27x43, CY8C29x66, qui diffèrent selon le nombre de blocs numériques et analogiques
intégrés, la taille de la mémoire de programme (type Flash), celle de la mémoire de données
(type SRAM) et le nombre de broches d’entrée/sortie (de 6 pour les boîtiers 8 broches à 44
pour les boîtiers 48 broches). Certaines caractéristiques sont communes tel que la tension
d’alimentation qui est de 3,3 V à 5 V, la fréquence de travail qui varie de 93,7 kHz à 24 MHz
ou encore la température de fonctionnement.
La figure suivante présente l’architecture interne d’un PSoC
Figure 2 : Architecture interne d’un PSoC
-1-
Le cœur de la structure interne d’un PSoC est un microcontrôleur 8-bits qui interagit avec :
Mémoire Flash
Oscillateurs Internes
Multiplieur/Accumulateur
Contrôleur D’interruptions, Sleep Timer, Watchdog Timer
Contrôleur I2C.
Il présente également des blocs logiques et analogiques banalisés configurables :

Blocs logiques configurables en compteurs, timers, UARTs, PWMs, SPI, générateurs
CRC, séquences pseudo aléatoires, etc.
Blocs analogiques configurables en amplis-op simples, comparateurs, filtres, CNAs,
CANs, modem, etc.
1.2.Contenu du kit
Tout au long des séances de l’atelier, nous allons utiliser la CT PSOC-DEV01 qui est un kit
didactique fabriqué et commercialisé par la société tunisienne Corail Technologies.
La CT PSOC-DEV01 est un système de développement pour les microcontrôleurs Cypress
PSOC. Elle est conçue pour permettre aux étudiants de tester rapidement et facilement les
capacités des microcontrôleurs PSOC. Elle permet aussi d’interfacer les microcontrôleurs
PSOC avec des circuits et des systèmes extérieurs.
Pour utiliser ce kit, il faut passer par ces étapes :
Etape 1 : installer le PSoC Designer Setup.
Etape 2 : alimenter la carte CT PSOC-DEV01.
Etape 3 : connecter le PSOC MINIProg au PC par le câble rétractable USB2 contenu
dans le kit CY3217 et à la carte CT PSOC-DEV01 par le biais du connecteur ISSP.
Etape 4 : tourner l’alimentation ON.
Figure 3: Présentation du kit
-2-
Dans ce qui suit, nous allons présenter le manuel d’utilisation de la CT PSOC-DEV01 avant
d’entamer la partie manipulation.
1.3.Manuel d’utilisation de la CT PSOC-DEV01
La carte de développement CT PSoC-DEV01 permet d’utiliser un grand nombre de PSoC, elle

est livrée avec deux PSoC Cypress CY8C27643 montés sur des cartes d’adaptation SSOP48-
DIP48.Elle permet aussi d’interfacer les microcontrôleurs PSOC avec des circuits et des
systèmes extérieurs.
Les figures 4 et 5 présentent respectivement un schéma synoptique présentant les différents
blocs de la CT PSOC-DEV01 et une image réelle détaillant les composants réels de la carte :
Figure 4: Schéma synoptique
Figure 5: Photo réel de la CT PSOC-DEV01
-3-
On présente également le schématique de la carte dans l’ [Annexe1]. Ceci est conçu et fourni
par la société Corail Technologies.
A partir de ce manuel, on va étudier chaque bloc séparément afin d’identifier et comprendre
le rôle dans le fonctionnement de la carte.
1.3.1. Bloc MCU
La carte de développement CT PSoC-DEV01 contient un bloc MCU comme l’indique la figure

suivante :
Figure 6: Bloc MCU
Le Bloc MCU contient trois autres sockets : DIP28, DIP20 et DIP8. Il est à signaler également
qu’avec cette carte, on peut monter et utiliser une liste non exhaustive des PSoC suivante :
CY8C21123 CY8C21223 CY8C21234 CY8C21323 CY8C21334 CY8C21434

CY8C28645 CY8C29466 CY8C29566 CY8C29666 CY8C29866
Tous les Ports du microcontrôleur sont connectés sur des connecteurs SILS pour les utiliser
dans des applications externes.
Le tableau ci-dessous indique les différents types de PsoC1 ainsi que leurs principales
caractéristiques :
Tableau 1: Récapitulatif des différentes caractéristiques
-4-
Remarque :
Pour le kit d’évaluation, le circuit implémenté est le CY8C27643.
Vu les connexions entre les différents sockets, il ne faut brancher qu’un seul
microcontrôleur à la fois.
1.3.2. Bloc d’alimentation
La carte de développement CT PSoC-DEV01 peut être alimentée par deux sources de

tension :
une alimentation extérieure +12V (convertisseur extérieure AC/DC SAGEM)
une alimentation +5V du programmateur PSOC MINIProg.
Lors de l’utilisation d’une source extérieure, l’alimentation +5V est délivrée par le circuit
régulateur L49418V. Elle présente un switch S1 qui bascule entre ces deux types de sources
de tension.
Figure 7: Bloc d’alimentation
1.3.3. Jumper
Un Jumper est utilisé pour établir une connexion entre deux points. Sous la couverture
plastique du Jumper, il y’a un contact métallique qui établit une connexion quand le Jumper
est placé entre les deux points.
Il est utilisé soit pour sélectionner entre deux connexions possibles d’un connecteur de trois
pins : le pin du milieu peut être connecté au pin de droite ou de gauche, soit pour connecter
le microcontrôleur à un bloc donné de la carte.
Figure 8 : Jumper
-5-
1.3.4. Bloc LED
La carte CT PSoC-DEV01 contient un bloc de 8 LED connectées à travers d’un Jumper W2

au port0 du microcontrôleur. LED (light-emitting diode) est un composant largement utilisé
pour afficher l’état logique.
Une diode LED ne laisse passer le courant électrique que dans un seul sens (le sens passant,
comme une diode classique, l'inverse étant le sens bloquant.
Figure 9: Bloc de 8 LED
1.3.5. Bloc Clavier
La carte CT PSoC-DEV01 contient un clavier (4 lignes x 4 colonnes) connecté directement

au port4 du microcontrôleur. Il est largement utilisé dans les applications embarquées pour
la commande et l’interface homme/ machine.
Figure 10 : Bloc Clavier
Ce clavier contient 16 touches dont leur branchement avec les pins du microcontrôleur est
mentionné dans le tableau ci-dessous :
Tableau 2: Branchement des pins du clavier
1.3.6. Bloc d’affichage
Les afficheurs à cristaux liquides, autrement appelés afficheurs LCD (Liquid Crystal Display),
sont des modules compacts intelligents et nécessitent peu de composants externes pour un
bon fonctionnement.
-6-
La carte CT PSoC-DEV01 contient un afficheur LCD connecté directement au port1 du
microcontrôleur dont son contraste est réglable par un potentiomètre et communique en 4-
bits parallèles.
Il est doté également d'un rétroéclairage de l'affichage via une LED montée derrière l'écran
du module et branchée au port 2 pin 4 du microcontrôleur.
Il est utilisé pour visualiser les données et les messages sur deux lignes et 16 caractères.
Figure 11: Blocs LCD & Contraste
La carte CT PSoC-DEV01 est équipée aussi d’un afficheur 4 digits 7 segments comme le
montre la figure ci-dessous :
Figure 12: Bloc afficheur 7 segments
Les afficheurs 7 segments sont un type d'afficheur très présent sur les applications
embarquées : les caractères (des chiffres, bien que quelques lettres soient utilisées pour
l'affichage hexadécimal) s'écrivent en allumant ou en éteignant des segments, au nombre de
sept.
Cet afficheur 7segements est constitué de 4 digits reliés au port1 du microcontrôleur et 7
segments et un DP (digital point) reliés au port0 (voir le schématique dans l’Annexe1).
1.3.7. Bloc ADC
La carte CT PSoC-DEV01 contient un potentiomètre utilisé pour ajuster une tension de test
d’une valeur comprise entre 0v-5v. Cette tension est connectée à travers un Jumper w1 au
pin P2.1.
Figure 13: Bloc ADC
L’utilisation de la conversion A/N est très répandue dans la plupart des applications. Dans
notre cas, le PSOC accepte une valeur mesurée qui varie entre 0v-5v.
-7-
1.3.8. Bloc Buzzer
La carte CT PSoC-DEV01 contient un Buzzer connecté à travers d’un Jumper W4 au pin p2.5
pour le commander par un signal PWM.
Figure 14: Bloc Buzzer
Un Buzzer est un élément électromécanique ou piézoélectrique qui produit un son

caractéristique quand on lui applique une tension.
La fréquence du signal sonore est relative au signal appliqué. Cette fréquence est
généralement comprise entre 2 kHz et 4 kHz. Ce type de Buzzer peut générer des bips
graves, aigus, plus graves ou plus aigus.
1.3.9. Capteur DS1820
Le thermomètre DS1820 est un capteur numérique de température qui capte une valeur entre
-55° et +125° avec une résolution de 0.5° (entre -10° et +85°).
Figure 15: Bloc thermomètre
Il communique avec le microcontrôleur par le biais d’une liaison 1_wire qui permet de
connecter (en série, parallèle ou en étoile) des composants avec seulement deux fils (un fil
de données et un fil de masse).Cette communication avec le PSoC est effectuée à travers les
deux pins p2.6 et p2.7.
1.3.10. Bloc de communication série (RS232)
La communication RS232 est largement utilisée pour l’acquisition et le transfert point à point
des données entre le microcontrôleur et le PC.
Puisque le niveau de tension entre ces deux derniers n’est pas compatible, il faut utiliser le
MAX232 qui inclut deux récepteurs transformant les signaux RS232 en signaux TTL, et deux
émetteurs transformant les signaux TTL en signaux RS232.
Ce circuit utilise un convertisseur élévateur de tension pour fournir les niveaux de +12V et -
12V à partir du +5V.
-8-
Tableau 3: Configuration des PINs (RS232)
Figure 16: Bloc RS232
2. Programmation de la carte CT PSoC--DEV01
Dans cette partie, nous allons décrire la programmation du PSoC intégré dans la carte CT
PSoC-DEV01. Ceci sera valable pour les différentes manipulations décrites dans ce fascicule.
La programmation du PSOC nécessite la présence d’un kit CY3217 contenant un PSOC
MINIProg qui permet le transfert du programme à la carte.
Figure 17: PSOC MINIProg et câble USB
Le PSOC MINIProg se connecte à la carte CT PSoC-DEV01 par le biais du connecteur ISSP et

au PC via un câble USB2.
3. Prise en main avec PSoC-DESIGNER 5.1

Cypress fournit plusieurs outils de développements gratuits comme PSoC Designer, PSoC
Creator et PSoC Programmer :
Figure 18: Outils de développement PSoC
-9-
Tout au long de cet atelier, nous faisons appel au logiciel PSoC Designer (voir Figure 19) pour
le développement des PSoC1.
Figure 19 : Interface du logiciel PsoC Designer
La conception d’un nouveau projet nécessite le passage par les quatre étapes suivantes :
Sélection et placement des modules
Configuration des modules et des drivers d'entrées et sorties
Connexion des modules
Codage, Compilation, vérification et débogage.
- 10 -
4. Manipulation :
4.1.Activité 1
L’objectif de cette activité est de débuter avec une première application simple sur la carte CT
PSoC-DEV0 qui consiste à allumer une LED (voir figure 20) choisie parmi 8 (D9 par exemple).
Figure 20: LED1 choisie
Ceci sera effectué en expliquant pas à pas les différentes étapes de développement d’une
application PSoC.
Figure 21: Etapes de développement d’une application PSoC
4.1.1. Après l’installation du PSoC Designer, lancez le programme et créez un nouveau

projet nommé « TestLed ».
- 11 -
4.1.2. Dans la fenêtre « Select Project Type», sélectionnez « select target device »
et cliquez sur view catalog. La fenêtre de « device catalog » s'ouvre. Cliquez sur
l'onglet PSoC et choisissez la référence CY8C27643-24PVXI.
4.1.3. Choisissez le langage de programmation C pour le programme main. Puis cliquez
sur OK.
4.1.4. Dans la fenêtre « User Modules», sélectionnez « Misc Digital » et cliquez sur le
module « LED ».
4.1.5. Paramétrez le module LED au niveau « Parameters-LED » et donnez les valeurs
des champs suivants :
o Name
o Port
o Pin
o Drive
(Vous pouvez afficher la documentation du module en cliquant avec le bouton droit sur le module
LED puis « Datasheet » puis « Show in Separate Window »).
4.1.6. Dans la fenêtre «Workspace Explorer», sélectionnez TestLed>Source
File>main.c et écrivez le programme permettant d’allumer la LED choisie.
4.1.7. Compilez le programme élaboré et ensuite effectuez le flashage du fichier « .HEX »
généré.
4.1.8. Testez directement l’allumage de la LED sur la carte alimentée par le
programmateur sans faire le branchement de l’alimentation externe.
4.2.Activité2
4.2.1. Modifiez le programme précèdent pour faire clignoter la diode LED (D9).
4.3.Activité3
Le but de cette activité est de créer un jeu de lumière à l’aide des huit diodes LED (D9D16)
4.3.1. Ajoutez les modules « LED » nécessaires pour créer le jeu de lumière et connectez
les pins de sorties.
4.3.2. Créez un programme qui permet de générer un jeu de lumière de votre choix (va
et vient, chenillard,…etc)
4.3.3. Transférez votre programme à la carte et vérifiez son bon fonctionnement.
- 12 -
Débuter avec PSoC : correction
Activité 1
4.1.1. Création d’un nouveau projet pour PSoC designer
Afin de créer un nouveau projet, nous suivons les étapes mentionnées dans la figure ci-
dessous :
Figure 22: Etapes de création d'un nouveau projet
4.1.2. Dans la fenêtre « Select Project Type», sélectionnez « select target device
» et cliquer sur view catalog. La fenêtre de « device catalog » s'ouvre. Nous
choisissons le PSoC CY8C27643-24PVXI pour notre kit d’évaluation comme
indique la figure suivante :
Figure 23: Device catalog-Chip level
- 13 -
4.1.3. Nous choisissons le langage de programmation C pour le programme main. Puis
nous cliquons sur OK.
Figure 24: Choix du langage C
4.1.4. Dans la fenêtre « User Modules», sélectionnez « Misc Digital » et cliquez sur
le module « LED ».
Dans cette étape, nous ajoutons le module LED (voir figure 24) via la fenêtre User
Modules. Ce module permet de contrôler une Led directement branchée sur une broche du
PSoC.
La fenêtre User Module n’est présente dans PSoC designer, nous pouvons
l’afficher avec le menu View puis User Module Catalog.
Figure 25: Insertion du Module LED
- 14 -
4.1.5. Paramétrez le module LED au niveau « Parameters-LED » et donnez les
valeurs des champs suivants :
o Name : LED_1
o Port : Port_0
o Pin : Port_0_0
o Drive : Active high
Figure 26 : Paramétrage et Pinout du module LED
NB :
Le module LED peut être configuré pour entraîner soit une configuration «Active High» ou
«Active Low».
Dans la configuration «Active High», l'anode de la LED est connectée à la broche de PSoC à
travers une résistance, et la cathode de la diode est reliée à Vss.
Par contre pour une configuration «Active Low», la cathode de la LED est connectée à la broche
de PSoC à travers une résistance, et l'anode de la diode est reliée à V cc. (voir datasheet LED)
Nous pouvons afficher la documentation du module en cliquant avec le bouton droit sur
LED ou sur LED_1 puis Datasheet puis « Show in Separate Window ».
Figure 27: Documentation du module LED
- 15 -
4.1.6. Dans la fenêtre «Workspace Explorer», sélectionnez TestLed>Source
File>main.c
Dans cette partie, nous écrivons le programme permettant d’allumer la diode LED.
En se référant à la datasheet du module LED, nous aurons besoin des fonctions suivantes :
- LED_Start() : La fonction permet d’éteindre la LED.
- LED_Switch() :La fonction permet d’éteindre ou d’allumer la LED selon la valeur
donnée :
 Si la valeur est à 1allumer la led
 Si la valeur est à 0éteindre la led.
Listing du programme :
-
#include <m8c.h>
-
#include "PSoCAPI.h"
void main(void)
{
LED_1_Start();
LED_1_Switch(1);
}
4.1.7. Compilation du programme élaboré et flashage du fichier « .HEX » généré.
Figure 28: Etapes de compilation
Dans la fenêtre Output en bas, nous devrons avoir le message suivant :
«TestLed - 0 error(s) 0 warning(s) 18:24:43
Dans cette partie, nous cherchons à flasher dans le PSoC le fichier .HEX généré. Pour cela,
nous allons suivre les étapes suivantes :
- 16 -
Etape1 : Connectez le programmateur CY3217 MiniProg à la carte, sans
alimenter la carte.
Figure 29: MiniProg CY3217
Etape2 : cliquez sur Program dans le menu de PSoC Designer puis Program Part…
Figure 30: Menu de PSoC Designer
Etape3 : cliquez sur le bouton de programmation (encadrer en bleu)
Figure 31: Menu Program Part
- 17 -
Etape4 : Cliquer sur le bouton d’alimentation (encadrer en rouge)
Figure 32: Menu Program Part
Activité2
Pour faire le clignotement de la diode LED (D9), nous aurons besoin d’ajouter :
LED_Invert() : Cette fonction inverse l'état de la LED . Si le voyant était allumé, il sera
éteint; si il était éteint , il sera allumé.
- Boucle infinie while(1) : Une boucle dont la condition de sortie n'a pas été définie. En
conséquence, la boucle ne peut se terminer qu'après l'interruption du programme qui
l'utilise.
- Boucle for : Dans notre programme, nous allons utiliser la boucle for qui remplace la
fonction delay() afin de suspendre le programme durant un temps bien déterminé.
-
#include <m8c.h>
-
void main(void)
{
int i ;
LED_1_Start();
LED_1_Switch(1);
while(1) {
LED_1_Invert();
for(i=0;i<10000;i++)
{
}
}
}
Activité3
Le but de cette activité est de créer un jeu de lumière à l’aide des huit diodes LED (D9D16)
- 18 -
4.3.1. Ajoutez les modules « LED » nécessaires pour créer le jeu de lumière et
connectez les pins de sorties.
Nous ajoutons huit Leds de D9 à D16 selon la configuration matérielle suivante :
D9 D10 D11 D12 D13 D14 D15 D16
Name LED_1 LED_2 LED_3 LED_4 LED_5 LED_6 LED_7 LED_8
Port Port_0 Port_0 Port_0 Port_0 Port_0 Port_0 Port_0 Port_0
Pin Port_0_0 Port_0_1 Port_0_2 Port_0_3 Port_0_4 Port_0_5 Port_0_6 Port_0_7
4.3.2.Créez un programme qui permet de générer un jeu de lumière de votre choix.
Nous nous intéressons à écrire un programme permettant de générer un jeu de lumière

représentant un chenillard de telle sorte qu’un mouvement lumineux qui se produit en
allumant et éteignant successivement une série de lampes ou LED. L'effet se traduit par un
déplacement de cette lumière dans un sens choisi, par exemple de gauche à droite.
-
#include <m8c.h>
-
int i ;
void main(void)
{
while (1)
{
LED_1_Invert();
for(i=0;i<9000;i++);
LED_1_Invert();
LED_8_Invert();
for(i=0;i<9000;i++);
LED_8_Invert();
LED_7_Invert();
for(i=0;i<9000;i++);
LED_7_Invert();
LED_6_Invert();
for(i=0;i<9000;i++);
LED_6_Invert();
LED_5_Invert();
for(i=0;i<9000;i++);
LED_5_Invert();
LED_4_Invert();
for(i=0;i<9000;i++);
LED_4_Invert();
LED_3_Invert();
for(i=0;i<9000;i++);
LED_3_Invert();
LED_2_Invert();
for(i=0;i<9000;i++);
LED_2_Invert();
}
}
- 19 -
TP : 1
Gestion du Clavier
A la fin de ce TP, l’étudiant doit être capable de faire la configuration matérielle nécessaire
et d’écrire un programme permettant la manipulation du clavier situé sur la carte CT
PSoC-DEV01.
Volume horaire
6 heures.
1. MISE EN SITUATION
1.1.Principe de fonctionnement du clavier :
Un clavier est constitué, comme montre la figure ci-dessous, de 16 boutons poussoirs

interconnectés de façon à former une matrice 4x4 (4 lignes x 4 colonnes). Un appui sur une
touche court-circuite la ligne et la colonne correspondantes.
Des résistances de tirage vers le bas (résistance de pull-down) pour garantir l’état bas des
rangées (colonnes) au repos. Dans la carte CT PSoC-DEV01, nous utilisons les résistances de
tirage intégré dans le PSoC.
Figure 33: Clavier
Pour plus de détails sur le clavier, revoir la partie mise en situation du TP0.
1.2.Principe d’acquisition d’une touche du clavier :
A travers le mappage du port/clavier, nous expliquons les étapes à suivre pour dégager l’adresse
d’une touche du clavier B10 à titre d’exemple.
Figure 34: Etapes à suivre pour dégager l’adresse de la touche B10
- 21 -
2. MANIPULATION
2.1.Activité 1
Le but de cette activité est d’écrire un programme permettant de commander une diode LED à
travers une touche parmi 16 du clavier.
2.1.1. Déterminez sur quel port le clavier est branché avec le PSoC de la carte CT PSoC-
DEV01.
2.1.2. Complétez le tableau suivant récapitulant l’adresse de chaque touche du clavier
Numéro de la Adresse Numéro Adresse Numéro de Adresse Numéro de Adresse

touche en de la en la en la en
hexadécimal touche hexadécimal touche hexadécimal touche hexadécimal
B1 B5 B9 B13
B2 B6 B10 B14
B3 B7 B11 B15
B4 B8 B12 B16
2.1.3. Ajoutez le module LED qui se trouve sous User Modules\ Misc Digital et le
configurez tout en indiquant les valeurs de ces paramètres.
2.1.4. Paramétrez le brochage du microcontrôleur pour configurer les résistances de
tirages intégrées dans le PSoC.
2.1.5. Créez un programme qui permet de commander une diode LED à travers une
touche du clavier : Tant que la touche est appuyée, la led s’allumera.
2.1.6. Transférez votre programme à la carte et vérifiez son bon fonctionnement
2.2.Activité 2
Modifiez le programme précèdent pour commander maintenant la Led par deux touches du
clavier tel qu’une touche du clavier choisie allumera la LED et l’autre éteindra.
2.3.Activité 3
Nous allons ajouter au programme précèdent (activité2) une troisième touche du clavier choisie
arbitrairement qui assure le clignotement de la Led.
- 22 -
Gestion du Clavier : correction
Activité 1
2.1.1. Le clavier est branché avec le PSoC de la carte CT PSoC-DEV01 sur le port 4.
2.1.2. Le tableau suivant présente l’adresse de chaque touche du clavier.
Numéro de la Adresse Numéro Adresse Numéro de Adresse Numéro de Adresse

touche en de la en la en la en
hexadécimal touche hexadécimal touche hexadécimal touche hexadécimal
B1 0x18 B5 0x28 B9 0x48 B13 0x88
B2 0x14 B6 0x24 B10 0x44 B14 0x84
B3 0x12 B7 0x22 B11 0x42 B15 0x82
B4 0x11 B8 0x21 B12 0x41 B16 0x81
2.1.3. Nous ajoutons le module LED tout en le configurant à travers le remplissage de

ces paramètres.
Figure 35: Configuration du module LED
2.1.4. Dans cette partie, nous paramétrons les broches du microcontrôleur afin de
configurer les résistances de tirages :
Tableau 4: Configuration des résistances de tirages
- 23 -
Pour cela, nous suivrons les étapes suivantes :
Etape1 : Cliquez P4 [0] Drive et sélectionnez Pull Down
Figure 36: Etape1 Drive-Pull Down
Il existe différents modes d'entraînement :

 High Z : Ce mode peut être utilisé lorsque le signal d'entrée est numérique ou analogique.
Mais il ne doit pas être utilisé lorsque la broche doit fonctionner comme une broche de
sortie. Lorsque le mode « High Z » est sélectionné, le trigger de Schmitt est activé. Dans
ce cas, la CPU peut lire l'état de la broche à travers le registre PRTxDR où le signal sur la
broche peut être transmis à des blocs numériques.
 High Z Analog : Ce mode d'entraînement doit être utilisé lorsque la broche sera
configurée comme entrée analogique. Dans ce mode, le trigger de Schmitt est désactivée.
 Open Drain Low et Open Drain High : Le mode Open Drain Low peut être utilisé pour
mettre en œuvre un circuit ET câblé.
o Par contre, le mode Open Drain High peut être utilisé pour créer un circuit OU
câblé.
 Pull Up et Pull Down : Dans ces modes, la broche est entraînée par une résistance pour
un 1 et 0 respectivement. Ces modes peuvent être utilisés aussi bien pour les entrées et
les sorties.
 Strong : Ce mode d'entraînement est utilisé lorsqu’ une sortie connectée à la broche
nécessite plus de quantité de courant.
 Strong Slow : Un condensateur interne est ajouté lorsque ce mode est choisi. Cela réduit
les harmoniques de la sortie.
- 24 -
Etape2 : Répétez la même manipulation pour P4 [1] jusqu’à P4 [7]. Le résultat
devrait ressembler à la figure ci-dessous :
Figure 37: Configuration de 8 pins du port4
2.1.5. Pour écrire un programme permettant d’allumer une diode LED à travers la
touche B1 du clavier par exemple, nous avons recours aux :
Registre PRTXDR : C’est un registre de données qui contrôle l’état des ports. Chaque port
est associé à un registre de données. Par exemple, PRT4DR contrôle le Port4 ; Le bit # 0 des
contrôles PRT4DR est associé au P4 [0]. L'état d'une broche GPIO peut également être lu en
utilisant le registre PRTxDR.
Variable rows (type chaine de caractère) : nous affectons dans cette variable l’adresse de la
ligne.
PRT4DR = 0x0F; //initialisation
rows = PRT4DR; //adresse de la ligne
Variable cols (type chaine de caractère) : nous attribuons dans cette variable l’adresse de la
colonne.
PRT4DR = 0xF0; //initialisation
cols = PRT4DR; //adresse de la colonne
Variable code (type chaine de caractère) : nous stockons dans cette variable l’adresse de la
touche du clavier appuyée. Ceci résulte d’un ET logique (&) entre rows et cols.
LED_Switch(1) : nous utilisons cette fonction pour activer la diode led.
- 25 -
#include <m8c.h>
char rows = 0, cols = 0;
char code ;
void main(void)
{
LED_1_Start();
while(1){
PRT4DR = 0xF0;
cols = PRT4DR;
PRT4DR = 0x0F;
rows = PRT4DR;
code = rows & cols;
switch (code)
{
case 0x18: //Adresse de la touche B1
LED_1_Switch(1);
break;
default: LED_1_Switch(0);
break;
}
}
}
Activité 2
2.2.1. Pour qu’une touche du clavier choisie allumera la LED et l’autre l’éteindra, nous
ajoutons alors au programme précédent le code source suivant :
……
switch (code)
{
case 0x18:
LED_1_Switch(1);
break;

LED_1_Switch(0);
break;
default:
break;
}
}
}
- 26 -
Activité 3
2.3.1. Nous allons ajouter au programme précèdent (activité2) une troisième touche
du clavier choisie arbitrairement qui assure le clignotement de la LED.
#include <m8c.h>
char code ;
void main(void)
{
int i ;
LED_1_Start();
while(1){
PRT4DR = 0xF0;
cols = PRT4DR;
PRT4DR = 0x0F;
rows = PRT4DR;
code = rows & cols;
switch (code)
{
LED_1_Switch(1);
break;
LED_1_Switch(0);
break;
while(1){
LED_1_Invert();
for(i=0;i<9000;i++);
PRT4DR = 0xF0;
cols = PRT4DR;
PRT4DR = 0x0F;
rows = PRT4DR;
code = rows & cols;
if ((code==0x18)||(code==0x14))
{break;}
default:
break;
}
}
}
- 27 -
TP : 2
Gestion de l’écran LCD et l’Afficheur
7segments
A la fin de ce TP, l’étudiant doit être capable de faire la configuration matérielle nécessaire
et d’écrire un programme permettant de commander un écran LCD tout en faisant appel
à un clavier en première partie et en utilisant un afficheur 7segments en deuxième partie.
Volume horaire
6 heures.
1. MISE EN SITUATION
1.1.Principe de fonctionnement d’un écran LCD
L’afficheur alphanumérique LCD dispose de 2 lignes de 16 caractères, il est compatible avec le

PSoC. (Pour plus de détails, veuillez consulter la partie mise en situation-TP0).
Figure 38: Ecran LCD
Il est à signaler aussi que cet afficheur LCD dispose d’une LED rétroéclairage.
Pour notre écran LCD (2x16), le coin supérieur gauche est la position (0,0) et le coin inférieur
droit est la position (1,15) comme il est indiqué dans la figure suivante :
Figure 39: Position du curseur
1.2.Principe de fonctionnement d’un afficheur 7segments
Un afficheur 7 segments est le plus simple des afficheurs. On le retrouve très fréquemment
lorsqu'il s'agit d'afficher une information numérique. Il est constitué de 7 LED (+1 pour le point)
reliées ensemble par leur anode (il en existe aussi reliés par la cathode). Classiquement les
différentes LED (aussi appelées segments) sont nommées conformément au schéma ci-
dessous :
Figure 40: Afficheur 7 Segments
- 29 -
La carte CT PSoC-DEV01 est équipée d’un afficheur 4 digits 7 segments comme le montre la
figure ci-dessous :
Figure 41: Afficheur 7segments 4digits
2. MANIPULATION
Nous allons diviser la manipulation en deux parties ; la première partie s’intéressera à la
manipulation de l’écran LCD tout en faisant appel au clavier et la deuxième partie se focalisera
sur l’étude et la manipulation de l’afficheur 7segments 4digits.
Partie1 : Ecran LCD-Clavier
2.1.Activité 1
Le but de cette activité est de tester le fonctionnement de l’écran LCD à travers l’affichage de
messages sur cet écran sans omettre d’allumer la LED de rétroéclairage intégrée.
2.1.1. Déterminez sur quel port la LED de rétroéclairage est branchée avec le PSoC de
la carte CT PSoC-DEV01.
2.1.2. Ajoutez le module LED qui se trouve sous User Modules\ Misc Digital et
configurez cette LED de rétroéclairage.
2.1.3. Déterminez sur quel port l’écran LCD est branché avec le PSoC de la carte CT
PSoC-DEV01.
2.1.4. Ajoutez le module LCD qui se trouve sous User Modules\ Misc Digital et le
(Cliquez sur le bouton droit du module LCD pour afficher la documentation).
2.1.5. Créez un programme qui permet de tester le fonctionnement de l’écran LCD à
travers l’affichage du message suivant : « test LCD » en première ligne tout en
activant le rétroéclairage.
- 30 -
2.2.Activité 2
Nous cherchons maintenant à exploiter les deux modules « clavier » et « LCD » de tel sorte que
l’appui sur une touche du clavier engendre l’affichage de son nom sur l’écran LCD en première
ligne.
2.2.1. Refaites les étapes nécessaires (déjà vu au niveau TP1) pour configurer le clavier.
2.2.2. Donnez le programme permettant de commander le clavier et l’écran LCD.
2.3.Activité 3
L’objectif de l’activité est d’appliquer le principe de la serrure à code
2.3.1. Ecrivez le programme adéquat traduisant le principe de la serrure codée : un
message est affiché sur l’écran LCD demandant l’utilisateur de saisir un code. Une
fois le code saisi, s’il est correct, le message « code valide » est affiché et une LED
s’allume pendant 3 secondes puis on revient au message de départ. Si le code est
erroné, le message « erreur » est affiché pendant une seconde et on redemande de
saisir le code. (Choisissez un code composé de 3 chiffres)
Partie2 : Afficheur 7segments 4digits

2.4.Activité 4
Le but de cette activité est d’utiliser l’afficheur 7segments avec 4digits afin de visualiser le
nombre 1234 comme indique la figure suivante :
Figure 42: Affichage du nombre 1234
2.4.1. En se référant au schématique, déterminez sur quel port du PSoC

Les 7 segments sont branchés ?
Les 4 digits sont branchés ?
2.4.2. Ajoutez le module LED7SEG qui se trouve sous User Modules\ Misc Digital et
le configurez.
(Cliquez sur le bouton droit du module LED7SEG pour afficher la documentation).
2.4.3. Combien de modules utilisateurs nécessite l’afficheur 7segments ? de quels types
sont les modules ?
2.4.4. Ecrivez le programme adéquat affichant le nombre 1234.
- 31 -
2.5.Activité 5
Modifiez le programme précèdent pour afficher maintenant une séquence de valeur de 0000
jusqu’ à 9999. Le résultat sera affiché sur le module « LED7SEG» comme indique la figure
suivante :
Figure 43: Affichage de la séquence de 0000 jusqu’ à 9999
2.6.Activité 6
Le but de cette activité est de commander deux modes de fonctionnement avec deux boutons
du clavier (B1 et B4) :
- Un appui sur B1 déclenche un compteur de 0 à 10
- Un appui sur B4 déclenche un décompteur de 10 à 0
Figure 44: Schéma explicatif du fonctionnement souhaité
2.6.1. Ecrivez le programme adéquat.

- 32 -
Gestion de l’écran LCD et l’Afficheur
7segments : correction
Partie1 : Ecran LCD-Clavier

2.1.Activité 1
2.1.1. La LED de rétroéclairage est branchée avec le PSoC au port 2 pin4.

2.1.2. Ajoutez le module LED qui se trouve sous User Modules\ Misc Digital et
configurez cette LED de rétroéclairage.
Figure 45: Configuration de la LED de rétroéclairage.
2.1.3. L’écran LCD est branché avec le PSoC au port1.

2.1.4. Ajoutez le module LCD qui se trouve sous User Modules\ Misc Digital et le
Figure 46: Configuration du module LCD
BarGrah=Disable Le code BarGraph est désactivé pour économiser l'espace ROM.

2.1.5. Pour afficher le message suivant : « test LCD » sur l’écran LCD en première
ligne avec l’activation du rétroéclairage, nous avons recours aux fonctions
suivantes :
LCD_Start(): Initialise LCD pour utiliser l'interface multi- ligne 4 -bit . Cette fonction doit être
appelée avant toutes les autres fonctions de l'écran LCD.
- 33 -
LCD_Position(BYTE bRow, BYTE bCol) : Cette fonction permet de déplacer le curseur à un
emplacement spécifié par les paramètres . Le caractère supérieur gauche est (la ligne 0,
colonne 0) et le caractère inférieur droit est (la ligne 1, colonne 15).
 bRow : C’est le numéro de la ligne à laquelle le curseur est positionné ; le Zéro

spécifie la première ligne.
 bCol : C’est le numéro de la colonne à laquelle le curseur est positionné ; le Zéro
spécifie la première colonne.
LCD_PrCString(" Message à afficher ") : Cette fonction permet d’afficher une chaine de caractère
sur l’écran LCD à la position indiquée au préalable.
LCD_PrString(theStr) : Cette fonction permet d’imprimer la valeur détenue par theStr à l'écran
LCD.
#include <m8c.h> #include <m8c.h>

#include "PSoCAPI.h" #include "PSoCAPI.h"
void main(void) void main(void)
{ {
LED_BL_Start(); char theStr[] = "test LCD";
LED_BL_Switch(1);
LED_BL_Start();
LCD_Start(); LED_BL_Switch(1);
LCD_Position(0,5);
LCD_PrCString("test LCD"); LCD_Start();
} LCD_Position(0,5);
LCD_PrString(theStr);
}
2.2.Activité 2
Nous cherchons maintenant à exploiter les deux modules « clavier » et « LCD » de tel sorte que
l’appuie sur une touche du clavier engendre l’affichage de son nom sur l’écran LCD en première
ligne.
2.2.1. Refaites les étapes nécessaires pour configurer le clavier.
Figure 47: Pinout-Clavier
- 34 -
Pour plus détails, nous vous conseillons de voir le TP1.
2.2.2. Donnez le programme permettant de commander le clavier et l’écran LCD.
#include <m8c.h>
char code ;
void main(void)
{
LED_BL_Start();
LED_BL_Switch(1);
LCD_Start();
while(1)
{
PRT4DR = 0xF0;
cols = PRT4DR;
PRT4DR = 0x0F;
rows = PRT4DR;
code = rows & cols;
switch (code)
{ case 0x18:
LCD_Position(1,1);
LCD_PrCString("B1");
break;
case 0x14:
LCD_Position(1,1);
break;
case 0x12:
LCD_Position(1,1);
break;
case 0x11:
LCD_Position(1,1);
break;
case 0x28:
LCD_Position(1,1);
break;
case 0x24:
LCD_Position(1,1);
break;
case 0x22:
LCD_Position(1,1);
break;
- 35 -
case 0x21:
LCD_Position(1,1);
break;
case 0x48:
LCD_Position(1,1);
break;
case 0x44:
LCD_Position(1,1);
break;
case 0x42:
LCD_Position(1,1);
break;
case 0x41:
LCD_Position(1,1);
break;
case 0x88:
LCD_Position(1,1);
break;
case 0x84:
LCD_Position(1,1);
break;
case 0x82:
LCD_Position(1,1);
break;
case 0x81:
LCD_Position(1,1);
break;
default:
LCD_Control(LCD_DISP_CLEAR_HOME);
LCD_Position(0,0);
LCD_PrCString("Press Button");
break;
}
}
}
- 36 -
2.3.Activité 3 :
L’objectif de l’activité est d’appliquer le principe de la serrure à code
2.3.1. Ecrivez le programme adéquat traduisant le principe de la serrure codée : un
message est affiché sur l’écran LCD demandant l’utilisateur de saisir un code. Une
fois le code saisie, s’il est correct, le message « code valide » est affiché et une LED
s’allume pendant 3 secondes puis on revient au message de départ. Si le code est
erroné, le message « erreur » est affiché pendant une seconde et on redemande de
saisir le code. (Choisissez un code composé de 3 chiffres)
Pour mieux comprendre le principe de la serrure codée, nous divisons l’explication du programme
en deux parties :
Partie1 :
#include <m8c.h>
char a1=0;
char b1=0;
char a;
int i,j ;
char c[3];
void main(void)
{
LED_BL_Start();
LED_BL_Switch(1);
LCD_Start();
LED1_Start();
LCD_Position(0,0);
LCD_PrCString("entre code:");
while(1)
{
i=0;
while(i<3)
{
LCD_Position(1,i);
PRT4DR=0xF0 ;
a1=PRT4DR ;
PRT4DR=0x0F ;
b1=PRT4DR ;
for(j=0;j<10000;j++);
if((a1!=0xF0) && (b1!=0x0F))
{
c[i]=(a1 & b1);
LCD_PrCString("*");
for(j=0;j<10000;j++);
i++;
}
}
La boucle While(i<3){……} est utilisée pour lire le code à 3 chiffres. Cette partie du programme
permet le cryptage du code de la touche appuyée en affichant le caractère « * » sur l’écran LCD.
- 37 -
Partie2 :
if ((c[0] == 0x18) && (c[1] == 0x14) && (c[2] == 0x12))

// le code de référence = 123
{
LCD_Position(1,1);
LCD_PrCString("code valide");
LED1_Switch(1);
for(i=0;i<30000;i++);
LED1_Switch(0);
LCD_Position(0,1);
LCD_PrCString("entrer code :");
}
else
{
LCD_Position(1,1);
LCD_PrCString("erreur");
for(i=0;i<20000;i++);
LCD_Position(0,1);
LCD_PrCString("entrer code :");
}
}
}
La structure conditionnelle if permet de vérifier le code saisi par rapport le code valide.
Partie2 : Afficheur 7segments 4digits

2.4.Activité 4
2.4.1. Les afficheurs 7 segments sont branchés au port_0 du PSoC tandis que les 4
points décimaux (DP) sont branchés au port_1.
2.4.2.Ajoutez le module LED7SEG qui se trouve sous User Modules\ Misc Digital et le
configurez.
Figure 48: Configuration du module LED7SEG
Lors de l’ajout du module, il faut choisir l’option « LED7SEg with MPX Timer ». D’après la
schématique de la carte, nous remarquons que le module 7 Segments à 4 digits est commandé
par 8 sorties du PSoC au lieu de 32 possibles (chaque afficheur 7 segments possède 8 entrées,
- 38 -
8*4 = 32) ce qui explique la nécessité d’un multiplexage pour l’adressage. D’après la datasheet,
pour un module à 4 digits, la valeur du paramètre « Multiplex Rate » doit être supérieur ou égale
1 KHZ.
Figure 49 : Commande du module 7 Segments à 4 digits
2.4.3. L’afficheur 7segments nécessite un seul module numérique.
Figure 50: Module numérique LED7SEG
2.4.4. Pour afficher le nombre 1234 sur l’afficheur 7segments 4digits, nous avons eu
recours aux fonctions suivantes :
M8C_EnableGInt : permet de supporter les interruptions.
LED7SEG_Start() : cette fonction efface toute la mémoire de l’afficheur et active la
numérisation.
LED7SEG_DispInt(int iValue, BYTE bPos, BYTE bLSD): permet d’afficher une valeur entière sur
l'écran . Il peut être compris entre 1 et 4 chiffres en longueur et commencer à tout
emplacement.
 iValue : Valeur entière à afficher.
 bPos: permet de préciser la position à partir de laquelle nous pouvons afficher notre nombre à
4chiffres.
 bLSD : présente le nombre de chiffre à utiliser pour l’affichage.
#include <m8c.h>
void main(void)
{
M8C_EnableGInt;
LED7SEG_Start();
LED7SEG_DispInt(1234, 1, 4);
}
- 39 -
Nous pouvons modifier ce programme en ajoutant la fonction suivante :
LED7SEG_DP(BYTE bOnOff, BYTE bDigit): permet d’activer/désactiver le point décimal tout
en indiquant son emplacement sur les 4digits.
 bOnOff =0 Désactiver le point décimal/ bOnOff =1 Activer le point décimal.
 bDigit: permet de préciser la position du point décimal sur les 4 digits.
LED7SEG_DP(1, 3); //Point décimal est activé et il est affiché sur le digit n°3
2.5.Activité 5
2.5.1. Pour afficher la séquence de valeur 0000 jusqu’ à 9999, nous écrivons le
programme suivant :
#include <m8c.h>
int i;
int j;
void main(void)
{
LED7SEG_Start();
M8C_EnableGInt;
while(1)
{
LED7SEG_Update();// contrôle le mis à jour de l’écran LED7SEG
for(j=0;j<10000;j++)
{LED7SEG_DispInt(0000, 1, 4);
}
LED7SEG_Update();
for(j=0;j<10000;j++)
}
LED7SEG_Update();
for(j=0;j<10000;j++)
}
LED7SEG_Update();
for(j=0;j<10000;j++)
}
LED7SEG_Update();
for(j=0;j<10000;j++)
}
- 40 -
LED7SEG_Update();
for(j=0;j<10000;j++)
}
LED7SEG_Update();
for(j=0;j<10000;j++)
}
LED7SEG_Update();
for(j=0;j<10000;j++)
}
LED7SEG_Update();
for(j=0;j<10000;j++)
}
LED7SEG_Update();
for(j=0;j<10000;j++)
{LED7SEG_DispInt(9999, 1, 4)
}
}
}
2.6.Activité 6
2.6.1. Nous présentons le programme adéquat pour assurer les deux fonctionnements
comptage et décomptage :
#include <m8c.h>
char cols=0;
char rows=0;
char code;
int i,j;
void main(void)
{
LED_BL_Start();
LED_BL_Switch(1);
LED7SEG_Start();
LCD_Start();
M8C_EnableGInt;
LCD_Position(0,0);
LCD_PrCString("B1 Comptage");
LCD_Position(1,0);
LCD_PrCString("B4 Decomptage");
for (j=0 ; j<20000 ; j++);
- 41 -
while(1)
{
PRT4DR=0xF0;
cols=PRT4DR;
PRT4DR=0x0F;
rows=PRT4DR;
code=rows&cols;
switch (code)
{
case 0x18: // Touche B1
LCD_Position(0,0);
LCD_PrCString("Comptage");
PRT4DR=0xF0;
cols=PRT4DR;
PRT4DR=0x0F;
rows=PRT4DR;
code=rows&cols;
while (code != 0x11)
{
for (i=0 ; i<=10 ; i++) // Comptage de 0==>10
{
LED7SEG_Update();
LED7SEG_DispInt(i, 1, 2);
for (j=0 ; j<20000 ; j++);
PRT4DR=0xF0;
cols=PRT4DR;
PRT4DR=0x0F;
rows=PRT4DR;
code=rows&cols;
if (code == 0x11)
break;
}
i=0;
PRT4DR=0xF0;
cols=PRT4DR;
PRT4DR=0x0F;
rows=PRT4DR;
code=rows&cols;
}
break;
case 0x11: // Touche B4

LCD_Position(0,0);
LCD_PrCString("Decomptage");
PRT4DR=0xF0;
cols=PRT4DR;
PRT4DR=0x0F;
rows=PRT4DR;
code=rows&cols;
- 42 -
while (code != 0x18)
{
for (i=10 ; i>=0 ; i--) // Décomptage de 10==>0
{
LED7SEG_Update();
LED7SEG_DispInt(i, 1, 2);
for (j=0 ; j<20000 ; j++);
PRT4DR=0xF0;
cols=PRT4DR;
PRT4DR=0x0F;
rows=PRT4DR;
code=rows&cols;
if (code == 0x18)
break;
}
i=0;
PRT4DR=0xF0;
cols=PRT4DR;
PRT4DR=0x0F;
rows=PRT4DR;
code=rows&cols;
}
break;
default:
LCD_Position(0,0);
LCD_PrCString("B1 Comptage");
LCD_Position(1,0);
LCD_PrCString("B4 Decomptage");
for (j=0 ; j<20000 ; j++);
break;
}
}
}
- 43 -
TP : 3
La conversion Analogique/Numérique
Le but de ce TP est de :
- Configurer le module de conversion A/N du PSoc.
- Faire l’acquisition d’une grandeur analogique.
- Afficher la grandeur acquise sur un afficheur LCD.
Volume horaire
6 heures.
1. Mise en situation :
La conversion A/N est utilisée dans de nombreuses applications. Le microcontrôleur prend un
signal analogique présent au niveau d’une entrée et le converti en une valeur numérique. Il est
possible de mesurer une valeur dans un intervalle acceptable par le microcontrôleur. Pour le
PSoC cet intervalle est entre 0v-5v. La carte CT PSoC-DEV01 contient un potentiomètre (voir
figure ci-dessous) utilisé pour ajuster une tension de test d’une valeur comprise entre 0v-5v.
Cette tension est connectée à travers un Jumper w1 à la pine P2.1 (voir schéma de câblage de
la maquette).
Le module interne du PSoC utilisé est le DELSIG11.Il fournit une sortie codée en complément à
2 sur 11 bits. Le module supporte des fréquences d'échantillonnage de 125 sps1 à 7,8 ksps.
Cette fréquence d’échantillonnage est déterminée par l’entrée d'horloge et est paramétrable par
l’utilisateur (pour plus d’informations concernant le module DELSIG11 consultez sa datasheet
accessible à partir du PSoCDesigner : clic droit sur le module > Datasheet).
Figure 51 : Bloc de l'entrée analogique
2. Manipulation :
Le but de cette manipulation est de faire l’acquisition de la tension délivrée par le potentiomètre
et de l’afficher sur un afficheur LCD :
2.1. Ajoutez le module DELSIG11 qui se trouve sous Users Modules\ADCs
2.2. Combien de modules utilisateurs nécessite le convertisseur ? de quels types sont les
modules ?
2.3. Reliez l’entrée du module analogique à l’entrée 2.1
2.4. Paramétrez le module en fixant les valeurs des champs suivants :
- Au niveau des paramètres globaux du projet :
o Analog Power
o Ref Mux
- Au niveau des paramètres de DELSIG11
o TMR Clock
o Input
o Polling
1 Sps : samples per second : échantillons par seconde
- 45 -
2.5. En se référant à la datasheet du module DELSIG11, donnez la formule qui permet de
calculer la valeur de la tension lue par le microcontrôleur
2.6. Ajoutez le module LCD et paramétrez-le (comme déjà vu au niveau du TP 3)
2.7. Réalisez un programme qui permet de lire la valeur envoyée par le potentiomètre et de
l’afficher sur l’afficheur LCD
2.8. Compilez votre programme et transférez le vers la maquette. Vérifiez son bon
fonctionnement.
2.9. Modifiez votre programme pour qu’il n’affiche que deux chiffres après la virgule.
- 46 -
La conversion Analogique/Numérique :
correction
2.1. Ajoutez le module DELSIG11 qui se trouve sous Users Modules\ADCs
Figure 52 : Ajout du module DELSIG11
2.2. Combien de modules utilisateurs nécessite le convertisseur ? de quels types sont les
modules ?
La conversion A/N nécessite deux blocs utilisateurs : un bloc analogique (DELSIG11 ADC) et
un bloc numérique (DELSIG11 TMR)
2.3. Reliez l’entrée du module analogique à l’entrée 2.1
Figure 53 : Câblage de l'entrée analogique

- Au niveau des paramètres globaux du projet :
o Analog Power : SC On/Ref High (le niveau maximal d’alimentation du bloc)
o Ref Mux : (Vdd/2)+/-(Vdd/2) (la plage de mesure s’étend de 0v à 5v)
- Au niveau des paramètres de DELSIG11
o TMR Clock : VC2 (il faut fixer le même signal d’horloge pour les deux blocs
analogique et numérique)
- 47 -
Figure 54 : Signal d'horloge des blocs DELSIG11
o Input : Port_2_1 (déjà câblé)

o Polling : Enable (afin de récupérer la valeur de la conversion directement de la
variable globale « DELSIG11_iResult » : voir datasheet)
2.5. En se référant à la datasheet du module DELSIG11, donnez la formule qui permet de
calculer la valeur de la tension lue par le microcontrôleur
La sortie du module DELSIG11 est codée sur 11 bits en complément à 2. Donc la valeur reçue
(stockée dans la variable globale DELSIG11_iResult) est comprise entre -1024 et 1024 pour une
entrée analogique comprise entre 0v et 5v. Pour appliquer la règle de trois, nous faisons un
décalage de 1024, ce qui nous donne :
2048 5v
DELSIG11_iResult +1048  valeur lue en volt
Donc : valeur lue en volt = (DELSIG11_iResult +1048)*5/2048 : c’est cette valeur lue qui
sera affichée sur l’afficheur LCD de la maquette
2.6. Ajoutez le module LCD et paramétrez-le (comme déjà vu au niveau du TP 3)
L’afficheur LCD est relié au port 1 du PSoC. Il ne faut pas oublier sa LED de rétroéclairage
reliée à la broche 2.4
Figure 55 : Paramétrage de l'afficheur LCD
- 48 -
2.7. Réalisez un programme qui permet de lire la valeur envoyée par le potentiomètre et de
En se référant à la datasheet du DELSIG11, nous aurons besoin des fonctions suivantes :
- DELSIG11_Start(DELSIG11_HIGHPOWER) : initialiser le module et définir le niveau de
puissance qui lui sera alloué (dans notre cas c’est la puissance maximale autorisée)
- DELSIG11_StartAD() : activer et initialiser le temporisateur du convertisseur
- DELSIG11_fIsDataAvailable() : vérifier la disponibilité d’une donnée valide
- DELSIG11_iGetData() : retourner la donnée convertie, après avoir vérifier sa disponibilité.
La valeur sera stockée dans la variable globale DELSIG11_iResult (à condition d’activer
l’option Polling)
- DELSIG11_ClearFlag() : remettre à zéro le drapeau de présence d’une donnée valide avant
de passer à la conversion suivante
#include <m8c.h>
#include "stdlib.h"
void main(void)
{
float v;
char *tmp;
int stat;
extern int DELSIG11_iResult;
LCD_1_Start();
DELSIG11_Start(DELSIG11_HIGHPOWER);
DELSIG11_StartAD();
M8C_EnableGInt;
LED_Start();
LED_Switch(1);
while(1)
{
while(DELSIG11_fIsDataAvailable() == 0);
LCD_1_Position(0,1);
LCD_1_PrCString("Volt");
DELSIG11_iGetData();
v=(((DELSIG11_iResult+1024)*5.0)/2048.0);
tmp=ftoa(v,&stat);
LCD_1_PrString(tmp);
DELSIG11_ClearFlag();
}
}
Remarque :
- Pour afficher une information sur l’afficheur LCD, elle doit être de type caractère. C’est
pour cette raison qu’il faut convertir la tension calculée (variable v dans notre
programme) en une chaine de caractère à l’aide de la fonction « ftoa ». pour utiliser cette
fonction, il faut ajouter la bibliothèque « stdlib.h » à l’entête de notre programme
- 49 -
fonctionnement.
Figure 56: Affichage sur LCD
2.9. Modifiez votre programme pour qu’il n’affiche que deux chiffres après la virgule.
Pour fixer le nombre de chiffres après la virgule, il suffit d’ajouter le caractère fin de chaine
« \0 » à la position souhaitée. Dans notre cas, si nous voulons deux chiffres après la virgule,
nous insérons le caractère de fin de chaine à la 4 ème position juste avant de l’afficher sur
l’afficheur :
…
tmp=ftoa(v,&stat);
tmp[4]='\0' ;
}
}
fonctionnement.
Figure 57: Formatage de l'affichage de la tension
- 50 -
TP : 4
Commande d’un Buzzer
- Configurer le module PWM
- Commander un Buzzer
- Générer des tonalités différentes
Volume horaire
6 heures.
Le but de ce TP est la commande d’un Buzzer en exploitant le module PWM du PSoC.
La fréquence du signal sonore émis par le Buzzer est relative au signal appliqué. Cette fréquence
est généralement comprise entre 2 kHz et 4 kHz. Selon la fréquence appliquée, le Buzzer peut
générer des bips graves, aigus, plus graves ou plus aigus.
Pour les modules numériques (comme le module PWM) on relie les sorties à des colonnes sur
lesquelles pourront se connecter les sorties.
Avec :
- GOO : Global Output Odd : ODD = IMPAIR : C'est ici que l'on pourra connecter une broche
de port impair comme P1.2 par exemple.
- GOE : Global Output Even : EVEN : PAIR : C'est ici que l'on pourra connecter une broche
de port pair comme P2.5 par exemple.
Le Buzzer présent sur la carte est connecté à travers le Jumper W4 au pin p2.5 du PSoc.
Figure 58 : Bloc Buzzer et pin de branchement
2. Manipulation :
2.1.Activité 1 :
A travers cette activité, nous allons essayer de commander le Buzzer et changer les tonalités des
bips émis en jouant sur les différents paramètres du module PWM.
2.1.1. Ajoutez le module PWM16 qui se trouve sous User Modules\PMWs
2.1.2. Combien de blocs occupe le module PWM16 ? de quel type sont les blocs ?
2.1.3. Reliez la sortie « CompareOut » du module PWM16 au pinout 2.5
2.1.4. Configurez le module PWM16 et indiquez les valeurs des paramètres suivants :
 Clock
 Enable
 CompareOut
 Period
 PulseWidh
2.1.5. Créez un programme qui permet de générer un bip continu au niveau du Buzzer
- 52 -
2.2.Activité 2 :
Le but de cette activité est de créer un piano où chaque touche du clavier émettra une tonalité
différente en jouant sur les valeurs des paramètres du module PWM16 (Period et Pulsewidh).
2.2.1. Modifiez votre programme pour réaliser le piano (n’oubliez pas de configurer les
entrées du clavier)
2.2.2. Transférez votre programme et vérifiez son bon fonctionnement
2.3.Activité 3 :
Reprenez le code du TP « conversion analogique numérique ». Le programme que vous avez
réalisé permettait d’afficher la valeur analogique lue par le PSoC sur l’afficheur LCD. Cette tension
est comprise entre les valeurs 0v et 5v. Modifiez votre programme en choisissant une valeur seuil
qui, une fois la tension l’attendra, permettra de déclencher le Buzzer.
- 53 -
Commande d’un Buzzer : correction
Activité 1 :
2.1.1. Ajoutez le module PWM16 qui se trouve sous User Modules\PMWs
Figure 59 : Ajout du module PWM16
2.1.2. Combien de blocs occupe le module PWM16 ? de quel type sont les blocs ?
2.1.3. Le module utilise de deux blocs numériques
Figure 60 : Blocs du module PWM16
2.1.4. Reliez la sortie « CompareOut » du module PWM16 au pinout 2.5
Figure 61 : Etapes de câblage de la sortie du PWM16
- 54 -
Le résultat final de la connexion est illustré dans la figure qui suit :
Figure 62 : la sortie "CompareOut" reliée au pinout 2.5
2.1.5. Configurez le module PWM16 et indiquez les valeurs des paramètres suivants :
 Clock : VC1
 Enable : High
 CompareOut : Row_0_Output_1 (ce champ est rempli automatiquement si la
connexion a été réalisée correctement au niveau de la question précédente)
 Period : on peut mettre n’importe qu’elle valeur entre 0 et 2 16-1 (cette valeur
peut être changée par programmation)
 PulseWidh : on peut mettre n’importe qu’elle valeur entre 0 et Period (cette
valeur peut être changée par programmation)
2.1.6. Créez un programme qui permet de générer un bip continu au niveau du Buzzer
Pour générer un bip, il faut fixer les valeurs de la période et de la largeur d’impulsion en
utilisant les commandes « PWM16_WritePeriod () » et « PWM16_WritePulseWidth () ». Nous
choisirons un rapport cyclique de 33%.
Pour modifier le son émis par le Buzzer, il suffit de jouer sur la valeur du rapport cyclique.
#include <m8c.h>
#include "PWM16.h"
#define PWM_PERIOD 999
#define PWM_PULSEWIDTH 333
void main(void)
{
PWM16_WritePeriod(PWM_PERIOD);
PWM16_WritePulseWidth(PWM_PULSEWIDTH); // largeur d’impulsion générée à 33%
PWM16_Start();
}
- 55 -
Activité 2 :
Le but de cette activité est de créer un piano où chaque touche du clavier émettra une tonalité
différente en jouant sur les valeurs des paramètres du module PWM16 (Period et Pulsewidh).
2.2.1. Modifiez votre programme pour réaliser le piano (n’oubliez pas de configurer les
entrées du clavier)
#include <m8c.h>
#include "PWM16.h"
char key_result[2] = {0, 0};
char keypad_scan(void)
{
PRT4DR = 0xF0;
rows = PRT4DR;
PRT4DR = 0x0F;
cols = PRT4DR;
return (rows & cols);
}
void bouton1_tone(void)
{
PWM16_WritePeriod(45866);
PWM16_WritePulseWidth(22933);
PWM16_Start();
}
{
PWM16_Start();
}
{
PWM16_Start();
}
{
PWM16_Start();
}
{
PWM16_Start();
}
{
PWM16_Start();
}
- 56 -
{
PWM16_Start();
}
{
PWM16_Start();
}
void main(void)
{ while(1)
{ key_result[0] = keypad_scan();
switch (key_result[0])
{ case 0x18:
bouton1_tone();
break;
case 0x14:
bouton2_tone();
break;
case 0x12:
bouton3_tone();
break;
case 0x11:
bouton4_tone();
break;
case 0x28:
bouton5_tone();
break;
I) Transférez
case 0x24:votre programme et vérifiez son bon fonctionnement
bouton6_tone();
Activité 3 break;
:
Reprenez le codecasedu0x22:
TP « conversion analogique numérique ». Le programme que vous avez réalisé
bouton7_tone();
permettait d’afficher la valeur analogique lue par le PSoc sur l’afficheur LCD. Cette tension est
break;
comprise entre les valeurs 0v et 5v. Modifiez votre programme en choisissant une valeur seuil qui,
case 0x21:
une fois la tensionbouton8_tone();
l’atteindra, permettra de déclencher le Buzzer.
1. Transférez votre programme et vérifiez son bon fonctionnement.
break;
default:
break;
}
}
}
- 57 -
Activité 3 :
#include <m8c.h>
#include "PWM16.h"
#include "stdlib.h"
void delayms(int delay)
{
int i,j;
for(i=0;i<delay;i++)
for(j=0;j<65;j++)
continue;
}
void main(void)
{
float v;
char *tmp;
int stat;
extern int DELSIG11_iResult;
LCD_1_Start();
DELSIG11_Start(DELSIG11_HIGHPOWER);
DELSIG11_StartAD();
M8C_EnableGInt;
LED_Start();
LED_Switch(1);
while(1)
{
while(DELSIG11_fIsDataAvailable() == 0);
LCD_1_PrCString("Tension en volt:");
DELSIG11_iGetData();
v=(((DELSIG11_iResult+1024)*5.0)/2048.0);
tmp=ftoa(v,&stat);
//delayms(100);
tmp[4]='\0';
if (v >= 4.0)
{
PWM16_Start();
}
else PWM16_Stop();
}
}
- 58 -
TP : 5
Capteur de température numérique : DS18S20
- Configurer le module OneWire.
- Faire l’acquisition de la température du capteur.
- Afficher le résultat sur un afficheur LCD.
Volume horaire
6 heures.
1.1.Présentation de l’interface de communication OneWire :

Le capteur DS18S20 est un thermomètre numérique qui utilise l’interface de communication
OneWire. Cette interface nécessite seulement une broche de port du PSoC pour communiquer.
Un maître OneWire peut communiquer avec un ou plusieurs dispositifs esclaves en utilisant un
seul fil de signal et une masse. Le maître initie tous les transferts de données.
Figure 63 : Interface de communication OneWire
1.2.Présentation du capteur DS18S20 :
Chaque capteur possède un numéro de série unique sur 64 bits gravé en ROM et ne nécessite
aucun composant supplémentaire pour communiquer. Il peut être alimenté par la ligne de données
et possède une plage d’alimentation de 3 à 5,5V. Son étendue de mesure de températures varie
de –55°C à +125°C avec une précision de +/- 0,5 °C sur la plage –10°C à +85°C.
Ce thermomètre a une résolution de 9 bits et un temps de conversion maximal de 0,75 s.
La fonctionnalité essentielle du DS18S20 est de fournir directement une valeur numérique de la
température. Le capteur de température possède une résolution de 9 bits ce qui correspond à des
pas de 0,5°C.
Le DS18S20 démarre à sa mise sous tension par un état de veille (idle) en basse consommation
est la valeur du registre température est fixée à +85,0°C soit un code sur 16 bits de 00AA en
hexadécimal [00AAh].
Comme tout module OneWire, le DS18B20 contient un « scratchpad » qui est une sorte de
mémoire tampon sécurisée ou l’on peut venir lire et/ou écrire. La figure qui suit présente la
structure du scratchpad du DS18S20 :
- 60 -
Figure 64: Scatchpad du DS18S20
Pour initier une mesure de température et une conversion analogique numérique, le maître du
bus doit générer une commande CONVERT T de code hexadécimal 44 [44h]. Suivant la conversion,
la donnée du résultat thermique est stockée dans le registre de température de taille 2 octets de
la mémoire scratchpad, puis le DS18S20 retourne dans son état de veille.
Si le DS18S20 est alimenté par une alimentation externe connectée sur sa broche VDD, le maître
du bus peut générer un « read-time slots » après la commande CONVERT T et le DS18S20 répondra
en transmettant des Niveaux Logiques (NL) 0 sur le bus tant que la conversion de température
sera en cours, puis un (NL) 1 lorsque la conversion sera terminée.
La donnée de sortie du DS18S20 est calibrée en demi-degrés centigrades. Cette donnée de
température est stockée dans le registre de température sous la forme d’un nombre en
complément à deux au format 16 bits. Les bits de signe S indiquent si la température est positive
(S= NL0) ou bien négative (S=NL1).
Figure 65 : Format du registre température
Le tableau suivant illustre la relation entre la température acquise et la donnée numérique :

Tableau 5: Correspondance température/donnée numérique
- 61 -
2. Manipulation :
Le but de cette manipulation est de faire l’acquisition de la température délivrée par le
thermomètre numérique et de l’afficher sur un afficheur LCD :
2.1. Ajoutez le module OneWire qui se trouve sous Users Modules\Digital Comm
2.2. Combien de modules utilisateurs nécessite l’interface de communication ? de quels types
sont les modules ?
2.3. Reliez l’entrée et la sortie du module OneWire en se référant au document à
l’emplacement « C:\PSoc\Documentation\CT PSoc-DEV01\Schematique » pour connaitre
les pins de câblage.
- Au niveau des paramètres de OneWire
o Clock
o ClockSync
2.5. En se référant à la datasheet du module OneWire et par rapport à ce qui a été expliqué
plus haut, donnez la formule qui permet de calculer la valeur de la température lue par le
microcontrôleur.
2.6. Ajoutez le module LCD et paramétrez-le.
2.7. Réalisez un programme qui permet de lire la valeur envoyée par le thermomètre et de
l’afficher sur l’afficheur LCD.
fonctionnement.
- 62 -
Capteur de température numérique :
DS18S20 : correction
2.1. Ajoutez le module OneWire qui se trouve sous Users Modules\Digital Comm
Figure 66 : Ajout du module OneWire

sont les modules ?
Le module OneWire utilise deux blocs numériques
les pins de câblage :
D’après la documentation fournie, nous remarquons que le capteur est relié au pin 2.6,
or le module OneWire possède une entrée RX et une sortie TX. Comme les pins 2.6 et
2.7 sont reliées (rôle des jumpers présents sur la maquette) nous allons brancher RX à
2.6 et TX à 2.7.
Figure 67 : Câblage du module OneWire

- Au niveau des paramètres de OneWire
- 63 -
o Clock : d’après la datasheet du module OneWire, l’horloge doit avoir la valeur exacte
de 3 Mhz. Donc pour le choix de ce paramètre, il faut faire un petit calcul. Nous
allons choisir la configuration suivante :
 CPU_Clock = 24 Mhz
 VC1 = SysClk/N = 2 (donc VC1 = 12 Mhz)
 VC2 = VC1/N = 4 (donc VC2 = 3Mhz)
Donc d’après cette configuration, le paramètre Clock sera égal à VC2
Figure 68 : Fréquence d'horloge du module OneWire
o ClockSync : d’après la datasheet, puisque nous avons choisi une fréquence SysClk
égale à 24 Mhz, alors ce paramètre doit être fixé à « Sync to SysClk »
2.5. En se référant à la datasheet du module OneWire et par rapport à ce qui a été expliqué
plus haut, donnez la formule qui permet de calculer la valeur de la température lue par le
microcontrôleur :
D’après ce qui a été expliqué plus haut, la valeur de la température est stockée sur les
deux premiers octets du « scratchpad » (voir Figure 64). En se référant au tableau de
correspondance (voir Tableau 4) nous remarquons que la température est codée sur deux
octets sous la forme d’un entier signé. En plus comme la précision est de 0.5 degré, la
valeur lue est le double de la valeur réelle (donc il faut penser à diviser la valeur lue par
2). Finalement la formule qui permet de récupérer la température est la suivante :
Température = (Octet0 du Scratchpad + Octet1 du Scratchpad décalé à gauche de 8 bits) / 2
Remarque :
- La variable température doit être déclarée comme étant un entier signé
- L’opérateur « + » sera un « OU » logique à l’aide du symbole « | » et le décalage à gauche
à l’aide du symbole « << »
2.6. Ajoutez le module LCD et paramétrez-le
Pour réaliser notre programme, nous devons nous référer à la documentation du module
OneWire et à celle du capteur DS18S20. D’après la datasheet du capteur, l’acquisition de
température se fait en 3 étapes qui sont :
- L’initialisation : OneWire_Start() : cette fonction permet d’initialiser le module OneWire
- 64 -
- Commandes ROM : OneWire_WriteByte(0xCC) : cette fonction permet au maître de s’adresser
à tous les esclaves simultanément. Dans notre cas, nous avons un seul esclave (le capteur
DS18S20)
- Commandes du capteur : OneWire_WriteByte(0x44) : cette fonction permet de démarrer la
conversion au niveau du capteur ; cependant avant de pouvoir lire le résultat de la
conversion à l’aide de la fonction OneWire_WriteByte(0xBE), il faut attendre au moins 750 ms
qui correspond au temps de conversion. Une fois le temps de conversion écoulé, nous
pouvons lire le contenue du Scratchpad (Octet0 et Octet1) à l’aide de la fonction
OneWire_bReadByte().
#include <m8c.h>
#include "stdlib.h"
void main(void)
{
char *tmp;
int stat;
signed int temp=0;
M8C_EnableGInt ;
OneWire_1_Start();
OneWire_1_WriteByte(0xCC);
OneWire_1_WriteByte(0x44);
while(!OneWire_1_bReadBit ());
OneWire_1_fReset();
OneWire_1_WriteByte(0xBE);
temp = OneWire_1_bReadByte();
temp |= OneWire_1_bReadByte()<<8;
OneWire_1_fReset();
LED_Start();
LED_Switch(1);
LCD_Start();
LCD_Position(0,0);
LCD_PrCString("Temperature:");
LCD_Position(1,0);
for (;;)
{
OneWire_1_fReset();
OneWire_1_fReset();
tmp=ftoa ((temp/2.0)-4,&stat);
LCD_Position(1,0);
LCD_PrString(tmp);
LCD_WriteData(223);
LCD_PrCString("C");
}
}
- 65 -
fonctionnement.
Figure 69: Affichage de la température
- 66 -
TP : 6
La communication série : UART
- Configurer le module UART.
- Faire l’acquisition de la température du capteur DS18S20.
- Envoyer le résultat au PC en utilisation une communication série.
Volume horaire
6 heures.
L’UART (Universal Asynchronous Receiver / Transmitter) est un protocole de communication série
standard pour l'échange de données entre deux appareils. Dans ce protocole de communication,
les données sont transférées de manière séquentielle, un bit à la fois. Ce mode de réalisation
utilise une trame composée de 8 bits de données, un bit de départ, un bit de parité en option, et
un ou plusieurs bits d'arrêt. Le bit de parité est un bit avec une valeur de 0 ou 1, qui est ajouté à
un bloc de données à des fins de détection d'erreurs.
Étant donné que le protocole UART est asynchrone, il n'a pas besoin d'un signal d'horloge. En
communication UART, la vitesse est définie par la vitesse de transmission. La vitesse de
transmission est égal au nombre de bits transmis par seconde, y compris les bits de démarrage
et d'arrêt. Pour une transmission fiable de données et la réception sans perte de bits, l’émetteur
et le récepteur doivent avoir la même vitesse de transmission. Une incompatibilité des taux de
transmission se traduit généralement par des erreurs. Les vitesses de transmission communes
sont 4800, 9600, 19200, 38400, 57600 et 115200, mais d'autres vitesses peuvent également
être utilisées.
2. Manipulation :
Le but de cette manipulation est de faire l’acquisition de la température délivrée par le
thermomètre numérique DS18S20, de l’envoyer à l’ordinateur via une connexion série et de
l’afficher sur le moniteur série (HyperTerminal)
2.1. Ajoutez le module UART qui se trouve sous Users Modules\Digital Comm
sont les modules ?
2.3. Reliez l’entrée et la sortie du module UART en se référant au document à
l’emplacement « C:\ PSoc\ Documentation\ CT PSoc-DEV01 \Schematique » pour
connaitre les pins de câblage.
2.4. Paramétrez le module UART en fixant les valeurs des champs suivants :
o Clock
o TX Interrupt Mode
o ClockSync
l’afficher sur l’HyperTerminal du PC
2.6. Compilez votre programme et transférez le vers la maquette. Ajouter la connexion série
entre la maquette et le PC et vérifiez son bon fonctionnement.
- 68 -
La communication série : UART: correction
2.1. Ajoutez le module UART qui se trouve sous Users Modules\Digital Comm
Figure 70 : Ajout du module UART

sont les modules ?
Le module UART occupe deux blocs de types numériques (UART RX et UART TX)
les pins de câblage.
D’après la documentation fournie, le module UART possède une entrée RX reliée au pin
5.3 et une sortie TX reliée au pin 5.2.
Figure 71 : Câblage du module UART
- 69 -
2.4. Paramétrez le module UART en fixant les valeurs des champs suivants :
o Clock : d’après la datasheet du module UART, l’horloge doit être obligatoirement
huit fois la vitesse de transmission choisie (un bit de donné est envoyé ou reçu tous
les huit cycles d’horloge). Si nous choisissons une vitesse de transmission de l’ordre
de 9600 baud alors l’horloge serait égale à 76.8 Khz. Si la fréquence du CPU est
24 Mhz, nous aurons besoin d’un diviseur de 312.5 (24Mhz/76.8Khz). Comme les
diviseurs sont des entiers, nous choisissons arbitrairement 312 ou 313. Pour ce
faire, nous pouvons choisir la configuration suivante :
SysClk = 24 MHz, VC1 divider = 2, VC3 source = VC1, and VC3 divider = 156
Donc l’horloge du module sera VC3
Figure 72 : Horloge du module UART
o TX Interrupt Mode : ce paramètre détermine le moment de générer une interruption

pour le bloc « UART TX ». Pour maximiser les sorties de l’émetteur, nous choisissons
la valeur TXRegEmpty (l’interruption est générée dès que les données sont
transférées à partir du registre des données pour le registre à décalage)
o ClockSync : Sync to SysClk
l’afficher sur l’HyperTerminal du PC
Nous allons exploiter le programme déjà réalisé lors du précédent TP qui permettait de
lire la température et de l’afficher sur l’afficheur LCD en envoyant cette même information
à travers l’interface de communication série à l’aide des commandes UART :
- 70 -
#include <m8c.h>
#include "stdlib.h"
void main(void)
{
char *tmp;
int stat;
signed int temp=0;
UART_CmdReset();
UART_IntCntl(UART_ENABLE_RX_INT);
UART_Start(UART_PARITY_NONE);
M8C_EnableGInt ;
OneWire_1_Start();
OneWire_1_fReset();
OneWire_1_fReset();
LED_Start();
LED_Switch(1);
LCD_Start();
LCD_Position(0,0);
for (;;)
{
OneWire_1_fReset();
OneWire_1_fReset();
tmp=ftoa ((temp/2.0)-4,&stat);
UART_PutString(tmp);
UART_PutCRLF();
LCD_Start();
LCD_PrString(tmp);
}
}
- 71 -
2.6. Compilez votre programme et transférez le vers la maquette. Ajouter la connexion série
entre la maquette et le PC et vérifiez son bon fonctionnement.
Figure 73: Etapes d'affichage sur l’HyperTerminal
- 72 -
Bibliographie
[1] Corail Technologie, «Prise en main de PSoC Designer 5.1», Février 2012.
[2] Corail Technologie, Tutorial : « Première application pour CT PSoC-DEV01 », Février 2012.
Webographie
[3] http://www.cypress.com , 7-Segment LED Controller Datasheet, Cypress Semiconductor
Corporation
[4] http://www.cypress.com , PSoC® Designer™ Quick Start Guide, Cypress Semiconductor
Corporation
[5] http://sti2d.patgue.com , Les microcontrôleurs PSoC, Patrick Guérangé
[6] http://www.louisreynier.com/ , Débuter avec PSoC, Louis REYNIER
[7] http://nalhossri.free.fr , Afficheur LCD 2x16 alphanumérique, Nabil Al-HOSSRI
- 73 -
Annexes
- 74 -
Annexe : Schématique de CT PSoC-DEV01 (1/5)
- 75 -
Schématique de CT PSoC-DEV01 (2/5)
- 76 -
- 77 -
- 78 -
- 79 -

Atelier Electronique Embarquee3 PSoC1-psoc-designer

Transféré par

Informations du document

Titre original

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

Atelier Electronique Embarquee3 PSoC1-psoc-designer

Transféré par

Droits d'auteur :

Formats disponibles

Ministère de l’Enseignement Supérieur et

Fascicule de Travaux Pratiques

0 2016 MHAYA Slah

Cet atelier vise à Mettre en œuvre des applications à base de PSoc

Classe : 3ème année

Licence : Génie Electrique

Figure 1 : PSoC (Programmable System on Chip) ................................................................................. 1

Tableau 1: Récapitulatif des différentes caractéristiques........................................................................ 4

-Travaux pratique N°0 :

Débuter avec PSoC

-Travaux pratique N°1 :

-Travaux pratique N°2 :

Gestion de l’écran LCD et l’Afficheur 7 segments

-Travaux pratique N°3 :

-Travaux pratique N°4 :

Commande d’un Buzzer

-Travaux pratique N°5 :

Capteur de température numérique : DS18S20

-Travaux pratique N°6 :

La communication série : UART

Le but de ce TP est de se familiariser avec les circuits PSoC et leur environnement,

Figure 1 : PSoC (Programmable System on Chip)

La famille PSoC est constituée des références CY8C21x34, CY8C24x23A, CY8C26xxx,

Figure 2 : Architecture interne d’un PSoC

Il présente également des blocs logiques et analogiques banalisés configurables :

Figure 3: Présentation du kit

1.3.Manuel d’utilisation de la CT PSOC-DEV01

La carte de développement CT PSoC-DEV01 permet d’utiliser un grand nombre de PSoC, elle

Figure 4: Schéma synoptique

Figure 5: Photo réel de la CT PSOC-DEV01

1.3.1. Bloc MCU

La carte de développement CT PSoC-DEV01 contient un bloc MCU comme l’indique la figure

Figure 6: Bloc MCU

CY8C21123 CY8C21223 CY8C21234 CY8C21323 CY8C21334 CY8C21434

1.3.2. Bloc d’alimentation

La carte de développement CT PSoC-DEV01 peut être alimentée par deux sources de

Figure 7: Bloc d’alimentation

La carte CT PSoC-DEV01 contient un bloc de 8 LED connectées à travers d’un Jumper W2

Figure 9: Bloc de 8 LED

1.3.5. Bloc Clavier

La carte CT PSoC-DEV01 contient un clavier (4 lignes x 4 colonnes) connecté directement

Figure 10 : Bloc Clavier

1.3.6. Bloc d’affichage

Figure 11: Blocs LCD & Contraste

Figure 12: Bloc afficheur 7 segments

1.3.7. Bloc ADC

Figure 13: Bloc ADC

Figure 14: Bloc Buzzer

Un Buzzer est un élément électromécanique ou piézoélectrique qui produit un son

1.3.9. Capteur DS1820

Figure 15: Bloc thermomètre

1.3.10. Bloc de communication série (RS232)

Figure 16: Bloc RS232

2. Programmation de la carte CT PSoC--DEV01

Figure 17: PSOC MINIProg et câble USB

Le PSOC MINIProg se connecte à la carte CT PSoC-DEV01 par le biais du connecteur ISSP et

3. Prise en main avec PSoC-DESIGNER 5.1

Figure 18: Outils de développement PSoC

Figure 19 : Interface du logiciel PsoC Designer

Figure 20: LED1 choisie

Figure 21: Etapes de développement d’une application PSoC

4.1.1. Après l’installation du PSoC Designer, lancez le programme et créez un nouveau

Figure 22: Etapes de création d'un nouveau projet

Etape3 : cliquez sur le bouton de programmation (encadrer en bleu)

Etape1 : Cliquez P4 [0] Drive et sélectionnez Pull Down