hc_ctl.c 93 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087
  1. #define DBG_ENABL
  2. #define DBG_SECTION_NAME "hc_ctl"
  3. #define DBG_LEVEL DBG_LOG
  4. #define DBG_COLOR
  5. #include <rtdbg.h>
  6. #include <rtthread.h>
  7. #include <rtdevice.h>
  8. #include <../add_pkg/libmodbus/inc/modbus.h>
  9. #include "stdio.h"
  10. #include "string.h"
  11. #include "math.h"
  12. #include <easyflash.h>
  13. #include "sys_config.h"
  14. #include <board.h>
  15. #include "bsp_user_lib.h"
  16. #include "signal_led.h"
  17. #include "hc_ctl.h"
  18. #include "stm32f4xx_hal.h"
  19. #include <CH376/bsp/bsp_log.h>
  20. #define DTU_UART_NAME "uart2"
  21. #define hc_addr 0xFE
  22. rt_device_t dtu_serial;
  23. int dtu_uart_init(void)
  24. {
  25. rt_err_t ret = RT_EOK;
  26. char uart_name[RT_NAME_MAX];
  27. // char str[] = "hello RT-Thread!\r\n";
  28. rt_strncpy(uart_name, DTU_UART_NAME, RT_NAME_MAX);
  29. /* 查找系统中的串口设备 */
  30. dtu_serial = rt_device_find(uart_name);
  31. if (!dtu_serial)
  32. {
  33. rt_kprintf("find %s failed!\n", uart_name);
  34. return RT_ERROR;
  35. }
  36. // rt_kprintf("dtu_uart_init √\n");
  37. return ret;
  38. }
  39. // 向uart2发送定长数据
  40. void rs485_send_data(uint8_t *data, uint8_t len)
  41. {
  42. if (!dtu_serial)
  43. {
  44. dtu_uart_init();
  45. }
  46. HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_SET);
  47. rt_device_write(dtu_serial, 0, data, len);
  48. HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_RESET);
  49. }
  50. ///
  51. /// 向航插小板发送控制码
  52. ///
  53. /// 返回执行结果(0失败 1成功)
  54. ///
  55. uint8_t hc_send_cmd(uint8_t cmd)
  56. {
  57. uint8_t tx_buf[10] = {0}, rx_buf[10] = {0};
  58. uint16_t crc = 0;
  59. tx_buf[0] = hc_addr;
  60. tx_buf[1] = 0x06;
  61. tx_buf[2] = 0x00;
  62. tx_buf[3] = 0x01;
  63. tx_buf[4] = 0x00;
  64. tx_buf[5] = cmd;
  65. crc = CRC16_Modbus(tx_buf, 6);
  66. tx_buf[6] = crc >> 8;
  67. tx_buf[7] = crc & 0xFF;
  68. rs485_send_data(tx_buf, 8);
  69. rt_thread_mdelay(900);
  70. if (rt_device_read(dtu_serial, 0, &rx_buf, sizeof(rx_buf)) > 0)
  71. {
  72. crc = 0;
  73. // rt_kprintf("recv return ->");
  74. for (uint8_t a = 0; a < 8; a++)
  75. {
  76. // rt_kprintf("%02X ",rx_buf[a]);
  77. if (tx_buf[a] == rx_buf[a])
  78. {
  79. crc++;
  80. }
  81. }
  82. // rt_kprintf("\n");
  83. }
  84. if (crc == 8)
  85. {
  86. // rt_kprintf("execute succ\n");
  87. return 1;
  88. }
  89. else
  90. {
  91. // rt_kprintf("execute fail\n");
  92. return 0;
  93. }
  94. }
  95. ///
  96. /// 读取航插小板当前的控制状态
  97. /// 成功 : 返回读取值
  98. /// 失败 : 返回-1
  99. ///
  100. extern uint16_t CRC16_Modbus(uint8_t *_pBuf, uint16_t _usLen);
  101. int hc_read_status(void)
  102. {
  103. int result = -1;
  104. uint8_t tx_buf[10] = {0}, rx_buf[10] = {0};
  105. uint16_t crc = 0;
  106. uint8_t recv_cnt = 0;
  107. memset(rx_buf, 0x9D, sizeof(rx_buf));
  108. tx_buf[0] = hc_addr;
  109. tx_buf[1] = 0x03;
  110. tx_buf[2] = 0x00;
  111. tx_buf[3] = 0x01;
  112. tx_buf[4] = 0x00;
  113. tx_buf[5] = 0x01;
  114. crc = CRC16_Modbus(tx_buf, 6);
  115. tx_buf[6] = crc >> 8;
  116. tx_buf[7] = crc & 0xFF;
  117. rs485_send_data(tx_buf, 8);
  118. rt_thread_mdelay(900);
  119. if (rt_device_read(dtu_serial, 0, &rx_buf, sizeof(rx_buf)) > 0)
  120. {
  121. /* 获取接收长度 */
  122. for (uint8_t a = 0; a < sizeof(rx_buf); a++)
  123. {
  124. if (rx_buf[a] == 0x9D && rx_buf[a + 1] == 0x9D)
  125. {
  126. // rt_kprintf("\n");
  127. break;
  128. }
  129. else
  130. {
  131. recv_cnt++;
  132. // rt_kprintf("%02X ", rx_buf[a]);
  133. }
  134. }
  135. /* 校验crc */
  136. crc = CRC16_Modbus((uint8_t *)rx_buf, recv_cnt - 2);
  137. if (((crc >> 8) == rx_buf[recv_cnt - 2]) &&
  138. ((crc & 0x00FF) == rx_buf[recv_cnt - 1]) &&
  139. (rx_buf[0] == hc_addr) &&
  140. (rx_buf[1] == 0x03) &&
  141. (rx_buf[2] == 0x02))
  142. {
  143. result = rx_buf[4];
  144. }
  145. }
  146. return result;
  147. }
  148. extern Sector qxz;
  149. extern Sensor *sensor;
  150. /* HMI显示功能函数 */
  151. extern void Status_Display(const char *content, uint16_t value1, int16_t value2);
  152. ELEM_POS_INFO elem_pos = {0}; // 用于存放航插中插孔与要素的对应关系
  153. // /**
  154. // * @brief Get the elem position object 获取要素与航插插孔的对应关系
  155. // *
  156. // * @param type 执行模式 type - 1 读取全体要素 type - 2 读取未成功获取的要素
  157. // *
  158. // * @return uint8_t 结果
  159. // *
  160. // * 0 - 航插小板无响应
  161. // * 3 - 所有要素获取失败
  162. // * 2 - 部分要素获取完成
  163. // * 1 - 所有要素均已获取完毕
  164. // *
  165. // */
  166. /**
  167. * @brief Get the elem position object
  168. * V2 修正该函数功能 为读取保持长供电的要素位置
  169. * @param type 暂无释义
  170. * @return uint8_t 返回需要保持长供电的参数(按位存放)
  171. */
  172. uint8_t get_elem_position(uint8_t type)
  173. {
  174. uint8_t result = 0;
  175. uint8_t retry = 0;
  176. uint8_t get_flg = 0;
  177. uint8_t cmd[9] = {0};
  178. uint8_t rx_buf[99] = {0};
  179. uint16_t crc = 0;
  180. uint8_t for_time = 0; // 循环次数
  181. uint8_t this_time = 0; // 本次循环参数
  182. char dis_buf[90] = {0}; // 用于组包显示内容
  183. char dis_cache[60] = {0}; // 组包缓存内容
  184. if (hc_read_status() == -1)
  185. {
  186. rt_kprintf("hc check fail \n");
  187. }
  188. // rt_kprintf("get_elem_position");
  189. /* 校验本次执行模式 */
  190. if (type == 2 && (elem_pos.pos[0][0] != qxz.Param.Num_sensors - elem_pos.info_cnt))
  191. {
  192. type = 1;
  193. }
  194. if (type == 1)
  195. {
  196. rt_memset(&elem_pos, 0, sizeof(ELEM_POS_INFO));
  197. for_time = qxz.Param.Num_sensors;
  198. rt_sprintf(dis_buf, "%s", "低功耗初始化中...");
  199. Status_Display(dis_buf, RT_NULL, RT_NULL);
  200. }
  201. else if (type == 2)
  202. {
  203. for_time = qxz.Param.Num_sensors - elem_pos.info_cnt;
  204. // rt_kprintf("type 2 have %d\n", for_time);
  205. rt_sprintf(dis_buf, "%d%s", for_time, " 项要素重新读取");
  206. Status_Display(dis_buf, RT_NULL, RT_NULL);
  207. }
  208. else
  209. {
  210. return 0;
  211. }
  212. /* 校验本次执行模式 */
  213. for (uint8_t i = 0; i < for_time; i++) // 所有要素都跑一遍
  214. {
  215. if (type == 2)
  216. {
  217. this_time = elem_pos.pos[0][i + 1];
  218. }
  219. else
  220. {
  221. this_time = i;
  222. }
  223. if (sensor[this_time].pwr_level != 2)
  224. {
  225. continue;
  226. }
  227. for (uint8_t a = 1; a <= 8; a++) // 8个插孔都试试
  228. {
  229. if (hc_send_cmd(1 << (a - 1)) && (hc_read_status() == 1 << (a - 1))) // 确认航插写命令成功
  230. {
  231. // rt_kprintf(" %s try hold %d\n", sensor[this_time].eName , a);
  232. rt_memset(cmd, 0, sizeof(cmd));
  233. cmd[0] = sensor[this_time].sensor_addr;
  234. cmd[1] = 0x03;
  235. cmd[2] = (uint8_t)(sensor[this_time].start_reg >> 8);
  236. cmd[3] = (uint8_t)(sensor[this_time].start_reg & 0x00FF);
  237. cmd[4] = (uint8_t)(sensor[this_time].count >> 8);
  238. cmd[5] = (uint8_t)(sensor[this_time].count & 0x00FF);
  239. crc = CRC16_Modbus((uint8_t *)cmd, 6);
  240. cmd[6] = (uint8_t)(crc >> 8);
  241. cmd[7] = (uint8_t)(crc & 0x00FF);
  242. rs485_send_data((uint8_t *)cmd, 8);
  243. while (retry < 3)
  244. {
  245. rt_thread_mdelay(300);
  246. if (rt_device_read(dtu_serial, 0, &rx_buf, sizeof(rx_buf)) > 0)
  247. {
  248. if (rx_buf[0] == sensor[this_time].sensor_addr &&
  249. rx_buf[1] == 0x03 &&
  250. rx_buf[2] == (sensor[this_time].count * 2))
  251. {
  252. rt_kprintf("\nfind %s in jack %d\n", sensor[this_time].eName, a);
  253. rt_sprintf(dis_buf, "%s%s%d", sensor[this_time].cName, "通道", a);
  254. Status_Display(dis_buf, RT_NULL, RT_NULL);
  255. result += (1 << (a - 1)); // 记录这个要素位置
  256. elem_pos.pos[a][++elem_pos.pos[a][0]] = this_time;
  257. elem_pos.info_cnt++;
  258. get_flg = 1;
  259. break;
  260. }
  261. }
  262. retry++;
  263. }
  264. retry = 0;
  265. if (get_flg == 1)
  266. {
  267. get_flg = 0;
  268. break;
  269. }
  270. }
  271. // else
  272. // {
  273. // rt_kprintf("write cmd -> %d failed\n", a);
  274. // }
  275. }
  276. }
  277. // if (elem_pos.info_cnt == qxz.Param.Num_sensors)
  278. // {
  279. // result = 1;
  280. // }
  281. // else if (elem_pos.info_cnt < qxz.Param.Num_sensors && elem_pos.info_cnt > 0)
  282. // {
  283. // result = 2;
  284. // }
  285. // else
  286. // {
  287. // result = 3;
  288. // }
  289. // elem_pos.pos[0][0] = qxz.Param.Num_sensors - elem_pos.info_cnt;
  290. // // rt_kprintf("now sensor pos info cnt %d fail cnt %d\n", elem_pos.info_cnt, elem_pos.pos[0][0]);
  291. // rt_thread_mdelay(900);
  292. // rt_sprintf(dis_buf, "%d%s", qxz.Param.Num_sensors - elem_pos.info_cnt, "要素初始化失败");
  293. // Status_Display(dis_buf, RT_NULL, RT_NULL);
  294. // rt_thread_mdelay(1500);
  295. rt_sprintf(dis_buf, "%d%s", elem_pos.info_cnt, "要素初始化完成");
  296. Status_Display(dis_buf, RT_NULL, RT_NULL);
  297. hc_send_cmd(0xFF); // 读取完成啦 记得给供电都开起来
  298. // rt_kprintf("return result %d\n", result);
  299. // printf_sensor_pos();
  300. return result;
  301. }
  302. // //要素属性数据结构
  303. // typedef struct
  304. // {
  305. // uint8_t num; // 编号,在hmi显示的控件序号
  306. // uint8_t sensor_addr; // 从机地址
  307. // int start_reg; // 寄存器起始地址
  308. // int count; // 读取寄存器数量
  309. // int d_pos; // 多要素下读取多个寄存器需要数据在其中的位置,从0开始(为了兼容新普惠传感器不能单独读取寄存器的问题)
  310. // int factor; // 读取到数据系数,负数为除,正数为乘
  311. // uint8_t d_length; // 数据长度,2:表示4字节 11:表示2字节
  312. // uint8_t err_cnt; // 读取错误计数
  313. // uint8_t online_flag; // 传感器在线标志
  314. // int32_t value; // 传感器数值
  315. // char cName[20]; //传感器中文名称,4个中文字符
  316. // char units[10]; //传感器单位
  317. // char eName[23]; //传感器名称
  318. // char eValue[20]; // 传感器字符串形式数据
  319. // char eKey[5]; //传感器通道号
  320. // char eNum[5];
  321. // char dotled_s[30]; // 点阵屏显示字符串,一行能显示16个字符/8个汉字
  322. // }Sensor;
  323. /**
  324. * @brief 打印当前的传感器位置信息
  325. *
  326. */
  327. // void printf_sensor_pos(void)
  328. //{
  329. // rt_kprintf("\n\n");
  330. // for (uint8_t a = 1; a <= 8; a++)
  331. // {
  332. // //rt_kprintf("hold%d -> %d %d %d %d %d\n", a,elem_pos.pos[a][0],elem_pos.pos[a][1],elem_pos.pos[a][2],elem_pos.pos[a][3],elem_pos.pos[a][4]);
  333. // for (uint8_t b = 1; b <= elem_pos.pos[a][0]; b++)
  334. // {
  335. // rt_kprintf("s%d -> %s on hold -> %d lv %d\n", elem_pos.pos[a][b], sensor[elem_pos.pos[a][b]].eName, a, sensor[elem_pos.pos[a][b]].pwr_level);
  336. // reflash_hc_ctl(elem_pos.pos[a][b], 0);
  337. // }
  338. // }
  339. // rt_kprintf("\n\n");
  340. //}
  341. /**
  342. * @brief 刷新航插中孔位的通断电状态
  343. *
  344. * @param pos 本次要读取的要素在sensor中的位置
  345. *
  346. * @param wait_time 本次更新开关量之后,是否需要给传感器留出时间
  347. *
  348. * @return 结果 0-失败(无响应/返回值校验失败) 1-成功 2-非法参数
  349. */
  350. uint8_t reflash_hc_ctl(uint8_t pos, uint8_t wait_time)
  351. {
  352. uint8_t result = 0;
  353. uint8_t cmd = 0;
  354. ///
  355. /// 本次要读的传感器 供电
  356. /// 下个要读的传感器 供电
  357. /// 下下个要读的传感器 (lv1/lv2)供电
  358. ///
  359. /// 其他 - lv2供电
  360. ///
  361. // rt_kprintf(" %s pwr_level %d\n",sensor[pos].eName , sensor[pos].pwr_level);
  362. uint8_t next, n_next = 0; // 保存下一个和下下个传感器的位置 使得判断传感器顺序时为环形数据结构
  363. next = (pos + 1) % qxz.Param.Num_sensors;
  364. n_next = (pos + 2) % qxz.Param.Num_sensors;
  365. // rt_kprintf("pos %d next %d n_next %d \n", pos , next , n_next);
  366. for (uint8_t a = 1; a <= 8; a++) // 8个插孔
  367. {
  368. for (uint8_t b = 1; b <= elem_pos.pos[a][0]; b++) // 遍历每个孔里的所有要素
  369. {
  370. if (pos < qxz.Param.Num_sensors)
  371. {
  372. if ((pos == elem_pos.pos[a][b]) || (next == elem_pos.pos[a][b])) // 本次或下次要读的 上电
  373. {
  374. // rt_kprintf("goto A a-b %d-%d elem_pos.pos[a][b] %d\n",a,b,elem_pos.pos[a][b]);
  375. cmd |= (uint8_t)(1 << (a - 1));
  376. break;
  377. }
  378. else if (n_next < qxz.Param.Num_sensors &&
  379. (n_next == elem_pos.pos[a][b])) // 下下次要读的 LV1/2上电
  380. {
  381. if (sensor[elem_pos.pos[a][b]].pwr_level == 1 ||
  382. sensor[elem_pos.pos[a][b]].pwr_level == 2)
  383. {
  384. // rt_kprintf("goto B a-b %d-%d elem_pos.pos[a][b] %d\n",a,b,elem_pos.pos[a][b]);
  385. cmd |= (uint8_t)(1 << (a - 1));
  386. break;
  387. }
  388. }
  389. else if (sensor[elem_pos.pos[a][b]].pwr_level == 2) // 其他的 LV2上电
  390. {
  391. // rt_kprintf("goto C a-b %d-%d elem_pos.pos[a][b] %d\n",a,b,elem_pos.pos[a][b]);
  392. cmd |= (uint8_t)(1 << (a - 1));
  393. break;
  394. }
  395. }
  396. else if (pos == 0xFF)
  397. {
  398. if (sensor[elem_pos.pos[a][b]].pwr_level == 2) // 读取结束时 LV2上电
  399. {
  400. // rt_kprintf("goto D a-b %d-%d elem_pos.pos[a][b] %d\n",a,b,elem_pos.pos[a][b]);
  401. cmd |= (uint8_t)(1 << (a - 1));
  402. break;
  403. }
  404. }
  405. else
  406. {
  407. result = 2;
  408. break;
  409. }
  410. }
  411. }
  412. // rt_kprintf(" exe cmd %d \n\n", cmd);
  413. result = hc_send_cmd(cmd);
  414. if (pos == 0 && wait_time == 1)
  415. {
  416. // rt_kprintf("wait sensor init\n");
  417. if (sensor[pos].pwr_level == 1)
  418. {
  419. rt_thread_mdelay(10000);
  420. }
  421. else
  422. {
  423. rt_thread_mdelay(5000);
  424. }
  425. }
  426. return result;
  427. }
  428. /* 测试要素 用完即删
  429. {"element":[
  430. {"num":0, "sensor_addr":1, "start_reg":0,"count":3,"d_pos":0,"factor":-10, "d_length":1,"err_cnt":0,"online_flag":0,"value":0,"cName":"空气温度:", "units":"℃", "eName":"Etemperature", "eValue":"0", "eKey":"e1 ", "eNum":"101", "pwr_level":1, "dotled_s":"%s温 度:%s%6s ℃"},
  431. {"num":1, "sensor_addr":1, "start_reg":0,"count":3,"d_pos":1,"factor":-10, "d_length":1,"err_cnt":0,"online_flag":0,"value":0,"cName":"空气湿度:", "units":"%", "eName":"Ehumidity", "eValue":"0", "eKey":"e2 ", "eNum":"102", "pwr_level":1, "dotled_s":"%s湿 度:%s%6s %% "},
  432. {"num":2, "sensor_addr":4, "start_reg":0,"count":2,"d_pos":0,"factor":-10, "d_length":1,"err_cnt":0,"online_flag":0,"value":0,"cName":"土壤温度:", "units":"℃", "eName":"SoilTemperature", "eValue":"0", "eKey":"e3 ", "eNum":"106", "pwr_level":0, "dotled_s":"%s土 温:%s%6s ℃"},
  433. {"num":8, "sensor_addr":5, "start_reg":1034,"count":2,"d_pos":0,"factor":-10, "d_length":1,"err_cnt":0,"online_flag":0,"value":0,"cName":"气 压:", "units":"hPa", "eName":"AirPressure", "eValue":"0", "eKey":"e9 ", "eNum":"127", "pwr_level":0, "dotled_s":"%s气 压:%s%6shPa"}
  434. ]
  435. }
  436. */
  437. /**
  438. * @brief 检查航插小板是否在线 不在线的话不使用低功耗模式 兼容旧版硬件
  439. *
  440. * @return uint8_t return 0 未检测到小板 return 1 小板在线
  441. */
  442. uint8_t check_hc_sta(void)
  443. {
  444. int sta = 0;
  445. for (uint8_t a = 0; a < 3; a++)
  446. {
  447. sta = hc_read_status();
  448. if (sta != -1)
  449. {
  450. Status_Display("启用低功耗模式", RT_NULL, RT_NULL);
  451. return 1;
  452. }
  453. }
  454. return 0;
  455. }
  456. /************* 滤波的使用方法 **************/
  457. /*
  458. 1. 在要素定制区 --> ****** 自2022-09-17 开始的对要素(单寄存器)定制区域
  459. 2. 新增一个要素定制的功能块 FD_Para.limit 为滤波幅度(针对原始值)
  460. else if (rt_strcmp(sensor[i].eName, "FD") == 0) //为果实直径做滤波
  461. {
  462. static Filter_Para FD_Para = {0}; //滤波用静态变量
  463. FD_Para.limit = 10; //滤波用限位值
  464. tab_reg[sensor[i].d_pos] = elem_filter(&FD_Para, tab_reg[sensor[i].d_pos]);
  465. sensor[i].value = (float)(tab_reg[sensor[i].d_pos] / 10);
  466. rt_sprintf(sensor[i].eValue, "%d.%d", (tab_reg[sensor[i].d_pos] / 10), (tab_reg[sensor[i].d_pos] % 10));
  467. sensor[i].online_flag = 1;
  468. sensor[i].err_cnt = 0;
  469. }
  470. 3. 即刻享受3次滤波服务, 3次过后历史数据清空,重新填充基础数据6个,填充过后才会重新启用滤波
  471. */
  472. /************* 滤波的使用方法 **************/
  473. /**
  474. * @brief 用于为要素滤波 调用前需要创建要素值缓存和pos
  475. *
  476. * 只能滤波d_lenght = 1的 也就是长度为uint16_t的要素
  477. *
  478. * 默认存放要素值的缓存长度为6 取6项平均值来测算波动
  479. *
  480. * @param buf 存放历史要素值的缓存指针
  481. * @param pos 当前存放的位置
  482. * @param active 指剩余缓存的活性(值越大活性越低 最大值为3) 活性值耗尽 不再进行滤波
  483. * @param limit 滤波幅度
  484. * @param val 本次用于校验的滤波值
  485. *
  486. * return 未触发滤波返回原始值 触发后返回历史数据的平均值
  487. *
  488. */
  489. uint16_t elem_filter(Filter_Para *para, uint16_t val)
  490. {
  491. uint16_t avg = 0; // 平均值
  492. // rt_kprintf("pos %d\nlimit %d\nactive %d\n buf[0] %d buf[1] %d buf[2] %d buf[3] %d buf[4] %d buf[5] %d \n\n"
  493. // , para->pos, para->limit, para->active,
  494. // para->buf[0],
  495. // para->buf[1],
  496. // para->buf[2],
  497. // para->buf[3],
  498. // para->buf[4],
  499. // para->buf[5]);
  500. if (para->active >= 3) // 这时候就是活性已经用完了返回原本的数据
  501. {
  502. rt_memset(para, 0, sizeof(Filter_Para));
  503. return val;
  504. }
  505. /************ 当原始数据未填充完成 *************/
  506. if (para->pos < 6) // 首次数据填充
  507. {
  508. para->buf[para->pos++] = val;
  509. return val;
  510. }
  511. if (para->pos == 6 || para->pos == 106) // 填充完成就使能滤波了
  512. {
  513. para->pos = 100;
  514. }
  515. /************ 当原始数据未填充完成 *************/
  516. if (para->limit != 0x9D) // 是启用滤波还是仅仅刷新数据
  517. {
  518. for (uint8_t a = 0; a < 6; a++) // 算平均值
  519. {
  520. avg += para->buf[a];
  521. if (a == 5)
  522. {
  523. avg /= 6;
  524. }
  525. }
  526. if (abs(avg - val) < para->limit) // 数据波动值在正常范围
  527. {
  528. para->buf[(para->pos++ - 100) % 6] = val;
  529. avg = val;
  530. if (para->active > 0)
  531. {
  532. para->active--;
  533. }
  534. }
  535. else if (para->active < 3) // 超出范围的时候消耗活性
  536. {
  537. para->active++;
  538. }
  539. }
  540. else
  541. {
  542. para->buf[(para->pos++ - 100) % 6] = val;
  543. // rt_kprintf("fill data \n");
  544. }
  545. return avg;
  546. }
  547. /************* NA抑制的使用方法 **************/
  548. /**
  549. * @brief NA抑制的使用方法
  550. *
  551. 1. 首先在 read_sensor上方的强抑制参数中新增一个结构体
  552. 如下方所示
  553. Filter_Para AT_Para = {0}; //空气温度的强抑制参数
  554. 2. 在read_sensor 函数中 **** 此处是定制要素开始前 为NA抑制提供数据 ****** 区域中新增数据记录功能块
  555. 如下所示
  556. // if (rt_strcmp(sensor[i].eName, "Etemperature") == 0)
  557. // {
  558. // //rt_kprintf("Etemperature inhibit NA\n");
  559. // AT_Para.limit = 0x9D;
  560. // elem_filter(&AT_Para, tab_reg[sensor[i].d_pos]);
  561. // }
  562. 3. 在protocol.c中 TerminalData函数上方新增需要的参数
  563. 如下所示
  564. // #include "hc_ctl.h"
  565. // extern Filter_Para AT_Para; //用于抑制NA
  566. 4. 在TerminalData中注释掉原有的一个else修改为新的else
  567. 两个else如下所示
  568. // else
  569. // {
  570. // cJSON_AddStringToObject(data0, "eValue", "-99.99");
  571. // }
  572. // else
  573. // {
  574. // if (((rt_strcmp(sensor[i].eName, "Etemperature") == 0)) &&
  575. // AT_Para.active < 3 && AT_Para.pos >= 100 && AT_Para.limit == 0x9D)
  576. // {
  577. // NA_fill_val = elem_inhibit_NA(&AT_Para);
  578. // rt_sprintf((char *)cache, "%d.%d", NA_fill_val / 10, NA_fill_val % 10);
  579. // cJSON_AddStringToObject(data0, "eValue", (char *)cache);
  580. // rt_kprintf(" NA_fill_val %d \n\n", NA_fill_val);
  581. // }
  582. // else
  583. // {
  584. // cJSON_AddStringToObject(data0, "eValue", "-99.99");
  585. // }
  586. // }
  587. 5. 编译升级 即可享受3次上报数据的NA抑制
  588. *
  589. *
  590. */
  591. /************* NA抑制的使用方法 **************/
  592. /**
  593. * @brief
  594. *
  595. * @param para 同滤波用的结构体指针一毛一样
  596. *
  597. * @return int 返回结果
  598. *
  599. * res = -1 活性耗尽
  600. * res >= 0 返回的从历史数据里算出来的平均值且活性降低
  601. *
  602. */
  603. int elem_inhibit_NA(Filter_Para *para)
  604. {
  605. int res = -1;
  606. uint16_t avg = 0;
  607. if (para->active < 3)
  608. {
  609. para->active++; // 活性 --
  610. for (uint8_t a = 0; a < 6; a++) // 算平均值
  611. {
  612. avg += para->buf[a];
  613. if (a == 5)
  614. {
  615. avg /= 6;
  616. // rt_kprintf("avg %d\n", avg);
  617. }
  618. }
  619. res = avg;
  620. }
  621. return res;
  622. }
  623. /**
  624. * @brief 为安奈恩的IEE745转浮点提前做滤波
  625. *
  626. * 安耐恩使用的是-DCBA-顺序 (氨氮)
  627. *
  628. * @param res_1 寄存器1值
  629. * @param res_2 寄存器2值
  630. * @param return 排序后放入的指针
  631. */
  632. uint8_t *AN_NH4_float_sort(uint16_t res_1, uint16_t res_2, uint8_t *res)
  633. {
  634. *res = (uint8_t)(res_2 & 0xFF);
  635. *(res + 1) = (uint8_t)(res_2 >> 8);
  636. *(res + 2) = (uint8_t)(res_1 & 0xFF);
  637. *(res + 3) = (uint8_t)(res_1 >> 8);
  638. return res;
  639. }
  640. /**
  641. * @brief 为安奈恩的IEE745转浮点提前做滤波
  642. *
  643. * 安耐恩使用的是-DCBA-顺序 (溶解氧)
  644. *
  645. * @param res_1 寄存器1值
  646. * @param res_2 寄存器2值
  647. * @param return 排序后放入的指针
  648. */
  649. uint8_t *AN_DO_float_sort(uint16_t res_1, uint16_t res_2, uint8_t *res)
  650. {
  651. *res = (uint8_t)(res_2 >> 8);
  652. *(res + 1) = (uint8_t)(res_2 & 0xFF);
  653. *(res + 2) = (uint8_t)(res_1 >> 8);
  654. *(res + 3) = (uint8_t)(res_1 & 0xFF);
  655. return res;
  656. }
  657. /**
  658. * @brief IEE754转浮点型
  659. *
  660. * @param p ABCD转好顺序后的起始位置指针
  661. *
  662. * @return uint32_t 含3位小数的u32浮点值(已做后一位的四舍五入)
  663. */
  664. uint32_t IEE754_to_float(uint8_t *p)
  665. {
  666. char i;
  667. char tmp;
  668. union IEE754_packet q;
  669. uint32_t result;
  670. tmp = *p;
  671. *p = *(p + 3);
  672. *(p + 3) = tmp;
  673. tmp = *(p + 1);
  674. *(p + 1) = *(p + 2);
  675. *(p + 2) = tmp;
  676. for (i = 0; i < 4; i++)
  677. {
  678. q.b[i] = p[i];
  679. // rt_kprintf("%X \n", p[i]);
  680. }
  681. result = (uint32_t)(q.a * 10000);
  682. if (result % 10 >= 5)
  683. {
  684. result = (uint32_t)(q.a * 1000 + 1);
  685. }
  686. else
  687. {
  688. result = (uint32_t)(q.a * 1000);
  689. }
  690. return result;
  691. }
  692. /**
  693. * @brief 为要素做假数据
  694. *
  695. * 当要素值有数据 但是区间变得离谱时
  696. * 使用该函数以真实数据为依托快速生成合理区间的假数据
  697. *
  698. * @param start_d 正常区间的起始值
  699. * @param end_d 正常区间的结束值
  700. * @param val 传感器读取到的数据
  701. * @return uint16_t 返回处理后的结果
  702. */
  703. uint16_t elem_fake_data(uint16_t start_d, uint16_t end_d, uint16_t val)
  704. {
  705. uint16_t res = 0; // 结果
  706. uint16_t dif = 0; // 差值
  707. if (val >= start_d && val <= end_d) // 数据已符合要求时
  708. {
  709. return val;
  710. }
  711. if (start_d >= end_d) // 区间值有误
  712. {
  713. return val;
  714. }
  715. dif = end_d - start_d;
  716. res = (val % dif) + start_d;
  717. return res;
  718. }
  719. /***************** 2022.9.27 为采集器加入e_code *******************/
  720. /******* 需要引入的参数 *******/
  721. extern uint8_t easyflash_cfg;
  722. extern uint32_t month;
  723. extern uint32_t day;
  724. extern uint32_t year;
  725. extern uint32_t hour;
  726. extern uint32_t min;
  727. extern uint32_t sec;
  728. /******* 需要引入的参数 *******/
  729. /******* 使用的全局变量 *******/
  730. // Record e_code[MAX_e_code_NUM] = {0}; // 错误码保存
  731. // Record_Para en_recode = {0}; // 使能参数
  732. uint16_t e_pointer = 0; // 错误码计数
  733. /******* 使用的全局变量 *******/
  734. /****************************************************
  735. *
  736. * 以直接存储数值的方式组成时间戳
  737. *
  738. * all in u32
  739. *
  740. * 1111-1111-1111-1111--1111-1111-1111-1111
  741. * [---年月---][-日-][--时--][--分--][--秒-]
  742. *
  743. * 32-23 使用10位存放年月 最大存放85年
  744. * 22-18 使用5位存放日 最大值31天
  745. * 17-13 使用5位存放时 最大值24时
  746. * 12- 7 使用6位存放分 最大值60分
  747. * 6- 1 使用6位存放秒 最大值60秒
  748. *
  749. * ************************************************/
  750. uint32_t Get_Time_Stampe(void)
  751. {
  752. Reflash_RTC();
  753. uint32_t result = 0;
  754. result = (year - 2000) * 12 + month;
  755. result = (uint32_t)((result << 22) & 0xFFC00000);
  756. result |= (uint32_t)((day << 17) & 0x3E0000);
  757. result |= (uint32_t)((hour << 12) & 0x1F000);
  758. result |= (uint32_t)((min << 6) & 0xFC0);
  759. result |= (uint32_t)((sec) & 0x3F);
  760. // rt_kprintf("+S %X\n", result);
  761. return result;
  762. }
  763. void Prase_Time_Stampe(RTC_DateTypeDef *date, RTC_TimeTypeDef *time, uint32_t tm)
  764. {
  765. date->Year = (uint8_t)(((tm & 0xFFC00000) >> 22) / 12);
  766. date->Month = (uint8_t)(((tm & 0xFFC00000) >> 22) % 12);
  767. date->Date = (uint8_t)((tm & 0x3E0000) >> 17);
  768. time->Hours = (uint8_t)((tm & 0x1F000) >> 12);
  769. time->Minutes = (uint8_t)((tm & 0xFC0) >> 6);
  770. time->Seconds = (uint8_t)((tm & 0x3F));
  771. if (date->Month == 0 && date->Year != 0)
  772. {
  773. date->Month = 12;
  774. date->Year--;
  775. }
  776. // rt_kprintf("%d:%d:%d %d:%d:%d", date->Year, date->Month, date->Date, time->Hours, time->Minutes, time->Seconds);
  777. }
  778. extern uint8_t off_ef_env;
  779. extern uint8_t easyflash_cfg;
  780. #include "ch376_driver.h"
  781. #include <CH376/bsp/bsp_csv.h>
  782. // /**
  783. // * @brief ecode存一份到SD
  784. // *
  785. // * @return uint32_t
  786. // */
  787. // static uint32_t RecodeEcodeToSD(void)
  788. // {
  789. // return (line_c+1);
  790. // }
  791. /**
  792. * @brief 对特殊状态进行记录,保存到norflash
  793. *
  794. * 可使用在线指令进行控制使能、保存等级、读取操作
  795. *
  796. * @param code 本次保存的e_code 可在对照表中获取释义
  797. * @param para 可选项,本次e_code 的附带参数
  798. * @param detail 详细信息
  799. */
  800. void Recode_e_code(EcodeTypedef code, uint16_t para, char *detail)
  801. {
  802. if (easyflash_cfg == 1)
  803. {
  804. Record ecode = {0};
  805. uint32_t used = ef_log_get_used_size();
  806. uint32_t cnt = used / sizeof(Record);
  807. if (cnt > 0)
  808. {
  809. ef_log_read((cnt - 1) * sizeof(Record), (uint32_t *)&ecode, sizeof(Record));
  810. }
  811. LOG_I("e_code used %d cnt %d\n", used, cnt);
  812. if ((used + sizeof(Record) + 0x0C) >= LOG_AREA_SIZE)
  813. {
  814. ef_log_clean();
  815. ecode.Time_Stampe = Get_Time_Stampe(); // 放入时间戳
  816. ecode.para = code;
  817. ecode.code = e_clearecode;
  818. ecode.num++;
  819. snprintf(ecode.detail, sizeof(ecode.detail), "ecode存满后清空"); // 本次信息
  820. }
  821. else
  822. {
  823. ecode.Time_Stampe = Get_Time_Stampe(); // 放入时间戳
  824. ecode.para = para;
  825. ecode.code = code;
  826. ecode.num++;
  827. snprintf(ecode.detail, sizeof(ecode.detail), "%s", detail); // 本次信息
  828. }
  829. LOG_W("e_code SET %d c %d p %d", ef_log_write((uint32_t *)&ecode, sizeof(Record)), code, para);
  830. // rt_kprintf("%d %d %d %s\n\n" , ecode.num , ecode.code , ecode.para , ecode.detail);
  831. static char once = 1;
  832. char filename[12] = {0};
  833. sprintf((char *)filename, (const char *)"ECODE.CSV");
  834. char title_name[128] = {0};
  835. sprintf(title_name, "序号,时间,Ecode,Para,描述");
  836. if (CSV_INIT(CH376_MODE_SD_CARD) != CSV_SUCCESS)
  837. {
  838. rt_kprintf("? Initialization failed in Recode_e_code\n");
  839. return;
  840. }
  841. int line_c = CSV_COUNT_FILE_LINES(filename);
  842. if (line_c == 0)
  843. {
  844. line_c = 1;
  845. }
  846. CSV_OPEN(filename, CSV_MODE_APPEND, title_name);
  847. sprintf(title_name, (const char *)"%d,%04d-%02d-%02dT%02d:%02d:%02d,%d,%d,%s", ecode.num,
  848. year,
  849. month,
  850. day,
  851. hour,
  852. min,
  853. sec,
  854. ecode.code,
  855. ecode.para,
  856. ecode.detail);
  857. // rt_kprintf("filename <%s> title_name <%s> line %d\n", filename, title_name, line_c);
  858. CSV_APPEND(title_name);
  859. CSV_CLOSE();
  860. CSV_DEINIT();
  861. }
  862. }
  863. /**
  864. * @brief printf_ecode
  865. *
  866. */
  867. void printf_ecode(void)
  868. {
  869. RTC_DateTypeDef r_date = {0};
  870. RTC_TimeTypeDef r_time = {0};
  871. uint32_t used = ef_log_get_used_size();
  872. uint32_t cnt = used / sizeof(Record);
  873. LOG_I("e_code used %d cnt %d\n", used, cnt);
  874. Record ecode = {0};
  875. for (uint32_t a = 0; a < cnt; a++)
  876. {
  877. if (ef_log_read(a * sizeof(Record), (uint32_t *)&ecode, sizeof(Record)) == EF_NO_ERR)
  878. {
  879. Prase_Time_Stampe(&r_date, &r_time, ecode.Time_Stampe);
  880. LOG_I("%d - %02d/%02d/%02d %02d:%02d:%02d:(%d-%d) %s",
  881. ecode.num,
  882. r_date.Year, r_date.Month, r_date.Date,
  883. r_time.Hours, r_time.Minutes, r_time.Seconds,
  884. ecode.code, ecode.para, ecode.detail);
  885. memset(&ecode, 0, sizeof(ecode));
  886. }
  887. else
  888. {
  889. LOG_I("ef_log_read %d fail\n", a);
  890. }
  891. }
  892. }
  893. /**
  894. * @brief 按包发送数据
  895. *
  896. * @param code code码
  897. * @param para 参数
  898. */
  899. void Send_code_data(se_modle *se)
  900. {
  901. if (se->code > e_typeMAX)
  902. {
  903. return;
  904. }
  905. char data[100] = {0};
  906. char d2[300] = {0};
  907. uint8_t len = 0;
  908. if (se->b > 0 && se->b < 10)
  909. {
  910. len = 1;
  911. }
  912. else if (se->b > 9 && se->b < 100)
  913. {
  914. len = 2;
  915. }
  916. else if (se->b > 99 && se->b < 1000)
  917. {
  918. len = 3;
  919. }
  920. else
  921. {
  922. return;
  923. }
  924. switch (len)
  925. {
  926. case 1:
  927. rt_sprintf(data, " %d/%d %02d/%02d/%02d %02d:%02d:%02d - ",
  928. se->a, se->b,
  929. se->date->Year,
  930. se->date->Month,
  931. se->date->Date,
  932. se->time->Hours,
  933. se->time->Minutes,
  934. se->time->Seconds);
  935. break;
  936. case 2:
  937. rt_sprintf(data, " %02d/%d %02d/%02d/%02d %02d:%02d:%02d - ",
  938. se->a, se->b,
  939. se->date->Year,
  940. se->date->Month,
  941. se->date->Date,
  942. se->time->Hours,
  943. se->time->Minutes,
  944. se->time->Seconds);
  945. break;
  946. case 3:
  947. rt_sprintf(data, " %03d/%d %02d/%02d/%02d %02d:%02d:%02d - ",
  948. se->a, se->b,
  949. se->date->Year,
  950. se->date->Month,
  951. se->date->Date,
  952. se->time->Hours,
  953. se->time->Minutes,
  954. se->time->Seconds);
  955. break;
  956. default:
  957. break;
  958. }
  959. sprintf(d2, "ecode_read.slt0.txt+=\"%s\"", data);
  960. Display_fun(d2);
  961. // rt_kprintf("%s",d2);
  962. rt_thread_delay(15);
  963. switch (se->code)
  964. {
  965. case reboot_ec:
  966. sprintf(d2, "ecode_read.slt0.txt+=\"设备重启\"");
  967. break;
  968. case mqtt600_ec:
  969. sprintf(d2, "ecode_read.slt0.txt+=\"mqtt初始化超时\"");
  970. break;
  971. case mqtt60_ec:
  972. sprintf(d2, "ecode_read.slt0.txt+=\"Mqtt长时间无法连接\"");
  973. break;
  974. case con_timeout_ec:
  975. sprintf(d2, "ecode_read.slt0.txt+=\"联网超时\"");
  976. break;
  977. case w5500_fail_ec:
  978. sprintf(d2, "ecode_read.slt0.txt+=\"W5500初始化出错\"");
  979. break;
  980. case disconn30_ec:
  981. sprintf(d2, "ecode_read.slt0.txt+=\"断线超过30分钟\"");
  982. break;
  983. case data_report_timeout_ec:
  984. sprintf(d2, "ecode_read.slt0.txt+=\"数据补录事件\"");
  985. break;
  986. case sta_report_timeout_ec:
  987. sprintf(d2, "ecode_read.slt0.txt+=\"超时未上报状态信息\"");
  988. break;
  989. case downloade_fw_succ_ec:
  990. switch (se->para)
  991. {
  992. case 0:
  993. sprintf(d2, "ecode_read.slt0.txt+=\"下载固件 (成功)\"");
  994. break;
  995. case 1:
  996. sprintf(d2, "ecode_read.slt0.txt+=\"下载固件 (失败)\"");
  997. break;
  998. default:
  999. break;
  1000. }
  1001. break;
  1002. case Data_supplement_ec:
  1003. sprintf(d2, "ecode_read.slt0.txt+=\"执行数据补录操作 (剩余%d)\"", se->para);
  1004. break;
  1005. case bak_para_ec:
  1006. sprintf(d2, "ecode_read.slt0.txt+=\"备份区参数写入操作 (分区%d)\"", se->para);
  1007. break;
  1008. case res_para_ec:
  1009. sprintf(d2, "ecode_read.slt0.txt+=\"备份区参数还原操作 (分区%d)\"", se->para);
  1010. break;
  1011. case para_set_def_ec:
  1012. sprintf(d2, "ecode_read.slt0.txt+=\"参数复位操作\"");
  1013. break;
  1014. case frequent_disconn_ec:
  1015. sprintf(d2, "ecode_read.slt0.txt+=\"频繁断线上线事件\"");
  1016. break;
  1017. case frequent_REGFail_ec:
  1018. sprintf(d2, "ecode_read.slt0.txt+=\"网络注册失败\"");
  1019. break;
  1020. case platform_change_ec:
  1021. sprintf(d2, "ecode_read.slt0.txt+=\"平台切换事件\"");
  1022. break;
  1023. case Net_Chg_TP_ec:
  1024. sprintf(d2, "ecode_read.slt0.txt+=\"联网失败 切换到贴片卡\"");
  1025. break;
  1026. case Net_Chg_ST_ec:
  1027. sprintf(d2, "ecode_read.slt0.txt+=\"联网失败 切换到实体卡\"");
  1028. break;
  1029. case Net_Chg_YX_ec:
  1030. sprintf(d2, "ecode_read.slt0.txt+=\"联网失败 切换到网线\"");
  1031. break;
  1032. case Plps_elemch:
  1033. sprintf(d2, "ecode_read.slt0.txt+=\"触发了同步elemch\"");
  1034. break;
  1035. case Plps_dp:
  1036. sprintf(d2, "ecode_read.slt0.txt+=\"触发了同步led显示参数\"");
  1037. break;
  1038. case Plps_url:
  1039. sprintf(d2, "ecode_read.slt0.txt+=\"触发了同步url\"");
  1040. break;
  1041. case Data_supp_fail_ec:
  1042. switch (se->para)
  1043. {
  1044. case 0:
  1045. sprintf(d2, "ecode_read.slt0.txt+=\"补录数据校验失败 (上报校验数量失败)\"");
  1046. break;
  1047. case 1:
  1048. sprintf(d2, "ecode_read.slt0.txt+=\"补录数据校验失败 (记录时要素数量校验失败)\"");
  1049. break;
  1050. case 2:
  1051. sprintf(d2, "ecode_read.slt0.txt+=\"补录数据校验失败 (补录时要素数量校验失败)\"");
  1052. break;
  1053. case 3:
  1054. sprintf(d2, "ecode_read.slt0.txt+=\"补录数据校验失败 (存储总量过大)\"");
  1055. break;
  1056. case 4:
  1057. sprintf(d2, "ecode_read.slt0.txt+=\"补录数据校验失败 (非法时间戳)\"");
  1058. break;
  1059. case 5:
  1060. sprintf(d2, "ecode_read.slt0.txt+=\"补录数据校验失败 (非云飞平台)\"");
  1061. break;
  1062. case 9:
  1063. sprintf(d2, "ecode_read.slt0.txt+=\"补录数据 功能被迫关闭\"");
  1064. break;
  1065. default:
  1066. break;
  1067. }
  1068. break;
  1069. case ec_U2_IllData:
  1070. sprintf(d2, "ecode_read.slt0.txt+=\"读取传感器数据错位 已清理\"");
  1071. break;
  1072. case e_reset_rain:
  1073. sprintf(d2, "ecode_read.slt0.txt+=\"雨量数据已清零 %d日\"", se->para);
  1074. break;
  1075. case e_supp_ResetOn:
  1076. sprintf(d2, "ecode_read.slt0.txt+=\"补录功能初始化开启\"");
  1077. break;
  1078. default:
  1079. return;
  1080. break;
  1081. }
  1082. Display_fun(d2);
  1083. rt_thread_delay(15);
  1084. // rt_kprintf("%s ",d2);
  1085. sprintf(d2, "ecode_read.slt0.txt+=\"\\r\"");
  1086. Display_fun(d2);
  1087. rt_thread_delay(15);
  1088. // rt_kprintf("%s\n",d2);
  1089. }
  1090. volatile uint8_t EN_flash_hmi = Zero;
  1091. /**
  1092. * @brief 向屏幕端刷新ecode信息
  1093. *
  1094. */
  1095. void getEcodeData(void)
  1096. {
  1097. rt_kprintf("fun not open yet,Please use after repair\n");
  1098. return;
  1099. RTC_DateTypeDef r_date = {0};
  1100. RTC_TimeTypeDef r_time = {0};
  1101. uint16_t ec_line = 0;
  1102. uint16_t cnt = 0;
  1103. // ef_get_env_blob("e_code", &e_code, sizeof(Record) * (MAX_e_code_NUM), NULL);
  1104. // ef_get_env_blob("e_pointer", &e_pointer, sizeof(e_pointer), NULL);
  1105. //
  1106. // LOG_I("e_code cnt %d", e_pointer);
  1107. // if (e_pointer > 0)
  1108. // {
  1109. // Display_fun("ecode_read.slt0.txt=\"\"");
  1110. // Display_fun("ecode_read.t3.txt=\"\"");
  1111. // EN_flash_hmi = One;
  1112. // rt_thread_mdelay(300);
  1113. // }
  1114. // else
  1115. // {
  1116. // Display_fun("ecode_read.t3.txt=\"当前无异常事件记录\"");
  1117. // return;
  1118. // }
  1119. //
  1120. // se_modle se = {0};
  1121. //
  1122. // if (e_pointer > MAX_e_code_NUM)
  1123. // {
  1124. // ec_line = e_pointer % MAX_e_code_NUM;
  1125. //
  1126. // // rt_kprintf("MARK 1 %d - %d\n" ,ec_line , MAX_e_code_NUM);
  1127. //
  1128. // for (uint16_t a = ec_line; a < (MAX_e_code_NUM); a++)
  1129. // {
  1130. // cnt++;
  1131. // Prase_Time_Stampe(&r_date, &r_time, e_code[a].Time_Stampe);
  1132. //
  1133. // se.date = &r_date;
  1134. // se.time = &r_time;
  1135. // se.code = e_code[a].code;
  1136. // se.para = e_code[a].para;
  1137. // se.a = a - ec_line + 1;
  1138. // se.b = MAX_e_code_NUM;
  1139. //
  1140. // Send_code_data(&se);
  1141. // }
  1142. // // rt_kprintf("MARK 2 %d - %d\n" ,0 , ec_line);
  1143. // for (uint16_t a = 0; a < ec_line; a++)
  1144. // {
  1145. // cnt++;
  1146. // Prase_Time_Stampe(&r_date, &r_time, e_code[a].Time_Stampe);
  1147. //
  1148. // se.date = &r_date;
  1149. // se.time = &r_time;
  1150. // se.code = e_code[a].code;
  1151. // se.para = e_code[a].para;
  1152. // se.a = a + (MAX_e_code_NUM - ec_line) + 1;
  1153. // se.b = MAX_e_code_NUM;
  1154. //
  1155. // Send_code_data(&se);
  1156. // }
  1157. // }
  1158. // else // 不满一环
  1159. // {
  1160. // // rt_kprintf("MARK 3\n");
  1161. //
  1162. // for (uint8_t a = 0; a < e_pointer; a++)
  1163. // {
  1164. // Prase_Time_Stampe(&r_date, &r_time, e_code[a].Time_Stampe);
  1165. //
  1166. // se.date = &r_date;
  1167. // se.time = &r_time;
  1168. // se.code = e_code[a].code;
  1169. // se.para = e_code[a].para;
  1170. // se.a = a + 1;
  1171. // se.b = e_pointer;
  1172. //
  1173. // Send_code_data(&se);
  1174. // }
  1175. // }
  1176. EN_flash_hmi = Zero;
  1177. }
  1178. MSH_CMD_EXPORT(getEcodeData, getEcodeData);
  1179. void delecode(void)
  1180. {
  1181. rt_kprintf("delecode EXE\n");
  1182. ef_log_clean();
  1183. }
  1184. MSH_CMD_EXPORT(delecode, delecode);
  1185. MSH_CMD_EXPORT(printf_ecode, printf_ecode);
  1186. // void ttecode(void)
  1187. //{
  1188. // while(1)
  1189. // {
  1190. // rt_thread_mdelay(600);
  1191. // Recode_e_code(e_supp_ResetOn, 0, levle_high);
  1192. // }
  1193. //
  1194. // }
  1195. // MSH_CMD_EXPORT(ttecode, ttecode);
  1196. /***************** 2022.9.27 为采集器加入e_code *******************/
  1197. /***************** 2022.9.29 加入Guard_thread *******************/
  1198. #define DelayRestartTime 600 //(单位 秒 )
  1199. #define A720_power_PIN GET_PIN(E, 4) // 720供电控制脚
  1200. extern uint16_t is_mqtt_disconnect; // 联网状态标记位
  1201. rt_sem_t report_data_sem = RT_NULL; // 上报数据标记位
  1202. rt_sem_t report_sta_sem = RT_NULL; // 上报状态标记位
  1203. rt_sem_t reconnect_sem = RT_NULL; // 网络连接成功信号量
  1204. rt_sem_t LTEREGFail_sem = RT_NULL; // LTE注册失败信号量
  1205. /**
  1206. * @brief 时分秒转 时间戳 获取当前的时分秒时间戳
  1207. *
  1208. * @param tim 时间戳
  1209. * @param tm 时分秒结构体指针
  1210. */
  1211. static uint32_t Now_TS(void)
  1212. {
  1213. /* Hours, minutes, seconds are easy */
  1214. uint32_t ts = 0;
  1215. ts += (hour * 3600);
  1216. ts += (min * 60);
  1217. ts += (sec * 1);
  1218. return ts;
  1219. }
  1220. extern uint8_t off_ef_env;
  1221. static void Guard_thread_entry(void *param)
  1222. {
  1223. static uint16_t net_cnt = 0; // 联网状态监控
  1224. static uint16_t data_cnt = 0; // 数据上报监控
  1225. static uint16_t sta_cnt = 0; // 状态上报监控
  1226. static uint16_t reconn_cnt = 0; // 异常重连监控计数
  1227. static uint32_t reconn_TS = 0; // 重连时的时刻
  1228. static uint16_t LTEREGFailCnt = 0; // LTE注册失败计数
  1229. static uint32_t LTEREGFailTS = 0; // LTE注册失败的时刻
  1230. report_data_sem = rt_sem_create("rpt_data_s", 0, RT_IPC_FLAG_PRIO); // 数据上报
  1231. report_sta_sem = rt_sem_create("rpt_sta_s", 0, RT_IPC_FLAG_PRIO); // 状态上报
  1232. reconnect_sem = rt_sem_create("reconnect_s", 0, RT_IPC_FLAG_PRIO); // 重连成功
  1233. LTEREGFail_sem = rt_sem_create("LTEREGFail_s", 0, RT_IPC_FLAG_PRIO); // LTE注册失败
  1234. rt_thread_mdelay(120000); // 线程开启由9秒等待 增大至120秒
  1235. // rt_thread_mdelay(20000); //线程开启由9秒等待 增大至120秒
  1236. rt_kprintf("Guard_thread start\n");
  1237. while (1)
  1238. {
  1239. if (off_ef_env == One)
  1240. {
  1241. rt_kprintf("off_ef_env > exit guard\n\n");
  1242. return;
  1243. }
  1244. /********* 监控联网状态 **********/
  1245. if (is_mqtt_disconnect == 0) // 联网成功清零
  1246. {
  1247. net_cnt = 0;
  1248. }
  1249. else
  1250. {
  1251. if (net_cnt++ > 30 * 60) // 断网30分钟进行重启
  1252. {
  1253. rt_kprintf("network timeout\n");
  1254. Recode_e_code(disconn30_ec, 0, "断线超过30分钟");
  1255. RESET_SYSTEM();
  1256. }
  1257. // if(net_cnt % 60 == 0)
  1258. // {
  1259. // rt_kprintf("net_cnt %d\n",net_cnt/60);
  1260. // }
  1261. }
  1262. /********* 监控联网状态 **********/
  1263. /********* 监控数据上报 **********/
  1264. if (rt_sem_take(report_data_sem, RT_WAITING_NO) == RT_EOK) // 有数据上报清零
  1265. {
  1266. data_cnt = 0;
  1267. // rt_kprintf("rpt data\n");
  1268. }
  1269. else if ((is_mqtt_disconnect == 0) && (qxz.Param.upload_interval >= 5)) // 新增校验条件 需要在联网且INR >= 5状态下
  1270. {
  1271. if (data_cnt++ > (qxz.Param.upload_interval * 60 + 60)) // data上报 根据interval确定
  1272. {
  1273. rt_kprintf("rpt data timeout\n");
  1274. Recode_e_code(data_report_timeout_ec, 0, "数据补录事件");
  1275. RESET_SYSTEM();
  1276. }
  1277. // if(data_cnt % 60 == 0)
  1278. // {
  1279. // rt_kprintf("data_cnt %d\n",data_cnt/60);
  1280. // }
  1281. }
  1282. /********* 监控数据上报 **********/
  1283. /********* 监控状态上报 **********/
  1284. if (rt_sem_take(report_sta_sem, RT_WAITING_NO) == RT_EOK) // 有状态上报清零
  1285. {
  1286. sta_cnt = 0;
  1287. // rt_kprintf("rpt sta\n");
  1288. }
  1289. else if (is_mqtt_disconnect == 0) // 新增校验条件 需要在联网状态下
  1290. {
  1291. if (sta_cnt++ > (15 * 60 + 60)) // sta上报是15分钟一次 放宽时间限制
  1292. {
  1293. rt_kprintf("rpt sta timeout\n");
  1294. Recode_e_code(sta_report_timeout_ec, 0, "超时未上报状态信息");
  1295. RESET_SYSTEM();
  1296. }
  1297. // if(sta_cnt % 60 == 0)
  1298. // {
  1299. // rt_kprintf("sta_cnt %d\n",sta_cnt/60);
  1300. // }
  1301. }
  1302. /********* 监控状态上报 **********/
  1303. /********* 监控频繁断线重连 **********/
  1304. if (rt_sem_take(reconnect_sem, RT_WAITING_NO) == RT_EOK) // 有状态上报清零
  1305. {
  1306. if (reconn_TS == 0) // 当第一次联网时
  1307. {
  1308. reconn_TS = Now_TS();
  1309. // rt_kprintf("First Conn\n");
  1310. }
  1311. else if (abs(Now_TS() - reconn_TS) < 180) // 当断线重连间隔小于3分钟时
  1312. {
  1313. reconn_cnt++;
  1314. reconn_TS = Now_TS();
  1315. rt_kprintf("Frequent reconn %d!\n", reconn_cnt);
  1316. }
  1317. else
  1318. {
  1319. reconn_TS = Now_TS();
  1320. rt_kprintf("ReConn \n");
  1321. }
  1322. if (reconn_cnt > 5) // 当频繁断线时
  1323. {
  1324. uint16_t cnt_restart = 0;
  1325. rt_pin_write(A720_power_PIN, PIN_LOW);
  1326. rt_kprintf("Air720 PowerDown!\n");
  1327. while (cnt_restart++ < DelayRestartTime) // 延时10分钟执行重启
  1328. {
  1329. rt_kprintf("\n\ndelayed %d/%d s restart\n\n", cnt_restart, DelayRestartTime);
  1330. rt_thread_mdelay(1000);
  1331. }
  1332. Recode_e_code(frequent_disconn_ec, reconn_cnt, "频繁断线上线事件");
  1333. RESET_SYSTEM();
  1334. }
  1335. }
  1336. /********* 监控频繁断线重连 **********/
  1337. /********* 监控频繁LTE注册失败 **********/
  1338. if (rt_sem_take(LTEREGFail_sem, RT_WAITING_NO) == RT_EOK) // 有状态上报清零
  1339. {
  1340. if (LTEREGFailTS == 0) // 当第一次注册失败时
  1341. {
  1342. LTEREGFailTS = Now_TS();
  1343. // rt_kprintf("First Conn\n");
  1344. }
  1345. else if (abs(Now_TS() - LTEREGFailTS) < 180) // 当注册失败间隔小于3分钟时
  1346. {
  1347. LTEREGFailCnt++;
  1348. LTEREGFailTS = Now_TS();
  1349. rt_kprintf("LTE REG fail cnt %d!\n", LTEREGFailCnt);
  1350. }
  1351. else
  1352. {
  1353. LTEREGFailTS = Now_TS();
  1354. rt_kprintf("LTE REG fails for the first time\n");
  1355. }
  1356. if (LTEREGFailCnt > 5) // 当频繁注册失败时
  1357. {
  1358. Recode_e_code(frequent_REGFail_ec, LTEREGFailCnt, "网络注册失败");
  1359. uint16_t cnt_restart = 0;
  1360. rt_pin_write(A720_power_PIN, PIN_LOW);
  1361. rt_kprintf("Air720 PowerDown!\n");
  1362. while (cnt_restart++ < DelayRestartTime) // 这里给到两分钟重启
  1363. {
  1364. rt_kprintf("\n\ndelayed %d s restart\n\n", (DelayRestartTime - cnt_restart));
  1365. rt_thread_mdelay(1000);
  1366. }
  1367. RESET_SYSTEM();
  1368. }
  1369. }
  1370. /********* 监控频繁LTE注册失败 **********/
  1371. rt_thread_mdelay(1000);
  1372. }
  1373. }
  1374. int Guard_thread(void)
  1375. {
  1376. rt_thread_t tid1 = RT_NULL;
  1377. tid1 = rt_thread_create("Guard",
  1378. Guard_thread_entry, RT_NULL,
  1379. 1024,
  1380. 6, 5); // 给足优先级 ////线程优先级降低至9
  1381. // 如果获得线程控制块,启动这个线程
  1382. if (tid1 != RT_NULL)
  1383. rt_thread_startup(tid1);
  1384. return 1;
  1385. }
  1386. INIT_ENV_EXPORT(Guard_thread); // 警戒线程 保证进入低功耗的最后一道防线
  1387. /***************** 2022.9.29 加入Guard_thread *******************/
  1388. MSH_CMD_EXPORT(ef_print_env, "ef_print_env");
  1389. /***************** 2022.1.1 加入参数备份功能 *******************/
  1390. /*
  1391. // [I/FAL] ==================== FAL partition table ====================
  1392. // [I/FAL] | name | flash_dev | offset | length |
  1393. // [I/FAL] -------------------------------------------------------------
  1394. // [I/FAL] | bl | onchip_flash | 0x00000000 | 0x00020000 |
  1395. // [I/FAL] | app | onchip_flash | 0x00020000 | 0x00060000 |
  1396. // [I/FAL] | easyflash | W25Q128 | 0x00000000 | 0x00e80000 |
  1397. // [I/FAL] | fm_area | W25Q128 | 0x00e80000 | 0x00080000 |
  1398. // [I/FAL] | df_area | W25Q128 | 0x00f00000 | 0x00080000 |
  1399. // [I/FAL] | zk_area | W25Q128 | 0x00f80000 | 0x00080000 |
  1400. // [I/FAL] =============================================================
  1401. */
  1402. /*
  1403. // easyflash 0 ------> 0xE80000
  1404. // ENV 0 ------> 0x016000
  1405. // LOG 0x016000 ------> 0xE16000
  1406. // Para 0xE30000 ------> 0xE60000
  1407. */
  1408. #include <easyflash.h>
  1409. /**
  1410. * @brief 用于MSH指令 打印当前备份区的标记位信息
  1411. *
  1412. * @return uint8_t 当前标记位
  1413. */
  1414. uint8_t read_bak_info(void)
  1415. {
  1416. uint8_t bak_flag = 0;
  1417. ef_port_read(Bak_Para_Addr, (uint32_t *)&bak_flag, 1);
  1418. // rt_kprintf("bak_flg = %d\n", bak_flag);
  1419. // rt_kprintf("Sector size%d \n",sizeof(Sector));
  1420. // rt_kprintf("sensor size%d \n",sizeof(Sensor) * Number_sensors);
  1421. // rt_kprintf("Sensor_CH size%d \n\n",Number_sensors * sizeof(Sensor_CH));
  1422. // bak_para(Zero , ch_bak_part);
  1423. // res_para(ch_bak_part);
  1424. if (bak_flag > 7)
  1425. {
  1426. bak_flag = 0;
  1427. }
  1428. return bak_flag;
  1429. }
  1430. /**
  1431. * @brief 更新flash中的备份参数的使能标记位
  1432. *
  1433. * @param type 操作类型 One->置1 Zero->置0
  1434. * @param num 被操作的位号 1 2 4 分别对应分区1 2 3
  1435. */
  1436. void write_bak_info(uint8_t type, uint8_t num)
  1437. {
  1438. // uint8_t bak_flag = 0;
  1439. //
  1440. // ef_port_read(Bak_Para_Addr, (uint32_t *)&bak_flag, 1);
  1441. //
  1442. // if (bak_flag > 7) // 校验参数
  1443. // {
  1444. // bak_flag = 0;
  1445. // ef_port_erase(Bak_Para_Addr, Erase_Size);
  1446. // ef_port_write(Bak_Para_Addr, (uint32_t *)&bak_flag, 1);
  1447. // }
  1448. //
  1449. // if ((type != One && type != Zero) || (num != 1 && num != 2 && num != 4)) // 校验参数
  1450. // {
  1451. // return;
  1452. // }
  1453. //
  1454. // if (type == One)
  1455. // {
  1456. // bak_flag |= num;
  1457. // }
  1458. // else if (type == Zero)
  1459. // {
  1460. // bak_flag &= (~num);
  1461. // }
  1462. //
  1463. // ef_port_erase(Bak_Para_Addr, Erase_Size);
  1464. //
  1465. // rt_kprintf("write bak_flag %d -> %d\n", bak_flag, ef_port_write(Bak_Para_Addr, (uint32_t *)&bak_flag, 1));
  1466. }
  1467. // #define qxz_bak_part 1 //qxz结构体的备份区
  1468. // #define elem_bak_part 2 //要素信息的备份区
  1469. // #define ch_bak_part 3 //通道信息的备份区
  1470. /**
  1471. * @brief 向flash更新参数
  1472. *
  1473. * @param type One -> 强制更新 Zero -> 按需更新
  1474. * @param num
  1475. * @return uint8_t 执行结果 0 失败 1 成功
  1476. */
  1477. uint8_t bak_para(uint8_t type, uint8_t num)
  1478. {
  1479. uint8_t result = 0;
  1480. // uint8_t bak_flag = 0;
  1481. // uint8_t para_n = 0;
  1482. // uint8_t upgrade_n = 0;
  1483. // uint8_t up_elem = One;
  1484. //
  1485. // if ((type != One && type != Zero) || (num != 1 && num != 2 && num != 3)) // 校验参数
  1486. // {
  1487. // return result;
  1488. // }
  1489. //
  1490. // if (num == 3)
  1491. // {
  1492. // para_n = 4;
  1493. // }
  1494. // else
  1495. // {
  1496. // para_n = num;
  1497. // }
  1498. //
  1499. // ef_port_read(Bak_Para_Addr, (uint32_t *)&bak_flag, 1);
  1500. //
  1501. // if (bak_flag > 7) // 校验参数
  1502. // {
  1503. // bak_flag = 0;
  1504. // ef_port_write(Bak_Para_Addr, (uint32_t *)&bak_flag, 1);
  1505. // }
  1506. //
  1507. // if (type == One) // 当强制更新时
  1508. // {
  1509. // upgrade_n = num;
  1510. // }
  1511. // else if ((type == Zero) && ((bak_flag & para_n) == 0)) // 当按需更新时
  1512. // {
  1513. // upgrade_n = num;
  1514. // }
  1515. // else
  1516. // {
  1517. // return result;
  1518. // }
  1519. //
  1520. // switch (upgrade_n)
  1521. // {
  1522. // case qxz_bak_part:
  1523. //
  1524. // ef_port_erase(Bak_Para_Addr + Para_Size * qxz_bak_part, Para_Use_Size);
  1525. //
  1526. // // rt_kprintf("write %d start %06X size %04X -> %d\n",
  1527. // // upgrade_n,
  1528. // // Bak_Para_Addr + Para_Size * qxz_bak_part,
  1529. // // sizeof(Sector),
  1530. // // ef_port_write(Bak_Para_Addr + Para_Size * qxz_bak_part, (uint32_t *)&qxz, sizeof(Sector)));
  1531. //
  1532. // if (ef_port_write(Bak_Para_Addr + Para_Size * qxz_bak_part, (uint32_t *)&qxz, sizeof(Sector)) == 0)
  1533. // {
  1534. // result = 1;
  1535. // upgrade_bak_crc(qxz_bak_part);
  1536. // }
  1537. //
  1538. // break;
  1539. //
  1540. // case elem_bak_part:
  1541. // {
  1542. // uint8_t cnt = 0;
  1543. // uint8_t cbuf[sizeof(Sensor)] = {0};
  1544. //
  1545. // ef_port_erase(Bak_Para_Addr + Para_Size * elem_bak_part, 0x1000);
  1546. //
  1547. // for (uint8_t i = 0; i < Number_sensors; i++)
  1548. // {
  1549. // memset(cbuf, 0, sizeof(cbuf));
  1550. // if (rt_strcmp(SENSOR_CH[i].eName, "\0") == 0) // 若不存在通道名
  1551. // {
  1552. // continue;
  1553. // }
  1554. // /**
  1555. // * @brief Construct a new memcpy object
  1556. // *
  1557. // * 260611 备份还原时不允许val有值
  1558. // *
  1559. // */
  1560. // sensor[i].value = 0;
  1561. // memcpy(sensor[i].eValue, 0, sizeof(sensor[i].eValue));
  1562. // /**
  1563. // * @brief Construct a new memcpy object
  1564. // *
  1565. // * 260611 备份还原时不允许val有值
  1566. // *
  1567. // */
  1568. // memcpy(cbuf, &(sensor[i]), sizeof(Sensor));
  1569. //
  1570. // rt_kprintf("bak elem[%d] >> %s\r\n", cnt, sensor[cnt].eName);
  1571. // ef_port_write((Bak_Para_Addr + Para_Size * elem_bak_part + cnt * sizeof(Sensor)), (uint32_t *)cbuf, sizeof(cbuf));
  1572. // cnt++;
  1573. // }
  1574. //
  1575. // if (cnt > 0) // 存入完成 记录一下存入量
  1576. // {
  1577. // result = 1;
  1578. //
  1579. // uint32_t elemcnt = cnt * sizeof(Sensor);
  1580. // ef_port_erase(Bak_elem_size_Addr, 0x1000);
  1581. // ef_port_write(Bak_elem_size_Addr, (uint32_t *)&elemcnt, sizeof(uint32_t));
  1582. // rt_kprintf("write bakelem size > %d \n\n", elemcnt);
  1583. // upgrade_bak_crc(elem_bak_part);
  1584. // }
  1585. // }
  1586. //
  1587. // break;
  1588. //
  1589. // case ch_bak_part:
  1590. //
  1591. // ef_port_erase(Bak_Para_Addr + Para_Size * ch_bak_part, 0x1000);
  1592. //
  1593. // uint8_t ccnt = 0;
  1594. // uint8_t ccbuf[sizeof(Sensor_CH)] = {0};
  1595. //
  1596. // for (uint8_t i = 0; i < Number_sensors; i++)
  1597. // {
  1598. // memset(ccbuf, 0, sizeof(ccbuf));
  1599. // if (rt_strcmp(SENSOR_CH[i].eName, "\0") == 0) // 若不存在通道名
  1600. // {
  1601. // continue;
  1602. // }
  1603. // memcpy(ccbuf, &(SENSOR_CH[i]), sizeof(Sensor_CH));
  1604. // rt_kprintf("bak ch[%d] >> %s\r\n", ccnt, SENSOR_CH[i].eName);
  1605. // ccnt++;
  1606. // // ef_port_write((Bak_Para_Addr + Para_Size * ch_bak_part + ccnt * sizeof(Sensor_CH)), (uint32_t *)ccbuf, sizeof(ccbuf));
  1607. // }
  1608. //
  1609. // if (ccnt > 0) // 存入完成 记录一下存入量
  1610. // {
  1611. // result = 1;
  1612. // uint32_t chcnt = ccnt * sizeof(Sensor_CH);
  1613. //
  1614. // ef_port_write((Bak_Para_Addr + Para_Size * ch_bak_part), (uint32_t *)SENSOR_CH, chcnt);
  1615. //
  1616. // ef_port_erase(Bak_ch_size_Addr, 0x1000);
  1617. // ef_port_write(Bak_ch_size_Addr, (uint32_t *)&chcnt, sizeof(uint32_t));
  1618. // rt_kprintf("write bakch size > %d \n\n", chcnt);
  1619. // upgrade_bak_crc(chcnt);
  1620. // }
  1621. //
  1622. // if (ef_port_write(Bak_Para_Addr + Para_Size * ch_bak_part, (uint32_t *)SENSOR_CH, sizeof(Sensor_CH) * Number_sensors) == 0)
  1623. // {
  1624. // upgrade_bak_crc(ch_bak_part);
  1625. // result = 1;
  1626. // }
  1627. //
  1628. // break;
  1629. //
  1630. // default:
  1631. // break;
  1632. // }
  1633. //
  1634. // if (result == 1)
  1635. // {
  1636. // Recode_e_code(bak_para_ec, num, "备份区参数写入操作"); // 记录事件
  1637. // if ((read_bak_info() & para_n) != para_n) // 按需更新标记位
  1638. // {
  1639. // write_bak_info(One, para_n);
  1640. // }
  1641. // }
  1642. return result;
  1643. }
  1644. /**
  1645. * @brief 从备份区中恢复参数
  1646. *
  1647. * @param num 分区号
  1648. * @return uint8_t 执行结果 0 失败 1 成功
  1649. */
  1650. uint8_t res_para(uint8_t num)
  1651. {
  1652. uint8_t result = 0;
  1653. // uint8_t bak_flag = 0;
  1654. // uint8_t restor_n = 0;
  1655. //
  1656. // /****************** 校验参数 ********************/
  1657. //
  1658. // if (num < 1 || num > 3)
  1659. // {
  1660. // return result;
  1661. // }
  1662. // if (check_bak_crc(num) != 1)
  1663. // {
  1664. // rt_kprintf("res_para %d fail, crc wrong \n", num);
  1665. // write_bak_info(Zero, num);
  1666. // return result;
  1667. // }
  1668. // if (num == 3)
  1669. // {
  1670. // restor_n = 4;
  1671. // }
  1672. // else
  1673. // {
  1674. // restor_n = num;
  1675. // }
  1676. //
  1677. // ef_port_read(Bak_Para_Addr, (uint32_t *)&bak_flag, 1);
  1678. //
  1679. // if (bak_flag > 7)
  1680. // {
  1681. // bak_flag = 0;
  1682. // ef_port_write(Bak_Para_Addr, (uint32_t *)&bak_flag, 1);
  1683. // }
  1684. //
  1685. // if ((restor_n & bak_flag) != restor_n)
  1686. // {
  1687. // return result;
  1688. // }
  1689. //
  1690. // /****************** 校验参数 ********************/
  1691. //
  1692. // rt_kprintf("restore para %d from bak\n", num);
  1693. //
  1694. // switch (num)
  1695. // {
  1696. // case qxz_bak_part:
  1697. //
  1698. // if (ef_port_read(Bak_Para_Addr + Para_Size * qxz_bak_part, (uint32_t *)&qxz, sizeof(Sector)) == 0)
  1699. // {
  1700. // result = 1;
  1701. // }
  1702. // break;
  1703. //
  1704. // case elem_bak_part:
  1705. //
  1706. // {
  1707. // uint32_t elemcnt = 0;
  1708. //
  1709. // ef_port_read(Bak_elem_size_Addr, (uint32_t *)&elemcnt, sizeof(uint32_t));
  1710. //
  1711. // if (elemcnt <= (Number_sensors * sizeof(Sensor)))
  1712. // {
  1713. // memset(sensor, 0, Number_sensors * sizeof(Sensor));
  1714. // }
  1715. // else
  1716. // {
  1717. // return 0;
  1718. // }
  1719. //
  1720. // if (ef_port_read(Bak_Para_Addr + Para_Size * elem_bak_part, (uint32_t *)sensor, elemcnt) == 0)
  1721. // {
  1722. // result = 1;
  1723. // for (char a = 0; a < Number_sensors; a++)
  1724. // {
  1725. // /**
  1726. // * @brief Construct a new memcpy object
  1727. // *
  1728. // * 260611 备份还原时不允许val有值
  1729. // *
  1730. // */
  1731. // sensor[a].value = 0;
  1732. // memcpy(sensor[a].eValue, 0, sizeof(sensor[a].eValue));
  1733. // /**
  1734. // * @brief Construct a new memcpy object
  1735. // *
  1736. // * 260611 备份还原时不允许val有值
  1737. // *
  1738. // */
  1739. // }
  1740. // }
  1741. // }
  1742. //
  1743. // break;
  1744. //
  1745. // case ch_bak_part:
  1746. //
  1747. // {
  1748. // uint32_t chcnt = 0;
  1749. //
  1750. // ef_port_read(Bak_ch_size_Addr, (uint32_t *)&chcnt, sizeof(uint32_t));
  1751. //
  1752. // if (chcnt <= (Number_sensors * sizeof(Sensor_CH)))
  1753. // {
  1754. // memset(SENSOR_CH, 0, Number_sensors * sizeof(Sensor_CH));
  1755. // }
  1756. // else
  1757. // {
  1758. // return 0;
  1759. // }
  1760. //
  1761. // if (ef_port_read(Bak_Para_Addr + Para_Size * ch_bak_part, (uint32_t *)SENSOR_CH, chcnt) == 0)
  1762. // {
  1763. // result = 1;
  1764. // }
  1765. // }
  1766. // break;
  1767. //
  1768. // default:
  1769. // break;
  1770. // }
  1771. //
  1772. // if (result == 1)
  1773. // {
  1774. // Recode_e_code(res_para_ec, num, "备份区参数还原操作");
  1775. // }
  1776. return result;
  1777. }
  1778. #define CRC_RESET_VAL 0xFFFFFFFF // 计算CRC时的初始值
  1779. /**
  1780. * @brief 产生CRC32校验值
  1781. *
  1782. * @param buf 数据指针
  1783. * @param len 长度
  1784. * @return uint32_t 计算结果
  1785. */
  1786. uint32_t CRC32(uint8_t *buf, uint16_t len)
  1787. {
  1788. uint32_t i, j;
  1789. uint32_t crc = CRC_RESET_VAL;
  1790. for (j = 0; j < len; j++)
  1791. {
  1792. crc = crc ^ buf[j];
  1793. for (i = 0; i < 8; i++)
  1794. {
  1795. crc = (crc >> 1) ^ (0xEDB88320 & -(crc & 1));
  1796. }
  1797. }
  1798. crc = ~crc;
  1799. return crc;
  1800. }
  1801. /**
  1802. * @brief 计算CRC_32值 可连续
  1803. *
  1804. * @param lenght 本次计算数据长度
  1805. * @param crc_buf 需要计算的数据
  1806. * @param _CRC 存放CRC值的指针(传入值不为0XFFFFFFFF 则做连续计算)
  1807. * @return uint32_t
  1808. */
  1809. uint32_t CRC_32_For_FW(uint32_t lenght, uint8_t *crc_buf, uint32_t *_CRC)
  1810. {
  1811. uint32_t i, j;
  1812. // uint32_t crc = _CRC;
  1813. if (*_CRC != CRC_RESET_VAL)
  1814. {
  1815. *_CRC = ~*_CRC;
  1816. }
  1817. for (j = 0; j < lenght; j++)
  1818. {
  1819. *_CRC = *_CRC ^ crc_buf[j];
  1820. for (i = 0; i < 8; i++)
  1821. {
  1822. *_CRC = (*_CRC >> 1) ^ (0xEDB88320 & -(*_CRC & 1));
  1823. }
  1824. }
  1825. *_CRC = ~*_CRC;
  1826. // rt_kprintf("CRC32 > %d > %X %X\n",lenght , crc_buf[0] , *_CRC);
  1827. return *_CRC;
  1828. }
  1829. #define cbuf_size 128
  1830. /**
  1831. * @brief 校验内存中参数区的CRC
  1832. *
  1833. * @param part 分区号
  1834. * @return uint32_t CRC32
  1835. */
  1836. uint32_t get_ram_part_crc(BakPart part)
  1837. {
  1838. uint8_t cbuf[cbuf_size] = {0}; // 用于临时存放被校验数据
  1839. uint16_t csize = 0; // 被校验数据量
  1840. uint32_t *cpoint = NULL; // 被校验数据指针
  1841. // rt_kprintf(" get_ram_part_crc >> %d \n\n", part);
  1842. switch (part)
  1843. {
  1844. case qxz_bak_part:
  1845. cpoint = (uint32_t *)&qxz;
  1846. csize = sizeof(Sector);
  1847. break;
  1848. case elem_bak_part:
  1849. cpoint = (uint32_t *)sensor;
  1850. uint16_t ram_elem_cnt = 0;
  1851. for (uint8_t n = 0, i = 0; i < Number_sensors; i++)
  1852. {
  1853. if (rt_strcmp(SENSOR_CH[i].eName, "\0") != 0) // 存在通道名
  1854. {
  1855. ram_elem_cnt++;
  1856. }
  1857. }
  1858. csize = sizeof(Sensor) * ram_elem_cnt;
  1859. // rt_kprintf("ram elem > %d \n", csize);
  1860. // csize = sizeof(Sensor) * 5;
  1861. break;
  1862. case ch_bak_part:
  1863. cpoint = (uint32_t *)SENSOR_CH;
  1864. uint16_t ram_ch_cnt = 0;
  1865. for (uint8_t n = 0, i = 0; i < Number_sensors; i++)
  1866. {
  1867. if (rt_strcmp(SENSOR_CH[i].eName, "\0") != 0) // 存在通道名
  1868. {
  1869. ram_ch_cnt++;
  1870. }
  1871. }
  1872. csize = sizeof(Sensor_CH) * ram_ch_cnt;
  1873. // rt_kprintf("ram ch > %d \n", csize);
  1874. break;
  1875. default:
  1876. return 0;
  1877. break;
  1878. }
  1879. uint16_t for_time = 0;
  1880. uint16_t Num_Of_Read = 0;
  1881. uint16_t Num_Of_leek = 0;
  1882. uint32_t CRC32 = CRC_RESET_VAL;
  1883. if (csize % cbuf_size == 0)
  1884. {
  1885. for_time = csize / cbuf_size;
  1886. }
  1887. else
  1888. {
  1889. for_time = csize / cbuf_size + 1;
  1890. }
  1891. for (uint16_t a = 0; a < for_time; a++)
  1892. {
  1893. memset(cbuf, 0, cbuf_size);
  1894. if (a == (for_time - 1) && csize % cbuf_size != 0)
  1895. {
  1896. Num_Of_Read = csize % cbuf_size;
  1897. }
  1898. else
  1899. {
  1900. Num_Of_Read = cbuf_size;
  1901. }
  1902. memcpy(cbuf, (uint8_t *)(cpoint + (Num_Of_leek / 4)), Num_Of_Read);
  1903. // rt_kprintf("memcpy %08X >> %d\n" ,(uint8_t *)(cpoint + (Num_Of_leek/4)) , Num_Of_Read);
  1904. // if (part == elem_bak_part && (a == 0 || a == 1 || a == 2))
  1905. // for (uint16_t v = 0; v < cbuf_size; v++)
  1906. // {
  1907. // rt_kprintf("%02X ", cbuf[v]);
  1908. // if ((v + 1) % 32 == 0)
  1909. // {
  1910. // rt_kprintf("\n");
  1911. // }
  1912. // else if ((v + 1) % 8 == 0)
  1913. // {
  1914. // rt_kprintf(" ");
  1915. // }
  1916. // }
  1917. // if (a == 0)
  1918. // {
  1919. // rt_kprintf("ram >> %08X \n\n", CRC32);
  1920. // }
  1921. CRC_32_For_FW(Num_Of_Read, (uint8_t *)cbuf, &CRC32);
  1922. // if (a < 3)
  1923. // {
  1924. // rt_kprintf("%d >> %08X \n\n", a, CRC32);
  1925. // }
  1926. Num_Of_leek += Num_Of_Read;
  1927. }
  1928. // if(part == ch_bak_part)
  1929. // {
  1930. // rt_kprintf(" RAM CH CRC %08X\n\n",CRC32);
  1931. // }
  1932. return CRC32;
  1933. }
  1934. /**
  1935. * @brief 校验备份参数区的CRC
  1936. *
  1937. * @param part 分区号
  1938. * @return uint32_t CRC32
  1939. */
  1940. uint32_t get_bak_part_crc(BakPart part)
  1941. {
  1942. uint8_t cbuf[cbuf_size] = {0}; // 用于临时存放被校验数据
  1943. uint16_t csize = 0; // 被校验数据量
  1944. uint32_t cpoint = 0; // 被校验数据指针
  1945. // rt_kprintf(" get_bak_part_crc >> %d \n\n", part);
  1946. switch (part)
  1947. {
  1948. case qxz_bak_part:
  1949. cpoint = Bak_Para_Addr + Para_Size * part;
  1950. csize = sizeof(Sector);
  1951. break;
  1952. case elem_bak_part:
  1953. cpoint = Bak_Para_Addr + Para_Size * part;
  1954. uint32_t elemcnt = 0;
  1955. ef_port_read(Bak_elem_size_Addr, (uint32_t *)&elemcnt, sizeof(uint32_t));
  1956. csize = elemcnt;
  1957. // rt_kprintf(" bak elem > %d\n", elemcnt);
  1958. // csize = sizeof(Sensor) * 5;
  1959. break;
  1960. case ch_bak_part:
  1961. cpoint = Bak_Para_Addr + Para_Size * part;
  1962. uint32_t chcnt = 0;
  1963. ef_port_read(Bak_ch_size_Addr, (uint32_t *)&chcnt, sizeof(uint32_t));
  1964. csize = chcnt;
  1965. // rt_kprintf(" bak ch > %d\n", chcnt);
  1966. break;
  1967. default:
  1968. return 0;
  1969. break;
  1970. }
  1971. uint16_t for_time = 0;
  1972. uint16_t Num_Of_Read = 0;
  1973. uint16_t Num_Of_leek = 0;
  1974. uint32_t CRC32 = CRC_RESET_VAL;
  1975. if (csize % cbuf_size == 0)
  1976. {
  1977. for_time = csize / cbuf_size;
  1978. }
  1979. else
  1980. {
  1981. for_time = csize / cbuf_size + 1;
  1982. }
  1983. for (uint16_t a = 0; a < for_time; a++)
  1984. {
  1985. memset(cbuf, 0, cbuf_size);
  1986. if (a == (for_time - 1) && csize % cbuf_size != 0)
  1987. {
  1988. Num_Of_Read = csize % cbuf_size;
  1989. }
  1990. else
  1991. {
  1992. Num_Of_Read = cbuf_size;
  1993. }
  1994. ef_port_read((cpoint + Num_Of_leek), (uint32_t *)cbuf, cbuf_size);
  1995. // if (part == elem_bak_part && (a == 1 || a == 2 || a == 0))
  1996. // for (uint16_t v = 0; v < Num_Of_Read; v++)
  1997. // {
  1998. // rt_kprintf("%02X ", cbuf[v]);
  1999. // if ((v + 1) % 32 == 0)
  2000. // {
  2001. // rt_kprintf("\n");
  2002. // }
  2003. // else if ((v + 1) % 8 == 0)
  2004. // {
  2005. // rt_kprintf(" ");
  2006. // }
  2007. // }
  2008. // if (a == 0)
  2009. // {
  2010. // rt_kprintf("bak >> %08X \n\n", CRC32);
  2011. // }
  2012. CRC_32_For_FW(Num_Of_Read, (uint8_t *)cbuf, &CRC32);
  2013. // if (a < 3)
  2014. // {
  2015. // rt_kprintf("%d >> %08X \n\n", a, CRC32);
  2016. // }
  2017. Num_Of_leek += Num_Of_Read;
  2018. }
  2019. return CRC32;
  2020. }
  2021. /**
  2022. * @brief 更新备份区数据的记录crc
  2023. *
  2024. */
  2025. void upgrade_bak_crc(BakPart part)
  2026. {
  2027. BakCrc bakcrc = {0};
  2028. ef_port_read(Bak_Crc_Addr, (uint32_t *)&bakcrc, sizeof(BakCrc));
  2029. // if(part == ch_bak_part)
  2030. // {
  2031. // rt_kprintf("1 - %08X \n", bakcrc.qxz_crc);
  2032. // rt_kprintf("2 - %08X \n", bakcrc.elem_crc);
  2033. // rt_kprintf("3 - %08X \n", bakcrc.ch_crc);
  2034. // rt_kprintf("0 - %08X \n\n\n", bakcrc.all_crc);
  2035. // }
  2036. switch (part)
  2037. {
  2038. case qxz_bak_part:
  2039. bakcrc.qxz_crc = get_ram_part_crc(qxz_bak_part);
  2040. break;
  2041. case elem_bak_part:
  2042. bakcrc.elem_crc = get_ram_part_crc(elem_bak_part);
  2043. break;
  2044. case ch_bak_part:
  2045. bakcrc.ch_crc = get_ram_part_crc(ch_bak_part);
  2046. break;
  2047. default:
  2048. return;
  2049. break;
  2050. }
  2051. bakcrc.all_crc = CRC_RESET_VAL;
  2052. CRC_32_For_FW((sizeof(BakCrc) - sizeof(uint32_t)), (uint8_t *)&bakcrc, &bakcrc.all_crc);
  2053. // bakcrc.all_crc = CRC32((uint8_t *)&bakcrc , (sizeof(BakCrc) - sizeof(uint32_t)));
  2054. // if(part == ch_bak_part)
  2055. // {
  2056. // rt_kprintf("1 - %08X \n", bakcrc.qxz_crc);
  2057. // rt_kprintf("2 - %08X \n", bakcrc.elem_crc);
  2058. // rt_kprintf("3 - %08X \n", bakcrc.ch_crc);
  2059. // rt_kprintf("0 - %08X \n\n\n", bakcrc.all_crc);
  2060. // }
  2061. ef_port_erase(Bak_Crc_Addr, Erase_Size);
  2062. ef_port_write(Bak_Crc_Addr, (uint32_t *)&bakcrc, sizeof(BakCrc));
  2063. }
  2064. /**
  2065. * @brief 检查当前备份区数据是否有效
  2066. *
  2067. * @return uint8_t 执行结果 0 失败 1 成功
  2068. */
  2069. uint8_t check_bak_crc(BakPart part)
  2070. {
  2071. /**
  2072. * @brief 为了保证严谨性 检查分为两步进行
  2073. *
  2074. */
  2075. /**
  2076. * @brief 第一步校验备份区的crc数据是否可信
  2077. *
  2078. */
  2079. uint8_t result = 0;
  2080. BakCrc bakcrc = {0};
  2081. uint32_t CRC32 = CRC_RESET_VAL;
  2082. ef_port_read(Bak_Crc_Addr, (uint32_t *)&bakcrc, sizeof(BakCrc));
  2083. CRC_32_For_FW((sizeof(BakCrc) - sizeof(uint32_t)), (uint8_t *)&bakcrc, &CRC32);
  2084. if (CRC32 != bakcrc.all_crc)
  2085. {
  2086. rt_kprintf("bak_crc check fail. \n");
  2087. }
  2088. /**
  2089. * @brief 第二步将要校验的分区的数据读出进行校验
  2090. *
  2091. */
  2092. CRC32 = get_bak_part_crc(part);
  2093. switch (part)
  2094. {
  2095. case qxz_bak_part:
  2096. if (CRC32 == bakcrc.qxz_crc)
  2097. {
  2098. result = 1;
  2099. }
  2100. break;
  2101. case elem_bak_part:
  2102. if (CRC32 == bakcrc.elem_crc)
  2103. {
  2104. result = 1;
  2105. }
  2106. break;
  2107. case ch_bak_part:
  2108. rt_kprintf(" get_bak_part_crc >> %08X\n\n", CRC32);
  2109. if (CRC32 == bakcrc.ch_crc)
  2110. {
  2111. result = 1;
  2112. }
  2113. break;
  2114. default:
  2115. return result;
  2116. break;
  2117. }
  2118. if (result)
  2119. {
  2120. rt_kprintf("part %d check pass \n", part);
  2121. }
  2122. return result;
  2123. }
  2124. /**
  2125. * @brief 还原所有备份分区
  2126. *
  2127. */
  2128. void Restor_para(BakPart part)
  2129. {
  2130. switch (part)
  2131. {
  2132. case qxz_bak_part:
  2133. if (res_para(qxz_bak_part) == 1) // 把qxz参数存到flash中
  2134. {
  2135. ef_set_env_blob("iSave", &qxz.Param.iSave, sizeof(qxz.Param.iSave));
  2136. ef_set_env_blob("sim_switch", &qxz.Param.sim_switch, sizeof(qxz.Param.sim_switch));
  2137. ef_set_env_blob("application_model", &qxz.Param.application_model, sizeof(qxz.Param.application_model));
  2138. ef_set_env_blob("save_flash_flag", &qxz.Param.save_flash_flag, sizeof(qxz.Param.save_flash_flag));
  2139. ef_set_env_blob("save_uflash_flag", &qxz.Param.save_uflash_flag, sizeof(qxz.Param.save_uflash_flag));
  2140. ef_set_env_blob("display_dotscreen_flag", &qxz.Param.display_dotscreen_flag, sizeof(qxz.Param.display_dotscreen_flag));
  2141. ef_set_env_blob("save_interval", &qxz.Param.save_interval, sizeof(qxz.Param.save_interval));
  2142. ef_set_env_blob("screen_timeout", &qxz.Param.screen_timeout, sizeof(qxz.Param.screen_timeout));
  2143. ef_set_env_blob("upload_mode_swtich_flag", &qxz.Param.upload_mode_swtich_flag, sizeof(qxz.Param.upload_mode_swtich_flag));
  2144. ef_set_env_blob("use_dhcp", &qxz.Param.use_dhcp, sizeof(qxz.Param.use_dhcp));
  2145. ef_set_env_blob("use_eeprom", &qxz.Param.use_eeprom, sizeof(qxz.Param.use_eeprom));
  2146. ef_set_env_blob("Split_Moisture", &qxz.Param.Split_Moisture, sizeof(qxz.Param.Split_Moisture));
  2147. ef_set_env_blob("local_ip", &qxz.Param.local_ip, sizeof(qxz.Param.local_ip));
  2148. ef_set_env_blob("subnet", &qxz.Param.subnet, sizeof(qxz.Param.subnet));
  2149. ef_set_env_blob("gateway", &qxz.Param.gateway, sizeof(qxz.Param.gateway));
  2150. ef_set_env_blob("dns_server", &qxz.Param.dns_server, sizeof(qxz.Param.dns_server));
  2151. ef_set_env_blob("remote_ip", &qxz.Param.remote_ip, sizeof(qxz.Param.remote_ip));
  2152. ef_set_env_blob("remote_bg_ip", &qxz.Param.remote_bg_ip, sizeof(qxz.Param.remote_bg_ip));
  2153. ef_set_env_blob("remote_port", &qxz.Param.remote_port, sizeof(qxz.Param.remote_port));
  2154. ef_set_env_blob("remote_bg_port", &qxz.Param.remote_bg_port, sizeof(qxz.Param.remote_bg_port));
  2155. ef_set_env_blob("sub", qxz.Param.sub, sizeof(qxz.Param.sub));
  2156. ef_set_env_blob("pub", qxz.Param.pub, sizeof(qxz.Param.pub));
  2157. ef_set_env_blob("usr", qxz.Param.usr, sizeof(qxz.Param.usr));
  2158. ef_set_env_blob("pwd", qxz.Param.pwd, sizeof(qxz.Param.pwd));
  2159. ef_set_env_blob("bg_sub", qxz.Param.bg_sub, sizeof(qxz.Param.bg_sub));
  2160. ef_set_env_blob("bg_pub", qxz.Param.bg_pub, sizeof(qxz.Param.bg_pub));
  2161. ef_set_env_blob("device_sn", qxz.Param.device_sn, sizeof(qxz.Param.device_sn));
  2162. ef_set_env_blob("Dotled_Option", &qxz.Param.Dotled_Option, sizeof(qxz.Param.Dotled_Option));
  2163. ef_set_env_blob("upgrade_url", &qxz.Param.upgrade_url, sizeof(qxz.Param.upgrade_url));
  2164. /*** 23.5.20 新增 ***/
  2165. ef_set_env_blob("dotled_p0", &qxz.Param.dotled_p0, sizeof(qxz.Param.dotled_p0));
  2166. /*** 23.7.05 新增 ***/
  2167. ef_set_env_blob("platform_f", &qxz.Param.platform_f, sizeof(qxz.Param.platform_f));
  2168. }
  2169. break;
  2170. case elem_bak_part:
  2171. if (res_para(elem_bak_part) == 1)
  2172. {
  2173. uint32_t elemcnt = 0;
  2174. ef_port_read(Bak_elem_size_Addr, (uint32_t *)&elemcnt, sizeof(uint32_t));
  2175. for (uint8_t a = 0; a < (elemcnt / sizeof(Sensor)); a++)
  2176. {
  2177. if (rt_strstr(SENSOR_CH[a].eName, sensor[a].eName) != NULL) // 存在通道名
  2178. {
  2179. rt_kprintf(" res a elem[%d].eName:%s\r\n", a, sensor[a].eName);
  2180. ef_set_env_blob(sensor[a].eName, &sensor[a], sizeof(Sensor));
  2181. }
  2182. else
  2183. {
  2184. rt_kprintf(" not match a elem[%d].eName:%s > %s\r\n", a, sensor[a].eName, SENSOR_CH[a].eName);
  2185. }
  2186. }
  2187. }
  2188. else
  2189. {
  2190. rt_kprintf("res_para elem_bak_part else \n\n");
  2191. }
  2192. break;
  2193. case ch_bak_part:
  2194. if (res_para(ch_bak_part) == 1)
  2195. {
  2196. uint32_t chcnt = 0;
  2197. ef_port_read(Bak_ch_size_Addr, (uint32_t *)&chcnt, sizeof(uint32_t));
  2198. rt_kprintf("chcnt >> %d \n\n", chcnt);
  2199. for (uint8_t b = 0; b < Number_sensors; b++)
  2200. {
  2201. if (rt_strcmp(SENSOR_CH[b].eName, "\0") != 0) // 存在通道名
  2202. {
  2203. rt_kprintf(" res CH[%d].eName:%s\r\n", b, SENSOR_CH[b].eName);
  2204. }
  2205. }
  2206. ef_set_env_blob("SENSOR_CH_M0", SENSOR_CH, sizeof(Sensor_CH) * Number_sensors);
  2207. }
  2208. else
  2209. {
  2210. rt_kprintf("res_para ch_bak_part else \n\n");
  2211. }
  2212. break;
  2213. default:
  2214. break;
  2215. }
  2216. }
  2217. /**
  2218. * @brief 使用备份区参数校验当前env参数的正确性 CRC
  2219. *
  2220. * @return uint8_t 0 -> 校验失败 1 -> 校验成功 2 -> 备份区校验失败
  2221. */
  2222. uint8_t check_sys_para(BakChktyp type)
  2223. {
  2224. uint8_t result = 2;
  2225. /**
  2226. * @brief 第一步校验备份区的crc数据是否可信
  2227. *
  2228. */
  2229. BakCrc bakcrc = {0};
  2230. uint32_t CRC32 = CRC_RESET_VAL;
  2231. ef_port_read(Bak_Crc_Addr, (uint32_t *)&bakcrc, sizeof(BakCrc));
  2232. CRC_32_For_FW((sizeof(BakCrc) - sizeof(uint32_t)), (uint8_t *)&bakcrc, &CRC32);
  2233. if (CRC32 != bakcrc.all_crc)
  2234. {
  2235. rt_kprintf("bak_crc check fail. \n");
  2236. return 2;
  2237. }
  2238. /**
  2239. * @brief 第二步校验内存中的参数CRC
  2240. *
  2241. */
  2242. switch (type)
  2243. {
  2244. case chk_qxz:
  2245. if (read_bak_info() & (1 << (qxz_bak_part - 1)))
  2246. {
  2247. CRC32 = CRC_RESET_VAL;
  2248. CRC32 = get_ram_part_crc(qxz_bak_part);
  2249. if (CRC32 == bakcrc.qxz_crc)
  2250. {
  2251. result = 1;
  2252. rt_kprintf(" qxz_crc pass \n\n");
  2253. }
  2254. else
  2255. {
  2256. rt_kprintf("qxz_crc check fail. %08X(ram) - %08X(bak) \n", CRC32, bakcrc.qxz_crc);
  2257. // rt_kprintf("get_ram_part_crc >> %08X \n\n", get_ram_part_crc(qxz_bak_part));
  2258. // rt_kprintf("\n\get_bak_part_crc >> %08X \n\n", get_bak_part_crc(qxz_bak_part));
  2259. return 0;
  2260. }
  2261. }
  2262. else
  2263. {
  2264. rt_kprintf("qxz_bak_part not found\n");
  2265. }
  2266. break;
  2267. case chk_elem_ch:
  2268. if (read_bak_info() & (1 << (ch_bak_part - 1)))
  2269. {
  2270. CRC32 = CRC_RESET_VAL;
  2271. CRC32 = get_ram_part_crc(ch_bak_part);
  2272. if (CRC32 == bakcrc.ch_crc)
  2273. {
  2274. result = 1;
  2275. rt_kprintf(" ch_check pass \n\n");
  2276. }
  2277. else
  2278. {
  2279. rt_kprintf("ch_crc check fail. %08X(ram) - %08X(bak) \n", CRC32, bakcrc.ch_crc);
  2280. // rt_kprintf("get_ram_part_crc >> %08X \n\n", get_ram_part_crc(ch_bak_part));
  2281. // rt_kprintf("\n\get_bak_part_crc >> %08X \n\n", get_bak_part_crc(ch_bak_part));
  2282. return 0;
  2283. }
  2284. }
  2285. else
  2286. {
  2287. rt_kprintf("ch_bak_part not found\n");
  2288. }
  2289. if (read_bak_info() & (1 << (elem_bak_part - 1)))
  2290. {
  2291. uint32_t elemcnt = 0;
  2292. ef_port_read(Bak_elem_size_Addr, (uint32_t *)&elemcnt, sizeof(uint32_t));
  2293. // rt_kprintf("check elemcnt > %d \n\n", elemcnt);
  2294. uint16_t ram_elem_cnt = 0;
  2295. for (uint8_t i = 0; i < Number_sensors; i++)
  2296. {
  2297. if (rt_strcmp(SENSOR_CH[i].eName, "\0") != 0) // 存在通道名
  2298. {
  2299. if (rt_strcmp(sensor[i].eName, SENSOR_CH[i].eName) == 0) // 存在通道名
  2300. {
  2301. ram_elem_cnt++;
  2302. }
  2303. }
  2304. else
  2305. {
  2306. break;
  2307. }
  2308. }
  2309. if (ram_elem_cnt == (elemcnt / sizeof(Sensor)))
  2310. {
  2311. result = 1;
  2312. rt_kprintf(" elem_crc pass \n\n");
  2313. }
  2314. else
  2315. {
  2316. return 0;
  2317. }
  2318. }
  2319. else
  2320. {
  2321. rt_kprintf("elem_bak_part not found\n");
  2322. }
  2323. break;
  2324. default:
  2325. return 2;
  2326. break;
  2327. }
  2328. return result;
  2329. }
  2330. // /**
  2331. // * @brief 刷新内存中elem的填充
  2332. // *
  2333. // * @return uint8_t 成功的数量
  2334. // */
  2335. // uint8_t reflash_elem(void)
  2336. // {
  2337. // uint8_t result = 0;
  2338. // uint8_t cnt = 0;
  2339. // memset(sensor, 0, sizeof(Sensor) * Number_sensors);
  2340. // for (uint8_t i = 0; i < Number_sensors; i++)
  2341. // {
  2342. // if (rt_strcmp(SENSOR_CH[i].eName, "\0") == 0) //若不存在通道名
  2343. // {
  2344. // continue;
  2345. // }
  2346. // if (ef_get_env_blob(SENSOR_CH[i].eName, &(sensor[cnt]), sizeof(Sensor), NULL) == sizeof(Sensor))
  2347. // {
  2348. // //rt_kprintf("CH[%d].eName:%s\r\n", cnt, sensor[cnt].eName);
  2349. // cnt++;
  2350. // }
  2351. // }
  2352. // return cnt;
  2353. // }
  2354. // MSH_CMD_EXPORT(read_bak_info, "read_bak_info");
  2355. /***************** 2022.1.1 加入参数备份功能 *******************/
  2356. void Mark_up_qxz(void)
  2357. {
  2358. uint8_t up_qxz = Zero;
  2359. ef_get_env_blob("up_qxz", &up_qxz, sizeof(up_qxz), NULL);
  2360. if (up_qxz != One)
  2361. {
  2362. rt_kprintf("Mark_up_qxz\n");
  2363. up_qxz = One;
  2364. ef_set_env_blob("up_qxz", &up_qxz, sizeof(up_qxz));
  2365. }
  2366. else
  2367. {
  2368. rt_kprintf("up_qxz already %d. \n", up_qxz);
  2369. }
  2370. }
  2371. void Mark_up_elem(void)
  2372. {
  2373. uint8_t up_elem = Zero;
  2374. ef_get_env_blob("up_elem", &up_elem, sizeof(up_elem), NULL);
  2375. if (up_elem != One)
  2376. {
  2377. rt_kprintf("Mark_up_elem\n");
  2378. up_elem = One;
  2379. ef_set_env_blob("up_elem", &up_elem, sizeof(up_elem));
  2380. }
  2381. else
  2382. {
  2383. rt_kprintf("up_elem already %d. \n", up_elem);
  2384. }
  2385. }
  2386. void del_bak_flg(void)
  2387. {
  2388. uint8_t bak_flag = read_bak_info();
  2389. uint8_t bak_flag1 = 0;
  2390. ef_port_erase(Bak_Para_Addr, Erase_Size);
  2391. rt_kprintf("write bak_flag %d -> %d\n", bak_flag, ef_port_write(Bak_Para_Addr, (uint32_t *)&bak_flag1, 1));
  2392. }
  2393. MSH_CMD_EXPORT(del_bak_flg, "del_bak_flg");
  2394. /***************** 2023.7.5 迭代了参数备份功能 *******************/
  2395. /***************** 2023.9.6 新增了强大的RTC备份寄存器操作的bsp *******************/
  2396. extern RTC_HandleTypeDef RTC_Handler;
  2397. /**
  2398. * @brief 向RTC备份寄存器写入数据
  2399. *
  2400. * @param reg_num 寄存器号
  2401. * @param w_data 要写入的数据
  2402. */
  2403. void Write_RTC_BKP(uint8_t reg_num, uint32_t w_data)
  2404. {
  2405. __HAL_RCC_PWR_CLK_ENABLE(); // 使能电源时钟PWR
  2406. HAL_PWR_EnableBkUpAccess(); // 取消备份区域写保护
  2407. HAL_RTCEx_BKUPWrite(&RTC_Handler, reg_num, w_data); // 写入数据
  2408. HAL_PWR_DisableBkUpAccess(); // 开启备份区域写保护
  2409. }
  2410. /**
  2411. * @brief 读RTC备份寄存器
  2412. *
  2413. * @param reg_num 寄存器号
  2414. * @param type 读取数据的位置及宽度(可选择8位 16位 或32位)
  2415. * @return uint32_t 若为0x7FFF则读取失败反之成功
  2416. */
  2417. uint32_t BSP_Read_RTC_Reg(BKP_Reg_Num reg_num, BKP_Reg_Pos type)
  2418. {
  2419. uint32_t result = Reg_Read_Fail; // 读取失败返回失效值 0x7FFF
  2420. if (reg_num > RTC_BKP_DR4) // 若需移植 给此处修改为最大支持的寄存器即可
  2421. {
  2422. return result;
  2423. }
  2424. if (type <= Reg_Very_High) // 当按8位读取时
  2425. {
  2426. result = ((HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num) & (0xFF << (type * 8))) >> (type * 8));
  2427. }
  2428. switch (type)
  2429. {
  2430. case Reg_Low_16:
  2431. {
  2432. result = (HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num) & 0xFFFF);
  2433. }
  2434. break;
  2435. case Reg_High_16:
  2436. {
  2437. result = ((HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num) & (0xFFFF << 16)) >> 16);
  2438. }
  2439. break;
  2440. case Reg_All:
  2441. {
  2442. result = HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num);
  2443. }
  2444. break;
  2445. default:
  2446. break;
  2447. }
  2448. return result;
  2449. }
  2450. /**
  2451. * @brief 向RTC备份寄存器写入数据
  2452. *
  2453. * @param reg_num 寄存器号
  2454. * @param type 写入数据的位置及宽度(可选择8位 16位 或32位)
  2455. * @param w_data 要写入的数据
  2456. * @return uint8_t 执行结果(0 -> 失败 1 -> 成功)
  2457. */
  2458. uint8_t BSP_Write_RTC_Reg(BKP_Reg_Num reg_num, BKP_Reg_Pos type, uint32_t w_data)
  2459. {
  2460. uint8_t result = 0; // 返回操作结果
  2461. uint32_t cache = 0; // 临时存放原始数据
  2462. uint32_t source_mask = 0; // 用于保留不需要被覆写部分的掩码
  2463. if (reg_num > RTC_BKP_DR4) // 若需移植 给此处修改为最大支持的寄存器即可
  2464. {
  2465. return result;
  2466. }
  2467. if (type <= Reg_Very_High) // 当写入8位数据
  2468. {
  2469. source_mask = (uint32_t)(~(0xFF << (type * 8)));
  2470. cache = ((HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num)) & source_mask) | ((uint32_t)(w_data << (type * 8)));
  2471. Write_RTC_BKP(reg_num, cache);
  2472. result = 1;
  2473. }
  2474. else // 当写入16或32位数据时
  2475. {
  2476. cache = HAL_RTCEx_BKUPRead(&RTC_Handler, reg_num);
  2477. switch (type)
  2478. {
  2479. case Reg_Low_16:
  2480. {
  2481. source_mask = (uint32_t)(~(0xFFFF));
  2482. Write_RTC_BKP(reg_num, ((cache & source_mask) | w_data));
  2483. result = 1;
  2484. }
  2485. break;
  2486. case Reg_High_16:
  2487. {
  2488. source_mask = (uint32_t)(0xFFFF);
  2489. Write_RTC_BKP(reg_num, ((cache & source_mask) | (w_data << 16)));
  2490. result = 1;
  2491. }
  2492. break;
  2493. case Reg_All:
  2494. {
  2495. Write_RTC_BKP(reg_num, w_data);
  2496. result = 1;
  2497. }
  2498. break;
  2499. default:
  2500. break;
  2501. }
  2502. }
  2503. return result;
  2504. }
  2505. /**
  2506. * @brief 使用了234号寄存器进行RTC寄存器读写bsp 快速判断配置是否成功
  2507. *
  2508. */
  2509. void test_bsp_rtc(void)
  2510. {
  2511. uint32_t data = 0x12345678;
  2512. uint32_t data1 = 0xABC0DEF0;
  2513. uint32_t data2 = 0xA1B2C3D4;
  2514. LOG_I("Start test");
  2515. LOG_I("write low 8bit %X ", data & 0xFF);
  2516. BSP_Write_RTC_Reg(RTC_BKP_DR1, Reg_Low, data & 0xFF);
  2517. LOG_I("read low 8bit %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR1, Reg_Low));
  2518. LOG_I("write Reg_Middle 8bit %X ", (data & 0xFF00) >> 8);
  2519. BSP_Write_RTC_Reg(RTC_BKP_DR1, Reg_Middle, (data & 0xFF00) >> 8);
  2520. LOG_I("read Reg_Middle 8bit %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR1, Reg_Middle));
  2521. LOG_I("write Reg_High 8bit %X ", (data & 0xFF0000) >> 16);
  2522. BSP_Write_RTC_Reg(RTC_BKP_DR1, Reg_High, (data & 0xFF0000) >> 16);
  2523. LOG_I("read Reg_High 8bit %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR1, Reg_High));
  2524. LOG_I("write Reg_Very_High 8bit %X ", (data & 0xFF000000) >> 24);
  2525. BSP_Write_RTC_Reg(RTC_BKP_DR1, Reg_Very_High, (data & 0xFF000000) >> 24);
  2526. LOG_I("read Reg_Very_High 8bit %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR1, Reg_Very_High));
  2527. LOG_I("write Reg_Low_16 %X ", data1 & 0xFFFF);
  2528. BSP_Write_RTC_Reg(RTC_BKP_DR2, Reg_Low_16, data1 & 0xFFFF);
  2529. LOG_I("read Reg_Low_16 %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR2, Reg_Low_16));
  2530. LOG_I("write Reg_High_16 %X ", (data1 & 0xFFFF0000) >> 16);
  2531. BSP_Write_RTC_Reg(RTC_BKP_DR2, Reg_High_16, (data1 & 0xFFFF0000) >> 16);
  2532. LOG_I("read Reg_High_16 %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR2, Reg_High_16));
  2533. LOG_I("write Reg_All %X ", data2);
  2534. BSP_Write_RTC_Reg(RTC_BKP_DR3, Reg_All, data2);
  2535. LOG_I("read Reg_All %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR3, Reg_All));
  2536. LOG_I("read RTC_BKP_DR1 %X ", BSP_Read_RTC_Reg(RTC_BKP_DR1, Reg_All));
  2537. LOG_I("read RTC_BKP_DR2 %X ", BSP_Read_RTC_Reg(RTC_BKP_DR2, Reg_All));
  2538. LOG_I("read RTC_BKP_DR3 %X \n", BSP_Read_RTC_Reg(RTC_BKP_DR3, Reg_All));
  2539. LOG_I("Test Finsh");
  2540. }
  2541. // MSH_CMD_EXPORT(test_bsp_rtc, "test_bsp_rtc");
  2542. /***************** 2023.9.6 新增了强大的RTC备份寄存器操作的bsp *******************/
  2543. /***************** 2023.9.5 新增了从平台同步配置功能 *******************/
  2544. #include "protocol.h"
  2545. extern int mqtt_publish_ch(cJSON *data, uint8_t ch);
  2546. extern cJSON *Element_Upload(char *eName);
  2547. extern void display_main_title(const char *str, uint8_t n);
  2548. /**
  2549. * @brief Get the Platform object
  2550. *
  2551. * @return uint8_t 返回通道号
  2552. */
  2553. uint8_t GetPlatform(void)
  2554. {
  2555. uint8_t platform_ff = 0;
  2556. ef_get_env_blob("platform_f", &platform_ff, sizeof(platform_ff), RT_NULL);
  2557. if (platform_ff == 0 || platform_ff == 1)
  2558. {
  2559. return 0; // 这个估计是大数据平台
  2560. }
  2561. else
  2562. {
  2563. return 1; // 这个估计是四清平台
  2564. }
  2565. }
  2566. //{"cmd": "request","ext": {"type": "config01"}}
  2567. //{"cmd": "request","ext": {"type": "configch"}}
  2568. //{"cmd": "request","ext": {"type": "configled"}}
  2569. // 请求
  2570. cJSON *SEND_plp_req(plp_req_type type, uint8_t para)
  2571. {
  2572. cJSON *root = RT_NULL;
  2573. cJSON *ext = RT_NULL;
  2574. cJSON *interval = RT_NULL;
  2575. root = cJSON_CreateObject();
  2576. ext = cJSON_CreateObject();
  2577. switch (type)
  2578. {
  2579. case req_ch:
  2580. cJSON_AddStringToObject(ext, "type", "configch");
  2581. break;
  2582. case req_elem:
  2583. if (para == 01)
  2584. {
  2585. cJSON_AddStringToObject(ext, "type", "config01");
  2586. }
  2587. else if (para == 02)
  2588. {
  2589. cJSON_AddStringToObject(ext, "type", "config02");
  2590. }
  2591. else
  2592. {
  2593. cJSON_AddStringToObject(ext, "type", "config03");
  2594. }
  2595. break;
  2596. case req_led:
  2597. cJSON_AddStringToObject(ext, "type", "configled");
  2598. break;
  2599. case req_url:
  2600. cJSON_AddStringToObject(ext, "type", "upgrade_url");
  2601. break;
  2602. default:
  2603. break;
  2604. }
  2605. // ef_get_env_blob("platform_f", &platform_f, sizeof(platform_f), RT_NULL);
  2606. cJSON_AddItemToObject(root, "cmd", cJSON_CreateString("request")); //
  2607. cJSON_AddItemToObject(root, "ext", ext);
  2608. return root;
  2609. }
  2610. void Display_plp_info(const char *str)
  2611. {
  2612. display_main_title(str, 36);
  2613. rt_thread_mdelay(600);
  2614. display_main_title(str, 36);
  2615. rt_thread_mdelay(600);
  2616. }
  2617. #define ZK_DOWNLOAD_PART "zk_area"
  2618. extern const struct fal_partition *fal_partition_find(const char *name);
  2619. /**
  2620. * @brief 检查字库文件是否存在(检查文件头)
  2621. *
  2622. * @return uint8_t RT_EOK - 已存在
  2623. */
  2624. static uint8_t check_zk(void)
  2625. {
  2626. const struct fal_partition *dl_part = RT_NULL;
  2627. uint8_t read_buf[5] = {0};
  2628. dl_part = fal_partition_find(ZK_DOWNLOAD_PART);
  2629. if (dl_part == RT_NULL)
  2630. {
  2631. return RT_ETIMEOUT;
  2632. }
  2633. fal_partition_read(dl_part, 0, read_buf, 4);
  2634. if (read_buf[0] == 0xBB && read_buf[1] == 0xD2 && read_buf[2] == 0xA1 && read_buf[3] == 0xB6)
  2635. {
  2636. // rt_kprintf("zk already exits \n");
  2637. return RT_EOK;
  2638. }
  2639. else
  2640. {
  2641. rt_kprintf("No zk found -> %X %X %X %X\n", read_buf[0], read_buf[1], read_buf[2], read_buf[3]);
  2642. return RT_ERROR;
  2643. }
  2644. }
  2645. MSH_CMD_EXPORT(check_zk, "check_zk");
  2646. rt_sem_t plp_sync_sem = RT_NULL; // 上报数据标记位
  2647. rt_sem_t plp_req_ch = RT_NULL; // 请求同步CH
  2648. rt_sem_t plp_req_dp = RT_NULL; // 请求同步屏幕参数
  2649. rt_sem_t plp_req_url = RT_NULL; // 请求同步升级url
  2650. rt_sem_t plp_ch_succ = RT_NULL; // 同步CH 成功
  2651. rt_sem_t plp_dp_succ = RT_NULL; // 同步屏幕参数 成功
  2652. rt_sem_t plp_url_succ = RT_NULL; // 同步升级url 成功
  2653. rt_sem_t plp_ch_fail = RT_NULL; // 同步CH 失败
  2654. rt_sem_t plp_dp_upgrade = RT_NULL; // 同步屏幕参数 失败
  2655. rt_sem_t plp_url_upgrade = RT_NULL; // 同步升级url 失败
  2656. void plp_fun_on(void);
  2657. void plp_fun_off(void);
  2658. static void plp_sync_thread_entry(void *param)
  2659. {
  2660. uint8_t unlink_cnt = 0; // 等待网络连接的次数 超时退出本功能
  2661. uint8_t enable_day = 0; // 触发日期 每天只能触发一次
  2662. uint8_t plps_tig_en = 0; // 手动触发向平台请求参数
  2663. uint8_t plps_chcfg_tig_en = 0; // 上次执行了 ch修改后触发了 所以再给一次机会进来
  2664. plp_sync_sem = rt_sem_create("plp_sync_s", 0, RT_IPC_FLAG_PRIO);
  2665. plp_req_ch = rt_sem_create("plp_req_ch_s", 0, RT_IPC_FLAG_PRIO);
  2666. plp_req_dp = rt_sem_create("plp_req_dp_s", 0, RT_IPC_FLAG_PRIO);
  2667. plp_req_url = rt_sem_create("plp_req_url_s", 0, RT_IPC_FLAG_PRIO);
  2668. plp_ch_succ = rt_sem_create("plp_ch_succ_s", 0, RT_IPC_FLAG_PRIO);
  2669. plp_dp_succ = rt_sem_create("plp_dp_succ_s", 0, RT_IPC_FLAG_PRIO);
  2670. plp_url_succ = rt_sem_create("plp_url_succ_s", 0, RT_IPC_FLAG_PRIO);
  2671. plp_ch_fail = rt_sem_create("plp_ch_fail_s", 0, RT_IPC_FLAG_PRIO);
  2672. plp_dp_upgrade = rt_sem_create("plp_dp_upgrade_s", 0, RT_IPC_FLAG_PRIO);
  2673. plp_url_upgrade = rt_sem_create("plp_url_upgrade_s", 0, RT_IPC_FLAG_PRIO);
  2674. return;
  2675. rt_thread_mdelay(90000); // 等待联网完成
  2676. // rt_sem_init(plp_sync_sem,"plp_sync_s", 0, RT_IPC_FLAG_PRIO);
  2677. //
  2678. // rt_sem_init(plp_req_ch,"plp_req_ch_s", 0, RT_IPC_FLAG_PRIO);
  2679. // rt_sem_init(plp_req_dp,"plp_req_dp_s", 0, RT_IPC_FLAG_PRIO);
  2680. // rt_sem_init(plp_req_url,"plp_req_url_s", 0, RT_IPC_FLAG_PRIO);
  2681. //
  2682. // rt_sem_init(plp_ch_succ,"plp_ch_succ_s", 0, RT_IPC_FLAG_PRIO);
  2683. // rt_sem_init(plp_dp_succ,"plp_dp_succ_s", 0, RT_IPC_FLAG_PRIO);
  2684. // rt_sem_init(plp_url_succ,"plp_url_succ_s", 0, RT_IPC_FLAG_PRIO);
  2685. //
  2686. // rt_sem_init(plp_ch_fail,"plp_ch_fail_s", 0, RT_IPC_FLAG_PRIO);
  2687. // rt_sem_init(plp_dp_upgrade,"plp_dp_upgrade_s", 0, RT_IPC_FLAG_PRIO);
  2688. // rt_sem_init(plp_url_upgrade,"plp_url_upgrade_s", 0, RT_IPC_FLAG_PRIO);
  2689. uint8_t plp_fun_ctl = 0; // 读取功能开关信息
  2690. if (ef_get_env_blob("plp_fun_ctl", &plp_fun_ctl, sizeof(plp_fun_ctl), NULL) == 0)
  2691. {
  2692. plp_fun_ctl = One;
  2693. rt_kprintf("plp_fun_ctl read NULL , trun it on \n");
  2694. plp_fun_on();
  2695. }
  2696. if (plp_fun_ctl != One)
  2697. {
  2698. rt_kprintf("plp_fun_ctl > disabled!\n\n");
  2699. return;
  2700. }
  2701. // ef_get_env_blob("enable_day", &enable_day, sizeof(enable_day), NULL);
  2702. ef_get_env_blob("plps_tig_en", &plps_tig_en, sizeof(plps_tig_en), NULL);
  2703. ef_get_env_blob("plps_chcfg_tig_en", &plps_chcfg_tig_en, sizeof(plps_chcfg_tig_en), NULL);
  2704. while (rt_sem_take(plp_sync_sem, RT_WAITING_NO) != RT_EOK) // 同样等联网
  2705. {
  2706. rt_thread_mdelay(1000);
  2707. if (unlink_cnt++ > 60)
  2708. {
  2709. rt_kprintf("plps:unlink timeout\n");
  2710. return;
  2711. }
  2712. }
  2713. if ((day == enable_day) && ((day != 0) && (plps_tig_en != One) && (plps_chcfg_tig_en != One)))
  2714. {
  2715. rt_kprintf("plps:open tomorrow");
  2716. if (day == enable_day)
  2717. {
  2718. rt_kprintf(" A\n");
  2719. }
  2720. else if ((day != 0) && (plps_tig_en != One))
  2721. {
  2722. rt_kprintf(" B\n");
  2723. }
  2724. return;
  2725. }
  2726. else
  2727. {
  2728. rt_kprintf("STEP1 > ready to snyc plp\n");
  2729. if (enable_day != day)
  2730. {
  2731. enable_day = day;
  2732. // ef_set_env_blob("enable_day", &enable_day, sizeof(enable_day));
  2733. Display_plp_info("准备向服务器同步配置A");
  2734. }
  2735. if (plps_tig_en == One)
  2736. {
  2737. plps_tig_en = Zero;
  2738. ef_set_env_blob("plps_tig_en", &plps_tig_en, sizeof(plps_tig_en));
  2739. Display_plp_info("准备向服务器同步配置B");
  2740. }
  2741. }
  2742. /* 同步ch elem */
  2743. if (plps_chcfg_tig_en != One)
  2744. {
  2745. rt_sem_release(plp_req_ch); // 通知mqtt处理线程
  2746. mqtt_publish_ch(SEND_plp_req(req_ch, 0), GetPlatform());
  2747. rt_kprintf("STEP2 > plp_req_ch ");
  2748. Display_plp_info("开始同步通道...");
  2749. if (check_zk() != RT_EOK) // 加入字库的校验 若发现字库丢了 及时下载
  2750. {
  2751. if (http_ota_zk() == RT_EOK)
  2752. {
  2753. mqtt_publish_ch(Element_Upload("zk_downloadsucc"), GetPlatform());
  2754. }
  2755. }
  2756. rt_thread_mdelay(5000);
  2757. if (rt_sem_take(plp_ch_succ, RT_WAITING_NO) == RT_EOK) // ch校验没问题 不需要再请求elem了
  2758. {
  2759. Display_plp_info("通道校验通过");
  2760. LOG_I(" check pass");
  2761. }
  2762. else if (rt_sem_take(plp_ch_fail, RT_WAITING_NO) == RT_EOK) // ch校验不一致 需要更新
  2763. {
  2764. Display_plp_info("通道更新中...");
  2765. LOG_I(" upguard");
  2766. Display_plp_info("开始同步要素/通道");
  2767. plps_chcfg_tig_en = One;
  2768. ef_set_env_blob("plps_chcfg_tig_en", &plps_chcfg_tig_en, sizeof(plps_chcfg_tig_en));
  2769. mqtt_publish_ch(SEND_plp_req(req_elem, 1), GetPlatform());
  2770. rt_thread_mdelay(3000);
  2771. mqtt_publish_ch(SEND_plp_req(req_elem, 2), GetPlatform());
  2772. rt_thread_mdelay(3000);
  2773. mqtt_publish_ch(SEND_plp_req(req_elem, 3), GetPlatform());
  2774. rt_thread_mdelay(3000);
  2775. mqtt_publish_ch(SEND_plp_req(req_ch, 0), GetPlatform());
  2776. rt_thread_mdelay(3000);
  2777. Display_plp_info("通道同步结束");
  2778. Recode_e_code(Plps_elemch, 0, "触发了同步要素和通道"); // 触发了同步elemch
  2779. rt_thread_mdelay(1500);
  2780. }
  2781. else
  2782. {
  2783. LOG_I(" timeout");
  2784. Display_plp_info("通道同步超时");
  2785. rt_sem_take(plp_req_ch, RT_WAITING_NO); // 超时了 回收信号量
  2786. rt_thread_mdelay(1500);
  2787. }
  2788. }
  2789. else
  2790. {
  2791. plps_chcfg_tig_en = Zero;
  2792. ef_set_env_blob("plps_chcfg_tig_en", &plps_chcfg_tig_en, sizeof(plps_chcfg_tig_en));
  2793. }
  2794. /* 同步ch elem */
  2795. /* 同步led参数 */
  2796. rt_sem_release(plp_req_dp); // 通知mqtt处理线程
  2797. mqtt_publish_ch(SEND_plp_req(req_led, 0), GetPlatform());
  2798. rt_kprintf("STEP3 > plp_req_dp ");
  2799. Display_plp_info("开始同步屏幕参数...");
  2800. rt_thread_mdelay(5000);
  2801. if (rt_sem_take(plp_dp_succ, RT_WAITING_NO) == RT_EOK) // led校验没问题
  2802. {
  2803. Display_plp_info("屏幕参数校验通过");
  2804. LOG_I(" check pass");
  2805. }
  2806. else if (rt_sem_take(plp_dp_upgrade, RT_WAITING_NO) == RT_EOK) // led校验不一致 需要更新
  2807. {
  2808. Display_plp_info("屏幕参数更新成功");
  2809. LOG_I(" upguard");
  2810. Recode_e_code(Plps_dp, 0, "触发了同步led显示参数"); // 触发了同步led显示参数
  2811. }
  2812. else
  2813. {
  2814. Display_plp_info("屏幕参数同步超时");
  2815. LOG_I(" timeout");
  2816. rt_sem_take(plp_req_dp, RT_WAITING_NO); // 超时了 回收信号量
  2817. }
  2818. rt_thread_mdelay(1500);
  2819. /* 同步led参数 */
  2820. /* 同步升级url */
  2821. rt_sem_release(plp_req_url); // 通知mqtt处理线程
  2822. mqtt_publish_ch(SEND_plp_req(req_url, 0), GetPlatform());
  2823. rt_kprintf("STEP4 > plp_req_url ");
  2824. Display_plp_info("开始同步升级路径...");
  2825. rt_thread_mdelay(5000);
  2826. if (rt_sem_take(plp_url_succ, RT_WAITING_NO) == RT_EOK) // led校验没问题
  2827. {
  2828. Display_plp_info("升级路径校验通过");
  2829. LOG_I(" check pass");
  2830. }
  2831. else if (rt_sem_take(plp_url_upgrade, RT_WAITING_NO) == RT_EOK) // led校验不一致 需要更新
  2832. {
  2833. Display_plp_info("升级路径更新成功");
  2834. LOG_I(" upguard");
  2835. Recode_e_code(Plps_url, 0, "触发了同步url"); // 触发了同步url
  2836. rt_thread_mdelay(1500);
  2837. Display_plp_info("开始更新固件");
  2838. mqtt_publish_ch(Element_Upload("updateing"), GetPlatform());
  2839. // 读出升级标志//重启后在进行升级`
  2840. uint8_t update_flag = 0;
  2841. if (ef_get_env_blob("update_flag", &update_flag, sizeof(update_flag), RT_NULL))
  2842. {
  2843. update_flag = GetPlatform() + 1; // 通道编号+1
  2844. }
  2845. ef_set_env_blob("update_flag", &update_flag, sizeof(update_flag));
  2846. rt_thread_delay(1000);
  2847. RESET_SYSTEM(); // 系统重启
  2848. }
  2849. else
  2850. {
  2851. Display_plp_info("升级路径同步超时");
  2852. LOG_I(" timeout");
  2853. rt_sem_take(plp_req_url, RT_WAITING_NO); // 超时了 回收信号量
  2854. }
  2855. /* 同步升级url */
  2856. rt_thread_mdelay(5000);
  2857. Display_plp_info("");
  2858. }
  2859. int plp_sync_thread(void)
  2860. {
  2861. rt_thread_t tid1 = RT_NULL;
  2862. tid1 = rt_thread_create("plp_sync",
  2863. plp_sync_thread_entry, RT_NULL,
  2864. 1024 * 2,
  2865. 11, 5); // 不重要的线程 优先级可以往后排
  2866. // 如果获得线程控制块,启动这个线程
  2867. if (tid1 != RT_NULL)
  2868. rt_thread_startup(tid1);
  2869. return 1;
  2870. }
  2871. //INIT_ENV_EXPORT(plp_sync_thread);
  2872. /***************** 2023.9.5 新增了从平台同步配置功能 *******************/
  2873. /***************** 2023.11.17 重构数据补录功能 *******************/
  2874. #include "protocol.h"
  2875. extern rt_sem_t reflash_485_mode_sem; // 刷新485 模式的标记位
  2876. extern int mqtt_publish_ch(cJSON *data, uint8_t ch);
  2877. extern cJSON *TerminalData(uint8_t option);
  2878. /********* 本功能参数区 **********/
  2879. // uint8_t data_supp_flag = 0; // 开启补录上报功能的标记位 开启时上报数据变为补录抬头 暂停传感器数据读取工作(One-开启 Zero-关闭)
  2880. static uint8_t supp_init_flg = 1; // 重要参数
  2881. static uint8_t mutex_supp = 0; // 功能互斥 补录和记录只能同时进行一个
  2882. static uint8_t supp_err_cnt = 0; // 累计错误过多的话 关闭补录功能
  2883. /********* 本功能参数区 **********/
  2884. /**
  2885. * @brief 记录未保存的数据
  2886. *
  2887. */
  2888. void recode_edata(void)
  2889. {
  2890. // if (mutex_supp == 0)
  2891. // {
  2892. // mutex_supp = 1;
  2893. // // rt_kprintf("mutex_supp = 1; B\n");
  2894. // }
  2895. // else
  2896. // {
  2897. // rt_kprintf("mutex_supp !\n");
  2898. // return;
  2899. // }
  2900. if (recovery_log_init() != 0)
  2901. {
  2902. rt_kprintf("recovery_log_init FAILED A %d \n", recovery_log_init());
  2903. mutex_supp = 0;
  2904. return;
  2905. }
  2906. else if (supp_init_flg)
  2907. {
  2908. rt_kprintf("\n\nData_supp_start > %d (%d MAX)\n\n", recovery_log_get_count(), MAX_RECOVERY_ITEMS);
  2909. Display_plp_info("数据补录功能已开启");
  2910. rt_thread_mdelay(2000);
  2911. Display_plp_info("");
  2912. supp_init_flg = 0;
  2913. }
  2914. cJSON *data = generate_ob_frame(1);
  2915. char *out = cJSON_PrintUnformatted(data);
  2916. rt_kprintf("recode_edata(%d) \n", strlen(out));
  2917. recovery_log_write(out, strlen(out), Get_Time_Stampe());
  2918. cJSON_Delete(data);
  2919. if (out)
  2920. {
  2921. rt_free(out);
  2922. }
  2923. recovery_log_deinit();
  2924. rt_kprintf("\n\n\n");
  2925. mutex_supp = 0;
  2926. /***** 保存数据 *****/
  2927. }
  2928. extern void DATA_SUPP(char *out);
  2929. static void supp_edata(void)
  2930. {
  2931. // if (mutex_supp == 1)
  2932. // {
  2933. // rt_kprintf("mutex_supp already locked!\n");
  2934. // return;
  2935. // }
  2936. mutex_supp = 1;
  2937. // rt_kprintf("mutex_supp = 1\n");
  2938. // 简化初始化
  2939. if (recovery_log_init() != 0)
  2940. {
  2941. rt_kprintf("recovery_log_init FAILED B %d \n", recovery_log_init());
  2942. goto cleanup;
  2943. }
  2944. else if (supp_init_flg)
  2945. {
  2946. rt_kprintf("\n\nData_supp_start > %d (%d MAX)\n\n", recovery_log_get_count(), MAX_RECOVERY_ITEMS);
  2947. Display_plp_info("数据补录功能已开启");
  2948. rt_thread_mdelay(2000);
  2949. Display_plp_info("");
  2950. supp_init_flg = 0;
  2951. }
  2952. // rt_kprintf("recovery_log_init OK\n");
  2953. uint32_t count = recovery_log_get_count();
  2954. if (count > 0)
  2955. {
  2956. // rt_kprintf("Starting data recovery...\n");
  2957. rt_kprintf("Current log count: %ld\n", count);
  2958. uint8_t *buffer = rt_malloc(2048);
  2959. if (buffer == NULL)
  2960. {
  2961. rt_kprintf("Buffer allocation failed\n");
  2962. goto cleanup;
  2963. }
  2964. rt_memset(buffer, 0, 2048);
  2965. uint16_t len = 0;
  2966. uint32_t time = 0;
  2967. // rt_kprintf("Calling recovery_log_read_last...\n");
  2968. int read_result = recovery_log_read_last(buffer, &len, &time);
  2969. // rt_kprintf("recovery_log_read_last returned: %d\n", read_result);
  2970. if (read_result == 0)
  2971. {
  2972. rt_kprintf("SUPP DATA recovered: len=%d, \n", len);
  2973. DATA_SUPP(buffer);
  2974. recovery_log_delete_oldest();
  2975. }
  2976. else
  2977. {
  2978. rt_kprintf("Data recovery failed: %d\n", read_result);
  2979. }
  2980. if (buffer)
  2981. {
  2982. // rt_kprintf("rt_free(buffer) > %x\n" , buffer );
  2983. rt_free(buffer);
  2984. }
  2985. }
  2986. else
  2987. {
  2988. // rt_kprintf("No data to supplement\n");
  2989. // 处理标记位逻辑...
  2990. }
  2991. cleanup:
  2992. recovery_log_deinit();
  2993. mutex_supp = 0;
  2994. // rt_kprintf("supp_edata completed\n");
  2995. }
  2996. /************************** Data_supplement function ******************************/
  2997. rt_sem_t data_supp = RT_NULL; // 使能数据补充上报信号量
  2998. rt_sem_t recode_data = RT_NULL; // 记录数据信号量
  2999. void recode_edataM(void)
  3000. {
  3001. if (recode_data != NULL)
  3002. {
  3003. rt_sem_release(recode_data); // 通知进行补录
  3004. }
  3005. else
  3006. {
  3007. rt_kprintf("recode_edataM FAIL\n");
  3008. }
  3009. }
  3010. void data_suppM(void)
  3011. {
  3012. if (data_supp != NULL)
  3013. {
  3014. rt_sem_release(data_supp); // 通知进行补录
  3015. }
  3016. else
  3017. {
  3018. rt_kprintf("data_suppM FAIL\n");
  3019. }
  3020. }
  3021. void supp_fun_on(void);
  3022. void supp_fun_off(void);
  3023. static void Data_supplement_thread_entry(void *param)
  3024. {
  3025. data_supp = rt_sem_create("data_supp", 0, RT_IPC_FLAG_PRIO); // 数据上报
  3026. recode_data = rt_sem_create("recode_data", 0, RT_IPC_FLAG_PRIO); // 数据记录
  3027. rt_thread_mdelay(10000);
  3028. uint8_t supp_fun_ctl = 0; // 读取功能开关信息
  3029. if (ef_get_env_blob("supp_fun_ctl", &supp_fun_ctl, sizeof(supp_fun_ctl), NULL) == 0)
  3030. {
  3031. supp_fun_ctl = One;
  3032. rt_kprintf("supp_fun_ctl read NULL , trun it on \n");
  3033. supp_fun_on();
  3034. Recode_e_code(e_supp_ResetOn, 99, "补录功能初始化开启");
  3035. }
  3036. if (supp_fun_ctl != One)
  3037. {
  3038. rt_kprintf("supp_fun_ctl > disabled!\n\n");
  3039. return;
  3040. }
  3041. // rt_kprintf(".elem_cnt %d Num_sensors %d \n",e_info.elem_cnt , qxz.Param.Num_sensors);
  3042. if (qxz.Param.Num_sensors == 0)
  3043. {
  3044. rt_thread_mdelay(3000);
  3045. }
  3046. rt_thread_mdelay(10000);
  3047. if (recovery_log_init() != 0)
  3048. {
  3049. rt_kprintf("recovery_log_init FAILED C %d \n", recovery_log_init());
  3050. }
  3051. else if (supp_init_flg)
  3052. {
  3053. rt_kprintf("\n\nData_supp_start > %d (%d MAX)\n\n", recovery_log_get_count(), MAX_RECOVERY_ITEMS);
  3054. Display_plp_info("数据补录功能已开启");
  3055. rt_thread_mdelay(2000);
  3056. Display_plp_info("");
  3057. supp_init_flg = 0;
  3058. recovery_log_deinit();
  3059. }
  3060. char cnt = 0;
  3061. while (1)
  3062. {
  3063. if (supp_err_cnt < 10)
  3064. {
  3065. if (rt_sem_take(data_supp, RT_WAITING_NO) == RT_EOK) // 补录
  3066. {
  3067. supp_edata();
  3068. }
  3069. if (rt_sem_take(recode_data, RT_WAITING_NO) == RT_EOK) // 记录
  3070. {
  3071. recode_edata();
  3072. }
  3073. }
  3074. else
  3075. {
  3076. supp_fun_off();
  3077. rt_kprintf("supp_fun_off\n");
  3078. Recode_e_code(Data_supp_fail_ec, 9, "补录校验失败-功能关闭");
  3079. break;
  3080. }
  3081. rt_thread_mdelay(1000);
  3082. // if(cnt ++ > 1)
  3083. // {
  3084. // data_suppM();
  3085. // cnt = 0;
  3086. // }
  3087. }
  3088. }
  3089. int Data_supplement(void)
  3090. {
  3091. rt_thread_t tid1 = RT_NULL;
  3092. tid1 = rt_thread_create("Data_supplement",
  3093. Data_supplement_thread_entry, RT_NULL,
  3094. 512 + 1024,
  3095. 10, 5);
  3096. // 如果获得线程控制块,启动这个线程
  3097. if (tid1 != RT_NULL)
  3098. rt_thread_startup(tid1);
  3099. return 1;
  3100. }
  3101. //INIT_ENV_EXPORT(Data_supplement);
  3102. /************************** Data_supplement function ******************************/
  3103. static void dis_elem_data(void)
  3104. {
  3105. rt_kprintf("\n %d-%d-%d %d:%d:%d\n\n", year, month, day, hour, min, sec);
  3106. for (uint8_t a = 0; a < qxz.Param.Num_sensors; a++)
  3107. {
  3108. if (sensor[a].online_flag == 1)
  3109. {
  3110. rt_kprintf(" s[%d] %s > %s %s\n", a, sensor[a].eName, sensor[a].eValue, sensor[a].units);
  3111. }
  3112. else
  3113. {
  3114. rt_kprintf(" s[%d] %s > %s\n", a, sensor[a].eName, "NA");
  3115. }
  3116. }
  3117. rt_kprintf("\n\n");
  3118. }
  3119. void trigger_supp(void)
  3120. {
  3121. if (data_supp != NULL)
  3122. rt_sem_release(data_supp); // 通知补录上报
  3123. }
  3124. void supp_fun_on(void)
  3125. {
  3126. uint8_t supp_fun_ctl = One;
  3127. ef_set_env_blob("supp_fun_ctl", &supp_fun_ctl, sizeof(supp_fun_ctl));
  3128. ef_get_env_blob("supp_fun_ctl", &supp_fun_ctl, sizeof(supp_fun_ctl), NULL);
  3129. if (supp_fun_ctl == One)
  3130. {
  3131. rt_kprintf(" supp_fun_ctl >>> enable!\n\n");
  3132. }
  3133. }
  3134. void supp_fun_off(void)
  3135. {
  3136. rt_kprintf("supp_fun_off\n");
  3137. uint8_t supp_fun_ctl = Zero;
  3138. ef_set_env_blob("supp_fun_ctl", &supp_fun_ctl, sizeof(supp_fun_ctl));
  3139. ef_get_env_blob("supp_fun_ctl", &supp_fun_ctl, sizeof(supp_fun_ctl), NULL);
  3140. if (supp_fun_ctl == Zero)
  3141. {
  3142. rt_kprintf(" supp_fun_ctl >>> disabled!\n\n");
  3143. }
  3144. }
  3145. void plp_fun_on(void)
  3146. {
  3147. uint8_t plp_fun_ctl = One;
  3148. ef_set_env_blob("plp_fun_ctl", &plp_fun_ctl, sizeof(plp_fun_ctl));
  3149. ef_get_env_blob("plp_fun_ctl", &plp_fun_ctl, sizeof(plp_fun_ctl), NULL);
  3150. if (plp_fun_ctl == One)
  3151. {
  3152. rt_kprintf(" plp_fun_ctl >>> enable!\n\n");
  3153. }
  3154. }
  3155. void plp_fun_off(void)
  3156. {
  3157. uint8_t plp_fun_ctl = Zero;
  3158. ef_set_env_blob("plp_fun_ctl", &plp_fun_ctl, sizeof(plp_fun_ctl));
  3159. ef_get_env_blob("plp_fun_ctl", &plp_fun_ctl, sizeof(plp_fun_ctl), NULL);
  3160. if (plp_fun_ctl == Zero)
  3161. {
  3162. rt_kprintf(" plp_fun_ctl >>> disabled!\n\n");
  3163. }
  3164. }
  3165. MSH_CMD_EXPORT(recode_edataM, "recode_edata");
  3166. MSH_CMD_EXPORT(dis_elem_data, "dis_elem_data");
  3167. MSH_CMD_EXPORT(trigger_supp, "trigger_supp");
  3168. /* 演示使用 */
  3169. MSH_CMD_EXPORT(supp_fun_on, "supp_fun_on");
  3170. MSH_CMD_EXPORT(supp_fun_off, "supp_fun_off");
  3171. MSH_CMD_EXPORT(plp_fun_on, "plp_fun_on");
  3172. MSH_CMD_EXPORT(plp_fun_off, "plp_fun_off");
  3173. /***************** 2022.11.17 重构数据补录功能 *******************/
  3174. /***************** 2024.08.08 屏幕去除测试模式入口按钮 *******************/
  3175. /**
  3176. * @brief 去除测试按钮
  3177. *
  3178. */
  3179. void Remove_Test_Button(void)
  3180. {
  3181. char buf[30];
  3182. sprintf(buf, "wepo 0x9D,1016");
  3183. HMI_Display(buf, strlen(buf));
  3184. }
  3185. MSH_CMD_EXPORT(Remove_Test_Button, "Remove_Test_Button");
  3186. /**
  3187. * @brief 恢复测试按钮
  3188. *
  3189. */
  3190. void Test_Button(void)
  3191. {
  3192. char buf[30];
  3193. sprintf(buf, "wepo 0,1016");
  3194. HMI_Display(buf, strlen(buf));
  3195. }
  3196. MSH_CMD_EXPORT(Test_Button, "Test_Button");
  3197. /***************** 2024.08.08 屏幕去除测试模式入口按钮 *******************/
  3198. /***************** 241206 多设备订阅功能 *******************/
  3199. volatile SDT_INFO sdt_info = {0};
  3200. cJSON *generate_sdt_json()
  3201. {
  3202. // 创建根对象
  3203. // static cJSON *root;
  3204. // if(root != NULL)
  3205. // {
  3206. // rt_kprintf("jump generate_sdt_json\n");
  3207. // return
  3208. // }
  3209. // else
  3210. // {
  3211. // rt_kprintf("generate_sdt_json\n");
  3212. // }
  3213. // rt_kprintf("generate_sdt_json\n");
  3214. cJSON *root = cJSON_CreateObject();
  3215. // 设置cmd字段
  3216. cJSON_AddStringToObject(root, "cmd", "read");
  3217. // 创建ext对象
  3218. cJSON *ext = cJSON_CreateObject();
  3219. // 设置ext内的字段
  3220. cJSON_AddStringToObject(ext, "type", "data");
  3221. if (strstr((const char *)sdt_info.ID_0, "86") != NULL)
  3222. cJSON_AddStringToObject(ext, "ID_0", (const char *)sdt_info.ID_0);
  3223. if (strstr((const char *)sdt_info.ID_1, "86") != NULL)
  3224. cJSON_AddStringToObject(ext, "ID_1", (const char *)sdt_info.ID_1);
  3225. if (strstr((const char *)sdt_info.ID_2, "86") != NULL)
  3226. cJSON_AddStringToObject(ext, "ID_2", (const char *)sdt_info.ID_2);
  3227. if (strstr((const char *)sdt_info.ID_3, "86") != NULL)
  3228. cJSON_AddStringToObject(ext, "ID_3", (const char *)sdt_info.ID_3);
  3229. if (strstr((const char *)sdt_info.ID_4, "86") != NULL)
  3230. cJSON_AddStringToObject(ext, "ID_4", (const char *)sdt_info.ID_4);
  3231. if (strstr((const char *)sdt_info.ID_5, "86") != NULL)
  3232. cJSON_AddStringToObject(ext, "ID_5", (const char *)sdt_info.ID_5);
  3233. // 将ext对象添加到根对象
  3234. cJSON_AddItemToObject(root, "ext", ext);
  3235. return root;
  3236. }
  3237. extern void GenerateValue(int val, int factor, char *eval);
  3238. /**
  3239. * @brief 函数用于解析JSON数据并输出eValue和eName
  3240. *
  3241. * @param json_string
  3242. */
  3243. void parse_Screen_json(const char *json_string)
  3244. {
  3245. static uint8_t elem_cnt = 0;
  3246. // 解析JSON字符串
  3247. cJSON *root = cJSON_Parse(json_string);
  3248. if (!root)
  3249. {
  3250. const char *error_ptr = cJSON_GetErrorPtr();
  3251. if (error_ptr)
  3252. {
  3253. rt_kprintf("Error before: %s\n", error_ptr);
  3254. return;
  3255. }
  3256. }
  3257. // 尝试获取ScreenData数组
  3258. cJSON *screen_data = cJSON_GetObjectItemCaseSensitive(root, "ScreenData");
  3259. if (!screen_data || !cJSON_IsArray(screen_data))
  3260. {
  3261. rt_kprintf("Error: ScreenData is not a valid array.\n");
  3262. cJSON_Delete(root);
  3263. return;
  3264. }
  3265. // 遍历ScreenData数组
  3266. int count = cJSON_GetArraySize(screen_data);
  3267. for (int i = 0; i < count; i++)
  3268. {
  3269. // 获取当前数组元素
  3270. cJSON *item = cJSON_GetArrayItem(screen_data, i);
  3271. if (!item)
  3272. continue; // 跳过无效的项
  3273. // 获取eValue和eName的值
  3274. cJSON *eValue_item = cJSON_GetObjectItemCaseSensitive(item, "eValue");
  3275. cJSON *eName_item = cJSON_GetObjectItemCaseSensitive(item, "eName");
  3276. if (!eValue_item || !cJSON_IsString(eValue_item) || !eName_item || !cJSON_IsString(eName_item))
  3277. {
  3278. rt_kprintf("Error: Invalid eValue or eName in item %d.\n", i);
  3279. continue; // 跳过无效的项
  3280. }
  3281. // 输出eValue和eName的值
  3282. // 注意:这里我们假设eValue是一个可以安全转换为int的double值
  3283. // int eValue = (int)cJSON_GetNumberValue(eValue_item);
  3284. // rt_kprintf("ScreenData ---> eValue: %s, eName: %s\n", eValue_item->valuestring , eName_item->valuestring);
  3285. for (uint8_t a = 0; a < qxz.Param.Num_sensors; a++)
  3286. {
  3287. if (strstr(sensor[a].eName, eName_item->valuestring) != NULL)
  3288. {
  3289. if (elem_cnt < qxz.Param.Num_sensors)
  3290. {
  3291. elem_cnt++;
  3292. rt_kprintf("Match elem > %s \n\n", sensor[a].eName);
  3293. }
  3294. // GenerateValue(eValue, sensor[a].factor, sensor[a].eValue);
  3295. rt_sprintf(sensor[a].eValue, "%s", eValue_item->valuestring);
  3296. sensor[a].online_flag = 1;
  3297. sensor[a].err_cnt = 0;
  3298. }
  3299. }
  3300. }
  3301. // 释放JSON对象占用的内存
  3302. cJSON_Delete(root);
  3303. }
  3304. /***************** 241206 多设备订阅功能 *******************/
  3305. /***************** 241213 MSH命令导出到mqtt *******************/
  3306. extern void Requset_SDT(void);
  3307. extern void upload_ecode(void);
  3308. extern void upload_all_CSV(void);
  3309. #define ml_max 16 // 标记了指令的最大数量
  3310. void ef_resetenv(void)
  3311. {
  3312. ef_env_set_default();
  3313. }
  3314. MSHDef mshlist[ml_max] =
  3315. {
  3316. {"delecode", delecode},
  3317. {"del_bak_flg", del_bak_flg},
  3318. {"trigger_supp", trigger_supp},
  3319. {"supp_fun_on", supp_fun_on},
  3320. {"supp_fun_off", supp_fun_off},
  3321. {"plp_fun_on", plp_fun_on},
  3322. {"plp_fun_off", plp_fun_off},
  3323. {"ef_resetenv", ef_resetenv},
  3324. {"Requset_SDT", Requset_SDT}
  3325. // {"upload_all_CSV", upload_all_CSV},
  3326. // {"upload_ecode", upload_ecode}
  3327. };
  3328. void parse_MSH_CMD(const char *cmd)
  3329. {
  3330. uint8_t a = 0;
  3331. for (a = 0; a < ml_max; a++)
  3332. {
  3333. if (strstr(cmd, mshlist[a].cmdtext) != NULL)
  3334. {
  3335. report_msh(a, 1);
  3336. mshlist[a].fun();
  3337. report_msh(a, 0);
  3338. break;
  3339. }
  3340. }
  3341. if (a == ml_max)
  3342. {
  3343. rt_kprintf("parse_MSH_CMD no cmd match\n");
  3344. }
  3345. }
  3346. /***************** 241213 MSH命令导出到mqtt *******************/
  3347. /**
  3348. * @brief 任意长度字节转uint64_t(最大8字节)
  3349. * @note 对于长度小于8的数据,默认放在高位(符合Modbus等协议的习惯)
  3350. */
  3351. uint64_t bytes_to_uint64(const uint8_t *data, uint8_t length, byte_order_t order)
  3352. {
  3353. if (length == 0 || length > 8 || data == NULL)
  3354. {
  3355. return 0;
  3356. }
  3357. // 确保长度是偶数(16位对齐)
  3358. if (length & 0x01)
  3359. {
  3360. length--; // 截断奇数长度
  3361. }
  3362. // 计算 16 位字段数量
  3363. uint8_t field_count = length / 2;
  3364. // 用于存储解析出的 16 位字段(最多 4 个)
  3365. uint16_t fields[4];
  3366. for (uint8_t i = 0; i < field_count; i++)
  3367. {
  3368. // 每个16位值按大端存储:高字节在前
  3369. fields[i] = ((uint16_t)data[i * 2] << 8) | data[i * 2 + 1];
  3370. }
  3371. uint64_t result = 0;
  3372. // 根据 order 决定字段拼接顺序
  3373. for (uint8_t i = 0; i < field_count; i++)
  3374. {
  3375. uint8_t index;
  3376. if (order == BYTE_ORDER_BIG_ENDIAN)
  3377. {
  3378. // 大端:字段0 是最高位
  3379. index = i;
  3380. }
  3381. else
  3382. {
  3383. // 小端:字段0 是最低位
  3384. index = field_count - 1 - i;
  3385. }
  3386. uint16_t value = fields[index];
  3387. // 将字段拼接到结果中(左移 16*(field_count-1-index) 位)
  3388. // 使用纯逻辑运算:左移 + 或
  3389. uint8_t shift = (field_count - 1 - index) * 16;
  3390. result |= ((uint64_t)value << shift);
  3391. }
  3392. return result;
  3393. }
  3394. /**
  3395. * @brief uint64_t转十进制字符串
  3396. */
  3397. uint8_t uint64_to_dec_str(uint64_t value, char *str)
  3398. {
  3399. char temp[21];
  3400. uint8_t i = 0;
  3401. uint8_t j = 0;
  3402. if (value == 0)
  3403. {
  3404. str[0] = '0';
  3405. str[1] = '\0';
  3406. return 1;
  3407. }
  3408. while (value > 0)
  3409. {
  3410. temp[i++] = '0' + (value % 10);
  3411. value /= 10;
  3412. }
  3413. uint8_t length = i;
  3414. while (i > 0)
  3415. {
  3416. str[j++] = temp[--i];
  3417. }
  3418. str[j] = '\0';
  3419. return length;
  3420. }
  3421. /**
  3422. * @brief uint64_t除法(纯移位和减法实现)
  3423. * @param dividend 被除数
  3424. * @param divisor 除数
  3425. * @return 包含商和余数的结构体
  3426. */
  3427. uint64_div_result_t uint64_div(uint64_t dividend, uint64_t divisor)
  3428. {
  3429. uint64_div_result_t result = {0, 0};
  3430. // 处理除数为0的情况
  3431. if (divisor == 0)
  3432. {
  3433. // 返回最大值表示错误(可根据需要修改)
  3434. result.quotient = 0xFFFFFFFFFFFFFFFF;
  3435. result.remainder = 0xFFFFFFFFFFFFFFFF;
  3436. return result;
  3437. }
  3438. // 处理被除数为0或除数大于被除数的情况
  3439. if (dividend == 0 || divisor > dividend)
  3440. {
  3441. result.quotient = 0;
  3442. result.remainder = dividend;
  3443. return result;
  3444. }
  3445. // 处理除数为1的情况
  3446. if (divisor == 1)
  3447. {
  3448. result.quotient = dividend;
  3449. result.remainder = 0;
  3450. return result;
  3451. }
  3452. // 使用移位减法算法实现除法
  3453. uint64_t remainder = dividend;
  3454. uint64_t quotient = 0;
  3455. uint64_t current_divisor = divisor;
  3456. int8_t shift_count = 0;
  3457. // 将除数左移到不超过被除数的最高位
  3458. while (current_divisor <= (remainder >> 1))
  3459. {
  3460. current_divisor <<= 1;
  3461. shift_count++;
  3462. }
  3463. // 逐位进行减法操作
  3464. for (int8_t i = shift_count; i >= 0; i--)
  3465. {
  3466. if (remainder >= current_divisor)
  3467. {
  3468. remainder -= current_divisor;
  3469. quotient |= (1ULL << i);
  3470. }
  3471. current_divisor >>= 1;
  3472. }
  3473. result.quotient = quotient;
  3474. result.remainder = remainder;
  3475. return result;
  3476. }