app.py 245 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116
  1. from flask import Flask, jsonify, request, abort, send_from_directory
  2. from flask_cors import CORS
  3. from flask_socketio import SocketIO, emit
  4. import threading
  5. import queue
  6. import time
  7. import json
  8. import os
  9. import re
  10. import logging
  11. import uuid
  12. # 配置文件路径
  13. SERIAL_CONFIG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'serial_config.json')
  14. MQTT_CONFIG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mqtt_config.json')
  15. # 静态文件目录(前端构建产物或由 nginx 提供)
  16. STATIC_FOLDER = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'frontend', 'dist')
  17. # 导入配置
  18. from config import (
  19. MAX_BUFFER_SIZE,
  20. FLASK_SECRET_KEY,
  21. FLASK_DEBUG,
  22. FLASK_HOST,
  23. FLASK_PORT,
  24. LOG_LEVEL,
  25. LOG_FORMAT,
  26. LOG_FILE,
  27. SOCKETIO_ASYNC_MODE,
  28. SOCKETIO_ALLOWED_ORIGINS,
  29. DEFAULT_FORWARD_SERIAL_TO_MQTT,
  30. DEFAULT_FORWARD_MQTT_TO_SERIAL,
  31. DEFAULT_MQTT_PUBLISH_TOPIC,
  32. SOCKETIO_NAMESPACE_DATA,
  33. SOCKETIO_NAMESPACE_STATUS,
  34. SOCKETIO_NAMESPACE_CONTROL,
  35. ERROR_CODES,
  36. ERROR_MESSAGES,
  37. DEFAULT_CUSTOMER_ID,
  38. DEFAULT_DTU_ID,
  39. DTU_HEARTBEAT_INTERVAL,
  40. DTU_OFFLINE_TIMEOUT,
  41. DEFAULT_MQTT_TOPIC_PREFIX,
  42. DTU_REGISTRATION_TOPIC,
  43. DTU_STATUS_TOPIC,
  44. DTU_CONTROL_TOPIC,
  45. DTU_RESPONSE_TOPIC,
  46. DTU_EVENT_TOPIC,
  47. DTU_ALARM_TOPIC,
  48. DTU_BROADCAST_TOPIC,
  49. MAX_PANELS,
  50. MAX_PORTS_PER_PANEL,
  51. DEFAULT_BAUDRATE,
  52. DEFAULT_SERIAL_PORT,
  53. DEFAULT_SERIAL_TIMEOUT,
  54. DEFAULT_ADDRESS_RANGE,
  55. PANEL_KEEPALIVE_MISS_LIMIT,
  56. PANEL_READ_FALLBACK_KEEPALIVE,
  57. PANEL_PROBE_TIMEOUT,
  58. PANEL_QUERY_TIMEOUT,
  59. PANEL_READ_TIMEOUT,
  60. PANEL_CONFIG_ADDRESS_TIMEOUT,
  61. DHT11_ENABLED,
  62. DHT11_GPIO_PIN,
  63. DHT11_GPIO_CHIP,
  64. DHT11_POLL_INTERVAL,
  65. DHT11_SIMULATE,
  66. NEXTION_ENABLED,
  67. NEXTION_SCREEN_PORT,
  68. NEXTION_SCREEN_BAUD,
  69. NEXTION_PANEL_NAME_PREFIX,
  70. NEXTION_CMD_DELAY_MS
  71. )
  72. # 配置日志
  73. logging_config = {
  74. 'level': getattr(logging, LOG_LEVEL),
  75. 'format': LOG_FORMAT
  76. }
  77. if LOG_FILE:
  78. logging_config['filename'] = LOG_FILE
  79. logging.basicConfig(**logging_config)
  80. logger = logging.getLogger('serial_mqtt_gateway')
  81. _boot_time = time.time()
  82. from modules.serial_port import SerialPort
  83. from modules.mqtt_client import MQTTClient
  84. from modules.network_config import network_manager
  85. from modules.modbus_rtu import (
  86. ModbusRTUClient,
  87. ANTENNA_ADDRESSES,
  88. AddressConfigProtocol,
  89. CONFIG_ADDRESS_ENTER_FRAME,
  90. CONFIG_ADDRESS_RESPONSE_LEN,
  91. parse_config_address_response,
  92. calculate_crc16,
  93. )
  94. from modules.dht11_sensor import DHT11Sensor
  95. from modules.nextion_display import NextionDisplay
  96. from modules import config_backup
  97. app = Flask(__name__)
  98. app.config['SECRET_KEY'] = FLASK_SECRET_KEY
  99. # 配置CORS以允许nginx代理的前端访问
  100. CORS(app, resources={r"/api/*": {"origins": "*"}, r"/socket.io/*": {"origins": "*"}})
  101. # 初始化SocketIO
  102. socketio = SocketIO(
  103. app,
  104. cors_allowed_origins=SOCKETIO_ALLOWED_ORIGINS,
  105. async_mode=SOCKETIO_ASYNC_MODE,
  106. manage_session=False, # 禁用会话管理以提高性能
  107. ping_timeout=30, # 心跳超时时间
  108. ping_interval=25, # 心跳间隔
  109. logger=FLASK_DEBUG, # 根据Flask调试模式决定是否记录SocketIO日志
  110. engineio_logger=FLASK_DEBUG
  111. )
  112. # 初始化串口和MQTT客户端
  113. serial_client = SerialPort()
  114. mqtt_client = MQTTClient()
  115. modbus_client = ModbusRTUClient(serial_client)
  116. address_config = AddressConfigProtocol(serial_client)
  117. # Nextion 串口屏实例
  118. screen_display = NextionDisplay()
  119. screen_current_panel_index = 0
  120. screen_lock = threading.Lock()
  121. screen_refresh_queue = queue.Queue()
  122. screen_refresh_thread = None
  123. # 初始化 DHT11 传感器(后续在 __main__ 中设置回调并启动)
  124. dht11_sensor = None
  125. if DHT11_ENABLED and (DHT11_GPIO_PIN is not None or DHT11_SIMULATE):
  126. dht11_sensor = DHT11Sensor(
  127. gpio_pin=DHT11_GPIO_PIN,
  128. gpio_chip=DHT11_GPIO_CHIP,
  129. poll_interval=DHT11_POLL_INTERVAL,
  130. simulate=DHT11_SIMULATE
  131. )
  132. elif DHT11_ENABLED and DHT11_GPIO_PIN is None and not DHT11_SIMULATE:
  133. logger.warning("DHT11 已启用但未配置 GPIO pin (DHT11_GPIO_PIN),跳过本地传感器启动")
  134. # 转发标志
  135. forward_serial_to_mqtt = DEFAULT_FORWARD_SERIAL_TO_MQTT
  136. forward_mqtt_to_serial = DEFAULT_FORWARD_MQTT_TO_SERIAL
  137. mqtt_publish_topic = DEFAULT_MQTT_PUBLISH_TOPIC
  138. # DTU MQTT协议配置(运行时可修改)
  139. dtu_config = {
  140. 'topic_prefix': DEFAULT_MQTT_TOPIC_PREFIX,
  141. 'customer_id': DEFAULT_CUSTOMER_ID,
  142. 'dtu_id': DEFAULT_DTU_ID,
  143. 'firmware_version': 'v1.0.0',
  144. 'hardware_version': 'v1.0',
  145. 'heartbeat_interval': DTU_HEARTBEAT_INTERVAL,
  146. 'enabled': True,
  147. 'address_range': dict(DEFAULT_ADDRESS_RANGE)
  148. }
  149. DTU_CONFIG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'dtu_config.json')
  150. # 本地自动快照目录(每次写配置前自动快照,可在"数据备份"页恢复)
  151. BACKUP_DIR = config_backup.BACKUP_DIR
  152. def _save_config_file(path, data, label):
  153. """快照 + 原子写 JSON 配置文件"""
  154. try:
  155. config_backup.snapshot_before_write(path, BACKUP_DIR)
  156. config_backup.write_json_atomic(path, data)
  157. return True
  158. except Exception as e:
  159. logger.error(f"保存{label}失败: {e}")
  160. return False
  161. def load_dtu_config():
  162. global dtu_config
  163. try:
  164. if os.path.exists(DTU_CONFIG_FILE):
  165. saved = None
  166. try:
  167. saved = config_backup.read_json_file(DTU_CONFIG_FILE)
  168. except Exception as e:
  169. logger.warning(f"加载DTU配置失败: {e},尝试回退快照")
  170. saved, snap = config_backup.latest_snapshot_content(DTU_CONFIG_FILE, BACKUP_DIR)
  171. if isinstance(saved, dict):
  172. logger.warning(f"已从快照恢复DTU配置: {snap}")
  173. if isinstance(saved, dict):
  174. dtu_config.update(saved)
  175. except Exception as e:
  176. logger.warning(f"加载DTU配置失败: {e}")
  177. def save_dtu_config():
  178. _save_config_file(DTU_CONFIG_FILE, dtu_config, 'DTU配置')
  179. # 端口状态追踪(用于事件检测)
  180. port_state = {} # {panel_id: {port_id: {'last_uid': str, 'expected_uid': str, 'alarm_count': int}}}
  181. # jumper_uid 十六进制字符集(大写)
  182. _JUMPER_HEX = set('0123456789ABCDEF')
  183. _mac_uid_prefix_cache = None # 缓存 MAC 派生的前缀(稳定,避免每次发布都读 MAC)
  184. def _read_mac_bytes():
  185. """读取本机真实 MAC 地址(6 字节),失败返回 None。
  186. 优先用 uuid.getnode();其 multicast 位为 1 时是随机生成而非真实硬件 MAC,
  187. 改读 /sys/class/net(Linux)兜底。
  188. """
  189. try:
  190. node = uuid.getnode()
  191. # 第 9 位(0x010000000000)为 1 表示 multicast/随机 MAC,非真实硬件地址
  192. if node and not (node & 0x010000000000):
  193. return node.to_bytes(6, 'big')
  194. except Exception:
  195. pass
  196. try:
  197. net_dir = '/sys/class/net'
  198. if os.path.isdir(net_dir):
  199. for iface in sorted(os.listdir(net_dir)):
  200. if iface == 'lo':
  201. continue
  202. path = os.path.join(net_dir, iface, 'address')
  203. if os.path.exists(path):
  204. with open(path) as f:
  205. mac_str = f.read().strip()
  206. if re.match(r'^[0-9A-Fa-f]{2}(:[0-9A-Fa-f]{2}){5}$', mac_str):
  207. return bytes(int(b, 16) for b in mac_str.split(':'))
  208. except Exception:
  209. pass
  210. return None
  211. def _dtu_uid_prefix():
  212. """jumper_uid 前 4 位 DTU 号(4 位大写十六进制),从 MAC 派生保证多 DTU 唯一。
  213. 适配规则: MQTT jumper_uid = 前 4 位 DTU 号 + 后 12 位硬件卡号(共 16 位)。
  214. 优先级:
  215. 1. dtu_config['uid_prefix'] 显式配置(4 位大写十六进制)
  216. 2. 本机 MAC 地址的 CRC16(稳定、各 DTU 不同)
  217. 3. 兜底: dtu_id 末尾数字
  218. """
  219. global _mac_uid_prefix_cache
  220. p = (dtu_config.get('uid_prefix') or '').strip().upper()
  221. if len(p) == 4 and all(c in _JUMPER_HEX for c in p):
  222. return p
  223. if _mac_uid_prefix_cache is None:
  224. mac = _read_mac_bytes()
  225. if mac:
  226. _mac_uid_prefix_cache = calculate_crc16(mac).hex().upper()
  227. else:
  228. m = re.search(r'(\d+)$', str(dtu_config.get('dtu_id') or ''))
  229. n = int(m.group(1)) if m else 0
  230. _mac_uid_prefix_cache = f'{n & 0xFFFF:04X}'
  231. return _mac_uid_prefix_cache
  232. def _to_mqtt_jumper_uid(card_uid):
  233. """内部 12 位硬件卡号 -> MQTT 16 位 jumper_uid(前 4 位 DTU 号 + 后 12 位卡号)。
  234. None/空 -> None。硬件通信固定 6 字节(12 位),仅在 MQTT 边界拼成 16 位。
  235. """
  236. if not card_uid:
  237. return None
  238. return _dtu_uid_prefix() + card_uid.upper()
  239. def _from_mqtt_jumper_uid(value):
  240. """MQTT jumper_uid -> 内部 12 位硬件卡号。
  241. 兼容两种输入(2026-10-29 放宽):
  242. - 16 位:标准 MQTT 边界格式(前 4 位 DTU 号 + 后 12 位卡号)-> 剥前 4 位
  243. - 12 位:平台/网页直接填的硬件卡号 -> 原样使用
  244. None/空 -> None;其他长度或非十六进制 -> 抛 ValueError(由 SYNC 调用方拒绝)。
  245. """
  246. if value is None:
  247. return None
  248. if not isinstance(value, str):
  249. raise ValueError(f"jumper_uid 必须是字符串或 null,当前类型: {type(value).__name__}")
  250. v = value.strip().upper().replace(':', '').replace(' ', '').replace('-', '')
  251. if v == '':
  252. return None
  253. if len(v) == 16 and all(c in _JUMPER_HEX for c in v):
  254. return v[4:]
  255. if len(v) == 12 and all(c in _JUMPER_HEX for c in v):
  256. return v
  257. raise ValueError(f"jumper_uid 必须是 16 位(含DTU前缀)或 12 位十六进制卡号,或 null,当前: {value!r}")
  258. def _to_internal_uid_lenient(value):
  259. """重建端口状态用:兼容历史持久化数据。
  260. 16 位 -> 剥前 4 位得 12 位;12 位 -> 原样;None/空 -> None;非法 -> None。
  261. """
  262. if value is None:
  263. return None
  264. if not isinstance(value, str):
  265. return None
  266. v = value.strip().upper()
  267. if v == '':
  268. return None
  269. if len(v) == 16 and all(c in _JUMPER_HEX for c in v):
  270. return v[4:]
  271. if len(v) == 12 and all(c in _JUMPER_HEX for c in v):
  272. return v
  273. return None
  274. def _hardware_card_base(device_address, timeout: float = 2.0):
  275. """读硬件当前 24 路真实卡号,作为下发卡号时的基底(读失败返回全 None)。
  276. 用途:单端口设置卡号时,24 路要整帧下发,未显式配置的端口必须填硬件现值,
  277. 否则会被 0xFF(无卡标记)擦掉。
  278. """
  279. base = {i: None for i in range(1, 25)}
  280. try:
  281. hw_read = modbus_client.read_all_antenna_cards(device_address, timeout=timeout)
  282. except Exception as e: # noqa: BLE001
  283. logger.warning(f"读取硬件卡号基底异常(地址={device_address}): {e}")
  284. return base
  285. if 'error' in hw_read:
  286. logger.warning(f"读取硬件卡号基底失败(地址={device_address}): {hw_read.get('error')}")
  287. return base
  288. for card in hw_read.get('cards', []):
  289. ant = card.get('antenna')
  290. cs = card.get('card_str') or card.get('uid')
  291. if not ant or not cs:
  292. continue
  293. cs_clean = str(cs).strip().upper().replace(':', '').replace(' ', '')
  294. if len(cs_clean) == 12 and all(c in _JUMPER_HEX for c in cs_clean):
  295. base[int(ant)] = cs_clean
  296. return base
  297. def _build_card_mappings_for_panel(panel_id):
  298. """从 dtu_config port_mappings 构建该面板 24 路卡号映射,用于 V4 下发硬件。
  299. 返回: {port_id(1-24): 'hex12' or None}
  300. 未配置/非法的端口返回 None(set_card_mapping 内部填 0xFF*6 无卡标记)。
  301. """
  302. mappings = dtu_config.get('port_mappings', {}).get(panel_id, {})
  303. result = {}
  304. for port_id in range(1, 25):
  305. uid = mappings.get(str(port_id))
  306. result[port_id] = _to_internal_uid_lenient(uid) # 非法/空 -> None
  307. return result
  308. def _dtu_mapping_overrides(panel_id):
  309. """返回 dtu_config 中**显式配置过**的端口 -> 'hex12' 或 None(显式清除)。
  310. 与 `_build_card_mappings_for_panel` 的区别:未出现过的端口不会出现在结果里,
  311. 调用方可以据此区分「从未配置」和「显式清除」,从而保留硬件里真实存在的卡号。
  312. """
  313. mappings = dtu_config.get('port_mappings', {}).get(panel_id) or {}
  314. overrides = {}
  315. for key, value in mappings.items():
  316. try:
  317. port_id = int(key)
  318. except (TypeError, ValueError):
  319. continue
  320. if not (1 <= port_id <= 24):
  321. continue
  322. overrides[port_id] = _to_internal_uid_lenient(value)
  323. return overrides
  324. def _store_port_mapping(panel_id, port_id, expected_uid):
  325. """落盘单条绑定②(端口↔卡号)。
  326. expected_uid 为 None/空时**删除该端口记录**(而非写入 null),
  327. 避免 dtu_config 累积大量无意义的 null;硬件那口由调用方下发 0xFF 清空。
  328. 注意:这不改变 `_dtu_mapping_overrides` 的语义——只有文件里确实存在 null 键时
  329. 才被当作「显式清除」覆盖硬件基底,删除键则视为「平台未配置」,交由硬件基底保留。
  330. """
  331. pm = dtu_config.setdefault('port_mappings', {}).setdefault(panel_id, {})
  332. key = str(port_id)
  333. if expected_uid:
  334. pm[key] = expected_uid
  335. else:
  336. pm.pop(key, None)
  337. def _clear_panel_port_mappings(panel_id):
  338. """删除某面板全部端口映射(绑定②),返回被删除的条数。"""
  339. pm = dtu_config.get('port_mappings', {})
  340. entries = pm.pop(panel_id, None)
  341. return len(entries) if isinstance(entries, dict) else 0
  342. def _prune_null_port_mappings():
  343. """启动时一次性清理历史脏数据:删除 port_mappings 里所有 null/空值端口记录。
  344. 旧版单端口写卡接口会把 24 路(含大量 null)整段落盘,导致配置膨胀且语义混乱。
  345. 仅清理空值条目;非空卡号保留。返回清理掉的条目总数。
  346. """
  347. removed = 0
  348. for panel_id, mappings in list(dtu_config.get('port_mappings', {}).items()):
  349. if not isinstance(mappings, dict):
  350. continue
  351. for key in list(mappings.keys()):
  352. if _to_internal_uid_lenient(mappings.get(key)) is None:
  353. mappings.pop(key, None)
  354. removed += 1
  355. if not mappings:
  356. dtu_config['port_mappings'].pop(panel_id, None)
  357. return removed
  358. def get_sorted_panels():
  359. """按 position 排序返回 panel 列表。"""
  360. return sorted(panel_config.items(), key=lambda x: x[1].get('position', 0))
  361. def _port_status_to_pic(port_state_entry):
  362. """将端口状态推导为 Nextion pic 编号。
  363. pic 映射(当前屏幕工程只有 pic 0-3,ILLEGAL_DISCONNECT 复用 pic=2 告警图):
  364. 0 = UNKNOWN (未轮询)
  365. 1 = DISCONNECTED (正常空闲: 无期望且无卡)
  366. 2 = 告警 (ILLEGAL_CONNECT 非法插入 + ILLEGAL_DISCONNECT 非法拔出)
  367. 3 = CONNECTED (正常已连: 实际 == 期望)
  368. 未来若 Nextion 工程增加 pic=4,将 ILLEGAL_DISCONNECT 单独改为 return 4。
  369. """
  370. if not port_state_entry:
  371. return 0
  372. last_uid = port_state_entry.get('last_uid')
  373. expected_uid = port_state_entry.get('expected_uid')
  374. last_polled = port_state_entry.get('last_polled_at')
  375. if not last_polled:
  376. return 0 # UNKNOWN
  377. if last_uid is None:
  378. return 2 if expected_uid else 1 # ILLEGAL_DISCONNECT 复用告警图 / DISCONNECTED
  379. if expected_uid and last_uid != expected_uid:
  380. return 2 # ILLEGAL_CONNECT
  381. return 3 # CONNECTED
  382. def _get_display_ip():
  383. """获取用于屏幕显示的本机 IP 地址。
  384. 优先选择 192.168.199.x 管理网段;其次选择物理网卡 eth*/en* 上的 IPv4;
  385. 最后回退到任意非回环 IPv4 或静态配置 IP。
  386. """
  387. try:
  388. net_status = network_manager.get_network_status()
  389. interfaces = net_status.get('interfaces', {})
  390. # 1. 优先 192.168.199.x 管理网段
  391. for iface, data in interfaces.items():
  392. if iface in ('lo', 'docker0') or iface.startswith(('br-', 'veth')):
  393. continue
  394. for addr in data.get('ip_addresses', []):
  395. if addr.startswith('192.168.199.') and '.' in addr:
  396. return addr
  397. # 2. 优先物理网卡 eth*/en*/wlan* 上的 IPv4
  398. physical_ips = []
  399. for iface, data in interfaces.items():
  400. if iface in ('lo', 'docker0') or iface.startswith(('br-', 'veth', 'docker')):
  401. continue
  402. if not (iface.startswith(('eth', 'en', 'wlan', 'wl')) or iface == 'end0'):
  403. continue
  404. for addr in data.get('ip_addresses', []):
  405. if '.' in addr and not addr.startswith('127.'):
  406. physical_ips.append((iface, addr))
  407. # 优先有线接口
  408. for iface, addr in physical_ips:
  409. if iface.startswith(('eth', 'en', 'end')):
  410. return addr
  411. if physical_ips:
  412. return physical_ips[0][1]
  413. # 3. 任意非回环 IPv4
  414. for iface, data in interfaces.items():
  415. if iface in ('lo', 'docker0') or iface.startswith(('br-', 'veth')):
  416. continue
  417. for addr in data.get('ip_addresses', []):
  418. if '.' in addr and not addr.startswith('127.'):
  419. return addr
  420. # 4. 回退:尝试网络配置中的静态 IP
  421. net_config = network_manager.get_network_config()
  422. static_ip = net_config.get('static_config', {}).get('ip_address')
  423. if static_ip:
  424. return static_ip
  425. except Exception as e:
  426. logger.warning(f"获取显示 IP 失败: {e}")
  427. return ''
  428. _last_display_ip = None # 上次写入屏幕的 IP,用于检测变化
  429. def _network_ip_monitor_loop():
  430. """后台监测本机 IP 变化。
  431. 插网线获取到 IP(或 IP 发生任何变化)时,及时刷新串口屏显示。
  432. 复用 screen_refresh_queue 串行化下发,避免与其它刷新竞争。
  433. """
  434. global _last_display_ip
  435. while True:
  436. try:
  437. current_ip = _get_display_ip()
  438. if current_ip != _last_display_ip:
  439. logger.info(f"显示 IP 变化: {_last_display_ip!r} -> {current_ip!r}")
  440. _last_display_ip = current_ip
  441. if screen_display.get_status().get('connected'):
  442. panels = get_sorted_panels()
  443. if panels:
  444. with screen_lock:
  445. idx = screen_current_panel_index
  446. if 0 <= idx < len(panels):
  447. screen_refresh_queue.put((panels[idx][0],))
  448. else:
  449. # 没有配线架也要刷新 IP,避免屏幕停留在 HMI 默认文字
  450. screen_refresh_queue.put((None,))
  451. except Exception as e:
  452. logger.error(f"网络 IP 监测异常: {e}")
  453. time.sleep(3)
  454. def _screen_refresh_worker():
  455. """在后台线程中异步刷新 Nextion 屏幕。"""
  456. while True:
  457. try:
  458. item = screen_refresh_queue.get()
  459. if item is None:
  460. break
  461. panel_id = item[0]
  462. if panel_id is None:
  463. # 没有配线架时也要把 IP/状态刷到屏幕
  464. if screen_display.get_status().get('connected'):
  465. _send_screen_header()
  466. else:
  467. refresh_screen_panel(panel_id)
  468. except Exception as e:
  469. logger.error(f"屏幕刷新工作线程异常: {e}")
  470. finally:
  471. try:
  472. screen_refresh_queue.task_done()
  473. except Exception:
  474. pass
  475. def _send_screen_header(panel_name=None):
  476. """下发与具体 panel 无关的屏幕信息:本机 IP、终端名、版本、MQTT 状态。
  477. 即使一个配线架都没发现(panel_count=0)也调用,否则屏幕会一直停留在
  478. HMI 工程的默认文字(例如默认占位 IP)。
  479. """
  480. online_count = sum(
  481. 1 for pid, _ in get_sorted_panels()
  482. if device_last_seen.get(pid, 0) > time.time() - 60
  483. )
  484. mqtt_st = mqtt_client.get_status()
  485. mqtt_connected = mqtt_st.get('connected', False) if isinstance(mqtt_st, dict) else bool(mqtt_st)
  486. delay_ms = NEXTION_CMD_DELAY_MS
  487. if panel_name is None:
  488. panel_name = f'{NEXTION_PANEL_NAME_PREFIX}0'
  489. screen_display.send_cmd(f't2.txt="{panel_name}"', delay_ms=delay_ms)
  490. screen_display.send_cmd(f't1.txt="{_get_display_ip()}"', delay_ms=delay_ms)
  491. screen_display.send_cmd(f't4.txt="{dtu_config.get("firmware_version", "v1.0.0")}"', delay_ms=delay_ms)
  492. mqtt_str = '已连接' if mqtt_connected else '未连接'
  493. screen_display.send_cmd(f'g0.txt="MQTT:{mqtt_str} 当前终端数:{online_count}"', delay_ms=delay_ms)
  494. screen_display.send_cmd(f'g0.pco={0 if mqtt_connected else 63488}', delay_ms=delay_ms)
  495. def refresh_screen_panel(panel_id):
  496. """将指定 panel 的数据下发到 Nextion 屏幕。"""
  497. global screen_current_panel_index
  498. with screen_lock:
  499. panels = get_sorted_panels()
  500. if not panels:
  501. return False, '没有可用的 panel'
  502. panel_ids = [p[0] for p in panels]
  503. if panel_id not in panel_ids:
  504. return False, f'panel 不存在: {panel_id}'
  505. if not screen_display.get_status().get('connected'):
  506. return False, '屏幕串口未连接'
  507. idx = panel_ids.index(panel_id)
  508. screen_current_panel_index = idx
  509. # 当前 panel 对应的设备地址
  510. device_address = panel_config.get(panel_id, {}).get('address', 1)
  511. _send_screen_header(panel_name=f'{NEXTION_PANEL_NAME_PREFIX}{idx + 1}')
  512. for port_id in range(1, 25):
  513. # 屏幕网口图片显示 LED:由端口真实连接状态推导(连接/断开/非法/未知)
  514. pic = _port_status_to_pic(port_state.get(panel_id, {}).get(port_id))
  515. cmd = f'p{port_id - 1}.pic={pic}'
  516. ok = screen_display.send_cmd(cmd, delay_ms=NEXTION_CMD_DELAY_MS)
  517. logger.info(f"[Nextion] panel={panel_id} addr={device_address} port={port_id} pic={pic} cmd={cmd} ok={ok}")
  518. logger.info(f"屏幕已刷新: {panel_id} (终端{idx + 1})")
  519. return True, '屏幕已刷新'
  520. def switch_screen_panel(direction):
  521. """切换当前显示的 panel,跳过已标记离线的终端。
  522. 离线终端不再占用屏幕:按"上一/下一终端"时自动落到下一台在线的设备,
  523. 避免屏上长时间停留在空白面板上。若全部终端都离线,则退化为相邻切换,
  524. 方便用户仍能浏览各终端的离线状态。
  525. """
  526. global screen_current_panel_index
  527. with screen_lock:
  528. panels = get_sorted_panels()
  529. if not panels:
  530. return False, '没有可用的 panel'
  531. n = len(panels)
  532. start = screen_current_panel_index
  533. idx = (start + direction) % n
  534. found = False
  535. while idx != start:
  536. if panels[idx][1].get('status') != 'offline':
  537. found = True
  538. break
  539. idx = (idx + direction) % n
  540. if not found:
  541. # 全部离线:仍然切换到相邻面板,让用户能浏览各终端
  542. idx = (start + direction) % n
  543. screen_current_panel_index = idx
  544. panel_id = panels[idx][0]
  545. logger.info(f'屏幕切换: 终端{idx + 1} -> {panel_id}')
  546. return refresh_screen_panel(panel_id)
  547. def _refresh_current_screen_panel():
  548. """LED 等状态变化后,触发当前屏幕 panel 刷新。"""
  549. try:
  550. panels = get_sorted_panels()
  551. if not panels:
  552. return
  553. with screen_lock:
  554. idx = screen_current_panel_index
  555. if 0 <= idx < len(panels):
  556. panel_id = panels[idx][0]
  557. screen_refresh_queue.put((panel_id,))
  558. except Exception as e:
  559. logger.warning(f"触发屏幕刷新失败: {e}")
  560. def screen_button_event_handler(page_id, comp_id, event):
  561. """处理屏幕按钮事件。"""
  562. if event != 0x01:
  563. return
  564. if page_id == 0x00 and comp_id == 0x05:
  565. logger.info('串口屏事件: 上一终端')
  566. switch_screen_panel(-1)
  567. elif page_id == 0x00 and comp_id == 0x06:
  568. logger.info('串口屏事件: 下一终端')
  569. switch_screen_panel(1)
  570. # 面板配置(从地址配置模块加载)
  571. panel_config = {} # {panel_id: {'address': int, 'position': int, 'panel_uid': str}}
  572. # 面板连续「未收到匹配 81 应答」次数(80/81 保活口径)。
  573. # 达到 PANEL_KEEPALIVE_MISS_LIMIT(2)即判离线并停止该机 0x03 读卡;收到匹配 81 清零。
  574. panel_keepalive_miss = {} # {panel_id: int}
  575. # 已在「本次在线会话」完成 0x10 端口映射重下的面板。
  576. # 图解:每次重新上线(掉线重连/换机/新注册/DTU 重启)都要先经 0x10 重下绑定②再恢复读卡。
  577. panel_mappings_synced = set()
  578. # 同地址不同 UID 的地址冲突(原机仍在线,不自动替换):{panel_id: new_uid},供 API/告警展示
  579. panel_conflict = {}
  580. # 手动"扫描新线架"后台任务状态
  581. _panel_scan_state = {'running': False, 'found': [], 'started_at': None, 'finished_at': None, 'error': None}
  582. # "配置地址状态"后台任务状态(让线架进入刷配置卡状态并等待其应答)
  583. _panel_config_addr_state = {
  584. 'running': False,
  585. 'started_at': None,
  586. 'finished_at': None,
  587. 'timeout': None,
  588. 'antenna': None,
  589. 'address': None,
  590. 'raw': '',
  591. 'error': None,
  592. # 配置成功后待探测的新地址(线架可能稍后才应用新地址,扫描时优先探测)
  593. 'pending_address': None,
  594. 'pending_until': None,
  595. }
  596. def _address_range():
  597. """当前地址段 (start, end),非法时回退默认值"""
  598. rng = dtu_config.get('address_range') or DEFAULT_ADDRESS_RANGE
  599. try:
  600. start = int(rng.get('start', DEFAULT_ADDRESS_RANGE['start']))
  601. end = int(rng.get('end', DEFAULT_ADDRESS_RANGE['end']))
  602. except Exception:
  603. start, end = DEFAULT_ADDRESS_RANGE['start'], DEFAULT_ADDRESS_RANGE['end']
  604. if not (1 <= start <= end <= 247):
  605. start, end = DEFAULT_ADDRESS_RANGE['start'], DEFAULT_ADDRESS_RANGE['end']
  606. return start, end
  607. def _default_panel_id(addr):
  608. return f"PANEL_{dtu_config.get('dtu_id', 'DTU001')}_{addr}"
  609. def _binding_uid_for_address(addr):
  610. """返回绑定到该地址的线架 UID(无绑定返回 None)"""
  611. for uid, a in address_config.get_stored_devices().items():
  612. if a == addr:
  613. return uid
  614. return None
  615. def _panel_id_for_address(addr):
  616. """按地址找 panel_id(panel_config 优先,其次 panel_id_mapping,最后默认命名)"""
  617. for pid, cfg in panel_config.items():
  618. if cfg.get('address') == addr:
  619. return pid
  620. pm = dtu_config.get('panel_id_mapping', {}) or {}
  621. uid = _binding_uid_for_address(addr)
  622. custom = (pm.get(uid) if uid else None) or pm.get(addr)
  623. return str(custom) if custom else _default_panel_id(addr)
  624. def _is_panel_custom_id(panel_id, addr):
  625. """panel_id 是否为 panel_id_mapping 自定义(区别于默认命名)"""
  626. return panel_id != _default_panel_id(addr)
  627. def _ensure_panel_entry(panel_id, addr, uid, status='online'):
  628. panel_config[panel_id] = {
  629. 'address': addr,
  630. 'position': addr,
  631. 'panel_uid': uid,
  632. 'status': status,
  633. }
  634. def _mark_panel_offline_once(panel_id, addr, cfg):
  635. """标记面板离线(只发布一次离线状态,清端口运行态)"""
  636. if cfg.get('status') == 'offline':
  637. return
  638. cfg['status'] = 'offline'
  639. port_state.pop(panel_id, None)
  640. # 重新上线需先经 0x10 重下绑定②,故清掉本在线会话的已同步标记
  641. panel_mappings_synced.discard(panel_id)
  642. panel_conflict.pop(panel_id, None)
  643. logger.info(f"面板 {panel_id}(地址={addr}) 已标记离线")
  644. dtu_publish_panel_status(panel_id, addr, None, online=False)
  645. # 若该面板正显示在串口屏上,触发刷新使其显示离线(全灰)状态,避免残留旧画面
  646. _refresh_current_screen_panel()
  647. def _note_keepalive_miss(panel_id, addr, cfg):
  648. """一次轮询未收到「匹配的 81 应答」:累计计数。
  649. 连续达 PANEL_KEEPALIVE_MISS_LIMIT(图解=2)次即判离线,DTU 停止该机 0x03 读卡。
  650. 返回 True 表示本轮已判离线。
  651. """
  652. n = panel_keepalive_miss.get(panel_id, 0) + 1
  653. panel_keepalive_miss[panel_id] = n
  654. already_offline = cfg.get('status') == 'offline'
  655. if n < PANEL_KEEPALIVE_MISS_LIMIT:
  656. logger.warning(f"面板 {panel_id}(地址={addr}) 80 保活无匹配 81,"
  657. f"连续 {n}/{PANEL_KEEPALIVE_MISS_LIMIT} 次")
  658. return False
  659. if not already_offline:
  660. logger.warning(f"面板 {panel_id}(地址={addr}) 连续 {n} 次无匹配 81,判定离线并停止读卡")
  661. _mark_panel_offline_once(panel_id, addr, cfg)
  662. return not already_offline
  663. def _note_keepalive_ok(panel_id, addr, cfg):
  664. """收到匹配 81:清失败计数/冲突;若此前离线则恢复在线。
  665. 返回 was_offline=True 表示本次为「重新上线」,调用方必须先经 0x10 重下绑定②再读卡。
  666. """
  667. was_offline = cfg.get('status') == 'offline'
  668. panel_keepalive_miss.pop(panel_id, None)
  669. panel_conflict.pop(panel_id, None)
  670. cfg['status'] = 'online'
  671. device_last_seen[panel_id] = time.time()
  672. if cfg.get('panel_uid'):
  673. device_last_seen[cfg['panel_uid']] = time.time()
  674. if was_offline:
  675. logger.info(f"面板 {panel_id}(地址={addr}) 重新收到匹配 81,恢复在线(读卡前先经 0x10 重下绑定②)")
  676. return was_offline
  677. def _read_cards_if_online(panel_id, cfg, addr):
  678. """仅对在线机执行 0x03 读卡(离线机在保活阶段即被停读卡,不会进入这里)。
  679. 在线关系完全由 80/81 决定;读卡失败只告警,不改变在线状态、不跳过后续端口。
  680. """
  681. result = modbus_client.read_all_antenna_cards(addr, timeout=PANEL_READ_TIMEOUT)
  682. if 'error' in result:
  683. logger.warning(f"面板 {panel_id}(地址={addr}) 在线但 0x03 读卡失败: {result.get('error')}")
  684. return
  685. _handle_panel_read_success(panel_id, cfg, addr, result)
  686. def _probe_online_by_cards(panel_id, cfg, addr):
  687. """81 缺失时的兼容探测(PANEL_READ_FALLBACK_KEEPALIVE):补发一次 0x03 读卡。
  688. - 读卡有正常应答 -> 视为在线(兼容不回带 UID 81 的现网固件),顺带处理端口状态,返回 True;
  689. - 读卡也无应答 -> 返回 False,由调用方判离线。
  690. 本函数只负责探测/处理读卡结果,不改在线状态、不清计数(交由调用方)。
  691. """
  692. result = modbus_client.read_all_antenna_cards(addr, timeout=PANEL_READ_TIMEOUT)
  693. if 'error' in result:
  694. return False
  695. _handle_panel_read_success(panel_id, cfg, addr, result)
  696. return True
  697. def _maybe_refresh_screen_panel(panel_id):
  698. """该面板若正显示在串口屏上,触发一次刷新"""
  699. try:
  700. panels = get_sorted_panels()
  701. trigger_panel_id = None
  702. with screen_lock:
  703. if panels and 0 <= screen_current_panel_index < len(panels) and panels[screen_current_panel_index][0] == panel_id:
  704. trigger_panel_id = panel_id
  705. if trigger_panel_id:
  706. screen_refresh_queue.put((trigger_panel_id,))
  707. except Exception as e:
  708. logger.error(f"刷新屏幕失败: {e}")
  709. def _migrate_port_mappings(old_panel_id, new_panel_id):
  710. """线架地址变化时迁移端口期望映射(随 panel_id 一起搬到新地址下)"""
  711. pm = dtu_config.setdefault('port_mappings', {})
  712. if old_panel_id and old_panel_id != new_panel_id and old_panel_id in pm and new_panel_id not in pm:
  713. pm[new_panel_id] = pm.pop(old_panel_id)
  714. save_dtu_config()
  715. logger.info(f"端口映射已迁移: {old_panel_id} -> {new_panel_id}")
  716. def _push_card_mappings_to_panel(panel_id, addr, reason=''):
  717. """把持久化的期望卡号下发到线架硬件(换架接管/新注册后恢复面板数据)
  718. 未显式配置过的端口沿用硬件当前卡号,避免把线架自带的卡号擦成 0xFF。
  719. """
  720. try:
  721. overrides = _dtu_mapping_overrides(panel_id)
  722. if not overrides:
  723. return
  724. mappings = _hardware_card_base(addr)
  725. for ant, v in overrides.items():
  726. mappings[ant] = v
  727. result = modbus_client.set_card_mapping(addr, mappings)
  728. if 'error' in result:
  729. logger.warning(f"{reason}下发卡号失败: 地址={addr}, {result.get('error')}")
  730. else:
  731. count = len([v for v in overrides.values() if v])
  732. logger.info(f"{reason}已向地址={addr} 下发 {count} 路卡号")
  733. except Exception as e:
  734. logger.error(f"{reason}下发卡号异常: 地址={addr}, {e}")
  735. def _sync_card_mappings_once(panel_id, addr, reason=''):
  736. """本次在线会话只做一次「0x10 重下绑定②」(图解:重新上线/换机/新注册先下发再读卡)。
  737. 无显式配置映射时不实际发帧(全 FF 占位),但同样标记为已同步,避免每轮空发。
  738. """
  739. if panel_id in panel_mappings_synced:
  740. return
  741. panel_mappings_synced.add(panel_id)
  742. _push_card_mappings_to_panel(panel_id, addr, reason=reason)
  743. def _process_cards_result(panel_id, addr, result, silent=False):
  744. """处理一次成功的批量读卡结果:更新端口状态/事件/告警,返回 panel_ports(用于状态发布)
  745. silent=True 时只对齐端口状态(不发布事件/告警),用于换架接管后的静默重建。
  746. """
  747. panel_ports = []
  748. for card in result.get('cards', []):
  749. port_id = card['antenna']
  750. uid = card['card_str'].upper() if card.get('present') else ''
  751. if panel_id not in port_state:
  752. port_state[panel_id] = {}
  753. if port_id not in port_state[panel_id]:
  754. # 重建端口状态时,从持久化的期望映射回填 expected_uid(内部 12 位)。
  755. # 兼容历史脏数据:16 位剥前 4 位得 12 位;12 位原样;非法丢弃并告警。
  756. exp_uid = dtu_config.get('port_mappings', {}).get(panel_id, {}).get(str(port_id))
  757. norm = _to_internal_uid_lenient(exp_uid)
  758. if exp_uid and norm is None:
  759. logger.warning(f"面板{panel_id}端口{port_id} 持久化的 expected_uid 非法已丢弃: {exp_uid!r}")
  760. port_state[panel_id][port_id] = {
  761. 'last_uid': None,
  762. 'expected_uid': norm,
  763. 'alarm_count': 0,
  764. 'last_polled_at': int(time.time() * 1000)
  765. }
  766. ps = port_state[panel_id][port_id]
  767. ps['last_polled_at'] = int(time.time() * 1000)
  768. last_uid = ps.get('last_uid')
  769. if silent:
  770. ps['last_uid'] = uid or None
  771. ps['alarm_count'] = 0
  772. else:
  773. if uid and uid != last_uid:
  774. dtu_publish_event(panel_id, port_id, 'CONNECT' if not last_uid else 'MOVE', uid, last_uid)
  775. ps['last_uid'] = uid
  776. elif not uid and last_uid:
  777. dtu_publish_event(panel_id, port_id, 'DISCONNECT', None, last_uid)
  778. ps['last_uid'] = None
  779. ps_exp = ps.get('expected_uid')
  780. if dtu_config.get('alarm_enabled', True):
  781. if ps_exp and uid and uid != ps_exp:
  782. ps['alarm_count'] = ps.get('alarm_count', 0) + 1
  783. sev = 'CRITICAL' if ps['alarm_count'] >= 3 else 'WARNING'
  784. dtu_publish_alarm(panel_id, port_id, 'ILLEGAL_CONNECT', ps_exp, uid, sev)
  785. elif ps_exp and not uid:
  786. ps['alarm_count'] = ps.get('alarm_count', 0) + 1
  787. sev = 'CRITICAL' if ps['alarm_count'] >= 3 else 'WARNING'
  788. dtu_publish_alarm(panel_id, port_id, 'ILLEGAL_DISCONNECT', ps_exp, None, sev)
  789. elif ps_exp and uid == ps_exp:
  790. ps['alarm_count'] = 0
  791. ps_exp = ps.get('expected_uid')
  792. if uid:
  793. port_status = 'ILLEGAL' if (ps_exp and uid != ps_exp) else 'CONNECTED'
  794. else:
  795. port_status = 'DISCONNECTED'
  796. panel_ports.append({'port_id': port_id, 'status': port_status, 'jumper_uid': uid or None})
  797. # V4: LED 由配线架自控,DTU 不再自动下发灯状态
  798. return panel_ports
  799. def _handle_panel_read_success(panel_id, cfg, addr, result, silent=False):
  800. """一次成功读卡后的统一处理:端口状态 + 状态发布 + 屏幕刷新
  801. 在线/离线由 80/81 保活决定,本函数不再改在线状态(仅在线机会被调用)。
  802. """
  803. panel_ports = _process_cards_result(panel_id, addr, result, silent=silent)
  804. device_last_seen[panel_id] = time.time()
  805. if cfg.get('panel_uid'):
  806. device_last_seen[cfg['panel_uid']] = time.time()
  807. dtu_publish_panel_status(panel_id, addr, panel_ports)
  808. _maybe_refresh_screen_panel(panel_id)
  809. def _takeover_panel(panel_id, addr, old_uid, new_uid):
  810. """换架自动接管(图解情形二,前提:原机已离线)。
  811. 同地址 81 回的 UID 与绑定①不符且原机连续 2 次无匹配 81(已离线):
  812. 更新绑定①为 addr↔新UID,panel_id/绑定②(端口映射)不变;
  813. 新机上线即先经 0x10 重下绑定②,再恢复读卡。不发 82/83(已废弃)。
  814. """
  815. old_uid = (old_uid or '').lower()
  816. new_uid = (new_uid or '').lower()
  817. stored = address_config.stored_devices
  818. if old_uid:
  819. stored.pop(old_uid, None)
  820. stored[new_uid] = addr
  821. save_device_config()
  822. cfg = panel_config.get(panel_id)
  823. if cfg is None:
  824. _ensure_panel_entry(panel_id, addr, new_uid)
  825. cfg = panel_config[panel_id]
  826. # 自定义 panel_id:换 UID 后仍保留原 panel_id(补一条 uid 映射,防止命名回退)
  827. if _is_panel_custom_id(panel_id, addr):
  828. dtu_config.setdefault('panel_id_mapping', {})[new_uid] = panel_id
  829. save_dtu_config()
  830. cfg['panel_uid'] = new_uid
  831. cfg['status'] = 'online'
  832. panel_keepalive_miss.pop(panel_id, None)
  833. panel_conflict.pop(panel_id, None)
  834. # 新机新会话:先经 0x10 重下绑定②,再读卡
  835. panel_mappings_synced.discard(panel_id)
  836. logger.info(f"线架自动接管(原机离线): 地址={addr} 旧UID={old_uid or '未记录'} -> 新UID={new_uid},"
  837. f"继承原面板数据(端口映射不变),先 0x10 重下绑定②再读卡")
  838. _sync_card_mappings_once(panel_id, addr, reason='换架接管: ')
  839. result = modbus_client.read_all_antenna_cards(addr, timeout=PANEL_READ_TIMEOUT)
  840. if 'error' in result:
  841. logger.warning(f"换架接管后读卡失败: 地址={addr}, {result.get('error')}")
  842. _mark_panel_offline_once(panel_id, addr, cfg)
  843. else:
  844. _handle_panel_read_success(panel_id, cfg, addr, result, silent=True)
  845. try:
  846. dtu_register()
  847. except Exception as e:
  848. logger.warning(f"接管后注册上报失败: {e}")
  849. return True
  850. def _register_new_panel(addr, uid, allow_move=False):
  851. """未绑定地址收到全 0 探测的 81 应答 -> 本地建立绑定①并上线(80/81 口径,不发 82/83)。
  852. 新线架上线:建立绑定① addr↔UID;先经 0x10 下发绑定②(端口↔卡号,未用全 FF),
  853. 再发 0x03 读卡建立端口状态。allow_move=True 允许把该 UID 从原地址迁到 addr(配置卡改址)。
  854. """
  855. uid = (uid or '').lower()
  856. if not uid:
  857. return False
  858. existing_addr = address_config.stored_devices.get(uid)
  859. if existing_addr is not None and existing_addr != addr:
  860. old_pid = _panel_id_for_address(existing_addr)
  861. old_cfg = panel_config.get(old_pid, {})
  862. # 原地址仍在线(保活未达离线阈值)则不允许抢占,避免两台线架串址
  863. old_offline = (old_cfg.get('status') == 'offline'
  864. or panel_keepalive_miss.get(old_pid, 0) >= PANEL_KEEPALIVE_MISS_LIMIT)
  865. if allow_move or old_offline:
  866. # 线架被配置卡改址:迁移绑定并把端口映射数据带到新地址
  867. address_config.stored_devices.pop(uid, None)
  868. panel_config.pop(old_pid, None)
  869. port_state.pop(old_pid, None)
  870. panel_keepalive_miss.pop(old_pid, None)
  871. panel_mappings_synced.discard(old_pid)
  872. panel_conflict.pop(old_pid, None)
  873. _migrate_port_mappings(old_pid, _panel_id_for_address(addr))
  874. logger.info(f"线架地址变更: UID={uid} {existing_addr} -> {addr},绑定与映射已迁移")
  875. else:
  876. logger.warning(f"地址 {addr} 探测到线架 {uid},但其仍绑定在地址 {existing_addr} 且在线,忽略本次绑定(防抢占)")
  877. return False
  878. # 80/81 口径:本地建立绑定①即上线,不再发 0x82 单向确认
  879. address_config.stored_devices[uid] = addr
  880. save_device_config()
  881. panel_id = _panel_id_for_address(addr)
  882. if panel_id not in panel_config:
  883. _ensure_panel_entry(panel_id, addr, uid)
  884. panel_config[panel_id]['status'] = 'online'
  885. panel_keepalive_miss.pop(panel_id, None)
  886. panel_conflict.pop(panel_id, None)
  887. logger.info(f"线架注册(81 匹配本地建立在线): 地址={addr} UID={uid}")
  888. # 新机上线:先经 0x10 下发绑定②,再发 0x03 读卡
  889. _sync_card_mappings_once(panel_id, addr, reason='新线架注册: ')
  890. result = modbus_client.read_all_antenna_cards(addr, timeout=PANEL_READ_TIMEOUT)
  891. if 'error' in result:
  892. logger.warning(f"新线架注册后读卡失败: 地址={addr}, {result.get('error')}")
  893. _mark_panel_offline_once(panel_id, addr, panel_config[panel_id])
  894. else:
  895. _handle_panel_read_success(panel_id, panel_config[panel_id], addr, result)
  896. if _panel_config_addr_state.get('pending_address') == addr:
  897. _panel_config_addr_state['pending_address'] = None
  898. _panel_config_addr_state['pending_until'] = None
  899. logger.info(f"配置地址后的新地址 {addr} 已完成注册,停止待探测")
  900. try:
  901. dtu_register()
  902. except Exception as e:
  903. logger.warning(f"新线架注册后上报失败: {e}")
  904. return True
  905. def _sweep_panel_addresses():
  906. """一轮地址段顺序扫描(80/81 口径,图解主规则):
  907. - 已绑定地址:发「地址 + 绑定 UID」的 0x80 保活(绝不发全 0)。
  908. * 收到匹配 81(UID=绑定①)-> 在线;若为重新上线/本会话未同步,先经 0x10 重下
  909. 绑定②(端口↔卡号,未用全 FF),再发 0x03 读卡;稳态在线则直接读卡。
  910. * 连续 PANEL_KEEPALIVE_MISS_LIMIT(=2)次收不到匹配 81 -> 判离线,停止该机 0x03 读卡;
  911. 重新收到匹配 81 才恢复(恢复时先 0x10 再读卡)。
  912. * 收到的 81 UID 与绑定①不同:仅当原机已离线(连续2次无匹配81)才换架接管
  913. (先 0x10 再读卡);原机仍在线则判地址冲突,不更新绑定、不读卡、不下发,记冲突。
  914. - 未绑定地址:每轮对地址段内全部地址发 12 字节全 0 的 0x80 探测,线架应答自身 UID
  915. (81)即本地建立绑定①并上线(82/83 已废弃,不发确认帧),先 0x10 再读卡。
  916. 所有总线帧仍走 serial_client 发送队列。
  917. """
  918. start, end = _address_range()
  919. stored = address_config.get_stored_devices()
  920. bound_map = {}
  921. for uid, a in stored.items():
  922. bound_map.setdefault(a, uid)
  923. pending_addr = _panel_config_addr_state.get('pending_address')
  924. pending_until = _panel_config_addr_state.get('pending_until') or 0
  925. if pending_addr and (not (start <= pending_addr <= end) or time.time() > pending_until):
  926. # 配置地址后的待探测地址:超时或不在地址段内则放弃
  927. logger.info(f"配置地址后的待探测地址 {pending_addr} 已超时/不在地址段内,停止探测")
  928. _panel_config_addr_state['pending_address'] = None
  929. _panel_config_addr_state['pending_until'] = None
  930. pending_addr = None
  931. # 每轮顺序探测地址段内所有未绑定地址(即使有绑定线架离线也照常探测),
  932. # 新线架接入后应答自身 UID 即自动绑定注册。
  933. unbound = [a for a in range(start, end + 1) if a not in bound_map]
  934. probe_set = set(unbound)
  935. # 刚配置过地址的线架优先探测(便于改址后立即重新注册)
  936. if pending_addr and pending_addr not in bound_map:
  937. probe_set.add(pending_addr)
  938. sweep_addrs = sorted(set(range(start, end + 1)) | set(bound_map.keys()))
  939. online = 0
  940. offline = 0
  941. for addr in sweep_addrs:
  942. uid = bound_map.get(addr)
  943. try:
  944. if not uid:
  945. # 未绑定地址:12 字节全 0 的 0x80 探测,线架回 81(自身 UID)即注册
  946. if addr in probe_set:
  947. result = modbus_client.query_address(addr, uid=None, timeout=PANEL_PROBE_TIMEOUT)
  948. if 'error' not in result:
  949. new_uid = (result.get('uid') or '').lower()
  950. if new_uid:
  951. _register_new_panel(addr, new_uid, allow_move=(addr == pending_addr))
  952. continue
  953. panel_id = _panel_id_for_address(addr)
  954. cfg = panel_config.get(panel_id)
  955. if cfg is None:
  956. _ensure_panel_entry(panel_id, addr, uid)
  957. cfg = panel_config[panel_id]
  958. # 链路1:0x80 保活(带绑定 UID)→ 等 81
  959. query = modbus_client.query_address(addr, uid=uid, timeout=PANEL_QUERY_TIMEOUT)
  960. resp_uid = '' if 'error' in query else ((query.get('uid') or '').lower())
  961. if resp_uid and resp_uid != uid.lower():
  962. # 同地址不同 UID:原机离线才接管(情形二),原机在线则冲突不替换(情形一)
  963. old_offline = (cfg.get('status') == 'offline'
  964. or panel_keepalive_miss.get(panel_id, 0) >= PANEL_KEEPALIVE_MISS_LIMIT)
  965. if old_offline:
  966. _takeover_panel(panel_id, addr, uid, resp_uid)
  967. bound_map[addr] = resp_uid
  968. online += 1
  969. else:
  970. if panel_conflict.get(panel_id) != resp_uid:
  971. panel_conflict[panel_id] = resp_uid
  972. logger.warning(f"地址 {addr} 地址冲突:绑定 UID={uid} 仍在线,"
  973. f"探测到不同 UID={resp_uid},不替换/不下发/不读卡,等待原机离线判定")
  974. # 原机本轮无匹配 81 -> 计数;达到 2 次离线后本轮立即接管新 UID
  975. went_offline = _note_keepalive_miss(panel_id, addr, cfg)
  976. if went_offline:
  977. logger.info(f"地址 {addr} 原机已连续 {PANEL_KEEPALIVE_MISS_LIMIT} 次无匹配 81,"
  978. f"按离线替换接管新 UID={resp_uid}")
  979. _takeover_panel(panel_id, addr, uid, resp_uid)
  980. bound_map[addr] = resp_uid
  981. online += 1
  982. else:
  983. offline += 1
  984. continue
  985. if resp_uid == uid.lower():
  986. # 收到匹配 81 -> 在线;重新上线/本会话未同步则先 0x10 重下绑定②再读卡
  987. was_offline = _note_keepalive_ok(panel_id, addr, cfg)
  988. if was_offline or panel_id not in panel_mappings_synced:
  989. _sync_card_mappings_once(panel_id, addr, reason='重新上线: ')
  990. _read_cards_if_online(panel_id, cfg, addr)
  991. online += 1
  992. continue
  993. # 未收到匹配 81(超时/空应答)
  994. was_offline = cfg.get('status') == 'offline'
  995. if PANEL_READ_FALLBACK_KEEPALIVE:
  996. # 兼容现网固件(不回带 UID 的 81,但 0x03 读卡正常):
  997. # 判离线前 / 离线等待恢复时,先发一次 0x03 读卡探测——有应答即判在线。
  998. if _probe_online_by_cards(panel_id, cfg, addr):
  999. if was_offline:
  1000. logger.info(f"面板 {panel_id}(地址={addr}) 81 缺失但读卡有应答,"
  1001. f"兼容判定在线(先经 0x10 重下绑定②)")
  1002. _sync_card_mappings_once(panel_id, addr, reason='读卡兜底恢复: ')
  1003. # 读卡有应答 -> 在线并清零保活计数
  1004. panel_keepalive_miss.pop(panel_id, None)
  1005. panel_conflict.pop(panel_id, None)
  1006. cfg['status'] = 'online'
  1007. online += 1
  1008. continue
  1009. # 读卡也无应答:累计保活失败,达阈值才判离线
  1010. _note_keepalive_miss(panel_id, addr, cfg)
  1011. if cfg.get('status') == 'offline':
  1012. offline += 1
  1013. else:
  1014. online += 1 # 第 1 次缺失尚未达阈值,仍按在线计
  1015. continue
  1016. # 严格图解口径:连续无匹配 81 计数;达 PANEL_KEEPALIVE_MISS_LIMIT 判离线停读卡
  1017. went_offline = _note_keepalive_miss(panel_id, addr, cfg)
  1018. if went_offline or cfg.get('status') == 'offline':
  1019. # 离线:停止该机 0x03 读卡
  1020. offline += 1
  1021. else:
  1022. # 仍在线(第 1 次保活缺失):尚未达离线阈值,本轮仍读卡
  1023. _read_cards_if_online(panel_id, cfg, addr)
  1024. online += 1
  1025. finally:
  1026. time.sleep(0.05)
  1027. return online, offline
  1028. # 数据存储缓冲区
  1029. serial_data_buffer = []
  1030. mqtt_data_buffer = []
  1031. # 状态标志
  1032. serial_status = False
  1033. mqtt_status = False
  1034. # 辅助函数:统一处理 get_status() 返回 dict 的布尔判断
  1035. def _mqtt_connected():
  1036. """MQTT 客户端是否已连接"""
  1037. st = mqtt_client.get_status()
  1038. return st.get('connected', False) if isinstance(st, dict) else bool(st)
  1039. def _serial_connected():
  1040. """串口是否已连接"""
  1041. st = serial_client.get_status()
  1042. return st.get('connected', False) if isinstance(st, dict) else bool(st)
  1043. # 串口配置保存和加载函数
  1044. def save_serial_config(port, baudrate=9600, timeout=1.0, bytesize=8, parity='N', stopbits=1):
  1045. """保存串口配置"""
  1046. config = {
  1047. 'port': port,
  1048. 'baudrate': baudrate,
  1049. 'timeout': timeout,
  1050. 'bytesize': bytesize,
  1051. 'parity': parity,
  1052. 'stopbits': stopbits
  1053. }
  1054. if _save_config_file(SERIAL_CONFIG_FILE, config, '串口配置'):
  1055. logger.info(f"串口配置已保存: {port} @ {baudrate}")
  1056. def default_serial_config():
  1057. """默认串口配置:板载 TTL 转 RS485 接配线架总线(/dev/ttyS8 @9600 8N1)。"""
  1058. return {
  1059. 'port': DEFAULT_SERIAL_PORT,
  1060. 'baudrate': DEFAULT_BAUDRATE,
  1061. 'timeout': DEFAULT_SERIAL_TIMEOUT,
  1062. 'bytesize': 8,
  1063. 'parity': 'N',
  1064. 'stopbits': 1,
  1065. }
  1066. def load_serial_config():
  1067. """加载串口配置(文件缺失/损坏时回退快照,仍无则用默认配置)"""
  1068. if os.path.exists(SERIAL_CONFIG_FILE):
  1069. try:
  1070. try:
  1071. config = config_backup.read_json_file(SERIAL_CONFIG_FILE)
  1072. except Exception as e:
  1073. logger.error(f"加载串口配置失败: {e},尝试回退快照")
  1074. config, snap = config_backup.latest_snapshot_content(SERIAL_CONFIG_FILE, BACKUP_DIR)
  1075. if not isinstance(config, dict):
  1076. logger.warning(f"串口配置损坏且无可用快照,使用默认配置: {DEFAULT_SERIAL_PORT}")
  1077. return default_serial_config()
  1078. logger.warning(f"已从快照恢复串口配置: {snap}")
  1079. logger.info(f"已加载串口配置: {config.get('port')} @ {config.get('baudrate')}")
  1080. return config
  1081. except Exception as e:
  1082. logger.error(f"加载串口配置失败: {e},使用默认配置")
  1083. return default_serial_config()
  1084. logger.warning(f"串口配置文件不存在,使用默认配置: {DEFAULT_SERIAL_PORT}")
  1085. return default_serial_config()
  1086. def save_mqtt_config(broker, port=1883, client_id='', username='', password='', keepalive=60, topics=None):
  1087. """保存MQTT配置"""
  1088. config = {
  1089. 'broker': broker,
  1090. 'port': port,
  1091. 'client_id': client_id,
  1092. 'username': username,
  1093. 'password': password,
  1094. 'keepalive': keepalive,
  1095. 'topics': topics or []
  1096. }
  1097. if _save_config_file(MQTT_CONFIG_FILE, config, 'MQTT配置'):
  1098. logger.info(f"MQTT配置已保存: {broker}:{port}")
  1099. def load_mqtt_config():
  1100. """加载MQTT配置(文件损坏时回退最新快照)"""
  1101. if os.path.exists(MQTT_CONFIG_FILE):
  1102. try:
  1103. try:
  1104. config = config_backup.read_json_file(MQTT_CONFIG_FILE)
  1105. except Exception as e:
  1106. logger.error(f"加载MQTT配置失败: {e},尝试回退快照")
  1107. config, snap = config_backup.latest_snapshot_content(MQTT_CONFIG_FILE, BACKUP_DIR)
  1108. if not isinstance(config, dict):
  1109. return None
  1110. logger.warning(f"已从快照恢复MQTT配置: {snap}")
  1111. logger.info(f"已加载MQTT配置: {config.get('broker')}:{config.get('port')}")
  1112. return config
  1113. except Exception as e:
  1114. logger.error(f"加载MQTT配置失败: {e}")
  1115. return None
  1116. def auto_connect_mqtt():
  1117. """自动连接上次使用的MQTT服务器"""
  1118. config = load_mqtt_config()
  1119. if config and config.get('broker'):
  1120. broker = config.get('broker')
  1121. port = config.get('port', 1883)
  1122. client_id = config.get('client_id', '')
  1123. username = config.get('username', '')
  1124. password = config.get('password', '')
  1125. keepalive = config.get('keepalive', 60)
  1126. topics = config.get('topics', [])
  1127. logger.info(f"尝试自动连接MQTT: {broker}:{port}")
  1128. will_topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status')
  1129. will_payload = json.dumps({
  1130. 'dtu_id': dtu_config['dtu_id'], 'type': 'STATUS',
  1131. 'payload': {'online': False, 'reason': 'CONNECTION_LOST'}
  1132. })
  1133. success, message = mqtt_client.connect(
  1134. broker=broker, port=port, client_id=client_id,
  1135. username=username or "", password=password or "",
  1136. keepalive=keepalive,
  1137. will_topic=will_topic, will_payload=will_payload, will_qos=1, will_retain=False
  1138. )
  1139. if success:
  1140. logger.info(f"自动连接MQTT成功: {broker}:{port}")
  1141. if topics:
  1142. mqtt_client.subscribe(topics)
  1143. else:
  1144. logger.warning(f"自动连接MQTT失败: {message}")
  1145. return success
  1146. return False
  1147. def auto_connect_serial():
  1148. """自动连接上次使用的串口"""
  1149. config = load_serial_config()
  1150. if config and config.get('port'):
  1151. port = config.get('port')
  1152. baudrate = config.get('baudrate', 9600)
  1153. timeout = config.get('timeout', 1.0)
  1154. bytesize = config.get('bytesize', 8)
  1155. parity = config.get('parity', 'N')
  1156. stopbits = config.get('stopbits', 1)
  1157. logger.info(f"尝试自动连接串口: {port} @ {baudrate}")
  1158. success, message = serial_client.connect(port, baudrate=baudrate, timeout=timeout, bytesize=bytesize, parity=parity, stopbits=stopbits)
  1159. if success:
  1160. logger.info(f"自动连接串口成功: {port}")
  1161. return True
  1162. else:
  1163. logger.warning(f"自动连接串口失败: {message}")
  1164. return False
  1165. # 客户端连接管理
  1166. connected_clients = {
  1167. 'data': set(),
  1168. 'status': set(),
  1169. 'control': set()
  1170. }
  1171. # 设置回调函数
  1172. def serial_data_handler(data):
  1173. """处理串口接收的数据"""
  1174. try:
  1175. timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
  1176. serial_data_buffer.append({
  1177. 'timestamp': timestamp,
  1178. 'data': data,
  1179. 'direction': 'in'
  1180. })
  1181. if len(serial_data_buffer) > MAX_BUFFER_SIZE:
  1182. serial_data_buffer.pop(0)
  1183. socketio.emit('serial_data', {
  1184. 'timestamp': timestamp,
  1185. 'data': data,
  1186. 'direction': 'in'
  1187. }, namespace=SOCKETIO_NAMESPACE_DATA)
  1188. if forward_serial_to_mqtt and _mqtt_connected():
  1189. success, msg = mqtt_client.publish(mqtt_publish_topic, data)
  1190. if not success:
  1191. logger.warning(f"串口数据转发到MQTT失败: {msg}")
  1192. except Exception as e:
  1193. logger.error(f"处理串口数据时出错: {str(e)}")
  1194. def serial_send_handler(data):
  1195. """处理串口发送的数据"""
  1196. try:
  1197. timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
  1198. serial_data_buffer.append({
  1199. 'timestamp': timestamp,
  1200. 'data': data,
  1201. 'direction': 'out'
  1202. })
  1203. if len(serial_data_buffer) > MAX_BUFFER_SIZE:
  1204. serial_data_buffer.pop(0)
  1205. socketio.emit('serial_data', {
  1206. 'timestamp': timestamp,
  1207. 'data': data,
  1208. 'direction': 'out'
  1209. }, namespace=SOCKETIO_NAMESPACE_DATA)
  1210. except Exception as e:
  1211. logger.error(f"处理串口发送数据时出错: {str(e)}")
  1212. def serial_status_handler(status):
  1213. """处理串口状态变化"""
  1214. try:
  1215. global serial_status
  1216. serial_status = status
  1217. # 通过WebSocket广播状态变化
  1218. socketio.emit('serial_status', {
  1219. 'connected': status
  1220. }, namespace=SOCKETIO_NAMESPACE_STATUS)
  1221. logger.info(f"串口状态更新: {'已连接' if status else '已断开'}")
  1222. # 串口重新连接后,按线架绑定表重建面板配置(实际在线状态由地址段扫描刷新)
  1223. if status:
  1224. try:
  1225. sync_panel_config()
  1226. except Exception as e:
  1227. logger.error(f"串口重连后同步面板配置失败: {e}")
  1228. except Exception as e:
  1229. logger.error(f"处理串口状态时出错: {str(e)}")
  1230. def mqtt_data_handler(data):
  1231. """处理MQTT接收的数据"""
  1232. try:
  1233. # 添加到缓冲区
  1234. timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
  1235. mqtt_data_buffer.append({
  1236. 'timestamp': timestamp,
  1237. 'topic': data['topic'],
  1238. 'payload': data['payload']
  1239. })
  1240. # 保持缓冲区大小
  1241. if len(mqtt_data_buffer) > MAX_BUFFER_SIZE:
  1242. mqtt_data_buffer.pop(0)
  1243. # 通过WebSocket广播数据
  1244. socketio.emit('mqtt_data', {
  1245. 'timestamp': timestamp,
  1246. 'topic': data['topic'],
  1247. 'payload': data['payload']
  1248. }, namespace=SOCKETIO_NAMESPACE_DATA)
  1249. # 如果启用了转发且串口已连接,转发数据到串口
  1250. if forward_mqtt_to_serial and _serial_connected():
  1251. success, msg = serial_client.send_data(data['payload'])
  1252. if not success:
  1253. logger.warning(f"MQTT数据转发到串口失败: {msg}")
  1254. except Exception as e:
  1255. logger.error(f"处理MQTT数据时出错: {str(e)}")
  1256. def mqtt_status_handler(status):
  1257. """处理MQTT状态变化"""
  1258. try:
  1259. global mqtt_status
  1260. mqtt_status = status
  1261. # 通过WebSocket广播状态变化
  1262. socketio.emit('mqtt_status', {
  1263. 'connected': status
  1264. }, namespace=SOCKETIO_NAMESPACE_STATUS)
  1265. logger.info(f"MQTT状态更新: {'已连接' if status else '已断开'}")
  1266. # 如果MQTT连接成功且启用了DTU协议,发送注册消息和订阅控制主题
  1267. if status and dtu_config.get('enabled'):
  1268. socketio.sleep(1) # 等待连接稳定
  1269. # 发送DTU注册消息
  1270. dtu_register()
  1271. # 订阅控制主题
  1272. control_topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'control')
  1273. mqtt_client.subscribe(control_topic, qos=1)
  1274. logger.info(f"已订阅控制主题: {control_topic}")
  1275. # 订阅广播主题 (DTU发现 7.14 和批量配置 7.15)
  1276. discover_topic = build_dtu_topic('broadcast', 'dtu', 'discover')
  1277. config_topic = build_dtu_topic('broadcast', 'dtu', 'config')
  1278. mqtt_client.subscribe(discover_topic, qos=1)
  1279. mqtt_client.subscribe(config_topic, qos=1)
  1280. logger.info(f"已订阅广播主题: {discover_topic}, {config_topic}")
  1281. # MQTT 状态变化时刷新当前屏幕显示
  1282. panels = get_sorted_panels()
  1283. if screen_display.get_status().get('connected'):
  1284. try:
  1285. if panels:
  1286. with screen_lock:
  1287. current_idx = screen_current_panel_index
  1288. if 0 <= current_idx < len(panels):
  1289. screen_refresh_queue.put((panels[current_idx][0],))
  1290. else:
  1291. screen_refresh_queue.put((None,))
  1292. except Exception as e:
  1293. logger.error(f"MQTT 状态变化刷新屏幕失败: {e}")
  1294. except Exception as e:
  1295. logger.error(f"处理MQTT状态时出错: {str(e)}")
  1296. # ========== DTU MQTT协议处理函数 ==========
  1297. def build_dtu_topic(*parts):
  1298. """构建DTU MQTT主题"""
  1299. prefix = dtu_config.get('topic_prefix', '线架系统')
  1300. return '/'.join([prefix] + list(parts))
  1301. def dtu_register(discovery_request_id=None):
  1302. """发送DTU注册消息"""
  1303. if not _mqtt_connected():
  1304. logger.warning("MQTT未连接,无法发送注册消息")
  1305. return False
  1306. try:
  1307. # 加载面板配置
  1308. devices = address_config.get_stored_devices()
  1309. # 优先使用 dtu_config 中预设的 panel_id 映射 (uid_hex -> panel_id)
  1310. panel_id_map = dtu_config.get('panel_id_mapping', {}) or {}
  1311. panels = []
  1312. panel_id = 1
  1313. for uid_hex, addr in devices.items():
  1314. custom_id = panel_id_map.get(uid_hex) or panel_id_map.get(addr)
  1315. if custom_id:
  1316. pid = str(custom_id)
  1317. else:
  1318. pid = f"PANEL_{dtu_config['dtu_id']}_{addr}"
  1319. panels.append({
  1320. 'panel_id': pid,
  1321. 'address': addr,
  1322. 'position': panel_id,
  1323. 'panel_uid': uid_hex
  1324. })
  1325. panel_id += 1
  1326. # 检测网络类型
  1327. network_type = 'ethernet'
  1328. signal_strength = None
  1329. try:
  1330. interfaces = network_manager.get_network_status().get('interfaces', {})
  1331. for name, info in interfaces.items():
  1332. if name in ('lo', 'docker0') or name.startswith(('br-', 'veth')):
  1333. continue
  1334. if info.get('status') != 'UP':
  1335. continue
  1336. if name.startswith(('wlan', 'wlp')):
  1337. network_type = 'wifi'
  1338. # 读取信号强度 (dBm, 越接近 0 越强)
  1339. try:
  1340. import re
  1341. with open('/proc/net/wireless') as f:
  1342. for line in f.readlines()[2:]:
  1343. m = re.match(r'\s*(\S+):.*\s(\d+)\.\s+(-?\d+)\.', line)
  1344. if m:
  1345. signal_strength = int(m.group(3))
  1346. break
  1347. except Exception:
  1348. pass
  1349. elif name.startswith(('wwan', 'ppp', 'usb', 'eth')):
  1350. # 移动网卡
  1351. if name.startswith(('wwan', 'ppp', 'usb')):
  1352. network_type = 'cellular'
  1353. break
  1354. except Exception:
  1355. pass
  1356. payload = {
  1357. 'msg_id': f"reg_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}",
  1358. 'timestamp': int(time.time() * 1000),
  1359. 'dtu_id': dtu_config['dtu_id'],
  1360. 'type': 'REGISTER',
  1361. 'payload': {
  1362. 'firmware_version': dtu_config.get('firmware_version', 'v1.0.0'),
  1363. 'hardware_version': dtu_config.get('hardware_version', 'v1.0'),
  1364. 'panel_count': len(panels),
  1365. 'network_type': network_type,
  1366. 'signal_strength': signal_strength,
  1367. 'uptime': int((time.time() - _boot_time) * 1000),
  1368. 'panels': panels,
  1369. 'discovery_request_id': discovery_request_id
  1370. }
  1371. }
  1372. if discovery_request_id:
  1373. payload['payload']['discovery_request_id'] = discovery_request_id
  1374. topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'register')
  1375. success, msg = mqtt_client.publish(topic, json.dumps(payload), qos=1)
  1376. if success:
  1377. logger.info(f"DTU注册消息已发送: {topic}")
  1378. else:
  1379. logger.error(f"DTU注册消息发送失败: {msg}")
  1380. return success
  1381. except Exception as e:
  1382. logger.error(f"发送DTU注册消息失败: {str(e)}")
  1383. return False
  1384. _discover_dedup = {}
  1385. def handle_broadcast_discover(payload):
  1386. """处理广播发现消息 (7.14)"""
  1387. try:
  1388. if not isinstance(payload, dict) or payload.get('type') != 'DISCOVER':
  1389. return
  1390. p = payload.get('payload', {})
  1391. cust_id = p.get('customer_id', '')
  1392. if cust_id and cust_id != dtu_config.get('customer_id'):
  1393. return
  1394. request_id = p.get('request_id', '')
  1395. now = time.time()
  1396. if request_id and request_id in _discover_dedup:
  1397. if now - _discover_dedup[request_id] < 60:
  1398. return
  1399. _discover_dedup[request_id] = now
  1400. # 清理超过 60s 的旧条目,防止内存泄漏
  1401. if len(_discover_dedup) > 256:
  1402. for k in list(_discover_dedup.keys()):
  1403. if now - _discover_dedup[k] > 60:
  1404. _discover_dedup.pop(k, None)
  1405. logger.info(f"收到DISCOVER广播,响应注册消息 (request_id={request_id})")
  1406. import random
  1407. delay = random.uniform(0, 3.0)
  1408. time.sleep(delay)
  1409. dtu_register(discovery_request_id=request_id)
  1410. dtu_publish_status()
  1411. except Exception as e:
  1412. logger.error(f"处理广播发现消息失败: {str(e)}")
  1413. def handle_broadcast_config(payload):
  1414. """处理广播批量配置消息 (7.15)"""
  1415. try:
  1416. if isinstance(payload, dict) and payload.get('type') == 'CONFIG':
  1417. cfg = payload.get('payload', {})
  1418. cust_id = cfg.get('customer_id', '')
  1419. if cust_id and cust_id != dtu_config.get('customer_id'):
  1420. return
  1421. config_version = cfg.get('config_version', '')
  1422. force_apply = cfg.get('force_apply', False)
  1423. items = cfg.get('items', {})
  1424. local_version = dtu_config.get('config_version', '')
  1425. incoming_msg_id = payload.get('msg_id', '')
  1426. if local_version == config_version and not force_apply:
  1427. logger.info(f"配置版本 {config_version} 已存在,跳过")
  1428. _send_config_response(config_version, [], True, 1011, incoming_msg_id)
  1429. return
  1430. valid_ranges = {
  1431. 'heartbeat_interval': (10, 3600),
  1432. 'poll_interval_ms': (100, 10000),
  1433. 'modbus_timeout_ms': (200, 5000),
  1434. 'mqtt_keepalive': (10, 300),
  1435. 'event_debounce_ms': (0, 5000),
  1436. }
  1437. applied = []
  1438. for key, val in items.items():
  1439. if key in valid_ranges:
  1440. lo, hi = valid_ranges[key]
  1441. if not (lo <= val <= hi):
  1442. _send_config_response(config_version, applied, False, 1012, incoming_msg_id)
  1443. return
  1444. if key == 'heartbeat_interval':
  1445. dtu_config['heartbeat_interval'] = val
  1446. elif key == 'mqtt_keepalive':
  1447. dtu_config['mqtt_keepalive'] = val
  1448. elif key == 'event_debounce_ms':
  1449. dtu_config['event_debounce_ms'] = val
  1450. elif key == 'poll_interval_ms':
  1451. dtu_config['poll_interval_ms'] = val
  1452. elif key == 'modbus_timeout_ms':
  1453. dtu_config['modbus_timeout_ms'] = val
  1454. applied.append(key)
  1455. elif key in ('alarm_enabled',):
  1456. dtu_config['alarm_enabled'] = bool(val)
  1457. applied.append(key)
  1458. else:
  1459. _send_config_response(config_version, applied, False, 1013, incoming_msg_id)
  1460. return
  1461. if applied:
  1462. dtu_config['config_version'] = config_version
  1463. try:
  1464. save_dtu_config()
  1465. except Exception as e:
  1466. logger.error(f"配置写入持久化失败: {e}")
  1467. _send_config_response(config_version, applied, False, 1014, incoming_msg_id)
  1468. return
  1469. _send_config_response(config_version, applied, True, 0, incoming_msg_id)
  1470. except Exception as e:
  1471. logger.error(f"处理广播配置消息失败: {str(e)}")
  1472. def _send_config_response(config_version, applied_items, success, error_code, original_msg_id=''):
  1473. """发送批量配置响应 (随机 0-2000ms 延迟避免广播风暴)"""
  1474. import time as _t, json as _j, random as _r
  1475. delay = _r.uniform(0, 2.0)
  1476. def _delayed_publish():
  1477. _t.sleep(delay)
  1478. topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'response')
  1479. payload = {
  1480. 'msg_id': f"rsp_cfg_{int(_t.time() * 1000)}",
  1481. 'timestamp': int(_t.time() * 1000),
  1482. 'dtu_id': dtu_config['dtu_id'],
  1483. 'type': 'RESPONSE',
  1484. 'payload': {
  1485. 'original_msg_id': original_msg_id or f"cfg_{config_version}",
  1486. 'command': 'BROADCAST_CONFIG',
  1487. 'success': success,
  1488. 'result': {
  1489. 'applied_version': config_version,
  1490. 'applied_items': applied_items,
  1491. 'restart_required': False
  1492. } if success else None,
  1493. 'error_code': error_code,
  1494. 'error_message': get_ota_error_message(error_code) if error_code and error_code >= 1000 else None
  1495. }
  1496. }
  1497. mqtt_client.publish(topic, _j.dumps(payload), qos=1)
  1498. # 异步执行避免阻塞 MQTT 主循环
  1499. threading.Thread(target=_delayed_publish, daemon=True).start()
  1500. def dtu_publish_status(force=False):
  1501. """发送DTU状态/心跳消息
  1502. Args:
  1503. force: 保留参数。事件/告警/查询触发时传入 True,用于立即上报(区别于定时心跳)
  1504. """
  1505. if not _mqtt_connected() or not dtu_config.get('enabled'):
  1506. return False
  1507. # 调试日志: 区分定时 vs 触发上报
  1508. if force:
  1509. logger.debug("dtu_publish_status(force=True) - 事件触发立即上报")
  1510. try:
  1511. # panel_online 计数: 在最近 60s 内所有 24 个端口都被成功轮询过
  1512. # 严格语义: 全部 24 端口在最近一轮 poll 周期内被 poll 成功 → online
  1513. now_ms = int(time.time() * 1000)
  1514. threshold_ms = 60_000 # 60 秒未轮询视为 offline
  1515. poll_ok = 0
  1516. for pid, cfg in panel_config.items():
  1517. ps = port_state.get(pid, {})
  1518. expected_ports = cfg.get('port_count', 24)
  1519. polled_recently = sum(
  1520. 1 for p in ps.values()
  1521. if p.get('last_polled_at') and (now_ms - p.get('last_polled_at', 0)) < threshold_ms
  1522. )
  1523. if polled_recently >= expected_ports:
  1524. poll_ok += 1
  1525. panel_online = poll_ok
  1526. panel_offline = max(0, len(panel_config) - panel_online)
  1527. # 检查串口状态
  1528. serial_st = serial_client.get_status()
  1529. rs485_status = 'normal' if (isinstance(serial_st, dict) and serial_st.get('connected', False)) else 'error'
  1530. # 网络状态: 检查实际接口 UP 状态
  1531. # 规则: 有线 (eth*/wlan*) UP → online; 仅 wifi 信号弱 (无 link/低质量) → weak; 否则 offline
  1532. network_status = 'offline'
  1533. try:
  1534. interfaces = network_manager.get_network_status().get('interfaces', {})
  1535. real_ifs = {i: s for i, s in interfaces.items()
  1536. if s.get('status') == 'UP'
  1537. and i not in ('lo', 'docker0')
  1538. and not i.startswith(('br-', 'veth'))}
  1539. if real_ifs:
  1540. # 优先有线连接
  1541. if any(i.startswith(('eth', 'en')) for i in real_ifs):
  1542. network_status = 'online'
  1543. else:
  1544. # 仅无线: 检查信号强度 (Linux: /proc/net/wireless)
  1545. try:
  1546. import re
  1547. with open('/proc/net/wireless') as f:
  1548. lines = f.readlines()
  1549. quality = None
  1550. for line in lines[2:]: # 跳过表头
  1551. m = re.match(r'\s*(\S+):.*\s(\d+)\.\s+(\d+)\.\s+(\d+)', line)
  1552. if m:
  1553. # link quality (字段 2, 0-70); signal level (字段 3, dBm, 越低越差)
  1554. link = int(m.group(2))
  1555. sig = int(m.group(3))
  1556. # 估算: link < 30 或 sig < -75 dBm 视为弱
  1557. if quality is None or link < quality:
  1558. quality = link
  1559. network_status = 'weak' if (quality is not None and quality < 30) else 'online'
  1560. except Exception:
  1561. network_status = 'online'
  1562. except Exception:
  1563. network_status = 'offline'
  1564. # 屏幕连接状态:从 Nextion 屏幕实例读取
  1565. screen_connected = screen_display.get_status().get('connected', False)
  1566. # CPU/内存使用率 (Linux 才有意义)
  1567. cpu_usage = _get_cpu_usage()
  1568. memory_usage = _get_memory_usage()
  1569. dtu_temperature = None
  1570. try:
  1571. # 主板温度: 优先 psutil.sensors_temperatures
  1572. try:
  1573. import psutil
  1574. temps = psutil.sensors_temperatures(fahrenheit=False) or {}
  1575. for chip_name, entries in temps.items():
  1576. for entry in entries:
  1577. if entry.current and entry.current > 0:
  1578. dtu_temperature = round(entry.current, 1)
  1579. break
  1580. if dtu_temperature is not None:
  1581. break
  1582. except Exception:
  1583. pass
  1584. # 回退: 直接读 /sys/class/thermal/thermal_zone*/temp
  1585. if dtu_temperature is None:
  1586. import glob as _glob
  1587. for tz in sorted(_glob.glob('/sys/class/thermal/thermal_zone*/temp')):
  1588. try:
  1589. with open(tz) as f:
  1590. v = int(f.read().strip())
  1591. if v > 0:
  1592. dtu_temperature = round(v / 1000.0, 1)
  1593. break
  1594. except Exception:
  1595. continue
  1596. except Exception:
  1597. pass
  1598. # 优先使用外部上报的 dtu_temperature (来自 MQTT/RS485 传感器)
  1599. dtu_temperature = env_sensor_data.get('dtu_temperature') or dtu_temperature
  1600. payload = {
  1601. 'msg_id': f"hbt_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}",
  1602. 'timestamp': int(time.time() * 1000),
  1603. 'dtu_id': dtu_config['dtu_id'],
  1604. 'type': 'STATUS',
  1605. 'payload': {
  1606. 'cpu_usage': cpu_usage,
  1607. 'memory_usage': memory_usage,
  1608. 'temperature': dtu_temperature,
  1609. 'network_status': network_status,
  1610. 'panel_online': panel_online,
  1611. 'panel_offline': panel_offline,
  1612. 'screen_connected': screen_connected,
  1613. 'mqtt_connected': _mqtt_connected(),
  1614. 'rs485_status': rs485_status
  1615. }
  1616. }
  1617. topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status')
  1618. success, _ = mqtt_client.publish(topic, json.dumps(payload), qos=1)
  1619. return success
  1620. except Exception as e:
  1621. logger.error(f"发送DTU状态消息失败: {str(e)}")
  1622. return False
  1623. def dtu_publish_event(panel_id, port_id, event_type, jumper_uid, previous_jumper_uid=None):
  1624. """发送端口事件消息。
  1625. 入参 jumper_uid / previous_jumper_uid 为内部 12 位硬件卡号;
  1626. MQTT 上行拼成 16 位(前 4 位 DTU 号 + 后 12 位卡号)。
  1627. """
  1628. if not _mqtt_connected() or not dtu_config.get('enabled'):
  1629. return False
  1630. try:
  1631. mqtt_jumper = _to_mqtt_jumper_uid(jumper_uid)
  1632. mqtt_prev = _to_mqtt_jumper_uid(previous_jumper_uid)
  1633. payload = {
  1634. 'msg_id': f"evt_{int(time.time() * 1000)}",
  1635. 'timestamp': int(time.time() * 1000),
  1636. 'dtu_id': dtu_config['dtu_id'],
  1637. 'type': 'EVENT',
  1638. 'payload': {
  1639. 'panel_id': panel_id,
  1640. 'port_id': port_id,
  1641. 'event_type': event_type,
  1642. 'event_id': f"evt_{uuid.uuid4().hex[:8]}",
  1643. 'jumper_uid': mqtt_jumper,
  1644. 'previous_jumper_uid': mqtt_prev
  1645. }
  1646. }
  1647. topic = build_dtu_topic(dtu_config['customer_id'], 'patchpanel', dtu_config['dtu_id'], panel_id, 'event')
  1648. success, _ = mqtt_client.publish(topic, json.dumps(payload), qos=1)
  1649. if success:
  1650. logger.info(f"端口事件已发送: {panel_id}:{port_id} - {event_type}")
  1651. # 记录到事件历史(保留内部 12 位,供本地前端/调试)
  1652. port_event_history.append({
  1653. 'timestamp': int(time.time() * 1000),
  1654. 'panel_id': panel_id,
  1655. 'port_id': port_id,
  1656. 'event_type': event_type,
  1657. 'jumper_uid': jumper_uid,
  1658. 'previous_jumper_uid': previous_jumper_uid
  1659. })
  1660. # 限制历史记录数量
  1661. if len(port_event_history) > 1000:
  1662. port_event_history[:] = port_event_history[-1000:]
  1663. # 事件驱动: 立即上报一次 status (符合 7.4 "状态变化时立即上报")
  1664. try:
  1665. dtu_publish_status(force=True)
  1666. except Exception:
  1667. pass
  1668. return success
  1669. except Exception as e:
  1670. logger.error(f"发送端口事件失败: {str(e)}")
  1671. return False
  1672. def dtu_publish_alarm(panel_id, port_id, alarm_type, expected_jumper_uid, actual_jumper_uid, severity='WARNING'):
  1673. """发送非法告警消息。
  1674. 入参 expected_jumper_uid / actual_jumper_uid 为内部 12 位硬件卡号;
  1675. MQTT 上行拼成 16 位(前 4 位 DTU 号 + 后 12 位卡号)。
  1676. """
  1677. if not _mqtt_connected() or not dtu_config.get('enabled'):
  1678. return False
  1679. try:
  1680. mqtt_exp = _to_mqtt_jumper_uid(expected_jumper_uid)
  1681. mqtt_act = _to_mqtt_jumper_uid(actual_jumper_uid)
  1682. description = f"端口{port_id}期望跳线{mqtt_exp or '无'},实际{'未读到' if not actual_jumper_uid else mqtt_act}"
  1683. payload = {
  1684. 'msg_id': f"alm_{int(time.time() * 1000)}",
  1685. 'timestamp': int(time.time() * 1000),
  1686. 'dtu_id': dtu_config['dtu_id'],
  1687. 'type': 'ALARM',
  1688. 'payload': {
  1689. 'panel_id': panel_id,
  1690. 'port_id': port_id,
  1691. 'alarm_type': alarm_type,
  1692. 'severity': severity,
  1693. 'expected_jumper_uid': mqtt_exp,
  1694. 'actual_jumper_uid': mqtt_act,
  1695. 'description': description
  1696. }
  1697. }
  1698. topic = build_dtu_topic(dtu_config['customer_id'], 'patchpanel', dtu_config['dtu_id'], panel_id, 'alarm')
  1699. success, _ = mqtt_client.publish(topic, json.dumps(payload), qos=1)
  1700. if success:
  1701. logger.warning(f"非法告警已发送: {panel_id}:{port_id} - {alarm_type}")
  1702. # 记录到事件历史(保留内部 12 位,供本地前端/调试)
  1703. port_event_history.append({
  1704. 'timestamp': int(time.time() * 1000),
  1705. 'panel_id': panel_id,
  1706. 'port_id': port_id,
  1707. 'event_type': 'ALARM',
  1708. 'alarm_type': alarm_type,
  1709. 'expected_jumper_uid': expected_jumper_uid,
  1710. 'actual_jumper_uid': actual_jumper_uid
  1711. })
  1712. # 限制历史记录数量
  1713. if len(port_event_history) > 1000:
  1714. port_event_history[:] = port_event_history[-1000:]
  1715. # 事件驱动: 告警后立即上报一次 status
  1716. try:
  1717. dtu_publish_status(force=True)
  1718. except Exception:
  1719. pass
  1720. return success
  1721. except Exception as e:
  1722. logger.error(f"发送非法告警失败: {str(e)}")
  1723. return False
  1724. def dtu_publish_panel_status(panel_id, address, ports_data, online=True):
  1725. """发送配线架状态消息 (7.7)
  1726. online=False 时表示面板已离线,ports 全部置为 UNKNOWN。
  1727. """
  1728. if not _mqtt_connected() or not dtu_config.get('enabled'):
  1729. return False
  1730. try:
  1731. if not online:
  1732. ports_data = [{'port_id': p, 'status': 'UNKNOWN', 'jumper_uid': None} for p in range(1, 25)]
  1733. # MQTT 上行 jumper_uid 拼成 16 位(前 4 位 DTU 号 + 后 12 位卡号)
  1734. mqtt_ports = [
  1735. {**p, 'jumper_uid': _to_mqtt_jumper_uid(p.get('jumper_uid'))}
  1736. for p in ports_data
  1737. ]
  1738. topic = build_dtu_topic(dtu_config['customer_id'], 'patchpanel', dtu_config['dtu_id'], panel_id, 'status')
  1739. payload = {
  1740. 'msg_id': f"pst_{int(time.time() * 1000)}",
  1741. 'timestamp': int(time.time() * 1000),
  1742. 'dtu_id': dtu_config['dtu_id'],
  1743. 'type': 'STATUS',
  1744. 'payload': {
  1745. 'panel_id': panel_id,
  1746. 'position': panel_config.get(panel_id, {}).get('position', 0),
  1747. 'address': address,
  1748. 'panel_uid': panel_config.get(panel_id, {}).get('panel_uid'),
  1749. 'online': online,
  1750. 'last_poll_time': int(time.time() * 1000),
  1751. 'ports': mqtt_ports
  1752. }
  1753. }
  1754. mqtt_client.publish(topic, json.dumps(payload), qos=0)
  1755. return True
  1756. except Exception as e:
  1757. logger.error(f"发送面板状态失败: {str(e)}")
  1758. return False
  1759. def dtu_publish_jumper_status():
  1760. """发送跳线状态汇总 (7.8) - STATUS envelope with panels[] array"""
  1761. if not _mqtt_connected() or not dtu_config.get('enabled'):
  1762. return False
  1763. try:
  1764. panels_arr = []
  1765. for panel_id, cfg in panel_config.items():
  1766. ports_arr = []
  1767. ps = port_state.get(panel_id, {})
  1768. for port_id in range(1, 25):
  1769. p = ps.get(port_id, {})
  1770. last_uid = p.get('last_uid')
  1771. expected_uid = p.get('expected_uid')
  1772. last_polled = p.get('last_polled_at')
  1773. if not last_polled:
  1774. status = 'UNKNOWN'
  1775. elif last_uid is None:
  1776. status = 'DISCONNECTED'
  1777. if expected_uid:
  1778. status = 'ILLEGAL'
  1779. elif expected_uid and last_uid != expected_uid:
  1780. status = 'ILLEGAL'
  1781. else:
  1782. status = 'CONNECTED'
  1783. ports_arr.append({
  1784. 'port_id': port_id,
  1785. 'status': status,
  1786. # MQTT 上行拼成 16 位(前 4 位 DTU 号 + 后 12 位卡号)
  1787. 'jumper_uid': _to_mqtt_jumper_uid(last_uid)
  1788. })
  1789. panels_arr.append({
  1790. 'panel_id': panel_id,
  1791. 'position': cfg.get('position', 0),
  1792. 'ports': ports_arr
  1793. })
  1794. topic = build_dtu_topic(dtu_config['customer_id'], 'jumper', dtu_config['dtu_id'], 'status')
  1795. payload = {
  1796. 'msg_id': f"jmp_{int(time.time() * 1000)}",
  1797. 'timestamp': int(time.time() * 1000),
  1798. 'dtu_id': dtu_config['dtu_id'],
  1799. 'type': 'STATUS',
  1800. 'payload': {'panels': panels_arr}
  1801. }
  1802. mqtt_client.publish(topic, json.dumps(payload), qos=0)
  1803. return True
  1804. except Exception as e:
  1805. logger.error(f"发送跳线状态汇总失败: {str(e)}")
  1806. return False
  1807. _env_sensor_data = {
  1808. 'temperature': None,
  1809. 'humidity': None,
  1810. 'sensor_update_time': None
  1811. }
  1812. def update_env_sensor_data(temperature, humidity, dtu_temperature=None, sensor_update_time=None):
  1813. """更新环境传感器数据 - 委托给完整实现(带历史和告警)"""
  1814. update_env_sensor_data_full(temperature, humidity, dtu_temperature, sensor_update_time)
  1815. def dtu_publish_env_sensor():
  1816. """发送环境传感器数据 (7.9) - STATUS envelope"""
  1817. if not _mqtt_connected() or not dtu_config.get('enabled'):
  1818. return False
  1819. try:
  1820. topic = build_dtu_topic(dtu_config['customer_id'], 'env', dtu_config['dtu_id'], 'sensor')
  1821. payload = {
  1822. 'msg_id': f"sen_{int(time.time() * 1000)}",
  1823. 'timestamp': int(time.time() * 1000),
  1824. 'dtu_id': dtu_config['dtu_id'],
  1825. 'type': 'STATUS',
  1826. 'payload': {
  1827. 'temperature': _env_sensor_data.get('temperature'),
  1828. 'humidity': _env_sensor_data.get('humidity'),
  1829. 'sensor_update_time': _env_sensor_data.get('sensor_update_time')
  1830. }
  1831. }
  1832. mqtt_client.publish(topic, json.dumps(payload), qos=0)
  1833. return True
  1834. except Exception as e:
  1835. logger.error(f"发送环境传感器数据失败: {str(e)}")
  1836. return False
  1837. def _resolve_panel_id(target):
  1838. """将 target 解析为 panel_config 中实际的 panel_id 键。
  1839. 兼容三种输入:
  1840. - 完整 panel_id(如 'PANEL_dtu_001_2'):原样返回(若存在)
  1841. - 数字地址/序号(如 2 或 '2'):尝试匹配 panel_config 中以该数字结尾的键
  1842. - 'all' / None:原样返回(由调用方处理)
  1843. """
  1844. if target is None or target == 'all':
  1845. return target
  1846. if target in panel_config:
  1847. return target
  1848. # 数字型:尝试匹配 PANEL_*_{n} 或地址为 n 的面板
  1849. try:
  1850. num = int(target)
  1851. except (TypeError, ValueError):
  1852. return target
  1853. # 1) 键以 _{num} 结尾
  1854. for pid in panel_config:
  1855. if pid.endswith(f'_{num}'):
  1856. return pid
  1857. # 2) 面板地址等于 num
  1858. for pid, cfg in panel_config.items():
  1859. if cfg.get('address') == num:
  1860. return pid
  1861. return target
  1862. def dtu_handle_control(topic, payload):
  1863. """处理下行控制指令"""
  1864. try:
  1865. if not dtu_config.get('enabled'):
  1866. return
  1867. command = payload.get('payload', {}).get('command')
  1868. target = payload.get('payload', {}).get('target')
  1869. params = payload.get('payload', {}).get('params', {})
  1870. logger.info(f"收到控制指令: command={command}, target={target}")
  1871. response_payload = {
  1872. 'msg_id': f"rsp_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}",
  1873. 'timestamp': int(time.time() * 1000),
  1874. 'dtu_id': dtu_config['dtu_id'],
  1875. 'type': 'RESPONSE',
  1876. 'payload': {
  1877. 'original_msg_id': payload.get('msg_id'),
  1878. 'command': command,
  1879. 'success': True,
  1880. 'result': {},
  1881. 'error_code': 0,
  1882. 'error_message': None
  1883. }
  1884. }
  1885. topic_response_dtu = build_dtu_topic(
  1886. dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'response')
  1887. # 处理各命令
  1888. if command == 'SET_PORT_LED':
  1889. # 设置端口LED
  1890. port_id = params.get('port_id')
  1891. led_mode = params.get('led_mode', 'OFF')
  1892. # 参数校验
  1893. if port_id is None or not (1 <= int(port_id) <= 24):
  1894. response_payload['payload']['success'] = False
  1895. response_payload['payload']['error_code'] = 1003
  1896. response_payload['payload']['error_message'] = f"端口号非法: {port_id}"
  1897. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  1898. return
  1899. if led_mode not in ('OFF', 'BLINK_RED', 'BLINK_GREEN', 'BLINK_BLUE'):
  1900. response_payload['payload']['success'] = False
  1901. response_payload['payload']['error_code'] = 1004
  1902. response_payload['payload']['error_message'] = f"LED模式非法: {led_mode}"
  1903. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  1904. return
  1905. # LED模式映射
  1906. led_mode_map = {'OFF': 0, 'BLINK_RED': 1, 'BLINK_GREEN': 2, 'BLINK_BLUE': 3}
  1907. color = led_mode_map.get(led_mode, 0)
  1908. # 查找设备地址
  1909. device_address = 1 # 默认
  1910. for panel_id, cfg in panel_config.items():
  1911. if panel_id == target:
  1912. device_address = cfg.get('address', 1)
  1913. break
  1914. result = modbus_client.set_rgb_led(device_address, port_id, color)
  1915. response_payload['payload']['success'] = 'error' not in result
  1916. response_payload['payload']['result'] = result
  1917. if 'error' in result:
  1918. response_payload['payload']['error_code'] = 1005
  1919. response_payload['payload']['error_message'] = result['error']
  1920. else:
  1921. if device_address not in led_states:
  1922. led_states[device_address] = {}
  1923. led_states[device_address][int(port_id)] = color
  1924. _refresh_current_screen_panel()
  1925. elif command == 'QUERY_DTU_STATUS':
  1926. # 查询DTU状态
  1927. dtu_publish_status(force=True)
  1928. elif command == 'SYNC_PORT_MAPPING':
  1929. # 同步单端口期望映射
  1930. port_id = params.get('port_id')
  1931. jumper_uid = params.get('jumper_uid')
  1932. # 前端把 panel_id 放在 params 里(target='port' 占位),优先取 params.panel_id
  1933. panel_target = params.get('panel_id')
  1934. if panel_target is None:
  1935. panel_target = target
  1936. # 兼容数字 panel_id:前端可能传 2/3 或 'PANEL_dtu_001_2'
  1937. panel_target = _resolve_panel_id(panel_target)
  1938. if port_id is None or panel_target is None or panel_target not in panel_config:
  1939. response_payload['payload']['success'] = False
  1940. response_payload['payload']['error_code'] = 1006 if port_id is None else 1002
  1941. response_payload['payload']['error_message'] = "参数缺失" if port_id is None else f"目标面板不存在: {panel_target}"
  1942. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  1943. return
  1944. try:
  1945. # MQTT 16 位 -> 内部 12 位硬件卡号(剥前 4 位 DTU 号)
  1946. expected_uid = _from_mqtt_jumper_uid(jumper_uid)
  1947. except ValueError as e:
  1948. response_payload['payload']['success'] = False
  1949. response_payload['payload']['error_code'] = 1006
  1950. response_payload['payload']['error_message'] = str(e)
  1951. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  1952. return
  1953. if panel_target not in port_state:
  1954. port_state[panel_target] = {}
  1955. if port_id not in port_state[panel_target]:
  1956. port_state[panel_target][port_id] = {'last_uid': None, 'expected_uid': None, 'alarm_count': 0}
  1957. port_state[panel_target][port_id]['expected_uid'] = expected_uid
  1958. # 持久化期望映射(内部 12 位),保证离线恢复/重启后仍能判定非法连接;
  1959. # expected_uid 为空(清除)时删除记录,不写 null
  1960. _store_port_mapping(panel_target, port_id, expected_uid)
  1961. save_dtu_config()
  1962. # V4: 下发卡号到配线架硬件(24路同时发送;保留其他端口真实硬件值,避免误擦)
  1963. device_address = panel_config[panel_target].get('address', 1)
  1964. # 策略同 HTTP 单端口模式:硬件读基底 → dtu_config 覆盖 → 目标端口覆盖
  1965. card_mappings = _hardware_card_base(device_address)
  1966. # dtu_config 期望值覆盖(平台下发过的映射是权威;显式清除同样覆盖,
  1967. # 否则被清除过的端口会被硬件基底重新还原)
  1968. for ant, v in _dtu_mapping_overrides(panel_target).items():
  1969. card_mappings[ant] = v
  1970. # 目标端口覆盖(本次要设置/清除的值)
  1971. try:
  1972. card_mappings[int(port_id)] = expected_uid
  1973. except (ValueError, TypeError):
  1974. response_payload['payload']['success'] = False
  1975. response_payload['payload']['error_code'] = 1006
  1976. response_payload['payload']['error_message'] = f"port_id 非法: {port_id}"
  1977. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  1978. return
  1979. try:
  1980. hw_result = modbus_client.set_card_mapping(device_address, card_mappings, timeout=2.0)
  1981. if 'error' in hw_result:
  1982. response_payload['payload']['success'] = False
  1983. response_payload['payload']['error_code'] = 1008
  1984. response_payload['payload']['error_message'] = f"卡号下发硬件失败: {hw_result['error']}"
  1985. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  1986. return
  1987. response_payload['payload']['result'] = {'hardware': hw_result}
  1988. logger.info(f"SYNC_PORT_MAPPING 面板{panel_target}端口{port_id} 卡号已下发硬件: {expected_uid}")
  1989. except Exception as e:
  1990. response_payload['payload']['success'] = False
  1991. response_payload['payload']['error_code'] = 1008
  1992. response_payload['payload']['error_message'] = f"卡号下发异常: {e}"
  1993. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  1994. return
  1995. elif command == 'SYNC_ALL_MAPPING':
  1996. # 批量同步期望映射
  1997. mappings = params.get('mappings', [])
  1998. if not isinstance(mappings, list):
  1999. response_payload['payload']['success'] = False
  2000. response_payload['payload']['error_code'] = 1006
  2001. response_payload['payload']['error_message'] = "mappings 字段格式错误"
  2002. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  2003. return
  2004. try:
  2005. for mapping in mappings:
  2006. panel_id = _resolve_panel_id(mapping.get('panel_id'))
  2007. port_id = mapping.get('port_id')
  2008. jumper_uid = mapping.get('jumper_uid')
  2009. # MQTT 16 位 -> 内部 12 位硬件卡号(剥前 4 位 DTU 号),非法抛 ValueError
  2010. expected_uid = _from_mqtt_jumper_uid(jumper_uid)
  2011. if panel_id not in panel_config:
  2012. raise ValueError(f"目标面板不存在: {mapping.get('panel_id')}")
  2013. if panel_id not in port_state:
  2014. port_state[panel_id] = {}
  2015. if port_id not in port_state[panel_id]:
  2016. port_state[panel_id][port_id] = {'last_uid': None, 'expected_uid': None, 'alarm_count': 0}
  2017. port_state[panel_id][port_id]['expected_uid'] = expected_uid
  2018. # 持久化期望映射(内部 12 位);清除(空)时删除记录,不写 null
  2019. _store_port_mapping(panel_id, port_id, expected_uid)
  2020. save_dtu_config()
  2021. except Exception as e:
  2022. response_payload['payload']['success'] = False
  2023. response_payload['payload']['error_code'] = 1007
  2024. response_payload['payload']['error_message'] = f"同步映射失败: {e}"
  2025. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  2026. return
  2027. # V4: 对涉及的面板逐个下发卡号到硬件
  2028. affected_panels = set()
  2029. for mapping in mappings:
  2030. pid = _resolve_panel_id(mapping.get('panel_id'))
  2031. if pid:
  2032. affected_panels.add(pid)
  2033. hw_results = {}
  2034. hw_errors = {}
  2035. for pid in affected_panels:
  2036. device_address = panel_config[pid].get('address', 1)
  2037. # 基线:先读硬件真实卡号,避免把平台没记录过的端口擦成 0xFF
  2038. card_mappings = _hardware_card_base(device_address)
  2039. for ant, v in _dtu_mapping_overrides(pid).items():
  2040. card_mappings[ant] = v
  2041. try:
  2042. hw_result = modbus_client.set_card_mapping(device_address, card_mappings, timeout=2.0)
  2043. if 'error' in hw_result:
  2044. hw_errors[pid] = hw_result['error']
  2045. else:
  2046. hw_results[pid] = 'ok'
  2047. logger.info(f"SYNC_ALL_MAPPING 面板{pid} 卡号已下发硬件")
  2048. except Exception as e:
  2049. hw_errors[pid] = str(e)
  2050. if hw_errors:
  2051. response_payload['payload']['success'] = False
  2052. response_payload['payload']['error_code'] = 1008
  2053. response_payload['payload']['error_message'] = f"部分面板卡号下发失败: {hw_errors}"
  2054. response_payload['payload']['result'] = {'hardware': {'success': hw_results, 'errors': hw_errors}}
  2055. elif command == 'REBOOT':
  2056. # 重启DTU: 1s 延迟后执行 reboot
  2057. import subprocess
  2058. logger.warning(f"MQTT REBOOT 命令收到,1 秒后执行系统重启")
  2059. threading.Thread(target=lambda: (
  2060. time.sleep(1),
  2061. subprocess.run(['reboot'], capture_output=True)
  2062. ), daemon=True).start()
  2063. response_payload['payload']['result'] = {'message': 'Reboot scheduled in 1s'}
  2064. elif command == 'READ_PANEL_STATUS':
  2065. # 读取面板状态
  2066. # V4 寄存器: 0x0000=网络通断(保留), 0x0001=LED控制, 0x0002=批量卡号(144字节)
  2067. device_address = 1
  2068. for panel_id, cfg in panel_config.items():
  2069. if panel_id == target:
  2070. device_address = cfg.get('address', 1)
  2071. break
  2072. # V4: 只读 0x0000-0x0001(网络通断 + LED);0x0002 起为批量卡号数据,不再作为状态寄存器
  2073. status_result = modbus_client.read_holding_registers(device_address, 0x0000, 2)
  2074. registers = status_result.get('registers', [])
  2075. # V4: 天线在场状态由批量卡号读得出(24 元素 0/1 列表)
  2076. bulk_result = modbus_client.read_all_antenna_cards(device_address)
  2077. antenna_status = []
  2078. if 'error' not in bulk_result:
  2079. antenna_status = [1 if c.get('present') else 0 for c in bulk_result.get('cards', [])]
  2080. panel_status = {
  2081. 'device_address': device_address,
  2082. 'run_status': registers[0] if len(registers) > 0 else None,
  2083. 'led_control': registers[1] if len(registers) > 1 else None,
  2084. 'antenna_status': antenna_status,
  2085. 'raw_registers': registers
  2086. }
  2087. response_payload['payload']['success'] = 'error' not in status_result
  2088. response_payload['payload']['result'] = panel_status
  2089. elif command == 'QUERY_JUMPER_STATUS':
  2090. # 查询跳线器状态汇总 (7.8) - 触发 STATUS 上行至 jumper/{dtu_id}/status
  2091. dtu_publish_jumper_status()
  2092. return # dtu_publish_jumper_status 已发送响应
  2093. elif command == 'QUERY_ENV_SENSOR':
  2094. # 查询环境传感器 (7.9) - 触发 STATUS 上行至 env/{dtu_id}/sensor
  2095. dtu_publish_env_sensor()
  2096. return # dtu_publish_env_sensor 已发送响应
  2097. elif command == 'OTA_UPGRADE':
  2098. params = payload.get('payload', {}).get('params', {})
  2099. target_version = params.get('firmware_version')
  2100. force_upgrade = params.get('force_upgrade', False)
  2101. current_version = dtu_config.get('firmware_version', 'v1.0.0')
  2102. incoming_msg_id = payload.get('msg_id', '')
  2103. if target_version == current_version and not force_upgrade:
  2104. response_payload['payload']['success'] = False
  2105. response_payload['payload']['error_code'] = 1021
  2106. response_payload['payload']['error_message'] = f"已是目标版本: {target_version}"
  2107. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  2108. return
  2109. if params.get('firmware_url'):
  2110. import threading
  2111. threading.Thread(target=lambda: _run_ota({**params, '_incoming_msg_id': incoming_msg_id}), daemon=True).start()
  2112. response_payload['payload']['success'] = True
  2113. response_payload['payload']['result'] = {
  2114. 'firmware_version': target_version,
  2115. 'ota_status': 'DOWNLOADING',
  2116. 'restart_required': False
  2117. }
  2118. elif command == 'OTA_CANCEL':
  2119. # 取消OTA升级
  2120. # 向OTA控制寄存器写入取消命令 (0x0000=取消)
  2121. device_address = 1
  2122. for panel_id, cfg in panel_config.items():
  2123. if panel_id == target:
  2124. device_address = cfg.get('address', 1)
  2125. break
  2126. # OTA控制寄存器地址: 0x0300
  2127. # 值: 0x0000=取消升级
  2128. cancel_result = modbus_client.write_single_register(device_address, 0x0300, 0x0000)
  2129. response_payload['payload']['success'] = 'error' not in cancel_result
  2130. response_payload['payload']['result'] = {
  2131. 'message': 'OTA upgrade cancelled' if 'error' not in cancel_result else 'Failed to cancel OTA',
  2132. 'raw_result': cancel_result
  2133. }
  2134. else:
  2135. # 未知命令
  2136. response_payload['payload']['success'] = False
  2137. response_payload['payload']['error_code'] = 1001
  2138. response_payload['payload']['error_message'] = f"未知命令: {command}"
  2139. mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
  2140. return
  2141. # 发送响应(QUERY_DTU_STATUS 已由 dtu_publish_status 发送;QUERY_JUMPER_STATUS/QUERY_ENV_SENSOR 已在分支中发布)
  2142. if command == 'QUERY_DTU_STATUS':
  2143. pass
  2144. else:
  2145. cmd = command
  2146. if cmd == 'READ_PANEL_STATUS':
  2147. if target and target != 'all' and target in panel_config:
  2148. # 单个面板: 使用 panel_id 作为 topic segment
  2149. topic = build_dtu_topic(dtu_config['customer_id'], 'patchpanel',
  2150. dtu_config['dtu_id'], target, 'status')
  2151. mqtt_client.publish(topic, json.dumps(response_payload), qos=0)
  2152. else:
  2153. # target=all: 遍历所有面板发布到各自的 topic
  2154. for pid in panel_config.keys():
  2155. topic = build_dtu_topic(dtu_config['customer_id'], 'patchpanel',
  2156. dtu_config['dtu_id'], pid, 'status')
  2157. mqtt_client.publish(topic, json.dumps(response_payload), qos=0)
  2158. else:
  2159. topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'response')
  2160. p = response_payload['payload']
  2161. if not p.get('success', True) and p.get('error_code', 0) == 0:
  2162. p['error_code'] = 9999
  2163. p['error_message'] = p.get('error_message') or '未知错误'
  2164. mqtt_client.publish(topic, json.dumps(response_payload), qos=1)
  2165. except Exception as e:
  2166. logger.error(f"处理控制指令失败: {str(e)}")
  2167. # 启动DTU心跳定时器
  2168. def start_dtu_heartbeat():
  2169. """启动DTU心跳定时任务"""
  2170. def heartbeat_task():
  2171. env_tick = 0
  2172. while True:
  2173. socketio.sleep(dtu_config.get('heartbeat_interval', DTU_HEARTBEAT_INTERVAL))
  2174. if _mqtt_connected() and dtu_config.get('enabled'):
  2175. dtu_publish_status()
  2176. # 每 2 个心跳周期 (120s) 主动推送一次环境传感器数据 (7.9)
  2177. env_tick += 1
  2178. if env_tick >= 2:
  2179. env_tick = 0
  2180. dtu_publish_env_sensor()
  2181. socketio.start_background_task(target=heartbeat_task)
  2182. # 修改mqtt_data_handler以处理控制指令
  2183. def mqtt_data_handler_extended(data):
  2184. """处理MQTT接收的数据(扩展版,含DTU协议)"""
  2185. try:
  2186. topic = data.get('topic', '')
  2187. payload_str = data.get('payload', '')
  2188. # 尝试解析JSON
  2189. try:
  2190. payload = json.loads(payload_str) if isinstance(payload_str, str) else payload_str
  2191. except:
  2192. payload = payload_str
  2193. # 添加到缓冲区
  2194. timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
  2195. mqtt_data_buffer.append({
  2196. 'timestamp': timestamp,
  2197. 'topic': topic,
  2198. 'payload': payload_str
  2199. })
  2200. if len(mqtt_data_buffer) > MAX_BUFFER_SIZE:
  2201. mqtt_data_buffer.pop(0)
  2202. # 通过WebSocket广播
  2203. socketio.emit('mqtt_data', {
  2204. 'timestamp': timestamp,
  2205. 'topic': topic,
  2206. 'payload': payload_str
  2207. }, namespace=SOCKETIO_NAMESPACE_DATA)
  2208. # 检查是否是控制指令主题
  2209. expected_control_topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'control')
  2210. if topic == expected_control_topic:
  2211. dtu_handle_control(topic, payload)
  2212. # 检查是否是状态主题,用于处理OTA状态上报
  2213. expected_status_topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status')
  2214. if topic == expected_status_topic and isinstance(payload, dict):
  2215. if 'ota_status' in payload or 'firmware_version' in payload:
  2216. handle_ota_status(dtu_config['dtu_id'], payload)
  2217. # 检查是否是环境传感器数据主题 (兼容旧 sensor/.../data 路径,spec 7.9 为 env/.../sensor)
  2218. sensor_topic = build_dtu_topic(dtu_config['customer_id'], 'sensor', dtu_config['dtu_id'], 'data')
  2219. env_topic = build_dtu_topic(dtu_config['customer_id'], 'env', dtu_config['dtu_id'], 'sensor')
  2220. if topic in (sensor_topic, env_topic) and isinstance(payload, dict):
  2221. if 'temperature' in payload or 'humidity' in payload:
  2222. update_env_sensor_data(
  2223. payload.get('temperature'),
  2224. payload.get('humidity'),
  2225. payload.get('dtu_temperature'),
  2226. payload.get('sensor_update_time')
  2227. )
  2228. # 检查是否是广播主题 - DTU发现 (7.14)
  2229. discover_topic = build_dtu_topic('broadcast', 'dtu', 'discover')
  2230. if topic == discover_topic:
  2231. handle_broadcast_discover(payload)
  2232. # 检查是否是广播主题 - 批量配置 (7.15)
  2233. config_topic = build_dtu_topic('broadcast', 'dtu', 'config')
  2234. if topic == config_topic:
  2235. handle_broadcast_config(payload)
  2236. # 转发到串口(如果启用)
  2237. if forward_mqtt_to_serial and _serial_connected():
  2238. success, msg = serial_client.send_data(payload_str)
  2239. if not success:
  2240. logger.warning(f"MQTT数据转发到串口失败: {msg}")
  2241. except Exception as e:
  2242. logger.error(f"处理MQTT数据时出错: {str(e)}")
  2243. # WebSocket事件处理
  2244. @socketio.on('connect', namespace=SOCKETIO_NAMESPACE_DATA)
  2245. def handle_data_connect():
  2246. """处理数据命名空间的连接"""
  2247. try:
  2248. client_id = str(uuid.uuid4())
  2249. connected_clients['data'].add(client_id)
  2250. logger.info(f'客户端已连接到数据命名空间,当前连接数: {len(connected_clients["data"])}')
  2251. # 发送当前的缓冲区数据,限制发送的历史记录数量
  2252. max_history = 100 # 限制发送的历史记录数量以提高性能
  2253. emit('serial_data_history', {'data': serial_data_buffer[-max_history:]})
  2254. emit('mqtt_data_history', {'data': mqtt_data_buffer[-max_history:]})
  2255. # 存储客户端ID以便断开连接时使用
  2256. socketio.start_background_task(target=lambda: None) # 确保上下文可用
  2257. except Exception as e:
  2258. logger.error(f"处理数据命名空间连接时出错: {str(e)}")
  2259. @socketio.on('connect', namespace=SOCKETIO_NAMESPACE_STATUS)
  2260. def handle_status_connect():
  2261. """处理状态命名空间的连接"""
  2262. try:
  2263. client_id = str(uuid.uuid4())
  2264. connected_clients['status'].add(client_id)
  2265. logger.info(f'客户端已连接到状态命名空间,当前连接数: {len(connected_clients["status"])}')
  2266. # 发送当前状态
  2267. emit('serial_status', {'connected': serial_status})
  2268. emit('mqtt_status', {'connected': mqtt_status})
  2269. emit('forward_status', {
  2270. 'serial_to_mqtt': forward_serial_to_mqtt,
  2271. 'mqtt_to_serial': forward_mqtt_to_serial,
  2272. 'publish_topic': mqtt_publish_topic
  2273. })
  2274. except Exception as e:
  2275. logger.error(f"处理状态命名空间连接时出错: {str(e)}")
  2276. @socketio.on('connect', namespace=SOCKETIO_NAMESPACE_CONTROL)
  2277. def handle_control_connect():
  2278. """处理控制命名空间的连接"""
  2279. try:
  2280. client_id = str(uuid.uuid4())
  2281. connected_clients['control'].add(client_id)
  2282. logger.info(f'客户端已连接到控制命名空间,当前连接数: {len(connected_clients["control"])}')
  2283. except Exception as e:
  2284. logger.error(f"处理控制命名空间连接时出错: {str(e)}")
  2285. @socketio.on('disconnect', namespace=SOCKETIO_NAMESPACE_DATA)
  2286. def handle_data_disconnect():
  2287. """处理数据命名空间的断开连接"""
  2288. try:
  2289. # 清理客户端连接记录
  2290. # 在实际应用中,可能需要更复杂的逻辑来追踪具体哪个客户端断开了连接
  2291. if len(connected_clients['data']) > 0:
  2292. # 这里简化处理,实际应该维护session到client_id的映射
  2293. connected_clients['data'].pop() # 注意:这是一个简化的实现
  2294. logger.info(f'客户端已断开数据命名空间的连接,当前连接数: {len(connected_clients["data"])}')
  2295. except Exception as e:
  2296. logger.error(f"处理数据命名空间断开连接时出错: {str(e)}")
  2297. @socketio.on('disconnect', namespace=SOCKETIO_NAMESPACE_STATUS)
  2298. def handle_status_disconnect():
  2299. """处理状态命名空间的断开连接"""
  2300. try:
  2301. # 清理客户端连接记录
  2302. if len(connected_clients['status']) > 0:
  2303. connected_clients['status'].pop()
  2304. logger.info(f'客户端已断开状态命名空间的连接,当前连接数: {len(connected_clients["status"])}')
  2305. except Exception as e:
  2306. logger.error(f"处理状态命名空间断开连接时出错: {str(e)}")
  2307. @socketio.on('disconnect', namespace=SOCKETIO_NAMESPACE_CONTROL)
  2308. def handle_control_disconnect():
  2309. """处理控制命名空间的断开连接"""
  2310. try:
  2311. # 清理客户端连接记录
  2312. if len(connected_clients['control']) > 0:
  2313. connected_clients['control'].pop()
  2314. logger.info(f'客户端已断开控制命名空间的连接,当前连接数: {len(connected_clients["control"])}')
  2315. except Exception as e:
  2316. logger.error(f"处理控制命名空间断开连接时出错: {str(e)}")
  2317. @socketio.on('serial_send', namespace=SOCKETIO_NAMESPACE_CONTROL)
  2318. def handle_serial_send(data):
  2319. """通过WebSocket处理串口发送数据请求"""
  2320. try:
  2321. message = data.get('message', '')
  2322. if not message:
  2323. emit('serial_send_response', {
  2324. 'success': False,
  2325. 'message': '消息内容不能为空',
  2326. 'error_code': ERROR_CODES['CONFIG_ERROR']
  2327. })
  2328. return
  2329. if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
  2330. emit('serial_send_response', {
  2331. 'success': False,
  2332. 'message': '串口未连接',
  2333. 'error_code': ERROR_CODES['SERIAL_CONNECTION_ERROR']
  2334. })
  2335. return
  2336. success, msg = serial_client.send_data(message)
  2337. emit('serial_send_response', {
  2338. 'success': success,
  2339. 'message': msg,
  2340. 'error_code': ERROR_CODES['SUCCESS'] if success else ERROR_CODES['SERIAL_SEND_ERROR']
  2341. })
  2342. if success:
  2343. logger.info(f"通过WebSocket发送串口数据成功: {message[:50]}..." if len(message) > 50 else message)
  2344. except Exception as e:
  2345. error_msg = f"处理串口发送请求时出错: {str(e)}"
  2346. logger.error(error_msg)
  2347. emit('serial_send_response', {
  2348. 'success': False,
  2349. 'message': error_msg,
  2350. 'error_code': ERROR_CODES['UNKNOWN_ERROR']
  2351. })
  2352. @socketio.on('mqtt_publish', namespace=SOCKETIO_NAMESPACE_CONTROL)
  2353. def handle_mqtt_publish(data):
  2354. """通过WebSocket处理MQTT发布数据请求"""
  2355. try:
  2356. topic = data.get('topic', '')
  2357. message = data.get('message', '')
  2358. if not topic or not message:
  2359. emit('mqtt_publish_response', {
  2360. 'success': False,
  2361. 'message': '主题或消息内容不能为空',
  2362. 'error_code': ERROR_CODES['CONFIG_ERROR']
  2363. })
  2364. return
  2365. if not _mqtt_connected():
  2366. emit('mqtt_publish_response', {
  2367. 'success': False,
  2368. 'message': 'MQTT未连接',
  2369. 'error_code': ERROR_CODES['MQTT_CONNECTION_ERROR']
  2370. })
  2371. return
  2372. success, msg = mqtt_client.publish(topic, message)
  2373. emit('mqtt_publish_response', {
  2374. 'success': success,
  2375. 'message': msg,
  2376. 'error_code': ERROR_CODES['SUCCESS'] if success else ERROR_CODES['MQTT_PUBLISH_ERROR']
  2377. })
  2378. if success:
  2379. logger.info(f"通过WebSocket发布MQTT消息成功: 主题={topic}, 消息={message[:50]}..." if len(message) > 50 else message)
  2380. except Exception as e:
  2381. error_msg = f"处理MQTT发布请求时出错: {str(e)}"
  2382. logger.error(error_msg)
  2383. emit('mqtt_publish_response', {
  2384. 'success': False,
  2385. 'message': error_msg,
  2386. 'error_code': ERROR_CODES['UNKNOWN_ERROR']
  2387. })
  2388. @socketio.on('update_forward_config', namespace=SOCKETIO_NAMESPACE_CONTROL)
  2389. def handle_update_forward_config(data):
  2390. """通过WebSocket更新转发配置"""
  2391. global forward_serial_to_mqtt, forward_mqtt_to_serial, mqtt_publish_topic
  2392. try:
  2393. # 更新转发标志
  2394. if 'serial_to_mqtt' in data:
  2395. forward_serial_to_mqtt = bool(data['serial_to_mqtt'])
  2396. if 'mqtt_to_serial' in data:
  2397. forward_mqtt_to_serial = bool(data['mqtt_to_serial'])
  2398. if 'publish_topic' in data:
  2399. new_topic = str(data['publish_topic'])
  2400. if not new_topic.strip():
  2401. raise ValueError("发布主题不能为空")
  2402. mqtt_publish_topic = new_topic
  2403. # 广播配置更新
  2404. socketio.emit('forward_status', {
  2405. 'serial_to_mqtt': forward_serial_to_mqtt,
  2406. 'mqtt_to_serial': forward_mqtt_to_serial,
  2407. 'publish_topic': mqtt_publish_topic
  2408. }, namespace=SOCKETIO_NAMESPACE_STATUS)
  2409. emit('update_forward_config_response', {
  2410. 'success': True,
  2411. 'message': '转发配置已更新',
  2412. 'error_code': ERROR_CODES['SUCCESS']
  2413. })
  2414. logger.info(f"转发配置已更新 - 串口到MQTT: {forward_serial_to_mqtt}, MQTT到串口: {forward_mqtt_to_serial}, 发布主题: {mqtt_publish_topic}")
  2415. except ValueError as e:
  2416. error_msg = str(e)
  2417. logger.warning(f"转发配置更新失败: {error_msg}")
  2418. emit('update_forward_config_response', {
  2419. 'success': False,
  2420. 'message': error_msg,
  2421. 'error_code': ERROR_CODES['CONFIG_ERROR']
  2422. })
  2423. except Exception as e:
  2424. error_msg = f'更新转发配置失败: {str(e)}'
  2425. logger.error(error_msg)
  2426. emit('update_forward_config_response', {
  2427. 'success': False,
  2428. 'message': error_msg,
  2429. 'error_code': ERROR_CODES['UNKNOWN_ERROR']
  2430. })
  2431. @socketio.on('clear_data_buffer', namespace=SOCKETIO_NAMESPACE_CONTROL)
  2432. def handle_clear_data_buffer(data):
  2433. """通过WebSocket清空数据缓冲区"""
  2434. try:
  2435. buffer_type = data.get('type', '')
  2436. if buffer_type == 'serial':
  2437. serial_data_buffer.clear()
  2438. emit('clear_data_buffer_response', {
  2439. 'success': True,
  2440. 'message': '串口数据缓冲区已清空',
  2441. 'error_code': ERROR_CODES['SUCCESS']
  2442. })
  2443. logger.info("串口数据缓冲区已清空")
  2444. elif buffer_type == 'mqtt':
  2445. mqtt_data_buffer.clear()
  2446. emit('clear_data_buffer_response', {
  2447. 'success': True,
  2448. 'message': 'MQTT数据缓冲区已清空',
  2449. 'error_code': ERROR_CODES['SUCCESS']
  2450. })
  2451. logger.info("MQTT数据缓冲区已清空")
  2452. elif buffer_type == 'all':
  2453. serial_data_buffer.clear()
  2454. mqtt_data_buffer.clear()
  2455. emit('clear_data_buffer_response', {
  2456. 'success': True,
  2457. 'message': '所有数据缓冲区已清空',
  2458. 'error_code': ERROR_CODES['SUCCESS']
  2459. })
  2460. logger.info("所有数据缓冲区已清空")
  2461. else:
  2462. emit('clear_data_buffer_response', {
  2463. 'success': False,
  2464. 'message': '无效的缓冲区类型',
  2465. 'error_code': ERROR_CODES['CONFIG_ERROR']
  2466. })
  2467. logger.warning(f"清空缓冲区失败: 无效的缓冲区类型 '{buffer_type}'")
  2468. except Exception as e:
  2469. error_msg = f'清空缓冲区失败: {str(e)}'
  2470. logger.error(error_msg)
  2471. emit('clear_data_buffer_response', {
  2472. 'success': False,
  2473. 'message': error_msg,
  2474. 'error_code': ERROR_CODES['UNKNOWN_ERROR']
  2475. })
  2476. # 设置回调
  2477. serial_client.set_data_callback(serial_data_handler)
  2478. serial_client.set_send_callback(serial_send_handler)
  2479. serial_client.set_status_callback(serial_status_handler)
  2480. mqtt_client.set_data_callback(mqtt_data_handler_extended)
  2481. mqtt_client.set_status_callback(mqtt_status_handler)
  2482. # 设备配置文件路径
  2483. DEVICE_CONFIG_FILE = '/root/dzxj_dtu/devices.json'
  2484. def save_device_config():
  2485. """保存设备配置到文件(快照 + 原子写)"""
  2486. try:
  2487. filepath = DEVICE_CONFIG_FILE
  2488. success = _save_config_file(filepath, address_config.get_stored_devices(), '设备配置')
  2489. if success:
  2490. logger.info(f"设备配置已保存到: {filepath}")
  2491. except Exception as e:
  2492. logger.error(f"保存设备配置失败: {str(e)}")
  2493. def load_device_config():
  2494. """加载设备配置(文件损坏时回退最新快照)"""
  2495. try:
  2496. filepath = DEVICE_CONFIG_FILE
  2497. if os.path.exists(filepath):
  2498. try:
  2499. devices = config_backup.read_json_file(filepath)
  2500. except Exception as e:
  2501. logger.error(f"读取设备配置失败: {e},尝试回退快照")
  2502. devices, snap = config_backup.latest_snapshot_content(filepath, BACKUP_DIR)
  2503. if not isinstance(devices, dict):
  2504. return {}
  2505. logger.warning(f"已从快照恢复设备配置: {snap}")
  2506. if isinstance(devices, dict):
  2507. address_config.stored_devices = devices
  2508. logger.info(f"已加载 {len(devices)} 个设备配置")
  2509. return devices
  2510. except Exception as e:
  2511. logger.error(f"加载设备配置失败: {str(e)}")
  2512. return {}
  2513. def _merge_panel_config(new_config):
  2514. """合并面板配置:叠加新发现的在线设备,并保留已标记为离线的面板
  2515. 离线设备保留在 panel_config 中(status='offline'),UI 可显示离线状态,
  2516. 轮询循环会跳过它们不再发查询;广播发现仍会定期尝试重新上线。
  2517. """
  2518. global panel_config
  2519. merged = dict(new_config)
  2520. for panel_id, cfg in panel_config.items():
  2521. if cfg.get('status') == 'offline' and panel_id not in merged:
  2522. merged[panel_id] = cfg
  2523. panel_config = merged
  2524. return merged
  2525. def sync_panel_config():
  2526. """根据 address_config.stored_devices 同步 panel_config"""
  2527. global panel_config
  2528. try:
  2529. devices = address_config.get_stored_devices()
  2530. panel_id_map = dtu_config.get('panel_id_mapping', {}) or {}
  2531. new_config = {}
  2532. for uid_hex, addr in devices.items():
  2533. custom_id = panel_id_map.get(uid_hex) or panel_id_map.get(addr)
  2534. if custom_id:
  2535. panel_id = str(custom_id)
  2536. else:
  2537. panel_id = f"PANEL_{dtu_config.get('dtu_id', 'DTU001')}_{addr}"
  2538. new_config[panel_id] = {
  2539. 'address': addr,
  2540. 'position': addr,
  2541. 'panel_uid': uid_hex,
  2542. 'status': 'online'
  2543. }
  2544. _merge_panel_config(new_config)
  2545. logger.info(f"已同步面板配置: {len(panel_config)} 个面板")
  2546. except Exception as e:
  2547. logger.error(f"同步面板配置失败: {str(e)}")
  2548. # API路由
  2549. # 移除静态文件服务,前端由nginx提供服务
  2550. # 根路径路由
  2551. @app.route('/')
  2552. def index():
  2553. return send_from_directory(STATIC_FOLDER, 'index.html')
  2554. # 404错误处理器 - 解决SPA路由刷新问题
  2555. @app.errorhandler(404)
  2556. def page_not_found(e):
  2557. """处理所有404错误,对于非API路径返回index.html"""
  2558. path = request.path
  2559. # 检查是否是API请求
  2560. if path.startswith('/api/'):
  2561. # 对于API请求,返回404错误
  2562. return jsonify({
  2563. 'success': False,
  2564. 'message': 'API endpoint not found'
  2565. }), 404
  2566. # 对于所有非API路径,返回index.html让前端路由处理
  2567. return send_from_directory(STATIC_FOLDER, 'index.html'), 200
  2568. @app.route('/api/serial/ports', methods=['GET'])
  2569. def get_serial_ports():
  2570. """获取可用串口列表"""
  2571. ports = serial_client.list_ports()
  2572. return jsonify({
  2573. 'success': True,
  2574. 'ports': ports
  2575. })
  2576. @app.route('/api/serial/connect', methods=['POST'])
  2577. def serial_connect():
  2578. """连接串口"""
  2579. try:
  2580. data = request.json
  2581. port = data.get('port')
  2582. baudrate = data.get('baudrate', 9600)
  2583. bytesize = data.get('bytesize', 8)
  2584. parity = data.get('parity', 'N')
  2585. stopbits = data.get('stopbits', 1)
  2586. timeout = data.get('timeout', 0.1)
  2587. if not port:
  2588. logger.warning("连接串口请求缺少串口名称")
  2589. return jsonify({
  2590. 'success': False,
  2591. 'message': '串口名称不能为空',
  2592. 'error_code': ERROR_CODES['CONFIG_ERROR']
  2593. }), 400
  2594. # 先断开之前的连接
  2595. _status = serial_client.get_status()
  2596. if isinstance(_status, dict) and _status.get('connected', False):
  2597. _port = serial_client.current_config.port if serial_client.current_config else 'unknown'
  2598. logger.info(f"断开现有串口连接: {_port}")
  2599. serial_client.disconnect()
  2600. # 连接新的串口
  2601. logger.info(f"尝试连接串口: {port}, 波特率: {baudrate}")
  2602. success, message = serial_client.connect(port, baudrate=baudrate, timeout=timeout, bytesize=bytesize, parity=parity, stopbits=stopbits)
  2603. status_code = 200 if success else 400
  2604. error_code = ERROR_CODES['SUCCESS'] if success else ERROR_CODES['SERIAL_CONNECTION_ERROR']
  2605. response = {
  2606. 'success': success,
  2607. 'message': message,
  2608. 'error_code': error_code
  2609. }
  2610. if success:
  2611. logger.info(f"串口连接成功: {port}")
  2612. # 保存串口配置
  2613. save_serial_config(port, baudrate, timeout, bytesize, parity, stopbits)
  2614. else:
  2615. logger.error(f"串口连接失败: {message}")
  2616. return jsonify(response), status_code
  2617. except Exception as e:
  2618. error_msg = f'连接串口时出错: {str(e)}'
  2619. logger.exception(error_msg) # 使用exception记录完整堆栈
  2620. return jsonify({
  2621. 'success': False,
  2622. 'message': error_msg,
  2623. 'error_code': ERROR_CODES['UNKNOWN_ERROR']
  2624. }), 500
  2625. @app.route('/api/serial/disconnect', methods=['POST'])
  2626. def serial_disconnect():
  2627. """断开串口连接"""
  2628. success, message = serial_client.disconnect()
  2629. return jsonify({
  2630. 'success': success,
  2631. 'message': message
  2632. })
  2633. @app.route('/api/serial/status', methods=['GET'])
  2634. def serial_get_status():
  2635. """获取串口状态"""
  2636. _st = serial_client.get_status()
  2637. saved_config = {}
  2638. try:
  2639. with open(SERIAL_CONFIG_FILE, 'r') as f:
  2640. saved_config = json.load(f)
  2641. except (FileNotFoundError, json.JSONDecodeError):
  2642. pass
  2643. result = {'saved_config': saved_config}
  2644. if isinstance(_st, dict):
  2645. result['connected'] = _st.get('connected', False)
  2646. if result['connected']:
  2647. cfg = _st.get('config')
  2648. result['port'] = cfg.port if cfg else None
  2649. else:
  2650. result['port'] = None
  2651. else:
  2652. result['connected'] = bool(_st)
  2653. result['port'] = None
  2654. return jsonify(result)
  2655. @app.route('/api/serial/send', methods=['POST'])
  2656. def serial_send():
  2657. """发送数据到串口"""
  2658. data = request.json
  2659. message = data.get('message')
  2660. if not message:
  2661. return jsonify({
  2662. 'success': False,
  2663. 'message': '消息内容不能为空'
  2664. })
  2665. success, message = serial_client.send_data(message)
  2666. return jsonify({
  2667. 'success': success,
  2668. 'message': message
  2669. })
  2670. @app.route('/api/mqtt/connect', methods=['POST'])
  2671. def mqtt_connect():
  2672. """连接MQTT服务器"""
  2673. try:
  2674. data = request.json
  2675. host = data.get('broker') or data.get('host', 'localhost')
  2676. port = data.get('port', 1883)
  2677. client_id = data.get('client_id', f'serial_gateway_{int(time.time())}')
  2678. username = data.get('username')
  2679. password = data.get('password')
  2680. keepalive = data.get('keepalive', 60)
  2681. # 先断开之前的连接
  2682. if _mqtt_connected():
  2683. _old = mqtt_client.config
  2684. _old_info = f"{_old.broker}:{_old.port}" if _old else "unknown"
  2685. logger.info(f"断开现有MQTT连接: {_old_info}")
  2686. mqtt_client.disconnect()
  2687. # 连接新的MQTT服务器
  2688. logger.info(f"尝试连接MQTT服务器: {host}:{port}, 客户端ID: {client_id}")
  2689. will_topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status')
  2690. will_payload = json.dumps({
  2691. 'dtu_id': dtu_config['dtu_id'], 'type': 'STATUS',
  2692. 'payload': {'online': False, 'reason': 'CONNECTION_LOST'}
  2693. })
  2694. success, message = mqtt_client.connect(
  2695. broker=host, port=port, client_id=client_id,
  2696. username=username or "", password=password or "",
  2697. keepalive=keepalive,
  2698. will_topic=will_topic, will_payload=will_payload, will_qos=1, will_retain=False
  2699. )
  2700. # 如果连接成功,订阅主题
  2701. if success and 'topics' in data:
  2702. mqtt_client.subscribe(data['topics'])
  2703. status_code = 200 if success else 400
  2704. error_code = ERROR_CODES['SUCCESS'] if success else ERROR_CODES['MQTT_CONNECTION_ERROR']
  2705. response = {
  2706. 'success': success,
  2707. 'message': message,
  2708. 'error_code': error_code
  2709. }
  2710. if success:
  2711. logger.info(f"MQTT服务器连接成功: {host}:{port}")
  2712. save_mqtt_config(
  2713. broker=host, port=port, client_id=client_id,
  2714. username=username or "", password=password or "",
  2715. keepalive=keepalive,
  2716. topics=data.get('topics', [])
  2717. )
  2718. else:
  2719. logger.error(f"MQTT服务器连接失败: {message}")
  2720. return jsonify(response), status_code
  2721. except Exception as e:
  2722. error_msg = f'连接MQTT服务器时出错: {str(e)}'
  2723. logger.exception(error_msg)
  2724. return jsonify({
  2725. 'success': False,
  2726. 'message': error_msg,
  2727. 'error_code': ERROR_CODES['UNKNOWN_ERROR']
  2728. }), 500
  2729. @app.route('/api/mqtt/disconnect', methods=['POST'])
  2730. def mqtt_disconnect():
  2731. """断开MQTT连接"""
  2732. success, message = mqtt_client.disconnect()
  2733. return jsonify({
  2734. 'success': success,
  2735. 'message': message
  2736. })
  2737. @app.route('/api/mqtt/status', methods=['GET'])
  2738. def mqtt_get_status():
  2739. """获取MQTT状态"""
  2740. _st = mqtt_client.get_status()
  2741. return jsonify({
  2742. 'connected': _st.get('connected', False) if isinstance(_st, dict) else bool(_st)
  2743. })
  2744. @app.route('/api/mqtt/publish', methods=['POST'])
  2745. def mqtt_publish():
  2746. """发布MQTT消息"""
  2747. data = request.json
  2748. topic = data.get('topic')
  2749. message = data.get('message')
  2750. if not topic or not message:
  2751. return jsonify({
  2752. 'success': False,
  2753. 'message': '主题和消息内容不能为空'
  2754. })
  2755. success, message = mqtt_client.publish(topic, message)
  2756. return jsonify({
  2757. 'success': success,
  2758. 'message': message
  2759. })
  2760. @app.route('/api/mqtt/subscribe', methods=['POST'])
  2761. def mqtt_subscribe():
  2762. """订阅MQTT主题"""
  2763. data = request.json
  2764. topics = data.get('topics', [])
  2765. if not topics:
  2766. return jsonify({
  2767. 'success': False,
  2768. 'message': '请至少订阅一个主题'
  2769. })
  2770. success, message = mqtt_client.subscribe(topics)
  2771. return jsonify({
  2772. 'success': success,
  2773. 'message': message
  2774. })
  2775. @app.route('/api/mqtt/broadcast_discover', methods=['POST'])
  2776. def mqtt_broadcast_discover():
  2777. """发送DTU发现广播 (7.14)
  2778. 服务器通过广播主题发送DISCOVER消息,
  2779. 触发所有在线DTU进行注册响应
  2780. """
  2781. data = request.json or {}
  2782. customer_id = data.get('customer_id', dtu_config.get('customer_id', 'default'))
  2783. discover_topic = build_dtu_topic('broadcast', 'dtu', 'discover')
  2784. request_id = f"dsc_{int(time.time() * 1000)}"
  2785. payload = {
  2786. 'msg_id': request_id,
  2787. 'timestamp': int(time.time() * 1000),
  2788. 'dtu_id': 'PLATFORM',
  2789. 'type': 'DISCOVER',
  2790. 'payload': {
  2791. 'request_id': request_id,
  2792. 'customer_id': customer_id
  2793. }
  2794. }
  2795. success, message = mqtt_client.publish(discover_topic, json.dumps(payload), qos=1)
  2796. logger.info(f"发送DTU发现广播: topic={discover_topic}, payload={payload}")
  2797. return jsonify({
  2798. 'success': success,
  2799. 'message': 'DTU发现广播已发送' if success else message,
  2800. 'topic': discover_topic
  2801. })
  2802. @app.route('/api/mqtt/broadcast_config', methods=['POST'])
  2803. def mqtt_broadcast_config():
  2804. """发送DTU批量配置广播 (7.15)
  2805. 服务器通过广播主题发送CONFIG消息,
  2806. 用于批量配置所有在线DTU
  2807. """
  2808. data = request.json or {}
  2809. customer_id = data.get('customer_id', dtu_config.get('customer_id', 'default'))
  2810. config_items = data.get('items', {})
  2811. config_version = data.get('config_version', f"cfg_{int(time.time())}")
  2812. force_apply = data.get('force_apply', False)
  2813. config_topic = build_dtu_topic('broadcast', 'dtu', 'config')
  2814. payload = {
  2815. 'msg_id': f"cfg_{int(time.time() * 1000)}",
  2816. 'timestamp': int(time.time() * 1000),
  2817. 'dtu_id': 'PLATFORM',
  2818. 'type': 'CONFIG',
  2819. 'payload': {
  2820. 'customer_id': customer_id,
  2821. 'config_version': config_version,
  2822. 'force_apply': force_apply,
  2823. 'items': config_items
  2824. }
  2825. }
  2826. success, message = mqtt_client.publish(config_topic, json.dumps(payload), qos=1)
  2827. logger.info(f"发送DTU批量配置广播: topic={config_topic}, payload={payload}")
  2828. return jsonify({
  2829. 'success': success,
  2830. 'message': 'DTU批量配置广播已发送' if success else message,
  2831. 'topic': config_topic,
  2832. 'config': {
  2833. 'config_version': config_version,
  2834. 'items': config_items,
  2835. 'force_apply': force_apply
  2836. }
  2837. })
  2838. @app.route('/api/data/serial', methods=['GET'])
  2839. def get_serial_data():
  2840. """获取串口数据"""
  2841. return jsonify({
  2842. 'data': serial_data_buffer
  2843. })
  2844. @app.route('/api/data/mqtt', methods=['GET'])
  2845. def get_mqtt_data():
  2846. """获取MQTT数据"""
  2847. return jsonify({
  2848. 'data': mqtt_data_buffer
  2849. })
  2850. @app.route('/api/forward/config', methods=['POST'])
  2851. def set_forward_config():
  2852. """设置转发配置"""
  2853. global forward_serial_to_mqtt, forward_mqtt_to_serial, mqtt_publish_topic
  2854. data = request.json
  2855. forward_serial_to_mqtt = data.get('serial_to_mqtt', False)
  2856. forward_mqtt_to_serial = data.get('mqtt_to_serial', False)
  2857. if 'publish_topic' in data:
  2858. mqtt_publish_topic = data['publish_topic']
  2859. return jsonify({
  2860. 'success': True,
  2861. 'message': '转发配置已更新',
  2862. 'config': {
  2863. 'serial_to_mqtt': forward_serial_to_mqtt,
  2864. 'mqtt_to_serial': forward_mqtt_to_serial,
  2865. 'publish_topic': mqtt_publish_topic
  2866. }
  2867. })
  2868. @app.route('/api/forward/status', methods=['GET'])
  2869. def get_forward_status():
  2870. """获取转发状态"""
  2871. return jsonify({
  2872. 'serial_to_mqtt': forward_serial_to_mqtt,
  2873. 'mqtt_to_serial': forward_mqtt_to_serial,
  2874. 'publish_topic': mqtt_publish_topic
  2875. })
  2876. # 健康检查端点
  2877. @app.route('/api/health', methods=['GET'])
  2878. def health_check():
  2879. """健康检查端点"""
  2880. try:
  2881. # 获取客户端连接数量
  2882. client_counts = {
  2883. 'data': len(connected_clients['data']),
  2884. 'status': len(connected_clients['status']),
  2885. 'control': len(connected_clients['control'])
  2886. }
  2887. # 获取缓冲区大小
  2888. buffer_sizes = {
  2889. 'serial': len(serial_data_buffer),
  2890. 'mqtt': len(mqtt_data_buffer)
  2891. }
  2892. # 执行系统负载检查
  2893. # 注意:这只是一个简化的负载检查,实际应用中可能需要更复杂的监控
  2894. is_healthy = True
  2895. load_warnings = []
  2896. # 检查缓冲区是否过大
  2897. if buffer_sizes['serial'] > MAX_BUFFER_SIZE * 0.8:
  2898. is_healthy = False
  2899. load_warnings.append(f"串口缓冲区接近最大容量: {buffer_sizes['serial']}/{MAX_BUFFER_SIZE}")
  2900. if buffer_sizes['mqtt'] > MAX_BUFFER_SIZE * 0.8:
  2901. is_healthy = False
  2902. load_warnings.append(f"MQTT缓冲区接近最大容量: {buffer_sizes['mqtt']}/{MAX_BUFFER_SIZE}")
  2903. # 检查WebSocket连接数是否过多
  2904. total_clients = sum(client_counts.values())
  2905. if total_clients > 100: # 设置合理的阈值
  2906. is_healthy = False
  2907. load_warnings.append(f"WebSocket连接数过多: {total_clients}")
  2908. # 尝试获取网络状态信息(使用try-except包装,防止网络模块出错导致健康检查失败)
  2909. network_info = None
  2910. try:
  2911. network_info = network_manager.get_network_status()
  2912. except Exception as e:
  2913. logger.warning(f"获取网络状态时出错: {str(e)}")
  2914. # 不影响整体健康检查,只添加警告
  2915. load_warnings.append(f"网络状态获取失败: {str(e)}")
  2916. response = {
  2917. 'status': 'healthy' if is_healthy else 'warning',
  2918. 'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
  2919. 'services': {
  2920. 'serial': serial_status,
  2921. 'mqtt': mqtt_status,
  2922. 'websocket': True
  2923. },
  2924. 'client_counts': client_counts,
  2925. 'buffer_sizes': buffer_sizes,
  2926. 'warnings': load_warnings
  2927. }
  2928. # 仅当获取到网络信息时添加
  2929. if network_info:
  2930. response['network'] = network_info
  2931. return jsonify(response), 200
  2932. except Exception as e:
  2933. # 捕获所有异常,确保健康检查不会返回500错误
  2934. logger.error(f"健康检查端点出错: {str(e)}")
  2935. # 返回一个基础的健康状态,至少显示服务在运行
  2936. return jsonify({
  2937. 'status': 'error',
  2938. 'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
  2939. 'error': str(e),
  2940. 'services': {
  2941. 'api': True, # API服务本身是运行的
  2942. 'serial': None,
  2943. 'mqtt': None,
  2944. 'websocket': None
  2945. }
  2946. }), 200 # 仍然返回200,避免健康检查导致的连锁反应
  2947. @app.route('/api/screen/status', methods=['GET'])
  2948. def get_screen_status():
  2949. """获取 Nextion 屏幕状态。"""
  2950. with screen_lock:
  2951. panels = get_sorted_panels()
  2952. current_index = screen_current_panel_index
  2953. current_panel_id = None
  2954. if panels and 0 <= current_index < len(panels):
  2955. current_panel_id = panels[current_index][0]
  2956. panel_count = len(panels)
  2957. status = screen_display.get_status()
  2958. return jsonify({
  2959. 'success': True,
  2960. 'data': {
  2961. 'connected': status.get('connected', False),
  2962. 'port': status.get('port'),
  2963. 'baudrate': status.get('baudrate'),
  2964. 'current_panel_index': current_index,
  2965. 'current_panel_id': current_panel_id,
  2966. 'panel_count': panel_count
  2967. }
  2968. })
  2969. @app.route('/api/screen/refresh', methods=['POST'])
  2970. def refresh_screen():
  2971. """手动刷新当前 panel 到屏幕。"""
  2972. with screen_lock:
  2973. panels = get_sorted_panels()
  2974. if not panels:
  2975. return jsonify({'success': False, 'message': '没有可用的 panel'}), 400
  2976. if not (0 <= screen_current_panel_index < len(panels)):
  2977. return jsonify({'success': False, 'message': '当前 panel 索引无效'}), 400
  2978. panel_id = panels[screen_current_panel_index][0]
  2979. success, message = refresh_screen_panel(panel_id)
  2980. if success:
  2981. return jsonify({'success': True, 'message': message})
  2982. return jsonify({'success': False, 'message': message}), 400
  2983. @app.route('/api/screen/test_cmd', methods=['POST'])
  2984. def screen_test_cmd():
  2985. """向 Nextion 屏幕发送原始命令(调试用)。"""
  2986. try:
  2987. data = request.json
  2988. cmd = data.get('cmd')
  2989. if not cmd:
  2990. return jsonify({'success': False, 'message': '缺少 cmd 参数'}), 400
  2991. status = screen_display.get_status()
  2992. if not status.get('connected'):
  2993. return jsonify({'success': False, 'message': '屏幕串口未连接'}), 400
  2994. ok = screen_display.send_cmd(cmd, delay_ms=data.get('delay_ms', 50))
  2995. logger.info(f"[Nextion TEST] cmd={cmd} ok={ok}")
  2996. return jsonify({'success': ok, 'cmd': cmd, 'screen_connected': True})
  2997. except Exception as e:
  2998. logger.error(f"屏幕测试命令失败: {e}")
  2999. return jsonify({'success': False, 'message': str(e)}), 500
  3000. # 网络配置相关API
  3001. @app.route('/api/network/config', methods=['GET'])
  3002. def get_network_config():
  3003. """获取当前网络配置"""
  3004. try:
  3005. config = network_manager.get_network_config()
  3006. return jsonify(config)
  3007. except Exception as e:
  3008. logger.error(f'获取网络配置失败: {str(e)}')
  3009. return jsonify({'success': False, 'message': f'获取网络配置失败: {str(e)}'}), 500
  3010. @app.route('/api/network/config', methods=['POST'])
  3011. def update_network_config():
  3012. """更新网络配置"""
  3013. try:
  3014. config_data = request.json
  3015. result = network_manager.update_network_config(config_data)
  3016. if result['success']:
  3017. return jsonify(result)
  3018. else:
  3019. return jsonify(result), 400
  3020. except Exception as e:
  3021. logger.error(f'更新网络配置失败: {str(e)}')
  3022. return jsonify({'success': False, 'message': f'更新网络配置失败: {str(e)}'}), 500
  3023. @app.route('/api/network/status', methods=['GET'])
  3024. def get_network_status():
  3025. """获取网络状态信息"""
  3026. try:
  3027. status = network_manager.get_network_status()
  3028. return jsonify(status)
  3029. except Exception as e:
  3030. logger.error(f'获取网络状态失败: {str(e)}')
  3031. return jsonify({'success': False, 'message': f'获取网络状态失败: {str(e)}'}), 500
  3032. @app.route('/api/network/restart', methods=['POST'])
  3033. def restart_network_service():
  3034. """重启网络服务以应用新配置"""
  3035. try:
  3036. result = network_manager.restart_network_service()
  3037. if result['success']:
  3038. return jsonify(result)
  3039. else:
  3040. return jsonify(result), 500
  3041. except Exception as e:
  3042. logger.error(f'重启网络服务失败: {str(e)}')
  3043. return jsonify({'success': False, 'message': f'重启网络服务失败: {str(e)}'}), 500
  3044. # Modbus RTU API
  3045. @app.route('/api/modbus/antenna_addresses', methods=['GET'])
  3046. def get_antenna_addresses():
  3047. """获取天线地址映射表"""
  3048. return jsonify({
  3049. 'success': True,
  3050. 'antennas': {str(k): f"0x{v:04x}" for k, v in ANTENNA_ADDRESSES.items()}
  3051. })
  3052. @app.route('/api/modbus/read_antenna', methods=['POST'])
  3053. def modbus_read_antenna():
  3054. """读取指定天线的卡号
  3055. 请求参数:
  3056. {
  3057. "device_address": 1, // 设备地址 (1-247)
  3058. "antenna": 1, // 天线编号 (1-24)
  3059. "timeout": 1.0 // 可选,超时时间(秒)
  3060. }
  3061. """
  3062. try:
  3063. data = request.json
  3064. device_address = data.get('device_address', 1)
  3065. antenna = data.get('antenna', 1)
  3066. timeout = data.get('timeout')
  3067. if antenna < 1 or antenna > 24:
  3068. return jsonify({
  3069. 'success': False,
  3070. 'message': f'无效的天线编号: {antenna}, 必须是1-24'
  3071. }), 400
  3072. if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
  3073. return jsonify({
  3074. 'success': False,
  3075. 'message': '串口未连接'
  3076. }), 400
  3077. result = modbus_client.read_antenna_card(
  3078. device_address=device_address,
  3079. antenna_num=antenna,
  3080. timeout=timeout
  3081. )
  3082. if 'error' in result:
  3083. return jsonify({
  3084. 'success': False,
  3085. 'message': result['error'],
  3086. 'raw_data': result.get('raw_data', '')
  3087. }), 400
  3088. return jsonify({
  3089. 'success': True,
  3090. 'data': result
  3091. })
  3092. except Exception as e:
  3093. logger.error(f'读取天线数据失败: {str(e)}')
  3094. return jsonify({
  3095. 'success': False,
  3096. 'message': str(e)
  3097. }), 500
  3098. @app.route('/api/modbus/read_all_cards', methods=['POST'])
  3099. def modbus_read_all_cards():
  3100. """V4: 一次批量读取全部 24 路天线卡号
  3101. 请求参数:
  3102. {
  3103. "device_address": 2,
  3104. "timeout": 1.0
  3105. }
  3106. 返回:
  3107. {
  3108. "success": true,
  3109. "data": {
  3110. "device_address": 2,
  3111. "cards": [
  3112. {"antenna": 1, "present": false, "card_str": "", "uid": ""},
  3113. {"antenna": 2, "present": true, "card_str": "aabbccddeeff", "uid": "aa:bb:cc:dd:ee:ff"},
  3114. ...
  3115. ]
  3116. }
  3117. }
  3118. """
  3119. try:
  3120. data = request.json or {}
  3121. device_address = data.get('device_address', 1)
  3122. timeout = data.get('timeout')
  3123. if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
  3124. return jsonify({'success': False, 'message': '串口未连接'}), 400
  3125. result = modbus_client.read_all_antenna_cards(device_address, timeout=timeout)
  3126. if 'error' in result:
  3127. return jsonify({
  3128. 'success': False,
  3129. 'message': result['error'],
  3130. 'raw_data': result.get('raw_data', '')
  3131. }), 400
  3132. return jsonify({'success': True, 'data': result})
  3133. except Exception as e:
  3134. logger.error(f'批量读卡失败: {str(e)}')
  3135. return jsonify({'success': False, 'message': str(e)}), 500
  3136. @app.route('/api/modbus/set_card_mapping', methods=['POST'])
  3137. def modbus_set_card_mapping():
  3138. """V4: 设置24路天线卡号到配线架硬件(0x10 写 0x0003,144字节)
  3139. 请求参数:
  3140. {
  3141. "device_address": 1,
  3142. "card_mappings": {"1": "aabbccddeeff", "2": null, ...}, // 完整模式:24路映射
  3143. // 或单端口模式:
  3144. "port_id": 1,
  3145. "card_uid": "aabbccddeeff", // null/空表示清除该端口卡号
  3146. "panel_id": "PANEL_dtu_001_2", // 单端口模式下用于读取其余端口期望卡号(可选)
  3147. "timeout": 2.0
  3148. }
  3149. 返回:
  3150. {
  3151. "success": true,
  3152. "data": {"device_address": 1, "cards_written": {...}, "raw_data": "..."}
  3153. }
  3154. """
  3155. try:
  3156. data = request.json or {}
  3157. device_address = data.get('device_address', 1)
  3158. timeout = data.get('timeout')
  3159. if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
  3160. return jsonify({'success': False, 'message': '串口未连接'}), 400
  3161. card_mappings = data.get('card_mappings')
  3162. single_port_mode = card_mappings is None
  3163. target_port_id = None
  3164. single_target_uid = None
  3165. if card_mappings is None:
  3166. # 单端口模式:构建 24 路数据,避免擦掉其他端口
  3167. # 策略: 先读硬件当前值做基底 → 再用 dtu_config 期望值覆盖 → 最后覆盖目标端口
  3168. # 这样 dtu_config 没记录但硬件已有卡号的端口(例如修复前设置的)不会被误清为 0xFF
  3169. port_id = data.get('port_id')
  3170. card_uid = data.get('card_uid')
  3171. # panel_id 解析:前端传的优先,否则用 device_address 反查 panel_config(LedDebug.vue 默认只传 address)
  3172. panel_id_from_req = _resolve_panel_id(data.get('panel_id'))
  3173. panel_id_from_addr = None
  3174. for pid, cfg in panel_config.items():
  3175. if cfg.get('address') == device_address:
  3176. panel_id_from_addr = pid
  3177. break
  3178. panel_id = panel_id_from_req or panel_id_from_addr
  3179. if port_id is None:
  3180. return jsonify({'success': False, 'message': '缺少 port_id 或 card_mappings'}), 400
  3181. try:
  3182. target_port_id = int(port_id)
  3183. except (ValueError, TypeError):
  3184. return jsonify({'success': False, 'message': f'port_id 非法: {port_id}'}), 400
  3185. # 第一步:读硬件当前 24 路值,作为默认基底(防止擦掉其他端口硬件里真实存在的卡号)
  3186. card_mappings = _hardware_card_base(device_address)
  3187. # 第二步:用 dtu_config 期望值覆盖(平台下发的才是权威,硬件基底只补缺失项)
  3188. # 注意:显式清除(值为 null)也要覆盖,避免被硬件基底还原成旧卡号
  3189. if panel_id:
  3190. overrides = _dtu_mapping_overrides(panel_id)
  3191. for ant, v in overrides.items():
  3192. card_mappings[ant] = v
  3193. logger.debug(f"单端口模式 panel={panel_id} dtu_config 期望合入: {sum(1 for v in overrides.values() if v)} 路")
  3194. # 第三步:最后覆盖目标端口(用户要设置/清除的值优先级最高)
  3195. if card_uid:
  3196. uid = str(card_uid).strip().upper().replace(':', '').replace(' ', '')
  3197. if len(uid) != 12 or not all(c in _JUMPER_HEX for c in uid):
  3198. return jsonify({'success': False, 'message': f'卡号必须是12位十六进制: {card_uid}'}), 400
  3199. single_target_uid = uid
  3200. card_mappings[target_port_id] = single_target_uid
  3201. # 转换 key 为 int
  3202. normalized = {}
  3203. for k, v in card_mappings.items():
  3204. try:
  3205. port = int(k)
  3206. except (ValueError, TypeError):
  3207. return jsonify({'success': False, 'message': f'端口编号非法: {k}'}), 400
  3208. if not (1 <= port <= 24):
  3209. return jsonify({'success': False, 'message': f'端口编号必须在1-24: {port}'}), 400
  3210. normalized[port] = v
  3211. result = modbus_client.set_card_mapping(device_address, normalized, timeout=timeout)
  3212. if 'error' in result:
  3213. return jsonify({
  3214. 'success': False,
  3215. 'message': result['error'],
  3216. 'raw_data': result.get('raw_data', '')
  3217. }), 400
  3218. # 硬件写入成功:同步更新本地 port_state 期望值 + 持久化 dtu_config
  3219. # 1. 先通过 device_address 反查 panel_id
  3220. panel_id_by_addr = None
  3221. for pid, cfg in panel_config.items():
  3222. if cfg.get('address') == device_address:
  3223. panel_id_by_addr = pid
  3224. break
  3225. # 单端口模式下若传入了 panel_id,优先用传入值
  3226. panel_target = _resolve_panel_id(data.get('panel_id')) or panel_id_by_addr
  3227. warnings = []
  3228. cards_written = result.get('cards_written', {})
  3229. if panel_target:
  3230. if single_port_mode:
  3231. # 单端口模式:硬件帧虽带全 24 口,但平台只记录目标这一条,
  3232. # 不再把硬件读回的卡号/未用端口灌进配置(修复端口映射污染)。
  3233. expected_uid = single_target_uid
  3234. port_state.setdefault(panel_target, {}).setdefault(target_port_id, {
  3235. 'last_uid': None, 'expected_uid': None, 'alarm_count': 0
  3236. })
  3237. port_state[panel_target][target_port_id]['expected_uid'] = expected_uid
  3238. _store_port_mapping(panel_target, target_port_id, expected_uid)
  3239. save_dtu_config()
  3240. logger.info(
  3241. f"卡号设置页 面板{panel_target} 端口{target_port_id} 已同步本地期望: "
  3242. f"{expected_uid or '已清除'}"
  3243. )
  3244. else:
  3245. # 完整模式:按提交的 24 路全量落盘;空值用删除语义(不写 null)
  3246. port_state.setdefault(panel_target, {})
  3247. for port_id, uid in cards_written.items():
  3248. port_id = int(port_id)
  3249. expected_uid = None
  3250. if uid:
  3251. clean_uid = str(uid).strip().upper().replace(':', '').replace(' ', '')
  3252. if len(clean_uid) == 12 and all(c in _JUMPER_HEX for c in clean_uid):
  3253. expected_uid = clean_uid
  3254. port_state[panel_target].setdefault(port_id, {
  3255. 'last_uid': None, 'expected_uid': None, 'alarm_count': 0
  3256. })
  3257. port_state[panel_target][port_id]['expected_uid'] = expected_uid
  3258. _store_port_mapping(panel_target, port_id, expected_uid)
  3259. save_dtu_config()
  3260. logger.info(f"卡号设置页 面板{panel_target} 已全量同步本地期望: {len(cards_written)} 路")
  3261. else:
  3262. warnings.append(f"未找到 device_address={device_address} 对应的面板,本地期望值未更新(仅硬件已生效)")
  3263. return jsonify({'success': True, 'data': result, 'warnings': warnings})
  3264. except Exception as e:
  3265. logger.error(f'设置卡号失败: {str(e)}')
  3266. return jsonify({'success': False, 'message': str(e)}), 500
  3267. @app.route('/api/modbus/read_registers', methods=['POST'])
  3268. def modbus_read_registers():
  3269. """读取保持寄存器
  3270. 请求参数:
  3271. {
  3272. "device_address": 1,
  3273. "start_address": 2, // 起始地址 (十六进制如0x0002或十进制如2)
  3274. "quantity": 4, // 寄存器数量
  3275. "timeout": 1.0
  3276. }
  3277. """
  3278. try:
  3279. data = request.json
  3280. device_address = data.get('device_address', 1)
  3281. start_address = data.get('start_address', 0)
  3282. quantity = data.get('quantity', 1)
  3283. timeout = data.get('timeout')
  3284. # 支持十六进制字符串
  3285. if isinstance(start_address, str):
  3286. start_address = int(start_address, 16)
  3287. if isinstance(device_address, str):
  3288. device_address = int(device_address, 16)
  3289. if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
  3290. return jsonify({
  3291. 'success': False,
  3292. 'message': '串口未连接'
  3293. }), 400
  3294. result = modbus_client.read_holding_registers(
  3295. device_address=device_address,
  3296. start_address=start_address,
  3297. quantity=quantity,
  3298. timeout=timeout
  3299. )
  3300. if 'error' in result:
  3301. return jsonify({
  3302. 'success': False,
  3303. 'message': result['error'],
  3304. 'raw_data': result.get('raw_data', '')
  3305. }), 400
  3306. return jsonify({
  3307. 'success': True,
  3308. 'data': result
  3309. })
  3310. except Exception as e:
  3311. logger.error(f'读取寄存器失败: {str(e)}')
  3312. return jsonify({
  3313. 'success': False,
  3314. 'message': str(e)
  3315. }), 500
  3316. @app.route('/api/modbus/write_register', methods=['POST'])
  3317. def modbus_write_register():
  3318. """写单个寄存器
  3319. 请求参数:
  3320. {
  3321. "device_address": 1,
  3322. "register_address": 1, // 寄存器地址
  3323. "value": 256, // 写入的值
  3324. "timeout": 1.0
  3325. }
  3326. """
  3327. try:
  3328. data = request.json
  3329. device_address = data.get('device_address', 1)
  3330. register_address = data.get('register_address', 1)
  3331. value = data.get('value', 0)
  3332. timeout = data.get('timeout')
  3333. if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
  3334. return jsonify({
  3335. 'success': False,
  3336. 'message':'串口未连接'
  3337. }), 400
  3338. result = modbus_client.write_single_register(
  3339. device_address=device_address,
  3340. register_address=register_address,
  3341. value=value,
  3342. timeout=timeout
  3343. )
  3344. if 'error' in result:
  3345. return jsonify({
  3346. 'success': False,
  3347. 'message': result['error'],
  3348. 'raw_data': result.get('raw_data', '')
  3349. }), 400
  3350. return jsonify({
  3351. 'success': True,
  3352. 'data': result
  3353. })
  3354. except Exception as e:
  3355. logger.error(f'写寄存器失败: {str(e)}')
  3356. return jsonify({
  3357. 'success': False,
  3358. 'message': str(e)
  3359. }), 500
  3360. @app.route('/api/modbus/set_rgb_led', methods=['POST'])
  3361. def modbus_set_rgb_led():
  3362. """设置RGB灯状态
  3363. 请求参数:
  3364. {
  3365. "device_address": 1,
  3366. "led_number": 1, // 灯编号 (1-24)
  3367. "color": 1, // 颜色: 0=灭, 1=红灯, 2=绿灯, 3=蓝灯
  3368. "timeout": 1.0
  3369. }
  3370. """
  3371. try:
  3372. data = request.json
  3373. device_address = data.get('device_address', 1)
  3374. led_number = data.get('led_number', 1)
  3375. color = data.get('color', 0)
  3376. timeout = data.get('timeout')
  3377. if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
  3378. return jsonify({
  3379. 'success': False,
  3380. 'message': '串口未连接'
  3381. }), 400
  3382. result = modbus_client.set_rgb_led(
  3383. device_address=device_address,
  3384. led_number=led_number,
  3385. color=color,
  3386. timeout=timeout
  3387. )
  3388. if 'error' in result:
  3389. return jsonify({
  3390. 'success': False,
  3391. 'message': result['error'],
  3392. 'raw_data': result.get('raw_data', '')
  3393. }), 400
  3394. # 按设备地址更新 LED 状态追踪
  3395. if device_address not in led_states:
  3396. led_states[device_address] = {}
  3397. led_states[device_address][led_number] = color
  3398. _refresh_current_screen_panel()
  3399. return jsonify({
  3400. 'success': True,
  3401. 'data': result
  3402. })
  3403. except Exception as e:
  3404. logger.error(f'设置RGB灯失败: {str(e)}')
  3405. return jsonify({
  3406. 'success': False,
  3407. 'message': str(e)
  3408. }), 500
  3409. # ========== 测试注入 API(模拟串口假数据,用于告警/同步映射端到端测试) ==========
  3410. @app.route('/api/test/inject_cards', methods=['POST'])
  3411. def test_inject_cards():
  3412. """注入假卡号,绕过真实串口。
  3413. 请求 body:
  3414. {
  3415. "cards": {
  3416. "2": {"1": "aabbccddeeff", "5": null, "12": "112233445566"}
  3417. }
  3418. }
  3419. key 为设备地址(Modbus 从机地址),value 为 {port_id: hex12|null}。
  3420. 调用后轮询将读到构造的卡号,触发 event/alarm 流程。
  3421. """
  3422. try:
  3423. data = request.json or {}
  3424. raw = data.get('cards')
  3425. if raw is None:
  3426. modbus_client.test_cards = None
  3427. return jsonify({'success': True, 'message': '注入已清空,恢复真实串口'})
  3428. parsed = {}
  3429. for addr_str, port_map in raw.items():
  3430. addr = int(addr_str)
  3431. pm = {}
  3432. for pid_str, hex_str in (port_map or {}).items():
  3433. pid = int(pid_str)
  3434. if hex_str in (None, '', 'null'):
  3435. pm[pid] = None
  3436. else:
  3437. s = hex_str.lower()
  3438. if len(s) != 12:
  3439. return jsonify({'success': False, 'message': f'hex 必须 12 字符: addr={addr} port={pid}'}), 400
  3440. bytes.fromhex(s) # 校验
  3441. pm[pid] = s
  3442. parsed[addr] = pm
  3443. modbus_client.test_cards = parsed
  3444. return jsonify({'success': True, 'test_cards': {
  3445. str(a): {str(p): v for p, v in m.items()} for a, m in parsed.items()
  3446. }})
  3447. except Exception as e:
  3448. return jsonify({'success': False, 'message': str(e)}), 400
  3449. @app.route('/api/test/inject_cards', methods=['GET'])
  3450. def test_inject_cards_get():
  3451. """查看当前注入状态"""
  3452. tc = modbus_client.test_cards
  3453. if tc is None:
  3454. return jsonify({'success': True, 'injected': False})
  3455. return jsonify({
  3456. 'success': True, 'injected': True,
  3457. 'cards': {str(a): {str(p): v for p, v in m.items()} for a, m in tc.items()}
  3458. })
  3459. @app.route('/api/modbus/scan', methods=['POST'])
  3460. def modbus_scan_devices():
  3461. """扫描在线设备
  3462. 请求参数:
  3463. {
  3464. "max_address": 247, // 最大设备地址
  3465. "timeout": 0.2 // 单个设备超时时间
  3466. }
  3467. """
  3468. try:
  3469. data = request.json or {}
  3470. max_address = data.get('max_address', 247)
  3471. timeout = data.get('timeout', 0.2)
  3472. if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
  3473. return jsonify({
  3474. 'success': False,
  3475. 'message': '串口未连接'
  3476. }), 400
  3477. # 异步扫描可能更好,但这里先同步实现
  3478. result = modbus_client.scan_devices(max_address)
  3479. return jsonify({
  3480. 'success': True,
  3481. 'devices': result
  3482. })
  3483. except Exception as e:
  3484. logger.error(f'扫描设备失败: {str(e)}')
  3485. return jsonify({
  3486. 'success': False,
  3487. 'message': str(e)
  3488. }), 500
  3489. # ========== 地址查询 / 确认 / 配置地址 API(V5 协议) ==========
  3490. @app.route('/api/modbus/query_address', methods=['POST'])
  3491. def modbus_query_address():
  3492. """V5 地址查询(0x80):对指定固定地址发送查询帧。
  3493. 请求体: {"address": 1, "uid": "24位hex" 或省略, "timeout": 0.5}
  3494. uid 省略/为空时使用 12 字节全 0(未绑定地址探测)。
  3495. """
  3496. try:
  3497. data = request.json or {}
  3498. addr = data.get('address')
  3499. try:
  3500. addr = int(addr)
  3501. except (TypeError, ValueError):
  3502. return jsonify({'success': False, 'message': '请提供有效的 address'}), 400
  3503. uid = (data.get('uid') or '').strip() or None
  3504. timeout = data.get('timeout')
  3505. if not _serial_connected():
  3506. return jsonify({'success': False, 'message': '串口未连接'}), 400
  3507. result = modbus_client.query_address(addr, uid=uid,
  3508. timeout=timeout or PANEL_QUERY_TIMEOUT)
  3509. payload = {'success': 'error' not in result, 'requested_address': addr}
  3510. payload.update(result)
  3511. return jsonify(payload)
  3512. except Exception as e:
  3513. logger.error(f'地址查询失败: {str(e)}')
  3514. return jsonify({'success': False, 'message': str(e)}), 500
  3515. @app.route('/api/modbus/confirm_address', methods=['POST'])
  3516. def modbus_confirm_address():
  3517. """手动调试:V5 地址确认(0x82)。
  3518. 注意:80/81 口径下 82/83 已废弃,自动注册/接管流程不再发送本帧(收到匹配 81 即本地建立在线)。
  3519. 本接口仅用于现场手工调试,默认只发帧、不写本地绑定表;bind=true 时同时写入并持久化。
  3520. 请求体: {"address": 1, "uid": "24位hex"}
  3521. """
  3522. try:
  3523. data = request.json or {}
  3524. addr = data.get('address')
  3525. uid = (data.get('uid') or '').strip().lower()
  3526. try:
  3527. addr = int(addr)
  3528. except (TypeError, ValueError):
  3529. return jsonify({'success': False, 'message': '请提供有效的 address'}), 400
  3530. if len(uid) != 24:
  3531. return jsonify({'success': False, 'message': 'UID长度必须是24个十六进制字符'}), 400
  3532. if not _serial_connected():
  3533. return jsonify({'success': False, 'message': '串口未连接'}), 400
  3534. result = modbus_client.confirm_address(addr, uid, timeout=PANEL_QUERY_TIMEOUT)
  3535. if data.get('bind') and 'error' not in result:
  3536. old_uid = _binding_uid_for_address(addr)
  3537. if old_uid and old_uid != uid:
  3538. address_config.stored_devices.pop(old_uid, None)
  3539. address_config.stored_devices[uid] = addr
  3540. save_device_config()
  3541. pid = _panel_id_for_address(addr)
  3542. if pid in panel_config:
  3543. panel_config[pid]['panel_uid'] = uid
  3544. logger.info(f"手动写入线架绑定: 地址={addr} UID={uid}")
  3545. payload = {'success': 'error' not in result}
  3546. payload.update(result)
  3547. return jsonify(payload)
  3548. except Exception as e:
  3549. logger.error(f'地址确认失败: {str(e)}')
  3550. return jsonify({'success': False, 'message': str(e)}), 500
  3551. @app.route('/api/modbus/stored_devices', methods=['GET'])
  3552. def get_stored_devices():
  3553. """获取已注册线架列表(地址↔UID 绑定 + 在线/缺失状态)"""
  3554. devices = address_config.get_stored_devices()
  3555. now = time.time()
  3556. online_threshold = 60 # 60 秒内被轮询到视为在线
  3557. panels = []
  3558. for uid, addr in devices.items():
  3559. pid = _panel_id_for_address(addr)
  3560. ps = port_state.get(pid, {})
  3561. last_seen = device_last_seen.get(pid) or device_last_seen.get(uid)
  3562. recent = bool(last_seen) and (now - last_seen) < online_threshold
  3563. ka_miss = panel_keepalive_miss.get(pid, 0)
  3564. conflict_uid = panel_conflict.get(pid)
  3565. # 80/81 口径:cfg.status 为准(匹配 81=online,连续2次无匹配81=offline)
  3566. cfg_status = (panel_config.get(pid) or {}).get('status')
  3567. if cfg_status == 'offline' or ka_miss >= PANEL_KEEPALIVE_MISS_LIMIT:
  3568. status = 'offline'
  3569. elif conflict_uid:
  3570. status = 'conflict'
  3571. elif ka_miss > 0:
  3572. status = 'missing'
  3573. else:
  3574. status = 'online' if recent else 'offline'
  3575. panels.append({
  3576. 'uid': uid,
  3577. 'address': addr,
  3578. 'online': status == 'online',
  3579. 'panel_id': pid,
  3580. 'status': status,
  3581. 'conflict_uid': conflict_uid,
  3582. 'keepalive_miss': ka_miss,
  3583. 'last_seen': last_seen,
  3584. 'port_count': len(ps),
  3585. 'connected_count': sum(1 for p in ps.values() if p.get('last_uid')),
  3586. 'alarm_count': sum(1 for p in ps.values() if p.get('alarm_count', 0) > 0),
  3587. })
  3588. return jsonify({
  3589. 'success': True,
  3590. 'devices': devices,
  3591. 'panels': panels,
  3592. 'address_range': {'start': _address_range()[0], 'end': _address_range()[1]},
  3593. 'scan': _panel_scan_state
  3594. })
  3595. @app.route('/api/modbus/stored_devices', methods=['POST'])
  3596. def add_stored_device():
  3597. """添加已存储的设备"""
  3598. try:
  3599. data = request.json
  3600. uid = data.get('uid', '').lower()
  3601. address = data.get('address', 1)
  3602. if len(uid) != 24:
  3603. return jsonify({'success': False, 'message': 'UID长度必须是24个十六进制字符'}), 400
  3604. address_config.add_stored_device(uid, address)
  3605. save_device_config()
  3606. return jsonify({'success': True, 'message': f'已添加设备: UID={uid}, 地址={address}'})
  3607. except Exception as e:
  3608. return jsonify({'success': False, 'message': str(e)}), 500
  3609. @app.route('/api/panel/unbind', methods=['POST'])
  3610. def panel_unbind():
  3611. """解除线架绑定(仅解除;线架仍在总线上时,下轮地址段扫描会重新识别绑定)"""
  3612. try:
  3613. data = request.json or {}
  3614. addr = data.get('address')
  3615. panel_id = data.get('panel_id')
  3616. if addr is None and panel_id:
  3617. cfg = panel_config.get(panel_id)
  3618. if cfg:
  3619. addr = cfg.get('address')
  3620. elif isinstance(panel_id, str) and panel_id.rsplit('_', 1)[-1].isdigit():
  3621. addr = int(panel_id.rsplit('_', 1)[-1])
  3622. if not isinstance(addr, int):
  3623. return jsonify({'success': False, 'message': '缺少有效的 address 或 panel_id'}), 400
  3624. uid = _binding_uid_for_address(addr)
  3625. if uid:
  3626. address_config.stored_devices.pop(uid, None)
  3627. save_device_config()
  3628. pid = panel_id if (panel_id and panel_id in panel_config) else _panel_id_for_address(addr)
  3629. panel_config.pop(pid, None)
  3630. port_state.pop(pid, None)
  3631. panel_keepalive_miss.pop(pid, None)
  3632. panel_mappings_synced.discard(pid)
  3633. panel_conflict.pop(pid, None)
  3634. device_last_seen.pop(pid, None)
  3635. if uid:
  3636. device_last_seen.pop(uid, None)
  3637. logger.info(f"已解除线架绑定: 地址={addr} UID={uid or '无'}")
  3638. try:
  3639. dtu_publish_panel_status(pid, addr, None, online=False)
  3640. except Exception:
  3641. pass
  3642. return jsonify({
  3643. 'success': True,
  3644. 'message': f"已解除地址 {addr} 的绑定" + (f"(UID={uid})" if uid else "(无绑定记录)"),
  3645. 'address': addr,
  3646. 'uid': uid
  3647. })
  3648. except Exception as e:
  3649. logger.error(f"解除线架绑定失败: {e}")
  3650. return jsonify({'success': False, 'message': str(e)}), 500
  3651. @app.route('/api/panel/clear_mappings', methods=['POST'])
  3652. def panel_clear_mappings():
  3653. """清空某面板的全部端口映射(绑定②:端口↔卡号)。
  3654. 请求: {"panel_id": "PANEL_dtu_001_1"} 或 {"address": 1}
  3655. - 删除 dtu_config.port_mappings[panel] 全部记录并落盘
  3656. - 若面板在线(panel_config 中有地址),同时下发 0x10 把硬件 24 口全部清成 0xFF
  3657. - 不影响绑定①(devices.json 的地址↔UID)
  3658. """
  3659. try:
  3660. data = request.json or {}
  3661. addr = data.get('address')
  3662. panel_id = _resolve_panel_id(data.get('panel_id'))
  3663. if addr is None and panel_id:
  3664. cfg = panel_config.get(panel_id)
  3665. if cfg:
  3666. addr = cfg.get('address')
  3667. elif isinstance(panel_id, str) and panel_id.rsplit('_', 1)[-1].isdigit():
  3668. addr = int(panel_id.rsplit('_', 1)[-1])
  3669. if not panel_id:
  3670. if isinstance(addr, int):
  3671. panel_id = _panel_id_for_address(addr)
  3672. else:
  3673. return jsonify({'success': False, 'message': '缺少有效的 address 或 panel_id'}), 400
  3674. removed = _clear_panel_port_mappings(panel_id)
  3675. # 清掉运行态期望与"本会话已同步"标记,下次上线会重新全量同步
  3676. port_state.pop(panel_id, None)
  3677. panel_mappings_synced.discard(panel_id)
  3678. save_dtu_config()
  3679. hw = {'cleared': False}
  3680. if isinstance(addr, int):
  3681. try:
  3682. if not (isinstance(serial_client.get_status(), dict)
  3683. and serial_client.get_status().get('connected', False)):
  3684. hw = {'cleared': False, 'message': '串口未连接,仅清除了平台记录'}
  3685. else:
  3686. empty = {p: None for p in range(1, 25)}
  3687. res = modbus_client.set_card_mapping(addr, empty, timeout=2.0)
  3688. if 'error' in res:
  3689. hw = {'cleared': False, 'message': f"硬件清空失败: {res['error']}"}
  3690. else:
  3691. hw = {'cleared': True}
  3692. except Exception as e:
  3693. hw = {'cleared': False, 'message': f"硬件清空异常: {e}"}
  3694. logger.info(f"已清空面板 {panel_id} 端口映射 {removed} 条,硬件清空={hw.get('cleared')}")
  3695. return jsonify({
  3696. 'success': True,
  3697. 'panel_id': panel_id,
  3698. 'address': addr,
  3699. 'removed': removed,
  3700. 'hardware': hw
  3701. })
  3702. except Exception as e:
  3703. logger.error(f"清空面板端口映射失败: {e}")
  3704. return jsonify({'success': False, 'message': str(e)}), 500
  3705. @app.route('/api/panel/mappings', methods=['GET'])
  3706. def panel_mappings_list():
  3707. """返回全部面板的端口映射(绑定②),供映射管理页展示/增改删。
  3708. 每面板: {panel_id, address, uid, status, mapping_count,
  3709. mappings: [{port, uid(12位hex|null)}]}
  3710. 同时包含 dtu_config 里有映射、但当前未注册(无绑定①)的面板组,便于清理。
  3711. """
  3712. try:
  3713. devices = address_config.get_stored_devices()
  3714. now = time.time()
  3715. groups = {}
  3716. # 已注册面板
  3717. for uid, addr in devices.items():
  3718. pid = _panel_id_for_address(addr)
  3719. cfg = panel_config.get(pid) or {}
  3720. ka_miss = panel_keepalive_miss.get(pid, 0)
  3721. last_seen = device_last_seen.get(pid) or device_last_seen.get(uid)
  3722. recent = bool(last_seen) and (now - last_seen) < 60
  3723. if cfg.get('status') == 'offline' or ka_miss >= PANEL_KEEPALIVE_MISS_LIMIT:
  3724. status = 'offline'
  3725. elif panel_conflict.get(pid):
  3726. status = 'conflict'
  3727. elif ka_miss > 0:
  3728. status = 'missing'
  3729. else:
  3730. status = 'online' if recent else 'offline'
  3731. groups[pid] = {
  3732. 'panel_id': pid, 'address': addr, 'uid': uid,
  3733. 'registered': True, 'status': status,
  3734. }
  3735. # 有残留映射但未注册的面板组(地址从 panel_id 末段解析)
  3736. for pid in (dtu_config.get('port_mappings') or {}):
  3737. if pid in groups:
  3738. continue
  3739. addr = None
  3740. if isinstance(pid, str) and pid.rsplit('_', 1)[-1].isdigit():
  3741. addr = int(pid.rsplit('_', 1)[-1])
  3742. groups[pid] = {
  3743. 'panel_id': pid, 'address': addr, 'uid': None,
  3744. 'registered': False, 'status': 'unbound',
  3745. }
  3746. result = []
  3747. for pid, info in groups.items():
  3748. raw = (dtu_config.get('port_mappings') or {}).get(pid) or {}
  3749. mappings = []
  3750. for key, value in raw.items():
  3751. try:
  3752. port = int(key)
  3753. except (TypeError, ValueError):
  3754. continue
  3755. if 1 <= port <= 24:
  3756. mappings.append({'port': port, 'uid': _to_internal_uid_lenient(value)})
  3757. mappings.sort(key=lambda m: m['port'])
  3758. result.append({**info, 'mapping_count': len(mappings), 'mappings': mappings})
  3759. result.sort(key=lambda g: (g['address'] is None, g['address'] if g['address'] is not None else 0))
  3760. return jsonify({'success': True, 'panels': result})
  3761. except Exception as e:
  3762. logger.error(f"查询端口映射失败: {e}")
  3763. return jsonify({'success': False, 'message': str(e)}), 500
  3764. def _push_single_port_hardware(panel_id, addr, port_id, expected_uid):
  3765. """单口增改删后,把整帧(硬件基底+平台期望+目标口)下发硬件。返回 (ok, msg)。"""
  3766. try:
  3767. if not (isinstance(serial_client.get_status(), dict)
  3768. and serial_client.get_status().get('connected', False)):
  3769. return False, '串口未连接'
  3770. card_mappings = _hardware_card_base(addr)
  3771. for ant, v in _dtu_mapping_overrides(panel_id).items():
  3772. card_mappings[ant] = v
  3773. card_mappings[int(port_id)] = expected_uid
  3774. res = modbus_client.set_card_mapping(addr, card_mappings, timeout=2.0)
  3775. if 'error' in res:
  3776. return False, res['error']
  3777. return True, None
  3778. except Exception as e:
  3779. return False, str(e)
  3780. @app.route('/api/panel/mapping', methods=['POST'])
  3781. def panel_mapping_upsert_delete():
  3782. """单端口映射 新增/修改/删除(绑定②)。
  3783. 请求: {"panel_id"或"address", "port": 1, "card_uid": "12位hex" 或 null/"" 删除}
  3784. - 落盘到 dtu_config.port_mappings(删除即移除键,不写 null)
  3785. - 面板已注册且在线、串口连接时,同步下发硬件(保留其它端口现值)
  3786. - 硬件下发失败不回滚已保存的期望映射,仅在响应里告警(下次上线会重下)
  3787. """
  3788. try:
  3789. data = request.json or {}
  3790. panel_id = _resolve_panel_id(data.get('panel_id'))
  3791. addr = data.get('address')
  3792. if addr is None and panel_id:
  3793. cfg = panel_config.get(panel_id)
  3794. if cfg:
  3795. addr = cfg.get('address')
  3796. elif isinstance(panel_id, str) and panel_id.rsplit('_', 1)[-1].isdigit():
  3797. addr = int(panel_id.rsplit('_', 1)[-1])
  3798. if not panel_id:
  3799. if isinstance(addr, int):
  3800. panel_id = _panel_id_for_address(addr)
  3801. else:
  3802. return jsonify({'success': False, 'message': '缺少有效的 address 或 panel_id'}), 400
  3803. try:
  3804. port_id = int(data.get('port'))
  3805. except (TypeError, ValueError):
  3806. return jsonify({'success': False, 'message': 'port 必须是 1-24 的整数'}), 400
  3807. if not (1 <= port_id <= 24):
  3808. return jsonify({'success': False, 'message': 'port 必须在 1-24'}), 400
  3809. raw_uid = data.get('card_uid')
  3810. expected_uid = None
  3811. if raw_uid not in (None, ''):
  3812. u = str(raw_uid).strip().upper().replace(':', '').replace(' ', '')
  3813. if len(u) != 12 or not all(c in _JUMPER_HEX for c in u):
  3814. return jsonify({'success': False, 'message': '卡号必须是 12 位十六进制'}), 400
  3815. expected_uid = u
  3816. action = 'delete' if expected_uid is None else 'set'
  3817. existed = str(port_id) in (dtu_config.get('port_mappings', {}).get(panel_id) or {})
  3818. # 更新运行态期望
  3819. port_state.setdefault(panel_id, {}).setdefault(
  3820. port_id, {'last_uid': None, 'expected_uid': None, 'alarm_count': 0})
  3821. port_state[panel_id][port_id]['expected_uid'] = expected_uid
  3822. _store_port_mapping(panel_id, port_id, expected_uid)
  3823. save_dtu_config()
  3824. # 在线则同步硬件
  3825. hw = {'synced': False}
  3826. registered = bool(_binding_uid_for_address(addr)) if isinstance(addr, int) else (
  3827. panel_id in panel_config)
  3828. if isinstance(addr, int) and registered:
  3829. ok, msg = _push_single_port_hardware(panel_id, addr, port_id, expected_uid)
  3830. hw = {'synced': ok, 'message': msg}
  3831. else:
  3832. hw = {'synced': False, 'message': '面板未注册,仅保存平台记录'}
  3833. logger.info(f"端口映射 {action}: 面板={panel_id} 端口={port_id} 卡号={expected_uid or '空'} 硬件同步={hw['synced']}")
  3834. return jsonify({
  3835. 'success': True, 'action': action,
  3836. 'panel_id': panel_id, 'address': addr, 'port': port_id,
  3837. 'card_uid': expected_uid, 'existed': existed, 'hardware': hw,
  3838. })
  3839. except Exception as e:
  3840. logger.error(f"保存端口映射失败: {e}")
  3841. return jsonify({'success': False, 'message': str(e)}), 500
  3842. def _run_panel_scan():
  3843. """后台扫描地址段内全部未绑定地址(手动触发,V5 0x80 查询)"""
  3844. global _panel_scan_state
  3845. _panel_scan_state = {'running': True, 'found': [], 'started_at': time.time(),
  3846. 'finished_at': None, 'error': None}
  3847. try:
  3848. with address_config.config_lock:
  3849. start, end = _address_range()
  3850. bound_addrs = set(address_config.get_stored_devices().values())
  3851. for addr in range(start, end + 1):
  3852. if addr in bound_addrs:
  3853. continue
  3854. result = modbus_client.query_address(addr, uid=None, timeout=PANEL_PROBE_TIMEOUT)
  3855. if 'error' not in result:
  3856. new_uid = (result.get('uid') or '').lower()
  3857. if new_uid and _register_new_panel(addr, new_uid):
  3858. _panel_scan_state['found'].append({'address': addr, 'uid': new_uid})
  3859. bound_addrs.add(addr)
  3860. time.sleep(0.05)
  3861. except Exception as e:
  3862. logger.error(f"线架扫描失败: {e}")
  3863. _panel_scan_state['error'] = str(e)
  3864. finally:
  3865. _panel_scan_state['running'] = False
  3866. _panel_scan_state['finished_at'] = time.time()
  3867. logger.info(f"线架扫描完成: 发现 {len(_panel_scan_state.get('found', []))} 台")
  3868. @app.route('/api/panel/scan', methods=['POST'])
  3869. def panel_scan():
  3870. """手动扫描地址段内未绑定地址,发现并注册新线架"""
  3871. if _panel_scan_state.get('running'):
  3872. return jsonify({'success': False, 'message': '扫描正在进行中,请稍候'}), 409
  3873. threading.Thread(target=_run_panel_scan, daemon=True).start()
  3874. return jsonify({'success': True, 'message': '已开始扫描地址段内未绑定地址'})
  3875. @app.route('/api/panel/scan_status', methods=['GET'])
  3876. def panel_scan_status():
  3877. """查询扫描进度/结果"""
  3878. return jsonify({'success': True, 'scan': _panel_scan_state})
  3879. def _probe_configured_address(addr):
  3880. """配置地址完成后主动探测新地址(线架可能稍后才应用新地址)"""
  3881. time.sleep(1.0)
  3882. try:
  3883. with address_config.config_lock:
  3884. result = modbus_client.query_address(addr, uid=None, timeout=PANEL_QUERY_TIMEOUT)
  3885. if 'error' in result:
  3886. logger.info(f"配置地址后首次探测 {addr} 无应答,交由地址段扫描继续重试")
  3887. return
  3888. uid = (result.get('uid') or '').lower()
  3889. if uid:
  3890. _register_new_panel(addr, uid, allow_move=True)
  3891. except Exception as e:
  3892. logger.warning(f"配置地址后探测 {addr} 失败: {e}")
  3893. def _run_panel_config_address(timeout):
  3894. """后台执行"进入配置地址状态":发送广播帧后等待线架读到配置卡的应答。
  3895. 期间持有 address_config.config_lock,暂停地址段轮询;用 wait_response(0.5)
  3896. 短轮询而不是一次长等待,避免长时间占住串口发送队列。
  3897. """
  3898. global _panel_config_addr_state
  3899. state = _panel_config_addr_state
  3900. raw_chunks = []
  3901. try:
  3902. if not _serial_connected():
  3903. state['error'] = '串口未连接'
  3904. return
  3905. with address_config.config_lock:
  3906. ok, msg = serial_client.send_raw(CONFIG_ADDRESS_ENTER_FRAME)
  3907. if not ok:
  3908. state['error'] = f'发送配置地址指令失败: {msg}'
  3909. return
  3910. logger.info(f"已发送配置地址状态指令: {CONFIG_ADDRESS_ENTER_FRAME.hex()},等待刷配置卡(超时 {timeout}s)")
  3911. deadline = time.time() + timeout
  3912. while time.time() < deadline:
  3913. resp = serial_client.wait_response(timeout=0.5,
  3914. min_response_bytes=CONFIG_ADDRESS_RESPONSE_LEN)
  3915. if not resp:
  3916. continue
  3917. raw_chunks.append(resp)
  3918. combined = b''.join(raw_chunks)
  3919. state['raw'] = combined.hex()
  3920. parsed = parse_config_address_response(combined)
  3921. if 'success' in parsed:
  3922. state['antenna'] = parsed['antenna']
  3923. state['address'] = parsed['address']
  3924. state['raw'] = parsed['raw_data']
  3925. logger.info(f"线架配置地址完成: 天线={parsed['antenna']} 地址={parsed['address']}")
  3926. return
  3927. # 无效应答只保留末尾 7 字节,避免缓冲无限增长
  3928. raw_chunks = [combined[-7:]]
  3929. except Exception as e:
  3930. state['error'] = str(e)
  3931. logger.error(f"配置地址状态异常: {e}")
  3932. finally:
  3933. state['running'] = False
  3934. state['finished_at'] = time.time()
  3935. if not state['error'] and state['address'] is None:
  3936. state['error'] = '等待配置卡超时,线架未回复有效地址'
  3937. if state['address'] is not None:
  3938. state['pending_address'] = state['address']
  3939. state['pending_until'] = time.time() + max(30, timeout)
  3940. threading.Thread(target=_probe_configured_address,
  3941. args=(state['address'],), daemon=True).start()
  3942. logger.info(f"配置地址状态结束: 地址={state['address']} 错误={state['error']}")
  3943. @app.route('/api/panel/config_address', methods=['POST'])
  3944. def panel_config_address():
  3945. """让线架进入"配置地址状态",等待现场刷配置卡后自动回复新地址"""
  3946. global _panel_config_addr_state
  3947. if _panel_config_addr_state.get('running'):
  3948. return jsonify({'success': False, 'message': '配置地址操作进行中,请稍候'}), 409
  3949. if not _serial_connected():
  3950. return jsonify({'success': False, 'message': '串口未连接'}), 400
  3951. data = request.json or {}
  3952. try:
  3953. timeout = int(data.get('timeout') or PANEL_CONFIG_ADDRESS_TIMEOUT)
  3954. except (TypeError, ValueError):
  3955. timeout = PANEL_CONFIG_ADDRESS_TIMEOUT
  3956. timeout = max(5, min(300, timeout))
  3957. _panel_config_addr_state = {
  3958. 'running': True,
  3959. 'started_at': time.time(),
  3960. 'finished_at': None,
  3961. 'timeout': timeout,
  3962. 'antenna': None,
  3963. 'address': None,
  3964. 'raw': '',
  3965. 'error': None,
  3966. 'pending_address': None,
  3967. 'pending_until': None,
  3968. }
  3969. threading.Thread(target=_run_panel_config_address, args=(timeout,), daemon=True).start()
  3970. return jsonify({
  3971. 'success': True,
  3972. 'message': f'已发送配置地址指令,请将配置卡放到目标天线({timeout} 秒内有效)',
  3973. 'timeout': timeout,
  3974. })
  3975. @app.route('/api/panel/config_address_status', methods=['GET'])
  3976. def panel_config_address_status():
  3977. """查询"配置地址状态"进度/结果"""
  3978. return jsonify({'success': True, 'config': _panel_config_addr_state})
  3979. @app.route('/api/modbus/save_config', methods=['POST'])
  3980. def modbus_save_config():
  3981. """保存设备配置到文件"""
  3982. try:
  3983. data = request.json
  3984. filepath = data.get('filepath', '/tmp/modbus_devices.json')
  3985. success = address_config.save_config(filepath)
  3986. return jsonify({'success': success, 'message': f'配置已保存到: {filepath}' if success else '保存失败'})
  3987. except Exception as e:
  3988. return jsonify({'success': False, 'message': str(e)}), 500
  3989. @app.route('/api/modbus/confirm_devices', methods=['POST'])
  3990. def confirm_devices():
  3991. """手动调试:对所有已存储设备发送 V5 地址确认帧(0x82,80/81 口径下已废弃,自动流程不再使用)。"""
  3992. try:
  3993. devices = address_config.get_stored_devices()
  3994. if not devices:
  3995. return jsonify({'success': False, 'message': '没有已存储的设备'}), 400
  3996. if not _serial_connected():
  3997. return jsonify({'success': False, 'message': '串口未连接'}), 400
  3998. results = []
  3999. for uid_hex, addr in devices.items():
  4000. try:
  4001. result = modbus_client.confirm_address(addr, uid_hex, timeout=PANEL_QUERY_TIMEOUT)
  4002. success = 'error' not in result
  4003. msg = result.get('error') or 'ok'
  4004. logger.info(f"确认设备 地址={addr}: {'成功' if success else '失败 ' + msg}")
  4005. results.append({'address': addr, 'uid': uid_hex,
  4006. 'success': success, 'message': msg})
  4007. except Exception as e:
  4008. results.append({'address': addr, 'uid': uid_hex, 'success': False, 'message': str(e)})
  4009. time.sleep(0.1)
  4010. return jsonify({'success': True, 'results': results, 'count': len(results)})
  4011. except Exception as e:
  4012. return jsonify({'success': False, 'message': str(e)}), 500
  4013. # 端口状态追踪 - 用于存储每个端口的事件状态
  4014. port_event_history = [] # 存储最近的端口事件
  4015. @app.route('/api/port/status', methods=['GET'])
  4016. def get_port_status():
  4017. """获取所有端口状态"""
  4018. return jsonify({'success': True, 'port_state': port_state})
  4019. @app.route('/api/port/events', methods=['GET'])
  4020. def get_port_events():
  4021. """获取端口事件历史"""
  4022. limit = request.args.get('limit', 100, type=int)
  4023. return jsonify({
  4024. 'success': True,
  4025. 'events': port_event_history[-limit:]
  4026. })
  4027. @app.route('/api/port/clear_events', methods=['POST'])
  4028. def clear_port_events():
  4029. """清除端口事件历史"""
  4030. global port_event_history
  4031. port_event_history = []
  4032. return jsonify({'success': True, 'message': '事件历史已清除'})
  4033. # 设备最后响应时间跟踪
  4034. device_last_seen = {}
  4035. @app.route('/api/panel/status', methods=['GET'])
  4036. def get_panel_status():
  4037. """获取所有面板状态,包含每个端口的连接状态"""
  4038. now = time.time()
  4039. PANEL_OFFLINE_TIMEOUT = 60
  4040. panel_status = {}
  4041. for panel_id, ports in port_state.items():
  4042. port_count = len(ports)
  4043. alarm_count = sum(1 for p in ports.values() if p.get('alarm_count', 0) > 0)
  4044. connected_count = sum(1 for p in ports.values() if p.get('last_uid'))
  4045. panel_ports = {}
  4046. for port_id, p in ports.items():
  4047. last_uid = p.get('last_uid')
  4048. expected_uid = p.get('expected_uid')
  4049. last_polled_at = p.get('last_polled_at')
  4050. if not last_polled_at:
  4051. status = 'UNKNOWN'
  4052. elif not last_uid:
  4053. # 有期望但读不到卡:告警未插;无期望:正常空闲
  4054. status = 'ILLEGAL_DISCONNECT' if expected_uid else 'DISCONNECTED'
  4055. elif expected_uid and last_uid != expected_uid:
  4056. status = 'ILLEGAL_CONNECT'
  4057. else:
  4058. status = 'CONNECTED'
  4059. panel_ports[port_id] = {
  4060. 'status': status,
  4061. 'jumper_uid': last_uid or None,
  4062. 'expected_uid': expected_uid or None,
  4063. 'alarm_count': p.get('alarm_count', 0)
  4064. }
  4065. panel_status[panel_id] = {
  4066. 'panel_id': panel_id,
  4067. 'port_count': port_count,
  4068. 'connected_count': connected_count,
  4069. 'alarm_count': alarm_count,
  4070. 'status': 'online' if connected_count > 0 else 'offline',
  4071. 'ports': panel_ports
  4072. }
  4073. for panel_id, cfg in panel_config.items():
  4074. last_seen = device_last_seen.get(panel_id, 0)
  4075. is_online = (now - last_seen) < PANEL_OFFLINE_TIMEOUT
  4076. if panel_id in panel_status:
  4077. panel_status[panel_id].update({
  4078. 'address': cfg.get('address'),
  4079. 'position': cfg.get('position'),
  4080. 'panel_uid': cfg.get('panel_uid'),
  4081. 'status': 'online' if is_online else 'offline'
  4082. })
  4083. else:
  4084. panel_status[panel_id] = {
  4085. 'panel_id': panel_id,
  4086. 'address': cfg.get('address'),
  4087. 'position': cfg.get('position'),
  4088. 'panel_uid': cfg.get('panel_uid'),
  4089. 'port_count': 0,
  4090. 'connected_count': 0,
  4091. 'alarm_count': 0,
  4092. 'status': 'online' if is_online else 'offline',
  4093. 'ports': {}
  4094. }
  4095. return jsonify({'success': True, 'panels': panel_status})
  4096. # LED 状态追踪 (按设备地址跟踪每个灯的最后设置状态)
  4097. # 结构: {device_address: {port_id: color}}, color: 0=off, 1=red, 2=green, 3=blue
  4098. led_states = {}
  4099. # Nextion 串口屏网口图片与 LED 颜色的映射关系
  4100. # 屏幕图片定义: 0=灰(灭), 1=蓝, 2=红, 3=绿
  4101. # 后端 LED 颜色定义: 0=灭, 1=红, 2=绿, 3=蓝
  4102. LED_COLOR_TO_PIC = {0: 0, 1: 2, 2: 3, 3: 1}
  4103. @app.route('/api/modbus/led_status', methods=['GET'])
  4104. def get_led_status():
  4105. """获取 LED 状态,支持按设备地址过滤"""
  4106. device_address = request.args.get('device_address', type=int)
  4107. if device_address is not None:
  4108. return jsonify({
  4109. 'success': True,
  4110. 'device_address': device_address,
  4111. 'leds': led_states.get(device_address, {})
  4112. })
  4113. return jsonify({'success': True, 'leds': led_states})
  4114. @app.route('/api/modbus/set_all_leds', methods=['POST'])
  4115. def set_all_leds():
  4116. """批量设置 LED
  4117. 请求: {"device_address": 1, "color": 1}
  4118. 设置所有 24 个 LED 到指定颜色
  4119. """
  4120. try:
  4121. data = request.json
  4122. device_address = data.get('device_address', 1)
  4123. color = data.get('color', 0)
  4124. timeout = data.get('timeout')
  4125. if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
  4126. return jsonify({'success': False, 'message': '串口未连接'}), 400
  4127. results = []
  4128. if device_address not in led_states:
  4129. led_states[device_address] = {}
  4130. for led_num in range(1, 25):
  4131. result = modbus_client.set_rgb_led(
  4132. device_address=device_address,
  4133. led_number=led_num,
  4134. color=color,
  4135. timeout=timeout
  4136. )
  4137. if 'error' in result:
  4138. results.append({'led': led_num, 'success': False, 'error': result['error']})
  4139. else:
  4140. results.append({'led': led_num, 'success': True})
  4141. led_states[device_address][led_num] = color
  4142. _refresh_current_screen_panel()
  4143. return jsonify({'success': True, 'results': results})
  4144. except Exception as e:
  4145. logger.error(f'批量设置LED失败: {str(e)}')
  4146. return jsonify({'success': False, 'message': str(e)}), 500
  4147. # 在 set_rgb_led 中更新 LED 状态追踪
  4148. # 不再需要静态文件目录,前端由nginx提供服务
  4149. # ========== DTU MQTT协议配置API ==========
  4150. @app.route('/api/dtu/config', methods=['GET'])
  4151. def get_dtu_config():
  4152. """获取DTU配置"""
  4153. return jsonify({
  4154. 'success': True,
  4155. 'data': dtu_config
  4156. })
  4157. @app.route('/api/dtu/config', methods=['POST'])
  4158. def update_dtu_config():
  4159. """更新DTU配置"""
  4160. try:
  4161. data = request.json
  4162. old_config = dtu_config.copy()
  4163. # 更新配置项
  4164. if 'topic_prefix' in data:
  4165. dtu_config['topic_prefix'] = data['topic_prefix']
  4166. if 'customer_id' in data:
  4167. dtu_config['customer_id'] = data['customer_id']
  4168. if 'dtu_id' in data:
  4169. dtu_config['dtu_id'] = data['dtu_id']
  4170. if 'firmware_version' in data:
  4171. dtu_config['firmware_version'] = data['firmware_version']
  4172. if 'hardware_version' in data:
  4173. dtu_config['hardware_version'] = data['hardware_version']
  4174. if 'heartbeat_interval' in data:
  4175. dtu_config['heartbeat_interval'] = data['heartbeat_interval']
  4176. if 'enabled' in data:
  4177. dtu_config['enabled'] = data['enabled']
  4178. if 'address_range' in data:
  4179. rng = data['address_range']
  4180. err = None
  4181. if not isinstance(rng, dict):
  4182. err = 'address_range 必须是对象'
  4183. else:
  4184. start, end = rng.get('start'), rng.get('end')
  4185. if not isinstance(start, int) or not isinstance(end, int):
  4186. err = 'address_range.start/end 必须是整数'
  4187. elif not (1 <= start <= end <= 247):
  4188. err = '地址段需满足 1 <= 起始 <= 结束 <= 247'
  4189. if err:
  4190. return jsonify({'success': False, 'message': err}), 400
  4191. dtu_config['address_range'] = {'start': int(rng['start']), 'end': int(rng['end'])}
  4192. # 如果MQTT已连接且主题配置发生变化,重新订阅
  4193. if mqtt_status and dtu_config.get('enabled'):
  4194. old_control_topic = build_dtu_topic(
  4195. old_config.get('customer_id', DEFAULT_CUSTOMER_ID),
  4196. 'dtu',
  4197. old_config.get('dtu_id', DEFAULT_DTU_ID),
  4198. 'control'
  4199. )
  4200. new_control_topic = build_dtu_topic(
  4201. dtu_config['customer_id'],
  4202. 'dtu',
  4203. dtu_config['dtu_id'],
  4204. 'control'
  4205. )
  4206. if old_control_topic != new_control_topic:
  4207. # 取消旧订阅,订阅新主题
  4208. mqtt_client.unsubscribe(old_control_topic)
  4209. mqtt_client.subscribe(new_control_topic)
  4210. logger.info(f"控制主题已更新: {old_control_topic} -> {new_control_topic}")
  4211. # 重新发送注册消息
  4212. dtu_register()
  4213. # 持久化 DTU 配置(此前仅改内存,重启会丢)
  4214. save_dtu_config()
  4215. return jsonify({
  4216. 'success': True,
  4217. 'message': 'DTU配置已更新',
  4218. 'data': dtu_config
  4219. })
  4220. except Exception as e:
  4221. logger.error(f"更新DTU配置失败: {str(e)}")
  4222. return jsonify({'success': False, 'message': str(e)}), 500
  4223. @app.route('/api/dtu/register', methods=['POST'])
  4224. def manual_dtu_register():
  4225. """手动触发DTU注册"""
  4226. try:
  4227. if not mqtt_status:
  4228. return jsonify({'success': False, 'message': 'MQTT未连接'}), 400
  4229. success = dtu_register()
  4230. if success:
  4231. return jsonify({'success': True, 'message': '注册消息已发送'})
  4232. else:
  4233. return jsonify({'success': False, 'message': '注册消息发送失败'}), 500
  4234. except Exception as e:
  4235. logger.error(f"手动触发DTU注册失败: {str(e)}")
  4236. return jsonify({'success': False, 'message': str(e)}), 500
  4237. _cpu_last_times = None
  4238. def _get_cpu_usage():
  4239. """CPU 使用率 (psutil 优先,无 psutil 时回退读 /proc/stat 计算瞬时差值)"""
  4240. global _cpu_last_times
  4241. try:
  4242. import psutil
  4243. return psutil.cpu_percent(interval=None)
  4244. except Exception:
  4245. pass
  4246. try:
  4247. with open('/proc/stat') as f:
  4248. fields = f.readline().split()
  4249. if len(fields) < 5 or not fields[0].startswith('cpu'):
  4250. return None
  4251. vals = [int(x) for x in fields[1:]]
  4252. idle = vals[3] + (vals[4] if len(vals) > 4 else 0)
  4253. total = sum(vals)
  4254. if _cpu_last_times:
  4255. dtotal = total - _cpu_last_times[0]
  4256. didle = idle - _cpu_last_times[1]
  4257. if dtotal > 0:
  4258. pct = round((1.0 - didle / dtotal) * 100, 1)
  4259. _cpu_last_times = (total, idle)
  4260. return pct
  4261. _cpu_last_times = (total, idle)
  4262. return None
  4263. except Exception:
  4264. return None
  4265. def _get_memory_usage():
  4266. """内存使用率 (psutil 优先,无 psutil 时回退读 /proc/meminfo)"""
  4267. try:
  4268. import psutil
  4269. return psutil.virtual_memory().percent
  4270. except Exception:
  4271. pass
  4272. try:
  4273. meminfo = {}
  4274. with open('/proc/meminfo') as f:
  4275. for line in f:
  4276. parts = line.split(':')
  4277. if len(parts) == 2:
  4278. try:
  4279. meminfo[parts[0].strip()] = int(parts[1].split()[0])
  4280. except (ValueError, IndexError):
  4281. continue
  4282. total = meminfo.get('MemTotal', 0)
  4283. available = meminfo.get('MemAvailable')
  4284. if available is None:
  4285. available = meminfo.get('MemFree', 0)
  4286. if total > 0:
  4287. return round((1.0 - available / total) * 100, 1)
  4288. return None
  4289. except Exception:
  4290. return None
  4291. @app.route('/api/dtu/status', methods=['GET'])
  4292. def get_dtu_status():
  4293. """获取DTU状态"""
  4294. try:
  4295. # 获取串口状态
  4296. serial_st = serial_client.get_status()
  4297. # 获取面板状态
  4298. devices = address_config.get_stored_devices()
  4299. # 主板温度: 优先外部上报,否则本地读取
  4300. dtu_temperature = env_sensor_data.get('dtu_temperature')
  4301. if dtu_temperature is None:
  4302. try:
  4303. import psutil
  4304. temps = psutil.sensors_temperatures(fahrenheit=False) or {}
  4305. for chip_name, entries in temps.items():
  4306. for entry in entries:
  4307. if entry.current and entry.current > 0:
  4308. dtu_temperature = round(entry.current, 1)
  4309. break
  4310. if dtu_temperature is not None:
  4311. break
  4312. except Exception:
  4313. pass
  4314. if dtu_temperature is None:
  4315. import glob as _glob
  4316. for tz in sorted(_glob.glob('/sys/class/thermal/thermal_zone*/temp')):
  4317. try:
  4318. with open(tz) as f:
  4319. v = int(f.read().strip())
  4320. if v > 0:
  4321. dtu_temperature = round(v / 1000.0, 1)
  4322. break
  4323. except Exception:
  4324. continue
  4325. status = {
  4326. 'dtu_id': dtu_config.get('dtu_id'),
  4327. 'mqtt_connected': mqtt_status,
  4328. 'serial_connected': isinstance(serial_st, dict) and serial_st.get('connected', False),
  4329. 'dtu_enabled': dtu_config.get('enabled', True),
  4330. 'topic_prefix': dtu_config.get('topic_prefix'),
  4331. 'customer_id': dtu_config.get('customer_id'),
  4332. 'panel_count': len(devices),
  4333. 'cpu_usage': _get_cpu_usage(),
  4334. 'memory_usage': _get_memory_usage(),
  4335. 'temperature': dtu_temperature,
  4336. 'dtu_temperature': dtu_temperature,
  4337. 'firmware_version': dtu_config.get('firmware_version', 'v1.0.0'),
  4338. 'topics': {
  4339. 'register': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'register'),
  4340. 'status': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status'),
  4341. 'control': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'control'),
  4342. 'response': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'response'),
  4343. 'event': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'event'),
  4344. 'alarm': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'alarm')
  4345. }
  4346. }
  4347. return jsonify({'success': True, 'data': status})
  4348. except Exception as e:
  4349. logger.error(f"获取DTU状态失败: {str(e)}")
  4350. return jsonify({'success': False, 'message': str(e)}), 500
  4351. @app.route('/api/dtu/control', methods=['POST'])
  4352. def dtu_control():
  4353. """发送DTU控制命令(HTTP 入口,复用 dtu_handle_control 逻辑)"""
  4354. try:
  4355. data = request.json or {}
  4356. # 兼容两种入参格式:
  4357. # 1) {"command": "...", "target": "...", "params": {...}} 简洁格式
  4358. # 2) {"payload": {"command": "...", "target": "...", "params": {...}}} MQTT envelope 格式
  4359. inner = data.get('payload') if isinstance(data.get('payload'), dict) else data
  4360. command = inner.get('command')
  4361. # REBOOT 走快速通道立即执行
  4362. if command == 'REBOOT':
  4363. import subprocess
  4364. logger.warning("执行系统重启命令")
  4365. threading.Thread(target=lambda: (
  4366. time.sleep(1),
  4367. subprocess.run(['reboot'], capture_output=True)
  4368. ), daemon=True).start()
  4369. return jsonify({'success': True, 'message': '系统正在重启...'})
  4370. # 其他命令委托给 MQTT 处理器(构造 MQTT envelope 后调用)
  4371. mqtt_envelope = {
  4372. 'msg_id': data.get('msg_id', f"http_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}"),
  4373. 'timestamp': data.get('timestamp', int(time.time() * 1000)),
  4374. 'dtu_id': data.get('dtu_id', dtu_config.get('dtu_id')),
  4375. 'type': 'CONTROL',
  4376. 'payload': {
  4377. 'command': command,
  4378. 'target': inner.get('target'),
  4379. 'params': inner.get('params', {})
  4380. }
  4381. }
  4382. # 调用 MQTT 处理器(其内部会发送响应到 dtu/.../response 主题)
  4383. dtu_handle_control('http/control', mqtt_envelope)
  4384. # 如果命令是 QUERY_JUMPER_STATUS / QUERY_ENV_SENSOR / QUERY_DTU_STATUS,
  4385. # 实际响应已发布到对应主题,HTTP 端点仅返回成功标记
  4386. if command in ('QUERY_JUMPER_STATUS', 'QUERY_ENV_SENSOR', 'QUERY_DTU_STATUS'):
  4387. return jsonify({
  4388. 'success': True,
  4389. 'message': f'{command} 已发布到 MQTT 主题'
  4390. })
  4391. # 其他命令: 从 MQTT 主题同步拉取最新响应(简化处理:直接返回已发布标记)
  4392. return jsonify({
  4393. 'success': True,
  4394. 'message': f'{command} 命令已下发,等待 MQTT 响应'
  4395. })
  4396. except Exception as e:
  4397. logger.error(f"DTU控制命令失败: {str(e)}")
  4398. return jsonify({'success': False, 'message': str(e)}), 500
  4399. # OTA状态存储
  4400. ota_status = {
  4401. 'status': 'IDLE', # IDLE, DOWNLOADING, VERIFYING, FLASHING, SUCCESS, FAILED
  4402. 'progress': 0,
  4403. 'firmware_version': None,
  4404. 'target_version': None,
  4405. 'error_code': None,
  4406. 'error_message': None,
  4407. 'last_update': None
  4408. }
  4409. @app.route('/api/dtu/ota_detect', methods=['POST'])
  4410. def ota_detect():
  4411. """检测固件包信息(自动下载并解析 manifest)"""
  4412. try:
  4413. url = request.json.get('url', '')
  4414. if not url:
  4415. return jsonify({'success': False, 'message': '请提供固件 URL'}), 400
  4416. import urllib.request, tempfile, tarfile, json, hashlib
  4417. tmp = tempfile.mktemp(suffix='.tar.gz')
  4418. try:
  4419. urllib.request.urlretrieve(url, tmp)
  4420. except Exception as e:
  4421. return jsonify({'success': False, 'message': f'下载失败: {str(e)}'}), 400
  4422. file_size = os.path.getsize(tmp)
  4423. h = hashlib.md5()
  4424. with open(tmp, 'rb') as f:
  4425. for chunk in iter(lambda: f.read(65536), b''):
  4426. h.update(chunk)
  4427. md5sum = h.hexdigest()
  4428. version = ''
  4429. try:
  4430. with tarfile.open(tmp, 'r:gz') as tar:
  4431. m = tar.extractfile('firmware/firmware.json')
  4432. if m:
  4433. manifest = json.loads(m.read())
  4434. version = manifest.get('version', '')
  4435. except Exception as e:
  4436. logger.warning(f"解析 firmware.json 失败: {e}")
  4437. os.remove(tmp)
  4438. return jsonify({
  4439. 'success': True,
  4440. 'data': {
  4441. 'file_size': file_size,
  4442. 'checksum': md5sum,
  4443. 'checksum_type': 'MD5',
  4444. 'firmware_version': version
  4445. }
  4446. })
  4447. except Exception as e:
  4448. logger.error(f"检测固件失败: {str(e)}")
  4449. return jsonify({'success': False, 'message': str(e)}), 500
  4450. @app.route('/api/dtu/ota_status', methods=['GET'])
  4451. def get_ota_status():
  4452. """获取OTA升级状态"""
  4453. try:
  4454. return jsonify({
  4455. 'success': True,
  4456. 'data': {
  4457. 'current_firmware': dtu_config.get('firmware_version', 'v1.0.0'),
  4458. 'ota_status': ota_status.get('status', 'IDLE'),
  4459. 'ota_progress': ota_status.get('progress', 0),
  4460. 'target_version': ota_status.get('target_version'),
  4461. 'error_code': ota_status.get('error_code'),
  4462. 'error_message': ota_status.get('error_message'),
  4463. 'last_update': ota_status.get('last_update')
  4464. }
  4465. })
  4466. except Exception as e:
  4467. logger.error(f"获取OTA状态失败: {str(e)}")
  4468. return jsonify({'success': False, 'message': str(e)}), 500
  4469. def handle_ota_status(dtu_id, payload):
  4470. """处理MQTT上报的OTA状态"""
  4471. ota_status['status'] = payload.get('ota_status', 'IDLE')
  4472. ota_status['progress'] = payload.get('ota_progress', 0)
  4473. ota_status['firmware_version'] = payload.get('firmware_version')
  4474. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4475. error_code = payload.get('error_code')
  4476. if error_code and error_code != 0:
  4477. ota_status['error_code'] = error_code
  4478. ota_status['error_message'] = payload.get('error_message', get_ota_error_message(error_code))
  4479. ota_status['status'] = 'FAILED'
  4480. elif ota_status['status'] == 'SUCCESS':
  4481. ota_status['error_code'] = None
  4482. ota_status['error_message'] = None
  4483. if ota_status.get('firmware_version'):
  4484. dtu_config['firmware_version'] = ota_status['firmware_version']
  4485. save_dtu_config()
  4486. logger.info(f"MQTT OTA状态更新: {ota_status['status']}, 进度: {ota_status['progress']}%")
  4487. def get_ota_error_message(error_code):
  4488. error_messages = {1021: '已是目标版本', 1022: '校验失败', 1023: '下载失败', 1024: '写入失败', 1025: '存储空间不足'}
  4489. return error_messages.get(error_code, f'未知错误码: {error_code}')
  4490. def _publish_ota_progress():
  4491. """通过MQTT发布OTA进度"""
  4492. try:
  4493. if not _mqtt_connected():
  4494. return
  4495. topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status')
  4496. payload = {
  4497. 'msg_id': f"ota_status_{int(time.time() * 1000)}",
  4498. 'timestamp': int(time.time() * 1000),
  4499. 'dtu_id': dtu_config['dtu_id'],
  4500. 'type': 'STATUS',
  4501. 'payload': {
  4502. 'ota_status': ota_status.get('status', 'IDLE'),
  4503. 'ota_progress': ota_status.get('progress', 0),
  4504. 'firmware_version': ota_status.get('target_version', ''),
  4505. 'error_code': ota_status.get('error_code', 0),
  4506. 'error_message': ota_status.get('error_message')
  4507. }
  4508. }
  4509. mqtt_client.publish(topic, json.dumps(payload), qos=1)
  4510. except Exception:
  4511. pass
  4512. def _send_ota_error_response(error_code, original_msg_id=''):
  4513. """通过MQTT发送OTA错误响应(1021-1025)"""
  4514. try:
  4515. if not _mqtt_connected():
  4516. return
  4517. topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'response')
  4518. payload = {
  4519. 'msg_id': f"rsp_ota_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}",
  4520. 'timestamp': int(time.time() * 1000),
  4521. 'dtu_id': dtu_config['dtu_id'],
  4522. 'type': 'RESPONSE',
  4523. 'payload': {
  4524. 'original_msg_id': original_msg_id,
  4525. 'command': 'OTA_UPGRADE',
  4526. 'success': False,
  4527. 'result': None,
  4528. 'error_code': error_code,
  4529. 'error_message': get_ota_error_message(error_code)
  4530. }
  4531. }
  4532. mqtt_client.publish(topic, json.dumps(payload), qos=1)
  4533. except Exception:
  4534. pass
  4535. def _run_ota(params):
  4536. """执行OTA升级(后台线程,供HTTP和MQTT共用)"""
  4537. import subprocess, os, hashlib, shutil, tarfile, tempfile, urllib.request
  4538. url = params['firmware_url']
  4539. version = params['firmware_version']
  4540. file_size = params['file_size']
  4541. checksum = params['checksum']
  4542. checksum_type = params.get('checksum_type', 'MD5').upper()
  4543. force = params.get('force_upgrade', False)
  4544. ota_status['status'] = 'DOWNLOADING'
  4545. ota_status['progress'] = 0
  4546. ota_status['target_version'] = version
  4547. ota_status['error_code'] = None
  4548. ota_status['error_message'] = None
  4549. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4550. _publish_ota_progress()
  4551. try:
  4552. tmp_dir = tempfile.mkdtemp(prefix='ota_')
  4553. fw_path = os.path.join(tmp_dir, 'firmware.tar.gz')
  4554. ota_status['progress'] = 5
  4555. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4556. logger.info(f"OTA: 开始下载固件 {url}")
  4557. req = urllib.request.Request(url, headers={'User-Agent': 'OTA-Updater'})
  4558. # 进度上报节流: 每 10% 或每 5 秒
  4559. last_published_pct = 0
  4560. last_publish_time = time.time()
  4561. with urllib.request.urlopen(req, timeout=120) as resp:
  4562. with open(fw_path, 'wb') as f:
  4563. total = int(resp.headers.get('Content-Length', 0))
  4564. downloaded = 0
  4565. while True:
  4566. chunk = resp.read(65536)
  4567. if not chunk: break
  4568. f.write(chunk)
  4569. downloaded += len(chunk)
  4570. if total:
  4571. pct = 5 + int(downloaded / total * 30)
  4572. ota_status['progress'] = min(pct, 35)
  4573. now = time.time()
  4574. if pct - last_published_pct >= 10 or (now - last_publish_time) >= 5:
  4575. last_published_pct = pct
  4576. last_publish_time = now
  4577. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4578. _publish_ota_progress()
  4579. dl_size = os.path.getsize(fw_path)
  4580. ota_status['progress'] = 40
  4581. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4582. _publish_ota_progress()
  4583. if abs(dl_size - file_size) > 1024:
  4584. raise Exception(f"文件大小不匹配: 预期{file_size}, 实际{dl_size}")
  4585. ota_status['status'] = 'VERIFYING'
  4586. ota_status['progress'] = 50
  4587. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4588. _publish_ota_progress()
  4589. h = hashlib.new(checksum_type)
  4590. with open(fw_path, 'rb') as f:
  4591. for chunk in iter(lambda: f.read(65536), b''): h.update(chunk)
  4592. actual_checksum = h.hexdigest().lower()
  4593. if actual_checksum != checksum.lower():
  4594. raise Exception(f"校验和不匹配: 预期{checksum}, 实际{actual_checksum}")
  4595. ota_status['progress'] = 60
  4596. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4597. _publish_ota_progress()
  4598. extract_dir = os.path.join(tmp_dir, 'firmware')
  4599. os.makedirs(extract_dir, exist_ok=True)
  4600. with tarfile.open(fw_path, 'r:gz') as tar: tar.extractall(extract_dir)
  4601. manifest_path = os.path.join(extract_dir, 'firmware', 'firmware.json')
  4602. if not os.path.exists(manifest_path):
  4603. raise Exception("固件包缺少 firmware.json")
  4604. with open(manifest_path, 'r') as f: manifest = json.load(f)
  4605. fw_version = manifest.get('version', version)
  4606. if not force:
  4607. current_ver = dtu_config.get('firmware_version', 'v0.0.0')
  4608. if fw_version == current_ver:
  4609. raise Exception(f'已是目标版本 {current_ver}')
  4610. ota_status['status'] = 'FLASHING'
  4611. ota_status['progress'] = 70
  4612. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4613. _publish_ota_progress()
  4614. fw_root = os.path.join(extract_dir, 'firmware')
  4615. project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  4616. excludes = {'__pycache__', '.git', 'log', 'venv'}
  4617. for root, dirs, files in os.walk(fw_root):
  4618. rel = os.path.relpath(root, fw_root)
  4619. if rel == '.': rel = ''
  4620. parts = rel.split(os.sep) if rel else []
  4621. if parts and parts[0] in excludes: continue
  4622. for fname in files:
  4623. if fname == 'firmware.json': continue
  4624. src = os.path.join(root, fname)
  4625. dst = os.path.join(project_dir, rel, fname)
  4626. os.makedirs(os.path.dirname(dst), exist_ok=True)
  4627. shutil.copy2(src, dst)
  4628. ota_status['progress'] = 90
  4629. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4630. dtu_config['firmware_version'] = fw_version
  4631. save_dtu_config()
  4632. ota_status['status'] = 'SUCCESS'
  4633. ota_status['progress'] = 100
  4634. ota_status['firmware_version'] = fw_version
  4635. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4636. _publish_ota_progress()
  4637. shutil.rmtree(tmp_dir, ignore_errors=True)
  4638. for i in range(10, 0, -1):
  4639. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4640. time.sleep(1)
  4641. logger.info("OTA: 重启服务...")
  4642. subprocess.Popen(
  4643. [subprocess.sys.executable, '-m', 'flask', 'run', '--host=0.0.0.0', '--port=5001'],
  4644. cwd=os.path.dirname(os.path.abspath(__file__)),
  4645. stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
  4646. )
  4647. os._exit(0)
  4648. except Exception as e:
  4649. ota_status['status'] = 'FAILED'
  4650. ota_status['error_message'] = str(e)
  4651. ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
  4652. # 映射错误到标准错误码 (1021-1025)
  4653. msg = str(e)
  4654. if '校验和' in msg or 'firmware.json' in msg:
  4655. ota_status['error_code'] = 1022
  4656. elif '已是目标版本' in msg:
  4657. ota_status['error_code'] = 1021
  4658. elif '下载' in msg or 'urlopen' in msg or 'Connection' in msg or 'timeout' in msg:
  4659. ota_status['error_code'] = 1023
  4660. elif '磁盘' in msg or '空间' in msg or 'No space' in msg:
  4661. ota_status['error_code'] = 1025
  4662. elif '写入' in msg or 'flash' in msg.lower() or 'shutil' in msg:
  4663. ota_status['error_code'] = 1024
  4664. else:
  4665. ota_status['error_code'] = 9999
  4666. _publish_ota_progress()
  4667. # 通过MQTT发送错误响应(同时适配HTTP和MQTT触发)
  4668. _send_ota_error_response(ota_status['error_code'], params.get('_incoming_msg_id', ''))
  4669. logger.error(f"OTA: 升级失败 - {str(e)}")
  4670. if 'tmp_dir' in dir() and tmp_dir and os.path.exists(tmp_dir):
  4671. shutil.rmtree(tmp_dir, ignore_errors=True)
  4672. @app.route('/api/dtu/ota_upgrade', methods=['POST'])
  4673. def trigger_ota_upgrade():
  4674. """触发OTA升级"""
  4675. try:
  4676. data = request.json
  4677. if not data:
  4678. return jsonify({'success': False, 'message': '请求体不能为空'}), 400
  4679. required_fields = ['firmware_url', 'firmware_version', 'file_size', 'checksum', 'checksum_type']
  4680. missing = [f for f in required_fields if not data.get(f)]
  4681. if missing:
  4682. return jsonify({'success': False, 'message': f'缺少必填字段: {", ".join(missing)}'}), 400
  4683. # 已是目标版本且未强制: 1021 (同时通过 MQTT 上报响应)
  4684. force_upgrade = data.get('force_upgrade', False)
  4685. current_version = dtu_config.get('firmware_version', 'v1.0.0')
  4686. if data['firmware_version'] == current_version and not force_upgrade:
  4687. # 通过 MQTT 上报 1021 响应 (与其他错误码一致)
  4688. try:
  4689. _send_ota_error_response(1021, data.get('msg_id', ''))
  4690. except Exception:
  4691. pass
  4692. return jsonify({
  4693. 'success': False,
  4694. 'error_code': 1021,
  4695. 'message': f'已是目标版本: {current_version}'
  4696. }), 400
  4697. # 注入 _incoming_msg_id 使 MQTT 错误响应可回填
  4698. ota_params = {**data, '_incoming_msg_id': data.get('msg_id', '')}
  4699. t = threading.Thread(target=_run_ota, args=(ota_params,), daemon=True)
  4700. t.start()
  4701. return jsonify({
  4702. 'success': True,
  4703. 'message': 'OTA升级已启动',
  4704. 'data': {
  4705. 'target_version': data['firmware_version'],
  4706. 'ota_status': 'DOWNLOADING'
  4707. }
  4708. })
  4709. except Exception as e:
  4710. logger.error(f"触发OTA升级失败: {str(e)}")
  4711. return jsonify({'success': False, 'message': str(e)}), 500
  4712. # ==================== 环境传感器 API ====================
  4713. # 环境传感器数据存储
  4714. env_sensor_data = {
  4715. 'temperature': None, # 环境温度 (℃)
  4716. 'humidity': None, # 环境湿度 (%)
  4717. 'dtu_temperature': None, # DTU主板温度 (℃)
  4718. 'update_time': None, # 数据更新时间
  4719. 'sensor_update_time': None, # 传感器更新时间
  4720. 'connected': False # 传感器连接状态
  4721. }
  4722. # 环境传感器告警阈值
  4723. env_sensor_threshold = {
  4724. 'temp_high': 45.0, # 环境温度上限 (℃)
  4725. 'temp_low': -10.0, # 环境温度下限 (℃)
  4726. 'humidity_high': 80.0, # 环境湿度上限 (%)
  4727. 'humidity_low': 20.0, # 环境湿度下限 (%)
  4728. 'dtu_temp_high': 70.0 # DTU主板温度上限 (℃)
  4729. }
  4730. # 环境传感器历史数据 (保留最近1000条)
  4731. env_sensor_history = []
  4732. @app.route('/api/sensor/env', methods=['GET'])
  4733. def get_env_sensor_data():
  4734. """获取环境传感器当前数据"""
  4735. data = dict(env_sensor_data)
  4736. # DTU 主板温度回退: 若外部未上报,从 sysfs 本地读取
  4737. if data.get('dtu_temperature') is None:
  4738. try:
  4739. import psutil
  4740. temps = psutil.sensors_temperatures(fahrenheit=False) or {}
  4741. for chip_name, entries in temps.items():
  4742. for entry in entries:
  4743. if entry.current and entry.current > 0:
  4744. data['dtu_temperature'] = round(entry.current, 1)
  4745. break
  4746. if data['dtu_temperature'] is not None:
  4747. break
  4748. except Exception:
  4749. pass
  4750. if data.get('dtu_temperature') is None:
  4751. import glob as _glob
  4752. for tz in sorted(_glob.glob('/sys/class/thermal/thermal_zone*/temp')):
  4753. try:
  4754. with open(tz) as f:
  4755. v = int(f.read().strip())
  4756. if v > 0:
  4757. data['dtu_temperature'] = round(v / 1000.0, 1)
  4758. data['update_time'] = data.get('update_time') or __import__('datetime').datetime.now().strftime('%Y-%m-%d %H:%M:%S')
  4759. break
  4760. except Exception:
  4761. continue
  4762. # 附加 CPU/内存使用率(始终本地读取)
  4763. data['cpu_usage'] = _get_cpu_usage()
  4764. data['memory_usage'] = _get_memory_usage()
  4765. return jsonify({
  4766. 'success': True,
  4767. 'data': data
  4768. })
  4769. @app.route('/api/sensor/threshold', methods=['GET', 'POST'])
  4770. def handle_env_sensor_threshold():
  4771. """获取或设置环境传感器告警阈值"""
  4772. if request.method == 'GET':
  4773. return jsonify({
  4774. 'success': True,
  4775. 'data': env_sensor_threshold
  4776. })
  4777. else:
  4778. try:
  4779. data = request.get_json()
  4780. for key in env_sensor_threshold.keys():
  4781. if key in data:
  4782. env_sensor_threshold[key] = float(data[key])
  4783. logger.info(f"更新环境传感器告警阈值: {env_sensor_threshold}")
  4784. return jsonify({
  4785. 'success': True,
  4786. 'message': '阈值设置成功',
  4787. 'data': env_sensor_threshold
  4788. })
  4789. except Exception as e:
  4790. logger.error(f"设置告警阈值失败: {str(e)}")
  4791. return jsonify({'success': False, 'message': str(e)}), 400
  4792. @app.route('/api/sensor/history', methods=['GET'])
  4793. def get_env_sensor_history():
  4794. """获取环境传感器历史数据"""
  4795. try:
  4796. import datetime
  4797. # 获取查询参数
  4798. range_param = request.args.get('range', '24h')
  4799. start_time = request.args.get('start_time')
  4800. end_time = request.args.get('end_time')
  4801. limit = request.args.get('limit', 100, type=int)
  4802. filtered_history = env_sensor_history
  4803. # 解析range参数
  4804. if not start_time and not end_time:
  4805. now = datetime.datetime.now()
  4806. if range_param == '1h':
  4807. start_time = (now - datetime.timedelta(hours=1)).strftime('%Y-%m-%d %H:%M:%S')
  4808. elif range_param == '6h':
  4809. start_time = (now - datetime.timedelta(hours=6)).strftime('%Y-%m-%d %H:%M:%S')
  4810. elif range_param == '24h':
  4811. start_time = (now - datetime.timedelta(hours=24)).strftime('%Y-%m-%d %H:%M:%S')
  4812. elif range_param == '7d':
  4813. start_time = (now - datetime.timedelta(days=7)).strftime('%Y-%m-%d %H:%M:%S')
  4814. elif range_param == '30d':
  4815. start_time = (now - datetime.timedelta(days=30)).strftime('%Y-%m-%d %H:%M:%S')
  4816. # 按时间过滤
  4817. if start_time:
  4818. filtered_history = [h for h in filtered_history if h.get('update_time') >= start_time]
  4819. if end_time:
  4820. filtered_history = [h for h in filtered_history if h.get('update_time') <= end_time]
  4821. # 按时间排序 (新到旧)
  4822. filtered_history = sorted(filtered_history, key=lambda x: x.get('update_time', ''), reverse=True)
  4823. # 限制返回数量
  4824. filtered_history = filtered_history[:limit]
  4825. return jsonify({
  4826. 'success': True,
  4827. 'data': filtered_history,
  4828. 'total': len(filtered_history)
  4829. })
  4830. except Exception as e:
  4831. logger.error(f"获取历史数据失败: {str(e)}")
  4832. return jsonify({'success': False, 'message': str(e)}), 500
  4833. def update_env_sensor_data_full(temperature, humidity, dtu_temperature, sensor_update_time):
  4834. """更新环境传感器数据 (由MQTT消息触发) - 完整版,含历史和告警"""
  4835. import datetime
  4836. now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
  4837. env_sensor_data['temperature'] = temperature
  4838. env_sensor_data['humidity'] = humidity
  4839. env_sensor_data['dtu_temperature'] = dtu_temperature
  4840. env_sensor_data['sensor_update_time'] = sensor_update_time
  4841. env_sensor_data['update_time'] = now
  4842. env_sensor_data['connected'] = True
  4843. # 同步到 MQTT 上行所用的 _env_sensor_data
  4844. _env_sensor_data['temperature'] = temperature
  4845. _env_sensor_data['humidity'] = humidity
  4846. _env_sensor_data['sensor_update_time'] = sensor_update_time
  4847. # 添加到历史记录
  4848. history_record = {
  4849. 'temperature': temperature,
  4850. 'humidity': humidity,
  4851. 'dtu_temperature': dtu_temperature,
  4852. 'sensor_update_time': sensor_update_time,
  4853. 'update_time': now
  4854. }
  4855. env_sensor_history.append(history_record)
  4856. # 保留最近1000条
  4857. if len(env_sensor_history) > 1000:
  4858. env_sensor_history[:] = env_sensor_history[-1000:]
  4859. # 检查告警
  4860. check_env_sensor_alarms(temperature, humidity, dtu_temperature)
  4861. logger.info(f"环境传感器数据更新: 温度={temperature}℃, 湿度={humidity}%, DTU温度={dtu_temperature}℃")
  4862. def dht11_data_callback(temperature, humidity):
  4863. """DHT11 本地 GPIO 传感器数据回调。
  4864. 将读取到的温湿度更新到环境传感器数据区,并通过 MQTT 上报。
  4865. 保留已有的 dtu_temperature(主板温度),仅更新环境温湿度字段。
  4866. 若外部未上报 dtu_temperature,则从本地 sysfs 读取(与 /api/sensor/env 回退逻辑一致),
  4867. 确保历史记录中 DTU 温度字段有值。
  4868. """
  4869. try:
  4870. sensor_update_time = int(time.time() * 1000)
  4871. dtu_temperature = env_sensor_data.get('dtu_temperature')
  4872. # DTU 主板温度回退:外部未上报时从 sysfs 本地读取,并回填 env_sensor_data
  4873. # 否则历史记录 dtu_temperature 会一直是 None(/api/sensor/env 有回退但历史写入没有)
  4874. if dtu_temperature is None:
  4875. try:
  4876. import psutil
  4877. temps = psutil.sensors_temperatures(fahrenheit=False) or {}
  4878. for chip_name, entries in temps.items():
  4879. for entry in entries:
  4880. if entry.current and entry.current > 0:
  4881. dtu_temperature = round(entry.current, 1)
  4882. break
  4883. if dtu_temperature is not None:
  4884. break
  4885. except Exception:
  4886. pass
  4887. if dtu_temperature is None:
  4888. import glob as _glob
  4889. for tz in sorted(_glob.glob('/sys/class/thermal/thermal_zone*/temp')):
  4890. try:
  4891. with open(tz) as f:
  4892. v = int(f.read().strip())
  4893. if v > 0:
  4894. dtu_temperature = round(v / 1000.0, 1)
  4895. break
  4896. except Exception:
  4897. continue
  4898. # 回填到 env_sensor_data,避免每次回调都重新读 sysfs
  4899. if dtu_temperature is not None:
  4900. env_sensor_data['dtu_temperature'] = dtu_temperature
  4901. update_env_sensor_data_full(temperature, humidity, dtu_temperature, sensor_update_time)
  4902. # 立即通过 MQTT 上报环境传感器数据
  4903. try:
  4904. dtu_publish_env_sensor()
  4905. except Exception as pub_err:
  4906. logger.warning(f"DHT11 数据 MQTT 上报失败: {pub_err}")
  4907. logger.info(f"DHT11 本地传感器数据已处理: 温度={temperature}°C, 湿度={humidity}%")
  4908. except Exception as e:
  4909. logger.error(f"处理 DHT11 本地传感器数据失败: {e}")
  4910. def check_env_sensor_alarms(temperature, humidity, dtu_temperature):
  4911. """检查环境传感器告警"""
  4912. alarms = []
  4913. if temperature is not None:
  4914. if temperature > env_sensor_threshold['temp_high']:
  4915. alarms.append({
  4916. 'type': 'temperature_high',
  4917. 'message': f'环境温度过高: {temperature}℃ (阈值: {env_sensor_threshold["temp_high"]}℃)',
  4918. 'level': 'warning'
  4919. })
  4920. elif temperature < env_sensor_threshold['temp_low']:
  4921. alarms.append({
  4922. 'type': 'temperature_low',
  4923. 'message': f'环境温度过低: {temperature}℃ (阈值: {env_sensor_threshold["temp_low"]}℃)',
  4924. 'level': 'warning'
  4925. })
  4926. if humidity is not None:
  4927. if humidity > env_sensor_threshold['humidity_high']:
  4928. alarms.append({
  4929. 'type': 'humidity_high',
  4930. 'message': f'环境湿度过高: {humidity}% (阈值: {env_sensor_threshold["humidity_high"]}%)',
  4931. 'level': 'warning'
  4932. })
  4933. elif humidity < env_sensor_threshold['humidity_low']:
  4934. alarms.append({
  4935. 'type': 'humidity_low',
  4936. 'message': f'环境湿度过低: {humidity}% (阈值: {env_sensor_threshold["humidity_low"]}%)',
  4937. 'level': 'warning'
  4938. })
  4939. if dtu_temperature is not None:
  4940. if dtu_temperature > env_sensor_threshold['dtu_temp_high']:
  4941. alarms.append({
  4942. 'type': 'dtu_temp_high',
  4943. 'message': f'DTU主板温度过高: {dtu_temperature}℃ (阈值: {env_sensor_threshold["dtu_temp_high"]}℃)',
  4944. 'level': 'critical'
  4945. })
  4946. # 发送告警通知
  4947. for alarm in alarms:
  4948. logger.warning(f"环境传感器告警: {alarm['message']}")
  4949. # 可以通过WebSocket发送告警
  4950. socketio.emit('env_sensor_alarm', alarm)
  4951. # ========== 运行数据备份 / 恢复 ==========
  4952. SYSTEM_ENV_FILE = '/etc/default/dzxj_dtu'
  4953. _SNAPSHOT_TARGETS = {
  4954. 'dtu_config': DTU_CONFIG_FILE,
  4955. 'serial_config': SERIAL_CONFIG_FILE,
  4956. 'mqtt_config': MQTT_CONFIG_FILE,
  4957. 'devices': DEVICE_CONFIG_FILE,
  4958. }
  4959. def _read_system_env():
  4960. """读取设备环境变量文件(/etc/default/dzxj_dtu),不存在返回 None"""
  4961. try:
  4962. if os.path.exists(SYSTEM_ENV_FILE):
  4963. with open(SYSTEM_ENV_FILE, 'r', encoding='utf-8') as f:
  4964. return f.read()
  4965. except Exception as e:
  4966. logger.warning(f"读取环境变量文件失败: {e}")
  4967. return None
  4968. def _collect_backup_files():
  4969. """收集备份内容:4 个配置文件 + 系统环境变量文件(可选)"""
  4970. files = {}
  4971. dtu_data = None
  4972. try:
  4973. if os.path.exists(DTU_CONFIG_FILE):
  4974. dtu_data = config_backup.read_json_file(DTU_CONFIG_FILE)
  4975. except Exception as e:
  4976. logger.warning(f"读取 dtu_config.json 失败,改用内存配置: {e}")
  4977. files['dtu_config'] = dtu_data if isinstance(dtu_data, dict) else dict(dtu_config)
  4978. for key, path in (('serial_config', SERIAL_CONFIG_FILE),
  4979. ('mqtt_config', MQTT_CONFIG_FILE),
  4980. ('devices', DEVICE_CONFIG_FILE)):
  4981. data = None
  4982. try:
  4983. if os.path.exists(path):
  4984. data = config_backup.read_json_file(path)
  4985. except Exception as e:
  4986. logger.warning(f"读取 {path} 失败: {e}")
  4987. files[key] = data
  4988. if not isinstance(files.get('devices'), dict):
  4989. files['devices'] = address_config.get_stored_devices()
  4990. files['system_env'] = _read_system_env()
  4991. return files
  4992. def _configs_differ(a, b):
  4993. try:
  4994. return (json.dumps(a or {}, sort_keys=True, ensure_ascii=False)
  4995. != json.dumps(b or {}, sort_keys=True, ensure_ascii=False))
  4996. except Exception:
  4997. return True
  4998. def _backup_preview(bundle):
  4999. """备份包预览信息(导入前确认用)"""
  5000. files = bundle.get('files') or {}
  5001. dtu_data = files.get('dtu_config') or {}
  5002. included = {}
  5003. for key, val in files.items():
  5004. if val in (None, '', {}):
  5005. continue
  5006. if isinstance(val, str):
  5007. included[key] = f'{len(val)} 字节文本'
  5008. else:
  5009. included[key] = f'{len(json.dumps(val, ensure_ascii=False))} 字节'
  5010. prefix = bundle.get('effective_uid_prefix')
  5011. return {
  5012. 'created_at': bundle.get('created_at'),
  5013. 'device': bundle.get('device') or {},
  5014. 'files': included,
  5015. 'effective_uid_prefix': prefix,
  5016. 'current_dtu_id': dtu_config.get('dtu_id'),
  5017. 'backup_dtu_id': dtu_data.get('dtu_id'),
  5018. 'will_fix_uid_prefix': bool(prefix) and not dtu_data.get('uid_prefix'),
  5019. 'restart_required': isinstance(files.get('system_env'), str) and bool((files.get('system_env') or '').strip()),
  5020. 'devices_count': len(files.get('devices') or {}),
  5021. 'port_mapping_panels': len(dtu_data.get('port_mappings') or {}),
  5022. }
  5023. def _apply_backup_bundle(bundle):
  5024. """应用备份包:写文件 + 内存生效 + 自动重连,返回结果摘要"""
  5025. files = bundle.get('files') or {}
  5026. applied = []
  5027. errors = []
  5028. # 1) dtu_config(固化 effective_uid_prefix,保证换机后卡号前缀一致)
  5029. dtu_data = files.get('dtu_config')
  5030. if isinstance(dtu_data, dict):
  5031. dtu_data = dict(dtu_data)
  5032. prefix = (bundle.get('effective_uid_prefix') or '').strip().upper()
  5033. if prefix and not dtu_data.get('uid_prefix'):
  5034. dtu_data['uid_prefix'] = prefix
  5035. applied.append(f'已固化 UID 前缀: {prefix}')
  5036. dtu_config.update(dtu_data)
  5037. save_dtu_config()
  5038. applied.append('dtu_config')
  5039. # 2) 串口配置(变化则重连)
  5040. sc = files.get('serial_config')
  5041. if isinstance(sc, dict):
  5042. old_sc = load_serial_config()
  5043. if _save_config_file(SERIAL_CONFIG_FILE, sc, '串口配置'):
  5044. applied.append('serial_config')
  5045. if _configs_differ(old_sc, sc):
  5046. try:
  5047. if _serial_connected():
  5048. serial_client.disconnect()
  5049. auto_connect_serial()
  5050. except Exception as e:
  5051. errors.append(f'串口重连失败: {e}')
  5052. # 3) MQTT 配置(变化则重连)
  5053. mc = files.get('mqtt_config')
  5054. if isinstance(mc, dict):
  5055. old_mc = load_mqtt_config()
  5056. if _save_config_file(MQTT_CONFIG_FILE, mc, 'MQTT配置'):
  5057. applied.append('mqtt_config')
  5058. if _configs_differ(old_mc, mc):
  5059. try:
  5060. if _mqtt_connected():
  5061. mqtt_client.disconnect()
  5062. auto_connect_mqtt()
  5063. except Exception as e:
  5064. errors.append(f'MQTT重连失败: {e}')
  5065. # 4) 线架绑定表(重建面板配置)
  5066. dev = files.get('devices')
  5067. if isinstance(dev, dict):
  5068. if _save_config_file(DEVICE_CONFIG_FILE, dev, '设备配置'):
  5069. applied.append('devices')
  5070. address_config.stored_devices = {str(k).lower(): int(v) for k, v in dev.items()}
  5071. panel_config.clear()
  5072. port_state.clear()
  5073. panel_keepalive_miss.clear()
  5074. panel_mappings_synced.clear()
  5075. panel_conflict.clear()
  5076. sync_panel_config()
  5077. # 5) 系统环境变量文件(需重启服务生效)
  5078. restart_required = False
  5079. env_text = files.get('system_env')
  5080. if isinstance(env_text, str) and env_text.strip():
  5081. try:
  5082. with open(SYSTEM_ENV_FILE, 'w', encoding='utf-8') as f:
  5083. f.write(env_text)
  5084. applied.append('system_env')
  5085. restart_required = True
  5086. except Exception as e:
  5087. errors.append(f'写入环境变量文件失败(需 root): {e}')
  5088. # 6) 后台补一次注册上报
  5089. def _post_restore_refresh():
  5090. try:
  5091. if _mqtt_connected():
  5092. dtu_register()
  5093. except Exception as e:
  5094. logger.warning(f"恢复后注册上报失败: {e}")
  5095. threading.Thread(target=_post_restore_refresh, daemon=True).start()
  5096. return {'applied': applied, 'errors': errors, 'restart_required': restart_required}
  5097. @app.route('/api/backup/export', methods=['GET'])
  5098. def backup_export():
  5099. """导出整机运行数据备份包(download=1 时作为文件下载)"""
  5100. try:
  5101. files = _collect_backup_files()
  5102. bundle = config_backup.build_bundle(
  5103. files,
  5104. device_meta={
  5105. 'dtu_id': dtu_config.get('dtu_id'),
  5106. 'customer_id': dtu_config.get('customer_id'),
  5107. 'firmware_version': dtu_config.get('firmware_version'),
  5108. 'hardware_version': dtu_config.get('hardware_version'),
  5109. 'hostname': os.uname().nodename,
  5110. },
  5111. uid_prefix=_dtu_uid_prefix(),
  5112. )
  5113. except Exception as e:
  5114. logger.error(f"导出备份失败: {e}")
  5115. return jsonify({'success': False, 'message': str(e)}), 500
  5116. if request.args.get('download') in ('1', 'true', 'True'):
  5117. text = json.dumps(bundle, ensure_ascii=False, indent=2)
  5118. fname = f"dzxj_dtu_backup_{dtu_config.get('dtu_id', 'dtu')}_{time.strftime('%Y%m%d_%H%M%S')}.json"
  5119. resp = app.response_class(text, mimetype='application/json')
  5120. resp.headers['Content-Disposition'] = f'attachment; filename="{fname}"'
  5121. return resp
  5122. return jsonify({'success': True, 'bundle': bundle})
  5123. @app.route('/api/backup/import', methods=['POST'])
  5124. def backup_import():
  5125. """导入整机备份(支持上传文件/JSON body;dry_run=1 仅预览不应用)"""
  5126. try:
  5127. raw = b''
  5128. if 'file' in request.files:
  5129. raw = request.files['file'].read()
  5130. dry_run = request.args.get('dry_run') in ('1', 'true', 'True')
  5131. if not raw:
  5132. body = request.get_json(silent=True)
  5133. if isinstance(body, dict) and 'bundle' in body:
  5134. raw = json.dumps(body['bundle'], ensure_ascii=False).encode('utf-8')
  5135. dry_run = dry_run or bool(body.get('dry_run'))
  5136. elif body is not None:
  5137. raw = json.dumps(body, ensure_ascii=False).encode('utf-8')
  5138. else:
  5139. raw = request.get_data() or b''
  5140. if not raw:
  5141. return jsonify({'success': False, 'message': '未收到备份内容'}), 400
  5142. if len(raw) > config_backup.MAX_BUNDLE_BYTES:
  5143. return jsonify({'success': False, 'message': '备份文件过大'}), 400
  5144. try:
  5145. bundle = json.loads(raw.decode('utf-8'))
  5146. except Exception:
  5147. return jsonify({'success': False, 'message': '备份内容不是有效 JSON'}), 400
  5148. ok, msg = config_backup.validate_bundle(bundle)
  5149. if not ok:
  5150. return jsonify({'success': False, 'message': msg}), 400
  5151. preview = _backup_preview(bundle)
  5152. if dry_run:
  5153. return jsonify({'success': True, 'dry_run': True, 'preview': preview})
  5154. logger.info(f"开始导入备份: created_at={bundle.get('created_at')} files={list((bundle.get('files') or {}).keys())}")
  5155. summary = _apply_backup_bundle(bundle)
  5156. logger.info(f"备份导入完成: {summary}")
  5157. return jsonify({'success': True, 'message': '备份已恢复', 'preview': preview, **summary})
  5158. except Exception as e:
  5159. logger.error(f"导入备份失败: {e}")
  5160. return jsonify({'success': False, 'message': str(e)}), 500
  5161. @app.route('/api/backup/list', methods=['GET'])
  5162. def backup_list():
  5163. """列出设备内自动快照"""
  5164. return jsonify({'success': True, 'backups': config_backup.list_snapshots(BACKUP_DIR)})
  5165. @app.route('/api/backup/download', methods=['GET'])
  5166. def backup_download():
  5167. """下载指定快照文件"""
  5168. name = request.args.get('name', '')
  5169. data, err = config_backup.read_snapshot(name, BACKUP_DIR)
  5170. if err:
  5171. return jsonify({'success': False, 'message': err}), 404
  5172. text = json.dumps(data, ensure_ascii=False, indent=2)
  5173. resp = app.response_class(text, mimetype='application/json')
  5174. resp.headers['Content-Disposition'] = f'attachment; filename="{os.path.basename(name)}"'
  5175. return resp
  5176. @app.route('/api/backup/restore_snapshot', methods=['POST'])
  5177. def backup_restore_snapshot():
  5178. """从设备内自动快照恢复单个配置文件"""
  5179. try:
  5180. payload = request.json or {}
  5181. name = payload.get('name', '')
  5182. content, err = config_backup.read_snapshot(name, BACKUP_DIR)
  5183. if err:
  5184. return jsonify({'success': False, 'message': err}), 404
  5185. stem = config_backup.snapshot_stem(name)
  5186. if not stem or stem not in _SNAPSHOT_TARGETS:
  5187. return jsonify({'success': False, 'message': f'未知快照类型: {stem}'}), 400
  5188. bundle = config_backup.build_bundle(
  5189. {stem: content},
  5190. device_meta={'source': 'snapshot', 'snapshot': name},
  5191. )
  5192. ok, msg = config_backup.validate_bundle(bundle)
  5193. if not ok:
  5194. return jsonify({'success': False, 'message': msg}), 400
  5195. summary = _apply_backup_bundle(bundle)
  5196. logger.info(f"已从快照 {name} 恢复: {summary}")
  5197. return jsonify({'success': True, 'message': f'已从快照恢复 {stem}', **summary})
  5198. except Exception as e:
  5199. logger.error(f"快照恢复失败: {e}")
  5200. return jsonify({'success': False, 'message': str(e)}), 500
  5201. @app.route('/api/backup/delete', methods=['POST'])
  5202. def backup_delete():
  5203. """删除指定快照"""
  5204. payload = request.json or {}
  5205. ok, msg = config_backup.delete_snapshot(payload.get('name', ''), BACKUP_DIR)
  5206. return (jsonify({'success': True, 'message': msg}) if ok
  5207. else jsonify({'success': False, 'message': msg})), (200 if ok else 404)
  5208. @app.route('/api/system/restart_service', methods=['POST'])
  5209. def restart_service():
  5210. """重启 dzxj_dtu 服务(延时 1 秒执行,让本次响应先返回)"""
  5211. def _do_restart():
  5212. import subprocess
  5213. time.sleep(1.0)
  5214. try:
  5215. subprocess.run(['systemctl', 'restart', 'dzxj_dtu'], timeout=30)
  5216. logger.info("已执行 systemctl restart dzxj_dtu")
  5217. except Exception as e:
  5218. logger.error(f"重启 dzxj_dtu 服务失败: {e}")
  5219. threading.Thread(target=_do_restart, daemon=True).start()
  5220. return jsonify({'success': True, 'message': 'dzxj_dtu 服务将在 1 秒后重启'})
  5221. if __name__ == '__main__':
  5222. try:
  5223. # 启动前的初始化工作
  5224. logger.info('启动串口-MQTT网关服务...')
  5225. logger.info(f"配置信息: 主机={FLASK_HOST}, 端口={FLASK_PORT}, 调试模式={FLASK_DEBUG}")
  5226. # 加载DTU配置
  5227. load_dtu_config()
  5228. # 一次性清理历史脏数据:旧版单端口写卡会把 24 路(含大量 null)落盘
  5229. try:
  5230. _pruned = _prune_null_port_mappings()
  5231. if _pruned:
  5232. save_dtu_config()
  5233. logger.info(f"已清理 port_mappings 中的空(null)端口映射 {_pruned} 条")
  5234. except Exception as e:
  5235. logger.warning(f"清理空端口映射失败: {e}")
  5236. # 加载线架绑定表(地址↔UID)
  5237. loaded = load_device_config()
  5238. logger.info(f"已加载 {len(loaded)} 个线架绑定")
  5239. # 自动连接上次使用的串口(RS485),必须先连接才能做地址段扫描
  5240. logger.info("尝试自动连接串口...")
  5241. auto_connect_serial()
  5242. # 自动连接上次使用的MQTT服务器
  5243. logger.info("尝试自动连接MQTT...")
  5244. auto_connect_mqtt()
  5245. # 根据绑定表重建面板列表(真实在线状态由地址段扫描实时刷新)
  5246. try:
  5247. _st = serial_client.get_status()
  5248. if isinstance(_st, dict) and _st.get('connected', False) and dtu_config.get('enabled'):
  5249. sync_panel_config()
  5250. else:
  5251. logger.info("串口未连接或 DTU 未启用,面板列表将在地址段扫描后建立")
  5252. except Exception as e:
  5253. logger.error(f"启动前检查串口状态失败: {e}")
  5254. logger.info(f"当前面板数: {len(panel_config)},地址段: {_address_range()[0]}-{_address_range()[1]}")
  5255. # 启动DTU心跳定时器
  5256. if dtu_config.get('enabled'):
  5257. start_dtu_heartbeat()
  5258. logger.info("启动DTU心跳定时器")
  5259. # 启动线架地址段扫描循环(注册模型:地址段顺序轮询 + UID 绑定 + 换架自动接管)
  5260. def port_poll_loop():
  5261. while True:
  5262. interval = dtu_config.get('poll_interval_ms', 5000) / 1000.0
  5263. time.sleep(max(1, interval))
  5264. try:
  5265. # 地址配置期间暂停扫描,避免总线上同时出现查询帧和配置帧
  5266. if not address_config.config_lock.acquire(blocking=False):
  5267. logger.info("地址配置进行中,本轮扫描跳过")
  5268. continue
  5269. try:
  5270. _st = serial_client.get_status()
  5271. if not (isinstance(_st, dict) and _st.get('connected', False)):
  5272. continue
  5273. if not dtu_config.get('enabled'):
  5274. continue
  5275. online, offline = _sweep_panel_addresses()
  5276. logger.debug(f"地址段扫描完成: 在线={online}, 离线/缺失={offline}")
  5277. dtu_publish_status(force=True)
  5278. finally:
  5279. address_config.config_lock.release()
  5280. except Exception as e:
  5281. logger.error(f"线架地址段扫描异常: {str(e)}")
  5282. t2 = threading.Thread(target=port_poll_loop, daemon=True)
  5283. t2.start()
  5284. logger.info(f"启动线架地址段扫描线程 (顺序轮询 {_address_range()[0]}-{_address_range()[1]})")
  5285. # 启动 DHT11 本地传感器读取线程
  5286. if dht11_sensor is not None:
  5287. dht11_sensor.on_data = dht11_data_callback
  5288. dht11_sensor.start()
  5289. # 连接 Nextion 串口屏
  5290. if NEXTION_ENABLED:
  5291. try:
  5292. ok, msg = screen_display.connect(NEXTION_SCREEN_PORT, NEXTION_SCREEN_BAUD)
  5293. if ok:
  5294. screen_display.set_button_callback(screen_button_event_handler)
  5295. logger.info("Nextion 屏幕连接成功")
  5296. panels = get_sorted_panels()
  5297. if panels:
  5298. refresh_screen_panel(panels[0][0])
  5299. else:
  5300. # 没有配线架时也要把 IP/版本/MQTT 状态刷到屏幕
  5301. _send_screen_header()
  5302. else:
  5303. logger.warning(f"Nextion 屏幕连接失败: {msg}")
  5304. except Exception as e:
  5305. logger.error(f"Nextion 屏幕初始化异常: {e}")
  5306. # 启动 Nextion 屏幕异步刷新工作线程
  5307. screen_refresh_thread = threading.Thread(target=_screen_refresh_worker, daemon=True)
  5308. screen_refresh_thread.start()
  5309. logger.info("启动 Nextion 屏幕异步刷新线程")
  5310. # 启动网络 IP 监测线程:插网线获取到 IP 后及时写入串口屏
  5311. network_ip_monitor_thread = threading.Thread(target=_network_ip_monitor_loop, daemon=True)
  5312. network_ip_monitor_thread.start()
  5313. logger.info("启动网络 IP 监测线程")
  5314. # 启动服务
  5315. socketio.run(
  5316. app,
  5317. host=FLASK_HOST,
  5318. port=FLASK_PORT,
  5319. debug=FLASK_DEBUG,
  5320. use_reloader=False, # 禁用重载器以避免重复初始化问题
  5321. log_output=False, # 禁用Flask的日志输出,使用我们自己的日志配置
  5322. allow_unsafe_werkzeug=True
  5323. )
  5324. except KeyboardInterrupt:
  5325. # 优雅退出
  5326. logger.info('正在关闭应用...')
  5327. try:
  5328. if isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False):
  5329. serial_client.disconnect()
  5330. logger.info('串口连接已断开')
  5331. if _mqtt_connected():
  5332. mqtt_client.disconnect()
  5333. logger.info('MQTT连接已断开')
  5334. if dht11_sensor is not None:
  5335. dht11_sensor.stop()
  5336. logger.info('DHT11 传感器线程已停止')
  5337. except Exception as e:
  5338. logger.error(f'关闭连接时出错: {str(e)}')
  5339. # 清理WebSocket连接
  5340. for client_type in connected_clients:
  5341. connected_clients[client_type].clear()
  5342. logger.info('应用已安全关闭')
  5343. except Exception as e:
  5344. logger.exception(f'应用启动失败') # 使用exception记录完整堆栈
  5345. # 确保资源被释放
  5346. try:
  5347. serial_client.disconnect()
  5348. mqtt_client.disconnect()
  5349. except:
  5350. pass