labview通过串口通信控制和读取89S52端口及AD7705-AD转换

LBQ691477940 · 发表于 2012-6-4 19:47

AD7705测试程序串口输出,直接读取出来的线性还算可以，上图http://bbs.mydigit.cn/images/post/smile/my1/teeth.gif。

ad7705.pdf (1021.04 KB, 下载次数: 1854)

AD7705应用.pdf (132.63 KB, 下载次数: 1917)

以下是labview通过串口通信控制和读取端口及AD转换
与AD7705相连的引脚定义
sbit DRDY = P3^4; //12=DRDY:逻辑输出。低电平表明来自AD7705数据寄存器新的输出字是有效的
sbit DOUT = P3^6; //13=DOUT:从片内输出移位寄存器中读出串行数据的串行输出端。
sbit DIN  = P3^5; //14=DIN:写到片内输入移位寄存器串行数据的串行输入端。
sbit REST = P3^3; //5=RESET:复位
sbit SCK  = P3^7; //1=SCLK:串行时钟,逻辑输入
/****************************************************************
      通过串口通信控制和读取端口
上位机发送十六进制的FF55（协议头）加如下对应操作码：
1>端口操作方式写：
   0xAA + 端口号可将对应的端口置低
   0xAB + 端口号可将对应的端口置高
2>寄存器操作方式写：
   0xA0 + 立即数可对P0所有口输出对应的立即数
   0xA1 + 立即数可对P1所有口输出对应的立即数
   0xA2 + 立即数可对P2所有口输出对应的立即数
   0xA3 + 立即数可对P3所有口输出对应的立即数
1>端口操作方式读：
   0xAC + 端口号可将对应的端口高低读回上位机
   当该为低会收到十六进制的00
   当该为高会收到十六进制的01
2>寄存器操作方式读：
   0xAD + 0xA0可对P0所有口的读并以十六进制返回P0所有端口的值
   0xAD + 0xA1可对P1所有口的读并以十六进制返回P1所有端口的值
   0xAD + 0xA2可对P2所有口的读并以十六进制返回P2所有端口的值
   0xAD + 0xA3可对P3所有口的读并以十六进制返回P3所有端口的值
2>AD7705进行AD转换：
   0xAD + 0xDA则从串口上返回被测量的值
   AD7705会占用4个I/O口及串口通信故P3端口，故剩1个I/O口了不进行其他操作
/************************************************************
端口号定义：(P3.0与P3.1不能控制)
P0.0 = 00  P1.0 = 10  P2.0 = 20
P0.1 = 01  P1.1 = 11  P2.1 = 21
P0.2 = 02  P1.2 = 12  P2.2 = 20
P0.3 = 03  P1.3 = 13  P2.3 = 23
P0.4 = 04  P1.4 = 14  P2.4 = 24
P0.5 = 05  P1.5 = 15  P2.5 = 25
P0.6 = 06  P1.6 = 16  P2.6 = 26
P0.7 = 07  P1.7 = 17  P2.7 = 27
  MCU = STC12C5A60S2 晶振 = 11.0592MHZ  波特率 = 57600
  MCU = STC12C5A60S2 晶振 = 22.1184MHZ  波特率 = 115200  22-03-2012
升级记录：
1.取消对P3端口操作并增加AD转换
               04-06-2012
/**************************************************/
HXE文件

通过串口通信控制和读取端口.rar (5.52 KB, 下载次数: 1811)

quicklylove · 发表于 2012-6-4 19:59

支持，谢啦！学习了

261307853 · 发表于 2012-6-4 21:18

...............................

heroshi · 发表于 2012-9-1 16:53

能不能共享下程序,大家学习学习?

LBQ691477940 · 发表于 2012-11-28 21:53

本帖最后由 LBQ691477940 于 2012-11-28 21:57 编辑

/******************************************************************************************************

Labview通过串口通信控制和读取端口及AD7708/8进行AD转换

串行通讯协议：

MCU = STC12C5A60S2 晶振 = 11.0592MHZ
波特率 = 57600

MCU = STC12C5A60S2 晶振 = 22.1184MHZ
波特率 = 115200

上位机发送十六进制:0xFB,0xEF,(协议头) + 如下操作码及CRC-16校验码
/******************************************************************************************************
端口号定义：

P0.0 = 00
P1.0 = 10
P2.0 = 20
P4.0 = 40
P5.0 = 50

P0.1 = 01
P1.1 = 11
P2.1 = 21

P4.1 = 41
P5.1 = 51

P0.2 = 02
P1.2 = 12
P2.2 = 20
P3.2 = 32
P4.2 = 42
P5.2 = 52

P0.3 = 03
P1.3 = 13
P2.3 = 23
P3.3 = 33
P4.3 = 43
P5.3 = 53

P0.4 = 04
P1.4 = 14
P2.4 = 24
P3.4 = 34
P4.4 = 44

P0.5 = 05
P1.5 = 15
P2.5 = 25
P3.5 = 35
P4.5 = 45

P0.6 = 06
P1.6 = 16
P2.6 = 26
P3.6 = 36
P4.6 = 46

P0.7 = 07
P1.7 = 17
P2.7 = 27
P3.7 = 37
P4.7 = 47
/******************************************************************************************************
1>单引脚端口写操作方式：

0x55 + 0xAA + 端口号 + CRC16校验码,可将对应的引脚置低,并返回OK,并回车

0x55 + 0xAB + 端口号 + CRC16校验码,可将对应的引脚置高,并返回OK,并回车

2>单引脚端口读操作方式：

0x55 + 0xAC + 端口号 + CRC16校验码,可将对应的端口高低读回上位机

当该引脚为低会返回L，及回车

当该引脚为高会返回H，及回车

3>寄存器总线写操作方式：

0x55 + 0xA0 + 立即数 + CRC16校验码,可对P0所有口输出对应的立即数,并返回OK,并回车

0x55 + 0xA1 + 立即数 + CRC16校验码,可对P1所有口输出对应的立即数,并返回OK,并回车

0x55 + 0xA2 + 立即数 + CRC16校验码,可对P2所有口输出对应的立即数,并返回OK,并回车

0x55 + 0xA3 + 立即数 + CRC16校验码,可对P3所有口输出对应的立即数,并返回OK,并回车

4>寄存器总线读操作方式：

0x55 + 0xBD + 0xA0 + CRC16校验码,可读回P0所有口的值并以字符形式返回P0的值,并回车

0x55 + 0xBD + 0xA1 + CRC16校验码,可读回P1所有口的值并以字符形式返回P1的值,并回车

0x55 + 0xBD + 0xA2 + CRC16校验码,可读回P2所有口的值并以字符形式返回P2的值,并回车

5>根据上位机要求AD7707 或 AD7708 进行N次的AD转换：

0x55 + 0xAD + 立即数 + CRC16校验码,以字符形式返回立即数次的直流AD当前值,并回车

0x55 + 0xAF + 立即数 + CRC16校验码,以字符形式返回立即数次的交流AD当前值,并回车

#:立即数只能是1~255之间的数。

6>16片RY板选择和对应的RY开/关：

0x55 + 0xD0 + 立即数 + CRC16校验码,第1 片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xD1 + 立即数 + CRC16校验码,第2 片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xD2 + 立即数 + CRC16校验码,第3 片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xD3 + 立即数 + CRC16校验码,第4 片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xD4 + 立即数 + CRC16校验码,第5 片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xD5 + 立即数 + CRC16校验码,第6 片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xD6 + 立即数 + CRC16校验码,第7 片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xD7 + 立即数 + CRC16校验码,第8 片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xD8 + 立即数 + CRC16校验码,第9 片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xD9 + 立即数 + CRC16校验码,第10片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xDA + 立即数 + CRC16校验码,第11片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xDB + 立即数 + CRC16校验码,第12片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xDC + 立即数 + CRC16校验码,第13片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xDD + 立即数 + CRC16校验码,第14片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xDE + 立即数 + CRC16校验码,第15片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

0x55 + 0xDF + 立即数 + CRC16校验码,第16片的RY板上的RY根据立即数的0/1开/关,并返回OK,并回车

7>16片RY板全部释放：

0x55 + 0xBB + 0xAA + CRC16校验码,可对16片RY板上的全部RY释放,并返回OK,并回车

8>根据上位机发过来的P2口立即数作为AD通道选择使AD7708/8按要求进行N次的交流AD转换：

0xAC + 立即数(P2口) + 立即数(N次转换) + CRC16校验码,以字符形式返回立即数次的交流AD当前值,并回车

9>根据上位机发过来的P2口立即数作为AD通道选择使AD7708/8按要求进行N次的直流AD转换：

0xDC + 立即数(P2口) + 立即数(N次转换) + CRC16校验码,以字符形式返回立即数次的直流AD当前值,并回车

10>根据上位机发过来的立即数要求DAC081S101CIMK 或 DAC121S101CIMK 进行DA转换：

0xDA + 立即数(高8位字节) + 立即数(低8位字节) + CRC16校验码,以字符形式返回立即数次的AD当前值,并回车

注意：

如果高8位字节中的D7 / D6 = 0 则本系统选中DAC081S101CIMK的程序来进行8位的DA转换

如果高8位字节中的D7 / D6 = 1 则本系统选中DAC121S101CIMK的程序来进行12位的DA转换

但高8位字节中的D5/D4位只能为00 这个是由DA芯片本身协议造成，否则DA芯片不能正常输出DA模拟量

/******************************************************************************************************
升级与更改记录：

1.取消对P3端口操作并增加AD转换
04-06-2012

2.改为TCL1864的AD转换
08-06-2012

3.更改返回值为字符型式
09-06-2012

4.增加CRC-16校验及收到有不正确的指令时返回NG，及回车
10-06-2012

5.增加16片RY板的选通和立即数直接控制
27-07-2012

6.改为上位机可预设读多少次AD值(不作任何处理直接返回AD值)
28-07-2012

7.增加16片RY板上的全部RY复位释放控制指令
28-07-2012

8.增加用单指令作为通道选择，控制LTC1864进行N次的AD转换
31-07-2012

9.修正了整型数组往串口发送子函数的编译警告
03-08-2012

10.修正了LTC1864第1次读数乱的问题
03-08-2012

11.修正了在运行中读P1.6 & P1.7口的错误问题
15-08-2012

12.增加读AD时切换通道后的延时
28-08-2012

13.更改为接收到正确指令后要等此指令所要求的功能完成后

才允许串口接收下一指令
30-08-2012

14.增加DAC081S101CIMK 8位或 DAC121S101CIMK 12位DA转换功能
12-09-2012

15.增加AD7708或AD7708 24位AD转换功能
13-09-2012

16.取消LTC1864的AD转换替代为AD7708或AD7708 24位AD转换
13-10-2012

17.增加对P3/P4/P5端口操作

18.将串口波特率发生器改为独立波特率发生器，定时器1得到释放

可以作为独立定时器使用
17-11-2012
/******************************************************************************************************/
//#include <LTC1864.H>
#include <DAC081S101.H>
#include <TM7708.H>
#define
CLR_BIT 0xAA
//将端口置0
#define SET_BIT 0xAB
//将端口置1
#define READ 0xAC
//读端口
#define BIT_L 'L'
//端口为低时返回值
#define BIT_H 'H'
//端口为高时返回值
#define p0
0xA0
//P0口寄存器写操作
#define p1
0xA1
//P1口寄存器写操作
#define p2
0xA2
//P2口寄存器写操作
#define p3
0xA3
//P3口寄存器写操作
#define READ_P
0xBD
//寄存器读
#define DC_AD
0xAD
//直流AD转换
#define AC_AD
0xAF
//交流AD转换
#define RyRST
0xBB
//释放全部RY
/******************************************************************************************************/
uchar gong_bei;
//靓女名字(^_^)，上位机发过来要求AD转换的次数。
//uint xdata buff_1684[255];
//定义字符串缓冲区在STC12C5A60S2的内部扩展RAM中
uchar xdata buff_7708[765];
//定义字符串缓冲区在STC12C5A60S2的内部扩展RAM中
uchar  *intp;
//字符型指针变量
/******************************************************************************************************/
void RY_INIT();
//16片RY板上的RY初始化为释放状态8*16=128个
void UART_INIT();
//串口及定时器初始化
void CLR_ByUART();
//清除接收标志和内容//允许接收
void SEND_NG(void);
//向串口NG字符串并转行
void SEND_OK(void);
//向串口OK字符串并转行
void SEND_CHRA(uchar dat);
//向串口发送一个字符
//void LTC1864_CONVERSION(uchar N);
//根据上位机要求进行N次的AD转换
uint CAL_CRC(uchar *ptr, uint len);  //CRC校验计算函数
//void SEND_1864(uint *str,uchar strlen);//向串口发送一个字符串，strlen为该字符串长度
void SEND_7708(uchar *str,uchar strlen);//向串口发送一个字符串，strlen为该字符串长度
/*******************************************************************************************************/
//单片机引脚重新定义
sbit P0_0 = 0x80;
sbit P1_0 = 0x90;
sbit P2_0 = 0xA0;
sbit P0_1 = 0x81;
sbit P1_1 = 0x91;
sbit P2_1 = 0xA1;
sbit P0_2 = 0x82;
sbit P1_2 = 0x92;
sbit P2_2 = 0xA2;
sbit P0_3 = 0x83;
sbit P1_3 = 0x93;
sbit P2_3 = 0xA3;
sbit P0_4 = 0x84;
sbit P1_4 = 0x94;
sbit P2_4 = 0xA4;
sbit P0_5 = 0x85;
sbit P1_5 = 0x95;
sbit P2_5 = 0xA5;
sbit P0_6 = 0x86;
sbit P1_6 = 0x96;
sbit P2_6 = 0xA6;
sbit P0_7 = 0x87;
sbit P1_7 = 0x97;
sbit P2_7 = 0xA7;

sbit P3_0 = 0xB0;
sbit P4_0 = 0xC0;
sbit P5_0 = 0xC8;
sbit P3_1 = 0xB1;
sbit P4_1 = 0xC1;
sbit P5_1 = 0xC9;
sbit P3_2 = 0xB2;
sbit P4_2 = 0xC2;
sbit P5_2 = 0xCA;
sbit P3_3 = 0xB3;
sbit P4_3 = 0xC3;
sbit P5_3 = 0xCB;
sbit P3_4 = 0xB4;
sbit P4_4 = 0xC4;
sbit P3_5 = 0xB5;
sbit P4_5 = 0xC5;
sbit P3_6 = 0xB6;
sbit P4_6 = 0xC6;
sbit P3_7 = 0xB7;
sbit P4_7 = 0xC7;
/******************************************************************************************************/
void delay (unsigned int a)
// 1ms延时程序
{

unsigned int i;

while( --a != 0)

{

for(i = 0; i < 1200; i++);
//STC单片机在外部晶振为22.1184MHz时i值上限为1200

}

//AT89C51单片机在外部晶振为12MHz时i值上限为125
}
/******************************************************************************************************/

/******************************************************************************************************/
//函数名：HexToChar()
//功能描述：把16进制转换为ASCII字符
//函数说明：
//调用函数：
//全局变量：
//输入：16进制
//返回：ASCII字符
/******************************************************************************************************/
uchar HexToChar(uchar bHex)
//把16进制转换为ASCII字符
{

if((bHex >= 0) && (bHex <= 9))

bHex += 0x30;

else if((bHex >= 10) && (bHex <= 15))
//大写字母

bHex += 0x37;

else bHex = 0xFF;

return bHex;
}
/******************************************************************************************************/
void SEND_CHRA(uchar dat)//向串口发送一个字符
{

ES = 0;
//关串行中断

TI = 0;
// 清发送标志

SBUF = dat;
//如果TI为0等待

while (!TI);
//等待发送完毕

ES = 1;
//开串行中断
}
/******************************************************************************************************/
void SEND_OK(void)
//向串口OK字符串并转行
{

SEND_CHRA('O');SEND_CHRA('K');
//OK

SEND_CHRA(0x0D);SEND_CHRA(0x0A);
//回车
}
/******************************************************************************************************/
void SEND_NG(void)
//向串口NG字符串并转行
{

SEND_CHRA('N');SEND_CHRA('G');
//NG

SEND_CHRA(0x0D);SEND_CHRA(0x0A);
//回车
}
/******************************************************************************************************/
void SEND_7708(uchar *str,uchar strlen)//向串口发送一个字符串，strlen为该字符串长度
{

uint k = 0;

ES = 0;
//关串行中断
do
{

SEND_CHRA(HexToChar((*(str + k)) >> 4));
//将十六进制转换为字符型式输出高四位

SEND_CHRA(HexToChar((*(str + k)) & 0x0F));
//将十六进制转换为字符型式输出低四位

//SEND_CHRA(*(str + k));
//以十六进制形式输出

k++;
}

while(k < (strlen * 3));//由于每转换一次为3个字节故strlen 要乘3才不影响最终结果，呵呵！

SEND_CHRA(0x0D);SEND_CHRA(0x0A);
//回车

ES = 1;
//开串行中断
}
/******************************************************************************************************/
union//定义地址共用体把要往串口发送的数据的高/低8位分开//Csend.Sdata[0]为高8位 Csend.Sdata[1]为低8位
{

unsigned int INT_data;

unsigned char CHAR_data[2]; // [0] 为高位 [1] 为低位
} SEND;

/******************************************************************************************************/
uchar uartDataSize;
//串口已读取数据长度
uchar GLengthLoh[8];
//接收缓冲区共8个
uchar TN = 0;
//接收超时变量清零
bit UART_RI = 0;
//成接收标志位置
/******************************************************************************************************/
union Check
//定义地址共用体把CRC校验码高位和低位分开//CRC.Chdata[0]为高位 CRC.Chdata[1]为低位
{


unsigned int CRCdata;

unsigned char Chdata[2]; // [0] 为高位 [1] 为低位
} CRC;
/******************************************************************************************************/
uint CAL_CRC(uchar *ptr, uint len)  //CRC校验计算函数
{

uint crc = 0xFFFF;

uchar i;

while(len-- != 0)

{

crc ^= *ptr;

for(i = 0;i < 8;i++)

{

if((crc & 0x0001) == 0)

crc = crc >> 1;

else

{

crc = crc >> 1;

crc ^= 0xA001;  //40961

}

}

ptr++;

}

return crc;
}
/******************************************************************************************************/
void UART_ISR(void) interrupt 4
//串口中断服务函数
{

if(RI)
//判断是否中断接收

{

RI = ET0 = TR0 = TN = 0;
//接收中断标位、定时器0禁止中断、停止定时器0/接收超时变量清零

GLengthLoh[uartDataSize++ & 0x07] = SBUF;
//与上7相当于不会大过7哈哈!

if(uartDataSize >= 7)

{

uartDataSize = 0;

CRC.CRCdata = CAL_CRC(&GLengthLoh,5);
//求取CRC16结果

if((GLengthLoh[5] == CRC.Chdata[0]) && (GLengthLoh[6] == CRC.Chdata[1]))

{

if((GLengthLoh[0] == 0xFB) && (GLengthLoh[1] == 0xEF))//检测命令头 FB EF

{

UART_RI = 1;
//如果已接收到6个字节数据且协议头相同将完成接收标志位置1

}

}

else

{

UART_RI = 0;
//接收成功标志位置1

SEND_NG();
//向串口NG字符串并转行

}

}

else

{

TH0 = (65536 - 5000) / 256;
//约5MS定时器初值//设定时值，收到数据时设定时值

TL0 = (65536 - 5000) % 256;
//约5MS定时器初值

ET0 = TR0 = 1; //开定时器0中断、启动定时器0定/时器用于在一帧数据接收时如有丢包则返回错误信息

}

}

else if(TI)
//如果是发送标志位，清零
      TI = 0;
}
/******************************************************************************************************/
void Timer0(void) interrupt 1
//定时器0中断用于处理丢包
{

TH0 = (65536 - 5000) / 256;
//约5MS定时器初值//设定时值，收到数据时设定时值

TL0 = (65536 - 5000) % 256;
//约5MS定时器初值

if(TN >= 2)
// 帧中的两字符间隔TN*10ms则为出错

{

ET0 = TR0 = TN = 0;
//关定时器0中断/定时器0/清超时变量

uartDataSize = 0;
//指针清零

SEND_NG();
//向串口NG字符串并转行

}

else

TN++;
}

/******************************************************************************************************

用户在程序中如何具体使用串口1和独立波特率发生器BRT
1.设置串口1的工作模式，SCON寄存器中的SM0和SM1两位决定了串口1的4种工作模式。
2.设置串口1的波特率,使用独立波特率发生器寄存器和相应的位：BRT独立波特率发生器寄存器,BRTx12位，SMOD位
3.启动独立波特率发生器,让BRTR位为1，BRT独立波特率发生器寄存器就立即开始计数。
4.设置串口1的中断优先级,及打开中断相应的控制位是:
PS,PSH,ES,EA
5.如要串口1接收,将REN置1即可如要串口1发送,将数据送入SBUF即可,接收完成标志RI,发送完成标志TI,要由软件清0。
/******************************************************************************************************
AUXR 辅助寄存器

T0x12
T1x12
UART_M0x6
BRTR
S2SMOD
BRTx12
XRAM
S1BRS

T0x12:

0, 定时器0是传统8051速度，12分频；

1, 定时器0的速度是传统8051的12倍，不分频
T1x12:

0, 定时器1是传统8051速度，12分频；1, 定时器1的速度是传统8051的12倍，不分频

如果UART串口用定时器1做波特率发生器，T1x12位就可以控制UART串口是12T 还是1T了。
UART_M0x6:

0, UART串口的模式0是传统12T的8051速度，12分频；

1, UART串口的模式0的速度是传统12T的8051的6倍，2分频

如果用定时器T1做波特率发生器时,UART串口的速度由T1的溢出率决定
BRTR: (S2TR)

0, 不允许独立波特率发生器运行

1, 允许独立波特率发生器运行
S2SMOD:

0, 缺省

1, 串口2 / UART2的波特率 x 2
BRTx12: (S2Tx12)

0, 独立波特率发生器每12个时钟计数一次

1, 独立波特率发生器每1个时钟计数一次
EXTRAM:

0, 允许使用内部扩展的1024字节扩展RAM

1, 禁止使用内部扩展的1024字节扩展RAM
S1BRS:

0, 缺省，串口1波特率发生器选择定时器1，S1BRS是串口1波特率发生器选择位

1, 独立波特率发生器作为串口1的波特率发生器,此时定时器1得到释放,可以作为独立定时器使用
/******************************************************************************************************/
#define RELOAD_9600
0x70
//使用22.1184M晶体且波特率加倍时波特率为9600
#define RELOAD_19200
0xb8
//使用22.1184M晶体且波特率加倍时波特率为19200
#define RELOAD_38400
0xdc
//使用22.1184M晶体且波特率加倍时波特率为38400
#define RELOAD_57600
0xe8
//使用22.1184M晶体且波特率加倍时波特率为57600

#define RELOAD_115200
0xf4
//使用22.1184M晶体且波特率加倍时波特率为115200
/******************************************************************************************************
当BRTx12位为0时波特率 = Fosc / 12 / ( 256 - BRT ) / 32
例：221184/12/(256-f4)/16 = 4800
当BRTx12位为1时波特率 = Fosc / ( 256 - BRT ) / 32
例：221184/(256-f4)/16 = 57600

当BRTx12位为0且波特率加倍时波特率 = Fosc / 12 / ( 256 - BRT ) / 16
例：221184/12/(256-f4)/16 = 9600
当BRTx12位为1且波特率加倍时波特率 = Fosc / ( 256 - BRT ) / 16
例：221184/(256-f4)/16 = 115200
/******************************************************************************************************/
void UART_INIT()
//使用独立波特率发生器作为波特率发生器的串口1初始化
{

AUXR = 0x15;
//独立波特率发生器作为串口1的波特率发生器,内部扩展EXTRAM位清0,即可使用内部扩展RAM

TMOD = 0x01;
//设置定时器0为模式1


SCON = 0x50;
//SM0-SM1-SM2-REN-TB8-RB8-TI-RI

PCON = 0x80;
//SMOD = 1; 波特率加倍

BRT = RELOAD_115200;//独立波特率发生器定时器,装入重装载数

RI = 0;
//清接收标志

TI = 0;
//清发送标志

PS = 1;
//串口中断先优

ES = 1;
//开串中断

EA = 1;
//开总中断
}
/******************************************************************************************************/
void RY_INIT()
//16片RY板上的RY初始化为释放状态8*16=128个
{

uchar i;

P1_5 = 1;
//将OE输出使能置高使全部IC输出为高阻状态

P0 = 0xFF;
//整片RY板的8个RY全部释放

for(i = 0;i < 16;i++)

{

P1 = 0xF0 | i;
//让P1口的低四位从0到f开始变化选中RY0板~RY16板

P1_4 = 0;
//使MAIN板上的CLK引脚产生一个上升沿

delay(10);
//延时10MS

P1_4 = 1;
//使MAIN板上的CLK引脚产生一个上升沿

}

P1_5 = 0;
//使MAIN板上的OE变低打开所有使能输出
}
/******************************************************************************************************/
void CLR_ByUART()
//清除接收标志和内容//允许接收
{

GLengthLoh[0] = GLengthLoh[1] = GLengthLoh[2] = GLengthLoh[3] = 0;

GLengthLoh[4] = GLengthLoh[5] = GLengthLoh[6] = 0;
//清除所接收到的数据

REN = 1;
//允许接收
}

/*************************************************************************************************************/
void TM7708_CONVERSION(uchar N)
//根据上位机要求进行N次的AD转换注每读一次为3个字节即24位
{

uchar i0,i1;

intp = buff_7708;
//将数组的地址赋给指针变量

for(i0 = 0;i0 < N;i0++)
//MCU连续存储24位数据gong_bei个。180/3相当于读60次AD值

{

while(DRDY);
//等待DRDT为低时,可读出数据

write_byte1(0x38);
//向通信寄存器写入数据，选择通道1作为有效，将下一个操作设为读数据寄存器。

for(i1 = 0;i1 < 3;i1++)
//连续存储一个数据。

{

*intp = read_byte1();
//读一字节数据,将数据存入数组中

intp++;
//指针变量加1

}

//CS = 1;
//读出数据后CS拉高。

}

SEND_7708(buff_7708,gong_bei);  //向串口发送一个字符串，gong_bei为该字符串长度
}
/******************************************************************************************************/
void main(void)
{

//uint ck;
//用来清除缓存

SP = 0x60;
//设置栈底
//注意STC89系列没有此时钟频率分频功能故只能有 12M晶振

//CLK_DIV = 0x00;
//系统时钟

//CLK_DIV = 0x01;
//系统时钟/2

//CLK_DIV = 0x02;
//系统时钟/4

//CLK_DIV = 0x03;
//系统时钟/8

//CLK_DIV = 0x04;
//系统时钟/16

//CLK_DIV = 0x06;
//系统时钟/32

//CLK_DIV = 0x06;
//系统时钟/64

//CLK_DIV = 0x07;
//系统时钟/128
/******************************************************************************************************

举例: MOV P1M1,#10100000B

   MOV P1M0,#11000000B

  P1.7为开漏,P1.6为强推挽输出,P1.5为高阻输入,P1.4/P1.3/P1.2/P1.1/P1.0为弱上拉

要外加注意:

虽然每个I/O口在弱上拉时都能承受20mA的灌电流(还是要加限流电阻,如1K，560Ω等),在强推挽输出

时都能输出20mA的拉电流（也要加限流电阻）,但整个芯片的工作电流推荐不要超过55mA。即从MCU-VCC流入的电

流不超过55mA,从MCU-Gnd流出电流不超过55mA,整体流入/流出电流都不能超过55mA.
/*******************************************************************************************************/

P0M0 = 0xff;
//将P0口所有端口都设为推挽输出，推挽输出（强上拉输出，可达20mA，要加限流电阻）

P0M1 = 0x00;
//将P0口所有端口都设为推挽输出，推挽输出（强上拉输出，可达20mA，要加限流电阻）
/*******************************************************************************************************

P1M0 = 0xff;
//将P1口所有端口都设为推挽输出，推挽输出（强上拉输出，可达20mA，要加限流电阻）

P1M1 = 0x00;
//将P1口所有端口都设为推挽输出，推挽输出（强上拉输出，可达20mA，要加限流电阻）
/*******************************************************************************************************

P2M0 = 0xff;
//将P2口所有端口都设为推挽输出，推挽输出（强上拉输出，可达20mA，要加限流电阻）

P2M1 = 0x00;
//将P2口所有端口都设为推挽输出，推挽输出（强上拉输出，可达20mA，要加限流电阻）
/*******************************************************************************************************

P3M0 = 0xff;
//将P3口所有端口都设为推挽输出，推挽输出（强上拉输出，可达20mA，要加限流电阻）

P3M1 = 0x00;
//将P3口所有端口都设为推挽输出，推挽输出（强上拉输出，可达20mA，要加限流电阻）
/*******************************************************************************************************/

RY_INIT();
//16片RY板上的RY初始化为释放状态8*16=128个

UART_INIT();
//串口初始化
/*******************************************************************************************************/

delay(300);
//如果测DC通道的差分电压则转换通道后延时300MS

TM7708_INIT();
/*
write_byte1(0x10);  //向通信寄存器写数据,选择通道1作为有效通道,将下一个操作设为对设置寄存器进行写操作。

write_byte1(0x20);  //对设置寄存器写操作,选择16倍增益,无BUF缓冲器,双极性。

write_byte1(0x50);  //向通信寄存器写数据,选择通道1作为有效通道,将下一个操作设为对滤波低寄存器进行写操作。

write_byte1(0x00);  //向滤波低寄存器写入0x00。

write_byte1(0x20);  //向通信寄存器写数据,选择通道1作为有效通道,将下一个操作设为对滤波高寄存器进行写操作。

write_byte1(0x0F);  //向滤波高寄存器写入0x0F。

TM7708_CONVERSION(60);
//根据上位机要求进行N次的AD转换注每读一次为3个字节即24位 */
/*******************************************************************************************************/

while (1)

{

if(UART_RI == 1 )//接收成功标志位 = 1

{

switch (GLengthLoh[2])

{

case 0x55://GLengthLoh[2] == 0x55

{

UART_RI = REN = 0;
//接收成功标志位置0防止多次重入//禁止串口接收

if(GLengthLoh[3] == CLR_BIT)//如果GLengthLoh[3]为 0xAA 则将相应端口置低

{

switch (GLengthLoh[4])
//则根据后字节的值将对应端口置低

{
/******************************************************************************************************/

case 0x00:

{

P0_0 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x01:

{

P0_1 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x02:

{

P0_2 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x03:

{

P0_3 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x04:

{

P0_4 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x05:

{

P0_5 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x06:

{

P0_6 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x07:

{

P0_7 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

case 0x10:

{

P1_0 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x11:

{

P1_1 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x12:

{

P1_2 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x13:

{

P1_3 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x14:

{

P1_4 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x15:

{

P1_5 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x16:

{

P1_6 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x17:

{

P1_7 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

case 0x20:

{

P2_0 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x21:

{

P2_1 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x22:

{

P2_2 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x23:

{

P2_3 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x24:

{

P2_4 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x25:

{

P2_5 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x26:

{

P2_6 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x27:

{

P2_7 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

/* case 0x30:

{

P3_0 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x31:

{

P3_1 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

} */

case 0x32:

{

P3_2 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x33:

{

P3_3 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x34:

{

P3_4 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x35:

{

P3_5 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x36:

{

P3_6 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x37:

{

P3_7 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

/******************************************************************************************************/

case 0x40:

{

P4_0 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x41:

{

P4_1 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x42:

{

P4_2 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x43:

{

P4_3 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x44:

{

P4_4 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x45:

{

P4_5 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x46:

{

P4_6 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x47:

{

P4_7 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

case 0x50:

{

P5_0 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x51:

{

P5_1 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x52:

{

P5_2 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x53:

{

P5_3 = 0;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

default:

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

SEND_OK();
//向串口OK字符串并转行

}
/******************************************************************************************************/

if(GLengthLoh[3] == SET_BIT)
//如果GLengthLoh[3]为 0xAB 则将相应端口高

{

switch (GLengthLoh[4])
//则根据后字节的值将对应端口置高

{

case 0x00:

{

P0_0 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x01:

{

P0_1 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x02:

{

P0_2 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x03:

{

P0_3 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x04:

{

P0_4 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x05:

{

P0_5 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x06:

{

P0_6 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x07:

{

P0_7 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

case 0x10:

{

P1_0 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x11:

{

P1_1 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x12:

{

P1_2 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x13:

{

P1_3 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x14:

{

P1_4 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x15:

{

P1_5 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x16:

{

P1_6 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x17:

{

P1_7 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

case 0x20:

{

P2_0 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x21:

{

P2_1 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x22:

{

P2_2 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x23:

{

P2_3 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x24:

{

P2_4 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x25:

{

P2_5 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x26:

{

P2_6 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x27:

{

P2_7 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

/******************************************************************************************************/

/* case 0x30:

{

P3_0 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x31:

{

P3_1 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

} */

case 0x32:

{

P3_2 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x33:

{

P3_3 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x34:

{

P3_4 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x35:

{

P3_5 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x36:

{

P3_6 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x37:

{

P3_7 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

case 0x40:

{

P4_0 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x41:

{

P4_1 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x42:

{

P4_2 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x43:

{

P4_3 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x44:

{

P4_4 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x45:

{

P4_5 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x46:

{

P4_6 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x47:

{

P4_7 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

case 0x50:

{

P5_0 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x51:

{

P5_1 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x52:

{

P5_2 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x53:

{

P5_3 = 1;

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

default:

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

SEND_OK();
//向串口OK字符串并转行

}
/******************************************************************************************************/

if(GLengthLoh[3] == READ)//如果GLengthLoh[3]为 0xAC 则读取相应的端口状态

{

switch (GLengthLoh[4])
//根据GLengthLoh[4]的值将对应端口的高低电平返回给串口,低发L高发H

{

case 0x00:

{

P0_0 = 1;
//先将其置高再读

if(!P0_0)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x01:

{

P0_1 = 1;
//先将其置高再读

if(!P0_1)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x02:

{

P0_2 = 1;
//先将其置高再读

if(!P0_2)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x03:

{

P0_3 = 1;
//先将其置高再读

if(!P0_3)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x04:

{

P0_4 = 1;
//先将其置高再读

if(!P0_4)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x05:

{

P0_5 = 1;
//先将其置高再读

if(!P0_5)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x06:

{

P0_6 = 1;
//先将其置高再读

if(!P0_6)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x07:

{

P0_7 = 1;
//先将其置高再读

if(!P0_7)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

case 0x10:

{

P1_0 = 1;
//先将其置高再读

if(!P1_0)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x11:

{

P1_1 = 1;
//先将其置高再读

if(!P1_1)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x12:

{

P1_2 = 1;
//先将其置高再读

if(!P1_2)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x13:

{

P1_3 = 1;
//先将其置高再读

if(!P1_3)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x14:

{

P1_4 = 1;
//先将其置高再读

if(!P1_4)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x15:

{

P1_5 = 1;
//先将其置高再读

if(!P1_5)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x16:

{

P1_6 = 1;
//先将其置高再读

if(!P1_6)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x17:

{

P1_7 = 1;
//先将其置高再读

if(!P1_7)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

case 0x20:

{

P2_0 = 1;
//先将其置高再读

if(!P2_0)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x21:

{

P2_1 = 1;
//先将其置高再读

if(!P2_1)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x22:

{

P2_2 = 1;
//先将其置高再读

if(!P2_2)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x23:

{

P2_3 = 1;
//先将其置高再读

if(!P2_3)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x24:

{

P2_4 = 1;
//先将其置高再读

if(!P2_4)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x25:

{

P2_5 = 1;
//先将其置高再读

if(!P2_5)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 L1

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x26:

{

P2_6 = 1;
//先将其置高再读

if(!P2_6)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 L1

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x27:

{

P2_7 = 1;
//先将其置高再读

if(!P2_7)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}
/******************************************************************************************************/

/* case 0x30:

{

P3_0 = 1;
//先将其置高再读

if(!P3_0)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x31:

{

P3_1 = 1;
//先将其置高再读

if(!P3_1)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

} */

case 0x32:

{

P3_2 = 1;
//先将其置高再读

if(!P3_2)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x33:

{

P3_3 = 1;
//先将其置高再读

if(!P3_3)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x34:

{

P3_4 = 1;
//先将其置高再读

if(!P3_4)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x35:

{

P3_5 = 1;
//先将其置高再读

if(!P3_5)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 L1

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x36:

{

P3_6 = 1;
//先将其置高再读

if(!P3_6)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 L1

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x37:

{

P3_7 = 1;
//先将其置高再读

if(!P3_7)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

/******************************************************************************************************/

case 0x40:

{

P4_0 = 1;
//先将其置高再读

if(!P4_0)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x41:

{

P4_1 = 1;
//先将其置高再读

if(!P4_1)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x42:

{

P4_2 = 1;
//先将其置高再读

if(!P4_2)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x43:

{

P4_3 = 1;
//先将其置高再读

if(!P4_3)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x44:

{

P4_4 = 1;
//先将其置高再读

if(!P4_4)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x45:

{

P4_5 = 1;
//先将其置高再读

if(!P4_5)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 L1

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x46:

{

P4_6 = 1;
//先将其置高再读

if(!P4_6)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 L1

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x47:

{

P4_7 = 1;
//先将其置高再读

if(!P4_7)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

/******************************************************************************************************/

case 0x50:

{

P5_0 = 1;
//先将其置高再读

if(!P5_0)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x51:

{

P5_1 = 1;
//先将其置高再读

if(!P5_1)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x52:

{

P5_2 = 1;
//先将其置高再读

if(!P5_2)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

case 0x53:

{

P5_3 = 1;
//先将其置高再读

if(!P5_3)
//如果端口为低

SEND_CHRA(BIT_L);
//向串口发送当前端口为 L

else
//如果端口为高

SEND_CHRA(BIT_H);
//向串口发送当前端口为 H

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

default:

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

SEND_CHRA(0x0D);

SEND_CHRA(0x0A);
//回车

}
/********************************
端口总线操作方式写
************************************************/

if(GLengthLoh[3] == p0)
//如果GLengthLoh[3]为 0xA0 则对P0口寄存器写操作

{

P0 = GLengthLoh[4];
//如果收到写P0口指令将立即数送P0所有口

SEND_OK();
//向串口OK字符串并转行

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}

if(GLengthLoh[3] == p1)
//如果GLengthLoh[3]为 0xA1 则对P1口寄存器写操作

{

P1 = GLengthLoh[4];
//如果收到写P1口指令将立即数送P1所有口

SEND_OK();
//向串口OK字符串并转行

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}

if(GLengthLoh[3] == p2)
//如果GLengthLoh[3]为 0xA2 则对P2口寄存器写操作

{

P2 = GLengthLoh[4];
//如果收到写P2口指令将立即数送P2所有口

SEND_OK();
//向串口OK字符串并转行

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}
/*********************************
端口总线操作方式读
************************************************/

if(GLengthLoh[3] == READ_P)
//如果GLengthLoh[3]为 0xBD
则对相应的端口寄存器读操作

{

switch (GLengthLoh[4])

{

case p0:
//则对P0口寄存器读操作

//SEND_CHRA(P0);
//向串口发送P0所有口的值以十六进制型式输出

//sprintf(str_buff,"%d",(P0-256)+256);
//以十进制输出

//uart_puts(str_buff);
//向串口发送字符串并转行

SEND_CHRA(HexToChar(P0 >> 4));//将十六进制转换为字符型式输出高四位

SEND_CHRA(HexToChar(P0 & 0x0F));//将十六进制转换为字符型式输出低四位

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

case p1:
//则对P1口寄存器读操作

//SEND_CHRA(P1);
//向串口发送P0所有口的值以十六进制型式输出

//sprintf(str_buff,"%d",(P1-256)+256);
//以十进制输出

//uart_puts(str_buff);
//向串口发送字符串并转行

SEND_CHRA(HexToChar(P1 >> 4));//将十六进制转换为字符型式输出高四位

SEND_CHRA(HexToChar(P1 & 0x0F));//将十六进制转换为字符型式输出低四位

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

case p2:
//则对P2口寄存器读操作

//SEND_CHRA(P2);
//向串口发送P0所有口的值以十六进制型式输出

//sprintf(str_buff,"%d",(P2-256)+256);
//以十进制输出

//uart_puts(str_buff);
//向串口发送字符串并转行

SEND_CHRA(HexToChar(P2 >> 4));//将十六进制转换为字符型式输出高四位

SEND_CHRA(HexToChar(P2 & 0x0F));//将十六进制转换为字符型式输出低四位

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;
/******************************************************************************************************/

default:

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

SEND_CHRA(0x0D);

SEND_CHRA(0x0A);
//回车

}
/******************************************************************************************************/

if(GLengthLoh[3] ==  RyRST)
//如果GLengthLoh[3]=0xBB与GLengthLoh[4]=0xAA则进行全部继电器释放

{

if(GLengthLoh[4] == 0xAA)
//如果GLengthLoh[4]=0xAA作以下处理

{

RY_INIT();
//进行N次的AD转换

SEND_OK();
//向串口OK字符串并转行

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}

else break;
//如果GLengthLoh[4] != 0xAA 不作以处理

}
/******************************************************************************************************/

if(GLengthLoh[3] ==  DC_AD)
//如果GLengthLoh[3]为 0xAD 则进行立即数次AD转换

{

P2_7 = 1;
//选择测试直流 DC

_nop_();

P2_6 = 0;
//选择测试直流 DC

gong_bei = GLengthLoh[4];
//GLengthLoh[4]中的值作为AD转换的次数允许为1~255

delay(10);
//延时10MS

if(gong_bei > 0)
//如果STRLEN=0则次数等于0没有实际意义故不作AD转处理

{

TM7708_CONVERSION(gong_bei);
//进行N次的AD转换

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}

else CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}
/******************************************************************************************************/

if(GLengthLoh[3] ==  AC_AD)
//如果GLengthLoh[3]为 0xAD 则进行立即数次AD转换

{

P2_7 = 0;
//选择测试交流 AC

_nop_();

P2_6 = 1;
//选择测试交流 AC

gong_bei = GLengthLoh[4];
//GLengthLoh[4]中的值作为AD转换的次数允许为1~255

delay(10);
//延时10MS

if(gong_bei > 0)
//如果STRLEN=0则次数等于0没有实际意义故不作AD转处理

{

TM7708_CONVERSION(gong_bei);
//进行N次的AD转换

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}

else CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}

/******************************************************************************************************/

//如果GLengthLoh[3]为 0xD0~0xDF之间的数表示为选择I/0继电器通道板

if((GLengthLoh[3] >= 0xD0) && (GLengthLoh[3] <= 0xDF))//执行16片RY板的选通

{
/******************************************************************************************************/

P1_5 = 0;
//所有74HC系列数字电路IC输出使能控制端置低，使其所有引脚能正常输出信号

P1 = (P1 & 0xF0) | (GLengthLoh[3] & 0xcf);//与上0xcf目的保证P1.6&P1.7口为高

//相当于先屏蔽P1口的低4位，再用GLengthLoh[3]中的低4位代替原P1口的低4位且保证P1.7为高

//P1口的低4位为四片I/O继电器通道板的选择控制端
/******************************************************************************************************/

P0 = GLengthLoh[4];
//将串口接收到的立即数送到P0口

P1_4 = 0;
//产生一个上升沿

delay(5);
//延时5MS

P1_4 = 1;
//产生一个上升沿

SEND_OK();
//向串口OK字符串并转行

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}

break;

}
/******************************************************************************************************/

case 0xac:
//GLengthLoh[2] == 0xAC//选择测试交流 AC

{

UART_RI = REN = 0;
//接收成功标志位置0防止多次重入//禁止串口接收

P2 = GLengthLoh[3];
//将GLengthLoh[3]中的数据直接送到P2口。

gong_bei = GLengthLoh[4];
//将GLengthLoh[4]中的数据作为要进行AD转换的次数先暂存

if(((GLengthLoh[3] & 0x60) == 0x60) || ((GLengthLoh[3] & 0x68) == 0x68))

{

if((GLengthLoh[3] & 0x60) == 0x60)

{

P5_0 = 0;
//选择差分IN1 & IN2

P5_1 = 1;
//选择差分IN1 & IN2

}

else

{

P5_0 = 1;
//选择差分IN3 & IN4

P5_1 = 0;
//选择差分IN3 & IN4

P2_3 = 0;
//如果不将其置0则会选通为输入地

}

delay(300);
//如果测DC通道的差分电压则转换通道后延时300MS

}

else

{

P5_0 = P5_1 = 1;
//不选择任何一组差分

delay(20);
//转换通道后延时20MS

}
/*
for (gong_bei = 0;gong_bei < 255;gong_bei++)

{

buff_7708[gong_bei] = 0;
//将缓存区清 0

}
*/

if(gong_bei > 0)
//如果gong_bei = 0则没有实际意义故不作AD转换处理

{

TM7708_CONVERSION(gong_bei);
//进行N次的AD转换

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}

else CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收;

break;

}
/******************************************************************************************************/

case 0xdc:
//GLengthLoh[2] == 0xDC//选择测试直流 DC

{

UART_RI = REN = 0;
//接收成功标志位置0防止多次重入//禁止串口接收

P2 = GLengthLoh[3];
//将GLengthLoh[3]中的数据直接送到P2口。

gong_bei = GLengthLoh[4];
//将GLengthLoh[4]中的数据作为要进行AD转换的次数先暂存

if(((GLengthLoh[3] & 0xA0) == 0xA0) || ((GLengthLoh[3] & 0xA8) == 0xA8))

{

if((GLengthLoh[3] & 0xA0) == 0xA0)

{

P5_0 = 0;
//选择差分IN1 & IN2

P5_1 = 1;
//选择差分IN1 & IN2

}

else

{

P5_0 = 1;
//选择差分IN3 & IN4

P5_1 = 0;
//选择差分IN3 & IN4

P2_3 = 0;
//如果不将其置0则会选通为输入地

}

delay(300);
//如果测DC通道的差分电压则转换通道后延时300MS

}

else

{

P5_0 = P5_1 = 1;
//不选择任何一组差分

delay(20);
//转换通道后延时20MS

}
/*
for (gong_bei = 0;gong_bei < 255;gong_bei++)

{

buff_7708[gong_bei] = 0;
//将缓存区清 0

}
*/

if(gong_bei > 0)
//如果gong_bei = 0则没有实际意义故不作AD转换处理

{

TM7708_CONVERSION(gong_bei);
//进行N次的AD转换

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

}

else CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收;

break;

}
/******************************************************************************************************/

case 0xda:
//GLengthLoh[2] == 0xDC//进行DA转换

{

UART_RI = REN = 0;
//接收成功标志位置0防止多次重入//禁止串口接收

if((GLengthLoh[3] & 0xc0) == 0xc0)
//判断高2位数据是0 & 1

SEND_DAC121(GLengthLoh[3] * 256 + GLengthLoh[4]);
//向DAC121S101中发送数据

else

SEND_DAC081(GLengthLoh[4]);
//向DAC081S101中发送数据

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

SEND_OK();
//向串口OK字符串并转行

break;

}

default:

UART_RI = REN = 0;
//接收成功标志位置0防止多次重入//禁止串口接收

CLR_ByUART();
//清除串口接收的所有数据及允许串口接接收

break;

}

}

}
}
/******************************************************************************************************/

sunny503 · 发表于 2012-11-29 05:16

这个编程那个强呀，几年前就用过AD7705-AD转换的集成做了个30V/3A春风数控稳压电源，现在还有2个AD7705呢。有空要试试了，多谢楼主共享哦

sqdnyll · 发表于 2012-11-29 22:38

回复 1# LBQ691477940

支持，谢啦！学习了

protel138 · 发表于 2014-11-26 12:19

支持，谢啦！学习了

Kowalski · 发表于 2014-12-6 14:51

感谢楼主分享~~~

fwj59 · 发表于 2017-12-5 13:48

感谢楼主分享~~~

		自动登录	找回密码
密码			请使用微信账号登录和注册会员

[其他综合] labview通过串口通信控制和读取89S52端口及AD7705-AD转换