[resolu] mega 2560, ITOA()+concatenation, (simple)

International Français
1

Bonjour , étant débutant je commence un programme assez simple qui me permet d'allumer/eteindre des lampes a une heure différente chaque jours en fonction de txt lu sur une carte sd.
mega 2560 , lcd itb02 5.0"+sdcard, ds1307 .
voici un exemple de txt

NOM DU TXT = 21231.txt ( celui ci est le txt de la date du 31/12/2012 )
SON CONTENU = 07452112 (en fait lire 07h45 et 21h12 )

dans l'ordre le programme:

#include <DS1307.h>
#include <UTFT.h>
#include <tinyFAT.h>
#include <UTFT_tinyFAT.h>
#include <ITDB02_Touch.h>

UTFTtf myGLCD(ITDB50,38,39,40,41);   // allume le lcd
ITDB02_Touch  myTouch(6,5,4,3,2);
DS1307 rtc(20, 21); // allume le DS1307 sur pin 20,21
Time t;

// definition de variable
unsigned long datecompil ; // 21231
char       datecompil_txt[] ="00000.txt"; 

//récupère la date sur le ds1307 ( t.mon & t.date )
 t = rtc.getTime();

//remanie la date dans une nouvelle variable :
datecompil = (20000L)+(t.mon *100)+t.date; //  la date (decembre 31) = 21231

// ici datecompil est un INT , J'ai besoin d'en fair un CHAR , je me sert de ITOA , Puis Jajoute ".txt" 
// cela me permetra de lire datecompil.txt
    itoa(datecompil, datecompil_txt, 10); //change un INT en un CHAR en base 10 ( decimal)

//      datecompil_txt[5]= '.' ; // PROBLEME ICI

//    datecompil_txt[6]= 't' ; // on ne touche pas les commentaire ici ou après
 //   datecompil_txt[7]= 'x' ;
 //   datecompil_txt[8]= 't' ;

 file.openFile(datecompil_txt, FILEMODE_TEXT_READ);

voici ce qui me gene :
Quand j'enleve les commentaire de la ligne datecompil_txt[5]= '.' ;
datecompil_txt= 21231.txt
si je remet le commentaire sur la ligne datecompil_txt[5]= '.' ;
datecompil_txt= 21231

donc je ne comprend pas pourquoi en ajoutant à date compile_txt sur le [5] caractere le "." il me rajoute les caractère a [6][7][8] txt

Compréhensible mon charabia ou ???..

Merci beaucoup ( j'ai encor plein de question pour plus tard...)

2

Bonjour,

Tu te casse la tête pour rien :wink:

char buf[] = "00000.txt";
sprintf(buf, "%05d.txt", datecompil);

http://www.cplusplus.com/reference/clibrary/cstdio/sprintf/

3 
datecompil_txt[5]= '.' ;

Cette ligne écrase le terminateur de la chaine. Il faut le remettre à la fin de tes manipulations

// ici datecompil est un INT , J'ai besoin d'en fair un CHAR , je me sert de ITOA , Puis Jajoute ".txt" 
// cela me permetra de lire datecompil.txt
    itoa(datecompil, datecompil_txt, 10); //change un INT en un CHAR en base 10 ( decimal)

//      datecompil_txt[5]= '.' ; // PROBLEME ICI

//    datecompil_txt[6]= 't' ; // on ne touche pas les commentaire ici ou après
 //   datecompil_txt[7]= 'x' ;
 //   datecompil_txt[8]= 't' ;


datecompil_txt[9]= 0;

En toute rigueur il serait préférable de travailler avec des String et d'utiliser une fonction de concaténation pour faire ça.

4

merci beaucoup de vos reponse
skywodd , toujours 1er à repondre!!! , sprintf c'est sympa ,fonctionnel, un truc que je n'ai peut être pas saisi c'est le langage utilisé pour la prog arduino , on peut utilisé du c ou c++ pur ?

fdufnews ,Merci beaucoup j'ai compris grâce a toi ou était le problème , itoa() va me rajouter \0 sur datecompil_txt[5] ='\0'; terminant ainsi la chaine de caractere
datecompil_txt[6]
datecompil_txt[7]
datecompil_txt[8]
sont toujours présent mais ne sont pas afficher a cause de datecompil_txt[5] ='\0' construit par ITOA()
le simple fait de remettre datecompil_txt[5] ='\0' sur datecompil_txt[5] ='.'; supprime le caractère de fin de chaine et reprend le reste du mot toujours en mémoire.

je comprend mieux maintenant , je vais utilisé sprintf et surtout essayer de le comprendre car il a l'air vraiment puissant!

Merci a vous 2.

de quoi pleurer: ( mais qui fonctionne)

#include <DS1307.h>
#include <UTFT.h>
#include <tinyFAT.h>
#include <UTFT_tinyFAT.h>
#include <ITDB02_Touch.h>

extern uint8_t BigFont[]; //declare la police lcd
UTFTtf myGLCD(ITDB50,38,39,40,41);   // allume le lcd
ITDB02_Touch  myTouch(6,5,4,3,2);
DS1307 rtc(20, 21); // allume le DS1307 sur pin 20,21
Time t;

unsigned long SCRIPT_TIMEB =0; // calcul la vitesse execution du script
unsigned long SCRIPT_TIME =0; // calcul la vitesse execution du script
unsigned long OLD_SCRIPT_TIME =0; // calcul la vitesse execution du script

unsigned long datecompil ;
unsigned long memoire_datecompil ;
unsigned int  heure_actuel_compil ;
char          datecompil_txt[] ="00000.txt";


// si le txt contient 07452152
byte heure_fin ; // 07
byte min_fin   ; //45
unsigned int heure_min_fin  ; //0745 // sert a la comparaison d'heure 
char H_M_F[6];// 07:45

byte heure_debut ;// 21
byte min_debut   ; //52
unsigned int heure_min_debut  ;//2152  // sert a la comparaison d'heure 
char H_M_D[6];//21:52

char textBuffer[8]; // pour la lecture du txt de la carte SD


////////////////////////////
void setup()
{
  rtc.halt(false); // Set the clock to run-mode
  Serial.begin(9600);   // Setup Serial connection
  myGLCD.InitLCD(); // initialise le lcd
  myGLCD.clrScr(); // efface tout ce qui est present a l'ecran
  myTouch.InitTouch();
  myTouch.setPrecision(PREC_MEDIUM);
  file.initFAT(SPISPEED_VERYHIGH); 
  myGLCD.setColor(0, 255, 0);
  myGLCD.setFont(BigFont); 
   // myGLCD.loadBitmap(0, 0, 800, 480, "pic888.raw");
myGLCD.loadBitmap(200, 10, 82, 82, "deb182.raw"); 
myGLCD.loadBitmap(400, 10, 82, 82, "ter182.raw"); // hor,ver
myGLCD.loadBitmap(600, 10, 82, 82, "lun182.raw");


}

void loop()
{ 
  t = rtc.getTime();// enregistre l'heure actuel dans t


  //  while (myTouch.dataAvailable() == true)// fonction pour dessiner a l'ecran avec touchpad
  //  {
  //    myTouch.read();
  //    myGLCD.drawPixel (myTouch.getX(), myTouch.getY());
  //  }


heure_actuel_compil = (t.hour*100)+t.min ; /* on compile l'heure hh*100 +mn , chifre max 2359 */
datecompil = (20000L)+(t.mon *100)+t.date; // on compile la date de l'horlage rtc // (20.000) + (mois * 100) + jour = 21231 pour le 31 decembre


// rtc.poke(55, 1); on poke la variable heure d'été dans la ram 55 !! on la recup en faisant : rtc.peek(55)
// truc simple pour la mise a l'heure d'été , les txt ne contienne pas de changement d'heure, l'horloge ne se met pas a jour toute seule
// lors dune mise a jour de l'heure (manuel) on changera la valeur a 1 ou 0

//si datecompil != memoire_datecompil , alors lit la carte sd
if (datecompil != memoire_datecompil) 
{   

sprintf(datecompil_txt, "%05d.txt", datecompil); // compile datecompil.txt


  if (file.exists(datecompil_txt)) // verifie si datecompil existe en txt
    {
    file.openFile(datecompil_txt, FILEMODE_TEXT_READ);
    file.readLn(textBuffer, 8);
    file.closeFile();
  //  myGLCD.print("txt existe", CENTER, 340);
    // on a recuperé sur textBuffer[] un truc genre : 07452152
    
H_M_F[0] = textBuffer[4];
H_M_F[1] = textBuffer[5]+ rtc.peek(55); if (H_M_F[1] == 58){H_M_F[1]=48; H_M_F[0]++;}
H_M_F[2] = 58; // la forme decimal de : = 48 en ascii
H_M_F[3] = textBuffer[6];
H_M_F[4] = textBuffer[7];

// H_M_ (F OU D) heure minute (fin ou debut) en chaine de caratere pour affichage lcd genre 07:45 ou 21:52

H_M_D[0] = textBuffer[0];
H_M_D[1] = textBuffer[1]+ rtc.peek(55); //if (H_M_D[1] == 58){H_M_D[1]=48; H_M_D[0]++;}
H_M_D[2] = 58; // la forme decimal de : = 48 en ascii 
H_M_D[3] = textBuffer[2];
H_M_D[4] = textBuffer[3]; 


            


    // je modifie le buffer code ascci > decimal pur 
    textBuffer[0]= textBuffer[0] - 48 ;
    textBuffer[1]= textBuffer[1] - 48 ;
    textBuffer[2]= textBuffer[2] - 48 ;
    textBuffer[3]= textBuffer[3] - 48 ;
    textBuffer[4]= textBuffer[4] - 48 ;
    textBuffer[5]= textBuffer[5] - 48 ;
    textBuffer[6]= textBuffer[6] - 48 ;
    textBuffer[7]= textBuffer[7] - 48 ;

    //on compile heure de debut du TXT
    heure_debut = (textBuffer[0] *10) + textBuffer[1] ;
    heure_debut = heure_debut + rtc.peek(55); // on ajoute l'heure d'ete ( 1 ou 0 )rtc.peek(55); recupere dans la ram du ds1307 a l'adresse 55 le 1/0
    min_debut   = (textBuffer[2] *10) + textBuffer[3] ;
    heure_min_debut = heure_debut *100 + min_debut ; // = 0745
    

    //on compile heure de fin du TXT
    heure_fin = (textBuffer[4] *10) + textBuffer[5] ;
    heure_fin = heure_fin + rtc.peek(55); // on ajoute l'heure d'ete ( 1 ou 0 )
    min_fin   = (textBuffer[6] *10) + textBuffer[7] ;
    heure_min_fin = heure_fin *100 + min_fin ; // = 2152

    //et on definie memoire_datecompil
    memoire_datecompil = datecompil ; // pour la verification a la prochaine boucle ( evite de refaire tout sa si la date actuel na pas changer.)
    }
    else
    {
 //   myGLCD.print("txt existe pas", CENTER, 340); 
    } 

 myGLCD.print(H_M_D,202, 92); // ici on a compiler l'heure du txt en chaine de caracter 07:45 , on l'afiche sur le lcd
 myGLCD.print(H_M_F,602, 92); 

}//  fin de la verification datecompil != memoire_datecompil



// la structure de controle pour l'allumage des lampes
if((heure_actuel_compil >= heure_min_debut) && (heure_actuel_compil <= heure_min_fin))
  { myGLCD.print("ON", CENTER,352); 

}
else
  { myGLCD.print("OFF", CENTER,352); 

}
 
myGLCD.print(rtc.getTimeStr(FORMAT_LONG), 378, 92); // on affiche l'heure sur le lcd


///////////////////////////////////////////////////////////////////////////////////////////
myGLCD.printNumI(freeRam (), CENTER, 460); // ici on affiche a l'ecran la memoire disponible
///////////affiche le temps d'execution du script/////
OLD_SCRIPT_TIME = SCRIPT_TIME ;                  /////
SCRIPT_TIME = millis() ;                         /////
SCRIPT_TIMEB = SCRIPT_TIME - OLD_SCRIPT_TIME ;   /////
myGLCD.printNumI(SCRIPT_TIMEB, CENTER, 440,4);   /////
//////////////////////////////////////////////////////

} // fin du VOID LOOP

////////////////fonction regarde la memoire////////////////////////////////////////////
int freeRam () {
extern int __heap_start, *__brkval;
int v;
return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}
///////////////////////////////////////////////////////////////////////////////////////

oui c'est pas beau mais sa marche , mon 1er script arduino ^^
5

ppzikos:
skywodd , toujours 1er à repondre!!!

Je suis un ninja tapis dans l'ombre prés a sauter sur les nouveaux topics :grin:

ppzikos:
sprintf c'est sympa ,fonctionnel, un truc que je n'ai peut être pas saisi c'est le langage utilisé pour la prog arduino , on peut utilisé du c ou c++ pur ?

Arduino n'est rien d'autre qu'une séries de classe C++ :wink:

Tu peut utiliser les fonctions "classique" de la libc et libc++ sans probléme, mais avec certaines limitations.
(pas de STL, usage limité de malloc() free() ..., ...)
Tu peut aussi coder en "avr-c" (C/C++ classique mais avec la notion de registres AVR) si tu veut :wink:

6

merci beaucoup.