Forum Programmation.python Fichier python pour lecture Arduino

Posté par . Licence CC by-sa
Tags : aucun
1
8
mar.
2015

Bonjour je reviens vers vous pour vous demandé de l'aide.
Comme j'avais expliqué ici
http://linuxfr.org/forums/programmation-c/posts/comment-capturer-et-stocker-image-provenant-de-camera-ip#comment-1587709
avec un émetteur je capte des codes en 433Mhz a l'aide d'un raspberry et un fichier en C++ , Mon système n'est pas du tout stable , mon CPU utilise trop de ressource.

j'ai trouvé une autre solution , j'ai branché sur le raspberry en USB , un arduino avec un récepteur 433 Mhz ,celui ci capte tous les codes émis et les envoie au raspberry . Il me faut donc maintenant lire et exploité ces codes avec mon raspberry a l'aide d'un fichier python .Comment faire ?

Ce code python lit tout les codes capté par l'arduino, je voudrais que si le code 35 est détecté ça aille me faire une action .

#!/usr/bin/env python
# -*- coding: latin-1 -*-

import serial
ser = serial.Serial('/dev/ttyACM0', 9600)
while 1 :
    print(ser.readline())
end
  • # reflexion de base

    Posté par . Évalué à 4.

    ton symptome :

    mon CPU utilise trop de ressource.

    la cause :

    while 1 :
        print(ser.readline())
    end

    quoique tu fasses une boucle qui tourne en permanence pour lire une info est une tres mauvaise idée en terme de cpu.
    et c'est pour cela que ton cpu consomme,
    deporter la reception du signal sur un arduino, mais continuer à faire un boucle permanente ne changera rien.

    il faut commencer à regarder la programmation evenementielle
    qui va detecter un signal et lancer une action

    • [^] # Re: reflexion de base

      Posté par . Évalué à 1. Dernière modification le 08/03/15 à 16:40.

      Bonjour NeoX et merci pour ta rapidité de réponse Quand je dis ''mon CPU utilise trop de ressource''je parlais de mon fichier en C++ qui etait sur le raspberry.

      Ma boucle Python qui tourne en permanence sur le raspberry ne consomme presque rien .

      Comment faire alors ?
      Il faut mettre l'integralité de mon fichier C++ sur l'arduino?

      • [^] # Re: reflexion de base

        Posté par . Évalué à 4.

        si ton fichier C++ consomme sur le raspberry, il est probable qu'il consommera sur l'arduino

        il faut peut-etre revoir l'algorythme que tu as repris,
        pour optimiser ce qui peut l'etre.

        comme evoqué dans le sujet precedent, tu as un programme en C++ qui :
        - va attendre un signal 433Mhz
        - à l'arrivée du signal, va ouvrir un shell pour prendre un fichier dans une URL
        - a la reception du fichier, ca ouvrir un shell pour lancer un script shell/python pour envoyer un email

        faudrait verifier qu'il declenche la lecture URL et le mail uniquement quand le signale 433Mhz est recu.

        mais il y a des etapes consommatrices de ressources (les ouvertures de shell) qui ne sont pas forcement necessaires.
        il avait été evoqué le fait d'aller lire l'URL ou envoyer l'email directement en C++

        ca devrait deja alléger la charge

        ensuite revoir la partie attente du signal, si on peut eviter ou simplifier la boucle d'attente pour l'alleger, ce sera encore mieux.

        • [^] # Re: reflexion de base

          Posté par . Évalué à 1. Dernière modification le 08/03/15 à 17:19.

          mon arduino branché sur le raspberry me sert uniquement pour capter les codes , Je voulais posté mon fichier C++ ici mais impossible trop gros
          ( 279 lignes ) il voila un lien pour le téléchargé
          http://dl.free.fr/getfile.pl?file=/q6R1ctFx ,

          • [^] # Re: reflexion de base

            Posté par . Évalué à 2.

            le code pour permettre aux autres de l'anlyser

            #include "RCSwitch.h"
            #include <stdlib.h>
            #include <stdio.h>
            #include <string.h>
            #include <unistd.h>
            #include <time.h>
            
            RCSwitch mySwitch;
            
            //int main(int argc, char *argv[]) {
            int main() {
                int PIN = 5;
                int radio_code = 0;
                int old_BL = 0;
                int new_BL = 0;
                char old_str[10] ;
                const char * sensor_loc ;
                const char * sensor_type ;
                // log
                struct tm * timeinfo;
                char timestamp_str[20] ;
                char localtime_s[20] ;
                char evnt_str[50] ;
            
                // capteurs BL
                int BL_plein = 5592332 ;
                int BL_vide  = 5592323 ;
                // capteurs DI
                int DI0 = 1381717 ;
                int DI1 = 7673173 ;
                // capteurs Sonnette
                int BPSO = 13487999 ;
            
                // les fichiers
                FILE *file_BL;
                FILE *file_ALARM;
                FILE *file_SMS;
                FILE *file_TEST;
                FILE *file_DI;
                FILE *file_SO;
            
                // taille de file_ALARM
                //int file_ALARM_size = 0;
                int file_ALARM_size;
                int file_DI_size;
                int file_SO_size;
                // nanosleep
                struct timespec delay;
                delay.tv_sec =0 ;
            //  delay.tv_nsec =  100000000L; // tts les 1/10 sec (10/s)
            //  delay.tv_nsec =  200000000L; // tts les 1/5 sec (5/s)
            //  delay.tv_nsec =  250000000L; // tts les 1/4 sec (4/s)
                delay.tv_nsec =  330000000L; // tts les 1/3 sec (3/s)
            //  delay.tv_nsec =  500000000L; // tts les 1/2 sec (2/s)
            //  delay.tv_nsec = 1000000000L; // tts les 1 sec (1/s)
            
                if(wiringPiSetup() == -1) {
                    if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {
                        time_t now;
                        time(&now);
                        strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                        sprintf(evnt_str,"%s : Erreur de lancement \n", timestamp_str); // prep ligne --> evnt_str
                        fputs(evnt_str, file_TEST);
                        fclose(file_TEST);
                        }
                    exit(9);
                }
            
                mySwitch = RCSwitch();
                mySwitch.enableReceive(PIN);
            
                // lecture de l'etat initial de la boite aux lettres
                if((file_BL = fopen("/home/www/logs/BL-state.txt", "r")) != NULL) {
                    fgets( old_str,10, file_BL );
                    fclose(file_BL);
                    }
                else {
                    if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {
                        time_t now;
                        time(&now);
                        strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                        sprintf(evnt_str,"%s : Erreur lecture etat initial BL \n", timestamp_str); // prep ligne --> evnt_str
                        fputs(evnt_str, file_TEST);
                        fclose(file_TEST);
                        }
                    exit(9);
                    }
                if (strstr(old_str,"PLEIN")!=NULL) {
                    old_BL=BL_plein;
                    }
                if (strstr(old_str,"VIDE")!=NULL) {
                    old_BL=BL_vide;
                    }
            
            /**/
                if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {
                    time_t now;
                    time(&now);
                    strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                    sprintf(evnt_str,"%s : Etat initial BL : %d \n", timestamp_str, old_BL); // prep ligne --> evnt_str
                    fputs(evnt_str, file_TEST);
                    fclose(file_TEST);
                    }
            /**/
                while(true) {
                    if (mySwitch.available()) {
                        radio_code = mySwitch.getReceivedValue();
                        if (radio_code != 0) { // on a recu un code
            /**/
                            /// pour test
            //              if (radio_code==BL_plein || radio_code==BL_vide) { // uniquement la BL
                                if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {
                                    time_t now;
                                    time(&now);
                                    strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                    sprintf(evnt_str,"%s : Code radio %d \n", timestamp_str, radio_code); // prep ligne --> evnt_str
                                    fputs(evnt_str, file_TEST);
                                    fclose(file_TEST);
                                    }
            //                  }
            /**/
                            /// fin test
                            if (radio_code==BL_plein || radio_code==BL_vide) { // specifique boite aux lettres
                                // if (old_BL != radio_code){ // ecriture nouvel etat
                                    if((file_BL = fopen("/home/www/logs/BL-state.txt", "r+")) != NULL) {
                                        if (radio_code==BL_plein){
                                            fputs("PLEIN", file_BL);
                                            old_BL=radio_code;
                                            }
                                        else if (radio_code==BL_vide){
                                            fputs("VIDE ", file_BL);
                                            old_BL=radio_code;
                                            }
                                        fclose(file_BL);
                                    }
                                }   // fin boite aux lettres
            
                                // Sonnette
                                // Capture des codes dans fichier SO-state.txt
                                if (radio_code==BPSO) { 
            
                                    if((file_SO = fopen("/home/www/logs/SO-state.txt", "w")) != NULL) {
                                        if (radio_code==BPSO){
                                            fputs("Dring", file_SO);
                                        }
                                    fclose(file_SO);
                                    }   
                                 // Envoie de mail avec gmail.pi
                                if (radio_code==BPSO){system("python /home/www/py/gmail.py");   
                                }
                                }
                                // Fin Sonnette
            
            
                                // detection incendie
                                if (radio_code==DI0 || radio_code==DI1) { // Capture des codes dans fichier DI-state.txt 
            
                                    if((file_DI = fopen("/home/www/logs/DI-state.txt", "w")) != NULL) {
                                        if (radio_code==DI0){
                                            fputs("Feu RdeCh", file_DI);
                                            sensor_loc="Incendie RdC";
                                            sensor_type="detecteur";
                                            }
                                        else if (radio_code==DI1){
                                            fputs("Feu Etage", file_DI);
                                            sensor_loc="Incendie Etage";
                                            sensor_type="detecteur";}
                                        fclose(file_DI);
                                    }
                                // fin detection incendie
            
                                    // Remplissage fichier incidents Detecteur Incendie
                                    if((file_ALARM = fopen("/home/www/logs/ALARM-cumul.txt", "a+")) != NULL) {
                                            // le log
                                            time_t now;
                                            time(&now);
                                            strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                            sprintf(evnt_str,"%s | ALARME detecteur %s\n", timestamp_str, sensor_loc); // prep ligne --> evnt_str
                                            fputs(evnt_str, file_ALARM);
                                            file_ALARM_size = ftell(file_ALARM);
                                            // Fin Remplissage fichier incidents Detecteur Incendie
            
                                            // log pour envoi SMS
                                            if((file_SMS = fopen("/home/www/logs/ALARM-SMS.txt", "a+")) != NULL) {
                                                fputs(evnt_str, file_SMS);
                                                fclose(file_SMS);
                                                }
                                            // envoi SMS si file_DI >= 300
                                            if (file_DI_size>=300) {
                                                system("python /home/www/py/SMS2send.py  >> /home/www/logs/SMS.log & ");
                                                }
                                            fclose(file_DI);
                                    }
                                    // Fin envoi SMS Detecteur Incendie
                                }  
            
                            // Alarmes
                            if(file_ALARM = fopen("/home/www/logs/ALARM-state.txt","r")) { // alarme active seulement si ALARM-state.txt existe
                                fclose(file_ALARM);
                                switch(radio_code){ // on cherche a quel emplacement correspond le code recu
                                    case 5592320 :
                                        sensor_loc="Garage";
                                        sensor_type="contact";
                                        break;
                                    case 5592404 :
                                        sensor_loc="Salon";
                                        sensor_type="radar";
                                        break;
                                    case 5592405 :
                                        sensor_loc="Sejour";
                                        sensor_type="radar";
                                        break;
                                    case 5592341 :
                                        sensor_loc="Entree";
                                        sensor_type="radar";
                                        break;
                                    case 5592389 :
                                        sensor_loc="Chambre";
                                        sensor_type="radar";
                                        break;
                                    case 5592149 :
                                        sensor_loc="Atelier";
                                        sensor_type="radar";
                                        break;
                                    case 5591381 :
                                        sensor_loc="Cuisine";
                                        sensor_type="radar";
                                        break;
                                    default: 
                                        sensor_loc="";
                                        sensor_type="";
                                        break;
                                    }
                                if (sensor_loc!="") {
                                    if((file_ALARM = fopen("/home/www/logs/ALARM-state.txt", "a+")) != NULL) {
                                        // le log
                                        time_t now;
                                        time(&now);
                                        strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                        sprintf(evnt_str,"%s | ALARME capteur %s\n", timestamp_str, sensor_loc); // prep ligne --> evnt_str
                                        fputs(evnt_str, file_ALARM);
                                        file_ALARM_size = ftell(file_ALARM);
                                        // log pour envoi SMS
                                        if((file_SMS = fopen("/home/www/logs/ALARM-SMS.txt", "a+")) != NULL) {
                                            fputs(evnt_str, file_SMS);
                                            fclose(file_SMS);
                                            }
                                        // declenchement sirene et envoi SMS si file_ALARM >= 300 ou si sensor_type=contact
                                        if (file_ALARM_size>=300) {
                                            system("python /home/www/py/SMS2send.py  >> /home/www/logs/SMS.log & ");
                                            system("python /home/www/py/Expander-set.py A 2 close 60 & ");
                                            }
                                        fclose(file_ALARM);
                                        // declenchement buzzer (GPA4)
                                        if (sensor_loc=="Garage") {
                                            system("python /home/www/py/Expander-set.py A 4 close 30 & ");
                                            }
                                        }
                                    }
                                } // fin alarmes
                            }
                        mySwitch.resetAvailable();
                        } // fin mySwitch.available
                    //sleep(1);
                    //usleep(50000); // microsecond
                    nanosleep(&delay, NULL); // nanosecond
                    } // fin infinite loop
                exit(9);
                } // fin main
            • [^] # Re: reflexion de base

              Posté par . Évalué à 1. Dernière modification le 08/03/15 à 17:36.

              Voila c'est cette grosse chose qui utilise 70% du CPU de mon raspberry. que je voudrais mettre sur l'arduino.

              comme tu vois je n'exploite pas qu'un seul code c'est pour cela qu'il faut que ca tourne en permanence.

            • [^] # Re: reflexion de base

              Posté par . Évalué à 3.

              mon analyse rapidement :

              1°) ta boucle c'est une boucle toutes les ⅓ secondes (soit 3 tours par secondes), definie par la variable delay.tv_nsec ligne 53.

              dans une boucle il y a beaucoup d'ouverture/ecriture/fermeture de fichier
              vu que tu demandes 3 boucles par secondes, ton CPU passe son temps à ouvrir des fichiers et à les fermer.

              tu peux commencer par faire une boucle par seconde en commentant la ligne 53 (ajouter // au debut)
              et en decommentant la ligne 55 (en enlevant les //)

              ensuite, pour le fichier de logs, tu pourrais ouvrir le fichier de log au debut, le fermer à la fin
              plutot que de l'ouvrir, ecrire, fermer le fichier à chaque fois.

              2°) petites optimisations, tu peux remonter ton appelle à gmail.py (ligne 149/150) et mettre juste l'appelle system ligne 145

              sinon, bah bienvenu dans le monde de l'embarqué, ou il faut parfois faire revoir plusieurs fois son code afin de l'optimiser.

              • [^] # Re: reflexion de base

                Posté par . Évalué à 1.

                Ouf tu as compris le fonctionnement ! Il y at'il un moyen de faire exécuter ce code avec l'arduino pour libérer le raspberry ?

                • [^] # Re: reflexion de base

                  Posté par . Évalué à 3. Dernière modification le 08/03/15 à 18:43.

                  ca doit etre possible, mais il doit falloir recompiler specifiquement pour l'arduino

                  dans ton cas avant de vouloir compiler pour envoyer sur l'arduino, je ferais deja les reglages :
                  - 1 test par seconde (voire plus etalé, par exemple 1 test toutes les 5 secondes)
                  - revoir l'algo pour n'ouvrir qu'une fois le fichier de log en debut de programme, le fermer en cloture
                  - voire ne pas tout logger si ce n'est pas necessaire.

                  sinon tu partais dans l'idée de refaire ca en python, en lisant ce qui sort de l'arduino,
                  c'est une voie aussi.

                  lire le port serie,
                  filtrer pour recuperer le code 35,
                  aller lire l'URL pour prendre l'image
                  envoyer l'email

                  mais là encore tu fais une boucle "while 1: … end"
                  ce qui veut dire que tu n'as pas de limiteur, tu tournes et repetes ta lecture tant que le CPU peut le faire.

                  • [^] # Re: reflexion de base

                    Posté par . Évalué à 1. Dernière modification le 08/03/15 à 19:14.

                    Je ne suis pas trop pour 1 test par seconde (voire plus étalé, par exemple 1 test toutes les 5 secondes), j'ai déjà testé ça fait baisser le CPU mais je perds souvent la réception des codes.

                    • [^] # Re: reflexion de base

                      Posté par . Évalué à 3. Dernière modification le 08/03/15 à 19:37.

                      alors il faut revoir l'algo,
                      et passer à la programmation evenementielle plutot que sequentielle (avec un boucle qui se repete sans arret)

                      avoir une boucle qui cherche l'evenement,
                      qui pose l'info et juste une info dans un fichier
                      et qui ne fait que ca.

                      puis des astuces systemes comme inotify qui surveille le dossier/fichier,
                      et execute un script quand le dossier/fichier a changé

                      faut peut-etre regarder aussi du coté de la programmation avec interruption materiel
                      ainsi tu ne declenches l'action que s'il y a un evenement materiel (un truc sur le port serie, ou un reception RF)

                      • [^] # Re: reflexion de base

                        Posté par . Évalué à 1. Dernière modification le 08/03/15 à 19:51.

                        La ça deviens vraiment trop compliqué pour moi avec mes faibles connaissances .!! Merci quand même de m'avoir orienter

                        • [^] # Re: reflexion de base

                          Posté par . Évalué à 2.

                          J'ai essayé de reecrire le code C proposé plus tot, en reorganisant le contenu, en le simplifiant par endroit.

                          Si j'ai pas trop fait de fautes, et que l'indentation n'est pas trop mal faite (bien qu'inutile en C, elle rend le code plus lisible),
                          ca doit donner ca (evidemment je ne l'ai pas compilé n'ayant pas le RCswitch.h)

                          ATTENTION : ce code ne fait plus l'alerting SMS ou le log du capteur declenché
                          ca ne devait deja pas fonctionner puisqu'on lisait le code DI0/DI1 puis on le comparait à 5592320 pour en determiner le lieu

                          je relirais mon code demain pour corriger la detection des lieux des capteurs.

                          #include "RCSwitch.h"
                          #include <stdlib.h>
                          #include <stdio.h>
                          #include <string.h>
                          #include <unistd.h>
                          #include <time.h>
                          
                          RCSwitch mySwitch;
                          
                          //int main(int argc, char *argv[]) {
                          int main() {
                              int PIN = 5;
                              int radio_code = 0;
                              int old_BL = 0;
                              int new_BL = 0;
                              char old_str[10] ;
                              const char * sensor_loc ;
                              const char * sensor_type ;
                              // log
                              struct tm * timeinfo;
                              char timestamp_str[20] ;
                              char localtime_s[20] ;
                              char evnt_str[50] ;
                          
                              // capteurs BL
                              int BL_plein = 5592332 ;
                              int BL_vide  = 5592323 ;
                              // capteurs DI
                              int DI0 = 1381717 ;
                              int DI1 = 7673173 ;
                              // capteurs Sonnette
                              int BPSO = 13487999 ;
                          
                              // les fichiers
                              FILE *file_BL;
                              FILE *file_ALARM;
                              FILE *file_SMS;
                              FILE *file_TEST;
                              FILE *file_DI;
                              FILE *file_SO;
                          
                              // taille de file_ALARM
                              //int file_ALARM_size = 0;
                              int file_ALARM_size;
                              int file_DI_size;
                              int file_SO_size;
                              // nanosleep
                              struct timespec delay;
                              delay.tv_sec =0 ;
                          //  delay.tv_nsec =  100000000L; // tts les 1/10 sec (10/s)
                          //  delay.tv_nsec =  200000000L; // tts les 1/5 sec (5/s)
                          //  delay.tv_nsec =  250000000L; // tts les 1/4 sec (4/s)
                              delay.tv_nsec =  330000000L; // tts les 1/3 sec (3/s)
                          //  delay.tv_nsec =  500000000L; // tts les 1/2 sec (2/s)
                          //  delay.tv_nsec = 1000000000L; // tts les 1 sec (1/s)
                          
                              if(wiringPiSetup() == -1) {
                                  if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {// Ecrire erreur dans le log
                                      time_t now;
                                      time(&now);
                                      strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                      sprintf(evnt_str,"%s : Erreur de lancement \n", timestamp_str); // prep ligne --> evnt_str
                                      fputs(evnt_str, file_TEST);
                                      fclose(file_TEST);
                                  }
                                  exit(9);
                              }
                          
                              mySwitch = RCSwitch();
                              mySwitch.enableReceive(PIN);
                          
                              // lecture de l'etat initial de la boite aux lettres
                              if((file_BL = fopen("/home/www/logs/BL-state.txt", "r")) != NULL) {
                                  fgets( old_str,10, file_BL );
                                  if (strstr(old_str,"PLEIN")!=NULL) {
                                      old_BL=BL_plein;
                                  }
                                  if (strstr(old_str,"VIDE")!=NULL) {
                                      old_BL=BL_vide;
                                  }
                                  fclose(file_BL);
                                  if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {// Ecriture dans le fichier de log
                                      time_t now;
                                      time(&now);
                                      strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                      sprintf(evnt_str,"%s : Etat initial BL : %d \n", timestamp_str, old_BL); // prep ligne --> evnt_str
                                      fputs(evnt_str, file_TEST);
                                      fclose(file_TEST);
                                  } // Fin ecriture dans fichier de log
                              }
                              else {// echec de l'ouverture du fichier BL-state.txt
                                  if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {// Ecriture dans le fichier de log
                                      time_t now;
                                      time(&now);
                                      strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                      sprintf(evnt_str,"%s : Erreur lecture etat initial BL \n", timestamp_str); // prep ligne --> evnt_str
                                      fputs(evnt_str, file_TEST);
                                      fclose(file_TEST);
                                  } // Fin ecriture dans fichier de log
                                  exit(9);// On quitte avec un code 9
                              } // Fin de la lecture de l'etat initial de la boite aux lettres
                          
                          /* ICI Commence la boucle d'attente et de traitement */
                              while(true) {
                                  if (mySwitch.available()) {
                                      radio_code = mySwitch.getReceivedValue();
                                      if (radio_code != 0) { // on a recu un code
                                          if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {//Ecriture dans les logs
                                              time_t now;
                                              time(&now);
                                              strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                              sprintf(evnt_str,"%s : Code radio %d \n", timestamp_str, radio_code); // prep ligne --> evnt_str
                                              fputs(evnt_str, file_TEST);
                                              fclose(file_TEST);
                                          }// Fin ecriture dans les logs
                          
                                          // Occupons nous du message radio
                                          switch(radio_code){ // on cherche a quel message et quel emplacement correspond le code recu
                                                  case BL_plein :
                                                      if((file_BL = fopen("/home/www/logs/BL-state.txt", "r+")) != NULL) {
                                                          fputs("PLEIN", file_BL);
                                                          old_BL=radio_code;
                                                          fclose(file_BL);
                                                      }
                                                  break;
                                                  case BL_vide : 
                                                      if((file_BL = fopen("/home/www/logs/BL-state.txt", "r+")) != NULL) {
                                                          fputs("VIDE ", file_BL);
                                                          old_BL=radio_code;
                                                          fclose(file_BL);
                                                      }
                                                  break;
                                                  case BPSO:
                                                      // Sonnette
                                                      // Capture des codes dans fichier SO-state.txt 
                                                      // Ecriture du fichier SO-state
                                                      if((file_SO = fopen("/home/www/logs/SO-state.txt", "w")) != NULL) {
                                                          fputs("Dring", file_SO);
                                                          fclose(file_SO);
                                                          // Envoie de mail avec gmail.pi
                                                          system("python /home/www/py/gmail.py");
                                                      }
                                                  break;
                                                  case DI0:
                                                      // detection incendie RDC
                                                      if((file_DI = fopen("/home/www/logs/DI-state.txt", "w")) != NULL) {
                                                          fputs("Feu RdeCh", file_DI);
                                                          sensor_loc="Incendie RdC";
                                                          sensor_type="detecteur";
                                                          fclose(file_DI);
                                                      }
                                                  break;
                                                  case DI1:
                                                      // detection incendie Etage
                                                      if((file_DI = fopen("/home/www/logs/DI-state.txt", "w")) != NULL) {
                                                          fputs("Feu Etage", file_DI);
                                                          sensor_loc="Incendie Etage";
                                                          sensor_type="detecteur";
                                                          fclose(file_DI);
                                                      }
                                                  break;
                                                  case 5592320 :
                                                      sensor_loc="Garage";
                                                      sensor_type="contact";
                                                      break;
                                                  case 5592404 :
                                                      sensor_loc="Salon";
                                                      sensor_type="radar";
                                                      break;
                                                  case 5592405 :
                                                      sensor_loc="Sejour";
                                                      sensor_type="radar";
                                                      break;
                                                  case 5592341 :
                                                      sensor_loc="Entree";
                                                      sensor_type="radar";
                                                      break;
                                                  case 5592389 :
                                                      sensor_loc="Chambre";
                                                      sensor_type="radar";
                                                      break;
                                                  case 5592149 :
                                                      sensor_loc="Atelier";
                                                      sensor_type="radar";
                                                      break;
                                                  case 5591381 :
                                                      sensor_loc="Cuisine";
                                                      sensor_type="radar";
                                                      break;
                                                  default: 
                                                      sensor_loc="";
                                                      sensor_type="";
                                                      break;
                                                  }
                          
                                              // Remplissage fichier incidents Detecteur Incendie
                          
                          /* NE FAIT PAS l'ALERTE SMS pour l'instant, à conditionner par le type de l'alarme, et necessite de recuperer le lieu
                                          if((file_ALARM = fopen("/home/www/logs/ALARM-cumul.txt", "a+")) != NULL) {
                                                  // le log
                                                  time_t now;
                                                  time(&now);
                                                  strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                                  sprintf(evnt_str,"%s | ALARME detecteur %s\n", timestamp_str, sensor_loc); // prep ligne --> evnt_str
                                                  fputs(evnt_str, file_ALARM);
                                                  file_ALARM_size = ftell(file_ALARM);
                                                  // Fin Remplissage fichier incidents Detecteur Incendie
                          
                                                  // log pour envoi SMS
                                                  if((file_SMS = fopen("/home/www/logs/ALARM-SMS.txt", "a+")) != NULL) {
                                                      fputs(evnt_str, file_SMS);
                                                      fclose(file_SMS);
                                                      }
                                                  // envoi SMS si file_DI >= 300
                                                  if (file_DI_size>=300) {
                                                      system("python /home/www/py/SMS2send.py  >> /home/www/logs/SMS.log & ");
                                                      }
                                                  fclose(file_DI);
                                          }
                                           * FIN ALARME INCENDIE SMS */
                                          // Fin envoi SMS Detecteur Incendie
                          
                                      /* ne fait pas le log d'alarme car ne sait pas ou est l'alerte
                                          // Alarmes
                                          if(file_ALARM = fopen("/home/www/logs/ALARM-state.txt","r")) { // alarme active seulement si ALARM-state.txt existe
                                              fclose(file_ALARM);                     
                                              if (sensor_loc!="") {
                                                  if((file_ALARM = fopen("/home/www/logs/ALARM-state.txt", "a+")) != NULL) {
                                                      // le log
                                                      time_t now;
                                                      time(&now);
                                                      strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                                      sprintf(evnt_str,"%s | ALARME capteur %s\n", timestamp_str, sensor_loc); // prep ligne --> evnt_str
                                                      fputs(evnt_str, file_ALARM);
                                                      file_ALARM_size = ftell(file_ALARM);
                                                      // log pour envoi SMS
                                                      if((file_SMS = fopen("/home/www/logs/ALARM-SMS.txt", "a+")) != NULL) {
                                                          fputs(evnt_str, file_SMS);
                                                          fclose(file_SMS);
                                                      }
                                                      // declenchement sirene et envoi SMS si file_ALARM >= 300 ou si sensor_type=contact
                                                      if (file_ALARM_size>=300) {
                                                          system("python /home/www/py/SMS2send.py  >> /home/www/logs/SMS.log & ");
                                                          system("python /home/www/py/Expander-set.py A 2 close 60 & ");
                                                      }
                                                      fclose(file_ALARM);
                                                      // declenchement buzzer (GPA4)
                                                      if (sensor_loc=="Garage") {
                                                          system("python /home/www/py/Expander-set.py A 4 close 30 & ");
                                                      }
                                                  }
                                              }
                                          } // fin alarmes
                                          */
                                      }
                                      mySwitch.resetAvailable();
                                  } // fin mySwitch.available
                                  //sleep(1);
                                  //usleep(50000); // microsecond
                                  nanosleep(&delay, NULL); // nanosecond
                              } // fin infinite loop
                              exit(9);
                          } // fin main
                          • [^] # Re: reflexion de base

                            Posté par . Évalué à 1.

                            Bonsoir NeoX et félicitation pour ce travail

                            Concernant les alertes SMS ça fonctionnais , je recevais les alertes distincte pour chaque détecteurs d'alarme ,de DI et de mise en Marche et Arret de l'alarme avec l'heure. c'est le fichier ALARM-state.txt ou DI-state.txt qui se rempli et qui déclenche l'envoie des SMS avec SMS2send.py .Une fois le SMS envoyé le fichier ALARM-state.txt ou DI-state.txt est vidé par SMS2send.py et j'ai une trace de ce qui as été envoyé avec le fichier SMS.log
                            14/08/14 12:44-Activation de l'Alarme (Clavier)
                            01/08/14 16:29-ALARME capteur Chambre
                            01/08/14 16:29-ALARME capteur Cuisine
                            01/08/14 16:30-ALARME capteur Salon
                            20/08/14 09:01-Desactivation de l'Alarme (PiHome)
                            SMS envoye a +336000000

                            Pour les autres fichiers Log

                            Dans RADIO_TEST.log il y a tout les codes que capte le récepteur 433 Mhz 24/24( c'est pour tester le bon fonctionnement de mes émetteurs )
                            03/01/15 06:21:22 : Code radio 5592341
                            03/01/15 06:21:26 : Code radio 5592320
                            03/03/15 03:02:17 : Etat initial BL : 5592323

                            Dans ALARM.log il y a toutes les Marches/Arrêts de l'alarme Intrusion.
                            21/12/14 11:26:44 : Activation de l'Alarme (PiHome)
                            21/12/14 11:28:11 : Desactivation del'Alarme PiHome)
                            29/12/14 17:41:08 : Desactivation del'AlarmeClavier)
                            06/01/15 18:03:28 : Activation de l'Alarme (Clavier)

                            Dans ALARM-cumul.txt il ya toutes les déclenchement de détecteur alarmes ainsi que la DI. ( je recupere les données de ce fichier sur une page Html)

                            27/12/14 16:09:37 | ALARME capteur Garage
                            27/12/14 16:19:20 | ALARME detecteur Incendie RdC
                            27/12/14 16:09:23 | ALARME capteur Atelier
                            18/01/15 20:37:09 | ALARME detecteurIncendie Etage

                            Pour la sonnette je n'ai plus besoin du fichier SO-state.txt. c’était ma première idée et ça ne me sert pas .

                            // Sonnette Capture des photos depuis camera IP Nord
                            if (radio_code==BPSO){system("python /home/www/py/gmail.py");
                            }

                            • [^] # Re: reflexion de base

                              Posté par . Évalué à 1.

                              Juste pour info j'ai essayé de compiler le fichier , il y a des erreurs .

                              RFSniffer.cpp: In function âint main()â:
                              RFSniffer.cpp:119:30: error: âBL_pleinâ cannot appear in a constant-expression
                              RFSniffer.cpp:126:30: error: âBL_videâ cannot appear in a constant-expression
                              RFSniffer.cpp:133:30: error: âBPSOâ cannot appear in a constant-expression
                              RFSniffer.cpp:144:30: error: âDI0â cannot appear in a constant-expression
                              RFSniffer.cpp:153:30: error: âDI1â cannot appear in a constant-expression
                              : recipe for target 'RFSniffer.o' failed
                              make: *** [RFSniffer.o] Error 1

                              • [^] # Re: reflexion de base

                                Posté par . Évalué à 3.

                                meaculpa, j'utilise les Variables au lieu des Valeurs dans les cases (pour remplacer les multiples if).

                                avec ce code, ca doit compiler,
                                j'ai modifié la partie BPSO pour faire directement le lancement du script python

                                et toujours, pour l'instant, sans faire les alarmes SMS/mail

                                #include "RCSwitch.h"
                                #include <stdlib.h>
                                #include <stdio.h>
                                #include <string.h>
                                #include <unistd.h>
                                #include <time.h>
                                
                                RCSwitch mySwitch;
                                
                                //int main(int argc, char *argv[]) {
                                int main() {
                                    int PIN = 5;
                                    int radio_code = 0;
                                    int old_BL = 0;
                                    int new_BL = 0;
                                    char old_str[10] ;
                                    const char * sensor_loc ;
                                    const char * sensor_type ;
                                    // log
                                    struct tm * timeinfo;
                                    char timestamp_str[20] ;
                                    char localtime_s[20] ;
                                    char evnt_str[50] ;
                                
                                    // capteurs BL
                                    int BL_plein = 5592332 ;
                                    int BL_vide  = 5592323 ;
                                    // capteurs DI
                                    int DI0 = 1381717 ;
                                    int DI1 = 7673173 ;
                                    // capteurs Sonnette
                                    int BPSO = 13487999 ;
                                
                                    // les fichiers
                                    FILE *file_BL;
                                    FILE *file_ALARM;
                                    FILE *file_SMS;
                                    FILE *file_TEST;
                                    FILE *file_DI;
                                    FILE *file_SO;
                                
                                    // taille de file_ALARM
                                    //int file_ALARM_size = 0;
                                    int file_ALARM_size;
                                    int file_DI_size;
                                    int file_SO_size;
                                    // nanosleep
                                    struct timespec delay;
                                    delay.tv_sec =0 ;
                                //  delay.tv_nsec =  100000000L; // tts les 1/10 sec (10/s)
                                //  delay.tv_nsec =  200000000L; // tts les 1/5 sec (5/s)
                                //  delay.tv_nsec =  250000000L; // tts les 1/4 sec (4/s)
                                    delay.tv_nsec =  330000000L; // tts les 1/3 sec (3/s)
                                //  delay.tv_nsec =  500000000L; // tts les 1/2 sec (2/s)
                                //  delay.tv_nsec = 1000000000L; // tts les 1 sec (1/s)
                                
                                    if(wiringPiSetup() == -1) {
                                        if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {// Ecrire erreur dans le log
                                            time_t now;
                                            time(&now);
                                            strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                            sprintf(evnt_str,"%s : Erreur de lancement \n", timestamp_str); // prep ligne --> evnt_str
                                            fputs(evnt_str, file_TEST);
                                            fclose(file_TEST);
                                        }
                                        exit(9);
                                    }
                                
                                    mySwitch = RCSwitch();
                                    mySwitch.enableReceive(PIN);
                                
                                    // lecture de l'etat initial de la boite aux lettres
                                    if((file_BL = fopen("/home/www/logs/BL-state.txt", "r")) != NULL) {
                                        fgets( old_str,10, file_BL );
                                        if (strstr(old_str,"PLEIN")!=NULL) {
                                            old_BL=BL_plein;
                                        }
                                        if (strstr(old_str,"VIDE")!=NULL) {
                                            old_BL=BL_vide;
                                        }
                                        fclose(file_BL);
                                        if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {// Ecriture dans le fichier de log
                                            time_t now;
                                            time(&now);
                                            strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                            sprintf(evnt_str,"%s : Etat initial BL : %d \n", timestamp_str, old_BL); // prep ligne --> evnt_str
                                            fputs(evnt_str, file_TEST);
                                            fclose(file_TEST);
                                        } // Fin ecriture dans fichier de log
                                    }
                                    else {// echec de l'ouverture du fichier BL-state.txt
                                        if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {// Ecriture dans le fichier de log
                                            time_t now;
                                            time(&now);
                                            strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                            sprintf(evnt_str,"%s : Erreur lecture etat initial BL \n", timestamp_str); // prep ligne --> evnt_str
                                            fputs(evnt_str, file_TEST);
                                            fclose(file_TEST);
                                        } // Fin ecriture dans fichier de log
                                        exit(9);// On quitte avec un code 9
                                    } // Fin de la lecture de l'etat initial de la boite aux lettres
                                
                                /* ICI Commence la boucle d'attente et de traitement */
                                    while(true) {
                                        if (mySwitch.available()) {
                                            radio_code = mySwitch.getReceivedValue();
                                            if (radio_code != 0) { // on a recu un code
                                                if((file_TEST = fopen("/home/www/logs/RADIO_TEST.log", "a+")) != NULL) {//Ecriture dans les logs
                                                    time_t now;
                                                    time(&now);
                                                    strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                                    sprintf(evnt_str,"%s : Code radio %d \n", timestamp_str, radio_code); // prep ligne --> evnt_str
                                                    fputs(evnt_str, file_TEST);
                                                    fclose(file_TEST);
                                                }// Fin ecriture dans les logs
                                
                                                // Occupons nous du message radio
                                                switch(radio_code){ // on cherche a quel message et quel emplacement correspond le code recu
                                                    case 5592332 : // BL_Plein
                                                        if((file_BL = fopen("/home/www/logs/BL-state.txt", "r+")) != NULL) {
                                                            fputs("PLEIN", file_BL);
                                                            old_BL=radio_code;
                                                            fclose(file_BL);
                                                        }
                                                    break;
                                                    case 5592323 : // BL_vide 
                                                        if((file_BL = fopen("/home/www/logs/BL-state.txt", "r+")) != NULL) {
                                                            fputs("VIDE ", file_BL);
                                                            old_BL=radio_code;
                                                            fclose(file_BL);
                                                        }
                                                    break;
                                                    case 13487999 : // BPSO - Sonnette
                                                        // Envoie de mail avec gmail.pi
                                                        system("python /home/www/py/gmail.py");
                                                    break;
                                                    case 1381717 : // DI0 : detection incendie RDC
                                                        if((file_DI = fopen("/home/www/logs/DI-state.txt", "w")) != NULL) {
                                                            fputs("Feu RdeCh", file_DI);
                                                            sensor_loc="Incendie RdC";
                                                            sensor_type="detecteur";
                                                            fclose(file_DI);
                                                        }
                                                    break;
                                                    case 7673173 : //DI1 : detection incendie Etage
                                                        if((file_DI = fopen("/home/www/logs/DI-state.txt", "w")) != NULL) {
                                                            fputs("Feu Etage", file_DI);
                                                            sensor_loc="Incendie Etage";
                                                            sensor_type="detecteur";
                                                            fclose(file_DI);
                                                        }
                                                    break;
                                                    case 5592320 :
                                                        sensor_loc="Garage";
                                                        sensor_type="contact";
                                                    break;
                                                    case 5592404 :
                                                        sensor_loc="Salon";
                                                        sensor_type="radar";
                                                    break;
                                                    case 5592405 :
                                                        sensor_loc="Sejour";
                                                        sensor_type="radar";
                                                    break;
                                                    case 5592341 :
                                                        sensor_loc="Entree";
                                                        sensor_type="radar";
                                                    break;
                                                    case 5592389 :
                                                        sensor_loc="Chambre";
                                                        sensor_type="radar";
                                                    break;
                                                    case 5592149 :
                                                        sensor_loc="Atelier";
                                                        sensor_type="radar";
                                                    break;
                                                    case 5591381 :
                                                        sensor_loc="Cuisine";
                                                        sensor_type="radar";
                                                    break;
                                                    default: 
                                                        sensor_loc="";
                                                        sensor_type="";
                                                    break;
                                                }
                                
                                                // Remplissage fichier incidents Detecteur Incendie
                                
                                /* NE FAIT PAS l'ALERTE SMS pour l'instant, à conditionner par le type de l'alarme, et necessite de recuperer le lieu
                                                if((file_ALARM = fopen("/home/www/logs/ALARM-cumul.txt", "a+")) != NULL) {
                                                        // le log
                                                        time_t now;
                                                        time(&now);
                                                        strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                                        sprintf(evnt_str,"%s | ALARME detecteur %s\n", timestamp_str, sensor_loc); // prep ligne --> evnt_str
                                                        fputs(evnt_str, file_ALARM);
                                                        file_ALARM_size = ftell(file_ALARM);
                                                        // Fin Remplissage fichier incidents Detecteur Incendie
                                
                                                        // log pour envoi SMS
                                                        if((file_SMS = fopen("/home/www/logs/ALARM-SMS.txt", "a+")) != NULL) {
                                                            fputs(evnt_str, file_SMS);
                                                            fclose(file_SMS);
                                                            }
                                                        // envoi SMS si file_DI >= 300
                                                        if (file_DI_size>=300) {
                                                            system("python /home/www/py/SMS2send.py  >> /home/www/logs/SMS.log & ");
                                                            }
                                                        fclose(file_DI);
                                                }
                                                 * FIN ALARME INCENDIE SMS */
                                                // Fin envoi SMS Detecteur Incendie
                                
                                            /* ne fait pas le log d'alarme car ne sait pas ou est l'alerte
                                                // Alarmes
                                                if(file_ALARM = fopen("/home/www/logs/ALARM-state.txt","r")) { // alarme active seulement si ALARM-state.txt existe
                                                    fclose(file_ALARM);                     
                                                    if (sensor_loc!="") {
                                                        if((file_ALARM = fopen("/home/www/logs/ALARM-state.txt", "a+")) != NULL) {
                                                            // le log
                                                            time_t now;
                                                            time(&now);
                                                            strftime(timestamp_str, 80, "%d/%m/%y %H:%M:%S", localtime (&now)); // mef horodatage --> timestamp_str
                                                            sprintf(evnt_str,"%s | ALARME capteur %s\n", timestamp_str, sensor_loc); // prep ligne --> evnt_str
                                                            fputs(evnt_str, file_ALARM);
                                                            file_ALARM_size = ftell(file_ALARM);
                                                            // log pour envoi SMS
                                                            if((file_SMS = fopen("/home/www/logs/ALARM-SMS.txt", "a+")) != NULL) {
                                                                fputs(evnt_str, file_SMS);
                                                                fclose(file_SMS);
                                                            }
                                                            // declenchement sirene et envoi SMS si file_ALARM >= 300 ou si sensor_type=contact
                                                            if (file_ALARM_size>=300) {
                                                                system("python /home/www/py/SMS2send.py  >> /home/www/logs/SMS.log & ");
                                                                system("python /home/www/py/Expander-set.py A 2 close 60 & ");
                                                            }
                                                            fclose(file_ALARM);
                                                            // declenchement buzzer (GPA4)
                                                            if (sensor_loc=="Garage") {
                                                                system("python /home/www/py/Expander-set.py A 4 close 30 & ");
                                                            }
                                                        }
                                                    }
                                                } // fin alarmes
                                                */
                                            }
                                            mySwitch.resetAvailable();
                                        } // fin mySwitch.available
                                        //sleep(1);
                                        //usleep(50000); // microsecond
                                        nanosleep(&delay, NULL); // nanosecond
                                    } // fin infinite loop
                                    exit(9);
                                } // fin main
                                • [^] # Re: reflexion de base

                                  Posté par . Évalué à 1.

                                  Je viens de compiler le fichier super ça a fonctionné . Sinon si tu n'as pas tout compris concernant les fichier log n’hésite pas .

                                  • [^] # Re: reflexion de base

                                    Posté par . Évalué à 2.

                                    J'ai juste commenté la partie log car j'ai remanié la gestion des codes.
                                    et je penses que j'ai du faire sortir la gestion des alarmes/sms de la bonne section de code.

                                    faut que je regardes ou mettre la gestion des alarmes. pour que ce soit correct.

                                    Je te fais ca dans un moment.

                                    • [^] # Re: reflexion de base

                                      Posté par . Évalué à 2. Dernière modification le 09/03/15 à 23:01.

                                      J'y suis presque, mais je ne comprend pas la gestion des alarmes et SMS,

                                      en simplifiant le code, on voit que ca remplit :
                                      - ALARM-cumul.txt quand c'est un incendie
                                      - ALARM-SMS.txt avec l'info de l'alerte
                                      - ca envoie un SMS si file_DI_size (qui n'existe pas) est superieur à 300

                                      puis ca teste et ecrit dans
                                      - ALARM-state.txt s'il y a un emplacement (sensor_loc!="")
                                      - ALARM-SMS.txt avec l'info de l'alerte
                                      - ca envoie un SMS si file_ALARM_size est superieur à 300 et ca fait sonner une alarme "A 2 close 60"
                                      et si l'emplacement est le "garage"
                                      ca fait aussi sonner une alarme "A 4 close 30"

                                      • [^] # Re: reflexion de base

                                        Posté par . Évalué à 2.

                                        ok j'ai fait une pause, j'y suis revenu,
                                        je comprend maintenant le distingo entre "alarme incendie" et "autres alarmes"

                                        et dans autres alarmes, finalement on alerte immediatement si c'est le garage,
                                        sinon on attend que la file d'attente soit pleine à 300 pour envoyer et faire sonner.

                                        par contre l'envoi de SMS conditionné par un log >= 300
                                        l'idée est bonne mais il est vidé de temps en temps ce fichier ?
                                        sinon il va se remplir sans cesse,
                                        et quand la taille sera de 301, le SMS partira des la premiere alerte.

                                        • [^] # Re: reflexion de base

                                          Posté par . Évalué à 1.

                                          Ce n'est effectivement pas simple , il y a 3 types de détecteurs,
                                          Les détecteurs incendie .

                                          Les détecteurs d'alarme intrusion ( Capteur magnétique sur une porte dans le garage et Infra rouge pour les autres), tous ces capteurs envoie des codes 24 /24 quand on passe devant ou que l'on ouvre la porte dans le garage .Ça on ne peux rien y faire , c'est le matériel qui est comme ça.

                                          Le contact magnétique si on ouvre la porte il Émet environ 8 fois le code a suivre
                                          5592320 5592320 5592320 5592320 5592320 5592320 5592320 5592320 puis s’arrête d’émettre.
                                          Les capteurs Infra rouge font la même chose mais avec une trame plus longue environ 20 fois le code puis s’arrête d’émettre..

                                          Afin de limiter les fausses alarmes du au soleil ou aux parasites j'avais prévu une constance temps de quelques secondes.
                                          Pour faire simple une trame de code ne suffit pas pour déclencher la Sirene et l'envoi du SMS .

                                          Pour le contact de la porte dans le garage c'est différent une seule trame de code suffit .

                                          Mon clavier pour mettre l'alarme en marche ou arrêt est dans le garage a coté de cette fameuse porte , des fois ça m'arrive d'oublier que l'alarme est en marche donc
                                          A 4 close 30" c'est la tempo du buzzer qui sonne 30 secondes si je rentre en oubliant de couper l'alarme . ( Uniquement sur ce contact ) si l'alarme n'est pas mis a l’arrêt dans les 30 secondes il faut que la sirène s'enclenche pour 60 secondes A 2 close 60 ,ainsi que l'envoie de SMS. .

                                          Si l'alarme est en marche et qu’une personne est piégé par un infra rouge la sirène doit se déclenche instantanément ainsi que l'envoie de SMS.

                                          Sur cette dernière partie il y avait une boulette , le buzzer devait être actif sur tout les détecteurs .

                                          • [^] # Re: reflexion de base

                                            Posté par . Évalué à 3.

                                            je verrais ce que je peux faire avec le code restant à retravailler.
                                            probablement pas ce soir, mais ca va venir.

                                            • [^] # Re: reflexion de base

                                              Posté par . Évalué à 1.

                                              Bonsoir Néox , prend ton temps ,De mon coté ,la semaine , je n’ai pas beaucoup de temps libre.

                                            • [^] # Re: reflexion de base

                                              Posté par . Évalué à 1.

                                              Bonjour Néox , ça y est je suis en week end , donc je suis a ton écoute si tu as des questions, ou des points mal compris.

                                        • [^] # Re: reflexion de base

                                          Posté par . Évalué à 1.

                                          Bonjour Néox , je viens de tester la modif du code optimiser sur mon raspberry , malheureusement ,je ne trouve aucune baisse de consommation des ressources CPU ,et de temps en temps le fichier s'arrette , je me demande si ce n'est pas plus simple d’écouter les codes capter avec un arduino et ensuite exploité les codes.

                                          • [^] # Re: reflexion de base

                                            Posté par . Évalué à 3.

                                            pour l'instant ca reste un code qui "tourne en rond" et fait 3 tests par seconde.

                                            l'optimisation actuelle consiste à reecrire le code pour comprendre ce qu'il fait en rangeant les choses de maniere logique.
                                            1°) detection d'un code
                                            2°) tri sur le numero du code pour determiner les actions
                                            3°) action

                                            et en essayant d'eviter des doublons.

                                            ce qu'il faut verifier dans la doc par exemple, c'est à combien l'arduino rafraichit le code recu
                                            ca si les capteurs envoient 1 trame / sec, ca ne sert à rien de rafraichir 3x par seconde.

                                            • [^] # Re: reflexion de base

                                              Posté par . Évalué à 1.

                                              Je viens de faire un test je suis passé devant un un détecteur ,et voila ce qu'il y a d’écrit dans Radio_Test.log

                                              14/03/15 11:31:08 : Code radio 517593
                                              14/03/15 11:31:08 : Code radio 517593
                                              14/03/15 11:31:08 : Code radio 517593
                                              14/03/15 11:31:09 : Code radio 517593
                                              Donc en 1 seconde il y a plusieurs codes d’émis .
                                              Ça veux dire que l'on peux diminuer le nombre de tests par seconde.

                                              • [^] # Re: reflexion de base

                                                Posté par . Évalué à 3.

                                                voila deja un point d'amelioration,
                                                en commentant la ligne 53 (mettre // devant)
                                                delay.tv_nsec = 330000000L; // tts les 1/3 sec (3/s)

                                                et en decommentant la 55 (en enlevant le // devant)

                                                apres faudra recalculer les cycles d'alertes car on se basait sur X code / sec ou N lignes dans le logs

                                                • [^] # Re: reflexion de base

                                                  Posté par . Évalué à 1.

                                                  Rien a faire , ça ne baisse pas j'ai essayé 1/2 sec et 1 sec . Toujours pareil entre 35% et 30 %

                                                  Titre de l'image

                                                  • [^] # Re: reflexion de base

                                                    Posté par . Évalué à 3.

                                                    c'est normal, ton programme ne s'arrete jamais, et dans ta capture on voit 17.2% de WA (ioWait)
                                                    il attend donc beaucoup apres les disques et les entrées sorties.

                                                    le meme programme sur une machine autre qu'un raspberry fonctionne mieux ?

                                                    • [^] # Re: reflexion de base

                                                      Posté par . Évalué à 1.

                                                      Bon ben ce n'est pas gagné !!! il y a donc RFSniffer qui consomme ainsi que les écritures sur la carte SD

                                                      • [^] # Re: reflexion de base

                                                        Posté par . Évalué à 2.

                                                        ah ben deja, faudrait pas ecrire sur la carte SD mais dans un ramfs ou tmpfs,
                                                        ce serait plus rapide
                                                        mais on risque de perdre les logs en cas de reboot du boitier

                                                        ca limiterait les IOWait, et soulagerait ton CPU

                                                        pour ca, il faut creer un dossier en tmpfs,
                                                        il me semble qu'il suffit de faire un dossier tmpfs personnalisé comme indiqué ici
                                                        http://doc.ubuntu-fr.org/tmpfs

                                                        mount -t tmpfs tmpfs /le-point-de-montage/ -o size=16Mo

                                                        le point de montage sera alors l'emplacement ou tu vas mettre les logs des alarms

                                                        • [^] # Re: reflexion de base

                                                          Posté par . Évalué à 1.

                                                          Voila j'ai créer un dossier tmpfs de 16M.

                                                          home/www/montmpfs

                                                          Titre de l'image

                                                          • [^] # Re: reflexion de base

                                                            Posté par . Évalué à 2.

                                                            bien,
                                                            plus qu'a modifier le code pour creer/lire les fichiers logs, so-state, bl-state, di-state dans ce dossier,

                                                            recompiler et relancer le programme
                                                            voir si ca reduit les iowait et donc l'utilisation cpu

                                                            • [^] # Re: reflexion de base

                                                              Posté par . Évalué à 1.

                                                              Je me demande si on ne tourne pas en rond ! iowait bouge sans cesse , et je me demande si ce n'est pas du a autre chose, ( rafraichissement de ma page PHP ) j'ai bien peur que ça ne serve pas a grand chose de mettre les fichiers log sur tmpfs ,quand il n'y a pas de détection des codes ,rien n'est écrit et la consommation des ressources CPU est toujours entre 30 et 35 % ,j'ai réussi a la faire baisser a 25 en modifiant a 1/4 sec

                                                              • [^] # Re: reflexion de base

                                                                Posté par . Évalué à 2.

                                                                et ca dit quoi si tu passes de 3 tests par seconde (lignes 53)
                                                                à 1 test par seocnde (ligne 55)

                                                                elle sert à quoi ta page php par rapport au projet alarme/detecteur/radio

                                                                • [^] # Re: reflexion de base

                                                                  Posté par . Évalué à 1.

                                                                  ça empire ça monte a 80 % quand je regle sur 1/2 sec et a 90 % sur 1 sec.

                                                                  Mes pages Php me servent a gérer tout le reste ( Température , chauffage camera . c'est pour cela que je voudrais mettre toute la détection 433Mhz sur l'Arduino

                                                                  Titre de l'image

                                                                  • [^] # Re: reflexion de base

                                                                    Posté par . Évalué à 2.

                                                                    ça empire ça monte a 80 % quand je regle sur 1/2 sec et a 90 % sur 1 sec.

                                                                    ca empire en CPU ou en IOwait ?
                                                                    parce que normalement s'il ne fait plus la boucle qu'une seule fois par seconde au lieu de 3x par seconde,
                                                                    ca devrait etre plus econome.

                                                                    si ca empire, faut tester dans l'autre sens,
                                                                    passer de 3 par secondes à 4 voire 5 par secondes

                                                                    • [^] # Re: reflexion de base

                                                                      Posté par . Évalué à 1.

                                                                      J'ai tout tester depuis ce matin ,quand je suis a 1/10 sec le CPU descend a 28 %, mais bien sur je rate des codes , pour preuve , je n'ai pas reçu de code de BAL alors qu'il y avais du courrier Quand je Kill RFSniffer ,la charge CPU descend pour IOwait les valeurs sont semblable avec RFSniffer qui tourne ou est a l'arret ( Çà change tout le temps )
                                                                      iowait
                                                                      1,83
                                                                      1,01
                                                                      1,13
                                                                      1,25
                                                                      1,09
                                                                      0,62
                                                                      0,64
                                                                      0,68
                                                                      0,96
                                                                      0,92
                                                                      1,01
                                                                      0,80
                                                                      1,00
                                                                      1,34
                                                                      1,11
                                                                      1,37
                                                                      0,87
                                                                      0,88
                                                                      2,36
                                                                      3,64
                                                                      3,00
                                                                      3,26
                                                                      3,30
                                                                      2,52
                                                                      2,38
                                                                      2,08
                                                                      2,18
                                                                      2,37
                                                                      1,68
                                                                      1,70
                                                                      1,74
                                                                      1,94
                                                                      1,76
                                                                      1,80
                                                                      2,60
                                                                      1,74
                                                                      1,69
                                                                      1,30
                                                                      15,17
                                                                      1,92
                                                                      1,42
                                                                      2,23
                                                                      2,89

                                                                      • [^] # Re: reflexion de base

                                                                        Posté par . Évalué à 2.

                                                                        ok donc les iowait c'est pas rfsniffer

                                                                        par contre je ne comprend pas, tu pars de 1/10sec, pour moi ca veut dire faire 1 test, toutes les 10 sec
                                                                        on a vu qu'en passant de 3 tests pour 1 seconde (intervalle de 330000 Nanoseconde) à 1 test par seconde, ca augmentait la charge,

                                                                        donc en passant à 1 test toutes les 10 sec, ca n'ira pas beaucoup mieux.

                                                                        d'ailleurs plutot que d'utiliser nanosleep, tu dois pouvoir utiliser la ligne sleep(1);
                                                                        pour lui dire de dormir 1 seconde entre chaque traitement
                                                                        sleep(2) pour dormir 2 secondes, etc…

                                                                        • [^] # Re: reflexion de base

                                                                          Posté par . Évalué à 1.

                                                                          Exact pour les iowait c'est pas rfsniffer

                                                                          Pourquoi lui dire de dormir dire de dormir 1 ou 2 secondes?

                                                                          • [^] # Re: reflexion de base

                                                                            Posté par . Évalué à 2.

                                                                            en general on fait dormir un process pour le faire attendre entre 2 actions,
                                                                            evitant aussi que le process prennent 100% du CPU meme s'il ne fait rien.

                                                                            si tu veux tu peux tester en commenant le sleep ou le nanosleep à la fin de ton code,

                                                                            • [^] # Re: reflexion de base

                                                                              Posté par . Évalué à 1.

                                                                              Bonjour Néox je viens de tester avec sleep(1)et tts les 1/3 sec , j'ai une toute petites amélioration CPU 27,0 % ,'ai aussi fait le test avec 1/2 et 1 sec la ce n'est pas bon je perd de temps en temps la reception des codes .
                                                                              Titre de l'image

                                                                              J'ai chercher partout sur le forum , et je ne trouve pas la possibilité de te parler en MP , Peux t’ont se parlez par mail ? car j'ai l'impression de passez pour un boulet ici .

  • # Code python

    Posté par . Évalué à 3. Dernière modification le 08/03/15 à 21:12.

    Pour ton code python, sauf erreur de ma part, ça pourrait se faire tout simplement comme ça je pense :

    import serial
    
    def action():
        print("hello world")
    
    ser = serial.Serial('/dev/ttyACM0', 9600)
    while 1 :
        line = ser.readline()
        if line=="35":
           action()
    end

    sinon si tu veux faire plus propre, tu peux utiliser la librairie Firmata qui va te permettre d'envoyer des messages au raspberry pi via le port série (avec un protocole fait pour ça), et de déclencher un callback. Mais ce sera un peu plus compliqué.

    sinon un exemple de communication arduino/raspberry pi pas mal ici

    • [^] # Re: Code python

      Posté par . Évalué à 1. Dernière modification le 14/03/15 à 18:52.

      Bonjour max22 , dans mon cas ,il faut faire simple ! il faut que le fichier python tourne sans arret et que je trouve une solution pour que la réception du code faite par l'arduino aille écrire un fichier txt sur le raspberry.

      Exemple je reçois le code 5592332 il faut que ça m’écrire PLEIN dans BL-state.txt.

  • # Version Python avec RF433Mhz sur l'arduino

    Posté par . Évalué à 3.

    #!/usr/bin/env python
    # -*- coding: latin-1 -*-
    
    import os
    import time
    
    import serial
    ser = serial.Serial('/dev/ttyACM0', 9600)
    
    # envoie les SMS et alarmes apres MAXLOG octet d'alerte
    # 4 codes = 172octets
    MAXLOG=300
    # DELAY entre 2 tours de boucle, en secondes, 
    # peut etre une fraction, exemple 0.5 secondes
    DELAY=1
    
    while 1 :
        radio_code=ser.readline()
        #radio_code=input("votre code ? ")
    
        ## L'action REELLE COMMENCE ICI
        sensor_loc=""
        sensor_type=""
    
        if radio_code != 0 : # on a recu un code
            file_TEST = open("/home/www/logs/RADIO_TEST.log", "a+")
            event=time.strftime("%d/%m/%y %H:%M:%S")+" : Code radio "+str(radio_code)+"\n"
            file_TEST.write(str(event))
            file_TEST.close()
            # Fin ecriture dans les logs
    
            # BL Pleine
            if radio_code == 5592332 :
                file=open("/home/www/logs/BL-state.txt", "r+")
                file.write("PLEIN")
                old_BL=radio_code
                file.close()
    
            # BL Vide
            if radio_code == 5592323 :
                file=open("/home/www/logs/BL-state.txt", "r+")
                file.write("VIDE ")
                old_BL=radio_code
                file.close()
    
            if radio_code == 13487999 : # BPSO - Sonnette
                # Envoie de mail avec gmail.pi
                # copier/coller le code python pour l'envoie d'email à partir du fichier : 
                os.system("python /home/www/py/gmail.py")
    
            # DI0 : detection incendie RDC
            if radio_code == 1381717 :
                file=open("/home/www/logs/DI-state.txt", "w")
                file.write("Feu RdeCh")
                sensor_loc="Incendie RdC"
                sensor_type="detecteur"
                file.close();
    
            if radio_code == 7673173 : #DI1 : detection incendie Etage
                file=open("/home/www/logs/DI-state.txt", "w")
                file.write("Feu Etage")
                sensor_loc="Incendie Etage"
                sensor_type="detecteur"
                file.close()
    
            if radio_code == 5592320 :
                sensor_loc="Garage"
                sensor_type="contact"
    
            if radio_code == 5592404 :
                sensor_loc="Salon"
                sensor_type="radar"
    
            if radio_code == 5592405 :
                sensor_loc="Sejour"
                sensor_type="radar"
    
            if radio_code == 5592341 :
                sensor_loc="Entree"
                sensor_type="radar"
    
            if radio_code == 5592389 :
                sensor_loc="Chambre"
                sensor_type="radar"
    
            if radio_code == 5592149 :
                sensor_loc="Atelier"
                sensor_type="radar"
    
            if radio_code == 5591381 :
                sensor_loc="Cuisine"
                sensor_type="radar"
    
            # Remplissage fichier incidents Detecteur Incendie
            if sensor_type == 'detecteur' :
                file_ALARM = open("/home/www/logs/ALARM-cumul.txt", "a+")
                # le log
                # mef horodatage --> timestamp_str
                event=time.strftime("%d/%m/%y %H:%M:%S")+" | ALARME detecteur "+sensor_loc+"\n" 
                file_ALARM.write(str(event))
                file_ALARM_size = os.path.getsize("/home/www/logs/ALARM-cumul.txt")
                file_ALARM.close()
                # Fin Remplissage fichier incidents Detecteur Incendie
    
                # log pour envoi SMS
                file_SMS = open("/home/www/logs/ALARM-SMS.txt", "a+")
                file_SMS.write(str(event))
                file_SMS.close();
    
                # envoi SMS si file_DI >= MAXLOG
                if file_ALARM_size >= MAXLOG :
                    # copier/coller ici le code contenu dans le fichier SMS2send.py
                    os.system("python /home/www/py/SMS2send.py  >> /home/www/logs/SMS.log & ");                 
    
                # Fin envoi SMS Detecteur Incendie
    
            # Autres Alarmes
            try:
                file_ALARM = open("/home/www/logs/ALARM-state.txt","r")
            except IOError:
                print "pas de fichier ALARM-state.txt"
            else :
                file_ALARM.close()
                if sensor_loc != "" :
                    file_ALARM = open("/home/www/logs/ALARM-state.txt","a+")
                    # le log
                    event=time.strftime("%d/%m/%y %H:%M:%S")+" | ALARME capteur "+sensor_loc+"\n" 
                    file_ALARM.write(str(event))
                    file_ALARM_size = os.path.getsize("/home/www/logs/ALARM-state.txt")
                    file_ALARM.close();
    
                    # log pour envoi SMS
                    file_SMS = open("/home/www/logs/ALARM-SMS.txt", "a+")
                    file_SMS.write(str(event))
                    file_SMS.close()
    
                    # declenchement sirene et envoi SMS si file_ALARM >= 300
                    if file_ALARM_size >= MAXLOG :
                        # copier/coller le code d'envoi de SMS et celui de Expander-set
                        os.system("python /home/www/py/SMS2send.py  >> /home/www/logs/SMS.log & ");
                        os.system("python /home/www/py/Expander-set.py A 2 close 60 & ");
    
                    # declenchement buzzer (GPA4) si sensor_loc=garage
                    if sensor_loc=="Garage" :
                        # copier/coller le code du Exapnder-set.py
                        os.system("python /home/www/py/Expander-set.py A 4 close 30 & ");
    
                    # fin autres alarmes
    
        # attend DELAY secondes avant de faire la prochaine boucle
        time.sleep(DELAY)
    • [^] # Re: Version Python avec RF433Mhz sur l'arduino

      Posté par . Évalué à 1.

      Bonsoir ce code a encore quelques petit probleme , je suis en train de le mettre au point avec Néox , quand il fonctionnera sans probleme je posterais la version finale

    • [^] # Re: Version Python avec RF433Mhz sur l'arduino

      Posté par . Évalué à 2.

      si je me trompe pas, radio_code est une chaine de caractères et elle est comparée avec un entier.
      il faudrait d'abord la transformer en entier.

      • [^] # Re: Version Python avec RF433Mhz sur l'arduino

        Posté par . Évalué à 3.

        on n'a pas fait de retour, mais l'aspect :

        chaine de caractere avec \n => entier sans \n
        a été traité,

        il reste à ce que bggwen teste plus en detail.
        par exemple ses codes sont emis plusieurs fois, meme pour une seule pression sur un bouton,
        il faut donc filtrer pour eviter d'avoir 25 SMS, ou 15 emails pour un seul appui.

        • [^] # Re: Version Python avec RF433Mhz sur l'arduino

          Posté par . Évalué à 1. Dernière modification le 20/03/15 à 17:59.

          Bonjour Après multiple tentative de réglage et avec l'aide de Néox voila le code fonctionnel

          #!/usr/bin/env python
          # -*- coding: latin-1 -*-
          
          # DEBUG active (1) ou desactive (0) les messages d'erreurs à l'ecran (ou dans nohup.out)
          DEBUG=0
          
          # LOG active (1) ou desactive (0) le log dans RADIO_TEST.log
          LOG=1
          
          import os
          import time
          
          import serial
          ser = serial.Serial('/dev/ttyACM0', 9600)
          
          # envoie les SMS et alarmes apres MAXLOG octet d'alerte
          # 4 codes = 172octets
          MAXLOG=10
          # DELAY entre 2 tours de boucle, en secondes, 
          # peut etre une fraction, exemple 0.5 secondes
          DELAY=1
          
          # MAXCODE definit le nombre maxi de code à laisser passer
          MAXCHRONO=20
          
          # initialisation des compteurs
          OLDCODE=0
          CHRONO=0
          
          while 1 :
              message=ser.readline()
              radio_code=int(message.rstrip())
              #radio_code=input("votre code ? ")
          
              ## L'action REELLE COMMENCE ICI
              sensor_loc=""
              sensor_type=""
          
                  CHRONO += 1
              if radio_code != 0 : # on recoit un code
                      if DEBUG :
                  print "=========="
                          print "Ancien/Nouveau code : "+str(OLDCODE)+"/"+str(radio_code)
                          print "compteur : "+str(CHRONO)+"/"+str(MAXCHRONO)
          
                      if ( OLDCODE == radio_code and CHRONO < MAXCHRONO ) : # un code deja recu, on laisse tomber
                          pass
                          print "code deja vu"
          
                      else :
                          CHRONO = 0
                          if DEBUG :
                              print " nouveau code, on reinitialise le compteur"
                          OLDCODE=radio_code 
                          event=time.strftime("%d/%m/%y %H:%M:%S")+" : Code radio >>"+str(radio_code)+"<<\n"
                  if LOG : 
                      file_TEST = open("/home/www/logs/RADIO_TEST.log", "a+")
                      file_TEST.write(str(event))
                      file_TEST.close()
                  if DEBUG :
                      print "==========\n"+str(event)
                  # Fin ecriture dans les logs
          
                  # BL Pleine
                  if radio_code == 55232 :
                      if DEBUG :
                          print "je dois ecrire >>PLEIN<< dans BL-state"
                      file=open("/home/www/logs/BL-state.txt", "r+")
                      file.write("PLEIN")
                      old_BL=radio_code
                      file.close()
          
                  # BL Vide
                  if radio_code == 5923 :
                      if DEBUG :
                          print "je dois ecrire >>VIDE << dans BL-state"
                      file=open("/home/www/logs/BL-state.txt", "r+")
                      file.write("VIDE ")
                      old_BL=radio_code
                      file.close()
          
                  if radio_code == 13499 : # Sonnette 
                      if DEBUG :
                          print "je dois envoyer un email avec gmail.py"
                      # Envoie de mail avec gmail.pi
                      # copier/coller le code python pour l'envoie d'email à partir du fichier : 
                      os.system("python /home/www/py/gmail.py")
          
                  # DI0 : detection incendie RDC
                  if radio_code == 1317 :
                      if DEBUG :
                          print "je dois ecrire >>Feu RDC<< dans DI-state"
                      file=open("/home/www/logs/DI-state.txt", "w")
                      file.write("Feu RdeCh")
                      sensor_loc="Incendie RdC"
                      sensor_type="detecteur"
                      file.close();
                  #DI1 : detection incendie Etage             
                  if radio_code == 7373 : 
                      if DEBUG :
                          print "je dois ecrire >>Feu Etage<< dans DI-state"
                      file=open("/home/www/logs/DI-state.txt", "w")
                      file.write("Feu Etage")
                      sensor_loc="Incendie Etage"
                      sensor_type="detecteur"
                      file.close()
          
                  if radio_code == 522 :
                      sensor_loc="Garage"
                      sensor_type="contact"
          
                  if radio_code == 5544 :
                      sensor_loc="Salon"
                      sensor_type="radar"
          
                  if radio_code == 5545 :
                      sensor_loc="Sejour"
                      sensor_type="radar"
          
                  if radio_code == 5231 :
                      sensor_loc="Entree"
                      sensor_type="radar"
          
                  if radio_code == 5989 :
                      sensor_loc="Chambre"
                      sensor_type="radar"
          
                  if radio_code == :3658
                      sensor_loc="Atelier"
                      sensor_type="radar"
          
                  if radio_code == 511 :
                      sensor_loc="Cuisine"
                      sensor_type="radar"
          
                  # Remplissage fichier incidents Detecteur Incendie
                  if sensor_type == 'detecteur' :
                      file_ALARM = open("/home/www/logs/ALARM-cumul.txt", "a+")
                      # le log
                      # mef horodatage --> timestamp_str
                      event=time.strftime("%d/%m/%y %H:%M:%S")+" | ALARME detecteur "+sensor_loc+"\n" 
                      if DEBUG :
                          print "je dois ecrire >>"+str(event).rstrip()+"<< dans ALARM-cumul.txt"
                      file_ALARM.write(str(event))
                      file_ALARM_size = os.path.getsize("/home/www/logs/ALARM-cumul.txt")
                      file_ALARM.close()
                      # Fin Remplissage fichier incidents Detecteur Incendie
          
                      if DEBUG :
                          print "je dois ecrire >>"+str(event).rstrip()+"<< dans ALARM-SMS.txt"
                      # log pour envoi SMS
                      file_SMS = open("/home/www/logs/ALARM-SMS.txt", "a+")
                      file_SMS.write(str(event))
                      file_SMS.close();
          
                      # envoi SMS si file_DI >= MAXLOG
                      if file_ALARM_size >= MAXLOG :
                          if DEBUG :
                              print "je dois envoyer un SMS si "+str(file_ALARM_size)+">="+str(MAXLOG)
                          # copier/coller ici le code contenu dans le fichier SMS2send.py
                          os.system("python /home/www/py/SMS2send.py  >> /home/www/logs/SMS.log & ")                      
                      # Fin envoi SMS Detecteur Incendie
          
                  # Autres Alarmes
                  try:
                      file_ALARM = open("/home/www/logs/ALARM-state.txt","r")
                  except IOError:
                      if DEBUG :
                          print "pas de fichier ALARM-state.txt"
                  else :
                      file_ALARM.close()
                      if sensor_loc != "" :
                          file_ALARM = open("/home/www/logs/ALARM-state.txt","a+")
                          # le log
                          event=time.strftime("%d/%m/%y %H:%M:%S")+" | ALARME capteur "+sensor_loc+"\n" 
                          if DEBUG :
                              print "je dois ecrire >>"+str(event).rstrip()+"<< dans ALARM-state.txt"
                          file_ALARM.write(str(event))
                          file_ALARM_size = os.path.getsize("/home/www/logs/ALARM-state.txt")
                          file_ALARM.close();
          
                          # log pour envoi SMS
                          if DEBUG :
                              print "je dois ecrire >>"+str(event).rstrip()+"<< dans ALARM-SMS.txt"
                          file_SMS = open("/home/www/logs/ALARM-SMS.txt", "a+")
                          file_SMS.write(str(event))
                          file_SMS.close()
          
                          # declenchement sirene et envoi SMS si file_ALARM >= 300
                          if file_ALARM_size >= MAXLOG :
                              if DEBUG :
                                  print "je dois envoyer un SMS si "+str(file_ALARM_size)+">="+str(MAXLOG)
                              # copier/coller le code d'envoi de SMS et celui de Expander-set
                              os.system("python /home/www/py/SMS2send.py  >> /home/www/logs/SMS.log & ")
                              if DEBUG :
                                  print "je dois declencher l'alarme"
                              os.system("python /home/www/py/Expander-set.py A 2 close 60 & ")
          
                          # declenchement buzzer (GPA4) si sensor_loc=garage
                          if sensor_loc=="Garage" :
                              if DEBUG :
                                  print "je dois declencher le buzzer du garage"
                              # copier/coller le code du Exapnder-set.py
                              os.system("python /home/www/py/Expander-set.py A 4 close 30 & ")
          
                          # fin autres alarmes
          
              # attend DELAY secondes avant de faire la prochaine boucle
              time.sleep(DELAY)

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.