plc.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914
  1. /******************************************************************************
  2. 版权所有:
  3. 文件名称: plc.c
  4. 文件版本: 01.01
  5. 创建作者: sunxi
  6. 创建日期: 2015-11-02
  7. 功能说明: 可编程逻辑
  8. 其它说明:
  9. 1、只有实点可以合并成双点,且一个实点只能参加一个双点合并。双点合并在转发点表中
  10. 第一个点必须为合位,第二个点必须为分位。
  11. 修改记录:
  12. */
  13. /*------------------------------- 头文件 --------------------------------------
  14. */
  15. #include "head.h"
  16. /*------------------------------- 宏定义 --------------------------------------
  17. */
  18. // 逻辑点定义
  19. // 逻辑点由16位构成
  20. // 高3位: 类型 0保留,其它为真正类型
  21. // 次高5位: 开关号,0为公共,其它为开关序号
  22. // 低8位: 点号, 0为无效点号,取值返回为0.
  23. #define LP_TYPE 0XE000 // 逻辑点类型
  24. #define LP_SW 0X1F00 // 开关号
  25. #define LP_INDEX 0X00FF // 点号
  26. #define LP_TYPE_YX 0X2000 // 遥信点
  27. #define LP_TYPE_YK 0X4000 // 遥控点
  28. #define LP_TYPE_YC 0X6000 // 遥测点
  29. //#define LP_TYPE_EV 0X8000 // 事件点
  30. #define LP_TYPE_PLC 0XA000 // PLC 点
  31. #define LP_TYPE_PLC_CST 0XC000 // PLC 常量
  32. #define LP_TYPE_PLC_OPT 0XE000 // PLC 操作符
  33. #define LP_SW_PUB 0
  34. #define LP_SW_BEGIN 1
  35. #define LP_SW_END 31
  36. #define PLC_LOGIC_NOT (LP_TYPE_PLC_OPT | 0X0001)
  37. #define PLC_LOGIC_AND (LP_TYPE_PLC_OPT | 0X0002)
  38. #define PLC_LOGIC_OR (LP_TYPE_PLC_OPT | 0X0003)
  39. #define PLC_LOGIC_XOR (LP_TYPE_PLC_OPT | 0X0004)
  40. /*------------------------------ 类型结构 -------------------------------------
  41. */
  42. //可编程逻辑文件头
  43. struct plc_config
  44. {
  45. // 配置文件头
  46. struct cfg_file_head cfh;
  47. //工程文件名
  48. s8 prj_name[64];
  49. // 表达式
  50. u32 exp_addr; // 地址
  51. u32 exp_num; // 个数
  52. u32 exp_len; // 表达式长度
  53. // 保留
  54. u32 re_addr; //地址
  55. u32 re_num; //个数
  56. //对应描述文件
  57. u32 rsc_version; // 版本
  58. u32 rsc_signature; // 签名
  59. u32 rsc_length; // 长度
  60. u16 rsc_crc; // CRC
  61. u16 reserved0;
  62. };
  63. struct di_db
  64. {
  65. // 初始化值
  66. u32 timeout; // 双点滤波超时值
  67. u16 ev_code[2]; // 两个单点的遥信事件代码,由slot和no组合而成,从转发点表来
  68. // 双点采集用
  69. u32 us0; // 超时原点
  70. u8 bChange; // 标识双点变位动作
  71. u8 value0; // 双点结果,滤波前,由遥信处理程序直接生成
  72. u8 value1; // 双点结果,滤波后,且根据转发点表完成取反操作
  73. struct timespec ts; // 动作时刻
  74. };
  75. /*------------------------------ 全局变量 -------------------------------------
  76. */
  77. // 逻辑点数组
  78. struct lp g_lp[LP_NUM];
  79. // PLC处理数据
  80. u32 g_plc_num;
  81. struct plc g_plc[PLC_EXP_NUM+1];
  82. u32 g_plc_merge_index; // 合并点在PLC表中的位置
  83. // 双点遥信结构
  84. struct di_db g_di_db[MAX_DPI_NUMBER];
  85. /*------------------------------ 函数声明 -------------------------------------
  86. */
  87. void plc_db_soe(EVENT_STRUCT *ev);
  88. /*------------------------------ 外部函数 -------------------------------------
  89. 外部函数供其它实体文件引用,必须仔细检查传入参数的合法性.
  90. */
  91. int plc_yx2index(u8 sw, u8 type)
  92. {
  93. if(sw>SWITCH_NUM_MAX)
  94. {
  95. return -1;
  96. }
  97. if(type == 0)
  98. {
  99. return -1;
  100. }
  101. type--;
  102. if(sw == 0)
  103. {
  104. return type;
  105. }
  106. else
  107. {
  108. sw--;
  109. return PUB_DI_NUM_ALL+(SW_DI_NUM_ALL*sw) + type;
  110. }
  111. return -2;
  112. }
  113. SOE_DEF *plc_yx2soe(u8 sw, u8 type)
  114. {
  115. if(sw>SWITCH_NUM_MAX)
  116. {
  117. return NULL;
  118. }
  119. if(type == 0)
  120. {
  121. return NULL;
  122. }
  123. type--;
  124. if(sw == 0)
  125. {
  126. if(type >= PUB_DI_NUM && type < PUB_DI_NUM_ALL)
  127. {
  128. return (SOE_DEF *)&tAllSOE[type - PUB_DI_NUM + EV_SW_NUM];
  129. }
  130. }
  131. else
  132. {
  133. if(type >= SW_DI_NUM && type < SW_DI_NUM_ALL)
  134. {
  135. return (SOE_DEF *)&tAllSOE[type - SW_DI_NUM];
  136. }
  137. }
  138. return NULL;
  139. }
  140. s32 plc_get_input(u16 ld)
  141. {
  142. u16 type,sw,no;
  143. s32 r;
  144. type = (ld & LP_TYPE);
  145. sw = (ld & LP_SW)>>8 ;
  146. no = (ld & LP_INDEX);
  147. r = 0;
  148. switch(type)
  149. {
  150. case LP_TYPE_YX:
  151. r = GetRmtYxVal(sw,no);
  152. r = (r == SW_DI_TYPE_ON);
  153. break;
  154. case LP_TYPE_YC:
  155. r = GetRmtMeaVal(sw,no,NULL);
  156. break;
  157. case LP_TYPE_PLC:
  158. r = g_plc[no].result;
  159. break;
  160. case LP_TYPE_PLC_CST:
  161. break;
  162. }
  163. return r;
  164. }
  165. int plc_init_iec_table(void)
  166. {
  167. u16 i,j,ep;
  168. u16 v;
  169. int index;
  170. SOE_DEF * soe;
  171. // 处理单点,如果一个逻辑点对应多个通讯点,将除第一个通讯点外的其它通讯点放入PLC逻辑中
  172. for(i=0; i<g_table_head->di_num; i++)
  173. {
  174. index = plc_yx2index(g_di_table[i].owner,g_di_table[i].indexno);
  175. if(index < 0)
  176. {
  177. continue;
  178. }
  179. // 将第一个通讯点滤除
  180. if(g_lp[index].cp == g_di_table[i].cp)
  181. {
  182. continue;
  183. }
  184. // 没有通讯点,不需要
  185. if(g_di_table[i].cp == 0)
  186. {
  187. continue;
  188. }
  189. // 除第一个通讯点外的其它通讯点,放入PLC逻辑中
  190. // 检查空间
  191. if(g_plc_num >= PLC_EXP_NUM)
  192. {
  193. rt_printf("g_plc_num单点越限(g_plc_num=%d,i=%d).\r\n",g_plc_num,i);
  194. return -1;
  195. }
  196. // 通讯点
  197. g_plc[g_plc_num].cp = g_di_table[i].cp;
  198. // 标志,目前只有故障记录标志
  199. soe = plc_yx2soe(g_di_table[i].owner,g_di_table[i].indexno);
  200. if(soe)
  201. {
  202. if(soe->soe_def&0x80)
  203. {
  204. g_plc[g_plc_num].flag = (PLC_FLAG_FAULT|(g_di_table[i].owner<<16));
  205. }
  206. }
  207. // 插入操作数
  208. ep = 0;
  209. v = LP_TYPE_YX;
  210. v |= (g_di_table[i].owner<<8) | g_di_table[i].indexno;
  211. g_plc[g_plc_num].exp[ep++] = v;
  212. //单点取反
  213. if(g_di_table[i].is_inverse)
  214. {
  215. g_plc[g_plc_num].exp[ep++] = PLC_LOGIC_NOT;
  216. }
  217. // 结束符
  218. g_plc[g_plc_num].exp[ep++] = 0;
  219. g_plc_num++;
  220. }
  221. // 处理合并点
  222. g_plc_merge_index = g_plc_num;
  223. for(i=0;i<g_table_head->dimerge_num;i++)
  224. {
  225. if(g_plc_num >= PLC_EXP_NUM)
  226. {
  227. rt_printf("g_plc_num合并点越限(g_plc_num=%d,i=%d).\r\n",g_plc_num,i);
  228. return -2;
  229. }
  230. g_plc[g_plc_num].cp = g_di_merge_table[i].cp;
  231. ep = 0;
  232. for(j=0;j<MIX_YX_NUMBER;j++)
  233. {
  234. u8 no=g_di_merge_table[i].no[j]&0xff;
  235. u8 owner=(g_di_merge_table[i].no[j]>>8)&0xff;
  236. // 组合点号为空代表结束,退出。
  237. if(g_di_merge_table[i].no[j] == 0)
  238. {
  239. break;
  240. }
  241. // 标志,目前只有故障记录标志
  242. soe = plc_yx2soe(owner,no);
  243. if(soe)
  244. {
  245. if(soe->soe_def&0x80)
  246. {
  247. g_plc[g_plc_num].flag = (PLC_FLAG_FAULT|(owner<<16));
  248. }
  249. }
  250. // 插入操作数
  251. v = LP_TYPE_YX | (owner<<8) | no;
  252. g_plc[g_plc_num].exp[ep++] = v;
  253. //单点取反
  254. if(g_di_merge_table[i].is_inv[j])
  255. {
  256. g_plc[g_plc_num].exp[ep++] = PLC_LOGIC_NOT;
  257. }
  258. // 插入或运算符
  259. if(j)
  260. {
  261. g_plc[g_plc_num].exp[ep++] = PLC_LOGIC_OR;
  262. }
  263. }
  264. // 合并点取反
  265. if(g_di_merge_table[i].is_inv_all)
  266. {
  267. g_plc[g_plc_num].exp[ep++] = PLC_LOGIC_NOT;
  268. }
  269. // 结束符
  270. g_plc[g_plc_num].exp[ep++] = 0;
  271. // 检查长度是否越界
  272. if(ep > PLC_EXP_LEN)
  273. {
  274. rt_printf("plc_iec_table: 表达式太长(i=%d,j=%d,ep=%d).\r\n",i,j,ep);
  275. return -3;
  276. }
  277. g_plc_num++;
  278. }
  279. //g_plc[2].do_owner = 0;
  280. //g_plc[2].do_index = 1;
  281. return 0;
  282. }
  283. int plc_init(void)
  284. {
  285. int i, j, k,index,ret;
  286. u8 sw, no;
  287. u32 timeout[2] = {0};
  288. u32 timeout_add;
  289. // 初值
  290. for(i=0; i< LP_NUM; i++)
  291. {
  292. g_lp[i].cp =0;
  293. g_lp[i].db_index = -1;
  294. }
  295. if(equ_config_null())
  296. {
  297. return -1;
  298. }
  299. // 单点
  300. // 保存第一个单点通讯点号
  301. for(i=0; i<g_table_head->di_num; i++)
  302. {
  303. index = plc_yx2index(g_di_table[i].owner,g_di_table[i].indexno);
  304. if(index < 0)
  305. {
  306. // 跳过备用点
  307. continue;
  308. }
  309. if(g_lp[index].cp == 0)
  310. {
  311. g_lp[index].cp = g_di_table[i].cp;
  312. }
  313. }
  314. // 双点
  315. if(g_table_head->di_db_num >MAX_DPI_NUMBER)
  316. {
  317. return -2;
  318. }
  319. for(i=0; i<g_table_head->di_db_num; i++)
  320. {
  321. for (k=0; k<2; k++)
  322. {
  323. sw = (u8)(g_di_db_table[i].no[k]>>8);
  324. no = (u8)(g_di_db_table[i].no[k]);
  325. // 得到检查索引
  326. index = plc_yx2index(sw,no);
  327. if(index< 0)
  328. {
  329. return -3;
  330. }
  331. // 一个逻辑点只能对应一个双点
  332. if(g_lp[index].db_index >= 0)
  333. {
  334. return -4;
  335. }
  336. g_lp[index].db_index = i;
  337. // 得到滤波时间
  338. for (j=0; j<g_equ_config->di_num; j++)
  339. {
  340. if ((g_equ_config_di[j].owner == sw)
  341. && (g_equ_config_di[j].type == no))
  342. {
  343. g_di_db[i].ev_code[k] = (g_equ_config_di[j].slot<<8)|g_equ_config_di[j].index;
  344. timeout[k] = g_equ_config_di[j].filter_time*USTIMER_MS;
  345. break;
  346. }
  347. }
  348. // 初始化双点值
  349. if(j != g_equ_config->di_num)
  350. {
  351. // 双点标准定义中,分位在bit0,合位在bit1.在转发点表中合位在前,分位在后
  352. // 所以移位必须取反一下。
  353. int sft = !k;
  354. if(dido_di_is_on(g_equ_config_di[j].slot,g_equ_config_di[j].index))
  355. {
  356. g_di_db[i].value0 |= 1<<sft;
  357. }
  358. else
  359. {
  360. g_di_db[i].value0 &= ~(1<<sft);
  361. }
  362. g_di_db[i].value1 = g_di_db[i].value0;
  363. if(g_di_db_table[i].is_inv[k])
  364. {
  365. g_di_db[i].value1 ^= 1<<sft;
  366. }
  367. }
  368. else
  369. {
  370. rt_printf("双点需要实际通道对应(i=%d)\r\n",i);
  371. return -5;
  372. }
  373. }
  374. // 双点确认延时(两点滤波时间差),转化为us,再增加20ms,以确保双点变位成功
  375. // 2017-09-05:在电科院测试,遥信10ms滤波,双点没有变位信号。针对此情况修改如下:
  376. // 1、附加延时由固定的20ms改为最小滤波时间的1/4,这样10ms的遥信滤波,将有2.5ms的附加延时。
  377. // 初步评估2.5ms的延时相对于5ms的中断间隔是个合适的值,
  378. // 2、如果附加延时大于20ms则限制为20ms,防止延时过长。
  379. if(timeout[0] >= timeout[1])
  380. {
  381. g_di_db[i].timeout = (timeout[0] - timeout[1]);
  382. timeout_add = timeout[1]/4;
  383. }
  384. else
  385. {
  386. g_di_db[i].timeout = (timeout[1] - timeout[0]);
  387. timeout_add = timeout[0]/4;
  388. }
  389. if(timeout_add >20*USTIMER_MS)
  390. {
  391. timeout_add = 20*USTIMER_MS;
  392. }
  393. g_di_db[i].timeout += timeout_add;
  394. }
  395. // 解析PLC文件
  396. // 将转发点表中的多余单点和合并点转入PLC模块
  397. ret = plc_init_iec_table();
  398. if(ret < 0)
  399. {
  400. ret -= 10;
  401. }
  402. plc_scan(0);
  403. return ret;
  404. }
  405. int plc_exit(void)
  406. {
  407. return 0;
  408. }
  409. u8 plc_db_value(int index)
  410. {
  411. return g_di_db[index].value1;
  412. }
  413. void plc_db_init_value(u8 slot,u8 no,u8 v)
  414. {
  415. int index,db_index;
  416. u16 ev_code;
  417. ev_code = (slot<<8) | no;
  418. // 得到检查逻辑点索引
  419. index = plc_yx2index(g_di_st[slot][no].owner,g_di_st[slot][no].type);
  420. if(index < 0)
  421. {
  422. return;
  423. }
  424. // 检查双点索引
  425. db_index = g_lp[index].db_index;
  426. if(db_index < 0)
  427. {
  428. return;
  429. }
  430. #if 1
  431. // 取消正在进行的双点处理过程
  432. g_di_db[db_index].bChange = 0;
  433. #else
  434. // 双点第一次变位,记录时标
  435. if (g_di_db[db_index].bChange == 0)
  436. {
  437. g_di_db[db_index].ts = ev->ts;
  438. g_di_db[db_index].bChange = 1;
  439. }
  440. #endif
  441. // 每次变位都重新获取超时起点和双点的值
  442. g_di_db[db_index].us0 = ustimer_get_origin();
  443. if(ev_code == g_di_db[db_index].ev_code[0])
  444. {
  445. index = 1;
  446. }
  447. else if(ev_code == g_di_db[db_index].ev_code[1])
  448. {
  449. index = 0;
  450. }
  451. else
  452. {
  453. rt_printf("plc_db_soe:ev_code err!\r\n");
  454. return;
  455. }
  456. // 滤波前的值
  457. if(v)
  458. {
  459. g_di_db[db_index].value0 |= 1<<index;
  460. }
  461. else
  462. {
  463. g_di_db[db_index].value0 &= ~(1<<index);
  464. }
  465. // 滤波后的值
  466. // 双点标准定义中,分位在bit0,合位在bit1.在转发点表中合位在前,分位在后
  467. // 所以移位必须取反一下。
  468. if(g_di_db_table[db_index].is_inv[!index])
  469. {
  470. v = !v;
  471. }
  472. if(v)
  473. {
  474. g_di_db[db_index].value1 |= (1<<index);
  475. }
  476. else
  477. {
  478. g_di_db[db_index].value1 &= ~(1<<index);
  479. }
  480. #if 0
  481. rt_printf("db_init:db=%d,index=%d,is_inv=%d,v0=%d,v1=%d\r\n",
  482. db_index,index,
  483. g_di_db_table[db_index].is_inv[!index],
  484. g_di_db[db_index].value0,
  485. g_di_db[db_index].value1);
  486. #endif
  487. return;
  488. }
  489. void plc_db_soe(EVENT_STRUCT *ev)
  490. {
  491. int index,db_index;
  492. u8 slot,no;
  493. slot = (ev->ev_code>>8);
  494. no = ev->ev_code&0xff;
  495. // 得到检查逻辑点索引
  496. index = plc_yx2index(g_di_st[slot][no].owner,g_di_st[slot][no].type);
  497. if(index < 0)
  498. {
  499. return;
  500. }
  501. // 检查双点索引
  502. db_index = g_lp[index].db_index;
  503. if(db_index < 0)
  504. {
  505. return;
  506. }
  507. // 双点第一次变位,记录时标
  508. if (g_di_db[db_index].bChange == 0)
  509. {
  510. g_di_db[db_index].ts = ev->ts;
  511. g_di_db[db_index].bChange = 1;
  512. }
  513. // 每次变位都重新获取超时起点和双点的值
  514. g_di_db[db_index].us0 = ustimer_get_origin();
  515. if(ev->ev_code == g_di_db[db_index].ev_code[0])
  516. {
  517. index = 1;
  518. }
  519. else if(ev->ev_code == g_di_db[db_index].ev_code[1])
  520. {
  521. index = 0;
  522. }
  523. else
  524. {
  525. rt_printf("plc_db_soe:ev_code err!\r\n");
  526. return;
  527. }
  528. if(ev->ev_value)
  529. {
  530. g_di_db[db_index].value0 |= 1<<index;
  531. }
  532. else
  533. {
  534. g_di_db[db_index].value0 &= ~(1<<index);
  535. }
  536. return;
  537. }
  538. // 双点滤波处理,得到滤波后的值
  539. static void plc_db_scan(void)
  540. {
  541. int i,value;
  542. uint32_t flags;
  543. for(i=0; i<g_table_head->di_db_num; i++)
  544. {
  545. if (g_di_db[i].bChange)
  546. {
  547. // 屏蔽中断的情况下检查超时,防止超时和value不对应。
  548. value = -1;
  549. rt_irq_save(flags);
  550. if(ustimer_get_duration(g_di_db[i].us0) >= g_di_db[i].timeout)
  551. {
  552. value = g_di_db[i].value0;
  553. }
  554. rt_irq_restore(flags);
  555. if(value!= -1)
  556. {
  557. g_di_db[i].bChange = 0;
  558. if(g_di_db_table[i].is_inv[0])
  559. {
  560. value ^= 2;
  561. }
  562. if(g_di_db_table[i].is_inv[1])
  563. {
  564. value ^= 1;
  565. }
  566. // 如果和旧值相等,说明信号已返回,不应送SOE。
  567. if(value != g_di_db[i].value1)
  568. {
  569. soe_record_dpi(i,value,&g_di_db[i].ts);
  570. g_di_db[i].value1 = value;
  571. }
  572. }
  573. }
  574. }
  575. return;
  576. }
  577. int plc_scan(int is_rec)
  578. {
  579. static s32 r[64];
  580. u16 *p,i,rp;
  581. // 双点扫描
  582. plc_db_scan();
  583. // PLC扫描
  584. for(i=0;i<g_plc_num;i++)
  585. {
  586. p = g_plc[i].exp;
  587. rp = 0;
  588. while(*p)
  589. {
  590. // 操作数,直接压栈
  591. if(((*p)&LP_TYPE) != LP_TYPE_PLC_OPT)
  592. {
  593. r[rp++] = plc_get_input(*p);
  594. }
  595. // 运算符,出栈计算,结果压栈
  596. else
  597. {
  598. switch(*p)
  599. {
  600. case PLC_LOGIC_NOT:
  601. r[rp-1] = (~r[rp-1]) & 0x01;
  602. break;
  603. case PLC_LOGIC_AND:
  604. r[rp-2] = r[rp-1] & r[rp-2];
  605. rp--;
  606. break;
  607. case PLC_LOGIC_OR:
  608. r[rp-2] = r[rp-1] | r[rp-2];
  609. rp--;
  610. break;
  611. case PLC_LOGIC_XOR:
  612. r[rp-2] = r[rp-1] ^ r[rp-2];
  613. rp--;
  614. break;
  615. default:
  616. return -1;
  617. }
  618. }
  619. p++;
  620. }
  621. // 全部计算完毕,rp应该等1.
  622. if(rp != 1)
  623. {
  624. rt_err_set(ERR_CODE_PLC,0);
  625. rt_printf("plc_scan:i=%d,rp=%d\r\n",i,rp);
  626. }
  627. if(g_plc[i].result != r[rp -1])
  628. {
  629. g_plc[i].result = r[rp -1];
  630. // 开出
  631. if(g_plc[i].do_index)
  632. {
  633. int type;
  634. if(g_plc[i].result)
  635. {
  636. type = SW_DO_TYPE_ON;
  637. soe_record_opt(EV_PLC_HZ,((g_plc[i].do_owner<<8)|g_plc[i].do_index));
  638. }
  639. else
  640. {
  641. type = SW_DO_TYPE_OFF;
  642. soe_record_opt(EV_PLC_TZ,((g_plc[i].do_owner<<8)|g_plc[i].do_index));
  643. }
  644. if(g_plc[i].do_owner == 0)
  645. {
  646. sw_do_pub(g_plc[i].do_index-1,type);
  647. }
  648. else
  649. {
  650. sw_do(g_plc[i].do_owner-1,g_plc[i].do_index-1,type);
  651. }
  652. }
  653. // 需要送主站
  654. if(g_plc[i].cp && is_rec)
  655. {
  656. u8 value = g_plc[i].result ? 1:0;
  657. soe_record_plc(i,value,g_plc[i].flag);
  658. }
  659. }
  660. }
  661. return 0;
  662. }
  663. /*------------------------------ 内部函数 -------------------------------------
  664. 内部函数以下划线‘_’开头,不需要检查参数的合法性.
  665. */
  666. /*------------------------------ 测试函数 -------------------------------------
  667. 一个实体文件必须带一个本模块的测试函数来进行单元测试,如果的确不方便在本模块中
  668. 进行单元测试,必须在此注明实际的测试位置(例如在哪个实体文件中使用哪个测试函数).
  669. */
  670. int plc_lp_printf(void)
  671. {
  672. int i,begin[5];
  673. begin[0] = 0;
  674. begin[1] = PUB_DI_NUM;
  675. begin[2] = PUB_DI_NUM_ALL;
  676. begin[3] = PUB_DI_NUM_ALL + SW_DI_NUM*SWITCH_NUM_MAX;
  677. begin[4] = PUB_DI_NUM_ALL + SW_DI_NUM*SWITCH_NUM_MAX + EV_SW_NUM*SWITCH_NUM_MAX;
  678. rt_printf("\r\n");
  679. for (i=0; i<LP_NUM; i++)
  680. {
  681. if(g_lp[i].cp == 0 && g_lp[i].db_index == -1)
  682. {
  683. continue;
  684. }
  685. rt_printf("%04d:通讯点:0x%04x, 双点索引:%02d, ", i,g_lp[i].cp,g_lp[i].db_index);
  686. // 公共实点
  687. if (i>= begin[0] && i<begin[1])
  688. {
  689. rt_printf("资源点:%s\r\n", g_pub_di_name[i]);
  690. }
  691. // 公共虚点
  692. else if (i>= begin[1] && i<begin[2])
  693. {
  694. rt_printf("资源点:%s\r\n", tAllSOE[(i-begin[1])+EV_SW_NUM].strName);
  695. }
  696. // 开关实点搜集
  697. else if (i>= begin[2] && i<begin[3])
  698. {
  699. rt_printf("资源点:开关%02d%s\r\n",(i-begin[2])/SW_DI_NUM,g_sw_di_name[(i-begin[2])%SW_DI_NUM]);
  700. }
  701. // 开关虚点搜集
  702. else if (i>= begin[3] && i<begin[4])
  703. {
  704. rt_printf("资源点:开关%02d%s\r\n", (i-begin[3])/EV_SW_NUM,tAllSOE[(i-begin[3])%EV_SW_NUM].strName);
  705. }
  706. }
  707. return 0;
  708. }
  709. int plc_info_printf(void)
  710. {
  711. u16 *p,i;
  712. rt_printf("\r\n可编程逻辑表(num=%d):\r\n",g_plc_num);
  713. for(i=0;i<g_plc_num;i++)
  714. {
  715. p = g_plc[i].exp;
  716. rt_printf("PLC%02d:地址=0x%04x,结果=%d,开出归属=%d,开出索引=%d.\r\n",
  717. i,g_plc[i].cp,g_plc[i].result,g_plc[i].do_owner,g_plc[i].do_index);
  718. rt_printf("EXP%02d:",i);
  719. while(*p)
  720. {
  721. // 操作数
  722. if((*p&LP_TYPE) != LP_TYPE_PLC_OPT)
  723. {
  724. rt_printf("%04x,",*p);
  725. }
  726. // 运算符
  727. else
  728. {
  729. switch(*p)
  730. {
  731. case PLC_LOGIC_NOT:
  732. rt_printf("~,");
  733. break;
  734. case PLC_LOGIC_AND:
  735. rt_printf("&,");
  736. break;
  737. case PLC_LOGIC_OR:
  738. rt_printf("|,");
  739. break;
  740. case PLC_LOGIC_XOR:
  741. rt_printf("^,");
  742. break;
  743. default:
  744. return -1;
  745. }
  746. }
  747. p++;
  748. }
  749. rt_printf("\r\n\r\n");
  750. }
  751. // 双点信息
  752. rt_printf("\r\n双点信息(num=%d):\r\n",g_table_head->di_db_num);
  753. rt_printf("timeout\tevcode0\tevcode1\tbChange\tv0\tv1\r\n");
  754. for(i=0;i<g_table_head->di_db_num;i++)
  755. {
  756. struct di_db *db;
  757. db = & g_di_db[i];
  758. rt_printf("%d\t%04x\t%04x\t%d\t%d\t%d\r\n",db->timeout,db->ev_code[0],db->ev_code[1],db->bChange,db->value0,db->value1);
  759. }
  760. return 0;
  761. }
  762. /*------------------------------ 文件结束 -------------------------------------
  763. */