hc_ctl.c 105 KB

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