app.py 246 KB

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