app.py 232 KB

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