Programmation PIC

[invite5637435c]

Rassure toi tu en es capable, il n'y a rien de compliqué dans les interruptions, surtout sur un PIC.
Le fait de réapprendre, et surtout de le vouloir, te met en situation très favorable et tu feras un gain de temps non négligeable.
Dans un microcontrôleur il faut apprendre à utiliser les ressources offertes, hardware et software, l'usage des interruptions est incontournables.
Quand tu vas utiliser un timer par exemple tu seras contraint d'exploiter ces interruptions.

Je te recommande la lecture des cours de bigonoff, c'est facile à lire et très bien construit, le mode interruptif y est abordé et très accessible.
Ne t'en prive pas, c'est gratuit et une des rare références valables sur le net.
-----

[invite519aafc0]

Mon problème est que j'ai horreur de lire,mais vraiment je dit pas ça comme ça.

Et donc quand je lis quelque chose même si sa m’intéresse je ne retient pas ce que je lit car je ne suis pas concentré et a cause de celas je ne comprend rien a ce que je lit,c'est comme ça et c'est très embêtant.

Mais tu a raison sur le cour de Bigonoff et je n’aurais pas trop le choix de lire,j'ai cas me forcé lol.

[invite5637435c]

Ben oui tu n'as pas trop le choix, personne le fera à ta place.

[invite519aafc0]

Ah mais je demande pas qu'on le fasse a ma place loin de la.

En tous cas je vais essayer .

Tu veux quand même voir mon nouveau code? Horrible je suppose car aucune interruption lol.

[invite519aafc0]

Hello,

J'ai télécharger la partie 1 du cours.

C'est peut être moi qui ne suis trop con mais j'ai rien comprit lol,j'ai beau essayer de comprendre j'ai lut ça pendant des heure je n'y arrive pas :s et pourtant je fait des effort de concentration j'ai mal au crâne comme pas possible.

En plus la plupart du temps il parle en hexadecimal et j'ai l'impression que les codes c'est de l'assembleur.

Pourtant il a l'air de bien expliqué ça mais pas assez pour moi il me parle chinois,je sais ce qu'est une interruption maintenant et a quoi sa sert mais c'est tous ce que j'ai comprit mdr.Comment les déclarer,comment les utilisé et a quelle moment pour faire quelle action je n'en sais rien mdr.

Quand il parle de tmr0,il dit que sont débordement (la déjà je vois pas de quoi il parle) permet de générer une interruption.Quand il parle de débordement il par de 0xff a 0x00 déjà de l'hexadecimal.A priori si j'ai bonne logique 0xff = 1 et 0x00 = 0? Pourquoi si c'est le cas ne parle t il pas en 0 ou 1.

Quand survient le débordement par quoi?


Vraiment désoler si je ne comprend rien pourtant j'essaye et fortement même a me cramé le cerveau mais ça veut pas.

[invite5637435c]

L'hexa, le binaire, c'est juste une représentation identique d'un même nombre dans des bases différentes.
Il faut d'abord que tu te familiarises avec ces notions c'est juste indispensable...
Il vaut mieux écrire 0xFF que b11111111, avec l'habitude ce sera commun pour toi.

Un timer 8 bits compte de 0 à 255 ou de 0 à 0xFF puis repart de 0 etc... au moment où il attend 0xFF il génère une interruption au coup suivant pour dire qu'il a fini son comptage et qu'il recommence.

Si ta base de temps est par exemple Fosc=4MHz, sur un PIC le temps d'une instruction vaut t=4/Fosc=1µs
Donc ton compteur va passer de 0 à 1 en 1µs, de 1 à 2 en 2µs etc, donc le compteur va générer son interruption au bout de 255*1µs+1µs= 256µs

Le timer0 est un compteur 8 bits dont le drapeau de l'interruption correspondante se nomme TMR0IF, avec F comme "flag", elle doit être initialement mise à 0 pour pouvoir passer à 1.
Donc dans la boucle d'interruption tu vas écrire la chose suivante:

void interrupt(void)
{
if(TMR0IF_bit == 1) led = 1;
TMR0IF_bit = 0;
}

On écrit TMR0IF=0 afin de détecter un nouveau débordement.
led = 1; est un exemple d'action, mais ça peut tout aussi bien être une variable qui dans ton programme principal va autoriser une action.

Pour que ton timer soit opérationnel il faudra au préalable le déclarer et autoriser les interruptions matérielles et globales:

Voici un exemple avec un timer0 qui déborde au bout de 50ms:

//Usage de Timer0
//Prescaler 1:256; TMR0 Preload = 61 pour obtenir 50ms

void InitTimer0(){

OPTION_REG = 0x87;
TMR0 = 61;
INTCON = 0xA0;
}


void Interrupt()
{

if (TMR0IF_bit)
   {
   TMR0IF_bit = 0;
   allume_led = 1;
   TMR0 = 61;
   }
}
    
main()
{
......
......
InitTimer0();

while(1)
     {
     if(allume_led == 1)
       {
       allume_led = 0;
       TMR0IF = 0; // on remet le drapeau de débordement à 0
       LATB = 0xFF;    // allume toutes les leds du portB
       Delay_ms(20); // pendant 20ms
       }
     else LATB = 0; // les leds du portB sont toutes éteintes
     }
}

Dis moi déjà si tu comprends un peu tout ça.
@+

[invite519aafc0]

Le début oui mais pas la suite.

Si j'ai bien comprit le début la TMR0 une fois activé il commence le décompte tous seul sans qu'on y touche?

If(allume_led == 1)

Donc il passeras a 1 après les 50ms quand TMR0 auras fini de compte alors?

allume_led = 0; // je suppose que tu remet la variable a 0
TMR0IF = 0; // La j'ai comprit
LATB = 1; // La t'allume tous
delay_20ms;  // ok comprit

else LATB = 0; // Je suppose que ceci marche car la variable allume_led a été mise a 0 avant.

Je ne comprend pas le sens de l'utilisation de l'interruption,pourquoi pas faire une boucle for associer a une variable qui servirais justement de compteur pour faire clignoté les led.Celas fait moins de ligne de code.

Il vaut mieux écrire 0xFF que b11111111, avec l'habitude ce sera commun pour toi.

Eu oui ça j'avais comprit mais pourquoi pas écrire 1 tous court? Genre PORTB = 1; , Maintenant y a du sens ou si tu doit mettre b00100100 il doit y avoir l'hexadécimale pour ça et effectivement c'est plus rapide.

[invite5637435c]

En fait il y a une erreur dans le code quand j'ai écrit

LATB = 1;

Je devrait plutôt écrire:

LATB = 0xFF;

Pour allumer les 8 leds sur le PORTB.

Timer0 démarre dès que on lui dit de démarrer et que les interruptions sont activées dans INTCON.
INTCON est le registre d'interruption, il peut y en avoir plusieurs selon le PIC.
Dans INTCON tu trouves:
bit7: GIE (global interrupt enable -> autorise toutes les interruptions si mis à 1)
bit5: T0IE: timer0 overflow interrupt enable (autorise l'interruption de débordement du timer0 si mis à 1)
bit2: TMR0IF: timer0 overflow interrupt flag (drapeau mis à 1 lors du débordement du registre TMR0, doit être remis à 0 par soft)

Donc en inscrivant INTCON = 0xA0; on met GIE=1 et T0IE=1

Le compteur démarre dès que les interruptions sont activées.

[invite519aafc0]

Tu m'avais dit qu'avec les interruption c'étais plus souple.

Tu sais aussi que un delay,exemple de 1000ms tu pouvais rien faire tant que le micro contrôleur l’exécutais.

Moi j'ai fait un montage avec un LED RGB,quand j’appuie sur le bouton sa permet de choisir 3 mode de changement auto de couleur.

Mais entre chaque changement tu a 1s de delay,tant qu'il est dans la delay si j'appuie sur le bouton ben il se passe rien je doit laissé mon doigt dessus.

Moi je pensais que les interruption pouvais régler ça? C'est le cas?

Je vais poster le code je doit allé le chercher dans mon autre PC.

[invite5637435c]

Le début oui mais pas la suite.

Si j'ai bien comprit le début la TMR0 une fois activé il commence le décompte tous seul sans qu'on y touche?

Oui à condition d'avoir autorisé les interruptions GIE et TMR0IE

If(allume_led == 1)

Donc il passeras a 1 après les 50ms quand TMR0 auras fini de compte alors?

Le flag passera à 1 et donc mettra à 1 la variable allume_led, qui donc autorisera l'allumage des leds dans le programme principale puisque la condition sera remplie.

allume_led = 0; // je suppose que tu remet la variable a 0 -> oui pour autoriser un nouveau passage plus tard 
TMR0IF = 0; // La j'ai comprit
LATB = 1; // La t'allume tous -> voir mon post précédent
delay_20ms;  // ok comprit

else LATB = 0; // Je suppose que ceci marche car la variable allume_led a été mise a 0 avant. -> eh oui si elle est à 0 on ne veut pas les leds allumées

Je ne comprend pas le sens de l'utilisation de l'interruption,pourquoi pas faire une boucle for associer a une variable qui servirais justement de compteur pour faire clignoté les led.Celas fait moins de ligne de code.

justement, le but de l'interruption est de travailler en tâche de fond et d'attendre la survenue de l'évènement, si tu as besoin de faire quelque chose d'autres tu peux, si tu réalises une boucle et bien tu ne peux pas faire autre chose tant que cette boucle est en cours... Ton exemple de bouton doit te faire comprendre ça.

[invite5637435c]

Tu m'avais dit qu'avec les interruption c'étais plus souple.

Tu sais aussi que un delay,exemple de 1000ms tu pouvais rien faire tant que le micro contrôleur l’exécutais.

Moi j'ai fait un montage avec un LED RGB,quand j’appuie sur le bouton sa permet de choisir 3 mode de changement auto de couleur.

Mais entre chaque changement tu a 1s de delay,tant qu'il est dans la delay si j'appuie sur le bouton ben il se passe rien je doit laissé mon doigt dessus.

Moi je pensais que les interruption pouvais régler ça? C'est le cas?

Je vais poster le code je doit allé le chercher dans mon autre PC.

Ben oui c'est le cas!
Comprends bien qu'en mode interruption le programme principal tourne jusqu'au moment où le temps de la tempo est atteint et que son flag est levé, là c'est la boucle d'interruption qui est prioritaire et exécute la tâche, l'adresse à laquelle se trouvait le programme principal est stockée le temps du traitement de l'interruption puis le compteur de programme reprend là où il en était.
Donc le temps de latence est réduit à quelques cycles machine contrairement à une boucle dans le programme principal qui doit finir sa tâche pour faire autre chose ensuite.

[invite519aafc0]

Voila mon code.

sbit bp1 at RB0_bit;
sbit r at RB1_bit;
sbit g at RB2_bit;
sbit b at RB3_bit;
sbit bp2 at RB5_bit;
unsigned char bascule1;
unsigned char bascule2;


void main() {
PORTB = 0;
TRISB = 0b00100001;
bascule1 = 0;
bascule2 = 0;

while(1)
{

 if (bp1 == 0)
 {
  bascule2 = 0;
  delay_ms(25);
  bascule1++;
  while(!bp1);
  delay_ms(25);
 }
 
  if (bp2 == 0)
 {
  bascule1 = 0;
  delay_ms(25);
  bascule2++;
  while(!bp2);
  delay_ms(25);
 }
 
 if (bascule1 == 1)
 {
  r = 1;
 }
 
 if (bascule1 == 2)
 {
  g = 1;
 }
 
 if (bascule1 == 3)
 {
  b = 1;
 }
 
 if (bascule1 == 4)
  {
   r = 1;
   g = 1;
  }
 
 if (bascule1 == 5)
  {
   g = 1;
   b = 1;
  }
 
 if (bascule1 == 6)
  {
   r = 1;
   b = 1;
  }
 
 if (bascule1 == 7)
  {
   r = 1;
   g = 1;
   b = 1;
  }
 
 if (bascule2 == 1)
  {
    r = 1;
    delay_ms(1000);
    r = 0;
    g = 1;
    delay_ms(1000);
    g = 0;
    b = 1;
    delay_ms(1000);
    b = 0;
  }
  
 if (bascule2 == 2)
  {

    r = 1;
    g = 1;
    delay_ms(1000);
    r = 0;
    g = 0;
    g = 1;
    b = 1;
    delay_ms(1000);
    g = 0;
    r = 1;
    delay_ms(1000);
    g = 1;
    delay_ms(1000);
    g = 0;
    b = 0;
  }

  if (bascule2 == 3)
  {
    r = 1;
    delay_ms(1000);
    r = 0;
    g = 1;
    delay_ms(1000);
    g = 0;
    b = 1;
    delay_ms(1000);
    b = 0;
    r = 1;
    g = 1;
    delay_ms(1000);
    r = 0;
    g = 0;
    g = 1;
    b = 1;
    delay_ms(1000);
    g = 0;
    r = 1;
    delay_ms(1000);
    g = 1;
    delay_ms(1000);
    g = 0;
    b = 0;
  }

 if (bascule1 == 8)
 {
  bascule1 = 0;
 }
 
 if (bascule2 == 4)
  {
   bascule2 = 0;
  }
 
 else
 {
  r = 0;
  g = 0;
  b = 0;
 }

}
}

Donc je devrais pour faire changer de couleur utilisé des interruption?

[invite5637435c]

Décris moi exactement ce que tu veux faire.
A mon avis il serait plus judicieux de pouvoir interrompre un cycle quand on veut pour changer les couleurs à la volée, plutôt que d'attendre la fin d'un cycle 1s.
non?
Tu veux faire un fondu-enchainé d'après ce que je lis dans ton code et pouvoir fixer une couleur selon le nombre d'appui.
Ce que je verrai:

A chaque appui court on fixe une couleur.
Avec un appui long on lance un fondu-enchainé
Si un appui court survient on revient en mode couleur fixe.
Qu'en dis-tu?

[invite519aafc0]

Oui c'est pas mal.

Quand tu regarde mon code tu vois que je fait 3 mode de fondu enchaîné,le bp 1 sert a fixer la couleur et le bp 2 a choisir entre 3 mode automatique de changement de la couleur.

Et quand tu dit de faire ça avec un seul bouton c'est pas une mauvaise idée du tous,j'y avais pensé mais rien ne me vient a l'esprit pour réussir cette programmation la.

Il faudrait aussi que un autre appui long permette de passé au 2ième mode de fondu par exemple.

Mais déjà si je comprend pas trop les interruption sa ne sert a rien de tenté de programmer celas.Au tend le laissé en suspend et commencer un simple projet juste avec un seul bp qui permet de choisir entre 2 mode de fondu.


Maintenant si j'arrive vraiment pas a comprendre c'est que je suis pas assez futé faut se rendre a l'évidence,en plus c'est gentil de ta pare de m'aider comme ça.

[invite519aafc0]

Salut,

J'ai un peut réfléchi sur les interruptions.

Est ce que une interruption sert justement de tâche de fond et permet de sortir d'une while?


Peut on utilisé une interruption qui décompte toute seul et s'enclenche seul toute les x µS?

Exemple mettre tous les appels de bouton dans une interruption qui s’enclenche toute les 100µS par exemple,qui permettrais quand je suit dans une while exemple avec un clignotement de led avec delay de 1s.Qui permettrais que même si le delay est en cour que le programme puisse lire l'action d'un bouton?

Merci d'avance.

[inviteb6b75063]

Une interruption n'est pas "une tâche de fond". Quand elle a lieu, le microcontrôleur sauve tout ce qu'il a en cours de traitement.
Puis il traite l'interruption. Quand il a finit, il restaure tout ce qu'il a sauvegardé, et reprend ses tâches.
Donc non, elle ne permet pas de "sortir d'une while"

Par contre, je n'ai pas compris ta seconde demande.

[Gérard]

Si, l'interruption sort du while et quand le traitement est fini, le programme reprend là où il a été interrompu dans le while.

[invite519aafc0]

Hello,

Par contre, je n'ai pas compris ta seconde demande.

Voici un exemple d'un code sans interruption et donc on constate un problème :

sbit Bouton at RB0_bit;
sbit LED at RB1_bit;
bit bascule; //variable 0 ou 1;

void main()
{

PORTB = 0; / int I/O
TRISB = 0b00000001; //int E/S RB0 en entrée seulement

while(1)
{
  if (Bouton == 0)
  {
   while(Bouton!);
   delay_ms(50);
   bascule++;
  }
  
  if (bascule == 1)
  {
   LED = 1;
   delay_ms(2000);
   LED = 0;
   delay_ms(2000);
   }

  else
  {
   LED = 0;
  }

}
}

Donc ici quand je push le bouton la led va clignoté avec intervalle de 2s,si je re push sa stop.

Bon ici le but est de contrer l'attente du delay,car une fois que le programme exécute le delay de 2s il ne prend plus en compte mes actions sur le bouton tant qu'il n'a pas fini.

Je pensais exécuter une interruption a intervalle de X µs et d'y mettre la fonction du Bouton.C'est a dire que quand le programme ce déroule,tous les x temps ben il lance cette interruption qui permet de faire l'action sur le bouton.

En gros permettre au programme de vérifier en permanence l'état du bouton hors de la while.Ce qui permettrais que si dans la while il y a un long delay,de pouvoir quand même changé l'état du bouton et qu'il le prennent en compte et donc permettrais de changer l'état de la variable bascule.

J'espère que je me suis mieux exprimé .

[antek]

Tu peux générer une interruption avec la période de ton choix avec un timer.

[invite519aafc0]

Tu peux générer une interruption avec la période de ton choix avec un timer.

Tu parle de l'interruption TMR0?

[antek]

N'importe quel timer fait l'affaire.
Celui qui ne sert pas à autre chose.

[invite519aafc0]

Ta un exemple de code?

[antek]

Tu veux une interruption tous les combien et quoi faire dans la routine d'interruption ?

[invite519aafc0]

Tu veux une interruption tous les combien et quoi faire dans la routine d'interruption ?

L'interruption toute les 100µS par exemple.

Mais ta vu le code que j'ai mit?

Je ne sais pas si c'est la partie ou je fait change la LED de couleur que je doit mettre dans l'interruption ou la partie qui fait l'appel du bouton.


Quand ta ça tu ferais quoi? (regarde les commentaire dans le code pour voir ou est le problème)

sbit Bouton at RB0_bit;
sbit LED at RB1_bit;
bit bascule; //variable 0 ou 1;

void main()
{

PORTB = 0;
TRISB = 0b00000001;

while(1)
{
  if (Bouton == 0)
  {
   while(Bouton!);
   delay_ms(50);
   bascule++;
  }
  
  if (bascule == 1)
  {
   LED = 1;
   delay_ms(2000); // !!! Ici pendant le delay tu peut actionné le bouton rien ne se passe
   LED = 0;
   delay_ms(2000); // !!! Egalement ici,logique
   }

  else
  {
   LED = 0;
  }

}
}

Je ne veux surtout pas que tu règle le problème a ma place surtout.J'essaye juste de comprendre le rôle de l'interruption dans ce genre de cas et comment l'appliqué.

[antek]

J'ai pas suivi depuis le début et je programme en assembleur.
D'après ce que j'ai compris, tu veux tester un bit sur un port pendant le "delay" ?
- avant le "delay" tu aurorises INT
- pendant le "delay" à chaque interruption tu testes le bit (dans la routine INT)

Si tu n'as pas besoin de INT en dehors des "delay" tu interdis INT en sortant de "delay"

C'est ça que tu veux ?

Avec ton langage je sais pas comment est fabriqué le "delay"

[invite519aafc0]

Oui

Désoler je ne savais pas que tu programmais en ASM.


Moi je programme que en C.

Si j'ai bien comprit avant le delay tu active l'interruption qui toute les 100µs teste l'état du bouton (donc en gros pendant un delay on sais faire une tache de fond si je puis dire qui testera l'état du bouton) et après le delay ben comme j'en ai plus besoin je peut désactivé l'interruption?


Maintenant celas poserais un problème si on l'active tous le temps?

Exemple :


activation de l'interruption
action
delay
action
delay
action
delay
désactivation de l'interruption

A chaque ligne de code il testera l'état du bouton.Tu en pense quoi?

[antek]

L'entrée est testée à chaque interruption (dans sa routine), pas à chaque ligne de code.
Faut pas la laisser active si tu as des choses urgentes à faire dans "action"

Faut pas appeler ça une tâche de fond

[Gérard]

Ta un exemple de code?

Et 100 balles et un mars ?

Pour comprendre le mécanisme des interruptions, tu devrais lire Bigonoff, c'est très bien expliqué.

[Gérard]

je préfère faire une fonction "tout OFF" et une "tout ON", tu économiseras de nombreuses ligne de code !

Bienvenu à toi.

Mais encore ?
Tu peux expliquer ?

[invitec6549ba7]

Ca fait bien longtemps que je n'ai pas fait ça, mais je ne pense pas que ça ait changé.

une interruption se déclanche avec un flag, ce flag peut être une GPIO, un timer, une reception série et surement autre chose. Ton interruption va lancer une autre fonction, ainsi tu peux éxécuter ta boucle while et dès que ton timer va arriver à son terme tu vas lancer une fonction dans laquelle tu allume ta LED.

regarde : http://ww1.microchip.com/downloads/e...Doc/41291D.pdf P33 pour plus d'infos