compteur jusqu'à 9999 mais passe à zero 127

Bonjour,

DEBUTANT!

Je me suis “écrit” un petit compteur avec un affich 4x7 seg A/C + 4543B . Je voulais d’abord “vérifier” tous les segments. Dans mon croquis il compte bien mais lorsqu’il arrive à 127 il passe à zero pendant un certain temps, puis redémarre.
Je n’arrive pas à voir pourquoi il passe à 0 après 127?? (voir code)
Merci de votre aide
Cdt.

//les broches du décodeur 7 segments
const int bit_A = 2;
const int bit_B = 3;
const int bit_C = 4;
const int bit_D = 5;
//les broches des transistors pour l'afficheur des dizaines et celui des unités

const int alim_unite = 6;
const int alim_dizaine = 7;
const int alim_centaine = 8;
const int alim_mille = 9;
void setup()
{
//Les broches sont toutes des sorties (sauf les boutons)

pinMode(bit_A, OUTPUT);
pinMode(bit_B, OUTPUT);
pinMode(bit_C, OUTPUT);
pinMode(bit_D, OUTPUT);
pinMode(alim_mille, OUTPUT);
pinMode(alim_centaine, OUTPUT);
pinMode(alim_dizaine, OUTPUT);
pinMode(alim_unite, OUTPUT);

//Les broches sont toutes mises à l'état bas (sauf led rouge éteinte)
digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
digitalWrite(alim_mille, LOW);
digitalWrite(alim_centaine, LOW);
digitalWrite(alim_dizaine, LOW);
digitalWrite(alim_unite, LOW);
}

void loop()
{
  for(char i=0; i<999; i++)//boucle qui permet de compter de 0 à 999 (= 1000 valeurs)
  {   
    afficher_nombre(i);//appel de la fonction affichage avec envoi du nombre à afficher    
  }   
}
//fonction permettant d'afficher un nombre sur 2 afficheurs
void afficher_nombre(char nombre)
{   
  int tempo=500;  // temporisation en ms
  long temps;//variable utilisée pour savoir le temps écoulé...
  char unite = 0, dizaine = 0, centaine = 0, mille = 0;//variable pour chaque afficheur
      if(nombre > 999)//si le nombre reçu dépasse 999
      {
        mille =nombre /1000;
      }
      {
        centaine = (nombre-(mille*1000))/100;//on récupère les centaines
      }
      
      {
        dizaine = (nombre - (mille*1000+centaine*100))/10;//on récupère les dizaines
      }
      { 
        unite = nombre - (mille*1000+centaine*100 + dizaine*10);//on récupère les unites
      }
   temps = millis();//on récupère le temps courant
   
   // tant qu'on a pas affiché ce chiffre pendant au moins 500 millisecondes
  // permet donc de pouvoir lire le nombre affiché
   while((millis() - temps) < tempo)
  {
    //on affiche le nombre
    
    //d'abord les centaines pendant 10 ms
    digitalWrite(alim_mille, HIGH);
    afficher(mille);
    digitalWrite(alim_centaine, LOW);
    digitalWrite(alim_dizaine, LOW);
    digitalWrite(alim_unite, LOW);
    delay(5);
    
    digitalWrite(alim_mille, LOW);
    digitalWrite(alim_centaine, HIGH);/* le transistor de l'afficheur des centaines est saturé,
                                      donc l'afficheur est allumé */
    afficher(centaine);            //on appelle la fonction qui permet d'afficher le chiffre centaine
    digitalWrite(alim_dizaine, LOW);//on éteint le transistor allumé
    digitalWrite(alim_unite, LOW);// l'autre transistor est bloqué et l'afficheur éteint
    delay(5);
   
   //puis les dizaines pendant 10 ms
    digitalWrite(alim_mille, LOW);
    digitalWrite(alim_centaine, LOW);//l'autre transistor est bloqué et l'afficheur éteint
    digitalWrite(alim_dizaine, HIGH);//le transistor de l'afficheur des dizaines est saturé,
                                    //donc l'afficheur est allumé 
    afficher(dizaine);            //on appel la fonction qui permet d'afficher le chiffre dizaine
    digitalWrite(alim_unite, LOW);// l'autre transistor est bloqué et l'afficheur éteint
    delay(5);
   
    //puis les unités pendant 10 ms
    digitalWrite(alim_mille, LOW);
    digitalWrite(alim_centaine, LOW);
    digitalWrite(alim_dizaine, LOW);
    digitalWrite(alim_unite, HIGH);//et on allume l'autre
    afficher(unite);
    delay(5);
  }
}

//fonction écrivant sur un seul afficheur
void afficher(char chiffre)
{
digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);

if(chiffre >= 8)
{
digitalWrite(bit_D, HIGH);
chiffre = chiffre - 8;
}
if(chiffre >= 4)
{
digitalWrite(bit_C, HIGH);
chiffre = chiffre - 4;
}
if(chiffre >= 2)
{
digitalWrite(bit_B, HIGH);
chiffre = chiffre - 2;
}
if(chiffre >= 1)
{
digitalWrite(bit_A, HIGH);
chiffre = chiffre - 1;
}
} //Fin du programme !

for(char i=0...

char est un octet (8 bit, signé semble-t-il !) cf. http://arduino.cc/en/Reference/Char

for(int i=0... devrait aller mieux peut-être.

ps: idem pour void afficher_nombre(char nombre)

Merci beaucoup! effectivement int =2 octets signé. Résolu