A la lecture de l’article de Patrice sur “La Saga Blink”, l’envie de vous faire connaître un nouveau langage de développement pour notre framboise adorée m’est revenue.
En effet quoi de plus simple que le clignotement d’une LED pour apprendre un nouveau langage : Go.

Le langage Go

Introduction

Go est développé par Google. La première version grand public est disponible depuis 2009. Le langage en est à la version 1.6.3. La version 1.7 devrait être disponible sous peu. Go se veut simple d’apprentissage et sur ce point je ne peux qu’approuver tellement la vitesse de réalisation de mes premiers projets a été rapide pour un usage sous Linux, Windows et MacOS. Vous l’aurez deviné, Go est cross-plateforme sans usage de Cygwin, MinGW ou autres outils externes (hormis pour l’usage de gccgo que je ne décrirai pas dans cet article). Derrière cette simplicité se cache un langage très complet, robuste et performant avec la gestion du multi-threads pour la réalisation d’applications sans interface graphique. Je l’utilise depuis maintenant 2 ans pour des traitements d’import/export de données sur des serveurs Windows et Linux, ainsi que pour la réalisation de serveurs Web grand public.

Sans le savoir vous avez surement déjà entendu parler ou peut être même utilisé l’un des projets les plus en vogue qui est développé en Go : Docker

J’invite les amateurs de lecture à consulter la courte page en français sur Wikipédia ici ou pour plus de détails la version anglaise ici.

Description du projet

Le schéma de câblage et le cahier des charges restent en tous points similaires à ceux de l’article de Patrice. Une résistance et une LED connecté entre le port GPIO 23 et GND. La LED devra s’allumer 1 seconde, puis s’éteindre durant 1 seconde avant de recommencer indéfiniment.

Installation de Go

Le langage Go n’est pas installé de base avec la distribution Raspbian mais la version 1.3.3 est présente dans les paquets disponibles. Toutefois cette version datant, vous allez installer la version 1.6.3 en quelques étapes via la console ou une connexion SSH.
Toutes les manipulations sont proposées avec l’utilisateur “pi”.

Depuis la console, télécharger la dernière version pour ARM (https://golang.org/dl/) :

cd $HOME
wget -q https://storage.googleapis.com/golang/go1.6.3.linux-armv6l.tar.gz
sudo tar -C /usr/local -xzf go1.6.3.linux-armv6l.tar.gz
rm go1.6.3.linux-armv6l.tar.gz

Editez le fichier /etc/profile depuis la console pour ajouter le chemin des binaires Go au PATH :

sudo nano /etc/profile

Ajoutez la ligne suivante à la fin du fichier :

export PATH=$PATH:/usr/local/go/bin

Préparez votre dossier de travail :

cd $HOME
mkdir go

Editez votre fichier profile :

cd $HOME
sudo .profile

Ajoutez la ligne suivante à la fin du fichier :

export GOPATH=$HOME/go

Pour accéder au GPIO, vous aurez besoin d’installer des librairies externes disponibles sur Github. En console, exécutez la commande :

sudo apt install git

Redémarrez votre Raspberry pour prendre en compte les modifications des fichiers profile.

Testez le bon fonctionnement de votre installation depuis la ligne de commandes :

go version

Vous devriez obtenir :

Programmation

Téléchargez une librairie native Go pour l’utilisation du GPIO :

go get github.com/mlgd/gpio

Créez le dossier du projet :

mkdir -p $HOME/go/src/mondomaine.ext/blink

Depuis le début, vous avez créé une arborescence pour votre espace de travail en Go :

+— go
|   +— src
|   |   +— github.com
|   |   |   +— mlgd
|   |   |   |   +— gpio
|   |   +— mondomaine.ext
|   |   |   +— blink

Les différentes sources externes téléchargées depuis Github seront stockées dans le dossier correspondant. Le dossier “mondomaine.ext” étant votre dossier personnel avec vos projets. Afin de respecter la nomenclature, j’ai utilisé “mondomaine.ext” mais vous pouvez tout aussi bien utiliser “projets”.

Le programme se compose d’un seul fichier source à créer depuis la console :

cd $HOME/go/src/mondomaine.ext/blink
nano blink.go

Le contenu du programme est le suivant :

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/mlgd/gpio"
)

func main() {
    // Ouverture du port 23 en mode OUT
    pin, err := gpio.OpenPin(gpio.GPIO23, gpio.ModeOutput)
    if err != nil {
        fmt.Printf("Error opening pin! %s\n", err)
        return
    }

    // Création d’une variable pour l’interception du signal de fin de programme
    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt)
    signal.Notify(c, syscall.SIGTERM)
    signal.Notify(c, syscall.SIGKILL)
    // Go routine (thread parallèle) d’attente de fin du programme
    // pour l’extinction de la LED et la fermeture du port
    go func() {
        <-c
        pin.Clear()
        pin.Close()
        os.Exit(0)
    }()

    // Boucle infinie réalisant la tâche souhaitée
    for {
        // Allumage de la LED
        pin.Set()
        // Attente d’une seconde
        time.Sleep(time.Second)
        // Extinction de la LED
        pin.Clear()
        // Attente d’une seconde
        time.Sleep(time.Second)
    }
}

 [stextbox id= »info » caption= »Info »]Personnellement je n’utilise pas “nano” lors de la création de programmes en Go sur Raspberry, mais LiteIDE sous Windows. Je me connecte en SFTP avec WinSCP ou WebDrive. LiteIDE a l’avantage de proposer l’aide à la saisie et d’utiliser le formateur de code disponible avec Go (pour peu que ce dernier soit installé sur le poste Windows) ce qui permet une meilleur lisibilité du code.[/stextbox]

Exécution du programme

Exécutez la commande de compilation :

[/code lang= »bash »]go build blink.go[]/code

Puis lancez le programme :

sudo ./blink

Observez votre LED 🙂

Arrêtez le programme avec la combinaison de touches “Ctrl + C”. Lors de l’arrêt du programme, la LED est systématiquement éteinte.

Si vous avez parcouru l’article “Pensez ‘Thread’”, vous aurez l’idée de regarder la consommation CPU du programme que vous venez de réaliser en Go. Ce dernier devrait apparaître que très rarement en tête de la commande “top” avec 1,0% d’usage CPU.

 [stextbox id= »info » caption= »A noter »]Il est possible de démarrer un programme Go à l’aide de la commande “go run blink.go”, toutefois vous ne disposerez pas des droits utilisateurs nécessaires pour accéder au port GPIO. En l’état de la configuration, l’usage de “sudo” avec “go run” ne peut pas non plus fonctionner car les variables d’environnement seront inconnues.[/stextbox]

Déploiement

Le programme “blink” généré lors de la compilation est dit “statique”. Vous pouvez le déployer sur un autre Raspberry sous OS Linux ARM sans installer Go ou tous autres programmes externes.

Conclusion

Le Raspberry est certes une superbe machine avec ses interfaces (GPIO, …), mais aussi une machine qui peut fonctionner seule dans son boitier avec des programmes que vous seuls pouvez imaginer. J’espère que cet article vous apportera des clés et pourquoi pas l’envie pour vous plonger dans le langage Go, que ce soit avec votre Raspberry préféré ou sur d’autres plateformes.

Références

Site officiel Go : https://golang.org/
Initiation au Go : https://tour.golang.org/basics/1
Référentiel et documentations de librairies Go : https://godoc.org/
Réalisation d’un serveur Web Wiki : https://golang.org/doc/articles/wiki/
Un ebook sur Go : https://www.golang-book.com/books/intro