Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur le langage C !

Modérateur : Jérémy

Module GSM2-Click
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1130
Âge : 68
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#71 Message par paulfjujo » dim. 9 oct. 2016 14:20 lien vers la Data-Sheet : Cliquez ici

bonjour,

Avec la combinaison GSM + GPS,
fini les calculs pour obtenir le decalage horaire d'ete/hiver
je recupere en plus de la trame $GPGGA, la trame $GPRMC qui contient
la date et l'heure + le correctif à apporter

En ce moment le correctif est +08 => 8*0,25H => +2H00
(1H00 pour le fuseau horaire et 1H pour l'horaire d'ete)
Bizarre cette correction au 1/4H pres ! mais c'est comme ça!
Pour eviter de faire des requetes GSM systematique, je recupere le parametre HDecal au moment
de l'inirt du GSM , et je lit l'heure GPS , lue toute les 8 secondes, et je corrige l'heure avec ce parametre
ou via une commande envoi SMS "MAH" , qui refera une requete SMS pour obtenir l'heure + correctif GSM.

à l'init ou sur demande "MAH"


Code : Tout sélectionner



void Recupe_DateHeure_GSM
()
{
    int i;
 //  +CCLK: "16/10/06,17:09:07+08"    dans buffer2
 HDecal= 0
   p
=strstr(buffer2,"+CCLK:") ;
 //  UART1_Write_Text(p);
   if((p>0)  && (*(p+25)=='+') )
   {
      HDecal=(*(p+27)-48)/4;
   }
   UART1_Write_CText("\r\n HDecal= ");
   UART1_Write(HDecal+48);
   CRLF1();
}



Code : Tout sélectionner


 Lecture de date et heure 
(AT+CCLK?)
AT+CCLK?
+
CCLK: "16/10/07,09:04:56+08"
OK
 HDecal
= 2
Aides toi, le ciel ou Fantastpic t'aideras

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2229
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#72 Message par Jérémy » mer. 26 oct. 2016 22:34 lien vers la Data-Sheet : Cliquez ici

Bonsoir,

Je crois que je vois le bout avec mon module.
Il me semble que mon probléme de fiabilité était dû au hard . Une mauvaise connexion de mes câbles sur la plaque.

Après de nombreux tests, je n'ai pas encore eu de bugs à déplorer.

Le principe de mon code est le suivant .

On envoie soit :
- un mode "chrono", qui permettait d'allumer quelques choses au bout d'un certains temps
- Un mode "réveil" , qui permettait d'allumer quelques choses à une certaine heure voir jours .

Je suis partis sur le principe de la machine d'état pour les commandes reçues.

Si vous voyez quelques choses qui vous chagrine n’hésitez pas !

Code : Tout sélectionner

/*
 Test du module  GSM2 click pour FantasPic le 26/10/16
 * Description:
   Ce programme utilise le module GSM Quectel M95 pour envoyer et recevoir des SMS
   Je controle ma carte easy PIC et dialogue avec le module

 *configuration:
     MCU:             PIC18F46K22 : http://ww1.microchip.com/downloads/en/DeviceDoc/41412F.pdf
     Carte:           EasyPIC7 : http://www.mikroe.com/easypic/
     Oscillateur:     HS 8.0000 MHz, 8.0000 MHz Crystal  PLL disable
     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:
   - Le clignotement de la led rouge "NET" rapide pas de connexion , lentement Connexion
 */
 
#include "timelib.h"
#define PWRKEY RE1_bit

//##############################################################################
//##################    DECLARATION VARIABLES/CONSTANTES     ###################
//##############################################################################
char Gdh[50];
char SMS_Recu[50];
char Numero_tel[20];         // tableau pour placer le numéro de téléphone en string format : {"+336********"}
char Composition_numero[50];
char Val_Signal[7];
char Val_Heures[4];
char Val_Minutes[4];
char Val_Secondes[4];
char Val_Jours_restant[4];
char Val_Heures_restant[4];
char Val_Minutes_restant[4];
char Val_Secondes_restant[4];

unsigned char Jours_restant=0,  Heures=0Minutes=0Secondes=0Signal=0temp=0Erreur=;
unsigned char Valeur=0Ok=0Buzzer=0CMTI=0CMGS=0Fin_SMS_recu=0Fleche=0;
unsigned char Demande_Lancement=0Demande_Lancement_Reveil=0Lancement=0Fin_Chrono=0Flag_Mah=0;

unsigned int i=0,j=0;

unsigned long Chrono=0epoch1=0epoch2=0diff=0;

TimeStruct ts1ts2 ;     // déclaration des structures pour le calcul du temps

//########################   PROTOTYPE DE FONCTION     #########################
void attente();
void RAZ_SMS_Recu();
void Message_a_envoyer(int);
void Envoi_Commande(const char);

//############################     FONCTION     ################################

// Fonction qui envoie une commande au module, elle boucle jusqu'a recevoir un "OK" ou un "ERROR"
// Param. d'entré : la commande "AT" à envoyer
void Envoi_Commande(const char *Commande){

    
char i=0j=0;   // variables Locales
    
Ok=Erreur=0;     // variables Globales

    
while(1){        // Boucle d'envoi de la commande
         
         
while(*Commande) {             // Boucle pour balayer le texte à envoyer jusqu'au "NULL"
             
UART_Write(*Commande++);
           }
           
UART_Write(13);              // On envoie un CR aprés la fin du texte pour valider

         
while ((Ok==0) && (Erreur==0)) // Je rentre dans une boucle pour attendre la reponse "Ok"
          
{
             
delay_ms(50);
             
i++;
             if (
i>60)                  // Au bout de 60 tentatives je sors pour re-envoyer la commande
                
{
                   
j++;
                   if (
j>=3Ok=1;     // Au bout de 3 boucles de 20 tentatives je sors de la fonction
                   
i=0;
                 }
           }
         if ((
Ok) || (Erreur)) break;   // Si j'ai recu "Ok" ou "erreur" , je sors
     
}
     
Ok=Erreur=0;
 }
 
// ---------------    FONCTION qui envoie les messages -------------------------
// Param. d'entrée : le numéro de la réponse à envoyer
void Message_a_envoyer(int reponse_a_envoyer){

   
char i=0j=0k=0;
   
   do{                     
// Tant que la réponse n'a pas ete envoyer je re-boucle
       
delay_ms(200);
       
k++;
       
// --------------------  Compose le numéro de téléphone  -----------------------
       // Fonction qui compose le numéro de téléphone jusqu'a que la Fleche,signifiant l'attente du message, apparaisse
       
do{
           
i++;
           
Composition_numero[0]=0;                  // Je me place en début de chaine
           
strcat(Composition_numero"AT+CMGS=\""); // rajoute la commande d'envoi de message(CMGS) et on ouvre les guillemets
           
strcat(Composition_numeroNumero_tel);   // On rajoute(colle) le numéro de tel, Ex: "AT+CMGS=06******xx\""
           
strcat(Composition_numero"\"");         // et on ferme les guillemets
           
strcat(Composition_numero0);            // On finit par un terminateur de string "NULL"
           
UART1_Write_Text(Composition_numero);     // On envoie le numero
           
UART1_Write(13);

           for (
j=0;j<=40;j++){           // J'attends la fleche
                
delay_ms(100);
                if (
Fleche) break;
            }
            if (
i>3) break;              // Au bout de trois tentatives j'arrete

         
}while (Fleche==0);             // Je sors aprés avoir recu la petite fleche
      
delay_ms(1000);
      
Fleche 0;

      
//-------------- Selection du message à envoyer    -----------------------
      
switch (reponse_a_envoyer){

             case 
1:{
                       
UART1_Write_Text("Valeurs recues:\r\n");
                       
UART1_Write_Text(Val_Heures);
                       
UART1_Write_Text("h : ");
                       
UART1_Write_Text(Val_Minutes);
                       
UART1_Write_Text("m : ");
                       
UART1_Write_Text(Val_Secondes);
                       
UART1_Write_Text("s\r\n\r\n");
                       
UART1_Write_Text("Voulez-vous le lancer ?");
                       break;
                     }
             case 
2:{
                       
TMR0IE_bit 1// On lance le chrono
                       
UART1_Write_Text("Le chrono est lancé !");
                       break;
                     }
             case 
3:{
                       
UART1_Write_Text("Abandon de l'initialisation");
                       break;
                     }
             case 
4:{
                       
UART1_Write_Text("Etat du module:\r\n");
                       
UART1_Write_Text("Date: ");  // On écrit la date
                       
UART1_Write(Gdh[6]);
                       
UART1_Write(Gdh[7]);
                       
UART1_Write_Text("/");
                       
UART1_Write(Gdh[3]);
                       
UART1_Write(Gdh[4]);
                       
UART1_Write_Text("/");
                       
UART1_Write(Gdh[0]);
                       
UART1_Write(Gdh[1]);
                       
UART1_Write_Text("\r\n");
                       
UART1_Write_Text("Heure:  ");  // On écrit l'heure
                       
for (i=9;i<17;i++)
                           {
                             if ( (
Gdh[i]<58) && Gdh[i]>47 )
                                
UART1_Write(Gdh[i]);
                              else
                                
UART1_Write_Text(":");
                           }
                       
UART1_Write_Text("\r\n");
                       
UART1_Write_Text("Force du signal :"); // On écrit la force du signal
                       
UART1_Write_Text(Val_Signal);
                       
UART1_Write_Text("%\r\n");

                       if (
Lancement==1)       // Le temps qu'il reste
                          
{
                            
UART1_Write_Text("Lancé : OUI\r\n");
                            
UART1_Write_Text("Temps restant :\r\n");
                            if ( 
Jours_restant != 0)
                               {
                                 
UART1_Write_text(Val_Jours_restant);
                                 
UART1_Write_Text("j");
                               }
                            
UART1_Write_Text(Val_Heures_restant);
                            
UART1_Write_Text("h");
                            
UART1_Write_Text(Val_Minutes_restant);
                            
UART1_Write_Text("m");
                            
UART1_Write_Text(Val_Secondes_restant);
                            
UART1_Write_Text("s");
                          }
                       else
                          {
                            
UART1_Write_Text("Lancé : NON");
                          }
                       break;
                     }
             case 
5:{
                       
UART1_Write_Text("Arret du chrono");
                       break;
                     }
             case 
6:{
                       
UART1_Write_Text("LES MOTS CLES SONT:\r\nStop\r\nOui\r\nNon\r\nEtat\r\nChrono Hxx Mxx Sxx\r\nReveil jj/mm/aa hh/mm/ss");
                       break;
                     }
             case 
7:{
                       
UART1_Write_Text("Réveil reglé\r\n");
                       
UART1_Write_Text("le : "); // écrit la date du reveil
                       
UART1_Write(SMS_Recu[7]);
                       
UART1_Write(SMS_Recu[8]);
                       
UART1_Write_Text("\/");
                       
UART1_Write(SMS_Recu[10]);
                       
UART1_Write(SMS_Recu[11]);
                       
UART1_Write_Text("\/");
                       
UART1_Write(SMS_Recu[13]);
                       
UART1_Write(SMS_Recu[14]);
                       
UART1_Write_Text("\r\n");
                       
UART1_Write_Text("a  : ");  // écrit l'heure du reveil
                       
for (i=16;i<24;i++)
                           {
                             
UART1_Write(SMS_Recu[i]);
                           }
                           
i=0;
                       
UART1_Write_Text("\r\nVoulez-vous le lancer ?");
                       break;
                     }
             case 
8:{
                       
UART1_Write_Text("Test\r\n");
                       
Gdh[8]=',';
                       
UART1_Write_Text(Gdh);
                       break;
                     }
             case 
9:{
                       
UART1_Write_Text("Le Chrono est déja lancé.\r\n");
                       
UART1_Write_Text("Utilisez le mot \"STOP\" pour l'arreter");
                       break;
                     }
             case 
10:{
                       
UART1_Write_Text("La Valeur du réveil est anterieur a l\'heure actuelle");
                       break;
                     }
             case 
11:{
                       
UART1_Write_Text("La date reveil est supérieur a une semaine");
                       break;
                     }
             case 
96:{
                       
UART1_Write_Text("Erreur, mot inconnu!.");
                       break;
                     }
             case 
97:{
                       
UART1_Write_Text("Erreur, les valeurs ne sont pas correctes\r\nHeures<100\r\nMinutes<60\r\nsecondes<60");
                       break;
                     }
             case 
98:{
                       
UART1_Write_Text("Erreur, ce mot ne convient pas ici !");
                       break;
                     }
             case 
99:{
                       
UART1_Write_Text("Fin");
                       break;
                     }
         }
        
UART1_Write(0x1A);     // Envoi cu CTRL+Z pour envoyer le message

        
for (j=0;j<=70;j++){   // je reste la pendant au moins 7 Secondes à attendre le mot "CMGS"
              
delay_ms(100);
              if (
CMGS) break;
          }
          
        if (
k>3) break;    // 3 tentatives d'envoi je sors

     
} while (CMGS == 0);  // Si je n'ai aps recu "CMGS" je re-boucle

   
CMGS 0;

   
RAZ_SMS_Recu();    // On efface le buffer du SMS recu
   
attente();
}

// -------------------      boucle d'attente       -----------------------------
// Elle permet de mettre le module dans une position connue
void attente(){
    
char i 0;
    
Ok 0;
    do {         
// Ici on envoie la commande "AT" tant que le Flag "Ok" n'est pas levé
          
i++;
          
UART1_Write_Text("AT\r");
          
delay_ms(50);
          if (
i>=100asm reset;        // Au bout de 100 tentatives on RESET
        
} while(Ok == 0);

    
Ok 0;
    
delay_ms(100);
 }
 
// --------------------------  EFFACE le SMS recu  -----------------------------
// Fait une boucle pour remplir le tableau du SMS par des NULL
void RAZ_SMS_Recu(){
    
char i=0;
    
RC1IE_bit 0;
    for (
i=0;i<=50;i++){  // On efface le tableau contenant le SMS recu .
        
SMS_Recu[i] = 0;
     }
    
SMS_Recu[0] = 0;     // On se place en début de tableau
    
RC1IE_bit 1;
 }


//########################     INTERRUPTION     ################################
void interrupt(){

  if ((
TMR0IF_bit) && (TMR0IE_bit)) {   //  TIMER 0 interruption toute les secondes
      
TMR0IF_bit 0;
      
TMR0H      0x0B;
      
TMR0L      0xDC;
      
PORTD.B7  = ~PORTD.B7;
      
Chrono--;
         if (
Chrono==0)
            {
              
Fin_Chrono 1;
            }
  }

// Lecture des données dans le buffer UART par INT
  
if (RCIF_bit == 1) {      // Si INT UART détecté

    
temp UART1_Read();      // On récupere et stock la donnée

    
switch (Valeur){

           case 
0:{
                    if (
temp == 'O')         // "OK"
                        
Valeur 1;
                    else if (
temp == 'C')    // "CMTI" ou "CMGS" ou "CSQ"
                         
Valeur 20;
                    else if (
temp == '"')    // "N° de tel" ou "Gdh" ou "SM"
                         
Valeur 30;
                    else if (
temp == '>')    // "Fleche"
                         
Valeur 50;
                    else if (
temp == 'E')    // "ERROR"
                         
Valeur 100;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
1:{
                    if (
temp == 'K')
                        
Valeur 2;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
2:{
                    if (
temp == 13)
                        
Valeur 3;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
3:{
                    if (
temp == 10)
                        
Ok 1;        // On a recu le mot "OK , on léve le drapeau
                    
Valeur 0;
                    break;
                  }
           case 
20:{
                    if (
temp == 'M')
                        
Valeur 21;
                    else if (
temp == 'S')
                        
Valeur 25;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
21:{
                    if (
temp == 'T')
                        
Valeur 22;
                    else if (
temp == 'G')
                        
Valeur 23;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
22:{
                    if (
temp == 'I')
                       {
                          
CMTI 1;     // On a recu "CMTI", on léve le drapeau
                          
Valeur 0;
                        }
                    else
                        
Valeur 0;
                    break;
                  }
           case 
23:{
                    if (
temp == 'S')
                       {
                          
CMGS 1;     // On a recu "CMGS", on léve le drapeau
                          
Valeur 0;
                        }
                    else
                        
Valeur 0;
                    break;
                  }
           case 
25:{
                    if (
temp == 'Q')
                          
Valeur 26;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
26:{
                    if (
temp == ':')       // On a recu "CSQ" on enregistre la valeur
                          
Valeur 27;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
27:{
                    if (
temp == ' ')
                          
Valeur 28;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
28:{
                    if (
temp >= '0' && temp <= '9')
                       {
                         
Val_Signal[0] = '0' ;
                         
Val_Signal[1] = temp ;
                       }
                    
Valeur 29;
                    break;
                  }
           case 
29:{
                    if (
temp >= '0' && temp <= '9')
                       {
                         
Val_Signal[0] = Val_Signal[1] ;
                         
Val_Signal[1] = temp ;
                       }

                    
Val_Signal[2] = 0;
                    
Valeur 0;
                    break;
                  }
           case 
30:{
                    if (
temp == '+')                // On enregistre le numéro de téléphones
                       
{
                          
Numero_tel[0] = temp;
                          
1;
                          
Valeur 31;
                        }
                     else if (
temp == '2')          // On enregistre la date
                          
Valeur 40;
                     else
                        
Valeur 0;
                  };break;
           case 
31:{
                     if (
temp >= '0' && temp <= '9')
                        {
                          
Numero_tel[i] = temp;
                          
i++;
                        }
                     else if (
temp == '"')
                        {
                          
Numero_tel[i] = 0;
                          
0;
                          
Valeur 0;
                        }
                      else
                        {
                          
Numero_tel[0] = 0;
                          
i=0;
                          
Valeur 0;
                        }
                  };break;
           case 
40:{
                    if (
temp == '0')
                        
Valeur 41;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
41:{
                    if (
temp == '1')
                       {
                         
Gdh[0] = temp;
                         
1;
                         
Valeur 42;
                       }
                    else
                        
Valeur 0;

                    break;
                  }
           case 
42:{
                     if (
temp != '"')
                        {
                          
Gdh[i] = temp;
                          
i++;
                        }
                     else
                        {
                          
Gdh[i] = 0;   // Je termine le Gdh par un "NULL" terminateur
                          
0;
                          
Valeur 43;
                        }
                     break;
                  }
           case 
43:{
                    if (
temp == 13)
                        
Valeur 44;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
44:{
                    if (
temp == 10)
                       {
                         
i=0;
                         
SMS_Recu[0] = 0;
                         
Valeur 45;
                       }
                    else
                        
Valeur 0;
                    break;
                  }
           case 
45:{
                     if (
temp != 10)
                        {
                          
SMS_Recu[i] = temp;
                          
i++;
                        }
                     else
                        {
                          
SMS_Recu[i] = 0;  // Je rajoute un terminateur "NULL"
                          
0;
                          
Fin_SMS_recu 1// Je signale que j'ai fini d'enrregistrer le message
                          
Valeur 0;
                        }
                     break;
                  }
           case 
50:{
                    if (
temp == ' ')
                       
Fleche 1;   // Je léve le drapeau
                    
Valeur 0;
                    break;
                  }
           case 
100:{
                    if (
temp == 'R')
                        
Valeur 101;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
101:{
                    if (
temp == 'R')
                        
Valeur 102;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
102:{
                    if (
temp == 'O')
                        
Valeur 103;
                    else
                        
Valeur 0;
                    break;
                  }
           case 
103:{
                    if (
temp == 'R')
                        
Erreur 1;   // Je léve le drapeau
                        
Valeur 0;
                    break;
                  }

           default: 
valeur 0;
    }
 }
}
//##############################################################################
//############################     MAIN     ####################################
//##############################################################################
void main(){

  
ANSELA ANSELB ANSELC ANSELD ANSELE 0// Tous les PORT en Digital
  
TRISB 0XFF ;        // Entrée
  
TRISD TRISE ;   // Sortie
  
LATD LATE 0;      // RAZ des sorties

//------------------------------------------------------------------------------
//  Activation de l'alimentation avec la pin PWRKEY
  
PWRKEY 0;             // Mise à zéro
  
delay_ms(3000);         // Maintenir à 0 pendant plus de 2S
  
PWRKEY 1;             // Allume le module

//------------------------------------------------------------------------------
// Réglages du Timer 0 pour 1 seconde
  
T0CON         0x84;
  
TMR0H         0x0B;
  
TMR0L         0xDC;
  
TMR0IE_bit    0;       // TIMER 0 Non activé au départ
  
//------------------------------------------------------------------------------
  
UART1_Init(2400);      // Initialisation de l'UART
  
Delay_ms(100);
  
Sound_Init(&PORTC2);  // Initialisation du Sound
  
Delay_ms(100);

//------------------------------------------------------------------------------
// Réglages de l'interruption
  
RC1IE_bit 1;           // INT sur Rx UART activé
  
PEIE_bit  1;           // INT péripheriques Activé
  
GIE_bit   1;           // INT Global activé

//------------------------------------------------------------------------------
// Parametrages du débit
 
attente();
 
delay_ms(8000); // Configuration du baud-rate , ensuite initilisation du module

//------------------------------------------------------------------------------
// Parametrages du module
 
Envoi_Commande("ATE0");
 
Envoi_Commande("AT+CMGF=1");
 
Envoi_Commande("AT+QMGDA=\"DEL ALL\"");

//------------------------------------------------------------------------------
// 3 Bips pour signifier l'initialisation c'est bien passéee et finie
  
for (i=0;i<=2;i++){
      
Sound_Play(200050); // On joue un son
      
delay_ms(50);
   }

  
RAZ_SMS_Recu();

  
Valeur Ok Fin_SMS_recu Signal Flag_Mah CMTI =0;

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

   if (
CMTI)         // On a recu un nouveau message
      
{
         
CMTI 0;

         
//-----------------     On demande à le lire     ----------------------
         
UART1_Write_Text("AT+CMGL=\"REC UNREAD\"");
         
UART1_Write(13);
         
delay_ms(1000);
         
attente();
         
         
//-----------------    On efface les messages     ---------------------
         
Envoi_Commande("AT+QMGDA=\"DEL ALL\"");
         
attente();

        
//-------------    On met à jour le Gdh au premier SMS    --------------
        
if (Flag_Mah==0)
           {
              
Flag_Mah 1;   // Je léve le drapeau comme quoi j'ai mis a jour une fois
              
Gdh[8]=',';     // Je rajoute le caractere ',' pour correspondre au format attendu
              
UART1_Write_Text("AT+CCLK=\"");
              
UART1_Write_Text(Gdh);
              
UART1_Write_Text("\"\r");
              
attente();
            }

        
//-----------------    On recoit "CHRONO"    ---------------------------
        
if ( ((SMS_Recu[0]=='C')||(SMS_Recu[0]=='c')) && ((SMS_Recu[1]=='H')||(SMS_Recu[1]=='h')) && ((SMS_Recu[2]=='R')||(SMS_Recu[2]=='r')) )
             {

                 
Heures =  (((SMS_Recu[8])-48)*10)+(((SMS_Recu[9])-48));
                 
Val_Heures[0]= SMS_Recu[8] ;
                 
Val_Heures[1]= SMS_Recu[9] ;
                 
Val_Heures[2]= 0;

                 
Minutes =  (((SMS_Recu[12])-48)*10)+(((SMS_Recu[13])-48));
                 
Val_Minutes[0]= SMS_Recu[12] ;
                 
Val_Minutes[1]= SMS_Recu[13] ;
                 
Val_Minutes[2]= 0;

                 
Secondes =  (((SMS_Recu[16])-48)*10)+(((SMS_Recu[17])-48)) ;
                 
Val_Secondes[0]= SMS_Recu[16] ;
                 
Val_Secondes[1]= SMS_Recu[17] ;
                 
Val_Secondes[2]= 0;

               if (
Lancement)
                  {
                     
Message_a_envoyer(9);
                  }
               else if ( (
Heures>99) || (Minutes>59) || (Secondes>59) )
                  {
                    
Message_a_envoyer(97);
                  }
               else
                  {
                    
Chrono = (Heures*3600)+(Minutes*60)+Secondes ;
                    
Demande_Lancement 1;
                    
Message_a_envoyer(1);
                  }
             }
        
//--------------    On recoit "OUI" ou "xOui"    -----------------------
        
else if ( ((SMS_Recu[0]=='O')||(SMS_Recu[0]=='o')) && ((SMS_Recu[1]=='U')||(SMS_Recu[1]=='u')) && ((SMS_Recu[2]=='I')||(SMS_Recu[2]=='i')) || ((SMS_Recu[1]=='O')||(SMS_Recu[1]=='o')) && ((SMS_Recu[2]=='U')||(SMS_Recu[2]=='u')) && ((SMS_Recu[3]=='I')||(SMS_Recu[3]=='i')) )
             {
                if ( (
Demande_Lancement==1) || (Demande_Lancement_Reveil ==) )
                   {
                    
Demande_Lancement 0;
                    
Demande_Lancement_Reveil 0;
                    
Lancement 1;
                    
Message_a_envoyer(2);
                   }
                 else
                   {
                     
Message_a_envoyer(98);
                   }

             }
        
//------------------    On recoit "NON"    -----------------------------
        
else if ( ((SMS_Recu[0]=='N')||(SMS_Recu[0]=='n')) && ((SMS_Recu[1]=='o')||(SMS_Recu[1]=='O')) && ((SMS_Recu[2]=='N')||(SMS_Recu[2]=='n')) )
             {
                if ((
Demande_Lancement==1) || (Demande_Lancement_Reveil ==))
                   {
                      
Demande_Lancement 0;
                      
Demande_Lancement_Reveil 0;
                      
Message_a_envoyer(3);
                   }
                 else
                   {
                     
Message_a_envoyer(98);
                   }
             }
        
//-------------------    On recoit "ETAT"    ---------------------------
        
else if ( ((SMS_Recu[0]=='E')||(SMS_Recu[0]=='e')) && ((SMS_Recu[1]=='T')||(SMS_Recu[1]=='t')) && ((SMS_Recu[2]=='A')||(SMS_Recu[2]=='a')) )
            {
                
// On calcul le temps restant du chrono
                
ByteToStr( (Chrono/86400), Val_Jours_restant);
                
ByteToStr( (Chrono/3600), Val_Heures_restant);
                
ByteToStr( ((Chrono%3600)/60), Val_Minutes_restant);
                
ByteToStr( ((Chrono%3600)%60), Val_Secondes_restant);

                
// On demande la qualite du reseau
                
Envoi_Commande("AT+CSQ");
                
Signal =  100 - ((((Val_Signal[0]-48)*10) + ((Val_Signal[1]-48)))*2);
                
ShortToStr(SignalVal_Signal);

                
Message_a_envoyer(4);
            }
        
//-------------------    On recoit "STOP"    ---------------------------
        
else if ( ((SMS_Recu[0]=='S')||(SMS_Recu[0]=='s')) && ((SMS_Recu[1]=='T')||(SMS_Recu[1]=='t')) && ((SMS_Recu[2]=='O')||(SMS_Recu[2]=='o')) )
            {
              if (
Lancement)
                 {
                    
Lancement 0;        // RAZ du flag
                    
TMR0IE_bit 0;       // Arret du TIMER0
                    
Chrono 0;           // RAZ de la Valeur du Chrono

                    
Message_a_envoyer(5);
                 }
               else
                 {
                   
Message_a_envoyer(98);
                 }
            }
        
//-------------------    On recoit "AIDE"    ---------------------------
        
else if ( ((SMS_Recu[0]=='A')||(SMS_Recu[0]=='a')) && ((SMS_Recu[1]=='I')||(SMS_Recu[1]=='i')) && ((SMS_Recu[2]=='D')||(SMS_Recu[2]=='d')) )
           {
              
Message_a_envoyer(6);
           }
        
//-----------------    On recoit "REVEIL"    ---------------------------
        
else if ( ((SMS_Recu[0]=='R')||(SMS_Recu[0]=='r')) && ((SMS_Recu[1]=='E')||(SMS_Recu[1]=='e')) && ((SMS_Recu[2]=='V')||(SMS_Recu[2]=='v')) )
           {
              
// remplissage des structures
              
ts1.ss = (((Gdh[15])-48)*10)+(((Gdh[16])-48));
              
ts1.mn = (((Gdh[12])-48)*10)+(((Gdh[13])-48));
              
ts1.hh = (((Gdh[9])-48)*10)+(((Gdh[10])-48));
              
ts1.md = (((Gdh[6])-48)*10)+(((Gdh[7])-48));
              
ts1.mo = (((Gdh[3])-48)*10)+(((Gdh[4])-48));
              
ts1.yy 2000 + ((((Gdh[0])-48)*10)+(((Gdh[1])-48))) ;

              
ts2.ss = (((SMS_Recu[22])-48)*10)+(((SMS_Recu[23])-48)) ;
              
ts2.mn = (((SMS_Recu[19])-48)*10)+(((SMS_Recu[20])-48)) ;
              
ts2.hh = (((SMS_Recu[16])-48)*10)+(((SMS_Recu[17])-48)) ;
              
ts2.md = (((SMS_Recu[7])-48)*10)+(((SMS_Recu[8])-48)) ;
              
ts2.mo = (((SMS_Recu[10])-48)*10)+(((SMS_Recu[11])-48)) ;
              
ts2.yy 2000 + ((((SMS_Recu[13])-48)*10)+(((SMS_Recu[14])-48)))  ;

              
// calcul du temps
              
epoch1 =Time_dateToEpoch(&ts1) ;
              
epoch2 Time_dateToEpoch(&ts2) ;
              
diff epoch2 epoch1 ;
              
              if (
Lancement == 1)          // Si le Chrono est déjà lancé
                   
Message_a_envoyer(9);
              else if ( 
epoch2 <= epoch1)  // Le reveil est inferieur à la date actuelle
                   
Message_a_envoyer(10);
              else if ( 
diff 604800)     // Le reveil est supérieur à une semaine
                     
Message_a_envoyer(11);
              else
                  {
                    
Chrono diff ;
                    
Demande_Lancement_Reveil 1;
                    
Message_a_envoyer(7);
                  }
           }
        
//-----------------    On recoit "TEST"    ---------------------------
        
else if ( ((SMS_Recu[0]=='T')||(SMS_Recu[0]=='t')) && ((SMS_Recu[1]=='E')||(SMS_Recu[1]=='e')) && ((SMS_Recu[2]=='S')||(SMS_Recu[2]=='s')) )
           {
              
Message_a_envoyer(8);
           }
        
//-----------------    On recoit un mot inexistant dans le lexique  ---------------------------
        
else
           {
              
Message_a_envoyer(96);
           }
      }

//---------------------  Fin du Chrono detecté    ------------------------------
   
if (( Fin_Chrono) && (Lancement) ){

          
Fin_Chrono Lancement Chrono 0;   // RAZ variable
          
TMR0IE_bit 0;                        // On arrete le chrono
          
for (i=0;i<=5;i++){                    // On joue un son
             
Sound_Play(2000100);
             
delay_ms(50);
          }
         
Message_a_envoyer(99);  // Envoi du message "fin"
     
}
 }
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2229
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#73 Message par Jérémy » lun. 12 déc. 2016 22:14 lien vers la Data-Sheet : Cliquez ici

Bonsoir à tous ,

@Paul: avais-t fais des test avec la PIN PWRKEY pour diminuer la consommation ?

car je ne sais pas si je dois couper l'alimentation général du module , ou si seulement en désactivant le broche PWRKEY cela met le module en veille ?

Si il faut éteindre complétement le module je passerai par un MOSFET CANAL N je pense piloté par le PIC .
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1130
Âge : 68
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#74 Message par paulfjujo » mar. 13 déc. 2016 19:21 lien vers la Data-Sheet : Cliquez ici

bonsoir Jeremy,

Je me repenche sur le sujet .. pour te repondre demain!
Aides toi, le ciel ou Fantastpic t'aideras

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2229
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#75 Message par Jérémy » mar. 13 déc. 2016 20:18 lien vers la Data-Sheet : Cliquez ici

Re,

j'ai fais des tests cette pares midi ! déjà je n'ai pas réussis a mettre le module en veille avec la PIN PWRKEY . j'ai essayer dans tous les sens .
Impulsions haut et basse, courte et longues répétées etc ..... . Ils se mettait en sommeil et paf se réveille 1 seconde après tout seul !

j'ai donc essayer avec la commande prévue a cette effet . ça fonctionne ! mais la conso reste à 8mA (diode verte enlevée) .

Aux grands maux les grands remèdes . J'alimente mon module par un MOSFET piloté par le Pic . Ainsi je coupe complétement l'alim de mon module, et je le rallume quand j'ai ai besoin ! Le temps n'est pas critique.donc je peux l'alllumer 1 minutes toutes les 10 minutes par exemple pour vois si j'ai recu une demande de reveil ou un ordre !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1130
Âge : 68
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#76 Message par paulfjujo » ven. 16 déc. 2016 11:25 lien vers la Data-Sheet : Cliquez ici

bonjour Jeremy,



+1 Là, c'est une solution radicale ...

8mA ? comment mesures tu cette consommation ?
c'est celle du module GSM2_Click seul ?
module uniquement alimenté en 3,3V ?


Quid du mosfet utilisé pour commuter 3,3V sans trop de chute
et tension VGS <3,3V

¨Pour ma part, je n'ai pas utilisé la cde PWRKEY, mais la mise en sommeil par la pin DTR, qui au depart n'est pas accessible => modif hard sur le module GSM2
mais ma conso golobale , si alime,tée par la batterie 3,3V , est de 28mA minimum ( en sommeil) 45 à 50 mA reveillé
et pointe à 100mA en reception, pointe à >1A en emission..
(clikker 2 PIC18F98J50 inclus ( module GSM enfiché sur support mikroBus)
Aides toi, le ciel ou Fantastpic t'aideras

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2229
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#77 Message par Jérémy » dim. 18 déc. 2016 10:50 lien vers la Data-Sheet : Cliquez ici

paulfjujo a écrit :Source du message 8mA ? comment mesures tu cette consommation ?

De souvenir j'avais mis une R de 1ohm en série avec l'alim pour visualiser a l'oscillo ! toujours de souvenir car j’ai fais énormément de test c’était tout le circuit PIC+module GSM, avec le module GSM en veille ! mais toujours alimenter ( sans la led verte 11mA avec la led verte de présende de tension).

paulfjujo a écrit :Quid du mosfet utilisé pour commuter 3,3V sans trop de chute
et tension VGS <3,3V


Bien vu ! pour le moment ma plaque d'essai n'est pas très catholique, je n'avais pas de MOSFET compatible 3.3V., j'ai docn utilisé un que j'avai ssous la main avec un Vgs de 1V et un Rdson donné pour 10V . Comme c'est pour faire un interrupteur je me suis dis que ca ne gênait pas trop .
Je vais en commander d'autre plus adapter pour sortir mon schéma final . ( si quelqu'un peut m'en indiquer ce serait parfait en SOT-23)

Autre particularité, j'ai enlevé le régulateur sur le Module ! J'alimente directement par un élément Li-ion, la broche 3.3V et 5V . Voir le Fil Ici

C'est certainement du au régulateur ta forte consommation car moi je descend à 8mAen veille et en dessoudant la led verte !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2229
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#78 Message par Jérémy » ven. 23 déc. 2016 09:55 lien vers la Data-Sheet : Cliquez ici

Hello,

Bon mon programme arrive à sa fin je pense.

J'ai donc plein de mot pour "dialoguer avec mon module ! réglage et arrêt du chrono, ou du réveil . demande d'état du module, lexique d'aide, pause , mise en sommeil , réveil .
Pour l'alimentation, je pense que je vais mettre mon module à l’arrêt pendant 10 minutes, puis l'allumer une minute pour "checker" des messages. la conso sera ainsi vraiment réduite.

Voila ce que ca peut donner:

Code : Tout sélectionner

/*
 Test du module  GSM2 click pour FantasPic le 23/12/16
 * Description:
   Ce programme utilise le module GSM Quectel M95 pour envoyer et recevoir des SMS

 *configuration:
     MCU:             PIC16F1847 : http://ww1.microchip.com/downloads/en/DeviceDoc/41453B.pdf
     Carte:           prototype maison
     Oscillateur:     INTOSC 8.0000 MHz, PLL disable
     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:
   - Le clignotement de la led Rouge "NET" rapide pas de connexion , lentement Connexion
 */
 
#include "timelib.h"
#define PWRKEY RB3_bit
#define Alim RB5_bit
#define Bleu RA2_bit
#define Vert RA4_bit
#define Rouge RA3_bit
#define T_Off 60       // Temps d'extinction
#define T_On 60        // Temps de reveil

//##############################################################################
//##################    DECLARATION VARIABLES/CONSTANTES     ###################
//##############################################################################
char Gdh[30];
char SMS_Recu[50];
char Numero_tel[20];         // tableau pour placer le numéro de téléphone en string format : {"+336********"}
char Composition_numero[30];
char Val_Signal[7];
char Val_Heures[4];
char Val_Minutes[4];
char Val_Secondes[4];
char Val_Jours_restant[4];
char Val_Heures_restant[4];
char Val_Minutes_restant[4];
char Val_Secondes_restant[4];

unsigned char Jours_restant=0,  Heures=0, Minutes=0, Secondes=0, Signal=0, temp=0, Erreur=0, Chrono_temp=;
unsigned char Valeur=0, Ok=0, CMTI=0, CMGS=0, Fin_SMS_recu=0, Fleche=0;
unsigned char Demande_Lancement=0, Demande_Lancement_Reveil=0, Lancement=0, Fin_Chrono=0, Flag_Mah=0;
unsigned char Etat_module=0;

unsigned int i=0, j=0, Sablier=0, Sablier_S=0;

unsigned long Chrono=0, epoch1=0, epoch2=0, diff=0;

TimeStruct ts1, ts2 ;     // déclaration des structures pour le calcul du temps avec calendrier

//########################   PROTOTYPE DE FONCTION     #########################
void attente();
void RAZ_SMS_Recu();
void Message_a_envoyer(int);
void Envoi_Commande(const char);
void UART1_Write_CText(const code char);
void On_M95();
void Off_M95();
void UART1_Write_CText(const code char);

//########################     INTERRUPTION     ################################
void interrupt(){

  if ((TMR1IF_bit) && (TMR1IE_bit)) {   //  TIMER 1 interruption toute les 100 ms
      TMR1IF_bit = 0;       // RAZ Flag
      TMR1H      = 0x3C;    // Offset
      TMR1L      = 0xB0;

      Chrono_temp++;  // Incrementation toute les 100ms

      if (Chrono_temp >= 10){
          Chrono_temp = 0;
          Chrono--;
           if (Chrono==0)
              {
                Fin_Chrono = 1;
              }
        }
  }

 if ((TMR0IF_bit) && (TMR0IE_bit)) {
    TMR0IF_bit = 0;           // RAZ Flag
    TMR0       = 6;           // Offset
    Sablier++;                // Incrementation de Sablier toute les 1 ms
    if ( Sablier >= 1000){
       Sablier_S++;           // Incrementation de Sablier_S toute les 1 seconde
       Sablier = 0;
     }
  }

// Lecture des données dans le buffer UART par INT
  if (RCIF_bit == 1) {      // Si INT UART détecté

    temp = UART1_Read();      // On récupere et stock la donnée

    switch (Valeur){

           case 0:{
                    if (temp == 'O')         // "OK"
                        Valeur = 1;
                    else if (temp == 'C')    // "CMTI" ou "CMGS" ou "CSQ"
                         Valeur = 20;
                    else if (temp == '"')    // "N° de tel" ou "Gdh" ou "SM"
                         Valeur = 30;
                    else if (temp == '>')    // "Fleche"
                         Valeur = 50;
                    else if (temp == 'E')    // "ERROR"
                         Valeur = 100;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 1:{
                    if (temp == 'K')
                        Valeur = 2;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 2:{
                    if (temp == 13)
                        Valeur = 3;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 3:{
                    if (temp == 10)
                        Ok = 1;        // On a recu le mot "OK , on léve le drapeau
                    Valeur = 0;
                    break;
                  }
           case 20:{
                    if (temp == 'M')
                        Valeur = 21;
                    else if (temp == 'S')
                        Valeur = 25;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 21:{
                    if (temp == 'T')
                        Valeur = 22;
                    else if (temp == 'G')
                        Valeur = 23;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 22:{
                    if (temp == 'I')
                       {
                          CMTI = 1;     // On a recu "CMTI", on léve le drapeau
                          Valeur = 0;
                        }
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 23:{
                    if (temp == 'S')
                       {
                          CMGS = 1;     // On a recu "CMGS", on léve le drapeau
                          Valeur = 0;
                        }
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 25:{
                    if (temp == 'Q')
                          Valeur = 26;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 26:{
                    if (temp == ':')       // On a recu "CSQ" on enregistre la valeur
                          Valeur = 27;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 27:{
                    if (temp == ' ')
                          Valeur = 28;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 28:{
                    if (temp >= '0' && temp <= '9')
                       {
                         Val_Signal[0] = '0' ;
                         Val_Signal[1] = temp ;
                       }
                    Valeur = 29;
                    break;
                  }
           case 29:{
                    if (temp >= '0' && temp <= '9')
                       {
                         Val_Signal[0] = Val_Signal[1] ;
                         Val_Signal[1] = temp ;
                       }

                    Val_Signal[2] = 0;
                    Valeur = 0;
                    break;
                  }
           case 30:{
                    if (temp == '+')                // On enregistre le numéro de téléphones
                       {
                          Numero_tel[0] = temp;
                          i = 1;
                          Valeur = 31;
                        }
                     else if (temp == '2')          // On enregistre la date
                          Valeur = 40;
                     else
                        Valeur 
= 0;
                  };break;
           case 31:{
                     if (temp >= '0' && temp <= '9')
                        {
                          Numero_tel[i] = temp;
                          i++;
                        }
                     else if (temp == '"')
                        {
                          Numero_tel[i] = 0;
                          i = 0;
                          Valeur = 0;
                        }
                      else
                        
{
                          Numero_tel[0] = 0;
                          i=0;
                          Valeur = 0;
                        }
                  };break;
           case 40:{
                    if (temp == '0')
                        Valeur = 41;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 41:{
                    if (temp == '1')
                       {
                         Gdh[0] = temp;
                         i = 1;
                         Valeur = 42;
                       }
                    else
                        Valeur 
= 0;

                    break;
                  }
           case 42:{
                     if (temp != '"')
                        {
                          Gdh[i] = temp;
                          i++;
                        }
                     else
                        
{
                          Gdh[i] = 0;   // Je termine le Gdh par un "NULL" terminateur
                          i = 0;
                          Valeur = 43;
                        }
                     break;
                  }
           case 43:{
                    if (temp == 13)
                        Valeur = 44;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 44:{
                    if (temp == 10)
                       {
                         i=0;
                         SMS_Recu[0] = 0;
                         Valeur = 45;
                       }
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 45:{
                     if (temp != 10)
                        {
                          SMS_Recu[i] = temp;
                          i++;
                        }
                     else
                        
{
                          SMS_Recu[i] = 0;  // Je rajoute un terminateur "NULL"
                          i = 0;
                          Fin_SMS_recu = 1; // Je signale que j'ai fini d'enrregistrer le message
                          Valeur = 0;
                        }
                     break;
                  }
           case 50:{
                    if (temp == ' ')
                       Fleche = 1;   // Je léve le drapeau
                    Valeur = 0;
                    break;
                  }
           case 100:{
                    if (temp == 'R')
                        Valeur = 101;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 101:{
                    if (temp == 'R')
                        Valeur = 102;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 102:{
                    if (temp == 'O')
                        Valeur = 103;
                    else
                        Valeur 
= 0;
                    break;
                  }
           case 103:{
                    if (temp == 'R')
                        Erreur = 1;   // Je léve le drapeau
                        Valeur = 0;
                    break;
                  }

           default: valeur = 0;
    }
 }
}

//############################     FONCTION     ################################

// Fonction qui permet d'ecrire le texte en ROM plutot qu'en RAM    ------------
// Param. d'entré : le texte à afficher     ------------------------------------
void UART1_Write_CText(const code char *txt) {
   while (*txt)
      UART1_Write(*txt++);
}

// ---------------    FONCTION qui envoie des commandes   ----------------------
// Param. d'entré : la commande "AT" à envoyer   -------------------------------
void Envoi_Commande(const char *Commande){

    char i=0, j=0;   // variables Locales
    Ok=Erreur=0;     // variables Globales

    while(1){        // Boucle d'envoi de la commande
         
         while
(*Commande) {             // Boucle pour balayer le texte à envoyer jusqu'au "NULL"
             UART1_Write(*Commande++);
           }
           UART1_Write(13);              // On envoie un CR aprés la fin du texte pour valider

         while ((Ok==0) && (Erreur==0)) // Je rentre dans une boucle pour attendre la reponse "Ok"
          {
             delay_ms(50);
             i++;
             if (i>60)                  // Au bout de 60 tentatives je sors pour re-envoyer la commande
                {
                   j++;
                   if (j>=3) Ok=1;     // Au bout de 3 boucles de 20 tentatives je sors de la fonction
                   i=0;
                 }
           }
         if ((Ok) || (Erreur)) break;   // Si j'ai recu "Ok" ou "erreur" , je sors
     }
     Ok=Erreur=0;
     attente();
 }
 
// ---------------    FONCTION qui envoie les messages -------------------------
// Param. d'entrée : le numéro de la réponse à envoyer -------------------------
void Message_a_envoyer(int reponse_a_envoyer){

   char i=0, j=0, k=0;
   
   do
{                     // Tant que la réponse n'a pas ete envoyer je re-boucle
       delay_ms(200);
       k++;
       // --------------------  Compose le numéro de téléphone  -----------------------
       // Fonction qui compose le numéro de téléphone jusqu'a que la Fleche,signifiant l'attente du message, apparaisse
       do{
           i++;
           Composition_numero[0]=0;                  // Je me place en début de chaine
           strcat(Composition_numero, "AT+CMGS=\""); // rajoute la commande d'envoi de message(CMGS) et on ouvre les guillemets
           strcat(Composition_numero, Numero_tel);   // On rajoute(colle) le numéro de tel, Ex: "AT+CMGS=06******xx\""
           strcat(Composition_numero, "\"");         // et on ferme les guillemets
           strcat(Composition_numero, 0);            // On finit par un terminateur de string "NULL"
           UART1_Write_Text(Composition_numero);     // On envoie le numero
           UART1_Write(13);

           for (j=0;j<=100;j++){           // J'attends la fleche
                delay_ms(50);
                if (Fleche) break;
            }
            if (i>3) break;              // Au bout de trois tentatives j'arrete

         }while (Fleche==0);             // Je sors aprés avoir recu la petite fleche
      
      delay_ms
(1000);

      Fleche = 0;

      //-------------- Selection du message à envoyer    -----------------------
      switch (reponse_a_envoyer){

             case 1:{
                       UART1_Write_CText("Valeurs recues:\r\n");
                       UART1_Write_CText(Val_Heures);
                       UART1_Write_CText("h : ");
                       UART1_Write_CText(Val_Minutes);
                       UART1_Write_CText("m : ");
                       UART1_Write_CText(Val_Secondes);
                       UART1_Write_CText("s\r\n");
                       UART1_Write_CText("Voulez-vous le lancer ?");
                       break;
                     }
             case 2:{
                       TMR1IE_bit = 1; // On lance le chrono
                       UART1_Write_CText("Le chrono est lancé !");
                       break;
                     }
             case 3:{
                       UART1_Write_CText("Abandon de l'initialisation");
                       break;
                     }
             case 4:{
                       UART1_Write_CText("Etat du module:\r\n");
                       UART1_Write_CText("Date: ");  // On écrit la date
                       UART1_Write(Gdh[6]);
                       UART1_Write(Gdh[7]);
                       UART1_Write_CText("/");
                       UART1_Write(Gdh[3]);
                       UART1_Write(Gdh[4]);
                       UART1_Write_CText("/");
                       UART1_Write(Gdh[0]);
                       UART1_Write(Gdh[1]);
                       UART1_Write_CText("\r\n");
                       UART1_Write_CText("Heure:  ");  // On écrit l'heure
                       for (i=9;i<17;i++)
                           {
                             if ( (Gdh[i]<58) && Gdh[i]>47 )
                                UART1_Write(Gdh[i]);
                              else
                                UART1_Write_CText
(":");
                           }
                       UART1_Write_CText("\r\n");
                       UART1_Write_CText("Force du signal :"); // On écrit la force du signal
                       UART1_Write_CText(Val_Signal);
                       UART1_Write_CText("%\r\n");
                       
                       UART1_Write_CText
("On-Off auto :");
                       if (TMR0IE_bit)
                          {
                             UART1_Write_CText("Activé");
                          }
                           else
                           
{
                             UART1_Write_CText("Désactivé");
                           }
                       UART1_Write_CText("\r\n");

                       if (Lancement==1)       // Le temps qu'il reste
                          {
                            UART1_Write_CText("Lancé : OUI\r\n");
                            UART1_Write_CText("Temps restant :\r\n");
                            if ( Jours_restant != 0)
                               {
                                 UART1_Write_CText(Val_Jours_restant);
                                 UART1_Write_CText("j");
                               }
                            UART1_Write_CText(Val_Heures_restant);
                            UART1_Write_CText("h");
                            UART1_Write_CText(Val_Minutes_restant);
                            UART1_Write_CText("m");
                            UART1_Write_CText(Val_Secondes_restant);
                            UART1_Write_CText("s");
                           }
                       else
                          
{
                            UART1_Write_CText("Lancé : NON");
                          }
                       break;
                     }
             case 5:{
                       UART1_Write_CText("Arret du chrono");
                       break;
                     }
             case 6:{
                       UART1_Write_CText("LES MOTS CLES SONT:\r\nStop\r\nOui\r\nNon\r\nEtat\r\nWakeup\r\nSommeil\r\nChrono Hxx Mxx Sxx\r\nReveil jj/mm/aa hh/mm/ss");
                       break;
                     }
             case 7:{
                       UART1_Write_CText("Réveil reglé\r\n");
                       UART1_Write_CText("le : "); // écrit la date du reveil
                       UART1_Write(SMS_Recu[7]);
                       UART1_Write(SMS_Recu[8]);
                       UART1_Write_CText("\/");
                       UART1_Write(SMS_Recu[10]);
                       UART1_Write(SMS_Recu[11]);
                       UART1_Write_CText("\/");
                       UART1_Write(SMS_Recu[13]);
                       UART1_Write(SMS_Recu[14]);
                       UART1_Write_CText("\r\n");
                       UART1_Write_CText("a  : ");  // écrit l'heure du reveil
                       for (i=16;i<24;i++)
                           {
                             UART1_Write(SMS_Recu[i]);
                           }
                           i=0;
                       UART1_Write_CText("\r\nVoulez-vous le lancer ?");
                       break;
                     }
             case 8:{
                       UART1_Write_CText("Test\r\n");
                       Gdh[8]=',';
                       UART1_Write_CText(Gdh);
                       break;
                     }
             case 9:{
                       UART1_Write_CText("Le Chrono est déja lancé.\r\n");
                       UART1_Write_CText("Utilisez le mot \"STOP\" pour l'arreter");
                       break;
                     }
             case 10:{
                       UART1_Write_CText("La Valeur du réveil est anterieur a l\'heure actuelle");
                       break;
                     }
             case 11:{
                       UART1_Write_CText("La date reveil est supérieur a 30 jours");
                       break;
                     }
             case 12:{
                       UART_Write_Text("Je suis réveillé !\r\n Les arrets et reveils automatiques sont désactivés");
                       break;
                     }
             case 13:{
                       UART_Write_Text("Je passe en veille");
                       break;
                     }
             case 14:{
                       UART_Write_Text("Arrets et reveils automatiques activés");
                       break;
                     }
             case 96:{
                       UART1_Write_CText("Erreur, mot inconnu!.");
                       break;
                     }
             case 97:{
                       UART1_Write_CText("Erreur, les valeurs ne sont pas correctes\r\nHeures<100\r\nMinutes<60\r\nsecondes<60");
                       break;
                     }
             case 98:{
                       UART1_Write_CText("Erreur, ce mot ne convient pas ici !");
                       break;
                     }
             case 99:{
                       UART1_Write_CText("Fin");
                       break;
                     }
         }
        UART1_Write(0x1A);     // Envoi cu CTRL+Z pour envoyer le message

        for (j=0;j<=150;j++){   // je reste la pendant au moins 7 Secondes à attendre le mot "CMGS"
              delay_ms(50);
              if (CMGS) break;
          }
          
        if 
(k>3) break;    // 3 tentatives d'envoi je sors

     } while (CMGS == 0);  // Si je n'ai pas recu "CMGS" je re-boucle

   CMGS = 0;

              for (i=0;i<=5;i++){      // A supprimer apres les tests
                Bleu = ~Bleu;
                delay_ms(100);
               }
       
   RAZ_SMS_Recu
();    // On efface le buffer du SMS recu
   attente();
}

// -------------------      boucle d'attente       -----------------------------
// Elle permet de mettre le module dans une position connue
void attente(){
    char i = 0;
    Ok = 0;
    do {         // Ici on envoie la commande "AT" tant que le Flag "Ok" n'est pas levé
          i++;
          UART1_Write_Text("AT\r");
          delay_ms(50);
          if (i>=100) asm reset;        // Au bout de 100 tentatives on RESET
        } while(Ok == 0);
    Ok = i = 0;
    delay_ms(100);
 }
 
// --------------------------  EFFACE le SMS recu  -----------------------------
// Fait une boucle pour remplir le tableau du SMS par des NULL
void RAZ_SMS_Recu(){
    char i=0;
    RCIE_bit = 0;
    for (i=0;i<=50;i++){  // On efface le tableau contenant le SMS recu .
        SMS_Recu[i] = 0;
     }
    SMS_Recu[0] = 0;     // On se place en début de tableau
    RCIE_bit = 1;
 }


//##############################################################################
//############################     MAIN     ####################################
//##############################################################################
void main(){

  ANSELA = ANSELB = 0;  // Tous les PORT en Digital
  TRISB = 0b00000010;   // RB1 en entrée
  TRISA = 0 ;           // En sortie
  PORTA = 0;
  PORTB = 0;

  OSCCON =  0b01110110 ; // Pll disable; Freq=8Mhz; OSC:intern

//------------------------------------------------------------------------------
// Réglages du Timer 1 pour 100 ms
  TMR1IE_bit = 0;    // désactiver ua départ
  T1CON      = 0x21;
  TMR1IF_bit = 0;
  TMR1H      = 0x3C;
  TMR1L      = 0xB0;

//------------------------------------------------------------------------------
// Réglages du Timer 0 pour 1 ms
  TMR0IE_bit = 0;    // désactiver au départ
  OPTION_REG = 0x82; // Presacler 1:8
  TMR0       = 6;    // Offset
  TMR0IF_bit = 0;

//------------------------------------------------------------------------------
// INTCON  =  Réglages des interruptions
  RCIE_bit = 1;            // INT sur Rx UART activé
  PEIE_bit  = 1;           // INT péripheriques Activé
  GIE_bit   = 1;           // INT Global activé

//------------------------------------------------------------------------------
  UART1_Init(9600);   // Initialisation de l'UART
  Delay_ms(100);

//------------------------------------------------------------------------------

  On_M95();         //On allume le module

  TMR0IE_bit = 1;   // Je lance le Sablier apres avoir recu le premier message

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

   
   if 
((Sablier_S >= T_On) && ( Etat_module == 1) ){        // Test de mise en pause
       Sablier_S = 0;
       Off_M95();
    }
    else if ((Sablier_S >= T_Off) && ( Etat_module==0) ){   // Test de réveil
       Sablier_S = 0;
       On_M95();
    }

   if (CMTI)         // Si le drapeau s'est levé, on a recu un nouveau message
      {
         CMTI = 0;      // RAZ du drapeau
         Sablier_S = 0; // RAZ du Sablier si on recoit un message

         for (i=0;i<=5;i++){
             Rouge = ~Rouge;
             delay_ms(100);
           }

         //-----------    On lit le message pour enregistrer     ---------------
         Envoi_Commande("AT+CMGL=\"REC UNREAD\"");

         //--------------    On efface TOUS les messages     -------------------
         Envoi_Commande("AT+QMGDA=\"DEL ALL\"");

        //-------------    On met à jour le Gdh au premier SMS    --------------
        if (Flag_Mah==0)
           {
              Flag_Mah = 1;   // Je léve le drapeau pour signaler que la MAJ à été faite
              Gdh[8]=',';     // Je rajoute le caractere ',' pour correspondre au format attendu
              UART1_Write_Text("AT+CCLK=\"");
              UART1_Write_Text(Gdh);
              UART1_Write_Text("\"\r");
              attente();
            }

        //-----------------    On recoit "CHRONO"    ---------------------------
        if ( ((SMS_Recu[0]=='C')||(SMS_Recu[0]=='c')) && ((SMS_Recu[1]=='H')||(SMS_Recu[1]=='h')) && ((SMS_Recu[2]=='R')||(SMS_Recu[2]=='r')) )
             {
                 Heures =  (((SMS_Recu[8])-48)*10)+(((SMS_Recu[9])-48));
                 Val_Heures[0]= SMS_Recu[8] ;
                 Val_Heures[1]= SMS_Recu[9] ;
                 Val_Heures[2]= 0;

                 Minutes =  (((SMS_Recu[12])-48)*10)+(((SMS_Recu[13])-48));
                 Val_Minutes[0]= SMS_Recu[12] ;
                 Val_Minutes[1]= SMS_Recu[13] ;
                 Val_Minutes[2]= 0;

                 Secondes =  (((SMS_Recu[16])-48)*10)+(((SMS_Recu[17])-48)) ;
                 Val_Secondes[0]= SMS_Recu[16] ;
                 Val_Secondes[1]= SMS_Recu[17] ;
                 Val_Secondes[2]= 0;

               if (Lancement)
                  {
                     Message_a_envoyer(9);
                  }
               else if ( (Heures>99) || (Minutes>59) || (Secondes>59) )
                  {
                    Message_a_envoyer(97);
                  }
               else
                  
{
                    Chrono = (Heures*3600)+(Minutes*60)+Secondes ;
                    Demande_Lancement = 1;
                    Message_a_envoyer(1);
                  }
             }
        //----------------------    On recoit "OUI"    -------------------------
        else if ( ((SMS_Recu[0]=='O')||(SMS_Recu[0]=='o')) && ((SMS_Recu[1]=='U')||(SMS_Recu[1]=='u')) && ((SMS_Recu[2]=='I')||(SMS_Recu[2]=='i'))  )
             {
                if ( (Demande_Lancement==1) || (Demande_Lancement_Reveil ==) )
                   {
                     Demande_Lancement = Demande_Lancement_Reveil = 0;
                     Lancement = 1;
                     Message_a_envoyer(2);
                   }
                 else
                   
{
                     Message_a_envoyer(98);
                   }
             }

        //--------------------    On recoit "NON"    ---------------------------
        else if ( ((SMS_Recu[0]=='N')||(SMS_Recu[0]=='n')) && ((SMS_Recu[1]=='o')||(SMS_Recu[1]=='O')) && ((SMS_Recu[2]=='N')||(SMS_Recu[2]=='n')) )
             {
                if ((Demande_Lancement==1) || (Demande_Lancement_Reveil ==))
                   {
                     Demande_Lancement = Demande_Lancement_Reveil = 0;
                     Message_a_envoyer(3);
                   }
                 else
                   
{
                     Message_a_envoyer(98);
                   }
             }
        //-------------------    On recoit "ETAT"    ---------------------------
        else if ( ((SMS_Recu[0]=='E')||(SMS_Recu[0]=='e')) && ((SMS_Recu[1]=='T')||(SMS_Recu[1]=='t')) && ((SMS_Recu[2]=='A')||(SMS_Recu[2]=='a')) )
            {
                // On calcul le temps restant du chrono
                ByteToStr( (Chrono/86400), Val_Jours_restant);
                ByteToStr( (Chrono/3600), Val_Heures_restant);
                ByteToStr( ((Chrono%3600)/60), Val_Minutes_restant);
                ByteToStr( ((Chrono%3600)%60), Val_Secondes_restant);

                // On demande la qualite du reseau
                Envoi_Commande("AT+CSQ");
                Signal =  100 - ((((Val_Signal[0]-48)*10) + ((Val_Signal[1]-48)))*2);
                ShortToStr(Signal, Val_Signal);

                Message_a_envoyer(4);
            }
        //-------------------    On recoit "STOP"    ---------------------------
        else if ( ((SMS_Recu[0]=='S')||(SMS_Recu[0]=='s')) && ((SMS_Recu[1]=='T')||(SMS_Recu[1]=='t')) && ((SMS_Recu[2]=='O')||(SMS_Recu[2]=='o')) )
            {
              if (Lancement)
                 {
                    Lancement = 0;        // RAZ du flag
                    TMR1IE_bit = 0;       // Arret du TIMER1
                    Chrono = 0;           // RAZ de la Valeur du Chrono

                    Message_a_envoyer(5);
                 }
               else
                 
{
                   Message_a_envoyer(98);
                 }
            }
        //-------------------    On recoit "Wake-up"    ---------------------------
        else if ( ((SMS_Recu[0]=='W')||(SMS_Recu[0]=='w')) && ((SMS_Recu[1]=='A')||(SMS_Recu[1]=='a')) && ((SMS_Recu[2]=='K')||(SMS_Recu[2]=='k')) )
            {
              On_M95();
              delay_ms(1000);
              TMR0IE_bit = 0;        // On stop les arrets/reveils automatiques
              Message_a_envoyer(12);
            }
        //-------------------    On recoit "Sommeil"    ---------------------------
        else if ( ((SMS_Recu[0]=='S')||(SMS_Recu[0]=='s')) && ((SMS_Recu[1]=='O')||(SMS_Recu[1]=='o')) && ((SMS_Recu[2]=='M')||(SMS_Recu[2]=='m')) )
            {
              TMR0IE_bit = 1;        // On autorise les arrets/reveils automatiques
              Message_a_envoyer(14);
              Off_M95();             // On met à l'arret
            }
        //-------------------    On recoit "AIDE"    ---------------------------
        else if ( ((SMS_Recu[0]=='A')||(SMS_Recu[0]=='a')) && ((SMS_Recu[1]=='I')||(SMS_Recu[1]=='i')) && ((SMS_Recu[2]=='D')||(SMS_Recu[2]=='d')) )
           {
              Message_a_envoyer(6);
           }
        //-----------------    On recoit "REVEIL"    ---------------------------
        else if ( ((SMS_Recu[0]=='R')||(SMS_Recu[0]=='r')) && ((SMS_Recu[1]=='E')||(SMS_Recu[1]=='e')) && ((SMS_Recu[2]=='V')||(SMS_Recu[2]=='v')) )
           {
              // remplissage des structures
              ts1.ss = (((Gdh[15])-48)*10)+(((Gdh[16])-48));
              ts1.mn = (((Gdh[12])-48)*10)+(((Gdh[13])-48));
              ts1.hh = (((Gdh[9])-48)*10)+(((Gdh[10])-48));
              ts1.md = (((Gdh[6])-48)*10)+(((Gdh[7])-48));
              ts1.mo = (((Gdh[3])-48)*10)+(((Gdh[4])-48));
              ts1.yy = 2000 + ((((Gdh[0])-48)*10)+(((Gdh[1])-48))) ;

              ts2.ss = (((SMS_Recu[22])-48)*10)+(((SMS_Recu[23])-48)) ;
              ts2.mn = (((SMS_Recu[19])-48)*10)+(((SMS_Recu[20])-48)) ;
              ts2.hh = (((SMS_Recu[16])-48)*10)+(((SMS_Recu[17])-48)) ;
              ts2.md = (((SMS_Recu[7])-48)*10)+(((SMS_Recu[8])-48)) ;
              ts2.mo = (((SMS_Recu[10])-48)*10)+(((SMS_Recu[11])-48)) ;
              ts2.yy = 2000 + ((((SMS_Recu[13])-48)*10)+(((SMS_Recu[14])-48)))  ;

              // calcul du temps
              epoch1 =Time_dateToEpoch(&ts1) ;
              epoch2 = Time_dateToEpoch(&ts2) ;
              diff = epoch2 - epoch1 ;
              
              if 
(Lancement == 1)          // Si le Chrono est déjà lancé
                   Message_a_envoyer(9);
              else if ( epoch2 <= epoch1)  // Le reveil est inferieur à la date actuelle
                   Message_a_envoyer(10);
              else if ( diff > 2592000)     // Le reveil est supérieur à 30 jours
                     Message_a_envoyer(11);
              else
                  
{
                    Chrono = diff ;
                    Demande_Lancement_Reveil = 1;
                    Message_a_envoyer(7);
                  }
           }
        //-----------------    On recoit "TEST"    ---------------------------
        else if ( ((SMS_Recu[0]=='T')||(SMS_Recu[0]=='t')) && ((SMS_Recu[1]=='E')||(SMS_Recu[1]=='e')) && ((SMS_Recu[2]=='S')||(SMS_Recu[2]=='s')) )
           {
              Message_a_envoyer(8);
           }
        //-----------------    On recoit un mot inexistant dans le lexique  ---------------------------
        else
           
{
              Message_a_envoyer(96);
           }
      }

//---------------------  Fin du Chrono detecté    ------------------------------
   if (( Fin_Chrono) && (Lancement) ){

          char i;
          Fin_Chrono = Lancement = Chrono = 0;   // RAZ variable
          TMR1IE_bit = 0;                        // On arrete le chrono
          for ( i=0; i<10; i++){
              Vert = ~Vert;
              Rouge = ~Rouge;
              Bleu = ~Bleu;
              delay_ms(300);
           }

         Message_a_envoyer(99);  // Envoi du message "fin"
     }
 }
}


//-----------------   FONCTION ALLUMAGE DU MODULE     --------------------------
void On_M95(){
  Alim = 1;       // Activation de l'alimentation par le MOSFET
  delay_ms(100);  // Pause pour stabiliser la tension
  PWRKEY = 0;     // Mise à zéro
  delay_ms(2500); // Maintenir à 0 pendant plus de 2S
  PWRKEY = 1;     // Allume le module
  Etat_module = 1;

   // Parametrages du débit
  attente();
  delay_ms(8000); // Configuration du baud-rate , ensuite initilisation du module

  // Parametrages du module
  Envoi_Commande("ATE0");                 // Pas d'Echo
  Envoi_Commande("AT+CMGF=1");            // Mode texte
  Envoi_Commande("AT+QMGDA=\"DEL ALL\""); // efface tous les messages

  RAZ_SMS_Recu();                         // Vide le buffer du SMS recu

  i = j = Valeur = Ok = Fin_SMS_recu = Signal = Flag_Mah = CMTI = 0 ;   // RAZ des variables
  Sablier_S = Sablier = Chrono = 0;
  
  Rouge 
= Vert = Bleu = 1;
  delay_ms(1000);
  Rouge = Vert = Bleu = 0;
}

//-----------------   FONCTION EXTINCTION DU MODULE     --------------------------
//------------------------------------------------------------------------------
void Off_M95(){
  if (Flag_Mah) Message_a_envoyer(13);   // Si j'ai recu un numero d'enregistrer je signale mon passage en veille
  Envoi_Commande("AT+QPOWD=1");
  delay_ms(200);
  Alim = 0;
  Etat_module = 0;
}


Si vous me comprenez et avez le courage de le lire, merci de m'indiquer si vous voyez des erreurs ou des améliorations à apportées
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1130
Âge : 68
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#79 Message par paulfjujo » ven. 23 déc. 2016 13:55 lien vers la Data-Sheet : Cliquez ici

bonjour Jeremy,

tu n'aurais pas des WARNINGS au sujet de ce bout de code ?
Utiliser UART1_Write_Text(Val_Heure); car Val_Heures est une variable en RAM et non en ROM

Au niveau Hardw utilise tu le GSM2_click modifié (Sans le Regulateur)
et avec le MOSFET pour alimenter le module ? est-ce concluant avec les appels de courant en emission SMS ?


Code : Tout sélectionner


   
case 1:{
                       
UART1_Write_CText("Valeurs recues:\r\n");
                       
UART1_Write_CText(Val_Heures);
                       
UART1_Write_CText("h : ");
                       
UART1_Write_CText(Val_Minutes);
                       
UART1_Write_CText("m : ");
                       
UART1_Write_CText(Val_Secondes);
                       
UART1_Write_CText("s\r\n");
                       
UART1_Write_CText("Voulez-vous le lancer ?");
                       break;
                     }
 


à +
Aides toi, le ciel ou Fantastpic t'aideras

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2229
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#80 Message par Jérémy » ven. 23 déc. 2016 14:29 lien vers la Data-Sheet : Cliquez ici

Bonjour paul,

Non aucun warnings ! Mais tu as l’œil très avertis , franchement bravo !

Au niveau Hardw utilise tu le GSM2_click modifié (Sans le Regulateur)

Oui tout a fait !

J'ai effectivement enlever le régulateur, j'ai straper ma batterie sur le 5V et la sortie du régulateur et le 3V3 ; ainsi ma batterie alimente tout !

Ensuite j’amène mon alimentation via un MOSFET piloter par le PIC, pour le moment canal N car j'en 'ai pas de quoi faire les modifs à la maison( mais ça fonctionne quand même).
est-ce concluant avec les appels de courant en emission SMS ?

Très ! je n'ai aucun bug à déclarer !

Pour être honnête depuis que j'ai fait ma petite plaque prototype, ça fonctionne à merveille ! je pense que ma carte EasyPic me dérangeait quelques part ( surtout sur l'UART). depuis que j'ai mon proto impeccable !
C'est en faisant des erreurs, que l'on apprend le mieux !!!


Retourner vers « Langage C »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 1 invité