Programmation PIC18F (valable pour les autres à mon avis)
Répondre à la discussion
Affichage des résultats 1 à 22 sur 22

Programmation PIC18F (valable pour les autres à mon avis)



  1. #1
    ArnaudN67

    Programmation PIC18F (valable pour les autres à mon avis)


    ------

    Bonjour à tous.

    C’est mon premier message sur un forum, pardonnez la forme !

    Je souhaite développer une carte à microcontrôleur pour du modélisme ferroviaire. Elle doit piloter une douzaine d’aiguillages et une vingtaine de leds. Et autant de boutons poussoirs. Elle évoluera surement vers un fonctionnement « capteurs » plutôt que boutons, mais pour démarrer, c’est bien comme ça.

    J’ai décidé d’utiliser un PIC1F87J60 car on m’a donné une carte dévaluation EasyPic V7 qui en est équipée.

    J’ai un peu bidouillé dessus et réalisé un programme tout simple qui allume une led en appuyant sur un BP. Je l’ai ensuit modifié pour intégrer une tempo… Et là ça se complique. Je m’explique : J’appuie sur mon BP, la led s’allume pendant 30 secondes puis se coupe. Jusqu’ici tout va bien. Mon problème, c’est que pendant que le µ exécute cette boucle, une action sur tout autre bouton n’est pas prise en compte. Le µ n’est pas à l’écoute, il termine d’abord sa tempo…

    Dans le code ci-dessous, typiquement, une fois que ma boucle aiguillage 2 est lancée, je ne peux pas intervenir sur l’aiguillage 1 tant que la routine " case 3 " n’est pas finie. C’est tout à fait normal vu mon programme, mais je ne sais pas comment faire autrement pour gérer ça (surtout pour une trentaine d’E/S et de cas différents entre les éclairages et les aiguillages) !

    Comment dois-je aborder le µC et le programme pour pouvoir commander plusieurs taches "en même temps" ? Est-ce possible ? Les interruptions, oui, mais pas suffisantes pour tous les boutons…

    Avez-vous des pistes à me donner SVP ? Vos conseils sont les bienvenus !

    Cordialement,

    Arnaud

    Le code :

    Code:
    bit PN1_UP;       // Passage à Niveau aiguillage 1
    bit PN1_DOWN;
    bit PN2_UP;       // Passage à Niveau aiguillage 2
    bit PN2_DOWN;
    
    int Bcmd;         //Sélecteur tache
    
    
    void tempo_PN1_UP() {
         Delay_ms(5000);   // Tempo passage niveau 5 secondes
    }
     void tempo_PN1_DOWN() {
         Delay_ms(5000);   // Tempo 5 secondes
    }
    void tempo_PN2_UP() {
         Delay_ms(4000);   // Tempo 4 secondes
    }
     void tempo_PN2_DOWN() {
         Delay_ms(4000);   // Tempo 4 secondes
    }
     void tempo_TrainTA() {
         Delay_ms(7000);   // Tempo passage train Type A : 7 secondes
    }
    
    void main() {
    
      ADCON0 = 0;                                  // Configure le PORTB en digital
      TRISB = 0xFF;                                // conf PORT en entrée
      TRISE = 0x00;                                // Configure PORTD en sortie
      LATE = 0x00;                                 // initialise PORTD à 0
    
      do {
    
    
      if (Button(&PORTB, 0, 1, 1)) {               // détection niveau logique 1 avec anti-rebond
          Bcmd=1; }
    
      if (Button(&PORTB, 1, 1, 1)) {               // détection niveau logique 1 avec anti-rebond
          Bcmd=2; }
    
      if (Button(&PORTB, 2, 1, 1)) {               // détection niveau logique 1 avec anti-rebond
          Bcmd=3; }
    
      switch(Bcmd){
    
      case 1 : {                                  //Aiguillage n°1 (manuel)
          Bcmd=0;
          LATE0_bit=1;                             //moteur Descente barrière PN1 Run
          tempo_PN1_DOWN();
          LATE0_bit=0;                             //moteur Descente barrière PN1 Stop
          break;}
    
      case 2 : {                                   //Aiguillage n°1 (manuel)
          Bcmd=0;
          LATE1_bit=1;                             //moteur Montée barrière PN1 Run
          tempo_PN1_UP();
          LATE1_bit=0;                             //moteur Montée barrière PN1 Stop
          break;}
    
       case 3 : {                                  //Aiguillage n°2 (automatique)
          Bcmd=0;
          LATE2_bit=1;                             //moteur Descente barrière PN1 Run
          tempo_PN2_DOWN();
          LATE2_bit=0;                             //moteur Descente barrière PN1 Stop
          tempo_TrainTA();                         //Tempo Passage du train
          LATE3_bit=1;                             //moteur Montée barrière PN1 Run
          tempo_PN2_UP();
          LATE3_bit=0;                             //moteur Montée barrière PN1 Stop
          break;}
       case 0 : break;
       }
    } while(1);                             // Boucle sans fin
    }

    -----

  2. #2
    surfbreizh

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Salut et bienvenue,

    La meilleur solution consiste à cadencer une boucle sur du polling d'un flag TIMER. En d'autres termes, tu exécutes ta boucle tout les Xms. Du coup, tu sais que tu passes dans chaque tâches tous les Xms où plus (X * Xms). En gros :

    do{
    while (polling flag timer){}
    gestion bouton
    gestion taches
    gestion led
    } while(1);

  3. #3
    RISC

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Salut,

    Oui, il est temps pour toi de démarrer avec les interruptions.
    Il n'y a aucun PB pour un microcontroleur à gérer des BP, même plusieurs. Il tourne beaucoup plus vite que la vitesse à laquelle tu vas appuyer même si tu veux gérer plusieurs appuis simultanés.
    Il existe des centaines d'exemples de gestion de clavier ou de boutons sur internet basés sur les interruptions.
    Je suppose que ta carte a été conçue de telle manière que les boutons sont positionnées sur les broches qui peuvent donner des interruptions (typiquement le PORTB).

    Comme par mettre en oeuvre les interruptions en faisant clignoter une led (ou plusieurs) au travers d'une interruption TIMER.

    Regarde aussi ton schéma pour savoir s'il faut faire un anti-rebond logiciel ou pas pour tes boutons.
    Je suis sur que Mikroelektronika donne des exemples pour mettre en oeuvre les différentes fonctions de sa carte.

    a+

  4. #4
    surfbreizh

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Je conseillerais quand même d'éviter au maximum les interruptions. Surtout pour l'appli dont tu parles, ce n'est pas indispensable.

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

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Citation Envoyé par surfbreizh Voir le message
    Je conseillerais quand même d'éviter au maximum les interruptions. Surtout pour l'appli dont tu parles, ce n'est pas indispensable.
    C'est la seule manière de bien écrire un programme sans laisser le µC se tourner les pouces !
    Evidemment, c'est un peu plus complexe, ce n'est pas à utiliser dans un premier programme
    Dernière modification par DAUDET78 ; 26/11/2014 à 18h53.
    J'aime pas le Grec

  7. #6
    ArnaudN67

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Bonsoir Messieurs,

    Merci pour vos réponses.

    Le PIC que j'utilise est un 18F87J60. A priori, sauf incompréhension du datasheet, les interruptions ne sont disponibles que sur RB0 à RB3. Comment alors gérer une vingtaine de boutons sur ce principe ? Il y a-t'il une méthode qui m’aurait échappé : Un matriçage ? Pour l'instant, j'utilise une carte de développement EASYPIC pour mes essais. Je suis donc complètement libre (affectation des pins...) pour la conception hard à venir. Mon point noir étant la programmation, j'ai préféré commencer par ça, avant le hard.

    Je vais investiguer cette solution "boucle sur du polling d'un flag TIMER" (essayer de trouver des infos sur le net) et voir coté interruption aussi. Je débute sur microcontrôleurs et je souhaite démarrer sur de bonne bases. Vos remarques ont donc été les bienvenues. Merci encore à vous.

    Bien cordialement,

    Arnaud

  8. #7
    DAUDET78

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Citation Envoyé par ArnaudN67 Voir le message
    Il y a-t'il une méthode qui m’aurait échappé : Un matriçage ?
    Oui, et un timer (1ms ?) vient scruter les différentes lignes/colonnes
    Si la lecture des contacts trouve une valeur différente de la lecture précédente .... c'est qu'il y a un changement des contacts. Et si ça perdure (anti-rebond) .... c'est qu'il y a un VRAI changement des contacts. On positionne un flag dans le main pour faire ce qu'il y a à faire .
    J'aime pas le Grec

  9. #8
    surfbreizh

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Par expérience, les interruptions sur un micro sont une source de problème. Il y a d’innombrable cas où elles viennent te perturber et te complique le fonctionnement plus qu'autre chose. Mais parfois, tu n'as pas le choix. Donc, la règle c'est : si je peux m'en passer, utilise autre chose.

    Pour prendre un exemple tout bête: les interruptions sur le PortB. Si tu viens lire un signal sur une Pin du portB quelconque, il est tous à fait possible que ton micro loupe le changement d'état d'une autre PIN B qui aurait du te déclencher une interruption. Microchip l'écrit noir sur blanc dans sa datasheet.

    Le monde des interruptions nécessitent de prendre un supplément d'information lors de la programmation, ce qui complique bien le travail.

    Un exemple où les personnes se jettent sur les interruptions sans en avoir besoin : le clignotement d'une LED 1seconde ON/OFF

    Voilà une solution sans interruption et sans delay

    /* C'est pas fonctionnel, mais c'est pour monter l'architecture */
    /* il manque l'init du timer et du micro etc... */

    /* Define plein de macro pour des modifications rapides et un programme lisible */
    #define WLED1 latchB1 // Ecriture par latch
    #define LED1 PINB1
    #define TEMPSDECLIGNOTEMENT 20 // 20 * 50ms (boucle) = 1seconde

    /*Des variables*/
    uint8 i = 0;

    /* une boucle principale */
    while(1)
    {
    /* un programme cadencé que tu maîtrises dans le temps */
    while(flagtimer1fini){} // Polling : Timer 1 = 50ms, il tourne en continu. Tu peux t'échapper tout les 50ms. Bien sûr, l’exécution de toutes les tâches du programmes doivent être moins longue que 50ms
    flagtimer1fini = 0; // Ré-initialise le flag
    if( i == 0)
    {
    WLED1 = !LED1;
    i = TEMPSDECLIGNOTEMENT;
    }
    else {i--;}
    }

    C'est brouillon, mais je ne doute pas que tu en trouveras l'essence de bonne pratique. Il y a de belles documentations sur les bonnes pratiques du codage en C.

  10. #9
    DAUDET78

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Citation Envoyé par surfbreizh Voir le message
    Par expérience, les interruptions sur un micro sont une source de problème. .
    Sorry, mais tu ne dois pas avoir une longue expérience !
    J'aime pas le Grec

  11. #10
    surfbreizh

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Ce que j'entends par expérience, n'est pas seulement la mienne, mais aussi celles des personnes avec qui je travailles et qui sont dans ce domaine depuis très longtemps. Après c'est un avis dans lequel je crois. Je prends note de ton désaccord.

    D'ailleurs, pour parler des interruptions. Il ne m'a pas fallu beaucoup de projet pour être convaincu de ce qui a été énoncé avant. Ensuite, chaque application à son approche.

     Cliquez pour afficher
    Dernière modification par surfbreizh ; 26/11/2014 à 21h03.

  12. #11
    DAUDET78

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    La programmation par interruption est plus délicate que la programmation linéaire bestiale par pulling. Mais elle utilise au mieux les capacités du µC.
    D'où ce commentaire:
    Citation Envoyé par daudet
    Evidemment, c'est un peu plus complexe, ce n'est pas à utiliser dans un premier programme
    Sinon, c'est la seule bonne méthode de programmation pour faire du "temps réel" ... Arch! que je n'aime pas ce terme, mais il est consacré.
    Citation Envoyé par surfbreizh
    mais aussi celles des personnes avec qui je travailles et qui sont dans ce domaine depuis très longtemps
    Mais qui, si elles pensent vraiment ça, sont incompétentes . le temps n'est pas un critére . Moi, je me fais de la cuisine depuis des dizaines d'année ...... et je ne sais toujours pas me servir d'un microonde !
    Dernière modification par DAUDET78 ; 26/11/2014 à 21h11.
    J'aime pas le Grec

  13. #12
    DAUDET78

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Citation Envoyé par surfbreizh Voir le message
    Je connais ta susceptibilité quand les idées ne vont pas dans ton sens.
    Je ne suis pas susceptible .... Mais j'ai souvent raison . Et quand j'ai raison, je me bat griffes et ongles contre l'ignorance.
    J'aime pas le Grec

  14. #13
    surfbreizh

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Mais qui, si elles pensent vraiment ça, sont incompétentes.
    Je te trouve bien trop affirmatif. Je doute que tu sois capable de juger de compétences de qui compte surtout en t'appuyant sur le fait qu'il juge que les interruptions sont une source de problème. De plus, tu le dis toi même : La programmation par interruption est plus délicate.

    Mais elle (interruption) utilise au mieux les capacités du µC
    J'interprète cette phrase dans le même sens que : si tu peux faire tourner ton µC à 80MHz alors il faut le mettre à fond. Et de la même façon, si tu as des interruptions disponibles il faut les utiliser. Je pense que ces deux précédentes phrases sont fausses.

    Du coup, j'ai peut être mal interprété ta phrase?

    D'ailleurs, si
    la programmation par interruption est plus délicate que la programmation linéaire
    , mais que la programmation linéaire est suffisante pour l'application voulu, alors pourquoi faire plus compliqué quand on peut faire simple?

    Il nous faudrait surement un topic dédié à la bonne programmation d'un micro .

    Bonne soirée.
    Dernière modification par surfbreizh ; 26/11/2014 à 21h40.

  15. #14
    DAUDET78

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Citation Envoyé par surfbreizh Voir le message
    D'ailleurs, si , mais que la programmation linéaire est suffisante pour l'application voulu, alors pourquoi faire plus compliqué quand on peut faire simple?
    Hélas, c'est la question de départ
    Citation Envoyé par ArnaudN67
    Dans le code ci-dessous, typiquement, une fois que ma boucle aiguillage 2 est lancée, je ne peux pas intervenir sur l’aiguillage 1 tant que la routine " case 3 " n’est pas finie.
    Il a fait un programme simple qui marche. Et c'est très bien pour un début! Mais quand il veut gérer deux boutons, il est incapable de faire du "temps réel" ........ CQFD .

    Et c'est là qu'il faut qu'il passe à un clavier matricé (vu le nombre de boutons )
    Et c'est là qu'il faut qu'il passe par un timer qui va régulièrement, en interruption, scanner le clavier .

    Mais il faut savoir , qu'en interruption, on n'a pas le droit de faire un calcul de FFT de 1024 points !
    On positionne des sorties, on vient lire des entrées , on regarde si ça a bougé par rapport à l'image du clavier précédent, on positionne un flag correspondant à la touche détecté et hop ! on quitte le programme d'interruption.

    Et plus tard, dans le "main", on vient regarder si le flag est positionné, on le reset et on lance le calcul de FFT de 1024 points
    J'aime pas le Grec

  16. #15
    RISC

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Salut,

    Un micro sans interruptions c'est comme le vin sans alcool...
    Tout s'apprend, y compris comment utiliser les interruptions. Cela permet de faire des systèmes qui consomme très très peu d'énergie, ce qui est impossible en scannant les broches en permanence et qui en plus est très inefficace.
    Il faut simplement mettre en oeuvre les interruptions pas à pas. (voir le site Gooligum)

    Si tu veux gérer beaucoup de touches, il faut simplement les matricer et venir sous interruptions régulièrement vérifier s'il y en a une ou plusieurs d'appuyées.
    Il existe des centaines d'exemples sur internet pour faire cela : Keypad scanning PIC18

    a+

  17. #16
    terriblement

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Je rejoins l'avis de RISC et Daudet,

    Les interruptions permettent une programmation propre et évolutive, et grace à elles, tu peux justement gérer à intervalles réguliers plusieurs fonctions !

  18. #17
    MichelM_38

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Bonjour

    Je suis d’accord avec surfbreizh. Les interruptions compliquent le programme entre autre lors du debug.
    On peut très bien faire une boucle principale avec un temps défini, puis scruter par pulling le clavier ou tout autre chose.

    Les interruptions peuvent être utiles en cas de nécessité d'une réponse rapide ( sécurité par exemple)

    Je gère des lasers de cette manière avec comme seules IT des fonctions de sécurité liées au lasers, et la réception RS232.
    Je dois aussi maintenir et modifier un soft ecrit par un ancien collegue, qui avait avait utilisé une it toutes les 25ms. Et le debug est merdi... comme par possible. En effet tu suis une zone en pas à pas et là , une it détourne ton code. Super !!!


    Je ne suis pas susceptible .... Mais j'ai souvent raison . Et quand j'ai raison, je me bat griffes et ongles contre l'ignorance.
    Quand a Daudet, tu n'a pas les chevilles qui enflent par hasard. Ce n'est pas parce que les personnes ne font pas comme tu préconise qu'elles sont ignorantes !!!!!

  19. #18
    surfbreizh

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Là où l'interruption prends son sens :

    Interruption pour gestion d'énergie : sortie de veille.
    Interruption pour de la communication.
    Interruption pour périphérique extérieure type encodeur (changement rapide à des instants inattendues)

    Là où elle peut être facilement remplacer :

    Scanner une dizaine de boutons (pk : notamment du à la faible contrainte de temps).
    Faire clignoter des LEDS.

    Listes non exhaustives.

    Je faire comme Daudet, je m'accroche à mon idée. Surtout car je vous rejoins sur certains points listés, sauf l'envie de tout faire passer en interruption. Lorsque tu auras chargé ton soft d'interruption et ensuite vient le moment où t'en à vraiment besoin d'une. Tu regretteras de passer déjà trop de temps en interruption. Une interruption ne doit pas venir une routine sinon elle perd tout son sens. Pour cela, il y a les périphériques qui lèvent les flags tout seul.

    Je rejoins aussi MichelM_38 sur la maintenance ou modification d'un soft.
    Dernière modification par surfbreizh ; 27/11/2014 à 07h25.

  20. #19
    terriblement

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Citation Envoyé par surfbreizh Voir le message
    Là où elle peut être facilement remplacer :

    Scanner une dizaine de boutons (pk : notamment du à la faible contrainte de temps).
    Faire clignoter des LEDS.
    Et quand ton micro est très occupé à faire des calculs qui prennent disons une seconde par exemple, et que quelqu'un appuie sur le bouton pendant ce temps, tu fais comment ?
    Tu cales des "if appuie bouton" a intervalles réguliers dans ton calcul ? :s

    Idem pour les LED, comment tu peux maintenir un clignotement régulier ? selno ce que le micro va faire, la LED clignotera différemment
    Dernière modification par terriblement ; 27/11/2014 à 08h04.

  21. #20
    MichelM_38

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Code:
    Et quand ton micro est très occupé à faire des calculs qui prennent disons une seconde par exemple, et que quelqu'un appuie sur le bouton pendant ce temps, tu fais comment ?
    Un calcul de 1s peut être découpé plusieurs calculs et se faire par étape. Mais une remarque , c'est un sacré calcul pour durer 1s !!! Et si tu n'a pas besoin de contrôler ton clavier toutes les 20ms !!! Le faire toutes les 100ms est suffisant. En cas de lecture de capteur, c'est différent. Et encore.. Cela dépend du temps de réaction de la fonction découlant de ce capteur.

    Code:
    Idem pour les LED, comment tu peux maintenir un clignotement régulier ? selno ce que le micro va faire, la LED clignotera différemment
    Si ta boucle a une base de temps définie ( 50ms) par exemple, et que ton programme est bien fait, le clignotement restera régulier !! Dans mon cas j'utilise ces 50ms comme base de temps, aussi bien pour les leds, que pour des compteurs de temps de fonctionnement.

  22. #21
    DAUDET78

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Citation Envoyé par MichelM_38 Voir le message
    Quand a Daudet, tu n'a pas les chevilles qui enflent par hasard. Ce n'est pas parce que les personnes ne font pas comme tu préconise qu'elles sont ignorantes !!!!!
    Ben je vois que dans la nuit, il y en a d'autres aussi qui sont de mon avis et c'est rassurant. Pour mes chevilles, t’inquiète pas!
    Citation Envoyé par RISC
    Un micro sans interruptions c'est comme le vin sans alcool...
    je crois que la messe est dite
    J'aime pas le Grec

  23. #22
    ArnaudN67

    Re : Programmation PIC18F (valable pour les autres à mon avis)

    Bonjour et Merci pour votre aide,

    Je pense avoir réussi à faire du Polling, le programme ci-dessous fonctionne comme décris en entête. (Merci à surfbreizh pour le tuyaux )

    Mon programme est très linéaire et peux sans aucun doute (vu mon niveau débutant) être très largement amélioré et optimisé. Ai-je compris le principe du polling ? Des conseils pour améliorer ce programme et le rendre plus "pro" ?

    Je vais maintenant m'attaquer aux interruptions pour le scan de ma matrice de boutons et essayer de modifier ce programme en conséquence. Suis pas sorti de l'auberge !! Mais c'est en forgeant que l'on devient forgeron...

    Encore merci et @+,

    Arnaud


    Code:
    /*
    Avec un oscillateur 25MHz
    Utilisation du TIMER0 en mode "polling" ??
    - LED1 s'allume si 1 action sur BP1 et s'éteint si 1 action sur BP2
    - LED2 allumée tant que action sur BP3
    - LED3 allumée tant que action sur BP4
    - LED4 allumée 5 secondes si 1 action sur BP5
    - LED5 clignote au rythme de 1 seconde toute le temps
    avec cohabitation fonctionnelle de toutes les actions
    */
    
    //Déclaration variables :
    
    unsigned cmpt,cmpt1;     // Compteurs
    int BP5;                         // Etat bouton
    int Bcmd;                      // Sélecteur tache
    
    // Polling timer 0
    
    void interrupt() {
      if (TMR0IF_bit) {
        cmpt++;              // Incrémentation du compteur à chaque interruption (overflow du timer0 : flag TMR0IF)
        cmpt1++;
        TMR0L  = 12;         // TMR0 Preload pour obtenir un overflow toutes les 10ms
        TMR0IF_bit = 0;      // Remise à zéro du flag
      }
    }
    
    // Boucle principale :
    
    void main() {
    
      ADCON0 = 0;            // Configure le PORTB en digital
      ADCON1 |= 0x0F;        // Configure les pins du CAN en mode digital
      CMCON  |= 0x07;        // Désactivation des comparateurs analogiques
    
      TRISB = 0xFF;          // Configuration du PORTB en entrées
    
      TRISC = 0x00;          // Configuration du PORTC en sorties
      LATC = 0x00;           // Initialisation portC à 0
    
      T0CON  = 0xC4;         // TMR0ON, T08BIT et Prescaler sur 1:256
      INTCON = 0xE0;         // GIE, PEIE et TRM0IE à 1
    
      cmpt = 0;              // Initialise le compteur à 0
      BP5=0;
      do {
      
      if (Button(&PORTB, 4, 1, 1)) {               // Détection niveau logique 1 avec anti-rebond sur BP n°1
          Bcmd=1; }
    
      if (Button(&PORTB, 0, 1, 1)) {               // Détection niveau logique 1 avec anti-rebond sur BP n°2
          Bcmd=2; }
    
      if (Button(&PORTB, 1, 1, 1)) {               // Détection niveau logique 1 avec anti-rebond sur BP n°3
          LATC1_bit=1; } else LATC1_bit=0;         // LED active tant que BP Activé
          
      if (Button(&PORTB, 2, 1, 1)) {               // Détection niveau logique 1 avec anti-rebond sur BP n°4
          LATC2_bit=1; } else LATC2_bit=0;         // LED active tant que BP Activé
    
      if (Button(&PORTB, 3, 1, 1)) {               // Détection niveau logique 1 avec anti-rebond sur BP n°5
          BP5=1;cmpt1=0; }
    
      if (BP5==1) {
          LATC5_bit = 1;}                          // Active la LED n°4 si le bouton 5 a été actionné
    
      if (cmpt1 >= 5000) {                         // Eteint la LED N)4 après 5 secondes
          BP5=0;
          LATC5_bit = 0;}
    
      switch(Bcmd){
    
      case 0 : break;
      
      case 1 : {                                   //LED n°1
          Bcmd=0;
          LATC0_bit=1;                             //Active LED
          break;}
    
      case 2 : {                                   //LED n°1
          Bcmd=0;
          LATC0_bit=0;                             //Désactive LED
          break;}
      }
    
    //Clignotement permanent led N°5
    
       if (cmpt >= 1000) {
          LATC4_bit = ~LATC4_bit;  // Inversion état bit 4
          cmpt = 0;                // Reset compteur
        }
      } while(1);                  // Boucle sans fin
    }

Discussions similaires

  1. programmation en basic le transformer en c pour PIC18f
    Par invitea403eabf dans le forum Électronique
    Réponses: 0
    Dernier message: 14/08/2012, 13h41
  2. programmation PIC18F
    Par wajdibh dans le forum Électronique
    Réponses: 1
    Dernier message: 14/06/2011, 22h21
  3. Programmation pic18f
    Par invite8a011b82 dans le forum Électronique
    Réponses: 4
    Dernier message: 05/01/2011, 12h23
  4. Problème programmation PIC18f
    Par invite624dc4b7 dans le forum Électronique
    Réponses: 7
    Dernier message: 12/09/2010, 12h47
  5. programmation des pic18F
    Par inviteb6d84301 dans le forum Électronique
    Réponses: 1
    Dernier message: 04/05/2006, 17h42
Découvrez nos comparatifs produits sur l'informatique et les technologies.