Boucle while pic 12F675
Répondre à la discussion
Page 1 sur 2 1 DernièreDernière
Affichage des résultats 1 à 30 sur 33

Boucle while pic 12F675



  1. #1
    invite9d655374

    Boucle while pic 12F675


    ------

    Bonjour,
    Je viens vers vous car d'une part je débute dans l' univers des pics, et que ça fait un moment que je me heurte à un problème sur la programmation en Mikroc d' un pic 12F675. En effet j' utilise un bouton poussoir pour passer successivement à l' état haut puis bas 3 pins d' un pic 12f675 et cela fonctionne très bien. Par contre dès que je veux faire un mode "case 4" utilisant les 3 pins style chenillard ça fonctionne 1 fois et la boucle s' arrête. Voila j' espère que mon explication n' est pas trop confuse. ci joint mon code réalisé avec MPLABX IDE v 2.2.
    Merci beaucoup pour votre aide.

    #include <stdio.h>
    #include <stdlib.h>
    #include <xc.h>

    #pragma config FOSC = INTRCIO // Oscillator Selection bits (INTOSC oscillator: I/O function on GP4/OSC2/CLKOUT pin, I/O function on GP5/OSC1/CLKIN)
    #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT enabled)
    #pragma config PWRTE = OFF // Power-Up Timer Enable bit (PWRT disabled)
    #pragma config MCLRE = OFF // GP3/MCLR pin function select (GP3/MCLR pin function is MCLR)
    #pragma config BOREN = ON // Brown-out Detect Enable bit (BOD enabled)
    #pragma config CP = OFF // Code Protection bit (Program Memory code protection is disabled)
    #pragma config CPD = OFF // Data Code Protection bit (Data memory code protection is disabled)

    #define _XTAL_FREQ 4000000

    //Variable
    int Compteur;
    void main()
    {
    //Initialisation
    OPTION_REG = 0b000000;
    CMCON = 0b000111;
    TRISIO = 0b000010;
    ANSELbits.ANS0 = 0;
    ANSELbits.ANS1 = 0;
    ANSELbits.ANS2 = 0;
    ANSELbits.ANS3 = 0;
    GPIO = 0;

    Compteur = 0;
    GPIO = 0b000000;

    while (1)
    {
    if (GPIO1)
    {
    BoucleBP:
    ;
    if (GPIO1)
    {
    goto BoucleBP;
    }
    Compteur = Compteur + 1;
    }
    switch (Compteur)
    {
    case 0:
    GPIO = 0b000000;
    {
    break;
    }
    case 1:
    {
    GPIO = 0b000001;
    break;
    }
    case 2:
    {
    GPIO = 0b000100;
    break;
    }
    case 3:
    {
    GPIO = 0b010000;
    break;
    }
    case 4:
    {
    GPIO = 0b000000;
    __delay_ms(250);
    GPIO = 0b000001;
    __delay_ms(250);
    GPIO = 0b000100;
    __delay_ms(250);
    GPIO = 0b010000;
    __delay_ms(250);
    break;
    }
    case 5:
    {
    GPIO = 0b000000;
    Compteur = 0;
    break;
    }
    }
    }
    }

    -----

  2. #2
    paulfjujo

    Re : Boucle while pic 12F675

    bonjour,


    Presente ton code entre balises, et surtout veille à la presentation et identation
    pour avoir une meilleur lisibilité et vision d'un bug potentiel..
    smiliblick dans le 1er test case

    Code:
     switch (Compteur)
     {
     case 0:
      {
       GPIO = 0b000000;
       break;
       }
     case 1:
       {
       GPIO = 0b000001;
       break;
       }
     case 2:
       {
        GPIO = 0b000100;
        break;
        }
    case 3:
       {
       GPIO = 0b010000;
       break;
       }
    case 4:
      {
      GPIO = 0b000000;
      __delay_ms(250);
      GPIO = 0b000001;
      __delay_ms(250);
      GPIO = 0b000100;
      __delay_ms(250);
      GPIO = 0b010000;
      __delay_ms(250);
      break;
      }
    case 5:
         {
         GPIO = 0b000000;
         Compteur = 0;
         break;
         }
    } //switch

  3. #3
    invitefa96bd8f

    Re : Boucle while pic 12F675

    salut,

    sans avoir ton cablage hard, j'aurai une question:

    GPIO = 0b000000;
    __delay_ms(250);
    GPIO = 0b000001;
    __delay_ms(250);
    GPIO = 0b000100;
    __delay_ms(250);
    GPIO = 0b010000;

    est-ce normal que sur la dernière ligne que j'ai copiée, tu décalles de deux bits au lieu d'un seul ?

    sinon, comme d'ab, utiliser du "vrai" c, et pas des fonctions préfaites ou on ne sait pas trop ce qui se passe à l'intérieur, ca évite des surprises

  4. #4
    invite9d655374

    Re : Boucle while pic 12F675

    Merci pour vos réponses rapides,
    Paulfjujo: c' est exact, je débute en programmation, mais ce n' est pas une raison pour ne pas prendre les bonnes habitudes des le début.

    terriblement: oui je décale de deux bits car sauf erreur de ma part la pin GPIO3 du 12F675 n' est pas bi-directionnelle elle ne s' utilise qu' en input (cf datasheet).
    Concernant le code pour le moment à mon niveau il est plus simple d' utiliser des fonctions préfaites mais je ne désespèrepas programmer en "vrai C" comme tu dis. C' est en forgeant qu' on devient .....

  5. A voir en vidéo sur Futura
  6. #5
    invite9d655374

    Re : Boucle while pic 12F675

    Ci joint le schéma du cablage sous ISIS Proteus.
    Nom : LedRGB.JPG
Affichages : 314
Taille : 86,1 Ko

  7. #6
    paulfjujo

    Re : Boucle while pic 12F675

    est-ce que tu as corrigé le
    smiliblick dans le 1er test case

    la pin GPIO3 du 12F675 n' est pas bi-directionnelle
    exact..

  8. #7
    invitee05a3fcc

    Re : Boucle while pic 12F675

    Sur la pin 6, il faut une résistance de PullUP de 10K (ou valider la PullUp interne si c'est possible )

  9. #8
    invite9d655374

    Re : Boucle while pic 12F675

    "est-ce que tu as corrigé le
    smiliblick dans le 1er test case"

    1er test case "Case 0" tout est à l' état bas c' est à dire les 3 led etteintes. Je ne vois comme erreur que GPIO3 1 et pas 0 en binaire 0b001000.

  10. #9
    paulfjujo

    Re : Boucle while pic 12F675

    de plus le test bouton est Horrible.. on ne met pas de saut dans un if qui est lui meme dans une boucle

    On suppose que ton entree GPOI1 est bien tiree au +VCC , au repos, donc à l'etat 1 si BP non activé.

    Code:
    ....
    
    while(1)
    {
      
       while   (GPIO1==1)   // boucle en attendant l'appui sur BP
       {
          delay_ms(100);  // il faudra appuyer sur le BP au moins 100mS pour sortir de la boucle
        }
       // donc GPIO1 est passé à zero pendant plus de 100mS 
    
       Compteur = Compteur + 1;
       switch (Compteur)
       {
        case 0:
    	{
     	GPIO = 0b000000;
    	break;
    	}
        case 1:
        	{
    	GPIO = 0b000001;
    	break ;
               }
    ... etc ....

  11. #10
    invite9d655374

    Re : Boucle while pic 12F675

    J' ai paramétrer le pic en "resistance pull-up" interne. La simulation sur ISIS fonctionne, allumage des leds fixes, mais pas l' allumage temporisé successif et infini cf case 4.

  12. #11
    invite9d655374

    Re : Boucle while pic 12F675

    ok merci paulfjujo,
    De plus il est noté de partout que le goto est à proscrire.

  13. #12
    paulfjujo

    Re : Boucle while pic 12F675

    mais pas l' allumage temporisé successif et infini cf case 4.
    repost ton code actuel...

  14. #13
    invite9d655374

    Re : Boucle while pic 12F675

    Ci dessous le code avec la modification au niveau du boutton poussoir. Il me semble que la variable compteur ne s' incrémente pas.


    #include <stdio.h>
    #include <stdlib.h>
    #include <xc.h>

    #pragma config FOSC = INTRCIO // Oscillator Selection bits (INTOSC oscillator: I/O function on GP4/OSC2/CLKOUT pin, I/O function on GP5/OSC1/CLKIN)
    #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT enabled)
    #pragma config PWRTE = OFF // Power-Up Timer Enable bit (PWRT disabled)
    #pragma config MCLRE = OFF // GP3/MCLR pin function select (GP3/MCLR pin function is MCLR)
    #pragma config BOREN = ON // Brown-out Detect Enable bit (BOD enabled)
    #pragma config CP = OFF // Code Protection bit (Program Memory code protection is disabled)
    #pragma config CPD = OFF // Data Code Protection bit (Data memory code protection is disabled)

    #define _XTAL_FREQ 4000000

    //Variable
    int Compteur;

    //Initialisation
    void INIT()
    {
    OPTION_REG = 0b000000;
    CMCON = 0b000111;
    TRISIO = 0b000010;
    ANSELbits.ANS0 = 0;
    ANSELbits.ANS1 = 0;
    ANSELbits.ANS2 = 0;
    ANSELbits.ANS3 = 0;
    GPIO = 0;
    Compteur = 0;
    GPIO = 0b000000;
    }

    void main()
    {
    INIT();
    while (1)
    {
    //début code paulfjujo
    while (GPIO1==1)
    {
    __delay_ms(100);
    }
    Compteur = Compteur + 1;
    //fin code paulfjujo

    switch (Compteur)
    {
    case 0:
    GPIO = 0b000000;
    {
    break;
    }
    case 1:
    {
    GPIO = 0b000001;
    break;
    }
    case 2:
    {
    GPIO = 0b000100;
    break;
    }
    case 3:
    {
    GPIO = 0b010000;
    break;
    }
    case 4:
    {
    GPIO = 0b000000;
    __delay_ms(250);
    GPIO = 0b000001;
    __delay_ms(250);
    GPIO = 0b000100;
    __delay_ms(250);
    GPIO = 0b010000;
    __delay_ms(250);
    break;
    }
    case 5:
    {
    GPIO = 0b000000;
    Compteur = 0;
    break;
    }
    }
    }
    }

  15. #14
    invite9d655374

    Re : Boucle while pic 12F675

    Merci Paul,
    Grace à toi mon problème devient plus clair. Celui ci fonctionne comme je veux en modifiant "while" par "if" et en testant l' appuie sur le BP selon tes conseils:
    0 actif.
    1 non actif.
    donc if (GPIO1==0) BP actif
    juste petit bemol la detection du BP n' est pas fluide il faut appuyer plusieur fois.


    #include <stdio.h>
    #include <stdlib.h>
    #include <xc.h>

    #pragma config FOSC = INTRCIO // Oscillator Selection bits (INTOSC oscillator: I/O function on GP4/OSC2/CLKOUT pin, I/O function on GP5/OSC1/CLKIN)
    #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT enabled)
    #pragma config PWRTE = OFF // Power-Up Timer Enable bit (PWRT disabled)
    #pragma config MCLRE = OFF // GP3/MCLR pin function select (GP3/MCLR pin function is MCLR)
    #pragma config BOREN = ON // Brown-out Detect Enable bit (BOD enabled)
    #pragma config CP = OFF // Code Protection bit (Program Memory code protection is disabled)
    #pragma config CPD = OFF // Data Code Protection bit (Data memory code protection is disabled)

    #define _XTAL_FREQ 4000000

    //Variable
    int Compteur;

    //Initialisation
    void INIT()
    {
    OPTION_REG = 0b000000;
    CMCON = 0b000111;
    TRISIO = 0b000010;
    ANSELbits.ANS0 = 0;
    ANSELbits.ANS1 = 0;
    ANSELbits.ANS2 = 0;
    ANSELbits.ANS3 = 0;
    GPIO = 0;
    Compteur = 0;
    GPIO = 0b000000;
    }

    void main()
    {
    INIT();
    while (1)
    {

    //début code paulfjujo
    if (GPIO1==0)
    {
    __delay_ms(100);
    Compteur = Compteur + 1;
    }
    //fin code paulfjujo

    switch (Compteur)
    {
    case 0:
    GPIO = 0b001000;
    {
    break;
    }
    case 1:
    {
    GPIO = 0b001001;
    break;
    }
    case 2:
    {
    GPIO = 0b001100;
    break;
    }
    case 3:
    {
    GPIO = 0b011000;
    break;
    }
    case 4:
    {
    GPIO = 0b001000;
    __delay_ms(250);
    GPIO = 0b001001;
    __delay_ms(250);
    GPIO = 0b001101;
    __delay_ms(250);
    GPIO = 0b011101;
    __delay_ms(250);
    break;
    }
    case 5:
    {
    GPIO = 0b001000;
    Compteur = 0;
    break;
    }
    }
    }
    }

  16. #15
    paulfjujo

    Re : Boucle while pic 12F675

    Avec un While
    tu bloqueq le programme sur BP ouvert et attens un appui sur le BP, qui doit durer plus de 100mS
    pour en sortir (du while) !
    le but est d'eliminer les rebonds du BP.. au fait ,
    test reel ou simulation seulement ?

    La fonction delay est-elle correcte .. avec Q=4Mhz ?

    de plus, rajoute un delay dans la boucle infinie While(1);
    avant de ne pas revenir trop vitedans le test du BP..
    il n'y a pas de raison à ce que le compteur ne s'incremente pas..

    revois aussi l'ecriture du case 0: ..parenthese mal placee




    while (GPIO1==1)
    {
    __delay_ms(100);
    }
    Compteur = Compteur + 1;
    ...
    ..

    delay_ms(500); // delai à rajouter en fin de boucle
    }// fin du while 1

  17. #16
    invite9d655374

    Re : Boucle while pic 12F675

    Les simulations sont faites avec isis.

    Si j' utilise :
    while (GPIO1==1) boucle tant que le BP n 'est pas actionné
    le programme correspondant à "CASE 4" ne fait pas clignoter les 3 leds indefiniment il ne fait qu 'un seul passage et stop en attendant un nouvel appui sur le BP pour continuer.
    si j' utilise :
    if (GPIO1==0)test si le BP est enfoncé
    le programme fonctionne et les 3 leds clignotent indefiniment "CASE4" jusqu' à un nouvel appui sur le BP.

    Paulfjujo merci de t'intéresser à mon problème.

  18. #17
    invite9d655374

    Re : Boucle while pic 12F675

    Je me répond à moi même,
    C' est normal qu' en utilisant while la boucle ne s' éxécute qu' une fois car après l' appui sur le BP, le programme retourne dans la boucle while (GPIO1==1) et attend un nouvel appui sur le BP pour en sortir. Par contre en utilisant if (GPIO1==0) le programme boucle sur le main programme et test à chaque passage l' état du BP.
    Effectivement paulfjujo il faut bien régler les tempos pour que le programme soit syncro. Quand je disais plus haut que l' appui sur le BP n' était pas fluide, en fait ça vient du fait que temps que le code dans la condition CASE n' est pas terminé la variable compteur ne change pas donc le programme ne change pas la condition CASE.
    Existe t' il un moyen d' arrêter le code sans attendre la fin de son éxécution dans le CASE 4.

    Appui bref sur BP pour changement d' état
    case 3:
    {
    GPIO = 0b011000;
    break;

    Appui long sur BP pour changement d' état case 4:
    {
    GPIO = 0b000000;
    __delay_ms(250);
    GPIO = 0b000001;
    __delay_ms(250);
    GPIO = 0b000100;
    __delay_ms(250);
    GPIO = 0b010000;
    __delay_ms(250);
    break;
    }

  19. #18
    paulfjujo

    Re : Boucle while pic 12F675

    Existe t' il un moyen d' arrêter le code sans attendre la fin de son éxécution dans le CASE 4.
    il faut alors traiter l'appui du BP et l'incrementation du compteur en mode interruption..
    il agira alors quelque soit l'endroit du programme principal
    et modifier case 4

    Code:
    case 4:
    {
    while(Compteur==4)   // on test si la condition d'entree du case reste inchangee ou non
    {                              // un appui sur BP changera la valeur du compteur , et ainsi on sort de la boucle
    GPIO = 0b000000;
    __delay_ms(250);
    GPIO = 0b000001;
    __delay_ms(250);
    GPIO = 0b000100;
    __delay_ms(250);
    GPIO = 0b010000;
    __delay_ms(250);
    }
    break;
    }
    Dernière modification par paulfjujo ; 25/11/2014 à 10h24.

  20. #19
    invite9d655374

    Re : Boucle while pic 12F675

    Ah les interruption... pas encore abordé le sujet.De la lecture en perspective, il faut que je me documente.
    Mais bon merci paulfjujo avec ton aide en 24H00 j' ai plus avancé qu' en 15 jours.

  21. #20
    RISC

    Re : Boucle while pic 12F675

    Salut,

    Il y a d'excellents tutoriels pour les PIC sur http://www.gooligum.com.au/tut_midrange_C.html

    a+

  22. #21
    invite9d655374

    Re : Boucle while pic 12F675

    Merci Risc A+

  23. #22
    invite9d655374

    Re : Boucle while pic 12F675

    Bonjour me revoila,
    Je reviens vers vous pour une question concernant les interruptions. J' ai testé deux interruptions externe sur changement d'état du bit GP1 et du bit GP2 le GP2 fonctionne mais pas GP1 malgré que GP1 peut être configuré en external interrupt.

    Pour GP2 j initialise Les bits 7 et 4 du registre INTCON
    et je test le flag INTF celui ci fonctionne ma variable s' incremente normalement.

    void interrupt Lsr(void)
    {
    if (INTCONbits.INTF) // Test du flag sur changement d' etat du port GP2
    {
    if (Compteur < 4)
    {
    Compteur = Compteur + 1;
    }
    else
    {
    Compteur = 0;
    }
    }
    INTCONbits.INTF = 0;// remise à zero du flag
    }



    Pour GP1 j initialise Les bits 7 et 3 du registre INTCON
    et j' initialise aussi le bit1 du registre IOC
    et je test le flag GPIF celui ci ne fonctionne pas.


    void interrupt Lsr(void)
    {
    if (INTCONbits.GPIF) // Test du flag sur changement d' etat du port 1
    {
    if (Compteur < 4)
    {
    Compteur = Compteur + 1;
    }
    else
    {
    Compteur = 0;
    }
    }
    INTCONbits.GPIF = 0;// remise à zero du flag
    }

    ci joint un extrait du datasheet du 12F675 et merci pour vos réponses.

    datasheet Registre INTCON
    GIE PEIE T0IE INTE GPIE T0IF INTF GPIF
    bit 7 bit 0

    datasheet registre IOC
    — — IOC5 IOC4 IOC3 IOC2 IOC1 IOC0
    bit 7 bit 0

  24. #23
    Gérard

    Re : Boucle while pic 12F675

    Je voudrais juste poser une question : pourquoi les break dans les "case" ?

  25. #24
    paulfjujo

    Re : Boucle while pic 12F675

    bonjour,

    Citation Envoyé par Gérard Voir le message
    Je voudrais juste poser une question : pourquoi les break dans les "case" ?
    http://fr.wikiversity.org/wiki/Java/...onditionnelles
    Si une instruction case ne contient pas de break alors les traitements associés au case suivant sont exécutés.
    comme pour le java, je pense que c'est pour avoir un code plus efficace , plus rapide.

    .

  26. #25
    invite9d655374

    Re : Boucle while pic 12F675

    Bonjour, messieurs.
    paulfjujo content de te retrouver, tu vois j' ai un peu potassé les interruptions.
    Sauf erreur de ma part c' est pour sortir plus vite du switcher une fois la condition trouvée le code sort du switcher à cet endroit 'Break' et stop les comparaisons.

  27. #26
    Gérard

    Re : Boucle while pic 12F675

    Citation Envoyé par paulfjujo Voir le message
    bonjour,





    comme pour le java, je pense que c'est pour avoir un code plus efficace , plus rapide.

    .
    Je suis étonné, je pensais qu'on sortait dès qu'une condition est vrai après exécution de ce qui est demandé.

  28. #27
    invite9d655374

    Re : Boucle while pic 12F675

    Bonjour,
    N' ayant pas de réponse, je reformule ma question parce que je l' ai peut être mal exposée.
    Est-il possible de configurer le port GP1 d' un pic 12F675 pour l' utiliser en interruption externe sur changement d' état par un bouton poussoir.
    Merci.

  29. #28
    Gérard

    Re : Boucle while pic 12F675

    Oui, il faut configurer les registres IOC et INTCON.

  30. #29
    paulfjujo

    Re : Boucle while pic 12F675

    bonsoir,

    En effet, tu progresses ..

    Pour GP1 j initialise Les bits 7 et 3 du registre INTCON
    et j' initialise aussi le bit1 du registre IOC
    et je test le flag GPIF celui ci ne fonctionne pas.
    Cela me parait correct ...
    La difference de reponse sur interruption entre GP2 et GP1 est que GP2 reagit sur un front , GP1 sur un changement d'etat..

    As tu une resistance de rappel au +5V sur GP1 avec le BP entre entree et 0V ?
    Reposte tout ton code et le schema du montage ..

  31. #30
    invite9d655374

    Re : Boucle while pic 12F675

    Merci Gerard,
    C' est ce que j' ai fais mais mal je pense parce que je n' ai pas le résultat attendu.
    Ma configuration INTCON et IOC pour Interruption sur GP1.
    INTCON = 0b1001000; //Bit 7 pour interruption globale (GIE) et bit3 pour surveiller l' interruption sur port 0 à 5 (GPIE).
    IOC = 0b0000010; // Bit 1 pour interruption sur GP1.

Page 1 sur 2 1 DernièreDernière

Discussions similaires

  1. relation entre gain statique en boucle ouverte et celui en boucle fermee
    Par invite21730e48 dans le forum Électronique
    Réponses: 4
    Dernier message: 29/09/2014, 21h47
  2. problème boucle interruption avec boucle spi
    Par invitef9a5b0e0 dans le forum Électronique
    Réponses: 8
    Dernier message: 16/03/2013, 03h26
  3. Diagramme de Bode boucle ouverte et boucle fermée
    Par invite29a24ce3 dans le forum Physique
    Réponses: 4
    Dernier message: 21/06/2012, 14h24
  4. Probleme boucle for ou boucle do...while imbriquées
    Par invite3d4f2ff3 dans le forum Électronique
    Réponses: 8
    Dernier message: 09/06/2010, 11h32
  5. Boucle ouverte boucle fermée
    Par invitedaf7b98f dans le forum Physique
    Réponses: 5
    Dernier message: 10/01/2010, 16h13
Dans la rubrique Tech de Futura, découvrez nos comparatifs produits sur l'informatique et les technologies : imprimantes laser couleur, casques audio, chaises gamer...