#include #include #include #include #include #include #include "rtc.h" #include "SysTick.h" #include "usart_nrf.h" #include "usart_nrf3.h" #include "usart_nrfConfig.h" #include "Memory.h" #include #include "malloc.h" #include "crc16.h" //dong 2020-0515 vu8 RecieveDataCnt = 0; vu8 AppPollCnt = 0; //Alarm serial number vu16 WarnSerNub[PORT_LEN]; vu16 DataAarnNub = 0; //The self-check status flag bit 0 is the default value, 1 is the self-check status in the rotation training, 2 is the self-check status, the rotation training is completed, and 3 is the status of preparing for packaging and reply. vu8 SelfCheckStateFlg = 0; SelfCheckParaType SelfCheckPara = {0}; // extern vu8 APP_Flg ; //u8 *pProBuffer = NULL; u8 pProBuffer[1500]; //Real-time alarm package volatile AlarmDataType pRealAlarm[20]; //Pending alarm volatile AlarmDataType pInformAlarm[20]; volatile AlarmStateType CurAlarmState = InitState; //Control type volatile bool CurSendRecHasSupplyAgain = false; vu8 TotalPackageNum = 0; // APP network command volatile App_DataPollState AppState; vu8 CurRecSendLostPackageNO = 0; //Multiple billing vu8 CurSendRecLostPackageNO = 0; vu8 CurSendRecLastPackageNO = 0; vu8 SubData3[MAX_TRANS_DAT_DATA_LEN]; vu8 CurRecSendPackageDataType = InitDataState; vu8 RealAlarmDataNO = 0; vu8 InformAlarmDataNO = 0; vu8 CurRowTotalLen = 0; vu8 TotalIndex_Para = 0; vu8 Index_Para = 0; //dong 2020-05-21 The serial number of the pending alarm has not been uploaded, the serial number of the alarm shall prevail //vu16 CurRealAlarmNum = 0; //vu16 CurInformAlarmNum = 0; //Alarm multi-plane mechanism vu8 AlarmTwoPack = 0; vu16 PortNO_App = 0; vu16 PortNO_Alarm_Server = 0; vu32 LineCnt_Pro = 0; vu32 NeedLostPackageState = 0; vu32 LocalTime_TaskTimeOut = 0; vu32 CurRecSendLostPackageState = 0; vu32 LocalTime_InformAlarmTimeOut = 0; ProtocalLayerType ProtocalLayer_Poll; ProtocalLayerType ProtocalLayer_Cmd; volatile bool CurPollIsDebugDataTime = true; //bool LockFlag = false; DataCntType *pDataCnt = NULL; //char TempRowData[] = //{ // 0x01, 0x22, 0x20, 0x02, 0x00, 0x00, 0x09, 0x60, 0x08, 0x40, 0x00, 0xD2, 0x0A, 0x50, 0x00, 0x82, // 0x10, 0x00, 0x17, 0x70, 0x16, 0xda, 0x0b, 0xb8, 0x17, 0xa2, 0x0b, 0xb8, 0x30, 0x00, 0x00, 0x96, // 0x40, 0x00, 0x07, 0xd0, 0x00, 0xc8, 0xb1, 0x12 //}; /********************************************** ** Function name: ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ bool FilterTotalEnergy(uint8_t u8min, uint8_t u8max, uint16_t PortNODebug) { uint16_t i; int32_t TotalEnergyDiffTemp[2] = {0}; TotalEnergyDiffTemp[0] = ((((uint32_t)MIReal[PortNODebug].Data.HistoryEnergyH) << 16) | ((uint32_t)MIReal[PortNODebug].Data.HistoryEnergyL)); TotalEnergyDiffTemp[1] = (((uint32_t)(pProBuffer[u8min] << 8 | pProBuffer[u8min + 1]) << 16) | ((uint32_t)(pProBuffer[u8max - 1] << 8 | pProBuffer[u8max]))); if((abs(TotalEnergyDiffTemp[1] - TotalEnergyDiffTemp[0])) > PV_ONE_DAY_TOTAL_ENERGY) { MIReal[PortNODebug].Data.LinkState = (MIReal[PortNODebug].Data.LinkState & MI_DISCONNECT) | MI_TOTAL_ENERGY_FAULT; MIReal[PortNODebug].Data.HistoryEnergyH = (uint32_t)pProBuffer[u8min] << 8 | pProBuffer[u8min + 1]; MIReal[PortNODebug].Data.HistoryEnergyL = (uint32_t)pProBuffer[u8max - 1] << 8 | pProBuffer[u8max]; #ifdef DEBUG_ZHOULEI printf("error code3:");//Excessive power generation printf("HistoryEnergyHL:%x", ((((uint32_t)MIReal[PortNODebug].Data.HistoryEnergyH) << 16) | ((uint32_t)MIReal[PortNODebug].Data.HistoryEnergyL))); printf("\n"); for(i = 0; i < 50; i++) { if(pProBuffer[i] <= 0x0f) { printf("0"); printf("%x", pProBuffer[i]); printf(" "); } else { printf("%x", pProBuffer[i]); printf(" "); } } printf("\n"); #endif return false; } else { MIReal[PortNODebug].Data.LinkState = MIReal[PortNODebug].Data.LinkState & MI_TOTAL_ENERGY_FAULTCLEAR; return true; } return true; } /*********************************************** ** Function name: Third-generation protocol Qingwei inverse software version ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_ClearMIVersion(void) { memset((u16 *) & (MIDetail.Property.USFWBuild_VER), 0, 2); memset((u16 *) & (MIDetail.Property.AppFWBuild_VER), 0, 2); // Application version memset((u16 *) & (MIDetail.Property.AppFWBuild_YYYY), 0, 2); memset((u16 *) & (MIDetail.Property.AppFWBuild_MMDD), 0, 2); memset((u16 *) & (MIDetail.Property.AppFWBuild_HHMM), 0, 2); memset((u16 *) & (MIDetail.Property.AppFW_PNH), 0, 2); memset((u16 *) & (MIDetail.Property.AppFW_PNL), 0, 2); memset((u16 *) & (MIDetail.Property.HW_PNL), 0, 4); // Hardware part number memset((u16 *) & (MIDetail.Property.HW_PNH), 0, 4); // Hardware part number memset((u16 *) & (MIDetail.Property.HW_VER), 0, 2); // Hardware version memset((u16 *) & (MIDetail.Property.HW_FB_TLmValue), 0, 2); memset((u16 *) & (MIDetail.Property.HW_FB_ReSPRT), 0, 2); memset((u16 *) & (MIDetail.Property.HW_GridSamp_ResValule), 0, 2); memset((u16 *) & (MIDetail.Property.HW_ECapValue), 0, 2); memset((u16 *) & (MIDetail.Property.GPFCode), 0, 2); // Grid-connected protection file code memset((u16 *) & (MIDetail.Property.GPFVer), 0, 2); // Grid-connected protection file version memset((u16 *) & (MIDetail.Property.ReservedPara), 0, 2); //Reserved parameters memset((u16 *) & (MIDetail.Property.AppFW_MINVER), 0, 2); memset((u16 *) & (MIDetail.Property.HW_CRCValue), 0, 2); memset((u16 *) & (MIDetail.Property.CRC_ALL), 0, 2); } /*********************************************** ** Function name: The third-generation protocol collects the micro-inverse state for 15 minutes to execute the led state ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ //void UsartNrf3_Process_LedShow(bool RealTimeState) //{ // u8 i; // if(RealTimeState == true) // { // Dtu3Detail.Property.LedState = 1;//Incomplete search // } // else // { // if(CurNetCmd == NET_NOPORT) // { // Dtu3Detail.Property.LedState = 0;//Error package // } // else // { // for(i = 0; i < Dtu3Detail.Property.PortNum; i++) // { // if((MIReal[i].Data.LinkState & MI_CONNECT) == 0) // { // Dtu3Detail.Property.LedState = 1;//Incomplete search // break; // } // } // if(i >= Dtu3Detail.Property.PortNum) // { // Dtu3Detail.Property.LedState = 2; //Search all // } // } // } //} /*********************************************** ** Function name: Three-generation protocol single-packet multiple-receiver mechanism ** Descriptions: ** input parameters: accepted data, maximum cache length (multiple packets and packets) ** output parameters: ? ** Returned value: Accept the total length after the return and package are completed, otherwise it will return 0 *************************************************/ u16 UsartNrf3_Process_GetDatatoProBuffer(u8 *pBuffer, u16 BufferSize) { vu16 CurPackageNO; vu16 i; static vu16 TotalDataNum; vu16 TempDataNum = 0; if(CurRecSendLostPackageState == 0) { memset(pProBuffer, 0, (BufferSize * sizeof(u8))); } CurPackageNO = 0x0F & pBuffer[10]; if(CurPackageNO > 0) { CurRecSendLostPackageState = CurRecSendLostPackageState | (1 << (CurPackageNO - 1)); //Which packages are actually charged } else { return 0; } //The 7th bit is 1, indicating the end of the frame if((pBuffer[10] & 0x80) == 0x80) { TotalPackageNum = 0x0f & pBuffer[10]; //Get the total number of packages for(i = 0; i < TotalPackageNum; i++) { NeedLostPackageState = NeedLostPackageState | (1 << i); //Which packages should be collected } for(i = 11; i < (16 + 11 + 2); i++) { //dong 2020-06-17---Encountered that 7F of the end frame data ended early // if((pBuffer[i] == ETX) if((pBuffer[i] == ETX) && (pBuffer[i + 1] == 0) && (pBuffer[i + 2] == 0)) { *(pProBuffer + (16 * (CurPackageNO - 1)) + i - 11) = ETX; break; } else { *(pProBuffer + (16 * (CurPackageNO - 1)) + i - 11) = pBuffer[i]; } } TotalDataNum = TotalDataNum + (i - 11); if(TotalDataNum >= 3) { TotalDataNum = TotalDataNum - 3; } //Error package else { NeedLostPackageState = 0; LocalTime_TaskTimeOut = LocalTime; CurRecSendLostPackageState = 0; TotalPackageNum = 0; CurRecSendPackageDataType = InitDataState; Uart_CurrentReplyState = 0; TotalDataNum = 0; } } //Tundish else { memcpy(pProBuffer + (16 * (CurPackageNO - 1)), &pBuffer[11], 16); TotalDataNum = TotalDataNum + 16; } if(TotalPackageNum > 0) { if((NeedLostPackageState > 0) && (NeedLostPackageState == CurRecSendLostPackageState)) //�Ƿ���ȫ { TempDataNum = TotalDataNum; TotalDataNum = 0; return TempDataNum; } else { CurRecSendLostPackageNO = TotalPackageNum; } } return 0; } /*********************************************** ** Function name: Three-generation protocol transport layer data information crc check ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ bool UsartNrf3_Process_DataCrc(u16 DataNum) { vu16 i; vu16 DatCrc = 0xffff; vu16 TempCrc = 0; NeedLostPackageState = 0; CurRecSendLostPackageState = 0; for(i = 0; i < DataNum; i++) { if(i % 2 == 1) { TempCrc = (u16)((pProBuffer[i - 1] << 8) | (pProBuffer[i])); DatCrc = CalcCRC16t(TempCrc, DatCrc); } } if(DatCrc == (((u16)pProBuffer[DataNum] << 8) | pProBuffer[DataNum + 1])) //crc check { ProtocalLayer_Poll = ToAppLayer; TotalPackageNum = 0; CurRecSendPackageDataType = InitDataState; Uart_CurrentReplyState = 0; if((CurAlarmState != AlarmInforUpdate_App) && (CurNetCmd != NET_MI_VERSION)) { CurNetCmd = NET_INIT; } return true; } else { ProtocalLayer_Poll = ToAppLayer; TotalPackageNum = 0; Uart_CurrentReplyState = 0x01 << 4; // The high four digits indicate the abnormal state of the transport layer receipt return false; } return false; } /*********************************************** ** Function name: Three-generation protocol polling, real-time data, real-time version transmission, application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevRunReality(u8 *pBuffer) { vu16 TempDataNum = 0; vu8 j; TempDataNum = UsartNrf3_Process_GetDatatoProBuffer(pBuffer, 5 * 16); //dong vu8 alarm_nub = 0; if(TempDataNum != 0) { if(UsartNrf3_Process_DataCrc(TempDataNum)) { if(TempDataNum == 4) { UsartNrf3_Process_One_MultiPackage(pBuffer); return; } if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) == Inverter_HM_OneToFour) { // UsartNrf3_Process_LedShow(false); memcpy((u16 *) & (MIReal[PortNO].Data.DataVer[0]), &(pProBuffer[0]), 2); // Data version if(UsartNrf_Process_ExceptionFilter(pProBuffer, 2, 3, 2000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVVol[0]), &(pProBuffer[2]), 2); // PV1 voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 2, 3, 2000, 0) == true)//PV voltage { memcpy((u8 *) & (MIReal[PortNO + 1].Data.PVVol[0]), &(pProBuffer[2]), 2); // PV2 voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 4, 5, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVCur), &(pProBuffer[4]), 2); // PV1 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 6, 7, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 1].Data.PVCur), &(pProBuffer[6]), 2); // PV2 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 8, 9, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVPower[0]), &(pProBuffer[8]), 2); // PV1 power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 10, 11, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 1].Data.PVPower[0]), &(pProBuffer[10]), 2); // PV2 power } else { return; } if(FilterTotalEnergy(12, 15, PortNO) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 12, 15, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[12]) << 8 | pProBuffer[13]); //PV1 Historical cumulative power generation MIReal[PortNO].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[14]) << 8 | pProBuffer[15]); } else { return; } if(FilterTotalEnergy(16, 19, PortNO + 1) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 16, 19, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO + 1].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[16]) << 8 | pProBuffer[17]); //PV2 Historical cumulative power generation MIReal[PortNO + 1].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[18]) << 8 | pProBuffer[19]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 20, 21, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO].Data.DailyEnergy = (u16)(((u16)pProBuffer[20]) << 8 | pProBuffer[21]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 22, 23, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO + 1].Data.DailyEnergy = (u16)(((u16)pProBuffer[22]) << 8 | pProBuffer[23]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 24, 25, 2000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 2].Data.PVVol[0]), &(pProBuffer[24]), 2); // PV3&PV4 voltage memcpy((u8 *) & (MIReal[PortNO + 3].Data.PVVol[0]), &(pProBuffer[24]), 2); // PV3&PV4 voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 26, 27, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 2].Data.PVCur), &(pProBuffer[26]), 2); // PV3 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 28, 29, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 3].Data.PVCur), &(pProBuffer[28]), 2); // PV4 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 30, 31, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 2].Data.PVPower[0]), &(pProBuffer[30]), 2); // PV3 power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 32, 33, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 3].Data.PVPower[0]), &(pProBuffer[32]), 2); // PV4 power } else { return; } if(FilterTotalEnergy(34, 37, PortNO + 2) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 34, 37, (u32)(pow(10, 9)), 0) == true) // { MIReal[PortNO + 2].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[34]) << 8 | pProBuffer[35]); //PV3 Historical cumulative power generation MIReal[PortNO + 2].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[36]) << 8 | pProBuffer[37]); } else { return; } if(FilterTotalEnergy(38, 41, PortNO + 3) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 38, 41, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO + 3].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[38]) << 8 | pProBuffer[39]); //PV4 Historical cumulative power generation MIReal[PortNO + 3].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[40]) << 8 | pProBuffer[41]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 42, 43, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO + 2].Data.DailyEnergy = (u16)(((u16)pProBuffer[42]) << 8 | pProBuffer[43]); //PV3 daily power generation } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 44, 45, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO + 3].Data.DailyEnergy = (u16)(((u16)pProBuffer[44]) << 8 | pProBuffer[45]); //PV4 daily power generation } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 46, 47, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridVol[0]), &(pProBuffer[46]), 2); // AC voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 48, 49, 20000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.Freque[0]), &(pProBuffer[48]), 2); // AC frequency } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 50, 51, 40000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridActivePower[0]), &(pProBuffer[50]), 2); // AC active power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 52, 53, 40000, -40000) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridReactivePower[0]), &(pProBuffer[52]), 2); // Reactive power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 54, 55, 2000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridCurrent[0]), &(pProBuffer[54]), 2); // AC current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 56, 57, 1000, -1000) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PowerFactor[0]), &(pProBuffer[56]), 2); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 58, 59, 2000, -1000) == true) //temperature { memcpy((u8 *) & (MIReal[PortNO].Data.Temper[0]), &(pProBuffer[58]), 2); } else { return; } for(j = 0; j < 4; j++) { MIReal[PortNO + j].Data.LinkState = MIReal[PortNO + j].Data.LinkState | MI_CONNECT; } // if((APP_Flg != 1) && (((((u16)pProBuffer[60] << 8) | pProBuffer[61]) & 0x01) == 1)) //dong 0528 If the alarm serial number in the data frame is greater than the temporarily stored alarm serial number, there is an alarm DataAarnNub = (((u16)pProBuffer[60] << 8) | pProBuffer[61]); if((APP_Flg != 1) && (DataAarnNub > WarnSerNub[PortNO])) { //If the total is greater than 20, store the alarms in the alarm pool first if(RealAlarmDataNO + DataAarnNub - WarnSerNub[PortNO] >= 20) { #ifdef DEBUG0619 printf("485-Alarm_Data_Write:%d", RealAlarmDataNO); #endif Alarm_Data_Write(0, 1, (AlarmDataType *)pRealAlarm, RealAlarmDataNO); RealAlarmDataNO = 0; memset((AlarmDataType *)pRealAlarm, 0, sizeof(AlarmDataType) * 20); //If the number of alarms for a single micro-inverse is greater than 20, subcontracting processing is required if(DataAarnNub - WarnSerNub[PortNO] > 20) { AlarmTwoPack = 1; } } CurAlarmState = HasNewAlarmRecord; } } else if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) == Inverter_HM_OneToTwo) { // UsartNrf3_Process_LedShow(false); memcpy((u16 *) & (MIReal[PortNO].Data.DataVer[0]), &(pProBuffer[0]), 2); // Data version if(UsartNrf_Process_ExceptionFilter(pProBuffer, 2, 3, 2000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVVol[0]), &(pProBuffer[2]), 2); // PV1 voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 4, 5, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVCur), &(pProBuffer[4]), 2); // PV1 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 6, 7, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVPower[0]), &(pProBuffer[6]), 2); // PV1 power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 8, 9, 2000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 1].Data.PVVol[0]), &(pProBuffer[8]), 2); // PV2 voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 10, 11, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 1].Data.PVCur), &(pProBuffer[10]), 2); // PV2 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 12, 13, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 1].Data.PVPower[0]), &(pProBuffer[12]), 2); // PV2 power } else { return; } //////////////////////////////DEBUG information///////////// //////// if(FilterTotalEnergy(14, 17, PortNO) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 14, 17, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[14]) << 8 | pProBuffer[15]); //PV1 Historical cumulative power generation MIReal[PortNO].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[16]) << 8 | pProBuffer[17]); } else { return; } //////////////////////////////DEBUG information///////////// //////// if(FilterTotalEnergy(18, 21, PortNO + 1) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 18, 21, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO + 1].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[18]) << 8 | pProBuffer[19]); //PV2 Historical cumulative power generation MIReal[PortNO + 1].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[20]) << 8 | pProBuffer[21]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 22, 23, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO].Data.DailyEnergy = (u16)(((u16)pProBuffer[22]) << 8 | pProBuffer[23]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 24, 25, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO + 1].Data.DailyEnergy = (u16)(((u16)pProBuffer[24]) << 8 | pProBuffer[25]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 26, 27, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridVol[0]), &(pProBuffer[26]), 2); // AC voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 28, 29, 20000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.Freque[0]), &(pProBuffer[28]), 2); // AC frequency } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 30, 31, 40000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridActivePower[0]), &(pProBuffer[30]), 2); // AC active power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 32, 33, 40000, -40000) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridReactivePower[0]), &(pProBuffer[32]), 2); // Reactive power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 34, 35, 20000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridCurrent[0]), &(pProBuffer[34]), 2); // AC current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 36, 37, 1000, -1000) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PowerFactor[0]), &(pProBuffer[36]), 2); // Power factor } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 38, 39, 2000, -1000) == true) //temperature { memcpy((u8 *) & (MIReal[PortNO].Data.Temper[0]), &(pProBuffer[38]), 2); } else { return; } for(j = 0; j < 2; j++) { MIReal[PortNO + j].Data.LinkState = MIReal[PortNO + j].Data.LinkState | MI_CONNECT; } //dong 20200529 DataAarnNub = (((u16)pProBuffer[40] << 8) | pProBuffer[41]); if((APP_Flg != 1) && (DataAarnNub > WarnSerNub[PortNO])) { //If the total is greater than 20, store the alarms in the alarm pool first if(RealAlarmDataNO + DataAarnNub - WarnSerNub[PortNO] >= 20) { Alarm_Data_Write(0, 1, (AlarmDataType *)pRealAlarm, RealAlarmDataNO); RealAlarmDataNO = 0; memset((AlarmDataType *)pRealAlarm, 0, sizeof(AlarmDataType) * 20); //If the number of alarms for a single micro-inverse is greater than 20, subcontracting processing is required if(DataAarnNub - WarnSerNub[PortNO] > 20) { AlarmTwoPack = 1; } } CurAlarmState = HasNewAlarmRecord; } } else if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) == Inverter_HM_OneToOne) { MIReal[PortNO].Data.LinkState = MIReal[PortNO].Data.LinkState | MI_CONNECT; // UsartNrf3_Process_LedShow(false); memcpy((u16 *) & (MIReal[PortNO].Data.DataVer[0]), &(pProBuffer[0]), 2); // Data version if(UsartNrf_Process_ExceptionFilter(pProBuffer, 2, 3, 2000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVVol[0]), &(pProBuffer[2]), 2); // PV1 voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 4, 5, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVCur), &(pProBuffer[4]), 2); // PV1 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 6, 7, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVPower[0]), &(pProBuffer[6]), 2); // PV1 power } else { return; } if(FilterTotalEnergy(8, 11, PortNO) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 8, 11, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[8]) << 8 | pProBuffer[9]); //PV1 Historical cumulative power generation MIReal[PortNO].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[10]) << 8 | pProBuffer[11]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 12, 13, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO].Data.DailyEnergy = (u16)(((u16)pProBuffer[12]) << 8 | pProBuffer[13]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 14, 15, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridVol[0]), &(pProBuffer[14]), 2); // AC voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 16, 17, 20000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.Freque[0]), &(pProBuffer[16]), 2); // AC frequency } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 18, 19, 40000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridActivePower[0]), &(pProBuffer[18]), 2); // AC active power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 20, 21, 40000, -40000) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridReactivePower[0]), &(pProBuffer[20]), 2); // Reactive power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 22, 23, 2000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridCurrent[0]), &(pProBuffer[22]), 2); // AC current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 24, 25, 1000, -1000) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PowerFactor[0]), &(pProBuffer[24]), 2); // Power factor } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 26, 27, 2000, -1000) == true) //temperature { memcpy((u8 *) & (MIReal[PortNO].Data.Temper[0]), &(pProBuffer[26]), 2); } else { return; } MIReal[PortNO].Data.LinkState = MIReal[PortNO].Data.LinkState | MI_CONNECT; //dong 20200529 DataAarnNub = (((u16)pProBuffer[28] << 8) | pProBuffer[29]); if((APP_Flg != 1) && (DataAarnNub > WarnSerNub[PortNO])) { //If the total is greater than 20, store the alarms in the alarm pool first if(RealAlarmDataNO + DataAarnNub - WarnSerNub[PortNO] >= 20) { #ifdef DEBUG0619 printf("700-Alarm_Data_Write:%d", RealAlarmDataNO); #endif Alarm_Data_Write(0, 1, (AlarmDataType *)pRealAlarm, RealAlarmDataNO); RealAlarmDataNO = 0; memset((AlarmDataType *)pRealAlarm, 0, sizeof(AlarmDataType) * 20); //If the number of alarms for a single micro-inverse is greater than 20, subcontracting processing is required if(DataAarnNub - WarnSerNub[PortNO] > 20) { AlarmTwoPack = 1; } } CurAlarmState = HasNewAlarmRecord; } } else if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) == Inverter_Pro) { memcpy((u16 *) & (MIReal[PortNO].Data.DataVer[0]), &(pProBuffer[0]), 2); // Data version if(UsartNrf_Process_ExceptionFilter(pProBuffer, 2, 3, 2000, 0) == true) //PV voltage { memcpy((u8 *) & (MIReal[PortNO + 1].Data.PVVol[0]), &(pProBuffer[2]), 2); // PV2 voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 2, 3, 2000, 0) == true) // PV1 voltage { memcpy((u8 *) & (MIReal[PortNO].Data.PVVol[0]), &(pProBuffer[2]), 2); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 4, 5, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVCur), &(pProBuffer[4]), 2); // PV1 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 6, 7, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 1].Data.PVCur), &(pProBuffer[6]), 2); // PV2 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 8, 9, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PVPower[0]), &(pProBuffer[8]), 2); // PV1 power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 10, 11, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 1].Data.PVPower[0]), &(pProBuffer[10]), 2); // PV2 power } else { return; } //////////////////////////////DEBUG information///////////// //////// if(FilterTotalEnergy(12, 15, PortNO) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 12, 15, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[12]) << 8 | pProBuffer[13]); //PV1 Historical cumulative power generation MIReal[PortNO].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[14]) << 8 | pProBuffer[15]); } else { return; } //////////////////////////////DEBUG information///////////// //////// if(FilterTotalEnergy(16, 19, PortNO + 1) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 16, 19, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO + 1].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[16]) << 8 | pProBuffer[17]); //PV2 Historical cumulative power generation MIReal[PortNO + 1].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[18]) << 8 | pProBuffer[19]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 20, 21, 2000, 0) == true) //PV voltage { memcpy((u8 *) & (MIReal[PortNO + 2].Data.PVVol[0]), &(pProBuffer[20]), 2); // PV3&PV4 voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 20, 21, 2000, 0) == true) //PV voltage { memcpy((u8 *) & (MIReal[PortNO + 3].Data.PVVol[0]), &(pProBuffer[20]), 2); // PV3&PV4 voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 22, 23, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 2].Data.PVCur), &(pProBuffer[22]), 2); // PV3 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 24, 25, 2500, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 3].Data.PVCur), &(pProBuffer[24]), 2); // PV4 current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 26, 27, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 2].Data.PVPower[0]), &(pProBuffer[26]), 2); // PV3 power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 28, 29, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO + 3].Data.PVPower[0]), &(pProBuffer[28]), 2); // PV4 power } else { return; } //////////////////////////////DEBUG information///////////// //////// if(FilterTotalEnergy(30, 34, PortNO + 2) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 30, 33, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO + 2].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[30]) << 8 | pProBuffer[31]); //PV3 Historical cumulative power generation MIReal[PortNO + 2].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[32]) << 8 | pProBuffer[33]); } else { return; } //////////////////////////////DEBUG information///////////// //////// if(FilterTotalEnergy(34, 37, PortNO + 3) == false) { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 34, 37, (u32)(pow(10, 9)), 0) == true) { MIReal[PortNO + 3].Data.HistoryEnergyH = (u16)(((u16)pProBuffer[34]) << 8 | pProBuffer[35]); //PV4 Historical cumulative power generation MIReal[PortNO + 3].Data.HistoryEnergyL = (u16)(((u16)pProBuffer[36]) << 8 | pProBuffer[37]); } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 38, 39, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.BusVol[0]), &(pProBuffer[38]), 2); // DC bus voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 40, 41, 10000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridVol[0]), &(pProBuffer[40]), 2); // AC voltage } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 42, 43, 20000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.Freque[0]), &(pProBuffer[42]), 2); // AC frequency } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 44, 45, 40000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridActivePower[0]), &(pProBuffer[44]), 2); // AC active power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 46, 47, 40000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridReactivePower[0]), &(pProBuffer[46]), 2); // Reactive power } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 48, 49, 2000, 0) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.GridCurrent[0]), &(pProBuffer[48]), 2); // AC current } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 50, 51, 100, -100) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.PowerFactor), &(pProBuffer[51]), 2); // Power factor } else { return; } if(UsartNrf_Process_ExceptionFilter(pProBuffer, 52, 53, 2000, -1000) == true) { memcpy((u8 *) & (MIReal[PortNO].Data.Temper[0]), &(pProBuffer[52]), 2); //temperature } else for(j = 0; j < 4; j++) { MIReal[PortNO + j].Data.LinkState = MIReal[PortNO + j].Data.LinkState | MI_CONNECT; } DataAarnNub = (((u16)pProBuffer[54] << 8) | pProBuffer[55]); if((APP_Flg != 1) && (DataAarnNub > WarnSerNub[PortNO])) { //If the total is greater than 20, store the alarms in the alarm pool first if(RealAlarmDataNO + DataAarnNub - WarnSerNub[PortNO] >= 20) { #ifdef DEBUG0619 printf("485-Alarm_Data_Write:%d", RealAlarmDataNO); #endif Alarm_Data_Write(0, 1, (AlarmDataType *)pRealAlarm, RealAlarmDataNO); RealAlarmDataNO = 0; memset((AlarmDataType *)pRealAlarm, 0, sizeof(AlarmDataType) * 20); //If the number of alarms for a single micro-inverse is greater than 20, subcontracting processing is required if(DataAarnNub - WarnSerNub[PortNO] > 20) { AlarmTwoPack = 1; } } CurAlarmState = HasNewAlarmRecord; } } } } } /*********************************************** ** Function name: Three-generation protocol polling debug version, real-time data transmission, application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevRunDebug(u8 *pBuffer) { UsartNrf3_Process_DevRunReality(pBuffer); } /*********************************************** ** Function name: Three-generation protocol polling device information transmission application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevInform_Sample(u8 *pBuffer) { vu16 TempDataNum = 0; TempDataNum = UsartNrf3_Process_GetDatatoProBuffer(pBuffer, 2 * 16); if(TempDataNum != 0) { if(UsartNrf3_Process_DataCrc(TempDataNum)) { if(TempDataNum == 4) { UsartNrf3_Process_One_MultiPackage(pBuffer); return; } InverterDetail_Read((InverterDetail *)&MIDetail, PortNO, 1);//Inverter RF hardware and software version MIDetail.Property.AppFWBuild_VER = (u16)(((u16)pProBuffer[0] << 8) | pProBuffer[1]); // Application version MIDetail.Property.HW_PNH = (u16)(((u16)pProBuffer[2] << 8) | pProBuffer[3]); // Hardware part number MIDetail.Property.HW_PNL = (u16)(((u16)pProBuffer[4] << 8) | pProBuffer[5]); // Hardware part number MIDetail.Property.HW_VER = (u16)(((u16)pProBuffer[6] << 8) | pProBuffer[7]); // Hardware version MIDetail.Property.GPFCode = (u16)(((u16)pProBuffer[8] << 8) | pProBuffer[9]); // Grid-connected protection file code MIDetail.Property.GPFVer = (u16)(((u16)pProBuffer[10] << 8) | pProBuffer[11]); // Grid-connected protection file version MIDetail.Property.ReservedPara = (u16)(((u16)pProBuffer[12] << 8) | pProBuffer[13]); //Reserved parameters InverterDetail_Write((InverterDetail *)&MIDetail, PortNO, 1);//Inverter RF hardware and software version if(MIReal[PortNO].Data.NetStatus == NET_NOT_EXECUTED) { MIReal[PortNO].Data.NetStatus = NET_EXECUTION_COMPLETED; UsartNrf_ClearVersionActionState(); } else { Dtu3Detail.Property.PolledVerState = 2; } } } } /*********************************************** ** Function name: Three-generation protocol polling, detailed version transmission, application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevInform_All(u8 *pBuffer) { vu16 TempDataNum = 0; TempDataNum = UsartNrf3_Process_GetDatatoProBuffer(pBuffer, 2 * 16); if(TempDataNum != 0) { if(UsartNrf3_Process_DataCrc(TempDataNum)) { if(TempDataNum == 4) { UsartNrf3_Process_One_MultiPackage(pBuffer); return; } InverterDetail_Read((InverterDetail *)&MIDetail, PortNO, 1);//Inverter RF hardware and software version // MIDetail.Property.AppFWPN = (u16)(((u16)pProBuffer[0] << 8) | pProBuffer[1]); //Application firmware part number // MIDetail.Property.AppFWBuild_VER = (u16)(((u16)pProBuffer[2] << 8) | pProBuffer[3]); //Application firmware version // MIDetail.Property.AppFWBuild_YYYY = (u16)(((u16)pProBuffer[4] << 8) | pProBuffer[5]); //Application firmware compilation time-year // MIDetail.Property.AppFWBuild_MMDD = (u16)(((u16)pProBuffer[6] << 8) | pProBuffer[7]); //Application firmware compilation time-month. day // MIDetail.Property.AppFWBuild_HHMM = (u16)(((u16)pProBuffer[8] << 8) | pProBuffer[9]); // Application version // MIDetail.Property.USFWBuild_VER = (u16)(((u16)pProBuffer[10] << 8) | pProBuffer[11]); // Hardware part number // MIDetail.Property.HW_PNH = (u16)(((u16)pProBuffer[12] << 8) | pProBuffer[13]); // Hardware part number // MIDetail.Property.AppFW_PNL = (u16)(((u16)pProBuffer[14] << 8) | pProBuffer[15]); // Hardware part number // MIDetail.Property.AppFW_PNL = (u16)(((u16)pProBuffer[16] << 8) | pProBuffer[17]); // Hardware part number // MIDetail.Property.HWSPECVER = (u16)(((u16)pProBuffer[18] << 8) | pProBuffer[19]); // Hardware version // MIDetail.Property.GPFCode = (u16)(((u16)pProBuffer[20] << 8) | pProBuffer[21]); // Grid-connected protection file code // MIDetail.Property.GPFVer = (u16)(((u16)pProBuffer[22] << 8) | pProBuffer[23]); // Grid-connected protection file version MIDetail.Property.AppFWBuild_VER = (u16)(((u16)pProBuffer[0] << 8) | pProBuffer[1]); //Application firmware version MIDetail.Property.AppFWBuild_YYYY = (u16)(((u16)pProBuffer[2] << 8) | pProBuffer[3]); //Application firmware compilation time-year MIDetail.Property.AppFWBuild_MMDD = (u16)(((u16)pProBuffer[4] << 8) | pProBuffer[5]); //Application firmware compilation time-month. day MIDetail.Property.AppFWBuild_HHMM = (u16)(((u16)pProBuffer[6] << 8) | pProBuffer[7]); // Application version MIDetail.Property.USFWBuild_VER = (u16)(((u16)pProBuffer[8] << 8) | pProBuffer[9]); // Hardware part number MIDetail.Property.HW_PNH = (u16)(((u16)pProBuffer[10] << 8) | pProBuffer[11]); // Hardware part number MIDetail.Property.AppFW_PNL = (u16)(((u16)pProBuffer[12] << 8) | pProBuffer[13]); // Hardware part number MIDetail.Property.AppFW_PNL = (u16)(((u16)pProBuffer[14] << 8) | pProBuffer[15]); // Hardware part number MIDetail.Property.HWSPECVER = (u16)(((u16)pProBuffer[16] << 8) | pProBuffer[17]); // Hardware version MIDetail.Property.GPFCode = (u16)(((u16)pProBuffer[18] << 8) | pProBuffer[19]); // Grid-connected protection file code MIDetail.Property.GPFVer = (u16)(((u16)pProBuffer[20] << 8) | pProBuffer[21]); // Grid-connected protection file version InverterDetail_Write((InverterDetail *)&MIDetail, PortNO, 1);//Inverter RF hardware and software version MIReal[PortNO].Data.NetStatus = NET_EXECUTION_COMPLETED; } } } /*********************************************** ** Function name: Three-generation protocol polling, grid-connected protection, file transfer, application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevInform_GridOnFile(u8 *pBuffer) { vu16 TempDataNum = 0; TempDataNum = UsartNrf3_Process_GetDatatoProBuffer(pBuffer, 15 * 16); if(TempDataNum != 0) { if(UsartNrf3_Process_DataCrc(TempDataNum)) { if(TempDataNum == 4) { UsartNrf3_Process_One_MultiPackage(pBuffer); return; } if(CurRowData_Dat == NULL) { CurRowData_Dat = mymalloc(300 * sizeof(u8)); // if(CurRowData_Dat == NULL) // { // return; // } } memset(CurRowData_Dat, 0, 300 * sizeof(u8)); memcpy(CurRowData_Dat, pProBuffer, TempDataNum); MIReal[PortNO].Data.NetStatus = NET_EXECUTION_COMPLETED; } } } /*********************************************** ** Function name: Three-generation protocol polling, all alarm transmission, application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevInform_Alarm(u8 *pBuffer) { //dong 0602 The first two bytes are the alarm version number // vu16 AlarmVer = 0; vu16 TempDataNum = 0; vu16 i, j; vu32 AlarmTime; calendar_obj calendar; TempDataNum = UsartNrf3_Process_GetDatatoProBuffer(pBuffer, 182 + 2); if(TempDataNum != 0) { if(UsartNrf3_Process_DataCrc(TempDataNum)) { if(TempDataNum == 4) { UsartNrf3_Process_One_MultiPackage(pBuffer); return; } //dong 0602 The first two bytes are the alarm version number // AlarmVer = (u16)pProBuffer[0]*256+pProBuffer[1]; for(i = 0; i < TempDataNum / 12; i++) { if(RealAlarmDataNO == 0) { memset((AlarmDataType *)pRealAlarm, 0, 20 * sizeof(AlarmDataType)); } memcpy((u8 *) & (pRealAlarm[RealAlarmDataNO].Data.Alarm_Id[0]), (u8 *)MIMajor[PortNO].Property.Pre_Id, 2); memcpy((u8 *) & (pRealAlarm[RealAlarmDataNO].Data.Alarm_Id[2]), (u8 *)MIMajor[PortNO].Property.Id, 4); //dong pRealAlarm[RealAlarmDataNO].Data.WCode = (u16)pProBuffer[i * 12 + 2] << 8 | pProBuffer[i * 12 + 3]; if((((pRealAlarm[RealAlarmDataNO].Data.WCode >> 14) & 0x03)) == 0) { MIReal[PortNO].Data.Run_Status[0] = 0x00; MIReal[PortNO].Data.Run_Status[1] = 0x08; } else if(((pRealAlarm[RealAlarmDataNO].Data.WCode >> 14) & 0x03) == 1) { MIReal[PortNO].Data.Run_Status[0] = 0x00; MIReal[PortNO].Data.Run_Status[1] = 0x03; } // There is a problem >> 11 bits should be wrong 2020-05-11 dong recording data // if(((((((uint16_t)pRealAlarm[RealAlarmDataNO].Data.WCode[0]) << 8) | pRealAlarm[RealAlarmDataNO].Data.WCode[1]) >> 11) & 0x01) == 1) // if(((((((u16)pRealAlarm[RealAlarmDataNO].Data.WCode[0]) << 8) | pRealAlarm[RealAlarmDataNO].Data.WCode[1]) >> 11) & 0x01) == 1) // if(((pRealAlarm1[RealAlarmDataNO].Data.WCode << 8) | ((pRealAlarm1[RealAlarmDataNO].Data.WCode >> 11) & 0x01)) == 1) // { // CurAlarmState = HasNewWaveRecord; // } // else // CurAlarmState = HasNONewWaveRecord; //Alarm serial number memcpy((u8 *) & (pRealAlarm[RealAlarmDataNO].Data.WNum), &(pProBuffer[i * 12 + 4]), 2); //dong 2020-05-20 WarnSerNub[PortNO] = (u16)pProBuffer[i * 12 + 4] << 8 | (u16)pProBuffer[i * 12 + 5]; RTC_GetWorldTime(&calendar, Dtu3Detail.Property.timezone); calendar.hour = 0; calendar.min = 0; calendar.sec = 0; //Pending alarm afternoon if(((pRealAlarm[RealAlarmDataNO].Data.WCode >> 13) & 0x01) == 1) { AlarmTime = 12 * 60 * 60 + (u32)(((u16)pProBuffer[i * 12 + 6] << 8) | ((u16)pProBuffer[i * 12 + 7])) + DateToSec(calendar); } //Pending alarm morning else { AlarmTime = (u32)((u16)pProBuffer[i * 12 + 6] << 8) | ((u16)pProBuffer[i * 12 + 7]) + DateToSec(calendar); } //Alarm start time pRealAlarm[RealAlarmDataNO].Data.WTime1[0] = AlarmTime >> 24; pRealAlarm[RealAlarmDataNO].Data.WTime1[1] = AlarmTime >> 16; pRealAlarm[RealAlarmDataNO].Data.WTime1[2] = AlarmTime >> 8; pRealAlarm[RealAlarmDataNO].Data.WTime1[3] = AlarmTime; //End the warning afternoon if(((pRealAlarm[RealAlarmDataNO].Data.WCode >> 12) & 0x01) == 1) { AlarmTime = 12 * 60 * 60 + (u32)(((u16)pProBuffer[i * 12 + 8] << 8) | ((u16)pProBuffer[i * 12 + 9])) + DateToSec(calendar); } //End warning morning else { AlarmTime = (u32)((u16)pProBuffer[i * 12 + 8] << 8) | ((u16)pProBuffer[i * 12 + 9]) + DateToSec(calendar); } //Alarm end time pRealAlarm[RealAlarmDataNO].Data.WTime2[0] = AlarmTime >> 24; pRealAlarm[RealAlarmDataNO].Data.WTime2[1] = AlarmTime >> 16; pRealAlarm[RealAlarmDataNO].Data.WTime2[2] = AlarmTime >> 8; pRealAlarm[RealAlarmDataNO].Data.WTime2[3] = AlarmTime; //Alarm data memcpy((u8 *) & (pRealAlarm[RealAlarmDataNO].Data.Data1[0]), &(pProBuffer[i * 12 + 10]), 2); //Alarm data memcpy((u8 *) & (pRealAlarm[RealAlarmDataNO].Data.Data2[0]), &(pProBuffer[i * 12 + 12]), 2); #ifdef DEBUG0619 printf("SS --id:%lld--wcode:%d--wnub:%d -- WTime1:%d -- WTime2:%d--data1:%d--data2:%d\n\r", \ (((uint64_t)(pRealAlarm[RealAlarmDataNO].Data.Alarm_Id[0]) << 40) + ((uint64_t)(pRealAlarm[RealAlarmDataNO].Data.Alarm_Id[1]) << 32) + ((uint64_t)(pRealAlarm[RealAlarmDataNO].Data.Alarm_Id[2]) << 24) + ((uint64_t)(pRealAlarm[RealAlarmDataNO].Data.Alarm_Id[3]) << 16) + ((uint64_t)(pRealAlarm[RealAlarmDataNO].Data.Alarm_Id[4]) << 8) + (uint64_t)(pRealAlarm[RealAlarmDataNO].Data.Alarm_Id[5])), pRealAlarm[RealAlarmDataNO].Data.WCode, \ ((u16)pRealAlarm[RealAlarmDataNO].Data.WNum[0] << 8 | pRealAlarm[RealAlarmDataNO].Data.WNum[1]), \ ((u32)pRealAlarm[RealAlarmDataNO].Data.WTime1[0] << 24 | (u32) pRealAlarm[RealAlarmDataNO].Data.WTime1[1] << 16 | (u32) pInformAlarm[InformAlarmDataNO].Data.WTime1[2] << 8 | (u32) pInformAlarm[InformAlarmDataNO].Data.WTime1[3]), \ ((u32) pRealAlarm[RealAlarmDataNO].Data.WTime2[0] << 24 | (u32) pRealAlarm[RealAlarmDataNO].Data.WTime2[1] << 16 | (u32) pInformAlarm[InformAlarmDataNO].Data.WTime2[2] << 8 | (u32) pInformAlarm[InformAlarmDataNO].Data.WTime2[3]), \ ((u16)pRealAlarm[RealAlarmDataNO].Data.Data1[0] << 8 | pRealAlarm[RealAlarmDataNO].Data.Data1[1]), \ ((u16)pRealAlarm[RealAlarmDataNO].Data.Data2[0] << 8 | pRealAlarm[RealAlarmDataNO].Data.Data2[1]) ); #endif RealAlarmDataNO++; //dong 2020-05-20 //CurRealAlarmNum = ((uint16_t)pRealAlarm[RealAlarmDataNO].Data.WNum[0]) | pRealAlarm[RealAlarmDataNO].Data.WNum[1]; //dong 20200529 Full 20 alarm data if((APP_Flg != 1) && (RealAlarmDataNO >= 20)) { //A pack of if(AlarmTwoPack == 0) { #ifdef DEBUG0619 printf("1042-Alarm_Data_Write:%d", RealAlarmDataNO); #endif Alarm_Data_Write(0, 1, (AlarmDataType *)pRealAlarm, RealAlarmDataNO); } //Multiple packages have not been accepted yet else if((AlarmTwoPack == 1) && (DataAarnNub > WarnSerNub[PortNO])) { #ifdef DEBUG0619 printf("1050-Alarm_Data_Write:%d", RealAlarmDataNO); #endif Alarm_Data_Write(0, 2, (AlarmDataType *)pRealAlarm, RealAlarmDataNO); AlarmTwoPack = 2; } //Multiple packages have been accepted completely-change to single package storage and jump out of the loop else if((AlarmTwoPack == 1) && (DataAarnNub <= WarnSerNub[PortNO])) { Alarm_Data_Write(0, 1, (AlarmDataType *)pRealAlarm, RealAlarmDataNO); AlarmTwoPack = 0; RealAlarmDataNO = 0; memset((AlarmDataType *)pRealAlarm, 0, sizeof(AlarmDataType) * 20); break; } RealAlarmDataNO = 0; memset((AlarmDataType *)pRealAlarm, 0, sizeof(AlarmDataType) * 20); } } //Not finished training if(DataAarnNub > WarnSerNub[PortNO]) { CurAlarmState = HasNewAlarmRecord; } //Completion of rotation training else { if(AlarmTwoPack == 2) { #ifdef DEBUG0619 printf("1081-Alarm_Data_Write:%d", RealAlarmDataNO); #endif Alarm_Data_Write(1, 2, (AlarmDataType *)pRealAlarm, RealAlarmDataNO); RealAlarmDataNO = 0; memset((AlarmDataType *)pRealAlarm, 0, sizeof(AlarmDataType) * 20); } CurAlarmState = InitState; AlarmTwoPack = 0; } } } } /*********************************************** ** Function name: Three-generation protocol polling, pending alarm transmission, application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevInform_InformUpdate(u8 *pBuffer) { vu16 TempDataNum = 0; vu16 i; vu32 AlarmTime; calendar_obj calendar; TempDataNum = UsartNrf3_Process_GetDatatoProBuffer(pBuffer, 182 + 2); if(TempDataNum != 0) { if(UsartNrf3_Process_DataCrc(TempDataNum)) { if(TempDataNum == 4) { UsartNrf3_Process_One_MultiPackage(pBuffer); return; } for(i = 0; i < TempDataNum / 12; i++) { if(InformAlarmDataNO == 0) { memset((AlarmDataType *)pInformAlarm, 0, 20 * sizeof(AlarmDataType)); } memcpy((u8 *) & (pInformAlarm[InformAlarmDataNO].Data.Alarm_Id[0]), (u8 *)MIMajor[PortNO].Property.Pre_Id, 2); memcpy((u8 *) & (pInformAlarm[InformAlarmDataNO].Data.Alarm_Id[2]), (u8 *)MIMajor[PortNO].Property.Id, 4); pInformAlarm[InformAlarmDataNO].Data.WCode = (u16)pProBuffer[i * 12 + 2] << 8 | pProBuffer[i * 12 + 3]; if(((pInformAlarm[InformAlarmDataNO].Data.WCode >> 14) & 0x03) == 0) { MIReal[PortNO].Data.Run_Status[1] = 0x08; MIReal[PortNO].Data.Run_Status[0] = 0x00; } else if(((pInformAlarm[InformAlarmDataNO].Data.WCode >> 14) & 0x03) == 1) { MIReal[PortNO].Data.Run_Status[1] = 0x03; MIReal[PortNO].Data.Run_Status[0] = 0x00; } // if(((((((u16)pAlarmData[AlarmDataNO]->Data.WCode[0]) << 8)|pAlarmData[AlarmDataNO]->Data.WCode[1]) >> 11)&0x01) == 1) // CurAlarmState = HasNewWaveRecord; // else // CurAlarmState = HasNONewWaveRecord; memcpy((u8 *) & (pInformAlarm[InformAlarmDataNO].Data.WNum), &(pProBuffer[i * 12 + 4]), 2); // Alarm serial number RTC_GetWorldTime(&calendar, Dtu3Detail.Property.timezone); calendar.hour = 0; calendar.min = 0; calendar.sec = 0; //Pending alarm afternoon if(((pInformAlarm[InformAlarmDataNO].Data.WCode >> 13) & 0x01) == 1) { AlarmTime = 12 * 60 * 60 + (u32)(((u16)pProBuffer[i * 12 + 6] << 8) | ((u16)pProBuffer[i * 12 + 7])) + DateToSec(calendar); } //Pending alarm morning else { AlarmTime = (u32)((u16)pProBuffer[i * 12 + 6] << 8) | ((u16)pProBuffer[i * 12 + 7]) + DateToSec(calendar); } //Alarm start time pInformAlarm[InformAlarmDataNO].Data.WTime1[0] = AlarmTime >> 24; pInformAlarm[InformAlarmDataNO].Data.WTime1[1] = AlarmTime >> 16; pInformAlarm[InformAlarmDataNO].Data.WTime1[2] = AlarmTime >> 8; pInformAlarm[InformAlarmDataNO].Data.WTime1[3] = AlarmTime; //End the warning afternoon if((((pInformAlarm[InformAlarmDataNO].Data.WCode >> 12) & 0x01)) == 1) { AlarmTime = 12 * 60 * 60 + (u32)(((u16)pProBuffer[i * 12 + 8] << 8) | ((u16)pProBuffer[i * 12 + 9])) + DateToSec(calendar); } //End warning morning else { AlarmTime = (u32)((u16)pProBuffer[i * 12 + 8] << 8) | ((u16)pProBuffer[i * 12 + 9]) + DateToSec(calendar); } //Alarm end time pInformAlarm[InformAlarmDataNO].Data.WTime2[0] = AlarmTime >> 24; pInformAlarm[InformAlarmDataNO].Data.WTime2[1] = AlarmTime >> 16; pInformAlarm[InformAlarmDataNO].Data.WTime2[2] = AlarmTime >> 8; pInformAlarm[InformAlarmDataNO].Data.WTime2[3] = AlarmTime; //Alarm data memcpy((u8 *) & (pInformAlarm[InformAlarmDataNO].Data.Data1[0]), &(pProBuffer[i * 12 + 10]), 2); //Alarm data 2 memcpy((u8 *) & (pInformAlarm[InformAlarmDataNO].Data.Data2[0]), &(pProBuffer[i * 12 + 12]), 2); #ifdef DEBUG0619 printf("GQ --id:%lld--wcode:%d--wnub:%d -- WTime1:%d -- WTime2:%d--data1:%d--data2:%d\n\r", \ (((uint64_t)(pInformAlarm[InformAlarmDataNO].Data.Alarm_Id[0]) << 40) + ((uint64_t)(pInformAlarm[InformAlarmDataNO].Data.Alarm_Id[1]) << 32) + ((uint64_t)(pInformAlarm[InformAlarmDataNO].Data.Alarm_Id[2]) << 24) + ((uint64_t)(pInformAlarm[InformAlarmDataNO].Data.Alarm_Id[3]) << 16) + ((uint64_t)(pInformAlarm[InformAlarmDataNO].Data.Alarm_Id[4]) << 8) + (uint64_t)(pInformAlarm[InformAlarmDataNO].Data.Alarm_Id[5])), pInformAlarm[InformAlarmDataNO].Data.WCode, \ ((u16) pInformAlarm[InformAlarmDataNO].Data.WNum[0] << 8 | pInformAlarm[InformAlarmDataNO].Data.WNum[1]), \ ((u32) pInformAlarm[InformAlarmDataNO].Data.WTime1[0] << 24 | (u32) pInformAlarm[InformAlarmDataNO].Data.WTime1[1] << 16 | (u32) pInformAlarm[InformAlarmDataNO].Data.WTime1[2] << 8 | (u32) pInformAlarm[InformAlarmDataNO].Data.WTime1[3]), \ ((u32) pInformAlarm[InformAlarmDataNO].Data.WTime2[0] << 24 | (u32) pInformAlarm[InformAlarmDataNO].Data.WTime2[1] << 16 | (u32) pInformAlarm[InformAlarmDataNO].Data.WTime2[2] << 8 | (u32) pInformAlarm[InformAlarmDataNO].Data.WTime2[3]), \ ((u16) pInformAlarm[InformAlarmDataNO].Data.Data1[0] << 8 | pInformAlarm[InformAlarmDataNO].Data.Data1[1]), \ ((u16) pInformAlarm[InformAlarmDataNO].Data.Data2[0] << 8 | pInformAlarm[InformAlarmDataNO].Data.Data2[1]) ); #endif InformAlarmDataNO++; // Write alarm data to flash if(InformAlarmDataNO >= 20) { #ifdef DEBUG0619 printf("AlarmInfo_Write:%d", InformAlarmDataNO); #endif AlarmInfo_Write((AlarmDataType *)&pInformAlarm, 20); InformAlarmDataNO = 0; memset((AlarmDataType *)pInformAlarm, 0, 20 * sizeof(AlarmDataType)); } } } } } /*********************************************** ** Function name: Three-generation protocol polling, recording, data transmission, application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevInform_RecordWave(u8 *pBuffer) { vu16 TempDataNum = 0; WaveDataType *pWaveData = NULL; u8 *pWVData = NULL; TempDataNum = UsartNrf3_Process_GetDatatoProBuffer(pBuffer, 1200 + 2); if(TempDataNum != 0) { if(UsartNrf3_Process_DataCrc(TempDataNum)) { if(TempDataNum == 4) { UsartNrf3_Process_One_MultiPackage(pBuffer); return; } if(pWaveData == NULL) { pWaveData = mymalloc(1200 * sizeof(u8)); // if(pWaveData == NULL) // { // return; // } } memset(pWaveData, 0, 1200 * sizeof(u8)); memcpy(&(pWaveData->Alarm_Id[0]), (u8 *)MIMajor[PortNO].Property.Pre_Id, 2); memcpy(&(pWaveData->Alarm_Id[2]), (u8 *)MIMajor[PortNO].Property.Id, 4); pWaveData->WCode = (u16)pProBuffer[0] << 8 | pProBuffer[1]; memcpy(&(pWaveData->WNum), &(pProBuffer[2]), 2);// Alarm serial number pWaveData->WTime1[0] = (u8)(RTC_GetWorldSecond(Dtu3Detail.Property.timezone) >> 24); pWaveData->WTime1[1] = (u8)(RTC_GetWorldSecond(Dtu3Detail.Property.timezone) >> 16); pWaveData->WTime1[2] = (u8)(RTC_GetWorldSecond(Dtu3Detail.Property.timezone) >> 8); pWaveData->WTime1[3] = (u8)(RTC_GetWorldSecond(Dtu3Detail.Property.timezone)); memcpy(&(pWaveData->WVDataL), &(pProBuffer[4]), 2); // Data length memcpy(&(pWaveData->WPos), &(pProBuffer[6]), 2);// Alarm location if(pWVData == NULL) { pWVData = mymalloc((u16)(pWaveData->WVDataL) * sizeof(u8)); // if(pWVData == NULL) // { // return; // } } memset(pWVData, 0, (u16)(pWaveData->WVDataL)*sizeof(u8)); pWVData = &(pProBuffer[8]); //Write recording data to flash if(pWaveData != NULL) { myfree(pWaveData); pWaveData = NULL; } if(pWVData != NULL) { myfree(pWVData); pWVData = NULL; } } } } /*********************************************** ** Function name: Three-generation protocol polling all data, information and communication quality ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevInform_GetLossRate(u8 *pBuffer) { vu16 TempDataNum = 0; TempDataNum = UsartNrf3_Process_GetDatatoProBuffer(pBuffer, 2 * 16); if(TempDataNum != 0) { if(UsartNrf3_Process_DataCrc(TempDataNum)) { if((pDataCnt->MI_CF_Num_Start == 0) && (pDataCnt->MI_RF_Num_Start == 0)) { pDataCnt->MI_CF_Num_Start = (int16_t)(((u16)pProBuffer[0] << 8) | pProBuffer[1]); //Micro-inverse receive count pDataCnt->MI_RF_Num_Start = (int16_t)(((u16)pProBuffer[2] << 8) | pProBuffer[3]); //Micro-inverse send count } else { pDataCnt->MI_CF_Num_End = (int16_t)(((u16)pProBuffer[0] << 8) | pProBuffer[1]); //Micro-inverse receive count pDataCnt->MI_RF_Num_End = (int16_t)(((u16)pProBuffer[2] << 8) | pProBuffer[3]); //Micro-inverse send count } } } } //dong 2020-06-15 /*********************************************** ** Function name: Three-generation protocol self-check status application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_Self_Check_State(u8 *pBuffer) { vu16 TempDataNum = 0; vu16 i; vu32 AlarmTime; calendar_obj calendar; TempDataNum = UsartNrf3_Process_GetDatatoProBuffer(pBuffer, 90 + 2); GPSTVal GPSTValBuf = {0}; if(TempDataNum != 0) { //id memcpy((u8 *) & (GPSTValBuf.Property.pv_sn[0]), (u8 *)MIMajor[PortNO].Property.Pre_Id, 2); memcpy((u8 *) & (GPSTValBuf.Property.pv_sn[2]), (u8 *)MIMajor[PortNO].Property.Id, 4); //Data version GPSTValBuf.Property.ver = (u16)pProBuffer[0] << 8 | pProBuffer[1]; //Test status GPSTValBuf.Property.st = (u16)pProBuffer[2] << 8 | pProBuffer[3]; //Collection completed if((GPSTValBuf.Property.st >= 2) && (GPSTValBuf.Property.st <= 6)) { } //Collecting else { return; } //Grid-connected rule file code GPSTValBuf.Property.gpf = (u16)pProBuffer[4] << 8 | pProBuffer[5]; //Grid-connected rule file version GPSTValBuf.Property.gpf_ver = (u16)pProBuffer[6] << 8 | pProBuffer[7]; //4 to 6 There is no subsequent data if((GPSTValBuf.Property.st >= 2) && (GPSTValBuf.Property.st <= 3)) { //First-level overvoltage self-test test results // memcpy((u8 *)GPSTValBuf.Property.hv1_stval.Data, (u8 *)&pProBuffer[8], 10); GPSTValBuf.Property.hv1_stval.Property.code = (u16)pProBuffer[8] << 8 | pProBuffer[9]; GPSTValBuf.Property.hv1_stval.Property.dflt_val = (u16)pProBuffer[10] << 8 | pProBuffer[11]; GPSTValBuf.Property.hv1_stval.Property.dflt_tim = (u16)pProBuffer[12] << 8 | pProBuffer[13]; GPSTValBuf.Property.hv1_stval.Property.rslt_val = (u16)pProBuffer[14] << 8 | pProBuffer[15]; GPSTValBuf.Property.hv1_stval.Property.rslt_tim = (u16)pProBuffer[16] << 8 | pProBuffer[17]; //First-level undervoltage self-test test results // memcpy((u8 *)GPSTValBuf.Property.lv1_stval.Data, (u8 *)&pProBuffer[18], 10); GPSTValBuf.Property.lv1_stval.Property.code = (u16)pProBuffer[18] << 8 | pProBuffer[19]; GPSTValBuf.Property.lv1_stval.Property.dflt_val = (u16)pProBuffer[20] << 8 | pProBuffer[21]; GPSTValBuf.Property.lv1_stval.Property.dflt_tim = (u16)pProBuffer[22] << 8 | pProBuffer[23]; GPSTValBuf.Property.lv1_stval.Property.rslt_val = (u16)pProBuffer[24] << 8 | pProBuffer[25]; GPSTValBuf.Property.lv1_stval.Property.rslt_tim = (u16)pProBuffer[26] << 8 | pProBuffer[27]; //Secondary overvoltage self-test test results // memcpy((u8 *)GPSTValBuf.Property.hv2_stval.Data, (u8 *)&pProBuffer[28], 10); GPSTValBuf.Property.hv2_stval.Property.code = (u16)pProBuffer[28] << 8 | pProBuffer[29]; GPSTValBuf.Property.hv2_stval.Property.dflt_val = (u16)pProBuffer[30] << 8 | pProBuffer[31]; GPSTValBuf.Property.hv2_stval.Property.dflt_tim = (u16)pProBuffer[32] << 8 | pProBuffer[33]; GPSTValBuf.Property.hv2_stval.Property.rslt_val = (u16)pProBuffer[34] << 8 | pProBuffer[35]; GPSTValBuf.Property.hv2_stval.Property.rslt_tim = (u16)pProBuffer[36] << 8 | pProBuffer[37]; //Secondary undervoltage self-test test results // memcpy((u8 *)GPSTValBuf.Property.lv2_stval.Data, (u8 *)&pProBuffer[38], 10); GPSTValBuf.Property.lv2_stval.Property.code = (u16)pProBuffer[38] << 8 | pProBuffer[39]; GPSTValBuf.Property.lv2_stval.Property.dflt_val = (u16)pProBuffer[40] << 8 | pProBuffer[41]; GPSTValBuf.Property.lv2_stval.Property.dflt_tim = (u16)pProBuffer[42] << 8 | pProBuffer[43]; GPSTValBuf.Property.lv2_stval.Property.rslt_val = (u16)pProBuffer[44] << 8 | pProBuffer[45]; GPSTValBuf.Property.lv2_stval.Property.rslt_tim = (u16)pProBuffer[46] << 8 | pProBuffer[47]; //First-level over-frequency self-test test results // memcpy((u8 *)GPSTValBuf.Property.hf1_stval.Data, (u8 *)&pProBuffer[48], 10); GPSTValBuf.Property.hf1_stval.Property.code = (u16)pProBuffer[48] << 8 | pProBuffer[49]; GPSTValBuf.Property.hf1_stval.Property.dflt_val = (u16)pProBuffer[50] << 8 | pProBuffer[51]; GPSTValBuf.Property.hf1_stval.Property.dflt_tim = (u16)pProBuffer[52] << 8 | pProBuffer[53]; GPSTValBuf.Property.hf1_stval.Property.rslt_val = (u16)pProBuffer[54] << 8 | pProBuffer[55]; GPSTValBuf.Property.hf1_stval.Property.rslt_tim = (u16)pProBuffer[56] << 8 | pProBuffer[57]; //First-level underfrequency self-test test results // memcpy((u8 *)GPSTValBuf.Property.lf1_stval.Data, (u8 *)&pProBuffer[58], 10); GPSTValBuf.Property.lf1_stval.Property.code = (u16)pProBuffer[58] << 8 | pProBuffer[59]; GPSTValBuf.Property.lf1_stval.Property.dflt_val = (u16)pProBuffer[60] << 8 | pProBuffer[61]; GPSTValBuf.Property.lf1_stval.Property.dflt_tim = (u16)pProBuffer[62] << 8 | pProBuffer[63]; GPSTValBuf.Property.lf1_stval.Property.rslt_val = (u16)pProBuffer[64] << 8 | pProBuffer[65]; GPSTValBuf.Property.lf1_stval.Property.rslt_tim = (u16)pProBuffer[66] << 8 | pProBuffer[67]; //Secondary over-frequency self-test test results // memcpy((u8 *)GPSTValBuf.Property.hf2_stval.Data, (u8 *)&pProBuffer[68], 10); GPSTValBuf.Property.hf2_stval.Property.code = (u16)pProBuffer[68] << 8 | pProBuffer[69]; GPSTValBuf.Property.hf2_stval.Property.dflt_val = (u16)pProBuffer[70] << 8 | pProBuffer[71]; GPSTValBuf.Property.hf2_stval.Property.dflt_tim = (u16)pProBuffer[72] << 8 | pProBuffer[73]; GPSTValBuf.Property.hf2_stval.Property.rslt_val = (u16)pProBuffer[74] << 8 | pProBuffer[75]; GPSTValBuf.Property.hf2_stval.Property.rslt_tim = (u16)pProBuffer[76] << 8 | pProBuffer[77]; //Secondary underfrequency self-test test results // memcpy((u8 *)GPSTValBuf.Property.lf2_stval.Data, (u8 *)&pProBuffer[78], 10); GPSTValBuf.Property.lf2_stval.Property.code = (u16)pProBuffer[78] << 8 | pProBuffer[79]; GPSTValBuf.Property.lf2_stval.Property.dflt_val = (u16)pProBuffer[80] << 8 | pProBuffer[81]; GPSTValBuf.Property.lf2_stval.Property.dflt_tim = (u16)pProBuffer[82] << 8 | pProBuffer[83]; GPSTValBuf.Property.lf2_stval.Property.rslt_val = (u16)pProBuffer[84] << 8 | pProBuffer[85]; GPSTValBuf.Property.lf2_stval.Property.rslt_tim = (u16)pProBuffer[86] << 8 | pProBuffer[87]; } #ifdef solar printf("AlarmInfo_Write:%d", InformAlarmDataNO); #endif //Storage GPST_Data_Write((GPSTVal *)&GPSTValBuf, 1); //Clear rotation status MIReal[PortNO].Data.NetCmd = NET_INIT; MIReal[PortNO].Data.NetStatus = NET_NOCMD; //Check the status whether all rounds of training have ended for(u8 i = 0; i < Dtu3Detail.Property.PortNum; i++) { if(MIReal[i].Data.NetCmd == NET_SELF_STAUS) { return ; } } //All rounds of training are over and uploaded to the server SelfCheckStateFlg = 2; } } /*********************************************** ** Function name: Three-generation protocol polling, all data and information transmission, application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevInform(u8 *pBuffer) { switch(CurRecSendPackageDataType) { case InverterDevInform_Simple: // Micro-inverse device Information-Simplified version { UsartNrf3_Process_DevInform_Sample(pBuffer); break; } case InverterDevInform_All: // Micro-inverse device Information-full version { UsartNrf3_Process_DevInform_All(pBuffer); break; } case GridOnProFilePara: // Grid-connected protection file parameters { UsartNrf3_Process_DevInform_GridOnFile(pBuffer); break; } case HardWareConfig: //Hardware configuration information { //UsartNrf3_Process_DevInform_SystemConfig(pBuffer); break; } case SimpleCalibrationPara: // Sampling calibration coefficient { // UsartNrf3_Process_DevInform_Calibration(pBuffer); break; } case SystemConfigPara: //System configuration parameters { // UsartNrf3_Process_DevInform_SystemConfig(pBuffer); break; } case RealTimeRunData_Debug: // Real-time display of operating data-system debugging stage { UsartNrf3_Process_DevRunDebug(pBuffer); break; } case RealTimeRunData_Reality: //Display operation data-system operation stage { UsartNrf3_Process_DevRunReality(pBuffer); break; } case RealTimeRunData_A_Phase: //Show operating data-phase a { break; } case RealTimeRunData_B_Phase: //Show operating data-phase b { break; } case RealTimeRunData_C_Phase: //Show operating data-phase c { break; } //All unsent alarms case AlarmData: { UsartNrf3_Process_DevInform_Alarm(pBuffer); break; } //All pending alarms case AlarmUpdate: { UsartNrf3_Process_DevInform_InformUpdate(pBuffer); break; } case RecordData: // Recording Data { UsartNrf3_Process_DevInform_RecordWave(pBuffer); break; } case InternalData: //Internal data 1 (for production and testing, dtu does not need to be supported) { // UsartNrf3_Process_DevInform_InternalData(pBuffer); break; } case GetLossRate: { UsartNrf3_Process_DevInform_GetLossRate(pBuffer); break; } //dong 2020-06-15 //Self-test status processing case GetSelfCheckState: { UsartNrf3_Process_Self_Check_State(pBuffer); break; } default: break; } } //dong 2020-06-23 /*********************************************** ** Function name: Third-generation protocol round sequence NRF version number ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ u8 UsartNrf3_Send_Mi_Nrf_VER(u8 *target_adr, u8 *rout_adr) { vu8 i = 0; vu8 temp_dat[UART_LEN]; memset((u8 *)temp_dat, 0, sizeof(temp_dat)); memset((u8 *)Uart_SendBuffer, 0, UART_LEN); Uart_SendBuffer[0] = STX;//Header temp_dat[0] = 0x06; //command memcpy((u8 *)&temp_dat[1], target_adr, 4);//Source address memcpy((u8 *)&temp_dat[5], rout_adr, 4);//Destination address temp_dat[9] = 0; temp_dat[10] = Get_crc_xor((u8 *)temp_dat, 10); i = ForwardSubstitution((u8 *)&Uart_SendBuffer[1], (u8 *)&temp_dat[0], 11); // Forward replacement Uart_SendBuffer[(i + 1)] = ETX; //Footer memset((u8 *)temp_dat, 0, sizeof(temp_dat)); return (i + 2); } /*********************************************** ** Function name: Three-generation protocol, single package, overcharged polling package ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ u8 UsartNrf3_Send_PackPollSigleDataCommand(u8 *target_adr, u8 *rout_adr, u8 FrameNO) { vu8 i = 0; vu8 temp_dat[UART_LEN]; memset((u8 *)temp_dat, 0, sizeof(temp_dat)); memset((u8 *)Uart_SendBuffer, 0, UART_LEN); Uart_SendBuffer[0] = STX;//Header temp_dat[0] = 0x15; //command memcpy((u8 *)&temp_dat[1], target_adr, 4);//Source address memcpy((u8 *)&temp_dat[5], rout_adr, 4);//Destination address if(FrameNO > 127) { return 0; } temp_dat[9] = FrameNO | 0x80; //Multi-frame identification temp_dat[10] = Get_crc_xor((u8 *)temp_dat, 10); i = ForwardSubstitution((u8 *)&Uart_SendBuffer[1], (u8 *)&temp_dat[0], 11); // Forward replacement Uart_SendBuffer[(i + 1)] = ETX; //Footer memset((u8 *)temp_dat, 0, sizeof(temp_dat)); return (i + 2); } /*********************************************** ** Function name: Three-generation protocol, single package, overcharged polling package ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ u8 UsartNrf3_Send_PackPollMultiDataCommand(u8 *target_adr, u8 *rout_adr, u8 DataType, u8 Gap, u8 *Password) { vu8 i = 0; vu16 TempCrc = 0; vu8 temp_dat[UART_LEN]; vu16 DatCrc = 0xffff; memset((u8 *)temp_dat, 0, sizeof(temp_dat)); memset((u8 *)Uart_SendBuffer, 0, UART_LEN); //20200514 dong vu32 time = RTC_GetWorldSecond(Dtu3Detail.Property.timezone); Uart_SendBuffer[0] = STX;//Header temp_dat[0] = 0x15; //command memcpy((u8 *)&temp_dat[1], target_adr, 4);//Source address memcpy((u8 *)&temp_dat[5], rout_adr, 4);//Destination address temp_dat[9] = 0x80;//Multi-frame identification temp_dat[10] = DataType;//User data: data type CurRecSendPackageDataType = DataType;//The currently packaged data type temp_dat[11] = 0;//rev temp_dat[12] = (u8)(time >> 24); temp_dat[13] = (u8)(time >> 16); temp_dat[14] = (u8)(time >> 8); temp_dat[15] = (u8)(time); temp_dat[16] = Gap;//User data: data upload server interval temp_dat[17] = Gap >> 8; if(DataType == AlarmData) { // temp_dat[18] = (u8)((CurRealAlarmNum + 1) / 0xff); // temp_dat[19] = (u8)((CurRealAlarmNum + 1) % 0xff); temp_dat[18] = (u8)((WarnSerNub[PortNO]) / 0xff); temp_dat[19] = (u8)((WarnSerNub[PortNO]) % 0xff); } else { memset((u8 *) & (temp_dat[18]), 0, 2); // User data: the latest alarm serial number received on the same day } memcpy((u8 *)(&temp_dat[20]), Password, 4); //User data: anti-theft password for(i = 10; i < 24; i++) { if((i - 10) % 2 == 1) { TempCrc = (u16)(temp_dat[i - 1] << 8) | (temp_dat[i]); DatCrc = CalcCRC16t(TempCrc, DatCrc); } } temp_dat[24] = (u8)(DatCrc >> 8); temp_dat[25] = (u8)(DatCrc); temp_dat[26] = Get_crc_xor((u8 *)temp_dat, 26); i = ForwardSubstitution((u8 *)&Uart_SendBuffer[1], (u8 *)&temp_dat[0], 27); // Forward replacement Uart_SendBuffer[(i + 1)] = ETX; //Footer memset((u8 *)temp_dat, 0, sizeof(temp_dat)); return (i + 2); } /*********************************************** ** Function name: Three-generation protocol device control package ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ u8 UsartNrf3_Send_PackDevControl(u8 *target_adr, u8 *rout_adr, u16 ControlMode, u8 *ControlData, u8 nub, u8 Num) { vu8 i = 0; vu16 TempCrc = 0; vu8 temp_dat[UART_LEN]; vu16 DatCrc = 0xffff; memset((u8 *)temp_dat, 0, sizeof(temp_dat)); memset((u8 *)Uart_SendBuffer, 0, UART_LEN); Uart_SendBuffer[0] = STX; //header temp_dat[0] = DEVCONTROL_ALL; //command memcpy((u8 *)&temp_dat[1], target_adr, 4);//Source address memcpy((u8 *)&temp_dat[5], rout_adr, 4);//Destination address temp_dat[9] = 0x81;// if((nub & 0x0f) == 1) { temp_dat[10] = (u8)(ControlMode >> 8); //Control type temp_dat[11] = (u8)(ControlMode); //Control type } memcpy((u8 *) & (temp_dat[12]), ControlData, Num); //Control parameters for(i = 10; i < 12 + Num + 1; i++) { if((i - 10) % 2 == 1) { TempCrc = (u16)((temp_dat[i - 1] << 8) | (temp_dat[i])); DatCrc = CalcCRC16t(TempCrc, DatCrc); } } temp_dat[12 + Num] = (u8)(DatCrc >> 8); temp_dat[13 + Num] = (u8)(DatCrc); temp_dat[14 + Num] = Get_crc_xor((u8 *)&temp_dat[0], 15 + Num); i = ForwardSubstitution((u8 *)&Uart_SendBuffer[1], (u8 *)&temp_dat[0], (15 + Num)); //Forward replacement Uart_SendBuffer[(i + 1)] = ETX; // footer memset((u8 *)temp_dat, 0, sizeof(temp_dat)); return (i + 2); } /*********************************************** ** Function name: Three-generation protocol parameter setting package ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ u8 UsartNrf3_Send_PackSetPara(u8 *target_adr, u8 *rout_adr, u16 ControlMode, u8 *ControlData, u8 nub, u8 Num) { vu8 i = 0, j = 0; vu16 TempCrc = 0; vu8 temp_dat[UART_LEN]; vu16 DatCrc = 0xffff; memset((u8 *)Uart_SendBuffer, 0, UART_LEN); memset((u8 *)temp_dat, 0, sizeof(temp_dat)); Uart_SendBuffer[0] = STX;//Header temp_dat[0] = PARASET_ALL; //command memcpy((u8 *)&temp_dat[1], target_adr, 4);//Source address temp_dat[9] = nub;// memcpy((u8 *)&temp_dat[5], rout_adr, 4);//Destination address j = 10; if((nub & 0x0f) == 1) { temp_dat[j++] = (u8)(ControlMode >> 8); //Control type temp_dat[j++] = (u8)(ControlMode);//Control type } memcpy((u8 *) & (temp_dat[j]), ControlData, Num); // Set parameters if((nub >> 7) == 1) { for(i = 0; i < TotalIndex_Para + 2; i++) { if(i % 2 == 1) { if(i > 2) { TempCrc = (u16)(((u16)MIMajor[PortNO].Property.Pass.Data[i - 3] << 8) | (MIMajor[PortNO].Property.Pass.Data[i - 2])); DatCrc = CalcCRC16t(TempCrc, DatCrc); } else { TempCrc = ControlMode; DatCrc = CalcCRC16t(TempCrc, DatCrc); } } } temp_dat[(j++) + Num] = (u8)(DatCrc >> 8); temp_dat[(j++) + Num] = (u8)(DatCrc); } temp_dat[j + Num] = Get_crc_xor((u8 *)&temp_dat[0], j + Num); i = ForwardSubstitution((u8 *)&Uart_SendBuffer[1], (u8 *)&temp_dat[0], (j + 1 + Num)); // Forward replacement Uart_SendBuffer[(i + 1)] = ETX; //Footer memset((u8 *)temp_dat, 0, sizeof(temp_dat)); return (i + 2); } /*********************************************** ** Function name: Convert three-generation protocol network command to Nrf command ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Send_NetCmdToNrfCmd(void) { if((CurNetCmd >= NET_TURN_ON) && (CurNetCmd <= NET_ELE_ENERGY)) { switch(CurNetCmd) { case NET_INVERTER_HW_INFOR: //case NET_TERMINAL_INFOR: SubCmd = InverterDevInform_Simple; // 0x00 MainCmd = REQ_ARW_DAT_ALL; // 0x15 break; case NET_POLL_GRID_ON_FILE: SubCmd = GridOnProFilePara; // 0x02 MainCmd = REQ_ARW_DAT_ALL; // 0x15 break; //////////////////////////////////////////////////////////////////////Operation control case NET_TURN_ON: SubCmd = Type_TurnOn;//Boot MainCmd = DEVCONTROL_ALL; break; case NET_TURN_OFF: SubCmd = Type_TurnOff;//Shut down MainCmd = DEVCONTROL_ALL; break; case NET_LIMIT_ACTIVE_POEWR: case NET_LIMIT_POEWR: SubCmd = Type_ActivePowerContr ;// Limit active power MainCmd = DEVCONTROL_ALL; break; case NET_LIMIT_REACTIVE_POWER: SubCmd = Type_ReactivePowerContr ;// Limit reactive power MainCmd = DEVCONTROL_ALL; break; case NET_PF_SET: SubCmd = Type_PFSet ;//Limit power factor MainCmd = DEVCONTROL_ALL; break; case NET_CLEAN_GFDI: case NET_CLEAR_ALARM: SubCmd = Type_CleanState_LockAndAlarm ;// Lock alarm cleared MainCmd = DEVCONTROL_ALL; break; case NET_RESTART: // Download program / reset MainCmd = DEVCONTROL_ALL; SubCmd = Type_Restart; break; case NET_UNLOCK: SubCmd = Type_Unlock; MainCmd = DEVCONTROL_ALL; break; case NET_LOCK: SubCmd = Type_Lock; MainCmd = DEVCONTROL_ALL; break; //dong 2020-06-15 case NET_SELF_INSPECTION: SubCmd = Type_SelfInspection;//Self-test MainCmd = DEVCONTROL_ALL; break; ////////////////////////////////////////////////////////////////Parameter configuration case NET_ELE_ENERGY: case NET_SET_ENERGY: SubCmd = EleEnergySet; MainCmd = PARASET_ALL; break; case NET_SET_PASSWORD: case NET_CANCEL_GUARD: SubCmd = AntitheftParaSet;//Set password MainCmd = PARASET_ALL; break; ////////////////////////////////////////////////////////////////File multi-package case NET_DOWNLOAD_PRO: MainCmd = DOWN_PRO; SubCmd = Type_Init; break; case NET_DOWNLOAD_DAT://Grid-connected protection file MainCmd = DOWN_DAT; SubCmd = Type_Init; break; default: break; } } else if(CurNetCmd == NET_INIT) { MainCmd = REQ_ARW_DAT_ALL; // 0x15 if(CurPollIsDebugDataTime == false) { SubCmd = RealTimeRunData_Reality; // 0x0c } else { SubCmd = RealTimeRunData_Debug; // 0x0b } } //dong 2020-06-15 // else if(CurNetCmd == NET_SELF_STAUS) // { // MainCmd = REQ_ARW_DAT_ALL; // 0x15 // SubCmd = GetSelfCheckState; // 0x1e // } //dong 2020-06-23 // else if(CurNetCmd == NET_GET_LOSS_RATE) // { // MainCmd = REQ_ARW_DAT_ALL; // 0x15 // SubCmd = GetLossRate; // 0x15 // } else if(CurNetCmd == NET_ALARM_DATA) { MainCmd = REQ_ARW_DAT_ALL; // 0x15 SubCmd = AlarmData; // 0x11 } else if(CurNetCmd == NET_RECORD_DATA) { MainCmd = REQ_ARW_DAT_ALL; // 0x15 SubCmd = RecordData; // 0x13 } else if(CurNetCmd == NET_ALARM_UPDATE) { MainCmd = REQ_ARW_DAT_ALL; // 0x15 SubCmd = AlarmUpdate; // 0x12 } else if(CurNetCmd == NET_MI_VERSION) { SubCmd = InverterDevInform_Simple; // 0x00 MainCmd = REQ_ARW_DAT_ALL; // 0x15 } } /*********************************************** ** Function name: Three-generation protocol device control application layer transmission ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf_Send_DevControlUpdate(u8 *target_adr, u8 *rout_adr) { vu16 relative_value = 0; if((SubCmd >= Type_TurnOn) && (SubCmd <= Type_Unlock)) { TotalIndex_Para = 0; } else if((SubCmd >= Type_ActivePowerContr) && (SubCmd <= Type_PFSet)) { if(SubCmd == Type_ActivePowerContr) { #ifdef DTU3PRO if((Dtu3Detail.Property.DRM_Limit_Switch == 1) || (Dtu3Detail.Property.SunSpec_Switch == 1)) { if(MIMajor[PortNO].Property.Acq_Switch == 0) { SubCmd = Type_TurnOff; TotalIndex_Para = 0; } else { TotalIndex_Para = 4; relative_value = MIMajor[PortNO].Property.Power_Limit; if(relative_value > FULL_CONTROL_VALUE) { relative_value = FULL_CONTROL_VALUE; } MIMajor[PortNO].Property.Pass.PowerPFDev.SetValut[0] = (u8)(relative_value >> 8); MIMajor[PortNO].Property.Pass.PowerPFDev.SetValut[1] = (u8)(relative_value); MIMajor[PortNO].Property.Pass.PowerPFDev.Desc[0] = 0; MIMajor[PortNO].Property.Pass.PowerPFDev.Desc[1] = 1; } } else if((Dtu3Detail.Property.Zero_Export_Switch == 1) || (Dtu3Detail.Property.Phase_Balance_Switch == 1)) { TotalIndex_Para = 4; MIMajor[PortNO].Property.Pass.PowerPFDev.SetValut[0] = (u8)(MIMajor[PortNO].Property.Power_Limit >> 8); MIMajor[PortNO].Property.Pass.PowerPFDev.SetValut[1] = (u8)(MIMajor[PortNO].Property.Power_Limit); } #endif } else { TotalIndex_Para = 4; } } else if(SubCmd == Type_CleanState_LockAndAlarm) { TotalIndex_Para = 2; } //dong 2020-06-15 Grid-connected parameter self-test else if(SubCmd == Type_SelfInspection) { TotalIndex_Para = 4; } if(TotalIndex_Para <= 12)//Only 1 frame { Uart_SendBufferLen = UsartNrf3_Send_PackDevControl((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + Index_Para, 0x81 + ((Index_Para + 4) / 16), TotalIndex_Para - Index_Para); if(TotalIndex_Para - 1 >= 0) { Index_Para = TotalIndex_Para - 1; } else { Index_Para = 0; } } else //Multi-frame { if(((TotalIndex_Para - 1) - Index_Para) <= 14) { Uart_SendBufferLen = UsartNrf3_Send_PackDevControl((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + Index_Para, 0x81 + ((Index_Para + 4) / 16), TotalIndex_Para - Index_Para); Index_Para = TotalIndex_Para - 1; ProtocalLayer_Cmd = ToTransLayer_Send;//Transport layer } else { if(Index_Para == 0) { Uart_SendBufferLen = UsartNrf3_Send_PackDevControl((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + Index_Para, 1 + ((Index_Para + 4) / 16), 14); Index_Para = Index_Para + 14; } else { Uart_SendBufferLen = UsartNrf3_Send_PackDevControl((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + Index_Para, 1 + ((Index_Para + 4) / 16), 16); Index_Para = Index_Para + 16; } } } if(TotalIndex_Para <= (Index_Para + 1)) { if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { ProtocalLayer_Cmd = ToTransLayer_Send;//Transport layer CurSendRecLastPackageNO = TotalIndex_Para / 16; memset((u8 *)SubData3, 0, MAX_TRANS_DAT_DATA_LEN); } } } /*********************************************** ** Function name: Three-generation protocol device control transport layer transmission ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Send_DevControlUpdate(u8 *target_adr, u8 *rout_adr) { if(CurSendRecLostPackageNO >= CurSendRecLastPackageNO) { if(CurSendRecLastPackageNO > 0) { Uart_SendBufferLen = UsartNrf3_Send_PackDevControl(target_adr, rout_adr, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + (14 + (CurSendRecLostPackageNO - 1) * 16), (CurSendRecLastPackageNO + 1) | 0x80, TotalIndex_Para - (14 + ((CurSendRecLostPackageNO - 1) * 16))); } else { Uart_SendBufferLen = UsartNrf3_Send_PackDevControl(target_adr, rout_adr, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data, (CurSendRecLastPackageNO + 1) | 0x80, TotalIndex_Para); } } else { if(CurSendRecLostPackageNO == 0) { Uart_SendBufferLen = UsartNrf3_Send_PackDevControl(target_adr, rout_adr, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data, CurSendRecLostPackageNO + 1, 16); } else { Uart_SendBufferLen = UsartNrf3_Send_PackDevControl(target_adr, rout_adr, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + (14 + (CurSendRecLostPackageNO - 1) * 16), CurSendRecLostPackageNO + 1, 16); } } } /*********************************************** ** Function name: Three-generation protocol device control transmission application layer transmission ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Send_DevControl(void) { if(ProtocalLayer_Cmd == InitLayer) { if(UsartNrf_HasSetCurrentInverterOk()) { UsartNrf_Send_DevControlUpdate((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id); //Application layer } } else { if(UsartNrf3_HasSetCurrentInverterOk()) { UsartNrf3_Send_DevControlUpdate((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id); //Transport layer } } } /*********************************************** ** Function name: Three-generation protocol grid-connected protection file transport layer packaging ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ u8 UsartNrf3_Send_PackUpdateGridOnProFile(u8 *target_adr, u8 *rout_adr) { if(RightGridOnProFile == true) { if(CurSendRecLostPackageNO >= CurSendRecLastPackageNO) { if(CurSendRecLastPackageNO > 0) { Uart_SendBufferLen = UsartNrf_Send_PackGridOnProFile_SigleFrame(target_adr, rout_adr, CurRowData_Dat + (CurSendRecLostPackageNO * 16), (CurSendRecLostPackageNO + 1) | 0x80, (u8)(TotalIndex_Dat - (CurSendRecLostPackageNO * 16))); } else { Uart_SendBufferLen = UsartNrf_Send_PackGridOnProFile_SigleFrame(target_adr, rout_adr, CurRowData_Dat, (CurSendRecLostPackageNO + 1) | 0x80, (u8)(TotalIndex_Dat)); } } else { Uart_SendBufferLen = UsartNrf_Send_PackGridOnProFile_SigleFrame(target_adr, rout_adr, CurRowData_Dat + (CurSendRecLostPackageNO * 16), CurSendRecLostPackageNO + 1, 16); } } return (u8)TotalIndex_Dat; } /*********************************************** ** Function name: Three-generation protocol transmission, application layer transmission ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Send_DownLoadDat(void) { if(ProtocalLayer_Cmd == InitLayer) { if(UsartNrf_HasSetCurrentInverterOk()) { UsartNrf_Send_PackUpdateGridOnProFile((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id); //Application layer } } else { if(UsartNrf3_HasSetCurrentInverterOk()) { UsartNrf3_Send_PackUpdateGridOnProFile((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id); //Transport layer } } } /*********************************************** ** Function name: Three-generation protocol parameter setting, application layer transmission ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf_Send_UpdatePara(u8 *target_adr, u8 *rout_adr) { vu8 AdminPasswd[4] = {10, 16, 50, 82}; if(SubCmd == EleEnergySet) { TotalIndex_Para = 18; // MIMajor[PortNO].Property.Pass.EletricSet.Info[1] = 0x0f; // MIMajor[PortNO].Property.Pass.EletricSet.Info[0] = 0x00; } else if(SubCmd == AntitheftParaSet) { TotalIndex_Para = 10; if(MIReal[PortNO].Data.NetCmd == NET_CANCEL_GUARD) { if(memcmp((u8 *)AdminPasswd, (u8 *)Dtu3Detail.Property.LockOldPassword, 4) == 0) { memset((u8 *)Dtu3Detail.Property.LockNewPassword, 0, 4); memset((u8 *)Dtu3Detail.Property.LockOldPassword, 0xff, 4); memcpy((u8 *)MIMajor[PortNO].Property.Pass.PassWordSet.PWO, (u8 *)Dtu3Detail.Property.LockOldPassword, 4); memcpy((u8 *)MIMajor[PortNO].Property.Pass.PassWordSet.PWN, (u8 *)Dtu3Detail.Property.LockNewPassword, 4); memcpy((u8 *)MIMajor[PortNO].Property.Pass.PassWordSet.ATTime, (u8 *)Dtu3Detail.Property.Lock_Time, 2); } else { MIReal[PortNO].Data.NetStatus = NET_EXECUTION_FAILURE; } } else if(MIReal[PortNO].Data.NetCmd == NET_SET_PASSWORD) { memcpy((u8 *)MIMajor[PortNO].Property.Pass.PassWordSet.PWO, (u8 *)Dtu3Detail.Property.LockOldPassword, 4); memcpy((u8 *)MIMajor[PortNO].Property.Pass.PassWordSet.PWN, (u8 *)Dtu3Detail.Property.LockNewPassword, 4); memcpy((u8 *)MIMajor[PortNO].Property.Pass.PassWordSet.ATTime, (u8 *)Dtu3Detail.Property.Lock_Time, 2); } } if(TotalIndex_Para <= 12)//Only 1 frame { Uart_SendBufferLen = UsartNrf3_Send_PackSetPara((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data, 0x81, TotalIndex_Para); Index_Para = TotalIndex_Para - 1; } else //Multi-frame { if(((TotalIndex_Para - 1) - Index_Para) <= 14) { Uart_SendBufferLen = UsartNrf3_Send_PackSetPara((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + Index_Para, 0x81 + ((Index_Para + 4) / 16), TotalIndex_Para - Index_Para); Index_Para = TotalIndex_Para - 1; ProtocalLayer_Cmd = ToTransLayer_Send;//Transport layer } else { if(Index_Para == 0) { Uart_SendBufferLen = UsartNrf3_Send_PackSetPara((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + Index_Para, 1 + ((Index_Para + 4) / 16), 14); Index_Para = Index_Para + 14; } else { Uart_SendBufferLen = UsartNrf3_Send_PackSetPara((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + Index_Para, 1 + ((Index_Para + 4) / 16), 16); Index_Para = Index_Para + 16; } } } if(TotalIndex_Para <= (Index_Para + 1)) { if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { ProtocalLayer_Cmd = ToTransLayer_Send;//Transport layer CurSendRecLastPackageNO = TotalIndex_Para / 16; memset((u8 *)SubData3, 0, MAX_TRANS_DAT_DATA_LEN); } } } /*********************************************** ** Function name: Three-generation protocol parameter setting, transport layer transmission ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Send_UpdatePara(u8 *target_adr, u8 *rout_adr) { if(CurSendRecLostPackageNO >= CurSendRecLastPackageNO) { if(CurSendRecLastPackageNO > 0) { Uart_SendBufferLen = UsartNrf3_Send_PackSetPara(target_adr, rout_adr, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + (14 + (CurSendRecLostPackageNO - 1) * 16), (CurSendRecLastPackageNO + 1) | 0x80, TotalIndex_Para - (14 + ((CurSendRecLostPackageNO - 1) * 16))); } else { Uart_SendBufferLen = UsartNrf3_Send_PackSetPara(target_adr, rout_adr, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data, (CurSendRecLastPackageNO + 1) | 0x80, TotalIndex_Para); } } else { if(CurSendRecLostPackageNO == 0) { Uart_SendBufferLen = UsartNrf3_Send_PackSetPara(target_adr, rout_adr, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data, CurSendRecLostPackageNO + 1, 16); } else { Uart_SendBufferLen = UsartNrf3_Send_PackSetPara(target_adr, rout_adr, (u16)(SubCmd << 8), (u8 *)MIMajor[PortNO].Property.Pass.Data + (14 + (CurSendRecLostPackageNO - 1) * 16), CurSendRecLostPackageNO + 1, 16); } } } /*********************************************** ** Function name: Three-generation protocol parameter setting, transmission, application layer transmission ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Send_ParaSet(void) { if(ProtocalLayer_Cmd == InitLayer) { if(UsartNrf_HasSetCurrentInverterOk()) { UsartNrf_Send_UpdatePara((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id); //Application layer } } else { if(UsartNrf3_HasSetCurrentInverterOk()) { UsartNrf3_Send_UpdatePara((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id); //Transport layer } } } /*********************************************** ** Function name: Three-generation protocol single-send and multiple-receive transport layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_One_MultiPackage(u8 *pBuffer) { vu8 i = 0; vu16 TempCrc, DatCrc = 0xffff; for(i = 11; i < 16; i++) { if((i - 11) % 2 == 1) { TempCrc = (u16)(pBuffer[i - 1] << 8) | (pBuffer[i]); DatCrc = CalcCRC16t(TempCrc, DatCrc); } } if((((u16)pBuffer[11 + 4] << 8) | pBuffer[11 + 5]) != DatCrc) { Uart_CurrentReplyState = 0x01 << 4; // The high four digits indicate the abnormal state of the transport layer receipt } else { if(pBuffer[13] == 0x01) { ProtocalLayer_Poll = ToAppLayer;//This data collection is not supported Uart_CurrentReplyState = 0x01 << 5; // The high four digits indicate the abnormal state of the transport layer receipt } else if(pBuffer[13] == 0X02) { ProtocalLayer_Poll = ToAppLayer;// Indicates data corruption (such as grid-connected rule files, hard configuration information such as grid-connected rule files, hard configuration information such as grid-connected rule files, hard configuration information such as grid-connected rule files, hard configuration information such as grid-connected rule files, hard configuration information such as grid-connected rule files, hard configuration information such as grid-connected rule files, hard configuration information, calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc., calibration parameter system, etc.) Uart_CurrentReplyState = 0x01 << 6; // The high four digits indicate the abnormal state of the transport layer receipt } else if(pBuffer[13] == 0X07) { Uart_CurrentReplyState = 0x01 << 7;//Indicates that the command length is wrong } else if(pBuffer[13] == 0X08) { Uart_CurrentReplyState = 0x01 << 8;//Indicates that the firmware is damaged } else if(pBuffer[13] == 0X09) { Uart_CurrentReplyState = 0x01 << 9;//Indicates that the firmware is damaged//indicates that the firmware is normal } else if(pBuffer[13] == 0X0a) { Uart_CurrentReplyState = 0x01 << 10;//Indicates that the diagnostic data is empty } else { } } } /*********************************************** ** Function name: Three-generation protocol multiple billing and receiving transport layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_Multi_OnePackage(u8 *pBuffer) { vu8 i = 0; vu16 TempCrc, DatCrc = 0xffff; for(i = 11; i < 11 + 14; i++) { if((i - 11) % 2 == 1) { TempCrc = (u16)(pBuffer[i - 1] << 8) | (pBuffer[i]); DatCrc = CalcCRC16t(TempCrc, DatCrc); } } if((((u16)pBuffer[11 + 14] << 8) | pBuffer[11 + 15]) != DatCrc) { ProtocalLayer_Cmd = ToTransLayer_Process;//CRC error Uart_CurrentReplyState = 0x01 << 4; memset((u8 *)SubData3, 0, MAX_TRANS_DAT_DATA_LEN); } else { if((pBuffer[11] >> 7) == 0x01) //CRC error { ProtocalLayer_Cmd = ToAppLayer; Uart_CurrentReplyState = 0x01 << 4; // The high four digits indicate an additional error } else if((pBuffer[11] >> 7) == 0x00) //Missing frame { ProtocalLayer_Cmd = ToTransLayer_Process;//Transport layer missing frame reissue memcpy((u8 *)SubData3, &pBuffer[11], MAX_TRANS_DAT_DATA_LEN); SubData3[(14 - (CurSendRecLastPackageNO / 8)) - 1] = (u8)(~(1 << (CurSendRecLastPackageNO % 8))&SubData3[(14 - (CurSendRecLastPackageNO / 8)) - 1]); } else { } } } /*********************************************** ** Function name: Three-generation protocol micro-inverse program update application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DownLoadPro(u8 *pBuffer) { ProtocalLayer_Cmd = ToAppLayer; Uart_CurrentReplyState = pBuffer[15]; memcpy((u8 *)Uart_CurrentReplyAddr, &(pBuffer[11]), 4); if(Uart_CurrentReplyState == 0) { MIReal[PortNO].Data.NetStatus = (u8)((Index_Pro * 100) / TotalIndex_Pro); if(MIReal[PortNO].Data.NetStatus == 0) { MIReal[PortNO].Data.NetStatus = 1; } if((memcmp((u8 *)Uart_CurSendAddr, (u8 *)Uart_CurrentReplyAddr, 4) == 0) && ((Uart_CurrentReplyAddr[0] == 0) && (Uart_CurrentReplyAddr[1] == 0) && (Uart_CurrentReplyAddr[2] == 0) && (Uart_CurrentReplyAddr[3] == 0x01))) { memset((u8 *)Uart_CurSendAddr, 0, 4); MIReal[PortNO].Data.NetStatus = NET_EXECUTION_COMPLETED; UsartNrf3_Process_ClearMIVersion(); InverterDetail_Write((InverterDetail *)&MIDetail, PortNO, 1);//Inverter RF hardware and software version Uart_CurrentReplyState = 0; RightHexFile = false; CurNetCmd = NET_INIT; } else { MIReal[PortNO].Data.NetStatus = (u8)((Index_Pro * 100) / TotalIndex_Pro); if(MIReal[PortNO].Data.NetStatus == 0) { MIReal[PortNO].Data.NetStatus = 1; } } } else { if((Uart_CurrentReplyState >= 1) && (Uart_CurrentReplyState <= 5)) { Index_Dat = 0; RightHexFile = false; } } } /*********************************************** ** Function name: Three-generation protocol grid-connected protection file application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DownLoadDat(u8 *pBuffer) { ProtocalLayer_Cmd = ToAppLayer; Uart_CurrentReplyState = pBuffer[11]; if(Uart_CurrentReplyState == 0) { if(CurRowData_Dat != NULL) { myfree(CurRowData_Dat); CurRowData_Dat = NULL; } RightGridOnProFile = false; MIReal[PortNO].Data.NetStatus = NET_EXECUTION_COMPLETED; CurNetCmd = NET_INIT; } else if((Uart_CurrentReplyState == 2) || (Uart_CurrentReplyState == 3)) //2--- File incompatible, 3 EEPROM read and write errors { Index_Dat = 0; RightGridOnProFile = false; } } /*********************************************** ** Function name: Three-generation protocol micro-inverse, so the operation is sent ** Descriptions: ** input parameters: ** output parameters: ** Returned value: *************************************************/ void UsartNrf3_Send_PackNrfCmd(void) { if(CurNetCmd == NET_DOWNLOAD_DAT) { UsartNrf3_Send_DownLoadDat();//Upgrade the grid-connected protection program } else if(CurNetCmd == NET_DOWNLOAD_PRO) { UsartNrf3_Send_DownLoadPro();//Upgrade micro reverse firmware } else if((CurNetCmd == NET_INVERTER_HW_INFOR) || (CurNetCmd == NET_TERMINAL_INFOR) || (CurNetCmd == NET_POLL_GRID_ON_FILE)) { UsartNrf3_Send_PackPollVersionCmd();// Third-generation protocol package polling version } else if((CurNetCmd == NET_TURN_ON) || (CurNetCmd == NET_TURN_OFF) || (CurNetCmd == NET_LIMIT_POEWR) || (CurNetCmd == NET_RESTART) || (CurNetCmd == NET_LOCK) || (CurNetCmd == NET_UNLOCK) || (CurNetCmd == NET_LIMIT_REACTIVE_POWER) || (CurNetCmd == NET_LIMIT_ACTIVE_POEWR) || (CurNetCmd == NET_PF_SET) || (CurNetCmd == NET_CLEAR_ALARM) || (CurNetCmd == NET_CLEAN_GFDI) //dong 2020-06-15 || (CurNetCmd == NET_SELF_INSPECTION)) { UsartNrf3_Send_DevControl();//Device control command } else if((CurNetCmd == NET_SET_ENERGY) || (CurNetCmd == NET_ELE_ENERGY) || (CurNetCmd == NET_SET_PASSWORD) || (CurNetCmd == NET_CANCEL_GUARD)) { UsartNrf3_Send_ParaSet(); } else { } } /*********************************************** ** Function name: Whether the status of the receipt of the third-generation agreement is ok ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ bool UsartNrf3_SendLoop_ReplyOK(void) { if(Uart_CurSendMainCmd == REQ_RF_RVERSISON) { if(Uart_CurRecMainCmd == ANSWER_REQ_RF_RVERSISON) { return true; } else { return false; } } else if(Uart_CurSendMainCmd == REQ_ARW_DAT_ALL) { if((Uart_CurRecMainCmd == ANSWER_REQ_ARW_DAT_ALL) && (Uart_CurRecSubCmd == GetLossRate)) { ProtocalLayer_Poll = InitLayer; Uart_CurRecSubCmd = 0; return true; } else { if((Uart_CurRecMainCmd == ANSWER_REQ_ARW_DAT_ALL) && (Uart_CurrentReplyState == 0) && (ProtocalLayer_Poll == ToAppLayer)) { ProtocalLayer_Poll = InitLayer; return true; } else { return false; } } } else if(Uart_CurSendMainCmd == DOWN_DAT) { if((Uart_CurRecMainCmd == ANSWER_DOWN_DAT) && (Uart_CurrentReplyState == 0) && (ProtocalLayer_Cmd == ToAppLayer)) { ProtocalLayer_Cmd = InitLayer; //Both the transport layer and the application layer are correct; return true; } else { return false; } } else if(Uart_CurSendMainCmd == DOWN_PRO) { if((Uart_CurRecMainCmd == ANSWER_DOWN_PRO) && (Uart_CurrentReplyState == 0) && (ProtocalLayer_Cmd == ToAppLayer)) { ProtocalLayer_Cmd = InitLayer; //Both the transport layer and the application layer are correct; return true; } else { return false; } } else if(Uart_CurSendMainCmd == CHANGE_MOD_2M_250K) { return true; } else { return false; } return true; } /*********************************************** ** Function name: Three-generation protocol single-send and multiple-receive transport layer replenishment mechanism ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ bool UsartNrf3_Send_One_MultiPackage(u8 *pTransLayerPollCnt) { vu8 j; CurRecSendLostPackageNO++; if(CurRecSendLostPackageNO >= TotalPackageNum) { CurRecSendLostPackageNO = 0; if(Uart_CurrentReplyState == (0x01 << 4)) { (*pTransLayerPollCnt)++; } } if((*pTransLayerPollCnt) >= TRANSLAYER_CYCLES)//Resend timeout { Uart_SendBufferLen = 0; Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; CurRecSendLostPackageState = 0; (*pTransLayerPollCnt) = 0; TotalPackageNum = 0; return true; } else { if(TotalPackageNum <= 0) { return false; } for(j = CurRecSendLostPackageNO; j < TotalPackageNum; j++) { if(((CurRecSendLostPackageState >> j) & 0x01) == 0x00) { CurRecSendLostPackageNO = j; return false; } } for(j = 0; j < CurRecSendLostPackageNO; j++) { if(((CurRecSendLostPackageState >> j) & 0x01) == 0x00) { CurRecSendLostPackageNO = j; return false; } } } return false; } /*********************************************** ** Function name: Three-generation protocol multiple billing and receiving transport layer replenishment mechanism ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ bool UsartNrf3_Send_Multi_OnePackage(u8 *pTransLayerCnt) { vs8 i, j; CurSendRecLostPackageNO++; if(CurSendRecLostPackageNO > CurSendRecLastPackageNO) { CurSendRecLostPackageNO = 0; if(Uart_CurrentReplyState == 0x10) { (*pTransLayerCnt)++; //Resend cycle count } } if((*pTransLayerCnt) >= TRANSLAYER_CYCLES)//Resend timeout { Uart_SendBufferLen = 0; Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; (*pTransLayerCnt) = 0; Uart_CurrentReplyState = 0; return true; } else { j = CurSendRecLostPackageNO % 8; for(i = 14 - (CurSendRecLostPackageNO / 8) - 1; i >= 11; i--) { for(j = j; j < 8; j++) { if(((SubData3[i] >> j) & 0x01) == 0x00) { CurSendRecLostPackageNO = (u8)(j + (14 - i - 1) * 8); return false; } } j = 0; } } return false; } /*********************************************** ** Function name: Three-generation protocol device control and parameter setting transmission application layer resend mechanism ** Descriptions: ** input parameters: ? ** Returned value: ? ** output parameters: ? *************************************************/ bool UsartNrf3_HasSetCurrentInverterOk() { static vu8 TransLayerCmdCnt = 0, AppLayerCmdCnt = 0; static vu8 TransLayerProCnt = 0; volatile bool HasOverTime = false; // dong 2020-05-12 Modified from greater than to greater than or equal to if((LocalTime >= LocalTime_TaskTimeOut) && (LocalTime_TaskTimeOut > 0)) { AppLayerCmdCnt = APPLAYER_CYCLES + 1; ProtocalLayer_Cmd = ToAppLayer; HasOverTime = true; UsartNrf3_SendLoop_SetTaskTimeOut(true);//Set the task timeout } if(UsartNrf3_SendLoop_ReplyOK() == true) { TransLayerCmdCnt = 0; AppLayerCmdCnt = 0; if((Uart_CurSendMainCmd != 0) && (Uart_CurSendMainCmd != CHANGE_MOD_2M_250K)) { Uart_SendBufferLen = 0; Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; return UsartNrf_SendLoop_GetNextSetCmd(); } else { Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; return true;//Baud rate You need to send a network command after receiving the receipt } } else { if((Uart_CurSendMainCmd != 0) && (Uart_CurSendMainCmd != CHANGE_MOD_2M_250K)) { if((MIReal[PortNO].Data.NetCmd == NET_DOWNLOAD_DAT) || ((MIReal[PortNO].Data.NetCmd == NET_ELE_ENERGY) || (MIReal[PortNO].Data.NetCmd == NET_SET_PASSWORD) || (MIReal[PortNO].Data.NetCmd == NET_CANCEL_GUARD)) || (((CurNetCmd == NET_TURN_ON) || (CurNetCmd == NET_TURN_OFF) || (CurNetCmd == NET_LIMIT_POEWR) || (CurNetCmd == NET_SET_ENERGY) || (CurNetCmd == NET_RESTART) || (CurNetCmd == NET_LOCK) || (CurNetCmd == NET_UNLOCK) || (CurNetCmd == NET_LIMIT_REACTIVE_POWER) || (CurNetCmd == NET_LIMIT_ACTIVE_POEWR) || (CurNetCmd == NET_PF_SET) || (CurNetCmd == NET_CLEAR_ALARM) || (CurNetCmd == NET_CLEAN_GFDI) //dong 2020-06-15 || (CurNetCmd == NET_SELF_INSPECTION) ))) { if(ProtocalLayer_Cmd == ToTransLayer_Process) { if(UsartNrf3_Send_Multi_OnePackage((u8 *)&TransLayerCmdCnt)) { MIReal[PortNO].Data.NetStatus = NET_EXECUTION_FAILURE; CurNetCmd = NET_INIT; if(MIReal[PortNO].Data.NetCmd == NET_DOWNLOAD_DAT) { RightGridOnProFile = false; if(CurRowData_Dat != NULL) { myfree(CurRowData_Dat); CurRowData_Dat = NULL; } } ProtocalLayer_Cmd = InitLayer; return UsartNrf_SendLoop_GetNextSetCmd(); } } else if(ProtocalLayer_Cmd == ToTransLayer_Send) { CurSendRecLostPackageNO = CurSendRecLastPackageNO; } else if(ProtocalLayer_Cmd == ToAppLayer)//Application layer { if(((MIReal[PortNO].Data.NetCmd == NET_DOWNLOAD_DAT) && (((Uart_CurrentReplyState > 1) && (Uart_CurrentReplyState <= 3)) || (Uart_CurrentReplyState == 0x10))) //Parameter crc error 1, network-connected file is not compatible 2, eeprom read and write error 3 || (((MIReal[PortNO].Data.NetCmd == NET_ELE_ENERGY) || (MIReal[PortNO].Data.NetCmd == NET_SET_PASSWORD) || (MIReal[PortNO].Data.NetCmd == NET_CANCEL_GUARD)) && (((Uart_CurrentReplyState > 1) && (Uart_CurrentReplyState <= 3)) || (Uart_CurrentReplyState == 0x10))) || (((CurNetCmd == NET_TURN_ON) || (CurNetCmd == NET_TURN_OFF) || (CurNetCmd == NET_LIMIT_POEWR) || (CurNetCmd == NET_SET_ENERGY) || (CurNetCmd == NET_RESTART) || (CurNetCmd == NET_LOCK) || (CurNetCmd == NET_UNLOCK) || (CurNetCmd == NET_LIMIT_REACTIVE_POWER) || (CurNetCmd == NET_LIMIT_ACTIVE_POEWR) || (CurNetCmd == NET_PF_SET) || (CurNetCmd == NET_CLEAR_ALARM) || (CurNetCmd == NET_CLEAN_GFDI) || (CurNetCmd == NET_SELF_INSPECTION)) //dong 2020-06-15 && ((((Uart_CurrentReplyState == 3) && (Uart_CurrentReplyState == 4)) || (Uart_CurrentReplyState == 7))))) { TransLayerCmdCnt = 0; memset((u8 *)SubData3, 0, MAX_TRANS_DAT_DATA_LEN); AppLayerCmdCnt++; ProtocalLayer_Cmd = InitLayer; Index_Dat = 0; Index_Para = 0; Uart_CurrentReplyState = 0; } if(AppLayerCmdCnt > APPLAYER_CYCLES) { AppLayerCmdCnt = 0; Uart_SendBufferLen = 0; Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; memset((u8 *)SubData3, 0, MAX_TRANS_DAT_DATA_LEN); Index_Dat = 0; Index_Para = 0; Uart_CurrentReplyState = 0; ProtocalLayer_Cmd = InitLayer; if(MIReal[PortNO].Data.NetCmd == NET_DOWNLOAD_DAT) { //Grid_Profiles_Data_Delete(); if(CurRowData_Dat != NULL) { myfree(CurRowData_Dat); CurRowData_Dat = NULL; } } MIReal[PortNO].Data.NetStatus = NET_EXECUTION_FAILURE; CurNetCmd = NET_INIT; RightGridOnProFile = false; return UsartNrf_SendLoop_GetNextSetCmd(); } return false; } else { return true; } } else if(MIReal[PortNO].Data.NetCmd == NET_DOWNLOAD_PRO) { if(ProtocalLayer_Cmd == ToTransLayer_Process)//Transport layer { if(UsartNrf3_Send_Multi_OnePackage((u8 *)&TransLayerCmdCnt)) { ProtocalLayer_Cmd = InitLayer; TransLayerProCnt++; if(TransLayerProCnt >= APPLAYER_CYCLES_PRO) { TransLayerProCnt = 0; MIReal[PortNO].Data.NetStatus = NET_EXECUTION_FAILURE; CurNetCmd = NET_INIT; RightHexFile = false; if(CurRowData_Pro != NULL) { myfree(CurRowData_Pro); CurRowData_Pro = NULL; } if(string != NULL) { myfree(string); string = NULL; } return UsartNrf_SendLoop_GetNextSetCmd(); } } } else if(ProtocalLayer_Cmd == ToTransLayer_Send) { CurSendRecLostPackageNO = CurSendRecLastPackageNO; } else if(ProtocalLayer_Cmd == ToAppLayer)//Application layer { if(((Uart_CurrentReplyState >= 2) && (Uart_CurrentReplyState <= 7)) || (Uart_CurrentReplyState == 0x10) || (HasOverTime == true)) //Parameter crc error 1, incompatible with grid-connected files 2, eeprom read and write error 3 { TransLayerCmdCnt = 0; memset((u8 *)SubData3, 0, MAX_TRANS_DAT_DATA_LEN); AppLayerCmdCnt++; ProtocalLayer_Cmd = InitLayer; Index_Pro = 0; RightHexFile = false; Uart_CurrentReplyState = 0; if(AppLayerCmdCnt >= APPLAYER_CYCLES) { AppLayerCmdCnt = 0; if(CurRowData_Pro != NULL) { myfree(CurRowData_Pro); CurRowData_Pro = NULL; } if(string != NULL) { myfree(string); string = NULL; } MIReal[PortNO].Data.NetStatus = NET_EXECUTION_FAILURE; return UsartNrf_SendLoop_GetNextSetCmd(); } } return true; } else { return true; } } else { return true; } } else { Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; return true; } } return true; } /*********************************************** ** Function name: Set the task-level timeout time for the third-generation protocol ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_SendLoop_SetTaskTimeOut(bool Stop) { if(Stop == true) { LocalTime_TaskTimeOut = LocalTime; } else { if((CurNetCmd >= NET_TURN_ON) && (CurNetCmd <= NET_ELE_ENERGY))//Command and configuration { switch(CurNetCmd) { case NET_DOWNLOAD_DAT: case NET_POLL_GRID_ON_FILE: //6S LocalTime_TaskTimeOut = LocalTime + TASK_CONFIG_GRID_ON_FILE; break; case NET_DOWNLOAD_PRO: if(LineCnt_Pro == 1) { LocalTime_TaskTimeOut = LocalTime + TASK_DOWNLOAD_SECOND_LINE; } else if((TotalIndex_Pro - Index_Pro) <= 76) { LocalTime_TaskTimeOut = LocalTime + TASK_DOWNLOAD_LAST_LINE; } else { LocalTime_TaskTimeOut = LocalTime + TASK_DOWNLOAD_OTHER_LINE; } break; case NET_ELE_ENERGY: case NET_SET_ENERGY: LocalTime_TaskTimeOut = LocalTime + TASK_CONFIG_ELE_ENERGY; break; case NET_SET_PASSWORD: LocalTime_TaskTimeOut = LocalTime + TASK_CONFIG_ANTITHEFT; break; case NET_CLEAR_ALARM: case NET_CLEAN_GFDI: LocalTime_TaskTimeOut = LocalTime + TASK_DEV_CONTROL_ALARM_CLEAR; break; case NET_TURN_ON: case NET_TURN_OFF: LocalTime_TaskTimeOut = LocalTime + TASK_DEV_CONTROL_TURN_ONOFF; break; case NET_RESTART: LocalTime_TaskTimeOut = LocalTime + TASK_DEV_CONTROL_RESTART; break; case NET_LOCK: case NET_UNLOCK: LocalTime_TaskTimeOut = LocalTime + TASK_DEV_CONTROL_LOCK_UNLOCK ; break; case NET_LIMIT_ACTIVE_POEWR: case NET_PF_SET: case NET_LIMIT_REACTIVE_POWER: LocalTime_TaskTimeOut = LocalTime + TASK_DEV_CONTROL_POWER_PF_ADJUST ; break; //dong 2020-06-15 case NET_SELF_INSPECTION: LocalTime_TaskTimeOut = LocalTime + TASK_SELF_CHECK0; break; default: LocalTime_TaskTimeOut = LocalTime + LOCAL_TIME_1S; break; } } else //Data polling { switch(CurNetCmd) { case NET_REGISTER_ID: LocalTime_TaskTimeOut = LocalTime + TASK_TRANS_DATA_RUNDATA_REALITY + LOCAL_TIME_1S; break; case NET_INIT: LocalTime_TaskTimeOut = LocalTime + TASK_TRANS_DATA_RUNDATA_REALITY; break; case NET_ALARM_DATA: case NET_ALARM_UPDATE: LocalTime_TaskTimeOut = LocalTime + TASK_TRANS_DATA_ALARM; break; case NET_RECORD_DATA: LocalTime_TaskTimeOut = LocalTime + TASK_TRANS_DATA_RECORD_DATA; break; case NET_INVERTER_HW_INFOR: case NET_MI_VERSION: LocalTime_TaskTimeOut = LocalTime + TASK_TRANS_DATA_INFORM_SIMPLE; break; case NET_GET_LOSS_RATE: LocalTime_TaskTimeOut = LocalTime + LOCAL_TIME_100MS; break; default: break; } } } } /*********************************************** ** Function name: Search for the next micro-inverse or component serial number ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Send_SearchNextPannelOrInv(void) { Uart_SendBufferLen = 0; Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) == Inverter_HM_OneToFour) { PortNO = PortNO + 4; } else if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) == Inverter_HM_OneToTwo) { PortNO = PortNO + 2; } else if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) == Inverter_HM_OneToOne) { PortNO = PortNO + 1; } else { PortNO = PortNO + 4; } } else { PortNO++; } if(PortNO >= Dtu3Detail.Property.PortNum) { PortNO = 0; } //dong The meaning of execution if((CurAlarmState == AlarmInforUpdate_App) || ((CurAlarmState != AlarmInforUpdate_App) && (CurNetCmd != NET_INIT))) { return; } for(PortNO = PortNO; PortNO < Dtu3Detail.Property.PortNum; PortNO++) { if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { if(CurPollIsDebugDataTime == true) { CurNetCmd = NET_INIT; return; } else { if(((MIReal[PortNO].Data.LinkState & MI_CONNECT) >> 1) != 1) { CurNetCmd = NET_INIT; return; } } } else { return; } } } /*********************************************** ** Function name: Three-generation protocol 15min all alarm storage ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_AlarmFlashWriteEvery15Min(void) { if(RealAlarmDataNO > 0) { //Alarm_Data_Write(&pRealAlarm, RealAlarmDataNO + 1); // Write alarm data to flash RealAlarmDataNO = 0; // if(pRealAlarm != NULL) // { // myfree(pRealAlarm); // pRealAlarm = NULL; // } } } /*********************************************** ** Function name: Three-generation protocol app status switch ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ bool UsartNrf3_AppStateSwitch(u8 TotalCnt, u8 SucCnt) { //dong 2020-0515 // static vu8 AppPollCnt = 0; // static vu8 RecieveDataCnt = 0; static vu16 PortNO_DataBreak = 0; static vu16 PortNO_RateBreak = 0; static vu16 PortNO_SigleStart = 0; vu16 i; if(AppState == PollAllMi) { if(CurNetCmd == NET_ALARM_UPDATE) { UsartNrf3_Send_SearchNextPannelOrInv();//Traverse to the next component or micro-inverse InverterDetail_Read((InverterDetail *)&MIDetail, PortNO, 1); if((MIDetail.Property.AppFWBuild_VER == 0) && (MIDetail.Property.HW_VER == 0)) { CurNetCmd = NET_MI_VERSION; } else { CurNetCmd = NET_INIT; } } else if(CurNetCmd == NET_MI_VERSION) { CurNetCmd = NET_INIT; } else { if(PortNO_App == Dtu3Detail.Property.PortNum) { PortNO = Dtu3Detail.Property.PortNum - 1; PortNO_App = 0; } else if(PortNO_App == (Dtu3Detail.Property.PortNum + 1)) { PortNO = PortNO_DataBreak; PortNO_App = 0; } else { PortNO_DataBreak = PortNO; } #ifdef DEBUG0610 printf("3174--NET_ALARM_UPDATE\n\r"); #endif CurNetCmd = NET_ALARM_UPDATE; } if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { UsartNrf3_SendLoop_SetTaskTimeOut(false);//Set the task timeout CurRecSendLostPackageState = 0; return true; } else { UsartNrf3_SendLoop_SetTaskTimeOut(true);//Set the task timeout return true; } } else if(AppState == PollSigleMi) { if(PortNO_App < Dtu3Detail.Property.PortNum) { PortNO = PortNO_App; PortNO_App = Dtu3Detail.Property.PortNum; PortNO_SigleStart = PortNO; } if(CurNetCmd == NET_ALARM_UPDATE) { if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) < Inverter_Pro) { if(PORT_NUMBER_CONFIRMATION2(PortNO)) { PortNO = PortNO_SigleStart; } else { UsartNrf3_Send_SearchNextPannelOrInv();//Traverse to the next component or micro-inverse } } if((MIDetail.Property.AppFWBuild_VER == 0) && (MIDetail.Property.HW_VER == 0)) { CurNetCmd = NET_MI_VERSION; } else { CurNetCmd = NET_INIT; } } else if(CurNetCmd == NET_MI_VERSION) { CurNetCmd = NET_INIT; } else { #ifdef DEBUG0610 printf("3230--NET_ALARM_UPDATE\n\r"); #endif CurNetCmd = NET_ALARM_UPDATE; } if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { UsartNrf3_SendLoop_SetTaskTimeOut(false);//Set the task timeout CurRecSendLostPackageState = 0; return true; } else { UsartNrf3_SendLoop_SetTaskTimeOut(true);//Set the task timeout return true; } } //Statistics of all micro-inverse communication status else if(AppState == AllMiLossRate) { if(PortNO_App == Dtu3Detail.Property.PortNum) { PortNO = 0; PortNO_App = 0; AppPollCnt = 0; RecieveDataCnt = 0; Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; for(i = 0; i < Dtu3Detail.Property.PortNum; i++) { MIReal[i].Data.NetStatus = 0; } TotalCnt = 0; SucCnt = 0; } else if(PortNO_App == (Dtu3Detail.Property.PortNum + 1)) { PortNO = PortNO_RateBreak; AppPollCnt = 0; RecieveDataCnt = 0; Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; PortNO_App = 0; } else { PortNO_RateBreak = PortNO; } if(AppPollCnt > 21) { if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { /*hzwang_20200421 */ // if(((pDataCnt->MI_CF_Num_End != 0) && (pDataCnt->MI_CF_Num_Start != 0)) && (pDataCnt->MI_CF_Num_End != pDataCnt->MI_CF_Num_Start)) // { // MIReal[PortNO].Data.NetStatus = (abs(pDataCnt->MI_CF_Num_End - pDataCnt->MI_CF_Num_Start)) * 100 / abs(pDataCnt->MI_RF_Num_End - pDataCnt->MI_RF_Num_Start); // } // else // { MIReal[PortNO].Data.NetStatus = RecieveDataCnt * 100 / 20; // } /*Modify the third-generation micro-inverse connection status counting method*/ if(pDataCnt != NULL) { myfree(pDataCnt); pDataCnt = NULL; } } else { MIReal[PortNO].Data.NetStatus = RecieveDataCnt * 100 / 20; } RecieveDataCnt = 0; AppPollCnt = 0; UsartNrf3_Send_SearchNextPannelOrInv();//Traverse to the next component or micro-inverse for(i = 0; i < 4; i++) { if(PORT_NUMBER_CONFIRMATION(PortNO)) { break; } else { UsartNrf3_Send_SearchNextPannelOrInv(); //Traverse to the next component or micro-inverse } } } else { //dong 2020-0515 // if(SucCnt >= 1) // { // RecieveDataCnt = RecieveDataCnt + SucCnt; // AppPollCnt = AppPollCnt + TotalCnt; // } // else // { // AppPollCnt = AppPollCnt + TotalCnt; // } } if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { CurNetCmd = NET_GET_LOSS_RATE; UsartNrf3_SendLoop_SetTaskTimeOut(false);//Set the task timeout CurRecSendLostPackageState = 0; if(pDataCnt == NULL) { pDataCnt = mymalloc(sizeof(DataCntType)); // if(pDataCnt == NULL) // { // return 0; // } pDataCnt->MI_CF_Num_End = 0; pDataCnt->MI_RF_Num_End = 0; pDataCnt->MI_CF_Num_Start = 0; pDataCnt->MI_RF_Num_Start = 0; } return true; } else { CurNetCmd = NET_INIT; UsartNrf3_SendLoop_SetTaskTimeOut(true);//Set the task timeout return true; } } //Communication status statistics of a single micro-inverse else if(AppState == ManuSigleLossRate) { if(PortNO_App < Dtu3Detail.Property.PortNum) { PortNO = PortNO_App; AppPollCnt = 0; RecieveDataCnt = 0; Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; PortNO_App = Dtu3Detail.Property.PortNum; } if(AppPollCnt >= 100) { if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { // /*hzwang_20200421 */ // if(((pDataCnt->MI_CF_Num_End != 0) && (pDataCnt->MI_CF_Num_Start != 0)) && (pDataCnt->MI_CF_Num_End != pDataCnt->MI_CF_Num_Start)) // { // MIReal[PortNO].Data.NetStatus = (abs(pDataCnt->MI_CF_Num_End - pDataCnt->MI_CF_Num_Start)) * 100 / abs(pDataCnt->MI_RF_Num_End - pDataCnt->MI_RF_Num_Start); // } // else // { MIReal[PortNO].Data.NetStatus = RecieveDataCnt; // } /*Modify the third-generation micro-inverse connection status counting method*/ if(pDataCnt != NULL) { myfree(pDataCnt); pDataCnt = NULL; } } else { MIReal[PortNO].Data.NetStatus = RecieveDataCnt; } AppPollCnt = 0; RecieveDataCnt = 0; MIReal[PortNO].Data.Real_Time = RTC_Getsecond(); } else { //dong 2020-0515 // if(SucCnt >= 1) // { // RecieveDataCnt = RecieveDataCnt + SucCnt; // AppPollCnt = AppPollCnt + TotalCnt; // } // else // { // AppPollCnt = AppPollCnt + TotalCnt; // } } if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { CurNetCmd = NET_GET_LOSS_RATE; UsartNrf3_SendLoop_SetTaskTimeOut(false);//Set the task timeout CurRecSendLostPackageState = 0; if(pDataCnt == NULL) { pDataCnt = mymalloc(sizeof(DataCntType)); // if(pDataCnt == NULL) // { // return 0; // } pDataCnt->MI_CF_Num_End = 0; pDataCnt->MI_RF_Num_End = 0; pDataCnt->MI_CF_Num_Start = 0; pDataCnt->MI_RF_Num_Start = 0; } return true; } else { UsartNrf3_SendLoop_SetTaskTimeOut(true);//Set the task timeout CurNetCmd = NET_INIT; return true; } } else { AppPollCnt = 0; RecieveDataCnt = 0; } return false; } /*********************************************** ** Function name: The third-generation protocol suspends the alarm search when networking ** Descriptions: ** input parameters: false--> next loop true--> next component ** output parameters: ? ** Returned value: ? *************************************************/ bool UsartNrf3_AlarmInformationSearch(void) { for(PortNO_Alarm_Server = PortNO_Alarm_Server; PortNO_Alarm_Server < Dtu3Detail.Property.PortNum ; PortNO_Alarm_Server++) { if((UsartNrf_GetInvterType((u8 *)MIMajor[PortNO_Alarm_Server].Property.Pre_Id) >= Inverter_Pro) && (PORT_NUMBER_CONFIRMATION(PortNO_Alarm_Server))) { #ifdef DEBUG0610 printf("3462--NET_ALARM_UPDATE\n\r"); #endif CurNetCmd = NET_ALARM_UPDATE; UsartNrf3_SendLoop_SetTaskTimeOut(false);//Set the task timeout PortNO = PortNO_Alarm_Server; PortNO_Alarm_Server++; CurRecSendLostPackageState = 0; TotalPackageNum = 0; Uart_CurrentReplyState = 0; #if DEBUG0610 printf("PortNO_Alarm:%d--PortNum:%d\n\r", PortNO_Alarm_Server, Dtu3Detail.Property.PortNum); #endif return true; } } if(PortNO_Alarm_Server >= Dtu3Detail.Property.PortNum) { CurAlarmState = InitState; CurNetCmd = NET_INIT; PortNO_Alarm_Server = 0; CurRecSendLostPackageState = 0; //dong 2020-05-20 Does the serial number of the pending alarm need to be recorded synchronously? // CurInformAlarmNum = ((u16)pInformAlarm[InformAlarmDataNO].Data.WNum[0]) | pInformAlarm[InformAlarmDataNO].Data.WNum[1]; // CurRealAlarmNum = WarnSerNub[PortNO]; //At the end of the round of training, if there are not enough 20 items, it must be stored #ifdef DEBUG0619 printf("AlarmInfo_Write:%d", InformAlarmDataNO); #endif AlarmInfo_Write((AlarmDataType *)&pInformAlarm, InformAlarmDataNO); //Write alarm data to flash InformAlarmDataNO = 0; memset((AlarmDataType *)pInformAlarm, 0, 20 * sizeof(AlarmDataType)); PortNO = PortNO_Alarm_Server; return true; } return false; } /*********************************************** ** Function name: The third-generation protocol forces polling version and real-time data ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? ************************************************/ bool UsartNrf3_PollRealTimeWithVersion(void) { vu8 i; if(CurNetCmd == NET_GET_LOSS_RATE) { return true; } if(CurNetCmd == NET_MI_VERSION) { CurNetCmd = NET_INIT; if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { UsartNrf3_SendLoop_SetTaskTimeOut(false);//Set the task timeout Uart_SendBufferLen = 0; Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; CurRecSendLostPackageState = 0; NeedLostPackageState = 0; TotalPackageNum = 0; Uart_CurrentReplyState = 0; return true; } else { UsartNrf3_SendLoop_SetTaskTimeOut(true);//Set the task timeout return true; } } else { for(i = 0; i < 4; i++) { UsartNrf3_Send_SearchNextPannelOrInv();//Traverse to the next component or micro-inverse if((PORT_NUMBER_CONFIRMATION(PortNO)) || (PORT_NUMBER_CONFIRMATION1(PortNO))) { break; } } InverterDetail_Read((InverterDetail *)&MIDetail, PortNO, 1); if((MIDetail.Property.AppFWBuild_VER == 0) && (MIDetail.Property.HW_VER == 0)) { CurNetCmd = NET_MI_VERSION; } else { CurNetCmd = NET_INIT; } if(UsartNrf_GetInvterType((u8 *)MIMajor[PortNO].Property.Pre_Id) >= Inverter_Pro) { UsartNrf3_SendLoop_SetTaskTimeOut(false);//Set the task timeout // UsartNrf3_Process_LedShow(false); Uart_SendBufferLen = 0; Uart_CurSendMainCmd = 0; Uart_CurRecMainCmd = 0; CurRecSendLostPackageState = 0; NeedLostPackageState = 0; TotalPackageNum = 0; Uart_CurrentReplyState = 0; return true; } else { UsartNrf_Process_LedShow(false, 10); UsartNrf3_SendLoop_SetTaskTimeOut(true);//Set the task timeout return true; } } return false; } /*********************************************** ** Function name: Three-generation protocol transmission application layer polling and resending mechanism ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? ************************************************/ bool UsartNrf3_HasPollCurInverterPort(void) { static vu8 TransLayerPollCnt = 0, AppLayerPollCnt = 0; vu16 i; // dong 2020-05-12 Modified from greater than to greater than or equal to if((LocalTime >= LocalTime_TaskTimeOut) && (LocalTime_TaskTimeOut > 0)) { //APP if(CurAlarmState == AlarmInforUpdate_App) { //dong 2020-0515 UsartNrf3_AppStateSwitch(1, 0); // return UsartNrf3_AppStateSwitch(1, 0); } //Pending alarm else if(CurAlarmState == AlarmInforUpdate_Server) { #ifdef DEBUG0610 printf("AlarmInforUpdate_Server -- 3634\n\r"); #endif return UsartNrf3_AlarmInformationSearch(); } else { CurAlarmState = InitState; if(CurNetCmd == NET_INVERTER_HW_INFOR) { if(MIReal[PortNO].Data.NetStatus == NET_NOT_EXECUTED) { MIReal[PortNO].Data.NetStatus = NET_EXECUTION_FAILURE; UsartNrf_ClearVersionActionState(); } memset((InverterDetail *)&MIDetail, 0, sizeof(InverterDetail)); //Clear MIDetail InverterDetail_Read((InverterDetail *)&MIDetail, PortNO, 1); //Read UsartNrf_Process_Version_InitInverterRf();//Fill in 0 InverterDetail_Write((InverterDetail *)&MIDetail, PortNO, 1); //Write 0 UsartNrf3_PollRealTimeWithVersion(); return false; } else if(CurNetCmd == NET_POLL_GRID_ON_FILE) { MIReal[PortNO].Data.NetStatus = NET_EXECUTION_FAILURE; UsartNrf3_PollRealTimeWithVersion(); LocalTime_TaskTimeOut = 0; return false; } else { return UsartNrf3_PollRealTimeWithVersion(); } } } else { if(((MIReal[PortNO].Data.NetCmd != NET_INVERTER_HW_INFOR) && (MIReal[PortNO].Data.NetStatus != NET_NOT_EXECUTED)) || ((MIReal[PortNO].Data.NetCmd != NET_POLL_GRID_ON_FILE) && (MIReal[PortNO].Data.NetStatus != NET_NOT_EXECUTED))) { for(i = 0; i < Dtu3Detail.Property.PortNum; i++) { if(((MIReal[i].Data.NetCmd >= NET_TURN_ON) && (MIReal[i].Data.NetCmd <= NET_ELE_ENERGY) && ((MIReal[i].Data.NetCmd != NET_WAIT_DOWNLOAD_DAT) && (MIReal[i].Data.NetCmd != NET_WAIT_DOWNLOAD_PRO))) && ((MIReal[i].Data.NetStatus == NET_NOT_EXECUTED) || (MIReal[i].Data.NetStatus == LOCAL_NOT_EXECUTED))) { PortNO = i; CurNetCmd = MIReal[i].Data.NetCmd; CurRecSendLostPackageState = 0; TotalPackageNum = 0; UsartNrf3_SendLoop_SetTaskTimeOut(false);//Set the task timeout return false; } } } } if(UsartNrf3_SendLoop_ReplyOK() == true) { if((Uart_CurSendMainCmd != 0) && (Uart_CurSendMainCmd != CHANGE_MOD_2M_250K) && (Uart_CurSendMainCmd != REQ_RF_RVERSISON)) { if(CurAlarmState == HasNewAlarmRecord) { CurNetCmd = NET_ALARM_DATA; UsartNrf3_SendLoop_SetTaskTimeOut(false);//Set the task timeout return true; } else if(CurAlarmState == HasNewWaveRecord) { CurNetCmd = NET_RECORD_DATA; UsartNrf3_SendLoop_SetTaskTimeOut(false);//Set the task timeout return true; } else if(CurAlarmState == AlarmInforUpdate_App) { #ifdef DEBUG0610 printf("AlarmInforUpdate_Server -- 3712\n\r"); #endif return UsartNrf3_AppStateSwitch(1, 1); } else if(CurAlarmState == AlarmInforUpdate_Server) { return UsartNrf3_AlarmInformationSearch(); } else { AppLayerPollCnt = 0; TransLayerPollCnt = 0; return UsartNrf3_PollRealTimeWithVersion(); } } else { return true; //next component } } else { if((((ProtocalLayer_Poll == ToTransLayer_Send) || (ProtocalLayer_Poll == ToTransLayer_Process)) && (UsartNrf3_Send_One_MultiPackage((u8 *)&TransLayerPollCnt))) || (ProtocalLayer_Poll == ToAppLayer)) { ProtocalLayer_Poll = InitLayer; TransLayerPollCnt = 0; if((Uart_CurrentReplyState == 0x10) || (Uart_CurrentReplyState == 0x20) || (Uart_CurrentReplyState == (0x01 << 6))) { AppLayerPollCnt++; } Uart_CurrentReplyState = 0; if(AppLayerPollCnt > APPLAYER_CYCLES) { AppLayerPollCnt = 0; CurAlarmState = InitState; return UsartNrf3_PollRealTimeWithVersion(); } } } return true; } /*********************************************** ** Function name: Three-generation protocol polling software version transmission ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Send_PackPollVersionCmd(void) { if(UsartNrf3_HasPollCurInverterPort()) { if((TotalPackageNum <= 0) && (CurRecSendLostPackageState != 0)) { Uart_SendBufferLen = UsartNrf3_Send_PackPollSigleDataCommand((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, 0x7f); } else { if(CurRecSendLostPackageState != 0) { Uart_SendBufferLen = UsartNrf3_Send_PackPollSigleDataCommand((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, CurRecSendLostPackageNO + 1); } else { Uart_SendBufferLen = UsartNrf3_Send_PackPollMultiDataCommand((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id, (u8)(SubCmd), 0, (u8 *)Dtu3Detail.Property.LockNewPassword); } } ProtocalLayer_Poll = ToTransLayer_Send; } else { return; } } /*********************************************** ** Function name: Three-generation protocol device control application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_DevControl(u8 *pBuffer) { Uart_CurrentReplyState = pBuffer[11]; if(Uart_CurSendSubCmd != (((u16)pBuffer[14] << 8) | pBuffer[13])) { return; } switch(Uart_CurrentReplyState) { case 0: // The command was executed successfully //dong 2020-06-15 Grid-connected protection file self-check command is processed separately if(Uart_CurSendSubCmd == Type_SelfInspection) { //Improper response to self-test status, do network command processing MIReal[PortNO].Data.NetCmd = NET_SELF_STAUS; MIReal[PortNO].Data.NetStatus = NET_NOCMD; SelfCheckStateFlg = 1; } else { MIReal[PortNO].Data.NetStatus = NET_EXECUTION_COMPLETED; ProtocalLayer_Cmd = InitLayer; Index_Para = 0; CurNetCmd = NET_INIT; } break; case 3: //eeprom read and write error Index_Para = 0; break; case 4: //This command is not supported MIReal[PortNO].Data.NetStatus = NET_EXECUTION_FAILURE; ProtocalLayer_Cmd = InitLayer; Index_Para = 0; CurNetCmd = NET_INIT; break; case 7: // Abnormal length of configuration parameter Index_Para = 0; break; default: break; } } /*********************************************** ** Function name: Three-generation protocol micro-inverse parameter setting application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_ParaSet(u8 *pBuffer) { Uart_CurrentReplyState = pBuffer[11]; if(Uart_CurSendSubCmd != (((u16)pBuffer[14] << 8) | pBuffer[13])) { return; } switch(Uart_CurrentReplyState) { case 0: // The command was executed successfully MIReal[PortNO].Data.NetStatus = NET_EXECUTION_COMPLETED; ProtocalLayer_Cmd = InitLayer; Index_Para = 0; if((CurNetCmd == NET_SET_PASSWORD) || (CurNetCmd == NET_CANCEL_GUARD)) { memcpy((u8 *)Dtu3Detail.Property.LockNewPassword, (u8 *)MIMajor[PortNO].Property.Pass.PassWordSet.PWN, 4); memcpy((u8 *)Dtu3Detail.Property.Lock_Time, (u8 *)MIMajor[PortNO].Property.Pass.PassWordSet.ATTime, 2); System_Dtu_Info_Write((DtuDetail *)&Dtu3Detail, (DtuMajor *)&Dtu3Major); } CurNetCmd = NET_INIT; break; case 3: //eeprom read and write error Index_Para = 0; break; case 4: //This command is not supported MIReal[PortNO].Data.NetStatus = NET_EXECUTION_FAILURE; CurNetCmd = NET_INIT; Index_Para = 0; break; case 6: // Parameter error Index_Para = 0; break; case 7: // Abnormal length of configuration parameter Index_Para = 0; break; default: break; } } /*********************************************** ** Function name: Three-generation protocol micro-inverse program update transport layer transmission ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Send_PackUpdateMiProgram(u8 *target_adr, u8 *rout_adr) { if(RightHexFile == true) { if(CurSendRecLostPackageNO >= CurSendRecLastPackageNO) { if(CurRowTotalLen % 16 == 0) { Uart_SendBufferLen = UsartNrf_Send_MiProgram_SigleFrame(target_adr, rout_adr, CurRowData_Pro + CurSendRecLostPackageNO * 16, 0x80 | (CurSendRecLostPackageNO + 1), 2); } else { Uart_SendBufferLen = UsartNrf_Send_MiProgram_SigleFrame(target_adr, rout_adr, CurRowData_Pro + CurSendRecLostPackageNO * 16, 0x80 | (CurSendRecLostPackageNO + 1), CurRowTotalLen % 16); } } else { Uart_SendBufferLen = UsartNrf_Send_MiProgram_SigleFrame(target_adr, rout_adr, CurRowData_Pro + CurSendRecLostPackageNO * 16, 0x00 | (CurSendRecLostPackageNO + 1), 16); } } } /*********************************************** ** Function name: Three-generation protocol micro-inverse program update transmission application layer transmission ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Send_DownLoadPro(void) { if((ProtocalLayer_Cmd == InitLayer) || (ProtocalLayer_Cmd == ToAppLayer)) { if(UsartNrf_HasSetCurrentInverterOk()) { UsartNrf_Send_PackUpdateMiProgram((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id); } } else { if(UsartNrf3_HasSetCurrentInverterOk()) { UsartNrf3_Send_PackUpdateMiProgram((u8 *)MIMajor[PortNO].Property.Id, (u8 *)MIMajor[PortNO].Property.Id); } } } /*********************************************** ** Function name: Three-generation protocol application layer receipt processing ** Descriptions: ** input parameters: ? ** output parameters: ? ** Returned value: ? *************************************************/ void UsartNrf3_Process_Pro(u8 *pBuffer) { switch(pBuffer[1]) { //dong 2020-06-23 case 0x86: if((AppState == AllMiLossRate) || (AppState == ManuSigleLossRate)) { //dong if(RecieveDataCnt < 100) { RecieveDataCnt++; #ifdef DEBUGSIGNAL printf("-RRR:T:%d-D:%d-S:%d-R:%d\n\r", LocalTime, PortNO, AppPollCnt, RecieveDataCnt); #endif } } break; case ANSWER_REQ_ARW_DAT_ALL: UsartNrf3_Process_DevInform(pBuffer); break; case ANSWER_DOWN_DAT: UsartNrf3_Process_DownLoadDat(pBuffer); break; case ANSWER_DOWN_PRO: UsartNrf3_Process_DownLoadPro(pBuffer); break; case ANSWER_DEVCONTROL_ALL: UsartNrf3_Process_DevControl(pBuffer); break; case ANSWER_PARASET_ALL: UsartNrf3_Process_ParaSet(pBuffer); break; // case ANSWER_EXCEPTION_ONE_MULTI: // UsartNrf3_Process_One_MultiPackage(pBuffer); // break; case ANSWER_EXCEPTION_MULTI_ONE: UsartNrf3_Process_Multi_OnePackage(pBuffer); break; default: break; } }