完善智能分配

DcPillar/Src/SmartAllocation/Drv_SmartAllocation.c

@@ -13,28 +13,28 @@ StructDcModuleGroup DcModuleGroup[] =
 		{
 			1, 0, 0, 0, 2, 0, 0, 0
 		},
-		Invalid, 0, 0
+		Invalid, 0, 0, 0
 	},
 	{
 		1, 0, 
 		{
 			3, 0, 0, 0, 0, 0, 0, 0
 		},
-		Invalid, 0, 0
+		Invalid, 0, 0, 0
 	},
 	{
 		2, 0, 
 		{
 			4, 0, 0, 0, 5, 0, 0, 0
 		},
-		Invalid, 0, 0
+		Invalid, 0, 0, 0
 	},
 	{
 		1, 0, 
 		{
 			6, 0, 0, 0, 0, 0, 0, 0
 		},
-		Invalid, 0, 0
+		Invalid, 0, 0, 0
 	},
 };
 
@@ -70,13 +70,6 @@ void DcModuleManageProcess_SmartAllocation(void)
 	u32 			Volt, Volt_A, Volt_B;
 	u8				status;
 
-	static u32 Tick = 0;
-	if ((GetSystemTick() -Tick) < 10)
-    {
-      return;
-     
-    }
-	Tick = GetSystemTick();
 
 	StructDcModuleSend DataSend;
 
@@ -117,7 +110,8 @@ void DcModuleManageProcess_SmartAllocation(void)
 		}
 	}
 
-
+	if(CheckTick == 0) CheckTick = GetSystemTick();
+	
 	if ((GetSystemTick() -CheckTick) < 100)
 		return;
 
@@ -148,7 +142,7 @@ void DcModuleManageProcess_SmartAllocation(void)
 		Flag				= Flag << 1;
 	}
 
-	//DcModuleManage_All.ValidNum = Count;
+
 	for (i = 0; i < DcModuleGroupSize; i++)
 	{
 		Currt				= 0;
@@ -218,6 +212,7 @@ void DcModuleManageProcess_SmartAllocation(void)
 		}
 		else if (DcModuleGroup[i].status == Hold_A)
 		{
+			if(DcModuleGroup[i].flag) continue;
 			Volt_A				+= DcModuleGroup[i].Voltage;
 			Currt_A 			+= DcModuleGroup[i].Current;
 			Count_A 			+= DcModuleGroup[i].ValidNum;
@@ -225,6 +220,7 @@ void DcModuleManageProcess_SmartAllocation(void)
 		}
 		else if (DcModuleGroup[i].status == Hold_B)
 		{
+			if(DcModuleGroup[i].flag) continue;
 			Volt_B				+= DcModuleGroup[i].Voltage;
 			Currt_B 			+= DcModuleGroup[i].Current;
 			Count_B 			+= DcModuleGroup[i].ValidNum;
@@ -272,8 +268,9 @@ void DcModuleCtrlProcess_SmartAllocation(void)
 	static u8		LastFlag_A = 0;
 	static u8		LastFlag_B = 0;
 
-	static u32 Tick = 0;
-	if ((GetSystemTick() -Tick) < 10)
+	static u32 Tick = 0;//
+        if(Tick==0) Tick=GetSystemTick();
+	if ((GetSystemTick() -Tick) < 100)
     {
       return;
      
@@ -294,9 +291,10 @@ void DcModuleCtrlProcess_SmartAllocation(void)
 	u8				addr;
 	u32 			Volt = 0;
 	u8				Cmd = 0;
-
+	u32 			Value = 0;
 	Temp				= 0;
 
+	//释放继电器
 	for (u8 i = 0; i < DcModuleGroupSize; i++)
 	{
 		if (status[i] != DcModuleGroup[i].status)
@@ -352,6 +350,7 @@ void DcModuleCtrlProcess_SmartAllocation(void)
 
 				//Volt = DcModuleAbility.MinVolt * 100;
 				Cmd 				= 0xAA; 		//关机
+				DcModuleGroup[i].flag = 0;
 			}
 			else if (DcModuleGroup[i].status == Hold_A)
 			{
@@ -392,14 +391,14 @@ void DcModuleCtrlProcess_SmartAllocation(void)
 				DataSend.Len		= 8;
 				DataSend.Data[0]	= 0x00;
 				DataSend.Data[1]	= 0x00;
-				Temp				= DcModuleAbility.MinCurrt * 100;
-				DataSend.Data[2]	= (u8) (Temp >> 8);
-				DataSend.Data[3]	= (u8) (Temp >> 0);
-				Temp				= Volt; 		//DcModuleAbility.MinVolt * 100;
-				DataSend.Data[4]	= (u8) (Temp >> 24);
-				DataSend.Data[5]	= (u8) (Temp >> 16);
-				DataSend.Data[6]	= (u8) (Temp >> 8);
-				DataSend.Data[7]	= (u8) (Temp >> 0);
+				Value				= DcModuleAbility.MinCurrt * 100;
+				DataSend.Data[2]	= (u8) (Value >> 8);
+				DataSend.Data[3]	= (u8) (Value >> 0);
+				Value				= Volt; 		//DcModuleAbility.MinVolt * 100;
+				DataSend.Data[4]	= (u8) (Value >> 24);
+				DataSend.Data[5]	= (u8) (Value >> 16);
+				DataSend.Data[6]	= (u8) (Value >> 8);
+				DataSend.Data[7]	= (u8) (Value >> 0);
 
 				//放入队列
 				if (pdTRUE != xQueueSend(DcModeMsg, &DataSend, 0))
@@ -432,9 +431,124 @@ void DcModuleCtrlProcess_SmartAllocation(void)
 
 	if (Temp)
 		return;
+	Temp				= 0;
+	//检测升压完成
+	
+	for (u8 i = 0; i < DcModuleGroupSize; i++)
+	{
+		if (DcModuleGroup[i].status == Hold_A && i != 0)
+		{
+			if(abs((s32)(DcModuleGroup[i].Voltage*100) - (s32)DcModuleManage.SetVolt) >10000)
+			{
+				Temp++;
+				for (u8 j = 0; j < DcModuleGroup[i].num; j++)
+				{
+					addr				= DcModuleGroup[i].modules[j].addr;
+
+					DataSend.Id 		= 0x1307C080 + addr;
+					DataSend.Len		= 8;
+					DataSend.Data[0]	= 0x00;
+					DataSend.Data[1]	= 0x00;
+
+					Value				= DcModuleAbility.MinCurrt * 100;
+					DataSend.Data[2]	= (u8) (Value >> 8);
+					DataSend.Data[3]	= (u8) (Value >> 0);
+					Value				= DcModuleManage.SetVolt;
+					DataSend.Data[4]	= (u8) (Value >> 24);
+					DataSend.Data[5]	= (u8) (Value >> 16);
+					DataSend.Data[6]	= (u8) (Value >> 8);
+					DataSend.Data[7]	= (u8) (Value >> 0);
+
+					//放入队列
+					if (pdTRUE != xQueueSend(DcModeMsg, &DataSend, 0))
+					{
+						//osDelay(10);
+					}
+
+					DcModuleManage.Cmd	= 0x55; 		//开机
+					DataSend.Id 		= 0x1307C080 + addr;
+					DataSend.Len		= 8;
+					DataSend.Data[0]	= 0x02;
+					DataSend.Data[1]	= 0x00;
+					DataSend.Data[2]	= 0x00;
+					DataSend.Data[3]	= 0x00;
+					DataSend.Data[4]	= 0x00;
+					DataSend.Data[5]	= 0x00;
+					DataSend.Data[6]	= 0x00;
+					DataSend.Data[7]	= DcModuleManage.Cmd;
+
+					//放入队列
+					if (pdTRUE != xQueueSend(DcModeMsg, &DataSend, 0))
+					{
+						//osDelay(10);
+					}
+				}
+			}
+			else
+			{
+				DcModuleGroup[i].flag = 0;
+			}
+		}
+		else if (DcModuleGroup[i].status == Hold_B && i != 2)
+		{
+			if(abs((s32)(DcModuleGroup[i].Voltage*100) - (s32)DcModuleManage_B.SetVolt) >10000)
+			{
+				Temp++;
+				for (u8 j = 0; j < DcModuleGroup[i].num; j++)
+				{
+					addr				= DcModuleGroup[i].modules[j].addr;
+
+					DataSend.Id 		= 0x1307C080 + addr;
+					DataSend.Len		= 8;
+					DataSend.Data[0]	= 0x00;
+					DataSend.Data[1]	= 0x00;
+
+					Value				= DcModuleAbility.MinCurrt * 100;
+					DataSend.Data[2]	= (u8) (Value >> 8);
+					DataSend.Data[3]	= (u8) (Value >> 0);
+					Value				= DcModuleManage_B.SetVolt;
+					DataSend.Data[4]	= (u8) (Value >> 24);
+					DataSend.Data[5]	= (u8) (Value >> 16);
+					DataSend.Data[6]	= (u8) (Value >> 8);
+					DataSend.Data[7]	= (u8) (Value >> 0);
+
+					//放入队列
+					if (pdTRUE != xQueueSend(DcModeMsg, &DataSend, 0))
+					{
+						//osDelay(10);
+					}
 
+					DcModuleManage_B.Cmd	= 0x55; 		//开机
+					DataSend.Id 		= 0x1307C080 + addr;
+					DataSend.Len		= 8;
+					DataSend.Data[0]	= 0x02;
+					DataSend.Data[1]	= 0x00;
+					DataSend.Data[2]	= 0x00;
+					DataSend.Data[3]	= 0x00;
+					DataSend.Data[4]	= 0x00;
+					DataSend.Data[5]	= 0x00;
+					DataSend.Data[6]	= 0x00;
+					DataSend.Data[7]	= DcModuleManage_B.Cmd;
+
+					//放入队列
+					if (pdTRUE != xQueueSend(DcModeMsg, &DataSend, 0))
+					{
+						//osDelay(10);
+					}
+				}
+			}
+			else
+			{
+				DcModuleGroup[i].flag = 0;
+			}
+		}
+	}
+
+	if (Temp)
+		return;
 	Temp				= 0;
 
+	//切换继电器输出
 	for (u8 i = 0; i < DcModuleGroupSize; i++)
 	{
 		if (status1[i] != DcModuleGroup[i].status)
@@ -508,7 +622,7 @@ void DcModuleCtrlProcess_SmartAllocation(void)
 
 	if (Temp)
 		return;
-
+	
 	if (LastFlag_A != DcModuleCtrl.CtrlFlag)
 	{
 		LastFlag_A			= DcModuleCtrl.CtrlFlag;
@@ -729,6 +843,7 @@ void release_DcModule(u8 flag)
 			{
 				DcModuleGroup[i].status = Valid;
 				DcModuleManage_B.ValidNum -= DcModuleGroup[i].ValidNum;
+				DcModuleGroup[i].flag = 0;
 			}
 		}
 		else if(flag == 2)
@@ -737,6 +852,7 @@ void release_DcModule(u8 flag)
 			{
 				DcModuleGroup[i].status = Valid;
 				DcModuleManage_B.ValidNum -= DcModuleGroup[i].ValidNum;
+				DcModuleGroup[i].flag = 0;
 			}
 		}
 	}

DcPillar/Src/SmartAllocation/Drv_SmartAllocation.h

@@ -27,6 +27,7 @@ typedef struct
   StructDcModuleUsedStatus status;
   u32 Voltage;
   u32 Current;
+  u8 flag;
 }StructDcModuleGroup;
 
 

DcPillar/Src/SmartAllocation/Drv_SmartAllocation_DcModule.c

@@ -263,6 +263,7 @@ void DcModuleSet(EnumSwitchStatus Set, u16 Volt, u16 Currt)
 		{
 			DcModuleGroup[0].status = Hold_A;
 			DcModuleManage_B.ValidNum -= DcModuleGroup[0].ValidNum;
+			DcModuleManage.ValidNum += DcModuleGroup[0].ValidNum;
 		}
 		else if(DcModuleGroup[0].status == Valid)
 		{
@@ -338,7 +339,7 @@ void DcModule(void const * parameter)
 
 		//osDelay(15);
 		DcModuleCtrlProcess_SmartAllocation();
-		osDelay(10);
+		osDelay(5);
 	}
 }
 
@@ -381,6 +382,7 @@ void DcModuleSet_B(EnumSwitchStatus Set, u16 Volt, u16 Currt)
 		{
 			DcModuleGroup[2].status = Hold_B;
 			DcModuleManage.ValidNum -= DcModuleGroup[2].ValidNum;
+			DcModuleManage_B.ValidNum += DcModuleGroup[2].ValidNum;
 		}
 		else if(DcModuleGroup[2].status == Valid)
 		{

DcPillar/Src/SmartAllocation/SmartAllocation_B_ChgRun.c

@@ -119,9 +119,9 @@ void ChgProChgRun_B(StructChargeCtrl_B *pChargeCtrl)
 			NeedCurrt = abs((s32)BclMsg_B.NeedCurrt - 4000);
 
 			static s16 GetCurrt_bak;
-			static u32		ReleaseDcModuleTick = 0;
+			
 			if(abs((s16)GetDcModuleCurrt_B()-GetCurrt_bak)<10 //ȶ
-				&& (abs((s16)NeedCurrt-(s16)GetDcModuleCurrt_B())>(DcModuleAbility.MaxCurrt))
+				&& (abs((s16)NeedCurrt-(s16)(DcModuleAbility.MaxCurrt*DcModuleManage_B.ValidNum))>(DcModuleAbility.MaxCurrt))
 			)
 			{
 				if(0 == UniChgTick)
@@ -129,41 +129,36 @@ void ChgProChgRun_B(StructChargeCtrl_B *pChargeCtrl)
 
 				if((GetSystemTick() - UniChgTick) > (10 * 1000))
 				{
-					if(NeedCurrt > GetDcModuleCurrt_B())
+					if(NeedCurrt > (DcModuleAbility.MaxCurrt*DcModuleManage_B.ValidNum) \
+						&& DcModuleGroup[0].flag == 0 \
+						&& DcModuleGroup[1].flag == 0 \
+						&& DcModuleGroup[3].flag == 0 )
 					{
 						if(DcModuleGroup[3].status == Valid)
 						{
 							DcModuleGroup[3].status = Hold_B;
-							DcModuleManage_B.ValidNum += DcModuleGroup[3].ValidNum;
+							//DcModuleManage_B.ValidNum += DcModuleGroup[3].ValidNum;
+							DcModuleGroup[3].flag = 1;
 						}
 						else if(DcModuleGroup[1].status == Valid)
 						{
 							DcModuleGroup[1].status = Hold_B;
-							DcModuleManage.ValidNum += DcModuleGroup[1].ValidNum;
+							//DcModuleManage.ValidNum += DcModuleGroup[1].ValidNum;
+							DcModuleGroup[1].flag = 1;
 						}
 						else if(DcModuleGroup[0].status == Valid)
 						{
 							DcModuleGroup[0].status = Hold_B;
-							DcModuleManage.ValidNum += DcModuleGroup[0].ValidNum;
+							//DcModuleManage.ValidNum += DcModuleGroup[0].ValidNum;
+							DcModuleGroup[0].flag = 1;
+							if(DcModuleGroup[1].status == Hold_B)
+							{
+								DcModuleGroup[1].status = Valid;
+								DcModuleManage.ValidNum -= DcModuleGroup[1].ValidNum;
+							}
 						}
 					}
-					else
-					{
-						
-					}
-					UniChgTick = 0;
-				}
-			}
-			else if(abs((s16)GetDcModuleCurrt_B()-GetCurrt_bak)<10 //输出电流稳定
-				&& (abs((s16)NeedCurrt-(s16)(DcModuleAbility.MaxCurrt*DcModuleManage_B.ValidNum))>(DcModuleAbility.MaxCurrt))
-			)
-			{
-				if(0 == ReleaseDcModuleTick)
-					ReleaseDcModuleTick = GetSystemTick();
-
-				if((GetSystemTick() - ReleaseDcModuleTick) > (10 * 1000))
-				{
-					if(NeedCurrt < (DcModuleAbility.MaxCurrt*DcModuleManage_B.ValidNum))
+					else if(NeedCurrt < (DcModuleAbility.MaxCurrt*DcModuleManage_B.ValidNum))
 					{
 						if(DcModuleGroup[0].status == Hold_B)
 						{
@@ -181,14 +176,14 @@ void ChgProChgRun_B(StructChargeCtrl_B *pChargeCtrl)
 							DcModuleManage.ValidNum -= DcModuleGroup[3].ValidNum;
 						}
 					}
-					ReleaseDcModuleTick = 0;
+					
+					UniChgTick = 0;
 				}
 			}
 			else
 			{
 
 				UniChgTick = 0;
-				ReleaseDcModuleTick = 0;
 				GetCurrt_bak = GetDcModuleCurrt_B();
 			}
 

DcPillar/Src/SmartAllocation/SmartAllocation_ChgRun.c

@@ -127,32 +127,36 @@ void ChgProChgRun(StructChargeCtrl * pChargeCtrl)
 			NeedCurrt			= abs((s32) BclMsg.NeedCurrt - 4000);
 
 			static s16		GetCurrt_bak;
-			static u32		ReleaseDcModuleTick = 0;
 			if (abs((s16) GetDcModuleCurrt() -GetCurrt_bak) < 10 //ȶ
-			&& (abs((s16) NeedCurrt - (s16) GetDcModuleCurrt()) > (DcModuleAbility.MaxCurrt)))
+			&& (abs((s16) NeedCurrt - (s16)(DcModuleManage.ValidNum*DcModuleAbility.MaxCurrt)) > (DcModuleAbility.MaxCurrt)))
 			{
 				if (0 == UniChgTick)
 					UniChgTick = GetSystemTick();
 
 				if ((GetSystemTick() -UniChgTick) > (10 * 1000))
 				{
-					if (NeedCurrt > GetDcModuleCurrt())
+					if (NeedCurrt > (DcModuleManage.ValidNum*DcModuleAbility.MaxCurrt) \
+						&& DcModuleGroup[1].flag == 0\
+						&& DcModuleGroup[2].flag == 0\
+						&& DcModuleGroup[3].flag == 0)
 					{
 						if (DcModuleGroup[1].status == Valid)
 						{
 							DcModuleGroup[1].status = Hold_A;
 							DcModuleManage.ValidNum += DcModuleGroup[1].ValidNum;
+							DcModuleGroup[1].flag = 1;
 						}
 						else if (DcModuleGroup[3].status == Valid)
 						{
 							DcModuleGroup[3].status = Hold_A;
 							DcModuleManage.ValidNum += DcModuleGroup[3].ValidNum;
+							DcModuleGroup[3].flag = 1;
 						}
 						else if (DcModuleGroup[2].status == Valid)
 						{
 							DcModuleGroup[2].status = Hold_A;
 							DcModuleManage.ValidNum += DcModuleGroup[2].ValidNum;
-
+							DcModuleGroup[2].flag = 1;
 							if (DcModuleGroup[3].status == Hold_A)
 							{
 								DcModuleGroup[3].status = Valid;
@@ -160,21 +164,7 @@ void ChgProChgRun(StructChargeCtrl * pChargeCtrl)
 							}
 						}
 					}
-					
-					UniChgTick			= 0;
-
-				}
-
-			}
-			else if (abs((s16) GetDcModuleCurrt() -GetCurrt_bak) < 10 //ȶ
-			&& (abs((s16) NeedCurrt - (s16)(DcModuleAbility.MaxCurrt * DcModuleManage.ValidNum)) > (DcModuleAbility.MaxCurrt)))
-			{
-				if (0 == ReleaseDcModuleTick)
-					ReleaseDcModuleTick = GetSystemTick();
-
-				if ((GetSystemTick() -ReleaseDcModuleTick) > (10 * 1000))
-				{
-					if(NeedCurrt < (DcModuleAbility.MaxCurrt * DcModuleManage.ValidNum))
+					else if(NeedCurrt < (DcModuleAbility.MaxCurrt * DcModuleManage.ValidNum))
 					{
 						if (DcModuleGroup[2].status == Hold_A)
 						{
@@ -192,13 +182,15 @@ void ChgProChgRun(StructChargeCtrl * pChargeCtrl)
 							DcModuleManage.ValidNum -= DcModuleGroup[1].ValidNum;
 						}
 					}
-					ReleaseDcModuleTick = 0;
+					
+					UniChgTick			= 0;
+
 				}
+
 			}
 			else 
 			{
 				UniChgTick			= 0;
-				ReleaseDcModuleTick = 0;
 				GetCurrt_bak		= GetDcModuleCurrt();
 			}