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 ---
- 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 ---
Modérateur : Jérémy
Module GSM2-Click
Module GSM2-Click
-
Jérémy
Administrateur du site- Messages : 2731
- Âge : 45
- Enregistré en : juillet 2015
- Localisation : Dans le sud
- Contact :
Bonjour à tous,
Je continue toujours sur mon module !
Premier point la partie Hard est bonne , plus de reset au démarrage, je pense maintenant qu'il y avait un problème HARD mais aussi SOFT ! en tout cas merci à tous !
j'ai donc tout repris depuis zéro, en avançant à tâtons! Pour le moment je n'ai aucun loupé et une liaison à 100% opérationnelle.
Cependant j'entrevois des "améliorations" ou des futurs bogues à venir .
A l'heure actuelle, dans un boucle infinie , je demande à mon module ( toutes les 3 secondes) si il a un message "lu" ou "non lu" . cette demande m'affiche tous les messages "lus" et "non lus" si il y en a bien sur .
Mais je trouve cela pas très optimisé, car il se peut que pendant ces trois secondes je reçoive 2 messages ! et la ,les deux messages seront traités en même temps , et ça , ben c'est pas bon du tout !
Pour palier à ce problème je compte demander à lire seulement le premier message en mémoire ! ( en imaginant que j'en reçoive deux à la suite), je le traite puis je l'efface !
Ma question est : est ce que le second message va venir en emplacement mémoire 1 après l'effacement du #1, ou restera-t-il en #2 ?
J'ouvre la DS du module en page 98 , mais mon anglais me joue des tours et la traduction google n'ai pas claire du tout sur le comportement d'un effacement d'un message .
Une âme charitable pourrait-elle me dire la quelle est la bonne solution a adopté pour ce cas de figure , il y à 5 options possibles ?
Merci à vous !
Je continue toujours sur mon module !
Premier point la partie Hard est bonne , plus de reset au démarrage, je pense maintenant qu'il y avait un problème HARD mais aussi SOFT ! en tout cas merci à tous !
j'ai donc tout repris depuis zéro, en avançant à tâtons! Pour le moment je n'ai aucun loupé et une liaison à 100% opérationnelle.
Cependant j'entrevois des "améliorations" ou des futurs bogues à venir .
A l'heure actuelle, dans un boucle infinie , je demande à mon module ( toutes les 3 secondes) si il a un message "lu" ou "non lu" . cette demande m'affiche tous les messages "lus" et "non lus" si il y en a bien sur .
Mais je trouve cela pas très optimisé, car il se peut que pendant ces trois secondes je reçoive 2 messages ! et la ,les deux messages seront traités en même temps , et ça , ben c'est pas bon du tout !
Pour palier à ce problème je compte demander à lire seulement le premier message en mémoire ! ( en imaginant que j'en reçoive deux à la suite), je le traite puis je l'efface !
Ma question est : est ce que le second message va venir en emplacement mémoire 1 après l'effacement du #1, ou restera-t-il en #2 ?
J'ouvre la DS du module en page 98 , mais mon anglais me joue des tours et la traduction google n'ai pas claire du tout sur le comportement d'un effacement d'un message .
Une âme charitable pourrait-elle me dire la quelle est la bonne solution a adopté pour ce cas de figure , il y à 5 options possibles ?
Merci à vous !
Module GSM2-Click
Module GSM2-Click
-
Jérémy
Administrateur du site- Messages : 2731
- Âge : 45
- Enregistré en : juillet 2015
- Localisation : Dans le sud
- Contact :
Bonjour à tous,
Après moultes Tests , sans résultats probants , j'ai donc opté pour le test des trois messages .
Si j'ai un message en #1 je le traite -> je sors . Si je n'en ai pas, je vais regarder en #2 , si y'en a un en #2 je le traite et je sors , si y'en a pas je vais regarder en #3 , je le traite et j'efface tout les messages !
Ceci est juste un pare-feu, car la personne est censée attendre la réponse du GSM à chaque fois !
Une âme charitable pourrait-elle me dire la quelle est la bonne solution a adopté pour ce cas de figure , il y à 5 options possibles ?
Après moultes Tests , sans résultats probants , j'ai donc opté pour le test des trois messages .
Si j'ai un message en #1 je le traite -> je sors . Si je n'en ai pas, je vais regarder en #2 , si y'en a un en #2 je le traite et je sors , si y'en a pas je vais regarder en #3 , je le traite et j'efface tout les messages !
Ceci est juste un pare-feu, car la personne est censée attendre la réponse du GSM à chaque fois !
Module GSM2-Click
-
Jérémy
Administrateur du site- Messages : 2731
- Âge : 45
- Enregistré en : juillet 2015
- Localisation : Dans le sud
- Contact :
Bonjour à tous,
Mon tout dernier soucis avec ce module GSM !!
Il s'agit d'une énigme pour moi .
Je calcul la valeur de mon chrono en seconde ! jusque la rien de particulier !
pour afficher le temps restant je dois donc convertir ces secondes en string formaté comme suit : jj hh mm ss . rien de bizarre !
Pour ce faire j'utilise cette portion de code ! que je vous ai simplifié : je force la valeur Chrono à 86466 , ce qui correspond à
1 jour , 0h , 1 minute et 6 secondes
On s'attend donc à ce que j'obtiens : 1j 0h 1m 6s
A votre avis quel est le résultat ???
Je suppute un probléme de conversion encore
Mon tout dernier soucis avec ce module GSM !!
Il s'agit d'une énigme pour moi .
Je calcul la valeur de mon chrono en seconde ! jusque la rien de particulier !
pour afficher le temps restant je dois donc convertir ces secondes en string formaté comme suit : jj hh mm ss . rien de bizarre !
Pour ce faire j'utilise cette portion de code ! que je vous ai simplifié : je force la valeur Chrono à 86466 , ce qui correspond à
1 jour , 0h , 1 minute et 6 secondes
On s'attend donc à ce que j'obtiens : 1j 0h 1m 6s
Code : Tout sélectionner
Chrono = 86466 ;
LongWordToStr (Chrono, temp);
strConstRamCpy(T_message+57, temp); //
strConstRamCpy(T_message+67, "\r\n..j ..h ..m ..s");
// Calcul des Jours restants
ByteToStr ( (unsigned char)(Chrono/86400), temp);
T_message[69] = temp[1];
T_message[70] = temp[2];
// Calcul des Heures restantes
ByteToStr ( (unsigned char)((Chrono%86400)/3600), temp);
T_message[73] = temp[1];
T_message[74] = temp[2];
// Calcul des Minutes restantes
ByteToStr ((unsigned char)(((Chrono%84600)%3600)/60), temp);
T_message[77] = temp[1];
T_message[78] = temp[2];
// Calcul des Secondes restantes
ByteToStr ((unsigned char)(((Chrono%84600)%3600)%60), temp);
T_message[81] = temp[1];
T_message[82] = temp[2];
A votre avis quel est le résultat ???
► Afficher le résultat
Je suppute un probléme de conversion encore
Module GSM2-Click
-
Jérémy
Administrateur du site- Messages : 2731
- Âge : 45
- Enregistré en : juillet 2015
- Localisation : Dans le sud
- Contact :
Quel boulet encore !!!!
Forcement avec les mauvaises valeurs ca ne peut pas fonctionner !
je crois que j'ai fini !!!!!!!
Fiabilité à 100% ( pour le moment) Je ne suis pas très content de ma gestion des réceptions de messages! je pense qu'on peut mieux faire mais bon , ça fait trop de temps que je suis al dessus et je commence à saturer !
Chrono = 86466 ;
LongWordToStr (Chrono, temp);
strConstRamCpy(T_message+57, temp); //
strConstRamCpy(T_message+67, "\r\n..j ..h ..m ..s");
// Calcul des Jours restants
ByteToStr ( (unsigned char)(Chrono/86400), temp);
T_message[69] = temp[1];
T_message[70] = temp[2];
// Calcul des Heures restantes
ByteToStr ( (unsigned char)((Chrono%86400)/3600), temp);
T_message[73] = temp[1];
T_message[74] = temp[2];
// Calcul des Minutes restantes
ByteToStr ((unsigned char)(((Chrono%84600)%3600)/60), temp);
T_message[77] = temp[1];
T_message[78] = temp[2];
// Calcul des Secondes restantes
ByteToStr ((unsigned char)(((Chrono%84600)%3600)%60), temp);
T_message[81] = temp[1];
T_message[82] = temp[2];
Forcement avec les mauvaises valeurs ca ne peut pas fonctionner !
je crois que j'ai fini !!!!!!!
Fiabilité à 100% ( pour le moment) Je ne suis pas très content de ma gestion des réceptions de messages! je pense qu'on peut mieux faire mais bon , ça fait trop de temps que je suis al dessus et je commence à saturer !
Module GSM2-Click
Module GSM2-Click
-
Jérémy
Administrateur du site- Messages : 2731
- Âge : 45
- Enregistré en : juillet 2015
- Localisation : Dans le sud
- Contact :
Temps-x a écrit :Source du message D’où vient tes 84600 secondes ?
Justement c'est mon erreur, j'ai jsute fait une faute de frappe en mettant 84600 à la place de 86400 ! Donc le résultat du modulo n'est pas le bon ! et donc le résultat final ne l'ai pas non plus !
J'ai galérer pour le voir !
Module GSM2-Click
Module GSM2-Click
-
Jérémy
Administrateur du site- Messages : 2731
- Âge : 45
- Enregistré en : juillet 2015
- Localisation : Dans le sud
- Contact :
Re,
Bon je pense que la c'est bon !! ( mise à part les caractères spéciaux dommage).
Aucun problèmes à signaler après deux jours de tests au moins 1000 SMS envoyer !
je sais que mon code n'est pas optimiser! je ne cherche pas la performance étant donné que mon module n'a qu'a attendre la fin du chrono .
Je vous montre mon code, si quelqu'un à la courage de le regarder , et de trouver un éventuel probléme à venir !
Afin d'aérer mon code j'ai placer les Interruptions dans un fichier Header !
Pour les Interruptions, c'est long mais simple, il s'agit d'une machine d'état !
Et pour le calcul du temps : rajouter la librairie "time" :
Sinon voici le fichier complet :
Il me reste le Tuto je pense !
Bon je pense que la c'est bon !! ( mise à part les caractères spéciaux dommage).
Aucun problèmes à signaler après deux jours de tests au moins 1000 SMS envoyer !
je sais que mon code n'est pas optimiser! je ne cherche pas la performance étant donné que mon module n'a qu'a attendre la fin du chrono .
Je vous montre mon code, si quelqu'un à la courage de le regarder , et de trouver un éventuel probléme à venir !
Afin d'aérer mon code j'ai placer les Interruptions dans un fichier Header !
Code : Tout sélectionner
/*
Test du module GSM2 pour http://www.FantasPIC.fr
lien command AT du module M95 : http://www.quectel.com/UploadImage/Downlad/M95_AT_Commands_Manual_V1.2.pdf
Data-Sheet du PIC 16F1847 : http://ww1.microchip.com/downloads/en/DeviceDoc/41453B.pdf
version du 12/02/17
*/
#include "timelib.h"
#define Vert RA2_bit
#define Jaune RA3_bit
#define Orange RA4_bit
#define Rouge RB0_bit
#define Bleu RB6_bit
#define Alim RB5_bit
#define PWRKEY RB3_bit
#define Envoi_tension RA0_bit
#define T_Off 30 // Temps d'extinction en secondes
#define T_On 60 // Temps de reveil en secondes
//------------------------------------------------------------------------------
// Tables des Réponses attendues
const GSM_OK = 0;
const GSM_FLECHE = 1;
const GSM_ERROR = 2;
const GSM_UNREAD = 3;
//------------------------------------------------------------------------------
// Tables des reponses SMS possibles
const R_CHRONO = 1;
const R_OUI = 2;
const R_NON = 3;
const R_STOP = 4;
const R_ETAT = 5;
const R_AIDE = 6;
const R_REVEIL = 7;
// Tableaux
char T_numero_tel[20]; // tableau pour placer le numéro de téléphone en string format : {"+336********"}
char T_message[200]; // Stockage du SMS à envoyer pendant la composition
char T_Reveil[20];
char T_Chrono[15];
char T_Tension[4];
char T_Signal[4];
char T_GDH[30]; // Tableau de reception de valeurs du Groupe Date Heure (GDH)
// Variables
short ReponseID = -1;
short SMS_ID = 0;
char Valeur, Index_num_tel, Fin_Chrono, Etat_module, Index_chrono, SMS_recu, Signal,Index_GDH, Index_REVEIL, moinsde30 ;
char Heures, Minutes, secondes;
char F_envoi_ok, F_READ, F_CMGS;
char Demande_lancement_chrono,Demande_lancement_reveil, Chrono_lance=0, Emplacement_SMS=0;
unsigned int i, Sablier, Sablier_temp, Chrono_temp;
signed long Chrono = -1;
unsigned long epoch1=0, epoch2=0;
TimeStruct ts1, ts2 ; // déclaration des structures pour le calcul du temps avec calendrier
#include "Interruptions.h"
//######################## PROTOTYPE DE FONCTION #########################
void envoi_commande_sans_reponse(char *s1);
void envoi_commande_avec_reponse(char *s1, char);
void envoi_et_composition_SMS(char numero_message);
void strConstRamCpy(char *dest, const char *source);
void analyse_SMS();
void On_M95();
void Off_M95();
void Lecture_T();
//------------------------------------------------------------------------------
// Compose le SMS , puis l'envoie avec fonction de time out et re-envoie
// Param. d'entrée : Le numéro correspondant au message à envoyer
void envoi_et_composition_SMS(char numero_message){
char Compteur=0, Compteur2=0, Temporaire; // compteur pour time-out et re-envoie
char temp[30]; // tableau temporaire pour les calculs
F_envoi_ok = 0; // RAZ de la variable, que indique que l'envoie c'est bien passé
T_message[0] = 0; // On se positionne au début du tableau
temp[0] = 0;
//-------------------- séléction et Création du message -------------------
switch (numero_message){
case 1:{
strConstRamCpy(T_message , "Valeurs recues:\r\n..h ..m ..s\r\nVoulez-vous le lancer ?"); // On copie en ROM avec un Terminateur de string à la fin
T_message[17] = T_CHRONO[0]; // On compléte les "."
T_message[18] = T_CHRONO[1];
T_message[21] = T_CHRONO[2];
T_message[22] = T_CHRONO[3];
T_message[25] = T_CHRONO[4];
T_message[26] = T_CHRONO[5];
break;
}
case 2:{
strConstRamCpy(T_message, "Le Chrono est déja lancé.\r\nUtilisez le mot \"STOP\" si vous souhaitez l'arreter");
break;
}
case 3:{
strConstRamCpy(T_message, "Erreur, les valeurs ne sont pas correctes\r\nHeures<100\r\nMinutes<60\r\nsecondes<60");
break;
}
case 4:{
strConstRamCpy(T_message, "Le chrono est lancé !");
break;
}
case 5:{
strConstRamCpy(T_message, "Abandon de l'initialisation");
break;
}
case 6:{
strConstRamCpy(T_message, "Erreur, ce mot ne convient pas ici !");
break;
}
case 7:{
strConstRamCpy(T_message, "Arret du chrono");
break;
}
case 8:{
strConstRamCpy(T_message, "Etat du module:\r\nRéseau : ..%\r\nNiveaux Batterie : ..%\r\nChrono lancé : ");
// rajoute le signal
T_message[26] = T_Signal[1];
T_message[27] = T_Signal[2];
// rajoute la tension
T_message[50] = T_Tension[1];
T_message[51] = T_Tension[2];
if (Chrono_lance==1){ // Si le Chrono est en cours
strConstRamCpy(T_message+70, "Oui\r\nTemps restant :\r\n");
if ( (Chrono/86400) >= 1){ // Donc plus de 1 jour restant
strConstRamCpy(T_message+92, "..j ");
Temporaire = 4;
// Calcul des Jours restants
ByteToStr ( (unsigned char)(Chrono/86400), temp);
T_message[92] = temp[1];
T_message[93] = temp[2];
}
strConstRamCpy(T_message+92+Temporaire, "..h ..m ..s");
// Calcul des Heures restantes
ByteToStr ( (unsigned char)((Chrono%86400)/3600), temp);
T_message[92+Temporaire] = temp[1];
T_message[93+Temporaire] = temp[2];
// Calcul des Minutes restantes
ByteToStr ((unsigned char)(((Chrono%86400)%3600)/60), temp);
T_message[96+Temporaire] = temp[1];
T_message[97+Temporaire] = temp[2];
// Calcul des Secondes restantes
ByteToStr ((unsigned char)(((Chrono%86400)%3600)%60), temp);
T_message[100+Temporaire] = temp[1];
T_message[101+Temporaire] = temp[2];
}
else{
strConstRamCpy(T_message+70 , "Non");
}
break;
}
case 9:{
strConstRamCpy(T_message, "LES MOTS CLES SONT:\r\nChrono hh mm ss\r\nStop\r\nOui\r\nNon\r\nEtat");
break;
}
case 10:{
strConstRamCpy(T_message, "Réveil reglé pour le :\r\n..-..-.. a ..:..:..\r\n");
// rajoute la date
T_message[24] = T_reveil[0];
T_message[25] = T_reveil[1];
T_message[27] = T_reveil[2];
T_message[28] = T_reveil[3];
T_message[30] = T_reveil[4];
T_message[31] = T_reveil[5];
// rajoute l'heure
T_message[35] = T_reveil[6];
T_message[36] = T_reveil[7];
T_message[38] = T_reveil[8];
T_message[39] = T_reveil[9];
T_message[41] = T_reveil[10];
T_message[42] = T_reveil[11];
strConstRamCpy(T_message+45, "Voulez-vous le lancer ?");
break;
}
case 11:{
strConstRamCpy(T_message, "La Valeur du réveil est anterieur a l\'heure actuelle\r\n");
break;
}
case 12:{
strConstRamCpy(T_message, "Les valeurs du réveil ne sont pas correctes !\r\n\"Reveil JJ MM AA HH MM SS\"");
break;
}
case 13:{
strConstRamCpy(T_message, "Le Chrono est inférieur a 30 Minutes.\r\nLe module restera actif en permanence.");
break;
}
case 14:{
strConstRamCpy(T_message, "Réglage inférieur a 30 Minutes.\r\nLe module restera actif en permanence.\r\n\r\nLe chrono est lancé !");
break;
}
case 99:{
strConstRamCpy(T_message, "Erreur, mot inconnu!");
break;
}
case 100:{
strConstRamCpy(T_message, "FIN !");
break;
}
}
//-------------------- creation de l'en-tete ------------------------------
do{
temp[0] = 0;
strConstRamCpy(temp , "AT+CMGS=\"............\"");
for (i=0;i<12;i++)
temp[9+i] = T_numero_tel[i]; // Je remplis la commande avec le numéro de telephone stocké
envoi_commande_avec_reponse(temp, GSM_FLECHE ); // Envoi la commande pour envoyer le message
RCIE_bit = 1; // Activation des INT Rx UART
// ------------------ envoi du message -------------------------------
UART_Write_Text(T_message);
UART_Write(0x1A); // Envoi CTRL + Z comme caractere de fin
Delay_ms(500);
while(1){ // Boucle d'attente de CMGS pour signifier l'envoi du message
Compteur++; // Time out de 5s avant d'essayer de le re-envoyer
Delay_ms(50); // Avec 3 tentatives d'envoi
if (F_CMGS==1){ // receptiopn du Flag pour signaler que l'envoi est bien parti
F_CMGS = 0; // RAZ du flag
F_envoi_ok = 1; // On leve le drapeau pour sortir de la fonction , RAZ se fait au début de la fonction
break;
}
if ( (ReponseID == GSM_ERROR) || (Compteur > 100) ){ // Au bouit de 5s on sort pour re-envoyer le message
Compteur = 0; // RAZ du compteur
Compteur2++; // compteur de renvoi de commande
F_envoi_ok = 0;
break;
}
}
}while( (Compteur2<3) && (F_envoi_ok==0) );
RCIE_bit = 0;
}
//------------------------------------------------------------------------------
// Envoi de commande ou donnée avec attente de la réponse
// Param. d'entrée : La commande à executer, et la réponse attendue a cette commande
void envoi_commande_avec_reponse(char *s1, char rspns ){
char Compteur=0, Compteur2 =0, Bonne_reponse = 0; // Variables locales
RCIE_bit = 1; // Autorise les INT Rx UART
do{
// ---- Envoi de la commande
while(*s1) {
UART_Write(*s1++);
}
UART_Write(0x0D); // On termine par un CR
//---- Boucle d'attente de Reponse ou timeout
while (1){
Compteur++; // compteur de time out
delay_ms(50);
if (ReponseID == rspns){
Bonne_reponse = 1; // le léve le drapeau pour sortir de la fonction
break; // Je sors de la boucle
}
else if ( (ReponseID == GSM_ERROR) || (Compteur>100) ){
Compteur = 0; // RAZ du time out
Compteur2++; // compteur de renvoi de commande
Bonne_reponse = 0;
break;
}
}
}while ( (Compteur2<3) && (Bonne_reponse==0) ); // Je sors apres 3 tentatives d'envoi ou j'ai recu la Reponse attendue
RCIE_bit = 0;
}
//###########################################################################################################################
//################################## TRAITEMENT DES REPONSES RECUES ########################################
// Si il y a un message non traité , je vais le retraiter ! lu ou non lu ;
void analyse_SMS(){
F_READ = 0; // RAZ du flag
for (i=0;i<6;i++){
Rouge = ~Rouge;
delay_ms(100);
}
//############### "Chrono" ##############
if (SMS_ID == R_CHRONO){
SMS_ID = SMS_recu = 0; // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS
//--- récupération et calcul du Chrono en seconde
Heures = ((T_Chrono[0]-48)*10) + (T_Chrono[1]-48);
Minutes = ((T_Chrono[2]-48)*10) + (T_Chrono[3]-48);
Secondes = ((T_Chrono[4]-48)*10) + (T_Chrono[5]-48);
Chrono = ( ((unsigned long)Heures*3600) + (Minutes*60) + Secondes ); // Calcul du temps en secondes ATTENTION AU CAST!!
if ( (Heures>99) || (Minutes>59) || (Secondes>59) ){ // Si une Valeur est supérieur à la normale
envoi_et_composition_SMS(3); // "Erreur, les valeurs ne sont pas correctes"
}
else if (Chrono_lance == 1){
envoi_et_composition_SMS(2); // "le Chrono est deja lance "
}
else{
envoi_et_composition_SMS(1); // "Valeurs recues etc....."
if (F_envoi_ok==1) // Si le message est bien parti !
Demande_lancement_chrono=1; // je l'indique pour attendre le OUI ou NON
else
Demande_lancement_chrono=0;
}
}
//############### "REVEIL" ##############
else if (SMS_ID == R_REVEIL){
SMS_ID = SMS_recu = 0; // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS
// remplissage de la structure GDH
ts1.ss = (((T_GDH[15])-48)*10)+(((T_GDH[16])-48));
ts1.mn = (((T_GDH[12])-48)*10)+(((T_GDH[13])-48));
ts1.hh = (((T_GDH[9])-48)*10)+(((T_GDH[10])-48));
ts1.md = (((T_GDH[6])-48)*10)+(((T_GDH[7])-48));
ts1.mo = (((T_GDH[3])-48)*10)+(((T_GDH[4])-48));
ts1.yy = 2000 + ((((T_GDH[0])-48)*10)+(((T_GDH[1])-48))) ;
// remplissage de la structure REVEIL
ts2.ss = (((T_REVEIL[10])-48)*10)+(((T_REVEIL[11])-48)) ;
ts2.mn = (((T_REVEIL[8])-48)*10)+(((T_REVEIL[9])-48)) ;
ts2.hh = (((T_REVEIL[6])-48)*10)+(((T_REVEIL[7])-48)) ;
ts2.md = (((T_REVEIL[0])-48)*10)+(((T_REVEIL[1])-48)) ;
ts2.mo = (((T_REVEIL[2])-48)*10)+(((T_REVEIL[3])-48)) ;
ts2.yy = 2000 + ((((T_REVEIL[4])-48)*10)+(((T_REVEIL[5])-48))) ;
// calcul du temps
epoch1 =Time_dateToEpoch(&ts1);
epoch2 = Time_dateToEpoch(&ts2);
Chrono = epoch2 - epoch1 ;
if (Chrono_lance==1){ // Si le Chrono est déjà lancé
envoi_et_composition_SMS(2); // "le Chrono est deja lance "
}
else if ( epoch2 <= epoch1){ // Le reveil est inferieur à la date actuelle
envoi_et_composition_SMS(11);
}
else if ( (T_REVEIL[2]>49) || ( (T_REVEIL[2]==49)&&(T_REVEIL[3]>50) ) || ( T_REVEIL[0]>51 ) || ( (T_REVEIL[0]==51)&&(T_REVEIL[1]>49) ) || ( T_REVEIL[6]>50 ) || ( (T_REVEIL[6]==50)&&(T_REVEIL[7]>51) ) || ( T_REVEIL[8]>53 ) || ( T_REVEIL[10]>53 ) ){
envoi_et_composition_SMS(12); // Si une Valeur n'est pas convenable
}
else{
envoi_et_composition_SMS(10); // "Réveil reglé pour le :\r\n..-..-.. a ..:..:..\r\n"
if (F_envoi_ok==1) // Si le message est bien parti !
Demande_lancement_reveil=1; // je l'indique pour attendre le OUI ou NON
else
Demande_lancement_reveil=0;
}
}
//############### "OUI" ################
else if (SMS_ID == R_OUI){
SMS_ID = SMS_recu = 0; // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS
if ( (Demande_lancement_chrono==1) || (Demande_lancement_reveil==1) ) { // Si la demande de lancement à été effectuée
Demande_lancement_chrono = Demande_lancement_reveil = 0;
if (Chrono<=30){ // Le Chrono est réglé < 30minutes
TMR0IE_bit = 0; // On arrete le Sablier
Sablier = 0;
moinsde30 = 1; // Pas besoin d'indiquer que le Chrono est < 30
envoi_et_composition_SMS(14); // "Réglage inférieur a 30 Minutes"
}
else{
moinsde30 = 0; // A chaque nouveau lancement je RAZ ppour l'indiquer à nouveau
envoi_et_composition_SMS(4); // "Le Chrono est lancé"
}
if (F_envoi_ok==1){ // Si le message est bien parti
TMR1IE_bit = 1; // je lance le chrono
Chrono_lance = 1; // J'indique que le Chrono est lancé
}
}
else{
envoi_et_composition_SMS(6); // "ERREUR, ce mot ne convient pas ici"
}
}
//############### "NON" ################
else if (SMS_ID == R_NON){
SMS_ID = SMS_recu = 0; // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS
if ( (Demande_lancement_chrono==1) || (Demande_lancement_reveil==1) ){
Demande_lancement_chrono = Demande_lancement_reveil = 0;
envoi_et_composition_SMS(5); // "Abandon de l'initialisation"
}
else{
envoi_et_composition_SMS(6); // "ERREUR, ce mot ne convient pas ici"
}
}
//############### "STOP" ################
else if (SMS_ID == R_STOP){
SMS_ID = SMS_recu = 0; // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS
if (Chrono_lance==1){ // Si le Chrono est lancé
TMR1IE_bit = 0; // j'arrete le chrono
Chrono_lance = 0; // J'indique que le Chrono est arreté
Vert = 0;
envoi_et_composition_SMS(7); // "Arret du Chrono"
}
else{
envoi_et_composition_SMS(6); // "ERREUR, ce mot ne convient pas ici"
}
}
//############### "ETAT" ################
else if (SMS_ID == R_ETAT){
SMS_ID = SMS_recu = 0; // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS
envoi_commande_avec_reponse("AT+CSQ", GSM_OK); // Je demande l'état du réseau
Signal = 100 - ((((T_Signal[0]-48)*10) + ((T_Signal[1]-48)))*2);
ByteToStr ( Signal, T_Signal);
Lecture_T(); // Je demande la Tension de la batterie
envoi_et_composition_SMS(8);
}
//############### "AIDE" ################
else if (SMS_ID == R_AIDE){
SMS_ID = SMS_recu = 0; // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS
envoi_et_composition_SMS(9);
}
//########### AUCUN MOT NE CONVIENT #############
else{
envoi_et_composition_SMS(99); // "Erreur, mot inconnu!"
}
if (F_envoi_ok == 1){ // Si la réponse à été envoyé alors on peut l'effacer, sinon on l'efface pas pour la relancer
F_envoi_ok = 0;
if (Emplacement_SMS == 1){
envoi_commande_avec_reponse("AT+CMGR=2", GSM_OK); // Je demande si j'ai recu un message entre temps
if (F_READ==1) // Si je trouve "READ" ou "UNREAD" à l'emplacement 3
envoi_commande_avec_reponse("AT+CMGD=1", GSM_OK); // On efface seulement le premier message
else
envoi_commande_avec_reponse("AT+QMGDA=\"DEL ALL\"", GSM_OK); // Sinon je les supprimes TOUS
}
else if (Emplacement_SMS == 2)
envoi_commande_avec_reponse("AT+CMGD=2", GSM_OK); // On efface seulement le premier message
else if (Emplacement_SMS == 3)
envoi_commande_avec_reponse("AT+QMGDA=\"DEL ALL\"", GSM_OK); // On efface seulement le premier message
delay_ms(1000);
Sablier = 0; // On RAZ le Sablier à la sortie
for (i=0;i<6;i++){
Bleu = ~Bleu; // A supprimer aprés les tets
delay_ms(100);
}
}
}
//##############################################################################
//########################### MAIN #####################################
//##############################################################################
void main(){
ANSELA = 0b00000010; // RA1 en Analogique pour lecture tension
ANSELB = 0;
TRISB = 0b00000010; // RB1 en entrée pour UART, RB3 en sortie PWRKEY
TRISA = 0b00000010; // RA1 en entrée pour lecture tension
Alim = 1; // Module éteint
PWRKEY = 0;
Vert = Jaune = Orange = Rouge = Bleu = 0;
Etat_module = Valeur = 0;
//------------------------------------------------------------------------------
// Réglages du Timer1 à 10 ms pour le chronometre
TMR1IE_bit = 0; // désactiver au départ
T1CON = 0b00010001;
TMR1IF_bit = 0;
TMR1H = 0x63;
TMR1L = 0xC0;
//------------------------------------------------------------------------------
// Réglages du Timer 0 à 1 ms pour la tempo On/Off "sablier"
TMR0IE_bit = 1; // activer au départ
OPTION_REG = 0x84; // Presacler 1:32
TMR0 = 6; // Offset
TMR0IF_bit = 0; // On RAZ le flag
//------------------------------------------------------------------------------
// Réglages de l'interruption sur Reception UART
GIE_bit = 1; // Active toutesl es INT
PEIE_bit = 1; // Active les INT peripherique
RCIE_bit = 0; // Desactive les Interruptions sur Rx UART
//------------------------------------------------------------------------------
// Configuration du convertisseur analogique/numérique avec reference interne
// Configuration de l'ADCON0 ------------------------------------
// bit 7 non utilisé
// CHS<4:0> = choix du canal AN1 = 00001
ADCON0 = 0b00000101; // Go/~DONE = ? je met 0 dans le doute
// ADON = 1, activation du module AD
// Configuration de l'ADCON1 --------------------------------------
// ADFM = 1, justification à droite
// ADCS<2:0>= 001, Fosc/8
ADCON1 = 0b10010011; // bit 3 non utilisé
// ADNREF = 0, ref- = GND
// ADPREF = 11, REF+ = FVR ( reglé sur 2.048V)
// Configuration de Vref -----------------------------------------
// FVREN_bit = 1; // Activation du Vref
// FVRRDY_bit = 1; // Pret a etre utilisé
// TSEN_bit = 0;
FVRCON = 0b11000010 ; // TSRNG_bit = 0;
// CDAFVR0_bit = 0;
// CDAFVR1_bit = 0;
// ADFVR1_bit = 1; // ADFVR = 0b10
// ADFVR0_bit = 0; // Mise du Vref à 2.048V
//------------------------------------------------------------------------------
UART1_Init(9600); // Initialisation de l'UART à 9600 bauds
delay_ms(200);
//------------------------------------------------------------------------------
On_M95(); // On allume le module
//##############################################################################
//####################### BOUCLE PRINCIPALE ################################
//##############################################################################
while(1) {
//------------ Gestion de l'extinction automatique ----------------------
if ((Sablier >= T_On) && ( Etat_module==1) ){ // Test de mise en pause
Off_M95();
}
if ( (Sablier >= T_Off) && (Etat_module==0) ){ // Test de réveil
On_M95();
}
if ( (Chrono<=30) && (Chrono>0) && (moinsde30==0) ){ // Le Chrono approche de la fin < 30minutes
moinsde30 = 1; // je leve le drapeau comme quoi j'ai deja envoyer le message moins de 30
if (Etat_module==0) // Si il est éteint je l'allume
On_M95();
TMR0IE_bit = 0; // On arrete le Sablier
Sablier = 0;
envoi_et_composition_SMS(13); // "Le Chrono est inférieur à 30 Minutes..."
}
//--------------------- Lecture des messages (Si le module est allumé ) -------------------------------
if (Etat_module==1){
delay_ms(2000);
envoi_commande_avec_reponse("AT+CMGR=3", GSM_OK); // Je lis le message à l'emplacement 3 de la memoire
delay_ms(10);
if (F_READ==1){ // Si je trouve "READ" ou "UNREAD" à l'emplacement 3
Emplacement_SMS = 3;
analyse_SMS(); // j'analyse le SMS à l'emplacement 3
}
else{ // Si je n'ai pas de SMS en #3 alors je regarde en #2
envoi_commande_avec_reponse("AT+CMGR=2", GSM_OK);
delay_ms(100);
if (F_READ==1){ // Si je trouve "READ" ou "UNREAD"
Emplacement_SMS = 2;
analyse_SMS();
}
else{ // Si je n'ai pas de SMS en #2 alors je regarde en #1
envoi_commande_avec_reponse("AT+CMGR=1", GSM_OK);
delay_ms(100);
if (F_READ==1){ // Si je trouve "READ" ou "UNREAD"
Emplacement_SMS = 1;
analyse_SMS();
}
}
}
}
//--------------------- action à executer à la fin du chrono -------------------------------
if ( (Fin_Chrono==1) && (Chrono_lance==1) ){ // Fin du chronometre detecté
for (i=0;i<12;i++){
Rouge = ~Rouge; // A supprimer apres les tests
Bleu = ~Bleu;
delay_ms(100);
}
Vert = 0; // A supprimer apres les tests
Fin_Chrono = 0; // RAZ du flag
TMR1IE_bit = 0; // J'arrete le chrono
Chrono_lance = 0; // J'indique que le Chrono est arreté
Chrono = -1; // Je réinitialise le Chrono
TMR0IE_bit = 1; // Je relance le Sablier
Sablier = 0;
envoi_et_composition_SMS(100); // "FIN !"
}
}
}
//##############################################################################
//####################### FONCTIONS SECONDAIRES ###########################
//##############################################################################
//------------------------------------------------------------------------
//------------------- Envoi de commande ou donnée -------------------
//------------------------------------------------------------------------
// Param. d'entrée : La commande à envoyer
void envoi_commande_sans_reponse(const code char *s1){
while(*s1) {
UART_Write(*s1++);
}
UART_Write(0x0D); // On termine par un CR
}
//------------------------------------------------------------------------
//----------------- Copie le texte depuis ROM vers RAM ---------------
//------------------------------------------------------------------------
// Param. d'entrée : le tableau où on doit stocker le texte, et la chaine de caracteres à stocker
void strConstRamCpy(char *dest, const char *source){
while(*source)
*(dest++) = *(source++) ;
*dest = 0 ; // Rajout du terminateur
}
//------------------------------------------------------------------------
//----------------- ACTIVATION DU MODULE --------------------------
//------------------------------------------------------------------------
void On_M95(){
Alim = 0; // Activation de l'alimentation du module par MOSFET
Delay_ms(500); // Stabilisation de la tension
PWRKEY = 0; // Mise à zéro
Delay_ms(3000); // Maintenir à 0 pendant plus de 2S
PWRKEY = 1; // Allume le module
Delay_ms(100);
// Test du baud rate
RCIE_bit = 1; // Autorise les INT UART
do{
envoi_commande_sans_reponse("AT"); // 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
} while (ReponseID != GSM_OK);
RCIE_bit = 0; // Coupe Les INT UART
Delay_ms(8000); // Attendre pour que le réseau GSM se configure, 8 secondes.
// RAZ des variables
F_READ = F_CMGS = F_envoi_ok = SMS_recu = Valeur = 0;
// Parametrage du module
envoi_commande_avec_reponse("ATE0", GSM_OK); // echo sur Off
envoi_commande_avec_reponse("AT+CMGF=1", GSM_OK); // Mode "TEXTE"
envoi_commande_avec_reponse("AT+QMGDA=\"DEL ALL\"", GSM_OK); // On efface tout les messages
// Allume la LED rouge pour signifier l'initialisation c'est bien passéee et finie
for (i=0;i<6;i++){
Rouge = ~Rouge; // A supprimer apres tests
Delay_ms(500);
}
Etat_module = 1; // On signale que le module est allumé
Sablier = 0;
}
//------------------------------------------------------------------------
//----------------- EXTINCTION DU MODULE --------------------------
//------------------------------------------------------------------------
void Off_M95(){
envoi_commande_sans_reponse("AT+QPOWD=1"); // On arrete le module proprement
Delay_ms(100);
RCIE_bit = 0; // Coupe Les INT UART
Alim = 1; // On eteint l'alim du module avec le MOSFET
Etat_module = 0; // On indique que le module est éteint
Sablier = 0; // On RAZ le Sablier
}
//------------------------------------------------------------------------
//----------------- LECTURE DE LA TENSION --------------------------
//------------------------------------------------------------------------
void Lecture_T(){
int Tension = 0; // Variable locale
Envoi_tension = 1; // Alumage du pont diviseur (PIN RA0)
delay_ms(200); // Stabilisation de la Tension sur la PIN
//----- Moyenne sur 8 valeurs ------
for (i=0 ; i<8 ; i++){
ADCON0.B1 = 1; // On démarre la conversion
while (ADCON0.B1); // J'attend que le bit soit effacé à la fin de la conversion
Tension += ( (ADRESH<<8) + (ADRESL) ); // j'enregistre et je convertis la Valeur des registres
delay_ms(1);
}
Tension >>= 3; // On divise par 8 pour obtenir la moyenne
Tension = (((Tension-830)*100)/193); // Mise à l'echelle de 1023 à 830 en pourcentage
ByteToStr(Tension, T_Tension); // On place la valeur dans le tableau pour l'envoyer par SMS
Envoi_tension = 0; // Exctinction du pont diviseur
}
Pour les Interruptions, c'est long mais simple, il s'agit d'une machine d'état !
Code : Tout sélectionner
//##############################################################################
// Lecture des données dans le buffer UART par INT
void interrupt(){
char tmp;
//---------------- TIMER 1 interruption toute les 10 ms -----------------
if ((TMR1IF_bit) && (TMR1IE_bit)) {
TMR1IF_bit = 0; // RAZ Flag
TMR1H = 0x63; // Offset
TMR1L = 0xC0;
Chrono_temp++; // Incrementation toutes les 10ms
if (Chrono_temp >= 100){
Chrono_temp = 0;
Vert = ~Vert;
Chrono--;
if (Chrono==0)
Fin_Chrono = 1;
}
}
//-------- TIMER 0 interruption toute les 1ms pour sablier ------------
if ((TMR0IF_bit) && (TMR0IE_bit)) {
TMR0IF_bit = 0; // RAZ Flag
TMR0 = 6; // Offset
Sablier_temp++; // Incrementation toutes les 1ms
if (Sablier_temp >= 1000){
Jaune = ~Jaune;
Sablier_temp = 0; // 1000 ms écoulé
Sablier++; // j'incremente le Sablier Seconde
}
}
//----------------------- UART -----------------------------
if (RCIF_bit == 1) { // Si INT UART détecté
tmp = UART_Read(); // On récupere et stock la donnée
switch (Valeur) {
case 0: {
ReponseID = -1; // RAZ de la réponse
if ( (tmp == 'O') || (tmp == 'o') )// "OK" ou "OUI"
Valeur = 1;
if ( (tmp == 'N') || (tmp == 'n') )// "NON"
Valeur = 6;
if (tmp == '>') // "> "
Valeur = 10;
if ( (tmp == 'S') || (tmp == 's') )// "STOP"
Valeur = 15;
if ( (tmp == 'C') || (tmp == 'c') )// "CMGS" ou "Chrono" ou "CSQ"
Valeur = 20;
if ( (tmp == 'E') || (tmp == 'e') )// "ERROR" ou "ETAT"
Valeur = 30;
if ( (tmp == 'R') || (tmp == 'r') )// "READ" ou "REVEIL"
Valeur = 40;
if ( (tmp == 'A') || (tmp == 'a') )// "AIDE"
Valeur = 45;
if (tmp == '"') // " "+33612345678"
Valeur = 60;
if (tmp == ',') // " ,"20xxxxxxxxxxx" GDH
Valeur = 70;
break;
}
case 1: {
if (tmp == 'K') // "OK"
Valeur = 2;
else if ((tmp == 'U') || (tmp == 'u') ) // "OUI"
Valeur = 5;
else
Valeur = 0;
break;
}
case 2: {
if (tmp == 13) // "OK"
Valeur = 3;
else
Valeur = 0;
break;
}
case 3: {
if (tmp == 10) // "OK"
ReponseID = GSM_OK;
Valeur = 0;
break;
}
case 5: {
if ( ((tmp == 'I') || (tmp == 'i')) && (SMS_recu == 0) ){ // "OUI"
SMS_recu = 1;
SMS_ID = R_OUI ;
}
Valeur = 0;
break;
}
case 6: {
if ((tmp == 'O') || (tmp == 'o') ) // "NON"
Valeur = 7 ;
else
Valeur = 0;
break;
}
case 7: {
if ( ((tmp == 'N') || (tmp == 'n')) && (SMS_recu == 0) ){ // "NON"
SMS_recu = 1;
SMS_ID = R_NON ;
}
Valeur = 0;
break;
}
case 10: {
if (tmp == ' '){
ReponseID = GSM_FLECHE; // "FLECHE"
}
Valeur = 0;
break;
}
case 15: {
if ((tmp == 'T') || (tmp == 't') ) // "STOP"
Valeur = 16;
else
Valeur = 0;
break;
}
case 16: {
if ((tmp == 'O') || (tmp == 'o') ) // "STOP"
Valeur = 17;
else
Valeur = 0;
break;
}
case 17: {
if ( ((tmp == 'P') || (tmp == 'p')) && (SMS_recu == 0) ){ // "STOP"
SMS_recu = 1;
SMS_ID = R_STOP ;
}
Valeur = 0;
break;
}
case 20: {
if (tmp == 'M') // "CMGS" ou "Chrono" ou "CSQ"
Valeur = 21;
else if (tmp == 'S')
Valeur = 25;
else if ((tmp == 'H') || (tmp == 'h') )
Valeur = 80;
else
Valeur = 0;
break;
}
case 21: {
if (tmp == 'G') // "CMGS"
Valeur = 22;
else
Valeur = 0;
break;
}
case 22: {
if (tmp == 'S') // "CMGS"
F_CMGS = 1;
Valeur = 0;
break;
}
case 25: {
if (tmp == 'Q') // "CSQ"
Valeur = 26;
else
Valeur = 0;
break;
}
case 26: {
if (tmp == ':') // "CSQ"
Valeur = 27;
else
Valeur = 0;
break;
}
case 27: {
if (tmp == ' ') // "CSQ"
Valeur = 28;
else
Valeur = 0;
break;
}
case 28: {
if (tmp >= '0' && tmp <= '9'){ // "CSQ"
T_Signal[0] = '0' ;
T_Signal[1] = tmp ;
Valeur = 29;
}
else
Valeur = 0;
break;
}
case 29: {
if (tmp >= '0' && tmp <= '9'){ // "CSQ"
T_Signal[0] = T_Signal[1] ;
T_Signal[1] = tmp ;
T_Signal[2] = 0; // terminateur de string
}
Valeur = 0;
break;
}
case 30: {
if (tmp == 'R') // "ERROR" ou "ETAT"
Valeur = 31;
else if ((tmp == 'T') || (tmp == 't') )
Valeur = 35;
else
Valeur = 0;
break;
}
case 31: {
if (tmp == 'R') // "ERROR"
Valeur = 32;
else
Valeur = 0;
break;
}
case 32: {
if (tmp == 'O') // "ERROR"
Valeur = 33;
else
Valeur = 0;
break;
}
case 33: {
if (tmp == 'R'){ // "ERROR"
ReponseID = GSM_ERROR;
}
Valeur = 0;
break;
}
case 35: {
if ((tmp == 'A') || (tmp == 'a') ) // "ETAT"
Valeur = 36;
else
Valeur = 0;
break;
}
case 36: {
if ( ((tmp == 'T') || (tmp == 't')) && (SMS_recu == 0) ){ // "ETAT"
SMS_recu = 1;
SMS_ID = R_ETAT ;
}
Valeur = 0;
break;
}
case 40: {
if ( (tmp == 'E') || (tmp == 'e') ) // "READ" ou "REVEIL"
Valeur = 41;
else
Valeur = 0;
break;
}
case 41: {
if (tmp == 'A') // "READ" ou "REVEIL"
Valeur = 42;
else if ((tmp == 'V') || (tmp == 'v') )
Valeur = 100;
else
Valeur = 0;
break;
}
case 42: {
if (tmp == 'D'){ // "READ"
F_READ = 1 ;
SMS_recu = 0;
}
Valeur = 0;
break;
}
case 45: {
if ((tmp == 'I') || (tmp == 'i') ) // "AIDE"
Valeur = 46;
else
Valeur = 0;
break;
}
case 46: {
if ((tmp == 'D') || (tmp == 'd') ) // "AIDE"
Valeur = 47;
else
Valeur = 0;
break;
}
case 47: {
if ( ((tmp == 'E') || (tmp == 'e')) && (SMS_recu == 0) ){ // "AIDE"
SMS_recu = 1;
SMS_ID = R_AIDE ;
}
Valeur = 0;
break;
}
case 60 :{
if (tmp == '+'){
Index_num_tel = 0;
T_numero_tel[Index_num_tel] = tmp;
Index_num_tel++;
Valeur = 61;
}
else
Valeur = 0;
break;
}
case 61 :{
if (tmp >= '0' && tmp <= '9'){
T_numero_tel[Index_num_tel] = tmp;
Index_num_tel ++;
}
else if (tmp == '"'){ // si on retrouve des guillemets
T_numero_tel[Index_num_tel] = 0; // Place un terminateur de string à la fin
Valeur = 0;
}
else{
T_numero_tel[0] = 0;
Index_num_tel = 0;
Valeur = 0;
}
break;
}
case 70: {
if (tmp == '"') // "GDH"
Valeur = 71;
else
Valeur = 0;
break;
}
case 71: {
if (tmp == '2') // "GDH"
Valeur = 72;
else
Valeur = 0;
break;
}
case 72: {
if (tmp == '0'){ // "GDH"
Valeur = 73;
Index_GDH = 0;
}
else
Valeur = 0;
break;
}
case 73: {
if ( (tmp != '+') && (Index_GDH<17) ) // "GDH" sécurité avec (Index_GDH<17)
{
T_GDH[Index_GDH] = tmp;
Index_GDH++;
}
else
{
T_GDH[Index_GDH] = 0; // Je termine le Gdh par un "NULL" terminateur
Index_GDH = 0;
Valeur = 0;
}
break;
}
case 80: {
if ( (tmp == 'R') || (tmp == 'r') ) // "CHRONO"
Valeur = 81;
else
Valeur = 0;
break;
}
case 81: {
if ( (tmp == 'O') || (tmp == 'o') ) // "CHRONO"
Valeur = 82;
else
Valeur = 0;
break;
}
case 82: {
if ( (tmp == 'N') || (tmp == 'n') ) // "CHRONO"
Valeur = 83;
else
Valeur = 0;
break;
}
case 83: {
if ( (tmp == 'O') || (tmp == 'o') ) // "CHRONO"
Valeur = 84;
else
Valeur = 0;
break;
}
case 84: {
if (tmp == ' ') // "CHRONO"
Valeur = 85;
else
Valeur = 0;
break;
}
case 85: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "CHRONO"
T_Chrono[0] = tmp;
Valeur = 86;
}
else
Valeur = 0;
break;
}
case 86: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "CHRONO"
T_Chrono[1] = tmp;
Valeur = 87;
}
else
Valeur = 0;
break;
}
case 87: {
if (tmp == ' ') // "CHRONO"
Valeur = 88;
else
Valeur = 0;
break;
}
case 88: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "CHRONO"
T_Chrono[2] = tmp;
Valeur = 89;
}
else
Valeur = 0;
break;
}
case 89: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "CHRONO"
T_Chrono[3] = tmp;
Valeur = 90;
}
else
Valeur = 0;
break;
}
case 90: {
if (tmp == ' ') // "CHRONO"
Valeur = 91;
else
Valeur = 0;
break;
}
case 91: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "CHRONO"
T_Chrono[4] = tmp;
Valeur = 92;
}
else
Valeur = 0;
break;
}
case 92: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "CHRONO"
T_Chrono[5] = tmp;
if (SMS_recu ==0){
SMS_recu = 1;
SMS_ID = R_CHRONO ;
}
}
Valeur = 0;
break;
}
case 100: {
if ((tmp == 'E') || (tmp == 'e') ) // "REVEIL"
Valeur = 101 ;
else
Valeur = 0;
break;
}
case 101: {
if ((tmp == 'I') || (tmp == 'i') ) // "REVEIL"
Valeur = 102 ;
else
Valeur = 0;
break;
}
case 102: {
if ((tmp == 'L') || (tmp == 'l') ) // "REVEIL"
Valeur = 103 ;
else
Valeur = 0;
break;
}
case 103: {
if (tmp == ' '){ // "REVEIL"
Index_REVEIL = 0;
Valeur = 104 ;
}
else
Valeur = 0;
break;
}
case 104: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[0] = tmp;
Valeur = 105;
}
else
Valeur = 0;
break;
}
case 105: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[1] = tmp;
Valeur = 106;
}
else
Valeur = 0;
break;
}
case 106: {
if (tmp == ' ') // "REVEIL"
Valeur = 107;
else
Valeur = 0;
break;
}
case 107: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[2] = tmp;
Valeur = 108;
}
else
Valeur = 0;
break;
}
case 108: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[3] = tmp;
Valeur = 109;
}
else
Valeur = 0;
break;
}
case 109: {
if (tmp == ' ') // "REVEIL"
Valeur = 110;
else
Valeur = 0;
break;
}
case 110: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[4] = tmp;
Valeur = 111;
}
else
Valeur = 0;
break;
}
case 111: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[5] = tmp;
Valeur = 112;
}
else
Valeur = 0;
break;
}
case 112: {
if (tmp == ' ') // "REVEIL"
Valeur = 113;
else
Valeur = 0;
break;
}
case 113: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[6] = tmp;
Valeur = 114;
}
else
Valeur = 0;
break;
}
case 114: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[7] = tmp;
Valeur = 115;
}
else
Valeur = 0;
break;
}
case 115: {
if (tmp == ' ') // "REVEIL"
Valeur = 116;
else
Valeur = 0;
break;
}
case 116: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[8] = tmp;
Valeur = 117;
}
else
Valeur = 0;
break;
}
case 117: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[9] = tmp;
Valeur = 118;
}
else
Valeur = 0;
break;
}
case 118: {
if (tmp == ' ') // "REVEIL"
Valeur = 119;
else
Valeur = 0;
break;
}
case 119: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[10] = tmp;
Valeur = 120;
}
else
Valeur = 0;
break;
}
case 120: {
if ( (tmp >= '0') && (tmp <= '9') ){ // "REVEIL"
T_Reveil[11] = tmp;
if (SMS_recu ==0){
SMS_recu = 1;
SMS_ID = R_REVEIL ;
}
}
Valeur = 0;
break;
}
default: {
Valeur = 0;
}
}
}
}
Et pour le calcul du temps : rajouter la librairie "time" :
Code : Tout sélectionner
// some constants
#define Time_secInMn 60 // seconds per minute
#define Time_secInH (Time_secInMn * 60) // seconds per hour
#define Time_secIn24h (Time_secInH * 24) // seconds per day
// simple time structure
typedef struct
{
unsigned char ss ; // seconds
unsigned char mn ; // minutes
unsigned char hh ; // hours
unsigned char md ; // day in month, from 1 to 31
unsigned char wd ; // day in week, monday=0, tuesday=1, .... sunday=6
unsigned char mo ; // month number, from 1 to 12 (and not from 0 to 11 as with unix C time !)
unsigned int yy ; // year Y2K compliant, from 1892 to 2038
} TimeStruct ;
// private variables
extern long Time_jd1970 ; // 01/01/1970 julian day number
// public functions
long Time_dateToEpoch(TimeStruct *ts) ;
void Time_epochToDate(long e, TimeStruct *ts) ;
// macro definitions
/*
* compares two dates,
* return time difference in seconds as a signed long
* result is positive if t1 is before t2
* result is null if t1 is the same as t2
* result is negative if t1 is after t2
*/
#define Time_dateDiff(t1, t2) (Time_dateToEpoch(t2) - Time_dateToEpoch(t1))
Sinon voici le fichier complet :
Il me reste le Tuto je pense !
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Qui est en ligne
Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 6 invités