NeoX a écrit 18127 commentaires

[^] # Re: Et avec un peu plus de précisions?

Posté par NeoX le 10 mars 2015 à 17:49. En réponse au message g4l : ''disk full" !!!!. Évalué à 2.

ca repond au moins à la question "y a personne qui utilise g4l ici ?"

faut croire que non,
peut-etre parce qu'on a eu les memes soucis que toi il y a des années,
on ne s'en souvient juste plus.

tu peux essayer clonezilla aussi,
qui permettrait de choisir de "cloner" une partition vers une image, une image vers une partition,
vers/depuis le reseau, etc.

on s'en sert au boulot en le demarrant depuis un serveur PXE,
tres pratique pour les machines de demo qu'on doit reinitialiser à la fin d'une presentation.
[^] # Re: reflexion de base

Posté par NeoX le 09 mars 2015 à 23:04. En réponse au message Fichier python pour lecture Arduino. É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 NeoX le 09 mars 2015 à 22:52. En réponse au message Fichier python pour lecture Arduino. É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 à 22:18. En réponse au message Fichier python pour lecture Arduino. É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: Et avec un peu plus de précisions?

Posté par NeoX le 09 mars 2015 à 21:58. En réponse au message g4l : ''disk full" !!!!. Évalué à 2.

apparemment il se vautre en passant au 2e split du fichier complet (sauvegarde-sdb2.001)

essaye en desactivant le "Image split mode"
en le mettant sur automatic, tu verras deja s'il va au bout.
[^] # Re: Premiers résultats

Posté par NeoX le 09 mars 2015 à 21:51. En réponse au message Salaire Paris bac+3 développeur. Évalué à 4.

Helas la regle du loyer <= ⅓ des revenus, ca vient d'une regle relativement simple pour vivre :
33% en logement
33% en alimentaire et frais variable
33% en loisir.

si tu as un salaire de 1875€, avec 1000€ de loyer,
il te reste 875€ pour manger, vivre, payer tes assurances, tes factures EDF/Telephone

dans un mois il y a 30 jours, à 20euros de nourriture/jour => 600euros depensé.
reste 275euros

impot sur le revenu (à partir de la 2e année) : environ 10% du revenu net mensuel => 187euros/mois
reste 88euros

taxe habitation (~1 mois de loyer à payer en octobre, ici 1000euros), soit 84euros/mois
reste 4euros

et on n'a pas encore payer, la facture EDF, l'assurance logement,

evidemment tu peux aussi manger des pates matin/midi/soir pour ne pas atteindre les 20euros/jours.
[^] # Re: Premiers résultats

Posté par NeoX le 09 mars 2015 à 21:42. En réponse au message Salaire Paris bac+3 développeur. Évalué à 2.

le site est bon,
sauf qu'on est maintenant plutot à 25% de charge salariale en France.

un salaire de 30K€ brut => 1875€ mensuel NET
[^] # Re: Loyer

Posté par NeoX le 09 mars 2015 à 21:39. En réponse au message Salaire Paris bac+3 développeur. Évalué à 2.

le 1% logement c'est aussi (surtout) pour la location,
les employés paient un loyer modéré, l'employeur paie l'autre partie
[^] # Re: Premiers résultats

Posté par NeoX le 09 mars 2015 à 21:38. En réponse au message Salaire Paris bac+3 développeur. Évalué à 3.

si tu viens occasionnellement (tu parles du train 1x par semaine)
alors c'est à la société de te fournir l'hotel le temps que tu es à paris.

on appelle ca un "deplacement professionel"
[^] # Re: résolue!!!

Posté par NeoX le 09 mars 2015 à 21:34. En réponse au message problème dell latitutude d610. Évalué à 2.

ce qui confirme l'histoire du firmware,
il a été chargé par windows,
tu rebootes, ca va marcher.

mais si tu eteins completement le PC tu auras peut-etre le meme probleme.
[^] # Re: Support deux écrans

Posté par NeoX le 09 mars 2015 à 21:32. En réponse au message [MATERIEL] Acheter un dual Screen. Évalué à 2.

Puisque pour 2 écrans et un pied on est largement plus chère que ce soit chez rueducommerce, amazon, …

possible, mais c'est moins multi-usage.

si tu veux changer un ecran, tu dois changer le pied,
alors que si tu prend le support d'un coté, les ecrans de l'autre,
tu pourras changer d'ecran dans 3 ans sans avoir à changer le pied.

[^] # Re: reflexion de base

Posté par NeoX le 09 mars 2015 à 21:28. En réponse au message Fichier python pour lecture Arduino. É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

# mon point de vue

Posté par NeoX le 09 mars 2015 à 14:20. En réponse au message Distribution de templates d'environnements propriétaires dans un projet sous licence libre. Évalué à 3.

1°)lire la licence du logiciel propritétaire qui te dira ce que tu peux (ou ne peux pas) faire

2°) si ce que tu appelles template, ce sont des fichiers de configurations,
au format texte, qui pourraient avoir été generés à la main,
et qui permettent juste de reimporter le projet dans le meme outil propriétaire chez un client qui voudrait recompiler le projet,
à mon avis, tu as le droit, sinon le code source perd de son interet.
[^] # Re: facile

Posté par NeoX le 09 mars 2015 à 10:40. En réponse au message TV connectée à Internet sous Linux.. Évalué à 2.

si le but c'est de branché le PC sur la TV, alors c'est juste le cable HDMI qu'il te faut,
tu en as peut-etre deja un avec ta box, avant d'acheter ca vaut le coup d'essayer

Je ne veux pas du tout avoir « plusieurs écrans branchés en même temps » o-: seulement pouvoir visionner sur ma TV des émissions diffusées sur Internet en HD.

et ta TV n'a pas de connexion RJ45 ou Wifi ?

car ce que tu t'appretes à faire, c'est utiliser tout ton PC sur la TV
donc le surf, les emails, les videos, les jeux, etc etc

[^] # Re: reflexion de base

Posté par NeoX le 09 mars 2015 à 00:20. En réponse au message Fichier python pour lecture Arduino. É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

# deux possibilités

Posté par NeoX le 08 mars 2015 à 22:14. En réponse au message Python et l'unicode. Évalué à 2.

solution simple

Ce sont des fichiers dont le nom est codé en iso8859-15 sur un OS en UTF-8…

en renommant le fichier en UTF-8
en meme temps utiliser des caracteres speciaux dans les noms de fichier, c'est pas cool quand meme

car comme tu le vois ici, c'est dependant du filesystem

solution plus complexe

revoir ton code pour que si l'erreur se presente tu refasses une tentative en ISO8859-1
# filaire ? mise à jour ?

Posté par NeoX le 08 mars 2015 à 19:44. En réponse au message problème dell latitutude d610. Évalué à 2. Dernière modification le 08 mars 2015 à 19:46.

Bienvenu dans le monde libre,
ou malheureusement certains contructeurs ne font leur boulot "que pour windows" et ne fournissent pas de pilotes libres pour leur materiel.

parfois il faut donc activer des bouts de firmwares non libres pour que certains materiels fonctionnent.

du coup, est-ce que ca marche en filaire ?
une fois installé tu as fais toutes les mises à jour ?
tu as activé les depots (non free chez debian par exemple) pour avoir les firmwares non libre par exemple.

sinon quelques infos pourraient nous aider, comme par exemple :
les linux que tu as essayé,

ce que disent les commandes :
ifconfig -a
rfkill list

il se passe quoi quand tu enclenches le bouton pour allumer/eteindre le wifi sur l'appareil
[^] # Re: Limitation de FAT32

Posté par NeoX le 08 mars 2015 à 19:39. En réponse au message g4l : ''disk full" !!!!. Évalué à 4.

au hasard, tu ne ferais une sauvegarde du disque vers une image,
plutot que d'une partition vers une image.

du coup tu ne cherches pas à sauvegarder 10Go, mais 10+200 sur une partition de 200
[^] # Re: reflexion de base

Posté par NeoX le 08 mars 2015 à 19:35. En réponse au message Fichier python pour lecture Arduino. É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: facile

Posté par NeoX le 08 mars 2015 à 18:50. En réponse au message TV connectée à Internet sous Linux.. Évalué à 4.

ca depend,
le windows+P sous windows, c'est pour ouvrir le selecteur d'ecran, dans le cas ou tu veux avoir plusieurs ecrans branchés en meme temps.

dans le cas ou tu veux branché ton ecran d'ordi ET ta TV, et pouvoir selectionner sur quel ecran tu veux afficher,
ben il faut ouvrir le gestionnaire d'ecran.

sur ubuntu (donc avec Unity) c'est dans le menu "reglage systeme" que tu as en haut à droite,
sous Kubuntu (donc KDE) il y a surement aussi un reglage d'ecran / reglage d'affichage, et peut-etre meme un raccourci clavier pour l'ouvrir directement.

dans un premier temps tu peux essayer en branchant seulement la TV pour voir si cela fonctionne.
[^] # Re: reflexion de base

Posté par NeoX le 08 mars 2015 à 18:41. En réponse au message Fichier python pour lecture Arduino. É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.
# facile

Posté par NeoX le 08 mars 2015 à 17:52. En réponse au message TV connectée à Internet sous Linux.. Évalué à 3.

d'apres le fabricant de ta machine
http://www.asus.com/fr/Motherboards/B85ME/

la carte mere dispose d'un port HDMI,
donc tu branches ta tour sur ta TV, via le cable HDMI
tu demarres ton PC

hop tu as ton ecran sur ta TV

ou alors je n'ai pas compris la question ?
[^] # Re: reflexion de base

Posté par NeoX le 08 mars 2015 à 17:49. En réponse au message Fichier python pour lecture Arduino. É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 NeoX le 08 mars 2015 à 17:22. En réponse au message Fichier python pour lecture Arduino. É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 NeoX le 08 mars 2015 à 16:52. En réponse au message Fichier python pour lecture Arduino. É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.

NeoX a écrit 18127 commentaires

solution simple

solution plus complexe