eeprom.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517
  1. /*
  2. * eeprom.c
  3. *
  4. * Created on: 2020. 4. 22.
  5. * Author: parkyj
  6. */
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include "main.h"
  10. #include "eeprom.h"
  11. #include "Bluecell_operate.h"
  12. #include "stm32f1xx_hal.h"
  13. #include "stm32f1xx_hal_gpio.h"
  14. /* Includes ------------------------------------------------------------------*/
  15. HAL_StatusTypeDef EEPROM_M24C08_ByteRead(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size);
  16. extern void Table_Init();
  17. extern BLUESTATUS_st bluecell_Currdatastatus;
  18. extern uint8_t FRBT_UserCtrl;
  19. extern uint8_t FRBT_UserCtrl_Get();
  20. extern uint8_t FRBT_UserCtrl_Set();
  21. uint8_t testdata[120];
  22. /*
  23. typedef enum{
  24. Test_DL1 = 0,
  25. Test_DL2 = 0,
  26. Test_DL3 = 0,
  27. Test_DL4 = 0,
  28. };
  29. typedef enum{
  30. Test_UL1 = 0,
  31. Test_UL2 = 0,
  32. Test_UL3 = 0,
  33. Test_UL4 = 0,
  34. };*/
  35. /**/
  36. void EEPROM_DataCheck(){
  37. static uint8_t datacheck_array[sizeof(BLUESTATUS_st)];
  38. Bluecell_StructCpy(&datacheck_array[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
  39. for(int i = 0; i < sizeof(BLUESTATUS_st); i++){
  40. if(datacheck_array[i] == 0xFF){
  41. }
  42. else{
  43. return;
  44. }
  45. }
  46. EEPROM_M24C08_Zerowrite(EEPROM_M24C08_ID ,(EEPROM_ATT_BASE));
  47. }
  48. void EEPROM_M24C08_Init(void){
  49. /* uint8_t* data = 0;
  50. int16_t DL_Main_Atten[4] = {0,};
  51. int16_t DL_Offset_Atten[4] = {0,};
  52. int16_t UL_Main_Atten[4] = {0,};
  53. int16_t UL_Offset_Atten[4] = {0,};
  54. int16_t UL_ALC_Atten[4] = {0,};
  55. int16_t DL_High_ThreasHold = 0;
  56. int16_t DL_Low_ThreasHold = 0;
  57. int16_t UL_Hihh_ThreasHold = 0;
  58. bool DL_Path[4] = {0,};
  59. bool UL_Path[4] = {0,};
  60. bool ALC_Path = 0;
  61. bool AGC_Path = 0;
  62. bool DL_shutdown_Path = 0;
  63. bool UL_shutdown_Path = 0;
  64. int16_t DL_Shutdown_ThreadHold = 0;
  65. int16_t UL_Shutdown_ThreadHold = 0;*/
  66. // DL_High_ThreasHold = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
  67. // ALC_TEMP[0] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
  68. // ALC_TEMP[1] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
  69. // ALC_TEMP[2] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
  70. // ALC_TEMP[3] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
  71. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );
  72. // EEPROM_DataCheck();
  73. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE ,&Att_DL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
  74. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL1_TABLE_ADDRESDS,&Att_DL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
  75. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL2_TABLE_ADDRESDS,&Att_DL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
  76. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL3_TABLE_ADDRESDS,&Att_DL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
  77. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_DL4_TABLE_ADDRESDS,&Att_UL1.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
  78. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL1_TABLE_ADDRESDS,&Att_UL2.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
  79. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL2_TABLE_ADDRESDS,&Att_UL3.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
  80. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL3_TABLE_ADDRESDS,&Att_UL4.Table_0_0_dBm,sizeof(ATT_TABLE_st) );
  81. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_UL4_TABLE_ADDRESDS,&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
  82. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL1_TABLE_ADDRESDS,&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
  83. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL2_TABLE_ADDRESDS,&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
  84. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL3_TABLE_ADDRESDS,&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) );
  85. // uint8_t* tmpdata;
  86. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_DL4_TABLE_ADDRESDS,&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
  87. //tmpdata = &Det_UL1.Table_Det_15_dBm_H;
  88. // for(int i =0; i < sizeof(DET_TABLEUL_st) ; i++){
  89. // printf("[%d]%f \r\n",i,(tmpdata[i * 2] << 8 | tmpdata[i*2+1])*0.001);
  90. // }
  91. // printf("");
  92. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL1_TABLE_ADDRESDS,&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
  93. // data = &Det_UL2.Table_Det_15_dBm_H;
  94. // for(int i = 0; i < sizeof(DET_TABLEUL_st) ; i ++ ){
  95. // printf("[%d] %x \r\n",i,data[i]);
  96. // }
  97. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL2_TABLE_ADDRESDS,&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
  98. // data = &Det_UL3.Table_Det_15_dBm_H;
  99. // for(int i = 0; i < sizeof(DET_TABLEUL_st) ; i ++ ){
  100. // printf("[%d] %x \r\n",i,data[i]);
  101. // }
  102. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL3_TABLE_ADDRESDS,&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) );
  103. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_DET_UL4_TABLE_ADDRESDS,&Temp_DL1.Table_1_Temp,sizeof(TEMP_TABLE_st) );
  104. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL1_TABLE_ADDRESDS,&Temp_DL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
  105. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL2_TABLE_ADDRESDS,&Temp_DL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
  106. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL3_TABLE_ADDRESDS,&Temp_DL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );
  107. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_DL4_TABLE_ADDRESDS,&Temp_UL1.Table_1_Temp,sizeof(TEMP_TABLE_st) );
  108. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL1_TABLE_ADDRESDS,&Temp_UL2.Table_1_Temp,sizeof(TEMP_TABLE_st) );
  109. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL2_TABLE_ADDRESDS,&Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
  110. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_TEMP_UL3_TABLE_ADDRESDS,&Temp_UL4.Table_1_Temp,sizeof(TEMP_TABLE_st) );
  111. Table_Init();
  112. HAL_Delay(200);
  113. // printf("MBIC_ULO_ALC_Atten1_H %x / MBIC_ULO_ALC_Atten1_L: %x \r\n",bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H,bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L);
  114. // printf("ATT_UL1_H %x / ATT_UL1_L: %x \r\n",bluecell_Currdatastatus.ATT_UL1_H,bluecell_Currdatastatus.ATT_UL1_L);
  115. // printf("bluecell_User_UL1_H %x / bluecell_User_UL1_L: %x \r\n",bluecell_Currdatastatus.bluecell_User_UL1_H,bluecell_Currdatastatus.bluecell_User_UL1_L);
  116. // printf("===========================================================================\r\n");
  117. // printf("ATT TableDL 1_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Att_DL1.Table_Length,Att_DL1.Table_Ref);
  118. // printf("ATT TableDL 2_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Att_DL2.Table_Length,Att_DL2.Table_Ref);
  119. // printf("ATT TableDL 3_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Att_DL3.Table_Length,Att_DL3.Table_Ref);
  120. // printf("ATT TableDL 4_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Att_DL4.Table_Length,Att_DL4.Table_Ref);
  121. // printf("ATT TableUL 1_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Att_UL1.Table_Length,Att_UL1.Table_Ref);
  122. // printf("ATT TableUL 2_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Att_UL2.Table_Length,Att_UL2.Table_Ref);
  123. // printf("ATT TableUL 3_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Att_UL3.Table_Length,Att_UL3.Table_Ref);
  124. // printf("ATT TableUL 4_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Att_UL4.Table_Length,Att_UL4.Table_Ref);
  125. //
  126. // printf("DET TableDL 1_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Det_DL1.Table_Length,Det_DL1.Table_Ref);
  127. // printf("DET TableDL 2_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Det_DL2.Table_Length,Det_DL2.Table_Ref);
  128. // printf("DET TableDL 3_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Det_DL3.Table_Length,Det_DL3.Table_Ref);
  129. // printf("DET TableDL 4_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Det_DL4.Table_Length,Det_DL4.Table_Ref);
  130. // printf("DET TableUL 1_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Det_UL1.Table_Length,Det_UL1.Table_Ref);
  131. // printf("DET TableUL 2_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Det_UL2.Table_Length,Det_UL2.Table_Ref);
  132. // printf("DET TableUL 3_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Det_UL3.Table_Length,Det_UL3.Table_Ref);
  133. // printf("DET TableUL 4_Init START ORIGIN TABLE LENGTH %d / Ref : %d \r\n",Det_UL4.Table_Length,Det_UL4.Table_Ref);
  134. // printf("DL1\r\n"); Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL1_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL1.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL1.Table_Length);
  135. // printf("DL2\r\n"); Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL2_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL2.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL2.Table_Length);
  136. // printf("DL3\r\n"); Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL3_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL3.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL3.Table_Length);
  137. // printf("DL4\r\n"); Table_DET_DataSetting(&DL_Table_ref[AGC_Table_DL4_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_DL4.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_DL4.Table_Length);
  138. // printf("UL1\r\n"); Table_DET_DataSetting(&UL_Table_ref[ALC_Table_UL1_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_UL1.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_UL1.Table_Length);
  139. // printf("UL2\r\n"); Table_DET_DataSetting(&UL_Table_ref[ALC_Table_UL2_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_UL2.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_UL2.Table_Length);
  140. // printf("UL3\r\n"); Table_DET_DataSetting(&UL_Table_ref[ALC_Table_UL3_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_UL3.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_UL3.Table_Length);
  141. // printf("UL4\r\n"); Table_DET_DataSetting(&UL_Table_ref[ALC_Table_UL4_Ref_Index][DLUL_TABLE_MAX_VALUE],Det_UL4.Table_Ref ,TableDataSetting_ATT_DET_STEP,Det_UL4.Table_Length);
  142. #if 0// PYJ.2020.06.28_BEGIN --
  143. DL_Main_Atten[Test_DL1] = (bluecell_Currdatastatus.ATT_DL1_H << 8) | bluecell_Currdatastatus.ATT_DL1_L;
  144. DL_Main_Atten[Test_DL2] = bluecell_Currdatastatus.ATT_DL2_H << 8 | bluecell_Currdatastatus.ATT_DL2_L;
  145. DL_Main_Atten[Test_DL3] = bluecell_Currdatastatus.ATT_DL3_H << 8 | bluecell_Currdatastatus.ATT_DL3_L;
  146. DL_Main_Atten[Test_DL4] = bluecell_Currdatastatus.ATT_DL4_H << 8 | bluecell_Currdatastatus.ATT_DL4_L;
  147. DL_Offset_Atten[Test_DL1] = bluecell_Currdatastatus.bluecell_User_DL1_H << 8 | bluecell_Currdatastatus.bluecell_User_DL1_L;
  148. DL_Offset_Atten[Test_DL2] = bluecell_Currdatastatus.bluecell_User_DL2_H << 8 | bluecell_Currdatastatus.bluecell_User_DL2_L;
  149. DL_Offset_Atten[Test_DL3] = bluecell_Currdatastatus.bluecell_User_DL3_H << 8 | bluecell_Currdatastatus.bluecell_User_DL3_L;
  150. DL_Offset_Atten[Test_DL4] = bluecell_Currdatastatus.bluecell_User_DL4_H << 8 | bluecell_Currdatastatus.bluecell_User_DL4_L;
  151. UL_Main_Atten[Test_UL1] = bluecell_Currdatastatus.ATT_UL1_H << 8 | bluecell_Currdatastatus.ATT_UL1_L;
  152. UL_Main_Atten[Test_UL2] = bluecell_Currdatastatus.ATT_UL2_H << 8 | bluecell_Currdatastatus.ATT_UL2_L;
  153. UL_Main_Atten[Test_UL3] = bluecell_Currdatastatus.ATT_UL3_H << 8 | bluecell_Currdatastatus.ATT_UL3_L;
  154. UL_Main_Atten[Test_UL4] = bluecell_Currdatastatus.ATT_UL4_H << 8 | bluecell_Currdatastatus.ATT_UL4_L;
  155. UL_Offset_Atten[Test_UL1] = bluecell_Currdatastatus.bluecell_User_UL1_H << 8 | bluecell_Currdatastatus.bluecell_User_UL1_L;
  156. UL_Offset_Atten[Test_UL2] = bluecell_Currdatastatus.bluecell_User_UL2_H << 8 | bluecell_Currdatastatus.bluecell_User_UL2_L;
  157. UL_Offset_Atten[Test_UL3] = bluecell_Currdatastatus.bluecell_User_UL3_H << 8 | bluecell_Currdatastatus.bluecell_User_UL3_L;
  158. UL_Offset_Atten[Test_UL4] = bluecell_Currdatastatus.bluecell_User_UL4_H << 8 | bluecell_Currdatastatus.bluecell_User_UL4_L;
  159. UL_ALC_Atten[Test_UL1] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten1_L;
  160. UL_ALC_Atten[Test_UL2] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten2_L;
  161. UL_ALC_Atten[Test_UL3] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten3_L;
  162. UL_ALC_Atten[Test_UL4] = bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_H << 8 | bluecell_Currdatastatus.MBIC_ULO_ALC_Atten4_L;
  163. #endif // PYJ.2020.06.28_END --
  164. #if 0 // PYJ.2020.06.28_BEGIN --
  165. for(int i = 0; i < 4; i++)
  166. printf("DL : %d \r\n",DL_Main_Atten[Test_DL1+i]);
  167. for(int i = 0; i < 4; i++)
  168. printf("DL Offset: %d \r\n",DL_Offset_Atten[Test_DL1+i]);
  169. for(int i = 0; i < 4; i++)
  170. printf("UL : %d \r\n",UL_Main_Atten[Test_DL1+i]);
  171. for(int i = 0; i < 4; i++)
  172. printf("UL Offset: %d \r\n",UL_Offset_Atten[Test_DL1+i]);
  173. for(int i = 0; i < 4; i++)
  174. printf("UL ALC: %d \r\n",UL_ALC_Atten[Test_DL1+i]);
  175. #endif // PYJ.2020.06.28_END --
  176. /*Table Initial Length Setting */
  177. #if 0 // PYJ.2020.06.23_BEGIN --
  178. printf("Init Temp_UL3 Length : %d \r\n",Temp_UL3.Table_Length);
  179. Bluecell_DataCopy(testdata, &Temp_UL3.Table_1_Temp,sizeof(TEMP_TABLE_st) );
  180. for(int i = 0; i < sizeof(TEMP_TABLE_st); i++){
  181. printf("\r\n testdata[%d] : %x ",i,testdata[i]);
  182. }
  183. #endif // PYJ.2020.06.23_END --
  184. bluecell_Currdatastatus.ALARM_TEMP_HIGH = 0; //bit
  185. bluecell_Currdatastatus.ALARM_DLI_Level = 0;
  186. bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN = 0;
  187. bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0;
  188. bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm = 0;
  189. bluecell_Currdatastatus.ALARM_ULO_Level = 0;
  190. bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN = 0;
  191. bluecell_Currdatastatus.DLI_Shutdown_Retry_Count1 = 0;
  192. bluecell_Currdatastatus.DLI_Shutdown_Retry_Count2 = 0;
  193. bluecell_Currdatastatus.DLI_Shutdown_Retry_Count3 = 0;
  194. bluecell_Currdatastatus.DLI_Shutdown_Retry_Count4 = 0;
  195. bluecell_Currdatastatus.ULO_Shutdown_Retry_Count1 = 0;
  196. bluecell_Currdatastatus.ULO_Shutdown_Retry_Count2 = 0;
  197. bluecell_Currdatastatus.ULO_Shutdown_Retry_Count3 = 0;
  198. bluecell_Currdatastatus.ULO_Shutdown_Retry_Count4 = 0;
  199. bluecell_Currdatastatus.DLI_FRBT_Atten1_H = 0;
  200. bluecell_Currdatastatus.DLI_FRBT_Atten2_H = 0;
  201. bluecell_Currdatastatus.DLI_FRBT_Atten3_H = 0;
  202. bluecell_Currdatastatus.DLI_FRBT_Atten4_H = 0;
  203. bluecell_Currdatastatus.DLI_FRBT_Atten1_L = 0;
  204. bluecell_Currdatastatus.DLI_FRBT_Atten2_L = 0;
  205. bluecell_Currdatastatus.DLI_FRBT_Atten3_L = 0;
  206. bluecell_Currdatastatus.DLI_FRBT_Atten4_L = 0;
  207. bluecell_Currdatastatus.DLI_FRBT_D_Day = DLI_FRBT_DAY_DEFAULT;
  208. bluecell_Currdatastatus.DLI_FRBT_Status = FRBT_TRACKING;
  209. // FRBT_UserCtrl = false;
  210. FRBT_UserCtrl_Set(false);
  211. if(bluecell_Currdatastatus.SelfTest == true){
  212. bluecell_Currdatastatus.ATT_DL1_H = bluecell_Currdatastatus.SelfTest_ATT_DL1_H ;
  213. bluecell_Currdatastatus.ATT_DL2_H = bluecell_Currdatastatus.SelfTest_ATT_DL2_H ;
  214. bluecell_Currdatastatus.ATT_DL3_H = bluecell_Currdatastatus.SelfTest_ATT_DL3_H ;
  215. bluecell_Currdatastatus.ATT_DL4_H = bluecell_Currdatastatus.SelfTest_ATT_DL4_H ;
  216. bluecell_Currdatastatus.ATT_DL1_L = bluecell_Currdatastatus.SelfTest_ATT_DL1_L ;
  217. bluecell_Currdatastatus.ATT_DL2_L = bluecell_Currdatastatus.SelfTest_ATT_DL2_L ;
  218. bluecell_Currdatastatus.ATT_DL3_L = bluecell_Currdatastatus.SelfTest_ATT_DL3_L ;
  219. bluecell_Currdatastatus.ATT_DL4_L = bluecell_Currdatastatus.SelfTest_ATT_DL4_L ;
  220. bluecell_Currdatastatus.ATT_UL1_H = bluecell_Currdatastatus.SelfTest_ATT_UL1_H ;
  221. bluecell_Currdatastatus.ATT_UL2_H = bluecell_Currdatastatus.SelfTest_ATT_UL2_H ;
  222. bluecell_Currdatastatus.ATT_UL3_H = bluecell_Currdatastatus.SelfTest_ATT_UL3_H ;
  223. bluecell_Currdatastatus.ATT_UL4_H = bluecell_Currdatastatus.SelfTest_ATT_UL4_H ;
  224. bluecell_Currdatastatus.ATT_UL1_L = bluecell_Currdatastatus.SelfTest_ATT_UL1_L ;
  225. bluecell_Currdatastatus.ATT_UL2_L = bluecell_Currdatastatus.SelfTest_ATT_UL2_L ;
  226. bluecell_Currdatastatus.ATT_UL3_L = bluecell_Currdatastatus.SelfTest_ATT_UL3_L ;
  227. bluecell_Currdatastatus.ATT_UL4_L = bluecell_Currdatastatus.SelfTest_ATT_UL4_L ;
  228. }
  229. bluecell_Currdatastatus.SelfTest = false;
  230. printf("bluecell_Currdatastatus.DLI_Level_High_Threshold_H : %x \r\n",bluecell_Currdatastatus.DLI_Level_High_Threshold_H);
  231. printf("bluecell_Currdatastatus.DLI_Level_High_Threshold_L : %x \r\n",bluecell_Currdatastatus.DLI_Level_High_Threshold_L);
  232. // bluecell_Currdatastatus.DLI_FRBT_Status = 7;
  233. bluecell_Currdatastatus.ALARM_TESTMODE = 0;
  234. bluecell_Currdatastatus.Type = 0;
  235. if(bluecell_Currdatastatus.Carrier_ON_OFF == true){
  236. if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x80)
  237. bluecell_Currdatastatus.ATT_DL1_PATH = true;
  238. else
  239. bluecell_Currdatastatus.ATT_DL1_PATH = false;
  240. if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x40)
  241. bluecell_Currdatastatus.ATT_DL2_PATH = true;
  242. else
  243. bluecell_Currdatastatus.ATT_DL2_PATH = false;
  244. if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x20)
  245. bluecell_Currdatastatus.ATT_DL3_PATH = true;
  246. else
  247. bluecell_Currdatastatus.ATT_DL3_PATH = false;
  248. if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x10)
  249. bluecell_Currdatastatus.ATT_DL4_PATH = true;
  250. else
  251. bluecell_Currdatastatus.ATT_DL4_PATH = false;
  252. if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x08)
  253. bluecell_Currdatastatus.ATT_UL1_PATH = true;
  254. else
  255. bluecell_Currdatastatus.ATT_UL1_PATH = false;
  256. if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x04)
  257. bluecell_Currdatastatus.ATT_UL2_PATH = true;
  258. else
  259. bluecell_Currdatastatus.ATT_UL2_PATH = false;
  260. if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x02)
  261. bluecell_Currdatastatus.ATT_UL3_PATH = true;
  262. else
  263. bluecell_Currdatastatus.ATT_UL3_PATH = false;
  264. if(bluecell_Currdatastatus.Path_TempSave_Bit & 0x01)
  265. bluecell_Currdatastatus.ATT_UL4_PATH = true;
  266. else
  267. bluecell_Currdatastatus.ATT_UL4_PATH = false;
  268. }
  269. else{
  270. bluecell_Currdatastatus.ATT_DL1_PATH = false;
  271. bluecell_Currdatastatus.ATT_DL2_PATH = false;
  272. bluecell_Currdatastatus.ATT_DL3_PATH = false;
  273. bluecell_Currdatastatus.ATT_DL4_PATH = false;
  274. bluecell_Currdatastatus.ATT_UL1_PATH = false;
  275. bluecell_Currdatastatus.ATT_UL2_PATH = false;
  276. bluecell_Currdatastatus.ATT_UL3_PATH = false;
  277. bluecell_Currdatastatus.ATT_UL4_PATH = false;
  278. bluecell_Currdatastatus.Path_TempSave_Bit = 0;
  279. }
  280. // printf("PCB Version : %d.%d \r\n",bluecell_Currdatastatus.PCB_Version[0],bluecell_Currdatastatus.PCB_Version[1]);
  281. // printf("Serial Number : ");
  282. // for(int a = 0; a < 20; a++){
  283. // printf("%c",bluecell_Currdatastatus.Serial_Number[a]);
  284. // }
  285. // printf("\r\n");
  286. // printf("Manufacture_Date : ");
  287. // for(int a = 0; a < 3; a++){
  288. // printf("%c",bluecell_Currdatastatus.Manufacture_Date[a]);
  289. // }
  290. // printf("\r\n");
  291. bluecell_Currdatastatus.ALARM_TEMP_HIGH = 0;
  292. bluecell_Currdatastatus.ALARM_DLI_Level = 0;
  293. bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN = 0;
  294. bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm = 0;
  295. bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm = 0;
  296. bluecell_Currdatastatus.ALARM_ULO_Level = 0;
  297. bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN = 0;
  298. }
  299. #if 0 // PYJ.2020.04.23_BEGIN --
  300. void eepromtest(){
  301. memset(&eepdata[0],0x33,100);
  302. for(int i = 0; i < 100; i ++ ){
  303. printf("data[%d] : %x \r\n",i,eepdata[i]);
  304. EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID,EEPROM_ATT_BASE + i,&eepdata[i],1);
  305. }
  306. for(int i = 0; i < 100; i ++ ){
  307. EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_ATT_BASE + i,&eepdata[i],1);
  308. printf("data[%d] : %x \r\n",i,eepdata[i]);
  309. }
  310. // EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&eepdata[0],100);
  311. // for(int i = 0; i < 100; i ++ ){
  312. // printf("data[%d] : %x \r\n",i,eepdata[i]);
  313. // }
  314. }
  315. #endif // PYJ.2020.04.23_END --
  316. #define MAXEEPROM_LENG 32
  317. HAL_StatusTypeDef EEPROM_M24C08_Read(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
  318. HAL_StatusTypeDef ret = HAL_ERROR;
  319. uint8_t sizecnt = 0,sizeremain = 0;
  320. uint16_t addrees_inc = 0;
  321. sizecnt = size /MAXEEPROM_LENG;
  322. sizeremain = size % MAXEEPROM_LENG;
  323. addrees_inc = 0;
  324. // uint16_t sizecnt = 0,
  325. //uint16_t sizeremain = 0;
  326. // uint16_t addrees_inc = 0;
  327. // ret = HAL_I2C_Mem_Read(&hi2c2, devid | ((Address & 0x0300) >> 7),((Address )), I2C_MEMADD_SIZE_8BIT, &data[0], size, 1024);
  328. #if 1 // PYJ.2020.06.28_BEGIN --
  329. ret = HAL_I2C_Mem_Read(&hi2c2, devid ,((Address )), I2C_MEMADD_SIZE_16BIT, &data[0], size, 0xFFFF);
  330. // EEPROM24XX_Load( Address,data, size);
  331. // if(ret == HAL_ERROR)
  332. // printf("Write ERR\r\n");
  333. #else
  334. if(sizecnt > 0){
  335. for(int i = 0 ; i < sizecnt; i++ ){
  336. addrees_inc = i * MAXEEPROM_LENG;
  337. ret = HAL_I2C_Mem_Read(&hi2c2, devid ,((Address + addrees_inc) & 0xFFFF) , I2C_MEMADD_SIZE_16BIT, &data[addrees_inc], MAXEEPROM_LENG, 1024);
  338. if(ret == HAL_ERROR)
  339. printf("Write ERR\r\n");
  340. HAL_Delay(20);
  341. }
  342. addrees_inc += MAXEEPROM_LENG;
  343. }
  344. #endif // PYJ.2020.06.28_END --
  345. // HAL_Delay(20);
  346. return ret;
  347. }
  348. HAL_StatusTypeDef EEPROM_M24C08_write(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
  349. HAL_StatusTypeDef ret = HAL_ERROR;
  350. uint8_t sizecnt = 0,sizeremain = 0;
  351. uint16_t addrees_inc = 0;
  352. sizecnt = size /MAXEEPROM_LENG;
  353. sizeremain = size % MAXEEPROM_LENG;
  354. addrees_inc = 0;
  355. #if 0 // PYJ.2020.04.25_BEGIN --
  356. for(int i = 0 ; i <sizecnt; i++ ){
  357. addrees_inc = i * 16;
  358. ret = HAL_I2C_Mem_Write(&hi2c2, devid | (((Address + addrees_inc) & 0x0300) >> 7),((Address + addrees_inc)) , I2C_MEMADD_SIZE_8BIT, &data[addrees_inc], 16, 1024);
  359. if(ret == HAL_ERROR)
  360. printf("Write ERR\r\n");
  361. else
  362. HAL_Delay(20);
  363. }
  364. addrees_inc += 16;
  365. ret = HAL_I2C_Mem_Write(&hi2c2, devid | (((Address + addrees_inc) & 0x0300) >> 7),((Address + addrees_inc)) , I2C_MEMADD_SIZE_8BIT, &data[addrees_inc], sizeremain, 1024);
  366. // EEPROM24XX_Save( Address,data, size);
  367. if(ret == HAL_ERROR)
  368. printf("Write ERR\r\n");
  369. else
  370. HAL_Delay(20);
  371. #else
  372. // printf("size : %d sizecnt = %d sizeremain : %d\r\n",size,sizecnt,sizeremain);
  373. if(sizecnt > 0){
  374. for(int i = 0 ; i < sizecnt; i++ ){
  375. addrees_inc = i * MAXEEPROM_LENG;
  376. ret = HAL_I2C_Mem_Write(&hi2c2, devid ,((Address + addrees_inc) & 0xFFFF) , I2C_MEMADD_SIZE_16BIT, &data[addrees_inc], MAXEEPROM_LENG, 1024);
  377. // if(ret == HAL_ERROR)
  378. // printf("Write ERR\r\n");
  379. HAL_Delay(20);
  380. }
  381. addrees_inc += MAXEEPROM_LENG;
  382. }
  383. // printf("Remain Data Index : %d \r\n",sizeremain);
  384. if(sizeremain > 0){
  385. // printf("Remain Data Write Start ");
  386. for(int i = 0; i < sizeremain; i++){
  387. ret = HAL_I2C_Mem_Write(&hi2c2, devid ,((Address + addrees_inc + i)& 0xFFFF) , I2C_MEMADD_SIZE_16BIT, &data[addrees_inc + i], 1, 0xFFFF);
  388. // EEPROM24XX_Save( Address,data, size);
  389. // if(ret == HAL_ERROR)
  390. // printf("Write ERR\r\n");
  391. HAL_Delay(20);
  392. }
  393. }
  394. // printf("EEPROM WRITE\r\n");
  395. #endif // PYJ.2020.04.25_END --
  396. return ret;
  397. }
  398. HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address){
  399. HAL_StatusTypeDef ret = HAL_ERROR;
  400. // uint8_t sizeremain = 0;
  401. uint16_t addrees_inc = 0;
  402. addrees_inc = 0;
  403. static uint8_t data[1024] = {0,};
  404. // printf("EEPROM ALL ERASE \r\n");
  405. for(int i = 0 ; i < 128; i++ ){
  406. addrees_inc = i * MAXEEPROM_LENG;
  407. ret = HAL_I2C_Mem_Write(&hi2c2,
  408. devid ,
  409. ((Address + addrees_inc) & 0xFFFF) ,
  410. I2C_MEMADD_SIZE_16BIT,
  411. &data[0],
  412. MAXEEPROM_LENG,
  413. 0xFFFF);
  414. // if(ret == HAL_ERROR)
  415. // printf("Write ERR\r\n");
  416. // else
  417. HAL_Delay(20);
  418. }
  419. return ret;
  420. }