Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur le langage C !

Modérateur : Jérémy

mikroc et les BP
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#11 Message par Jérémy » lun. 5 oct. 2015 07:18

Bonjour,

Et les 4 afficheurs affichent quoi comme Infosys ? Minutes/secondes. Heures/minutes ?
C'est en faisant des erreurs, que l'on apprend le mieux !!!

mikroc et les BP
nebukadnezare
Membre
Membre
Messages : 9
Enregistré en : octobre 2015

#12 Message par nebukadnezare » lun. 5 oct. 2015 11:07

Pour l'instant il affiche que des seconds (9999S)

mikroc et les BP
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#13 Message par Jérémy » mar. 6 oct. 2015 09:54

Bonjour ,

Alors voici le principe. Il faudra faire quelques modifs pour l'adapter a ton PIC . si tu as des problèmes n’hésite pas à poster ici .

Le principe est le suivant .

Une interruption permet de mettre l'affichage à jour toutes les 20ms . (clignotement invisible a l’œil nu)
Au départ on rentre dans un sous-programme de réglage, permettant de régler le compte à rebours, grâce au BP "plus et moins".
Pour sortir, on doit lancé le compte a rebours en appuyant sur le BP start.

Une fois lancé :
Il est possible d’arrêter le compte à rebours en appuyant sur le BP stop.
Ainsi on peut re-régler le chrono, et re-appuyé sur start pour le relancer.

Une fois a zéro le décompteur s’arrête et on retourne dans le programme réglage pour le Re-regler .

Le compte à rebours décompte en seconde . Il faut 50 boucle de 20ms pour faire une seconde et donc décrémenter notre chrono.

L'appui sur les BP "plus et moins", fonctionne par palier réglage . Plus on laisse longtemps appuyé , plus ca va vite .

Voila, j'ai fais ca assez vite fait, sans grande précision ( anti rebond , timer optimisation). Mais l'idée générale est la, et il fonctionne parfaitement sur ma plaque d'essai .

Tiens nous au courant !

Code : Tout sélectionner

/*##################################################################################
##############################     Variable / Constante    #########################
##################################################################################*/
#define bp_plus PORTC.B7
#define bp_moins PORTC.B6
#define bp_start PORTC.B0
#define bp_stop PORTC.B1

unsigned int   compteur, num, millier, centaine, dizaine, unite, timer;  // Déclaration des variables
unsigned char etat_Bp, seconde, flag_start ;

void reglage();      // Fonction réglage
void affichage();    // Fonction qui met à jour l'affichage
unsigned short conversion(unsigned short num);   // Fonction qui convertis le chiffre pour le display


/*##############################   Interruption TIMER0   #########################*/
 void Interrupt(){
                      // On regarde quel drapeau a été mis à 1, pour connaitre la source de l’interruption
  if (TMR0IF_bit){    // Ici le bit TMR0IF (bit2) du registre INTCON est testé
    
    affichage
();      // On met à jour l'affichage toute les 20 ms

    if ( flag_start == 1)       // Si le compte à rebours est lancé on incrémente le compteur de seconde
       seconde = seconde++;     // Incrémente une variable pour savoir quand 1 seconde est écoulé

    TMR0H = 0x63;               // Remise du timer
    TMR0L = 0xC0;
    TMR0IF_bit = 0;             // activation de l'interruption
   }
 }
/*##################################################################################
############################   PROGRAMME PRINCIPAL    ##############################
##################################################################################*/
void main() {

  ANSELA = 0;                   // Configure le PORTA en Digital
  ANSELC= 0;                    // Configure le PORTD en Digital
  ANSELD = 0;                   // Configure le PORTD en Digital
  TRISA = 0;                    // Configure le PORTA en SORTIE
  LATA  = 0;                    // affecte 0 aux broches du PORTA
  TRISC = 0xff;                 // Configure le PORTC en entrée
  TRISD = 0;                    // Configure le PORTD en SORTIE
  LATD  = 0;                    // affecte 0 aux broches du PORTD

  T0CON = 0b11000111 ;   // Configuration du TIMER0 à 20ms
  TMR0H = 0x63;          // chargement de la valeur 125 dans le TIMER du bas
  TMR0L = 0xC0;          // chargement de la valeur 0 dans le TIMER du haut
  INTCON = 0b10100000;   // Configuration de l'interruption

  PORTA = 0;             // Mise à l'état haut de RA0 pour activer le premier afficheur.
  compteur = 0;          // Initialise notre compteur à 0.

  reglage ();            // On rentre dans le programme de réglage

 //##########################    BOUCLE INFINIE    ##################################
  do {

   if (seconde >= 50 & flag_start == 1) { // Si la variable a été incrémenté 50 fois on enlève une seconde
      compteur = compteur--;              // décrémentation du compteur ( 50 x 20ms = 1s)
               if (compteur == 0){         // Un fois arrivé à 0 on arrête le décompte on rentre dans réglage
                   flag_start = 0;
                   reglage ();
                }
      seconde = 0;                        // remet a 0 la variable
    }

   if (bp_stop == 1){                     // Si pendant le décompte le BP stop est appuyé
      delay_ms(30);                       // anti-rebond
      if (bp_stop == 1){
         flag_start = 0;                  // On arrête de décrémenter en mettant le flag a zéro
         reglage ();                      // On va dans le programme réglage
       }
    }
  } while(1);                           // On reboucle
}

/*##################################################################################
############################   PROGRAMME SECONDAIRE    ##############################
##################################################################################*/

/*############################   Fonction réglage    #############################*/
void reglage () {
  do{
    if (bp_plus == 1){      // détection du Bp plus appuyé
        delay_ms (50);      // Anti-rebond
        if (bp_plus == 1){
              timer = 0;    // Mise a zéro de la variable timer pour détecter la longueur d'un appui
              do {
                 compteur = compteur++ ;      // Incrémente le compteur
                 timer = timer++;             // Incrémente la variable de détection d'appui
                       if (timer <= 5)        // Premier palier En dessous de 5 le compteur incrémente une pause de 80ms entre chaque incrémentation ( a regler)
                          delay_ms (80);      // avec une pause de 80ms entre chaque incrémentation ( à regler)
                        else if (timer <= 20) // Deuxième palier entre 5 et 20
                             {delay_ms(50);}
                        else if (timer <= 60) // Troisième palier entre 20 et 60
                             {delay_ms(30);}
                        else if (timer <= 200)
                             {delay_ms(10);}
                        else if (timer <= 1000)
                             {delay_ms(1);}
                        else
                             
{delay_ms(1);compteur = compteur+;} // Dernier palier incrémentation de 5 en 5
               } while (bp_plus == 1);             // On reboucle tant que le BP est appuyé
          delay_ms(50);                            // Anti--rebond au relâchement
         }
     }
    if (bp_moins == 1){                     // La même chose que l’incrémentation , mais en décrémentant
        delay_ms (50);
        if (bp_moins == 1){
              timer = 0;
              do {
                 compteur = compteur-- ;
                 timer = timer++;
                       if (timer <= 5)
                          delay_ms (80);
                        else if (timer <= 20)
                             {delay_ms(50);}
                        else if (timer <= 60)
                             {delay_ms(30);}
                        else if (timer <= 200)
                             {delay_ms(10);}
                        else if (timer <= 1000)
                             {delay_ms(1);}
                        else
                             
{delay_ms(1);compteur = compteur-;}
               } while (bp_moins == 1);
          delay_ms(50);
         }
     }
  } while (bp_start == 0);       // Détection de l'appui sur le BP start
  delay_ms (50);                 // Anti rebond
  flag_start = 1;                // Mise a 1 du flag start
  seconde = 0;                   // Mise à zéro du compteur seconde
}


/*###########################   Fonction affichage    ############################*/
void affichage () {

    millier = compteur/1000 %10 ;     // Calcul de la valeur des milliers . On divise le compteur par 1000 on prend le modulo
    PORTA = 8;                        // On active le 4iéme digit ( 0b00001000) en mettant le bit 3 à 1
    PORTD = conversion(millier);      // On convertis la valeur calculée en segments pour affichage.
    delay_ms (3);                     // On marque une pause pour afficher le chiffre

    centaine = compteur/100 %10;     // calcul de la valeur des centaines . On divise le compteur par 100 on prend le modulo
    PORTA = 4;                       // On active le 3iéme digit ( 0b00000100) en mettant le bit 2 à 1
    PORTD = conversion(centaine);    // On convertis la valeur calculée en segments pour affichage.
    delay_ms (3);                    // On marque une pause pour afficher le chiffre

    dizaine = compteur/10 %10;      // calcul de la valeur des dizaines . On divise le compteur par 10  on prend le modulo
    PORTA = 2;                      // On active le 2iéme digit ( 0b00000010) en mettant le bit 1 à 1
    PORTD = conversion(dizaine);    // On convertis la valeur calculée en segments pour affichage.
    delay_ms (3);                   // On marque une pause pour afficher le chiffre

    unite = compteur %10;           // calcul de la valeur des unités . On prend le modulo
    PORTA = 1;                      // On active le 1er digit ( 0b00000001) en mettant le bit 0 à 1
    PORTD = conversion(unite);      // On convertis la valeur calculée en segments pour affichage.
    delay_ms (3) ;                  // On marque une pause pour afficher le chiffre
    PORTA = 0;                      // On met le PORT à 0 pour avoir la même luminosité
 }

/*###########################    CONVERTIR LE CHIFFRE    #########################*/
unsigned short conversion(unsigned short num) {  //  Fonction avec paramètres d'entrée et de sortie
                                                 // suivant le chiffre du compteur on renvoie la valeur pour allumer tel ou tel segments sur le PORTD

                                      // Utilisation de la commande "switch"
      switch (num) {                  // "Switch" compare la valeur contenu dans "num" au valeur "case" ci dessous
                                      // Si une valeur est trouvée, "Switch" renvoie la valeur correspondante et sort
                                      // Une seule valeur est prise en compte

      case 0 : return 0x3F;           // Affiche un "0" avec l'allumage de six segments 3F = 00111111  du PORTD
      case 1 : return 0x06;           //                     |
      case 2 : return 0x5B;           //                     |
      case 3 : return 0x4F;           //                     |
      case 4 : return 0x66;           //                     |
      case 5 : return 0x6D;           //                     |
      case 6 : return 0x7D;           //                     |
      case 7 : return 0x07;           //                     |
      case 8 : return 0x7F;           //                     |
      case 9 : return 0x6F;           // Affiche un "9" par l'allumage des segments correspondants
    }
 


Attention!! Ce programme n'est pas du tout optimisé, je suis débutant moi aussi . Si un expert peu l'analyser et apporté des commentaires, sur la méthode et la façon de faire je suis preneur ! . par exemple je sais que dans l'interruption je ne devrais pas effectué la mise à jour de l'affichage car c'est trop long ? mais je savais pas trop comment faire ?
C'est en faisant des erreurs, que l'on apprend le mieux !!!

mikroc et les BP
nebukadnezare
Membre
Membre
Messages : 9
Enregistré en : octobre 2015

#14 Message par nebukadnezare » mar. 6 oct. 2015 23:17

super "Jérémy" merci infiniment pour l'accélération c'est exactement ce que je chercher pile poile, il me reste plus qu'a trouver un moyen pour la mémorisation. vraiment merci.

mikroc et les BP
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#15 Message par Jérémy » mar. 6 oct. 2015 23:56

Pas de problème, c'était avec plaisir , si ça te conviens comme ca .

Pour ton histoire de mémorisation ouvre un nouveau sujet ! y'a aucun soucis !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

mikroc et les BP
nebukadnezare
Membre
Membre
Messages : 9
Enregistré en : octobre 2015

#16 Message par nebukadnezare » mar. 6 oct. 2015 23:57

Encore une fois milles merci.


Retourner vers « Langage C »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 40 invités