Une installation sans fioriture, avec tablette murale (Fully kiosk)

[fgtoul]

Bonjour à tous,
Je prends enfin le temps de vous présenter un chantier sur lequel j’ai été sollicité… à une époque où seuls les murs extérieurs faisaient office de décor. Autant dire qu’on partait avec une page blanche, ou plutôt, des parpaings nus !

Dans cette configuration minimaliste, la liberté était totale. Et qui dit liberté totale dit aussi liberté de se faire plaisir (tout en gardant la tête froide et le portefeuille dans la poche).

Le projet se voulait sans prétention et ne visait pas une domotisation complète ; seuls l’éclairage, le chauffage, les volets roulants et la sécurité ont été intégrés à l’installation. Quelques postes additionnels comme la sonnette, le portail, les éclairages extérieurs, ventilation thermostatée de la baie informatique avec sonde TC4012 de récupération, citerne d’eau de pluie avec pompe sont en cours ou à venir.
Les prises ne sont généralement pas commandées (seulement 2 dûment repérées 10A pour satisfaire à la NF C15-100) pour une vitrine et un spot posé sur meuble de cuisine). Une pieuvre classique est alors mise en place avec dérivations dans les combles.

La domotique de l’habitation est assurée à 100% par une ipx800 V4. Elle est supervisée par la V5 qui assure principalement la fonction de système d’alarme, cela apporte le confort des Liveviews sur tablette murale et le support du protocole Wiegand.
Le propriétaire des lieux n’étant pas un geek, l’installation a été conçue pour du 100% autonome made by GCE (pas de Jeedom, RPI, …).
Chaque IPX800 a la totale maîtrise des fonctions essentielles qui lui incombent. Les fonctionnalités déclenchées par un push à la demande de l’autre IPX ne sont pas essentielles. En cas de coupure du réseau local (switch figé par exemple), l’installation continue d’être fonctionnelle et autonome.

La baie informatique, la domotique et l’alarme sont alimentées par un onduleur Online de 1500 VA. L’IPX800 V5 de l’alarme se voit affublée d’une batterie supplémentaire.

Matériel acheté :

Domotique :
2 IPX800 V4 (1 en spare)
1 X-4FP
2 X-4VR
4 X-8R
1 X-8D
2 X-Dimmer

Alarme :
1 IPX800 V5
1 X-24D
1 X-Wiegand (avec clavier/rfid Wiegand 26 acheté séparément)
1 X-Display V2

Les travaux ont commencé en 2020 avec le coulage d’une chappe résinée sur la dalle de béton.
Le tracé des futures cloisons aide à déterminer les cheminements à créer et les emplacements des futures sorties de câbles.

Les plans

Tous les plans ont été réalisés à l’échelle avec Archifacile (www.archifacile.fr).
Cela permet de déterminer les longueurs de câbles à commander.

Plans architecturaux

VDI

Les schémas unifilaires

Nous avons choisi des équipements modulaire XL3 de Legrand, le tableau électrique a donc naturellement été conçu avec la suite logicielle de Legrand.
Le schéma unifilaire a été généré puis retouché dans cette même suite.

Pose des gaines.

BT et TBT bien séparées avec des gaines de couleur différente pour un repérage rapide. Respect de la NF C15-100, croisement BT/TBT à 90°, chaque détail a son importance pour la pérennité de l’installation. Nous avons pris notre temps à cette étape car nous savions qu’il serait difficile voire impossible de corriger les erreurs par la suite.
Chaque dispositif est câblé directement au tableau.
Dans la mesure du possible, 1 câble est tiré directement vers le tableau pour chaque poste BP, point lumineux, radiateur, Volet roulant, ..

Il va sans dire que le repérage des gaines et des fils est primordial. Sur ces photos, le câblage n’est qu’à 50% environ.
Voici un exemple réalisé avec de la gaine thermo rétractable transparente.

Les tableaux

Notre choix s’est orienté vers des tableaux Schneider Pragma Evolution de 120 modules (5 x 24), un pour l’installation électrique, l’autre pour la domotique.
Ces tableaux prévus pour le tertiaire offrent un entraxe de 150mm nécessaire au câblage des extensions GCE.

Schémas

A l’époque ces schémas avaient été réalisés sous Excel. Aujourd’hui si je devais les refaire j’utiliserais Draw.io (voir mon tuto)

Finalisation des tableaux

Très récemment j’ai dû ajouter des protections parafoudres T2 et T3. La région montagneuse se voit attribuer un niveau kéraunique <25. Même si le parafoudre n’est pas obligatoire dans ce cas, les changements climatiques finissent par nous l’imposer.
La foudre ayant frappé non loin de l’installation, une alimentation 12V, 1 extension X4VR ainsi qu’un différentiel 40A ont rendu l’âme. Au passage je tiens à remercier le SAV GCE (@Kevin_GCE) pour la rapidité et l’efficacité de leur service.
Ce tableau électrique secondaire est situé à 17 mètres du tableau principal.
Malgré le T2 installé sur le 1er tableau, une surtension s’est regénérée avec suffisamment d’amplitude pour causer des dégâts dans le tableau secondaire (distance > 10 mètres).
Le nouveauT2 éliminera environ 95% de l’onde régénérée, le T3 éliminera le reste et de fait protègera les appareils fixes comme la hotte, les volets, la VMC, etc. Les appareils sensibles branchés sur les prises auront un parasurtenseur T3 au plus près sur la prise.
L’installation est sous surveillance avec l’été qui démarre et ses orages saisonniers. J’espère ne pas être contraint de passer au T1 sur le tableau principal. Il faut dire que l’habitation est ancrée sur un bloc de granit bleu ce qui n’arrange rien.
Pour installer ces protections, j’ai donc été contraint de remanier le tableau électrique secondaire, non seulement pour amener l’alimentation principale et la terre au plus près afin de respecter la règle des 50 cm, mais aussi pour faire de la place.
Aujourd’hui avec ce dernier ajout, le tableau est presque plein.

On a toujours peur de prévoir trop grand, mais quand il faut ajouter une protection, une alimentation ou encore une extension, il vaut mieux avoir prévu large dès le début. Si je devais refaire l’installation, j’opterais assurément pour du 6x24 modules. Aujourd’hui les Pragma ne se font plus, récemment j’ai utilisé des modèles PrismaSet.

Les blindages

Pour respecter les préconisations GCE, il est nécessaire de câbler les entrées digitales, le Bus EBX et les analogiques avec du câble blindé. Le blindage doit être mis à la terre (côté tableau de préférence) afin d’éliminer les interférences. J’ai choisi des borniers PTFIX.

Le bus EBX

Le bus EBX doit être réalisé en Daisy Chain avec du câble blindé. (Voir les Wikis).
J’ai opté pour du câble blindé 1 paire type EIB KNX (câble vert sur la photo)

Par expérience, je ne peux que conseiller de prendre son temps lors de la réalisation du Bus, il faut soigner chaque connexion. Vu que c’est du câble souple j’ai mis des embouts sertis afin d’éviter les éventuelles dégradations du branchement au fil du temps et des manipulations.
Pour le chaînage des 5 X-THL, j’ai choisi de ramener tous les câbles au tableau et de les brancher sur une carte réalisée sur mesure. Celle ci ne comporte que des borniers et les pistes du PCB facilitent la génération du Daisy Chain et la mise à la terre des blindages.

L’éclairage

Tous les points lumineux sont à LED. Pour les points à spots multiples (couloir, salle à manger) ou bien lorsque la puissance prévue dépassait les préconisations, un contacteur a été systématiquement intercalé afin de préserver les relais de l’IPX.
Les spots dimmables sur X-Dimmer laissaient une lueur résiduelle lorsqu’ils étaient éteins. Il a fallu ajouter des compensateurs de charge

Nous avons disposé les boutons poussoirs de manière à ce que chaque commande permette d’éteindre dans la pièce précédente et allumer la pièce suivante. Cela double les commandes mais apporte un réel confort.
Un capteur de mouvement Finder 230Vac avec contact actif NO a été installé au plafond du couloir.
Un relais 230Vac a donc été placé dans le tableau électrique pour y connecter une entrée digitale.

Une plage horaire « Nuit » permet sur détection d’allumer les spots du couloir à 25% en activant un Preset X-Dimmer par scénario.

Les poussoirs Céliane

Les Dashboards

Rien de compliqué sur la V4

Les volets roulants

Les boutons Céliane sont équipés d’un bouton Stop central, mais suite aux essais, il ne remplit pas son rôle avec le X-4VR. Nous avons configuré les 2 extensions X-4VR v1 en mode 1.

moteurs Somfy

Les moteurs sont des COMBIROL’51.
La connexion à 4 fils (Montée, Descente, Neutre, Terre) est très simple. Le réglage des fins de course a été rapide. Une fois fait, la calibration des X-4VR V1 s’est bien passée au premier essai.
2 condensateurs X2 ont été ajoutés à chaque VR (montée, descente). Ils ont été placés au plus près de chaque moteur dans sa boite de dérivation encastrée.

Le Dashboard V4

Dashboard classique et simplissime.

le chauffage

Sur V4, programmation classique par plage horaire (tarif bleu HC/HP) et dashboard.

L’hiver, le chauffage électrique sera complété par une flambée dans le foyer du piano de cuisson mixte bois/électricité.

Le climat

Le climat est monitoré par 5 X-THL V1, répartis dans les salles de bains, les chambres et l’espace ouvert cuisine/séjour.
Ils sont posés sur obturateur Céliane.

Le système d’alarme sur IPX800 V5

Un clavier Wiegand avec lecteur RFID intégré est mis en place.

Il permet la lecture des badges sans contact ainsi que la saisie de codes PIN.
L’objet Access Control de la V5 permet la vérification sécurisée des codes autorisés.
L’extension ne pilotant pas la gâche, elle est placée sous le clavier dans le boitier encastré.
L’IPX800 V5 fait bipper le buzzer toutes les secondes pendant la temporisation d’entrée-sortie.
Tous les capteurs peuvent être exclus (inhibés) en cas de problème.
Le liveview est accessible sur la tablette murale 15.6" protégée par lecture d’empreinte (verrouillage natif Androïd)
La programmation a été abordée dans cet article.

Les capteurs sont essentiellement des contacts d’ouverture à contact Reed Normalement fermés. Ils ont été posés sur la porte d’entrée, les fenêtres et portes-fenêtres.
Ils sont tous connectés à la X-24D.

Les capteurs de mouvements sont de la marque Paradox. Ils fonctionnent avec une double technologie permettant d’éviter les faux positifs. Considérant la proximité d’un bois, j’ai préféré un modèle avec une immunité aux animaux de 40kg. Ces capteurs assurent en parallèle la fonction d’allumage des projecteurs extérieurs.
Les DG85 sont munis d’un micro switch permettant de les configurer en fonctionnement par Relais. Par défaut ils sont configurés pour fonctionner sur un Bus propriétaire.

Au moment de la conception, je ne savais pas encore si les capteurs de mouvement pour éclairage seraient en 230Vac ou en 12Vdc. Le câblage a donc été fait en 3x1.5mm² pour être universel.
Il s’avère aujourd’hui que c’est un mixte de modèles BT et TBT. Le choix initial de câblage en 1.5 l’a permis et les modifications seront permises dans le futur (en cas de remplacement, le nouveau modèle pourra être choisi selon ses fonctionnalités, sans restriction de par sa tension de fonctionnement).
Les détecteurs sont branchés par 3 fils sur une X-8D via la borne NC, cela permettra une détection en cas de sabotage malgré le manque de connexion TAMPER.

En cas de détection par un capteur de mouvement, si l’alarme est armée, l’ipx800 V5 envoie une notification. Dans tous les cas, en fonction du statut de la variable « Day/Night » du plugin Weather, la V5 envoie un PUSH à la V4 pour allumer les projecteurs extérieurs.

Dashboard et Liveview

Pour le pilotage via un smartphone, le choix s’est porté sur un dashboard protégé par un code d’accès.
Par défaut seul le clavier s’affiche, permettant la saisie du code. Si le code est validé (dépendance avec un objet Access Control), le dashboard s’affiche entièrement. (Voir mon sujet ici)

Dashboard informatif :

Les codes de déverrouillage et administrateurs sont gérés sur dashboard grace à un widget HTML (voir mon sujet ici)

Vous trouverez le code des autres widgets dans mon sujet concernant la mise en oeuvre d’un système d’alarme ici

Le liveview autorise les même fonctionnalités. Il est affiché sur la tablette murale (protégé par empreinte digitale).

V5 en supervision

Le monoxyde de carbone (CO)

Étant donnée la présence d’une cuisinière à bois, des capteurs de monoxydes ont été installés et raccordés à l’IPX800 V5. Ils sont autonomes et possèdent leur propre sirène de 70dB en cas de dépassement des seuils autorisés par la NF EN 50291. Pour la sécurité des personnes, pas de DIY, même si le coût est bien inférieur.
Les capteurs sont munis d’un relais (contact sec) qui est branché sur une entrée digitale de l’IPX800 V5. Cela permet d’être notifié en cas d’absence et de démarrer un extracteur d’air branché sur un relais de l’ipx.
Les capteurs choisis sont des NB-983-CO-12V.

Les capteurs de fumée

Les capteurs de fumée sont connectés à la V5. Idem que pour le gaz, pas de DIY ici pour respecter la loi et/ou le code des assurances.
Le CQR-338 est muni d’un relais NO/NF. Sur activation de la sortie, l’ipx800 fait retentir la sirène intérieure.
Une temporisation de 0 à 600s permet de passer les DAAF en mode maintenance en inhibant le déclenchement de la sirène. Cela permet de faire les tests de capteurs (ou d’allumer le gâteau d’anniversaire )
Après le décompte, les alertes DAAF reprennent automatiquement un fonctionnement normal.

La sirène intérieure

C’est une Altec SX auto-alimentée.

X-4FP

Le chauffage est pilotable sur un Liveview. Les retours d’état se font par polling de la V4. Les commandes API V4 sont exécutées lors d’un clic sur un bouton.
Cette séparation action/retour permet un monitoring fiable.

Le liveview indique également le retour d’état du relais des capteurs de monoxyde, ainsi que les mesures X-THL. Une évaluation de la qualité de l’air est déterminée en fonction de la température et de l’humidité ambiantes.

VR sur X-Display et Liveview

Sur V5, un X-Display V2 permet la manipulation de tous les volets de la V4 via un écran type « Slider » rattaché à une analogique.

Le bouton on/off active par lien l’envoi de la valeur de positionnement via un PUSH à la V4.

Sur V5 également, un Liveview avec des widgets HTML permet la manipulation des Volets roulants de la V4 et la visualisation de leur état. Comme précédemment, les commandes et les retours d’état par polling sont distincts, ce qui permet un monitoring sans faille.
L’éclairage principal est également accessible via cet écran.

La valeur de chaque curseur est actualisée par le polling.
Lorsque la valeur est modifiée manuellement, le script ne le met plus à jour pendant 20 secondes, ce qui permet d’avoir le temps de cliquer sur le bouton SET pour valider la commande.

Monitoring du réseau

Affichage des Pings Watchdogs

Pour récupérer et afficher son adresse publique sur le Liveview, il faut créer un PUSH et le lier à un planning pour le lancer au moins 1 fois par jour.
Méthode : GET
Adresse : ifconfig.me
Port : 443
TLS : oui
URI : /ip

Un simple Widget Texte pointant sur [Push]Response affichera l’IP.

Par souci de confidentialité j’ai supprimé le widget sur la capture du Liveview.

Les notifications

L’IPX800 V5 notifie tout défaut (incendie, gaz, intrusion) ou changement d’état d’un dispositif surveillé (armement/désarmement, capteurs de mouvement, ouvertures, …) via Pushingbox.

A venir

Une gestion des consommations reste à mettre en place avec l’EDRT2, ainsi que la vidéosurveillance.
Je dois aussi faire quelques plans de recollement.
Plus tard, un climatiseur sera installé. J’aviserai le moment venu si un modèle avec communication ModBus est envisageable. Il sera alors connecté sur la V5 au lieu de la V4.
Le câble éthernet est déjà prévu, tout comme derrière les réfrigérateurs.
Je me souviens une discussion sur ce forum à ce sujet, tendant à prouver qu’une prise éthernet derrière un réfrigérateur ou un congélateur était une hérésie. Mais avec l’essor du modbus, ceux qui comme moi en ont prévu, pourront en profiter avantageusement. Les capteurs en tout genre sont à prix accessibles aujourd’hui. La prise éthernet peut également être utilisée pour connecter un X-THL en EBX Powered. Il suffit alors d’enlever le noyau keystone à l’autre extrémité pour établir la connexion avec l’IPX800 via un EBX-Connect.

[cce66]

@fgtoul

Eh beh on se demande ce que cela aurait donné avec les fioritures !!!
Superbe install et super doc !

[seb-bois-basalte]

merci pour ce partage

[Yannick1]

Belle installation, cela montre un exemple complet. Je suis surpris de la présence de convecteurs grille-pain ! Quel type de chauffage?

[fgtoul]

l’image n’est pas contractuelle
ce sont des radiateurs chaleur douce avec un complément saisonnier au bois et clim réversible à venir

[fgtoul]

Bonjour,
Les notifications sont désormais prises en charge par Pushover, qui propose une API avancée intégrant notamment les messages d’urgence (priority=2).

Ces messages se distinguent par :

• Une sonnerie de type alarme, renforçant la perception de l’urgence,
• Un clignotement rouge de l’écran pour améliorer la visibilité,
• La possibilité d’être répétés à intervalles réguliers jusqu’à acquittement manuel sur le téléphone (retry et expire requis).

Les Push déclenchés par les détections d’Intrusion, d’Incendie ou de Monoxyde de carbone sont configurés en messages d’urgence afin de garantir une réactivité maximale de l’utilisateur.

Exemple :

Adresse : api.pushover.net
Port : 443
Auth Mode : None
TLS : OUI
URI : /1/messages.json?title=INTRUSION+$196663$&priority=2&expire=180&retry=30&token=$589828$&device=$589829$&user=$589827$&message=1%3dSAM+2%3dEntree+3%3dSalon1+4%3dSalon2+5%3dCuisine+6%3dCh2+7%3dCh1+8%3dDress+9%3dMvt

Utilisation de variables pour les notifications Pushover

Les paramètres Token, Device et User sont encapsulés dans des variables de type Str afin d’optimiser la construction des URI. Cette méthode permet de :

• Réduire la longueur des URI pour gagner des caractères disponibles dans le message (qui doit être encodé),
• Faciliter la maintenance : en cas de changement de login, d’API Key ou de téléphone, une simple modification des variables suffit à mettre à jour tous les Push.

Lorsqu’un message Push possède une priorité égale à 2, il est traité comme une alerte d’urgence. Dans ce cas, les paramètres expire et retry deviennent obligatoires :

• retry définit l’intervalle entre deux envois (en secondes),
• expire définit la durée totale pendant laquelle le message sera répété jusqu’à acquittement.

Il est également possible de paramétrer une durée de vie pour les notifications non critiques, afin qu’elles soient automatiquement supprimées après un délai prédéfini. Cette option permet de ne pas surcharger l’historique avec des alertes sans valeur permanente (exemple : sonnette, événement informatif).

Ce délai de suppression est défini via le paramètre ttl (Time To Live), exprimé en secondes. Une fois le délai écoulé, la notification disparaît des interfaces de suivi et de l’historique Pushover.

Exemple d’URI avec suppression après 24 heures :

/1/messages.json?title=SONNETTE&ttl=86400&token=$589828$&device=$589829$&user=$589827$&priority=0&sound=pushover&message=Quelqu%27un%20sonne%20%C3%A0%20la%20porte%20d%27entr%C3%A9e.

Voici son apparence sur l’interface de suivi

La date d’expiration est indiquée par le champ Expires on, en fonction du paramètre ttl

[fgtoul]

Bonjour à tous,
Voici quelques informations concernant la tablette murale utilisée dans l’installation domotique. Je ne vais pas détailler ici l’ensemble des logiciels, mais je souhaite vous présenter une fonctionnalité très utile : l’affichage de messages personnalisés sur la tablette, grâce à l’API de Fully Kiosk Browser .

• Tablette 14" sous **Android 14 : Android 14 utilise un le mode de stockage « scoped »
• Application : Fully Kiosk Browser avec licence PLUS

Tout d’abord, voici une courte présentation du logiciel:
Fully Kiosk Browser est une application Android conçue pour transformer une tablette en terminal autonome et sécurisé. Elle est particulièrement adaptée aux usages domotiques et d’affichage permanent. Ses principales fonctionnalités sont :

• Affichage en plein écran de pages web, dashboards ou fichiers HTML locaux
• Blocage de l’accès aux autres applications et paramètres système (mode kiosque)
• Démarrage automatique au boot de l’appareil
• Administration à distance via interface web ou API REST (licence PLUS requise)
• Exécution de commandes HTTP comme le chargement d’URL, la lecture vocale de messages, ou le lancement d’applications
• Gestion de fichiers locaux dans le stockage privé de l’application
• Intégration possible avec des systèmes domotiques comme IPX800, Home Assistant, etc.

En complément du mode kiosque, la tablette peut être sécurisée par les mécanismes natifs d’Android lors de la mise en veille :

• Verrouillage automatique après extinction de l’écran ou période d’inactivité
• Sortie de veille protégée par l’un des moyens suivants :
  • Code PIN
  • Motif de déverrouillage (pattern)
  • Reconnaissance faciale (si disponible sur l’appareil)

Cette double couche de sécurité (Fully Kiosk + verrouillage Android) permet de garantir que l’accès à la tablette est strictement réservé aux utilisateurs autorisés, tout en assurant la continuité du service en mode affichage.

La licence PLUS permet d’activer Fully Remote Admin, qui offre un pilotage complet de la tablette à distance via une API REST. L’administration peut se faire via une interface web ou par des requêtes HTTP/HTTPS.
Si l’administration distante passe par une interface réactive, le pilotage de la tablette est aussi possible par des Url http ou https selon paramétrage.

• Installez Fully Kiosk Browser, achetez une licence PLUS.
  Allez dans Settings

• Remote Administration (PLUS)

  • Enable Remote Administration → activez l’option
  • Remote Admin Password → Créez un mot de passe
  • Remote Admin from local Network → activez l’option
  • Enable File Management on Remote Admin → activez l’option

• Device Management

  • Launch on boot
  • Get Device Admin

• Advanced Web settings

  • Enable Javascript interface (PLUS) → activez l’option
  • Enable user interactions → activez l’option

Le paramétrage vu ci-dessus est un minimum pour piloter Fully Kiosk à distance.
Par défaut, vous accèderez à l’interface d’administration depuis votre navigateur préféré sur votre PC par cette URL:
http://<IP-tablette>:2323/home

Revenons à la fonctionnalité permettant d’afficher les annonces ou alertes sur l’écran de la tablette, via des Pushes émis par l’IPX800.
J’ai choisi la solution qui consiste à placer des fichiers Html personnalisés en local dans Fully Kiosk afin de les appeler par leur URL.
La spécificité de la tablette, c’est qu’elle est mue par Android 14 (SDK 33) avec Scoped Storage activé qui empêche l’accès aux ressources locales (sdcard, …).
Les URL du type http://localhost/sdcard/* ne sont pas permises.
Pour contourner le problème, j’ai placé le fichier html dans le dossier privé de l’application.
Dans le menu de Remote Admin, exécutez « Manage Files » puis sélectionnez « Private App Storage »

Ouvrez le sous-dossier « Files » et téléversez votre fichier HTML en cliquant sur
Votre fichier doit apparaître dans la liste après upload.

Pour avoir la possibilité d’exécuter ce fichier HTML sur la tablette, il faut autoriser l’utilisation d’URL type file:/// et ajouter l’Url dans la liste blanche.
Dans Settings

• Web Settings / URL Whitelist, ajoutez file:///data/user/0/de.ozerov.fully/files/*

Vous pouvez faire apparaître votre page html sur la tablette depuis l’interface d’administration distante.
Sélectionnez la commande Load other URL, entrez l’url complète de votre fichier sous la forme file:///data/user/0/de.ozerov.fully/files/votreFichier.html

Pour mon cas, la page html reçoit un message et l’affiche en grand sur fond rouge. Ce sera utile pour les alertes Incendie ou Monoxyde.

Code de la page :

<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8">
  <title>Overlay HTML</title>
  <style>
    html, body {
      margin: 0;
      padding: 0;
      background-color: red;
      height: 100%;
      width: 100%;
      display: flex;
      justify-content: center;
      align-items: center;
    }
    #message {
      color: white;
      font-size: 10vw;
      text-align: center;
      word-wrap: break-word;
      max-width: 90%;
    }
  </style>
</head>
<body>
  <div id="message">Chargement...</div>

  <script>
    function getParam(name) {
      const urlParams = new URLSearchParams(window.location.search);
      return urlParams.get(name);
    }

    const raw = getParam("msg");
    if (raw) {
      try {
        const decoded = decodeURIComponent(raw);
        document.getElementById("message").innerHTML = decoded;
      } catch (e) {
        document.getElementById("message").textContent = "Erreur de décodage";
      }
    } else {
      document.getElementById("message").textContent = "Aucun message reçu";
    }
  </script>
</body>
</html>

Exemple d’utilisation :

http://192.168.0.149:2323/?cmd=loadUrl&url=file:///data/user/0/de.ozerov.fully/files/overlayMessage.html?msg=URGENCE%20!!!%3Cbr%3Ealerte+Monoxyde&password=fgtoul`

Depuis l’IPX800 V5, il suffit de configurer un objet PUSH comme ceci:
Méthode : GET
Adresse :
Port : 2323 (par défaut)
Auth.Mode : None
TLS : selon la config de votre tablette (http ou https)
URI : /?cmd=loadUrl&url=file:///data/user/0/de.ozerov.fully/files/overlayMessage.html?msg=URGENCE%20!!!<br>alerte%20Monoxyde&password=<password>

Remplacez <password>par le mot de passe mis en place pour protéger l’enterface Remote Admin.

Il est également possible d’envoyer des messages que la tablette lira à haute voix dans un français correct.
Voici un exemple de push sur IPX800 pour faire parler Fully Kiosk :

Méthode : GET
Adresse :
Port : 2323 (par défaut)
Auth.Mode : None
TLS : selon la config de votre tablette (http ou https)
URI : /?cmd=textToSpeech&text=ceci+est+un+message+vocal+de+mon+i+p+x&password=<password>

NB : aux URL de Remote Admin, vous pouvez ajouter un paramètre &type=json qui permettra d’obtenir une réponse en Json, plus légère que la réponse Html par défaut.

Screensaver

Fully kiosk permet l’activation d’un économiseur d’écran permettant de transformer la tablette en cadre photo.
Il suffit de déposer quelques images de fond et activer la rotation aléatoire.
Le délai d’activation est paramétré dans notre cas à 60s. La mise en veille Android est programmée à 30 minutes avec interdiction d’activation en cas de mouvement. Ainsi, après la dernière utilisation de Fully ou le passage devant la tablette (celle-ci étant positionnée dans un passage fréquenté), le diaporama démarre au bout de 60s d’inactivité, il suffit de passer devant la tablette pour qu’elle se réveille, sans avoir à entrer le code sur l’écran de verrouillage Android. L’écran sera mis en veille (écran noir pour économiser la batterie) au bout de 30 minutes de diaporama si personne ne passe devant et le déverrouillage sera alors obligatoire.
Pour cette tablette, j’ai choisi de déposer les images de fonds d’écran sur le dossier
Android/data/de.ozerov.fully/files/Wallpapers sur la SD Card.
Pour cela, via Remote Admin, j’ai créé le sous dossier Wallpapers puis collé les fichiers que j’avais téléchargés auparavant.

Lorsque l’IPX envoie une nouvelle URL à la tablette, il est nécessaire de s’assurer que celle-ci s’affiche bien , notamment dans le cas des messages urgents.
Il faut donc que l’ipx800 envoie les ordres stopScreensaver et screenOn à la tablette pour réactiver l’écran en cas de veille.
Il faut donc comme précédemment créer 2 push supplémentaires sur l’ipx, ils seront lancés par le moteur de scénarios derrière l’ordre d’affichage de l’alerte (voir précédemment).
ED capteur monoxyde<ON<Push loadURL MonoxydePush stopScreensaverPush screenOn

les URI pour ces pushes sont respectivement
/?cmd=stopScreensaver&password=myPassword
/?cmd=screenOn&password=myPassword

exemple de configuration avec stopScreensaver :

Il est tout à fait possible de provoquer le verrouillage de l’écran via la commande turnScreenOff lors de la mise sous alarme de l’habitation. Android active alors immédiatement le verrouillage. Un intrus ne pourra alors pas accéder aux écrans de l’IPX ou autres.

Pour éviter la sortie non autorisée de Fully Kiosk par un mouvement de Glissé sur l’écran, il faut activer le paramètre Disable other Apps

Bonne journée

[cce66]

Avec un gif animé ce serait plus rigolo !

[fgtoul]

le but de l’alerte est de sauver des vies, pas de faire mourir de rire

[fgtoul]

Bonjour,
comme vu précédemment, j’utilise Fully Remote Admin pour afficher des informations générales de la tablette murale sur un Liveview de l’IPX800 V5

Vu que la réponse à la requête est de type HTML, elle est incluse dans une balise iFrame.
Voici le code du widget sur le liveview de l’IPX800 V5:

<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8">
  <title>Infos tablette Fully Kiosk</title>
  <style>

    h1 {
      text-align: center;
    }
    .info-block {
      background: white;
      padding: 10px;
      margin-bottom: 10px;
      border-radius: 6px;
      box-shadow: 0 0 5px rgba(0,0,0,0.1);
      width:90%;
      height:90%;
    }
    .label {
      font-weight: bold;
    }
  </style>
</head>
<body>
    <h1>Informations de la tablette</h1><br>
<iframe src="http://<IP_Tablette>:2323/?cmd=getDeviceInfo&password=<password>" width="100%" height="100%" style="background:transparent"></iframe>
</body>
</html>

Remplacer l’adresse ip par celle de la tablette et le mot de passe par celui que qui a été mis en place pour protéger l’interface d’administration distante.

L’API Javascript est beaucoup plus puissante.
Outre le fait d’offrir des commandes pour piloter la tablette via des scripts exécutés localement, elle propose aussi un grand nombre de méthodes permettant de récupérer des informations plus précises que Remote Admin.

Voici le code html pour ceux qui sont intéressés :

<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8" />
  <title>Infos Tablette (version enrichie avec console debug)</title>
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <style>
    body {
      font-family: Arial, sans-serif;
      margin: 0;
      background: #121212;
      color: #eee;
      padding: 15px;
      font-size: 18px;
    }
    h1 {
      text-align: center;
      color: #4CAF50;
      margin-bottom: 20px;
      font-size: 28px;
    }
    #debugConsole {
      background-color: #222;
      color: #f88;
      font-family: monospace;
      padding: 12px;
      height: 200px;
      overflow-y: auto;
      white-space: pre-wrap;
      border-radius: 8px;
      margin-top: 25px;
      font-size: 16px;
    }
    .section {
      margin-bottom: 30px;
      padding: 18px;
      background: #222;
      border-radius: 8px;
      box-shadow: 0 0 8px #111 inset;
    }
    .section h2 {
      color: #66ccff;
      border-bottom: 2px solid #444;
      padding-bottom: 8px;
      margin-top: 0;
      font-weight: 600;
      letter-spacing: 0.04em;
      font-size: 22px;
    }
    .tiles {
      display: flex;
      flex-wrap: wrap;
      gap: 15px;
      margin-top: 15px;
    }
    .tile {
      flex: 1 1 240px;
      background: #333;
      padding: 15px 18px;
      border-radius: 8px;
      box-shadow: 0 2px 4px #0008;
      display: flex;
      flex-direction: column;
    }
    .tile span.key {
      color: #66ccff;
      font-weight: 700;
      margin-bottom: 8px;
      user-select: text;
      font-size: 1.1em;
    }
    .tile span.value {
      color: #ffcc66;
      user-select: text;
      font-size: 1.3em;
      word-break: break-word;
    }
    @media (max-width: 600px) {
      body {
        font-size: 16px;
      }
      .tiles {
        flex-direction: column;
      }
      .tile {
        flex: none;
        width: 100%;
      }
    }
  </style>
</head>
<body>
  <h1>Infos Tablette (version enrichie avec console debug)</h1>

  <div id="infoContainer"></div>

  <div id="debugConsole" aria-label="Console de debug"></div>

  <script>
    // Console visible dans la page
    (function() {
      const logEl = document.getElementById('debugConsole');

      function log(msg) {
        const time = new Date().toLocaleTimeString();
        logEl.textContent += `[${time}] ${msg}\n`;
        logEl.scrollTop = logEl.scrollHeight;
      }

      window.onerror = function(msg, url, lineNo, columnNo, error) {
        log(`Erreur: ${msg} à ${lineNo}:${columnNo}`);
        return false;
      };

      const originalLog = console.log;
      console.log = function(...args) {
        log(args.join(' '));
        originalLog.apply(console, args);
      };

      // Expose log to global scope pour tests éventuels
      window.log = log;
    })();

    // Fonctions utilitaires
    function createTile(key, value) {
      const div = document.createElement('div');
      div.className = 'tile';
      div.innerHTML = `<span class="key">${key}</span><span class="value">${value}</span>`;
      return div;
    }

    function createSection(title) {
      const section = document.createElement('section');
      section.className = 'section';
      const h2 = document.createElement('h2');
      h2.textContent = title;
      section.appendChild(h2);
      const tilesContainer = document.createElement('div');
      tilesContainer.className = 'tiles';
      section.appendChild(tilesContainer);
      return { section, tilesContainer };
    }

    // Récupération et affichage des infos tablette
    function displayInfos() {
      const container = document.getElementById('infoContainer');

      if (typeof fully === 'undefined') {
        console.log('❌ L\'objet fully est introuvable. Assure-toi que Fully Kiosk Browser est utilisé avec API activée.');
        container.appendChild(createTile('Erreur', "Objet 'fully' introuvable"));
        return;
      }

      // Helper pour format booléen
      function boolToStr(val) {
        if (val === true) return 'Oui';
        if (val === false) return 'Non';
        return val;
      }

      // Helper pour convertir octets en unités adaptées
      function formatBytes(bytes) {
        if (bytes === 'N/A' || isNaN(bytes)) return 'N/A';
        
        const GB = 1024 * 1024 * 1024;
        const MB = 1024 * 1024;
        
        if (bytes >= GB) {
          return (bytes / GB).toFixed(2) + ' Go';
        } else {
          return (bytes / MB).toFixed(2) + ' Mo';
        }
      }

      // Helper pour formater la température
      function formatTemperature(temp) {
        if (temp === 'N/A' || isNaN(temp)) return 'N/A';
        return parseFloat(temp).toFixed(1) + ' °C';
      }

      // Helper pour récupérer méthode safe
      function safeCall(methodName) {
        try {
          if (typeof fully[methodName] === 'function') {
            let result = fully[methodName]();
            
            // Conversion spécifique selon le type de donnée
            if (methodName.includes('Bytes') || 
                methodName.includes('Storage')) {
              return formatBytes(result);
            } else if (methodName === 'getBatteryTemperature') {
              return formatTemperature(result);
            }
            
            return result;
          }
        } catch (e) {
          console.log(`Erreur méthode ${methodName}: ${e.message}`);
        }
        return 'N/A';
      }

      // Organiser les infos par thématique
      const themes = {
        'Informations Générales': [
          { key: 'Nom appareil', method: 'getDeviceName' },
          { key: 'Modèle', method: 'getDeviceModel' },
          { key: 'N° de série', method: 'getSerialNumber' },
          { key: 'Version Android', method: 'getAndroidVersion' },
          { key: 'Résolution physique', value: '1920×1200' },  // Ajout de la résolution native
          { key: 'Région', method: 'getCurrentLocale' },
          { key: 'Adresse IP', method: 'getIp4Address' },
          { key: 'Adresse MAC', method: 'getMacAddress' }
        ],
        'Batterie': [
          { key: 'Niveau batterie (%)', method: 'getBatteryLevel' },
          { key: 'Charge en cours', method: 'isPlugged' },
          { key: 'Température batterie', method: 'getBatteryTemperature' }
        ],
        'Connectivité': [
          { key: 'Wifi connecté', method: 'isWifiConnected' },
          { key: 'SSID Wifi', method: 'getWifiSsid' },
          { key: 'Force signal Wifi', method: 'getWifiSignalLevel' },
          { key: 'Wifi Data reçues', method: 'getAllRxBytesWifi' },
          { key: 'Wifi Data transmises', method: 'getAllTxBytesWifi' },
          { key: 'Bluetooth activé', method: 'isBluetoothEnabled' }
        ],
        'Écran & Affichage': [
          { key: 'Résolution fenêtre', value: `${window.innerWidth}×${window.innerHeight}` },
          { key: 'Résolution système', value: `${window.screen.width}×${window.screen.height}` },
          { key: 'Densité pixels', method: 'getScreenDensity' },
          { key: 'Orientation écran', method: 'getScreenOrientation' },
          { key: 'Luminosité écran (%)', method: 'getScreenBrightness' },
          { key: 'Rotation verrouillée', method: 'isScreenRotationLocked' }
        ],
        'Statut application Fully': [
          { key: 'Id appareil', method: 'getDeviceId' },
          { key: 'Version Fully', method: 'getFullyVersion' },
          { key: 'Fully Version Code', method: 'getFullyVersionCode' },
          { key: 'Version Webview', method: 'getWebviewVersion' }
        ],
        'Stockage': [
          { key: 'Mémoire interne totale', method: 'getInternalStorageTotalSpace' },
          { key: 'Mémoire interne disponible', method: 'getInternalStorageFreeSpace' },
          { key: 'Mémoire externe totale', method: 'getExternalStorageTotalSpace' },
          { key: 'Mémoire externe disponible', method: 'getExternalStorageFreeSpace' }
        ],
        'Performances': [
          { key: 'RAM Totale', method: 'getTotalMemory' },
          { key: 'RAM Libre', method: 'getFreeMemory' }
        ]
      };

      for (const [theme, infos] of Object.entries(themes)) {
        const { section, tilesContainer } = createSection(theme);
        infos.forEach(info => {
          let val = 'N/A';
          if (info.method) {
            val = safeCall(info.method);
            if (typeof val === 'boolean') val = boolToStr(val);
          } else if (info.value !== undefined) {
            val = info.value;
          }
          tilesContainer.appendChild(createTile(info.key, val));
        });
        container.appendChild(section);
      }

      console.log('✅ Données Fully récupérées et affichées.');
    }

    // Délai pour s'assurer que fully est prêt
    window.addEventListener('load', () => {
      setTimeout(() => {
        displayInfos();
      }, 300);
    });
  </script>
</body>
</html>

Ce fichier html devra être stocké localement (vous pouvez utiliser Remote admin comme vu précédemment). Ce fichier pourra alors être appelé par l’URL de type file:///data/user/0/de.ozerov.fully/files/monFichier.html
Vous pourrez créer le lien dans le Launcher Universel de Fully Kiosk.

À la différence de Remote Admin, cette page Html ne fonctionne que si elle est affichée par Fully Kiosk.
Pour créer un lien vers cette page sur votre Dashboard ou liveview, il faudra charger la page en utilisant l’API Remote Admin afin de l’afficher sur la tablette.
Sur IPX, créer un widget HTML, puis insérer ce code :

<button onclick="appelAPI(); return false;">PLUS D'INFORMATIONS</button>
<script>
  async function appelAPI() {
    try {
      const response = await fetch("http://<ip_Tablette>:2323/?cmd=loadURL&url=file:///data/user/0/de.ozerov.fully/files/Fully-Diag-JS.html&password=<password>&type=json");
      const data = await response.json();
      console.log(data);
    } catch (error) {
      console.error('Erreur API:', error);
    }
  }
</script>

Bonne journée

[fgtoul]

Informations sur le branchement électrique de la tablette :
selon moi, le branchement permanent d’une alimentation à découpage Made in China pour alimenter la tablette est rédhibitoire :

• risque pour l’alimentation (surchauffe, …)
• risque pour la batterie (surchauffe, détérioration par surcharge, …)
  (la tablette ne propose pas d’option pour limiter la charge à 80% de la batterie et je n’ai pas envie de rooter le firmware)

J’ai donc opté pour une alimentation USB Legrand type Céliane, en flush mounted (sans plastron). Cette alimentation est connectée à un relais de l’ipx800 (via contacteur) qui permet de n’alimenter la tablette que sur plage horaire de nuit. Une extinction de la tablette est programmée dans Fully Kiosk sur la même plage horaire afin de rendre la charge optimale, sans risque de surchauffe de la batterie.
La tablette est accrochée devant l’alimentation, alimentée par un câble USB extra plat coudé à 90° aux 2 extrémités. Ce câble est prévu pour une charge rapide à 65W, cela évite la surchauffe.

[fgtoul]

Bonjour à tous,
Aujourd’hui j’aborde le chapitre Vidéosurveillance concernant ce chantier.
Mon choix s’est porté sur du matériel Reolink :

• Caméras POE RLC-540 et RLC-840
• NVR RLN36

Les caméras

Les caméras sont capables d’être autonomes. Elles proposent une détection intelligente des personnes, véhicules et animaux, réduisant ainsi les fausses alertes. Elles offrent une vision nocturne IR et couleur, et un champ de vision assez large, idéale pour capturer les moindres détails à 5 ou 8MP (4K).
Elles sont anti-vandalisme (IK10) et étanches (IP67).
Elles intègrent les alertes en temps réel.

Le NVR

Connectées à un NVR, les caméras IP perdent leur autonomie sur le réseau.
Leur adresse IP devient invisible car gérée par le NVR. L’accès direct à la caméra est alors rendu impossible, les fonctionnalités comme le Time-Lapse ou encore la compatibilité Cloud qui permet de les connecter à Alexa sont inhibées.
Il fallait donc choisir un NVR capable de la fonction qui permettrait de récupérer toutes ces fonctionnalités perdues. Chez la plupart des fabricants c’est ce qui est appelé « Bridge mode » ou encore « Dual access ». Chez Reolink cette capacité est appelée HyBridge Mode

L’autre critère de choix important était la mise à disposition d’un bornier Entrées/Sorties Alarme pour communiquer avec l’IPX800.
Mon choix s’est tout naturellement porté sur le RLN36 qui permettait ces 2 fonctions.

La vidéo sur IPX800 V5

Les caméras choisies, comme toutes celles d’aujourd’hui, ne proposent plus le flux Mjpeg, mais principalement le RTSP, non pris en charge par les IPX800.
J’ai tenté d’installer TinyCam Monitor Pro sur la tablette pour assurer la fonction de Proxy Vidéo (convertir à la volée les flux RTSP en MJPEG et les rendre disponibles sur un mini serveur Web). La latence était un peu importante (5-6s), j’ai abandonné. Vous allez me dire que j’aurais pu installer FFMPEG sur un Raspberry 4 ou 5 pour plus de puissance, mais je rappelle que je ne veux pas d’éléments tiers dans l’installation car cela complique toujours la maintenance et multiplie les risques de dysfonctionnements.
« Tout ce qui peut mal tourner finira par mal tourner. » dixit Murphy.
Il fallait donc forcément utiliser les widgets natifs de la V5 en mode « Image par image ». Les caméras proposent une API permettant de le faire.

http://<IP-Camera>/api.cgi?cmd=Snap&channel=0&user=admin&password=<password>&width=640&height=480

En faisant les tests, je me suis rendu compte que dans ce mode « Snapshot », le widget ne fonctionne pas. Il affiche une image figée de la première capture. En mode plein écran, l’image est également figée. J’en déduis qu’il y a un problème de mise en cache par le navigateur non géré par l’IPX.
J’ai donc remonté ce dysfonctionnement au BE (@gce) et développé mon propre widget en attendant les correctifs. La résolution consiste à ajouter une valeur aléatoire dans la requête pour bloquer la mise en cache. Dans le cas de l’API Reolink, c’est le paramètre rs. Pour toute autre camera, il est possible d’ajouter un paramètre quelconque, l’essentiel étant son caractère unique à chaque requête.

    <style>
        #snapImg { 
            max-width: 100%; 
            border: 1px solid #ddd; 
            margin: 10px 0; 
            background: #000;
        }
    </style>

    <img id="snapImg" src="" alt="Live Snap">
    
    <script>
        // Configuration
        var camIp = 'IP-Camera';  // Remplacez par l'IP de votre caméra
        var myAdmin = 'admin';       // Votre nom d'utilisateur
        var  myPass = 'myPass';  // Votre mot de passe
        var  refreshInterval = 1800;    // Intervalle de rafraîchissement en ms
        var snapImg;
        // Éléments DOM

        
        // Génère un paramètre anti-cache
        function getCacheBuster() {
            return 'rs=' + Date.now().toString(36) + Math.random().toString(36).substr(2, 8);
        }
        
        // Charge une nouvelle image
        function fetchNewImage() {
			snapImg = document.getElementById('snapImg');
            
            const url = `http://${camIp}/cgi-bin/api.cgi?cmd=Snap&channel=0&${getCacheBuster()}&user=${myAdmin}&password=${myPass}&width=640&height=480`;
            
            fetch(url, { 
                mode: 'no-cors'
            })
            .then(() => {
                // Utilisation d'un timestamp pour forcer le rechargement
                snapImg.src = url + '&t=' + Date.now();
            })
            .catch(e => console.log('Erreur de chargement:', e));
        }
        
        // Démarrer le rafraîchissement automatique
        setInterval(fetchNewImage, refreshInterval);
        
        // Premier chargement
        setTimeout(fetchNewImage,500);
    </script>

Attention au temps de rafraichissement. Si les requêtes sont trop fréquentes, la caméra n’a pas le temps d’envoyer l’image, le widget est figé. Il faut allonger le délai petit à petit pour trouver la bonne valeur (1800 ms dans mon cas).

Cette vidéo permet de comparer la latence des widgets par rapport au direct. Pour l’exemple j’active les projecteurs de la caméra.

• à gauche le flux vidéo converti en mjpeg par TinyCam sur widget natif en mode vidéo
• au centre mon widget html en mode image avec refresh=1800ms
• à droite un widget natif en mode image

Pour le Liveview, le widget Caméra présente le même dysfonctionnement, mais en mode plein écran seulement.
J’ai donc dû également développer mon propre widget affichant les caméras en grand une à une avec une sélection par boutons, sans devoir utiliser la fenêtre modale plein écran du widget.

Voici le code :

<style>
  .buttons { margin: 10px; }
  button {
    background: #444; color: #fff; border: none; padding: 10px 20px;
    margin: 5px; font-size: 16px; border-radius: 5px;
  }
  button:hover { background: #666; }
</style>

<div class="buttons">
  <button onclick="loadCam('192.168.0.106','80','admin','myPass')">Portail</button>
  <button onclick="loadCam('192.168.0.152','80','admin','myPass')">Entrée</button>
  <button onclick="loadCam('192.168.0.108','80','admin','myPass')">Bois</button>
  <button onclick="loadCam('192.168.0.109','80','admin','myPass')">Potager</button>
  <button onclick="loadCam('192.168.0.110','80','admin','myPass')">Intérieur</button>
</div>

<img src="" id="snapImg" width="100%" alt="snapshot en cours">

<script>
  let base = "";

  function loadCam(camip, camport, user, pwd) {
    base = `http://${camip}:${camport}/api.cgi?cmd=Snap&channel=0&user=${user}&password=${pwd}&width=640&height=480`;
    refreshImg(); // Affiche immédiatement
  }

  function refreshImg() {
    const img = document.getElementById("snapImg");
    img.src = base + `&t=${Date.now()}`; // Empêche le cache
  }

  setInterval(refreshImg, 2000); // Rafraîchit toutes les 2 secondes
</script>

La vidéo sur la tablette

Les flux des caméras sont visibles sur le Liveview de l’ipx en TimeLaps.
Fully Kiosk permet également de lancer l’application Reolink pour visualiser les vidéos en très haute résolution sur les flux RTSP directement.

La visualisation des caméras peut donc se faire sur tout appareil connecté, que ce soit au travers de l’IPX ou directement sur les caméras avec l’application Reolink, en local comme à distance.

Principes domotiques

Dans le cadre de la mise en service de l’alarme, l’IPX800 active — via un relais interposé — une entrée du NVR Reolink RLN36.

=> Principe de connexion des I/O du RLN36 :

Les sorties du RLN36 sont des relais.

Sur le Reolink RLN36, il est possible de conditionner l’envoi de notifications à la fois par :

• la détection de mouvement (personne ou véhicule) par les caméras connectées,
• et par l’activation d’une entrée alarme sur le bornier du NVR.

Cette configuration permet de réduire significativement le nombre de notifications envoyées par le NVR vers l’application installée sur tablette murale, en ne transmettant les alertes que lorsque le système d’alarme est effectivement armé.

[wildc4rd]

Bonjour fgtoul‚

Merci d’avoir créer ce post et de prendre le temps de nous faire partager ce super projet. Pour ma part je le suis avec beaucoup d’intérêt.

@fgtoul

Vous allez me dire que j’aurais pu installer FFMPEG sur un raspberry 4 ou 5 pour plus de puissance, mais je rappelle que je ne veux pas d’éléments tiers dans l’installation car cela complique toujours la maintenance et multiplie les risques de dysfonctionnements.

Je sais que vous ne voulez pas de tiers dans votre installe mais pourquoi ne pas utiliser un NRX800 ? c’est du GCE et c’est plus stable qu’un raspberry.

[fgtoul]

quand j’ai dit raspberry, j’incluais aussi le NRX.
Rasp ou NRX, c’est orienté power user. ce n’est pas le cas du propriétaire.
ça demande beaucoup de temps pour le programmer et éventuellement le maintenir (updates, évolutions, …) c’est aussi pour cette raison que je préfère le 100% ipx. Il faut aussi penser revente. L’acheteur pourra se tourner vers GCE pour les ipx et extensions, mais pour le Rpi, il devra se débrouiller.

Personnellement, j’ai un Jeedom sur Rpi. Il n’a pour fonction que Data-Logger. Aucun rôle actif sur l’installation.

[cce66]

Ah ces satanées fioritures…
Super boulot…et partage !

[wildc4rd]

Petite question concernant vos tableaux electriques.
Vu que vos tableaux sont de 24 modules vous n’avez pas pu mettre de goulottes GTL.

Vous faites arriver vos gaines ICTA directement dans les tableaux par derriere en passant par le doublage ?

[fgtoul]

Oui, c’est bien ça .

[wildc4rd]

Je suis curieux de savoir comment vous avez réussi à tout faire passer ?
C’est plutôt épais une gaine de 25 et vous en avez un bon paquet qui reviennent aux tableaux.
Votre doublage est profond ?
Vous faites tout arriver par le plafond ?

[fgtoul]

C’est une GTL bâtie .

[wildc4rd]

Bonjour fgtoul‚

Merci. C’est plus clair.

Je ne vois pas le linky. Vous etes sur un branchement de type 2 ?
Pourquoi du placo pare feu ?
Aucun problèmes avec le consuel ? Est-ce qu’il à vérifié si vos gaines ICTA BT arrivaient bien jusque dans le tableau ?