NeoX a écrit 18334 commentaires

parce qu'un navigateur web est disponible sur tous les terminaux
parce qu'un navigateur web ne necessite pas d'installation (souvent fournit par defaut sur une machine)
parce qu'ensuite, tu peux quand meme utiliser un client lourd, pour lui cibler un dosser local, qui sera synchroniser avec le serveur (dropbox, evernote, owncloud, et probablement cozycloud)

en fait y a pas,
tu avais 12.04, tu as mis à jour en 14.04
il n'y a rien qui reste de la 12.04

si vraiment tu veux purger un eventuel ancien noyau qui serait rester dans /boot :
- dans un terminal, tapes uname -a ca va te donner la version du noyau courant
- dans syaptique, supprimes les autres versions.

c'est tout.

j'avais pas été voir le detail, mais la photo principale montrait les ecrans bien collés,

et en effet, la fixation etant vesa 100x100mm, tu pourras changer d'ecran plus tard.

probalement aucune difference,
juste que la presentation entre g4l, clonezilla et partimage va etre differente,
l'integration aussi permettant ou non de realiser l'image correctement.

j'ai souvenir d'erreur de "clonage" car la partition windows etait mal demontée par exemple.
du coup clonezilla refusait de faire le backup, mais permetter de faire un chkdsk avant.

en france le net = brut - 22 à 25%
ca c'est dans ta poche

puis une fois par an l'etat te prend environ :
1 mois de salaire net pour l'impot sur le revenu ( pour un salaire de 35 à 40K€ brut)
1 mois de loyer pour la taxe d'habitation si tu es locataire

ces taxes peuvent etre mensualisées apres la premiere année,
c'est alors mensualisé sur 10 mois,
les 2 mois restant servant à regulariser si tu leur dois encore des sous.

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

sans aller jusqu'a ndiswrapper,
mettre à jour les programmes, et charger les paquets non-libres suffit parfois sur certaines distribs.

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.

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.

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"

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.

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.

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.

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

un salaire de 30K€ brut => 1875€ mensuel NET

le 1% logement c'est aussi (surtout) pour la location,
les employés paient un loyer modéré, l'employeur paie l'autre partie

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"

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.

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.

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

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.

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

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

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

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

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