PiRDF #2 : Préparation du matériel

PiRDF #2 : Préparation du matériel

Cet article permet de lister tous les éléments nécessaires à la préparation du Raspberry Pi pour l’application PiRDF que sous avons préciser l’article de présentation générale.
Nous allons voir point par point comment réaliser l’installation de toutes les dépendances nécessaires.

Préparation du système d’exploitation

Dans il est nécessaire d’installer un système Raspbian sur une carte SD. On ne le répétera jamais assez, il est très important que votre carte SD soit de qualité et ait des propriétés de vitesses importantes. J’utilise personnellement ce modèle des SanDisk classe 10 comme celle-ci :

On notera que 16GB est suffisant dans ce cas particulier.

Pour installer le système d’exploitation, vous devez télécharger la dernière image de Raspbian, ici celle du 09-10-2018 ce qui m’a permis de tester la dernière version.

Pour la copier, sur la carte, il suffit d’effectuer une copie sur la carte de l’img iso après l’avoir formatée. La copie s’effectue à l’aide de l’instruction dd selon le formalisme suivant :

dd bs=4M if=2018-10-09-raspbian-stretch.img of=/dev/sdb conv=fsync

l’argument if est utilisé pour les données d’entrée (ici l’image) et of pour la destination ici, /dev/sdb.

NB : l’installation les instructions ici sont celle d’un système Linux. Si vous effectuez l’installation depuis un système Windows (pratique que je déconseille), reportez-vous à rubrique d’aide spécifique du site officiel de Rapberry Pi’ c’est à dire :

Après avoir réaliser ces opérations de copie de l’image, il ne vous reste plus qu’à placer la carte SD dans le Raspberry Pi et de le démarrer.

Enfin, pour finir votre installation, il faut faudra configurer :

  • la langage du système
  • la timezone
  • le tytpe de clavier
  • le WIFI

Toutes ces informations vous seront demandées par le biais d’un assistant au premier démarrage. C’est une des nouveautés de la nouvelle version de Raspbian.

Après cela, il est temps de passer à l’installation des éléments liés à python.

La stack python

Outils de développement

Raspbian arrive avec des versions de python installer : la version de python 2.7.XX (je sais plus trop et j’en moque, je l’explique dans quelques lignes) et la version 3.5.3.
Je ne reviendrais par sur les raisons qui ont poussé la communauté de développeurs de maintenir pendant de trop nombreuses années 2 versions de python, mais le fait est que Python ne sera plus maintenu à partir de 2020 (voir le python countdown) et les librairies feront de même rapidement. Certaines librairies comme sci-kit-learn (que nous allons utiliser) l’ont déjà annoncé.
Pour ces raisons évidentes, je ne développe que du code compatible Python 3 et je n’assure aucune compatibilité pour Python!

A Python 3, j’ajoute deux outils de développements dont je considère qu’ils améliorent ma productivité :

  • ipython
  • ipdb

ipython

Ipython est environnement permettant d’exécuter du code de manière interactif, ce qui permet en d’autres choses d’accéder aux valeurs des différentes variables après exécutions, d’exécuter des commandes(dont certaines commandes consoles) directement et d’avoir accès à la coloration syntaxique et l’autocomplétion.

Pour l’installer, il suffit d’exécuter la ligne suivant :

pip3 install ipython

ipdb

Ipdb est un débugger un peu plus évolué que pdb (le débugger officiel). Il est surtout plus ergonomique que celui-ci. Pour installer, il faut également passer par pip :

pip3 install ipdb

Librairie scientifique

Pour réaliser les tâches de caractérisations des images et de prises de décisions automatiques, nous aurons besoin d’utiliser un certain nombre de librairies qu’on qualifie souvent de scientifique.

scipy et numpy

scipy et numpy sont inséparables, ce sont les deux librairies qui permet de réaliser tout ce qui est lié au calcul scientifique dont le calcul matriciel et l’algèbre linéaire.
Il ne faut pas envisager de les installer via pip car le risque de swap est très important et l’installation risquerait de ne pas aboutir.
Il faut mieux passer par le gestionnaire de paquet apt. Pour cela il faut saisir les commandes suivantes :

sudo apt-get install python3-scipy

sudo apt-get install python3-numpy

sci-kit-image

Sci-kit-image est la librairie qui permet d’accéder à un grand nombre de méthodes de traitement d’images disponible dans la littérature scientifique. Cette librairie possède également une couche IO (entrée/sortie) qui permet d’ouvrir de nombreux format d’images et de stocker les données dans des matrices de type numpy. De la même manière sci-kit-image permet un enregistrement de données brut en de nombreux formats d’images (png, jpeg, bmp…).
Pour l’installation, ça se passe pas apt :

sudo apt-get install python3-skimage

sci-kit-learn

Sci-kit-learn est une librairie spécifique d’outils d’intelligence artificielle. Nous utiliserons pour les phases d’apprentissage et de décision automatique. Pour l’installation, on passe encore une fois par apt :

sudo apt-get install python3-sklearn

Interfaçage de la caméra et éléments graphiques

Il ne nous reste plus qu’à installer les deux librairies permettant d’une part l’accès à la camera et à ses données grâce à picamera et la librairie pygame qui nous permettra de sans trop développement d’afficher le flux vidéo dans une interface graphique.

Pour l’installation, on passe cette fois par pip:

pip3 install picamera

et

pip3 install pygame

NB : On notera que dans la dernière version de Raspbian, ces deux librairies sont déjà installées

Et le hardware là-dedans

Après, le software, il nous est nécessaire de préparer le hardware. Il n’est pas nécessaire de préparer le hardware final pour ce qui est des switches. J’ai préféré passer par une phase de prototypage avec des microswitches, une « plaque lab » et quelques fils.

Pour aller un peu plus loin

Les autres articles du projet PiRDF :

Le matériel utilisé (liens affiliés — si vous commandez via ce lien, j’ai quelques % en commission pour payer l’hébergement de ce site l!):

PiRDF #1 : Présentation du projet

PiRDF #1 : Présentation du projet

Ce billet marque le début d’une série d’articles concernant la documentation d’un projet que je présenterai à la Maker Faire Paris sur le stand des éditions ENI qui est l’éditeur de mon livre intitulé « Python. Libérez le potentiel de votre Rapsberry Pi ».

Ce projet, je l’ai intitulé PiRDF. Pi en référence au Raspberry Pi et RDF pour le Reconnaissance De Formes. Le but de ce projet sera donc de construire une petite application qui permet d’apprendre et de reconnaitre des objets simples.
Tous les éléments logiciels seront développés en langage Python et publiés sur le « repository » Github : Projet PiRdf sur github. De cette manière quiconque pourra utiliser le code et/ou proposer des évolutions.

Le but de cette démo est montré au public qu’il est possible en très peu de lignes de construire des applications dont les fonctionnalités peuvent être complexes.

Enfin, on notera que l’ensemble de ces articles est une consignation des notes au cours de la réalisation. En effet, à l’heure où j’écris ces lignes le développement du code est loin d’être abouti, vous verrez sans doute des erreurs de conception qui vont nécessiter des refactoring d’un article à l’autre, j’essayerai donc de documenter toutes ces évolutions.

Dans la suite des cet article, je vais détailler le cahier des charges après une courte introduction de ce qu’est la reconnaissance de formes.

C’est quoi la reconnaissance de formes

La reconnaissance de forme est un des sous-domaines de la vision par ordinateur qui est elle-même une discipline à la croisée de nombreuses disciplines que sont :

  • l’informatique
  • les mathématiques appliquées
  • le traitement du signal et des images.

La reconnaissance de formes a pour but de reconnaitre au sein des images un ou des motifs appris au préalable. Ce motif peut être, par exemple, un objet, un visage…
La reconnaissance de formes fait donc appelle à des techniques comme l’apprentissage automatique et à la modélisation statistique. Pour le profane, on pourrait résumer le tout en disant que la reconnaissance de formes est une branche de l’intelligence artificielle même si le terme a en partie perdu de sa teneur à cause de la médiocrité de la vulgarisation de certains médias ces dernières années… Bref, ça, c’est un autre sujet…

Historiquement en sépare la reconnaissance d’objet en 2 familles :

  • l’approche globale
  • l’approche locale

l’approche locale

L’approche locale regroupe les différents techniques qui permettent de détecter et reconnaître un objet au sein d’une scène composée d’un ensemble d’objets.
Pour illustrer, on peut citer la détection de piéton (voir l’image ci-dessous) dans une scène urbaine qui trouve des applications dans le développement des véhicules autonomes.


Crédits : By Milwaukee_(WIS)N_5th_St« Tree,_Rain,_Wind« Pedestrian_1.jpg: vincent desjardinsderivative work: Indif (talk) – Milwaukee(WIS)N_5th_St« Tree,_Rain,_Wind« _Pedestrian_1.jpg, CC BY 2.0, https://commons.wikimedia.org/w/index.php?curid=11912052

Cette approche qui a beaucoup évolué en matière de performances depuis le début des années 2010, n’est toujours pas parfaite et le taux d’erreur reste toujours trop élevé pour certains types d’applications.
De plus, les dernières méthodes nécessitent, le plus souvent, des puissances de calcul très élevées. À titre d’illustrations, la voiture Tesla autonome possède la puissance de calcul de plusieurs MacBook Pro…
Il est par conséquent quasiment impossible d’espérer faire tourner ce genre de manip sur un Raspberry Pi qui possède des ressources matérielles limitées tant au niveau du processeur que de la mémoire de type RAM.

l’approche globale

À l’inverse, l’approche globale est plus simple et historiquement antérieure à l’approche globale.
Le but, ici, est de reconnaitre un unique objet au sein d’une image ou d’une région d’intérêt au sein d’une image.
Dans ce cas, le nombre de méthodes disponibles dans la littérature est plus nombreux et les performances atteintes par les meilleurs sur les bases de test sont de plus en plus proches de 100% de réussites.
Enfin, ils existent une multitude de méthodes qui présentent une complexité calculatoire diverse et variée. Dans tous les cas, de nombreuses méthodes peuvent être envisagées pour une implémentation en python sur le Raspberry Pi.

Cahier des charges — c’est quoi donc le projet PiRDF

L’application sera réduite au maximum en termes de fonctionnalités et d’interface graphique.
Dans tous les cas, elle sera découpée en 2 phases : 1- l’apprentissage 2- la décision. Les sections qui suivent vont permettre de définir plus précisément les éléments fonctionnels de chaque tâche.

Phase d’apprentissage

La phase d’apprentissage correspond à l’ajout d’un nouvel élément à une base de connaissance.
En pratique cela correspond à calculer un ensemble de caractéristiques à partir de l’image qui contient l’objet de calculer un modèle d’apprentissage à partir de la base de connaissance.

D’un point de vue pratique, on aura à disposition un bouton branché sur le GPIO qui permet de démarrer l’apprentissage.
L’appui sur ce bouton permet de commencer à calculer les caractéristiques pour les images arrivant de la caméra.
Toutes images ne serviront pas à l’apprentissage.
Nous réaliserons un suréchantillonnage du signal vidéo de l’ordre d’une image par seconde voir moins si le temps de traitement est trop long.

Pour mettre fin, à la phase d’apprentissage un second bouton sera installé sur le port GPIO.
Un appui sur ce bouton permet d’arrêter la phase de création et d’enrichissement de la base de connaissances et de réaliser la phase d’apprentissage à proprement dites et permet de créer un modèle de décision.

À partir de cette étape, nous possédons l’information nécessaire pour réaliser une décision vis-à-vis de l’objet présent devant la caméra.

Phase de décision

La phase de décision consiste à déterminer la classe d’appartenance d’un objet devant la caméra aux classes existantes dans le modèle.
Pour réaliser cela, on va calculer un ensemble de caractéristiques à partir de l’image et utiliser un modèle décisionnel pour déterminer la classe d’appartenance.

Enfin, le nom de la classe d’appartenance sera transmis un module de synthèse vocale qui permettra de restituer le nom de la classe d’un point de vue audio.

Par ailleurs, 2 boutons permettront de démarrer et d’arrêter la phase de décision.

À venir prochainement

Si vous jetez un oeil sur le repo Github vous verrez que le coeur du projet est bien avancé.
Vous pouvez donc fouiller pour voir l’évolution du projet en termes de code.
L’article qui suivra détaillera la configuration nécessaire du raspberry à partir d’une configuration vierge.

Le matériel utilisé (liens affiliés — si vous commandez via ce lien, j’ai quelques % en commission pour payer l’hébergement de ce site l!):

C++ / un squelette type pour compiler vos projets

C++ / un squelette type pour compiler vos projets

Programmer en C++ pour votre Raspberry Pi

Le développement d’application en langage python n’est pas la seule solution pour la création d’application pour votre Raspberry Pi.
C++ est également un très bon choix même si la rapidité de développement est plus faible que pour le langage Python.
Il existe plusieurs façons de développer.
La première est d’utiliser un environnement de développement complet qui permet la prise en charge de l’intégrité du projet.
C’est à dire d’édition des sources à la compilation en passant par la gestion de la configuration de la compilation et l’outil de débogage.
La seconde est l’édition d’un éditeur performant (vim, emacs…) et un outil de compilation par ailleurs.

La première méthodologie décrite ci-dessus nécessite un IDE de bonne qualité. Pour les utilisateurs d’un système basé sur Linux, le choix le plus populaire actuellement (2018) est sans doute QT Creator. Cependant sur le Raspberry Pi, cette solution est un peu couteuse en ressources.
La seconde option est, à mon sens, plus légère et permet d’avoir un environnement de développement performant et sur multiplateforme.
En effet, la manière conventionnelle de compiler sous Linux est d’utiliser un makefile, un fichier reprend en charge la compilation de votre projet en seulement une instruction.
Cependant un makefile ne vous garantit pas une compilation multiplateforme.
Il permet juste de réaliser une succession d’instruction de compilation.
Néanmoins, un outil permet de générer des makefile en fonction de la configuration des outils disponibles sur votre machine de développement.
Cet outil, c’est CMake!

CMake

Cmake vous permettra de générer des makefile pour votre projet mais également pour la copilation sur votre machine mais permettra le déployement de votre projet sur d’autres machines.

Afin de pouvoir réaliser la compilation, j’ai créé une base de projet qui me permet de démarrer rapidement un projet en langage C++ et ceci, quelle que soit la plateforme sur laquelle je développe.

Cette base de projet est disponible ici : https://github.com/clemaitre58/ProjSkeletonCpp

L’architecture du projet est la suivante :

+-- data               --> pour contenir d'éventuelles données
+-- src                --> pour vos sources
|   +-- CMakeModules   
|   +-- apps           --> sources de votre application (main.cc par exemple)
|   +-- cmake
|   +-- common         --> sources d'api, librairie, etc
|   +-- tests          --> vos tests GoogleTests ici

Pour l’utiliser, il suffit de mettre vos sources dans les dossiers commons ou apps et ensuite de réaliser l’ensemble des instructions disponible dans le README :

Compilation

Create a build folder:

mkdir build

  • Move to the created folder:

cd build

  • Create the MakeFile via cmake:

cmake ../src

To configure to be in debug mode :

cmake -DCMAKE_BUILD_TYPE=Debug ../src

  • Compile the code to generate the executable:

make or make -j n where n is the number of cores to use for the compilation

  • A folder bin will be created at the same level as the build directory.

Remarks

  • If you add new file or remove some other, you have to create the makefile again:

cmake ../src

Un exemple d’utilisation est disponible ici : https://github.com/clemaitre58/BSCVDemoCpp1718

Alors c’est quoi votre prochain projet en C++ pour votre Raspberry Pi?

Utiliser Dropbox sur son Raspeberry Pi

Dropbox sur son Raspeberry Pi

Dropbox est un service très pratique qui permet de sauvegarder des données et de les synchroniser via le cloud.
C’est un service gratuit jusqu’à une limite de 2Go de données.
C’est également sans doute le service de cloud, le plus populaire actuellement avec le Drive de google.
Comme tout bon service de cloud, la synchronisation est automatisée à l’aide d’un client qui tourne en tâche de fond et dont la seule visibilité est la présence d’information dans la barre de tâche.

Des versions de ce client existe pour :
– windows
– Mac
– Linux

Malheureusement, la version Linux gère seulement les processeurs de type Intel et non le processeur ARM que possède notre Raspberry Pi.

Cependant, il existe une solution même si elle est moins user Friendly que le client de chez Dropbox. En effet, Andrea Fabrizi
a développé une série de scripts qui permettent de téléverser (ça, c’est la version validée pas l’Académie française d’uploader) et de télécharger des données de son espace cloud.

Sans rentrer dans le détail, sachez que l’auteur des scripts manipule en fait l’api proposé par Dropbox aux développeurs. Cela vous parait peut être un détail, mais cela a son importance, car, il vous faudra une clé de développement pour faire fonctionner le bousin!

Prérequis

Avant toute manipulation, faites les sauvegardes nécessaires.
Mettez également à jour votre système :

sudo apt-get update
sudo apt-get upgrade

Vous devez également installer git (git est un outil de versionning) si ce n’est pas déjà fait :

sudo apt-get install git

Installation

Rendez-vous sur cette page : https://github.com/andreafabrizi/Dropbox-Uploader

puis dans une console, placez-vous dans un dossier spécifique (on va dire ~/Documents/Code)

cd ~/Documents/Code

puis clonons le repo de github

git clone https://github.com/andreafabrizi/Dropbox-Uploader

placez-vous dans le dossier qui vient d’être créé :

cd Dropbox-Uploader

Changer les droits :

chmod +x dropbox_uploader.sh

puis lancer le script :

./dropbox_uploader.sh

Ce premier lancement se fait sans paramètres puisque vous aurez besoin de saisir une clé d’API dropbox. Cette étape de configuration est faite pas à pas et très bien documentée.

votre premier upload

Vous pouvez maintenant uploader un dossier, imaginons ~/Document/Cours

Pour cela, il suffit de saisir la commande :

./dropbox_uploader.sh upload ~/Documents/Cours /

Ce qui va permettre de téléverser le dossier Cours en racine de Dropbox.

La stratégie pour le download est équivalente.

Pour aller plus loin

Je joins ici quelques exemples de l’auteur :

> ./dropbox_uploader.sh upload /etc/passwd /myfiles/passwd.old
> ./dropbox_uploader.sh upload *.zip /
> ./dropbox_uploader.sh -x .git upload ./project /
> ./dropbox_uploader.sh download /backup.zip
> ./dropbox_uploader.sh delete /backup.zip
> ./dropbox_uploader.sh mkdir /myDir/
> ./dropbox_uploader.sh upload "My File.txt" "My File 2.txt"
> ./dropbox_uploader.sh share "My File.txt"
> ./dropbox_uploader.sh list

ainsi que la documentation : ici

ma config

  • RPi 3
  • Raspbian Jessie

UART USB : un port série supplémentaire pour mon Raspberry Pi

UART USB RPi

UART USB : un port série supplémentaire pour mon Raspberry Pi

Votre Raspberry Pi possède quelques soit sa version un port série.
Ce port permet de prendre le contrôle de votre Raspberry Pi mais, ça reste une utilisation marginale.
En effet, ce port est à coup sûre plus utile dans les communications entre processeurs et d’autres microcontroleurs que ce soit des arduino ou des micro plus classiques comme les ARM.

Cependant si vous utilisez le port série de votre GPIO, cela vous prive de 2 broches IO de votre Framboise.
De plus, co porte peut ne pas être disponible. En effet, si vous utiliser un Hat, votre port GPIO n’est plus aisement accessible.

Pourtant, il existe des solution simple.

Le port RS232 n’est plus accessible! Une solution simple

En effet, des modules complémentaires à brancher existent. Il suffit les brancher sur le port USB pour transformer votre pour USB en un port RS232 virtuel.
On nomme ces modiles UART – USB.
Dans mon cas, j’utilise un modèle à moins 10€ qu’on peut trouver sur amazon.
Ce module m’est utile pour debugger la sortie RS232 d’un ARM (STN32L432KC), plus particulièrement ça me permet de voir si les données envoyées sur le port RS232 sont bien celles attendues.

UART USB RPi

Je vais vous montrer comment réaliser cette tâche.

Mise en pratique

Vous allez voir, c’est très très simple :

  • On branche le module sur le port USB du RPI. Il est détecté automatiquement. Nul besoin d’installer qqch. Pour ceux qui on pratiquer le port USB à ses débuts, je peux vous dire que c’est le bonheur.
  • On va utiliser un utilitaire pour lire le pors RS232 émuler sur USB.

Pour cela :

grabserial -v -d "/dev/ttyUSB0" -b 115200 -w 8 -p N -s 1 -e 30

Cette commande signifie que vous allez exécuter un grab, une lecture, du port /dev/ttyUSB0 (le port série émulé) avec le formalisme RS232 suivant :

  • 115200 bauds de vitesse
  • 8 bits de données
  • Parité pair
  • 1 bit de stop

le tout pour une durée de 30sec.

Le résultat de cette lecture est affiché dans la fenêtre de votre console. Si vous voulez logger les données dans un fichier il suffit de rediriger le flux vers un fichier.
De cette façon :

grabserial -v -d "/dev/ttyUSB0" -b 115200 -w 8 -p N -s 1 -e 30 >> mon_fichier.log

#Et pour écrire sur ce port?

L’application grabserial permet de rapidement faire un log. Pour des applications de lecture et d’écriture spécifique vous serez obliger d’écrire votre propre code.
A mon sens le plus simple étant d’utiliser Python et la libraire pyserial.

Alors prêt à manipuler une UART USB.

Module RTC ds1307 : installer et configurer une horloge externe pour votre Raspberry Pi

Module RTC ds1307 :

Un problème récurrent des utilisateurs de Raspberry Pi est que celui ci ne possède pas d’horloge interne.
Ceci a pour effet de ne pas pouvoir réaliser d’application utilisant des informations sur l’heure absolue (par exemple faire une actions tous les jours à 20h) sans être connecté à un internet. En effet, votre connection internet, vous permet de récupérer leur sur un serveur donné.

Pour pouvoir réaliser ce genre d’opération, il faut avoir recours à un module RTC (Real-Time Clock) qu’on peut traduire « horloge temps réel ».
Ce genre de module n’est ni plus ni moins une horloge externe alimentée par une pile bouton, qui après une première initialisation, peut être interrogée par le raspberry pi pour obtenir l’heure.

Dans mon cas, j’ai choisi le Module RTC ds1307. Ce choix est expliqué pour plusieurs raisons :

  • le module est très courant
  • le module ce trouve pour moins 5€ (par exemple sur aliexpress)
  • ce module a un support natif par la version Jessie du système raspbian
  • il est i2c ce qui réduit le nombre de boches mobilisées sur le port GPIO

Connection du module

Le module est très simple à brancher. Vous devez uniquement connecter :

  • VCC
  • GND
  • SCL
  • SDA

du module sur les broches du même nom du Raspberry Pi.

Vérification de la détection du nodule sur le Bus i2c

Si votre port i2c n’est pas activé, rien de plus simple. Il suffit d’exécuter :

 sudo raspi-config

Dans le menu Advenced, il faut rendre actif le port i2c.
Nous allons vérifier que le module est bien détecté mais , au péralable, il faut installer les outils nécessaire à cette tâche.

sudo apt-get install python-smbus i2c-tools

Puis nous pouvons utiliser l’utilitaire i2cdetect :

sudo i2cdetect -y 1

L’instruction est différente suivant les versions du Raspberry Pi1

Cette instruction devrait vous retourner l’équivalent de l’écran suivant :

On voit que le RPi a détecté un composant à l’adresse 0x68 qui d’après la doc constructeur l’adresse par défaut.

Installation du Module RTC ds1307

On va ajouter la gestion du module en éditant le fichier de configuration de boot.

sudo nano /boot/config.txt

Auquel on va ajouter un la ligne suivante à la fin du fichier :

dtoverlay=i2c-rtc,ds1307

A ce stade, vous devez redémarrez votre système :

sudo reboot

Une fois le système de nouveau actif, il vous pouvez éxécuter de nouveau:

sudo i2cdetect -y 1

Vous devriez observer si le prise en charge de l’horloge est effective en obtenant les caractères UU à l’adresse 0X68

Il vous est maintenant nécessaire de désactiver l’horloge qui émule l’horloge hardware «fake hwclock> avec les instructions suivantes :

sudo apt-get -y remove fake-hwclock
sudo update-rc.d -f fake-hwclock remove

Puis décommenter les lignes suivantes du fichier (en début de fichier) /lib/udev/hwclock-set :

#if [ -e /run/systemd/system ] ; then
# exit 0
#fi

Configuration de l’horloge du Module RTC ds1307

Pour configuer votre horloge RTC, à partir de l’heure système (nécessite donc une connexion à Internet):

sudo hwclock -w

NB : W pour Write

Pour vérifier que votre horloge est bien à l’heure, il suffit cette fois-ci de lire

sudo hwclock -r

NB : R pour Read

Vérification du fonctionnement

Pour vérifier, le bonctionnement du système, couper la connexion internet (faite éventuellement un reboot) et exécuté :

date

Si tous c’est bien passé vous devriez obtenir l’heure exact!

Alors prêt à utiliser le Module RTC ds1307?


  1. Si votre raspberry est une version antérieur au Pi 3 et Pi Zero, l’instruction est sudo i2cdetect -y 0 

Modifier l’url par défaut de Gitlab

Si vous avez installé votre forge Gitlab en local sur un Raspberry P, il y a fort a parier que vous  vouliez garder le RPi dans votre réseau privée.

Cependant, vous voudrez sans doute le rendre accessible depuis extérieure. Pour cela, vous devrez donc faire pointez une URL vers un votre Box internet qui routera le port 80 vers votre RPi.

Jusque là rien que du bien classique. Malheureusement, à l’usage vous remarquerez que l’adresse par défaut de vos projets ne sont pas utilisable depuis l’extérieur. En effet,  quand vous récupérer l’adresse pour faire un clone d’un projet vous aurez l’adresse suivante :

http://localhost/monuser/mon-projet.git ou http://nomdelamachine/monuser/mon-projet.git

Pour corriger cela, il est nécessaire d’éditer le fichier de config :

nano /etc/gitlab/gitlab.rb

et de modifier la ligne suivante :

external_url 'http://gitlab.example.com'

par

external_url 'http://monurl.com'

 

Plus d’informations ici