Rapport de Stage Licence Professionnelle Communication PC-PIC · Rapport de Stage Licence Professionnelle Communication PC-PIC ... II.2) Les différentes familles de PIC Exemple de

Institut universitaire Mulhouse CNRS

Département GEII LMSPC

IUT de Mulhouse Bureau de P.Bernhardt

61 rue Albert Camus 25 Rue Becquerel 68093 MULHOUSE cedex 67087 Strasbourg Cedex 2

Rapport de Stage Licence Professionnelle

Communication PC-PIC

Stage du 19/03/12 au 22/06/12

Année universitaire 2011/2012

Tuteur Enseignant : Olivier Haeberle

Damien Madonna

Tuteur Entreprise : Pierre Bernhardt

Sommaire

Les remerciements

Introduction……………………………………………………………………………………………………………………p1

I) Le CNRS de Strasbourg…………………………………………………………………………………..p2

II) Le microcontrôleur………………………………………………………………………………………..p3

II.1) Le plan mémoire des microcontrôleurs…………………………………………………………………….p4

II.2) Les différentes familles de PIC………………………………………………………………………………….p5

III) Présentation du Pic 18F4550............................................................................p6

III.1)La carte pour le pic 18F4550…………………………………………………………………………………….p7

IV) Matériel Informatique……………………………………………………………………………………p8

IV.1) Les logiciels et le PICKit3…………………………………………………………………………………………p8

IV.2) Logiciel Microsoft Visual Studio 2010……………………………………………………………….……p8

IV.3) Logiciel MPLAB……………………………………………………………………………………………………….p9

IV.4) Le PICKit3……………………………………………………………………………………………………………….p9

V) Organigramme du programme……………………………………………………………………..p10

VI) Explications détaillées sur le programme : La tête du programme……………….p11

VI.1) Les fichiers « include ».………………………………………………………………………………………..p11

VI.2) Les définitions……………………………………………………………………………………………………….p11

VI.3) Les pragma config………………………………………………………………………………………………….p12

VI.4) Les procédures pour void………………………………………………………………………………………p12

VI.5) Les déclarations de variables…………………………………………………………………………………p12

VI.6) Les niveaux d’interruption…………………………………………………………………………………….p13

VII) Explications détaillées sur le programme : Partie communication……………….p15

VIII) Explications détaillées sur le programme : Partie affichage sur écran LCD……p16

IX) Explications détaillées sur le programme : Partie comptage…………………………p17

IX.1) Les Timers……………………………………………………………………………………………………………..p17

IX.2) Le Timer 0 en compteur de temps………………………………………………………………………….p17

IX.3) Le Timer 1 en compteur d’impulsions extérieures..……………………………………………….p18

IX.4) Explication partie comptage…......………………………………………………………………………….p19

X) Explications détaillées sur le programme : Partie Conversion…………………….p20

X.1) ADC………………………………………………………………………………………………………………………..p20

X.2) Explications partie conversion………………………………………………………………………………..p20

XI) L’affichage……………………………………………………………………………………………………p21

XI.1) La fenêtre d’affichage……………………………………………………………………………………………p21

XII) La programmation du logiciel………………………………………………………………………p22

XII.1) Le paramétrage de la communication…………………………………………………………………..p22

XII.2) Explications sur un bouton……………………………………………………………………………………p22

XIII) Bilan et perspectives…………………………………………………………………………………….p24

XIV) Conclusion……………………………………………………………………………………………………p25

XV) Lexique………………………………………………………………………………………………………..p26

XVI) Listing et webographie…………………………………………………………………………………p27

XVI.1) Listing « Figure »…………………………………………………………………………………………………p27

XVI.2)Webographie…………………………………………………………………………………………………….…p27

XVII) Le résumé en Anglais…………………………….…………………………………………………….p28

XVIII) Les annexes…………………………………………………………………………………………………p29

XVIII.1) Structure du PIC……………………………………………………………………………………………….p29

XVIII.2) La tête du programme……………………………………………………………………………………..p30

XVIII.3) La communication……………………………………………………………………………………………p31

XVIII.4) L’affichage……………………………………………………………………………………………………....p32

XVIII.5) Le comptage et la conversion………………………………………………………………………..…p32

XVIII.6) Une partie de la programmation du logiciel…………….……………………………………..p34

Les remerciements

Je remercie l’ensemble de l’équipe du LMSPC pour m’avoir accepté parmi eux

pendant ces trois mois.

Je remercie Stéphane Le Calve et Pierre Bernhardt pour m’avoir suivi pendant

mon stage.

Je remercie Olivier Haeberle pour avoir été mon enseignant tuteur.

Je remercie l’ensemble des professeurs de la licence professionnelle pour leurs

enseignements durant cette année scolaire.

Je remercie particulièrement monsieur XU qui m’a fait parvenir l’annonce du

stage.

1

Introduction

Je m’appelle Damien MADONNA, je suis étudiant en Licence Professionnelle en Automatique et

Informatique Industrielle. Après de nombreuses lettres envoyées, j’ai eu la chance de trouver un

stage en toute dernière minute. Il s’agit du CNRS de Strasbourg qui à accepté ma candidature. Plus

particulièrement le Laboratoire des Matériaux, Surfaces et Procédés pour la Catalyse.

Le but de mon stage est de communiquer entre un PIC et un PC afin de pouvoir faire réaliser

plusieurs tâches au PIC. Pour que mon tuteur Pierre Bernhardt puisse le réutiliser pour l’analyseur de

formaldéhyde, qui est un appareil qui mesure la pureté de l’air.

Pour la rédaction de ce rapport, j’ai choisi d’abord, de présenter l’entreprise dans laquelle j’ai

effectué mon stage, ensuite, de parler des microcontrôleurs en général, de parler des différents

matériaux que j’ai utilisés, de rentrer dans les explications sur les différents programmes que j’ai

créés, et, pour finir ce rapport, j’ai écrit un bilan et une conclusion.

2

I) Le CNRS de Strasbourg

Le Centre National de la Recherche Scientifique est un organisme public de recherche.

Il est placé sous la tutelle du Ministère de l’Enseignement supérieur de la Recherche.

En France, le CNRS c’est plus de 34000 personnes avec 11450 chercheurs et 14180 ingénieurs,

techniciens et administratifs.

En 2012 le budget du CNRS s’est estimé à une valeur de 3.3 milliards d’euros.

Parmi tous les chercheurs qui sont passés au CNRS, il y a eu 17 lauréats du prix Nobel et 11 de la

Médaille Fields.

Le CNRS est présent dans tous les champs de connaissance :

• Institut des sciences biologiques (INSB)

• Institut de chimie (INC)

• Institut écologie et environnement (INEE)

• Institut des sciences humaines et sociales (INSHS)

• Institut des sciences de l'information et de leurs interactions (INS2I)

• Institut des sciences de l’ingénierie et des systèmes (INSIS)

• Institut national des sciences mathématiques et de leurs interactions (INSMI) Métivier

• Institut de physique (INP)

• Institut national de physique nucléaire et physique des particules (IN2P3) Martino

• Institut national des sciences de l’univers (INSU)

Mon stage a eu lieu au LMSPC de Strasbourg, qui est sous la tutelle de l’INC.

Le LMSPC est un laboratoire de recherche qui a été crée en 1988 et dont les axes de recherches sont

autour de la catalyse pour l’énergie, la dépollution et l’environnement.

Figure 1 : Logo CNRS et LMSPC

3

II) Le microcontrôleur

Un microcontrôleur est un composant électronique qui comprend :

• Une CPU

• De la RAM

• Une mémoire de programme : EEPROM ou ROM par exemple

• Des Entrées/ Sortie TOR

• Des liaisons séries

• Un CAN

• Des TIMERS

• Etc..

Figure 2 : Image microcontrôleurs

Les microcontrôleurs sont de plus en plus utilisés dans les systèmes embarqués comme :

Les télécommandes, l’électroménager, les jouets, les téléphones mobiles.

Une liste des fabricants de microcontrôleurs :

• Analog Devices ADuC

• Atmel AT91, AVR

• Comfile Technology PICBASIC

• Cypress PSoC

• Freescale 68HC08, 68HC11, 68HC12

• Hitachi H8

• Intel 8051, 8085

• Microchip PIC, dsPIC

• NEC V800, K0

• Philips LPC21xx ARM7-TDMI

• Siemens/Infineon C167

• STMicroelectronics ST6, ST7, STM8, ST10, STR7, STR9, STM32

• Texas Instruments MSP430

Pour ma part j’utilise un PIC 18F4550 de Microchip.

4

II.1) Le plan mémoire des microcontrôleurs

Pour les microcontrôleurs, il existe deux types de plan mémoire :

• Architecture de type Von Neumann

• Architecture de type Harvard

L’architecture, dite de Von Neumann, est une architecture ou le même plan mémoire contient à la

fois le programme et les données, c'est-à-dire qu’il utilise une structure de stockage unique pour

conserver à la fois les instructions et les données.

L’architecture, dite de Harvard, est une architecture ou il y à deux plans mémoires différents. Le

premier contient le programme, et le deuxième contient les données. L’accès à chacune des deux

mémoires s’effectue via deux bus distincts.

Figure 3 : Architecture Neumann et Harvard

Le microcontrôleur PIC 18F4550 possède un plan mémoire de type Harvard.

5

II.2) Les différentes familles de PIC

Exemple de PICS : 18F4550, 16F877

Les PICS sont classés selon leurs critères : microcontrôleur 8 bits, 16bits et 32 bits.

� Dans la classe 8 bits, il y a les PIC de types « 10, 12, 14, 16 et 18 ».

� Dans la classe 16 bits, il y a les PIC de types « 24, 30 et 33 ».

� Dans la classe 32 bits, il y a le PIC de type « 32 ».

On peut encore décomposer la classe 8 bits comme cela :

• Les PICS de types « 10 et 12 » sont considérés comme « Base-Line ou Bas de gamme ». Ils

utilisent des mots d’instructions de 12 bits.

• Les PICS de types « 14 et 16 » sont considérés comme « Mid-Range ou Milieu de gamme ».

Ils utilisent des mots d’instructions de 14 bits.

• Le PIC de type « 18 » est considéré comme « High-End ou Haut de gamme ». Il utilise des

mots d’instructions de 16 bits.

« Un mot d'instruction d'une largeur de 16 bits, correspond au nombre de bits qui sont nécessaires

pour coder une instruction de programme dans le PIC ».

Ensuite il y à les lettres :

• "C" indique que la mémoire programme est une EPROM, elle peut être effacée (suivant le

cas) par ultraviolet.

• "CR" pour indiquer une mémoire de type ROM, qui n'est pas effaçable. Un composant qu’on

ne peut pas reprogrammer est aussi appelé O.T.P. pour One Time Programming.

• "F" pour indiquer une mémoire de type FLASH, reprogrammable électriquement, via un

programmateur (PICSTART, PICKIT, ICD, REAL ICE...).

Derrière la lettre, il y a la référence du PICS :

Par exemple 4550 et 877.

6

III) Présentation du Pic 18F4550 :

Figure 4 : Pic 18F4550

Comme on peut le remarquer : le Pic 18F4550 est composé de 40 broches. Ces broches ont chacune

une fonction, comme on peut le voir sur le schéma.

Il y a :

• VDD et VSS, pour l’alimentation.

• OSC1 et OSC2, pour le quartz.

• Toutes les entrées/sorties : Les ports RA(0-5), RB(0-7), RC(0-7), RD(0-7)et RE(0-3).

• Le reset MCLR.

Le Pic 18F4550 n’est pas un simple ensemble de broche, c’est un microcontrôleur qui possède

également :

• (CAN) Un convertisseur Analogique / Numérique sur 10 bits

• Une USART

• Une PWM (MLI = modulation de largeur d’impulsions)

• Quatre TIMERS : du 0 au 3

• Un « Watchdog »

Plus de détails sur le schéma de la structure du Pic fournis en annexe p29.

7

III.1) La carte pour le pic 18F4550

C’est une carte que m’a fournie mon tuteur pour travailler sur mon projet.

Elle comprend un grand nombre d’interfaces pour utiliser le microcontrôleur.

La carte se compose de :

1. Deux entrées d’alimentation externe (5V et alimentation par USB)

2. Un régulateur 3v3

3. Deux connecteurs de programmation. (Utilisé pour le PICKit)

4. Deux supports pour deux oscillateurs, le principal et le secondaire

5. Deux supports pour PIC, un 28 broches et un 40 broches

6. Quatre connecteurs HE10

7. Quatre LEDs, quatre boutons poussoirs et trois potentiomètres

8. Une interface USB

9. Une mémoire EEPROM

10. Un capteur de température

11. Un buzzer Piezo

Figure 5 : Carte PIC

8

IV) Matériel Informatique

IV.1) Les logiciels et le PICKit3

Pour me lancer dans la programmation du microcontrôleur j’ai utilisé deux logiciels : le logiciel

MPLAB, que je ne connaissais pas avant d’avoir commencé mon stage ainsi que le logiciel Visual

Studio 2010 que j’avais utilisé pendant quelques heures en licence professionnelle.

Bien sur, une fois le programme créé, il faut pouvoir le tester ; donc pour l’envoyer sur le

microcontrôleur, j’ai utilisé un programmateur : le PICKit3.

IV.2)Logiciel Microsoft Visual Studio 2010

Microsoft Visual Studio est une suite de logiciels de développement pour Windows.

Il y a :

• Visual Basic

• Visual C++

• Visual C#

• Visual Web Developer

• Visual J#

• SQL Server

Il existe plusieurs versions:

Visual Studio 97, Visual Studio 6.0, Visual Studio .NET, Visual Studio .NET 2003, Visual

Studio 2005, Visual Studio Express, Visual Studio 2008, Visual Studio 2010.

J’ai été amené à utiliser ce logiciel pendant mes cours de DotNet en Licence professionnelle. J’ai du le

réutiliser dans sa version 2010 pour mon projet dans le but de faire une interface graphique pour le

programme. Visual Studio est un logiciel de programmation très performant et très intéressant.

Figure 6 : Logo Visual Studio

IV.3) Logiciel MPLAB

Pour programmer le PIC, j’ai eu à ma disposition le logiciel MPLAB IDE et un PICKit3.

Le logiciel MPLAB est un outil de

microcontrôleurs de la famille Microchip. Ce logiciel est un logiciel entièrement gratuit, mis au point

par Microchip et donc très facile à se procurer.

MPLAB permet à son utilisateur de créer un progra

Pour ensuite l’envoyer au PIC à l’aide d’un PICKit par exemple.

Avec L’environnement de MPLAB, le développement d’un programme informatique peut être fait en

langage machine (assembleur) ou peut être réalisé en langag

IV.4) Le PICKit3

Le PICKit a été créé par Microchip Technology

microcontrôleurs PIC. Ils sont utilisés pour programmer les microcontrôleurs et certaines mémoires

EEPROM.

Le PICKit3 est le successeur du PICKit1 et du PICKit2. Il possède tous les avantages des deux premiers,

c'est-à-dire pouvoir programmer et de déboguer un très grande nombre de microcontrôleur.

La différence avec les deux autres, est que ce dernier possède des régulateurs de te

découpage, donc cela permet au PICKit3 de générer des tensions de 2.5 à 5.5 V à partir de l’entrée 5

V USB.

Figure 7 : Logo Microchip


Le logiciel MPLAB est un outil de développement spécialement créé pour programmer des


par Microchip et donc très facile à se procurer.

MPLAB permet à son utilisateur de créer un programme, de l’assembler et de le simuler.

Pour ensuite l’envoyer au PIC à l’aide d’un PICKit par exemple.


langage machine (assembleur) ou peut être réalisé en langage C.

par Microchip Technology ; c’est une famille de programmateurs conçus pour les


sseur du PICKit1 et du PICKit2. Il possède tous les avantages des deux premiers,

dire pouvoir programmer et de déboguer un très grande nombre de microcontrôleur.

La différence avec les deux autres, est que ce dernier possède des régulateurs de te


Figure 8 : PickIt3

9


pour programmer des


mme, de l’assembler et de le simuler.


; c’est une famille de programmateurs conçus pour les


sseur du PICKit1 et du PICKit2. Il possède tous les avantages des deux premiers,

dire pouvoir programmer et de déboguer un très grande nombre de microcontrôleur.

La différence avec les deux autres, est que ce dernier possède des régulateurs de tension à


10

V) Organigramme du programme

Voici l’organigramme du programme :

Figure 9 : Organigramme

Résumé du programme avant les explications détaillées :

J’ai coupé en deux le programme pour une meilleure compréhension. Il y a une partie conversion et

une partie comptage.

La partie conversion est destinée à la conversion analogique-numérique. Ce type de conversion est

la seule disponible sur le pic 18F4550 ; en effet, la conversion numérique-analogique n’existe pas sur

ce PIC.

La partie comptage est destinée à compter le nombre de « Pulses » d’un signal envoyé. Pour cela j’ai

dû utiliser les différents Timers du pic, notamment le Timer 0 pour compter la seconde et le Timer 1

pour compter le nombre de « Pulses ».

Il y à aussi une partie affichage sur le PC ainsi que sur l’écran LCD et une partie connexion PC-Pic

18F4550 que je vais aborder dans la suite du développement.

11

VI) Explications détaillées sur le programme : La tête du programme

Voir Tête du programme en annexe p30.

VI.1) Les fichiers « include »

La directive #include permet d’introduire les différents fichiers et librairies disponibles. Ce sont des

fichiers extérieurs au programme. Les <.h> sont situés dans un répertoire source que l’on donne au

logiciel, tandis que les ".h" sont situés dans le répertoire ou se situe le programme. Ces fichiers ont

différentes fonctions :

Le fichier stdio.h (Standard Input/Output Header = En-tête Standard d'Entrée/Sortie) contient les

macros et fonctions utilisés dans les opérations sur les entrées/sortie.

Pour les autres fichiers, on peut facilement deviner leur utilisation :

• usart.h est utilisé pour les fonctions de l’usart.

• adc.h est utilisé pour les fonctions de l’adc.

• delays.h est utilisé pour les fonctions de delays.

• LCD.h est utilisé pour les fonctions de LCD.

• timers.h est utilisé pour les fonctions de timers.

• Routine.h est un fichier que j’ai créé pour alléger le programme principal en y incluant toutes

les procédures et fonctions du programme.

Ces différents fichiers sont indispensables pour l’allègement du programme principal et surtout pour

son bon fonctionnement.

VI.2) Les définitions

Une définition #define est en fait une substitution. Je l’ai incluse dans mon programme pour montrer

son existence et pour montrer son intérêt avec cet exemple :

#define q 4.9e-3

#include <stdio.h>

#include <delays.h>

#include <usart.h>

#include "adc.h"

#include "delay.h"

#include "LCD.h"

#include "timers.h"

#include "Routine.h"

12

Donc dans cet exemple « q » remplace la valeur 4.9e-3, ce qui simplifie l’écriture par la suite.

VI.3) Les pragma config

Le « #pragma config » est une directive qui permet de configurer le microcontrôleur.

Je l’utilise pour ces quelques exemples :

« FOSC = HS » Configure l’oscillateur à 20MHz. (20 MHz fréquence d’horloge externe)

« USBDIV = 1 » est utilisé pour configurer la source de l’usb, il utilise l’oscillateur primaire.

« LVP = OFF » autorise simplement l’alimentation externe de 5V.

« MCLRE = OFF » n’autorise pas le reset.

VI.4) Les procédure pour void

Void est un nom utilisé en C permettant de signaler une fonction et de créer des procédures.

Voici quelques exemples ci-dessus, c’est une partie de toutes les procédures que j’ai créées.

Le reste des procédures est disponible dans le programme.

Il y a beaucoup de procédures pour simplement rendre le programme plus lisible. Elles ont été

créées, par exemple, pour simplement allumer un timer ou pour configurer l’usart. Donc les

procédures sont utiles pour les tâches les plus simples comme pour les plus compliquées.

VI.5) Les déclarations de variables

#pragma config FOSC = HS

#pragma config USBDIV = 1

#pragma config LVP = OFF

#pragma config MCLRE = OFF

void Int_Init(void);

void Interruption_Haute_Priorite(void);

void Interruption_Basse_Priorite(void);

void USART_Open(void);

void USART_ISR_Init(unsigned char, unsigned char);

void USART_ISR(void);

void ADC_On(void);

void ADC_Off(void);

float Tension_Valeur;

char CommandePC = 'X';

unsigned int Seconde = 65536-39062;

13

Pour pouvoir utiliser une variable, il faut lui donner un nom et un type.

Une variable se définit de la manière suivante :

Type Nom_de_la_variable

Dans mon programme, j’utilise des types float, char et unsigned int, ce sont dans l’ordre, des réels,

des caractères et des entiers non signés. J’utilise ces types de variables, mais il en existe d’autres,

comme les types double et bool.

VI.6) Les niveaux d’interruption

Le Pic 18F4550 possède deux niveaux d’interruption, dont l’un est plus prioritaire que l’autre.

Il y a les interruptions dites de « haute priorité » et les interruptions dites de « basse priorité ».

C’est un langage assembleur car ce n’est pas accessible en C.

Voici le code pour les deux niveaux d’interruption.

« #pragma code Interruption_Vecteur_Haut = 0x08 » et « #pragma code Interruption_Vecteur_Bas =

0x18 » sont les instructions qui force le compilateur à placer les codes en 0x08 et 0x18.

Pourquoi 0x08 et 0x18 ? Et bien ce sont les sont les adresses fixés par Microchip pour ces

microcontrôleurs PIC.

#pragma code Interruption_Vecteur_Haut = 0x08

void Interruption_Echt(void)

{

_asm

goto Interruption_Haute_Priorite

_endasm

}

#pragma code Interruption_Vecteur_Bas = 0x18

void Interruption_Vecteur_Bas(void)

{

_asm

goto Interruption_Basse_Priorite

_endasm

}

#pragma code

void Int_Init(void)

{

RCONbits.IPEN=1 ;

INTCONbits.GIEH = 1 ;

INTCONbits.GIEL = 1;

}

14

Ces trois instructions sont celles qui autorisent les interruptions (voir annexe).

« RCONbits.IPEN=1 ; » active les priorités des interruptions.

« INTCONbits.GIEH = 1 ; » active les interruptions prioritaires.

« INTCONbits.GIEL = 1 ; » active les interruptions non prioritaires.

Voici donc les explications pour les parties importantes de tous ce que j’ai appelés la tête du

programme. Viennent ensuite la partie communication entre le PC et le PIC ainsi que la partie

affichage sur écran LCD et sur logiciel.

15

VII) Explications détaillées sur le programme : Partie communication

La communication entre le PC et le PIC s’est faite en rs232, c’est une communication série entre deux

équipements.

Pour cela j’ai utilisé la fonction USART du PIC 18F4550. Et on ma donné les instructions suivantes :

9600 Bauds, 8 Bits de données, un Bit de Stop, pas de Bit de parité.

Voir annexe Communication p31.

Ceci est la procédure créée, pour configurer la communication.

« USART_TX_INT_OFF » n’autorise pas les interruptions sur la transmission.

« USART_RX_INT_ON » autorise les interruptions sur réception.

J’utilise simplement les interruptions sur réception car c’est ce que j’utilise, je n’utilise pas la fonction

de transmission

« USART_ASYNCH_MODE » mode asynchrone.

« USART_EIGHT_BIT » transmission sur 8 bits.

« USART_CONT_RX » réception continue.

« USART_BRGH_HIGH » définit une « baud rate » élevée (la vitesse de connexion).

« 129 » détermine la vitesse de connexion.

La valeur 129 a été trouvée grâce à la datasheet en faisant :

x = (FOSC/(BAUD*16))-1 avec FOSC (Hz), BAUD (Hz)

x = (20000000/(9600*16))-1= 129,208

Ou en faisant :

x = FOSC/(16*(n+1))

x = 20000000/(16*(9600+1))= 130,194

Donc on peut choisir une des deux solutions, j’ai choisi la première.

La communication se fait ensuite grâce à l’interruption sur IPR1bits.RCIP.

void USART_Open(void)

{

OpenUSART( USART_TX_INT_OFF &

USART_RX_INT_ON &

USART_ASYNCH_MODE &

USART_EIGHT_BIT &

USART_CONT_RX &

USART_BRGH_HIGH ,

129 );

IPR1bits.RCIP = 0;

}

16

VIII) Explications détaillées sur le programme : Partie affichage sur écran

LCD

L’afficheur LCD que j’ai à ma disposition est un afficheur 2*16, c'est-à-dire qu’il à deux lignes, et sur

ces deux lignes, on peut écrire jusqu’à seize caractères par ligne. Voir affichage p32.

La partie affichage se fait simplement grâce à Microchip et à sa librairie LCD. C’est une librairie qui

contient toutes les commandes pour l’affichage, il suffit de trouver les bonnes.

La commande « LCD_Init() » configure l’afficheur LCD 2*16

La commande « LCD_AddCurseur(L2C1); » j’écris sur la LIGNE 2 à partir de l’emplacement du

CARACTERE 1.

« fprintf(_H_USART, (const far rom char *)"\r\nTimer1 ON"); et

fprintf(_H_USER, (const far rom char *)" Timer1 ON "); »

Voilà comment écrire sur l’afficheur et sur le logiciel.

_H_USART � Logiciel

_H_USER � Afficheur LCD

Figure 10 : Afficheur LCD

L’afficheur et un petit exemple de ce que l’on peut afficher.

Maintenant que ces deux parties on été expliquées, je peux passer à la partie « comptage » qui

comme je vais vous le montrer, utilise les Timers et leurs interruptions.

LCD_Init();

LCD_AddCurseur(L2C1);

fprintf(_H_USART, (const far rom char *)"\r\nTimer1 ON");

fprintf(_H_USER, (const far rom char *)" Timer1 ON ");

17

IX) Explications détaillées sur le programme : Partie comptage

Comme je l’ai dit pour cette partie, j’ai utilisé les Timers, donc voici une petite explication sur les

TIMERS du 18F4550.

IX.1) Les Timers

Pour gérer le temps, tous les microcontrôleurs possèdent un ou plusieurs Timers.

Le PIC 18F4550 possède 4 Timers :

• Le Timer 0

• Le Timer 1

• Le Timer 2

• Le Timer 3

Les Timers permettent de compter un nombre d’impulsions. Ces impulsions proviennent :

• Du quartz du microcontrôleur � Compteur de temps.

• D’une entrée du PIC � Compteur d’événements extérieurs.

J’utilise ces deux types de compteurs pour mon programme.

Pour les mettre en œuvre, j’utilise le Timer 0 en compteur de temps et le Timer 1 en compteur

d’événements extérieurs. Je n’utilise pas les autres car je n’en ai pas eu l’utilité.

IX.2) Le Timer 0 en compteur de temps

En ayant fait plusieurs expériences sur les Timers, j’ai opté pour le Timer 0 pour compter le temps,

car c’est celui avec lequel j’ai eu le plus de facilités pour créer un événement toutes les secondes.

Le Timer 0 a été configuré comme ceci :

« TIMER_INT_ON » Autorise les interruptions du Timer 0, donc l’allume.

« T0_16BIT » J’utilise le Timer 0 sur 16 Bits.

« T0_SOURCE_INT » J’utilise le quartz du microcontrôleur.

void Timer0_On (void)

{

OpenTimer0( TIMER_INT_ON &

T0_16BIT &

T0_SOURCE_INT &

T0_PS_1_128 );

WriteTimer0(Seconde);

}

18

« T0_PS_1_128 » J’utilise un prescaler de 128.

« WriteTimer0(Seconde) » est la commande qui fait la « Seconde ».

Voici pourquoi je travail sur 16 bits et avec un prescaler de 128.

unsigned int Seconde = 65536-39062; (1/(20/4)mhz) * 128 * 39062 = 0.9999872 seconde (65536-

39062)

Figure 11 : Block Diagram Timer 0

IX.3) Le Timer 1 en compteur d’impulsions extérieures

J’ai utilisé le Timer 1 pour compter les impulsions, le Timer 0 le fait aussi, mais je l’utilise déjà. Les

Timers 2 et 3 peuvent aussi compter les impulsions extérieures, mais sont inutiles, vu qu’il ne m’en

faut qu’un.

Voici la configuration du Timer 1 :

« TIMER_INT_OFF » N’autorise pas les interruptions du Timer 1, donc ça le configure seulement, il

n’est pas en fonctionnement.

void Timer1_Open(void)

{

OpenTimer1(TIMER_INT_OFF &

T1_16BIT_RW &

T1_SOURCE_EXT &

T1_PS_1_1 &

T1_OSC1EN_ON &

T1_SYNC_EXT_OFF);

}

void Timer1_On (void)

{

T1CONbits.TMR1ON = 1;

WriteTimer1(0);

}

19

« T1CONbits.TMR1ON = 1 » Allume le Timer 1, donc autorise les interruptions.

Le reste est sur le même principe que le Timer 0, mise à part qu’on agit sur les interruptions

extérieures.

L’entrée pour ces interruptions est sur le schéma ci-dessous, c’est T13CKI sur le port C du

microcontrôleur. Voir broche 15 du PIC.


IX.4) Explications partie comptage

J’utilise la communication pour envoyer des caractères au PIC, ces caractères sont associés aux

procédures. Par exemple la case 0, allume le timer 0. Pour le reste, voir Comptage et Conversion

p32.

Toutes les routines de ce programme sont placées en priorités hautes.

Le programme fonctionne de la manière suivante :

• Communication établie entre PC et PIC

• Choisir le mode « Comptage »

• Allume Timer 0 et configure Timer 1

• Allume Timer 1 et donc démarre comptage

• Affiche les différentes valeurs comptées grâce à la fonction « ReadTimer1() »

• Arrêt du Timer 1 et donc stop comptage

• Choix entre tout éteindre ou redémarrer le comptage

20

X) Explications détaillées sur le programme : Partie Conversion

La partie conversion utilise le « ADC » du microcontrôleur, c’est une conversion analogique vers

numérique. Dans ce programme je transforme la tension envoyée au microcontrôleur en valeur

numérique.

X.1) ADC

La configuration de « ADC » est :

« ADC_FOSC_32 » Règle la fréquence de l’oscillateur.

« ADC_RIGHT_JUST » Alignement du résultat à droite.

« ADC_12_TAD » Durée d’acquisition (1 TAD = FOSC /32).

« ADC_CH0 » Je me mets sur le canal 0 pour la conversion.

« ADC_REF_VDD_VSS » Les tensions références sont VDD et VSS

« ADC_INT_ON » J’autorise l’interruption après conversion.

« ADC_1ANA » l’entrée AN0 est en analogique, le reste en digital ( AN1-AN15)

X.2) Explications partie conversion

Tous comme la partie précédente, j’utilise la communication pour envoyer des caractères associés à

différentes procédures. Voir Comptage et Conversion p32.

Le programme fonctionne de la manière suivante :

• Communication établie entre PC et PIC

• Choisir le mode « Conversion »

• Allume L’ « ADC », démarre la conversion et l’affiche

• Arrêt ADC

• Choix entre tout éteindre ou redémarrer conversion

Ces étapes expliquées, je vais passer à la partie affichage des données sur PC.

void ADC_On(void)

{

OpenADC(ADC_FOSC_32 &

ADC_RIGHT_JUST &

ADC_12_TAD ,

ADC_CH0 &

ADC_REF_VDD_VSS &

ADC_INT_ON ,

ADC_1ANA );

IPR1bits.ADIP = 0 ;

}

21

XI) L’affichage

Pour afficher ces données, il a fallu créer un logiciel sur le PC. Pour cela, j’ai utilisé le logiciel Visual

Studio, car c’est ce que l’on m’a conseillé. J’ai utilisé le C# (sharp).

XI.1) La fenêtre d’affichage

Figure 13 : Affichage Logiciel

Voici la fenêtre créée, il y à plusieurs boutons et zones de textes, pour afficher les valeurs mesurées.

Les boutons :

• Le bouton « Open port » sert à établir la communication PC-PIC.

• On a le choix entre la conversion ADC et le COMPTEUR

• « Allume et Eteint ADC » Comme indiqué on démarre ou arrête la conversion

• Les boutons pour le compteur, allume les différents Timers, démarre comptage etc…

J’ai dû mettre plusieurs restrictions sur les différents boutons, pour ne pas faire « bugger » le

programme. Car je ne peux pas démarrer la conversion et le comptage en même temps par exemple.

Donc il y à aussi une partie programmation derrière tous cela.

22

XII) La programmation du logiciel

Voir annexe p34.

XII.1) Le paramétrage de la communication

Ce sont les mêmes paramètres de connexion que pour le PIC.

Création d’une MessageBox avec enregistrement d’un fichier texte pour les valeurs

Grâce à cette commande, au moment ou j’appuie sur le bouton Comptage, je dois créer un

document texte qui va enregistrer toutes les valeurs comptées par le PIC, jusqu’à arrêt du compteur.

comport.BaudRate = 9600;

comport.DataBits = 8;

comport.StopBits = StopBits.One;

comport.Parity = Parity.None;

comport.PortName = "COM3";

commandesauvegarde.Filter = "txt files (*.txt)|*.txt|All files (*.*)|*.*";

commandesauvegarde.FilterIndex = 2;

commandesauvegarde.RestoreDirectory = true;

if (commandesauvegarde.ShowDialog() == DialogResult.OK)

{

fch = commandesauvegarde.FileName;

if ((myStream = commandesauvegarde.OpenFile()) != null)

{

myStream.Close();

}

}

23

XII.2) Explications sur un bouton

Voici donc la programmation d’un des boutons.

« txtSendData.Text = "G"; SendData(); » est la commande qui envoie le caractère.

« Stop.Enabled = true; » Autorise l’accès au bouton STOP.

« Go.Enabled = false; » On ne peut plus accéder au bouton GO.

« deb » est la date à l’heure à laquelle on appuis sur le bouton.

« rtfTerminal.Clear(); » Efface les informations sur l’écran.

« Donnée.Text = " La Fréquence est :"; temps.Text = "le début est à : " + deb; » Ecrit dans les boites

de dialogues.

Ce sont les informations que j’ai jugées, les plus importantes pour cette partie logiciel, car je ne peux

pas tout montrer, vu que le programme est conséquent en taille, mais ce sont plus ou moins les

même paramètres pour chaque bouton.

private void btn_Go_Click(object sender,

EventArgs e)

{

txtSendData.Text = "G";

SendData();

Stop.Enabled = true;

Go.Enabled = false;

deb = new DateTime(DateTime.Now.Year,

DateTime.Now.Month, DateTime.Now.Day,

DateTime.Now.Hour, DateTime.Now.Minute,

DateTime.Now.Second); // heure actuelle au moment

ou on clique

rtfTerminal.Clear();

Donnée.Text = " La Fréquence est :";

temps.Text = "le début est à : " + deb;

Stop_tout.Enabled = false;

}

24

XIII) Bilan et perspectives

Le projet pour la réalisation de la communication entre PC-PIC a bien été faite. Les différents

programmes créés pour le projet fonctionnent.

J’ai réalisé le projet comme ceci :

Figure 14 : Planning

Cela à été établie sur 11 semaines, car j’ai commencé mon stage en retard, les semaines restantes

seront effectuées mais le travail accompli ne peut pas être dans le rapport.

Il s’agit de continuer à créer des programmes pour le PIC, comme l’accès à un capteur de

température, ou un lecteur SD par exemple.

25

XIV) Conclusion

Ce stage au LMSPC m’aura appris énormément de choses. Au départ je n’étais pas totalement serein,

car les microcontrôleurs étaient une branche avec laquelle je n’étais pas à l’aise. Au fil du stage j’ai

réussi à me familiariser avec les PIC et à créer des programmes qui fonctionnent.

C’était très enrichissant au niveau théorique.

Dans l’ensemble je suis satisfait d’avoir obtenu ce stage de fin d’étude car je ne pensais pas qu’il

m’apporterait autant. Bien sur comme je l’ai dit, cela m’a apporté des choses au niveau théorique,

mais aussi montré une vision positive de ma vie professionnelle qui commence bientôt.

26

XV) Lexique

Voici une signification des différents mots que j’ai pu utiliser :

• ADC ou CAN : Analog-to-Digital (A/D) Converter module CCP

• CCP : CAPTURE / COMPARE / PWM

• CPU : Processeur

• Datasheet : documentation sur le microcontrôleur

• FOSC : Frequence oscillateur

• IDE : Integrated Development Environment

• PC : Personal Computer

• PIC : Famille de microcontrôleur Microchip

• Pulse : Impulsion

• RAM : Random Access Memory

• ROM : Read Only Memory

• USART : Universal Synchronous & Asynchronous Receiver Transmitter

• USB : Universal Serial Bus

• Watchdog : Chien de garde (fr) C'est un mécanisme qui permet de s'assurer qu'un processus

ne reste pas bloqué à une étape particulière du traitement effectué. Si tel était le cas alors le

débordement de ce Timer spécialisé provoquerait le redémarrage du système.

27

XVI) Listing et Webographie

XVI.1) Listing « Figure »

Figure 1 : Logo CNRS et LMSPC

Figure 2 : Image microcontrôleurs

Figure 3 : Architecture Neumann et Harvard

Figure 4 : Pic 18F4550

Figure 5 : Carte PIC

Figure 6 : Logo Visual Studio

Figure 7 : Logo Microchip

Figure 8 : PickIt3

Figure 9 : Organigramme

Figure 10 : Afficheur LCD



Figure 13 : Affichage Logiciel

Figure 14 : Planning

XVI.2) Webographie

J’ai utilisé :

• Toutes les documentations que fournit Microchip.com sur le PIC 18F4550

• Wikipédia.fr

• Google.fr pour de nombreuses recherches

• Les forums de Futura-sciences.com

28

XVII) Résumé en Anglais

I am Damien Madonna, Damien is my first name, Madonna is my Surname. I am 23.

I’m studying at the Mulhouse IUT the local College of technology. I’ve been there since the 12th

September since I started my new Degree course. I’m studying for an Engineering degree in

Automation and Industrial Data Processing. It’s a one year course completing my two years course I

did before.

To complete my degree I must do a 3 month placement.

For this placement, I sent a lot of letters to different companies and finally the CNRS-LMSPC say YES.

The 3 month placement is designed to improve my different practical skills. It’s in the CNRS-LMSPC in

Strasbourg.

I started the placement the 19th

March and I will finish the 22th

June.

The subject of the placement is to programming a PIC 18F4550, it’s a microcontroller.

This placement is very interesting and I learned a lot of things.

29

XVIII) Les annexes

XVIII.1) Structure du PIC

30

XVIII.2) La tête du programme

#include <stdio.h>// .\h\stdio.h #include <delays.h>// .\h\delays.h #include <usart.h>// .\h\usart.h #include "adc.h" #include "common.h" #include "delay.h" #include "LCD.h" #include "timers.h" #include "Routine.h" void Int_Init(void); void Interruption_Haute_Priorite(void); // Routine d'interruption priorité haute void Interruption_Basse_Priorite(void); // Routine d'interruption priorité basse void USART_Open(void);

void USART_ISR_Init(unsigned char, unsigned char); void USART_ISR(void); void ADC_On(void); // Démarrage de la conversion void ADC_Off(void);// Arrêt conversion void Timer1Conv_Open(void); void Timer1_Open(void); void Timer0_On(void);// Démarrage Timer0 pour Echantillonnage : Prescale = 128 void Timer0_OFF(void);// Arret Timer0 void Timer1_On(void); void Timer1_OFF(void); void Message_Accueil(void); char string[10]; float ADC_Valeur; float Tension_Valeur; char CommandePC = 'X'; // Commande nulle char Go = '0'; // Indique un acquisition en cours

unsigned int Seconde = 65536-39062; // 1/5mhz * 128 * 39062 = 0.9999872 seconde (65536-39062) unsigned int Tic = 0;// bat la seconde unsigned int TicOld = 0; // Indique la présence d'un nouveau comptage unsigned int Dat = 0;// Valeur T1 par sec unsigned int Conv = 0; unsigned int Boucle = 0; #pragma config USBDIV = 1 // USB clock source provident de l’oscillateur primaire #pragma config FOSC = HS // HS oscillator #pragma config WDT= OFF // Watchdog désactivé #pragma config LVP = OFF // alimentation externe 5V #pragma config MCLRE = OFF // MCLR désactivé #define q 4.9e-3 // valeur pour afficher 0v-5v // Vecteur d'interruption priorité Haute #pragma code Interruption_Vecteur_Haut = 0x08 // définir le vecteur interruption à l'adresse 0x08 void Interruption_Echt(void)

{ _asm goto Interruption_Haute_Priorite // saut à routine interruption _endasm } // Vecteur d'interruption priorité basse #pragma code Interruption_Vecteur_Bas = 0x18 // définir le vecteur interruption à l'adresse 0x18 void Interruption_Vecteur_Bas(void) { _asm goto Interruption_Basse_Priorite _endasm } #pragma code #pragma interrupt Interruption_Basse_Priorite void Interruption_Basse_Priorite(void)

{ USART_ISR(); ADC_ISR();

31

} #pragma interrupt Interruption_Haute_Priorite void Interruption_Haute_Priorite(void) { Tic++; // incrément Tic; Timer1_OFF();// Arret comptage T1 Dat = ReadTimer1();// valeur Timer 1 WriteTimer1(0); WriteTimer0(Seconde); Timer1_On();// Reprise comptage T1

INTCONbits.TMR0IF = 0; // reset du flag } void Int_Init(void) // autorise les interruptions { INTCONbits.TMR0IE = 1; RCONbits.IPEN = 1; INTCONbits.GIEH = 1; INTCONbits.GIEL = 1; }

XVIII.3) La communication

void USART_ISR_Init() { // Registres pour la transmission PIR1bits.TXIF = 0; IPR1bits.TXIP = 0;

PIE1bits.TXIE = 0; // Registre pour la reception PIR1bits.RCIF = 0; IPR1bits.RCIP = 0; PIE1bits.RCIE = 0; } void USART_Open(void) { OpenUSART( USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH , 129 ); IPR1bits.RCIP = 0; // Configuration manuelle du niveau de priorité de l'interruption de

l'UART } void USART_ISR(void) { if (PIR1bits.RCIF) // Donnée en reception { switch(RCREG) { case '0': CommandePC = '0'; // T0 ON break; case '1': CommandePC = '1' ;// T1 ON break; case 'G':

CommandePC = 'G'; // Départ comptage sur T1 break; case 'S': CommandePC = 'S'; // Arret T1 break; case 'H': CommandePC = 'H'; // Arret T0 break;

32

case 'A': CommandePC = 'A'; // Démarre une conversion break; case 'Z': CommandePC = 'Z'; // Arrete conversion break; default : Nop(); break; }

PIR1bits.RCIF = 0; // efface drapeau d'INT avant de sortir de la routine } }

XVIII.4) L’affichage

void Message_Accueil(void) { LCD_Display("Interface PC ", "Analyseur HCHO"); fprintf(_H_USART, (const far rom char *)" -Interface PC- \r\n"); }

XVIII.5) Le comptage et la conversion

void Timer0_On (void) { OpenTimer0( TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_128 ); WriteTimer0(Seconde); } void Timer0_OFF (void) { T0CONbits.TMR0ON = 0; // Timer0 Off }

void Timer1_OFF (void) { T1CONbits.TMR1ON = 0; // Timer1 OFF } void Timer1_On (void) { T1CONbits.TMR1ON = 1; // Timer1 ON WriteTimer1(0); } void ADC_On(void) { OpenADC( ADC_FOSC_32 & ADC_RIGHT_JUST &

ADC_12_TAD , ADC_CH0 & ADC_REF_VDD_VSS & ADC_INT_ON , ADC_1ANA ); // analog:AN0, digital:AN1-AN15 IPR1bits.ADIP = 0 ; } void ADC_Off(void) { CloseADC(); } void ADC_ISR(void)

33

{ if (PIR1bits.ADIF) { ADC_Valeur = ReadADC(); // ADC_Valeur prend la valeur de ReadADC() PIR1bits.ADIF = 0; // efface drapeau d'INT avant de sortir de la routine } }

void main (void) { Int_Init(); LCD_Init();// Configuration de l'afficheur LCD 2x16 USART_Open(); Message_Accueil(); while (1) { switch(CommandePC) { case '0': // Démarrage Tempo

CommandePC = 'X'; // on évite les réentrances Timer0_On(); // Démarrage Timer0 LCD_AddCurseur(L2C1); fprintf(_H_USART, (const far rom char *)"Timer0 ON"); fprintf(_H_USER, (const far rom char *)" Timer0 ON "); break; case '1':// Démarrage T1 CommandePC = 'X'; // on évite les réentrances Go = '0'; Timer1_Open(); LCD_AddCurseur(L2C1); fprintf(_H_USART, (const far rom char *)"\r\nTimer1 ON"); fprintf(_H_USER, (const far rom char *)" Timer1 ON "); break; case 'G': // Démarrage Comptage CommandePC = 'X'; // on évite les réentrances Go = '1';

Timer1_On(); // Démarrage Comptage TicOld = 0; Tic = 0; LCD_AddCurseur(L2C1); fprintf(_H_USART, (const far rom char *)"\r\n Comptage ON \r\n\n"); fprintf(_H_USER, (const far rom char *)" Comptage ON "); break; case 'S': // Stop comptage CommandePC = 'X'; // on évite les réentrances Go = '0'; Timer1_OFF(); // Stop comptage T1 LCD_AddCurseur(L2C1); fprintf(_H_USART, (const far rom char *)"\r\nComptage OFF"); fprintf(_H_USER, (const far rom char *)" Comptage Off "); break; case 'H': // Arret comptage

CommandePC = 'X'; // on évite les réentrances Go = '0'; T3CONbits.TMR3ON = 0; // Arret comptage T1 CloseADC(); LCD_AddCurseur(L2C1); fprintf(_H_USART, (const far rom char *)"\r\nTout OFF"); fprintf(_H_USER, (const far rom char *)" Tout Off "); break; case 'A': // Démarrage T1 CommandePC = 'X'; // on évite les réentrances ADC_On(); LCD_AddCurseur(L1C1); fprintf(_H_USART, (const far rom char *)"\r\nADC ON "); fprintf(_H_USER, (const far rom char *)" ADC ON "); Delay10KTCYx(250); Delay10KTCYx(250);Delay10KTCYx(250); Delay10KTCYx(250); // attend 2 secondes

34

Boucle = 1; break; case 'Z': // Arrêt ADC CommandePC = 'X'; // on évite les réentrances Boucle = 0; ADC_Off(); LCD_AddCurseur(L1C1); fprintf(_H_USART, (const far rom char *)"\r\nADC Off "); fprintf(_H_USER, (const far rom char *)"ADC OFF "); LCD_AddCurseur(L2C1);

fprintf(_H_USER, (const far rom char *)" "); IPR1bits.ADIP = 0; PIR1bits.ADIF = 0; break; default : Nop(); break; } if (Go == '1') { if (Tic > TicOld) { fprintf(_H_USART, (const far rom char *)" = %d",Dat); LCD_AddCurseur(L1C1); fprintf(_H_USER, (const far rom char *)"Temps = %d",Tic);

LCD_AddCurseur(L2C1); fprintf(_H_USER, (const far rom char *)"Data = %u",Dat); TicOld = Tic; } } if (Boucle == 1) { ConvertADC(); // commence convertion while( BusyADC() ); // Attente de la fin d'activité de l'ADC LCD_AddCurseur(L1C1); fprintf(_H_USER, (const far rom char *)"Valeur ADC= %u ", (int)ADC_Valeur); Tension_Valeur = (float)ADC_Valeur*q; // calcul de la tension ftoa(Tension_Valeur, string, 3, 'f');// convertion en une chaine de caractère LCD_AddCurseur(L2C1); fprintf(_H_USART, (const far rom char *)"\r\nT = %s V et V = %u

",string,(int)ADC_Valeur ); fprintf(_H_USER, (const far rom char *)"Tension= %s V ", string); } } }

XVIII.6) Une partie de la programmation du logiciel

private void btnOpenPort_Click(object sender, EventArgs e) { bool error = false; if (comport.IsOpen) comport.Close(); else {

comport.BaudRate = 9600; // comport.DataBits = 8; // comport.StopBits = StopBits.One; // parametrage du port comport.Parity = Parity.None; // comport.PortName = "COM3"; // try {

35

// ouvre le port comport.Open(); } }

if (comport.IsOpen) // si le port et ouvert { txtSendData.Focus(); ClearTerminal(); // efface les textes dans terminal }

btnOpenPort.Enabled = false; // le bouton n'est plus accessible // btnSend.Enabled = true; // bouton accessible btnClear.Enabled = true; // bouton accessible ADC.Enabled = true; // bouton accessible Compt.Enabled = true; // bouton accessible }

private void btn_Timer1_Open(object sender, EventArgs e) { txtSendData.Text = "1"; // 1 à envoyer SendData(); // envoi les données

Go.Enabled = true; // bouton go disponible Timer1_Open.Enabled = false; // bouton timer1 indisponible }

private void btn_Go_Click(object sender, EventArgs e) { txtSendData.Text = "G"; // G à envoyer SendData();// envoi les données Stop.Enabled = true; // bouton stop disponible

Go.Enabled = false; // bouton go indisponible deb = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day,

DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second); // heure actuelle au moment ou on clique rtfTerminal.Clear();// efface texte dans Terminal Donnée.Text = " La Fréquence est :"; (); // écrit dans donnée temps.Text = "le debut est à : " + deb; (); //écrit dans temps

Stop_tout.Enabled = false; // bouton Stop_tout indisponible }

Documents

Rapport de Stage Licence Professionnelle Communication PC-PIC · Rapport de Stage Licence Professionnelle Communication PC-PIC ... II.2) Les différentes familles de PIC Exemple de