Forum Programmation.python Fichier python pour lecture Arduino

Posté par b.gwen le 08 mars 2015 à 16:15. Licence CC By‑SA.

Étiquettes : aucune

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 NeoX le 08 mars 2015 à 16:19. É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 b.gwen le 08 mars 2015 à 16:39. Évalué à 1. Dernière modification le 08 mars 2015 à 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 NeoX le 08 mars 2015 à 16:52. É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 b.gwen le 08 mars 2015 à 17:18. Évalué à 1. Dernière modification le 08 mars 2015 à 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 NeoX le 08 mars 2015 à 17:22. É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 b.gwen le 08 mars 2015 à 17:32. Évalué à 1. Dernière modification le 08 mars 2015 à 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 NeoX le 08 mars 2015 à 17:49. É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 b.gwen le 08 mars 2015 à 18:12. É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 NeoX le 08 mars 2015 à 18:41. Évalué à 3. Dernière modification le 08 mars 2015 à 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 b.gwen le 08 mars 2015 à 19:13. Évalué à 1. Dernière modification le 08 mars 2015 à 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 NeoX le 08 mars 2015 à 19:35. Évalué à 3. Dernière modification le 08 mars 2015 à 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 b.gwen le 08 mars 2015 à 19:50. Évalué à 1. Dernière modification le 08 mars 2015 à 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 NeoX le 09 mars 2015 à 00:20. É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 b.gwen le 09 mars 2015 à 19:24. É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 b.gwen le 09 mars 2015 à 19:34. É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 NeoX le 09 mars 2015 à 21:28. É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 b.gwen le 09 mars 2015 à 22:04. É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 NeoX le 09 mars 2015 à 22:18. É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 NeoX le 09 mars 2015 à 22:52. Évalué à 2. Dernière modification le 09 mars 2015 à 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 NeoX le 09 mars 2015 à 23:04. É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 b.gwen le 10 mars 2015 à 01:36. É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 NeoX le 10 mars 2015 à 17:52. É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 b.gwen le 10 mars 2015 à 18:21. É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 b.gwen le 13 mars 2015 à 07:08. É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 b.gwen le 14 mars 2015 à 11:08. É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 NeoX le 14 mars 2015 à 11:17. É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 b.gwen le 14 mars 2015 à 11:36. É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 NeoX le 14 mars 2015 à 12:04. É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 b.gwen le 14 mars 2015 à 12:33. Évalué à 1.
        
        Rien a faire , ça ne baisse pas j'ai essayé 1/2 sec et 1 sec . Toujours pareil entre 35% et 30 %
        
        [^] # Re: reflexion de base
        
        Posté par NeoX le 14 mars 2015 à 13:02. É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 b.gwen le 14 mars 2015 à 13:19. É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 NeoX le 14 mars 2015 à 13:37. É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 b.gwen le 14 mars 2015 à 16:17. Évalué à 1.
        
        Voila j'ai créer un dossier tmpfs de 16M.
        
        home/www/montmpfs
        
        [^] # Re: reflexion de base
        
        Posté par NeoX le 14 mars 2015 à 17:15. É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 b.gwen le 14 mars 2015 à 17:49. É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 NeoX le 14 mars 2015 à 17:59. É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 b.gwen le 14 mars 2015 à 18:13. É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
        
        [^] # Re: reflexion de base
        
        Posté par NeoX le 14 mars 2015 à 19:44. É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 b.gwen le 14 mars 2015 à 20:16. É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 NeoX le 14 mars 2015 à 20:27. É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 b.gwen le 14 mars 2015 à 20:45. É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 NeoX le 15 mars 2015 à 00:28. É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 b.gwen le 15 mars 2015 à 08:36. É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 .
        
        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 .
        
        [^] # Re: reflexion de base
        
        Posté par NeoX le 15 mars 2015 à 13:25. Évalué à 2.
        
        j'ai ouvert un chan #rfsniff sur irc.freenode.net

# Code python

Posté par max22 le 08 mars 2015 à 21:11. Évalué à 3. Dernière modification le 08 mars 2015 à 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 b.gwen le 14 mars 2015 à 18:50. Évalué à 1. Dernière modification le 14 mars 2015 à 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 NeoX le 15 mars 2015 à 23:44. É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 b.gwen le 18 mars 2015 à 20:22. É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 max22 le 19 mars 2015 à 11:46. É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 NeoX le 19 mars 2015 à 13:32. É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 b.gwen le 20 mars 2015 à 17:56. Évalué à 1. Dernière modification le 20 mars 2015 à 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 à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.