Université François-Rabelais de Tours

Institut Universitaire de Technologie de Tours

Département Génie Électrique et Informatique Industrielle

VINOT Mitsuaki Enseignants :Groupe P1 LEQUEU Thierry2012-2013

Réception et décodage du signal de l'horloge atomique de Francfort

Expression technique

Université François-Rabelais de Tours

Institut Universitaire de Technologie de Tours

Département Génie Électrique et Informatique Industrielle

VINOT Mitsuaki Enseignants :Groupe P1 LEQUEU Thierry2012-2013

Réception et décodage du signal de l'horloge atomique de Francfort

Expression technique

SommaireIntroduction..........................................................................................................................................41.Cahier des charges et planning..........................................................................................................52.Conception de l'horloge.....................................................................................................................6

2.1.L'afficheur............................................................................................................................62.2.Le récepteur DCF.................................................................................................................82.3.L'ATmega8535.....................................................................................................................92.4.L'alimentation.....................................................................................................................102.5.Le montage.........................................................................................................................11

3.La programmation...........................................................................................................................153.1.La trame de l'horloge atomique de Francfort.....................................................................153.2.Détection de début de trame et comptage des bits.............................................................163.3.Tableau de valeur...............................................................................................................173.4.Décodage et test de parité..................................................................................................18

Conclusion..........................................................................................................................................20Annexe 1.............................................................................................................................................22Annexe 2.............................................................................................................................................25Annexe 3.............................................................................................................................................27

Introduction

Dans le cadre de l’étude & réalisation du semestre 4, nous devions réaliser un projet. Ce projet devait contenir une partie programmation et utiliser un maximum de composants disponibles au magasin de l'IUT. Dans notre humble monôme, nous avons décidé d'étudier et de traiter le décodage de la trame de l'horloge atomique de Francfort.

Dans ce dossier nous allons dans un premier temps nous intéresser au cahier des charges, puis dans un deuxième temps la conception et la réalisation d'une horloge support, et enfin nous nous intéresserons à la partie programmation du projet.

4

1. Cahier des charges et planning

Le but du projet est de récupérer la trame envoyée toutes les minutes par l’horloge atomique basée en Allemagne. Ceci permettra d'obtenir l'heure exacte ainsi que la date et le jour. Le matériel utilisé sera un Atméga 8535 et un récepteur DCF77 AM.

Cahier des charges :

• recevoir le signal• le décoder• le ré-encoder• envoyer les informations par liaison série et/ou parallèle• maintenir le fonctionnement de l’horloge en cas de perte de réception

Utilisation possible :

• Horloge à afficheur 7 segments ou tube Nixie• Module date et heure pour une station de contrôle d’irrigation• ...

Trame1baud

Planning prévisionnel :

Semaines 06 07 08 09 10 11 12 13 14

Prise en main de

Code Vision

X X Vacances

X

Vacances

Programmation

X X X X X X

Oral X

5

Récepteur

DCF

ATmega 8535

Trame série compatible Atmega 16

kbauds

Trame parallèle

(afficheurs)

Après une première programmation, le seul moyen pour valider le programme est de tester avec la trame réelle envoyée depuis Francfort. Pour cela, la conception d'un support est nécessaire. Ce support doit contenir le récepteur DCF, un ATmega 8535 avec son programmateur, un afficheur, et les différentes alimentations de chaque composant du support.

Le planning réel est donc le suivant :

Semaines 06 07 08 09 10 11 12 13 14

Prise en main de

Code Vision

X X Vacances

X

Vacances

Programmation

X X X X

Conception

du support

X X X

Oral X

Dans la suite de ce dossier, nous allons donc suivre la réalisation du support permettant de tester le premier programme.

2. Conception de l'horloge

2.1. L'afficheur

L'afficheur choisi, pour afficher l'heure et la date reçues par l'antenne DCF, sort un peu de l'ordinaire. Cet afficheur est issu de la technologie des tubes fluorescents (VFD : Vacuum Fluoresent Display) apparue dans les années 1980, qui regroupe la technologie des tubes cathodiques et celle des tubes nixie.

6

Illustration 1: Afficheur à tube fluorescent 9 digits

L'afficheur est composé de 9 digits, et chacun de ces digits possède 8 segments, 7 segments pour afficher les chiffres et 1 segment pour le point. Le tout est placé dans un tube en verre. Le principe de fonctionnement de l'afficheur reste cependant élémentaire.

Numéro de patte

Fonction Numéro de patte Fonction

1 2V ou 0V 11 Activation du segment DP

2 Activation du digit n°1 12 Activation du digit n°6

3 Activation du segment G 13 Activation du segment C

4 Activation du digit n°2 14 Activation du digit n°7

5 Activation du segment F 15 Activation du segment B

6 Activation du digit n°3 16 Activation du digit n°8

7 Activation du segment E 17 Activation du segment A

8 Activation du digit n°4 18 Activation du digit n°9

9 Activation du segment D 19 0V ou 2V

10 Activation du digit n°5

Il y a 19 connexions à réaliser pour pouvoir utiliser ce composant. Les deux pattes aux extrémités doivent être alimentées l'une en 2V et l'autre en 0V. Elle correspondent au filament interne qui va augmenter la température à l'intérieur du tube et permettre ainsi de faire fonctionner les segments. Pour afficher un chiffre, il suffit d'activer le digit choisit, puis d'activer tous les segments nécessaires pour former le bon chiffre. Par exemple, pour afficher un 2 sur le digit n°3, il faudra alimenter la patte 6, 17, 15, 3, 7, 9. Les digits se commandent donc l'un après l'autre.

7

Illustration 3: Schéma de l'afficheur vu de face Illustration 2: 8 segments d'un digit

Il est donc nécessaire, pour gérer l'affichage, d'utiliser un composant programmable. Ce sera le rôle de l'ATmega 8535. De plus, pour avoir plusieurs digit allumés en même temps, il faut réaliser un multiplexage, c'est à dire balayer et rafraîchir les 9 digits à une fréquence supérieure à la persistance rétinienne.

2.2. Le récepteur DCF

Il existe dans le commerce beaucoup de circuits récepteurs DCF avec différentes caractéristiques. Il n'a pas été choisi car il y en avait déjà un de disponible à l'IUT.

La platine réceptrice est composée d'une antenne en ferrite et d'un récepteur. L'antenne est réalisée par une bobine et un condensateur montés en parallèle. Le condensateur et la bobine forment un filtre résonnant, et sont dimensionnés pour avoir une résonance à une fréquence de 77,5 kHz, la fréquence d'émission de l'horloge atomique de Francfort. Cette résonnance va servir à capter le signal hertzien. Le signal va ensuite être transmis au récepteur qui va le restituer en une trame lisible par des composants logiques.

Sur l'illustration ci-dessus, le décodeur sera l'ATmega 8535 qui gère donc le décodage de la trame ainsi que l'affichage.

8

Illustration 4: Platine récepteur DCF

Illustration 5: Schéma de principe de réception

2.3. L'ATmega8535

Voici une description succincte des principales caractéristiques de l'ATmega :

Pour résumer en quoi consiste le travail de ce composant, je dirai que c'est un microprocesseur 8 bits programmable avec le logiciel AVR Code Vision. Celui-ci possède 44 pattes dont 24 sont programmables en entrées/sorties numériques (c'est à dire qui reçoivent ou délivrent un signal soit 0 V soit 5V qui sont des équivalent d'un langage numérique binaire fait de 0 et de 1) ; et 8 sont programmable en sorties numériques ou en entrées analogiques ou numériques. C'est à dire que 8 pattes de ce composant permettent une acquisition de données en analogique. Ce composant est donc un Convertisseur Analogique Numérique.

CMOS RISC, ATmega8535 AVR 8-BIT Microcontroller, In-system Programmable with Flash code storage, re-programmble up to 1000 times. Features 32 working registers, single clock cycle execution giving up to 1MIPs/MHz.

Features• 8K BYTES of In-System Programmable Flash • 512 BYTES of In-System Programmable EEPROM • 512 Bytes SRAM • Two 8-bit Timer/Counters with Separate Prescalers and Compare Modes • One 16-bit Timer/Counter with Separate Prescaler, Compare Mode, and Capture

Mode • Real Time Counter with Separate Oscillator • Four PWM Channels • 8-channel, 10-bit ADC -8 Single-ended Channels • Byte-oriented Two-wire Serial Interface • Programmable Serial USART • Master/Slave SPI Serial Interface • Programmable Watchdog Timer with Separate On-chip Oscillator • On-chip Analog Comparator • Power-on Reset and Programmable Brown-out Detection • Internal Calibrated RC Oscillator • External and Internal Interrupt Sources • Six Sleep Modes: Idle, ADC Noise Reduction, Power-save, Power-down, Standby

and Extended Standby • 32 I/O pins

• 4.5 to 5.5V operation, 0 to 16MHz

Source : http://www.kanda.com/products/Atmel/ATmega8535.html

9

2.4. L'alimentation

Nous devons maintenant faire le bilan des alimentations :

l'ATmega 8535 a besoin d'une tension de 5V régulée pour fonctionner,

l'afficheur requiert 2V pour alimenter le filament interne,

également une tension de 15V pour activer les digits, allumer un segment, et enfin alimenter le DCF.

Le courant consommé est très faible. Nous utilisons donc, pour transformer le 230V du secteur, un transformateur moulé à point milieu 230V/2x12V de 1VA seulement. Une fois le 12V redressé par l'intermédiaire de deux diodes puis lissé par un condensateur, nous obtenons une tension de l'ordre des 20V à vide.

De là, nous utilisons ensuite un montage composé d'une diode Zener montée en inverse de tension de seuil de 15V et d'une résistance. En réalité, d'après les calculs de départ, la tension une fois redressée devait être de 17V. Pourtant, une fois la carte d'alimentation réalisée, les mesures montraient 22V de tension continue. Il a donc fallu dépanner le problème sur la carte. Ce montage est schématisé ci-dessous.

Pour permettre un bon fonctionnement de l'ATmega, son alimentation doit être régulée. La solution retenue est classique. Un montage utilisant un circuit intégré LM2574, qui est un hacheur BUCK, permet de réguler facilement la tension de sortie à 5V grâce à un asservissement.

(Voir Annexe 1)

A la sortie du régulateur de tension, nous allons appliquer le même montage à diode Zener qu'avant, en prenant une diode ayant une tension de seuil d'environ 2V cette fois. On réalise ainsi la tension d'alimentation du filament de l'afficheur.

10

Illustration 6: Montage "réducteur" de tension

2.5. Le montage

L'idée supplémentaire dans la réalisation de l'horloge est qu'elle soit de petite taille. Afin de rajouter du volume, l'horloge à été imaginée en deux étages. Un premier étage « socle » recevant le 230V en entrée et distribuant les différentes tensions voulues en sortie. C'est la carte d'alimentation. Et un deuxième étage, recevant en entrée les tensions de l’alimentation, contenant l'ATmega, l'afficheur et le DCF. C'est la carte de traitement.

Pour bien faire, la question à se poser est celle de l'encombrement des composants. Il faut donc d'abord faire le bilan des composants.

2.5.1. Carte d'alimentation

L'alimentation requiert peu d'éléments pour mener à bien son fonctionnement. Elle nécessite un transformateur, un fusible, un interrupteur marche arrêt, un CI à huit pattes, quelques diodes, condensateur et résistance. En somme très peu de composants. Par conséquent cette carte sera réalisée avec des composants discrets.

Voici maintenant le schéma et le typon de l'alimentation réalisés sur le logiciel KiCad :

Il manque sur le schéma, au niveau du 15V, le montage à diode Zener présenté précédemment, ce défaut a été corrigé sur la carte une fois gravée.

11

Illustration 7: schéma de la carte d'alimentation

On remarquera que toutes les pistes qui se trouvent au primaire du transformateur sont d'une taille supérieure ( >3mm) car elles reçoivent 230V.

Lors de la conception du typon, certaines empreintes de composants ont dut être refaites, ce qui m'a obligé à utiliser le logiciel KiCad de façon approfondie.

2.5.2. Carte de traitement

En considérant le nombre important de composants et de connexions à réaliser sur cette carte, notamment à cause de l'Atmega8535 qui possède 44 pattes, l'afficheur est également pourvu de 19 dont 17 pour la gestion de l'affichage. Ces 17 pattes ne sont pas directement reliées à l'ATmega, mais reliées par l'intermédiaire de 17 montages suiveurs à transistor. Le suiveur est un montage classique composé d'un transistor et de deux résistances. Il permet de recopier ce que propose le composant programmable et permet de fournir la puissance nécessaire à l'éclairement des segments.

Par conséquent la technologie de composants utilisée est CMS (Composants Monté en Surface). L'utilisation de cette technologie va permettre de pouvoir placer tous les éléments prévus sur une petite surface.

Voici maintenant le schéma et le typon de la carte de traitement réalisée sur le logiciel KiCad :

(Annexe 2 : schéma de l'horloge)

12

Illustration 8: typon de la carte d'alimentation

Le programmeur de l'Atmega8535 est placé à gauche de la carte. Il sert à implémenter le programme via un ordinateur. Comme les 44 pattes du composant ne sont pas toutes utilisées, les pattes restantes sont déportées pour réaliser des fonctions externes à l'horloge (par exemple commander l'activation d'un réveil).

Une fois les deux carte gravées, soudées et montées, et après l'ajout de la platine DCF, nous obtenons une horloge sans boîtier avec les carte visibles.

13

Illustration 9: Typon de la carte de traitement

14

Illustration 10: Horloge finale

3. La programmation

3.1. La trame de l'horloge atomique de Francfort

Avant de décoder le signal reçu, il faut d'abord le comprendre. L'horloge atomique de Francfort envoie un bit (binary digit) toutes les secondes, et chaque bit a sa signification. Voici un diagramme récapitulatif de la trame DCF.

La partie intéressante pour le projet se trouve à partir du bit 21. De là, on obtient les minutes, les heures, le jour de la semaine et la date. Les bits marqués 1, 2, 4, 8, 10, etc, en s'additionnant en fonction de l'état du bit (0 ou 1) donne le chiffre de la valeur concernée. Et enfin les bits marqué P1, P2, P3 sont des bits de parité. Cela permet de contrôler la validité de ce que l'on vient de recevoir. Par exemple si l'on a :

seconde 29 : bit = 1

seconde 30 : bit = 0

seconde 31 : bit = 1

seconde 32 : bit = 1

seconde 33 : bit =0

seconde 34 : bit =0

seconde 35 (P2) : bit =0

15

Illustration 11: trame de l'horloge atomique de Francfort

On calcule donc l'heure, 1 + 4 + 8 = 13, c'est un nombre impair et le bit de parité est égal à P2=0, on peut donc confirmer que l'on a la bonne heure.

Pour détecter un 0 ou un 1 sur le signal numérique, il faut calculer le temps de niveau haut. Si le temps de niveau haut vaut 200ms c'est un 1, s'il vaut 100ms c'est un 0. Il faut enfin savoir détecter le début de trame, c'est à dire le bit n°1. C'est donc lorsque le temps de niveau bas est supérieur à 1 seconde.

3.2. Détection de début de trame et comptage des bits

Il faut préciser que l'Atmega8535 requiert une horloge externe à quartz, qui envoie des fronts montants à différentes fréquence selon l'horloge choisit. L'atmega8535 effectuera une opération à chaque front montants. Nous utilisons dans notre cas une horloge de fréquence 16 MHz. Elle sera réduite en interne à 250 kHz pour traiter le programme plus facilement.

Tout d'abord, pour détecter un 0 ou un 1 ou encore le début de trame, il faut compter le temps de niveau bas et le temps de niveau haut. Pour cela nous allons utiliser une fonction de l'Atmega8535 appelé « Overflow Interrupt » cette fonction va incrémenter la valeur TCNT0 à chaque front de l'horloge. Lorsque la valeur de TCNT0 atteint 256 il effectue le code que l'on lui a associé.

Dans le code nous allons pour commencer mettre la valeur de TCNT0 à 6, pour que TCNT0 compte seulement 250 valeur. Le code est donc exécuté toutes les 250 000 kHz / 250, ce qui nous donne 1000Hz, ce qui correspond à 1ms. Toute les 1ms nous allons pouvoir faire quelque choses dans la fonction TCNT0.

Surtout nous allons lire l'entrée où le DCF est branché et donc compter le temps à 1 et le temps à 0.

16

Illustration 12: fonctionnement de la trame

// Timer 0 overflow interrupt service routineinterrupt [TIM0_OVF] void timer0_ovf_isr(void){ TCNT0=6; if(PIND.2==0) { temps0++;

temps1=0; } else { temps1++; temps0=0; } if(temps0>1200) { temps0=0; temps1=0; d codage_trame();é test_parite(); n=0;seconde=0; } }

PIND.2 est justement l'entrée du DCF. On voit bien que si (if) cette entrée est à 0 nous ajoutons 1 à la valeur à la variable temps0. Sinon (else) l'entrée est égale à 1 (forcément car il n'existe que 0 ou 1 traduit par une tension de 0V ou 5V), nous pourrons compter de la même façon le temps à 1.

On pourra donc ainsi détecter le début de trame, le temps à 1 et le temps à 0. On peut voir que la détection de début de trame se fait dans cette fonction – Si temps à 0 > 1200ms, donc supérieur à 1,2s alors nous appelons différentes fonction, mais surtout la variable n = 0.

3.3. Tableau de valeur

Cette valeur n, est le pilier de la réception. C'est dans l’interruption externe, qui se trouve exactement sur le PIND.2, que la variable n prend tout son sens. Une interruption externe est une fonction qui se déclenche et qui effectue son code associé lorsque qu'il détecte un front montant. Le moment où l'entrée passe 1, à 5 V...

La variable n va s’incrémenter à chaque front montant. Si on regarde la fonction précédente, n se met à 0 à chaque début de trame, et au front montant suivant il sera égal à 1, puis à 2, puis à 3, etc... Cela correspond au numéro de bit de la trame.

Il y a donc 58 bit par minutes. Nous allons créer un tableau de valeur où la n ème case sera à 0 ou à 1. A chaque front montant la fonction va également regarder si temps à 1 se trouve autour de 100ms ou 200ms et donc remplir la case numéro n du tableau à 0 ou à 1.

17

De cette façon nous pouvons récupérer les 58 bit dans un tableau avec les valeurs correspondantes.

// External Interrupt 0 service routineinterrupt [EXT_INT0] void ext_int0_isr(void){ n++; if(n>58) { n=0; } if((temps1>90)*(temps1<110)) { trame[n]=0; } else { if((temps1>190)*(temps1<210)) { trame[n]=1; } else { //Bug } } temps1=0;

}

3.4. Décodage et test de parité

Ce sont deux fonctions qui vont, avec le tableau rempli, trouver par un calcul simple l'heure, le jour, la date. La fonction test_parité, teste la parité.

void decodage_trame(void){ minute_recu=trame[21]+2*trame[22]+4*trame[23]+8*trame[24]+10*trame[25]+20*trame[26]+40*trame[27]; heure_recu=trame[29]+2*trame[30]+4*trame[31]+8*trame[32]+10*trame[33]+20*trame[34]; datejour_recu=trame[36]+2*trame[37]+4*trame[38]+8*trame[39]+10*trame[40]+20*trame[41]; datemois_recu=trame[45]+2*trame[46]+4*trame[47]+8*trame[48]+10*trame[49]; jour_recu=trame[42]+2*trame[43]+4*trame[44]; }

void test_parite (void){ for(i=21;i==27;i++) { K= K + trame[i]; }; if((K+trame[28])%2==0) { minute=minute_recu; K=0; } for(i=29;i==34;i++) { K= K + trame[i];

18

}; if((K+trame[35])%2==0) { heure=heure_recu; K=0; } for(i=36;i==57;i++) { K= K + trame[i]; }; if((K+trame[58])%2==0) { //afficher date jour //afficher date mois jour=jour_recu; K=0; }}

Le programme complet se trouve en annexe 3.

19

Conclusion

Nous avons trouvé le projet très intéressant et très enrichissant. Il a permis notamment de découvrir l'électronique en CMS qui s'est avéré être une technologie pratique, efficace et plus facile à utiliser qu'il n'y paraît. Nous avons également pu mettre en œuvre l'Atmega8535 et découvrir toutes ses fonctionnalités. Un composant que notre monôme voulait déjà mettre en place depuis un certain temps déjà.

L'ensemble du programme fonctionne correctement, il reste cependant la réception et d'autres détails à régler afin de terminer le projet.

Pour améliorer le projet nous envisageons de changer l'antenne réceptrice par une autre plus encombrante de façon à mieux recevoir le signal.

20

Index des illustrationsIllustration 1: Afficheur à tube fluorescent 9 digits..............................................................................6Illustration 2: 8 segments d'un digit......................................................................................................7Illustration 3: Schéma de l'afficheur vu de face...................................................................................7Illustration 4: Platine récepteur DCF....................................................................................................8Illustration 5: Schéma de principe de réception...................................................................................8Illustration 6: Montage "réducteur" de tension...................................................................................10Illustration 7: schéma de la carte d'alimentation................................................................................11Illustration 8: typon de la carte d'alimentation...................................................................................12Illustration 9: Typon de la carte de traitement....................................................................................13Illustration 10: Horloge finale............................................................................................................14Illustration 11: trame de l'horloge atomique de Francfort..................................................................15Illustration 12: fonctionnement de la trame........................................................................................16

Annexe 1

22

23

24

Annexe 2

25

26

Annexe 3

27

/*****************************************************This program was produced by theCodeWizardAVR V2.03.4 StandardAutomatic Program Generator© Copyright 1998-2008 Pavel Haiduc, HP InfoTech s.r.l.http://www.hpinfotech.com

Project : Version : Date : 21/03/2013Author : Company : Comments:

Chip type : ATmega8535Program type : ApplicationClock frequency : 16,000000 MHzMemory model : SmallExternal RAM size : 0Data Stack size : 128*****************************************************/

#include <mega8535.h>#include <stdio.h>#include <DELAY.h>

int horloge=0; int temps0;int temps1; unsigned char trame[60]; //Tableau de la trameunsigned char n; //Numero de bit de la traMEunsigned char seconde,minute,heure,jour;unsigned char minute_recu,heure_recu,datejour_recu,datemois_recu,jour_recu;unsigned char i,K;unsigned char conversion;

// External Interrupt 0 service routineinterrupt [EXT_INT0] void ext_int0_isr(void){ n++; if(n>58) { n=0; } if((temps1>90)*(temps1<110)) { trame[n]=0; PORTC.5=0; } else { if((temps1>190)*(temps1<210)) { trame[n]=1; PORTC.5=1; } else { //Bug } } temps1=0;

}

void decodage_trame(void){ minute_recu=trame[21]+2*trame[22]+4*trame[23]+8*trame[24]+10*trame[25]+20*trame[26]+40*trame[27]; heure_recu=trame[29]+2*trame[30]+4*trame[31]+8*trame[32]+10*trame[33]+20*trame[34]; datejour_recu=trame[36]+2*trame[37]+4*trame[38]+8*trame[39]+10*trame[40]+20*trame[41]; datemois_recu=trame[45]+2*trame[46]+4*trame[47]+8*trame[48]+10*trame[49]; jour_recu=trame[42]+2*trame[43]+4*trame[44]; }

28

void test_parite (void){ for(i=21;i==27;i++) { K= K + trame[i]; }; if((K+trame[28])%2==0) { minute=minute_recu; K=0; } for(i=29;i==34;i++) { K= K + trame[i]; }; if((K+trame[35])%2==0) { heure=heure_recu; K=0; } for(i=36;i==57;i++) { K= K + trame[i]; }; if((K+trame[58])%2==0) { //afficher date jour //afficher date mois jour=jour_recu; K=0; }}

void AfficheurChiffre(unsigned char VAL){ switch (VAL) { case 0: { PORTC.0=0; PORTC.2=0; PORTC.4=0; PORTC.6=1; PORTA.7=0; PORTA.5=0; PORTA.3=0; PORTA.1=1; } break; case 1: { PORTC.0=1; PORTC.2=0; PORTC.4=0; PORTC.6=1; PORTA.7=1; PORTA.5=1; PORTA.3=1; PORTA.1=1; } break; case 2: { PORTC.0=0; PORTC.2=0; PORTC.4=1; PORTC.6=1; PORTA.7=0; PORTA.5=0; PORTA.3=1; PORTA.1=0; } break; case 3: { PORTC.0=0; PORTC.2=0; PORTC.4=0; PORTC.6=1; PORTA.7=0; PORTA.5=1; PORTA.3=1; PORTA.1=0;

29

} break; case 4: { PORTC.0=1; PORTC.2=0; PORTC.4=0; PORTC.6=1; PORTA.7=1; PORTA.5=1; PORTA.3=0; PORTA.1=0; } break; case 5: { PORTC.0=0; PORTC.2=1; PORTC.4=0; PORTC.6=1; PORTA.7=0; PORTA.5=1; PORTA.3=0; PORTA.1=0; } break; case 6: { PORTC.0=0; PORTC.2=1; PORTC.4=0; PORTC.6=1; PORTA.7=0; PORTA.5=0; PORTA.3=0; PORTA.1=0; } break; case 7: { PORTC.0=0; PORTC.2=0; PORTC.4=0; PORTC.6=1; PORTA.7=1; PORTA.5=1; PORTA.3=1; PORTA.1=1; } break; case 8: { PORTC.0=0; PORTC.2=0; PORTC.4=0; PORTC.6=1; PORTA.7=0; PORTA.5=0; PORTA.3=0; PORTA.1=0; } break; case 9: { PORTC.0=0; PORTC.2=0; PORTC.4=0; PORTC.6=1; PORTA.7=0; PORTA.5=1; PORTA.3=0; PORTA.1=0; } break; } }

30

void AfficheurTiret(){ PORTC.0=1; PORTC.2=1; PORTC.4=1; PORTC.6=1; PORTA.7=1; PORTA.5=1; PORTA.3=1; PORTA.1=0; }

// Timer 0 overflow interrupt service routineinterrupt [TIM0_OVF] void timer0_ovf_isr(void){ TCNT0=6; horloge++; if(horloge>999) { seconde++; horloge=0; } if (seconde>59) { minute++; seconde=0; } if (minute>59) { minute=0; heure++; } if (heure>23) { heure=0; jour++; } if (jour>6) { jour=0; } if(PIND.2==0) { temps0++; } else { temps1++; temps0=0; } if(temps0>1200) { temps0=0; temps1=0; decodage_trame(); //test_parite(); n=0;//seconde=0; } }

// Declare your global variables here

void main(void){// Declare your local variables here

// Input/Output Ports initialization// Port B initialization// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In // State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T PORTB=0xFF;DDRB=0xFF; PORTA=0xFF;DDRA=0xFF;

// Port C initialization// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In // State6=T State5=T State4=T State3=T State2=T State1=T State0=T PORTC=0xFF;DDRC=0xFF;

// Port D initialization// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In // State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T PORTD=0x80;DDRD=0x80;

31

// Timer/Counter 0 initialization// Clock source: System Clock// Clock value: 250,000 kHzTCCR0=0x03;TCNT0=0x00;

// Timer/Counter 1 initialization// Clock source: System Clock// Clock value: Timer 1 Stopped// Mode: Normal top=FFFFh// OC1A output: Discon.// OC1B output: Discon.// Noise Canceler: Off// Input Capture on Falling Edge// Timer 1 Overflow Interrupt: Off// Input Capture Interrupt: Off// Compare A Match Interrupt: Off// Compare B Match Interrupt: OffTCCR1A=0x00;TCCR1B=0x00;TCNT1H=0x00;TCNT1L=0x00;ICR1H=0x00;ICR1L=0x00;OCR1AH=0x00;OCR1AL=0x00;OCR1BH=0x00;OCR1BL=0x00;

// Timer/Counter 2 initialization// Clock source: System Clock// Clock value: Timer 2 Stopped// Mode: Normal top=FFh// OC2 output: DisconnectedASSR=0x00;TCCR2=0x00;TCNT2=0x00;OCR2=0x00;

// External Interrupt(s) initialization// INT0: On// INT0 Mode: Rising Edge// INT1: OffGICR|=0x40;MCUCR=0x03;GIFR=0x40;

// Timer(s)/Counter(s) Interrupt(s) initializationTIMSK=0x01;

// USART initialization// Communication Parameters: 8 Data, 1 Stop, No Parity// USART Receiver: Off// USART Transmitter: On// USART Mode: Asynchronous// USART Baud Rate: 9600UCSRA=0x00;UCSRB=0x48;UCSRC=0x86;UBRRH=0x00;UBRRL=0x67;

// Analog Comparator initialization// Analog Comparator: Off// Analog Comparator Input Capture by Timer/Counter 1: OffACSR=0x80;SFIOR=0x00;

// Global enable interrupts#asm("sei")

32

while (1) { //putchar(minute_recu); PORTA.0=0; conversion = heure/10; AfficheurChiffre(conversion); //Affiche les Dizaines delay_ms(2); PORTA.0=1; PORTA.2=0; conversion = heure%10; AfficheurChiffre(conversion); //Affiche les unit sé delay_ms(2); PORTA.2=1; PORTA.4=0; AfficheurTiret(); delay_ms(2); PORTA.4=1; PORTA.6=0; conversion = minute/10; AfficheurChiffre(conversion); delay_ms(2); PORTA.6=1; PORTC.7=0; conversion = minute%10; AfficheurChiffre(conversion); delay_ms(2); PORTC.7=1; PORTC.5=0; AfficheurTiret(); delay_ms(2); PORTC.5=1; PORTC.3=0; conversion = seconde/10; AfficheurChiffre(conversion); delay_ms(2); PORTC.3=1; PORTC.1=0; conversion = seconde%10; AfficheurChiffre(conversion); delay_ms(2); PORTC.1=1; PORTD.7=0; AfficheurTiret(); delay_ms(2); PORTD.7=1; };}

33