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，不留程序。