Thursday 29 March 2012

Week 10: Combine All Circuit Development

Week No: 10
Date: 29/3/2012


Title of Activity: Combine all the circuit development


Objective: 


1) To complete the project
2) To see if all the circuitry can interact well with each other
3) To put all the circuit in a one place


Content / Procedure:


1) Take all the circuit and arrange it on a prospect, arrange it so all the circuit will look organized and simple.


2) Drill hole on the prospect to put screw so that the circuit does not move.


3) Connect all the circuit with the appropriate cable. From circuit to circuit we use cable to connect them but from main circuit to GSM we use RS 232 serial connector and for main circuit to computer we use USB to RS 232 serial cable.


4) After done placing the circuit and connect them, I make name tag for each of the component so that it will be easier to explain to the assessor.


Result and analysis: 


1) I put the socket outlet at the top of the prospect for the power supply of main circuit and the GSM modem.


2) At the middle I put the main circuit so it easy to connect with another circuit.


3) At the bottom I put the GSM modem so that it antenna do not get caught with other thing.


4) Load driving circuit and current sensing circuit I put at the side of the prospect to make it easy to connect with the load that is electric motor that I put at separate prospect. 


Conclusion:


1) All the work for combining the circuitry is finish and it is according to plan.


2) The circuit for motor starter control i have to do it separately because it take to much space.


3) The project is starting to come together.




Picture of RS 232 serial connector: 


Figure 1: RS 232 serial connector

Figure 2: RS 232 pin assignments 


Figure 3: USB to RS 232 serial cable


Figure 4: RS 232 connection information 





Posted by at No comments:

Thursday 22 March 2012

Week 9: PIC Program

Week No: 9
Date: 22/3/2012


Title of Activity: PIC program


Objective:


1) To program the PIC according to our design
2) To make the project work as we intend it to be


Content / Procedure:


1) Use C Language 
2) Use PCW compiler 
3) Refer to AT command guide and GSM module guide
4) Burn program into integrated circuit PIC18F452


Conclusion: 


1) It take quite a long time for me to finish this program because I do not use to it.

Figure 1: Schematic Diagram


Program:

GSM_MAIN
#include "SOC.h"
#include "global.h"
#include "macro.h"
#include <string.h>
#include "peripheral.c"
#include "GSM.c"
#include "intr_handler.c"
#include "eeprom_data.c"

//------------------------------------------------------------------------------
// convert ADC digital value to analog
//------------------------------------------------------------------------------
float calc_current(float adc_value)
{
   float current_value;
  
   current_value = ((5*adc_value)/1024);
  
   return(current_value);
}


//------------------------------------------------------------------------------
// MAIN FUNCTION
//------------------------------------------------------------------------------
void main()
{
   char phone_number2[14];
   int test_loop;
   unsigned long current_sense_timer = 0;
   unsigned long send_alert_sms_timer = 0;
   unsigned long start_timeout = 0;
   boolean result;
   float ADC1_val,ADC2_val,ADC3_val,ADC4_val;
   float cur1,cur2,cur3,cur4;
     
   #if DEBUG_ON
      WTF = 0;
   #endif
  
   // Set non 0D 0A to TRUE when startup
   exit_non_OD_OA();
   g_msg_read_in=0;
   //output_high(MOVE_LED);
  
   // I/O and other peripheral setup
   peripheral_setup();
   // UART setup
   serial_init();

 #if (!DISABLE_POWER_ON)
   // Program start - check for GSM first
   fprintf(PC,"\r\nGSM - let GSM modem do internal initialize!");
   // check for call ready and set timeout for 120s
     do
     {
        check_call_ready();
        delay_ms(1000);
        start_timeout++;
     }
    while((!g_ok_to_go) && (start_timeout < 120));
  
   // if time out, something wrong
   if(start_timeout >= 120)
   {
      // for now just stuck here
      fprintf(PC,"\r\nERROR! GSM not ready to communicate!");
      for(;;);
   }
   else
   {
      fprintf(PC," GSM Call Ready!");
   }
  
#endif

   // Initizlize GSM - echo off, clear GSM receive buffer, set to text mode
   fprintf(PC,"\r\nInitialize GSM modem");
   GSM_init();

   // Just test incase EEPROM is used to store phone number - not used
   ep_write_phone_number(phone_number);    // eeprom write oK!
   ep_read_phone_number(phone_number2);    // eeprom read ok!
 
  // MAIN LOOP
   for(;;)
   {
  
      // Check for incoming SMS notification from GSM modem
      check_incoming_data();
      result = FAIL;
     
      // there is incoming data --> decode and extract out SMS msg
      if(g_msg_read_in)
      {
         fprintf(PC,"\r\n\r\nIncoming data!!!");
         g_msg_read_in = 0;
        
         // send read SMS msg to GSM and store data in message array
         result = check_on_read();

         // send SMS msg to PC
         fprintf(PC,"\r\nMSG : ");
         fprintf(PC,message,"\f");
         fprintf(PC,"\r\n\r\nDone!");
      }
     
      // the SMS coming in is valid
      if (result == SUCCESS)
      {
         // Check is it user command is valid and if valid set the output
         for(test_loop = 0; test_loop < 12; test_loop++)
         {
            result = FAIL;
        
            switch(test_loop)
            {
               case 0:
                  if(comp_str(P1_on,MESSAGE_STRING))
                     lamp_output(LAMP_1,TURN_ON);
               break;
              
               case 1:
                  if(comp_str(P2_on,MESSAGE_STRING))
                     lamp_output(LAMP_2,TURN_ON);
                  break;
               
               case 2:
                  if(comp_str(P3_on,MESSAGE_STRING))
                     lamp_output(LAMP_3,TURN_ON);    
                  break;
              
               case 3:
                  if(comp_str(P4_on,MESSAGE_STRING))
                     lamp_output(LAMP_4,TURN_ON);
                  break;

               case 4:
                  if(comp_str(PAll_on,MESSAGE_STRING))
                     lamp_output(LAMP_ALL,TURN_ON);
                  break;

               case 5:
                  if(comp_str(P1_off,MESSAGE_STRING))
                     lamp_output(LAMP_1,TURN_OFF);
                  break;
              
               case 6:
                  if(comp_str(P2_off,MESSAGE_STRING))
                     lamp_output(LAMP_2,TURN_OFF);
                  break;
              
               case 7:
                  if(comp_str(P3_off,MESSAGE_STRING))
                     lamp_output(LAMP_3,TURN_OFF);
                  break;
              
               case 8:
                  if(comp_str(P4_off,MESSAGE_STRING))
                     lamp_output(LAMP_4,TURN_OFF);
                  break;

               case 9:
                  if(comp_str(PAll_off,MESSAGE_STRING))
                     lamp_output(LAMP_ALL,TURN_OFF);
                  break;

               case 10:                                      // special case
                  if(comp_str(status_in,MESSAGE_STRING))
                     g_got_msg_to_send = SUCCESS;
                  break;

               default:
                  break;
            }
         }
        
         current_sense_timer = 0;
      }

      // send sms if STAT command was received
      if(g_got_msg_to_send)
      {
         GSM_send(0,1);
         g_got_msg_to_send = FAIL;
      }
     
      // read all the ADC
      SET_ADC_CHANNEL(0);
      ADC1_val = READ_ADC(ADC_START_AND_READ);
      delay_us(200);
      cur1 = calc_current(ADC1_val);
      SET_ADC_CHANNEL(1);
      ADC2_val = READ_ADC(ADC_START_AND_READ);
      delay_us(200);
      cur2 = calc_current(ADC2_val);
      SET_ADC_CHANNEL(2);
      ADC3_val = READ_ADC(ADC_START_AND_READ);
      delay_us(200);
      cur3 = calc_current(ADC3_val);
      SET_ADC_CHANNEL(3);
      ADC4_val = READ_ADC(ADC_START_AND_READ);
      delay_us(200);
      cur4 = calc_current(ADC4_val);

      // update value of to PC
      if(current_sense_timer == 10)
      {
         fprintf(PC,"\r\n%2.3f A",cur1);
         fprintf(PC,"   %2.3f A",cur2);
         fprintf(PC,"   %2.3f A",cur3);
         fprintf(PC,"   %2.3f A",cur4);
         current_sense_timer = 0;
      }
     
      // Check movement on sensor
      if(input(MOVE_SENSE))
      {
         // might be sending SMS... but not so frequent
         // but LED make sense
         output_low(MOVE_LED);
         if(g_intruder_detected == 0)
         {
            g_intruder_detected = SUCCESS;
            send_alert_sms_timer = 0;
         }
      }
      else
      {
         output_high(MOVE_LED);
      }
     
      // in 1 minutes send 1 sms alert house owner
      if(!input(MOVE_SENSE_EN) && (send_alert_sms_timer == 60) && g_intruder_detected)
      {
         fprintf(PC,"\r\n\r\nIntruder Msg Send!\r\n");
         GSM_send(intruder_msg,0);
         g_intruder_detected = FAIL;
         send_alert_sms_timer = 0;
      }
  
      current_sense_timer++;
      send_alert_sms_timer++;
      delay_ms(1000);
   }
}


GSM.c
#include "serial.c"

//------------------------------------------------------------------------------
// Enter No OD OA check
//------------------------------------------------------------------------------
void enter_non_OD_OA(void)
{
   g_read_int = 1;
}

//------------------------------------------------------------------------------
// Exit No OD OA check
//------------------------------------------------------------------------------
void exit_non_OD_OA(void)
{
   g_read_int = 0;
}

//------------------------------------------------------------------------------
// find size of character
//------------------------------------------------------------------------------
int size_of_char(int8 input_v)
{
   int temp;
  
   if (r_ok == input_v)
   {
      temp = sizeof(r_ok);
   }
   else if(msg_in == input_v)
   {
      temp = sizeof(msg_in);
   }
   else if(ate_cmd == input_v)
   {
      temp = sizeof(ate_cmd);
   }
   else if(text_cmd == input_v)
   {
      temp = sizeof(text_cmd);
   }
   else if(del_msg_cmd == input_v)
   {
      temp = sizeof(del_msg_cmd);
   }
   else if(send_msg_cmd == input_v)
   {
      temp = sizeof(send_msg_cmd);
   }
   else if(read_msg_cmd == input_v)
   {
      temp = sizeof(read_msg_cmd);
   }  
   else if(message == input_v)
   {
      temp = sizeof(message);
   }
   else if(P1_on == input_v)
   {
      temp = sizeof(P1_on);
   }
   else if(P2_on == input_v)
   {
      temp = sizeof(P2_on);
   }
   else if(P3_on == input_v)
   {
      temp = sizeof(P3_on);
   }
   else if(P4_on == input_v)
   {
      temp = sizeof(P4_on);
   }
   else if(P1_off == input_v)
   {
      temp = sizeof(P1_off);
   }
   else if(P2_off == input_v)
   {
      temp = sizeof(P2_off);
   }
   else if(P3_off == input_v)
   {
      temp = sizeof(P3_off);
   }
   else if(P4_off == input_v)
   {
      temp = sizeof(P4_off);
   }
   else if(intruder_msg == input_v)
   {
      temp = sizeof(intruder_msg);
   }
   else if(phone_number == input_v)
   {
      temp = sizeof(phone_number);
   }
   else if(status_in == input_v)
   {
      temp = sizeof(status_in);
   }
   else if(call_ready == input_v)
   {
      temp = sizeof(call_ready);
   }
   else if(PAll_on == input_v)
   {
      temp = sizeof(PAll_on);
   }
   else if(PAll_off == input_v)
   {
      temp = sizeof(PAll_off);
   }
   else if(status_out1 == input_v)
   {
      temp = sizeof(status_out1);
   }
   else if(at_basic == input_v)
   {
      temp = sizeof(at_basic);
   }
   else if(r_error == input_v)
   {
      temp = sizeof(r_error);
   }
   else if(r_ok_echo == input_v)
   {
      temp = sizeof(r_ok_echo);
   } 
   else
   {
      temp = 1;
   }
  
   return(temp);
}


//------------------------------------------------------------------------------
// compare string (based on buffer TYPE)
//------------------------------------------------------------------------------
boolean comp_str(int *input, int buffer_type)
{
   int i;
   int ok_count = 0;
   boolean error = FAIL;
   int max_size;
  
   max_size = size_of_char(input);
   
   for(i=0;i<max_size;i++)
   {
      switch (buffer_type)
      {
         case DATA_INPUT_STRING:
            if(data_input[i] == *input)
            {
               ok_count++;
            }
            break;
       
         case INCOMING_MSG_STRING:
            if(incoming_msg[i] == *input)
            {
               ok_count++;
            }
            break;           

         case MESSAGE_STRING:
            if(message[i] == *input)
            {
               ok_count++;
            }
            break;           
      }
     
      input++;
   }

   // FOR DEBUGGING PURPOSES
   //fprintf(PC,"\r\nok_count = %d ",ok_count);      
   //fprintf(PC,"\r\nmax_size = %d ",max_size);
   //fprintf(PC,data_input,"\r\n\f ");
  
   if(ok_count == max_size)
   {
      error = SUCCESS;
   }
  
   return(error);
}


//------------------------------------------------------------------------------
// send character to GSM modem
//------------------------------------------------------------------------------
void send_char(int *input)
{
   int i;
   int max_size;

   max_size = size_of_char(input);

   for(i=0;i<max_size;i++)
   {
      delay_ms(100);
      // FOR DEBUGGING PURPOSES
      #if DEBUG_ON
      if(WTF == 1)
         fprintf(PC,"%c",*input);
      #endif
      fprintf(GSM_MODEM,"%c",*input++);
   }
}

//------------------------------------------------------------------------------
// send special character to GSM modem
//------------------------------------------------------------------------------
void send_special_char(int i)
{
   delay_ms(100);
   // FOR DEBUGGING PURPOSES
   #if DEBUG_ON
   if(WTF == 1)
      fprintf(PC,"%c",special_char[i]);
   #endif
   fprintf(GSM_MODEM,"%c",special_char[i]);
}

//------------------------------------------------------------------------------
// send number to GSM modem
//------------------------------------------------------------------------------
void send_num(unsigned long num)
{
   delay_ms(100);
   // FOR DEBUGGING PURPOSES
   #if DEBUG_ON
   if(WTF == 1)
      fprintf(PC,"%lu",num);
   #endif
   fprintf(GSM_MODEM,"%lu",num);    
}

//------------------------------------------------------------------------------
// Reset GSM by sending dummy command
//------------------------------------------------------------------------------
void send_dummy_command(void)
{
   enter_non_OD_OA();
   incoming_msg_cleanup();
   pInData_init();
   fprintf(GSM_MODEM,"x");
   send_special_char(return_c);
   exit_non_OD_OA();
   buffer_cleanup();
   pdata_init();
}

//------------------------------------------------------------------------------
// check for OK reply from GSM modem
//------------------------------------------------------------------------------
boolean check_r_ok(void)
{
   boolean error = FAIL;

   delay_ms(250);
  
   if(g_HBI_SPP)
   {
      error = comp_str(r_ok, DATA_INPUT_STRING);
      buffer_cleanup();
      g_HBI_SPP = FAIL;
   }

   return(error);
}

//------------------------------------------------------------------------------
// Send AT basic command
//------------------------------------------------------------------------------
void check_at_cmd(void)
{
   boolean error;
  
   do
   {              
      send_char(at_basic);                                //ECHO off   
      error = check_r_ok();
   }
   while(error != SUCCESS);
}

//------------------------------------------------------------------------------
// Send echo off command
//------------------------------------------------------------------------------
void echo_off(void)
{
   boolean error;
  
   send_char(ate_cmd);
   send_char(ate_cmd);
   send_char(ate_cmd);
  
   do
   {             
      send_char(ate_cmd);                                //ECHO off   
      error = check_r_ok();
   }
   while(error != SUCCESS);
}

//------------------------------------------------------------------------------
// Send clear all read message command
//------------------------------------------------------------------------------
void clear_read_msg(void)
{
   unsigned long i;
   boolean error;
  
   for(i=1;i<31;i++)
   {
      do                                              //Clear all MSG
      {       
         send_char(del_msg_cmd);
         send_num(i);
         send_special_char(return_c);
         error = check_r_ok();
      }
      while(error != SUCCESS);
      fprintf(PC,".");
   }  
}

//------------------------------------------------------------------------------
// Send clear current read message command
//------------------------------------------------------------------------------
void clear_current_read_msg(void)
{
   unsigned long i;
   boolean error;

   i = 1;
  
   do                                              //Clear current MSG
   {       
      send_char(del_msg_cmd);
      send_num(i);
      send_special_char(return_c);
      error = check_r_ok();
   }
   while(error != SUCCESS);
 
}

//------------------------------------------------------------------------------
// Send text mode command
//------------------------------------------------------------------------------
void set_text_mode(void)
{
   boolean error;
  
   do
   {      
      send_char(text_cmd);                                   //Text mode
      error = check_r_ok();
   }
   while(error != SUCCESS);    
}

//------------------------------------------------------------------------------
// GSM Initialization
//------------------------------------------------------------------------------
void GSM_init(void)
{ 
   echo_off();
   fprintf(PC,"\r\nEcho was set to off!");
   delay_ms(1000);
  
   fprintf(PC,"\r\nClearing inbox");
   clear_read_msg();
   fprintf(PC,"<-- Inbox was emptied!");
   delay_ms(1000);

   set_text_mode();
   fprintf(PC,"\r\nText mode set!");
   delay_ms(1000);
  
   fprintf(PC,"\r\n\r\nGSM SYSTEM READY!");
}

//------------------------------------------------------------------------------
// Send message to GSM modem
//------------------------------------------------------------------------------
boolean GSM_send(int8 input, boolean lamp_status)
{
   boolean error;
   int i,port_data,temp;

   do
   {
      delay_ms(250);

      //Send dummy byte
      send_dummy_command();
      buffer_cleanup();
      pdata_init();
      incoming_msg_cleanup();
      pInData_init();
     
      check_at_cmd();
      set_text_mode();
     
      // To avoid stuck in OD OA check in interrupt handler we just take data
      enter_non_OD_OA();                       
      fprintf(GSM_MODEM,"AT+CMGS=");
      fputc(0x22,GSM_MODEM);
      fprintf(GSM_MODEM,"+60122717486");
      fputc(0x22,GSM_MODEM);
      fputc(0x0D,GSM_MODEM);
      delay_ms(50);
      error = comp_str(r_error,INCOMING_MSG_STRING);
   }
   while(error == SUCCESS);         // if Error msg receive try again
  
   buffer_cleanup();
   pdata_init();
   incoming_msg_cleanup();
   pInData_init();
     
   if(lamp_status)
   {
      port_data = LAT_PORTB >> 2;
      send_char(status_out1);
        
      for(i = 0; i < 4; i++)
      {
         temp = port_data & 1;
         switch (i)
         {
            case 0:
               if(temp)
                  send_char(P1_off);
               else
                  send_char(P1_on);
               break;

            case 1:
               if(temp)
                  send_char(P2_off);
               else
                  send_char(P2_on);
               break;

            case 2:
               if(temp)
                  send_char(P3_off);
               else
                  send_char(P3_on);
               break;

            case 3:
               if(temp)
                  send_char(P4_off);
               else
                  send_char(P4_on);
               break;
         }
         port_data >>= 1;
      }
   }
   else
   {
      send_char(input);
   }
   fputc(0x1A,GSM_MODEM);
  
   delay_ms(1000);
   buffer_cleanup();
   incoming_msg_cleanup();
   pdata_init();
   pInData_init();
  
   // Exit the non OD OA to enable OD OA check
   exit_non_OD_OA();
  
   clear_current_read_msg();
  
   return(error);
}

//------------------------------------------------------------------------------
// check message from a AT read sms command
//------------------------------------------------------------------------------
boolean search_for_message(void)
{
   int counter;
   int i;
   int OD_OA_counter;
  
   counter = 0;
   OD_OA_counter=0;
     
   for(counter=0;counter<max_buffer_size;counter++)
   {
      if(incoming_msg[counter] == 0x0D)
      {
         OD_OA_counter++;
         if(OD_OA_counter == 2)
         {
            break;
         }
      }
   }
     
   i=0;
   do
   {
      *pmessage++=incoming_msg[counter+i];
      i++;
   }
   while(incoming_msg[counter+i] != 0x0D);

   *pmessage = 0;
  
   return(SUCCESS);
}

//------------------------------------------------------------------------------
// Send get msg command from GSM
//------------------------------------------------------------------------------
boolean GSM_read_sms(void)
{
   boolean error;
   unsigned long number;
   number = 1;
  
   enter_non_OD_OA();
   incoming_msg_cleanup();
   message_cleanup();
   pmessage_init();
   pInData_init();
  
   send_char(read_msg_cmd);
   send_num(number);
   send_special_char(return_c);
     
   delay_ms(500);
   exit_non_OD_OA();
  
   error = search_for_message();
   clear_current_read_msg();

   return(error);
}

//------------------------------------------------------------------------------
// read incoming msg
//------------------------------------------------------------------------------
BOOLEAN check_on_read(void)
{
   boolean error = FAIL;
  
   error = GSM_read_sms();
   g_HBI_SPP = FAIL;
  
   return(error);
}

//------------------------------------------------------------------------------
// check for incoming msg from GSM modem
//------------------------------------------------------------------------------
void check_incoming_data(void)
{
   boolean error = FAIL;

   if(g_HBI_SPP)
   {
      error = comp_str(msg_in,DATA_INPUT_STRING);
      g_HBI_SPP = FAIL;
   }
  
   if(error)
   {
      g_msg_read_in = SUCCESS;
   }
}

//------------------------------------------------------------------------------
// check Call Ready
//------------------------------------------------------------------------------
void check_call_ready(void)
{
   boolean error = FAIL;

   if(g_HBI_SPP)
   {
      error = comp_str(call_ready,DATA_INPUT_STRING);
      g_HBI_SPP = FAIL;
   }
  
   if(error)
   {
      g_ok_to_go = SUCCESS;
   }
}


Global.h


#define  DEBUG_ON             FALSE
#define  DISABLE_POWER_ON     TRUE

#byte    LAT_PORTB      = 0xF8A

//------------------------------------------------------------------------------
// enum for the special character
//------------------------------------------------------------------------------
enum
{
   ctrl_z         = 0,
   return_c       = 1
};

//------------------------------------------------------------------------------
// enum for the character as above
//------------------------------------------------------------------------------
enum
{
   FAIL           = 0,
   SUCCESS        = 1,
};

enum
{
   DATA_INPUT_STRING    = 0,
   INCOMING_MSG_STRING  = 1,
   MESSAGE_STRING       = 2
};

//------------------------------------------------------------------------------
// char array for special character
//------------------------------------------------------------------------------
const char special_char[10]={0x1A,0x0D};              // Used in send msg

//------------------------------------------------------------------------------
// GSM Reply table and protocol
//------------------------------------------------------------------------------
char r_ok[2]            ={'O','K'};
char r_error[7]         ={0x0D,0x0A,'E','R','R','O','R'};
char r_ok_echo[7]       ={'A','T',0x0D,0x0D,0x0A,'O','K'};

char at_basic[3]        ={'A','T',0x0D};
char ate_cmd[5]         ={'A','T','E','0',0x0D};
char text_cmd[10]       ={'A','T','+','C','M','G','F','=','1',0x0D};
char del_msg_cmd[8]     ={'A','T','+','C','M','G','D','='};
char send_msg_cmd[8]    ={'A','T','+','C','M','G','S','='};
char read_msg_cmd[8]    ={'A','T','+','C','M','G','R','='};
char msg_in[5]          ={'+','C','M','T','I'};
char P1_on[7]           ={0x0D,0x0A,'P','1',' ','O','N'};
char P2_on[7]           ={0x0D,0x0A,'P','2',' ','O','N'};
char P3_on[7]           ={0x0D,0x0A,'P','3',' ','O','N'};
char P4_on[7]           ={0x0D,0x0A,'P','4',' ','O','N'};
char PAll_on[8]         ={0x0D,0x0A,'A','L','L',' ','O','N'};
char P1_off[8]          ={0x0D,0x0A,'P','1',' ','O','F','F'};
char P2_off[8]          ={0x0D,0x0A,'P','2',' ','O','F','F'};
char P3_off[8]          ={0x0D,0x0A,'P','3',' ','O','F','F'};
char P4_off[8]          ={0x0D,0x0A,'P','4',' ','O','F','F'};
char PAll_off[9]        ={0x0D,0x0A,'A','L','L',' ','O','F','F'};
char status_in[6]       ={0x0D,0x0A,'S','T','A','T'};
char status_out1[6]     ={'S','T','A','T','U','S'};
char call_ready[10]      ={'C','a','l','l',' ','R','e','a','d','y'};

char intruder_msg[17]   ={'I','n','t','r','u','d','e','r',' '
                         ,'i','n',' ','h','o','u','s','e'};
                         
char message[60];
char *pmessage;
char phone_number[14]={0x22,'+','6','0','1','9','6','1','2','1','2','5','7',0x22};

//------------------------------------------------------------------------------
// Definition
//------------------------------------------------------------------------------
#define max_buffer_size       100


//------------------------------------------------------------------------------
// Global Variable
//------------------------------------------------------------------------------
char data_input[max_buffer_size];                   // data array
char *pdata;                           // pointer to data buffer
char incoming_msg[max_buffer_size];
char *pInData;
boolean g_msg_read_in = FAIL;
boolean g_ok_to_go = FAIL;
boolean g_HBI_SPP = FAIL;
boolean g_read_int = FAIL;
boolean g_got_msg_to_send = FAIL;
boolean g_intruder_detected = FAIL;
#if DEBUG_ON
boolean WTF;
#endif


 SOC.h

//------------------------------------------------------------------------------
// SOC
//------------------------------------------------------------------------------
#include <18F452.h>

//------------------------------------------------------------------------------
// Special funtion
//------------------------------------------------------------------------------
#device ICD=TRUE
#device adc=10

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
#FUSES H4                       //High speed osc with HW enabled 4X PLL
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOOSCSEN                 //Oscillator switching is disabled, main oscillator is source
#FUSES NOBROWNOUT               //No brownout reset
#FUSES BORV20                   //Brownout reset at 2.0V
#FUSES NOPUT                    //No Power Up Timer
#FUSES STVREN                   //Stack full/underflow will cause reset
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOWRT                    //Program memory not write protected
#FUSES NOWRTD                   //Data EEPROM not write protected
#FUSES NOWRTB                   //Boot block not write protected
#FUSES NOWRTC                   //configuration not registers write protected
#FUSES NOCPD                    //No EE protection
#FUSES NOCPB                    //No Boot Block code protection
#FUSES NOEBTR                   //Memory not protected from table reads
#FUSES NOEBTRB                  //Boot block not protected from table reads

//------------------------------------------------------------------------------
// clock and RS232 Definition
//------------------------------------------------------------------------------
#use delay(clock=40000000)
#use rs232(baud=115200,xmit=PIN_C6,rcv=PIN_C7,PARITY=N,bits=8,BRGH1OK,STREAM=GSM_MODEM)
#use rs232(baud=9600,parity=N,xmit=PIN_D0,rcv=PIN_D1,bits=8,FORCE_SW,STREAM=PC)


 serial.c

//------------------------------------------------------------------------------
// Serial related deifinition
//------------------------------------------------------------------------------
#define  CTS      pin_c5
#define  RTS      pin_c4   

//------------------------------------------------------------------------------
// clear receive buffer
//------------------------------------------------------------------------------
void buffer_cleanup(void)
{
   int i;
  
   for(i=0;i<max_buffer_size;i++)
   {
      data_input[i]=0;
   }
}

//------------------------------------------------------------------------------
// clear incoming message buffer (with AT command) when read command send
//------------------------------------------------------------------------------
void incoming_msg_cleanup(void)
{
   int i;
  
   for(i=0;i<max_buffer_size;i++)
   {
      incoming_msg[i]=0;
   }
}

//------------------------------------------------------------------------------
// clear message buffer
//------------------------------------------------------------------------------
void message_cleanup(void)
{
   int i;
  
   for(i=0;i<max_buffer_size;i++)
   {
      message[i]=0;
   }
}

//------------------------------------------------------------------------------
// RTS activate - low
//------------------------------------------------------------------------------
void activate_rts(void)
{
   output_low(RTS);
}

//------------------------------------------------------------------------------
// RTS deactivate - high
//------------------------------------------------------------------------------
void deactivate_rts(void)
{
   output_high(RTS);
}

//------------------------------------------------------------------------------
// Serial Initialization
//------------------------------------------------------------------------------
void serial_init(void)
{
   boolean dummy;
  
   pdata_init();
   buffer_cleanup();
   incoming_msg_cleanup();
   deactivate_rts();
   delay_ms(10);
   activate_rts();
   dummy = input(CTS);
}


Peripheral.c

#define  P4_OUT         pin_b5
#define  P3_OUT         pin_b4
#define  P2_OUT         pin_b3
#define  P1_OUT         pin_b2

#define  MOVE_SENSE     pin_d4

#define  MOVE_SENSE_EN  pin_e0
#define  MOVE_LED       pin_e2

typedef enum
{
   LAMP_1         = 1,
   LAMP_2         = 2,
   LAMP_3         = 3,
   LAMP_4         = 4,
   LAMP_ALL       = 5,
  
   TURN_ON        = 0xFE,
   TURN_OFF       = 0xFF
}LAMP_SECTION_T;

//------------------------------------------------------------------------------
// Set LAMP on or off
//------------------------------------------------------------------------------
void lamp_output(LAMP_SECTION_T lamp_position, LAMP_SECTION_T turn_on_off)
{
   switch(lamp_position)
   {
      case LAMP_1:
         if(turn_on_off == TURN_ON)
            output_low(P1_OUT);
         else
            output_high(P1_OUT);
         break;

      case LAMP_2:
         if(turn_on_off == TURN_ON)
            output_low(P2_OUT);
         else
            output_high(P2_OUT);
         break;

      case LAMP_3:
         if(turn_on_off == TURN_ON)
            output_low(P3_OUT);
         else
            output_high(P3_OUT);
         break;
        
      case LAMP_4:
         if(turn_on_off == TURN_ON)
            output_low(P4_OUT);
         else
            output_high(P4_OUT);
         break;

      case LAMP_ALL:
         if(turn_on_off == TURN_ON)
         {
            output_low(P1_OUT);
            output_low(P2_OUT);
            output_low(P3_OUT);
            output_low(P4_OUT);
         }
         else
         {
            output_high(P1_OUT);
            output_high(P2_OUT);
            output_high(P3_OUT);
            output_high(P4_OUT);        
         }
         break;

      default:
         break;
   };
}

//------------------------------------------------------------------------------
// peripheral initialization
//------------------------------------------------------------------------------
void peripheral_setup(void)
{
   setup_adc_ports(AN0_AN1_AN2_AN3_AN4);
   setup_adc(ADC_CLOCK_DIV_64);
   setup_psp(PSP_DISABLED);
   setup_spi(SPI_SS_DISABLED);
   setup_wdt(WDT_OFF);
   setup_timer_0(RTCC_INTERNAL);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
  
   delay_ms(500);
   lamp_output(LAMP_ALL,TURN_OFF);
  
   enable_interrupts(INT_RDA);
   enable_interrupts(GLOBAL);
}


Eeprom_data.c

//------------------------------------------------------------------------------
// definition to start addres of EEPROM Memory
//------------------------------------------------------------------------------
#define eep_phone_number               0x00
#define eep_phone_number_size          15
#define eep_phone_number_end           eep_phone_number + eep_phone_number_size



//------------------------------------------------------------------------------
// Write Phone number to EEPROM
//------------------------------------------------------------------------------
void ep_write_phone_number(int8 *phone_number)
{
   int8 counter;
  
   for(counter=eep_phone_number;counter<eep_phone_number_end;counter++)
      write_eeprom(counter,*phone_number++);
}

//------------------------------------------------------------------------------
// Read Phone Number from EEPROM
//------------------------------------------------------------------------------
void ep_read_phone_number(int8 *phone_number)
{
   int8 counter;
  
   for(counter=eep_phone_number;counter<eep_phone_number_end;counter++)
      *phone_number++=read_eeprom(counter);
}


intr_handler.c

//------------------------------------------------------------------------------
// Serial Comm Data Receive Interrupt Handler
//------------------------------------------------------------------------------

#INT_RDA
void int_RDA_isr(void)
{
   char temp;

   if(!g_read_int)
   {
      temp=fgetc(GSM_MODEM);        
      if(temp == 0x0D)
      {
         temp=getch(GSM_MODEM);    
         if(temp == 0x0A)
         {
            do
            {
               temp=getch(GSM_MODEM);          
               *pdata++=temp;
            }
            while(temp != 0x0D);
           
            temp=getch(GSM_MODEM);             
            if(temp == 0x0A)
            {
               g_HBI_SPP = SUCCESS;
            }
         }
      }
   }
   else
   {
      *pInData++=fgetc(GSM_MODEM);
   }

   pdata_init();
}



Posted by at No comments:
Subscribe to: Posts (Atom)