＃i nclude
sfr16 DPTR = 0x82;

typedef unsigned char INT8U;
typedef unsigned int INT16U;

#define YES 1
#define NO 0

//定義使用哪個定時器, 只可定義一個
//#define TIMER_0
#define TIMER_1

//定義串口收、發(fā)送管腳。
sbit rs_TXD = P2^1;
sbit rs_RXD = P2^0;

//根據(jù)定時器確定參數(shù)
#ifdef TIMER_0
#define TMOD_AND_WORD 0xF0;
#define TMOD_TIME_MODE 0x01;
#define TMOD_COUNT_MODE 0x05; //設置計數(shù)模式位
sbit TCON_ENABLE_TIMER = TCON^4;
sbit TCON_TFx = TCON^5; //中斷標志位
sbit IE_ETx = IE^1; //中斷允許位為 ET0
sbit IP_PTx = IP^1; //中斷優(yōu)先級

sfr rs_timerL = 0x8A; //TL0
sfr rs_timerH = 0x8C; //TH0
#endif

#ifdef TIMER_1
#define TMOD_AND_WORD 0x0F;
#define TMOD_TIME_MODE 0x10;
#define TMOD_COUNT_MODE 0x50; //設置計數(shù)模式位
sbit TCON_ENABLE_TIMER = TCON^6; //
sbit TCON_TFx = TCON^7; //中斷標志位
sbit IE_ETx = IE^3; //中斷允許位為 ET1
sbit IP_PTx = IP^4; //中斷優(yōu)先級

sfr rs_timerL = 0x8B; //TL1
sfr rs_timerH = 0x8D; //TH1
#endif

INT8U bdata rs_BUF; //串行收、發(fā)時用的移位暫存器。
sbit rs_BUF_bit7 = rs_BUF^7; //移位暫存器的最高位。
INT8U rs_shift_count; //移位計數(shù)器。

INT8U bdata rsFlags;
sbit rs_f_TI = rsFlags^0; //0:正在發(fā)送; 1: 一個字符完畢
sbit rs_f_RI_enable = rsFlags^1; //0:禁止接收; 1:允許接收
sbit rs_f_TI_enable = rsFlags^2; //0:禁止發(fā)送; 1:允許發(fā)送

//選擇以下一個晶體頻率
//#define Fosc 6000000 //6MHz
#define Fosc 11059200 //11.059MHz
//#define Fosc 12000000
//#define Fosc 18432000
//#define Fosc 20000000
//#define Fosc 24000000
//#define Fosc 30000000
//#define Fosc 40000000

//選擇以下一個波特率:
//#efine Baud 300 //11.059MHz時，baud 最低為 300
//#define Baud 1200
//#define Baud 2400
//#define Baud 4800
#define Baud 9600
//#define Baud 14400
//#define Baud 19200
//#define Baud 28800
//#define Baud 38400
//#define Baud 57600

//收、發(fā)一位所需定時器計數(shù)
#define rs_FULL_BIT0 ((Fosc/12) / Baud)
#define rs_FULL_BIT (65536 - rs_FULL_BIT0)
#define rs_FULL_BIT_H rs_FULL_BIT >> 8 //收、發(fā)一位所需定時器計數(shù)高位
#define rs_FULL_BIT_L (rs_FULL_BIT & 0x00FF) //收、發(fā)一位所需定時器計數(shù)低位

//檢測起始位的時間間隔所需定時器計數(shù)
#define rs_TEST0 rs_FULL_BIT0 / 4 //波特率較低時可以除以 3 或除以 2
#define rs_TEST ((~rs_TEST0))
#define rs_TEST_H rs_TEST >> 8 //高位
#define rs_TEST_L rs_TEST & 0x00FF //低位

//發(fā)送起始位所需定時器總計數(shù)
#define rs_START_BIT 0xFFFF - (Fosc/12/Baud) + 0x28
#define rs_START_BIT_H rs_START_BIT >> 8 //發(fā)送起始位所需定時器計數(shù)高位
#define rs_START_BIT_L rs_START_BIT & 0x00FF //發(fā)送起始位所需定時器計數(shù)低位

#define rs_RECEIVE_MAX 128 //最大接收長度
INT8U idata rs232buffer[rs_RECEIVE_MAX]; //收、發(fā)緩沖區(qū)
INT16U ReceivePoint; //接收數(shù)據(jù)存儲指針

void soft_rs232_interrupt( void );

#ifdef TIMER_0
void timer0 (void) interrupt 1 using 3
{
if (rs_RXD == 0 | rs_shift_count > 0)
{ soft_rs232_interrupt(); }
else
{
rs_timerH = rs_TEST_H;
rs_timerL = rs_TEST_L;
}
}
#endif

#ifdef TIMER_1
void timer1 (void) interrupt 3 using 3
{
if (rs_RXD == 0 | rs_shift_count > 0)
{ soft_rs232_interrupt(); }
else
{
rs_timerH = rs_TEST_H;
rs_timerL = rs_TEST_L;
}
}
#endif

void soft_rs232_init (void) //串口初始化
{
TCON_ENABLE_TIMER = 0; //停止定時器
TMOD &= TMOD_AND_WORD;
TMOD |= TMOD_TIME_MODE;
rs_RXD = 1; //接收腳置成高電平
rs_TXD = 1; //發(fā)射腳置成高電平
IP_PTx = 1; //置中斷優(yōu)先級為高
IE_ETx = 1; //允許定時器中斷
}

void soft_receive_init() //監(jiān)測起始位
{
TCON_ENABLE_TIMER = 0; //停止定時器
rs_timerH = rs_TEST_H;
rs_timerL = rs_TEST_L;
rs_shift_count = 0;
TCON_ENABLE_TIMER = 1; //啟動定時器
}

void soft_receive_enable() //允許接收
{
rs_f_RI_enable = 1; //允許接收
rs_f_TI_enable = 0; //禁止發(fā)送
soft_receive_init(); //監(jiān)測起始位, RXD 下降沿觸發(fā)接收字節(jié)過程.
}

void soft_send_enable (void) //允許發(fā)送
{
TCON_ENABLE_TIMER = 0; //停止定時器
rs_f_TI_enable = 1; //允許發(fā)送
rs_f_RI_enable = 0; //禁止接收

rs_shift_count = 0; //清移位計數(shù)器
rs_f_TI = 1; //發(fā)送一個字符完畢標志
TCON_ENABLE_TIMER = 1; //啟動定時器
}

void soft_rs232_interrupt( void )
{

if (rs_f_RI_enable == 1)
{
if (rs_shift_count == 0) //移位計數(shù)器==0, 表示檢測到起始位的起點
{
if ( rs_RXD == 1 )
{
soft_receive_enable (); //起始位錯, 從新開始
}
else
{
//下次中斷在數(shù)據(jù)位或停止位中的某時刻發(fā)生
rs_timerL += rs_FULL_BIT_L + 0x10;
rs_timerH = rs_FULL_BIT_H;
rs_shift_count++;
rs_BUF = 0; //清移位緩沖變量
}
}
else
{
rs_timerL += rs_FULL_BIT_L; //下次中斷在數(shù)據(jù)位或停止位中發(fā)生
rs_timerH = rs_FULL_BIT_H;

rs_shift_count++; //2--9:數(shù)據(jù)位 10:停止位

if ( rs_shift_count == 9)
{
rs_BUF = rs_BUF >> 1; //接收第8位
rs_BUF_bit7 = rs_RXD;
if( ReceivePoint < rs_RECEIVE_MAX)
{ //保存收到的字節(jié)
rs232buffer[ReceivePoint++] = rs_BUF;
}
else
{
rs_f_RI_enable = 0; //緩沖區(qū)滿, 禁止接收
}
}
else
{
if (rs_shift_count < 9 ) //收到的是數(shù)據(jù)位 1 -- 7
{
rs_BUF = rs_BUF >> 1;
rs_BUF_bit7 = rs_RXD;
}
else
{ //收到停止位，繼續(xù)檢測 PC 機發(fā)出的下一個起始位
soft_receive_init();
}
}
}
TCON_TFx = 0; //清定時器中斷標志
}
else
{

if (rs_f_TI_enable == 1)
{
rs_timerL += rs_FULL_BIT_L;//下次中斷在數(shù)據(jù)位的末尾時刻
rs_timerH = rs_FULL_BIT_H;

rs_shift_count--; //0:停止位末尾時刻到
//1:發(fā)送停止位
//2--9:發(fā)送數(shù)據(jù)位
if (rs_shift_count > 9) //錯誤狀態(tài)
{
rs_shift_count = 9;
rs_BUF = 0xFF;
}

if (rs_shift_count > 1) //2--9:發(fā)送數(shù)據(jù)位
{
ACC = rs_BUF;
ACC = ACC >> 1;
rs_TXD = CY;
rs_BUF = ACC;
}
else
{
if (rs_shift_count == 0) //0:停止位末尾時刻到
{
rs_TXD = 1;
rs_f_TI = 1; //已發(fā)送完畢一個字節(jié)
}
else
{
rs_TXD = 1; //1:發(fā)送停止位
}
}
}
}
}

//由收轉到發(fā)時，要先調用 soft_send_enable ()
void rs_send_byte(INT8U SendByte) //發(fā)送一個字節(jié)
{
while ( rs_f_TI == 0); //等待發(fā)送完畢前一個字節(jié)
rs_TXD = 1;
rs_timerL = rs_START_BIT_L; //下次中斷在起始位的末尾時刻
rs_timerH = rs_START_BIT_H;
rs_BUF = SendByte;
rs_shift_count = 10;
rs_TXD = 0; //發(fā)送起始位
rs_f_TI = 0; //清已發(fā)送完畢一個字節(jié)的標志
}

void initiate_MCU (void) //系統(tǒng)初始化
{
soft_rs232_init(); //串口初始化
EA = 1; //開中斷
}

void main (void)
{
//首先發(fā)送 128 個字節(jié) 00H--7FH, 然后等待 PC 機發(fā)送的數(shù)據(jù)。當收到 128
//個字節(jié)后，立刻將收到的 128 個數(shù)據(jù)回發(fā)送給 PC 機，然后繼續(xù)等待下一個
//數(shù)據(jù)塊。

INT8U i;
initiate_MCU(); //系統(tǒng)初始化

soft_send_enable (); //允許發(fā)送，禁止接收
for (i=0; i < rs_RECEIVE_MAX; i++ )
{
rs_send_byte(i);
}
while ( rs_f_TI == 0) ; // 等待最后一個字節(jié)發(fā)送完畢

while(1)
{
soft_receive_enable (); //啟動并開始接收，禁止發(fā)送
while (ReceivePoint < rs_RECEIVE_MAX); // 等待接收緩沖區(qū)滿

soft_send_enable (); //允許發(fā)送，禁止接收
for (i=0; i < rs_RECEIVE_MAX; i++ )
{
rs_send_byte(rs232buffer[i]);
}
while ( rs_f_TI == 0) ; //等待最后一個字節(jié)發(fā)送完畢
ReceivePoint = 0;
}
}

單片機:LPC932

void INT_SERIAL(void) interrupt 4
{
unsigned char i,j,k,l;
ES=0;
j=0;
k=0;
l=SBUF;
//數(shù)據(jù)做偶校驗
for(i=0;i<8;i++)
{
if(l & 0x80)
{ //bytedata和0x80作AND邏輯運算等于0x80
j++;
if(j==2)
{
j=0;
} //即表示位7等于1則條件成立
}
l <<=1;
} //禁止串口中斷
if(j==0)
{
if(RB8)
{
k=0;
}
else
{
k=1;
}
}
else
{
if(RB8)
{
k=1;
}
}
if(k)
{
if(ComEn)
{
SeriesSt=0;
if(InfraredSt)
{
if(InfraredBufDptr<60)
{
if(InfraredBufDptr==0) //數(shù)據(jù)緩沖區(qū)地址指針是否為零
{
if(SBUF==0x68) //緩沖區(qū)的第一個數(shù)據(jù)是否等于0x68*/
{
ComDataBuf[0]=SBUF; //數(shù)據(jù)保存到緩沖區(qū)*/
InfraredBufDptr++; //緩沖區(qū)地址累加*/
}
else
{
InfraredBufDptr=0;
}
}
else
{
ComDataBuf[InfraredBufDptr]=SBUF; //數(shù)據(jù)保存到緩沖區(qū)*/
InfraredBufDptr++; //緩沖區(qū)地址累加*/
}

}
else
{
InfraredBufDptr=0;
}
if(ComDataBuf[ComDataBuf][9]+11]==0x16)
{
InfraredBufDptr=0;
InfraredFg=1;//紅外占用數(shù)據(jù)通道有效
ComBit=1;
}
else
{
InfraredFg=0;//紅外占用數(shù)據(jù)通道失效標志
}
}
}
else
{
ComEn=1;
InfraredSt=1;
}
}
RI=0;
ES=1; //接收標志位清零*
}
void INT_INT0(void) interrupt 0
{
unsigned char BitData;
bit BitChk;
EA=0;
EX0=0;
WDT();
EX0=0;
BitData=0;
BitChk=1;
SeriesInData=0;
Delay(130); //等過起始位
while(BitData<9)
{
if(BitData==8)
{
SeriesBitNine=RXD;
}
if(RXD==1)
{
SeriesInData|=0x0080;
BitChk=~BitChk;
}
BitData++;
if(BitData<8)
{
SeriesInData>>=1;
}
Delay(90);
}
if(BitChk)
{
if(ComEn)
{

InfraredSt=0;
if(SeriesSt)
{
if(SeriesBufDptr<60)
{
if(SeriesBufDptr==0) //數(shù)據(jù)緩沖區(qū)地址指針是否為零
{
if(SeriesInData==0x68) //緩沖區(qū)的第一個數(shù)據(jù)是否等于0x68*/
{
ComDataBuf[0]=SeriesInData; //數(shù)據(jù)保存到緩沖區(qū)*/
SeriesBufDptr++; //緩沖區(qū)地址累加*/
}
else
{
SeriesBufDptr=0;
}
}
else
{
ComDataBuf[SeriesBufDptr]=SeriesInData; //數(shù)據(jù)保存到緩沖區(qū)*/
SeriesBufDptr++; //緩沖區(qū)地址累加*/
}
}
else
{
SeriesBufDptr=0;
}
if(ComDataBuf[ComDataBuf][9]+11]==0x16)
{
SeriesBufDptr=0;
SeriesFg=1;//串口占用數(shù)據(jù)通道有標志效
ComBit=1;
}
else//命令錯誤釋放串口占用數(shù)據(jù)通道標志
{
SeriesFg=0;//串口占用數(shù)據(jù)通道標志失效
}
}
}
else
{
ComEn=1;
SeriesSt=1;
}
}
EX0=1;
EA=1;
}
void DataCom(void)
{
if(ComBit)
{
//串口數(shù)據(jù)集合校驗
if(ComEn)
{
if(SeriesSt)
{
if(SendOverFg)
{
CmdParseFg=1;
ComFg=1;
ComTimeA=0;
ComTimeB=0;
ComBit=0;
ComEn=0;
SeriesSt=0;
}
else//占用標志等候數(shù)據(jù)發(fā)送完畢
{
SeriesFg=1;//串口占用數(shù)據(jù)通道標志有效
}
}
else
{
if(InfraredSt)
{
if(SendOverFg)
{
CmdParseFg=1;
ComFg=1;
ComTimeA=0;
ComTimeB=0;
ComBit=0;
ComEn=0;
InfraredSt=0;
}
else
{
InfraredFg=1;//占用標志等候數(shù)據(jù)發(fā)送完畢
}
}
else
{
SeriesFg=0;
InfraredFg=0;
ComEn=0;
}
}
}
}
}

單片機普通IO口模擬串口的方法介紹（轉載） [資源共享] 發(fā)布時間：2010-12-17 16:51:23 51單片機模擬串口的三種方法

隨著單片機的使用日益頻繁，用其作前置機進行采集和通信也常見于各種應用，一般是利用前置
機采集各種終端數(shù)據(jù)后進行處理、存儲，再主動或被動上報給管理站。這種情況下下，采集會需
要一個串口，上報又需要另一個串口，這就要求單片機具有雙串口的功能，但我們知道一般的51
系列只提供一個串口，那么另一個串口只能靠程序模擬。
本文所說的模擬串口， 就是利用51的兩個輸入輸出引腳如P1.0和P1.1，置1或0分別代表高低電
平，也就是串口通信中所說的位，如起始位用低電平，則將其置0，停止位為高電平，則將其置
1，各種數(shù)據(jù)位和校驗位則根據(jù)情況置1或置0。至于串口通信的波特率，說到底只是每位電平持續(xù)
的時間，波特率越高，持續(xù)的時間越短。如波特率為9600BPS，即每一位傳送時間為
1000ms/9600=0.104ms，即位與位之間的延時為為0.104毫秒。單片機的延時是通過執(zhí)行若干條
指令來達到目的的，因為每條指令為1-3個指令周期，可即是通過若干個指令周期來進行延時的，
單片機常用11.0592M的的晶振，現(xiàn)在我要告訴你這個奇怪數(shù)字的來歷。用此頻率則每個指令周期
的時間為(12/11.0592)us，那么波特率為9600BPS每位要間融多少個指令周期呢？
指令周期s=(1000000/9600)/(12/11.0592)=96，剛好為一整數(shù)，如果為4800BPS則為
96x2=192，如為19200BPS則為48，別的波特率就不算了，都剛好為整數(shù)個指令周期，妙吧。至于
別的晶振頻率大家自已去算吧。
現(xiàn)在就以11.0592M的晶振為例，談談三種模擬串口的方法。

方法一：延時法

通過上述計算大家知道，串口的每位需延時0.104秒，中間可執(zhí)行96個指令周期。
#define uchar unsigned char
sbit P1_0 = 0x90;
sbit P1_1 = 0x91;
sbit P1_2 = 0x92;
#define RXD P1_0
#define TXD P1_1
#define WRDYN 44 //寫延時
#define RDDYN 43 //讀延時

//往串口寫一個字節(jié)
void WByte(uchar input)
{
uchar i=8;
TXD=(bit)0; //發(fā)送啟始
位
Delay2cp(39);
//發(fā)送8位數(shù)據(jù)位
while(i--)
{
TXD=(bit)(input&0x01); //先傳低位
Delay2cp(36);
input=input>>1;
}
//發(fā)送校驗位(無)
TXD=(bit)1; //發(fā)送結束
位
Delay2cp(46);
}

//從串口讀一個字節(jié)
uchar RByte(void)
{
uchar Output=0;
uchar i=8;
uchar temp=RDDYN;
//發(fā)送8位數(shù)據(jù)位
Delay2cp(RDDYN*1.5); //此處注意，等過起始位
while(i--)
{
Output >>=1;
if(RXD) Output |=0x80; //先收低位
Delay2cp(35); //(96-26)/2，循環(huán)共
占用26個指令周期
}
while(--temp) //在指定的
時間內搜尋結束位。
{
Delay2cp(1);
if(RXD)break; //收到結束位便退出
}
return Output;
}

//延時程序*
void Delay2cp(unsigned char i)
{
while(--i); //剛好兩個
指令周期。
}

此種方法在接收上存在一定的難度，主要是采樣定位存在需較準確，另外還必須知道
每條語句的指令周期數(shù)。此法可能模擬若干個串口，實際中采用它的人也很多，但如果你用Keil
C，本人不建議使用此種方法，上述程序在P89C52、AT89C52、W78E52三種單片機上實驗通過。

方法二：計數(shù)法

51的計數(shù)器在每指令周期加1，直到溢出，同時硬件置溢出標志位。這樣我們就可以
通過預置初值的方法讓機器每96個指令周期產生一次溢出，程序不斷的查詢溢出標志來決定是否
發(fā)送或接收下一位。

//計數(shù)器初始化
void S2INI(void)
{
TMOD |=0x02; //計數(shù)器0，方式2
TH0=0xA0; //預值為256-96=140，十六進制A0
TL0=TH0;
TR0=1; //開始計數(shù)
TF0=0;
}

void WByte(uchar input)
{
//發(fā)送啟始位
uchar i=8;
TR0=1;
TXD=(bit)0;
WaitTF0();
//發(fā)送8位數(shù)據(jù)位
while(i--)
{
TXD=(bit)(input&0x01); //先傳低位
WaitTF0();
input=input>>1;
}
//發(fā)送校驗位(無)
//發(fā)送結束位
TXD=(bit)1;
WaitTF0();
TR0=0;
}
//查詢計數(shù)器溢出標志位
void WaitTF0( void )
{
while(!TF0);
TF0=0;
}
接收的程序，可以參考下一種方法，不再寫出。這種辦法個人感覺不錯，接收和發(fā)送
都很準確，另外不需要計算每條語句的指令周期數(shù)。

方法三：中斷法

中斷的方法和計數(shù)器的方法差不多，只是當計算器溢出時便產生一次中斷，用戶可以
在中斷程序中置標志，程序不斷的查詢該標志來決定是否發(fā)送或接收下一位，當然程序中需對中
斷進行初始化，同時編寫中斷程序。本程序使用Timer0中斷。
#define TM0_FLAG P1_2 //設傳輸標志位
//計數(shù)器及中斷初始化
void S2INI(void)
{
TMOD |=0x02; //計數(shù)器0，方式2
TH0=0xA0; //預值為256-96=140，十六進制A0
TL0=TH0;
TR0=0; //在發(fā)送或
接收才開始使用
TF0=0;
ET0=1; //允許定時
器0中斷
EA=1; //中斷允許
總開關
}

//接收一個字符
uchar RByte()
{
uchar Output=0;
uchar i=8;
TR0=1; //啟動Timer0
TL0=TH0;
WaitTF0(); //等過起始
位
//發(fā)送8位數(shù)據(jù)位
while(i--)
{
Output >>=1;
if(RXD) Output |=0x80; //先收低位
WaitTF0(); //位間延時
}
while(!TM0_FLAG) if(RXD) break;
TR0=0; //停止
Timer0
return Output;
}
//中斷1處理程序
void IntTimer0() interrupt 1
{
TM0_FLAG=1; //設置標志位。
}
//查詢傳輸標志位
void WaitTF0( void )
{
while(!TM0_FLAG);
TM0_FLAG=0; //清標志位
}
中斷法也是我推薦的方法，和計數(shù)法大同小異。發(fā)送程序參考計數(shù)法，相信是件很容
易的事。
另外還需注明的是本文所說的串口就是通常的三線制異步通信串口（UART），只用RXD、TXD、
GND。

附：51 IO口模擬串口通訊C源程序（定時器計數(shù)法）

#include
sbit BT_SND =P1^0;
sbit BT_REC =P1^1;

#define MODE_QUICK

#define F_TM F0

#define TIMER0_ENABLE TL0=TH0; TR0=1;
#define TIMER0_DISABLE TR0=0;

sbit ACC0= ACC^0;
sbit ACC1= ACC^1;
sbit ACC2= ACC^2;
sbit ACC3= ACC^3;
sbit ACC4= ACC^4;
sbit ACC5= ACC^5;
sbit ACC6= ACC^6;
sbit ACC7= ACC^7;

void IntTimer0() interrupt 1
{
F_TM=1;
}
//發(fā)送一個字符
void PSendChar(unsigned char inch)
{
#ifdef MODE_QUICK
ACC=inch;

F_TM=0;
BT_SND=0; //start bit
TIMER0_ENABLE; //啟動
while(!F_TM);

BT_SND=ACC0; //先送出低位
F_TM=0;
while(!F_TM);

BT_SND=ACC1;
F_TM=0;
while(!F_TM);

BT_SND=ACC2;
F_TM=0;
while(!F_TM);

BT_SND=ACC3;
F_TM=0;
while(!F_TM);

BT_SND=ACC4;
F_TM=0;
while(!F_TM);

BT_SND=ACC5;
F_TM=0;
while(!F_TM);

BT_SND=ACC6;
F_TM=0;
while(!F_TM);

BT_SND=ACC7;
F_TM=0;
while(!F_TM);

BT_SND=1;
F_TM=0;
while(!F_TM);

TIMER0_DISABLE; //停止timer
#else
unsigned char ii;

ii=0;

F_TM=0;
BT_SND=0; //start bit
TIMER0_ENABLE; //啟動
while(!F_TM);

while(ii<8)
{
if(inch&1)
{
BT_SND=1;
}
else
{
BT_SND=0;
}
F_TM=0;
while(!F_TM);
ii++;
inch>>=1;
}
BT_SND=1;
F_TM=0;
while(!F_TM);

#endif
TIMER0_DISABLE; //停止timer
}
//接收一個字符
unsigned char PGetChar()
{
#ifdef MODE_QUICK

TIMER0_ENABLE;
F_TM=0;
while(!F_TM); //等過起始位
ACC0=BT_REC;

TL0=TH0;

F_TM=0;
while(!F_TM);
ACC1=BT_REC;

F_TM=0;
while(!F_TM);
ACC2=BT_REC;

F_TM=0;
while(!F_TM);
ACC3=BT_REC;

F_TM=0;
while(!F_TM);
ACC4=BT_REC;

F_TM=0;
while(!F_TM);
ACC5=BT_REC;

F_TM=0;
while(!F_TM);
ACC6=BT_REC;

F_TM=0;
while(!F_TM);
ACC7=BT_REC;

F_TM=0;

while(!F_TM)
{
if(BT_REC)
{
break;
}
}
TIMER0_DISABLE; //停止timer
return ACC;
#else
unsigned char rch,ii;
TIMER0_ENABLE;
F_TM=0;
ii=0;
rch=0;
while(!F_TM); //等過起始位

while(ii<8)
{
rch>>=1;
if(BT_REC)
{
rch|=0x80;
}
ii++;
F_TM=0;
while(!F_TM);

}
F_TM=0;
while(!F_TM)
{
if(BT_REC)
{
break;
}

}
TIMER0_DISABLE; //停止timer
return rch;

#endif

}
//檢查是不是有起始位
bit StartBitOn()
{
return (BT_REC==0);

}
void main()
{
unsigned char gch;

TMOD=0x22;
PCON=00;

TR0=0; //在發(fā)送或接收才開始使用
TF0=0;
TH0=(256-96); //9600bps 就是 1000000/9600=104.167微秒 執(zhí)行的
timer是
//
104.167*11.0592/12= 96
TL0=TH0;
ET0=1;
EA=1;

PSendChar(0x55);
PSendChar(0xaa);
PSendChar(0x00);
PSendChar(0xff);

while(1)
{
if(StartBitOn())
{
gch=PGetChar();
PSendChar(gch);
}
}

}