protect.c 67 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311
  1. /******************************************************************************
  2. 版权所有:
  3. 文件名称: protect.c
  4. 文件版本: 01.01
  5. 创建作者: xxxxxx
  6. 创建日期: 2012-03-28
  7. 功能说明: 保护整组处理过程
  8. 其它说明:
  9. 修改记录:
  10. */
  11. /*------------------------------- 头文件 --------------------------------------
  12. */
  13. #include "head.h"
  14. /*------------------------------- 宏定义 --------------------------------------
  15. */
  16. #define SW_I_NUM 4 // 突变量算法仅涉及三相相电流及零序电流
  17. /*------------------------------ 类型结构 -------------------------------------
  18. */
  19. /*------------------------------ 全局变量 -------------------------------------
  20. */
  21. struct protect_stu g_protect; // 保护整组处理过程
  22. TRELAY_T g_tRelay[SWITCH_NUM_MAX];
  23. u16 wIQdCnt[SWITCH_NUM_MAX][SW_I_NUM]; // 突变量启动计数器
  24. static DWORD dTAfterFault = 0;
  25. /*------------------------------ 函数声明 -------------------------------------
  26. */
  27. static int _protect_amp_qd(u32 dStep);
  28. static int _protect_gzcl_init(void);
  29. static int _protect_gzcl_process(void);
  30. static int _protect_zzfg_check(u32 dStep);
  31. static int _protect_zzfg(void);
  32. static int _protect_sw_tz(u32 dStep);
  33. static int _protect_sw_hz(u32 dStep);
  34. static int _protect_alarm(void);
  35. static int _protect_rmt_sw(u32 dStep);
  36. static int _protect_sfsh_clr(void);
  37. static bool _protect_check_fault(int sw);
  38. /*------------------------------ 外部函数 -------------------------------------
  39. 外部函数供其它实体文件引用,必须仔细检查传入参数的合法性.
  40. */
  41. /******************************************************************************
  42. 函数名称: protect_init
  43. 函数版本: 01.01
  44. 创建作者: xxxxxx
  45. 创建日期: 2015-05-13
  46. 函数说明: 保护相关标志初始化
  47. 参数说明: 无
  48. 返回值: 成功返回0.
  49. 修改记录:
  50. */
  51. int protect_init(void)
  52. {
  53. int i;
  54. // 初始化保护整组相关标志
  55. memset(&g_protect, 0, sizeof(g_protect));
  56. memset(&wIQdCnt, 0, sizeof(wIQdCnt));
  57. // 初始化保护相关标志
  58. for (i = 0; i < SWITCH_NUM_MAX; i++)
  59. {
  60. memset(&g_tRelay[i], 0, sizeof(TRELAY_T));
  61. }
  62. hcbs_init();
  63. #ifdef FUN_JDXX
  64. jdxx_init();
  65. #endif
  66. return 0;
  67. }
  68. /******************************************************************************
  69. 函数名称: _protect_sg_all
  70. 函数版本: 01.01
  71. 创建作者: xxxxxx
  72. 创建日期: 2015-7-20
  73. 函数说明: 事故总巡检
  74. 参数说明: 无
  75. 返回值: 成功返回0.
  76. 修改记录:
  77. */
  78. int _protect_sg_all(void)
  79. {
  80. bool ret = 0;
  81. ret = check_fault();
  82. if (ret)
  83. {
  84. if (soe_check(FAULT_ALL) == false)
  85. {
  86. soe_record_ev(FAULT_ALL, 1, 0, 0, 0);
  87. }
  88. }
  89. else
  90. {
  91. if (soe_check(FAULT_ALL) == true)
  92. {
  93. soe_record_ev(FAULT_ALL, 0, 0, 0, 0);
  94. }
  95. }
  96. return 0;
  97. }
  98. #ifdef FUNC_DRIVE_JY
  99. static void clear_func_drive(u32 dStep)
  100. {
  101. int sw = 0;
  102. if (!gb_drive.b_drive_on)
  103. {
  104. ResetTR(&gb_drive.tDriveUa1Time);
  105. ResetTR(&gb_drive.tDriveUa2Time);
  106. ResetTR(&gb_drive.tDriveU0Time);
  107. ResetTR(&gb_drive.tDriveITime);
  108. ResetTR(&gb_drive.tDriveI0Time);
  109. if (gb_drive.b_drive_on_check && soe_check(EV_HZFAIL + sw * EV_SW_NUM))
  110. { // 分/合闸拒动时10S后重新分/合闸
  111. RunTR(&gb_drive.tDriveAgainTime, true, dStep);
  112. if (gb_drive.tDriveAgainTime.boolTrip)
  113. {
  114. if (soe_check(EV_DRIVE_ADD_HZ + sw * EV_SW_NUM) == false) // 传动补发合闸
  115. {
  116. soe_record_ev(EV_DRIVE_ADD_HZ + sw * EV_SW_NUM, 1, 0, 0, 0);
  117. }
  118. if (soe_check(EV_DRIVE_ADD_HZ + sw * EV_SW_NUM) == true) // 传动补发合闸返回
  119. {
  120. soe_record_ev(EV_DRIVE_ADD_HZ + sw * EV_SW_NUM, 0, 0, 0, 0);
  121. }
  122. gb_drive.b_drive_on_check = false;
  123. gb_drive.b_drive_success_again = true;
  124. if (BH_ALL_EN(sw))
  125. gb_drive.b_bh_reclose = true;
  126. else if (FA_ALL_EN(sw))
  127. gb_drive.b_fa_reclose = true;
  128. }
  129. }
  130. return;
  131. }
  132. RunTR(&gb_drive.tDriveUa1Time, true, dStep);
  133. RunTR(&gb_drive.tDriveUa2Time, true, dStep);
  134. RunTR(&gb_drive.tDriveU0Time, true, dStep);
  135. RunTR(&gb_drive.tDriveITime, true, dStep);
  136. RunTR(&gb_drive.tDriveI0Time, true, dStep);
  137. ResetTR(&gb_drive.tDriveAgainTime);
  138. if (FA_ALL_EN(sw))
  139. {
  140. if (gb_drive.tDriveUa1Time.boolTrip && gb_drive.tDriveUa2Time.boolTrip && gb_drive.tDriveU0Time.boolTrip && gb_drive.tDriveITime.boolTrip && gb_drive.tDriveI0Time.boolTrip)
  141. {
  142. gb_drive.b_drive_on = false;
  143. }
  144. }
  145. }
  146. #endif
  147. #ifdef FUNC_DRIVE
  148. // 退出不停电传动功能软压板处理
  149. void quit_drive(void)
  150. {
  151. SET_VALUE *parBuf; // 定义定值查看及整定时的buf
  152. if (gb_drive.bQuit)
  153. {
  154. gb_drive.b_drive_on = false;
  155. gb_drive.b_drive_soe = false;
  156. gb_drive.b_drive_process = false;
  157. #ifdef FUNC_DRIVE_PULSE
  158. gb_drive.b_unset_pulse = true;
  159. MakeRunPara(false, false); // 恢复合分闸脉冲原来的值
  160. MakeRunSet(false); // 加入先设置一次所有定值的处理,避免提前return导致没恢复原定值内容
  161. #endif
  162. parBuf = rt_malloc(PUB_SET_NUMBER * 4);
  163. if (!parBuf)
  164. {
  165. rt_free(parBuf);
  166. rt_printf("\r\n退出不停电传动功能软压板时分配缓冲区出错!\r\n");
  167. return;
  168. }
  169. // 不停电传动投入软压板置0
  170. gb_drive.bQuit = false;
  171. if (!ReadPara((void *)parBuf, EEP_SET_ADDR + m_runsection * SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]))
  172. {
  173. rt_err_set(ERR_CODE_SET, 0);
  174. GetDefPara((void *)parBuf, PUB_SET_NUMBER, &tSwSetTable[0]);
  175. }
  176. parBuf[SET_XDL_YB + gb_drive.sw * SW_SET_NUMBER].ff = 0;
  177. if (SavePara((void *)parBuf, EEP_SET_ADDR + m_runsection * SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]))
  178. {
  179. soe_record_opt(EV_YBSET_OK, 0);
  180. MakeRunSet(false);
  181. rt_err_clr(ERR_CODE_SET, 0);
  182. }
  183. rt_free(parBuf);
  184. }
  185. }
  186. #endif
  187. #ifdef OCI_XB_0MS
  188. static void xb_cal_0ms(int sw, u32 dStep)
  189. {
  190. int ui_begin;
  191. bool bxbbs, bxb;
  192. bool bIazx, bIbzx, bIczx;
  193. bool bQDD, bTrip;
  194. int oc;
  195. // 电流启动
  196. ui_begin = UI_SW_INDEX_BEGIN(sw);
  197. bxb = pRunSet->tSwSet[sw].bTT_bh_xbbs;
  198. for (oc = BH_GL1; oc <= BH_GL3; oc++)
  199. {
  200. TOC_T *poc = &g_tRelay[sw].tOC[oc];
  201. OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
  202. poc->sta.bFlag.bIaQD = OverRelay(g_ui[ui_begin + SW_AC_IA].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIaQD);
  203. poc->sta.bFlag.bIbQD = OverRelay(g_ui[ui_begin + SW_AC_IB].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIbQD);
  204. poc->sta.bFlag.bIcQD = OverRelay(g_ui[ui_begin + SW_AC_IC].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIcQD);
  205. bIazx = CalDir_A(sw, poc->sta.bFlag.bIaQD && pSet->bDir, pRunSet->tSwSet[sw].bTT_DIR_Inv); // 方向计算
  206. bIbzx = CalDir_B(sw, poc->sta.bFlag.bIbQD && pSet->bDir, pRunSet->tSwSet[sw].bTT_DIR_Inv);
  207. bIczx = CalDir_C(sw, poc->sta.bFlag.bIcQD && pSet->bDir, pRunSet->tSwSet[sw].bTT_DIR_Inv);
  208. poc->sta.bFlag.bIaxb = bxb && XBCalc(sw, SW_AC_IA, pRunSet->tSwSet[sw].d_bh_xbcoe, poc->sta.bFlag.bIaQD);
  209. poc->sta.bFlag.bIbxb = bxb && XBCalc(sw, SW_AC_IB, pRunSet->tSwSet[sw].d_bh_xbcoe, poc->sta.bFlag.bIbQD);
  210. poc->sta.bFlag.bIcxb = bxb && XBCalc(sw, SW_AC_IC, pRunSet->tSwSet[sw].d_bh_xbcoe, poc->sta.bFlag.bIcQD);
  211. bQDD = poc->sta.bFlag.bIaQD || poc->sta.bFlag.bIbQD || poc->sta.bFlag.bIcQD;
  212. bxbbs = (poc->sta.bFlag.bIaxb || poc->sta.bFlag.bIbxb || poc->sta.bFlag.bIcxb); // 谐波闭锁
  213. if (BH_ALL_EN(sw))
  214. {
  215. poc->sta.bFlag.bXBbs = (BH_ALL_EN(sw) && (pSet->bTz || pSet->bGj) && bQDD) && bxbbs;
  216. if (oc == BH_GL1)
  217. xb_bs_soe(g_protect.sw, dStep);
  218. }
  219. }
  220. }
  221. #endif
  222. void yc_refresh_en(int sw)
  223. {
  224. TRELAY_T *pR = &g_tRelay[sw];
  225. int ui_begin;
  226. DWORD Ia, Ib, Ic;
  227. DWORD I0;
  228. ui_begin = UI_SW_INDEX_BEGIN(sw);
  229. Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
  230. Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
  231. Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
  232. I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
  233. if (pR->bYcRefresh.bAGl)
  234. {
  235. pR->bYcRefresh.bAGl = false;
  236. g_sw_pub.ac_in[PUB_AC_YC9] = Ia;
  237. }
  238. if (pR->bYcRefresh.bBGl)
  239. {
  240. pR->bYcRefresh.bBGl = false;
  241. g_sw_pub.ac_in[PUB_AC_YC10] = Ib;
  242. }
  243. if (pR->bYcRefresh.bCGl)
  244. {
  245. pR->bYcRefresh.bCGl = false;
  246. g_sw_pub.ac_in[PUB_AC_YC11] = Ic;
  247. }
  248. if (pR->bYcRefresh.bLx)
  249. {
  250. pR->bYcRefresh.bLx = false;
  251. g_sw_pub.ac_in[PUB_AC_YC12] = I0;
  252. }
  253. if (g_run_stu.button_on)
  254. {
  255. int i = 0;
  256. g_run_stu.button_on = false;
  257. for (i = PUB_AC_YC9; i <= PUB_AC_YC12; i++)
  258. {
  259. g_sw_pub.ac_in[i] = 0;
  260. }
  261. }
  262. }
  263. /******************************************************************************
  264. 函数名称: protect_polling
  265. 函数版本: 01.01
  266. 创建作者: xxxxxx
  267. 创建日期: 2015-05-13
  268. 函数说明: 保护5ms巡检
  269. 参数说明: 无
  270. 返回值: 成功返回0.
  271. 修改记录:
  272. */
  273. int protect_polling(void)
  274. {
  275. u64 us0;
  276. u64 dTDelta; // 5ms巡检时间片
  277. // 首次进入初始化
  278. if (!g_protect.update)
  279. {
  280. g_protect.t_rcd_bh = dTCounter;
  281. g_protect.update = 1;
  282. return 0;
  283. }
  284. // 取得5ms巡检的时间间隔
  285. dTDelta = dTCounter - g_protect.t_rcd_bh;
  286. g_protect.t_rcd_bh = dTCounter;
  287. // 计算全波FFT
  288. us0 = ustimer_get_origin();
  289. sw_cal_protect();
  290. rt_stat_other_in(1, ustimer_get_duration(us0) / USTIMER_US);
  291. // 定值有修改,重新初始化
  292. if (bRunSetModify)
  293. {
  294. ProtectRelayInit1();
  295. bRunSetModify = 0;
  296. }
  297. #ifdef FUNC_DRIVE_JY
  298. clear_func_drive(dTDelta);
  299. #endif
  300. // 内部状态识别
  301. run_status_check(dTDelta);
  302. if (rt_err_count())
  303. return -1; // 系统异常,退出保护处理
  304. // 公共轮巡类保护
  305. {
  306. Pro_vol(dTDelta); // 电压告警逻辑
  307. #ifdef XDL_ZT // 小电流接地
  308. xdl_protect(dTDelta); // 小电流接地保护
  309. #endif
  310. PT_Check(dTDelta);
  311. FDL_Check(dTDelta);
  312. hcbs_dataset();
  313. }
  314. // 开关类保护
  315. for (g_protect.sw = 0; g_protect.sw < g_sw_num; g_protect.sw++)
  316. {
  317. TRELAY_T *pR = &g_tRelay[g_protect.sw];
  318. _protect_rmt_sw(dTDelta); // 遥控器,其手分或手合标志在其他保护逻辑中有使用,故放在最开始
  319. XBCalc_goc(g_protect.sw); // goose 谐波计算:处理标志:谐波闭锁动作
  320. // 电流轮巡类
  321. Pro_over_i(g_protect.sw, dTDelta, BH_OVI_ZZ, EV_DLZZ); // 电流重载
  322. Pro_over_i(g_protect.sw, dTDelta, BH_OVI_GZ, EV_DLGZ); // 电流过载
  323. Pro_over_i(g_protect.sw, dTDelta, BH_OVI, EV_DLYX); // 电流越限
  324. Pro_over_i0(g_protect.sw, dTDelta, BH_OVI0, EV_I0YX); // 零序电流越限
  325. #ifdef FUN_JDXX
  326. jdxx_pro(g_protect.sw, dTDelta);
  327. #endif
  328. // 电压轮巡类
  329. // Pro_U0Tz(g_protect.sw,dTDelta);
  330. // FA_OverU0Tz(g_protect.sw,dTDelta); // 合后接地故障
  331. // FA_lostvotTz(g_protect.sw,dTDelta); // 失压分闸
  332. Pro_TQHz(g_protect.sw, dTDelta); // 合环
  333. Pro_TQBS(g_protect.sw, dTDelta); // 手动闭锁
  334. Pro_3U0(g_protect.sw, dTDelta);
  335. vol_DYJL(g_protect.sw, dTDelta);
  336. vol_PLJL(g_protect.sw, dTDelta);
  337. fag_bh(g_protect.sw, dTDelta);
  338. Pro_hzbs(g_protect.sw, dTDelta);
  339. // 其他轮巡类
  340. AutoReclose(g_protect.sw, dTDelta); // 重合闸保护逻辑
  341. // 分段、联络就地馈线自动化逻辑,完成独立存在,不需要进入故障处理过程
  342. FA_Run(dTDelta);
  343. #ifdef CUSTOMIZE_BZT // 备自投
  344. bzt_process(g_protect.sw, dTDelta);
  345. #endif
  346. #ifdef GD_AREA_ZHONGSHAN_2020
  347. fag_oc_acc(g_protect.sw, dTDelta);
  348. #endif
  349. sw_op_fail(dTDelta);
  350. // 保护合闸
  351. _protect_sw_hz(dTDelta);
  352. #ifdef OCI_XB_0MS
  353. // 谐波闭锁判断放到循环中,实时判断,解决过流1段时间为0、谐波闭锁后一直幅值启动-整组复归的问题
  354. xb_cal_0ms(g_protect.sw, dTDelta);
  355. #endif
  356. // 幅值启动判别
  357. if (!pR->zqd)
  358. {
  359. _protect_amp_qd(dTDelta);
  360. }
  361. #ifdef FUNC_DRIVE
  362. if (gb_drive.b_drive_on)
  363. {
  364. // 保护跳合闸处理
  365. _protect_sw_tz(dTDelta);
  366. return 0;
  367. }
  368. #endif
  369. // 故障处理流程
  370. if (pR->zqd)
  371. {
  372. switch (pR->gz_process)
  373. {
  374. // 保护处理初始化
  375. case CXLC_BHIN:
  376. _protect_gzcl_init();
  377. break;
  378. // 保护处理
  379. case CXLC_BHCL:
  380. _protect_gzcl_process();
  381. break;
  382. // 整组复归
  383. case CXLC_ZZFG:
  384. _protect_zzfg();
  385. break;
  386. default:
  387. watchdog_reset_cpu(51);
  388. break;
  389. }
  390. }
  391. yc_refresh_en(g_protect.sw);
  392. _protect_alarm(); // 异常告警类逻辑
  393. _protect_sfsh_clr(); // 清除手分、手合标志
  394. }
  395. // 保护巡检完毕,检查事故总
  396. _protect_sg_all();
  397. rt_stat_other_in(2, ustimer_get_duration(us0) / USTIMER_US);
  398. return 0;
  399. }
  400. /******************************************************************************
  401. 函数名称: protect_tbl_qd
  402. 函数版本: 01.01
  403. 创建作者: xxxxxx
  404. 创建日期: 2015-05-13
  405. 函数说明: 保护突变量启动
  406. 参数说明: 无
  407. 返回值: 成功返回0.
  408. 修改记录:
  409. */
  410. int protect_tbl_qd(void)
  411. {
  412. short pnSam[3] = {0};
  413. long laaa;
  414. DWORD daaa;
  415. int i;
  416. u32 sw;
  417. int caulp = g_adc_dots_index;
  418. for (sw = 0; sw < g_sw_num; sw++)
  419. {
  420. TRELAY_T *pR = &g_tRelay[sw];
  421. // 保护已启动,直接返回
  422. if (pR->zqd)
  423. {
  424. continue;
  425. }
  426. // 保护未启动,获取故障的第一个点时刻,作为故障启动时刻,+1是因为
  427. if ((wIQdCnt[sw][SW_AC_IA] == 0) && (wIQdCnt[sw][SW_AC_IB] == 0) && (wIQdCnt[sw][SW_AC_IC] == 0) && (wIQdCnt[sw][SW_AC_I0] == 0))
  428. {
  429. pR->t_rcd_qd = dTCounter + 1;
  430. pR->us_tbl = ustimer_get_origin();
  431. pR->tblqd = 0;
  432. }
  433. else
  434. {
  435. if (!pR->tblqd)
  436. {
  437. pR->tblqd = 1;
  438. pR->tbldz = 0;
  439. pR->tblzzdz = 0;
  440. }
  441. }
  442. // 保护未起动、突变量启动判断
  443. for (i = 0; i < SW_I_NUM; i++)
  444. {
  445. // 如果索引通道不存在,不需计算
  446. if (g_ui[UI_SW_INDEX(sw, i)].chn_index == CFG_ADC_CHANNEL_ZERO)
  447. {
  448. continue;
  449. }
  450. // 取出连续三周波的同一对应点
  451. pnSam[0] = g_adc_dots[g_ui[UI_SW_INDEX(sw, i)].chn_index][(caulp - 1) & SAMLENGTH];
  452. pnSam[1] = g_adc_dots[g_ui[UI_SW_INDEX(sw, i)].chn_index][(caulp - SAMFREQ - 1) & SAMLENGTH];
  453. pnSam[2] = g_adc_dots[g_ui[UI_SW_INDEX(sw, i)].chn_index][(caulp - 2 * SAMFREQ - 1) & SAMLENGTH];
  454. // 计算突变量并取绝对值,i(k)-2*i(k-N)+i(K-2N)
  455. laaa = (pnSam[0] - pnSam[1] * 2 + pnSam[2]);
  456. if (laaa < 0)
  457. {
  458. daaa = -laaa; //
  459. }
  460. else
  461. {
  462. daaa = laaa;
  463. }
  464. // 检查是否超过突变量门槛,且需满足3次,即对应相电流突变量满足要求
  465. if (daaa > pRunSet->dTBLValue[sw])
  466. {
  467. wIQdCnt[sw][i] += 2;
  468. if (wIQdCnt[sw][i] >= TBLQDDSMK)
  469. {
  470. pR->uBHQD.bFlag.bTBQD = true;
  471. rt_printf("protect_tbl_qd:i=%d,daaa=%d,dTBLValue=%d.\r\n", i, daaa, pRunSet->dTBLValue[sw]);
  472. break;
  473. }
  474. }
  475. else
  476. {
  477. if (wIQdCnt[sw][i] >= 1)
  478. {
  479. wIQdCnt[sw][i]--;
  480. }
  481. }
  482. }
  483. if (pR->uBHQD.bFlag.bTBQD)
  484. {
  485. // 进入故障流程:故障初始化
  486. pR->gz_process = CXLC_BHIN;
  487. // 保护总启动标志置位
  488. pR->zqd = 1;
  489. pR->uBHQD.bFlag.bZQD = 1;
  490. // 清除计数
  491. memset(&wIQdCnt[sw], 0, SW_I_NUM * 2);
  492. // 突变量启动时间统计
  493. rt_stat_in(&pR->tbl_stat, ustimer_get_duration(pR->us_tbl) / USTIMER_US);
  494. }
  495. }
  496. return 0;
  497. }
  498. // 速断幅值启动滤波加速,加快幅值启动过程
  499. int protect_amp_qd_js(int sw)
  500. {
  501. int i, v, r;
  502. int ui_begin;
  503. int chn_index;
  504. u32 m2_max;
  505. s16 *dots;
  506. u32 threshold;
  507. // 寻找最大值的相
  508. ui_begin = UI_SW_INDEX_BEGIN(sw);
  509. m2_max = 0;
  510. chn_index = 0;
  511. for (i = 0; i < 3; i++)
  512. {
  513. if (g_ui[ui_begin].m2[0] > m2_max && g_ui[ui_begin].chn_index != CFG_ADC_CHANNEL_ZERO)
  514. {
  515. m2_max = g_ui[ui_begin].m2[0];
  516. chn_index = g_ui[ui_begin].chn_index;
  517. }
  518. ui_begin++;
  519. }
  520. if (m2_max == 0)
  521. {
  522. // 理论上,有采样通道的最大值相不可能不存在
  523. // rt_printf("Pro_SDGJ:m2_max == 0.\r\n");
  524. return 0;
  525. }
  526. // 在最大值的通道里,计算傅立叶的采样点中,检查相位相差180度的两点之和是否大约设定值。
  527. // 条件满足就算存在干扰
  528. dots = adc_fourier_address(chn_index, g_prot_index);
  529. threshold = (u32)rt_round(sqrt_32fix(m2_max) * pRunSet->fFZLBXS / Q16_BASE);
  530. r = 1;
  531. for (i = 0; i < CFG_ADC_DOTS_PER_PERIOD / 2; i++)
  532. {
  533. #if 0
  534. v = *(s16 *)((u32)(dots+i)&CFG_ADC_BUF_MASK);
  535. v+= *(s16 *)((u32)(dots+i+CFG_ADC_DOTS_PER_PERIOD/2)&CFG_ADC_BUF_MASK);
  536. #else
  537. v = *(dots + i);
  538. v += *(dots + i + CFG_ADC_DOTS_PER_PERIOD / 2);
  539. #endif
  540. v = abs(v);
  541. if (v >= threshold) // 如果系数设置为0,则幅值加速没有效果。
  542. {
  543. // 干扰存在
  544. r = 0;
  545. break;
  546. }
  547. }
  548. {
  549. #if 0
  550. float it,iv;
  551. // it = (float)_Mul_Div_U(threshold*Q16_BASE, 256, g_ui[UI_SW_INDEX_BEGIN(sw)].m2_factor_k);
  552. // iv = (float)_Mul_Div_U(v*Q16_BASE, 256, g_ui[UI_SW_INDEX_BEGIN(sw)].m2_factor_k);
  553. it = (float)threshold*256/g_ui[UI_SW_INDEX_BEGIN(sw)].m2_factor_k;
  554. iv = (float)v*256/g_ui[UI_SW_INDEX_BEGIN(sw)].m2_factor_k;
  555. // modify for xxxxxx 当输入量在保护定值的边界值时,会反复打印,导致装置重启
  556. rt_printf("threshold=%d,v=%d,r=%d,m2_max=%d,fFZLBXS=%f.\r\n",threshold,v,r,m2_max,pRunSet->fFZLBXS);
  557. rt_printf("it=%f,iv=%f,iv/it=%f.\r\n",it,iv,iv/it);
  558. #endif
  559. }
  560. return r;
  561. }
  562. // 零序幅值启动滤波加速,加快幅值启动过程
  563. int protect_amp_lx_js(int sw)
  564. {
  565. int i, v, r;
  566. int ui_begin;
  567. int chn_index;
  568. u32 m2_max;
  569. s16 *dots;
  570. u32 threshold;
  571. ui_begin = UI_SW_INDEX(sw, SW_AC_I0);
  572. m2_max = g_ui[ui_begin].m2[0];
  573. chn_index = g_ui[ui_begin].chn_index;
  574. if (m2_max == 0)
  575. {
  576. // 理论上,有采样通道的最大值相不可能不存在
  577. rt_printf("protect_amp_lx_js:m2_max == 0.\r\n");
  578. return 0;
  579. }
  580. // 在最大值的通道里,计算傅立叶的采样点中,检查相位相差180度的两点之和是否大约设定值。
  581. // 条件满足就算存在干扰
  582. dots = adc_fourier_address(chn_index, g_prot_index);
  583. threshold = (u32)rt_round(sqrt_32fix(m2_max) * pRunSet->fFZLBXS / Q16_BASE);
  584. r = 1;
  585. for (i = 0; i < CFG_ADC_DOTS_PER_PERIOD / 2; i++)
  586. {
  587. #if 0
  588. v = *(s16 *)((u32)(dots+i)&CFG_ADC_BUF_MASK);
  589. v+= *(s16 *)((u32)(dots+i+CFG_ADC_DOTS_PER_PERIOD/2)&CFG_ADC_BUF_MASK);
  590. #else
  591. v = *(dots + i);
  592. v += *(dots + i + CFG_ADC_DOTS_PER_PERIOD / 2);
  593. #endif
  594. v = abs(v);
  595. if (v >= threshold) // 如果系数设置为0,则幅值加速没有效果。
  596. {
  597. // 干扰存在
  598. r = 0;
  599. break;
  600. }
  601. }
  602. {
  603. // float it,iv;
  604. // it = (float)_Mul_Div_U(threshold*Q16_BASE, 256, g_ui[UI_SW_INDEX_BEGIN(sw)].m2_factor_k);
  605. // iv = (float)_Mul_Div_U(v*Q16_BASE, 256, g_ui[UI_SW_INDEX_BEGIN(sw)].m2_factor_k);
  606. // it = (float)threshold*256/g_ui[UI_SW_INDEX_BEGIN(sw)].m2_factor_k;
  607. // iv = (float)v*256/g_ui[UI_SW_INDEX_BEGIN(sw)].m2_factor_k;
  608. #if 0 // modify for xxxxxx 当输入量在保护定值的边界值时,会反复打印,导致装置重启
  609. rt_printf("lx_threshold=%d,v=%d,r=%d,m2_max=%d,fFZLBXS=%f.\r\n",threshold,v,r,m2_max,pRunSet->fFZLBXS);
  610. rt_printf("lx_it=%f,iv=%f,iv/it=%f.\r\n",it,iv,iv/it);
  611. #endif
  612. }
  613. return r;
  614. }
  615. /*------------------------------ 内部函数 -------------------------------------
  616. 内部函数以下划线‘_’开头,不需要检查参数的合法性.
  617. */
  618. /******************************************************************************
  619. 函数名称: _protect_amp_qd
  620. 函数版本: 01.01
  621. 创建作者: xxxxxx
  622. 创建日期: 2015-05-13
  623. 函数说明: 保护幅值启动
  624. 参数说明: 无
  625. 返回值: 成功返回0.
  626. 修改记录:
  627. */
  628. static int _protect_amp_qd(u32 dStep)
  629. {
  630. bool bQD;
  631. bool bFZJS = false; // 幅值加速
  632. bool bFZQD = false; // 幅值加速
  633. u32 sw = g_protect.sw;
  634. int i;
  635. TRELAY_T *pR = &g_tRelay[sw];
  636. bQD = 0;
  637. // 过流类启动
  638. for (i = BH_GL1; i <= FA_DLBS; i++)
  639. {
  640. TOC_T *pSW = &g_tRelay[sw].tOC[i];
  641. OC_SET *pSet = &pRunSet->tSwSet[sw].toc[i];
  642. bool bY1 = false, bEn;
  643. if (i <= BH_LXJS)
  644. bEn = BH_ALL_EN(sw);
  645. else
  646. bEn = FA_ALL_EN(sw);
  647. if (bEn && (pSet->bTz || pSet->bGj))
  648. {
  649. if (i == BH_LX1 || i == BH_LX2 || i == BH_LX3 || i == BH_LXJS || i == FA_LX)
  650. {
  651. bY1 = OverRelay(g_ui[UI_SW_INDEX(sw, SW_AC_I0)].m2[0], pSet->dI, pSet->dI, false);
  652. }
  653. else
  654. {
  655. #ifdef OCI_XB_0MS
  656. bY1 = OverRelay(g_sw[sw].m2_max, pSet->dI, pSet->dI, false) && (!pR->tOC[BH_GL1].sta.bFlag.bXBbs);
  657. #else
  658. bY1 = OverRelay(g_sw[sw].m2_max, pSet->dI, pSet->dI, false);
  659. #endif
  660. }
  661. }
  662. // 幅值启动25ms延时
  663. RunTR(&pSW->tFz25ms, bY1, dStep);
  664. bQD |= bY1;
  665. bFZQD |= pSW->tFz25ms.boolTrip;
  666. }
  667. // 反时限启动
  668. {
  669. TSETSW *pSet = &pRunSet->tSwSet[sw];
  670. bool bY1;
  671. if (BH_ALL_EN(sw) && pSet->bTT_FSX)
  672. {
  673. bY1 = OverRelay(g_sw[sw].fz_max, pSet->dIglfsx, pSet->dIglfsx, false);
  674. bFZQD |= bY1;
  675. }
  676. }
  677. // 智能分布式启动判断
  678. {
  679. TGOC_T *poc = &g_tRelay[sw].tgoc;
  680. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  681. bool bY1 = false, bY2 = false;
  682. if (BH_GOOSE_EN(sw))
  683. {
  684. bY1 = OverRelay(g_sw[sw].m2_max, pSet->dIgl, pSet->dIgl, false);
  685. bY2 = OverRelay(g_ui[UI_SW_INDEX(sw, SW_AC_I0)].m2[0], pSet->dIlx, pSet->dIlx, false);
  686. }
  687. // 幅值启动25ms延时
  688. RunTR(&poc->tglFz25ms, bY1, dStep);
  689. RunTR(&poc->tlxFz25ms, bY2, dStep);
  690. bQD |= (bY1 | bY2);
  691. bFZQD |= poc->tglFz25ms.boolTrip;
  692. bFZQD |= poc->tlxFz25ms.boolTrip;
  693. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  694. if (BH_GOOSE_EN(sw))
  695. {
  696. bY1 = OverRelay(g_sw[sw].m2_max, pSet->dIgl2, pSet->dIgl2, false);
  697. }
  698. // 幅值启动25ms延时
  699. RunTR(&poc->tgl2Fz25ms, bY1, dStep);
  700. bQD |= (bY1);
  701. bFZQD |= poc->tgl2Fz25ms.boolTrip;
  702. #endif
  703. }
  704. if (bQD)
  705. {
  706. if (!pR->fzqd)
  707. {
  708. pR->us_fz = ustimer_get_origin();
  709. pR->fzqd = 1;
  710. pR->fzdz = 0;
  711. pR->fzzzdz = 0;
  712. dStep = 0;
  713. }
  714. // 幅值启动加速
  715. bFZJS = protect_amp_qd_js(sw);
  716. bFZJS |= protect_amp_lx_js(sw); // xj
  717. }
  718. else
  719. {
  720. pR->fzqd = 0;
  721. }
  722. pR->uBHQD.bFlag.bFZQD = bFZJS || bFZQD; // 幅值启动加速
  723. // 其他启动,借助幅值启动,进入故障处理流程,以实现录波、出口、整组复归过程
  724. {
  725. bool bY1 = false;
  726. bY1 |= pR->tgoc.sta.bFlag.bgzglQD || pR->tgoc.sta.bFlag.bsdQD || pR->tgoc.sta.bFlag.berrQD || pR->tgoc.sta.bFlag.bextQD || pR->tgoc.sta.bFlag.bllQD;
  727. for (i = 0; i < 8; i++)
  728. {
  729. bY1 |= pR->tFdl[i].sta.bFlag.bTz;
  730. }
  731. #ifdef GD_AREA_ZHONGSHAN_2020
  732. bY1 |= pR->tgoc.tOc[FAG_GL1].sta.bFlag.bQD // 启动
  733. || pR->tgoc.tOc[FAG_GL2].sta.bFlag.bQD || pR->tgoc.tOc[FAG_LX].sta.bFlag.bQD;
  734. #endif
  735. pR->uBHQD.bFlag.bBHQD = bY1 || pR->tCHZ.sta.bFlag.bCHQD // 重合闸
  736. || pR->tU0TZ.uZOV.bFlag.bQD // 合后接地跳闸
  737. || pR->tDYJL.sta.bFlag.bQD // 电压解列
  738. || pR->tPLJL.sta.bFlag.bQD // 频率解列
  739. || pR->tXXTZ.uZOV.bFlag.bQD // 选线跳闸
  740. || pR->tLostVot.uLostVot.bFlag.bQD // 失压分闸
  741. || pR->tOVER_U0TZ.uZOV.bFlag.bTz // 过零序电压跳闸
  742. || pR->tOC[FA_GL].sta.bFlag.bQD || pR->tOC[FA_GL_II].sta.bFlag.bQD || pR->tOC[FA_LX].sta.bFlag.bQD // 零序电流启动
  743. #ifdef FUN_JDXX
  744. || pR->tJD.sta.bFlag.bTz // 接地选线跳
  745. #endif
  746. ;
  747. }
  748. // 幅值启动 + 其他启动 = 总启动
  749. if (pR->uBHQD.bFlag.bFZQD || pR->uBHQD.bFlag.bBHQD)
  750. {
  751. WORD wSubCnt;
  752. #ifdef FUNC_DRIVE
  753. gb_drive.b_drive_on = false;
  754. #endif
  755. // 如果是幅值启动,故障启动时刻倒退25ms
  756. if (pR->uBHQD.bFlag.bFZQD)
  757. {
  758. wSubCnt = T_25ms;
  759. }
  760. else
  761. {
  762. wSubCnt = 0;
  763. }
  764. // 记录故障启动时刻
  765. pR->t_rcd_qd = dTCounter - wSubCnt;
  766. // 进入故障流程:故障初始化
  767. pR->gz_process = CXLC_BHIN;
  768. // 保护总启动标志置位
  769. pR->zqd = 1;
  770. pR->uBHQD.bFlag.bZQD = 1;
  771. // 此时突变量未启动,将故障处理的等待限制取消
  772. if (!pR->uBHQD.bFlag.bTBQD)
  773. {
  774. pR->uBHQD.bFlag.bQD25ms = true;
  775. }
  776. // 幅值启动时间统计
  777. if (pR->uBHQD.bFlag.bFZQD)
  778. {
  779. rt_stat_in(&pR->fz_stat, ustimer_get_duration(pR->us_fz) / USTIMER_US);
  780. }
  781. rt_printf("开关%d辐值启动(bFZJS=%d)\r\n", sw, bFZJS);
  782. }
  783. return 0;
  784. }
  785. /******************************************************************************
  786. 函数名称: _protect_gzcl_init
  787. 函数版本: 01.01
  788. 创建作者: xxxxxx
  789. 创建日期: 2015-05-13
  790. 函数说明: 保护故障处理初始化
  791. 参数说明: 无
  792. 返回值: 成功返回0.
  793. 修改记录:
  794. */
  795. static int _protect_gzcl_init(void)
  796. {
  797. u32 sw = g_protect.sw;
  798. TRELAY_T *pR = &g_tRelay[sw];
  799. int oc;
  800. // 校验保护启动标志:
  801. if (!pR->zqd)
  802. {
  803. watchdog_reset_cpu(52);
  804. }
  805. // 校验定值
  806. if (!CheckRunSet())
  807. {
  808. watchdog_reset_cpu(53);
  809. }
  810. // 初始化标志字与时间继电器
  811. for (oc = 0; oc <= FA_DLBS; oc++)
  812. {
  813. TOC_T *poc = &g_tRelay[sw].tOC[oc];
  814. OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
  815. if (!(oc == FA_GL || oc == FA_LX || oc == FA_GL_II)) // FA逻辑不清所有标志位
  816. {
  817. poc->sta.wfFlag = 0;
  818. }
  819. if (oc != FA_DLBS) // 遮断返回时间需设置长一点,防止故障量跌落太快,闭锁不住
  820. {
  821. InitTR(&poc->tQDTime, pSet->dT, PRO_RET_TIME);
  822. }
  823. else
  824. {
  825. InitTR(&poc->tQDTime, pSet->dT, T_200ms);
  826. }
  827. InitTR(&poc->tQD25ms, T_25ms, 0);
  828. // 突变量启动时预置定时器,因为突变量启动会死等35个采样点的延时,但实际置的延时只是20ms附近,没有过于精准
  829. if (pR->uBHQD.bFlag.bTBQD)
  830. {
  831. PreSetTime(&poc->tQDTime, T_10ms + T_5ms);
  832. PreSetTime(&poc->tQD25ms, T_10ms);
  833. // rt_printf("dT = %d\r\n",dTCounter);
  834. }
  835. #ifdef YX_RESET_TIME
  836. if (pRunSet->dT_ZZFG > tRunPara.dTEventRst)
  837. {
  838. InitTR_Time(&pR->tTZZFG_5S0ms, pRunSet->dT_ZZFG, 0); // 无故障延时5s
  839. }
  840. else
  841. {
  842. InitTR_Time(&pR->tTZZFG_5S0ms, tRunPara.dTEventRst, 0); // 无故障延时5s
  843. }
  844. #else
  845. InitTR_Time(&pR->tTZZFG_5S0ms, pRunSet->dT_ZZFG, 0); // 无故障延时5s
  846. #endif
  847. }
  848. // 取得故障启动时刻,以便故障处理流程中,第一次计算的时间片是从故障启动时刻开始
  849. pR->t_rcd_gz = pR->t_rcd_qd;
  850. // 提前打开启动继电器,以节省硬件耗用时间
  851. sw_do(sw, SW_DO_BHT, SW_DO_TYPE_SELECT_ON);
  852. // 录波:保护启动
  853. // 20160918:目前策略,启动不录波,动作时再录波
  854. // rcd_start(sw,RECORD_WAVE_TYPE_QD, RECORD_LEN_TZQD);
  855. // 进入故障流程:故障处理
  856. if (pR->gz_process == CXLC_BHIN)
  857. {
  858. pR->gz_process = CXLC_BHCL;
  859. }
  860. else
  861. {
  862. watchdog_reset_cpu(54);
  863. }
  864. // 巡检类保护,逻辑已经判断,如果延时已到达,可在此快速出口
  865. _protect_sw_tz(0);
  866. return 0;
  867. }
  868. /******************************************************************************
  869. 函数名称: _protect_gzcl_process
  870. 函数版本: 01.01
  871. 创建作者: xxxxxx
  872. 创建日期: 2015-05-13
  873. 函数说明: 保护故障处理
  874. 参数说明: 无
  875. 返回值: 成功返回0.
  876. 修改记录:
  877. */
  878. static int _protect_gzcl_process(void)
  879. {
  880. // static DWORD dTAfterFault=0;
  881. u32 dTGZDelta; // 5ms故障巡检时间片
  882. u32 sw = g_protect.sw;
  883. TRELAY_T *pR = &g_tRelay[sw];
  884. u32 tmpstep;
  885. // 校验流程
  886. if (pR->gz_process != CXLC_BHCL)
  887. {
  888. watchdog_reset_cpu(55);
  889. }
  890. // 突变量启动36采样点之后才进入故障处理,否则返回.
  891. dTAfterFault = dTCounter - pR->t_rcd_qd;
  892. if (dTAfterFault >= 24 && dTAfterFault < 36)
  893. {
  894. #ifdef CPU_FUXI
  895. return 0;
  896. #else
  897. tmpstep = dTCounter;
  898. do
  899. {
  900. dTAfterFault = dTCounter - pR->t_rcd_qd;
  901. } while (dTAfterFault < 36);
  902. // 等待36点满后,重新计算一下全部的傅式值
  903. sw_cal_protect();
  904. GOC_dir_check(sw, dTCounter - tmpstep); // 重新计算一下故障信息
  905. pR->uBHQD.bFlag.bQD25ms = true;
  906. #endif
  907. }
  908. #ifdef CPU_FUXI
  909. else if (dTAfterFault >= 36)
  910. {
  911. dTAfterFault = 36;
  912. pR->uBHQD.bFlag.bQD25ms = true;
  913. }
  914. #endif
  915. // 更新故障处理的时间片
  916. dTGZDelta = dTCounter - pR->t_rcd_gz;
  917. pR->t_rcd_gz = dTCounter;
  918. // 保护逻辑
  919. if (pR->uBHQD.bFlag.bQD25ms)
  920. {
  921. Pro_BSTZ(sw, dTGZDelta, BH_DLBS, EV_BSTZ);
  922. Pro_OC(sw, dTGZDelta, BH_GL1, EV_GL1TZ);
  923. Pro_OC(sw, dTGZDelta, BH_GL2, EV_GL2TZ);
  924. Pro_OC(sw, dTGZDelta, BH_GL3, EV_GL3TZ);
  925. Pro_LX(sw, dTGZDelta, BH_LX1, EV_LX1TZ);
  926. Pro_LX(sw, dTGZDelta, BH_LX2, EV_LX2TZ);
  927. Pro_LX(sw, dTGZDelta, BH_LX3, EV_LX3TZ);
  928. Pro_Accheck(sw, dTGZDelta, BH_GLJS, EV_GLJS);
  929. Pro_Accheck(sw, dTGZDelta, BH_LXJS, EV_LXJS);
  930. // Pro_Accheck(sw,dTGZDelta,FA_GL,EV_FA_GL_TZ);
  931. // Pro_Accheck(sw,dTGZDelta,FA_LX,EV_FA_LX_TZ);
  932. fag_oc_gl(sw, dTGZDelta);
  933. fag_oc_lx(sw, dTGZDelta);
  934. fsxGL(sw, dTGZDelta); // 反时限过流
  935. }
  936. // 保护跳合闸处理
  937. _protect_sw_tz(dTGZDelta);
  938. // 保护动作时间统计
  939. if (_protect_check_fault(sw))
  940. {
  941. if ((!pR->tbldz) && pR->tblqd)
  942. {
  943. rt_stat_in(&pR->tbldz_stat, ustimer_get_duration(pR->us_tbl) / USTIMER_US);
  944. pR->tbldz = 1;
  945. pR->tblqd = 0;
  946. }
  947. else if ((!pR->fzdz) && pR->fzqd)
  948. {
  949. rt_stat_in(&pR->fzdz_stat, ustimer_get_duration(pR->us_fz) / USTIMER_US);
  950. pR->fzdz = 1;
  951. pR->fzqd = 0;
  952. }
  953. }
  954. // 等待保护返回,转入整组复归流程
  955. _protect_zzfg_check(dTGZDelta);
  956. return 0;
  957. }
  958. /******************************************************************************
  959. 函数名称: _protect_gzcl_zzfg
  960. 函数版本: 01.01
  961. 创建作者: xxxxxx
  962. 创建日期: 2015-05-13
  963. 函数说明: 保护故障整组复归检查
  964. 参数说明: 无
  965. 返回值: 成功返回0.
  966. 修改记录:
  967. */
  968. static int _protect_zzfg_check(u32 dStep)
  969. {
  970. bool bQD, bQDFH;
  971. u32 sw = g_protect.sw;
  972. TRELAY_T *pR = &g_tRelay[sw];
  973. bool bY1 = false;
  974. int i;
  975. for (i = 0; i <= FA_DLBS; i++)
  976. {
  977. bY1 |= (pR->tOC[i].sta.bFlag.bQD || pR->tOC[i].sta.bFlag.bXBbs || pR->tOC[i].sta.bFlag.bTz || pR->tOC[i].sta.bFlag.bGj);
  978. }
  979. for (i = 0; i < 8; i++)
  980. {
  981. bY1 |= pR->tFdl[i].sta.bFlag.bTz;
  982. }
  983. #ifdef GD_AREA_ZHONGSHAN_2020
  984. bY1 |= pR->tgoc.tOc[FAG_GL1].sta.bFlag.bQD // 复归
  985. || pR->tgoc.tOc[FAG_GL2].sta.bFlag.bQD || pR->tgoc.tOc[FAG_LX].sta.bFlag.bQD;
  986. #endif
  987. bY1 |= pR->uGLFSX.bFlag.bFXQD;
  988. bY1 |= pR->tgoc.sta.bFlag.bglQD
  989. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  990. || pR->tgoc.sta.bFlag.bgl2QD
  991. #endif
  992. || pR->tgoc.sta.bFlag.blxQD || pR->tgoc.sta.bFlag.bgzglQD || pR->tgoc.sta.bFlag.bsdQD || pR->tgoc.sta.bFlag.berrQD || pR->tgoc.sta.bFlag.bextQD || pR->tgoc.sta.bFlag.bllQD;
  993. // 检查保护是否返回
  994. bQD = (bY1 || pR->tU0TZ.uZOV.bFlag.bQD // 合后接地保护启动
  995. || pR->tDYJL.sta.bFlag.bQD || pR->tPLJL.sta.bFlag.bQD || pR->tXXTZ.uZOV.bFlag.bQD // 选线跳闸
  996. //||pR->tCHZ.sta.bFlag.bQDFG // 重合闸保护启动202004
  997. || pR->tCHZ.sta.bFlag.bCHQD // 重合闸保护启动
  998. || pR->tLostVot.uLostVot.bFlag.bQD // 失压分闸保护启动
  999. || pR->tTQHz.uTQHz.bFlag.bQD // 合环保护启动
  1000. || pR->tTQHz.uTQHz.bFlag.bLock // 合环闭锁启动
  1001. || pR->tOVER_U0TZ.uZOV.bFlag.bTz // 过零序电压跳闸
  1002. #ifdef FUN_JDXX
  1003. || pR->tJD.sta.bFlag.bTz // 接地选线跳
  1004. #endif
  1005. );
  1006. // 所有保护返回后,等待5S进入整组复归流程
  1007. RunTR(&pR->tTZZFG_5S0ms, !bQD, dStep);
  1008. bQDFH = pR->tTZZFG_5S0ms.boolTrip;
  1009. pR->uBHQD.bFlag.bZZFG = bQDFH;
  1010. if (pR->uBHQD.bFlag.bZZFG && (pR->gz_process == CXLC_BHCL))
  1011. {
  1012. pR->gz_process = CXLC_ZZFG;
  1013. #ifdef CPU_FUXI
  1014. dTAfterFault = 0;
  1015. #endif
  1016. }
  1017. return 0;
  1018. }
  1019. /******************************************************************************
  1020. 函数名称: _protect_zzfg
  1021. 函数版本: 01.01
  1022. 创建作者: xxxxxx
  1023. 创建日期: 2015-05-13
  1024. 函数说明: 保护整组复归
  1025. 参数说明: 无
  1026. 返回值: 成功返回0.
  1027. 修改记录:
  1028. */
  1029. static int _protect_zzfg(void)
  1030. {
  1031. u32 sw = g_protect.sw;
  1032. TRELAY_T *pR = &g_tRelay[sw];
  1033. int oc;
  1034. for (oc = 0; oc <= FA_DLBS; oc++)
  1035. {
  1036. TOC_T *poc = &pR->tOC[oc]; // 过流保护相关
  1037. poc->sta.wfFlag = 0;
  1038. ResetTR(&poc->tQDTime);
  1039. ResetTR(&poc->tQD25ms);
  1040. ResetTR(&poc->tFz25ms);
  1041. #ifdef YX_RESET_TIME
  1042. ResetTR(&poc->tGjEvRstTime);
  1043. ResetTR(&poc->tTzEvRstTime);
  1044. #endif
  1045. }
  1046. ResetTR(&pR->tgoc.tglFz25ms);
  1047. ResetTR(&pR->tgoc.tlxFz25ms);
  1048. // 重合闸标志复归,定时器复归
  1049. if (soe_check(EV_GOOSE_QC_QD + sw * EV_SW_NUM) == true) // 故障隔离启动
  1050. {
  1051. soe_record_ev(EV_GOOSE_QC_QD + sw * EV_SW_NUM, 0, 0, 0, 0);
  1052. }
  1053. if (soe_check(EV_GOOSE_QC_FAIL + sw * EV_SW_NUM) == true) // 故障切除失败
  1054. {
  1055. soe_record_ev(EV_GOOSE_QC_FAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1056. }
  1057. if (soe_check(EV_GOOSE_QC_OK + sw * EV_SW_NUM) == true) // 故障切除成功
  1058. {
  1059. soe_record_ev(EV_GOOSE_QC_OK + sw * EV_SW_NUM, 0, 0, 0, 0);
  1060. }
  1061. if (soe_check(EV_GOOSE_GL_QD + sw * EV_SW_NUM) == true) // 故障隔离启动
  1062. {
  1063. soe_record_ev(EV_GOOSE_GL_QD + sw * EV_SW_NUM, 0, 0, 0, 0);
  1064. }
  1065. if (soe_check(EV_GOOSE_GL_FAIL + sw * EV_SW_NUM) == true) // 故障隔离失败
  1066. {
  1067. soe_record_ev(EV_GOOSE_GL_FAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1068. }
  1069. if (soe_check(EV_GOOSE_GL_OK + sw * EV_SW_NUM) == true) // 故障隔离成功
  1070. {
  1071. soe_record_ev(EV_GOOSE_GL_OK + sw * EV_SW_NUM, 0, 0, 0, 0);
  1072. }
  1073. if (soe_check(EV_GOOSE_HZ_OK + sw * EV_SW_NUM) == true) // 故障切除成功
  1074. {
  1075. soe_record_ev(EV_GOOSE_HZ_OK + sw * EV_SW_NUM, 0, 0, 0, 0);
  1076. }
  1077. if (soe_check(EV_GOOSE_HZ_FAIL + sw * EV_SW_NUM) == true) // 故障切除成功
  1078. {
  1079. soe_record_ev(EV_GOOSE_HZ_FAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1080. }
  1081. // if(soe_check(EV_GOOSE_LL_UNOK+sw*EV_SW_NUM)==true) // 自转电条件不满足返回
  1082. //{
  1083. // soe_record_ev( EV_GOOSE_LL_UNOK+sw*EV_SW_NUM,1, 0,0,0 );
  1084. // }
  1085. // 202004
  1086. // pR->tCHZ.sta.wfFlag=0;
  1087. // pR->tCHZ.wAR_ActTimes=0;
  1088. // ResetTR(&pR->tCHZ.tTCHJD_HJS);
  1089. // 失压分闸标志复归,定时器复归
  1090. if (pR->tLostVot.uLostVot.bFlag.bTz)
  1091. pR->tLostVot.uLostVot.wfFlag = 0; // 只出口后才清标志
  1092. // ResetTR(&pR->tLostVot.tLostVotTime); //Z计时器禁止复归
  1093. // 合环标志复归,定时器复归
  1094. pR->tTQHz.uTQHz.wfFlag = 0;
  1095. // 跳闸失败标志复归,定时器复归
  1096. ResetTR(&pR->tTripfail_2s);
  1097. pR->uBHDZ.bFlag.bTZSB = 0;
  1098. // 启动标志复归
  1099. pR->uBHQD.dfBHQDLogic = 0;
  1100. // 整组复归定时器复归
  1101. ResetTR(&pR->tTZZFG_5S0ms);
  1102. // 保护总启动标志复归
  1103. pR->zqd = 0;
  1104. // 复归保护启动标志后,再复归启动继电器
  1105. // 如果有就地或远方的分、合闸操作,在继电器出口处会强制打开启动继电器
  1106. sw_do(sw, SW_DO_BHT, SW_DO_TYPE_SELECT_OFF);
  1107. // 流程处理
  1108. if (pR->gz_process == CXLC_ZZFG)
  1109. {
  1110. pR->gz_process = CXLC_ZCCL;
  1111. }
  1112. else
  1113. {
  1114. watchdog_reset_cpu(57);
  1115. }
  1116. pR->tblqd = 0;
  1117. pR->tbldz = 0;
  1118. pR->tblzzdz = 0;
  1119. pR->fzqd = 0;
  1120. pR->fzdz = 0;
  1121. pR->fzzzdz = 0;
  1122. rt_printf("开关%d整组复归\r\n", sw);
  1123. return 0;
  1124. }
  1125. /******************************************************************************
  1126. 函数名称: _protect_sw_tz
  1127. 函数版本: 01.01
  1128. 创建作者: xxxxxx
  1129. 创建日期: 2015-05-13
  1130. 函数说明: 保护跳闸
  1131. 参数说明: 无
  1132. 返回值: 成功返回0.
  1133. 修改记录:
  1134. */
  1135. static int _protect_sw_tz(u32 dStep)
  1136. {
  1137. bool bCur;
  1138. bool bTz = false;
  1139. u32 sw = g_protect.sw;
  1140. TRELAY_T *pR = &g_tRelay[sw];
  1141. int i;
  1142. u8 bh_bs = g_tRelay[sw].tOC[BH_DLBS].sta.bFlag.bQD;
  1143. #ifdef FUNC_DRIVE
  1144. if (!gb_drive.b_drive_on)
  1145. #endif
  1146. {
  1147. // 校验流程
  1148. if (pR->gz_process != CXLC_BHCL)
  1149. {
  1150. watchdog_reset_cpu(56);
  1151. }
  1152. }
  1153. // 保护动作跳闸情况检测
  1154. for (i = BH_GL1; i <= FA_LX; i++)
  1155. {
  1156. bTz |= pR->tOC[i].sta.bFlag.bTz;
  1157. }
  1158. #ifdef GD_AREA_ZHONGSHAN_2020
  1159. for (i = FAG_GL1; i <= FAG_LX; i++)
  1160. {
  1161. bTz |= pR->tgoc.tOc[i].sta.bFlag.bTz; // 跳闸
  1162. }
  1163. #endif
  1164. for (i = 0; i < 8; i++)
  1165. {
  1166. bTz |= pR->tFdl[i].sta.bFlag.bTz;
  1167. if (pR->tFdl[i].sta.bFlag.bTz)
  1168. pR->tCHZ.sta.bFlag.bCDWC = false; // 重合闸放电
  1169. }
  1170. bTz |= pR->uGLFSX.bFlag.bFXDZ;
  1171. bTz |= (pR->tU0TZ.uZOV.bFlag.bTz // 合后接地保护动作
  1172. || pR->tDYJL.sta.bFlag.bTz || pR->tPLJL.sta.bFlag.bTz || pR->tOVER_U0TZ.uZOV.bFlag.bTz // 过零序电压跳闸
  1173. || pR->tLostVot.uLostVot.bFlag.bTz // 失压分闸
  1174. #ifdef FUN_JDXX
  1175. || pR->tJD.sta.bFlag.bTz // 接地选线跳
  1176. #endif
  1177. );
  1178. #ifdef FUNC_DRIVE
  1179. if (gb_drive.b_drive_on && pR->tSWST.uSWST.bFlag.bDIHW && gb_drive.b_fa_drive)
  1180. {
  1181. RunTR(&gb_drive.tQDTime_fz, true, dStep);
  1182. }
  1183. else
  1184. {
  1185. ResetTR(&gb_drive.tQDTime_fz);
  1186. }
  1187. #endif
  1188. // 无分闸闭锁
  1189. pR->uBHDZ.bFlag.bBHTrip = bTz && (!pR->bBSTZ) && !bh_bs;
  1190. // 跳闸脉冲最短保持40ms
  1191. // DTUv4此处为100ms need to confirm
  1192. RunTR(&pR->tTrip_BHT40MS, pR->uBHDZ.bFlag.bBHTrip, dStep);
  1193. pR->uBHDZ.bFlag.bBHT = pR->tTrip_BHT40MS.boolTrip || pR->uBHDZ.bFlag.bBHTrip;
  1194. #ifdef SELF_OPEN_RELEASE
  1195. // 保护跳保持继电器 默认保持200ms,用于更准确的区分是保护跳
  1196. RunTR(&pR->tTripBHTKeep, pR->uBHDZ.bFlag.bBHT, dStep);
  1197. pR->uBHDZ.bFlag.bBHTKeep = pR->tTripBHTKeep.boolTrip || pR->uBHDZ.bFlag.bBHT;
  1198. #endif
  1199. // 跳闸失败检查: 跳闸后持续2S有流或合位
  1200. bCur = ((!pR->tSWST.uSWST.bFlag.bSXWL) || pR->tSWST.uSWST.bFlag.bHZWZ);
  1201. RunTR(&pR->tTripfail_hz, pR->uBHDZ.bFlag.bBHT, dStep); // 跳闸失败,不与跳闸脉冲关联,防止失压分闸,跳闸脉冲较短,无法判位置
  1202. RunTR(&pR->tTripfail_2s, (pR->tTripfail_hz.boolTrip && bCur), dStep); // 跳闸失败,不与跳闸脉冲关联,防止失压分闸,跳闸脉冲较短,无法判位置
  1203. if (pR->tTripfail_2s.boolTrip)
  1204. {
  1205. pR->uBHDZ.bFlag.bTZSB = 1;
  1206. }
  1207. else
  1208. {
  1209. pR->uBHDZ.bFlag.bTZSB = 0;
  1210. }
  1211. // 有跳闸信号时,可由大电流闭锁不动作,
  1212. // 无闭锁时,需保证一次动作信号仅一次出口
  1213. #ifdef FUNC_DRIVE
  1214. if (!bTz)
  1215. { // 避免传动延时分闸时间设为0时无法分闸出口
  1216. pR->uBHDZ.bFlag.bTZOut = 0;
  1217. }
  1218. if (bTz || gb_drive.tQDTime_fz.boolTrip)
  1219. #else
  1220. if (bTz)
  1221. #endif
  1222. {
  1223. if ((!pR->uBHDZ.bFlag.bTZOut) && (!pR->bBSTZ) && KZ_OUT_ALL_EN(sw) && g_run_stu.kz_out_tt)
  1224. {
  1225. sw_do(sw, SW_DO_BHH, SW_DO_TYPE_OFF);
  1226. sw_do(sw, SW_DO_YKH, SW_DO_TYPE_OFF);
  1227. sw_do(sw, SW_DO_BHDZ, SW_DO_TYPE_ON);
  1228. sw_do(sw, SW_DO_BHT, SW_DO_TYPE_ON);
  1229. sw_do(sw, SW_DO_BHT, SW_DO_TYPE_ON);
  1230. #ifdef CUSTOMIZE_BZT // 备自投
  1231. bzt_oc_sw_off(sw);
  1232. #endif
  1233. #ifdef FUNC_DRIVE
  1234. if (gb_drive.tQDTime_fz.boolTrip)
  1235. {
  1236. pR->uBHDZ.bFlag.bTZOut = 0; // 传动结束后应返回原正常逻辑,不应影响原功能运行
  1237. ResetTR(&gb_drive.tQDTime_fz);
  1238. }
  1239. else
  1240. #endif
  1241. {
  1242. pR->uBHDZ.bFlag.bTZOut = 1;
  1243. }
  1244. tRunPara.sysData.wSwTzCount++;
  1245. rt_printf("开关%d保护跳闸\r\n", sw);
  1246. }
  1247. }
  1248. else
  1249. {
  1250. pR->uBHDZ.bFlag.bTZOut = 0;
  1251. }
  1252. return 0;
  1253. }
  1254. /******************************************************************************
  1255. 函数名称: _protect_sw_hz
  1256. 函数版本: 01.01
  1257. 创建作者: xxxxxx
  1258. 创建日期: 2015-05-13
  1259. 函数说明: 保护合闸
  1260. 参数说明: 无
  1261. 返回值: 成功返回0.
  1262. 修改记录:
  1263. */
  1264. static int _protect_sw_hz(u32 dStep)
  1265. {
  1266. bool bHz = false;
  1267. int sw = g_protect.sw;
  1268. TRELAY_T *pR = &g_tRelay[sw];
  1269. // 保护动作合闸情况检测
  1270. bHz = (pR->tCHZ.sta.bFlag.bHz // 重合闸
  1271. || pR->tSDHZ.uSdhz_S.bFlag.bHz // 分段开关上电合闸
  1272. || pR->tSDHZ.uSdhz_L.bFlag.bHz); // 联络开关上电合闸
  1273. #ifdef FUNC_DRIVE
  1274. if (gb_drive.b_drive_on && pR->tSWST.uSWST.bFlag.bDITW && gb_drive.b_fa_drive)
  1275. {
  1276. RunTR(&gb_drive.tQDTime_hz, true, dStep);
  1277. }
  1278. else
  1279. {
  1280. ResetTR(&gb_drive.tQDTime_hz);
  1281. }
  1282. #endif
  1283. pR->uBHDZ.bFlag.bBHH = bHz;
  1284. // 有合闸信号时,需保证一次动作信号仅一次出口
  1285. #ifdef FUNC_DRIVE
  1286. if (!bHz)
  1287. { // 避免传动延时分闸时间设为0时无法分闸出口
  1288. pR->uBHDZ.bFlag.bHZOut = 0;
  1289. }
  1290. if (bHz || gb_drive.tQDTime_hz.boolTrip)
  1291. #else
  1292. if (bHz)
  1293. #endif
  1294. {
  1295. if (!pR->uBHDZ.bFlag.bHZOut && !pR->bBSHZ && KZ_OUT_ALL_EN(sw))
  1296. {
  1297. sw_do(sw, SW_DO_BHH, SW_DO_TYPE_ON);
  1298. #ifdef FUNC_DRIVE
  1299. if (gb_drive.b_drive_on)
  1300. {
  1301. gb_drive.b_drive_on = false;
  1302. ResetTR(&gb_drive.tQDTime_hz);
  1303. }
  1304. #endif
  1305. pR->uBHDZ.bFlag.bHZOut = 1;
  1306. tRunPara.sysData.wSwHzCount++;
  1307. // rt_printf("开关%d保护合闸\r\n", sw);
  1308. }
  1309. }
  1310. else
  1311. {
  1312. pR->uBHDZ.bFlag.bHZOut = 0;
  1313. }
  1314. return 0;
  1315. }
  1316. void sw_op_fail(DWORD dStep)
  1317. {
  1318. int sw = g_protect.sw;
  1319. TRELAY_T *pR = &g_tRelay[sw];
  1320. TSDHZ_T *pSW = &pR->tSDHZ;
  1321. #ifdef CUSTOMIZE_BZT // 备自投
  1322. UBZT *uBZT = &pR->tBzt.uBZT;
  1323. #endif
  1324. #if defined SW_FAIL_SINGLE_OUT // 开关拒动发送失灵信号
  1325. static int status = 0;
  1326. #endif
  1327. // 分闸失败检查
  1328. RunTR(&pSW->tTz0ms2s, pR->uRmtSW.bTz_Doing, dStep);
  1329. if (pSW->tTz0ms2s.boolTrip && (pR->run_stu.sw == 2))
  1330. {
  1331. if (soe_check(EV_TZFAIL + sw * EV_SW_NUM) == false)
  1332. soe_record_ev(EV_TZFAIL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1333. if (soe_check(EV_SWFAIL + sw * EV_SW_NUM) == false)
  1334. soe_record_ev(EV_SWFAIL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1335. #ifdef FUNC_DRIVE
  1336. if (gb_drive.b_drive_soe)
  1337. {
  1338. if (soe_check(EV_DRIVE_TZ_FAIL + sw * EV_SW_NUM) == false)
  1339. {
  1340. soe_record_ev(EV_DRIVE_TZ_FAIL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1341. }
  1342. gb_drive.b_drive_on = false;
  1343. gb_drive.b_drive_soe = false;
  1344. }
  1345. #endif
  1346. pR->uRmtSW.bTz_Doing = 0;
  1347. #ifdef CUSTOMIZE_BZT // 备自投
  1348. if (uBZT->bBZT.bZF && uBZT->bBZT.bSYFZ)
  1349. {
  1350. uBZT->bBZT.bSYFZ = 0;
  1351. pR->tSWST.uSWST.bFlag.bBZTSY = 0;
  1352. }
  1353. #endif
  1354. ResetTR(&pSW->tTz0ms2s);
  1355. #ifdef FUNC_DRIVE_JY
  1356. if (gb_drive.b_drive_on)
  1357. {
  1358. gb_drive.b_drive_on = false;
  1359. if (soe_check(EV_DRIVE_TZ_FAIL + sw * EV_SW_NUM) == false) // 不停电传动开关拒分
  1360. {
  1361. soe_record_ev(EV_DRIVE_TZ_FAIL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1362. }
  1363. if (soe_check(EV_DRIVE_END + sw * EV_SW_NUM) == false) // 传动结束
  1364. {
  1365. soe_record_ev(EV_DRIVE_END + sw * EV_SW_NUM, 1, 0, 0, 0);
  1366. }
  1367. if (soe_check(EV_DRIVE_END + sw * EV_SW_NUM) == true) // 传动结束返回
  1368. {
  1369. soe_record_ev(EV_DRIVE_END + sw * EV_SW_NUM, 0, 0, 0, 0);
  1370. }
  1371. }
  1372. gb_drive.b_drive_success = false;
  1373. #endif
  1374. }
  1375. #ifdef SOE_RECORD_DELAY
  1376. // 分闸动作check
  1377. if (soe_check(EV_TZFAIL + sw * EV_SW_NUM) == true) // 分闸拒动:清空延时SOE QUEUE
  1378. {
  1379. if (g_soe_queue.fzsoe_wait_flag)
  1380. memset((char *)&g_soe_queue.delay_fzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_fzsoe_tab[] buffer
  1381. g_soe_queue.fzsoe_wait_flag = false;
  1382. g_soe_queue.fzsoe_delay_flag = false;
  1383. g_soe_queue.delay_fzsoe_count = 0;
  1384. }
  1385. else if (g_soe_queue.fzsoe_wait_flag && (pR->run_stu.sw == 1)) // 启动转录: 分闸SOE QUEUE非空 && 分位(分闸成功)
  1386. {
  1387. int i;
  1388. g_soe_queue.fzsoe_delay_flag = true;
  1389. g_soe_queue.fzsoe_wait_flag = false;
  1390. for (i = 0; i < DELAY_SOE_MAX; i++)
  1391. {
  1392. if (g_soe_queue.delay_fzsoe_tab[i].value == 0)
  1393. break; // null
  1394. g_soe_queue.delay_fzsoe_count = i;
  1395. // if((g_soe_queue.delay_fzsoe_tab[i].code%EV_SW_NUM)==EV_HA_FZ) //重置手分时间
  1396. // clk_time_get(&g_soe_queue.delay_fzsoe_tab[i].ts);
  1397. soe_record_ev(g_soe_queue.delay_fzsoe_tab[i].code, g_soe_queue.delay_fzsoe_tab[i].value, g_soe_queue.delay_fzsoe_tab[i].v1, g_soe_queue.delay_fzsoe_tab[i].v2, g_soe_queue.delay_fzsoe_tab[i].v3);
  1398. }
  1399. memset((char *)&g_soe_queue.delay_fzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_soe_tab[] buffer
  1400. g_soe_queue.delay_fzsoe_count = 0;
  1401. g_soe_queue.fzsoe_delay_flag = false;
  1402. }
  1403. #endif
  1404. // 合闸失败检查
  1405. RunTR(&pSW->tHz0ms2s, pR->uRmtSW.bHz_Doing, dStep);
  1406. if (pSW->tHz0ms2s.boolTrip && (pR->run_stu.sw == 1))
  1407. {
  1408. if (soe_check(EV_HZFAIL + sw * EV_SW_NUM) == false)
  1409. soe_record_ev(EV_HZFAIL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1410. if (soe_check(EV_SWFAIL + sw * EV_SW_NUM) == false)
  1411. soe_record_ev(EV_SWFAIL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1412. #ifdef FUNC_DRIVE
  1413. if (gb_drive.b_drive_soe)
  1414. {
  1415. if (soe_check(EV_DRIVE_HZ_FAIL + sw * EV_SW_NUM) == false)
  1416. {
  1417. soe_record_ev(EV_DRIVE_HZ_FAIL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1418. }
  1419. gb_drive.b_drive_on = false;
  1420. gb_drive.b_drive_soe = false;
  1421. }
  1422. #endif
  1423. #ifdef FUNC_DRIVE_JY
  1424. if (gb_drive.b_drive_on || gb_drive.b_drive_success_again)
  1425. {
  1426. if (soe_check(EV_DRIVE_HZ_FAIL + sw * EV_SW_NUM) == false) // 不停电传动开关拒合
  1427. {
  1428. soe_record_ev(EV_DRIVE_HZ_FAIL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1429. }
  1430. if (gb_drive.b_drive_success_again)
  1431. {
  1432. if (soe_check(EV_DRIVE_END + sw * EV_SW_NUM) == false) // 传动结束
  1433. {
  1434. soe_record_ev(EV_DRIVE_END + sw * EV_SW_NUM, 1, 0, 0, 0);
  1435. }
  1436. if (soe_check(EV_DRIVE_END + sw * EV_SW_NUM) == true) // 传动结束返回
  1437. {
  1438. soe_record_ev(EV_DRIVE_END + sw * EV_SW_NUM, 0, 0, 0, 0);
  1439. }
  1440. }
  1441. gb_drive.b_drive_success_again = false;
  1442. gb_drive.b_drive_on = false;
  1443. }
  1444. gb_drive.b_drive_success = false;
  1445. #endif
  1446. if (pSW->uSdhz_L.bFlag.bX_HZEvent)
  1447. {
  1448. #ifndef GD_AREA_ZHONGSHAN_2020 // 中山2020不报分布式恢复失败SOE
  1449. if (soe_check(EV_GOOSE_HZ_FAIL + sw * EV_SW_NUM) == false)
  1450. soe_record_ev(EV_GOOSE_HZ_FAIL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1451. #endif
  1452. }
  1453. pSW->uSdhz_L.bFlag.bX_HZEvent = false;
  1454. pR->uRmtSW.bHz_Doing = 0;
  1455. ResetTR(&pSW->tHz0ms2s);
  1456. }
  1457. #ifdef SOE_RECORD_DELAY
  1458. // 合闸动作check
  1459. if (soe_check(EV_HZFAIL + sw * EV_SW_NUM) == true) // 合闸拒动:清空延时SOE QUEUE
  1460. {
  1461. if (g_soe_queue.hzsoe_wait_flag)
  1462. memset((char *)&g_soe_queue.delay_hzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_hzsoe_tab[] buffer
  1463. g_soe_queue.hzsoe_wait_flag = false;
  1464. g_soe_queue.hzsoe_delay_flag = false;
  1465. g_soe_queue.delay_hzsoe_count = 0;
  1466. }
  1467. else if (g_soe_queue.hzsoe_wait_flag && (pR->run_stu.sw == 2)) // 启动转录: 合闸SOE QUEUE非空 && 合位(合闸成功)
  1468. {
  1469. int i;
  1470. g_soe_queue.hzsoe_delay_flag = true; // 转录标志
  1471. g_soe_queue.hzsoe_wait_flag = false;
  1472. for (i = 0; i < DELAY_SOE_MAX; i++)
  1473. {
  1474. if (g_soe_queue.delay_hzsoe_tab[i].value == 0)
  1475. break; // null
  1476. g_soe_queue.delay_hzsoe_count = i;
  1477. soe_record_ev(g_soe_queue.delay_hzsoe_tab[i].code, g_soe_queue.delay_hzsoe_tab[i].value, g_soe_queue.delay_hzsoe_tab[i].v1, g_soe_queue.delay_hzsoe_tab[i].v2, g_soe_queue.delay_hzsoe_tab[i].v3);
  1478. }
  1479. memset((char *)&g_soe_queue.delay_hzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_soe_tab[] buffer
  1480. g_soe_queue.delay_hzsoe_count = 0;
  1481. g_soe_queue.hzsoe_delay_flag = false;
  1482. }
  1483. #endif
  1484. // 合闸失败返回
  1485. pR->run_stu.hw_change = (pR->run_stu.sw == 1) ? true : false || pR->run_stu.hw_change;
  1486. if (pR->run_stu.hw_change && ((pR->run_stu.sw == 2) ? true : false)) // 开关由分到合
  1487. {
  1488. pR->uRmtSW.bHz_Doing = false;
  1489. pR->run_stu.hw_change = false;
  1490. if (soe_check(EV_HZFAIL + sw * EV_SW_NUM) == true)
  1491. soe_record_ev(EV_HZFAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1492. if (soe_check(EV_SWFAIL + sw * EV_SW_NUM) == true)
  1493. soe_record_ev(EV_SWFAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1494. if (soe_check(EV_GOOSE_HZ_FAIL + sw * EV_SW_NUM) == true)
  1495. soe_record_ev(EV_GOOSE_HZ_FAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1496. #ifdef FUNC_DRIVE
  1497. if (soe_check(EV_DRIVE_HZ_FAIL + sw * EV_SW_NUM) == true)
  1498. {
  1499. soe_record_ev(EV_DRIVE_HZ_FAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1500. }
  1501. #endif
  1502. #ifdef FUNC_DRIVE_JY
  1503. if (gb_drive.b_drive_on_check)
  1504. {
  1505. gb_drive.b_drive_on_check = false;
  1506. }
  1507. if (soe_check(EV_DRIVE_HZ_FAIL + sw * EV_SW_NUM) == true) // 不停电传动开关拒合返回
  1508. {
  1509. soe_record_ev(EV_DRIVE_HZ_FAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1510. }
  1511. if (gb_drive.b_drive_success || gb_drive.b_drive_success_again)
  1512. {
  1513. if (BH_ALL_EN(sw))
  1514. {
  1515. gb_drive.b_drive_on = false;
  1516. }
  1517. if (soe_check(EV_DRIVE_END + sw * EV_SW_NUM) == false) // 传动结束
  1518. {
  1519. soe_record_ev(EV_DRIVE_END + sw * EV_SW_NUM, 1, 0, 0, 0);
  1520. }
  1521. if (soe_check(EV_DRIVE_END + sw * EV_SW_NUM) == true) // 传动结束返回
  1522. {
  1523. soe_record_ev(EV_DRIVE_END + sw * EV_SW_NUM, 0, 0, 0, 0);
  1524. }
  1525. if (soe_check(EV_DRIVE_SUCESS + sw * EV_SW_NUM) == false) // 不停电传动成功
  1526. {
  1527. soe_record_ev(EV_DRIVE_SUCESS + sw * EV_SW_NUM, 1, 0, 0, 0);
  1528. }
  1529. if (soe_check(EV_DRIVE_SUCESS + sw * EV_SW_NUM) == true) // 不停电传动成功返回
  1530. {
  1531. soe_record_ev(EV_DRIVE_SUCESS + sw * EV_SW_NUM, 0, 0, 0, 0);
  1532. }
  1533. gb_drive.b_drive_success = false;
  1534. gb_drive.b_drive_success_again = false;
  1535. }
  1536. #endif
  1537. #ifdef SELF_OPEN_RELEASE
  1538. pR->uRmtSW.bSwTz = false;
  1539. #endif
  1540. #ifdef CUSTOMIZE_BZT // 备自投
  1541. if (uBZT->bBZT.bZF && uBZT->bBZT.bSYFZ)
  1542. {
  1543. uBZT->bBZT.bSYFZ = 0;
  1544. pR->tSWST.uSWST.bFlag.bBZTSY = 0;
  1545. }
  1546. #endif
  1547. }
  1548. // 跳闸失败返回
  1549. pR->run_stu.tw_change = (pR->run_stu.sw == 2) ? true : false || pR->run_stu.tw_change;
  1550. if (pR->run_stu.tw_change && ((pR->run_stu.sw == 1) ? true : false)) // 开关由合到分
  1551. {
  1552. #ifdef SELF_OPEN_RELEASE
  1553. if (!pR->uBHDZ.bFlag.bBHTKeep)
  1554. {
  1555. pR->uRmtSW.bSwTz = true; // 开关拉杆分闸
  1556. }
  1557. #endif
  1558. pR->uRmtSW.bTz_Doing = false;
  1559. pR->run_stu.tw_change = false;
  1560. if (soe_check(EV_TZFAIL + sw * EV_SW_NUM) == true)
  1561. soe_record_ev(EV_TZFAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1562. if (soe_check(EV_SWFAIL + sw * EV_SW_NUM) == true)
  1563. soe_record_ev(EV_SWFAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1564. #ifdef FUNC_DRIVE
  1565. if (soe_check(EV_DRIVE_TZ_FAIL + sw * EV_SW_NUM) == true)
  1566. {
  1567. soe_record_ev(EV_DRIVE_TZ_FAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1568. }
  1569. #endif
  1570. #ifdef CUSTOMIZE_BZT // 备自投
  1571. if (uBZT->bBZT.bZF && uBZT->bBZT.bSYFZ)
  1572. {
  1573. if ((g_sw[sw].do_cfg_index[SW_DO_JX1_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX2_SY] == 0xffff))
  1574. {
  1575. sw_do(sw, SW_DO_JX1_SY, SW_DO_TYPE_ON);
  1576. }
  1577. /*else if((g_sw[sw].do_cfg_index[SW_DO_JX2_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX1_SY] == 0xffff))
  1578. {
  1579. sw_do(sw,SW_DO_JX2_SY,SW_DO_TYPE_ON);
  1580. }*/
  1581. uBZT->bBZT.bSYFZ = 0;
  1582. pR->tSWST.uSWST.bFlag.bBZTSY = 0;
  1583. }
  1584. #endif
  1585. #ifdef FUNC_DRIVE_JY
  1586. if (soe_check(EV_DRIVE_TZ_FAIL + sw * EV_SW_NUM) == true) // 不停电传动开关拒分返回
  1587. {
  1588. soe_record_ev(EV_DRIVE_TZ_FAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1589. }
  1590. #endif
  1591. }
  1592. #if defined SW_FAIL_SINGLE_OUT // 开关拒动发送失灵信号
  1593. if (soe_check(EV_SWFAIL + sw * EV_SW_NUM) == true)
  1594. {
  1595. sw_do(sw, SW_DO_UNSTUCK_SINGLE, SW_DO_TYPE_ON);
  1596. if (status == 0)
  1597. {
  1598. status = 1; // 输出空接点
  1599. // rt_printf("开关拒动失灵信号发送开始\r\n");
  1600. }
  1601. }
  1602. else if ((soe_check(EV_SWFAIL + sw * EV_SW_NUM) == false) && (status == 1))
  1603. {
  1604. sw_do(sw, SW_DO_UNSTUCK_SINGLE, SW_DO_TYPE_OFF);
  1605. status = 0; // 不输出空接点
  1606. // rt_printf("开关拒动失灵信号发送结束\r\n");
  1607. }
  1608. #endif
  1609. #ifdef FUNC_DRIVE
  1610. RunTR(&gb_drive.tQDTime_fz_end, (gb_drive.bTz_Doing && gb_drive.b_drive_process), dStep);
  1611. if (gb_drive.tQDTime_fz_end.boolTrip)
  1612. {
  1613. gb_drive.bTz_Doing = 0;
  1614. }
  1615. RunTR(&gb_drive.tQDTime_hz_end, (gb_drive.bHz_Doing && gb_drive.b_drive_process), dStep);
  1616. if (gb_drive.tQDTime_hz_end.boolTrip)
  1617. {
  1618. gb_drive.bHz_Doing = 0;
  1619. }
  1620. // 分/合闸后延时结束传动
  1621. if (gb_drive.tQDTime_fz_end.boolTrip || gb_drive.tQDTime_hz_end.boolTrip)
  1622. {
  1623. gb_drive.b_drive_on = false;
  1624. gb_drive.b_drive_process = false;
  1625. gb_drive.bQuit = true;
  1626. gb_drive.sw = sw;
  1627. ResetTR(&gb_drive.tQDTime_fz_end);
  1628. ResetTR(&gb_drive.tQDTime_hz_end);
  1629. if (soe_check(EV_DRIVE_BEGIN + sw * EV_SW_NUM) == true)
  1630. {
  1631. soe_record_ev(EV_DRIVE_BEGIN + sw * EV_SW_NUM, 0, 0, 0, 0);
  1632. }
  1633. }
  1634. #endif
  1635. }
  1636. /******************************************************************************
  1637. 函数名称: _alarm_process
  1638. 函数版本: 01.01
  1639. 创建作者: xxxxxx
  1640. 创建日期: 2015-10-23
  1641. 函数说明: 异常告警类逻辑
  1642. 参数说明: 无
  1643. 返回值: 成功返回0.
  1644. 修改记录:
  1645. */
  1646. static int _protect_alarm(void)
  1647. {
  1648. u32 sw = g_protect.sw;
  1649. TRELAY_T *pR = &g_tRelay[sw];
  1650. TSWST *pSW = &pR->tSWST;
  1651. // 弹簧未储能告警
  1652. if (pSW->uSWST.bFlag.bWCN)
  1653. {
  1654. if (soe_check(EV_TH_WCN + sw * EV_SW_NUM) == false)
  1655. {
  1656. soe_record_ev(EV_TH_WCN + sw * EV_SW_NUM, 1, 0, 0, 0);
  1657. }
  1658. }
  1659. else
  1660. {
  1661. if (soe_check(EV_TH_WCN + sw * EV_SW_NUM) == true)
  1662. {
  1663. soe_record_ev(EV_TH_WCN + sw * EV_SW_NUM, 0, 0, 0, 0);
  1664. }
  1665. }
  1666. if (pSW->uSWST.bFlag.bKZHL)
  1667. {
  1668. if (soe_check(EV_KZHL + sw * EV_SW_NUM) == false)
  1669. {
  1670. soe_record_ev(EV_KZHL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1671. }
  1672. }
  1673. else
  1674. {
  1675. if (soe_check(EV_KZHL + sw * EV_SW_NUM) == true)
  1676. {
  1677. soe_record_ev(EV_KZHL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1678. }
  1679. }
  1680. // 跳位有流告警
  1681. if (pSW->uSWST.bFlag.bTWYL && KZ_OUT_ALL_EN(sw))
  1682. {
  1683. if (soe_check(EV_TWYL + sw * EV_SW_NUM) == false)
  1684. {
  1685. soe_record_ev(EV_TWYL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1686. }
  1687. }
  1688. else
  1689. {
  1690. if (soe_check(EV_TWYL + sw * EV_SW_NUM) == true)
  1691. {
  1692. soe_record_ev(EV_TWYL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1693. }
  1694. }
  1695. // 跳闸失败
  1696. if (pR->uBHDZ.bFlag.bTZSB && KZ_OUT_ALL_EN(sw))
  1697. {
  1698. if (soe_check(EV_TZFAIL + sw * EV_SW_NUM) == false)
  1699. {
  1700. soe_record_ev(EV_TZFAIL + sw * EV_SW_NUM, 1, 0, 0, 0);
  1701. }
  1702. }
  1703. else
  1704. {
  1705. if (soe_check(EV_TZFAIL + sw * EV_SW_NUM) == true)
  1706. {
  1707. soe_record_ev(EV_TZFAIL + sw * EV_SW_NUM, 0, 0, 0, 0);
  1708. }
  1709. }
  1710. return 0;
  1711. }
  1712. /**************************************************************************
  1713. 函数名称:_protect_rmt_sw
  1714. 函数版本:1.00
  1715. 作者: mwd
  1716. 创建日期:2007.9.29
  1717. 函数功能说明:开关遥控:遥控器、PDA
  1718. 输入参数:
  1719. 输出参数:
  1720. 返回值:
  1721. 函数扇入清单:
  1722. 日志:
  1723. ***************************************************************************/
  1724. static int _protect_rmt_sw(u32 dStep)
  1725. {
  1726. u32 sw = g_protect.sw;
  1727. URMTSW *pRmtsw = &g_tRelay[sw].uRmtSW;
  1728. RUN_STU_SW *pRunstu = &g_tRelay[sw].run_stu;
  1729. TRELAY_T *pR = &g_tRelay[sw];
  1730. u8 Ycn = !(pR->run_stu.wcn && pRunSet->tSwSet[sw].bTT_WCN); // 已储能
  1731. RunTR(&pR->tMb_yuk_time, g_run_stu.mb_yuk, dStep); // 预置按键取消
  1732. if (pR->tMb_yuk_time.boolTrip)
  1733. g_run_stu.mb_yuk = 0;
  1734. if (((((g_rmt_op.cmd == CMD_HZ) || pRunstu->sw_sh || g_run_stu.mb_hz) && (!g_run_stu.yf) && Ycn) || g_tPDA.bPDAHz || g_tPDA.bMsgHz) && (!fa_bs_hz(sw))) // 有手合信号
  1735. {
  1736. if (pRunSet->tSwSet[sw].btt_gnyb_tqhz)
  1737. {
  1738. pRmtsw->bTQHz = true;
  1739. }
  1740. else if (!pRmtsw->bHandHz)
  1741. {
  1742. pRmtsw->bHandHz = true;
  1743. pRmtsw->bHandHz_fa = true;
  1744. #ifdef CUSTOMIZE_BZT // 备自投
  1745. BZT_ManualOnOffHandle(sw, SW_DO_FD_HZ);
  1746. #endif
  1747. sw_do(sw, SW_DO_YKH, SW_DO_TYPE_ON);
  1748. if (g_rmt_op.cmd == CMD_HZ)
  1749. {
  1750. soe_record_opt(EV_433M_HZ, 1);
  1751. }
  1752. else if (pRunstu->sw_sh)
  1753. {
  1754. soe_record_opt(EV_HAND_HZ, 1);
  1755. }
  1756. else if (g_run_stu.mb_hz)
  1757. {
  1758. soe_record_ev(EV_MB_HZ, 1, 0, 0, 0);
  1759. g_run_stu.mb_hz = 0;
  1760. }
  1761. else if (g_tPDA.bPDAHz)
  1762. {
  1763. soe_record_opt(EV_PDA_HZ, 1);
  1764. }
  1765. else
  1766. {
  1767. soe_record_opt(EV_MSG_HZ, 1);
  1768. }
  1769. }
  1770. // pRmtsw->bTQHz=false; //手合将同期合闸标志清零??
  1771. g_tPDA.bPDAHz = false;
  1772. g_tPDA.bMsgHz = false;
  1773. g_rmt_op.cmd = CMD_NILL;
  1774. }
  1775. #if 0 // 科陆东自V1&V2版本临时测试用, 佛山局用的永磁模块未储能时无法带动继电器,我司用开出5模拟一个该信号
  1776. if(pRunstu->wcn)
  1777. {
  1778. sw_do(sw,SW_RST_SY,SW_DO_TYPE_ON);
  1779. sw_do(sw,SW_RST_SY1,SW_DO_TYPE_OFF);
  1780. }
  1781. else
  1782. {
  1783. sw_do(sw,SW_RST_SY1,SW_DO_TYPE_ON);
  1784. sw_do(sw,SW_RST_SY,SW_DO_TYPE_OFF);
  1785. }
  1786. #else // v3版本储能信号开出
  1787. if (pRunstu->wcn)
  1788. {
  1789. sw_do(sw, SW_DO_CN, SW_DO_TYPE_OFF);
  1790. }
  1791. else
  1792. {
  1793. sw_do(sw, SW_DO_CN, SW_DO_TYPE_ON);
  1794. }
  1795. // rt_printf("pRunstu->wcn=%d \r\n",pRunstu->wcn);
  1796. #endif
  1797. if (((((g_rmt_op.cmd == CMD_FZ) || pRunstu->sw_sf || g_run_stu.mb_fz) && (!g_run_stu.yf)) || g_tPDA.bPDATz || g_tPDA.bMsgTz) && (!pR->bBSTZ)) // 有手跳信号
  1798. {
  1799. if (!pRmtsw->bHandTz)
  1800. {
  1801. pRmtsw->bHandTz = true;
  1802. pRmtsw->bHandTz_fa = true;
  1803. sw_do(sw, SW_DO_BHH, SW_DO_TYPE_OFF);
  1804. #ifdef CUSTOMIZE_BZT // 备自投
  1805. sw_do(sw, SW_DO_FD_FZ, SW_DO_TYPE_ON);
  1806. #endif
  1807. sw_do(sw, SW_DO_BHDZ, SW_DO_TYPE_ON);
  1808. sw_do(sw, SW_DO_BHT, SW_DO_TYPE_ON);
  1809. sw_do(sw, SW_DO_YKT, SW_DO_TYPE_ON);
  1810. if (g_rmt_op.cmd == CMD_FZ)
  1811. {
  1812. soe_record_opt(EV_433M_TZ, 1);
  1813. }
  1814. else if (pRunstu->sw_sf)
  1815. {
  1816. soe_record_opt(EV_HAND_TZ, 1);
  1817. }
  1818. else if (g_run_stu.mb_fz)
  1819. {
  1820. soe_record_ev(EV_MB_TZ, 1, 0, 0, 0);
  1821. g_run_stu.mb_fz = 0;
  1822. }
  1823. else if (g_tPDA.bPDATz)
  1824. {
  1825. soe_record_opt(EV_PDA_TZ, 1);
  1826. }
  1827. else
  1828. {
  1829. soe_record_opt(EV_MSG_TZ, 1);
  1830. }
  1831. }
  1832. g_tPDA.bPDATz = false;
  1833. g_tPDA.bMsgTz = false;
  1834. g_rmt_op.cmd = CMD_NILL;
  1835. }
  1836. // 手持遥控复归 C 信号复归
  1837. if (g_rmt_op.cmd == CMD_FG)
  1838. {
  1839. SignalReset(0, false);
  1840. g_rmt_op.cmd = CMD_NILL;
  1841. rt_printf("遥控器复归信号产生\r\n");
  1842. }
  1843. return 0;
  1844. }
  1845. /******************************************************************************
  1846. 函数名称: _protect_sfsh_clr
  1847. 函数版本: 01.01
  1848. 创建作者: xxxxxx
  1849. 创建日期: 2015-10-23
  1850. 函数说明: 清除手分、手合标志
  1851. 参数说明: 无
  1852. 返回值: 成功返回0.
  1853. 修改记录:
  1854. */
  1855. static int _protect_sfsh_clr(void)
  1856. {
  1857. URMTSW *pRmtsw = &g_tRelay[g_protect.sw].uRmtSW;
  1858. pRmtsw->bHandHz = false;
  1859. pRmtsw->bHandTz = false;
  1860. return 0;
  1861. }
  1862. /******************************************************************************
  1863. 函数名称: _protect_check_fault
  1864. 函数版本: 01.01
  1865. 创建作者: xxxxxx
  1866. 创建日期: 2015-10-23
  1867. 函数说明: 检查保护是否返回
  1868. 参数说明: 无
  1869. 返回值: 成功返回0.
  1870. 修改记录:
  1871. */
  1872. static bool _protect_check_fault(int sw)
  1873. {
  1874. int i;
  1875. TRELAY_T *pR = &g_tRelay[sw];
  1876. bool bY1 = false;
  1877. for (i = BH_GL1; i <= FA_LX; i++)
  1878. {
  1879. bY1 |= (pR->tOC[i].sta.bFlag.bTz || pR->tOC[i].sta.bFlag.bGj);
  1880. }
  1881. for (i = 0; i < 8; i++)
  1882. {
  1883. bY1 |= pR->tFdl[i].sta.bFlag.bTz;
  1884. }
  1885. bY1 |= pR->tgoc.sta.bFlag.bglTz
  1886. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  1887. || pR->tgoc.sta.bFlag.bgl2Tz
  1888. #endif
  1889. || pR->tgoc.sta.bFlag.blxTz || pR->tgoc.sta.bFlag.bgzglTz || pR->tgoc.sta.bFlag.bsdTz || pR->tgoc.sta.bFlag.bextTz || pR->tgoc.sta.bFlag.berrTz || pR->tgoc.sta.bFlag.bllhz;
  1890. bY1 |= pR->uGLFSX.bFlag.bFXDZ;
  1891. bY1 |= (pR->tCHZ.sta.bFlag.bHz || pR->tXXTZ.uZOV.bFlag.bTz || pR->tU0TZ.uZOV.bFlag.bTz || pR->tDYJL.sta.bFlag.bTz || pR->tPLJL.sta.bFlag.bTz || pR->tLostVot.uLostVot.bFlag.bTz || pR->tOVER_U0TZ.uZOV.bFlag.bTz // 过零序电压跳闸
  1892. #ifdef FUN_JDXX
  1893. || pR->tJD.sta.bFlag.bTz // 接地选线跳
  1894. #endif
  1895. );
  1896. if (bY1)
  1897. {
  1898. return true;
  1899. }
  1900. return false;
  1901. }
  1902. /*------------------------------ 测试函数 -------------------------------------
  1903. 一个实体文件必须带一个本模块的测试函数来进行单元测试,如果的确不方便在本模块中
  1904. 进行单元测试,必须在此注明实际的测试位置(例如在哪个实体文件中使用哪个测试函数).
  1905. */
  1906. int protect_stat_reset(void)
  1907. {
  1908. int sw;
  1909. for (sw = 0; sw < SWITCH_NUM_MAX; sw++)
  1910. {
  1911. TRELAY_T *pR = &g_tRelay[sw];
  1912. rt_stat_init(&pR->tbl_stat, "突变量");
  1913. rt_stat_init(&pR->tbldz_stat, "突变量动作");
  1914. rt_stat_init(&pR->tblzzdz_stat, "突变量整组动作");
  1915. rt_stat_init(&pR->fz_stat, "幅值");
  1916. rt_stat_init(&pR->fzdz_stat, "幅值动作");
  1917. rt_stat_init(&pR->fzzzdz_stat, "幅值整组动作");
  1918. }
  1919. return 0;
  1920. }
  1921. int protect_printf_process(void)
  1922. {
  1923. int sw;
  1924. rt_printf("[突变量启动耗时(us):]\r\n");
  1925. rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
  1926. for (sw = 0; sw < g_sw_num; sw++)
  1927. {
  1928. TRELAY_T *pR = &g_tRelay[sw];
  1929. rt_printf("%d\t", sw);
  1930. rt_stat_printf(&pR->tbl_stat);
  1931. }
  1932. rt_printf("\r\n[突变量动作耗时(us):]\r\n");
  1933. rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
  1934. for (sw = 0; sw < g_sw_num; sw++)
  1935. {
  1936. TRELAY_T *pR = &g_tRelay[sw];
  1937. rt_printf("%d\t", sw);
  1938. rt_stat_printf(&pR->tbldz_stat);
  1939. }
  1940. rt_printf("\r\n[突变量整组动作耗时(us):]\r\n");
  1941. rt_printf("[需用分闸继电器输入分位开入,防抖为0s]\r\n");
  1942. rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
  1943. for (sw = 0; sw < g_sw_num; sw++)
  1944. {
  1945. TRELAY_T *pR = &g_tRelay[sw];
  1946. rt_printf("%d\t", sw);
  1947. rt_stat_printf(&pR->tblzzdz_stat);
  1948. }
  1949. rt_printf("\r\n[幅值启动耗时(us):]\r\n");
  1950. rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
  1951. for (sw = 0; sw < g_sw_num; sw++)
  1952. {
  1953. TRELAY_T *pR = &g_tRelay[sw];
  1954. rt_printf("%d\t", sw);
  1955. rt_stat_printf(&pR->fz_stat);
  1956. }
  1957. rt_printf("\r\n[幅值动作耗时(us):]\r\n");
  1958. rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
  1959. for (sw = 0; sw < g_sw_num; sw++)
  1960. {
  1961. TRELAY_T *pR = &g_tRelay[sw];
  1962. rt_printf("%d\t", sw);
  1963. rt_stat_printf(&pR->fzdz_stat);
  1964. }
  1965. rt_printf("\r\n[幅值整组动作耗时(us):]\r\n");
  1966. rt_printf("[需用分闸继电器输入分位开入,防抖为0s]\r\n");
  1967. rt_printf("sw\tname\t\t\tmin\tmax\tavg\tsum\t\tcnt\r\n");
  1968. for (sw = 0; sw < g_sw_num; sw++)
  1969. {
  1970. TRELAY_T *pR = &g_tRelay[sw];
  1971. rt_printf("%d\t", sw);
  1972. rt_stat_printf(&pR->fzzzdz_stat);
  1973. }
  1974. return 0;
  1975. }
  1976. #ifdef YB_AUTO_SELECT
  1977. bool fa_yb_enable(int sw)
  1978. {
  1979. bool bY1 = false;
  1980. if ((short)g_sw[sw].di_cfg_index[SW_DI_FA_TT] != INDEX_INVALLID)
  1981. {
  1982. bY1 = g_tRelay[sw].run_stu.fatt && pRunSet->tSwSet[sw].btt_gnyb_fa; // FA
  1983. }
  1984. else
  1985. {
  1986. bY1 = pRunSet->tSwSet[sw].btt_gnyb_fa; // FA
  1987. }
  1988. return bY1;
  1989. }
  1990. bool goose_yb_enable(int sw)
  1991. {
  1992. bool bY1 = false;
  1993. if ((short)g_sw[sw].di_cfg_index[SW_DI_FA_GOOSE] != INDEX_INVALLID)
  1994. {
  1995. bY1 = g_tRelay[sw].run_stu.fa_g_tt && pRunSet->tSwSet[sw].btt_gnyb_dfa; // 智能分布式把手
  1996. }
  1997. else
  1998. {
  1999. bY1 = pRunSet->tSwSet[sw].btt_gnyb_dfa;
  2000. }
  2001. return bY1;
  2002. }
  2003. bool bh_yb_enable(int sw)
  2004. {
  2005. bool bY1 = false;
  2006. if ((short)g_sw[sw].di_cfg_index[SW_DI_BHTT] != INDEX_INVALLID)
  2007. {
  2008. bY1 = g_tRelay[sw].run_stu.cgbhtt && pRunSet->tSwSet[sw].btt_gnyb_cg; // 保护
  2009. }
  2010. else
  2011. {
  2012. bY1 = pRunSet->tSwSet[sw].btt_gnyb_cg; // 保护
  2013. }
  2014. return bY1;
  2015. }
  2016. #endif
  2017. // #ifdef GD_AREA_ZHONGSHAN_2020 //中山要求通信异常,全系统均异常
  2018. #if defined GD_AREA_ZHONGSHAN_2020 || defined YB_AUTO_SELECT
  2019. bool fa_fun_true(int sw)
  2020. {
  2021. bool bY1 = false, bY2 = false, bY3 = false;
  2022. #ifdef YB_AUTO_SELECT
  2023. if ((short)g_sw[sw].di_cfg_index[SW_DI_FA_GOOSE] != INDEX_INVALLID)
  2024. {
  2025. bY1 = g_tRelay[sw].run_stu.fa_g_tt && pRunSet->tSwSet[sw].btt_gnyb_dfa; // 智能分布式把手
  2026. }
  2027. else
  2028. {
  2029. bY1 = pRunSet->tSwSet[sw].btt_gnyb_dfa;
  2030. }
  2031. if ((short)g_sw[sw].di_cfg_index[SW_DI_BHTT] != INDEX_INVALLID)
  2032. {
  2033. bY2 = g_tRelay[sw].run_stu.cgbhtt && pRunSet->tSwSet[sw].btt_gnyb_cg; // 保护
  2034. }
  2035. else
  2036. {
  2037. bY2 = pRunSet->tSwSet[sw].btt_gnyb_cg; // 保护
  2038. }
  2039. if ((short)g_sw[sw].di_cfg_index[SW_DI_FA_TT] != INDEX_INVALLID)
  2040. {
  2041. bY3 = g_tRelay[sw].run_stu.fatt && pRunSet->tSwSet[sw].btt_gnyb_fa; // FA
  2042. }
  2043. else
  2044. {
  2045. bY3 = pRunSet->tSwSet[sw].btt_gnyb_fa; // FA
  2046. }
  2047. #else
  2048. bY1 = g_tRelay[sw].run_stu.fa_g_tt && pRunSet->tSwSet[sw].btt_gnyb_dfa // 智能分布式把手
  2049. && ((pRunSet->tSwSet[sw].tGocSet.bsw_fz && pRunSet->tSwSet[sw].btt_gnyb_cg && !pRunSet->tSwSet[sw].btt_gnyb_fa) || (!pRunSet->tSwSet[sw].tGocSet.bsw_fz && pRunSet->tSwSet[sw].btt_gnyb_fa && !pRunSet->tSwSet[sw].btt_gnyb_cg));
  2050. bY2 = g_tRelay[sw].run_stu.cgbhtt && pRunSet->tSwSet[sw].btt_gnyb_cg // 保护
  2051. && (!pRunSet->tSwSet[sw].btt_gnyb_fa && !pRunSet->tSwSet[sw].btt_gnyb_dfa);
  2052. bY3 = g_tRelay[sw].run_stu.fatt && pRunSet->tSwSet[sw].btt_gnyb_fa // FA
  2053. && (!pRunSet->tSwSet[sw].btt_gnyb_cg && !pRunSet->tSwSet[sw].btt_gnyb_dfa);
  2054. #endif
  2055. return (bY1 || bY2 || bY3);
  2056. }
  2057. #endif
  2058. /*------------------------------ 文件结束 -------------------------------------
  2059. */