Backend de suivi de configuration de maison intelligente

Modèle de backend de suivi de configuration de maison intelligente PH0
Journaux de couplage de périphériques et configuration du hub

Q: Où les équipes de configuration de maisons intelligentes perdent-elles le plus de temps entre le bureau et le terrain ?

Un tracker de configuration de maison intelligente est un schéma et une API BaaS pour les opérations d'installation : sites de maison, configurations de hub, journaux de couplage de dispositifs et autorisations utilisateur.

Q: Comment les affectations de modèle de configuration de maison intelligente, le statut et l'utilisation des pièces devraient-ils être gérés sans compliquer le schéma ?

Il inclut User (nom d'utilisateur, email, mot de passe), HomeSite (surnom, étiquette d'adresse, notes d'installateur), HubConfig (homeSite, wifiSsid, fuseau horaire, mode d'automatisation), DevicePairingLog (homeSite, nom de dispositif, type de dispositif, statut de couplage, associé à), et PermissionGrant (homeSite, utilisateur, rôle, niveau d'accès), plus le diagramme ER, le terrain de jeu API et un prompt d'agent IA.

Q: Quelle est la manière la plus sûre d'évoluer les entités de configuration de maison intelligente à mesure que l'entreprise ajoute des SKU ou des services ?

Back4app fournit une base de données gérée, une authentification, des requêtes en temps réel et un schéma flexible afin que vous puissiez expédier des journaux de couplage de dispositifs, des configurations de hub et des autorisations sans faire fonctionner votre propre backend.

Q: Comment exécuter des requêtes pour HomeSite et HubConfig avec Flutter ?

Utilisez les classes HomeSite et HubConfig pour interroger et afficher les détails de configuration, en tirant parti du SDK Back4app.

Q: Comment gérer les autorisations de configuration de la maison intelligente avec Next.js Server Actions ?

Utilisez une action de serveur pour créer un objet Parse pour PermissionGrant avec des pointeurs vers User et HomeSite, puis validez l'accès dans Cloud Code.

Q: Est-ce que React peut mettre en cache les entrées DevicePairingLog hors ligne ?

Oui. Activez Local Datastore et épinglez les résultats DevicePairingLog et HomeSite afin que les installateurs puissent consulter l'historique de configuration sans connectivité.

Q: Comment puis-je empêcher les modifications non autorisées du hub ?

Dans Cloud Code beforeSave pour HubConfig, imposez des vérifications de rôle et rejetez les modifications lorsque l'utilisateur n'a pas le bon niveau d'accès.

Q: Quelle est la meilleure façon d'afficher les journaux de couplage sur Android ?

Interrogez les classes DevicePairingLog et HomeSite pour afficher deviceName, pairingStatus et pairedAt pour chaque installation.

Q: Comment fonctionne le flux de configuration de la maison intelligente de bout en bout ?

Un utilisateur se connecte, charge un HomeSite, met à jour HubConfig, crée des entrées DevicePairingLog pour chaque appareil, et le tableau de bord se met à jour via Live Queries lorsque l'installation change.

Q: Quelles classes alimentent ce modèle de suivi de configuration de maison intelligente ?

Le modèle de base comprend Utilisateur (nom d'utilisateur, e-mail, mot de passe), SiteDomicile (surnom, étiquette d'adresse, notes d'installateur), ConfigHub (siteDomicile, wifiSsid, fuseauHoraire, modeAutomatisation), JournalAppairageDispositif (siteDomicile, nomDispositif, typeDispositif, statutAppairage, appairéÀ), et AutorisationAccord (siteDomicile, utilisateur, rôle, niveauAccès).

Un backend de suivi de configuration de maison intelligente prêt pour la production sur Back4app avec journaux de couplage de périphériques, configuration du hub et autorisations des utilisateurs. Comprend un diagramme ER, un dictionnaire de données, un schéma JSON, un environnement de test API, et un prompt AI Agent pour un démarrage rapide.

Construire avec AI Agent Choisissez votre technologie

Récapitulatif du tracker de configuration

Ce modèle vous fournit un backend de tracker de configuration de maison intelligente avec des journaux de couplage de dispositifs, la configuration du concentrateur et les permissions utilisateur afin que les coordinateurs puissent garder les installations visibles et contrôlées.

Visibilité des journaux de couplage — Suivez chaque DevicePairingLog avec le nom du dispositif, l'état du couplage et les notes du technicien dans une structure interrogeable.
Contrôle de configuration du concentrateur — Stockez les enregistrements HubConfig pour le Wi-Fi, la région et les règles d'automatisation que les installateurs peuvent examiner avant la remise.
Accès sensible aux permissions — Attribuez des entrées PermissionGrant afin que seuls les utilisateurs approuvés puissent voir ou modifier une configuration de maison.
Suivi des opérations sur le terrain — Utilisez les enregistrements HomeSite et DevicePairingLog pour suivre les installations à travers les pièces, les adresses et les états d'achèvement.
Backend multi-client — Servez des clients mobiles et web via une API REST et GraphQL pour la configuration, les journaux et les autorisations utilisateur.

Qu'est-ce que le modèle de suivi de configuration de maison intelligente ?

Le routage, les pièces et les communications avec les clients ne semblent sans effort que lorsque les données de configuration de maison intelligente sont structurées plutôt que piégées dans des PDF et des discussions parallèles. Le coût se manifeste dans les rappels et les crédits. Ce modèle modélise HomeSite, HubConfig, DevicePairingLog et PermissionGrant sur Back4app afin que vous expédiiez un backend de configuration de maison intelligente fonctionnel au lieu d'attacher des tableurs ensemble de manière improvisée. Le schéma couvre Utilisateur (nom d'utilisateur, email, mot de passe), HomeSite (surnom, label d'adresse, notes d'installateur), HubConfig (homeSite, wifiSsid, fuseau horaire, mode d'automatisation), DevicePairingLog (homeSite, nom du dispositif, type de dispositif, état de couplage, appairé à), et PermissionGrant (homeSite, utilisateur, rôle, niveau d'accès) avec suivi d'authentification et de configuration intégré. Connectez votre frontend préféré et expédiez plus rapidement.

Meilleur pour :

Traceurs d'installation de maison intelligenteTableaux de bord des journaux de jumelage de dispositifsOutils de configuration du HubApplications de gestion des autorisations utilisateurÉquipes des opérations sur le terrainÉquipes choisissant BaaS pour des produits de maison intelligente

Configuration de la maison intelligente : instantané du backend

Si l'intégration d'un nouvel employé dans la configuration de la maison intelligente nécessite des connaissances tribales, vous êtes à un départ d'un point de défaillance unique.

Que vous expédiez sur le web ou mobile, HomeSite, HubConfig et DevicePairingLog restent la colonne vertébrale — cette page est le moyen le plus rapide d'aligner les parties prenantes.

Fonctionnalités de base de la configuration de maison intelligente

Chaque carte de technologie dans ce hub utilise le même schéma de configuration de maison intelligente avec User, HomeSite, HubConfig, DevicePairingLog et PermissionGrant.

Gestion de site principal

HomeSite stocke le surnom, l'étiquette d'adresse et les notes d'installation.

Enregistrements de configuration du hub

HubConfig relie chaque site principal à wifiSsid, fuseau horaire et mode d'automatisation.

Journaux de couplage de périphériques

DevicePairingLog suit deviceName, deviceType, pairingStatus et pairedAt.

Permissions utilisateur

PermissionGrant stocke homeSite, user, role et accessLevel.

Pourquoi créer votre backend de suivi de configuration de maison intelligente avec Back4app ?

Back4app vous fournit des primitives de maison, de hub, de journal, et de permissions afin que votre équipe puisse se concentrer sur les opérations d'installation plutôt que sur la plomberie du backend.

•Suivi de HomeSite et de DevicePairingLog: HomeSite enregistre chaque adresse tandis que DevicePairingLog capture le nom de l'appareil, le type d'appareil et l'état d'apairage pour chaque installation.
•Contrôle de HubConfig: HubConfig garde wifiSsid, fuseau horaire et mode d'automatisation en un seul endroit pour les installateurs et les coordinateurs.
•Flexibilité en temps réel + API: Utilisez Live Queries pour les mises à jour de DevicePairingLog tout en gardant REST et GraphQL disponibles pour chaque client.

Construisez et faites évoluer rapidement des flux de travail de configuration de maison intelligente avec un seul contrat backend sur toutes les plateformes.

Avantages principaux

Un backend de configuration de maison intelligente qui maintient le travail d'installation visible et autorisé.

Lancement de l'installation rapide

Commencez avec un schéma complet HomeSite, HubConfig et DevicePairingLog plutôt que de concevoir le backend de configuration depuis zéro.

Historique de couplage clair

Capturez les tentatives de couplage avec deviceName, deviceType, pairingStatus et notes afin que les problèmes soient faciles à revoir.

Transmission consciente des permissions

Utilisez PermissionGrant pour contrôler qui peut voir ou modifier chaque site résidentiel après l'installation.

Paramètres du hub au même endroit

Stockez wifiSsid, fuseau horaire et mode d'automatisation ensemble afin que les modifications de configuration restent traçables.

Instantanés de maison et d'appareil

Conservez des instantanés de configuration pour HomeSite et DevicePairingLog sans changer le schéma chaque fois qu'un nouvel appareil est ajouté.

Flux de travail de bootstrap AI

Générez rapidement l'échafaudage backend et les conseils d'intégration avec une invite structurée.

Prêt à lancer le suivi de la configuration de votre maison intelligente ?

Laissez l'Agent AI Back4app échafauder votre backend de configuration de maison intelligente et générer des journaux d'appairage des appareils, la configuration du hub et les autorisations des utilisateurs à partir d'une seule invite.

Construire avec l'Agent AI Essayez le terrain de jeu API

Gratuit pour commencer — 50 invites d'Agent AI/mois, pas de carte de crédit requise

Empilement technique

Tout compris dans ce modèle de backend de configuration de maison intelligente.

Frontend

13+ technologies

Backend

Back4app

Base de données

MongoDB

Auth

Authentification intégrée + sessions

API

REST et GraphQL

Temps réel

Live Queries

Diagramme ER de la maison intelligente

Modèle de relation d'entité pour le schéma backend de la maison intelligente.

Diagramme ER

Voir la source du diagramme

Mermaid

erDiagram
    User ||--o{ HomeSite : "primaryContact"
    User ||--o{ DevicePairingLog : "technician"
    User ||--o{ HubConfiguration : "configuredBy"
    User ||--o{ PermissionGrant : "grantee"
    HomeSite ||--o{ DevicePairingLog : "homeSite"
    HomeSite ||--o{ HubConfiguration : "homeSite"
    HomeSite ||--o{ PermissionGrant : "homeSite"

    User {
        String objectId PK
        String username
        String email
        String password
        String fullName
        String role
        Date createdAt
        Date updatedAt
    }

    HomeSite {
        String objectId PK
        String siteCode
        String addressLabel
        String setupStatus
        String primaryContactId FK
        Date createdAt
        Date updatedAt
    }

    DevicePairingLog {
        String objectId PK
        String homeSiteId FK
        String deviceName
        String deviceType
        String pairingStatus
        Date pairedAt
        String technicianId FK
        Date createdAt
        Date updatedAt
    }

    HubConfiguration {
        String objectId PK
        String homeSiteId FK
        String hubModel
        String firmwareVersion
        String networkName
        String pairingMode
        String configuredById FK
        Date createdAt
        Date updatedAt
    }

    PermissionGrant {
        String objectId PK
        String homeSiteId FK
        String granteeId FK
        String accessLevel
        String status
        Date grantedAt
        Date createdAt
        Date updatedAt
    }

Flux d'intégration de configuration de maison intelligente

Flux d'exécution typique pour l'authentification, la recherche du site domicile, la configuration du hub, les journaux de couplage des appareils et les octrois de permission.

Diagramme ER

Voir la source du diagramme

Mermaid

sequenceDiagram
  participant User
  participant App as Smart Home Setup Tracker App
  participant Back4app as Back4app Cloud

  User->>App: Sign in to review a home installation
  App->>Back4app: POST /login
  Back4app-->>App: Session token

  User->>App: Open HomeSite list
  App->>Back4app: GET /classes/HomeSite?include=primaryContact
  Back4app-->>App: HomeSite rows with setupStatus

  User->>App: Save a DevicePairingLog
  App->>Back4app: POST /classes/DevicePairingLog
  Back4app-->>App: DevicePairingLog objectId

  User->>App: Update HubConfiguration
  App->>Back4app: PUT /classes/HubConfiguration/:objectId
  Back4app-->>App: HubConfiguration saved

  App->>Back4app: Subscribe to live changes for PermissionGrant
  Back4app-->>App: PermissionGrant updates

Configurer le dictionnaire de données

Référence complète au niveau des champs pour chaque classe dans le schéma de configuration de maison intelligente.

Champ	Type	Description	Requis
objectId	String	Auto-generated unique identifier	Auto
username	String	User login name
email	String	User email address
password	String	Hashed password (write-only)
fullName	String	Display name for the installer, coordinator, or homeowner
role	String	Role of the user (e.g., coordinator, field-tech, homeowner)
createdAt	Date	Auto-generated creation timestamp	Auto
updatedAt	Date	Auto-generated last-update timestamp	Auto

8 champs dans User

Sécurité et autorisations

Comment la stratégie ACL et CLP sécurise les utilisateurs, les sites principaux, les configurations de hub, les journaux de couplage de dispositifs et les attributions de permission.

Contrôles des comptes détenus par l'utilisateur

Seul l'utilisateur peut mettre à jour ou supprimer son profil ; les autres ne peuvent pas modifier le contenu de l'utilisateur.

Intégrité de la maison et du hub

Seul le personnel autorisé peut créer ou modifier des enregistrements HomeSite et HubConfig. Utilisez Cloud Code pour la validation.

Accès de configuration limité

Restreindre les lectures de DevicePairingLog et PermissionGrant aux personnes assignées à ce site de résidence.

Schéma (JSON)

Définition de schéma JSON brut prête à être copiée dans Back4app ou à utiliser comme référence de mise en œuvre.

JSON

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

{
  "classes": [
    {
      "className": "User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "fullName": {
          "type": "String",
          "required": true
        },
        "role": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "HomeSite",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "siteCode": {
          "type": "String",
          "required": true
        },
        "addressLabel": {
          "type": "String",
          "required": true
        },
        "setupStatus": {
          "type": "String",
          "required": true
        },
        "primaryContact": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "DevicePairingLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "homeSite": {
          "type": "Pointer",
          "required": true,
          "targetClass": "HomeSite"
        },
        "deviceName": {
          "type": "String",
          "required": true
        },
        "deviceType": {
          "type": "String",
          "required": true
        },
        "pairingStatus": {
          "type": "String",
          "required": true
        },
        "pairedAt": {
          "type": "Date",
          "required": true
        },
        "technician": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "HubConfiguration",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "homeSite": {
          "type": "Pointer",
          "required": true,
          "targetClass": "HomeSite"
        },
        "hubModel": {
          "type": "String",
          "required": true
        },
        "firmwareVersion": {
          "type": "String",
          "required": true
        },
        "networkName": {
          "type": "String",
          "required": true
        },
        "pairingMode": {
          "type": "String",
          "required": true
        },
        "configuredBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "PermissionGrant",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "homeSite": {
          "type": "Pointer",
          "required": true,
          "targetClass": "HomeSite"
        },
        "grantee": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "accessLevel": {
          "type": "String",
          "required": true
        },
        "status": {
          "type": "String",
          "required": true
        },
        "grantedAt": {
          "type": "Date",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Construire avec l'agent IA

Utilisez l'agent IA Back4app pour générer une véritable application de suivi de configuration de maison intelligente à partir de ce modèle, y compris le frontend, le backend, l'authentification et les flux de maison, de hub, de journal et de permissions.

Agent IA Back4app

Prêt à construire

Créez un backend d'application de suivi de configuration de maison intelligente sur Back4app avec ce schéma et ce comportement exacts.

Schéma :
1. Utilisateur (utilisez le intégré de Back4app) : nom d'utilisateur, email, mot de passe ; objectId, createdAt, updatedAt (système).
2. HomeSite : surnom (String, requis), label d'adresse (String, requis), notes de l'installateur (String) ; objectId, createdAt, updatedAt (système).
3. HubConfig : homeSite (Pointer to HomeSite, requis), wifiSsid (String, requis), fuseau horaire (String, requis), mode d'automatisation (String, requis) ; objectId, createdAt, updatedAt (système).
4. DevicePairingLog : homeSite (Pointer to HomeSite, requis), nom de l'appareil (String, requis), type d'appareil (String, requis), statut de couplage (String, requis), couplé à (Date, requis), notes du technicien (String) ; objectId, createdAt, updatedAt (système).
5. PermissionGrant : homeSite (Pointer to HomeSite, requis), utilisateur (Pointer to User, requis), rôle (String, requis), niveau d'accès (String, requis) ; objectId, createdAt, updatedAt (système).

Sécurité :
- Uniquement l'utilisateur peut mettre à jour/supprimer son profil. Seul le personnel autorisé peut créer/modifier HomeSite et HubConfig. Restreindre les lectures de DevicePairingLog et PermissionGrant aux utilisateurs assignés. Utilisez Cloud Code pour la validation.

Auth :
- Inscription, connexion, déconnexion.

Comportement :
- Lister les sites domestiques, enregistrer les journaux de couplage des appareils, mettre à jour les configurations des hubs et gérer les permissions.

Livraison :
- Application Back4app avec schéma, ACL, CLP ; frontend pour les sites domestiques, configurations de hub, journaux de couplage des appareils et attributions de permissions.

Appuyez sur le bouton ci-dessous pour ouvrir l'agent avec cette invite de modèle pré-remplie.

Ceci est l'invite de base sans suffixe technologique. Vous pouvez adapter la pile frontend générée par la suite.

Déployer en quelques minutes50 invitations gratuites / moisAucune carte de crédit requise

API Playground

Essayez les points de terminaison REST et GraphQL contre le schéma de configuration de maison intelligente. Les réponses utilisent des données fictives et ne nécessitent pas de compte Back4app.

Chargement du terrain de jeu…

Utilise le même schéma que ce modèle.

Choisissez votre technologie

Développez chaque carte pour voir comment intégrer HomeSite, HubConfig et DevicePairingLog avec votre pile choisie.

Ce que vous obtenez avec chaque technologie

Chaque pile utilise le même schéma backend de configuration de maison intelligente et des contrats API.

Structure de données de maison intelligente unifiée

Gérez facilement les sites de maisons, les configurations de hubs, les journaux de couplage et les autorisations avec un schéma cohérent.

Journaux de couplage des appareils pour les installateurs

Suivez les tentatives de couplage, les nouvelles tentatives et les états de complétion pour chaque appareil.

Support de configuration du hub

Stockez les paramètres Wi‑Fi, de fuseau horaire et d'automatisation pour chaque installation.

Autorisations utilisateur personnalisables

Définissez les niveaux d'accès pour les gestionnaires, les coordinateurs, les installateurs et les résidents.

REST/GraphQL APIs pour les applications de maison intelligente

Intégrez des tableaux de bord mobiles, des consoles web et des outils de terrain avec des APIs flexibles.

Architecture extensible pour les équipes opérationnelles

Ajoutez des visites de service, des inventaires d'appareils ou des vérifications de maintenance sans rompre les enregistrements de configuration existants.

Comparaison des frameworks de maison intelligente

Comparer la vitesse de configuration, le style SDK et le support AI parmi toutes les technologies prises en charge.

Cadre	Temps de Configuration	Avantage de la Maison Intelligente	Type de SDK	Support AI
Flutter	Environ 5 minutes	Base de code unique pour les applications d'installation et de coordination.	SDK Typé	Complet
React	Moins de 5 minutes	Tableau de bord web rapide pour les journaux de couplage.	SDK typé	Complet
React Native	~3–7 min	Application mobile multiplateforme pour le personnel sur le terrain.	SDK typé	Complet
Next.js	Configuration rapide (5 min)	Console rendue côté serveur pour les avis de configuration à domicile.	SDK typé	Complet
JavaScript	~3–5 min	Intégration web légère pour les opérations domotiques.	SDK typé	Complet
Android	Environ 5 min	Application Android native pour les équipes d'installation.	SDK typé	Complet
iOS	Moins de 5 minutes	Application iOS native pour les vérifications de configuration mobile.	SDK typé	Complet
Vue	~3–7 min	Interface web Reactive pour le suivi de configuration.	SDK tapé	Complet
Angular	Configuration rapide (5 min)	Application web d'entreprise pour les autorisations et les journaux.	SDK tapé	Complet
GraphQL	Moins de 2 min	API GraphQL flexible pour la configuration de maison intelligente.	API GraphQL	Complet
REST API	Configuration rapide (2 min)	intégration REST API pour le suivi des installations.	REST API	Complet
PHP	~3 min	Backend PHP côté serveur pour les outils d'installation.	REST API	Complet
.NET	~3–7 min	Backend .NET pour les tableaux de bord des opérations.	SDK typé	Complet

Le temps de configuration reflète la durée attendue de l'amorçage du projet à la première requête HomeSite ou DevicePairingLog utilisant ce schéma de modèle.

Questions Fréquemment Posées

Questions courantes sur la création d'un backend de suivi de configuration de maison intelligente avec ce modèle.

Où les équipes de configuration de maisons intelligentes perdent-elles le plus de temps entre le bureau et le terrain ?

Comment les affectations de modèle de configuration de maison intelligente, le statut et l'utilisation des pièces devraient-ils être gérés sans compliquer le schéma ?

Quelle est la manière la plus sûre d'évoluer les entités de configuration de maison intelligente à mesure que l'entreprise ajoute des SKU ou des services ?

Comment exécuter des requêtes pour HomeSite et HubConfig avec Flutter ?

Comment gérer les autorisations de configuration de la maison intelligente avec Next.js Server Actions ?

Est-ce que React peut mettre en cache les entrées DevicePairingLog hors ligne ?

Comment puis-je empêcher les modifications non autorisées du hub ?

Quelle est la meilleure façon d'afficher les journaux de couplage sur Android ?

Comment fonctionne le flux de configuration de la maison intelligente de bout en bout ?

Quelles classes alimentent ce modèle de suivi de configuration de maison intelligente ?

Approuvé par des développeurs du monde entier

Rejoignez des équipes qui expédient des produits de configuration pour maison intelligente plus rapidement avec les modèles Back4app

Prêt à construire votre suivi de configuration pour maison intelligente ?

Commencez votre projet de configuration de maison intelligente en quelques minutes. Aucune carte de crédit requise.

Choisissez la technologie

Modèle de backend de suivi de configuration de maison intelligente __PH0__Journaux de couplage de périphériques et configuration du hub