可能是你没看过。这个程序我还没发布呢，是我为大家设计的一个51开发板。中的UART程序，包括简单的协议，都可以这么做。

//函数：ISR_UART()
//描述：UART中服
//参数：无
void ISR_UART(void) interrupt 4
{
        if (RI == 1)
        {
                UART_Flag = 1;
                RI = 0;
        }
        else
                TI = 0;  
}



// 文件名称：串口文件
// 实现功能：串口的发送接受极其中断
// 日期：2015-1-1
// 备注：printf实现

#include "System.h"

sbit PC_Slave_Bit = P3^5;

volatile unsigned char UART_ReceCount = 0;                        // UART接收计数
unsigned char UART_Buffer[100];                                                                        // UART接收缓存区
unsigned char data CMD_Flag = 0;                                                                // UART_CMD返回值

unsigned char data UARTStateFlag = UARTFlag_PC;        // 主机状态标志，默认与虚拟串口通讯

unsigned char code Waiting[] = {"请等待..."};
unsigned char code No_CMD[] = {"NO CMD"};

// 命令结构体
struct CMD
{
        unsigned char CMD_Num;                                // 命令标号
        unsigned char *CMD_Name;                        // 命令说明
        unsigned char Slave_List;                  // 服务器序列
        unsigned char *CMD_Data;                        // 命令       
};
// 命令参数
struct CMD code PC_CMD[]=
{
        1,// 命令1
        "PWM_Duty_Cycle",
        2,
        "pwm+",
       
        2,// 命令2
        "PWM_Duty_Cycle",
        2,
        "pwm-",
       
        3,// 命令3
        "Demand_Pressure",
        1,
        "dpress",
};

extern void Delay(unsigned int T0, unsigned int T1);

//函数：Uart_Send()
//描述：UART发送数据
//参数：Data        待发送数据
void Uart_Send(unsigned char Data)
{
        SBUF = Data;
        while(TI == 0);
        TI = 0;
}
//函数：Uart_SendBrush()
//描述：UART连续发送数据
//参数：Data        待发送数据
void Uart_SendBrush(unsigned char *Data)
{
        while(*Data != '')
        {
                Uart_Send(*Data);
                Data++;
        }       
}
//函数：Uart_nBrush_Send()
//描述：UART连续发送数据
//参数：Data        待发送数据
static void Uart_nBrush_Send(unsigned char *Data, unsigned char Num)
{
        unsigned char i;
       
        for(i=0; i<Num; i++)
                Uart_Send(Data[i]);
}
//函数：UART_PC_CMD()
//描述：UART接受PC命令处理
//参数：return        命令参数
static unsigned char UART_PC_CMD(void)
{
  unsigned char i,j;

  UART_Buffer[UART_ReceCount] = SBUF;                                                                // 接受记录数据
  Uart_Send(UART_Buffer[UART_ReceCount]);                                         // 返回接受信息
  if(UART_Buffer[UART_ReceCount] == ' ')                                                // 请求执行
  {
                UART_ReceCount = 0;                                                                                                                 // 清空数据计数记录
                for(i=0;i<3;i++)                                                                                                                                // 查询命令
                {
                        j = 0;
                        while(PC_CMD[i].CMD_Data[j] != '')
                        {
                                if(PC_CMD[i].CMD_Data[j] != UART_Buffer[j])                               
                                        break;
                                else
                                        j++;
                        }
                        if(j == strlen(PC_CMD[i].CMD_Data))
                        {
                                Uart_SendBrush(Waiting);                                                                                // 命令成功，发送等待响应
                                Uart_Send(' ');
                                return PC_CMD[i].CMD_Num;                                                                                // 返回命令标号
                        }                       
                }
                Uart_SendBrush(No_CMD);                                                                                                        // 命令失败，发送命令警告
                Uart_Send(' ');
                return 0;
  }
        else if(UART_Buffer[UART_ReceCount] == '')                         // 删除上一个字符
        {
                UART_Buffer[UART_ReceCount] = '';
                UART_ReceCount--;
                UART_Buffer[UART_ReceCount] = '';
        }
  else
                UART_ReceCount++;                                                                                                                                // 命令计数自加
  return 0;
}
//函数：UART_Slave_Response()
//描述：UART接受Slave命令处理
//参数：return        1         比对成功
//                                                        0                比对失败
unsigned char UART_Slave_Response(void)
{
  UART_Buffer[UART_ReceCount] = SBUF;                                                        // 接受记录数据
  if(UART_Buffer[UART_ReceCount] == ' ')                                        // 请求执行
                return 1;
        else
                UART_ReceCount++;
        return 0;
}
// 函数：UART()
// 描述：UART中断处理
// 参数：无
void UART(void)
{
        switch(UARTStateFlag)
        {
                case UARTFlag_PC: // 与主机通讯
                        CMD_Flag = UART_PC_CMD();
                        if(CMD_Flag != 0)
                        {
                                // 转换UART对接口，寻找Slave
                                PC_Slave_Bit = 0;
                                Delay(3,3);
                                // 发送地址
                                SM2 = 1;
                                TB8 = 1;
                                RB8 = 0;
                                Uart_Send(PC_CMD[CMD_Flag-1].Slave_List);
                                // 状态切换为等待地址回应
                                UARTStateFlag = UARTFlag_WaitingAddressACK;
                        }
                        break;
                case UARTFlag_WaitingAddressACK:
                        if(SBUF == PC_CMD[CMD_Flag-1].Slave_List) // 核查地址
                        {
                                // 发送命令
                                SM2 = 0;
                                TB8 = 0;
                                RB8 = 0;
                                Uart_SendBrush(PC_CMD[CMD_Flag-1].CMD_Data);
                                Uart_Send(' ');
                                // 状态切换为等待命令响应
                                UARTStateFlag = UARTFlag_WaitingCMDACK;
                        }       
                        break;
                case UARTFlag_WaitingCMDACK:
                        if(UART_Slave_Response() == 1)
                        {
                                // 状态切换为与PC通讯
                                UARTStateFlag = UARTFlag_PC;
                                // 命令结束
                                CMD_Flag = 0;
                                // 转换UART对接口，与PC对话
                                PC_Slave_Bit = 1;
                                Delay(3,3);
                                // 回复PC命令响应情况
                                Uart_nBrush_Send(UART_Buffer,UART_ReceCount);
                                Uart_Send(' ');
                                UART_ReceCount = 0;
                        }
                default : break;
        }
        UART_Flag = 0;
}