Les paramètres en ligne de commande (Script Shell, programme C et script

python) et les appels système à partir des Scripts

Compléments et application à la configuration/contrôle des GPIO

Travaux dirigés
1. utilisation des paramètres d’un script Shell:
a. Introduction

Un script shell ou programme (binaire exécutable) peuvent recevoir des paramètres en ligne de
commande. Exemples :
script : ScriptBonjour.sh Paramètres ou arguments en
ligne de commande pour un
script shell

programme exécutable : Bonjour

paramètres en ligne de commande
pour programme exécutable

b. Comment accéder aux paramètres fournis en ligne de commande à l’intérieur d’un

script shell ou d’un programme C ?
soit le script parameter_demo1.sh suivant :

#!/bin/bash
#Auteur: Y.ROCHDI
#script de demo d'utilisation des paramètres
#usage: parameters_demo.sh param1 param2 param3

echo 'Nom du script='$0 #$0 contient le nom du script

echo 'premier paramètre=' $1 #$1 contient le premier paramètre
echo 'deuxième paramètre=' $2
echo 'troisième paramètre=' $3
echo 'nb de paramètres=' $# # $# contient le nb de paramètres
echo 'tous les paramètres:' $@ # $@ contient tous les paramètres
echo 'fin du scripts'
NB :ce qui est entre ' ' est affiché tel qu’il est par echo

Execution:

1
NB : le nombre de paramètres est 3 dans l’exemple précédent
Soit le script parameter_demo2.sh suivant :

#!/bin/bash
#Auteur: Y.ROCHDI
#script parameters_demo2.sh
#script de demo d'utilisation des paramètres
#usage: parameters_demo.sh param1 param2 ..etc
i=1
for p in "$@" #pour chaque param dans la listes des paramètres
do
echo "\$$i=" $p
i=$(($i+1)) # (( )) pour évaluer l’expression -- > faire le calcul
done
NB: ce qui est entre " " est affiché intégralement sauf $i est remplacé par le contenu de la variable i. \
caractère escape pour désactiver l’effet du premier caractère spécial $
Pour faire un calcul dans un script shell on utilise les doubles parentèses $(($i+1)) contenue de la variable i
est incrémenté de 1 et affecté à la variable i

Exécution :

script parameter_demo3.sh suivant :

#!/bin/bash
#script de demo d'utlisation des arguments dans les scripts shells (bash)
#Auteur: Y.ROCHDI
echo syntax : $0 arg1 arg2 ... etc #$0 nom du script
##################################################
echo "nb_arguments =" $#
echo "liste des args:" $@
echo "premier arg:" $1
echo "dernier arg:" ${!#}
echo "recuperation sequentielle des args:"
#shift n : permet de supprimer les n premiers argu de la liste et de
#decaler les autres le n+1 ième devient le premier
#decommenter chaque ligne pour essayer chaque methode

#première méthode par décalage (shift) de la liste des args et test sur nb arg
#while [ $# -ne 0 ];do echo -n $1 "- "; shift 1; done; echo #retour à la ligne

2
#deuxième methode par decalage et decompteur
#i=$# ;while [ $i -gt 0 ]; do echo -n $1 "- ";shift; i=$(($i-1));done;echo "\n"

#troisième methode sans decalage avec index

#i=1;while test $i -le $# ; do echo -n ${!i} "- "; i=$(($i+1));done;echo "\n"

c. TD d’application:
a- Ecrire un script qui configure en sortie plusieurs GPIO dont les numéros sont données en paramètres.
Usage :
multi_mode_out.sh 23 24 25 2 # configure GPIOs 23 24 25 et 2 en sortie
b- Ecrire un script qui configure des gpios en sortie ou en entrée selon le premier paramètre
Usage :
multi_mode.sh out 2 34 25 #configure GPIOs 2, 34 et 25 en sorties
multi_mode.sh in 8 9 #configure GPIOs 9, 8 en entrée.

2. utilisation des paramètres en ligne de commande pour un exécutable :

Un programme écrit en C puis compilé, peut accepter des paramètres lors de son exécution : la fonction
main possède dans ce cas deux paramètres : un entier argc représentant le nombre de paramètres plus
un, et un tableau de pointeurs sur char, argv, le premier pointeur pointe sur une chaine qui est le nom du
programme, le deuxième pointe sur une chaine de caractère représentant le premier paramètre,…
programme : parameter_demo.c

#include <stdio.h>
#include <wiringPi.h>
void main(int argc , char *argv[]){
int i;
printf("nom du programme:%s\n",argv[0]);
for(i=1;i<argc;i++){
printf("parametre %d : %s\n", i ,argv[i]);
}
}

Compilation:

$ gcc –o parameters_demo parameters_demo.c

Execution:

Application :
Programme multi_mode_out.c qui permet de configurer plusieurs GPIOs en sortie

#include <stdio.h>
#include <stdlib.h> /* pour atoi( ) */
#include <wiringPi.h>

void main(int argc , char *argv[]){

3
int i, num_pin;
wiringPiSetup();
for(i=1;i<argc;i++){
num_pin=atoi(argv[i]); /*conversion chaine vers int*/
printf("%d \n",num_pin);
pinMode(num_pin,OUTPUT);
}
}

Compilation:

$ gcc –o multi_mode_out multi_mode_out.c -lwiringPi

Execution:

$ multi_mode_out 0 2 3
$ gpio readall #pour vérifier la config des GPIOs 0, 2 et 3

TD d’application
a- Ecrire un programme multi_mode.c qui permet de configure une séquence de GPIOs dont les numéros
sont donnés en paramètres de ligne de commande, en entrées ou sorties, selon le premier paramètre qui
peut être in ou out.

Usage :
multi_mode in|out num1 num2 … (in|out signifie in ou out)

b- Ecrire un programme multi_set.c qui permet de changer l’état d’une séquence de GPIOs dont les
numéros sont donnés en paramètres de ligne de commande, à 1 ou à 0, selon le premier paramètre qui
peut être 1 ou 0.
Usage :
multi_set 0|1 num1 num2 …

3. Exécution des commandes Shell à partir d’un programme C:

Un programme écrit en C peut exécuter des commandes Shell en utilisant la fonction system ().
Application :
On reprend le programme précédent qui permet de configurer plusieurs GPIOs en sortie en utilisant la
commande gpio,
multi_mode_out_sys.c

#include <stdio.h>
#include <stdlib.h>
#inlcude <string.h>
const char commande[15]= "gpio mode " ; //debut de commande
char commande1[25] ;
void main(int argc , char *argv[]){
int i, num_pin;
for(i=1;i<argc;i++){
strcpy(commande1, commande); //copier debut decommande
strcat(commande1,argv[i]) ; // y ajouter le num_pin
strcat(commande1," out") ; //y ajouter out précédé d’un espace
printf("%s\n",commande1); //afficher la commande juste pour vérifier
system(commande1); //exécution de la commande composée
}
}
NB : autre possibilité sprintf(commande1, " gpio mode %s out" , argv[i])

4
Compilation et exécution

TD d’application :
a- Créer un programme UpDownEdge qui permet de provoquer un front sur l’entrée dont le numéro est
donné comme premier argument, le deuxième argument doit être -r (pour front montant) ou -f pour front
descendant. Utiliser la fonction system , la commande gpio et l’exploitation de la configuration des
résistances PullUp_Down
Exemple d’utilisation :
$ ./UpDownEdge 1 -r # provoque un front montant sur l’entrée 1
$ ./UpDownEdge 0 -f # provoque un front descendant sur l’entrée 2

4. Arguments en ligne de commande pour un script python:

Un script python peut accepter des arguments en ligne de commande, comme pour les scripts
shell.
Exemple :

5. Exécution d’un programme à partir d’un script python (fonction system):

On peut lancer un programme exécutable (une commande shell par exemple ou un autre script
python) à partir d’un script python en utilisant la fonction system du module os.
Exemple :

5
 TD d’application :
a- Ecrire un script python multi_mode.py qui permet de configurer plusieurs GPIO données en
arguments de ligne de commande en sorties, en se basant sur la commande gpio.
exemple d’utilisation

$ ./multi_mode.py 26 0 1 #configure les GPIO 26 , 0 et 1 en sortie.

b- Ecrire un script python multi_mode_in_out.py qui permet de configurer plusieurs GPIO données en
arguments de ligne de commande en entrée ou en sortie selon le dernier argument fourni in ou out, en
utilisant la librairie RPi.GPIO.
exemple d’utilisation

$ ./multi_mode.py 26 0 1 in #config les GPIOs 26, 0 et 1 en entrées

$ ./multi_mode.py 25 2 in #config les GPIOs 25, 2 en sorties