www.pudn.com > tc35i-SMS_Mcu_Program.rar > sl.c, change:2004-03-26,size:75725b
//-----------------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------------
//#include <c8051f020.h> // SFR declarations
//#include <Absacc.h>
//#include <MAC.c>
//-----------------------------------------------------------------------------------
// Global CONSTANTS
//-----------------------------------------------------------------------------------
#define UINT unsigned int
#define UCHAR unsigned char
#define PPPINITFCS16 0xffff /* Initial FCS value */
#define PPPGOODFCS16 0x3e62 /* Good final FCS value */
/* SW_UART CONSTANTS DEFINITION */
#define BAUD_RATE 9600 // User-definable SW_UART baud rate
#define SYSCLK 18432000 // System clock derived from 18.432MHz XTL
#define TIME_COUNT SYSCLK/BAUD_RATE/4 // Number of PCA counts for one bit-time.
// (PCA configured to count SYSCLK/4)
#define TH_TIME_COUNT TIME_COUNT*3/2 // 3/2 bit-time, for use after receiving
// a START bit. RX should be LOW for one
// bit-time after the edge of the START,
// and the first bit sample starts in the
// middle of the next bit-time.
#define HW_TIME_COUNT SYSCLK/BAUD_RATE/16 // Time count for HW_UART baud rate
#define TI1 (SCON1 & 0x02)
sfr PRT1IF=0xad; // 设置外部中断7寄存器
/* define FLASH address */ // above.
#define StartAddress 0x1000
#define Backup_Add0 0x2000
#define Backup_Add1 0x3000
#define Backup_Add2 0x4000
#define Address5555 XBYTE[0x5555]
#define Address2AAA XBYTE[0x2AAA]
/* define time chip address */
#define IniDataAddress 0xF000
//define RTC Register
#define RegA XBYTE[0xff0a]
#define RegB XBYTE[0xff0b]
#define RegC XBYTE[0xff0c]
#define RegD XBYTE[0xff0d]
#define Hour XBYTE[0xff04]
#define Minute XBYTE[0xff02]
#define Second XBYTE[0xff00]
#define Year XBYTE[0xff09]
#define Month XBYTE[0xff08]
#define Day XBYTE[0xff07]
#define Week XBYTE[0xff06]
#define Century XBYTE[0xff32]
#define Hour_Alarm XBYTE[0xff05]
#define Minute_Alarm XBYTE[0xff03]
#define Second_Alarm XBYTE[0xff01]
#define Record_Ind XBYTE[0xff34]
// define Initilized Data Address
#define Monitor_IP_Add 0x01
#define Monitor_PORT_Add 0x05
#define Machine_Num 0x07
#define Machine_Cycle 0x09
#define Pressure_Limit 0x0A
#define Power_Limit 0x0C
#define UP_Send_Time 0x0E
#define Time_Interval 0x10
//---------------------------------------------------------------------------------------------------
//Global VARIABLES
//-----------------------------------------------------------------------------------
/* SW_UART VARIABLES DEFINITION */
bit SRI; // SW_UART Receive Complete Indicator
bit STI; // SW_UART Transmit Complete Indicator
bit STXBSY; // SW_UART TX Busy flag
bit SREN; // SW_UART RX Enable
bit SES; // SW_UART User-level Interrupt Support Enable
sbit SW_RX = P0^4; // SW_UART Receive pin
sbit SW_TX = P1^2; // SW_UART Transmit pin
//------------------------------------------------------------------------------------
sbit P1_4 = P1^4; // BUTTON DOOR
sbit P1_3 = P1^3; // BUTTON CARGO
sbit P1_5 = P1^5; // BUTTON CLEAR
//------------------------------------------------------------------------------------
sbit CS_RTC=P1^7; //RTC Chip Select,Low Effect, Flash Chip Select pin
sbit GPRS_LED=P1^6; //
bit Net_Ok_Flag=0; // 网络连接成功标识符
bit Timer3_Flag=0; // Flag for GSM Init and EXCHANGE4 resend
bit Reset_Flag=0;
bit EXCH_SEND4_Flag=0;
// 软串口缓存区定义
unsigned char TDR; // SW_UART TX Data Register
unsigned char RDR; // SW_UART RX Data Register (latch)
unsigned char xdata Ini_Data_Buffer[26],*Ini_Data_BufferPoint;
unsigned char xdata Ini_Data_Num_Reci=0,Ini_Data_Num_Send=0;
unsigned char xdata Receive_Ini_Flag=0;
bit Ini_Data_Flag=0;
//-------------------------------------------------------------------------------------
unsigned int xdata counter_timer3=0;
unsigned int xdata Timer3_Counter=0;
// GSM Commands
unsigned char xdata GSMCommand1[7] = "AT+CSQ\r";
unsigned char xdata GSMCommand2[12] = "ATD*99***1#\r";
/*MPU shake hands with WAVECOM*/
UCHAR xdata EXCHANGE1[22]={0x7E,0xFF,0x03,0xC0,0x21,0x01,0x01,0x00,0x0E,0x02,0x06,0x00,0x00,0x00,0x00,0x07,0x02,0x08,0x02,0x00,0x00,0x7E};
UCHAR xdata EXCHANGE2[30]={0x7E,0xFF,0x03,0xC0,0x21,0x02,0x01,0x00,0x16,0x01,0x04,0x05,0xDC,0x02,0x06,0x00,0x00,0x00,0x00,0x07,0x02,0x08,0x02,0x03,0x04,0xC0,0x23,0x00,0x00,0x7E};
UCHAR xdata EXCHANGE3[21]={0x7E,0xC0,0x23,0x01,0x01,0x00,0x0F,0x09,0x48,0x55,0x41,0x4E,0x47,0x4C,0x45,0x49,0x5C,0x00,0x00,0x00,0x7E};
UCHAR xdata EXCHANGE4[21]={0x7E,0xC0,0x23,0x01,0x02,0x00,0x0F,0x09,0x48,0x55,0x41,0x4E,0x47,0x4C,0x45,0x49,0x5C,0x00,0x00,0x00,0x7E};
UCHAR xdata EXCHANGE5[16]={0x7E,0x80,0x21,0x01,0x03,0x00,0x0A,0x03,0x06,0x00,0x00,0x00,0x00,0x97,0x5D,0x7E};
UCHAR xdata EXCHANGE6[16]={0x7E,0x80,0x21,0x02,0x01,0x00,0x0A,0x03,0x06,0xC0,0xA8,0x6F,0x6F,0xA4,0x3D,0x7E};
UCHAR xdata EXCHANGE7[16]={0x7E,0x80,0x21,0x01,0x04,0x00,0x0A,0x03,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x7E};
/*Disconnect form GPRS network*/
//UCHAR xdata EXCHANGE8[14]={0x7E,0xFF,0x03,0xC0,0x21,0x05,0x01,0x00,0x06,0x00,0x00,0x96,0xE,0x7E};
//UCHAR xdata EXCHANGE9[12]={0x7E,0xFF,0x03,0xC0,0x21,0x06,0x02,0x00,0x04,0x00,0x00,0x7E};
// Definition of frame information
UCHAR xdata Frame_Head[2]={0x7E,0x21};
UCHAR xdata IP_Head[20]={0x45,0x9D,0xFF,0xFF,0x00,0x00,0x00,0x00,0xFF,0x11,0x00,0x00,0xFF,0xFF,0xFF,0xFF,211,71,10,117};
UCHAR xdata UDP_Head[8]={0x03,0xEA,0x02,0xBD,0x00,0x00,0x00,0x00};
UCHAR xdata Frame_End[3]={0x00,0x00,0x7E};
// 串口中断接收缓存区定义
unsigned char xdata rec[50],RECEIVEBUFFER[100],*RECEIVEBUFFERPOINT; // UART0 RECEIVE buffer
unsigned char xdata WAVE_Receive_Num = 0;
unsigned char xdata Receive_Buf_UAR1[300]; // UART1 RECEIVE buffer
unsigned int xdata CAIJI_Receive_Len;
//unsigned char xdata Inf_Buffer_UART1[20]; // 采集板送来数据存放区
bit RECEIVE_FLAG = 0,PADDING_Flag = 0,PPP_Rec_Complete = 0; // UART0 RECEIVE FLAG
bit Receive_Flag_UART1=0,Padding_Flag_UART1=0,UART1_Rec_Complete=0; // UART1 RECEIVE FLAG
bit PPP_First_Receive=0;
bit GPRS_OK = 0;
// WAVECOM收发数据相关定义
bit WAVE_Data_Receive = 0,WAVE_Resend_Flag = 0;
unsigned char xdata WAVE_Timer=0,WAVE_Resend_Num,WAVE_Receive_SeqNr = 0,WAVE_Send_SeqNr=0;
unsigned char xdata WAVE_Data_Buffer[50],WAVE_Command_Buf[300];
unsigned char xdata WAVE_Data_Len;
unsigned int xdata WAVE_Comm_Len;
// 采集板收发数据相关定义
bit CAIJI_Data_Receive = 0,CAIJI_Resend_Flag = 0;
unsigned char xdata CAIJI_Timer=0,CAIJI_Resend_Num,CAIJI_Receive_SeqNr = 0,CAIJI_Send_SeqNr = 0;
unsigned char xdata CAIJI_Data_Buffer[300],CAIJI_Command_Buf[15];
unsigned int xdata CAIJI_Data_Len;
unsigned char xdata CAIJI_Comm_Len;
// 采集命令的相关定义
bit Data_Gather_Comm = 0,WAVECOM_Gather=0,Time_Gather = 0;
bit Data_Ready_Flag = 0;
unsigned char xdata Frame_Num = 0;
bit WAVE_Timer_End = 0;
bit CAIJI_Timer_End = 0;
// 数据备份相关定义
unsigned char xdata Backup_Index;
unsigned int Current_Add;
// 上电初始化标识设定
bit Init_Flag = 0;
// 外部中断1相关定义
bit Send_Test_Frame = 0;
bit Test_Frame_Answer = 0;
bit Timer_Gather_Flag = 0;
unsigned char xdata Timer_Num = 0;
// 测试数据定义
bit send_flag=1;
unsigned char xdata Inf_Buffer[10];
UINT code fcstab[256] = {
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};
void Delay10ms();
// 初始化子程序组
void Baudrate_Init(void);
void AT();
void GSM_INI(void);
void ATD99();
void Download_Init_Data();
void SW_UART_INIT(); // SW_UART initialization routine
void SW_UART_ENABLE();
void Interrupt_Enable(void);
void Ini_Data_Deal();
// 握手子程序组
void EXCH_SEND1();
void EXCH_SEND2();
void EXCH_SEND3();
void EXCH_SEND4();
void EXCH_SEND5();
void EXCH_SEND6();
void EXCH_SEND7();
// FLASH程序组
void Write_Byte(unsigned int w_address, unsigned char w_byte);
void Erase_Sector(unsigned int w_address);
void Erase_Chip(void);
//void Flash_Test(void);
// RTC程序组
void RTC_Init(void);
void RTC_Time_Update(unsigned char xdata *source);
//void RTC_Test(void);
// FCS校验子程序组
UINT pppfcs16(UINT fcs,unsigned char *cp,int len);
void Fcs16(unsigned char *cp,int len);
// 头校验子程序组
void CHECKSUM_UDP(unsigned int Data_length);
long cksum(unsigned char *ip, int len);
// 应用子程序组
void DEAL_DATA_WAVECOM(void);
void WAVE_Rec_Ack(void);
void SEND_DATA_CAIJI(unsigned char Data_Len);
void SEND_DATA_WAVECOM(unsigned int data_len);
void DEAL_DATA_CAIJI(void);
// 监控命令程序组
void Machine_Message_Set(void);
void Pressure_Limit_Set(void);
void Power_Limit_Set(void);
void UP_Timer_Set(void);
void Time_Interval_Set(void);
void Data_Gather_Set(void);
void Open_Machine_Comm(void);
void Close_Machine_Comm(void);
void Link_Send_Comm();
void Test_Frame_Send();
void Timer_Gather_Deal();
//采集命令组
void Frame_Data_Deal();
void Trouble_Inform_Comm();
void Data_Ready_Comm();
void Get_Data_Comm();
// 重发程序组
void CAIJI_Resend_Deal();
void WAVE_Resend_Deal();
void MAIN (void)
{
UINT delay; // Delay counter.
UINT i;
unsigned char j;
// ProtectCode();
OSCXCN = 0x67; // Enable external crystal
WDTCN = 0xDE; // disable watchdog timer
WDTCN = 0xAD;
EMI0CF = 0x07; // Set External Memory Configuration Register,使用片内 4K 和片外存储器 低端口，地址数据复用
XBR0 = 0x0c; // Set UART0,CEX0,CEX1,
XBR1 = 0x14; // Set /INT0,/INT1
XBR2 = 0x46; // Set UART1,Enable XBAR,Enable EMFILE
P0MDOUT = 0xe5; // Output configuration for P0
P1MDOUT = 0xc4; // Output configuration for P1
P2MDOUT = 0xff; // Output configuration for P2
P3MDOUT = 0xff; // Output configuration for P3
P0 |= 0x1a; // Enable RX0
// Enable RX1
P1 |= 0x3b; // Enable RX2
// 输出PIN初始化
GPRS_LED=1; // LED灯指示初始化
CS_RTC=1; // 禁止访问时钟芯片
delay=256; // Delay >1 ms before polling XTLVLD.
while(delay--);
while (!(OSCXCN & 0x80)); // Wait until external crystal has // started.
OSCICN = 0x0C; // Switch to external oscillator
OSCICN = 0x88; // Disable internal oscillator; enable
// missing clock detector.
while (!(OSCXCN & 0x80)); // Wait until external crystal has // started.
OSCICN = 0x08; // Switch to external oscillator
// 初始化UART0、UART1、TIMER2、TIMER4、TIMER3 ，定时器3中断开
Baudrate_Init(); // 初始化串口0和串口1的波特率
IP |= 0x10; // interrupt UART0 priority
IT0 = 1; // 设置外部中断1为沿触发
// 初始化软串口
SW_UART_INIT();
// 时间芯片初始化
// RTC_Init();
// 复位WAVECOM
GPRS_LED=0;
for(i=0;i<100;i++) Delay10ms();
GPRS_LED=1; // 初始化指示灯
EA=1; // open interrupt control
for(i=0;i<1000;i++) Delay10ms();
// 擦除FLASH
// Erase_Chip();
// 数据初始化
// Download_Init_Data();
//GSM初始化，查询网络信号强度
GSM_INI();
ES0=1; //允许串口0中断
// delay
for(i=0;i<1000;i++) Delay10ms();
for(i=0;i<1000;i++) Delay10ms();
for(i=0;i<1000;i++) Delay10ms();
ATD99(); //拨号连接GPRS网络 ATD*99***1#
for(i=0;i<1000;i++) Delay10ms();
WDTCN = 0xa5;
while(1)
{
// 处理WAVECOM传来的数据
if(PPP_Rec_Complete)
{
PPP_Rec_Complete = 0;
DEAL_DATA_WAVECOM();
}
// 用于连接网络时，超时进行复位
if(Reset_Flag==1)
{
Reset_Flag=0;
for(i=0;i<1000;i++) Delay10ms();
WDTCN = 0xa5;
for(i=0;i<80;i++) Delay10ms();
}
// 用于连接网络时，数组4重发
if(EXCH_SEND4_Flag == 1)
{
EXCH_SEND4_Flag = 0;
EXCH_SEND4();
}
if(GPRS_OK == 1)
{
/*
if(send_flag == 1)
{
send_flag = 0;
CAIJI_Comm_Len =0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 00;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 01;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 03;
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置命令重传标识
CAIJI_Resend_Flag = 1;
CAIJI_Resend_Num = 0;
CAIJI_Timer = 1;
TMR3CN |= 0x04; // 开启定时器3
}
*/
i=1;
}
//软串口收到数据处理
if(Ini_Data_Flag == 1)
{
Ini_Data_Flag=0;
Ini_Data_Deal();
}
// 处理采集板传来的数据
if(UART1_Rec_Complete == 1)
{
UART1_Rec_Complete = 0;
DEAL_DATA_CAIJI();
}
// 处理监控中心传来的数据
if(WAVE_Data_Receive == 1)
{
WAVE_Data_Receive = 0;
WAVE_Rec_Ack();
}
// 处理取数据命令
if(Data_Gather_Comm == 1)
{
if(Data_Ready_Flag == 1)
{
if(CAIJI_Resend_Flag != 1 && WAVE_Resend_Flag !=1)
{
Get_Data_Comm();
}
}
}
// 测试帧发送处理
if(Send_Test_Frame == 1)
{
Send_Test_Frame = 0;
if(CAIJI_Resend_Flag != 1 && WAVE_Resend_Flag !=1)
{
Test_Frame_Send();
}
else
{
Test_Frame_Answer = 0;
}
}
// 定时发送数据处理
if(Timer_Gather_Flag == 1)
{
if(CAIJI_Resend_Flag != 1 && WAVE_Resend_Flag !=1)
{
Timer_Gather_Flag = 0;
Timer_Gather_Deal();
}
}
// 处理向采集板的命令重发
if(CAIJI_Timer_End == 1)
{
CAIJI_Timer_End = 0;
CAIJI_Resend_Deal();
}
// 处理向监控中心的命令重发
if(WAVE_Timer_End == 1)
{
WAVE_Timer_End = 0;
WAVE_Resend_Deal();
}
if(GPRS_OK==1) // 测试WAVECOM数据发送报文
{
if(send_flag==1)
{
send_flag=0;
for(j=0;j<3;j++)
{
for(i=0;i<100;i++) Delay10ms();
Inf_Buffer[0]=0x41;
Inf_Buffer[1]=0x42;
Inf_Buffer[2]=0x43;
Inf_Buffer[3]=0x44;
Inf_Buffer[4]=0x45;
Inf_Buffer[5]=0x46;
SEND_DATA_WAVECOM(6);
}
}
}
}
}
//-------------------------------------------------------------------------
//--------------------------------------------------------------------------
// 初始化程序模块
void Baudrate_Init(void)
{
T2CON = 0x30; //Set Timer2 as Baudrate Generator of UART0
RCAP2H = 0xff; //Set Reload High Byte
RCAP2L = 0xc4; //Set Reload Low Byte
SCON0 = 0x50; //Set UART0 Mode 1 (1 Start Bit ,8 Data Bit ,1 Stop Bit) and Enable Receive
T4CON = 0x30; //Use SysClk
RCAP4H = 0xff; //Set Timer1 Mode 2 (Auto Reload Byte)
RCAP4L = 0xc4; //Set Reload High Byte
SCON1 = 0x50; //Set UART1 Mode 1 (1 Start Bit ,8 Data Bit ,1 Stop Bit) and Enable Receive
TMR3CN = 0x00; //Timer3 use sysclk/12
TMR3H = 0x3c; //set Timer3 High Byte
TMR3L = 0x00; //set Timer3 Low Byte
TMR3RLH= 0x3c; //set Timer3 Reload High Byte
TMR3RLL= 0x00; // set Timer3 Reload Low Byte Timer3 : 10ms is distance
EIE2 &= 0xfb; //Disable Timer4 Interrupt
ET2 = 0; //Disable Timer2 Interrupt
EIE2 |= 0x01; //允许定时器3中断
T4CON |= 0x04; //Start Timer4
TR2 = 1; //Start Timer2
TMR3CN &=0xFB; //Stop Timer3
}
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//软串口初始化子程序
void SW_UART_INIT(void)
{
PCA0CPM0 = 0x10; // Module 0 in negative capture mode; module
// 0 interrupt disabled.
PCA0CPM1 = 0x01; // Module 1 in software timer mode; module
// 1 interrupt disabled.
PCA0CN = 0; // Leave PCA disabled
PCA0MD = 0x02; // PCA timebase = SYSCLK/4; PCA counter
// interrupt disabled.
CCF0 = 0; // Clear pending PCA module 0 and
CCF1 = 0; // module 1 capture/compare interrupts.
SRI = 0; // Clear Receive complete flag.
STI = 0; // Clear Transmit complete flag.
SW_TX = 1; // TX line initially high.
STXBSY = 0; // Clear SW_UART Busy flag
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
// SW_UART_ENABLE: SW_UART Enable Routine
void SW_UART_ENABLE(void)
{
PCA0CPM0 |= 0x01; // Enable module 0 (receive) interrupts.
PCA0CPM1 |= 0x01; // Enable module 1 (transmit) interrupts.
CR = 1; // Start PCA counter.
EIE1 |= 0x08; // Enable PCA interrupts
}
//延时子程序
void Delay10ms()
{
UINT i;
for(i=0;i<10000;i++);
}
// --------------------------------------------------------------------------------
// 上电初始化程序
void Download_Init_Data(void)
{
unsigned char i;
// 初始化备份索引号
CS_RTC = 0;
if((Record_Ind<2) || (Record_Ind>4))
{
Record_Ind = 2;
}
Backup_Index = Record_Ind;
// 初始化信宿IP地址和端口号
CS_RTC = 1;
if(XBYTE[StartAddress] == 0xAA)
{
// FLASH数据已初始化过
for(i=0;i<4;i++)
{
IP_Head[16+i] = XBYTE[StartAddress+Monitor_IP_Add+i]; // 装入IP地址
}
for(i=0;i<2;i++)
{
UDP_Head[2+i] = XBYTE[StartAddress+Monitor_PORT_Add+i]; // 装入端口号
}
Init_Flag = 1; // 设定初始化标识
}
}
//---------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------
//测试模块是否正常子程序
void AT()
{
UCHAR i;
UCHAR AT_Command[3]="AT\r";
for(i=0;i<3;i++)
{
SBUF0=AT_Command[i];
while(TI0==0); TI0 =0;
}
}
//-------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//拨号连接GPRS网络子程序
void ATD99()
{
unsigned char i;
for(i=0;i<12;i++) /* ATD*99***1# */
{
SBUF0 = GSMCommand2[i];
while(TI0==0); TI0=0;
}
}
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
// 查询GSM网络信号强度子程序
void GSM_INI( void)
{
unsigned char i;
bit Signal_OK=0;
RI0=0;
AT();
for(i=0;i<80;i++) Delay10ms();
AT();
for(i=0;i<80;i++) Delay10ms();
TMR3CN |= 0x04;
while(!Signal_OK) /* AT+CSQ */
{
for(i=0;i<7;i++)
{
SBUF0 = GSMCommand1[i];
while(TI0==0); TI0 = 0;
while(RI0==0);
rec[i] = SBUF0;
RI0 = 0;
}
for(i=7;i<15;i++) /* Error state */
{
while(RI0==0);
rec[i] = SBUF0;
RI0 = 0;
}
if(rec[8] != 'R' && rec[9] != 'R' && rec[10] != 'R' && rec[11] != 'R')
{
for(i=15;i<25;i++)
{
while(RI0==0);
rec[i] = SBUF0;
RI0 = 0;
}
}
for(i=8;i<25;i++){
if(rec[i] == ':' && rec[i+2] != '9')
{
Signal_OK = 1;
break;
}
}
}
TMR3CN &=0xFB;
Timer3_Flag=1;
counter_timer3=0;
Timer3_Counter=0;
}
//--------------------------------------------------------------------
//
// RTC初始化代码
void RTC_Init(void)
{
CS_RTC = 0; // 使能时钟芯片
RegB = 0x02; // 设置时间格式为BCD码格式，24小时制式
// RegA = 0x20; // 开启RTC计时 软串口数据初始化后在开启
RegB |=0x80;
Hour_Alarm = 0xFF;
Minute_Alarm = 0xFF;
Second_Alarm = 0x00;
RegB &= 0x7F;
CS_RTC = 1;
}
// RTC时间更新代码
void RTC_Time_Update(unsigned char xdata *source)
{
unsigned char i;
CS_RTC=0; // open RTC
RegB |= 0x80;
for(i=0;i<10;i++)
{
XBYTE[IniDataAddress+i] = *(source+i);
}
Second_Alarm = 0x00;
Minute_Alarm = 0xFF;
Hour_Alarm = 0xFF;
RegB &= 0x7F;
CS_RTC = 1;
}
// -----------------------------------------------------------------------
// 中断使能处理
void Interrupt_Enable(void)
{
// 网络连接成功后，打开其余的中断
EIE2 |=0x40; // 允许串口1中断
if(Init_Flag == 1)
{
EX0 = 1; // 允许外部1中断
CS_RTC = 0; // 允许时间芯片中断
RegB |=0x20;
CS_RTC = 1;
}
SW_UART_ENABLE(); // 软串口中断设置
SREN = 1; // 允许软串口接收
SES = 1;
}
//------------------------------------------------------------------------
// 软串口初始化数据处理
void Ini_Data_Deal()
{
unsigned char i;
// 数据存入FLASH
CS_RTC = 1;
Erase_Sector(StartAddress);
for(i=0;i<16;i++)
{
Write_Byte(StartAddress+1+i,Ini_Data_Buffer[i]);
}
Write_Byte(StartAddress,0xAA); // 设置FLASH设置标识位
// 初始化时间芯片
CS_RTC = 0;
RegB = 0x06; // 设置时间格式为二进制格式，24小时制式
RegB |= 0x80;
Second = Ini_Data_Buffer[16];
Minute = Ini_Data_Buffer[17];
Hour = Ini_Data_Buffer[18];
Week = Ini_Data_Buffer[19];
Day = Ini_Data_Buffer[20];
Month = Ini_Data_Buffer[21];
Year = Ini_Data_Buffer[22];
Hour_Alarm = 0xFF;
Minute_Alarm = 0xFF;
Second_Alarm = 0x00;
RegB &=0x7F;
// RegA = 0x20; // 开启时间芯片
CS_RTC = 1;
// 开中断
EX0 = 1; // 允许外部1中断
CS_RTC = 0; // 允许时间芯片中断
RegB |=0x20;
RegA = 0x20; // 开启时间芯片
CS_RTC = 1;
// 初始化IP地址
for(i=0;i<4;i++)
{
IP_Head[16+i] = XBYTE[StartAddress+Monitor_IP_Add+i]; // 装入IP地址
}
for(i=0;i<2;i++)
{
UDP_Head[2+i] = XBYTE[StartAddress+Monitor_PORT_Add+i]; // 装入端口号
}
// 设置起始标识
Init_Flag = 1;
// 定时间隔计数器清0
Timer_Num = 0;
// 向采集板发初始化数据
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x07;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x05;
CS_RTC = 1;
for(i=0;i<5;i++)
{
CAIJI_Command_Buf[CAIJI_Comm_Len++] = XBYTE[StartAddress+Machine_Cycle+i];
}
SEND_DATA_CAIJI(CAIJI_Comm_Len);
/*
// 向监控中心发链路命令
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Send_SeqNr++; // 命令序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // command[0]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x03; // command[1]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x02; // 数据长度
CS_RTC = 1;
for(i=0;i<2;i++)
{
WAVE_Command_Buf[WAVE_Comm_Len++] = XBYTE[StartAddress+Machine_Num+i];
}
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
// 设置命令重传标识
WAVE_Resend_Flag = 1;
WAVE_Resend_Num = 0;
WAVE_Timer = 10;
*/
CAIJI_Resend_Flag = 1;
CAIJI_Resend_Num = 0;
CAIJI_Timer = 1;
TMR3CN |= 0x04; // 开启定时器3
// 回送软串口数据
STI=1;
EIE2 |= 0x20; // Start SW_TX by enabling
PRT1IF |= 0x80;
}
//------------------------------------------------------------------------
//处理 WAVECOME 传来数据子程序
void DEAL_DATA_WAVECOM(void)
{
UINT i;
RECEIVEBUFFERPOINT=RECEIVEBUFFER;
if((*RECEIVEBUFFERPOINT==0xFF)&&(*(RECEIVEBUFFERPOINT+2)==0xC0)&&(*(RECEIVEBUFFERPOINT+3)==0x21)&&(*(RECEIVEBUFFERPOINT+4)==0x01) && (PPP_First_Receive==0))
{
WDTCN = 0xDE; // disable watchdog timer
WDTCN = 0xAD;
EXCH_SEND1();
PPP_First_Receive = 1;
}
else if((*RECEIVEBUFFERPOINT==0xFF)&&(*(RECEIVEBUFFERPOINT+2)==0xC0)&&(*(RECEIVEBUFFERPOINT+3)==0x21)&&(*(RECEIVEBUFFERPOINT+4)==0x1))
{
PPP_First_Receive = 0;
EXCH_SEND2();
EXCH_SEND3();
TMR3CN |= 0x04; //启动定时器3,每隔1S发送EXCH_SEND4(),直至收到回应
}
else if((*RECEIVEBUFFERPOINT==0xC0)&&(*(RECEIVEBUFFERPOINT+1)==0x23)&&(*(RECEIVEBUFFERPOINT+2)==0x02))
{
TMR3CN &=0xFB; //关闭定时器3，停止发送EXCH_SEND4()
counter_timer3=0;
EXCH_SEND5();
}
else if((*RECEIVEBUFFERPOINT==0x80)&&(*(RECEIVEBUFFERPOINT+1)==0x21)&&(*(RECEIVEBUFFERPOINT+2)==0x01))
{
for(i=8;i=12;i++) EXCHANGE6[i+1] = *(RECEIVEBUFFERPOINT+i);
EXCH_SEND6(); //读取网关地址
}
else if((*RECEIVEBUFFERPOINT==0x80)&&(*(RECEIVEBUFFERPOINT+1)==0x21)&&(*(RECEIVEBUFFERPOINT+2)==0x03))
{
for(i=8;i<12;i++) {
EXCHANGE7[i+1] = *(RECEIVEBUFFERPOINT+i); //读取并更新IP地址
IP_Head[i+4] = *(RECEIVEBUFFERPOINT+i);
}
EXCH_SEND7();
GPRS_OK = 1;
Net_Ok_Flag=1;
// 中断使能处理
Interrupt_Enable();
// 发送链路连接命令
Link_Send_Comm();
// EIE2 |=0x40; //允许串口1中断
}
else if((*RECEIVEBUFFERPOINT==0xFF)&&(*(RECEIVEBUFFERPOINT+2)==0xC0)&&(*(RECEIVEBUFFERPOINT+3)==0x21)&&(*(RECEIVEBUFFERPOINT+4)==0x5))
{
Reset_Flag=1;
}
else if((*RECEIVEBUFFERPOINT==0x21)&&(*(RECEIVEBUFFERPOINT+1)==0x45)&&(*(RECEIVEBUFFERPOINT+10)==0x11))
{
if((*(RECEIVEBUFFERPOINT+13)==IP_Head[12])&&(*(RECEIVEBUFFERPOINT+14)==IP_Head[13])&&(*(RECEIVEBUFFERPOINT+15)==IP_Head[14])&&(*(RECEIVEBUFFERPOINT+16)==IP_Head[15]))
{
WAVE_Data_Receive = 1;
// WAVE_Rec_Ack(); //注意中心的IP地址
}
}
}
//---------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------
//PPP的FCS校验子程序
UINT pppfcs16(UINT fcs,unsigned char *cp,int len)
{
while (len--)
fcs = (fcs >> 8) ^ fcstab[(fcs ^ *cp++) & 0xff];
return (fcs);
}
//----------------------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------------
//PPP的FCS校验子程序
void Fcs16(unsigned char *cp,int len)
{
UINT trialfcs;
cp++;
trialfcs = pppfcs16( PPPINITFCS16, cp, len-4 );
trialfcs ^= 0xffff; // complement
cp[len-4] = (trialfcs & 0x00ff); // least significant byte first
cp[len-3] = ((trialfcs >> 8) & 0x00ff);
}
/********************************************************************
// PPP连接时交互语句
********************************************************************/
// 发送PPP连接建立的第1条交互语句子程序
void EXCH_SEND1()
{
UINT xdata i,len=22;
Fcs16(EXCHANGE1,len);
for(i=0;i<len;i++)
{
TI0 = 0;
SBUF0 = EXCHANGE1[i];
while(TI0==0); TI0 = 0;
}
}
//-----------------------------------------------------------------------------------------------------------
// 发送PPP连接建立的第2条交互语句子程序
void EXCH_SEND2()
{
UINT xdata i,len=30;
Fcs16(EXCHANGE2,len);
for(i=0;i<len;i++)
{
TI0 = 0;
SBUF0 = EXCHANGE2[i];
while(TI0==0); TI0 = 0;
}
}
//-----------------------------------------------------------------------------------------------------------
// 发送PPP连接建立的第3条交互语句子程序
void EXCH_SEND3()
{
UINT xdata i,len=21;
Fcs16(EXCHANGE3,len);
for(i=0;i<len;i++)
{
TI0 = 0;
SBUF0 = EXCHANGE3[i];
while(TI0==0); TI0 = 0;
}
}
//-----------------------------------------------------------------------------------------------------------
// 发送PPP连接建立的第4条交互语句子程序
void EXCH_SEND4()
{
UINT xdata i,len=21;
Fcs16(EXCHANGE4,len);
for(i=0;i<len;i++)
{
TI0 = 0;
SBUF0 = EXCHANGE4[i];
while(TI0==0); TI0 = 0;
}
}
//-----------------------------------------------------------------------------------------------------------
// 发送PPP连接建立的第5条交互语句子程序
void EXCH_SEND5()
{
UINT xdata i,len=16;
Fcs16(EXCHANGE5,len);
for(i=0;i<len;i++)
{
TI0 = 0;
SBUF0 = EXCHANGE5[i];
while(TI0==0); TI0 = 0;
}
}
//-----------------------------------------------------------------------------------------------------------
// 发送PPP连接建立的第6条交互语句子程序
void EXCH_SEND6()
{
UINT xdata i,len=16;
Fcs16(EXCHANGE6,len);
for(i=0;i<len;i++)
{
TI0 = 0;
SBUF0 = EXCHANGE6[i];
while(TI0==0); TI0 = 0;
}
}
//-----------------------------------------------------------------------------------------------------------
// 发送PPP连接建立的第7条交互语句子程序
void EXCH_SEND7()
{
UINT xdata i,len=16;
Fcs16(EXCHANGE7,len);
for(i=0;i<len;i++)
{
TI0 = 0;
SBUF0 = EXCHANGE7[i];
while(TI0==0); TI0 = 0;
}
}
//--------------------------------------------------------------------
// Interrupt Programe
//--------------------------------------------------------------------
// Timer3 interrupt programe
void Timer3_Interrupt(void) interrupt 14
{
unsigned char i;
TMR3CN &=0x7f; // Clear TF3
if(Timer3_Counter<300){ //Wait 1s
Timer3_Counter++;
}
else{
Timer3_Counter = 0;
counter_timer3++;
if(Net_Ok_Flag==1){
if(CAIJI_Timer != 0) // 采集板重发数据定时处理
{
CAIJI_Timer--;
if(CAIJI_Timer == 0)
{
CAIJI_Timer_End = 1;
}
}
if(WAVE_Timer != 0) // 监控中心重发数据定时处理
{
WAVE_Timer--;
if(WAVE_Timer == 0)
{
WAVE_Timer_End = 1;
}
}
}
else{
if(Timer3_Flag==1){
if(counter_timer3>20){
counter_timer3=0;
TMR3CN &=0xFB; //Closing Timer3
Reset_Flag=1; //Setting reset Flag
}
else{
//EXCH_SEND4();
EXCH_SEND4_Flag=1;
}
}
else{
if(counter_timer3>10){ //sending AT+CSQ more than 10 ,reset
WDTCN = 0xa5;
for(i=0;i<100;i++)Delay10ms();
}
}
}
}
}
//-----------------------------------------------------------------------------
// PCA 中断服务子程序
void PCA_ISR(void) interrupt 9
{
static char SUTXST = 0; // SW_UART TX state variable
static char SURXST = 0; // SW_UART RX state variable
static unsigned char RXSHIFT; // SW_UART RX Shift Register
unsigned int PCA_TEMP; // Temporary storage variable for
// manipulating PCA module high & low bytes.
// Check receive interrupt flag first; service if CCF0 is set.
if (CCF0){
CCF0 = 0; // Clear interrupt flag.
switch (SURXST){
// State 0: START bit received.
// In this state, a negative edge on SW_TX has caused the interrupt,
// meaning a START has been detected and the PCA0CP0 registers have
// captured the value of PCA0.
// - Check for receive enable and good START bit
// - Switch PCA module 0 to software timer mode
// - Add 3/2 bit time to module 0 capture registers to sample LSB.
// - Increment RX state variable.
case 0:
if (SREN & ~SW_RX){ // Check for receive enable and a good
// START bit.
PCA_TEMP = (PCA0CPH0 < 8); // Read module 0 contents into
PCA_TEMP |= PCA0CPL0; // PCA_TEMP.
PCA_TEMP += TH_TIME_COUNT; // Add 3/2 bit times to PCA_TEMP
PCA0CPL0 = PCA_TEMP; // Restore PCA0CPL0 and PCA0CPH0
PCA0CPH0 = (PCA_TEMP >> 8); // with the updated value
PCA0CPM0 = 0x49; // Change module 0 to software
// timer mode, interrupts enabled.
SURXST++; // Update RX state variable.
}
break;
// States 1-8: Bit Received
// - Sample SW_RX pin
// - Shift new bit into RXSHIFT
// - Add 1 bit time to module 0 capture registers
// - Increment RX state variable
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
RXSHIFT = RXSHIFT >> 1; // Shift right 1 bit
if (SW_RX) // If SW_RX=1,
RXSHIFT |= 0x80; // shift '1' into RXSHIFT msb
PCA_TEMP = (PCA0CPH0 < 8); // Read module 0 contents into
PCA_TEMP |= PCA0CPL0; // PCA_TEMP.
PCA_TEMP += TIME_COUNT; // Add 1 bit time to PCA_TEMP
PCA0CPL0 = PCA_TEMP; // Restore PCA0CPL0 and PCA0CPH0
PCA0CPH0 = (PCA_TEMP >> 8); // with the updated value
SURXST++; // Update RX state variable.
break;
// State 9: 8-bits received, Capture STOP bit.
// - Move RXSHIFT into RDR.
// - Set SRI (indicate receive complete).
// - Prepare module 0 for next transfer.
// - Reset RX state variable.
// - Trigger IE7 if user-level interrupt support is enabled.
case 9:
RDR = RXSHIFT; // Move received data to receive register.
SRI = 1; // Set receive complete indicator.
PCA0CPM0 = 0x11; // Switch module 0 to negative capture
// mode; interrupt enabled for START
// detection.
SURXST = 0; // Reset RX state variable.
if (SES){ // If user-level interrupt support enabled
EIE2 |= 0x20; // Enable IE7.
PRT1IF |= 0x80; // Trigger IE7.
}
break;
}
}
// Check Transmit interrupt; service if CCF1 is set.
else if (CCF1){
CCF1 = 0; // Clear interrupt flag
switch (SUTXST){
// State 0: Transmit Initiated.
// Here, the user has loaded a byte to transmit into TDR, and set the
// module 1 interrupt to initiate the transfer.
// - Transmit START bit (drop SW_TX)
// - Read PCA0, add one bit time, & store in module 1 capture registers
// for first bit.
// - Increment TX state variable.
case 0:
SW_TX = 0; // Drop TX pin as START bit.
PCA_TEMP = PCA0L; // Read PCA counter value into
PCA_TEMP |= (PCA0H < 8); // PCA_TEMP.
PCA_TEMP += TIME_COUNT; // Add 1 bit time.
PCA0CPL1 = PCA_TEMP; // Store updated match value into
PCA0CPH1 = (PCA_TEMP >> 8); // module1 capture/compare registers.
PCA0CPM1 |= 0x48; // Enable module 1 software timer.
SUTXST++; // Update TX state variable.
break;
// States 1-9: Transmit Bit.
// - Output LSB of TDR onto TX
// - Shift TDR 1 bit right.
// - Shift a '1' into MSB of TDR for STOP bit in State 9.
// - Add 1 bit time to module 1 capture register
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
SW_TX = (TDR & 0x01); // Output LSB of TDR onto SW_TX pin.
TDR >>= 1; // Shift TDR right 1 bit.
TDR |= 0x80; // Shift '1' into MSB of TDR for
// STOP bit in State 9.
PCA_TEMP = (PCA0CPH1 < 8); // Read module 0 contents into
PCA_TEMP |= PCA0CPL1; // PCA_TEMP.
PCA_TEMP += TIME_COUNT; // Add 1 bit time to PCA_TEMP
PCA0CPL1 = PCA_TEMP; // Restore PCA0CPL1 and PCA0CPH1
PCA0CPH1 = (PCA_TEMP >> 8); // with the updated value
SUTXST++; // Update TX state variable.
break;
// State 10: Last bit has been transmitted. Transmit STOP bit
// and end transfer.
// - Transmit STOP bit
// - Set TX Complete indicator, clear Busy flag
// - Reset TX state
// - Prepare module 1 for next transfer.
// - Trigger IE7 interrupt if user-level interrupts enabled.
case 10:
STI = 1; // Indicate TX complete.
SUTXST = 0; // Reset TX state.
SW_TX = 1; // SW_TX should remain high.
PCA0CPM1 = 0x01; // Disable module 1 software timer; leave
// interrupt enabled for next transmit.
if (SES){ // If user-level interrupt support enabled:
EIE2 |= 0x20; // Enable IE7.
PRT1IF |= 0x80; // Trigger IE7.
}
STXBSY = 0; // SW_UART TX free.
break;
}
}
}
//----------------------------------------------------------------------------------------
// USER_ISR: User SW_UART Interrupt Service Routine (IE7 ISR)
// If interrupt-mode test code is enabled, this ISR
// transmits 15 characters and receives 15 characters. This routine is triggered each
// time a SW_UART transmit or receive is completed.
// - Checks receive complete indicator, and services.
// - Checks transmit complete indicator, and services.
// - Checks for transmits or receives that completed during the ISR; if so, triggers the
// interrupt again.
// 软串口中断服务程序(外部中断7服务程序）
void USER_ISR(void) interrupt 19 // IE7 Interrupt Service Routine
{
unsigned char Rec_Data;
PRT1IF &= ~(0x80); // Clear IE7 interrupt flag
if (SRI) // If Receive Complete:
{
SRI = 0; // Clear receive flag.
Rec_Data=RDR;
if (Receive_Ini_Flag==0)
{
if(Rec_Data==0xa5)
{
Receive_Ini_Flag=1; //Has received the first byte
}
}
else if ( Receive_Ini_Flag==1)
{
if(Rec_Data==0xa5)
{
Receive_Ini_Flag=2;
Ini_Data_BufferPoint=Ini_Data_Buffer;
Ini_Data_Num_Reci=0;
}
else
{
Receive_Ini_Flag=0;
}
}
else if ( Receive_Ini_Flag==2)
{
*(Ini_Data_BufferPoint+Ini_Data_Num_Reci)=Rec_Data;
Ini_Data_Num_Reci++;
if( Ini_Data_Num_Reci==23)
{
Receive_Ini_Flag=0;
Ini_Data_Num_Reci=0;
//待处理程序
Ini_Data_Flag=1;
}
}
else
{
Receive_Ini_Flag=0;
}
}
else if (STI)
{ // If Transmit Complete:
STI = 0; // Clear transmit flag.
if (Ini_Data_Num_Send<23) // If less than 15 characters transmitted:
{
STXBSY = 1; // Claim SW_UART Transmitter.
TDR = *(Ini_Data_BufferPoint+Ini_Data_Num_Send);
Ini_Data_Num_Send++; // Increment variable, transmit.
CCF1 = 1; // Force module 0 interrupt to initiate TX
}
else
{
Ini_Data_Num_Send=0;
}
Ini_Data_Flag=0;
}
}
//--------------------------------------------------------------
//WAVECOM 数据接收子程序：串口0中断服务程序
void Serial0_WAVECOM(void) interrupt 4
{
EA=0;
if (RI0)
{
RI0=0;
if(RECEIVE_FLAG==0)
{
if(SBUF0==0x7E)
{
RECEIVE_FLAG=1;
RECEIVEBUFFERPOINT=RECEIVEBUFFER;
WAVE_Receive_Num = 0;
}
}
else
{
if(SBUF0==0x7E)
{
if(RECEIVEBUFFERPOINT!=RECEIVEBUFFER) //排除连续收到两个7E，数据长度为0的错误情况
{
RECEIVE_FLAG=0;
PPP_Rec_Complete = 1;
}
}
else
{
if(PADDING_Flag==1)
{
*RECEIVEBUFFERPOINT=SBUF0;
*RECEIVEBUFFERPOINT^=0x20;
PADDING_Flag=0;
RECEIVEBUFFERPOINT++;
WAVE_Receive_Num++;
}
else
{
if(SBUF0==0x7D)
PADDING_Flag=1;
else
{
*RECEIVEBUFFERPOINT=SBUF0;
RECEIVEBUFFERPOINT++;
WAVE_Receive_Num++;
}
}
}
}
}
EA=1;
}
//-------------------------------------------------------------
//-------------------------------------------------------------
// 采集板数据接收子程序：串口1中断服务程序
// Head_Flag=0x0E End_Flag=0x05 0x0A means 0x7D
// when x<0x10 ,x= 0x7D x^0x10
void Serial1_CaiJi(void) interrupt 20
{
if((SCON1 & 0x01)!=0x00){
SCON1 &= 0xFE; // 清串口1标字位
if(SBUF1==0x0E){ // 接收帧头
Receive_Flag_UART1=1;
CAIJI_Receive_Len = 0;
}
else{
if(Receive_Flag_UART1==1){
if(SBUF1==0x05){
Receive_Flag_UART1=0;
Padding_Flag_UART1=0;
UART1_Rec_Complete=1;
}
else if(Padding_Flag_UART1==1){
Padding_Flag_UART1=0;
Receive_Buf_UAR1[CAIJI_Receive_Len] = SBUF1;
Receive_Buf_UAR1[CAIJI_Receive_Len] ^= 0x7D;
CAIJI_Receive_Len++;
}
else if(SBUF1==0x7D){
Padding_Flag_UART1=1;
}
else if(SBUF1==0x0A){
Receive_Buf_UAR1[CAIJI_Receive_Len] = 0x7D;
CAIJI_Receive_Len++;
}
else{
Receive_Buf_UAR1[CAIJI_Receive_Len] = SBUF1;
CAIJI_Receive_Len++;
}
}
}
}
}
// 定时发送测试帧子程序 ：外部中断0
void TestNetwork(void) interrupt 0
{
unsigned char xdata temp1;
unsigned char xdata temp2;
Timer_Num++;
// 测试间隔到否
CS_RTC = 1;
if(Timer_Num == XBYTE[StartAddress + Time_Interval])
{
if(Test_Frame_Answer == 1)
{
WDTCN = 0xa5; // 重启
}
else
{
Send_Test_Frame = 1;
Test_Frame_Answer = 1;
Timer_Num = 0;
}
}
CS_RTC=0;读时钟芯片的寄存器C
temp1 = RegC; //,用于中断标志位清0
while(RegA & 0x80 != 0x00);
temp1 = Hour;
temp2 = Minute;
CS_RTC=1;
//测试定时采集到否
if((temp1 == XBYTE[StartAddress+UP_Send_Time]) && (temp2 == XBYTE[StartAddress+UP_Send_Time+1]))
{
Timer_Gather_Flag = 1;
}
}
// -------------------------------------------------------------------
// 外部FLASH处理程序代码
//擦除FLASH子程序
void Erase_Chip(void)
{
unsigned int i,j;
Address5555=0xAA;
Address2AAA=0x55;
Address5555=0x80;
Address5555=0xAA;
Address2AAA=0x55;
Address5555=0x10;
for(i=0;i<1000;i++) for(j=0;j<1000;j++);
}
//擦除FLASH扇区子程序
void Erase_Sector(unsigned int w_address)
{
unsigned int i,j;
Address5555=0xAA;
Address2AAA=0x55;
Address5555=0x80;
Address5555=0xAA;
Address2AAA=0x55;
XBYTE[w_address]=0x30;
for(i=0;i<100;i++) for(j=0;j<1000;j++);
}
//写FLASH操作子程序
void Write_Byte(unsigned int w_address, unsigned char w_byte)
{
unsigned int i;
CS_RTC=1;
Address5555=0xAA;
Address2AAA=0x55;
Address5555=0xA0;
XBYTE[w_address]=w_byte;
for(i=0;i<1000;i++); //for(i=0;i<10000;i++); 减少10倍
CS_RTC=0;
}
// ------------------------------------------------------------------
// ------------------------------------------------------------------
// 应用程序校验代码
void CHECKSUM_UDP(unsigned int Data_length)
{
unsigned char i;
long sum;
unsigned char xdata Temp_Buffer[350];
sum = cksum(IP_Head,20);
IP_Head[10] = ((sum >> 8) & 0x00ff);
IP_Head[11] = (sum & 0x00ff); // least significant byte first
for(i=0;i<8;i++) Temp_Buffer[i] = IP_Head[i+12];
Temp_Buffer[8] = 0x0;
Temp_Buffer[9] = IP_Head[9];
Temp_Buffer[10] = UDP_Head[4];
Temp_Buffer[11] = UDP_Head[5];
for(i=0;i<8;i++) Temp_Buffer[i+12] = UDP_Head[i];
for(i=0;i<Data_length;i++)Temp_Buffer[i+20] = WAVE_Command_Buf[i];
sum = cksum(Temp_Buffer,20+Data_length);
UDP_Head[6] = ((sum >> 8) & 0x00ff);
UDP_Head[7] = (sum & 0x00ff); // least significant byte first
}
//-------------------------------------------------------------------------------------------------------
long cksum(unsigned char *ip, int len)
{
register long sum = 0;
while( len > 1 )
{
sum += *((unsigned short *)ip)++;
len -= 2;
}
if( len > 0 )
sum += *(unsigned char *)ip;
while (sum>>16)
sum = (sum & 0xffff) + (sum >> 16);
return ~sum;
}
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// 应用程序段
void SEND_DATA_WAVECOM(unsigned int data_len)
{
unsigned int i;
unsigned char xdata Temp_Buffer[400];
unsigned int buffer_len=0;
/*
// 网络不同且没经过初始化,不允许发数据
if((GPRS_OK !=1) || (Init_Flag != 1))
{
return;
}
// 如为奇数后面补0
i = data_len%2;
if(i!=0)
{
WAVE_Command_Buf[data_len] = 0;
data_len++;
}
*/
*( unsigned int xdata *)(IP_Head+2)=28+data_len; // write total length to IP head
IP_Head[10]=IP_Head[11]=0x00; // clear check_sum buffer in IP_HEAD
*(unsigned int xdata *)(UDP_Head+4)=8+data_len; // write UDP length to UDP head
UDP_Head[6]=UDP_Head[7]=0x00; // clear check_sum buffer in UDP_HEAD
Frame_End[0]=Frame_End[1]=0x00; // clear FCS buffer
CHECKSUM_UDP(data_len);
for(i=0;i<2;i++) Temp_Buffer[buffer_len++] = Frame_Head[i];
for(i=0;i<20;i++) Temp_Buffer[buffer_len++] = IP_Head[i];
for(i=0;i<8;i++) Temp_Buffer[buffer_len++] = UDP_Head[i];
for(i=0;i<data_len;i++) Temp_Buffer[buffer_len++] = WAVE_Command_Buf[i];
for(i=0;i<3;i++) Temp_Buffer[buffer_len++] = Frame_End[i];
Fcs16(Temp_Buffer,buffer_len); // create FSC and write to buffer
for(i=0;i<11;i++) // send data to UART0
{
TI0 = 0;
SBUF0 = Temp_Buffer[i];
while(TI0==0); TI0 = 0;
}
SBUF0 = 0x7D;
while(TI0==0);TI0=0;
SBUF0 = 0x31;
while(TI0==0);TI0=0;
for(i=12;i<buffer_len-1;i++)
{
if(Temp_Buffer[i] == 0x7E){
SBUF0 = 0x7D;
while(TI0==0);TI0=0;
SBUF0 = 0x5E;
while(TI0==0);TI0=0;
}
else if(Temp_Buffer[i] == 0x7D){
SBUF0 = 0x7D;
while(TI0==0);TI0=0;
SBUF0 = 0x5D;
while(TI0==0);TI0=0;
}
/* else if(Temp_Buffer[i] 0x20){
SBUF0 = 0x7D;
while(TI0==0);TI0=0;
SBUF0 = Temp_Buffer[i]^0x20;
while(TI0==0);TI0=0;
}*/
else{
SBUF0 = Temp_Buffer[i];
while(TI0==0);TI0=0;
}
}
SBUF0 = 0x7E;
while(TI0==0);TI0=0;
}
// 向采集板发送子程序
void SEND_DATA_CAIJI(unsigned char Data_Len)
{
unsigned char i;
unsigned char checksum=0;
for(i=0;i<Data_Len;i++)
{
checksum = checksum + CAIJI_Command_Buf[i];
}
CAIJI_Command_Buf[Data_Len] = checksum;
SCON1 &=0xFD;
SBUF1 = 0x0E; // 发送帧头
while(TI1==0); SCON1 &= 0xFD;
for(i=0;i<Data_Len+1;i++) // 发送数据
{
if(CAIJI_Command_Buf[i] == 0x7D)
{
SBUF1 = 0x0A;
while(TI1==0); SCON1 &=0xFD;
}
else if(CAIJI_Command_Buf[i]<0x10)
{
SBUF1 = 0x7D;
while(TI1==0); SCON1 &=0xFD;
SBUF1 = CAIJI_Command_Buf[i]^0x7D;
while(TI1==0); SCON1 &=0xFD;
}
else
{
SBUF1 = CAIJI_Command_Buf[i];
while(TI1==0); SCON1 &=0xFD;
}
}
SBUF1 = 0x05; // 发送帧尾
while(TI1==0); SCON1 &=0xFD;
}
// 采集板送来数据处理子程序
void DEAL_DATA_CAIJI(void)
{
unsigned int i;
unsigned char check_sum=0;
for(i=0;i<CAIJI_Receive_Len-1;i++)
{
CAIJI_Data_Buffer[i] = Receive_Buf_UAR1[i]; // 保存数据到数据缓存区
check_sum = check_sum + Receive_Buf_UAR1[i]; // 计算校验和
}
if(check_sum != Receive_Buf_UAR1[CAIJI_Receive_Len-1]) // 校验校验和
{
return;
}
// 数据传输正确，进行处理
CAIJI_Data_Len = CAIJI_Receive_Len - 1;
switch(CAIJI_Data_Buffer[1])
{
case 0xAA: // 应答代码
switch(CAIJI_Data_Buffer[2])
{
case 0x10:
// 普通命令应答处理
if(CAIJI_Data_Buffer[0] != (CAIJI_Send_SeqNr-1))
{
return; // 序列号不匹配，不作处理
}
// 停止向采集板命令重传
CAIJI_Resend_Flag = 0;
CAIJI_Timer = 0;
if(WAVE_Resend_Flag == 0)
{
TMR3CN &=0xFB; // 关闭定时器3
}
break;
case 0x20:
// 采集数据处理
Frame_Data_Deal();
break;
}
case 0x55:
switch(CAIJI_Data_Buffer[2])
{
case 0x00:
Trouble_Inform_Comm(); // 故障通知命令
break;
case 0x01:
Data_Ready_Comm(); // 数据准备好命令
break;
}
}
}
// 采集板送来的帧处理
void Frame_Data_Deal(void)
{
unsigned int i;
unsigned int address;
// 判断序列号
if(CAIJI_Data_Buffer[0] != CAIJI_Send_SeqNr-1 )
{
return;
}
// 判断帧序号
if(CAIJI_Data_Buffer[5] != Frame_Num)
{
return;
}
// 判断帧长度
if(CAIJI_Data_Buffer[3]>245)
{
return;
}
// 停止向采集板命令重传
CAIJI_Resend_Flag = 0;
CAIJI_Timer = 0;
if(WAVE_Resend_Flag == 0)
{
TMR3CN &=0xFB; // 关闭定时器3
}
// 设置向监控中心发送的命令报文
WAVE_Comm_Len = 0;
if(WAVECOM_Gather == 1)
{
// 发送被动上传数据命令
{
// 命令头
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Send_SeqNr++; // 命令序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // command [0]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // command [1]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x03+CAIJI_Data_Len-0x06; // 数据长度
// 中心序号
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Receive_SeqNr;
// 尾帧标识
WAVE_Command_Buf[WAVE_Comm_Len++] = CAIJI_Data_Buffer[4];
// 帧序号
WAVE_Command_Buf[WAVE_Comm_Len++] = Frame_Num;
// 送入采集数据
for(i=0;i<CAIJI_Data_Len - 6;i++)
{
WAVE_Command_Buf[WAVE_Comm_Len++] = CAIJI_Data_Buffer[6+i];
}
}
}
else
{
// 现场定时上传采集数据
{
// 命令头
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Send_SeqNr++; // 命令报文序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 发送命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // Command[0]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x01; // Command[1]
WAVE_Command_Buf[WAVE_Comm_Len++] = CAIJI_Data_Len + 3; // 数据长度
// 尾帧标识
WAVE_Command_Buf[WAVE_Comm_Len++] = CAIJI_Data_Buffer[4];
// 帧序号
WAVE_Command_Buf[WAVE_Comm_Len++] = Frame_Num;
// 设置时间
{
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x14; // 年（高位）
CS_RTC = 0; // 从时间芯片读取时间
while(RegA & 0x80 != 0x00);
WAVE_Command_Buf[WAVE_Comm_Len++] = Year;
WAVE_Command_Buf[WAVE_Comm_Len++] = Month;
WAVE_Command_Buf[WAVE_Comm_Len++] = Day;
WAVE_Command_Buf[WAVE_Comm_Len++] = Hour;
WAVE_Command_Buf[WAVE_Comm_Len++] = Minute;
WAVE_Command_Buf[WAVE_Comm_Len++] = Second;
CS_RTC = 1;
}
// 送入采集数据
for(i=0;i<CAIJI_Data_Len - 6;i++)
{
WAVE_Command_Buf[WAVE_Comm_Len++] = CAIJI_Data_Buffer[6+i];
}
// 备份数据
{
// 备份长度
Write_Byte(Current_Add,CAIJI_Data_Len+1);
Current_Add++;
// 备份数据
for(i=0;i<CAIJI_Data_Len+1;i++)
{
Write_Byte(Current_Add,WAVE_Command_Buf[7+i]);
Current_Add++;
}
}
}
}
// 向中心发命令
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
// 设置重传标识
WAVE_Resend_Flag = 1; // 设置命令重传标识
WAVE_Resend_Num = 0;
WAVE_Timer = 10;
TMR3CN |= 0x04; // 开启定时器3
// ----------------------------------------------------------
// 设置后续重发帧
Frame_Num++;
if(CAIJI_Data_Buffer[4] == 0)
{
// 帧传输结束
// 清数据采集好标识
Data_Ready_Flag = 0;
if(WAVECOM_Gather == 1)
{
WAVECOM_Gather = 0;
if(Time_Gather == 1)
{
// 向采集板发送采集命令(类型为定时发送规定的)
// 命令头
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x05;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x04;
// 冲次数
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x01;
// 参量类型
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x03;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x08;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x10;
// 发送数据
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置命令重传标识
CAIJI_Resend_Flag = 1;
CAIJI_Resend_Num = 0;
CAIJI_Timer = 1;
TMR3CN |= 0x04; // 开启定时器3
// 设置初始帧序号
Frame_Num = 1;
}
else
{
Data_Gather_Comm = 0;
}
}
else
{
// 清除数据采集标识
Time_Gather = 0;
Data_Gather_Comm = 0;
// 设置备份项数和备份数据发送标识
address = Backup_Index*0x1000;
// Write_Byte(address,0xAA); // 标识该帧已发送
Write_Byte(address,Frame_Num-1);
// 修改记录号
if(Backup_Index == 4)
{
Backup_Index = 2;
CS_RTC = 0;
Record_Ind = 2;
CS_RTC = 1;
}
else
{
Backup_Index++;
CS_RTC = 0;
Record_Ind = Backup_Index;
CS_RTC = 1;
}
}
}
}
// 故障通知命令处理
void Trouble_Inform_Comm(void)
{
CAIJI_Receive_SeqNr = CAIJI_Data_Buffer[0]; // 保存接收序列号
// 停止其它一切的命令及应答
WAVE_Resend_Flag = 0;
WAVE_Timer = 0;
CAIJI_Resend_Flag = 0;
CAIJI_Timer = 0;
TMR3CN &=0xFB; // 关闭定时器3
WAVECOM_Gather = 0;
Time_Gather = 0;
Data_Gather_Comm = 0;
// 向采集板回送应答代码
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Receive_SeqNr;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0xAA;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x10;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x00;
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 向监控中心发命令代码
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Send_SeqNr++; // 命令报文序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 发送命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // Command[0]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x02; // Command[1]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x08+0x03; // 数据长度
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x14; // 年（高位）
CS_RTC = 0; // 从时间芯片读取时间
while(RegA & 0x80 != 0x00);
WAVE_Command_Buf[WAVE_Comm_Len++] = Year;
WAVE_Command_Buf[WAVE_Comm_Len++] = Month;
WAVE_Command_Buf[WAVE_Comm_Len++] = Day;
WAVE_Command_Buf[WAVE_Comm_Len++] = Hour;
WAVE_Command_Buf[WAVE_Comm_Len++] = Minute;
WAVE_Command_Buf[WAVE_Comm_Len++] = Second;
CS_RTC = 1;
WAVE_Command_Buf[WAVE_Comm_Len++] = 0xAA; // 故障标识
WAVE_Command_Buf[WAVE_Comm_Len++] = CAIJI_Data_Buffer[4]; // 故障信息
WAVE_Command_Buf[WAVE_Comm_Len++] = CAIJI_Data_Buffer[5];
WAVE_Command_Buf[WAVE_Comm_Len++] = CAIJI_Data_Buffer[6];
WAVE_Resend_Flag = 1; // 设置命令重传标识
WAVE_Resend_Num = 0;
WAVE_Timer = 10;
TMR3CN |= 0x04; // 开启定时器3
}
// 数据准备好命令处理
void Data_Ready_Comm()
{
if(WAVE_Resend_Flag == 1 || CAIJI_Resend_Flag == 1)
{
return; // 如有数据重发，不作处理
}
CAIJI_Receive_SeqNr = CAIJI_Data_Buffer[0]; // 保存接收序列号
// 向采集板回送应答代码
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Receive_SeqNr;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0xAA;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x10;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x00;
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置数据准备好标识
Data_Ready_Flag = 1;
}
// 向采集板取数据命令
void Get_Data_Comm(void)
{
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x06;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x01;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = Frame_Num;
// 发送数据
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置命令重传标识
CAIJI_Resend_Flag = 1;
CAIJI_Resend_Num = 0;
CAIJI_Timer = 1;
TMR3CN |= 0x04; // 开启定时器3
}
// --------------------------------------------------------------------------------------------------
// 处理监控中心发来的UDP信息
void WAVE_Rec_Ack(void)
{
unsigned char i;
for(i=0;i<WAVE_Receive_Num - 31;i++)
{
WAVE_Data_Buffer[i] = RECEIVEBUFFER[29+i];
}
switch(WAVE_Data_Buffer[1]) // 命令代码和应答代码分类
{
case 0x00: // 命令代码
if(WAVE_Resend_Flag == 1 || CAIJI_Resend_Flag == 1 || Data_Gather_Comm == 1)
{
return; // 当前有数据重传或者正在进行数据采集，不应答
}
switch(WAVE_Data_Buffer[2]) // 命令类型分类
{
case 0x00: // 参数设置命令
switch(WAVE_Data_Buffer[3])
{
case 0x00: // 设置油井编号和油井冲次
Machine_Message_Set();
break;
case 0x01: // 设置油管回压超限值
Pressure_Limit_Set();
break;
case 0x02: // 设置电动机功率超限值
Power_Limit_Set();
break;
case 0x03: // 设置上传时间
UP_Timer_Set();
break;
case 0x04: // 设置时间间隔
Time_Interval_Set();
break;
default:
break;
}
case 0x01: // 数据采集命令
Data_Gather_Set();
break;
case 0x02: // 控制命令
switch(WAVE_Data_Buffer[3])
{
case 0x00: // 开机命令
Open_Machine_Comm();
break;
case 0x01: // 关机命令
Close_Machine_Comm();
break;
default:
break;
}
default:
break;
}
case 0x01: // 应答报文
if(WAVE_Data_Buffer[0] != WAVE_Send_SeqNr-1)
{
return;
}
// 清除重发标识
WAVE_Resend_Flag = 0;
WAVE_Timer = 0;
Test_Frame_Answer = 0;
if(CAIJI_Resend_Flag == 0)
{
TMR3CN &=0xFB; //Stop Timer3
}
break;
default:
break;
}
}
// 油井信息设置命令
void Machine_Message_Set(void)
{
unsigned char i;
unsigned char xdata temp[19];
// 校验长度
if(WAVE_Data_Buffer[4] != 3)
{
return;
}
// 备份数据
for(i=1;i<17;i++)
{
temp[i-1] = XBYTE[StartAddress+i];
}
// 擦除扇区
CS_RTC = 1;
Erase_Sector(StartAddress);
// 保存发来的序列号
WAVE_Receive_SeqNr = WAVE_Data_Buffer[0];
// 恢复前面的数据
for(i=0;i<6;i++)
{
Write_Byte(StartAddress+1+i,temp[i]);
}
// 写入修改的数据
for(i=0;i<2;i++)
{
Write_Byte(StartAddress+Machine_Num+i,WAVE_Data_Buffer[5+i]); // 油井编号
}
Write_Byte(StartAddress+Machine_Cycle,WAVE_Data_Buffer[7]); // 油井冲次
// 恢复后面的数据
for(i=9;i<16;i++)
{
Write_Byte(StartAddress+1+i,temp[i]);
}
Write_Byte(StartAddress,0xAA); // 设置FLASH设置标识位
// 向监控中心发应答信息
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Receive_SeqNr; // 应答序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x01; // 应答命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 状态
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 长度
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
// 向采集板发送设置参数
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x00;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x01;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = WAVE_Data_Buffer[7];
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置重发标识
CAIJI_Resend_Flag = 1;
CAIJI_Timer = 1;
CAIJI_Resend_Num =0 ;
TMR3CN |= 0x04; // 开启定时器3
}
// 油管回压超限值设置命令
void Pressure_Limit_Set(void)
{
unsigned char i;
unsigned char xdata temp[19];
// 校验长度
if(WAVE_Data_Buffer[4] != 0x02)
{
return;
}
// 备份数据
for(i=1;i<17;i++)
{
temp[i-1] = XBYTE[StartAddress+i];
}
// 擦除扇区
CS_RTC = 1;
Erase_Sector(StartAddress);
// 保存发来底序列号
WAVE_Receive_SeqNr = WAVE_Data_Buffer[0];
// 恢复前面的数据
for(i=0;i<9;i++)
{
Write_Byte(StartAddress+1+i,temp[i]);
}
// 写入修改的数据
for(i=0;i<2;i++)
{
Write_Byte(StartAddress+Pressure_Limit+i,WAVE_Data_Buffer[5+i]); // 油管回压超限值
}
// 恢复后面的数据
for(i=11;i<16;i++)
{
Write_Byte(StartAddress+1+i,temp[i]);
}
Write_Byte(StartAddress,0xAA); // 设置FLASH设置标识位
// 向监控中心发应答信息
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Receive_SeqNr; // 应答序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x01; // 应答命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 状态
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 长度
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
// 向采集板发送设置参数
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x01;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x02;
for(i=0;i<2;i++)
{
CAIJI_Command_Buf[CAIJI_Comm_Len++] = WAVE_Data_Buffer[5+i];
}
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置重发标识
CAIJI_Resend_Flag = 1;
CAIJI_Timer = 1;
CAIJI_Resend_Num =0 ;
TMR3CN |= 0x04; // 开启定时器3
}
// 电动机功率超限值设置命令
void Power_Limit_Set(void)
{
unsigned char i;
unsigned char xdata temp[19];
// 校验长度
if(WAVE_Data_Buffer[4] !=0x02)
{
return;
}
// 备份数据
for(i=1;i<17;i++)
{
temp[i-1] = XBYTE[StartAddress+i];
}
// 擦除扇区
CS_RTC = 1;
Erase_Sector(StartAddress);
WAVE_Receive_SeqNr = WAVE_Data_Buffer[0];
// 恢复前面的数据
for(i=0;i<11;i++)
{
Write_Byte(StartAddress+1+i,temp[i]);
}
// 写入修改的数据
for(i=0;i<2;i++)
{
Write_Byte(StartAddress+Power_Limit+i,WAVE_Data_Buffer[5+i]); // 电动机功率超限值
}
// 恢复后面的数据
for(i=13;i<16;i++)
{
Write_Byte(StartAddress+1+i,temp[i]);
}
Write_Byte(StartAddress,0xAA); // 设置FLASH设置标识位
// 向监控中心发应答信息
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Receive_SeqNr; // 应答序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x01; // 应答命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 状态
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 长度
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
// 向采集板发送设置参数
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x02;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x02;
for(i=0;i<2;i++)
{
CAIJI_Command_Buf[CAIJI_Comm_Len++] = WAVE_Data_Buffer[5+i];
}
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置重发标识
CAIJI_Resend_Flag = 1;
CAIJI_Timer = 1;
CAIJI_Resend_Num =0 ;
TMR3CN |= 0x04; // 开启定时器3
}
// 上传时间设置命令
void UP_Timer_Set(void)
{
unsigned char i;
unsigned char xdata temp[19];
// 校验数据长度
if(WAVE_Data_Buffer[4] != 0x02)
{
return;
}
// 备份数据
for(i=1;i<17;i++)
{
temp[i-1] = XBYTE[StartAddress+i];
}
// 擦除扇区
CS_RTC = 1;
Erase_Sector(StartAddress);
WAVE_Receive_SeqNr = WAVE_Data_Buffer[0];
// 恢复前面的数据
for(i=0;i<13;i++)
{
Write_Byte(StartAddress+1+i,temp[i]);
}
// 写入修改的数据
Write_Byte(StartAddress+UP_Send_Time,WAVE_Data_Buffer[5]); // 电动机功率超限值
Write_Byte(StartAddress+UP_Send_Time+1,WAVE_Data_Buffer[6]);
// 恢复后面的数据
for(i=15;i<16;i++)
{
Write_Byte(StartAddress+1+i,temp[i]);
}
Write_Byte(StartAddress,0xAA); // 设置FLASH设置标识位
// 向监控中心发应答信息
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Receive_SeqNr; // 应答序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x01; // 应答命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 状态
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 长度
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
}
// 时间间隔设置命令
void Time_Interval_Set(void)
{
unsigned char i;
unsigned char xdata temp[19];
// 校验数据长度
if(WAVE_Data_Buffer[4] != 0x01)
{
return;
}
// 备份数据
for(i=1;i<17;i++)
{
temp[i-1] = XBYTE[StartAddress+i];
}
// 擦除扇区
CS_RTC = 1;
Erase_Sector(StartAddress);
WAVE_Receive_SeqNr = WAVE_Data_Buffer[0];
// 恢复前面的数据
for(i=0;i<15;i++)
{
Write_Byte(StartAddress+1+i,temp[i]);
}
// 写入修改的数据
Write_Byte(StartAddress+Time_Interval,WAVE_Data_Buffer[5]); // 时间间隔
Write_Byte(StartAddress,0xAA); // 设置FLASH设置标识位
// 时间间隔计数器清0
Timer_Num = 0;
// 向监控中心发应答信息
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Receive_SeqNr; // 应答序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x01; // 应答命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 状态
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 长度
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
}
// 数据采集命令
void Data_Gather_Set(void)
{
unsigned char i;
// 校验数据长度
if(WAVE_Data_Buffer[4] != 0x04)
{
return;
}
// 校验冲次数
if((WAVE_Data_Buffer[5]>3) || (WAVE_Data_Buffer[5]==0) ) // 冲次数大于3，错误不处理
{
return;
}
WAVE_Receive_SeqNr = WAVE_Data_Buffer[0];
// 设置采集命令标识
Data_Gather_Comm = 1;
WAVECOM_Gather=1;
Frame_Num = 1;
// 向监控中心发应答信息
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Receive_SeqNr; // 应答序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x01; // 应答命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 状态
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 长度
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
// 向采集板发送数据采集命令
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x05;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x04; // 数据长度
for(i=0;i<4;i++)
{
CAIJI_Command_Buf[CAIJI_Comm_Len++] = WAVE_Data_Buffer[5+i];
}
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置重发标识
CAIJI_Resend_Flag = 1;
CAIJI_Timer = 1;
CAIJI_Resend_Num =0 ;
TMR3CN |= 0x04; // 开启定时器3
}
// 开机命令
void Open_Machine_Comm(void)
{
// 校验数据长度
if(WAVE_Data_Buffer[4] != 00)
{
return;
}
WAVE_Receive_SeqNr = WAVE_Data_Buffer[0];
// 向监控中心发应答信息
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Receive_SeqNr; // 应答序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x01; // 应答命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 状态
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 长度
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
// 向采集板发送设置参数
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x03;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x00;
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置重发标识
CAIJI_Resend_Flag = 1;
CAIJI_Timer = 1;
CAIJI_Resend_Num =0 ;
TMR3CN |= 0x04; // 开启定时器3
}
// 关机命令
void Close_Machine_Comm(void)
{
// 校验数据长度
if(WAVE_Data_Buffer[4] != 00)
{
return;
}
WAVE_Receive_SeqNr = WAVE_Data_Buffer[0];
// 向监控中心发应答信息
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Receive_SeqNr; // 应答序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x01; // 应答命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 状态
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 长度
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
// 向采集板发送设置参数
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x04;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x00;
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置重发标识
CAIJI_Resend_Flag = 1;
CAIJI_Timer = 1;
CAIJI_Resend_Num =0 ;
TMR3CN |= 0x04; // 开启定时器3
}
// 链路连接命令
void Link_Send_Comm(void)
{
unsigned char i;
if(Init_Flag != 1)
{
return; // 没有进行初始化，不能发链路命令
}
/*
// 发送链路命令
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Send_SeqNr++; // 命令序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // command[0]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x03; // command[1]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x02; // 数据长度
CS_RTC = 1;
for(i=0;i<2;i++)
{
WAVE_Command_Buf[WAVE_Comm_Len++] = XBYTE[StartAddress+Machine_Num+i];
}
SEND_DATA_WAVECOM(WAVE_Comm_Len); // 向监控中心发送数据
WAVE_Resend_Flag = 1; // 设置命令重传标识
WAVE_Resend_Num = 0;
WAVE_Timer = 10;
TMR3CN |= 0x04; // 开启定时器3
*/
}
// 发送测试帧命令
void Test_Frame_Send(void)
{
WAVE_Comm_Len = 0;
WAVE_Command_Buf[WAVE_Comm_Len++] = WAVE_Send_SeqNr++; // 命令序列号
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // 命令标识
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x00; // command[0]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x02; // command[1]
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x08; // 数据长度
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x14;
CS_RTC = 0; // 从时间芯片读取时间
while(RegA & 0x80 != 0x00);
WAVE_Command_Buf[WAVE_Comm_Len++] = Year;
WAVE_Command_Buf[WAVE_Comm_Len++] = Month;
WAVE_Command_Buf[WAVE_Comm_Len++] = Day;
WAVE_Command_Buf[WAVE_Comm_Len++] = Hour;
WAVE_Command_Buf[WAVE_Comm_Len++] = Minute;
WAVE_Command_Buf[WAVE_Comm_Len++] = Second;
CS_RTC = 1;
WAVE_Command_Buf[WAVE_Comm_Len++] = 0x55; // 运行正常
WAVE_Resend_Flag = 1; // 设置命令重传标识
WAVE_Resend_Num = 0;
WAVE_Timer = 10;
TMR3CN |= 0x04; // 开启定时器3
}
// 定时采集命令处理
void Timer_Gather_Deal(void)
{
Data_Gather_Comm = 1;
Time_Gather =1 ;
Current_Add = (Backup_Index+1)*0x1000 + 1;
if(WAVECOM_Gather != 1)
{
// 发送采集命令
CAIJI_Comm_Len = 0;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = CAIJI_Send_SeqNr++;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x55;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x05;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x04;
// 冲次数
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x01;
// 参量类型
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x03;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x08;
CAIJI_Command_Buf[CAIJI_Comm_Len++] = 0x10;
// 发送数据
SEND_DATA_CAIJI(CAIJI_Comm_Len);
// 设置命令重传标识
CAIJI_Resend_Flag = 1;
CAIJI_Resend_Num = 0;
CAIJI_Timer = 1;
TMR3CN |= 0x04; // 开启定时器3
// 设置初始帧序号
Frame_Num = 1;
}
}
//------------------------------------------------------------------------
// 重发程序处理块
// 采集板重发处理
void CAIJI_Resend_Deal(void)
{
if(CAIJI_Resend_Flag == 1)
{
CAIJI_Resend_Num++;
if(CAIJI_Resend_Num <3)
{
// 重发该命令
SEND_DATA_CAIJI(CAIJI_Comm_Len);
CAIJI_Timer = 1;
}
else
{
// 采集板无应答,出错
CAIJI_Resend_Flag = 0;
CAIJI_Timer = 0;
if(WAVE_Resend_Flag !=1)
{
TMR3CN &=0xFB; //Stop Timer3
}
// 采集命令出错处理(*************************)
}
}
}
void WAVE_Resend_Deal(void)
{
if(WAVE_Resend_Flag == 1)
{
WAVE_Resend_Num++;
if(WAVE_Resend_Num <3)
{
// 重发该命令
SEND_DATA_WAVECOM(WAVE_Comm_Len);
WAVE_Timer = 10;
}
else
{
// 采集板无应答,出错
WAVE_Resend_Flag = 0;
WAVE_Timer = 0;
if(CAIJI_Resend_Flag !=1)
{
TMR3CN &=0xFB; //Stop Timer3
}
// 采集命令出错处理(*************************)
}
}
}
// -----------------------------------------------------------------------
/*
// 测试程序块
void Flash_Test(void)
{
unsigned char xdata buffer1[4],buffer2[4];
unsigned char i;
for (i=0;i<4;i++)
{
buffer1[i]=0xDD;
buffer2[i]=0x00;
}
Erase_Sector(0x1000);
for(i=0;i<4;i++)
{
Write_Byte(0x1000+i,buffer1[i]);
CS_RTC=1;
buffer2[i]=XBYTE[0x1000+i];
}
}
void RTC_Test(void)
{
unsigned int i;
unsigned char xdata time_buffer[10] = {0x00,0x00,0x12,0x12,0x09,0x09,0x02,0x18,0x02,0x03};
RTC_Init();
CS_RTC = 0;
RegB |=0x20;
CS_RTC = 1;
EX0 = 1;
RTC_Time_Update(time_buffer);
// for(i=0;i<10000;i++) Delay10ms();
CS_RTC = 0;
// while(RegA & 0x80 == 0x00);
// for(i=0;i<10;i++)
// {
// time_buffer[i] = XBYTE[IniDataAddress+i];
// }
RegB |=0x20;
CS_RTC = 1;
EX0 = 1;
while (1);
}
*/