hmi.c 158 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808
  1. /*
  2. * Copyright (c) 2006-2020, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2020-05-26 Administrator the first version
  9. */
  10. /* [2026-10-15] 日志配置必须放在本文件所有 include 之前: spi_flash_sfud.h ->
  11. * sfud_cfg.h 会抢先 #include <rtdbg.h>(该头带 include guard) 并以 DBG_LVL=DBG_INFO
  12. * 钉死本文件的日志等级 —— 放在后面会使 LOG_D 被整体裁剪
  13. * (现象: 屏幕接收原始数据等 LOG_D 打印消失)。此处直接定义 DBG_SECTION_NAME 而非
  14. * DBG_TAG, 避免 sfud_cfg.h 的 DBG_TAG 重定义("SFUD")影响本文件日志节名。 */
  15. #define DBG_ENABLE
  16. #define DBG_COLOR
  17. #define DBG_SECTION_NAME "hmi"
  18. #define DBG_LEVEL DBG_LOG
  19. #include <rtdbg.h>
  20. #include <rtthread.h>
  21. #include "hmi.h"
  22. #include <board.h>
  23. #include <control.h>
  24. #include <rtdevice.h>
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  28. #include "stdarg.h"
  29. #include "string.h"
  30. #include "sht30_collect.h"
  31. #include "beep.h"
  32. #include "easyflash.h"
  33. #include "sound.h"
  34. #include "ymodem.h"
  35. #include <shell.h>
  36. #include <msh.h> /* msh_exec:屏幕 debug1 调试页控制台命令执行 */
  37. #include "dtu_uart2.h"
  38. #include <fal.h>
  39. #include <spi_flash_sfud.h> /* debug1 页外挂Flash信息(与 sys_monitor.c 相同方式读取) */
  40. #include "selfcheck.h"
  41. #include <user_mb_app.h>
  42. #include "sys_monitor.h"
  43. #include "param_mirror.h"
  44. #define HMI_THREAD_PRIORITY 5 //线程优先级
  45. #define HMI_THREAD_STACK_SIZE 2048 //线程栈空间大小
  46. #define HMI_THREAD_TIMESLICE 10 //时间片
  47. #define CONTROL_MOTOR_PRIORITY 18
  48. #define CONTROL_MOTOR_STACK_SIZE 2048
  49. #define CONTROL_MOTOR_TIMESLICE 5
  50. static char msg_pool[512];
  51. static char rx_buffer[HMI_UART_RXBUFFER_SIZE + 1];
  52. static char rx_pkt[HMI_UART_RXBUFFER_SIZE + 1];
  53. int mb_master_samlpe();
  54. /**/
  55. /* device_status 已收敛为全工程唯一定义(在 main.c), 此处不再重复定义, 见 control.h 的 extern 声明 */
  56. /* system_status 已收敛为全工程唯一定义(在 sys_monitor.c), 见 sys_monitor.h 的 extern 声明 */
  57. extern eMBMasterReqErrCode _485_play(USHORT *Buffer,USHORT NREGS);
  58. time_t time(time_t *t);
  59. /* 串口接收消息结构*/
  60. struct rx_msg
  61. {
  62. rt_device_t dev;
  63. rt_size_t size;
  64. };
  65. struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT; /*初始化配置参数*/
  66. ////
  67. static rt_thread_t hmi1 = RT_NULL;
  68. static rt_thread_t ctr_motor = RT_NULL;
  69. rt_device_t serial; /*串口设备句柄*/
  70. rt_timer_t timer_uart2 = RT_NULL;
  71. static upgrade_state_t current_state = STATE_IDLE;
  72. uint32_t total_file_size = 0;
  73. static uint32_t bytes_received = 0;
  74. static uint8_t recv_buffer[RECV_BUFFER_SIZE];
  75. static uint32_t recv_write_pos = 0;
  76. /* 消息队列控制块 */
  77. static struct rt_messagequeue rx_mq;//接收数据消息队列
  78. static void HMI_Decode(void);
  79. static rt_err_t uart_input(rt_device_t dev, rt_size_t size);
  80. /* P2-14 把开机等联网搬进独立线程时新增的两个函数, 定义在文件后段
  81. (Check_ParamConfig 之后), 但 net_wait_start() 在前面的 Check_ParamConfig 里
  82. 就被调用 -> 必须先有前向声明, 否则报 implicit declaration。 */
  83. static void net_wait_thread_entry(void);
  84. /* 开机"联网检测线程"(net_wait)是否仍在运行。
  85. net_wait 在等网期间自己每秒发一帧 read 去刷新网络状态;
  86. refresh_hmi_Component() 每 5 个节拍也会发一帧 read —— 两者同时发就是重复上报,
  87. RTU 会连续收到两倍 read 帧。用本标志让 HMI 侧在 net_wait 退出前让路。 */
  88. static volatile uint8_t net_wait_running = 0;
  89. #ifdef RT_USING_SERIAL_V2
  90. static int HMI_uart4_init(void)
  91. {
  92. serial = rt_device_find(UART_NAME);
  93. /*修改串口配置参数*/
  94. config.baud_rate = BAUD_RATE_115200; //修改波特率9600
  95. config.data_bits = DATA_BITS_8; //数据位8
  96. config.stop_bits = STOP_BITS_1; //停止位1
  97. #ifdef RT_USING_SERIAL_V2
  98. config.rx_bufsz = 512;
  99. config.tx_bufsz = 1024;
  100. #else
  101. config.bufsz = 512; //缓冲区128字节
  102. #endif
  103. config.parity = PARITY_NONE; //无奇偶校验
  104. /* step3:控制串口设备。通过控制接口传入命令控制字,与控制参数 */
  105. rt_device_control(serial, RT_DEVICE_CTRL_CONFIG, &config);
  106. // /* step4:打开串口设备。以中断接收及轮询发送模式打开串口设备 */
  107. //rt_device_open(serial, RT_DEVICE_FLAG_INT_RX);
  108. /* 以 DMA 接收及轮询发送模式打开串口设备 */
  109. #ifdef RT_USING_SERIAL_V2
  110. rt_err_t uart_res = rt_device_open(serial, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_NON_BLOCKING); // 串口设备使用模式为 (发送阻塞 接收非阻塞) 模式
  111. #else
  112. rt_err_t uart_res = rt_device_open(serial, RT_DEVICE_FLAG_DMA_RX); //RT_DEVICE_FLAG_DMA_RX
  113. #endif
  114. if(uart_res!=RT_EOK)
  115. {
  116. LOG_E("%s打开失败!",UART_NAME);
  117. }else{
  118. LOG_I("%s Open Success!",UART_NAME);
  119. }
  120. return RT_EOK;
  121. }
  122. #endif
  123. /* ==================== UART4(屏幕)发送:互斥 / 升级闸门 / 批量 / 去重 ====================
  124. * 来源: master 分支 2026-10-10 发送优化(HMI_WRITE 签名不变, 调用方无感):
  125. * ① 批量发送:HMI_BATCH_BEGIN()/END() 之间累积成整块再一次写入(缓冲满自动 flush);
  126. * 整页刷新 60+ 条属性由 60+ 次写合并为 1~3 次写。
  127. * ② 重复过滤:同一调用点(用格式化串地址唯一标识)输出内容与上次相同则不发送;
  128. * 直接映射表, 槽位冲突按"未命中"处理——只会多发、绝不会漏发。
  129. * ③ 过滤表每 HMI_DEDUPE_RESYNC_SEC 秒整体复位, 并在 Swversion 握手串变化
  130. * (换型号/换页面/屏幕重启)时立即复位, 保证屏幕不长期停在旧值。
  131. * ④ 升级闸门: 屏幕升级传输期间屏蔽普通刷新指令(见 Hmi_Upgrade_Begin/End),
  132. * 避免业务数据混入升级固件流; 60s 无新升级数据自动解除。
  133. * 平台差异(apm32f1): 保留 g_hmi_port_closed 早退(OTA 前 uart4 已 close,
  134. * 继续写会解引用已释放的 tx_fifo 而 HardFault, 见 hmi.h 注释)。
  135. * 维护提示:新增刷新项直接用 HMI_WRITE 即可, 无需关心批量/去重。 */
  136. /* ---------- 发送互斥与升级状态 ---------- */
  137. static struct rt_mutex hmi_write_mutex;
  138. static rt_bool_t hmi_mutex_inited = RT_FALSE;
  139. static volatile rt_tick_t s_hmi_upgrade_tick = 0; /* 0=不在升级; 非0=最近一次升级数据时间 */
  140. /* 串口4(HMI屏)在 OTA 升级前被关闭, 置 1 后所有发送路径直接 return。
  141. 为什么必须有这个标志而不能只靠句柄判空:
  142. rt_device_close() 真正关掉设备时, serial_v2 的 rt_serial_rx/tx_disable()
  143. 会 rt_free 掉 rx/tx fifo 并把 serial->serial_rx / serial_tx 置 NULL,
  144. 但 dev 指针本身依然非空、依然能被 rt_device_write() 调到;
  145. 而 rt_serial_write() 会直接 `serial->serial_tx->activated` 解引用 →
  146. 空指针, 整机 HardFault。所以必须靠这个显式标志拦住。 */
  147. rt_uint8_t g_hmi_port_closed = 0;
  148. static rt_bool_t hmi_write_lock(void)
  149. {
  150. /* 中断上下文不加锁(互斥锁不允许在中断中获取) */
  151. if (rt_interrupt_get_nest() != 0)
  152. {
  153. return RT_FALSE;
  154. }
  155. if (!hmi_mutex_inited)
  156. {
  157. rt_base_t level = rt_hw_interrupt_disable();
  158. if (!hmi_mutex_inited)
  159. {
  160. if (rt_mutex_init(&hmi_write_mutex, "hmi_mtx", RT_IPC_FLAG_FIFO) == RT_EOK)
  161. {
  162. hmi_mutex_inited = RT_TRUE;
  163. }
  164. }
  165. rt_hw_interrupt_enable(level);
  166. }
  167. if (hmi_mutex_inited)
  168. {
  169. rt_mutex_take(&hmi_write_mutex, RT_WAITING_FOREVER);
  170. return RT_TRUE;
  171. }
  172. return RT_FALSE;
  173. }
  174. static void hmi_write_unlock(void)
  175. {
  176. if (hmi_mutex_inited)
  177. {
  178. rt_mutex_release(&hmi_write_mutex);
  179. }
  180. }
  181. void Hmi_Upgrade_Begin(void)
  182. {
  183. s_hmi_upgrade_tick = rt_tick_get();
  184. LOG_I("HMI upgrade begin");
  185. }
  186. void Hmi_Upgrade_End(void)
  187. {
  188. s_hmi_upgrade_tick = 0;
  189. LOG_I("HMI upgrade end");
  190. }
  191. /* 升级传输期间返回真:屏蔽普通属性刷新,避免混入固件数据流;
  192. * 60s 内没有新的升级数据自动解除(防止升级中断后屏幕刷新永久失效)。 */
  193. static rt_bool_t hmi_upgrade_busy(void)
  194. {
  195. rt_tick_t t = s_hmi_upgrade_tick;
  196. if (t == 0)
  197. {
  198. return RT_FALSE;
  199. }
  200. if ((rt_tick_get() - t) > (60 * RT_TICK_PER_SECOND))
  201. {
  202. s_hmi_upgrade_tick = 0;
  203. LOG_W("HMI upgrade timeout, auto clear busy flag");
  204. return RT_FALSE;
  205. }
  206. return RT_TRUE;
  207. }
  208. /* ---------- 重复过滤(CRC32 直接映射表) ---------- */
  209. #define HMI_DEDUPE_EN 1 /* 置 0 可整体关闭重复过滤(调试用) */
  210. #define HMI_DEDUPE_ENTRIES 96 /* 槽位数; 冲突只影响压缩率, 不影响正确性 */
  211. #define HMI_DEDUPE_RESYNC_SEC 10 /* 定期全量刷新周期(s) */
  212. typedef struct {
  213. const char *key; /* 格式化串地址:每个调用点唯一 */
  214. rt_uint32_t crc; /* 上次发送内容的 CRC32 */
  215. rt_uint16_t len; /* 上次发送内容长度 */
  216. } hmi_dedupe_item_t;
  217. static hmi_dedupe_item_t hmi_dedupe_tab[HMI_DEDUPE_ENTRIES];
  218. static rt_uint16_t hmi_dedupe_tick_cnt = 0;
  219. static rt_uint32_t hmi_crc32(const char *s, rt_uint16_t len)
  220. {
  221. rt_uint32_t crc = 0xFFFFFFFFu;
  222. rt_uint16_t i;
  223. rt_uint8_t k;
  224. for (i = 0; i < len; i++)
  225. {
  226. crc ^= (rt_uint8_t)s[i];
  227. for (k = 0; k < 8; k++)
  228. {
  229. crc = (crc >> 1) ^ (0xEDB88320u & (rt_uint32_t)(-(rt_int32_t)(crc & 1u)));
  230. }
  231. }
  232. return ~crc;
  233. }
  234. static rt_uint16_t hmi_dedupe_index(const char *key)
  235. {
  236. return (rt_uint16_t)(((rt_uint32_t)key >> 2) % HMI_DEDUPE_ENTRIES);
  237. }
  238. /* 返回 RT_TRUE:本次内容与上次完全相同,可跳过发送 */
  239. static rt_bool_t hmi_dedupe_skip(const char *key, const char *line, rt_uint16_t len)
  240. {
  241. rt_uint16_t idx = hmi_dedupe_index(key);
  242. hmi_dedupe_item_t *it = &hmi_dedupe_tab[idx];
  243. rt_uint32_t crc = hmi_crc32(line, len);
  244. if (it->key == key && it->len == len && it->crc == crc)
  245. {
  246. return RT_TRUE;
  247. }
  248. /* 写入顺序:crc/len 先写、key 最后写; 读取时先比 key——
  249. * 这样并发时"命中"的条目其 crc/len 一定是完整的 */
  250. it->crc = crc;
  251. it->len = len;
  252. it->key = key;
  253. return RT_FALSE;
  254. }
  255. static void hmi_dedupe_reset(void)
  256. {
  257. rt_memset(hmi_dedupe_tab, 0, sizeof(hmi_dedupe_tab)); /* key=NULL, 任何真实调用点都不会命中 */
  258. hmi_dedupe_tick_cnt = 0;
  259. }
  260. /* 由 Ctr_Mortor_entry 每 100ms 调用一次:到点复位过滤表(等价于下一次刷新全量重发) */
  261. static void hmi_dedupe_tick(void)
  262. {
  263. if (++hmi_dedupe_tick_cnt >= (HMI_DEDUPE_RESYNC_SEC * 10))
  264. {
  265. hmi_dedupe_reset();
  266. }
  267. }
  268. /* ---------- ① 批量发送 ---------- */
  269. #define HMI_BATCH_BUF_SIZE 1024 /* 累积缓冲; 满则自动 flush, 不丢指令 */
  270. static char hmi_batch_buf[HMI_BATCH_BUF_SIZE];
  271. static rt_uint16_t hmi_batch_len = 0;
  272. static volatile rt_bool_t hmi_batch_on = RT_FALSE;
  273. static rt_thread_t hmi_batch_owner = RT_NULL; /* 批量会话所属线程 */
  274. #define HMI_BATCH_BEGIN() Hmi_Batch_Begin()
  275. #define HMI_BATCH_END() Hmi_Batch_End()
  276. /* ---------- 完整写入(nonblocking TX 的环形缓冲保护,2026-10-15) ----------
  277. * uart4 以 TX_NON_BLOCKING 打开(见 HMI_uart4_init):数据先进 1024B 的 TX
  278. * 环形缓冲,rt_device_write 只接受能容纳的部分并立即返回,**超出的静默丢弃**。
  279. * 2.48 时代逐条发送(约30B)+ 每条 mdelay(1) 自然节流,缓冲几乎不积压;
  280. * 2.49 引入批量发送后单次 flush 可达 1024B:第 1 批写满缓冲并启动 DMA
  281. * (1024B@115200 ≈ 89ms 才发完),同一刷新内的第 2/3 批到达时缓冲仍满 →
  282. * **整批丢失**。现象:屏幕后段控件(menu.va_net / menu.cam_sta 等)收不到
  283. * 指令;且发送去重表已记录"值未变不再重发" → 该控件永久不更新
  284. * (每 10s 全量轮的重发又落回被丢批次)。
  285. * 本函数分块写入并检查实际写入量,未写完时让出等待 TX 缓冲释放后重试;
  286. * 中断上下文不等待(保持 HMI_WRITE 的中断可调用性),仅尽力发送。
  287. * 返回实际写入字节数。 */
  288. #define HMI_TX_RETRY_MAX 400 /* 最长等待约 400ms:覆盖升级块 4KB@115200≈356ms;普通刷新远小于此 */
  289. static rt_uint16_t hmi_write_all(const void *data, rt_uint16_t len)
  290. {
  291. const char *pbuf = (const char *)data;
  292. rt_uint16_t sent = 0;
  293. rt_uint16_t retry = 0;
  294. while (sent < len)
  295. {
  296. rt_size_t n = rt_device_write(serial, 0, pbuf + sent, len - sent);
  297. sent += (rt_uint16_t)n;
  298. if (sent >= len)
  299. {
  300. break;
  301. }
  302. /* 中断上下文不能等待:放弃剩余(正常业务发送都走线程上下文) */
  303. if (rt_interrupt_get_nest() != 0)
  304. {
  305. break;
  306. }
  307. if (++retry > HMI_TX_RETRY_MAX)
  308. {
  309. LOG_W("hmi tx wait timeout, dropped %u bytes", (unsigned)(len - sent));
  310. break;
  311. }
  312. rt_thread_mdelay(1);
  313. }
  314. system_status.uart4_tx_bytes += sent;
  315. return sent;
  316. }
  317. void Hmi_Batch_Begin(void)
  318. {
  319. hmi_batch_len = 0;
  320. hmi_batch_owner = rt_thread_self();
  321. hmi_batch_on = RT_TRUE;
  322. }
  323. void Hmi_Batch_End(void)
  324. {
  325. hmi_batch_on = RT_FALSE;
  326. hmi_batch_owner = RT_NULL;
  327. if (hmi_batch_len > 0)
  328. {
  329. if (!g_hmi_port_closed && serial != RT_NULL)
  330. {
  331. rt_bool_t locked = hmi_write_lock();
  332. hmi_write_all(hmi_batch_buf, hmi_batch_len); /* 完整写入: TX 缓冲满时等待重试, 不丢数据 */
  333. if (locked)
  334. {
  335. hmi_write_unlock();
  336. }
  337. }
  338. hmi_batch_len = 0;
  339. }
  340. }
  341. /* 访问批量缓冲只允许批量会话的属主线程(见 HMI_WRITE):
  342. * 其它线程即便在批量期间调用 HMI_WRITE 也直接立即发送,
  343. * 避免两线程同时往同一缓冲追加导致内容错乱。 */
  344. static rt_bool_t hmi_batch_owned(void)
  345. {
  346. return (hmi_batch_on && hmi_batch_owner == rt_thread_self()) ? RT_TRUE : RT_FALSE;
  347. }
  348. /* 单条立即发送(批量会话外的默认行为) */
  349. static void hmi_send_now(const char *data, rt_uint16_t len)
  350. {
  351. rt_bool_t locked = hmi_write_lock();
  352. hmi_write_all(data, len); /* 完整写入: TX 缓冲满时等待重试, 不丢数据 */
  353. if (locked)
  354. {
  355. hmi_write_unlock();
  356. }
  357. }
  358. void HMI_WRITE(char *fmt, ...)
  359. {
  360. va_list ap;
  361. char str[256 + 3]; /* 预留 3 字节结束符 0xFF 0xFF 0xFF */
  362. rt_size_t str_length;
  363. /* OTA 期间串口4已关闭(见 control.c 的 uart_stop_for_ota)必须最先返回:
  364. 不能只靠 serial 判空——rt_device_close 释放的是 serial_v2 内部 fifo,
  365. 设备指针本身仍非空, 继续写会解引用已释放的 tx_fifo 而 HardFault。 */
  366. if (g_hmi_port_closed || serial == RT_NULL || fmt == NULL) {
  367. return;
  368. }
  369. /* 升级传输期间屏蔽普通业务指令 */
  370. if (hmi_upgrade_busy()) {
  371. return;
  372. }
  373. va_start(ap, fmt);
  374. str_length = rt_vsnprintf(str, sizeof(str) - 3, fmt, ap);
  375. va_end(ap);
  376. if (str_length == 0 || str_length >= sizeof(str) - 3) {
  377. if (str_length > 0)
  378. {
  379. LOG_W("HMI_WRITE: frame too long(%d), dropped", (int)str_length);
  380. }
  381. return;
  382. }
  383. #if HMI_DEDUPE_EN
  384. /* ② 同一调用点内容未变化则不重发 */
  385. if (hmi_dedupe_skip(fmt, str, (rt_uint16_t)str_length))
  386. {
  387. return;
  388. }
  389. #endif
  390. /* 结束符与指令合并为一次写入, 减少写入次数、避免发送被拆散 */
  391. str[str_length] = (char)0xFF;
  392. str[str_length + 1] = (char)0xFF;
  393. str[str_length + 2] = (char)0xFF;
  394. if (hmi_batch_owned())
  395. {
  396. rt_uint16_t need = (rt_uint16_t)(str_length + 3);
  397. if ((rt_uint32_t)hmi_batch_len + need > sizeof(hmi_batch_buf))
  398. {
  399. Hmi_Batch_End(); /* 缓冲不足先落地一批 */
  400. Hmi_Batch_Begin(); /* 继续留在批量会话内(重新取回属主) */
  401. }
  402. if ((rt_uint32_t)hmi_batch_len + need <= sizeof(hmi_batch_buf))
  403. {
  404. rt_memcpy(hmi_batch_buf + hmi_batch_len, str, need);
  405. hmi_batch_len += need;
  406. }
  407. else
  408. {
  409. /* 单条本身就超过批量缓冲(异常情况): 直接发, 宁可多一次写也不丢指令 */
  410. hmi_send_now(str, need);
  411. }
  412. return;
  413. }
  414. hmi_send_now(str, (rt_uint16_t)(str_length + 3));
  415. }
  416. /* 接收数据回调函数 */
  417. static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
  418. {
  419. struct rx_msg msg;
  420. rt_err_t result;
  421. msg.dev = dev;
  422. msg.size = size;
  423. result = rt_mq_send(&rx_mq, &msg, sizeof(msg));
  424. if ( result == -RT_EFULL)
  425. {
  426. /* 消息队列满 */
  427. LOG_E("hmi message queue full!\n");
  428. rt_mq_control(&rx_mq, RT_IPC_CMD_RESET, RT_NULL); // 清空队列
  429. }
  430. return result;
  431. }
  432. // 预计算转换表
  433. static const int8_t hex_to_byte[256] = {
  434. [0 ... 255] = -1,
  435. ['0'] = 0, ['1'] = 1, ['2'] = 2, ['3'] = 3, ['4'] = 4,
  436. ['5'] = 5, ['6'] = 6, ['7'] = 7, ['8'] = 8, ['9'] = 9,
  437. ['A'] = 10, ['B'] = 11, ['C'] = 12, ['D'] = 13, ['E'] = 14, ['F'] = 15,
  438. ['a'] = 10, ['b'] = 11, ['c'] = 12, ['d'] = 13, ['e'] = 14, ['f'] = 15
  439. };
  440. /**
  441. * @brief 快速HEX字符串转二进制
  442. * @param hex HEX字符串
  443. * @param bin 输出缓冲区
  444. * @param max_len 最大输出长度
  445. * @return 转换的字节数,<0表示错误
  446. */
  447. static inline int fast_hex_to_bin(const char* hex, uint8_t* bin, int max_len)
  448. {
  449. if (!hex || !bin || max_len <= 0) {
  450. return -1;
  451. }
  452. int hex_len = strlen(hex);
  453. if (hex_len % 2 != 0) {
  454. return -1; // HEX长度必须是偶数
  455. }
  456. int bin_len = hex_len / 2;
  457. if (bin_len > max_len) {
  458. return -1; // 输出缓冲区太小
  459. }
  460. for (int i = 0; i < bin_len; i++) {
  461. int high = hex_to_byte[(unsigned char)hex[i * 2]];
  462. int low = hex_to_byte[(unsigned char)hex[i * 2 + 1]];
  463. if (high < 0 || low < 0) {
  464. return -1; // 无效HEX字符
  465. }
  466. bin[i] = (high << 4) | low;
  467. }
  468. return bin_len;
  469. }
  470. // 发送原始数据到HMI
  471. static int send_raw_to_hmi(const uint8_t* data, uint32_t size)
  472. {
  473. if (g_hmi_port_closed || !serial || !data || size == 0) return -1;
  474. /* 4KB 块远大于 1024B TX 环形缓冲:必须完整写入(等待重试),
  475. 原实现单次写只进 1KB、返回 -1,升级数据静默丢失 3/4 */
  476. return (hmi_write_all(data, (rt_uint16_t)size) == (rt_uint16_t)size) ? 0 : -1;
  477. }
  478. // 最简洁版本 - 每4096字节直接清空
  479. void process_hex_payload(const char* hex_str, int req_id) {
  480. if (!hex_str) return;
  481. if (current_state != STATE_RECEIVING)
  482. {
  483. /* 新一轮屏幕升级开始: 复位重复过滤表, 升级结束后屏幕控件恢复全量刷新 */
  484. hmi_dedupe_reset();
  485. /* ★ 原来只复位去重表: 第二轮升级时 bytes_received 仍是上一轮的值,
  486. 首包就满足 >= total_file_size -> 立刻判"升级完成"并退出 HMI 线程。 */
  487. bytes_received = 0;
  488. recv_write_pos = 0;
  489. }
  490. /* 升级传输期间屏蔽普通刷新指令(见 HMI_WRITE 升级闸门) */
  491. Hmi_Upgrade_Begin();
  492. current_state = STATE_RECEIVING;
  493. // 转换HEX
  494. uint8_t temp[JSON_CHUNK_SIZE];
  495. int data_len = fast_hex_to_bin(hex_str, temp, JSON_CHUNK_SIZE);
  496. if (data_len <= 0) return;
  497. // 添加到缓冲区
  498. if (recv_write_pos + data_len > sizeof(recv_buffer)) {
  499. LOG_E("缓冲区溢出");
  500. return;
  501. }
  502. memcpy(recv_buffer + recv_write_pos, temp, data_len);
  503. recv_write_pos += data_len;
  504. bytes_received += data_len;
  505. LOG_I("收到 %d 字节,缓冲: %u/%u",
  506. data_len, recv_write_pos, sizeof(recv_buffer));
  507. // 每4096字节发送一次
  508. if (recv_write_pos >= 4096) {
  509. LOG_I("发送 4096 字节到HMI...");
  510. if (send_raw_to_hmi(recv_buffer, 4096) != 0) {
  511. LOG_E("发送失败");
  512. return;
  513. }
  514. LOG_I("发送成功");
  515. /* ★ 原来发送后直接 recv_write_pos = 0: 本块解码长度不是 512 整数倍时,
  516. 超出的尾部(最多 511 字节)被整块丢掉 -> 屏幕收到的固件流缺字节。
  517. 发完 4096 字节后把剩余字节前移保留。 */
  518. if (recv_write_pos > 4096) {
  519. memmove(recv_buffer, recv_buffer + 4096, recv_write_pos - 4096);
  520. recv_write_pos -= 4096;
  521. } else {
  522. recv_write_pos = 0;
  523. }
  524. /* 不再 return: 文件长度正好是 4096 整数倍时, 最后一包之后不会再有新数据,
  525. 原来在这里返回会让升级永远停在 RECEIVING。继续走下面的完成判断。 */
  526. }
  527. // 检查完成
  528. if (bytes_received >= total_file_size && total_file_size > 0) {
  529. if (recv_write_pos > 0) {
  530. LOG_I("发送最后 %u 字节", recv_write_pos);
  531. send_raw_to_hmi(recv_buffer, recv_write_pos);
  532. recv_write_pos = 0; // 清空
  533. }
  534. current_state = STATE_COMPLETED;
  535. Hmi_Upgrade_End();
  536. LOG_I("升级完成!");
  537. return;
  538. }
  539. // 发送进度
  540. int progress = total_file_size > 0 ?
  541. (bytes_received * 100 / total_file_size) : 0;
  542. char progress_json[256];
  543. rt_snprintf(progress_json, sizeof(progress_json),
  544. "{\"jsonrpc\":\"2.0\",\"method\":\"upgradehmi\","
  545. "\"params\":{\"received\":%u,\"total\":%u,\"progress\":%d},\"id\":%d}",
  546. bytes_received, total_file_size, progress, req_id);
  547. /* ★ progress_json 是栈上数组(不能交给 dtu_write_json 释放), 但要加 "%s" 防止被当格式串 */
  548. DTU_Write("%s", progress_json);
  549. }
  550. /* ==================== UART4(屏幕)接收:帧组装 ====================
  551. * 屏幕每条指令以 "\r\n" 结尾, 而串口按 DMA 包分段:
  552. * ① 一条指令可能被拆到两次 read —— 旧实现靠 strstr 前缀匹配, 残段会误命中别的
  553. * 分支(2026-10-08 的 SwversionV4/V43 误切版本类型即此问题, 见 hmi_cmd_match);
  554. * ② 一次 read 可能含多条指令 —— 旧实现是 if/else 链, 只处理第一条匹配的分支,
  555. * 例如 "getFullData\r\n" 与 "putTest.switchHeat=1\r\n" 同包时, 按键会被丢掉。
  556. * 现在: 整包先喂入组装缓冲, 按 '\n' 切出完整帧逐条交给 HMI_Decode(帧内容保留
  557. * "\r\n", 与旧行为一致); 残段留待下次 read 拼接; 超长无结束符的帧丢弃并告警。 */
  558. #define HMI_FRAME_MAX 512
  559. static char hmi_frame[HMI_FRAME_MAX + 1];
  560. static rt_uint16_t hmi_frame_len = 0;
  561. /* 处理一帧完整指令; 返回 RT_TRUE 表示 HMI 线程应退出(屏幕升级完成) */
  562. static rt_bool_t Hmi_Frame_Handle(void)
  563. {
  564. rt_uint16_t copy_len;
  565. if (hmi_frame_len == 0)
  566. {
  567. return RT_FALSE;
  568. }
  569. hmi_frame[hmi_frame_len] = '\0';
  570. /* 屏幕升级应答: 单字节 0x05 */
  571. if (hmi_frame_len == 1 && (rt_uint8_t)hmi_frame[0] == HMI_ACK_BYTE)
  572. {
  573. LOG_W("屏幕响应信号!");
  574. hmi_frame_len = 0;
  575. if (current_state == STATE_COMPLETED)
  576. {
  577. Hmi_Upgrade_End();
  578. return RT_TRUE; /* 升级完成, Hmi_thread_entry 收到后退出线程 */
  579. }
  580. /* RTU 可以发送升级文件了 */
  581. dtu_write_json(makeJsonRpc2_0("upgradehmi",NULL,1));
  582. return RT_FALSE;
  583. }
  584. /* 交给解析入口(rx_buffer 为解析缓冲, HMI_Decode 内部会清空它) */
  585. copy_len = (hmi_frame_len < HMI_UART_RXBUFFER_SIZE) ? hmi_frame_len : HMI_UART_RXBUFFER_SIZE;
  586. rt_memcpy(rx_buffer, hmi_frame, copy_len);
  587. rx_buffer[copy_len] = '\0';
  588. hmi_frame_len = 0;
  589. HMI_Decode();
  590. return RT_FALSE;
  591. }
  592. /* 喂入串口收到的原始数据; 返回 RT_TRUE 表示升级完成、HMI 线程应退出 */
  593. static rt_bool_t Hmi_Rx_Feed(const char *data, rt_uint16_t len)
  594. {
  595. rt_uint16_t i;
  596. for (i = 0; i < len; i++)
  597. {
  598. char c = data[i];
  599. /* 升级应答 0x05: 单字节, 不参与帧组装 */
  600. if (hmi_frame_len == 0 && (rt_uint8_t)c == HMI_ACK_BYTE)
  601. {
  602. hmi_frame[0] = c;
  603. hmi_frame_len = 1;
  604. if (Hmi_Frame_Handle())
  605. {
  606. return RT_TRUE;
  607. }
  608. continue;
  609. }
  610. if (hmi_frame_len >= HMI_FRAME_MAX)
  611. {
  612. LOG_W("hmi frame too long(%d), drop!", hmi_frame_len);
  613. hmi_frame_len = 0;
  614. }
  615. hmi_frame[hmi_frame_len++] = c;
  616. if (c == '\n')
  617. {
  618. if (Hmi_Frame_Handle())
  619. {
  620. return RT_TRUE;
  621. }
  622. }
  623. }
  624. return RT_FALSE;
  625. }
  626. /*入口函数*/
  627. static void Hmi_thread_entry(void *parameter)
  628. {
  629. struct rx_msg msg;
  630. rt_err_t result;
  631. rt_uint32_t rx_length;
  632. if(device_status.dtype==3){
  633. device_status.collt_box_sta = 0;
  634. device_status.run_sta = 0;
  635. }
  636. device_status.upan_sta = 1;
  637. device_status.camsta = 1;
  638. while(1)
  639. {
  640. rt_memset(&msg, 0, sizeof(msg));
  641. /* 从消息队列中读取消息*/
  642. result = rt_mq_recv(&rx_mq, &msg, sizeof(msg), 50);
  643. if (result == RT_EOK)
  644. {
  645. /* 读到本次 DMA 收到的原始数据(rx_pkt), 按帧组装后再解析 */
  646. rx_length = rt_device_read(msg.dev, 0, rx_pkt, HMI_UART_RXBUFFER_SIZE);
  647. if (rx_length > 0)
  648. {
  649. system_status.uart4_rx_bytes += rx_length;
  650. rx_pkt[rx_length] = '\0';
  651. /* 屏幕每帧原始数据打印: 保持 LOG_I 可见级(2.48 行为)。
  652. * master 减噪版曾降为 LOG_D —— 控制台调屏/排查依赖本行直接可见, 勿降级 */
  653. LOG_I("hmi rx(%u): %s", (unsigned)rx_length, rx_pkt);
  654. if (Hmi_Rx_Feed(rx_pkt, (rt_uint16_t)rx_length))
  655. {
  656. return; /* 屏幕升级完成, 线程退出 */
  657. }
  658. }
  659. }
  660. /*********************************************************************************************************************/
  661. //rt_kprintf("%04d-%02d-%02d %02d:%02d:%02d\n",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
  662. //rt_kprintf("workSta.vbat.txt=%c%d.%02d%c\n",hmi_str,voltage/100,voltage%100,hmi_str);
  663. }
  664. }
  665. /*******************************************************************************************/
  666. void Start_timer_Uart2(void)
  667. {
  668. device_status.mock_uart2_timer_flag = 1;
  669. }
  670. void Stop_timer_Uart2(void)
  671. {
  672. device_status.mock_uart2_timer_flag = 0;
  673. }
  674. static void refresh_hmi_Component(struct tm tm)
  675. {
  676. if(device_status.refresh_num>=5)
  677. {
  678. device_status.refresh_num = 0;
  679. /* ★ 开机联网检测线程(net_wait)还没退出时, 它自己每秒都在发 read 刷状态:
  680. 这里再发就是重复上报。等它退出(联网成功/超时)后由本函数接管刷新。
  681. 顺带补上 makeJson_ReadInfo() 的空指针判断(原实现会把 NULL 送进 DTU_Write)。 */
  682. if (net_wait_running == 1)
  683. {
  684. char *readinfo = makeJson_ReadInfo();
  685. if (readinfo != RT_NULL)
  686. {
  687. DTU_Write("%s", readinfo);
  688. rt_free(readinfo);
  689. }
  690. }
  691. device_status.hmi_fresh = 1;
  692. rt_thread_delay(100);
  693. }
  694. //在解析getinfo中清除超时0
  695. if(device_status.refresh_timeout==15)
  696. {
  697. rt_sprintf(device_status.sim,"1");
  698. rt_sprintf(device_status.net,"1");
  699. rt_sprintf(device_status.csq,"0");
  700. device_status.camsta = 1;
  701. device_status.link_sta=0;
  702. device_status.refresh_timeout=0;
  703. HMI_WRITE("menu.warn.txt=\"%s\"","[RTU/4G模块]通信失败,检查连接/固件!");
  704. }
  705. device_status.refresh_num++;
  706. device_status.refresh_timeout++;
  707. if(device_status.version_type!=6)
  708. {
  709. HMI_WRITE("uploadSet.iccid.txt=\"%s\"",device_status.iccid);
  710. if(strstr(device_status.mqttcfg1,"8.136.98.49")!=NULL)
  711. {
  712. HMI_WRITE("uploadSet.plt.val=%d",RESET);
  713. }
  714. else if (strstr(device_status.mqttcfg1,"120.27.222.26")!=NULL) {
  715. HMI_WRITE("uploadSet.plt.val=%d",SET);
  716. }
  717. //HMI_WRITE("mqttcfg.mqtt1Message.txt=\"%s\"",device_status.mqttcfg1);
  718. HMI_WRITE("uploadSet.t0.txt=\"%s\"",device_status.mqttcfg1);
  719. //更新固件版本号
  720. HMI_WRITE("debug.t3.txt=\"%s\"",device_status.driver);
  721. //更新固件编译日期
  722. HMI_WRITE("debug.t4.txt=\"%s\"",device_status.driver_compile);
  723. //
  724. HMI_WRITE("debug.t5.txt=\"%s\"",device_status.driver_bl);
  725. HMI_WRITE("debug.t7.txt=\"%s\"",device_status.driver_compile);
  726. //更新dtu/rtu版本
  727. HMI_WRITE("debug.t9.txt=\"%s\"",device_status.driver_4g);
  728. //更新时间
  729. HMI_WRITE("menu.rtc.txt=\"%04d-%02d-%02d %02d:%02d:%02d\"",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
  730. HMI_WRITE("workSta.rtc.txt=\"%04d-%02d-%02d %02d:%02d:%02d\"",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
  731. HMI_WRITE("set.t0.txt=\"%d\"",tm.tm_hour);
  732. HMI_WRITE("set.t1.txt=\"%d\"",tm.tm_min);
  733. HMI_WRITE("set.t2.txt=\"%d\"",tm.tm_sec);
  734. //更新电压
  735. HMI_WRITE("workSta.vbat.txt=\"%s\"",device_status.voltage);
  736. //更新电流
  737. HMI_WRITE("workSta.power.txt=\"%s\"",device_status.power);
  738. //更新温湿度数据
  739. HMI_WRITE("workSta.envHum.val=%d",atoi(device_status.humidity));
  740. HMI_WRITE("workSta.envTem.val=%d",atoi(device_status.tempture));
  741. //更新电池状态
  742. HMI_WRITE("workSta.batStatus.val=%d",device_status.bat_status);
  743. //更新上仓门状态
  744. HMI_WRITE("workSta.upStatus.val=%d",device_status.up_status);
  745. //更新下仓门状态
  746. HMI_WRITE("workSta.downStatus.val=%d",device_status.down_status);
  747. //更新工作状态
  748. HMI_WRITE("workSta.workStatus.val=%d",device_status.work_status);
  749. //更新温控状态
  750. HMI_WRITE("workSta.tempStatus.val=%d",device_status.temp_status);
  751. //更新雨控状态
  752. HMI_WRITE("workSta.rainStatus.val=%d",device_status.rain_status);
  753. //更新光控状态
  754. HMI_WRITE("workSta.sunStatus.val=%d",device_status.sun_status);
  755. //更新收集时间
  756. HMI_WRITE("sysSet.stime.val=%d",device_status.clt_time);
  757. //更新加热时间
  758. HMI_WRITE("workSta.heatTime.val=%d",device_status.heattime);
  759. HMI_WRITE("sysSet.jtime.val=%d",device_status.heattime);
  760. //
  761. HMI_WRITE("sysSet.vol.val=%d",device_status.vol);
  762. //更新加热时间和温度
  763. HMI_WRITE("workSta.heatTem.val=%d",device_status.heattem);
  764. HMI_WRITE("sysSet.jheat.val=%d",device_status.heatvalue);
  765. //更新加热状态
  766. HMI_WRITE("workSta.heatStatus.val=%d",device_status.heat_status);
  767. //更新密码
  768. HMI_WRITE("inputPasswd.pwdData.txt=\"8888\"");
  769. //更新工作进度
  770. //HMI_WRITE("menu.workProgress.val=%d",);
  771. //更新定时模式
  772. HMI_WRITE("clockSet.timeSwitch.val=%d",device_status.timeSwitch);
  773. //更新光控定时时长
  774. HMI_WRITE("clockSet.sunBar.val=%d",device_status.sunBar);
  775. //更新时控开始
  776. HMI_WRITE("clockSet.startBar.val=%d",device_status.startBar);
  777. //更新时控结束
  778. HMI_WRITE("clockSet.stopBar.val=%d",device_status.stopBar);
  779. //SIM卡状态
  780. HMI_WRITE("workSta.bt0.val=%d",atoi(device_status.sim));
  781. //ID
  782. HMI_WRITE("menu.equipid.txt=\"%s\"",device_status.imei);
  783. HMI_WRITE("menu.deviceId.txt=\"%s\"",device_status.deviceId);
  784. //HMI_WRITE("workSta.equipid.txt=\"%s\"",device_status.imei);
  785. //数据上传间隔
  786. HMI_WRITE("uploadSet.datt.val=%d",device_status.dattim);
  787. //语音音量
  788. HMI_WRITE("sysSet.vol.val=%d",device_status.vol);
  789. //更新熄屏时间
  790. if(device_status.thsp<60) device_status.thsp = device_status.thsp * 60;
  791. HMI_WRITE("thsp=%d",device_status.thsp);
  792. if(strstr(device_status.link_ip,".")!=RT_NULL){
  793. HMI_WRITE("menu.t0.txt=\"%s\"",device_status.link_ip);
  794. }
  795. #if MATCH_DEVICE == 1
  796. HMI_WRITE("menu.mode.val=%d",device_status.work_mode);
  797. HMI_WRITE("menu.upan.val=%d",device_status.upan_sta);
  798. HMI_WRITE("menu.alarm_tg.txt=\"%s\"",device_status.alarm_tg);
  799. //更新有线连接状态
  800. HMI_WRITE("menu.va_net.val=%d",0);
  801. #else
  802. HMI_WRITE("menu.va_net.val=%d",device_status.link_sta);
  803. #endif
  804. }
  805. HMI_WRITE("menu.cam_sta.val=%d",device_status.camsta);
  806. HMI_WRITE("menu.version.txt=\"%s\"",device_status.driver);
  807. if(atoi(device_status.gps)==1){
  808. HMI_WRITE("menu.gps_state.txt=\"定位成功:(GPS+BD)%d/%d\"",device_status.gps_inuse,device_status.gps_view);
  809. }else if(atoi(device_status.gps)==2){
  810. HMI_WRITE("menu.gps_state.txt=\"定位成功:(基站)\"");
  811. }
  812. //更新联网状态
  813. if(atoi(device_status.net)==1)
  814. {
  815. HMI_WRITE("menu.net.val=1");
  816. HMI_WRITE("workSta.net.val=1");
  817. }
  818. else {
  819. #if MATCH_DEVICE == 0
  820. HMI_WRITE("workSta.net.val=0");
  821. HMI_WRITE("menu.net.val=0");
  822. //更新CSQ
  823. HMI_WRITE("menu.csq_value.txt=\"%s\"",device_status.csq);
  824. HMI_WRITE("menu.va_csq.val=%d",atoi(device_status.csq));
  825. HMI_WRITE("workSta.csq_value.txt=\"%s\"",device_status.csq);
  826. #else
  827. HMI_WRITE("workSta.net.val=1");
  828. HMI_WRITE("menu.net.val=1");
  829. HMI_WRITE("menu.va_csq.val=0");
  830. #endif
  831. }
  832. if(atoi(device_status.csq)==0&&atoi(device_status.net)==1)
  833. {
  834. HMI_WRITE("menu.net.val=1");
  835. HMI_WRITE("workSta.net.val=2");
  836. }
  837. /**********************************************************************/
  838. }
  839. /***************************** 解析从屏幕收到的数据 begin **********************************/
  840. /* ==================== 屏幕测试加热:定时自动关闭 ====================
  841. * 需求:屏幕测试页打开加热(putTest.switchHeat=1)后,10 分钟自动关闭,避免忘记关导致干烧。
  842. * 实现:一次性软定时器;只在"本次加热由屏幕测试打开"时生效——手动关闭(switchHeat=0)
  843. * 或定时到点都会撤销;若定时到点时设备正处于工作流程中(work_status==1),
  844. * 加热由工作循环(calorstat)托管,则本定时器不干预,仅撤销自己。
  845. * 维护提示:如需改自动关闭时长,只改 HMI_TEST_HEAT_TIMEOUT 一处。 */
  846. #define HMI_TEST_HEAT_TIMEOUT (10 * 60) /* 秒 */
  847. static rt_timer_t s_test_heat_timer = RT_NULL;
  848. static volatile rt_bool_t s_test_heat_on = RT_FALSE;
  849. static void hmi_test_heat_timeout(void *parameter)
  850. {
  851. if (!s_test_heat_on)
  852. {
  853. return;
  854. }
  855. s_test_heat_on = RT_FALSE;
  856. if (device_status.work_status == 1)
  857. {
  858. LOG_I("test heat timeout ignored (work in progress)");
  859. return;
  860. }
  861. ctr_Heat(OFF);
  862. device_status.heat_status = 0;
  863. HMI_WRITE("sysTest.switchHeat.val=0");
  864. HMI_WRITE("workSta.heatStatus.val=0");
  865. LOG_W("屏幕测试加热已自动关闭(超时 %d 秒)", HMI_TEST_HEAT_TIMEOUT);
  866. }
  867. static void hmi_test_heat_start(void)
  868. {
  869. if (s_test_heat_timer == RT_NULL)
  870. {
  871. s_test_heat_timer = rt_timer_create("t_testheat", hmi_test_heat_timeout, RT_NULL,
  872. HMI_TEST_HEAT_TIMEOUT * RT_TICK_PER_SECOND,
  873. RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER);
  874. if (s_test_heat_timer == RT_NULL)
  875. {
  876. LOG_E("rt_timer_create t_testheat failed!");
  877. return;
  878. }
  879. }
  880. s_test_heat_on = RT_TRUE;
  881. rt_timer_stop(s_test_heat_timer);
  882. rt_timer_start(s_test_heat_timer); /* 每次打开都重新计时 */
  883. }
  884. static void hmi_test_heat_stop(void)
  885. {
  886. s_test_heat_on = RT_FALSE;
  887. if (s_test_heat_timer != RT_NULL)
  888. {
  889. rt_timer_stop(s_test_heat_timer);
  890. }
  891. }
  892. /* ==================== workSta 工作过程刷新(屏幕 t1~t6 + 拍照/清扫状态) ====================
  893. * 数据来源:control.c 各控制流程实时写入 device_status.work_*、photo_left、clear_left;
  894. * hmi.c Ctr_Mortor_entry 写入 work_door_left / photo_left;progress 由
  895. * Work_Progress_Get() 按时间加权计算。
  896. * 下发条件:HMI_WORK_PROC_VT(vt) 当前为 (vt)!=6 —— 除吸虫塔外的页面都下发,
  897. * 孢子仪(dtype!=3)在前一行条件已被挡掉。 */
  898. #define HMI_WORK_PROC_VT(vt) ((vt) != 6) /* 需要显示工作过程的版本类型 */
  899. /* t1~t6 数值朗读:为 0 时下发空字符串(屏幕该栏显示空白),非 0 下发数值;
  900. * percent=RT_TRUE 时数值后带 % 号(t4 进度显示形如 "45%")。
  901. * 实现要点:每个控件只保留**一个** HMI_WRITE 调用点(数值先格式化成字符串、统一走 %s)。
  902. * 因为 HMI_WRITE 的重复过滤按调用点记录"上次内容"——只有单调用点时,
  903. * "上次内容"才恒等于"屏幕当前显示"。若拆成 空串/数值 两个调用点,两个缓存互相独立:
  904. * 从"有值(如 1)"切回 0 时会命中空串调用点的旧缓存而被跳过,屏幕会残留上一个数字
  905. * (要等到过滤表 10s 周期复位才纠正)。 */
  906. static void hmi_write_num_or_blank(char *fmt, uint16_t v, rt_bool_t percent)
  907. {
  908. char num[8];
  909. if (v == 0)
  910. {
  911. num[0] = '\0'; /* 0 → 空串,屏幕显示空白 */
  912. }
  913. else if (percent)
  914. {
  915. rt_snprintf(num, sizeof(num), "%u%%", v);
  916. }
  917. else
  918. {
  919. rt_snprintf(num, sizeof(num), "%u", v);
  920. }
  921. HMI_WRITE(fmt, num);
  922. }
  923. static void hmi_refresh_work_proc(void)
  924. {
  925. if(device_status.dtype != 3)
  926. {
  927. return;
  928. }
  929. /* 拍照状态:device_status.photo_ws(0-停止 1-拍照中) */
  930. HMI_WRITE("workSta.photoSta.val=%d", (device_status.photo_ws != 0) ? 1 : 0);
  931. /* 清扫状态:device_status.clear_status(0-停止 1-清扫中,2-转仓动作) */
  932. HMI_WRITE("workSta.clearSta.val=%d", (device_status.clear_status != 0) ? 1 : 0);
  933. /* t1~t6:工作过程实时数据(文本控件;数值为 0 时下发空串,该栏显示空白) */
  934. hmi_write_num_or_blank("workSta.t1.txt=\"%s\"", device_status.work_heat_left, RT_FALSE); /* 剩余加热时间(s) */
  935. hmi_write_num_or_blank("workSta.t2.txt=\"%s\"", device_status.work_clt_left, RT_FALSE); /* 收集倒计时(s) */
  936. hmi_write_num_or_blank("workSta.t3.txt=\"%s\"", device_status.work_door_left, RT_FALSE); /* 仓门开/关倒计时(s) */
  937. hmi_write_num_or_blank("workSta.t4.txt=\"%s\"", Work_Progress_Get(), RT_TRUE); /* 工作进度(%) */
  938. hmi_write_num_or_blank("workSta.t5.txt=\"%s\"", device_status.photo_left, RT_FALSE); /* 拍照结束剩余(s) */
  939. hmi_write_num_or_blank("workSta.t6.txt=\"%s\"", device_status.clear_left, RT_FALSE); /* 清扫结束剩余(s) */
  940. }
  941. /* ==================== 屏幕命令严格匹配(2026-10-08 修复) ====================
  942. * 屏幕命令以 \r 结尾, 但串口按包分段: 一条 "SwversionV43" 可能被拆成
  943. * "SwversionV4" + "3" 两段先后到达。原实现用 strstr() 前缀包含匹配,
  944. * 前段 "SwversionV4" 会误命中"水稻"分支, 把 version_type 错误切换(并误报 RTU、
  945. * 重复写 Flash、随后完整帧又切回, 配置来回翻转)。
  946. * 本函数要求: 命令字完整相等, 且其后紧跟 \r(完整帧结束符, 兼容 \r\n);
  947. * 分包残段没有 \r, 会被拒绝, 等屏幕后续完整帧(心跳重发)正常处理。
  948. * 用法: 替换存在"短命令是长命令前缀"关系的分支(SwversionV1/V4)。 */
  949. static rt_bool_t hmi_cmd_match(const char *buf, const char *cmd)
  950. {
  951. size_t n = rt_strlen(cmd);
  952. if (rt_strncmp(buf, cmd, n) != 0)
  953. {
  954. return RT_FALSE;
  955. }
  956. return (buf[n] == '\r') ? RT_TRUE : RT_FALSE;
  957. }
  958. /* ==================== 屏幕 debug1 调试页(2026-10-13 新增) ====================
  959. * 对应陶晶驰(USART HMI)工程中的调试页 debug1,功能与协议如下:
  960. * ① 信息区(t0 RT-Thread版本 / t1 内核 / t2 BSP型号 / t13 运行时长 / t5 BL版本 /
  961. * t3 固件版本 / t4 编译时间 / t11+j0 CPU占用 / t12+j1 RAM占用 / t10 外挂Flash):
  962. * 屏幕侧在该页定时器(或进入页面)下发 "getDebugData",固件整批刷新(HMI_WRITE 带重复过滤,
  963. * 未变化的项不会重复占用串口带宽);
  964. * ② 按钮区 b0~b9(屏幕弹起事件下发文本命令,以 "\r\n" 结束):
  965. * reboot 重启(沿用既有分支 rt_hw_cpu_reset)
  966. * bootloader 启动BL:置 stop_in_bootloader 并重启进入 BootLoader(沿用既有分支)
  967. * startapp 启动APP:清除 stop_in_bootloader 并重启(下次直接启动 APP)
  968. * dbg_on 打开调试:把 RT-Thread 控制台输出镜像到 debug1 底部文本框
  969. * dbg_off 关闭调试:恢复原控制台设备
  970. * dbg_clr 清空固件侧控制台缓存与屏幕文本框
  971. * dbg_erase 擦除参数:恢复出厂默认参数(按供电类型走交流/电池两套默认值)
  972. * dbg_restore 恢复固件:置 restore_pending + stop_in_bootloader 并重启进 BL,
  973. * 由 BL 执行 df_area→app 恢复(BL 侧支持见交付说明;未支持时不会误动作)
  974. * dbg:<命令> 把 <命令> 作为 msh 命令在本机执行,输出回传文本框(b4 发送按钮)
  975. * ③ 调试控制台实现:注册只写"捕获设备" dbgcap,打开调试时 rt_console_set_device("dbgcap"),
  976. * 此后 rt_kprintf / finsh / msh 的输出全部经其 write 回调缓存并推送屏幕文本框
  977. * (换行按 TJC 官方约定用 "\r" 两字符转义下发,不能用 \n);同时经"转发设备"
  978. * DBG1_CHAIN_DEV(默认 uart1) 原样转发,保证本机调试口日志不停流。命令执行放在
  979. * 独立线程 dbg_exec_thread,避免 top 之类的长命令把屏幕刷新线程卡死。
  980. * 注意:转发设备只 find 句柄、不自行 open/close。(本工程 apm32f1 用 serial_v2:
  981. * open 已打开设备直接返回、标志位只增不覆盖,不存在 v1 的接收位被洗问题,
  982. * 故未移植 dbg_chain_fixup / hmi_uart4_fixup_rx)
  983. * ④ 屏幕文本框收发约定("单框收发"设计,与截图的底部 msh>> 框一致):
  984. * - 固件每次下发的内容尾部都会附加一行提示符 "msh >> "(宏 DBG1_PROMPT);
  985. * - 用户点框→键盘输入→按[发送](b4);b4 弹起事件发送:printh 64 62 67 3A("dbg:")
  986. * + prints "debug1.<框名>.txt",0 + printh 0d 0a;
  987. * - 固件收到 "dbg:"+整个框内容后,取**最后一个 ">>" 之后**的文本作为命令执行
  988. * (无 ">>" 时按纯命令处理,兼容"独立输入框"的接法),执行结果回填框内。
  989. * ⑤ 推送节流与页面联动:输出推送带最小间隔节流;且仅在"该页有心跳"(最近
  990. * DBG1_PAGE_ALIVE_TICK 内收到过 getDebugData)时才推送——离开调试页后自动停推,
  991. * 返回调试页后自动恢复(缓存不丢,回页即见最新内容)。
  992. * 注意:打开调试期间本机 UART1 调试口日志经转发保留;控制台设备在"关闭调试"后恢复原样。
  993. * 维护提示:屏幕控件名若变化,仅需改 DBG1_CON_OBJ 宏及下方各 HMI_WRITE 中的控件名。 */
  994. #define DBG1_CON_OBJ "msh" /* 底部调试文本框对象名(改名只需改这一处) */
  995. #define DBG1_PROMPT "msh >> " /* 文本框尾部提示符(兼作命令提取锚点) */
  996. #define DBG1_CHAIN_DEV "uart1" /* 日志转发设备(本机调试口);置 "" 可关闭转发 */
  997. #define DBG1_CAP_DEV_NAME "dbgcap" /* 控制台捕获设备名(仅固件内部使用) */
  998. #define DBG1_CON_RAW_MAX 200 /* 行缓存上限(约文本框一屏可见字符数,可调) */
  999. #define DBG1_CON_ESC_MAX 220 /* 单次下发转义后上限(受 HMI_WRITE 内部 256B 缓冲限制) */
  1000. #define DBG1_CON_PUSH_MAX 120 /* 单次下发取缓存尾部长度(转义前)。受"b4 发送会回传整框"
  1001. * 约束:中文按 UTF-8 3B/字,120 字符最坏 360B,
  1002. * 加提示符与用户输入仍小于单帧上限 HMI_FRAME_MAX(512) */
  1003. #define DBG1_CMD_MAX 100 /* 屏幕控制台单条命令最大长度 */
  1004. #define DBG1_EXEC_PRIO 22 /* 调试命令执行线程优先级(低于屏幕线程) */
  1005. #define DBG1_EXEC_STACK_SIZE 3072 /* 调试命令执行线程栈 */
  1006. #define DBG1_FLUSH_MIN_TICK 30 /* 输出推送最小间隔(tick,10ms/tick;纯节流不丢行) */
  1007. #define DBG1_PAGE_ALIVE_TICK 500 /* 调试页心跳存活窗口(5s):超过则暂停推送,离开页面不再占带宽 */
  1008. #define DBG1_BSP_NAME "APM32F103RET6" /* t2 BSP型号显示(按实际板卡) */
  1009. #define DBG1_CORE_NAME "Cortex-M3" /* t1 内核显示(如需改成内核版本号改这里) */
  1010. #define DBG1_PART_OBJ "t14" /* 分区表文本框对象名(屏幕侧新增控件;改名只改这一处) */
  1011. #define DBG1_PART_MAX 200 /* 分区表下发字符串上限(单条 HMI_WRITE 上限约 250B,留余量) */
  1012. static char dbg_con_raw[DBG1_CON_RAW_MAX + 2]; /* 控制台行缓存(屏幕文本框内容源) */
  1013. static rt_uint16_t dbg_con_len = 0;
  1014. static rt_bool_t dbg_mirror_on = RT_FALSE; /* 控制台是否已镜像到屏幕(打开调试) */
  1015. static char dbg_saved_console[RT_NAME_MAX + 1]; /* 打开调试前的控制台设备名 */
  1016. static struct rt_device dbg_con_dev; /* 只写捕获设备(dbgcap) */
  1017. static rt_bool_t dbg_con_dev_ready = RT_FALSE;
  1018. static rt_device_t dbg_chain_dev = RT_NULL; /* 日志转发设备句柄(只 find,不持有引用;见 dbg_chain_fixup) */
  1019. static volatile rt_tick_t s_dbg1_page_tick = 0; /* 最近一次收到 getDebugData 的时刻(0=从未) */
  1020. static struct rt_thread dbg_exec_thread;
  1021. static rt_uint8_t dbg_exec_stack[DBG1_EXEC_STACK_SIZE];
  1022. static struct rt_semaphore dbg_exec_sem;
  1023. static char dbg_cmd_buf[DBG1_CMD_MAX + 1];
  1024. static volatile rt_uint8_t dbg_exec_busy = 0;
  1025. static rt_bool_t dbg_exec_inited = RT_FALSE;
  1026. static rt_bool_t dbg_exec_ready = RT_FALSE;
  1027. /* ---------- 控制台行缓存与屏幕推送 ---------- */
  1028. static void dbg_con_append(const char *s, rt_uint16_t n)
  1029. {
  1030. if (n == 0)
  1031. {
  1032. return;
  1033. }
  1034. /* 缓存满:丢弃最旧内容(优先从行边界截断),保留最新输出 */
  1035. if ((rt_uint32_t)dbg_con_len + n > DBG1_CON_RAW_MAX)
  1036. {
  1037. rt_uint16_t cut = (dbg_con_len > (DBG1_CON_RAW_MAX / 3)) ? (dbg_con_len - DBG1_CON_RAW_MAX / 3) : 0;
  1038. while (cut < dbg_con_len && dbg_con_raw[cut] != '\n')
  1039. {
  1040. cut++;
  1041. }
  1042. cut = (cut < dbg_con_len) ? (cut + 1) : dbg_con_len;
  1043. if (cut > 0)
  1044. {
  1045. rt_memmove(dbg_con_raw, dbg_con_raw + cut, dbg_con_len - cut);
  1046. dbg_con_len -= cut;
  1047. }
  1048. }
  1049. if (n > DBG1_CON_RAW_MAX - dbg_con_len) /* 单次超长:只保留尾部 */
  1050. {
  1051. s += (n - (DBG1_CON_RAW_MAX - dbg_con_len));
  1052. n = DBG1_CON_RAW_MAX - dbg_con_len;
  1053. }
  1054. rt_memcpy(dbg_con_raw + dbg_con_len, s, n);
  1055. dbg_con_len += n;
  1056. dbg_con_raw[dbg_con_len] = '\0';
  1057. }
  1058. static void dbg_con_puts(const char *s)
  1059. {
  1060. dbg_con_append(s, (rt_uint16_t)rt_strlen(s));
  1061. }
  1062. /* 把行缓存转义后推送到屏幕文本框。
  1063. * TJC 字符串转义(官方 wiki 约定):换行 -> "\r"(\ 和 r 两个字符,不要用 \n);双引号 -> \"。
  1064. * 下发内容 = [缓存尾部] + 换行 + 提示符 DBG1_PROMPT —— 提示符固定收尾,用户直接在框尾
  1065. * 输入命令后按[发送],固件即可按"最后一个 >> 之后"提取命令(见 dbg_exec_submit)。
  1066. * force=RT_FALSE 时按 DBG1_FLUSH_MIN_TICK 做最小间隔节流(只影响推送时机,不丢内容);
  1067. * 页面心跳消失(离开调试页)超过 DBG1_PAGE_ALIVE_TICK 时暂存不推,回页后自动恢复。 */
  1068. static void dbg_con_flush(rt_bool_t force)
  1069. {
  1070. static rt_tick_t s_last_flush = 0;
  1071. char esc[DBG1_CON_ESC_MAX + 1];
  1072. rt_uint16_t i, n = 0, raw_len = dbg_con_len;
  1073. const char *p = dbg_con_raw;
  1074. if (raw_len == 0 || rt_interrupt_get_nest() != 0) /* 中断上下文不推送,等下次 */
  1075. {
  1076. return;
  1077. }
  1078. /* 页面联动:从未收到心跳或心跳已停(离开调试页)时暂不推送 */
  1079. if (s_dbg1_page_tick == 0 ||
  1080. (rt_tick_get() - s_dbg1_page_tick) > DBG1_PAGE_ALIVE_TICK)
  1081. {
  1082. return;
  1083. }
  1084. if (force == RT_FALSE && (rt_tick_get() - s_last_flush) < DBG1_FLUSH_MIN_TICK)
  1085. {
  1086. return;
  1087. }
  1088. s_last_flush = rt_tick_get();
  1089. if (raw_len > DBG1_CON_PUSH_MAX) /* 超长只保留尾部(屏幕一屏可见有限) */
  1090. {
  1091. p += (raw_len - DBG1_CON_PUSH_MAX);
  1092. raw_len = DBG1_CON_PUSH_MAX;
  1093. }
  1094. for (i = 0; i < raw_len && n < DBG1_CON_ESC_MAX - 16; i++)
  1095. {
  1096. char c = p[i];
  1097. if (c == '\n')
  1098. {
  1099. if (n < DBG1_CON_ESC_MAX - 16) { esc[n++] = '\\'; esc[n++] = 'r'; }
  1100. }
  1101. else if (c == '"')
  1102. {
  1103. if (n < DBG1_CON_ESC_MAX - 16) { esc[n++] = '\\'; esc[n++] = '"'; }
  1104. }
  1105. else
  1106. {
  1107. esc[n++] = c;
  1108. }
  1109. }
  1110. if (n > 0 && esc[n - 1] == '\\') /* 截断落在转义符中间时丢弃半个转义 */
  1111. {
  1112. n--;
  1113. }
  1114. /* 追加换行 + 提示符(预留空间已在循环上限扣除) */
  1115. esc[n++] = '\\';
  1116. esc[n++] = 'r';
  1117. for (i = 0; DBG1_PROMPT[i] != '\0' && n < DBG1_CON_ESC_MAX; i++)
  1118. {
  1119. esc[n++] = DBG1_PROMPT[i];
  1120. }
  1121. esc[n] = '\0';
  1122. HMI_WRITE("debug1." DBG1_CON_OBJ ".txt=\"%s\"", esc);
  1123. }
  1124. /* ---------- 控制台捕获设备(只写,替代 uart1 作为 rt_console_set_device 目标) ---------- */
  1125. static rt_err_t dbg_con_dev_open(rt_device_t dev, rt_uint16_t oflag)
  1126. {
  1127. (void)dev; (void)oflag;
  1128. return RT_EOK;
  1129. }
  1130. static rt_err_t dbg_con_dev_close(rt_device_t dev)
  1131. {
  1132. (void)dev;
  1133. return RT_EOK;
  1134. }
  1135. static rt_size_t dbg_con_dev_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
  1136. {
  1137. (void)dev; (void)pos; (void)buffer; (void)size;
  1138. return 0;
  1139. }
  1140. /* 捕获 rt_kprintf/finsh/msh 的全部输出:① 转发到 DBG1_CHAIN_DEV(本机调试口,保持日志不停流);
  1141. * ② 过滤 ANSI 转义与编辑控制字符后按行入缓存,行尾或节流点推送屏幕(页面心跳存在时)。 */
  1142. static rt_size_t dbg_con_dev_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
  1143. {
  1144. static rt_uint8_t s_esc = 0; /* ANSI 转义过滤状态机:0-普通 1-已见ESC 2-ESC[ 序列 */
  1145. const char *p = (const char *)buffer;
  1146. rt_size_t i;
  1147. (void)dev; (void)pos;
  1148. /* ① 本机调试口转发(best effort:设备未打开则静默跳过) */
  1149. if (dbg_chain_dev != RT_NULL)
  1150. {
  1151. rt_device_write(dbg_chain_dev, 0, buffer, size);
  1152. }
  1153. for (i = 0; i < size; i++)
  1154. {
  1155. char c = p[i];
  1156. if (s_esc == 0)
  1157. {
  1158. if ((rt_uint8_t)c == 0x1B) { s_esc = 1; continue; }
  1159. }
  1160. else if (s_esc == 1)
  1161. {
  1162. s_esc = (c == '[') ? 2 : 0;
  1163. continue;
  1164. }
  1165. else
  1166. {
  1167. if ((rt_uint8_t)c >= 0x40 && (rt_uint8_t)c <= 0x7E) s_esc = 0;
  1168. continue;
  1169. }
  1170. if (c == '\n')
  1171. {
  1172. dbg_con_append("\n", 1);
  1173. if (dbg_mirror_on || dbg_exec_busy) dbg_con_flush(RT_FALSE);
  1174. }
  1175. else if (c == '\t')
  1176. {
  1177. dbg_con_append(" ", 1);
  1178. }
  1179. else if (c == '\r' || (rt_uint8_t)c < 0x20 || (rt_uint8_t)c == 0x7F)
  1180. {
  1181. /* \r 与其它控制字符(含 finsh 编辑用的 \b)不显示 */
  1182. }
  1183. else
  1184. {
  1185. dbg_con_append(&c, 1);
  1186. }
  1187. }
  1188. return size;
  1189. }
  1190. static void dbg_con_dev_init(void)
  1191. {
  1192. if (dbg_con_dev_ready)
  1193. {
  1194. return;
  1195. }
  1196. rt_memset(&dbg_con_dev, 0, sizeof(dbg_con_dev));
  1197. dbg_con_dev.type = RT_Device_Class_Char;
  1198. dbg_con_dev.rx_indicate = RT_NULL;
  1199. dbg_con_dev.tx_complete = RT_NULL;
  1200. dbg_con_dev.init = RT_NULL;
  1201. dbg_con_dev.open = dbg_con_dev_open;
  1202. dbg_con_dev.close = dbg_con_dev_close;
  1203. dbg_con_dev.read = dbg_con_dev_read;
  1204. dbg_con_dev.write = dbg_con_dev_write;
  1205. dbg_con_dev.control = RT_NULL;
  1206. if (rt_device_register(&dbg_con_dev, DBG1_CAP_DEV_NAME, RT_DEVICE_FLAG_STREAM) == RT_EOK)
  1207. {
  1208. dbg_con_dev_ready = RT_TRUE;
  1209. }
  1210. }
  1211. /* ---------- (apm32f1) 本机口/屏幕口"接收位保护":无需移植 ----------
  1212. * master(v1 serial) 的 dbg_chain_fixup()/hmi_uart4_fixup_rx() 用于修复
  1213. * "rt_serial_open 用 open_flag=oflag&0xff 覆盖标志位、洗掉 INT_RX/DMA_RX 导致
  1214. * 无法输入"的问题。本工程用 serial_v2 驱动:rt_serial_open 对已打开设备直接返回、
  1215. * 标志位一律 |= 不覆盖(serial_v2.c),不存在该缺陷,故整段未移植。 */
  1216. static void dbg_console_save(void)
  1217. {
  1218. rt_device_t cur = rt_console_get_device();
  1219. /* 已处于捕获设备(如执行线程临时切换期间被并发调用)时不覆盖记录,
  1220. * 否则"关闭调试"会恢复到 dbgcap 上,永远回不到真实控制台 */
  1221. if (cur != RT_NULL && rt_strcmp(cur->parent.name, DBG1_CAP_DEV_NAME) == 0)
  1222. {
  1223. return;
  1224. }
  1225. if (cur != RT_NULL) rt_strncpy(dbg_saved_console, cur->parent.name, RT_NAME_MAX);
  1226. else rt_strncpy(dbg_saved_console, "uart1", RT_NAME_MAX);
  1227. dbg_saved_console[RT_NAME_MAX] = '\0';
  1228. }
  1229. static void dbg_console_restore(void)
  1230. {
  1231. if (dbg_saved_console[0] != '\0') rt_console_set_device(dbg_saved_console);
  1232. else rt_console_set_device("uart1");
  1233. }
  1234. /* ---------- 屏幕控制台:命令执行(独立线程,防长命令卡死屏幕线程) ---------- */
  1235. static rt_bool_t dbg_cmd_is_blocking(const char *cmd)
  1236. {
  1237. while (*cmd == ' ' || *cmd == '\t')
  1238. {
  1239. cmd++;
  1240. }
  1241. /* top/Msh_DisplaySysMonitor 为持续刷新命令,在屏幕控制台里无法按键退出,直接拒绝 */
  1242. if (rt_strncmp(cmd, "top", 3) == 0 && (cmd[3] == '\0' || cmd[3] == ' '))
  1243. {
  1244. return RT_TRUE;
  1245. }
  1246. if (rt_strncmp(cmd, "Msh_DisplaySysMonitor", 21) == 0)
  1247. {
  1248. return RT_TRUE;
  1249. }
  1250. return RT_FALSE;
  1251. }
  1252. static void dbg_exec_run(void)
  1253. {
  1254. rt_bool_t switched = RT_FALSE;
  1255. char cmd[DBG1_CMD_MAX + 1];
  1256. rt_memcpy(cmd, dbg_cmd_buf, DBG1_CMD_MAX + 1);
  1257. cmd[DBG1_CMD_MAX] = '\0';
  1258. if (dbg_cmd_is_blocking(cmd))
  1259. {
  1260. dbg_con_puts("(该命令为持续刷新命令,不支持屏幕控制台执行)\n");
  1261. dbg_con_flush(RT_TRUE);
  1262. return;
  1263. }
  1264. /* 未开镜像时临时把控制台切到捕获设备,保证 msh 输出可被捕获 */
  1265. if (dbg_mirror_on == RT_FALSE)
  1266. {
  1267. dbg_con_dev_init();
  1268. if (rt_device_find(DBG1_CAP_DEV_NAME) == RT_NULL)
  1269. {
  1270. dbg_con_puts("(捕获设备未就绪,命令未执行)\n");
  1271. dbg_con_flush(RT_TRUE);
  1272. return;
  1273. }
  1274. dbg_console_save();
  1275. rt_console_set_device(DBG1_CAP_DEV_NAME); /* 转发只需设备引用,无需自行 open */
  1276. switched = RT_TRUE;
  1277. }
  1278. dbg_con_puts("msh> ");
  1279. dbg_con_puts(cmd);
  1280. dbg_con_append("\n", 1);
  1281. dbg_con_flush(RT_FALSE);
  1282. msh_exec(cmd, rt_strlen(cmd)); /* 输出经控制台进入捕获设备 -> 行缓存 -> 屏幕 */
  1283. if (switched)
  1284. {
  1285. dbg_console_restore(); /* 恢复控制台;其内部 open 会洗掉接收位 */
  1286. }
  1287. dbg_con_flush(RT_TRUE);
  1288. }
  1289. static void dbg_exec_thread_entry(void *parameter)
  1290. {
  1291. (void)parameter;
  1292. while (1)
  1293. {
  1294. if (rt_sem_take(&dbg_exec_sem, RT_WAITING_FOREVER) != RT_EOK)
  1295. {
  1296. continue;
  1297. }
  1298. dbg_exec_busy = 1;
  1299. dbg_exec_run();
  1300. dbg_exec_busy = 0;
  1301. }
  1302. }
  1303. static void dbg_exec_init(void)
  1304. {
  1305. if (dbg_exec_inited)
  1306. {
  1307. return;
  1308. }
  1309. dbg_exec_inited = RT_TRUE;
  1310. rt_sem_init(&dbg_exec_sem, "dbgsem", 0, RT_IPC_FLAG_FIFO);
  1311. if (rt_thread_init(&dbg_exec_thread, "dbgexec", dbg_exec_thread_entry, RT_NULL,
  1312. dbg_exec_stack, sizeof(dbg_exec_stack), DBG1_EXEC_PRIO, 10) == RT_EOK)
  1313. {
  1314. rt_thread_startup(&dbg_exec_thread);
  1315. dbg_exec_ready = RT_TRUE;
  1316. }
  1317. }
  1318. /* 从 "dbg:" 之后的载荷中提取命令并提交执行线程。
  1319. * 载荷 = 屏幕文本框的整个内容("单框收发"设计),提取规则:
  1320. * 取**最后一个 ">>"** 之后的文本作为命令(框尾固定有提示符 "msh >> ",用户在其后输入);
  1321. * 载荷中不含 ">>" 时按"纯命令"处理(兼容另接独立命令输入框的用法);
  1322. * 再裁剪:跳过前导空白、截至行尾/上限、去尾部空白。 */
  1323. static void dbg_exec_submit(const char *payload)
  1324. {
  1325. const char *cmd = payload;
  1326. const char *p = payload;
  1327. const char *last = RT_NULL;
  1328. rt_uint16_t n = 0;
  1329. dbg_exec_init();
  1330. while ((p = rt_strstr(p, ">>")) != RT_NULL) /* 定位最后一个 ">>" */
  1331. {
  1332. last = p;
  1333. p += 2;
  1334. }
  1335. if (last != RT_NULL)
  1336. {
  1337. cmd = last + 2;
  1338. }
  1339. while (*cmd == ' ' || *cmd == '\t') /* 跳过提示符后的空白 */
  1340. {
  1341. cmd++;
  1342. }
  1343. while (cmd[n] != '\0' && cmd[n] != '\r' && cmd[n] != '\n' && n < DBG1_CMD_MAX)
  1344. {
  1345. dbg_cmd_buf[n] = cmd[n];
  1346. n++;
  1347. }
  1348. while (n > 0 && (dbg_cmd_buf[n - 1] == ' ' || dbg_cmd_buf[n - 1] == '\t'))
  1349. {
  1350. n--;
  1351. }
  1352. dbg_cmd_buf[n] = '\0';
  1353. if (n == 0)
  1354. {
  1355. return; /* 空命令(只发了提示符)不处理 */
  1356. }
  1357. if (dbg_exec_ready == RT_FALSE)
  1358. {
  1359. dbg_con_puts("(调试执行线程创建失败)\n");
  1360. dbg_con_flush(RT_TRUE);
  1361. return;
  1362. }
  1363. if (dbg_exec_busy)
  1364. {
  1365. dbg_con_puts("(上一条命令仍在执行,请稍候)\n");
  1366. dbg_con_flush(RT_TRUE);
  1367. return;
  1368. }
  1369. rt_sem_release(&dbg_exec_sem);
  1370. }
  1371. /* ---------- debug1 按钮处理 ---------- */
  1372. static void dbg_console_on(void)
  1373. {
  1374. dbg_con_dev_init();
  1375. if (rt_device_find(DBG1_CAP_DEV_NAME) == RT_NULL)
  1376. {
  1377. dbg_con_puts("(捕获设备注册失败,无法打开屏幕调试)\n");
  1378. dbg_con_flush(RT_TRUE);
  1379. return;
  1380. }
  1381. if (dbg_mirror_on == RT_FALSE)
  1382. {
  1383. dbg_console_save(); /* 记录当前控制台(uart1) */
  1384. rt_console_set_device(DBG1_CAP_DEV_NAME); /* 输出切到捕获设备;日志仍转发本机口 */
  1385. dbg_mirror_on = RT_TRUE;
  1386. }
  1387. dbg_con_puts("--- 屏幕调试已打开:日志同步到本框;在提示符后输入命令按[发送] ---\n");
  1388. dbg_con_flush(RT_TRUE);
  1389. }
  1390. static void dbg_console_off(void)
  1391. {
  1392. if (dbg_mirror_on)
  1393. {
  1394. dbg_console_restore(); /* 恢复控制台:内部 open 会洗掉接收模式位 */
  1395. dbg_mirror_on = RT_FALSE;
  1396. }
  1397. dbg_con_puts("--- 屏幕调试已关闭(控制台已恢复) ---\n");
  1398. dbg_con_flush(RT_TRUE);
  1399. }
  1400. static void dbg_con_clear(void)
  1401. {
  1402. dbg_con_len = 0;
  1403. dbg_con_raw[0] = '\0';
  1404. /* 复位重复过滤表:否则本调用点缓存仍是上次发出的内容,
  1405. * 二次点击"清空"(期间文本框已被日志刷新)会被去重逻辑跳过 */
  1406. hmi_dedupe_reset();
  1407. HMI_WRITE("debug1." DBG1_CON_OBJ ".txt=\"" DBG1_PROMPT "\""); /* 清空后仅保留提示符便于继续输入 */
  1408. }
  1409. static void dbg_erase_params(void)
  1410. {
  1411. LOG_I("debug1: 擦除参数(恢复出厂默认)");
  1412. if (device_status.Power_Type == 1) ResetParamDefault_DC(); /* 电池供电默认值 */
  1413. else ResetParamDefault(); /* 交流供电默认值 */
  1414. dbg_con_puts("--- 参数已恢复出厂默认值 ---\n");
  1415. dbg_con_flush(RT_TRUE);
  1416. }
  1417. static void dbg_start_app(void)
  1418. {
  1419. LOG_I("debug1: 启动APP(清除BL停留标志), 重启");
  1420. device_status.stop_in_bootloader = 0;
  1421. ef_set_env_blob("stop_in_bootloader", &device_status.stop_in_bootloader,
  1422. sizeof(device_status.stop_in_bootloader));
  1423. rt_thread_mdelay(200);
  1424. rt_hw_cpu_reset();
  1425. }
  1426. static void dbg_restore_fw(void)
  1427. {
  1428. uint8_t pending = 1;
  1429. LOG_I("debug1: 恢复固件(置标志并重启进BL)");
  1430. /* APP 正在 app 分区运行,不能自擦运行分区;置标志重启进 BL 恢复。
  1431. * restore_pending:供 BL 读取(BL 支持后自动执行 df_area→app 恢复)。 */
  1432. device_status.stop_in_bootloader = 1;
  1433. ef_set_env_blob("stop_in_bootloader", &device_status.stop_in_bootloader,
  1434. sizeof(device_status.stop_in_bootloader));
  1435. ef_set_env_blob("restore_pending", &pending, sizeof(pending));
  1436. rt_thread_mdelay(200);
  1437. rt_hw_cpu_reset();
  1438. }
  1439. /* debug1 页指令分发:返回 RT_TRUE 表示指令属于 debug1 并已处理。
  1440. * 注意:调用点必须放在 HMI_Decode 的 if/else 链最前 —— "dbg:<命令>" 的
  1441. * 命令内容里可能包含 reboot/clear 等既有分支的关键字,不能让它们先匹配。
  1442. * 另:能收到本页按钮指令即证明用户停留在调试页,匹配成功时顺带刷新页面心跳
  1443. * (s_dbg1_page_tick),使按钮在未配 1 秒心跳定时器时也能独立工作。 */
  1444. static rt_bool_t hmi_debug1_handle(const char *frame)
  1445. {
  1446. if (rt_strncmp(frame, "dbg:", 4) == 0) /* b4 发送:执行控制台命令 */
  1447. {
  1448. s_dbg1_page_tick = rt_tick_get();
  1449. dbg_exec_submit(frame + 4);
  1450. return RT_TRUE;
  1451. }
  1452. if (strstr(frame, "dbg_on") != RT_NULL) { s_dbg1_page_tick = rt_tick_get(); dbg_console_on(); return RT_TRUE; }
  1453. if (strstr(frame, "dbg_off") != RT_NULL) { s_dbg1_page_tick = rt_tick_get(); dbg_console_off(); return RT_TRUE; }
  1454. if (strstr(frame, "dbg_clr") != RT_NULL) { s_dbg1_page_tick = rt_tick_get(); dbg_con_clear(); return RT_TRUE; }
  1455. if (strstr(frame, "dbg_erase") != RT_NULL) { s_dbg1_page_tick = rt_tick_get(); dbg_erase_params(); return RT_TRUE; }
  1456. if (strstr(frame, "dbg_restore") != RT_NULL) { s_dbg1_page_tick = rt_tick_get(); dbg_restore_fw(); return RT_TRUE; }
  1457. if (strstr(frame, "startapp") != RT_NULL) { s_dbg1_page_tick = rt_tick_get(); dbg_start_app(); return RT_TRUE; }
  1458. return RT_FALSE;
  1459. }
  1460. /* ---------- debug1 信息区整批刷新("getDebugData" 触发) ---------- */
  1461. /* JEDEC 厂商 ID → 名称(取值与 SFUD 内置 mf_table 一致,仅供显示用)。
  1462. * 2026-10-13 新增:芯片走 SFDP 识别路径时 SFUD 不填 chip.name(见 t10 注释),
  1463. * 用厂商名兜底可读性最好。 */
  1464. static const char *dbg1_flash_vendor(uint8_t mf_id)
  1465. {
  1466. static const struct { uint8_t id; const char *name; } tbl[] = {
  1467. {0x01, "Cypress"}, {0x04, "Fujitsu"}, {0x1C, "EON"}, {0x1F, "Atmel"},
  1468. {0x20, "Micron"}, {0x37, "AMIC"}, {0x62, "Sanyo"}, {0x89, "Intel"},
  1469. {0x8C, "ESMT"}, {0xA1, "Fudan"}, {0xAD, "Hyundai"}, {0xBF, "SST"},
  1470. {0xC2, "Micronix"}, {0xC8, "GigaDevice"}, {0xD5, "ISSI"}, {0xEF, "Winbond"},
  1471. };
  1472. rt_size_t i;
  1473. for (i = 0; i < sizeof(tbl) / sizeof(tbl[0]); i++)
  1474. {
  1475. if (tbl[i].id == mf_id)
  1476. {
  1477. return tbl[i].name;
  1478. }
  1479. }
  1480. return RT_NULL;
  1481. }
  1482. /* 组装 FAL 分区表文本(t14 下发用):每行 "分区名 所属Flash 起址K+大小K",
  1483. * 行间用 TJC 换行转义 "\r"(两个字符)。例:
  1484. * bl onchip_flash 0K+200K / app onchip_flash 200K+312K
  1485. * easyflash MYFLASH16 0K+3072K / fm_area ... / df_area ...
  1486. * 超出 cap 时按整行截断(宁少一行,不给屏幕发半行)。 */
  1487. static void dbg1_build_part_txt(char *out, rt_uint16_t cap)
  1488. {
  1489. size_t part_num = 0;
  1490. const struct fal_partition *tbl = fal_get_partition_table(&part_num);
  1491. rt_uint16_t n = 0;
  1492. size_t i;
  1493. out[0] = '\0';
  1494. if (tbl == RT_NULL || part_num == 0)
  1495. {
  1496. rt_snprintf(out, cap, "%s", "分区表不可用");
  1497. return;
  1498. }
  1499. for (i = 0; i < part_num; i++)
  1500. {
  1501. char line[56];
  1502. int ln = rt_snprintf(line, sizeof(line), "%s %s %luK+%luK",
  1503. tbl[i].name, tbl[i].flash_name,
  1504. (unsigned long)(tbl[i].offset / 1024),
  1505. (unsigned long)(tbl[i].len / 1024));
  1506. if (ln <= 0)
  1507. {
  1508. continue;
  1509. }
  1510. if (ln > (int)sizeof(line) - 1) /* rt_snprintf 返回"应有长度",先夹取再参与判界/拷贝 */
  1511. {
  1512. ln = (int)sizeof(line) - 1;
  1513. }
  1514. if ((rt_uint32_t)n + (rt_uint32_t)ln + 2 + 1 > cap) /* +2 换行 +1 结束符 */
  1515. {
  1516. break;
  1517. }
  1518. if (n > 0)
  1519. {
  1520. out[n++] = '\\';
  1521. out[n++] = 'r';
  1522. }
  1523. rt_memcpy(out + n, line, ln);
  1524. n += (rt_uint16_t)ln;
  1525. out[n] = '\0';
  1526. }
  1527. }
  1528. static void hmi_refresh_debug1(void)
  1529. {
  1530. char buf[48];
  1531. rt_uint32_t total = 0, used = 0, max_used = 0, sec, pct = 0;
  1532. sfud_flash_t nor;
  1533. sys_monitor_refresh(); /* CPU 利用率 / 运行时长(非阻塞,任意线程可用) */
  1534. /* t0 RT-Thread版本 / t1 内核 / t2 BSP型号 */
  1535. rt_snprintf(buf, sizeof(buf), "%d.%d.%d", (int)RT_VERSION, (int)RT_SUBVERSION, (int)RT_REVISION);
  1536. HMI_WRITE("debug1.t0.txt=\"%s\"", buf);
  1537. HMI_WRITE("debug1.t1.txt=\"%s\"", DBG1_CORE_NAME);
  1538. HMI_WRITE("debug1.t2.txt=\"%s\"", DBG1_BSP_NAME);
  1539. /* t13 运行时长:总小时:分:秒(如 72:05:11,小时持续累加、不跨天回绕)。
  1540. * 2026-10-13 修正:① 秒位原为累计秒(屏幕显示形如 2:03:7397),改为 sec%60;
  1541. * ② 时位去掉 %86400 掩码——去掉"天"字段后若保留掩码,24h 处会静默回绕、
  1542. * 长跑设备无法区分"已运行 2 天还是 26 天"。 */
  1543. sec = (rt_uint32_t)(rt_tick_get() / RT_TICK_PER_SECOND);
  1544. rt_snprintf(buf, sizeof(buf), "%lu:%02lu:%02lu",
  1545. (unsigned long)(sec / 3600),
  1546. (unsigned long)((sec % 3600) / 60),
  1547. (unsigned long)(sec % 60));
  1548. HMI_WRITE("debug1.t13.txt=\"%s\"", buf);
  1549. /* 版本区:t5 BL版本 / t3 固件版本 / t4 编译时间 */
  1550. HMI_WRITE("debug1.t5.txt=\"%s\"", device_status.driver_bl);
  1551. HMI_WRITE("debug1.t3.txt=\"%s\"", device_status.driver);
  1552. HMI_WRITE("debug1.t4.txt=\"%s\"", device_status.driver_compile);
  1553. /* CPU:t11 文本 + j0 进度条(0-100) */
  1554. HMI_WRITE("debug1.t11.txt=\"%d%%\"", system_status.cpu_usage);
  1555. HMI_WRITE("debug1.j0.val=%d", system_status.cpu_usage);
  1556. /* RAM:t12 文本 + j1 进度条(0-100) */
  1557. rt_memory_info(&total, &used, &max_used);
  1558. if (total > 0)
  1559. {
  1560. pct = (rt_uint32_t)used * 100 / total;
  1561. rt_snprintf(buf, sizeof(buf), "%lu%%", (unsigned long)pct);
  1562. HMI_WRITE("debug1.t12.txt=\"%s\"", buf);
  1563. HMI_WRITE("debug1.j1.val=%d", (int)pct);
  1564. }
  1565. else
  1566. {
  1567. HMI_WRITE("debug1.t12.txt=\"%s\"", "N/A");
  1568. HMI_WRITE("debug1.j1.val=%d", 0);
  1569. }
  1570. /* t10 外挂Flash(SFUD 探测结果)。
  1571. * 2026-10-13 修复:芯片支持 JESD216(SFDP) 时,SFUD 走 SFDP 识别路径并**显式置
  1572. * chip.name = NULL**(sfud.c:279,SFDP 不含型号名;实测本机 16MB 闪存即此路径),
  1573. * 原实现直接 %s 打印会输出 "(NULL)"。现按三级兜底保证内容有效:
  1574. * ① 型号表命中 → "W25Q128 16MB"(原样保留);
  1575. * ② 型号为空 → "Winbond EF4018 16MB"(厂商名 + JEDEC ID + 容量,信息全部实读自芯片);
  1576. * ③ 厂商也未知 → "JEDEC EF4018 16MB"。 */
  1577. /* ★ 2026-10-30 修复:这里原来传 NOR_FLASH_DEV_NAME("norflash0"),那是 **FAL 设备名**;
  1578. * SFUD 注册用的是 rtconfig 的 FAL_USING_NOR_FLASH_DEV_NAME(本机 "W25Q16"),
  1579. * 两者不同名 → 查找恒返回 NULL,调试页一直显示"未检测到外挂Flash"。 */
  1580. nor = rt_sfud_flash_find_by_dev_name(FAL_USING_NOR_FLASH_DEV_NAME);
  1581. if (nor != RT_NULL)
  1582. {
  1583. const char *vendor = dbg1_flash_vendor(nor->chip.mf_id);
  1584. unsigned cap_mb = (unsigned)(nor->chip.capacity / (1024 * 1024));
  1585. if (nor->chip.name != RT_NULL && nor->chip.name[0] != '\0')
  1586. {
  1587. rt_snprintf(buf, sizeof(buf), "%s %uMB", nor->chip.name, cap_mb);
  1588. }
  1589. else if (vendor != RT_NULL)
  1590. {
  1591. rt_snprintf(buf, sizeof(buf), "%s %02X%02X%02X %uMB", vendor,
  1592. (unsigned)nor->chip.mf_id, (unsigned)nor->chip.type_id,
  1593. (unsigned)nor->chip.capacity_id, cap_mb);
  1594. }
  1595. else
  1596. {
  1597. rt_snprintf(buf, sizeof(buf), "JEDEC %02X%02X%02X %uMB",
  1598. (unsigned)nor->chip.mf_id, (unsigned)nor->chip.type_id,
  1599. (unsigned)nor->chip.capacity_id, cap_mb);
  1600. }
  1601. }
  1602. else
  1603. {
  1604. rt_snprintf(buf, sizeof(buf), "未检测到");
  1605. }
  1606. HMI_WRITE("debug1.t10.txt=\"%s\"", buf);
  1607. /* t14 分区表详情(FAL 分区表:分区名 所属Flash 起址K+大小K,多行)。
  1608. * 内容静态,配合发送去重仅首次(及换页/10s 复位后)实际占用串口带宽。 */
  1609. {
  1610. char part[DBG1_PART_MAX + 2];
  1611. dbg1_build_part_txt(part, sizeof(part));
  1612. HMI_WRITE("debug1." DBG1_PART_OBJ ".txt=\"%s\"", part);
  1613. }
  1614. }
  1615. /* 屏幕版本握手串变化检测。
  1616. * 说明:屏幕心跳里 SwversionV** 可能与 getFullData 一样每秒都发,
  1617. * 若每次都复位重复过滤表会让去重完全失效;因此只在"版本串发生变化"时复位
  1618. * (换型号/换页面工程才会变)。屏幕重启但版本不变的情况由 HMI_DEDUPE_RESYNC_SEC
  1619. * 周期复位兜底(最坏 10s 后恢复全量刷新)。
  1620. * 2026-10-15:版本串变化还用于触发版本类型切换(hmi_switch_version),
  1621. * 见 HMI_Decode 的 SwversionV 分支。 */
  1622. static char s_last_hmi_ver[16] = {0};
  1623. static rt_bool_t hmi_ver_changed(const char *frame)
  1624. {
  1625. char cur[16];
  1626. int i = 0;
  1627. while (frame[i] != '\0' && frame[i] != '\r' && frame[i] != '\n' && i < (int)sizeof(cur) - 1)
  1628. {
  1629. cur[i] = frame[i];
  1630. i++;
  1631. }
  1632. cur[i] = '\0';
  1633. if (rt_strcmp(cur, s_last_hmi_ver) != 0)
  1634. {
  1635. rt_strncpy(s_last_hmi_ver, cur, sizeof(s_last_hmi_ver) - 1);
  1636. s_last_hmi_ver[sizeof(s_last_hmi_ver) - 1] = '\0';
  1637. LOG_I("hmi version frame changed: %s", s_last_hmi_ver);
  1638. return RT_TRUE;
  1639. }
  1640. return RT_FALSE;
  1641. }
  1642. /* ==================== 屏幕版本串 → 版本类型切换(2026-10-15) ====================
  1643. * 触发:HMI_Decode 的 SwversionV 分支中,hmi_ver_changed() 检测到屏幕版本握手串
  1644. * 发生变化时调用一次——即连接/更换不同版本的屏幕工程时,按串切换
  1645. * dtype/version_type/driver 并写 EF(MA_save/param_mirror_sync)。
  1646. * 历史:本逻辑原为 HMI_Decode 内一段 else-if 链(V12/V11/V1/V43/V42/V41/V4/V6/
  1647. * V30/V7),自 SwversionV 整页刷新分支加入后所有版本帧都被其先命中,
  1648. * 原链永远不可达(死代码);现迁移为本函数并改由版本串变化事件触发,
  1649. * 逐分支语义与原链一致(分包防误切仍用 hmi_cmd_match 严格匹配)。 */
  1650. static void hmi_switch_version(const char *frame)
  1651. {
  1652. //高空-带拍照
  1653. if (strstr(frame,"SwversionV12")!=NULL)
  1654. {
  1655. device_status.dtype = 3;
  1656. if(device_status.version_type != 12)
  1657. {
  1658. device_status.version_type = 12;
  1659. sprintf(device_status.driver, "%s",VERSION_GK);
  1660. ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type)); //版本类型
  1661. ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype)); //版本类型
  1662. MA_save();
  1663. param_mirror_sync();
  1664. }
  1665. else {
  1666. }
  1667. }
  1668. //高空
  1669. else if (strstr(frame,"SwversionV11")!=NULL)
  1670. {
  1671. device_status.dtype = 3;
  1672. if(device_status.version_type != 11)
  1673. {
  1674. device_status.version_type = 11;
  1675. sprintf(device_status.driver, "%s",VERSION_GK);
  1676. ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type)); //版本类型
  1677. ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype)); //版本类型
  1678. MA_save();
  1679. param_mirror_sync();
  1680. }
  1681. else {
  1682. }
  1683. return;
  1684. }
  1685. //1.0
  1686. /* 注意:必须用严格匹配——"SwversionV1" 是 "SwversionV11/12" 的前缀,
  1687. * 串口分包时残段会误切到本分支(同 V4 的问题,见 hmi_cmd_match 说明) */
  1688. else if (hmi_cmd_match(frame,"SwversionV1"))
  1689. {
  1690. if(device_status.version_type != 1)
  1691. {
  1692. device_status.dtype = 3;
  1693. device_status.version_type = 1;
  1694. sprintf(device_status.driver, "%s",VERSION_ZP);
  1695. ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type)); //版本类型
  1696. ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype)); //版本类型
  1697. MA_save();
  1698. param_mirror_sync();
  1699. }
  1700. else {
  1701. }
  1702. return;
  1703. }
  1704. //中端款
  1705. else if (strstr(frame,"SwversionV43")!=NULL) {
  1706. device_status.dtype = 3;
  1707. if(device_status.version_type != 43)
  1708. {
  1709. device_status.dtype = 3;
  1710. device_status.version_type = 43;
  1711. sprintf(device_status.driver, "%s",VERSION_HK_2000W);
  1712. ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type)); //版本类型
  1713. ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype)); //版本类型+
  1714. MA_save();
  1715. param_mirror_sync();
  1716. }
  1717. return;
  1718. }
  1719. //低端款
  1720. else if (strstr(frame,"SwversionV42")!=NULL) {
  1721. device_status.dtype = 3;
  1722. if(device_status.version_type != 42)
  1723. {
  1724. device_status.dtype = 3;
  1725. device_status.version_type = 42;
  1726. sprintf(device_status.driver, "%s",VERSION_HK_2000W);
  1727. ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type)); //版本类型
  1728. ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype)); //版本类型+
  1729. MA_save();
  1730. param_mirror_sync();
  1731. }
  1732. return;
  1733. }
  1734. //4.0
  1735. else if (strstr(frame,"SwversionV41")!=NULL) {
  1736. device_status.dtype = 3;
  1737. if(device_status.version_type != 41)
  1738. {
  1739. device_status.dtype = 3;
  1740. device_status.version_type = 41;
  1741. sprintf(device_status.driver, "%s",VERSION_HK);
  1742. ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type)); //版本类型
  1743. ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype)); //版本类型+
  1744. DTU_Write("SwversionV41");
  1745. MA_save();
  1746. param_mirror_sync();
  1747. }
  1748. else {
  1749. }
  1750. return;
  1751. }
  1752. //水稻
  1753. /* 注意:必须用严格匹配——"SwversionV4" 是 "SwversionV41/42/43" 的前缀。
  1754. * 实测(2026-10-08):串口分包时 "SwversionV43" 的前段 "SwversionV4" 会误切到
  1755. * 本分支(version_type 43→4、误报 RTU、写 Flash),随后完整帧又切回 43,
  1756. * 造成配置来回翻转。见 hmi_cmd_match 说明。 */
  1757. else if (hmi_cmd_match(frame,"SwversionV4"))
  1758. {
  1759. device_status.dtype = 3;
  1760. if(device_status.version_type != 4)
  1761. {
  1762. device_status.version_type = 4;
  1763. sprintf(device_status.driver, "%s",VERSION_HK_2000W);
  1764. ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type)); //版本类型
  1765. ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype)); //版本类型
  1766. MA_save();
  1767. param_mirror_sync();
  1768. }
  1769. else {
  1770. }
  1771. return;
  1772. }
  1773. else if((strstr(frame,"SwversionV7")!=NULL)) {
  1774. if(device_status.dtype!=7)
  1775. {
  1776. LOG_D("设置版本类型:7");
  1777. device_status.dtype = 7;
  1778. device_status.version_type = 7;
  1779. ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype)); //设备类型
  1780. ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type)); //版本类型
  1781. DTU_Write("SwversionV7");
  1782. MA_save();
  1783. param_mirror_sync();
  1784. }
  1785. }
  1786. }
  1787. static void HMI_Decode(void)
  1788. {
  1789. time_t now = time(RT_NULL);
  1790. static struct tm tm;
  1791. gmtime_r(&now, &tm);
  1792. static char *json_temp;
  1793. static char *var;
  1794. /* 屏幕页刷新与版本握手统一入口(SwversionV* / getFullData 两类帧):
  1795. * ① SwversionV*:先检测并持久化版本类型(原独立 else-if 分支链并入本块,
  1796. * 保证"先更新版本、再刷新页面",刷新内容即时反映新版本);
  1797. * ② 版本串变化(换型号/换页面工程) → 复位重复过滤表,立即恢复全量刷新;
  1798. * ③ getFullData / SwversionV* 均触发整页刷新:60+ 条属性合并为 1~3 次
  1799. * 串口写(见 HMI_WRITE 发送优化);
  1800. * ④ 处理完直接 return(沿用原版本分支的语义),不再落入下方指令链。
  1801. * 注意:显式排除 "dbg:" 控制台发送帧——b4[发送]会回传整框文本,其中可能内嵌
  1802. * 历史日志里的版本串(如本机口镜像的 hmi rx 行),若不排除会抢在 hmi_debug1_handle
  1803. * 之前吞掉命令帧,导致命令不再执行。 */
  1804. if(strstr(rx_buffer,"SwversionV") != NULL || strstr(rx_buffer,"getFullData") != NULL)
  1805. {
  1806. /* 屏幕版本握手串变化(换型号/换页面工程) → 复位重复过滤表 + 按串切换版本类型,
  1807. * 并立即整页全量刷新 */
  1808. if (strstr(rx_buffer,"SwversionV") != NULL && hmi_ver_changed(rx_buffer))
  1809. {
  1810. hmi_dedupe_reset();
  1811. /* 2026-10-15:版本串变化后按字符设置版本类型(见 hmi_switch_version 说明) */
  1812. hmi_switch_version(rx_buffer);
  1813. }
  1814. /* 整页刷新 60+ 条属性合并为 1~3 次串口写(见 HMI_WRITE 发送优化) */
  1815. HMI_BATCH_BEGIN();
  1816. refresh_hmi_Component(tm);
  1817. hmi_refresh_work_proc(); /* 拍照/清扫状态 + t1~t6 工作过程显示 */
  1818. HMI_BATCH_END();
  1819. return; /* 握手/刷新帧处理完毕, 不再落入下方指令链 */
  1820. }
  1821. /* ---- 屏幕 debug1 调试页(心跳刷新 + 按钮/控制台指令)----
  1822. * 必须放在 if/else 链最前:dbg:<命令> 的内容里可能包含 reboot/clear 等
  1823. * 既有分支的关键字,让它们先匹配会导致误动作。 */
  1824. if (strstr(rx_buffer, "getDebugData") != RT_NULL)
  1825. {
  1826. s_dbg1_page_tick = rt_tick_get(); /* 调试页心跳:离开该页(超时)后暂停日志推送 */
  1827. HMI_BATCH_BEGIN();
  1828. hmi_refresh_debug1();
  1829. dbg_con_flush(RT_FALSE); /* 回页/持续在页:把最新控制台内容补推一次(带去重) */
  1830. HMI_BATCH_END();
  1831. }
  1832. else if (hmi_debug1_handle(rx_buffer))
  1833. {
  1834. /* debug1 指令已处理(dbg:/dbg_on/dbg_off/dbg_clr/dbg_erase/dbg_restore/startapp),
  1835. * 页面心跳已在处理函数内随之刷新。 */
  1836. }
  1837. else if (strstr(rx_buffer,"getClockData")!=NULL) {
  1838. //更新定时模式
  1839. HMI_WRITE("clockSet.timeSwitch.val=%d",device_status.timeSwitch);
  1840. //更新光控定时时长
  1841. HMI_WRITE("clockSet.sunBar.val=%d",device_status.sunBar);
  1842. //更新时控开始
  1843. HMI_WRITE("clockSet.startBar.val=%d",device_status.startBar);
  1844. //更新时控结束
  1845. HMI_WRITE("clockSet.stopBar.val=%d",device_status.stopBar);
  1846. }
  1847. else if (strstr(rx_buffer,"button")!=NULL) {
  1848. LOG_D("button!");
  1849. DTU_Write("button");
  1850. }
  1851. //拍照
  1852. else if(strstr(rx_buffer,"putTest.switchPhoto=1")!=NULL) {
  1853. #if MATCH_DEVICE == 1
  1854. ctr_led(ON);
  1855. //发送拍照指令
  1856. char *takephotojson = makeJson_takephoto();
  1857. DTU_Write("%s",takephotojson);
  1858. rt_free(takephotojson);
  1859. HMI_WRITE("sysTest.switchPhoto.val=0");
  1860. #else
  1861. device_status.test_flag=1;
  1862. device_status.photo_ws = 1;
  1863. #endif
  1864. }
  1865. else if (strstr(rx_buffer,"putTest.switchPic=1")!=NULL) {
  1866. #if MATCH_DEVICE == 1
  1867. ctr_led(ON);
  1868. //发送拍照指令
  1869. char *takephotojson = makeJson_takephoto();
  1870. DTU_Write("%s",takephotojson);
  1871. rt_free(takephotojson);
  1872. HMI_WRITE("sysTest.switchPhoto.val=0");
  1873. #else
  1874. device_status.photo_ws = 1;
  1875. #endif
  1876. }
  1877. //打开补光
  1878. else if (strstr(rx_buffer,"putTest.switchLed=1")!=NULL) {
  1879. LOG_I("打开补光!!");
  1880. ctr_led(ON);
  1881. }
  1882. //关闭补光
  1883. else if (strstr(rx_buffer,"putTest.switchLed=0")!=NULL) {
  1884. LOG_I("关闭补光!!!");
  1885. ctr_led(OFF);
  1886. }
  1887. //关闭加热
  1888. else if(strstr(rx_buffer,"putTest.switchHeat=0")!=NULL) {
  1889. device_status.heat_status = 0;
  1890. ctr_Heat(OFF);
  1891. hmi_test_heat_stop(); /* 手动关闭:撤销自动关闭定时器 */
  1892. LOG_I("Close Heat!");
  1893. }
  1894. //打开加热
  1895. else if(strstr(rx_buffer,"putTest.switchHeat=1")!=NULL) {
  1896. device_status.heat_status = 1;
  1897. ctr_Heat(ON);
  1898. hmi_test_heat_start(); /* 屏幕测试加热:10分钟自动关闭(防忘记关干烧) */
  1899. LOG_I("Open Heat!");
  1900. }
  1901. else if (strstr(rx_buffer,"turnzp")!=NULL) {
  1902. LOG_W("转仓!");
  1903. device_status.clear_status=2;
  1904. }
  1905. //清扫
  1906. else if (strstr(rx_buffer,"clear")!=NULL) {
  1907. LOG_W("清扫!");
  1908. device_status.clear_status=1;
  1909. }
  1910. //震动
  1911. else if (strstr(rx_buffer,"putTest.switchShake=1")!=NULL) {
  1912. LOG_I("震动!");
  1913. if(device_status.version_type==6)
  1914. {
  1915. Motor_shake(ON, device_status.shake_sec);
  1916. }
  1917. else{
  1918. ctr_shake(ON,device_status.shake_sec);
  1919. ctr_router(ON);
  1920. }
  1921. }
  1922. //打开补光
  1923. else if (strstr(rx_buffer,"putTest.switchFill=1")!=NULL) {
  1924. rt_kprintf("\n打开补光!!!\n");
  1925. ctr_led(ON);
  1926. }
  1927. //关闭补光
  1928. else if (strstr(rx_buffer,"putTest.switchFill=0")!=NULL) {
  1929. rt_kprintf("\n关闭补光!!!\n");
  1930. ctr_led(OFF);
  1931. }
  1932. //打开灯管
  1933. else if (strstr(rx_buffer,"putTest.switchLamp=1")!=NULL)
  1934. {
  1935. device_status.test_flag=1;
  1936. rt_kprintf("Open Lamp!\n");
  1937. ctr_lamp(ON,1);
  1938. device_status.rain_status = 0;
  1939. }
  1940. //关闭灯管
  1941. else if (strstr(rx_buffer,"putTest.switchLamp=0")!=NULL)
  1942. {
  1943. device_status.test_flag=0;
  1944. rt_kprintf("Close Lamp1!\n");
  1945. ctr_lamp(OFF,1);
  1946. }
  1947. //打开上仓门
  1948. else if(strstr(rx_buffer,"putTest.switchUp=1")!=NULL){
  1949. if(device_status.dtype==7)
  1950. {
  1951. ctr_lamp(ON, 1);
  1952. ctr_Motor_Driver(1, 0,1000000,500);
  1953. LOG_I("开始步进上行!");
  1954. }
  1955. else
  1956. {
  1957. rt_kprintf("Open UP!\n");
  1958. ctr_cangmen_up(OFF);
  1959. device_status.ctr_up_motor = 1;
  1960. }
  1961. }
  1962. //关闭上仓门
  1963. else if(strstr(rx_buffer,"putTest.switchUp=0")!=NULL){
  1964. if(device_status.dtype==7)
  1965. {
  1966. LOG_I("停止步进上行!");
  1967. ctr_lamp(OFF, 1);
  1968. ctr_Motor_Driver(0, 0,0,0);
  1969. }
  1970. else
  1971. {
  1972. rt_kprintf("CLOSE UP!\n");
  1973. ctr_cangmen_up(OFF);
  1974. device_status.ctr_up_motor = 2;
  1975. }
  1976. }
  1977. //打开下仓门
  1978. else if(strstr(rx_buffer,"putTest.switchDown=1")!=NULL){
  1979. if(device_status.dtype==7)
  1980. {
  1981. LOG_I("开始步进下行!");
  1982. ctr_lamp(ON, 1);
  1983. ctr_Motor_Driver(1, 1,1000000,500);
  1984. }
  1985. else
  1986. {
  1987. ctr_cangmen_down(OFF);
  1988. device_status.ctr_down_motor = 1;
  1989. rt_kprintf("Open down!\n");
  1990. }
  1991. }
  1992. //关闭下仓门
  1993. else if(strstr(rx_buffer,"putTest.switchDown=0")!=NULL){
  1994. if(device_status.dtype==7)
  1995. {
  1996. ctr_lamp(OFF, 1);
  1997. ctr_Motor_Driver(0, 0,0,0);
  1998. rt_kprintf("停止步进下行!\n");
  1999. }
  2000. else
  2001. {
  2002. ctr_cangmen_down(OFF);
  2003. device_status.ctr_down_motor = 2;
  2004. rt_kprintf("CLOSE down!\n");
  2005. }
  2006. }
  2007. else if(strstr(rx_buffer,"putTest.Testpaichong")!=NULL){
  2008. if(device_status.collt_box_sta==0){
  2009. device_status.collt_box_sta = 111;
  2010. }else{
  2011. HMI_WRITE("sysTest.result.txt=\"请等待当前执行完成再进行操作\"");
  2012. }
  2013. LOG_I("排虫测试!");
  2014. }
  2015. //排虫
  2016. else if(strstr(rx_buffer,"putTest.paichong")!=NULL){
  2017. if(device_status.run_sta == 0){
  2018. device_status.run_sta = 111;
  2019. }else{
  2020. HMI_WRITE("sysTest.result.txt=\"请等待当前执行完成再进行操作\"");
  2021. }
  2022. LOG_I("开始排虫!");
  2023. device_status.handle_bugger = 0;
  2024. ef_set_env_blob("handle_bugger", &device_status.handle_bugger, sizeof(device_status.handle_bugger));
  2025. }
  2026. else if(strstr(rx_buffer,"putTest.shouchong")!=NULL){
  2027. if(device_status.run_sta == 0){
  2028. device_status.run_sta = 112;
  2029. }else{
  2030. HMI_WRITE("sysTest.result.txt=\"请等待当前执行完成再进行操作\"");
  2031. }
  2032. LOG_I("开始收虫!");
  2033. device_status.handle_bugger = 1;
  2034. ef_set_env_blob("handle_bugger", &device_status.handle_bugger, sizeof(device_status.handle_bugger));
  2035. }
  2036. //设置设备时间
  2037. else if (strstr(rx_buffer,"stamp=")!=NULL)
  2038. {
  2039. var = strstr(rx_buffer,"=");
  2040. var ++;
  2041. LOG_I("设置时间:%s",var);
  2042. static char year_s[5],month_s[3],day_s[3],hour_s[3],min_s[3],sec_s[3];
  2043. strncpy(year_s, var, 4);
  2044. strncpy(month_s,var+4,2);
  2045. strncpy(day_s,var+6,2);
  2046. strncpy(hour_s,var+8,2);
  2047. strncpy(min_s,var+10,2);
  2048. strncpy(sec_s,var+12,2);
  2049. if(atoi(year_s)>=2024&&atoi(year_s)<3000&&atoi(month_s)>0&&atoi(month_s)<13&&atoi(day_s)>0&&atoi(day_s)<32)
  2050. {
  2051. if(set_date(atoi(year_s),atoi(month_s),atoi(day_s))==RT_EOK)
  2052. {
  2053. LOG_I("设置日期:%d年%d月%d日",atoi(year_s),atoi(month_s),atoi(day_s));
  2054. /* ★ 原来是 >0: 合法的 00:xx:xx 永远设不进去(只改了日期)。且 24 点非法。 */
  2055. if(atoi(hour_s)>=0&&atoi(hour_s)<24&&atoi(min_s)>=0&&atoi(min_s)<=59&&atoi(sec_s)>=0&&atoi(sec_s)<=59)
  2056. {
  2057. LOG_I("设置时间:%d时%d分%d秒",atoi(hour_s),atoi(min_s),atoi(sec_s));
  2058. set_time(atoi(hour_s),atoi(min_s),atoi(sec_s));
  2059. MA_save();
  2060. }
  2061. //上传最新数据
  2062. dtu_request_report(); //立即请求一次上报(上报后按 dattim 自动重排定时器), 更新RTU的时间
  2063. }
  2064. else {
  2065. LOG_E("set_date failed!");
  2066. }
  2067. }
  2068. }
  2069. //设置闹钟时间
  2070. else if (strstr(rx_buffer,"ALARM=")!=NULL)
  2071. {
  2072. char *var = strstr(rx_buffer,"=");
  2073. if (var == NULL) {
  2074. return;
  2075. }
  2076. var ++;
  2077. // ===================== 修复:去掉末尾的 \r 或 换行 =====================
  2078. // 遍历字符串,把 \r \n 全部替换成结束符
  2079. for (int i = 0; var[i] != '\0'; i++) {
  2080. if (var[i] == '\r' || var[i] == '\n') {
  2081. var[i] = '\0';
  2082. break;
  2083. }
  2084. }
  2085. /* ★ 原来无条件写 var[6]: 载荷短于 6 位时读写越过字符串结尾,
  2086. 帧被截断时 var+6 甚至越过 rx_buffer 末尾。先判长度再截断。 */
  2087. if(strlen(var) > 6) {
  2088. var[6] = '\0';
  2089. }
  2090. // 现在 var 只剩下干净的 6 位数字了
  2091. int len = strlen(var);
  2092. int is_valid = 1;
  2093. // 1. 必须是 6 个字符(已经去掉\r)
  2094. if (len != 6) {
  2095. is_valid = 0;
  2096. }
  2097. // 2. 必须全部是数字 0-9
  2098. else {
  2099. for (int i = 0; i < 6; i++) {
  2100. if (!(var[i] >= '0' && var[i] <= '9')) {
  2101. is_valid = 0;
  2102. break;
  2103. }
  2104. }
  2105. }
  2106. // 校验不通过:打印报错,不赋值
  2107. if (!is_valid) {
  2108. LOG_E("闹钟格式错误!必须是 6 位数字时间(如 150000),当前值:%s", var);
  2109. return;
  2110. }
  2111. // ======================================================================
  2112. // 格式正确才赋值
  2113. LOG_I("设置闹钟时间:%s",var);
  2114. rt_sprintf(device_status.alarm_tg, "%s", var);
  2115. ef_set_env_blob("alarm_tg", &device_status.alarm_tg, sizeof(device_status.alarm_tg));
  2116. }
  2117. //设备编码设置
  2118. else if (strstr(rx_buffer,"deviceId=")!=NULL)
  2119. {
  2120. char value_str[20];
  2121. memset(value_str,0,sizeof(value_str));
  2122. LOG_I("设备编码 长度:%d",strlen(rx_buffer));
  2123. if(strlen(rx_buffer)!=19){
  2124. LOG_E("编码长度错误!");
  2125. return;
  2126. }
  2127. var = strstr(rx_buffer,"=");
  2128. var ++;
  2129. strncpy(value_str,var,8); //设备编码为16位
  2130. if(strstr(value_str,"00000000")!=RT_NULL){
  2131. char *config_reset = makeJson_Config_Reset();
  2132. //发送json到RTU
  2133. DTU_Write("%s",config_reset);
  2134. rt_free(config_reset);
  2135. //恢复RTU的默认配置参数
  2136. }else{
  2137. rt_sprintf(device_status.deviceId,"10300101%s",value_str); //设备大类编码103-虫情 设备小类编码 001 生产商代码01
  2138. ef_set_env_blob("deviceId", &device_status.deviceId, sizeof(device_status.deviceId));
  2139. LOG_I("解析到设备编码:%s",device_status.deviceId);
  2140. char *device_id = makeJson_Config_BDH(device_status.deviceId);
  2141. //发送json到RTU
  2142. DTU_Write("%s",device_id);
  2143. rt_free(device_id);
  2144. }
  2145. }
  2146. //定时设置
  2147. else if (strstr(rx_buffer,"saveClockSet=")!=NULL) {
  2148. char value_str[10];
  2149. memset(value_str,0,sizeof(value_str));
  2150. if(device_status.dtype==7)
  2151. {
  2152. var = strstr(rx_buffer,"=");
  2153. var ++;
  2154. strncpy(value_str,var,2);
  2155. if(atoi(value_str)>=0&&atoi(value_str)<=23)
  2156. {
  2157. device_status.collecting_sh1 = atoi(value_str);
  2158. ef_set_env_blob("collecting_sh1", &device_status.collecting_sh1, sizeof(device_status.collecting_sh1));
  2159. }
  2160. else {
  2161. LOG_E("Set collecting_sh1 Failed!");
  2162. }
  2163. memset(value_str,0,sizeof(value_str));
  2164. strncpy(value_str,var+2,2);
  2165. if(atoi(value_str)>=0&&atoi(value_str)<=23)
  2166. {
  2167. device_status.collecting_eh1 = atoi(value_str);
  2168. ef_set_env_blob("collecting_eh1", &device_status.collecting_eh1, sizeof(device_status.collecting_eh1));
  2169. }
  2170. else {
  2171. LOG_E("Set collecting_eh1 Failed!");
  2172. }
  2173. memset(value_str,0,sizeof(value_str));
  2174. strncpy(value_str,var+4,2);
  2175. if(atoi(value_str)>=0&&atoi(value_str)<=23)
  2176. {
  2177. device_status.collecting_sh2 = atoi(value_str);
  2178. ef_set_env_blob("collecting_sh2", &device_status.collecting_sh2, sizeof(device_status.collecting_sh2));
  2179. }
  2180. else {
  2181. LOG_E("Set collecting_sh2 Failed!");
  2182. }
  2183. memset(value_str,0,sizeof(value_str));
  2184. strncpy(value_str,var+6,2);
  2185. if(atoi(value_str)>=0&&atoi(value_str)<=23)
  2186. {
  2187. device_status.collecting_eh2 = atoi(value_str);
  2188. ef_set_env_blob("collecting_eh2", &device_status.collecting_eh2, sizeof(device_status.collecting_eh2));
  2189. }
  2190. else {
  2191. LOG_E("Set collecting_eh2 Failed!");
  2192. }
  2193. memset(value_str,0,sizeof(value_str));
  2194. strncpy(value_str,var+8,2);
  2195. if(atoi(value_str)>=0&&atoi(value_str)<=23)
  2196. {
  2197. device_status.shake_sec = atoi(value_str);
  2198. ef_set_env_blob("shake_sec", &device_status.shake_sec, sizeof(device_status.shake_sec));
  2199. }
  2200. else {
  2201. LOG_E("Set shake_sec Failed!");
  2202. }
  2203. memset(value_str,0,sizeof(value_str));
  2204. strncpy(value_str,var+10,2);
  2205. if(atoi(value_str)>0&&atoi(value_str)<=24)
  2206. {
  2207. device_status.cul_time = atoi(value_str);
  2208. ef_set_env_blob("cul_time", &device_status.cul_time, sizeof(device_status.cul_time));
  2209. }
  2210. else {
  2211. LOG_E("Set cul_time Failed!");
  2212. }
  2213. MA_save();
  2214. LOG_I("参数已保存:%d-%d-%d-%d-%d-%d",device_status.collecting_sh1,device_status.collecting_eh1,device_status.collecting_sh2,device_status.collecting_eh2,device_status.shake_sec,device_status.cul_time);
  2215. return;
  2216. }
  2217. LOG_I("时间设置!");
  2218. var=strstr(rx_buffer,"=");
  2219. var++;
  2220. strncpy(value_str,var,2);
  2221. if(atoi(value_str) > 0 && atoi(value_str) <60)
  2222. {
  2223. if(device_status.version_type!=6)
  2224. {
  2225. device_status.sunBar=atoi(value_str);
  2226. ef_set_env_blob("sunBar", &device_status.sunBar, sizeof(device_status.sunBar));
  2227. }
  2228. else {
  2229. device_status.shake_sec = atoi(value_str);
  2230. ef_set_env_blob("shake_sec", &device_status.shake_sec, sizeof(device_status.shake_sec));
  2231. }
  2232. }
  2233. else {
  2234. LOG_E("参数设置异常(光控时长):%d!!!",atoi(value_str));
  2235. }
  2236. memset(value_str,0,sizeof(value_str));
  2237. //时控开始时间
  2238. strncpy(value_str,var+2,2);
  2239. if(atoi(value_str) >= 0 && atoi(value_str) < 24)
  2240. {
  2241. #if 1
  2242. device_status.startBar=atoi(value_str);
  2243. ef_set_env_blob("startBar", &device_status.startBar, sizeof(device_status.startBar));
  2244. #endif
  2245. }
  2246. else {
  2247. LOG_E("参数设置异常(开始):%d!!!",atoi(value_str));
  2248. }
  2249. memset(value_str,0,sizeof(value_str));
  2250. //
  2251. strncpy(value_str,var+4,2);
  2252. if(atoi(value_str) >= 0&& atoi(value_str) < 24)
  2253. {
  2254. #if 1
  2255. device_status.stopBar=atoi(value_str);
  2256. ef_set_env_blob("stopBar", &device_status.stopBar, sizeof(device_status.stopBar));
  2257. #endif
  2258. }
  2259. else {
  2260. LOG_E("参数设置异常(结束):%d!!!",atoi(value_str));
  2261. }
  2262. memset(value_str,0,sizeof(value_str));
  2263. //
  2264. strncpy(value_str,var+6,2);
  2265. if(atoi(value_str) >= 0 && atoi(value_str) <= 1)
  2266. {
  2267. device_status.timeSwitch=atoi(value_str);
  2268. ef_set_env_blob("timeSwitch", &device_status.timeSwitch, sizeof(device_status.timeSwitch));
  2269. }
  2270. else {
  2271. if(device_status.version_type==6)
  2272. {
  2273. device_status.timeSwitch=1;
  2274. device_status.dattim=atoi(value_str);
  2275. ef_set_env_blob("dattim", &device_status.dattim, sizeof(device_status.dattim));
  2276. ef_set_env_blob("timeSwitch", &device_status.timeSwitch, sizeof(device_status.timeSwitch));
  2277. }
  2278. else {
  2279. LOG_E("参数设置异常(模式):%d!!!",atoi(value_str));
  2280. }
  2281. }
  2282. //2022/06/23,add: 操作记录改为局部缓冲(原 device_status.json_w_clock)
  2283. {
  2284. char json_warn[192];
  2285. rt_snprintf(json_warn, sizeof(json_warn),"屏幕操作:修改工作时间:开始-%d,结束-%d,模式-%d(0-光控,1-时控)操作时间:%s",device_status.startBar,device_status.stopBar,device_status.timeSwitch,device_status.stamp);
  2286. json_temp = makeJson_Warn(json_warn, "修改工作时间");
  2287. ef_set_env_blob("json_w_clock", json_warn, strlen(json_warn) + 1); //将修改屏幕参数操作记录保存到Flash中
  2288. if(atoi(device_status.net)==0)
  2289. DTU_Write("%s",json_temp);
  2290. rt_free(json_temp);
  2291. }
  2292. rt_thread_delay(2000);
  2293. MA_save();
  2294. rt_kprintf("工作时间参数已保存:模式-%d,光控时间-%d,时控开始时间-%d,时控结束时间-%d\n",device_status.timeSwitch,device_status.sunBar,device_status.startBar,device_status.stopBar);
  2295. }
  2296. else if (strstr(rx_buffer,"saveSystemSet")!=NULL) {
  2297. static char clt_time_str[3],heattime_str[3],heatvale_str[4],vol_str[4],thsp_str[5];
  2298. static char value_temp[5];
  2299. LOG_I("系统设置!");
  2300. if(device_status.dtype==7)
  2301. {
  2302. LOG_I("系统设置,孢子仪!");
  2303. var = strstr(rx_buffer,"=");
  2304. var ++;
  2305. memset(value_temp,0,sizeof(value_temp));
  2306. strncpy(value_temp,var,2);
  2307. if(atoi(value_temp)==0 || atoi(value_temp) == 1)
  2308. {
  2309. device_status.cold_sw = atoi(value_temp); //制冷开关
  2310. ef_set_env_blob("cold_sw", &device_status.cold_sw, sizeof(device_status.cold_sw));
  2311. }
  2312. else {
  2313. LOG_E("制冷开关参数设置错误!");
  2314. }
  2315. memset(value_temp,0,sizeof(value_temp));
  2316. strncpy(value_temp,var+2,2);
  2317. if(atoi(value_temp)>=0 && atoi(value_temp) <= 7)
  2318. {
  2319. device_status.vol = atoi(value_temp); //音量
  2320. }
  2321. else {
  2322. LOG_E("音量参数设置错误!");
  2323. }
  2324. memset(value_temp,0,sizeof(value_temp));
  2325. strncpy(value_temp,var+4,2);
  2326. if(atoi(value_temp)>=10 && atoi(value_temp) <= 50)
  2327. {
  2328. device_status.heatvalue = atoi(value_temp); //设定的培养温度
  2329. ef_set_env_blob("heatvalue", &device_status.heatvalue, sizeof(device_status.heatvalue));
  2330. }
  2331. else {
  2332. LOG_E("培养温度参数设置失败!");
  2333. }
  2334. memset(value_temp,0,sizeof(value_temp));
  2335. strncpy(value_temp,var+6,2);
  2336. if(atoi(value_temp)>=1 && atoi(value_temp) <= 60)
  2337. {
  2338. device_status.dattim = atoi(value_temp); //设定的数据上传间隔,单位:分钟
  2339. ef_set_env_blob("dattim", &device_status.dattim, sizeof(device_status.dattim));
  2340. }
  2341. else {
  2342. LOG_E("数据上传间隔参数设置失败!");
  2343. }
  2344. memset(value_temp,0,sizeof(value_temp));
  2345. strncpy(value_temp,var+8,2);
  2346. if(atoi(value_temp)>=1 && atoi(value_temp) <= 30)
  2347. {
  2348. device_status.thsp = atoi(value_temp); //设定的息屏间隔,单位:分钟
  2349. ef_set_env_blob("thsp", &device_status.thsp, sizeof(device_status.thsp));
  2350. }
  2351. else {
  2352. LOG_E("数据息屏间隔参数设置失败!");
  2353. }
  2354. LOG_I("制冷开关:%d",device_status.cold_sw);
  2355. LOG_I("系统设置已保存:\n自动熄屏-%d\n音量-%d\n培养温度-%d\n数据上传间隔-%d",device_status.thsp,device_status.vol,device_status.heatvalue,device_status.dattim);
  2356. MA_save();
  2357. return;
  2358. }
  2359. var = strstr(rx_buffer,"=");
  2360. var ++;
  2361. strncpy(clt_time_str,var,2);
  2362. if(atoi(clt_time_str)>0 && atoi(clt_time_str) <= 30)
  2363. {
  2364. device_status.clt_time = atoi(clt_time_str); //收集时间
  2365. ef_set_env_blob("stime", &device_status.clt_time, sizeof(device_status.clt_time));
  2366. }
  2367. strncpy(heattime_str,var+2,2);
  2368. if(atoi(heattime_str)>0 && atoi(heattime_str) <= 30)
  2369. {
  2370. device_status.heattime = atoi(heattime_str); //加热时间
  2371. LOG_I("设置加热时间:%d",atoi(heattime_str));
  2372. ef_set_env_blob("jtime", &device_status.heattime, sizeof(device_status.heattime));
  2373. }
  2374. strncpy(heatvale_str,var+4,3);
  2375. if(atoi(heatvale_str) > 0 && atoi(heatvale_str) <= 130)
  2376. {
  2377. device_status.heatvalue=atoi(heatvale_str);
  2378. LOG_I("设置加热温度:%d",device_status.heatvalue);
  2379. ef_set_env_blob("jheat", &device_status.heatvalue, sizeof(device_status.heatvalue));
  2380. }
  2381. strncpy(vol_str,var+7,3);
  2382. if(atoi(vol_str)>0&&atoi(vol_str)<8)
  2383. {
  2384. device_status.vol = atoi(vol_str); //音量
  2385. LOG_I("设置音量:%d",device_status.vol);
  2386. //DTU_Write("volume=");
  2387. }
  2388. strncpy(thsp_str,var+10,4);
  2389. if(atoi(thsp_str)>0&&atoi(thsp_str)<3600)
  2390. {
  2391. device_status.thsp = atoi(thsp_str); //熄屏时间
  2392. LOG_I("设置熄屏时间:%d",device_status.thsp);
  2393. }
  2394. else {
  2395. LOG_E("参数设置失败!!!");
  2396. }
  2397. rt_thread_delay(1000);
  2398. MA_save();
  2399. //rt_kprintf("系统设置已保存:收集时间-%d,加热时间-%d,加热温度-%d,音量-%d,自动关屏-%d\n",device_status.clt_time,device_status.heattime,device_status.heatvalue,device_status.vol,device_status.thsp);
  2400. }
  2401. else if (strstr(rx_buffer,"rtc_h=")!=NULL) {
  2402. /* ★ 原来是 char rtc_h[2] + strncpy(rtc_h,var,2): 拷贝满 2 字节不补 '\0',
  2403. atoi() 会越界读栈; 而且小时上限写成 24(非法)。直接解析并做范围校验。 */
  2404. int v;
  2405. var = strstr(rx_buffer,"=");
  2406. var++;
  2407. v = atoi(var);
  2408. if(v>=0 && v<=23)
  2409. {
  2410. set_time(v, 99, 99);
  2411. }
  2412. }
  2413. else if (strstr(rx_buffer,"rtc_m=")!=NULL) {
  2414. int v;
  2415. var = strstr(rx_buffer,"=");
  2416. var++;
  2417. v = atoi(var);
  2418. if(v>=0 && v<=59)
  2419. {
  2420. set_time(99, v, 99);
  2421. }
  2422. }
  2423. else if (strstr(rx_buffer,"rtc_s=")!=NULL) {
  2424. int v;
  2425. var = strstr(rx_buffer,"=");
  2426. var++;
  2427. v = atoi(var);
  2428. if(v>=0 && v<=59)
  2429. {
  2430. set_time(99, 99, v);
  2431. }
  2432. }
  2433. else if(strstr(rx_buffer,"saveUploadSet=")!=NULL)
  2434. {
  2435. static char dattim_str[3];
  2436. rt_kprintf("上传间隔设置!\n");
  2437. var = strstr(rx_buffer,"=");
  2438. var ++;
  2439. strncpy(dattim_str,var,2);
  2440. if(atoi(dattim_str)>=1&&atoi(dattim_str)<=120)
  2441. {
  2442. device_status.dattim =atoi(dattim_str); //数据上传间隔
  2443. ef_set_env_blob("dattim", &device_status.dattim, sizeof(device_status.dattim));
  2444. MA_save();
  2445. }
  2446. else {
  2447. rt_kprintf("设置失败!!!\n");
  2448. }
  2449. rt_kprintf("数据上传设置:%d\n",device_status.dattim);
  2450. }
  2451. //光控测试
  2452. else if(strstr(rx_buffer,"putTest.switchSun=1")!=NULL)
  2453. {
  2454. rt_kprintf("光控测试!!!");
  2455. ctr_lamp(ON,1);
  2456. device_status.sun_test = 1;
  2457. }
  2458. else if (strstr(rx_buffer,"setshake_sec=")!=NULL)
  2459. {
  2460. static char shakesec_str[4];
  2461. LOG_I("震动时间设置!");
  2462. var = strstr(rx_buffer,"=");
  2463. var ++;
  2464. strncpy(shakesec_str,var,2);
  2465. if(atoi(shakesec_str)>=0&&atoi(shakesec_str)<=10)
  2466. {
  2467. device_status.shake_sec =atoi(shakesec_str); //2026-0608:取消*10
  2468. }
  2469. else {
  2470. LOG_E("设置失败!!!");
  2471. }
  2472. LOG_D("震动时间设置:%d",device_status.shake_sec);
  2473. }
  2474. //恢复出厂设置电池
  2475. else if (strstr(rx_buffer,"resetdcDefault")!=NULL)
  2476. {
  2477. ResetParamDefault_DC();
  2478. rt_thread_delay(1000);
  2479. //2022/06/23,add: 操作记录改为局部缓冲(原 device_status.json_w_reset)
  2480. {
  2481. char json_warn[192];
  2482. rt_snprintf(json_warn, sizeof(json_warn),"屏幕操作:系统重置:电池供电,操作时间:%04d-%02d-%02d %02d:%02d:%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
  2483. json_temp = makeJson_Warn(json_warn, "系统重置");
  2484. ef_set_env_blob("json_w_reset", json_warn, strlen(json_warn) + 1); //将修改屏幕参数操作记录保存到Flash中
  2485. if(atoi(device_status.net)==0)
  2486. DTU_Write("%s",json_temp);
  2487. rt_free(json_temp);
  2488. }
  2489. }
  2490. //恢复出厂设置-交流
  2491. else if (strstr(rx_buffer,"resetDefault")!=NULL)
  2492. {
  2493. ResetParamDefault();
  2494. rt_thread_delay(1000);
  2495. //2022/06/23,add: 操作记录改为局部缓冲(原 device_status.json_w_reset)
  2496. {
  2497. char json_warn[192];
  2498. rt_snprintf(json_warn, sizeof(json_warn),"屏幕操作:系统重置:交流供电,操作时间:%04d-%02d-%02d %02d:%02d:%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
  2499. json_temp = makeJson_Warn(json_warn, "系统重置");
  2500. ef_set_env_blob("json_w_reset", json_warn, strlen(json_warn) + 1); //将修改屏幕参数操作记录保存到Flash中
  2501. if(atoi(device_status.net)==0)
  2502. DTU_Write("%s",json_temp);
  2503. rt_free(json_temp);
  2504. }
  2505. }
  2506. //获取SIM卡信息
  2507. else if(strstr(rx_buffer,"getSim")!=NULL)
  2508. {
  2509. //http://sim.openluat.com/api/wechat/openapidoc
  2510. DTU_Write("getsiminfo");
  2511. }
  2512. else if (strstr(rx_buffer,"DebugEnable")!=NULL) {
  2513. Debug_log_ON();
  2514. }
  2515. else if (strstr(rx_buffer,"DebugDisable")!=NULL) {
  2516. Debug_log_OFF();
  2517. }
  2518. /* Swversion 版本类型检测已并入本函数开头"页刷新/版本握手"统一入口块(先检测后刷新),原分支链移除 */
  2519. else if(strstr(rx_buffer,"DisplayPower")!=RT_NULL)
  2520. {
  2521. HMI_WRITE("sysTest.sysTest_power.txt=\"%s\"",device_status.power);
  2522. HMI_WRITE("sysTest.heat_txt.txt=\"%s\"",device_status.heat_power);
  2523. hmi_write_num_or_blank("sysTest.t1.txt=\"%s\"", device_status.work_heat_left, RT_FALSE); /* 剩余加热时间(s) */
  2524. hmi_write_num_or_blank("sysTest.t3.txt=\"%s\"", device_status.work_door_left, RT_FALSE); /* 仓门开/关倒计时(s) */
  2525. hmi_write_num_or_blank("sysTest.t0.txt=\"%s\"", device_status.photo_left, RT_FALSE); /* 拍照结束剩余(s) */
  2526. hmi_write_num_or_blank("sysTest.t5.txt=\"%s\"", device_status.clear_left, RT_FALSE); /* 清扫结束剩余(s) */
  2527. // HMI_WRITE("sysTest.switchHeat.val=%d",device_status.heat_status);
  2528. }
  2529. //立即上传
  2530. else if(strstr(rx_buffer,"uploaddata")!=RT_NULL)
  2531. {
  2532. UpLoad_Data();
  2533. }
  2534. else if (strstr(rx_buffer,"checkupdate")!=NULL)
  2535. {
  2536. time_t now = time(RT_NULL);
  2537. static struct tm tm;
  2538. gmtime_r(&now, &tm);
  2539. HMI_WRITE("hardcheck.tip_rtc.txt=\"%04d-%02d-%02d %02d:%02d:%02d\"",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
  2540. HMI_WRITE("hardcheck.p0.pic=%d",70);
  2541. //RTC时间判断,如果当前年份小于2020,提示需要设置时间
  2542. if(tm.tm_year+1900<2020)
  2543. {
  2544. rt_kprintf("时间未设置:%04d-%02d-%02d %02d:%02d:%02d\n",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
  2545. HMI_WRITE("hardcheck.tip_rtc.txt=%04d-%02d-%02d %02d:%02d:%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
  2546. }
  2547. }
  2548. //进入bootloader模式
  2549. else if (strstr(rx_buffer,"bootloader")!=NULL) {
  2550. device_status.stop_in_bootloader = 1;
  2551. ef_set_env_blob("stop_in_bootloader", &device_status.stop_in_bootloader, sizeof(device_status.stop_in_bootloader));
  2552. rt_hw_cpu_reset();
  2553. }
  2554. /* ★ "dtu_reboot" 里包含 "reboot", 原来 reboot 分支在前 -> 屏幕下发 dtu_reboot
  2555. 会走整机复位, RTU 重启指令永远发不出去。dtu_reboot 必须先判。 */
  2556. else if (strstr(rx_buffer,"dtu_reboot")!=NULL) {
  2557. DTU_Write("{\"cmd\": \"dtu_reboot\"}");
  2558. }
  2559. //软件重启
  2560. else if (strstr(rx_buffer,"reboot")!=NULL) {
  2561. rt_hw_cpu_reset();
  2562. }
  2563. else if (strstr(rx_buffer,"saveLog_usb")!=NULL) {
  2564. DTU_Write("{\"cmd\": \"saveLog_usb\"}");
  2565. }
  2566. //屏幕上触发远程升级
  2567. else if (strstr(rx_buffer,"hmi_update")!=NULL) {
  2568. }else if (strstr(rx_buffer,"SaveRecordParam")!=NULL){
  2569. //"SaveRecordParam:10000-200"
  2570. int param1, param2;
  2571. // 从冒号后开始扫描
  2572. if (sscanf(rx_buffer + strlen("SaveRecordParam:"), "%d-%d", &param1, &param2) == 2) {
  2573. /* ★ 原 itoa(param1, temp_val_pic, 10) 写 char[10]: 10 位十进制(或负值 11 字节)
  2574. 直接踩栈, itoa 不做容量检查。负数是非法参数, 直接丢弃。 */
  2575. char temp_val_mqtt[12],temp_val_pic[12];
  2576. if (param1 < 0 || param2 < 0) {
  2577. LOG_E("Invalid record param:%d-%d", param1, param2);
  2578. return;
  2579. }
  2580. rt_snprintf(temp_val_pic, sizeof(temp_val_pic), "%d", param1);
  2581. rt_snprintf(temp_val_mqtt, sizeof(temp_val_mqtt), "%d", param2);
  2582. /* ★ 原来 DTU_Write(write_record_param) 把 JSON 当格式串(内容含 '-' 等无所谓,
  2583. 但一旦含 '%' 就会被 vsnprintf 当格式说明符) -> 统一走 dtu_write_json */
  2584. dtu_write_json(makeJson_record_write(temp_val_mqtt,temp_val_pic));
  2585. } else {
  2586. LOG_E("Parse failed.\n");
  2587. }
  2588. }
  2589. else if (strstr(rx_buffer,"ReadRecordParam")!=NULL){
  2590. LOG_I("读离线存储参数");
  2591. dtu_write_json(makeJson_record_read("data"));
  2592. }
  2593. else if (strstr(rx_buffer,"checkcamera")!=NULL){
  2594. DTU_Write("{\"ctr_cam\":\"checkcamera\"}");
  2595. //校准屏幕的RTC
  2596. HMI_WRITE("rtc0=%d",tm.tm_year+1900);
  2597. HMI_WRITE("rtc1=%d",tm.tm_mon+1);
  2598. HMI_WRITE("rtc2=%d",tm.tm_mday);
  2599. HMI_WRITE("rtc3=%d",tm.tm_hour);
  2600. HMI_WRITE("rtc4=%d",tm.tm_min);
  2601. HMI_WRITE("rtc5=%d",tm.tm_sec);
  2602. //开启超时定时器
  2603. Start_timer_Uart2();
  2604. }else if (strstr(rx_buffer,"ReadCamParam")!=NULL){
  2605. DTU_Write("{\"ctr_cam\":\"ReadParam\"}");
  2606. //开启超时定时器
  2607. Start_timer_Uart2();
  2608. }//SaveCamParam:2070.00000-0.7-144-30-0-0-5472*5472
  2609. else if (strstr(rx_buffer,"SaveCamParam")!=NULL){
  2610. const char *prefix ="SaveCamParam:";
  2611. size_t prefix_len = strlen(prefix);
  2612. const char *start_pos = strstr(rx_buffer, prefix);
  2613. if(start_pos!=NULL)
  2614. {
  2615. // 移动到前缀之后的位置
  2616. start_pos += prefix_len;
  2617. /* ★ makeJson_Cam 的返回值原来没人释放 -> 每次点"保存相机参数"漏一块堆。
  2618. (start_pos 是 const char*, 与 makeJson_Cam(char*,char*) 的形参有 const 冲突,
  2619. 这里做一次显式转换消除 -Wdiscarded-qualifiers) */
  2620. dtu_write_json(makeJson_Cam("SaveParam", (char *)start_pos));
  2621. }
  2622. //开启超时定时器
  2623. Start_timer_Uart2();
  2624. }else if (strstr(rx_buffer,"GrabOn")!=NULL){
  2625. DTU_Write("{\"ctr_cam\":\"GrabOn\"}");
  2626. //开启超时定时器
  2627. Start_timer_Uart2();
  2628. }else if (strstr(rx_buffer,"GrabOff")!=NULL){
  2629. DTU_Write("{\"ctr_cam\":\"GrabOff\"}");
  2630. //开启超时定时器
  2631. Start_timer_Uart2();
  2632. }
  2633. else if(strstr(rx_buffer,"SelfCheck")!=NULL)
  2634. {
  2635. //校准屏幕的RTC
  2636. HMI_WRITE("rtc0=%d",tm.tm_year+1900);
  2637. HMI_WRITE("rtc1=%d",tm.tm_mon+1);
  2638. HMI_WRITE("rtc2=%d",tm.tm_mday);
  2639. HMI_WRITE("rtc3=%d",tm.tm_hour);
  2640. HMI_WRITE("rtc4=%d",tm.tm_min);
  2641. HMI_WRITE("rtc5=%d",tm.tm_sec);
  2642. if(device_status.selfcheck_ws==2||device_status.selfcheck_ws==3)
  2643. {
  2644. LOG_I("自检进行中!");
  2645. }else {
  2646. device_status.selfcheck_ws = 2;
  2647. LOG_W("开始自检:%d",device_status.selfcheck_ws);
  2648. }
  2649. }else if(strstr(rx_buffer,"SwitchMode")!=NULL)
  2650. {
  2651. device_status.work_mode = !device_status.work_mode;
  2652. ef_set_env_blob("work_mode", &device_status.work_mode, sizeof(device_status.work_mode));
  2653. LOG_W("修改工作模式:%d",device_status.work_mode);
  2654. }else if(strstr(rx_buffer,"DeleteUimage")!=NULL){
  2655. /* ★ 原来 DTU_Write(temp) 把 JSON 当格式串; 统一走 dtu_write_json("%s" + 判空 + 自动释放) */
  2656. dtu_write_json(makeJsonRpc2_0("upan_delete_image", NULL, 1));
  2657. }else if(strstr(rx_buffer,"MOVE_IMAGE")!=NULL){
  2658. dtu_write_json(makeJsonRpc2_0("MOVE_IMAGE", NULL, 1));
  2659. }else if(strstr(rx_buffer,"COPY_IMAGE")!=NULL){
  2660. cJSON *params = cJSON_CreateObject(); // params 子对象
  2661. if (params == RT_NULL) {
  2662. LOG_E("COPY_IMAGE: create params failed (no memory)");
  2663. } else {
  2664. cJSON_AddNumberToObject(params, "st", device_status.startBar); // st:20
  2665. cJSON_AddNumberToObject(params, "et", device_status.stopBar); // et:7
  2666. dtu_write_json(makeJsonRpc2_0("COPY_IMAGE", params, 1));
  2667. }
  2668. }else if(strstr(rx_buffer,"UMOUNT_UPAN")!=NULL){
  2669. dtu_write_json(makeJsonRpc2_0("UMOUNT_UPAN", NULL, 1));
  2670. }
  2671. /* 一屏指令处理完, 若有参数变更则同步进参数镜像(内容未变则不擦写) */
  2672. param_mirror_sync();
  2673. }
  2674. //入口函数-电机控制及
  2675. static void Ctr_Mortor_entry(void* parameter)
  2676. {
  2677. rt_uint16_t num_up_open = 200; //20s 上仓门打开时间
  2678. rt_uint16_t num_up_close = 200; // 上仓门关闭时间
  2679. rt_uint16_t num_down_open = 200; // 下仓门打开时间
  2680. rt_uint16_t num_down_close = 200; // 下仓门关闭时间
  2681. rt_int16_t photo_led_sec = 900; //55S
  2682. static rt_uint16_t mock_uart2_timer_cnt = 0;
  2683. static rt_uint16_t route_off_t = 0;
  2684. device_status.route_off_t = 0;
  2685. static uint8_t is_rain = 0;
  2686. static uint8_t isnot_rain = 0;
  2687. rt_pin_mode(CTR_UPC_LIMIT, PIN_MODE_INPUT);
  2688. while(1)
  2689. {
  2690. #if 0
  2691. time_t time_reset12V;
  2692. time(&time_reset12V);
  2693. static struct tm alarm_reset12V;
  2694. alarm_reset12V =*localtime(&time_reset12V);
  2695. if((alarm_reset12V.tm_hour)==8&&(alarm_reset12V.tm_min==18)&&(alarm_reset12V.tm_sec==00))
  2696. {
  2697. char *rep = makeJsonRpc2_0("reboot",NULL, 1);
  2698. /* ★ 第四批: DTU_Write 是变参函数, 原来直接传 rep 等于"拿 JSON 当格式串"。
  2699. 统一走 dtu_write_json(固定 "%s" + 判空 + 自动释放)。 */
  2700. dtu_write_json(rep);
  2701. rt_thread_delay(1000);
  2702. }
  2703. if(device_status.mock_uart2_timer_flag==1){
  2704. mock_uart2_timer_cnt++;
  2705. if(mock_uart2_timer_cnt>=200){
  2706. mock_uart2_timer_cnt = 0;
  2707. device_status.mock_uart2_timer_flag = 0;
  2708. }
  2709. }
  2710. #endif
  2711. if(device_status.ctr_up_motor==1)
  2712. {
  2713. ctr_cangmen_up(OPEN);
  2714. num_up_open--;
  2715. if (num_up_open == 0)
  2716. {
  2717. #if JINGJIKUAN == 0
  2718. ctr_cangmen_up(OFF);
  2719. #else
  2720. device_status.ctr_up_motor = 0;
  2721. #endif
  2722. num_up_open = 200;
  2723. system_status.upper_door_open_count +=1;
  2724. }
  2725. num_up_close = 200;
  2726. }
  2727. else if(device_status.ctr_up_motor==2)
  2728. {
  2729. ctr_cangmen_up(CLOSE);
  2730. num_up_close --;
  2731. if (num_up_close == 0)
  2732. {
  2733. #if JINGJIKUAN == 0
  2734. ctr_cangmen_up(OFF);
  2735. #else
  2736. device_status.ctr_up_motor = 0;
  2737. #endif
  2738. num_up_close= 200;
  2739. system_status.upper_door_close_count +=1;
  2740. }
  2741. num_up_open = 200;
  2742. }
  2743. if (device_status.ctr_down_motor == 1)
  2744. {
  2745. ctr_cangmen_down(OPEN);
  2746. num_down_open--;
  2747. #if TG_MODULE ==1
  2748. if(rt_pin_read(CTR_UPC_LIMIT)==1){
  2749. ctr_cangmen_down(OFF);
  2750. Beep_Tip(2000);
  2751. ctr_cangmen_down(OPEN);
  2752. Beep_Tip(2000);
  2753. num_down_open = 200;
  2754. device_status.ctr_down_motor = 1;
  2755. }
  2756. #endif
  2757. if (num_down_open == 0) //2025-07-07,增加限位检测
  2758. {
  2759. #if JINGJIKUAN == 0
  2760. ctr_cangmen_down(OFF);
  2761. #else
  2762. device_status.ctr_down_motor = 0;
  2763. #endif
  2764. num_down_open = 200;
  2765. system_status.lower_door_open_count +=1;
  2766. }
  2767. num_down_close = 200;
  2768. }
  2769. else if (device_status.ctr_down_motor == 2)
  2770. {
  2771. ctr_cangmen_down(CLOSE);
  2772. num_down_close--;
  2773. if (num_down_close == 0)
  2774. {
  2775. #if JINGJIKUAN == 0
  2776. ctr_cangmen_down(OFF);
  2777. #else
  2778. device_status.ctr_down_motor = 0;
  2779. #endif
  2780. num_down_close = 200;
  2781. system_status.lower_door_close_count += 1;
  2782. }
  2783. num_down_open = 200;
  2784. }
  2785. /* 屏幕 workSta.t3:仓门开(关)动作倒计时(s);无动作时清零 */
  2786. if(device_status.ctr_up_motor == 1) device_status.work_door_left = (uint16_t)(num_up_open / 10);
  2787. else if(device_status.ctr_up_motor == 2) device_status.work_door_left = (uint16_t)(num_up_close / 10);
  2788. else if(device_status.ctr_down_motor == 1) device_status.work_door_left = (uint16_t)(num_down_open / 10);
  2789. else if(device_status.ctr_down_motor == 2) device_status.work_door_left = (uint16_t)(num_down_close / 10);
  2790. else device_status.work_door_left = 0;
  2791. if(device_status.sun_test==1)
  2792. {
  2793. SunTest();
  2794. }
  2795. //拍照
  2796. if(device_status.photo_ws==1)
  2797. {
  2798. struct timeval tv;
  2799. gettimeofday(&tv, NULL);
  2800. device_status.photo_stamp = tv.tv_sec-8*3600;
  2801. if(photo_led_sec==900)
  2802. ctr_led(ON);
  2803. //打开补光灯
  2804. if(photo_led_sec==800)
  2805. {
  2806. system_status.photo_taken_count+=1;
  2807. LOG_I("测试拍照!");
  2808. #if 1
  2809. char *takephotojson = makeJson_takephoto();
  2810. DTU_Write("%s",takephotojson);
  2811. rt_free(takephotojson);
  2812. #endif
  2813. rt_thread_delay(5000); //延时
  2814. }
  2815. //15S后执行拍照
  2816. else if (photo_led_sec==750)
  2817. {
  2818. //DTU_Write("takephoto.mp3");
  2819. //延时
  2820. rt_thread_delay(1000);
  2821. LOG_I("测试拍照!");
  2822. Hk_Take_io();
  2823. }
  2824. photo_led_sec--;
  2825. /* 屏幕 workSta.t5:拍照结束剩余(s)。photo_led_sec 900->300 段倒计时 60s->0 */
  2826. device_status.photo_left = (photo_led_sec > 300) ? (uint16_t)((photo_led_sec - 300) / 10) : 0;
  2827. if(photo_led_sec==300) //
  2828. {
  2829. ctr_led(OFF);
  2830. device_status.photo_ws = 0;
  2831. photo_led_sec = 900;
  2832. device_status.photo_left = 0;
  2833. if(device_status.test_flag==0){
  2834. device_status.clear_status = 1;
  2835. }else{
  2836. device_status.test_flag = 0;
  2837. }
  2838. HMI_WRITE("sysTest.switchPhoto.val=0");
  2839. HMI_WRITE("sysTest.switchFill.val=0");
  2840. }
  2841. }else{
  2842. photo_led_sec = 900;
  2843. device_status.photo_left = 0;
  2844. }
  2845. if(device_status.selfcheck_ws==2)
  2846. {
  2847. selfcheck(1);
  2848. }else if (device_status.selfcheck_ws==3) {
  2849. selfcheck(0);
  2850. }
  2851. if(device_status.route_off_t!=0)
  2852. {
  2853. ctr_router(OFF);
  2854. route_off_t = device_status.route_off_t * 60 * 10;
  2855. device_status.route_off_t = 0;
  2856. }
  2857. if(route_off_t>0)
  2858. {
  2859. route_off_t--;
  2860. if(route_off_t==1)
  2861. {
  2862. ctr_router(ON);
  2863. route_off_t = 0;
  2864. }
  2865. }
  2866. #if JINGJIKUAN == 1
  2867. if(device_status.rain_status==1){
  2868. isnot_rain = 0;
  2869. if(is_rain==0){
  2870. ctr_Collect_Fan(OFF); //触发雨控
  2871. rt_thread_delay(2000);
  2872. device_status.ctr_up_motor = 2; //关闭上仓门
  2873. is_rain = 1;
  2874. }
  2875. }else{
  2876. is_rain = 0;
  2877. if(isnot_rain == 0){
  2878. ctr_Collect_Fan(ON); //解除雨控
  2879. isnot_rain = 1;
  2880. }
  2881. }
  2882. #endif
  2883. /* 屏幕刷新重复过滤表:到点(每 HMI_DEDUPE_RESYNC_SEC 秒)整体复位一次,
  2884. 保证屏幕重启/换页后最迟该周期内恢复全量刷新(详见 HMI_WRITE 处说明) */
  2885. hmi_dedupe_tick();
  2886. rt_thread_delay(100);
  2887. }
  2888. }
  2889. /*屏幕写数据*/
  2890. int Hmi_Fresh(void)
  2891. {
  2892. //初始化串口4
  2893. //HMI_uart4_init();
  2894. rt_err_t ret = RT_EOK;
  2895. /* 初始化消息队列 */
  2896. rt_mq_init(&rx_mq, "rx_mq",
  2897. msg_pool, /* 存放消息的缓冲区 */
  2898. sizeof(struct rx_msg), /* 一条消息的最大长度 */
  2899. sizeof(msg_pool), /* 存放消息的缓冲区大小 */
  2900. RT_IPC_FLAG_FIFO); /* 如果有多个线程等待,按照先来先得到的方法分配消息 */
  2901. /* 设置接收回调函数(★ 原来未判空: 屏幕串口设备名配错/未注册时
  2902. rt_device_find() 返回 NULL, 这里直接解引用空设备句柄) */
  2903. if (serial != RT_NULL)
  2904. {
  2905. rt_device_set_rx_indicate(serial, uart_input);
  2906. }
  2907. /* 创建线程*/
  2908. hmi1 = rt_thread_create("Hmi_Fresh_thread",
  2909. Hmi_thread_entry,
  2910. RT_NULL,
  2911. HMI_THREAD_STACK_SIZE,
  2912. HMI_THREAD_PRIORITY,
  2913. HMI_THREAD_TIMESLICE);
  2914. /*部分控制的线程*/
  2915. ctr_motor = rt_thread_create("Ctr motor",
  2916. Ctr_Mortor_entry,
  2917. RT_NULL,
  2918. CONTROL_MOTOR_STACK_SIZE,
  2919. CONTROL_MOTOR_PRIORITY,
  2920. CONTROL_MOTOR_TIMESLICE);
  2921. if(ctr_motor != RT_NULL)
  2922. {
  2923. rt_thread_startup(ctr_motor);
  2924. }
  2925. /* 如果获得线程控制块,启动这个线程 */
  2926. if (hmi1 != RT_NULL)
  2927. {
  2928. rt_thread_startup(hmi1);
  2929. }
  2930. else
  2931. {
  2932. ret = RT_ERROR;
  2933. }
  2934. return ret;
  2935. }
  2936. void Check_ParamConfig(void)
  2937. {
  2938. time_t now = time(RT_NULL);
  2939. static struct tm tm;
  2940. gmtime_r(&now, &tm);
  2941. int ef_ok = 0; /* EasyFlash 是否可用 */
  2942. int up_flag_ef = 0; /* EasyFlash 里的升级请求(iSave 丢失时保留) */
  2943. /* ★ flash 健康检查门控(2026-09-24 加固)
  2944. SPI flash 探测失败(虚焊/击穿/SPI 不通)时, 原链路会一路"假装正常":
  2945. fal 建出合法分区 -> easyflash_init 返回成功 -> 第一次读就 sfud_read(NULL,...)
  2946. 空指针解引用 -> hard fault, 而日志停在 ENV 打印之后, 跟栈溢出极难区分。
  2947. 这里在开机最前面显式判 flash 可用性: 不 ready 就完全不碰 EasyFlash,
  2948. 用 RAM 默认值降级启动, 设备照样能干活、能上报故障, 而不是变砖。 */
  2949. if(!nor_flash0_is_ready())
  2950. {
  2951. LOG_E("!! SPI FLASH NOT READY - degraded boot, params live in RAM only");
  2952. /* 三声短鸣: 现场靠声音就知道是存储故障, 不用接串口 */
  2953. Beep_Tip(200);
  2954. rt_thread_mdelay(300);
  2955. Beep_Tip(200);
  2956. rt_thread_mdelay(300);
  2957. Beep_Tip(200);
  2958. }
  2959. else if(easyflash_init()==EF_NO_ERR) //初始化成功
  2960. {
  2961. ef_ok = 1;
  2962. ef_get_env_blob("reboot_time", &device_status.rebootcnt, sizeof(device_status.rebootcnt), NULL); //读出reboot_time的值
  2963. ef_get_env_blob("update_flag", &device_status.update_flag, sizeof(device_status.update_flag), NULL); //读出updateflag的值
  2964. up_flag_ef = (device_status.update_flag != 0) ? 1 : 0;
  2965. ef_get_env_blob("iSave", &device_status.iSave, sizeof(device_status.iSave), NULL); //判断是否用户配置了程序
  2966. device_status.rebootcnt++;
  2967. /* ★ 原实现每次开机都写一条 reboot_time。EasyFlash 是追加式 KV,每次写占
  2968. 一条记录并推动扇区轮换/GC,属持续写放大,而且正好落在上电/复位最不稳的
  2969. 时刻。同步 master 1.85:每 10 次落盘一次(落盘值 1,11,21…,断电最多倒退
  2970. 9 次计数)。
  2971. ⚠️ param_mirror 的 payload 不含 rebootcnt(与 master 布局一致),
  2972. 所以这条计数只能走 EasyFlash,不能再依赖参数快照延迟落盘。 */
  2973. if ((device_status.rebootcnt % 10) == 1)
  2974. {
  2975. ef_set_env_blob("reboot_time", &device_status.rebootcnt, sizeof(device_status.rebootcnt));
  2976. }
  2977. LOG_I("REBOOT_TIME:%d-%d-%d",device_status.rebootcnt,device_status.iSave,device_status.update_flag);
  2978. }
  2979. else {
  2980. LOG_E("easyflash init ERRPR!!!");
  2981. }
  2982. /* ★ iSave 是整机参数的唯一哨兵: 它一旦丢失, 下面这个分支会把全部参数
  2983. 刷成出厂值(现场表现为"重启后参数全没")。这里先用参数镜像抢救一次,
  2984. 把"丢一条 iSave -> 全量回出厂"拦在前面(与 master 同一策略)。
  2985. 镜像无效时不做任何事, 继续走下面的默认值分支。 */
  2986. if (device_status.iSave != FLASH_FLAG)
  2987. {
  2988. param_payload_t boot_mirror;
  2989. if (param_mirror_load(&boot_mirror) == RT_EOK)
  2990. {
  2991. LOG_W("iSave lost but mirror is valid (seq=%u), recovering",
  2992. (unsigned)boot_mirror.write_seq);
  2993. mirror_to_device_status(&boot_mirror);
  2994. /* iSave 现在已是 FLASH_FLAG;置 iFlag=0 与"正常读取用户配置"路径语义一致 */
  2995. device_status.iFlag = 0;
  2996. }
  2997. }
  2998. //保存默认配置
  2999. if(device_status.iSave!=FLASH_FLAG)
  3000. {
  3001. device_status.iSave=FLASH_FLAG;
  3002. device_status.iFlag = 1;
  3003. /*设备类型,7孢子仪,3测报灯,默认设置测报灯*/
  3004. device_status.dtype = 3;
  3005. device_status.version_type = 4; //4.0
  3006. device_status.Power_Type = 0; //0-交流供电;1-直流供电
  3007. device_status.clt_time = 6; //收集时间
  3008. device_status.heattime = 8; //加热时间
  3009. device_status.heatvalue=100; //加热温度
  3010. device_status.thsp = 300; //默认熄屏时间5分钟
  3011. device_status.sunBar = 9; //光控定时时长
  3012. device_status.startBar = 20; //定时开始时间
  3013. device_status.stopBar = 0; //定时结束时间
  3014. device_status.tph = 70; //高温保护阈值
  3015. device_status.tpl = 5; //低温保护阈值
  3016. device_status.shake_ws = 1; //震动开关,默认开
  3017. #if TG_MODULE == 0
  3018. device_status.shake_sec = 1; //震动时间,s
  3019. #else
  3020. device_status.shake_sec = 2; //震动时间,s
  3021. #endif
  3022. device_status.vol = 7; //音量
  3023. device_status.timeSwitch = 0; //工作模式:光控
  3024. device_status.passWord = 8888; //屏幕密码
  3025. device_status.dattim = 10; //数据上传间隔
  3026. device_status.ds = 1; //设备状态
  3027. /* ★ 原代码在这里无条件把 update_flag 清 0。
  3028. 走到这个分支只说明 iSave 这条 env 丢了(EasyFlash 局部损坏),
  3029. 并不代表升级请求是假的 —— 现场表现就是:
  3030. 参数丢了 -> 升级标志被顺手抹掉 -> 触发升级后重启静静跳过升级。
  3031. 这里保留已从 EasyFlash 读到的升级请求。
  3032. ⚠️ param_mirror 的 payload 不含 update_flag(与 master 布局一致),
  3033. 原先"参数快照里再存一份升级请求"的通道随 param_backup 一并移除。 */
  3034. device_status.update_flag = (up_flag_ef != 0) ? 1 : 0;
  3035. /*孢子仪*/
  3036. device_status.collecting_sh1 = 9;
  3037. device_status.collecting_eh1 = 10;
  3038. device_status.collecting_sh2 = 14;
  3039. device_status.collecting_eh2 = 16;
  3040. device_status.motor_active = 0;
  3041. device_status.heat_sw = 0;
  3042. device_status.cul_time = 1;
  3043. device_status.run_sta = 0;
  3044. device_status.handle_bugger = 0; //默认排虫
  3045. device_status.work_mode = 0;
  3046. sprintf(device_status.driver, "%s",VERSION_HK);
  3047. sprintf(device_status.deviceId,"0");
  3048. rt_sprintf(device_status.tempture, "-15");
  3049. rt_sprintf(device_status.humidity, "31");
  3050. rt_sprintf(device_status.mqttcfg1, "8.136.98.49");
  3051. rt_sprintf(device_status.alarm_tg,"220000");
  3052. /* ★ 以下 32 连写只在 EasyFlash 可用时执行。
  3053. flash 坏了硬写只会拿到一堆 EF_WRITE_ERR, 还可能触发 EasyFlash 内部 GC
  3054. (GC 中途失败会 format 掉整个 sector)。默认值已经写进 RAM 了,
  3055. 设备用出厂参数降级运行即可。 (内部未重新缩进, 保持与原代码逐行对齐) */
  3056. if (ef_ok)
  3057. {
  3058. ef_set_env_blob("iSave", &device_status.iSave, sizeof(device_status.iSave)); //
  3059. ef_set_env_blob("ds", &device_status.ds, sizeof(device_status.ds));
  3060. ef_set_env_blob("stime", &device_status.clt_time, sizeof(device_status.clt_time));
  3061. ef_set_env_blob("startBar", &device_status.startBar, sizeof(device_status.startBar));
  3062. ef_set_env_blob("stopBar", &device_status.stopBar, sizeof(device_status.stopBar));
  3063. ef_set_env_blob("timeSwitch", &device_status.timeSwitch, sizeof(device_status.timeSwitch));
  3064. ef_set_env_blob("sunBar", &device_status.sunBar, sizeof(device_status.sunBar));
  3065. ef_set_env_blob("jtime", &device_status.heattime, sizeof(device_status.heattime));
  3066. ef_set_env_blob("jheat", &device_status.heatvalue, sizeof(device_status.heatvalue));
  3067. ef_set_env_blob("tph", &device_status.tph, sizeof(device_status.tph));
  3068. ef_set_env_blob("tpl", &device_status.tpl, sizeof(device_status.tpl));
  3069. ef_set_env_blob("shake_ws", &device_status.shake_ws, sizeof(device_status.shake_ws)); //震动开关
  3070. ef_set_env_blob("shake_sec", &device_status.shake_sec, sizeof(device_status.shake_sec)); //震动时间
  3071. ef_set_env_blob("thsp", &device_status.thsp, sizeof(device_status.thsp));
  3072. ef_set_env_blob("passWord", &device_status.passWord,sizeof(device_status.passWord));
  3073. ef_set_env_blob("dattim",&device_status.dattim,sizeof(device_status.dattim)); //上传时间
  3074. ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type)); //版本类型
  3075. ef_set_env_blob("env_t",&device_status.tempture,sizeof(device_status.tempture)); //温度
  3076. ef_set_env_blob("env_h",&device_status.humidity,sizeof(device_status.humidity)); //湿度
  3077. ef_set_env_blob("platform",&device_status.mqttcfg1,sizeof(device_status.mqttcfg1)); //上传平台
  3078. ef_set_env_blob("cul_time",&device_status.cul_time,sizeof(device_status.cul_time)); //采集时间
  3079. ef_set_env_blob("motor_active",&device_status.motor_active,sizeof(device_status.motor_active)); //制冷开关
  3080. ef_set_env_blob("heat_sw",&device_status.heat_sw,sizeof(device_status.heat_sw)); //加热开关
  3081. ef_set_env_blob("collecting_sh1",&device_status.collecting_sh1,sizeof(device_status.collecting_sh1)); //风机开关
  3082. ef_set_env_blob("collecting_eh1",&device_status.collecting_eh1,sizeof(device_status.collecting_eh1)); //采集时间
  3083. ef_set_env_blob("collecting_sh2",&device_status.collecting_sh2,sizeof(device_status.collecting_sh2)); //采集时间
  3084. ef_set_env_blob("collecting_eh2",&device_status.collecting_eh2,sizeof(device_status.collecting_eh2)); //采集时间
  3085. ef_set_env_blob("run_sta", &device_status.run_sta, sizeof(device_status.run_sta)); //
  3086. ef_set_env_blob("Power_Type", &device_status.Power_Type, sizeof(device_status.Power_Type));
  3087. ef_set_env_blob("handle_bugger", &device_status.handle_bugger, sizeof(device_status.handle_bugger));
  3088. ef_set_env_blob("work_mode", &device_status.work_mode, sizeof(device_status.work_mode));
  3089. ef_set_env_blob("alarm_tg", &device_status.alarm_tg, sizeof(device_status.alarm_tg));
  3090. } /* if (ef_ok) —— flash 不可用时整段跳过 */
  3091. LOG_I("SOFTWARE VERSION:%s",device_status.driver);
  3092. LOG_I("Default paramconf is:");
  3093. LOG_I("stime:%d",device_status.iSave);
  3094. LOG_I("stime:%d",device_status.clt_time);
  3095. LOG_I("startBar:%d",device_status.startBar);
  3096. LOG_I("stopBar:%d",device_status.stopBar);
  3097. LOG_I("timeSwitch:%d",device_status.timeSwitch);
  3098. LOG_I("sunBar:%d",device_status.sunBar);
  3099. LOG_I("jtime:%d",device_status.heattime);
  3100. LOG_I("jheat:%d",device_status.heatvalue);
  3101. LOG_I("thsp:%d", device_status.thsp);
  3102. LOG_I("passwd:%d",device_status.passWord);
  3103. LOG_I("alarm_tg:%s",device_status.alarm_tg);
  3104. /* 用刚刚写入 EF 的同一套默认值初始化参数镜像。
  3105. 此后所有参数变更路径都会调用 param_mirror_sync() 保持镜像与 EF 同步。 */
  3106. param_mirror_sync();
  3107. }//从easyflash读取参数配置
  3108. else if (device_status.iSave==FLASH_FLAG) {
  3109. /* 先尝试从参数镜像恢复。镜像里有 20 个关键标量字段,单条 env 丢失时
  3110. 不会直接露出过期默认值;镜像里没有的字段(imei/iccid/deviceId/
  3111. driver_bl/platform/env_t/env_h 等字符串)仍在下面从 EasyFlash 逐条读取。
  3112. ⚠️ 与 master 行为一致:下面的逐条读取会覆盖镜像值,镜像只对"读不到的键"生效。 */
  3113. param_payload_t mirror;
  3114. device_status.iFlag = 0;
  3115. if (param_mirror_load(&mirror) == RT_EOK)
  3116. {
  3117. LOG_I("param mirror loaded (seq=%u)", (unsigned)mirror.write_seq);
  3118. mirror_to_device_status(&mirror);
  3119. }
  3120. else
  3121. {
  3122. LOG_W("param mirror unavailable, falling back to EF single-key");
  3123. }
  3124. ef_get_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype),NULL); //设备类型
  3125. ef_get_env_blob("dattim",&device_status.dattim,sizeof(device_status.dattim),NULL); //数据上传间隔
  3126. ef_get_env_blob("stime", &device_status.clt_time, sizeof(device_status.clt_time), NULL); //收集时间
  3127. ef_get_env_blob("startBar", &device_status.startBar,sizeof(device_status.startBar), NULL); //开始时间
  3128. ef_get_env_blob("stopBar", &device_status.stopBar, sizeof(device_status.stopBar), NULL); //结束时间
  3129. ef_get_env_blob("timeSwitch", &device_status.timeSwitch, sizeof(device_status.timeSwitch), NULL); //模式
  3130. ef_get_env_blob("sunBar", &device_status.sunBar, sizeof(device_status.sunBar), NULL); //光控时间
  3131. ef_get_env_blob("jtime", &device_status.heattime, sizeof(device_status.heattime), NULL); //加热时间
  3132. /* heatvalue 这一个字段承载了两种语义, 写入侧也分成了两个 key:
  3133. 测报灯(dtype!=7): 加热温度 -> key "jheat" (hmi.c 系统设置页)
  3134. 孢子仪(dtype==7): 培养温度 -> key "heatvalue" (hmi.c 孢子仪系统设置)
  3135. 老代码开机一律读 jheat, 孢子仪设好的培养温度重启后会被 jheat 的值顶掉,
  3136. 现场表现就是"温度设了没保存住"。这里按 dtype 分开读;
  3137. 老设备 flash 里还没有 heatvalue 这个 key 时回退读 jheat, 避免读到 0。 */
  3138. if (device_status.dtype == 7) {
  3139. if (ef_get_env_blob("heatvalue", &device_status.heatvalue, sizeof(device_status.heatvalue), NULL) == 0) {
  3140. ef_get_env_blob("jheat", &device_status.heatvalue, sizeof(device_status.heatvalue), NULL); //兼容老固件
  3141. }
  3142. } else {
  3143. ef_get_env_blob("jheat", &device_status.heatvalue, sizeof(device_status.heatvalue), NULL); //加热温度
  3144. }
  3145. ef_get_env_blob("shake_ws", &device_status.shake_ws, sizeof(device_status.shake_ws), NULL); //震动开关
  3146. ef_get_env_blob("shake_sec", &device_status.shake_sec, sizeof(device_status.shake_sec), NULL); //震动时间
  3147. ef_get_env_blob("tph", &device_status.tph, sizeof(device_status.tph), NULL); //高温保护
  3148. ef_get_env_blob("tpl", &device_status.tpl, sizeof(device_status.tpl), NULL); //低温保护
  3149. ef_get_env_blob("dattim", &device_status.dattim, sizeof(device_status.dattim), NULL); //数据上传间隔
  3150. ef_get_env_blob("thsp", &device_status.thsp, sizeof(device_status.thsp), NULL); //熄屏时间
  3151. ef_get_env_blob("passWord",&device_status.passWord,sizeof(device_status.passWord),NULL); //密码
  3152. ef_get_env_blob("imei",&device_status.imei,sizeof(device_status.imei),NULL); //IMEI
  3153. ef_get_env_blob("iccid",&device_status.iccid,sizeof(device_status.iccid),NULL); //ICCID
  3154. ef_get_env_blob("lat",&device_status.lat,sizeof(device_status.lat),NULL);
  3155. ef_get_env_blob("lng",&device_status.lng,sizeof(device_status.lng),NULL);
  3156. ef_get_env_blob("ds",&device_status.ds,sizeof(device_status.ds),NULL); //开关机状态
  3157. ef_get_env_blob("env_t",&device_status.tempture,sizeof(device_status.tempture),NULL); //环境温度
  3158. ef_get_env_blob("env_h",&device_status.humidity,sizeof(device_status.humidity),NULL); //环境湿度
  3159. /* json_w_clock/json_w_reset/json_w_platform 已无对应全局字段,开机不再回读 */
  3160. ef_get_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type),NULL); //版本类型
  3161. ef_get_env_blob("driver_bl",&device_status.driver_bl,sizeof(device_status.driver_bl),NULL); //BL版本号 进BL的时候存储到FLASH
  3162. ef_get_env_blob("platform",&device_status.mqttcfg1,sizeof(device_status.mqttcfg1),NULL); //平台地址
  3163. /*孢子仪*/
  3164. ef_get_env_blob("cul_time",&device_status.cul_time,sizeof(device_status.cul_time),NULL); //培养时间
  3165. ef_get_env_blob("motor_active",&device_status.motor_active,sizeof(device_status.motor_active),NULL); //电机
  3166. ef_get_env_blob("heat_sw",&device_status.heat_sw,sizeof(device_status.heat_sw),NULL); //加热开关
  3167. /* 制冷开关: 孢子仪设置页(hmi.c 系统设置, dtype==7)只写了这个 key,
  3168. 老代码开机却从来不读 —— 设置完一重启就丢。这里补上读取。
  3169. flash 里没有该 key 时 ef_get_env_blob 返回 0 且不清零 buf, 保持原值即可。 */
  3170. ef_get_env_blob("cold_sw",&device_status.cold_sw,sizeof(device_status.cold_sw),NULL); //制冷开关
  3171. ef_get_env_blob("run_sta",&device_status.run_sta,sizeof(device_status.run_sta),NULL); //运行状态
  3172. ef_get_env_blob("Power_Type",&device_status.Power_Type,sizeof(device_status.Power_Type),NULL); //供电类型
  3173. ef_get_env_blob("deviceId",&device_status.deviceId,sizeof(device_status.deviceId),NULL); //设备编码
  3174. ef_get_env_blob("handle_bugger",&device_status.handle_bugger,sizeof(device_status.handle_bugger),NULL); //排虫
  3175. ef_get_env_blob("work_mode",&device_status.work_mode,sizeof(device_status.work_mode),NULL); //工作模式
  3176. ef_get_env_blob("alarm_tg",&device_status.alarm_tg,sizeof(device_status.alarm_tg),NULL); //闹钟 //光控计数
  3177. device_status.work_done = 0;
  3178. /* 说明:原 param_backup 在这里做"整包健康自检 + 双分区回写 EF",
  3179. 已随 param_backup 一并移除。现在由上面开头的 param_mirror_load() 负责
  3180. iSave/关键标量的抢救,下面的补丁负责把明显不合理的 0 值修回可用值;
  3181. 两者合并后仍能覆盖"单条 env 丢失"的现场故障。 */
  3182. //丢参数的处理
  3183. if(device_status.sunBar==0) device_status.sunBar = 4;
  3184. if(device_status.dattim==0) device_status.dattim = 10;
  3185. if(device_status.thsp==0) device_status.thsp = 300;
  3186. if(device_status.clt_time==0) device_status.clt_time = 10;
  3187. if(device_status.heattime==0) device_status.heattime = 10;
  3188. if(device_status.heatvalue==0) device_status.heatvalue = 100;
  3189. if(device_status.tph==0){ //参数丢失
  3190. device_status.tpl = 5;
  3191. device_status.tph = 70;
  3192. device_status.ds = 1;
  3193. device_status.startBar = 20;
  3194. device_status.stopBar = 0;
  3195. }
  3196. if(device_status.work_mode>1) device_status.work_mode = 0;
  3197. /* ★ 上面这段补丁原来只改 RAM 不落盘, 所以每次重启都要重复丢、重复修。
  3198. 现在把修正后的值写进参数镜像(内容未变化时 param_mirror_sync 不擦写),
  3199. 下次开机镜像恢复时即可带回修正值。 */
  3200. param_mirror_sync();
  3201. /*设备类型,7孢子仪,3测报灯,默认设置测报灯*/
  3202. if(device_status.dtype!=7)
  3203. {
  3204. device_status.dtype = 3;
  3205. }
  3206. else {
  3207. device_status.version_type = 7;
  3208. }
  3209. if(device_status.version_type==0)
  3210. {
  3211. device_status.version_type = 4;
  3212. ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));
  3213. }
  3214. else if(device_status.version_type==1)
  3215. {
  3216. rt_sprintf(device_status.driver, "%s",VERSION_ZP);
  3217. }
  3218. else if (device_status.version_type==11)
  3219. {
  3220. rt_sprintf(device_status.driver, "%s",VERSION_GK);
  3221. }
  3222. else if (device_status.version_type==4||device_status.version_type==42||device_status.version_type==43)
  3223. {
  3224. rt_sprintf(device_status.driver, "%s",VERSION_HK_2000W);
  3225. }
  3226. else if (device_status.version_type==41) {
  3227. rt_sprintf(device_status.driver, "%s",VERSION_HK);
  3228. }
  3229. LOG_I("SOFTWARE VERSION:%s-imei:%s--iccid:%s",device_status.driver,device_status.imei,device_status.iccid);
  3230. LOG_I("read flash paramconfis:%d-%s-%s",device_status.version_type,device_status.driver_bl,device_status.driver_compile);
  3231. LOG_I("开机次数:%d",device_status.rebootcnt);
  3232. LOG_I("收集时间:%d",device_status.clt_time);
  3233. LOG_I("定时开始时间:%d",device_status.startBar);
  3234. LOG_I("定时结束时间:%d",device_status.stopBar);
  3235. LOG_I("timeSwitch:%d",device_status.timeSwitch);
  3236. LOG_I("光控定时时长:%d",device_status.sunBar);
  3237. LOG_I("加热开关:%d",device_status.heat_sw);
  3238. LOG_I("加热时间:%d",device_status.heattime);
  3239. LOG_I("加热温度:%d",device_status.heatvalue);
  3240. LOG_I("震动开关:%d",device_status.shake_ws);
  3241. LOG_I("震动时间:%d",device_status.shake_sec);
  3242. LOG_I("高温保护:%d",device_status.tph);
  3243. LOG_I("低温保护:%d",device_status.tpl);
  3244. LOG_I("thsp:%d", device_status.thsp);
  3245. LOG_I("密码:%d",device_status.passWord);
  3246. LOG_I("数据上传间隔:%d",device_status.dattim);
  3247. LOG_I("温湿度数据:%d-%d",atoi(device_status.tempture),atoi(device_status.humidity));
  3248. LOG_I("上传平台:%s",device_status.mqttcfg1);
  3249. LOG_I("孢子仪运行状态:%d",device_status.run_sta);
  3250. LOG_I("孢子仪采集时间:[%d-%d,%d-%d]",device_status.collecting_sh1,device_status.collecting_eh1,device_status.collecting_sh2,device_status.collecting_eh2);
  3251. LOG_I("PowerType:%d",device_status.Power_Type);
  3252. LOG_I("deviceId:%s",device_status.deviceId);
  3253. LOG_I("handle_bugger:%d",device_status.handle_bugger);
  3254. LOG_I("alarm_tg:%s",device_status.alarm_tg);
  3255. LOG_I("motor_active:%d",device_status.motor_active);
  3256. }
  3257. /* 同步 master:param_backup 的"延迟落盘线程"已取消。
  3258. param_mirror_sync() 在参数变更点同步写镜像,靠"内容未变化则跳过"抑制写放大,
  3259. 不再需要常驻线程与 500ms 静默期。 */
  3260. {
  3261. device_status.update_flag = 0;
  3262. //初始化联网状态
  3263. rt_sprintf(device_status.net,"1");
  3264. rt_sprintf(device_status.csq,"0");
  3265. rt_sprintf(device_status.sim,"1");
  3266. /* Sys_Motor_Task() 已取消(同步 master):sys_monitor 后台线程删除,
  3267. 统计改为 sys_monitor_refresh() 现场采集,见 sys_monitor.c。 */
  3268. ctr_router(ON);
  3269. #if JINGJIKUAN == 1
  3270. ctr_Cold(ON); //球阀电机电源
  3271. ctr_Collect_Fan(ON); //雨控解除
  3272. #endif
  3273. Hmi_Fresh();
  3274. Control_clear();
  3275. Control_Check(); //自检
  3276. dtu_data_play();
  3277. sht30_collect();
  3278. #if SENSOR_EN==1
  3279. mb_master_samlpe();
  3280. #endif
  3281. net_wait_thread_entry();
  3282. dtu_send_data_start();
  3283. Workstatus_check();
  3284. Work_Loop_Task();
  3285. }
  3286. }
  3287. /* ★ P2-14: 开机等联网的独立线程。
  3288. 原来这两个 while 直接写在 main 线程(Check_ParamConfig)里, 最长阻塞 180s + 10s:
  3289. while(atoi(net)==1) { ... rt_thread_delay(1000) ... } // 最多 180 次 = 180s
  3290. while(atoi(net)==0) { ... rt_thread_delay(2000) ... } // 最多 6 次 = 12s
  3291. 期间 main 线程后面的 dtu_send_data_start() / Workstatus_check() / Work_Loop_Task()
  3292. 全部延后 —— 现场表现是"开机后近 3 分钟内不自检、不进工作循环、不上报"。
  3293. 现在把等待搬到本线程, main 立刻往下走。
  3294. ⚠️ 本线程里所有用到 tm 的地方都用本函数自己的时间快照, 不再借用
  3295. Check_ParamConfig() 的 static struct tm(那里开机后还会被别处改写)。 */
  3296. static void net_wait_thread_entry(void)
  3297. {
  3298. uint16_t connect_num = 0;
  3299. time_t nnow = time(RT_NULL);
  3300. static struct tm ntm;
  3301. gmtime_r(&nnow, &ntm);
  3302. /* 等待联网 */
  3303. while (atoi(device_status.net) == 1)
  3304. {
  3305. char *readinfo = makeJson_ReadInfo();
  3306. if (readinfo != RT_NULL)
  3307. {
  3308. DTU_Write("%s", readinfo);
  3309. rt_free(readinfo);
  3310. }
  3311. rt_thread_delay(2000);
  3312. connect_num++;
  3313. LOG_I("联网中......%d", connect_num);
  3314. /* 超时时间为 3 分钟 */
  3315. #if MATCH_DEVICE == 1
  3316. if (connect_num == 60) /* 180 */
  3317. #else
  3318. if (connect_num == 90) /* 180 */
  3319. #endif
  3320. {
  3321. device_status.timeSwitch = 0;
  3322. LOG_W("Time not set:%04d-%02d-%02d %02d:%02d:%02d",
  3323. ntm.tm_year + 1900, ntm.tm_mon + 1, ntm.tm_mday,
  3324. ntm.tm_hour, ntm.tm_min, ntm.tm_sec);
  3325. #if 0
  3326. set_date(2020, 1, 1);
  3327. set_time(0, 0, 0);
  3328. #endif
  3329. break;
  3330. }
  3331. }
  3332. connect_num = 0;
  3333. rt_thread_delay(2000);
  3334. #if MATCH_DEVICE == 1
  3335. device_status.timeSwitch = 1;
  3336. #endif
  3337. /* ★ 原来 makeJson_Warn() 的返回值从未释放 -> 每次开机都漏一块堆 */
  3338. dtu_write_json(makeJson_Warn("turnon", "device_stm32"));
  3339. rt_thread_delay(1000);
  3340. /* 本线程退出(联网成功或 3 分钟超时): 交还 read 刷新职责给 refresh_hmi_Component() */
  3341. net_wait_running = 1;
  3342. LOG_I("net wait thread exit");
  3343. }
  3344. void ResetParamDefault(void)
  3345. {
  3346. #if MATCH_DEVICE == 1
  3347. rt_sprintf(device_status.tempture,"%d",30);
  3348. #else
  3349. rt_sprintf(device_status.tempture,"%d",-15);
  3350. #endif
  3351. device_status.ds = 1; //设备状态开机
  3352. device_status.thsp = 300;
  3353. device_status.passWord = 8888;
  3354. device_status.dattim = 10;
  3355. device_status.collecting_sh1 = 9;
  3356. device_status.collecting_eh1 = 10;
  3357. device_status.collecting_sh2 = 14;
  3358. device_status.collecting_eh2 = 16;
  3359. device_status.Power_Type = 0;
  3360. ef_set_env_blob("Power_Type", &device_status.Power_Type, sizeof(device_status.Power_Type));
  3361. ef_set_env_blob("dattim",&device_status.dattim,sizeof(device_status.dattim)); //上传时间
  3362. if(device_status.dtype==3)
  3363. {
  3364. device_status.clt_time = 6; //收集时间
  3365. device_status.startBar = 20; //定时开始时间
  3366. device_status.stopBar = 5; //定时结束时间
  3367. device_status.heattime = 8; //加热时间
  3368. device_status.shake_ws = 1; //针对开关
  3369. #if TG_MODULE == 0
  3370. device_status.shake_sec = 1; //震动时间,s
  3371. #else
  3372. device_status.shake_sec = 2; //震动时间,s
  3373. #endif
  3374. device_status.sunBar = 8;
  3375. device_status.tph = 70; //高温保护阈值
  3376. device_status.tpl = -5; //低温保护阈值
  3377. device_status.timeSwitch = 0; //定时模式:光控
  3378. device_status.heatvalue=100; //加热温度
  3379. device_status.heat_sw = 1;
  3380. ef_set_env_blob("heat_sw", &device_status.heat_sw, sizeof(device_status.heat_sw));
  3381. ef_set_env_blob("stime", &device_status.clt_time, sizeof(device_status.clt_time));
  3382. ef_set_env_blob("startBar", &device_status.startBar, sizeof(device_status.startBar));
  3383. ef_set_env_blob("stopBar", &device_status.stopBar, sizeof(device_status.stopBar));
  3384. ef_set_env_blob("timeSwitch", &device_status.timeSwitch, sizeof(device_status.timeSwitch));
  3385. ef_set_env_blob("sunBar", &device_status.sunBar, sizeof(device_status.sunBar));
  3386. ef_set_env_blob("jtime", &device_status.heattime, sizeof(device_status.heattime));
  3387. ef_set_env_blob("jheat", &device_status.heatvalue, sizeof(device_status.heatvalue));
  3388. ef_set_env_blob("tph", &device_status.tph, sizeof(device_status.tph));
  3389. ef_set_env_blob("tpl", &device_status.tpl, sizeof(device_status.tpl));
  3390. ef_set_env_blob("shake_ws", &device_status.shake_ws, sizeof(device_status.shake_ws)); //震动开关
  3391. ef_set_env_blob("shake_sec", &device_status.shake_sec, sizeof(device_status.shake_sec)); //震动时间
  3392. device_status.handle_bugger = 0;
  3393. ef_set_env_blob("handle_bugger", &device_status.handle_bugger, sizeof(device_status.handle_bugger));
  3394. }
  3395. else if(device_status.dtype==7)
  3396. {
  3397. device_status.run_sta = 0;
  3398. device_status.heatvalue = 25; //培养温度
  3399. ef_set_env_blob("run_sta", &device_status.run_sta, sizeof(device_status.run_sta));
  3400. ef_set_env_blob("collecting_sh1", &device_status.collecting_sh1, sizeof(device_status.collecting_sh1)); //采集时间
  3401. ef_set_env_blob("collecting_eh1", &device_status.collecting_eh1, sizeof(device_status.collecting_eh1)); //采集时间
  3402. ef_set_env_blob("collecting_sh2", &device_status.collecting_sh2, sizeof(device_status.collecting_sh2)); //采集时间
  3403. ef_set_env_blob("collecting_eh2", &device_status.collecting_eh2, sizeof(device_status.collecting_eh2)); //采集时间
  3404. ef_set_env_blob("jheat", &device_status.heatvalue, sizeof(device_status.heatvalue));
  3405. }
  3406. ef_set_env_blob("ds", &device_status.ds, sizeof(device_status.ds));
  3407. ef_set_env_blob("thsp", &device_status.thsp, sizeof(device_status.thsp));
  3408. ef_set_env_blob("passWord", &device_status.passWord,sizeof(device_status.passWord));
  3409. /* 恢复出厂是一次 24 连写, 最容易被打断导致只写一半。
  3410. 这里同步写一份参数镜像, 保证出厂值也有可信副本(param_mirror_sync 立即落盘)。 */
  3411. param_mirror_sync();
  3412. HMI_WRITE("play %d,%d,%d",1,5,0);
  3413. DTU_Write("reset.mp3");
  3414. rt_thread_delay(1000);
  3415. }
  3416. void ResetParamDefault_DC(void)
  3417. {
  3418. //将温度数据设置为-15摄氏度,以便上传的数据中包含温控数据
  3419. rt_sprintf(device_status.tempture,"%d",-15);
  3420. device_status.clt_time = 6; //收集时间
  3421. device_status.dattim = 10; //数据上传间隔
  3422. device_status.startBar = 20; //定时开始时间
  3423. device_status.stopBar = 0; //定时结束时间
  3424. device_status.heattime = 8; //加热时间
  3425. device_status.shake_ws = 1; //针对开关
  3426. #if TG_MODULE == 0
  3427. device_status.shake_sec = 1; //震动时间,s
  3428. #else
  3429. device_status.shake_sec = 2; //震动时间,s
  3430. #endif
  3431. device_status.sunBar = 4;
  3432. device_status.tph = 70; //高温保护阈值
  3433. device_status.tpl = -5; //低温保护阈值
  3434. device_status.timeSwitch = 0; //定时模式
  3435. device_status.heatvalue=100;
  3436. device_status.ds = 1; //设备状态开机
  3437. device_status.thsp = 300;
  3438. device_status.passWord = 8888;
  3439. device_status.timeSwitch = 0;
  3440. device_status.Power_Type = 1;
  3441. device_status.handle_bugger = 0;
  3442. device_status.heat_sw = 0;
  3443. ef_set_env_blob("dattim",&device_status.dattim,sizeof(device_status.dattim)); //上传时间
  3444. ef_set_env_blob("handle_bugger", &device_status.handle_bugger, sizeof(device_status.handle_bugger));
  3445. ef_set_env_blob("Power_Type", &device_status.Power_Type, sizeof(device_status.Power_Type));
  3446. ef_set_env_blob("ds", &device_status.ds, sizeof(device_status.ds));
  3447. ef_set_env_blob("stime", &device_status.clt_time, sizeof(device_status.clt_time));
  3448. ef_set_env_blob("startBar", &device_status.startBar, sizeof(device_status.startBar));
  3449. ef_set_env_blob("stopBar", &device_status.stopBar, sizeof(device_status.stopBar));
  3450. ef_set_env_blob("timeSwitch", &device_status.timeSwitch, sizeof(device_status.timeSwitch));
  3451. ef_set_env_blob("sunBar", &device_status.sunBar, sizeof(device_status.sunBar));
  3452. ef_set_env_blob("jtime", &device_status.heattime, sizeof(device_status.heattime));
  3453. ef_set_env_blob("jheat", &device_status.heatvalue, sizeof(device_status.heatvalue));
  3454. ef_set_env_blob("tph", &device_status.tph, sizeof(device_status.tph));
  3455. ef_set_env_blob("tpl", &device_status.tpl, sizeof(device_status.tpl));
  3456. ef_set_env_blob("shake_ws", &device_status.shake_ws, sizeof(device_status.shake_ws)); //震动开关
  3457. ef_set_env_blob("shake_sec", &device_status.shake_sec, sizeof(device_status.shake_sec)); //震动时间
  3458. ef_set_env_blob("thsp", &device_status.thsp, sizeof(device_status.thsp));
  3459. ef_set_env_blob("passWord", &device_status.passWord,sizeof(device_status.passWord));
  3460. ef_set_env_blob("heat_sw", &device_status.heat_sw,sizeof(device_status.heat_sw));
  3461. /* 同上, 18 连写后同步一份参数镜像(立即生效) */
  3462. param_mirror_sync();
  3463. DTU_Write("reset.mp3");
  3464. rt_thread_delay(1000);
  3465. }
  3466. //固件备份
  3467. void app_partion_backup(void)
  3468. {
  3469. rt_kprintf("固件恢复!!!\n");
  3470. const char *dst_part_name = "df_area";
  3471. const char *src_part_name = "app";
  3472. const struct fal_partition *dst_part;
  3473. const struct fal_partition *src_part;
  3474. /* ★ FAL 没建表成功时 fal_partition_find() 会撞 assert(init_ok) 死循环,
  3475. 先查 fal_init_check() 门控。 */
  3476. if (fal_init_check() != 1)
  3477. {
  3478. rt_kprintf("FAL is NOT initialized, partition backup aborted!\n");
  3479. return;
  3480. }
  3481. dst_part = fal_partition_find(dst_part_name);
  3482. src_part = fal_partition_find(src_part_name);
  3483. if (dst_part == RT_NULL || src_part == RT_NULL)
  3484. {
  3485. if (dst_part == RT_NULL)
  3486. rt_kprintf("%s partition is not exist!\n", dst_part_name);
  3487. if (src_part == RT_NULL)
  3488. rt_kprintf("%s partition is not exist!\n", src_part_name);
  3489. }
  3490. else
  3491. {
  3492. rt_kprintf("Clone %s partition to %s partition:\n", src_part_name, dst_part_name);
  3493. if (fal_partition_erase(dst_part, 0, dst_part->len) >= 0)
  3494. {
  3495. int clone_pos = 0;
  3496. int clone_len = 0, clone_tol_len;
  3497. rt_uint8_t *buf = rt_malloc(4096);
  3498. if (dst_part->len < src_part->len)
  3499. clone_tol_len = dst_part->len;
  3500. else
  3501. clone_tol_len = src_part->len;
  3502. while ((clone_pos < clone_tol_len) && (buf != RT_NULL))
  3503. {
  3504. clone_len = fal_partition_read(src_part, clone_pos, buf, 4096);
  3505. if (clone_len < 0)
  3506. {
  3507. rt_kprintf("\nread %s partition failed, clone stop!\n", src_part_name);
  3508. break;
  3509. }
  3510. if (fal_partition_write(dst_part, clone_pos, buf, clone_len) < 0)
  3511. {
  3512. rt_kprintf("\nwrite %s partition failed, clone stop!\n", dst_part_name);
  3513. break;
  3514. }
  3515. HMI_WRITE("#");
  3516. rt_kprintf("#");
  3517. clone_pos += clone_len;
  3518. }
  3519. if (clone_pos >= clone_tol_len)
  3520. {
  3521. rt_kprintf("\nClone partition success, total %d bytes!\n", clone_tol_len);
  3522. }
  3523. else
  3524. {
  3525. rt_kprintf("Clone partition failed!");
  3526. }
  3527. if (buf)
  3528. rt_free(buf);
  3529. }
  3530. }
  3531. }
  3532. void Debug_log_ON(void)
  3533. {
  3534. rt_console_set_device("uart4");
  3535. finsh_set_device("uart4");
  3536. }
  3537. void Debug_log_OFF(void)
  3538. {
  3539. rt_console_set_device("uart1");
  3540. finsh_set_device("uart1");
  3541. /* ★ 原来这里无条件再 rt_mq_init() 一次 + 再建一个 "Hmi_Fresh_thread":
  3542. ① 对已初始化的消息队列重复 init 会重置其等待链表/读写指针(返回 -RT_ERROR),
  3543. 正在排队的屏幕指令直接丢;
  3544. ② 线程重复创建后同一消息队列有两个消费者, 每条屏幕指令会被处理两遍
  3545. (reboot / 写 Flash 等动作执行两次), 且每次泄漏一份线程栈。
  3546. 消息队列与接收回调在 INIT_BOARD 阶段已建立, 这里只需在升级结束线程退出后
  3547. 重建(rt_thread_find 为空), 否则保持现状。 */
  3548. if (serial != RT_NULL)
  3549. {
  3550. rt_device_set_rx_indicate(serial, uart_input);
  3551. }
  3552. if (rt_thread_find("Hmi_Fresh_thread") == RT_NULL)
  3553. {
  3554. hmi1 = rt_thread_create("Hmi_Fresh_thread",
  3555. Hmi_thread_entry,
  3556. RT_NULL,
  3557. HMI_THREAD_STACK_SIZE,
  3558. HMI_THREAD_PRIORITY,
  3559. HMI_THREAD_TIMESLICE);
  3560. if (hmi1 != RT_NULL)
  3561. {
  3562. rt_thread_startup(hmi1);
  3563. }
  3564. }
  3565. }
  3566. MSH_CMD_EXPORT(Debug_log_ON,Debug_log_ON);
  3567. MSH_CMD_EXPORT(Debug_log_OFF,Debug_log_OFF);
  3568. //
  3569. INIT_BOARD_EXPORT(HMI_uart4_init);