#include #include "main.h" #include "Bluecell_operate.h" #include "PE43711.h" #include "eeprom.h" extern volatile uint32_t LedTimerCnt; extern volatile uint32_t AdcTimerCnt; extern void PE43711_atten_ctrl(PE43711_st ATT ,uint8_t data); extern void Uart1_Data_Send(uint8_t* data,uint8_t size); uint8_t Alarm_Status[MAX_ALARM_Len] = {0,}; //uint8_t data123[10000]; uint8_t ResultData[1024] = {0,}; void Boot_LED_Toggle(void){ if(LedTimerCnt > 500){ HAL_GPIO_TogglePin(BOOT_LED_GPIO_Port,BOOT_LED_Pin); LedTimerCnt = 0; // printf("LED OF OFF\r\n"); } } uint8_t* MBIC_HeaderDataSetting(uint8_t* data){ ResultData[MBIC_PREAMBLE_0] = MBIC_PREAMBLE0; ResultData[MBIC_PREAMBLE_1] = MBIC_PREAMBLE1; ResultData[MBIC_PREAMBLE_2] = MBIC_PREAMBLE2; ResultData[MBIC_PREAMBLE_3] = MBIC_PREAMBLE3; ResultData[MBIC_SUBUID_0] = MBIC_SUBUID0; ResultData[MBIC_SUBUID_1] = MBIC_SUBUID1; ResultData[MBIC_RCODE_0] = data[MBIC_RCODE_0]; ResultData[MBIC_TRID_0] = data[MBIC_TRID_0]; ResultData[MBIC_TRID_1] = data[MBIC_TRID_1]; ResultData[MBIC_SEQSUM_0] = data[MBIC_SEQSUM_0]; ResultData[MBIC_TTL_0] = data[MBIC_TTL_0]; ResultData[MBIC_TIME_0] = data[MBIC_TIME_0]; ResultData[MBIC_TIME_1] = data[MBIC_TIME_1]; ResultData[MBIC_TIME_2] = data[MBIC_TIME_2]; ResultData[MBIC_TIME_3] = data[MBIC_TIME_3]; ResultData[MBIC_TIME_4] = data[MBIC_TIME_4]; ResultData[MBIC_TIME_5] = data[MBIC_TIME_5]; return ResultData; } typedef enum{ BLUECELL_HEADER, BLUECELL_TYPE, BLUECELL_LENGTH, BLUECELL_CRCINDEX, BLUECELL_DATA, }BLUECELLProt_st; typedef struct{ bool AGC1_En; bool AGC2_En; bool AGC3_En; bool AGC4_En; bool ALC1_En; bool ALC2_En; bool ALC3_En; bool ALC4_En; }AutoCtrl_st; extern ALL_PE43711_st ALL_ATT; BLUESTATUS_st bluecell_Currdatastatus; BLUESTATUS_st bluecell_Prevdatastatus; double TableAtteGuarantee(uint8_t* Table,double AttenValue); uint8_t PE43711_Calc(uint8_t* Table,uint8_t high_bit,uint8_t low_bit); uint8_t PE43711_Calc_NoTable(uint8_t high_bit,uint8_t low_bit); double PE43711_Double(uint8_t high_bit,uint8_t low_bit); uint8_t PE43711_Calc(uint8_t* Table,uint8_t high_bit,uint8_t low_bit){ uint8_t tmp_h = high_bit,tmp_l = low_bit; double ret = 0; uint8_t val = 0; ret = PE43711_Double(high_bit,low_bit); // printf("ret1 : %f \r\n",ret); // 2 ret = TableAtteGuarantee(Table,ret);//Table Guarantee // printf("ret2 : %f \r\n",ret); val = PE43711_DataToHexConvert(ret); } uint8_t PE43711_Calc_NoTable(uint8_t high_bit,uint8_t low_bit){ uint16_t tmp_h = high_bit,tmp_l = low_bit; double ret = 0; uint8_t val = 0; ret = PE43711_Double(high_bit,low_bit); val = PE43711_DataToHexConvert(ret); } double PE43711_Double(uint8_t high_bit,uint8_t low_bit){ uint16_t tmp_h = 0,tmp_l = 0; double ret = 0; uint8_t val = 0; tmp_h = high_bit; tmp_l = low_bit; ret = ((tmp_h << 8) & 0xFF00); ret += (tmp_l & 0x00FF); if((((tmp_h << 8) & 0xFF00) & 0xF000) == 0xF000){ // printf("minus Calc Start\r\n"); ret = 0xFFFF - ret; // printf("0xFFFF - %x\r\n",ret); ret += 0x01; ret = ret - (2*ret); // printf("ret : %x\r\n",ret); } // printf("%s 1: ret : %x\r\n",__func__,ret); ret /= 100; // printf("%s 2: ret : %f\r\n",__func__,ret); return ret; } uint8_t GuaranteeData[256]; double TableAtteGuarantee(uint8_t* Table,double AttenValue){ double ret = 0; double ref = 0; uint8_t cnt = 0; for(double ref = 0; ref < AttenValue; ref += 0.5){ cnt++; } Bluecell_StructCpy(&GuaranteeData[0],&Table[0],sizeof(ATT_TABLE_st)); // printf("H : %x L : %x \r\n",GuaranteeData[cnt * 2],GuaranteeData[cnt * 2 + 1]); ret = PE43711_Double(GuaranteeData[cnt * 2],GuaranteeData[cnt * 2 + 1]); // printf("ret3 : %f \r\n",ret); //1 ret += AttenValue; // printf("ret4 : %f \r\n",ret); return ret; } void CompareAttenData(BLUESTATUS_st Curr,BLUESTATUS_st Prev){ uint8_t val = 0; if(Curr.ATT_DL1_H != Prev.ATT_DL1_H ||Curr.ATT_DL1_L != Prev.ATT_DL1_L){ bluecell_Prevdatastatus.ATT_DL1_H = bluecell_Currdatastatus.ATT_DL1_H; bluecell_Prevdatastatus.ATT_DL1_L = bluecell_Currdatastatus.ATT_DL1_L; val = PE43711_Calc(&Att_DL1.Table_0_0_dBm_H,Curr.ATT_DL1_H,Curr.ATT_DL1_L); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); } if((Curr.ATT_DL2_H != Prev.ATT_DL2_H) ||(Curr.ATT_DL2_L != Prev.ATT_DL2_L)){ bluecell_Prevdatastatus.ATT_DL2_H = bluecell_Currdatastatus.ATT_DL2_H; bluecell_Prevdatastatus.ATT_DL2_L = bluecell_Currdatastatus.ATT_DL2_L; val = PE43711_Calc(&Att_DL2.Table_0_0_dBm_H,Curr.ATT_DL2_H,Curr.ATT_DL2_L); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_DL2,val); } if(Curr.ATT_DL3_H != Prev.ATT_DL3_H ||Curr.ATT_DL3_L != Prev.ATT_DL3_L){ bluecell_Prevdatastatus.ATT_DL3_H = bluecell_Currdatastatus.ATT_DL3_H; bluecell_Prevdatastatus.ATT_DL3_L = bluecell_Currdatastatus.ATT_DL3_L; val = PE43711_Calc(&Att_DL3.Table_0_0_dBm_H,Curr.ATT_DL3_H,Curr.ATT_DL3_L); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_DL3,val); } // printf("\r\nCurr.ATT_DL3_H : %x \r\nPrev.ATT_DL3_H : %x \r\n",Curr.ATT_DL3_H,Prev.ATT_DL3_H); // printf("\r\nCurr.ATT_DL3_L : %x \r\nPrev.ATT_DL3_L : %x \r\n",Curr.ATT_DL3_L,Prev.ATT_DL3_L); if(Curr.ATT_DL4_H != Prev.ATT_DL4_H ||Curr.ATT_DL4_L != Prev.ATT_DL4_L){ bluecell_Prevdatastatus.ATT_DL4_H = bluecell_Currdatastatus.ATT_DL4_H; bluecell_Prevdatastatus.ATT_DL4_L = bluecell_Currdatastatus.ATT_DL4_L; val = PE43711_Calc(&Att_DL4.Table_0_0_dBm_H,Curr.ATT_DL4_H,Curr.ATT_DL4_L); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_DL4,val); } if(Curr.ATT_UL1_H != Prev.ATT_UL1_H ||Curr.ATT_UL1_L != Prev.ATT_UL1_L){ bluecell_Prevdatastatus.ATT_UL1_H = bluecell_Currdatastatus.ATT_UL1_H; bluecell_Prevdatastatus.ATT_UL1_L = bluecell_Currdatastatus.ATT_UL1_L; val = PE43711_Calc(&Att_UL1.Table_0_0_dBm_H,Curr.ATT_UL1_H,Curr.ATT_UL1_L); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL1,val); } if(Curr.ATT_UL2_H != Prev.ATT_UL2_H ||Curr.ATT_UL2_L != Prev.ATT_UL2_L){ bluecell_Prevdatastatus.ATT_UL2_H = bluecell_Currdatastatus.ATT_UL2_H; bluecell_Prevdatastatus.ATT_UL2_L = bluecell_Currdatastatus.ATT_UL2_L; val = PE43711_Calc(&Att_UL2.Table_0_0_dBm_H,Curr.ATT_UL2_H,Curr.ATT_UL2_L); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL2,val); } if(Curr.ATT_UL3_H != Prev.ATT_UL3_H ||Curr.ATT_UL3_L != Prev.ATT_UL3_L){ bluecell_Prevdatastatus.ATT_UL3_H = bluecell_Currdatastatus.ATT_UL3_H; bluecell_Prevdatastatus.ATT_UL3_L = bluecell_Currdatastatus.ATT_UL3_L; val = PE43711_Calc(&Att_UL3.Table_0_0_dBm_H,Curr.ATT_UL3_H,Curr.ATT_UL3_L); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL3,val); } if(Curr.ATT_UL4_H != Prev.ATT_UL4_H ||Curr.ATT_UL4_L != Prev.ATT_UL4_L){ bluecell_Prevdatastatus.ATT_UL4_H = bluecell_Currdatastatus.ATT_UL4_H; bluecell_Prevdatastatus.ATT_UL4_L = bluecell_Currdatastatus.ATT_UL4_L; val = PE43711_Calc(&Att_UL4.Table_0_0_dBm_H,Curr.ATT_UL4_H,Curr.ATT_UL4_L); // printf("%d val = %x \r\n",__LINE__,val); PE43711_atten_ctrl(ALL_ATT.ATT_UL4,val); } // memcpy(&bluecell_Prevdatastatus.ATT_DL1_H,&bluecell_Currdatastatus.ATT_DL1_H,32); #if 1 // PYJ.2020.04.21_BEGIN -- if(Curr.ATT_ALC1_H != Prev.ATT_ALC1_H ||Curr.ATT_ALC1_L != Prev.ATT_ALC1_L){ bluecell_Prevdatastatus.ATT_ALC1_H = bluecell_Currdatastatus.ATT_ALC1_H; bluecell_Prevdatastatus.ATT_ALC1_L = bluecell_Currdatastatus.ATT_ALC1_L; val = PE43711_Calc(&Att_UL1.Table_0_0_dBm_H,Curr.ATT_ALC1_H,Curr.ATT_ALC1_L); // val = PE43711_DataToHexConvert(ret); // PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); } if(Curr.ATT_ALC2_H != Prev.ATT_ALC2_H ||Curr.ATT_ALC2_L != Prev.ATT_ALC2_L){ bluecell_Prevdatastatus.ATT_ALC2_H = bluecell_Currdatastatus.ATT_ALC2_H; bluecell_Prevdatastatus.ATT_ALC2_L = bluecell_Currdatastatus.ATT_ALC2_L; val = PE43711_Calc(&Att_UL2.Table_0_0_dBm_H,Curr.ATT_ALC2_H,Curr.ATT_ALC2_L); // PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); } if(Curr.ATT_ALC3_H != Prev.ATT_ALC3_H ||Curr.ATT_ALC3_L != Prev.ATT_ALC3_L){ bluecell_Prevdatastatus.ATT_ALC3_H = bluecell_Currdatastatus.ATT_ALC3_H; bluecell_Prevdatastatus.ATT_ALC3_L = bluecell_Currdatastatus.ATT_ALC3_L; val = PE43711_Calc(&Att_UL3.Table_0_0_dBm_H,Curr.ATT_ALC3_H,Curr.ATT_ALC3_L); // PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); } if(Curr.ATT_ALC4_H != Prev.ATT_ALC4_H ||Curr.ATT_ALC4_L != Prev.ATT_ALC4_L){ // printf("Curr.ATT_ALC4_H : %x Curr.ATT_ALC4_L : %x\r\n",Curr.ATT_ALC4_H,Curr.ATT_ALC4_L); bluecell_Prevdatastatus.ATT_ALC4_H = bluecell_Currdatastatus.ATT_ALC4_H; bluecell_Prevdatastatus.ATT_ALC4_L = bluecell_Currdatastatus.ATT_ALC4_L; val = PE43711_Calc(&Att_UL4.Table_0_0_dBm_H,Curr.ATT_ALC4_H,Curr.ATT_ALC4_L); // PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); } if(Curr.ATT_AGC1_H != Prev.ATT_AGC1_H ||Curr.ATT_AGC1_L != Prev.ATT_AGC1_L){ bluecell_Prevdatastatus.ATT_AGC1_H = bluecell_Currdatastatus.ATT_AGC1_H; bluecell_Prevdatastatus.ATT_AGC1_L = bluecell_Currdatastatus.ATT_AGC1_L; val = PE43711_Calc(&Att_DL1.Table_0_0_dBm_H,Curr.ATT_AGC1_H,Curr.ATT_AGC1_L); // PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); } if(Curr.ATT_AGC2_H != Prev.ATT_AGC2_H ||Curr.ATT_AGC2_L != Prev.ATT_AGC2_L){ bluecell_Prevdatastatus.ATT_AGC2_H = bluecell_Currdatastatus.ATT_AGC2_H; bluecell_Prevdatastatus.ATT_AGC2_L = bluecell_Currdatastatus.ATT_AGC2_L; val = PE43711_Calc(&Att_DL2.Table_0_0_dBm_H,Curr.ATT_AGC2_H,Curr.ATT_AGC2_L); // PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); } if(Curr.ATT_AGC3_H != Prev.ATT_AGC3_H ||Curr.ATT_AGC3_L != Prev.ATT_AGC3_L){ bluecell_Prevdatastatus.ATT_AGC3_H = bluecell_Currdatastatus.ATT_AGC3_H; bluecell_Prevdatastatus.ATT_AGC3_L = bluecell_Currdatastatus.ATT_AGC3_L; val = PE43711_Calc(&Att_DL3.Table_0_0_dBm_H,Curr.ATT_AGC3_H,Curr.ATT_AGC3_L); // PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); } if(Curr.ATT_AGC4_H != Prev.ATT_AGC4_H ||Curr.ATT_AGC4_L != Prev.ATT_AGC4_L){ bluecell_Prevdatastatus.ATT_AGC4_H = bluecell_Currdatastatus.ATT_AGC4_H; bluecell_Prevdatastatus.ATT_AGC4_L = bluecell_Currdatastatus.ATT_AGC4_L; val = PE43711_Calc(&Att_DL4.Table_0_0_dBm_H,Curr.ATT_AGC4_H,Curr.ATT_AGC4_L); // PE43711_atten_ctrl(ALL_ATT.ATT_DL1,val); } #endif // PYJ.2020.04.21_END -- } typedef enum{ Bluecell_Table_ATT_DL1 = 0, Bluecell_Table_ATT_UL1, Bluecell_Table_ATT_DL2, Bluecell_Table_ATT_UL2, Bluecell_Table_ATT_DL3, Bluecell_Table_ATT_UL3, Bluecell_Table_ATT_DL4, Bluecell_Table_ATT_UL4, Bluecell_Table_DET_DL1, Bluecell_Table_DET_UL1, Bluecell_Table_DET_DL2, Bluecell_Table_DET_UL2, Bluecell_Table_DET_DL3, Bluecell_Table_DET_UL3, Bluecell_Table_DET_DL4, Bluecell_Table_DET_UL4, Bluecell_Table_TEMP_DL1, Bluecell_Table_TEMP_UL1, Bluecell_Table_TEMP_DL2, Bluecell_Table_TEMP_UL2, Bluecell_Table_TEMP_DL3, Bluecell_Table_TEMP_UL3, Bluecell_Table_TEMP_DL4, Bluecell_Table_TEMP_UL4, }Bluecell_tableIndex; ATT_TABLE_st Att_DL1; ATT_TABLE_st Att_DL2; ATT_TABLE_st Att_DL3; ATT_TABLE_st Att_DL4; ATT_TABLE_st Att_UL1; ATT_TABLE_st Att_UL2; ATT_TABLE_st Att_UL3; ATT_TABLE_st Att_UL4; DET_TABLEDL_st Det_DL1; DET_TABLEDL_st Det_DL2; DET_TABLEDL_st Det_DL3; DET_TABLEDL_st Det_DL4; DET_TABLEUL_st Det_UL1; DET_TABLEUL_st Det_UL2; DET_TABLEUL_st Det_UL3; DET_TABLEUL_st Det_UL4; TEMP_TABLE_st Temp_DL1; TEMP_TABLE_st Temp_DL2; TEMP_TABLE_st Temp_DL3; TEMP_TABLE_st Temp_DL4; TEMP_TABLE_st Temp_UL1; TEMP_TABLE_st Temp_UL2; TEMP_TABLE_st Temp_UL3; TEMP_TABLE_st Temp_UL4; void Bluecell_StructCopyFunction(uint16_t* dst,uint8_t* src,uint16_t size){ for(int i = 0; i < size / 2; i++){ dst[i] = ((src[i * 2] << 8) & 0xFF00); dst[i] += src[i * 2 + 1] & 0x00FF; } } void Bluecell_StructCpy(uint8_t* dst,uint8_t* src,uint16_t size){ for(int i = 0; i < size; i++){ dst[i] = src[i]; } } uint16_t ConvertTo2byte(uint8_t highbit, uint8_t lowbit){ uint16_t ret = 0; ret += ((highbit << 8) & 0xFF00); ret += (lowbit & 0x00FF); return ret; } typedef struct{ uint8_t High_bit; uint8_t Low_bit; }OneByteToTwoByte; OneByteToTwoByte ConvertTo1Byte(uint16_t data){ OneByteToTwoByte ret; ret.High_bit = ((data & 0xFF00) >> 8); ret.Low_bit = ((data & 0x00FF)); return ret; } void Bluecell_Struct2byteCopyFunction(uint8_t* dst,uint16_t* src,uint8_t size){ OneByteToTwoByte convert; for(int i = 0; i < (size / 2); i++){ convert = ConvertTo1Byte(src[i]); dst[i * 2] = convert.High_bit; dst[i * 2 + 1] = convert.Low_bit; } } void Bluecell_structprintf(uint8_t* dst,uint8_t size){ for(int i = 0; i < size; i++){ printf("Index[%d]%x \r\n",i,dst[i]); } } uint8_t DataWrite[512] = {0,}; uint8_t DataRead[512] = {0,}; void Bluecell_DataCopy(uint8_t* dst,uint8_t* src,uint16_t size){ for(int i = 0; i < size; i++){ dst[i] = src[i]; } } void Bluecell_TableLoad(uint8_t* data){ uint8_t tabletype = data[BLUECELL_DATA]; // OneByteToTwoByte data; // printf("%s : %x \r\n",__func__,tabletype); switch(tabletype){ case Bluecell_Table_ATT_DL1: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,EEPROM_WINDOW_STATUS_ADDRESDS ,&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); // Bluecell_structprintf(&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3; break; case Bluecell_Table_ATT_DL2: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3; break; case Bluecell_Table_ATT_DL3: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3; break; case Bluecell_Table_ATT_DL4: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_DL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3; break; case Bluecell_Table_ATT_UL1: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3; break; case Bluecell_Table_ATT_UL2: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3; break; case Bluecell_Table_ATT_UL3: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3; break; case Bluecell_Table_ATT_UL4: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Att_UL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(ATT_TABLE_st)) + 7 - 3; break; case Bluecell_Table_DET_DL1: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3; break; case Bluecell_Table_DET_DL2: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL1_TABLE_ADDRESDS),&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3; break; case Bluecell_Table_DET_DL3: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL2_TABLE_ADDRESDS),&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3; break; case Bluecell_Table_DET_DL4: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL3_TABLE_ADDRESDS),&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); data[BLUECELL_LENGTH] = (sizeof(DET_TABLEDL_st)) + 7 - 3; break; case Bluecell_Table_DET_UL1: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_DL4_TABLE_ADDRESDS),&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3; break; case Bluecell_Table_DET_UL2: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL1_TABLE_ADDRESDS),&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3; break; case Bluecell_Table_DET_UL3: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL2_TABLE_ADDRESDS),&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3; break; case Bluecell_Table_DET_UL4: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL3_TABLE_ADDRESDS),&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); data[BLUECELL_LENGTH] = (sizeof(DET_TABLEUL_st)) + 7 - 3; break; case Bluecell_Table_TEMP_DL1: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3; break; case Bluecell_Table_TEMP_DL2: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3; break; case Bluecell_Table_TEMP_DL3: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3; break; case Bluecell_Table_TEMP_DL4: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3; break; case Bluecell_Table_TEMP_UL1: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3; break; case Bluecell_Table_TEMP_UL2: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3; break; case Bluecell_Table_TEMP_UL3: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3; break; case Bluecell_Table_TEMP_UL4: EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st) ); Bluecell_DataCopy(&data[BLUECELL_DATA + 1],&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); data[BLUECELL_LENGTH] = (sizeof(TEMP_TABLE_st)) + 7 - 3; break; } } void Bluecell_TableSave(uint8_t* data){ uint8_t tabletype = data[BLUECELL_DATA]; //printf("%s : %x \r\n",__func__,tabletype); switch(tabletype){ case Bluecell_Table_ATT_DL1: Bluecell_DataCopy(&Att_DL1.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS) ,&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) ); // Bluecell_structprintf(&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); // printf("ADDRESS : %d \r\n",EEPROM_WINDOW_STATUS_ADDRESDS ); // Bluecell_structprintf(&Att_DL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); break; case Bluecell_Table_ATT_DL2: Bluecell_DataCopy(&Att_DL2.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL1_TABLE_ADDRESDS),&Att_DL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st) ); // printf("ADDRESS : %d \r\n",EEPROM_ATT_DL1_TABLE_ADDRESDS ); break; case Bluecell_Table_ATT_DL3: Bluecell_DataCopy(&Att_DL3.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL2_TABLE_ADDRESDS),&Att_DL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); break; case Bluecell_Table_ATT_DL4: Bluecell_DataCopy(&Att_DL4.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL3_TABLE_ADDRESDS),&Att_DL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); break; case Bluecell_Table_ATT_UL1: Bluecell_DataCopy(&Att_UL1.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_DL4_TABLE_ADDRESDS),&Att_UL1.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); break; case Bluecell_Table_ATT_UL2: Bluecell_DataCopy(&Att_UL2.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL1_TABLE_ADDRESDS),&Att_UL2.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); break; case Bluecell_Table_ATT_UL3: Bluecell_DataCopy(&Att_UL3.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL2_TABLE_ADDRESDS),&Att_UL3.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); break; case Bluecell_Table_ATT_UL4: Bluecell_DataCopy(&Att_UL4.Table_0_0_dBm_H,&data[BLUECELL_DATA + 1],sizeof(ATT_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL3_TABLE_ADDRESDS),&Att_UL4.Table_0_0_dBm_H,sizeof(ATT_TABLE_st)); break; case Bluecell_Table_DET_DL1: Bluecell_DataCopy(&Det_DL1.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_ATT_UL4_TABLE_ADDRESDS),&Det_DL1.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); break; case Bluecell_Table_DET_DL2: Bluecell_DataCopy(&Det_DL2.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL1_TABLE_ADDRESDS),&Det_DL2.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); break; case Bluecell_Table_DET_DL3: Bluecell_DataCopy(&Det_DL3.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL2_TABLE_ADDRESDS),&Det_DL3.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); case Bluecell_Table_DET_DL4: Bluecell_DataCopy(&Det_DL4.Table_Det5_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEDL_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL3_TABLE_ADDRESDS),&Det_DL4.Table_Det5_dBm_H,sizeof(DET_TABLEDL_st)); break; case Bluecell_Table_DET_UL1: Bluecell_DataCopy(&Det_UL1.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_DL4_TABLE_ADDRESDS),&Det_UL1.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); break; case Bluecell_Table_DET_UL2: Bluecell_DataCopy(&Det_UL2.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL1_TABLE_ADDRESDS),&Det_UL2.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); break; case Bluecell_Table_DET_UL3: Bluecell_DataCopy(&Det_UL3.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL2_TABLE_ADDRESDS),&Det_UL3.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); break; case Bluecell_Table_DET_UL4: Bluecell_DataCopy(&Det_UL4.Table_Det_15_dBm_H,&data[BLUECELL_DATA + 1],sizeof(DET_TABLEUL_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL3_TABLE_ADDRESDS),&Det_UL4.Table_Det_15_dBm_H,sizeof(DET_TABLEUL_st)); break; case Bluecell_Table_TEMP_DL1: Bluecell_DataCopy(&Temp_DL1.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_DET_UL4_TABLE_ADDRESDS),&Temp_DL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); break; case Bluecell_Table_TEMP_DL2: Bluecell_DataCopy(&Temp_DL2.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL1_TABLE_ADDRESDS),&Temp_DL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); break; case Bluecell_Table_TEMP_DL3: Bluecell_DataCopy(&Temp_DL3.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&Temp_DL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); break; case Bluecell_Table_TEMP_DL4: Bluecell_DataCopy(&Temp_DL4.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL3_TABLE_ADDRESDS),&Temp_DL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); break; case Bluecell_Table_TEMP_UL1: Bluecell_DataCopy(&Temp_UL1.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); Bluecell_structprintf(&Temp_UL1.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); break; case Bluecell_Table_TEMP_UL2: Bluecell_DataCopy(&Temp_UL2.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL1_TABLE_ADDRESDS),&Temp_UL2.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); break; case Bluecell_Table_TEMP_UL3: Bluecell_DataCopy(&Temp_UL3.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL2_TABLE_ADDRESDS),&Temp_UL3.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); break; case Bluecell_Table_TEMP_UL4: Bluecell_DataCopy(&Temp_UL4.Table_10_Temp_H,&data[BLUECELL_DATA + 1],sizeof(TEMP_TABLE_st)); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL3_TABLE_ADDRESDS),&Temp_UL4.Table_10_Temp_H,sizeof(TEMP_TABLE_st)); break; } } uint8_t Txdata[512]; bool Bluecell_Operate(uint8_t* data){ uint8_t datatype = data[BLUECELL_TYPE]; uint16_t tmp_h = 0,tmp_l = 0; double ret = 0 ,tmp = 0.1; uint8_t val = 0; uint8_t i = 0; switch(datatype){ case ATTSET : // printf("Function : %s Line %d \r\n",__func__,__LINE__); bluecell_Currdatastatus.ATT_DL1_H = data[BLUECELL_DATA + i++]; // printf("bluecell_Currdatastatus.ATT_DL1_H : %x\r\n",bluecell_Currdatastatus.ATT_DL1_H); // printf("bluecell_Currdatastatus.ATT_DL1_L : %x\r\n",bluecell_Currdatastatus.ATT_DL1_L); bluecell_Currdatastatus.ATT_DL1_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_DL2_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_DL2_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_DL3_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_DL3_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_DL4_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_DL4_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL1_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL1_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL2_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL2_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL3_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL3_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL4_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_UL4_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_AGC1_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_AGC1_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_AGC2_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_AGC2_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_AGC3_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_AGC3_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_AGC4_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_AGC4_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_ALC1_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_ALC1_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_ALC2_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_ALC2_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_ALC3_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_ALC3_L = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_ALC4_H = data[BLUECELL_DATA + i++]; bluecell_Currdatastatus.ATT_ALC4_L = data[BLUECELL_DATA + i++]; // printf("bluecell_Currdatastatus.ATT_ALC4_H : %x \r\nbluecell_Currdatastatus.ATT_ALC4_L : %x\r\n", //bluecell_Currdatastatus.ATT_ALC4_H,bluecell_Currdatastatus.ATT_ALC4_L); // memcpy(&bluecell_Currdatastatus.ATT_DL1_H,&data[BLUECELL_DATA],32); // bluecell_Currdatastatus.ATT_DL1_H = data[BLUECELL_DATA + i++]; // bluecell_Currdatastatus.ATT_DL1_L = data[BLUECELL_DATA + 1]; /* Atten Ctrl Function */ CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); // printf("ret : %f ,tmp %f \r\n",ret,tmp ); break; case ATT_DL1_PATH : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,GPIO_PIN_RESET);//CLOCK // printf("ATT_DL1_PATH OFF\r\n"); } else{ HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,GPIO_PIN_SET);//CLOCK // printf("ATT_DL1_PATH ON\r\n"); } break; case ATT_UL1_PATH : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_UL1_GPIO_Port,PATH_EN_UL1_Pin,GPIO_PIN_RESET);//CLOCK } else{ HAL_GPIO_WritePin(PATH_EN_UL1_GPIO_Port,PATH_EN_UL1_Pin,GPIO_PIN_SET);//CLOCK } // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case ATT_SelfTest1 : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(_PATH_SW1_GPIO_Port,_PATH_SW1_Pin,GPIO_PIN_RESET);//CLOCK HAL_GPIO_WritePin(PATH_SW1_GPIO_Port,PATH_SW1_Pin,GPIO_PIN_SET);//CLOCK } else{ HAL_GPIO_WritePin(_PATH_SW1_GPIO_Port,_PATH_SW1_Pin,GPIO_PIN_SET);//CLOCK HAL_GPIO_WritePin(PATH_SW1_GPIO_Port,PATH_SW1_Pin,GPIO_PIN_RESET);//CLOCK } // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case ATT_DL2_PATH : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,GPIO_PIN_RESET);//CLOCK } else{ HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,GPIO_PIN_SET);//CLOCK } // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; break; case ATT_UL2_PATH : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_UL2_GPIO_Port,PATH_EN_UL2_Pin,GPIO_PIN_RESET);//CLOCK } else{ HAL_GPIO_WritePin(PATH_EN_UL2_GPIO_Port,PATH_EN_UL2_Pin,GPIO_PIN_SET);//CLOCK } break; case ATT_SelfTest2 : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(_PATH_SW2_GPIO_Port,_PATH_SW2_Pin,GPIO_PIN_RESET);//CLOCK HAL_GPIO_WritePin(PATH_SW2_GPIO_Port,PATH_SW2_Pin,GPIO_PIN_SET);//CLOCK }else{ HAL_GPIO_WritePin(PATH_SW2_GPIO_Port,PATH_SW2_Pin,GPIO_PIN_RESET);//CLOCK HAL_GPIO_WritePin(_PATH_SW2_GPIO_Port,_PATH_SW2_Pin,GPIO_PIN_SET);//CLOCK } // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case ATT_DL3_PATH : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_RESET);//CLOCK } else{ HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,GPIO_PIN_SET);//CLOCK } // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case ATT_UL3_PATH : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin,GPIO_PIN_RESET);//CLOCK } else{ HAL_GPIO_WritePin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin,GPIO_PIN_SET);//CLOCK } // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case ATT_SelfTest3 : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(_PATH_SW3_GPIO_Port,_PATH_SW3_Pin,GPIO_PIN_RESET);//CLOCK HAL_GPIO_WritePin(PATH_SW3_GPIO_Port,PATH_SW3_Pin,GPIO_PIN_SET);//CLOCK } else{ HAL_GPIO_WritePin(PATH_SW3_GPIO_Port,PATH_SW3_Pin,GPIO_PIN_RESET);//CLOCK HAL_GPIO_WritePin(_PATH_SW3_GPIO_Port,_PATH_SW3_Pin,GPIO_PIN_SET);//CLOCK } // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case ATT_DL4_PATH : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,GPIO_PIN_RESET);//CLOCK }else{ HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,GPIO_PIN_SET);//CLOCK } // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case ATT_UL4_PATH: if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin,GPIO_PIN_RESET);//CLOCK } else{ HAL_GPIO_WritePin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin,GPIO_PIN_SET);//CLOCK } // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case ATT_SelfTest4 : if(data[BLUECELL_DATA]==0){ HAL_GPIO_WritePin(_PATH_SW4_GPIO_Port,_PATH_SW4_Pin,GPIO_PIN_RESET);//CLOCK HAL_GPIO_WritePin(PATH_SW4_GPIO_Port,PATH_SW4_Pin,GPIO_PIN_SET);//CLOCK }else{ HAL_GPIO_WritePin(_PATH_SW4_GPIO_Port,_PATH_SW4_Pin,GPIO_PIN_SET);//CLOCK HAL_GPIO_WritePin(PATH_SW4_GPIO_Port,PATH_SW4_Pin,GPIO_PIN_RESET);//CLOCK } // printf("Function : %s Line %d \r\n",__func__,__LINE__); break; case ALC1_EN : if(data[BLUECELL_DATA]==0){ bluecell_Currdatastatus.ATT_ALC1_ONOFF = false; } else{ bluecell_Currdatastatus.ATT_ALC1_ONOFF = true; } break; case ALC2_EN : if(data[BLUECELL_DATA]==0){ bluecell_Currdatastatus.ATT_ALC2_ONOFF = false; } else{ bluecell_Currdatastatus.ATT_ALC2_ONOFF = true; } break; case ALC3_EN : if(data[BLUECELL_DATA]==0){ bluecell_Currdatastatus.ATT_ALC3_ONOFF = false; } else{ bluecell_Currdatastatus.ATT_ALC3_ONOFF = true; } break; case ALC4_EN : if(data[BLUECELL_DATA]==0){ bluecell_Currdatastatus.ATT_ALC4_ONOFF = false; } else{ bluecell_Currdatastatus.ATT_ALC4_ONOFF = true; } break; case AGC1_EN : if(data[BLUECELL_DATA]==0){ bluecell_Currdatastatus.ATT_AGC1_ONOFF = false; } else{ bluecell_Currdatastatus.ATT_AGC1_ONOFF = true; } break; case AGC2_EN : if(data[BLUECELL_DATA]==0){ bluecell_Currdatastatus.ATT_AGC2_ONOFF = false; } else{ bluecell_Currdatastatus.ATT_AGC2_ONOFF = true; } break; case AGC3_EN : if(data[BLUECELL_DATA]==0){ bluecell_Currdatastatus.ATT_AGC3_ONOFF = false; } else{ bluecell_Currdatastatus.ATT_AGC3_ONOFF = true; } break; case AGC4_EN : if(data[BLUECELL_DATA]==0){ bluecell_Currdatastatus.ATT_AGC4_ONOFF = false; } else{ bluecell_Currdatastatus.ATT_AGC4_ONOFF = true; } break; case ATT_TableSet: Bluecell_TableSave(data); break; case ATT_TableGet: Bluecell_TableLoad(data); data[data[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]); Bluecell_StructCpy(&Txdata[0],&data[0],data[BLUECELL_LENGTH] + 3); Uart1_Data_Send(&Txdata[0], Txdata[BLUECELL_LENGTH] + 3); #if 0 // PYJ.2020.04.22_BEGIN -- for(int i = 0 ; i < data[BLUECELL_LENGTH] + 3; i++ ){ // printf("%x ",data[i]); } printf("\r\n"); #endif // PYJ.2020.04.22_END -- // printf("\r\nuint8_t data : %x data[BLUECELL_LENGTH] + 6 : %d\r\n",data[0],data[BLUECELL_LENGTH] + 6); break; case Bluecell_StatusReq: DataStatusSet(); Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st)); Txdata[Txdata[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]); #if 0 // PYJ.2020.04.22_BEGIN -- for(int i = 0 ; i < Txdata[BLUECELL_LENGTH] + 3; i++ ){ printf("%x ",Txdata[i]); } printf("\r\n"); #endif // PYJ.2020.04.22_END -- Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st)); break; case Bluecell_StatusSave: // printf("Copy Complete"); EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_UL4_TABLE_ADDRESDS),&DataWrite[0],sizeof(BLUESTATUS_st)); Bluecell_StructCpy(&Txdata[0],&DataWrite[0],sizeof(BLUESTATUS_st)); Txdata[Txdata[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]); Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st)); break; } return true; } void DataStatusSet(void){ bluecell_Currdatastatus.bluecell_header = 0xbe; bluecell_Currdatastatus.bluecell_type = Bluecell_StatusReq; bluecell_Currdatastatus.bluecell_length = sizeof(bluecell_Currdatastatus) - 3; bluecell_Currdatastatus.bluecell_crcindex = sizeof(bluecell_Currdatastatus) - 2 + 1; bluecell_Currdatastatus.Selftest0 = HAL_GPIO_ReadPin(_PATH_SW1_GPIO_Port,_PATH_SW1_Pin); bluecell_Currdatastatus.Selftest1 = HAL_GPIO_ReadPin(_PATH_SW2_GPIO_Port,_PATH_SW2_Pin); bluecell_Currdatastatus.Selftest2 = HAL_GPIO_ReadPin(_PATH_SW3_GPIO_Port,_PATH_SW3_Pin); bluecell_Currdatastatus.Selftest3 = HAL_GPIO_ReadPin(_PATH_SW4_GPIO_Port,_PATH_SW4_Pin); bluecell_Currdatastatus.ATT_DL1_PATH = HAL_GPIO_ReadPin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin);//CLOCK; bluecell_Currdatastatus.ATT_DL2_PATH = HAL_GPIO_ReadPin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin);//CLOCK; bluecell_Currdatastatus.ATT_DL3_PATH = HAL_GPIO_ReadPin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin);//CLOCK; bluecell_Currdatastatus.ATT_DL4_PATH = HAL_GPIO_ReadPin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin);//CLOCK; bluecell_Currdatastatus.ATT_UL1_PATH = HAL_GPIO_ReadPin(PATH_EN_UL1_GPIO_Port,PATH_EN_UL1_Pin);//CLOCK; bluecell_Currdatastatus.ATT_UL2_PATH = HAL_GPIO_ReadPin(PATH_EN_UL2_GPIO_Port,PATH_EN_UL2_Pin);//CLOCK; bluecell_Currdatastatus.ATT_UL3_PATH = HAL_GPIO_ReadPin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin);//CLOCK; bluecell_Currdatastatus.ATT_UL4_PATH = HAL_GPIO_ReadPin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin);//CLOCK; bluecell_Currdatastatus.bluecell_etx = 0xeb; /*bluecell_Currdatastatus.ATT_AGC1_ONOFF; bluecell_Currdatastatus.ATT_ALC1_ONOFF; bluecell_Currdatastatus.ATT_AGC2_ONOFF; bluecell_Currdatastatus.ATT_ALC2_ONOFF; bluecell_Currdatastatus.ATT_AGC3_ONOFF; bluecell_Currdatastatus.ATT_ALC3_ONOFF; bluecell_Currdatastatus.ATT_AGC4_ONOFF; bluecell_Currdatastatus.ATT_ALC4_ONOFF; bluecell_Currdatastatus.ATT_AGC1_H; bluecell_Currdatastatus.ATT_AGC1_L; bluecell_Currdatastatus.ATT_ALC1_H; bluecell_Currdatastatus.ATT_ALC1_L; bluecell_Currdatastatus.ATT_AGC2_H; bluecell_Currdatastatus.ATT_AGC2_L; bluecell_Currdatastatus.ATT_ALC2_H; bluecell_Currdatastatus.ATT_ALC2_L; bluecell_Currdatastatus.ATT_AGC3_H; bluecell_Currdatastatus.ATT_AGC3_L; bluecell_Currdatastatus.ATT_ALC3_H; bluecell_Currdatastatus.ATT_ALC3_L; bluecell_Currdatastatus.ATT_AGC4_H; bluecell_Currdatastatus.ATT_AGC4_L; bluecell_Currdatastatus.ATT_ALC4_H; bluecell_Currdatastatus.ATT_ALC4_L; */ } void Bluecell_DataInit(){ HAL_GPIO_WritePin(PATH_SW1_GPIO_Port,_PATH_SW1_Pin,bluecell_Currdatastatus.Selftest0 ); HAL_GPIO_WritePin(_PATH_SW1_GPIO_Port,_PATH_SW1_Pin,bluecell_Currdatastatus.Selftest0 ); HAL_GPIO_WritePin(PATH_SW2_GPIO_Port,_PATH_SW2_Pin,bluecell_Currdatastatus.Selftest1 ); HAL_GPIO_WritePin(_PATH_SW2_GPIO_Port,_PATH_SW2_Pin,bluecell_Currdatastatus.Selftest1 ); HAL_GPIO_WritePin(PATH_SW3_GPIO_Port,_PATH_SW3_Pin,bluecell_Currdatastatus.Selftest2 ); HAL_GPIO_WritePin(_PATH_SW3_GPIO_Port,_PATH_SW3_Pin,bluecell_Currdatastatus.Selftest2 ); HAL_GPIO_WritePin(PATH_SW4_GPIO_Port,_PATH_SW4_Pin,bluecell_Currdatastatus.Selftest3 ); HAL_GPIO_WritePin(_PATH_SW4_GPIO_Port,_PATH_SW4_Pin,bluecell_Currdatastatus.Selftest3 ); HAL_GPIO_WritePin(PATH_EN_DL1_GPIO_Port,PATH_EN_DL1_Pin,bluecell_Currdatastatus.ATT_DL1_PATH); HAL_GPIO_WritePin(PATH_EN_DL2_GPIO_Port,PATH_EN_DL2_Pin,bluecell_Currdatastatus.ATT_DL2_PATH); HAL_GPIO_WritePin(PATH_EN_DL3_GPIO_Port,PATH_EN_DL3_Pin,bluecell_Currdatastatus.ATT_DL3_PATH); HAL_GPIO_WritePin(PATH_EN_DL4_GPIO_Port,PATH_EN_DL4_Pin,bluecell_Currdatastatus.ATT_DL4_PATH); HAL_GPIO_WritePin(PATH_EN_UL1_GPIO_Port,PATH_EN_UL1_Pin,bluecell_Currdatastatus.ATT_UL1_PATH); HAL_GPIO_WritePin(PATH_EN_UL2_GPIO_Port,PATH_EN_UL2_Pin,bluecell_Currdatastatus.ATT_UL2_PATH); HAL_GPIO_WritePin(PATH_EN_UL3_GPIO_Port,PATH_EN_UL3_Pin,bluecell_Currdatastatus.ATT_UL3_PATH); HAL_GPIO_WritePin(PATH_EN_UL4_GPIO_Port,PATH_EN_UL4_Pin,bluecell_Currdatastatus.ATT_UL4_PATH); CompareAttenData(bluecell_Currdatastatus,bluecell_Prevdatastatus); DataStatusSet(); Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st)); Txdata[Txdata[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]); Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st)); } bool MBIC_Operate(uint8_t* data){ uint16_t datatype = 0; switch(datatype){ case Alarm_Bit_List: Uart1_Data_Send(&Alarm_Status[0],MAX_ALARM_Len); break; case Alarm_Mask: break; case Alarm_Test_Mode: break; case Alarm_Test_Dummy: break; case CPU_Version: break; case ModuleINFORMATION_null1: break; case CPU_Current_Bank: break; case CPU_Bank_Select_Reboot_by: break; case CPU_Bank1_Image_Version: break; case CPU_Bank1_Image_BuildTime: break; case CPU_Bank1_Image_Name: break; case CPU_Bank2_Image_Version: break; case CPU_Bank2_Image_BuildTime: break; case CPU_Bank2_Image_Name: break; case SW_Reset: break; case Factory_Set_Initialization: break; case Temperature: break; case Temperature_Offset: break; case Temp_High_Threshold: break; case Temp_High_Threshold_Default: break; case Temp_High_Alarm: break; case LED_TEST: break; case Node: break; case Type: break; case PCB_Version: break; case Serial_Number: break; case Manufacture: break; case Manufacture_Date: break; case ENVIRONMENT_INVENTORY_null1: // printf("Function : %s .... Line : %d\r\n",__func__,__LINE__); break; case Freq_ID: break; case Carrier_ID: break; case Carrier_ON_OFF: break; } return true; } extern volatile uint32_t ADC1_Average_value[4]; extern volatile uint32_t ADC3_Average_value[5]; uint16_t ADC1Ret[4]; uint16_t ADC3Ret[5]; void ADC_Check(void){ static uint8_t Cnt = 0; double Volt_Calc_val = 3.3 / 4095; double ret = 0; // if(AdcTimerCnt > 10){ if(adc3cnt >= 100){ for(int i = 0; i < 5; i++){ ADC3Ret[i] = ADC3_Average_value[i] / adc3cnt; ADC3_Average_value[i] = 0; // printf("ADC3value[%d] : %d UL4 : %f\r\n",i,ADC3value[i],ret * Volt_Calc_val); } adc3cnt = 0; bluecell_Currdatastatus.DET_DL1_IN_H = ((ADC3Ret[1] & 0xFF00) >> 8); bluecell_Currdatastatus.DET_DL1_IN_L = ((ADC3Ret[1] & 0x00FF)); bluecell_Currdatastatus.DET_DL2_IN_H = ((ADC3Ret[2] & 0xFF00) >> 8); bluecell_Currdatastatus.DET_DL2_IN_L = ((ADC3Ret[2] & 0x00FF) ); bluecell_Currdatastatus.DET_DL3_IN_H = ((ADC3Ret[3] & 0xFF00) >> 8); bluecell_Currdatastatus.DET_DL3_IN_L = ((ADC3Ret[3] & 0x00FF) ); bluecell_Currdatastatus.DET_DL4_IN_H = ((ADC3Ret[4] & 0xFF00) >> 8); bluecell_Currdatastatus.DET_DL4_IN_L = ((ADC3Ret[4] & 0x00FF) ); bluecell_Currdatastatus.DET_UL4_IN_H = ((ADC3Ret[0] & 0xFF00) >> 8); bluecell_Currdatastatus.DET_UL4_IN_L = ((ADC3Ret[0] & 0x00FF) ); #if 0 // PYJ.2020.04.26_BEGIN -- ret = (ADC3Ret[0]) * Volt_Calc_val; printf("ADC3Ret[0] : %d UL4 : %f\r\n",ADC3Ret[0],ret); ret = (ADC3Ret[1]) * Volt_Calc_val; printf("ADC3Ret[1] : %d DL1 : %f\r\n",ADC3Ret[1],ret); ret = (ADC3Ret[2]) * Volt_Calc_val; printf("ADC3Ret[2] : %d DL2 : %f\r\n",ADC3Ret[2],ret); ret = (ADC3Ret[3]) * Volt_Calc_val; printf("ADC3Ret[3] : %d DL3 : %f\r\n",ADC3Ret[3],ret); ret = (ADC3Ret[4]) * Volt_Calc_val; printf("ADC3Ret[4] : %d DL4 : %f\r\n",ADC3Ret[4],ret); #endif // PYJ.2020.04.26_END -- } if(adc1cnt >= 100){ for(int i = 0; i < 4; i++){ ADC1Ret[i] = ADC1_Average_value[i] / adc1cnt; ADC1_Average_value[i] = 0; } adc1cnt = 0; bluecell_Currdatastatus.DET_UL1_IN_H = ((ADC1Ret[0] & 0xFF00) >> 8); bluecell_Currdatastatus.DET_UL1_IN_L = ((ADC1Ret[0] & 0x00FF) ); bluecell_Currdatastatus.DET_UL2_IN_H = ((ADC1Ret[1] & 0xFF00) >> 8); bluecell_Currdatastatus.DET_UL2_IN_L = ((ADC1Ret[1] & 0x00FF) ); bluecell_Currdatastatus.DET_UL3_IN_H = ((ADC1Ret[2] & 0xFF00) >> 8); bluecell_Currdatastatus.DET_UL3_IN_L = ((ADC1Ret[2] & 0x00FF) ); bluecell_Currdatastatus.DET_TEMP_H =((ADC1Ret[3] & 0xFF00) >> 8); bluecell_Currdatastatus.DET_TEMP_L =((ADC1Ret[3] & 0x00FF) ); #if 0 // PYJ.2020.04.26_BEGIN -- ret = (ADC1Ret[0]) * Volt_Calc_val; printf("ADC1Ret[0] : %d UL1 : %f\r\n",ADC1Ret[0],ret); ret = (ADC1Ret[1]) * Volt_Calc_val; printf("ADC1Ret[1] : %d UL2 : %f\r\n",ADC1Ret[1],ret); ret = (ADC1Ret[2]) * Volt_Calc_val; printf("ADC1Ret[2] : %d UL3 : %f\r\n",ADC1Ret[2],ret); ret = (ADC1Ret[3]) * Volt_Calc_val; printf("ADC1Ret[3] : %d TEMP : %f\r\n",ADC1Ret[3],ret); #endif // PYJ.2020.04.26_END -- } #if 0 // PYJ.2020.04.22_BEGIN -- if(Cnt >= 250){ ret = (ADC3value[0]) * Volt_Calc_val; printf("UL4 : %f\r\n",ret); ret = (ADC3value[1]) * Volt_Calc_val; printf("DL1 : %f\r\n",ret); ret = (ADC3value[2]) * Volt_Calc_val; printf("DL2 : %f\r\n",ret); ret = (ADC3value[3]) * Volt_Calc_val; printf("DL3 : %f\r\n",ret); ret = (ADC3value[4]) * Volt_Calc_val; printf("DL4 : %f\r\n",ret); ret = ((ADC1value[0]) * Volt_Calc_val); printf("UL1 : %f\r\n",ret); ret = ((ADC1value[1]) * Volt_Calc_val); printf("UL2 : %f\r\n",ret); ret = ((ADC1value[2]) * Volt_Calc_val); printf("UL3 : %f\r\n",ret); Cnt = 0; }else{ Cnt++; } #else #if 0 // PYJ.2020.04.22_BEGIN -- if(Cnt >= 250){ ret = (ADC3value[0]); printf("UL4 : %x\r\n",ret); ret = (ADC3value[1]); printf("DL1 : %x\r\n",ret); ret = (ADC3value[2]); printf("DL2 : %x\r\n",ret); ret = (ADC3value[3]); printf("DL3 : %x\r\n",ret); ret = (ADC3value[4]); printf("DL4 : %x\r\n",ret); ret = ((ADC1value[0])); printf("UL1 : %x\r\n",ret); ret = ((ADC1value[1])); printf("UL2 : %x\r\n",ret); ret = ((ADC1value[2])); printf("UL3 : %\r\n",ret); Cnt = 0; }else{ Cnt++; } #endif // PYJ.2020.04.22_END -- #endif // PYJ.2020.04.22_END -- }