FA_g.c 59 KB

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