Tuesday 24 April 2012

Week 14: Presentation Day / Engineer's Day for UniKL B.M.I (S1/2012)

Week No: 14
Date: 24/4/2012


Objective :


1) To present the project on the Engineer's Day.
2) To get the evaluation & marks about the project from the assessors.


Content / Procedure :


1) The details about the Engineer's Day for UniKL BMi session S1/2012 :
    Day : Tuesday     
    Date : 24th April 2012     
    Venue : Foyer TTL / Dewan Gemilang Hall     
    Time : 12.00 pm - 5.00 pm

2) Get the turn to be evaluated from the assessor according to the listed number in RPS.


Result and Analysis :


1) The event is conducted by the committees of FYP.
2) All the progress of event going well & smooth.


Conclusion :


1) The winner for the top 20th of project is announced on the end of event and the competition will be proceed on Thursday ( 26/4/2012 ).


2) Final progress is submitted the final report of project and finished up the progress of blog.



Posted by at No comments:

Thursday 19 April 2012

Week 13: Complete Poster & Blog for FYP S1/2012

Week No: 13
Date: 19/4/2012


Title of Activity: Complete poster & blog for FYP S1/2012


Objective: 


1) To design the poster of Machine Remote Controller.
2) To complete up the progress of blog for FYP session S1/2012


Content / Procedure :


1) Design the poster by using Microsoft Power Point.


2) The contains of poster including the brief of  Machine Remote Controller  ( abstract, methodology, results, analysis, conclusion and the reasons why the project did not function according to plan ).


3) Complete up the blog progress ; which is starting from Week 1 until Week 14.


Result and Analysis :


1) The poster will be used during the presentation on the Engineering's Day that will be held on 24th April 2012.


2) It also used as the ' additional method ' to explain brief & details to the assessors besides using the power point slide and prototype about what's the Machine Remote Controller about.


Conclusion :


1) It will give the easiest way to tell the readers about the Machine Remote Controller.


2) To enhance a little bit of knowledge about relationship between combination of electrical, programming and telecommunication protocol concepts.




Picture of poster for Machine Remote Controller:



Posted by at No comments:

Friday 13 April 2012

Week 12: Troubleshoot Project

Week No: 12
Date: 13/4/2012


Title of Activity: Troubleshoot project


Objective:


1) To find out what make the project did not function like we intend it to be.
2) To repair the error that occur so our project can run smoothly.


Content / Procedure:


1) Check all the connection between the circuit
2) Check all the IC used in the circuit
3) Check power supply for main circuit and GSM modem
4) Check the load / motor
5) Check the program that we have write




Result and analysis:


1) Connection between all the circuit and between GSM modem are in good condition, there is no loose cable.


2) All the IC used in the circuit like MAX 232, ULN 2003 and PIC18F452 are in good condition, no broken pin and did not burn.


3) Power supply for the main circuit and GSM modem is also functioning because when we check the input voltage at the main circuit and the GSM modem with multimeter it shows reading.


4) When we test the motor with direct supply, it run as usual and this means it's in good condition.


5) Lastly we have to check the program that we write, because of everything in the project works properly that's mean the only thing that cause the malfunction in our project most likely because of the program. 


Conclusion:


1) It is certain that the error in the project is because of the program that we write.


2) We have to check back the program that we do, because there could be some mistake at the AT command and the protocol that we used in the program.


3) It likely for us to make a mistake while writing this program because it is the first time using the AT command and the telecommunication protocol.


4) Due to lack of time, we could not found the error in the program, thus the project cannot functioning according to our plan.
Posted by at No comments:

Thursday 5 April 2012

Week 11: Test Programming Onto Circuitry

Week No: 11
Date: 5/4/2012


Title of Activity: Test programming onto circuitry


Objective: 


1) To test the program that we have write whether it's working properly or not
2) To see if the all the circuit can interact with each other after we burn the program into IC


Content / Procedure:


1) Burn the programming that we have write into the programmable integrated circuit (PIC).


2) Insert the IC into the slot.


3) Insert the sim card that the number we have write in the program.


4) On the power supply to the main circuit and to the GSM modem.


5) Wait for 5 minute so that the system can be ready.


6) Test the project:
- send short massage service (SMS) to the number that we have assign 
- wait for report of the SMS being reply
- wait a coupe of minute for the project to respond.
- send SMS asking for the status of the load to see if the program can execute the two way communication


Result and analysis:


1) The motion sensor circuit work properly and can detect any movement within 5 meters range.


2) The current sensing circuit work properly in reading the current at the load and convert it into DC voltage.


3) The GSM modem work properly because it can receive the SMS that we send but fail to reply the message to us when we try to do the two way communication.


4) The load driving circuit did not work as we intend it to be because it not switching the load on and off.


5) The main circuit cannot be seen whether it's working or not.


Conclusion:


1) The working part of the project is like what we expected.


2) The load driving circuit is not working as we intend it to be maybe because of the main circuit did not work properly also.


3) The reason for the GSM modem did not reply the SMS when we ask for the status of the load is also because of the error at the main circuit.


4) Is is most likely that the program that we write is the cause of the problem.
Posted by at No comments:

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)