Le routeur en tête réseau PI - Historique des versions

Jpinon : /* Installation des outils */

2026-04-22T21:54:32Z

Installation des outils

← Version précédente		Version du 22 avril 2026 à 21:54
Ligne 179 :		Ligne 179 :
	</syntaxhighlight>Ensuite on installe le script qui installera lui même l'écran.<syntaxhighlight lang="bash">		</syntaxhighlight>Ensuite on installe le script qui installera lui même l'écran.<syntaxhighlight lang="bash">
	cd ~		cd ~
	sudo apt-get update		sudo apt-get update # discutable
	sudo apt-get install -y git python3-pip		sudo apt-get install -y git python3-pip # aussi
	pip3 install --upgrade adafruit-python-shell click Flask-SQLAlchemy		pip3 install --upgrade adafruit-python-shell click Flask-SQLAlchemy
	git clone https://github.com/adafruit/Raspberry-Pi-Installer-Scripts.git		git clone https://github.com/adafruit/Raspberry-Pi-Installer-Scripts.git

Jpinon : correction venv python d'install de l'écran

2026-04-22T21:52:25Z

correction venv python d'install de l'écran

← Version précédente		Version du 22 avril 2026 à 21:52
Ligne 175 :		Ligne 175 :
	Il faut d'abord installer les outils python de virtualisation d'environnement.<syntaxhighlight lang="bash">		Il faut d'abord installer les outils python de virtualisation d'environnement.<syntaxhighlight lang="bash">
	sudo apt install python3-venv		sudo apt install python3-venv
	~~python~~ -m venv env --system-site-packages		python3 -m venv env --upgrade-deps --system-site-packages
	source env/bin/activate		source env/bin/activate
	</syntaxhighlight>Ensuite on installe le script qui installera lui même l'écran.<syntaxhighlight lang="bash">		</syntaxhighlight>Ensuite on installe le script qui installera lui même l'écran.<syntaxhighlight lang="bash">

Jpinon le 16 mars 2026 à 16:44

2026-03-16T16:44:51Z

← Version précédente		Version du 16 mars 2026 à 16:44
Ligne 813 :		Ligne 813 :
	sudo systemctl restart dnsmasq		sudo systemctl restart dnsmasq
	Et c'est tout.		Et c'est tout.

			=== Ajout d'une règle de redirection de port NAP/PAT ===
			Dans cet exemple je vais rediriger ce qui rentre sur le port 2222 de eth0 sur front-router vers le port 22 sur le serveur git.

			==== Modification: ====
			Tout se fait dans <code>/etc/nftables.conf</code>.

			On ajoute dans <code>table ip filter</code> la chaine <code>forward</code>doit être modifiée:<syntaxhighlight lang="c">
			chain forward {
			type filter hook forward priority 0; policy drop;

			# flux établis
			ct state established,related accept

			# ICI LES ANCIENNES REGLES

			# DNAT SSH WAN:2222 -> GIT:22
			iifname $WAN oifname $LAN ip daddr $GIT tcp dport 22 ct state new accept
			}

			</syntaxhighlight>Et le post routing.<syntaxhighlight lang="c">
			table ip nat {
			chain prerouting {
			type nat hook prerouting priority -100; policy accept;

			# DNAT SSH (port 2222 du frontal -> GIT:22)
			iifname $WAN tcp dport 2222 dnat to $GIT:22
			}

			</syntaxhighlight>

			==== Application ====
			On valide la syntaxe par :<syntaxhighlight lang="bash">
			sudo nft -f /etc/nftables.conf
			</syntaxhighlight>Et on relance par :<syntaxhighlight lang="bash">
			sudo systemctl restart nftables
			</syntaxhighlight>

			==== Récapitulation ====
			Le fichier <code>/etc/nftables.conf</code> contient maintenant :<syntaxhighlight lang="c">
			flush ruleset

			define WAN = "eth0" # 192.168.0.0/24
			define LAN = "eth1" # 10.11.11.0/24
			define LAN_NET = 10.11.11.0/24
			define GIT = 10.11.11.30

			table ip filter {
			chain input {
			type filter hook input priority 0; policy drop;

			# loopback
			iifname "lo" accept

			# established/related
			ct state established,related accept

			# ICMP utile
			ip protocol icmp accept

			# DNS vers le routeur (clients du sous-LAN)
			iifname $LAN udp dport 53 accept
			iifname $LAN tcp dport 53 accept

			# DHCP serveur (dnsmasq)
			iifname $LAN udp sport 68 udp dport 67 accept
			iifname $LAN udp sport 67 udp dport 68 accept

			# SSH vers le routeur (port 22)
			iifname $LAN tcp dport 22 accept
			ip saddr 192.168.0.0/24 iifname $WAN tcp dport 22 accept

			# HTTP/HTTPS vers Caddy sur le frontal
			iifname $WAN tcp dport {80, 443} accept
			iifname $LAN tcp dport {80, 443} accept
			# HTTP/3 (QUIC)
			iifname $WAN udp dport 443 accept
			}

			chain forward {
			type filter hook forward priority 0; policy drop;

			# flux établis
			ct state established,related accept

			# LAN -> WAN (trafic sortant)
			iifname $LAN oifname $WAN ct state new accept

			# DNAT SSH WAN:2222 -> GIT:22
			iifname $WAN oifname $LAN ip daddr $GIT tcp dport 22 ct state new accept
			}

			chain output {
			type filter hook output priority 0; policy accept;
			}
			}

			table ip nat {
			chain prerouting {
			type nat hook prerouting priority -100; policy accept;

			# DNAT SSH (port 2222 du frontal -> GIT:22)
			iifname $WAN tcp dport 2222 dnat to $GIT:22
			}

			chain postrouting {
			type nat hook postrouting priority 100; policy accept;

			# Masquerade LAN -> WAN
			oifname $WAN ip saddr $LAN_NET masquerade
			}
			}
			</syntaxhighlight>Oui c'est mort depuis le WAN seul le HTTPS est ouvert (et le HTTP pour let's encrypt) inutile d'essayer de rentrer (par là en tout cas)

Jpinon : /* Fichier config.txt */

2025-12-20T22:16:20Z

Fichier config.txt

← Version précédente		Version du 20 décembre 2025 à 22:16
Ligne 222 :		Ligne 222 :
	On l'édite avec<syntaxhighlight lang="bash">		On l'édite avec<syntaxhighlight lang="bash">
	sudo vi /boot/firmware/config.txt		sudo vi /boot/firmware/config.txt
	</syntaxhighlight>Et on y trouves <syntaxhighlight lang="ini">		</syntaxhighlight>La première chose est de DESACTIVER le son car: Si un écran HDMI est branché tout va bien le son est dirigé vers là. Mais il n'y a pas d'écran le son est dirigé vers le port jack 3.5 qui est géré par le GPIO 18 en PWM. On c'est ce GPIO qui est utilisé par Adafruit pour le rétro éclairage de l'écran. <syntaxhighlight lang="ini">
			# Désactiver audio PWM
			dtparam=audio=off
			</syntaxhighlight>On désactive le son sur le JACK 3.3 comme ça. Le Raspberry PI 5 qui supprime le port jack 3.5 ne doit pas nécessiter cela.

			Ensuite

			Et on y trouves <syntaxhighlight lang="ini">
	# --- added by adafruit-pitft-helper ---		# --- added by adafruit-pitft-helper ---
	[all]		[all]
Ligne 234 :		Ligne 241 :
	# --- added by adafruit-pitft-helper ---		# --- added by adafruit-pitft-helper ---
	[all]		[all]
	~~hdmi_force_hotplug=0~~
	dtparam=spi=on		dtparam=spi=on
	dtparam=i2c1=on		dtparam=i2c1=on
	dtparam=i2c_arm=on		dtparam=i2c_arm=on
	dtoverlay=pitft28-capacitive,rotate=270,speed=64000000,fps=30,drm		dtoverlay=pitft28-capacitive,rotate=270,speed=64000000,fps=30,drm
			dtoverlay=gpio-backlight,gpios=18,active_low=0
	hdmi_force_hotplug=1		hdmi_force_hotplug=1
	hdmi_group=2		hdmi_group=2
	hdmi_mode=82		hdmi_mode=82

	# --- end adafruit-pitft-helper ---		# --- end adafruit-pitft-helper ---
	</syntaxhighlight>C'est mieux ~~et en plus on peut gérer les 4 boutons de droite~~.		</syntaxhighlight>C'est mieux.

	J'ai ai profité pour retourner l'écran (rotate=270) car avec un rotatate=90 les boutons sont a gauche.		J'ai ai profité pour retourner l'écran (rotate=270) car avec un rotatate=90 les boutons sont a gauche.

Jpinon : /* Economiseur d'écran. */ Correction du script pour gerer le timeout de l'economiseur même avec ecran HDMI débranche

2025-12-20T22:10:22Z

Economiseur d'écran. : Correction du script pour gerer le timeout de l'economiseur même avec ecran HDMI débranche

← Version précédente		Version du 20 décembre 2025 à 22:10
Ligne 273 :		Ligne 273 :
	Le script bash est assez simple:<syntaxhighlight lang="bash" line="1">		Le script bash est assez simple:<syntaxhighlight lang="bash" line="1">
	#!/bin/bash		#!/bin/bash
			# /usr/local/bin/gpio-screen-saver.sh
			# Extinction du backlight après IDLE_TIMEOUT, rallumage par bouton (libgpiod v2).
			# BL=GPIO18 (1=ON, 0=OFF), BTN=GPIO27 (pull-up interne, appui → INACTIVE).

	set -euo pipefail		set -euo pipefail

	~~SCREEN_GPIO~~=~~530~~		CHIP="/dev/gpiochip0"
	~~BTN_GPIO~~=~~539~~		BL_PIN=18
	IDLE_TIMEOUT=20 # secondes		BTN_PIN=27
			IDLE_TIMEOUT=10 # secondes (adapter)
			SLEEP_STEP=0.2
			MIN_OFF_HOLD=1 # hystérésis OFF minimale (s)

	~~# Exporter les GPIO si nécessaire~~		GPIOSET="/usr/bin/gpioset"
	~~for g in $SCREEN_GPIO $BTN_GPIO; do~~		GPIOGET="/usr/bin/gpioget"
	~~if [ ! -e /sys~~/~~class~~/~~gpio~~/~~gpio$g ]; then~~
	~~echo $g > /sys~~/~~class~~/~~gpio~~/~~export~~		log() { printf '[backlight] %s\n' "$*"; }
	fi
	~~done~~

	~~# Configurer les directions~~		is_on=true
	~~echo out > /sys/class/gpio/gpio~~$~~SCREEN_GPIO/direction~~		last_activity=$(date +%s)
	~~echo in > /sys/class/gpio/gpio$BTN_GPIO/direction~~		off_since=0

	~~# Allumer l'écran au démarrage~~		cleanup() {
	~~echo~~ 1 ~~> /sys/class/gpio/gpio$SCREEN_GPIO/value~~		if [[ "$is_on" != true ]]; then
			log "Exit: backlight ON"
			"$GPIOSET" -c "$CHIP" -t 0 "$BL_PIN=1" \|\| true
			fi
			}
			trap cleanup EXIT

			log "Start: backlight ON"
			"$GPIOSET" -c "$CHIP" -t 0 "$BL_PIN=1"
			is_on=true
	last_activity=$(date +%s)		last_activity=$(date +%s)

	while true; do		while true; do
	~~btn_state~~=$(~~cat~~ /~~sys~~/~~class/gpio/gpio~~$~~BTN_GPIO/value~~)		now=$(date +%s)
	if [ "$~~btn_state~~" = "0" ]; then
	~~echo 1~~ > /~~sys~~/~~class/gpio/gpio~~$~~SCREEN_GPIO/value~~		# --- Lecture du bouton avec pull-up ---
	~~last_activity~~=$(~~date +%s~~)		raw=$("$GPIOGET" -c "$CHIP" -b pull-up "$BTN_PIN" 2>/dev/null \|\| echo "$BTN_PIN=inactive")
			state=$(echo "$raw" \| awk -F= '{print $2}') # "active" ou "inactive"

			if [[ "$state" == "inactive" ]]; then
			# Appui (niveau bas), anti-rebond
			sleep 0.02
			raw2=$("$GPIOGET" -c "$CHIP" -b pull-up "$BTN_PIN" 2>/dev/null \|\| echo "$BTN_PIN=inactive")
			state2=$(echo "$raw2" \| awk -F= '{print $2}')

			if [[ "$state2" == "inactive" ]]; then
			if [[ "$is_on" != true ]]; then
			log "Button press → backlight ON"
			"$GPIOSET" -c "$CHIP" -t 0 "$BL_PIN=1"
			is_on=true
			fi
			last_activity=$now
			sleep 0.2 # anti-rebond
			fi
	fi		fi
			# --- Fin lecture bouton ---

	~~now~~=~~$(date +%s)~~		if [[ "$is_on" == true ]]; then
	if (( now - last_activity >= IDLE_TIMEOUT )); then		if (( now - last_activity >= IDLE_TIMEOUT )); then
	~~echo~~ 0 ~~> /sys/class/gpio/gpio~~$~~SCREEN_GPIO/value~~		log "Idle >= ${IDLE_TIMEOUT}s → backlight OFF"
	~~last_activity~~=$(( now - ~~IDLE_TIMEOUT + 1~~ ))		"$GPIOSET" -c "$CHIP" -t 0 "$BL_PIN=0"
			is_on=false
			off_since=$now
			fi
			else
			# Hystérésis OFF minimale (optionnel)
			if (( now - off_since < MIN_OFF_HOLD )); then :; fi
	fi		fi

	sleep ~~0.1~~		sleep "$SLEEP_STEP"
	done		done

	</syntaxhighlight>'''La ligne 2''' indique à bash comment gérer les erreurs		</syntaxhighlight>'''La ligne 2''' indique à bash comment gérer les erreurs

Jpinon : /* Architecture réseau: */

2025-12-18T08:26:33Z

Architecture réseau:

← Version précédente		Version du 18 décembre 2025 à 08:26
Ligne 12 :		Ligne 12 :
	* eth0 (le port Ethernet standard) sera relié au WAN en tant que client DHCP. C'est sur le routeur auquel il est relié que le serveur DHCP attribuera (ou pas) une IP fixe.		* eth0 (le port Ethernet standard) sera relié au WAN en tant que client DHCP. C'est sur le routeur auquel il est relié que le serveur DHCP attribuera (ou pas) une IP fixe.
	* eth1 (le port Ethernet sur USB) sera relié au LAN. Il sera configuré en serveur DHCP et s'occupera du sub-net 10.11.11.0/24. Les autres raspberry seront reliés à ce port via un switch.		* eth1 (le port Ethernet sur USB) sera relié au LAN. Il sera configuré en serveur DHCP et s'occupera du sub-net 10.11.11.0/24. Les autres raspberry seront reliés à ce port via un switch.
			La configuration réseau n'est pas idéale car le contrôleur USB du PI2 n'est pas USB3 mais USB2 et le port ethernet natif est également un ethernet USB. Donc les deux ports partageront la bande passante de l'USB2 de 480 Mbs max.

	Derrière on aura toute sorte de serveurs basés sur des raspberry PI du genre:		L'utilisateur d'un adaptateur gigabit n'a donc pas vraiment d'intérêt car sur les 480 l'Ethernet embarqué utilise déjà 100Mbs... il en reste théoriquement 380 a disposition sans compter les conflits.

			Bon moi j'ai un adaptateur gigabit car c'est le standard aujourd'hui! Je serais prêt si je dois passer à un Raspberry PI 4 qui gère de l'USB3 a 5Gbs et un Ethernet Gigabit. Je ne penses cependant pas que ce soit nécessaire. Le switch est gigabit et si, dans le LAN 10.11.11.0/24 on a deux PI4 ils communiqueront entre eux en gigabit.

			Derrière on aura donc toute sorte de serveurs basés sur des raspberry PI du genre:

	* Serveur node-red		* Serveur node-red
	* Serveur MariaDB		* Serveur MariaDB
	* Serveur MediaWiki		* Serveur MediaWiki
			* Serveur Git
	* ce dont on aura besoin...		* ce dont on aura besoin...

Jpinon : /* Présentation */

2025-12-17T09:07:10Z

Présentation

← Version précédente		Version du 17 décembre 2025 à 09:07
Ligne 6 :		Ligne 6 :
	Schématiquement on a un raspberry PI en frontal. Il n'a en aucun cas besoin de wifi donc un simple Raspbery PI2 sera suffisant.		Schématiquement on a un raspberry PI en frontal. Il n'a en aucun cas besoin de wifi donc un simple Raspbery PI2 sera suffisant.

	En revanche il lui faudra ~~deus~~ "pattes" réseau donc un adaptateur USB - Ethernet sera nécessaire. De plus un écran [[Écran Adafruit 2.8 pouces TFT\|Adafruit 2.8']] sera utilisé pour le "status".		En revanche il lui faudra deux "pattes" réseau donc un adaptateur USB - Ethernet sera nécessaire. De plus un écran [[Écran Adafruit 2.8 pouces TFT\|Adafruit 2.8']] sera utilisé pour le "status".

	=== Architecture réseau: ===		=== Architecture réseau: ===

Jpinon : /* Un petit dashboard sur la console */

2025-12-07T21:21:45Z

Un petit dashboard sur la console

← Version précédente		Version du 7 décembre 2025 à 21:21
Ligne 530 :		Ligne 530 :
	sleep 10		sleep 10
	done		done
	</syntaxhighlight>Si on le lance:~~<syntaxhighlight lang="text">~~		</syntaxhighlight>Si on le lance:
	~~Thu 4 Dec 00:49:47 CET 2025~~
	~~-----------------------------------------------~~		[[Fichier:Dashboard-router.png\|sans_cadre\|432x432px]]
	~~Routeur WAN IP~~: ~~192.168.X.X~~
	~~LAN Gateway : 10.11.11.1~~		Le plus élégant serait que ce script se lance sur le petit écran LCD du PI au démarrage. Facile on a configuré l'autologin...<syntaxhighlight lang="bash">
	~~-------~~-~~---------------------------------------~~
	~~LAN Clients:~~
	~~d8:3a:dd:d8:XX:XX 10.11.11~~.~~XXX database~~
	~~dc:a6:32:67:XX:XX 10.11.11.XXX main-host~~
	~~b8:27:eb:e1:XX:XX 10.11.11.XXX test~~
	~~</syntaxhighlight>~~Le plus élégant serait que ce script se lance sur le petit écran LCD du PI au démarrage. Facile on a configuré l'autologin...<syntaxhighlight lang="bash">
	vi ~/.profile		vi ~/.profile
	</syntaxhighlight>Et on ajoute à la fin:<syntaxhighlight lang="bash">		</syntaxhighlight>Et on ajoute à la fin:<syntaxhighlight lang="bash">
Ligne 550 :		Ligne 544 :
	tput cnorm # Show carret		tput cnorm # Show carret
	fi		fi
	</syntaxhighlight>Sur la console principale (l'écran LCD adafruit) il est toujours possible de sortir du dashboard avec <Ctrl> + C		</syntaxhighlight>Sur la console principale (l'écran LCD adafruit) il est toujours possible de sortir du dashboard avec <Ctrl> + C

	=== Serveur DNS ===		=== Serveur DNS ===

Jpinon : /* Un petit dashboard sur la console */

2025-12-07T21:16:55Z

Un petit dashboard sur la console

← Version précédente		Version du 7 décembre 2025 à 21:16
Ligne 500 :		Ligne 500 :
	Un petit script permet d'avoir les info essentielles :<syntaxhighlight lang="bash">		Un petit script permet d'avoir les info essentielles :<syntaxhighlight lang="bash">
	#!/bin/bash		#!/bin/bash
			set -o pipefail

	printf "\e[2J"		printf "\e[2J"
			esc=$'\e'
	while [ 1 ]		while [ 1 ]
	do		do
	printf "\e[1;1H"		printf "\e[1;1H"
	date		date "+%d/%m/%Y %H:%M"
	echo "-----------------------------------------------"		echo "-----------------------------------------------"
	echo -n "Routeur WAN IP: "		echo -n "Routeur WAN IP: "
	ifconfig eth0 \| grep "inet " \| awk '{print $2}'		ifconfig eth0 \| grep "inet " \| awk '{print $2 " "}'
	echo -n "LAN Gateway : "		echo -n "LAN Gateway : "
	ifconfig eth1 \| grep "inet " \| awk '{print $2}'		ifconfig eth1 \| grep "inet " \| awk '{print $2 " "}'
	echo "-----------------------------------------------"		echo "-----------------------------------------------"
	echo "LAN Clients: "		echo "LAN Clients: "
	cat /var/lib/misc/dnsmasq.leases \| awk '{print $2,$3,$4}'		cat /var/lib/misc/dnsmasq.leases \| awk '{print "\033[94m",$2, "\033[0m",$3,"\033[93m",$4,"\033[0m"}'
	sleep 1		echo "-----------------------------------------------"
			echo "Services: http"
			printf "node-red\t"
			curl --max-time 2 -I -s http://main-host.pilan:1880 \| grep HTTP \| sed "s/OK/${esc}[30;42m[OK]${esc}[0m 1880/"
			if [[ $? != 0 ]]; then
			printf "\033[31mERREUR\033[0m\n"
			fi
			printf "webssh \t"
			curl --max-time 2 -I -s http://main-host.pilan:8888 \| grep HTTP \| sed "s/OK/${esc}[30;42m[OK]${esc}[0m 8888/"
			if [[ $? != 0 ]]; then
			printf "\033[31mERREUR\033[0m\n"
			fi
			sleep 10
	done		done
	</syntaxhighlight>Si on le lance:<syntaxhighlight lang="text">		</syntaxhighlight>Si on le lance:<syntaxhighlight lang="text">

Jpinon : /* Economiseur d'écran. */

2025-12-07T20:55:31Z

Economiseur d'écran.

← Version précédente		Version du 7 décembre 2025 à 20:55
Ligne 257 :		Ligne 257 :

	==== Economiseur d'écran. ====		==== Economiseur d'écran. ====
			L'écran LCD est toujours allumé dans ce cas. C'est pratique mais ca chauffe énormément, ça l'use et ca consomme. Bref ppas top.

			On va faire un économiseur d'écran. On pourrait le faire en détectant un appui dessus mais la date tactile du mien est morte. On a cependant 4 bon vieux boutons physiques que je vais utiliser.

			On a des boutions marqués de haut en bas <code>#17</code>, <code>#22</code>, <code>#23</code> et <code>#27</code>.

			Nous nous proposons d'utiliser le bouton du bas soit <code>#27</code>.

			Le script bash est assez simple:<syntaxhighlight lang="bash" line="1">
			#!/bin/bash
			set -euo pipefail

			SCREEN_GPIO=530
			BTN_GPIO=539
			IDLE_TIMEOUT=20 # secondes

			# Exporter les GPIO si nécessaire
			for g in $SCREEN_GPIO $BTN_GPIO; do
			if [ ! -e /sys/class/gpio/gpio$g ]; then
			echo $g > /sys/class/gpio/export
			fi
			done

			# Configurer les directions
			echo out > /sys/class/gpio/gpio$SCREEN_GPIO/direction
			echo in > /sys/class/gpio/gpio$BTN_GPIO/direction

			# Allumer l'écran au démarrage
			echo 1 > /sys/class/gpio/gpio$SCREEN_GPIO/value

			last_activity=$(date +%s)

			while true; do
			btn_state=$(cat /sys/class/gpio/gpio$BTN_GPIO/value)
			if [ "$btn_state" = "0" ]; then
			echo 1 > /sys/class/gpio/gpio$SCREEN_GPIO/value
			last_activity=$(date +%s)
			fi

			now=$(date +%s)
			if (( now - last_activity >= IDLE_TIMEOUT )); then
			echo 0 > /sys/class/gpio/gpio$SCREEN_GPIO/value
			last_activity=$(( now - IDLE_TIMEOUT + 1 ))
			fi

			sleep 0.1
			done

			</syntaxhighlight>'''La ligne 2''' indique à bash comment gérer les erreurs

			<code>'''-e'''</code> implique qu'a la première commande en erreur (!=0) le script entier s'arrête (pas besoin de gérer les codes retour)

			<code>'''-u'''</code> si on accède à une variable d'environnement non existante le script s'arrête (Lutte contre les fautes de frappe)

			<code>'''-o'''</code> est plus subtile. On l'appelle "pipe fail". Si dans une commande avec des pipe <code>cmd \| cmd1 \| cmd2</code> l'une des commandes plante le code d'erreur du script (le <code>$?</code>) sera celui de la commande en question et pas celui de la dernière. si <code>cmd1</code> provoque une erreur <code>$?=1</code> mais que <code>cmd2</code> passe bien <code>$?=0</code>, le script retournera la valeur du <code>$?</code> de <code>cmd1</code> si l'option <code>-o</code> est utilisée sinon c'est la dernière qui gagne.

			'''Les lignes 3 et 4''' définissent les lignes GPIO utilisées. Les adresse commencent à 512 donc l'écran c'est 512+18 (GPIO18) donc 530 et le bouton c'est 512+27 soit 539.

			'''La ligne 5''' c'est la durée au bout de laquelle l'écran va s'éteindre de nouveau. (20 sec ça ma paru bien pour un simple affichage de status)

			'''Lignes 8 à 13''' une fonction qui exporte le GPIO si ce n'est pas déjà fait.

			'''Lignes 16 et 17''' on définie les directions. écran=out bouton=in

			'''Ligne 20''' on commence par allumer l'écran

			'''Ligne 22''' <code>last_activity</code> reçoit le timestamp courant.

			'''Lignes 24 à 38''' c'est la boucle.

			* '''Lignes 25 à 29''' on allume l'écran su on détecte un appui sur le bouton et <code>ast_activity</code> reçoit le timestamp courant.
			* Lignes 31 à 35 on éteint l'écran si on a dépassé le timeout <code>now - last_activity >= IDLE_TIMEOUT</code>.

			Et c'est tout.

			Maintenant on va faire un service ([[Deamon avec systemd\|un deamon]]) de ce script. C'est décrit dans le lien mail je donne la conf spécifique:<syntaxhighlight lang="ini">
			[Unit]
			Description=Daemon pour économiseur d'écran GPIO
			After=multi-user.target

			[Service]
			Type=simple
			ExecStart=/usr/local/bin/gpio-screen-saver.sh
			Restart=always
			RestartSec=2

			[Install]
			WantedBy=multi-user.target

			</syntaxhighlight>On donne les noms suivants aux fichiers

			* gpio-screen-saver.sh est le bash vu plus haut
			* gpio-screen-saver.service le fichier de conf ci-dessus

			On installe avec:<syntaxhighlight lang="bash">
			#!/bin/bash
			set -euo pipefail

			sudo cp gpio-screen-saver.sh /usr/local/bin/
			sudo chmod +x /usr/local/bin/gpio-screen-saver.sh
			sudo cp gpio-screen-saver.service /etc/systemd/system/

			sudo systemctl daemon-reload
			sudo systemctl enable --now gpio-screen-saver.service
			</syntaxhighlight>SI ca marche bien il affiche juste le lien crée.

			===== Arrêt relance =====
			Tout ceci est bien beau mais l'écran LCD peut aussi servir de console de secours. Il suffit de branche un clavier et de taper ctrl+c et on récupère la console. Le timeout de 20 seconde va vite devenir insupportable (oui le clavier n'est pas pris en compte dedans).<syntaxhighlight lang="bash">
			sudo systemctl stop gpio-screen-saver.service # Arrète le service
			sudo systemctl start gpio-screen-saver.service # Démarre le service
			sudo systemctl restart gpio-screen-saver.service # Redémarre le service (si on change la valeur du timeout pas exemple)
			</syntaxhighlight>Pour avoir le statut:<syntaxhighlight lang="bash">
			sudo systemctl status gpio-screen-saver.service
			</syntaxhighlight>Qui nous donne un joli:
			[[Fichier:Screen-saver.service.png\|sans_cadre\|838x838px]]
			Avec tout plein de détails.

			Pour que l'arrêt soit définitif (même après un reboot):<syntaxhighlight lang="bash">
			sudo systemctl disable gpio-screen-saver.service
			</syntaxhighlight>Et pour le réactiver<syntaxhighlight lang="bash">
			sudo systemctl enable gpio-screen-saver.service
			</syntaxhighlight>

	=== La configuration du réseau ===		=== La configuration du réseau ===

Le routeur en tête réseau PI - Historique des versions

Jpinon : /* Installation des outils */

Jpinon : correction venv python d'install de l'écran

Jpinon le 16 mars 2026 à 16:44

Jpinon : /* Fichier config.txt */

Jpinon : /* Economiseur d'écran. */ Correction du script pour gerer le timeout de l'economiseur même avec ecran HDMI débranche

Jpinon : /* Architecture réseau: */

Jpinon : /* Présentation */

Jpinon : /* Un petit dashboard sur la console */

Jpinon : /* Un petit dashboard sur la console */

Jpinon : /* Economiseur d'écran. */

Jpinon : /* Installation des outils */

Jpinon : correction venv python d'install de l'écran

Jpinon : /* Fichier config.txt */

Jpinon : /* Economiseur d'écran. */ Correction du script pour gerer le timeout de l'economiseur même avec ecran HDMI débranche

Jpinon : /* Architecture réseau: */

Jpinon : /* Présentation */

Jpinon : /* Un petit dashboard sur la console */

Jpinon : /* Un petit dashboard sur la console */

Jpinon : /* Economiseur d'écran. */