Skip to content

D
DC360_1drap3_xiaoju_V1
提交 de1188bb 作者: wysheng
操作

修改一些错误

上级 077158e8
正在显示 包含 1911 行增加 和 2646 行删除
DcPillar/Projects/DcPillar.ewp
......@@ -315,6 +315,7 @@
<state>$PROJ_DIR$\..\Src\Drivers\W5500\Ethernet\W5500</state>
<state>$PROJ_DIR$\..\Src\Drivers\W5500\Ethernet</state>
<state>$PROJ_DIR$\..\Src\Drivers\W5500\Internet\DNS</state>
<state>$PROJ_DIR$\..\Src\SmartAllocation</state>
</option>
<option>
<name>CCStdIncCheck</name>
......@@ -2150,6 +2151,21 @@
</file>
</group>
<group>
<name>SmartAllocation</name>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\Drv_SmartAllocation.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\Drv_SmartAllocation.h</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\SmartAllocation_B_ChgRun.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\SmartAllocation_ChgRun.c</name>
</file>
</group>
<group>
<name>Threads</name>
<group>
<name>Charge</name>
......@@ -2212,6 +2228,9 @@
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Charge\ChgPro_ChgRun.c</name>
<excluded>
<configuration>Debug</configuration>
</excluded>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Charge\ChgPro_ChgStart.c</name>
......@@ -2260,6 +2279,9 @@
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Charge_B\ChgPro_B_ChgRun.c</name>
<excluded>
<configuration>Debug</configuration>
</excluded>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Charge_B\ChgPro_B_ChgStart.c</name>
......
DcPillar/Projects/DcPillar.ewt
......@@ -419,6 +419,21 @@
</file>
</group>
<group>
<name>SmartAllocation</name>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\Drv_SmartAllocation.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\Drv_SmartAllocation.h</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\SmartAllocation_B_ChgRun.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\SmartAllocation_ChgRun.c</name>
</file>
</group>
<group>
<name>Threads</name>
<group>
<name>Charge</name>
......
DcPillar/Src/Drivers/Drv_DcModule.h
......@@ -67,6 +67,40 @@ typedef struct
u16 ActualCurrt;//0.1A/Bit;
}StructDcModuleCtrl;
#define TemCtrlSwith 0//温控开关 1:打开，0:关闭
#if 1
#define DcModuleMaxVolt (7500)//750V
#define DcModuleMinVolt (2000)//200V
#define DcModuleMaxCurrt (100) //10A
#define DcModuleMinCurrt (5) //1A
#define DcModuleSinMaxCurrt (2000)
#else
#define DcModuleMaxVolt (5000)//750V
#define DcModuleMinVolt (2000)//250V
#define DcModuleMaxCurrt (150) //15A
#define DcModuleMinCurrt (10) //1A
#endif
typedef enum
{
eSwSta_Low= 0,
eSwSta_High,
}EnumModuStatus;
typedef struct
{
u8 Id;
u8 Temp;
u16 Volt;//0.1V/Bit;
u16 Currt;//0.1A/Bit;
u16 State;
u32 RecvTime;
EnumModuStatus ModStatus;
}StructDcModuleStatus;
extern StructDcModuleAbility DcModuleAbility;
extern void DcModuleCanInit_B(void);
......
DcPillar/Src/Drivers/Drv_DcModuleIncre.c
......@@ -12,42 +12,7 @@
#include "Drv_MCP2515.h"
#include "Memory.h"
#define TemCtrlSwith 0//温控开关 1:打开，0:关闭
#if 1
#define DcModuleMaxVolt (7500)//750V
#define DcModuleMinVolt (2000)//200V
#define DcModuleMaxCurrt (100) //10A
#define DcModuleMinCurrt (5) //1A
#define DcModuleSinMaxCurrt (2000)
#else
#define DcModuleMaxVolt (5000)//750V
#define DcModuleMinVolt (2000)//250V
#define DcModuleMaxCurrt (150) //15A
#define DcModuleMinCurrt (10) //1A
#endif
typedef enum
{
eSwSta_Low= 0,
eSwSta_High,
}EnumModuStatus;
typedef struct
{
u8 Id;
u8 Temp;
u16 Volt;//0.1V/Bit;
u16 Currt;//0.1A/Bit;
u16 State;
u32 RecvTime;
EnumModuStatus ModStatus;
}StructDcModuleStatus;
#define YINGKERUI
StructDcModuleAbility DcModuleAbility =
{
......@@ -75,7 +40,6 @@ void DcModuleRxIrqHandle(void)
Union1939Id Id1939 = {.Mult = 0,};
UnionYouExtId CommId = {.Mult = 0,};
//IrSta = MCP2515_ReadReg(CANINTF);
IrSta = MCP2515_ReadStatus();
if(IrSta & 0x01)
......@@ -88,74 +52,22 @@ void DcModuleRxIrqHandle(void)
{
if((CAN_ID_EXT == RxMsg.IDE) && (CAN_RTR_DATA == RxMsg.RTR))
{
if(UserParam.Module.DCModType == eDCModType_ZhongXin )
if((0x1207C080 == (RxMsg.ExtId & 0xFFFFFFC0)) && (0x01 == RxMsg.Data[0]))//模块状态回复
{
if((0x80 == (Id1939.Disp.DA_PS)) && (0x01 == (Id1939.Disp.PF))&& (0x06 == (Id1939.Disp.Prio)))//模块状态回复
{
Data.Id = Id1939.Disp.SA;
DcModuleManage.OnlineFlag |= ((long long)1<<Data.Id);
Data.Currt = (((u32)RxMsg.Data[4]<<8) + RxMsg.Data[3])/10;
Data.Volt = (((u32)RxMsg.Data[2]<<8) + RxMsg.Data[1]);
Data.State = ((u32)RxMsg.Data[6]<<8) + RxMsg.Data[5]+((u32)RxMsg.Data[7]<<16);
Data.RecvTime = GetSystemTick();
DcModuleStatus[Data.Id] = Data;
}
Data.Id = RxMsg.ExtId & 0x0000003F;
DcModuleManage.OnlineFlag |= ((long long)1<<Data.Id);
Data.Currt = ((u32)RxMsg.Data[2]<<8) + RxMsg.Data[3];
Data.Volt = ((u32)RxMsg.Data[4]<<8) + RxMsg.Data[5];
Data.State = ((u32)RxMsg.Data[6]<<8) + RxMsg.Data[7];
Data.RecvTime = GetSystemTick();
DcModuleStatus[Data.Id] = Data;
}
else if ((UserParam.Module.DCModType == eDCModType_YouYou)||
(UserParam.Module.DCModType == eDCModType_YouYouNormal) )
{
Data.Id = CommId.Disp.ModAd;
if((Data.Id < 0x0D)&&( RxMsg.Data[0] ==0x13))
{
DcModuleManage.OnlineFlag |= ((long long)1<<Data.Id);
DcModuleStatus[Data.Id].RecvTime = GetSystemTick();
if(0x00 == RxMsg.Data[1])//模块输出电压
{
DcModuleStatus[Data.Id].Volt= (((u32)RxMsg.Data[4]<<24) + ((u32)RxMsg.Data[5]<<16)+
((u32)RxMsg.Data[6]<<8) + (u32)RxMsg.Data[7]
)/100;
}
else if(0x01 == RxMsg.Data[1])//模块输出电流
{
DcModuleStatus[Data.Id].Currt = (((u32)RxMsg.Data[4]<<24) + ((u32)RxMsg.Data[5]<<16)+
((u32)RxMsg.Data[6]<<8) + (u32)RxMsg.Data[7]
)/100;
}
else if(0x08 == RxMsg.Data[1])//模块状态标志位
{
DcModuleStatus[Data.Id].State = (((u32)RxMsg.Data[4]<<24) + ((u32)RxMsg.Data[5]<<16)+
((u32)RxMsg.Data[6]<<8) + (u32)RxMsg.Data[7]
);
}
else if(0x60== RxMsg.Data[1])//模块状态标志位
{
if(RxMsg.Data[7] == 0x02 )
DcModuleStatus[Data.Id].ModStatus = eSwSta_Low;
else if(RxMsg.Data[7] == 0x01 )
DcModuleStatus[Data.Id].ModStatus = eSwSta_High;
}
}
}
else
{
if((0x1207C080 == (RxMsg.ExtId & 0xFFFFFFC0)) && (0x01 == RxMsg.Data[0]))//模块状态回复
{
Data.Id = RxMsg.ExtId & 0x0000003F;
DcModuleManage.OnlineFlag |= ((long long)1<<Data.Id);
Data.Currt = ((u32)RxMsg.Data[2]<<8) + RxMsg.Data[3];
Data.Volt = ((u32)RxMsg.Data[4]<<8) + RxMsg.Data[5];
Data.State = ((u32)RxMsg.Data[6]<<8) + RxMsg.Data[7];
Data.RecvTime = GetSystemTick();
DcModuleStatus[Data.Id] = Data;
}
}
}
}
}
if(IrSta & 0x02)
else if(IrSta & 0x02)
{
RecvFlag = MCP2515_Receive(1, &RxMsg);
MCP2515_BitModify(CANINTF, 0x02, 0x00);
......@@ -165,70 +77,18 @@ void DcModuleRxIrqHandle(void)
{
if((CAN_ID_EXT == RxMsg.IDE) && (CAN_RTR_DATA == RxMsg.RTR))
{
if(UserParam.Module.DCModType == eDCModType_ZhongXin )
if((0x1207C080 == (RxMsg.ExtId & 0xFFFFFFC0)) && (0x01 == RxMsg.Data[0]))//模块状态回复
{
if((0x80 == (Id1939.Disp.DA_PS)) && (0x01 == (Id1939.Disp.PF))&& (0x06 == (Id1939.Disp.Prio)))//模块状态回复
{
Data.Id = Id1939.Disp.SA;
DcModuleManage.OnlineFlag |= ((long long)1<<Data.Id);
Data.Currt = (((u32)RxMsg.Data[4]<<8) + RxMsg.Data[3])/10;
Data.Volt = (((u32)RxMsg.Data[2]<<8) + RxMsg.Data[1]);
Data.State = ((u32)RxMsg.Data[6]<<8) + RxMsg.Data[5]+((u32)RxMsg.Data[7]<<16);
Data.RecvTime = GetSystemTick();
DcModuleStatus[Data.Id] = Data;
}
}
else if ((UserParam.Module.DCModType == eDCModType_YouYou)||
(UserParam.Module.DCModType == eDCModType_YouYouNormal) )
{
Data.Id = CommId.Disp.ModAd;
if((Data.Id < 0x0D)&&( RxMsg.Data[0] ==0x13))
{
DcModuleManage.OnlineFlag |= ((long long)1<<Data.Id);
DcModuleStatus[Data.Id].RecvTime = GetSystemTick();
if(0x00 == RxMsg.Data[1])//模块输出电压
{
DcModuleStatus[Data.Id].Volt= (((u32)RxMsg.Data[4]<<24) + ((u32)RxMsg.Data[5]<<16)+
((u32)RxMsg.Data[6]<<8) + (u32)RxMsg.Data[7]
)/100;
}
else if(0x01 == RxMsg.Data[1])//模块输出电流
{
DcModuleStatus[Data.Id].Currt = (((u32)RxMsg.Data[4]<<24) + ((u32)RxMsg.Data[5]<<16)+
((u32)RxMsg.Data[6]<<8) + (u32)RxMsg.Data[7]
)/100;
}
else if(0x08 == RxMsg.Data[1])//模块状态标志位
{
DcModuleStatus[Data.Id].State = (((u32)RxMsg.Data[4]<<24) + ((u32)RxMsg.Data[5]<<16)+
((u32)RxMsg.Data[6]<<8) + (u32)RxMsg.Data[7]
);
}
else if(0x60== RxMsg.Data[1])//模块状态标志位
{
if(RxMsg.Data[7] == 0x02 )
DcModuleStatus[Data.Id].ModStatus = eSwSta_Low;
else if(RxMsg.Data[7] == 0x01 )
DcModuleStatus[Data.Id].ModStatus = eSwSta_High;
}
}
Data.Id = RxMsg.ExtId & 0x0000003F;
DcModuleManage.OnlineFlag |= ((long long)1<<Data.Id);
Data.Currt = ((u32)RxMsg.Data[2]<<8) + RxMsg.Data[3];
Data.Volt = ((u32)RxMsg.Data[4]<<8) + RxMsg.Data[5];
Data.State = ((u32)RxMsg.Data[6]<<8) + RxMsg.Data[7];
Data.RecvTime = GetSystemTick();
DcModuleStatus[Data.Id] = Data;
}
else
{
if((0x1207C080 == (RxMsg.ExtId & 0xFFFFFFC0)) && (0x01 == RxMsg.Data[0]))//模块状态回复
{
Data.Id = RxMsg.ExtId & 0x0000003F;
DcModuleManage.OnlineFlag |= ((long long)1<<Data.Id);
Data.Currt = ((u32)RxMsg.Data[2]<<8) + RxMsg.Data[3];
Data.Volt = ((u32)RxMsg.Data[4]<<8) + RxMsg.Data[5];
Data.State = ((u32)RxMsg.Data[6]<<8) + RxMsg.Data[7];
Data.RecvTime = GetSystemTick();
DcModuleStatus[Data.Id] = Data;
}
}
}
}
}
......@@ -356,1146 +216,6 @@ u8 DcModuleSendMsg(StructDcModuleSend *pMsg)
return FALSE; //未发送成功，返回FALSE
}
void DcModuleManageProcess_Incre(void)
{
static u32 CheckTick = 0;
static u8 StatusGetCnt = 0;
u8 i;
long long Flag;
u8 Count;
u32 Currt;
u32 Volt;
StructDcModuleSend DataSend;
{
StatusGetCnt++;
if(StatusGetCnt > 64)
StatusGetCnt = 0;
// if((((long long)1)<<StatusGetCnt) & DcModuleManage.OnlineFlag)
{
DataSend.Id = 0x1307C080 + StatusGetCnt;
DataSend.Len = 8;
DataSend.Data[0] = 0x01;
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] = 0x00;
DcModuleSendMsg(&DataSend);
}
}
if((GetSystemTick() - CheckTick) < 100)
return;
CheckTick = GetSystemTick();
Flag = 1;
Count = 0;
for(i=0; i<64; i++)
{
if(Flag & DcModuleManage.OnlineFlag)
{
if((GetSystemTick() - DcModuleStatus[i].RecvTime) > 8000)
{
DcModuleManage.OnlineFlag &= ~Flag;
DcModuleManage.ValidFlag &= ~Flag;
}
else
{
if(0x0002 != (DcModuleStatus[i].State & 0x0002))//0x03FE))
{
DcModuleManage.ValidFlag |= Flag;
Count++;
}
}
}
Flag = Flag << 1;
}
DcModuleManage.ValidNum = Count;
Flag = 1;
Currt = 0;
Volt = 0;
for(i=0; i<64; i++)
{
if(Flag & DcModuleManage.ValidFlag)
{
Currt += DcModuleStatus[i].Currt;
Volt += DcModuleStatus[i].Volt;
}
Flag = Flag << 1;
}
DcModuleCtrl.ActualCurrt = Currt;
DcModuleCtrl.ActualVolt = Volt/Count;
if(0 == DcModuleManage.OnlineFlag)
DcModuleCanInit();
}
void DcModuleCtrlProcess_Incre(void)
{
static u32 CtrlTick = 0;
static u8 LastFlag = 0;
StructDcModuleSend DataSend;
u32 Temp;
Temp = 0;
if(LastFlag != DcModuleCtrl.CtrlFlag)
{
LastFlag = DcModuleCtrl.CtrlFlag;
Temp++;
}
if((GetSystemTick() - CtrlTick) > 100)
{
CtrlTick = GetSystemTick();
Temp++;
}
if(0 == Temp)
return;
if(DcModuleCtrl.CtrlFlag)
{
if(DcModuleCtrl.NeedVolt > DcModuleAbility.MaxVolt)
DcModuleManage.SetVolt = (DcModuleAbility.MaxVolt*100);
else if(DcModuleCtrl.NeedVolt > DcModuleAbility.MinVolt)
DcModuleManage.SetVolt = (DcModuleCtrl.NeedVolt*100);
else
DcModuleManage.SetVolt = (DcModuleAbility.MinVolt*100);
if(DcModuleManage.ValidNum)
{
Temp = (DcModuleCtrl.NeedCurrt*100)/DcModuleManage.ValidNum;
if((DcModuleCtrl.NeedCurrt*100) % DcModuleManage.ValidNum)
Temp++;
}
else
Temp = DcModuleManage.SetCurrt;
if(Temp > (DcModuleAbility.MaxCurrt*100))
Temp = (DcModuleAbility.MaxCurrt*100);
else if(Temp < (DcModuleAbility.MinCurrt*100))
Temp = (DcModuleAbility.MinCurrt*100);
//限单个模块功率
u32 temp1 = GetDcModuleVolt();//DcModuleCtrl.NeedVolt/10;
if( temp1 == 0)
temp1 = 1;
temp1 = (u32)UserParam.DcMaxPower*1000*1000*10/temp1;
if(Temp > temp1)
Temp = temp1;
////////////////
if(Temp <= DcModuleManage.SetCurrt)
DcModuleManage.SetCurrt = Temp;
else
{
DcModuleManage.SetCurrt += 500;
if(DcModuleManage.SetCurrt >= Temp)
DcModuleManage.SetCurrt = Temp;
}
if(DcModuleManage.SetCurrt > (DcModuleAbility.MaxCurrt*100))
DcModuleManage.SetCurrt = (DcModuleAbility.MaxCurrt*100);
else if(DcModuleManage.SetCurrt < (DcModuleAbility.MinCurrt*100))
DcModuleManage.SetCurrt = (DcModuleAbility.MinCurrt*100);
//if(DcModuleManage.SetCurrt >=TemDecreaseCurrentValue())
// DcModuleManage.SetCurrt -= TemDecreaseCurrentValue();//温控电流
DataSend.Id = 0x1307C080;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
#if TemCtrlSwith
if(DcModuleManage.SetCurrt > TemDecreaseCurrentValue())//温控电流
Temp = DcModuleManage.SetCurrt - TemDecreaseCurrentValue();
else
#endif
Temp = DcModuleManage.SetCurrt;
DataSend.Data[2] = (u8)(Temp>>8);
DataSend.Data[3] = (u8)(Temp>>0);
Temp = DcModuleManage.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg(&DataSend);
osDelay(5);
DcModuleManage.Cmd = 0x55;//开机
DataSend.Id = 0x1307C080;
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;
DcModuleSendMsg(&DataSend);
}
else
{
DcModuleManage.SetVolt = DcModuleAbility.MinVolt*100;
DcModuleManage.SetCurrt = DcModuleAbility.MinCurrt*100;
DataSend.Id = 0x1307C080;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
Temp = DcModuleManage.SetCurrt;
DataSend.Data[2] = (u8)(Temp>>8);
DataSend.Data[3] = (u8)(Temp>>0);
Temp = DcModuleManage.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg(&DataSend);
osDelay(5);
DcModuleManage.Cmd = 0xAA;//关机
DataSend.Id = 0x1307C080;
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;
DcModuleSendMsg(&DataSend);
}
}
void DcModuleManageProcess_ZhongXing(void)
{
static u32 CheckTick = 0;
static u32 CheckTickStatus = 0;
u8 i;
long long Flag;
u8 Count;
u32 Currt;
u32 Volt;
StructDcModuleSend DataSend;
if((GetSystemTick() - CheckTickStatus) > 1000)
{
DataSend.Id = 0x1805FF80;
DataSend.Len = 8;
DataSend.Data[0] = 0x01;
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] = 0x00;
DcModuleSendMsg(&DataSend);
CheckTickStatus = GetSystemTick();
}
if((GetSystemTick() - CheckTick) < 2000)
return;
CheckTick = GetSystemTick();
Flag = 1;
Count = 0;
for(i=0; i<64; i++)
{
if(Flag & DcModuleManage.OnlineFlag)
{
if((GetSystemTick() - DcModuleStatus[i].RecvTime) > 8000)
{
DcModuleManage.OnlineFlag &= ~Flag;
DcModuleManage.ValidFlag &= ~Flag;
}
else
{
if(0 == (DcModuleStatus[i].State & 0x07FFFF))//0x03FE))
{
DcModuleManage.ValidFlag |= Flag;
Count++;
}
}
}
Flag = Flag << 1;
}
DcModuleManage.ValidNum = Count;
Flag = 1;
Currt = 0;
Volt = 0;
for(i=0; i<64; i++)
{
if(Flag & DcModuleManage.ValidFlag)
{
Currt += DcModuleStatus[i].Currt;
Volt += DcModuleStatus[i].Volt;
}
Flag = Flag << 1;
}
DcModuleCtrl.ActualCurrt = Currt;
DcModuleCtrl.ActualVolt = Volt/Count;
if(0 == DcModuleManage.OnlineFlag)
DcModuleCanInit();
}
void DcModuleCtrlProcess_ZhongXing(void)
{
static u32 CtrlTick = 0;
static u8 LastFlag = 0;
StructDcModuleSend DataSend;
u32 Temp;
Temp = 0;
if(LastFlag != DcModuleCtrl.CtrlFlag)
{
LastFlag = DcModuleCtrl.CtrlFlag;
Temp++;
}
if((GetSystemTick() - CtrlTick) > 100)
{
CtrlTick = GetSystemTick();
Temp++;
}
if(0 == Temp)
return;
if(DcModuleCtrl.CtrlFlag)
{
if(DcModuleCtrl.NeedVolt > DcModuleAbility.MaxVolt)
DcModuleManage.SetVolt = (DcModuleAbility.MaxVolt*100);
else if(DcModuleCtrl.NeedVolt > DcModuleAbility.MinVolt)
DcModuleManage.SetVolt = (DcModuleCtrl.NeedVolt*100);
else
DcModuleManage.SetVolt = (DcModuleAbility.MinVolt*100);
if(DcModuleManage.ValidNum)
{
Temp = (DcModuleCtrl.NeedCurrt*100)/DcModuleManage.ValidNum;
if((DcModuleCtrl.NeedCurrt*100) % DcModuleManage.ValidNum)
Temp++;
}
else
Temp = DcModuleManage.SetCurrt;
if(Temp > (DcModuleAbility.MaxCurrt*100))
Temp = (DcModuleAbility.MaxCurrt*100);
else if(Temp < (DcModuleAbility.MinCurrt*100))
Temp = (DcModuleAbility.MinCurrt*100);
//限单个模块功率
u32 temp1 = GetDcModuleVolt();//DcModuleCtrl.NeedVolt/10;
if( temp1 == 0)
temp1 = 1;
temp1 = (u32)UserParam.DcMaxPower*1000*1000*10/temp1;
if(Temp > temp1)
Temp = temp1;
////////////////
if(Temp <= DcModuleManage.SetCurrt)
DcModuleManage.SetCurrt = Temp;
else
{
DcModuleManage.SetCurrt += 500;
if(DcModuleManage.SetCurrt >= Temp)
DcModuleManage.SetCurrt = Temp;
}
if(DcModuleManage.SetCurrt > (DcModuleAbility.MaxCurrt*100))
DcModuleManage.SetCurrt = (DcModuleAbility.MaxCurrt*100);
else if(DcModuleManage.SetCurrt < (DcModuleAbility.MinCurrt*100))
DcModuleManage.SetCurrt = (DcModuleAbility.MinCurrt*100);
DcModuleManage.Cmd = 0xAA;//开机
DataSend.Id = 0x0803FF80;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = DcModuleManage.Cmd;
DataSend.Data[5] = 0x01;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;//DcModuleManage.Cmd;
DcModuleSendMsg(&DataSend);
osDelay(5);
DataSend.Id = 0x1004FF80;//0x1307C080;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
DataSend.Data[2] = 0;
DataSend.Data[3] = 0;
#if TemCtrlSwith
if(DcModuleManage.SetCurrt > TemDecreaseCurrentValue())//温控电流
Temp = (DcModuleManage.SetCurrt - TemDecreaseCurrentValue())/10;
else
#endif
Temp = DcModuleManage.SetCurrt/10;
DataSend.Data[6] = (u8)(Temp>>0);
DataSend.Data[7] = (u8)(Temp>>8);
Temp = DcModuleManage.SetVolt/100;
DataSend.Data[4] = (u8)(Temp>>0);
DataSend.Data[5] = (u8)(Temp>>8);
DcModuleSendMsg(&DataSend);
}
else
{
DcModuleManage.SetVolt = DcModuleAbility.MinVolt*100;
DcModuleManage.SetCurrt = DcModuleAbility.MinCurrt*100;
DataSend.Id = 0x1004FF80;//0x1307C080;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
DataSend.Data[2] = 0;
DataSend.Data[3] = 0;
Temp = DcModuleManage.SetCurrt/10;
DataSend.Data[6] = (u8)(Temp>>0);
DataSend.Data[7] = (u8)(Temp>>8);
Temp = DcModuleManage.SetVolt/100;
DataSend.Data[4] = (u8)(Temp>>0);
DataSend.Data[5] = (u8)(Temp>>8);
DcModuleSendMsg(&DataSend);
osDelay(5);
DcModuleManage.Cmd = 0x55;//关机
DataSend.Id = 0x0803FF80;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = DcModuleManage.Cmd;
DataSend.Data[5] = 0x01;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;//DcModuleManage.Cmd;
DcModuleSendMsg(&DataSend);
}
}
void DcModuleManageProcess_YouYou(void)
{
static u32 CheckTick = 0;
static u32 CheckTick1 = 0;
UnionYouExtId CommId = {.Mult = 0,};
u8 i;
long long Flag;
u8 Count;
u32 Currt;
u32 Volt;
StructDcModuleSend DataSend;
if (GetSystemTick()- CheckTick >500)
{
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;//读取模块状态
DataSend.Data[1] = 0x08;
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg(&DataSend);
osDelay(10);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;
DataSend.Data[1] = 0x01;//读取所有模块输出电流
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg(&DataSend);
osDelay(10);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;
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] = 0x00;
DcModuleSendMsg(&DataSend);
osDelay(10);
/*DataSend.Id = CommId.Mult;
DataSend.Len = 8;
CommId.Disp.ModAd = 0x01;
DataSend.Data[0] = 0x12;
DataSend.Data[1] = 0x60;//读取模块1 高低压模式
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg(&DataSend);
osDelay(10);*/
CheckTick = GetSystemTick();
}
if (GetSystemTick()- CheckTick1 < 500)
return;
CheckTick1 = GetSystemTick();
Flag = 1;
Count = 0;
for(i=0; i<0x0d; i++)
{
if(Flag & DcModuleManage.OnlineFlag)
{
if((GetSystemTick() - DcModuleStatus[i].RecvTime) > 5000)
{
DcModuleManage.OnlineFlag &= ~Flag;
DcModuleManage.ValidFlag &= ~Flag;
}
else
{
if(0 == (DcModuleStatus[i].State & 0x37D3C7))//0x03FE))
{
DcModuleManage.ValidFlag |= Flag;
Count++;
}
}
}
Flag = Flag << 1;
}
DcModuleManage.ValidNum = Count;
Flag = 1;
Currt = 0;
Volt = 0;
for(i=0; i<0x0D; i++)
{
if(Flag & DcModuleManage.ValidFlag)
{
Currt += DcModuleStatus[i].Currt;
Volt += DcModuleStatus[i].Volt;
//DcModuleCtrl.ActualVolt = DcModuleStatus[i].Volt;
}
Flag = Flag << 1;
}
DcModuleCtrl.ActualCurrt = Currt;
DcModuleCtrl.ActualVolt = Volt/Count;
if(0 == DcModuleManage.OnlineFlag)
DcModuleCanInit();
}
void DcModuleCtrlProcess_YouYou(void)
{
static u32 CtrlTick = 0;
static u8 LastFlag = 0;
StructDcModuleSend DataSend;
u32 Temp;
UnionYouExtId CommId = {.Mult = 0,};
Temp = 0;
if(LastFlag != DcModuleCtrl.CtrlFlag)
{
LastFlag = DcModuleCtrl.CtrlFlag;
Temp++;
}
if((GetSystemTick() - CtrlTick) > 100)
{
CtrlTick = GetSystemTick();
Temp++;
}
if(0 == Temp)
return;
/*if((DcModuleCtrl.NeedVolt >=2000)&&(DcModuleCtrl.NeedVolt <=3000) )
DcModuleAbility.MaxCurrt = 100*10;
else if((DcModuleCtrl.NeedVolt >3000)&&(DcModuleCtrl.NeedVolt <=10000) )
DcModuleAbility.MaxCurrt = (u32)30*1000*10*10/DcModuleCtrl.NeedVolt;
if(3000000%DcModuleCtrl.NeedVolt)
DcModuleAbility.MaxCurrt++;
else if (DcModuleCtrl.NeedVolt >10000 )
DcModuleAbility.MaxCurrt =0 ;
else if (DcModuleCtrl.NeedVolt < 2000 )
DcModuleAbility.MaxCurrt =0 ;
else
DcModuleAbility.MaxCurrt =0 ;
if(DcModuleAbility.MaxCurrt >= DcModuleAbilitySet.MaxCurrt)
DcModuleAbility.MaxCurrt = DcModuleAbilitySet.MaxCurrt;*/
if(DcModuleCtrl.CtrlFlag)
{
if(DcModuleCtrl.NeedVolt > DcModuleAbility.MaxVolt)
DcModuleManage.SetVolt = (DcModuleAbility.MaxVolt*100);
else if(DcModuleCtrl.NeedVolt > DcModuleAbility.MinVolt)
DcModuleManage.SetVolt = (DcModuleCtrl.NeedVolt*100);
else
DcModuleManage.SetVolt = (DcModuleAbility.MinVolt*100);
if(DcModuleManage.ValidNum)
{
Temp = (DcModuleCtrl.NeedCurrt*100)/DcModuleManage.ValidNum;
if((DcModuleCtrl.NeedCurrt*100) % DcModuleManage.ValidNum)
Temp++;
}
else
Temp = DcModuleManage.SetCurrt;
if(Temp > (DcModuleAbility.MaxCurrt*100))
Temp = (DcModuleAbility.MaxCurrt*100);
else if(Temp < (DcModuleAbility.MinCurrt*100))
Temp = (DcModuleAbility.MinCurrt*100);
//限单个模块功率
u32 temp1 = GetDcModuleVolt();//DcModuleCtrl.NeedVolt/10;
if( temp1 == 0)
temp1 = 1;
temp1 = (u32)UserParam.DcMaxPower*1000*1000*10/temp1;
if(Temp > temp1)
Temp = temp1;
////////////////
if(Temp <= DcModuleManage.SetCurrt)
DcModuleManage.SetCurrt = Temp;
else
DcModuleManage.SetCurrt += 500;
if(DcModuleManage.SetCurrt > (DcModuleAbility.MaxCurrt*100))
DcModuleManage.SetCurrt = (DcModuleAbility.MaxCurrt*100);
else if(DcModuleManage.SetCurrt < (DcModuleAbility.MinCurrt*100))
DcModuleManage.SetCurrt = (DcModuleAbility.MinCurrt*100);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;//
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x02;//设置电压
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg(&DataSend);
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x03;//设置电流
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
#if TemCtrlSwith
if(DcModuleManage.SetCurrt > TemDecreaseCurrentValue())//温控电流
Temp = DcModuleManage.SetCurrt - TemDecreaseCurrentValue();
else
#endif
Temp = DcModuleManage.SetCurrt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg(&DataSend);
osDelay(2);
}
// if((DcModuleManage.SetVolt >=500*1000)&&(DcModuleStatus[1].ModStatus == eSwSta_High)
// ||(DcModuleManage.SetVolt <500*1000)&&(DcModuleStatus[1].ModStatus == eSwSta_Low))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x04;//开机
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg(&DataSend);
}
/* else if((DcModuleManage.SetVolt >=500*1000)&&(DcModuleStatus[1].ModStatus == eSwSta_Low))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x5F;//
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x01;//高压模式
DcModuleSendMsg(&DataSend);
osDelay(1500);
}
else if((DcModuleManage.SetVolt <500*1000)&&(DcModuleStatus[1].ModStatus == eSwSta_High))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x5F;//
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x02;//低压模式
DcModuleSendMsg(&DataSend);
osDelay(1500);
}*/
}
else
{
DcModuleManage.SetVolt = DcModuleAbility.MinVolt*100;
DcModuleManage.SetCurrt = DcModuleAbility.MinCurrt*100;
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;//
{
CommId.Disp.ModAd = 0x00 ;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x02;//设置电压
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg(&DataSend);
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x03;//设置电流
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage.SetCurrt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg(&DataSend);
osDelay(2);
}
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x04;
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x01;
DcModuleSendMsg(&DataSend);
}
}
}
void DcModuleManageProcess_YouYou30KW(void)
{
static u32 CheckTick = 0;
static u32 CheckTick1 = 0;
UnionYouExtId CommId = {.Mult = 0,};
u8 i;
long long Flag;
u8 Count;
u32 Currt;
u32 Volt;
StructDcModuleSend DataSend;
if (GetSystemTick()- CheckTick >500)
{
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;//读取模块状态
DataSend.Data[1] = 0x08;
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg(&DataSend);
osDelay(10);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;
DataSend.Data[1] = 0x01;//读取所有模块输出电流
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg(&DataSend);
osDelay(10);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;
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] = 0x00;
DcModuleSendMsg(&DataSend);
osDelay(10);
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
CommId.Disp.ModAd = 0x01;
DataSend.Data[0] = 0x12;
DataSend.Data[1] = 0x60;//读取模块1 高低压模式
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg(&DataSend);
osDelay(10);
CheckTick = GetSystemTick();
}
if (GetSystemTick()- CheckTick1 < 500)
return;
CheckTick1 = GetSystemTick();
Flag = 1;
Count = 0;
for(i=0; i<0x0d; i++)
{
if(Flag & DcModuleManage.OnlineFlag)
{
if((GetSystemTick() - DcModuleStatus[i].RecvTime) > 5000)
{
DcModuleManage.OnlineFlag &= ~Flag;
DcModuleManage.ValidFlag &= ~Flag;
}
else
{
if(0 == (DcModuleStatus[i].State & 0x37D3C7))//0x03FE))
{
DcModuleManage.ValidFlag |= Flag;
Count++;
}
}
}
Flag = Flag << 1;
}
DcModuleManage.ValidNum = Count;
Flag = 1;
Currt = 0;
Volt = 0;
for(i=0; i<0x0D; i++)
{
if(Flag & DcModuleManage.ValidFlag)
{
Currt += DcModuleStatus[i].Currt;
Volt += DcModuleStatus[i].Volt;
//DcModuleCtrl.ActualVolt = DcModuleStatus[i].Volt;
}
Flag = Flag << 1;
}
DcModuleCtrl.ActualCurrt = Currt;
DcModuleCtrl.ActualVolt = Volt/Count;
if(0 == DcModuleManage.OnlineFlag)
DcModuleCanInit();
}
void DcModuleCtrlProcess_YouYou30KW(void)
{
static u32 CtrlTick = 0;
static u8 LastFlag = 0;
StructDcModuleSend DataSend;
u32 Temp;
UnionYouExtId CommId = {.Mult = 0,};
Temp = 0;
if(LastFlag != DcModuleCtrl.CtrlFlag)
{
LastFlag = DcModuleCtrl.CtrlFlag;
Temp++;
}
if((GetSystemTick() - CtrlTick) > 100)
{
CtrlTick = GetSystemTick();
Temp++;
}
if(0 == Temp)
return;
/*if((DcModuleCtrl.NeedVolt >=2000)&&(DcModuleCtrl.NeedVolt <=3000) )
DcModuleAbility.MaxCurrt = 100*10;
else if((DcModuleCtrl.NeedVolt >3000)&&(DcModuleCtrl.NeedVolt <=10000) )
DcModuleAbility.MaxCurrt = (u32)30*1000*10*10/DcModuleCtrl.NeedVolt;
if(3000000%DcModuleCtrl.NeedVolt)
DcModuleAbility.MaxCurrt++;
else if (DcModuleCtrl.NeedVolt >10000 )
DcModuleAbility.MaxCurrt =0 ;
else if (DcModuleCtrl.NeedVolt < 2000 )
DcModuleAbility.MaxCurrt =0 ;
else
DcModuleAbility.MaxCurrt =0 ;
if(DcModuleAbility.MaxCurrt >= DcModuleAbilitySet.MaxCurrt)
DcModuleAbility.MaxCurrt = DcModuleAbilitySet.MaxCurrt;*/
if(DcModuleCtrl.CtrlFlag)
{
if(DcModuleCtrl.NeedVolt > DcModuleAbility.MaxVolt)
DcModuleManage.SetVolt = (DcModuleAbility.MaxVolt*100);
else if(DcModuleCtrl.NeedVolt > DcModuleAbility.MinVolt)
DcModuleManage.SetVolt = (DcModuleCtrl.NeedVolt*100);
else
DcModuleManage.SetVolt = (DcModuleAbility.MinVolt*100);
if(DcModuleManage.ValidNum)
{
Temp = (DcModuleCtrl.NeedCurrt*100)/DcModuleManage.ValidNum;
if((DcModuleCtrl.NeedCurrt*100) % DcModuleManage.ValidNum)
Temp++;
}
else
Temp = DcModuleManage.SetCurrt;
if(Temp > (DcModuleAbility.MaxCurrt*100))
Temp = (DcModuleAbility.MaxCurrt*100);
else if(Temp < (DcModuleAbility.MinCurrt*100))
Temp = (DcModuleAbility.MinCurrt*100);
//限单个模块功率
u32 temp1 = GetDcModuleVolt();//DcModuleCtrl.NeedVolt/10;
if( temp1 == 0)
temp1 = 1;
temp1 = (u32)UserParam.DcMaxPower*1000*1000*10/temp1;
if(Temp > temp1)
Temp = temp1;
////////////////
if(Temp <= DcModuleManage.SetCurrt)
DcModuleManage.SetCurrt = Temp;
else
DcModuleManage.SetCurrt += 500;
if(DcModuleManage.SetCurrt > (DcModuleAbility.MaxCurrt*100))
DcModuleManage.SetCurrt = (DcModuleAbility.MaxCurrt*100);
else if(DcModuleManage.SetCurrt < (DcModuleAbility.MinCurrt*100))
DcModuleManage.SetCurrt = (DcModuleAbility.MinCurrt*100);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;//
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x02;//设置电压
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg(&DataSend);
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x03;//设置电流
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
#if TemCtrlSwith
if(DcModuleManage.SetCurrt > TemDecreaseCurrentValue())//温控电流
Temp = DcModuleManage.SetCurrt - TemDecreaseCurrentValue();
else
#endif
Temp = DcModuleManage.SetCurrt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg(&DataSend);
osDelay(2);
}
if((DcModuleManage.SetVolt >=500*1000)&&(DcModuleStatus[1].ModStatus == eSwSta_High)
||(DcModuleManage.SetVolt <500*1000)&&(DcModuleStatus[1].ModStatus == eSwSta_Low))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x04;//开机
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg(&DataSend);
}
else if((DcModuleManage.SetVolt >=500*1000)&&(DcModuleStatus[1].ModStatus == eSwSta_Low))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x5F;//
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x01;//高压模式
DcModuleSendMsg(&DataSend);
osDelay(1500);
}
else if((DcModuleManage.SetVolt <500*1000)&&(DcModuleStatus[1].ModStatus == eSwSta_High))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x5F;//
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x02;//低压模式
DcModuleSendMsg(&DataSend);
osDelay(1500);
}
}
else
{
DcModuleManage.SetVolt = DcModuleAbility.MinVolt*100;
DcModuleManage.SetCurrt = DcModuleAbility.MinCurrt*100;
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;//
{
CommId.Disp.ModAd = 0x00 ;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x02;//设置电压
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg(&DataSend);
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x03;//设置电流
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage.SetCurrt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg(&DataSend);
osDelay(2);
}
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x04;
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x01;
DcModuleSendMsg(&DataSend);
}
}
}
void DcModuleSet(EnumSwitchStatus Set, u16 Volt, u16 Currt)
......@@ -1540,7 +260,8 @@ u16 GetDcModuleCurrtSet(void)
return DcModuleCtrl.NeedCurrt;
}
osMessageQId DcModeMsg = 0;
extern void DcModuleManageProcess_SmartAllocation(void);
/* the system main thread */
void DcModule(void const *parameter)
{
......@@ -1554,36 +275,46 @@ void DcModule(void const *parameter)
DcModuleAbility.MinCurrt = UserParam.DcMinCurrt;
DcModuleAbility.SingleMaxCurrt= UserParam.SingleMaxCurrt;
DcModeMsg = NULL;
osMessageQDef(DcModeMsg, 64, StructDcModuleSend);
DcModeMsg = osMessageCreate(osMessageQ(DcModeMsg), NULL);
while(1)
{
if(UserParam.Module.DCModType == eDCModType_ZhongXin )
{
DcModuleManageProcess_ZhongXing();
osDelay(15);
DcModuleCtrlProcess_ZhongXing();
osDelay(15);
}
else if(UserParam.Module.DCModType == eDCModType_YouYouNormal)
{
DcModuleManageProcess_YouYou();
osDelay(15);
DcModuleCtrlProcess_YouYou();
osDelay(15);
}
else if(UserParam.Module.DCModType == eDCModType_YouYou)
{
DcModuleManageProcess_YouYou30KW();
osDelay(15);
DcModuleCtrlProcess_YouYou30KW();
osDelay(15);
}
else
{
DcModuleManageProcess_Incre();
osDelay(15);
DcModuleCtrlProcess_Incre();
osDelay(15);
}
StructDcModuleSend DataSend;
if (pdTRUE == xQueueReceive(DcModeMsg, &DataSend, 0))
{
DcModuleSendMsg(&DataSend);
}
DcModuleManageProcess_SmartAllocation();
#if 0
static u8 StatusGetCnt = 0;
StatusGetCnt++;
if(StatusGetCnt > 64)
StatusGetCnt = 0;
DataSend.Id = 0x1307C080 + StatusGetCnt;
DataSend.Len = 8;
DataSend.Data[0] = 0x01;
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] = 0x00;
if(pdTRUE != xQueueSend(DcModeMsg, &DataSend, 0))
{
osDelay(1000);
}
#endif
osDelay(30);
}
}
......@@ -1604,95 +335,15 @@ void DcModuleRxIrqHandle_B(void)
u8 RecvFlag;
Union1939Id Id1939 = {.Mult = 0,};
UnionYouExtId CommId = {.Mult = 0,};
//IrSta = MCP2515_ReadReg(CANINTF);
IrSta = MCP2515_B_ReadStatus();
if(IrSta & 0x01)
{
RecvFlag = MCP2515_B_Receive(0, &RxMsg);
MCP2515_B_BitModify(CANINTF, 0x01, 0x00);
Id1939.Mult = RxMsg.ExtId;
CommId.Mult = RxMsg.ExtId;
if(TRUE == RecvFlag)
{
if((CAN_ID_EXT == RxMsg.IDE) && (CAN_RTR_DATA == RxMsg.RTR))
{
if(UserParam.Module.DCModType == eDCModType_ZhongXin )
{
if((0x80 == (Id1939.Disp.DA_PS)) && (0x01 == (Id1939.Disp.PF))&& (0x06 == (Id1939.Disp.Prio)))//模块状态回复
{
Data.Id = Id1939.Disp.SA;
DcModuleManage_B.OnlineFlag |= ((long long)1<<Data.Id);
Data.Currt = (((u32)RxMsg.Data[4]<<8) + RxMsg.Data[3])/10;
Data.Volt = (((u32)RxMsg.Data[2]<<8) + RxMsg.Data[1]);
Data.State = ((u32)RxMsg.Data[6]<<8) + RxMsg.Data[5]+((u32)RxMsg.Data[7]<<16);
Data.RecvTime = GetSystemTick();
DcModuleStatus_B[Data.Id] = Data;
}
}
else if ((UserParam.Module.DCModType == eDCModType_YouYou)||
(UserParam.Module.DCModType == eDCModType_YouYouNormal) )
{
Data.Id = CommId.Disp.ModAd;
if((Data.Id < 0x0D)&&( RxMsg.Data[0] ==0x13))
{
DcModuleManage_B.OnlineFlag |= ((long long)1<<Data.Id);
DcModuleStatus_B[Data.Id].RecvTime = GetSystemTick();
if(0x00 == RxMsg.Data[1])//模块输出电压
{
DcModuleStatus_B[Data.Id].Volt= (((u32)RxMsg.Data[4]<<24) + ((u32)RxMsg.Data[5]<<16)+
((u32)RxMsg.Data[6]<<8) + (u32)RxMsg.Data[7]
)/100;
}
else if(0x01 == RxMsg.Data[1])//模块输出电流
{
DcModuleStatus_B[Data.Id].Currt = (((u32)RxMsg.Data[4]<<24) + ((u32)RxMsg.Data[5]<<16)+
((u32)RxMsg.Data[6]<<8) + (u32)RxMsg.Data[7]
)/100;
}
else if(0x08 == RxMsg.Data[1])//模块状态标志位
{
DcModuleStatus_B[Data.Id].State = (((u32)RxMsg.Data[4]<<24) + ((u32)RxMsg.Data[5]<<16)+
((u32)RxMsg.Data[6]<<8) + (u32)RxMsg.Data[7]
);
}
else if(0x60== RxMsg.Data[1])//模块状态标志位
{
if(RxMsg.Data[7] == 0x02 )
DcModuleStatus_B[Data.Id].ModStatus = eSwSta_Low;
else if(RxMsg.Data[7] == 0x01 )
DcModuleStatus_B[Data.Id].ModStatus = eSwSta_High;
}
}
}
else
{
if((0x1207C080 == (RxMsg.ExtId & 0xFFFFFFC0)) && (0x01 == RxMsg.Data[0]))//模块状态回复
{
Data.Id = RxMsg.ExtId & 0x0000003F;
DcModuleManage_B.OnlineFlag |= ((long long)1<<Data.Id);
Data.Currt = ((u32)RxMsg.Data[2]<<8) + RxMsg.Data[3];
Data.Volt = ((u32)RxMsg.Data[4]<<8) + RxMsg.Data[5];
Data.State = ((u32)RxMsg.Data[6]<<8) + RxMsg.Data[7];
Data.RecvTime = GetSystemTick();
DcModuleStatus_B[Data.Id] = Data;
}
}
UnionYouExtId CommId = {.Mult = 0,};
}
}
}
//IrSta = MCP2515_ReadReg(CANINTF);
IrSta = MCP2515_B_ReadStatus();
if(IrSta & 0x02)
if(IrSta & 0x01)
{
RecvFlag = MCP2515_B_Receive(1, &RxMsg);
MCP2515_B_BitModify(CANINTF, 0x02, 0x00);
RecvFlag = MCP2515_B_Receive(0, &RxMsg);
MCP2515_B_BitModify(CANINTF, 0x01, 0x00);
Id1939.Mult = RxMsg.ExtId;
CommId.Mult = RxMsg.ExtId;
......@@ -1713,6 +364,7 @@ void DcModuleRxIrqHandle_B(void)
DcModuleStatus_B[Data.Id] = Data;
}
}
else if ((UserParam.Module.DCModType == eDCModType_YouYou)||
(UserParam.Module.DCModType == eDCModType_YouYouNormal) )
{
......@@ -1748,9 +400,41 @@ void DcModuleRxIrqHandle_B(void)
}
}
}
}
else
{
{
if((0x1207C080 == (RxMsg.ExtId & 0xFFFFFFC0)) && (0x01 == RxMsg.Data[0]))//模块状态回复
{
Data.Id = RxMsg.ExtId & 0x0000003F;
DcModuleManage_B.OnlineFlag |= ((long long)1<<Data.Id);
Data.Currt = ((u32)RxMsg.Data[2]<<8) + RxMsg.Data[3];
Data.Volt = ((u32)RxMsg.Data[4]<<8) + RxMsg.Data[5];
Data.State = ((u32)RxMsg.Data[6]<<8) + RxMsg.Data[7];
Data.RecvTime = GetSystemTick();
DcModuleStatus_B[Data.Id] = Data;
}
}
}
}
}
else if(IrSta & 0x02)
{
RecvFlag = MCP2515_B_Receive(1, &RxMsg);
MCP2515_B_BitModify(CANINTF, 0x02, 0x00);
Id1939.Mult = RxMsg.ExtId;
CommId.Mult = RxMsg.ExtId;
if(TRUE == RecvFlag)
{
if((CAN_ID_EXT == RxMsg.IDE) && (CAN_RTR_DATA == RxMsg.RTR))
{
if((0x1207C080 == (RxMsg.ExtId & 0xFFFFFFC0)) && (0x01 == RxMsg.Data[0]))//模块状态回复
{
Data.Id = RxMsg.ExtId & 0x0000003F;
......@@ -1761,7 +445,7 @@ void DcModuleRxIrqHandle_B(void)
Data.RecvTime = GetSystemTick();
DcModuleStatus_B[Data.Id] = Data;
}
}
}
}
......@@ -1808,9 +492,9 @@ void DcModuleCanInit_B(void)
MCP2515_B_WriteReg(CNF1, (1<<BRP0)|(1<<BRP1)|(1<<BRP2)); //125K
// 设置传播段 Prop Seg 为00，即1TQ，相位缓冲段 Phase Seg1的长度3TQ
MCP2515_B_WriteReg(CNF2, (1<<BTLMODE)|(1<<PHSEG11));
MCP2515_B_WriteReg(CNF2, (1<<BTLMODE)|(0<<PHSEG11));
// 设置 相位缓冲段 Phase Seg2为 3TQ ， 禁用唤醒滤波器
MCP2515_B_WriteReg(CNF3, (1<<PHSEG21) );
MCP2515_B_WriteReg(CNF3, (0<<PHSEG21) );
// 设置MCP2515中断使能寄存器,使能接收缓冲器中断
MCP2515_B_WriteReg(CANINTE, (1<<RX1IE)|(1<<RX0IE));
......@@ -1882,1157 +566,6 @@ u8 DcModuleSendMsg_B(StructDcModuleSend *pMsg)
return FALSE; //未发送成功，返回FALSE
}
void DcModuleManageProcess_BIncre(void)
{
static u32 CheckTick = 0;
static u8 StatusGetCnt = 0;
u8 i;
long long Flag;
u8 Count;
u32 Currt;
u32 Volt;
StructDcModuleSend DataSend;
// while(DcModuleManage_B.OnlineFlag)
{
StatusGetCnt++;
if(StatusGetCnt > 64)
StatusGetCnt = 0;
// if((((long long)1)<<StatusGetCnt) & DcModuleManage_B.OnlineFlag)
{
DataSend.Id = 0x1307C080 + StatusGetCnt;//DcModuleStatus_B[StatusGetCnt].Id;
DataSend.Len = 8;
DataSend.Data[0] = 0x01;
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] = 0x00;
DcModuleSendMsg_B(&DataSend);
// break;
}
}
if((GetSystemTick() - CheckTick) < 100)
return;
CheckTick = GetSystemTick();
Flag = 1;
Count = 0;
for(i=0; i<64; i++)
{
if(Flag & DcModuleManage_B.OnlineFlag)
{
if((GetSystemTick() - DcModuleStatus_B[i].RecvTime) > 8000)
{
DcModuleManage_B.OnlineFlag &= ~Flag;
DcModuleManage_B.ValidFlag &= ~Flag;
}
else
{
if(0x0002 != (DcModuleStatus_B[i].State & 0x0002))//0x03FE))
{
DcModuleManage_B.ValidFlag |= Flag;
Count++;
}
}
}
Flag = Flag << 1;
}
DcModuleManage_B.ValidNum = Count;
Flag = 1;
Currt = 0;
Volt = 0;
for(i=0; i<64; i++)
{
if(Flag & DcModuleManage_B.ValidFlag)
{
Currt += DcModuleStatus_B[i].Currt;
Volt += DcModuleStatus_B[i].Volt;
//DcModuleCtrl_B.ActualVolt = DcModuleStatus_B[i].Volt;
}
Flag = Flag << 1;
}
DcModuleCtrl_B.ActualCurrt = Currt;
DcModuleCtrl_B.ActualVolt = Volt/Count;
if(0 == DcModuleManage_B.OnlineFlag)
DcModuleCanInit_B();
}
void DcModuleCtrlProcess_BIncre(void)
{
static u32 CtrlTick = 0;
static u8 LastFlag = 0;
StructDcModuleSend DataSend;
u32 Temp;
// if(0 == DcModuleManage_B.OnlineFlag)
// return;
Temp = 0;
if(LastFlag != DcModuleCtrl_B.CtrlFlag)
{
LastFlag = DcModuleCtrl_B.CtrlFlag;
Temp++;
}
if((GetSystemTick() - CtrlTick) > 100)
{
CtrlTick = GetSystemTick();
Temp++;
}
if(0 == Temp)
return;
if(DcModuleCtrl_B.CtrlFlag)
{
if(DcModuleCtrl_B.NeedVolt > DcModuleAbility.MaxVolt)
DcModuleManage_B.SetVolt = (DcModuleAbility.MaxVolt*100);
else if(DcModuleCtrl_B.NeedVolt > DcModuleAbility.MinVolt)
DcModuleManage_B.SetVolt = (DcModuleCtrl_B.NeedVolt*100);
else
DcModuleManage_B.SetVolt = (DcModuleAbility.MinVolt*100);
if(DcModuleManage_B.ValidNum)
{
Temp = (DcModuleCtrl_B.NeedCurrt*100)/DcModuleManage_B.ValidNum;
if((DcModuleCtrl_B.NeedCurrt*100) % DcModuleManage_B.ValidNum)
Temp++;
}
else
Temp = DcModuleManage_B.SetCurrt;
if(Temp > (DcModuleAbility.MaxCurrt*100))
Temp = (DcModuleAbility.MaxCurrt*100);
else if(Temp < (DcModuleAbility.MinCurrt*100))
Temp = (DcModuleAbility.MinCurrt*100);
//限单个模块功率
u32 temp1 = GetDcModuleVolt_B();//DcModuleCtrl_B.NeedVolt/10;
if( temp1 == 0)
temp1 = 1;
temp1 = (u32)UserParam.DcMaxPower*1000*1000*10/temp1;
if(Temp > temp1)
Temp = temp1;
////////////////
if(Temp <= DcModuleManage_B.SetCurrt)
DcModuleManage_B.SetCurrt = Temp;
else
{
DcModuleManage_B.SetCurrt += 500;
if(DcModuleManage_B.SetCurrt >= Temp)
DcModuleManage_B.SetCurrt = Temp;
}
if(DcModuleManage_B.SetCurrt > (DcModuleAbility.MaxCurrt*100))
DcModuleManage_B.SetCurrt = (DcModuleAbility.MaxCurrt*100);
else if(DcModuleManage_B.SetCurrt < (DcModuleAbility.MinCurrt*100))
DcModuleManage_B.SetCurrt = (DcModuleAbility.MinCurrt*100);
DataSend.Id = 0x1307C080;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
#if TemCtrlSwith
if(DcModuleManage_B.SetCurrt > TemDecreaseCurrentValueB())//温控电流
Temp = DcModuleManage_B.SetCurrt - TemDecreaseCurrentValueB();
else
#endif
Temp = DcModuleManage_B.SetCurrt;
DataSend.Data[2] = (u8)(Temp>>8);
DataSend.Data[3] = (u8)(Temp>>0);
Temp = DcModuleManage_B.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg_B(&DataSend);
osDelay(5);
DcModuleManage_B.Cmd = 0x55;//开机
DataSend.Id = 0x1307C080;
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;
DcModuleSendMsg_B(&DataSend);
}
else
{
DcModuleManage_B.SetVolt = DcModuleAbility.MinVolt*100;
DcModuleManage_B.SetCurrt = DcModuleAbility.MinCurrt*100;
DataSend.Id = 0x1307C080;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
Temp = DcModuleManage_B.SetCurrt;
DataSend.Data[2] = (u8)(Temp>>8);
DataSend.Data[3] = (u8)(Temp>>0);
Temp = DcModuleManage_B.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg_B(&DataSend);
osDelay(5);
DcModuleManage_B.Cmd = 0xAA;//关机
DataSend.Id = 0x1307C080;
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;
DcModuleSendMsg_B(&DataSend);
}
}
void DcModuleManageProcess_BZhongXing(void)
{
static u32 CheckTick = 0;
static u32 CheckTickStatus = 0;
u8 i;
long long Flag;
u8 Count;
u32 Currt;
u32 Volt;
StructDcModuleSend DataSend;
if((GetSystemTick() - CheckTickStatus) > 1000)
{
{
DataSend.Id = 0x1805FF80;
DataSend.Len = 8;
DataSend.Data[0] = 0x01;
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] = 0x00;
DcModuleSendMsg_B(&DataSend);
CheckTickStatus = GetSystemTick();
}
}
if((GetSystemTick() - CheckTick) < 2000)
return;
CheckTick = GetSystemTick();
Flag = 1;
Count = 0;
for(i=0; i<64; i++)
{
if(Flag & DcModuleManage_B.OnlineFlag)
{
if((GetSystemTick() - DcModuleStatus_B[i].RecvTime) > 8000)
{
DcModuleManage_B.OnlineFlag &= ~Flag;
DcModuleManage_B.ValidFlag &= ~Flag;
}
else
{
if(0 == (DcModuleStatus_B[i].State & 0x07FFFF))
{
DcModuleManage_B.ValidFlag |= Flag;
Count++;
}
}
}
Flag = Flag << 1;
}
DcModuleManage_B.ValidNum = Count;
Flag = 1;
Currt = 0;
Volt = 0;
for(i=0; i<64; i++)
{
if(Flag & DcModuleManage_B.ValidFlag)
{
Currt += DcModuleStatus_B[i].Currt;
Volt += DcModuleStatus_B[i].Volt;
}
Flag = Flag << 1;
}
DcModuleCtrl_B.ActualCurrt = Currt;
DcModuleCtrl_B.ActualVolt = Volt/Count;
if(0 == DcModuleManage_B.OnlineFlag)
DcModuleCanInit_B();
}
void DcModuleCtrlProcess_BZhongXing(void)
{
static u32 CtrlTick = 0;
static u8 LastFlag = 0;
StructDcModuleSend DataSend;
u32 Temp;
Temp = 0;
if(LastFlag != DcModuleCtrl_B.CtrlFlag)
{
LastFlag = DcModuleCtrl_B.CtrlFlag;
Temp++;
}
if((GetSystemTick() - CtrlTick) > 100)
{
CtrlTick = GetSystemTick();
Temp++;
}
if(0 == Temp)
return;
if(DcModuleCtrl_B.CtrlFlag)
{
if(DcModuleCtrl_B.NeedVolt > DcModuleAbility.MaxVolt)
DcModuleManage_B.SetVolt = (DcModuleAbility.MaxVolt*100);
else if(DcModuleCtrl_B.NeedVolt > DcModuleAbility.MinVolt)
DcModuleManage_B.SetVolt = (DcModuleCtrl_B.NeedVolt*100);
else
DcModuleManage_B.SetVolt = (DcModuleAbility.MinVolt*100);
if(DcModuleManage_B.ValidNum)
{
Temp = (DcModuleCtrl_B.NeedCurrt*100)/DcModuleManage_B.ValidNum;
if((DcModuleCtrl_B.NeedCurrt*100) % DcModuleManage_B.ValidNum)
Temp++;
}
else
Temp = DcModuleManage_B.SetCurrt;
if(Temp > (DcModuleAbility.MaxCurrt*100))
Temp = (DcModuleAbility.MaxCurrt*100);
else if(Temp < (DcModuleAbility.MinCurrt*100))
Temp = (DcModuleAbility.MinCurrt*100);
//限单个模块功率
u32 temp1 = GetDcModuleVolt_B();//DcModuleCtrl_B.NeedVolt/10;
if( temp1 == 0)
temp1 = 1;
temp1 = (u32)UserParam.DcMaxPower*1000*1000*10/temp1;
if(Temp > temp1)
Temp = temp1;
////////////////
if(Temp <= DcModuleManage_B.SetCurrt)
DcModuleManage_B.SetCurrt = Temp;
else
{
DcModuleManage_B.SetCurrt += 500;
if(DcModuleManage_B.SetCurrt >= Temp)
DcModuleManage_B.SetCurrt = Temp;
}
if(DcModuleManage_B.SetCurrt > (DcModuleAbility.MaxCurrt*100))
DcModuleManage_B.SetCurrt = (DcModuleAbility.MaxCurrt*100);
else if(DcModuleManage_B.SetCurrt < (DcModuleAbility.MinCurrt*100))
DcModuleManage_B.SetCurrt = (DcModuleAbility.MinCurrt*100);
DataSend.Id = 0x1004FF80;//0x1307C080;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
DataSend.Data[2] = 0;
DataSend.Data[3] = 0;
#if TemCtrlSwith
if(DcModuleManage_B.SetCurrt > TemDecreaseCurrentValueB())//温控电流
Temp = (DcModuleManage_B.SetCurrt - TemDecreaseCurrentValueB())/10;
else
#endif
Temp = DcModuleManage_B.SetCurrt/10;
DataSend.Data[6] = (u8)(Temp>>0);
DataSend.Data[7] = (u8)(Temp>>8);
Temp = DcModuleManage_B.SetVolt/100;
DataSend.Data[4] = (u8)(Temp>>0);
DataSend.Data[5] = (u8)(Temp>>8);
DcModuleSendMsg_B(&DataSend);
osDelay(5);
DcModuleManage_B.Cmd = 0xAA;//开机
DataSend.Id = 0x0803FF80;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = DcModuleManage_B.Cmd;
DataSend.Data[5] = 0x01;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;//DcModuleManage.Cmd;
DcModuleSendMsg_B(&DataSend);
}
else
{
DcModuleManage_B.SetVolt = DcModuleAbility.MinVolt*100;
DcModuleManage_B.SetCurrt = DcModuleAbility.MinCurrt*100;
DataSend.Id = 0x1004FF80;//0x1307C080;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
DataSend.Data[2] = 0;
DataSend.Data[3] = 0;
Temp = DcModuleManage_B.SetCurrt/10;
DataSend.Data[6] = (u8)(Temp>>0);
DataSend.Data[7] = (u8)(Temp>>8);
Temp = DcModuleManage_B.SetVolt/100;
DataSend.Data[4] = (u8)(Temp>>0);
DataSend.Data[5] = (u8)(Temp>>8);
DcModuleSendMsg_B(&DataSend);
osDelay(5);
DcModuleManage_B.Cmd = 0x55;//关机
DataSend.Id = 0x0803FF80;;
DataSend.Len = 8;
DataSend.Data[0] = 0x00;
DataSend.Data[1] = 0x00;
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = DcModuleManage_B.Cmd;
DataSend.Data[5] = 0x01;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;//DcModuleManage.Cmd;
DcModuleSendMsg_B(&DataSend);
}
}
void DcModuleManageProcess_BYouYou(void)
{
static u32 CheckTick = 0;
static u32 CheckTick1 = 0;
UnionYouExtId CommId = {.Mult = 0,};
u8 i;
long long Flag;
u8 Count;
u32 Currt;
u32 Volt;
StructDcModuleSend DataSend;
if (GetSystemTick()- CheckTick >500)
{
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;//读取模块状态
DataSend.Data[1] = 0x08;
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg_B(&DataSend);
osDelay(10);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;
DataSend.Data[1] = 0x01;//读取所有模块输出电流
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg_B(&DataSend);
osDelay(10);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;
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] = 0x00;
DcModuleSendMsg_B(&DataSend);
osDelay(10);
/*DataSend.Id = CommId.Mult;
DataSend.Len = 8;
CommId.Disp.ModAd = 0x01;
DataSend.Data[0] = 0x12;
DataSend.Data[1] = 0x60;//读取模块1 高低压模式
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg_B(&DataSend);
osDelay(10);*/
CheckTick = GetSystemTick();
}
if (GetSystemTick()- CheckTick1 < 500)
return;
CheckTick1 = GetSystemTick();
Flag = 1;
Count = 0;
for(i=0; i<0x0d; i++)
{
if(Flag & DcModuleManage_B.OnlineFlag)
{
if((GetSystemTick() - DcModuleStatus_B[i].RecvTime) > 5000)
{
DcModuleManage_B.OnlineFlag &= ~Flag;
DcModuleManage_B.ValidFlag &= ~Flag;
}
else
{
if(0 == (DcModuleStatus_B[i].State & 0x37D3C7))//0x03FE))
{
DcModuleManage_B.ValidFlag |= Flag;
Count++;
}
}
}
Flag = Flag << 1;
}
DcModuleManage_B.ValidNum = Count;
Flag = 1;
Currt = 0;
Volt = 0;
for(i=0; i<0x0D; i++)
{
if(Flag & DcModuleManage_B.ValidFlag)
{
Currt += DcModuleStatus_B[i].Currt;
Volt += DcModuleStatus_B[i].Volt;
}
Flag = Flag << 1;
}
DcModuleCtrl_B.ActualCurrt = Currt;
DcModuleCtrl_B.ActualVolt = Volt/Count;
if(0 == DcModuleManage_B.OnlineFlag)
DcModuleCanInit_B();
}
void DcModuleCtrlProcess_BYouYou(void)
{
static u32 CtrlTick = 0;
static u8 LastFlag = 0;
StructDcModuleSend DataSend;
u32 Temp;
UnionYouExtId CommId = {.Mult = 0,};
Temp = 0;
if(LastFlag != DcModuleCtrl_B.CtrlFlag)
{
LastFlag = DcModuleCtrl_B.CtrlFlag;
Temp++;
}
if((GetSystemTick() - CtrlTick) > 100)
{
CtrlTick = GetSystemTick();
Temp++;
}
if(0 == Temp)
return;
/* if((DcModuleCtrl.NeedVolt >=2000)&&(DcModuleCtrl.NeedVolt <=3000) )
DcModuleAbility.MaxCurrt = 100*10;
else if((DcModuleCtrl.NeedVolt >3000)&&(DcModuleCtrl.NeedVolt <=10000) )
DcModuleAbility.MaxCurrt = (u32)30*1000*10*10/DcModuleCtrl.NeedVolt;
if(3000000%DcModuleCtrl.NeedVolt)
DcModuleAbility.MaxCurrt++;
else if (DcModuleCtrl.NeedVolt >10000 )
DcModuleAbility.MaxCurrt =0 ;
else if (DcModuleCtrl.NeedVolt < 2000 )
DcModuleAbility.MaxCurrt =0 ;
else
DcModuleAbility.MaxCurrt =0 ;
if(DcModuleAbility.MaxCurrt >= DcModuleAbilitySet.MaxCurrt)
DcModuleAbility.MaxCurrt = DcModuleAbilitySet.MaxCurrt;*/
if(DcModuleCtrl_B.CtrlFlag)
{
if(DcModuleCtrl_B.NeedVolt > DcModuleAbility.MaxVolt)
DcModuleManage_B.SetVolt = (DcModuleAbility.MaxVolt*100);
else if(DcModuleCtrl_B.NeedVolt > DcModuleAbility.MinVolt)
DcModuleManage_B.SetVolt = (DcModuleCtrl_B.NeedVolt*100);
else
DcModuleManage_B.SetVolt = (DcModuleAbility.MinVolt*100);
if(DcModuleManage_B.ValidNum)
{
Temp = (DcModuleCtrl_B.NeedCurrt*100)/DcModuleManage_B.ValidNum;
if((DcModuleCtrl_B.NeedCurrt*100) % DcModuleManage_B.ValidNum)
Temp++;
}
else
Temp = DcModuleManage_B.SetCurrt;
if(Temp > (DcModuleAbility.MaxCurrt*100))
Temp = (DcModuleAbility.MaxCurrt*100);
else if(Temp < (DcModuleAbility.MinCurrt*100))
Temp = (DcModuleAbility.MinCurrt*100);
//限单个模块功率
u32 temp1 = GetDcModuleVolt_B();//DcModuleCtrl_B.NeedVolt/10;
if( temp1 == 0)
temp1 = 1;
temp1 = (u32)UserParam.DcMaxPower*1000*1000*10/temp1;
if(Temp > temp1)
Temp = temp1;
////////////////
if(Temp <= DcModuleManage_B.SetCurrt)
DcModuleManage_B.SetCurrt = Temp;
else
DcModuleManage_B.SetCurrt += 500;
if(DcModuleManage_B.SetCurrt > (DcModuleAbility.MaxCurrt*100))
DcModuleManage_B.SetCurrt = (DcModuleAbility.MaxCurrt*100);
else if(DcModuleManage_B.SetCurrt < (DcModuleAbility.MinCurrt*100))
DcModuleManage_B.SetCurrt = (DcModuleAbility.MinCurrt*100);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;//
// for(i = 0;i < 2;i++)
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x02;//设置电压
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage_B.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg_B(&DataSend);
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x03;//设置电流
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
#if TemCtrlSwith
if(DcModuleManage_B.SetCurrt > TemDecreaseCurrentValueB())//温控电流
Temp = DcModuleManage_B.SetCurrt - TemDecreaseCurrentValueB();
else
#endif
Temp = DcModuleManage_B.SetCurrt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg_B(&DataSend);
osDelay(2);
}
// if((DcModuleManage_B.SetVolt >=500*1000)&&(DcModuleStatus_B[1].ModStatus == eSwSta_High)
// ||(DcModuleManage_B.SetVolt <500*1000)&&(DcModuleStatus_B[1].ModStatus == eSwSta_Low))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x04;//开机
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg_B(&DataSend);
}
/* else if((DcModuleManage_B.SetVolt >=500*1000)&&(DcModuleStatus_B[1].ModStatus == eSwSta_Low))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x5F;//
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x01;//高压模式
DcModuleSendMsg_B(&DataSend);
osDelay(1500);
}
else if((DcModuleManage_B.SetVolt <500*1000)&&(DcModuleStatus_B[1].ModStatus == eSwSta_High))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x5F;//
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x02;//低压模式
DcModuleSendMsg_B(&DataSend);
osDelay(1500);
}*/
}
else
{
DcModuleManage_B.SetVolt = DcModuleAbility.MinVolt*100;
DcModuleManage_B.SetCurrt = DcModuleAbility.MinCurrt*100;
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;//
// for(i = 0;i < 2;i++)
{
CommId.Disp.ModAd = 0x00 ;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x02;//设置电压
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage_B.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg_B(&DataSend);
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x03;//设置电流
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage_B.SetCurrt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg_B(&DataSend);
osDelay(2);
}
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;//
// for(i = 0;i < 2;i++)
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x04;//
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x01;
DcModuleSendMsg_B(&DataSend);
}
}
}
void DcModuleManageProcess_BYouYou30KW(void)
{
static u32 CheckTick = 0;
static u32 CheckTick1 = 0;
UnionYouExtId CommId = {.Mult = 0,};
u8 i;
long long Flag;
u8 Count;
u32 Currt;
u32 Volt;
StructDcModuleSend DataSend;
if (GetSystemTick()- CheckTick >500)
{
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;//读取模块状态
DataSend.Data[1] = 0x08;
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg_B(&DataSend);
osDelay(10);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;
DataSend.Data[1] = 0x01;//读取所有模块输出电流
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg_B(&DataSend);
osDelay(10);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x12;
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] = 0x00;
DcModuleSendMsg_B(&DataSend);
osDelay(10);
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
CommId.Disp.ModAd = 0x01;
DataSend.Data[0] = 0x12;
DataSend.Data[1] = 0x60;//读取模块1 高低压模式
DataSend.Data[2] = 0x00;
DataSend.Data[3] = 0x00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg_B(&DataSend);
osDelay(10);
CheckTick = GetSystemTick();
}
if (GetSystemTick()- CheckTick1 < 500)
return;
CheckTick1 = GetSystemTick();
Flag = 1;
Count = 0;
for(i=0; i<0x0d; i++)
{
if(Flag & DcModuleManage_B.OnlineFlag)
{
if((GetSystemTick() - DcModuleStatus_B[i].RecvTime) > 5000)
{
DcModuleManage_B.OnlineFlag &= ~Flag;
DcModuleManage_B.ValidFlag &= ~Flag;
}
else
{
if(0 == (DcModuleStatus_B[i].State & 0x37D3C7))//0x03FE))
{
DcModuleManage_B.ValidFlag |= Flag;
Count++;
}
}
}
Flag = Flag << 1;
}
DcModuleManage_B.ValidNum = Count;
Flag = 1;
Currt = 0;
Volt = 0;
for(i=0; i<0x0D; i++)
{
if(Flag & DcModuleManage_B.ValidFlag)
{
Currt += DcModuleStatus_B[i].Currt;
Volt += DcModuleStatus_B[i].Volt;
}
Flag = Flag << 1;
}
DcModuleCtrl_B.ActualCurrt = Currt;
DcModuleCtrl_B.ActualVolt = Volt/Count;
if(0 == DcModuleManage_B.OnlineFlag)
DcModuleCanInit_B();
}
void DcModuleCtrlProcess_BYouYou30KW(void)
{
static u32 CtrlTick = 0;
static u8 LastFlag = 0;
StructDcModuleSend DataSend;
u32 Temp;
UnionYouExtId CommId = {.Mult = 0,};
Temp = 0;
if(LastFlag != DcModuleCtrl_B.CtrlFlag)
{
LastFlag = DcModuleCtrl_B.CtrlFlag;
Temp++;
}
if((GetSystemTick() - CtrlTick) > 100)
{
CtrlTick = GetSystemTick();
Temp++;
}
if(0 == Temp)
return;
/* if((DcModuleCtrl.NeedVolt >=2000)&&(DcModuleCtrl.NeedVolt <=3000) )
DcModuleAbility.MaxCurrt = 100*10;
else if((DcModuleCtrl.NeedVolt >3000)&&(DcModuleCtrl.NeedVolt <=10000) )
DcModuleAbility.MaxCurrt = (u32)30*1000*10*10/DcModuleCtrl.NeedVolt;
if(3000000%DcModuleCtrl.NeedVolt)
DcModuleAbility.MaxCurrt++;
else if (DcModuleCtrl.NeedVolt >10000 )
DcModuleAbility.MaxCurrt =0 ;
else if (DcModuleCtrl.NeedVolt < 2000 )
DcModuleAbility.MaxCurrt =0 ;
else
DcModuleAbility.MaxCurrt =0 ;
if(DcModuleAbility.MaxCurrt >= DcModuleAbilitySet.MaxCurrt)
DcModuleAbility.MaxCurrt = DcModuleAbilitySet.MaxCurrt;*/
if(DcModuleCtrl_B.CtrlFlag)
{
if(DcModuleCtrl_B.NeedVolt > DcModuleAbility.MaxVolt)
DcModuleManage_B.SetVolt = (DcModuleAbility.MaxVolt*100);
else if(DcModuleCtrl_B.NeedVolt > DcModuleAbility.MinVolt)
DcModuleManage_B.SetVolt = (DcModuleCtrl_B.NeedVolt*100);
else
DcModuleManage_B.SetVolt = (DcModuleAbility.MinVolt*100);
if(DcModuleManage_B.ValidNum)
{
Temp = (DcModuleCtrl_B.NeedCurrt*100)/DcModuleManage_B.ValidNum;
if((DcModuleCtrl_B.NeedCurrt*100) % DcModuleManage_B.ValidNum)
Temp++;
}
else
Temp = DcModuleManage_B.SetCurrt;
if(Temp > (DcModuleAbility.MaxCurrt*100))
Temp = (DcModuleAbility.MaxCurrt*100);
else if(Temp < (DcModuleAbility.MinCurrt*100))
Temp = (DcModuleAbility.MinCurrt*100);
//限单个模块功率
u32 temp1 = GetDcModuleVolt_B();//DcModuleCtrl_B.NeedVolt/10;
if( temp1 == 0)
temp1 = 1;
temp1 = (u32)UserParam.DcMaxPower*1000*1000*10/temp1;
if(Temp > temp1)
Temp = temp1;
////////////////
if(Temp <= DcModuleManage_B.SetCurrt)
DcModuleManage_B.SetCurrt = Temp;
else
DcModuleManage_B.SetCurrt += 500;
if(DcModuleManage_B.SetCurrt > (DcModuleAbility.MaxCurrt*100))
DcModuleManage_B.SetCurrt = (DcModuleAbility.MaxCurrt*100);
else if(DcModuleManage_B.SetCurrt < (DcModuleAbility.MinCurrt*100))
DcModuleManage_B.SetCurrt = (DcModuleAbility.MinCurrt*100);
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;//
// for(i = 0;i < 2;i++)
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x02;//设置电压
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage_B.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg_B(&DataSend);
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x03;//设置电流
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
#if TemCtrlSwith
if(DcModuleManage_B.SetCurrt > TemDecreaseCurrentValueB())//温控电流
Temp = DcModuleManage_B.SetCurrt - TemDecreaseCurrentValueB();
else
#endif
Temp = DcModuleManage_B.SetCurrt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg_B(&DataSend);
osDelay(2);
}
if((DcModuleManage_B.SetVolt >=500*1000)&&(DcModuleStatus_B[1].ModStatus == eSwSta_High)
||(DcModuleManage_B.SetVolt <500*1000)&&(DcModuleStatus_B[1].ModStatus == eSwSta_Low))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x04;//开机
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x00;
DcModuleSendMsg_B(&DataSend);
}
else if((DcModuleManage_B.SetVolt >=500*1000)&&(DcModuleStatus_B[1].ModStatus == eSwSta_Low))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x5F;//
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x01;//高压模式
DcModuleSendMsg_B(&DataSend);
osDelay(1500);
}
else if((DcModuleManage_B.SetVolt <500*1000)&&(DcModuleStatus_B[1].ModStatus == eSwSta_High))
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x5F;//
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x02;//低压模式
DcModuleSendMsg_B(&DataSend);
osDelay(1500);
}
}
else
{
DcModuleManage_B.SetVolt = DcModuleAbility.MinVolt*100;
DcModuleManage_B.SetCurrt = DcModuleAbility.MinCurrt*100;
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;//
// for(i = 0;i < 2;i++)
{
CommId.Disp.ModAd = 0x00 ;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x02;//设置电压
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage_B.SetVolt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg_B(&DataSend);
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x03;//设置电流
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
Temp = DcModuleManage_B.SetCurrt;
DataSend.Data[4] = (u8)(Temp>>24);
DataSend.Data[5] = (u8)(Temp>>16);
DataSend.Data[6] = (u8)(Temp>>8);
DataSend.Data[7] = (u8)(Temp>>0);
DcModuleSendMsg_B(&DataSend);
osDelay(2);
}
CommId.Disp.Reserve = 0x00;
CommId.Disp.Protocol= 0x01;
CommId.Disp.MonAd = 0x01;
CommId.Disp.ModAd = 0x00;
CommId.Disp.ProduDay=0x00;
CommId.Disp.SeNunLo =0x00;//
// for(i = 0;i < 2;i++)
{
CommId.Disp.ModAd = 0x00;
DataSend.Id = CommId.Mult;
DataSend.Len = 8;
DataSend.Data[0] = 0x10;
DataSend.Data[1] = 0x04;//
DataSend.Data[2] = 00;
DataSend.Data[3] = 00;
DataSend.Data[4] = 0x00;
DataSend.Data[5] = 0x00;
DataSend.Data[6] = 0x00;
DataSend.Data[7] = 0x01;
DcModuleSendMsg_B(&DataSend);
}
}
}
void DcModuleSet_B(EnumSwitchStatus Set, u16 Volt, u16 Currt)
{
......@@ -3080,52 +613,45 @@ u16 GetDcModuleCurrtSet_B(void)
/* the system main thread */
void DcModule_B(void const *parameter)
{
/**/osDelay(6000);
osDelay(6000);
DcModuleCanInit_B();
DcModuleAbility.MaxVolt = UserParam.DcMaxVolt;
DcModuleAbility.MinVolt = UserParam.DcMinVolt;
DcModuleAbility.MaxCurrt = UserParam.DcMaxCurrt;
DcModuleAbility.MinCurrt = UserParam.DcMinCurrt;
DcModuleAbility.SingleMaxCurrt= UserParam.SingleMaxCurrt;
while(1)
{
if(UserParam.Module.DCModType == eDCModType_ZhongXin )
{
DcModuleManageProcess_BZhongXing();
osDelay(15);
DcModuleCtrlProcess_BZhongXing();
osDelay(15);
}
else if(UserParam.Module.DCModType == eDCModType_YouYouNormal)
{
DcModuleManageProcess_BYouYou();
osDelay(15);
DcModuleCtrlProcess_BYouYou();
osDelay(15);
}
else if(UserParam.Module.DCModType == eDCModType_YouYou)
{
DcModuleManageProcess_BYouYou30KW();
osDelay(15);
DcModuleCtrlProcess_BYouYou30KW();
osDelay(15);
}
else
{
DcModuleManageProcess_BIncre();
osDelay(15);
DcModuleCtrlProcess_BIncre();
osDelay(15);
//DcModuleManageProcess_BIncre();
osDelay(30);
#if 1
static u8 StatusGetCnt = 0;
StructDcModuleSend DataSend;
StatusGetCnt++;
if(StatusGetCnt > 64)
StatusGetCnt = 0;
DataSend.Id = 0x1307C080 + StatusGetCnt;
DataSend.Len = 8;
DataSend.Data[0] = 0x01;
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] = 0x00;
DcModuleSendMsg_B(&DataSend);
#endif
}
}
}
u8 DcModuleInit_B(void)
{
//DcModuleCanInit_B();
osThreadDef(DcModule_B, DcModule_B, osPriorityAboveNormal, 0, configMINIMAL_STACK_SIZE);
if(NULL == osThreadCreate(osThread(DcModule_B), NULL))
......
DcPillar/Src/Drivers/Drv_MCP2515.c
......@@ -443,6 +443,7 @@ void MCP2515_SetInt(pMCP2515IntHandle pIrqHandle, FunctionalState NewState)
/* Enable GPIOA clock */
RCC_AHB1PeriphClockCmd(MCP2515_INT_GPIO_CLK, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
/* Enable SYSCFG clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
......
DcPillar/Src/Drivers/Drv_TCUComm.c
......@@ -264,10 +264,10 @@ void TCUCanInit(void)
MCP2515_B_WriteReg(CNF1, (1 << BRP0) | (1 << BRP1) | (1 << BRP2)); //125K
// 设置传播段 Prop Seg 为00，即1TQ，相位缓冲段 Phase Seg1的长度3TQ
MCP2515_B_WriteReg(CNF2, (1 << BTLMODE) | (1 << PHSEG11));
MCP2515_B_WriteReg(CNF2, (1 << BTLMODE) | (0 << PHSEG11));
// 设置 相位缓冲段 Phase Seg2为 3TQ ， 禁用唤醒滤波器
MCP2515_B_WriteReg(CNF3, (1 << PHSEG21));
MCP2515_B_WriteReg(CNF3, (0 << PHSEG21));
// 设置MCP2515中断使能寄存器,使能接收缓冲器中断
MCP2515_B_WriteReg(CANINTE, (1 << RX1IE) | (1 << RX0IE));
......@@ -326,7 +326,7 @@ u8 TCUCommInit(void)
TCUMsg = osMessageCreate(osMessageQ(TCUMsg), NULL);
TCUCanInit();
return TRUE;
}
......@@ -411,8 +411,8 @@ StructTCUEM TCUChgContralTCUEM_B;
StructTCUCControl TCUControlInfo =
{
.ChargingServiceFlag = 2,
.version = 0x0110,
.ChargingServiceFlag = 1,
.version = 0x0100,
.ChargeNum =
{
0, 0, 0, 0
......@@ -1420,7 +1420,7 @@ void TCUHeartBeat_A(void)
};
static u8 CountNum; //最大255
Data[0] = 0x01;
Data[0] = 0x00;
Data[1] = CountNum++;
Data[2] = TCUCommuStatus.ConnectFlag;
Data[3] = TCUControlInfo.ChargingServiceFlag;
......@@ -1457,17 +1457,10 @@ void AckTCUHeartBeat(StructTCUSend * pPgnRecv)
TCUCommuStatus.HeartBeatRecvTime_B = GetSystemTick();
}
if (pPgnRecv->Data[2] == 0x00)
{
TCUCommuStatus.ConnectFlag = 1; //tcu检测控制器心跳状态
TCUCommuStatus.HeartBeatVaild = 1; //控制器检测tcu心跳状态
}
else
{
TCUCommuStatus.ConnectFlag = 0;
TCUCommuStatus.HeartBeatVaild = 0;
memset(&TCUCommuStatus, 0, sizeof(TCUCommuStatus)); //通讯失败通讯初始化
}
TCUCommuStatus.ConnectFlag = CONNECT_NORMAL; //tcu检测控制器心跳状态
TCUCommuStatus.HeartBeatVaild = CONNECT_NORMAL; //控制器检测tcu心跳状态
}
......@@ -1499,7 +1492,10 @@ void TCUtimeSet(StructTCUSend * pPgnRecv)
void TCUtimeSetAck(void)
{
u8 Data[8];
u8 Data[8] =
{
0
};
StructTime Time;
cp56time2a * time = NULL;
......@@ -1540,7 +1536,10 @@ void TCUVersionCheck(StructTCUSend * pPgnRecv)
void TCUVersionCheckSent(void)
{
u8 Data[8];
u8 Data[8] =
{
0
};
Data[0] = TCUCommuStatus.ChgNum;
Data[1] = TCUControlInfo.version;
......@@ -1562,10 +1561,10 @@ void TCUParam(StructTCUSend * pPgnRecv)
void TCUParamAck(void)
{
u8 Data[8];
memset(Data,0,8);
Data[0] = TCUCommuStatus.ChgNum;
if ((TCUCommuStatus.VerChkVaild == 0) || (TCUCommuStatus.ConnectFlag == 0))
if ((TCUCommuStatus.VerChkVaild == 0) || (TCUCommuStatus.ConnectFlag == CONNECT_TIMEOUT))
{
TCUCommuStatus.ParamVaild = 0;
Data[1] = 01; //失败
......@@ -1615,7 +1614,10 @@ void SerConAckAnalysis(StructTCUSend * pPgnRecv)
void SerConAck(void)
{
u8 Data[8];
u8 Data[8] =
{
0
};
Data[0] = TCUCommuStatus.ChgNum;
Data[1] = TCUCommuStatus.ChargingServiceSetValue;
......@@ -1683,7 +1685,10 @@ void ElectControlAnalysis(StructTCUSend * pPgnRecv)
void ElectControlAck(void)
{
u8 Data[8];
u8 Data[8] =
{
0
};
Data[0] = TCUCommuStatus.ChgNum;
Data[1] = TCUCommuStatus.ElectLockSetValue;
......
DcPillar/Src/Drivers/Drv_TCUComm.h
......@@ -218,7 +218,7 @@ typedef struct
}StructVerificationInformain;
#define TCU1939Addr (0x8A)
#define ChargerCont1939Addr (0xF6)
#define ChargerCont1939Addr (0xE0)
typedef enum
{
eCmd_start = 0x000100,// 充电启动帧
......
DcPillar/Src/SmartAllocation/Drv_SmartAllocation.c 0 → 100644
#include "Drv_DcModule.h"
#include "Drv_MCP2515.h"
#include "Memory.h"
#include "Drv_SmartAllocation.h"
#include "Global.h"
StructDcModuleGroup DcModuleGroup[] =
{
{
2, 0,
{
1, 0, 0, 0, 2, 0, 0, 0
},
Invalid, 0, 0
},
{
1, 0,
{
3, 0, 0, 0, 0, 0, 0, 0
},
Invalid, 0, 0
},
{
2, 0,
{
4, 0, 0, 0, 5, 0, 0, 0
},
Invalid, 0, 0
},
{
1, 0,
{
6, 0, 0, 0, 0, 0, 0, 0
},
Invalid, 0, 0
},
};
static u8 DcModuleGroupSize = sizeof(DcModuleGroup) / sizeof(DcModuleGroup[0]);
extern StructDcModuleManage DcModuleManage;
StructDcModuleManage DcModuleManage_A;
extern StructDcModuleManage DcModuleManage_B;
StructDcModuleManage DcModuleManage_All;
extern StructDcModuleCtrl DcModuleCtrl;
StructDcModuleCtrl DcModuleCtrl_A;
extern StructDcModuleCtrl DcModuleCtrl_B;
extern u8 DcModuleSendMsg(StructDcModuleSend * pMsg);
extern StructDcModuleStatus DcModuleStatus[64];
extern StructDcModuleStatus DcModuleStatus_B[64];
extern void DcModuleCanInit(void);
extern osMessageQId DcModeMsg;
void DcModuleManageProcess_SmartAllocation(void)
{
static u32 CheckTick = 0;
u8 addr = 0;
u8 i, j;
long long Flag;
u8 Count, Count_A, Count_B;
u32 Currt, Currt_A, Currt_B;
u32 Volt, Volt_A, Volt_B;
u8 status;
static u8 StatusGetCnt = 0;
StructDcModuleSend DataSend;
static u32 StaticTick = 0;
if(StaticTick == 0)
StaticTick = GetSystemTick();
if((GetSystemTick() -StaticTick) > 1000){
StaticTick = GetSystemTick();
for(i=0;i<DcModuleGroupSize;i++){
for(j=0;j<DcModuleGroup[i].num;j++){
addr = DcModuleGroup[i].modules[j].addr;
DataSend.Id = 0x1307C080 + addr;
DataSend.Len = 8;
DataSend.Data[0] = 0x01;
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] = 0x00;
//DcModuleSendMsg(&DataSend);
//放入队列
if (pdTRUE != xQueueSend(DcModeMsg, &DataSend, 0))
{
osDelay(10);
}
}
}
}
if ((GetSystemTick() -CheckTick) < 100)
return;
CheckTick = GetSystemTick();
Flag = 1;
Count = 0;
for (i = 0; i < 64; i++)
{
if (Flag & DcModuleManage_All.OnlineFlag)
{
if ((GetSystemTick() -DcModuleStatus[i].RecvTime) > 8000)
{
DcModuleManage_All.OnlineFlag &= ~Flag;
DcModuleManage_All.ValidFlag &= ~Flag;
}
else
{
if (0x0002 != (DcModuleStatus[i].State & 0x0002))
{
DcModuleManage_All.ValidFlag |= Flag;
Count++;
}
}
}
Flag = Flag << 1;
}
DcModuleManage_All.ValidNum = Count;
for (i = 0; i < DcModuleGroupSize; i++)
{
Currt = 0;
Volt = 0;
Count = 0;
for (j = 0; j < DcModuleGroup[i].num; j++)
{
addr = DcModuleGroup[i].modules[j].addr;
Flag = addr << 1;
if (Flag & DcModuleManage_All.ValidFlag)
{
Currt += DcModuleStatus[addr].Currt;
Volt += DcModuleStatus[addr].Volt;
Count++;
DcModuleGroup[i].modules[j].status = Valid;
DcModuleGroup[i].modules[j].Voltage = DcModuleStatus[addr].Volt;
DcModuleGroup[i].modules[j].Current = DcModuleStatus[addr].Currt;
}
else
{
DcModuleGroup[i].modules[j].status = Invalid;
}
}
DcModuleGroup[i].ValidNum = Count;
DcModuleGroup[i].Voltage = Volt / Count;
DcModuleGroup[i].Current = Currt;
}
for (i = 0; i < DcModuleGroupSize; i++)
{
status = DcModuleGroup[i].modules[0].status;
if (DcModuleGroup[i].num != DcModuleGroup[i].ValidNum)
{
}
if (DcModuleGroup[i].num > 1)
{
if (status != Valid)
{
if (DcModuleGroup[i].modules[1].status != Valid)
{
DcModuleGroup[i].status = Invalid;
}
}
}
else
{
if (status != Valid)
{
DcModuleGroup[i].status = Invalid;
}
}
}
Currt = 0;
Currt_A = 0;
Currt_B = 0;
Volt = 0;
Volt_A = 0;
Volt_B = 0;
Count = 0;
Count_A = 0;
Count_B = 0;
for (i = 0; i < DcModuleGroupSize; i++)
{
if (DcModuleGroup[i].status == Valid)
{
Volt += DcModuleGroup[i].Voltage;
Currt += DcModuleGroup[i].Current;
Count += DcModuleGroup[i].ValidNum;
}
else if (DcModuleGroup[i].status == Hold_A)
{
Volt_A += DcModuleGroup[i].Voltage;
Currt_A += DcModuleGroup[i].Current;
Count_A += DcModuleGroup[i].ValidNum;
}
else if (DcModuleGroup[i].status == Hold_B)
{
Volt_B += DcModuleGroup[i].Voltage;
Currt_B += DcModuleGroup[i].Current;
Count_B += DcModuleGroup[i].ValidNum;
}
}
DcModuleCtrl.ActualCurrt = Currt;
DcModuleCtrl.ActualVolt = Volt;
DcModuleCtrl_A.ActualCurrt = Currt_A;
DcModuleCtrl_A.ActualVolt = Volt_A;
DcModuleCtrl_B.ActualCurrt = Currt_B;
DcModuleCtrl_B.ActualVolt = Volt_B;
DcModuleManage.ValidNum = Count;
DcModuleManage_A.ValidNum = Count_A;
DcModuleManage_B.ValidNum = Count_B;
//if (0 == DcModuleManage_All.OnlineFlag)
// DcModuleCanInit();
}
void DcModuleCtrlProcess_SmartAllocation(void)
{
static u32 CtrlTick = 0;
static u8 LastFlag_A = 0;
static u8 LastFlag_B = 0;
static StructDcModuleUsedStatus status[4] =
{
Invalid, Invalid, Invalid, Invalid
};
StructDcModuleSend DataSend;
u32 Temp;
u8 addr;
Temp = 0;
for (u8 i = 0; i < DcModuleGroupSize; i++)
{
if (status[i] != DcModuleGroup[i].status)
{
if (DcModuleGroup[i].status == Valid)
{
//切换继电器
//关机
if (status[i] == Hold_A)
{
DcModuleManage_A.SetVolt = DcModuleAbility.MinVolt * 100;
DcModuleManage_A.SetCurrt = DcModuleAbility.MinCurrt * 100;
DcModuleManage_A.Cmd = 0xAA; //关机
}
else if (status[i] == Hold_B)
{
DcModuleManage_B.SetVolt = DcModuleAbility.MinVolt * 100;
DcModuleManage_B.SetCurrt = DcModuleAbility.MinCurrt * 100;
DcModuleManage_B.Cmd = 0xAA; //关机
}
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;
Temp = DcModuleAbility.MinCurrt * 100;
DataSend.Data[2] = (u8) (Temp >> 8);
DataSend.Data[3] = (u8) (Temp >> 0);
Temp = 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);
//放入队列
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] = 0xAA; //关机
//放入队列
}
}
else if (DcModuleGroup[i].status == Hold_A)
{
//切换继电器
}
else if (DcModuleGroup[i].status == Hold_B)
{
//切换继电器
}
else
{
//切换继电器
}
status[i] = DcModuleGroup[i].status;
}
}
if (LastFlag_A != DcModuleCtrl_A.CtrlFlag)
{
LastFlag_A = DcModuleCtrl_A.CtrlFlag;
Temp++;
}
if (LastFlag_B != DcModuleCtrl_B.CtrlFlag)
{
LastFlag_B = DcModuleCtrl_B.CtrlFlag;
Temp++;
}
if ((GetSystemTick() -CtrlTick) > 100)
{
CtrlTick = GetSystemTick();
Temp++;
}
if (0 == Temp)
return;
if (DcModuleCtrl_A.CtrlFlag)
{
if (DcModuleCtrl_A.NeedVolt > DcModuleAbility.MaxVolt)
DcModuleManage_A.SetVolt = (DcModuleAbility.MaxVolt * 100);
else if (DcModuleCtrl_A.NeedVolt > DcModuleAbility.MinVolt)
DcModuleManage_A.SetVolt = (DcModuleCtrl_A.NeedVolt * 100);
else
DcModuleManage_A.SetVolt = (DcModuleAbility.MinVolt * 100);
if (DcModuleManage_A.ValidNum)
{
Temp = (DcModuleCtrl_A.NeedCurrt * 100) / DcModuleManage_A.ValidNum;
if ((DcModuleCtrl_A.NeedCurrt * 100) % DcModuleManage_A.ValidNum)
Temp++;
}
else
Temp = DcModuleManage_A.SetCurrt;
if (Temp > (DcModuleAbility.MaxCurrt * 100))
Temp = (DcModuleAbility.MaxCurrt * 100);
else if (Temp < (DcModuleAbility.MinCurrt * 100))
Temp = (DcModuleAbility.MinCurrt * 100);
if (Temp <= DcModuleManage_A.SetCurrt)
DcModuleManage_A.SetCurrt = Temp;
else
{
DcModuleManage_A.SetCurrt += 500;
if (DcModuleManage_A.SetCurrt >= Temp)
DcModuleManage_A.SetCurrt = Temp;
}
if (DcModuleManage_A.SetCurrt > (DcModuleAbility.MaxCurrt * 100))
DcModuleManage_A.SetCurrt = (DcModuleAbility.MaxCurrt * 100);
else if (DcModuleManage_A.SetCurrt < (DcModuleAbility.MinCurrt * 100))
DcModuleManage_A.SetCurrt = (DcModuleAbility.MinCurrt * 100);
for (u8 i = 0; i < DcModuleGroupSize; i++)
{
if (DcModuleGroup[i].status != Hold_A)
continue;
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;
Temp = DcModuleManage_A.SetCurrt;
DataSend.Data[2] = (u8) (Temp >> 8);
DataSend.Data[3] = (u8) (Temp >> 0);
Temp = DcModuleManage_A.SetVolt;
DataSend.Data[4] = (u8) (Temp >> 24);
DataSend.Data[5] = (u8) (Temp >> 16);
DataSend.Data[6] = (u8) (Temp >> 8);
DataSend.Data[7] = (u8) (Temp >> 0);
//放入队列
DcModuleManage_A.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_A.Cmd;
//放入队列
}
}
}
else
{
}
if (DcModuleCtrl_B.CtrlFlag)
{
if (DcModuleCtrl_B.NeedVolt > DcModuleAbility.MaxVolt)
DcModuleManage_B.SetVolt = (DcModuleAbility.MaxVolt * 100);
else if (DcModuleCtrl_B.NeedVolt > DcModuleAbility.MinVolt)
DcModuleManage_B.SetVolt = (DcModuleCtrl_B.NeedVolt * 100);
else
DcModuleManage_B.SetVolt = (DcModuleAbility.MinVolt * 100);
if (DcModuleManage_B.ValidNum)
{
Temp = (DcModuleCtrl_B.NeedCurrt * 100) / DcModuleManage_B.ValidNum;
if ((DcModuleCtrl_B.NeedCurrt * 100) % DcModuleManage_B.ValidNum)
Temp++;
}
else
Temp = DcModuleManage_B.SetCurrt;
if (Temp > (DcModuleAbility.MaxCurrt * 100))
Temp = (DcModuleAbility.MaxCurrt * 100);
else if (Temp < (DcModuleAbility.MinCurrt * 100))
Temp = (DcModuleAbility.MinCurrt * 100);
if (Temp <= DcModuleManage_B.SetCurrt)
DcModuleManage_B.SetCurrt = Temp;
else
{
DcModuleManage_B.SetCurrt += 500;
if (DcModuleManage_B.SetCurrt >= Temp)
DcModuleManage_B.SetCurrt = Temp;
}
if (DcModuleManage_B.SetCurrt > (DcModuleAbility.MaxCurrt * 100))
DcModuleManage_B.SetCurrt = (DcModuleAbility.MaxCurrt * 100);
else if (DcModuleManage_B.SetCurrt < (DcModuleAbility.MinCurrt * 100))
DcModuleManage_B.SetCurrt = (DcModuleAbility.MinCurrt * 100);
for (u8 i = 0; i < DcModuleGroupSize; i++)
{
if (DcModuleGroup[i].status != Hold_B)
continue;
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;
Temp = DcModuleManage_B.SetCurrt;
DataSend.Data[2] = (u8) (Temp >> 8);
DataSend.Data[3] = (u8) (Temp >> 0);
Temp = DcModuleManage_B.SetVolt;
DataSend.Data[4] = (u8) (Temp >> 24);
DataSend.Data[5] = (u8) (Temp >> 16);
DataSend.Data[6] = (u8) (Temp >> 8);
DataSend.Data[7] = (u8) (Temp >> 0);
//放入队列
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;
//放入队列
}
}
}
else
{
}
}
DcPillar/Src/SmartAllocation/Drv_SmartAllocation.h 0 → 100644
#ifndef __DRV_SMARTALLOCATION_H__
#define __DRV_SMARTALLOCATION_H__
#include "Global.h"
typedef enum
{
Invalid = 0, //无效
Valid = 1, //有效且空闲
Hold_A = 2, //A枪占用
Hold_B = 3, //B枪占用
}StructDcModuleUsedStatus;
typedef struct
{
u8 addr;
u8 status;
u32 Voltage;
u32 Current;
}StructDcModule;
typedef struct
{
u8 num;
u8 ValidNum;
StructDcModule modules[2];
StructDcModuleUsedStatus status;
u32 Voltage;
u32 Current;
}StructDcModuleGroup;
typedef struct
{
u8 num;
u16 NeedVolt;//0.1V/Bit;
u16 NeedCurrt;//0.1A/Bit;
u16 ActualVolt;//0.1V/Bit;
u16 ActualCurrt;//0.1A/Bit;
}StructDcModuleGroupCtrl;
extern StructDcModuleGroup DcModuleGroup[];
extern StructDcModuleManage DcModuleManage_A;
#endif /*__DRV_SMARTALLOCATION_H__*/
DcPillar/Src/SmartAllocation/SmartAllocation_B_ChgRun.c 0 → 100644
#include "Thd_Charge.h"
#include "Thd_Charge_B.h"
#include "Drv_BoardIo.h"
#include "Drv_DcModule.h"
#include "Drv_BmsComm.h"
#include "Drv_ImdJyc.h"
#include "Drv_Meter.h"
#include "Memory.h"
#include "Drv_SmartAllocation.h"
s32 GetChgVoltChgRun_B(void)
{
return -1;
}
s32 GetChgCurrtChgRun_B(void)
{
return -1;
}
void SmartAllocation_ChgProChgRun_B(StructChargeCtrl_B *pChargeCtrl)
{
StructPgnRecv PgnRecv;
u32 CCS_SendTick = 0;
u32 CcStatusChkTick = 0;
u32 SocStopTick = 0;
u16 MaxCurrt = 0;
u16 NeedCurrt = 0;
u16 MaxVolt = 0;
u16 NeedVolt = 0;
u16 CcsChgEnable = 0;
u32 BmsPauseTick = 0;
s32 Temp = 0;
u32 CurrtOutChkTick = 0;
u32 UniChgTick = 0;
memset(&BemMsg_B, 0, sizeof(BemMsg_B));
memset(&CemMsg_B, 0, sizeof(CemMsg_B));
memset(&BstMsg_B, 0, sizeof(BstMsg_B));
memset(&CstMsg_B, 0, sizeof(CstMsg_B));
memset(&BsdMsg_B, 0, sizeof(BsdMsg_B));
memset(&CsdMsg_B, 0, sizeof(CsdMsg_B));
memset(&BmvMsg_B, 0xFF, sizeof(BmvMsg_B));
memset(&BmtMsg_B, 0xFF, sizeof(BmtMsg_B));
BmvMsg_B.Valid = 0;
BmtMsg_B.Valid = 0;
BemMsg_B.Valid = 0;
BstMsg_B.Valid = 0;
BmsCanInit_B();
osDelay(20);
ChargeTimerSet_B(eSwSta_On);
BmsPowerSet_B(eSwSta_On);
LockSet_B(eSwSta_On);
FanSet_B(eSwSta_On);
ImdWorkSet_B(eSwSta_Off);
DrainResistSet_B(eSwSta_Off);
DcOutSet_B(eSwSta_On);
CcsChgEnable = 1;
CCS_Send_B(GetDcModuleVolt_B(), (4000-GetDcModuleCurrt_B()), GetChgMin_B(), CcsChgEnable);
CCS_SendTick = GetSystemTick();
BclMsg_B.RecvTick = GetSystemTick();
BcsMsg_B.RecvTick = GetSystemTick();
BmsPauseTick = 0;
CurrtOutChkTick = 0;
UniChgEnable = FALSE;
UniChgTick = 0;
while(1)
{
if((GetSystemTick() - CCS_SendTick) > 50)
{
CCS_Send_B( MeterValue_B.Voltage, (4000- MeterValue_B.Current/100), GetChgMin(), CcsChgEnable);
CCS_SendTick = GetSystemTick();
}
ChgPgnRecv_B(&PgnRecv);
if((0 != ChargePauseFlag_B) || (0 != BmsPauseTick))
{
CcsChgEnable = 0;
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
}
else if(0 != BclMsg_B.Valid)
{
if(eChgVer_2011 != UserParam.ChgVer)
MaxCurrt = abs((s32)BcpMsg_B.ChgMaxCurrt - 4000);
else
MaxCurrt = abs((s32)BclMsg_B.NeedCurrt - 4000);
NeedCurrt = abs((s32)BclMsg_B.NeedCurrt - 4000);
static s16 GetCurrt_bak;
if(abs((s16)GetDcModuleCurrt_B()-GetCurrt_bak)<10 //输出电流稳定
&& (abs((s16)NeedCurrt-(s16)GetDcModuleCurrt_B())>(DcModuleAbility.MaxCurrt*10))
)
{
if(0 == UniChgTick)
UniChgTick = GetSystemTick();
if((GetSystemTick() - UniChgTick) > (5 * 1000))
{
if(NeedCurrt > GetDcModuleCurrt_B())
{
if(DcModuleGroup[3].status == Valid)
{
DcModuleGroup[3].status = Hold_B;
DcModuleManage_B.ValidNum += DcModuleGroup[3].ValidNum;
//切换继电器
}
else if(DcModuleGroup[2].status == Valid)
{
DcModuleGroup[2].status = Hold_B;
DcModuleManage.ValidNum += DcModuleGroup[2].ValidNum;
//切换继电器
}
else if(DcModuleGroup[1].status == Valid)
{
DcModuleGroup[1].status = Hold_B;
DcModuleManage.ValidNum += DcModuleGroup[1].ValidNum;
//切换继电器
}
}
else
{
if(DcModuleGroup[1].status == Hold_B)
{
DcModuleGroup[1].status = Valid;
DcModuleManage.ValidNum -= DcModuleGroup[1].ValidNum;
//切换继电器
}
else if(DcModuleGroup[2].status == Hold_B)
{
DcModuleGroup[2].status = Valid;
DcModuleManage.ValidNum -= DcModuleGroup[2].ValidNum;
//切换继电器
}
else if(DcModuleGroup[3].status == Hold_B)
{
DcModuleGroup[3].status = Valid;
DcModuleManage.ValidNum -= DcModuleGroup[3].ValidNum;
//切换继电器
}
}
UniChgTick = 0;
}
}
else
{
UniChgTick = 0;
GetCurrt_bak = GetDcModuleCurrt_B();
}
if(NeedCurrt > MaxCurrt)
NeedCurrt = MaxCurrt;
if(NeedCurrt > (DcModuleAbility.MaxCurrt*DcModuleManage_B.ValidNum))
NeedCurrt = DcModuleAbility.MaxCurrt*DcModuleManage_B.ValidNum;
MaxVolt = BcpMsg_B.ChgMaxVolt;
NeedVolt = BclMsg_B.NeedVolt;
if(NeedVolt > MaxVolt)
NeedVolt = MaxVolt;
if(NeedVolt > DcModuleAbility.MaxVolt)
NeedVolt = DcModuleAbility.MaxVolt;
CcsChgEnable = 1;
DcModuleSet_B(eSwSta_On, NeedVolt, NeedCurrt);
ChargeTimerSet_B(eSwSta_On);
}
if((eChgVer_2011 != UserParam.ChgVer) && (eChgVer_2011 != ChgVer_B))
{
Temp = GetChgVoltChgRun_B();
if((0 != CcsChgEnable) && (Temp >= DcModuleAbility.MinVolt) && (Temp > GetDcModuleVoltSet_B()))
{
if((Temp - GetDcModuleVoltSet_B()) > (GetDcModuleVoltSet_B()*5/100))
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CstMsg_B.StopFault.Value.Volt = 1;
ChargeError_B.Value.VoltOutError = 1;
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
DcOutSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_VoltOutHighErr;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
}
}
if((eChgVer_2011 != UserParam.ChgVer) && (eChgVer_2011 != ChgVer_B))
{
Temp = GetChgCurrtChgRun_B();
if((0 != CcsChgEnable) && (Temp > (DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum)) && (Temp > GetDcModuleCurrtSet_B()))
{
if((Temp - GetDcModuleCurrtSet_B()) > (GetDcModuleCurrtSet_B()*10/100))
{
if(0 == CurrtOutChkTick)
CurrtOutChkTick = GetSystemTick();
}
else
CurrtOutChkTick = 0;
}
else
CurrtOutChkTick = 0;
if((0 != CurrtOutChkTick) && ((GetSystemTick() - CurrtOutChkTick) > 10000))
{
CurrtOutChkTick = 0;
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CstMsg_B.StopFault.Value.Currt = 1;
ChargeError_B.Value.CurrtOutError = 1;
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
DcOutSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_CurrtOutHighErr;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
}
if(0 != BsmMsg_B.Valid)
{
if(0x00 != BsmMsg_B.BatSta.Value.Volt)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopFault.Value.Volt = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_SinglBatVolt;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
else if(0x00 != BsmMsg_B.BatSta.Value.Soc)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_SocOver;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
else if(0x01 == BsmMsg_B.BatSta.Value.Currt)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopFault.Value.Currt = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_CurrtOver;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
else if(0x01 == BsmMsg_B.BatSta.Value.Temp)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_BatTempOver;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
if(0x01 == BsmMsg_B.ChgSta.Value.Imd)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_BatIsolate;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
if(0x01 == BsmMsg_B.ChgSta.Value.Connect)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_Cc2Error;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
else if(0x00 == BsmMsg_B.ChgSta.Value.ChgEnable)
{
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
if(0 == BmsPauseTick)
BmsPauseTick = GetSystemTick();
if((0 != BmsPauseTick) && ((GetSystemTick() - BmsPauseTick) > MsgTimeout_B_10M))
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_BmsPause;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
}
else if(0x01 == BsmMsg_B.ChgSta.Value.ChgEnable)
BmsPauseTick = 0;
}
if((GetSystemTick() - BclMsg_B.RecvTick) > MsgTimeout_B_1S)
{
CemMsg_B.Cem.Value.Bcl = 1;
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
pChargeCtrl->CurProcess = eChgPro_B_CommBreak;
pChargeCtrl->Param = 0;
}
else
CemMsg_B.Cem.Value.Bcl = 0;
if((GetSystemTick() - BcsMsg_B.RecvTick) > MsgTimeout_B_5S)
{
CemMsg_B.Cem.Value.Bcs = 1;
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
pChargeCtrl->CurProcess = eChgPro_B_CommBreak;
pChargeCtrl->Param = 0;
}
else
CemMsg_B.Cem.Value.Bcs = 0;
if(0 != BemMsg_B.Valid)
{
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
pChargeCtrl->CurProcess = eChgPro_B_CommBreak;
pChargeCtrl->Param = 0;
}
if(0 != BstMsg_B.Valid)
{
CstMsg_B.StopReason.Value.BmsStop = 1;
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_BmsStop;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
if(0 == ChargeEnable_B)
{//外部控制结束充电
CstMsg_B.StopReason.Value.Manual = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_UserCancel;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
if((BcsMsg_B.Valid) && (BcsMsg_B.CurSoc >= 100))
{
if(0 == SocStopTick)
SocStopTick = GetSystemTick();
}
else
SocStopTick = 0;
if((0 != SocStopTick) && ((GetSystemTick() - SocStopTick) > (MsgTimeout_B_60S*2)))
{//外部控制结束充电
CstMsg_B.StopReason.Value.AutoSet = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_Soc98;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
if((BcsMsg_B.Valid) && (BcsMsg_B.BatVoltAndGroup.Value.Volt > BcpMsg_B.PerBatMaxVolt) && (1 == UserParam.ChgFun.Value.BatCellJud))
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopFault.Value.Volt = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
ChargeTimerSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_SinglBatVoltOverPermitMax;
pChargeCtrl->CurProcess = eChgPro_B_ChgStop;
pChargeCtrl->Param = 0;
}
if(eSwSta_On != CcStatusRead_B())
{
if(0 == CcStatusChkTick)
CcStatusChkTick = GetSystemTick();
}
else
CcStatusChkTick = 0;
if((0 != CcStatusChkTick) && ((GetSystemTick() - CcStatusChkTick) > CC_CheckTick_B))
{
CstMsg_B.StopReason.Value.Manual = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
DcOutSet_B(eSwSta_Off);
CcStatusChkTick = 0;
ChargeStopType_B = eChgStop_Run_CcOpen;
pChargeCtrl->CurProcess = eChgPro_B_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError_B.Value.Emergency)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Emergency = 1;
CST_Send_B(&CstMsg_B);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
DcOutSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_EmerClose;
pChargeCtrl->CurProcess = eChgPro_B_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError_B.Value.Door)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
DcOutSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_DoorOpen;
pChargeCtrl->CurProcess = eChgPro_B_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError_B.Value.Contactor)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
DcOutSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_Contactor;
pChargeCtrl->CurProcess = eChgPro_B_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError_B.Value.UniContactor)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
DcOutSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_Contactor;
pChargeCtrl->CurProcess = eChgPro_B_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError_B.Value.InVolt)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
DcOutSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_InVolt;
pChargeCtrl->CurProcess = eChgPro_B_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError_B.Value.NoDcmod)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
DcOutSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_NoDcmod;
pChargeCtrl->CurProcess = eChgPro_B_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError_B.Value.Meter)
{
CstMsg_B.StopReason.Value.Truble = 1;
CstMsg_B.StopTruble.Value.Other = 1;
CST_Send_B(&CstMsg);
DcModuleSet_B(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_B.ValidNum);
DcOutSet_B(eSwSta_Off);
ChargeStopType_B = eChgStop_Run_Meter;
pChargeCtrl->CurProcess = eChgPro_B_ChgBreak;
pChargeCtrl->Param = 0;
}
if(eChgPro_B_ChgRun != pChargeCtrl->CurProcess)
return;
osDelay(5);
}
}
DcPillar/Src/SmartAllocation/SmartAllocation_ChgRun.c 0 → 100644
#include "Thd_Charge.h"
#include "Thd_Charge_B.h"
#include "Drv_BoardIo.h"
#include "Drv_DcModule.h"
#include "Drv_BmsComm.h"
#include "Drv_ImdJyc.h"
#include "Drv_Meter.h"
#include "Memory.h"
#include "Drv_SmartAllocation.h"
s32 GetChgVoltChgRun(void)
{
return -1;
}
s32 GetChgCurrtChgRun(void)
{
return -1;
}
void SmartAllocation_ChgProChgRun(StructChargeCtrl *pChargeCtrl)
{
StructPgnRecv PgnRecv;
u32 CCS_SendTick = 0;
u32 CcStatusChkTick = 0;
u32 SocStopTick = 0;
u16 MaxCurrt = 0;
u16 NeedCurrt = 0;
u16 MaxVolt = 0;
u16 NeedVolt = 0;
u16 CcsChgEnable = 0;
u32 BmsPauseTick = 0;
s32 Temp = 0;
u32 CurrtOutChkTick = 0;
u32 UniChgTick = 0;
memset(&BemMsg, 0, sizeof(BemMsg));
memset(&CemMsg, 0, sizeof(CemMsg));
memset(&BstMsg, 0, sizeof(BstMsg));
memset(&CstMsg, 0, sizeof(CstMsg));
memset(&BsdMsg, 0, sizeof(BsdMsg));
memset(&CsdMsg, 0, sizeof(CsdMsg));
memset(&BmvMsg, 0xFF, sizeof(BmvMsg));
memset(&BmtMsg, 0xFF, sizeof(BmtMsg));
BmvMsg.Valid = 0;
BmtMsg.Valid = 0;
BemMsg.Valid = 0;
BstMsg.Valid = 0;
BmsCanInit();
osDelay(20);
ChargeTimerSet(eSwSta_On);
BmsPowerSet(eSwSta_On);
LockSet(eSwSta_On);
FanSet(eSwSta_On);
ImdWorkSet(eSwSta_Off);
DrainResistSet(eSwSta_Off);
DcOutSet(eSwSta_On);
CcsChgEnable = 1;
CCS_Send(GetDcModuleVolt(), (4000-GetDcModuleCurrt()), GetChgMin(), CcsChgEnable);
CCS_SendTick = GetSystemTick();
BclMsg.RecvTick = GetSystemTick();
BcsMsg.RecvTick = GetSystemTick();
BmsPauseTick = 0;
CurrtOutChkTick = 0;
UniChgEnable = FALSE;
UniChgTick = 0;
while(1)
{
if((GetSystemTick() - CCS_SendTick) > 50)
{
CCS_Send( MeterValue.Voltage, (4000- MeterValue.Current/100), GetChgMin(), CcsChgEnable);
CCS_SendTick = GetSystemTick();
}
ChgPgnRecv(&PgnRecv);
if((0 != ChargePauseFlag) || (0 != BmsPauseTick))
{
CcsChgEnable = 0;
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
}
else if(0 != BclMsg.Valid)
{
if(eChgVer_2011 != UserParam.ChgVer)
MaxCurrt = abs((s32)BcpMsg.ChgMaxCurrt - 4000);
else
MaxCurrt = abs((s32)BclMsg.NeedCurrt - 4000);
NeedCurrt = abs((s32)BclMsg.NeedCurrt - 4000);
static s16 GetCurrt_bak;
if(abs((s16)GetDcModuleCurrt()-GetCurrt_bak)<10 //输出电流稳定
&& (abs((s16)NeedCurrt-(s16)GetDcModuleCurrt())>(DcModuleAbility.MaxCurrt*10))
)
{
if(0 == UniChgTick)
UniChgTick = GetSystemTick();
if((GetSystemTick() - UniChgTick) > (10 * 1000))
{
if(NeedCurrt > GetDcModuleCurrt())
{
if(DcModuleGroup[1].status == Valid)
{
DcModuleGroup[1].status = Hold_A;
DcModuleManage_A.ValidNum += DcModuleGroup[1].ValidNum;
//切换继电器
}
else if(DcModuleGroup[3].status == Valid)
{
DcModuleGroup[3].status = Hold_A;
DcModuleManage_A.ValidNum += DcModuleGroup[3].ValidNum;
//切换继电器
}
else if(DcModuleGroup[2].status == Valid)
{
DcModuleGroup[2].status = Hold_A;
DcModuleManage_A.ValidNum += DcModuleGroup[2].ValidNum;
//切换继电器
}
}
else
{
if(DcModuleGroup[2].status == Hold_A)
{
DcModuleGroup[2].status = Valid;
DcModuleManage_A.ValidNum -= DcModuleGroup[2].ValidNum;
//切换继电器
}
else if(DcModuleGroup[3].status == Hold_A)
{
DcModuleGroup[3].status = Valid;
DcModuleManage_A.ValidNum -= DcModuleGroup[3].ValidNum;
//切换继电器
}
else if(DcModuleGroup[1].status == Hold_A)
{
DcModuleGroup[1].status = Valid;
DcModuleManage_A.ValidNum -= DcModuleGroup[1].ValidNum;
//切换继电器
}
}
UniChgTick = 0;
}
}
else
{
UniChgTick = 0;
GetCurrt_bak = GetDcModuleCurrt();
}
if(NeedCurrt > MaxCurrt)
NeedCurrt = MaxCurrt;
if(NeedCurrt > (DcModuleAbility.MaxCurrt*DcModuleManage_A.ValidNum))
NeedCurrt = DcModuleAbility.MaxCurrt*DcModuleManage_A.ValidNum;
MaxVolt = BcpMsg.ChgMaxVolt;
NeedVolt = BclMsg.NeedVolt;
if(NeedVolt > MaxVolt)
NeedVolt = MaxVolt;
if(NeedVolt > DcModuleAbility.MaxVolt)
NeedVolt = DcModuleAbility.MaxVolt;
CcsChgEnable = 1;
DcModuleSet(eSwSta_On, NeedVolt, NeedCurrt);
ChargeTimerSet(eSwSta_On);
}
/*电压异常判断*/
if((eChgVer_2011 != UserParam.ChgVer) && (eChgVer_2011 != ChgVer))
{
Temp = GetChgVoltChgRun();
if((0 != CcsChgEnable) && (Temp >= DcModuleAbility.MinVolt) && (Temp > GetDcModuleVoltSet()))
{
if((Temp - GetDcModuleVoltSet()) > (GetDcModuleVoltSet()*5/100))
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CstMsg.StopFault.Value.Volt = 1;
ChargeError.Value.VoltOutError = 1;
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
DcOutSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_VoltOutHighErr;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
}
}
/*电流异常判断*/
if((eChgVer_2011 != UserParam.ChgVer) && (eChgVer_2011 != ChgVer))
{
Temp = GetChgCurrtChgRun();
if((0 != CcsChgEnable) && (Temp > (DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum)) && (Temp > GetDcModuleCurrtSet()))
{
if((Temp - GetDcModuleCurrtSet()) > (GetDcModuleCurrtSet()*10/100))
{
if(0 == CurrtOutChkTick)
CurrtOutChkTick = GetSystemTick();
}
else
CurrtOutChkTick = 0;
}
else
CurrtOutChkTick = 0;
if((0 != CurrtOutChkTick) && ((GetSystemTick() - CurrtOutChkTick) > 10000))
{
CurrtOutChkTick = 0;
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CstMsg.StopFault.Value.Currt = 1;
ChargeError.Value.CurrtOutError = 1;
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
DcOutSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_CurrtOutHighErr;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
}
if(0 != BsmMsg.Valid)
{
if(0x00 != BsmMsg.BatSta.Value.Volt)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopFault.Value.Volt = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_SinglBatVolt;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
else if(0x00 != BsmMsg.BatSta.Value.Soc)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_SocOver;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
else if(0x01 == BsmMsg.BatSta.Value.Currt)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopFault.Value.Currt = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_CurrtOver;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
else if(0x01 == BsmMsg.BatSta.Value.Temp)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_BatTempOver;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
if(0x01 == BsmMsg.ChgSta.Value.Imd)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_BatIsolate;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
if(0x01 == BsmMsg.ChgSta.Value.Connect)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_Cc2Error;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
else if(0x00 == BsmMsg.ChgSta.Value.ChgEnable)
{
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
if(0 == BmsPauseTick)
BmsPauseTick = GetSystemTick();
if((0 != BmsPauseTick) && ((GetSystemTick() - BmsPauseTick) > MsgTimeout_10M))
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_BmsPause;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
}
else if(0x01 == BsmMsg.ChgSta.Value.ChgEnable)
BmsPauseTick = 0;
}
if((GetSystemTick() - BclMsg.RecvTick) > MsgTimeout_1S)
{
CemMsg.Cem.Value.Bcl = 1;
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
pChargeCtrl->CurProcess = eChgPro_CommBreak;
pChargeCtrl->Param = 0;
}
else
CemMsg.Cem.Value.Bcl = 0;
if((GetSystemTick() - BcsMsg.RecvTick) > MsgTimeout_5S)
{
CemMsg.Cem.Value.Bcs = 1;
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
pChargeCtrl->CurProcess = eChgPro_CommBreak;
pChargeCtrl->Param = 0;
}
else
CemMsg.Cem.Value.Bcs = 0;
if(0 != BemMsg.Valid)
{
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
pChargeCtrl->CurProcess = eChgPro_CommBreak;
pChargeCtrl->Param = 0;
}
if(0 != BstMsg.Valid)
{
CstMsg.StopReason.Value.BmsStop = 1;
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_BmsStop;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
if(0 == ChargeEnable)
{//外部控制结束充电
CstMsg.StopReason.Value.Manual = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_UserCancel;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
if((BcsMsg.Valid) && (BcsMsg.CurSoc >= 100))
{
if(0 == SocStopTick)
SocStopTick = GetSystemTick();
}
else
SocStopTick = 0;
if((0 != SocStopTick) && ((GetSystemTick() - SocStopTick) > (MsgTimeout_60S*2)))
{//外部控制结束充电
CstMsg.StopReason.Value.AutoSet = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_Soc98;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
if((BcsMsg.Valid) && (BcsMsg.BatVoltAndGroup.Value.Volt > BcpMsg.PerBatMaxVolt) && (1 == UserParam.ChgFun.Value.BatCellJud))
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopFault.Value.Volt = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
ChargeTimerSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_SinglBatVoltOverPermitMax;
pChargeCtrl->CurProcess = eChgPro_ChgStop;
pChargeCtrl->Param = 0;
}
if(eSwSta_On != CcStatusRead())
{
if(0 == CcStatusChkTick)
CcStatusChkTick = GetSystemTick();
}
else
CcStatusChkTick = 0;
if((0 != CcStatusChkTick) && ((GetSystemTick() - CcStatusChkTick) > CC_CheckTick))
{
CstMsg.StopReason.Value.Manual = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
DcOutSet(eSwSta_Off);
CcStatusChkTick = 0;
ChargeStopType = eChgStop_Run_CcOpen;
pChargeCtrl->CurProcess = eChgPro_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError.Value.Emergency)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Emergency = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
DcOutSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_EmerClose;
pChargeCtrl->CurProcess = eChgPro_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError.Value.Door)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
DcOutSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_DoorOpen;
pChargeCtrl->CurProcess = eChgPro_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError.Value.Contactor)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
DcOutSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_Contactor;
pChargeCtrl->CurProcess = eChgPro_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError.Value.UniContactor)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
DcOutSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_Contactor;
pChargeCtrl->CurProcess = eChgPro_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError.Value.InVolt)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
DcOutSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_InVolt;
pChargeCtrl->CurProcess = eChgPro_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError.Value.NoDcmod)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
DcOutSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_NoDcmod;
pChargeCtrl->CurProcess = eChgPro_ChgBreak;
pChargeCtrl->Param = 0;
}
if(0 != PillarError.Value.Meter)
{
CstMsg.StopReason.Value.Truble = 1;
CstMsg.StopTruble.Value.Other = 1;
CST_Send(&CstMsg);
DcModuleSet(eSwSta_Off, DcModuleAbility.MinVolt, DcModuleAbility.MinCurrt*DcModuleManage_A.ValidNum);
DcOutSet(eSwSta_Off);
ChargeStopType = eChgStop_Run_Meter;
pChargeCtrl->CurProcess = eChgPro_ChgBreak;
pChargeCtrl->Param = 0;
}
if(eChgPro_ChgRun != pChargeCtrl->CurProcess)
return;
osDelay(5);
}
}
DcPillar/Src/Thread/Thd_Charge.c
......@@ -62,6 +62,8 @@ extern void ChgProCommBeak_AB(StructChargeCtrl *pChargeCtrl);
extern void ChgProCommError_AB(StructChargeCtrl *pChargeCtrl);
extern void ChgProChgBreak_AB(StructChargeCtrl *pChargeCtrl);
extern void SmartAllocation_ChgProChgRun(StructChargeCtrl *pChargeCtrl);
const pChargeCtrlHandle ChargeCtrlHandle[] =
{
ChgProChgIdle,
......@@ -75,7 +77,7 @@ const pChargeCtrlHandle ChargeCtrlHandle[] =
ChgProWaitBmsReady,
ChgProWaitPillarReady,
ChgProChgStart,
ChgProChgRun,
SmartAllocation_ChgProChgRun,//ChgProChgRun,
ChgProWaitVoltChgRun,
ChgProChgStop,
ChgProCommBeak,
......@@ -150,8 +152,8 @@ void Thd_Charge(void const *parameter)
MemoryInit();
DcModuleInit();//DcModuleInit_B();
MeterInit();
DcOutInit_Uni();
//MeterInit();
//DcOutInit_Uni();
DcOutInit(); //DcOutInit_B();
FanInit();
......
DcPillar/Src/Thread/Thd_Charge_B.c
......@@ -39,6 +39,7 @@ extern void ChgProCommBeak_B(StructChargeCtrl_B *pChargeCtrl);
extern void ChgProCommError_B(StructChargeCtrl_B *pChargeCtrl);
extern void ChgProChgBreak_B(StructChargeCtrl_B *pChargeCtrl);
extern void SmartAllocation_ChgProChgRun_B(StructChargeCtrl_B *pChargeCtrl);
const pChargeCtrlHandle_B ChargeCtrlHandle_B[] =
{
......@@ -53,7 +54,7 @@ const pChargeCtrlHandle_B ChargeCtrlHandle_B[] =
ChgProWaitBmsReady_B,
ChgProWaitPillarReady_B,
ChgProChgStart_B,
ChgProChgRun_B,
SmartAllocation_ChgProChgRun_B,//ChgProChgRun_B,
ChgProWaitVoltChgRun_B,
ChgProChgStop_B,
ChgProCommBeak_B,
......@@ -106,7 +107,7 @@ void ChargeTimeCountCtrl_B(void const *Param)
/* the system main thread */
void Thd_Charge_B(void const *parameter)
{
DcModuleInit_B();
//DcModuleInit_B();
//MeterInit_B();
DcOutInit_B();
DrainResistInit_B();
......
DcPillar/Src/Thread/Thd_TCU.c
......@@ -13,6 +13,8 @@
#include "FTP_Upgrade.h"
extern void TCUCanInit(void);
StructTCUCommuStatus TCUCommuStatus =
{
.ChgNum = 0,
......@@ -104,6 +106,7 @@ void TCURecvProcess(void)
break;
case eCmd_TCUErroComm: // 计费单元错误帧
TCUErroCommAnalysis(&pPgnRecv);
break;
default:
......@@ -157,7 +160,7 @@ void DCMeasuring_A(void)
TCUCommuStatus.ConnectFlag = 0;
TCUCommuStatus.HeartBeatErrCnt = 0;
TCUCommuStatus.HeartBeatVaild = 0; //心跳失效
DcModuleCanInit_B(); //can通讯接口初始化
TCUCanInit(); //can通讯接口初始化
}
else
{
......@@ -193,7 +196,7 @@ void DCMeasuring_B(void)
TCUCommuStatus.ConnectFlag = 0;
TCUCommuStatus.HeartBeatErrCnt = 0;
TCUCommuStatus.HeartBeatVaild = 0; //心跳失效
DcModuleCanInit_B();
TCUCanInit();
}
else
{
......@@ -335,7 +338,7 @@ void TCUPillarHeartBeat(void)
{
u32 SendTick;
if (TCUCommuStatus.HeartBeatVaild == 0)
if (TCUCommuStatus.HeartBeatVaild != CONNECT_NORMAL)
return;
if (0 == TCUCommuStatus.HeartBeatRecvTime) //初始12s一次
......@@ -350,7 +353,7 @@ void TCUPillarHeartBeat(void)
TCUCommuStatus.ConnectFlag = 0;
TCUCommuStatus.HeartBeatErrCnt = 0;
TCUCommuStatus.HeartBeatVaild = 0; //心跳失效
DcModuleCanInit_B();
TCUCanInit();
}
else
{
......@@ -378,7 +381,7 @@ void TCUPillarHeartBeat_B(void)
{
u32 SendTick;
if (TCUCommuStatus.HeartBeatVaild == 0)
if (TCUCommuStatus.HeartBeatVaild != CONNECT_NORMAL)
return;
if (0 == TCUCommuStatus.HeartBeatRecvTime_B) //初始12s一次
......@@ -392,7 +395,7 @@ void TCUPillarHeartBeat_B(void)
TCUCommuStatus.ConnectFlag = 0;
TCUCommuStatus.HeartBeatErrCnt_B = 0;
TCUCommuStatus.HeartBeatVaild = 0; //心跳失效
DcModuleCanInit_B();
TCUCanInit();
}
else
{
......@@ -825,7 +828,7 @@ void TCUWorkProcess(void)
void TCULinkProcess(void) //心跳帧处理
{
TCUPillarHeartBeat(); //心跳处理
TCUPillarHeartBeat_B(); //心跳处理
//TCUPillarHeartBeat_B(); //心跳处理
CommutionConfigurationStage(); //配置阶段
CommutionRunStage(); //运行阶段
ConEMSend(); //ab超时发送逻辑
......@@ -836,12 +839,13 @@ void TCULinkProcess(void) //心跳帧处理
void TCUComm(void const * argument)
{
osDelay(6000);
TCUCommInit();
//DcModuleCanInit_B();
/**/ osDelay(6000);
for (; ; )
{
#if 1
TCURecvProcess(); //帧接收
TCUWorkProcess(); //遥测遥信息处理
TCULinkProcess(); //心跳包处理配置信息
......@@ -849,6 +853,21 @@ void TCUComm(void const * argument)
// TCUCodeDone();//告警故障处理
// TCUSaveEventDone();
#endif
#if 0
static u8 StatusGetCnt = 0;
StatusGetCnt++;
if(StatusGetCnt > 255)
StatusGetCnt = 0;
u8 Data[8] ={0};
Data[0] = StatusGetCnt;
TCUSinglePackSendMsg(Data, 8, eCmd_stopAck, 4);
#endif
osDelay(100);
}
}
......
DcPillar/Src/Thread/Thd_TCU.h
......@@ -5,7 +5,8 @@
#include "Drv_TCUComm.h"
#include "Thd_TcuControl.h"
#define CONNECT_NORMAL 0
#define CONNECT_TIMEOUT 1
typedef enum
{
......
DcPillar/Src/main.c
......@@ -128,7 +128,7 @@ int main(void)
osThreadDef(Thd_TCUControl, Thd_TCUControl, osPriorityNormal, 0, 2*configMINIMAL_STACK_SIZE);
osThreadCreate(osThread(Thd_TCUControl), NULL);
//osThreadDef(Internet, Internet, osPriorityNormal, 0, 2*configMINIMAL_STACK_SIZE);
// osThreadCreate(osThread(Internet), NULL);
//osThreadCreate(osThread(Internet), NULL);
osThreadDef(TCUComm, TCUComm, osPriorityNormal, 0, 2*configMINIMAL_STACK_SIZE);
osThreadCreate(osThread(TCUComm), NULL);
......@@ -136,7 +136,7 @@ int main(void)
}
DBGMCU_Config(DBGMCU_IWDG_STOP, ENABLE);
WdgInit();
//WdgInit();
/* Start scheduler */
osKernelStart();
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论