Quantcast
Are you the publisher? Claim or contact us about this channel


Embed this content in your HTML

Search

Report adult content:

click to rate:

Account: (login)

More Channels


Showcase


Channel Catalog



Channel Description:

La référence du Raspberry Pi en France - Par l'auteur du livre "Raspberry Pi 3 et Pi Zero" paru aux Edts. ENI

(Page 1) | 2 | 3 | 4 | newer

    0 0

    cadre_photo_250pxOn trouve aujourd’hui sur le marché des cadres photo qui n’ont plus besoin d’une carte SD ou d’une clé USB de stockage. Ils récupèrent directement les images dans un dossier partagé de votre PC ou de votre serveur NAS
    Comptez une centaine d’euros pour acheter ce genre de produit. Et si on se servait du Raspberry Pi pour réaliser notre propre cadre ? C’est le choix qu’a fait Franck et il nous propose sa solution dans cet article.

    panneau_danger_80pxAttention, au cours de ce tutoriel, vous allez modifier des fichiers de configuration. Avant toute modification je vous recommande de sauvegarder les fichiers en question pour pouvoir revenir en arrière en cas de problème…
    (sudo   cp   fichier_d_origine   fichier_de_sauvegarde)

    Prérequis : Savoir installer NOOBS et/ou Raspbian, savoir modifier un fichier avec nano, savoir lire une documentation, un fichier man 😉

    Ce tutoriel a été réalisé sur un Raspberry Pi 2, tournant sous la dernière version de Raspbian. Il devrait fonctionner également sur un B+ ou un B…

    Un cadre photo avec le Raspberry Pi

    Le cahier des charges

    • Les photos sont stockées dans un dossier sur un PC ou un serveur NAS.
    • Les images sont des jpg, png ou autre format standard utilisé habituellement.
    • Lorsque le Raspberry Pi démarre en mode graphique, l’application doit se lancer automatiquement.

    Préparation du dossier sur le PC

    Pour tester la solution de Franck, j’ai choisi de créer un dossier c:\photos à la racine de mon PC.

    Je l’ai partagé sous le nom de partage photos avec tout le monde en lecture seule.

    Si cela ne vous parle pas, reportez vous à l’article sur le partage de dossier entre un PC sous Windows et un Raspberry Pi… L’objectif du blog et de ce genre d’article n’est pas de vous proposer des solutions clés en mains mais de vous aider à progresser dans le monde de l’informatique. La seule façon de progresser est de faire des erreurs mais surtout ensuite de chercher où on a fait une erreur.

    Comme disait Lao Tseu : Si tu donnes un poisson à un homme, il mangera un jour. Si tu lui apprends à pêcher, il mangera toujours.

    Pensez à mettre quelques photos dans le dossier… Ça pourra servir 😉

    Installation sur le Raspberry Pi

    L’écran

    Vous pouvez choisir de transformer votre télé en cadre photo géant ! Il suffit de connecter votre Raspberry Pi via la sortie HDMI sur la télé.

    Mais si de temps en temps vous souhaitez utiliser votre télé pour voir des films, vous pouvez opter pour l’achat d’un petit écran à connecter sur la sortie vidéo analogique (écran de recul pour voiture). On en trouve à partir d’une vingtaine d’euros… Après tout dépend de la taille et de la qualité que vous souhaitez obtenir… Dans ce cas, ne connectez pas la prise HDMI sur le Raspberry Pi, la sortie vidéo sera automatiquement renvoyée sur le port analogique (la prise jack à 4 points).

    La configuration du système

    Démarrage en mode graphique

    Commencez par installer un système propre (NOOBS ou Raspbian directement). Quand le système a démarré, raspi-config se lance. Activez le démarrage automatique en mode graphique. (Choix 3)

    cadre_photo_raspi-configpuis

    cadre_photo_raspi-config2Choisissez Desktop Log in as user ‘pi’ at the graphical desktop.

    Avec la touche TAB déplacez vous sur <Ok> puis validez. Vous revenez au menu de base de raspi-config. Sortez de raspi-config sans redémarrer. On fera ça après, il y a encore du boulot en mode texte 😉

    Mise à jour du système

    Commencez par mettre votre système à jour

    sudo apt-get update
    sudo apt-get upgrade

    Installation du client Samba

    Le partage de dossier en Windows utilise le protocole SMB. Sous Linux c’est Samba qui est utilisé pour gérer le partage de dossier avec ce protocole. Il faut installer smbclient pour pouvoir accéder au partage sur la machine Windows.

    sudo apt-get install smbclient

    Selon votre distribution, il est possible que smbclient soit déjà installé. Si ce n’est pas le cas, autorisez l’installation.

    Création d’un point de montage sur le Raspberry Pi

    Pour « raccrocher » le dossier de la machine Windows au Raspberry Pi, nous allons créer un point de montage. Ce sera le dossier /home/pi/pics qui jouera ce rôle.

    mkdir /home/pi/pics

    Désactivation des écrans de veille et des fonctions d’économie d’énergie

    Ouvrez le fichier /etc/kbd/config

    sudo nano /etc/kbd/config

    Trouvez et modifiez les lignes suivantes :

    • blank_time=0
    • powerdown_time=0

    Enregistrez ensuite le fichier modifié.

    Ouvrez maintenant le fichier /etc/lightdm/lightdm.conf

    sudo nano /etc/lightdm/lightdm.conf

    Recherchez le bloc [Seat Default].

    Ajouter la ligne suivante :

    • xserver-command=X  -s  0  dpms

    Enregistrez ensuite le fichier modifié.

    Installation de QIV

    QIV (Quick Image Viewer) est un logiciel destiné à visionner des images. Il a été développé avec gdk/imlib, ce qui le rend plus rapide que bien d’autres visionneurs classiques.

    sudo apt-get install qiv

    Création d’un script de démarrage automatique

    Lors du démarrage du bureau, LXDE lance automatiquement les scripts qui se trouvent dans le dossier /home/pi/.config/autostart

    Nous allons créer ce dossier sur notre Raspberry Pi puis créer le script qui sera lancé au démarrage du bureau :

    mkdir /home/pi/.config/autostart
    cd autostart
    sudo nano slideshow.desktop

    Une fois que nano est ouvert, insérez les lignes suivantes dans le fichier.

    [Desktop Entry]
    Type=Application
    Exec=lxterminal -e /home/pi/slideshow.sh

    Création du script de lancement de qiv

    Le script chargé de démarrer l’application est créé dans le dossier /home/pi

    cd /home/pi
    sudo nano slideshow.sh

    Une fois que nano est ouvert, insérez les lignes suivantes dans le fichier.

    #!/bin/bash
    #slideshow script
    sleep 1
    echo Démarrage du Cadre Photo
    export DISPLAY=:0.0
    qiv -f -R -S -n -s -r -d 5 -l -u -t -i -m  /home/pi/pics/*

    Diable ! Que d’options ! Allez je suis gentil, je vous en explique une : -d 5 met un délai de 5 secondes entre chaque diapo… Et les autres ? Facile : man qiv dans un terminal ou cliquez sur le lien en bas de page dans la rubrique Sources… Eh, vous allez quand même bosser un peu, non ? 😉

    Connecter le Raspberry au partage Windows

     Avant d’automatiser le montage du dossier partagé dans fstab, je vous conseille de tester manuellement le montage avec mount. En cas de souci, vous obtiendrez des informations utiles via les messages d’erreur…

    Pour info, le PC que j’utilise pour le partage est à l’adresse IP 192.168.1.105 et l’utilisateur sur le PC se nomme admin, son mot de passe est … password !

    Montage manuel du partage Windows

    sudo mount -t cifs -o username=admin //192.168.1.105/photos /home/pi/pics
    Password:
    cd pics
    ls
    image_01.jpg image_02.jpg image_03.png

    Tout s’est bien passé. Le nom d’utilisateur sur le PC est renseigné dans la ligne de commande, le mot de passe est ensuite saisi. Le montage s’est fait sans encombre et je retrouve les photos initialement déposées dans le dossier partagé sur le PC, dans mon dossier /home/pi/pics.

    Ceci étant vérifié, il est temps d’automatiser le montage du partage… Pensez à la sauvegarde de fstab 😉 )

    Si le montage ne se fait pas manuellement, inutile de passer à l’étape suivante. Soyez heureux, vous avez certainement fait une connerie erreur que vous allez devoir trouver… et vous allez apprendre plein de choses ! Veinard(e) !

    Montage automatique du partage Windows

    Allez, vous arrivez au bout de vos peines, il reste à automatiser le montage du dossier partagé sur le PC dans /home/pi/pics, le point de montage que nous lui avons réservé.

    Ouvrez /etc/fstab avec nano  (débrouillez vous tout(e) seul cette fois 😉 ) et ajoutez lui la ligne suivante :

    //192.168.1.105/photos  /home/pi/pics cifs defaults,ro,username=admin,password=password 0 0

    Redémarrage du Raspberry Pi

    Tous les éléments sont maintenant en place pour notre cadre photo. Je résume ?

    • Nous avons créé un dossier à la racine du PC
    • Nous avons mis quelques photos dedans
    • Nous avons partagé ce dossier en lecture seule

    Sur le Raspberry Pi

    • Nous avons configuré le démarrage en mode graphique
    • Nous avons désactivé les écrans de veille
    • Nous avons installé smbclient
    • Nous avons installé QIV
    • Nous avons créé un fichier qui s’exécute automatiquement au démarrage de bureau
    • Nous avons créé un script qui lance le visionneur de photos
    • Nous avons monté manuellement le partage Windows sur le système de fichiers du Raspberry Pi
    • Nous avons modifié fstab pour que le montage devienne automatique

    Bon, bin, vous ne serez pas venu pour rien sur framboise314 aujourd’hui…

    Il nous reste à vérifier si tout ça fonctionne (roulements de tambour) :

    Redémarrez votre Raspberry Pi

    sudo reboot

    Regardez bien l’écran, vous devez avoir le gros carré coloré, la (les) framboise(s) avec du texte qui défile, le bureau démarre (quel bonheur de retrouver le curseur de la souris, hein?) un terminal s’ouvre… le message de démarrage du script s’affiche et… voici la première image qui apparait, bientôt suivie de toutes les autres. On en pleurerait… 😉

    Si l’image ne remplit pas l’écran, relancez raspi-config (sudo raspi-config) et modifiez le paramètre overscan…

    Si tout ne se passe pas comme prévu, inutile d’insulter framboise314… Essayez plutôt de comprendre ce qui ne fonctionne pas, ce sera beaucoup plus constructif et enrichissant !

    Mais bon, si vous galérez trop, vous avez le droit de mettre un commentaire ci-dessous… Attention quand même, le modérateur de framboise314 est magnanime mais les insultes ne passent pas 😉

    Conclusion

    Merci à Franck de partager son utilisation du Raspberry Pi en Cadre Photo. Tous ceux qui ont besoin d’afficher des images de façon automatique apprécieront.

    Bien entendu vous êtes libres de modifier ce tutoriel à votre guise pour l’adapter à votre propre usage (c’est même d’ailleurs fortement recommandé 😉 ).

    Si comme Franck vous avez mis au point une utilisation un peu particulière du RasPi, les pages de framboise314 vous sont ouvertes et vous pourrez en faire profiter la communauté.

    Sources


    0 0

    20150408_2150_250px Lors du crash de l’Airbus A320 de Germanwings (24 mars 2015), de nombreuses personnes ont découvert l’existence de FlightRadar24.
    FlightRadar24 regroupe les données ADS-B (Automatic Dependent Surveillance-Broadcast) fournies par plusieurs milliers de récepteurs répartis à la surface du globe. Ces récepteurs sont mis en œuvre par des personnes qui participent ainsi au fonctionnement de ce système international. D’ailleurs FlightRadar24 fournit des systèmes de réception à ceux qui en font la demande et qui sont éligibles du fait de leur position géographique dans une zone encore mal couverte.

    Un Raspberry Pi pour suivre les avions sur FlightRadar24

    Comment ça marche, l’ADS-B ?

    adsb_flightradar

    Principe de l’ADS-B – Source FlightRadar24 ©

    La technologie que FlightRadar24 utilise pour recevoir des informations de vol est appelée ADS-B. Cette technologie est illustrée sur l’image ci-dessus.

    • L’avion récupère sa localisation à partir d’un récepteur GPS
    • Le transpondeur ADS-B installé sur l’avion transmet un signal à 1090 MHz contenant cette information de position ainsi que d’autres données (N° du vol et indicatif, altitude, vitesse, vitesse ascensionnelle…)
    • Le signal du transpondeur ADS-B est capté par un récepteur au sol, connecté aux serveurs de FlightRadar24
    • Le récepteur envoie les données reçues à Flightradar24
    • Les données s’affichent sur www.flightradar24.com et les applications FlightRadar24
    transpondeur

    Transpondeur ADS-B

    ADS-B est une technologie relativement nouvelle et toujours en cours de développement ce qui signifie qu’actuellement elle est rarement utilisé pour le contrôle de la circulation aérienne. FlightRadar24 estime que près de 65% des avions commerciaux transportant des passagers (75% en Europe, 35% aux États-Unis) sont équipés d’un transpondeur ADS-B. Pour l’aviation en  général ce nombre est probablement inférieur à 20%. Mais ce pourcentage est en constante augmentation et l’ADS-B deviendra obligatoire mondialement pour la plupart des avions en 2020. Lorsqu’il sera obligatoire, l’ADS-B remplacera les radars primaires comme méthode de surveillance aérienne utilisé par l’ATC.

    AXP340angle

    Transpondeur ADS-B

    FlightRadar24 (basée à Stockholm) dispose d’un réseau de plus de 6000 récepteurs ADS-B répartis dans le monde qui reçoivent les informations de vol des avions équipés de transpondeur ADS-B et renvoie ces informations à ses serveurs. En raison de la haute fréquence utilisée (1 090 MHz) la couverture de chaque récepteur est limitée à environ 250 à 400 km autour de l’antenne en fonction de l’endroit où elle est implantée. Plus un avion vole loin du récepteur plus il doit voler haut pour être dans la zone couverte par le récepteur. La portée maximale fait qu’il est très difficile d’obtenir une couverture ADS-B au-dessus des océans.

    Environ 99% de l’Europe est couverte de récepteurs ADS-B. Il ya aussi une bonne couverture ADS-B aux Etats-Unis, Canada, Mexique, Caraïbes, Brésil, Russie, Moyen-Orient, Inde, Japon, Thaïlande, Malaisie, Indonésie, Australie et Nouvelle-Zélande. Dans les autres parties du monde, la couverture ADS-B est très variable.

    Les transpondeurs et antennes sur avion

    Il existe de nombreux modèles de transpondeurs pour avion, comme ceux qui figurent plus haut dans l’article.

    adsb_transponder01Celui-ci est en deux partie, avec un élément de commande qui peut se monter sur le tableau de bord, et un bloc électronique déporté.

    adsb_transponder02Cet ensemble (qui intègre un transpondeur présenté plus haut) est équipé d’un afficheur qui permet au pilote de voir les appareils équipés d’un ADS-B sur une carte. Ceci améliore la sécurité des vols.

    adsb_antenna2Les antennes peuvent également revêtir des apparences différentes, mais le plus souvent c’est ce type d’antenne qui est utilisé.

    adsb_antenna3

    Les récepteurs

    FR24

    Côté réception beaucoup de possibilités existent. en dehors des matériels professionnels ci-dessus.

    free-ads-b-equipment-66_400FlightRadar24 offre ce modèle pour équiper les stations situées dans des zones qui sont intéressantes pour le service (zones mal ou peu couvertes).

    Caractéristiques

    • Processeur embarqué – opérationnel sans ordinateur
    • Formats reçus : 1090 MHz Mode S, ADS-B et Mode-AC
    • Plage de réception : plus de 225 Km (en fonction de la qualité de l’antenne et de son emplacement)
    • Vitesse de traitement : plus de 1600 trames Mode-S par seconde (dans les zones à fort trafic)
    •  Horodatage en mode 12Mhz ou haute résolution en mode GPS
    • IP automatiquement attribué par DHCP
    • Fonctionne derrière un NAT
    • Consommation d’énergie : moins de 5W
    • Consommation bande passante : 200 à 800 Mo / mois en fonction de la couverture
    free-ads-b-equipment-67_400

    L’antenne fournie par FlightRadar24

    Contenu du kit de réception fourni par FlightRadar24

    • Le récepteur FR24 ADS-B
    • L’antenne GPS avec 5 m de câble
    • Une alimentation continue (entrée 110V-230V ~)
    • 5 m de câble Ethernet
    • Une antenne mode S de 38 cm de long avec système de montage (0 dBd de gain, 55 cm de long, étanche)
    • Un câble coaxial de 5 ou 10 mètres de long pour antenne mode-S, avec connecteur. Câble de type H155 de 6 mm de diamètre à faible perte. Câble équipé avec connecteur SMA mâle et connecteur de type N

    Le stick FlightRadar24

    dvbt-stick-adsb-receiver-48_380 53200_mSur la boutique la boutique jetvision vous trouverez les solutions de récepteur DVB-T (Digital Video Broadcast – Terrestrial) préconisées par FlightRadar24. Il existe une version avec la petite antenne représentée ci-dessus (23€) mais vous pouvez choisir une antenne extérieure de meilleure qualité (78€).

    La solution d’Erik

    Sur blogwifi.fr, Erick d’Infracom a publié un article sur la réception de l’ADS-B avec un récepteur USB DVB-T et un Raspberry Pi. La framboise est utilisée pour décoder les signaux, les afficher et envoyer les trames à FlightRadar24. Il a aussi réalisé une antenne colinéaire pour améliorer la réception

    Le projet

    Une grande partie des avions est équipée d’un transpondeur, chargé de diffuser des informations destinées à assurer la sécurité aérienne, mais accessibles à ceux qui souhaitent les écouter. On y retrouve l’altitude, la vitesse, le cap, etc. L’avion va donc se faire « voir » des autres avions et du contrôle au sol, mais également de la station au sol réalisée par Erik pour recevoir les données, via un RaspberryPi, pour ensuite les diffuser sur le site FlightRadar24.

    L’idée est de contribuer au site, en apportant une nouvelle zone de couverture sur la région de St Nazaire, région peu couverte lorsque les avions sont à basse altitude, comme le montre le suivi de la navette Airbus St Nazaire / Toulouse un matin :

    flightradar-LFRZOn ne voit rien du décollage de St-Nazaire, la trace ne débute que lorsque l’avion dépasse les 5000 pieds (1,5 Km) environ, et encore. Depuis Crossac, il devrait être possible de pouvoir améliorer cette couverture qui semble un peu faible, et ainsi suivre les Beluga qui se posent à St-Nazaire, suivre les avions en exercice, les avions de tourisme qui découvrent la côte et les marais de Brière, etc.

    Comme tout ce qui tourne autour de la radio, tout commence par l’antenne ! Il y a un proverbe radioamateur qui dit « Ce que vaut l’antenne, vaut la station »… Et qui dit bonne antenne, dit antenne maison 😉 : une colinéaire, taillée pour fonctionner sur 1090 MHz, la fréquence de l’ADS-B !

    L’antenne

    colineaire-1090-500x1024

    Antenne colinéaire d’Erik en cours de construction

    Je vous entends déjà : oulaaa, compliqué, impossible, marchera jamais !! Allez, courage, un peu de câble 75 Ohm pour satellite, et prenez bien un câble avec une âme pleine (avec une âme PLEINE, pas multi-brins), et un p’tit tuto sur Youtube :

    Pas compliqué non ? Ce que le tuto oublie de dire : ajoutez deux brins à la fois, il faut, au final, avoir un nombre PAIR de brins, très important…

    coli2Venons maintenant rajouter un connecteur en bricolant un peu :

    colineaire-1090-adbsPar rapport à la vidéo, Erik a utilisé de la gaine thermo-rétractable pour solidifier, pas du scotch. Le câble qui va de l’antenne au récepteur USB DVB-T est lui en H155, faibles pertes, utilisable jusqu’à 5 GHz environ, donc parfaitement adapté pour une simple réception. Erik a ensuite réalisé un petit pigtail (petit bout de câble servant d’adaptateur) MCX / N femelle pour venir sur le module USB, avec du RG316. C’est par contre un petit peu moins accessible au bricoleur lambda, sauf si vous disposez des outils pour réaliser le sertissage.

    Avec un petit peu plus de matériel, l’antenne a pris forme, elle a surtout bénéficié d’un habillage de protection, de façon à résister à un usage extérieur :

    flightradar-colineaire-1090-MHzLa voici par exemple avant sa finalisation, ouverte. Les matériaux sont simples : un tube PVC diam. 30 coupé à la bonne dimension, des embouts pour le fermer et un vague coup de bombe de peinture blanche pour ne pas effrayer des voisins un peu bizarres :-)

    Un peu de colle PVC et hop, voici une antenne prête à être installée au bout d’un mât :

    flightradar-colineaire-1090-MHz2

    Un câble H155 de 4 m vient s’y raccorder, en connectique N mâle. Sur la clé de réception, Erik a assemblé un adaptateur MCX / N femelle tout simple, en attendant de recevoir un adaptateur coaxial pour réduire encore un brin les pertes en ligne.

    Une fois montée, l’antenne a fière allure :

    flightradar-colineaire-1090-MHz3Direction l’iMac et surprise… surprise quant à la couverture désormais atteinte, je vous laisse juger par vous même le résultat d’une capture effectuée un matin :

    flightradar-coverage

    Oui c’est dingue, les avions sont reçus pratiquement jusqu’à Paris ! Certes, ils sont en niveau de vol, pas à 200 m du sol, mais quand même, c’est dingue, considérant que l’antenne n’est qu’à 4 m du sol, et encore, avec des obstacles proches.

    Rapide mesure en voyant un appareil au Havre et calcul de la distance qui le sépare du récepteur :

    flightradar24-coverage-distance

    285 km, soit environ 154 Nm, plutôt pas mal non? Encourageant en tout cas pour aller fixer l’antenne tout en haut, sur le toit. Reste désormais à trouver LA bonne solution pour un montage extérieur durable :

    • antenne et raspberry sur le toit, avec une alimentation PoE
    • antenne seule sur le toit, avec un minimum de câble très faibles pertes (Aircom)

    Pour obtenir une solution cohérente et sans trop de pertes radio, on peut envisager de placer le Raspberry dans un boîtier étanche, le munir d’un POE (vous trouverez un exemple de timelapse qui fonctionne sans interruption depuis 2014 sur https://blogwifi.fr/?p=12741), et limiter les liaisons coaxiales vers l’antenne au strict minimum, par exemple en fixant une embase N Femelle sur le boîtier étanche. Le Raspberry Pi et le récepteur DVB-T sont placés le plus près possible de l’antenne et un simple câble Ethernet blindé suffira à venir alimenter le tout et récupérer le réseau.

    D’autres antennes ?

    La solution d’Erik est excellente pour la réception, mais pour démarrer et faire vos essais vous pouvez commencer par des antennes simples :

    Nota : Quelle que soit l’antenne utilisée, elle devra respecter la polarisation verticale du signal pour une réception optimale. L’antenne sera donc disposée verticalement.

    La plus simple !

    CAhqVmiQ45Y_dip1090Une antenne réduite à sa plus simple expression : dénudez le câble coaxial pour satellite (75Ω) torsadez la tresse, donnez la forme d’un dipôle (voir photo) et coupez (de façon symétrique) pour que la longueur totale soit de 13,7 cm… à peu près.

    Si vous trouvez plus simple, dites moi…

    Avec un bouchon…

    1090_antenna_11090_antenna_21090_antenna_3En trois images c’est clair, pas besoin de beaucoup d’explications… Et ici, en Bourgogne, des bouchons ça va, on en récupère pas mal 😉

    Un peu plus compliqué…

    adsb-antennaCette antenne est un peu plus complexe mais offre une bonne adaptation…
    Longueur totale du fil : 150 + 69 +8 + 69 + 150 = 446 mm

    Antenne active 1090 MHz de F5ANN

    adsb-f5ann Pour améliorer les performances de l’antenne 1090 MHz, la solution la plus simple est d’ajouter un préamplificateur juste derrière l’antenne. Cependant compte tenu de la technologie de l’antenne sur circuit imprimé, il est possible de transformer cette antenne en antenne active en ajoutant sur le même circuit imprimé un amplificateur faible bruit avec un gain de 20 à 30 dB, et pour s’affranchir des problèmes d’interférences avec les fréquences GSM, d’intégrer un filtre 1090 MHz de type SAW avec une bande passante de 30 MHz, ou moins. On arrive ainsi à avoir une antenne de faible dimensions – 160 mm de longueur – avec un gain important et permettant d’avoir un facteur de bruit de la chaine réception très faible – inférieur à 1 dB-(d’après F5ANN un site incontournable pour l’ADS-B)Si vous aimez bricoler les antennes cherchez donc avec les mots clés suivants : ads-b antenna diy

    Un préampli à faible bruit (LNA)

    Si vous avez une expérience de la soudure, si vous tremblez en même temps que le circuit que vous soudez, si le mot CMS (Composant Monté en Surface) ne vous effraye pas… 😉 vous trouverez chez jetvision un kit de préampli pour une cinquantaine d’euros…

    preampli_ADS-BUne fois monté le préampli est inséré dans son boîtier qui assure la protection contre les interférences :

    mini-adsb-boxLe préampli est placé au plus près de l’antenne (ici une ground-plane montée directement sur une prise N) :

    ads-b-quart-ant

     

    Le récepteur

    Le récepteur doit être basé sur le chipset Realtek RTL2832U. Les numéros de type sont E4000 et R820T. Ils peuvent facilement être trouvés sur eBay ou Amazon. Ils sont généralement livrés avec une antenne intérieure simple, qui donne de très bons résultats. Je peux recevoir des avions qui sont à plus de 140 km du côté où j’ai une vue dégagée sur le ciel. Pour des résultats encore meilleurs vous pouvez construire votre propre dipôle.

    La conclusion d’Erik

    « Le Pi tourne sans discontinuer, c’est vraiment stable. Il va falloir que je pense à installer l’antenne un peu mieux que sur un trépied pour améliorer la couverture vers Nantes et la Vendée, trop faible pour le moment.« 

     Pygmalion vous explique comment configurer le Raspberry Pi

    Le récepteur fonctionne sur un Raspberry Pi. Dans son article Erik indique qu’il a configuré le RasPi en suivant le tutoriel de Pygmalion. Celui-ci étant en anglais, je vous en propose la traduction.

    Et le Raspberry Pi là dedans ?

    Bin oui, jusque là c’était un peu l’arlésienne… Mais le voici : Erik a utilisé un tutoriel de Pygmalion dont je vous propose ici la traduction.

    Introduction

    Un dongle USB DVB-T peut être utilisé pour recevoir les signaux ADS-B, qui peuvent être décodés avec le logiciel approprié.

    Installez les outils de construction du logiciel et la librairie requise

    Si vous n’avez pas installé les outils de construction utilisez la commande suivante. Vous devez également libusb-1.0-0-dev.

    sudo apt-get -fym install git cmake build-essential libusb-1.0-0-dev

     

    Installation de rtl-sdr

    Le pack logiciel contient la bibliothèque chargée de communiquer avec le dongle DVB-T (Digital Video Braodcasting-Terrestrial) et un certain nombre d’outils pour l’utiliser comme SDR (Sofware Defined Radio).

    mkdir git
    cd git
    git clone git://git.osmocom.org/rtl-sdr.git
    cd rtl-sdr
    mkdir build
    cd build
    cmake .. -DINSTALL_UDEV_RULES=ON
    sudo make install
    sudo ldconfig
    sudo cp ../rtl-sdr.rules /etc/udev/rules.d/

    Comme nous ne voulons pas regarder la télévision le pilote DVB-T par défaut doit être supprimé dans la liste noire. Créez le fichier suivant:

    /etc/modprobe.d/rtlsdr.conf

    Ajoutez lui la ligne suivante :

    blacklist dvb_usb_rtl28xxu

    Vérifiez si le module est chargé :

    lsmod | grep dvb_usb_rtl28xxu

    S’il est chargé, supprimez le en exécutant cette commande :

    sudo modprobe -r dvb_usb_rtl28xxu

    Installer et exécuter Dump1090

    Ce logiciel est utilisé pour recevoir et décoder le signa ADS-B. Il permet également de représenter les données que vous aurez collectées sur une page web.

    cd ~/git
    git clone git://github.com/MalcolmRobb/dump1090.git
    cd dump1090
    make
    ./dump1090 --quiet --net --enable-agc &

    Maintenant ouvrez une page web à l’adresse de votre Raspberry Pi sur le port 8080 et vous devriez voir une carte avec les données de tous les avions à portée. Vous pourriez avoir envie de présenter ceci dans votre propre page web :

    <!DOCTYPE html>
    <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <title>Flight Radar Kranenburg-N&uuml;tterden</title>
    <meta name="description" content="Flight Radar (ADS-B Receiver) Kranenburg-N&uuml;tterden">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="stylesheet" href="css/main.css">
    </head>
    
    <body>
    <h4>Flight Radar (ADS-B Receiver) Kranenburg-N&uuml;tterden</h4>
    <iframe src="http://nitri.ddns.net:8080" name="flight-radar" width="95%" height="90%" align="center"
    scrolling="no" marginheight="0" marginwidth="0" frameborder="0"></iframe>
    </body>
    </html>

    Personnaliser Dump1090

    Le script config.js se trouve dans le répertoire public_html de Dump1090. Recherchez cette section dans script.js si vous voulez modifier la carte.

    // Define the Google Map
    var mapOptions = {
    center: new google.maps.LatLng(CenterLat, CenterLon),
    zoom: ZoomLvl,
    mapTypeId: google.maps.MapTypeId.TERRAIN,
    mapTypeControl: true,
    streetViewControl: false,
    mapTypeControlOptions: {
    mapTypeIds: mapTypeIds,
    position: google.maps.ControlPosition.TOP_LEFT,
    style: google.maps.MapTypeControlStyle.DROPDOWN_MENU
    }

    A mon avis la carte normale donne de bons résultats mais si vous voulez utiliser la carte OpenStreetMap :

    mapTypeId: "OSM"

    Personnalisez l’apparence de la couche données dans config.js. L’exemple ci-dessous devrait vous aider :

    // --------------------------------------------------------
    //
    // This file is to configure the configurable settings.
    // Load this file before script.js file at gmap.html.
    //
    // --------------------------------------------------------
    
    // -- Output Settings -------------------------------------
    // Show metric values
    Metric = true; // true or false
    
    // -- Map settings ----------------------------------------
    // The Latitude and Longitude in decimal format
    CONST_CENTERLAT = 51.785982;
    CONST_CENTERLON = 6.059338;
    // The google maps zoom level, 0 - 16, lower is further out
    CONST_ZOOMLVL = 10;
    
    // -- Marker settings -------------------------------------
    // The default marker color
    MarkerColor = "rgb(127, 127, 127)";
    SelectedColor = "rgb(225, 225, 225)";
    StaleColor = "rgb(190, 190, 190)";
    
    // -- Site Settings ---------------------------------------
    SiteShow = true; // true or false
    // The Latitude and Longitude in decimal format
    SiteLat = 51.785982;
    SiteLon = 6.059338;
    
    SiteCircles = true; // true or false (Only shown if SiteShow is true)
    // In nautical miles or km (depending settings value 'Metric')
    SiteCirclesDistances = new Array(40,80);

    Partagez vos données avec FlightRadar24

    Pour partager vos données avec FlightRadar24, vous devez fournir un flux compatible TCP30003 :

    ./dump1090 --quiet --net --net-sbs-port 30003 --enable-agc &

    Installez le logiciel :

    mkdir fr24
    cd fr24/
    wget https://dl.dropboxusercontent.com/u/66906/fr24feed_arm-rpi_242.tgz
    tar zxvf fr24feed_arm-rpi_242.tgz

    Inscrivez vous pour obtenir une clé :

    ./fr24feed_arm-rpi_242 --signup

    Remplissez le questionnaire. Vous aurez besoin des coordonnées décimales de votre récepteur. Une fois que vous aurez obtenu la clé, vous pouvez partager vos données.

    ./fr24feed_arm-rpi_242 --fr24key=<key> --bs-ip=127.0.0.1 --bs-port=30003

    Lancer le logiciel au démarrage du Raspberry Pi

    Plusieurs approches sont possibles. J’ai créé plusieurs scripts pour démarrer le système de réception ADS-B/

    /home/pi/start_flight_radar.sh

    #!/bin/sh
    cd /home/pi/git/dump1090/
    ./dump1090 --quiet --net --net-sbs-port 30003 --enable-agc&
    
    pkill -f fr24feed
    /home/pi/fr24/fr24feed_arm-rpi_242 --fr24key=<key> --bs-ip=127.0.0.1 --bs-port=30003

    /etc/init.d/flightradar

    #!/bin/bash
    # /etc/init.d/flightradar
    
    ### BEGIN INIT INFO
    # Provides: flightradar
    # Required-Start: $remote_fs $syslog
    # Required-Stop: $remote_fs $syslog
    # Default-Start: 2 3 4 5
    # Default-Stop: 0 1 6
    # Short-Description: Flight Radar
    # Description: Flight Radar (ADS-B Receiver)
    ### END INIT INFO
    
    case "$1" in
    start)
    echo "Starting flightradar"
    /home/pi/start_flight_radar.sh &
    ;;
    stop)
    echo "Stopping flightradar"
    killall dump1090
    ;;
    *)
    echo "Usage: /etc/init.d/flightradar start|stop"
    exit 1
    ;;
    esac
    
    exit 0

    N’oubliez pas de rendre le script exécutable et de configurer update-rc.d

    sudo chmod +x /etc/init.d/flightradar
    sudo update-rc.d flightradar defaults
    raspi_cam_fr

    Le système de réception ADS-B de Pygmalion

    Conclusion

    Désolé si cet article vous a semblé un peu long avant d’arriver à la partie qui vous concerne si vous êtes uniquement RasPinaute… Il m’a semblé intéressant de présenter un peu plus en détails la réception ADS-B qui est réalisable avec des moyens réduits.

    Avec un dongle DVB-T à une dizaine d’euros et son antenne de m… très simple, il est déjà possible de recevoir quelques trames lorsque les avions passent au dessus de chez vous… Alors imaginez en installant une antenne un peu plus évoluée 😉

    Et un jour où la propagation est favorable, vous aurez peut-être la surprise, comme Erik (le  point rouge sur la carte), de découvrir que vous pouvez suivre une multitude d’avions situés à grande distance…

    propag_ads_BSi le sujet vous intéresse, rejoignez le forum de framboise314 : Un tutoriel de Mmega vous y attend, ainsi qu’une intéressante discussion sur l’ADS-B…

     

    Mes tests de réception au Creusot

    C’est du vite fait pour vérifier la faisabilité :

    • 1 Raspberry Pi 2
    • 1 carte SD 16Go Samsung
    • 1 clé DVB-T modèle SPC-0155
    • 1 antenne livrée avec la clé USB

    C’est pas l’installation rêvée puisque j’ai posé l’antenne sur le rebord de fenêtre (métallique) d’un bâtiment industriel le toit est en plus entouré d’un bardage métallique de 3m de haut…

     reception_creusot2 Le récepteur est quand à lui connecté directement sur le câble d’origine qui fait au moins… 1 mètre de long 😉 ainsi que sur le Raspberry Pi :

    reception_creusotL’antenne est la prise en haut à droite de l’image. LE RasPi est connecté au réseau, ce qui m’a permis d’observer sur la carte mes premiers avions (yep !)

    20150414_10h00_110kmJ’ai tracé un cercle de 110 Km de rayon autour du Creusot et on voit que même avec des moyens très limités (pour ne pas dire primitifs!) il est possible de recevoir les trames ADS-B d’avions situés à plus de 100Km… Imaginez si l’antenne est une colinéaire placée en haut d’un mât avec un préampli 😉

    Personnalisation de l’affichage de Dump1090

    Il est possible de personnaliser votre affichage comme indiqué plus haut. Pour ma part, /home/pi/git/dump1090/public_html/config.js est modifié comme suit :

    // --------------------------------------------------------
    //
    // Ce fichier permet de modifier l'affichage sous Dump1090.
    // Chargez ce fichier avant script.js dans gmap.html.
    //
    // --------------------------------------------------------
    
    // -- Valeurs de sortie -------------------------------------
    // Affichage métrique : true pour afficher en km
    Metric = true; // true ou false
    
    // -- Configuration de la carte -----------------------------
    // Latitude et Longitude en format décimal
    // Indique le centre de la carte qui sera affichée
    // J'ai choisi de centrer sur mon antenne ADS-B
    CONST_CENTERLAT = 46.799107;
    CONST_CENTERLON = 4.418899;
    // Niveau de zoom google map de 0 à 16, 0 est le plus éloigné
    CONST_ZOOMLVL   = 5;
    
    // -- Paramètres des marqueurs -------------------------------
    // Couleur par défaut des marqueurs
    MarkerColor       = "rgb(127, 127, 127)";
    SelectedColor = "rgb(225, 225, 225)";
    StaleColor = "rgb(190, 190, 190)";
    
    // -- Configuration du site de réception ---------------------
    // true affiche une cible aux coordonnées indiquées
    // Pour moi : les coordonnées de l'antenne
    SiteShow    = true; // true ou false
    // Latitude et Longitude en format décimal
    SiteLat     = 46.799107;
    SiteLon     = 4.418899;
    
    // -- Dessin des cercles donnant la distance des avions ------
    // Les cercles ne sont affichés que si SiteShaw est sur true
    SiteCircles = true; // true ou false 
    // In miles nautiques ou en km (selon la valeur de 'Metric')
    // J'ai choisi d'afficher des cercles à 50km, 100km, 150km et 200km
    SiteCirclesDistances = new Array(50,100,150,200);

    Le résultat

    reception_creusot_20150419_2Un dimanche après midi d’avril à 15 heures… L’antenne est la petite antenne d’origine livrée avec la clé USB/TNT posée sur un appui de fenêtre. Les cercles permettent d’estimer rapidement la distance de l’avion. J’attends avec impatience de pouvoir tester une « vraie » antenne et un préampli 1090MHz qui est en chemin depuis le Japon.

    Vous pouvez voir le résultat sur RaspiBlog, un serveur hébergé par … un Raspberry Pi 😉 qui comporte une page dédiée pour l’affichage des avions aux alentours de LE CREUSOT (71)

    L’affichage sur la console du Raspberry Pi

    Dump1090 possède de nombreuses options accessibles par la commande

    ./dump1090 --help

     

    -----------------------------------------------------------------------------
    |                dump1090 ModeS Receiver         Ver : 1.10.3010.14         |
    -----------------------------------------------------------------------------
    
    --device-index <index>   Select RTL device (default: 0)
    --gain <db>             Set gain (default: max gain. Use -10 for auto-gain)
    --enable-agc             Enable the Automatic Gain Control (default: off)
    --freq <hz>             Set frequency (default: 1090 Mhz)
    --ifile <filename>       Read data from file (use '-' for stdin)
    --interactive           Interactive mode refreshing data on screen
    --interactive-rows <num> Max number of rows in interactive mode (default: 15)
    --interactive-ttl <sec> Remove from list if idle for <sec> (default: 60)
    --interactive-rtl1090   Display flight table in RTL1090 format
    --raw                   Show only messages hex values
    --net                    Enable networking
    --modeac                 Enable decoding of SSR Modes 3/A & 3/C
    --net-beast             TCP raw output in Beast binary format
    --net-only               Enable just networking, no RTL device or file used
    --net-bind-address <ip> IP address to bind to (default: Any; Use 127.0.0.1 for private)
    --net-http-port <port>   HTTP server port (default: 8080)
    --net-ri-port <port>     TCP raw input listen port (default: 30001)
    --net-ro-port <port>     TCP raw output listen port (default: 30002)
    --net-sbs-port <port>   TCP BaseStation output listen port (default: 30003)
    --net-bi-port <port>     TCP Beast input listen port (default: 30004)
    --net-bo-port <port>     TCP Beast output listen port (default: 30005)
    --net-ro-size <size>     TCP raw output minimum size (default: 0)
    --net-ro-rate <rate>     TCP raw output memory flush rate (default: 0)
    --net-heartbeat <rate>   TCP heartbeat rate in seconds (default: 60 sec; 0 to disable)
    --net-buffer <n>         TCP buffer size 64Kb * (2^n) (default: n=0, 64Kb)
    --lat <latitude>         Reference/receiver latitude for surface posn (opt)
    --lon <longitude>       Reference/receiver longitude for surface posn (opt)
    --fix                   Enable single-bits error correction using CRC
    --no-fix                Disable single-bits error correction using CRC
    --no-crc-check           Disable messages with broken CRC (discouraged)
    --phase-enhance         Enable phase enhancement
    --aggressive             More CPU for more messages (two bits fixes, ...)
    --mlat                  display raw messages in Beast ascii mode
    --stats                 With --ifile print stats at exit. No other output
    --stats-every <seconds> Show and reset stats every <seconds> seconds
    --onlyaddr               Show only ICAO addresses (testing purposes)
    --metric                 Use metric units (meters, km/h, ...)
    --snip <level>           Strip IQ file removing samples < level
    --debug <flags>         Debug mode (verbose), see README for details
    --quiet                 Disable output to stdout. Use for daemon applications
    --ppm <error>           Set receiver error in parts per million (default 0)
    --help                   Show this help 
    
    Debug mode flags: d = Log frames decoded with errors
    D = Log frames decoded with zero errors
    c = Log frames with bad CRC
    C = Log frames with good CRC
    p = Log frames with bad preamble
    n = Log network debugging info
    j = Log frames to frames.js, loadable by debug.html

    Si vous souhaitez afficher un tableau plus lisible que le défilé rapide des messages envoyé par dump1090 vers la console du Raspberry Pi, ajoutez – – interactive à la ligne de commande, vous pourrez lire ce tableau, identique à celui qui apparait sur la page web :

    reception_creusot_20150419_3

    Sources


    0 0
  • 05/03/15--21:56: Lazarus sur le Raspberry Pi
  • Lazarus_logo_250pxLazarus est un EDI multiplateforme développé en Free Pascal pour Free Pascal. Son objectif est de fournir aux programmeurs Pascal Objet un environnement de développement s’approchant le plus possible de Delphi.
    Henri, un lecteur du blog et développeur en Free Pascal a galéré pour installer Lazarus sur son Raspberry Pi, il a voulu vous faire profiter de son expérience…

    Lazarus_logo
    Free Pascal est un compilateur sous licence GPL fonctionnant sous Linux, Windows, OS/2, Mac OS X, BSD, iOS, Android, etc. Il est conçu pour interpréter et compiler le Pascal Objet de Delphi. À la différence de Java dont le slogan est « write once run anywhere » (écrire une fois, exécuter partout), celui de Lazarus et Free Pascal est « write once compile anywhere » (écrire une fois, compiler partout). (Wikipedia)

     lazarus_raspi_600pxJe laisse la parole à Henri :

    « Ce diable de Pi 2 est une petite merveille, mais ne se laisse pas domestiquer si facilement!
    Si j’ai pu sans problème installer pas mal de choses, il a refusé (sous Raspbian) d’installer Lazarus: “paquets cassés”.
    J’ai essayé quelques solutions proposés sur le net pour des problèmes similaires, que dalle..

    Le Raspberry Pi est décidément une drôle de petite bécane bien sympathique, et il m’est venu l’idée de m’en servir pour réaliser un projet assez particulier : l’accueil de jeunes hirondelles dans de nouveaux nids installés sur les murs de la maison. Et c’est là que le petit ordinateur intervient : je désire le faire gazouiller de 7h à 20h pour attirer les jeunes oiseaux et les inviter à s’installer chez nous ,

    La partie programmation n’est pas très compliquée : il s’agit de brancher un ordinateur sur des baffles et d’y faire passer plusieurs fichiers sons dans un ordre aléatoire entre 7 & 20h. Le logiciel ad hoc a déjà été réalisé en 2014 sous Windows 7 et fonctionne très bien. Mais quel gâchis énergétique de faire fonctionner un PC 24h/24 durant un mois ! Alors un petit Raspberry ne pourrait-il faire ce travail ?

    Certes : il suffit a priori d’installer sur le Pi Lazarus, puis de recompiler le logiciel fonctionnant sous Windows. C’est d’autant plus facile que Raspbian dispose de Lazarus et son compilateur Fpc dans sa bibliothèque de paquetages.

    Ouais. Sauf que le Rasp refuse d’installer ces logiciels : un paquetage est corrompu (broken comme disent les Godons)..

    Il m’a fallu pas mal de temps pour trouver l’origine de ce souci, et surtout sa solution, c’est d’ailleurs un de nos amis programmeurs anglais qui l’a trouvée pour moi, je vous en délivre la substantifique moelle.

    Il faut savoir que la cause du problème semble être liée au fait que le compilateur Pascal (fpc) s’appuie sur un mauvais paquet présent dans la version actuelle du Raspbian. Avant donc d’espérer faire fonctionner Lazarus, avant même de l’installer, il convient d’ajouter en mode administrateur au fichier /etc/apt/sources.list  la ligne suivante :

    deb http://plugwash.raspbian.org/wsf wheezy-wsf main

    puis un simple apt-get update (qui va prendre un temps certain), puis d’installer lazarus sans plus se soucier de quoi que ce soit, et tout rendre dans l’ordre !

    C’est égal : il m’aura fallu pas moins d’une quinzaines d’essais avant de trouver la solution efficace..« 

    Conclusion

    Merci à Henri d’avoir partagé cette information qui permettra aux amateurs de Pascal de développer sur le Raspberry Pi. N’hésitez pas à nous faire part de vos expériences avec cet environnement de développement…

    Complément

    Roland utilise également Lazarus et il me transmet cette information :

    « bonjour François
    j’utilise essentiellement delphi pour faire des programmes pro et perso, c’est vraiment confortable pour créer des applications avec interface graphiques
    Il y a un équivalent sous linux qui s’appelle lazarus et que l’on peut installer sur le raspberry pi version 2 , cela permet de pouvoir programmer en pascal sur la framboise, ce qui peut intéresser de nombreuses personnes programmant avec delphi (python, c’est bien ,mais en mode graphique , c’est un peu galère…)
    j’ai découvert un tuto très détaillé sur l’installation de lazarus sur le raspberry ici :
    http://otapi.com/2015/02/10/raspberry-pi-2-freepascal-lazarus-and-delphi/

    je suis plus qu’enchanté du résultat !

    si tu penses que ça peut servir à d’autres utilisateurs…
    cordialement
    roland »

    Sources


    0 0

    nrf24l01_250pxDominique (Domi sur le forum de framboise314) a réalisé une liaison 2,4 GHz entre un Raspberry Pi et un Arduino Nano.
    Il a publié son tutoriel sur le forum et vous pouvez le lire directement. Dominique m’a gentiment proposé de reprendre son tutoriel sur le blog pour le mettre à disposition de tous les lecteurs. Voilà qui est chose faite. Merci à Dominique pour ce partage ! Attention, ce tutoriel nécessite d’avoir quelques connaissances en ligne commande et en compilation de programme… 😉 Si vous êtes un « vrai » débutant mettez l’adresse dans vos favoris et revenez un peu plus tard.

    NRF24L01_FB

    Différentes déclinaisons du circuit nRF24L01

    Liaison 2,4 GHz entre Raspberry Pi et Arduino

    Je laisse la parole à Dominique :

    Recherchant un moyen de relier des capteurs autonomes à un Raspberry Pi. Mon choix s’est orienté sur l’utilisation d’un Arduino Nano. Petit mais suffisamment puissant pour être autonome, effectuer différents relevés, mais également effectuer des actions comme par exemple piloter un relais.

    Pour communiquer avec le Raspberry Pi, j’ai choisi d’utiliser des modules nRF24L01, module de liaison Hertzienne à 2,4 Ghz.

    NRF24L01

    Le circuit nRF24L01

    But recherché

    Le but de ce tutoriel est de faire dialoguer un Raspberry Pi et un Arduino Nano.
    Nous allons voir comment réaliser l’installation de la bibliothèque RF24, le câblage, ainsi que la configuration du Raspberry et de l’Arduino Nano.
    Les programmes en C++ sont une adaptation de programmes trouvés en exemple sur Internet, je les ai adaptés à mon besoin.

    Principe de fonctionnement souhaité

    Le principe de fonctionnement de ce tutoriel est de piloter depuis un Raspberry Pi, une LED pilotée par l’Arduino Nano, ce dernier retourne au Raspberry Pi un état de la commande pour indiquer sa bonne exécution, ou pas.

    • Allumage de la LED
      • On envoie dans une commande une chaine JSON au Raspberry Pi, celui ci l’interprète, puis envoie à l’Arduino Nano via le nRF24L01 la commande d’allumage de la led (envoi du N° d’ID attribué au nRF24L01 du Nano + commande « ON » ).
      • L’Arduino Nano reçoit la commande, allume la LED, et retourne sont état au RasPi.
      • Le RasPi reçoit l’état de la LED, le programme reconstruit une chaine JSON de retour avec la valeur de retour pour l’utilisateur (« TRUE » ou « FALSE« ), ainsi que l’état de la LED (« ON » ou « OFF« )
    • Extinction de la LED
      • Idem ci dessus, mais envoi d’une commande « OFF« 
    • Demander l’état de la LED
      • Le Raspberry Pi envoie une demande à l’Arduino Nano pour connaitre l’état de la LED (envoi du N° d’ID attribué au nRF24L01 du Nano + commande « GET« ).
      • L’Arduino Nano lit l’état de la LED qu’il a en mémoire, et le retourne au RasPi.
      • Le RasPi reçoit l’état de la LED, le programme reconstruit une chaine JSON de retour avec la valeur de retour (« TRUE » ou « FALSE ») ainsi que l’état de la LED (« ON » ou « OFF »)

    Passons maintenant à la partie technique, installation et configuration du matériel.

    NRF24L01-circuits

    Schéma d’une carte nRF24L01

    Mise à jour du système

    Avant toute installation, on commence par mettre à jour le système :

    $ sudo apt-get update
    $ sudo apt-get upgrade
    $ sudo apt-get dist-upgrade

    Préparation du système

    Installation de SPI

    Afin d’assurer une bonne stabilité de l’interface SPI, il est préférable d’annuler l’overcloking si vous l’avez activé sur votre système… Il sera possible une fois que l’ensemble sera fonctionnel, de tenter une réactivation de l’overclock. Mais par sécurité, il vaut mieux d’abord installer l’ensemble, et le faire fonctionner dans des conditions normales et sur un système sain, et seulement après retenter un overclockage.

    Pour activer l’interface SPI, il faut lancer la commande :

    $ sudo raspi-config

    Aller dans le menu des options avancées (menu « Advanced Options »), puis dans le sous-menu, sélectionner « SPI« , et cliquer sur « Oui » pour activer le SPI.

    Il est ensuite demandé si l’on souhaite charger le module SPI avec le Noyau, répondre « OUI »

    Quitter l’utilitaire « Raspi-config ». Rebooter le système.

    image9

    nRF24L01 : Implantation des composants

    Après le redémarrage, on va autoriser l’accès à SPI. Pour cela, éditer le fichier « raspi-blacklist.conf » :

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

    Attention, dans les dernières versions de Raspbian, j’ai remarqué que ce fichier n’existe plus, ou qu’il est vide, il n’y a donc plus rien à modifier dedans. Passer directement à la suite du prochain reboot sans suivre les modifications du fichier.

    Si le fichier n’est pas vide, vérifier si la ligne ci-dessous existe :

    blacklist spi-bcm2708

    Dans ce cas, il faut la commenter en ajoutant un « # » devant :

    #blacklist spi-bcm2708

    On enregistre, on quitte l’éditeur, et on reboot le Raspberry.

    Au redémarrage, on vérifie que le SPI est bien activé :

    pi@raspberrypi ~ $ ls -la /dev/spi*
    crw-rw---T 1 root spi 153, 0 janv. 1 1970 /dev/spidev0.0
    crw-rw---T 1 root spi 153, 1 janv. 1 1970 /dev/spidev0.1

    Si on voit apparaître les « /dev/spi* » , c’est que la configuration est correcte.

    NRF24L01_02

    Installation de la bibliothèque

    Créer un dossier que l’on nommera « nrf24l01 » dans le « home directory » de l’utilisateur « pi« . Importer la bibliothèque RF24, et la compiler de la façon suivante.

    $ cd
    $ mkdir nrf24l01
    $ cd nrf24l01
    $ git clone https://github.com/TMRh20/RF24.git
    $ cd RF24
    $ make
    $ sudo make install

    On installe la librairie « JSON » que l’on va utiliser dans notre script de communication :

    $ sudo apt-get install libjson0-dev

    Revenir dans le dossier nrf24l01

    $ cd ~/nrf24l01

    Copier les fichiers « Makefile » et « sender.cpp » que vous trouverez dans le ZIP « nRF24L01_Raspberry » en bas de ce tutoriel.
    Compiler le fichier à l’aide de la commande « make »

    $ make
    NRF24L01_01

    nRF24L01 équipé d’une antenne

    Installation matérielle

    Le Raspberry Pi

    Rpi_nrf24l01.png

    Connexions entre le  Raspberry Pi et le nRF24L01

    Éteignez le Raspberry Pi avant de lui connecter physiquement le module nRF24L01. Ceci évitera d’éventuelles destructions de ports…
    L’exemple est ici avec un Raspberry Type B, mais les connexions sont identiques avec un A, A+, B+ ou Pi2

    Connexion sur le Raspberry, les connexions aux broches ci-dessous ne peuvent être changées :

    • Pin 19 = MOSI du Raspberry vers MOSI (pin 6) du nRF24L01.
    • Pin 21 = MISO du Raspberry vers MISO (pin 7) du nRF24L01.
    • Pin 23 = SCLK du Raspberry vers SCK (pin 5) du nRF24L01.
    • Pin 24 = CE0 du Raspberry vers CSN (pin 4) du nRF24L01. (Peut éventuellement être connecté sur pin 26 du Raspberry, mais les scripts devront être adaptés).

    La connexion du +3,3v, pin 2 du nRF24L01 est prise dans ce schéma sur le pin 1 du Raspberry. Cette alimentation peut être prise sur tout autre pin du Raspberry fournissant du 3,3v (pin 1 ou 17).

    La connexion GND, pin 1 du nRF24L01 peut être prise partout ou il y a une pin GND sur le Raspberry.

    • Reste la pin 22 du Raspberry, il s’agit d’un port GPIO. Si celui ci est déjà utilisé, on peut prendre n’importe quel port GPIO. Il faudra pour cela adapter le script « sender.cpp » puis le recompiler.

    Dans le script, changer la ligne :

    RF24 radio(RPI_V2_GPIO_P1_22, RPI_V2_GPIO_P1_24, BCM2835_SPI_SPEED_16MHZ);

    en adaptant « RPI_V2_GPIO_P1_22″ en fonction du pin GPIO connecté.
    Exemple : « RPI_V2_GPIO_P1_11″ pour le GPIO 0.

    Avant de remettre le Raspberry Pi sous tension, faites une nouvelle vérification de vos connexions…

    L’Arduino Nano

    Nous allons installer le module nRF24L01 sur un Arduino Nano. C’est ce dernier qui recevra l’ordre du Raspberry Pi  lui demandant d’allumer ou d’éteindre la LED.
    Le tutoriel est ici donné avec un Arduino Nano, mais toute autre carte Arduino fera l’affaire, en respectant les connexions ci-dessous.

    Voici le schéma du câblage entre l’Arduino Nano et le nRF24L01

    Nano_nrf24l01.png

    Connexions entre l’Arduino Nano et le nRF24L01

    Connexion sur l’Arduino Nano, les connexions aux broches ci-dessous ne peuvent être changées :

    • Pin D11 du Nano vers MOSI (pin 6) du nRF24L01.
    • Pin D12 du Nano vers MISO (pin 7) du nRF24L01.
    • Pin D13 du Nano vers SCK (pin 5) du nRF24L01.

    Connexions pouvant être effectuées sur d’autre pin, mais qui devront être adaptées dans le code du Croquis exporté vers l’Arduino Nano.

    • Pin D10 du Nano vers CSN (pin 4) du nRF24L01.
    • Pin D9 du Nano vers CE (pin 3) du nRF24L01.
    • Pin D6 du Nano vers l’anode de la LED.
    • L’alimentation du +3,3v, pin 2 du nRF24L01 est prise dans ce schéma sur le pin +3,3v du Nano.

    Pour effectuer les connexions D10, D9 ou D6 à un autre pin, il faut ouvrir le croquis Arduino (.ino) et adapter les lignes suivantes :

    #define RF_CE    9
    #define RF_CSN   10
    #define LED_PIN  6

    Les Programmes

    Programme Raspberry Pi

    Le programme du Raspberry Pi permet d’envoyer via le nRF24L01, un ordre d’allumage ou d’extinction d’une LED. Cette dernière est commandée par notre Arduino Nano, l’ordre d’allumage et d’extinction est donc envoyé par le Raspberry Pi, vers Arduino Nano.

    Le programme est écrit en C++, il utilise la bibliothèque RF24, que nous avons installée plus haut dans ce tutoriel.

    Le principe est d’envoyer une chaine JSON via la ligne de commande du Raspberry Pi. Cette chaîne est composée de :

    {
    "to":"1",              // id di nRF24L01 vers lequel on envoi la commande.
    "message":"get", // commande envoyée au Arduino Nano.
    "TTL":"3000"      // (paramètre optionnel) "Time out" (si non précisé il sera de 1000 ms).
    }

    Les messages peuvent être :

    set=on     // Commande l'allumage de la LED
    set=off    // Commande l'extinction de la LED
    get         // Demande au Nano quel est l'état de la LED

    Exemple de commande envoyée pour commander l’allumage de la LED :

    $ sudo ./sender '{"to":"1","message":"set=on"}'

    Nous envoyons bien en paramètre une chaîne au format JSON. Le programme du Raspberry Pi s’occupe de transcrire cette chaine afin d’envoyer les commandes à l’Arduino, via le nRF24L01.

    Télécharger ci-dessous le ZIP, puis copier les deux fichiers contenus dans l’archive « nRF24L01_Raspberry » vers le dossier « ~/nrf24l01/« 

    nrf24-raspberry.zip    Script pour Raspberry  (1.58 Kio)

    Se placer dans le dossier puis compiler le programme.

    $ cd ~/nrf24l01
    $ make</code>

    Le programme sur le Raspberry Pi est maintenant fonctionnel.

    Programme Aduino Nano

    Le programme de l’Arduino Nano permet de recevoir les commandes envoyées, les interpréter, puis de répondre au Raspberry Pi si la commande est OK ou pas.

    Ci-dessous le programme « ino » à charger depuis votre atelier Arduino (IDE).
    nrf24-arduino.ino.zip     Script pour Arduino  (1.28 Kio)

    Conclusion

    Notre montage est maintenant fonctionnel.
    Les prochaines étapes seront de remplacer la LED par une sonde de température DS18B20, et donc d’adapter les programmes à ce nouveau périphérique.
    Au menu également une sonde DHT 11 ou DHT 22, un détecteur ultrasons de type HC-SR04 (pour remplacer le RasPi dans ma cuve à eau), …. et tout autre détecteur ou sonde dont je pourrais avoir besoin.

    Note de framboise314 : Merci Domi pour cette description détaillée qui pourra servir de point de départ à de nombreuses réalisations domotiques !

    Sources

    Voici quelques liens vers des articles sur la mise en œuvre du nRF24L01. Ce sont des articles de montages ou de programmes, auxquels je me suis inspirés afin d’arriver à ce résultat.

    L’article d’origine se trouve ici :


    0 0

    cagoulJean-Michel m’a contacté il y a quelque temps pour me raconter sa création : réaliser un film sur la Feria de Nîmes avec un RasPi équipé de sa caméra…
    Alors, de quoi s’agit-il ? me direz-vous.C’est tout simple : c’est une animation vidéo image par image réalisée à partir des photos prises en déambulant durant la Féria de Nîmes à l’aide d’un Raspberry Pi muni de sa caméra et alimenté de façon autonome…

    Timelapse à la Feria de Nîmes 2015

    Le matériel utilisé

    Il a utilisé le matériel suivant :

    • 1 Raspberry pi (ici un  Model B 512 Mo).
    • 1 Camera Pi
    • 1 écran TFT pour lancer/contrôler/vérifier le processus à tout moment.
    • 1 Power bank pour l’alimentation
    • 1 carte mémoire 32 Go pour un stockage confortable.
    • 1 élastique, 1 morceau de ficelle et des petits bouts de papier autocollant pour assembler le tout (the french touch !)
    • 1 cagoule afin de ne pas attirer l’attention  😉 et passer incognito malgré votre pendentif futuriste (voir Gif et Photo).
    • 1 clavier et une souris à portée pour entrer le code et en cas de dysfonctionnement imprévu (également appelé « Bug »).

    Préparation

    Une fois que vous en êtes là, le Pi devrait démarrer et afficher le Bureau, effectuez donc des tests caméra afin de s’assurer que tout fonctionne.

    Le code Raspicam pour la prise de vue à rentrer dans le terminal :

    raspistill -o timelapse_05%d.jpg -tl 1000 -t 10800000

    Ce qui indique que l’on va prendre les photos nommées « timelapse 00001.jpg, timelapse 00002.jpg, etc. » toutes les secondes (option -tl) pendant une durée (option -t) ici de 3 heures, les durées étant exprimées en millisecondes.

    recto

    Le « 05%d » est primordial pour incrémenter les images et définir une valeur à 5 décimales, sinon il mettra la 11, la 12, etc. avant la 2; la 52 avant la 6 par exemple et ce sera la pagaille lors du montage final.

    verso

    On peut uitiliser les options -w et -h pour réduire la taille des photos, qui par défaut sont 1920×1080, et ainsi bénéficier d’un gain de place sur la carte. Pour faciliter l’écriture du code qui peut s’avérer rébarbatif pour certaines personnes, vous pouvez utiliser le générateur « Handsdown » à cette adresse : http://www.handsdown.be/raspicam/indexfr.html (traduit en français par qui ? 😉 )

    Ensuite vous n’avez plus qu’à

    • vous balader avec votre attirail autour du cou.
    • rentrer chez vous.
    • trier les photos (en deux soirées et une après-midi, Jean-Michel a récolté environ 18000 images ! Elles n’apparaissent donc pas toutes dans la vidéo finale.)
    • effectuer le montage.

    et vous obtiendrez un magnifique « MovingTimelapse » de votre pérégrination, mais appelons le « Accéléré Mobile », c’est un terme français plus approprié.

    Les vidéos

    Cette deuxième vidéo est de meilleure qualité que la précédente, la HD étant disponible en cliquant sur l’engrenage en bas à droite

    C’est la fin de la Féria, le Lundi soir au Prolé , on refait le match, on termine le stock de bibine et on croise des gens sympathiques, Jean-Michel a immortalisé ces moments toujours avec le Raspberry Pi et la technique décrite ci dessus :

     

    Conclusion

    Cette réalisation vous donnera peut-être des idées pour réaliser le même genre de « reportage » lors d’une festivité comme il va y en avoir de nombreuses cette année (enfin je ne parle pas des festivals qui sont morts à cause de la subvention des collectivités… :( )

    Sources


    Warnning: Do NOT Get Caught While Searching!!
    Your IP : - Country : - City:
    Your ISP TRACKS Your Online Activity! Hide your IP ADDRESS with a VPN!
    Before you searching always remember to change your IP adress to not be followed!
    PROTECT YOURSELF & SUPPORT US! Purchase a VPN Today!
    0 0
  • 07/24/15--09:14: Un point sur le Device Tree
  • BigTree_250pxLes derniers noyaux et firmware du Raspberry Pi, y compris Raspbian et NOOBS, utilisent maintenant par défaut Device Tree (Arborescence Matérielle) pour gérer certaines allocations des ressources et les chargements de modules. L’objectif de ce changement est de diminuer le problème d’accès concurrent aux ressources du système par plusieurs pilotes, et de permettre la configuration automatique des modules HAT.

    Les Device Tree et le Raspberry Pi

    Ce billet s’adresse plutôt à des utilisateurs avancés
    qui sont amenés à intervenir au niveau du système,
    et à utiliser les bus externes I2C, I2C et SPI.
    <== C’est une traduction d’un article paru sur raspberrypi.org ==>

    Depuis quelques années, un important changement a eu lieu dans le support de l’architecture ARM du noyau Linux : le passage à une description du matériel appelée le Device Tree. Tout développeur souhaitant aujourd’hui porter le noyau Linux sur une plateforme ARM (que ce soit une nouvelle carte ou un nouveau processeur) doit désormais comprendre ce nouveau mécanisme et l’utiliser: c’est devenu une connaissance indispensable du développeur Linux embarqué.

    L’implémentation actuelle n’est pas un système d’arborescence des périphériques pur – il y a encore du code qui s’occupe des composants présents sur la carte – mais les interfaces externes (I2C, I2S spi) et les périphériques audio qui les utilisent doivent maintenant être créés à l’aide d’un Blob d’Arborescence Matérielle (DTB = Device Tree Blob) transmis au noyau par le loader (start.elf). (voir la page 11 de Device Tree for the Dummies)

    device_tree_for_dummies_600px

    Le principal impact de l’utilisation de l’Arborescence Matérielle est de changer d’approche. On part d’une situation où tout est validé, une liste noire (blacklist) permettant d’éliminer les modules inutiles. Ici rien n’est validé, sauf les modules indiqués par la DTB. Si vous voulez continuer à utiliser des interfaces externes ainsi que les périphériques qui s’y rattachent, vous allez devoir ajouter de nouveaux paramètres à votre fichier config.txt. La partie 3 de cet article donne des informations plus détaillées, en attendant voici quelques exemples :

    # Uncomment some or all of these to enable the optional hardware interfaces
    #dtparam=i2c_arm=on
    #dtparam=i2s=on
    #dtparam=spi=on
    
    # Uncomment one of these lines to enable an audio interface
    #dtoverlay=hifiberry-amp
    #dtoverlay=hifiberry-dac
    #dtoverlay=hifiberry-dacplus
    #dtoverlay=hifiberry-digi
    #dtoverlay=iqaudio-dac
    #dtoverlay=iqaudio-dacplus
    
    # Uncomment this to enable the lirc-rpi module
    #dtoverlay=lirc-rpi
    
    # Uncomment this to override the defaults for the lirc-rpi module
    #dtparam=gpio_out_pin=16
    #dtparam=gpio_in_pin=17
    #dtparam=gpio_in_pull=down

    Partie 1 : Les Arborescences Matérielles (DT)

    Une Arborscence Matérielle (DT = Device Tree) est une façon de décrire le matériel présent dans un système. Il doit inclure le nom de la CPU (microprocesseur) de base, sa configuration mémoire et les périphériques (internes et externes) qui y sont reliés. Une DT ne doit pas être utilisée pour décrire le logiciel, même si en énumérant les modules matériels elle provoque habituellement le chargement des pilotes pour ces modules. Il peut être utile de rappeler que les DT sont censées être neutres par rapport à l’OS, donc tout ce qui est spécifique à Linux n’a probablement pas lieu de s’y trouver…

    Les DT représentent la configuration matérielle sous la forme d’une hiérarchie de nœuds. Chaque nœud peut contenir des propriétés ainsi que des sous-noeuds. Les propriétés sont appelées tableaux d’octets, et peuvent contenir des chaînes, des nombres (big-endian), des séquences arbitraires d’octets… Par analogie avec un système de fichiers, les nœuds seraient les répertoires et les propriétés seraient les fichiers. Les emplacements des nœuds et des propriétés au sein de l’arborescence peuvent être décrits à l’aide d’un chemin, avec des barres obliques comme séparateurs et une seule barre oblique (/) pour indiquer la racine.

    arboresence_Linux

    Syntaxe de base des DT

    [Cette section emprunte beaucoup à devicetree.org]

    Les Arborescences Matérielles sont généralement écrites sous forme de texte, appelés Source de l’Arborscence Matérielle (DTS = Device Tree Source) et stockées dans des fichiers ayant un suffixe .dts.

    DTS est une syntaxe C-like, avec des accolades pour le regroupement et des points-virgules à la fin de chaque ligne. ATTENTION /!\. DTS nécessite des points-virgules après les accolades fermantes – pensez plutôt aux structures du C plutôt qu’aux fonctions.

    Le format binaire compilé est appelé Arborescence Matérielle Aplatie (FDT = Flattened Device Tree) ou Blob d’Arborescence Matérielle (DTB = Device Tree Blob), et est stocké dans des fichiers .dtb.

    Voici un exemple d’arborescence simple au format .dts :

    /dts-v1/;
    /include/ "common.dtsi";
    
    / {
        node1 {
            a-string-property = "A string";
            a-string-list-property = "first string", "second string";
            a-byte-data-property = [0x01 0x23 0x34 0x56];
            cousin: child-node1 {
                first-child-property;
                second-child-property = ;
                a-string-property = "Hello, world";
            };
            child-node2 {
            };
        };
        node2 {
            an-empty-property;
            a-cell-property = < 1 2 3 4>; /* chaque nombre (cell) est un uint32 */
            child-node1 {
                my-cousin = <&cousin>;
            };
        };
    };
    
    /node2 {
        another-property-for-node2;
    };

    Cet arbre contient

    • Une liste d’Item
    • Un en-tête obligatoire — / dts-v1 /.
    • L’inclusion d’un autre fichier DTS, classiquement appelé *.dtsi, analogue à un fichier d’en-tête .h en C – voir ci dessous « Un aparté sur /include/ ».
    • Un seul nœud racine : /
    • Deux nœuds enfants : node1 et node2 .
    • Des enfants pour node1: child-node1 et child-node2 .
    • Un label (étiquette) ( cousin ) et une référence à ce label ( &cousin ) – voir les labels et références ci-dessous.
    • Un tas de propriétés dispersés à travers l’arborescence.
    • Un nœud répété ( /node2 ) – voir ci dessous « Un aparté sur /include/ ».

    Les propriétés sont de simples paires clévaleurvaleur peut être vide ou contenir un flux d’octets quelconque. Bien que les types de données ne soient pas encodées dans la structure de données, il y a quelques types de données fondamentales qui peuvent être utilisés dans un fichier source d’Arborescence Matérielle.

    Les chaînes de caractères (terminées par NUL) sont indiqués par des guillemets :

    string-property = "a string";

    Les «cellules» sont des entiers sur 32 bits délimités par < et > :

    cell-property = <0xbeef 123 0xabcd1234>;

    Des données sous forme d’octets arbitraires sont délimitée par des crochets, et saisies en hexadécimal :

    binary-property = [01 23 45 67 89 ab cd ef];

    Les données de types différentes peuvent être concaténées en utilisant une virgule :

    mixed-property = "a string", [01 23 45 67], <0x12345678>;

    Les virgules sont également utilisé pour créer des listes de chaînes :

    string-list = "red fish", "blue fish";

    Un aparté sur /include/

    La directive /include/ provoque une inclusion de texte simple, un peu comme la directive #include de C, mais une caractéristique du compilateur d’Arborescence Matérielle conduit à différents modes d’utilisation. Étant donné que les nœuds sont nommés, éventuellement avec des chemins absolus, il est possible pour le même nœud apparaisse deux fois dans un fichier DTS (et ses inclusions). Lorsque cela arrive, les nœuds et les propriétés sont combinés, écrasant les propriétés (les dernières valeurs remplacent les valeurs précédentes).

    Dans l’exemple ci-dessus, la deuxième apparition de /node2 fait qu’une nouvelle propriété va être ajoutée à l’original :

    /node2 {
        an-empty-property;
        a-cell-property = <1 2 3 4>; /* chaque nombre (cell) est un uint32 */
        another-property-for-node2;
        child-node1 {
            my-cousin = <&cousin>;
        };
    };

     

    Il est ainsi possible pour un .dtsi de remplacer (ou de fournir des valeurs par défaut) à différents endroits d’une arborescence.

    Labels et Références

    Il est souvent nécessaire pour une partie de l’arbre de se référer à une autre partie, et il y a quatre façons de le faire :

    Chemin sous forme de chaîne de caractères

    Les chemins doivent être explicites, par analogie à un système de fichiers – /soc/i2S@7e203000 est le chemin complet vers le périphérique I2S dans un BCM2835 et un BCM2836. Notez que même s’il est facile de construire un chemin d’accès à une propriété (/soc/i2S@7e203000/état – voilà, c’est fait), les API standard ne le font pas ; vous trouvez tout d’abord un nœud, puis vous choisissez les propriétés de ce nœud.

    phandles

    Un phandle est un entier de 32 bits unique attribué à un nœud dans sa propriété phandle. (Pour des raisons historiques, vous verrez aussi un doublon, correspondant à linux,phandle). Les phandle sont numérotés de manière séquentielle à partir de 1 – 0 est pas un phandle valable – et sont généralement attribués par le compilateur DT quand il rencontre une référence à un nœud dans un contexte d’entiers, généralement sous la forme d’un label (voir ci-dessous). Les références aux nœuds à l’aide phandles sont simplement encodées en tant que la valeur de cet entier (cell) ; il n’y a pas de balisage pour indiquer qu’ils doivent être interprétés comme phandles – c’est défini au niveau de l’application.

    Labels

    Tout comme une étiquette en C donne un nom à un endroit dans le code, un label – ou étiquette – de DT attribue un nom à un noeud dans la hiérarchie. Le compilateur prend les références aux labels et les convertit en chemins lorsqu’il est utilisé dans un contexte de chaîne ( &node ) et en phandles un contexte d’entiers ( <&node> ) ; les étiquettes d’origine ne figurent pas dans la sortie compilée. Notez que les étiquettes ne contiennent pas de structure – ce ne sont que des repères dans un espace de noms global et plat.

    Alias

    Les Alias sont similaires aux étiquettes, sauf qu’ils apparaissent dans la sortie FDT comme une espèce d’index. Ils sont stockés en tant que propriétés du nœud /aliases avec chaque propriété reliant un nom d’alias à un chemin sous forme de chaîne de caractères. Bien que le nœud aliases apparaisse dans la source, les chaînes de chemin apparaissent généralement comme des références aux labels ( &node ) plutôt que d’être écrites en toutes lettres. Les APIs DT qui résolvent une chaîne de chemin en nœud lisent généralement le premier caractère du chemin, et traitent les chemins qui ne commencent pas par un slash comme les alias qui doivent d’abord être convertis en chemin en utilisant la table /aliases .

    Sémantique de l’Arborescence Matérielle

    Comment construire une Arborescence Matérielle – la meilleure façon est encore de récupérer la configuration de certains matériels – est un sujet vaste et complexe. Il y a beaucoup de ressources disponibles, dont certaines sont énumérées ci-dessous, et ce document ne veut pas en être un autre. Mais il y a certaines choses qui méritent d’être abordées.

    Les propriétés compatible sont le lien entre la description du matériel et le logiciel du pilote. Quand un OS rencontre un nœud avec une propriété compatible il consulte sa base de données de pilotes de périphériques pour trouver celui qui convient le mieux. Sous Linux cela aboutit habituellement au chargement automatique du module, à condition qu’il ait été correctement désigné et qu’il ne figure pas sur la liste noire (blacklist).

    La propriété status indique si un périphérique est activé ou désactivé. Si status vaut ok, okay ou est absent, alors le périphérique est activé. Sinon status doit être disabled, ce qui signifie que ce que vous pensez que cela signifie 😉 le périphérique est désactivé. Il peut être utile de placer des périphériques dans un fichier .dtsi avec un status défini sur disabled. Une configuration dérivée peut alors inclure ce .dtsi et définir l’état des périphériques nécessaires à okay.

    Voici quelques liens vers des articles sur l’écriture de l’Arborescence Matérielle :

    Partie 2 : Overlays d’Arborescence Matérielle

    Un SoC moderne (System-on-Chip) est un circuit très compliqué – une arborescence de ce circuit complet pourrait nécessiter plusieurs centaines de lignes. Si on va un peu plus loin et qu’on place le SoC sur une carte avec d’autres composants, ça ne fait qu’aggraver les choses. Pour que tout cela reste gérable, surtout si certains périphériques partagent des composants, il est logique de mettre les éléments communs dans les fichiers .dtsi qui seront éventuellement inclus dans plusieurs fichiers .dts.

    Mais quand un système comme LE Raspberry Pi peut aussi accueillir des cartes d’extension, comme les cartes HAT, le problème ne fait qu’empirer ! En fin de compte, chaque configuration possible nécessite une Arborescence Matérielle pour la décrire, mais une fois que vous avez pris en compte les différents modèles de base (modèles A, B, A+ et B+, Pi2) et les gadgets qui ne nécessitent que l’utilisation de quelques broches du GPIO et qui peuvent coexister, le nombre de combinaisons commence à croître très rapidement.

    Ce qu’il faut c’est une façon de décrire ces composants optionnels en utilisant des Arborescences Matérielles (DT) partielles, puis d’être capable de construire une arborescence complète en prenant un DT de base et en lui ajoutant un certain nombre d’éléments optionnels. Eh bien c’est possible, et ces éléments optionnels sont appelés « overlays« .

    Fragments

    Un overlay d’Arborescence Matérielle (DT) comprend un certain nombre de fragments, dont chacun cible un nœud  (et ses sous-nœuds). Bien que le concept semble assez simple, la syntaxe parait plutôt étrange au premier abord :

    // Enable the i2s interface
    /dts-v1/;
    /plugin/;
    
    / {
        compatible = "brcm,bcm2708";
    
        fragment@0 {
            target = <&i2s>;
            __overlay__ {
                status = "okay";
            };
        };
    };

    La chaîne compatible identifie ce point comme étant le bcm2708, qui est l’architecture de base de cette partie du BCM2835. Pour le BCM2836 vous pouvez utiliser une chaîne compatible de type « BRCM, bcm2709 », mais à moins que vous ne cibliez les caractéristiques propres des CPU ARM, les deux architectures devraient être équivalentes, donc utiliser « BRCM, bcm2708 » peut convenir. Puis vient le premier (et dans ce cas seulement) fragment. Les fragments sont numérotés de manière séquentielle à partir de zéro. Le non respect de ceci peut faire que certains de vos fragments voir la totalité peuvent manquer.

    Chaque fragment est constitué de deux parties – une propriété  target  , identifiant le nœud auquel appliquer l’overlay et l’ __overlay__ lui-même, dont le corps est ajouté au nœud cible. L’exemple ci-dessus peut être interprété comme s’il avait été écrit comme ceci :

    /dts-v1/;
    
    / {
        compatible = "brcm,bcm2708";
    };
    
    &i2s {
        status = "okay";
    };

    L’effet de la fusion de cet overlay avec l’Arborescence Matérielle de base  du Raspberry Pi (bcm2708rpibplus.dtb, par exemple), à condition que l’overlay soit chargé en second, serait d’activer l’interface I2S en passant son statut en okay. Mais si vous essayez de compiler cet overlay en utilisant :

    dtc -I dts -O dtb -o 2nd-overlay.dtb 2nd-overlay.dts

    Vous allez obtenir une erreur :

    Label or path i2s not found

    Cela n’est pas étonnant, car il n’y a aucune référence au fichier .dtb de base ou .dts permettant au compilateur de trouver l’étiquette i2S.

    Essayez à nouveau, cette fois avec l’exemple d’origine :

    dtc -I dts -O dtb -o 1st-overlay.dtb 1st-overlay.dts

    vous aurez une ou deux erreurs :

    Si dtc retourne une erreur à propos de la troisième ligne, alors il n’a pas les extensions requises pour que l’overlay fonctionne. La directive  /plugin/ signale au compilateur qu’il doit générer des informations de lien pour que les symboles non résolus puissent être corrigées plus tard.

    Pour installer un dtc appropriés sur un Raspberry Pi, tapez :

    sudo apt-get install device-tree-compiler

    Sur les autres plateformes, vous avez deux options : si vous téléchargez les sources du noyau depuis le github de raspberrypi et faites  make ARCH=arm dtbs vous obtiendrez un dtc utilisable dans le répertoire scripts/dtc. Sinon, suivez ces étapes dans un répertoire utilisable :

    wget -c https://raw.githubusercontent.com/RobertCNelson/tools/master/pkgs/dtc.sh
    chmod +x dtc.sh
    ./dtc.sh

    Remarque : Ce script va télécharger la source principale, appliquer quelques patches, puis compiler et installer. Vous pouvez modifier dtc.sh avant de l’exécuter pour modifier le chemin de téléchargement (actuellement ~/ git/dtc) et le chemin d’installation (/usr/local/bin).

    Si vous voyez   Reference to non-existent node or label « i2s »   tout ce que vous avez à faire est de modifier la ligne de commande pour indiquer au compilateur d’autoriser les symboles non résolus, en ajoutant @ :

    dtc -@ -I dts -O dtb -o 1st-overlay.dtb 1st-overlay.dts

    Cette fois, la compilation devrait se terminer avec succès. Il est intéressant de lister le contenu du fichier DTB pour voir ce que le compilateur a généré :

    $ fdtdump 1st-overlay.dtb
    
    /dts-v1/;
    // magic:           0xd00dfeed
    // totalsize:       0x106 (262)
    // off_dt_struct:   0x38
    // off_dt_strings:  0xe8
    // off_mem_rsvmap:  0x28
    // version:         17
    // last_comp_version:    16
    // boot_cpuid_phys: 0x0
    // size_dt_strings: 0x1e
    // size_dt_struct:  0xb0
    
    / {
        compatible = "brcm,bcm2708";
        fragment@0 {
            target = <0xdeadbeef>;
            __overlay__ {
                status = "okay";
            };
        };
        __fixups__ {
            i2s = "/fragment@0:target:0";
        };
    };

     

    Après la description détaillée de la structure du fichier, voici notre fragment. Mais regardez attentivement – où nous avions écrit &I2S, il est maintenant écrit 0xdeadbeef, un indice que quelque chose d’étrange s’est passé… Après le fragment il y a un nouveau nœud, __fixups__. Il contient une liste de propriétés reliant les noms des symboles non résolus aux listes de chemins vers des cellules dans les fragments qui doivent être patchée avec le pHandle du nœud cible, une fois que la cible a été localisé. Dans ce cas, le chemin a la valeur 0xdeadbeef de target, mais des fragments peuvent contenir d’autres références non résolues qui nécessiteraient des modifications supplémentaires.

    Si vous écrivez des fragments plus compliqués le compilateur peut générer deux noeuds supplémentaires __local_fixups__ et __symbols__. Le premier est nécessaire si un nœud dans les fragments a un pHandle, parce que le programme qui effectue la fusion devra veiller à ce que les numéros de pHandle soient séquentiels et uniques, mais le dernier est la clé qui indique comment les symboles non résolus seront traitées.

    Retour à la section 2.3 où il est dit que « les étiquettes originales ne figurent pas dans la sortie compilée« , mais cela n’est pas vrai lorsque vous utilisez le commutateur -@. Au lieu de cela, toutes les étiquettes résultent d’une propriété du nœud __symbols__, reliant une étiquette à un chemin, exactement comme le nœud aliases. En fait, le mécanisme est si semblable que lors de la résolution de symboles, le chargeur du Raspberry Pi va rechercher le nœud « aliases » en l’absence d’un nœud __symbols__. Cela est utile car en fournissant alias suffisamment d’alias, nous pouvons utiliser un ancien DTC pour construire les fichiers DTB de base.

    Paramètres de l’Arborescence Matérielle

     Pour éviter d’avoir une superposition d’overlays dans l’Arborescence Matérielle, et (nous l’espérons) pour limiter l’écriture des fichiers DTS aux seuls fabricants de périphériques, le chargeur du Raspberry Pi prend en charge une nouvelle fonctionnalité – les paramètres d’Arborescence Matérielle. Cela permet de petits changements au DT en utilisant des paramètres nommés, un peu comme les modules du noyau peuvent recevoir des paramètres de modprobe et de la ligne de commande du noyau. Les paramètres peuvent être fournis par les DTB de base et par les overlays, y compris les overlays HAT.

    Les paramètres sont définis dans les DTS par addition d’un noeud __overrides__ à la racine. Il contient des propriétés dont les noms sont les noms des paramètres choisis, et dont les valeurs sont une séquence comprenant un pHandle (référence à un label) pour le nœud cible, ainsi qu’ une chaîne indiquant la propriété cible. string, integer (cellule) et les propriétés booléennes sont pris en charge.

    Paramètres string

    Les paramètres string se déclarent ainsi :

    name = <&label>,"property";

    label et property sont remplacés par les valeurs appropriées. Les paramètres string peuvent faire croître, décroître ou créer leurs propriétés cibles.

    Notez que les propriétés appelées status sont traités spécialement – les valeurs  non-zero/true/yes/on  sont converties en la chaîne « okay », alors que zero/false/no/off   deviennent « disabled ».

    Paramètres entiers

    Les paramètres entiers sont déclarées comme ceci :

    name = <&label>,"property.offset"; // 8-bit
    name = <&label>,"property;offset"; // 16-bit
    name = <&label>,"property:offset"; // 32-bit
    name = <&label>,"property#offset"; // 64-bit

    label, property et offset sont remplacés par les valeurs appropriées; l’offset (décalage) est spécifié en octets par rapport au début de la propriété (en décimal par défaut), et le séparateur précédent impose la taille du paramètre. Les paramètres entiers doivent se référer à une partie existante d’une propriété – ils ne peuvent pas faire croître leurs propriétés cibles.

    Paramètres BOOLÉENS

    L’Arborescence Matérielle code les valeurs booléennes comme des propriétés de longueur nulle – si elle existe alors la propriété est vraie, sinon elle est fausse. Ils sont définis comme suit :

    boolean_property; // Set 'boolean_property' to true

    Notez que la propriété se voit attribuer la valeur false simplement en ne la définissant pas. Les paramètres booléens sont déclarées comme ceci :

    name = <&label>,"property?";

    label et property sont remplacés par les valeurs appropriées. Les paramètres booléens peuvent faire qu’une propriété soit crée ou supprimée.

     Exemples

    Voici quelques exemples des différents types de propriétés, avec les paramètres pour les modifier :

    / {
        fragment@0 {
            target-path = "/";
            __overlay__ {
    
                test: test_node {
                    string = "hello";
                    status = "disabled";
                    bytes = /bits/ 8 <0x67 0x89>;
                    u16s = /bits/ 16 <0xabcd 0xef01>;
                    u32s = /bits/ 32 <0xfedcba98 0x76543210>;
                    u64s = /bits/ 64 < 0xaaaaa5a55a5a5555 0x0000111122223333>;
                    bool1; // Defaults to true
                           // bool2 defaults to false
                };
            };
        };
    
        __overrides__ {
            string =      <&test>,"string";
            enable =      <&test>,"status";
            byte_0 =      <&test>,"bytes.0";
            byte_1 =      <&test>,"bytes.1";
            u16_0 =       <&test>,"u16s;0";
            u16_1 =       <&test>,"u16s;2";
            u32_0 =       <&test>,"u32s:0";
            u32_1 =       <&test>,"u32s:4";
            u64_0 =       <&test>,"u64s#0";
            u64_1 =       <&test>,"u64s#8";
            bool1 =       <&test>,"bool1?";
            bool2 =       <&test>,"bool2?";
        };
    };

     Paramètres avec des cibles multiples

    Il est parfois pratique de pouvoir régler la même valeur dans plusieurs endroits de l’Arborescence Matérielle. Plutôt que de créer maladroitement plusieurs paramètres, il est possible d’ajouter des cibles multiples à un seul paramètre en les enchaînant, comme ceci:

        __overrides__ {
            gpiopin = <&w1>,"gpios:4",
                      <&w1_pins>,"brcm,pins:0";
            ...
        };

    Notez qu’il est même possible de cibler des propriétés de types différents avec un seul paramètre. Vous pourriez raisonnablement connecter un paramètre « enable » pour une string status , les cellules contenant zéro ou un, et une propriété booléenne correcte.

    D’autres exemples d’overlays

    Il y a une quantité croissante de fichiers sources d’overlays hébergés dans le dépot raspberrypi/linux github.

    Partie 3 : Utilisation de l’Arborescence Matérielle sur le Raspberry Pi

    Overlays et config.txt

    Sur le Raspberry Pi c’est au chargeur (une des images start*.elf) de combiner les overlays avec une arborescence matérielle de base appropriée, puis de transmettre une arborescence matérielle entièrement résolue au noyau. Les arborescences matérielles de base sont situés près de start.elf dans la partition FAT (/boot de Linux), elles sont appelés bcm2708-RPI-b.dtb, bcm2708-RPI-b-plus.dtb, bcm2708-RPI-cm.dtb et bcm2709- RPI-2-b.dtb. Notez que les Modèles A et A+ utiliseront les variantes « b » et « b-plus », respectivement. Cette sélection est automatique et permet à une même image de carte SD d’être utilisée sur les différents Raspberry Pi.

    ATTENTION : DT et ATAGs sont mutuellement exclusifs. En conséquence, le passage d’un blob DT à un noyau qui ne le comprend pas bloque le démarrage (boot failure). Pour éviter cela, le chargeur vérifie la compatibilité des images du noyau avec les DT. Elle est indiquée par un marqueur ajouté par l’utilitaire mkknlimg (que vous trouverez ici, ou dans le répertoire des scripts d’une source récente du noyau). Tout noyau sans marqueur est supposé être incapable d’utiliser le DT.

    Le chargeur prend désormais également en charge les builds utilisant bcm2835_defconfig, qui supportent le BCM2835. Cette configuration va provoquer la construction de  bcm2835-RPI-b.dtb et bcm2835-RPI-b-plus.dtb. Si ces fichiers sont copiés avec le noyau, et si le noyau a été marqué par un mkknlimg récent, le chargeur va essayer de charger un de ces DTB par défaut.

    Afin de gérer l’Arborescence Matérielle et les overlays, le chargeur prend en charge un certain nombre de nouvelles directives de config.txt :

    dtoverlay=acme-board
    dtparam=foo=bar,level=42

    Ceci amène le chargeur à rechercher  overlays/acme-board-overlay.dtb dans la partition du firmware, que Raspbian monte sur /boot. Il recherche alors les paramètres foo et level, et leur attribue les valeurs indiquées.

    Le chargeur recherchera également une carte HAT avec une mémoire EEPROM programmée, et chargera l’overlay correspondant : cela se produit sans aucune intervention de l’utilisateur.

    Il ya plusieurs façons de dire que le noyau utilise l’Arborescence Matérielle :

    1. Le « Machine Model : » un message du noyau pendant le démarrage affiche une valeur spécifique à la carte comme « Raspberry Pi 2 Model B », plutôt que « BCM2709 ».
    2. Quelque temps plus tard, un autre message du noyau indique « No ATAGs? » – C’est ce qui est attendu.
    3. /proc/device-tree existe, et contient des sous-répertoires et des fichiers qui reflètent exactement les nœuds et les propriétés du DT.

    Avec une Arborescence Matérielle, le noyau va rechercher automatiquement et charger les modules qui prennent en charge les périphériques activés indiqués. Par conséquent, si vous créez l’overlay de DT approprié pour un périphérique, vous évitez aux utilisateurs du périphérique d’avoir à modifier /etc/modules – toute la configuration se passe dans config.txt (dans le cas d’une carte HAT, même cette étape devient inutile). Notez, cependant, que les modules comme i2c-dev doivent toujours être chargée explicitement.

    L’autre conséquence c’est que puisque les périphériques de la plate-forme ne sont pas créés, sauf sur demande du DTB, il ne devrait plus être nécessaire de blacklister les modules habituellement chargés du fait de leur définition dans le code de la carte. En fait, les images actuelles de Raspbian sont fournies sans fichier blacklist (liste noire).

    Paramètres du DT

    Comme décrit ci-dessus, les paramètres du DT sont un moyen pratique d’appliquer de petits changements à la configuration d’un périphérique. Les DTB de base actuels acceptent des paramètres pour activer et contrôler les interfaces I2C, I2S et SPI sans utiliser d’overlays dédiés. Les paramètres ressemblent à ceci :

    dtparam=i2c_arm=on,i2c_arm_baudrate=400000,spi=on

    Notez que plusieurs affectations peuvent être placés sur la même ligne (mais il ne faut pas dépasser 80 caractères (à moins que ce soit 79 ?). Parce que ce serait mal).

    Un futur config.txt par défaut pourrait contenir une section comme celle-ci :

    # Uncomment some or all of these to enable the optional hardware interfaces
    #dtparam=i2c_arm=on
    #dtparam=i2s=on
    #dtparam=spi=on

     

    Si vous avez un overlay qui définit certains paramètres, ils peuvent être spécifié soit sur des lignes consécutives comme ceci :

    dtoverlay=lirc-rpi
    dtparam=gpio_out_pin=16
    dtparam=gpio_in_pin=17
    dtparam=gpio_in_pull=down

    soit ajoutés à la ligne de l’overlay comme ceci :

    dtoverlay=lirc-rpi:gpio_out_pin=16,gpio_in_pin=17,gpio_in_pull=down

    Notez ici l’utilisation de deux points ( : ) pour séparer le nom de l’overlay de ses paramètres, ce qui est une variante valable de la syntaxe.

    Les paramètres d’overlay ne sont accessible que jusqu’au chargement de l’overlay suivant. Dans le cas où un paramètre portant le même nom est exporté à la fois par l’overlay et par la base (ne pas le faire – c’est source de confusion), le paramètre dans l’overlay est prioritaire. Pour utiliser le paramètre exporté par la base DTB , il faut terminer l’overlay par :

    dtoverlay=

    Labels et paramètres spécifiques à la carte

    Les cartes Raspberry Pi ont deux interfaces I2C. Ce sont séparées d’origine – une pour l’ARM (CPU) et une pour le VideoCore (le «GPU»). Sur presque tous les modèles, i2c1 appartient à l’ARM et i2c0 au GPU, où elle est utilisé pour contrôler la caméra et lire l’EEPROM de la carte HAT. Cependant, dans les deux premières révisions du modèle B (les plus anciennes) ces rôles étaient inversés.

    Pour rendre possible l’utilisation d’un jeu d’overlays et de paramètres avec tous les Raspberry Pi, le firmware crée certains paramètres de DT spécifiques à la carte. Ce sont :

    <pre>i2c/i2c_arm
    i2c_vc
    i2c_baudrate/i2c_arm_baudrate
    i2c_vc_baudrate</pre>

    Ce sont des alias pour i2c0, i2c1, i2c0_baudrate et i2c1_baudrate. Il est recommandé d’utiliser uniquement i2c_vc et i2c_vc_baudrate si vous en avez vraiment besoin – par exemple, si vous programmez une mémoire EEPROM de carte HAT.  L’activation de I2c_v c peut par exemple empêcher la détection de la caméra Pi.

    Pour les gens qui écrivent des overlays, le même aliasing a été appliqué aux labels sur les nœuds I2C du DT. Ainsi, vous devriez écrire :

    fragment@0 {
        target = <&i2c_arm>;
        __overlay__ {
            status = "okay";
        };
    };

    Tous les overlays utilisant les variantes numériques seront modifiés pour utiliser les nouveaux alias.

    Carte HAT et Arborescence Matérielle

    Une carte HAT pour Raspberry Pi est une carte d’extension (add-on) pour une carte de format « Plus » (A+, B+ ou Pi 2 B) avec une mémoire EEPROM intégrée. L’EEPROM comprend l’overlay au DT nécessaire pour activer la carte, et cet overlay peut aussi fournir des paramètres.

    L’overlay de la carte HAT est automatiquement chargé par le firmware après la DTB de base, de sorte que ses paramètres sont accessibles jusqu’au chargement d’un autre overlay (ou jusqu’à ce que la portée de l’overlay soit terminée en utilisant dtoverlay =. Si pour une raison quelconque vous souhaitez supprimer le chargement de l’overlay de la carte HAT, indiquez dtoverlay = avant tout autre directive dtoverlay ou dtparam.

    Overlays et paramètres pris en charge

    Plutôt que de documenter les overlays individuels ici, nous vous invitons à lire le fichier README qui se trouve dans le répertoire des fichiers overlay  /boot/overlays. Il est régulièrement mis à jour et inclut des ajouts et modifications.

    PARTIE 4 : Dépannage et astuces

    Debugging

    Le chargeur va ignorer les overlays manquants et les mauvais paramètres, mais s’ il y a des erreurs graves comme un dtb de base manquant ou endommagé ou une fusion d’overlay échouée, le chargeur va revenir à un boot sans DT. Si cela se produit, ou si vos paramètres ne se comportent pas comme prévu, il vaut mieux vérifier les avertissements et erreurs du chargeur :

    sudo vcdbg log msg

    Le débogage supplémentaire peut être activée en ajoutant dtdebug = 1 à config.txt.

    Si le noyau ne parvient pas à démarrer en mode DT, c’est probablement parce que l’image du noyau n’a pas un marqueur valide. Utilisez knlinfo pour vérifier si ce marqueur existe, et l’utilitaire mkknlimg pour en ajouter un. Notez que les deux utilitaires sont également inclus dans le répertoire de scripts des souces actuelles du noyau du raspberrypi.

    Vous pouvez créer une représentation (semi-)lisible par un humain de l’état actuel du DT comme ceci :

    dtc -I fs /proc/device-tree

    ce qui peut être utile pour voir l’effet de la fusion d’overlays sur l’arborescence d’origine.

    Si les modules du noyau ne se chargent pas comme prévu, vérifier qu’ils ne sont pas dans la liste noire (dans /etc/modprobe.d/raspi-blacklist.conf); il ne devrait pas être nécessaire de les mettre en liste noire lorsque vous utilisez l’Arborescence Matérielle. Si cela ne donne rien, vous pouvez également vérifier que le module exporte les bons alias corrects en vérifiant que la valeur compatible existe dans  /lib/modules/<version>/modules.alias. Si ce n’est pas le cas, votre driver n’avait pas soit :

    .of_match_table = xxx_of_match,

    ou :

    MODULE_DEVICE_TABLE(of, xxx_of_match);

    A défaut, depmod a échoué ou les modules mis à jour n’ont pas été installés sur le système de fichiers cible.

    Force une Arborescence Matérielle spécifique

    Si vous avez des besoins très spécifiques qui ne sont pas pris en charge par les DTB par défaut (en particulier, les gens qui expérimentent avec l’approche tout-DT utilisée par le projet de ARCH_BCM2835), ou si vous voulez juste vous lancer dans l’écriture de vos propres DT, vous pouvez forcer le chargeur à charger un fichier DTB alternatif de la façon suivante :

    device_tree=my-pi.dtb

    Désactiver l’utilisation de l’Arborescence Matérielle

    Si vous décidez que le DT n’est pas pour vous (ou à des fins de diagnostic), vous pouvez désactiver le charfment du DT et forcer le noyau à revenir à l’ancien comportement en ajoutant :

    device_tree=

    à config.txt. Notez, cependant, que les futures versions du noyau pourraient à un moment donné ne plus soutenir cette option.

    Raccourcis et variantes de syntaxe

    Le chargeur accepte quelques raccourcis :

    dtparam=i2c_arm=on
    dtparam=i2s=on

    peut être réduit en :

    dtparam=i2c,i2s

    (i2c est un alias de i2c_arm, et  =on est par défaut). Il accepte également toujours les versions longues – device_tree_overlay et device_tree_param.

    Vous pouvez également utiliser des séparateurs alternatifs si vous pensez que = est galvaudé. Tout ce qui suit est accepté :

    dtoverlay thing:name=value,othername=othervalue
    dtparam setme andsetme='long string with spaces and "a quote"'
    dtparam quote="'"

    Ces exemples utilisent des espaces pour séparer la directive du reste de la ligne au lieu de =. Ils utilisent également une virgule pour séparer l’overlay de ses paramètres, et setme prend la valeur par défaut 1/true /on/okay.

    Conclusion

    Qu’on le veuille ou non, l’utilisation de l’Arborescence Matérielle devient la norme sur le Raspberry Pi. Les utilisateurs « lamba » n’ont pas à s’en inquiéter, et cela devrait même leur faciliter la vie.

    Ceux qui sont concernés sont ceux qui interviennent dans la création de cartes d’extension, en particulier les cartes HAT, ou dans le développement de périphériques destinés au Raspberry Pi.

    Avec cette traduction, j’espère avoir fourni un point de départ pour tous ceux qui sont intéressés mais rechignent à se lancer dans la doc. en anglais.

    Cette traduction n’est certainement pas parfaite et si vous pensez que certaines parties (mots, phrases, tournures…) méritent d’être revues, n’hésitez pas à me contacter via les commentaires ci-dessous !

    Sources


    0 0

    Ubuntu-Logo_250pxUbuntu vient de sortir en version adaptée au processeur du Raspberry Pi 2. Il fallait en effet porter la version d’Ubuntu MATE 15.04 pour le jeu d’instructions du BCM2836 qui est un armv7.
    Cette image est fonctionnelle et basée sur la version  normale de Ubuntu armhf, et non sur la nouvelle Snappy, ce qui signifie que la procédure d’installation pour les applications est le même que pour la version desktop normale, c’est à dire qu’elle utilise apt-get.

    Ubuntu MATE pour Raspberry Pi 2 – armv7

    La distribution a été adaptée au mieux pour le Raspberry Pi 2 et on peut utiliser confortablement des applications telles que LibreOffice, qu’on utilise maintenant avec plaisir :-) Mais le débit d’E/S de la carte microSDHC est un goulot d’étranglement de sorte que l’utilisation d’une carte de classe 6 ou 10 est fortement recommandée. Si vous construisez vous-même l’image, il vaut mieux utiliser le système de fichiers f2fs.

    Vous aurez besoin d’une carte microSD de 4 Go ou plus pour copier l’image. Le système de fichiers peut être redimensionné pour occuper l’espace non alloué de la carte microSD, comme pour Raspbian.

    NOTA : Il n’y a pas de compte utilisateur prédéfini. La première fois que vous démarrez l’image de Ubuntu MATE, elle fonctionne grâce à un assistant de configuration avec lequel vous pouvez créer votre propre compte d’utilisateur et configurer vos paramètres régionaux. Le premier démarrage est assez lent, mais une fois la première configuration effectuée, les démarrages suivants sont beaucoup plus rapides.

    ubuntu-mate-1504-raspberry-pi-2-screenshot_600px

    Cliquer sur l’image pour agrandir

     Télécharger le rootfs

    L’équipe de Ubuntu MATE a créé une version Ubuntu 15.04 MATE pour les appareils basés sur système de fichiers racine générique aarch32 (ARMv7). – ubuntu-mate-download_v7

    Si vous téléchargez cette image, assurez vous que son hash MD5 soit bien :

    dcbc6539d2260ddcc7bb13a963f35583

    Comme le Raspberry Pi 2- Ce système de fichiers racine est destiné aux amateurs d’ARMv7 et aux fabricants de cartes qui voudraient construire une image d’Ubuntu MATE pour leur(s) appareil(s). Afin d’adapter le système de fichiers racine pour votre appareil, vous aurez besoin :

    • d’ajouter un chargeur de démarrage
    • d’ajouter un noyau
    • d’ajouter les pilotes X.org 1.17
    • d’ajouter toute autre configuration spécifique du matériel

    Vous trouverez plus d’informations sur l’utilisation de cette ressource sur http://fra.ubuntu-mate.net/armhf-rootfs/

     Télécharger l’image pour le Raspberry Pi2

     Heureusement pour nous, l’équipe Ubuntu MATE a également créé une image -presque- toute prête pour l’utilisation avec le Raspberry Pi 2 :)

    ubuntu-mate-download

    Si vous téléchargez cette image, assurez vous que son hash MD5 soit bien :

    ea74db696bb50907a12ffbc2f2eeb4b5

     Mettre l’image sur une carte microSD

    Télécharger l’image puis extraire l’archive .img.bz2 pour obtenir le fichier image :

    bunzip2 ubuntu-mate-15.04-desktop-armhf-raspberry-pi-2.img.bz2

    Sur une machine Linux écrivez le fichier image sur la carte microSD en tant que root :

    sudo   ddrescue  -d  -D  --force  ubuntu-mate-15.04-desktop-armhf-raspberry-pi-2.img  /dev/sdX

    Le lecteur peut être monté sur un /dev/sdX quelconque : sda, sdb … Utiliser la commande lsblk pour vérifier !

    Construire le système

    NOTA :  Ces scripts ne fonctionnent que sur armhf. (https://bitbucket.org/ubuntu-mate/ubuntu-mate-rpi2)

    Ouvrez  build-image.sh et modifiez BASEDIR en fonction des besoins. Ensuite, lancez la construction (build).

    sudo ./build-image.sh

    Cela va prendre un certain temps, Il vaut mieux lancer cette opération le soir avant d’aller vous coucher 😉

    Redimensionner le système de fichiers

    Les utilitaires de redimensionnement automatique du système de fichier ne sont pas inclus. Cependant, il est pas difficile de réaliser cette opération manuellement. Une fois le système démarré :

    sudo   fdisk   /dev/mmcblk0

    Supprimer la seconde partition (d, 2), puis re-créez la en utilisant les paramètres par défaut (n, p, 2, entrée, entrée), puis écrire et sortir (w). Redémarrez le système, puis :

    sudo resize2fs /dev/mmcblk0p2

    Accélération vidéo matérielle

    Pour lire des vidéos en utilisant l’accélération matérielle du décodage vous devrez acquérir une licence MPEG-2 et/ou VC-1 dans le Raspberry Pi store. Vous pouvez ensuite utiliser omxplayer, qui utilise les bibliothèques Raspberry Pi VideoCore, et peut fournir une lecture vidéo avec accélération matérielle.

    Redirection de la sortie audio

    Vous pouvez sélectionner vers quelle sortie audio omxplayer va envoyer le son.

    Pour sortir en HDMI

    omxplayer   -o   hdmi video.mp4

    Pour sortir sur le jack ausio 3,5 mm

    omxplayer   -o   local   video.mp4

    Le système envoie le son vers la prise HDMI par défaut, si les deux prise HDMI et jack audio de 3,5 mm sont connectées. Vous pouvez, cependant, forcer le système à sortir sur une des deux prises en utilisant amixer.

    Pour sortir en HDMI

    sudo   amixer   cset   numid=3   2

    Pour sortir sur le jack ausio 3,5 mm

    sudo   amixer   cset   numid= 3   1

     Conclusion

    Pas forcément accessible par les novices en raison des opérations à réaliser, cette distribution vous permettra de tester Ubuntu 15.04 MATE sur le Raspberry Pi 2.

    N’hésitez pas à faire un retour sur votre expérience dans les commentaires ci-dessous.

    Merci à Tony qui m’a signalé cette information

     Sources


    0 0

    noobs_3_250pxDernier épisode de cette saga NOOBS. Après avoir installé NOOBS nous avons installé une distribution Raspbian que nous avons personnalisée (frambian).
    Il nous reste à intégrer cette distribution modifiée dans NOOBS, à personnaliser les écrans qui défilent pendant l’installation de NOOBS et à ajuster quelques paramètres de démarrage de NOOBS. Tout ceci est l’objet de ce troisième épisode.

    Personnaliser NOOBS : Partie 1Partie 2Partie 3

    Personnaliser NOOBS

    Tout savoir sur le partitionnement et le démarrage de NOOBS

    Avant de regarder comment NOOBS gère les partitions, vous avez devez savoir comment fonctionne le partitionnement sur le Raspberry Pi : lisez cette page (en anglais) ou celle-ci (en français) si vous ne savez pas comment ça se passe au démarrage d’un Raspbian installé seul sur sa carte microSD.

    Nommage des partitions

    samsung_sd_200pxPour des raisons historiques il n’y a que 4 emplacements de partitions prévus dans la table de partition.  Les disques durs et les cartes SD et microSD ne peuvent donc avoir plus de 4 partitions primaires. Pour contourner cette limitation, une de ces partitions primaires peut éventuellement être utilisée comme partition étendue.

    Une partition étendue peut contenir un nombre illimité de partitions logiques. Sous Linux, les partitions primaires sont toujours numérotées de 1 à 4. Par exemple sur le Raspberry Pi vous trouvez des partitions appelées /dev/mmcblk0p1 à /dev/mmcblk0p4. Toutes les partitions logiques sont quant à elles, numérotées à partir de 5 (par exemple /dev/mmcblk0p5 et suivantes sur le Raspberry Pi).

    Partition d’origine

    Lorsque NOOBS est copié pour la première fois sur une carte SD au format FAT (Windows), il n’y a qu’une partition unique occupant tout l’espace sur la carte. Et c’est là que les fichiers extraits du fichier zip NOOBS sont écrits. Sous forme de tableau, on peut le représenter ainsi :

    noobs_tableau1La seule différence entre NOOBS et NOOBS Lite est que NOOBS Lite n’embarque pas les images de récupération du système d’exploitation Raspbian.

    Démarrage de NOOBS – bas-niveau

    Lorsque le Raspberry Pi est mis sous tension avec une carte NOOBS insérée :

    1. Il charge et exécute bootcode.bin depuis la partition FAT /dev/mmcblk0p1, exactement comme il le fait pour les images de systèmes autonomes. (Ce comportement est intégré dans le firmware interne du BCM2835 sur tous les Raspberry Pi, et ne peut donc pas être modifié.)
    2. bootcode.bin détecte que start.elf est manquant, alors il charge et exécute recovery.elf en lieu et place.
    3. Le lancement de recovery.elf passe alors le firmware en mode « NOOBS » – il utilise recovery.img lieu de kernel.img, recovery.cmdline au lieu de cmdline.txt, et il définit le système de fichiers racine comme étant recovery.rfs.
    4. recovery.elf lit alors recovery.cmdline puis charge et exécute recovery.img (le noyau Linux), en lui passant la totalité de la ligne de commande qu’il a lue à partir de recovery.cmdline et lui disant de charger recovery.rfs comme système de fichiers racine (un initramfs contenant divers scripts ainsi que l’application NOOBS GUI).
    5. Ce qui se passe ensuite dépend du ‘mode’ dans lequel NOOBS fonctionne…

    Démarrage de NOOBS – en mode de configuration

    Si  runInstaller  est présent dans la ligne de commande du noyau, c’est que c’est la première fois que NOOBS démarre, il entre alors dans le «mode de configuration ‘. Ensuite :

    1. Il diminue automatiquement la taille de la  première (et seule) partition /dev/mmcblk0p1, lui donnant juste la taille nécessaire pour contenir les fichiers qu’il contient, et la nomme «RECOVERY». Pour NOOBS Lite cette partition aura une taille d’environ XMB; pour NOOBS cette partition aura une taille d’environ XGB.
    2. Il crée une nouvelle partition étendue /dev/mmcblk0p2, en utilisant la presque totalité de l’espace restant sur la carte.
    3. Il crée une nouvelle petite partition au format ext4 (32 Mo) /dev/mmcblk0p3 tout au bout de la carte, et la nomme «SETTINGS». C’est utilisé pour stocker les fichiers qui informent NOOBS des OS qui sont installés (et sur quelles partitions ils sont installés), quel OS doit être chargé par défaut, quelle langue/clavier NOOBS doit utiliser, etc.
    4. Il supprime runInstaller de recovery.cmdline pour empêcher que le processus de configuration ne se déclenche à nouveau.

    Les paramètres sont stockés sur une petite partition auxiliaire plutôt que dans la même partition /dev/mmcblk0p1 que tout le reste. Ceci est dû à la «directive principale» de NOOBS – « NOOBS n’écrit jamais  dans la première partition FAT. Dans la première partition FAT, jamais NOOBS n’écrit…. ». Ne jamais écrire dans la première partition (après être sorti du « mode de configuration »), garantit que la première partition ne peut jamais devenir corrompue; et ainsi le «mode de récupération» de NOOBS sera toujours accessible (pour permettre de réinstaller les OS), peu importe ce qui se passe dans le reste de la carte SD.

    Les partitions deviennent alors :

    noobs_tableau2

    Démarrage de NOOBS – en mode récupération

    Si NOOBS détecte qu’aucun système d’exploitation n’a encore été installé, ou si l’utilisateur appuie sur la touche Shift (ou que l’une des autres façons de déclencher ce modeest active), NOOBS entre en «mode de récupération». Cela affiche le menu d’installation des OS, permettant à l’utilisateur de choisir quel(s) système(s) d’exploitation il souhaite installer. Reportez-vous à la documentation normale pour plus de détails à propos de ce menu.

    noobs_kdrc_02Comme vous l’aurez deviné, «l’espace disponible» (Available) affiché ici est la taille de la partition étendue /dev/mmcblk0p2, qui est l’endroit où tous les systèmes d’exploitation sont installées.

    Fichiers de NOOBS

    Contrairement à ce qui se passe avec les images autonomes décrites précédemment (qui contiennent des images raw -bit à bit- des partitions ), NOOBS utilisations des archives tar compressées contenant le contenu de la partition, en parallèle avec des fichiers de configuration. NOOBS est chargé de créer effectivement les partitions sur la carte microSD elle-même, ce qui signifie que les partitions sont toujours créés à la taille « correcte » en premier lieu : il n’y a pas besoin de les redimensionner plus tard. Et contrairement aux images de partitions de bas niveau (utilisées dans les images d’OS autonomes), les archives tar ne stockent pas les blocs de disques inutilisés.

    Installation d’un système par NOOBS

    Pour le premier exemple, supposons que l’utilisateur installe uniquement Raspbian. Le fichier partitions.json (que vous pouvez voir en ligne ici) indique ensuite les partitions qui doivent être créés, la taille qu’elles doivent avoir, et avec quel système de fichiers elles doivent être formatées.

    Dans cet exemple, il créerait une partition FAT de 60 Mo (/dev/mmcblk0p5), la formaterait, puis extrairait le contenu du fichier boot.tar.xz dans cette partition de 60Mo. Comme la partition root a le flag want_maximised : true, il créerait une partition ext4 (/dev/mmcblk0p6) remplissant la totalité du reste de la partition étendue, la formaterait, et extrairait le contenu du fichier root.tar.xz dans cette partition. Cela nous donne la structure de partitionnement complète que montre le tableau vu précédemment. NOOBS exécute ensuite le script partition_setup.sh qui monte ces nouvelles partitions, et édite les fichiers (généralement uniquement cmdline.txt dans la partition de démarrage et /etc/fstab dans la partition racine) pour indiquer à Raspbian sur quelles partitions il a été installé. Cela permet de se régler Raspbian soient stockées sur / dev / mmcblk0p5 et / dev / mmcblk0p6 au lieu de / dev / mmcblk0p1 et / dev / mmcblk0p2. Et enfin, il met à jour la partition de paramètres avec des détails sur le système d’exploitation que nous venons d’installer.

    noobs_tableau3

    Démarrage de NOOBS – démarrage d’un système

    Si l’utilisateur n’appuie pas sur la touche Maj (SHIFT), et que NOOBS détecte (en utilisant les informations stockées sur la partition de configuration SETTINGS) qu’un seul système d’exploitation amorçable a été installé, il démarre automatiquement sur ce système d’exploitation. Il le fait en lisant les données dans la partition de configuration SETTINGS pour déterminer la partition de démarrage pour ce système d’exploitation, puis demande au firmware un « redémarrage à chaud » en utilisant la partition de démarrage de l’OS.

    Ceci «redémarre» le firmware et charge le fichier start.elf depuis la partition spécifiée (normalement /dev/mmcblk0p5 si un seul système d’exploitation est installé). Tout se passe ensuite comme pour le démarrage autonome décrit au haut de cette page : start.elf charge kernel.img et lit cmdline.txt, puis kernel.img utilise la ligne de commande qui lui a été passée pour déterminer sur quelle partition le système de fichiers racine est stocké (normalement /dev/mmcblk0p6 si un seul système d’exploitation est installé), il charge ensuite le reste du système d’exploitation.

    Si au lieu d’un seul OS plusieurs systèmes d’exploitation ont été installés, NOOBS affiche alors le menu OS-boot, qui permet à l’utilisateur de choisir sur quel système d’exploitation il souhaite démarrer.

    risc_os_install_13Une fois que l’utilisateur a sélectionné une option (si on arrive au bout du délai (time-out) du menu, c’est le dernier OS qui a démarré qui est sélectionné par défaut), le boot se fait comme décrit dans le paragraphe ci-dessus, NOOBS utilisant les informations de la partition de configuration pour déterminer quelle partition utiliser pour un « redémarrage logiciel  » comme partition de démarrage.

    Démarrage de RISC OS avec NOOBS

    Le seul petit bémol à ce qui précède est que RISC OS ne comprend pas les tables de partition. Il doit être installé sur une partition spécifique avec un décalage donné. C’est la raison de la présence du fichier riscos-boot.bin, et c’est ce qui explique que la partition ‘root‘ de RISC OS est encore stockée au format raw (brut) et pas sous forme d’une archive. Cependant NOOBS gère automatiquement tous ces détails pour vous, et il est toujours possible d’installer d’autres systèmes d’exploitation conjointement à RISC OS.

    Personnaliser l’installation de frambian

    noobs_FB

    Installation automatique d’un OS avec NOOBS

    Même si vous utilisez votre Pi headless (sans affichage), vous pouvez toujours utiliser NOOBS pour installer facilement le système d’exploitation de votre choix. Pour configurer NOOBS afin d’installer automatiquement et « silencieusement » un OS spécifique (c’est à dire sans nécessiter d’intervention de l’utilisateur), suivez ces étapes :

    1. Copiez le dossier du système d’exploitation que vous souhaitez installer dans le répertoire  /os . Vous pouvez aussi supprimer tous les autres systèmes d’exploitation contenus dans le répertoire  /os  de sorte qu’il ne reste que le système d’exploitation que vous avez choisi d’installer.
    2. Si le système d’exploitation que vous souhaitez installer automatiquement a plusieurs configurations d’installation disponibles (flavours), éditez le fichier flavours.json pour qu’il ne contienne que la configuration que vous souhaitez installer.
    3. Éditez le fichier recovery.cmdline dans le répertoire racine de NOOBS et ajoutez silentInstall à la liste des arguments.

    Maintenant, lorsque vous démarrez votre Raspberry Pi en utilisant une carte SD contenant cette version modifiée de NOOBS que vous venez de créer, il installe automatiquement l’OS que vous avez choisi et le démarrage après la fin de l’installation

    Comment créer une version personnalisée d’un OS

    peintre_200px

    Personnalisez votre version de NOOBS

    Il y a deux cas principaux dans lesquels vous voudrez peut-être créer une version personnalisée de l’un des OS standard qui sont disponibles pour l’installation via NOOBS :

    • Vous êtes enseignant et vous souhaitez déployer facilement une version de système d’exploitation personnalisé contenant un ensemble prédéfini de paquets et de fichiers sur un certain nombre de cartes SD (par exemple pour mettre des Raspberry Pi préconfigurés à disposition d’une classe ou  remettre rapidement un certain nombre de Raspberry Pi en configuration « usine »).
    • Vous voulez être en mesure de sauvegarder les paquets et les fichiers installés sur votre Raspberry Pi pour ne pas avoir à repartir d’une installation de base la prochaine fois.

    Les étapes qui suivent vous permettent de créer une copie modifiée de l’une des versions d’OS standard qui contient vos fichiers personnalisés, des paquets que vous avez installé et une configuration personnalisée.

    1. Téléchargez une version de base de NOOBS depuis http://downloads.raspberrypi.org/NOOBS_latest
    2. Extrayez les fichiers de NOOBS de l’archive
    3. Accédez au répertoire os
    4. Créez une copie du dossier contenant la version du système d’exploitation que vous souhaitez modifier et renommez le avec un autre nom.
    5. Modifiez les champs suivants dans le fichier os.json qui se trouve dans le dossier que vous venez de créer
      1. « name » – Remplacer le nom de l’OS avec le nom de votre version d’OS
      2. « description » – Remplacer la description de l’OS standard par celle de la version de votre système d’exploitation personnalisé.
    6. [Optionnellement] Renommez ou remplacez le fichier contenant l’icône <OS>.png fichier icône .png existant avec un correspondant au nom de la coutume votre version OS
    7. [Optionnellement] Remplacez les fichiers d’image PNG dans les répertoires slides et slides_vga  par vos propres diapositives personnalisées
    8. Modifiez les champs suivants dans le fichier partitions.json contenu dans le dossier que vous venez de créer
      1. « Partition_size_nominal » – Remplacez la valeur numérique par la taille des partitions de votre version personnalisée du système d’exploitation
      2. « Uncompressed_tarball_size » – Remplacez la valeur numérique par la taille de vos archives tar du système de fichiers lorsqu’elles sont décompressées
    9. Remplacez les fichiers .tar.xz des partitions root et boot  présents dans le dossier /os par les archives tar des copies des système de fichiers de boot et rootfs créées à partir de votre version personnelle de système d’exploitation NOTA : Ces instructions supposent que vous n’utilisez qu’un seul système d’exploitation à la fois avec NOOBS – Elles ne fonctionneront pas si vous exécutez plusieurs systèmes d’exploitation à partir de une seule carte SD.
      Le nom de ces archives tar doit correspondre aux labels utilisés dans partitions.json. (Ci-dessous remplacez  <label>  par le nom de la distribution).
    1. Pour créer l’archive tar de rootfs, vous devrez exécuter
      tar -cvpf <label>.tar /* --exclude=proc/* --exclude=sys/* --exclude = dev/pts/*

      depuis la racine du système de fichiers de votre version personnalisée de l’OS . (faites cd / pour vous y rendre). Ensuite vous devez compresser l’archive obtenue avec

      xz  -9  -e  <label>.tar
    2. Pour créer l’archive tar de boot, vous devrez exécuter
      tar  -cvpf <label>.tar

      dans le répertoire racine de la partition de démarrage (/boot) de votre version personnalisée de l’OS. Vous devez ensuite compresser l’archive obtenue avec

      xz  -9  -e  <label>.tar

    Application à frambian

    Tout ça c’est bien beau… Mais revenons à notre distribution  frambian  et voyons comment l’intégrer dans NOOBS.

    Rappel des épisodes précédents

    noobs_custom_SD_200pxDans le deuxième article de cette série vous avez vu comment préparer votre distribution et produire les deux archives boot.tar.xz et root.tar.xz. Ce sont ces deux fichiers que nous allons réutiliser. Ils doivent être sur votre clé USB. Je ferai ces manipulation sous Windows 8.1, les personnes débutant avec le Raspberry Pi ayant rarement une machine Linux installée… Pour les Linuxiens de longue date, vous transposerez sans mal sur votre système préféré.

    Prenez une carte microSD neuve ou formatez en une avec SDFormater 4.0. Pour ma part je reste fidèle aux Samsung EVO que je trouve à moins de 9 € dans le supermarché voisin.

    Formatage de la carte microSD

    Pour ces essais, j’ai réutilisé une carte SD de 16 Go contenant auparavant Raspbian en autonome (c’est ce qui explique qu’elle s’appelle BOOT). J’ai formaté la carte avec SDFormatter 4.0 avec les options Format Type : Full Erase et Format Size Adjustment : On.

    Copie des fichiers de NOOBS

    Décompressez les fichiers à partir de l’archive de NOOBS que vous avez téléchargée sur le site de la Fondation. Copiez ces fichiers sur la carte microSD que vous destinez à NOOBS: carte_sd_noobs_01Le dossier qui nous intéresse est le dossier os.

    carte_sd_noobs_02Ce dossier contient lui même 2 dossiers : Data_Partition et Raspbian. Double-cliquez sur Raspbian

    carte_sd_noobs_03

    On retrouve dans ce dossier les deux fichiers boot.tar.xz et root.tar.xz qui sont ceux du Raspbian d’origine. Ce sont ces deux fichiers que nous allons remplacer plus loin par nos fichiers personnalisés.

    NOTA : Attention, les logiciels comme WORD ou le Bloc Note insèrent des caractères non compatibles avec Linux. Préférez leur un utilitaire comme Notepad++ par exemple. Ou éditez les avec nano sous Linux.

    Modification du fichier partitions.json

    On commence par éditer partitions.json qui contient d’origine :

    {
    "partitions": [
    {
    "label": "boot",
    "filesystem_type": "FAT",
    "partition_size_nominal": 60,
    "want_maximised": false,
    "uncompressed_tarball_size": 20
    },
    {
    "label": "root",
    "filesystem_type": "ext4",
    "partition_size_nominal": 2730,
    "want_maximised": true,
    "mkfs_options": "-O ^huge_file",
    "uncompressed_tarball_size": 750
    }
    ]
    }

    La première section (« label »: »boot ») correspond à la partition /boot, la seconde section (« label »: »root ») correspond au rootfs, la partition principale de Raspbian.

    Ne modifiez pas la première partie, puisque rien n’a changé dans cette partition /boot sur le Raspberry Pi :

    pi@raspberrypi /boot $ sudo xz -l boot.tar.xz
    Flux    Blocs    Compressé  Décompressé  Ratio  Vérif   Nom de fichier
    1       1     10,5 MiB     19,2 MiB  0,548  CRC64   boot.tar.xz

    La taille de la partition peut rester à 60 Mo (« partition_size_nominal »: 60) et la taille du fichier décompressé est bien de 20 Mo environ ( « uncompressed_tarball_size »: 20).

    C’est la deuxième section qui nous intéresse car nous avons allégé cette partie de Raspbian :

    pi@raspberrypi / $ sudo xz -l root.tar.xz
    Flux    Blocs    Compressé  Décompressé  Ratio  Vérif   Nom de fichier
    1       1    161,5 MiB    725,8 MiB  0,223  CRC64   root.tar.xz

    Pour ma part, j’ai modifié cette section comme suit :

    "partition_size_nominal": 2000,
    "want_maximised": false,
    "mkfs_options": "-O ^huge_file",
    "uncompressed_tarball_size": 750

    En effet, 2 Go me suffisent comme taille de partition (« partition_size_nominal »: 2000), je ne souhaite pas non plus que la partition occupe toute la place disponible sur la carte microSD (« want_maximised »: false), et enfin l’archive occupera 750 Mo une fois décompactée comme l’indique xz -l.

    Suppression du fichier flavours.json

    Supprimez le fichier flavours.json. Il contient les informations pour que le système démarre sur Scratch. Sans la partie graphique ni Scratch, ça ne sert plus à rien ! Supprimez Raspbian_-_Boot_to_Scratch.png qui ne sert plus non plus, pour les mêmes raisons.

    Remplacement des fichiers de Raspbian

    Supprimez boot.tar.xz et root.tar.xz et remplacez les par vos versions personnalisées (celles qui sont sur votre clé USB 😉 )

    Premier test

    A partir de là vous disposez d’une version de NOOBS qui peut booter sur votre système personnalisé : je vous laisse tester…

    NOTA : Avant les tests pensez à faire un sauvegarde du contenu de votre carte. Après le test de démarrage, vous pourrez rapidement reformater la carte microSD avec SDFormatter, puis remettre les fichiers dessus et repartir de ce point.

    Modifier les champs du fichier os.json

    Le fichier os.json contient les informations sur le système et sur l’utilisateur. Nous allons également les actualiser. D’origine, le fichier os.json contient :

    {
    "name": "Raspbian",
    "version": "wheezy",
    "release_date": "2015-05-05",
    "kernel": "3.18",
    "description": "A community-created port of Debian wheezy, optimised for the Raspberry Pi",
    "url": "http://www.raspbian.org/",
    "username": "pi",
    "password": "raspberry",
    "supported_hex_revisions": "2,3,4,5,6,7,8,9,d,e,f,10,11,12,14,19,1040,1041"
    }

    Que je modifie en

    {
    "name": "Frambian",
    "version": "wheezy",
    "release_date": "2015-08-02",
    "kernel": "4.0",
    "description": "Raspbian allégé - Ne comporte pas la partie graphique...",
    "url": "http://www.raspbian.org/",
    "username": "pi",
    "password": "raspberry",
    "supported_hex_revisions": "2,3,4,5,6,7,8,9,d,e,f,10,11,12,14,19,1040,1041"
    }

    Vous pouvez modifier le nom de l’OS, mais aussi le nom d’utilisateur et le mot de passe par défaut.

    Changement de l’icône

    RaspbianL’icône affichée par NOOBS dans la fenêtre de choix de l’OS est par défaut celle qui figure à droite de ce texte. Pour personnaliser l’installation de frambian, il faut fournir à NOOBS une icône mesurant 40 x 40 pixels. Ce sera le logo de framboise314 qui tiendra lieu d’icône pour frambian :

    logoIl suffit de remplacer l’icône de Raspbian par votre icône. Attention, le nom doit respecter le nom de la distribution (ici : Frambian.png)

    Renommer le dossier de Raspbian

    Pour personnaliser complètement la version de NOOBS avec frambian, il faut encore renommer le dossier /os/Raspbian en /os/frambian (encore une fois en respectant le nom de la distribution, y compris la majuscule de la première lettre).

    Encore un test

    Oui, je sais je teste, je teste… Mais dites vous bien que si vous suivez un tutoriel comme celui-ci (ou un autre) sans tester SYSTÉMATIQUEMENT chaque étape, vous risquez de vous retrouver à la fin du tutoriel avec un « truc », voire un « machin » qui ne fonctionne pas… bouee_sauvetage_200pxÇa se finit en général par un commentaire désobligeant du genre « J’ai suivi ce tutoriel, il marche pô !… » ou encore « Ça marche pas, avez vous une idée de l’endroit où j’ai pu me tromper ?« … et le pauvre auteur est bien embêté pour vous aider parce qu’il y a des dizaines d’instructions dans le tutoriel et il ne peut pas savoir ce que vous avez oublié, raté, ce qui n’a pas fonctionné pour une raison ou une autre. Parfois ça fait plus d’un an que le tutoriel a été publié et il a coulé bien de l’eau sous les ponts et des applis sur les Raspberry Pi 😉 Conclusion, n’hésitez pas, sauvegardez à chaque étape, testez, recommencez… C’est uniquement comme ça que vous apprendrez, et pas en suivant à la lettre un ‘tuto » sans comprendre ce qu’il raconte.

    Donc ici, si vous testez le démarrage de NOOBS vous obtenez ceci :noobs_frambian_02

    Mais que voici donc une belle copie d’écran (Eh oui, elle sert la première partie de cet article…). On y voit qu’ayant supprimé le répertoire Raspbian pour le remplacer par Frambian, j’ai causé une belle frayeur à NOOBs qui s’en est allé sur le web quérir la version de Raspbian en ligne, ce qui est indiqué par la prise RJ45 à droite de la ligne Raspbian.

    Par contre vous pouvez voir que ma distribution Frambian a bien été prise en compte par NOOBS 😉 et avec son icône s’il vous plait ! La description est également bien affichée. Comme j’utilise une carte microSD de 16Go NOOBS m’indique que 15 Go sont disponibles (Available)

    Les plus téméraires sélectionneront Frambian en cliquant sur la case à gauche de sa ligne, puis choisiront le français comme langue d’installation avant de lancer l’installation en cliquant sur l’icône Install, en haut à gauche et…

    noobs_frambian_03… assisteront à la première installation de leur système personnalisé, non sans essuyer la larme qui perle en ce moment historique…

    La lecture de la carte SD sur une machine Linux après installation de frambian permet de vérifier que les partitions annoncées ci-dessus ont bien été créées par NOOBS :

    /dev/sdb3                 31M  4,5M   25M  16% /media/SETTINGS
    /dev/sdb5                 60M   20M   41M  33% /media/boot
    /dev/sdb6                2,0G  817M  1,1G  44% /

    Elle est pas belle, la vie ?

    Il y a encore quelques améliorations à apporter à notre NOOBS pour que tout soit encore plus facile, et plus joli.

    Personnaliser le Diaporama d’installation

    Le dossier  os/Raspbian/slides_vga  contient les diapos qui sont affichées pendant l’installation pour vous faire patienter.

    slides_vgaCes diapos s’appellent tout simplement A.png, B.png … G.png. Pour personnaliser encore un peu plus l’installation de NOOBS, vous pouvez créer vos propres diapos. Elles doivent faire exactement 387 x 290 pixels, avec une résolution de 72 pixels/pouce. Leur nombre peut varier, mais elles doivent garder la même convention de nommage : les lettres consécutives de l’alphabet, en majuscule, suivies de .png.

    Pour faire ces modifs, vous choisirez le logiciel qui vous convient le mieux. The Gimp est pas mal, PhotoFiltre aussi. Ceux qui aiment utiliser un bazooka pour écraser un moustique utiliseront Photoshop (oh ! je plaisante !!). Pour ma part et à ma plus grande honte, j’utilise PhotoImpact de Ulead, une antiquité qui doit dater du millénaire précédent, mais qui en quelques clics de souris me permet d’obtenir le résultat que j’attends…

    Au démarrage pas de surprise, on retrouve exactement le même écran que précédemment lors du test de NOOBS avec Frambian. Cochez la case de Frambian, choisissez le français comme langue d’installation, puis cliquez en haut à gauche sur l’icône Install.

    C’est maintenant que les choses changent puisque les écrans qui défilent sont ceux que vous avez vous même créé.

    frambian_noobs_install_02a

    Les messages sont en français  et NOOBS est en train de créer une partition pour Frambian…

    frambian_noobs_install_03

    frambian_noobs_install_04

    frambian_noobs_install_05

    frambian_noobs_install_06

    frambian_noobs_install_07

    Ça vous a plu ? A vous de jouer maintenant si vous voulez personnaliser votre NOOBS vous avez tous les éléments en main. Soyez patient, lisez bien les infos avant de vous lancer, testez, sauvegardez… On ne le dira jamais assez.

    Et puis si vous voulez tester Frambian, la version de NOOBS spéciale framboise314, elle vous attend sagement, il suffit de cliquer sur ce lien pour la télécharger !

    Et pour vérifier le téléchargement :

    •  SHA1 : 776665938E6335597FF1035DA9698E92BCF977A0
    • MD5  :  077CB16F025B17F17829E42D0C222F05

    Bien entendu ce ne sont pas les seules possibilités de NOOBS qui nous réserve encore quelques surprises. Suivez moi si vous voulez encore en savoir plus 😉

    Configurer la langue par défaut, la partition de boot…

    Éditez le fichier recovery.cmdline dans le répertoire principal de NOOBS et ajoutez les arguments suivants le cas échéant :

    • lang=<langage codé sur 2 lettres> (exemple : lang=fr ou lang=en)
    • keyboard=<type de clavier codé sur 2 lettres> (exemple : keyboard=fr ou keyboard=us)
    • display=<numéro du mode d'affichage> (exemple : display=1 ou display=3)
    • partition=<numéro de partition> (exemple : partition=5)

    Si les deux premiers paramètres sont assez parlants, le troisième indique à NOOBS quel mode vidéo il doit utiliser pour l’affichage :

    • 1 = HDMI
    • 2 = HDMI safe mode (mode sans échec)
    • 3 = composite PAL
    • 4 = composite NTSC

    Le mode 2  ou « mode sans échec » peut être utilisé pour essayer de démarrer avec une compatibilité maximale HDMI

    Le quatrième paramètre indique la partition qui est sélectionnée par défaut, celle sur laquelle NOOBS bootera après le time-out du menu.

    NOTA : Les valeurs que vous sélectionnerez dans l’interface graphique de NOOBS remplaceront ces paramètres.

    Ignorer l’écran d’accueil (spashscreen) et booter directement

    Après avoir installé le (ou les) système(s) d’exploitation que vous avez choisi(s), vous pouvez ajouter le fichier suivant dans le répertoire racine de NOOBS pour que la partition indiquée soit bootée, sans passer par les menus de NOOBS. Le splashscrren (l’écran gris avec une framboise au milieu) ne sera pas affiché.

    1. Ajouter un fichier texte nommé autoboot.txt dans le répertoire racine de NOOBS.
    2. Ajouter boot_partition = <numéro de partition> dans le fichier et l’enregistrer sur le disque.

    Cela permettra également d’éviter que les écrans de NOOBS soient affichés au démarrage. Le numéro de la partition peut être trouvé en exécutant sudo fdisk -l : la partition sera l’une des partitions FAT32 affichées  /dev/mmcblk0p5  serait la partition 5.

    NOTA : Une fois un fichier autoboot.txt présent dans le répertoire racine de NOOBS, il n’y a plus aucun moyen de forcer l’affichage de l’interface graphique de NOOBS. Si vous voulez afficher NOOBS il faudra supprimer (ou renommer) le fichier autoboot.txt.


    Dépannage de NOOBS

     Que faire si l’appui sur la SHIFT n’agit pas

    Essayez d’appuyer sur la touche SHIFT uniquement lorsque l’écran gris avec le logo du Raspberry Pi apparait, au lieu de la maintenir appuyée tout le temps du démarrage.

    Démarrer en « Safe Mode »

    Pour démarrer dans une « boîte à outils » en ligne de commande plutôt que de lancer l’interface graphique de  NOOBS, vous pouvez soit :

    1. Ajouter  rescueshell  à la liste d’arguments dans le fichier  recovery.cmdline  qui se trouve dans le répertoire principal de NOOBS.
    2. Insérer un cavalier (jumper) entre les broches 5 et 6 du connecteur GPIO (P1). Si vous avez du matériel connecté au GPIO ou une carte d’extension connectée su le port GPIO, il peut arriver que la broche 5 soit mise à la masse. Ceci déclenche accidentellement le « Safe Mode ». Le paragraphe suivant vous indique comment remédier à cela.

    Ne pas démarrer en « Safe Mode »

    Si la broche 5 du GPIO est mise à la masse lors du démarrage de NOOBS, celui-ci démarre en mode console (shell). Pour éviter le démarrage en « Safe Mode » (une « boîte à outil » en ligne de commande), vous pouvez ajouter  disablesafemode  à la liste d’arguments dans le fichier  recovery.cmdline  qui se trouve dans le répertoire principal de NOOBS.

    Utiliser le GPIO pour passer en Mode Récupération

    Pour forcer le passage en Mode Récupération au démarrage de NOOBS et afficher l’interface de NOOBS, vous maintenez normalement la touche MAJ (SHIFT) enfoncée pendant le démarrage. S’il n’y a pas de clavier ou si l’appui sur la touche SHIFT n’est pas détecté, suivez les instructions suivantes pour que l’interface de NOOBS s’affiche au démarrage :

    1. Ajoutez  gpiotriggerenable  à la liste d’arguments dans le fichier  recovery.cmdline  qui se trouve dans le répertoire principal de NOOBS.
    2. Rebootez

    Pour forcer le passage en Mode Récupération au démarrage, connectez la broche 3 du GPIO (P1) à la masse GND (broche 25). Si la broche 3 du GPIO reste en l’air (déconnectée) NOOBS va démarrer normalement sur l’OS installé.

    Forcer le Mode Récupération au démarrage (prioritaire sur le GPIO et le clavier)

    Si vous n’êtes pas en mesure d’utiliser le GPIO ou le clavier pour déclencher le passage en Mode Récupération, vous pouvez :

    1. Ajouter  forcetrigger  à la liste d’arguments dans le fichier  recovery.cmdline  qui se trouve dans le répertoire principal de NOOBS.
    2. Rebooter

    Notez que lorsque cette option est activée, le Mode Récupération est affiché chaque fois que vous démarrez à partir de votre carte NOOBS (jusqu’à ce que vous modifiiez  recovery.cmdline  en enlevant  forcetrigger ).

    Désactiver l’utilisation du clavier pour passer en mode récupération

    Dans quelques rares cas, il se peut que NOOBS détecte un appui sur la touche SHIFT de votre clavier alors que vous n’avez rien fait ;). Dans de tels cas, il est possible de désactiver l’utilisation du clavier pour déclencher le Mode Récupération.

    Pour éviter qu’une pression sur la touche SHIFT ne fasse entrer NOOBS dans le Mode  Récupération au démarrage (si vous un clavier problématique qui déclenche le Mode Récupération à tort chaque fois que vous démarrez), vous pouvez :

    1. Ajouter  keyboardtriggerdisable  à la liste d’arguments dans le fichier  recovery.cmdline  qui se trouve dans le répertoire principal de NOOBS.
    2. Rebooter

    Modifier le mode de la sortie vidéo

    Par défaut, NOOBS envoie la vidéo sur la prise HDMI à la résolution préférée de votre écran, même si aucun écran HDMI est connecté. Si vous ne voyez rien sur votre écran HDMI ou si vous utilisez la sortie composite, appuyez sur la touche 1, 2, 3 ou 4 de votre clavier pour sélectionner la sortie HDMI, le mode sans échec HDMI, la sortie composite en PAL ou en NTSC.

    • 1 = HDMI
    • 2 = HDMI safe mode (mode sans échec)
    • 3 = composite PAL
    • 4 = composite NTSC

    Si vous n’avez pas de clavier, vous pouvez toujours modifier le mode d’affichage utilisé par NOOBS en modifiant le fichier recovery.cmdline  situé à la racine du répertoire de Noobs avant le premier démarrage en ajoutant l’argument suivant:

    • display=<numéro du mode d'affichage> (exemple :  display=1 oo display=3)

     

    Reconstruire NOOBS

    NOTA : Ceci nécessite au moins 6 Go de mémoire.

    Récupérer les dépendances

    Sur Ubuntu :

    • sudo apt-get install build-essential rsync texinfo libncurses-dev whois unzip

    Lancer le script de construction

    • ./BUILDME.sh

    Buildroot construira ensuite le logiciel et toutes les dépendances, puis rangera le résultat dans le répertoire  output .

    Buildroot compile par défaut plusieurs fichiers en parallèle, en fonction du nombre de cœurs du processeur équipant la machine utilisée.

    Si la machine sur laquelle vous compilez NOOBS a un CPU quad core, mais pas beaucoup de RAM, vous pouvez en réduire le nombre pour diminuer le swapping :

    •  buildroot cd; make menuconfig
    • Dans  « Build options » ==> « Number of jobs to run simultaneously » réglez le nombre de tâches simultanées.

    Exécuter votre version de NOOBS

    Pour préparer une carte microSD avec une version de NOOBS que vous venez de construire, vous devrez :

    • Formater en FAT une carte microSD de 4 Go ou plus
    • Remplacez le répertoire  /os  du répertoire  /output  avec la copie contenue dans la version actuelle de NOOBS (lien de téléchargement)
    • Copiez les fichiers existant dans le répertoire  /output  sur la carte microSD

    Infrastructure de Buildroot

    Pour ajouter des paquets supplémentaires :  cd buildroot ; make menuconfig

    Le paquet du logiciel Recovery est dans : buildroot/package/recovery

    Configuration de noyau utilisée : buildroot/kernelconfig-recovery

    Principales différences avec  bcmrpi_defconfig :

    • CONFIG_BLK_DEV_INITRD=y – support de initramfs
    • CONFIG_INPUT_EVDEV=y – support de evdev inclus
    • CONFIG_USB_HID=y – driver usb HID inclus
    • Tous les modules désactivés

    Modifier la source de Qt

    Les sources sont dans le dossier recovery. Soyez attentif au fait que les écrans d’interface utilisateur apparaîtront plus grand dans Qt Creator que lorsqu’ils seront déployés sur un Raspberry Pi. vous pouvez augmenter la taille des polices de caractères de deux points pour compenser.

    Certaines constantes peuvent être modifiées dans config.h

    Entourez le code qui apppelle les classes spécifiques de Qt Embedded (comme QWSServer) entre

    #ifdef Q_WS_QWS

    et

    #endif

    De façon que le projet soit également compilé et puisse être testé sous un Qt standard.

    Ajouter/Mettre à jour des traductions

    Références:

    http://qt-project.org/doc/qt-4.8/i18n-source-translation.html

    http://qt-project.org/doc/qt-4.8/linguist-manual.html

    Pour mettre en place « crochet » (hook) Git pour mettre à jour automatiquement les fichiers de traduction, exécutez les commandes suivantes à la racine du projet :

    chmod + x pre-commit-translation-update-hook.sh
    
    cp pre-commit-translation-update-hook.sh  .git/hooks/pre-commit

    Pour ajouter une nouvelle traduction

    • Ajouter à recovery/recovery.pro ce qui suit :
      TRANSLATIONS += translation_<code_de_la_langue>.ts
    • Exécutez lupdate recovery/recovery.pro qui extrait les chaînes à partir du code source et génère/met à jour les fichiers .ts.
    • Les .ts peuvent ensuite être envoyés au traducteur, ouverts dans Qt Linguist et remplis.
    • Ajouter une ligne pour le fichier .ts dans recovery/icons.qrc, mais remplacez l’extension .ts par .qm. Ce fichier contient une liste des fichiers de ressources qui seront intégrés à l’exécutable de l’application lors de la construction.
    • Ajouter une icône du drapeau corrspondant à votre langue prise sur http://www.famfamfam.com/lab/icons/flags/  ou si vous n’y trouvez pas le drapeau dont vous avez besoin, vous pouvez utiliser une autre petite icône png en remplacement. Copiez le fichier de l’icône dans le dossier recovery/icons et ajoutez une ligne pour ce fichier dans recovery/icons.qrc.

    Jeux d’icônes utilisés

    Les jeux d’icônes actuellement utilisés sont :

    Conclusion

    Nous voici arrivés au terme de cette série de trois articles. Si vous utilisiez NOOBS uniquement pour installer un système ou le régénérer en cas de problème, vous avez pu vous rendre compte que NOOBS c’est bien plus que ça !

    Pouvoir produire et personnaliser votre propre NOOBS vous permettra d’intégrer un OS personnalisé. De plus l’installation se réduit à la copie de fichiers sur une carte microSD neuve, sortie de sa boîte, sans préparation aucune.

    Vous avez à votre disposition un outil très souple et adaptable. Profitez-en !

    Comme d’habitude, toutes les sources que j’ai utilisées sont référencées dans le texte sous forme de liens ou dans la rubrique Sources en bas des articles. Vous pourrez ainsi vérifier que je n’ai pas raconté trop de conneries mes traductions sont conformes et ne comportent pas d’interprétation erronée…

    Et puis si vous avez des remarques… les commentaires sont là pour ça…

    noobs_FB

    Personnaliser NOOBS : Partie 1Partie 2Partie 3

    ==============>>  Mise à jour du 9 août 2015    <<==============

    Puisque vous avez eu le courage de lire cette série d’articles jusqu’ici, je vous offre un Bonus!

    Suite à des demandes de lecteurs souhaitant imprimer de manière correcte ces 3 articles (ce qui n’est pas facile avec des articles en ligne…) j’ai mis ces articles en forme dans un document PDF qui est disponible en téléchargement sous licence CC-BY-NC-SA :

    page_0_300pxVous disposez en début de document d’une table des matières très complète qui vous envoie vers le paragraphe désiré avec un simple clic 😉

    Sources


    0 0

    noobs2_250pxBienvenue dans ce deuxième article consacré à la personnalisation (customisation en français 😉 ) de NOOBS.
    Après avoir installé une distribution avec NOOBS, je vous propose de personnaliser une version de Raspbian pour l’adapter à vos besoins. Pour ma part j’ai choisi de fabriquer une Raspbian allégée que j’ai baptisée Frambian… Je vous laisse deviner d’où vient le nom… 😉 Je me suis inspiré de diverses sources (en particulier CNXSoft) que vous retrouvez dans la rubrique Sources, en bas de cet article.

    Personnaliser NOOBS : Partie 1Partie 2Partie 3

    Personnaliser une distribution Raspbian

    Pourquoi Raspbian

    raspbian_osMon choix s’est porté sur Raspbian parce que c’est la distribution que j’utilise le plus. J’ai souvent besoin pour des manips ou des tests de mettre en place rapidement une distribution Raspbian. Mais bon, pour ce dont j’ai besoin, les temps de création de la carte sont longs, un tas de paquets inutiles (pour moi) encombrent l’espace disponible sur la carte. Je n’ai pas besoin de l’interface graphique et de tout ce qui tourne autour, ni de Scratch, Mathematica et autres Sonic PI… etc. etc…

    Customiser comment ?

    verre_moitie_videPour faire une distribution allégée personnalisée on a deux solutions… Le verre à moitié vide et le verre à moitié plein… Quoi, c’est pareil ? Voici comment je vois les choses :

    Pour le verre à moitié plein vous démarrez d’un verre vide et vous le remplissez. Si on parle distribution, vous partez de zéro et vous construisez votre distribution à partir de rien (from scratch), vous remplissez le verre. Projet ô combien intéressant en soi mais bon… peut être un peu long à mettre en œuvre.

    Pour le verre à moitié vide, vous partez du verre plein (la distribution fonctionnant et complète) et vous enlevez ce qui ne vous sert pas. Pour aboutir au verre à moitié vide aussi, mais en éliminant les paquets inutiles.

    Comme je suis Bourguignon d’adoption, je dirai que dans la première solution pour aboutir au verre à moitié plein il faut planter la vigne, la traiter, vendanger, presser les grappes, recueillir le jus, gérer la vinification, mettre en bouteille pour pouvoir enfin verser un demi verre de vin. Et on n’est pas certain d’avoir produit un bon vin. La deuxième solution qui consiste à sortir une bonne bouteille de la cave, verser un plein verre de vin et en boire la moitié me plait beaucoup plus…

    C’est donc la deuxième méthode que j’ai retenue : partir d’une Raspbian fraîchement installée et mise à jour, et en enlever les parties que je n’utilise pas. Vous choisirez ce qui vous convient le mieux avec la distribution qui vous intéresse.

    Pour aboutir à quoi ?

     L’objectif est une distribution légère qui occupe le minimum de place. Il va aussi falloir préparer les deux partitions qui vont être utilisées par NOOBS pour lancer l’image. Si vous ne voyez pas ce dont je parle, relisez l’article sur le démarrage du Raspberry Pi ou reportez vous au chapitre correspondant de mon livre…

    etape_01Au démarrage du système, le CPU est en veille et c’est le GPU qui démarre sur une ROM interne au SoC BCM283x. Il va alors récupérer les fichiers de démarrage (boot loader) sur la partition FAT de la carte SD. c’est ce qui explique la présence de cette partition FAT ! Ensuite, après le chargement et le démarrage du noyau Linux, c’est la partition Linux (ext4) qui travaille (rootfs). La partition FAT est quant à elle montée dans /boot.

    Vous y voyez plus clair ?

    frambianLe but du jeu après avoir enlevé les parties inutilisées de Raspbian est de récupérer les deux partitions FAT et ext4 séparément dans deux archives au format TAR, puis de  compresser ces archives en xz.

    Les anciens comme moi se souviennent de l’utilisation de la commande TAR qui permettait de sauvegarder les données sur bande ou cartouche magnétique (streamer). Ici elle servira à créer l’archive qui sera ensuite passée au format xz avec une compression LZMA.

    Préparation d'une distribution pour l'utilisation avec NOOBSChacune des partitions de la carte SD d’origine sera compressée et fournira une archive. Ces deux fichiers archives compressés sont ceux que NOOBS va utiliser pour installer notre distribution. Certains dossiers seront exclus comme /proc qui est un système de fichiers virtuel et contient des infirmations sur le système, /dev/pts qui contient les pseudo-terminaux (pty), et enfin /sys un répertoire virtuel pour les informations système. Nous verrons comment au moment de compresser les partitions.

    La partition NOOBS SETTINGS située en haut de la carte SD de NOOBS n’occupe que 32 Mo. C’est une partition  partition ext4 appelée « SETTINGS ». Elle est utilisé pour stocker les fichiers qui informent NOOBS des OS qui sont installés (et sur quelles partitions ils se trouvent), de l’OS qui doit être chargé par défaut, de la langue/clavier que NOOBS utilise, etc…

    Pour être à l’aise et pouvoir exécuter sereinement les manipulations suivantes, il vaut mieux avoir 2 cartes microSD : Une pour installer NOOBS, une pour installer Raspbian et le personnaliser. N’oubliez pas non plus que Win32DiskImager permet également de faire une sauvegarde de votre carte microSD et de garder l’archive… au cas où 😉

    Alléger Raspbian

    Ici encore pas question de réinventer le fil à couper l’eau chaude… Il existe des distributions légères de Raspbian qu’on pourrait utiliser comme Minibian ou Moebius. L’idée c’est plutôt de partir d’une Raspbian complètement à jour (et qui fonctionne) puis de la modifier en lui retirant des éléments. Dans mon cas j’ai choisi de l’alléger mais vous pouvez opter pour d’autres choix. Par exemple un media-center personnalisé, une solution domotique adaptée à vos besoins…

    Ne prenez donc pas cette partie de la personnalisation comme une obligation, mais comme une des possibilités existantes parmi tant d’autres…

    Installer Raspbian

    Bon là on reste classique ! Récupérez la dernière version de Raspbian sur le site de la Fondation. Procédez de la manière habituelle, avec Win32DiskImager. Une fois la carte microSD prête, insérez la dans le connecteur SD du Raspberry Pi, connectez l’écran, le clavier (oubliez la souris !) et mettez sous tension. Pas de configuration particulière avec raspi-config, sauf si la distribution que vous souhaitez préparer nécessite des réglages particuliers. Allez donc directement sur <Finish> et validez.

    Dégraisser le mammouth

    degraisser-mammouth_minAh non, ça c’était un ancien ministre de l’éducation nationale qui disait ça… Disons que nous allons « soumettre Raspbian à un régime sévère ».

    Commençons par regarder la place qu’occupe un Raspbian fraîchement installé (version 2015-05-11) :

    pi@raspberrypi ~ $ df -h
    Filesystem      Size  Used Avail Use% Mounted on
    rootfs          2.9G  2.4G  335M  88% /
    /dev/root       2.9G  2.4G  335M  88% /
    ...
    /dev/mmcblk0p1   56M   19M   37M  34% /boot

    Notre Root File system (rootfs) n’occupe pas moins de 2,4 Go sur la carte SD.

    Pour partir d’un Raspbian à jour il faut passer par

    sudo apt-get update
    sudo apt-get upgrade

    Et on se retrouve avec 2,5 Go occupés sur la carte.

    Ensuite un sudo rpi-update pour mettre le firmware à jour également, suivi d’un sudo reboot. Le firmware passe de la version 3.18.11-v7+ à la  4.0.9-v7+. La distribution occupe maintenant 2,6 Go (voir ci dessous)  et nous voilà fin prêt(e)s pour supprimer les paquets inutiles.

    pi@raspberrypi ~ $ df -h
    Filesystem      Size  Used Avail Use% Mounted on
    rootfs          2.9G  2.6G  138M  96% /

    J’ai adopté la méthode de Samat, à savoir un script qui recense les paquets à supprimer et qui le fait de façon automatique. Vous pouvez ainsi adapter facilement le script à vos besoins et y ajouter/retrancher ce que vous souhaitez… :

    Récupérez le fichier frambian.sh sur framboise314 avec wget ou téléchargez le ici.

    pi@raspberrypi ~ $ wget http://www.framboise314.fr/docs/frambian.sh
    --2015-07-31 11:48:28--  http://www.framboise314.fr/docs/frambian.sh
    Resolving www.framboise314.fr (www.framboise314.fr)... 185.49.20.101
    Connecting to www.framboise314.fr (www.framboise314.fr)|185.49.20.101|:80... connected.
    HTTP request sent, awaiting response... 200 OK
    Length: 1923 (1.9K) [application/x-sh]
    Saving to: `frambian.sh'
    100%[=======================================>] 1,923       --.-K/s   in 0.001s 2015-07-31 11:48:28 (2.75 MB/s) - `frambian.sh' saved [1923/1923]

    Puis modifiez les droits pour qu’il soit exécutable.

    pi@raspberrypi ~ $ sudo chmod 750 frambian.sh

    Avec nano vous pouvez ajouter/retirer les paquets dont vous avez besoin (ou pas) et personnaliser votre Raspbian à votre sauce. Une fois le script à votre goût, exécutez le :

    ./frambian.sh

    Patientez une vingtaine de minutes, pendant que frambian.sh travaille à votre place 😉

    Fin de la précédure
    Sys. fich.     Taille Util. Dispo Uti% Monté sur
    /dev/root        2,9G  1,1G  1,7G  39% /
    devtmpfs         459M     0  459M   0% /dev
    tmpfs             93M  248K   93M   1% /run
    tmpfs            5,0M     0  5,0M   0% /run/lock
    tmpfs            186M     0  186M   0% /run/shm
    /dev/mmcblk0p1    56M   20M   37M  36% /boot

    Terminer par

    sudo apt-get autoremove
    sudo apt-get clean

    On a encore quelques fichiers à nettoyer (oui je sais, j’aurais pu intégrer tout ça au script mais vous pouvez bien bosser un peu, non?) :

     sudo rm /opt/vc/src/hello_pi/hello_video/test.h264
    sudo rm /usr/lib/gcc/arm-linux-gnueabihf/4.6/cc1plus

    On peut enlever les paquets dev, listons les dans un premier temps :

    root@raspberrypi:/home/pi# sudo dpkg --get-selections | grep "\-dev"
    dpkg-dev                                        install
    libapt-pkg-dev:armhf                            install
    libc-dev-bin                                    install
    libc6-dev:armhf                                 install
    libept-dev                                      install
    libfreetype6-dev                                install
    libpng12-dev                                    install
    libraspberrypi-dev                              install
    libstdc++6-4.6-dev                              install
    libtagcoll2-dev                                 install
    libwibble-dev                                   install
    libxapian-dev                                   install
    linux-libc-dev:armhf                            install
    manpages-dev                                    install
    zlib1g-dev:armhf                                install

    Allez zou, on dit qu’on ne fera pas de développement sur ce Raspberry Pi !

    sudo apt-get remove `sudo dpkg --get-selections | grep "\-dev" | sed s/install//`

    Passez à nouveau un autoremove et un clean : Cette fois un df -h nous indique qu’on tourne aux environs de 970 Mo …

    A ce niveau vous pouvez même tenter un sudo reboot avant de supprimer le swap.

    Voyons ce que nous dit free :

    pi@raspberrypi ~ $ free
    total       used       free     shared    buffers     cached
    Mem:        948252      57656     890596          0       8452      20936
    -/+ buffers/cache:      28268     919984
    Swap:       102396          0     102396

    On voit que le swap est actif et occupe encore 100 Mo. Occupons nous de son cas !

    pi@raspberrypi ~ $sudo dphys-swapfile swapoff
    sudo dphys-swapfile uninstall
    sudo update-rc.d dphys-swapfile remove
    sudo reboot

    et on regarde ce que disent df et free :

    pi@raspberrypi ~ $ free -htl
    total       used       free     shared    buffers     cached
    Mem:          926M        55M       870M         0B       8,2M        20M
    Low:          926M        55M       870M
    High:           0B         0B         0B
    -/+ buffers/cache:        27M       898M
    Swap:           0B         0B         0B
    Total:        926M        55M       870M
    pi@raspberrypi ~ $ df -h
    Sys. fich.     Taille Util. Dispo Uti% Monté sur
    /dev/root        2,9G  867M  1,9G  32% /
    devtmpfs         459M     0  459M   0% /dev
    tmpfs             93M  240K   93M   1% /run
    tmpfs            5,0M     0  5,0M   0% /run/lock
    tmpfs            186M     0  186M   0% /run/shm
    /dev/mmcblk0p1    56M   20M   37M  36% /boot

    On continue en supprimant les python_games qui se planquent dans le dossier /home/pi et qui croyaient qu’on ne les avaient pas vus ! (on va encore gagner 20Mo)

    pi@raspberrypi ~ $ sudo rm -r /home/pi/python_games

    Allez un dernier petit effort, faites un tour dans /lib/modules.bak : il y a un double des modules qui a été créé lors de la mise à jour rpi-update. On peut aussi supprimer ce répertoire ainsi que l’original et gagner une quarantaine de Mo :

    pi@raspberrypi /lib/modules.bak $ sudo rm -r /lib/modules.bak/3.18.11-v7+/
    pi@raspberrypi /lib/modules $ sudo rm -r /lib/modules/3.18.*

    Vous adapterez bien entendu à la version en service au moment où vous ferez cette manip 😉

    Une dernière chose, si vous diffusez votre distribution et que vous ne souhaitez pas qu’on voie tout ce que vous avez tapé précédemment, effacez l’historique :

    pi@raspberrypi ~ $ history -c

    Pendant que vous avez un système tout propre sous la main, pourquoi ne pas en faire une sauvegarde avec Win32DiskImager ?

    oufJe ne sais pas pour vous, mais moi ça commence à me plaire. Notre rootfs est passé de 2,4 Go à 733 Mo (divisé par 3). Ma méthode n’est sans doute pas la meilleure, elle n’est pas optimisée, j’aurais pu améliorer le script, encore enlever d’autres fichiers inutile… etc, etc … J’accepte toutes les critiques ! Et comme disent les gamins : « C’ui qui l’dit c’est c’ui qui y est ! ». Donc si vous savez faire mieux, les pages de framboise314 vous sont ouvertes et j’attends votre article sur la cure d’amaigrissement de Raspbian… Non mais ! 😉

    “Ce n’est pas le critique qui est digne d’estime, ni celui qui montre comment l’homme fort a trébuché ou comment l’homme d’action aurait pu mieux faire. Tout le mérite appartient à celui qui descend vraiment dans l’arène, dont le visage est couvert de sueur, de poussière et de sang, qui se bat vaillamment, qui se trompe, qui échoue encore et encore – car il n’y a pas d’effort sans erreur et échec -, mais qui fait son maximum pour progresser, qui est très enthousiaste, qui se consacre à une noble cause, qui au mieux connaîtra in fine le triomphe d’une grande réalisation et qui, s’il échoue après avoir tout osé, saura que sa place n’a jamais été parmi les âmes froides et timorées qui ne connaissent ni la victoire ni l’échec”.

    Théodore Roosevelt

    theodore_roosevelt

     

    NOTA :

    • L’option –purge, passée à la commande autoremove, supprime les paquets indiqués, les dépendances logicielles et leurs fichiers de configuration
    • APT conserve une copie de chaque paquet installé et désinstallé sur carte microSD (dans le dossier /var/cache/apt/archives). L’option clean, option radicale, supprime la totalité des paquets présents dans /var/cache/apt/archives. (Cela n’a aucun impact sur les paquets installés.)

    ==================== >>  Mise à jour du 6 Août 2015  << ====================

    Un lecteur du blog, Karma que je remercie 😉 , me signale qu’il y a un bug signalé quand on enlève le paquet raspberrypi-ui-modshttps://github.com/raspberrypi/documentation/issues/233
    « apt-get purge raspberrypi-ui-mods breaks networking components » la suppression de ce paquet supprime également le fichier /etc/network/interfaces utilisé pour les connexions réseau.

    Je vous conseille de modifier frambian en rajoutant un fichier interfaces après son installation. Ce bug devrait être corrigé dans une future version, mais vérifiez la présence de /etc/network/interfaces par sécurité…

    Ajouter un fichier interfaces

    pi@raspberrypi ~ $ cd /etc/network
    pi@raspberrypi /etc/network $ ls -al
    total 24
    drwxr-xr-x  6 root root 4096 janv.  1  1970 .
    drwxr-xr-x 96 root root 4096 janv.  1  1970 ..
    drwxr-xr-x  2 root root 4096 janv.  1  1970 if-down.d
    drwxr-xr-x  2 root root 4096 janv.  1  1970 if-post-down.d
    drwxr-xr-x  2 root root 4096 janv.  1  1970 if-pre-up.d
    drwxr-xr-x  2 root root 4096 janv.  1  1970 if-up.d
    lrwxrwxrwx  1 root root   12 janv.  1  1970 run -> /run/network

    Effectivement pas de fichier interfaces en vue. Dans ce dossier, les fichiers appartiennent à root, nous allons donc nous connecter avec le compte root pour créer le fichier manquant.

    pi@raspberrypi /etc/network $ sudo su
    root@raspberrypi:/etc/network# nano interfaces

    et ajoutez ceci au fichier interfaces avant de l’enregistrer (CTRL X) :

    auto lo
    iface lo inet loopback
    
    auto eth0
    iface eth0 inet dhcp

    Ceci devrait éliminer d’éventuels problème de réseau… Merci Karma !

    ==================== >>  Fin de la Mise à jour du 6 Août 2015  << ====================

    Compresser les partitions :

    Voici venu le moment de créer nos deux archives destinées à NOOBS : boot.tar.xz et root.tar.xz. Déplacez vous à la racine de votre arborescence :

    pi@raspberrypi / $ cd /

    Vous pouvez démarrer la réalisation de l’archive de votre rootfs :

    pi@raspberrypi / $ sudo tar -cvpf root.tar /* --exclude=proc/* --exclude=sys/* --exclude=dev/pts/* --exclude=run/*

    Il faudra quelques minutes pour créer l’archive

    On va maintenant la passer en .xz

    <code>sudo xz -9 -e root.tar</code>

    Comptez un peu plus d’une heure pour que ça mouline tout ça… Vous avez encore de la bière au frigo ? 😉 Bon, il vous reste à la siroter en regardant clignoter la LED ACT…

    Vous devriez vous retrouver avec une archive de 170 Mo environ :

    -rw-r--r--   1 root root 169346868 août   2 14:31 root.tar.xz

    Vous pouvez maintenant passez à la partition /boot (ça devrait aller plus vite, la taille est beaucoup plus petite !)

    Au passage voici ce que répond tar s’il lui manque un paramètre 😉

    pi@raspberrypi /boot $ sudo tar -cvpf boot.tar
    tar: Je refuse de créer un fichier d'archive vide (oui je suis lâche)
    Pour en savoir davantage, faites : « tar --help » ou « tar --usage ».

    Bon, si on n’oublie pas l’étoile ça fonctionne mieux :

    pi@raspberrypi / $ cd /boot
    pi@raspberrypi /boot $ pi@raspberrypi /boot $ sudo tar -cvpf boot.tar  *

    On obtient un fichier de 20 Mo qu’il ne reste qu’à compresser avec xz :

    pi@raspberrypi /boot $ ls -al boot.tar
    -rwxr-xr-x 1 root root 20183040 août   2 15:40 boot.tar
    pi@raspberrypi /boot $ sudo xz -9 -e boot.tar
    pi@raspberrypi /boot $ ls -al boot.tar.xz
    -rwxr-xr-x 1 root root 11053916 août   2 15:40 boot.tar.xz

    Et ça se termine avec un boot.tar.xz de 11 Mo.

    Récupérer les fichiers sur une clé USB

     Pour transférer les archives nouvellement créées, j’ai opté pour un transfert par clé USB. Ça permettra à ceux qui n’ont pas encore fait ce genre de manip de voir comment ça se passe…

    La clé USB est utilisée sur diverse machines, elle est donc formatée en FAT, ce qui permet de la passer d’une machine équipée d’un OS libre à une autre dont l’OS est propriétaire. Bon, d’un GNU/Linux à un Windows, quoi…

    Première opération, insérer la clé dans un port USB libre du Raspberry Pi. Ma clé est équipé d’une LED qui clignote, indiquant qu’il se passe des trucs.

    Sur la console du Raspberry Pi, tapez dmesg. Vous avez sur l’écran l’affichage des messages du noyau.

    Avec Linux vous avez un noyau, avec Windows vous n’avez que des pépins 😛

    Vous devriez donc obtenir quelque chose de ce genre. Si ce n’est pas le cas, changez de clé. Si ça ne marche toujours pas… je sais pas, moi, brûlez un cierge ou faites une incantation !

    [ 8075.943988] usb 1-1.2: new high-speed USB device number 5 using dwc_otg
    [ 8076.044977] usb 1-1.2: New USB device found, idVendor=abcd, idProduct=1234
    [ 8076.045003] usb 1-1.2: New USB device strings: Mfr=1, Product=2, SerialNumber=3
    [ 8076.045021] usb 1-1.2: Product: UDisk
    [ 8076.045037] usb 1-1.2: Manufacturer: General
    [ 8076.045053] usb 1-1.2: SerialNumber: \xffffffd0\xffffff89\xffffff89
    [ 8076.046280] usb-storage 1-1.2:1.0: USB Mass Storage device detected
    [ 8076.048526] scsi host0: usb-storage 1-1.2:1.0
    [ 8077.044711] scsi 0:0:0:0: Direct-Access     General  UDisk            5.00 PQ: 0 ANSI: 2
    [ 8077.046772] sd 0:0:0:0: [sda] 15728640 512-byte logical blocks: (8.05 GB/7.50 GiB)
    [ 8077.047229] sd 0:0:0:0: [sda] Write Protect is off
    [ 8077.047258] sd 0:0:0:0: [sda] Mode Sense: 0b 00 00 08
    [ 8077.047661] sd 0:0:0:0: [sda] No Caching mode page found
    [ 8077.047685] sd 0:0:0:0: [sda] Assuming drive cache: write through
    [ 8077.051519]  sda:
    [ 8077.054273] sd 0:0:0:0: [sda] Attached SCSI removable disk
    [ 8077.082318] sd 0:0:0:0: Attached scsi generic sg0 type 0

    En observant la réaction du système on voit bien qu’il s’est rendu compte de quelque chose… Il indique le temps de l’événement entre crochets (c’est le temps en secondes depuis le démarrage du système).

    Tiens ! Un nouveau périphérique USB [8075.943988] ! Ah, mais c’est une mémoire de masse [8076.046280] ! Bon, je la connecte sur sda  [8077.046772] (c’est le nom de votre clé pour le système). Ça va, vous suivez ?

    Nous allons « monter » (en fait rattacher) la clé USB au système de fichiers pour que Raspbian puisse l’utiliser. Un répertoire est prévu pour ce genre d’opération : /media.

    pi@raspberrypi ~ $ sudo  mount  /dev/sda  /media

    Vous pouvez vérifier que la clé est bien montée :roll:

    pi@raspberrypi ~ $ ls /media
    __NOOBS_CUSTOM__
    potar.ino
    programme_ARDUINO.docx
    pwm.jpg
    schema_shield.png
    shield_multifonctions.jpg

    La commande ls affiche bien le contenu de la clé USB, tout va bien.

    J’avais créé sur la clé un dossier __NOOBS_CUSTOM__ dans lequel je souhaite copier mes fichiers :

    pi@raspberrypi ~ $ cd /media/__NOOBS_CUSTOM__
    pi@raspberrypi /media/__NOOBS_CUSTOM__ $ sudo cp /*.xz ./
    pi@raspberrypi /media/__NOOBS_CUSTOM__ $ sudo cp /boot/*.xz ./
    pi@raspberrypi /media/__NOOBS_CUSTOM__ $ ls -al
    total 176188
    drwxr-xr-x  2 root root      4096 août   2 15:51 .
    drwxr-xr-x 35 root root      8192 janv.  1  1970 ..
    -rwxr-xr-x  1 root root  11053916 août   2 15:51 boot.tar.xz
    -rwxr-xr-x  1 root root 169346868 août   2 15:51 root.tar.xz
    pi@raspberrypi /media/__NOOBS_CUSTOM__ $ sync
    

    Terminez par sync ce qui assure la copie correcte des fichiers sur la clé et vous permet de la retirer sans risquer de l’endommager.

    Vous devriez retrouver vos deux fichiers sur la clé USB :

    cle_usbPensez à démonter la clé avant de la retirer du port USB du Raspberry Pi.

    pi@raspberrypi ~ $ sudo umount /dev/sda

    Conclusion

    Dans ce deuxième épisode, nous avons vu comment, à partir d’une distribution Raspbian fraichement installée et mise à jour, créer une distribution personnalisée.

    Dans le cas que j’avais choisi, la personnalisation s’est faite en enlevant des paquets inutilisés, mais rien ne vous empêche de préparer une distribution dans laquelle non seulement vous supprimerez des paquets, mais vous en installerez d’autres qui vous servent régulièrement.

    noobs_FB

    A la fin de la personnalisation de Raspbian nous avons récupéré les partitions rootfs et boot sous forme de deux archives compressées qui vont s’intégrer dans NOOBS pour une installation facilitée.

    Personnaliser NOOBS : Partie 1Partie 2Partie 3

     Sources


    0 0

    noobs_250pxEn anglais, un NOOB est un newbie, un novice un débutant. C’est un terme un peu péjoratif utilisé dans le milieu des jeux en ligne.
    C’est le nom qui a été choisi pour l’utilitaire destiné à installer facilement le système d’exploitation du Raspberry Pi.
    NOOBS (New Out Of the Box Software = Nouveau Logiciel -fonctionnant- au sortir de la boîte) permet à un débutant d’installer un système d’exploitation pour le Raspberry Pi sans connaissances particulières.

    Personnaliser NOOBS : Partie 1Partie 2Partie 3

    Nos NOOBS à Nous

    Pour tout vous dire c’est le premier titre auquel j’avais pensé pour cette série d’articles… Mais bon, avouez que pour les moteurs de recherche ce n’est pas forcément très parlant 😉

    L’idée ici est d’utiliser NOOBS pour charger rapidement une distribution personnalisée.

    Niveau : Utilisateurs avertis (un utilisateur averti en vaut deux!)

    Personnaliser NOOBS – Article 1/3

    Dans le premier article, je vous présente NOOBS, et j’explique comment réaliser simplement des copies d’écran du démarrage de NOOBS. On voit trop souvent des tutoriels sur NOOBS avec des images à pleurer… Ce sont en fait des photos d’écran, jamais prises d’équerre, un peu floutes, avec du moirage… J’ai eu le même problème lors de la rédaction de mon premier livre. J’avais pris des images en essayant de faire au mieux, mais le retour de mon éditeur était clair… Bof ! Pas utilisable ! Pas net ! Pas bon, quoi…

    Alors je me suis retourné vers les créateurs de NOOBS. Bon sang de bonsoir ! Ils présentent bien des copies d’écran superbes… J’ai obtenu de l’aide pour capturer les écrans : merci à eux !

    image_noobs_origine_600px

    Image provenant du site github NOOBS

    Hein ? C’est pas beau ? Eh bien si vous lisez le premier article, vous pourrez faire des copies d’écran aussi belles puisqu’après quelques discussions sur les forums, tests… j’ai pu mettre en œuvre une solution pour capturer les écrans de NOOBS. C’est celle que je présente dans ce premier article.

    NOTA : L’installation de NOOBS via KRDC est strictement identique à l’installation de NOOBS directement sur le Raspberry Pi équipé de son écran/clavier/souris. Vous pouvez donc utiliser cet article pour une installation « normale » de NOOBS 😉

    Personnaliser NOOBS – Article 2/3

    Dans ce deuxième article nous allons préparer une distribution personnalisée. Un Raspbian « Lite » ou « Allégé ». A quoi ça sert d’embarquer sur la carte tout un tas de trucs dont vous n’allez pas vous servir ? Par exemple vous montez un serveur sur votre framboise. Avez vous besoin de tout l’environnement graphique ? et de Mathematica ? etc…

    Dans cet article nous verrons comment retirer les choses « inutiles » (dans notre cas) et créer une distribution qui va peser beaucoup moins que le Raspbian d’origine. Après vous adapterez à vos besoins.

    A partir de ce Raspbian Lite, il s’agira de créer les fichiers archives qui seront intégrés dans NOOBS, ce qui clôturera cette deuxième partie.

    NOTA : Bien entendu vous pourrez appliquer cette méthode à toute autre distribution que vous réaliserez. Celle -ci n’étant utilisée qu’à titre d’exemple.

    Personnaliser NOOBS – Article 3/3

    Troisième et dernier article de la série, nous allons customiser ou personnaliser NOOBS en intégrant NOTRE distribution afin qu’elle soit lancée automatiquement au démarrage. On en profitera pour personnaliser les quelques écrans qui défilent pendant l’installation.

    Au passage vous en saurez plus sur le fonctionnement de NOOBS et son organisation, comment il gère sa carte SD…

    Tout ça va se terminer par un test de l’ensemble et pour ceux qui sont intéressés, vous aurez à disposition en téléchargement l’image de NOOBS personnalisée incluant le Raspbian Lite.

    Présentation de NOOBS

    tux_noobs

    Alors que l’installation de Raspbian requiert la mise en ouvre d’un utilitaire (Win32DiskImager) chargé de partitionner la carte microSD avec

    • une partition FAT (Windows) assurant le démarrage du système
    • une partition ext4 (GNU/Linux) destinée au RFS (Root File System)

    NOOBS se contente d’une carte microSD « brute de fonderie ». Il suffit de télécharger NOOBS sur le site de la Fondation, décompresser l’archive dans un dossier de votre machine et copier les fichiers obtenus sur la carte microSD. Et c’est tout ! La carte est prête à âtre utilisée sur le Raspberry Pi. J’ai publié plusieurs articles à ce sujet.

    Les 2 versions de NOOBS

    NOOBS existe en deux versions :

    NOOBS Offline and network install

    Cette version « complète » de NOOBS (742Mo) embarque le système d’exploitation Raspbian. Elle permet également d’installer une version de Raspbian en mode graphique (Desktop) ou démarrant par défaut sur Scratch (utile pour les enseignants). (Toutes) Les autres distributions seront téléchargées avant installation, ce qui nécessite une connexion Internet filaire si vous choisissez une autre distribution que Raspbian.

    NOOBS Lite Network install only

    Cette deuxième version « légère » (21,8Mo) ne contient aucun système d’exploitation. Sa faible taille garantit un téléchargement et une installation rapides. Toutes les distributions seront donc OBLIGATOIREMENT téléchargées en ligne. Ceci peut être gênant sur des Raspberry Pi A ou A+ ne disposant pas de connecteur Ethernet.

     C’est quoi NOOBS ?

    NOOBS c’est d’abord un utilitaire qui facilite l’installation des systèmes d’exploitation sur la carte microSD des Raspberry Pi même par un débutant. Il est écrit en C++ et les sources sont disponibles sur Github.

    noobs_downloadCommencez par télécharger la version de NOOBS qui vous intéresse sur la page https://www.raspberrypi.org/downloads/. Il est possible d’utiliser un téléchargement direct ou en Torrent.

    Lors de la rédaction de cet article, c’est la version 1.4.1 qui était en ligne pour le version Offline et la 1.4 pour la version Lite (image ci-dessus). Vous adapterez en fonction de la version existante au moment de votre lecture.

    Les hash SHA-1 fournis vous permettent de vérifier que l’archive téléchargée est conforme à celle qui existe sur le site. Il suffit qu’un bit change pour que le hash soit totalement différent.

    Sous Windows utilisez File Checksum Integrity Verifier (FCIV) qui est un utilitaire de vérification SHA1 en ligne de commande téléchargeable ici. Sous Linux tapez

    sha1sum nom_du_fichier_a_verifier

    Installer NOOBS

    Une fois l’archive récupérée et enregistrée, décompressez la dans un dossier.

    nobbs_fichiers

    Ce sont les fichiers de ce dossier que vous allez simplement copier sur une carte microSD. Si la carte a déjà été utilisée par ailleurs, il est conseillé de la formater avec SD Card Formater (en version 4.0 actuellement).

    Au passage remarquez le dernier fichier de la liste (riscos-boot.bin)… Nous en reparlerons dans la troisième partie de cette série. Ce fichier est utilisé lors de l’installation de RISC OS par NOOBS.

     Copier l’écran de NOOBS (Screenshot)

    VNC

    Votre carte microSD est prête. Les fichiers sont copiés dessus… Parfait. Nous allons pouvoir indiquer à NOOBS qu’il va être contrôlé à distance, au lieu d’utiliser le clavier et l’écran du Raspberry Pi.

    VNC (Virtual Network Computing, littéralement « informatique virtuelle en réseau ») est un système de visualisation et de contrôle de l’environnement de bureau d’un ordinateur distant. Il permet au logiciel client VNC de transmettre les informations de saisie du clavier et de la souris à l’ordinateur distant, possédant un logiciel serveur VNC à travers un réseau informatique. VNC est indépendant du système d’exploitation ; un client VNC installé sur n’importe quel système d’exploitation peut se connecter à un serveur VNC installé sur un système d’exploitation différent. Il existe des clients et des serveurs VNC pour la plupart des systèmes d’exploitation. Plusieurs clients peuvent se connecter en même temps à un unique serveur VNC. (Wikipedia)

    Pour lancer VNC, il faut simplement ajouter vncinstall à la fin de la ligne contenue dans le fichier recovery.cmdline. Attention, faites une copie du fichier avant de le modifier, on ne sait jamais… Utilisez un utilitaire qui n’ajoute pas de caractères cachés mais perturbateurs. Pour ma part j’utilise NotePad++ lorsque je suis sous Windows.

    Démarrage de NOOBS

    Insérez votre carte microSD dans le logement prévu pour cette carte sur le Raspberry Pi. Connectez l’écran HDMI, connectez le câble micro USB de l’alimentation secteur, enfin branchez le bloc d’alimentation dans la prise secteur.

    Après l’écran coloré de démarrage du Raspberry Pi, vous allez voir s’afficher sur l’écran :

    Ip : SIOCGIFFLAGS : No such device

    Pas de panique, c’est le signe que vncinstall a bien été exécuté

    Adresse IP du Raspberry Pi

    Retrouvez l’adresse IP de votre Raspberry Pi car il a démarré en DHCP et votre Box/routeur lui a attribué une adresse. Oui certes, mais comment fais-je me direz vous ?

    Connectez-vous sur votre Box, votre routeur, enfin ce que vous utilisez pour vous sortir sur Internet (chaque appareil étant différent, reportez vous à la documentation de votre Box ou routeur pour savoir comment procéder).

    Sur mon routeur TP-Link, un écran affiche les machines connectées, ce qui permet de repérer l’adresse IP du Raspberry Pi.

    nobbs_adresse_ipL’adresse du Raspberry Pi est donc 192.168.1.103 (toutes les autres machines -floutées- étaient identifiées par leur nom. Il ne restait que cette ligne).

    Lancement de KRDC sur la machine Linux

    Sur une machine Linux, lancez krdc. Si KRDC (KDE Remote Desktop Connection) n’est pas disponible sur votre distribution, installez le – sous debian par exemple :

    apt-get install krdc

    Puis exécuter krdc depuis un terminal. La fenêtre de krdc s’ouvre

    noobs_kdrc_01_600px

    Cliquez sur la copie d’écran pour agrandir

    Ici krdc ayant déjà été utilisé, l’adresse de mon Raspberry Pi apparait. Lors de la première tentative, saisissez l’adresse IP du Raspberry Pi dans la ligne Connect to vnc et validez.

    noobs_install_01_600px

    Cliquez sur la copie d’écran pour agrandir

    Si vous regardez cet écran vous voyez que certaines lignes (Raspbian – Data Partition et Scratch) sont illustrée à droite par une carte SD. Cela signifie que ces options sont accessibles directement depuis NOOBS, sans nécessiter de connexion Internet.

    Les lignes suivantes (OpenELEC_Pi1, OpenELEC_Pi2, OSMC_Pi1, Arch… les autres sont plus bas et apparaissent sur la copie d’écran suivante…) comportent une prise RJ45 à l’extrémité droite de la ligne. C’est l’indication que leur installation ne peut se faire directement depuis la carte microSD et que le Raspberry Pi doit obligatoirement être connecté à Internet via une liaison filaire.

    Copie d’écran de NOOBS

    Et voilà, miracle de la technologie (?) dans la fenêtre de KRDC  apparait l’écran d’accueil de NOOBS. Elle est pas belle la vie ? Profitez en pour faire une copie d’écran – Eh, débrouillez pour trouver comment on fait, je ne vais quand même pas tout vous dire 😉

    Donc à partir de maintenant qu’on se le dise, je ne veux plus voir de blog avec d’infâmes des photos illustrant l’installation de NOOBS ! Et Pi c’est tout !

    noobs_install_02_600px

    Cliquez sur la copie d’écran pour agrandir

    Installation de Raspbian avec NOOBS

    Allez nous voilà avec NOOBS démarré et qui n’attend que vos ordres. Sur la copie d’écran ci-dessus, j’ai déplacé l’ascenseur de la fenêtre vers le bas et fait apparaître complètement Arch, mais aussi Pidora, OSMC_Pi2 et RISC_OS ! Et ne me dites pas que vous n’avez pas le choix 😉

    noobs_install_03_600px

    Cliquez sur la copie d’écran pour agrandir

    Configurer la langue de la distribution

    On continue la configuration, cette fois ça se passe en bas de l’écran : une liste déroulante vous permet de choisir la langue de la distribution que vous allez installer. Par défaut c’est l’Anglais (UK) qui est sélectionné.  Ouvrez la liste et choisissez Français. Enfin, vous choisissez ce que vous voulez… Si vous parlez le finnois vous pouvez choisir suomi😉

    Cliquez sur la langue choisie.

    noobs_install_04_600px

    Cliquez sur la copie d’écran pour agrandir

    Automatiquement le clavier adapté à la langue est sélectionné dans la liste Keyboard. Ces informations seront transmises aux distributions lors de leur installation.

    Choisir la distribution à installer

    noobs_install_05_600px

    Cliquez sur la copie d’écran pour agrandir

    Pour montrer le fonctionnement de NOOBS, j’ai choisi d’installer Raspbian [RECOMMENDED] : cliquez simplement sur la case à cocher située sur la gauche de la ligne de la (ou des) distribution(s) que vous souhaitez installer.

    Démarrer l’installation de raspbian

     Tout est prêt pour l’installation de notre distribution :

    noobs_install_clic

    Cliquez sur l’icône Install en haut et à gauche de l’écran… Faites vous couler un café ou décapsulez une bière bien fraîche* selon vos préférences.
    * à consommer avec modération bien entendu !

    noobs_install_06_600px

    Cliquez sur la copie d’écran pour agrandir

    Avant de déguster votre boisson, répondez quand même à la question que vous pose NOOBS : Êtes vous sûr, certain, convaincu… que votre carte microSD ne contient pas les photos de votre petit dernier en train de manger tout seul sa purée de carottes ? Alors répondez Oui et toutes les données encore présentes sur la carte seront -irrémédiablement- effacées et remplacées par NOOBS et les OS que vous choisirez.

    noobs_install_08_600px

    Cliquez sur la copie d’écran pour agrandir

    Et c’est parti ! L’installation démarre, ce qu’indique la barre de progression située en bas de la fenêtre. En même temps regardez au dessus de la barre de progression, la fenêtre va afficher un certain nombre d’informations utiles -ou pas- pour vous permettre de patienter. Ici on vous rappelle que le login pour Raspbian est pi et que le mot de passe est raspberry.

    noobs_install_09_600px

    Cliquez sur la copie d’écran pour agrandir

    Ici on vous rappelle que pour lancer l’interface graphique de Raspbian (le bureau) il faut saisir startx sur la ligne de commande. Eh, ne laissez pas réchauffer votre bière, pensez à boire un coup.

    noobs_install_10_600px

    Cliquez sur la copie d’écran pour agrandir

    Ici on vous invite à visiter la boutique Raspberry Pi pour télécharger des applications gratuites mais aussi certaines payantes…

    noobs_install_11_600px

    Cliquez sur la copie d’écran pour agrandir

    Une petite explication de ce qu’est Raspbian

    noobs_install_12_600px

    Cliquez sur la copie d’écran pour agrandir

    Et nous voici arrivés au bout de nos peines. Le système d’exploitation est enfin installé, le verre de bière est vide et nous allons pouvoir continuer.

    Cliquez sur le bouton OK. NOOBS va redémarrer. Nous sommes connectés à distance avec KRDC, par conséquent ne vous étonnez pas si celui-ci vous indique qu’il a été sauvagement déconnecté !

    Sur l’écran HDMI connecté au Raspberry Pi vous allez voir l’écran coloré apparaître, puis après quelques instants le système installé démarre et affiche l’utilitaire de configuration raspi-config

    Ça ne nous arrange pas, puisque le but est de continuer à utiliser NOOBS à distance pour pouvoir faire des captures d’écran dignes de ce nom !

    Redémarrez le Raspberry Pi (soyez fou, débranchez la prise micro USB, attendez 2 ou 3 secondes et rebranchez la…). Tout de suite après l’apparition de l’écran coloré appuyez sur la touche SHIFT du clavier… NAN, pas celui qui est connecté sur le poste de prise de main à distance, celui qui est connecté sur le Raspberry Pi ! Ralala faut tout vous expliquer 😉

    Vous devez revenir à un écran noir affichant en haut et à gauche :

    Ip : SIOCGIFFLAGS : No such device

    Sur le poste distant relancez KRDC, il devrait trouver un serveur pour se connecter maintenant…

    noobs_kdrc_02Différence avec le premier affichage, sur cette copie d’écran (elle est jolie, non?) NOOBS indique que Raspbian est installé…

    Fichiers de configuration de raspbian

    L’icône Edit config à droite de l’icône Install en haut de la fenêtre est maintenant accessible. Cliquez dessus :

    noobs_kdrc_03Vous disposez d’un éditeur qui va vous permettre de personnaliser les fichiers config.txt et cmdline.txt depuis NOOBS. C’est la possibilité de paramétrer facilement les systèmes d’exploitation avant leur démarrage.

    Une aide en ligne est accessible via l’icône Online help.

    Enfin si vous cliquez sur Exit vous sortez de NOOBS, le Raspberry Pi redémarre pour aboutir à nouveau sur l’écran de raspi-config et … KRDC est à nouveau déconnecté !

    Installer deux OS avec NOOBS

    Vous pouvez également choisir d’installer un autre système en même temps que Raspbian. Il suffit de cocher la (les) cases voulues et de relancer l’installation.

    NOTA : Attention cependant si vous avez précédemment installé et utilisé Raspbian et que vous relancez cette installation multi OS, votre précédente version de Raspbian sera écrasée. Faites attention aux données qui pourraient s’y trouver !

    Choix des OS à installer avec NOOBS

    risc_os_install_01

    Comme précédemment cochez la case située à gauche de la ligne de Raspbian. Descendez avec l’ascenseur pour faire apparaître RISC OS et cochez également la case correspondante (image ci-dessus). Remarquez l’icône à droite de la ligne de RISC OS : elle représente un connecteur RJ45 Ethernet. La distribution va donc être téléchargée depuis un dépôt en ligne.

    En bas de l’écran vous avez l’indication de la taille de la distribution et de l’espace restant sur votre carte microSD.

     risc_os_install_02

    Installation des deux systèmes d’exploitation

    Cliquez sur l’icône Install en haut et à gauche de la fenêtre. Comme précédemment confirmez l’écrasement des données présentes sur la carte microSD en cliquant sur OUI.

    risc_os_install_03L’installation de RISC OS démarre. Cette fois NOOBS indique « Downloading and extracting filesystem« , ce qui montre que RISC OS est en cours de téléchargement. Euhhhh vous pouvez vous verser une autre bière 😉

    risc_os_install_04Après un moment l’indication devient « Writing OS image« , les opérations continuent de se dérouler tranquillement. Au passage un écran de promotion pour Scratch. Ce sont ces écrans que nous personnaliserons dans un prochain article…

    risc_os_install_05Maintenant quelques infos sur RISC OS.

    risc_os_install_06

    risc_os_install_07

    NOOBS a maintenant terminé l’installation de RISC OS. Il est passé à celle de Raspbian pour lequel il crée la partition.

    risc_os_install_08Celle là on l’a déjà vue…

    risc_os_install_09Du genre bon c’est long, OK mais bois une gorgée de bière et tu va bientôt pouvoir t’éclater avec ton Raspberry Pi…

    risc_os_install_10

    Boy YawningOui… c’est un peu long mais patience, ça se termine bientôt…

    risc_os_install_11

    risc_os_install_12

    Mode récupération de NOOBS

    Voilà, vous voyez, je vous l’avais dit 😉 L’installation est terminée. Remarquez le message For recovery mode, hold SHIFT. Imaginez que l’un de vos OS connaisse quelque souci, un plantage… Lors d’un prochain redémarrage appuyez sur la touche SHIFT pour accéder à l’écran de récupération qui vous permettra de réinstaller le système proprement (les modifs et les données seront perdues !).

     Cliquez sur OK pour clore l’installation. Si vous étiez connecté à distance KRDC perd la connexion. L’écran du Raspberry Pi affiche de nouveau la plage colorée puis NOOBS démarre.

    risc_os_install_14

    Choix du système d’exploitation par défaut

    On voit ici que nos deux systèmes sont bien indiqués comme étant installés. Vous pourrez donc par la suite démarrer au choix sur l’un ou l’autre.

    risc_os_install_13Comme nous avons installé deux systèmes, au premier démarrage suivant l’installation, NOOBS demande de choisir celui qui va démarrer par défaut. Et voilà le multiboot !

    Changer le système d’exploitation par défaut

    Un clic de souris et votre système va booter. Votre choix sera mémorisé. Lors des prochains démarrages, si vous ne faites rien, NOOBS lancera le même système après une courte attente.

    risc_os_install_15Le compte à rebours est affiché dans la barre de titre de la fenêtre. Ici il vous reste 4 secondes pour modifier le choix par défaut qui est Raspbian. Si vous ne faites rien, c’est cet OS qui va booter.

    Conclusion

    Dans ce premier article, vous avez pu voir comment installer NOOBS sur une carte microSD, vous connecter depuis KRDC pour réaliser de superbes copies d’écran (screenshot) si vous en avez besoin, installer au choix un ou deux systèmes, choisir celui qui va démarrer et enfin restaurer un système défectueux.

    noobs_FB

    Personnalisation de NOOBS !

    Dans le deuxième article je vous invite à créer une distribution personnalisée à partir de Raspbian. C’est cette distribution que nous intègrerons dans NOOBS au cours du troisième article. On y va ?

    Personnaliser NOOBS : Partie 1Partie 2Partie 3


    Warnning: Do NOT Get Caught While Searching!!
    Your IP : - Country : - City:
    Your ISP TRACKS Your Online Activity! Hide your IP ADDRESS with a VPN!
    Before you searching always remember to change your IP adress to not be followed!
    PROTECT YOURSELF & SUPPORT US! Purchase a VPN Today!
    0 0

    wheezy-jessie_250pxAu revoir Wheezy, bienvenue à Jessie, la nouvelle version de Raspbian.
    Jessie ? C’est qui Jessie ? Est-ce que ce ne serait pas la poupée cow-girl dans « Toy Story 2 ».
    Oui, c’est ça ! Mais là on n’est pas dans Toy Story mais bien dans le Raspberry Pi et c’est une Debian 8 adaptée à notre framboise qui arrive !
    Yee-Haw
    Les versions précédentes de Raspbian étaient basée sur Debian Wheezy (le pingouin qui a perdu son pouet dans « Toy Story 2 »). Raspbian a maintenant été mis à jour vers la nouvelle version stable de Debian, appelée Jessie.

    Raspbian Jessie

    Alors quoi de neuf?

    Beaucoup des changements survenus entre Wheezy et Jessie sont invisibles pour l’utilisateur final. Le système sous-jacent a été modifié pour améliorer la performance et la flexibilité, en particulier en ce qui concerne le contrôle des processus système. Comme pour toute mise à jour, il y a de nombreuses corrections de bugs et des améliorations. En même temps que la mise à niveau vers Jessie, un tas de changements et des améliorations ont été apportés à l’interface utilisateur du bureau.

    Interface utilisateur

    Démarrage en mode graphique

    La première chose que tous ceux qui démarrent la nouvelle version « Jessie » remarquent est que le nouveau comportement par défaut est de démarrer directement sur l’interface graphique du bureau (environnement Desktop), et pas en ligne de commande Linux. Cette décision a été prise parce que ce comportement est le comportement normal de tous les ordinateurs modernes ; l’interface par défaut pour un ordinateur personnel en 2015 est une interface graphique de bureau, pas seulement du texte sur un écran. Il est encore possible de régler le Raspberry Pi pour qu’il démarre en ligne de commande (note de framboise314 : encore heureux !) pour les personnes qui préfèrent ce fonctionnement – il faut simplement changer le paramètre pertinent dans l’application Raspberry Pi Configuration décrite ci-dessous.

    jessie-toy-story-theory-andys-mom

    Nouveau look

    Lorsque le bureau se lance, vous remarquerez peut-être quelques légers ajustements touchant l’apparence des objets comme les menus, les cases à cocher et les boutons radio. Ceci est dû au fait que l’apparence de Raspbian est maintenant basée sur la version 3 de GTK+, la boîte à outils utilisée pour créer l’interface utilisateur utilisée dans l’environnement de bureau LXDE.
    L’ancienne version de GTK+2 est petit à petit remplacée par la version 3 dans de nombreuses applications, de sorte que ce changement était devenu inévitable – la nouvelle apparence ne présente pas un changement énorme, mais elle a l’air un peu plus moderne. La plupart des applications dans Raspbian utilisent encore la version GTK+2, mais le thème PiX pour GTK+2 a été modifié pour le mettre en conformité avec celui de GTK+3.

    jessie_nouveau_look

    Un nouveau look pour Raspbian Jessie… Vous aimez ?

    Icône d’éjection

    jessie_ejectVous remarquerez sur la barre de menu qu’il y a maintenant une icône d’éjection (dans le coin en haut à droite). Ceci est une nouvelle fonctionnalité qui permet d’éjecter les clés USB (et autres) en toute sécurité, sans risque de perte de données. Il est en effet un peu risqué de simplement débrancher une clé/un disque dur USB, en particulier si vous venez d’y copier un fichier. Le système gère l’écriture sur disque en tâche de fond, et cette écriture prend un certain temps. jessie_eject2Si vous retirez la clé/le disque avant que l’écriture ne soit terminée, vous allez corrompre le fichier et risquez de perdre des données. En cliquant sur l’icône d’éjection (ci-dessus entourée en rouge)  puis en sélectionnant le lecteur à éjecter dans le menu, le système termine son écriture puis vous invite à enlever la clé quand l’opération est complètement terminée.
    Un bémol cependant, puisque quand j’ai voulu éjecter ma clé USB le système demande un mot de passe pour root et…. ça n’a pas marché (il va falloir creuser un peu cette fonction 😉 )

    jessie_eject3

    Applications bureautiques

    Un des principaux objectifs des créateurs du Raspberry Pi est non seulement d’en faire un grand ordinateur pas cher pour l’éducation, mais aussi d’en faire un grand ordinateur pas cher… tout court.

    jessie_libre_office_03_600pxPour ça, il faut qu’on puisse faire avec un Raspberry Pi le même genre de choses qui se fait sur un Mac ou sur un PC. C’est pourquoi la Fondation inclut les applications qui devraient plaire aux utilisateurs. Dans cette version de Jessie, vous trouverez donc la suite bureautique LibreOffice et le client de messagerie Claws Mail.

    jessie_libre_office_01_600px

    Cliquez pour agrandir

    jessie_libre_office_02_600px

    Cliquez pour agrandir

    LibreOffice est une suite bureautique complète qui est compatible avec les fichiers Microsoft Office. Elle comprend un traitement de texte, un tableur, un outil de présentation graphique, un logiciel de dessin vectoriel et un programme de base de données. Tous les habitués de Microsoft Office devraient se sentir à l’aise avec ces logiciels. La suite a été optimisée pour le Raspberry Pi, et fonctionne plutôt bien, en particulier sur Raspberry Pi 2.

    Claws Mail est un client de messagerie pour ceux d’entre nous qui sont assez vieux jeu pour préférer ne pas gérer leurs emails via un navigateur. Il prend en charge tous les protocoles de messagerie courants, et offre toutes les fonctionnalités d’un client de messagerie autonome comme Windows Mail ou Thunderbird.

    Outils Java

    jessie_javaIl y a aussi deux nouvelles applications dans la rubrique Programmation – ce sont deux nouveaux environnements pour l’écriture d’applications Java, appelés BlueJ et Greenfoot (de l’Université de Kent et Oracle).

    jessie_java01_600px

    Cliquez pour agrandir – © raspberrypi.org

    Si vous êtes intéressé(e) par l’apprentissage de Java, ou si vous êtes déjà un(e) programmeur(euse)  Java confirmé(e), jetez-y un coup d’œil. Il y a quelques exemples de projets pour les deux environnements dans /home/pi/Documents.

    Réglages et configuration

    jessie_preferencesIl y a plusieurs nouvelles rubriques de paramétrage dans cette version. Elles figurent dans la rubrique Préférences du menu principal.

    jessie_raspi_config_01La première est Raspberry Pi Configuration. C’est une version graphique de l’ancienne application de ligne de commande raspi-config. Elle fournit les mêmes fonctionnalités avec une interface plus agréable (note de framboise314 : si on est en mode graphique 😉 ).

    jessie_raspi_config_07L’ancien raspi-config est toujours présent dans le système et est accessible à partir de la ligne de commande en tapant « sudo raspi-config« , mais il ne devrait plus être nécessaire de l’utiliser (enfin ça c’est la Fondation qui le dit… il y a encore quelques accros de la ligne de commande ! et vous avez le droit de le dire dans les commentaires 😉 )

    jessie_raspi_config_02Le nouvel utilitaire Raspberry Pi Configuration du Raspberry Pi vous permet d’activer ou de désactiver les interfaces.

    jessie_raspi_config_03jessie_raspi_config_04Vous pourrez aussi peaufiner les performances

    jessie_raspi_config_05et configurer les options d’internationalisation, comme le fuseau horaire ou le clavier.

    jessie_raspi_config_06Il permet également un peu plus de contrôle sur les options de démarrage que ce qui était possible précédemment…

    jessie_raspi_config_08Il y a par exemple l’option de se connecter automatiquement en tant qu’utilisateur « pi » (ou pas)  disponible lors du démarrage à la fois en ligne de commande (CLI) et pour le bureau.

    jessie_clavierIl y a également une nouvelle boîte de dialogue pour la configuration du clavier (ci-dessus), accessible à partir de l’onglet Localisation, mais beaucoup d’utilisateurs pouuront se passer de ce réglage, le système devrait détecter certains des claviers standards vendus pour une utilisation avec le Raspberry Pi et configurer le pilote du clavier de l’interface graphique correctement. Si cela ne se produisait pas, il sera facile de choisir son pays et le type de clavier utilisé dans cette boîte de dialogue.

    jessie_configuration_menuL’autre nouvelle boîte de dialogue est l’Éditeur du Menu Principal. C’est une version adaptée pour le Raspberry Pi d’un éditeur de menu appelé Alacarte, écrit en Python. Ceci devrait faciliter l’ajout ou la suppression d’éléments au menu principal. (Et, à la demande générale, le menu Autres est de retour sur le système, mais il n’apparaît maintenant que si les applications qui  sont installées ne figurent pas dans les autres catégories …)

    Applications Mises à jour

    Plusieurs applications installées avec Raspbian ont été mises à jour. Il y a de nouvelles versions de Scratch, Sonic Pi, et du navigateur Web Epiphany. Aucune de ces applications n’a fondamentalement changé, mais elles comprennent toutes des correctifs de bugs et des améliorations de performance.

    Le support de certains des périphériques du Raspberry Pi qui sont sortis récemment a été ajouté. c’est le cas pour la Sense HAT utilisée dans Astro Pi qui est maintenant supportée par Scratch et Python.

    Les utilisateurs de Python avaient l’habitude de devoir lancer Python avec sudo afin de pouvoir accéder aux ports GPIO. Python peut maintenant accéder aux GPIOs  en tant qu’utilisateur standard. Toujours pour Python, l’environnement de jeu Pygame Zéro est installé par défaut. Voyez pygame-zero.readthedocs.org pour en savoir plus sur ses possibilités…

    Une dernière petite chose : si vous voulez obtenir une capture de l’écran de votre Raspberry Pi, appuyez simplement sur la touche Impr écran de votre clavier. Un fichier PNG sera créé dans votre répertoire personnel (normalement /home/pi), grâce à l’utilitaire au nom bizarre scrot.

    Comment obtenir Jessie ?

    jessie_conclusionJessie est une mise à jour majeure en raison du grand nombre de modifications apportées au système d’exploitation sous-jacent. Il est fortement recommandé d’utiliser Jessie à partir d’une image propre. Il faudra télécharger une image de Jessie de puis la page des téléchargements du site de la Fondation. Apparemment certaines personnes ont eu des problèmes pour extraire les fichiers zip, il semble que la grande taille des fichiers images fait que ZIP utilise un format interne différent. Les images peuvent être décompressées avec 7-Zip sur Windows et The Unarchiver sur Mac. Toutes deux sont des applications gratuites.

    Démarrer à partir d’une image propre est vraiment la méthode recommandée pour passer à Jessie. Si vous devez mettre à jour une image Wheezy, il est conseillé d’utiliser la méthode décrite ICI. Cela a été testé et fonctionne correctement sur une image Wheezy de base, mais il est impossible de prévoir quel effet la mise à jour peut avoir sur des paquets ou des données que vous auriez installés. Vous faites donc la mise à jour à vos propres risques. N’hésitez pas à faire figurer vos expériences et améliorations de la mise à niveau sur le forum pour que les autres RasPiNautes puissent en bénéficier.

    jessie_conclusion2

    Bienvenue, Jessie ! Yee-Haw !

     

    Conclusion

    En guise de conclusion, je vais vous résumer les points qui me semblent les plus intéressants de cette nouvelle version :

    • Accès aux ports du GPIO sans passer par sudo
    • Amélioration de l’interface utilisateur, y compris le remplacement de raspi-config par une version graphique qui devrait rassurer les débutants.
    • Deux nouveaux environnements de programmation Java
    • L’installation en standard de LibreOffice (pour le meilleur et pour le pire 😉 )

    Comme toujours, vos commentaires sur cette version sont les bienvenus… !

    Sources

     

     


    0 0
  • 10/16/15--00:33: Le Raspberry Pi chez OAM
  • raspi_ouiaremakers_20151014_250pxDébut octobre je vous avais présenté le site OUIAREMAKERS (OAM pour les intimes), le premier site destiné aux makers francophones de toute spécialité…
    Après 3 semaines de présence sur le web, OAM compte une quarantaine de tutoriels. Parmi ceux-ci des tutos Arduino mais également des réalisations à base de Raspberry Pi !

    OUIAREMAKERS : Des projets Raspberry Pi

    je vous propose de les découvrir rapidement. Vous pourrez lire la totalité des explications sur OAM… 😉

    raspi_ouiaremakers_20151014_FBDe gauche à droite vous trouvez sur cette image :

    PiSqueeze

    raspi_squeezebox_600pxCe tutoriel proposé par Frédéric répond au besoin suivant : Disposant d’une radio SqueezeBox de Logitech, Frédéric en est vraiment très content.

    Malheureusement Logitech a stoppé la commercialisation de ce superbe système audio multiroom.

    toutankhamonIl a donc cherché une solution pour pouvoir diffuser de la musique dans une autre pièce, toujours à partir de SqueezeBox malgré l’arrêt de la commercialisation des produits.

    Finalement il s’est résolu à fabriquer ma propre radio tout seul, comme un grand ! Il vous présente de façon très détaillée son projet pharaonique : La PiSqueeze tout en carton. 😉

    Écran tactile et Raspberry Pi

    raspi_ecran_tactile_600px

    Ce projet est présenté par yar0d, codeur de profession et fan du RasPi et du partage.

    Dans ce tutoriel il vous apprend de manière détaillée à installer un écran tactile sur un Raspberry Pi 2. yar0d ne décrit pas l’installation du système d’exploitation Raspbian que vous trouverez ailleurs sur le net, mais il s’attache à bien expliquer l’installation et la mise en service de l’écran tactile. Comme vous le montrent les images, l’écran s’intègre parfaitement dans un boîtier en acrylique. Cela donne à la réalisation un fini et une esthétique de qualité.

    OAM_tactile-01

    Construisez une TOR Box

    raspi_tor_600px

    Proposé par Grégory, ce tutoriel s’appuie sur un article du magazine Hackable n°6 : http://boutique.ed-diamond.com/home/861-hackable-magazine-6.html. L’idée est d’utiliser un raspberry pi comme point d’accès à Tor et de pouvoir ainsi protéger et anonymiser tout votre traffic internet

    Lorsque vous voulez protéger votre connexion, il suffit de brancher cette Tor Box via un câble réseau à votre box Internet et celle-ci expose un réseau Wifi dont tout le trafic passe par Tor.

    Tor permet de chiffrer votre trafic internet et de vous rendre anonyme et invisible à la surveillance (à moins, bien sûr, de se connecter à un site qui demande votre nom, prénom, etc). 😉

    Conclusion

    Avec ces trois premiers projets mettant en œuvre le Raspberry Pi, le site OAM ouvre ses portes à la communauté francophone du Raspberry Pi.

    A vous (à nous !) d’alimenter ce site en projets impliquant la framboise et bientôt parmi les rubriques de OAM, je vois bien une rubrique spécialisée Arduino-Raspberry Pi… Qu’en dites vous?


    0 0

    wifi_logo_3dAvec la nouvelle version de Raspbian, Jessie, les RaspiNautes se retrouvent devant tout un tas de nouveautés, pas forcément évidentes à utiliser.
    Dans un commentaire laissé sur le blog, Grégory fait part de ses difficultés à connecter un RasPi sous Jessie au réseau WiFi de sa box.
    Comme je n’avais pas rencontré ce genre de souci, j’ai branché un RasPi et refait les manips. Je vous les décris ci-dessous.

    Jessie et le WiFi

    dhcpcd, tout nouveau tout beau ?

    jessie_peur2Avec l’arrivée de Simon LONG à la Fondation Raspberry Pi, c’est le design et le contenu de la distribution qui ont rapidement évolué.

    Une des nouveauté apparues dans Jessie, c’est la gestion du WiFI. Autrefois confiée à wpa_gui en mode graphique, cette gestion est maintenant entre les mains de dhcpcd secondé en mode graphique par dhcpcd-ui.

    De fait, le fichier /etc/network/interfaces ne joue plus le rôle que nous lui avions connu précédemment… Oubliez le !

    Comme Jessie démarre nativement en mode graphique, je vous propose de regarder comment configurer votre clé WiFI pour une utilisation normale du réseau sans fil.

    Le réseau avec Jessie

    jessie_peurSi vous êtes un peu perdu(e) devant l’écran de démarrage de Jessie, regardez dans le coin, en haut à droite… Vous voyez l’icône du réseau ?

    jessie_reseau_600px

    Cliquez pour agrandir

    Je vous ai mis une flèche, c’est bon, vous voyez ?

    Alors on y va !

    Configurer le WiFi sous Jessie

    clic_gaucheNotre Raspberry étant simplement connecté en réseau filaire (via la prise RJ45), sans clé WiFi, si vous faites un clic gauche sur l’icône réseau une boîte d’information vous indique qu’aucune sans fil (wireless)  n’a été trouvée.


    wifi_non_associeCommençons par positionner le curseur de la souris sur l’icône réseau. Après un court laps de temps, une boite d’information s’ouvre. Ici on voit que le réseau filaire (un câble Ethernet est branché sur la prise RJ45) est configuré avec l’adresse 192.168.1.108, avec un masque de 255.255.255.0 (ce qui est indiqué par le /24 – si vous ne voyez pas pourquoi je vous conseille un peu de binaire).

    dwa131 s-l300

    Cette adresse lui a été attribuée par le routeur branché sur la ligne ADSL. (non, je n’ai pas de box).
    Quant à l’interface wlan0 on voit qu’il n’est pas configuré, ni associé à un point d’accès WiFI.

    choixSSIDSi vous cliquez avec le bouton gauche de la souris, vous voyez apparaître une liste.
    Ce sont les points d’accès que votre clé WiFi a identifiés.
    On voit du NEUF, du SFR, Sec_Linkshare c’est la télé (bin oui connectée) et MAISON c’est mon routeur…


    choix_SSIDOn sélectionne le point d’accès auquel notre Raspberry Pi doit se connecter.

    Ici c’est MAISON qui est mis en surbrillance au survol de la souris.

    Cliquez sur votre point d’accès et une fenêtre s’ouvre pour que vous puissiez saisir la phrase de sécurité (de votre box, routeur…)


    saisie_passphraseC’est nommé Pre Shared Key dans la fenêtre. (clé d’authentification pré-partagée)

    Saisissez votre clé (j’ai flouté la zone de saisie… par sécurité ) puis cliquez sur le bouton Valider.


    wifi_plusAbavala… L’icône réseau sur laquelle figuraient deux écrans (ou deux ordinateurs) s’est transformée en symbole WiFi. Attendez quelques secondes, le temps que la connexion se fasse et que votre RasPi récupère une adresse. Le nombre de traits de l’icône donne une idée de la puissance du signal WiFi.


    wifi_connectAllez on va s’assouplir encore un peu le poignet 😉 Revenez avec le curseur de la souris (je ne dis pas avec la souris parce qu’il en a qui plaqueraient la souris sur leur écran et qui diraient que « Ça marche pas ! ») survoler l’icône WiFi.

    La boite d’information qui s’ouvre indique que cette fois wlan0 est bien associé au SSID MAISON et a récupéré l’adresse 192.168.1.107 avec un masque à 255.255.255.0.

    wifi_connect2Si on clique à nouveau (clic gauche) sur l’icône WiFi, on a cette fois la même liste que précédemment.

    Cette fois cependant le SSID MAISON est précédé d’une coche qui indique que c’est le point d’accès auquel mon Raspberry Pi s’est connecté.


    Bon, c’est pas mal tout ça… On a connecté notre Raspberry Pi au WiFi en lui faisant prendre une adresse en automatique.

    Et si par hasard (enfin, non pas par hasard 😉 ) je voulais faire prendre à mon Raspberry Pi une adresse fixe en WiFi ?

    clic_droit_wifijessie_facheAllez, on reprend la souris et on amène le curseur sur notre icône favorite (pour cet article) celle du réseau. Cette fois nous actionnons avec nos petits doigts agiles le bouton droit de la souris… Histoire de varier les plaisirs.

    Ici c’est la première ligne du menu qui nous intéresse : WiFi Networks Settings (paramétrage des réseaux WiFi). On clique sur cette ligne (avec le bouton gauche – encore un peu d’exercice).

    clic_droit_wifi2Et la fenêtre Network Preferences de s’ouvrir !
    Dans la partie Configure c’est interface qui est sélectionné dans la liste déroulante. L’autre option est SSID mais elle ne nous concerne pas ici.
    Remarquez que tout le bas de la fenêtre est grisé, ce qui signifie que c’est inutilisable pour le moment.
    A droite de ce bouton interface, vous voyez une liste qui est vide pour le moment.
    Cliquez donc dessus (clic gauche) pour voir ce qui se dissimule dans cette liste.


    clic_droit_wifi3Ayé, le mystère est levé.

    Cette seconde liste déroulante vous propose de choisir l’interface que vous souhaitez configurer.

    Comme nous nous intéressons actuellement au WiFi, nous allons cliquer (clic gauche) sur wlan0 pour paramétrer notre interface WiFi.

    A nouveau, comme nous n’avons pas encore choisi l’interface à configurer, notez que le bas de la fenêtre est toujours grisé.


    clic_droit_wifi4

    Une fois l’interface choisie, vous voyez que le bas de la fenêtre a changé de look et que les boites de dialogues sont devenues « normales ».

    Cela signifie qu’à partir de maintenant il devient possible de renseigner manuellement l’adresse du raspberry Pi, celle du Routeur (ou de la Box également appelée Passerelle ou Gateway).

    On peut aussi indiquer une adresse de DNS ainsi que le nom du domaine de recherche DNS.

    Alors là un petit conseil… Ne tripotez ces paramètres que si vous savez ce que vous faites 😉 vous risquez de donner une adresse inadaptée (ou en double) et de bloquer l’accès au Raspberry Pi. Vous ne direz pas que vous n’étiez pas prévenu(e).

    clic_droit_wifi5Comme je sais ce que je fais (enfin des fois…) j’attribue une adresse à mon Raspberry Pi. Cette adresse est dans la plage d’adresses distribuées par le DHCP (je sais c’est pas bien) qui va de 100 à 199.
    Le DHCP distribue des adresses à tout le monde à la maison. Mais même en ajoutant les smartphones, la télé, les PC, les tablettes et… les Raspberry Pi on est loin de 50 adresses distribuées (bon j’ai quand même jeté un coup d’œil à la DHCP Clients List du routeur pour vérifier.
    Pas de lézard je peux prendre l’adresse 153 le temps des essais de configuration.

    Comme adresse de routeur je mets 192.168.1.254 qui me sert de passerelle vers Internet. J’aurais pu mettre la même adresse 254 pour le DNS puisque mon routeur sert de relais DNS, mais j’ai choisi de mettre le DNS de Google (8.8.8.8).

    WiFi_DongleNotez cette adresse au passage 8.8.8.8 ça se retient facilement et ça permet de faire un test d’accès à internet en mode console. Si le ping 8.8.8.8 répond, c’est que votre machine accède à Internet. Bon, après vous pouvez aussi essayer 8.8.4.4 qui est aussi un DNS de Google.

    wifi2Terminez la configuration en cliquant sur le bouton Appliquer, puis sur Fermer. Selon la clé que vous utilisez, la modif sera faite à chaud, ou il faudra rebooter le Raspberry Pi.
    Avec la clé DLINK que j’ai utilisée pour les tests, il fallait redémarrer.

    clic_droit_wifi6Comme je ne vous vois pas convaincu(e) vous avez ci-dessus la copie d’écran d’un ifconfig. Je n’ai mis que la partie wlan0 qui nous intéresse.

    Supprimer un point d’accès WiFi

    Tout ça c’est bien joli, mais à chaque fois que je mets une clé WiFi ce #$*%!! de raspberry Pi se reconnecte automatiquement sur le point d’accès que j’avais configuré.

    ports_usb_raspberry_piS’il vous plait faites quelque chose, Docteur.

    Allons, soyez patient(e), je vous explique ça dans pas longtemps.

    Lorsque dhcpcd-ui enregistre un point d’accès, il le fait dans…
    suspens… roulements de tambour…

    le fichier wpa_supplicant.conf !

    Bien… Mais où qu’il est ce fichier ?

    Il est ici : /etc/wpa_supplicant/wpa_supplicant.conf

    Pas de précipitation, faites d’abord une copie du fichier avec cp, on sait jamais 😀

    Pour le modifier ouvrez le avec sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

    ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
    update_config=1
    
    network={
    ssid="MAISON"
    psk="MonMotDePasseSecret"
    key_mgmt=WPA-PSK
    }

    Pour supprimer le point d’accès, supprimez simplement

    network={
    ssid="MAISON"
    psk="MonMotDePasseSecret"
    key_mgmt=WPA-PSK
    }

     Et vous revenez à la configuration de départ.

    Conclusion

    jessie_contenteJ’espère avoir éclairci la configuration  du WiFi sous Jessie pour ceux qui sont amenés à le configurer sur le Raspberry Pi (et ils sont nombreux !)
    Bien entendu rien n’est parfait et il est possible que vous ayez des soucis avec certaines clés USB WiFi.
    N’hésitez pas à le mentionner dans les commentaires ci-dessous. Vos remarques serviront sans doute à ceux qui utilisent le même matériel.

    Bon amusement avec la framboise !

    Sources

    Another Raspbian Desktop User Interface Update


    0 0

    raspisms_250pxRaspiSMS est une solution vous permettant d’envoyer et de recevoir des SMS avec le Raspberry Pi (ou tout autre ordinateur/serveur tournant sous Linux).
    Du point de vue utilisateur, RaspiSMS se présente comme un logiciel à installer sur le RasPi, auquel vous accédez via internet. Vous pouvez ainsi envoyer des SMS depuis un site internet !
    En hébergeant vous même l’application, vous disposez ainsi de votre propre site internet d’envoi de SMS, assurant la confidentialité de vos données et la protection de votre vie privée !

    RaspiSMS 2 : un logiciel libre développé par Raspbian France

    À l’origine, RaspiSMS est issu du besoin de l’équipe de Raspbian France d’envoyer des SMS via internet (pour une raison encore inconnue à ce jour, une bonne partie de la Dordogne semble avoir découvert internet mais pas les téléphones portables).

    Ne trouvant que des solutions payantes pour envoyer des SMS par internet, ils ont décidé de développer leur propre logiciel ! Et plutôt que de faire un simple script en lignes de commande qui ne réponde qu’à leurs besoins propres, ils ont choisi de créer une véritable application web et de la distribuer gratuitement et librement à la communauté, sous licence GNU/GPL3 !

    Fonctions de RaspiSMS 2

    discussion-raspisms2_600px

    Cliquez pour agrandir

    RaspiSMS 2 dispose d’une interface de discussion par SMS permettant d’échanger de façon fluide avec un contact. Les SMS sont envoyés en temps réel. Si un utilisateur souhaite ne plus recevoir les SMS, il lui suffit d’envoyer un SMS contenant uniquement le mot « STOP », les messages ne lui seront plus envoyés.

    Quel équipement pour RaspiSMS ?

    cleUSB
    Pour profiter des services de RaspiSMS, il vous faudra un Raspberry Pi avec son alimentation, une carte MicroSD de 8 Go minimum (une fois RaspiSMS et ses différentes dépendances installées, le système seul dépasse déjà les 4 Go). Si vous souhaitez utiliser d’autres applications sur cette carte que RaspiSMS, il vaut mieux prendre une carte de 16 Go !
    Dernier point, le plus important, vous aurez besoin d’un modem GSM/3G USB compatible avec le logiciel Gammu comme la clé USB ci-dessus.

    Une distribution préinstallée

    3 solutions sont proposées par Raspbian France pour l’installation de RaspiSMS :

    • Vous pouvez installer manuellement RaspiSMS  à partir du code source, et avec l’aide d’un fichier d’installation automatique pour Debian.
    • Vous pourrez installer RaspiSMS sur un système de type Debian avec le paquet .deb fourni.
    • Enfin, et c’est la solution la plus intéressante proposée par Raspbian France, ils vous ont concocté une distribution « clés en main », prête à l’utilisation. C’est une image que vous installerez facilement comme une autre Raspbian téléchargée sur le site de la Fondation Raspberry Pi.

    RTFM

    Bien entendu comme tout bon linuxien, vous connaissez par nécessité le fameux RTFM !
    L’équipe de Raspbian France a anticipé la demande, et vous trouverez une documentation en ligne. Vous pourrez donc vous y reporter avant (ou après) l’installation de votre distribution.

    Conclusion

    Avec RaspiSMS, Raspbian France propose une interface en ligne qui pourra intéresser de nombreux RaspiNautes. En particulier vous pourrez envoyer des SMS à partir d’une installation domotique pour recevoir sur votre smartphone les alertes générées par votre installation.

    raspisms_600px

    Attention cependant aux forfaits SMS illimités qui ne le sont pas (arnaque ?) et qui limitent en fait le nombre de SMS mensuels ou encore le nombre de destinataires.

    Sources


    0 0

    jessie_wifi_250pxDepuis 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

    Je vous propose de lire dans un premier temps une traduction d’un post paru sur StackExchange, suivie d’un tutoriel basé sur les tests que j’ai effectués.
    Jacques un lecteur fidèle du blog vous propose également sa solution, vous la trouverez en fin d’article.

    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.

    jessie_wifi_600px

    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-Box

    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_addressdhcpcd 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

    avahi-tracLes 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

    samsung_sd_200pxBon, 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.
    titi_méfiant_150pxAlors 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 :

    42_43Vous 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

     

     

     


    Warnning: Do NOT Get Caught While Searching!!
    Your IP : - Country : - City:
    Your ISP TRACKS Your Online Activity! Hide your IP ADDRESS with a VPN!
    Before you searching always remember to change your IP adress to not be followed!
    PROTECT YOURSELF & SUPPORT US! Purchase a VPN Today!
    0 0

    tux_systemd_250pxsystemd 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, Arch, 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.

    synoptique_600px

    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.

    systemd_600pxJusqu’à 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.

    systemd_600pxÀ 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_pingouinsystemd 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.

    evolution1Ca 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. les-singes-de-la-sagesseMais 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_LinuxRed 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/.

    evolution3_600px

    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 :

    vnc_01

    Cliquez sur Connexion

    vnc_02Cliquez sur Continuer

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

    vnc_04_600pxBon… 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&amp;                   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]

    Les quatre premières commandes fonctionnent avec root (en sudo), la dernière est accessible en utilisateur normal…

    Par exemple si vous voulez arrêter le serveur VNC :

    pi@raspberrypi:~ $ sudo systemctl stop vncserver@1.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

     

     

     

     

     


    0 0

    freqshow_250pxMê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)

    https://commons.wikimedia.org/wiki/File:SpectrumAnalyzerDisplay.png

    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 :

    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 !!! freqshow_win32diskimager

    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…

    freqshow_win32diskimager2A 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

    freqshow_raspberrypi2_600pxBon, 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″

    freqshow_ecran_3p5_dessus_600pxLivré 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.

    freqshow_raspberrypi2_ecran_600pxL’é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.

    freqshow_raspberrypi2_ecran2_600pxCet é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 consolefenêtre graphique, affichage d’images ou de vidéo, etc. Sa qualité est suffisante pour assurer un usage normal.

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

    rtl-sdr_05

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

    rtl-sdr_01

    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. rtl-sdr_03Habituellement, 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. freqshow_Rx5_600pxLe connecteur SMA utilisé ici est beaucoup plus commun et de nombreuses antennes ou adaptateurs sont disponibles dans ce format. freqshow_Rx4_600pxIl 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. rtl-sdr_04Cette 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. bias_tee_instructions_600pxCela 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 directbreakoutpads_instructions_600pxDeux 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.

    rtl-sdr_02

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

    freqshow_Rx_600px freqshow_Rx2_600px freqshow_Rx3_600px

    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.

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

    freqshow_demarrage2_600pxLa 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…

    freqshow_raspberrypi2_ecran_Rx_600pxVé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:&amp;nbsp; 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 :

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

    freqshow_comment_600px

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

    freqshow_waterfall_600px

    Photo Adafruit

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

    freqshow_config_600pxOn 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 :

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

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

    freqshow_lancement_progCré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 !

    freqshow_demarrage3_600pxBon, 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 !) :

    adafruit_touchscreen_01

    Cliquez pour accéder au PDF

    Et tout à la fin du document cette phrase sybilline :

    adafruit_touchscreen_02

    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)

    freqshow_RTL_600px

    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.

    freqshow_conso_600px

    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

    How To Autorun A Python Script On Boot Using systemd

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

     

     


    0 0

    raspi_partage_samba_250pxQui n’a pas pesté au moment de transférer des fichiers entre sa machine de bureau et un Raspberry Pi connecté uniquement à une prise Ethernet, voire une clé Wi-Fi USB ?
    Que celui qui n’a jamais râlé me jette la première framboise ! Il est possible de créer un partage entre le Raspberry Pi et une machine Linux ou Windows rapidement, ce qui facilite le transfert de fichiers multimédia, de programmes…

    Partage de répertoire avec Samba sous Jessie

    On se fait une petite Samba ?

    raspberry-pi-samba-shareC’est vrai que début février c’est l’époque des carnavals et que quand on parle de Samba, on pense plutôt à des cariocas emplumées dansant dans les rues de Rio. Eh bien au risque de vous décevoir ce n’est pas le sujet de cet article…
    Samba est un logiciel d’interopérabilité qui permet à des ordinateurs Unix/Linux de mettre à disposition des imprimantes et des fichiers dans des réseaux Windows, en mettant en œuvre le protocole SMB/CIFS de Microsoft. (Source Wikipedia)

    Attention, la mise en place de ce partage avec le mode opératoire décrit ne procure aucune sécurité. Ne l’utilisez que pour connecter un Raspberry Pi en interne à votre réseau local, surtout pas sur Internet ! Imaginez que des hackers russes ou chinois viennent dérober des infos sur votre RasPi :)

    shared-folder

    Rappel sur les priorités

    Samba permet différents types d’autorisations. Essayez de vous rappeler ces deux petites choses à propos des autorisations UNIX/Linux et Samba.

    • Les autorisations système de Linux (rwx) sont prioritaires sur les autorisations Samba. Par exemple, si un répertoire n’a pas la permission d’écriture sous Linux, le fait d’ajouter writeable = yes dans le fichier de configuration de samba (smb.conf) ne permettra pas d’écrire dans un répertoire partagé avec Samba.
    • L’autorisation du système de fichiers est prioritaire par rapport à l’autorisation Samba. Par exemple, si un système de fichiers est monté en lecture seule, le fait d’ajouter
      writeable = yes dans le fichier de configuration de samba (smb.conf) ne permettra pas d’écrire dans un répertoire partagé avec Samba.

    Gardez ces priorités en tête de nombreux RasPiNautes qui installent Samba râlent parce que « ça marche pas ! » et ils oublient les vérifications élémentaires.

    raspi_partage_samba_FB

    Installer Samba

    Comme toujours avant une installation, pensez à faire une mise à jour du système. Ça ne peut pas faire de mal.

    sudo apt-get update
    sudo apt-get upgrade

    On peut maintenant passer à l’installation de Samba :

    sudo apt-get install samba samba-common-bin

    Par sécurité, faites une copie de sauvegarde du fichier de configuration par défaut de Samba (on ne sait jamais..) :

    sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.org

    Bon, c’est mon habitude de garder les fichiers originaux avec une extension .org mais rien ne vous empêche de les appeler .old, .back ou… tout ce que vous voulez

    samba_linux_windoq

    Allez on va aller tartouiller dans le fichier de configuration de Samba : Trouvez les lignes et décommentez les (enlevez les # du début de ligne des deux dernières lignes uniquement)

    # The specific set of interfaces / networks to bind to
    # This can be either the interface name or an IP address/netmask;
    # interface names are normally preferred
    interfaces = 127.0.0.0/8 eth0
    bind interfaces only = yes

    Samba sera lié (bind) à la machine locale (127.0.0.0) et à l’interface eth0 (le port Ethernet du Raspberry Pi).

    Maintenant rendez vous à la fin du fichier… oui, tout en bas et ajoutez :

    [Partage]
    comment = Partage Samba sur Raspberry Pi
    path = /home/pi/partage
    writable = yes
    guest ok = yes
    guest only = yes
    create mode = 0777
    directory mode = 0777
    share modes = yes 
    • comment : c’est une brève description du dossier de partage. Adaptez-le à vos besoins.
    • path : c’est l’emplacement du dossier à partager. Cet exemple utilise /home/pi/partage
    • writable : les utilisateurs pourront écrire
    • guest ok : permet aux clients de se connecter au répertoire partagé sans fournir de mot de passe.
    • 0777 quand un fichier/dossier est créé, les droits appliqués permettent à tout un chacun de lire ou d’écrire. (avec le mask vous aurez rwxrw-rw- sur un fichier créé et rwxrwxrwx sur un répertoire créé). Si ça ne vous dit rien lisez cet article

    Redémarrez Samba sous (Jessie):

     sudo systemctl restart smbd.service

    Trouver le partage sur la machine Windows

    Dans l’explorateur

    samba_reseau_windowsOuvrez un Explorateur de fichiers, dans la rubrique Réseaux (à gauche) vous voyez apparaitre un ordinateur nommé… RASPBERRYPI. Cliquez sur ce nom et le partage est visible dans la fenêtre de droite.

    Ouvrez le partage et… testez !

    RaspberryPiSamba

    Pour les tests j’ai créé des fichiers depuis la machine Windows et envoyé ensuite BigBuckBunny (le film) sur le RasPi :

    transfert_samba_600px

    Dans la fenêtre « Exécuter »

    On peut aussi lancer la connexion depuis la fenêtre Exécuter :

    samba_executerSaisissez l’adresse du RasPi suivi du nom de partage avec la syntaxe ci-dessus, vous aboutirez sur une fenêtre donnant accès au partage.

    Conclusion

    Avec ce partage Samba vite mis en place sur le Raspberry Pi, vous ouvrez un accès bien pratique pour faire des tests ou des transferts de données.

    On peut certainement faire mieux et plus simple mais… ça marche. Si vous avez mieux, les commentaires vous tendent les bras.

    A nouveau, n’utilisez ce tutoriel que si votre Raspberry Pi n’est pas connecté à Internet.

    Sources


    0 0

    bluetooth_signal_250pxL’arrivée du WiFi et du BlueTooth sur le Raspberry Pi 3 est un événement important. Si la mise en œuvre du WiFi ne pose pas trop de problème,  le BlueTooth soulève pas mal de questions. David ROBERTS a publié il y a quelques jours un article sur la configuration du BlueTooth avec un Raspberry Pi 3. Et puis est sorti le MagPi N°44 qui aborde également le sujet. Je vous propose d’en découvrir une synthèse et de voir comment utiliser votre Raspberry Pi pour envoyer du son à un casque/écouteur/enceinte Bluetooth.

    ============= Article sponsorisé =============

    Le Raspberry Pi 3 et le BlueTooth

    jesse_cook_videoLe Raspberry Pi 3 est un petit ordinateur utilisable pour de nombreux usages. Son système d’exploitation Raspbian n’est pas prévu d’origine pour écouter de l’audio sur un casque ou des haut-parleurs Bluetooth. Cependant, ce n’est pas très difficile à mettre en place, c’est très agréable à écouter, et… ça marche ! Pendant que j’écris cet article j’écoute du Jesse COOKj’écoute ce que je veux, non ?– sur mon RasPi 3 (vidéo ci-dessus), avec mes écouteurs Bluetooth yep !

     synoptiqueCe que je voulais faire, c’est recevoir du signal via Internet en WiFi et le renvoyer en Bluetooth vers mes écouteurs. Le RasPi posé sur la table, pas de fil à la patte mis à part celui de l’alimentation.

    Cet article a été réalisé avec la version de Raspbian (ou de NOOBS) du 18 mars 2016. Il devrait fonctionner avec les versions précédentes de Jessie. N’importe quel Raspberry Pi fait l’affaire, mais il faut reconnaître que le Pi d’origine (le tout premier avec 512 Mo de RAM) et le Pi Zero sont un peu limités en puissance pour diffuser correctement de l’audio à partir d’Internet sur une liaison BlueTooth. Ils vont bien pour jouer des MP3 avec un media player comme VLC… mais n’en demandez pas trop 🙂

    raspberrypi3_bluetooh_600px

    C’est l’apparition d’une interface WiFi/Bluetooth sur le Raspberry Pi 3 qui ouvre la porte à ce genre de manip, sans monopoliser 2 ports USB, un pour une clé USB WiFi, un autre pour une clé USB Bluetooth 🙂 . Là tout est intégré, tout est compris !

    raspi3_antenne

    Préparation du Raspberry Pi 3 et de Raspbian

    Téléchargez la dernière version de Raspbian Jessie et mettez la sur une carte microSD de 8 Go ou plus. Effectuez les connexions des différents câbles au Raspberry Pi et démarrez-le. Ouvrez un terminal et exécutez les commandes suivantes pour vous assurer que tout est mis à jour. Si vous ouvrez cette page en même temps dans le navigateur sur votre Raspberry Pi, vous pouvez copier/coller ces commandes directement dans votre terminal pour éviter les fautes de frappe.

    Raspberry_Pi_Logo

    Je vous conseille dans un premier temps d’étendre le système de fichiers car c’est un peu ric-rac à mon avis et j’ai eu plusieurs fois des surprises lors des mises à jour parce qu’il n’y avait plus de place disponible sur la carte. L’image que vous téléchargez est livrée avec un espace de 4Go et lorsque vous faites les mises à jour, il risque de ne plus y avoir assez d’espace disponible. Le fait d’étendre le système de fichier à toute la carte donne un peu d’air au système. J’ai l’habitude d’utiliser des cartes Samsung EVO de 16Go (moins de 9€ dans le supermarché du coin).expand_filesystemEn mode graphique (bin oui il en faut pour tout le monde 😉 ) cliquez sur Menu >> Preferences >> Raspberry Pi Configuration. La fenêtre ci-dessus s’ouvre. Cliquez sur le bouton Expand Filesystem. Puis soyez conciliant répondez oui (yes, ok) à tout ce que vous demande le RasPi. Vous irez ainsi jusqu’au Reboot de la bête, après quoi le système de fichier, tel un gaz (ou moi sur mon bureau:-D ) occupera tout l’espace disponible.

    Si vous faites une allergie au mode graphique (si si, ça arrive, il y en a à qui ça file… des boutons) connectez vous en mode texte et faites

    sudo raspi-config

    ce qui devrait avoir pour effet d’ouvrir cette fenêtre semi-graphique (bin oui, on est en mode texte 🙂 )

    raspi-config01On est déjà sur Expand Filesystem… Ça tombe bien. Validez, soyez poli, répondez voui sur la prochaine fenêtre. Après quelques TAB vous illuminerez <Finish>, validez avec Entrée et votre Filesystem occupera aussi toute la place ==> après le prochain reboot.

    Bon cette fois, on redémarre le Raspi.

    sudo reboot

    Ou tout autre moyen. Évitez toutefois le sauvage « j’le débranche, y va bien redémarrer » qui se termine parfois en… « bin zut y r’démarre plus 🙁 « 

    Connectez-vous en mode texte pour vérifier que le RFS est bien étendu à toute la carte SD :

    df-h

    Ma foi tout ça m’a l’air de bon aloi, on va pouvoir passer à la suite.

    sudo apt-get update
    sudo apt-get upgrade

    Acceptez toutes les mises à jour proposées. En date du 2 avril 2016 il y a 18Mo à télécharger.

    (C’est le minimum syndical pour mes tests j’ai aussi fait dist-upgrade et rpi-upgrade 🙂 )

    Installation de la suite Blootooth pour le Raspberry Pi 3

    Installez la suite Bluetooth pour le Raspberry Pi : pi-bluetooth. Dans mon cas la dernière version était installée.

    pi@raspberrypi:~ $ sudo apt-get install pi-bluetooth
    Reading package lists... Done
    Building dependency tree
    Reading state information... Done
    pi-bluetooth is already the newest version.
    0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.

    Vous pouvez maintenant installer les utilitaires nécessaires à la gestion Bluetooth.

     

    sudo apt-get install blueman pulseaudio pavucontrol pulseaudio-module-bluetooth

    Cette fois il y a du monde et une quinzaine de Mo vont être téléchargés, décompactés et installés.

    Quand l’installation est terminée, redémarrez le Raspberry Pi.

    raspbian_bluetoothOh surprise (enfin… non) une icône Bluetooth est apparue dans la barre des tâches.

    Configuration du Bluetooth sur Raspberry Pi 3

    Cliquez sur l’icône Bluetooth de la barre des tâches.

    raspi3_bluetooth_3Cette fenêtre s’ouvre au centre de l’écran. Mettez votre périphérique en mode appairage (pairing en anglais). Pour mes écouteurs, par exemple, ils doivent être éteints et il faut les allumer en maintenant ensuite la pression sur la touche multifonction jusqu’à entendre une voix féminine qui annonce « Pairing ! ». Pour savoir comment faire avec votre périphérique c’est simple : RTFM… Surtout ne me demandez pas comment on fait avec vos écouteurs ou votre enceinte, je n’en sais rien 😉

    Lorsque votre écouteur/enceinte est prêt pour l’appairage, cliquez sur Search (à côté de la loupe).

    raspi3_bluetooth_2L’écouteur Syncwire SW-BTE-01 a bien été détecté par le Raspberry Pi. Il faut maintenant le connecter à celui-ci :

    raspi3_bluetooth_4Faites un clic droit sur le périphérique que vous souhaitez connecter. Choisissez Connect dans le menu qui s’est affiché. Remarquez en bas du menu l’item Remove…  qui vous permettra de retirer un périphérique de la liste.

    raspi3_bluetooth_5Les chiffres en bas à droite indiquent la quantité de données qui a transité par le Bluetooth, ainsi que la vitesse de transmission.

    Des icônes indiquant la connexion et son état apparaissent à droite de la ligne de votre périphérique. On y est presque !

    raspi3_bluetooth_0Cliquez sur le bouton Menu (en haut à gauche) puis sur Sound & Video et enfin sur PulseAudio Volume Control.

    raspi3_bluetooth_7Si vous aviez eu la curiosité d’ouvrir cette fenêtre avant de connecter votre écouteur/enceinte, vous n’auriez trouvé que la partie haute de la fenêtre (bcm2835 ALSA Analog Stereo) qui envoie le son en analogique (en fait en PWM) vers la sortie Jack du Raspberry Pi.

    Le fait d’avoir connecté l’écouteur SW-BTE-01 l’a fait apparaitre dans la liste des choix possibles pour la sortie son. Ici les deux sorties sont actives.

    raspi3_bluetooth_8Comme je n’ai rien de connecté (pour le moment) sur la sortie audio analogique, j’ai dévalidé la sortie son d’origine en cliquant sur l’icône du haut-parleur orné d’une croix(Mute= Muet).

    Allez, tout est en place…

    Ouvrez une vidéo Youtube et… dégustez !

    raspi3_bluetooth_1Après un moment d’audition, vous voyez que la quantité de données envoyée au casque à fortement augmenté par rapport à la vue précédente de cette fenêtre.

    Et ce casque alors ? ma foi après l’avoir mis en charge je l’ai utilisé plusieurs heures  sans défaillance. Le fabricant annonce que la batterie Lithium-ion polymère de 80mAh permet 7 heures de lecture audio/appels téléphoniques et 175 heures en veille avec une seule charge. La portée d’appairage d’appareils Bluetooth va jusqu’à 10 mètres. En intérieur j’ai pu aller jusque 6 mètres.

    La qualité sonore était au rendez vous. Je n’ai pas forcément un oreille très affutée mais la qualité est très bonne, avec des basse profondes et des aigus bien distincts. Mon seul motif d’agacement concerne le cache qui referme le port USB destiné à la recharge. Il manque ne serait-ce qu’une aspérité  pour pouvoir l’attraper. Je n’ai pas réussi à l’ouvrir avec un ongle (non, je ne me les ronge pas 🙂 ) il a fallu à chaque fois que je fasse appel à un tournevis d’horloger ou une pointe de cutter.

    Je l’ai utilisé également avec mon smartphone (Samsung Galaxy IV) aussi bien pour écouter de la musique que pour des appels téléphoniques le tout sans problème.

    Les écouteurs m’ont été envoyés par Syncwire pour les tester.  Voici une présentation de ce casque destiné à l’écoute de la musique et à une utilisation téléphonique.

     

    Les écouteurs Bluetooth Syncwire

    Vous avez vu que cet article est sponsorisé : c’est toujours indiqué quand c’est le cas sur framboise314. D’une part parce que c’est la loi, d’autre part parce que lorsqu’un article est sponsorisé, je pense que le respect des lecteurs implique que ce soit indiqué 🙂

    logo_syncwireIci c’est Sync-wire, une entreprise de Shenzen, qui m’a contacté pour que je présente leurs produits. Comme ils sont plutôt spécialisé sur la gamme Apple (câbles pour iPhone, iPad, iPod) ce genre de produits ne concerne pas trop le Raspberry Pi. Mais… les écouteurs bluetooth et les chargeurs/alimentations oui ! Ils m’ont donc fait parvenir une paire d’écouteurs et un chargeur pour que je les teste.

    syncwire_ecouteur_boiteComme beaucoup de produits maintenant, les écouteurs sont livrés dans une boîte en carton assez épais et résistant.

    syncwire_ecouteur_etuiDans laquelle on trouve une autre boîte avec la notice des écouteurs (en anglais) ainsi qu’un pochette de rangement.

    ecouteur_syncwire3_600px

    Cliquer pour agrandir

    Les écouteurs sont reliés par un câble siliconé très souple qui permet de faire transiter le signal mais aussi l’alimentation entre les deux écouteurs.

    ecouteur_syncwire2_600px

    cliquez pour agrandir

    L’écouteur gauche (ils sont marqués R=droite et L=gauche) comporte un bouton multi fonction destiné à mettre les écouteurs sous tension, mais aussi les appairer avec… un Raspberry Pi ou encore prendre un appel téléphonique.

    syncwire_ecouteur_chargeCe qui m’a aussi intéressé sur le site du constructeur, c’est la présentation du produit sous forme d’éclaté :

    ecouteur_syncwire4_600px

    Cliquer pour agrandir

    eclaté_ecouteur_syncwire_600px

    Cliquer pour agrandir

    On n’a pas trop l’habitude de découvrir ce que ces bestioles ont dans le ventre. Les écouteurs se rechargent en 2 heures environ. Il sont à la norme Bluetooth 4.1+EDR et utilisent le décodage audio AptX.

    Un chargeur un peu juste pour le Raspberry Pi 3

    chargeur_boiteDans la même livraison j’ai reçu un chargeur/alimentation mural USB à 4 ports. Il fait merveille pour charger smartphones et tablettes avec ses deux sortie 2,4A.

    Là encore on a affaire à un emballage soigné et un produit de taille réduite avec un plus pour les voyageurs : Il peut en quelques secondes être équipé d’une prise clipsable au format adapté à la Grande-Bretagne, l’UE et les États-Unis. Sa petite taille permet de l’emmener dans un sac de voyage et de disposer d’un chargeur universel.

    chargeur_boite2Ce chargeur est prévu pour fournir une charge complète aux appareils connectés. Il dispose de 4 ports USB (2 de 2.4A et  2 de 1A). Il peut fournir une puissance maximale de 34W (6.8A), et charge rapidement jusqu’à quatre appareils en même temps, en adaptant automatiquement la sortie pour chacun en fonction des besoins. Il est géré par un circuit « intelligent » qui protège l’adaptateur USB contre la surchauffe et la surcharge de l’appareil, et gère la charge des appareils connectés.

    chargeur_prises_USBLes essais sur le Raspberry Pi 3 ont montré que la tension de sortie de 5,04v est un peu juste quand il faut alimenter un Raspberry Pi 3 avec l’écran officiel. Le carré signalant une sous alimentation de la carte clignote de temps en temps en haut à droite de l’écran. Il en a été de même avec un Raspberry Pi 3 équipé d’un écran 5 pouces HDMI. Par contre pour des versions plus anciennes il fournit suffisamment de puissance.

    Là aussi le constructeur fournit des éclatés du produit, ce qui permet d’avoir une idée de ce qu’il y a dedans.

    eclaté_chargeur_syncwire_600px

    Le chargeur/alimentation – Vue éclatée. Cliquer pour agrandir

    eclaté_chargeur_syncwire2_600px

    Les cartes du chargeur/alimentation – Vue éclatée. Cliquer pour agrandir

    Tester son Bluetooth

    Pour tester votre installation, voici quelques signaux (certains viennent de http://www.testsounds.com/)

    jesse_cook_video


    Jesse COOK :

    Son uniquement (MP3)
    (2,28 Mo)


    Video HD (MPEG4)
    (87 Mo)


    percussion
    Solo de batterie MONO (MP3)

    Solo de batterie STEREO (MP3)

    Signal sinusoïdal :

    sinusoide

    20Hz
    30Hz
    50Hz
    100Hz
    200Hz en phase
    200Hz déphasé
    2500Hz
    10KHz (droit)
    10KHz (gauche)

    Conclusion

    La mise en œuvre du Bluetooth sur le Raspberry Pi 3 devient plus simple. Que ceux qui n’ont jamais galéré avec bluez me jettent la première clé USB 🙂

    Tout n’est pas encore au point, loin de là puisque seule cette fonction d’envoi de musique est disponible actuellement. La réception de musique par le Raspberry Pi  est indiquée comme Expérimentale! et l’émulation de casque (lui faire jouer le rôle du casque) est indiquée Très Expérimentale!

    Je vous passe les installations qui n’ont pas fonctionné avec un blueman à la ramasse du genre tu cliques et tu as le temps de boire un café avant que la fenêtre s’ouvre… (tu as même le temps de le torréfier et de le mouliner). Parfois également l’icône Bluetooth n’apparait pas dans la barre des tâches… Bin ? où qu’il est passé ?

    En résumé on peut dire que le Bluetooth existe sur le Pi 3 mais que pour son utilisation au quotidien il faudra sans doute être encore patient.

    J’ai également testé le Bluetooth en mode manuel (bluetoothctl) et vous savez quoi… ça marche vraiment bien 😉 Mais ça… c’est une autre histoire.

    Si vous vous êtes également frotté(e) au Bluetooth n’hésitez pas à faire un retour d’expérience dans les commentaires ci-dessous. Ce sera profitable à tous les utilisateurs de Raspberry Pi 3… Et pourquoi pas un article ?

    Sources

    Listen to Bluetooth Audio on Your Raspberry Pi 3, Pi Zero, or Earlier Pi

     


    0 0

    rj45-1139366_1280Cette manipulation s’avère être assez facile et assez basique, mais néanmoins elle vous sera d’une grande utilité pour reconnaitre votre Raspberry au sein de votre réseau local mais également très utile lors de la création de serveurs, de scripts d’automatisations, etc.

    Niveau : débutant – intermédiaire

    Durée : environ 10 minutes

    Ne s’applique qu’à la version Wheezy de Raspbian

    Pour le moment, votre Raspberry dispose d’une adresse IP (Internet Protocol) dynamique, c’est-à-dire qu’elle peut changer à tout moment (ça fait déjà plusieurs fois que vous essayez de vous connecter à votre SSH avec l’adresse IP de d’habitude, par exemple 192.168.1.36:22 alors que votre box en a décidé autrement en donnant une toute autre adresse à votre RasPi). 🙁

    Ma box ?! Pourquoi elle ? 😯

    Eh oui !! pour une fois votre chère petite Framboise n’y est pour rien c’est bel et bien la faute de cette fameuse box ! C’est elle qui distribue les adresses IP donc c’est elle qui est susceptible de changer celle de votre Raspberry (ou bien de votre PC, smartphone, …) 🙂

    Mais comment faire ?

    1er Méthode :

    Prérequis :

    Avoir un accès au Raspberry : que ce soit en mode texte, graphique ou bien encore en SSH (même si j’ai toujours cette allergie au mode graphique, cela ne changera rien dans la suite du tuto 😀 )

    Se rendre dans le terminal et taper :

     sudo nano /etc/network/interfaces 

    Une fois le fichier ouvert, recherchez la ligne

    iface eth0 inet dhcp

    et la remplacer par:

     iface eth0 inet static
    
    
    
    address 192.168.1.x
    
    netmask 255.255.255.0
    
    network 192.168.1.0
    
    gateway 192.168.1.1 

     

    Attention! Les paramètres si dessus sont à modifier suivant votre réseau !

    Enregistrer et fermer le fichier

    Ctrl + o (pour enregistrer)

    Entrée (pour valider)

    Ctrl + x (pour fermer)

    Redémarrer la bête

     sudo reboot 

     

    Pour vérifier si les changements ont bien été pris en compte, retournez dans le fichier précédemment modifier et vous devriez voir … vos modifications ! 😀

    2nd méthode :

    Cette fois ci, vous n’aurez pas besoin d’avoir accès au Raspberry, il suffit juste qu’il soit démarré et branché au réseau.

    Cette méthode consiste à vous rendre sur l’interface web de votre box et de modifier l’adresse de votre RasPi de dynamique à fixe.

    Pour cela reportez-vous au manuel d’utilisation de votre box ou bien googlez un peu, vous devriez trouver assez rapidement.

    Si par malheur vous ne trouvez pas, faites-le nous savoir dans les commentaires.

     

    Conclusion :

    Eh bien voilà, votre Raspberry a enfin sa propre adresse IP ! Il doit être content et vous aussi car plus besoin de chercher votre Framboise sur le réseau car maintenant il aura sa propre adresse IP ! 🙂


    Warnning: Do NOT Get Caught While Searching!!
    Your IP : - Country : - City:
    Your ISP TRACKS Your Online Activity! Hide your IP ADDRESS with a VPN!
    Before you searching always remember to change your IP adress to not be followed!
    PROTECT YOURSELF & SUPPORT US! Purchase a VPN Today!

(Page 1) | 2 | 3 | 4 | newer