scintillement multiplexage 7 segments

[newtech1]

Bonjour,

j'ai multiplexé deux afficheur sept segments à ANODE commune avec un microcontroleur PIC, j'ai réalisé un petit programme qui compte de 0 à 99, alors ca marche parfaitement sur ISIS mais le probleme est que j'ai des scintillements, en fait on voit bien que il y a un changement de chiffre et que les deux afficheurs ne restent pas allumés simultanément, j'ai changé les délais etc mais rien n'y fait alors je crois qu'il s'agit d'un probleme au niveau de isis?

voila une partie du code qui n'est pas un probleme je pense

void main(){

    Init_Pic();
    InitTimer1();
    Sel1 = 0;                                               // Variable de multiplexage ( Premier afficheur)  commande le transistor Q1
    Sel2 = 0;                                               // Variable de multiplexage ( Deuxième afficheur) commande le transistor Q2

	while(1){                                               // Boucle infinie


		PORTD = Seven_seg(val % 10);                        // Affiche les chiffres par la méthode du multiplexage
		Sel2 = 0;
		delay_ms(10);                                       // Délai a varier selon application
                Sel2 = 1;
		PORTD = Seven_seg((val / 10) % 10);
		Sel1 = 0;
		delay_ms(10);
		Sel1 = 1;


        if (flag_0 == 1){                                  

        	val++;                                       
        	flag_0 = 0;  

}                                  
        

        

	}
}

-----

[Jack]

où est déclarée flag_0 ?

De plus cette varible n'est jamais mise à 1

Tu ne donne pas l'état actif de Sel1 et Sel2

etc. etc.

Bref, essaie de donner un code utilisable et renseigné si tu veux qu'on essaie de l'interpréter correctement.

[newtech1]

Voila le code

#define   Sel1      LATC.F0                                 // On affecte la macro Sel1 au PORTC0
#define   Sel2      LATC.F1                                 // On affecte la macro Sel2 au PORTC1

unsigned char val = 0;                                      // Variable Val non signé servant à compter les chiffres
unsigned char count = 0;                                    // Variable count utilisée pour multiple de l'interruption
volatile char flag_0 = 0;                                   // Variable flag servant à détecter une interruption


// Prototype des fonctions

void Init_Pic();                                            // Initialise le Pic18F4550
void InitTimer1();                                          // Initialise les registres du Timer1 du PIC18F4550
unsigned char Seven_seg(unsigned char Value);               // Fonction qui sert à afficher les chiffres sur les afficheurs septs segments

void main(){

    Init_Pic();
    InitTimer1();
    Sel1 = 0;                                               // Variable de multiplexage ( Premier afficheur)  commande le transistor Q1
    Sel2 = 0;                                               // Variable de multiplexage ( Deuxième afficheur) commande le transistor Q2

	while(1){                                               // Boucle infinie


		PORTD = Seven_seg(val % 10);                        // Affiche les chiffres par la méthode du multiplexage
		Sel2 = 0;
		delay_ms(10);                                       // Délai a varier selon application
                Sel2 = 1;
		PORTD = Seven_seg((val / 10) % 10);
		Sel1 = 0;
		delay_ms(10);
		Sel1 = 1;


        if (flag_0 == 1){                                   // On a détecter une interruption ( On arrive ici chaque 1 seconde (100 ms * 10 = 1000 ms = 1 s))

        	val++;                                          // On incrémente de 1 notre variable val
        	flag_0 = 0;                                     // On remet à Zéro le bit de flag
        }
        

        

	}
}


void Init_Pic(){

         ADCON1 = 0x0D;                                         // Tous les Ports en Digital sauf RA0 et RA1 qui restent en analogique
	 CMCON = 7;                                             // Désactiver les comparateurs analogiques
	 TRISC = 0;                                             // PORTC En sortie
	 LATC = 0;                                              // Mise à 0 du PORTC entier
	 TRISD = 0;                                             // PORTD en sortie
	 LATD = 0;                                              // Mise à 0 du PORTD entier
	 TRISB = 1;                                             // PORTB en entrée
	 LATB = 0;                                              // Mise à 0 du PORTB entier

}




unsigned char Seven_seg(unsigned char Value){               // Fonction d'affichage des chiffres 

	switch(Value){

		case 0 : return ~0xC0;      // Retourne le chiffre 1 lorsque value vaut 0 (Les digits sont inversés à cause de l'usage du ULN2003)
		case 1 : return ~0xF9;      // Retourne le chiffre 2 .......................
		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 InitTimer1(){               

  T1CON	 = 0x11;                                             // Configuration du registre Timer
  TMR1IF_bit= 0;
  TMR1H = 0x3C;
  TMR1L = 0xB0;
  TMR1IE_bit = 1;
  INTCON = 0xC0;

}


void interrupt(){

        if (TMR1IF_bit){                                     // Une interruption est déclenchée toute les 100 ms

                        TMR1IF_bit = 0;                      // On efface le drapeau du flag 
                        TMR1H	 = 0x3C;                     // On loade les registres TMR1H et TMR1L
                        TMR1L	 = 0xB0;

                        // Interruption chaque 100 ms

                        count++;                             // On incrémente une variable count pour avoir un multiple du temps de 100 ms

		                if (count == 1) {

		                 	             flag_0 = 1;         // On déclenche l'interruption généré par le débordement du timer à l'éxtétieur de l'ISR
		                 	             count = 0;          // On remet à 0 la variable count pour pouvoir compter de nouveau
	                                 	}

	                   }

}

Pour les délai j'ai essayé de 1 jusqu'a 50 ms c'est toujours la meme chose, il y a de forte chances que ca vienne de proteus apparement le probleme

[kevin8z]

Je n'ai pas regardé ton code. Mais quelle est la fréquence de multiplexage? Et dans mes souvenir je crois que j'avais fait quelque chose à peu près pareil, et sous ISIS ça clignoté, car le logiciel de simulation était un peut "long".
Le meilleur moyen serai de câbler ton montage.

[A voir en vidéo sur Futura]

[Jack]

Il est bizarre ton programme. A quoi sert la variable count puisqu'elle est toujours égale à 1 dans le test "if (count == 1) {" de la routine d'interruption?

Ce qui est bizarre également, c'est que le multiplexage est fait dans une boucle. Ce qui me semble beaucoup plus judicieux est de switcher d'un afficheur à l'autre dans le programme d'interruption justement, toutes les 10 ms par exemple.

[newtech1]

salut,

Oui effectivement c'est plus judicieux c'est vrai je compte utiliser l'interruption pour le changement d'affichage mais je voulais que ca arrete de scintiller pour le moment. il y a une erreur il s"agit de if (count == 10) et non pas 1.


Les registres sont configurés de telle sorte que l'interruption se déclenche chaque 100 ms, or je voudrais faire compter les chiffres par pas de 1 seconde donc j'ai rajouté la variable count afin d'avoir 1 s 100ms*10 = 1000 ms et lorsque c'est le cas mettre à 1 le flag_0 et remettre à 0 le count, ca me parait logique

je crois qu'il s'agit d'un probleme de proteus je vais tenter en hard our voir

[Jack]

alors ca marche parfaitement sur ISIS mais le probleme est que j'ai des scintillements

Je n'avais pas trop fait attention, mais je pensais que ça marchait sous ISIS et pas dans la réalité. En fait ça scintille sous ISIS, c'est çà? Bin comme dit plus haut, c'est un simulateur, donc ...

[newtech1]

oui ca scintille sous isis mais le programme fait ce qu'il doit faire, je crois que c'est ca alors

[PIXEL]

faut se méfier des simulos....

je repose la même question que mes éminents collégues , quelle est la fréquence de rafraichissement ?

[Jack]

N'empêche, toute la partie multiplexage et gestion des secondes devrait se trouver dans le sous-programme d'interruption à mon avis.

[Jack]

je repose la même question que mes éminents collégues , quelle est la fréquence de rafraichissement ?

D'après le programme: 50 Hz

[PIXEL]

alors ça ne doit pas scintiller , mais le simulo dépend de la puissance de calcul du pécé....

donc méfiance , il faut être conscient des limites de ces gadgets qu'il faut utiliser :
"avec des pincettes"

[newtech1]

la frequence est de 1 / 10ms*2 = 50 Hz, logiquement l'oeil ne doit pas voir les scintillement à cette fréquence donc je pense effectivement que c'est proteus qui est cause c'est pas la premiere que j'ai des souci en simul et que ca marche en vrai je vais donc cabler tout ca et je vous tiens au courant et si c'est bon je passerai le multiplexage en interruption comme suggéré

[newtech1]

j'ai testé en pratique, cela fonctionne parfaitement c'etait donc le simulateur!

Alors je me penche sur l'avis de jack, pouvez vous détailler la méthode d'utiliser le multiplex au sein de l'interrupt? en se basant sur mon programme


merci

[Jack]

Une interruption toutes les 10 ms par exemple:
- un compteur comme tu l'as fait qui s'incrémente à chaque interruption: si compteur = 100, on incrémente les secondes et RAZ compteur
- on switche sur l'autre afficheur et on affiche

[newtech1]

ca donne quelque chose comme ca? parceque je vois pas comment afficher avec l'interruption par intervalle de 10 ms les deux afficheurs

void interrupt(){

        if (TMR1IF_bit){                                     // Une interruption est déclenchée toute les 100 ms

                        TMR1IF_bit = 0;                      // On efface le drapeau du flag 
                        TMR1H	 = 0x3C;                     // On loade les registres TMR1H et TMR1L
                        TMR1L	 = 0xB0;

                        // Interruption chaque 100 ms

                        count++;                             // On incrémente une variable count pour avoir un multiple du temps de 100 ms

		                if (count == 10) {       // ca fait une seconde   100 ms * 10 = 1  s

		                 	             flag_0 = 1;         // On déclenche l'interruption généré par le débordement du timer à l'éxtétieur de l'ISR
		                 	             count = 0;          // On remet à 0 la variable count pour pouvoir compter de nouveau
	                                 	}

	                   }

}



void main (){


          while(1){



               if (flag_0 == 1){                                // On a détecter une interruption ( On arrive ici chaque 1 seconde (100 ms * 10 = 1000 ms = 1 s))

        	val++;                                          // On incrémente de 1 notre variable val
                PORTD = Seven_seg(val % 10);     // Premier afficheur               
		Sel2 = 0;
		delay_ms(10);                                   
                Sel2 = 1;

        	flag_0 = 0;                                     // On remet à Zéro le bit de flag
        }


                PORTD = Seven_seg((val / 10) % 10);
		Sel1 = 0;
		delay_ms(10);
		Sel1 = 1;
        


 
 }

[Jack]

ca donne quelque chose comme ca? parceque je vois pas comment afficher avec l'interruption par intervalle de 10 ms les deux afficheurs

????

La gestion de l'afficheur que tu as dans le "main", tu la mets dans le S/P d'interruption.

En passant, je note que tu n'as pas répondu à ma question: quel est l'état actif (qui allume l'afficheur) pour Sel1 et Sel2?

[newtech1]

Très Bien.

mais dans ce cas je dois enlever le delay_ms(10) ou pas entre sel2 et sel1


lorsque sel1 = 0, ca allume le premier afficheur et lorsque sel2=0 ca allume le deuxieme afficheur

[Jack]

mais dans ce cas je dois enlever le delay_ms(10) ou pas entre sel2 et sel1

Evidemment, c'est tout l'intérêt d'utiliser les interruptions. C'est la periode d'interruption qui va servir de délai.

lorsque sel1 = 0, ca allume le premier afficheur et lorsque sel2=0 ca allume le deuxieme afficheur

C'est bien ce que je pensais. Ta gestion de la commutation des afficheurs va donc avoir de courts instants pendant lesquels les 2 afficheurs seront allumés en même temps. Je pense qu'il est préférable d'avoir une séquence de commutation au cours de laquelle on commence par éteindre l'afficheur actif avant d'allumer l'autre

[newtech1]

si je declenche une interruption toutes les 1 secondes (en utilisant un compteur) je pourrais actualiser la valeur de sel1 à 0 ou à 1 mais si je mets celle de sel2 dans l'interruption les deux valeurs vont etre mise a jour en même temps et non pas par période de 1 s? ou il faut que j'utilise deux interruptions, je peux avoir un exemple de programme pour mieux comprendre?

[Jack]

si je declenche une interruption toutes les 1 secondes

Relis attentivement mes réponses: j'ai pourtant bien dit une interruption toutes les 10 ms. Dans le programme d'interruption, ce n'est quand même pas compliqué de compter jusqu'à 100 pour obtenir ta période de 1 seconde.

je pourrais actualiser la valeur de sel1 à 0 ou à 1 mais si je mets celle de sel2 dans l'interruption les deux valeurs vont etre mise a jour en même temps et non pas par période de 1 s? ou il faut que j'utilise deux interruptions, je peux avoir un exemple de programme pour mieux comprendre?

Réfléchis un peu plus longtemps avant de soumettre tes questions La non plus ce n'est pas compliqué à chaque interruption : un coup on fait sel1 = 1 puis sel2 = 0 et à l'interruption suvante sel1 = 0 puis sel2 = 1 et ainsi de suite pour que ca commute à l'infini