[Jérémy]

Bonjour à tous,

Je vous propose avec ce petit tutoriel, de vous aidez à comprendre l'utilisation et le but des fonctions.

Les fonctions ne sont pas très compliquées à comprendre, mais sont vraiment très importantes. Il faut qu'a la fin de ce tuto, vous ayez bien compris le rôle d'une fonction.

Une fonction est en fait un sous-programme.

Un programme pour être fonctionnel, doit contenir un programme principal, qui appelle plein de petits sous-programmes. Ainsi cela facilite grandement, les modifications, les débogages et la compréhension générale. Il est préférable d'avoir plein de fonctions avec un petit programme principale ,qu'un gros programme principale sans fonctions,cela le rendra que plus efficace.

Comme tout objet en C, une fonction doit être déclarée AVANT son utilisation.

- Soit vous écrivez votre fonction avant la fonction appelante.
- Soit vous déclarez le prototype de la fonction. Il sert à indiquer au compilateur le nom de la fonction, le type de la valeur de retour et le type des paramètres.

Il existe 4 types de fonctions : sans paramètres, avec paramètres d’entrées, avec paramètres de sorties, et enfin avec paramètres d'entrées et de sorties.
Une fonction peut en appelée une autre, On parlera d'imbrication . suivant le type de PIC utilisé ce nombre d'imbrication maximum varie ; mais si vous lisez ce tuto, je doute que vous arriviez au maximum des imbrications possible ( Souvent 8 imbrications max).

Voici un exemple classique de structure de programme , avec tout les cas possibles .

- Fonction X
{ Corps de votre fonction }

- Fonction Y
{ Corps de votre fonction }

- Déclaration de la fonction Z seulement (la fonction sera écrite en fin de programme)

- Fonction principale (main)
{ Corps de votre fonction, appel des fonctions X, Y et Z à l'intérieur}

- Fonction Z
{ Corps de votre fonction, appel des fonctions X et Y si nécessaire}


1/ Les fonctions sans paramètres :
Très simple il s'agit d’appeler un petit sous-programme. Il ne recevra aucune valeur, et n'en renverra pas non plus . Par contre il peut modifier des variables.

Ici, on créer une fonction qui va multiplier par deux un chiffre, afin de faire un décalage d'un bit sur la droite, et fera une pause . C'est notre fonction principale qui va appeler cette fonction .

Code : Tout sélectionner

//#################################       DECLARATION      #########################################

char chiffre;   // On creer une variable nommée "chiffre" de type char .
                // Je rappelle que par defaut char est de type unsigned, donc pas besoin de l'écrire. (seulement pour char)

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

void compteur () {               // Ici notre fonction

    chiffre = chiffre * 2 ;     // On multiplie chiffre par 2 pour creer un décalage du bit sur la gauche.
           if (chiffre == 0)    // Quand chiffre est à 128 et qu'on le mulitplie par deux : il devient = 0 . 128*2=256 donc sur un char = 0
              chiffre = 1 ;     // on initialise notre chiffre
              
  delay_ms (200);              // pause de 200ms
 }


//#########################     FONCTION PRINCIPALE ET CONFIGURATION    #################################

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

ANSELB = 0;             // Met le PORT B en numérique

PORTB = 0;              // Affecte 0 au PORT B

TRISB = 0b00000000;     // Place le PORTB en sortie pour afficher les leds

chiffre = 1;            // Initialise notre chiffre à "1"

 //#################################     Boucle infinie    #########################################

while(1)                 // Ici c'est notre boucle sans fin.
 {

  compteur ();           // On va effectué notre fonction. Une fois fini on passera à la ligne suivante.

  PORTB = chiffre;       // On affecte notre chiffre au PORTB pour afficher la valeur .

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

2/ Les fonctions avec paramètres d'entrée :

La fonction appelée peut recevoir un ou plusieurs "paramètres". Ces paramètres ne seront que temporaires car ils seront effacés à la fin de l’exécution de la fonction. Vous ne pourrez donc pas vous en servir après votre fonction .
Ceci nous permettra d’effectuer les mêmes taches, mais avec des valeurs ou variables différentes.
Il faudra veiller à ce que les paramètres envoyés soient de même type que ceux déclarés dans la fonction . par exemple vous ne devez pas envoyez un long à la fonction si vous avez déclaré un "char" dans les parenthèses.

La syntaxe ressemble à ceci :
void nom_de_la_fonction ( type paramètre1, type paramètre 2)

Dans notre exemple nous allons tout simplement envoyer notre chiffre et un coefficient multiplicateur pour créer notre décalage de bit .

Code : Tout sélectionner

//#################################       DÉCLARATION      #########################################

char chiffre;   // On creer une variable nommée "chiffre" de type char .
                // Je rappelle que par defaut char est de type unsigned, donc pas besoin de l'écrire. (seulement pour char)
char parametre1 ;
char parametre2 ;
//#################################        FONCTION       #########################################

void compteur (char parametre1, char parametre2) {    // Ici notre fonction qui enregistre les paramètres qu'on lui envoie dans des variables temporaires.
                                                      // On précise le type de variable à creer en corrélation avec celle envoyées.
                                                      
    chiffre = parametre1 * parametre2 ;     // On utilise nos variables envoyées et stockées temporairement pour faire notre compteur.
           if (chiffre == 0)                // Quand chiffre est à 128 et qu'on le multiplie par deux : il devient = 0 . 128*2=256 donc sur un char = 0
              chiffre = 1 ;                 // on initialise notre chiffre
              
  delay_ms (200);                          // pause de 200ms
 }


//#########################     FONCTION PRINCIPALE ET CONFIGURATION    #################################

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

ANSELB = 0;             // Met le PORT B en numérique

PORTB = 0;              // Affecte 0 au PORT B

TRISB = 0b00000000;     // Place le PORTB en sortie pour afficher les leds

chiffre = 1;            // Initialise notre chiffre à "1"

 //#################################     Boucle infinie    #########################################

while(1)                 // Ici c'est notre boucle sans fin.
 {

  compteur (chiffre,2);  // On va effectuer notre fonction, en lui envoyant des paramètres.
                         // Nous lui envoyons une variable et un nombre de type "char".
                         
  PORTB = chiffre;       // On affecte notre chiffre au PORTB pour afficher la valeur .

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

3/ Les fonctions avec paramètres de sortie:

Comme son nom l'indique , une fonction avec paramètre de sortie , va renvoyer une valeur à la fonction qui l'a appelée . Comme précédemment, le type de donnée renvoyée doit être compatible.

une ligne appelée "return" à la fin de la fonction mettra fin à celle-ci et renverra la donnée.

la syntaxe de cette fonction ressemble à ça :

"Type" nom_fonction ()
{
ici votre fonction;
return "donnée a retourner";
}

Code : Tout sélectionner

//#################################       DECLARATION      #########################################

char chiffre;   // On creer une variable nommée "chiffre" de type char .
                // Je rappelle que par defaut char est de type unsigned, donc pas besoin de l'écrire. (seulement pour char)
char exemple ;
char parametre2 ;
//#################################        FONCTION       #########################################

char compteur () {               // Nous ecrivons notre fonction en commençant par indiqué le "type" de données a renvoyer
                                                      
    chiffre = chiffre * 2 ;     // On effectue le corps de notre fonction, en travaillant sur une variable chiffre
           if (chiffre == 0)    // Quand chiffre est à 128 et qu'on le multiplie par deux : il devient = 0 . 128*2=256 donc sur un char = 0
              chiffre = 1 ;     // on initialise notre chiffre
              
  delay_ms (200);              // pause de 200ms
  
  return chiffre;              // Ici notre fonction renvoie une variable . il s'agit de "chiffre" qui est en fait notre compteur
 }                             // Dans la boucle principale, cela reviens à rentre la valeur chiffre directement à la place de la fonction


//#########################     FONCTION PRINCIPALE ET CONFIGURATION    #################################

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

ANSELB = 0;             // Met le PORT B en numérique

PORTB = 0;              // Affecte 0 au PORT B

TRISB = 0b00000000;     // Place le PORTB en sortie pour afficher les leds

chiffre = 1;            // Initialise notre chiffre à "1"

 //#################################     Boucle infinie    #########################################

while(1)                 // Ici c'est notre boucle sans fin.
 {
                         // Ici notre fonction est considérée comme le résultat qu'elle retourne
  PORTB = compteur();    // Le PORT B va donc prendre la valeur de retour, qui est dans notre exemple la variable chiffre
                         // On affecte notre variable "chiffre" au PORTB pour afficher la valeur .

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

4/ Les fonctions avec paramètres d'entrées et de sorties:

Ceci ne devrait pas poser de problèmes , car il s'agit simplement d'un mélange des deux. La fonction accepte des paramètres en entrée, qu'elle place dans des variables temporaires qu'elle nomme paramètre 1 et 2, et pour finir elle renvoie une donnée nommée "chiffre" dans l'exemple.

Code : Tout sélectionner

//#################################       DECLARATION      #########################################

char chiffre;   // On creer une variable nommée "chiffre" de type char .
                // Je rappelle que par defaut char est de type unsigned, donc pas besoin de l'écrire. (seulement pour char)
char exemple ;
char parametre2 ;
//#################################        FONCTION       #########################################

char compteur (char parametre1, char parametre2) {               // Nous ecrivons notre fonction en commençant par indiquer le "type" de données à renvoyer et nous mettons les données entrantes dans les parenthèses.
                                                      
    chiffre = parametre1 * parametre2 ;     // On effectue le corps de notre fonction, en travaillant avec nos variables d'entrées.
           if (chiffre == 0)    // Quand chiffre est à 128 et qu'on le multiplie par deux : il devient = 0 . 128*2=256 donc sur un char = 0
              chiffre = 1 ;     // on initialise notre chiffre
              
  delay_ms (200);              // pause de 200ms
  
  return chiffre;              // Ici notre fonction renvoie une variable . il s'agit de "chiffre" qui est en fait notre compteur
 }                             // Dans la boucle principale, cela reviens à rentrer la valeur "chiffre" directement à la place de la fonction


//#########################     FONCTION PRINCIPALE ET CONFIGURATION    #################################

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

ANSELB = 0;             // Met le PORT B en numérique

PORTB = 0;              // Affecte 0 au PORT B

TRISB = 0b00000000;     // Place le PORTB en sortie pour afficher les leds

chiffre = 1;            // Initialise notre chiffre à "1"

 //#################################     Boucle infinie    #########################################

while(1)                 // Ici c'est notre boucle sans fin.
 {
  compteur(chiffre, 2) ; // On appelle notre fonction, en lui envoyant les paramètres d'entrée.

  PORTB = chiffre;    // Le PORT B va donc prendre la valeur de retour, qui est dans notre exemple la variable chiffre
                         // On affecte notre variable "chiffre" au PORTB pour afficher la valeur .

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