Programe

#define P16F877A
//Functions
#define MX_CLK_SPEED 20000000
#ifdef _BOOSTC
#include <system.h>
#endif
#ifdef HI_TECH_C
#include <pic.h>
#endif
//Configuration data
#ifdef _BOOSTC
#pragma DATA 0x2007, 0x3f72
#endif
#ifdef HI_TECH_C
__CONFIG(0x3f72);
#endif
//Internal functions
#include "internals.c"
//Macro function declarations
void FCM_check(MX_UINT8 FCL_ADC_NO);
//Variable declarations
#define FCSZ_SEND_SMS 75
#define FCSZ_STRCNV 2
#define FCSZ_IN_SMS 10
#define FCV_FALSE (0)
#define FCV_TRUE (1)
MX_BOOL FCV_ON_OFF = (0);
MX_UINT8 FCV_LOOP = (0x1);
MX_UINT8 FCV_CHECK = (0x0);
MX_BOOL FCV_IN = (0);
MX_CHAR FCV_SEND_SMS[FCSZ_SEND_SMS] = ("");
MX_CHAR FCV_STRCNV[FCSZ_STRCNV] = ("");
MX_CHAR FCV_IN_SMS[FCSZ_IN_SMS] = ("");
MX_UINT8 FCLV_LOOP1;
//GSM(0): //Defines:
/**** Macro Substitutions ****
a = Unique Reference
b = Uart Channel (0-software / 1-4 hardware)
c = tx pin
d = tx port
e = rx pin
f = rx port
g = flow control (0-Off / 1-On)
h = cts pin
i = cts port
j = rts pin
k = rts port
l = echo enable (0-Off / 1-On)
m = Number of scripts
n = Script 1
o = Script 2
p = Script 3
q = Script 4
******************************/
#define GSM_1_UART_Init CAL_APPEND(FC_CAL_UART_Init_, GSM_1_MX_UART_UREF)
#define GSM_1_UART_Send CAL_APPEND(FC_CAL_UART_Send_, GSM_1_MX_UART_UREF)
#define GSM_1_UART_Receive CAL_APPEND(FC_CAL_UART_Receive_, GSM_1_MX_UART_UREF)
extern void GSM_1_UART_Init();
extern void GSM_1_UART_Send(MX_UINT16 nChar);
extern MX_SINT16 GSM_1_UART_Receive(MX_UINT8 nTimeout);
//This section details the static defines, prototypes and functions.
#define GSM_1_GSM_STRING_ARRAY_SIZE 80
#define GSM_1_MSG_ARRAY_SIZE 80
#ifndef GSM_DEFINES
#define GSM_DEFINES
#define GSM_RESPONSE_OK
1
#define GSM_RESPONSE_ERROR
2
#define GSM_RESPONSE_CONNECT
3
#define GSM_RESPONSE_NOCARRIER 4
#define GSM_RESPONSE_AUDIO
5
#define GSM_RESPONSE_PAIR
6
#define GSM_RESPONSE_RING
7
#define GSM_EXPECTECHO
#define GSM_CHAR_CR
#define GSM_CHAR_LF
13
10
//Timeout within the <BT_Send_Command> function (ms)

#define GSM_SENDCMD_TIMEOUT 75
//Timeout within the <BT_Wait_For_Response> function (ms)
#define GSM_RESPONSE_TIMEOUT 75
//Timeout within the <BT_String_Receive> function (ms)

#define GSM_STRINGRX_TIMEOUT 150
//Timeout within the <BT_Send_Script> function (ms)
#define GSM_SENDSCRIPT_TIMEOUT 75
#endif
//common global variables
MX_UINT8 GSM_1_GSM_String_Array[GSM_1_GSM_STRING_ARRAY_SIZE];
MX_UINT8 GSM_1_GSM_MSG_ARRAY[GSM_1_MSG_ARRAY_SIZE];
MX_UINT8 GSM_1_GSM_RX_LENGTH = 0;
MX_UINT8 GSM_1_GSM_MSG_LENGTH = 0;
MX_UINT8 GSM_1_GSM_RX_DONE = 0;
MX_UINT8 GSM_1_GSM_NUMBER[14];
MX_UINT8 GSM_1_GSM_MSG_C = 0;
MX_UINT8 GSM_1_GSM_RING_C = 0;
//GSM(0): //Macro function declarations

MX_UINT8 FCD_GSM0_Initialize();
MX_UINT8 FCD_GSM0_CheckNetworkStatus();
MX_UINT8 FCD_GSM0_SendCommand(MX_STRING command, MX_UINT8 MSZ_command, MX_UINT8
bSendCR);
MX_UINT8 FCD_GSM0_StringReceive();
MX_UINT8 FCD_GSM0_SendScript(MX_UINT8 idx);
MX_UINT8 FCD_GSM0_CheckForIncoming();
MX_UINT8 FCD_GSM0_DialNumber(MX_STRING number, MX_UINT8 MSZ_number);
MX_UINT8 FCD_GSM0_HangUpCall();
MX_UINT8 FCD_GSM0_AnswerIncomingCall();
MX_UINT8 FCD_GSM0_SendTextMessage(MX_STRING number, MX_UINT8 MSZ_number, MX_STRING
message, MX_UINT8 MSZ_message);
MX_UINT8 FCD_GSM0_DeleteAllMessages();
void FCD_GSM0_ReadString(MX_CHAR* FCR_RETVAL, MX_UINT8 FCR_RETVAL_SIZE);
void FCD_GSM0_GetTextNumber(MX_CHAR* FCR_RETVAL, MX_UINT8 FCR_RETVAL_SIZE);
void FCD_GSM0_GetTextString(MX_CHAR* FCR_RETVAL, MX_UINT8 FCR_RETVAL_SIZE);
//ADC(0): //Defines:
b = Which ADC Channel
c = Acquisition time
d = Conversion Speed
e = VRef+ Option
f = VRef Voltage x 0.01V

******************************/
//Common Defines
#define ADC_2_MX_ADC_CHANNEL 0
#define ADC_2_MX_ADC_ACTIME 40
#define ADC_2_MX_ADC_CONVSP 3
#define ADC_2_MX_ADC_VREFOP 0
#define ADC_2_MX_ADC_VREFVOL 500
#ifndef MX_ADC_CHANNEL_0
#define MX_ADC_CHANNEL_0 //Inform CAL ADC channel 0 is now in use.
#endif
#ifndef MX_ADC_REF //Inform CAL ADC peripheral is now in use
#define MX_ADC_REF
#endif
extern void FC_CAL_Enable_ADC (MX_UINT8 Channel, MX_UINT8 Conv_Speed, MX_UINT8 Vref,
MX_UINT8 T_Charge);
extern MX_UINT16 FC_CAL_Sample_ADC (MX_UINT8 Sample_Mode);
extern void FC_CAL_Disable_ADC (void);
//ADC(0): //Macro function declarations

void FCD_ADC0_SampleADC();
MX_UINT8 FCD_ADC0_ReadAsByte();
MX_UINT16 FCD_ADC0_ReadAsInt();
MX_FLOAT FCD_ADC0_ReadAsVoltage();
void FCD_ADC0_ReadAsString(MX_CHAR* FCR_RETVAL, MX_UINT8 FCR_RETVAL_SIZE);
void FCD_ADC0_ADC_RAW_Configure_Channel();
MX_UINT8 FCD_ADC0_ADC_RAW_Sample_Channel_Byte();
MX_UINT16 FCD_ADC0_ADC_RAW_Sample_Channel_Int();
MX_UINT8 FCD_ADC0_ADC_RAW_Average_Channel_Byte(MX_UINT8 NumSamples, MX_UINT8
DelayUs);
MX_UINT16 FCD_ADC0_ADC_RAW_Average_Channel_Int(MX_UINT8 NumSamples, MX_UINT8
DelayUs);
void FCD_ADC0_ADC_RAW_Disable_Channel();
e = VRef+ Option
******************************/
//Common Defines
#endif
#define MX_ADC_REF
#endif
MX_UINT8 T_Charge);

DelayUs);
DelayUs);

e = VRef+ Option
******************************/
//Common Defines
#endif
#define MX_ADC_REF
#endif
MX_UINT8 T_Charge);

DelayUs);
DelayUs);

e = VRef+ Option
******************************/
//Common Defines
#endif
#define MX_ADC_REF
#endif
MX_UINT8 T_Charge);

DelayUs);
DelayUs);
e = VRef+ Option
******************************/
//Common Defines
#endif
#define MX_ADC_REF
#endif
MX_UINT8 T_Charge);

DelayUs);
DelayUs);
e = VRef+ Option
******************************/
//Common Defines
#endif
#define MX_ADC_REF
#endif
e = VRef+ Option
******************************/
//Common Defines
#endif

#define MX_ADC_REF
#endif
//GSM(0): //Macro implementations
MX_UINT8 FCD_GSM0_Initialize()
{
//0=ok
//255=no reply
//254=Command not accepted
char Retval;
FCD_GSM0_StringReceive();
Retval = FCD_GSM0_SendCommand("AT+CMGF=1",9,1); //Default: Format SMS message as text
if (Retval)
return Retval;
if ((GSM_1_GSM_String_Array[0] != 'O') || (GSM_1_GSM_String_Array[1] != 'K'))
{
return 254;
}
Wdt_Delay_Ms(100);
Retval = FCD_GSM0_SendCommand("AT+CNMI=1,2,0,0,0",17,1); //Default: SMS is not stored
if (Retval)
return Retval;
if ((GSM_1_GSM_String_Array[0] != 'O') || (GSM_1_GSM_String_Array[1] != 'K'))
{
return 254;
}
Wdt_Delay_Ms(100);
return Retval;
}
MX_UINT8 FCD_GSM0_CheckNetworkStatus()
{
//0 = not connected
//1 = connected
//255 = no reply
char retval = 0;
FCD_GSM0_SendCommand("AT+CREG?",8,1); //Check network status
if ( FCD_GSM0_StringReceive() == 0)
return 255;
if ( GSM_1_GSM_String_Array[7] == '0' && GSM_1_GSM_String_Array[9] == '1' )
retval = 1;
//Added roaming mode connectivity - some modems report this by default.
if ( GSM_1_GSM_String_Array[7] == '1' && GSM_1_GSM_String_Array[9] == '5' )
retval = 1;
Wdt_Delay_Ms(100);
return retval;
}
MX_UINT8 FCD_GSM0_SendCommand(MX_STRING command, MX_UINT8 MSZ_command, MX_UINT8
bSendCR)
{
//0=ok
//255=no reply
MX_UINT8 idx = 0;
while ( FCD_GSM0_StringReceive()); //Purge any unwanted data
if (MSZ_command > 0)
{
while (idx < MSZ_command)
{
GSM_1_UART_Send (command[idx]);
idx++;
}
if (bSendCR != 0)
{
GSM_1_UART_Send (0x0D);
//send the terminating CR
MSZ_command = MSZ_command + 1;
}
}
#ifdef GSM_EXPECTECHO
FCD_GSM0_StringReceive(); //Collect Echo
#endif
if ( FCD_GSM0_StringReceive() == 0)
{
return 255;
}
return 0;
}
MX_UINT8 FCD_GSM0_StringReceive()
{
//0=timeout
//1=valid data
MX_UINT8 tout = 0;
MX_UINT8 len = GSM_1_GSM_RX_LENGTH;
GSM_1_GSM_RX_DONE = 0;
GSM_1_GSM_RX_LENGTH = 0;
while ((GSM_1_GSM_RX_DONE == 0) && (tout < 255))
{
tout = tout + 1;
if (len != GSM_1_GSM_RX_LENGTH)
{
tout = 0;
len = GSM_1_GSM_RX_LENGTH;
}
delay_10us(50);
}
if (tout == 255)
{
GSM_1_GSM_RX_DONE = 0;
GSM_1_GSM_RX_LENGTH = 0;
return 0;
}
return 1;
}
MX_UINT8 FCD_GSM0_SendScript(MX_UINT8 idx)
{
MX_UINT8 i = 0;
MX_UINT8 ch = 255;
MX_UINT8 retval = 0;
if ((idx < 1) || (idx > GSM_1_GSM_SCRIPT_COUNT))
{
return (0xFF);
//error - index out of range
}
while (ch > 0)
{
switch (idx)
{
#if (GSM_1_GSM_SCRIPT_COUNT >= 1)
case 1:
ch = GSM_1_GSM_SCRIPT_1[i];
break;
#endif
case 2:
break;
#endif
case 3:
break;
#endif
#if (GSM_1_GSM_SCRIPT_COUNT == 4)
case 4:
break;
#endif
default:
return (0xFF);
//should not get here
}
if (ch > 0)
{
//send the character
GSM_1_UART_Send (ch);
//if we sent a CR, wait for the response
if (ch == 13)
{
#endif
retval = FCD_GSM0_StringReceive(); //Collect Reply
while ( FCD_GSM0_StringReceive()); //Make sure we have received everything
}
}
i++;
}
return (retval);
}
MX_UINT8 FCD_GSM0_CheckForIncoming()
{
FCD_GSM0_StringReceive(); //Read any incoming messages
if (GSM_1_GSM_MSG_C == 4) //Text has been received
{
GSM_1_GSM_MSG_C = 0;
return 1; //Text Received
}
else if (GSM_1_GSM_RING_C == 4)
{
GSM_1_GSM_RING_C = 0;
return 2; //Phone Ringing
}
return 0;
}
MX_UINT8 FCD_GSM0_DialNumber(MX_STRING number, MX_UINT8 MSZ_number)
{
MX_UINT8 idx;
GSM_1_UART_Send ('A');
GSM_1_UART_Send ('T');
GSM_1_UART_Send ('D');
for (idx=0; idx<MSZ_number; idx++)
{
GSM_1_UART_Send (number[idx]);
}
GSM_1_UART_Send (';');
GSM_1_UART_Send (GSM_CHAR_CR);
#endif
if ((GSM_1_GSM_String_Array[0] == 'O') && (GSM_1_GSM_String_Array[1] == 'K'))
return 0;
return 255;
}
MX_UINT8 FCD_GSM0_HangUpCall()
{
GSM_1_UART_Send ('H');
#endif
return 0;
return 255;
}
MX_UINT8 FCD_GSM0_AnswerIncomingCall()
{
#endif
return 0;
return 255;
}
MX_UINT8 FCD_GSM0_SendTextMessage(MX_STRING number, MX_UINT8 MSZ_number, MX_STRING
message, MX_UINT8 MSZ_message)
{
MX_UINT8 idx;
GSM_1_UART_Send ('+');
GSM_1_UART_Send ('C');
GSM_1_UART_Send ('S');
GSM_1_UART_Send ('M');
GSM_1_UART_Send ('P');
GSM_1_UART_Send ('=');
GSM_1_UART_Send ('1');
GSM_1_UART_Send (',');
#endif
Wdt_Delay_Ms(100);
GSM_1_UART_Send ('D');
GSM_1_UART_Send ('H');
#endif
Wdt_Delay_Ms(100);
GSM_1_UART_Send ('M');
GSM_1_UART_Send ('G');
GSM_1_UART_Send ('"');
for (idx=0; idx<MSZ_number; idx++)
{
if (number[idx] == 0)
break;
GSM_1_UART_Send (number[idx]);
}
GSM_1_UART_Send ('"');
#endif
Wdt_Delay_Ms(100);
for (idx=0; idx<MSZ_message; idx++)
{
if (message[idx] == 0)
break;
GSM_1_UART_Send (message[idx]);
}
GSM_1_UART_Send (26);
#endif
Wdt_Delay_Ms(100);
return 0;
return 255;
}
MX_UINT8 FCD_GSM0_DeleteAllMessages()
{
FCD_GSM0_SendCommand("AT+CMGD=1,4",11,1);
return 0;
return 255;
}
void FCD_GSM0_ReadString(MX_CHAR* FCR_RETVAL, MX_UINT8 FCR_RETVAL_SIZE)
{
MX_UINT8 idx = 0;
while ((idx < FCR_RETVAL_SIZE) && (GSM_1_GSM_String_Array[idx] > 0))
{
FCR_RETVAL[idx] = GSM_1_GSM_String_Array[idx];
idx = idx + 1;
}
if (idx < FCR_RETVAL_SIZE)
FCR_RETVAL[idx] = 0; //String termination
}
void FCD_GSM0_GetTextNumber(MX_CHAR* FCR_RETVAL, MX_UINT8 FCR_RETVAL_SIZE)
{
MX_UINT8 idx = 0;
while (idx < FCR_RETVAL_SIZE && GSM_1_GSM_NUMBER[idx] > 0 )
{
FCR_RETVAL[idx] = GSM_1_GSM_NUMBER[idx];
idx = idx + 1;
}
}
void FCD_GSM0_GetTextString(MX_CHAR* FCR_RETVAL, MX_UINT8 FCR_RETVAL_SIZE)
{
MX_UINT8 idx = 0;
while ((idx < GSM_1_GSM_MSG_LENGTH) && (GSM_1_GSM_MSG_ARRAY[idx] > 0))
{
FCR_RETVAL[idx] = GSM_1_GSM_MSG_ARRAY[idx];
idx = idx + 1;
}
FCD_GSM0_DeleteAllMessages();
}
//ADC(0): //Macro implementations

void FCD_ADC0_SampleADC()
{
//unused
}
MX_UINT8 FCD_ADC0_ReadAsByte()
{
MX_UINT8 retVal;
//Configure & Enable ADC Channel
FC_CAL_Enable_ADC ( ADC_2_MX_ADC_CHANNEL , ADC_2_MX_ADC_CONVSP ,
ADC_2_MX_ADC_VREFOP , ADC_2_MX_ADC_ACTIME );
retVal = FC_CAL_Sample_ADC( 0 ); //Perform Sample - Return as byte
FC_CAL_Disable_ADC ();
return (retVal);
}
MX_UINT16 FCD_ADC0_ReadAsInt()
{
MX_UINT16 retVal;
retVal = FC_CAL_Sample_ADC( 1 ); //Perform Sample - Return as MX_UINT16
return (retVal);
}
MX_FLOAT FCD_ADC0_ReadAsVoltage()
{
MX_UINT16 iSample;
MX_FLOAT fSample, fVoltage, fVperDiv;

#ifdef MX_ADC_BITS_8
iSample = FC_CAL_Sample_ADC( 0 ); //Perform Sample - Return as byte
#else
iSample = FC_CAL_Sample_ADC( 1 ); //Perform Sample - Return as MX_UINT16
#endif
FC_CAL_Disable_ADC (); //Switch off ADC peripheral
fVoltage = flt_fromi( ADC_2_MX_ADC_VREFVOL ); //Convert reference voltage count to floating point (0 500 x 10mV)
fVoltage = flt_mul(fVoltage, 0.01); //Convert reference voltage count to actual voltage (0 - 5)
fVperDiv = flt_mul(fVoltage, 0.00390625); //Convert actual voltage to voltage per division (VRef / 256)
#endif
#endif
#endif
fSample = flt_fromi(iSample); //Convert to floating point variable
fVoltage = flt_mul(fSample, fVperDiv); //Calculate floating point voltage
return (fVoltage);
}
void FCD_ADC0_ReadAsString(MX_CHAR* FCR_RETVAL, MX_UINT8 FCR_RETVAL_SIZE)
{
MX_FLOAT fVoltage;
fVoltage = FCD_ADC0_ReadAsVoltage();
FCI_FLOAT_TO_STRING(fVoltage, 2, FCR_RETVAL, FCR_RETVAL_SIZE); //Convert to String
}
void FCD_ADC0_ADC_RAW_Configure_Channel()
{
}
MX_UINT8 FCD_ADC0_ADC_RAW_Sample_Channel_Byte()
{
return FC_CAL_Sample_ADC( 0 ); //Perform Sample - Return as byte
}
MX_UINT16 FCD_ADC0_ADC_RAW_Sample_Channel_Int()
{
return FC_CAL_Sample_ADC( 1 ); //Perform Sample - Return as MX_UINT16
}
DelayUs)
{
MX_UINT32 average = 0;
MX_UINT8 count;
for (count=0; count<NumSamples; count++)
{
average = average + FC_CAL_Sample_ADC( 0 ); //Perform Sample - Return as byte - add to average
if (DelayUs)
delay_us(DelayUs); //If delay is not 0 then pause between samples
}
average = average / count;
return (average & 0xFF); //Return average as byte
}
DelayUs)
{
MX_UINT8 count;
{
average = average + FC_CAL_Sample_ADC( 1 ); //Perform Sample - Return as MX_UINT16 - add to average
if (DelayUs)
}
return (average & 0x1FFF); //Return average as MX_SINT16
}
void FCD_ADC0_ADC_RAW_Disable_Channel()
{
FC_CAL_Disable_ADC (); //Disable ADC Channel
}

{
//unused
}
{
MX_UINT8 retVal;
return (retVal);
}
{
MX_UINT16 retVal;
return (retVal);
}
{
MX_UINT16 iSample;
#else
#endif
#endif
#endif
#endif
return (fVoltage);
}
{
MX_FLOAT fVoltage;
}
{

}
{
}
{
}
DelayUs)
{
MX_UINT8 count;
{
if (DelayUs)
}
}
DelayUs)
{
MX_UINT8 count;
{
if (DelayUs)
}

}
{
}

{
//unused
}
{
MX_UINT8 retVal;
return (retVal);
}
{
MX_UINT16 retVal;
return (retVal);
}
{
MX_UINT16 iSample;
#else
#endif
#endif
#endif
#endif
return (fVoltage);
}
{
MX_FLOAT fVoltage;
}
{
}
{
}
{
}
DelayUs)
{
MX_UINT8 count;
{
if (DelayUs)
}
}
DelayUs)
{
MX_UINT8 count;
{
if (DelayUs)

}
}
{
}

{
//unused
}
{
MX_UINT8 retVal;
return (retVal);
}
{
MX_UINT16 retVal;
return (retVal);
}
{
MX_UINT16 iSample;
#else
#endif
#endif
#endif
#endif
return (fVoltage);
}
{
MX_FLOAT fVoltage;
}
{
}
{
}
{
}
DelayUs)
{
MX_UINT8 count;
{
if (DelayUs)
}
}
DelayUs)
{
MX_UINT8 count;
{

if (DelayUs)
}
}
{
}

{
//unused
}
{
MX_UINT8 retVal;
return (retVal);
}
{
MX_UINT16 retVal;

return (retVal);
}
{
MX_UINT16 iSample;
#else
#endif
#endif
#endif
#endif
return (fVoltage);
}
{
MX_FLOAT fVoltage;
}
{
}
{
}
{
}
DelayUs)
{
MX_UINT8 count;
{
if (DelayUs)
}
}
DelayUs)
{
MX_UINT8 count;
{
if (DelayUs)
}
}
{
}

{
//unused
}
{
MX_UINT8 retVal;
ADC_7_MX_ADC_VREFOP , ADC_7_MX_ADC_A

Programe

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Programe

Diunggah oleh

Hak Cipta:

Format Tersedia

#define P16F877A

//Timeout within the <BT_Send_Command> function (ms)

//Timeout within the <BT_String_Receive> function (ms)

//GSM(0): //Macro function declarations

f = VRef Voltage x 0.01V

//ADC(0): //Macro function declarations

//ADC(1): //Macro function declarations

b = Which ADC Channel

//ADC(2): //Macro function declarations

/**** Macro Substitutions ****

//ADC(3): //Macro function declarations

//ADC(4): //Macro function declarations

#ifndef MX_ADC_REF //Inform CAL ADC peripheral is now in use

//error - index out of range

//should not get here

//ADC(0): //Macro implementations

MX_FLOAT fSample, fVoltage, fVperDiv;

//ADC(1): //Macro implementations

FC_CAL_Enable_ADC ( ADC_3_MX_ADC_CHANNEL , ADC_3_MX_ADC_CONVSP ,

return (average & 0x1FFF); //Return average as MX_SINT16

//ADC(2): //Macro implementations

delay_us(DelayUs); //If delay is not 0 then pause between samples

//ADC(3): //Macro implementations

average = average + FC_CAL_Sample_ADC( 1 ); //Perform Sample - Return as MX_UINT16 - add to average

//ADC(4): //Macro implementations

FC_CAL_Enable_ADC ( ADC_6_MX_ADC_CHANNEL , ADC_6_MX_ADC_CONVSP ,

//ADC(5): //Macro implementations

Anda mungkin juga menyukai

/ Macro Substitutions