Horloge et PIC

[cookieParis]

je suis debutant en pic (16F84 !et oui tout debut ! ) , donc hesitez pas a recadre mes questions si elles vous semblent pas cohérentes.

En gros je voudrais faire une horloge ( entre autre).
j'ai lu dans le cours de bigonoff , qu'une methode est de compter les instructions executés et d'en deduire le temps qui passe.
Assez logique et facile ...

La ou ca se complique c'ets que j'aimerai que mon pic traite des données en entrée et sortie, ce qui va produire un nombre d'intruction non previsible executés .

1) Comment faire ? existe il un equivalent du multithreading informatique en version electronique ?

2) Existe il un pic plus evolué qui integrerait une fonction utile a mon probleme ?

3) je pensais utiliser 2 pic , un qui compte et un qui recupere les données de celui qui compte ( une sorte de multi threading physique ! )

merci, pour votre apport.

[Gérard]

Tu veux une horloge qui donne l'heure ou une horloge qui compte du temps (ou des évènements) ?
Le nombre d'instructions n'est pas imprévisible vu que c'est toi qui les écrit.
Il faudrait que tu précises un peu tes questions.
Gérard.

[cookieParis]

je voudrais que mon pic fasse 2 choses , la premiere qu'il decompte le temps pour que j'en deduise l"heure, en meme temps qu'il va executer un algo pseudo aleatoire au nombre d'iteration non previsible ( j'aurai un truc du style "tant que condition" tu executes l'algo ..

[Helkafen]

C'est simple, il suffit d'utiliser un timer
Les timers s'incrémentent une fois pour 4 cycles d'horloge dans leur utilisation basique. Ils peuvent servir pour d'autre choses (compteur de fronts montants etc..) donc il faut configurer les registres idoines; fais un tour dans le datasheet section timer
Après, un timer se lit comme n'importe quelle variable en connaissant son adresse.
Le problème est maintenant le débordement du timer; eh oui mine de rien un timer 16bits et surtout 8bits ça passe vite, donc il va falloir te mettre aux interruptions. Configure ton pic pour générer une interruption à chaque débordemement du timer, et dans la routine d'interruption tu mettras le bout de code pour mettre à jour ton horloge
Conseil: fais l'horloge en premier et ajoute l'autre appli ensuite

seb

[Gérard]

Bonjour,
Comme le dit Helkafen, utilise l'interruption du timer pour compter le temps (horloge) et le programme principal pour ton application.
Pour + de détails, voir les cours de Bigonoff.
Gérard.

[nanard]

bonjour tout le monde

cookieParis programmes tu ton pic en assembleur ou en C?
les cours de bigoinoff sont fait si tu dévellopes en assembleur, les instruction en C pour les timers ne sont pas les même qu'en assembleur. Je ne peut pas d'aider pour l'instant car je débute sur les PICs en C mais j'était sur les AVRs en C.
@+

[cookieParis]

je suis les cours de bigonof dans l'ordre j'en suis au 16F84 et donc j'essaye de programmer en assembleur.

Merci de vos reponses !

[joop@gp]

Bonjour,

Une autre précision peut etre ? la précision escompté pour l'horloge...
Sinon en effet, le cours de bigonoff t'aidera

A+

[caliban]

bonjour, personellement je n'utilise pas (pas encore) de PIC, car travail avec des cpld ou fpga.
Mais quand il s'agit d'avoir une hologe on ne s'embête plus, on travail avec une RTC ( real time clock ==> horloge temps réel).
voir un circuit d'un genre DS1678 par exemple.
Comme cela tu libère ton pic d'une tache qu'un circuit à 6 pattes fait mieux que quiconque.

[joop@gp]

Bonjour,

Cowl, je connaissais pas :d
Merci caliban.

J'ai rapidement regarder l'histoire, en fait c'est sympa comme composant.
Nécessite :
Un clok (32 KH mais capacitance précise)
Il y a un pin pour interruption et ensuite , une communication avec le µC avec un bus I²C.
Donc il faut implémenter ca en plus

Bonne chance.
A+

[Gérard]

Bonjour,
L'I2C en assembleur n'est pas aussi simple.
En langage évolué c'est + facile.
Gérard.

[T-Bot]

Citation:

Posté par cookieParis

je suis les cours de bigonof dans l'ordre j'en suis au 16F84 et donc j'essaye de programmer en assembleur.

Merci de vos reponses !

continue alors jusqu'au moment où ca parlera du timer0.

[thm]

Pour avoir réalisé ce genre de chose, je peux dire que la difficulté ne vient pas du "comptage" mais .. de la mise à l'heure (et de l'affichage). Sinon, effectivement, le comptage du temps peut se faire sur base d'une incrémentation d'une variable suite à une interruption timer. Cela se code en une douzaine de lignes asm; et ne pend donc qu'une diziane de µ sec à chaque interruption qui se produit toutes les x msec. Donc le µC (Pic ou autre) a largement le temps de s'occuper à faire autre chose..
Une RTC externe ne sert à rien .. sauf à compliquer le hard et si l'heure doit être sauvegardée et sauf si il s'agit d'un ancien µC qui n'a pas de mode basse consommation si le montage fonctionne sur piles.
th.

[popoye]

un module externe peut s'averer utile pour certaines appli, mais si j'ai bien compris tu n'as pas un projet spécifique à réaliser, tu fait ca pour "t'amuser".

t'as plusieurs solutions , jsuis en train de fairte la meme chose, j'ai mon timer qui tourne et chaque débordement incrémente le port B ou j'ai mis des leds pour visualiser le comptage.
ca marche, mais ca ne marche pas.
Mon Pic compte, s'arete, compte.... tout ca de facon totalement aléatoire....si vous voyez un défault dans mon prog, j'ai un quartz 4MHz avec PLL activé, pas de watch dog... SVP
#include "p18f452.h"


void main(void)
{
//configuration des ports
TRISB=0x00; //port B en sortie
PORTB=0x00;
//registre timer0
T0CON=0x00; //clr T0CON
T0CON=0x04;
T0CONbits.T0CS=0; //TOCS en Fosc/4
T0CONbits.PSA=0; //PSA sans prescaler
T0CONbits.T08BIT=0; //compteur 16bits
T0CONbits.TMR0ON=1; //allume le timer0
TMR0L=0x00; //init reg low
TMR0H=0xFF; //init reg high

//registre interruptions INTCON
INTCONbits.RBIF =0; //flag interrupt externes sur port B
INTCONbits.INT0IF =0; //interruptions externes
INTCONbits.TMR0IF =0; //clear flag
INTCONbits.RBIE =0; //pas de changement sur le port B lors d'une interruption
INTCONbits.INT0IE =0; //disable les interruptions externes
INTCONbits.TMR0IE =1; //enable the timer0 overflow interrupt
INTCONbits.PEIE =0; //disable les interruptions périphériques
INTCONbits.GIE =1; //enable toutes les interruptions unmasked

//registre de priorité des interruptions INTCON2
INTCON2bits.RBIP =0; //low priority sur le portB
INTCON2bits.TMR0IP =1; //high priority sur le timer0
INTCON2bits.INTEDG2 =0; //interrupt externe2 sur front montant
INTCON2bits.INTEDG1 =0; //interrupt externe1 sur front montant
INTCON2bits.INTEDG0 =0; //interrupt externe0 sur front montant
INTCON2bits.RBPU =0; //pull-up sur portB controlés par leur latch

//registre de validation des interruptions INTCON3
INTCON3bits.INT1IF=0; //pas de flag sur les interrupt externes
INTCON3bits.INT2IF=0; //pas de flag sur les interrupt externes
INTCON3bits.INT1IE=0; //disable external interrupt
INTCON3bits.INT2IE=0; //disable external interrupt
INTCON3bits.INT1IP=0; //low priority sur les interrupt externes
INTCON3bits.INT2IP=0; //low priority sur les interrupt externes

//registre des flags des interruptions périphériques PIR et PIR2

//registre de validation des interrupt périphériques PIE et PIE2

//registre de priorité des interruptions périphériques IPR et IPR2

//registre reset interruptions RCON
RCONbits.IPEN=0;

while(1)
{
if (INTCONbits.TMR0IF)
{
INTCONbits.TMR0IF=0; //clr flag
PORTB++;
}//end if
}//end while
}//end main


PS en voyant que ca ne marchait pas j'ai meme configurer les registres que je n'utilisait pas dans le doute.
De plus la simu tourne sans probleme avecI SIS proteus

[electrotricot]

Bonjour à tous,
je suis aussi actuellement en projet sur à peu près le même sujet que le votre et j'ai un petit problème pour comprendre un language assembleur qui ne correspond pas exactement au language asembleur que j'ai étudié en cours! (En effet, celui que j'ai étudié me parait un peu plus simple, par exemple, utilisation de LD (load), CP,PADDR, PADR, PAOR, ....

J'ai la copie du programme en question, pourriez vous s'il vous plait y jeter un coup d'oeil, et essayer de m'aider, ou de traduire plus simplement (par exemple à quoi correspond movf ou btfsc...? (Si vous voyez de quel language assembleur je veux parler!...)En fait j'utilise un ST7FLITE20 comme microcontroleur (et le programme dont je dispose et fait pour lePIC16f84...) et c'est peut-etre ça le fait que je doive écrire le programme avec l'assembleur plus simpliste?
Aidez-moi!!!!!
Merci A TOUS

include <p16f84.inc>

;;;;;;;;;;;;;;;;;;;;;;;;;
; Defines
;;;;;;;;;;;;;;;;;;;;;;;;;

RS EQU 0x03; RS sur RA3
RW EQU 0x00
E EQU 0x02
DCF EQU 0x01

;;;;;;;;;;;;;;;;;;;;;;;;;
; Variables
;;;;;;;;;;;;;;;;;;;;;;;;;

Minutes EQU 0x1D
Heures EQU 0x11
Jour_Cal EQU 0x12
Jour_Sem EQU 0x13
Mois EQU 0x14
Annee EQU 0x15
VAR EQU 0x16
VAR2 EQU 0x17

Cpt_Tempo EQU 0x18
Cpt_Bit EQU 0x19
Tampon EQU 0x1A
var3 EQU 0x1B
Cpt_test EQU 0x1C
Res_Mi EQU 0x1E
Res_He EQU 0x1F

Min_Msb EQU 0x20
Min_Lsb EQU 0x21
Heu_Msb EQU 0x22
Heu_Lsb EQU 0x23



;;;;;;;;;;;;;;;;;;;;;;;;;
; Début du programme à l'adresse 0H
;;;;;;;;;;;;;;;;;;;;;;;;;

org 0
nop
goto START

;;;;;;;;;;;;;;;;;;;;;;;;;
; Programme principal
;;;;;;;;;;;;;;;;;;;;;;;;;

org 0x10

;;;;;;;;;;;;;;;;;;;;;;;;;
; void main ( void )
;;;;;;;;;;;;;;;;;;;;;;;;;

START:

; configurations des ports
clrf PORTA
bsf STATUS,RP0 ;met en bank 1
;movlw 0x7F
;movwf OPTION_REG ; Port B avec résistances de pull up p.15
clrf TRISB ; PORT B en sortie

movlw 0x02
movwf TRISA ; PORT A en sortie sauf RA2
bcf STATUS,RP0 ; met en bank 0 pour utiliser le port A physiqmt

call INIT

movlw 0X49 ;affichage de "Init"
call PUTCHAR
call TEST_BUSY
movlw 0X4E
call PUTCHAR
call TEST_BUSY
movlw 0X49
call PUTCHAR
call TEST_BUSY
movlw 0X54
call PUTCHAR
call TEST_BUSY
BOUCLE:

call CAPTURE

movlw 0x01 ;effacement de l'afficheur
call CONFIG

movf Heu_Msb,0
call PUTCHAR
call TEST_BUSY

movf Heu_Msb,0
call PUTCHAR
call TEST_BUSY

movf Heu_Lsb,0
call PUTCHAR
call TEST_BUSY

movlw 0x48 ;espace
call PUTCHAR
call TEST_BUSY

movf Min_Msb,0
call PUTCHAR
call TEST_BUSY

movf Min_Lsb,0
call PUTCHAR
call TEST_BUSY


goto BOUCLE

;;;;;;;;;;;;;;;;;;;;;;;;;
; FIN DU MAIN
;;;;;;;;;;;;;;;;;;;;;;;;;



CAPTURE:
; lecture des données de la RAM du microcontrôleur alors (RS=1, RW=1)
bsf PORTA,RS
bsf PORTA,RW
clrf Cpt_Tempo
clrf Cpt_Bit
clrf Minutes
clrf Heures
clrf Tampon
clrf Cpt_test
clrf Res_Mi
clrf Res_He
clrf Heu_Msb
clrf Heu_Lsb
clrf Min_Msb
clrf Min_Lsb


;******detection du début de la trame*****

Scrutation2: ;attente PortA,DCF état bas
clrf Cpt_Tempo
Scrutation:
btfsc PORTA,DCF
goto Scrutation

Scrutation3:
incf Cpt_Tempo,1
movlw 0x63
subwf Cpt_Tempo,0
btfsc STATUS,2
goto Suite
movlw 0x10 ;Tempo de 16 ms
call DELAY
btfss PORTA,DCF
goto Scrutation3
goto Scrutation2
Suite: clrf Cpt_Tempo
Bcf STATUS,2
;***********fin de la détection du bit de start***



;***********Détection du 1er bit significatif******


clrf PORTB
Scrut: ;détection état haut
btfss PORTA,DCF
goto Scrut
Scrut2: ; détection état bas
btfsc PORTA,DCF
goto Scrut2

incf Cpt_Bit,1
movlw 0x15 ;détection du 20ème bit
subwf Cpt_Bit,0
Btfss STATUS,2
goto Scrut

bcf STATUS,2


;***********Fin de la détection du 1er bit significatif******



;***********détection de la valeur des bits significatifs*********


Front:
Btfsc PORTA,DCF ;detection d'un front montant
goto Front
Front_mo:
Btfss PORTA,DCF
goto Front_mo

incf Cpt_Bit,1
movlw 0x50 ;crée une tempo de 150 ms environ
call DELAY
movlw 0x50
call DELAY

btfsc PORTA,DCF ;met à 1 ou à 0 le bit7 de tampon
goto Suite2
bcf Tampon,7
goto Suite3
Suite2:
bsf Tampon,7


;***********Fin détection de la valeur des bits significatifs*********




;***Stockage des valeurs reçues***
Suite3: ;Stockage minutes
movlw 0x1E
subwf Cpt_Bit,0
btfsc STATUS,0 ;test si bit minutes
goto lbl_Heure

bcf STATUS,0 ;decalage à droite de Minutes
rrf Minutes,1

btfss Tampon,7 ;bit reçu appartient aux Minutes
goto lbl_Reset
bsf Minutes,7
goto lbl_Set
lbl_Reset:
bcf Minutes,7
lbl_Set:
goto Front
lbl_Heure: ;Stockage heures
movlw 0x24
subwf Cpt_Bit,0
btfsc STATUS,0 ;test si bit heures
goto Traiter

btfss Tampon,7 ;bit reçu appartient aux heures
goto lbl_Reset2
bsf Heures,7
goto lbl_Set2
lbl_Reset2:
bcf Heures,7
lbl_Set2:
bcf STATUS,0
rrf Heures,1

goto Front
goto Traiter
;lbl_Jour_cal: ;Stockage jours calendaires
; movlw 0x2A
; subwf Cpt_Bit,0
; btfsc STATUS,0 ;test si bit heures
; goto lbl_Jour_sem
;
; btfss Tampon,7 ;bit reçu appartient aux heures
; goto lbl_Reset3
; bsf Jour_Cal,7
; goto lbl_Set3
;lbl_Reset3:
; bcf Jour_Cal,7
;lbl_Set3:
; bcf STATUS,0
; rrf Jour_Cal,1
;
; goto Front

;lbl_Jour_sem:

;*******Traitement****
;**Conversion des données en binaire naturel
;*****Octet des minutes****
Traiter:
bcf STATUS,0
rlf Minutes,1 ;rotation de la parité des minutes(bit à ne pas prendre en compte)

bcf STATUS,0
rlf Minutes,1 ;traitement du bit de poids fort de Minutes

btfss STATUS,0
goto Minute_20
movlw d'40'
addwf Res_Mi,1
Minute_20:
bcf STATUS,0
rlf Minutes,1 ;traitement du bit de (poids fort)-1 de Minutes

btfss STATUS,0
goto Minute_10
movlw d'20'
addwf Res_Mi,1
Minute_10:
bcf STATUS,0
rlf Minutes,1 ;traitement du bit de (poids fort)-2 de Minutes

btfss STATUS,0
goto Minute_8
movlw d'10'
addwf Res_Mi,1
Minute_8:
bcf STATUS,0
rlf Minutes,1 ;traitement du bit de (poids fort)-3 de Minutes

btfss STATUS,0
goto Minute_4
movlw d'8'
addwf Res_Mi,1
Minute_4:
bcf STATUS,0
rlf Minutes,1 ;traitement du bit de (poids fort)-4 de Minutes

btfss STATUS,0
goto Minute_2
movlw d'4'
addwf Res_Mi,1
Minute_2:
bcf STATUS,0
rlf Minutes,1 ;traitement du bit de (poids fort)-5 de Minutes

btfss STATUS,0
goto Minute_1
movlw d'2'
addwf Res_Mi,1
Minute_1
bcf STATUS,0
rlf Minutes,1 ;traitement du bit de poids faible de Minutes

btfss STATUS,0
goto Heure_Par
movlw d'1'
addwf Res_Mi,1

;*****octet des heures
Heure_Par:

bcf STATUS,0
rlf Heures,1 ;traitement du bit de parité des heures

bcf STATUS,0
rlf Heures,1 ;traitement de poids fort des heures

btfss STATUS,0
goto Heure_10
movlw d'20'
addwf Res_He,1

Heure_10:

bcf STATUS,0
rlf Heures,1 ;traitement du bit de poids (fort-1)des heures

btfss STATUS,0
goto Heure_8
movlw d'10'
addwf Res_He,1

Heure_8:
bcf STATUS,0
rlf Heures,1 ;traitement du bit de poids (fort-2) des heures

btfss STATUS,0
goto Heure_4
movlw d'8'
addwf Res_He,1

Heure_4:

bcf STATUS,0
rlf Heures,1 ;traitement du bit de poids(fort-3)des heures

btfss STATUS,0
goto Heure_2
movlw d'4'
addwf Res_He,1
Heure_2:

bcf STATUS,0
rlf Heures,1 ;traitement du bit de poids (fort-4) des heures

btfss STATUS,0
goto Heure_1
movlw d'2'
addwf Res_He,1

Heure_1:
bcf STATUS,0
rlf Heures,1 ;traitement du bit de poids faible des heures

btfss STATUS,0
goto Conversion
movlw d'1'
addwf Res_He,1


;*****Conversion de la valeur binaire en décimal
;Conversion des minutes

Conversion:

movlw 0x0A
subwf Res_Mi,0

btfss STATUS,0
goto Stock

movlw 0x0A
subwf Res_Mi,1
incf Min_Msb,1
goto Conversion

Stock:
movf Res_Mi,0
movwf Min_Lsb

;Conversion des Heures

Conversion2:

movlw 0x0A
subwf Res_He,0

btfss STATUS,0
goto Stock2

movlw 0x0A
subwf Res_He,1
incf Heu_Msb,1
goto Conversion2

Stock2:
movf Res_He,0
movwf Heu_Lsb

;*******Conversion ASCII

movlw 0x30
addwf Min_Msb,1
addwf Min_Lsb,1
addwf Heu_Msb,1
addwf Heu_Lsb,1

return

INIT:

; 2) delay après la mise sous tension
movlw d'20' ; 20 ms
call DELAY

; 3) DL = 1
movlw 0x30 ; initial reset of instruction, MEO function set
call CONFIG

; 4) 4,1 ms mini
movlw d'10' ; 10 ms
call DELAY

; DL = 0
movlw 0x00
call CONFIG

; 5) DL = 1
movlw 0x30
call CONFIG

; 6) 100 us mini
movlw d'1' ; 1 ms
call DELAY

; DL = 0
movlw 0x00
call CONFIG

; 7) DL = 1
movlw 0x30
call CONFIG

; 8) écran occupé ou pas?
call TEST_BUSY

; 9) config du hard : bus 8 bits, 2 lignes, digit 5*7
movlw 0x38
call CONFIG

; 10)
call TEST_BUSY

; 11) DISPLAY MODE : Display ON, Cursor ON, Blink OFF
movlw 0x0E
call CONFIG

; 12)
call TEST_BUSY

; 13) CLEAR DISPLAY
movlw 0x01
call CONFIG

; 14)
call TEST_BUSY

; 15) SHIFT MODE : incrémentation de l'adresse, sans décalage de l'écran
; fonction entry mode set
movlw 0x06
call CONFIG

; 16)
call TEST_BUSY

;;;;;;;;;;;;
; 17) INIT TERMINEE
;;;;;;;;;;;;

return

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; void CONFIG ( char Configuration )
; Cette fonction envoie un octet de configuration à l'écran
; entree : La configuration est dans l'accumulateur W
; sortie : -
; variables détruites :
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

CONFIG: ; sur un frt montant de E, lcd reçoit les instructions
; RS=0, RW=0
bcf PORTA,RS
bcf PORTA,RW

movwf PORTB
bsf PORTA,E
bcf PORTA,E

; RS=1, RW=1
bsf PORTA,RS
bsf PORTA,RW
return

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FIN FONCTION CONFIG
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; void PUTCHAR ( char Caractere )
; Cette fonction affiche un caractere à l'écran
; entree : Le caractere en ASCII est dans l'accumulateur W
; sortie : -
; variables détruites :
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

PUTCHAR:
; RS=1, RW=0
bsf PORTA,RS ; le lcd reçoit des instructions
bcf PORTA,RW ; lcd lit le contenu de l'écran

movwf PORTB
bsf PORTA,E
bcf PORTA,E ; on baisse E pour valider la donnee

; RS=1, RW=1
bsf PORTA,RS
bsf PORTA,RW
return

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FIN FONCTION PUTCHAR
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; void TEST_BUSY ( void )
; Fonction du test du Busy Flag
; Attend que l'écran est disponible
; entree : -
; sortie : -
; variables détruites : -
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

TEST_BUSY:

bcf PORTA,RS ; RS=0
bsf PORTA,RW ; RW=1 (lecture du statut de l'écran)

; on met le port B en entrée pour pouvoir lire
bsf STATUS,RP0 ; banque 1
movlw 0xFF ;
movwf TRISB ; portb en entrée
bcf STATUS,RP0

LOOP_BF:
bcf PORTA,E
nop
nop
bsf PORTA,E
nop
nop
btfsc PORTB,0x07 ; test du busy flag si c'est vrai il saute l'instruction
; sinon il boucle
goto LOOP_BF
bcf PORTA,E

;remise du portb en sortie0
bsf STATUS,RP0 ;met en bank 1
clrf TRISB
bcf STATUS,RP0 ; met en bank 0 pour utiliser le port A physiqmt

;RS=1, RW=1
bsf PORTA,RS
bsf PORTA,RW

return

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FIN FONCTION TEST_BUSY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Fonction de retard DELAY
; entree : temps du retard en ms dans le registre W
; sortie : -
; variables détruites : VAR, VAR2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

DELAY:
bcf STATUS,C ;
movwf VAR
rlf VAR,1 ; multiplie W par 2

LOOP_DELAY:
movlw 0xA5 ; chargemt de 0xff ds l'accu
movwf VAR2 ; var2=0xff
call LOOP2_DELAY
decfsz VAR,1 ; si var différent de 0 var=var-1
goto LOOP_DELAY ; sinon saute l'instruction suivante
return

LOOP2_DELAY: ; deuxieme boucle imbriquee
decfsz VAR2,1
goto LOOP2_DELAY
return

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FIN FONCTION RETARD
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; On sort du programme

;FIN: goto START
end