Publié le 7 août 2016 - par

Plongez dans le Go

go_250pxA 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_N&BGo 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

yell_blLe 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.

connexion_LED_shema

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/) :

image03

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

image04

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

image02

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 :

go version go1.6.3 linux/arm

image01Programmation

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)
    }
}

 

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.

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 🙂

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

image06Si 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.

image05

 

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.

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.

go_FB

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

ebook_go

 

Share Button

À propos Mickael GALLARD

Développeur Go, Obj-C, Swift, WinDev, Java, PHP, Flex, Action Script

6 réflexions au sujet de « Plongez dans le Go »

  1. Ping : Plongez dans le Go

  2. FrancoisD

    Hello !
    Ce langage m’a toujours beaucoup tenté, mais j’avais quelques doutes suite aux pb que j’avais lu sur le net sur les montées de versions des sources externes … As-tu quelques éléments à partager sur ce sujet ?

    Sinon, la communauté semble sympa, c’est très vivant, et même Microsoft s’y met (voir https://azure.microsoft.com/fr-fr/documentation/templates/101-webapp-with-golang/) !

    Je verrais si j’arrive à motiver ma boîte à l’utiliser par rapport au C# :p

    Merci pour l’article !

    Répondre
    1. Mickael GALLARD Auteur de l’article

      Bonjour,
      Cela fait deux ans et demi que j’utilise Go (soit depuis la version 1.3) et j’en suis grandement satisfait.
      Comme tu l’indiques, les évolutions d’un projet externe peuvent poser quelques difficultés. Depuis plus d’un an le framework Web Beego est au coeur de mes développements Web. J’ai rencontré quelques problèmes lors du passage de la version 1.5.x à 1.6.0 de Beego, mais rien d’insoluble et en peu de temps. La gêne occasionnée dépendra de toute façon du nombre de sources externes utilisées et de leur stabilité.
      Dans cet article, j’utilise une librairie GPIO que j’ai cloné sur GitHub afin de corriger la fonction SetMode() qui comportait un effet indésirable au démarrage.
      Je dirais qu’avant tout, lorsqu’on décide d’utiliser des sources externes (payantes ou gratuites), il faut s’attendre à mettre les main dans le cambouis.
      Quant aux évolutions de Go en lui même, peu de problèmes rencontrés. En tout cas moins qu’avec les évolutions de PHP par exemple.

      Essayer Go, c’est l’adopter !

      Répondre
  3. Ping : Prenez la température en Go | Framboise 314, le Raspberry Pi à la sauce française….

  4. Ping : La Saga Blink Suite : Elle clignote toujours | Framboise 314, le Raspberry Pi à la sauce française….

  5. barmic

    Il est encore plus pratique de le faire en se faisant de la cross compilation (depuis ton windows ou linux). C’est très simple en go.

    Répondre

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Complétez ce captcha SVP * Time limit is exhausted. Please reload CAPTCHA.