Allumer – Éteindre son PC (HAOS)

Noyé dans un océan de doutes

Allumer – Éteindre son PC (HAOS)

Le but

  • Via un simple bouton (bascule) allumer ou éteindre son ordinateur derrière une prise connectée.

Pré-requis 

  • Proxmox
  • HAOS sur une VM (192.168.0.100)
  • Conteneur LXC ID 105 (Debian)
  • Service Samba déjà installé et fonctionnel
  • Couple UserMdP défini sur le système (pve01 / pve01) et enregistré dans Samba
  • Windows 10/11
  • Dans HAOS, les plugins « Advanced Terminal & SSH » ainsi que « Local Files editor » sont un gros plus.

Défis

  • Le bouton est juste un simple bouton switch (toggle) sans moyen de connaître son état donc.
  • La prise connectée alimente le PC ainsi que les écrans, petites lumières, enceintes etc
  • Ne pas couper brutalement l’ordinateur comme si on débrancherai la prise !
  • HAOS est un système très fermé donc le montage réseau exige une configuration via Samba et un montage depuis « Stockage » afin de faire reconnaître l’emplacement réseau.
  • Un service Windows devra surveiller en permanence la présence d’un « déclencheur » qui lui fera comprendre qu’une demande d’extinction est faite.

Architecture / Synoptique 

  • La pression sur un simple bouton (Sonoff SNZB-01P) déclenchera une action conditionnée :
    • Allumer la prise connectée puis allumer le PC
    • Eteindre le PC puis couper la prise connectée.
  • Le réveil via le service WoL est très simple
  • L’extinction du PC demande un montage un peu plus… spécial.
    • HAOS écrit un fichier shutdow.txt dan un partage réseau monté :/mnt/share/pc_auto-shutdown
    • Ce partage est servi par un LXC Debian (ID 105) via Samba : \\192.168.0.105\pc_auto-shutdown.
    • Côté Windows, un script/planificateur surveille ce fichier et coupe la machine.

Proxmox

Étape 1 – Création, montage, réservation

On va créer un dossier qui sera partagé par la suite.

  • Depuis le noeud Proxmox :

Shell - Linux

    mkdir -p /mnt/share/pc_auto-shutdown   
            
                    
        
  • Vérifier les permissions :

Shell - Linux

    ls -ld /mnt/share/pc_auto-shutdown   
            
                    
        
  • Vous devriez obtenir quelque chose de similaire à :
drwxr-xr-x 2 root root 4096 Aug 26 14:56 /mnt/share/pc_auto-shutdown

Étape 2 – Monter le dossier pour le conteneur 105

Pour que le conteneur LXC 105 puisse accéder au dossier « pc_auto-shutdown » précédemment créé, il faut lui donner le chemin. C’est ce que l’on appel « monter un dossier ».

  1. Depuis le nœud Proxmox, éditez la conf du conteneur 105 :

Shell - Linux

    nano /etc/pve/lxc/105.conf   
            
                    
        
  1. Ajouter cette ligne à la fin :

Shell - Linux

    mp0: /mnt/share/pc_auto-shutdown,mp=/srv/pc_auto-shutdown

   
            
                    
        

Explications :

  • mp0 « Montage Point #0 » Si vous aviez déjà d’autres points de montage, mettez simplement le numéro qui suit.
  • /mnt/share/pc_auto-shutdown est le chemin du partage.
  • mp=/srv/pc_auto-shutdown indique que ce partage (point de montage) doit être monté dans…
  1. Redémarrer le conteneur :

Shell - Linux

    pct reboot 105
   
            
                    
        

Étape 3 – Samba

L’outil Samba doit être déjà installé et fonctionnel.
L’utilisateur « pve01 » avec son mot de passe (identique) est déjà connu.

  • Depuis le conteneur LXC, vérifier l’état de fonctionnement de Samba :

Shell - Linux

    systemctl status smbd   
            
                    
        

Vous devriez voir en vert l’information « Active: active (running)« .

On va à présent configurer Samba pour exposer notre point de montage sur le service.

  • Édition du fichier :

Shell - Linux

    nano /etc/samba/smb.conf   
            
                    
        
  • Tout à la fin, ajoutez ceci :

Shell - Linux

    [pc_auto-shutdown]
   path = /srv/pc_auto-shutdown
   browseable = yes
   read only = no
   guest ok = no
   valid users = pve01   
            
                    
        

Enregistrez et quitter.

  • Vérifions l’UID/GID pour l’utilisateur sus-mentionné « pve01 » :

Shell - Linux

    id pve01   
            
                    
        

Vous devriez voir quelque chose comme :

uid=1000(pve01) gid=1000(pve01) groups=1000(pve01),100(users)

Notez bien ceci quelque part car si chez vous ces chiffres sont différents, il faudra en tenir compte pour la suite.

  • Permission sur le dossier partagé :

Shell - Linux

    chown -R 1000:1000 /srv/pc_auto-shutdown
chmod -R 775 /srv/pc_auto-shutdown   
            
                    
        

Étape 4 – Chrony (service NTP)

Hôte Proxmox [nœud pve01]

On va synchroniser la définition des « temps » (heure) entre les machines en s’appuyant sur notre home-serveur (Proxmox) qui va servir à récupérer l’heure via le composant chrony pour servir de service NTP.
Ce service sera alors la pierre angulaire pour redistribuer l’heure exact aux machines de votre réseau local (après configuration individuelle…) pour qu’elles soient toutes synchronisées à la seconde près.

Donc l’hôte Proxmox aillant (normalement) déjà le composant chrony d’installé, nous allons le configurer puis configurer les clients (conteneur LXC Debian + Windows) afin que tout ce petit monde soit raccord.

  • Depuis l’hôte Proxmox, vérifier la présence de chrony :

Shell - Linux

    # Vérifier si chrony est installé
dpkg -l | grep chrony   
            
                    
        

Si rien ne s’affiche c’est que le service est absent. Pour l’installer :

apt update
apt install chrony -y
  • Editer le configuration :

Shell - Linux

    nano /etc/chrony/chrony.conf
   
            
                    
        
  • Ajouter/adaptez cette ligne pour correspondre à votre infrastructure réseau :

Shell - Linux

    # Autoriser les clients du LAN à se synchroniser
allow 192.168.0.0/24
   
            
                    
        
  • Toujours dans le même fichier, s’assurer d’avoir des serveurs NTP publics comme source. Exemple:

Shell - Linux

    pool 2.debian.pool.ntp.org iburst
   
            
                    
        
  • Redémarrer/relancer/vérifier le service :

Shell - Linux

    systemctl restart chrony
systemctl enable chrony --now
systemctl status chrony   
            
                    
        

Le service doit apparaître en vert à l’état de « running ».

  • Vérifier qu’il écoute sur le port UDP 123 [0.0.0.0:123] :

Shell - Linux

    ss -ulpn | grep 123
   
            
                    
        
  • Vérifier la synchronisation sur l’hôte :

Shell - Linux

    chronyc sources
chronyc tracking

   
            
                    
        
Client LXC Debian [Conteneur 105]

Maintenant que l’hôte reçoit une heure universelle, on va la récupérer sur notre client conteneur LXC Debian.

  • Installer le service Chrony sur le conteneur LXC :

Shell - Linux

    apt update
apt install chrony -y
   
            
                    
        
  • Éditer la configuration de chrony :

Shell - Linux

    nano /etc/chrony/chrony.conf
   
            
                    
        
  • Ajoutez à la fin du fichier l’instruction correspondante à l’adresse IP de votre hôte Proxmox :

Shell - Linux

    # Serveur NTP : l'hôte Proxmox
server 192.168.0.11 iburst
   
            
                    
        
  • Redémarrer/relancer/vérifier le service :

Shell - Linux

    systemctl restart chrony
systemctl enable chrony --now
systemctl status chrony   
            
                    
        
  • Vérifiez la synchronisation :

Shell - Linux

    chronyc sources
chronyc tracking
   
            
                    
        
Windows

Coté Windows, nous allons faire exactement la même chose : utiliser l’hôte Proxmox comme référent prioritaire à la synchronisation NTP de l’heure. En cas de soucis si l’hôte Proxmox ne répond pas, il y aura moyen de joindre les serveurs directement pour ne pas « crasher ».

  • Ouvrez une fenêtre terminal cmd Powershel en tant d’administrateur et collez ce qui suit :

cmd - Powershell

    w32tm /config /manualpeerlist:"192.168.0.11,0.fr.pool.ntp.org,1.fr.pool.ntp.org" /syncfromflags:manual /reliable:yes /update
net stop w32time
net start w32time
w32tm /resync /rediscover
w32tm /query /status
w32tm /query /peers   
            
                    
        

Explications :

  • 192.168.0.11 → serveur interne (celui de votre hôte Proxmox)
  • 0.fr.pool.ntp.org, 1.fr.pool.ntp.org, 2.fr.pool.ntp.org → serveurs publics comme backup
  • syncfromflags:manual → utilise uniquement les serveurs listés
  • reliable:yes → indique que ce PC peut être considéré comme une source fiable sur le LAN
  • update → applique immédiatement la configuration

Windows va interroger dans l’ordre les adresse configurées donc si la première est HS, ils consultera la suivante puis celle d’après…

HAOS

Via l’interface

  • HAOS > Paramètres > Système > Stockage > Ajouter un stockage réseau
  • Renseigner les champs comme sur la capture d’écran ci-dessous :

HAOS – Nouveau stockage réseau

  • Le dossier correspondant est automatiquement créé par HAOS.

Pour retrouver exactement où HAOS à monté le dossier « PC_HA » il faut se diriger du coté du terminal SSH.

  • Envoyez la commande suivante :

Shell - Linux

    mount | grep cifs   
            
                    
        

Une liste (ou une seule ligne) apparaissent avec tous les détails comme par exemple :

//192.168.0.105/pc_auto-shutdown on //192.168.0.105/pc_auto-shutdown on /share/PC_HA type cifs (rw,relatime,vers=3.1.1,cache=strict,upcall_target=app,username=pve01,uid=0,noforceuid,gid=0,noforcegid,addr=192.168.0.105,file_mode=0755,dir_mode=0755,soft,nounix,mapposix,reparse=nfs,rsize=4194304,wsize=4194304,bsize=1048576,retrans=1,echo_interval=60,actimeo=1,closetimeo=1) type cifs (rw,relatime,vers=3.1.1,cache=strict,upcall_target=app,username=pve01,uid=0,noforceuid,gid=0,noforcegid,addr=192.168.0.105,file_mode=0755,dir_mode=0755,soft,nounix,mapposix,reparse=nfs,rsize=4194304,wsize=4194304,bsize=1048576,retrans=1,echo_interval=60,actimeo=1,closetimeo=1)

C’est assez imbuvable mais l’information que l’on cherche se trouve ici : /share/PC_HA

Nous venons d’identifier l’emplacement exact où HAOS gère ce partage.
Et il n’y a pas d’autres solution que d’en passer par l’utilitaire graphique pour que le « supervisor » accepte et gère convenablement les droits !

Commande shell

Maintenant que HAOS à un accès configuré pour aller y déposer un fichier (qui déclenchera l’arrêt du PC) nous allons écrire la commande qui effectuera à proprement parler cette tâche.

  • Dans le fichier de configuration.yaml :

YAML

    # Moyen pour arrêter le PC
shell_command:
  create_shutdown_file: "date '+%Y-%m-%dT%H:%M:%S%:z' > /share/PC_HA/shutdown.txt"   
            
                    
        
  • Enregistrez et redémarrez HAOS.

La date est inscrite comme contenu du fichier et son format garanti une portabilité maximale.

  • Pour tester, HAOS > Outils de développement > Actions

YAML

    service: shell_command.create_shutdown_file
data: {}
   
            
                    
        

Si vous obtenez une réponse différente de :

YAML

    stdout: ""
stderr: ""
returncode: 0   
            
                    
        

… c’est qu’il y aura eu un problème.

  • Pour vérifier la présence de ce fichier, via le terminal SSH :

Shell - Linux

    ls -l /share/PC_HA   
            
                    
        

Vous devriez voir apparaître le fichier shutdown.txt

  • Si vous consultez via l’explorateur de fichiers Windows l’adresse : \\192.168.0.105\pc_auto-shutdown vous devez aussi trouver le fichier bien visible.

Window

Outils

Pour y parvenir, nous allons avoir besoin d’utiliser PowerShell Admin [CTRL + X > A] et d’installer quelques outils intermédiaires…

Chocolatey

Chocolatey est un peu comme une suite de mini logiciels/fonctions. Pur plus de facilité nous allons en passer par lui.

  • Vérification de sa présence éventuelle :

cmd - PowerShell

    choco --version
   
            
                    
        

Si vous obtenez un numéro de version, Chocolatey est déjà installé.
Si c’est un message d’erreur, il faudra l’installer.

  • Installation de Chocolatey :

cmd - PowerShell

    Set-ExecutionPolicy Bypass -Scope Process -Force; `
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; `
iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
   
            
                    
        

Une fois l’installation terminée, fermez et rouvrez la fenêtre PowerShell pour vérifier avec la commande choco --version

NSSM (Non-Sucking Service Manager)

C’est ce logiciel que nous visions et son installation est plus aidée via Chocolatey. Donc ce dernier étant installé, nous allons procéder à l’installation de NSSM.
C’est un petit logiciel, léger et sûre même si un peu ancien.

  • Vérification de la présence éventuelle de NSSM sur votre système :

cmd - PowerShell

    nssm version
   
            
                    
        

Vous vous recevez un numéro de version c’est bon. Sinon, en cas d’erreur, vous êtes bon pour l’installer.

  • Installation :

cmd - PowerShell

    choco install nssm -y
   
            
                    
        

Le -y répond automatiquement “oui” à toutes les confirmations.
Chocolatey va télécharger NSSM et le placer dans son dossier (C:\ProgramData\chocolatey\bin par défaut).

Normalement, Chocolatey ajoute automatiquement les exécutables à ton PATH.
Si tu obtiens une erreur en tapant nssm, ajoute manuellement :

  1. Ouvre Paramètres > Système > Informations système > Paramètres système avancés > Variables d’environnement
  2. Dans Path, ajoute : C:\ProgramData\chocolatey\bin
  3. Redémarre PowerShell et teste à nouveau nssm version.

Script Chocolatey + NSSM

Pour ceux qui ont la flemme, le script suivant (copier/coller toujours dans une fenêtre PowerShell Admin) est fait pour vous !

cmd - PowerShell

    # Vérifier si Chocolatey est installé
Write-Host "Vérification de Chocolatey..."
if (!(Get-Command choco -ErrorAction SilentlyContinue)) {
    Write-Host "Chocolatey n'est pas installé. Installation en cours..."
    Set-ExecutionPolicy Bypass -Scope Process -Force
    [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
    iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

    # Recharge la session pour activer choco
    refreshenv
} else {
    Write-Host "Chocolatey est déjà installé."
}

# Vérifier la version de Chocolatey
choco --version

# Installer NSSM
Write-Host "Installation de NSSM..."
choco install nssm -y

# Vérifier NSSM
Write-Host "Vérification de NSSM..."
nssm version
   
            
                    
        

Le fichier exécutable se trouve ainsi installé à C:\ProgramData\chocolatey\bin

Script de surveillance

  • Via le gestionnaire de fichiers de Windows, ajouter un fichier dans C:\Scripts\shutdown_watcher.ps1
  • A l’aide du bloc-note, éditez le fichier avec le contenu suivant :

cmd - PowerShell

    # -----------------------------------------------------------------------------
# Script de surveillance pour extinction du PC via fichier déclencheur (log amélioré)
# -----------------------------------------------------------------------------

Start-Sleep -Seconds 30

# Monter le partage réseau (si nécessaire)
net use \\192.168.0.105\pc_auto-shutdown /user:pve01 pve01 /persistent:yes

$shutdownFile = "\\192.168.0.105\pc_auto-shutdown\shutdown.txt"
$logFile = "C:\Scripts\shutdown_watcher.log"

# --- Nettoyage automatique du log au démarrage ---
if (Test-Path $logFile) {
    # Option 1 : vider le fichier
    Clear-Content $logFile
    # Option 2 : archive le fichier (décommenter si besoin)
    # Rename-Item $logFile ("C:\Scripts\shutdown_watcher_" + (Get-Date -Format "yyyyMMdd_HHmmss") + ".log")
}

# Fonction de log (préfixe les nouvelles lignes en haut du fichier)
function Log {
    param([string]$msg)
    $timestamp = (Get-Date).ToString("yyyy-MM-dd HH:mm:ss")
    $newLine = "$timestamp $msg`r`n"
    
    # Lire l'ancien contenu
    $old = ""
    if (Test-Path $logFile) { $old = Get-Content $logFile -Raw }
    
    # Écrire le nouveau bloc en haut
    Set-Content -Path $logFile -Value ($newLine + $old)
}

# Formats ISO8601 tolérés
$formats = @(
    "yyyy-MM-ddTHH:mm:ssK",
    "yyyy-MM-ddTHH:mmK",
    "yyyy-MM-ddTHH:mm:ss"
)

Log "=== Script démarré ==="

while ($true) {
    if (Test-Path $shutdownFile) {
        try {
            # Séparation des tentatives
            Log "----- Nouvelle tentative -----"

            $raw = Get-Content $shutdownFile -Raw
            $fileContent = ($raw -replace "^\uFEFF","").Trim()

            Log "Contenu brut    : [$raw]"
            Log "Contenu nettoyé : [$fileContent]"

            # Conversion tolérante
            $shutdownTime = New-Object DateTime
            if (-not [datetime]::TryParse($fileContent, [ref]$shutdownTime)) {
                throw "Impossible de convertir l'horodatage : [$fileContent]"
            }

            $now = Get-Date
            $diff = ($now - $shutdownTime).TotalSeconds

            Log "Heure Windows       : $now"
            Log "Horodatage fichier  : $shutdownTime"
            Log "Ecart en sec        : $diff"

            # Tolérance : 45 secondes maximum, uniquement si le fichier est dans le passé
			if ($diff -ge 0 -and $diff -le 45) {
				Log "✅ Décision : Extinction demandée (écart $diff sec)"
				Remove-Item $shutdownFile -Force
				Start-Process "shutdown.exe" -ArgumentList "/s /f /t 0" -NoNewWindow
				exit
			}
			else {
				Log "❌ Décision : Ignoré, horodatage ancien ou futur (écart $diff sec)"
				Remove-Item $shutdownFile -Force
			}
        }
        catch {
            Log "⚠️ Erreur : $($_.Exception.Message)"
            Log "DEBUG brut : [$raw]"
            Remove-Item $shutdownFile -Force
        }
    }

    Start-Sleep -Seconds 5
}
   
            
                    
        

Explications :

  1. Le service de surveillance (watcher) va contrôler la présence du fichier shutdown.txt dans le répertoire réseau \\192.168.0.105\pc_auto-shutdown
  2. Pour y accéder, il a besoin du couple d’identifiants Samba ET d’un compte windows (à vous d’adapter le ligne !)
  3. En cas de présence du dit fichier :
    1. Va effectuer un contrôle par comparaison de date entre celle inscrite au sein du fichier (via la comande shell de HOAS) et celle actuelle dans un format « universelle ».
    2. Un écart fixé de 45 secondes est permis. Au delà, le fichier est supprimé et… rien d’autres.
    3. Mais si l’écart est inférieur à 45 secondes de décalage : suppression du fichier (pour éviter une boucle infini) et arrêt du PC.

Cette « double vérification » fait suite à un constat que j’ai effectué lors de mes essais : si mon PC est déjà éteint mais que l’automatisme (ou autre) déclenche l’envoi du fichier shutdown.txt dans le dossier partager (Proxmox), lors de l’ouverture de la session Windows, le script de surveillance va tout de suite trouver le fichier et va alors arrêter le PC avant même que vous aillez eu le temps de vous logger !

Un système de « log » est mis en place, c’est ce qui m’a permis de constater une différence dans l’horodatage. Du coup, impossible d’éteindre le PC. Nous avons mis en place un moyen de synchroniser les « temps » (service NTP) entre les machines donc vous ne devriez plus avoir de soucis.

Mise en œuvre du script de surveillance

Maintenant que tous les outils sont en place, nous allons installer un « watcher » grâce à NSSM.

  • Installer un nouveau service :

cmd - PowerShell

    nssm install PCShutdownWatcher
   
            
                    
        

NSSM – Nouveau service

  • Dans le champs « Chemin », inscrire :
    C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
  • Dans le champs « Rép. de démarrage » inscrire :
    C:\Scripts
  • Dans le champs Paramètres, inscrire :
    -NoProfile -ExecutionPolicy Bypass -NoLogo -NonInteractive -File "C:\Scripts\shutdown_watcher.ps1"

Tests

  • Pour démarrer le service sans plus attendre :

cmd - PowerShell

    nssm start PCShutdownWatcher
   
            
                    
        

Vérification

  • Pour voir le processus, faite [CTRL + ALT + Suppr] > Gestionnaire des tâches.
  • Recherchez « nssm »
  • Vous trouverez votre watcher.

Pour information, ce service ne me prend que 1,4Mo de RAM. Autrement dit : rien !

Essai grandeur nature

Enregistrez tout votre travail car votre PC va s’arrêter à l’issue du test.

Donc 2 possibilités :
– Écrire manuellement le fichier « shutdown.txt » dans \\192.168.0.105\pc_auto-shutdown\
– Faire écrire le fichier via une simulation d’action depuis HAOS

Le premier cas étant d’une évidence enfantine, je ne vais pas la détailler préfèrent tester une simulation depuis HAOS.

Reportez vous en fait au chapitre « Commande shell » qui explique exactement quoi faire.

En cas de doute, vous pouvez redémarrer le service avec la commande PowerShell nssm restart PCShutdownWatcher

HAOS – Automatisation

Nous arrivons ENFIN à l’automatisation !

Via le plugin « Local Files Editor » nous allons ajouter au fichier « automation.yaml » le bloc suivant pour commencer :

YAML

    - id: '1756310101388'
  alias: PC - Toggle (allumer / éteindre)
  description: ''
  triggers:
  - domain: mqtt
    device_id: b9e8f93bf99b9c0b6366842e4e2db0f0
    type: action
    subtype: single
    trigger: device
  conditions: []
  actions:
  - choose:
    - conditions:
      - condition: and
        conditions:
        - condition: state
          entity_id: switch.prise_antela_ordinateur
          state: 'on'
        - condition: state
          entity_id: device_tracker.msi_pc_fixe_lan
          state: home
        - condition: numeric_state
          entity_id: sensor.prise_antela_ordinateur_puissance
          above: 90
          enabled: true
      sequence:
      - action: light.turn_on
        metadata: {}
        data:
          brightness_pct: 100
          rgb_color:
          - 255
          - 0
          - 0
        target:
          area_id: bureau
      - action: light.turn_on
        metadata: {}
        data:
          flash: long
        target:
          area_id: bureau
      - action: shell_command.create_shutdown_file
        metadata: {}
        data: {}
        enabled: true
      - delay:
          hours: 0
          minutes: 0
          seconds: 55
          milliseconds: 0
      - condition: numeric_state
        entity_id: sensor.prise_antela_ordinateur_puissance
        enabled: true
        below: 90
      - action: light.turn_off
        metadata: {}
        data: {}
        target:
          area_id: bureau
      - action: switch.turn_off
        metadata: {}
        data: {}
        target:
          device_id: 70ecb632ddad3328a7c11ddcd55024b7
        enabled: true
      alias: Eteindre le PC
    - conditions:
      - condition: or
        conditions:
        - condition: state
          entity_id: switch.prise_antela_ordinateur
          state: 'off'
        - condition: state
          entity_id: device_tracker.msi_pc_fixe_lan
          state: not_home
        - condition: numeric_state
          entity_id: sensor.prise_antela_ordinateur_puissance
          below: 45
      sequence:
      - action: switch.turn_on
        metadata: {}
        data: {}
        target:
          device_id: 70ecb632ddad3328a7c11ddcd55024b7
      - delay:
          hours: 0
          minutes: 0
          seconds: 4
          milliseconds: 0
      - action: wake_on_lan.send_magic_packet
        metadata: {}
        data:
          mac: D8:BB:C1:CA:A6:FF
      alias: Allumer le PC
  mode: single   
            
                    
        

Bien évidement, cela correspond aux éléments qui sont présents chez moi avec leur nom et leur ID

Cela, encore une fois répond à MON besoin qui était de couper l’alimentation électrique de la prise qui alimente mon PC avec les écrans et les lumières.
Donc il fallait tenir compte de plusieurs facteurs ce qui a complexifier pas mal la chose.

Pour la « déco » j’ai aussi mis un petit système de lumières qui s’animent en cas d’arrêt demandé. Bref, vous avez l’idée içi. A vous d’adapter.

Tags: ,

Laisser un commentaire

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