Depuis la version de Raspbian Wheezy publiée 5 mai 2015, le fonctionnement du réseau a changé, et en particulier celle du WiFi.
Cela vaut également pour les versions de Raspbian Jessie datées du 24 septembre 2015 et du 21 novembre 2015 et sans doute pour les prochaines versions de Jessie.

WiFi en ligne de commande avec Raspbian Jessie

Article paru sur StackExchange

Cette modification rend tous les tutoriels existants obsolètes, eh oui même ceux que vous trouvez sur framboise314

Notez que les anciens didacticiels peuvent encore être utilisés si vous souhaitez utiliser l’ancienne méthode de configuration manuelle, mais ne vous y amusez pas si vous avez seulement des connaissances de base en Linux.

La méthode de configuration actuelle (basé sur dhcpcd) présente de nombreux avantages (mais aussi quelques inconvénients mineurs) et son utilisation est vivement recommandée pour les nouveaux utilisateurs.

Comment configurer le réseau sur Raspbian Jessie

Out of the box !

Si vous utilisez une connexion Ethernet derrière une Box ou un routeur il ne devrait y avoir aucune configuration à faire et tout devrait fonctionner « out of the box » (au sortir de la boîte !)

Si vous utilisez le WiFi avec l’interface graphique de Raspbian (LXDE), référez vous à l’article que j’ai publié il y a quelque temps sur framboise314.

Si vous utilisez le WiFi à partir de la ligne de commande configurez le fichier /etc/wpa_supplicant/wpa_supplicant.conf mis en place en suivant les indication publiées par la Fondation. C’est la seule façon de configurer le réseau lorsque le SSID n’est pas diffusé.

Cela peut également être utilisé pour mettre en place un système » Headless » (sans clavier ni écran) qui utiliserait un câble console par exemple, mais ce sera beaucoup plus facile si vous pouvez connecter un moniteur et un clavier lors de la configuration. Vous trouverez ci-dessous une autre méthode grâce à la quelle il est possible de se connecter un PC au Raspberry Pi à l’aide d’un câble Ethernet.

Fichiers de configuration réseau

Si vous utilisez une version récente de Raspbian le fichier /etc/network/interfaces devrait ressembler à celui qui est ci-dessous. Si vous l’avez modifié, il faut ABSOLUMENT le remettre comme celui-ci !.

auto lo
iface lo inet loopback

auto eth0
allow-hotplug eth0
iface eth0 inet manual

auto wlan0
allow-hotplug wlan0
iface wlan0 inet manual
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

auto wlan1
allow-hotplug wlan1
iface wlan1 inet manual
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

Si la Fondation avait configuré dhcpcd comme son auteur l’a prévu, le fichier /etc/network/interfaces n’aurait plus été nécessaire. Le hook (crochet) 10 wpa_supplicant (normalement présent dans /usr/lib/dhcpcd/dhcpcd-hooks/) lance automatiquement WPA Supplicant sur les interfaces sans fil et il peut être installé si on souhaite l’utiliser.

Le fichier /etc/wpa_supplicant/wpa_supplicant.conf sera créé/modifié avec les méthodes de configuration recommandées, mais il peut aussi être configuré à la main. Il devrait contenir quelque chose comme ce qui suit :

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="ESSID"
    psk="Your_wifi_password"
}

Si vous avez besoin de vous connecter à un réseau privé (qui ne diffuse pas son SSID) ajoutez la ligne scan_ssid=1 à l’intérieur du bloc network= {} ⋯.
NOTE : il y a de nombreuses autres options qui peuvent être utilisés. Lisez la page  man wpa_supplicant.conf.

Configurer une adresse IP statique

L’utilisation d’une adresse statique est rarement la meilleure chose à faire. Si vous voulez/avez besoin d’une adresse IP fixe, définissez une réservation statique dans votre routeur (si possible) ou utiliser une implémentation libre de Zeroconf comme avahi.

Modifier le fichier /etc/dhcpcd.conf comme suit (extrait de la page man de dhcpcd.conf) :

Si vous définissez ip_address,  dhcpcd ne tentera pas d’obtenir un bail auprès d’un DHCP et utilisera la valeur que vous avez indiquée pour l’adresse avec une durée de bail infinie.

Voici un exemple qui configure une adresse statique, la passerelle et un DNS.

interface eth0

static ip_address=192.168.0.10/24
static routers=192.168.0.1
static domain_name_servers=192.168.0.1

Il y a un bon article à propos de dhcpcd sur https://wiki.archlinux.org/index.php/dhcpcd Le fallback profile (profil de repli) est une alternative à l’adresse IP statique.

Connexion d’un ordinateur au Rapberry Pi

Les versions récentes de Raspbian (qui utilisent dhcpcd) permettent à ssh  de travailler sur une adresse de liaison locale (link-locale) et avahi (qui est une implémentation de zeroconf) permet aux programmes de découvrir les hôtes (ordinateurs) présents sur un réseau local.

Cela signifie que vous pouvez relier le Raspberry Pi à un ordinateur (avec un câble Ethernet) ou à un routeur et vous y connecter sans en connaître l’adresse IP.

Vous pouvez facilement vous connecter depuis Linux et OS X en tapant ssh pi@hostname.local (le nom d’hôte par défaut est raspberrypi). Cela devrait fonctionner avec les interfaces graphiques (GUI) les plus populaires pour ssh. C’est parfois plus problématique avec certaines versions de Windows et avec des réseaux qui utilisent .local d’une manière non-standard. (Voir https://en.wikipedia.org/wiki/.local)

Si vous avez plusieurs Raspberry Pi sur le réseau assurez vous que chaque Raspberry Pi possède un nom d’hôte unique.

Vous pouvez utiliser un câble croisé (c’est la norme entre deux ordinateurs ou entre un ordinateur et un routeur), mais ce n’est pas obligatoire (la plupart des interfaces grand-public modernes détectent automatiquement le type de câble).

Un inconvénient de la connexion directe est que le Raspberry Pi n’aura pas d’accès à Internet et que la date ne sera pas correcte. Vous pouvez copier la date de l’hôte en exécutant

ssh pi@hostname.local sudo date -s$(date -Ins)

avant la connexion.

Configurer une adresse IP statique sur une connexion Ethernet :

Editez le fichier /etc/dhcpcd.conf

sudo nano /etc/dhcpcd.conf

Tapez les lignes suivantes au début du fichier :

interface eth0
static ip_address=192.168.1.XX/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1

Remplacez XX par l’adresse que vous souhaitez attribuer à votre machine. Le Masque de sous-réseau (subnet mask) est ici indiqué sous la forme /24. Cela signifie que les 24 premiers bits du masque sont à 1. C’est à dire que le masque vaut 255.255.255.0
(si ça ne vous dit rien faites un peu de binaire, ça s’éclaircira )

Maintenant redémarrez votre Raspberry Pi :

sudo reboot

Ceci est valable pour les mises à jour récentes de Jessie. Le fichier /etc/network/interfaces devrait être laissé de côté. Ouvrez votre navigateur et saisissez l’adresse de votre box/routeur (192.168.1.1 pour la plupart des box). Vérifiez les données de votre réseau pour vous assurer que le Raspberry Pi est bien reconnu avec une adresse «statique».

Les tests sur Jessie Lite et un Raspberry Pi 2

Bon, maintenant qu’on a vu la théorie, on passe à la pratique?
J’ai préparé une Jessie Lite toute propre que j’ai installée sur une carte micro SD 16 Go Samsung EVO. Je n’ai même pas fait un expand file system pour occuper toute la place disponible sur la carte.
C’est vrai que vu le faible espace occupé par Jessie (1Go) on pourrait penser qu’il est possible de réutiliser des anciennes cartes microSD genre 2Go ou 4Go. Ouaille note ? Binnnn… N’oublions pas que le système utilise la carte SD comme disque dur. Vous en avez vous, des carte micro SD 2Go en classe 10 ? Moi non. Vous risquez en utilisant des cartes antiques de ralentir votre RasPi dernière génération.
Alors je me rabats sur des cartes 16Go EVO que je trouve autour de 9€ voire moins au supermarché du coin.
Des 2Go ? Ils z’en ont plus, mon pôv monsieur… ça s’fait plus… qu’est ce que vous voulez stocker là d’sus avec la résolution actuelle des smartphones, la vidéo HD et tout et tout…
« Bin… moi c’est pour utiliser comme disque dur sur mon ordinateur. »
Et là vous voyez la tête du vendeur méfiant qui se demande dans quelle brocante vous avez bien pu trouver un ordinateur qui utilise comme HDD une SD card de 2Go… Ou alors si vous n’êtes pas en train de vous foutre de sa gu…le
Eh non, mon Raspberry avec une ch’tite carte de 2Go il fonctionne ! Et sans devoir payer la redevance obligatoire (la comment? ah oui la licence) liée au système d’exploitation qui équipe vos machines. En général c’est à ce moment là qu’il appelle la sécurité et qu’on vous prie -fermement- de ne plus importuner le gentil vendeur du rayon informatique

Bon, allez, je diverge ! Revenons à nos moutons…

Installation et démarrage de Jessie Lite

Commencez par télécharger l’image de Jessie Lite (ou pas) sur la page Download du site de la Fondation.

Décompressez l’archive dans un dossier, puis transférez l’image obtenue (ici 2015-11-21-raspbian-jessie-lite.img) sur la carte SD. Je ne vous détaille pas cette opération maintes fois décrite par ailleurs.

Un df -h montre l’utilisation de la carte SD avec Jessie Lite (1,3 Mo), pas d’expansion de Root File System.

pi@raspberrypi:~ $ df -h
Filesystem Size Used Avail Use% Mounted on
/dev/root 1.3G 945M 248M 80% /
devtmpfs 459M 0 459M 0% /dev
tmpfs 463M 0 463M 0% /dev/shm
tmpfs 463M 6.3M 457M 2% /run
tmpfs 5.0M 4.0K 5.0M 1% /run/lock
tmpfs 463M 0 463M 0% /sys/fs/cgroup
/dev/mmcblk0p1 60M 20M 41M 34% /boot

Sur ma maquette j’ai connecté un ensemble clavier/souris sans fil (Logitech Unifying) ainsi qu’une clé USB WiFi équipée d’une antenne (TP LINK TL-WN722N). Il y a aussi une liaison Ethernet filaire qui me permet de prendre la main à distance avec putty et d’inclure les copies de l’écran en mode texte dans cet article. On ajoute un câble HDMI équipé d’un adaptateur DVI qui envoie l’image en local sur un antique écran Dell.

Allez, on met le feu branche la prise micro USB d’alimentation sur le Raspberry Pi.

Démarrage du RasPi, login de l’utilisateur par défaut (pi / raspberry) et on peut commencer. (je ne laisse que les lignes utiles pour ne pas surcharger…)

pi@raspberrypi:~ $ ifconfig

eth0     Link encap:Ethernet HWaddr b8:27:eb:b3:12:08
         inet addr:192.168.1.107 Bcast:192.168.1.255 Mask:255.255.255.0
...
         RX bytes:19962 (19.4 KiB) TX bytes:17504 (17.0 KiB)

lo       Link encap:Local Loopback
         inet addr:127.0.0.1 Mask:255.0.0.0
...
         RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)

wlan0     Link encap:Ethernet HWaddr e8:94:f6:1b:f6:3c
          inet6 addr: fe80::111c:2b8a:5001:608/64 Scope:Link
          UP BROADCAST MULTICAST MTU:1500 Metric:1
...
          RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)

Premier ifconfig : eth0 a récupéré une adresse via le DHCP. Par contre wlan0 même si la clé WiFi est bien détectée (e8:94:f6 est le code constructeur de TP-LINK) n’a pas récupéré d’adresse IP.

L’affichage des périphériques USB confirme la bonne détection de la clé WiFi :

La clé wifi est détectée dès la mise en route

pi@raspberrypi:~ $ lsusb
Bus 001 Device 005: ID 046d:c52b Logitech, Inc. Unifying Receiver
Bus 001 Device 004: ID 0cf3:9271 Atheros Communications, Inc. AR9271 802.11n
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp. SMSC9512/9514 Fast Ethernet Adapter
Bus 001 Device 002: ID 0424:9514 Standard Microsystems Corp.
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

C’est ce qu’indique la ligne

Bus 001 Device 004: ID 0cf3:9271 Atheros Communications, Inc. AR9271 802.11n

Connecter la clé WiFi au point d’accès

Si vous regardez le contenu du fichier /etc/wpa_supplicant/wpa_supplicant.conf, vous verrez qu’il contient :

pi@raspberrypi:/etc/wpa_supplicant $ sudo cat wpa_supplicant.conf
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

Modifiez le en ajoutant ces lignes à la fin du fichier :

network={
ssid="Votre_SSID"
psk="Votre_Mot_De_Passe"
}

Après un reboot (avec le reboot toutes les clés seront correctement configurées ce qui n’est pas forcément le cas avec un redémarrage du service réseau) votre clé devrait se connecter à votre point d’accès. Vérifiez d’abord que wlan0 a récupéré une adresse :

pi@raspberrypi:~ $ ifconfig
eth0    Link encap:Ethernet  HWaddr b8:27:eb:b3:12:08
        addr:192.168.1.107 Bcast:192.168.1.255  Mask:255.255.255.0
...
wlan0   Link encap:Ethernet HWaddr e8:94:f6:1b:f6:3c
        inet addr:192.168.1.108 Bcast:192.168.1.255 Mask:255.255.255.0

La clé WiFi a récupéré l’adresse 192.168.1.108.

Pour les tests j’ai ensuite débranché le câble Ethernet. Après être sorti de putty, je me suis reconnecté sans problème au Raspberry Pi sur l’adresse de la clé WiFi.

Attribuer une adresse statique à la clé WiFi

Reste à donner une adresse statique à notre framboise pour avoir un aperçu des possibilités.

Attention, si vous êtes connecté(e) uniquement en WiFi, l’opération que vous allez faire s’appelle « couper la branche sur laquelle on est assis(e) »…

Si vous attribuez une adresse fixe à wlan0 ne soyez pas surpris de ne pas pouvoir vous reconnecter avec l’adresse précédente (obtenue via DHCP). Rebranchez le câble Ethernet en plus du WiFi si vous avez fait le test précédent, vous aurez au moins cette voie d’accès :).

Dans mon cas, le DHCP distribue des adresses à partir de 100. Les quelques premiers octets sont occupés (j’ai un tableau avec les adresses fixes distribuées ça évite de faire des conn bêtises).

J’ai choisi 42 comme adresse Ethernet filaire et 43 comme adresse WiFi, pour les tests.

Mon Raspberry Pi devra prendre l’adresse 192.168.1.42 sur eth0 une fois qu’il aura redémarré.

Retournons dans notre fichier /etc/dhcpcd.conf

sudo nano /etc/dhcpcd.conf

Tapez les lignes suivantes au début du fichier :

interface eth0
static ip_address=192.168.1.42/24
static routers=192.168.1.254
static domain_name_servers=192.168.1.254

Vérification :

pi@raspberrypi:~ $ ifconfig
eth0 Link encap:Ethernet HWaddr b8:27:eb:b3:12:08
     inet addr:192.168.1.42 Bcast:192.168.1.255 Mask:255.255.255.0

wlan0 Link encap:Ethernet HWaddr e8:94:f6:1b:f6:3c
      inet addr:192.168.1.108 Bcast:192.168.1.255 Mask:255.255.255.0

On modifie maintenant le fichier /etc/dhcpcd.conf pour mettre une adresse statique à wlan0 :

sudo nano /etc/dhcpcd.conf

Tapez les lignes suivantes au début du fichier :

interface wlan0
static ip_address=192.168.1.43/24
static routers=192.168.1.254
static domain_name_servers=192.168.1.254

et cette fois on obtient :

Vous voyez ici une copie d’écran avec 2 putty connectés au RasPi, un en Ethernet filaire et l’autre en WiFi.

La solution proposée par Jacques

Modèle Raspberry Pi 2 Type B
Version Jessie : 2015-11-21-raspbian-jessie.img
Kernel Version : 4.1
Wifi dongle : Belkin components F7D1102 N150/surf Micro Wireless adapter v1000 [Realteck RTL8188CUS]
J’ai testé sur Raspberry pi 2./ Raspbian Jessie
La connexion WiFi avec la nouvelle interface graphique ne fonctionnait pas complétement, Impossible de se connecter….

Solution proposée :
– Mises à jour

sudo apt-get update

– Installer l’ancien gestionnaire graphique WiFi wpagui

sudo apt-get install wpagui

– Editer le fichier d’interfaces et compléter ainsi la partie Wlan0 :

sudo nano /etc/network/interfaces
allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp

– Vèrifier le contenu du fichier wpa_supplicant.conf

sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

– Donner les permissions suivantes :

sudo chmod 600 /etc/wpa_supplicant/wpa_supplicant.conf

sudo adduser pi netdev

– Mettre un raccourci du gestionnaire graphique sur Le bureau

cp /usr/share/applications/wpa_gui.desktop ~/Desktop

– Lancer Le gestionnaire graphique wpagui

• Lancer un scan…
• Selectionner le reseau …double cliquer dessus
• Selectionner “Static WEP (Shared Key Authentication) »
• Key0 : saisir le code et faire Add pour terminer.

Vérifier que l’icône réseau sur laquelle figuraient deux écrans s’est transformée en symbole WiFi

Merci à Jacques pour cette procédure qui est un modèle du genre… Je m’explique : On y trouve le modèle de Raspberry Pi utilisé, la version de Jessie, celle du noyau et le type de clé WiFi. Un bon exemple de procédure bien documentée !

Conclusion

Pas la peine de râler ! « Pfff ça n’arrête pas de changer !« . Si, par la suite, vous voulez que l’informatique devienne votre métier –de toute façon quel que soit votre métier, vous utiliserez certainement l’informatique– faites vous tout de suite à cette idée :

« Ce que je sais aujourd’hui ne sera plus valable dans 1 an » (des fois moins ).

C’est aussi ce qui fait (à mes yeux) l’intérêt de cette « discipline »… On apprend tous les jours, on se remet en question continuellement. On se rend compte que plus on en sait, plus il reste à apprendre ! Allez je ne vais pas philosopher. Je l’ai déjà dit, et je le maintiens le métier du technicien consiste à utiliser au mieux le matériel/logiciel qui lui est fourni, pas à le critiquer ou à trouver tous les prétextes pour le dénigrer. Si vous pensez que les solutions choisies ne sont pas les bonnes, sortez votre fer à souder et faites nous une carte meilleure que tout ce qui existe, ou alors créez un projet open-source pour développer (enfin) le logiciel parfait !

Cet article permettra à ceux qui éprouvent des difficultés avec le réseau de Jessie de pouvoir démarrer. Il est loin d’avoir épuisé toutes les possibilités offertes par les différents fichiers de configuration.

Si cet article vous a aidé ou si vous trouvez que certaines parties ne sont pas claires et demandent à être modifiées…. Pas d’hésitation, un commentaire sera le bienvenu !

Sources

• http://raspberrypi.stackexchange.com/questions/37920/how-do-i-set-up-networking-wifi-static-ip
• https://www.raspberrypi.org/documentation/configuration/wireless/wireless-cli.md
• https://wiki.archlinux.org/index.php/Dhcpcd#10-wpa_supplicant

Tous les auteurs d’articles qui font vivre framboise314 se joignent à moi pour vous présenter nos

Meilleurs Vœux pour l’année 2016 !

11111100000 ?

Ne soyez pas étonné(e)s de lire 11111100000 sur l’image qui illustre cet article

Pour tout geek et tout fan de Raspberry Pi qui se respecte, le binaire est une denrée indispensable si on veut comprendre et progresser.

Le binaire et le Raspberry Pi

Toutes les données dans votre RasPi sont stockées sous forme de 0 et de 1. Les textes, les images, les sons, les programmes, les applis, les bibliothèques, le noyau Linux lui-même…

Certes, me direz vous, mais peu me chaut de savoir comment mon ordinateur stocke les informations…

Bin oui, si c’est pour agiter une souris, télécharger des séries ou écouter de la musique, je suis d’accord.

Mais quand vient le moment de s’attaquer à des choses plus sérieuses comme les masques de sous réseau ou les droits Linux, là… le binaire risque bien de vous servir !

Alors parmi les vœux que je formule pour cette année 2016 figure celui-ci : que le binaire soit votre seconde langue, qu’il soit appris dans les collèges et les lycées. Pas pour faire des maths et des conversions qui ne servent à rien, mais en application réelle pour lire des températures, des vitesses, commander un moteur, une LED….

Et bien entendu pour un apprentissage ludique et peu onéreux, pourquoi pas utiliser des Raspberry Pi ?

Un premier entrainement en binaire ?

Bon… un premier exercice pour ceux qui débutent. Combien vaut le nombre binaire 11111100000 quand on le convertit en décimal ?

Partez de la droite, la première position vaut 1. Ensuite pour obtenir la valeur de chaque case suivante, multipliez par 2 : 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024…

Maintenant remplissez les cases en écrivant le nombre binaire que vous voulez convertir. Pour calculer le résultat additionnez la valeur (on peut dire le « poids ») de toutes les cases contenant un chiffe 1 : 1024+512+256+128+64+32 = 2016 ! CQFD.

La prochaine série de 1 sera celle-ci : 11111110000

Je vous laisse faire le calcul en plaçant les chiffres binaires dans les cases… Eh oui, la prochaine suite de 1, ce sera en… 2032 ! (11111110000).

Question subsidiaire, en quelle année (décimale) aura-t-on uniquement des 1 (en binaire). Pfff fastoche et sans calcul aucun on peut dire que ce sera en … 2047

Alors, on s’y jette ?

Si tous ces calculs vous intéressent et s’il y a de la demande, je suis prêt à vous proposer une série d’article : Le binaire pour les geek (ou pour les RasPiNautes si vous préférez…) pour vous expliquer comment les techniciens utilisent les différentes bases. Si vous êtes sages je peux même aller jusqu’à l’hexadécimal (oui Monsieur on s’en sert aussi – Comment sont codées les couleurs en HTML ? #FE7CD4 et les adresses en IPV6 ?) en passant par l’octal (oui Monsieur on s’en sert aussi – Comment sont codés les droits Linux dans la commande chmod 766 fichier ?)…

Rassurez vous, ces tutoriels seraient limités à ce qu’utilise VRAIMENT un technicien ! Promis juré!

Alors si vous êtes partants pour cette nouvelle année binaire,  dites le dans l’enquête et/ou les commentaires ci-dessous

Meilleurs vœux pour 2016, amis lecteurs/lectrices du blog, ainsi qu’à vos proches !

Passez de bonnes fêtes de fin d’année

Merci à Michael pour ce 2016 en boîtes (80 !) de Raspberry Pi ! – Cliquez pour agrandir

et attention, hein (1 ?) avec modération

 Note: There is a poll embedded within this post, please visit the site to participate in this post's poll.

Vous avez reçu un beau Raspberry Pi tout neuf pour Noël ? Le Père Noël a vraiment été bien inspiré !
Une fois la framboise connectée déception… « Mais où qu’est mon environnement favori, avec ses fenêtres et tout et tout ? »
Pas de panique, et bienvenue dans le monde du libre, bienvenue sur (ou sous c’est comme on préfère) Linux !

Découvrez  Linux sur Raspbian France

Raspbian France, c’est qui ?

Ce sont 3 étudiants en informatiques qui travaillent régulièrement sur le Raspberry Pi. Afin de faire profiter de leur expérience l’ensemble de la communauté, ils ont créé le site Raspbian France (http://raspbian-france.fr) qui propose des tutoriels en français autour du Raspberry Pi.

(Note de framboise314 : Sur Raspbian France ils disent LA Raspberry Pi… sur framboise314, on n’a que des framboises mâles, alors on dit LE Raspberry Pi… Mais je vous rassure, on parle de la même chose et le sondage de l’article http://www.framboise314.fr/raspberry-pi-et-le-sexe-des-anges/ donne 63% de mâles…)

Pourquoi un cours sur Linux ?

Revenons à nos étudiants : suite à leur travail sur le site Raspbian France, ils se sont rendu compte que beaucoup d’utilisateurs du Raspberry Pi semblent bloqués par la découverte de Linux.

Dans le cadre de leurs études ils ont eu l’occasion de donner des cours autour du développement web à d’autres élèves. Pour ces formations, ils ont créé un cours d’introduction à Linux.

Conscients de la difficulté pour des utilisateurs débutants d’arriver sur un système qu’ils ne connaissent pas, ils ont adapté le cours d’introduction à Linux pour le rendre facilement exploitable par des débutants, sans avoir besoin d’un professeur. Leur but est de mettre ce cours en ligne, afin de les aider à prendre en main leur Raspberry Pi.

Comprendre les bases essentielles de Linux

De nombreux tutoriels demandent des connaissances diverses (gestion des droits –voir le tutoriel de framboise314 sur les droits Linux-, ligne de commande, installation de logiciels, sudo, etc.) qui ne peuvent que difficilement faire l’objet de tutoriels à part entière (ceux-ci seraient soit trop courts et facilement compréhensibles, soit trop complexes). Ce cours vise à fournir aux utilisateur un moyen de mieux appréhender et comprendre ces différentes notions.

Saviez vous que 90% des serveurs web tournent sous Linux ?

Nos 3 auteurs se sont tout attachés à la mise en forme du cours, pour le rendre à la fois clair et plaisant à lire.

Ils ont également tenté de faire le pont entre le besoin de rapidité de la formation (le but est que les lecteurs maîtrisent les bases de Linux en quelques heures à peine) et une certaine exhaustivité (une fois le cours terminé, les utilisateurs sont à même de comprendre les grands mécanismes de Linux, mais également son histoire, sa philosophie, etc.).

Où trouver le cours ?

Aujourd’hui, le cours a été publié dans un article paru sur Raspbian France : http://raspbian-france.fr/decouvrir-linux-cours-introduction-debutants/

Une explication simple sur les notions de base…

L’espoir de Raspbian France c’est que ce cours soit utile à leur communauté, bien-sur, mais également à toutes celles qui gravitent autour du Raspberry Pi, de Linux….

Conclusion

Débutant ou un peu plus avancé, parcourez ce cours en ligne. Il ne faut pas très longtemps pour le lire … mais il ouvre beaucoup de pistes pour approfondir vos connaissances. N’hésitez pas à prendre des notes, à consulter les pages man (la commande magique) des commandes utilisées.

Ça parait un peu rébarbatif au début, mais on apprend énormément !

Sur les pages du cours utilisez les flèches (en bas à droite) pour vous déplacer. (RTFM… j’aime !)

Et surtout n’hésitez pas à faire un retour sur ce cours. Vous -t-il plu, vous a-t-il aidé à démarrer en Linux ? Les auteurs ont besoin de ce retour pour savoir si leur objectif est atteint, s’il faut modifier certaines choses…

Sources

• http://raspbian-france.fr/decouvrir-linux-cours-introduction-debutants/
• http://raspbian-france.fr/cours/slides-linux-introduction.html#/

Ian Murdock est décédé à l’age de 42 ans. Il avait créé Debian il y a 22 ans…

Lui c’était le « ian », et sa compagne d’alors, Debra, était le « Deb ».

Il avait également été le Directeur Technique de la Fondation Linux, et salarié chez Sun. Il travaillait chez Docker dont le blog a annoncé son décès.

Merci Ian !

Sources

In Memoriam: Ian Murdock

• http://www.zdnet.fr/actualites/deces-mysterieux-de-ian-murdock-fondateur-du-projet-debian-39830444.htm
• http://www.liberation.fr/futurs/2015/12/31/ian-murdock-pilier-du-logiciel-libre-est-mort_1423760

Sortie du numéro 41 de The MagPi avec 100 pages de projets à base de Raspberry Pi.

De nombreux sujets abordés dans ce pages ainsi que des nouvelles de l’écosystème de notre framboise.

Réalisations pratiques et programmation sont au menu. Il faut juste lire l’anglais…

Je vous propose de découvrir le sommaire de ce numéro ci-dessous.

Comme d’habitude, il vous est possible de télécharger le PDF de la revue sur le site de la fondation ou sur framboise314.

Josh Williams a utilisé une paire de jumelles pour réaliser des photos. Il utilise les jumelles comme téléobjectif pour une caméra Pi.

La totalité de son projet est décrite sur Instructables.
Mis à part le nom du projet qui fait un effet bizarre en français, l’idée est excellente !

Pinoculars

L’idée de Josh est simple. Il a découpé au laser des éléments en contreplaqué qui viennent se fixer sur les jumelles. Sur ce support il vient fixer un Raspberry Pi avec un écran, ce qui permet d’avoir le retour vidéo et d’augmenter les chances de réussite des photos.

Le dossier paru sur Instructables, ainsi que les vidéos décrivent pas à pas cette réalisation.

Quelques exemples

vue normale

vue prise avec les jumelles pointées sur le clocher

Vidéos

Sources

• http://www.instructables.com/id/PiNoculars-Raspberry-Pi-Binoculars/

PiNoculars

Début d’année sur les chapeaux de roue pour la revue Programmez ! N° 192 – Janvier 2016
De l’Arduino, du Raspberry Pi, un drone et un dossier spécial vintage qui réjouira tous ceux qui ont démarré sur Amstrad, Amiga, Atari….
Vous y retrouverez les bases de programmation de ces ancêtres qui nous ont donné beaucoup de peine (chaque bit, chaque octet compte) mais aussi tellement de joie quand le petit carré se déplaçait sur l’écran, uniquement dirigé par quelques touches… Vous vous souvenez ? Je vous propose de parcourir ce numéro pour découvrir les sujets qui pourraient vous intéresser.

Programmez! N° 192

La couverture

Le sommaire

Écran tactile officiel du RasPi

C’est François Tonic, le Rédac’ Chef qui s’y colle et nous présente l’écran officiel du Raspberry Pi, une première approche de sa mise en œuvre sur la framboise, et même une explication sur le codage en direct sur l’écran (PyQt et QtDesigner).

Spécial vintage

Vous les reconnaissez ? Ce numéro de Programmez! vous propose un retour sur ces ancêtres sous l’angle de la programmation.

Programmation sur Apple II

On commence avec celui qui a tenu le haut du pavé à l’époque : l’Apple II (j’en ai toujours un dans mon musée de geek !).

Amstrad CPC

Avec sa –gigantesque– mémoire de 64Ko (non non, il n’y a pas d’erreur ) bientôt augmentée à 128 Ko, le CPC a fait la joie de milliers de programmeurs en herbe. Ses possibilités graphiques permettaient de créer des jeux qui rivalisaient d’ingéniosité. Bon, avec 160 x 200 pixels en 16 couleurs ou 320 x 200 pixels en 4 couleurs, on est loin de la 4K….

Commodore Amiga

C’est son affichage graphique qui fit le succès du Commodore. Avec ses sorties PAL et NTSC, une haute résolution en 640 x 480 et selon le modèle des palettes de 4K ou 16M de couleurs, il fut doté de jeux adaptés à sa définition. Son Basic est encore disponible aujourd’hui sous licence BSD.

L’Amiga dans tous ses états

Cet article retrace l’évolution de l’Amiga à travers les âges.

Depuis l’Amiga 1000 en passant par les modèles 500,  2000 puis 3000 vous revivrez l’épopée de ces fantastiques machines. Même l’Amiga 4000 (utilisé par la Nasa jusqu’en 2010 !) y figure…

Il existe toujours des rassemblements (Alchimie en 2017 à Tain l’hermitage) pour partager sur les OS et le coding Amiga…

Atari ST

Il a 30 ans également cette année. Il est à l’origine d’une confrontation bon enfant sur les qualités respectives des Amiga et Atari. Il fera les beaux jours des musiciens grâce à ses capacités élevées dans le domaine (Jean-Michel Jarre ou le groupe Kassav).

Gameboy

La Gameboy a été l’une des premières consoles émulées sur PC. Cet article explique comment l’émulation fonctionne, aussi bien côté processeur que GPU…

Construire son drone

Le « Mission Maker » de ce numéro 192 propose la première partie de la construction d’un drone.

L’auteur est parti d’un châssis Tarot  et ce premier article donne les éléments nécessaires pour comprendre le vocabulaire et expliquer les choix des moteurs, hélices, ESC (contrôleur de vitesse)…

Pour ma part je suis impatient de découvrir la suite

Interconnecter vos objets avec Node.js

Après la mise en route de l’Arduino Yun vous découvrirez celle de l’Intel Edison et celle du Raspberry Pi 2. Chacune de ces cartes embarque un Node.js et facilitera l’accès à vos objets connectés.

Conclusion

Un numéro de Programmez! qui ravira les vieux geeks nostalgiques de leurs machines d’antan mais aussi les makers de tout poil.

Sources

• http://www.programmez.com/magazine/programmez-192-pdf

Depuis mes premiers tutoriaux sur l’installation de Owncloud sur Raspberry Pi, il y a eu l’apparition de dépôts pour Debian en version 7 et 8. Personnellement je suis toujours sur Debian 7, et que vous soyez sur Debian 8 ne changera pas grand chose. En revanche il faut maintenant mettre les nouveaux dépôts sinon vous resterez sur une version antérieure. Cette manipulation est valable pour un Pi qu’il soit de première version ou supérieure. Mais pour un confort absolu, je vous recommande de tourner sur un Pi2.

Ajouter le dépôt pour Debian 7 :

# wget -nv https://download.owncloud.org/download/repositories/stable/Debian_7.0/Release.key -O Release.key
apt-key add - < Release.key

# sh -c "echo 'deb http://download.owncloud.org/download/repositories/stable/Debian_7.0/ /' >> /etc/apt/sources.list.d/owncloud.list"

# apt-get update

# apt-get dist-upgrade

Ajouter le dépôt pour Debian 8 :

# wget -nv https://download.owncloud.org/download/repositories/stable/Debian_8.0/Release.key -O Release.key
apt-key add - < Release.key

# sh -c "echo 'deb http://download.owncloud.org/download/repositories/stable/Debian_8.0/ /' >> /etc/apt/sources.list.d/owncloud.list"

# apt-get update

# apt-get install owncloud

Les derniers petits réglages :

N’oubliez pas réactiver Owncloud pour faire la mise à jour en modifiant le fichier config.php

# cd /var/www/owncloud/config

# nano config.php

Vous changerez la valeur  ‘maintenance’ => true, en false. Et via votre navigateur vous appliquerez la mise à jour. Mais parfois les tailles de transfert de fichiers sont de nouveau à 513 mo, sans pouvoir modifier la valeur. Alors il faudra bien remettre les autorisations au dossier en question.

Exemple :

# chown -R www-data:www-data /var/www/owncloud/

Normalement tout doit bien se passer, et au passage une application (client) payante existe pour Android. Elle remplacera Google Drive ou One Drive etc.. A vous la liberté dans le Cloud.

C’est Guillaume, le concepteur de DiskioPi qui m’a contacté pour me parler de son projet de tablette.
C’est un projet qui peut intéresser du monde, de par sa conception initiale, et ses possibilités d’usage.
Diskio Pi est un boitier compatible Raspberry Pi 2 et Odroid XU4, avec dedans tout ce qu’il faut pour utiliser sa carte sans se compliquer la vie : écran tactile HD, ampli audio + hauts parleurs, batterie, hub usb… On branche, et on s’amuse !

Cette solution open source est destinée à la centralisation et au pilotage de votre domotique, mais peut aussi être utilisée pour un usage multimédia., ou éducatif.

Le prototype, réalisé avec une carte Orange Pi, peut faire tourner Android 4.4, ou Debian. Bien sûr, tout autre distribution Linux compatible avec la carte mère (Rpi ou Odroid) est installable.

Ici, un écran 17′ est utilisé pour permettre un rapport épaisseur/surface le plus petit possible, ainsi qu’une surface de travail agréable pour un usage « desktop »

Un indicateur de batterie est présent, avec 5 leds et un bouton pour tester.

L ‘avantage d’une telle solution est bien sûr un accès au port GPIO, donc une intégration de vos montages électroniques la plus simple possible, mais aussi trois ports USB externes et un interne pour un éventuel dongle Wifi, et pour le clavier/souris. Un port SATA (ou mSATA)

Le concepteur vise sur une compatibilité « multi-carte » (qui s’étendra par la suite), l’intégration d’un emplacement pour des modules divers (accéléromètre, capteurs de température, etc), un slot frontal pour une caméra officielle Raspberry Pi, et des batteries (6 cellules) en option. Une compatibilité Arduino est aussi envisagée.
Pour réjouir les utilisateurs de domotique, un support mural et une alimentation POE+ est aussi de la partie, afin d’utiliser le port Ethernet pour alimenter le tout.

Bref, de nombreuses options seront disponibles, en gardant à l’esprit que toute distribution officielle de la carte mère sera compatible. A part Android où il faudra compiler les sources pour ajouter le driver tactile, pour Linux il faudra simplement modifier un fichier pour charger ce driver au démarrage.

Une communauté sera rassemblée via un forum, donc même les débutants pourront s’adonner aux joies de monter une tablette en kit.

Le principe :

Un compartiment amovible prévu pour votre carte est la seule pièce qui diffère, le reste est commun.
Le compartiment rassemble toutes les entrées/sorties (HDMI, Audio, USB, Ethernet…) pour communiquer avec la carte fille de la tablette.
Ainsi tout est redistribué en utilisant un hardware au maximum open source.

Pour le moment, ce projet n’est pas encore financé, mais de nombreux indicateurs montrent que la demande est là, surtout auprès de la communauté de la domotique libre.

Le porteur du projet, Guillaume, attend avec impatience vos retours du sondage qui est actuellement disponible à cette adresse : http://goo.gl/forms/nzDF3fRlBN

La taille de l’écran idéal n’est pas encore choisi, ni le prix…

Dès qu’un second prototype sera prêt, un financement participatif (crowdfunding) sera mis en place courant 2016.

Pour plus de détails : www.diskiopi.com

Sources

• www.diskiopi.com

systemd est un démon destiné à remplacer l’ancien système de démarrage init. Il a pour but d’offrir un meilleur cadre pour la gestion des dépendances entre services, de permettre le chargement en parallèle des services au démarrage, et de réduire les appels aux scripts shell.
Il est mis en œuvre dans un certain nombre de distribution standard – Fedora, openSUSE, Arche, RHEL, CentOS, etc.

Cet article a pour base une publication de Carla Schroder sur linux.com

C’est quoi systemd ?

Un démon !

systemd est un démon de gestion système nommé conformément à la convention UNIX qui consiste à ajouter un «d» à la fin du nom du démon. Cela permet de les reconnaître facilement.

Initialement, il a été libéré sous la licence GNU General Public, Le projet a été lancé par Lennart Poettering en 2010 et publié sous licence GNU LGPL. Le nom de ce programme vient de « system daemon » : le daemon du système. Comme init, systemd est le parent de tous les autres processus, directement ou indirectement. Il est le premier processus lancé au démarrage donc il se voit généralement attribuer un « pid = 1″.

Comment démarre le système ?

d’après http://linuxfr.org/news/systemd-l-init-martyrise-l-init-bafoue-mais-l-init-libere – CC by SA

Lorsqu’un ordinateur démarre, il initialise les différents composants de l’ordinateur (processeur, mémoire vive, disque dur, carte graphique, etc.) et effectue quelques vérifications basiques, puis démarre le cœur du système d’exploitation : le noyau (ici, Linux). En effet, c’est la partie qui communique directement avec les périphériques comme le clavier, la souris, la mémoire ou l’écran et permet leur utilisation.

Lorsque le noyau est chargé, l’ordinateur n’est pas encore prêt à l’emploi. Le noyau délègue au système d’initialisation le lancement du reste du système, selon la configuration établie par l’administrateur. Il lance les services d’arrière-plan (montage des périphériques de stockage, configuration du réseau, messagerie…) et l’interface utilisateur, qu’elle soit graphique ou pas. Le système d’initialisation possède aussi une autre fonction : récupérer les processus qui sortent de leur session. En effet, dans tous les Unix-like—et cela inclut GNU/Linux—tous les processus doivent avoir au moins un processus père, sauf le tout premier processus lancé (PID 1). Si un processus renie son père (on dit qu’il est démonisé), le noyau le rattache alors au premier processus.

Hormis le noyau, il est donc le premier processus lancé sur la machine (ce qui explique l’appellation « PID 1 » — « processus n°1 ») et le dernier à s’arrêter, car il contrôle tous les autres. Par conséquent, le système d’initialisation est un composant critique du système car s’il ne fonctionne pas, la machine ne démarre pas. D’où sa robustesse requise.

Jusqu’à récemment ce programme était souvent SysVinit, mais des remplaçants, plus ou moins compatibles, se sont multipliés ces dernières années, comme Upstart qui est l’init par défaut d’Ubuntu. Un init de type SysV fonctionne comme suit : il lit le fichier /etc/inittab qui lui indique quoi faire à un niveau d’exécution (runlevel) particulier, puis il démarre, redémarre ou arrête automatiquement les services selon le niveau choisi par l’utilisateur.

La syntaxe de ce fichier n’étant pas turing complète, les administrateurs ont préféré déléguer l’essentiel du démarrage à des scripts rc nommés dans ce fichier et appelés par init.

Ces scripts sont aujourd’hui décriés à cause du travail dupliqué entre les distributions, de la difficulté réelle ou supposée de les maintenir et de leurs limites. Sont-elles supposées ou avérées ? Là est toute la question ! Quelques exemples :

• tous ne sont pas, par exemple, forcément compatibles avec des composants tels que selinux (ou autre LSM à la mode) ;
• il est difficile de lancer un service uniquement suite à un événement. Par exemple, lors du branchement d’une clé USB ;
• il est difficile de s’assurer qu’un service (par exemple, sshd) sera relancé automatiquement en cas d’arrêt.

Le système d’init nécessite un travail d’intégration important dans la distribution ; il ne peut donc pas, la plupart du temps, être changé facilement par l’utilisateur.

Ca change quoi, systemd ?

Le projet systemd est écrit avec le langage de programmation C. Il s’agit d’une collection de logiciels sous forme de binaires. Le pilotage des services se fait grâce à des fichiers de configuration.

À première vue, cela ressemble à SysV (écrit en C, formé de trois exécutables et configuré par le fichier « inittab »), mais la grande différence est que SysV suit une approche minimaliste qui déplace une grande partie de l’initialisation des services dans des programmes écrits en Shell et utilisant des bibliothèques externes (par exemple, « start-stop-daemon » pour l’init Debian). À contrario, systemd implémente un large éventail d’actions afin de décourager l’utilisation de scripts de lancement. En pratique, un service SysV pour sshd a pour élément central un script de quelques centaines de lignes (script Shell qui peut être utilisé indépendamment de l’init), alors que sous systemd le service sera généralement piloté par un fichier texte d’une dizaine de lignes (dans une syntaxe spécifique à systemd).

On vante souvent la simplicité des anciens systèmes d’init : en effet, quoi de plus simple que des fichiers textes exécutables dont on peut lire l’exécution ligne par ligne ?

En éditant ces fichiers, on a une maîtrise totale du démarrage de l’ordinateur (à partir du moment où l’on est capable de comprendre le code). Mais modifier le système d’init en lui-même peut poser problème lors de mises à jour ou simplement parce que ce code n’a pas été testé.

systemd remplit les mêmes fonctions que les précédents systèmes, mais il met l’accent sur la simplicité d’utilisation et sur une maîtrise du système plus poussée et moins éparpillée, ce qui est parfois vu comme l’opposé de la philosophie Unix.

Ainsi, beaucoup de choses qui nécessitaient auparavant de modifier des scripts Shell existent maintenant sous la forme d’un simple paramètre dans un fichier. Le comportement est codé dans systemd ce qui permet de mutualiser beaucoup de code et de rendre les fichiers souvent beaucoup plus courts.

Pour la plupart des gens, utiliser systemd ou SysVinit ne fait aucune différence, y compris pour la vitesse de démarrage ; pour bidouiller, tout dépend des outils que l’on maîtrise, soit les outils systemd et leur syntaxe de configuration, soit la programmation Shell, les outils de suivi de processus et la configuration SysV.

systemd en pratique

Un peu d’histoire

Qu’on le veuille ou non systemd est là. Et comme je l’ai souvent dit le rôle du technicien n’est pas de critiquer les choix qui ont été faits (même s’il a le droit de râler !) mais d’utiliser au mieux les outils mis à sa disposition. Et si ça ne lui plait vraiment pas, libre à lui de créer une nouvelle distribution ou une nouvelle carte mère qui fera ce qu’il souhaite… C’est d’ailleurs ce qu’on fait les dissidents de Debian qui ont créé Devuan (=Dev One), une Debian sans systemd.

systemd est controversée pour plusieurs raisons : Il remplace quelque chose que beaucoup d’utilisateurs de Linux n’estiment pas devoir être remplacé, et le comportement des développeurs de systemd n’a pas conquis les cœurs et les esprits. c’est plutôt le contraire, comme en témoigne le fameux fil LKML dans lequel où Linus Torvalds interdit l’accès au noyau Linux à Kay Sievers, développeur de systemd.

Pendant des années Linux a fonctionné avec SysVInit et BSD init. Puis sont venus les add-on les gestionnaires de services, comme les commandes service et chkconfig qui étaient censées rendre la gestion des services plus aisée, mais qui n’étaient que des choses supplémentaires à maîtrisersans que cela ne rende la tâche plus facile, juste un peu plus complexe.

Ensuite vinrent Upstart et systemd avec toutes sortes d’extension alambiquées pour maintenir la compatibilité avec SysVInit. Ce qui part d’un bon sentiment… Mais bon courage pour comprendre comment ça fonctionne. Maintenant Upstart a pris sa retraite au profit de systemd, à partir d’Ubuntu 14.10.

Ca fait toujours peur quand les développeurs commencent à tritouiller les sous-systèmes clés dans Linux, parce que nous sommes un peu coincé avec tout ce qu’ils imposent. Si nous n’aimons pas une application particulière, ou un l’environnement de bureau, ou une commande il y a toujours plusieurs alternatives et il est facile à utiliser quelque chose d’autre. Mais les sous-systèmes essentiels ont des accroches profondes dans le noyau, un tas de scripts de gestion, et des dépendances de paquets logiciels, alors les remplacer n’est pas du tout facile.

La morale de cette histoire (larirette…) c’est que les choses changent, les ordinateurs deviennent inévitablement de plus en plus complexes, et finalement tout ça fonctionne… ou pas !  Mais nous devons nous habituer à ne pas pouvoir façonner les événements selon notre propre volonté.

Premiers pas avec systemd

Red Hat est l’inventeur et le premier promoteur de systemd, donc les meilleures distributions pour jouer avec systemd sont Red Hat Enterprise Linux, ou les clones de RHEL comme CentOS et Scientific Linux, et bien sûr le bon vieux Fedora Linux, qui embarque toujours la dernière version.

Les utilisateurs expérimentés de RH peuvent toujours utiliser service et chkconfig en RH 7, mais il est grand temps de les remplacer par les services natifs. systemd les a remplacés, et service et chkconfig ne prennent pas en charge les services natifs de systemd.

Notre bien-aimé /etc/inittab n’est plus.
A la place, nous avons un répertoire /etc/systemd/system/ rempli de liens symboliques vers des fichiers situés dans /usr/lib/systemd/system/.

C’est ce répertoire qui contient les scripts d’initialisation : pour lancer un service au démarrage, il doit être lié à /etc/systemd/system/. La commande systemctl le fait pour vous lorsque vous activez un nouveau service, comme je le fais dans cet exemple pour tightvncserver :

Installer tightvncserver

On commence comme d’habitude par mettre à jour la distribution :

sudo apt-get update
sudo apt-get upgrade

On peut passer à l’installation de tightvncserver :

pi@raspberrypi:~ $ sudo apt-get install tightvncserver

Lancer tightvncserver pour vérifier qu’il est bien installé et fonctionne :

pi@raspberrypi:~ $ vncserver :1

You will require a password to access your desktops.

Password:
Warning: password truncated to the length of 8.
Verify:
Would you like to enter a view-only password (y/n)? n

New 'X' desktop is raspberrypi:1

Creating default startup script /home/pi/.vnc/xstartup
Starting applications specified in /home/pi/.vnc/xstartup
Log file is /home/pi/.vnc/raspberrypi:1.log

Voyons voir si ça marche

On peut maintenant lancer VNCviewer sur le PC pour voir si on se connecte bien au RasPi :

Cliquez sur Connexion

Cliquez sur Continuer

Tapez le mot de passe que vous aviez saisi sur le Raspberry Pi (pour faire original j’avais mis… raspberry )

Bon… Jusque là tout va bien !

Créer le service sous systemd

Créez un fichier /etc/systemd/system/vncserver@.service

pi@raspberrypi:~ $ sudo nano /etc/systemd/system/vncserver@.service

avec le contenu suivant :

[Unit]
Description=Service de bureau à distance (VNC)
After=syslog.target network.target

[Service]
Type=forking
User=pi
PAMName=login
PIDFile=/home/pi/.vnc/%H:%i.pid
ExecStartPre=-/usr/bin/vncserver -kill :%i > /dev/null 2>&1
ExecStart=/usr/bin/vncserver -depth 24 -geometry 1280x800 :%i
ExecStop=/usr/bin/vncserver -kill :%i

[Install]
WantedBy=multi-user.target

Modifiez éventuellement les paramètres dans le fichier. puis lancez l’installation du logiciel :

pi@raspberrypi:~ $ sudo systemctl daemon-reload && sudo systemctl enable vncserver@1.service
Created symlink from /etc/systemd/system/multi-user.target.wants/vncserver@1.service to /etc/systemd/system/vncserver@.service.

systemctl indique en retour qu’il a bien créé le lien symbolique.

Vous pouvez maintenant redémarrer le Raspberry Pi :

pi@raspberrypi:~ $ sudo reboot

On peut vérifier que tightvncserver a bien été lancé :

pi@raspberrypi:~ $ systemctl
UNIT&                   LOAD   ACTIVE SUB       DESCRIPTION
...
vncserver@1.service        loaded  active running  Service de bureau à distance (VNC)

Il reste un petit défaut : dans le fenêtre de VNCviewer, le curseur de souris prend la forme d’une croix noire. Une modification dans le fichier /home/pi/.vnc/xstartup permet de retrouver le curseur classique (une flèche orientée vers la gauche) :

Remplacez

xsetroot -solid grey 

par

xsetroot -solid grey -cursor_name left_ptr

et au prochain redémarrage, lorsque vous reconnecterez VNCviewer, vous retrouver votre curseur habituel.

Tout ça c’est bien joli, mais tu nous explique un peu ?

Si vous voulez… On va faire ça ligne par ligne en prenant comme exemple le fichier vncserver@.service que nous avons créé ci-dessus. Je vous dis ce que j’en ai compris/trouvé sur les pages d’aide… N’hésitez pas à me reprendre ou à compléter :

[Unit]
Le fichier xxx@.service peut comporter cette section [Unit], qui contient l’information générique de l’unité et ne dépend pas du type d’unité.

Description=Service de bureau à distance (VNC)
Cette chaîne libre décrit l’unité. Cette ligne est destinée à fournir des informations décrivant l’unité. La description doit signifier quelque chose pour l’utilisateur final. « Serveur Web Apache 2 » est un bon exemple, « serveur HTTP léger haute performance » est mauvais : trop générique ou encore « Apache2 » trop spécifique et dénuée de sens pour les gens qui ne connaissent pas Apache.

After=syslog.target network.target
After indique que le service actuel VNCserver ne sera démarré qu’après le démarrage effectif des services listés (et séparés par un espace)

[Service]
les fichiers des services doivent inclure une section « [Service] », comportant des informations sur le service et le sur processus qu’il supervise. Ces options sont documentées dans systemd.exec (5) et systemd.kill (5).de service sont les suivantes:

Type=forking
Si Type est défini comme forking, le processus configuré avec ExecStart= (ci-dessous) fera un appel à la fonction fork () lors de son démarrage. Le processus parent se termine quand le démarrage est fini et que tous les canaux de communication sont établis. L’enfant continue de fonctionner en tant que processus démon principal. C’est le comportement des démons UNIX traditionnels. Si ce paramètre est utilisé, il est recommandé d’utiliser l’option PIDFile=  pour que systemd puisse identifier le processus principal du démon. systemd démarrera les unités suivantes dès l’arrêt du processus parent.

User=pi
Permet de désigner l’utilisateur qui lancera le processus

PAMName=login
Définit sous quel nom la session démarre. Si défini, le processus sera enregistré comme session PAM sous le nom de service spécifié. Ceci est utilisé en association avec l’option User= (ci-dessus).

PIDFile=/home/pi/.vnc/%H:%i.pid

Bon, ici la ligne est plus longue… Regardons en détail les différentes parties :
/home/pi/.vnc/  designe le chemin (l’endroit) où le fichier de PID sera enregistré.
%H:%i.pid est le nom du fichier avec %H le nom de la machine et %i le numéro de l’instance de l’unité.

Dans la pratique on trouve

pi@raspberrypi:~/.vnc $ ls
passwd raspberrypi:1.log raspberrypi:1.pid xstartup

et dans le fichier raspberrypi:1.pid

pi@raspberrypi:~/.vnc $ cat raspberrypi:1.pid
562

Avec 562 qui est l’ID du processus.

ExecStartPre=-/usr/bin/vncserver -kill :%i > /dev/null 2>&1
Encore une ligne à rallonge !

ExecStartPre= c’est la commande qui sera exécutée avant ExecStart (on s’en serait douté !)
usr/bin/vncserver -kill:%i cette commande « tue » un bureau VNC qui aurait préalablement lancé par le serveur. Elle le fait en tuant le processus dont l’ID est stockée dans le fichier « /home/pi/.vnc/hôte: instance.pid » (voir ci-dessus)
/dev/null 2>&1 redirige toute sortie de cette commande vers un « trou noir » : Rien n’est affiché

ExecStart=/usr/bin/vncserver -depth 24 -geometry 1280×800 :%i
Si le service est lancé avec start, cette ligne va lancer le serveur VNC avec une profondeur de couleur de 24 bits ( -depth 24), une taille d’écran de (-geometry 1280×800) sur l’instance :i%

ExecStop=/usr/bin/vncserver -kill :%i
Si le service est arrêté avec stop, cette ligne va « tuer » l’instance en cours

[Install]
WantedBy=multi-user.target
La section « [Install] » comporte des informations pour l‘installation de l’unité. Cette section n’est pas interprété par systemd lors de l’exécution. Elle est utilisée exclusivement par les commandes enable et disable de l’utilitaire systemctl lors de l’installation d’une unité.

WantedBy=multi-user.target
Les target de systemd ressemblent aux runlevel que nous avons connus précédemment. Ils portent un nom au lieu d’un numéro. Ici multi-user correspond au runlevel 3, c’est à dire le mode texte (non graphique) multi utilisateurs…  Un lien symbolique est créé dans le répertoire .wants/ de chacune des unités répertoriées lorsque cette unité est installé avec systemctl enable. Le résultat est que l’unité actuelle sera lancé lorsque l’unité indiquée après WantedBy sera lancée.

Vous trouverez ci-dessous tout un tas de liens plus intéressants les uns que  les autres si vous souhaitez aller plus loin dans la compréhension de systemd.

Et si je neveux plus utiliser VNCserver ?

Vous pouvez soit le dévalider

sudo systemctl disable vncserver@1.service

Soit l’enlever complètement

sudo systemctl remove vncserver@1.service

Et c’est tout ?

Non, bien sûr… systemd comprend bien d’autres options. Mais c’est peut être suffisant pour cet article, non?

Allez une dernière info : Comment faire pour démarrer, arrêter manuellement un service ?

# systemctl start [name.service]
# systemctl stop [nom.service]
# systemctl restart [nom.service]
# systemctl reload [nom.service]
$ systemctl status [nom.service]

Conclusion

La migration vers systemd ne va pas se faire sans grognements. Vous trouverez sur la toile autant d’arguments en sa faveur qu’en sa défaveur. A mon avis, il faudra s’habituer, oublier des années de pratique de sysV.
Un regret quand même, c’est que le Raspberry Pi est destiné pour beaucoup à des débutants et le passage (discret) à systemd ne me semble pas avoir été assez accompagné par la Fondation, laissant bon nombre d’utilisateurs perplexes… un peu comme le changement de gestion du réseau confié maintenant à dhcpcd. Combien d’entre nous se sont démenés avec le fichier interfaces avant de s’apercevoir du changement ?

Sources

• https://www.linux.com/learn/tutorials/788613-understanding-and-using-systemd
• http://linuxfr.org/news/systemd-l-init-martyrise-l-init-bafoue-mais-l-init-libere
• Le blog de Nicolas Ledez
• L’article de Carla Schroder sur Linux.com – Sept 2014
• https://www.digitalocean.com/community/tutorials/how-to-use-systemctl-to-manage-systemd-services-and-units
• L’article de Avishek Kumar sur tecmint.com
• https://www.raspberrypi.org/forums/viewtopic.php?t=123457&p=830506
• http://linuxfr.org/news/systemd-pour-les-administrateurs-parties-3-4-et-5
• http://0pointer.de/public/systemd-man/systemd.special.html
• http://www.lanterne-rouge.info/article-que-signifie-dev-null-2-1-70233357.html
• https://wiki.archlinux.org/index.php/systemd
• http://www.freedesktop.org/software/systemd/man/systemd.unit.html
• http://www.freedesktop.org/software/systemd/man/systemd.service.html
• http://www.freedesktop.org/software/systemd/man/systemd.directives.html
• http://www.freedesktop.org/software/systemd/man/systemd.exec.html
• https://www.realvnc.com/products/open/4.1/man/vncserver.html

C’est Jean-François qui m’a mis un message il y a quelques jours : « Il m’arrive quelquefois d’acheter la revue « Pirate informatique » car elle est très intéressante pour tout ce qui concerne les aspects protection des données, anonymat sur les réseaux et préservation de la vie privée.
Aussi, dans le n° 26 de nov. 2015-jan. 2016 de cette revue, on trouve un article décrivant comment utiliser un VPN auto-hébergé

à l’aide d’un Raspberry Pi.
Je pense que ça pourrait être intéressant d’en faire une récension (eh oui ! c’est pas tous les jours que j’utilise un terme pareil – note de framboise314 : moi non plus ) sur ton site pour en informer tes lecteurs réguliers. Comme quoi, on peut vraiment faire beaucoup de choses avec ce nano-ordinateur!« 

J’avoue que je n’achète pas souvent cette revue… Déjà à cause de la couverture que j’apprécie moyennement.

Ils doivent être à peu près les seuls à inclure un CD dans la revue (dites-moi si je me trompe) et comme la revue est sous plastique on ne peut pas la feuilleter…

Bon cette fois, intéressé par l’alerte de Jean-François, j’ai sorti les 4,90€ réclamés par mon buraliste pour qu’il me laisse emporter la revue.

Avec ses 50 pages et son CD, je n’ai pas trop eu l’impression de me faire arnaquer.

Bien entendu je me suis précipité sur l’article sur le VPN. Allez je vais pas faire mon ronchon… C’est plutôt pas mal. Les copies d’écrans sont lisibles (même par un vieux presbyte comme moi… Qui a dit casse… aussi ?).
Comme il faut bien grogner un peu je regrette que l’install soit sous Wheezy et pas sou Jessie mais on fera avec.

Après une description très lisible de l’installation, vous trouverez la procédure de connexion à votre VPN avec Windows et Android (si t’es sous Linux, retourne chez ta mère !).

Mais ce qui m’a plus également c’est que le CD (heureusement qu’ils ont pas mis une disquette 5″1/4) contient également d’anciens articles. Comme ce numéro abrite la partie 2 d’un article sur Kali, j’ai pu retrouver la partie 1 dans la liste des articles parus dans les numéros précédents:

et l’article sur Kali :

Du coup avec ces articles en sus (non, ce n’est pas un gros mot !) j’estime avoir rentabilisé mes 4,90€.

N’imaginez quand même pas que le simple fait d’installer les logiciels de ce CD fera de vous un pirate de haute volée. NAN ! C’est pas parce que vous avez un logiciel qui craque (des fois…) un mot de passe que vous êtes tout à coup devenu un hacker…

Il faudra bosser vos connaissance système si vous voulez tirer la quintessence des logiciels dits « de piratage ». En attendant que vous soyez au top, il faudra patienter …

====== Merci à Jean-François qui m’a communiqué cette information ======

Sources

• http://www.journaux.fr/pirate-informatique_generaliste_informatique_142508.html

Olivier, président de l’association UtoPi, consulte de temps en temps le blog framboise314.fr. Il est président de l’assoc. qui gère le FabLab UtoPi de la communauté Creusot-Montceau.
Quand il a découvert sur le blog que j’habite Le Creusot (tout en bas de la page) il m’a contacté et invité à la première réunion 2016 de l’association.
Le FabLab du Creusot UtoPi se trouve au cœur de l’IUT du Creusot, dans une salle qui est dédiée à ce projet. Imprimante 3D, Arduino, ordinateurs, entraide et bonne humeur sont les mots d’ordre de l’association. (je rajouterai : Raspberry Pi )

FabLab UtoPi

Une association

Le FabLab est une association loi de 1901 crée en 2015 qui s’est maintenant structurée et débute réellement les activités pour lesquelles elle a vu le jour.

Le projet

Le but du projet Utopi est de pouvoir permettre à tous l’accès aux sciences dans tous les domaines : cafés scientifiques, activités et présentations diverses… Il s’agit aussi de donner à tous les moyens de concrétiser ses idées. L’impression 3D est l’un des aspects principaux du FabLab : la conception et l’impression d’un objet peuvent figurer au menu d’un grand nombre de projets.

Qui peut venir au FabLab UtoPi ?

Tout le monde peut adhérer au FabLab, quelque soit l’âge ou les connaissances en science : c’est là un des intérêts du FabLab, comme cela est stipulé dans la charte internationale des FabLab.

Comment ça marche ?

L’association propose une réunion en général le premier samedi du mois (10h-12h environ).

Le FabLab est ouvert le jeudi de 14h à 20h, éventuellement à d’autres moment en fonction de la présence d’un des responsables du FabLab.

Un atelier par mois permet d’enrichir ses connaissances et de les partager. Les prochains ateliers devraient concerner SketchUp pour la préparation d’objets à imprimer en 3D (février), le Raspberry Pi (mars), radioamateurs et SDR (avril)…

L’association organise également un « café scientifique » et participe à des manifestations autour du numérique.

Pour plus de renseignements, vous pouvez consulter le règlement disponible en ligne.

Combien ça coûte ?

L’adhésion à l’association permet d’accéder au statut d’adhérent. L’adhésion est due pour une année universitaire, soit du 1er Septembre de l’année N, au 31 août de l’année N+1.

 Le montant de l’adhésion est fixé à :

• 20 € par an en tarif normal
• 10 € par an en tarif réduit (demandeurs d’emploi, étudiants hors  de l’Université de Bourgogne, mineurs)
• 0 € par an pour les étudiants de l’Université de Bourgogne, les personnes sans emploi et sans droits et hors cursus scolaire.

 L’adhésion inclut 50g de matière d’impression 3D (imprimante à fil PLA). L’adhésion n’inclut pas l’achat de consommables supplémentaires.

 Formations / Ateliers / Initiation

• Les tarifs seront définis au cas par cas pour les adhérents et les invités.

Les activités

Les projets

Plusieurs projets sont en cours de réalisation. Dans le futur le FabLab envisage la création d’un Body Scanner 3D (Scanner corps entier) avec un plateau tournant et une motorisation verticale de la Kinect.

Visite en images du FabLab UtoPi du Creusot

Impression 3D

Imprimante MakerBot Replicator 2

Imprimante Velleman

Tête d’impression 3D de l’imprimante Velleman

Objets réalisée en 3D par impression – Le clé à molette est faite en 3D par tir laser dans de la résine

Robotique

Robot Arduino

Robot Arduino

Charlyrobot

 Robot arachnide hexapode

Hexapode. La main donne une idée de la taille

Toutes les pièces de l’araignée sont réalisées en impression 3D

Chaque patte nécessite 2 heures de montage

Le montage mécanique est achevé. La bestiole n’attend plus que l’installation de la carte Arduino Mega pour aller gambader joyeusement sur terrain accidenté

La capture en 3D

Le FabLab UtoPi est équipé pour la capture d’images en 3D.

Le premier modèle ci-dessus (DAVID 3D Scanner) permet de découvrir le principe du scan 3D. Un objet est placé dans un angle pourvu de repères. Un scanner tenu à la main est utilisé pour balayer les différentes parties de l’objet. Le logiciel reconstitue ensuite l’objet en 3D.

Le FabLab dispose également d’un scanner 3D  Skanect basé sur une Kinect de Microsoft.

Euh… non, Vador n’est pas venu se faire scanner au FabLab… c’est juste une impression 3D :)

Vidéo de présentation de Skanect

Démonstration de capture 3D avec Skanect

Lors de la visite du FabLab, Olivier a réalisé une démonstration de scan 3D d’une personne. C’est Marianne, la secrétaire de l’association qui s’est prêtée au jeu. La vidéo ci-dessous vous permet de découvrir la réalisation du buste de Marie-Anne

Bien entendu les objets ou personnes scannés par ce système peuvent être repris pour être finalisés et imprimés grâce aux imprimantes 3D disponibles…

Il faut noter que vous pouvez télécharger gratuitement (avec certaines fonctions limitées) le logiciel Skanect pour un usage personnel.

Autre matériel

D’autres matériels sont disponibles (alimentation, oscilloscope…) pour mettre au point les projets.

Conclusion

Une visite très intéressante d’un FabLab Bourguignon. Olivier et les adhérents du FabLab sont très accueillants et la réunion a été vraiment conviviale.

Si vous habitez les environs du Creusot (Montceau, Autun, Chalon et communes proches) vous pouvez si vous le souhaitez rejoindre le FabLab pour participer à ses activités…

Pour prendre contact rendez vous sur la page du FabLab Utopi, le formulaire de contact se trouve tout en bas de la page. Le FabLab dispose également d’un forum qui vient de démarrer.

Sources

• http://utopifablab.wix.com/utopifablab
• http://utopi-fablab.xooit.org/index.php
• http://www.journal-officiel.gouv.fr/publications/assoc/pdf/2015/0032/JOAFE_PDF_Unitaire_20150032_01141.pdf

Iziproto est une startup strasbourgeoise qui a développé un driver software permettant d’interfacer de nombreux capteurs et de faire fonctionner les modèles de régulation sur Raspberry Pi sans effort.
À l’occasion du lancement du projet et pour se faire connaitre de la communauté Raspberry Pi, Iziproto organise un concours de projet Raspberry Pi à poster sur le groupe Facebook Iziproto, avec à la clef une imprimante 3D da vinci 1.0.

Concours Iziproto

Pour promouvoir ce nouveau driver qui sera disponible à partir du 20 février 2016, Iziproto organise un concours permettant de gagner une imprimante 3D XYZ Da Vinci d’une valeur de 500 €. Les lots suivants sont une licence Matlab home et une licence Iziproto, d’une valeur totale de 147 € HT. Le troisième prix est une licence Iziproto, d’une valeur de 42 € HT.

Le règlement du concours est disponible en ligne.

Pour participer c’est simple : Vous devez proposer un projet à base de Raspberry Pi  en le postant sur la page Facebook de la startup.

Les gagnants seront ceux dont les projets seront les plus commentés. En cas d’égalité, les lots seront attribués par tirage au sort entre les ex-æquo. Seuls les commentaires de différents utilisateurs de Facebook seront comptabilisés : deux commentaires du même utilisateur sur le même projet ne seront comptés qu’une fois. Les commentaires seront comptés par l’équipe d’InSolem qui contactera les gagnants dans la semaine suivant la fin de la compétition pour organiser la livraison des prix.

Le concours dure jusqu’au 28 février 2016 !

Le site Web Iziproto

Le site web originellement publié en anglais est également disponible en français.

La première version d’Iziproto ne gère que des capteurs Adafruit. Cependant l’objectif est d’enrichir la banque de capteurs rapidement, et de ce point de vue Iziproto est preneur de tout type de propositions : s’il y a pour vous des capteurs qui semblent importants/très utilisés, informez Iziproto et ils étudieront leur intégration dans les prochaines mises à jour (qui seront bien entendu gratuites pour tous ceux qui ont acheté la licence).

La cible de ce driver n’est pas uniquement l’entreprise. Iziproto ne propose pas de licence annuelle mais des licences à vie, simplement les mise à jour ne sont disponibles gratuitement que pendant un an. Avec la licence, vous avez donc accès à vie à notre plateforme de management de Raspberry Pi, ce qui vous permet de gérer votre pool de Raspberry Pi, de flasher en un click votre logiciel, d’installer en un click vos capteurs et d’enregistrer vos données de tests dans le datalogger.

De manière générale le projet Iziproto est en cours de démarrage et il y a donc beaucoup de choses qui devraient être développées.

La solution Iziproto sera disponible à partir du 20 février.

Iziproto permet de libérer du temps en vous permettant de rester concentré sur votre processus de conception et de mettre en œuvre automatiquement votre Raspberry Pi, sans programmation de matériel.

Iziproto propose:

• Un déploiement automatique de votre code C ou Python sur le Raspberry Pi en un seul clic
• Une installation automatique de vos capteurs sur le Raspberry Pi : branchez votre capteur sur le Raspberry Pi, Iziproto le détecte, l’installe et collecte les données. Iziproto couvre un large choix de capteurs I2C Adafruit (Le but de l’équipe derrière IziProto est de développer un outil capable de gérer des dizaines de capteurs différents (accéléromètre, GPS, capteur de luminosité…) et d’autres capteurs seront bientôt ajoutés

• Un suivi de votre pool de Raspberry Pi depuis votre ordinateur : vous pouvez suivre l’état de tous vos Raspberry Pi, les capteurs installés et les modèles en cours d’exécution

• Un enregistrement automatique de vos données : choisissez votre intervalle d’enregistrement et exportez les données enregistrées dans Excel à la fin de votre phase de test.

Iziproto est toujours en développement, et des fonctionnalités supplémentaires seront bientôt disponibles (compatibilité avec Matlab/Simulink, des capteurs et des actionneurs supplémentaires, etc.). Pour toute licence achetée, toutes les versions mises à jour sont disponibles en téléchargement gratuit pendant une année.

Les capteurs gérés par Iziproto

Liste des I2C Adafruit capteurs qui seront disponibles dans Iziproto:

ADXL345 , MCP4725 , MPL115A2 , MCP9808 , MPL3115A2 , TPA2016, TCA9548A I, CAP1188 , BMP280 , TSL2561 , ADS1115 , DS1307 , TCS34725 , BMP180 , ADS1015 , LSM303 , INA219 , L3GD20H , HTU21D-F , TMP006, MAX9744 , SI1145 , HMC5883L , MMA8451 , TSL2561 , TSL2591, MPR121, TMP007, LSM9DS0, STMPE610, HDC1008, VNCL 4010, ESP8266, AT42QT1070, Si5351A, Si4713, DRV2605L, LIS3DH

Conclusion

Une solution de gestion d’un ensemble de capteurs qui semble prometteuse, il faudra voir à l’usage…

Un grand nombre de capteurs Adafruit sont intégrés d’origine et la gestion d’un ensemble de Raspberry Pi à partir d’un ordinateur unique peut-être intéressante pour quelqu’un qui aurait une installation domotique répartie ou pour une installation de type industriel ou scientifique.

Le modèle économique d’Iziproto repose sur la vente de licences. Il faudra donc s’acquitter  d’une quarantaine d’euros pour la licence à vie, mais avec une possibilité de télécharger les mises à jour pendant seulement 1 an.

Sources

• http://www.facebook.com/groups/iziproto/ 
• http://www.iziproto.com/
• http://us.xyzprinting.com/us_en/Product/da-Vinci-1.0

RISC OS est l’OS quasi natif de la plateforme ARM.
Bon, d’accord RISC OS ce n’est pas Linux, mais c’est un système très léger, rapide, efficace et il existe quantité de logiciels, utilitaires… intéressants et disponibles. Ils ont été développés depuis l’époque de l’Archimedes d’Acorn (1987) et tournent sur le Raspberry Pi.
Si vous souhaitez découvrir RISC OS vous ne partirez pas seul ! En effet un site EN FRANÇAIS existe qui pourra vous aider à démarrer avec ce système. Vous trouverez également des informations sur les logiciels disponibles et éventuellement de l’aide apportée par David, le webmaster de riscos.fr !

Le site RISCOS.FR

Le Webmaster

Avant de vous parler du site, j’ai posé quelques questions à David, l’animateur de riscos.fr et il a bien voulu y répondre :

Qui es-tu ?

Je suis David Feugey, à demi entre Paris et Troyes, entre la presse et la programmation et entre RISC OS et BBC Basic. Fonctionnaire des Finances au début de ma carrière, je suis devenu ensuite journaliste où j’ai été un temps rédacteur en chef de Login, puis le principal contributeur de l’Acheteur Micro, et enfin l’un des journalistes de Silicon.fr, où je travaille toujours aujourd’hui.

Comment es-tu venu à utiliser RISC OS ?

C’est par hasard que j’ai découvert RISC OS. J’ai bien entendu été intrigué par la couverture du fameux numéro de SVM présentant les machines Acorn comme les ordinateurs personnels les plus rapides de la planète.

C’est toutefois le processeur ARM qui m’a convaincu de franchir le pas. L’ARM permettait de revenir (‘rester’ serait plus exact) à une programmation assembleur facile, tout en affichant un potentiel très important dans le marché de l’embarqué (dominé alors par les puces 8 bits). Potentiel largement concrétisé depuis, puisque cette architecture processeur s’est imposée comme la plus commune au monde. Le tout ‘made in Europe’.

Tu dis que tu côtoies RISC OS depuis 20 ans est-ce professionnel ou pour ton plaisir uniquement (ou les deux ?)

Acorn RISC PC

Les deux. À mes débuts dans la presse, j’étais responsable de la rubrique « tout sauf Unix » sur Login (BeOS, OS/2, RISC OS, etc.). Ma machine de travail était un Risc PC d’Acorn. RISC OS a donc été très directement mon gagne-pain. J’ai aussi travaillé pendant une courte période en Russie, où je pilotais un laboratoire de R&D 100 % RISC OS. Laboratoire qui avait sorti pas mal de choses sur RISC OS, ARM et – plus tard – pour le monde Linux mobile (ARM toujours).

Par la suite, j’ai longtemps été éloigné du monde RISC OS. C’est le Raspberry Pi qui m’y a fait revenir il y a quelques années à titre de loisir. J’y retrouve le fun et la futilité que ni Windows ni Linux ne m’offrent aujourd’hui. Curieusement, je me suis aperçu que si j’étais noyé dans l’IT, je n’en faisais plus vraiment à titre personnel. Vu le succès auprès du public du Pi, des machines ARM et des offres FPGA, je n’étais visiblement pas le seul.

La communauté RISC OS étant assez réduite, presque tout reste à faire. Par exemple, des centaines de logiciels pourraient être portés du monde Unix (les outils sont là), mais il manque des bras pour participer à cet effort. Le site RISC OS FR (www.riscos.fr) est ma petite pierre apportée à cet édifice. Sans prétention, juste pour le fun. Et si cela sert, tant mieux. J’essaie aussi de créer des synergies avec mon activité développeur, en utilisant par exemple BBC Basic for Windows côté PC et BBC Basic côté RISC OS.

Tu aides gratuitement les personnes qui ont des projets à base de RISC OS… cela te prend beaucoup de temps ?

L’aide aux utilisateurs me prend finalement peu de temps. Il est vrai que peu de personnes s’intéressent aujourd’hui à cet OS ! Et pourtant, il est bien pratique pour du développement ‘semi-bare metal’, car il laisse beaucoup de liberté aux développeurs, tout en proposant des API avancées. En général je le conseille dans deux domaines : 1, le développement Basic pour les débutants voulant s’amuser ; 2, le développement ASM, même si destiné à d’autres OS ARM par la suite.

Parlons de RISC OS : Ce système tourne sur de nombreux modèles de machines, peux-tu en citer quelques-unes?

RISC OS est peu présent sur les machines ARM, mais c’est – dans le même temps – l’OS ARM desktop le plus commun après les offres Linux. On le retrouve sur un large panel de machines, allant de l’Archimedes au Raspberry Pi, en passant par des cartes mères en OMAP4, OMAP5, i.MX6, etc. L’UMPC Pandora, par exemple, peut fonctionner sous RISC OS. Son successeur, la console Pyra, fera sûrement de même.

Quelles sont les principales applications tournant sur RISC OS que tu utilises à titre personnel ?

Tout dépend de l’usage. Plusieurs milliers de titres sont disponibles. En général de petits outils, car l’interface utilisateur de RISC OS favorise le fractionnement des tâches. Côté développement, l’offre est excellente, avec le DDE (branche Acorn du C/C++ d’ARM), des éditeurs de texte épatants (StrongEd, Zap, etc.) et, bien évidemment, une foule d’outils autour de l’assembleur et du Basic. Un triptyque logique, l’OS étant un mélange d’assembleur, de C et de Basic.

Pour les utilisateurs ‘classiques’, nous trouvons des titres comme NetSurf et Otter (navigation web), Messenger et Pluto (e-mail), Ovation et Impression (PAO), Draw et Artworks (dessin vectoriel), Fireworkz et TechWriter (bureautique), etc. Certains vieux jeux peuvent tourner, plus de 25 ans après leur sortie, via des outils comme ADFFS ou Aemulor (qui tiennent plus de la virtualisation que de l’émulation), voire des émulateurs comme ArchiEmu. Beaucoup de vieux logiciels sont devenus gratuits et redonnent ainsi du souffle à cet OS.

Le choix ne manque donc pas. Chose d’autant plus vraie que SDL et Qt sont accessibles sous RISC OS, ainsi qu’un jeu de librairies de base Posix. Ce qui manque c’est un défrichage de l’offre disponible. Des décennies de logiciels plus ou moins compatibles avec RISC OS 5 (la dernière version en date du système) se sont accumulées depuis la sortie du premier BBC Micro par Acorn en 1981.

Sur le Raspberry Pi : Quels avantages trouves-tu à RISC OS par rapport aux autres systèmes disponibles ?

RISC OS présente plusieurs avantages clés dans l’embarqué. Le temps de boot est minimal (quasi in-mesurable en ligne de commande, 12 secondes environ en mode desktop sur un Raspberry Pi A). Très simple, son interface utilisateur laisse le maximum d’espace au contenu et se veut particulièrement réactive. Mais c’est du côté de la programmation que cet OS fait la différence. C’est plus une toolbox qu’un carcan, laissant ainsi l’utilisateur libre d’employer les fonctions proposées par l’OS… ou non. Il est possible de quasiment tout débrancher, si besoin est.

Concrètement, sur un Raspberry Pi, la légèreté de RISC OS permet de faire tourner toute application native sans ralentissements même à 700 MHz et avec 256 Mo de RAM (200 MHz et 64 Mo de RAM seraient plus que suffisants, autant dire que la marge est grande). Points négatifs, le multitâche coopératif, qu’il faut savoir maîtriser, et l’absence de SMP, qui limite l’OS à un cœur de processeur. Toutefois, le côté boite à outils de RISC OS ne s’oppose pas au code multitâche préemptif ou multicœur. Les expérimentations dans ce sens se sont multipliées au fil des ans.

La gestion des GPIO est-elle assurée sous RISC OS ?

Tout à fait. Un module est proposé pour y accéder. Même depuis le Basic. À noter, SPI et DSI sont aussi accessibles, mais pas le CSI du module caméra. Les convertisseurs RS232 ou Midi en USB passent bien aussi (avec un excellent support des interfaces Midi bas de gamme). Tout programme peut basculer en mode monotâche pur, ce qui permet un contrôle total de la machine et une prédictibilité des temps de traitement (hors interruptions) appréciable. RISC OS est dépassé côté accès web, et donc sur le desktop en général, mais ne manque pas d’intérêt pour de l’électronique embarquée. Sa seule vraie limite est l’absence de support WiFi, qui s’est perdu (oui ; perdu) au fil des versions de l’OS.

Le téléchargement de RISC OS est gratuit. Tu conseilles cependant l’achat de Nut Pi (35£) qu’amène ce complément à RISC OS ?

Des titres phares sont proposés dans Nut Pi. À commencer par DDE, le kit de développement de RISC OS. C’est un compilateur C/C++ proche de celui proposé par ARM (pour un prix très inférieur). Il est nécessaire pour recompiler l’OS. Autre perle, SparkFS, qui permet de naviguer dans des archives comme dans un dossier classique. PhotoDesk est un outil de traitement d’images convaincant, lui aussi présent dans Nut Pi. Autres éléments intéressants, les bases de données DataPower et Impact, l’agenda Organizer, le client de messagerie électronique Messenger Pi, ou encore l’outil d’analyse de données Luafox (s’appuyant sur Lua).

Ou alors que ne peut-on pas faire avec RISC OS sur le RasPi si on n’achète pas ce complément ?

Rien, car il existe des alternatives multiples à la plupart de ces logiciels. GCC peut ainsi remplacer avantageusement DDE, le pilote ODBC et SQLTool les bases de données, etc. Seul SparkFS pourrait manquer aux habitués. Quoi qu’il en soit, les logiciels du Nut Pi restent des ‘must have’ pour réellement apprécier RISC OS… mais aussi pour soutenir la communauté. Et il y a bien sûr DDE, vendu plus cher isolément, et qui propose l’un des meilleurs assembleurs ARM du marché, mais aussi un outil pour compiler le code BBC Basic en assembleur.

As-tu quelques exemples d’applications/réalisations construites à base de Raspberry Pi et RISC OS

Il y a eu pas mal de choses dans le secteur de la robotique. Les électroniciens apprécient le Basic, qui permet de piloter des automates sans trop se casser la tête, mais pas sans puissance non plus. La version ARM du BBC Basic se veut l’un des interpréteurs (hors JIT) les plus véloces jamais conçus. Ce langage propose également un assembleur ARM intégré. Ironiquement, c’est le BBC Micro, très extensible, qui a poussé nombre de personnes vers le monde de l’électronique et c’est le monde de l’électronique qui retient aujourd’hui certains utilisateurs sur RISC OS.

Schleppi

C’est cependant dans le secteur desktop que RISC OS s’illustre le plus aujourd’hui, avec des ‘mods’ très bien réalisés, comme ceux de l’Allemand Raik Fisher, qui a créé plusieurs cartouches dédiées au Lapdock de Motorola (http://www.riscos.fr/schleppi.jpg). Un vrai Raspberry Pi portable, avec une bonne autonomie.

Dans un autre registre, il ne faut pas oublier qu’Acorn était le Thomson de l’informatique anglaise. La situation de cet OS est un peu particulière du fait de son histoire (premier OS pour machines ARM) et d’une logithèque qui remontre potentiellement très loin dans le temps (jusqu’au BBC Micro). L’arrivée du Raspberry Pi est clairement un hommage à cette époque, jusqu’au choix des noms (calqués sur ceux des BBC Micro), des cibles (éducation, programmation, automatisation), ou même du processeur (comme par hasard un des rares que soit compatible avec la logithèque de l’Iyonix pc, dernière machine RISC OS avant le Pi). Il se murmure que le support de RISC OS était un des prérequis lors de la création du Raspberry Pi. Ce n’est d’ailleurs pas RISC OS Open Limited qui pilote le développement du portage dédié au Pi, mais la Fondation Raspberry Pi elle-même.

Merci David pour toutes ces informations très intéressantes sur RISC OS !

Le contenu du site riscos.fr

Le site est organisé en rubriques. Je vous propose quelques extraits du site.

La première vous permet de découvrir RISC OS et son histoire:

Découvrez RISC OS

Entre juin 1987, date de sortie du premier Archimedes, et février 2015, date de sortie du Raspberry Pi 2, de nouveaux ordinateurs compatibles RISC OS sont sortis presque chaque année. Seules exceptions en 27 ans, les années 1988, 1993, 2006 et 2007, où RISC OS n’est apparu sur aucune nouvelle machine.

RISC OS 5, juste après l’installation de base. – Cliquez pour agrandir

Au fil des générations, ce système d’exploitation a su évoluer pour s’adapter aux caractéristiques des nouveaux ordinateurs ARM. Aujourd’hui, RISC OS 5, développé par RISC OS Open Limited (ROOL), est la seule mouture du système encore activement supportée. Elle est compatible avec un nombre croissant d’ordinateurs et de cartes mères ARM.

Utilisez RISC OS

Ici vous trouverez les informations sur les offres « prêtes à l’emploi », mais aussi sur la création d’une machine RISC OS avec un Raspberry Pi, vous saurez comment devenir un acteur du monde RISC OS. Dans cette rubrique figure également la (longue) liste des machines compatibles RISC OS 5 ainsi que les benchmarks.

Si vous avez opté pour un Raspberry Pi, le premier achat indispensable sera le Nut Pi, un ensemble de vingt logiciels phares du monde RISC OS, dont DDE (Desktop Development Environment), qui vaut à lui seul plus que le package complet.

Quelques applications, certaines gratuites, d’autres payantes et des titres venant du monde Unix. – Cliquez pour agrandir –

Une fois équipé, reste à partir à la découverte de RISC OS 5, et – pourquoi pas ? – à participer à son développement. RISC OS est un formidable terrain de jeu pour créer des applications en amateur. Son Basic intégré permet en effet de mettre aisément au point des logiciels, de l’animation graphique la plus simple à l’application desktop la plus sophistiquée. Le C (via DDE ou GCC) est l’étape suivante dans le parcours du programmeur RISC OS. L’assembleur ARM sera pour sa part réservé aux plus mordus des développeurs.

Guide des logiciels

Plus de 600 logiciels figurent dans cette rubrique. Il serait étonnant que vous n’y trouviez pas votre bonheur . Au menu multimédia, réseaux, système… et bien plus encore !

Certaines des applications livrées en standard sous RISC OS 5. – Cliquez pour agrandir –

Des jeux, dont Star Fighter 3000 et SPatience (un des plus complets du marché ; 360 patiences !). – Cliquez pour agrandir –

Applications exclusives

Émulateurs RISC OS pour Windows : Afin de démarrer plus aisément dans le monde RISC OS, vous trouverez (entre autres) une archive prête à l’emploi d’un émulateur Risc PC dédié à Windows. RPCEmu (licence GPL) est ici livré préinstallé avec RISC OS 5 (licence Castle Technology).

NetSurf, navigateur web développé initialement sous RISC OS (bien la copie d’écran ), et Ovation Pro, toujours activement développé. – Cliquez pour agrandir –

Ressources exclusives

Alors là ! 30 fonds d’écran, 127 polices de caractères et 106 sons système vous attendent !

BBC BASIC sous RISC OS

Le BBC Basic est un langage de programmation né avec le BBC Micro, un ordinateur 8 bits qui a été l’un des best-sellers d’Acorn Computers. Cette machine servait de support à des cours de programmation dispensés par la BBC et était présente dans la plupart des écoles britanniques.

Sous RISC OS, des applications comme Maestro, SciCalc ou encore Patience sont écrites entièrement à l’aide du BBC Basic. Et elles ne sont même pas compilées, l’interpréteur Basic se montrant particulièrement véloce. Tous les logiciels présents ci-dessus sont écrits en pur Basic interprété… -Cliquez pour agrandir –

Le BBC Basic a poursuivi sa carrière sur les ordinateurs 32 bits d’Acorn pourvus de puces RISC ARM (l’architecture processeur devenue la plus commune au monde). Aujourd’hui encore, le BBC Basic est toujours livré en standard avec les dernières versions de RISC OS, dont RISC OS 5, le système qui se place au coeur d’une nouvelle génération de machines. Une bonne partie du code créé pour les BBC fonctionne encore sous RISC OS 5.

Conclusion

Une incursion dans le monde de RISC OS qui j’espère, vous donnera envie de découvrir ce système qui a eu le temps de se stabiliser et de faire ses preuves.

Léger, rapide et performant il pourra vous accompagner dans vos projets. Les bémols ? Pas de gestion du WiFi qui apparemment a disparu lors des évolutions du système, et pas de gestion de la caméra. Pour le reste tout est géré et fonctionne, la disponibilité de nombreux logiciels stables est également un plus.

Merci à Xavier Louis qui m’a aiguillé vers riscos.fr

Sources

• http://riscos.fr/
• http://riscos.fr/decouvrez.html
• https://www.riscosopen.org/content/downloads/raspberry-pi

C’est en tout cas ce qu’affirme Dylan Callahan qui a annoncé aujourd’hui la disponibilité immédiate de la troisième mouture de Chromium OS (Chrome OS) pour le Raspberry Pi 2.
Les Codecs nécessaires pour le multimédia sont maintenant installés d’origine et par rapport à la version précédente, de nombreux problèmes gênants ont été corrigés.

Chromium OS disponible pour le Raspberry Pi 2

Chromium OS 0.3 est arrivé sur le Raspberry Pi 2 amis RaspiNautes ! Et il promet d’apporter une amélioration des performances de 8% (à voir…), des codecs pour le multimedia intégrés d’origine, ainsi qu’un ensemble de correctifs pour les problèmes les plus gênants rapportés par les utilisateurs depuis la sortie de la version précédente de l’OS.

Par exemple, il est maintenant possible d’étendre la quantité d’espace disque libre :  de nombreux utilisateurs ont signalé qu’elle était limitée à 200 Mo environ. L’heure est maintenant automatiquement synchronisée sans intervention de l’utilisateur. Certains gels inexpliqués des sessions de connexion ont été résolus, et les sites Web devraient maintenant afficher correctement.

« C’est une distribution toute jeune, donc nous sommes conscients du fait qu’il y a encore des bugs. Beaucoup d’entre eux ont déjà été traités dans notre dernier révision du code et nous allons diffuser de nouvelles versions de test bientôt ! Mais n’hésitez pas à nous faire remonter tout ce que vous remarquerez et que nous n’avons pas vu . Nous sommes conscients du fait que le résultat n’est pas parfait avec cette version », dit Dylan Callahan.

Le support de Netflix est parmi les fonctions les plus demandées

Dylan Callahan et son équipe travaillent à améliorer encore le port de Chrome OS pour le Raspberry Pi 2 et à lui ajouter autant de fonctionnalités que possible. Parmi les plus demandées on trouve le support de Netflix et des services de streaming vidéo similaires utilisant les DRM, ce qui devrait exister dans les prochaines versions.

Télécharger Chrome OS

Soyez parmi les premiers à télécharger le Chrome OS 0.3 (environ 447 Mo) pour le Raspberry Pi 2, que vous pourrez installer sur une carte micro SD 2Go (ou plus) de classe 6 ou 10.

Cliquez uniquement sur le bouton vert : DOWNLOAD (436.24 MB)

Installer Chrome OS

Comment installer cet OS à partir d’un PC sous Linux (une Debian 7 pour moi)?  Commencez par extraire le fichier image (un .bin de 1,9 Go)  à partir de l’archive zip, puis connectez la carte microSD à votre PC, et vérifiez bien son emplacement en exécutant la commande de lsblk.

Si vous avez un seul lecteur sur votre PC, la carte microSD est situé sous /dev/sdb. Dans un terminal, tapez

dd if=image.img of=/dev/sdX

(« image.img » étant le nom du fichier img de la version de Chromium OS pour le Raspberry Pi 2, et « /dev/sdX » l’emplacement de la carte micro SD.

pour moi c’était :

root@debian-7:~# dd if=chromiumos_image.bin of=/dev/sdb bs=4096
476664+0 enregistrements lus
476664+0 enregistrements écrits
1952415744 octets (2,0 GB) copiés, 575,561 s, 3,4 MB/s

Vidéo

Conclusion

Encore un système d’exploitation qui arrive sur notre framboise. Cette multiplication des possibilités du Raspberry Pi montre bien tout l’intérêt qu’il éveille…

Si vous testez Chrome OS, n’hésitez pas à laisser vos impressions ci-dessous.

Merci Seb de m’avoir transmis cette info

Sources

• http://news.softpedia.com/news/chromium-os-for-raspberry-pi-2-gets-an-8-overall-performance-increase-499255.shtml
• https://github.com/tohipfortheroom
• https://github.com/tohipfortheroom?tab=activity
• http://www.mediafire.com/download/d33q4w5r4gn32oh
• https://www.reddit.com/r/ChromiumRPI/
• https://www.reddit.com/r/ChromiumRPI/comments/421r7r/release_chromium_os_for_raspberry_pi_2_03/

Au commencement était le Raspberry Pi Model B, avec sa carte SD. Chaque carte SD était soigneusement rangée dans sa petite boîte en plastique translucide.
Et puis sont venus les petits nouveaux, avec leur toute ch’tite carte microSD. Et là ça se corse. Si on trouve encore quelques boîtes l’évolution va vers la vente des microSD en blister. Une fois que vous les avez ouverts la pauvre carte se retrouve bien seule…

Rangement des cartes micro SD

Vous me direz que si vous avez un seul Raspberry Pi et que la carte microSD reste dedans ça ne pose pas trop de problème.

Par contre, si votre élevage de Raspberry Pi est productif (c’est le cas du mien !) vous vous retrouvez à la tête d’une grande famille, chaque membre de la fratrie utilisant une, voire plusieurs cartes microSD…

Vous comprenez que je ne peux pas re-flasher une carte SD chaque fois que je fais un test et utiliser la même carte en boucle, en la ré-écrivant à chaque fois. En plus d’être chronophage, cette méthode amène parfois à faire des conneries erreurs  par exemple en effaçant une carte dont on avait encore besoin… (oui ça m’est arrivé… et alors ?)

Pas facile d’écrire sur les cartes micro SD à moins de limiter les informations portées sur la carte. J’ai essayé de mettre un numéro et de suivre les cartes dans un tableau Calc, mais ce n’est pas pratique.

Un jour j’ai découvert le range carte microSD !

De la taille d’une carte bancaire (donc de la taille d’un Raspberry Pi ) ce gadget est prévu pour accueillir 8 cartes micro SD. Il tient sans problème dans une poche de chemise.

Différents modèles existent, la différence tient surtout à la décoration du support.

Pour ma part je suis resté sérieux et j’ai adopté un modèle classique qui me semble plus adapté à mon utilisation :

De l’autre côté vous avez au niveau de chaque carte une zone blanche dans laquelle vous pouvez porter des indications à propos du contenu.

C’est suffisamment grand pour écrire 2 lignes avec un crayon fin. J’arrive même à gommer quand je change le contenu d’une carte. Bon si vous écrivez avec un stylo indélébile ça sera sûrement plus difficile…

Quelques exemples :

Si les modèles accueillant 8 cartes ne vous suffisent pas (j’en suis à 2) il existe également des moèles à 24 emplacements, pas plus grands mais en aluminium cette fois :

Conclusion

Je ne vous mets pas de liens vers ces range-carte microSD car ce sont souvent des liens éphémères sur des boutiques en ligne.

Méfiez vous car les modèles qu’on trouve actuellement sur Libé (cherchez par exemple dimecard holder) proviennent des USA ou de Grande-Bretagne. Ils coûtent une dizaine d’euros ou plus et les frais de port sont du même ordre. Fô pas exagérer, c’est un simple morceau de plastique et les cartes tiennent par friction, il n’y a pas de système de ressort…

Si vous ne trouvez que ce genre de range-carte, tournez vous vers le grand fleuve d’Amérique du Sud. Les frais de ports seront souvent moins élevés, comme le prix du produit. Pas de précipitation, comparez bien prix et frais de port… Je vous aurai prévenu.

Bien pratique si vous trimballez toute la journée des SD cards, ce système de rangement trouvera sa place dans la poche d’une chemise comme dans la valise du technicien.

Vous avez une autre – une meilleure solution ? Allez zou ! parlez en dans les commentaires ci-dessous

 Sources

• http://dimedium.com/

Avec ce numéro de Hackable Magazine, le N°10 de janvier-février 2016, Denis BODOR met à nouveau la barre très haut !
Au menu de ce numéro hivernal, vous trouverez de quoi vous réchauffer pendant les longues soirées d’hiver (dépêchez vous, les jours rallongent…).
Parmi les sujets abordé, la NFC se taille la part du lion puisque qu’elle est abordée aussi bien depuis l’Arduino que le Raspberry Pi.
Et puis pour une fois un hack matériel… siiiiii
L’utilisation d’un GPS USB de récup avec un Arduino, en supprimant l’interface USB  qui sévit au milieu du câble…

Hackable Magazine N°10 janvier-février 2016

Un Récepteur GPS avec l’Arduino

Comment redonner vie à un GPS trouvé dans un vide grenier ? En supprimant l’adaptateur USB qui encombre le câble et en reliant directement la sortie série à un Arduino qui sera en charge de décoder les trames NMEA…

Communication par lumière visible avec Arduino

La généralisation du Li-Fi c’est  pour demain… Plus d’ondes dangereuses, plus d’antennes rayonnantes ! C’est la lumière produite par les LED utilisées en éclairage qui transmettra les informations. A mon avis on trouvera encore des inconvénients (sécurité, problèmes médicaux posés par le clignotement rapide des LED… mais c’est une autre histoire qui se répète à chaque fois qu’une nouvelle technologie apparait. Aux débuts du chemin de fer : Le professeur Dionysius Lardner a affirmé en 1830 « Le voyage en chemin de fer à grande vitesse n’est pas possible car les passagers incapables de respirer mourraient par asphyxie. » (Wikipedia)

Bon, ici il s’agit d’expérimenter ce moyen de transmission en utilisant deux LED (oui elles peuvent aussi jouer le rôle de récepteur).

Une horloge à aiguille originale

Originale dans le sens où l’affichage se fait sur 2 galvanomètres à aiguille gradués en heures et en minutes. Un module RTC et un Arduino et c’est prêt Un bon exemple d’utilisation du PWM sur Arduino

La NFC et les tags RFID : Ce qu’il faut savoir

Hackable s’est fixé comme objectif, depuis le premier numéro, de permettre un accès à l’électronique numérique, à la programmation et aux technologies à tous les curieux et bidouilleurs. Aborder dans nos pages la NFC passe par une introduction pédagogique devant être la plus claire possible. Nous avons donc pris le temps (et l’espace) nécessaire pour exposer les choses le plus simplement possible, dans une introduction qui vous donnera, je l’espère, les clés et les bases pour passer sereinement à la pratique, aussi bien avec votre carte Arduino qu’avec votre/vos Raspberry Pi.
Dans ce numéro, vous découvrirez et comprendrez ce qu’est la NFC, ses relations avec la RFID, la construction générale, les principes de bases, la terminologie, le matériel nécessaire, les outils et bibliothèques à utiliser, etc. Le tout sans peine, sans hurlement et sans maux de tête. Le tout complété par des mises en oeuvre pratiques, comme toujours, aussi bien avec Arduino qu’avec Raspberry Pi. (http://www.hackable.fr/?p=746)

RFID et NFC sur Android : Quelles applis?

Une revue des applications disponibles sur Android pour jouer avec les tags et votre smartphone… avec votre carte bancaire aussi

Configurer le NFC sur le Raspberry Pi

Même si Raspbian contient beaucoup de choses, le support des périphériques de lecture/écriture des tags NFC/RFID n’est pas prévu. Cet article vous explique comment mettre tout ça en place proprement.

Raspberry Pi et tags NFC/RFID

Après la mise en place de la couche logicielle permettant d’utiliser les tags NFC/RFID, cet article fait le tour des utilitaires que vous pourrez utiliser pour vous amuser avec les tags et votre Raspberry Pi

Lire les tags NFC avec Arduino

Bon ne soyons pas chauvins ! L’Arduino est lui aussi capable de lire les tags NFC/RFID… La preuve !

Chargeur solaire LiPo Rider Pro

Un projet Arduino ou Raspberry Pi à alimenter en autonomie ? La solution qui vient à l’esprit c’est le panneau solaire. Mais bon… La mise en œuvre et surtout la charge (dangereuse) d’une batterie LiPo est souvent un frein à l’utilisation de ce type d’alimentation.

Le module open source LiPo Rider Pro vous offre une solution clé en main et vous pouvez vous concentrer sur le projet lui-même.

Du code atomique sur Arduino

Je vous rassure… Pas question ici de reproduire Fukushima ou Tchernobyl ! Un excellent article sur l’écriture de code « atomique » in-interruptible sur Arduino, ainsi que l’explication de quelques bugs fréquent mais qui restent souvent mystérieux.

Compilez un noyau pour votre Raspberry Pi

Allez, vanne de Geek : « Si vous en avez assez d’avoir des pépins avec windows, passez au noyau de Linux ».

Là on joue dans la cour des barbus. Il y a belle burette lurette qu’on n’est plus obligé de compiler son noyau pour s’amuser avec Linux (et c’est tant mieux) mais il faut parfois revenir à ces méthodes. Soit pour comprendre (enfin) en quoi consiste la compilation du noyau, soit pour ajouter un périphérique exotique que Linux ne semble pas connaître.

Vous trouverez ici toutes les informations pour vous lacer dans la compilation croisée…

Conclusion

Je ne sais pas comment fait Denis.Ses journées doivent faire 30 ou 40 heures

J’écris des articles, je connais la difficulté de l’exercice. Entre documentation, synthèse, écriture… On ne voit pas le temps passer.

Hackable nous propose des articles pédagogiques, faciles à lire, instructifs, pratiques…

Si vous êtes passionné(e) d’Arduino ou de Raspberry, curieux de découvrir le NFC, ce numéro il faut l’avoir !

Sources

Hackable 10 est disponible chez votre marchand de journaux

Idein est une start-up japonaise. Elle utilisé un Raspberry Pi Compute Module pour créer Actbulb, un dispositif multi-fonctionnel pour des applications utilisant le calcul de la détection de mouvement et l’analyse de données. Ce produit se visse dans une douille d’ampoule normale.
Pour leurs tests internes, ils ont décidé de créer un cluster de 16 cartes Raspberry Pi zéro.

Un cluster de 16 Raspberry Pi Zero

Actbulb

Actbulb, le projet de la startup japonaise, est un détecteur de mouvements intelligent, basé sur un Compute Module.

Intégré dans un boîtier qui peut remplacer une lampe à culot vissable E27 (de 27mm), le Compute Module de la Fondation Raspberry Pi assure des fonctions de détection intelligentes.

Le cluster de 16 Raspberry Pi Zero

La carte Cluster Pizero Cluster dispose de 32 ports micro USB pour l’alimentation et les données (deux pour chaque Raspberry Pi Zero). Elle comporte également 16 ports USB de type A, et 16 connecteurs Ethernet. Idein a probablement créé cette carte pour tester ActBulb, comme Koichi Nakamura, PDG et fondateur d’Idein mentionné que:

« Nous créons un dispositif de détection qui utilise le Compute Module Raspberry Pi. Donc, nous avons besoin de beaucoup de Raspberry Pi pour le développement et les tests. Puisque nous allons utiliser le GPU du RasPi pour le traitement de l’image, le deep learning, etc. Nous avons un besoin réel de Raspberry Pi, mais pas seulement comme machines Linux. Pour autre chose. Ils peuvent être utilisés pour flasher les eMMC de nos appareils via les ports USB, lorsque nous avons à le faire.« 

Cliquez pour agrandir

Vous avez sans doute remarqué qu’il n’y a qu’un seul Raspberry Pi Zero sur la carte Cluster… C’est tout simplement parce qu’il n’y en a pas plus, et que les cartes Pi Zero ne sont pas disponibles sur le marché.

Cliquez pour agrandir

La fondation Raspberry Pi a lancé la fabrication de nouveaux exemplaires (voir ci-dessous), mais ils n’en vendront qu’un par client pour le moment en raison de la forte demande. Ça pourra prendre un certain temps pour que la carte soit garnie de ses 16 PiZero… Même en supposant qu’ils se fassent aider par la famille ou les amis

Cliquez pour agrandir

Dernière minute

Après la publication des informations sur leur carte PiZero cluster, Idein a eu beaucoup de retours et de demandes…

L’entreprise projette d’intégrer un commutateur Ethernet, d’ajouter des connecteurs GPIO, etc .. et probablement de vendre la carte. A suivre donc…

Les Raspberry Pi Zero en production

La production de Raspberry Pi Zero bat son plein pour répondre à la demande. Pour info, dans le bac ci-dessus il y en a 280 ! Et pas loin de 2000 sur la photo du dessus

Patience ils arrivent !

Conclusion

Que faire avec un cluster de 16 PiZero ? Ne pas oublier qu’il s’agit de Soc BCM 2835 mono cœur avec 512 Mo de RAM, et à part pour des formations au calcul distribué à moindre coût… Si vous avez des idées.

Sources

• http://actbulb.idein.jp/

This is What a 16 Raspberry Pi Zero Cluster Board Looks Like

L’an passé l’hébergeur associatif Web4all proposait à ses adhérents/clients de tester -gratuitement- des serveurs VPS (Virtual Private Server = Serveur virtuel privé), suivant le principe premier inscrit premier servi. J’ai eu la chance de décrocher un VPS hébergé par Web4all qui souhaite ainsi tester sa future offre.
Automatiser entièrement un timelapse fut le deuxième projet testé sur ce VPS. Le premier avait été le traitement des trames SigFox dont je vous avais parlé en septembre.

Pour tester plus avant les possibilités du serveur, je propose à mon collègue Jean-Pierre qui a imaginé un projet de timelapse sur les levers de soleil, d’utiliser le VPS pour réaliser les vidéos, au lieu de les assembler sur le Raspberry. Ça devrait accélérer le processus et mettre la vidéo à disposition plus rapidement.

SI le projet vous intéresse, je vous propose un article décrivant cette réalisation. Attention, ce n’est pas un tutoriel ! Le projet est en constante évolution et pas du tout figé. Il sert aussi de « bac à sable » pour tester des solutions qui sont ensuite utilisées sur d’autres développements, y compris professionnels…
Ne vous attendez donc pas à un descriptif de type « Next.. Next.. Next » ! Si vous vous lancez dans un projet identique, il faudra vous prendre par la main et mettre au point certaines parties du projet (RTFM)…

Toutes les critiques sont possibles, sur la méthode, sur le code… Mais bon, si ça ne vous plait pas, il faudra réaliser « votre » projet et le publier…

Toutes les vidéos ne sont pas disponibles… Quand il y a de la brume on ne voit pas grand chose… Et puis la taille du disque étant limitée, il faut bien faire des choix

Le synoptique du projet

Une caméra est chargée de prendre des photos toutes les 20 secondes. Le moment de la prise de vue est calculé en Python en fonction des heures de lever du soleil à l’endroit de la prise de vue.

Le Raspberry Pi dépose les photos dans un dossier du serveur VPS hébergé chez Web4all en passant par une liaison Wi-Fi, une FreeBox et Internet.

Le VPS qui a reçu les informations des heures de prise de vue démarre la construction de la vidéo et la publie sur Internet avec une mise en page minimaliste (bin oui quoi, c’est du test ).

Voilà vous savez comment le système est organisé. On regarde les détails ?

Le VPS de Web4all

C’est Benoit (Expert infrastructure de Web4all) qui a bien voulu me donner les renseignements sur les VPS en test chez l’hébergeur.

Le serveur de virtualisation utilisé aujourd’hui, dans le cadre d’une pré-béta VPS de type container est basé sur une machine virtuelle qui fonctionne sous VMware.

En effet, toute l’infrastructure Web4all est virtualisée et offre déjà des services sur des VPS infogérés de type Vmware pour des besoins précis mais ce n’est pas encore mis en avant sur leur site. Les clients qui connaissent web4all n’hésitent pas à demander s’il est possible de mettre en place telle et telle solution ou infra pour eux.

Web4all envisage également de mettre un service de VPS type containter en place. Un projet parmi d’autres qui est lancé actuellement en pré-bêta pour avoir une idée du fonctionnement de la technologie
Pour l’instant il n’y a pas de panneau de gestion, ce n’est pas encore dans le manager Web4all actuellement ni dans la prochaine version qui devrait voir le jour avant la fin de l’année.
Le but des VPS de type container est de permettre aux clients de mettre en place des solutions suivant leur besoin pour des services qui ne nécessitent pas un environnement redondé. Donc on parle ici de services non productifs ou des applications non critiques au niveau disponibilité .

A terme, si ce service est lancé , web4all offrira la possibilité de déployer des VPS applicatifs pré-configurés.

Les classiques OS de base seront disponible (Centos, Debian, Ubuntu) avec installation/réinstallation depuis le manager.

Pour l’instant la question qui reste en suspend c’est de savoir si la virtualisation se fera en interne sur un serveur physique dédié ou si elle est externalisée chez un prestataire pour diminuer les coûts.

Le VPS d’un point de vue technique

Au niveau de la virtualisation

– Type de virtualisation : container
– Technologie de virtualisation LXD  basée sur LXC qui existe depuis plusieurs années.

La particularité ici est au niveau du fonctionnement de LXD et des containers « sans privilèges »… Globalement, l’utilsateur est root dans le container, mais sur l’hyperviseur, les processus exécutés dans le container en tant que root le sont comme un utilisateur standard sur le système. Si quelqu’un parvenait à s’échapper du container, il ne serait pas « root » sur la machine mais utilisateur standard.

Au niveau Hyperviseur

– Machine virtuelle (VM) type Vmware qui repose sur l’infrastructure web4all.
– Disque : 200 Go (LVM)
– OS: Ubuntu 15.04 (vivid)

Au niveau réseau

– Virtualisation du réseau avec Open Vswitch (http://openvswitch.org/)
– Gestion des flux avec Open Flow (géré par OVS)

Au niveau VPS

Pour la pré-béta

– Shares CPU: 1024
– Ram: 1Go
– Disque: 10 Go (en LVM)
– Connexion 10 Mb/s
– OS: Ubuntu 15.05 (vivid)
– Déploiement et mise en place automatisée entièrement par l’équipe Web4all

Comment ça marche ?

Cliquez pour agrandir

Préparation du Raspberry

Matériel :

• Raspberry Pi Model B
• Carte SD avec distribution Wheezy en mode texte
• clé USB WiFi
• Caméra compatible Raspberry Pi
• Alimentation 5V/2A

Le Raspberry Pi utilisé pour le timelapse, avec une caméra à monture CS. (photoJ-P)

Préparer le Raspberry Pi

Si vous voulez tester l’encodage de la vidéo sur le Raspberry Pi, installez mencoder :

sudo apt-get install mencoder

La prise de vue se fera avec raspistill comme dans le tutoriel publié dans Epinglé.

raspistill -o timelapse_%d.jpg -tl 12000 -t 14400000

mencoder -nosound -ovc lavc -lavcopts vcodec=mpeg4 -o test.avi -mf type=jpeg:fps=20 mf://@files.txt

Les options de raspistill  -tl pour indiquer un timelapse avec prise de vue toutes les 12 secondes (12000 mS) pendant 4 heures (14400000 mS).

La ligne de commande avec mencoder permet de réaliser la vidéo sur le Raspberry Pi (ne soyez pas trop pressé(e) !) en fonction d’un liste files.txt dans laquelle on a copié les noms des photos à assembler. Le fichier obtenu, test.avi est en mpeg4.

Le Raspberry Pi est posé sur un rebord de fenêtre. Il est abrité mais reste 24h/24h à l’extérieur. (photo J-P)

Le serveur est accessible sur vps.goblink.fr et le partage samba s’appelle goblink. Le partage du serveur est monté dans un premier temps manuellement sur le Raspberry Pi dans le dossier /home/pi/vps.

Une fois que c’est testé et que ça fonctionne, il faut monter le partage dans /etc/fstab, sinon au premier redémarrage… hop ! plus de partage

(les identifiants ont été masqués… allez savoir pourquoi?)

Le Mont-Blanc est dans l’axe de prise de vue. Les branches sont visibles sur certaines vidéos. (photo J-P)

Le principe de fonctionnement étant de créer une crontab en Python, il faut installer le module python-crontab sur le Raspberry Pi.

pip install pyhton-crontab

Pour prendre en compte l’heure d’été :

heuredete = time.localtime().tm_isdst

Script exécuté à 00h01

A minuit et une minute (bin… pourquoi pas ?) le script python shedtlapse.py est exécuté.

Fichier shedtlapse.py

from math import cos, acos, sin, asin, degrees, radians
import crontab
import datetime
import time
import pickle
from crontab import CronTab

# Source:
# http://pagesperso-orange.fr/jean-paul.cornec/heures_lc.htm
class sunriseClass:
    def __init__(self):
        self.theDay=0
        self.theDate=[]
        self.solarDeclination=0
        self.equationOfTime=0
        self.latitude=0
        self.longitude=0
        self.sunrise=0
        self.sunset=0
        self.meridian=0
        self.duration=0
        self.sunriseTime=0
        self.sunsetTime=0
        self.meridianTime=0
        self.durationTime=0

    def getDay(self,d,m,y):
        d=float(d)
        m=float(m)
        y=float(y)
        n1 = int( (m* 275.0)/9.0 )
        n2 = int( (m+9.0)/12.0 )
        k = 1.0 + int( (y-4.0*int(y/4.0)+2.0)/3.0 )
        n=n1-n2*k+d-30.0
        return int(n)

    def getEoT(self,j):
        j=float(j)
        m = 357.0+(0.9856*j) 
        c = (1.914*sin(radians(m))) + (0.02*sin(radians(2.0*m)))
        l = 280.0 + c + (0.9856*j)
        r=(-2.465*sin(radians(2.0*l))) + (0.053*sin(radians(4.0*l)))
        Equ=(c+r)*4.0
        return Equ/60.0

    def getDec(self,j):
        j=float(j)
        m = 357.0+(0.9856*j) 
        c = (1.914*sin(radians(m))) + (0.02*sin(radians(2.0*m)))
        l = 280.0 + c + (0.9856*j)
        sinDec= 0.3978*sin(radians(l))
        return degrees(asin(sinDec))

    def getHo(self,Dec,Lat,Lon):
        cosHo=( -0.01454-sin(radians(self.solarDeclination))*sin(radians(self.latitude)) ) / ( cos(radians(self.solarDeclination))*cos(radians(self.latitude)) )
        return (degrees(acos(cosHo))/15.0)

    def setNumericalDate(self,d,m,y):
        self.theDate=[d,m,y]
        self.theDay=self.getDay(d,m,y)
        self.solarDeclination=self.getDec(self.theDay)
        self.equationOfTime=self.getEoT(self.theDay)
        return None

    def setLocation(self,Lat,Lon):
        self.latitude=Lat
        self.longitude=Lon
        return None

    def getHM(self,nH):
        h=int(nH)
        m=int(((nH*60.0)%60)+0.5)
        return '%d:%02d' % (h,m)

    def calculateWithUTC(self,UTC):
        mLon=(self.longitude*4.0)/60.0
        Ho=self.getHo(self.solarDeclination,self.latitude,self.longitude)
        self.meridian=12.0+self.equationOfTime-mLon+UTC
        self.sunrise=self.meridian-Ho 
        self.sunset=self.meridian+Ho 
        self.duration=2.0*Ho
        self.meridianTime=self.getHM(self.meridian)
        self.sunriseTime=self.getHM(self.sunrise)
        self.sunsetTime=self.getHM(self.sunset)
        self.durationTime=self.getHM(self.duration)
        return None

thisDay=datetime.date.today()
mySunrise=sunriseClass()
mySunrise.setNumericalDate(thisDay.day,thisDay.month,thisDay.year)
#mySunrise.setLocation(34.052222,-118.243611) # Los Angeles, UTC -8
#mySunrise.setLocation(41.012222,28.975833) # Istanbul, UTC +2
#mySunrise.setLocation(48.856667,2.350833) # Paris, UTC +1
mySunrise.setLocation(46.711667,4.696667) # renseigner votre location 
mySunrise.calculateWithUTC(+(1+time.localtime().tm_isdst))

coucher = mySunrise.sunset 
lever = mySunrise.sunrise

#-------------calcul décalage de la capture avant le lever du soleil---------------
debcapture = lever - 0.75
fincapture = debcapture + 2

coucherheure = int(coucher)
coucherminute =int( (coucher-int(coucher))*60)
leverheure = int(lever)
leverminute = int( (lever-int(lever))*60)

debcapheure = int(debcapture)
debcapminute = int((debcapture-int(debcapture))*60)

fincapheure = int(fincapture)
fincapminute = int((fincapture-int(fincapture))*60)

heuredete = time.localtime().tm_isdst

#----------------déclaration objet timelapse----------

timelapse ={
        "fincapture" :  fincapture,   
        "debcapheure":  debcapheure,
        "debcapminute": debcapminute,
        "fincapheure":  fincapheure,
        "fincapminute": fincapminute,
        "leverheure":   leverheure,
        "leverminute":  leverminute,
        "coucherheure": coucherheure,
        "coucherminute":  coucherminute,
}

#------------------génération de la tache crontab---------------------------
tab = CronTab(user='pi')
tab.remove_all()
cmd = 'sudo  /home/pi/capture.sh'
cron_job = tab.new(cmd, comment='timelaps du jour')
cron_job.minute.on(debcapminute)
cron_job.hour.on(debcapheure)

tab.write()
print tab.render()

#------------------création d'un fichier avec objet timelapse de la date du jour sur le serveur dans le dossier meta--------------
#-------------enregistrement de l’objet dans un fichier en texte-----------------------------
filename="./vpstimelaps/meta/" + str(thisDay.year) +"-"+ str(thisDay.month)+"-" + str(thisDay.day) + ".txt"    
with  open(filename,"wb")   as fichier:
    mon_pickler = pickle.Pickler(fichier)
    mon_pickler.dump(timelapse)

Jean-Pierre a utilisé un superbe programme (on ne réinvente pas le fil à couper l’eau chaude ) de Jean-Paul CORNEC qui calcule avec précision les heures de lever et de coucher du soleil. Les essais ont montré que (contrairement à ce que nous pensions) quelques kilomètres de décalage en longitude ou en latitude sont sensibles sur ces horaires…

Sur cette photo on voit bien l’objectif à monture CS qui équipe la caméra – http://www.framboise314.fr/une-nouvelle-gamme-de-cameras-chez-arducam/2/ (photo J-P)

Script pour réaliser une capture d’images pendant 2 heures

Ce script est lancé pour réaliser la capture d’images pendant 2 heures, à raison d’une image toutes les 20 secondes.

La zone couverte par la photo

Cliquez pour agrandir.

Chaque image est prise depuis un point situé au sud-ouest de Chalon sur Saône, en direction du sud-est. La zone couverte par la photo englobe le Mont-Blanc (situé à 192 Km). La montagne apparait lorsque le temps est clair. On voit également la chaîne des Alpes sur la gauche du sommet de l’Europe.

Le côté serveur

Côté serveur, le script Python cronjpg2mp4.py est lui exécuté tous les jours à 2h01, lancé depuis la crontab.

Fichier /etc/crontab du serveur

Le fichier cronjpg2mp4.py lit le fichier contenant l’objet timelapse de la date du jour que le Raspberry Pi a déposé sur le serveur à minuit.

Il utilise les informations qu’il contient pour générer la tâche chargée d’exécuter l’assemblage des images 5 minutes après la fin de la capture.

Cinq minutes après la fin de la prise de vue, le VPS lance l’assemblage des images pour en faire un vidéo. Il extrait également une image correspondant au moment du lever du soleil, pour en faire la miniature qui sera affichée pour présenter la vidéo (sinon la vidéo se charge et ralentit fortement l’affichage…).

Quand la vidéo est terminée, elle est transférée avec la miniature qui lui correspond. Le serveur web est chargé de gérer l’affichage des vidéos, le défilement avant/arrière…

Et ça donne quoi ?

Le mieux est d’aller voir sur le serveur VPS : http://vps.goblink.fr

Sinon, voici un avant-goût des résultats obtenus :

Conclusion

Encore en phase de test, le système connait parfois une interruption de service, souvent due à la perte de connexion du Raspberry Pi en Wi-Fi.

Par rapport au Raspberry qui mettait de nombreuses minutes (15 à 20 mn) pour assembler les 360 photos, le VPS raccourcit le temps de fabrication de la vidéo à 1 à 2 minutes minutes.

De plus, il permet de publier les vidéos en ligne à destination des visiteurs.

D’après les retours de Web4all, le serveur VPS est un des plus actifs de ceux mis à disposition pour les tests. Ne soyez pas étonné(e) si l’affichage est lent ou la diffusion de la vidéo un peu hâchée, la bande passante est (volontairement) limitée pour ces machines de test gratuites…

Merci à Jean-Pierre d’avoir mis cette expérience à disposition de la communauté.

Sources

•  http://vps.goblink.fr/
• https://pypi.python.org/pypi/python-crontab
• http://pagesperso-orange.fr/jean-paul.cornec/heures_lc.htm

Simple time lapse video in Linux

Time-lapse avec Raspberry Pi et sa (Pi)caméra

Même si je suis pas très actif côté émission (c’est un peu la faute au Raspberry Pi ), je reste radioamateur et passionné par les techniques de plus en plus numériques qui apparaissent dans ce domaine.
Je vous ai déjà parlé du SDR (Software Defined Radio) pour suivre les avions ou écouter la radio avec votre RasPi… Le projet que décrit cet article vous permettra de visualiser une fréquence et ses environs. Il s’agit d’un analyseur de spectre à base de Raspberry Pi. Adafruit appelle ce projet un scanner…

Ne vous lancez pas dans cette réalisation si vous êtes débutant. Ce tutoriel ne détaille pas toutes les opérations et il vaut mieux avoir un peu d’expérience avec Debian…

Un analyseur de spectre avec un Raspberry Pi

C’est quoi un analyseur de spectre ?

Un analyseur de spectre est un instrument de mesure destiné à afficher les différentes fréquences contenues dans un signal ainsi que leurs amplitudes respectives. Les signaux peuvent être de natures diverses : électrique, optique, sonore, radioélectrique. (wikipedia)

Source Wikipedia

Les analyseurs de spectre sont des appareils autonomes coûtant de quelques centaines à quelques milliers (glups !) d’euros. C’est pourtant un appareil très utile (sinon indispensable) quand on travaille dans le domaine des radiocommunications.
Le premier modèle proposé par Adafruit avait été réalisé sur une base de Raspberry Pi model B, il était tentant de profiter de la disponibilité du Raspberry Pi 2 avec ses 4 cœurs  pour améliorer (peut-être) cette réalisation.

La problématique

• L’analyseur de spectre (scanner) a été initialement réalisé sur un RasPi model B sous Wheezy.
• Les réponses sur le forum Adafruit renvoient généralement les questionneurs dans leurs buts quand l’écran utilisé n’est pas celui pour lequel le « scanner » a été développé.
• Ça tombe bien (comme disait le père La Chaise) l’écran adapté au Pi2 est le modèle Adafruit 2441 (3,5 pouces PiTFT Plus) alors que le scanner a été réalisé avec le modèle 2097 (3,5 pouces PiTFT…). Donc s’il y a des problèmes… dém… toi
• Même si on n’est pas en présence d’un « vrai » appareil de mesure, les clés USB DVB-T que j’ai utilisées jusqu’alors présentent un certain nombre de défauts (on va pas chipoter pour un récepteur à 15€…)

Les choix

Après moult réflexion, lecture de docs (RTFM) et d’articles parus sur des blogs, étude des caractéristiques… il fallait se décider ! Voici donc les choix que j’ai arrêtés pour ce projet :

• Utiliser un Raspberry Pi 2 sous Jessie
• Utiliser un écran Adafruit PiTFT Plus 3,5 pouces (ref. 2441)
• Utiliser une clé DVB-T RTL-DSR de dernière génération (et un peu plus cher )
• Lancer l’analyseur automatiquement au démarrage du RasPi
• Rendre l’appareil autonome (par la suite)

Réalisation de l’analyseur logique / scanner

Choix et installation du système

Il y a deux possibilités :

• Soit on part d’un Jessie de base dans le noyau duquel  on va intégrer les composants logiciels destinés à gérer un écran PiTFT de 3,5 pouces (le 2097 !) – à la mano ou en utilisant un script fourni.
• Soit on installe une distribution Jessie déjà préparée pour le PiTFT par Adafruit et disponible en téléchargement sur leur site. (en date du 24 sept. 2015)

Vous ferez bien comme vous voulez… Pour ma part la solution consistant à utiliser une distribution toute faite me convient particulièrement bien et c’est celle que je vous propose.

Téléchargez la version de Jessie préparée pour gérer l’écran PiTFT 3.5″. Téléchargez les 1,5 Go de cette version et rangez le fichier 2015-09-24-raspbian-jessie-pitft35r.zip dans un dossier de votre PC. Extrayez l’image contenue dans l’archive .zip : 2015-09-24-raspbian-jessie-pitft35r.img (4,2 Go).

Si vous êtes sous Windows, insérez votre carte micro SD dans le lecteur de carte. Repérez soigneusement la lettre identifiant votre carte, toute erreur effacera irrémédiablement les données à l’endroit où vous transférerez l’image !!!

Lancez Win32DiskImager (en tant qu’admin), choisissez la lettre de la carte micro SD de destination (voir ci-dessus) et démarrez l’écriture de l’image sur la carte…

A la fin de l’opération vous avez entre les mains une carte prête à être utilisée avec le Raspberry Pi 2 et l’écran PiTFT 3,5″.

Avant de mettre la carte en service et d’appliquer la tension d’alimentation, regardons les composants que nous allons utiliser.

Le Raspberry Pi 2

Bon, ici pas de surprise. c’est un Raspberry Pi 2 classique. Ne faites pas attention aux pattes tordues sur le GPIO (ah, zut, vous n’aviez pas remarqué ?) c’est arrivé en enlevant l’écran à la main, c’est parti d’un coup et d’un côté… La prochaine fois ce sera tournevis plat et démontage précautionneux
Remarquez l’adhésif sur le dessus des prises. L’écran n’a pas de contacts dans cette zone, sauf… 1 et c’est par précaution que j’ai appliqué cette protection. Pour le reste c’est un Raspberry Pi 2 tout ce qu’il y a de plus banal (processeur 4 cœurs 900MHz ARM Cortex-A7 CPU, 1 Go de RAM, 4 ports USB, un port Ethernet, sortie HDMI et audio/vidéo analogique…)

L’écran PiTFT Plus 3,5″

Livré tout monté et prêt à l’emploi, l’écran PiTFT Plus 3,5″ Adafruit est destiné aux modèles A+, B+ et Pi2 du fait de la présence d’un connecteur 40 points. Ce modèle 2441 utilise les même ports que son prédécesseur à 26 points (modèle 2097) : Le bus SPI (SCLK, MISO, MOSI) ainsi que les ports GPIO 25 et 24. C’est ce qui m’a fait espérer une compatibilité entre les deux modèles.

L’écran s’adapte parfaitement sur le Raspberry Pi 2. Il dispose de 4 « oreilles » qui permettront de le fixer (sur une façade d’appareil par exemple). Le Raspberry Pi est fermement maintenu uniquement par le connecteur 40 points.

Cet écran tactile de 3,5 pouces (ça fait presque 9 cm de diagonale) offre une résolution de  480×320 pixels avec une profondeur de couleur de 16 bits (65536 couleurs). Le dessus de l’écran comporte une couche résistive qui le rend sensible à la pression du doigt. On peut l’utiliser comme console, fenêtre graphique, affichage d’images ou de vidéo, etc. Sa qualité est suffisante pour assurer un usage normal.

Un connecteur (à droite sur la photo ci-dessus) donne accès aux ports du GPIO si c’est nécessaire. Les informations techniques (implantation et schéma) sont disponibles en ligne.
Avec le backplane à fond (éclairage à l’arrière de l’écran) la consommation est de 100 mA environ.

Récepteur RTL-SDR.com

Par rapport aux modèles existant sur le marché, ce nouveau modèle est amélioré ce qui explique un prix de vente (un peu) supérieur aux modèles qu’on trouve sur les sites d’enchère en ligne : 19.95$ pour le récepteur seul ou 24.95$ avec 2 antennes télescopiques. La plus petite va de 6 cm à 20 cm, et la plus grande va de 20 cm à 1,5 m. L’embase de l’antenne est également plus grande avec un diamètre de 4,5 cm, à comparer aux embases miniatures livrées avec la plupart des modèles. Cela permet une meilleure stabilité lors de l’utilisation de l’antenne la plus grande.

Ces deux antennes peuvent s’accorder sur presque toute la gamme de réception de la clé. Pour un bon fonctionnement, l’antenne sera placée à l’extérieur et aussi haut que possible pour obtenir le meilleur rendement. Coller l’embase magnétique sur une surface métallique peut également aider à améliorer le fonctionnement de l’antenne en lui fournissant un plan de masse. Lorsqu’elle est entièrement rentrée, la petite antenne fonctionne à 1090 MHz pour la réception des fréquences ADS-B.

Le récepteur a reçu les améliorations suivantes :

• Oscillateur compensé en température précision 1 ppm (TCXO) – La fréquence est précise et la dérive en fonction de la température pratiquement nulle (2 ppm de décalage initial, 1 ppm de dérive en température). L’oscillateur à quartz 28,8 MHz utilisée dans la plupart des clés DVB-T est peu précis. Cela signifie que lorsque vous voulez recevoir une fréquence connue, elle sera probablement décalée de quelques kHz. Habituellement, la compensation prévue sur les clés DBV-T est de l’ordre de 30 à 150 ppm. En outre, lorsque les composants se réchauffent, la fréquence va encore dériver jusqu’à 20 ppm ou plus, jusqu’à ce que la température se stabilise. Le TCXO est un oscillateur à compensation thermique qui offre un réglage précis avec un décalage initial de 2 ppm maxi et une dérive de température de 1 ppm au fil du temps. Cela signifie qu’un signal connu apparaîtra là où il doit être sur le spectre de fréquences et ne dérivera pas en fréquence de manière significative lorsque la clé se réchauffera.
• Prise d’antenne SMA femelle – La plupart des clés DVB-T utilisent un connecteur MCX ou PAL moins répandus. Le connecteur SMA utilisé ici est beaucoup plus commun et de nombreuses antennes ou adaptateurs sont disponibles dans ce format. Il a également une longévité plus grande et a des pertes d’insertion inférieures.
• Tuner R820T2 – Plus sensible / bruit plus faible que le tuner R820T plus. 100% compatible avec les logiciels écrits pour le R820T. Cette version améliore le fonctionnement aussi bien en HF qu’aux environs de 1,5 GHz.
• Amélioration des tolérances de tous les composants – Permet au dongle RTL-SDR de travailler beaucoup mieux sur toutes les fréquences.
• Expérimental : Alimentation USB 4.5V pour préampli – Peut être activée en reliant deux pastilles du circuit par une soudure. Cela permet au RTL-SDR d’alimenter un LNA (amplificateur à faible bruit)comme le LNA4ALL et HABAMP, ou des antennes actives via le câble coaxial.
• Expérimental : Possibilité d’utiliser l’échantillonnage direct – Deux pastilles à souder donnent accès aux broches 4 et 5 du circuit intégré RTL2832U pour permettre l’échantillonnage direct. L’accès direct à l’échantillonnage est une modification matérielle qui vous permet de syntoniser des fréquences HF avec un dongle RTL-SDR.

• Boîtier en aluminium et refroidissement passif – les modèles les plus récents sont montés dans un boîtier en aluminium. Ils bénéficient d’un refroidissement passif via un pad thermique…

Premier test

Comme toujours le test de chaque étape est important. Trop souvent on voit des messages (sur les blogs ou les forums) du style : « Ouais, tuto de m… je l’ai suivi et ça marche pas ! » Sauf qu’aucune des étapes intermédiaires n’a été testée… Alors si à la fin du tutoriel il y a un souci, c’est très difficile de déterminer d’où vient le problème.

Alors ici on va procéder calmement, par étape. D’abord mettez l’écran PiTFT en place sur le Raspberry Pi 2. La clé RTL-SDR peut encore attendre un peu… laissez la de côté pour le moment. Reliez le Raspberry Pi au réseau Ethernet, Insérez la carte microSD que vous avez préparée précédemment avec Win32DiskImager. L’heure est venue du premier test. Branchez l’alimentation micro USB sur le Raspberry Pi 2. L’écran doit s’illuminer (le backlight s’allume) puis le texte habituel défile.

Ensuite l’écran PiTFT s’éteint et après une attente (qui parait bien longue), l’écran affiche le bureau de Raspbian :

La première étape est franchie… testez le fonctionnement du menu. La liste des items est plus longue que l’écran. Une petite flèche en bas du menu permet de faire défiler le menu (j’ai du appuyer avec l’ongle pour la faire fonctionner…). Si vous avez du mal vous pouvez brancher une souris, elle fonctionne.

Le Raspian  Wheezy installé est en anglais. Il va falloir le passer en français si vous voulez l’utiliser avec un clavier. Ici comme on a une utilisation dédiée, je l’ai laissé en anglais. Je me suis connecté en SSH avec Putty pour intervenir sur le système et finalement je suis passé par le bon vieux raspi-config pour passer en français

Voyons déjà quelle place il reste sur la partition créée par l’image d’Adafruit :

pi@raspberrypi ~ $ df -h
Filesystem Size Used Avail Use% Mounted on
/dev/root 3.9G 3.2G 502M 87% /
devtmpfs 459M 0 459M 0% /dev
tmpfs 463M 0 463M 0% /dev/shm
tmpfs 463M 6.4M 457M 2% /run
tmpfs 5.0M 4.0K 5.0M 1% /run/lock
tmpfs 463M 0 463M 0% /sys/fs/cgroup
/dev/mmcblk0p1 56M 29M 28M 52% /boot
tmpfs 93M 0 93M 0% /run/user/1000

500 Mo restant. Un peu juste mais pour le moment je ne touche à rien…

Blacklister les modules d’origine

Lorsqu’il détecte une clé TNT (DVB-T) Raspbian charge un module destiné à géré le matériel. Comme nous voulons gérer la clé DVB-T à notre façon, il faut empêcher le noyau de charger le(s) module(s) correspondant(s).

Ouvrez le fichier /etc/modprobe.d/raspi-blacklist.conf avec nano

 sudo nano /etc/modprobe.d/raspi-blacklist.conf

et ajoutez lui les lignes suivantes :

blacklist dvb_usb_rtl28xxu
blacklist dvb_usb_v2
blacklist rtl_2830
blacklist rtl_2832
blacklist rtl_2838
blacklist r820t

Ceci garantit que le dongle DVB-T sera bien géré par la bibliothèque qui nous intéresse.

Installer les dépendances

Avant d’installer le logiciel il va falloir installer quelques dépendances (bin oui quoi, on est sous Linux : ) ). Pour cette installation le Raspberry Pi doit impérativement pouvoir accéder à Internet.
Connectez-vous au Raspberry Pi et exécutez les commandes suivantes pour installer les dépendances :

sudo apt-get update
sudo apt-get install cmake build-essential python-pip libusb-1.0-0-dev python-numpy git

Ne vous inquiétez pas si vous obtenez des messages indiquant que la dernière version est déjà installé et continuez. (Si ce sont d’autres messages trouvez ce qui cloche !)

Maintenant il va falloir télécharger, compiler et installer la librairie RTL-DSR d’osmocom :

cd ~
git clone git://git.osmocom.org/rtl-sdr.git
cd rtl-sdr
mkdir build
cd build
cmake ../ -DINSTALL_UDEV_RULES=ON -DDETACH_KERNEL_DRIVER=ON
make
sudo make install
sudo ldconfig

Lorsque la librairie est en place, on peut installer le wraper Python qui va  permettre de faire la liaison entre la librairie et les applications en Python.

sudo pip install pyrtlsdr

Tout est (presque) en place pour l’utilisation du programme freqshow.py.

Redémarrez le Raspberry Pi pour mettre tout ça proprement en place.

Test du dongle RTL-SDR

Allez le moment que vous attendiez est enfin arrivé ! Vous pouvez connecter la clé RTL-SDR sur un port USB, et l’antenne sur la prise SMA…

Vérifions déjà que la clé USB est bien reconnue :

pi@raspberrypi ~ $ lsusb
Bus 001 Device 006: ID 0bda:2838 Realtek Semiconductor Corp. RTL2838 DVB-T
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp. SMSC9512/9514 Fast Ethernet Adapter

Oui, le Device 006 est un RTL2838 DVB-T : impeccable !

Est-ce que ça fonctionne ?

pi@raspberrypi ~ $ rtl_test
Found 1 device(s):
0:  Realtek, RTL2838UHIDIR, SN: 00000001

Using device 0: Generic RTL2832U OEM
Found Rafael Micro R820T tuner
Supported gain values (29): 0.0 0.9 1.4 2.7 3.7 7.7 8.7 12.5 14.4 15.7 16.6 19.7 20.7 22.9 25.4 28.0 29.7 32.8 33.8 36.4 37.2 38.6 40.2 42.1 43.4 43.9 44.5 48.0 49.6
[R82XX] PLL not locked!
Sampling at 2048000 S/s.

C’est rassurant la clé DVB-T est reconnue et le test fonctionne. Nous allons pouvoir installer le programme freqshow.py.

Le message PLL not locked! semble être habituel et ne pas perturber le fonctionnement des programmes … A priori cette info est affichée lorsqu’il n’y a pas d’émission sur la fréquence de réception. A vérifier.

Installation du programme analyseur de spectre / scanner

L’installation du logiciel est on ne peut plus simple, puisqu’elle consiste à télécharger le programme Pyton sur votre Raspberry Pi…

Lancez les commandes suivantes pour télécharger freqshow.py :

cd ~
git clone https://github.com/adafruit/FreqShow.git
cd FreqShow

Respectez bien la casse (les majuscules et les minuscules) !
Et… c’est tout. Le programme est prêt à être utilisé ! On y va ?

Premier essai de l’analyseur de spectre

Vérifiez que vous travaillez bien dans le répertoire ~/FreqShow et lancez le programme :

pi@raspberrypi ~/FreqShow $ sudo python freqshow.py

Vous devriez voir apparaître l’écran d’accueil de freqshow :

et quelques instants après l’analyseur de spectre :

Photo Adafruit

Cette image d’Adafruit montre le résultat sur l’écran PiTFT. En bas figurent les fréquences couvertes par l’affichage. A gauche les niveaux mini et maxi du signal. Par défaut le réglage est automatique. J’ai souvent été amené à modifier le niveau mini manuellement pour obtenir une courbe exploitable.

Utilisation de freqshow.py

La partie haute de l’écran est occupée par un menu. QUIT ferme le programme, SWITCH MODE passe l’affichage en mode waterfall (bleu = niveau mini / rouge = niveau maxi) :

Photo Adafruit

CONFIG donne accès au menu de configuration (comme on s’en serait douté )

On peut régler la fréquence centrale, celle d’échantillonnage, le gain et les niveaux maxi et mini de l’affichage du signal.

Lorsqu’on veut saisir une valeur numérique, l’écran passe dans un mode de saisie numérique :

Par exemple ici vous pouvez modifier la fréquence centrale, en saisissant la valeur sur l’écran tactile. Appuyez sur la touche CLEAR pour effacer complètement la valeur actuelle de la fréquence centrale, et saisissez la nouvelle valeur en tapant sur les chiffres. Pour supprimer le dernier chiffre saisi appuyez sur DELETE.

Une fois que vous avez entré la nouvelle valeur vous pouvez appuyer sur ACCEPT pour changer la fréquence centrale. Si finalement vous ne voulez pas changer la fréquence appuyez sur CANCEL  pour fermer la boîte de dialogue sans modifier la valeur.

Essayez de changer la fréquence centrale pour celle d’une station de radio FM de votre région. Appuyez sur BACK en bas à gauche de l’écran de configuration pour revenir à l’affichage graphique de fréquence. Vérifiez sur l’écran graphique que la fréquence centrale a été modifiée.

Depuis l’écran graphique, si vous tapez au centre de l’écran vous passez en mode Plein Écran comme ci-dessus. Tapez à nouveau vers le centre de l’écran pour revenir à l’affichage normal.

Démarrage automatique du programme

Le mieux serait qu’à la mise sous tension du Raspberry Pi, le programme freqshow.py soit lancé automatiquement. Pour un appareil dédié ça semble logique…
Comme nous sommes sous Jessie, il va falloir créer un lanceur qui va s’intégrer à systemd.

Création du script de lancement

Avec nano créez un script /home/pi/scanner.sh

Dans ce script ajoutez les lignes suivantes :

#!/bin/bash

# Ci-dessous indiquez le script ou le programme Python que vous voulez lancer
cd /home/pi/FreqShow
sudo python freqshow.py

Rendez le script exécutable

sudo chmod +x /home/pi/scanner.sh

Testez le script pour vérifier son fonctionnement :

pi@raspberrypi ~ $ ./scanner.sh
Found Rafael Micro R820T tuner
[R82XX] PLL not locked!

Si tout va bien, vous devez voir apparaitre l’analyseur de spectre sur le Raspberry Pi. (vous pouvez interrompre le programme avec CTRL C ci vous êtes à distance avec Putty).

Création du fichier service

Il faut maintenant indiquer à systemd qu’il doit lancer le service :

Créez le fichier /lib/systemd/system/scanner.service avec nano :

sudo nano /lib/systemd/system/scanner.service

Ajoutez les lignes suivantes dans le fichier :

[Unit]
Description=Analyseur de spectre
After=multi-user.target

[Service]
Type=simple
ExecStart=/home/pi/scanner.sh

[Install]
WantedBy=multi-user.target

Faites prendre en compte votre service par systemd :

pi@raspberrypi /etc/systemd/system $ sudo systemctl daemon-reload

pi@raspberrypi /etc/systemd/system $ sudo systemctl enable scanner.service
Created symlink from /etc/systemd/system/multi-user.target.wants/scanner.service to /lib/systemd/system/scanner.service.

Bon… Normalement on n’est pas loin du but

On se fait un test de démarrage ? Chiche !

sudo reboot

Et là…. Miracle de la technologie moderne, vous voyez le texte défiler sur l’écran, puis le bureau de Raspbian et enfin devant vos yeux emplis de larmes, l’analyseur de spectre se met en route !

Bon, si vous avez autant de chance que moi, la bande FM est muette autour de 90.3 MHz… Qu’à cela ne tienne, je vais changer la fréquence avec le menu Config… Euh… tiens, ça marche pas… Et Switch Mode ? pas plus que QUIT ! Damned, c’est quoi ce tuto de m…. Ils l’avaient pourtant bien dit que ça marchait juste avec le clavier 2097… Pourquoi t’a été prendre celui-là ? tsss

Trouver la panne

Ne vous en faites pas c’est comme ça très souvent… C’est ce qui apprend à être patient, à ne pas aller trop vite, à lire la doc, à faire des recherches…

Allez on commence. Pourquoi donc le clavier tactile serait-il inerte ?

Après quelques recherches d’abord en français, sans succès, puis en anglais (ça sert quand même la langue de Shakespeare) je me retrouve sur un document Adafruit (décidément !) :

Cliquez pour accéder au PDF

Et tout à la fin du document cette phrase sybilline :

Et là un doute m’étreint (comme on dit à la SNCF) et si freqshow utilisait pygame ? Vite je regarde le début du programme avec un cat freqshow | less :

import os
import time

import pygame

import controller
import model
import ui

Bingo ! Effectivement le programme utilise pygame

Donc le problème pourrait venir d’une incompatibilité d’humeur entre pygame et la librairie SDL utilisée.

Un ps pour trouver le PID de freqshow.py et me voici sur la liste des librairies utilisées :

pi@raspberrypi /proc/827 $ sudo cat maps | grep SDL
75900000-75920000 r-xp 00000000 b3:02 57546      /usr/lib/arm-linux-gnueabihf/libSDL_mixer-1.2.so.0.12.0
75920000-75927000 ---p 00020000 b3:02 57546      /usr/lib/arm-linux-gnueabihf/libSDL_mixer-1.2.so.0.12.0
75927000-75928000 r--p 0001f000 b3:02 57546      /usr/lib/arm-linux-gnueabihf/libSDL_mixer-1.2.so.0.12.0
75928000-75930000 rw-p 00020000 b3:02 57546      /usr/lib/arm-linux-gnueabihf/libSDL_mixer-1.2.so.0.12.0
75a61000-75a66000 r-xp 00000000 b3:02 57554      /usr/lib/arm-linux-gnueabihf/libSDL_ttf-2.0.so.0.10.1
75a66000-75a6d000 ---p 00005000 b3:02 57554      /usr/lib/arm-linux-gnueabihf/libSDL_ttf-2.0.so.0.10.1
75a6d000-75a6e000 rw-p 00004000 b3:02 57554      /usr/lib/arm-linux-gnueabihf/libSDL_ttf-2.0.so.0.10.1
75d2e000-75d39000 r-xp 00000000 b3:02 57532      /usr/lib/arm-linux-gnueabihf/libSDL_image-1.2.so.0.8.4
75d39000-75d40000 ---p 0000b000 b3:02 57532      /usr/lib/arm-linux-gnueabihf/libSDL_image-1.2.so.0.8.4
75d40000-75d41000 r--p 0000a000 b3:02 57532      /usr/lib/arm-linux-gnueabihf/libSDL_image-1.2.so.0.8.4
75d41000-75d42000 rw-p 0000b000 b3:02 57532      /usr/lib/arm-linux-gnueabihf/libSDL_image-1.2.so.0.8.4
76961000-769bd000 r-xp 00000000 b3:02 57514      /usr/lib/arm-linux-gnueabihf/libSDL-1.2.so.0.11.4
769bd000-769cd000 ---p 0005c000 b3:02 57514      /usr/lib/arm-linux-gnueabihf/libSDL-1.2.so.0.11.4
769cd000-769ce000 r--p 0005c000 b3:02 57514      /usr/lib/arm-linux-gnueabihf/libSDL-1.2.so.0.11.4
769ce000-769cf000 rw-p 0005d000 b3:02 57514      /usr/lib/arm-linux-gnueabihf/libSDL-1.2.so.0.11.4

Il y a bien du SDL là dedans. La solution est proposée dans le document d’Adafruit (merci Lady ADA) : Il faut réinstaller l’ancienne version de SDL, la 1.2. Comme elle se trouve sur le dépôt Wheezy il faut rajouter celui-ci à la sources.list. C’est ce que fait très bien le script inclus dans le pdf

Créez un fichier installsdl.sh dans /home/pi

Ajoutez y les lignes suivantes :

#!/bin/bash



#enable wheezy package sources
echo "deb http://archive.raspbian.org/raspbian wheezy main
" > /etc/apt/sources.list.d/wheezy.list



#set stable as default package source (currently jessie)
echo "APT::Default-release \"stable\";
" > /etc/apt/apt.conf.d/10defaultRelease



#set the priority for libsdl from wheezy higher then the jessie package
echo "Package: libsdl1.2debian
Pin: release n=jessie
Pin-Priority: -10
Package: libsdl1.2debian
Pin: release n=wheezy
Pin-Priority: 900
" > /etc/apt/preferences.d/libsdl



#install
apt-get update
apt-get -y --force-yes install libsdl1.2debian/wheezy

Rendez le script exécutable :

sudo chmod +x installsdl.sh

puis exécutez le :

sudo ./installsdl.sh

Après exécution du script votre écran devient sensible à la pression de vos doigts ! C’est pas beau ?

Changer la fréquence d’origine

Le démarrage de l’analyseur logique ne me convient pas trop. La fréquence de 90.3 MHz sur laquelle l’affichage est centré n’est pas occupée par un émetteur FM.

Pour montrer le fonctionnement du RTL-DSR, j’ai choisi de régler la fréquence centrale sur… RTL soit 105.5 MHz Mais il doit y avoir moyen de modifier ça dans le programme pour que l’analyseur se cale sur RTL à chaque démarrage, non ?

Quelques cat plus loin je trouve :

pi@raspberrypi ~/FreqShow $ cat model.py |less
self.sdr = RtlSdr()
self.set_center_freq(90.3)
self.set_sample_rate(2.4)
self.set_gain('AUTO')

C’est donc là que ça se tient ! Modifiez la fréquence de départ en fonction de ce que vous voulez avoir au démarrage. Après avoir modifié comme suit :

self.set_center_freq(105.5)

Le programme se lance avec la fréquence centrale choisie. Il y a certainement moyen de modifier d’autres informations au lancement (le gain, les mini et maxi…) mais bon, vous allez peut-être chercher un peu, non ?

Et la consommation ?

Si vous envisagez de réaliser un appareil autonome, il est important d’avoir une idée de la consommation pour dimensionner la batterie qui va alimenter l’ensemble RasPi + écran + clé TNT…

Avec l’analyseur en fonctionnement on est au dessus de 700 ma ! Quand même… Il faudra peut-être prévoir de jongler avec l’éclairage de l’écran (PWM prot GPIO 18) pour abaisser la consommation.

Consommation indiqué par l’analyseur USB

La vidéo

Conclusion

Pour une centaine d’euros vous avez à portée de main un analyseur de spectre. Sans être un vrai appareil de mesure, il pourra donner de précieuses indications à tous ceux qui gravitent autour des radiocommunications.

Le programme ne décode pas les signaux et ne sort donc pas le signal démodulé sur la prise HP du Raspberry Pi. Ce sera peut-être une évolution de cette application.

Le même matériel peut être utilisé avec gnu-radio. GNU Radio est une boîte à outils logicielle open-source qui fournit des blocs de traitement des signaux pour mettre en œuvre des radios logicielles (SDR). Il est largement utilisé dans les environnements amateur, universitaires et commerciaux pour mener à la fois des recherches sur les communications sans fil et sur les systèmes de radio réels. J’espère avoir l’occasion de vous le présenter dans un futur article.

Sources

• https://learn.adafruit.com/adafruit-pitft-3-dot-5-touch-screen-for-raspberry-pi
• https://learn.adafruit.com/adafruit-pitft-3-dot-5-touch-screen-for-raspberry-pi/easy-install
• https://learn.adafruit.com/freq-show-raspberry-pi-rtl-sdr-scanner/overview
• https://learn.adafruit.com/downloads/pdf/freq-show-raspberry-pi-rtl-sdr-scanner.pdf
• https://learn.adafruit.com/downloads/pdf/adafruit-pitft-3-dot-5-touch-screen-for-raspberry-pi.pdf
• http://www.rtl-sdr.com/new-products-rtl-sdr-with-1ppm-tcxo-sma-f-connector-r820t2-bias-tee-improved-tolerances-direct-sampling-break-out-pads-now-available-in-our-store/
• http://www.rtl-sdr.com/buy-rtl-sdr-dvb-t-dongles/
• https://www.adafruit.com/products/2097
• https://www.adafruit.com/products/2441
• https://gist.github.com/tstellanova/7323116
• https://www.libsdl.org/download-1.2.php

How To Autorun A Python Script On Boot Using systemd

APRS Rx-only IGate with Raspberry Pi and DVB-T dongle