Skip to content

D
DC360_1drap3_xiaoju_V1
提交 3fce6c2f 作者: wysheng
操作

恢复原来的Drv_DcModuleIncre.c文件， 修改内容保存到Drv_SmartAllocation_DcModule.c

上级 de1188bb
正在显示 包含 3399 行增加 和 156 行删除
DcPillar/Projects/DcPillar.ewp
......@@ -2103,6 +2103,9 @@
</file>
<file>
<name>$PROJ_DIR$\..\Src\Drivers\Drv_DcModuleIncre.c</name>
<excluded>
<configuration>Debug</configuration>
</excluded>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Drivers\Drv_Dht12.c</name>
......@@ -2141,9 +2144,6 @@
<name>$PROJ_DIR$\..\Src\Drivers\Drv_SpiFlash.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Drivers\Drv_TCUComm.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Drivers\Drv_W5500.c</name>
</file>
<file>
......@@ -2159,6 +2159,9 @@
<name>$PROJ_DIR$\..\Src\SmartAllocation\Drv_SmartAllocation.h</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\Drv_SmartAllocation_DcModule.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\SmartAllocation_B_ChgRun.c</name>
</file>
<file>
......@@ -2166,6 +2169,18 @@
</file>
</group>
<group>
<name>TCU</name>
<file>
<name>$PROJ_DIR$\..\Src\Drivers\Drv_TCUComm.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Thd_TCU.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Thd_TcuControl.c</name>
</file>
</group>
<group>
<name>Threads</name>
<group>
<name>Charge</name>
......@@ -2581,12 +2596,6 @@
<file>
<name>$PROJ_DIR$\..\Src\Thread\Thd_Mult.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Thd_TCU.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Thd_TcuControl.c</name>
</file>
</group>
<file>
<name>$PROJ_DIR$\..\Src\FTP_Upgrade.c</name>
......
DcPillar/Projects/DcPillar.ewt
......@@ -409,9 +409,6 @@
<name>$PROJ_DIR$\..\Src\Drivers\Drv_SpiFlash.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Drivers\Drv_TCUComm.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Drivers\Drv_W5500.c</name>
</file>
<file>
......@@ -427,6 +424,9 @@
<name>$PROJ_DIR$\..\Src\SmartAllocation\Drv_SmartAllocation.h</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\Drv_SmartAllocation_DcModule.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\SmartAllocation\SmartAllocation_B_ChgRun.c</name>
</file>
<file>
......@@ -434,6 +434,18 @@
</file>
</group>
<group>
<name>TCU</name>
<file>
<name>$PROJ_DIR$\..\Src\Drivers\Drv_TCUComm.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Thd_TCU.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Thd_TcuControl.c</name>
</file>
</group>
<group>
<name>Threads</name>
<group>
<name>Charge</name>
......@@ -843,12 +855,6 @@
<file>
<name>$PROJ_DIR$\..\Src\Thread\Thd_Mult.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Thd_TCU.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\Src\Thread\Thd_TcuControl.c</name>
</file>
</group>
<file>
<name>$PROJ_DIR$\..\Src\FTP_Upgrade.c</name>
......
DcPillar/Src/Drivers/Drv_DcModuleIncre.c
......@@ -12,7 +12,42 @@
#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 =
{
......@@ -40,6 +75,7 @@ void DcModuleRxIrqHandle(void)
Union1939Id Id1939 = {.Mult = 0,};
UnionYouExtId CommId = {.Mult = 0,};
//IrSta = MCP2515_ReadReg(CANINTF);
IrSta = MCP2515_ReadStatus();
if(IrSta & 0x01)
......@@ -52,22 +88,74 @@ void DcModuleRxIrqHandle(void)
{
if((CAN_ID_EXT == RxMsg.IDE) && (CAN_RTR_DATA == RxMsg.RTR))
{
if((0x1207C080 == (RxMsg.ExtId & 0xFFFFFFC0)) && (0x01 == RxMsg.Data[0]))//模块状态回复
if(UserParam.Module.DCModType == eDCModType_ZhongXin )
{
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((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;
}
}
}
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;
}
}
}
}
}
else if(IrSta & 0x02)
if(IrSta & 0x02)
{
RecvFlag = MCP2515_Receive(1, &RxMsg);
MCP2515_BitModify(CANINTF, 0x02, 0x00);
......@@ -77,18 +165,70 @@ void DcModuleRxIrqHandle(void)
{
if((CAN_ID_EXT == RxMsg.IDE) && (CAN_RTR_DATA == RxMsg.RTR))
{
if((0x1207C080 == (RxMsg.ExtId & 0xFFFFFFC0)) && (0x01 == RxMsg.Data[0]))//模块状态回复
if(UserParam.Module.DCModType == eDCModType_ZhongXin )
{
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((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;
}
}
}
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;
}
}
}
}
}
......@@ -216,6 +356,1146 @@ 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)
......@@ -260,8 +1540,7 @@ u16 GetDcModuleCurrtSet(void)
return DcModuleCtrl.NeedCurrt;
}
osMessageQId DcModeMsg = 0;
extern void DcModuleManageProcess_SmartAllocation(void);
/* the system main thread */
void DcModule(void const *parameter)
{
......@@ -275,46 +1554,36 @@ 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)
{
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);
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);
}
}
}
......@@ -337,13 +1606,93 @@ void DcModuleRxIrqHandle_B(void)
Union1939Id Id1939 = {.Mult = 0,};
UnionYouExtId CommId = {.Mult = 0,};
//IrSta = MCP2515_ReadReg(CANINTF);
IrSta = MCP2515_B_ReadStatus();
//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;
}
}
}
}
}
if(IrSta & 0x01)
if(IrSta & 0x02)
{
RecvFlag = MCP2515_B_Receive(0, &RxMsg);
MCP2515_B_BitModify(CANINTF, 0x01, 0x00);
RecvFlag = MCP2515_B_Receive(1, &RxMsg);
MCP2515_B_BitModify(CANINTF, 0x02, 0x00);
Id1939.Mult = RxMsg.ExtId;
CommId.Mult = RxMsg.ExtId;
......@@ -364,7 +1713,6 @@ void DcModuleRxIrqHandle_B(void)
DcModuleStatus_B[Data.Id] = Data;
}
}
else if ((UserParam.Module.DCModType == eDCModType_YouYou)||
(UserParam.Module.DCModType == eDCModType_YouYouNormal) )
{
......@@ -400,41 +1748,9 @@ 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))
{
else
{
if((0x1207C080 == (RxMsg.ExtId & 0xFFFFFFC0)) && (0x01 == RxMsg.Data[0]))//模块状态回复
{
Data.Id = RxMsg.ExtId & 0x0000003F;
......@@ -445,7 +1761,7 @@ void DcModuleRxIrqHandle_B(void)
Data.RecvTime = GetSystemTick();
DcModuleStatus_B[Data.Id] = Data;
}
}
}
}
......@@ -492,9 +1808,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)|(0<<PHSEG11));
MCP2515_B_WriteReg(CNF2, (1<<BTLMODE)|(1<<PHSEG11));
// 设置 相位缓冲段 Phase Seg2为 3TQ ， 禁用唤醒滤波器
MCP2515_B_WriteReg(CNF3, (0<<PHSEG21) );
MCP2515_B_WriteReg(CNF3, (1<<PHSEG21) );
// 设置MCP2515中断使能寄存器,使能接收缓冲器中断
MCP2515_B_WriteReg(CANINTE, (1<<RX1IE)|(1<<RX0IE));
......@@ -566,6 +1882,1157 @@ 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)
{
......@@ -613,45 +3080,52 @@ 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_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
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);
}
}
}
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/SmartAllocation/Drv_SmartAllocation_DcModule.c 0 → 100644
/******************************************************************************
文件 : Drv_RunLedIncre.c
描述 : 英可瑞模块驱动
作者 :
修改 : 2015-04-02 郭涛 建立
******************************************************************************/
#include "Drv_DcModule.h"
#include "Drv_MCP2515.h"
#include "Memory.h"
StructDcModuleAbility DcModuleAbility =
{
.MaxVolt = DcModuleMaxVolt,
.MinVolt = DcModuleMinVolt,
.MaxCurrt = DcModuleMaxCurrt,
.MinCurrt = DcModuleMinCurrt,
.SingleMaxCurrt = DcModuleSinMaxCurrt,
};
StructDcModuleManage DcModuleManage;
StructDcModuleManage DcModuleManage_B;
StructDcModuleStatus DcModuleStatus[64];
StructDcModuleStatus DcModuleStatus_B[64];
StructDcModuleCtrl DcModuleCtrl;
StructDcModuleCtrl DcModuleCtrl_B;
void DcModuleRxIrqHandle(void)
{
CanRxMsg RxMsg;
u8 IrSta = 0;
StructDcModuleStatus Data;
u8 RecvFlag;
Union1939Id Id1939 = {.Mult = 0,};
UnionYouExtId CommId = {.Mult = 0,};
IrSta = MCP2515_ReadStatus();
if(IrSta & 0x01)
{
RecvFlag = MCP2515_Receive(0, &RxMsg);
MCP2515_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((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;
}
}
}
}
else if(IrSta & 0x02)
{
RecvFlag = MCP2515_Receive(1, &RxMsg);
MCP2515_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;
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;
}
}
}
}
}
/*125K*/
void DcModuleCanInit(void)
{
MCP2515_EnterCritical();
MCP2515_SetInt(DcModuleRxIrqHandle, DISABLE);
MCP2515_SpiInit();//初始化MCU的SPI总线
MCP2515_Reset();// MCP2515 启动前进行软件复位
//使用位修改指令将MCP2515设置为配置模式
//也就是将CANCTRL寄存器的REQOP[2:0]设置为100
MCP2515_BitModify(CANCTRL, 0xE0, (1<<REQOP2));
/*
//计算并设置MCP2515的位时间
// 时钟频率：Fosc = 16MHz
// 分频控制器 CNF1.BRP[5:0] = 7
// 最小时间份额 TQ = 2 * ( BRP + 1 ) / Fosc = 2*(7+1)/16M = 1uS
// 同步段 Sync Seg = 1TQ
// 传播段 Prop Seg = ( PRSEG + 1 ) * TQ = 1 TQ
// 相位缓冲段 Phase Seg1 = ( PHSEG1 + 1 ) * TQ = 3 TQ
// 相位缓冲段 Phase Seg2 = ( PHSEG2 + 1 ) * TQ = 3 TQ
// 同步跳转长度设置为 CNF1.SJW[1:0] = 00, 即 1TQ
// 总线波特率 NBR = Fbit = 1/(sync seg + Prop seg + PS1 + PS2 )
// = 1/(8TQ) = 1/8uS = 125kHz
//设置分频控制器CNF1.BRP[5:0] = 7，同步跳转长度设置为 CNF1.SJW[1:0] = 00
MCP2515_WriteReg( CNF1, (1<<BRP0)|(1<<BRP1)|(1<<BRP2) );
// 设置传播段 Prop Seg 为00，即1TQ，相位缓冲段 Phase Seg1的长度3TQ
MCP2515_WriteReg( CNF2, (1<<BTLMODE)|(1<<PHSEG11) );
// 设置 相位缓冲段 Phase Seg2为 3TQ ， 禁用唤醒滤波器
MCP2515_WriteReg( CNF3, (1<<PHSEG21) );
*/
MCP2515_WriteReg(CNF1, (1<<BRP0)|(1<<BRP1)|(1<<BRP2)); //125K
// 设置传播段 Prop Seg 为00，即1TQ，相位缓冲段 Phase Seg1的长度3TQ
MCP2515_WriteReg(CNF2, (1<<BTLMODE)|(1<<PHSEG11));
// 设置 相位缓冲段 Phase Seg2为 3TQ ， 禁用唤醒滤波器
MCP2515_WriteReg(CNF3, (1<<PHSEG21) );
// 设置MCP2515中断使能寄存器,使能接收缓冲器中断
MCP2515_WriteReg(CANINTE, (1<<RX1IE)|(1<<RX0IE));
//设置数据接收相关寄存器
// 设置RXM[1:0]=11,关闭接收缓冲器0屏蔽/滤波功能，接收所有报文；禁止滚存功能
//MCP2515_WriteReg(RXB0CTRL, (1<<RXM1)|(1<<RXM0));
MCP2515_WriteReg(RXB0CTRL, (1<<RXM1)|(1<<RXM0)|(1<<BUKT));
// 设置RXM[1:0]=11,关闭接收缓冲器1屏蔽/滤波功能，接收所有报文；
MCP2515_WriteReg(RXB1CTRL, (1<<RXM1)|(1<<RXM0));
u8 Temp[4] = {0, 0, 0, 0};
//设置6个验收滤波寄存器为0，
MCP2515_WriteBuffer(RXF0SIDH, Temp, 4);
MCP2515_WriteBuffer(RXF1SIDH, Temp, 4);
MCP2515_WriteBuffer(RXF2SIDH, Temp, 4);
MCP2515_WriteBuffer(RXF3SIDH, Temp, 4);
MCP2515_WriteBuffer(RXF4SIDH, Temp, 4);
MCP2515_WriteBuffer(RXF5SIDH, Temp, 4);
//设置2个验收滤波寄存器为0，
MCP2515_WriteBuffer(RXM0SIDH, Temp, 4);
MCP2515_WriteBuffer(RXM1SIDH, Temp, 4);
//配置引脚
//设置接收相关引脚控制寄存器，配置它们禁用第二功能
MCP2515_WriteReg(BFPCTRL, 0);
//调试使用，设置BFPCTRL使RX0BF,RX1BF设置为数字输出。
//MCP2515_BitModify( BFPCTRL, (1<<B1BFE)|(1<<B0BFE)|(1<<B1BFM)|(1<<B0BFM), (1<<B1BFE)|(1<<B0BFE) );
//设置发送相关引脚控制寄存器，配置它们禁用第二功能
MCP2515_WriteReg(TXRTSCTRL, 0);
//MCP2515进入环回模式，进行功能测试
//MCP2515_BitModify(CANCTRL, 0XE0, (1<<REQOP1));
//MCP2515进入正常模式
MCP2515_BitModify(CANCTRL, 0xE0, 0);
MCP2515_SetInt(DcModuleRxIrqHandle, ENABLE);
MCP2515_ExitCritical();
MCP2515_SpiHightSpeedInit();
}
/**************************************************************************************************
** 函数名: CAN1_SendMessage
** 输　入: ulCanId----发送ID， ulCanDataA----发送数据的底4字节， ulCanDataB----发送数据的高4字节
** 输　出: 参数读取状态
** 描 述: 通过CAN通道发送数据
** 日　期: 2010/08/19
**************************************************************************************************/
u8 DcModuleSendMsg(StructDcModuleSend *pMsg)
{
CanTxMsg TxMsg;
TxMsg.ExtId = pMsg->Id;
TxMsg.IDE = CAN_ID_EXT;
TxMsg.RTR = CAN_RTR_DATA;
TxMsg.DLC = pMsg->Len;
TxMsg.Data[0] = pMsg->Data[0];
TxMsg.Data[1] = pMsg->Data[1];
TxMsg.Data[2] = pMsg->Data[2];
TxMsg.Data[3] = pMsg->Data[3];
TxMsg.Data[4] = pMsg->Data[4];
TxMsg.Data[5] = pMsg->Data[5];
TxMsg.Data[6] = pMsg->Data[6];
TxMsg.Data[7] = pMsg->Data[7];
if(CAN_TxStatus_NoMailBox != MCP2515_Transmit(&TxMsg))
return TRUE;
return FALSE; //未发送成功，返回FALSE
}
void DcModuleSet(EnumSwitchStatus Set, u16 Volt, u16 Currt)
{
if(Currt> DcModuleAbility.SingleMaxCurrt)
Currt = DcModuleAbility.SingleMaxCurrt;
if(eSwSta_Off == Set)
{
DcModuleCtrl.CtrlFlag = 0;
DcModuleCtrl.NeedVolt = Volt;
DcModuleCtrl.NeedCurrt = Currt;
}
else
{
DcModuleCtrl.CtrlFlag = 1;
DcModuleCtrl.NeedVolt = Volt;
DcModuleCtrl.NeedCurrt = Currt;
}
}
u16 GetDcModuleVolt(void)
{
//return DcModuleCtrl.ActualVolt*201/200;
return (u16)((u32)DcModuleCtrl.ActualVolt*UserParam.VoltRatio/1000);
}
u16 GetDcModuleCurrt(void)
{
//return DcModuleCtrl.ActualCurrt*202/200;
return (u16)((u32)DcModuleCtrl.ActualCurrt*UserParam.CurrtRatio/1000);
}
u16 GetDcModuleVoltSet(void)
{
//return DcModuleManage.SetVolt/100;
return DcModuleCtrl.NeedVolt;
}
u16 GetDcModuleCurrtSet(void)
{
//return DcModuleManage.SetVolt*DcModuleManage.ValidNum/100;
return DcModuleCtrl.NeedCurrt;
}
osMessageQId DcModeMsg = 0;
extern void DcModuleManageProcess_SmartAllocation(void);
/* the system main thread */
void DcModule(void const *parameter)
{
osDelay(6000);
DcModuleCanInit();
DcModuleAbility.MaxVolt = UserParam.DcMaxVolt;
DcModuleAbility.MinVolt = UserParam.DcMinVolt;
DcModuleAbility.MaxCurrt = UserParam.DcMaxCurrt;
DcModuleAbility.MinCurrt = UserParam.DcMinCurrt;
DcModuleAbility.SingleMaxCurrt= UserParam.SingleMaxCurrt;
DcModeMsg = NULL;
osMessageQDef(DcModeMsg, 64, StructDcModuleSend);
DcModeMsg = osMessageCreate(osMessageQ(DcModeMsg), NULL);
while(1)
{
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);
}
}
u8 DcModuleInit(void)
{
osThreadDef(DcModule, DcModule, osPriorityAboveNormal, 0, configMINIMAL_STACK_SIZE);
if(NULL == osThreadCreate(osThread(DcModule), NULL))
return FALSE;
return TRUE;
}
void DcModuleRxIrqHandle_B(void)
{
CanRxMsg RxMsg;
u8 IrSta = 0;
StructDcModuleStatus Data;
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;
}
}
}
}
}
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;
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;
}
}
}
}
}
/*125K*/
void DcModuleCanInit_B(void)
{
MCP2515_B_EnterCritical();
MCP2515_B_SetInt(DcModuleRxIrqHandle_B, DISABLE);
MCP2515_B_SpiInit();//初始化MCU的SPI总线
MCP2515_B_Reset();// MCP2515 启动前进行软件复位
//使用位修改指令将MCP2515设置为配置模式
//也就是将CANCTRL寄存器的REQOP[2:0]设置为100
MCP2515_B_BitModify(CANCTRL, 0xE0, (1<<REQOP2));
/*
//计算并设置MCP2515的位时间
// 时钟频率：Fosc = 16MHz
// 分频控制器 CNF1.BRP[5:0] = 7
// 最小时间份额 TQ = 2 * ( BRP + 1 ) / Fosc = 2*(7+1)/16M = 1uS
// 同步段 Sync Seg = 1TQ
// 传播段 Prop Seg = ( PRSEG + 1 ) * TQ = 1 TQ
// 相位缓冲段 Phase Seg1 = ( PHSEG1 + 1 ) * TQ = 3 TQ
// 相位缓冲段 Phase Seg2 = ( PHSEG2 + 1 ) * TQ = 3 TQ
// 同步跳转长度设置为 CNF1.SJW[1:0] = 00, 即 1TQ
// 总线波特率 NBR = Fbit = 1/(sync seg + Prop seg + PS1 + PS2 )
// = 1/(8TQ) = 1/8uS = 125kHz
//设置分频控制器CNF1.BRP[5:0] = 7，同步跳转长度设置为 CNF1.SJW[1:0] = 00
MCP2515_WriteReg( CNF1, (1<<BRP0)|(1<<BRP1)|(1<<BRP2) );
// 设置传播段 Prop Seg 为00，即1TQ，相位缓冲段 Phase Seg1的长度3TQ
MCP2515_WriteReg( CNF2, (1<<BTLMODE)|(1<<PHSEG11) );
// 设置 相位缓冲段 Phase Seg2为 3TQ ， 禁用唤醒滤波器
MCP2515_WriteReg( CNF3, (1<<PHSEG21) );
*/
MCP2515_B_WriteReg(CNF1, (1<<BRP0)|(1<<BRP1)|(1<<BRP2)); //125K
// 设置传播段 Prop Seg 为00，即1TQ，相位缓冲段 Phase Seg1的长度3TQ
MCP2515_B_WriteReg(CNF2, (1<<BTLMODE)|(0<<PHSEG11));
// 设置 相位缓冲段 Phase Seg2为 3TQ ， 禁用唤醒滤波器
MCP2515_B_WriteReg(CNF3, (0<<PHSEG21) );
// 设置MCP2515中断使能寄存器,使能接收缓冲器中断
MCP2515_B_WriteReg(CANINTE, (1<<RX1IE)|(1<<RX0IE));
//设置数据接收相关寄存器
// 设置RXM[1:0]=11,关闭接收缓冲器0屏蔽/滤波功能，接收所有报文；禁止滚存功能
//MCP2515_WriteReg(RXB0CTRL, (1<<RXM1)|(1<<RXM0));
MCP2515_B_WriteReg(RXB0CTRL, (1<<RXM1)|(1<<RXM0)|(1<<BUKT));
// 设置RXM[1:0]=11,关闭接收缓冲器1屏蔽/滤波功能，接收所有报文；
MCP2515_B_WriteReg(RXB1CTRL, (1<<RXM1)|(1<<RXM0));
u8 Temp[4] = {0, 0, 0, 0};
//设置6个验收滤波寄存器为0，
MCP2515_B_WriteBuffer(RXF0SIDH, Temp, 4);
MCP2515_B_WriteBuffer(RXF1SIDH, Temp, 4);
MCP2515_B_WriteBuffer(RXF2SIDH, Temp, 4);
MCP2515_B_WriteBuffer(RXF3SIDH, Temp, 4);
MCP2515_B_WriteBuffer(RXF4SIDH, Temp, 4);
MCP2515_B_WriteBuffer(RXF5SIDH, Temp, 4);
//设置2个验收滤波寄存器为0，
MCP2515_B_WriteBuffer(RXM0SIDH, Temp, 4);
MCP2515_B_WriteBuffer(RXM1SIDH, Temp, 4);
//配置引脚
//设置接收相关引脚控制寄存器，配置它们禁用第二功能
MCP2515_B_WriteReg(BFPCTRL, 0);
//调试使用，设置BFPCTRL使RX0BF,RX1BF设置为数字输出。
//MCP2515_BitModify( BFPCTRL, (1<<B1BFE)|(1<<B0BFE)|(1<<B1BFM)|(1<<B0BFM), (1<<B1BFE)|(1<<B0BFE) );
//设置发送相关引脚控制寄存器，配置它们禁用第二功能
MCP2515_B_WriteReg(TXRTSCTRL, 0);
//MCP2515进入环回模式，进行功能测试
//MCP2515_BitModify(CANCTRL, 0XE0, (1<<REQOP1));
//MCP2515进入正常模式
MCP2515_B_BitModify(CANCTRL, 0xE0, 0);
MCP2515_B_SetInt(DcModuleRxIrqHandle_B, ENABLE);
MCP2515_B_ExitCritical();
MCP2515_B_SpiHightSpeedInit();
}
u8 DcModuleSendMsg_B(StructDcModuleSend *pMsg)
{
CanTxMsg TxMsg;
TxMsg.ExtId = pMsg->Id;
TxMsg.IDE = CAN_ID_EXT;
TxMsg.RTR = CAN_RTR_DATA;
TxMsg.DLC = pMsg->Len;
TxMsg.Data[0] = pMsg->Data[0];
TxMsg.Data[1] = pMsg->Data[1];
TxMsg.Data[2] = pMsg->Data[2];
TxMsg.Data[3] = pMsg->Data[3];
TxMsg.Data[4] = pMsg->Data[4];
TxMsg.Data[5] = pMsg->Data[5];
TxMsg.Data[6] = pMsg->Data[6];
TxMsg.Data[7] = pMsg->Data[7];
if(CAN_TxStatus_NoMailBox != MCP2515_B_Transmit(&TxMsg))
return TRUE;
return FALSE; //未发送成功，返回FALSE
}
void DcModuleSet_B(EnumSwitchStatus Set, u16 Volt, u16 Currt)
{
if(Currt> DcModuleAbility.SingleMaxCurrt)
Currt = DcModuleAbility.SingleMaxCurrt;
if(eSwSta_Off == Set)
{
DcModuleCtrl_B.CtrlFlag = 0;
DcModuleCtrl_B.NeedVolt = Volt;
DcModuleCtrl_B.NeedCurrt = Currt;
}
else
{
DcModuleCtrl_B.CtrlFlag = 1;
DcModuleCtrl_B.NeedVolt = Volt;
DcModuleCtrl_B.NeedCurrt = Currt;
}
}
u16 GetDcModuleVolt_B(void)
{
//return DcModuleCtrl_B.ActualVolt;
return (u16)((u32)DcModuleCtrl_B.ActualVolt*UserParam.VoltRatio/1000);
}
u16 GetDcModuleCurrt_B(void)
{
//return DcModuleCtrl_B.ActualCurrt;
return (u16)((u32)DcModuleCtrl_B.ActualCurrt*UserParam.CurrtRatio/1000);
}
u16 GetDcModuleVoltSet_B(void)
{
//return DcModuleManage_B.SetVolt/100;
return DcModuleCtrl_B.NeedVolt;
}
u16 GetDcModuleCurrtSet_B(void)
{
//return DcModuleManage_B.SetVolt*DcModuleManage_B.ValidNum/100;
return DcModuleCtrl_B.NeedCurrt;
}
/* the system main thread */
void DcModule_B(void const *parameter)
{
osDelay(6000);
DcModuleCanInit_B();
while(1)
{
{
//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)
{
osThreadDef(DcModule_B, DcModule_B, osPriorityAboveNormal, 0, configMINIMAL_STACK_SIZE);
if(NULL == osThreadCreate(osThread(DcModule_B), NULL))
return FALSE;
return TRUE;
}
void DcModuleSet_AB(EnumSwitchStatus Set, u16 Volt, u16 Currt)
{
if(eSwSta_Off == Set)
{
DcModuleCtrl.NeedVolt = DcModuleAbility.MinVolt;
DcModuleCtrl.NeedCurrt = DcModuleAbility.MinCurrt * DcModuleManage.ValidNum;
DcModuleCtrl_B.NeedVolt = DcModuleAbility.MinVolt;
DcModuleCtrl_B.NeedCurrt = DcModuleAbility.MinCurrt * DcModuleManage_B.ValidNum;
DcModuleCtrl.CtrlFlag = 0;
DcModuleCtrl_B.CtrlFlag = 0;
}
else
{
if(ChargeEnable_AB == 0)//单枪连冲
{
if(Currt> DcModuleAbility.SingleMaxCurrt)
Currt = DcModuleAbility.SingleMaxCurrt;
}
if(0 == DcModuleManage_B.ValidNum)
{
if(0 == DcModuleManage.ValidNum)
{
DcModuleCtrl.NeedVolt = DcModuleAbility.MinVolt;
DcModuleCtrl.NeedCurrt = DcModuleAbility.MinCurrt * DcModuleManage.ValidNum;
DcModuleCtrl.CtrlFlag = 0;
}
else
{
DcModuleCtrl.NeedVolt = Volt;
DcModuleCtrl.NeedCurrt = Currt; //* (DcModuleManage.ValidNum / (DcModuleManage.ValidNum + DcModuleManage_B.ValidNum));
DcModuleCtrl.CtrlFlag = 1;
}
DcModuleCtrl_B.NeedVolt = DcModuleAbility.MinVolt;
DcModuleCtrl_B.NeedCurrt = DcModuleAbility.MinCurrt * DcModuleManage_B.ValidNum;
DcModuleCtrl_B.CtrlFlag = 0;
}
else if(0 == DcModuleManage.ValidNum)
{
DcModuleCtrl_B.NeedVolt = Volt;
DcModuleCtrl_B.NeedCurrt = Currt;
DcModuleCtrl_B.CtrlFlag = 1;
DcModuleCtrl.NeedVolt = DcModuleAbility.MinVolt;
DcModuleCtrl.NeedCurrt = DcModuleAbility.MinCurrt * DcModuleManage.ValidNum;
DcModuleCtrl.CtrlFlag = 0;
}
else
{
DcModuleCtrl.NeedVolt = Volt;
DcModuleCtrl_B.NeedVolt = Volt;
DcModuleCtrl.NeedCurrt = (u16)(Currt * ((float)(DcModuleManage.ValidNum) / (DcModuleManage.ValidNum + DcModuleManage_B.ValidNum)));
DcModuleCtrl_B.NeedCurrt = (u16)(Currt * ((float)(DcModuleManage_B.ValidNum) / (DcModuleManage.ValidNum + DcModuleManage_B.ValidNum)));
DcModuleCtrl.CtrlFlag = 1;
DcModuleCtrl_B.CtrlFlag = 1;
}
}
if(ChargeEnable_AB == 1)//双枪连充
{
if(DcModuleCtrl.NeedCurrt> DcModuleAbility.SingleMaxCurrt)
DcModuleCtrl.NeedCurrt = DcModuleAbility.SingleMaxCurrt;
if(DcModuleCtrl_B.NeedCurrt> DcModuleAbility.SingleMaxCurrt)
DcModuleCtrl_B.NeedCurrt = DcModuleAbility.SingleMaxCurrt;
}
}
u16 GetDcModuleVolt_AB(void)
{
if(0 == DcModuleCtrl.CtrlFlag)
return GetDcModuleVolt_B();
if(0 == DcModuleCtrl_B.CtrlFlag)
return GetDcModuleVolt();
return (GetDcModuleVolt() + GetDcModuleVolt_B())/2;
}
u16 GetDcModuleCurrt_AB(void)
{
return (GetDcModuleCurrt() + GetDcModuleCurrt_B());
}
u16 GetDcModuleVoltSet_AB(void)
{
//return DcModuleManage.SetVolt/100;
return (DcModuleCtrl.NeedVolt + DcModuleCtrl_B.NeedVolt)/2;
}
u16 GetDcModuleCurrtSet_AB(void)
{
//return DcModuleManage.SetVolt*DcModuleManage.ValidNum/100;
return (DcModuleCtrl.NeedCurrt + DcModuleCtrl_B.NeedCurrt);
}
DcPillar/Src/SmartAllocation/SmartAllocation_B_ChgRun.c
......@@ -22,7 +22,7 @@ s32 GetChgCurrtChgRun_B(void)
return -1;
}
void SmartAllocation_ChgProChgRun_B(StructChargeCtrl_B *pChargeCtrl)
void ChgProChgRun_B(StructChargeCtrl_B *pChargeCtrl)
{
StructPgnRecv PgnRecv;
u32 CCS_SendTick = 0;
......
DcPillar/Src/SmartAllocation/SmartAllocation_ChgRun.c
......@@ -25,7 +25,7 @@ s32 GetChgCurrtChgRun(void)
return -1;
}
void SmartAllocation_ChgProChgRun(StructChargeCtrl *pChargeCtrl)
void ChgProChgRun(StructChargeCtrl *pChargeCtrl)
{
StructPgnRecv PgnRecv;
u32 CCS_SendTick = 0;
......
DcPillar/Src/Thread/Thd_Charge.c
......@@ -62,8 +62,6 @@ 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,
......@@ -77,7 +75,7 @@ const pChargeCtrlHandle ChargeCtrlHandle[] =
ChgProWaitBmsReady,
ChgProWaitPillarReady,
ChgProChgStart,
SmartAllocation_ChgProChgRun,//ChgProChgRun,
ChgProChgRun,
ChgProWaitVoltChgRun,
ChgProChgStop,
ChgProCommBeak,
......
DcPillar/Src/Thread/Thd_Charge_B.c
......@@ -39,8 +39,6 @@ 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[] =
{
ChgProChgIdle_B,
......@@ -54,7 +52,7 @@ const pChargeCtrlHandle_B ChargeCtrlHandle_B[] =
ChgProWaitBmsReady_B,
ChgProWaitPillarReady_B,
ChgProChgStart_B,
SmartAllocation_ChgProChgRun_B,//ChgProChgRun_B,
ChgProChgRun_B,
ChgProWaitVoltChgRun_B,
ChgProChgStop_B,
ChgProCommBeak_B,
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论