Scribd Logo
Importer

Bienvenue sur Scribd !

  • 29 vues

    Raspberry Pi - Programmer en Langage C

    Transféré par

    aminali158

    Droits d'auteur :

    © All Rights Reserved
    Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd

    Raspberry Pi - Programmer en Langage C

    Transféré par

    aminali158
    29 vues1 page

    Titre original

    Raspberry Pi - Programmer en langage C

    Copyright

    © © All Rights Reserved

    Formats disponibles

    PDF, TXT ou lisez en ligne sur Scribd

    Avez-vous trouvé ce document utile ?

    Ce contenu est-il inapproprié ?

    Droits d'auteur :

    © All Rights Reserved
    Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd
    Télécharger au format pdf ou txt
    29 vues1 page

    Raspberry Pi - Programmer en Langage C

    Transféré par

    aminali158

    Droits d'auteur :

    © All Rights Reserved
    Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd
    Télécharger au format pdf ou txt
    sur 1

    Sélectionner une langue ▼

    Livres Commentaires Liens Images Divers

    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

    Mentions légales © 2015

    Vous aimerez peut-être aussi