Go Down

Topic: Thermostat à distance et + si...... (Read 2057 times) previous topic - next topic

FP24V

bonjour à tous:

je viens demander conseil et aide pour pouvoir aller plus loin sur mon projet de thermostat.

d'abord voici le lien qui parlait une peu de mon projet:

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1287925450

ensuite voici les codes que j'utilise dans leur intégrité ( en plusieurs morceau, c'est un peu chiant d'ailleurs):

code arduino:

Code: [Select]
//////////////////////////////////// les entrées sorties ////////////////////////////////////
int SB=1;                                           // pin sonde température sol
int SR=0;                                           // pin sonde température ambiance
int SW=2;                                           // pin sonde température exterieur
int TEM = 11;                                       // pin digital état arduino
int THA=8;                                          // pin digital état thermostat arudino
int R1=11000;                                       // valeur de la resistance fixe du pont diviseur en ohm

//////////////////////////////////// hyperterminal ou processing ////////////////////////////////////
int PROC=1;                                         // bascule entre processing et hyperterminal

//////////////////////////////////// gestion des messages hyperterminal ////////////////////////////////////
int CHAUF=0;                                        // message chauffage(hyperterminal)
int COM=0;                                          // tempo pour renvoie de mesure sur terminal
int INFO=0;                                         // message information état general(hyperterminal)
int MESU=0;                                         // message mesure(hyperterminal)
int REBO=0;                                         // message de retour au réglage par défaut(hyperterminal)
int TABL=0;                                         // message premiére ligne du tableau(hyperterminal)
int VERS=0;                                         // message version du programme (hyperterminal)
int WARM=0;                                         // message alarme(hyperterminal)

//////////////////////////////////// gestion du programe ////////////////////////////////////
int ARD;                                            // variable pour l'état thermostat par arduino
int DEPART=0;                                       // variable pour la présentation du tableau
int RUN=1;                                          // variable prise de control thermostat
int WAR=0;                                          // variable de l'alarme surchauffe

//////////////////////////////////// gestion de la sonde  intérieur ////////////////////////////////////
int PRT=0;                                          // Signe de la sonde intérieur
int RR1=27537;                                      // Résistance de la sonde mesure 1
int RR2=13731;                                      // Résistance de la sonde mesure 2  
int RR3=734;                                        // Résistance de la sonde mesure 3
float RT1=4;                                        // température mesure 1
float RT2=19.5;                                     // température mesure 2  
float RT3=92.8;                                     // température mesure 3
float RR=0;                                         // variable résistance sonde de témpérature intérieur
float RRB=0;                                        // variable signal sonde intérieur
const int numReadingsR = 10 ;                       // Nombre de relevés pour la moyenne signal
int readingsR [ numReadingsR ] ;                    // Variable lecture pour la sonde intérieur
int indexR = 0 ;                                    // position dans la création de la moyenne
int totalR = 0 ;                                    // Total en cours
int averageR = 0 ;                                  // La moyenne

//////////////////////////////////// gestion de la sonde  sol ////////////////////////////////////
int PBT=0;                                          // Signe de la sonde sol
int BR1=27275;                                      // Résistance de la sonde mesure 1
int BR2=13677;                                      // Résistance de la sonde mesure 2  
int BR3=721;                                        // Résistance de la sonde mesure 3
float BT1=4;                                        // température mesure 1
float BT2=19.5;                                     // température mesure 2  
float BT3=92.8;                                     // température mesure 3
float BR=0;                                         // variable résistance sonde de témpérature sol
float BRB=0;                                        // variable signal sonde intérieur
const int numReadingsB = 10 ;                       // Nombre de relevés pour la moyenne signal
int readingsB [ numReadingsB ] ;                    // Variable lecture pour la sonde sol
int indexB = 0 ;                                    // position dans la création de la moyenne
int totalB = 0 ;                                    // Total en cours
int averageB = 0 ;                                  // La moyenne


//////////////////////////////////// gestion de la sonde  exterieur ////////////////////////////////////
int PWT=0;                                          // Signe de la sonde exterieur
int WR1=28623;                                      // Résistance de la sonde mesure 1
int WR2=14287;                                      // Résistance de la sonde mesure 2  
int WR3=734;                                        // Résistance de la sonde mesure 3
float WT1=4;                                        // température mesure 1
float WT2=19.5;                                     // température mesure 2
float WT3=92.8;                                     // température mesure 3
float WR=0;                                         // variable résistance sonde de témpérature exterieur
float WRB=0;                                        // variable signal sonde exterieur
const int numReadingsW = 10 ;                       // Nombre de relevés pour la moyenne signal
int readingsW [ numReadingsW ] ;                    // Variable lecture pour la sonde sol
int indexW = 0 ;                                    // position dans la création de la moyenne
int totalW = 0 ;                                    // Total en cours
int averageW = 0 ;;                                  // La moyenne

//////////////////////////////////// gestion des températures ////////////////////////////////////
float CTT=-0.5;                                     // constante calcul degrés
float HSTA=1.5;                                     // variable Hysteresys ambiance
float HSTS=1.5;                                     // variable Hysteresys intérieur
float HSTG=2;                                       // variable Hysteresys global
float SDW=4;                                        // seuille de déclenchement surchauffe
float VTACD=22.0;                                   // variable température de base recherchée pour l'ambiance par defaut
float VTSCD=21;                                   // variable température de base recherchée pour la dalle par defaut
float VTAC=21; // variable température de base recherchée pour l'ambiance

float VTSC=21; // variable température de base recherchée pour la dalle

int VTSC2=VTSC;                                     // calcul de découpe pour le processing
int VTSC3=(VTSC-VTSC2)*100;                         // calcul de découpe pour le processing
float VTAmax=25;                                    // temperature max de l'ambiance
float VTAmin=15;                                    // temperature min de l'ambiance
float VTSmax=25;                                    // temperature max de la dalle
float VTSmin=19;                                    // temperature min de la dalle


void setup()
{
Serial.begin(9600);                                 //vitesse de communication
pinMode(THA,OUTPUT);                                //indication du type pin
pinMode(TEM,OUTPUT);                                //indication du type pin

//////////////////////////////////// gestion des moyennes ////////////////////////////////////
for ( int thisReadingW = 0 ; thisReadingW < numReadingsW ; thisReadingW ++ )
readingsW [ thisReadingW ] = 0 ;
for ( int thisReadingB = 0 ; thisReadingB < numReadingsB ; thisReadingB ++ )
readingsB [ thisReadingB ] = 0 ;
for ( int thisReadingR = 0 ; thisReadingR < numReadingsR ; thisReadingR ++ )
readingsR [ thisReadingR ] = 0 ;

}


2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

FP24V

Code: [Select]


void loop()
{
//////////////////////////////////// calcul de moyenne de la sonde intérieur ////////////////////////////////////
totalR = totalR - readingsR [ indexR ] ;            
readingsR [ indexR ] = analogRead ( SR ) ;   // read from the sensor:
totalR = totalR + readingsR [ indexR ] ;             // add the reading to the total:          
indexR = indexR + 1 ;                              // advance to the next position in the array:
if ( indexR >= numReadingsR )                      // if we're at the end of the array...
indexR = 0 ;                                      // ...wrap around to the beginning:
averageR = totalR / numReadingsR ;                  // calculate the average:  
RRB=averageR;

//////////////////////////////////// calcul de la température intérieur via stein hart, pont diviseur et gestion des caractéres pour le processing ////////////////////////////////////
RR=((R1*RRB)/(1023-RRB));  
double RY1=1/(RT1+273.15);
double RY2=1/(RT2+273.15);
double RY3=1/(RT3+273.15);
double RL1=log(RR1);
double RL2=log(RR2);
double RL3=log(RR3);
double RV2=(RY2-RY1)/(RL2-RL1);
double RV3=(RY3-RY1)/(RL3-RL1);
double RC=((RV3-RV2)/((RL3-RL2))*((1/(RL1+RL2+RL3))));
double RB=RV2-(RC*((RL1*RL1)+(RL1*RL2)+(RL2*RL2)));
double RA=RY1-((RB+(RL1*RL1)*RC)*RL1);
double RT=((1/(RA+(RB*log(RR))+(RC*((log(RR))*(log(RR))*(log(RR))))))-275.5);
int SPRT=RT*100;
int RT2=RT;
int RT3=(RT-RT2)*100;
if (RT3<0)
{RT3=RT3*(-1);}
if ((-1<RT2<1)&&(RT3<0))
{RT2=RT2*(-1);}

//////////////////////////////////// calcul de moyenne de la sonde exterieur ////////////////////////////////////
totalW = totalW - readingsW [ indexW ] ;            
readingsW [ indexW ] = analogRead ( SW ) ;   // read from the sensor:
totalW = totalW + readingsW [ indexW ] ;             // add the reading to the total:          
indexW = indexW + 1 ;                              // advance to the next position in the array:
if ( indexW >= numReadingsW )                      // if we're at the end of the array...
indexW = 0 ;                                      // ...wrap around to the beginning:
averageW = totalW / numReadingsW ;                  // calculate the average:
WRB=averageW;

//////////////////////////////////// calcul de la température exterieur via stein hart, pont diviseur et gestion des caractéres pour le processing ////////////////////////////////////
WR=((R1*WRB)/(1023-WRB));
double WY1=1/(WT1+273.15);
double WY2=1/(WT2+273.15);
double WY3=1/(WT3+273.15);
double WL1=log(WR1);
double WL2=log(WR2);
double WL3=log(WR3);
double WV2=(WY2-WY1)/(WL2-WL1);
double WV3=(WY3-WY1)/(WL3-WL1);
double WC=((WV3-RV2)/((WL3-WL2))*((1/(WL1+WL2+WL3))));
double WB=WV2-(WC*((WL1*WL1)+(WL1*WL2)+(WL2*WL2)));
double WA=WY1-((WB+(WL1*WL1)*WC)*WL1);
double WT=((1/(WA+(WB*log(WR))+(WC*((log(WR))*(log(WR))*(log(WR))))))-275.5);
int SPWT=WT*100;
int WT2=WT;
int WT3=(WT-WT2)*100;
if (WT3<0)
{WT3=WT3*(-1);}
if ((-1<WT2<1)&&(WT3<0))
{WT2=WT2*(-1);}

//////////////////////////////////// calcul de moyenne de la sonde sol ////////////////////////////////////
totalB = totalB - readingsB [ indexB ] ;            
readingsB [ indexB ] = analogRead ( SB ) ;   // read from the sensor:
totalB = totalB + readingsB [ indexB ] ;             // add the reading to the total:          
indexB = indexB + 1 ;                              // advance to the next position in the array:
if ( indexB >= numReadingsB )                      // if we're at the end of the array...
indexB = 0 ;                                      // ...wrap around to the beginning:
averageB = totalB / numReadingsB ;                  // calculate the average:
BRB=averageB;

//////////////////////////////////// calcul de la température exterieur via stein hart, pont diviseur et gestion des caractéres pour le processing ////////////////////////////////////
BR=((R1*BRB)/(1023-BRB));
double BY1=1/(BT1+273.15);
double BY2=1/(BT2+273.15);
double BY3=1/(BT3+273.15);
double BL1=log(BR1);
double BL2=log(BR2);
double BL3=log(BR3);
double BV2=(BY2-BY1)/(BL2-BL1);
double BV3=(BY3-BY1)/(BL3-BL1);
double BC=((BV3-RV2)/((BL3-BL2))*((1/(BL1+BL2+BL3))));
double BB=BV2-(BC*((BL1*BL1)+(BL1*BL2)+(BL2*BL2)));
double BA=BY1-((BB+(BL1*BL1)*BC)*BL1);
double BT=((1/(BA+(BB*log(BR))+(BC*((log(BR))*(log(BR))*(log(BR))))))-275.5);
int SPBT=BT*100;
int BT2=BT;
int BT3=(BT-BT2)*100;
if (BT3<0)
{BT3=BT3*(-1);}
if ((-1<BT2<1)&&(BT3<0))
{BT2=BT2*(-1);}

////////////////////////////////////Module message////////////////////////////////////
////////////////////////////////////VER début////////////////////////////////////
if (VERS==0&&PROC==0)  
 {
  Serial.println();
  Serial.println("==============================================");
  Serial.println("||Arduino THERMO CONTROL V2.0 du 20/10/2010||");
  Serial.println("==============================================");
  Serial.println();
  VERS=1;
 }
else{}
////////////////////////////////////VER fin////////////////////////////////////


////////////////////////////////////ALARME début////////////////////////////////////
if (WARM==1&&PROC==0)
 {
  Serial.println();
  Serial.println("=====================================================");
  Serial.println("||Coupure total d'urgence, surchauffe de l'ambiance||");
  Serial.println("=====================================================");
  Serial.println();
  WARM==0;
 }
else{}
////////////////////////////////////ALARME fin////////////////////////////////////

////////////////////////////////////ETAT début////////////////////////////////////
if (INFO==1&&PROC==0)
 {
  Serial.println();
  Serial.println();
  Serial.print("Alerte :");
  Serial.println(WAR);
  Serial.print("ARD :");
  Serial.println(ARD);
  Serial.print("Run :");
  Serial.println(RUN);
  Serial.print("Consigne dalle :");
  Serial.println(float(VTSC));
  Serial.print("consigne ambiance :");
  Serial.println(float(VTAC));
 
  Serial.print("Temperateure interieur :");
  Serial.print(double(RT));
  Serial.println(" degres");
  Serial.println();

  Serial.print("Temperateure exterieur :");
  Serial.print(double(WT));
  Serial.println(" degres");
  Serial.println();
  Serial.print("Temperateure sol :");
  Serial.print(double(BT));
  Serial.println(" degres");
  Serial.println();
  INFO=0;
 }
else{}
////////////////////////////////////ETAT fin////////////////////////////////////


////////////////////////////////////TABLEAU début////////////////////////////////////
if (TABL==1&&PROC==0)
 {
  Serial.println();
  Serial.print("|STA|");
  Serial.print("|STS|");
  Serial.print("|STE|");
  Serial.print("|   CS  |");
  Serial.print("|   CA  |");
  Serial.print("|  TA  |");
  Serial.print("|  TE  |");
  Serial.print("|  TS |");
  Serial.print("|  ARD|");
  Serial.println();
  TABL=0;
 }
else{}
////////////////////////////////////TABLEAU fin////////////////////////////////////

////////////////////////////////////MESURE début////////////////////////////////////
if (MESU==1&&PROC==0)
 {
  Serial.print(analogRead(SR));
  Serial.print(" ; ") ;
  Serial.print(analogRead(SB));
  Serial.print(" ; ") ;
  Serial.print(analogRead(SW));
  Serial.print(" ; ") ;
  Serial.print(VTSC);
  Serial.print(" ; ") ;
  Serial.print(VTAC);
  Serial.print(" ; ") ;
  Serial.print(double(RT));
  Serial.print(" ; ") ;
  Serial.print(double(WT));
  Serial.print(" ; ") ;
  Serial.print(double(BT));  
  Serial.print(" ; ") ;
  Serial.print(ARD) ;
  Serial.println(" ; ");
  MESU=0;
 }
else{}
////////////////////////////////////MESURE fin////////////////////////////////////

////////////////////////////////////retour début////////////////////////////////////
if (REBO==1&&PROC==0)
 {
  Serial.println();
  Serial.println("Retour au réglage par defaut");
  Serial.println("============================");
  Serial.println();
  REBO=0;
 }
else{}
////////////////////////////////////retour fin////////////////////////////////////

////////////////////////////////////ETAT CHAUFFAGE début////////////////////////////////////
if (CHAUF==1&&PROC==0)
 {
  Serial.print("Etat du chauffage Arduino :");
  if (ARD==1)
    {
     Serial.println("actif");
     Serial.println();
    }
   else
    {
     Serial.println("inactif");
     Serial.println();
    }
  CHAUF=0;
 }
else{}
////////////////////////////////////ETAT CHAUFFAGE fin////////////////////////////////////




////////////////////////////////////Module message////////////////////////////////////





if (PROC==1)
 {delay (1000);
 if (WT>=0)
 {PWT=1;}
 else{PWT=0;}
 if (RT>=0)
 {PRT=1;}
 else{PRT=0;}
 if (BT>=0)
 {PBT=1;}
 else{PBT=0;}
 
int SPVTSC=VTSC*100;  
int SPVTAC=VTAC*100;  
int VTAC2=VTAC;
int VTAC3=(VTAC-VTAC2)*100;
int VTSC2=VTSC;
int VTSC3=(VTSC-VTSC2)*100;
 
 
 
 
  Serial.print("A");
  Serial.print((SPWT));
  Serial.print(("B"));
  Serial.print((SPBT));
  Serial.print(("C"));
  Serial.print((SPRT));
  Serial.print(("D"));
  Serial.print((SPVTAC));
  Serial.print(("E"));
  Serial.print((SPVTSC));
  Serial.print(("F"));
  Serial.print((ARD));
  Serial.print(("G"));
  Serial.print((RUN));
  Serial.print(("H"));
  Serial.print((WARM));
  Serial.print(("I"));
  Serial.println();
}

2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

FP24V

Code: [Select]

 if ((RT>=VTAC+SDW)&&ARD==1)
 
   {WAR=1;}
 else {}
 
 if (WAR==1&&ARD==1)
    {
     WARM=1;
     INFO=1;
    }
 else{}

 if (WAR==1)
   {digitalWrite (TEM,LOW);
    delay(2000);
    digitalWrite (TEM,HIGH);
    delay(100);
    digitalWrite (TEM,LOW);
    delay(100);
    digitalWrite (TEM,HIGH);
    delay(100);
    digitalWrite (TEM,LOW);
    delay(100);
    digitalWrite (TEM,HIGH);
    delay(100);
    digitalWrite (TEM,LOW);
    delay(500);
    digitalWrite (TEM,HIGH);
    delay(700);
    digitalWrite (TEM,LOW);
    delay(500);
    digitalWrite (TEM,HIGH);
    delay(100);
    digitalWrite (TEM,LOW);
    delay(100);
    digitalWrite (TEM,HIGH);
    delay(100);
    digitalWrite (TEM,LOW);
    delay(100);
    digitalWrite (TEM,HIGH);
    delay(100);
    digitalWrite (TEM,LOW);
    delay(2000);
   }

 if(RUN==1)
  {
   COM=COM+1;
   if (COM==240)
     {
       COM=0;
       MESU=1;
     }
   else{}

   digitalWrite (TEM,HIGH);
   delay (250);
   if (ARD==1)
     {
       digitalWrite (TEM,LOW);
       delay(250);
       digitalWrite (TEM,HIGH);
     }
   else{}
   
  }
else if(RUN==0||WAR==1)
  {
   digitalWrite (TEM,LOW);
  }

if (DEPART==0)
 {
  INFO=1;
  TABL=1;
  MESU=1;  
  DEPART=1;
 }
else{}
if ((RT<=(VTAC-HSTA))&&(RUN==1)&&(ARD==0)&&(WAR==0))
            {
              digitalWrite (THA,HIGH);
              if (PROC==0)
                {
                 Serial.print("activation chauffage ambiance a ");
                 BRB=analogRead(SB);
                 BR=((11000*BRB)/(1023-BRB));
                 Serial.print(double(BT));
                 Serial.println(" degres");
                 Serial.println();
                }
              ARD=1;
            }
else{}


if (((RT>=VTAC)||WAR==1)&&(ARD==1))
            {
              digitalWrite (THA,LOW);
              if (PROC==0)
                {
                 Serial.print("desactivation chauffage ambiance a ");
                 BRB=analogRead(SB);
                 BR=((11000*BRB)/(1023-BRB));
                 Serial.print(double(BT));
                 Serial.println(" degres");
                 Serial.println();
                }
              ARD=0;
            }

if ((RUN==0)&&(ARD==1))
            {
              digitalWrite (THA,LOW);
              if (PROC==0)
                {
                 Serial.print("desactivation chauffage a ");
                 BRB=analogRead(SB);
                 BR=((11000*BRB)/(1023-BRB));
                 Serial.print(double(BT));
                 Serial.print(" degres");
                 Serial.println(" par arret programme par utilisateur ");
                 Serial.println();
                }
              ARD=0;
            }
else{}


 if (Serial.available() > 0)  
 {
   int v = Serial.read();
   if((v=='q')&&(VTAC>VTAmin))
     {
        VTAC-=0.5;
       if (PROC==0)
         {
          Serial.print("Ambiamce : ");
          Serial.println(float(VTAC));
         }
       
       
     }
   else if(v=='p')
     {PROC=1;}
   else if(v=='m')
     {PROC=0;}
   else if((v=='a')&&(VTAC<VTAmax))
    {
      VTAC+=0.5;
      if (PROC==0)
        {
         Serial.print("Ambiance : ");
         Serial.println(float(VTAC));
        }
    }
   else if((v=='j')&&(VTSC>VTSmin))
    {
      VTSC-=0.5;
      if (PROC==0)
        {
         Serial.print("Dalle : ");
         Serial.println(float(VTSC));
        }
    }
   else if((v=='u')&&(VTSC<VTSmax))
    {
      VTSC+=0.5;
      if (PROC==0)
        {
         Serial.print("Dalle : ");
         Serial.println(float(VTSC));
        }
    }
   else if(v=='r')
     {
      RUN=1;
      if (PROC==0)
        {
         Serial.println("controle par arduino actif");
         Serial.println("==========================");
        }
     }
   else if(v=='d')
     {
      WAR=0;
      VTSC=VTSCD;
      VTAC=VTACD;
      REBO=1;
      INFO=1;
      CHAUF=1;
      TABL=1;
      MESU=1;
      if (PROC==1)
        {WARM=0;}
     }
   
   else if(v=='f')
    {
      RUN=0;
      if (PROC==0)
        {
         Serial.println("controle par arduino inactif");
         Serial.println("============================");
        }
    }
   else if(v=='e')
    {
      INFO=1;
      CHAUF=1;
      TABL=1;
      MESU=1;
     
   
    }
 else{}
 
}
else{}
     
}



voilà pour l'arduino.

résumé et explication de son fonctionnement:

-l'arduino mesure la température sur 3 sonde
-il envoie les infos brut des sondes et convertit ainsi que des consignes et statut pour le processing dans un langage maison où les lettres sont juste des séparateur
-si l'on fait sur l'hypertherminal "m", il envoie toujours les infos mais exclusivement pour l'hypertherminal et en clair.
-les touches "a" et "q" font varier la consigne température ambiance
-les touches "u" et "j" font varier la consigne température sol (pas encore écrit dans le programme)
-les touches "r" et "f" sont la marche arrêt de la gestion du chauffage
-la touche "d" et la remise des paramétrés par défaut
-la touche "e" et la demande d'état
-la touche "p" et le changement de langage pour émettre pour le processing (langage utilisé dés le démarrage)
-l'arduino gère 2 sorties, un voyant de message et un relai pour activer le chauffage.
2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

FP24V

#3
Nov 13, 2010, 11:55 am Last Edit: Nov 13, 2010, 11:55 am by FP24V Reason: 1
le code du processing

Code: [Select]

//////////////////////////////////////////////gestion de la communication//////////////////////////////////////////////////////
import processing.serial.*;
Serial myPort;  // Create object from Serial class
//////////////////////////////////////////////gestion de la communication//////////////////////////////////////////////////////


//////////////////////////////////////////////gestion des couleurs//////////////////////////////////////////////////////
color off = color(0,0,0);
color on = color(84, 145, 158);
color colCourbe = color(100,100,255);
color colText = color(255,69,0);
color Vert= color(0,100,0);
color Vert2= color(0,255,0);
color Rouge=color(255,0,0);
color Rouge2=color(100,0,0);
color Bleu=color(100,100,255);
color Bleu2=color(0,0,255);
color Blanc=color(255,255,255);
//////////////////////////////////////////////gestion des couleurs//////////////////////////////////////////////////////


//////////////////////////////////////////////gestion des variables//////////////////////////////////////////////////////
int ARD;                                        //variable transmise ARD
int RT;                                         //Variable transmise RT
int RT2;                                        //Doublons de la variable transmise RT
int RT3;                                        //Doublons de la variable transmise RT
int WT;                                         //Variable transmise WT
int WT2;                                        //Doublons 1 de la variable transmise WT
int WT3;                                        //Doublons 2 de la variable transmise WT
int BT;                                         //Variable transmise BT
int BT2;                                        //Doublons 1 de la variable transmise BT
int BT3;                                        //Doublons 2 de la variable transmise BT
int RUN;                                        //Variable transmise RUN
int VTSC;                                       //Variable transmise VTSC
int VTSC2;                                      //Doublons 1 de la variable transmise VTSC
int VTSC3;                                      //Doublons 2 de la variable transmise VTSC
int VTAC;                                       //Variable transmise VTSC
int VTAC2;                                      //Doublons 1 de la variable transmise VTAC
int VTAC3;                                      //Doublons 2 de la variable transmise VTAC
int WARM;                                       //Variable transmise WARM
float RTM=150;                                      //Variable mappé progressive d'aprés RT
float WTM=150;                                      //Variable mappé progressive d'aprés WT
float BTM=150;                                      //Variable mappé progressive d'aprés BT
float VTACM;                                    //Variable mappé progressive d'aprés VTAC
float VTSCM;                                    //Variable mappé progressive d'aprés VTSC
float ARTM;                                     //Variable mappé d'aprés RT
float AWTM;                                     //Variable mappé d'aprés WT
float ABTM;                                     //Variable mappé d'aprés BT
float AVTACM;                                   //Variable mappé d'aprés VTAC
float AVTSCM;                                   //Variable mappé d'aprés VTSC
int RL=5;
int RE=1;
float RMIN;
float RMAX;
float WMIN;
float WMAX;
float BMIN;
float BMAX;
int MINMAX=1000;
int MINMAXE=0;

//////////////////////////////////////////////gestion des variables//////////////////////////////////////////////////////

void setup()
{
 size(560, 400);                               //Taille de l'écran
 String portName = Serial.list()[0];           //Listage interne des ports
 myPort = new Serial(this, "COM4", 9600);      //Sélection du port ainsi que de sa vitesse
 background(off);                              //Sélection du type d'arriére plan
}

void draw()
{
 PFont font1;                                  //initialisation de la police 1
 font1 = loadFont("Serif-14.vlw");                 //Chargement de la police 1
 PFont font2;                                  //initialisation de la police 2
 font2 = loadFont("Serif-30.vlw");               //Chargement de la police 2        
 
 textFont(font1);                              //Utilisation de la police 1
 

 
//////////////////////////////////////////////extraction des variables émises//////////////////////////////////////////////////////  
 String xString = myPort.readStringUntil('\n');  // lecture série jusqu'au saut de ligne
   if (xString != null)  // si la chaîne n'est pas vide
   {
   
         xString = trim(xString);  // on vire les éventuels espace devant et derrière au cas où...

         String getA = xString.substring(xString.indexOf("A")+1, xString.indexOf("B")); // on lit la sous chaîne juste après la lettre 'A' jusqu'à la lettre 'B'
       String getB = xString.substring(xString.indexOf("B")+1, xString.indexOf("C")); // on lit la sous chaîne juste après la lettre 'B' jusqu'à la lettre 'C'
       String getC = xString.substring(xString.indexOf("C")+1, xString.indexOf("D")); // on lit la sous chaîne juste après la lettre 'C' jusqu'à la lettre 'D'
       String getD = xString.substring(xString.indexOf("D")+1, xString.indexOf("E")); // on lit la sous chaîne juste après la lettre 'D' jusqu'à la lettre 'E'
       String getE = xString.substring(xString.indexOf("E")+1, xString.indexOf("F")); // on lit la sous chaîne juste après la lettre 'E' jusqu'à la lettre 'F'
       String getF = xString.substring(xString.indexOf("F")+1, xString.indexOf("G")); // on lit la sous chaîne juste après la lettre 'F' jusqu'à la lettre 'G'
       String getG = xString.substring(xString.indexOf("G")+1, xString.indexOf("H")); // on lit la sous chaîne juste après la lettre 'G' jusqu'à la lettre 'H'
       String getH = xString.substring(xString.indexOf("H")+1, xString.indexOf("I")); // on lit la sous chaîne juste après la lettre 'H' jusqu'à la lettre 'I'
     
       WT = Integer.parseInt(getA);                                                   //Stockage des données lu après la lettre 'A' jusqu'à la lettre 'B'
       BT = Integer.parseInt(getB);                                                   //Stockage des données lu après la lettre 'B' jusqu'à la lettre 'C'
       RT = Integer.parseInt(getC);                                                   //Stockage des données lu après la lettre 'C' jusqu'à la lettre 'D'
         VTAC = Integer.parseInt(getD);                                                 //Stockage des données lu après la lettre 'D' jusqu'à la lettre 'E'
       VTSC = Integer.parseInt(getE);                                                 //Stockage des données lu après la lettre 'E' jusqu'à la lettre 'F'
         ARD = Integer.parseInt(getF);                                                  //Stockage des données lu après la lettre 'F' jusqu'à la lettre 'G'
       RUN = Integer.parseInt(getG);                                                  //Stockage des données lu après la lettre 'G' jusqu'à la lettre 'H'
         WARM = Integer.parseInt(getH);                                                 //Stockage des données lu après la lettre 'H' jusqu'à la lettre 'I'
             
       ARTM=map(RT,1500,2500,0,300);                                                   //Mappage de RT sur ARTM
       AWTM=map(WT,-2000,4000,0,300);                                                  //Mappage de WT sur AWTM
       ABTM=map(BT,1700,2500,0,300);                                                   //Mappage de BT sur ARTM
       AVTACM=map(VTAC,1500,2500,0,300);                                               //Mappage de VTAC sur AVTACM
       AVTSCM=map(VTSC,1900,2500,0,300);                                               //Mappage de VTSC sur AVTSCM
       
       RT2=RT/100;
       RT3=RT-(RT2*100);
       WT2=WT/100;
       WT3=WT-(WT2*100);  
       BT2=BT/100;
       BT3=BT-(BT2*100);
       VTSC2=VTSC/100;
       VTSC3=VTSC-(VTSC2*100);
       VTAC2=VTAC/100;
       VTAC3=VTAC-(VTAC2*100);
   }
//////////////////////////////////////////////extraction des variables émises//////////////////////////////////////////////////////    

   
//////////////////////////////////////////////initialisation et régénration de la fenetre d'affichage principale//////////////////////////////////////////////////////
 stroke(off);  // défini la couleur du trait
 fill(off);    // défini la couleur de remplissage
 rect(0, 0, 1400, 800);
//////////////////////////////////////////////initialisation et régénration de la fenetre d'affichage principale//////////////////////////////////////////////////////  


//////////////////////////////////////////////initialisation et régénration de la fenetre d'affichage mesure//////////////////////////////////////////////////////  
 stroke(Vert2);  // défini la couleur du trait
 fill(off);    // défini la couleur de remplissage
 rect(10,35, 460, 240);
//////////////////////////////////////////////initialisation et régénration de la fenetre d'affichage mesure//////////////////////////////////////////////////////  

2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

FP24V

Code: [Select]

//////////////////////////////////////////////module pour l'affichage intérieure//////////////////////////////////////////////////////  
if ((RT>=1500)&&(RT<2500))
 {
  stroke(Vert2);  // défini la couleur du trait
  fill(off);    // défini la couleur de remplissage
  rect(15, 45, 300, 20);
  stroke(Vert);  // défini la couleur du trait
  fill(Vert);    // défini la couleur de remplissage
  if ((RTM>0)&&(RTM<300))
  {rect(15, 45, RTM, 20);
  stroke(Vert2);  // défini la couleur du trait
  fill(Vert2);    // défini la couleur de remplissage
  rect(15+RTM-5, 40,5, 30);}
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("Température intérieure ", 85, 60);
 }
else
 {
  stroke(Rouge);  // défini la couleur du trait
  fill(Rouge2);    // défini la couleur de remplissage
  rect(15, 45, 300, 20);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("Température intérieure hors plage", 55, 60);
 }
fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
text((RT2)+","+(RT3)+"°", 350, 60);
 
//////////////////////////////////////////////module pour l'affichage intérieure//////////////////////////////////////////////////////  


//////////////////////////////////////////////module pour l'affichage exterieure//////////////////////////////////////////////////////  
  if ((WT>=-2000)&&(WT<4000))
 {
  stroke(Vert2);  // défini la couleur du trait
  fill(off);    // défini la couleur de remplissage
  rect(15, 95, 300, 20);
  stroke(Vert);  // défini la couleur du trait
  fill(Vert);    // défini la couleur de remplissage
  if ((WTM>0)&&(WTM<300))
  {rect(15, 95, WTM, 20);
  stroke(Vert2);  // défini la couleur du trait
  fill(Vert2);    // défini la couleur de remplissage
  rect(15+WTM-5, 90,5, 30);}
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("Température exterieure ", 85, 110);
 }
else
 {
  stroke(Rouge);  // défini la couleur du trait
  fill(Rouge2);    // défini la couleur de remplissage
  rect(15, 95, 300, 20);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("Température exterieure hors plage", 55, 110);
 }
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text((WT2)+","+(WT3)+"°", 350, 110);
 
  stroke(Bleu2);  // défini la couleur du trait
  if (WT>400)
  {
  fill(off);// défini la couleur de remplissage
  }    
  else if(WT<400)
  {
   fill(Bleu);// défini la couleur de remplissage
  }    
  rect(440, 95, 20, 20);  

//////////////////////////////////////////////module pour l'affichage exterieure//////////////////////////////////////////////////////

//////////////////////////////////////////////module pour l'affichage sol//////////////////////////////////////////////////////
      if ((BT>=1700)&&(BT<2500))
 {
  stroke(Vert2);  // défini la couleur du trait
  fill(off);    // défini la couleur de remplissage
  rect(15, 145, 300, 20);
  stroke(Vert);  // défini la couleur du trait
  fill(Vert);    // défini la couleur de remplissage
  if ((BTM>0)&&(BTM<300))
  {rect(15, 145, BTM, 20);
  stroke(Vert2);  // défini la couleur du trait
  fill(Vert2);    // défini la couleur de remplissage
  rect(15+BTM-5, 140,5, 30);}
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("Température sol ", 85, 160);
 }
else
 {
  stroke(Rouge);  // défini la couleur du trait
  fill(Rouge2);    // défini la couleur de remplissage
  rect(15, 145, 300, 20);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("Température sol hors plage", 55, 160);
 }
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text((BT2)+","+(BT3)+"°", 350, 160);
//////////////////////////////////////////////module pour l'affichage sol//////////////////////////////////////////////////////

//////////////////////////////////////////////module pour l'affichage consigne ambiance//////////////////////////////////////////////////////
  stroke(Vert2);  // défini la couleur du trait
  fill(off);    // défini la couleur de remplissage
  rect(15, 195, 300, 20);
  stroke(Vert);  // défini la couleur du trait
  fill(Vert);    // défini la couleur de remplissage
  if ((VTACM>0)&&(VTACM<300))
  {rect(15, 195, VTACM, 20);
  stroke(Vert2);  // défini la couleur du trait
  fill(Vert2);    // défini la couleur de remplissage
  rect(15+VTACM-5, 190,5, 30);}
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("consigne ambiance ", 85, 210);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text(VTAC2+","+VTAC3+"°", 350, 210);
//////////////////////////////////////////////module pour l'affichage consigne ambiance//////////////////////////////////////////////////////
 
//////////////////////////////////////////////module pour l'affichage consigne sol//////////////////////////////////////////////////////
  stroke(Vert2);  // défini la couleur du trait
  fill(off);    // défini la couleur de remplissage
  rect(15, 245, 300, 20);
  stroke(Vert);  // défini la couleur du trait
  fill(Vert);    // défini la couleur de remplissage
  if ((VTSCM>0)&&(VTSCM<300))
  {rect(15, 245, VTSCM, 20);
  stroke(Vert2);  // défini la couleur du trait
  fill(Vert2);    // défini la couleur de remplissage
  rect(15+VTSCM-5, 240,5, 30);}
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("consigne sol ", 85, 260);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text(VTSC2+","+VTSC3+"°", 350, 260);
//////////////////////////////////////////////module pour l'affichage consigne sol//////////////////////////////////////////////////////
 
//////////////////////////////////////////////module pour l'état chauffage ambiance//////////////////////////////////////////////////////
  stroke(Rouge);  // défini la couleur du trait
  if (ARD==0)
  {
  fill(off);// défini la couleur de remplissage
  }    
  else if(ARD==1)
  {
   fill(Rouge2);// défini la couleur de remplissage
  }    
  rect(440, 195, 20, 20);
 
  stroke(Rouge);  // défini la couleur du trait
//////////////////////////////////////////////module pour l'état chauffage ambiance//////////////////////////////////////////////////////

//////////////////////////////////////////////module pour l'état chauffage sol//////////////////////////////////////////////////////
  stroke(Rouge);  // défini la couleur du trait
  fill(off);    // défini la couleur de remplissage
  rect(440, 245, 20, 20);
//////////////////////////////////////////////module pour l'état chauffage sol//////////////////////////////////////////////////////

//////////////////////////////////////////////module pour l'affichage des boutons +-//////////////////////////////////////////////////////
  textFont(font1);
  stroke(Blanc);  // défini la couleur du trait
  fill(off);    // défini la couleur de remplissage
  rect(500, 195, 20, 20);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("+ ", 507, 209);  
 
  stroke(Blanc);  // défini la couleur du trait
  fill(off);    // défini la couleur de remplissage
  rect(530, 195, 20, 20);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("- ", 537, 209);
 
  stroke(Blanc);  // défini la couleur du trait
  fill(off);    // défini la couleur de remplissage
  rect(500, 245, 20, 20);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("+ ", 507, 260);
 
  stroke(Blanc);  // défini la couleur du trait
  fill(off);    // défini la couleur de remplissage
  rect(530, 245, 20, 20);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte  
  text("- ", 537, 260);
//////////////////////////////////////////////module pour l'affichage des boutons +-//////////////////////////////////////////////////////

//////////////////////////////////////////////module pour l'affichage du bouton RUN//////////////////////////////////////////////////////
  stroke(Rouge);  // défini la couleur du trait
  if (RUN==0)
  {
  fill(off);// défini la couleur de remplissage
 
  }    
  else if(RUN==1)
  {
   fill(Rouge2);// défini la couleur de remplissage
  }    
  rect(20, 340, 70, 30);  
  textFont(font2);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("RUN ", 23, 365);
//////////////////////////////////////////////module pour l'affichage du bouton RUN//////////////////////////////////////////////////////

2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

FP24V

Code: [Select]

//////////////////////////////////////////////module pour l'affichage du bouton RESET//////////////////////////////////////////////////////
  stroke(Rouge);  // défini la couleur du trait
  fill(Bleu2);// défini la couleur de remplissage
  rect(100, 340, 100, 30);  
  textFont(font2);
  fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
  text("RESET ", 100, 365);
//////////////////////////////////////////////module pour l'affichage du bouton RESET//////////////////////////////////////////////////////

//////////////////////////////////////////////module gestion et affichage pour les mini et maxi//////////////////////////////////////////////////////
if (MINMAXE<MINMAX)
{MINMAXE=MINMAXE+1;

 RMAX=RT;
  WMAX=WT;
  BMAX=BT;
  RMIN=RT;
  WMIN=WT;
  BMIN=BT;}





else if (MINMAXE>=MINMAX)
{if (RT>RMAX)
 {RMAX=RT;}
 if (WT>WMAX)
 {WMAX=WT;}
 if (BT>BMAX)
 {BMAX=BT;}
 if(RT<RMIN)
 {RMIN=RT;}
 if(WT<WMIN)
 {WMIN=WT;}
 if(BT<BMIN)
 {BMIN=BT;}

textFont(font1);
fill(colText);  // la commande text utilise la couleur de remplissage (fill) pour dessiner le texte
text("intérieure", 20, 385);
text((RMIN/100)+"     "+(RMAX/100), 100, 385);
text("extérieure", 200, 385);
text((WMIN/100)+"     "+(WMAX/100), 280, 385);
text("sol", 380, 385);
text((BMIN/100)+"     "+(BMAX/100), 420, 385);}

//////////////////////////////////////////////module gestion et affichage pour les mini et maxi//////////////////////////////////////////////////////

//////////////////////////////////////////////module pour l'amortissement de l'affichage des baragraphe//////////////////////////////////////////////////////
if ((AWTM-WTM)>RL)
    {WTM=WTM+RE;}  
else if ((AWTM-WTM)<RL)
    {WTM=WTM-RE;}
// else if (((AWTM-WTM)>3)&&((AWTM-WTM)<3))
//     {WTM=AWTM;}
if ((ARTM-RTM)>RL)
    {RTM=RTM+RE;}  
else if ((ARTM-RTM)<RL)
    {RTM=RTM-RE;}
// else if (((ARTM-RTM)>3)&&((ARTM-RTM)<3))
//     {RTM=ARTM;}
if ((ABTM-BTM)>RL)
    {BTM=BTM+RE;}  
else if ((ABTM-BTM)<RL)
    {BTM=BTM-RE;}
// else if (((ABTM-BTM)>3)&&((ABTM-BTM)<3))
//     {BTM=ABTM;}
if ((AVTACM-VTACM)>RL)
    {VTACM=VTACM+RE;}  
else if ((AVTACM-VTACM)<RL)
    {VTACM=VTACM-RE;}
// else if (((AVTACM-VTACM)>3)&&((AVTACM-VTACM)<3))
//     {VTACM=AVTACM;}
if ((AVTSCM-VTSCM)>RL)
    {VTSCM=VTSCM+RE;}  
else if ((AVTSCM-VTSCM)<RL)
    {VTSCM=VTSCM-RE;}
// else if (((AVTSCM-VTSCM)>3)&&((AVTSCM-VTSCM)<3))
//     {VTSCM=AVTSCM;}

delay (10);  
//////////////////////////////////////////////module pour l'amortissement de l'affichage des baragraphe//////////////////////////////////////////////////////

//////////////////////////////////////////////intération avec le clavier//////////////////////////////////////////////////////  
 if(keyPressed)
  {
   myPort.write(key);
   delay(500);
  }
//////////////////////////////////////////////intération avec le clavier//////////////////////////////////////////////////////


}

//////////////////////////////////////////////intération avec la souris//////////////////////////////////////////////////////
void mouseClicked()

{
 if (500<mouseX&&mouseX<520&&195<mouseY&&mouseY<215)
 {myPort.write("a");}
 if (500<mouseX&&mouseX<520&&245<mouseY&&mouseY<265)
 {myPort.write("u");}
 if (530<mouseX&&mouseX<550&&195<mouseY&&mouseY<215)
 {myPort.write("q");}
 if (530<mouseX&&mouseX<550&&245<mouseY&&mouseY<265)
 {myPort.write("j");}
 
 
 if (100<mouseX&&mouseX<200&&340<mouseY&&mouseY<370)
 {myPort.write("d");}
 
 if(RUN==1)
 {
   if (20<mouseX&&mouseX<90&&340<mouseY&&mouseY<370)
  {myPort.write("f");}
 }
 else if(RUN==0)
 {
   if (20<mouseX&&mouseX<90&&340<mouseY&&mouseY<370)
  {myPort.write("r");}
 }
//////////////////////////////////////////////intération avec la souris//////////////////////////////////////////////////////  
 
}

2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

FP24V

#6
Nov 13, 2010, 12:10 pm Last Edit: Nov 13, 2010, 12:13 pm by FP24V Reason: 1
Ha oui quand même, pour trois sondes, ça fait pas mal de lignes, bon reprenons plus sérieusement,

j'aimerai des conseils simple et clair car bien que je sois fière de mes 2 PRG, je sais très bien que mon niveau ne vol pas haut et que j'ai du pas mal ...... pour arriver à ça, disons niveau débutant++. Mon anglais est honorables mais très peu technique

1- est t'il possible d'optimiser un peu les programmes, en terme de place et de rapidité??

2- lorsque j'utilise le processing, le pc monte très vite en température car il semblerais très solliciter, es ce normal??

3- est t'il possbile à l'arduino de lui faire écrire les relevés qu'il fait dans un fichier texte, une base de données sql serait top mais là je serai totalement largué. en ce moment en plus de géré la température, je lui fait faire des relevés, et si le pc plante je perds tous et ça me fait perdre dans l'étude du comportement.

4-je viens d'investir dans une module wifi pour l'arduino et je voudrai savoir comment je vai pouvoir le commander à distance via le processing.

merci d'avance pour votre aide et vos conseils
2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

Jean-François

Processing compile en Java.
Ce langage utilise toute la CPU qui lui est mise à disposition(ça peut aller jusqu'au plantage de l'ordi).
Donc, suivant l'ampleur de ton appli Processing, c'est normal que ton processeur chauffe.

Avec Processing, la fonction createWriter() te permet de créer un fichier et d'écrire dedans.
MacBook intel core 2 duo  os X snow Leopard 10.6<br/> eMac PPc G4  os X Leopard 10.5<br/>powerbook G4 os X Leopard 10.5
imac PPC G3 os X Pa

FP24V

merci pour l'écriture du fichier, ça va encore faire chauffer un peu plus le pc mais bon.
2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

Jean-François

Une chose encore, si tu as fais une interface graphique qui rafraichit l'affichage à chaque boucle, ça te ruine les ressources de ton processeur.

La solution c'est d'utiliser millis() pour faire un rafraichissement toutes les 0.04 secondes (25 fois par seconde pour éviter le scintillement).

Tu peux gagner jusqu'à 70% de ce que te consomme ton appli.
MacBook intel core 2 duo  os X snow Leopard 10.6<br/> eMac PPc G4  os X Leopard 10.5<br/>powerbook G4 os X Leopard 10.5
imac PPC G3 os X Pa

FP24V

merci de l'astuces, mais aprés quelque recherches et conseil, j'utilise plutot frameRate()  qui en plus de milis() me permet de dire combien de rafraîchissement par seconde je veux. ce qui me permet en plus d'avoir des boucles de durée définis par une base de temps que par la vitesse du cpu, le pc dit merci d'ailleurs. et gestion des delay plus fiable.

mais merci quand même. pour l'écriture de fichier je suis allez un chouillat plus loin d'ailleurs

à chaque lancement de l'application je crée un nouveaux fichiers avec un nom forcement différent.

Code: [Select]

PrintWriter output;

void setup()
{
 String fileName = "evotemp_"+year()+"-"+nf(month(),2)+"-"+nf(day(),2)+"-"+nf(hour(),2)+"h"+nf(minute(),2)+"m"+nf(second(),2)+".txt";
 println(fileName);
 output = createWriter(fileName);
 frameRate(10);
}

void draw()
{
  output.println(WT+","+(BT)+","+(RT)+","+(ARD));
  output.flush();
}



ce qui me donne des fichiers avec un nom du genre "evotemp_2010-11-14-22h35m14.txt"

je n'utilise pas "exit" pour que mon fichier puisse en permanence être écrit

et les "nf(minute(),2)" me permette d'avoir les temps du genre 18h07m plutôt que 18h7m. c'est plus éléguant.

voilou, merci à vous
2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

Jean-François

MacBook intel core 2 duo  os X snow Leopard 10.6<br/> eMac PPc G4  os X Leopard 10.5<br/>powerbook G4 os X Leopard 10.5
imac PPC G3 os X Pa

FP24V

oh oui, le pc est beaucoup plus calme.
2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

Jean-François

Si ça t'intéresse de savoir comment écrire à la fin du fichier sans l'écraser, même lorsque tu éteins et relance ton appli....
MacBook intel core 2 duo  os X snow Leopard 10.6<br/> eMac PPc G4  os X Leopard 10.5<br/>powerbook G4 os X Leopard 10.5
imac PPC G3 os X Pa

FP24V

j'ai essayer et il change de fichiers je sais c'est voulu, c'est la seul méthode que j'ai trouvé pour ne pas perdre de relevé.

bon pour le moment j'attend ma carte wifi pour passer en sans fil.

Quelqu'un pourrais me guider pour la mise en route en wifi?
2 ans d'absence et tout à réapprendre.
Heureusement, je ne savais pas grand chose.

Go Up