设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › GYJ-0095单片机四路输入输出继电器工控板仿modbus控制源 ...
返回列表 发新帖
查看: 3758|回复: 3
收起左侧

GYJ-0095单片机四路输入输出继电器工控板仿modbus控制源码与资料下载

[复制链接]
ID:280979 发表于 2018-3-18 01:01 | 显示全部楼层 |阅读模式
GYJ-0095_四路输入输出继电器工控板产品使用说明书
【简要说明】
一、尺寸：长145mmX宽90mmX高20mm
二、主要芯片：单片机STC89C52RC 继电器 光耦
三、工作电压：有直流12V及24V可选。
四、特点：
电路结构简单，稳定可靠，采用最新款STC单片机，运行速度快，单片机预留扩展接口。
1、具有四路输入信号指示灯，四路继电器吸合指示灯，电源指示灯。
2、板子功耗小于8W
3、额定切换电流10A以内，切换电压250V以内
4、单路最大切换功率500W 额定功率300W
5、继电器寿命1000000次以上。
6、电器绝缘电阻100M
7、触电耐压1000V
8、继电器最大吸合时间15mS毫秒
9、继电器最大释放时间5mS毫秒
10、工作温度-40度至+70度
11、工作湿度40%~80%RH
12、四路光电隔离输入，8路光电隔离输出
13、四输入低电平有效（即：NPN输入）
14、四路输出开关量输出（即：干接点输出）
15、具有MAX232通讯。
16、单片机所有IO口都引出，客户可以自己编程扩展功能
17、可以选择使用外部EEPROM 作为存储单元
18、电路具有，防反接保护、过流保护、续流保护、压敏保护等
19、单片机可以自行更换，可以选择替换型的STC系列单片机
20、我们提供电路相关的，原理图、例程、开发环境、下载软件等相关资料
适用场合：工业控制、产品开发、项目设计，自动化改造等
【标注说明】
010133h5u22dccdwl2wldc.jpg
【接线说明】
   
【输入控制设备】
【输出控制设备】

【输出举例说明】
【输出举例说明】（开关量输出、干接点输出）
【专业下载线接线说明】
【串口通信说明】也可以通过串口下载



【原理图】（提供PDF格式的原理图及PCB图)更清晰
免费提供与此工控板有关的：资料、例程、原理图
芯片资料、软件。
【图片展示】

【默认发货程序】
  1. 单片机与PC机采用9针串口，MAX232通讯，波特率默认为9600.

  3. 单片机接收PC机发送的十六进制码表如下：

  5. 01、全开：PC发送'I'；
  6. 02、全关：PC发送'i';

  8. 03、第一路开：PC发送'A'；
  9. 04、第二路开：PC发送'B'；
  10. 05、第三路开：PC发送'C'；
  11. 06、第四路开：PC发送'D'；


  14. 11、第一路关：PC发送'a'；
  15. 12、第二路关：PC发送'b'；
  16. 13、第三路关：PC发送'c'；
  17. 14、第四路关：PC发送'd'；


  20. *********************************************************************/
  21. #include<reg52.h>                       //库文件
  22. #define uchar unsigned char//宏定义无符号字符型
  23. #define uint unsigned int  //宏定义无符号整型
  24. /********************************************************************
  25.                             初始定义
  26. *********************************************************************/

  28. unsigned char dat; //用于存储单片机接收发送缓冲寄存器SBUF里面的内容

  30. /*定义八位输入为单片机P1口*/
  31. sbit IN0=P1^0;
  32. sbit IN1=P1^1;
  33. sbit IN2=P1^2;
  34. sbit IN3=P1^3;

  36. /*定义八位输出为单片机P2口*/
  37. sbit K1=P2^0;
  38. sbit K2=P2^1;
  39. sbit K3=P2^2;
  40. sbit K4=P2^3;

  42. /********************************************************************
  43.                             延时函数
  44. *********************************************************************/
  45. void delay(uchar t)
  46. {
  47.   uchar i,j;
  48.    for(i=0;i<t;i++)
  49.    {
  50.                  for(j=13;j>0;j--);
  51.               { ;
  52.               }
  53.    }
  54. }

  56. /********************************************************************
  57.               功能:串口初始化,波特率9600，方式1
  58. *********************************************************************/
  59. void Init_Com(void)
  60. {
  61. TMOD = 0x20;
  62. PCON = 0x00;
  63. SCON = 0x50;
  64. TH1 = 0xFd;
  65. TL1 = 0xFd;
  66. TR1 = 1;
  67. }

  69. /********************************************************************
  70.                             主函数
  71. *********************************************************************/
  72. void main()
  73. {
  74. Init_Com();//串口初始化
  75. while(1)
  76. {

  78. if(IN0==0){delay(100);K1=0;while(!IN0);SBUF ='1';K1=1;} //继电器K1按下闭合，松开断开
  79. if(IN1==0){delay(100);K2=0;while(!IN1);SBUF ='2';K2=1;} //继电器K2按下闭合，松开断开
  80. if(IN2==0){delay(100);K3=0;while(!IN2);SBUF ='3';K3=1;} //继电器K3按下闭合，松开断开
  81. if(IN3==0){delay(100);K4=0;while(!IN3);SBUF ='4';K4=1;} //继电器K4按下闭合，松开断开                    
  82. if ( RI ) //扫描判断是否接收到数据，
  83. {
  84. dat = SBUF; //接收数据SBUF赋与dat
  85. RI=0; //RI 清零。
  86. SBUF = dat; //在原样把数据发送回去
  87. }
  88. /********************************************************************
  89.                             接收数据判断函数
  90. *********************************************************************/
  91. switch(dat) //接收数据判断
  92. {
  93. uchar k;
  94. k=10;
  95. case 'I': P2=0X00;delay(k);break; //  全开
  96. case 'i': P2=0XFF;delay(k);break; //  全关

  98. case 'A': K1=0;delay(k);break;                 //  第一路开
  99. case 'B': K2=0;delay(k);break;                 //  第二路开
  100. case 'C': K3=0;delay(k);break;                 //  第三路开
  101. case 'D': K4=0;delay(k);break;                 //  第四路开

  103. case 'a': K1=1;delay(k);break;                 //  第一路关
  104. case 'b': K2=1;delay(k);break;                 //  第二路关
  105. case 'c': K3=1;delay(k);break;                 //  第三路关
  106. case 'd': K4=1;delay(k);break;                 //  第四路关


  109. default:break;                                                                         //  跳出
  110. }

  112. }
  113. }
  114.             
  115. /********************************************************************
  116.                               结束
  117. *********************************************************************/

复制代码

【仿modbus通信控制程序】
                           485通讯控制板通讯协议(技术QQ115451619)

波特率 9600
通讯协议格式如下：发送十六进制
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00~FF
00~09
00~FF
BB
解释
第一个数据
第二个数据
第三个数据
第四个数据
最后一个数据
功能1：改变板子地址
举例:更改地址：（发货默认地址00）注意：多个板子并联使用时需要不同地址
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
01
01
BB
解释
开始数据
向00地址发送
改变地址
将地址改成01
数据结束
功能2：打开继电器
举例:打开第一块板子的继电器
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
02
01
BB
解释
开始数据
向00地址发送
打开功能
打开继电器
数据结束
功能3：关闭继电器
举例:关闭第二路板子的继电器
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
01
03
01
BB
解释
开始数据
向01地址发送
关闭功能
关闭继电器
数据结束
功能4：打开某块板子的所有继电器（单路继电器模块的这个功能码和功能2一样）
举例:打开第一块板子的全部继电器
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
04
FF
BB
解释
开始数据
向00地址发送
打开所有功能
打开所有继电器
数据结束
功能5：关闭某块板子的所有继电器（单路继电器模块的这个功能码和功能3一样）
举例:关闭第三块板子的全部继电器
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
02
05
00
BB
解释
开始数据
向02地址发送
关闭所有功能
关闭所有继电器
数据结束
功能6：查询继电器状态
举例:查询第一块板子继电器状态
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
06
01
BB
解释
开始数据
向00地址发送
查询功能
查询继电器
数据结束
查询返回信息分析 继电器关闭返回值（关闭返回00）
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
07
00
BB
解释
开始数据
00地址返回
返回功能
继电器状态关闭
数据结束
查询返回信息分析 继电器打开返回值（打开返回FF）
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
07
FF
BB
解释
开始数据
00地址返回
返回功能
继电器状态打开
数据结束

功能7：查询输入状态
举例:查询第一块板子的输入状态
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
08
01
BB
解释
开始数据
向00地址发送
查询功能
查询输入
数据结束
查询返回信息分析 输入返回值（关闭返回00）
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
09
00
BB
解释
开始数据
00地址返回
返回功能
输入状态关闭
数据结束
查询返回信息分析 输入返回值（打开返回01）
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
09
FF
BB
解释
开始数据
00地址返回
返回功能
输入状态打开
数据结束
功能8：输入发送数据
当输入端有信号时，给上位机发送数据
举例：第一路有信号输入时的数据为：AA 00 08 01 BB
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
08
01~08
BB
解释
开始数据
00地址返回
返回功能
输入状态
数据结束
功能9：板子地址清零控制(用于地址不清晰或者忘记，在485总线下禁止操作，只可对其单独清零)
协议
启始位
地址位
功能位
数据位
结束位
控制
AA
00
00
00
BB
解释
开始数据
00
地址清零
数据结束
功能10：继电器定时输出
协议
启始位
地址位
继电器位
数据位
结束位
控制
AA
00
11
00
BB
解释
开始数据
地址
打开第一个继电器
时间值单位秒
数据结束
协议
启始位
地址位
继电器位
数据位
结束位
控制
AA
00
12
00
BB
解释
开始数据
地址
打开第二个继电器
时间值单位秒
数据结束
协议
启始位
地址位
继电器位
数据位
结束位
控制
AA
00
13
00
BB
解释
开始数据
地址
打开第三个继电器
时间值单位秒
数据结束
协议
启始位
地址位
继电器位
数据位
结束位
控制
AA
00
14
00
BB
解释
开始数据
地址
打开第四个继电器
时间值单位秒
数据结束
  1. #include<reg52.h>                       //库文件
  2. #include <intrins.H>
  3. #include<EEPROM.h>
  4. #define uchar unsigned char//宏定义无符号字符型
  5. //sfr WDT_CONTR=0Xe1;
  6. sbit K1=P2^0;
  7. sbit K2=P2^1;
  8. sbit K3=P2^2;
  9. sbit K4=P2^3;
  10. sbit K5=P2^4;
  11. sbit K6=P2^5;
  12. sbit K7=P2^6;
  13. sbit K8=P2^7;

  15. /*定义八位入为单片机P1口*/
  16. sbit IN0=P1^0;
  17. sbit IN1=P1^1;
  18. sbit IN2=P1^2;
  19. sbit IN3=P1^3;
  20. sbit IN4=P1^4;
  21. sbit IN5=P1^5;
  22. sbit IN6=P1^6;
  23. sbit IN7=P1^7;
  24. uchar dat;
  25. uchar t,r,ii;
  26. uchar k=100;
  27. uchar add;    //掉电保持485的地址
  28. uchar j=0;
  29. bit flag_zx=0;
  30. uchar sendBuf[10];                //发送缓冲区
  31. uchar receBuf[10];    //接收缓冲区
  32. uchar s1,s2,s3,s4,s5,s6,s7,s8;
  33. uchar s11,s22,s33,s44,s55,s66,s77,s88;
  34. bit busy;
  35. bit bz1=0;
  36. bit bz2=0;
  37. bit bz3=0;
  38. bit bz4=0;
  39. bit bz5=0;
  40. bit bz6=0;
  41. bit bz7=0;
  42. bit bz8=0;

  44. bit sj1=0;
  45. bit sj2=0;
  46. bit sj3=0;
  47. bit sj4=0;
  48. bit sj5=0;
  49. bit sj6=0;
  50. bit sj7=0;
  51. bit sj8=0;
  52. /********************************************************************
  53.                             初始定义
  54. *********************************************************************/
  55. uint sec; //定义计数值，每过1/10 秒，sec 加一
  56. uint tcnt; //键值判断
  57. /********************************************************************
  58.                             延时函数
  59. *********************************************************************/
  60. void delay(uchar t)
  61. {
  62.   uchar i,j;
  63.    for(i=0;i<t;i++)
  64.    {
  65.                  for(j=13;j>0;j--);
  66.               { ;
  67.               }
  68.    }
  69. }

  71. /********************************************************************
  72.               功能:串口初始化,波特率9600，方式1
  73. *********************************************************************/
  74. void Init_Com(void)
  75. {
  76. TMOD|=0x20;
  77. SCON=0x50;
  78. TH1=0xfd;
  79. TL1=0xfd;
  80. TR1=1;
  81. ES=1;
  82. }

  84. /****************发送函数*********************/
  85. void senduart2()
  86. {               
  87. //RS485_DIR=1;
  88. SBUF=sendBuf[0];while(!TI);TI=0;
  89. SBUF=sendBuf[1];while(!TI);TI=0;
  90. SBUF=sendBuf[2];while(!TI);TI=0;
  91. SBUF=sendBuf[3];while(!TI);TI=0;
  92. SBUF=sendBuf[4];while(!TI);TI=0;
  93. }

  95. /****************发送函数*********************/
  96. void send1()
  97. {               
  98. //RS485_DIR=1;
  99. SBUF=0XAA;while(!TI);TI=0;
  100. SBUF=add;while(!TI);TI=0;
  101. SBUF=0X08;while(!TI);TI=0;
  102. SBUF=0X01;while(!TI);TI=0;
  103. SBUF=0XBB;while(!TI);TI=0;
  104. }
  105. /****************发送函数*********************/
  106. void send2()
  107. {               
  108. //RS485_DIR=1;
  109. SBUF=0XAA;while(!TI);TI=0;
  110. SBUF=add;while(!TI);TI=0;
  111. SBUF=0X08;while(!TI);TI=0;
  112. SBUF=0X02;while(!TI);TI=0;
  113. SBUF=0XBB;while(!TI);TI=0;
  114. }
  115. /****************发送函数*********************/
  116. void send3()
  117. {               
  118. //RS485_DIR=1;
  119. SBUF=0XAA;while(!TI);TI=0;
  120. SBUF=add;while(!TI);TI=0;
  121. SBUF=0X08;while(!TI);TI=0;
  122. SBUF=0X03;while(!TI);TI=0;
  123. SBUF=0XBB;while(!TI);TI=0;
  124. }
  125. /****************发送函数*********************/
  126. void send4()
  127. {               
  128. //RS485_DIR=1;
  129. SBUF=0XAA;while(!TI);TI=0;
  130. SBUF=add;while(!TI);TI=0;
  131. SBUF=0X08;while(!TI);TI=0;
  132. SBUF=0X04;while(!TI);TI=0;
  133. SBUF=0XBB;while(!TI);TI=0;
  134. }
  135. /****************发送函数*********************/
  136. void send5()
  137. {               
  138. //RS485_DIR=1;
  139. SBUF=0XAA;while(!TI);TI=0;
  140. SBUF=add;while(!TI);TI=0;
  141. SBUF=0X08;while(!TI);TI=0;
  142. SBUF=0X05;while(!TI);TI=0;
  143. SBUF=0XBB;while(!TI);TI=0;
  144. }
  145. /****************发送函数*********************/
  146. void send6()
  147. {               
  148. //RS485_DIR=1;
  149. SBUF=0XAA;while(!TI);TI=0;
  150. SBUF=add;while(!TI);TI=0;
  151. SBUF=0X08;while(!TI);TI=0;
  152. SBUF=0X06;while(!TI);TI=0;
  153. SBUF=0XBB;while(!TI);TI=0;
  154. }/****************发送函数*********************/
  155. void send7()
  156. {               
  157. //RS485_DIR=1;
  158. SBUF=0XAA;while(!TI);TI=0;
  159. SBUF=add;while(!TI);TI=0;
  160. SBUF=0X08;while(!TI);TI=0;
  161. SBUF=0X07;while(!TI);TI=0;
  162. SBUF=0XBB;while(!TI);TI=0;
  163. }
  164. /****************发送函数*********************/
  165. void send8()
  166. {               
  167. //RS485_DIR=1;
  168. SBUF=0XAA;while(!TI);TI=0;
  169. SBUF=add;while(!TI);TI=0;
  170. SBUF=0X08;while(!TI);TI=0;
  171. SBUF=0X08;while(!TI);TI=0;
  172. SBUF=0XBB;while(!TI);TI=0;
  173. }

  175. /*****************清空发送缓冲区*************************/
  176. void clear_receBuf()
  177. {
  178.     uchar i;
  179.               for(i=0;i<5;i++)
  180.               {
  181.                   receBuf[i]=0;
  182.               }
  183. }
  184. /********************************************************************
  185.               功能:串口初始化,波特率9600，方式1
  186. *********************************************************************/
  187. void initTimer(void)
  188. {
  189. TMOD=0x2;
  190. TH0=0x1b;
  191. TL0=0x1b;
  192. }
  193. /********************************************************************
  194.                             串口中断服务函数
  195. *********************************************************************/
  196. void uart(void) interrupt 4
  197. {
  198. /********************************************************************
  199.                             接收数据判断函数
  200. *********************************************************************/
  201. if(RI)  //如果有接收
  202.                  {
  203.                    RI=0; //接收标志清零
  204.                    receBuf[r++&0x0F]=SBUF;     //把接受的数据存储到BUT数组中
  205.                             if(receBuf[0]!=0xaa){r=0;}
  206.                             if(r>=5)
  207.                             {              r=0;

  209.                                 flag_zx=1;
  210.                             }
  211.                  }
  212.                  if(flag_zx==1)
  213.                  {                                

  215.                       flag_zx=0;
  216.                            
  217.                                 //0         1       2       3        4                           
  218.                                           //起始位   地址位  功能位   数据位  结束位
  219.                                           if((receBuf[0]==0xaa)&&(receBuf[4]==0xbb)&&(receBuf[1]==add))                //如果开始位和结束位，还有地址都正确，进行下一步判断
  220.                                           {
  221.                                              if(receBuf[2]==0x01)  //修改板子地址
  222.                                              {
  223.                                                   add=receBuf[3];
  224.                                                                       EEPROMSectorErase(0);//擦除扇区
  225.                                                   EEPROMWriteByte(0,add);//写入新的地址
  226.                                              }
  227.                                              else if(receBuf[2]==0x02)  //打开单路继电器
  228.                                              {
  229.                                                                switch(receBuf[3])
  230.                                                                       {
  231.                                                                           case 0x01: K1=0;sj1=0; break;
  232.                                                                                     case 0x02: K2=0;sj2=0; break;
  233.                                                                           case 0x03: K3=0;sj3=0; break;
  234.                                                                                     case 0x04: K4=0;sj4=0; break;
  235.                                                                           case 0x05: K5=0;sj5=0;break;
  236.                                                                                     case 0x06: K6=0;sj6=0;break;
  237.                                                                           case 0x07: K7=0;sj7=0;break;
  238.                                                                                     case 0x08: K8=0;sj8=0;break;
  239.                                                                                     default:break;
  240.                                                                       }
  241.                                              }
  242.                                              else if(receBuf[2]==0x03)  //关闭单路继电器
  243.                                              {
  244.                                                                switch(receBuf[3])
  245.                                                                       {
  246.                                                                           case 0x01: K1=1;sj1=0; break;
  247.                                                                                     case 0x02: K2=1;sj2=0; break;
  248.                                                                           case 0x03: K3=1;sj3=0; break;
  249.                                                                                     case 0x04: K4=1;sj4=0; break;
  250.                                                                           case 0x05: K5=1;sj5=0; break;
  251.                                                                                     case 0x06: K6=1;sj6=0; break;
  252.                                                                           case 0x07: K7=1;sj7=0; break;
  253.                                                                                     case 0x08: K8=1;sj8=0; break;
  254.                                                                                     default:break;
  255.                                                                       }                                 
  256.                                              }
  257.                                              else if(receBuf[2]==0x04)  //打开全部继电器
  258.                                              {
  259.                                                   if(receBuf[3]==0xff)
  260.                                                   {
  261.                                                                           P2=0X00; sj1=0;sj2=0;sj3=0;sj4=0;sj5=0;sj6=0;sj7=0;sj8=0;
  262.                                                                       }
  263.                                              }
  264.                                              else if(receBuf[2]==0x05)  //关闭全部继电器
  265.                                              {
  266.                                                   if(receBuf[3]==0x00)
  267.                                                   {
  268.                                                                           P2=0XFF; sj1=0;sj2=0;sj3=0;sj4=0;sj5=0;sj6=0;sj7=0;sj8=0;
  269.                                                                       }                                 
  270.                                              }
  271.                                              else if(receBuf[2]==0x06)  //查询继电器
  272.                                              {
  273.                                                                       sendBuf[0]=0xaa;
  274.                                                                       sendBuf[1]=add;
  275.                                                                       sendBuf[2]=0x07;
  276.                                                                       //sendBuf[3]=0xfe;
  277.                                                                       sendBuf[4]=0xbb;            
  278.                                                  switch(receBuf[3])
  279.                                                            {
  280.                                                                case 0x01: if(K1==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  281.                                                                          case 0x02: if(K2==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  282.                                                                case 0x03: if(K3==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  283.                                                                          case 0x04: if(K4==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  284.                                                                case 0x05: if(K5==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  285.                                                                          case 0x06: if(K6==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  286.                                                                case 0x07: if(K7==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  287.                                                                          case 0x08: if(K8==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  288.                                                                          default:break;
  289.                                                            }
  290.                                                            senduart2();
  291.                                              }
  292.                                              else if(receBuf[2]==0x08)  //查询输入
  293.                                              {
  294.                                                                       sendBuf[0]=0xaa;
  295.                                                                       sendBuf[1]=add;
  296.                                                                       sendBuf[2]=0x09;
  297.                                                                       //sendBuf[3]=0xfe;
  298.                                                                       sendBuf[4]=0xbb;
  299.                                                       
  300.                                                  switch(receBuf[3])
  301.                                                            {
  302.                                                                case 0x01: if(IN0==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  303.                                                                          case 0x02: if(IN1==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  304.                                                                case 0x03: if(IN2==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  305.                                                                          case 0x04: if(IN3==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  306.                                                                case 0x05: if(IN4==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  307.                                                                          case 0x06: if(IN5==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  308.                                                                case 0x07: if(IN6==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  309.                                                                          case 0x08: if(IN7==0) sendBuf[3]=0xFF;else sendBuf[3]=0x00;break;
  310.                                                                          default:break;
  311.                                                            }
  312.                                                                       senduart2();
  313.                                              }                                          

  315.                                                        else if(receBuf[2]==0x11)  //第1路延时控制
  316.                                           {
  317.                                           sj1=1; s11=0;
  318.                                           s1=receBuf[3];clear_receBuf();
  319.                                              }                                                                                                                                                         
  320.                                                                                     else if(receBuf[2]==0x12)  //第2路延时控制
  321.                                           {
  322.                                           sj2=1;s22=0;
  323.                                           s2=receBuf[3];clear_receBuf();
  324.                                              }
  325.                                                                                     else if(receBuf[2]==0x13)  //第3路延时控制
  326.                                           {
  327.                                           sj3=1;s33=0;
  328.                                           s3=receBuf[3];clear_receBuf();
  329.                                              }
  330.                                                                                     else if(receBuf[2]==0x14)  //第4路延时控制
  331.                                           {
  332.                                           sj4=1;s44=0;
  333.                                           s4=receBuf[3];clear_receBuf();
  334.                                              }
  335.                          else if(receBuf[2]==0x15)  //第5路延时控制
  336.                                           {
  337.                                           sj5=1; s55=0;
  338.                                           s5=receBuf[3];clear_receBuf();
  339.                                              }
  340.                                                                                     else if(receBuf[2]==0x16)  //第6路延时控制
  341.                                           {
  342.                                           sj6=1;s66=0;
  343.                                           s2=receBuf[3];clear_receBuf();
  344.                                              }
  345.                                                                                     else if(receBuf[2]==0x17)  //第7路延时控制
  346.                                           {
  347.                                           sj7=1;s77=0;
  348.                                           s77=receBuf[3];clear_receBuf();
  349.                                              }
  350.                                                                                     else if(receBuf[2]==0x18)  //第8路延时控制
  351.                                           {
  352.                                           sj8=1;s88=0;
  353.                                           s8=receBuf[3];clear_receBuf();
  354.                                              }

  356.                                           }
  357.                                           if((receBuf[0]==0xaa)&&(receBuf[1]==0x00)&&(receBuf[2]==0x00)&&(receBuf[3]==0x00)&&(receBuf[4]==0xbb))
  358.                                           {
  359.                                                   add=0x00;
  360.                                                                       EEPROMSectorErase(0);//擦除扇区
  361.                                                   EEPROMWriteByte(0,0);//写入新的地址                                            
  362.                                           }
  363.                                           clear_receBuf();
  364.                             }

  366. }
  367. /********************************************************************
  368.                             主函数
  369. *********************************************************************/
  370. void main()
  371. {
  372. //WDT_CONTR=0x35;                //启动看门狗
  373. initTimer();
  374. Init_Com();//串口初始化
  375. add = EEPROMReadByte(0);
  376. //add = 0X00;
  377. TR0=1;
  378. ET0=1;
  379. EA=1;

  381. while(1)
  382. {



  386.     if((IN0==0)&&(bz1==0)){delay(k);if(IN0==0){delay(k);send1();clear_receBuf();bz1=1;}}if((bz1==1)&&(IN0==1)){delay(k);bz1=0;}
  387.     if((IN1==0)&&(bz2==0)){delay(k);if(IN1==0){delay(k);send2();clear_receBuf();bz2=1;}}if((bz2==1)&&(IN1==1)){delay(k);bz2=0;}
  388.     if((IN2==0)&&(bz3==0)){delay(k);if(IN2==0){delay(k);send3();clear_receBuf();bz3=1;}}if((bz3==1)&&(IN2==1)){delay(k);bz3=0;}
  389.     if((IN3==0)&&(bz4==0)){delay(k);if(IN3==0){delay(k);send4();clear_receBuf();bz4=1;}}if((bz4==1)&&(IN3==1)){delay(k);bz4=0;}

  391.     if((IN4==0)&&(bz5==0)){delay(k);if(IN4==0){delay(k);send5();clear_receBuf();bz5=1;}}if((bz5==1)&&(IN4==1)){delay(k);bz5=0;}
  392.     if((IN5==0)&&(bz6==0)){delay(k);if(IN5==0){delay(k);send6();clear_receBuf();bz6=1;}}if((bz6==1)&&(IN5==1)){delay(k);bz6=0;}
  393.     if((IN6==0)&&(bz7==0)){delay(k);if(IN6==0){delay(k);send7();clear_receBuf();bz7=1;}}if((bz7==1)&&(IN6==1)){delay(k);bz7=0;}
  394.     if((IN7==0)&&(bz8==0)){delay(k);if(IN7==0){delay(k);send8();clear_receBuf();bz8=1;}}if((bz8==1)&&(IN7==1)){delay(k);bz8=0;}
  395. /*if(write==1)
  396. {
  397. write=0;
  398.                                           KK1 = P0;
  399.                                           KK2 = P1;
  400.                                           KK3 = P2;
  401.                                           KK4 = P3;
  402.                                           EEPROMSectorErase(0);
  403.                                           EEPROMWriteByte(0,KK1);
  404.                                           EEPROMWriteByte(1,KK2);
  405.                                           EEPROMWriteByte(2,KK3);
  406.                                           EEPROMWriteByte(3,KK4);
  407. }*/
  408. }
  409. }
  410. /********************************************************************
  411.                             定时中断服务函数
  412. *********************************************************************/
  413. void t0(void) interrupt 1 using 0 //定时中断服务函数
  414. {
  415.               tcnt++; //每过250ust tcnt 加一
  416.               if(tcnt==3900) //计满400 次（1秒）时
  417.               {
  418.               tcnt=0; //重新再计
  419.               // K1=!K1;
  420.               // WDT_CONTR=0x35;  //7.2s喂狗一次
  421.               if(sj1==1){K1=0;s11++;if(s11>=s1){K1=1;s11=0;sj1=0;}}
  422.               if(sj2==1){K2=0;s22++;if(s22>=s2){K2=1;s22=0;sj2=0;}}
  423.               if(sj3==1){K3=0;s33++;if(s33>=s3){K3=1;s33=0;sj3=0;}}
  424.               if(sj4==1){K4=0;s44++;if(s44>=s4){K4=1;s44=0;sj4=0;}}
  425.               }
  426.               }
  427. /********************************************************************
  428.                               结束
  429. *********************************************************************/
复制代码


0.png 0.png

全部资料51hei下载地址：
GYJ-0095_四路输入输出继电器工控板发货资料.rar (8.74 MB, 下载次数: 126)
回复

使用道具 举报

ID:462629 发表于 2021-3-6 23:50 | 显示全部楼层
这是好人啊，打包成一个，太谢谢了
回复

使用道具 举报

ID:65956 发表于 2021-3-8 08:46 | 显示全部楼层
也只是仿modbus，并不是真modbus通讯协议，所以不一定很通用
回复

使用道具 举报

ID:336378 发表于 2021-3-17 11:44 | 显示全部楼层
    能用不？？
有大神用过没？？
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表