[Jérémy]

Bonjour à tous,

Mes investigations avance bien !

J'arrive maintenant a communiquer avec le M95 direct avec mon PC, pour comprendre les commandes ... En fait il ne faut pas croiser les fils du câbles . Tx sur TX et RX sur RX . Ensuite j'ai initialiser complétement le MP95 avec le PIC, j'ai vérifie que ça fonctionnait , puis j'ai retirer le PIC en prenant de laisser la broche PWRKEy a Vcc .

Du coup maintenant j'envoie des commandes et il me répond ; Bon c'est pas du 100% la bonne réponse mais bon, je comprends maintenant mieux pourquoi il y a plusieurs boucles infinies dans le programme test .

J'ai donc pu tester la commande = "AT+CSQ" qui me renvoie le niveau de réseau. Impeccable je pourrais ainsi signaler si le module capte ou NON .

Je vais donc comme Paul chercher à le mettre en sommeil, mais je ferais pas bien mieux à mon avis . 28mA en reception seul c'est pas mal je pense.

@Paul: concernant les 120ms de Ring permettant de sortir du mode sommeil, as-tu essayé de rallonger le temps de la sonnerie avec "AT+VTD"

Un peu de lecture : http://www.quectel.com/UploadImage/Down ... n_V1.3.pdf
Page 58, Il parle de 0.98mA en fonction minimum ET sleep mode !!!!

As tu une autre piste pour réduire la conso ? même en intervenant niveau hard !

La commande "AT+CFUN" à l'air peut être intéressante en endormant le module, seul l'UART reste a accessible ; Ainsi par exemple l'UART pourrai le réveiller toute les minute pour vérifier si un message est arrivé ? Pas de message on l'endort , sinon lecture du mesage traitement du message et dodo pour 1 minute.

Le mode sleep ( plus facile) peut reveiller le Module sur reception de SMS ! intéressant aussi

[sylvain54]

Salut,

ça avance bien cette histoire, je suis cela avec intérêt
Je ne peux pas vous aider, je n'ai pas la chance d'avoir ce shield. Mais ça donne envie

++

[Jérémy]

Honnêtement c'est juste énorme ! J'en reviens toujours pas .

L'envoi d'un sms au module et on peut faire ce qu'on veut !!! c'est juste énorme. Ca m'a troué le C.., quand j'ai vu mes leds changées sur ma plaque après envoi du SMS . Le pire c'est que tu reçois un SMS de retour t'indiquant des choses et l'état de tes I/O de ta carte !!!! Incroyable. Ca ouvre tellement de possibilité ....

Petit Bémol , comme j'aime ce qui est nomade, la consommation reste un point clef . mais si j'arrive à paramétrer correctement ce module, j’espère tombé au 1.3mA promis par la DS ! la ce serait le top du top ; avec un petite batterie de 1000mAh on pourrais tenir un sacré moment

[paulfjujo]

bonjour,

while(*s1 == 1)

Donc il faudrait détecter un "1" et pas un "0" ????

TANT QUE *s1 est vrai ( different de zero) on boucle
donc si on rencontre un zero , on sort ..

[Jérémy]

TANT QUE *s1 est vrai ( different de zero) on boucle
donc si on rencontre un zero , on sort ..

et

[Jérémy]

Je crois que j'ai fais une connerie ! A force de tripâtouiller !!

Mon module ne réagit plus comme avant même avec le programme d'exemple ! Incompréhensible . j’ai l'ai ausculté et rien d'étrange dans le programme, le liaison UART fait des siennes et ne m'indique n'importe quoi.
Je penche peut être a une mauvaise manipulation de ma part , qui a changer le mode de fonctionnement un truc du genre ;

Je vais essayer trouver la commande pour le remettre en mode usine

[Jérémy]

Bon je jette l'éponge , sans aide j'y arriverai pas , un détail doit m'échapper.

Voici le programme qui est censé fonctionner ! J'ai juste rajouter la commande de son pour faire buzzer 3 fois quand on reçoit un SMS et 1 fois après un démarrage réussi !
Ceci a très bien fonctionner jusque la !

Que ce passe-t-il :

Au démarrage j'ai bien mon bip de fin d’initialisation, suivi dans la foulée de 3 bip d'envoi de message ! et je reçois effectivement un SMS m'indiquant le statut de ma carte .

Déjà ce SMS ne devrait pas partir au démarrage ? première chose bizarre , ensuite il me met tout les sorties à 1 ( toutes les leds sont allumées) alors qu'au départ elles sont éteintes .

Mon ressenti serait qu'au démarrage il me charge un vieux sms, qui me met mes sorties à 1 avec une demande de statut, et donc s’exécute ! Oui mais on est censé avoir supprimer les messages lors de l'initialisation ?

Quand j'envoi un sms pour éteindre une led ( vu qu'elles sont toutes allumées), il le reçoit mais n'éteins pas la led . par contre le PORT est mis à jour et la valeur analogique lue aussi !

Je ne sais plus quoi faire ! surtout que je n'arrive pas a retrouver mon terminal , il m’indique n’importe quoi
j'ai essayé en passant à 4800 bauds et 19200 bauds rien

Je presque rien touché a part le buzzer !

Code : Tout sélectionner

/*
 Test du module  GSM2 click
 * Copyright: (c) MikroElektronika, 2011.

 * Description:
   Ce programme utilise le module GSM Quectel M95 pour envoyer et recevoir des SMS
   Je controle ma carte easy PIC et envoie son état par SMS .
   Je recois dans le SMS, l'état d'une broche Analogique, l'état du niveau sur le PORTB et l'état de mon PORTD

 *configuration:
     MCU:             PIC18F46K22
                      http://ww1.microchip.com/downloads/en/DeviceDoc/41412F.pdf
     Carte:           EasyPIC7
                      http://www.mikroe.com/easypic/
     Oscillateur:     HS-PLL 32.0000 MHz, 8.0000 MHz Crystal
     modules ext.:    gsm2 clickick
                      http://www.mikroe.com/click/gsm2/
                      Quectel M95
                      https://www.soselectronic.hu/a_info/resource/c/quectel/M95_ATC_V1.0.pdf
     SW:              mikroC PRO for PIC
                      http://www.mikroe.com/mikroc/pic/
 * NOTES:
     - Les SMS à envoyer au module doivent contenir les mot clef suivant :
       "Statut?" indiquant que l'on souhaite recevoir l'état de notre carte
       Si on désire modifier une broche du PORTD, on envoie le mot clef:
       Pour mettre à 1 : "Set" suivi de "RDx"  ( x = Numero de la broche ) ex " Set RD0 RD1 RD2 RD3"
       Pour mettre à 0 : "Clear" suivi de RDx  ( x = Numero de la broche ) ex " Clear RD4 RD5 RD6 RD7"
    
    -  "Set RD0 RD4 RD6 Clear RD2 RD5 Status?" fonctionne aussi .
    -  ATTENTION à la Casse
 */

// Réglages des commande "AT" de bases
const char atc0[] = "AT";                        // Toutes les commandes "AT" commance par "AT"
const char atc1[] = "ATE";
const char atc2[] = "AT+CMGF=1";                 // TXT messages
      char atc3[] = "AT+CMGS=\"";                // envoi de  SMS au numero choisi
const char atc4[] = "AT+CMGR=1";                 // Commande pour lire les messages de l'emplacement 1 de la sauvegarde
      char atc5[] = "AT+CMGD=1";                 // Efface le message à 'lemplacement 1
const char atc6[] = "AT+CMGL=\"ALL\"";           // Vérifie l'état du SMS recu
//

// Tables des Réponses attendues
const GSM_OK                       = 0;
const GSM_Ready_To_Receive_Message = 1;
const GSM_ERROR                    = 2;
const GSM_UNREAD                   = 3;

sbit PWRKEY at RE1_bit;
sbit PWRKEY_Direction at TRISE1_bit;

char Digital_INPUT            at PORTB;   // Valeur du Port B
char Digital_INPUT_Direction  at TRISB;
char Digital_OUTPUT           at LATD;    // Valeur du Port D
char Digital_OUTPUT_Direction at TRISD;

char SMS_Message[300];  // Message composant le SMS
char ADC1_data[6];      // donnée ADC en string pour stockage
char phone_number[20];  // Numéro de téléphone en string format : {"+336********"}
char status_req = 0;    // flag : demande de status

// Variables de controle du statut
char gsm_state = 0;
char response_rcvd = 0;
short responseID = -1, response = -1, rsp;
char set_stat = 0, clr_stat = 0;
char PORT_flag = 0;
char Digital_O = 0;
char gsm_number = 0;
char Unread_flag;
char i;

//------------------------------------------------------------------------------
// Envoi de commande ou donnée (const)
void M95_Send(const char *s){
   while(*s) {
    UART1_Write(*s++);
   }
   UART_Wr_Ptr(0x0D);   // On termine par un CR
}

// Envoi de commande ou donnée (RAM)
void M95_Send_Ram(char *s1){
   while(*s1) {
    UART_Wr_Ptr(*s1++);
   }
   UART_Wr_Ptr(0x0D);   // On termine par un CR
}


// Get GSM response, if there is any
short Get_response() {
    if (response_rcvd) {   // Si il y a une reponse qui est finie  (flag levé)
      response_rcvd = 0;   // RAZ du flag
      return responseID;   // On renvoie l'identification de la réponse
    }
    else
      return -1;           // Sinon on renvoie -1
}

//------------------------------------------------------------------------------
// Attente de la réponse du GSM (boucle infinie)
void Wait_response(char rspns) {
char test = 1;
  
  while (test){
  test = Get_response();
  if ((test == rspns) || (test == GSM_ERROR))
    test = 0;
  else
    test = 1;
  }
}

//------------------------------------------------------------------------------
// Fonction qui compose le message du "statut"
unsigned ComposeMessage(char* Message);

//------------------------------------------------------------------------------
// Envoi du SMS "status"
void Send_Msg(char* Msg){
  char atc[33];
  
  atc[0] = 0;                        // Initialisation du début de tableau
  strcat(atc, atc3);                 // rajoute la commande d'envoi de message(atc3) dans le tableau atc[]
  strcat(atc, phone_number);         // Rajout le numéro de téléphone   à la suite
  strcat(atc, "\"");                 // et on fini avec une commande AT
  // Ex: atc[]= "AT+CMGS=06******xx\""
  M95_Send_Ram(atc);                 // Envoi la commande pour envoyer le message
  
  Wait_response(GSM_Ready_To_Receive_Message); // On attend que le GSM soit pret

  M95_Send_Ram(Msg);                 // Envoi du contenu du Msg
  UART_Wr_Ptr(0x1A);                 // Envoi CTRL + Z comme caractere de fin
  UART_Wr_Ptr(0x0D);                 // Envoi un  "CR"
  Wait_response(GSM_OK);             // Attente de "OK" comme confirmation que le message a été envoyé
}

// Envoi le SMS de "Statut" au numéro défini avec la commande act3
void Send_Status(){
 ComposeMessage(SMS_Message);  // Compose le message formaté
 Send_Msg(SMS_Message);        // Envoi le message
}

// Pause de 3s
void Wait(){
   Delay_ms(3000);
}

//##############################################################################
//###################     MAIN     #############################################
//##############################################################################
void main(){
  ANSELA = 0;             // Tous les PORT en Digital
  ANSELB = 0;
  ANSELC = 0;
  ANSELD = 0;
  ANSELE = 0;

  SLRCON = 0;             // Set output slew rate on all ports at standard rate

  ANSELA |= 0x01;         // Met la broche A0 en entrée analogique
  TRISA0_bit = 1;         // Met la broche A0 en entrée

  Digital_INPUT_Direction = 0xFF;  // PORTB en Entrée
  Digital_OUTPUT_Direction = 0;    // PORTD en sortie
  Digital_OUTPUT = 0;              // Mise à zéro des sorties


//------------------------------------------------------------------------------
// Réglages de l'interruption
  RC1IE_bit = 1;          // Enable Rx1 intterupts
  PEIE_bit = 1;           // Enable peripheral interrupts
  GIE_bit  = 1;           // Enable global interrupts


//------------------------------------------------------------------------------
//  Activation de l'alim avec la pin PWRKEY
  PWRKEY_Direction  = 0;  // PWRKEY en sortie
  PWRKEY = 0;             // Mise à zéro
  Delay_ms(2500);         // Maintenir à 0 pendant plus de 2S
  PWRKEY = 1;             // Allume le module
  

//------------------------------------------------------------------------------
  UART1_Init(9600);      // Initialisation de l'UART
  ADC_Init();            // Initialisation du lecteur analogique
  Delay_ms(200);
  Sound_Init(&PORTC, 2);  // Initialisation du Sound

//------------------------------------------------------------------------------
// Test du baud rate
  while(1){
    M95_Send(atc0);                 //On envoi la commande "AT" pour obtenir la réponse "OK" et verifier la com
    Delay_ms(100);                  // Laisse le temps de recevoir la réponse
    if (Get_response() == GSM_OK)   // Si la réponse du M95 repond est "OK" au test baud rate le programme peut continuer
      break;                        // On sort de la boucle de test baud rate
  }

  Wait(); Wait();         // Attendre pour que le réseau GSM se configure, 6 secondes.

//------------------------------------------------------------------------------
// Quelques parametrages du module
  M95_Send(atc2);        // Reglage des messages de type "texte"
  Wait_response(GSM_OK); // Attende de la réponse

  M95_Send(atc1);        // Désactivation de la commande "Echo"
  Wait_response(GSM_OK); // Attende de la réponse


//------------------------------------------------------------------------------
//  Effacement de message
while(1){
   M95_Send_Ram(atc5);           // Envoi la commande pour effacer le message en place 1 si il existe
   if (get_response() == GSM_OK) // Si la réponse est "OK" message effacé, on sort de la boucle
     break;
   Delay_ms(500);
 }

 while(1){
   atc5[8] = '2';                // On remplace le chiffre "1"(8iéme valeur du tableau) dans la commande atc5[] par 2,   ca donne char atc5[] = "AT+CMGD=2";
   M95_Send_Ram(atc5);           // On efface donc le 2ieme message
   if (get_response() == GSM_OK) // Si la réponse est "OK" message effacé, on sort de la boucle
     break;
   Delay_ms(500);
 }

 while(1){
   atc5[8] = '3';                // On remplace le chiffre "1"(8iéme valeur du tableau) dans la commande atc5[] par 3,   ca donne char atc5[] = "AT+CMGD=3";
   M95_Send_Ram(atc5);           // On efface donc le 3 ieme message)
   if (get_response() == GSM_OK) // Si la réponse est "OK" message effacé, on sort de la boucle
     break;
   Delay_ms(500);
 }

 atc5[8] = '1';                  // On remet la valeur à 1 pour revenir au 1 message

//------------------------------------------------------------------------------
 // Allume le PORTD pour signifier l'initialisation c'est bien passéee et finie
 // Initialize the pin RC3 for playing sound

 Sound_Play(2000, 100);

 Digital_OUTPUT = 0xFF;
 Delay_ms(500);
 Digital_OUTPUT = 0;

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

    M95_Send(atc6);                  // On demande si un message à été recu
    Delay_ms(100);                   // Pause

    while(1) {
      M95_Send(atc0);                // Ici on attend que le module soit pret
      Delay_ms(50);
      if (Get_response() == GSM_OK)  // Si la réponse est "OK" le module est donc pret
        break;                       // On sort de la boucle d'attente
    }

    if (Unread_flag){         // Si il y a un message non lu , suite à reception de "UNREAD" dans le buffer
    
       for (i=0;i<3;i++){
       Sound_Play(5000, 50); // On joue un son
       Digital_Output = 0;
       delay_ms(50);

       }
       
          if (PORT_flag){     // Si le flag du port est levé
            PORT_flag = 0;    // On raz le flag
            Digital_Output = Digital_O; // On allume les leds du port en fonction de la valeur recue
          }

          while(1) {
            M95_Send(atc0);               // Ici on attend que le module soit pret
            Delay_ms(50);
            if (Get_response() == GSM_OK) // Si la réponse est "OK" le module est donc pret
              break;                      // On sort de la bocule d'attente
          }

          if (status_req){       // Si le drapeau de la demande de statut est lévé
            status_req = 0;      // On RAz le drapeau
            Send_Status();       // Envoyer le SMS du "Statut"
          }

          Unread_flag = 0;      // RAZ du flag non lu avant effacement des messages


          while(1){              // Boucle qui permet d'éffacer les messages qui ont été lus
            M95_Send_Ram(atc5);  // Envoi de la commande pour effacer le message
            Delay_ms(50);
            if (get_response() == GSM_OK) // Si tout les messages ont été éffacés recetpion de "OK"
              break;                      // Alors on sort de la boucle
              
            Delay_ms(50);
            
            if (Unread_flag){  // Si entre temps on recoit un message on sort d'ici pour le lire
              Unread_flag = 0; // RAZ du flag "non lu"
              break;           // On sort de la boucle
            }
          }
     }
    Wait();
    

  }

}


/*****************    Composition du message de retour   **********************/

unsigned ComposeMessage(char* Message){
  unsigned adc_value1, adc_value2;
  char temp_txt[15];
  char PORTB_temp, i, PORTD_temp;

  RC1IE_bit = 0;                // Désactive l'interruption RX1

  Message[0] = '\0';

  // SMS header
  strcat(Message, "INFO:");         // Ecrit du texte
  strcat(Message, "\r\n");          // Passe à la ligne(CR + LF)

  temp_txt[0] = 0;                 // Place un null en début de ligne
  strcat(temp_txt, "PORTB ");      // Ecrit du texte
  PORTB_temp = Digital_INPUT;      // Recopie la valeur du PORTB dans une temporaire
  for (i = 0; i < 8; i ++){        // Envoie l'état du PORTB en binaire
    temp_txt[13 - i] = (PORTB_temp % 2) + 48;
    PORTB_temp = PORTB_temp / 2;
  }
  temp_txt[14] = 0;                // Fin de chaine
  strcat(Message, temp_txt);       // Rajout du txt temporaire à la suite du message
  strcat(Message, "\r\n");         // Passe à la ligne(CR + LF)

  temp_txt[0] = 0;                 // Place un null en début de ligne
  strcat(temp_txt, "PORTD ");      // Ecrit du texte
  PORTD_temp = Digital_O;          // Recopie la valeur du PORTD dans une temporaire
  for (i = 0; i < 8; i ++){        // Envoie l'état du PORTD en binaire
    temp_txt[13 - i] = (PORTD_temp % 2) + 48;
    PORTD_temp = PORTD_temp / 2;
  }
  temp_txt[14] = 0;                // Fin de chaine
  strcat(Message, temp_txt);       // Rajout du txt temporaire à la suite du message
  strcat(Message, "\r\n");         // Passe à la ligne(CR + LF)

  adc_value1 = ADC_Get_Sample(0);  // Lecture de la valeur analogique sur RA0
  WordToStr(adc_value1, ADC1_data);// Conversion en chaine de caractere
  strcat(Message, "AN0 - ");       // Ecrit du texte
  strcat(Message, ADC1_data);      // Rajoute la valeur lue à la suite du message
  strcat(Message, "\r\n");         // Passe à la ligne(CR + LF)

  // SMS footer
  strcat(Message, "Fin.");        // Ecrit du texte
  strcat(Message, "\r\n");        // Passe à la ligne(CR + LF)

  RC1IE_bit = 1;                 // On reactive les interrutpions sur RX1

  return strlen(Message);        // retourne la longueur du message
}


//##############################################################################
// Lecture des données dans le buffer UART par INT
void interrupt(){
char tmp;
char i;
  if (RCIF_bit == 1) {                           // Si INT UART détecté
    tmp = UART_Rd_Ptr();                         // On récupere et stock la donnée

// Ici on analyse les réponse possibles jusqu'a trouver la bonne réponse
// Suivant le résultat de la premiere lettre recue dans le BUFFER on indique quelle peut etre la suivante
// On continue jusqu"a obtenir un mot complet, et donc un résultat ou une réponse.
// On commence toujours par un gsm_state=0 et on indique que response = -1 tant que l'on a pas un mot complet
    switch (gsm_state) {
      case  0: {
                response = -1;                   // Clear response
                if (tmp == 'O')                  // si Nous avons un 'O', C'est peut-être le mot "OK"
                  gsm_state = 1;                 // On signale qu'on attend peut etre un 'K'
                if (tmp == '>')                  // si Nous avons un '>', C'est peut-être le mot "> "
                  gsm_state = 10;                // On signale qu'on attend peut etre un  ' '
                if (tmp == 'E')                  // si Nous avons un 'E', C'est peut-être le mot "ERROR "
                  gsm_state = 30;                // On signale qu'on attend peut etre un 'R'
                if (tmp == 'S')                  // si Nous avons un 'S', C'est peut-être le mot  "Status?" ou "Set"
                  gsm_state = 40;                // On signale qu'on attend peut etre un 't' pour le mot "Statut" sinon se sera "Set"
                if (tmp == 'R')                  // si Nous avons un 'R', C'est peut-être le mot "RDx" or
                  gsm_state = 50;                // On signale qu'on attend peut etre un 'D'
                if (tmp == 'C')                  // si Nous avons un 'C', C'est peut-être le mot "Clear"
                  gsm_state = 110;               // On signale qu'on attend peut etre un 'l'
                if (tmp == 'U')                  // si Nous avons un 'U', C'est peut-être le mot "UNREAD"
                  gsm_state = 120;               // On signale qu'on attend peut etre un 'N'
                break;
               }
      case  1: {
                if (tmp == 'K') {                // Nous avons un 'K' ->
                  response = GSM_OK;             // Donc on a "OK" , la réponse du M95 c'est "OK"
                  gsm_state = 20;                // on va faire un CR+LF
                }
                else
                  gsm_state = 0;                 // si après le 'O' on a pas le 'K' On retourne au départ
                break;
               }
      case 10: {
                if (tmp == ' ') {
                  response_rcvd = 1;             // Nous avons "> " response
                  response = GSM_Ready_To_Receive_Message; // Set reception flag
                  responseID = response;         // Set response ID
                }
                gsm_state = 0;                   // Reset state machine
                break;
                }

      case 20: {
                if (tmp == 13)                   // We have 13, it could be CR+LF
                  gsm_state = 21;                // Expecting LF
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 21: {
                if (tmp == 10) {                 // We have LF, response is complete
                  response_rcvd = 1;             // Set reception flag
                  responseID = response;         // Set response ID
                }
                gsm_state = 0;                   // Reset state machine
                break;
               }

      case 30: {
                if (tmp == 'R')                  // We have 'R', it could be "ERROR"
                  gsm_state = 31;                // Expecting 'R'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 31: {
                if (tmp == 'R')                  // We have 'R', it could be "ERROR"
                  gsm_state = 32;                // Expecting 'O'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 32: {
                if (tmp == 'O')                  // We have 'O', it could be "ERROR"
                  gsm_state = 33;                // Expecting 'R'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 33: {
                if (tmp == 'R'){                 // We have 'R'
                  response_rcvd = 1;             // We have "ERROR" response
                  response = GSM_ERROR;          // Set reception flag
                  responseID = response;         // Set response ID
                }
                gsm_state = 0;                   // Reset state machine
                break;
                }
      case 40: {
                if (tmp == 't')                  // We have 't', it could be "Status?"
                  gsm_state = 41;                // Expecting 'a'
                else
                  if (tmp == 'e')                // We have 'e'. it could be "Set"
                    gsm_state = 100;
                  else
                    gsm_state = 0;               // Reset state machine
               }; break;
      case 41: {
                if (tmp == 'a')                  // We have 'a', it could be "Status?"
                  gsm_state = 42;                // Expecting 't'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
      case 42: {
                if (tmp == 't')                  // We have 't', it could be "Status?"
                  gsm_state = 43;                // Expecting 'u'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }

       case 43: {
                if (tmp == 'u')                  // We have 'u', it could be "Status?"
                  gsm_state = 44;                // Expecting 's'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }

       case 44: {
                if (tmp == 's')                  // We have 's', it could be "Status?"
                  gsm_state = 45;                // Expecting '?'
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }

       case 45: {
                if (tmp == '?'){                 // We have '?'
                  status_req = 1;                // Status has been requested!
                }
                gsm_state = 0;                   // Reset state machine
                break;
                }

       case 50: {
                if (tmp == 'D')                  // We have 'D', it could be "RDx"
                  gsm_state = 51;                // Expecting number
                else
                  gsm_state = 0;                 // Reset state machine
                break;
               }
       case 51: {
                if (tmp >= '0' && tmp <= '7'){   // We have pin number, it could be "RDx"
                  if (set_stat)
                    Digital_O |= 1 << (tmp - '0');
                  if (clr_Stat)
                    Digital_O &= (0xFF ^(1 << (tmp - '0')));
                }
                  PORT_flag = 1;
                  gsm_state = 0;                 // Reset state machine
               }; break;

       case 100: {
                   if (tmp == 't'){              // We have 't', we received set command
                     set_stat = 1;               // Set following bits
                     clr_stat = 0;               // Do not clear following bits
                   }
                   gsm_state = 0;
                 }; break;
       case 110: {
                   if (tmp == 'l'){              // We have 'l', it could be Clear
                     gsm_state = 111;
                   }
                   else
                     gsm_state = 0;
                 }; break;
       case 111: {
                   if (tmp == 'e'){              // We have 'e', it could be Clear
                     gsm_state = 112;
                   }
                   else
                     gsm_state = 0;
                 }; break;
       case 112: {
                   if (tmp == 'a'){              // We have 'a', it could be Clear
                     gsm_state = 113;
                   }
                   else
                     gsm_state = 0;
                 }; break;
       case 113: {
                   if (tmp == 'r'){              // We have 'r', we have received Clear
                     clr_stat = 1;               // Clear following bits
                     set_stat = 0;               // Do not set following bits
                   }
                   gsm_state = 0;
                 }; break;
       case 120: {
                  if (tmp == 'N')
                    gsm_state = 121;
                  else
                    gsm_state = 0;
                 }; break;
       case 121: {
                  if (tmp == 'R')
                    gsm_state = 122;
                  else
                    gsm_state = 0;
                 }; break;
       case 122: {
                  if (tmp == 'E')
                    gsm_state = 123;
                  else
                    gsm_state = 0;
                 }; break;
       case 123: {
                  if (tmp == 'A')
                    gsm_state = 124;
                  else
                    gsm_state = 0;
                 }; break;
       case 124: {
                  if (tmp == 'D'){
                    response_rcvd = 1;             // Nous avon un message non lu
                    response = GSM_UNREAD;         // Set reception flag
                    responseID = response;         // Set response ID
                    Unread_flag = 1;               // drapeau de unread levé
                  }
                  gsm_state = 0;
                 }; break;
      default: {                                 // Si un charactere non reconnu
                gsm_state = 0;                   // On reset
               }
    }
    
    // analyse le numéro de téléphone sur lequel on doit répondre
    switch (gsm_number) {
      case 0 :{
               if (tmp == '"'){
                 gsm_number = 1;
                 i = 0;
               }
              }; break;
      case 1 :{
               if (tmp == '+'){
                 phone_number[i] = tmp;
                 i ++;
                 gsm_number = 2;
               }
               else{
                 gsm_number = 0;
                 i = 0;
               }
              }; break;
      case 2 :{
               if (tmp >= '0' && tmp <= '9'){
                 phone_number[i] = tmp;
                 i ++;
               }
               else 
                 if (tmp == '"'){
                   phone_number[i] = 0;
                   i = 0;
                   gsm_number = 0;
                 }
                 else{
                   phone_number[0] = 0;
                   i = 0;
                   gsm_number = 0;
                 }
              }; break;
      default : {
                 phone_number[0] = 0;
                 i = 0;
                 gsm_number = 0;
                }
    }
 }
}

[paulfjujo]

bonsoir

Code : Tout sélectionner

if (RCIF_bit == 1) {                           // Si INT UART détecté
    tmp = UART_Rd_Ptr();                         // On récupere et stock la donnée
 

ou est la fonction UART_Rd_Ptr(); ?

[Jérémy]

Merci Paul d'avoir prit un peu de ton temps .

Je viens de trouver mon problème! enfin , de le résoudre . Mon intuition était la bonne. Il s'agissait bien d'un problème vers le stockage des SMS .

Au lieu de supprimer 1 par 1 les SMS en modifiant la commande , j'ai utilisé une commande fait pour ça .

Code : Tout sélectionner

while(1){
   M95_Send_Ram("AT+QMGDA=\"DEL ALL\""); // Envoi la commande pour effacer tous les messages
   if (get_response() == GSM_OK) // Si la réponse est "OK" messages effacés, on sort de la boucle
     break;
   Delay_ms(500);
 } 

Avec ça tous mes SMS se sont effacés et je n'avais plus aucun problème, a part mon UART que je n’arrive a visualiser sur mon terminal !!! ça va être dur d'optimiser sans ça !

Concernant ta question, je viens de regarder !!!! Aucune idée, le seul truc que je peux dire c'est que ca fonctionne bien avec !

Maintenant je me dis que c'est peut etre la cause de mon problème de terminal ! je viens de changer par un classique tmp = UART1_Read();
ça fonctionne aussi . MAis toujours pas mon terminal !

[Jérémy]

Bonsoir,

Mon affaire avance tranquillement , mais il y a de nombreuses commandes à éplucher, alors ca prends un peu de temps!

J'arrive maintenant à bien visualiser le dialogue avec le MODULE et mon PC , mais en 300bauds . A 300 bauds je n'ai aucun problème de lecture et les information sont bonnes à 100%
Si j'augmente la vitesse sur hyper-terminal, les caractères donnent n'importe quoi! je ne sais pas d'où ça peut venir .
Si je change la vitesse UART du PIC cela ne change rien, c'est vraiment la liaison Ordi->module qui rame !

Bizarre, ca ne me dérange pas plus que ce à 300 bauds, c'était par curiosité

Sinon PAul, tu gére l'effacement des SMS recu par "DEL INBOX" ? qu'entend-il par INBOX ? par rapport à un "DEL ALL"