aladec

Bonjour, Tout simplement parce que je dispose d'un Arduino Uno et que le but de ce post est de connecter un Uno au Syno par usb. Le Uno sert donc d'interface entre un signal d'alarme et l'activation des caméras de surveillance gérées sur le Syno par SurveillanceStation. Le Uno est connecté à 3 diodes led pour surveiller les différents états possibles, un interrupteur simple pour activer ou désactiver les caméras et un relais qui se ferme ou s'ouvre en fonction du branchement de l'alarme. Trois caméras sont gérées par SurveillanceStation, 3 caméras sont gérées directement par le script python et 1 caméra est gérée par ZoneMinder installé sur un Raspberry Pi 3 B. Le script Python qui réceptionne les commandes du Uno, gère donc l'activation de 7 caméras. Exemple de script en Python 3 de gestion des caméras (activer ou désactiver) 1 ou plusieurs caméras du Syno en fonction de la documentation de l'API SurveillanceStation version 9 avec DSM version 7. #!/usr/bin/env python import requests from urllib3.exceptions import InsecureRequestWarning IP_nas = '###.###.###.###' PORT_nas = '####' dsm_url = 'https://'+IP_nas+':'+PORT_nas username = '##########' password = '##########' num_camera = '#' # séparer par , si plusieurs caméras à activer ou désactiver # désactive warning pour certificat en https requests.packages.urllib3.disable_warnings(category=InsecureRequestWarning) params={"api":"SYNO.API.Auth","method":"login","version":"6","account":username,"passwd":password,"session":"SurveillanceStation","format":"sid"} rep=requests.get(dsm_url+"/webapi/auth.cgi",params=params,verify=False) obj=rep.json() #print (obj) sid = obj['data']['sid'] #print(sid) succes=obj['success'] #print (succes) if succes==True: print ("Entrée en session acceptée") else: print ("Entrée en session refusée") # active/désactive caméra "method":"Enable" ou "method":"Disable" # il est parfois nécessaire de changer la valeur de "version" en fonction de la documentation de l'API params={"api":"SYNO.SurveillanceStation.Camera","method":"Disable","version":"9","idList":num_camera,"_sid":sid} rep=requests.get(dsm_url+"/webapi/entry.cgi",params=params,verify=False) obj=rep.json() succes=obj['success'] #print (succes) if succes==True: print ("Caméra "+num_camera+" désactivée(s)") else: print ("Caméra "+num_camera+" impossible à désactiver") #Infos params={"api":"SYNO.SurveillanceStation.Info","method":"GetInfo","version":"7"} rep=requests.get(dsm_url+"/webapi/entry.cgi",params=params,verify=False) obj=rep.json() print (obj) #fin de session params={"api":"SYNO.API.Auth","method":"logout","version":"2","session":"SurveillanceStation","_sid":sid} rep=requests.get(dsm_url+"/webapi/auth.cgi",params=params,verify=False) obj=rep.json() succes=obj['success'] #print (obj) if succes==True: print ("Fin de session") else: print ("Fin de session impossible")

Bonjour, Je redécouvre ce sujet que j'avais publié en 2016. Merci à Chegui pour les avancées concernant la recherche des modules de connexion usb pour un Arduino Uno. J'utilise toujours le système entre un Syno et le Uno. Avec toutes les mises à jour sur le Syno (passage à Python 3), j'ai été obligé de rénover mes scripts. Je compte les publier dès que j'ai le temps.

Bonjour, Je découvre avec surprise une publication en mai 2019 concernant ce sujet. Nous sommes maintenant en janvier 2021 et le système fonctionne toujours suite à différentes adaptations. Il y a 3 caméras (1 licence supplémentaire) qui fonctionnent avec Surveillance Station. 2 caméras supplémentaires avec ZoneMinder sur Raspberry Pi3. 1 interface entre le système d'alarme et le Nas Synology réalisée avec un Arduino Uno qui déclenche un script sur le Nas lorsque le signal d'alarme est branché. La Synchro avec Google Drive n'est plus activée pour des raisons budgétaires. Lors du dernier cambriolage, nous avons pu fournir des vidéos de nos 2 voleurs qui ne sont pas restés très longtemps.

Bonjour, Je constate aussi que cette maj a effectué un grand nettoyage ... Obligation de réinstaller une librairie Python 2 et tout ce qui concerne les anciens ipkg a été liquidé. Certaines tâches planifiées semblent ne plus fonctionner.

Bonjour, Pour éviter une perte de temps en recherche sur la façon de connecter un Arduino Uno à un Nas Synology, voici la façon de procéder : Testé sur un Nas Synology (DS115j - DSM 6.0.2-8451 Update 5 - le 11/12/2016) et un Arduino Uno R3 L'Arduino Uno est considéré comme un périphérique ttyACM. Sur le Nas, il est nécessaire de créer un nœud et de charger en mémoire un module (cdc-acm.ko présent dans /lib/modules). On se connecte en ssh (via Putty.exe sous Windows 10) en tant qu'administrateur et on passe en Root via sudo -i. On charge le module en mémoire par la commande insmod /lib/modules/cdc-acm.ko On crée le nœud par la commande mknod /dev/ttyACM0 C 166 0 On vérifie que le module est bien en mémoire par la commande lsmod Pour communiquer via la connexion usb (une communication série), on doit mettre en place un script bash ou un script Python qui permettra de lire et de transmettre (écrire) les données sur ce port. Avant de passer à cette étape, il est nécessaire d'automatiser le chargement en mémoire du module cdc-acm.ko et de vérifier si le nœud /dev/ttyACM0 existe. On réalise donc un script bash qui sera exécuté lors du boot du Nas. (je ne suis pas l'auteur de ce script, j'ai réalisé quelques adaptations mineures). Il est nécessaire de créer un dossier /volume1/logs pour le fichier modules.log. Le nom du script S50modules.sh avec le paramètre start ou stop est à enregistrer dans un dossier prévu à cet effet. Il ne faut pas oublier de donner les droits d'exécution à ce script. Pour l'exécuter lors du boot, on place dans le fichier /etc/rc.local une ligne de commande qui pointe vers ce script. Il vaut mieux de placer cette ligne avec une certaine priorité par rapport à d'autres lignes présentent dans ce fichier. sh [chemin vers ce script]/S50modules.sh start Code du script S50modules.sh : #!/bin/sh MODULES_DIR="/lib/modules" MAINMODULE="cdc-acm.ko" heure=$(date +%Hh-%Mmin) jour=$(date +%d-%m-%Y) start_modules(){ echo "--- Charge le module en mémoire ---" echo "Le module cdc-acm.ko est chargé à $heure, le $jour" >> "/volume1/logs/module.log" for i in $MAINMODULE; do echo "Chargement de $i" insmod $MODULES_DIR/$i done sleep 1 # Create the ttyACM0 if [ ! -c /dev/ttyACM0 ]; then echo "Création de /dev/ttyACM0" echo "Le noeud /dev/ttyACM0 est créé à $heure, le $jour" >> "/volume1/logs/module.log" mknod /dev/ttyACM0 c 166 0 fi sleep 1 stty -F /dev/ttyACM0 cs8 115200 ignbrk -brkint -icrnl -imaxbel -opost -onlcr -isig -icanon -iexten -echo -echoe -echok -echoctl -echoke noflsh -ixon -crtscts sleep 1 } stop_modules(){ echo "--- Décharge le module de la mémoire ---" echo "Le module cdc-acm.ko est déchargé à $heure, le $jour" >> "/volume1/logs/module.log" for i in $MAINMODULE; do echo "Décharge $i" rmmod $MODULES_DIR/$i done # supprime le ttyACM0 if [ -c /dev/ttyACM0 ]; then echo "Le noeud /dev/ttyACM0 est supprimé à $heure, le $jour" >> "/volume1/logs/module.log" echo "/dev/ttyACM0 est supprimé" rm /dev/ttyACM0 fi sleep 1 } case ${1:-start} in start) start_modules ;; stop) stop_modules ;; *) echo "usage: $0 { start | stop }" >&2 exit 1 ;; esac La suite consiste à tester la communication entre un script sur l'Arduino et un script sur le Nas. On aura besoin de remplacer le Nas par un pc tournant sous Linux et de connecter l'Arduino Uno à cette machine via ttyACM afin de procéder au développement des scripts. En effet, le Nas est considéré comme une machine de production et on ne dispose pas de l'IDE Arduino qui permet la réalisation des sketchs (scripts). Lorsque les tests seront concluants, on migrera les scripts vers le Nas. Pour ma part, j'utilise une version Ubuntu 16.04 LTS, présente sur un disque usb. L'avantage est de disposer du paquet Arduino qu'il suffit d'installer via un terminal. sudo apt-get install arduino On dispose alors de l'IDE Arduino qui permet la réalisation des sketchs. Avant la 1ère utilisation, un reboot est nécessaire pour la mise en place. L'Arduino Uno est connecté sur un port usb (en ttyACM0). Le module cdc_acm est chargé automatiquement en mémoire sur Ubuntu. Pour vérifier : lsmod | grep cdc_acm Au niveau des scripts qui seront placés sur le Nas, il faut choisir entre Bash et Python afin de gérer les données sur le /dev/ttyACM0. Sur le Nas, il est possible d'installer le paquet Python 2.7.12. Sur le pc Ubuntu, on dispose aussi de la version Python 2.7.12 . Je choisis donc Python bien que je sois un néophyte de ce langage. Les scripts seront simples à développer. A partir du moment où on sait gérer les communications entre l'Arduino Uno et le Nas via le port usb (port série), plusieurs projets seront possibles éventuellement en domotique. L'inconvénient est la distance entre le Nas et l'Arduino Uno qui dépend de la longueur du câble usb. L'Arduino Uno est également alimenté via cette liaison (une autre possibilité existe). Exemple : l'Arduino Uno servira d'interface entre mon système d'alarme et les caméras de surveillance gérées via Surveillance Station présent sur le Nas. J'ai déjà réalisé ce projet mais en utilisant un Arduino Yun doté d'une liaison Ethernet qui communique via le réseau interne avec le Nas (protocole TCP/IP). Je trouve dommage d'utiliser un Arduino Yun pour ce genre de projet, de plus le Yun est connecté au Nas par usb afin d'être alimenté. Je vais donc tenter de remplacer le Yun par le Uno (3 x moins cher) et communiquer via la connexion usb. Réalisation du script Python chargé sur le Nas et responsable de la gestion des données envoyées par l'Arduino sur le port usb (série) : Avant de programmer, on récupère la librairie "pyserial-master.zip". Cette archive est décompressée dans un dossier du Nas prévu dans /volume1 (on peut le faire sous Windows). On se connecte au Syno en ssh via Putty.exe et on installe cette librairie qui permettra de gérer le port usb du Nas. Pour l'installation, on se déplace dans le dossier "pyserial-master" et on exécute le fichier "setup.py" par la commande python setup.py install - (la librairie est alors disponible pour Python 2.7.12) Le script devra réagir en fonction des données en provenance de l'Arduino Uno. Il y aura 5 données possibles '0', '1', '2', '3' ou '' (vide - pas de donnée). Chaque donnée correspond à une action précise exécutée par un script Bash (déjà opérationnel). Voici le code (attention aux indentations ! Python oblige ...) : #!/usr/bin/env python # -*-coding:UTF-8 -* import subprocess import serial import time import serial.tools.list_ports import sys import os ################# Les fonctions ################################################### def serial_ports(vid_pid): # recherche du port sur lequel se trouve Arduino Uno identifié par son VID:PID portList = list(serial.tools.list_ports.comports()) for info in portList: #print(info[2]) if (vid_pid in info[2]): #print(info[2]) #print "retourne : " + info[0] return info[0] return False def verif_connexion(device): #verification du port de connexion avec Arduino try: print "Tentative de connexion à ..." + device arduino_usb = serial.Serial(device, 9600,timeout=None) # attention aux réglages avec l'Arduino ! Le timeout=None est obligatoire pour rester à l'écoute sur le port print "La connexion est établie avec " + arduino_usb.name #print arduino_usb return(arduino_usb) except: print "La connexion a échoué sur " + device return False def connexion_usb(arduino_usb,boo_shell): chemin_bash="" # variable à introduire !!! while (True): print "En attente ..." arduino_usb.inWaiting() # s'utilise si le timeout=None !!! - écoute infinie sur le port usb en attente de données reçues reception = arduino_usb.read(size=1) print "Réception de : '" + reception +"'" if (reception == '0'): print "L'Arduino demande un arrêt des caméras" subprocess.call(chemin_bash, shell=boo_shell) info_cameras = "Les caméras sont arrêtées" if (reception == '1'): print "L'Arduino demande un démarrage des caméras" subprocess.call(chemin_bash, shell=boo_shell) info_cameras = "Les caméras sont activées" if (reception == '2'): print "L'Arduino a détecté un déclenchement d'alarme" subprocess.call(chemin_bash, shell=boo_shell) info_cameras = "Le signal d'alarme est déclenché" if (reception == '3'): print "L'Arduino demande une vérification des enregistrements vidéos" subprocess.call(chemin_bash, shell=boo_shell) info_cameras = "Vérification des enregistrements vidéos" # renvoi vers arduino print "Le Syno envoie '"+reception+"'" arduino_usb.write(reception) print info_cameras time.sleep(2) arduino_usb.flushInput() arduino_usb.flushOutput() print "Reprise de l'écoute sur " + arduino_usb.name return ########################################################################################### # Ossature du script - boucle principale de lancement # ########################################################################################### if __name__ == '__main__': # Introduire la valeur du VID:PID de l'Arduino (commande lsusb pour l'obtenir) # Attention à la casse, les lettres doivent être en majuscules !!! vid_pid="VID:PID=....:...." # variable à introduire !!! # enregistre le pid de ce processus dans un fichier afin de pouvoir l'arrêter #print os.getpid() chemin="" # variable à introduire !!! fichier_pid=open(chemin+"arduino_usb.pid","w") fichier_pid.write(str(os.getpid())) fichier_pid.close() tentative=1 while True: print "Récupération des données en provenance de l'Arduino avec " + vid_pid if (serial_ports(vid_pid) != False): device = serial_ports(vid_pid) connecte=True else: connecte=False if (tentative > 5): print "Le nombre de tentatives est dépassé - FIN" sys.exit(0) print "L'Arduino n'est pas connecté !" print str(tentative) + " - Tentative de reconnection dans 30 secondes (maximum de tentatives = 5)" time.sleep(30) tentative+=1 while connecte: try: if (verif_connexion(device).is_open == True): connexion_usb(verif_connexion(device), True) except: print "connexion interrompue" print "Attente de 5 secondes avant de reprendre l'écoute sur le port" time.sleep(5) tentative=1 connecte=False # nom du script : "arduino_usb.py" (se lance en tâche de fond comme un service via "script bash start/stop à réaliser !") sys.exit(0) Remarques : Le script est enregistré sous le nom "arduino_usb.py" et se lance (pour les tests) via une session Putty.exe sous Windows, par la commande python usb_arduino.py Il tourne dans une boucle infinie et lors d'une déconnexion de l'Arduino, il tente de se reconnecter, après 5 tentatives espacées de 30 secondes, il s'arrête. Il serait également nécessaire de vérifier si le périphérique connecté est bien l'Arduino Uno. (On utilise le VID:PID de l'Arduino) En utilisation réelle (après les tests), il faudra démarrer ce script au boot du Syno.(On peut tester avec le planificateur de tâches du Syno - exécuter "à la main" le script) Réalisation du sketch à placer sur l'Arduino Uno pour tester la connexion avec le Syno. La fonction suivante est à placer dans le sketch afin de se connecter // fonction appelée pour connexion au syno, renvoie true si la connexion est ok // la variable cas peut prendre les valeurs '0', '1', '2' ou '3' boolean connexion_syno(char cas) { boolean reponse = true; while(reponse) { Serial.print(cas);// écrit la valeur de cas sur le port série (usb) delay(1000);// attente 1 seconde // attente de la réponse du Syno : // vérifie si présence dans le tampon série if (Serial.available() > 0) { if (Serial.read() == cas) // réponse du syno qui renvoi la valeur de cas { reponse=false;// passe à false pour sortir de la boucle while } } } return true;// renvoi true } L'appel de cette fonction s'effectue dans la boucle principale void loop() par if (connexion_syno('3') == true) // ici cas='3' { ...... } Il s'agit ici d'un exemple où l'Arduino Uno pilote le Syno via une connexion usb (série). On peut évidemment envisager l'inverse. Après quelques tests (Arduino connecté au Syno par usb) sur la durée, j'ai remarqué une demande intempestive du démarrage des caméras. Cela provient certainement d'une certaine instabilité de la connexion, il suffit de recevoir '1' pour démarrer. J'ai donc modifié les 2 scripts de gestion sur le Syno et l'Arduino afin d'envoyer des chaînes de commande entre les 2 machines. Actuellement (30/12/2016), je suis en période de test.

tel_linphone.zip Voir le fichier Décompresser l'archive zip -> tel_linphone.sh (script bash) - Les informations suivantes sont reprises dans les commentaires du fichier tel_linphone.sh Commentaires et explications : nom du script : tel_linphone.sh (on peut le changer) adaptation du script trouvé sur http://martinverges.blogspot.be/ un grand MERCI se lance en ligne de commande via Putty.exe sous Windows : sh tel_alarme.sh paramètre_1 le paramètre_1 n'est pas obligatoire -> voir plus loin objectifs de ce script : composer un numéro de téléphone et entrer en communication audio avec son correspondant ou composer automatiquement des appels vers un chaîne de numéros afin de diffuser un message enregistré dans un fichier.wav (message d'alarme par exemple) la possibilité de répondre à un appel n'est pas encore possible ! la possibilité répondeur avec message enregistré n'est pas encore possible ! matériel de test : Synology DS115j Marvell Armada 370 88F6707 avec DSM 5.2 - 5644 update 3 (le 13/02/2016) pas obligatoire : carte son Terratec Aureon Dual USB sur le Synology avec casque micro raccordés Routeur "Fritz!Box 7390" avec "Fritz!Os 06.30" comme serveur sip Modem/routeur Netgear Voo en Bridge - téléphonie gérée par Fritz!box -> sortie téléphone analogique -> entrée sur prise téléphonique du Voo/Netgear (utilisation de Voo pour les communcations téléphoniques vers l'extérieur) actuellement pas d'abonnement sur serveur Sip extérieur Voo est un cablo-distributeur (Tv, téléphone, Internet en Belgique - Wallonie) prérequis : ipkg sur le synology - paquet Linphone fournit par ipkg il est nécessaire d'installer ipkg pour le syno (installation manuelle car pas de "bootstrap" pour le DS115j) http://blog.nouveauxterritoires.fr/fr/2014/04/23/installer-la-commande-ipkg-sur-un-nas-synology-recent/ en cas de problème avec ipkg (error while loading shared libraries: libidn.so.11) -> 2 commandes à exécuter cp /usr/syno/bin/wget /opt/bin/ ipkg update; ipkg upgrade réparer l'install de ipkg en cas de mise à jour de DSM http://korben.info/ipkg-not-found-voici-comment-reparer-linstall-dipkg-sur-votre-nas-synology.html installer le paquet Linphone 3.3.2-1 fourni par ipkg (ipkg install linphone) le processus (daemon) "linphonecsh" est alors disponible en ligne de commande (un reboot du Syno est nécessaire) linphonec et linphonecsh se touvent dans le répertoire /opt/bin placer ce script bash dans un répertoire et lui donner les droits d'exécution compléter les valeurs à introduire -> voir plus bas enregistrer un fichier wav avec un message et placer ce fichier dans un répertoire (droit de lecture) [EDIT du 20/02/2016] Lors de l'appel en boucle, il est parfois nécessaire de procéder à certaines adaptations du script. Appel sur un gsm, après 8 secondes de sonnerie, la communication est considérée comme établie même si le correspondant n'a pas décroché. (le serveur du FAI, enregistre l'appel en absence pour éventuellement prévenir (plus tard) le correspondant si celui-ci ne décroche pas) Dans le script, il faut supprimer la condition qui vérifie le décrochage par le correspondant et placer une durée pour la diffusion du message. Si vous rencontrez ce problème, je peux fournir le code adapté. Contributeur aladec Soumis 14/02/2016 Catégorie Créations de nos membres

Bonjour, Actuellement le script qui active les caméras et réalise des archives zip synchronisées avec Google Drive me donne entière satisfaction. Il est dommage que pour que ce script s'exécute toutes les 5 minutes, il soit nécessaire d'allumer un ordinateur et de se connecter au Syno afin de déclencher la tâche "cron" via le "planificateur de tâches". Il faut ensuite brancher le signal d'alarme qui est indépendant du système. Pour stopper, il faut effectuer les opérations en sens inverse. J'ai remarqué que pour de courtes absences, la procédure de mise en activité des caméras n'était pas exécutée car il faut trop de temps pour la mise en œuvre. De plus lorsque la maison est occupée, le signal d'alarme est branché durant la nuit mais en général les caméras ne sont pas activées. Pour remédier à ces problèmes, il faut donc interagir entre la centrale d'alarme et le Syno. - lorsque le signal d'alarme est branché, les caméras sont activées automatiquement via le Syno. Il faut donc trouver le chaînon manquant entre la centrale d'alarme et le Syno. Je propose de tester avec un micro-ordinateur "Arduino Yun" Un relai se ferme lorsque le signal d'alarme est branché (relai 12v alimenté par la centrale d'alarme). L'Arduino reçoit l'information de la part du circuit de relai comme un interrupteur ouvert ou fermé. L'Arduino devra transmettre au Syno via le réseau ethernet l'information reçue. Relai fermé = démarrage des caméras et toutes les 5 minutes, vérifier s'il y a des enregistrements. Relai ouvert = ne fait rien ou arrête les caméras et la vérification des enregistrements. Relai ouvert/fermé rapidement = déclenchement du signal d'alarme Cela nécessite sur le Syno de faire tourner un serveur à l'écoute de l'Arduino Yun - Ok avec netcat en bash C'est l'Arduino qui donne l'ordre au Syno de démarrer ou d'arrêter les caméras en fonction de l'état du relai. Toutes les 3 minutes, lorsque les caméras fonctionnent, une vérification d'enregistrement est demandée au Syno (synchro avec Google drive) Lorsqu'il y a un déclenchement d'alarme, l'arduino demande au Syno de réaliser des appels téléphoniques automatiques avec message enregistrés au format wav. [EDIT du 17/02/2016] concernant le script de la page 1 de ce post dans lequel la commande "awk" est utilisée. Suite à une maj du Syno, la commande "awk" (fichier awk) se trouve maintenant dans /usr/bin donc dans le script il faut changer "awk" par "/usr/bin/awk" . Sans ce changement, le script fonctionne toujours mais les statuts de "CloudSync" ne sont plus valables. [EDIT du 05/04/2016] Attention suite au passage à la DSM 6, les scripts précédents ne fonctionnent plus entièrement. Une adaptation sera nécessaire. Du travail en perspective ...

Bonjour, Suite à une mise à jour de Surveillance Station, les caméras dont l'enregistrement était au format .avi, changent de format et passent en .mp4 Il faut donc adapter le script si c'est nécessaire. A+

Bonjour, Le fait d'utiliser des caméras de cette manière en prenant le risque que le cambrioleur coupe l'alimentation électrique n'est pas une solution à écarter. J'ai été victime de 5 cambriolages sur 30 ans et les cambrioleurs n'ont jamais coupé l'alimentation électrique. (ce ne sont pas des "pros"). De plus le système d'alarme est pourvu d'une alimentation de secours sur batterie avec appel téléphonique en cas d'intrusion. Lors du dernier cambriolage, j'ai été averti par l'appel téléphonique automatique et je me suis connecté à la seule caméra que je possédais à l'époque (il y à maintenant 1an1/2). J'ai constaté qu'une porte était ouverte et donc qu'il ne s'agissait pas d'une alarme intempestive. Les caméras apportent donc un plus. Elles sont maintenant au nombre de 3 avec un enregistrement vidéo des zones de surveillance. Elles constituent aussi un outil de dissuasion. On pourra toujours discuter sur la qualité de protection en tenant compte du rapport qualité/prix du système utilisé. A chacun de choisir et de s'adapter en fonction de son expérience. Revenons au véritable sujet de ce post et limitons aux solutions proposées.

Bonjour, Et si on actualise la page du navigateur ?

Bonjour, Content que cela fonctionne avec Hubic. Pour enlever le doute, pourriez-vous tester de la même façon avec Google Drive et donner le résultat du test ? Merci d'avance.

Bonjour, Pour le kill "-19" "12897", il faudrait vérifier avant de tester cette commande si le processus 12897 est bien présent dans la liste des processus (commande ps en ligne de commande dans la console Putty pour obtenir la liste). Il est évident que si le processus de Cloud Sync n'est pas présent, il sera impossible de le "geler". Comment se comporte CloudSync avec ces modifications ? La synchro avec Google Drive est-elle correcte ? J'ai testé sur mon Syno (sans enregistrer de vidéos avec Surveillance Station) et cela fonctionnait correctement. Il faudra passer à l'étape suivante si cela va bien (faire fonctionner rsync lors d'un enregistrement vidéo)

Bonjour, Je propose dans un premier temps d'effectuer le changement suivant : créer un sous-répertoire dans le dossier partagé "surveillancebis" avec comme nom "clone". Modifier la commande rsync pour pointer sur le sous-répertoire "clone" et s'assurer que le propriétaire de "clone" est "admin" et le groupe "users". Le répertoire de synchronisation utilisé par CloudSync est "surveillancebis" dans lequel il y a "clone". Voici la commande qui pointe sur "clone" comme destination. rsync -azur --delete-after --log-file="rsync.log" /volume1/surveillance/ /volume1/surveillancebis/clone Pour être certain que les modifications seront prises en compte par CloudSync, redémarrer le Syno. Entrer en session "admin" et vérifier que CloudSync est actif (voir l'icône verte). Via Putty.exe, exécuter le script pour que rsync synchronise le répertoire "surveillance" avec "surveillancebis/clone". (ne pas effectuer d'enregistrement vidéo dans "surveillance" à ce moment) Observer le comportement de CloudSync. Quelques commandes concernant CloudSync qui pourraient servir : #!/bin/sh # récupère la valeur du PID de Cloud Sync dans le fichier syno-cloud-syncd.pid if [ -f /var/run/syno-cloud-syncd.pid ] ; then PID_cloud_sync=`head -1 /var/run/syno-cloud-syncd.pid` fi echo "le pid de CloudSync = $PID_cloud_sync" exit En ligne de commande dans Putty.exe, exécuter la commande ps pour visionner les processus actifs. Repérer le processus de CloudSync (avec le pid). Ce processus est : /var/packages/CloudSync/target/sbin/syno-cloud-syncd /volume1/@cloudsync/config/daemon.conf <<<< commande pour relancer le processus CloudSync On pourra utiliser cette commande pour relancer le processus de CloudSync si on "tue" celui-ci avec kill (sans devoir redémarrer le Syno) Pour tuer le processus : kill "-9" "$PID_cloud_sync" -> relancer avec /var/packages/CloudSync/target/sbin/syno-cloud-syncd /volume1/@cloudsync/config/daemon.conf Pour geler le processus : kill "-19" "$PID_cloud_sync" -> dégeler avec kill "-18" "$PID_cloud_sync"

Bonjour, Merci pour les infos. Pour la synchro, je n'avais pas remarqué ce problème avec l'utilisation de la commande rsync. Il y a, semble-t-il, un problème avec le processus de CloudSync. Il faudrait tenter un redémarrage du Syno et voir si le problème se reproduit. Il est vrai que je n'ai pas testé très longtemps cette possibilité et que j'ai adopté le script qui me construit des archives zip synchronisées avec Google Drive. Si vous optez pour cette solution, il faudra adapter le script en tenant compte qu'il n'y a qu'une caméra et que les enregistrements sont au format mp4.

Re re bonjour, Ok parfait, bonne idée d'éteindre les diodes du Nas, on pourrait le faire lorsque les caméras sont en surveillance et allumer lorsque la surveillance est terminée. Les codes sont d'après mes recherches : pour éteindre echo 67B > /dev/ttyS1 et pour allumer echo 58A > /dev/ttyS1 Pouvez-vous confirmer ? Je ne sais pas tester car je suis actuellement en déplacement. En ce qui concerne la marque des caméras, on ne boxe pas dans la même catégorie ! (j'ai 3 Foscam ...) Je suppose que le format vidéo d'enregistrement est du mp4 ?

Ré bonjour, Il suffit d'utiliser le petit script utilisant rsync . Copier/coller les lignes du script dans un éditeur de texte comme notepad++. Enregistrer le script dans un répertoire du synology (video_rsync.sh). Vérifier avec putty si le script fonctionne correctement. Il y parfois des caractères spéciaux qui doivent être supprimés comme ^M et qui sont responsables du non fonctionnement. Si c'est le cas, via putty, ouvrir le script dans l'éditeur de texte vi et supprimer ces caractères et enregistrer. On peut alors lancer le script via le planificateur de tâches du synology, en utilisant script créé par l'utilisateur. Il faut indiquer le chemin absolu vers le script (/volume1/emplacementscript/video_rsync.sh )

Bonjour, Vous arrivez donc aux mêmes constatations. La technique de cloner le répertoire "surveillance" et de synchroniser avec Google Drive ou One Drive ne fonctionne pas correctement par contre cela fonctionne avec Dropbox. Le problème alors est que Dropbox n'offre que 2 Go gratuits par rapport à 15 Go sur Google Drive. A rappeler que j'avais utilisé une application Dropbox (Synobox) qui permettait de synchroniser directement le dossier "surveillance" avec la Dropbox (sans cloner). Il faut donc faire un choix. Soit utiliser Dropbox avec seulement 2 Go et une solution technique simple de mise en œuvre, soit utiliser Google Drive avec une solution plus compliquée de mise en œuvre. Pour ne pas compliquer trop, j'utilise Putty sous Win10. Vous pouvez tester un des scripts au début de ce post qui utilise rsync (publié le 2 septembre) afin de vous faire la main avec Putty ensuite lancer une tâche planifiée en utilisant le planificateur de tâches du Syno. J'utilise depuis 1 mois le script qui me permet de réaliser des archives zip (un peu plus compliqué) et je trouve que cette technique est une bonne solution. J'ai amélioré le script afin de piloter la 3me caméra qui n'est pas gérée par Surveillance Station. A noter qu'avec les améliorations, lors d'un arrêt de la surveillance, les 3 caméras s'orientent maintenant vers des zones de vues blanches (les plafonds) et que lors de la reprise de surveillance, elles se repositionnent vers les zones définies. Vous disposez de combien de caméras et quelle est leur marque ?

Bonjour, En gros, j'avais constaté les mêmes symptômes et je me suis donc tourné vers une autre solution (voir les posts précédents)

Bonjour, J'avais déjà testé cette solution (voir un de mes posts précédents du 21 août 2015) mais ce n'était pas concluant. Donc, pouvez-vous confirmer que la réception dans Google Drive fonctionne correctement car dans mon cas, j'obtenais des vidéos corrompues. (voir le post pour plus de détails). Merci d'avance.

Bonjour, Pour les propriétaires d'une caméra Foscam FI8918W, un petit script bash qui permet d'activer ou de désactiver l'alarme de mouvement avec prise de photos envoyées par FTP. Il est possible de fusionner ce script avec le précédent de façon à gérer 2 caméras avec Surveillance Station + 1 caméra avec photos prises sur mouvement et uploadées par FTP. #!/bin/sh # script destiné à une caméra FOSCAM FI8918W - activation de la prise de photo en cas de mouvement ou désactivaton # les photos sont uploadées vers FTP # Attention ! une adaptation du script est nécessaire pour d'autres modèles de caméras cd "$PWD/" # se place dans le dossier d'emplacement du script SERVER="xxx.xxx.xxx.xxx:xxxx" # à introduire adresse IP:PORT exemple : 192.168.0.21:7777 USER="xxxxxxxxx" # à introduire PASS="xxxxxxxxx" # à introduire camera="xxxxxxxxxxxx" # à introduire - nom de la caméra statuts_cameras_photos() { # statuts de l'alarme cameras photos ? statut=$(wget -qO - "http://${SERVER}/get_params.cgi?user=${USER}&pwd=${PASS}") stat="est activée" if echo "$statut" | grep 'var alarm_motion_armed=0' >/dev/null 2>&1 ; then stat="n'est pas activée" ; fi } demarre_cameras_photo() { # démarre alarme photo sur caméra # la sensibilité est réglée sur 5 - l'intervalle entre 2 photos est de 10 s - les photos seront uploadées par ftp wget -qO- 2> /dev/null "http://${SERVER}/set_alarm.cgi?user=${USER}&pwd=${PASS}&next_url=alarm.htm&motion_armed=1&motion_sensitivity=5&motion_compensation=0&sounddetect_armed=0&sounddetect_sensitivity=0&iolinkage=0&mail=0&upload_interval=10&schedule_enable=0&schedule_sun_0=0&schedule_sun_1=0&schedule_sun_2=0&schedule_mon_0=0&schedule_mon_1=0&schedule_mon_2=0&schedule_tue_0=0&schedule_tue_1=0&schedule_tue_2=0&schedule_wed_0=0&schedule_wed_1=0&schedule_wed_2=0&schedule_thu_0=0&schedule_thu_1=0&schedule_thu_2=0&schedule_fri_0=0&schedule_fri_1=0&schedule_fri_2=0&schedule_sat_0=0&schedule_sat_1=0&schedule_sat_2=0" > /dev/null 2>&1 } arrete_cameras_photo(){ # arrête alarme photo sur caméra # remet tous les paramètres à 0 wget -qO- 2> /dev/null "http://${SERVER}/set_alarm.cgi?user=${USER}&pwd=${PASS}&next_url=alarm.htm&motion_armed=0&motion_sensitivity=0&motion_compensation=0&sounddetect_armed=0&sounddetect_sensitivity=0&iolinkage=0&mail=0&upload_interval=10&schedule_enable=0&schedule_sun_0=0&schedule_sun_1=0&schedule_sun_2=0&schedule_mon_0=0&schedule_mon_1=0&schedule_mon_2=0&schedule_tue_0=0&schedule_tue_1=0&schedule_tue_2=0&schedule_wed_0=0&schedule_wed_1=0&schedule_wed_2=0&schedule_thu_0=0&schedule_thu_1=0&schedule_thu_2=0&schedule_fri_0=0&schedule_fri_1=0&schedule_fri_2=0&schedule_sat_0=0&schedule_sat_1=0&schedule_sat_2=0" > /dev/null 2>&1 } ####################### gestion de l'alarme sur mouvement d'une caméra -> photo envoyée par FTP ###################### statuts_cameras_photos # vérifie si alarme est activée ou non echo "Statut caméra : l'alarme photo de la $camera $stat" ########## en fonction du paramètre, active l'alarme ou la désactive ########## $1=1 -> active alarme si pas activée if [ "$1" = "1" ] && [ "$stat" = "n'est pas activée" ] ; then demarre_cameras_photo echo "Action -> l'alarme photo de la $camera est activée" fi ######### $1=2 -> désactive alarme si pas désactivé if [ "$1" = "2" ] && [ "$stat" = "est activée" ] ; then arrete_cameras_photo echo "Action -> l'alarme photo de la $camera est arrêtée" fi ##################################################################################################################### # nom du script : check_foscam.sh # admet 1 paramètre # 1 - pour activer l'alarme # 2 - pour désactiver l'alarme # exemple : sh check_foscam.sh 1 # exemple : sh check_foscam.sh 2 # exemple : sh check_foscam.sh (sans paramètre) -> donne simplement le statut de l'alarme

Bonjour, Je viens de placer le code du script bash qui permet de créer des archives zip des vidéos enregistrées par Surveillance Station. Ces archives sont placées dans un dossier synchronisé avec Google Drive. Je déclenche ce script en tâche programmée (chaque 5 minutes) sur le Synology. J'ai effectué des tests pendant 4 jours et cela paraît concluant. Pour la mise en place : Copier le script dans un emplacement dédié sur le Synology (/volume1/emplacementscript/) Créer un dossier pour recevoir les archives zip (/volume1/surveillancebis/) Effectuer les adaptations dans le script en fonction des noms de dossier et des noms de caméra Tester en se connectant en ssh avec Putty.exe sous Windows (pour afficher les erreurs à l'écran commenter les lignes chargées de réorienter les erreurs vers un fichier) Se placer dans le répertoire du script et le lancer avec la commande suivante : sh video_rsync.sh (on peut ajouter des paramètres -> voir les explications dans le script) Les tests ont été effectués avec 2 caméras ( intéressant d'avoir les tests avec 1 ou 3 caméras ...) Attention les fichiers vidéos enregistrés par la 1ère caméra sont au format mp4 et ceux de la 2ème caméra sont au format avi. Une adaptation est éventuellement nécessaire au niveau du script. Si le script ne se lance pas, vérifier les droits en exécution. (se placer dans le répertoire du script et exécuter la commande : chmod +x video_rsync.sh) En espérant qu'il n'y aura pas trop de problèmes ... Merci d'avance pour les retours qui me permettront d'améliorer le script. Si tout est ok, on peut alors créer une tâche planifiée via le Planificateur de tâches de Synology. (Créer un script défini par l'utilisateur, indiquer le chemin absolu vers le script et ajouter les paramètres désirés, programmer un démarrage toutes les 5 minutes et enregistrer la tâche.) [EDIT du 23/09/2015] J'ai modifié mon script suite à une recherche sur Internet. Le script démarre et arrête maintenant les caméras en concordance avec l'interface web de Surveillance Station (utilisation de la commande wget -> voir http://forum.synology.com/enu/viewtopic.php?f=82&t=47074&sid=624dd57738d6deeff14282584b77f5b4&start=15 ). Les tests sont concluants. Il faudra que je publie une nouvelle version ... c'est fait ! Reste à trouver comment gérer Cloud Sync de façon similaire ...c'est fait ! Je publie de nouveau le code ... Il restait cependant un problème : comment savoir si Cloud Sync est en pause ou non (voir interface web de Cloud Sync) J'ai la solution et je teste actuellement ... ok cela semble bien fonctionner. voici le code : #!/bin/sh cd "$PWD/" # se place dans le dossier d'emplacement du script # traitement de toutes les erreurs redirigées vers le fichier erreurs_video_rsync.log > erreurs_video_rsync.log # ligne à commenter si on veut les erreurs à l'écran de la console exec 6>&2 # ligne à commenter si on veut les erreurs à l'écran de la console exec 2>>erreurs_video_rsync.log # ligne à commenter si on veut les erreurs à l'écran de la console ID="$RANDOM" USER="xxxxx" # nom d'un utilisateur défini dans Surveillance Station avec les droits sur CloudSync - à introduire PASS="xxxxx" # mot de passe de cet utilisateur - à introduire SERVEUR="xxx.xxx.xxx.xxx:xxxx" # adresse IP du serveur et port de connexion, ex ; "192.168.0.12:9900" - à introduire heure=$(date +%Hh-%Mmin) jour=$(date +%d-%m-%Y) jour_archive=$(date +%Y-%m-%d) #yyyy-mm-dd pour option t de zip # calcule le nombre de minutes depuis le début de ce jour à 00.00 h.m -> utilisé pour la commande find chargée de trouver les fichiers vidéos créés ce jour diff_min=$(date +"%M") diff_heure=$(date +"%H") if [ "${diff_min::1}" == "0" ] ; then diff_min=${diff_min:1} ; fi if [ "${diff_heure::1}" == "0" ] ; then diff_heure=${diff_heure:1} ; fi diff_heure=$(($diff_heure*60)) min_ecoulees=$(($diff_heure+$diff_min)) #rep_1_source et rep_2_source sont les noms des répertoires où Surveillance Station enregistre les fichiers vidéos - on considère 2 caméras rep_1_source="/volume1/surveillance/CameraBureau/" # à adapter - terminer par / rep_2_source="/volume1/surveillance/CameraCouloir/" # à adapter - erminer par / #rep_zip est le nom du répertoire dans lequel sont enregistrées les archives zip - ce dossier est synchronisé avec Google Drive et doit être créé rep_zip="/volume1/surveillancebis/videos/" # à adapter - terminer par / synchro="$1" # si 1 le processus de CloudSynchro est démarré par ce script - si 0, ce script ne gère pas la synchro # si 2 le processus de CloudSynchro est arrêté par ce script # nom de chacune des caméras camera_1="caméra_bureau" camera_2="caméra_couloir" ##################### fonctions de GESTION DES 2 CAMERAS ###################################################### # statuts des cameras actives ou non ? statuts_cameras() { proc="[/]var/packages/SurveillanceStation/target/sbin/ssd -c $1" PID=$(ps -w | grep "$proc" -m1) if [ $? = 0 ] ; then echo "est activée" else echo "n'est pas activée" fi } demarre_cameras() { # activation des 2 caméras en fonction du paramètre intoduit # ancienne méthode d'activation sans concordance avec l'interface web de Surveillance Station #/var/packages/SurveillanceStation/target/sbin/ssd -c "$1" # méthode d'activation des caméras en concordance avec l'interface web de Surveillance Station VER="1" wget -q --keep-session-cookies --save-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/auth.cgi?api=SYNO.API.Auth&method=Login&version=${VER}&account=${USER}&passwd=${PASS}">/dev/null 2>&1 VER="3" wget -q --load-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/entry.cgi?api=SYNO.SurveillanceStation.Camera&method=Enable&version=${VER}&cameraIds=$1">/dev/null 2>&1 VER="1" wget -q --load-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/auth.cgi?api=SYNO.API.Auth&method=Logout&version=${VER}">/dev/null 2>&1 echo "est activée" > $rep_zip"cameras_ON" if [ -e $rep_zip"cameras_OFF" ] ; then rm $rep_zip"cameras_OFF" ; fi } arrete_cameras() { # ancienne méthode de désactivation des caméras sans concordance avec l'interface web de Surveillance Station #proc="[/]var/packages/SurveillanceStation/target/sbin/ssd -c $1" #PID=$(ps -w | grep "$proc" | awk '{ print $1 }') #kill "$PID" # méthode de désactivation des caméras en concordance avec l'interface web de Surveillance Station VER="1" wget -q --keep-session-cookies --save-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/auth.cgi?api=SYNO.API.Auth&method=Login&version=${VER}&account=${USER}&passwd=${PASS}">/dev/null 2>&1 VER="3" wget -q --load-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/entry.cgi?api=SYNO.SurveillanceStation.Camera&method=Disable&version=${VER}&cameraIds=$1">/dev/null 2>&1 VER="1" wget -q --load-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/auth.cgi?api=SYNO.API.Auth&method=Logout&version=${VER}">/dev/null 2>&1 echo "est arrêtée" > $rep_zip"cameras_OFF" if [ -e $rep_zip"cameras_ON" ] ; then rm $rep_zip"cameras_ON" ; fi } demarre_arrete_cloud_sync() { # reprend la synchro lorsqu'elle est en pause ou met en pause lorsqu'elle est active en concordance avec l'interface web de CloudSync # cette fonction reçoit 1 paramètre - soit $1=pause - soit $1=resume # il est nécessaire de définir un utilisateur ayant les droits sur l'exécution de CloudSync (admin avec mot de passe) VER="1" wget -q --keep-session-cookies --save-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/auth.cgi?api=SYNO.API.Auth&method=Login&version=${VER}&account=${USER}&passwd=${PASS}">/dev/null 2>&1 wget -q --load-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/entry.cgi?api=SYNO.CloudSync&method=$1&version=${VER}">/dev/null 2>&1 wget -q --load-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/auth.cgi?api=SYNO.API.Auth&method=Logout&version=${VER}">/dev/null 2>&1 } statut_cloud_sync() { # récupère la valeur du PID de Cloud Sync dans le fichier syno-cloud-syncd.pid if [ -f /var/run/syno-cloud-syncd.pid ] ; then PID_cloud_sync=`head -1 /var/run/syno-cloud-syncd.pid` else statclsync="n'est pas installé !" fi if [ -n "$PID_cloud_sync" ] ; then # récupère le statut du processus Cloud Sync (S = actif / T = inactif) STCS=$(ps -w | grep '[/]var/packages/CloudSync/target/sbin/syno-cloud-syncd' | awk '{ print $4 }') statclsync="processus absent" if [ "$STCS" == "T" ] ; then statclsync="processus présent mais non actif" ; fi if [ "$STCS" == "S" ] ; then statclsync="processus présent et actif" ; fi if [ -z "$STCS" ] && [ "$synchro" == "1" ]; then statclsync="processus non présent -> tente de le relancer" # tente de relancer le processus Cloud Sync après un kill -9 /var/packages/CloudSync/target/sbin/syno-cloud-syncd /volume1/@cloudsync/config/daemon.conf fi fi } statut_cloud_sync_web() { # récupère le statut de Cloud Sync en fonction du paramétrage de l'interface web de Cloud Sync statclsyncweb="absent" SCSW="A" VER="1" wget -q --keep-session-cookies --save-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/auth.cgi?api=SYNO.API.Auth&method=Login&version=${VER}&account=${USER}&passwd=${PASS}">/dev/null 2>&1 statut_sync=$(wget -q --load-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/entry.cgi?is_tray=false&api=SYNO.CloudSync&method=list_conn&version=${VER}") wget -q --load-cookies /tmp/syno-cookies-${ID}.txt -O- "http://${SERVEUR}/webapi/auth.cgi?api=SYNO.API.Auth&method=Logout&version=${VER}">/dev/null 2>&1 if echo "$statut_sync" | grep '"is_pause":false' >/dev/null 2>&1 ; then SCSW="R";statclsyncweb="la synchro est lancée" ; fi if echo "$statut_sync" | grep '"is_pause":true' >/dev/null 2>&1 ; then SCSW="P";statclsyncweb="la synchro est en pause" ; fi } ############################################################################################################### # les informations de ce script sont redirigées vers un fichier "demarrage_video_rsync-$jour-$min_ecoulees.log" se trouvant dans le dossier rep_zip # nom du fichier log qui change en fonction du jour et du nombre de minutes écoulées depuis 00h00min fichier_log="demarrage_video_rsync-$jour-$min_ecoulees.log" rm "$rep_zip""demarrage_video_rsync"*".log" # efface les anciens fichiers log echo "***************** Check Surveillance Station processus ********************" | tee "$rep_zip""$fichier_log" echo "Démarrage de l'archivage des vidéos de surveillance le $jour à $heure" | tee -a "$rep_zip""$fichier_log" echo "Chemin absolu du script : $PWD/$0 $1 $2 $3" | tee -a "$rep_zip$fichier_log" echo "Nouveau nom du fichier log = $fichier_log" | tee -a "$rep_zip$fichier_log" ############## GESTION DES 2 CAMERAS ########################################################################## # vérifie l'état d'activation des 2 caméras - appel la fonction statuts_cameras nbr_cameras=0 stat_1=$(statuts_cameras "5") # le paramètre "5" est l'id de la caméra attribué par Surveillance Station stat_2=$(statuts_cameras "6") # le paramètre "6" est l'id de la caméra attribué par Surveillance Station # Pour trouver id de la caméra, ouvrir le fichier "cam_settings.conf" situé dans le sous-dossier de la caméra du répertoire Surveillance # effectuer dans ce fichier texte, une recherche sur "id": # le nombre recherché est celui après les 2 points, ex : ,"id":5, echo "Statut caméra : la $camera_1 $stat_1" | tee -a "$rep_zip$fichier_log" if [ "$stat_1" == "est activée" ] ; then let nbr_cameras++ ; fi echo "Statut caméra : la $camera_2 $stat_2" | tee -a "$rep_zip$fichier_log" if [ "$stat_2" == "est activée" ] ; then let nbr_cameras++ ; fi # active les caméras si demandé $2=1 et si elles ne sont pas déjà actives if [ "$2" == "1" ] && [ "$stat_1" == "n'est pas activée" ] ; then if [ -z "$3" ] ; then tempo="0" else tempo=$3 # 3me paramètre éventuel - nombre de minutes avant d'activer les caméras if [ "$tempo" -gt "4" ] ; then tempo="4" ; fi # la temporisation de mise en marche des caméras ne peut pas dépasser 4 minutes car la tâche planifiée s'effectuera de 5 en 5 minutes ! echo "Les caméras seront activées dans $tempo minute(s)" | tee -a "$rep_zip$fichier_log" sleep $(($tempo*60)) # temporise $3 minutes avant de démarrer les caméras - temps de sortie oblige ! fi stat_1=$(demarre_cameras "5") echo "La $camera_1 $stat_1" | tee -a "$rep_zip""$fichier_log" let nbr_cameras++ fi if [ "$2" == "1" ] && [ "$stat_2" == "n'est pas activée" ] ; then stat_2=$(demarre_cameras "6") echo "La $camera_2 $stat_2" | tee -a "$rep_zip""$fichier_log" let nbr_cameras++ fi # arrête les caméras si demandé $2=2 et si elles ont été activées if [ "$2" == "2" ] && [ "$stat_1" == "est activée" ] ; then stat_1=$(arrete_cameras "5") echo "La $camera_1 $stat_1" | tee -a "$rep_zip""$fichier_log" let nbr_cameras-- fi if [ "$2" == "2" ] && [ "$stat_2" == "est activée" ] ; then stat_2=$(arrete_cameras "6") echo "La $camera_2 $stat_2" | tee -a "$rep_zip""$fichier_log" let nbr_cameras-- fi ##### nombre de caméras activées 0 - 1 ou 2 #echo "Nombre de caméras actives = $nbr_cameras" # enlever "#" en début de cette ligne pour afficher en console echo "Nombre de caméras actives = $nbr_cameras" | tee -a "$rep_zip""$fichier_log" # si le nombre de caméras actives est > 0 alors if [ "$nbr_cameras" -gt "0" ] ; then echo "Surveillance Station processus est actif avec $nbr_cameras caméra(s)" | tee -a "$rep_zip""$fichier_log" else echo "Surveillance Station processus n'est pas actif - $nbr_cameras caméra activée" | tee -a "$rep_zip""$fichier_log" fi ############# GESTION DE LA SYNCHRONISATION avec GOOGLE DRIVE ################################################### statut_cloud_sync # récupère le statut du processus S ou T statclsyncweb="statut interface web ?" # récupère le statut de l'interface web Pause ou Resume if [ -n "$PID_cloud_sync" ] && [ "$STCS" == "S" ]; then statut_cloud_sync_web;fi echo "Cloud Sync $statclsync -> $statclsyncweb" | tee -a "$rep_zip""$fichier_log" # Synchronisation avec Google Drive gérée ou non par ce script # cas où la synchro est gérée par ce script $synchro > 0 ( 1 ou 2 ou 3 ou 4) if [ "$synchro" -gt "0" ] ; then if [ "$STCS" == "S" ] && [ "$synchro" == "1" ]; then # sortie de pause si le processus est en pause P if [ "$SCSW" == "P" ] ; then demarre_arrete_cloud_sync "resume" echo "Relance la synchronisation avec Google Drive gérée par ce script" | tee -a "$rep_zip""$fichier_log" statut_cloud_sync_web # vérifie de nouveau le statut via l'interface web if [ "$SCSW" == "R" ] ; then echo "Cloud Sync $statclsync -> $statclsyncweb" | tee -a "$rep_zip""$fichier_log" fi fi fi if [ "$STCS" == "T" ] ; then kill "-18" "$PID_cloud_sync" # déclenche la Synchro avec Google Drive si elle ne l'était pas - relance le processus mis en veille echo "Démarrage de la synchronisation avec Google Drive gérée par ce script" | tee -a "$rep_zip""$fichier_log" statut_cloud_sync # vérifie le statut statut_cloud_sync_web # vérifie de nouveau le statut via l'interface web if [ "$SCSW" == "P" ] ; then demarre_arrete_cloud_sync "resume" statut_cloud_sync_web # vérifie de nouveau le statut via l'interface web fi echo "Cloud Sync $statclsync -> $statclsyncweb" | tee -a "$rep_zip""$fichier_log" fi else echo "La synchronisation avec Google Drive n'est pas gérée par ce script" | tee -a "$rep_zip""$fichier_log" fi ################################################################################################################# ##################### GESTION DES ARCHIVES ZIP ################################################################## ##### compte le nombre de fichiers vidéos au format mp4 et avi dans chaque répertoire source de Surveillane Station dont la présence remonte au début de ce jour vide_1=$(find "$rep_1_source" \( -iname '*.mp4' -o -iname '*.avi' \) -maxdepth 2 -type f -mmin -$min_ecoulees | wc -l) # pour caméra 1 vide_2=$(find "$rep_2_source" \( -iname '*.mp4' -o -iname '*.avi' \) -maxdepth 2 -type f -mmin -$min_ecoulees | wc -l) # pour caméra 2 echo "nombre de fichiers vidéos pour la caméra 1 = $vide_1" | tee -a "$rep_zip""$fichier_log" echo "nombre de fichiers vidéos pour la caméra 2 = $vide_2" | tee -a "$rep_zip""$fichier_log" # si présence de fichiers mp4 ou avi enregistrés à partir du début de ce jour alors il est possible d'ajouter des fichiers mp4 ou avi à l'archive du jour if [ "$vide_1" -gt "0" ] || [ "$vide_2" -gt "0" ] ; then echo "Il y a des fichiers mp4 et avi enregistrés à la date du $jour dans les sous-répertoires de Surveillance Station" | tee -a "$rep_zip""$fichier_log" echo "jour archive = $jour_archive" | tee -a "$rep_zip""$fichier_log" # taille des 2 fichiers zip avant archivage poids_fichier_1_old=0 if [ -e "$rep_zip"archive-$camera_1-du_"$jour".zip ] ; then poids_fichier_1_old=`du -k "$rep_zip"archive-"$camera_1"-du_"$jour".zip | sed 's/\([0-9]*\)\(.*\)/\1/')` fi poids_fichier_2_old=0 if [ -e "$rep_zip"archive-$camera_2-du_"$jour".zip ] ; then poids_fichier_2_old=`du -k "$rep_zip"archive-"$camera_2"-du_"$jour".zip | sed 's/\([0-9]*\)\(.*\)/\1/')` fi echo "poids fichier 1 old = $poids_fichier_1_old et poids fichier 2 old = $poids_fichier_2_old" | tee -a "$rep_zip""$fichier_log" # recherche des fichiers mp4 ou avi afin de les archiver en ajoutant à l'archive zip if [ "$vide_1" -gt "0" ] ; then find "$rep_1_source" -iname "*.mp4" -type f | zip -jut "$jour_archive" "$rep_zip"archive-$camera_1-du_"$jour".zip -@ fi if [ "$vide_2" -gt "0" ] ; then find "$rep_2_source" -iname "*.avi" -type f | zip -jut "$jour_archive" "$rep_zip"archive-$camera_2-du_"$jour".zip -@ fi # taille des 2 fichiers zip après archivage poids_fichier_1_new=0 if [ -e "$rep_zip"archive-$camera_1-du_"$jour".zip ] ; then poids_fichier_1_new=`du -k "$rep_zip"archive-"$camera_1"-du_"$jour".zip | sed 's/\([0-9]*\)\(.*\)/\1/')` fi poids_fichier_2_new=0 if [ -e "$rep_zip"archive-$camera_2-du_"$jour".zip ] ; then poids_fichier_2_new=`du -k "$rep_zip"archive-"$camera_2"-du_"$jour".zip | sed 's/\([0-9]*\)\(.*\)/\1/')` fi echo "poids fichier 1 new = $poids_fichier_1_new et poids fichier 2 new = $poids_fichier_2_new" | tee -a "$rep_zip$fichier_log" declenche="0" # declenche passe à "1" si des fchiers vidéos sont ajoutés à l'archive zip # comparaison avant et après archivage des fichiers zip si le fichier archive zip existe if [ -e "$rep_zip"archive-$camera_1-du_"$jour".zip ] ; then echo "Le fichier archive-$camera_1-du_"$jour".zip existe" | tee -a "$rep_zip""$fichier_log" if [ "$poids_fichier_1_old" == "$poids_fichier_1_new" ] ; then echo "Aucune vidéo ajoutée à l'archive de la $camera_1 (archive-$camera_1-du_$jour.zip)" | tee -a "$rep_zip""$fichier_log" else echo "Des vidéos ont été ajoutées à l'archive de la $camera_1 (archive-$camera_1-du_$jour.zip)" | tee -a "$rep_zip""$fichier_log" declenche="1" fi else echo "Le fichier archive du $jour de la $camera_1 n'a pas été créé" | tee -a "$rep_zip""$fichier_log" fi if [ -e "$rep_zip"archive-$camera_2-du_"$jour".zip ] ; then echo "Le fichier archive-$camera_2-du_"$jour".zip existe" | tee -a "$rep_zip""$fichier_log" if [ "$poids_fichier_2_old" == "$poids_fichier_2_new" ] ; then echo "Aucune vidéo ajoutée à l'archive de la $camera_2 (archive-$camera_2-du_$jour.zip)" | tee -a "$rep_zip""$fichier_log" else echo "Des vidéos ont été ajoutées à l'archive de la $camera_2 (archive-$camera_2-du_$jour.zip)" | tee -a "$rep_zip""$fichier_log" declenche="1" fi else echo "Le fichier archive du $jour de la $camera_2 n'a pas été créé" | tee -a "$rep_zip""$fichier_log" fi if [ "$synchro" -gt "1" ] ; then # désactive la synchro avec Google Drive if [ "$declenche" == "1" ] ; then echo "Temporisation de 4 minutes afin de synchroniser avec Google Drive" | tee -a "$rep_zip""$fichier_log" sleep 210 # 3 minutes et 30 secondes fi # temporise 4 minutes avant de tuer la tâche de synchro avec Google Drive fi else echo "Pas de fichiers mp4 ou avi du $jour dans le dossier Surveillance, aucun archivage ne sera effectué ce $jour à $heure" | tee -a "$rep_zip""$fichier_log" if [ -e "$rep_zip"archive-$camera_1-du_"$jour".zip ] ; then rm "$rep_zip"archive-$camera_1-du_"$jour".zip # efface le fichier zip fi if [ -e "$rep_zip"archive-$camera_2-du_"$jour".zip ] ; then rm "$rep_zip"archive-$camera_2-du_"$jour".zip # efface le fichier zip fi fi ####################### MISE EN PAUSE ou GELE ou TUE le processus de Cloud Sync ####################################################### # arrêt automatique de la synchronisation en fonction du parmètre intoduit $1=2 et synchro effective "R" pas en pause "P" if [ "$synchro" -gt "1" ] && [ "$SCSW" == "R" ]; then echo "Il reste 30 secondes de temporisation afin de synchroniser avec Google Drive" | tee -a "$rep_zip""$fichier_log" echo "Mise en pause de la synchronisation avec Google Drive gérée par ce script dans 30 secondes" | tee -a "$rep_zip""$fichier_log" sleep 30 # 30 secondes demarre_arrete_cloud_sync "pause" # via interface web de Cloud Synchro echo "Mise en pause de la synchronisation avec Google Drive effectuée" | tee -a "$rep_zip""$fichier_log" fi # gèle le processus s'il est actif -> statut 'T' if [ "$synchro" == "3" ] && [ "$statclsync" != "processus absent" ]; then kill "-19" "$PID_cloud_sync" # gèle le processus - statut "T" -> ne peut pas être relancé via l'interface graphique !!! echo "Le processus Cloud Sync est gelé - statut 'T' (non gérable via l'interface web !)" | tee -a "$rep_zip""$fichier_log" fi # tue le processus s'il est actif if [ "$synchro" == "4" ] && [ "$statclsync" != "processus absent" ]; then kill "-9" "$PID_cloud_sync" # tue le processus -> ne peut pas être relancé via l'interface graphique !!! echo "Le processus Cloud Sync est tué (non gérable via l'interface web !)" | tee -a "$rep_zip""$fichier_log" fi ######################################################################################################################################## # supprime les cookies générés par ce script et présents dans le dossier /tmp rm /tmp/syno-cookies-*.txt exec 2>&6 6>&- # fin de la redirection vers le fichier erreur # ligne à commenter si on veut les erreurs à l'écran de la console exit 0 ####################################################################################################################################### # nom du script = video_rsync.sh admet 3 paramètres séparés par 1 caractère espace # 1er paramètre - 0 - ne gère pas la synchronisation avec Google Drive # - 1 - démarre la synchronisation avec Google Drive si elle ne l'est pas en concordance avec l'interface web # - 2 - met en pause la synchronisation avec Google Drive après 30 secondes ou 4 minutes # - 3 - gèle le processus de synchronisation (processus à T - ingérable via l'interface web !) # - 4 - tue le processus de synchronisation (ingérable via l'interface web !) # 2me paramètre - 0 - ne gère pas le démarrage des 2 caméras # - 1 - démarre les 2 caméras en surveillance si ce n'était pas le cas # - 2 - arrête les 2 caméras en surveillance si ce n'était pas le cas # 3me paramètre - indique le nombre de minutes avant le démarrage des caméras si celles-ci sont gérées par ce script # Attention de ne pas dépasser 4 minutes si la tâche planifiée démarre de 5 en 5 minutes !!!! # lignes de commande possibles dans la console ssh (Putty.exe) : sh video_rsync.sh 0 0 (ou sans paramètre) # : sh video_rsync.sh 1 0 (ou sans le 0) # : sh video_rsync.sh 1 1 3(le mieux pour démarrer !) # : sh video_rsync.sh 2 0 (ou sans le 0) # : sh video_rsync.sh 2 1 # : sh video_rsync.sh 2 2 (le mieux pour arrêter)

Bonjour, Je viens d'améliorer mon script bash qui a pour but de réaliser des archives zip dans un répertoire "surveillancebis" synchronisé avec Google Drive. Ce script est démarré par une tâche planifiée toutes les 5 minutes (on pourrait diminuer à 1 minute). Le fait qu'il s'agit d'archives au format zip, permet une synchronisation assez rapide (ma vitesse d'envoi est de 2,74Mbit/s). La synchronisation avec Google Drive est réglée sur 30 secondes avec un upload vers Google Drive lors d'un changement sur le dossier local. J'effectue actuellement des tests et actuellement cela paraît efficace. J'ai également réalisé un script bash qui permet (start | stop) d'activer et de désactiver les 2 caméras en surveillance. Malheureusement si on active les 2 caméras par ce script, l'interface web de Surveillance Station ne prend pas en compte le fait que les 2 caméras sont actives. Je cherche une solution, si vous avez une piste ... Je suis d'accord avec jms8591 sur le fait de pouvoir récupérer les vidéos. On peut aussi effectuer les 2 opérations mais j'ai souvent des déclenchements intempestifs des caméras (volets automatiques et éclairages automatiques) donc je risque de recevoir une quantité de courriels assez importante.

Bonjour, Merci pour cette info. Je préfère cependant utiliser un répertoire bis synchronisé avec Google Drive dans lequel je place les vidéos sous forme d'archives zip (les fichiers sont alors compressés) voir le script bash

Bonjour, J'utilise un fichier bash avec une commande rsync qui permet de copier le dossier Surveillance vers le dossier Surveillancebis qui est synchronisé avec Google Drive via l'application Cloud Sync. Ce bash est lancé comme tâche (via le Planificateur de tâches) avec un délai de 5 minutes lorsque les caméras fonctionnent en détection de mouvements. #!/bin/sh heure=$(date +%H.%M) jour=$(date +%d-%m-%Y) cd /volume1/emplacementscript / # important de se placer dans le dossier qui contient ce script echo "demarrage de video_rsync le $jour a $heure" > demarrage_video_rsync.log # pour obtenir les logs de démarrage rsync -azur --delete-after --log-file="rsync.log" /volume1/surveillance/ /volume1/surveillancebis/ exit 0 On peut aussi opter pour la création d'une archive zip dans un répertoire synchronisé avec Google Drive. Cela donne de meilleurs résultats vu que l'on obtient des fichiers compressés. Voir la suite de ce post ...

Bonjour, Je suis aussi confronté au même problème. Avant j'avais utilisé le logiciel Synobox que j'avais paramétré pour synchroniser mon répertoire Surveillance avec la Dropbox, tout fonctionnait parfaitement. Mon espace Dropbox a été réduit après 2 ans d'utilisation de 50 Go à 6 Go. J'ai donc décidé d'utiliser mon espace Google Drive afin de synchroniser mon dossier Surveillance avec celui-ci. J'ai donc installé Cloud Sync et tenté la synchro avec le dossier Surveillance. problème : la synchro échoue car je ne dispose pas des droits nécessaires sur le dossier Surveillance (impossible de changer les droits) Je recherche une solution sur Internet et je trouve une possibilité : - monter un dossier Surveillancebis au démarrage du Synology qui un clone du dossier Surveillance - j'utilise 2 scripts bash qui permettent la mise en œuvre via une connexion au NAS par Putty.exe - je tente alors la synchronisation du dossier Surveillancebis avec Google Drive en utilisant Cloud Sync. Cela fonctionne mais ... Lorsqu'une séquence vidéo est enregistrée par une caméra (fichier au format mp4 ou avi), j'observe que le fichier vidéo est présent dans le dossier Surveillance et que son clone est présent dans le dossier Surveillancebis. S'il s'agit d'une nouvelle journée, Surveillance Station crée un nouveau répertoire dans lequel se trouve ce 1er fichier vidéo. Tout se déroule bien en local. Malheureusement quand Cloud Sync doit opérer, il crée bien le nouveau répertoire du jour mais le fichier vidéo qui devrait être présent sur Google Drive est tronqué (corrompu, impossible de lire la vidéo). En plus si un 2ème fichier est enregistré le même jour, il est placé dans le même répertoire à la suite du 1er fichier mais Cloud Sync n'effectue pas le travail donc ce 2ème fichier n'est pas enregistré sur le Google Drive. (idem avec un 3ème fichier, etc ...) Un remède mais il faut intervenir manuellement, ouvrir Cloud Sync, changer le type de Synchro et sauvegarder (bidirectionnel en upload local ou l'inverse). La synchronisation s'effectue alors correctement. (autre possibilité : redémarrer le NAS). J'ai également testé avec One Drive mais ce sont les mêmes problèmes. Si on ajoute manuellement par copier/coller, un fichier dans Surveillancebis alors la synchro fonctionne correctement. Autre remède, via un fichier bash, copier les fichiers vidéo vers un répertoire synchronisé avec Google Drive mais à quelle fréquence faut-il démarrer cette tâche ? Il semblerait que Cloud Sync pose un problème, je suis en DSM 5.2-5592 Update 3 sur le NAS. [EDIT du 29/08/2015] Je viens de réaliser un fichier bash qui permet de solutionner les problèmes. Je teste et si vous êtes toujours intéressés, je publie le code.