Bonjour,
J'ai comme projet de faire fonctionner un programme avec un module sim900 ainsi qu'un module GPS.
Le principe est simple : il suffit de localiser un emplacement à l'aide du module GPS et par la suite envoyer les données de localisation par SMS.

J'ai donc commandé un Shield GPS : http://www.designersystems.co.uk/GPM.S_info.htm
Et un module GSM : https://www.itead.cc/sim900-sim900a-gsm-gprs-minimum-system-module.html
J'ai aussi acheté une carte SIM à 2 € chez Free.


Je me suis donc lancé, j'ai fait quelques soudures et tout branché : RX/TX, TX/RX pour le module GSM.j'ai donc attaqué les programmes.
Voici mon programme qui fonctionne à merveille pour le GPS :

/*====================================================
Systeme DS-GPM Shield Arduino 
Utilisé avec une carte Arduino UNO

------------------------------------------------------
cablage :
L'interface DS-GPM.S transmet les données via le bus I2C 
(Broche ANALOG 4 [SDA] & Broche ANALOG 5 [SCL]) 
Le terminal série est paramétré à 9600 baud
 
====================================================== */

#include <Wire.h>

#define GPM 0x68  	                              // GPM I2C Address

byte Address;                                         // variable
byte Data;                                            // variable

byte Data_10, Data_9, Data_8, Data_7, Data_6, Data_5, Data_4, Data_3, Data_2, Data_1;
int Latitude_1, Longitude_1;
long Latitude_2, Longitude_2;
float Latitude_C, Longitude_C; 


void setup()
{

  Wire.begin();                                       // Start I2C comms
  Serial.begin(9600);                                 // serial port: 9600 baud





                    delay(6000);                                        // attendre 6 sec

}

void loop()
{
  Serial.println(" ");
  Serial.print("Date : ");
  Get_Date();

  Serial.print("Heure : ");
  Get_Heure();

  delay(500);                                        // attendre

  Serial.print("Satellites en vue : ");
  Get_Satellites_vus();

 

  Serial.print("Vitesse : ");
  Get_Vitesse();

  Serial.println(" ");
  delay(500);                                        // attendre

  
  Serial.print("Latitude calcul : ");
  GetLatitude_Calcul();
  Serial.println(Latitude_C,6);



  Serial.println(" ");
  

  
  Serial.print("Longitude calcul : "); 
  GetLongitude_Calcul();
  Serial.println(Longitude_C,6);
 




 delay(5000);                                     // attendre
  Serial.println(" ");
    Serial.println(" ");
      Serial.println(" ");
        Serial.println(" ");
}


/*---------------------------------------------------------
 Sous programme 'GetDouble'
 ------------------------------------------------------------ */
int GetDouble()
{				      // Get double register value from GPM
  int Value = 0; 
  byte H_Byte = 0;
  byte L_Byte = 0;

  Wire.beginTransmission(GPM);
  Wire.write(Address);				      // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 2);			      // Request double register
  while(Wire.available() < 2);			      // Wait for double byte
  H_Byte = Wire.read();                            // Store one
  L_Byte = Wire.read();                            // Store two

  Value = (H_Byte * 10) + L_Byte;                     // Adjust for one byte

    return(Value);	                          
}

/*---------------------------------------------------------
 Sous programme 'GetSingle'
 ------------------------------------------------------------ */
int GetSingle()
{				      // Get single register value from GPM
  int Value = 0; 

  Wire.beginTransmission(GPM);
  Wire.write(Address);				      // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 1);			      // Request register
  while(Wire.available() < 1);			      // Wait for single byte
  Value = Wire.read();                             // and store

  return(Value);	                          
}


/*---------------------------------------------------------
 Sous programme 'Get_Date'
 ------------------------------------------------------------ */
byte Get_Date()
{
  Address = 6;                                        // Adresse Registre JOUR
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 8;                                        // Adresse Registre MOIS
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 10;                                       // Adresse Registre ANNEE (Milliers et Centaines)
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Address = 12;                                       // Adresse Registre ANNEE (Dizaines et Unités)
  Data = GetDouble();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
} 

/*---------------------------------------------------------
 Sous programme 'Get_Heure'
 ------------------------------------------------------------ */
byte Get_Heure()
{
  Address = 0;                                        // Adresse Registre Heures
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 2;                                        // Adresse Registre Minutes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 4;                                        // Adresse Registre Secondes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}

/*---------------------------------------------------------
 Sous programme 'Get_Satellites_vus'
 ------------------------------------------------------------ */
byte Get_Satellites_vus()
{
  Address = 35;           //58 version1 / 35 Version2 // Adresse de Pointage satellites en vue
  Data = GetSingle();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}


/*---------------------------------------------------------
 Sous programme 'Get_Vitesse'
 ------------------------------------------------------------ */
int Get_Vitesse()
{
  Address = 52;                                       // Point to Speed 1 register
  Data = GetDouble();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Address = 54;                                       // Point to Speed 2 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Serial.print(".");
  Address = 55;                                       // Point to Speed 3 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // and print to PC
}


/*---------------------------------------------------------
 Sous programme 'GetLatitude_Calcul'
 ------------------------------------------------------------ */
double GetLatitude_Calcul()
{
  Address = 14;                                       // Registre Latitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 15;                                       // Registre Latitude Dizaines de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 16;                                       // Registre Latitude Dizaines de minutes
  Data_6 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 17;                                       // Registre Latitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 18;                                       // Registre Latitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 19;                                       // Registre Latitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 20;                                       // Registre Latitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 21;                                       // Registre Latitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)


  Latitude_1=(Data_8*10+Data_7);  
  Latitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Latitude_2=(Latitude_2/60);
    Latitude_C = (Latitude_1+(Latitude_2*1E-4));        // Calcu complet latitude
  return (Latitude_C);
}



/*---------------------------------------------------------
 Sous programme 'GetLongitude_Calcul'
 ------------------------------------------------------------ */
double GetLongitude_Calcul()
{
  Address = 23;                                       // Registre Longitude Centaines de degrés
  Data_9 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 24;                                       // Registre Longitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 25;                                       // Registre Longitude Unités de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 26;                                       // Registre Longitude Dizaines de minutes
  Data_6 = GetSingle();                               /// Lire le registre du GPM (1 octet)

  Address = 27;                                       // Registre Longitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 28;                                       // Registre Longitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 29;                                       // Registre Longitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 30;                                       // Registre Longitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 31;                                       // Registre Longitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Longitude_1=(Data_9*1E2+Data_8*10+Data_7);  
  Longitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Longitude_2=(Longitude_2/60);

    Longitude_C = (Longitude_1+(Longitude_2*1E-4));      // Calcu complet longitude
  return (Longitude_C);
}

Ce programme me donne les coordonnées GPS la date etc… :

Pour le programme du module GPS sim900 c'est plus compliqué.
j'ai recherché plusieurs programmes sur Internet mais beaucoup ne fonctionnait pas jusqu'à ce que je tombe sur ce tuto : http://www.upsilonaudio.com/sim900-envoyer-des-sms-avec-une-carte-arduino/
Le programme marche à merveille j'arrive à envoyer des SMS cependant je le trouve très compliqué j'en ai donc cherché un plus simple mais tout ce que j'ai trouvé ne marche pas.

 Maintenant mon but est de « fusionner » les deux programmes : ce que j'ai essayé de faire mais sans succès. Je ne sais pas comment m'y prendre sachant que je n'ai jamais essayer de fusionner de programmes.
 Voici comment j'ai essayé de faire (tout bêtement) :

// VAR GPS
#include <Wire.h>
#define GPM 0x68                                  // GPM I2C Address
byte Address;                                         // Global variable
byte Data;                                            // Global variable
byte Data_10, Data_9, Data_8, Data_7, Data_6, Data_5, Data_4, Data_3, Data_2, Data_1;
int Latitude_1, Longitude_1;
long Latitude_2, Longitude_2;
float Latitude_C, Longitude_C; 

//VAR SMS
int8_t answer;
int onModulePin= 2; // port DTR (ou PWR) du module SIM900.
char aux_string[30];
char phone_number[]="+3365**********"; //numéro tel


void setup()
{

// -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*  SETUP PARTIE SMS  -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
{
    pinMode(onModulePin, OUTPUT);
    Serial.begin(115200);
    Serial.begin(115200);    
    Serial.println("");
    Serial.println("***localisation GPS+GSM***");
    Serial.println("");
    Serial.println("Initialisation ...");
    
    
   power_on(); // Cette commande active la carte SIM.
    delay(5000);

    
    Serial.println("Attente allumage du module....");

        while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) ||                     //Attente allumage du module
               sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );               //Attente allumage du module

    Serial.println("activation mode SMS ...");  // Activation du mode texte pour les SMS.
    sendATcommand("AT+CMGF=1", "OK", 1000);
    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("Envoi du SMS...");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
    
    {
        Serial.println("bonjour!!!!"); // message a envoyer
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("Message envoye !");    
        }
        else
        {
            Serial.print("Erreur envoi SMS !");
        }
    }
    else
    {
       // Serial.print("Erreur !");
       // Serial.println(answer, DEC);
    }

}

// -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*  SETUP PARTIE GPS  -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
{

  Wire.begin();                                       // Start I2C comms
  Serial.begin(9600);                                 // Start PC serial port @ 9600 baud
  delay(6000);                                        // Wait 3 seconds for DS-GPM.S to initialise

}
}



//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=-=-=-=-=-=-=-=
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=-=-=-=-=-=-=-=


void loop()
{
  // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*  LOOP PARTIE GPS  -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
  {
  Serial.println(" ");
  Serial.print("Date : ");
  Get_Date();

  Serial.print("Heure : ");
  Get_Heure();

  delay(500);                                        // wait

  Serial.print("Satellites en vue : ");
  Get_Satellites_vus();

 

  Serial.print("Vitesse : ");
  Get_Vitesse();

  Serial.println(" ");
  delay(500);                                        // Wait

  
  Serial.print("Latitude calcul : ");
  GetLatitude_Calcul();
  Serial.println(Latitude_C,6);



  Serial.println(" ");
  

  
  Serial.print("Longitude calcul : "); 
  GetLongitude_Calcul();
  Serial.println(Longitude_C,6);
 




 delay(5000);
  Serial.println(" ");
    Serial.println(" ");
      Serial.println(" ");
        Serial.println(" ");
}


/*---------------------------------------------------------
 Sous programme 'GetDouble'
 ------------------------------------------------------------ */
int GetDouble()
{              // Get double register value from GPM
  int Value = 0; 
  byte H_Byte = 0;
  byte L_Byte = 0;

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 2);           // Request double register
  while(Wire.available() < 2);            // Wait for double byte
  H_Byte = Wire.read();                            // Store one
  L_Byte = Wire.read();                            // Store two

  Value = (H_Byte * 10) + L_Byte;                     // Adjust for one byte

    return(Value);                            
}

/*---------------------------------------------------------
 Sous programme 'GetSingle'
 ------------------------------------------------------------ */
int GetSingle()
{             // Get single register value from GPM
  int Value = 0; 

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 1);           // Request register
  while(Wire.available() < 1);            // Wait for single byte
  Value = Wire.read();                             // and store

  return(Value);                            
}


/*---------------------------------------------------------
 Sous programme 'Get_Date'
 ------------------------------------------------------------ */
byte Get_Date()
{
  Address = 6;                                        // Adresse Registre JOUR
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 8;                                        // Adresse Registre MOIS
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 10;                                       // Adresse Registre ANNEE (Milliers et Centaines)
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Address = 12;                                       // Adresse Registre ANNEE (Dizaines et Unités)
  Data = GetDouble();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
} 

/*---------------------------------------------------------
 Sous programme 'Get_Heure'
 ------------------------------------------------------------ */
byte Get_Heure()
{
  Address = 0;                                        // Adresse Registre Heures
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 2;                                        // Adresse Registre Minutes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 4;                                        // Adresse Registre Secondes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}

/*---------------------------------------------------------
 Sous programme 'Get_Satellites_vus'
 ------------------------------------------------------------ */
byte Get_Satellites_vus()
{
  Address = 35;           //58 version1 / 35 Version2 // Adresse de Pointage satellites en vue
  Data = GetSingle();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}


/*---------------------------------------------------------
 Sous programme 'Get_Vitesse'
 ------------------------------------------------------------ */
int Get_Vitesse()
{
  Address = 52;                                       // Point to Speed 1 register
  Data = GetDouble();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Address = 54;                                       // Point to Speed 2 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Serial.print(".");
  Address = 55;                                       // Point to Speed 3 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // and print to PC
}


/*---------------------------------------------------------
 Sous programme 'GetLatitude_Calcul'
 ------------------------------------------------------------ */
double GetLatitude_Calcul()
{
  Address = 14;                                       // Registre Latitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 15;                                       // Registre Latitude Dizaines de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 16;                                       // Registre Latitude Dizaines de minutes
  Data_6 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 17;                                       // Registre Latitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 18;                                       // Registre Latitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 19;                                       // Registre Latitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 20;                                       // Registre Latitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 21;                                       // Registre Latitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)


  Latitude_1=(Data_8*10+Data_7);  
  Latitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Latitude_2=(Latitude_2/60);
    Latitude_C = (Latitude_1+(Latitude_2*1E-4));
  return (Latitude_C);
}



/*---------------------------------------------------------
 Sous programme 'GetLongitude_Calcul'
 ------------------------------------------------------------ */
double GetLongitude_Calcul()
{
  Address = 23;                                       // Registre Longitude Centaines de degrés
  Data_9 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 24;                                       // Registre Longitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 25;                                       // Registre Longitude Unités de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 26;                                       // Registre Longitude Dizaines de minutes
  Data_6 = GetSingle();                               /// Lire le registre du GPM (1 octet)

  Address = 27;                                       // Registre Longitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 28;                                       // Registre Longitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 29;                                       // Registre Longitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 30;                                       // Registre Longitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 31;                                       // Registre Longitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Longitude_1=(Data_9*1E2+Data_8*10+Data_7);  
  Longitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Longitude_2=(Longitude_2/60);

    Longitude_C = (Longitude_1+(Longitude_2*1E-4));
  return (Longitude_C);
}
}
// -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*  PARTIE SMS  -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

// Définition des différentes fonctions.
//le programme SMS n'est pas dans la partie voidloop
void power_on(){

    uint8_t answer=0;
    
    // Cette commande vérifie si le module GSM est en marche.
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // Mise en marche du module GSM
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // Envoie d'une commande AT toutes les deux secondes et attente d'une réponse.
        while(answer == 0){
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}

// Cette fonction permet d'envoyer des commandes AT au module GSM.
int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout){

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    // Initialisation de la chaine de caractère (string).
    memset(response, '\0', 100);
    
    delay(100);
    
    // Initialisation du tampon d'entrée (input buffer).
    while( Serial.available() > 0) Serial.read();
    
    // Envoi des commandes AT
    Serial.println(ATcommand);


    x = 0;
    previous = millis();

    // Cette boucle attend la réponse du module GSM.
    
    do{
// Cette commande vérifie s'il y a des données disponibles dans le tampon.
//Ces données sont comparées avec la réponse attendue.
        if(Serial.available() != 0){    
            response[x] = Serial.read();
            x++;
            // Comparaison des données
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Attente d'une réponse.
    }while((answer == 0) && ((millis() - previous) < timeout));    

   // Serial.println(response); //Cette ligne permet de debuguer le programme en cas de problème !
   return answer;
}

 Si quelqu'un peut me venir en aide pour « fusionner » les programmes ce serait super car je suis dans une impasse…  de plus fusionner ces programmes n'est que le début après il faut que je trouve un moyen pour pouvoir copier / coller les réponses de mon GPS dans le texte de message…

Mon deuxième but est de le compléter en ajoutant une fonction qui est de définir une zone où le module sera (avec les dixaines centaines et millièmes de degrés), lorsque le module sors de cette zone la carte Arduino envoie un SMS au téléphone puis lorsque j'enverrai un SMS du type "localisationposition" depuis mon téléphone j'aimerais que la carte Arduino me renvoie la localisation du module. ( ce qui me semble assez compliqué , je ne sais pas si je vais arriver au bout..)

En attendant impatiemment vos réponses !

Mat

-
Edité par MatMathieuu 9 avril 2018 à 20:45:14

Je crois que tu t'es un peu mélangé les pinceaux dans les codes que tu as posté.

Mais pour faire simple, l'envoie de SMS est assez simple avec le code suivant :

    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);
    answer = sendATcommand(aux_string, ">", 2000);
    if ( answer == 1 ) {
        Serial.println("bonjour!!!!");
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
    }

Quand à ton code pour l'affichage du GPS, c'est là aussi assez simple :

  Serial.print("Latitude calcul : ");
  GetLatitude_Calcul();
  Serial.println(Latitude_C,6);
 
  Serial.print("Longitude calcul : ");
  GetLongitude_Calcul();
  Serial.println(Longitude_C,6);

Au final, ce sont tes variables Latitude_C et Longitude_C qui contiennent les coordonnées.

Du coup, il ne reste tout simplement plus qu'à les envoyer par SMS.

Ce qui donne quelque chose dans ce style :

// 1: Calcul des coordoonées
  GetLatitude_Calcul();
  GetLongitude_Calcul();

// 2: Envoie par SMS
    answer = sendATcommand(aux_string, ">", 2000);
    if ( answer == 1 ) {
        Serial.println("Bonjour,");
        Serial.println("Voici ma position:");
        Serial.print("Latitude: ");
        Serial.println(Latitude_C,6);
        Serial.print("Longitude: ");
        Serial.println(Longitude_C,6);
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
    }

Merci de ta réponse rapide,

Partie GPS j'ai compris comment cela ce passait car c'est moi qui ai fait en sorte que ça m'affiche les coordonnées déjà calculées dans le moniteur série , c'était plus partie programme du module GSM qui était ambigu.

Merci pour la partie envoie des coordonnées SMS c'est tout bête, je pensais faire autrement en créant une variable englobant tout les message du module GPS...

mon problème est maintenant que  le programme m'affiche plein d'erreur de variables..

je ne sais pas d'u cela peut venir, peut être les des parenthèses { et } vu que individuellement les programmes marchent très bien ..

Effectivement, il te manque des accolades.

Si je prends l'exemple de ta fonction loop, tu ouvres une accolade à la ligne 88 puis une seconde à la ligne 90 mais il n'y a qu'une seule accolade fermante à la ligne 135.

Alors forcément, si tu ouvres plus d'accolades que tu n'en fermes, il y a aura forcément un problème de compilation

Oui effectivement je ne l'avais pas vu, maintenant tout fonctionne ! merci !

Mais j’ai encore un souci…

Lorsque je lance le programme voilà ce que ça m’affiche… :

 

Les programmes ne doivent pas s’exécuter en même temps je pense, tout d’abord le programme SMS se lance puis ensuite le programme GPS mais alors je ne sais pas comment faire pour que les coordonnées GPS s’affiche dans le corps du message.

Ps : je reçois bien le SMS mais comme dans le moniteur série : 0.00000 en latitude et longitude

Doit-on transférer toute la partie void loop dans la partie void setup ? ( car en plus de ça les positions GPS dans le moniteur série n’arrêtent pas de s’afficher en continu, y a-t-il un autre moyen pour arrêter cette boucle ?)

Peux-tu m’éclaircir ?

voila le code:

// VAR GPS
#include <Wire.h>
#define GPM 0x68                                  // GPM I2C Address
byte Address;                                         // Global variable
byte Data;                                            // Global variable
byte Data_10, Data_9, Data_8, Data_7, Data_6, Data_5, Data_4, Data_3, Data_2, Data_1;
int Latitude_1, Longitude_1;
long Latitude_2, Longitude_2;
float Latitude_C, Longitude_C; 

//VAR SMS
int8_t answer;
int onModulePin= 2; // port DTR (ou PWR) du module SIM900.
char aux_string[30];
char phone_number[]="+336********"; //numéro tel


void setup()
{

// -*-*-*-*-*-*-*-*  SETUP PARTIE GPS  -*-*-*-*-*-*-*
  
  Wire.begin();                                       // Start I2C comms
  Serial.begin(115200);// Start PC serial port @ 9600 baud
   Serial.println("GPS: démarrage");
  delay(5000);                                        // Wait for DS-GPM.S to initialise
  

  
// -*-*-*-*-*-*-*-*-*-*  SETUP PARTIE SMS  -*-*-*-*-*-*-*-*-*-*
    
    pinMode(onModulePin, OUTPUT);
    Serial.begin(115200);
       
    Serial.println("");
    Serial.println("***localisation GPS+GSM***");
    Serial.println("");
    Serial.println("Attente allumage du module SIM..");
    
    
   power_on(); // Cette commande active la carte SIM.
    delay(5000);

    
   

        while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) ||                     //Attente allumage du module
               sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );               //Attente allumage du module

    Serial.println("activation mode SMS ...");  // Activation du mode texte pour les SMS.
    sendATcommand("AT+CMGF=1", "OK", 1000);
    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("Envoi du SMS...");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
    
                 //envoi SMS de la position 
        Serial.println("Position module:");
        Serial.println("");
        Serial.print("Latitude: ");
        Serial.println(Latitude_C,6);
        Serial.print("Longitude: ");
        Serial.println(Longitude_C,6);
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("Message envoye !");    
        }
        else
        {
            Serial.print("Erreur envoi SMS !");
        }
  }
    else
    {
        Serial.print("Erreur !");
        Serial.println(answer, DEC);
    }


}




//===
//=========
//==============
//=========
//===



void loop()
{
  // -*-*-*-*-*-*-*-*  LOOP PARTIE GPS  -*-*-*-*-*-*-*-
  Serial.println(" ");
  Serial.print("Date : ");
  Get_Date();

  Serial.print("Heure : ");
  Get_Heure();

  delay(500);                                        // wait

  Serial.print("Satellites en vue : ");
  Get_Satellites_vus();

 

  Serial.print("Vitesse : ");
  Get_Vitesse();

  Serial.println(" ");
  delay(500);                                        // Wait

  
  Serial.print("Latitude calcul : ");
  GetLatitude_Calcul();                  // calcul coordonnées
  Serial.println(Latitude_C,6);          // envoyer coordonées



  Serial.println(" ");
  

  
  Serial.print("Longitude calcul : "); 
  GetLongitude_Calcul();                // calcul coordonnées
  Serial.println(Longitude_C,6);
 




 delay(5000);
  Serial.println(" ");
}

/*--------------------------
 Sous programme 'GetDouble'
 --------------------------- */
int GetDouble()
{              // Get double register value from GPM
  int Value = 0; 
  byte H_Byte = 0;
  byte L_Byte = 0;

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 2);           // Request double register
  while(Wire.available() < 2);            // Wait for double byte
  H_Byte = Wire.read();                            // Store one
  L_Byte = Wire.read();                            // Store two

  Value = (H_Byte * 10) + L_Byte;                     // Adjust for one byte

    return(Value);                            
}

/*--------------------------
 Sous programme 'GetSingle'
 --------------------------- */
int GetSingle()
{             // Get single register value from GPM
  int Value = 0; 

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 1);           // Request register
  while(Wire.available() < 1);            // Wait for single byte
  Value = Wire.read();                             // and store

  return(Value);                            
}


/*-------------------------
 Sous programme 'Get_Date'
 --------------------------- */
byte Get_Date()
{
  Address = 6;                                        // Adresse Registre JOUR
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 8;                                        // Adresse Registre MOIS
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 10;                                       // Adresse Registre ANNEE (Milliers et Centaines)
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Address = 12;                                       // Adresse Registre ANNEE (Dizaines et Unités)
  Data = GetDouble();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
} 

/*--------------------------
 Sous programme 'Get_Heure'
 ---------------------------*/
byte Get_Heure()
{
  Address = 0;                                        // Adresse Registre Heures
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 2;                                        // Adresse Registre Minutes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 4;                                        // Adresse Registre Secondes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}

/*------------------------------------
 Sous programme 'Get_Satellites_vus'
 ------------------------------------ */
byte Get_Satellites_vus()
{
  Address = 35;           //58 version1 / 35 Version2 // Adresse de Pointage satellites en vue
  Data = GetSingle();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}


/*-----------------------------
 Sous programme 'Get_Vitesse'
 ----------------------------- */
int Get_Vitesse()
{
  Address = 52;                                       // Point to Speed 1 register
  Data = GetDouble();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Address = 54;                                       // Point to Speed 2 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Serial.print(".");
  Address = 55;                                       // Point to Speed 3 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // and print to PC
}


/*------------------------------------
 Sous programme 'GetLatitude_Calcul'
 -------------------------------------*/
double GetLatitude_Calcul()
{
  Address = 14;                                       // Registre Latitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 15;                                       // Registre Latitude Dizaines de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 16;                                       // Registre Latitude Dizaines de minutes
  Data_6 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 17;                                       // Registre Latitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 18;                                       // Registre Latitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 19;                                       // Registre Latitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 20;                                       // Registre Latitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 21;                                       // Registre Latitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)


  Latitude_1=(Data_8*10+Data_7);  
  Latitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Latitude_2=(Latitude_2/60);
    Latitude_C = (Latitude_1+(Latitude_2*1E-4));
  return (Latitude_C);
}



/*-------------------------------------
 Sous programme 'GetLongitude_Calcul'
 -------------------------------------- */
double GetLongitude_Calcul()
{
  Address = 23;                                       // Registre Longitude Centaines de degrés
  Data_9 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 24;                                       // Registre Longitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 25;                                       // Registre Longitude Unités de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 26;                                       // Registre Longitude Dizaines de minutes
  Data_6 = GetSingle();                               /// Lire le registre du GPM (1 octet)

  Address = 27;                                       // Registre Longitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 28;                                       // Registre Longitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 29;                                       // Registre Longitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 30;                                       // Registre Longitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 31;                                       // Registre Longitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Longitude_1=(Data_9*1E2+Data_8*10+Data_7);  
  Longitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Longitude_2=(Longitude_2/60);

    Longitude_C = (Longitude_1+(Longitude_2*1E-4));
  return (Longitude_C);
}

//-*-*-*-*-*-*-*-*-*-*-*-*  PARTIE SMS  -*-*-*-*-*-*-*-*-*-*-*-

// Définition des différentes fonctions.
//le programme SMS n'est pas dans la partie voidloop
void power_on(){

    uint8_t answer=0;
    
    // Cette commande vérifie si le module GSM est en marche.
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // Mise en marche du module GSM
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // Envoie d'une commande AT toutes les deux secondes et attente d'une réponse.
        while(answer == 0){
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}

// Cette fonction permet d'envoyer des commandes AT au module GSM.
int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout)
{

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    // Initialisation de la chaine de caractère (string).
    memset(response, '\0', 100);
    
    delay(100);
    
    // Initialisation du tampon d'entrée (input buffer).
    while( Serial.available() > 0) Serial.read();
    
    // Envoi des commandes AT
    Serial.println(ATcommand);


    x = 0;
    previous = millis();

    // Cette boucle attend la réponse du module GSM.
    
    do{
// Cette commande vérifie s'il y a des données disponibles dans le tampon.
//Ces données sont comparées avec la réponse attendue.
        if(Serial.available() != 0){    
            response[x] = Serial.read();
            x++;
            // Comparaison des données
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Attente d'une réponse.
    }while((answer == 0) && ((millis() - previous) < timeout));    

   // Serial.println(response); //Cette ligne permet de debuguer le programme en cas de problème !
   return answer;
}

-
Edité par MatMathieuu 10 avril 2018 à 20:48:26

La fonction setup s'exécute une seule fois au début du programme.

Puis la fonction loop s'exécute en boucle.

Vu que ton bout de code pour envoyer le SMS se trouve dans setup, il ne sera exécuté qu'une seule fois, ce qui explique pourquoi tu ne reçois qu'un seule SMS.

Cependant, au moment où l'arduino exécute le code du SMS, il n'a pas encore exécuté la partie concernant le GPS donc les coordonnées sont forcément à 0.

Vient ensuite ton code du GPS affichant les données qui se trouve dans la fonction loop donc il va s'exécuter en boucle, ce qui explique pourquoi tu vois les coordonnées s'afficher en permanence par la suite.

Si tu veux que ton programme envoie par SMS les bonnes coordonnées, il faudrait appeler la gestion du SMS dans le loop, après avoir fait la partie du GPS.

En faisant ça, tu auras donc un SMS à chaque fois qu'il y a un message sur le moniteur.

Si tu ne veux pas recevoir 36000 SMS, tu peux ajouter un if permettant d'en n'envoyer qu'un :

int SMS_sended = 0;

void loop() {

    [...] // <== Code pour le GPS

    // Si position correct
    if ( ( Latitude_C != 0 ) && ( Longitude_C != 0 ) ) {

        // Et si SMS pas encore envoyé
        if ( SMS_sended == 0 ) {

            // Alors on envoie le SMS
            [...] // <== Code pour le SMS

            // Puis on enregistre le fait que le SMS a été envoyé
            // de façon à ne pas en renvoyer un autre
            SMS_sended = 1;

        }

    }

}

-

-
Edité par MatMathieuu 9 mai 2018 à 0:52:58

je poste ce message avec un pseudo bidonc car " je dois attendre 24h avant de poster un nouveau message à la suite " alors que je n'ai pas poster de message....

voila le message: 

Merci Beaucoup ça fonctionne !

Je suis donc passé à la deuxième phase : si mon module se déplace de 20 m j’envoie un SMS de l'emplacement.

J’ai donc regardé sur https://www.geoportail.gouv.fr/carte  a quoi correspondait un déplacement de 20 m et j'ai vu que cela correspondait à : latitude : (+ si on avance et - si on recule) 00.000150 et de mème pour longitude :(+ si on avance et - si on recule )0.000150 .

Je me suis donc mis en question de comment je pourrai faire et j'ai eu une idée toute simple : faire une variable. Je m’explique : on allume le module : il est donc défini sur les coordonnées la ou il est allumé alors la variable =0 mais si on le déplace de : latitude +/- 0.000150 ou longitude +/- 0.000150 dans ses coordonnées, la variable passe a 1 et avec une fonction if j’envoie le SMS.

J’aimerais avoir ton avis pour savoir si cela est une bonne idée ou si je me trompe ?

De plus je ne sais pas du tout comment faire pour définir le déplacement de la ruche car il faut définir si elle gagne ou perd des coordonnées. J’ai donc  recherché mais sans résultat j’ai donc essayer de commencer mais je suis bloqué:

 Int Varlong = Longitude_C,6

Int Varlat = Latitude_C,6

if (Varlong = (ici ou viendra s’insérer le + ou – 0.000150))

{

  [...] // <== code evoi SMS

}

if (Varlat = (ici ou viendra s’insérer le + ou – 0.000150))

{

  [...] // <== code envoi SMS

}

Est-ce un bon début si l’idée de variable est la bonne ? (si oui ya t’il pas moyen de fusionner les 2 if pour ne pas a recopier 2 fois le code envoie SMS ?

Je te montre mon code d’envoi SMS fonctionnel et le moniteur série :

// VAR GPS
#include <Wire.h>
#define GPM 0x68                                  // GPM I2C Address
byte Address;                                         // Global variable
byte Data;                                            // Global variable
byte Data_10, Data_9, Data_8, Data_7, Data_6, Data_5, Data_4, Data_3, Data_2, Data_1;
int Latitude_1, Longitude_1;
long Latitude_2, Longitude_2;
float Latitude_C, Longitude_C; 

//VAR SMS
int8_t answer;
int onModulePin= 2; // port DTR (ou PWR) du module SIM900.
char aux_string[30];
char phone_number[]="+33651***"; //numéro tel
int SMS_sended = 0;


void setup()
{
  
    Serial.println("");
    Serial.println("***localisation GPS+GSM***");
    Serial.println("");
    
// -*-*-*-*-*-*-*-*  SETUP PARTIE GPS  -*-*-*-*-*-*-*
  
  Wire.begin();                                       // Start I2C comms
  Serial.begin(115200);                               // Start PC serial port 
 delay(500);
     Serial.println("****************************");
     Serial.println("***/localisation GPS+GSM/***");
     Serial.println("****************************");
 delay(300);
   Serial.println("Allumage du module GPS");
   delay(500);
   Serial.print(".");
   delay(500);
   Serial.print(".");
   delay(500);
   Serial.println(".");

  
  delay(5000);                                        // Wait for DS-GPM.S to initialise
  

  
// -*-*-*-*-*-*-*-*-*-*  SETUP PARTIE SMS  -*-*-*-*-*-*-*-*-*-*
    
    pinMode(onModulePin, OUTPUT);
    Serial.begin(115200);
       
    
    Serial.println("Allumage du module SIM");
    delay(500);
    Serial.print(".");
    delay(500);
    Serial.print(".");
    delay(500);
    Serial.println(".");
    delay(5000);
}



//===
//=========
//==============
//=========
//===


void loop()
{
// Si position correct
if ( ( Latitude_C != 0 ) && ( Longitude_C != 0 ) ) {
 
        // Et si SMS pas encore envoyé
        if ( SMS_sended == 0 ) {
 
            // Alors on envoie le SMS
           
            power_on(); // Cette commande active la carte SIM.
    delay(5000);

    
   

        while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) ||                     //Attente allumage du module
               sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );               //Attente allumage du module

    Serial.println("activation mode SMS ...");  // Activation du mode texte pour les SMS.
    sendATcommand("AT+CMGF=1", "OK", 1000);
    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("-------- Envoi du 1er SMS... --------");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
     delay(10000);

       //envoi SMS de la position 
       
        Serial.print("Date : ");
        Get_Date();
        Serial.print("Heure : ");
        Get_Heure();
        Serial.print("Satellites en vue :");
        Get_Satellites_vus();
        Serial.print("Vitesse :");
        Get_Vitesse();
     
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("-------- 1er message envoye ! --------");    
        }
        else
        {
            Serial.print("********Erreur envoi SMS !********");
        }
  }
  
    else
    {
        Serial.print("********Erreur !********");
        Serial.println(answer, DEC);
    }


    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("-------- Envoi du 2nd SMS... --------");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
     delay(3000);

       //envoi SMS de la position 
       
        Serial.println("Position module:");
        Serial.println("");
        Serial.print("Latitude: ");
        Serial.println(Latitude_C,6);
        Serial.print("Longitude: ");
        Serial.println(Longitude_C,6);
        Serial.print("www.coordonnees-gps.fr/");
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("-------- 2nd message envoye ! --------");    
        }
        else
        {
            Serial.print("********Erreur envoi SMS !********");
        }
  }
  
    else
    {
        Serial.print("********Erreur !********");
        Serial.println(answer, DEC);
    }



    
 
            // Puis on enregistre le fait que le SMS a été envoyé
            // de façon à ne pas en renvoyer un autre
            SMS_sended = 1;
 
        }
 
    }
 



  // -*-*-*-*-*-*-*-*  LOOP PARTIE GPS  -*-*-*-*-*-*-*-
  
   
  GetLatitude_Calcul();                  // calcul coordonnées
  GetLongitude_Calcul();                // calcul coordonnées


 delay(5000);
 
}

/*--------------------------
 Sous programme 'GetDouble'
 --------------------------- */
int GetDouble()
{              // Get double register value from GPM
  int Value = 0; 
  byte H_Byte = 0;
  byte L_Byte = 0;

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 2);           // Request double register
  while(Wire.available() < 2);            // Wait for double byte
  H_Byte = Wire.read();                            // Store one
  L_Byte = Wire.read();                            // Store two

  Value = (H_Byte * 10) + L_Byte;                     // Adjust for one byte

    return(Value);                            
}

/*--------------------------
 Sous programme 'GetSingle'
 --------------------------- */
int GetSingle()
{             // Get single register value from GPM
  int Value = 1; 

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 1);           // Request register
  while(Wire.available() < 1);            // Wait for single byte
  Value = Wire.read();                             // and store

  return(Value);                            
}


/*-------------------------
 Sous programme 'Get_Date'
 --------------------------- */
byte Get_Date()
{
  Address = 6;                                        // Adresse Registre JOUR
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 8;                                        // Adresse Registre MOIS
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 10;                                       // Adresse Registre ANNEE (Milliers et Centaines)
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Address = 12;                                       // Adresse Registre ANNEE (Dizaines et Unités)
  Data = GetDouble();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
} 

/*--------------------------
 Sous programme 'Get_Heure'
 ---------------------------*/
byte Get_Heure()
{
  Address = 0;                                        // Adresse Registre Heures
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 2;                                        // Adresse Registre Minutes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 4;                                        // Adresse Registre Secondes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}

/*------------------------------------
 Sous programme 'Get_Satellites_vus'
 ------------------------------------ */
byte Get_Satellites_vus()
{
  Address = 35;           //58 version1 / 35 Version2 // Adresse de Pointage satellites en vue
  Data = GetSingle();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}


/*-----------------------------
 Sous programme 'Get_Vitesse'
 ----------------------------- */
int Get_Vitesse()
{
  Address = 52;                                       // Point to Speed 1 register
  Data = GetDouble();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Address = 54;                                       // Point to Speed 2 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Serial.print(".");
  Address = 55;                                       // Point to Speed 3 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // and print to PC
}


/*------------------------------------
 Sous programme 'GetLatitude_Calcul'
 -------------------------------------*/
double GetLatitude_Calcul()
{
  Address = 14;                                       // Registre Latitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 15;                                       // Registre Latitude Dizaines de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 16;                                       // Registre Latitude Dizaines de minutes
  Data_6 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 17;                                       // Registre Latitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 18;                                       // Registre Latitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 19;                                       // Registre Latitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 20;                                       // Registre Latitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 21;                                       // Registre Latitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)


  Latitude_1=(Data_8*10+Data_7);  
  Latitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Latitude_2=(Latitude_2/60);
    Latitude_C = (Latitude_1+(Latitude_2*1E-4));
  return (Latitude_C);
}



/*-------------------------------------
 Sous programme 'GetLongitude_Calcul'
 -------------------------------------- */
double GetLongitude_Calcul()
{
  Address = 23;                                       // Registre Longitude Centaines de degrés
  Data_9 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 24;                                       // Registre Longitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 25;                                       // Registre Longitude Unités de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 26;                                       // Registre Longitude Dizaines de minutes
  Data_6 = GetSingle();                               /// Lire le registre du GPM (1 octet)

  Address = 27;                                       // Registre Longitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 28;                                       // Registre Longitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 29;                                       // Registre Longitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 30;                                       // Registre Longitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 31;                                       // Registre Longitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Longitude_1=(Data_9*1E2+Data_8*10+Data_7);  
  Longitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Longitude_2=(Longitude_2/60);

    Longitude_C = (Longitude_1+(Longitude_2*1E-4));
  return (Longitude_C);
}





//-*-*-*-*-*-*-*-*-*-*-*-*  PARTIE SMS  -*-*-*-*-*-*-*-*-*-*-*-

// Définition des différentes fonctions.
//le programme SMS n'est pas dans la partie voidloop
void power_on(){

    uint8_t answer=0;
    
    // Cette commande vérifie si le module GSM est en marche.
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // Mise en marche du module GSM
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // Envoie d'une commande AT toutes les deux secondes et attente d'une réponse.
        while(answer == 0){
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}

// Cette fonction permet d'envoyer des commandes AT au module GSM.
int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout)
{

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    // Initialisation de la chaine de caractère (string).
    memset(response, '\0', 100);
    
    delay(100);
    
    // Initialisation du tampon d'entrée (input buffer).
    while( Serial.available() > 0) Serial.read();
    
    // Envoi des commandes AT
    Serial.println(ATcommand);


    x = 0;
    previous = millis();

    // Cette boucle attend la réponse du module GSM.
    
    do{
// Cette commande vérifie s'il y a des données disponibles dans le tampon.
//Ces données sont comparées avec la réponse attendue.
        if(Serial.available() != 0){    
            response[x] = Serial.read();
            x++;
            // Comparaison des données
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Attente d'une réponse.
    }while((answer == 0) && ((millis() - previous) < timeout));    

   // Serial.println(response); //Cette ligne permet de debuguer le programme en cas de problème !
   return answer;
}

Merci Beaucoup ça fonctionne !

Je suis donc passé à la deuxième phase : si mon module se déplace de 20 m j’envoie un SMS de l'emplacement.

J’ai donc regardé sur https://www.geoportail.gouv.fr/carte a quoi correspondait un déplacement de 20 m et j'ai vu que cela correspondait à : latitude : (+ si on avance et - si on recule) 00.000150 et de mème pour longitude :(+ si on avance et - si on recule )0.000150 .

Je me suis donc mis en question de comment je pourrai faire et j'ai eu une idée toute simple : faire une variable. Je m’explique : on allume le module : il est donc défini sur les coordonnées la ou il est allumé alors la variable =0 mais si on le déplace de : latitude +/- 0.000150 ou longitude +/- 0.000150 dans ses coordonnées, la variable passe a 1 et avec une fonction if j’envoie le SMS.

J’aimerais avoir ton avis pour savoir si cela est une bonne idée ou si je me trompe ?

De plus je ne sais pas du tout comment faire pour définir le déplacement de la ruche car il faut définir si elle gagne ou perd des coordonnées. J’ai donc recherché mais sans résultat j’ai donc essayer de commencer mais je suis bloqué:

 Int Varlong = Longitude_C,6

Int Varlat = Latitude_C,6

if (Varlong = (ici ou viendra s’insérer le + ou – 0.000150))

{

  [...] // <== code evoi SMS

}

if (Varlat = (ici ou viendra s’insérer le + ou – 0.000150))

{

  [...] // <== code envoi SMS

}

Est-ce un bon début si l’idée de variable est la bonne ? (si oui ya t’il pas moyen de fusionner les 2 if pour ne pas a recopier 2 fois le code envoie SMS ?

Je te montre mon code d’envoi SMS fonctionnel et le moniteur série :

// VAR GPS
#include <Wire.h>
#define GPM 0x68                                  // GPM I2C Address
byte Address;                                         // Global variable
byte Data;                                            // Global variable
byte Data_10, Data_9, Data_8, Data_7, Data_6, Data_5, Data_4, Data_3, Data_2, Data_1;
int Latitude_1, Longitude_1;
long Latitude_2, Longitude_2;
float Latitude_C, Longitude_C; 

//VAR SMS
int8_t answer;
int onModulePin= 2; // port DTR (ou PWR) du module SIM900.
char aux_string[30];
char phone_number[]="+33651***"; //numéro tel
int SMS_sended = 0;


void setup()
{
  
    Serial.println("");
    Serial.println("***localisation GPS+GSM***");
    Serial.println("");
    
// -*-*-*-*-*-*-*-*  SETUP PARTIE GPS  -*-*-*-*-*-*-*
  
  Wire.begin();                                       // Start I2C comms
  Serial.begin(115200);                               // Start PC serial port 
 delay(500);
     Serial.println("****************************");
     Serial.println("***/localisation GPS+GSM/***");
     Serial.println("****************************");
 delay(300);
   Serial.println("Allumage du module GPS");
   delay(500);
   Serial.print(".");
   delay(500);
   Serial.print(".");
   delay(500);
   Serial.println(".");

  
  delay(5000);                                        // Wait for DS-GPM.S to initialise
  

  
// -*-*-*-*-*-*-*-*-*-*  SETUP PARTIE SMS  -*-*-*-*-*-*-*-*-*-*
    
    pinMode(onModulePin, OUTPUT);
    Serial.begin(115200);
       
    
    Serial.println("Allumage du module SIM");
    delay(500);
    Serial.print(".");
    delay(500);
    Serial.print(".");
    delay(500);
    Serial.println(".");
    delay(5000);
}



//===
//=========
//==============
//=========
//===


void loop()
{
// Si position correct
if ( ( Latitude_C != 0 ) && ( Longitude_C != 0 ) ) {
 
        // Et si SMS pas encore envoyé
        if ( SMS_sended == 0 ) {
 
            // Alors on envoie le SMS
           
            power_on(); // Cette commande active la carte SIM.
    delay(5000);

    
   

        while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) ||                     //Attente allumage du module
               sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );               //Attente allumage du module

    Serial.println("activation mode SMS ...");  // Activation du mode texte pour les SMS.
    sendATcommand("AT+CMGF=1", "OK", 1000);
    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("-------- Envoi du 1er SMS... --------");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
     delay(10000);

       //envoi SMS de la position 
       
        Serial.print("Date : ");
        Get_Date();
        Serial.print("Heure : ");
        Get_Heure();
        Serial.print("Satellites en vue :");
        Get_Satellites_vus();
        Serial.print("Vitesse :");
        Get_Vitesse();
     
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("-------- 1er message envoye ! --------");    
        }
        else
        {
            Serial.print("********Erreur envoi SMS !********");
        }
  }
  
    else
    {
        Serial.print("********Erreur !********");
        Serial.println(answer, DEC);
    }


    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("-------- Envoi du 2nd SMS... --------");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
     delay(3000);

       //envoi SMS de la position 
       
        Serial.println("Position module:");
        Serial.println("");
        Serial.print("Latitude: ");
        Serial.println(Latitude_C,6);
        Serial.print("Longitude: ");
        Serial.println(Longitude_C,6);
        Serial.print("www.coordonnees-gps.fr/");
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("-------- 2nd message envoye ! --------");    
        }
        else
        {
            Serial.print("********Erreur envoi SMS !********");
        }
  }
  
    else
    {
        Serial.print("********Erreur !********");
        Serial.println(answer, DEC);
    }



    
 
            // Puis on enregistre le fait que le SMS a été envoyé
            // de façon à ne pas en renvoyer un autre
            SMS_sended = 1;
 
        }
 
    }
 



  // -*-*-*-*-*-*-*-*  LOOP PARTIE GPS  -*-*-*-*-*-*-*-
  
   
  GetLatitude_Calcul();                  // calcul coordonnées
  GetLongitude_Calcul();                // calcul coordonnées


 delay(5000);
 
}

/*--------------------------
 Sous programme 'GetDouble'
 --------------------------- */
int GetDouble()
{              // Get double register value from GPM
  int Value = 0; 
  byte H_Byte = 0;
  byte L_Byte = 0;

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 2);           // Request double register
  while(Wire.available() < 2);            // Wait for double byte
  H_Byte = Wire.read();                            // Store one
  L_Byte = Wire.read();                            // Store two

  Value = (H_Byte * 10) + L_Byte;                     // Adjust for one byte

    return(Value);                            
}

/*--------------------------
 Sous programme 'GetSingle'
 --------------------------- */
int GetSingle()
{             // Get single register value from GPM
  int Value = 1; 

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 1);           // Request register
  while(Wire.available() < 1);            // Wait for single byte
  Value = Wire.read();                             // and store

  return(Value);                            
}


/*-------------------------
 Sous programme 'Get_Date'
 --------------------------- */
byte Get_Date()
{
  Address = 6;                                        // Adresse Registre JOUR
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 8;                                        // Adresse Registre MOIS
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 10;                                       // Adresse Registre ANNEE (Milliers et Centaines)
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Address = 12;                                       // Adresse Registre ANNEE (Dizaines et Unités)
  Data = GetDouble();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
} 

/*--------------------------
 Sous programme 'Get_Heure'
 ---------------------------*/
byte Get_Heure()
{
  Address = 0;                                        // Adresse Registre Heures
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 2;                                        // Adresse Registre Minutes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 4;                                        // Adresse Registre Secondes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}

/*------------------------------------
 Sous programme 'Get_Satellites_vus'
 ------------------------------------ */
byte Get_Satellites_vus()
{
  Address = 35;           //58 version1 / 35 Version2 // Adresse de Pointage satellites en vue
  Data = GetSingle();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}


/*-----------------------------
 Sous programme 'Get_Vitesse'
 ----------------------------- */
int Get_Vitesse()
{
  Address = 52;                                       // Point to Speed 1 register
  Data = GetDouble();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Address = 54;                                       // Point to Speed 2 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Serial.print(".");
  Address = 55;                                       // Point to Speed 3 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // and print to PC
}


/*------------------------------------
 Sous programme 'GetLatitude_Calcul'
 -------------------------------------*/
double GetLatitude_Calcul()
{
  Address = 14;                                       // Registre Latitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 15;                                       // Registre Latitude Dizaines de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 16;                                       // Registre Latitude Dizaines de minutes
  Data_6 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 17;                                       // Registre Latitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 18;                                       // Registre Latitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 19;                                       // Registre Latitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 20;                                       // Registre Latitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 21;                                       // Registre Latitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)


  Latitude_1=(Data_8*10+Data_7);  
  Latitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Latitude_2=(Latitude_2/60);
    Latitude_C = (Latitude_1+(Latitude_2*1E-4));
  return (Latitude_C);
}



/*-------------------------------------
 Sous programme 'GetLongitude_Calcul'
 -------------------------------------- */
double GetLongitude_Calcul()
{
  Address = 23;                                       // Registre Longitude Centaines de degrés
  Data_9 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 24;                                       // Registre Longitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 25;                                       // Registre Longitude Unités de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 26;                                       // Registre Longitude Dizaines de minutes
  Data_6 = GetSingle();                               /// Lire le registre du GPM (1 octet)

  Address = 27;                                       // Registre Longitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 28;                                       // Registre Longitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 29;                                       // Registre Longitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 30;                                       // Registre Longitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 31;                                       // Registre Longitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Longitude_1=(Data_9*1E2+Data_8*10+Data_7);  
  Longitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Longitude_2=(Longitude_2/60);

    Longitude_C = (Longitude_1+(Longitude_2*1E-4));
  return (Longitude_C);
}





//-*-*-*-*-*-*-*-*-*-*-*-*  PARTIE SMS  -*-*-*-*-*-*-*-*-*-*-*-

// Définition des différentes fonctions.
//le programme SMS n'est pas dans la partie voidloop
void power_on(){

    uint8_t answer=0;
    
    // Cette commande vérifie si le module GSM est en marche.
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // Mise en marche du module GSM
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // Envoie d'une commande AT toutes les deux secondes et attente d'une réponse.
        while(answer == 0){
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}

// Cette fonction permet d'envoyer des commandes AT au module GSM.
int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout)
{

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    // Initialisation de la chaine de caractère (string).
    memset(response, '\0', 100);
    
    delay(100);
    
    // Initialisation du tampon d'entrée (input buffer).
    while( Serial.available() > 0) Serial.read();
    
    // Envoi des commandes AT
    Serial.println(ATcommand);


    x = 0;
    previous = millis();

    // Cette boucle attend la réponse du module GSM.
    
    do{
// Cette commande vérifie s'il y a des données disponibles dans le tampon.
//Ces données sont comparées avec la réponse attendue.
        if(Serial.available() != 0){    
            response[x] = Serial.read();
            x++;
            // Comparaison des données
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Attente d'une réponse.
    }while((answer == 0) && ((millis() - previous) < timeout));    

   // Serial.println(response); //Cette ligne permet de debuguer le programme en cas de problème !
   return answer;
}

Merci Beaucoup ça fonctionne !

Je suis donc passé à la deuxième phase : si mon module se déplace de 20 m j’envoie un SMS de l'emplacement.

J’ai donc regardé sur https://www.geoportail.gouv.fr/carte a quoi correspondait un déplacement de 20 m et j'ai vu que cela correspondait à : latitude : (+ si on avance et - si on recule) 00.000150 et de mème pour longitude :(+ si on avance et - si on recule )0.000150 .

Je me suis donc mis en question de comment je pourrai faire et j'ai eu une idée toute simple : faire une variable. Je m’explique : on allume le module : il est donc défini sur les coordonnées la ou il est allumé alors la variable =0 mais si on le déplace de : latitude +/- 0.000150 ou longitude +/- 0.000150 dans ses coordonnées, la variable passe a 1 et avec une fonction if j’envoie le SMS.

J’aimerais avoir ton avis pour savoir si cela est une bonne idée ou si je me trompe ?

De plus je ne sais pas du tout comment faire pour définir le déplacement de la ruche car il faut définir si elle gagne ou perd des coordonnées. J’ai donc recherché mais sans résultat j’ai donc essayer de commencer mais je suis bloqué:

 Int Varlong = Longitude_C,6

Int Varlat = Latitude_C,6

if (Varlong = (ici ou viendra s’insérer le + ou – 0.000150))

{

  [...] // <== code evoi SMS

}

if (Varlat = (ici ou viendra s’insérer le + ou – 0.000150))

{

  [...] // <== code envoi SMS

}

Est-ce un bon début si l’idée de variable est la bonne ? (si oui ya t’il pas moyen de fusionner les 2 if pour ne pas a recopier 2 fois le code envoie SMS ?

Je te montre mon code d’envoi SMS fonctionnel et le moniteur série :

// VAR GPS
#include <Wire.h>
#define GPM 0x68                                  // GPM I2C Address
byte Address;                                         // Global variable
byte Data;                                            // Global variable
byte Data_10, Data_9, Data_8, Data_7, Data_6, Data_5, Data_4, Data_3, Data_2, Data_1;
int Latitude_1, Longitude_1;
long Latitude_2, Longitude_2;
float Latitude_C, Longitude_C; 

//VAR SMS
int8_t answer;
int onModulePin= 2; // port DTR (ou PWR) du module SIM900.
char aux_string[30];
char phone_number[]="+33651***"; //numéro tel
int SMS_sended = 0;


void setup()
{
  
    Serial.println("");
    Serial.println("***localisation GPS+GSM***");
    Serial.println("");
    
// -*-*-*-*-*-*-*-*  SETUP PARTIE GPS  -*-*-*-*-*-*-*
  
  Wire.begin();                                       // Start I2C comms
  Serial.begin(115200);                               // Start PC serial port 
 delay(500);
     Serial.println("****************************");
     Serial.println("***/localisation GPS+GSM/***");
     Serial.println("****************************");
 delay(300);
   Serial.println("Allumage du module GPS");
   delay(500);
   Serial.print(".");
   delay(500);
   Serial.print(".");
   delay(500);
   Serial.println(".");

  
  delay(5000);                                        // Wait for DS-GPM.S to initialise
  

  
// -*-*-*-*-*-*-*-*-*-*  SETUP PARTIE SMS  -*-*-*-*-*-*-*-*-*-*
    
    pinMode(onModulePin, OUTPUT);
    Serial.begin(115200);
       
    
    Serial.println("Allumage du module SIM");
    delay(500);
    Serial.print(".");
    delay(500);
    Serial.print(".");
    delay(500);
    Serial.println(".");
    delay(5000);
}



//===
//=========
//==============
//=========
//===


void loop()
{
// Si position correct
if ( ( Latitude_C != 0 ) && ( Longitude_C != 0 ) ) {
 
        // Et si SMS pas encore envoyé
        if ( SMS_sended == 0 ) {
 
            // Alors on envoie le SMS
           
            power_on(); // Cette commande active la carte SIM.
    delay(5000);

    
   

        while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) ||                     //Attente allumage du module
               sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );               //Attente allumage du module

    Serial.println("activation mode SMS ...");  // Activation du mode texte pour les SMS.
    sendATcommand("AT+CMGF=1", "OK", 1000);
    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("-------- Envoi du 1er SMS... --------");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
     delay(10000);

       //envoi SMS de la position 
       
        Serial.print("Date : ");
        Get_Date();
        Serial.print("Heure : ");
        Get_Heure();
        Serial.print("Satellites en vue :");
        Get_Satellites_vus();
        Serial.print("Vitesse :");
        Get_Vitesse();
     
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("-------- 1er message envoye ! --------");    
        }
        else
        {
            Serial.print("********Erreur envoi SMS !********");
        }
  }
  
    else
    {
        Serial.print("********Erreur !********");
        Serial.println(answer, DEC);
    }


    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("-------- Envoi du 2nd SMS... --------");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
     delay(3000);

       //envoi SMS de la position 
       
        Serial.println("Position module:");
        Serial.println("");
        Serial.print("Latitude: ");
        Serial.println(Latitude_C,6);
        Serial.print("Longitude: ");
        Serial.println(Longitude_C,6);
        Serial.print("www.coordonnees-gps.fr/");
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("-------- 2nd message envoye ! --------");    
        }
        else
        {
            Serial.print("********Erreur envoi SMS !********");
        }
  }
  
    else
    {
        Serial.print("********Erreur !********");
        Serial.println(answer, DEC);
    }



    
 
            // Puis on enregistre le fait que le SMS a été envoyé
            // de façon à ne pas en renvoyer un autre
            SMS_sended = 1;
 
        }
 
    }
 



  // -*-*-*-*-*-*-*-*  LOOP PARTIE GPS  -*-*-*-*-*-*-*-
  
   
  GetLatitude_Calcul();                  // calcul coordonnées
  GetLongitude_Calcul();                // calcul coordonnées


 delay(5000);
 
}

/*--------------------------
 Sous programme 'GetDouble'
 --------------------------- */
int GetDouble()
{              // Get double register value from GPM
  int Value = 0; 
  byte H_Byte = 0;
  byte L_Byte = 0;

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 2);           // Request double register
  while(Wire.available() < 2);            // Wait for double byte
  H_Byte = Wire.read();                            // Store one
  L_Byte = Wire.read();                            // Store two

  Value = (H_Byte * 10) + L_Byte;                     // Adjust for one byte

    return(Value);                            
}

/*--------------------------
 Sous programme 'GetSingle'
 --------------------------- */
int GetSingle()
{             // Get single register value from GPM
  int Value = 1; 

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 1);           // Request register
  while(Wire.available() < 1);            // Wait for single byte
  Value = Wire.read();                             // and store

  return(Value);                            
}


/*-------------------------
 Sous programme 'Get_Date'
 --------------------------- */
byte Get_Date()
{
  Address = 6;                                        // Adresse Registre JOUR
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 8;                                        // Adresse Registre MOIS
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 10;                                       // Adresse Registre ANNEE (Milliers et Centaines)
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Address = 12;                                       // Adresse Registre ANNEE (Dizaines et Unités)
  Data = GetDouble();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
} 

/*--------------------------
 Sous programme 'Get_Heure'
 ---------------------------*/
byte Get_Heure()
{
  Address = 0;                                        // Adresse Registre Heures
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 2;                                        // Adresse Registre Minutes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 4;                                        // Adresse Registre Secondes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}

/*------------------------------------
 Sous programme 'Get_Satellites_vus'
 ------------------------------------ */
byte Get_Satellites_vus()
{
  Address = 35;           //58 version1 / 35 Version2 // Adresse de Pointage satellites en vue
  Data = GetSingle();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}


/*-----------------------------
 Sous programme 'Get_Vitesse'
 ----------------------------- */
int Get_Vitesse()
{
  Address = 52;                                       // Point to Speed 1 register
  Data = GetDouble();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Address = 54;                                       // Point to Speed 2 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Serial.print(".");
  Address = 55;                                       // Point to Speed 3 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // and print to PC
}


/*------------------------------------
 Sous programme 'GetLatitude_Calcul'
 -------------------------------------*/
double GetLatitude_Calcul()
{
  Address = 14;                                       // Registre Latitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 15;                                       // Registre Latitude Dizaines de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 16;                                       // Registre Latitude Dizaines de minutes
  Data_6 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 17;                                       // Registre Latitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 18;                                       // Registre Latitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 19;                                       // Registre Latitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 20;                                       // Registre Latitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 21;                                       // Registre Latitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)


  Latitude_1=(Data_8*10+Data_7);  
  Latitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Latitude_2=(Latitude_2/60);
    Latitude_C = (Latitude_1+(Latitude_2*1E-4));
  return (Latitude_C);
}



/*-------------------------------------
 Sous programme 'GetLongitude_Calcul'
 -------------------------------------- */
double GetLongitude_Calcul()
{
  Address = 23;                                       // Registre Longitude Centaines de degrés
  Data_9 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 24;                                       // Registre Longitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 25;                                       // Registre Longitude Unités de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 26;                                       // Registre Longitude Dizaines de minutes
  Data_6 = GetSingle();                               /// Lire le registre du GPM (1 octet)

  Address = 27;                                       // Registre Longitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 28;                                       // Registre Longitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 29;                                       // Registre Longitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 30;                                       // Registre Longitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 31;                                       // Registre Longitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Longitude_1=(Data_9*1E2+Data_8*10+Data_7);  
  Longitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Longitude_2=(Longitude_2/60);

    Longitude_C = (Longitude_1+(Longitude_2*1E-4));
  return (Longitude_C);
}





//-*-*-*-*-*-*-*-*-*-*-*-*  PARTIE SMS  -*-*-*-*-*-*-*-*-*-*-*-

// Définition des différentes fonctions.
//le programme SMS n'est pas dans la partie voidloop
void power_on(){

    uint8_t answer=0;
    
    // Cette commande vérifie si le module GSM est en marche.
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // Mise en marche du module GSM
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // Envoie d'une commande AT toutes les deux secondes et attente d'une réponse.
        while(answer == 0){
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}

// Cette fonction permet d'envoyer des commandes AT au module GSM.
int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout)
{

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    // Initialisation de la chaine de caractère (string).
    memset(response, '\0', 100);
    
    delay(100);
    
    // Initialisation du tampon d'entrée (input buffer).
    while( Serial.available() > 0) Serial.read();
    
    // Envoi des commandes AT
    Serial.println(ATcommand);


    x = 0;
    previous = millis();

    // Cette boucle attend la réponse du module GSM.
    
    do{
// Cette commande vérifie s'il y a des données disponibles dans le tampon.
//Ces données sont comparées avec la réponse attendue.
        if(Serial.available() != 0){    
            response[x] = Serial.read();
            x++;
            // Comparaison des données
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Attente d'une réponse.
    }while((answer == 0) && ((millis() - previous) < timeout));    

   // Serial.println(response); //Cette ligne permet de debuguer le programme en cas de problème !
   return answer;
}

Les coordonnées GPS sont des coordonnées angulaire.

Du coup, il est impératif de prendre latitude ET longitude en compte pour le calcul du déplacement.

Prenons par exemple 2 cas extrêmes :

- si latitude = 0° et que tu fais un déplacement de 360° sur la longitude, alors tu auras fais le tour de la terre sur la ligne équatorial, ce qui fait une distance énorme (cf trait rouge sur image suivante)

- si latitude = 80° et que tu fais un déplacement de 360° sur la longitude, alors tu auras fais le tour de la terre en étant proche du pôle, ce qui fait une distance bien plus faible

Bref, il y a de la trigonométrie à faire

Mais il doit y avoir pleins de formules toute prête sur internet.

Merci pour ta réponse et après de longues recherches, cela me semble trop compliqué pour mon niveau… je cherche a faire plus simple et j’ai donc eu une autre idée : si le module change de place alors cela m’envoie un SMS (plus besoin de distances a calculer) j’ai donc essayer de 2 manières mais cela ne marche pas , pourrais tu me dire ou je fait erreur ?

int x
x = Latitude_C,6

void loop()
{     
     if ( ( Latitude_C != 0 ) && ( Longitude_C != 0 ) )   // Si position correct
         {
             if ( x + 10 ) // Et si le module bouge
                 {                
                       (….)   envoie SMS
                      }
                           }

Simple mais je ne sais pas si je fais une erreur ici : if ( x + 10 ) ; cette ligne de programme existe-t-elle ?(voila ce que je pense que cette ligne fait : immaginon que ma position latitude = 45.9000000 alors si la position prend+10 soit 45.9000010 alors on m’envoie un SMS .

J’en ai essayé un autre:

int x
x = Latitude_C,6
int y 
y =  x + 10

void loop()
{     
     if ( ( Latitude_C != 0 ) && ( Longitude_C != 0 ) ) //Si position correct
         {
             if ( x >= y ) // Et si le module bouge
                 {                
                       (….)   envoie SMS
                      }
                           }

Dans les 2 cas je suis bloqué a la déclaration de variables et de plus il faudrait recommencer 3 x la démarche ( latitude +10 , latitude -10, longitude+10, longitude-10 ) et je ne sais pas si je commence bien ou si il y a plus simple..

-
Edité par MatMathieuu 14 avril 2018 à 12:54:33

Pour faire ça, il faudrait que tu garde en mémoire une copie de la dernière pos envoyée par SMS.

Ainsi, tu peux comparer la nouvelle position avec celle envoyée sur le SMS précédant.

Et si la différence est trop grande, alors on envoie le SMS.

Dans ce cas, le programme serait alors :

float Latitude_C, Longitude_C;    // Pos en cours
float Latitude_S, Longitude_S;    // Pos du SMS
bool forceSMS = 1;                // Forçage du SMS la première fois

void loop() {

    [...]    // Lecture position

    if (     // Si la position change,
        ( Latitude_C < ( Latitude_S - 0.0000010 ) ) ||
        ( Latitude_C > ( Latitude_S + 0.0000010 ) ) ||
        ( Longitude_C < ( Longitude_S - 0.0000010 ) ) ||
        ( Longitude_C > ( Longitude_S + 0.0000010 ) ) ||
        forceSMS
    ) {

        [...] // Envoie du SMS

        forceSMS = 0;
        Latitude_S = Latitude_C;
        Longitude_S = Longitude_C;
    }

}

-
Edité par lorrio 15 avril 2018 à 17:39:24

Merci pour ton message mais après plusieurs tests rien de concluant, je n’arrive pas a faire ce programme.

Je me posait la question : comment la carte Arduino sait que " floatLatitude_S, Longitude_S;" soit bien la position envoyée par SMS ?

voila mon dernier changement de programme ( j'ai testé de plusieurs manières avec le bout de programme que tu m'a passé mais a chaque fois le SMS s'envoie sans continue. je suppose que cela est normal qu'il m'en envoie un au début pour pouvoir le comparer par la suite mais après la boucle ne s’arrête pas , j'ai l'impression que le "if" devient transparent.) :

// VAR GPS
#include <Wire.h>
#define GPM 0x68                                  // GPM I2C Address
byte Address;                                         // Global variable
byte Data;                                            // Global variable
byte Data_10, Data_9, Data_8, Data_7, Data_6, Data_5, Data_4, Data_3, Data_2, Data_1;
int Latitude_1, Longitude_1;
long Latitude_2, Longitude_2;
float Latitude_C, Longitude_C;    // Pos en cours
float Latitude_S, Longitude_S;    // Pos du SMS



//VAR SMS
int8_t answer;
int onModulePin= 2; // port DTR (ou PWR) du module SIM900.
char aux_string[30];
char phone_number[]="+336********"; //numéro tel

bool forceSMS = 1;                // Forçage du SMS la première fois

void setup()
{
  
    Serial.println("");
    Serial.println("***localisation GPS+GSM***");
    Serial.println("");
    
// -*-*-*-*-*-*-*-*  SETUP PARTIE GPS  -*-*-*-*-*-*-*
  
  Wire.begin();                                       // Start I2C comms
  Serial.begin(115200);                               // Start PC serial port 
 delay(500);
     Serial.println("****************************");
     Serial.println("***/localisation GPS+GSM/***");
     Serial.println("****************************");
 delay(300);
   Serial.println("Allumage du module GPS");
   delay(500);
   Serial.print(".");
   delay(500);
   Serial.print(".");
   delay(500);
   Serial.println(".");

  
  delay(10000);                                        // Wait for DS-GPM.S to initialise
  

  
// -*-*-*-*-*-*-*-*-*-*  SETUP PARTIE SMS  -*-*-*-*-*-*-*-*-*-*
    
    pinMode(onModulePin, OUTPUT);
    Serial.begin(115200);
       
    
    Serial.println("Allumage du module SIM");
    delay(500);
    Serial.print(".");
    delay(500);
    Serial.print(".");
    delay(500);
    Serial.println(".");
    delay(5000);
    
   
}


//===
//=========
//==============
//=========
//===


void loop()
{
    // -*-*-*-*-*-*-*-*  LOOP PARTIE GPS  -*-*-*-*-*-*-*-
  
   Serial.print("Latitude calcul : ");
    GetLatitude_Calcul();                  // calcul coordonnées
      Serial.println(Latitude_C,6);

   Serial.print("Longitude calcul : ");
     GetLongitude_Calcul();                // calcul coordonnées
       Serial.println(Longitude_C,6);
   Get_Satellites_vus();
   delay(3000);

    // -*-*-*-*-*-*-*-*  LOOP PARTIE GSM  -*-*-*-*-*-*-*-
    
    // Si position correct
if ( ( Latitude_C != 0 ) && ( Longitude_C != 0 ) ) 
 {
   if (     // Si la position change,
        ( Latitude_C < ( Latitude_S - 0.0001000 ) ) ||
        ( Latitude_C > ( Latitude_S + 0.0001000 ) ) ||
        ( Longitude_C < ( Longitude_S - 0.0001000 ) ) ||
        ( Longitude_C > ( Longitude_S + 0.0001000 ) ) ||
        forceSMS
        ) {
 
            // Alors on envoie le SMS
           power_on(); // Cette commande active la carte SIM.
    delay(3000);
          

    
   

        while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) ||                     //Attente allumage du module
               sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );               //Attente allumage du module

    Serial.println("activation mode SMS ...");  // Activation du mode texte pour les SMS.
    sendATcommand("AT+CMGF=1", "OK", 1000);
    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("-------- Envoi du 1er SMS... --------");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
     delay(10000);

       //envoi SMS de la position 
       
        Serial.print("Date : ");
        Get_Date();
        Serial.print("Heure : ");
        Get_Heure();
        Serial.print("Satellites en vue :");
        Get_Satellites_vus();
        Serial.print("Vitesse :");
        Get_Vitesse();
     
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("-------- 1er message envoye ! --------");    
        }
        else
        {
            Serial.print("********Erreur envoi SMS !********");
        }
  }
  
    else
    {
        Serial.print("********Erreur !********");
        Serial.println(answer, DEC);
    }


    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("-------- Envoi du 2nd SMS... --------");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
     delay(3000);

       //envoi SMS de la position 
       
        Serial.println("Position module:");
        Serial.println("");
        Serial.print("Latitude: ");
        Serial.println(Latitude_C,6);
        Serial.print("Longitude: ");
        Serial.println(Longitude_C,6);
        Serial.print("www.coordonnees-gps.fr/");
        Serial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("-------- 2nd message envoye ! --------");    
        }
        else
        {
            Serial.print("********Erreur envoi SMS !********");
        }
  }
  
    else
    {
        Serial.print("********Erreur !********");
        Serial.println(answer, DEC);
    }

            forceSMS = 0;
        Latitude_S = Latitude_C;
        Longitude_S = Longitude_C;
        
 
    }
 

 delay(5000);
 
}
}
/*--------------------------
 Sous programme 'GetDouble'
 --------------------------- */
int GetDouble()
{              // Get double register value from GPM
  int Value = 0; 
  byte H_Byte = 0;
  byte L_Byte = 0;

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 2);           // Request double register
  while(Wire.available() < 2);            // Wait for double byte
  H_Byte = Wire.read();                            // Store one
  L_Byte = Wire.read();                            // Store two

  Value = (H_Byte * 10) + L_Byte;                     // Adjust for one byte

    return(Value);                            
}

/*--------------------------
 Sous programme 'GetSingle'
 --------------------------- */
int GetSingle()
{             // Get single register value from GPM
  int Value = 1; 

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 1);           // Request register
  while(Wire.available() < 1);            // Wait for single byte
  Value = Wire.read();                             // and store

  return(Value);                            
}


/*-------------------------
 Sous programme 'Get_Date'
 --------------------------- */
byte Get_Date()
{
  Address = 6;                                        // Adresse Registre JOUR
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 8;                                        // Adresse Registre MOIS
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 10;                                       // Adresse Registre ANNEE (Milliers et Centaines)
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Address = 12;                                       // Adresse Registre ANNEE (Dizaines et Unités)
  Data = GetDouble();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
} 

/*--------------------------
 Sous programme 'Get_Heure'
 ---------------------------*/
byte Get_Heure()
{
  Address = 0;                                        // Adresse Registre Heures
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 2;                                        // Adresse Registre Minutes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 4;                                        // Adresse Registre Secondes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}

/*------------------------------------
 Sous programme 'Get_Satellites_vus'
 ------------------------------------ */
byte Get_Satellites_vus()
{
  Address = 35;           //58 version1 / 35 Version2 // Adresse de Pointage satellites en vue
  Data = GetSingle();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}


/*-----------------------------
 Sous programme 'Get_Vitesse'
 ----------------------------- */
int Get_Vitesse()
{
  Address = 52;                                       // Point to Speed 1 register
  Data = GetDouble();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Address = 54;                                       // Point to Speed 2 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Serial.print(".");
  Address = 55;                                       // Point to Speed 3 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // and print to PC
}


/*------------------------------------
 Sous programme 'GetLatitude_Calcul'
 -------------------------------------*/
double GetLatitude_Calcul()
{
  Address = 14;                                       // Registre Latitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 15;                                       // Registre Latitude Dizaines de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 16;                                       // Registre Latitude Dizaines de minutes
  Data_6 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 17;                                       // Registre Latitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 18;                                       // Registre Latitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 19;                                       // Registre Latitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 20;                                       // Registre Latitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 21;                                       // Registre Latitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)


  Latitude_1=(Data_8*10+Data_7);  
  Latitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Latitude_2=(Latitude_2/60);
    Latitude_C = (Latitude_1+(Latitude_2*1E-4));
  return (Latitude_C);
}



/*-------------------------------------
 Sous programme 'GetLongitude_Calcul'
 -------------------------------------- */
double GetLongitude_Calcul()
{
  Address = 23;                                       // Registre Longitude Centaines de degrés
  Data_9 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 24;                                       // Registre Longitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 25;                                       // Registre Longitude Unités de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 26;                                       // Registre Longitude Dizaines de minutes
  Data_6 = GetSingle();                               /// Lire le registre du GPM (1 octet)

  Address = 27;                                       // Registre Longitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 28;                                       // Registre Longitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 29;                                       // Registre Longitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 30;                                       // Registre Longitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 31;                                       // Registre Longitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Longitude_1=(Data_9*1E2+Data_8*10+Data_7);  
  Longitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Longitude_2=(Longitude_2/60);

    Longitude_C = (Longitude_1+(Longitude_2*1E-4));
  return (Longitude_C);
}





//-*-*-*-*-*-*-*-*-*-*-*-*  PARTIE SMS  -*-*-*-*-*-*-*-*-*-*-*-

// Définition des différentes fonctions.
//le programme SMS n'est pas dans la partie voidloop
void power_on(){

    uint8_t answer=0;
    
    // Cette commande vérifie si le module GSM est en marche.
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // Mise en marche du module GSM
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // Envoie d'une commande AT toutes les deux secondes et attente d'une réponse.
        while(answer == 0){
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}

// Cette fonction permet d'envoyer des commandes AT au module GSM.
int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout)
{

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    // Initialisation de la chaine de caractère (string).
    memset(response, '\0', 100);
    
    delay(100);
    
    // Initialisation du tampon d'entrée (input buffer).
    while( Serial.available() > 0) Serial.read();
    
    // Envoi des commandes AT
    Serial.println(ATcommand);


    x = 0;
    previous = millis();

    // Cette boucle attend la réponse du module GSM.
    
    do{
// Cette commande vérifie s'il y a des données disponibles dans le tampon.
//Ces données sont comparées avec la réponse attendue.
        if(Serial.available() != 0){    
            response[x] = Serial.read();
            x++;
            // Comparaison des données
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Attente d'une réponse.
    }while((answer == 0) && ((millis() - previous) < timeout));    

   // Serial.println(response); //Cette ligne permet de debuguer le programme en cas de problème !
   return answer;
}

Alors je me pose plusieurs question : faut il que je laisse le premier "if" a la ligne 94? J'ai aussi supprimé ceux que tu m'avais dit de mettre pour arrêter la boucle dans les messages précédent mais dois-je les remettre?

merci de ton aide!

-
Edité par MatMathieuu 18 avril 2018 à 22:53:21

Il y a un truc qui n'est pas logique dans ton programme...

Que ce soit pour envoyer des données (ATCommand ou SMS) au module GSM ou des messages vers le PC, tu utilises toujours la classe Serial.

Ce n'est pas très logique et ça ne peut forcément pas marcher (le module GSM ne peut pas deviner de lui même si ce qu'il reçoit est une ATCommand pour lui ou un simple message à destination du PC).

D'où ma question : comment as tu câblé ton GSM ???

oui effectivement au paravant il y avait:

 Serial.begin(115200); Serial2.begin(115200);

Le serial2 communiquait avec le module et le serial avec le pc mais je ne peux utiliser 2 serial car j'utilise une carte Arduino normale et non une méga qui m'aurais permis d'avoir plusieurs serial.

mon module est câblé avec les bornes d'alimentations soudées et par les ports TX et RX de la carte arduino mais en croisant ceux ci(RX avec TX et inversement).

Effectivement je ne sais pas comment faire pour déclarer un autre port série avec une Arduino normale ce qui pourrait peut être résoudre mon problème selon toi?

Si ton module est relié aux pins Tx/Rx, tu ne peux pas utiliser Serial pour envoyer des infos au PC.

En effet, ton module va recevoir des messages du genre "Latitude calcul : " qui vont forcément le perturber car ce n'est pas une AT Commande.

Je te conseille vivement d'utiliser la lib SoftwareSerial pour émuler un Serial sur 2 autres pins

merci pour ce conseil ! Mais j'ai un petit problème lors de la mise en place du programme;

lorsque je déclare un nouveau port les messages ne s'envoie plus et lorsque j'ouvre le moniteur série voila ce qu'il me donne puis il s’arrête sans donner de résultat...

voici mon programme avec la librairie SoftwareSerial que j'ai rajouté :

// VAR GPS
#include <SoftwareSerial.h>
SoftwareSerial mySerial(10, 11); // RX, TX
#include <Wire.h>
#define GPM 0x68                                  // GPM I2C Address
byte Address;                                         // Global variable
byte Data;                                            // Global variable
byte Data_10, Data_9, Data_8, Data_7, Data_6, Data_5, Data_4, Data_3, Data_2, Data_1;
int Latitude_1, Longitude_1;
long Latitude_2, Longitude_2;
float Latitude_C, Longitude_C;    // Pos en cours
float Latitude_S, Longitude_S;    // Pos du SMS



//VAR SMS
int8_t answer;
int onModulePin= 2; // port DTR (ou PWR) du module SIM900.
char aux_string[30];
char phone_number[]="+33651062837"; //numéro tel

bool forceSMS = 1;                // Forçage du SMS la première fois

void setup()
{
  
    Serial.println("");
    Serial.println("***localisation GPS+GSM***");
    Serial.println("");

    Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  mySerial.begin(115200);


    
// -*-*-*-*-*-*-*-*  SETUP PARTIE GPS  -*-*-*-*-*-*-*
  
  
 delay(500);
     Serial.println("****************************");
     Serial.println("***/localisation GPS+GSM/***");
     Serial.println("****************************");
 delay(300);
   Serial.println("Allumage du module GPS");
   delay(500);
   Serial.print(".");
   delay(500);
   Serial.print(".");
   delay(500);
   Serial.println(".");

  
  delay(10000);                                        // Wait for DS-GPM.S to initialise
  

  
// -*-*-*-*-*-*-*-*-*-*  SETUP PARTIE SMS  -*-*-*-*-*-*-*-*-*-*
    
    pinMode(onModulePin, OUTPUT);
       
    
    Serial.println("Allumage du module SIM");
    delay(500);
    Serial.print(".");
    delay(500);
    Serial.print(".");
    delay(500);
    Serial.println(".");
    delay(5000);
    
   
}


//===
//=========
//==============
//=========
//===


void loop()
{
    // -*-*-*-*-*-*-*-*  LOOP PARTIE GPS  -*-*-*-*-*-*-*-
  
   Serial.print("Latitude calcul : ");
    GetLatitude_Calcul();                  // calcul coordonnées
      Serial.println(Latitude_C,6);

   Serial.print("Longitude calcul : ");
     GetLongitude_Calcul();                // calcul coordonnées
       Serial.println(Longitude_C,6);
   Get_Satellites_vus();
   delay(3000);

    // -*-*-*-*-*-*-*-*  LOOP PARTIE GSM  -*-*-*-*-*-*-*-
    
    // Si position correct
if ( ( Latitude_C != 0 ) && ( Longitude_C != 0 ) ) 
 {
   if (     // Si la position change,
        ( Latitude_C < ( Latitude_S - 0.0001000 ) ) ||
        ( Latitude_C > ( Latitude_S + 0.0001000 ) ) ||
        ( Longitude_C < ( Longitude_S - 0.0001000 ) ) ||
        ( Longitude_C > ( Longitude_S + 0.0001000 ) ) ||
        forceSMS
        ) {
 
            // Alors on envoie le SMS
           power_on(); // Cette commande active la carte SIM.
    delay(3000);
          

    
   

        while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) ||                     //Attente allumage du module
               sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );               //Attente allumage du module

    Serial.println("activation mode SMS ...");  // Activation du mode texte pour les SMS.
    sendATcommand("AT+CMGF=1", "OK", 1000);
    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("-------- Envoi du 1er SMS... --------");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
     delay(10000);

       //envoi SMS de la position 
       
        mySerial.print("Date : ");
        Get_Date();
        mySerial.print("Heure : ");
        Get_Heure();
        mySerial.print("Satellites en vue :");
        Get_Satellites_vus();
        mySerial.print("Vitesse :");
        Get_Vitesse();
     
       mySerial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("-------- 1er message envoye ! --------");    
        }
        else
        {
            Serial.print("********Erreur envoi SMS !********");
        }
  }
  
    else
    {
        Serial.print("********Erreur !********");
        Serial.println(answer, DEC);
    }


    sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
    Serial.println("-------- Envoi du 2nd SMS... --------");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
    answer = sendATcommand(aux_string, ">", 2000);
    if (answer == 1)
  {
     delay(3000);

       //envoi SMS de la position 
       
        mySerial.println("Position module:");
        mySerial.println("");
        mySerial.print("Latitude: ");
        mySerial.println(Latitude_C,6);
        mySerial.print("Longitude: ");
        mySerial.println(Longitude_C,6);
       mySerial.print("www.coordonnees-gps.fr/");
        mySerial.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.println("-------- 2nd message envoye ! --------");    
        }
        else
        {
            Serial.print("********Erreur envoi SMS !********");
        }
  }
  
    else
    {
        Serial.print("********Erreur !********");
        Serial.println(answer, DEC);
    }



    
 
            // Puis on enregistre le fait que le SMS a été envoyé
            // de façon à ne pas en renvoyer un autre
            forceSMS = 0;
        Latitude_S = Latitude_C;
        Longitude_S = Longitude_C;
        
 
    }
 

 delay(5000);
 
}
}
/*--------------------------
 Sous programme 'GetDouble'
 --------------------------- */
int GetDouble()
{              // Get double register value from GPM
  int Value = 0; 
  byte H_Byte = 0;
  byte L_Byte = 0;

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 2);           // Request double register
  while(Wire.available() < 2);            // Wait for double byte
  H_Byte = Wire.read();                            // Store one
  L_Byte = Wire.read();                            // Store two

  Value = (H_Byte * 10) + L_Byte;                     // Adjust for one byte

    return(Value);                            
}

/*--------------------------
 Sous programme 'GetSingle'
 --------------------------- */
int GetSingle()
{             // Get single register value from GPM
  int Value = 1; 

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 1);           // Request register
  while(Wire.available() < 1);            // Wait for single byte
  Value = Wire.read();                             // and store

  return(Value);                            
}


/*-------------------------
 Sous programme 'Get_Date'
 --------------------------- */
byte Get_Date()
{
  Address = 6;                                        // Adresse Registre JOUR
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 8;                                        // Adresse Registre MOIS
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 10;                                       // Adresse Registre ANNEE (Milliers et Centaines)
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Address = 12;                                       // Adresse Registre ANNEE (Dizaines et Unités)
  Data = GetDouble();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
} 

/*--------------------------
 Sous programme 'Get_Heure'
 ---------------------------*/
byte Get_Heure()
{
  Address = 0;                                        // Adresse Registre Heures
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 2;                                        // Adresse Registre Minutes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 4;                                        // Adresse Registre Secondes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}

/*------------------------------------
 Sous programme 'Get_Satellites_vus'
 ------------------------------------ */
byte Get_Satellites_vus()
{
  Address = 35;           //58 version1 / 35 Version2 // Adresse de Pointage satellites en vue
  Data = GetSingle();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}


/*-----------------------------
 Sous programme 'Get_Vitesse'
 ----------------------------- */
int Get_Vitesse()
{
  Address = 52;                                       // Point to Speed 1 register
  Data = GetDouble();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Address = 54;                                       // Point to Speed 2 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Serial.print(".");
  Address = 55;                                       // Point to Speed 3 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // and print to PC
}


/*------------------------------------
 Sous programme 'GetLatitude_Calcul'
 -------------------------------------*/
double GetLatitude_Calcul()
{
  Address = 14;                                       // Registre Latitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 15;                                       // Registre Latitude Dizaines de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 16;                                       // Registre Latitude Dizaines de minutes
  Data_6 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 17;                                       // Registre Latitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 18;                                       // Registre Latitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 19;                                       // Registre Latitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 20;                                       // Registre Latitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 21;                                       // Registre Latitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)


  Latitude_1=(Data_8*10+Data_7);  
  Latitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Latitude_2=(Latitude_2/60);
    Latitude_C = (Latitude_1+(Latitude_2*1E-4));
  return (Latitude_C);
}



/*-------------------------------------
 Sous programme 'GetLongitude_Calcul'
 -------------------------------------- */
double GetLongitude_Calcul()
{
  Address = 23;                                       // Registre Longitude Centaines de degrés
  Data_9 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 24;                                       // Registre Longitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 25;                                       // Registre Longitude Unités de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 26;                                       // Registre Longitude Dizaines de minutes
  Data_6 = GetSingle();                               /// Lire le registre du GPM (1 octet)

  Address = 27;                                       // Registre Longitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 28;                                       // Registre Longitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 29;                                       // Registre Longitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 30;                                       // Registre Longitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 31;                                       // Registre Longitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Longitude_1=(Data_9*1E2+Data_8*10+Data_7);  
  Longitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Longitude_2=(Longitude_2/60);

    Longitude_C = (Longitude_1+(Longitude_2*1E-4));
  return (Longitude_C);
}





//-*-*-*-*-*-*-*-*-*-*-*-*  PARTIE SMS  -*-*-*-*-*-*-*-*-*-*-*-

// Définition des différentes fonctions.
//le programme SMS n'est pas dans la partie voidloop
void power_on(){

    uint8_t answer=0;
    
    // Cette commande vérifie si le module GSM est en marche.
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // Mise en marche du module GSM
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // Envoie d'une commande AT toutes les deux secondes et attente d'une réponse.
        while(answer == 0){
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}

// Cette fonction permet d'envoyer des commandes AT au module GSM.
int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout)
{

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    // Initialisation de la chaine de caractère (string).
    memset(response, '\0', 100);
    
    delay(100);
    
    // Initialisation du tampon d'entrée (input buffer).
    while( mySerial.available() > 0) mySerial.read();
    
    // Envoi des commandes AT
    mySerial.println(ATcommand);


    x = 0;
    previous = millis();

    // Cette boucle attend la réponse du module GSM.
    
    do{
// Cette commande vérifie s'il y a des données disponibles dans le tampon.
//Ces données sont comparées avec la réponse attendue.
        if(mySerial.available() != 0){    
            response[x] = mySerial.read();
            x++;
            // Comparaison des données
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Attente d'une réponse.
    }while((answer == 0) && ((millis() - previous) < timeout));    

   // Serial.println(response); //Cette ligne permet de debuguer le programme en cas de problème !
   return answer;
}

sais tu d’où peut venir le problème?

Ton problème se situe probablement sur les lignes 253 et 254 :

  Wire.requestFrom(GPM, 1);           // Request register
  while(Wire.available() < 1);        // Wait for single byte

Tout d'abord, tu fais la lecture d'un octet, puis tu as une boucle d'attente infinie qui attend que l'octet soit reçu.

Sauf que ce n'est pas parce que tu demande un octet que tu vas en recevoir un.

Si le module est mal cablé où qu'il n'est pas prêt à répondre, tu ne recevras rien et ton programme restera à attendre indéfiniment.

La fonction requestFrom retourne le nombre d'octet reçu, tu devrais t'en servir

Exemple :

// Requete d'un octet :
int size = Wire.requestFrom(GPM, 1);

if ( size == 0 ) {

    // Erreur de lecture, que faire ???
    // TODO: traiter le problème
    return 0;

} else {

    // Lecture OK, on peut envoyer le résultat
    return Wire.read();

}

Merci de ta réponse mais je n'ai pas bien compris..

Malgré cela j'ai essayé de changer le programme mais hélas plus rien ne s'affiche dans le moniteur série ...

Faut il que je change cette partie aussi dans le getDouble?(ligne 232-233)

Merci encore e ton aide

Difficile de faire plus simple comme explication...

La fonction Wire.requestFrom permet de demander un certain nombre d'octet sur le bus de communication I2C.

Mais ce n'est pas parce que tu en fais la demande que cela va forcément se produire.

Il se peut que le module ne réponde pas ou qu'il soit mal branché et dans ce cas, tu ne recevras rien.

Donc si ton code attend qu'il y ai un octet de disponible, il peut potentiellement attendre indéfiniment...

==========

On peut faire une comparaison avec un groupe d'ami dans un bar.

D'abord, quand on voit le serveur, on dit "4 cafés s'il vous plait !"

Mais il se peut que le serveur ne nous ai pas entendu et/ou qu'il n'ai plus de café.

Donc si on attend que les 4 cafés soit servi avant de trinquer, ça peut durer une éternité.

En temps normal, on aurait tendance à répéter ou changer notre commande au serveur, mais ce n'est pas ce que fait ton code puisque celui-ci se contente de faire une seule requête puis d'attendre.

==========

Bref, tout ça pour dire qu'il faut vérifier si la commande a bien été faite.

Et éventuellement la répéter si besoin.

==========

PS: oui, il faut aussi changer GetDouble

// VAR GPS
#include <Wire.h>
#define GPM 0x68                                  // GPM I2C Address
byte Address;                                         // Global variable
byte Data;                                            // Global variable
byte Data_10, Data_9, Data_8, Data_7, Data_6, Data_5, Data_4, Data_3, Data_2, Data_1;
int Latitude_1, Longitude_1;
long Latitude_2, Longitude_2;
float Latitude_C, Longitude_C;    // Pos en cours
long Latitude_Ref, Longitude_Ref;    // Pos reférence

//VAR SMS
int8_t answer;
int onModulePin= 2; // port DTR (ou PWR) du module SIM900.
char aux_string[30];
char phone_number[]="+33651062837"; //numéro tel
bool forceSMS = 1;                // Forçage du SMS la première fois


  void setup()
     {
        delay(500);
        Serial.println("****************************");
        Serial.println("***/localisation GPS+GSM/***");
        Serial.println("****************************");
        delay(300);
      
       
       // -*-*-*-*-*-*-*-*-*-*  SETUP PARTIE SMS  -*-*-*-*-*-*-*-*-*
    
          pinMode(onModulePin, OUTPUT);
          Serial.begin(115200);
          Serial.println("Allumage du module SIM");
          delay(500);
          Serial.print(".");
          delay(500);
          Serial.print(".");
          delay(500);
          Serial.println(".");
          delay(5000);
        // -*-*-*-*-*-*-*-*  SETUP PARTIE GPS  -*-*-*-*-*-*-*
         Wire.begin();                                       // Start I2C comms
         Serial.begin(115200);                               // Start PC serial port 
         Serial.println("Allumage du module GPS");
         delay(500);
         Serial.print(".");
         delay(500);
         Serial.print(".");
         delay(500);
         Serial.println(".");
        delay(50000);                                        // Wait for DS-GPM.S to initialise
  
   if ( Get_Satellites_vus > 3 )
   { 
     Latitude_Ref = Calcul_Latitude_complet();
     Longitude_Ref = Calcul_Longitude_complet();
   }
}

//================
void loop()
{
// Si position correct
if ( ( Latitude_C != 0 ) && ( Longitude_C != 0 ) ) 
 {
     if (( Latitude_C < ( Latitude_Ref - 0.0000100 ) ) ||
        ( Latitude_C > ( Latitude_Ref + 0.0000100 ) ) ||
        ( Longitude_C < ( Longitude_Ref - 0.0000100 ) ) ||
        ( Longitude_C > ( Longitude_Ref + 0.0000100 ) ) ||
        forceSMS ) // Si la position change,
        {
            // Alors on envoie le SMS
           power_on(); // Cette commande active la carte SIM.
           delay(5000);

           while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) ||                     //Attente allumage du module
               sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );               //Attente allumage du module

           Serial.println("activation mode SMS ...");  // Activation du mode texte pour les SMS.
           sendATcommand("AT+CMGF=1", "OK", 1000);
           sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
           Serial.println("-------- Envoi du 1er SMS... --------");
    
           sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
           answer = sendATcommand(aux_string, ">", 2000);
           
                  if (answer == 1)
                  {
                         delay(10000);
                      //envoi SMS de la position 
                 
                        Serial.print("Date : ");
                        Get_Date();
                        Serial.print("Heure : ");
                        Get_Heure();
                        Serial.print("Satellites en vue :");
                        Get_Satellites_vus();
                        Serial.print("Vitesse :");
                        Get_Vitesse();
                     
                        Serial.write(0x1A);
                        answer = sendATcommand("", "OK", 20000);
                        
                              if (answer == 1)
                                {
                                        Serial.println("-------- 1er message envoye ! --------");    
                                 }
                              else
                                {
                                    Serial.print("********Erreur envoi SMS !********");
                                 }
                  }
                else
                {
                 Serial.print("********Erreur !********");
                 Serial.println(answer, DEC);
                }

        sendATcommand("AT+CSMP=17,167,0,240", "OK", 1000); // Flaash SMS
        Serial.println("-------- Envoi du 2nd SMS... --------");
    
        sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);  // Envoi du numéro de téléphone au module GSM.
        answer = sendATcommand(aux_string, ">", 2000);
        
            if (answer == 1)
              {
                 delay(3000);

                   //envoi SMS de la position 
                Serial.println("Position module:");
                Serial.println("");
                Serial.print("Latitude: ");
                Serial.println(Latitude_C,6);
                Serial.print("Longitude: ");
                Serial.println(Longitude_C,6);
                Serial.print("www.coordonnees-gps.fr/");
                Serial.write(0x1A);
                answer = sendATcommand("", "OK", 20000);
                
                  if (answer == 1)
                  {
                      Serial.println("-------- 2nd message envoye ! --------");    
                  }
                  else
                  {
                      Serial.print("********Erreur envoi SMS !********");
                  }
              }
           else
           {
            Serial.print("********Erreur !********");
            Serial.println(answer, DEC);
           }
        }

         delay(120000)  //délai 2 min avant de renvoyer le SMS
  }

 // -*-*-*-*-*-*-*-*  LOOP PARTIE GPS  -*-*-*-*-*-*-*-
 
  GetLatitude_Calcul();                  // calcul coordonnées
  GetLongitude_Calcul();                // calcul coordonnées
  delay(5000);
/*-------------------------------------
 Sous programme 'position référence'
 -------------------------------------- */
if ( Get_Satellites_vus > 3 )
for ( n=0 ; n>1 ; n++ )
   { 
     Latitude_Ref = Latitude_C;
     Longitude_Ref = Longitude_C;
   }
}
/*--------------------------
 Sous programme 'GetDouble'
 --------------------------- */
int GetDouble()
{              // Get double register value from GPM
  int Value = 0; 
  byte H_Byte = 0;
  byte L_Byte = 0;

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 2);           // Request double register
  while(Wire.available() < 2);            // Wait for double byte
  H_Byte = Wire.read();                            // Store one
  L_Byte = Wire.read();                            // Store two

  Value = (H_Byte * 10) + L_Byte;                     // Adjust for one byte

    return(Value);                            
}

/*--------------------------
 Sous programme 'GetSingle'
 --------------------------- */
int GetSingle()
{             // Get single register value from GPM
  int Value = 1; 

  Wire.beginTransmission(GPM);
  Wire.write(Address);              // Send register start address
  Wire.endTransmission();

  Wire.requestFrom(GPM, 1);           // Request register
  while(Wire.available() < 1);            // Wait for single byte
  Value = Wire.read();                             // and store

  return(Value);                            
}
/*-------------------------
 Sous programme 'Get_Date'
 --------------------------- */
byte Get_Date()
{
  Address = 6;                                        // Adresse Registre JOUR
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 8;                                        // Adresse Registre MOIS
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print("/");
  Address = 10;                                       // Adresse Registre ANNEE (Milliers et Centaines)
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Address = 12;                                       // Adresse Registre ANNEE (Dizaines et Unités)
  Data = GetDouble();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
} 
/*--------------------------
 Sous programme 'Get_Heure'
 ---------------------------*/
byte Get_Heure()
{
  Address = 0;                                        // Adresse Registre Heures
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 2;                                        // Adresse Registre Minutes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.print(Data, DEC);                            // Affichage sur terminal série PC
  Serial.print(":");
  Address = 4;                                        // Adresse Registre Secondes
  Data = GetDouble();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}
/*------------------------------------
 Sous programme 'Get_Satellites_vus'
 ------------------------------------ */
byte Get_Satellites_vus()
{
  Address = 35;           //58 version1 / 35 Version2 // Adresse de Pointage satellites en vue
  Data = GetSingle();                                 // Lecture du registre depuis GPM
  Serial.println(Data, DEC);                          // Affichage sur terminal série PC
}
/*-----------------------------
 Sous programme 'Get_Vitesse'
 ----------------------------- */
int Get_Vitesse()
{
  Address = 52;                                       // Point to Speed 1 register
  Data = GetDouble();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Address = 54;                                       // Point to Speed 2 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.print(Data, DEC);                            // and print to PC
  Serial.print(".");
  Address = 55;                                       // Point to Speed 3 register
  Data = GetSingle();                                 // Read registers from GPM
  Serial.println(Data, DEC);                          // and print to PC
}
/*------------------------------------
 Sous programme 'GetLatitude_Calcul'
 -------------------------------------*/
double GetLatitude_Calcul()
{
  Address = 14;                                       // Registre Latitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 15;                                       // Registre Latitude Dizaines de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 16;                                       // Registre Latitude Dizaines de minutes
  Data_6 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 17;                                       // Registre Latitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 18;                                       // Registre Latitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 19;                                       // Registre Latitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 20;                                       // Registre Latitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 21;                                       // Registre Latitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Latitude_1=(Data_8*10+Data_7);  
  Latitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Latitude_2=(Latitude_2/60);
    Latitude_C = (Latitude_1+(Latitude_2*1E-4));
  return (Latitude_C);
}
/*-------------------------------------
 Sous programme 'GetLongitude_Calcul'
 -------------------------------------- */
double GetLongitude_Calcul()
{
  Address = 23;                                       // Registre Longitude Centaines de degrés
  Data_9 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 24;                                       // Registre Longitude Dizaines de degrés
  Data_8 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 25;                                       // Registre Longitude Unités de degrés
  Data_7 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 26;                                       // Registre Longitude Dizaines de minutes
  Data_6 = GetSingle();                               /// Lire le registre du GPM (1 octet)

  Address = 27;                                       // Registre Longitude Unités de minutes
  Data_5 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 28;                                       // Registre Longitude dixièmes de minutes
  Data_4 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 29;                                       // Registre Longitude centièmes de minutes
  Data_3 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 30;                                       // Registre Longitude millièmes de minutes
  Data_2 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Address = 31;                                       // Registre Longitude dix-millièmes de minutes
  Data_1 = GetSingle();                               // Lire le registre du GPM (1 octet)

  Longitude_1=(Data_9*1E2+Data_8*10+Data_7);  
  Longitude_2=(Data_6*1E5+Data_5*1E4+Data_4*1E3+Data_3*1E2+Data_2*1E1+Data_1);
  Longitude_2=(Longitude_2/60);

    Longitude_C = (Longitude_1+(Longitude_2*1E-4));
  return (Longitude_C);
}
//-*-*-*-*-*-*-*-*-*-*-*-*  PARTIE SMS  -*-*-*-*-*-*-*-*-*-*-*-

// Définition des différentes fonctions.
//le programme SMS n'est pas dans la partie voidloop
void power_on(){

    uint8_t answer=0;
    
    // Cette commande vérifie si le module GSM est en marche.
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // Mise en marche du module GSM
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // Envoie d'une commande AT toutes les deux secondes et attente d'une réponse.
        while(answer == 0){
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}

// Cette fonction permet d'envoyer des commandes AT au module GSM.
int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout)
{

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    // Initialisation de la chaine de caractère (string).
    memset(response, '\0', 100);
    
    delay(100);
    
    // Initialisation du tampon d'entrée (input buffer).
    while( Serial.available() > 0) Serial.read();
    
    // Envoi des commandes AT
    Serial.println(ATcommand);


    x = 0;
    previous = millis();

    // Cette boucle attend la réponse du module GSM.
    
    do{
// Cette commande vérifie s'il y a des données disponibles dans le tampon.
//Ces données sont comparées avec la réponse attendue.
        if(Serial.available() != 0){    
            response[x] = Serial.read();
            x++;
            // Comparaison des données
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Attente d'une réponse.
    }while((answer == 0) && ((millis() - previous) < timeout));    

   // Serial.println(response); //Cette ligne permet de debuguer le programme en cas de problème !
   return answer;

-
Edité par MatMathieuu 11 mai 2018 à 16:17:50

Bonsoir 

je suis un débutant en  programmation avec Arduino et j'ai le même projet que Mat Mathieu sauf que j'ai pas en ma disposition tous les matériels qu'il  a utilisé. j'aimerais reproduire son exemple mais je ne sais pas comment faire le montage électrique des différents modules.

je dispose d"un module GSM, GPRS SIM900, d'un Arduino Uno  et une carte SIM Orange 

il  me manque le module Shield GPS que j'ai commandé sur le net 

est ce possible de voir un schéma de câblage des différents modules ?

Merci d'avance

Bonjour, c'est Christian!

Je travail également sur le même type de projet, mais vue que je n'ai pas encore rassemblé tout ce qu'il me faut, je traine encore un peu.

Mais j'ai quand même une question, le module GSM pour l'envoi des SMS. Faut-il avoir un forfait sms ou bien c'est gratuit!

Merci d'avance pour votre éclaircissement.

Pour pouvoir utiliser les réseaux mobiles GSM (que ce soit pour des SMS, des appels ou de la data), il faut forcément passer par un opérateur.

Donc cela implique d'avoir une carte sim et l’abonnement qui va avec.

Un habonnement free à 2€/mois est amplement suffisant pour envoyer quelques SMS

Bonsoir j'ai l'ambition de faire fonctionner une des versions du programme de mathieuu en utilisant une carte arduino uno, un module gps et une sim900 . Mes connaissances en branchement étant limité serait il possible d'avoir des précisions me permettant de brancher correctement entre eux les différents composants ? J'ai lu les precedents posts et je ne saisis pas les détails les concernant. Les programme étant annotés il est facile de percevoir les subtilités, ce qui est bienvenu. Cordialement

Il n'y a pas grand chose à connecter pour faire fonctionner un SIM900 avec Arduino.

Tout d'abord, il faut alimenter correctement le SIM900, cela parait logique.

Ensuite, si l'alimenter du SIM900 est différente de celle de l'arduino, il faut relier le GND de l'arduino au GND du SIM900.

Si c'est le même alimentation, la liaison GND est déjà faite.

Il y a les broches TX/RX à relier à l'Arduino, sur les pins d'un Serial Hardware de préférence.

Mais si c'est un Arduino UNO, tu n'auras pas beaucoup d'autres soit que d'utiliser un SoftwareSerial sur les pins de ton choix.

Et pour finir, il y a la pin PWR à relier sur n'importe quel pin numérique (ou analogique) de l'Arduino.

salut, j'ai un souci...

Bonjour josiasepierretagnefoka,

J'ai bien peur de devoir t'annoncer qu'on ne va pas pouvoir aller bien loin avec si peu d'information, personne ici ne peut deviner le souci que tu as pour te proposer une solution.

Je t'invite donc à créer ton propre sujet (ce sera mieux que d'utiliser un sujet existant) et y détaillé ton problème, ainsi que ce que tu as déjà tenté de faire pour le résoudre.

Lorrio.

J'ai comme projet de faire fonctionner un programme avec un Module GSM Sim 900 en shield ainsi qu'un module GPS shield duinopeak. le principe consiste à envoyer un message à la sim du nom de Location, une fois que le GSM est reconnu cet orthographe il me renvoi les coordonnées de l'objet sous forme de http sur le téléphone afin que je puisse cliqué sur ce lien et tombé directement sur google map. Mais le plus grand soucis, le GSM reconnait avoir recu le message convenu mais ce  dernier ne me renvoi pas l'adresse http.

voici le programme en langage arduino

#include <SoftwareSerial.h>
#include <TinyGPS.h>

SoftwareSerial ss(4, 3);
// Configure software serial port
SoftwareSerial SIM900(7, 8);

float flat, flon;
unsigned long age;
//Variable to save incoming SMS characters
String incoming_char;

TinyGPS gps;

void setup() {
  // put your setup code here, to run once:
   Serial.begin(9600); 
   SIM900.begin(9600);
   SIM900.print("AT+CMGF=1\r");
    delay(2000);
   SIM900.print("AT+CNMI=2,2,0,0,0\r");
  delay(2000);
}

void loop() {
receiver();
if(incoming_char.indexOf("Location")>=0){
  
       gps_cood();
       smsLOCATION();       
  }
delay(1000);
    } 


  void receiver(){

     if(SIM900.available() >0) {
    //Get the character from the cellular serial port
    incoming_char=SIM900.readString(); 
    //Print the incoming character to the terminal
    Serial.print(incoming_char);
    delay(10); }
  }

  void gps_cood(){
    
     ss.listen();
  bool newData = false;
 
  for (unsigned long start = millis(); millis() - start < 1000;)
  {
    while (ss.available())
    {
      char c = ss.read();
      Serial.print(c);
       if (gps.encode(c)) 
        newData = true;
    }
  }
  if(newData ){
  
    gps.f_get_position(&flat, &flon, &age);
    Serial.print("LAT=");
     Serial.print(flat,7);
      Serial.print("LONG=");
       Serial.print(flon,7);
        
    }
    }


    void smsLOCATION(){
      SIM900.print("AT+CMGF=1"); 
     delay(1000);
        SIM900.print("AT+CMGS=\"+237656842757\"\r"); 
      delay(1000);         
     if(flat!=0.0&&flon!=0.0){
   
      SIM900.println("http://maps.google.com/maps?f=q&q=(");
      SIM900.print(flat,7);
       SIM900.print(',');
        SIM900.print(flon,7);
         SIM900.print(')');
     }
      delay(100);
      SIM900.println((char)26);
      delay(100);
      SIM900.println();
      delay(1000);
      }

voici ce que le moniteur série m'affiche :