FA_g.c 73 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955
  1. #include "head.h"
  2. #ifdef __IEC61850_GOOSE_FUNC__
  3. #include "app_61850.h"
  4. #endif
  5. #include "goose.h"
  6. int g_bgseEnable;
  7. const struct gse_tbl g_goose_send_tbl[GOOSE_SEND_TBL_NUMBER]=
  8. {
  9. {"节点故障", "GSE_KO_FAULT"},
  10. {"故障隔离成功", "GSE_KO_GLOK"},
  11. {"开关拒跳", "GSE_KO_JT"},
  12. {"过流闭锁", "GSE_KO_GLBS"},
  13. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 //中山要求通信异常,全系统均异常
  14. {"状态闭锁值", "GSE_KO_BS_STATUS"},
  15. {"状态复归值", "GSE_KO_BS_FG"},
  16. #endif
  17. };
  18. const struct gse_tbl g_goose_recv_tbl[GOOSE_RECV_TBL_NUMBER]=
  19. {
  20. {"M侧节点故障01", "GSE_KI_M01"},
  21. {"M侧节点故障02", "GSE_KI_M02"},
  22. {"M侧节点故障03", "GSE_KI_M03"},
  23. {"M侧节点故障04", "GSE_KI_M04"},
  24. {"M侧节点故障05", "GSE_KI_M05"},
  25. {"M侧节点故障06", "GSE_KI_M06"},
  26. {"M侧节点故障07", "GSE_KI_M07"},
  27. {"M侧节点故障08", "GSE_KI_M08"},
  28. {"N侧节点故障01", "GSE_KI_N01"},
  29. {"N侧节点故障02", "GSE_KI_N02"},
  30. {"N侧节点故障03", "GSE_KI_N03"},
  31. {"N侧节点故障04", "GSE_KI_N04"},
  32. {"M侧障隔离成功01", "GSE_KI_GLCG01"},
  33. {"M侧障隔离成功02", "GSE_KI_GLCG02"},
  34. {"M侧障隔离成功03", "GSE_KI_GLCG03"},
  35. {"M侧障隔离成功04", "GSE_KI_GLCG04"},
  36. {"M侧障隔离成功05", "GSE_KI_GLCG05"},
  37. {"M侧障隔离成功06", "GSE_KI_GLCG06"},
  38. {"M侧障隔离成功07", "GSE_KI_GLCG07"},
  39. {"M侧障隔离成功08", "GSE_KI_GLCG08"},
  40. {"N侧障隔离成功01", "GSE_KI_GLCG09"},
  41. {"N侧障隔离成功02", "GSE_KI_GLCG10"},
  42. {"N侧障隔离成功03", "GSE_KI_GLCG11"},
  43. {"N侧障隔离成功04", "GSE_KI_GLCG12"},
  44. {"M侧开关拒跳01", "GSE_KI_JT01"},
  45. {"M侧开关拒跳02", "GSE_KI_JT02"},
  46. {"M侧开关拒跳03", "GSE_KI_JT03"},
  47. {"M侧开关拒跳04", "GSE_KI_JT04"},
  48. {"M侧开关拒跳05", "GSE_KI_JT05"},
  49. {"馈线开关拒跳01", "GSE_KI_JT06"},
  50. {"馈线开关拒跳02", "GSE_KI_JT07"},
  51. {"馈线开关拒跳03", "GSE_KI_JT08"},
  52. {"N侧开关拒跳01", "GSE_KI_JT09"},
  53. {"N侧开关拒跳02", "GSE_KI_JT10"},
  54. {"N侧开关拒跳03", "GSE_KI_JT11"},
  55. {"馈线开关拒跳04", "GSE_KI_JT12"},
  56. {"馈线过流闭锁01", "GSE_KI_GLBS01"},
  57. {"馈线过流闭锁02", "GSE_KI_GLBS02"},
  58. {"馈线过流闭锁03", "GSE_KI_GLBS03"},
  59. {"馈线过流闭锁04", "GSE_KI_GLBS04"},
  60. {"馈线过流闭锁05", "GSE_KI_GLBS05"},
  61. {"馈线过流闭锁06", "GSE_KI_GLBS06"},
  62. {"馈线过流闭锁07", "GSE_KI_GLBS07"},
  63. {"馈线过流闭锁08", "GSE_KI_GLBS08"},
  64. {"馈线过流闭锁09", "GSE_KI_GLBS09"},
  65. {"馈线过流闭锁10", "GSE_KI_GLBS10"},
  66. {"馈线过流闭锁11", "GSE_KI_GLBS11"},
  67. {"馈线过流闭锁12", "GSE_KI_GLBS12"},
  68. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 //中山要求通信异常,全系统均异常
  69. {"状态闭锁值01", "GSE_KI_BS_STATUS01"},
  70. {"状态闭锁值02", "GSE_KI_BS_STATUS02"},
  71. {"状态闭锁值03", "GSE_KI_BS_STATUS03"},
  72. {"状态闭锁值04", "GSE_KI_BS_STATUS04"},
  73. {"状态闭锁值05", "GSE_KI_BS_STATUS05"},
  74. {"状态闭锁值06", "GSE_KI_BS_STATUS06"},
  75. {"状态闭锁值07", "GSE_KI_BS_STATUS07"},
  76. {"状态闭锁值08", "GSE_KI_BS_STATUS08"},
  77. {"状态闭锁值09", "GSE_KI_BS_STATUS09"},
  78. {"状态闭锁值10", "GSE_KI_BS_STATUS10"},
  79. {"状态闭锁值11", "GSE_KI_BS_STATUS11"},
  80. {"状态闭锁值12", "GSE_KI_BS_STATUS12"},
  81. {"状态复归值01", "GSE_KI_FG_STATUS01"},
  82. {"状态复归值02", "GSE_KI_FG_STATUS02"},
  83. {"状态复归值03", "GSE_KI_FG_STATUS03"},
  84. {"状态复归值04", "GSE_KI_FG_STATUS04"},
  85. {"状态复归值05", "GSE_KI_FG_STATUS05"},
  86. {"状态复归值06", "GSE_KI_FG_STATUS06"},
  87. {"状态复归值07", "GSE_KI_FG_STATUS07"},
  88. {"状态复归值08", "GSE_KI_FG_STATUS08"},
  89. {"状态复归值09", "GSE_KI_FG_STATUS09"},
  90. {"状态复归值10", "GSE_KI_FG_STATUS10"},
  91. {"状态复归值11", "GSE_KI_FG_STATUS11"},
  92. {"状态复归值12", "GSE_KI_FG_STATUS12"},
  93. #endif
  94. };
  95. FA_GOOSE tFAg;
  96. bool bFAgInit = false;
  97. void fa_g_init(void)
  98. {
  99. int i;
  100. if (!bFAgInit) // 61850 初始化会调用 fa_g_extinit ,将初始化部分tFAg的变量,两处调用可能先后顺序不确定,保证只初始化一次
  101. {
  102. bFAgInit = true;
  103. memset(&tFAg, 0, sizeof(tFAg));
  104. }
  105. for (i = 0; i < GOOSE_RECV_TBL_NUMBER; i++)
  106. {
  107. tFAg.inval[i] = -1; // 默认为-1 ,有正确接收时置位
  108. }
  109. InitTR(&tFAg.tRstTime, pRunSet->dT_sendext * 100, 0);
  110. InitTR(&tFAg.tGooseStillTime, T_20ms, T_20ms);
  111. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  112. InitTR(&tFAg.tErrfgtime, tRunPara.gse_T1, 0);
  113. #endif
  114. fa_g_packet(true); // 发送数据初始化
  115. }
  116. // buf 为32个遥信的起始位置
  117. void fa_g_unpack(void)
  118. {
  119. int i;
  120. bool bgzglok = 0;
  121. int sw = 0;
  122. TGOC_T *poc = &g_tRelay[sw].tgoc;
  123. TRELAY_T *pR = &g_tRelay[sw];
  124. if (BH_GOOSE_EN_YB(sw)) // 智能FA 不投入时,不处理订阅信息
  125. {
  126. for (i = 0; i <= GOOSE_RECV_LOGIC_NUM; i++)
  127. {
  128. int soeno = EV_GOOSE_BGN + i;
  129. if (tFAg.inval[i] > 0)
  130. {
  131. if (soe_check(soeno) == false)
  132. {
  133. soe_record_ev(soeno, 1, 0, 0, 0);
  134. ResetTR(&tFAg.tRstTime);
  135. }
  136. }
  137. else
  138. {
  139. if (soe_check(soeno) == true)
  140. {
  141. soe_record_ev(soeno, 0, 0, 0, 0);
  142. }
  143. }
  144. }
  145. for (i = 0; i < GOOSE_EQU_SIDE + GOOSE_EQU_SIDE_N; i++)
  146. {
  147. tFAg.ugside[i].bFlag.bgl = (tFAg.inval[GOOSE_RECV_TBL_M01 + i] > 0) ? 1 : 0;
  148. tFAg.ugside[i].bFlag.bgzglok = (tFAg.inval[GOOSE_RECV_TBL_GL01 + i] > 0) ? 1 : 0;
  149. tFAg.ugside[i].bFlag.bglbs = (tFAg.inval[GOOSE_RECV_TBL_GLBS01 + i] > 0) ? 1 : 0;
  150. bgzglok |= tFAg.ugside[i].bFlag.bgzglok;
  151. }
  152. for (i = 0; i < GOOSE_EQU_MAX; i++)
  153. {
  154. tFAg.ugside[i].bFlag.btzsb = (tFAg.inval[GOOSE_RECV_TBL_JT01 + i] > 0) ? 1 : 0;
  155. }
  156. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 // 中山要求通信异常,全系统均异常
  157. {
  158. u32 st, fg;
  159. uint32_t flags;
  160. st = 0;
  161. fg = 0;
  162. for (i = 0; i < GOOSE_EQU_MAX; i++)
  163. {
  164. st |= tFAg.inval[GOOSE_RECV_TBL_STATUS01 + i];
  165. fg |= tFAg.inval[GOOSE_RECV_TBL_FG01 + i];
  166. }
  167. rt_irq_save(flags);
  168. tFAg.commerrst |= (st & ~(1 << tRunPara.gse_id));
  169. if (tFAg.commerrst)
  170. {
  171. tFAg.commerrfg |= (fg & ~(1 << tRunPara.gse_id));
  172. }
  173. if ((st & (1 << tRunPara.gse_id)) && tFAg.commerr == 0) // 本机收到其他装置本机闭锁,但本机已恢复数据,重新发送复归值
  174. {
  175. tFAg.commerrfg |= (1 << tRunPara.gse_id);
  176. }
  177. for (i = 0; i < GOOSE_EQU_MAX; i++)
  178. {
  179. if (tFAg.inval[GOOSE_RECV_TBL_STATUS01 + i]) // 现阶段,本段代码起不了作用,原因是61850接收时,把本身保存的接收控制块的数据重新拷贝了过来,这儿清掉,重新接收后又被赋值
  180. {
  181. tFAg.inval[GOOSE_RECV_TBL_STATUS01 + i] &= (~tFAg.commerrfg); // 清保存的本机闭锁值,防止通信异常,闭锁值无法更新
  182. }
  183. }
  184. tFAg.commerrst &= (~tFAg.commerrfg);
  185. rt_irq_restore(flags);
  186. }
  187. #endif
  188. if (bgzglok) // 收到故障隔离成功信息,需转发
  189. {
  190. if (pR->tSWST.uSWST.bFlag.bTZWZ) // 开关在跳位不转发
  191. {
  192. return;
  193. }
  194. if (pRunSet->tSwSet[sw].tGocSet.bsw_fz) // 分支开关不转发
  195. {
  196. return;
  197. }
  198. if (g_tRelay[sw].tgoc.bTzout) // 本装置处于跳闸状态,不转发故障隔离信号
  199. {
  200. RunTR(&poc->tgzglokForbitTime, true, 1); // 故障隔离发送闭锁
  201. return;
  202. }
  203. if (!poc->tgzglokForbitTime.boolTrip) // 故障隔离发送未闭锁
  204. {
  205. RunTR(&poc->tgzglokextTime, true, 1);
  206. poc->psta.bFlag.bgzglok = poc->tgzglokextTime.boolTrip;
  207. RunTR(&poc->tgzglokForbitTime, poc->psta.bFlag.bgzglok, 1); // 故障隔离发送闭锁
  208. }
  209. }
  210. if (soe_check(EV_GOOSE_DECODE) == true)
  211. {
  212. soe_record_ev(EV_GOOSE_DECODE, 0, 0, 0, 0);
  213. }
  214. }
  215. }
  216. void fa_g_decode(int commstate)
  217. {
  218. int sw = 0;
  219. // TGOC_T *poc=&g_tRelay[ sw].tgoc;
  220. if ((commstate == -1) && BH_GOOSE_EN_YB(sw))
  221. {
  222. if (soe_check(EV_GOOSE_DECODE) == false)
  223. {
  224. soe_record_ev(EV_GOOSE_DECODE, 1, 0, 0, 0);
  225. }
  226. return;
  227. }
  228. #if 0
  229. if((commstate>0)&&BH_GOOSE_EN_YB(sw))
  230. {
  231. if(soe_check(EV_GOOSE_ERR)==false)
  232. {
  233. soe_record_ev(EV_GOOSE_ERR,1, 0,0,0 );
  234. poc->psta.bFlag.bcomerr=1;
  235. }
  236. if(soe_check(EV_SYS_GOOSE_ERR)==false) //置系统通信异常soe
  237. {
  238. soe_record_ev(EV_SYS_GOOSE_ERR, 1, 0,0,0 );
  239. tFAg.syscomerr=1; //goose系统通信异常
  240. }
  241. tFAg.commerr=1;
  242. }
  243. else
  244. {
  245. if(soe_check(EV_GOOSE_ERR)==true)
  246. {
  247. soe_record_ev(EV_GOOSE_ERR,0, 0,0,0 );
  248. }
  249. tFAg.commerr=0;
  250. }
  251. #endif
  252. }
  253. void fa_g_extinit(int num, int firstaddr) // app_goose.c中调用fa_g.c中的变量初始化
  254. {
  255. int i;
  256. if (num >= GOOSE_RECV_GOLBNUM)
  257. num = GOOSE_RECV_GOLBNUM;
  258. if (!bFAgInit)
  259. {
  260. bFAgInit = true;
  261. memset(&tFAg, 0, sizeof(tFAg));
  262. }
  263. tFAg.recvgolbnum = num;
  264. for (i = 0; i < num; i++)
  265. {
  266. tFAg.dTrecv[i] = dTCounter;
  267. }
  268. tFAg.bNside = false;
  269. if (num == 1 && firstaddr >= GOOSE_RECV_TBL_N01)
  270. tFAg.bNside = true; // 若输入控制块只有一个,判断是M侧还是N侧
  271. }
  272. void fa_g_gocbrecvdT(int index) // app_goose.c中接收后调用,用于通信超时处理
  273. {
  274. if (index < GOOSE_RECV_GOLBNUM)
  275. {
  276. tFAg.dTrecv[index] = dTCounter;
  277. }
  278. }
  279. void fa_g_bs_fa(int sw)
  280. {
  281. TRELAY_T *pR = &g_tRelay[sw];
  282. TSETSW *pSet = &pRunSet->tSwSet[sw];
  283. TGOC_T *poc = &g_tRelay[sw].tgoc;
  284. if (pR->tSWST.uSWST.bFlag.bTZWZ && (!pSet->tGocSet.bsw_ll && !pSet->tGocSet.bsw_fz))
  285. {
  286. if (poc->bgooseGz)
  287. {
  288. if (soe_check(EV_GOOSE_GZBS_FA) == false) // goose故障闭锁
  289. {
  290. soe_record_ev(EV_GOOSE_GZBS_FA, 1, 0, 0, 0);
  291. }
  292. }
  293. else
  294. {
  295. if (soe_check(EV_GOOSE_TZBS_FA) == false) // goose故障闭锁
  296. {
  297. soe_record_ev(EV_GOOSE_TZBS_FA, 1, 0, 0, 0);
  298. }
  299. }
  300. poc->bgooseBsHz = true;
  301. }
  302. else
  303. {
  304. poc->bgooseGz = false;
  305. poc->bgooseBsHz = false;
  306. }
  307. }
  308. #ifdef GOOSE_NETTYPE_SET
  309. extern unsigned char fec_get_hsr_prp_flag(void); // 返回订阅点组网类型
  310. #endif
  311. void fa_g_app_time(int sw) // 1s 执行一次函数
  312. {
  313. sw = 0;
  314. #ifdef DFA_MESH_ERR_SOE // 单一网口网线掉了,需弹soe
  315. if (rt_get_net_linkstatus(0) && BH_GOOSE_EN_YB(sw) && g_goose_net_type) // 普通模式,不报单网卡掉线
  316. {
  317. if (soe_check(EV_NET1_DOWN) == false)
  318. {
  319. soe_record_ev(EV_NET1_DOWN, 1, 0, 0, 0);
  320. }
  321. }
  322. else
  323. {
  324. if (soe_check(EV_NET1_DOWN) == true)
  325. {
  326. soe_record_ev(EV_NET1_DOWN, 0, 0, 0, 0);
  327. }
  328. }
  329. if (rt_get_net_linkstatus(1) && BH_GOOSE_EN_YB(sw) && g_goose_net_type)
  330. {
  331. if (soe_check(EV_NET2_DOWN) == false)
  332. {
  333. soe_record_ev(EV_NET2_DOWN, 1, 0, 0, 0);
  334. }
  335. }
  336. else
  337. {
  338. if (soe_check(EV_NET2_DOWN) == true)
  339. {
  340. soe_record_ev(EV_NET2_DOWN, 0, 0, 0, 0);
  341. }
  342. }
  343. #endif
  344. #ifdef GOOSE_NETTYPE_SET
  345. u8 temp;
  346. static u8 nettype;
  347. static u32 count;
  348. // unsigned char fec_get_hsr_prp_flag()
  349. // return 1--hsr;return 2--prp;return 3--hsr&prp
  350. if (BH_GOOSE_EN(sw) && g_goose_net_type) //
  351. {
  352. // nettype
  353. temp = fec_get_hsr_prp_flag();
  354. if (temp)
  355. {
  356. nettype |= temp;
  357. }
  358. // 10s判一次
  359. count++;
  360. if (count % 10 == 0)
  361. {
  362. if (nettype)
  363. {
  364. if (nettype & g_goose_net_type)
  365. {
  366. if (soe_check(EV_GOOSE_NETTYPE_ERR) == true)
  367. {
  368. soe_record_ev(EV_GOOSE_NETTYPE_ERR, 0, 0, 0, 0);
  369. }
  370. }
  371. else
  372. {
  373. if (soe_check(EV_GOOSE_NETTYPE_ERR) == false)
  374. {
  375. soe_record_ev(EV_GOOSE_NETTYPE_ERR, 1, 0, 0, 0);
  376. }
  377. }
  378. }
  379. nettype = 0;
  380. }
  381. }
  382. else
  383. {
  384. if (soe_check(EV_GOOSE_NETTYPE_ERR) == true)
  385. {
  386. soe_record_ev(EV_GOOSE_NETTYPE_ERR, 0, 0, 0, 0);
  387. }
  388. }
  389. #endif
  390. #ifdef GD_AREA_ZHONGSHAN_2020 // 中山局
  391. {
  392. bool bCfgerr;
  393. bCfgerr = pRunSet->tSwSet[sw].tGocSet.bKg_mainloop // 主环开关
  394. && (tFAg.recvgolbnum == 0) // 接收控制块未配置
  395. && (gi_platelib_state == IEC61850_LIB_INIT_SUCCESS); // 61850初始化完毕
  396. if (bCfgerr)
  397. {
  398. if (soe_check(EV_GOOSE_CONFIG_ERR) == false)
  399. {
  400. soe_record_ev(EV_GOOSE_CONFIG_ERR, 1, 0, 0, 0);
  401. }
  402. }
  403. else
  404. {
  405. if (soe_check(EV_GOOSE_CONFIG_ERR) == true)
  406. {
  407. soe_record_ev(EV_GOOSE_CONFIG_ERR, 0, 0, 0, 0);
  408. }
  409. }
  410. }
  411. #endif
  412. }
  413. void fa_g_commcheck(DWORD dStep) // 防止goose信息丢失,相关置位信息延时复归
  414. {
  415. int i;
  416. bool bret = false;
  417. bool boverdT = false;
  418. int sw = 0;
  419. for (i = 0; i <= GOOSE_RECV_LOGIC_NUM; i++)
  420. {
  421. bret |= (tFAg.inval[i] > 0) ? true : false;
  422. }
  423. RunTR(&tFAg.tRstTime, bret, dStep); // 信息延迟复归
  424. if (tFAg.tRstTime.boolTrip)
  425. {
  426. for (i = 0; i <= GOOSE_RECV_LOGIC_NUM; i++)
  427. {
  428. if (tFAg.tRstTime.boolTrip && (tFAg.inval[i] > 0))
  429. tFAg.inval[i] = 0;
  430. }
  431. ResetTR(&tFAg.tRstTime);
  432. fa_g_unpack();
  433. }
  434. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  435. if (tFAg.commerr)
  436. {
  437. tFAg.commerrst |= (1 << tRunPara.gse_id);
  438. tFAg.commerrfg &= ~(1 << tRunPara.gse_id); // 本机通信异常,清除复归位
  439. }
  440. else
  441. {
  442. tFAg.commerrst &= ~(1 << tRunPara.gse_id);
  443. }
  444. if (tFAg.commerrst > 0) //
  445. {
  446. if (soe_check(EV_SYS_GOOSE_ERR) == false) // 置系统通信异常soe
  447. {
  448. soe_record_ev(EV_SYS_GOOSE_ERR, 1, 0, 0, 0);
  449. tFAg.syscomerr = 1; // goose系统通信异常
  450. fa_g_bs_fa(sw);
  451. if (tFAg.commerr)
  452. {
  453. InitTR(&tFAg.tErrfgtime, tRunPara.gse_T1, 0); // 若是本机通信异常,发送时间为T1
  454. }
  455. else
  456. {
  457. InitTR(&tFAg.tErrfgtime, tRunPara.gse_T2, 0); // 若不是本机通信异常,发送时间为T2
  458. }
  459. }
  460. }
  461. else
  462. {
  463. if (soe_check(EV_SYS_GOOSE_ERR) == true) // 置系统通信异常soe
  464. {
  465. soe_record_ev(EV_SYS_GOOSE_ERR, 0, 0, 0, 0);
  466. tFAg.syscomerr = 0; // goose系统通信异常
  467. }
  468. }
  469. RunTR(&tFAg.tErrfgtime, tFAg.commerrfg, dStep); // 分布式功能投入
  470. if (tFAg.tErrfgtime.boolTrip) // 复归发送时间到,清复归标志:条件 无通信异常
  471. {
  472. tFAg.commerrfg &= tFAg.commerrst;
  473. ResetTR(&tFAg.tErrfgtime);
  474. }
  475. #endif
  476. for (i = 0; i < tFAg.recvgolbnum; i++)
  477. {
  478. boverdT |= ((dTCounter - tFAg.dTrecv[i]) > T_1s * 20) ? true : false;
  479. if (!BH_GOOSE_EN_YB(sw))
  480. {
  481. tFAg.dTrecv[i] = dTCounter;
  482. }
  483. #ifdef DFA_MESH_ERR_SOE // 单一网口网线掉了,需弹soe
  484. {
  485. bool berr = ((dTCounter - tFAg.dTrecv[i]) > T_1s * 20) ? true : false;
  486. if (berr && BH_GOOSE_EN_YB(sw))
  487. {
  488. if (((i == tFAg.recvgolbnum - 1) && (tFAg.recvgolbnum > 1)) || tFAg.bNside)
  489. {
  490. if (soe_check(EV_GOOSE_ERR_N) == false)
  491. {
  492. soe_record_ev(EV_GOOSE_ERR_N, 1, 0, 0, 0);
  493. }
  494. }
  495. else
  496. {
  497. if (soe_check(EV_GOOSE_ERR_M) == false)
  498. {
  499. soe_record_ev(EV_GOOSE_ERR_M, 1, 0, 0, 0);
  500. }
  501. }
  502. }
  503. else
  504. {
  505. if (((i == tFAg.recvgolbnum - 1) && (tFAg.recvgolbnum > 1)) || tFAg.bNside)
  506. {
  507. if (soe_check(EV_GOOSE_ERR_N) == true)
  508. {
  509. soe_record_ev(EV_GOOSE_ERR_N, 0, 0, 0, 0);
  510. }
  511. }
  512. else if (soe_check(EV_GOOSE_ERR_M) == true)
  513. {
  514. int j;
  515. bool berr1 = false;
  516. for (j = 0; j < tFAg.recvgolbnum - 1; j++)
  517. {
  518. berr1 |= ((dTCounter - tFAg.dTrecv[j]) > T_1s * 20) ? true : false;
  519. }
  520. if (berr1 == false)
  521. {
  522. soe_record_ev(EV_GOOSE_ERR_M, 0, 0, 0, 0);
  523. }
  524. }
  525. }
  526. }
  527. #endif
  528. }
  529. if (boverdT && BH_GOOSE_EN_YB(sw))
  530. {
  531. if (soe_check(EV_GOOSE_ERR) == false)
  532. {
  533. soe_record_ev(EV_GOOSE_ERR, 1, 0, 0, 0);
  534. }
  535. tFAg.commerr = 1;
  536. }
  537. else
  538. {
  539. if (soe_check(EV_GOOSE_ERR) == true)
  540. {
  541. soe_record_ev(EV_GOOSE_ERR, 0, 0, 0, 0); // 本机通信恢复
  542. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  543. tFAg.commerrfg |= (1 << tRunPara.gse_id); // 本机通信恢复,置复归位
  544. #endif
  545. }
  546. tFAg.commerr = 0;
  547. }
  548. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  549. // 分布式FA由投入转为退出时,需处理闭锁FA 的相关信息,同通信异常类似
  550. RunTR(&tFAg.tGooseStillTime, BH_GOOSE_EN_YB(sw), dStep); // 分布式功能投入
  551. bret = tFAg.tGooseStillTime.boolTrip && (!BH_GOOSE_EN_YB(sw)); // 分布式功能由投入转为退出
  552. if (bret)
  553. {
  554. fa_g_bs_fa(sw);
  555. ResetTR(&tFAg.tGooseStillTime);
  556. }
  557. #endif
  558. }
  559. void fa_g_packet(bool bfirst)
  560. {
  561. int sw = 0;
  562. UGOOSE_STU *pug = &tFAg.ug;
  563. TRELAY_T *pR = &g_tRelay[sw];
  564. TGOC_T *poc = &pR->tgoc;
  565. bool bcommerrsend = false;
  566. pug->bFlag.bzx = poc->psta.bFlag.bZX; // 本线路正向故障
  567. pug->bFlag.bfx = poc->psta.bFlag.bFX; // 本线路反向故障
  568. pug->bFlag.blx = poc->psta.bFlag.bLX; // 本线路无方向故障
  569. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  570. pug->bFlag.bgl = poc->psta.bFlag.bWX || poc->psta2.bFlag.bWX; // 本线路跳闸失败
  571. #else
  572. pug->bFlag.bgl = poc->psta.bFlag.bWX; // 本线路跳闸失败
  573. #endif
  574. pug->bFlag.bgzglok = poc->psta.bFlag.bgzglok; // 本线路跳闸失败
  575. pug->bFlag.btzsb = poc->psta.bFlag.btzsb || (pR->uBHDZ.bFlag.bTZSB && pRunSet->bTT_fhkg_pub); // 本线路跳闸失败
  576. pug->bFlag.bglbs = poc->psta.bFlag.bGLBS; // 负荷开关
  577. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 // 中山要求通信异常,全系统均异常
  578. if (tFAg.commerrst != tFAg.commerrstsave || tFAg.commerrfg != tFAg.commerrfgsave)
  579. {
  580. bcommerrsend = true;
  581. tFAg.commerrstsave = tFAg.commerrst;
  582. tFAg.commerrfgsave = tFAg.commerrfg;
  583. }
  584. #endif
  585. g_bgseEnable = BH_GOOSE_EN_YB(sw) || pRunSet->bTT_fhkg_pub;
  586. if ((pug->wfFlag != tFAg.ug_save) || bfirst || bcommerrsend) // 启动goose 发送
  587. {
  588. int *dat = tFAg.outval;
  589. tFAg.ug_save = pug->wfFlag;
  590. dat[GOOSE_SEND_TBL_GZ] = (pug->bFlag.bgl || pug->bFlag.blx || pug->bFlag.bTstgz);
  591. dat[GOOSE_SEND_TBL_GL] = (pug->bFlag.bgzglok || pug->bFlag.bTstglok);
  592. dat[GOOSE_SEND_TBL_JT] = (pug->bFlag.btzsb) || pug->bFlag.bTstjt; // 开关拒跳:智能FA逻辑或负荷开关常规动作拒跳
  593. dat[GOOSE_SEND_TBL_GLBS] = pug->bFlag.bglbs || pug->bFlag.bTstglbs; // 负荷开关
  594. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 // 中山要求通信异常,全系统均异常
  595. dat[GOOSE_SEND_TBL_STATUS] = tFAg.commerrstsave; // 通信状态
  596. dat[GOOSE_SEND_TBL_FG] = tFAg.commerrfgsave; // 复归值
  597. #endif
  598. if (!bfirst)
  599. {
  600. tFAg.bSend = true;
  601. #ifdef __IEC61850_GOOSE_FUNC__
  602. goose_send_wakeup();
  603. #endif
  604. }
  605. }
  606. }
  607. // A相电流方向判断
  608. void GOc_dir_phA(int sw)
  609. {
  610. TGOC_T *poc = &g_tRelay[sw].tgoc;
  611. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  612. int indexI;
  613. bool bzx, bfx;
  614. u32 dIgl, dIgl_fh;
  615. dIgl = pSet->dIgl;
  616. dIgl_fh = pSet->dIgl_fh;
  617. indexI = UI_SW_INDEX(sw, SW_AC_IA);
  618. poc->psta.bFlag.bQDA = OverRelay(g_ui[indexI].m2[0], dIgl, dIgl_fh, poc->psta.bFlag.bQDA); // A相过流启动
  619. bzx = CalDir_A(sw, poc->psta.bFlag.bQDA && pSet->bTT_DIR, false);
  620. bfx = (!bzx) && poc->psta.bFlag.bQDA && pSet->bTT_DIR;
  621. poc->psta.bFlag.bZXA = poc->psta.bFlag.bQDA // A相电流启动
  622. && bzx // 正方向
  623. && pSet->bTT_DIR // 功率方向投入
  624. && (!tPT.uPT1DX.bFlag.bPTYC);
  625. poc->psta.bFlag.bFXA = poc->psta.bFlag.bQDA // A相电流启动
  626. && (bfx) // 反方向
  627. && pSet->bTT_DIR // 功率方向投入
  628. && (!tPT.uPT1DX.bFlag.bPTYC);
  629. poc->psta.bFlag.bWXA = poc->psta.bFlag.bQDA // A相电流启动
  630. && (!pSet->bTT_DIR || tPT.uPT1DX.bFlag.bPTYC); // 功率方向退出或功率方向投入,PT异常退方向)
  631. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  632. dIgl = pSet->dIgl2;
  633. dIgl_fh = pSet->dIgl2_fh;
  634. poc->psta2.bFlag.bQDA = OverRelay(g_ui[indexI].m2[0], dIgl, dIgl_fh, poc->psta2.bFlag.bQDA); // A相过流启动
  635. bzx = CalDir_A(sw, poc->psta2.bFlag.bQDA && pSet->bTT_DIR, false);
  636. bfx = (!bzx) && poc->psta2.bFlag.bQDA && pSet->bTT_DIR;
  637. poc->psta2.bFlag.bZXA = poc->psta2.bFlag.bQDA // A相电流启动
  638. && bzx // 正方向
  639. && pSet->bTT_DIR // 功率方向投入
  640. && (!tPT.uPT1DX.bFlag.bPTYC);
  641. poc->psta2.bFlag.bFXA = poc->psta2.bFlag.bQDA // A相电流启动
  642. && (bfx) // 反方向
  643. && pSet->bTT_DIR // 功率方向投入
  644. && (!tPT.uPT1DX.bFlag.bPTYC);
  645. poc->psta2.bFlag.bWXA = poc->psta2.bFlag.bQDA // A相电流启动
  646. && (!pSet->bTT_DIR || tPT.uPT1DX.bFlag.bPTYC); // 功率方向退出或功率方向投入,PT异常退方向)
  647. #endif
  648. }
  649. // B相电流方向判断
  650. void GOc_dir_phB(int sw)
  651. {
  652. TGOC_T *poc = &g_tRelay[sw].tgoc;
  653. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  654. int indexI;
  655. bool bzx, bfx;
  656. u32 dIgl, dIgl_fh;
  657. dIgl = pSet->dIgl;
  658. dIgl_fh = pSet->dIgl_fh;
  659. indexI = UI_SW_INDEX(sw, SW_AC_IB);
  660. poc->psta.bFlag.bQDB = OverRelay(g_ui[indexI].m2[0], dIgl, dIgl_fh, poc->psta.bFlag.bQDB); // A相过流启动
  661. bzx = CalDir_B(sw, poc->psta.bFlag.bQDB && pSet->bTT_DIR, false);
  662. bfx = (!bzx) && poc->psta.bFlag.bQDB && pSet->bTT_DIR;
  663. poc->psta.bFlag.bZXB = poc->psta.bFlag.bQDB // A相电流启动
  664. && bzx // 正方向
  665. && pSet->bTT_DIR // 功率方向投入
  666. && (!tPT.uPT1DX.bFlag.bPTYC); // 无TV异常
  667. poc->psta.bFlag.bFXB = poc->psta.bFlag.bQDB // A相电流启动
  668. && (bfx) // 反方向
  669. && pSet->bTT_DIR // 功率方向投入
  670. && (!tPT.uPT1DX.bFlag.bPTYC); // 无TV异常
  671. poc->psta.bFlag.bWXB = poc->psta.bFlag.bQDB // A相电流启动
  672. && (!pSet->bTT_DIR || tPT.uPT1DX.bFlag.bPTYC); // 功率方向退出或功率方向投入,PT异常退方向)
  673. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  674. dIgl = pSet->dIgl2;
  675. dIgl_fh = pSet->dIgl2_fh;
  676. poc->psta2.bFlag.bQDB = OverRelay(g_ui[indexI].m2[0], dIgl, dIgl_fh, poc->psta2.bFlag.bQDB); // A相过流启动
  677. bzx = CalDir_B(sw, poc->psta2.bFlag.bQDB && pSet->bTT_DIR, false);
  678. bfx = (!bzx) && poc->psta2.bFlag.bQDB && pSet->bTT_DIR;
  679. poc->psta2.bFlag.bZXB = poc->psta2.bFlag.bQDB // A相电流启动
  680. && bzx // 正方向
  681. && pSet->bTT_DIR // 功率方向投入
  682. && (!tPT.uPT1DX.bFlag.bPTYC); // 无TV异常
  683. poc->psta2.bFlag.bFXB = poc->psta2.bFlag.bQDB // A相电流启动
  684. && (bfx) // 反方向
  685. && pSet->bTT_DIR // 功率方向投入
  686. && (!tPT.uPT1DX.bFlag.bPTYC); // 无TV异常
  687. poc->psta2.bFlag.bWXB = poc->psta2.bFlag.bQDB // A相电流启动
  688. && (!pSet->bTT_DIR || tPT.uPT1DX.bFlag.bPTYC); // 功率方向退出或功率方向投入,PT异常退方向)
  689. #endif
  690. }
  691. // C相电流方向判断
  692. void GOc_dir_phC(int sw)
  693. {
  694. TGOC_T *poc = &g_tRelay[sw].tgoc;
  695. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  696. int indexI;
  697. bool bzx, bfx;
  698. u32 dIgl, dIgl_fh;
  699. dIgl = pSet->dIgl;
  700. dIgl_fh = pSet->dIgl_fh;
  701. indexI = UI_SW_INDEX(sw, SW_AC_IC);
  702. poc->psta.bFlag.bQDC = OverRelay(g_ui[indexI].m2[0], dIgl, dIgl_fh, poc->psta.bFlag.bQDC); // A相过流启动
  703. bzx = CalDir_C(sw, poc->psta.bFlag.bQDC && pSet->bTT_DIR, false);
  704. bfx = (!bzx) && poc->psta.bFlag.bQDC && pSet->bTT_DIR;
  705. poc->psta.bFlag.bZXC = poc->psta.bFlag.bQDC // A相电流启动
  706. && bzx // 正方向
  707. && pSet->bTT_DIR // 功率方向投入
  708. && (!tPT.uPT1DX.bFlag.bPTYC); // 无TV异常
  709. poc->psta.bFlag.bFXC = poc->psta.bFlag.bQDC // A相电流启动
  710. && (bfx) // 反方向
  711. && pSet->bTT_DIR // 功率方向投入
  712. && (!tPT.uPT1DX.bFlag.bPTYC); // 无TV异常
  713. poc->psta.bFlag.bWXC = poc->psta.bFlag.bQDC // A相电流启动
  714. && (!pSet->bTT_DIR || tPT.uPT1DX.bFlag.bPTYC); // 功率方向未投入,或PT异常
  715. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  716. dIgl = pSet->dIgl2;
  717. dIgl_fh = pSet->dIgl2_fh;
  718. poc->psta2.bFlag.bQDC = OverRelay(g_ui[indexI].m2[0], dIgl, dIgl_fh, poc->psta2.bFlag.bQDC); // A相过流启动
  719. bzx = CalDir_C(sw, poc->psta2.bFlag.bQDC && pSet->bTT_DIR, false);
  720. bfx = (!bzx) && poc->psta2.bFlag.bQDC && pSet->bTT_DIR;
  721. poc->psta2.bFlag.bZXC = poc->psta2.bFlag.bQDC // A相电流启动
  722. && bzx // 正方向
  723. && pSet->bTT_DIR // 功率方向投入
  724. && (!tPT.uPT1DX.bFlag.bPTYC); // 无TV异常
  725. poc->psta2.bFlag.bFXC = poc->psta2.bFlag.bQDC // A相电流启动
  726. && (bfx) // 反方向
  727. && pSet->bTT_DIR // 功率方向投入
  728. && (!tPT.uPT1DX.bFlag.bPTYC); // 无TV异常
  729. poc->psta2.bFlag.bWXC = poc->psta2.bFlag.bQDC // A相电流启动
  730. && (!pSet->bTT_DIR || tPT.uPT1DX.bFlag.bPTYC); // 功率方向未投入,或PT异常
  731. #endif
  732. }
  733. void GOc_lx_check(int sw)
  734. {
  735. TGOC_T *poc = &g_tRelay[sw].tgoc;
  736. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  737. int indexI;
  738. indexI = UI_SW_INDEX(sw, SW_AC_I0);
  739. poc->psta.bFlag.bQDLX = OverRelay(g_ui[indexI].m2[0], pSet->dIlx, pSet->dIlx_fh, poc->psta.bFlag.bQDLX); // 零序启动
  740. }
  741. bool GOC_bh_all(int sw)
  742. {
  743. int i;
  744. for (i = BH_GL1; i <= FA_LX2; i++)
  745. {
  746. if (g_tRelay[sw].tOC[i].sta.bFlag.bQD)
  747. return true;
  748. }
  749. return false;
  750. }
  751. void GOC_dir_check(int sw, u32 dStep)
  752. {
  753. bool bY1;
  754. TGOC_T *poc = &g_tRelay[sw].tgoc;
  755. GOc_dir_phA(sw);
  756. GOc_dir_phB(sw);
  757. GOc_dir_phC(sw);
  758. GOc_lx_check(sw);
  759. // 正方向判断,保持2秒
  760. bY1 = (poc->psta.bFlag.bZXA || poc->psta.bFlag.bZXB || poc->psta.bFlag.bZXC) && (!poc->sta.bFlag.bXBbs) && BH_GOOSE_EN_YB(sw);
  761. RunTR(&poc->tTZX_300ms, bY1, dStep);
  762. poc->psta.bFlag.bZX = poc->tTZX_300ms.boolTrip;
  763. // 反方向判断,保持2秒
  764. bY1 = (poc->psta.bFlag.bFXA || poc->psta.bFlag.bFXB || poc->psta.bFlag.bFXC) && (!poc->sta.bFlag.bXBbs) && BH_GOOSE_EN_YB(sw);
  765. RunTR(&poc->tTFX_300ms, bY1, dStep);
  766. poc->psta.bFlag.bFX = poc->tTFX_300ms.boolTrip;
  767. // 无方向判断,保持2秒
  768. bY1 = (poc->psta.bFlag.bWXA || poc->psta.bFlag.bWXB || poc->psta.bFlag.bWXC) && (!poc->sta.bFlag.bXBbs) && BH_GOOSE_EN_YB(sw);
  769. RunTR(&poc->tTWX_300ms, bY1, dStep);
  770. poc->psta.bFlag.bWX = poc->tTWX_300ms.boolTrip;
  771. // 零序判断,保持2秒
  772. bY1 = poc->psta.bFlag.bQDLX && BH_GOOSE_EN_YB(sw);
  773. RunTR(&poc->tTLX_300ms, bY1, dStep);
  774. poc->psta.bFlag.bLX = poc->tTLX_300ms.boolTrip;
  775. // 过流闭锁
  776. bY1 = (GOC_bh_all(sw) && pRunSet->bTT_fhkg_pub); // 负荷开关
  777. RunTR(&poc->tTGLBS_300ms, bY1, dStep);
  778. poc->psta.bFlag.bGLBS = poc->tTGLBS_300ms.boolTrip;
  779. poc->psta.bFlag.bGZ = poc->psta.bFlag.bZX | poc->psta.bFlag.bFX | poc->psta.bFlag.bWX | poc->psta.bFlag.bLX; // 线路有故障
  780. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  781. // 正方向判断,保持2秒
  782. bY1 = (poc->psta2.bFlag.bZXA || poc->psta2.bFlag.bZXB || poc->psta2.bFlag.bZXC) && (!poc->sta.bFlag.bXBbs2) && BH_GOOSE_EN_YB(sw);
  783. RunTR(&poc->tTZX2_300ms, bY1, dStep);
  784. poc->psta2.bFlag.bZX = poc->tTZX2_300ms.boolTrip;
  785. // 反方向判断,保持2秒
  786. bY1 = (poc->psta2.bFlag.bFXA || poc->psta2.bFlag.bFXB || poc->psta2.bFlag.bFXC) && (!poc->sta.bFlag.bXBbs2) && BH_GOOSE_EN_YB(sw);
  787. RunTR(&poc->tTFX2_300ms, bY1, dStep);
  788. poc->psta2.bFlag.bFX = poc->tTFX2_300ms.boolTrip;
  789. // 无方向判断,保持2秒
  790. bY1 = (poc->psta2.bFlag.bWXA || poc->psta2.bFlag.bWXB || poc->psta2.bFlag.bWXC) && (!poc->sta.bFlag.bXBbs2) && BH_GOOSE_EN_YB(sw);
  791. RunTR(&poc->tTWX2_300ms, bY1, dStep);
  792. poc->psta2.bFlag.bWX = poc->tTWX2_300ms.boolTrip;
  793. poc->psta2.bFlag.bGZ = poc->psta2.bFlag.bZX | poc->psta2.bFlag.bFX | poc->psta2.bFlag.bWX | poc->psta2.bFlag.bLX; // 线路有故障
  794. poc->psta.bFlag.bGZ |= poc->psta2.bFlag.bGZ;
  795. #endif
  796. }
  797. bool fag_goosecheck_gzqc(int sw) // 故障切除邻域故障信息判断
  798. {
  799. TGOC_T *poc = &g_tRelay[sw].tgoc;
  800. TSETSW *pSet = &pRunSet->tSwSet[sw];
  801. UGOOSE_STU *pg;
  802. int i;
  803. if (pSet->tGocSet.bTT_DIR && (!tPT.uPT1DX.bFlag.bPTYC)) // 带方向判断
  804. {
  805. if (poc->psta.bFlag.bZX) // 本线路有正向故障,L邻域
  806. {
  807. bool bY1 = false;
  808. for (i = GOOSE_EQU_SIDE; i < GOOSE_EQU_MAX; i++)
  809. {
  810. pg = &tFAg.ugside[i];
  811. bY1 |= pg->bFlag.bfx; // L邻域 有反向故障
  812. }
  813. return (!bY1);
  814. }
  815. if (poc->psta.bFlag.bFX) // 本线路有反向故障, B邻域 无正向向故障
  816. {
  817. bool bY1 = false;
  818. for (i = 0; i < GOOSE_EQU_SIDE; i++)
  819. {
  820. pg = &tFAg.ugside[i];
  821. bY1 |= pg->bFlag.bzx; // B邻域 正向向故障
  822. }
  823. return (!bY1);
  824. }
  825. return false;
  826. }
  827. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  828. if (poc->psta.bFlag.bWX || poc->psta2.bFlag.bWX || poc->psta.bFlag.bLX) // 本线路有无方向故障 ,或零序故障
  829. #else
  830. if (poc->psta.bFlag.bWX || poc->psta.bFlag.bLX) // 本线路有无方向故障 ,或零序故障
  831. #endif
  832. {
  833. bool bY1 = false;
  834. bool bY2 = false;
  835. bool ret = false;
  836. for (i = 0; i < GOOSE_EQU_SIDE; i++)
  837. {
  838. pg = &tFAg.ugside[i];
  839. bY1 |= (pg->bFlag.bgl | pg->bFlag.blx | pg->bFlag.bzx | pg->bFlag.bfx | pg->bFlag.bglbs | pg->bFlag.blxbs);
  840. }
  841. for (i = GOOSE_EQU_SIDE; i < GOOSE_EQU_MAX; i++)
  842. {
  843. pg = &tFAg.ugside[i];
  844. bY2 |= (pg->bFlag.bgl | pg->bFlag.blx | pg->bFlag.bzx | pg->bFlag.bfx | pg->bFlag.bglbs | pg->bFlag.blxbs);
  845. }
  846. if (pRunSet->tSwSet[sw].tGocSet.bsw_fz) // 末端开关
  847. {
  848. ret = (bY1 || bY2); // 末端开关,邻域有故障
  849. }
  850. else if (pRunSet->tSwSet[sw].tGocSet.bsw_sd) // 首端开关
  851. {
  852. ret = (!(bY1 || bY2)); // 任一侧有故障(首开关)
  853. }
  854. else
  855. {
  856. ret = (bY1 ^ bY2); // 非首末端,邻域有一侧无故障
  857. }
  858. return ret;
  859. }
  860. return false;
  861. }
  862. bool fag_goosecheck_gzgl(int sw) // 故障隔离邻域故障信息判断
  863. {
  864. TSETSW *pSet = &pRunSet->tSwSet[sw];
  865. UGOOSE_STU *pg;
  866. int i;
  867. if (pSet->tGocSet.bTT_DIR && (!tPT.uPT1DX.bFlag.bPTYC))
  868. {
  869. return false; // 合环方式下,无故障隔离故障产生
  870. }
  871. else
  872. {
  873. bool bY1 = false;
  874. int num = 0;
  875. for (i = 0; i < GOOSE_EQU_MAX; i++)
  876. {
  877. pg = &tFAg.ugside[i];
  878. bY1 = (pg->bFlag.bgl | pg->bFlag.blx | pg->bFlag.bzx | pg->bFlag.bfx | pg->bFlag.bglbs | pg->bFlag.blxbs);
  879. if (bY1)
  880. {
  881. num++;
  882. }
  883. }
  884. return (num == 1);
  885. }
  886. return false;
  887. }
  888. bool fag_goosecheck_ll(int sw) // 联络开关动作,邻域条件判断
  889. {
  890. int i;
  891. UGOOSE_STU *pg;
  892. bool bgzglok = false;
  893. TSETSW *pSet = &pRunSet->tSwSet[sw];
  894. if (pSet->tGocSet.bTT_DIR && (!tPT.uPT1DX.bFlag.bPTYC)) // 带方向判断,无故障隔离发送,条件自动满足
  895. {
  896. bgzglok = true;
  897. }
  898. else
  899. {
  900. for (i = 0; i < GOOSE_EQU_MAX; i++)
  901. {
  902. pg = &tFAg.ugside[i];
  903. bgzglok |= pg->bFlag.bgzglok; // 收到故障隔离成功信息
  904. }
  905. }
  906. return bgzglok;
  907. }
  908. void fag_get_side_dz(int sw) // 获取相邻侧故障信息
  909. {
  910. TGOC_T *poc = &g_tRelay[sw].tgoc;
  911. UGOOSE_STU *pg;
  912. bool bdz = false;
  913. bool btzsb = false;
  914. int i;
  915. for (i = 0; i < GOOSE_EQU_MAX; i++)
  916. {
  917. pg = &tFAg.ugside[i];
  918. bdz |= (pg->bFlag.bgl || pg->bFlag.blx || pg->bFlag.bzx || pg->bFlag.bfx | pg->bFlag.bglbs | pg->bFlag.blxbs);
  919. btzsb |= pg->bFlag.btzsb;
  920. }
  921. poc->b_side_gz = bdz;
  922. poc->b_side_tzsb = btzsb;
  923. }
  924. void fag_cd(int sw, DWORD dStep) //
  925. {
  926. TRELAY_T *pR = &g_tRelay[sw];
  927. TGOC_T *poc = &g_tRelay[sw].tgoc;
  928. TSETSW *pSet = &pRunSet->tSwSet[sw];
  929. FA_CD *pcd;
  930. bool bQD;
  931. bool bY1;
  932. fag_get_side_dz(sw); // 获取开关临域信息
  933. poc->psta.bFlag.bYY1 = OverRelay(g_sw_pub.m2_max[2], pSet->dU_fa_YY, pSet->dU_fa_YY_fh, poc->psta.bFlag.bYY1); // 有压
  934. poc->psta.bFlag.bYY2 = OverRelay(g_sw_pub.m2_max[3], pSet->dU_fa_YY, pSet->dU_fa_YY_fh, poc->psta.bFlag.bYY2);
  935. poc->psta.bFlag.bWY1 = LowRelay(g_sw_pub.m2_max[2], pSet->dU_fa_WY, pSet->dU_fa_WY_fh, poc->psta.bFlag.bWY1); // 无压
  936. poc->psta.bFlag.bWY2 = LowRelay(g_sw_pub.m2_max[3], pSet->dU_fa_WY, pSet->dU_fa_WY_fh, poc->psta.bFlag.bWY2);
  937. // 故障切除充电判断
  938. pcd = &pR->tgoc.tqccd;
  939. RunTR(&pcd->tWYTime, (poc->psta.bFlag.bWY1 && poc->psta.bFlag.bWY2), dStep); // 放电两侧无压60秒
  940. pcd->sta.bFlag.bFD = (!BH_GOOSE_EN(sw)) // 分布式退出
  941. || pR->tSWST.uSWST.bFlag.bTZWZ // 开关跳位
  942. || pcd->tWYTime.boolTrip; // 两侧无压超过60秒
  943. bQD = (BH_GOOSE_EN(sw))
  944. //&&!poc->b_side_gz //邻域无故障
  945. //&&!poc->psta.bFlag.bGZ //本开关无故障
  946. && (poc->psta.bFlag.bYY1 || poc->psta.bFlag.bYY2 || (pRunSet->dT_cd == 0)) // 一侧有电压
  947. && pR->tSWST.uSWST.bFlag.bHZWZ && !pcd->sta.bFlag.bFD;
  948. RunTR(&pcd->tCDTime, bQD, dStep);
  949. pcd->sta.bFlag.bCD = (pcd->tCDTime.boolTrip || pcd->sta.bFlag.bCD) && (!pcd->sta.bFlag.bFD); // 充电完成
  950. pR->run_stu.goose_qccd = pcd->sta.bFlag.bCD;
  951. // 隔离充电判断
  952. pcd = &pR->tgoc.tglcd;
  953. RunTR(&pcd->tWYTime, (poc->psta.bFlag.bWY1 && poc->psta.bFlag.bWY2), dStep); // 放电两侧无压60秒
  954. pcd->sta.bFlag.bFD = (!BH_GOOSE_EN(sw)) // 分布式退出
  955. || pR->tSWST.uSWST.bFlag.bTZWZ // 开关跳位
  956. || poc->psta.bFlag.bGZ // 本开关有故障,故障隔离立即放电
  957. || pcd->tWYTime.boolTrip; // 两侧无压超过60秒
  958. bQD = (BH_GOOSE_EN(sw)) && !poc->b_side_gz // 邻域无故障
  959. && !poc->psta.bFlag.bGZ // 本开关无故障
  960. && (poc->psta.bFlag.bYY1 || poc->psta.bFlag.bYY2 || (pRunSet->dT_cd == 0)) // 一侧有电压
  961. && pR->tSWST.uSWST.bFlag.bHZWZ && !pcd->sta.bFlag.bFD;
  962. RunTR(&pcd->tCDTime, bQD, dStep);
  963. pcd->sta.bFlag.bCD = (pcd->tCDTime.boolTrip || pcd->sta.bFlag.bCD) && (!pcd->sta.bFlag.bFD); // 充电完成
  964. pR->run_stu.goose_glcd = pcd->sta.bFlag.bCD;
  965. // 联络充电判断
  966. pcd = &pR->tgoc.tllcd;
  967. RunTR(&pcd->tWYTime, (poc->psta.bFlag.bWY1 && poc->psta.bFlag.bWY2), dStep); // 无压判断
  968. pcd->sta.bFlag.bFD = (!BH_GOOSE_EN(sw)) // 分布式退出
  969. || !pSet->tGocSet.bTT_ll // 联络功能退出
  970. #if defined GD_AREA_ZHONGSHAN // 中山要求联络开关固定
  971. || !pSet->tGocSet.bsw_ll
  972. #endif
  973. || pcd->tWYTime.boolTrip // 两侧无压超过15秒
  974. || poc->b_side_gz // 领域故障
  975. || pR->tgoc.b_side_tzsb // 领域拒动
  976. //||!g_run_stu.yf //KK把手非远方
  977. || poc->sta.bFlag.bllhz; // 本开关联络动作
  978. bQD = (BH_GOOSE_EN(sw)) // 充电条件:保护投入
  979. && (poc->psta.bFlag.bYY1 && poc->psta.bFlag.bYY2) // 两侧有压
  980. && pR->tSWST.uSWST.bFlag.bTZWZ // 开关跳位
  981. && !pcd->sta.bFlag.bFD; // 无放电
  982. RunTR(&pcd->tCDTime, bQD, dStep);
  983. pcd->sta.bFlag.bCD = (pcd->tCDTime.boolTrip || pcd->sta.bFlag.bCD) // 充电完成,并自保持
  984. && (!pcd->sta.bFlag.bFD); // 无放电标志
  985. pR->run_stu.goose_ll_cd = pcd->sta.bFlag.bCD; // 充电标志
  986. // 缓动型无压无流判断
  987. poc->bslowEn = (!pSet->tGocSet.bFA_slow) || (pSet->tGocSet.bFA_slow // 缓动型
  988. && poc->psta.bFlag.bWY1 // 无压
  989. && poc->psta.bFlag.bWY2 && pR->tSWST.uSWST.bFlag.bSXWL); // 无流
  990. bY1 = soe_check(EV_GOOSE_GZBS_FA) || soe_check(EV_GOOSE_TZBS_FA);
  991. RunTR(&poc->tTHz1s, pR->tSWST.uSWST.bFlag.bHZWZ && bY1, dStep); // 合闸后1秒,清动作标志
  992. if (poc->tTHz1s.boolTrip && BH_GOOSE_EN(sw))
  993. {
  994. pR->tgoc.bgooseGz = false;
  995. pR->tgoc.bgooseBsHz = false;
  996. if (soe_check(EV_GOOSE_GZBS_FA) == true) // goose故障闭锁
  997. {
  998. soe_record_ev(EV_GOOSE_GZBS_FA, 0, 0, 0, 0);
  999. }
  1000. if (soe_check(EV_GOOSE_TZBS_FA) == true) // goose故障闭锁
  1001. {
  1002. soe_record_ev(EV_GOOSE_TZBS_FA, 0, 0, 0, 0);
  1003. }
  1004. }
  1005. }
  1006. void fag_oc_gl(int sw, u32 dStep)
  1007. {
  1008. TGOC_T *poc = &g_tRelay[sw].tgoc;
  1009. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  1010. bool bgl, bGoose, bTz;
  1011. // 电流启动
  1012. bgl = OverRelay(g_sw[sw].m2_max, pSet->dIgl, pSet->dIgl_fh, poc->sta.bFlag.bglQD);
  1013. bGoose = (fag_goosecheck_gzqc(sw)) || (tFAg.commerr > 0); // goose判断满足要求,中山通信异常后,BH_GOOSE_EN 不满足要求,不会启动
  1014. poc->sta.bFlag.bglQD = (BH_GOOSE_EN(sw) && poc->tqccd.sta.bFlag.bCD // 故障隔离充电完成
  1015. && (bgl)
  1016. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 // 中山要求联络开关固定
  1017. && (!pSet->bsw_fz) // 中山局要求分支走常规保护逻辑
  1018. #endif
  1019. && !poc->sta.bFlag.bXBbs); // 谐波闭锁
  1020. if (poc->sta.bFlag.bglQD) // 幅值启动
  1021. {
  1022. if (!poc->sta.bFlag.bglQDWave)
  1023. {
  1024. rcd_start(sw, RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); // 录波类型:跳闸类
  1025. poc->sta.bFlag.bglQDWave = true;
  1026. }
  1027. }
  1028. RunTR(&poc->tglQDTime, poc->sta.bFlag.bglQD, dStep);
  1029. RunTR(&poc->tglQD25ms, poc->sta.bFlag.bglQD, dStep);
  1030. // 如果速断时间到,启动时间未到,调用幅值启动加速模块
  1031. if (poc->sta.bFlag.bglQD && poc->tglQDTime.boolTrip && !poc->tglQD25ms.boolTrip)
  1032. {
  1033. if (protect_amp_qd_js(sw))
  1034. {
  1035. // 预置25ms,让下个循环再出口
  1036. PreSetTime(&poc->tglQD25ms, T_25ms);
  1037. }
  1038. }
  1039. bTz = poc->tglQDTime.boolTrip && bGoose // 电流启动
  1040. && poc->tglQD25ms.boolTrip; // 启动后25ms
  1041. RunTR(&poc->tglslowTime, (bTz && pSet->bFA_slow), dStep); // 缓动型,跳闸信息自动延长
  1042. poc->sta.bFlag.bglTz = (bTz && (!pSet->bFA_slow)) // 非缓动型,直接出口
  1043. || (poc->bslowEn && poc->tglslowTime.boolTrip);
  1044. if (poc->sta.bFlag.bglTz) // 启动信息
  1045. {
  1046. int ui_begin;
  1047. DWORD Ia, Ib, Ic;
  1048. ui_begin = UI_SW_INDEX_BEGIN(sw);
  1049. 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);
  1050. 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);
  1051. 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);
  1052. if (soe_check(EV_GOOSE_GL_TZ + sw * EV_SW_NUM) == false) // 过流跳闸
  1053. {
  1054. soe_record_ev(EV_GOOSE_GL_TZ + sw * EV_SW_NUM, 1, Ia, Ib, Ic);
  1055. poc->bglTzLed = true;
  1056. poc->sta.bFlag.bglTzH = true;
  1057. poc->bgooseGz = true;
  1058. }
  1059. if (soe_check(EV_GOOSE_QC_QD + sw * EV_SW_NUM) == false) // 故障隔离启动
  1060. {
  1061. soe_record_ev(EV_GOOSE_QC_QD + sw * EV_SW_NUM, 1, 0, 0, 0);
  1062. }
  1063. }
  1064. else
  1065. {
  1066. if (soe_check(EV_GOOSE_GL_TZ + sw * EV_SW_NUM) == true) // 过流跳闸
  1067. {
  1068. soe_record_ev(EV_GOOSE_GL_TZ + sw * EV_SW_NUM, 0, 0, 0, 0);
  1069. }
  1070. }
  1071. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  1072. // 电流启动
  1073. bgl = OverRelay(g_sw[sw].m2_max, pSet->dIgl2, pSet->dIgl2_fh, poc->sta.bFlag.bgl2QD);
  1074. bGoose = (fag_goosecheck_gzqc(sw)) || (tFAg.commerr > 0); // goose判断满足要求,或通信异常
  1075. poc->sta.bFlag.bgl2QD = (BH_GOOSE_EN(sw) && poc->tqccd.sta.bFlag.bCD // 故障隔离充电完成
  1076. && (bgl) && (!pSet->bsw_fz) // 中山局要求分支走常规保护逻辑
  1077. && !poc->sta.bFlag.bXBbs2); // 谐波闭锁
  1078. if (poc->sta.bFlag.bgl2QD) // 幅值启动
  1079. {
  1080. if (!poc->sta.bFlag.bgl2QDWave)
  1081. {
  1082. rcd_start(sw, RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); // 录波类型:跳闸类
  1083. poc->sta.bFlag.bgl2QDWave = true;
  1084. }
  1085. }
  1086. RunTR(&poc->tgl2QDTime, poc->sta.bFlag.bgl2QD, dStep);
  1087. RunTR(&poc->tgl2QD25ms, poc->sta.bFlag.bgl2QD, dStep);
  1088. // 如果速断时间到,启动时间未到,调用幅值启动加速模块
  1089. if (poc->sta.bFlag.bgl2QD && poc->tgl2QDTime.boolTrip && !poc->tgl2QD25ms.boolTrip)
  1090. {
  1091. if (protect_amp_qd_js(sw))
  1092. {
  1093. // 预置25ms,让下个循环再出口
  1094. PreSetTime(&poc->tgl2QD25ms, T_25ms);
  1095. }
  1096. }
  1097. bTz = poc->tgl2QDTime.boolTrip && bGoose // 电流启动
  1098. && poc->tgl2QD25ms.boolTrip; // 启动后25ms
  1099. RunTR(&poc->tgl2slowTime, (bTz && pSet->bFA_slow), dStep); // 缓动型,跳闸信息自动延长
  1100. poc->sta.bFlag.bgl2Tz = (bTz && (!pSet->bFA_slow)) // 非缓动型,直接出口
  1101. || (poc->bslowEn && poc->tgl2slowTime.boolTrip);
  1102. if (poc->sta.bFlag.bgl2Tz) // 启动信息
  1103. {
  1104. int ui_begin;
  1105. DWORD Ia, Ib, Ic;
  1106. ui_begin = UI_SW_INDEX_BEGIN(sw);
  1107. 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);
  1108. 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);
  1109. 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);
  1110. if (soe_check(EV_GOOSE_GL2_TZ + sw * EV_SW_NUM) == false) // 过流跳闸
  1111. {
  1112. soe_record_ev(EV_GOOSE_GL2_TZ + sw * EV_SW_NUM, 1, Ia, Ib, Ic);
  1113. poc->bglTzLed = true;
  1114. poc->sta.bFlag.bglTzH = true;
  1115. poc->bgooseGz = true;
  1116. }
  1117. if (soe_check(EV_GOOSE_QC_QD + sw * EV_SW_NUM) == false) // 故障隔离启动
  1118. {
  1119. soe_record_ev(EV_GOOSE_QC_QD + sw * EV_SW_NUM, 1, 0, 0, 0);
  1120. }
  1121. }
  1122. else
  1123. {
  1124. if (soe_check(EV_GOOSE_GL2_TZ + sw * EV_SW_NUM) == true) // 过流跳闸
  1125. {
  1126. soe_record_ev(EV_GOOSE_GL2_TZ + sw * EV_SW_NUM, 0, 0, 0, 0);
  1127. }
  1128. }
  1129. #endif
  1130. }
  1131. void fag_oc_lx(int sw, u32 dStep)
  1132. {
  1133. TGOC_T *poc = &g_tRelay[sw].tgoc;
  1134. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  1135. bool blx, bGoose, bTz;
  1136. // 电流启动
  1137. blx = OverRelay(g_ui[UI_SW_INDEX(sw, SW_AC_I0)].m2[0], pSet->dIlx, pSet->dIlx_fh, poc->sta.bFlag.blxQD);
  1138. bGoose = (fag_goosecheck_gzqc(sw)) || (tFAg.commerr > 0); // goose判断满足要求,或通信异常
  1139. poc->sta.bFlag.blxQD = (BH_GOOSE_EN(sw) && poc->tqccd.sta.bFlag.bCD // 故障隔离充电完成
  1140. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 // 中山要求联络开关固定
  1141. && (!pSet->bsw_fz) // 中山局要求分支走常规保护逻辑
  1142. #endif
  1143. && (blx));
  1144. if (poc->sta.bFlag.blxQD) // 幅值启动
  1145. {
  1146. if (!poc->sta.bFlag.blxQDWave)
  1147. {
  1148. rcd_start(sw, RECORD_TYPE_LXGL, RECORD_LEN_TZQD); // 录波类型:跳闸类
  1149. poc->sta.bFlag.blxQDWave = true;
  1150. }
  1151. }
  1152. RunTR(&poc->tlxQDTime, poc->sta.bFlag.blxQD, dStep);
  1153. RunTR(&poc->tlxQD25ms, poc->sta.bFlag.blxQD, dStep);
  1154. // 如果速断时间到,启动时间未到,调用幅值启动加速模块
  1155. if (poc->sta.bFlag.blxQD && poc->tlxQDTime.boolTrip && !poc->tlxQD25ms.boolTrip)
  1156. {
  1157. if (protect_amp_lx_js(sw))
  1158. {
  1159. // 预置25ms,让下个循环再出口
  1160. PreSetTime(&poc->tlxQD25ms, T_25ms);
  1161. }
  1162. }
  1163. bTz = poc->tlxQDTime.boolTrip && bGoose // 电流启动
  1164. && poc->tlxQD25ms.boolTrip; // 启动后25ms
  1165. RunTR(&poc->tlxslowTime, (bTz && pSet->bFA_slow), dStep); // 缓动型,跳闸信息自动延长
  1166. poc->sta.bFlag.blxTz = (bTz && (!pSet->bFA_slow)) // 非缓动型,直接出口
  1167. || (poc->bslowEn && poc->tlxslowTime.boolTrip);
  1168. if (poc->sta.bFlag.blxTz) // 启动信息
  1169. {
  1170. int ui_begin;
  1171. DWORD I0;
  1172. ui_begin = UI_SW_INDEX_BEGIN(sw);
  1173. 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);
  1174. if (soe_check(EV_GOOSE_LX_TZ + sw * EV_SW_NUM) == false) // 零序跳闸
  1175. {
  1176. soe_record_ev(EV_GOOSE_LX_TZ + sw * EV_SW_NUM, 1, I0, 0, 0);
  1177. poc->blxTzLed = true;
  1178. poc->sta.bFlag.blxTzH = true;
  1179. poc->bgooseGz = true;
  1180. }
  1181. if (soe_check(EV_GOOSE_QC_QD + sw * EV_SW_NUM) == false) // 故障切除启动
  1182. {
  1183. soe_record_ev(EV_GOOSE_QC_QD + sw * EV_SW_NUM, 1, 0, 0, 0);
  1184. }
  1185. }
  1186. else
  1187. {
  1188. if (soe_check(EV_GOOSE_LX_TZ + sw * EV_SW_NUM) == true) // 零序跳闸
  1189. {
  1190. soe_record_ev(EV_GOOSE_LX_TZ + sw * EV_SW_NUM, 0, 0, 0, 0);
  1191. }
  1192. }
  1193. }
  1194. // 缓动型故障扩展发送时间,需大于变电站出口时间,保证无压无流后,领域故障还存在
  1195. void fag_gzgl(int sw, DWORD dStep) // 故障隔离
  1196. {
  1197. TRELAY_T *pR = &g_tRelay[sw];
  1198. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  1199. TGOC_T *poc = &pR->tgoc;
  1200. UGOOSE_STU *pg;
  1201. bool bY1, bY2, bGoose, bfztz;
  1202. int i;
  1203. bool bWY1, bWY2; // 无压判断
  1204. bWY1 = LowRelay(g_sw_pub.m2_max[2], pRunSet->tSwSet[sw].dU_fa_WY, pRunSet->tSwSet[sw].dU_fa_WY_fh, false); // 无压
  1205. bWY2 = LowRelay(g_sw_pub.m2_max[3], pRunSet->tSwSet[sw].dU_fa_WY, pRunSet->tSwSet[sw].dU_fa_WY_fh, false);
  1206. bY1 = false;
  1207. for (i = 0; i < GOOSE_EQU_MAX; i++) // 邻域有故障产生
  1208. {
  1209. pg = &tFAg.ugside[i];
  1210. bY1 |= (pg->bFlag.bgl | pg->bFlag.blx | pg->bFlag.bzx | pg->bFlag.bfx | pg->bFlag.bglbs | pg->bFlag.blxbs);
  1211. }
  1212. bfztz = (!pSet->bsw_fz) || pSet->bTT_mxTfz; // 非分支或分支线且母线故障跳分支未投入
  1213. bY2 = (BH_GOOSE_EN(sw)) && bfztz && bY1 // 邻域有故障产生
  1214. && poc->bslowEn // 缓动型,需无压无流,速动自动满足
  1215. && pR->tSWST.uSWST.bFlag.bHZWZ // 在合闸位置
  1216. && pR->tgoc.tglcd.sta.bFlag.bCD; // 充电完成,无放电条件
  1217. RunTR(&poc->tgoose15ms_gzgl, bY2, dStep); // 电流启动 15ms后,goose 判断有效
  1218. bGoose = fag_goosecheck_gzgl(sw) && poc->tgoose15ms_gzgl.boolTrip && (tFAg.commerr == 0); // 故障隔离,通信正常时处理,异常,靠失压跳闸
  1219. if (poc->tgoose15ms_gzgl.boolTrip && !poc->sta.bFlag.bgzglQD) // goose 判断时间到,若条件不满足,放电,防止邻域开关故障撤销后,由于发送间隔问题,goose条件又满足导致误动
  1220. {
  1221. if (!bGoose) // 外部条件不满足
  1222. {
  1223. pR->tgoc.tglcd.sta.bFlag.bCD = false;
  1224. ResetTR(&poc->tglcd.tCDTime);
  1225. }
  1226. }
  1227. #ifdef GD_AREA_ZHONGSHAN_2020 // 中山要求,动作后,通信异常不起作用,继续动作
  1228. poc->sta.bFlag.bgzglQD = ((bGoose && bY2) || poc->sta.bFlag.bgzglQD) && bWY1 && bWY2; // 故障隔离启动, 增加无压条件
  1229. #else
  1230. poc->sta.bFlag.bgzglQD = ((bGoose && bY2) || poc->sta.bFlag.bgzglQD) && pR->tgoc.tglcd.sta.bFlag.bCD && bWY1 && bWY2; // 故障隔离启动, 增加无压条件
  1231. #endif
  1232. RunTR(&poc->tgzglTime, poc->sta.bFlag.bgzglQD, dStep); // 故障隔离时间到,出口
  1233. poc->sta.bFlag.bgzglTz = poc->tgzglTime.boolTrip; // 故障隔离启动
  1234. if (poc->sta.bFlag.bgzglTz)
  1235. {
  1236. if (soe_check(EV_GOOSE_GL_QD + sw * EV_SW_NUM) == false) // 故障隔离启动
  1237. {
  1238. soe_record_ev(EV_GOOSE_GL_QD + sw * EV_SW_NUM, 1, 0, 0, 0);
  1239. }
  1240. poc->bgzglTzLed = true;
  1241. poc->sta.bFlag.bgzglTzH = true;
  1242. poc->sta.bFlag.bgzglQD = false;
  1243. poc->bgooseGz = true;
  1244. }
  1245. }
  1246. void fag_lostvol_sd(int sw, DWORD dStep) // 首端开关失压跳闸
  1247. {
  1248. TRELAY_T *pR = &g_tRelay[sw];
  1249. TGOC_T *poc = &pR->tgoc;
  1250. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  1251. bool bWY1, bWY2, bEnble;
  1252. /***********启动 **********************************/
  1253. bWY1 = LowRelay(g_sw_pub.m2_max[2], pRunSet->tSwSet[sw].dU_fa_WY, pRunSet->tSwSet[sw].dU_fa_WY_fh, poc->sta.bFlag.bsdQD); // 无压
  1254. bWY2 = LowRelay(g_sw_pub.m2_max[3], pRunSet->tSwSet[sw].dU_fa_WY, pRunSet->tSwSet[sw].dU_fa_WY_fh, poc->sta.bFlag.bsdQD);
  1255. #ifdef GD_AREA_ZHONGSHAN_2020 // 中山要求,动作后,通信异常不起作用,继续动作
  1256. bEnble = (pSet->bTT_sdlost && pSet->bsw_sd); // 首端开关,失压投退投入,无通信异常
  1257. poc->sta.bFlag.bsdQD = bEnble && (BH_GOOSE_EN_YB(sw)) && (tFAg.bComErr == 0 || poc->sta.bFlag.bsdQD) && pR->tgoc.psta.bFlag.bCYY // 曾有压
  1258. && pR->tSWST.uSWST.bFlag.bHZWZ // 在合闸位置
  1259. && pR->tSWST.uSWST.bFlag.bSXWL // 三相无流;
  1260. && (poc->tqccd.sta.bFlag.bCD || poc->sta.bFlag.bsdQD) && bWY1 && bWY2;
  1261. #else
  1262. bEnble = (pSet->bTT_sdlost && pSet->bsw_sd && (tFAg.commerr == 0)); // 首端开关,失压投退投入,无通信异常
  1263. poc->sta.bFlag.bsdQD = bEnble && (BH_GOOSE_EN(sw)) && pR->tgoc.psta.bFlag.bCYY // 曾有压
  1264. && pR->tSWST.uSWST.bFlag.bHZWZ // 在合闸位置
  1265. && pR->tSWST.uSWST.bFlag.bSXWL // 三相无流;
  1266. && poc->tqccd.sta.bFlag.bCD && bWY1 && bWY2;
  1267. #endif
  1268. /***********失压分闸*********************************/
  1269. RunTR(&poc->tsdlostTime, poc->sta.bFlag.bsdQD, dStep);
  1270. poc->sta.bFlag.bsdTz = poc->tsdlostTime.boolTrip;
  1271. if (poc->sta.bFlag.bsdTz) // 启动信息
  1272. {
  1273. if (soe_check(EV_GOOSE_SDLOST_TZ + sw * EV_SW_NUM) == false) // 故障隔离启动
  1274. {
  1275. soe_record_ev(EV_GOOSE_SDLOST_TZ + sw * EV_SW_NUM, 1, 0, 0, 0);
  1276. }
  1277. if (soe_check(EV_GOOSE_GL_QD + sw * EV_SW_NUM) == false) // 故障隔离启动
  1278. {
  1279. soe_record_ev(EV_GOOSE_GL_QD + sw * EV_SW_NUM, 1, 0, 0, 0);
  1280. }
  1281. poc->bsdTzLed = true;
  1282. poc->sta.bFlag.bsdTzH = true;
  1283. pR->tgoc.psta.bFlag.bCYY = false;
  1284. poc->bgooseGz = true;
  1285. ResetTR(&pR->tgoc.tCYY3sdelayms);
  1286. }
  1287. else
  1288. {
  1289. if (soe_check(EV_GOOSE_SDLOST_TZ + sw * EV_SW_NUM) == true) // 故障隔离启动
  1290. {
  1291. soe_record_ev(EV_GOOSE_SDLOST_TZ + sw * EV_SW_NUM, 0, 0, 0, 0);
  1292. }
  1293. }
  1294. }
  1295. void fag_lostvol_commer(int sw, DWORD dStep) // 通信异常失压跳闸
  1296. {
  1297. TRELAY_T *pR = &g_tRelay[sw];
  1298. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  1299. TGOC_T *poc = &pR->tgoc;
  1300. bool bWY1, bWY2, bEnble;
  1301. bool bfztz;
  1302. /***********启动 **********************************/
  1303. bWY1 = LowRelay(g_sw_pub.m2_max[2], pRunSet->tSwSet[sw].dU_fa_WY, pRunSet->tSwSet[sw].dU_fa_WY_fh, poc->sta.bFlag.berrQD); // 无压
  1304. bWY2 = LowRelay(g_sw_pub.m2_max[3], pRunSet->tSwSet[sw].dU_fa_WY, pRunSet->tSwSet[sw].dU_fa_WY_fh, poc->sta.bFlag.berrQD);
  1305. bEnble = (tFAg.commerr > 0); // 通信异常,失压跳闸
  1306. bfztz = (!pSet->bsw_fz) || pSet->bTT_mxTfz; // 非分支或分支线且母线故障跳分支未投入
  1307. poc->sta.bFlag.berrQD = bEnble && bfztz && (BH_GOOSE_EN(sw)) && pR->tgoc.psta.bFlag.bCYY // 曾有压
  1308. && pR->tSWST.uSWST.bFlag.bHZWZ // 在合闸位置
  1309. && pR->tSWST.uSWST.bFlag.bSXWL // 三相无流;
  1310. && bWY1 && bWY2;
  1311. /***********失压分闸*********************************/
  1312. RunTR(&poc->terrlostTime, poc->sta.bFlag.berrQD, dStep);
  1313. poc->sta.bFlag.berrTz = poc->terrlostTime.boolTrip;
  1314. if (poc->sta.bFlag.berrTz) // 启动信息
  1315. {
  1316. if (soe_check(EV_GOOSE_ERRLOST_TZ + sw * EV_SW_NUM) == false) // 失压跳闸
  1317. {
  1318. soe_record_ev(EV_GOOSE_ERRLOST_TZ + sw * EV_SW_NUM, 1, 0, 0, 0);
  1319. }
  1320. if (soe_check(EV_GOOSE_GL_QD + sw * EV_SW_NUM) == false) // 故障隔离启动
  1321. {
  1322. soe_record_ev(EV_GOOSE_GL_QD + sw * EV_SW_NUM, 1, 0, 0, 0);
  1323. }
  1324. poc->berrTzLed = true;
  1325. poc->sta.bFlag.berrTzH = true;
  1326. pR->tgoc.psta.bFlag.bCYY = false;
  1327. poc->bgooseGz = true;
  1328. ResetTR(&pR->tgoc.tCYY3sdelayms);
  1329. }
  1330. else
  1331. {
  1332. if (soe_check(EV_GOOSE_ERRLOST_TZ + sw * EV_SW_NUM) == true) // 失压跳闸
  1333. {
  1334. soe_record_ev(EV_GOOSE_ERRLOST_TZ + sw * EV_SW_NUM, 0, 0, 0, 0);
  1335. }
  1336. }
  1337. }
  1338. void fag_exttz(int sw, DWORD dStep) // 下级开关跳闸失败,本级开关跳闸
  1339. {
  1340. TGOC_T *poc = &g_tRelay[sw].tgoc;
  1341. GOC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet;
  1342. UGOOSE_STU *pg;
  1343. bool btzsb = false;
  1344. bool bfztz;
  1345. int i;
  1346. bool bgzgl;
  1347. for (i = 0; i < GOOSE_EQU_MAX; i++)
  1348. {
  1349. pg = &tFAg.ugside[i];
  1350. btzsb |= (pg->bFlag.btzsb); // 相邻开关有跳闸失败
  1351. }
  1352. bgzgl = fag_goosecheck_gzgl(sw) && (!pSet->bsw_sd) && (!pSet->bsw_fz);
  1353. bfztz = (!pSet->bsw_fz) || pSet->bTT_mxTfz; // 非分支或分支线且母线故障跳分支未投入
  1354. RunTR(&poc->textbsTime, btzsb && bgzgl, dStep); // 缓动型,跳闸信息自动延长
  1355. poc->sta.bFlag.bextQD = btzsb // 相邻线路有开关跳闸失败
  1356. && !poc->textbsTime.boolTrip && (tFAg.commerr == 0) // 通信正常
  1357. && bfztz && (BH_GOOSE_EN(sw)) && g_tRelay[sw].tSWST.uSWST.bFlag.bHZWZ && poc->bslowEn // 缓动 无压无流 速动,自动满足
  1358. && !poc->psta.bFlag.btzsb;
  1359. poc->sta.bFlag.bextTz = poc->sta.bFlag.bextQD;
  1360. if (poc->sta.bFlag.bextTz)
  1361. {
  1362. if (soe_check(EV_GOOSE_EXT_TZ + sw * EV_SW_NUM) == false) // 保护总
  1363. {
  1364. soe_record_ev(EV_GOOSE_EXT_TZ + sw * EV_SW_NUM, 1, 0, 0, 0);
  1365. #ifdef GD_AREA_ZHONGSHAN_2020
  1366. g_tRelay[i].run_stu.fgbs = 1; // 该SOE返回太快,需直接赋值
  1367. #endif
  1368. }
  1369. poc->sta.bFlag.bextTzH = true;
  1370. poc->bgooseGz = true;
  1371. }
  1372. else
  1373. {
  1374. if (soe_check(EV_GOOSE_EXT_TZ + sw * EV_SW_NUM) == true) // 保护总
  1375. {
  1376. soe_record_ev(EV_GOOSE_EXT_TZ + sw * EV_SW_NUM, 0, 0, 0, 0);
  1377. }
  1378. }
  1379. }
  1380. // 两侧有压,开关在分位,确认联络开关有效,
  1381. // 单侧失压后,判合闸条件,条件满足,合联络开关,恢复供电,重新确认联络开关位置
  1382. void fag_ll(int sw, DWORD dStep) // 联络开关逻辑处理
  1383. {
  1384. TRELAY_T *pR = &g_tRelay[sw];
  1385. TSETSW *pSet = &pRunSet->tSwSet[sw];
  1386. TGOC_T *poc = &pR->tgoc;
  1387. bool bY1, bQD;
  1388. bool bWY1, bWY2;
  1389. bool bYY1, bYY2, bllYY;
  1390. bool bLstQD = false;
  1391. // 有压检测
  1392. bWY1 = LowRelay(g_sw_pub.m2_max[2], pSet->dU_fa_WY, pSet->dU_fa_WY_fh, poc->psta.bFlag.bllWY1); // 无压
  1393. bWY2 = LowRelay(g_sw_pub.m2_max[3], pSet->dU_fa_WY, pSet->dU_fa_WY_fh, poc->psta.bFlag.bllWY2);
  1394. bYY1 = OverRelay(g_sw_pub.m2_max[2], pSet->dU_fa_YY, pSet->dU_fa_YY_fh, poc->psta.bFlag.bYY1); // 有压
  1395. bYY2 = OverRelay(g_sw_pub.m2_max[3], pSet->dU_fa_YY, pSet->dU_fa_YY_fh, poc->psta.bFlag.bYY2);
  1396. RunTR(&poc->tllWY1Time, bWY1, dStep);
  1397. RunTR(&poc->tllWY2Time, bWY2, dStep);
  1398. RunTR(&poc->tllYY1Time, bYY1, dStep);
  1399. RunTR(&poc->tllYY2Time, bYY2, dStep);
  1400. poc->psta.bFlag.bllWY1 = poc->tllWY1Time.boolTrip;
  1401. poc->psta.bFlag.bllWY2 = poc->tllWY2Time.boolTrip;
  1402. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 // 中山要求联络开关固定,并且单侧失压后报联络合闸失败
  1403. bLstQD = pSet->tGocSet.bTT_ll // 联络开关投入
  1404. && (BH_GOOSE_EN(sw)) // 智能分布式已投入
  1405. #ifdef GD_AREA_ZHONGSHAN
  1406. && pSet->tGocSet.bsw_ll
  1407. #endif
  1408. && (poc->psta.bFlag.bllWY1 ^ poc->psta.bFlag.bllWY2) // 单侧失压
  1409. && pR->tSWST.uSWST.bFlag.bTZWZ; // 开关跳位
  1410. #endif
  1411. bllYY = poc->tllYY1Time.boolTrip && poc->tllYY2Time.boolTrip;
  1412. poc->sta.bFlag.bllWY_1 = ((bLstQD && bllYY) || poc->sta.bFlag.bllWY_1) && bLstQD;
  1413. RunTR(&poc->tllQdTime, poc->sta.bFlag.bllWY_1, dStep); // 双侧有压后,又单侧失压,超过联络合闸时间,报联络合闸不满足
  1414. bQD = pSet->tGocSet.bTT_ll // 联络开关投入
  1415. #ifdef GD_AREA_ZHONGSHAN_2020 // 中山要求联络开关固定
  1416. && (poc->tllcd.sta.bFlag.bCD || poc->sta.bFlag.bllQD) // 联络开关充电完成
  1417. //&&pSet->tGocSet.bsw_ll
  1418. && (BH_GOOSE_EN_YB(sw)) // 智能分布式已投入
  1419. && (tFAg.bComErr == 0 || poc->sta.bFlag.bllQD) // 联络启动后,自保持,通信异常不退出动作逻辑
  1420. #else
  1421. && poc->tllcd.sta.bFlag.bCD // 联络开关充电完成
  1422. && (BH_GOOSE_EN(sw)) // 智能分布式已投入
  1423. #endif
  1424. && (poc->psta.bFlag.bllWY1 ^ poc->psta.bFlag.bllWY2) // 单侧失压
  1425. && pR->tSWST.uSWST.bFlag.bTZWZ; // 开关跳位
  1426. RunTR(&poc->tgoosedelayms_ll, bQD, dStep); // 联络失压后启动
  1427. bY1 = bQD // 单侧失压,联络启动条件满足
  1428. && (!poc->tgoosedelayms_ll.boolTrip) // 在失压后300ms内
  1429. && !poc->b_side_gz // 领域无故障
  1430. && fag_goosecheck_ll(sw); // 收到故障隔离信号
  1431. poc->sta.bFlag.bllQD = (bY1 || poc->sta.bFlag.bllQD) && bQD && !poc->b_side_tzsb; // 联络启动后,自保持
  1432. RunTR(&poc->tllhzTime, poc->sta.bFlag.bllQD, dStep); // Y确认时间后,失压可合闸
  1433. poc->sta.bFlag.bllhz = poc->tllhzTime.boolTrip;
  1434. if (poc->sta.bFlag.bllhz) // 启动信息
  1435. {
  1436. if (soe_check(EV_GOOSE_HZ_QD + sw * EV_SW_NUM) == false) // 联络合闸启动
  1437. {
  1438. soe_record_ev(EV_GOOSE_HZ_QD + sw * EV_SW_NUM, 1, 0, 0, 0);
  1439. }
  1440. sw_do(sw, SW_DO_BHH, SW_DO_TYPE_ON);
  1441. poc->sta.bFlag.bllhzH = true;
  1442. ResetTR(&poc->tllQdTime);
  1443. poc->sta.bFlag.bllWY_1 = false;
  1444. }
  1445. else
  1446. {
  1447. if (soe_check(EV_GOOSE_HZ_QD + sw * EV_SW_NUM) == true) // 联络合闸启动返回
  1448. {
  1449. soe_record_ev(EV_GOOSE_HZ_QD + sw * EV_SW_NUM, 0, 0, 0, 0);
  1450. }
  1451. }
  1452. if (poc->tllQdTime.boolTrip) // 联络失压后合闸不满足
  1453. {
  1454. if (soe_check(EV_GOOSE_LL_UNOK + sw * EV_SW_NUM) == false) //
  1455. {
  1456. soe_record_ev(EV_GOOSE_LL_UNOK + sw * EV_SW_NUM, 1, 0, 0, 0);
  1457. }
  1458. ResetTR(&poc->tllQdTime);
  1459. ResetTR(&poc->tllcd.tCDTime);
  1460. poc->sta.bFlag.bllWY_1 = false;
  1461. poc->tllcd.sta.bFlag.bCD = false;
  1462. }
  1463. if (poc->tllcd.sta.bFlag.bCD || pR->tSWST.uSWST.bFlag.bHZWZ)
  1464. {
  1465. if (soe_check(EV_GOOSE_LL_UNOK + sw * EV_SW_NUM) == true) //
  1466. {
  1467. soe_record_ev(EV_GOOSE_LL_UNOK + sw * EV_SW_NUM, 0, 0, 0, 0);
  1468. }
  1469. }
  1470. RunTR(&poc->tHzcheckTime, poc->sta.bFlag.bllhzH, dStep); //
  1471. if (poc->tHzcheckTime.boolTrip) // 跳闸失败时间到,清标志,报soe
  1472. {
  1473. if (pR->tSWST.uSWST.bFlag.bTZWZ) // 合闸闸失败
  1474. {
  1475. if (soe_check(EV_GOOSE_HZ_FAIL + sw * EV_SW_NUM) == false) //
  1476. {
  1477. soe_record_ev(EV_GOOSE_HZ_FAIL + sw * EV_SW_NUM, 1, 0, 0, 0); // 联络合闸失败
  1478. }
  1479. }
  1480. else // 跳闸成功
  1481. {
  1482. if (soe_check(EV_GOOSE_HZ_OK + sw * EV_SW_NUM) == false) // 联络合闸成功
  1483. {
  1484. soe_record_ev(EV_GOOSE_HZ_OK + sw * EV_SW_NUM, 1, 0, 0, 0);
  1485. }
  1486. }
  1487. poc->sta.bFlag.bllhzH = false;
  1488. }
  1489. }
  1490. #ifdef GD_AREA_ZHONGSHAN_2020
  1491. void fag_oc_acc(int sw, u32 dStep) // 分布式合闸加速跳闸
  1492. {
  1493. bool bQDD;
  1494. bool bJS3, bJS4, bJS5;
  1495. bool bY1, bY2;
  1496. int ui_begin;
  1497. int oc;
  1498. ui_begin = UI_SW_INDEX_BEGIN(sw);
  1499. for (oc = FAG_GL1; oc < FAG_BHNUMBER; oc++)
  1500. {
  1501. TOC_T *poc = &g_tRelay[sw].tgoc.tOc[oc];
  1502. OC_SET *pSet = &pRunSet->tSwSet[sw].tGocSet.tOc[oc];
  1503. u16 soeno = EV_GOOSE_HZ_GL1 + oc + sw * EV_SW_NUM;
  1504. bool bgloc = (oc == FAG_LX) ? false : true;
  1505. bool bxbbs = false;
  1506. // 电流启动
  1507. if (bgloc)
  1508. {
  1509. bool bxb;
  1510. DWORD xbcoe; // 谐波系数
  1511. bxb = pRunSet->tSwSet[sw].bTT_goose_xbbs;
  1512. xbcoe = pRunSet->tSwSet[sw].d_goose_xbcoe;
  1513. poc->sta.bFlag.bIaQD = OverRelay(g_ui[ui_begin + SW_AC_IA].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIaQD);
  1514. poc->sta.bFlag.bIbQD = OverRelay(g_ui[ui_begin + SW_AC_IB].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIbQD);
  1515. poc->sta.bFlag.bIcQD = OverRelay(g_ui[ui_begin + SW_AC_IC].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIcQD);
  1516. poc->sta.bFlag.bIaxb = bxb && XBCalc(sw, SW_AC_IA, xbcoe, poc->sta.bFlag.bIaQD);
  1517. poc->sta.bFlag.bIbxb = bxb && XBCalc(sw, SW_AC_IB, xbcoe, poc->sta.bFlag.bIbQD);
  1518. poc->sta.bFlag.bIcxb = bxb && XBCalc(sw, SW_AC_IC, xbcoe, poc->sta.bFlag.bIcQD);
  1519. bQDD = poc->sta.bFlag.bIaQD || poc->sta.bFlag.bIbQD || poc->sta.bFlag.bIcQD;
  1520. bxbbs = poc->sta.bFlag.bIaxb || poc->sta.bFlag.bIbxb || poc->sta.bFlag.bIcxb; // 谐波闭锁
  1521. }
  1522. else // 零序加速
  1523. {
  1524. // 零序电流过量继电器
  1525. bY1 = OverRelay(g_ui[UI_SW_INDEX(sw, SW_AC_I0)].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD);
  1526. bY2 = true;
  1527. bQDD = bY1 && ((bY2 && pRunSet->bTT_U0BS) || (!pRunSet->bTT_U0BS));
  1528. bxbbs = false;
  1529. }
  1530. // 检查合闸加速标
  1531. bJS3 = g_tRelay[sw].tSWST.uSWST.bFlag.bSHJS; // 手合加速标
  1532. poc->sta.bFlag.bQD = (BH_GOOSE_EN_YB(sw)) && (!pRunSet->tSwSet[sw].tGocSet.bsw_fz) && bQDD && (!bxbbs); // 谐波闭锁
  1533. // 加速标保持
  1534. bJS4 = bJS3 || poc->sta.bFlag.bJSBC;
  1535. // 后加速启动条件满足
  1536. bJS5 = poc->sta.bFlag.bQD && bJS4;
  1537. // 合闸加速标保持
  1538. poc->sta.bFlag.bJSBC = bJS5 && bJS4;
  1539. if (bJS5) // 幅值启动
  1540. {
  1541. if (!poc->sta.bFlag.bQDWave)
  1542. {
  1543. if (bgloc)
  1544. {
  1545. rcd_start(sw, RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); // 录波类型:跳闸类
  1546. }
  1547. else
  1548. {
  1549. rcd_start(sw, RECORD_TYPE_LXGL, RECORD_LEN_TZQD); // 录波类型:跳闸类
  1550. }
  1551. poc->sta.bFlag.bQDWave = true;
  1552. }
  1553. }
  1554. else
  1555. {
  1556. poc->sta.bFlag.bQDWave = true;
  1557. }
  1558. RunTR(&poc->tQDTime, bJS5, dStep);
  1559. RunTR(&poc->tQD25ms, bJS5, dStep);
  1560. // 如果加速时间到,启动时间未到,调用幅值启动加速模块
  1561. if (poc->sta.bFlag.bQD && poc->tQDTime.boolTrip && !poc->tQD25ms.boolTrip)
  1562. {
  1563. if (bgloc)
  1564. {
  1565. if (protect_amp_qd_js(sw))
  1566. {
  1567. // 预置25ms,让下个循环再出口
  1568. PreSetTime(&poc->tQD25ms, T_25ms);
  1569. }
  1570. }
  1571. else
  1572. {
  1573. if (protect_amp_lx_js(sw))
  1574. {
  1575. // 预置25ms,让下个循环再出口
  1576. PreSetTime(&poc->tQD25ms, T_25ms);
  1577. }
  1578. }
  1579. }
  1580. poc->sta.bFlag.bTz = poc->tQDTime.boolTrip && poc->tQD25ms.boolTrip;
  1581. // 出口记录及出口
  1582. if (poc->sta.bFlag.bTz)
  1583. {
  1584. if (bgloc)
  1585. {
  1586. int ui_begin;
  1587. DWORD Ia, Ib, Ic;
  1588. ui_begin = UI_SW_INDEX_BEGIN(sw);
  1589. 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);
  1590. 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);
  1591. 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);
  1592. if (soe_check(soeno) == false) // 过流跳闸
  1593. {
  1594. soe_record_ev(soeno, 1, Ia, Ib, Ic);
  1595. poc->sta.bFlag.bDzLed = true;
  1596. g_tRelay[sw].tgoc.bgooseGz = true;
  1597. }
  1598. }
  1599. else // 零序加速
  1600. {
  1601. // 出口记录及出口
  1602. if (poc->sta.bFlag.bTz)
  1603. {
  1604. int ui_begin;
  1605. DWORD I0;
  1606. ui_begin = UI_SW_INDEX_BEGIN(sw);
  1607. 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);
  1608. if (soe_check(soeno) == false) // 零序跳闸
  1609. {
  1610. soe_record_ev(soeno, 1, I0, 0, 0);
  1611. poc->sta.bFlag.bDzLed = true;
  1612. g_tRelay[sw].tgoc.bgooseGz = true;
  1613. }
  1614. if (soe_check(soeno) == false) // 故障切除启动
  1615. {
  1616. soe_record_ev(soeno, 1, 0, 0, 0);
  1617. }
  1618. }
  1619. }
  1620. }
  1621. else
  1622. {
  1623. if (soe_check(soeno) == true) // 过流跳闸
  1624. {
  1625. soe_record_ev(soeno, 0, 0, 0, 0);
  1626. }
  1627. }
  1628. }
  1629. }
  1630. #endif
  1631. void fag_kc(int sw, DWORD dStep) // goose开出
  1632. {
  1633. TRELAY_T *pR = &g_tRelay[sw];
  1634. TGOC_T *poc = &g_tRelay[sw].tgoc;
  1635. bool bTz;
  1636. bool bCur;
  1637. bool bgzglok = false;
  1638. bool btzsb = false;
  1639. bTz = poc->sta.bFlag.bglTzH || poc->sta.bFlag.blxTzH || poc->sta.bFlag.bgzglTzH || poc->sta.bFlag.bsdTzH || poc->sta.bFlag.bextTzH || poc->sta.bFlag.berrTzH;
  1640. // 有跳闸信号时,可由大电流闭锁不动作,
  1641. // 无闭锁时,需保证一次动作信号仅一次出口
  1642. if (bTz && !pR->bBSTZ && !poc->bTzout)
  1643. {
  1644. sw_do(sw, SW_DO_BHH, SW_DO_TYPE_OFF);
  1645. sw_do(sw, SW_DO_BHDZ, SW_DO_TYPE_ON);
  1646. sw_do(sw, SW_DO_BHT, SW_DO_TYPE_ON);
  1647. poc->bTzout = true;
  1648. }
  1649. // 跳闸失败检查: 跳闸后持续有流或合位
  1650. bCur = ((!pR->tSWST.uSWST.bFlag.bSXWL) || pR->tSWST.uSWST.bFlag.bHZWZ);
  1651. RunTR(&poc->tTzcheckTime, bTz, dStep); //
  1652. if (poc->tTzcheckTime.boolTrip) // 跳闸失败时间到,清标志,报soe
  1653. {
  1654. if (bCur) // 跳闸失败
  1655. {
  1656. bTz = poc->sta.bFlag.bglTzH || poc->sta.bFlag.blxTzH || poc->sta.bFlag.bgzglTzH || poc->sta.bFlag.bsdTzH || poc->sta.bFlag.berrTzH;
  1657. if (poc->sta.bFlag.bglTzH || poc->sta.bFlag.blxTzH || poc->psta.bFlag.bGZ) // 故障切除
  1658. {
  1659. if (soe_check(EV_GOOSE_QC_FAIL + sw * EV_SW_NUM) == false)
  1660. {
  1661. soe_record_ev(EV_GOOSE_QC_FAIL + sw * EV_SW_NUM, 1, 0, 0, 0); // 故障切除失败
  1662. }
  1663. }
  1664. else
  1665. {
  1666. if (soe_check(EV_GOOSE_GL_FAIL + sw * EV_SW_NUM) == false) //
  1667. {
  1668. soe_record_ev(EV_GOOSE_GL_FAIL + sw * EV_SW_NUM, 1, 0, 0, 0); // 故障隔离失败
  1669. }
  1670. }
  1671. if (bTz)
  1672. btzsb = true; // 开关失灵引起的跳闸失败,不再发送
  1673. }
  1674. else // 跳闸成功
  1675. {
  1676. if (poc->sta.bFlag.bglTzH || poc->sta.bFlag.blxTzH || poc->psta.bFlag.bGZ)
  1677. {
  1678. if (soe_check(EV_GOOSE_QC_OK + sw * EV_SW_NUM) == false) // 故障切除
  1679. {
  1680. soe_record_ev(EV_GOOSE_QC_OK + sw * EV_SW_NUM, 1, 0, 0, 0);
  1681. }
  1682. }
  1683. else
  1684. {
  1685. if (soe_check(EV_GOOSE_GL_OK + sw * EV_SW_NUM) == false) // 故障隔离成功
  1686. {
  1687. soe_record_ev(EV_GOOSE_GL_OK + sw * EV_SW_NUM, 1, 0, 0, 0);
  1688. }
  1689. bgzglok = true && (!pRunSet->tSwSet[sw].tGocSet.bsw_fz); // 分支开关不发送故障隔离成功信号
  1690. }
  1691. }
  1692. poc->bTzout = false;
  1693. poc->sta.bFlag.bglTzH = false;
  1694. poc->sta.bFlag.blxTzH = false;
  1695. poc->sta.bFlag.bgzglTzH = false;
  1696. poc->sta.bFlag.bsdTzH = false;
  1697. poc->sta.bFlag.bextTzH = false;
  1698. poc->sta.bFlag.berrTzH = false;
  1699. ResetTR(&poc->tTzcheckTime);
  1700. }
  1701. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 // 中山要求联络开关固定
  1702. btzsb |= (pR->uBHDZ.bFlag.bTZSB && pRunSet->tSwSet[sw].tGocSet.bsw_fz); // 分支开关动作逻辑在常规保护中处理
  1703. #endif
  1704. RunTR(&poc->tgzglokextTime, bgzglok, dStep); // 故障隔离成功发送
  1705. poc->psta.bFlag.bgzglok = poc->tgzglokextTime.boolTrip;
  1706. RunTR(&poc->ttzsbextTime, btzsb, dStep); // 跳闸失败发送展宽时间
  1707. poc->psta.bFlag.btzsb = poc->ttzsbextTime.boolTrip;
  1708. RunTR(&poc->tgzglokForbitTime, poc->psta.bFlag.bgzglok, dStep); // 故障隔离发送闭锁
  1709. }
  1710. void fag_bh(int sw, DWORD dStep)
  1711. {
  1712. tFAg.bComErr = (tFAg.commerr > 0 || tFAg.syscomerr > 0) ? true : false; // goose 通信异常 本机和系统通信异常
  1713. GOC_dir_check(sw, dStep);
  1714. fag_cd(sw, dStep); //
  1715. fag_gzgl(sw, dStep); //
  1716. fag_lostvol_sd(sw, dStep); //
  1717. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 // 中山地区,不需要通信失压分闸
  1718. #else
  1719. fag_lostvol_commer(sw, dStep); //
  1720. #endif
  1721. fag_exttz(sw, dStep); //
  1722. fag_ll(sw, dStep); //
  1723. fag_kc(sw, dStep); //
  1724. fa_g_commcheck(dStep); // goose信息延时复归
  1725. }
  1726. bool _XB2_Logic_Relay(int sw, DWORD I, DWORD Ixb2, DWORD XBcoe, DWORD Iset)
  1727. {
  1728. if ((I > Iset) && (Ixb2 > pRunSet->dIWL_SQR[sw])) // I 与 Ixb2 均应大于无流定值
  1729. {
  1730. if (Ixb2 > _MulFac_U(I, XBcoe))
  1731. {
  1732. return (true);
  1733. }
  1734. else
  1735. {
  1736. return (false);
  1737. }
  1738. }
  1739. else
  1740. {
  1741. return (false);
  1742. }
  1743. return 0;
  1744. }
  1745. /******************************************************************************
  1746. 函数名称: XBCalc
  1747. 函数版本: 01.01
  1748. 创建作者: xxxxxx
  1749. 创建日期: 2014-12-16
  1750. 函数说明: 谐波计算
  1751. 参数说明:
  1752. 返回值: 无
  1753. 修改记录:
  1754. */
  1755. void XBCalc_goc(int sw)
  1756. {
  1757. bool bH1, bH2, bH3;
  1758. bool bxbbs = false;
  1759. bool bxbbs2 = false;
  1760. if (!BH_GOOSE_EN(sw))
  1761. return;
  1762. if (pRunSet->tSwSet[sw].bTT_goose_xbbs)
  1763. {
  1764. bH1 = _XB2_Logic_Relay(sw, g_ui[UI_SW_INDEX(sw, SW_AC_IA)].m2[0], g_ui[UI_SW_INDEX(sw, SW_AC_IA)].m2[1], pRunSet->tSwSet[sw].d_goose_xbcoe, pRunSet->tSwSet[sw].tGocSet.dIgl); // A相谐波闭锁
  1765. bH2 = _XB2_Logic_Relay(sw, g_ui[UI_SW_INDEX(sw, SW_AC_IB)].m2[0], g_ui[UI_SW_INDEX(sw, SW_AC_IB)].m2[1], pRunSet->tSwSet[sw].d_goose_xbcoe, pRunSet->tSwSet[sw].tGocSet.dIgl); // B相谐波闭锁
  1766. bH3 = _XB2_Logic_Relay(sw, g_ui[UI_SW_INDEX(sw, SW_AC_IC)].m2[0], g_ui[UI_SW_INDEX(sw, SW_AC_IC)].m2[1], pRunSet->tSwSet[sw].d_goose_xbcoe, pRunSet->tSwSet[sw].tGocSet.dIgl); // C相谐波闭锁
  1767. bxbbs = (bH1 || bH2 || bH3);
  1768. #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
  1769. bH1 = _XB2_Logic_Relay(sw, g_ui[UI_SW_INDEX(sw, SW_AC_IA)].m2[0], g_ui[UI_SW_INDEX(sw, SW_AC_IA)].m2[1], pRunSet->tSwSet[sw].d_goose_xbcoe, pRunSet->tSwSet[sw].tGocSet.dIgl2); // A相谐波闭锁
  1770. bH2 = _XB2_Logic_Relay(sw, g_ui[UI_SW_INDEX(sw, SW_AC_IB)].m2[0], g_ui[UI_SW_INDEX(sw, SW_AC_IB)].m2[1], pRunSet->tSwSet[sw].d_goose_xbcoe, pRunSet->tSwSet[sw].tGocSet.dIgl2); // B相谐波闭锁
  1771. bH3 = _XB2_Logic_Relay(sw, g_ui[UI_SW_INDEX(sw, SW_AC_IC)].m2[0], g_ui[UI_SW_INDEX(sw, SW_AC_IC)].m2[1], pRunSet->tSwSet[sw].d_goose_xbcoe, pRunSet->tSwSet[sw].tGocSet.dIgl2); // C相谐波闭锁
  1772. bxbbs2 = (bH1 || bH2 || bH3);
  1773. #endif
  1774. }
  1775. g_tRelay[sw].tgoc.sta.bFlag.bXBbs = bxbbs;
  1776. g_tRelay[sw].tgoc.sta.bFlag.bXBbs2 = bxbbs2;
  1777. if (bxbbs || bxbbs2)
  1778. {
  1779. if (soe_check(EV_XBBS + sw * EV_SW_NUM) == false)
  1780. {
  1781. soe_record_ev(EV_XBBS + sw * EV_SW_NUM, 1, 0, 0, 0);
  1782. }
  1783. }
  1784. else
  1785. {
  1786. if (soe_check(EV_XBBS + sw * EV_SW_NUM) == true)
  1787. {
  1788. soe_record_ev(EV_XBBS + sw * EV_SW_NUM, 0, 0, 0, 0);
  1789. }
  1790. }
  1791. }
  1792. /***************************************endfile**********************************************************/