Raspberry Pi - Raspbian - Programmer en langage C
Le langage C, inventé au début des années 1970 est un langage de programmation très utilisé qui exécute les instructions de façon séquentielle (l'une après l'autre, dans l'ordre où elles apparaissent dans le code source). La page suivante décrit une méthode relativement simple pour faire de la programmation en langage C sur un Raspberry Pi équipé du système d'exploitation Linux Raspbian. Cette méthode peut se décomposer selon les 2 étapes principales suivantes.
1) Ecrire un programme
On ouvre l'environnement de développement intégré (IDE) Geany et on écrit un fichier "projet1.c" contenant le code source suivant par exemple:
#include <gtk/gtk.h>
int main (int argc, char *argv[])
{
//--mon programme C
int x=30; int y= 34; int z=0;
char buf[256];
z=100*(x+y);
sprintf(buf, "Addition de x+y" "\r" "x+y=" "%d" , z);
//--affichage du résultat dans une fenêtre gtk centrée------
GtkWidget *window;
GtkWidget *label;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Ma fenêtre");
gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_main_quit ), NULL);
label = gtk_label_new (buf);
gtk_misc_set_alignment( GTK_MISC(label), 0.0, 0.0 );
gtk_container_add (GTK_CONTAINER (window), label);
gtk_widget_show (label);
gtk_widget_show (window);
gtk_main ();
//-------------------------------------------------------
return 0;
}
Code source projet1.c
Explications
La librairie GTK+ (GIMP Toolkit ou Boîte à outils de Gimp) a été écrite en langace C dans le cadre de la création du logiciel Gimp. Elle contient un ensemble de fonctions permettant la création d'interfaces graphiques. Elle est utilisé dans de nombreux projets, notamment dans les environnements de bureau Linux (Gnome, Xfce, Lxde). Cette librairie (version libgtk2.0-0:armhf 2.24.31-2 GTK+ graphical user interface library) est intégrée dans l'image "2017-09-07-raspbian-stretch.img" de Raspbian qui est téléchargeable sur le site de la Fondation Rasberry Pi. Dans l'univers de la librairie GTK, un widget est un élément de base d'interface graphique (fenêtre, label, bouton, case à cocher, menu, barre d'outils...). Le mot widget (petit objet de fenêtre) est dérivé des mots window (fenêtre) et gadget (petit objet).
• void gtk_init (int *argc, char ***argv);
On appelle cette fonction en premier. Elle initialise tout ce qui est nécessaire pour faire fonctionner la boîte à outils. Les paramètres argc, argv peuvent être passés à NULL si la gestion des paramètres
argc et char *argv[] passés dans Main n'est pas nécessaire.
• GtkWidget *gtk_window_new (GtkWindowType type);
Cette fonction crée une fenêtre (window) de premier niveau (GTK_WINDOW_TOPLEVEL).
• void gtk_window_set_title (GtkWindow *window, const gchar *title);
Cette fonction permet de définir le titre qui apparaîtra la barre de titre de la fenêtre. La macro GTK_WINDOW() permet d'effectuer une opération directe de conversion de type de donnée (cast) de GtkWidget
*window en GtkWindow *window
• void gtk_window_set_default_size (GtkWindow *window, gint width, gint height);
Cette fonction définit la taille par défaut de la fenêtre
• void gtk_window_set_position (GtkWindow *window, GtkWindowPosition position);
Cette fonction définit la position par défaut de la fenêtre
• gint gtk_signal_connect (
GtkObject *object, /* widget */
gchar *name, /* signal */
GtkSignalFunc func, /* signal handler */
gpointer func_data ); /* NULL ou application data */
Cette fonction gère, à l'aide du gestionnaire de signal (signal handler) indiqué en 3ème paramètre, l'évènement (signal) indiqué en 2ème paramètres reçus par le widget indiqué 1er paramètre. Le
gestionnaire de signal est une fonction qui est appelée par un widget à chaque fois qu'un évènement déclencheur se produit dans le widget.
Pour effectuer rapidement les conversions de types de données (cast), GTK utilise les macros suivantes:
GTK_WIDGET(widget)
GTK_OBJECT(object)
GTK_SIGNAL_FUNC(function)
GTK_CONTAINER(container)
GTK_WINDOW(window)
GTK_BOX(box)
• GTK_SIGNAL_FUNC() est une macro de conversion (cast) qui permet d'associer à une fonction le type GtkSignalFunc (fonction de signal)
• void gtk_main_quit (void);
Cette fonction permet de quitter la boucle principale du programme.
• GtkWidget *gtk_label_new (const gchar *str);
Cette fonction crée une nouvelle étiquette (Label) avec le texte indiqué affiché à l'intérieur.
• void gtk_misc_set_alignment (GtkMisc *misc, gfloat xalign, gfloat yalign);
Cette fonction permet de définir les alignements (horizontal et vertical) d'un objet
Dans GTK, les GtkMisc sont des widgets sans fenêtre (comme les labels par exemple) et se trouve dans la hiérarchie suivante : GtkObject -> GtkWidget -> GtkMisc
Les GtkMisc possèdent plusieurs macros et notamment la macro de conversion de type GTK_MISC ()
• void gtk_container_add (GtkContainer *container,GtkWidget *widget);
Cette fonction ajoute un widget à un conteneur.
La macro GTK_CONTAINER() effectue la conversion (cast) du type de donnée GtkWidget *window en *container.
• void gtk_widget_show (GtkWidget *widget);
Cette fonction marque le widget avec un "drapeau" (flag) afin qu'il soit ensuite affiché (un widget qui n'a pas de drapeau n'est pas affiché à l'écran).
• void gtk_main (void);
Cette fonction exécute la boucle principale du programme jusqu'à ce que gtk_main_quit () soit appelé.
On Enregistre le fichier "projet1.c" dans un répertoire (dans le répertoire "/home/pi/mon-programme-c" par exemple)
2) Construire l'exécutable
Dans Geany, on clique "Build/Set Build Commands" <:
Dans la fenêtre qui s'ouvre, on tape la ligne suivante dans la zone "1. Compile" puis on clique OK
gcc projet1.c -o projet1 `pkg-config --cflags --libs gtk+-2.0`
Dans Geany, on clique "Build/Compile"
Le compte rendu de compilation apparaît :
gcc projet1.c -o projet1 `pkg-config --cflags --libs gtk+-2.0` (in directory: /home/pi/mon-programme-c)
Compilation finished successfully.
Remarque : si lors de la compilation on obtient le message d'erreur suivant, c'est que la librairie de développement GTK (fichier libgtk2.0-dev) n'est pas installée.
Dans ce cas, il suffit de l'installer (en utilisant l'utilitaire Add/ Remove Software de Raspbian par exemple) et tout rentre dans l'ordre.
Ensuite, une fois le programme compilé, on clique dans Geany Build/Execute
Le programme s'execute, il affiche dans sa fenêtre le résultat de l'addition de x=30 + y=34 multiplié par 100.
Lorsqu'on ferme la fenêtre du programme (Ma fenêtre), le compte rendu suivant s'affiche en bas de Geany
Pour lancer directement le fichier exécutable, on se rend dans le répertoire /home/pi/mon-programme-c à l'aide de l'explorateur de fichier. On clique droit sur le fichier exécutable projet1 et on clique Open
Dans la boîte de dialogue qui s'ouvre, on clique Execute
Le programme s'exécute alors de façon autonome sur le Bureau de Raspbian.
3) Annexe : Exemple - utilisation de Boutons de commande
Le programme suivant crée une fenêtre dotée de 7 boutons de commandes. Chaque bouton de commande permet d'ouvrir rapidement et automatiquement, avec un simple clic, un fichier .m3u (playlist) avec le logiciel multimedia VLC. Les 7 fichiers m3u ainsi que l'ensemble des fichiers mp3 associés sont rangés dans 7 répertoires (/home/pi/JBOX/CDC1 à /home/pi/JBOX/CDC7) sur la SD Card du système.
Code source du programme : jbox.c
Exemple de fichier m3u (Playlist) CDC7.m3u