Creation d'une class et bibliotheque

[denis-j]

Bonjour,

j'essaye depuis un certain temps de créer une class depuis un programme que j'ai créé
pour extraire des données GPS car les bibliothèques existantes saturent mon espace mémoire programme .
je vous joins mon fichier programme qui fonctionne.
et un de mes essais de transformation en bibliothèque que je ne peux compiler.
j'aimerais y ajouter les déclarations de broches RX TX ainsi que le software Serial.

Merci de votre aide

Denis
Forum_NFP.zip (3.3 KB)
Forum_Ok.zip (3.2 KB)

[denis-j]

je vous joins ma dernière version ou le compilateur réagit mieux

Reste a intégrer le software serial et a tester en fonction demain

Merci de votre attention

Denis
Forum_NFP.zip (3.4 KB)

[biggil]

mets ton code ici même, entre balises "code"
Sinon je ne lis pas, désolé.

[fdufnews]

De nombreux participants répondent de leur téléphone ils n'ouvriront pas un zip.

[lesept]

Même sur un PC...

[denis-j]

Bonjour à vous,
pas de soucis c’était pour ne pas encombrer.

c'est ma première class, elle fonctionne aussi

• J'aimerais avoir vos avis sur sa construction
• j'aimerais y intégrer le software Serial
  voilà les fichiers
  "DJ_GPS.ino
  /* DJ 09/10/23

• Test du fonctionnement d'un module GPS Neo-6M avec carte Uno

*/

#include "DJ_Gps.h"
DJ_Gps Neo6m(6,9);

SoftwareSerial gpsSerial(Neo6m.Rx,Neo6m.Tx); // Rx = 6 (Tx = 9)

void setup() {
Serial.begin(115200); // Démarre la communication série avec l'ordinateur
gpsSerial.begin(9600); // Démarre la communication série avec le module GPS
}

void loop() {
Neo6m.Recept_Gps(); // Reception GPS
if(Neo6m.Check_Ok){ // Utilisation Data Reception
char Date_c[12];
char Heure_c[10];
sprintf(Date_c,"%02d/%02d/20%02d ",Neo6m.Jour,Neo6m.Mois,Neo6m.Annee);
Serial.print(Date_c);
sprintf(Heure_c,"%02d:%02d:%02d ",Neo6m.Heure,Neo6m.Minute,Neo6m.Seconde);
Serial.println(Heure_c);
if(Neo6m.Vit_Ok){
Serial.print(F("Vitesse:"));
Serial.print (Neo6m.Vitesse,3);
Serial.println(" Km/h");
}
Serial.println();
// Preparation nouvelle Reception :
Neo6m.Jour=Neo6m.Mois=Neo6m.Annee=Neo6m.Heure=Neo6m.Minute=Neo6m.Seconde=Neo6m.Vitesse=0;
Neo6m.Check_Ok = false;
}
}
"
DJ_GPS.h
/* DJ_Gps V8-A 07/10/23
*
*/

#ifndef DJ_GPS_H
#define DJ_GPS_H

#include "Arduino.h"
#include <SoftwareSerial.h>

class DJ_Gps {
public:
DJ_Gps(uint8_t _Rx,uint8_t _Tx);
uint8_t Rx;
uint8_t Tx;
uint8_t Jour;
uint8_t Mois;
uint8_t Annee;
uint8_t Heure;
uint8_t Minute;
uint8_t Seconde;
bool Check_Ok; // Checksum Trame OK
bool Vit_Ok; // Vitesse OK
float Vitesse;
void Recept_Gps(); // Reception GPS

private:
char Gps_Data[85]; // Tableau pour stocker la trame GPS
uint8_t Data_Index; // Index pour la nouvelle trame
bool Recept_Trame(); // Reception Trame :
// Extraction Trame souhaitée :
bool Extract_Trame (char* Gps_Data, char Test_T[7]);
bool Calc_Checksum(char* Gps_Data);
// Calcul du Checksum de la Trame :
// Extraction du Checksum de la Trame :
uint8_t Extr_Checksum(char* Gps_Data);
// Extraction Vitesse de la Trame :
float Extr_Vitesse(char* Gps_Data);
// Extraction Date(_Date true),Heure(_Date false) :
void Extr_D_H(char* Gps_Data,bool _Date,uint8_t &_C1,uint8_t &_C2,uint8_t &_C3);
// Conversion 2 Caract Ascii en uint8_t :
uint8_t Trslt_Dble(char* Trsl);
};

extern SoftwareSerial gpsSerial; // Rx = 6 (Tx = 9)
#endif
"
"DJ_GPS.cpp
/* DJ_Gps V8-A 07/10/23
*
*/

include "DJ_Gps.h"

DJ_Gps::DJ_Gps(uint8_t _Rx,uint8_t _Tx){
Rx = _Rx;
Tx = _Tx;
}

const uint8_t Pos_Date = 9; // Position Date dans Trame $GPRMC
const uint8_t Pos_Heure = 1; // Position Heure dans Trame $GPRMC
const uint8_t Pos_Vitesse = 7; // Position Vitesse dans Trame $GPRMC
char Id_Trame[7] = {'$','G','P','R','M','C',0}; // Identifiant Trame

char Gps_Data[85]; // Tableau pour stocker la trame GPS
uint8_t Data_Index = 0; // Index pour la nouvelle trame
uint8_t Checks_Idx = 0; // Index pour isolement Checksum
uint8_t Jour=0,Mois=0,Annee=0,Heure=0,Minute=0,Seconde=0;
float Vitesse=0;
bool Check_Ok = false; //Checksum Trame OK
bool Vit_Ok = false; // Vitesse OK

void DJ_Gps::Recept_Gps(){ // Reception GPS :
if(Recept_Trame()){
// Traitement Trame :
if(Extract_Trame (Gps_Data,Id_Trame)){
for(uint8_t i = 0;i < Data_Index;i ++) Serial.print(Gps_Data[i]);
if(Calc_Checksum(Gps_Data)){
Extr_D_H(Gps_Data,true,Jour,Mois,Annee);
Extr_D_H(Gps_Data,false,Heure,Minute,Seconde);
Vitesse = Extr_Vitesse(Gps_Data);
Check_Ok = true; //Checksum Trame OK
}
else {
Serial.println("Trame non Valide");
Check_Ok = false;
}
} // Fin Traitement
Data_Index = 0; // réinitialiser l'index ici pour la nouvelle trame
}
}

// Reception Trame :
bool DJ_Gps::Recept_Trame(){
while (gpsSerial.available() > 0){ // Reception GPS
char c = gpsSerial.read();
Gps_Data[Data_Index] = c; // Stocke le caractère dans le tableau
Data_Index++;
// Si nous atteignons la fin de la trame GPS
if (c == '\n') return true;
}
return false;
}

// Extraction Trame souhaitée
bool DJ_Gps::Extract_Trame (char* Gps_Data, char Test_T[7]){
uint8_t C_Ok = 0;
for (uint8_t i = 0; i < 7;i ++){
if(Gps_Data[i] == Test_T[i]) C_Ok ++;
}
if(C_Ok == 6) return true;
else return false;
}

bool DJ_Gps::Calc_Checksum(char* Gps_Data) {
// Calcul du Checksum de la Trame
uint8_t Checksum = 0;
uint8_t i = 1;
for (; Gps_Data[i] != '*'; i++) {
Checksum ^= Gps_Data[i];
}
Checks_Idx = i + 1;
if(Checksum == Extr_Checksum(Gps_Data)) return true;
else return false;
}

uint8_t DJ_Gps::Extr_Checksum(char* Gps_Data){ // Extraction du Checksum de la Trame
uint8_t Checks_PF = Gps_Data[Checks_Idx]; // Extraction Poids fort en Ascii Hexa
uint8_t Checks = Gps_Data[Checks_Idx + 1]; // Extraction Poids faible en Ascii Hexa
// Conversion Ascii HEX vers Decimal
if((Checks_PF <= 57)&&(Checks_PF >= 48)) Checks_PF = Checks_PF - 48; // 0 a 9 en Ascii
else if((Checks_PF <= 70)&&(Checks_PF >= 65)) Checks_PF = Checks_PF - 55; // A a F en Ascii
Checks_PF *= 16;
if((Checks <= 57)&&(Checks >= 48)) Checks = Checks - 48; // 0 a 9 en Ascii
else if((Checks <= 70)&&(Checks >= 65)) Checks = Checks - 55; // A a F en Ascii
Checks += Checks_PF;
return Checks;
}

float DJ_Gps::Extr_Vitesse(char* Gps_Data){ // Extraction Vitesse de la Trame
uint8_t i = 1,k = 0,Cmpt_idx = 0,B_Inf = 0,B_Sup = 0;
float Vit = 0.0;
char Ext_T[10];
for(uint8_t j = 0; j<= 9;j ++) Ext_T[j] = 0; // Rst Tableau extract Vitesse
for (; Gps_Data[i] != '*'; i++){
if((Gps_Data[i] == ',')&&(B_Inf != 0)) {B_Sup = i; break;} // Borne Superieure Data Vitesse
if((Gps_Data[i] == ',')&&(B_Inf == 0)){
Cmpt_idx ++;
if(Cmpt_idx == Pos_Vitesse) B_Inf = i; // Borne Inferieure Data Vitesse
}
}
if((B_Sup - B_Inf) > 1){ // Test si Recept. Vitesse non vide
for(uint8_t j = (B_Inf + 1); j <= B_Sup; j++) {
Ext_T[k] = Gps_Data[j]; // Extract Vitesse
k ++;
}
// Conversion Tableau Ascii en float
// Vit = atof(Ext_T);
uint16_t Ent = 0, Dec = 0;
uint8_t i = 0, Cmpt_B = 0;
for(i = 0; Ext_T[i] != '.'; i ++){ // Extract et convert. partie entiere
Ent *= 10;
if((Ext_T[i] <= 57)&&(Ext_T[i] >= 48)) Ent += (Ext_T[i] - 48); // 0 a 9 en Ascii => dec
}
for(i=i+1;(Ext_T[i] <= 57)&&(Ext_T[i] >= 48);i++){ // Extract et convert. partie decimale
Dec *= 10;
if((Ext_T[i] <= 57)&&(Ext_T[i] >= 48)){
Dec += (Ext_T[i] - 48); // 0 a 9 en Ascii => dec
Cmpt_B ++;
}
}
switch (Cmpt_B){
case 0 : {Vit = Ent;break;}
case 1 : {Vit = ((Ent * 10) + Dec) / 10.0; break;}
case 2 : {Vit = ((Ent * 100) + Dec) / 100.0; break;}
case 3 : {Vit = ((Ent * 1000) + Dec) / 1000.0; break;}
}
if(Dec < 1000){
Vit *= 1.852; // Vitesse neuds => Km/h
Vit_Ok = true;
}
else Vit_Ok = false;
}
else Vit_Ok = false;
return Vit;
}

// Extraction Date, Heure
void DJ_Gps::Extr_D_H(char* Gps_Data,bool _Date,uint8_t &_C1,uint8_t &_C2,uint8_t &_C3){
uint8_t i = 1,k = 0,Cmpt_idx = 0,B_Inf = 0,B_Sup = 0,Pos = 0;
char Ext_T[10];
if(_Date) Pos = (uint8_t)Pos_Date;
else Pos = (uint8_t)Pos_Heure;
for (; Gps_Data[i] != '*'; i++){
if((Gps_Data[i] == ',')&&(B_Inf != 0)) {B_Sup = i; break;} // Borne Superieure Data
if((Gps_Data[i] == ',')&&(B_Inf == 0)){
Cmpt_idx ++;
if(Cmpt_idx == Pos) B_Inf = i; // Borne Inferieure Data
}
}
if((B_Sup - B_Inf) > 6){
for(uint8_t j = (B_Inf + 1); j < B_Sup; j++) {
Ext_T[k] = Gps_Data[j];
k ++;
}
char Trsl[3];
Trsl[0] = Ext_T[0]; Trsl[1] = Ext_T[1]; // Conversion 1
_C1 = Trslt_Dble(Trsl);
Trsl[0] = Ext_T[2]; Trsl[1] = Ext_T[3]; // Conversion 2
_C2 = Trslt_Dble(Trsl);
Trsl[0] = Ext_T[4]; Trsl[1] = Ext_T[5]; // Conversion 3
_C3 = Trslt_Dble(Trsl);
}
else{
if(_Date) Serial.println(F("Date HS"));
else Serial.println(F("Heure HS"));
}
}

uint8_t DJ_Gps::Trslt_Dble(char* Trsl){ // Conversion 2 Caract Ascii en uint8_t
uint8_t Conv = 0;
if((Trsl[0] <= 57)&&(Trsl[0] >= 48)) Conv = Trsl[0] - 48; // 0 a 9 en Ascii => dec
Conv *= 10;
if((Trsl[1] <= 57)&&(Trsl[1] >= 48)) Conv += (Trsl[1] - 48);
return Conv;
}
"
Merci de votre attention
Denis

[terwal]

Il faudrait que tu mettes ton code source entre balise < code>, car là c'est difficilement lisible un sur un écran de PC, je n'imagine pas avec un smartphone

[fdufnews]

Bonjour,
Merci de prendre quelques minutes pour lire les bonnes pratiques du forum francophone et les appliquer.

Les bonnes pratiques du Forum Francophone

QUELQUES RÈGLES SIMPLES À LIRE IMPÉRATIVEMENT AVANT DE POSTER Elles faciliteront la vie de tous et contribueront à rendre votre expérience la plus enrichissante possible. Bienvenue !!! Vous rejoignez une communauté : nous incitons très fortement les nouveaux arrivants sur la partie francophone à rédiger dans ce fil de discussion une rapide présentation personnelle. Aidez nous à vous aider : les réponses qui sont faites sur le forum francophone arduino sont majorit…

En particulier, la mise en forme du code avec les balises <code/>

[denis-j]

Avec mes excuses

/*  DJ 09/10/23
   Test du fonctionnement d'un module GPS Neo-6M avec carte Uno

*/


#include "DJ_Gps.h"
DJ_Gps Neo6m(6, 9);

SoftwareSerial gpsSerial(Neo6m.Rx, Neo6m.Tx); // Rx = 6 (Tx = 9)

void setup() {
  Serial.begin(115200); // Démarre la communication série avec l'ordinateur
  gpsSerial.begin(9600); // Démarre la communication série avec le module GPS
}

void loop() {
  Neo6m.Recept_Gps(); // Reception GPS
  if (Neo6m.Check_Ok) { // Utilisation Data Reception
    char Date_c[12];
    char Heure_c[10];
    sprintf(Date_c, "%02d/%02d/20%02d ", Neo6m.Jour, Neo6m.Mois, Neo6m.Annee);
    Serial.print(Date_c);
    sprintf(Heure_c, "%02d:%02d:%02d ", Neo6m.Heure, Neo6m.Minute, Neo6m.Seconde);
    Serial.println(Heure_c);
    if (Neo6m.Vit_Ok) {
      Serial.print(F("Vitesse:"));
      Serial.print (Neo6m.Vitesse, 3);
      Serial.println(" Km/h");
    }
    Serial.println();
    // Preparation nouvelle Reception :
    Neo6m.Jour = Neo6m.Mois = Neo6m.Annee = Neo6m.Heure = Neo6m.Minute = Neo6m.Seconde = Neo6m.Vitesse = 0;
    Neo6m.Check_Ok = false;
  }
}

pour le point h:

/*  DJ_Gps V8-A 07/10/23

*/

#ifndef DJ_GPS_H
#define DJ_GPS_H

#include "Arduino.h"
#include <SoftwareSerial.h>

class DJ_Gps {
  public:
    DJ_Gps(uint8_t _Rx, uint8_t _Tx);
    uint8_t Rx;
    uint8_t Tx;
    uint8_t Jour;
    uint8_t Mois;
    uint8_t Annee;
    uint8_t Heure;
    uint8_t Minute;
    uint8_t Seconde;
    bool Check_Ok; // Checksum Trame OK
    bool Vit_Ok; // Vitesse OK
    float Vitesse;
    void Recept_Gps(); // Reception GPS

  private:
    char Gps_Data[85]; // Tableau pour stocker la trame GPS
    uint8_t Data_Index; // Index pour la nouvelle trame
    bool Recept_Trame(); // Reception Trame :
    // Extraction Trame souhaitée :
    bool Extract_Trame (char* Gps_Data, char Test_T[7]);
    bool Calc_Checksum(char* Gps_Data);
    // Calcul du Checksum de la Trame :
    // Extraction du Checksum de la Trame :
    uint8_t Extr_Checksum(char* Gps_Data);
    // Extraction Vitesse de la Trame :
    float Extr_Vitesse(char* Gps_Data);
    // Extraction Date(_Date true),Heure(_Date false) :
    void Extr_D_H(char* Gps_Data, bool _Date, uint8_t &_C1, uint8_t &_C2, uint8_t &_C3);
    // Conversion 2 Caract Ascii en uint8_t :
    uint8_t Trslt_Dble(char* Trsl);
};

extern SoftwareSerial gpsSerial; // Rx = 6 (Tx = 9)
#endif

pour le point cpp

/*  DJ_Gps V8-A 07/10/23

*/

# include "DJ_Gps.h"

DJ_Gps::DJ_Gps(uint8_t _Rx, uint8_t _Tx) {
  Rx = _Rx;
  Tx = _Tx;
}



const uint8_t Pos_Date = 9; // Position Date dans Trame $GPRMC
const uint8_t Pos_Heure = 1; // Position Heure dans Trame $GPRMC
const uint8_t Pos_Vitesse = 7; // Position Vitesse dans Trame $GPRMC
char Id_Trame[7] = {'$', 'G', 'P', 'R', 'M', 'C', 0}; // Identifiant Trame

char Gps_Data[85]; // Tableau pour stocker la trame GPS
uint8_t Data_Index = 0; // Index pour la nouvelle trame
uint8_t Checks_Idx = 0; // Index pour isolement Checksum
uint8_t Jour = 0, Mois = 0, Annee = 0, Heure = 0, Minute = 0, Seconde = 0;
float Vitesse = 0;
bool Check_Ok = false;  //Checksum Trame OK
bool Vit_Ok = false; // Vitesse OK


void DJ_Gps::Recept_Gps() { // Reception GPS :
  if (Recept_Trame()) {
    // Traitement Trame :
    if (Extract_Trame (Gps_Data, Id_Trame)) {
      for (uint8_t i = 0; i < Data_Index; i ++) Serial.print(Gps_Data[i]);
      if (Calc_Checksum(Gps_Data)) {
        Extr_D_H(Gps_Data, true, Jour, Mois, Annee);
        Extr_D_H(Gps_Data, false, Heure, Minute, Seconde);
        Vitesse = Extr_Vitesse(Gps_Data);
        Check_Ok = true;  //Checksum Trame OK
      }
      else {
        Serial.println("Trame non Valide");
        Check_Ok = false;
      }
    } // Fin Traitement
    Data_Index = 0; // réinitialiser l'index ici pour la nouvelle trame
  }
}

// Reception Trame :
bool DJ_Gps::Recept_Trame() {
  while (gpsSerial.available() > 0) { // Reception GPS
    char c = gpsSerial.read();
    Gps_Data[Data_Index] = c; // Stocke le caractère dans le tableau
    Data_Index++;
    // Si nous atteignons la fin de la trame GPS
    if (c == '\n') return true;
  }
  return false;
}

// Extraction Trame souhaitée
bool DJ_Gps::Extract_Trame (char* Gps_Data, char Test_T[7]) {
  uint8_t C_Ok = 0;
  for (uint8_t i = 0; i < 7; i ++) {
    if (Gps_Data[i] == Test_T[i]) C_Ok ++;
  }
  if (C_Ok == 6) return true;
  else return false;
}

bool DJ_Gps::Calc_Checksum(char* Gps_Data) {
  // Calcul du Checksum de la Trame
  uint8_t Checksum = 0;
  uint8_t i = 1;
  for (; Gps_Data[i] != '*'; i++) {
    Checksum ^= Gps_Data[i];
  }
  Checks_Idx = i + 1;
  if (Checksum == Extr_Checksum(Gps_Data)) return true;
  else return false;
}

uint8_t DJ_Gps::Extr_Checksum(char* Gps_Data) { // Extraction du Checksum de la Trame
  uint8_t Checks_PF = Gps_Data[Checks_Idx]; // Extraction Poids fort en Ascii Hexa
  uint8_t Checks = Gps_Data[Checks_Idx + 1]; // Extraction Poids faible en Ascii Hexa
  // Conversion Ascii HEX vers Decimal
  if ((Checks_PF <= 57) && (Checks_PF >= 48)) Checks_PF = Checks_PF - 48; // 0 a 9 en Ascii
  else if ((Checks_PF <= 70) && (Checks_PF >= 65)) Checks_PF = Checks_PF - 55; // A a F en Ascii
  Checks_PF *= 16;
  if ((Checks <= 57) && (Checks >= 48)) Checks = Checks - 48; // 0 a 9 en Ascii
  else if ((Checks <= 70) && (Checks >= 65)) Checks = Checks - 55; // A a F en Ascii
  Checks += Checks_PF;
  return Checks;
}

float DJ_Gps::Extr_Vitesse(char* Gps_Data) { // Extraction Vitesse de la Trame
  uint8_t i = 1, k = 0, Cmpt_idx = 0, B_Inf = 0, B_Sup = 0;
  float Vit = 0.0;
  char Ext_T[10];
  for (uint8_t j = 0; j <= 9; j ++) Ext_T[j] = 0; // Rst Tableau extract Vitesse
  for (; Gps_Data[i] != '*'; i++) {
    if ((Gps_Data[i] == ',') && (B_Inf != 0)) {
      B_Sup = i;  // Borne Superieure Data Vitesse
      break;
    }
    if ((Gps_Data[i] == ',') && (B_Inf == 0)) {
      Cmpt_idx ++;
      if (Cmpt_idx == Pos_Vitesse) B_Inf = i; // Borne Inferieure Data Vitesse
    }
  }
  if ((B_Sup - B_Inf) >  1) { // Test si Recept. Vitesse non vide
    for (uint8_t j = (B_Inf + 1); j <= B_Sup; j++) {
      Ext_T[k] = Gps_Data[j]; // Extract Vitesse
      k ++;
    }
    // Conversion Tableau Ascii en float
    //    Vit = atof(Ext_T);
    uint16_t Ent = 0, Dec = 0;
    uint8_t i = 0, Cmpt_B = 0;
    for (i = 0; Ext_T[i] != '.'; i ++) { // Extract et convert. partie entiere
      Ent *= 10;
      if ((Ext_T[i] <= 57) && (Ext_T[i] >= 48)) Ent += (Ext_T[i] - 48); // 0 a 9 en Ascii => dec
    }
    for (i = i + 1; (Ext_T[i] <= 57) && (Ext_T[i] >= 48); i++) { // Extract et convert. partie decimale
      Dec *= 10;
      if ((Ext_T[i] <= 57) && (Ext_T[i] >= 48)) {
        Dec += (Ext_T[i] - 48); // 0 a 9 en Ascii => dec
        Cmpt_B ++;
      }
    }
    switch (Cmpt_B) {
      case 0 : {
          Vit = Ent;
          break;
        }
      case 1 : {
          Vit = ((Ent * 10) + Dec) / 10.0;
          break;
        }
      case 2 : {
          Vit = ((Ent * 100) + Dec) / 100.0;
          break;
        }
      case 3 : {
          Vit = ((Ent * 1000) + Dec) / 1000.0;
          break;
        }
    }
    if (Dec < 1000) {
      Vit *= 1.852; // Vitesse neuds => Km/h
      Vit_Ok = true;
    }
    else Vit_Ok = false;
  }
  else Vit_Ok = false;
  return Vit;
}

// Extraction Date, Heure
void DJ_Gps::Extr_D_H(char* Gps_Data, bool _Date, uint8_t &_C1, uint8_t &_C2, uint8_t &_C3) {
  uint8_t i = 1, k = 0, Cmpt_idx = 0, B_Inf = 0, B_Sup = 0, Pos = 0;
  char Ext_T[10];
  if (_Date) Pos = (uint8_t)Pos_Date;
  else Pos = (uint8_t)Pos_Heure;
  for (; Gps_Data[i] != '*'; i++) {
    if ((Gps_Data[i] == ',') && (B_Inf != 0)) {
      B_Sup = i;  // Borne Superieure Data
      break;
    }
    if ((Gps_Data[i] == ',') && (B_Inf == 0)) {
      Cmpt_idx ++;
      if (Cmpt_idx == Pos) B_Inf = i; // Borne Inferieure Data
    }
  }
  if ((B_Sup - B_Inf) >  6) {
    for (uint8_t j = (B_Inf + 1); j < B_Sup; j++) {
      Ext_T[k] = Gps_Data[j];
      k ++;
    }
    char Trsl[3];
    Trsl[0] = Ext_T[0]; Trsl[1] = Ext_T[1]; // Conversion 1
    _C1 = Trslt_Dble(Trsl);
    Trsl[0] = Ext_T[2]; Trsl[1] = Ext_T[3]; // Conversion 2
    _C2 = Trslt_Dble(Trsl);
    Trsl[0] = Ext_T[4]; Trsl[1] = Ext_T[5]; // Conversion 3
    _C3 = Trslt_Dble(Trsl);
  }
  else {
    if (_Date) Serial.println(F("Date HS"));
    else Serial.println(F("Heure HS"));
  }
}

uint8_t DJ_Gps::Trslt_Dble(char* Trsl) { // Conversion 2 Caract Ascii en uint8_t
  uint8_t Conv = 0;
  if ((Trsl[0] <= 57) && (Trsl[0] >= 48)) Conv = Trsl[0] - 48; // 0 a 9 en Ascii => dec
  Conv *= 10;
  if ((Trsl[1] <= 57) && (Trsl[1] >= 48)) Conv += (Trsl[1] - 48);
  return Conv;
}
[/code]
J’espère que c'est plus lisible
A bientôt
Denis

[biggil]

Tu rends ta classe dépendante de la classe SoftwareSerial. Ce n'est pas forcément une bonne idée.
Peut-être l'utilisateur d'un Arduino Mega, qui a 3 lignes série hardware, voudrait utiliser l'un d'elles plutôt qu'une instance de SoftwareSerial (par exemple, d'autres cas sont possibles, il faut que tu restes le plus souple possible).
L'idée est de laisser ton utilisateur (c-à-d le programmeur qui va utiliser ta classe) créer lui même le canal dont il a besoin, puis le passer (le donner) à ta classe pour qu'elle l'utilise.
La classe SoftwareSerial dérive de la classe Stream, fournie par Arduino.
l'objet Serial, que tout le monde connait, est aussi une instance de la classe Serial (ou d'une classe dérivée).
Ainsi, dans le constructeur de ta classe, tu demandes à ton utilisateur de te passer une référence sur un objet de la classe Stream, que l'utilisateur aura bâti avant de construire un objet de ta classe. Ce pourra être une instance de SoftwareSerial, ou l'objet Serial ou Serial1...
DJ_Gps ( Stream & stream );
Pas besoin de passer rx et tx, qui ne servent que pour un SoftwareSerial, dans ce cas l'utilisateur les aura fixés au moment de créer l'objet SoftwareSerial.
Exemple avec SoftwareSerial:

SoftwareSerial SS ( 2, 3 );
DJ_Gps gps ( SS );

Exemple avec Serial1:

// pas besoin de créer Serial1, c'est automatique
DJ_Gps gps ( Serial1 );

Si tu as des questions ... vas-y !

[denis-j]

Ok je comprend ta réponse.

je vais l’intégrer demain avec softwareSerial.
Peux tu me montrer comment la programmer dans mon constructeur STP ?

d'autre part j'ai lu dernièrement qu'une variable locale passée par return peux retourner un résultat aléatoire si elle n'est pas déclarée static. ça me surprend un peu. je pensais qu'elle était perdue après le transfert d'info.
Du coup la variable locale static perd un peu de sont intérêt si elle verrouille l'espace mémoire.
En tout cas merci de votre patience après mes transferts de programme par étapes
Denis

[biggil]

il n'y a pas de problème à faire return d'une variable locale. Le compilateur fait une copie de cette variable.
Ce qu'il ne faut surtout pas faire, c'est renvoyer un pointeur sur une variable locale ! (ou une référence sur...)
Dans ce cas le pointeur pointe quelque part dans la pile (là où se trouve la variable locale), mais au sortir (return) de la fonction la pile est libérée (ce qui ne veut pas dire effacée). Très rapidement, le programme va empiler d'autres choses, l'ancienne variable locale sera écrasée, et le pointeur va pointer vers ... n'importe quoi.

Je te donne l'exemple que tu demandes pus tard, là il faut que j'aille jammer

[denis-j]

Merci beaucoup pour l'info.
ça me rassure pour l'utilisation variables.

[biggil]

exemple de DJ_Gps
définition:

class DJ_Gps
{
  DJ_Gps ( Stream & stream );
  .../...
protected:
 Stream & mStream;
}

Déclaration:

DJ_Gps ::DJ_Gps ( Stream & stream ) 
: mStream ( stream ) // initialise le membre mStream avec le stream passé au ctor
{
  // éventuellement (ce choix peut aussi être laissé à l'utilisateur
  // qui doit l'effectuer hors de cette classe,
  // l'annoncer clairement dans la doc de la classe
  mStream.begin ( 9600 ); // ou autre valeur...
}

Usage interne:
while ( mStream.available() > 0) { // Reception GPS

[denis-j]

Bonjour et Merci

a la compilation j'ai l'erreur suivante
````Use code tags to format code for the forum`

C:\Users\Denis\AppData\Local\Temp\arduino_build_278100\sketch\DJ_Gps.cpp: In constructor 'DJ_Gps::DJ_Gps(Stream&)':

DJ_Gps.cpp:10:11: error: 'class Stream' has no member named 'begin'

   mStream.begin ( 9600 )

           ^~~~~

type or paste code here

J'ai peut être mal retranscrit
`Use code tags to format code for the forum````

#include <SoftwareSerial.h>
#include "DJ_Gps.h"

SoftwareSerial gpsSerial(6, 9); // Rx = 6 (Tx = 9)

DJ_Gps Neo6m(gpsSerial);


void setup() {
  Serial.begin(115200); // Démarre la communication série avec l'ordinateur
}

Declaration:

[code]
class DJ_Gps {
  public:
    DJ_Gps( Stream & stream);
    uint8_t Rx;
    uint8_t Tx;
    uint8_t Jour;
    uint8_t Mois;
    uint8_t Annee;
    uint8_t Heure;
    uint8_t Minute;
    uint8_t Seconde;
    bool Check_Ok; // Checksum Trame OK
    bool Vit_Ok; // Vitesse OK
    float Vitesse;
    void Recept_Gps(); // Reception GPS

  private:
    char Gps_Data[85]; // Tableau pour stocker la trame GPS
    uint8_t Data_Index; // Index pour la nouvelle trame
    bool Recept_Trame(); // Reception Trame :
    // Extraction Trame souhaitée :
    bool Extract_Trame (char* Gps_Data, char Test_T[7]);
    bool Calc_Checksum(char* Gps_Data);
    // Calcul du Checksum de la Trame :
    // Extraction du Checksum de la Trame :
    uint8_t Extr_Checksum(char* Gps_Data);
    // Extraction Vitesse de la Trame :
    float Extr_Vitesse(char* Gps_Data);
    // Extraction Date(_Date true),Heure(_Date false) :
    void Extr_D_H(char* Gps_Data, bool _Date, uint8_t &_C1, uint8_t &_C2, uint8_t &_C3);
    // Conversion 2 Caract Ascii en uint8_t :
    uint8_t Trslt_Dble(char* Trsl);
    Stream & mStream;
};
#endif
[/code]

Definition

[code]

# include "DJ_Gps.h"

DJ_Gps::DJ_Gps(Stream & stream)
  : mStream ( stream)
{
  mStream.begin ( 9600 )
}


[/code]

[terwal]

Tu es sûre que la class Stream contient cette fonction ?
Dans la documentation il n'y ait pas fait mention.
Il n'y a pas non plus le code d'instanciation de ta classe.

[denis-j]

Bonjour,

finalement je reste avec SoftwareSerial à l’extérieur de ma class
c'est plus simple et je ne maitrise pas suffisamment le langage pour aller plus loin.
Je garde en mémoire nos échanges ils me serviront peut être un jour.

Merci beaucoup pour votre attention et Bonne Chance dans vos développements

Denis

[biggil]

OK, j'ai fait une erreur. Selon la doc Arduino, la classe Stream est l'ancêtre de plusieurs classes : Serial, Wire, Ethernet, SD.
Seule Serial est concernée par la déclaration d'une vitesse de transfert, et possède donc une fonction membre nommé begin().
Donc il suffit de ne pas s'occuper de begin() dans ta classe à toi, et demander à l'utilisateur d'appeler begin(), si pertinent, sur l'objet qu'il passe à ton constructeur.

SoftwareSerial SS ( 2, 3 );
SS.begin ( 9600 );
DJ_Gps gps ( SS );

nota : tu n'as plus besoin de Rx et Tx dans les membres de ta classe.