Programmation microncontroleur PIC18F45K22, afficheur 7 segment 4 digit

[invite64bb2dc2]

Bonjour à tous,

J'ai utilisé un programme qui m'a été envoyé avec la platine EASYPIC7. J'utilise le compilateur mikroC. Je lancé le programme sur ma platine; il fonctionne très bien.

Mon problème c'est ce que je ne comprend une partie du programme.

voici l'ensemble du programme:
Est ce que quelqu'un pourrait m'expliquer si il a compris ce que fait ma fonction interruption (Ligne par Ligne), surtout le shifter et le portd_index

Merci d'avance!!!!!!!!!!!!!!!!!

unsigned short shifter, portd_index;
unsigned int digit, number;
unsigned short portd_array[4];

//-------------- Returns mask for common cathode 7-seg. display
unsigned short mask(unsigned short num) {
switch (num) {
case 0 : return 0x3F;
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;
} //case end
}

void interrupt() {
LATA = 0; // Turn off all 7seg displays
LATD = portd_array[portd_index]; // bring appropriate value to PORTD
LATA = shifter; // turn on appropriate 7seg. display

// move shifter to next digit
shifter <<= 1;
if (shifter > 8u)
shifter = 1;

// increment portd_index
portd_index++ ;
if (portd_index > 3u)
portd_index = 0; // turn on 1st, turn off 2nd 7seg.
TMR0L = 0; // reset TIMER0 value
TMR0IF_bit = 0; // Clear TMR0IF
}

void main() {
ANSELA = 0; // Configure PORTA pins as digital
ANSELD = 0; // Configure PORTD pins as digital

TRISA = 0; // Configure PORTA as output
LATA = 0; // Clear PORTA
TRISD = 0; // Configure PORTD as output
LATD = 0; // Clear PORTD

T0CON = 0xC4; // Set TMR0 in 8bit mode, assign prescaler to TMR0
TMR0L = 0; // clear TMROL
digit = 0;
portd_index = 0;
shifter = 1;

number = 1234; // Initial number value
GIE_bit = 1;
TMR0IE_bit = 1;

do {
digit = number / 1000u ; // extract thousands digit
portd_array[3] = mask(digit); // and store it to PORTD array
digit = (number / 100u) % 10u; // extract hundreds digit
portd_array[2] = mask(digit); // and store it to PORTD array
digit = (number / 10u) % 10u; // extract tens digit
portd_array[1] = mask(digit); // and store it to PORTD array
digit = number % 10u; // extract ones digit
portd_array[0] = mask(digit); // and store it to PORTD array

Delay_ms(1000); // one second delay

number++ ; // increment number
if (number > 9999u) //ancienne valuer
number = 0;

} while(1); // endless loop
}
-----

[luc_1049]

Bonjour

C'est du logiciel embarqué donc lié au hardware, que vous devez être capable d'analyser à partir du schéma de la carte.

Sinon toute tentative de codage logiciel embarqué sur cette carte ou sur une autre sera vaine. le soft est lié au hardware, il faut savoir lire le schéma !

L'interruption semble être là pour assurer le multiplexage des afficheurs via lata (porta) et vous en avez 8 (shifter de évolue 1 à 8) mais c'est à voir sur votre schéma . Y-at-il des circuits logiques multiplexeur, ....

Portd_ array comprend les chiffres à afficher qui sont choisis par le soft par portd_index qui évolue de 0 à 3

Voila ce que j'ai compris !
cdlt

[spown]

Bonjour/bonsoir est bienvenu sur FUTURA,

Ton programme c'est en gros un compteur sur un afficheur de 7 segments à 4 digit. La fonctionne Interreupt(), c'est l'interruption de ton timer0. Apres chaque période déterminée par ta vitesse d'horloge et ton prescaler de ton timer0, ce dernier incrémente les chiffres en commence par le segment à droit jusqu’à l’atteint du 9 puis il se décale vers le segments de gauche grâce à "shifter" et ainsi de suite juste le 4éme segemts.

Il boucle sa jusqu’à 9999 puis il repart à 0 avec une vitesse de 1 chiffre/seconde.

Voila , pense à mettre des balises de code pour la prochaine fois.

[invite64bb2dc2]

Bonjour à tous,

D'abord merci pour vos réponse, je commence à mieux comprendre ce que fait ma fonction interruption "void interrupt()".
D'après ce que j'ai compris, vous pouvez me corriger si je me trompe, Pord_index s'incrémente pour afficher la valeur sur le digit concerné et Shifter permet de sélectionner le DIGIT (l'afficheur 7segment)

Mais j'ai quand même quelques questions qui me trottent dans la tête.

1) Je ne comprend pas pourquoi portd_index s'incrément dans ma fonction interruption "portd_index++", j'ai l'impression qu'il devrait diminuer de 3 jusqu'à 0, c'est ce que je vois dans ma fonction principale avec pord_array[]:

digit = number / 1000u ; // extract thousands digit
portd_array[3] = mask(digit); // and store it to PORTD array
digit = (number / 100u) % 10u; // extract hundreds digit
portd_array[2] = mask(digit); // and store it to PORTD array
digit = (number / 10u) % 10u; // extract tens digit
portd_array[1] = mask(digit); // and store it to PORTD array
digit = number % 10u; // extract ones digit
portd_array[0] = mask(digit); // and store it to PORTD array

2)Ma variable Shifter j'ai compris (Corriger moi si je me trompe) qu'il doit évoluer jusqu'à 8 afin de donner l'impression que mes 4 digit son activer simultanément (méthode de Multiplexage), mais je ne comprend pas comment il interagit avec le programme principal

// move shifter to next digit
shifter <<= 1;
if (shifter > 8u)
shifter = 1;

3)Venons au plus important, Je ne comprend pas comment fonctionne l'interruption. Car pour moi, c'est le programme principal qui interrompt son action pour donner la main (appel à un sous-programme) à un sous programme. Mais je ne vois pas l'appel de la fonction interruption " void interrupt()" dans le programme principal. Je sais que c'est fait par le timer, et l'activation de "GIE_bit = 1; et TMR0IE_bit = 1;" je ne comprend pas comment discute mon programme principal avec ma fonction interruption. La question est quand appel t-il ma fonction interruption, et comment interagit il avec cette fonction?

Merci pour vos réponse!!!!!

[A voir en vidéo sur Futura]

[luc_1049]

Bonjour

Pour le point 3, dans le principe dés qu'elle est activée une interruption est inévitable, sauf si une de priorité supérieure arrive avant . C'est en gros comme cela quelque soit le micro. Ou si l'interruption devient masquée ou inhibée si vous préférez.
Dés l'entrée en interruption le micro sauvegarde son contexte, pile et valeur du compteur programme qu'il restitue automatiquement via une instruction assembleur du style RTI. Mais là c'est un pic et la routine procédure d'interruption est en C. Soit il y a une routine assembleur qui est transparente, ou c'est plutot le compilateur qui transforme le C en assembleur qui les ajoute en voyant le mot clé INTERRUPT et en voyant "}" qu'il remplace par l'instruction RTI.
Il y a aussi ailleurs dans votre projet informatique une table de vecteur dans laquelle est indiquée le nom de la procédure d'interruption qu'il faut associer à la source timeur que vous utilisez.

Ce qui m'étonne c'est que la procédure d'interruption n'a pas de nom, en effet il pourrait très bien y avoir plusieurs interruptions donc plusieurs procédures. mais cela est peut être propre au compilateur microchip ?

Mais peut être que vous avez omis de nous présenter les include de .h et les différents fichier source du projet ( c et .asm) avec cette table.
cdlt

[invite5c0d525e]

Il n'y a pas d'appel "visible" de l'interruption c'est le débordement du timer qui la déclenche. Quand le timer déborde le bit TMR0IF (TiMeR 0 Interrupt Flag) passe à 1 et c'est lui qui apelle l'interruption. Ce bit est d'ailleur remis à 0 en fin d'interruption grâce à l'instruction TMR0IF_bit = 0; // Clear TMR0IF

[luc_1049]

J'ai peut être fait une erreur (je ne connais pas ce compilateur) lorque j'ai dit que la procédure d'interruption n'a pas de nom, en fait si interrupt n'est pas un mot réservé du compilateur elle est bien nommé, sinon ce serait sans doute interrupt void NOM().
En tout cas il doit bien avoir une table de vecteur, si c'est pas le cas, je suis curieux de savoir quel le dispositif implicite.

cdlt

[invite5c0d525e]

L'interruption n'a pas de nom propre. Si il n'y a qu'une seule source d'interruption comme c'est le cas ici, pas de soucis. Sinon il faut tester un à un les flags pour savoir qui a provoquer l'interruption et orienter le pgr en conséquence.

[luc_1049]

bonsoir

Ok ce n'est donc pas comme certains micros. Toutes les sources d'interruption matériel et les software sont donc traitées par la même procédure. Il faut donc y tester tous les flags qui sont succeptibles d'indiquer une des interruptions validées par le logiciel.
cdlt

[invite64bb2dc2]

Bonjour à tous,

D'abord encore merci pour vos réponse.
D'après ce que j'ai compris (corriger-moi si je me trompe) l'interruption se fait lorsque le bit TMR0IF passe 1 (Le programme principal passe la main à la fonction interruption). On doit remettre le bit TMR0IF à 0 pour redonner la main au programme principal.

Mais je vais encore vous embêter car je suis très curieux :
Je vous envoie un petit programme (fonction d'interruption) dont le résultat attendu est la même que la fonction d'interruption que vous avez vu dans le programme que je vous ai envoyé précédemment.
Ce que je ne comprends pas dans ce programme: C'est que non seulement le bit TMR0IF est mis à 0 (Ok j'ai compris), mais il met aussi le bit TOIE à 1 ("INTCON = 0x20; // Bit T0IF=0, T0IE=1"); ce qui n'est pas le cas dans la fonction d'interruption précédente. Pourquoi autorise-t-il une interruption dans la fonction d'interruption?
Le fait de mettre le TMR0IF ne suffit pas à donner la main au programme principal ? C'est troublant parce que dans ma fonction d'interruption précédente, j'ai l'impression que TMR0IE vaut 0.

void interrupt() {

if (digit_no==0) {
PORTA = 0; // Turn off all displays
PORTD = digit1; // Set mask for displaying ones on PORTD
PORTA = 1; // Turn on display for ones (RA0 = 1)
digit_no = 1;
} else if(digit_no==1) {
PORTA = 0; // Turn off all displays
PORTD = digit10; // Set mask for displaying tens on PORTD
PORTA = 2; // Turn on display for tens (RA1 = 1)
digit_no = 2;
} else if(digit_no==2){
PORTA = 0;
PORTD = digit100;
PORTA = 4; // Turn on display for hundreds (RA2 = 1)
digit_no = 3; // Turn on display for hundreds
} else {
PORTA = 0;
PORTD = digit1000;
PORTA = 8; // Turn on display for thousands (RA3 = 1)
digit_no = 0;
}
TMR0L = 0; // Reset counter TMROL
INTCON = 0x20; // Bit T0IF=0, T0IE=1 0x20
}

Point important aussi: excusez-moi mais vous n'avez pas répondu au deux première question:

1) Je ne comprends pas pourquoi portd_index s'incrément dans ma fonction interruption "portd_index++", j'ai l'impression qu'il devrait diminuer de 3 jusqu'à 0, c'est ce que je vois dans ma fonction principale avec pord_array[]:

digit = number / 1000u ; // extract thousands digit
portd_array[3] = mask(digit); // and store it to PORTD array
digit = (number / 100u) % 10u; // extract hundreds digit
portd_array[2] = mask(digit); // and store it to PORTD array
digit = (number / 10u) % 10u; // extract tens digit
portd_array[1] = mask(digit); // and store it to PORTD array
digit = number % 10u; // extract ones digit
portd_array[0] = mask(digit); // and store it to PORTD array

2) Ma variable Shifter j'ai compris (Corriger-moi si je me trompe) qu'il doit évoluer jusqu'à 8 afin de donner l'impression que mes 4 digit son activer simultanément (méthode de Multiplexage), mais je ne comprends pas comment il interagit avec le programme principal

// move shifter to next digit
shifter <<= 1;
if (shifter > 8u)
shifter = 1;

Merci, pour vos réponses

[luc_1049]

bonjour

Pour votre point important 1 , c'est vous qui avez le schéma, l'important pour le multiplexage c'est de charger tour à tour chaque valeur , que ce soit de 0 à 3 ou l'inverse je ne vois pas ce qui qui vous gène.

Pour le point 2 , Shifter est une variable globale, initialisée dans le main puis décalée et remise à 1 selon le cas au fur et à mesure de chaque interruption. Enfin Shifter est chargée dans LATA.

cdlt

[invite5c0d525e]

Et pour ce qui est du bit TOIE (overflow timer0 enable bit) il n'a rien à faire dans l'interruption, une fois qu'il est a 1 il le reste. C'est sans doute une étourderie de la part du gars qui a pondu le code.
Une petite précision toutefois, ce n'est pas la remise à 0 du flag TMR0IF qui met fin à l'interruption. L'interruption s'arrête à la fin de l'acolade et le programme reprend alors automatiquement son cours normal là où il s'était arrêté. Il est toutefois impératif de remettre ce bit à zéro car sinon le pic va détecter une nouvelle interruption sans que le timer n'ait débordé.
Autre chose, si tu dois à l'avenir faire toi-même tes programmes, il vaut mieux éviter de "traiter" l'interruption directement, surtout si tu dois en gérer plusieurs. il est préférable de faire un truc du style :

void interrupt() {
mettreàjourlaffichage
}

L'interruption appellera automatiquement la procédure "mettreajourlaffichage" (enfin je ne sais pas si en C ça s'appelle des procédures mais bon, tu vois ce que je veux te dire)

[luc_1049]

Bonsoir

Le précédent conseil précise qu'il vaut mieux utiliser une procédure afin de ne pas recopier le code soit.

Par contre il ne faudrait pas que cela induise en erreur dans un autre cas ou la procédure mettreajourlaffichage serait longue, car il faut éviter de mettre un traitement long dans une interruption.
Faire attention aussi à la portabilité des variables, en global il n'y a pas de pb toutefois comme c'est le cas ici.

cdlt