CCS C Software and Maintenance Offers
FAQFAQ   FAQForum Help   FAQOfficial CCS Support   SearchSearch  RegisterRegister 

ProfileProfile   Log in to check your private messagesLog in to check your private messages   Log inLog in 

CCS does not monitor this forum on a regular basis.

Please do not post bug Reports on this forum. Send them to support@ccsinfo.com

A6 GSM module initialisation an send/receive an SMS

 
Post new topic   Reply to topic    CCS Forum Index -> Code Library
View previous topic :: View next topic  
Author Message
PrinceNai



Joined: 31 Oct 2016
Posts: 109

View user's profile Send private message

A6 GSM module initialisation an send/receive an SMS
PostPosted: Sun Aug 11, 2019 7:26 pm     Reply with quote

Hi,

below is a code to initialize an A6 based GSM module. BOOT pin has a FET transistor with drain connected to A6 ground and source to GND to turn the module on or off. At the beginning the code tries to find the baud rate of the module (115.200 by default) and sets it to 57.600. It works much better with that speed, don't know why. Then it sets some parameters: text mode and how incoming messages will be reported to PIC. In this case, GSM reports that the message arrived, but PIC has to ask for the contents. After that, it just checks if it is registered on the network and waits for an incoming message. Whenever a message comes in, the number from which it came is extracted to GSM_NUMBER buffer. If the message says: Status? (case doesn't matter), an SMS is returned to the number this request came from.

What I struggle with is error checking. Init part isn't bullet-proof if something goes wrong. Also errors when sending an SMS aren't 100% sure to be recovered from. I'd be glad if anyone sends me to the right direction. This is intended as a part of a home fire alarm system, and I just cant allow the GSM module to hang the flow of the program for too long.

Anyway, if something unexpected doesn't happen, this works.

The project:

test.c

Code:


#include <test.h>                //fuses, uses
#include <i2c_Flex_LCD_driver.c>
#include <defs.h>                //definitions of pins and registers
#include <string.h>
#include <ctype.h>
#include <1Wire.c>
#include <ds1820.c>                     
#include <stdlib.h>                 
                                                                                     
//***********************************************************************
// includes
//***********************************************************************
#include <functions.c>           //all the functions                                                     
//*****************WRITE VALUES TO EEPROM WHEN PROGRAMMING PIC*******************                                                     
//#if defined (__PCM__)                                                                               
//#rom 0x2100={30,0,0x58,0x02,0x20,0x1C,50,0,0xEC,0,8,0,50,0,248,0,38,0,0x58,0x02,0,0}
//#elif defined(__PCH__)
#rom int 0xf00000={"+38267600917"}        //    eeprom start                                             
#rom int 0xf00010={"a38269407581"}        //    second block of 16 bytes                                 
#rom int 0xf00020={"+38267600917"}        //    third                                                 
#rom int 0xf00030={"b38267600917"}        //    fourth                                                                     
//#rom int 0xf00040={"+38267600917"}      //
//#rom int 0xf00050={"+38267600917"}      //                                 
//#rom int 0xf00060={"+38267600917"}      //                                           
//#rom int 0xf00070={"+38267600917"}      //
//#rom int 0xf00080={"+38267600917"}      //
//#rom int 0xf00090={"+38267600917"}      //    začetek eeproma                                                     
//#define Last_Known_EEprom 0xf000ff
//#rom int8 Last_Known_EEprom = {0xf0}    // to store last known good state of relays in EEprom after every change

//-----------------------------------------------------------------------
//  end functions
//-----------------------------------------------------------------------

//***********************************************************************
// interrupts
//***********************************************************************
#int_TIMER0                         // interrupt every 104ms @ 20MHZ or
                                     
void  TIMER0_isr(void) {
   ResponseTimeout++;               // increment GSM response time counter
   Second++;
   if(Second == 10){
      Second = 0;
      GO = 1;
   }
}         
                                                                                       
#int_TIMER1                         // interrupt every 13ms
void  TIMER1_isr(void) {                                                         
                                                                                                               
}                                                       

                           

//-----------RS232 data recieve ISR------------------------------------------------------------
#int_RDA
void RDA_isr(void){
                                     
   #include <sms_receive.c>             
                                                   
}                                 

//----------------------------------------------------------------------
// end interrupts
//----------------------------------------------------------------------

//**********************************************************************
// main
//**********************************************************************
void main() {

   setup_wdt(WDT_128S); 
   
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_8);        //104 ms overflow @ 20MHz
   setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);         //13,1 ms overflow @ 20MHz
                                     
   Delay_ms(10);                                                   
   enable_interrupts(INT_RDA);
   enable_interrupts(GLOBAL);                                                                       
   Not_Initialized = 1;                             
   StartGSM = BOOT_GSM;               
                       
   lcd_init();
   Init_GSM();                               // init GSM module 
                                                                                                                                                                             
   lcd_putc('\f');                         
   delay_ms(30);
                                 
   enable_interrupts(INT_TIMER0);            // enable interrupts
   enable_interrupts(INT_TIMER1);            // enable interrupts
//   Clear_ADDED();                            // clear buffers                                                               
//   Clear_TEMPOR();             
//   Clear_UART_Buffer();
   New_SMS = 0;                              // prepare for SMS                                       
                       
//---------------------------- END INIT ---------------------------------------
                                                                                                                                         
   while(true){     
      if(GO){                     
         GO = 0;         
   
         restart_wdt();                            // WDT is set to 64s, which should be plenty     
         Blink_Led();                           // inform user that program is running                                                                                                                                                                         
      //-----------------------------------------------------------------------------
      //--------------------------- GSM RELATED -------------------------------------
      // Possible problems when we come here:
      // no communication with the module: No_Comm = 1;                                       
      // module not initialized from the begginning: Not_Initialized = 1;
      // not registered: Registered_OK = 0;
      //-----------------------------------------------------------------------------
         
         switch (GSM_Action){   
            case _GET_SMS:{                     // this case is set in interrupt routine
               Blink_CO_Led();                                                                                           
               New_SMS = 0;     
               Get_SMS();                       // read SMS from module and set relevant flags, if the message was correct                         
               GSM_Action = _DELETE_SMS;                                                                               
               break;                                                                                   
            }
      // ............................................................................               
            case _STATUS:{
               Send_Status();                   // STATUS requested, send it                                       
               GSM_Action = _DELETE_SMS;
               break;                                             
            }                                                                                                                                                                                             
      // ............................................................................
            case _DELETE_SMS:{                  //
               Delay_ms(1000);                             
               GSM_Send(ERASE_SMS);                         // delete messages
               Wait_OK_Response();
               if(OK_Response){               
                  GSM_Action = _IDLE; 
               }                                   
               else{                                   
                  lcd_putc('\f');
                  lcd_gotoxy(1,1);                               
                  lcd_putc("DELETE SMS ERROR");
                  while(1);
               }     
               break;                                             
            }
      // ............................................................................               
            case _IDLE:{
               if(New_SMS){
                  New_SMS = 0;
                  GSM_Action = _GET_SMS;                   
               
               }
               else if(Status_Requested){
                  Status_Requested = 0;
                  delay_cycles(1);
                  GSM_Action = _STATUS;
               }                                   
               else{                                                     
                  GSM_Action = _COMM;                                 
               } 
               break;                                             
            }
      // ............................................................................               
            case _COMM:{
               Check_Registration();            // send AT+CREG? and see if GSM is registered on the network
               delay_cycles(1);                 // if it isn't, try to register
               lcd_gotoxy(14,4);                 
                                                 
               if(!Registered_OK){                                           
                  lcd_putc("R:0");
                  Not_Connected_Timer++;        // wait for 40s to see if the module reconnects
                  if(Not_Connected_Timer > 10){
                     Not_Connected_Timer = 10;
                     Not_Initialized = 1;
                     Init_GSM();
                  }
               }                 
               else{
                  delay_cycles(1);              // if it isn't, try to register
                  lcd_putc("R:1");
                  Not_Connected_Timer = 0;
               }                                                                   
               GSM_Action = _IDLE;                           
               break;               
            }
                                                                                           
         }              // GSM_Action switch brace                         
      }
    }                 // while true                                           
                           
}                                                                         
 
               


LCD include is from this forum.


test.h
Code:

#include <18F4520.h>
#device PASS_STRINGS = IN_RAM    //copy all the strings to RAM to allow access with pointers
#device adc=10                   //10 bit AD resolution
#device ICD=TRUE
#FUSES DEBUG                     //No Watch Dog Timer
//#include <stdlib.h>

                                                                                   
#FUSES WDT                       //Watch Dog Timer
#FUSES WDT128                    //Watch Dog Timer uses 1:128 Postscale
#FUSES HS                        //High speed Osc, high power 16MHz-25MHz                                       
#FUSES NOBROWNOUT                //No brownout reset
#FUSES NOLVP                     //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES PUT
//#FUSES INTRC
//#FUSES NOXINST                   //Extended set extension and Indexed Addressing mode disabled (Legacy mode)

//#FUSES NOMCLR
                                                                 
#use delay(crystal=20000000)       //20Mhz clock                                         
//#use delay(internal=32000000)                               
                                                                                         
#use rs232(parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8,stream=GSM,errors)                               

#use i2c(Master,slow,sda=PIN_C4,scl=PIN_C3, force_hw)                                                     

//#use pwm(output=pin_c2, timer=2, frequency=1kHz, duty=3)             

//#use pwm(output=pin_a4, output=pin_b3, timer=1, frequency=1 kHz, duty=75, disable_level=low)



sms_receive.c

Code:


// Flags set by this state machine are:

// New_SMS = 1;                     // indicates that we may have received an SMS, result of "+CIEV" unsolicited code from the module
                                    // it can also be something else, but it doesn't matter. Program just checks if there is a new SMS.
                                    // If there is none, it just goes on.

// GSM_ONLINE = 1;                  // registered to network response, result of "AT+CMGS?" query         
// Status_Requested = 1;            // status report requested via "Status?" command
// Got_OK = 1;
// GSM_ERROR_Flag = 1;                                                                                                   
                                                                                             
// ****************************************************************************

   tmp=getc();                      // get received char and thus also clear interrupt flag                                       
   
// ............................................................................
// Not really needed, everything is done in the state machine. But nice for debugging.

   buffer[next_in]= tmp;            // move received char to the appropriate place in buffer
   ++next_in;                       // increment IN pointer                                                                                                       
                                                                                                 
   if(next_in==BUFFER_SIZE-1) {     // if we have 32, go back to 0         
      next_in=0;                           
      };                                           
                         
// Process reception through state machine
// Possible data from GSM module that will be handled is:                                                                                                                                                                                               
// OK + CR + LF               
// ERROR + CR + LF
// +CREG
// "> "     arrow-space combo! This is the response from GSM module after you send a " send SMS " command
// ERROR
// +CIEV:                                                                                                                                   
// status?  command to receive the status message from GSM
// phone number in format +(country code)(area code)(number), ie +38267999999

// All else is ignored.
                                                                               
  switch (gsm_state) {                                                   
                                                           
//wait for initial character 's', 'O','E', '> ' or '+'                 
      case 0:{
// STATUS?     
         if(tmp == 's' || tmp == 'S'){          //we have "s", could be "status?"
            gsm_state = 2;                      //expecting t
         }
// OK         
         else if(tmp == 'O' || tmp == 'O'){     //we have "O", could be "OK"
            gsm_state = 3;                      //expecting 'K'                                       
         }
// ARROW - SPACE COMBO         
         else if(tmp == '>'){                   //have arrow, vould be "> "                             
            gsm_state = 4;                      //expecting space
         }
// ERROR         
         else if(tmp == 'E'){
            gsm_state = 5;                      // we have 'E', could be "ERROR"
         }
//         
         else if(tmp == '+'){
            gsm_state = 6;                      // we have '+', could be "+CREG" or "+CMGS", phone number or "+CIEV:"     
         }
// FORGOT WHY THIS IS HERE, MOST LIKELY NOT NEEDED :-)         
         else if(tmp == '\n'){
            delay_cycles(1);                                                                                           
         }                                         
         else {                         
            gsm_state = 0;                     
         }
         break;                   
      }

 //******** 'S' WAS THE FIRST CHARACTER, EXPECTING 'STATUS?' ******************   
       
      case 2:{                               //we have 's', expecting 't'
         if(tmp == 't' || tmp == 'T')
            gsm_state = 21;                  //we have "st", expecting 'a'
         else
            gsm_state = 0;                   // 'T' hasn't arrived after 'S', reset
         break;
            }
      case 21:{                              //we have 'st', expecting 'a'
         if(tmp == 'a' || tmp == 'A')
            gsm_state = 22;                  //we have "sta", expecting 't'
         else
            gsm_state = 0;
         break;
            }
      case 22:{                              //we have 'sta', expecting 't'
         if(tmp == 't' || tmp == 'T')
            gsm_state = 23;                  //we have "stat", expecting 'u'
         else
            gsm_state = 0;
         break;
            }
      case 23:{                                                               
         if(tmp == 'u' || tmp == 'U')
            gsm_state = 24;                  //we have "statu", expecting 's'
         else
            gsm_state = 0;
         break;
            }
      case 24:{                              //we have 'statu', expecting 's'
        if(tmp == 's' || tmp == 'S')
            gsm_state = 25;                  //we have "status", expecting '?'
         else
            gsm_state = 0;
         break;
      }                                                                                   
                                                                                         
      case 25:{
         if(tmp == '?'){
// ****************************************************************************
            Status_Requested = 1;            // send status report             
// ****************************************************************************
         }
         gsm_state = 0;                                             
         break;     
      }                                                                           
 //********WE HAVE RECIEVED 'O' AS A FIRST CHARACTER***************************
      case 3:{
         if(tmp == 'K')                      //we have 'OK'
            gsm_state = 31;                  //expecting CR + LF
         else
            gsm_state = 0;
            break;
      }
      case 31:{
        if(tmp == 13)                        //we have OK + CR (binary 13)
            gsm_state = 32;                  //expecting LF (binary 10)
         else
            gsm_state = 0;
         break;
      }
      case 32:{
        if(tmp == 10){                       //we have OK + CR +LF, OK response is complete
// ****************************************************************************
            Got_OK = 1;                      // OK was received from the module
// ****************************************************************************
         }
         gsm_state = 0;                      //reset state machine
         break;                                                                                                                           
                                                 
         }
         
// We received '>' character, could be "> " that indicates that GSM module is ready to accept message from MCU
      case 4:{
         if(tmp == ' '){                     //we have "> ", module ready for SMS message text
            ARROW_SPACE = 1;
         }
         gsm_state = 0;                       
         break;                                                         
      }                                                             
     
// We received 'E', could be ERROR
      case 5:{
         if(tmp == 'R')
            gsm_state = 51;
         else
         gsm_state = 0;
         break; 
   }
      case 51:{
         if(tmp == 'R')
            gsm_state = 52;
         else
         gsm_state = 0;
         break; 
   }
      case 52:{
         if(tmp == 'O')
            gsm_state = 53;                                   
         else
         gsm_state = 0;
         break; 
   }
      case 53:{
         if(tmp == 'R'){
            gsm_state = 0;
//*****************************************           
            GSM_ERROR_Flag = 1; // GSM returned error
//*****************************************           
         }
   }                                                                       

// We've received '+', could be +CREG or +CIEV or telephone number
      case 6:{
         if(tmp == 'C')         
            gsm_state = 61;                     // go check if +CREG or +CMGS or +CIEV

// maybe we have a phone number, store it to a GSM_NUMBER buffer
         else if(tmp =='1'||tmp =='2'||tmp =='3'||tmp =='4'||tmp =='5'||tmp =='6'||tmp =='7'||tmp =='8'||tmp =='9'){   // we might have a phone number. 0 is not a valid first number!!!
            gsm_state = 69;
            Next_Number = 0;
            GSM_NUMBER[Next_Number] = '+';      // put '+' into the first location of buffer
            Next_Number++;
            GSM_NUMBER[Next_Number] = tmp;      // put the received number into second location of buffer
            Next_Number++;
         }   
         else                                                                             
            gsm_state = 0;
         break; 
   }
      case 61:{                                                                                             
         if(tmp == 'R')                      // proceed to look for +CREG
            gsm_state = 62;
         else if(tmp == 'I'){
            gsm_state = 7;                   // look for +CIEV
         }
 
         else                                                 
            gsm_state = 0;
         break;                                           
   }
      case 62:{                             
         if(tmp == 'E')
            gsm_state = 63;             
         else
            gsm_state = 0;
         break; 
   }
      case 63:{                                                                                                                       
         if(tmp == 'G')
            gsm_state = 64;                   
         else
            gsm_state = 0;
         break; 
   }
      case 64:{
         if(tmp == ':')
            gsm_state = 65;
         else
            gsm_state = 0;
         break; 
   }
//////////
     case 65:{
         if(tmp == ' ')
            gsm_state = 66;
         else                                     
            gsm_state = 0;
         break;                   
   }
      case 66:{
         if(tmp == '0' || tmp == '1' || tmp == '2')         // we have +CREG: so far
            gsm_state = 67;
         else
            gsm_state = 0;
         break; 
   }
     case 67:{                                              // we have +CREG: 0 or +CREG: 1 or +CREG: 2 so far
         if(tmp == ',')
            gsm_state = 68;
         else
            gsm_state = 0;
         break; 
   }
   
// A6 module was sending some interesting answers to AT+CREG? when not registered, like +CREG 0,12 or +CREG 0,13
      case 68:{                                 // we have +CREG: 0, or +CREG: 1, or +CREG: 2, so far
     
         if(tmp == '5'){                        // correct answer for roaming, just wait for OK 
            gsm_state = 681;                           
         }                                                                                                         
         else if(tmp == '1'){                   // correct answer for home network, but
            gsm_state = 684;                    // check if something else than OK is coming. This module has options 12 and 13, apparently. And it isn't registered then.
         }
         else{
//***************************************         
            GSM_ONLINE = 0;   // only 1 or 5 are good for registration
//***************************************           
            gsm_state = 0;                      //just inform we are NOT registered
         }
         break;                           
     }                                                   
      case 684:{
         if(tmp == '2' || tmp == '3'){          // everything but letter O behind 1 is wrong here. we hope to catch +CREG: 0, 12
            gsm_state = 0;
//***************************************
            GSM_ONLINE = 0;   //*********
//***************************************                                                                                                   
         }                                   
         else if (tmp == 'O')                                     
            gsm_state = 682;                    // we got letter O, proceed to waiting for K   
         break;   
   }     
//?????     
      case 681:{
        if(tmp != '0'){                         // if it isnt "+CREG = 0,we are registered, handle also the OK that is comming from the module after this
            gsm_state = 682;
         }                                   
         else                                           
            gsm_state = 0;                      //reset state machine
         break;   
   }                                                   
      case 682:{
        if(tmp != 'K'){
            gsm_state = 682;                    //???
// ****************************************************************************
            GSM_ONLINE = 0;              // ***********************************
// ****************************************************************************
         }
         else{
// ****************************************************************************
            GSM_ONLINE = 1;                   // registered to network
// ****************************************************************************
            gsm_state = 0;                    //reset state machine       
         }
         break; 
   }                                                                     
   
//**************** RECEIVING PHONE NUMBER *************************************
   case 69:{                                   
        if((tmp != '"')&&(tmp =='1'||tmp =='2'||tmp =='3'||tmp =='4'||tmp =='5'||tmp =='6'||tmp =='7'||tmp =='8'||tmp =='9'|| tmp == '0')){    // stupid
            GSM_NUMBER[Next_Number] = tmp;                 
            Next_Number++;
         }                           
         else if(tmp == '"'){     
            GSM_NUMBER[Next_Number] = '\0';  // got ", write NULL, end of phone number       
            Next_Number = 0;
            gsm_state = 0;
            break;
         }                                                 
         else {
            Next_Number = 0;
            gsm_state = 0;                                             
         }     
            break;   
   }
// ****************************************************************************
     case 7:{                                // catch +CIEV, that can indicate new SMS
         if(tmp == 'E')                     
            gsm_state = 71;
         else
            gsm_state = 0;
         break; 
   }                                                                         
      case 71:{
         if(tmp == 'V'){                     // we have "+CIEV"
            gsm_state = 0;
// ****************************************************************************
            New_SMS = 1;               // indicate to MAIN that we may have an SMS
// ****************************************************************************
            delay_cycles(1);
         }                                                       
         else                                                       
            gsm_state = 0;                                           
         break;                                                             
      }           

//*****************************************************************************
//we don't have anything good, ERROR   
      default:{
         gsm_state = 0;
         break;
      }
     
                                                 
   }  // switch brace                             
   
   


Last edited by PrinceNai on Sun Aug 11, 2019 8:02 pm; edited 1 time in total
PrinceNai



Joined: 31 Oct 2016
Posts: 109

View user's profile Send private message

PostPosted: Sun Aug 11, 2019 8:00 pm     Reply with quote

I don't know, maybe the code is too long but it didn't let me post it whole. So here is the missing part:

functions.c

Code:


void Blink_Led (void);                                                     
void Blink_CO_Led(void);                                 
void Init_GSM (void);
void Get_Baudrate(void);
void Set_Baudrate ();         
void Clear_UART_Buffer();
void Wait_OK_Response(void);
void Wait_ONLINE_Response(void);
void Wait_Arrow_Space(void);
void Check_Registration(void);
void GSM_Send(char *s);
unsigned ComposeMessage(char* Message);
// ************************** BLINK OK LED ************************************
void Blink_Led(){
   output_low(OK_STATUS);                               
   delay_ms(20);                                         
   output_high(OK_STATUS);                         
}                                         
// ************************** BLINK CO LED ************************************
void Blink_CO_Led(){
   output_low(CO_LED);                               
   delay_ms(20);                                         
   output_high(CO_LED);                                                                                                   
}

//*****************************************************************************
//*****************************************************************************
// GSM module init sequence
// ****************************************************************************
void Init_GSM (void){
   int8 i = 0;             
   int j = 0;
   while (Not_Initialized){               // stay here as long as needed. Preset this variable to 1 before coming here
                                          // there are two ways for exiting, either module initializes or it fails for more than 10 times
   if(j>2){
      break;                              // if the module fails initialisation more than 10 times, quit for now
   }                                      // and let the program continue with measuring
                             
   switch (StartGSM) {     
// *************************** BOOT *******************************************
      case BOOT_GSM:{
         output_low (BOOT);               // turn the module OFF                   
         delay_ms(2000);                                                                             
         output_high (BOOT);              // and back ON                                                                                                                 
         lcd_putc('\f');                  // CLEAR lcd
         delay_ms(100);                                                                           
         lcd_putc("GSM INIT IN:");                                 
         int8 i = 0;
         while(i<BOOT_TIME){               
            i++;                   
            lcd_gotoxy(12,1);
            printf(lcd_putc, "%3u", BOOT_TIME-i);  // display countdown till BOOT
            delay_ms(1000);   
         }
         lcd_putc('\f');                  //CLEAR lcd                                                       
         delay_ms(1000);                                                                                                   
         i=0;                 
         StartGSM = COMM_SPEED;           // next state is setting baudrate to 57.600
         break;                           //
      }
// ********************** GET AND SET BAUDRATE ********************************       
      case COMM_SPEED:{
         Get_Baudrate();                                           
         Set_Baudrate ();             
         if(BaudRate == _baud_rate_error_){     
            StartGSM = BOOT_GSM;                                                       
            j++;                             // count GSM errors and resets
            break;                                   
         }               
         else{                                                           
            StartGSM = SEND_AT;           // next state is AT
            Break;                                                         
         }             
      }                                                                                                                                                                         
// ********************** SEND AT COMMAND ********************************     
      case SEND_AT:{
         lcd_gotoxy(1,1);
         lcd_putc("SENDING AT...");                                     
         delay_ms(300);
         GSM_Send(AT);                   
         Wait_OK_Response();
         if(OK_Response){                                                   
            lcd_putc('\f');               //CLEAR lcd                             
            lcd_gotoxy(1,1);
            lcd_putc("AT OK...");         // display success
            delay_ms(500);
            StartGSM = SEND_ECHO;         // next state is SEND_ECHO         
            break;
         }                                           
         else{
            lcd_gotoxy(1,1);                                             
            delay_ms(30);                                       
            lcd_putc("AT error");
            Delay_ms(2000);
            StartGSM = BOOT_GSM;          // restart GSM
            j++;                          // count GSM errors and resets
            break;           
         }                   
                         
      } // end case
// ************************* SEND ECHO COMMAND ********************************         
      case SEND_ECHO:{
         lcd_gotoxy(1,1);
         lcd_putc("SET ECHO ON");
         delay_ms(300);
         GSM_Send(ATE);                   //ATE1                                   
         Wait_OK_Response();
         if(OK_Response){
            lcd_putc('\f');               //CLEAR lcd
            lcd_gotoxy(1,1);
            lcd_putc("ECHO ON...");       // display success
            delay_ms(500);
            StartGSM = UNSOLICITED;           // next state is SET_GSM       
            break;
         }                                           
         else{                                         
            lcd_gotoxy(1,1);                                             
            delay_ms(30);                                       
            lcd_putc("ECHO error");
            Delay_ms(2000);
            StartGSM = BOOT_GSM;          // restart GSM
            j++;                          // count GSM errors and resets
            break;
         }
      } // end case                                           

// ********************** UNSOLICITED MESSAGES ********************************
      case UNSOLICITED:{
         lcd_putc('\f');                  //CLEAR lcd                                                                                       
         lcd_gotoxy(1,1);
         lcd_putc("UNSOLICITED...");
         delay_ms(300);
         GSM_Send(STOP_UNSOLICITED);      //                                                                             
         if(OK_Response){   
            lcd_putc('\f');               //CLEAR lcd
            lcd_gotoxy(1,1);                                                 
            lcd_putc("UNSOLICITED ON...");      // display success
            delay_ms(500);
            i = 0;
           
            StartGSM = SET_TXT;           // next state is SEND_ECHO         
            break;
         }                                           
         else{
            lcd_gotoxy(1,1);                                             
            delay_ms(30);                                       
            lcd_putc("UNSOLICITED error");                                                                                                       
            Delay_ms(2000);
            StartGSM = BOOT_GSM;          // restart GSM
            j++;                          // count GSM errors and resets
            break;         
         }
      }

// *********************** SET TXT MODE ***************************************
      case SET_TXT:{
         lcd_putc('\f');                  //CLEAR lcd                                                                                 
         lcd_gotoxy(1,1);
         lcd_putc("SET TXT MODE");                                   
         delay_ms(300);
         GSM_Send(TXT);                   // Set message type as TXT
         Wait_OK_Response();
         if(OK_Response){
            lcd_putc('\f');               //CLEAR lcd
            lcd_gotoxy(1,1);                                                               
            lcd_putc("TXT MODE SET...");  // display success
            delay_ms(500);
            StartGSM = DEL_MSG;           // next state is SET_GSM         
            break;
         }                                           
         else{                                                                                                                                           
            lcd_gotoxy(1,1);                                             
            delay_ms(30);                                       
            lcd_putc("TEXT error");
            Delay_ms(2000);
            StartGSM = BOOT_GSM;          // restart GSM
            j++;                          // count GSM errors and resets
            break;
         }                                                                                                                                 
      }
                                                                                           
// ************************** DELETE ALL MESSAGES *****************************
      case DEL_MSG:{
         lcd_putc('\f');                  //CLEAR lcd
         lcd_gotoxy(1,1);
         lcd_putc("DELETING MESSAGES"); 
         delay_ms(300);
         GSM_Send(ERASE_SMS);             // Delete all messages
         Wait_OK_Response();
         delay_ms(300);
         Gsm_Send(READ_SMS);
         Wait_OK_Response();
         if(OK_Response){
            lcd_putc('\f');               //CLEAR lcd
            lcd_gotoxy(1,1);                                               
            lcd_putc("MESSAGES DELETED");                                                 
            delay_ms(500);                 
            StartGSM = CONNECT;
            break;
         }                                       
         else{                                                                                                                           
            lcd_putc('\f');               //CLEAR lcd                               
            lcd_gotoxy(1,1);
            lcd_putc("DELETION ERROR"); 
            delay_ms(500);                                                                                                             
            StartGSM = BOOT_GSM;
            break;
         }
      }
// ************************** CONNECT TO NETWORK *******************************
      case CONNECT:{
         lcd_putc('\f');               //CLEAR lcd
         lcd_gotoxy(1,1);                                                         
         lcd_putc("CONNECT...");
         delay_ms(300);
         GSM_Send(REGISTER_TO_NET);    // Set GSM mode
         Wait_OK_Response();                                                             
         if(OK_Response){
            lcd_putc('\f');            //CLEAR lcd
            lcd_gotoxy(1,1);
            lcd_putc("CONNECTED...");  // display success
            delay_ms(500);
            StartGSM = WAIT_CELL;      // next state is SEND_ECHO         
            break;
         }                                           
         else{
            lcd_gotoxy(1,1);                                             
            delay_ms(30);                                       
            lcd_putc("CONNECTION error");                                       
            Delay_ms(2000);
            StartGSM = BOOT_GSM;       // restart GSM
            j++;                       // count GSM errors and resets
            break;                   
         }                                                                                       
      }    // case brace                           
     
// ************************* WAIT REGISTRATION ********************************
// the biggest problem can be here, if the module doesn't connect to the
// network
// ****************************************************************************
      case WAIT_CELL:{
         lcd_putc('\f');               //CLEAR lcd
         lcd_gotoxy(1,1);
         lcd_putc("WAITING CELL");
         lcd_gotoxy(1,2);
         lcd_putc("REGISTRATION");
         lcd_gotoxy(15,2);
         printf(lcd_putc,"%u", NotResponding);
         Check_Registration();         // query module for registration status
         if(Registered_OK){                                           
            Registered_OK = 0;                                                                                                     
            lcd_putc('\f');            //CLEAR lcd
            lcd_gotoxy(1,1);
            lcd_putc("REGISTERED..."); // display success                           
            delay_ms(500);
            StartGSM = BOOT_GSM;       // next state is SEND_ECHO
            Not_Initialized = 0;       // module initialized, exit loop         
            break;
         }                                           
         else{                                 

// repair this!!!!!!!           
           
            lcd_gotoxy(1,1);
            delay_ms(30);                                       
            lcd_putc("REGISTRATION error");
            Delay_ms(2000);
            StartGSM = BOOT_GSM;       // restart GSM
            j++;                       // count GSM errors and resets
            break;               
         }                             
      }                           
   }     // switch brace
}        // while brace                         
}        // function brace


// ****************************************************************************
// ***************************** GET BAUDRATE *********************************
void Get_Baudrate (){                         
   Baud_Rate_State = _115200;
   Not_Found = 1;
   lcd_putc('\f');                              //CLEAR lcd                                                         
   delay_ms(30);                                                                                     
   lcd_gotoxy(1,1);
   delay_ms(30);                                                   
   lcd_putc("GETTING MODEM SPEED");                                 

//   char *ret;                                   // pointer to the first occurance of a substring in a larger string
   int8 i = 0;               
   while(Not_Found){                            // repeat until you find the baudrate of the modem
      delay_ms(300);                     
   
      switch(Baud_Rate_State){         
// ............................................................................     
         case _57600:{
            set_uart_speed(57600);              // set UART to 57.600 and try to get an "OK"
            lcd_gotoxy(1,2);
            delay_ms(30);                                                   
            lcd_putc("57.600 baud");                             
            Delay_ms(300);                 
            Clear_UART_Buffer();

            while (i<6){
               i++;
               GSM_Send(AT);
               delay_ms(100);
            }
            i = 0;
            GSM_Send(AT);
            Wait_OK_Response();
            if(OK_Response){                                   
               Baud_Rate_State = BaudRateFound;
               BaudRate = _57600baud_; 
               delay_cycles(1);                     
               break;
            }                                                                             
            else{
               Baud_Rate_State = _115200;
               delay_cycles(1);
               break;
            }                                       
         }        // case         
// .............................................................................         
         case _115200:{
            set_uart_speed(115200);           // set UART to 57.600 and try to get an "OK"
            lcd_gotoxy(1,2);
            delay_ms(30);                                                   
            lcd_putc("115.200baud");                   
            Delay_ms(300);
            while (i<6){
               i++;
               GSM_Send(AT);
               delay_ms(100);
            }
            i = 0;           
            GSM_Send(AT);
            Wait_OK_Response();
            if(OK_Response){                                                             
               Baud_Rate_State = BaudRateFound;
               BaudRate = _115200baud_;
               delay_cycles(1);     
               break;
            }                                                             
            else{
               Baud_Rate_State = _57600;
               delay_cycles(1);
               break;
               }                                       
            }                     
// .............................................................................         
         case _38400:{
           
         }
// .............................................................................         
         case _19200:{                                                                                                                               
           
         }
// .............................................................................         
         case _9600:{
           
         }
// .............................................................................         
         case BaudRateFound:{
            Not_Found = 0;
            lcd_putc('\f');                  //CLEAR lcd                       
            delay_ms(30);
            lcd_gotoxy(1,1);       
            delay_ms(30);                                       
            lcd_putc("MODEM SPEED FOUND");
            delay_ms(30);
            lcd_gotoxy(1,2);
            delay_ms(30);
            if(BaudRate == _57600baud_){
               lcd_putc("57.600 baud");
            }                                                 
            if(BaudRate == _115200baud_){                                                                       
               lcd_putc("115.200 baud");               
            }                                                     
            Delay_ms(500);
            break;
         }                                                 
// .............................................................................     
      }     //switch brace
   }        // while brace                 
}           // function brace
                                                       

// ************************** SET BAUDRATE ************************************

void Set_Baudrate (){
int8 Baudrate_Not_Set = 1;
                                                                       
// We want to set the baudrate to 57600. We came here with the unknown modem's UART speed.
// If it is 57600, everything is OK. If not, first change the speed of the modem
// to 57600 and then also PIC UART speed
//      char *ret;                       // pointer to the first occurance of a substring in a larger string
      int8 i = 0;                       
      lcd_putc('\f');                  //CLEAR lcd                       
      delay_ms(30);
      lcd_gotoxy(1,1);
      delay_ms(30);                                       
      lcd_putc("SETTING SPEED");                               
      delay_ms(30);                     
      lcd_gotoxy(1,2);                                   
      delay_ms(30);
      lcd_putc("57.600 BAUD");                                               
   
      if(BaudRate != _57600baud_){     // if the speed is wrong, set correct one
//         Got_OK = 0;
         GSM_Send("AT+IPR=57600\r\n");
         Wait_OK_Response();
         if(!OK_Response){           
            lcd_putc('\f');
            lcd_gotoxy(1,1);                               
            lcd_putc("SET IPR ERROR");
            while(1);   
         }                           
                                         
         set_uart_speed(57600);                                                                 
         delay_ms(500);                                           
      }                                                                         
      while(Baudrate_Not_Set){
         i++;
         if(i>10){
            BaudRate = _baud_rate_error_;    // reboot GSM if for 10 consecutive times baud rate can't be set
            break;
         }
//         Got_OK = 0;
         GSM_Send(AT);                   
         Wait_OK_Response();
         if(OK_Response){                   
            delay_cycles(1);                                                         
            delay_ms(500);                                                                 
            lcd_putc('\f');                  //CLEAR lcd
            delay_ms(30);
            lcd_gotoxy(1,1);                                                   
            delay_ms(30);
            lcd_putc("57.600 BAUD SET");                                                                               
            delay_ms(500); 
            lcd_putc('\f');                  //CLEAR lcd   
            delay_ms(30);
            Baudrate_Not_Set = 0;
         }

   }        // while brace                         
}           // function brace

// ****************************************************************************

//-----------------------------------------------------------------------------
//------------------------ clear UART buffer ----------------------------------
void Clear_UART_Buffer() {         
   next_in=0;                                                                                 
   while (next_in < BUFFER_SIZE){                                                                   
      buffer[next_in] = '\0';                     
      next_in++;
   }
   next_in=0;
}

//-----------------------------------------------------------------------------
//------------------ Send command or data to GSM module -----------------------
void GSM_Send(char *s)           // Send command or data string
{
   while(*s) {                   // as long as you don't encounter NULL
      fputc(*s++);               // send characters to RS232
   }
}                                                                                                         
//-----------------------------------------------------------------------------
//-------------------------- Send SMS------------------------------------------
void Send_Msg(char* Msg_To_Send){
   SMS_In_Process = 1;                             // preload for error response
   SMS_Sent_OK = 0;
   int8 j = 0;
   int8 k = 0;
   SENDING_SMS = ATCMGS;                       
   while(SMS_In_Process){                                   
      switch (SENDING_SMS){
//0                                         
         case ATCMGS:{             
            lcd_putc('\f');                                 
            lcd_gotoxy(1,1);                               
            lcd_putc("SENDING SMS TO");                       
            delay_ms(30);                                             
            lcd_gotoxy(1,2);
            printf(lcd_putc,GSM_NUMBER);
            delay_ms(500);
            fprintf(GSM,"AT+CMGS=\"%s\"\r\n",GSM_NUMBER);   // send SEND SMS command to the module
            SENDING_SMS = ARROWSPACE;         
            break;
         }
//1
         case ARROWSPACE:{
            Wait_Arrow_Space();                             // wait for "> "
            if(ARROW_SPACE){
               ARROW_SPACE = 0;                             // got ARROW_SPACE
               lcd_gotoxy(1,3);                               
               lcd_putc("GOT ARROW_SPACE");                                                                                         
               Delay_ms(400);                   
               GSM_Send(Msg_To_Send);                               // write message to the module               
               SENDING_SMS = CTRLZ;                                 
               delay_ms(50);
            }
            else{
               SENDING_SMS = GSM_ERROR_CONDITION;           // no arrow-space in 4 seconds, error
            }                             
            break;
         }
//2         
         case CTRLZ:{
            lcd_gotoxy(1,3);
            lcd_putc("CTRL+Z SENT    ");
            Delay_ms(200);           
            fputc(0x1A);
            SENDING_SMS = SMS_CONFIRMED;         
            break; 
         }
         
// The problems start about here:         
//3         
         case SMS_CONFIRMED:{
            Wait_OK_Response();                             // GSM should return +CMGS:XXX followed by an OK
            if(OK_Response){                           
               SMSCounter++;
               lcd_putc('\f');                   
               lcd_gotoxy(1,1);                               
               lcd_putc("SMS SENT OK");
               delay_ms(500);
               delay_cycles(1);               
               lcd_putc('\f');                       
               delay_ms(10);                                               
               lcd_gotoxy(17,4); 
               printf(lcd_putc,"%4Lu", SMSCounter);         // display SMS count                                   
               SMS_In_Process = 0;                          // exit while loop
               SMS_Sent_OK = 1;                             // signal succesfull sending
            }
            else{                                                         
               SENDING_SMS = GSM_ERROR_CONDITION;           // didn't get "OK", error
            }
            break;
         }
//4         
         case GSM_ERROR_CONDITION:{
            delay_ms(500);                                  //
            lcd_putc('\f');                   
            lcd_gotoxy(1,1);                               
            lcd_putc("ERROR CONDITION");
            delay_ms(500);             
            GSM_Send(AT);                                   // try to wake up the module with AT           
            Wait_OK_Response();       
            if(OK_Response){
               lcd_putc('\f');                             
               lcd_gotoxy(1,1);                               
               lcd_putc("SECOND TRY");
               delay_ms(500);             
               SENDING_SMS = ATCMGS;                        // GSM responded to AT, try to send the SMS once more
               j++;                                         //
            }
            if(j == 2){                                     // after second try, reboot GSM
               j = 0;
               SENDING_SMS = GSM_REBOOT;
               k = 0;                           
            }                                         
            break;       
         }                                                                 
//5                                               
         case GSM_REBOOT:{
            restart_wdt();                                  // give it time for two more tries
            k++;                                           // count how many times we came here
            Init_GSM();                           
            SENDING_SMS = ATCMGS; 
                                           
            if(k == 2){
               SMS_In_Process = 0;                          // exit while loop
               SMS_Sent_OK = 0;                             // signal unsuccesfull sending
            }
            break;                                                   
         }                                                                       
      }               // switch
   }                  // while
}                     // function 


// ********************* Wait_Arrow_Space *************************************
// uses  ARROW_SPACE  flag set in the receive routine
// It is to be used immediately after issuing the command to the module                                                           
// in order not to miss the "ARROW_SPACE"
// or set ARROW_SPACE = 0 before issuing the command to the module
                                                       
void Wait_Arrow_Space(){                                                     
   int i = 0;
   delay_cycles(1);
   while (i < 80){                  // two ways to exit this loop
      i++;                          // either find "ARROW_SPACE" in four seconds
      if(ARROW_SPACE){
         break;                   
      }                                                           
      else{                                   
         delay_ms(50);              // or timeout
      }
      if(i >= 80){
         ARROW_SPACE = 0;              // ARROW_SPACE not received in 4 seconds
      }     
   }                                                                                         
}                   

// ********************* Wait_OK_Response *************************************
// uses  Got_OK  flag set in the receive routine
// It is to be used immediately after issuing the command to the module
// in order not to miss the "OK"
// or set Got_OK = 0 before issuing the command to the module
                                                       
void Wait_OK_Response(){
   Got_OK = 0;                                         
   OK_Response = 0;                 // init
   OK_Response_Delay = 0;
   delay_cycles(1);
   while (OK_Response_Delay < 200){                  // two ways to exit this loop                 
      OK_Response_Delay++;                          // either find "OK" in four seconds
      if(Got_OK){
         Got_OK = 0;                     
         OK_Response = 1;           // OK received                 
         break;                   
      }                                                     
      else{                                   
         delay_ms(50);              // or timeout
      }
      if(OK_Response_Delay >= 200){
         OK_Response = 0;              // OK not received in 4 seconds
      }       
     
   }                                                                                       
}

// ********************* Wait_Online_Response *********************************                 
// uses  GSM_ONLINE  flag set in the receive routine
// It is to be used immediately after issuing the command to the module       
// in order not to miss the "+CREG= X,Y"
// or set Got_OK = 0 before issuing the command to the module
                                                       
void Wait_ONLINE_Response(){
   int i = 0;                                         
   delay_cycles(1);
   while (i < 80){                  // two ways to exit this loop
      i++;                          // either find "+CREG: 0,1" in four seconds
      if(GSM_ONLINE){               // correct CREG received
         GSM_ONLINE = 0;
         Registered_OK = 1;
         break;                                                                   
      }                                                                         
      else{                                   
         delay_ms(50);             // or timeout
      }
      if(i >= 80){
         GSM_ONLINE = 0;              // +CREG: X,Y not received in 4 seconds
         Registered_OK = 0;
      }           
   }                                                                                                                                       
}

// ****************************************************************************
// *********************** CHECK NETWORK STATUS *******************************
void Check_Registration(){
   GSM_ONLINE = 0;
   GSM_Send(CHECK_REGISTERED);                                           
   Wait_ONLINE_Response();
}

// ****************************************************************************
// ******************* READ SMS MESSAGE FROM THE MODULE ***********************
void Get_SMS(){
   GSM_Send(READ_SMS);                          //Read message from location 1
   Wait_OK_Response();
   if(!OK_Response){
      lcd_putc('\f');
      lcd_gotoxy(1,1);                               
      lcd_putc("GET SMS ERROR");             
      while(1);           
   }                         
}

//-----------------------------------------------------------------------------
//------ Send status SMS to the cell phone number in GSM_NUMBER ---------------
void Send_Status(){
   ComposeMessage(SMS_Message);
   Send_Msg(SMS_Message);
   status_req = 0;                                           
}

//-----------------------------------------------------------------------------
//----------------------- STATUS MESSAGE --------------------------------------
// Compose Status SMS
   unsigned ComposeMessage(char* Message){      // compose status message

   SMS_Message[0] = '\0';
// SMS header                 
   strcat(Message, "Info:\n");                                                                                                               
// body
   strcat(Message, "Success!!!\n");
// SMS footer
   strcat(Message, "End Info"); 
                                                 
   return strlen (Message);                  // copied from somewhere, but neither needed nor used. It could be a void function.
}

PrinceNai



Joined: 31 Oct 2016
Posts: 109

View user's profile Send private message

PostPosted: Tue Aug 13, 2019 6:56 am     Reply with quote

I just realized that something else is missing:

defs.h

Code:


//sensor inputs
#define CO_IN PIN_A0
#define PROX_SENS_IN_NPN PIN_D1
#define PROX_SENS_IN_PNP PIN_A3
#define TEMPERATURE_IN PIN_A5     
#define SMOKE_IN PIN_A4
#define  MQ7_SENSOR    0        // ADC channel 0
#define PWM_SENSE 1              // ADC channel 1             
int16 PWM_Sense_Value = 0;

//alarm leds
#define TEMPERATURE_LED PIN_C0
#define CO_LED PIN_C1                                     
#define SMOKE_LED PIN_E2
#define PELLET_LED PIN_E0                             
#define BOOT PIN_D2
#define OK_STATUS PIN_E1                           
                           
#define INPUT 1
#define OUTPUT 0

//reverse logic, 0 turns the output on!!!
#define  ON 0                   
#define  OFF   1                     


#define  Full  0
#define Empty 1

//#define  TemperatureADChannel   0          //AD chanel for temperature sensor
#define  COADChannel   0                     //AD chanel for CO sensor

#DEFINE SIZE_BUFFER    80                    // Serial Buffer Size
#DEFINE NULL    '\0'                         // Easier to type than '\0'

float  Temp = 0;                       //temperature from 1820 in deg. Celsius

                                       
int8   Second = 0;                     //sets a flag GO every second
int8   GO;                             //starts the execution of the main loop
     
int16 ResponseTimeout = 0;                   // gsm module response time timer
//****************GSM***********************************************************
//**************BUFFERS***************************************************************
//char limiter9[] = "*****-* RS232 buffer *";
#define BUFFER_SIZE 64                       //create 255 byte large buffer
char buffer[BUFFER_SIZE];
int8 next_in = 0;                            //max. next_in =  BUFFER_SIZE -1 !!!!!

//char  limiter1[] = "&&& MESSAGE  &&&";       // delimit buffer for easier debugging

#define MESSAGE_SIZE 180
char SMS_Message[MESSAGE_SIZE];              // SMS message buffer
int8   MessageBufferCounter = 0;                                                                   
                                                                                                   

//char  limiter2[] = "** GSM NUMBER **";

// buffer to hold phone number read from EEPROM or SMS message. This is the number SMS is sent to.
#define   GSM_NUMBER_SIZE   16               // GSM number buffer size
char GSM_NUMBER[GSM_NUMBER_SIZE];            // GSM number buffer   
int8 Next_Number = 0;                        // pointer to the position in buffer

//char  limiter3[] = "%%% TEMPOR %%%";

//char  limiter44[] = "%%% TIME   %%%";


char END[] = "* END BUFFERS ***";                                               


//************************************************************************************

//
int8 status_req = 0;             // Status request variables
                                               
#define EEprom_Max 150           // only first 10 chunks of 16 bytes are for GSM numbers (the routine check if nex                         

// ***************************************************************************
#define     BOOT_TIME   15       // time to wait for the module to be ready, in seconds

int8   StartGSM = 1;
int8   Not_Initialized = 1;      // indicates that GSM module wasn't initialized yet. preset this variable to 1

enum {BOOT_GSM, SEND_AT, SEND_ECHO, SET_TXT, DEL_MSG, UNSOLICITED, CONNECT, WAIT_CELL,COMM_SPEED}; // state machine variables       
                                                                                                                                                                 
int16  SMSCounter;                       //number of SMS's sent                                           

// Set of AT commands
const char AT[] = "AT\r\n";                                    // Every AT command starts with "AT". Sinchronise baud rate with modem.
const char ATE[] = "ATE1\r\n";                                 // enable command echo
const char TXT[] = "AT+CMGF=1\r\n";                            // set TXT messages                                                                         
//const char GSM_MODE[] = "AT+CSCS=\"GSM\"\r\n";                 // Set GSM_MODE
//const char STORE_SIM[] = "AT+CPMS=\"SM\",\"SM\",\"SM\"\r";     // Store on SIM Card
const char READ_SMS[] = "AT+CMGL=\"REC UNREAD\"\r\n";          // Command for reading messages from inbox
const char STOP_UNSOLICITED[] = "AT+CNMI=0,0,0,0,0\r\n";       //                                                                             
// AT+CNMI=0,2,0,0,0  DELA, POŠLJE DIREKTNO:  +CMT: "+38267600917",,"2019/08/03,16:45:23+02"  MESSAGE                             
//AT+CNMI=0,1,0,0,0 DELA, POŠLJE +CMTI:, MORAŠ VPRAŠAT ZA MESSAGE     
const char ERASE_SMS[] = "AT+CMGD=1,4\r\n";                    // Erase all messages           
const char CHECK_REGISTERED[] = "AT+CREG?\r\n";                // Commant to check cell network registration. result: +CREG: 0,1 or 0,5 for roaming
const char REGISTER_TO_NET[] = "AT+CREG=0\r\n";                // register to the network
//const char CHECK_TIME[] = "AT+CCLK?\r\n";                      // check time                                                                                                       
                                                                                   
                                                                                 
int16   gsm_state = 0;
                                                       
#define Max_Response_Time  200
#define Max_No_Response 100              // 10,4s

int8   NotResponding = 0;        // timer for GSM response time
#define   MaxResponseTime 100    // GSM timeout = MaxResponseTime * 100ms ie 5s
char tmp;

     

enum {_115200baud_, _57600baud_, _38400baud_, _baud_rate_error_ };
int8 BaudRate = _115200baud_;

enum {_57600, _115200, _38400, _19200, _9600, BaudRateFound };
int8 Baud_Rate_State = _57600;

int8 Not_Found = 1;
int8 Got_OK = 0;                       

int8 New_SMS = 0;                         
int8 Status_Requested = 0;                                                                               
 
enum {_IDLE, _STATUS, _NUMBER_STATUS, _ADD_NUMBER, _DELETE_NUMBER, _DELETE_SMS, _READ_SMS, _STATUS_TO_ALL, _WRONG_COMMAND_FORMAT, _COMM};
int8 GSM_Action = _IDLE;

int8 OK_Response = 0;                                                         
#define NOT_PARENTHESIS 0                                                               
#define RECORD 1
                                           
signed int Sign = 0;
int8 GSM_ONLINE = 0;
int8 ARROW_SPACE = 0;                         

enum {ATCMGS, ARROWSPACE, CTRLZ, SMS_CONFIRMED, GSM_ERROR_CONDITION, GSM_REBOOT};
unsigned int8 SENDING_SMS = ATCMGS;


int1 Registered_OK = 0;
int8 Not_Connected_Timer = 0;
#define RESET_BUTTON PIN_B1         


enum {WAIT_INFO, COUNT_PARENTHESIS, TIME_INFO};
int8 OK_Response_Delay = 0;
int8 GSM_ERROR_Flag = 0;
int8 SMS_In_Process = 1;
int8 SMS_Sent_OK = 0;

Display posts from previous:   
Post new topic   Reply to topic    CCS Forum Index -> Code Library All times are GMT - 6 Hours
Page 1 of 1

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum


Powered by phpBB © 2001, 2005 phpBB Group