Probléme de fonction avec argument ?

[Jérémy]

Bonjour à tous,

Bon difficile de trouver un titre , pour mon problème .

Je suis en train d'essayer de paramétrer un module(GSM2-click) avec des commandes "AT". Pour l'initialisation je dois tout d'abord effectivement le réglage du baud-rate en envoyant la commande "AT" au module. Quand celui me répond "OK", c'est que le baud-rate est bon.

Ensuite dans le même principe, j'envoie des commandes au module pour le paramétrer . il doit aussi me répondre "OK" pour valider le paramétrage.

Après plusieurs test, tout est bon. Je me dis alors que je peux "optimiser" mon code et le rendre plus propre. J'ai donc décider de créer une fonction pour envoyer une commande au module et je reviens quand j'ai reçu "OK" .

voici un code qui fonctionne :

Code : Tout sélectionner

//------------------------------------------------------------------------------
// Test du baud rate
  while(1) {
     UART_Write_Text("AT");
     UART_Write(0x0D);      // On termine par un CR
     delay_ms(100);
    
     if (ReponseID == GSM_OK){               // Si "OK" au test baud rate le programme peut continuer
        ReponseID = 0;
        break;                              // On sort de la bocule de test baud rate
      }
   }

Dans ce code je rentre dans une boucle sans fin. j’envoie le mot "AT" au module, j’attends 100ms le temps de recevoir la réponse en UART. Si mon drapeau GSM_OK pendant ces 100ms, c'est que le module à répondu "OK", je peux sortir de ma boucle.
Sinon je re-envoi le mot"AT" ...Etc .... jusqu' a que je reçoive "OK".

Voici une autre partie du code qui fonctionne :
dans mon initialisation j'ai l'appel d'une fonction :

Code : Tout sélectionner

  envoi_commande_Parametre("ATE0");

Cette fonction, envoi la commande "ATE0" au module est attends la réponse " OK" . Exactement comme pour le "AT"

Vocii la fonction en question :

Code : Tout sélectionner

//------------------------------------------------------------------------
// Param. d'entrée : La commande à envoyer
void envoi_commande_Parametre(char *s1){
  while(1) {
   
      while(*s1) {
         UART_Write(*s1++);
       }
      UART_Write(0x0D);   // On termine par un CR
      
      Delay_ms(100);
      
      if (ReponseID == GSM_OK){
          ReponseID = 0;
          break;
       }
   }
}

ca fonctionne bien.

Comme il s'agit de la même fonction pour envoyer "ATE0" et "AT" , je me dis que si je fais :

Code : Tout sélectionner

  envoi_commande_Parametre("AT")

Ca devrati faire la même chose .

Et ben non , le programme me renvoie que des "cr".

Je ne comprends pas pourquoi, il n'arrive pas a m'envoyer une série de "AT" pour faire le baud-rate avec ma fonction.
J'ai comme l'impression que le "AT" est envoyé une seul fois et qu’après plus rien n'est envoyé ! a part le "CR"
Du coup quelle est la durée de validité de l'argument envoyé ?
LE pointeur doit-il est remis au début ?

PS: j'ai un cable TTL-UART pour espionner le dialogue sur hyperterminal
RE-PS: Voici le programme en entier :

► Afficher le programme

Code : Tout sélectionner

/*
lien command AT du module M95 : http://www.quectel.com/UploadImage/Downlad/M95_AT_Commands_Manual_V1.2.pdf
Data-Sheet du PIC 16F1847     : http://ww1.microchip.com/downloads/en/DeviceDoc/41453B.pdf
*/

#define PNP RA2_bit
#define NPN RA3_bit
#define Test_PNP RA4_bit
#define Test_NPN RB0_bit
#define Led RB6_bit
#define Alim LATB.B5
#define PWRKEY  RB3_bit
#define Envoi_tension RA0_bit

//------------------------------------------------------------------------------
// Tables des Réponses attendues
const GSM_OK         = 1;
const GSM_FLECHE     = 2;
const GSM_ERROR      = 3;
const GSM_Call_Ready = 4;

//------------------------------------------------------------------------------
// Tables des reponses SMS possibles
const SMS_UNREAD = 10 ;
const SMS_OUI    = 11;
const SMS_NON    = 12;
const SMS_STOP   = 13;
const SMS_AIDE   = 14;


// Tableaux
char T_numero_tel[30]="AT+CMGS=\"";  // tableau pour placer le numéro de téléphone en string format : {"+336********"}
char T_message[200];                 // Stockage du SMS à envoyer pendant la composition
char T_Chrono[15];

// Variables
short ReponseID = 0;

unsigned char i, Valeur ;

#include "Interruptions.h"

//########################   PROTOTYPE DE FONCTION     #########################
void Initialisation();
void envoi_commande_sans_reponse(char *s1);
void envoi_commande_avec_reponse(char *s1, char);
void strConstRamCpy(char *dest, const char *source);
void envoi_commande_Parametre(char *s1);

//##############################################################################
//###########################     MAIN     #####################################
//##############################################################################
void main(){
  ANSELA = 0b00000010;  // RA1 en Analogique pour lecture tension
  ANSELB = 0b00000000;  // RB en numérique
  TRISB  = 0b00000010;  // RB1 en entrée pour UART, RB3 en sortie PWRKEY
  TRISA  = 0b00001110;  // RA1 en entrée pour lecture tension , PNP et NPN en entrée

  Alim = 1;             // Module éteint
  PWRKEY = Valeur = Led = 0;

//------------------------------------------------------------------------------
// Réglages de l'Oscillateur Interne
  OSCCON = 0b01110010;     // PLL disable, 8 Mhz
//------------------------------------------------------------------------------
// Réglages du Timer1 à 10 ms pour le chronometre
  TMR1IE_bit = 0;          // désactiver au départ
  T1CON      = 0x01;
  TMR1IF_bit = 0;
  TMR1H      = 0xB1;
  TMR1L      = 0xE0;
//------------------------------------------------------------------------------
// Réglages de l'interruption sur Reception UART
  GIE_bit  = 1;     // Active toutesl es INT
  PEIE_bit = 1;     // Active les INT peripherique
  RCIE_bit = 0;     // Dés-Active les Interruptions sur Rx UART
//------------------------------------------------------------------------------
// Configuration du convertisseur analogique/numérique avec reference interne
  // Configuration de l'ADCON0  ------------------------------------
                        // bit 7 non utilisé
                        // CHS<4:0> = choix du canal AN1  = 00001
  ADCON0 = 0b00000101;  // Go/~DONE = ? je met 0 dans le doute
                        // ADON = 1, activation du module AD

  // Configuration de l'ADCON1  --------------------------------------
                        // ADFM = 1, justification à droite
                        // ADCS<2:0>= 001, Fosc/8
  ADCON1 = 0b10010011;  // bit 3 non utilisé
                        // ADNREF = 0, ref- = GND
                        // ADPREF = 11, REF+ = FVR ( reglé sur 2.048V)

  // Configuration de Vref  -----------------------------------------
                         //  FVREN_bit = 1;   // Activation du Vref
                         //  FVRRDY_bit = 1;  // Pret a etre utilisé
                         //  TSEN_bit = 0;
   FVRCON = 0b11000010 ; //  TSRNG_bit = 0;
                         //  CDAFVR0_bit = 0;
                         //  CDAFVR1_bit = 0;
                         //  ADFVR1_bit = 1;  // ADFVR = 0b10
                          // ADFVR0_bit = 0;  // Mise du Vref à 2.048V
//------------------------------------------------------------------------------
  UART1_Init(9600); // Initialisation de l'UART à 9600 bauds
  delay_ms(200);

//------------------------------------------------------------------------------
  Initialisation(); // On Initialisa et allume le module pour la premiere fois

//##############################################################################
//####################### BOUCLE PRINCIPALE     ################################
//##############################################################################
 while(1) {

 }
}

//##############################################################################
//#######################   FONCTIONS SECONDAIRES    ###########################
//##############################################################################
//------------------------------------------------------------------------
//-----------------   Initialisation des paramétres     ------------------
//------------------------------------------------------------------------
void Initialisation(){
   Alim = 0;               // On allume le module par MOSFET
   delay_ms(500);          // Stabilisation tension
  
   RCIE_bit = 1;           // Active les Interruptions sur Rx UART
  
   PWRKEY = 0;             // Mise à zéro
   Delay_ms(3000);         // Maintenir à 0 pendant plus de 2S
   PWRKEY = 1;             // Allume le module


/*
//------------------------------------------------------------------------------
// Test du baud rate
  while(1) {
     UART_Write_Text("AT");
     UART_Write(0x0D);      // On termine par un CR
     delay_ms(100);
    
     if (ReponseID == GSM_OK){               // Si "OK" au test baud rate le programme peut continuer
        ReponseID = 0;
        break;                              // On sort de la bocule de test baud rate
      }
   }
 */
  envoi_commande_Parametre("AT");
 
  while(ReponseID != GSM_Call_Ready);       // J'attends que le module soit pret "Call_Ready"
  ReponseID = 0;
  
  envoi_commande_Parametre("ATE0");
  envoi_commande_Parametre("AT+CMGF=1");
  envoi_commande_Parametre("AT");

  delay_ms(3000);                            // Lecture des SMS
  
  envoi_commande_Parametre("AT+QMGDA=\"DEL ALL\"");

 for (i=0;i<6;i++){
        Led = ~Led;
        delay_ms(100);
     }
}

//------------------------------------------------------------------------
// Param. d'entrée : La commande à envoyer
void envoi_commande_Parametre(char *s1){
  while(1) {
   
      while(*s1) {
         UART_Write(*s1++);
       }
      UART_Write(0x0D);   // On termine par un CR
      
      Delay_ms(100);
      
      if (ReponseID == GSM_OK){
          ReponseID = 0;
          break;
       }
   }
}

//------------------------------------------------------------------------------
// Envoi de commande ou donnée avec attente de la réponse
// Param. d'entrée : La commande à executer, et la réponse attendue a cette commande
void envoi_commande_avec_reponse(char *s1, char rspns ){
    
   char Compteur=0, Compteur2 =0, Bonne_reponse = 0;      // Variables locales

   // ---- Envoi de la commande
   while(*s1) {
      UART_Write(*s1++);
    }
   UART_Write(0x0D);   // On termine par un CR
   delay_ms(100);


   while (ReponseID != rspns){    // J'attends la réponse
        delay_ms(20);
        Compteur++;
        
        if (ReponseID == GSM_ERROR){
            ReponseID = 0;
           break;
         }
        // if (Compteur >= 250)
        //  break;
     }
}


//------------------------------------------------------------------------
//-----------------  Copie le texte depuis ROM vers RAM    ---------------
//------------------------------------------------------------------------
// Param. d'entrée : le tableau où on doit stocker le texte, et la chaine de caracteres à stocker
void strConstRamCpy(char *dest, const char *source){
  while(*source)
       *(dest++) = *(source++) ;
  *dest = 0 ;    // Rajout du terminateur
}

//------------------------------------------------------------------------
// Param. d'entrée : La commande à envoyer
void envoi_commande_sans_reponse(const code char *s1){
   while(*s1) {
    UART_Write(*s1++);
   }
   UART_Write(0x0D);   // On termine par un CR
} 

[paulfjujo]

bonsoir Jeremy


je pense que c'est du au type de donnees
Dans un cas c'est un pointeur de char
Dans l'autre c'est une valeur en dur, dans le code ..

essaie avec un cast de forcer le type de pointeur
envoi_commande_Parametre((char *)"AT");

ou modifie la fonction :
void envoi_commande_Parametre(const char *s1)

[Jérémy]

Bonsoir Paul,

Ou ije pense que c'est un problème dans ce genre.

Du coup je pense que cela va me résoudre d'autre bug incompréhensible. Car les commandes envoyées de cette façon ne passe qu'une fois la première ! donc si il y a un loupé au premier coup, le deuxième envoi ne sert à rien et ca bug. Cela explique pourquoi sans raison apparente l'initialisation ne passait pas parfois !

Du coup en voulant optimiser et rendre plus lisible, j'ai compliqué et bugger mon code! . Surtout quand on touche aux pointeurs et en plus en les passant entre fonction; Je cherche le bâton pour me faire battre...... Maudit pointeur....

Demain j'essayerai ta solution, sinon je vais faire au plus simple mais plus long lol

[Jérémy]

En fait dans m’exempte de mikroe sur le GSM2 click, il utilise deux commandes différentes et donc évite ce genre de tracas.

Comme je ne suis pas plus malin que mikroE , je vais faire pareil .....

Une boucle infinie avec dedans , une commande pour envoyer le texte, et une autre pour attendre la réponse;
Je ne me sens pas faire une fonction avec passage de chaine de caractères sans terminateur à la fin.