A. 双机通信（8051单片机）
仿真图用了DB9接口，那个DB9是对应电脑硬件的串口的，即仿真时，数据从DB9收/发，对应的电脑实际串口数据收发。所以，两个DB9是不能用导线连接起通信片，你那三条线画了也没用。
DB9是直接与单片机的RXD，TXD连接的，不能加MAX232，加了反倒不对了。
要仿真双机通信，很简单，两个单片机的TXD，RXD直接交叉连接就行，而你这么画，又加MAX232，又用DB9反倒不行了。要用MAX232也可以，但不能用DB9了，两个单片机的MAX232对接。
B. 双机通信程序
#include <reg51.h> //单片机头文件
#define uchar unsigned char //宏定义，uchar字符代替unsigned char，即无符号字符型数据，占1个字节，取值于0-255
#define uint unsigned int //宏定义，用uint字符代替unsigned int，即无符号整数，
sbit p21=P2^1;//（按键端口）定义特殊功能寄存器的位变量
uint j,f;
uchar dat[]={0xff,0x00,0x18,0x3c,0x7e,0xff,0x7e,0x3c,0x18,0x00};//发送控制LED的十六进制的数，依次为255，0，24，60，126，255，126，60，24，0。
void delay(uint x)//void为无返回值的函数，软件延时
{
uint k; //定规无符号整数k
while(x--)//while循环，弱非0，则执行循环体语句，
{
for(k=120;k>0;k--); //循环嵌套达到延时目的。
}
}
void serial_init() //using 0 中断初始化
{
P1=0x00;
p21=1;
SCON=0x50;//(工作在方式1下，REN设置为允许接收).给SCON控制寄存器赋值16进制数50，即01110000,01决定工作方式1，REN为第四个数字，即1，为允许两机接收。
PCON=0x00;//（不加倍） PCON寄存器定义：当值为1是，串口波特率加倍，其他则不加倍 （PCON除最高位外都输虚设的）
TMOD=0x20;//自动重装初值，波特率：9600。计数模式控制寄存器,方式2，初值自动重载8位计数器。
TH1=0xfd;//TH1是作为时间常数的寄存器的
TL1=0xfd;//TL1是作为8位计数器，可以实现TL1计数回0时自动重装时间常数，即将TH1中的数自动送给TL1，再次计数 (9600=11.0592*1000000/12/(0x100-0xfd)/32)
TR1=1;//T1运行控制位，启动T1定时器 (GATE=0 需要手动开启T1定时/计数器)
EA=1;//开启总中断，允许开启串口中断（中断允许位）
ES=1;//开启串口中断
}
void serial_inte() interrupt 4 //中断函数 串行口中断 P117
{
if(TI==0)//只让接收中断执行以下类容 软件清零 （TI是SCON发送中断标志位）
{
ES=0;
RI=0;//RI=1表示帧接收完成, 清零RI， （RI是SCON接受中断标志位） (串口发送数据之后就进入中断)
P1=SBUF; //当接收完一帧数据后，RI置1，此时如果开了全局中断EA和局部中断ES那么就会进中断，中断里面无论你怎么去读SBUF都不会清零RI
ES=1;
}
}
void main()
{
uint i,t;
P1=0xff;
serial_init();//串口初始化
while(1)
{
for(i=0;i<9;)
{
t=p21;
delay(1);//延时去抖动
if(p21==t&&p21==0)//再次判断是否按下
{
while(!p21);//判断是否弹起
delay(1);//延时去抖动
SBUF=dat[i];
while(!TI);//判断是否发送完成
TI=0; //清除发送结束标志位 （进入中断）
i++; //for循环最后的i++
delay(100);//使LED灯能点亮让人看见
}
}
}
}
C. 单片机双机通信系统设计
//两个51单片机，两机的串口交叉连线，双机互发数据
//接收方采用两位数显示收到的数据
//下列双机通信程序，适用于双方同时使用
//经过编译、仿真成功
//显示函数应该根据自己的设备进行改写
//===============================
#include<reg52.h>
#define uchar unsigned char
#define uint unsigned int
uchar Rbuf = 0;
uchar code dis_7[] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71, 0x00};//共阴段码
//段码表 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, off
//-------------------------------
void delay(uint k)
{
uint i, j;
for(i = 0; i < k; i++) for(j = 0; j < 200; j++);
}
//-------------------------------
void Display(uchar x)
{
P0 = dis_7[x / 16]; //输出高四位
P2 = 0xFE;
delay(2);
P0 = dis_7[x % 16]; //输出低四位
P2 = 0xFD;
delay(2);
}
//-------------------------------
void UART()interrupt 4
{
if(RI) {
RI = 0; //清除中断标志
Rbuf = SBUF;
}
if(TI) {
TI = 0; //清除中断标志
}
}
//-------------------------------
void main() //主函数
{
uchar t1, i;
SCON = 0x50; //串口工作在方式1
PCON &= 0x7F; //SMOD=0
TMOD = 0x20; //定时器1当做波特率发生器
TH1 = 0xFD; //初值, 9600 @ 11.0592MHz
TL1 = 0xFD;
TR1 = 1;
while (1){
for (i = 0; i < 250; i++) Display(Rbuf);
SBUF = t1; //发送数据
t1++;
}
}
//===============================
D. 实现双机通信的C语言代码
代码要求是什么? 基本实现 ping 的功能?
ping 代码
#include <windows.h>
#include <winsock2.h>
#define IP_RECORD_ROUTE 0x7
#define ICMP_ECHO 8
#define ICMP_ECHOREPLY 0
#define ICMP_MIN 8 // minimum 8 byte icmp packet (just header)
#define DEF_PACKET_SIZE 32 // Default packet size
#define MAX_PACKET 60000 // Max ICMP packet size 1024
#define MAX_IP_HDR_SIZE 60 // Max IP header size w/options
typedef struct _iphdr
{
unsigned int h_len:4; // Length of the header
unsigned int version:4; // Version of IP
unsigned char tos; // Type of service
unsigned short total_len; // Total length of the packet
unsigned short ident; // Unique identifier
unsigned short frag_and_flags; // Flags
unsigned char ttl; // Time to live
unsigned char proto; // Protocol (TCP, UDP etc)
unsigned short checksum; // IP checksum
unsigned int sourceIP;
unsigned int destIP;
} IpHeader;
//
// ICMP header structure
//
typedef struct _icmphdr
{
BYTE i_type;
BYTE i_code; // Type sub code
USHORT i_cksum;
USHORT i_id;
USHORT i_seq;
// This is not the standard header, but we reserve space for time
ULONG timestamp;
} IcmpHeader;
//
// IP option header - use with socket option IP_OPTIONS
//
typedef struct _ipoptionhdr
{
unsigned char code; // Option type
unsigned char len; // Length of option hdr
unsigned char ptr; // Offset into options
unsigned long addr[9]; // List of IP addrs
} IpOptionHeader;
//
// Function: FillICMPData
//
// Description:
// Helper function to fill in various fields for our ICMP request
//
void FillICMPData(char *icmp_data, int datasize)
{
IcmpHeader *icmp_hdr = NULL;
char *datapart = NULL;
icmp_hdr = (IcmpHeader*)(icmp_data); //+sizeof(IpHeader)
icmp_hdr->i_type = ICMP_ECHO; // Request an ICMP echo
icmp_hdr->i_code = 0;
icmp_hdr->i_id = (USHORT)GetCurrentProcessId();
icmp_hdr->i_cksum = 0;
icmp_hdr->i_seq = 0;
datapart = icmp_data + sizeof(IcmpHeader);
//
// Place some junk in the buffer
//
memset(datapart,'E', datasize - sizeof(IcmpHeader));
}
//---------------------------------------------------------------------------
USHORT checksum(USHORT *buffer, int size)
{
unsigned long cksum=0;
while (size > 1)
{
cksum += *buffer++;
size -= sizeof(USHORT);
}
if (size)
{
cksum += *(UCHAR*)buffer;
}
cksum = (cksum >> 16) + (cksum & 0xffff);
cksum += (cksum >>16);
return (USHORT)(~cksum);
}
//---------------------------------------------------------------------------
void DecodeIPOptions(char *buf, int bytes, void CALLBACK (*pDis)(const char* szMes))
{
IpOptionHeader *ipopt = NULL;
IN_ADDR inaddr;
int i;
HOSTENT *host = NULL;
char szMesBuffer[255];
ipopt = (IpOptionHeader *)(buf + 20);
if (pDis != NULL)
{
pDis("RR: ");
}
for(i = 0; i < (ipopt->ptr / 4) - 1; i++)
{
inaddr.S_un.S_addr = ipopt->addr[i];
if (i != 0)
{
if (pDis != NULL)
{
pDis(" ");
}
}
host = gethostbyaddr((char *)&inaddr.S_un.S_addr, sizeof(inaddr.S_un.S_addr), AF_INET);
if (host)
{
if (pDis != NULL)
{
wsprintf(szMesBuffer, "(%-15s) %s", inet_ntoa(inaddr), host->h_name);
pDis(szMesBuffer);
}
}
else
{
if (pDis != NULL)
{
wsprintf(szMesBuffer, "(%-15s)", inet_ntoa(inaddr));
pDis(szMesBuffer);
}
}
}
return;
}
//---------------------------------------------------------------------------
int DecodeICMPHeader(char *buf, int bytes, struct sockaddr_in *from, void CALLBACK (*pDis)(const char* szMes))
{
IpHeader *iphdr = NULL;
IcmpHeader *icmphdr = NULL;
unsigned short iphdrlen;
DWORD tick;
static int icmpcount = 0;
char szMesBuffer[255];
char szMesBuffer1[255];
iphdr = (IpHeader *)buf;
// Number of 32-bit words * 4 = bytes
iphdrlen = iphdr->h_len * 4;
tick = GetTickCount();
if ((iphdrlen == MAX_IP_HDR_SIZE) && (!icmpcount))
DecodeIPOptions(buf, bytes, pDis);
if (bytes < iphdrlen + ICMP_MIN)
{
//printf("Too few bytes from %s\n", inet_ntoa(from->sin_addr));
if (pDis != NULL)
{
wsprintf(szMesBuffer, "Too few bytes from %s", inet_ntoa(from->sin_addr));
pDis(szMesBuffer);
}
}
icmphdr = (IcmpHeader*)(buf + iphdrlen);
if (icmphdr->i_type != ICMP_ECHOREPLY)
{
//printf("nonecho type %d recvd\n", icmphdr->i_type);
if (pDis != NULL)
{
wsprintf(szMesBuffer, "nonecho type %d recvd", icmphdr->i_type);
pDis(szMesBuffer);
}
return -1;
}
// Make sure this is an ICMP reply to something we sent!
//
if (icmphdr->i_id != (USHORT)GetCurrentProcessId())
{
//printf("someone else's packet!\n");
if (pDis != NULL)
{
pDis("someone else's packet!");
}
return -1;
}
//printf("%d bytes from %s:", bytes, inet_ntoa(from->sin_addr));
//printf(" icmp_seq = %d. ", icmphdr->i_seq);
//printf(" time: %d ms", tick - icmphdr->timestamp);
//printf("\n");
if (pDis != NULL)
{
wsprintf(szMesBuffer, "%d bytes from %s:", bytes, inet_ntoa(from->sin_addr));
wsprintf(szMesBuffer1, " icmp_seq = %d. ", icmphdr->i_seq);
lstrcat(szMesBuffer, szMesBuffer1);
wsprintf(szMesBuffer1, " time: %d ms", tick - icmphdr->timestamp);
lstrcat(szMesBuffer, szMesBuffer1);
wsprintf(szMesBuffer1, " TTL = %d", iphdr->ttl);
lstrcat(szMesBuffer, szMesBuffer1);
pDis(szMesBuffer);
}
icmpcount++;
return tick - icmphdr->timestamp;
}
//---------------------------------------------------------------------------
ping(const char* szTargetAddress, int iDataSize, int iTimeOut, int iTimes, bool bReply, void CALLBACK (*pDis)(const char* szMes))
{
WSADATA wsaData;
SOCKET sockRaw = INVALID_SOCKET;
struct sockaddr_in dest,
from;
int bread,
fromlen = sizeof(from),
timeout = iTimeOut,
ret;
char *icmp_data = NULL,
*recvbuf = NULL;
unsigned int addr = 0;
USHORT seq_no = 0;
struct hostent *hp = NULL;
IpHeader ip_header;
IpOptionHeader ipopt;
char szMesBuffer[255];
if (timeout > 3000)
timeout = 3000;
else if (timeout < 100)
timeout = 100;
if (pDis != NULL)
{
wsprintf(szMesBuffer, "ping %s with %d bytes of data:", szTargetAddress, iDataSize);
pDis(szMesBuffer);
}
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
{
//printf("WSAStartup() failed: %d\n", GetLastError());
if (pDis != NULL)
{
wsprintf(szMesBuffer, "WSAStartup() failed: %d", GetLastError());
pDis(szMesBuffer);
}
return -1;
}
sockRaw = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, WSA_FLAG_OVERLAPPED);
if (sockRaw == INVALID_SOCKET)
{
//printf("WSASocket() failed: %d\n", WSAGetLastError());
if (pDis != NULL)
{
wsprintf(szMesBuffer, "WSASocket() failed: %d", WSAGetLastError());
pDis(szMesBuffer);
}
return -1;
}
// Set the send/recv timeout values
//
bread = setsockopt(sockRaw, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
if(bread == SOCKET_ERROR)
{
//printf("setsockopt(SO_RCVTIMEO) failed: %d\n", WSAGetLastError());
if (pDis != NULL)
{
wsprintf(szMesBuffer, "setsockopt(SO_RCVTIMEO) failed: %d", WSAGetLastError());
pDis(szMesBuffer);
}
return -1;
}
bread = setsockopt(sockRaw, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout));
if (bread == SOCKET_ERROR)
{
//printf("setsockopt(SO_SNDTIMEO) failed: %d\n", WSAGetLastError());
if (pDis != NULL)
{
wsprintf(szMesBuffer, "setsockopt(SO_SNDTIMEO) failed: %d", WSAGetLastError());
pDis(szMesBuffer);
}
return -1;
}
memset(&dest, 0, sizeof(dest));
//
// Resolve the endpoint's name if necessary
//
dest.sin_family = AF_INET;
if ((dest.sin_addr.s_addr = inet_addr(szTargetAddress)) == INADDR_NONE)
{
if ((hp = gethostbyname(szTargetAddress)) != NULL)
{
memcpy(&(dest.sin_addr), hp->h_addr, hp->h_length);
dest.sin_family = hp->h_addrtype;
//printf("dest.sin_addr = %s\n", inet_ntoa(dest.sin_addr));
if (pDis != NULL)
{
wsprintf(szMesBuffer, "dest.sin_addr = %s", inet_ntoa(dest.sin_addr));
pDis(szMesBuffer);
}
}
else
{
//printf("gethostbyname() failed: %d\n", WSAGetLastError());
if (pDis != NULL)
{
wsprintf(szMesBuffer, "gethostbyname() failed: %d", WSAGetLastError());
pDis(szMesBuffer);
}
return -1;
}
}
//
// Create the ICMP packet
//
int datasize = iDataSize;
if (datasize < 0)
datasize = DEF_PACKET_SIZE;
datasize += sizeof(IcmpHeader);
if (datasize > MAX_PACKET)
datasize = MAX_PACKET;
icmp_data = (char *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MAX_PACKET);
recvbuf = (char *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MAX_PACKET);
if (!icmp_data)
{
//printf("HeapAlloc() failed: %d\n", GetLastError());
if (pDis != NULL)
{
wsprintf(szMesBuffer, "HeapAlloc() failed: %d", GetLastError());
pDis(szMesBuffer);
}
return -1;
}
//memset(icmp_data, 0, datasize); //, MAX_PACKET
FillICMPData(icmp_data, datasize);
//
// Start sending/receiving ICMP packets
//
int nCount = 0;
int iReceiveCount = 0;
if (iTimes < 2)
{
iTimes = 2;
}
while(1)
{
int bwrote;
if (nCount++ == iTimes)
break;
((IcmpHeader*)icmp_data)->i_cksum = 0;
((IcmpHeader*)icmp_data)->timestamp = GetTickCount();
((IcmpHeader*)icmp_data)->i_seq = seq_no++;
((IcmpHeader*)icmp_data)->i_cksum = checksum((USHORT*)icmp_data, datasize);
bwrote = sendto(sockRaw, icmp_data, datasize, 0, (struct sockaddr*)&dest, sizeof(dest));
if (bwrote == SOCKET_ERROR)
{
if (WSAGetLastError() == WSAETIMEDOUT)
{
//printf("timed out\n");
if (pDis != NULL)
{
wsprintf(szMesBuffer, "timed out");
pDis(szMesBuffer);
}
continue;
}
//printf("sendto() failed: %d\n", WSAGetLastError());
if (pDis != NULL)
{
wsprintf(szMesBuffer, "sendto() failed: %d", WSAGetLastError());
pDis(szMesBuffer);
}
return -1;
}
if (bwrote < datasize)
{
//printf("Wrote %d bytes\n", bwrote);
if (pDis != NULL)
{
wsprintf(szMesBuffer, "Wrote %d bytes", bwrote);
pDis(szMesBuffer);
}
}
bread = recvfrom(sockRaw, recvbuf, MAX_PACKET, 0, (struct sockaddr*)&from, &fromlen);
if (bread == SOCKET_ERROR)
{
if (WSAGetLastError() == WSAETIMEDOUT)
{
//printf("timed out\n");
if (pDis != NULL)
{
wsprintf(szMesBuffer, "timed out");
pDis(szMesBuffer);
}
continue;
}
//printf("recvfrom() failed: %d\n", WSAGetLastError());
if (pDis != NULL)
{
wsprintf(szMesBuffer, "recvfrom() failed: %d", WSAGetLastError());
pDis(szMesBuffer);
}
return -1;
}
DecodeICMPHeader(recvbuf, bread, &from, pDis); //return replay time ms
iReceiveCount++;
Sleep(50);//1000
}
// Cleanup
//
if (sockRaw != INVALID_SOCKET)
closesocket(sockRaw);
HeapFree(GetProcessHeap(), 0, recvbuf);
HeapFree(GetProcessHeap(), 0, icmp_data);
WSACleanup();
if (pDis != NULL && bReply)
{
pDis(" ");
nCount--;
wsprintf(szMesBuffer, "Packets: Sent = %d, Received = %d, Lost = %d (%d%s", nCount, iReceiveCount, nCount - iReceiveCount, (nCount - iReceiveCount) * 100 / nCount, "% loss)");
pDis(szMesBuffer);
pDis(" ");
}
return 0;
}
//---------------------------------------------------------------------------
调用方法：
ping(
szTargetAddress, //目标地址 //IP 或网址
iDataSize, //数据包大小
iTimeOut, //延时
iTimes, //发送次数
bReply, //是否显示信息
CALLBACK (*pDis)(const char* szMes)//显示信息的函数指针
);
void pingMessage(const char* szMes);
main()
{
ping("127.0.0.1", 32, 500, 5, true, pingMessage);
}
void pingMessage(const char* szMes)
{
printf("%s\n", szMes);
}
E. 单片机双机通信，两个单片机的一方作为发送，另一方作为接收，分别调
#include<reg51.h>
#define uchar unsigned char
uchar distab[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e};
void delay(uchar a)
{
uchar i;
while(a--)for(i=0;i<120;i++);
}
main()
{
uchar i;
TMOD=0x20;
TH1=0xfd;
TL1=0xfd;
TR1=1;
SCON=0x40;
while(1)
{
for(i=0;i<16;i++)
{
SBUF=distab[i];
whileTI==0);
TI=0;
delay(200);
}
}
}
#include<reg51.h>
#define uchar unsigned char
main()
{
uchar i;
TMOD=0x20;
TH1=0xfd;
TL1=0xfd;
TR1=1;
SCON=0x50;
while(1)
{
if(RI)
{
RI=0;
P1=SBUF;
}
}
}
F. 是一道单片机C51程序设计题：设计一个双机通信系统。
#include<reg52.h> //头文件
#include<intrins.h> //循环文件
#define uchar unsigned char//宏定义
#define uint unsigned int
uchar count,cnt;//定义全局变量
sbit LED2=P3^4;
sbit LED1=P3^5;
sbit key3=P3^6;
sbit key4=P3^7;
sbit buzze=P2^3;
uchar temp,flag1,flag2;
void delay(uchar i)
{
uchar x,y;
for(x=i;x>0;x--)
for(y=110;y>0;y--);
}
void init()
{
TMOD=0x20;//T1工作在方式2
TH1=0XFd; //波特率为：4.8kbit/s，发送与接收的波特率要相等
TL1=0XFd;
TR1=1; //启动定时器1
SCON=0X50;//串口中断工作在方式1，允许接收
EA=1;
ES=1;
}
void key_scan2()
{
cnt=0x55;
SBUF=cnt;
//送给缓冲区，发送
while(!TI); //等待发送完
TI=0;
// flag1=1; //发送完了，标志位清零
delay(5000); //判断是否有按键按下
cnt=0xff;
SBUF=cnt;
//送给缓冲区，发送
while(!TI); //等待发送完
TI=0;
// flag1=1;
delay(5000); //发送完了，标志位清零
}
void main()
{
init(); //调用初始化子函数
while(1)
{
key_scan2();
}
}
void recive() interrupt 4
{
if(RI)
{
RI = 0;
//add your code here!
temp=SBUF;
// P4=temp;
P0=temp;
// LED1=0;
// delay(5000);
// LED1=1;
}
else
TI = 0;
}
#include<reg52.h>
#include<intrins.h>
#define uchar unsigned char
#define uint unsigned int
sbit key1=P3^5;
sbit key2=P3^4;
uchar count,cnt,flag1,flag2,temp;
void delay(uchar i)
{
uchar x,y;
for(x=i;x>0;x--)
for(y=110;y>0;y--);
}
void init()
{
TMOD=0x20; //T1工作在方式2
TH1=0XFd; //波特率为4.8kbit/s
TL1=0XFd;
TR1=1; //启动定时器1
SCON=0X50; //REN=1; SM0=0;SM1=1;
EA=1;
ES=1;
//串口工作在方式1，允许接收
}
void key_scan2()
{
cnt=0x55;
SBUF=cnt;
//送给缓冲区，发送
while(!TI); //等待发送完
TI=0;
// flag1=1; //发送完了，标志位清零
delay(5000); //判断是否有按键按下
cnt=0xff;
SBUF=cnt;
//送给缓冲区，发送
while(!TI); //等待发送完
TI=0;
// flag1=1;
delay(5000); //发送完了，标志位清零
}
void main()
{
init(); //调用初始化子函数
while(1)
{
key_scan2();
}
}
void UARTInterrupt(void) interrupt 4
{
if(RI)
{
RI = 0;
//add your code here!
temp=SBUF;
P0=temp;
}
else
TI = 0;
}
G. 单片机 双机通信 程序
双机通信不需要安装虚拟端口软件
，两机通过txd
<==>
rxd
直接通信。
#include
#define
uchar
unsigned
char;
#define
uint
unsigneed
int;
uchar
a0,a1,a2,a3,temp,i;
uchar
code
tab[
]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
sbit
p2_0=p2^0;
sbit
p2_1=p2^1;
sbit
p2_2=p2^2;
sbit
p2_3=p2^3;
void
delay(int
ms)
{
while(ms--)
for(i=0;i<123;i++);
}
void
inituart()
{
tmod=0x20;
//m1=1,m0=0
定时器1工作方式2（定时常数重装，8
位）
scon=0x50;
//sm0=0,sm1=1,ren=1
串口工作方式1，允许接收
th1=0xfd;
//晶振11.0592时，波特率9600
tl1=th1;
//tl1计数，溢出后，th1值送入tl1
ea=1;
//开总中断
es=1;
//允许串口中断
tr1=1;
//启动定时器1
}
void
disp()
{
a0=temp%2;
a1=temp/2%2;
a2=temp/2/2%2;
a3=temp/2/2/2%2;
p2_0=0;
p0=tab[a0];
delay(1);
p2_0=1;
p2_1=0;
p0=tab[a1];
delay(1);
p2_1=1;
p2_2=0;
p0=tab[a2];
delay(1);
p2_2=1;
p2_3=0;
p0=tab[a3];
delay(1);
p2_3=1;
}
void
main()
{
inituart();
//调用串口初始化子程序
while(1)
{
disp();
sbuf=p1;
while(ti==0);
ti=0;
}
}
void
uartinterrupt(
)
interrupt
4
{
if(ri)
{
ri=0;
temp=sbuf;
}
}
H. 双机串行通信
这里有个基本的双机串行通信范例：
http://hi..com/%D7%F6%B6%F8%C2%DB%B5%C0/blog/item/b738c5d010b2ce349a5027ee.html
是否可以解决您的问题？
I. 设计一个单片机双机通信系统，并编写通信程序
串口调试助手是PC端的软件，用来从PC的串口发送和接收数据的。我们调试PC和单片机之间通讯的时候用来模拟PC端应用软件给单片机发送数据和接收单片机发送的数据的。你调试的是单片机和单片机之间的通讯，不适合用串口调试助手的。
但是单片机和单片机通讯不容易知道实际通讯的数据，所以存在很大的调试难度。如果条件允许的话，一般是通过单片机连PC串口，让PC模拟模块收发数据来验证串口通讯是否正常（PC端能够直接看到单片机发送的数据，从而判断程序是否符合同模块的通讯要求），再把PC换成模块进行通讯。这样调试比较方便。
你和模块通讯也是单纯的串口通讯。
我又仔细分析了一下你的系统，按你的意思应该是拿51单片机做上位机。习惯上我们把PC称为上位机，所以刚才没明白。
1、SMOD是用来给串口波特率硬件倍频的。在串口模式1，2，3下，如果SMOD=0波特率是4800，那么SMOD=1时波特率是9600。它存在的理由就是：如果要求的波特率非常快，在给定晶振条件下SMOD=0已经满足不了，才需要SMOD=1倍频。
比如你11.0592MHZ在SMOD=0时波特率最大28800bps达不到要求的57600bps，所以你要用SMOD=1倍频才能实现。
你串口要选择模式1，波特率是可变的，取决于定时器1的溢出速率：
波特率＝（2SMOD÷32）×定时器1 溢出速率
通常会使用定时器1 工作在定时器工作模式2下，这时定时值中的TL1 做为计数，TH1 做为自动重装值 ，这个定时模式下，定时器溢出后，TH1 的值会自动装载到TL1，再次开始计数，这样可以不用软件去干预，使得定时更准确。在这个定时模式2 下定时器1 溢出速率的计算公式如下：
溢出速率＝（计数速率）/(256－TH1) ；
计数速率＝ 11.0592M/12；
算了一下是TH1=255（#0FFH）；就是计数器走一个计数周期。
2、你不用关心什么叫做数据包，只是一种形象的叫法。把一串数据作为一次通讯的内容，这一串数据就是一个包了。那个2位和4位只是写法上便于你理解的，
如01H +0000H + 01H + 03H + 0005H
对应上面的包格式解释0000H是地址码保留字0005H是校验和。
而串口通讯一帧只能发送一个字节。发送的时候只能 01H + 00H +00H + 01H + 03H + 00H + 05H 依序发送。
用汇编写的话流程就是 写入第一个字节01H到SBUF，等待直到TI=1，发送第二个字节00H，等待直到TI=1，发送第三个字节00H，如此循环直到发送完05H为止。
3、类似发送，应答8181H也是81H+81H两个字节回复的。可以用中断，也可以用查询。例如2的发送通讯中05H发送完之后就要开始查询RI直到RI=1，然后就把 SBUF中的字节读出来，是81H，清RI后再查询RI直到RI=1，把 SBUF中的字节读出来，是81H，清RI。如果判断两个接收的都是81H那就表明收包正确。
4、串口通讯一帧只能发送一个字节。这个就不是问题了。
+我hi交流，不留Q，不留程序。