app.py 230 KB

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