Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Commentez, partagez et proposez des Tutos en langage C !
Faire un chenillard à leds
Jérémy
Administrateur du site
Administrateur du site
Messages : 2164
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#1 Message par Jérémy » mar. 11 août 2015 16:18

Bonjour à tous,

Je vous propose de créer un chenillard lumineux!

Nous allons:
- nommer des entrées/sorties et des variables (I/O)
- Utiliser le décalage de bit
- faire une fonction
- Gérer un Bouton poussoir et ses rebonds (BP)
Plaque easyPIC7.jpg


Configuration :

-IDE : MikroC Pro for PIC Version 6.6.2
-Compilateur : Mikro prog suite fo PIC V 2.32
-Plaque Easy PIC V7



1/ L'objectif :
Faire un chenillard pouvant être mis en pause sur l'appui d'un BP.
Cela consiste à créer un mouvement lumineux en allumant et éteignant successivement une série de LED. L'effet se traduit par un déplacement de cette lumière dans un sens choisi, par exemple de gauche à droite.


2/ Hardware :
Sur chaque Broche du PORTB sera branché une DEL avec une Résistance de limitation de courant en série. (Attention votre PIC ne pourra pas allumer toutes les DEL à 20mA, voir les specs de vos DEL et l’alimentation utilisée)
Un Bouton-Poussoir (BP) sera placé sur le PORTC à la broche RC0 avec un Résistance de pull-down(10K).
Nous utiliserons l’oscillateur interne du PIC pour la temporisation.

3/ Le CODE commenté:

Code : Tout sélectionner

//#################################       DECLARATION      #########################################
#define BP PORTC.B0           // On donne un nom à une broche pour faciliter la compréhension du programme . 
                              // ici au lieu d'écrire PORTC.B0 dans le programme il suffira d’écrire BP désignant la broche où est branché le BP.

                              // Les variables "bit" peuvent prendre la valeur de 0 ou 1 seulement.
bit sens;                     // on créer une variable de type "bit"  et qui se nomme "sens". cette variable nous dira dans quel sens doit aller le décalage de la lumiére
bit etat;                     // On créer une variable de type "bit"  et qui se nomme "état". Cette variable nous indiquera si le chenillard , est en mode lecture ou pause.

//#################################     FONCTION    #########################################

void chenillard (){           // Voici votre première fonction qu'il faut déclarer avant la fonction principale absolument (voir conseil)
                              // Cette fonction est le mouvement du chenillard. elle doit être appelée seulement en mode lecture, car c'est elle qui fait avancer le chenillard.
  
  if 
(sens == 0 )             // Si le sens est à 0 on fait décaler les bit ( et donc les leds branchées sur les broches) vers la gauche .
       PORTB = PORTB << 1;
  else
       PORTB 
= PORTB >> 1;    // Sinon ( sens = 1 , car c'est un type bit donc seulement deux valeurs  possible), vers la droite.

  if (PORTB == 128)           // Ici on change le sens quand on arrive en butée. Càd quand la dernière broche est allumée PORTB vaut 128 = 0b10000000 .
      sens = 1 ;              // Il faut donc repartir dans l'autre sens, en inversant le bit adapté.

  if (PORTB == 1)             // Ici on change le sens quand on arrive en butée. Càd quand la première broche est allumée PORTB vaut 1 = 0b00000001 .
      sens = 0 ;              // Il faut donc repartir dans l'autre sens .

  delay_ms (100);             // Entre chaque changement de led , on marque une pause afin de voir le défilement. Ralentir le chenillard en augmentant cette pause par exemple.
}
                              // Fin de notre fonction.


void main() {           // ceci contiendra notre programme, c'est la fonction principale(main) et elle est obligatoire.

//#################################     CONFIGURATION    #########################################
ANSELB = 0;             // Configure les broches du PORTB en digital (contrairement à analogique) état haut=1 , état bas=0 .
ANSELC = 0;             // En numérique la valeur 1, c'est à dire un état haut correspond a Vcc et 0 = état bas = la masse .

PORTB = 0;              // On définit les valeurs du PORT B et C  à 0 afin de s'assurer de leurs états
PORTC = 0;

                        // En écrivant "0b" on déclare que l'on va écrire en binaire. Chaque chiffres correspondra à une broche du PORT en question.
TRISB = 0b00000000;     // Configure tout le PORT B en sortie, ce sont nos sorties de LEDs.
TRISC = 0b00000001;     // Configure la broches 1 du PORTC comme entrée en affectant la valeur 1.  Ce sera notre BP.

 PORTB = 0b00000001;    // On met le PORT B a 1 , car pour décaler des bits il en faut au moins une a décaler.
 sens = 0;              // On initialise la valeur de sens à 0 au démarrage, car il faudra aller sur la gauche.
 etat = 0;              // On initialise la valeur de l’état à 0 , ainsi le chenillard sera en pause au démarrage.
 
 
//#################################     Boucle infinie    #########################################

while(1)    // Ici c'est notre boucle sans fin.
 {
  if (BP == 1)                 // Ici on détecte un appui sur le BP , je rappelle qu'il est branché sur la Broche RC0 du PORT C qui est configurée en entrée.
  {
     delay_ms (40);            // Anti-rebond (voir tuto spécifique anti-rebond)
      if (BP == 1)             // On re-regarde après la pause anti-rebond, pour valider l'appui sur le Bouton Poussoir.
         {
          etat = ~etat;        // la "~" inverse toutes les valeurs ; Comme état est une variable de type "bit" , on inverse de 0 à 1 et de 1 à 0.
                               // Cela fait office télérupteur, un appui inverse l’état en permanence.
          while (BP == 1){} ;  // Ici on attend d'avoir relâché le BP pour valider l'ensemble de l'action. (voir tuto spécifique anti-rebond)
          }
  }

  if (etat == 1)               // On regarde si le chenillard est mode "lecture, etat= 1" ou "pause, etat = 0"
    chenillard();              // Si etat = 1 alors on effectue la chenille.
     

 
}                      // Nous arrivons à la parenthèse de la boucle infini, donc on repart au début et ainsi de suite .
}                       // Fin de notre fonction principale                           


4/ Conseils:
- Variez le temps de pause pour voir le défilement accéléré ou ralentir
- Augmentez le décalage de BIT, pour voir les effets.

5/ Vidéo:
http://www.dailymotion.com/video/x31as3h
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Retourner vers « Langage C »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 1 invité