Compteur minute pic16f628a sur 4 afficheurs 7 segments..

[nodoubtman]

Bonjour et bonne année à tous et à toutes!
J'essaie de réaliser un compteur de minutes avec un pic16f628a, avec une interruption à chaque 60 secondes avec le TMR0, voici le code :

unsigned short i, DD0, DD1, DD2, DD3;
sbit segment_deux_points at RA4_BIT;
unsigned int count_heure, count_minute;
unsigned short count, Num, Num2Points;


//------ Function to Return mask for common anode 7-seg. display
unsigned short mask(unsigned short num) {
 switch (num) {
 case 0 : return 0xC0;
 case 1 : return 0xF9;
 case 2 : return 0xA4;
 case 3 : return 0xB0;
 case 4 : return 0x99;
 case 5 : return 0x92;
 case 6 : return 0x82;
 case 7 : return 0xF8;
 case 8 : return 0x80;
 case 9 : return 0x90;
 } //case end
}

void Debounce(){
 Delay_ms(300);
}


void interrupt() {
  Num ++;           // Interrupt causes Num to be incremented by 1
  Num2Points ++;
  
  if (Num2Points == 18) {   // clignote les : à chaque seconde
   segment_deux_points = ~segment_deux_points;
   Num2Points = 0;
  }

if (Num == 1080) {       // 1 minute      (18*60)
   Sound_Play(1500, 500);
   Delay_ms(500);
   // count = count + 1;
   Num = 0;
  }

  TMR0 = 39;        // TMR0 returns to its initial value
  INTCON.T0IF = 0;  // Bit T0IF is cleared so that the interrupt could reoccur
}

void main() {
  CMCON  |= 7;        // Disable Comparators
  TRISB = 0x00;       // Set PORTB direction to be output
  PORTB = 0xff;       // Turn OFF LEDs on PORTB
  PORTA = 0x00;
  TRISA = 0x00;
  count = 0;          // initialize minute to display to 7 segment display

  Num = 0;
  Num2Points = 0;
  
  OPTION_REG = 0x07; // Prescaler (1:256) is assigned to the timer TMR0
  TMR0 = 39;         // Timer T0 counts from 39 to 255
  INTCON = 0xA0;     // Enable interrupt TMR0 and Global Interrupts
  Sound_Init(&PORTA, 5);
  segment_deux_points = 0;
  
 do {
  DD0 = count%10;  // Extract Ones Digit
  DD0 = mask(DD0);
  DD1 = (count/10)%10; // Extract Tens Digit
  DD1 = mask(DD1);
  DD2 = (count/100)%10; // Extract Hundreds Digit
  DD2 = mask(DD2);
  DD3 = (count/1000);  // Extract Thousands Digit
  DD3 = mask(DD3);

  for (i = 0; i<=50; i++) {
      PORTB = DD0;
      RA0_bit = 0;      // Select Ones Digit
      RA1_bit = 1;
      RA2_bit = 1;
      RA3_bit = 1;
      delay_ms(5);
      PORTB = DD1;
      RA0_bit = 1;
      RA1_bit = 0;     // Select Tens Digit
      RA2_bit = 1;
      RA3_bit = 1;
      delay_ms(5);
      PORTB = DD2;
      RA0_bit = 1;
      RA1_bit = 1;
      RA2_bit = 0;     // Select Hundreds Digit
      RA3_bit = 1;
      delay_ms(5);
      PORTB   = DD3;
      RA0_bit = 1;
      RA1_bit = 1;
      RA2_bit = 1;
      RA3_bit = 0;     // Select Thousands Digit
      delay_ms(5);
      }
     } while(1);          // endless loop
}

mais mon problème c'est qu'on dirait le compteur Num n'est jamais égal à 1080, mon pic fonctionne sous 4 Mhz
donc si le num == 14 ca fait 1 seconde, pas de problème là-dessus...
Je me suis dis si 14 == 1 sec, donc 1080 fais 1 minutes, donc j'incrémente le count = count + 1 à chaque minute et
je l'affiche sur l'afficheurs 7 segments, malheureusement on dirait qu'il ne se rend jamais là..
J'ai ajouté le schéma en fichier joints.
pourrirez-vous m'aider à résoudre mon problème?
Ça serait très apprécié!
Merci les amis!
A+!
marC
-----

[invite03481543]

mais mon problème c'est qu'on dirait le compteur Num n'est jamais égal à 1080, mon pic fonctionne sous 4 Mhz
donc si le num == 14 ca fait 1 seconde, pas de problème là-dessus...
Je me suis dis si 14 == 1 sec, donc 1080 fais 1 minutes, ....

Bonsoir,

1mn faisant 60s et si 1s fait 14 au compteur, je ne vois pas comment 1080 ferait 14*60 (puisque faisant 840)....

[invite03481543]

Je vous ai mis en rouge quelques corrections.
Vous devez declarer Num et Num2Points comme variable volatile puisque modifiee en interruption.

void interrupt() {

if(T0IF)
 {
  Num ++;           // Interrupt causes Num to be incremented by 1
  Num2Points ++;
  
  if (Num2Points == 18) {   // clignote les : à chaque seconde
   segment_deux_points = !segment_deux_points; // Il s'agit d'un bit donc on inverse avec: !
   Num2Points = 0;
  }
if (Num == 1080) {       // 1 minute      (18*60)
   Sound_Play(1500, 500);
   Delay_ms(500);
   // count = count + 1;
   Num = 0;
  }
  TMR0 = 39;        // TMR0 returns to its initial value
  INTCON.T0IF = 0;  // Bit T0IF is cleared so that the interrupt could reoccur
}
}

[nodoubtman]

Variable voltatile?

comme quoi??
et on dirait que l'afficheur rendu à 1 min, ne s'affiche pas... on dirait meme que le Num == 840 ne survient jamais

merci!
A+!
marC

[A voir en vidéo sur Futura]

[invite03481543]

Je n'ai pas verifier vos timings selon vos declarations sur Timer0 mais plusieurs choses a faire:

Dites si actuellement le point decimal clignote bien au rythme de la seconde et prevoyer un autre point decimal pour la minute que vous laisserez actif une minute et eteint la minute suivante, au moins vous saurez si ca passe bien dans les if de l'interruption.
Vous pouvez vous contentez d'une seule variable pour les minutes et les secondes avec count comme vous l'aviez prevu

[nodoubtman]

OPTION_REG = 0x07; // Prescaler (1:256) is assigned to the timer TMR0
TMR0 = 39; // Timer T0 counts from 39 to 255
INTCON = 0xA0; // Enable interrupt TMR0 and Global Interrupts



dans le main

[invite03481543]

volatile unsigned short count, Num, Num2Points;

[nodoubtman]

il ne se rend jamais à 840

je ne sais plus quoi faire... je voudrais faire un horloge... mais si ça ne fonctionne pas.. et bien je suis malpris..

A+!
marC

[invite03481543]

OPTION_REG = 0x07; // Prescaler (1:256) is assigned to the timer TMR0
TMR0 = 39; // Timer T0 counts from 39 to 255
INTCON = 0xA0; // Enable interrupt TMR0 and Global Interrupts

4MHz represente un clock de 1micro seconde puisque Fclock=Fosc/4
Avec le prescaler a 256 cela fait une interruption timer en 256*256*1=65536 microsecondes

Donc pour 1s cela fait: 1000000/65536=15.258 tour de timer

Pour avoir un compte rond on charge le timer avec un offset pour avoir 62500
Verification: 62500*16=0.999s

Donc il faut precharger le timer avec 12 soit 0x0C et attendre la 16eme interruption timer pour avoir 1s.

A verifier.

[nodoubtman]

il ne se rend jamais à 960 (donc 1 minute)...

j'ai essayé :

void interrupt() {

if (T0IF == 1) {
Num2Points++; // Interrupt causes Num to be incremented by 1


if (Num2Points == 960) {
segment_deux_points = !segment_deux_points; // Il s'agit d'un bit donc on inverse avec: !
Num2Points = 0; }

TMR0 = 0x0C; // TMR0 returns to its initial value 12
INTCON.T0IF = 0; // Bit T0IF is cleared so that the interrupt could reoccur
}
}

je ne sais plus quoi faire?

merci!

[invite03481543]

Essaye avec ce code et dis moi si ca clignote au rythme de la seconde.

sbit segment_deux_points at RA4_BIT;  // ATTENTION! RA4 est de type open drain donc il faut un pull-up ou mettre la led et la resistance serie associee au +Vcc
volatile unsigned short count, Num, Num2Points;


void interrupt() {
 if(T0IF)
 {
  TMR0 = 12;        // TMR0 returns to its initial value
   INTCON.T0IF = 0;  // Bit T0IF is cleared so that the interrupt could reoccur

  Num ++;           // Interrupt causes Num to be incremented by 1
  Num2Points ++;
  
  if (Num2Points == 16) {   // clignote les : à chaque seconde
   segment_deux_points = !segment_deux_points;
   Num2Points = 0;
  }
if (Num == 960) {       // 1 minute      (16*60)
   Sound_Play(1500, 500);
   Delay_ms(500);
   // count = count + 1;
   Num = 0;
   }
  }
}
void main() {
  CMCON  |= 7;        // Disable Comparators
  TRISB = 0x00;       // Set PORTB direction to be output
  PORTB = 0xff;       // Turn OFF LEDs on PORTB
  PORTA = 0x00;
  TRISA = 0x00;
  count = 0;          // initialize minute to display to 7 segment display
  Num = 0;
  Num2Points = 0;
  
  OPTION_REG = 0x07; // Prescaler (1:256) is assigned to the timer TMR0
  TMR0 = 12;         // Timer T0 counts from 12 to 255
  INTCON = 0xA0;     // Enable interrupt TMR0 and Global Interrupts
  Sound_Init(&PORTA, 5);
  segment_deux_points = 0;
while(1);
  
 }

[nodoubtman]

met le segment deux points clignote à chaque seconde == 16
et non à 960 (1 minute)

je ne comprends plus rien...

A+!
marC

[invite03481543]

Pourquoi RA4 n'apparait pas sur ton schema?
Je t'ai mis un commentaire sur RA4 qui est de type open drain, il faut que ta led et sa resistance soit branchee au +Vcc pour que cette sortie puisse etre utilisee en tout ou rien.

[invite03481543]

met le segment deux points clignote à chaque seconde == 16
et non à 960 (1 minute)

je ne comprends plus rien...

A+!
marC

Les deux points comme tu dis doivent clignoter a chaque seconde donc apres 16 comptage de timer0.
Une fois que cela fonctionnera tu pourras les utiliser avec le comptage par 960 pour verifier la minute.
Ensuite seulement tu pourras implanter tes segments et tes digits.
Il faut toujours travailler avec un code simple et le faire fonctionner et implementer petit a petit le reste sans quoi tu vas t'y perdre.

[invite03481543]

Et a chaque fois poste moi le code avec lequel tu fais tes essais sinon c'est moi qui ne vais plus te suivre...

[nodoubtman]

J'ai essayé avec une led sur un output sur le PORTA3...
la led ne s'allume jamais... j'ai bien mis 1 min 16*60 = 960... :~(

sbit LED at RA3_BIT;
volatile unsigned short count, Num;

void interrupt()
{
if (T0IF == 1) {

 Num++;           // Interrupt causes Num to be incremented by 1

  if (Num == 960) {
     LED = !LED;

   Num = 0;  
 }
}
  TMR0 = 0x0C;        // TMR0 returns to its initial value 12
  INTCON.T0IF = 0;   // Bit T0IF is cleared so that the interrupt could reoccur
}

void main() {
  CMCON  |= 7;        // Disable Comparators
  TRISA = 0x00;
  TRISB = 0x00;       // Set PORTB direction to be output
  PORTB = 0xff;       // Turn OFF LEDs on PORTB
  PORTA = 0x00;
  count = 0;          // initialize minute to display to 7 segment display

  Num = 0;
  
  OPTION_REG = 0x07; // Prescaler (1:256) is assigned to the timer TMR0
  TMR0 = 0x0C;          // Timer T0 counts from 12 to 255
  INTCON = 0xA0;     // Enable interrupt TMR0 and Global Interrupts

do {

while (1);
}
}

Merci bien!

[nodoubtman]

Salut!

Je voulais juste te dire que j'ai finalement résous ma solution en ajoutant une autre variable hihihi :P

void interrupt() {
  Num2Points++;           // Interrupt causes Num to be incremented by 1

  if (Num2Points == 16) {
    compteur2 = compteur2 + 1;
    segment_deux_points = !segment_deux_points; // Il s'agit d'un bit donc on inverse avec: !
    Num2Points = 0;

     if (compteur2 == 60) {
      if (count == 2359) count = 0;
       count = count + 1;
       compteur2 = 0;
     }
   }
  TMR0 = 0x0C;        // TMR0 returns to its initial value 12
  INTCON.T0IF = 0;   // Bit T0IF is cleared so that the interrupt could reoccur
}

Merci de tout coeur de l'aide!

A++!
marC
BOnne année à toi!

[invite03481543]

Normalement ça devrait fonctionner avec le précédent code, celui que tu postes ne change rien, plus grave il n'est même pas correct
A la moindre interruption Num2points va s'incrémenter, il faut toujours invoquer la source d'interruption qui doit être gérée, dans ton cas if(T0IF).
C'est quoi ton compilateur C?

[nodoubtman]

mikroC PRO

merci!
A+!
marC

[nodoubtman]

Bonsoir! J'ai finis mon réveil matin, horloge en temps réel avec affichage seconde par seconde, et j'ai réussis!
Merci à toi!
Là un peu plus complexe, je cherche à faire le même genre de truc mais un programmateur de cafetière ou chaîne hi-fi, avec relais.
L'utilisateur a plusieurs boutons poussoirs, un heure horloge, un minute horloge, un réveil heure, un réveil minute(réveil == mettre à on l'appareil).
quand je teste pour voir si c'est l'heure de mettre le relais à ON :

i

int Regarder_Si_Heure_Reveil(){  // voir si c'est l'heure du réveil
 if ((alarme_heure[0] == heure[0]) && (alarme_heure[1] == heure[1]) &&
    (alarme_minute[0] == minute[0]) && (alarme_minute[1] == minute[1])) {
  goto stop;
 }
 return 0;
 stop : return 1;
}

void interrupt()
{
if ((T0IF) && (Drapeau_heure == 0) && (Drapeau_minute == 0) && (drapeau_alarme_heure == 0) &&
    (drapeau_alarme_minute == 0)) {
 Num++;

 if(Num == 18) {  // à chaque seconde...
   Num = 0;
   heure_du_reveil = Regarder_Si_Heure_Reveil();

   if (heure_du_reveil == 1) RELAY = 1;
   if (heure_du_reveil == 0) RELAY = 0;

}
}

oui pas de problème, sauf avec mon TMR0 et mon interruption à chaque seconde, quand la minute va changer, mon relais va se mettre à OFF automatiquement, je veux qu'il reste à ON,
j'ai essayer de faire des compteurs pour vérifier l'était du relais, mais on dirait que le pic16f628a l'ignore complètement il fait à sa tête..

 if ( (heure_du_reveil == 1) && (cptReveil == 0) ){ // C'est le temps du réveil...
     cptReveil++;              // On est passé par ici au moins une fois donc.. on laisse toujours le relais ouvert
     if (cptReveil > 1) cptReveil = 1;
     RELAY = 0;
     }

 if (heure_du_reveil == 0)
 {
  if (cptReveil == 1) RELAY = 0;
  if (cptReveil == 0) RELAY = 1;
 }

j'ai besoin d'aide svp, comment puis-je m'y prendre afin de réaliser ce beau projet

Merci de tout coeur!
A+!
marC
}

[invite03481543]

Ta gestion du relais n'a rien à faire en interruption, il suffit juste que chaque minute tu lèves un drapeau qui sera géré dans le programme principal, ton µC ne fait rien qu'attendre donc tu ne seras pas en retard.
Tu utilises une variable (volatile) par exemple volatile char minute_test_reveil qui passera à 1 chaque minute en interruption, qui provoquera dans le programme principal un test de ta fonction Regarder_Si_Heure_Reveil().
Pas besoin de retour avec cette fonction donc tu peux la déclarer en void Regarder_Si_Heure_Reveil(void) tout simplement.
Si le test n'est pas ok tu remets la variable à 0 et rebelote la minute suivante, c'est pas plus compliqué que ça.

[invite03481543]

Et évite les goto en C ce n'est pas indispensable.

[invite03481543]

Ensuite pour ton histoire de relais, si l'heure du réveil est atteinte tu mets le relais à 1 "tant que" un contre ordre n'est pas donné.
Par exemple while(bouton_stop == 0) RELAY=1 et si bouton stop est appuyé il passera à 1 (par exemple ou l'inverse peu importe ce que tu auras choisi comme niveau logique actif) et dans ce cas le relais sera mis OFF.
Ainsi à chaque test ton relais restera activé puisque seule la condition sur le bouton stop sera testée.
@+

[nodoubtman]

Merci bien mon ami Hulk!

A+!
marC

[nodoubtman]

Salut Hulk!
Mon projet de relais est terminé. Alors maintenant je suis en train de programmer un horloge en temps réel avec les secondes par secondes, mais
mon problème c'est que le compteur compte 0,1,2,4,5,7,8,10. Mais il est supposé de compteur 0,1,2,3,4,5,6,7,8,9, ensuite augmenter les minutes..etc..

voici ma routine d'interruption, je crois que cela pose problème, dites moi ce que vous en pensez, et vos recommandation:

void interrupt()
{
if ((T0IF) && (Drapeau_heure == 0) && (Drapeau_minute == 0) ) {
 Num++;

 if(Num == 18) {  // à chaque seconde...
   Num = 0;
   OneSec ++;      // Increase sec
   secondes ++;
   Num2Points = ~Num2Points;
   if (secondes == 60) secondes = 0;
  }

 if (OneSec == 60) // à chaque minute (60 secondes == 1 minute)
       {
        count_minute_horloge = count_minute_horloge + 1;
        if (count_minute_horloge == 60) {
         count_heure_horloge = count_heure_horloge + 1;
         count_minute_horloge = 0;
         secondes = 0;
         }
        if (count_heure_horloge == 24) count_heure_horloge = 0;
        // réinitialisation du compteur OneSec pour donner
        // toujours 60 secondes à chaque fois sinon on le perd...
         OneSec = 0;
       }

    TMR0 = 39;           // Timer T0 counts from 39 to 255
    INTCON.T0IF = 0;    // Bit T0IF is cleared so that the interrupt could reoccur
 }
}

voici mon main() :

void main() 
{
  OPTION_REG = 0x07; // Prescaler (1:256) is assigned to the timer TMR0
  TMR0 = 39;         // Timer T0 counts from 39 to 255
  INTCON = 0xA0;     // Enable interrupt TMR0 and Global Interrupts
 // etc...
 
 
 Afficher_Heure();
}

Merci beacoup encore!!!
A+!
marC

[invite03481543]

Il me faut le code complet avec ta fonction Afficher_Heure() et tes declaratifs de variables.

[nodoubtman]

Voici mon programme complet, ca affiche les secondes au complet de 0 à 59, mais l'horloge se désynchronise de 2 mins...

Merci de m'aider Hulk..

/***************************************
* Marc HORLOGE 7 segment COMPLET avec  *
* affichage des secondes en temps réel *
* Microcontrôleur utilisé PIC16887     *
* de type HH:MM:SS cathode commune     *
* Avec quartz 4 Mhz pour précision     *
* Date début : 12-01-2013              *
* Date fin   : 15-01-2013              *
* Copyright (c) Marc Paradis 2013      *
****************************************/

// Début déclaration variables
unsigned short i, DD0, DD1, DD2, DD3, DD4, DD5;
unsigned short Num;
unsigned short compteur, compteur2, calc_time, drapeau_minute, drapeau_heure, unit, dix,flag;
unsigned short count_heure_horloge, count_minute_horloge;
unsigned short Blink;
volatile unsigned short secondes;
unsigned short compteur_one_minute;
// Fin déclaration variables

// Déclaration input
sbit bouton_set_heure at RE1_BIT;      // pic 9
sbit bouton_set_minute at RE0_BIT;     // pic 8
sbit bouton_reset_secondes at RE2_BIT; // pic 10
// Fin déclaration input

// Déclaration output
sbit Num2Points at RD6_BIT;            // pic 29
// Fin déclaration output

//------ Function to Return mask for common anode 7-seg. display en hexadécimal
unsigned short mask(unsigned short num) {
 switch (num) {
 case 0 : return 0xC0;
 case 1 : return 0xF9;
 case 2 : return 0xA4;
 case 3 : return 0xB0;
 case 4 : return 0x99;
 case 5 : return 0x92;
 case 6 : return 0x82;
 case 7 : return 0xF8;
 case 8 : return 0x80;
 case 9 : return 0x90;
 }
}

void Debounce(){
 Delay_ms(300);
}

void Afficher_Heure()
{
 for (i = 0; i<=50; i++) {
      PORTC = DD0;
      RD0_bit = 0;    // 19  // Select Ones Digit
      RD1_bit = 1;    // 20
      RD2_bit = 1;    // 21
      RD3_bit = 1;    // 22
      RD4_bit = 1;    // 27
      RD5_bit = 1;    // 28
      delay_ms(3);
      PORTC = DD1;
      RD0_bit = 1;
      RD1_bit = 0;
      RD2_bit = 1;
      RD3_bit = 1;
      RD4_bit = 1;
      RD5_bit = 1;
      delay_ms(5);
      PORTC = DD2;
      RD0_bit = 1;
      RD1_bit = 1;
      RD2_bit = 0;
      RD3_bit = 1;
      RD4_bit = 1;
      RD5_bit = 1;
      delay_ms(5);
      PORTC = DD3;
      RD0_bit = 1;
      RD1_bit = 1;
      RD2_bit = 1;
      RD3_bit = 0;
      RD4_bit = 1;
      RD5_bit = 1;
      delay_ms(5);
      PORTC = DD4;
      RD0_bit = 1;
      RD1_bit = 1;
      RD2_bit = 1;
      RD3_bit = 1;
      RD4_bit = 0;
      RD5_bit = 1;
      delay_ms(5);
      PORTC = DD5;
      RD0_bit = 1;
      RD1_bit = 1;
      RD2_bit = 1;
      RD3_bit = 1;
      RD4_bit = 1;
      RD5_bit = 0;
      delay_ms(5);
  }
}

// ISR
// À chaque débordement du TMR0 on passe par ici, il compte de 39 à 255
void interrupt()
{
if (T0IF) 
 {
 Num++;
 if(Num == 18) {  // à chaque seconde...
   Num = 0;
   Blink = !Blink;
  }
   TMR0 = 39;          // Timer T0 counts from 39 to 255
   INTCON.T0IF = 0;   // Bit T0IF is cleared so that the interrupt could reoccur
  }
}
    
void main() {
  ANSEL  = 0;        // Configure AN pins as digital I/O
  ANSELH = 0;
  C1ON_bit = 0;     // Disable comparators
  C2ON_bit = 0;

  TRISA = 0x00;
  TRISB = 0x00;       // Set PORTB direction to be output
  TRISC = 0x00;
  TRISD = 0x00;
  TRISE = 0b00000111;
  PORTA = 0x00;
  PORTB = 0x00;
  PORTC = 0x00;
  PORTD = 0x00;

  // initialisation de l'heure à 10:30:00
  count_heure_horloge = 23;
  count_minute_horloge = 59;
  drapeau_minute = 0;
  drapeau_heure = 0;
  secondes = 50;
  Num = 0;
  compteur_one_minute = 0;
  PORTA.B1 = 1; // led témoin ouverte
  Blink = 0x00;
  
// désactivation des résistances de pullup
//  NOT_RBPU_bit = 0;
  OPTION_REG = 0x07; // Prescaler (1:256) is assigned to the timer TMR0
  TMR0 = 39;         // Timer T0 counts from 39 to 255
  INTCON = 0xA0;     // Enable interrupt TMR0 and Global Interrupts

 do {
     DD0 = secondes%10;  // 2ième digit seconde
     DD0 = mask(DD0);    // 1ier digit seconde
     DD1 = secondes/10;
     DD1 = mask(DD1);
 
     DD2 = count_minute_horloge%10; // 2ieme digit minute
     DD2 = mask(DD2);
     DD3 = count_minute_horloge/10; // 1er digit minute
     DD3 = mask(DD3);
     DD4 = count_heure_horloge%10;  // 2ieme digit heure
     DD4 = mask(DD4);
     DD5 = count_heure_horloge/10;  // 1er digit heure
     DD5 = mask(DD5);

     if (!bouton_set_heure) {
      drapeau_heure = 1;
      count_heure_horloge = count_heure_horloge + 1;
      if (count_heure_horloge == 24) count_heure_horloge = 0;
      }
      
     if (!bouton_set_minute) {
      drapeau_minute = 1;
      count_minute_horloge = count_minute_horloge + 1;
      if (count_minute_horloge == 60) count_minute_horloge = 0;
      }
      
      if(!bouton_reset_secondes) {
       secondes = 0;
      }

     if (bouton_set_heure)  drapeau_heure  = 0;
     if (bouton_set_minute) drapeau_minute = 0;
         
     switch(Blink){
     case 0: 
             Num2Points = !Num2Points;
             secondes++;
             break;
     case 255:
             Num2Points = !Num2Points;    
             secondes++;
             break;
     }
    
       if (secondes == 60) // à chaque minute (60 secondes = 1 minute)
       {
        secondes = 0;
        count_minute_horloge = count_minute_horloge + 1;
        if (count_minute_horloge == 60) {
         count_heure_horloge = count_heure_horloge + 1;
         count_minute_horloge = 0;
         secondes = 0;
         }
        if (count_heure_horloge == 24) count_heure_horloge = 0;
        // réinitialisation du compteur OneSec pour donner
        // toujours 60 secondes à chaque fois sinon on le perd...
        } */

       Afficher_Heure();
       }
   while(1); // infinite loop
}

Dis moi si tu trouves de quoi...
A++!
marC

[nodoubtman]

as-tu trouvé quelque chose svp?

merci!
A+!
marC

[invite03481543]

J'ai pas eu trop le temps de regarder jusqu'a aujourd'hui je te tiens au courant dans la journee.
@+

[invite03481543]

J'ai pas eu trop le temps de regarder jusqu'a aujourd'hui je te tiens au courant dans la journee.
@+