Mise à jour le 20/01/2021 : Surveillance Station est une application fournie dans les NAS Synology. Elle permet de monitorer plusieurs caméra IP et de centraliser leur gestion. On peut ainsi regrouper plusieurs caméras.
Sommaire :
- Introduction à surveillance station
- Le matériel
- 1er partie le paramétrage du NAS
- Installation du module Surveillance Station
- Création d’un certificat SSL auto signé.
- Accès depuis Internet sans IP fixe
- Création du compte utilisateur spécial caméras.
- Paramétrage des caméras dans surveillance Station
- Paramétrage d’un smartphone pour accéder aux caméras.
- 2er partie le montage Arduino / Yokis .
- Le logiciel pour piloter le NAS
- Retour au menu tutoriel .
Introduction à surveillance station |
.
Surveillance Station est une application fournie dans les NAS Synology. Elle permet de monitorer plusieurs caméra IP et de centraliser leur gestion. On peut ainsi regrouper plusieurs caméras, paramétrer des plages de surveillance, activer/désactiver les caméras, gérer des cycles de surveillance (uniquement avec les caméras motorisées). L’avantage des NAS Synology, c’est qu’ils proposent également des applications pour smartphone afin de gérer les fichiers, les téléchargements… mais surtout, les caméras. On peut ainsi visionner ses caméras depuis l’extérieur, on peut même recevoir une notification directement sur le smartphone en cas d’intrusion.
Le but de cet article est de réaliser un montage permettant d’activer ou désactiver toutes les caméras IP à partir d’un module Yokis en communiquant avec le NAS Synology.
Schéma de principe :
Nous verrons dans une première partie le paramétrage du NAS pour mettre à disposition les caméras sur le réseau, pour pouvoir visionner celles-ci sur notre smartphone depuis l’exterieur du réseau domestique. Dans un second temps, nous verrons le montage permettant d’envoyer une impulsion sur la carte arduino pour que celle-ci envoie l’ordre au NAS d’activer ou de désactiver la caméra. Enfin, nous verrons en dernière partie la partie programmation de l’arduino afin de communiquer avec le NAS.
.
Retour au sommaire.
Le matériel |
.
Pour créer votre centre de surveillance complet, vous devez pour cela posséder :
Pour la partie surveillance
- Un NAS Synology (le DS214 s’y prête très bien) avec bien entendu un disque dur à l’intérieur
- Une ou plusieurs caméras IP supportées par le NAS (page concernant les caméras compatibles ici)
- Tout le nécessaire pour le réseau (Cablage RJ45, Switch)
Pour la partie pilotage par télécommande
- Un module Arduino (Pour notre montage, nous avons utilisé la version Mega 2560)
- Le shield Ethernet (ou Wifi, mais pour l’exemple de cet article, nous utiliserons le module filaire RJ45)
- Une alimentation 12V 400mA pour Arduino (un exemple ici)
- Un module de pilotage par télécommande Yokis (Disponible ici)
- LED
- Resistances (1.5K et 4.7K)
.
Retour au sommaire.
– Première partie –
|
.
Afin de fonctionner correctement, nous devons effectuer un certain nombre de paramétrages dans le serveur NAS :
Installation du module Surveillance Station
Surveillance station est un module optionnel qui n’est pas installé par défaut sur le NAS. Vous devez alors vous rendre dans le centre de paquets du NAS puis, dans la zone de recherche, tapez « surveillance ». Apparaitra alors le module de surveillance « Surveillance Station ». Cliquez sur le bouton installer.
Création d’un certificat SSL auto signé
Le certificat SSL permet de sécuriser les communications entre votre NAS et le reste du monde (votre smartphone, l’Arduino…). En effet, la protection HTTPS via un certificat SSL permet de chiffrer toutes les données qui passent entre le NAS et l’appareil qui y accède ce qui protège la transmission des mots de passe et autres données sensibles.
Pour créer ce certificat auto-signé, rendez-vous dans Panneau de configuration puis dans Sécurité. Cliquez sur l’onglet Certificat puis cliquez sur le bouton « Créer un certificat ». Laissez l’option par défaut « Créer un certificat auto-signé » puis cliquez sur suivant. Renseignez tous les champs puis validez.
Une fois le certificat créé, rendez-vous dans le panneau de configuration, section « Réseau », cliquez sur l’onglet « Paramètres de DSM ». Ici, vous devez avoir le port 5000 assigné à la communication HTTP et le port 5001 assigné à la communication HTTPS. Cochez la case « Activer la connexion HTTPS » ainsi que la case « Rediriger automatiquement les connexions http vers HTTPS ». en cochant ces deux options, on active la sécurité de communications cryptées et on force la redirection des demandes non cryptées vers une route cryptée. On est ainsi sûrs que même en cas d’erreur, toutes les communications sont cryptées.
Accès depuis Internet sans IP fixe
Lorsque vous voudrez accéder à votre NAS depuis l’extérieur de votre réseau domestique, vous devrez connaitre l’adresse IP de votre modem ADSL. Cette IP, selon les fournisseurs d’accès, est susceptible de changer de façon variable (certains vont la faire changer toutes les 24h, d’autres tous les 2 mois…). Afin de vous éviter de devoir noter votre nouvelle IP tous les jours (d’autant plus qu’on ne sait pas exactement quand est prévu le changement dans la journée) Synology a prévu un service NO-IP qui permet de ne plus utiliser d’adresse IP mais plutôt un nom qu’il suffit de taper et alors vous accédez à votre NAS.
Le principe est simple : le NAS va vérifier régulièrement l’adresse IP publique de votre box. Si celle-ci change, le NAS va prévenir un serveur appartenant à Synology en lui indiquant quelle est la nouvelle IP et va alors l’enregistrer dans sa base de données. Lorsque vous entrez le nom que vous avez choisi pour accéder à votre NAS depuis n’importe quel appareil, vous communiquez avec le serveur appartenant à Synology qui, lui, va faire la correspondance entre le nom et votre nouvelle IP. Pour vous c’est totalement transparent, vous ne faites qu’appeler un nom, mais derrière, c’est toute la mécanique Synology qui s’occupe du reste.
Pour paramétrer ce service, rendez-vous dans le panneau de configuration du NAS puis cliquez sur Quick Connect. Activez l’option « Activez QuickConnect » et suivez la procédure standard accessible ici
Pensez lors de cette étape à activer les applications mobiles (clic sur le bouton « Avancé »)
N’oubliez pas d’activer les ports 5000 et 5001 de votre routeur ou de votre box afin de laisser passer les demandes effectuées depuis l’extérieur vers ces mêmes ports à l’adresse du NAS.
Création du compte utilisateur spécial caméras
Par principe, on évite toujours d’utiliser un compte administrateur dans des applications tierces. En effet, si quelqu’un met la main sur votre application tierce, il met également la main sur le compte utilisateur. Donc moins les droits sont élevés, mieux c’est… Autant ne pas donner un accès complet à toute personne malveillante.
Nous devons donc créer un nouvel utilisateur spécifique à cette application et lui donner les droits nécessaires pour gérer l’accès à l’application Surveillance Station. Pour cela, dans le panneau de configuration, rendez-vous dans « Utilisateur » puis cliquez sur le bouton Créer. Donnez-lui un nom (par exemple « Arduino ») et un mot de passe. Décochez la case « Envoyez un courrier de notification… » et cochez la case « Ne pas autoriser l’utilisateur à changer de mot de passe ». Validez. Laissez cet utilisateur dans le groupe « users » et uniquement ce groupe. Validez. Ne lui donnez aucun accès aux répertoires et ne lui mettez aucun quota. Au niveau de l’écran de paramétrage des applications, cochez refuser pour tout sauf pour « Surveillance Station » pour laquelle vous mettrez « Autoriser ». Finissez la procédure de création d’utilisateur. Vous avez désormais un utilisateur limité au seul usage de Surveillance Station.
Paramétrage des caméras dans surveillance Station
Assurez-vous tout d’abord que vos caméras sont bien disponibles sur le réseau par le biais de leur interface web constructeur (vous devez y avoir accès par le biais de leur adresse IP et d’un login/mot de passe fournis avec la caméra). Faites également le paramétrage de vos caméras IP individuellement pour remplacer les mots de passe fournis par défaut par les constructeurs qui sont en général « admin/admin » ou quelque chose du genre, ce qui n’est pas sécurisé du tout. Une fois que toutes vos caméras sont paramétrées et accessibles individuellement, nous allons passer au paramétrage dans le NAS Synology. Pour cela, rendez-vous dans votre menu Synology (en haut à gauche) et cliquez sur « Surveillance Station ». Un nouvel onglet s’ouvre dans votre navigateur.
Sur la partie gauche, vous avez tous les menus accessibles et en cliquant sur le menu « Caméra IP », vous aurez alors la partie centrale permettant de gérer votre parc de caméras. Cliquez sur le bouton « Ajouter » puis « Ajouter une caméra ». Dans la procédure guidée, restez en « réglages rapides » et validez. Renseignez alors le nom que vous souhaitez donner à la caméra puis, son adresse IP, la marque, le modèle, le nom d’utilisateur et le mot de passe. Vous devez alors voir l’image de votre caméra apparaitre. Si ce n’est pas le cas, revérifiez que vous avez accès à cette caméra par le biais de votre navigateur comme indiqué dans la notice de celle-ci. Vérifiez également sa compatibilité grâce au lien fourni en début d’article dans la section des prérequis matériels.
Ajoutez comme cela toutes vos caméras IP jusqu’à avoir votre parc complet.
Paramétrage d’un smartphone pour accéder aux caméras
Concernant la partie mobile, il faut s’appuyer sur l’application DS CAM disponible dans les stores android et iPhone. Installez l’application puis lorsqu’il vous demande de vous connecter, rentrez le quick connect ID que vous avez choisi lors de l’étape sur le paramétrage de l’accès au NAS depuis l’exterieur. Rentrez votre login personnel (n’utilisez pas le compte Arduino), votre mot de passe, et cochez les options « HTTPS » et « Se souvenir de moi ». Si, lors de votre connexion, votre application refuse de se connecter, il est probable que votre mobile refuse le certificat auto-signé (certificat qui n’émane pas d’une autorité connue donc l’appareil refoule directement la demande). Pour autoriser le certificat sur votre mobile, il faut aller dans le panneau de configuration du NAS, dans « Sécurité » puis onglet « Certificat ». Cliquer sur le bouton « Exporter le certificat », puis enregistrez le sur votre pc. Il faut maintenant vous envoyer ce certificat sur un email auquel vous avez accès depuis le client de messagerie de votre smartphone/tablette.
Depuis le smartphone, la tablette, ouvrez l’email et cliquez sur le certificat en pièce jointe. Votre mobile va vous proposer de l’installer dans le système d’exploitation, acceptez. Retentez alors de vous connecter à vos caméras depuis l’application DS Cam, il ne devrait plus y avoir de soucis.
.
Retour au sommaire.
– Deuxième partie –
|
.
Le principe de montage est très simple :
Un module Yokis va venir donner un état sur le PIN d’entrée du module Arduino. En fonction de cet état, on va envoyer des ordres au NAS au travers du shield ethernet. L’arduino donnera alors son état au travers d’une LED qui sera allumée si les caméras sont actives ou éteinte si les caméras sont inactives.
Schéma éléctrique :
.
Retour au sommaire
Le logiciel pour piloter le NAS |
.
Le principe de fonctionnement est très simple : l’arduino attend un état sur un PIN d’entrée. Lorsqu’on reçoit un changement d’état, on va aller chercher l’information sur le NAS pour savoir si la première caméra du lot est active ou non. On va ensuite envoyer l’ordre correspondant à l’inverse de l’état de la première caméra à toutes les caméras paramétrées. La communication entre la carte arduino et le NAS Synology se fait au travers du réseau via des requêtes http.
Principe des requêtes http
Lorsque vous entrez une adresse dans votre navigateur pour aller sur un site internet, votre navigateur communique avec un serveur. Celui-ci retourne alors le contenu de la page sous forme de code source HTML qui est interpreté par votre navigateur pour vous afficher le résultat.
Le principe de la communication avec le NAS est le même : Vous allez, au travers de l’arduino, faire un appel http comme si c’était votre navigateur. Il va alors communiquer avec le serveur qu’est le NAS Synology. Celui-ci renverra une réponse codée (au format JSON) que nous pourrons alors déchiffrer. Chaque adresse envoyée contiendra un certain nombre de paramètres qui feront que le NAS retournera des réponses différentes et agira d’une certaine manière avec les éléments qui l’entourent.
Code source
Il faudra remplacer les données suivantes dans le code source :
- adresses IP de l’arduino et du NAS
- Adresse MAC de l’arduino
- Login et mot de passe du compte Arduino
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 |
/* /* /* Programme Arduino de pilotage des caméras /* Surveillance Station /* /* /* RedOhm le 26/12/2014 /* Steeve /* /*---------------------------------------------------------------- INCLUSION DES LIBRAIRIES ----------------------------------------------------------------*/ #include <SPI.h> #include <w1500.h> #include <Dhcp.h> #include <Dns.h> #include <b64.h> #include <HttpClient.h> #include <Ethernet.h> #include <EthernetClient.h> #include <EthernetUdp.h> #include <util.h> #include <JsonGenerator.h> #include <JsonParser.h> #include <JsonObject.h> /*---------------------------------------------------------------- DECLARATION DES NAMESPACES ET SIGNATURES ----------------------------------------------------------------*/ using namespace ArduinoJson::Parser; JsonObject GetResponse(String kHostname, int port, String kPath); /*---------------------------------------------------------------- CONSTANTES ----------------------------------------------------------------*/ // Nombre de millisecondes sans recevoir de // donnée et avant d'abandonner la demande const int kNetworkTimeout = 30*1000; // Nombre de millisecondes pendant lesquelles // on doit attendre avant de retenter une requete const int kNetworkDelay = 1000; /*---------------------------------------------------------------- DECLARATION DES VARIABLES ----------------------------------------------------------------*/ //Adresse MAC du shield ethernet byte mac[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; //Adresse IP du shield ethernet IPAddress ip(192,168,0,1); //Adresse IP du NAS Synologue char UrlNasSyno[] = "192.168.1.2"; //Port par lequel on accède au Synology pour Surveillance Station int PortNasSyno = 5000; //PIN d'entrée pour l'état provenant du module Yokis int entreeContacteur = 22; //PIN de sortie permettant d'afficher l'état des caméras int sortieLed = 24; //Instance du client Ethernet EthernetClient client; //Etat courant (permet de savoir si on a les caméras actives ou inactives) int EtatCourant; //Variable contenant l'url d'appel du NAS Synology (variable dynamique //selon l'ordre à passer) String urlNasSynoStr; //indique si nous sommes en train d'envoyer tous les ordres pour passer d'un // état à un autre. Cette variable va servir de verrou pour eviter qu'on // puisse envoyer deux ordres quasi en même temps et finir avec un état ne //correspondant à rien. int connecting = 0; //Login et mot de passe du compte utilisateur créé //spécialement pour cette application sur le NAS String login = "Arduino"; String pwd = "password" /*---------------------------------------------------------------- MISE EN PLACE DE LA CARTE (SETUP) ----------------------------------------------------------------*/ void setup() { //On indique que pour le moment on est dans un état inactif (LOW) EtatCourant = LOW; //Mise en place de la communication de la carte Serial.begin(9600); //Mise en place des entrées / sorties pinMode(entreeContacteur, INPUT); pinMode(sortieLed, OUTPUT); //Mise en place de la carte Ethernet if (Ethernet.begin(mac) == 0) { Serial.println("Failed to configure Ethernet using DHCP"); Ethernet.begin(mac, ip); } urlNasSynoStr = UrlNasSyno; //On patiente une seconde delay(1000); } /*---------------------------------------------------------------- BOUCLE PRINCIPALE ----------------------------------------------------------------*/ void loop() { //On va chercher l'état de l'entrée Yokis int buttonState = digitalRead(entreeContacteur); //Si l'état de l'entrée est différent de l'état courant, on doit //alors changer l'état des caméras if(buttonState != EtatCourant && connecting ==0) { //On indique qu'on va effectuer une opération (qui peut //prendre du temps) connecting = 1; int compteur = 0; int HasChangedState = -1; //On va tenter d'activer ou désactiver la/les caméra(s). Si la //tentative échoue, on essayera en tout 3 fois avec un délai //de 3 secondes entre chaque tentative while(HasChangedState == -1 && compteur < 3) { compteur = compteur + 1; Serial.print("tentative "); Serial.println(compteur); if(ActiverDesactiverCameras(buttonState) == -1) { delay(3000); } else { HasChangedState = 1; } } //Si on a bien changé d'état, on met à jour l'état de sortie //pour la LED if(HasChangedState == 1) { digitalWrite(sortieLed, buttonState); HasChangedState = -1; } //On indique que maintenant l'état courant = l'état du bouton EtatCourant = buttonState; //Fin des opérations, on indique 0 dans la variable connecting connecting = 0; } delay(10); } /*---------------------------------------------------------------- ALLUMER/ETEINDRE CAMERAS ----------------------------------------------------------------*/ int ActiverDesactiverCameras(int active) { //On commence par afficher un message de debug indiquant si on allume //ou si on éteint la/les camera(s) if(active == 1) Serial.println("----------------------- ALLUMAGE CAMERA --------------------------"); else Serial.println("----------------------- EXTINCTION CAMERA --------------------------"); //On teste la connexion avec le NAS Serial.println("-------- TEST DE CONNEXION"); JsonObject infos = GetResponse(urlNasSynoStr, PortNasSyno, "/webapi/query.cgi?api=SYNO.API.Info&method=Query&version=1&query=SYNO.Auth"); //On récupère l'information (success) indiquant si tout est ok pour communiquer avec le NAS String infosSuccess = (char*)infos["success"]; //Selon l'état, soit on quitte la fonction avec un retour à -1, soit on continue if(infosSuccess != "true") { Serial.println("connexion au nas KO"); return -1; } Serial.println("connexion au nas OK"); delay(50); //Récupération des informations concernant l'API de surveillance station Serial.println("-------- RECUPERATION INFOS API SURVEILLANCE STATION INFO"); JsonObject surveillanceInfos = GetResponse(urlNasSynoStr, PortNasSyno, "/webapi/query.cgi?api=SYNO.API.Info&method=Query&version=1&query=SYNO.SurveillanceStation.Info"); //Validation du retour de l'appel HTTP String surveillanceInfosSuccess = (char*)surveillanceInfos["success"]; if(surveillanceInfosSuccess != "true") { Serial.println("recuperation infos API surveillance station KO"); return -1; } //A partir du résultat, on récupère le chemin d'accès à l'application surveillance //station (qui peut varier selon les modèles ou même changer dans le temps //avec les mises à jour Synology). Cela permet de ne pas avoir à modifier le code //source pour faire pointer les appels sur le nouveau chemin Serial.println("recuperation infos API surveillance station OK"); String surveillanceAPIpath = (char*)surveillanceInfos["data"]["SYNO.SurveillanceStation.Info"]["path"]; delay(50); //Récupération des infos API des caméras surveillance station Serial.println("-------- RECUPERATION INFOS API SURVEILLANCE STATION CAMERA"); JsonObject CameraAPIInfos = GetResponse(urlNasSynoStr, PortNasSyno, "/webapi/query.cgi?api=SYNO.API.Info&method=Query&version=1&query=SYNO.SurveillanceStation.Camera"); //Validation du retour de l'appel HTTP String CameraAPIInfosSuccess = (char*)CameraAPIInfos["success"]; if(CameraAPIInfosSuccess != "true") { Serial.println("recuperation infos API camera KO"); return -1; } //Récupération du chemin d'accès aux caméras Serial.println("recuperation infos API camera OK"); String cameraAPIpath = (char*)CameraAPIInfos["data"]["SYNO.SurveillanceStation.Camera"]["path"]; delay(50); //Création d'un session avec le NAS. On s'authentifie en tant qu'utilisateur //avec un login et un mot de passe Serial.println("-------- AUTHENTIFICATION"); JsonObject AuthInfos = GetResponse(urlNasSynoStr, PortNasSyno, "/webapi/auth.cgi?api=SYNO.API.Auth&method=Login&version=2&account=" + login + "&passwd=" + pwd + "&session=SurveillanceStation&format=sid"); String AuthInfosSuccess = (char*)AuthInfos["success"]; //Validation du retour de l'appel HTTP if(AuthInfosSuccess != "true") { Serial.println("authentification KO"); return -1; } //Récupération du sid (Session Identifier permettant de communiquer en sécurité avec le NAS) Serial.println("authentification OK"); String sid = (char*)AuthInfos["data"]["sid"]; delay(50); //Récupération de la liste de caméras disponibles Serial.println("-------- RECUPERATION DE LA LISTE DE CAMERAS"); JsonObject CameraListInfos = GetResponse(urlNasSynoStr, PortNasSyno, "/webapi/" + cameraAPIpath + "?api=SYNO.SurveillanceStation.Camera&method=List&version=1&_sid=" + sid); String CameraListSuccess = (char*)CameraListInfos["success"]; //Validation du retour de l'appel HTTP if(CameraListSuccess != "true") { Serial.println("recuperation liste cameras KO "); return -1; } //Récupération du tableau de caméras et traitement des informations les concernant Serial.println("recuperation liste cameras OK"); String listeCameras; JsonArray cameras = CameraListInfos["data"]["cameras"]; //Récupération du nombre de caméra int nbCameras = cameras.size(); Serial.print("Nombre de cameras : "); Serial.println(nbCameras); //Pour chaque caméra du tableau, on va concaténer son ID pour créer une chaine //de caractère composée comme ceci : "ID_CAMERA1,ID_CAMERA2,ID_CAMERA3..." for(int x = 0; x < nbCameras; x++) { if(x==0) { listeCameras = (char*)CameraListInfos["data"]["cameras"][x]["id"]; } else { listeCameras = listeCameras + ","; listeCameras = listeCameras + (char*)CameraListInfos["data"]["cameras"][x]["id"]; } } Serial.print("id des cameras detectees : "); Serial.println(listeCameras); delay(50); //On récupère l'action à envoyer en fonction de l'état matériel (PIN //d'entrée Yokis) dans lequel on se trouve String action; String actionPrintln; if(active == 1) { action = "Enable"; actionPrintln = "activation"; } else { action = "Disable"; actionPrintln = "desactivation"; } //On envoie l'ordre d'activer ou désactiver la liste de caméras complète Serial.println("-------- " + actionPrintln + " DE LA CAMERA"); JsonObject CameraEnable = GetResponse(urlNasSynoStr, PortNasSyno, "/webapi/" + cameraAPIpath + "?api=SYNO.SurveillanceStation.Camera&method=" + action + "&version=3&cameraIds=" + listeCameras + "&_sid=" + sid); //Vérification du retour de l'appel HTTP String CameraEnableSuccess = (char*)CameraEnable["success"]; if(CameraEnableSuccess != "true") { Serial.println(actionPrintln + " cameras KO"); return -1; } Serial.println(actionPrintln + " cameras OK"); delay(50); //On se déconnecte proprement du NAS en envoyant une requete de déconnexion Serial.println("-------- DECONNEXION"); JsonObject LougoutInfos = GetResponse(urlNasSynoStr, PortNasSyno, "/webapi/auth.cgi?api=SYNO.API.Auth&method=Logout&version=2&session=SurveillanceStation&_sid=" + sid); //On vérifie le retour de l'appel HTTP String LougoutInfosSuccess = (char*)LougoutInfos["success"]; if(LougoutInfosSuccess != "true") { Serial.println("Logout KO"); return -1; } Serial.println("Logout OK"); //On indique que c'est la fin de la procédure d'activation/désactivation if(active == 1) Serial.println("----------------------- FIN ALLUMAGE CAMERA --------------------------"); else Serial.println("----------------------- FIN EXTINCTION CAMERA --------------------------"); return 0; } /*---------------------------------------------------------------- OPERATIONS DE COMMUNICATION AVEC LE NAS ----------------------------------------------------------------*/ //Cette fonction permet d'envoyer une requete HTTP au NAS Synology et //retourne en résultat un objet utilisable qui correspond à la chaine //de caractères formatée JSON transformée en objet JsonObject GetResponse(String kHostname, int port, String kPath) { int err =0; String result = ""; //On créé les instances d'objets permettant de communiquer par le biais du réseau EthernetClient c; HttpClient http(c); //Récupération des tableaux de caractères correspondant à l'adresse //du NAS + requete HTTP à envoyer char charBufHost[kHostname.length()+1]; kHostname.toCharArray(charBufHost, kHostname.length()+1); char charBufPath[kPath.length()+1]; kPath.toCharArray(charBufPath, kPath.length()+1); //Envoi de la requete HTTP err = http.get(charBufHost, port, charBufPath, "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.0)"); if (err == 0) { //On récupère le statut de la requete HTTP (200 si ok, 404 si introuvable...) err = http.responseStatusCode(); if (err >= 0) { //On se déplace pour ne pas récupérer les entetes de la //réponse HTTP qui ne nous intéressent pas err = http.skipResponseHeaders(); if (err >= 0) { //On récupère le corps de la réponse int bodyLen = http.contentLength(); unsigned long timeoutStart = millis(); char c; //Tant qu'on est connecté ou qu'il y a encore des éléments à récupérer //et qu'on ne dépasse pas le timeout, on continue de lire la réponse while ( (http.connected() || http.available()) && ((millis() - timeoutStart) < kNetworkTimeout) ) { if (http.available()) { //On lit un caractère de la réponse c = http.read(); //On ajoute ce caractère au reste de la réponse déjà lue result = result + c; bodyLen--; timeoutStart = millis(); } else { delay(kNetworkDelay); } } } else { Serial.print("Impossible de passer les entetes HTTP : "); Serial.println(err); } } else { Serial.print("Impossible de récupérer la réponse : "); Serial.println(err); } } else { Serial.print("Connection impossible : "); Serial.println(err); } //On arrete le client HTTP http.stop(); //On supprime les 2 premiers caractères de la réponse qui ne servent à rien result = result.substring(2,result.length()); //On transforme le résultat en table de caractères char charBufResult[result.length()+1]; result.toCharArray(charBufResult, result.length()+1); //On utilise la librairie JSON Parser afin de découper la chaine de //caractères au format JSON en plusieurs objets utilisables. JsonParser<128> parser; JsonObject root = parser.parse(charBufResult); //On retourne le résultat sous forme d'objet JSON utilisable. return root; } |
Boitier imprimé en 3d
Afin de contenir tout le nécessaire, nous avons réalisé un boitier embarquant l’arduino, le module de reception Yokis et l’alimentation 12V. Ce boitier peut être vissé à un mur à l’aide des 3 ergots mis à disposition.
.
.
Télécharger : Boitier Surveillance Station.
Retour au sommaire.