*=========================================================================
=========================================================================*/
//库文件包含
#include <stdlib.h>
#include <math.h>
#include <limits.h>
//==========================================================================
#pragma CODE_SECTION(main,"flashDFuncs")
#pragma CODE_SECTION(MainCycle,"flashDFuncs")
#pragma CODE_SECTION(MsTask,"ramfuncs")
#pragma CODE_SECTION(EQep1Isr,"ramfuncs")
#define TOPPWD 1218 //定义最高权限密码(厂家使用)
#define SOFT_VER 319 //2009-06 变更标志: ld-09-06-03 & sy0906
//头文件包含
#include "include\DSP2806_Device.h"
#include "AD200\include\Panel.h"
#include "AD200\include\globalQ.h"
#include "AD200\include\GlobalConst.h"
#include "AD200\include\GlobalVar.h"
#include "AD200\include\DSP2806_GlobalPrototypes.h"
#include "AD200\include\Parameter.h"
#include "AD200\include\GpioOut.h"
#include "AD200\include\93LC86.h"
#include "AD200\include\DigitalIO.h"
#include "AD200\include\AdcFunction.h"
#include "AD200\include\AnalogIO.h"
#include "AD200\include\PFunc.h"
#include "AD200\include\plc.h"
#include "AD200\include\PID.h"
#include "AD200\include\various.h"
#include "AD200\include\AdMathTable.h"
#include "AD200\include\wobble.h"
#include "AD200\include\modbus.h"
#include "AD200\include\MotorParaAutoMeas.h"
#include "AD200\include\MotorModel.h"
//==========================================================================
//源文件包含
#include "AD200\source\XInterrupt.c"
#include "AD200\source\AdMath.c"
#include "AD200\source\GlobalFunction.c"
#include "AD200\source\byTypePrar.c"
#include "AD200\source\93LC86.c"
#include "AD200\source\DigitalIO.c"
#include "AD200\source\AdcFunction.c"
#include "AD200\source\AnalogIO.c"
#include "AD200\source\Panel.c"
#include "AD200\source\PFunc.c"
#include "AD200\source\plc.c"
#include "AD200\source\PID.c"
#include "AD200\source\Dynamic.c"
#include "AD200\source\wobble.c"
#include "AD200\source\RunModeSel.c"
#include "AD200\source\MotorFormula.c"
#include "AD200\source\SvGendq.c"
#include "AD200\source\MotorParaAutoMeas.c"
#include "AD200\source\ASR.c"
#include "AD200\source\VectorCtrl.c"
#include "AD200\source\variblize.c"
#include "AD200\source\InverterCtrlnow.c"
#include "AD200\source\vvvfh.c"
#include "AD200\source\MotorModel.c"
#include "AD200\source\EPwm1Isr.c"
#include "AD200\source\pfo.c"
#include "AD200\source\PFI.c"
#include "AD200\source\ModBusInit.c"
#include "AD200\source\modbus.c"
#include "AD200\source\pgSpeed_now.c"
#include "AD200\source\torqCtrl.c"
//==========================================================================
//函数原型声明
extern Uint16 ramtable_loadstart;
extern Uint16 ramtable_loadend;
extern Uint16 ramtable_runstart;
extern Uint16 RamfuncsLoadStart;
extern Uint16 RamfuncsLoadEnd;
extern Uint16 RamfuncsRunStart;
extern interrupt void EQep1Isr(void);
extern interrupt void Xint1Isr(void);
extern interrupt void AdcIsr(void);
extern interrupt void EPwm1Isr(void);
extern interrupt void Ecap1Isr(void);
//extern interrupt void Ecap2Isr(void);
extern void MainCycle(void);
extern void PrarIndexAndMaxCarryFCal(Uint16 driveTypeTemp);
//==========================================================================
//主函数
//==========================================================================
void main(void)
{
DisableDog();
//======================================================================
InitSysCtrl(); //In DSP2806_SysCtrl.c
InitGpio(); //In DSP2806_Gpio.c
DINT; //Disable global interrupts
//======================================================================
InitPieCtrl(); //In DSP2806_PieCtrl.c
IER = 0x0000;
IFR = 0x0000;
InitPieVectTable(); //In DSP2806_PieVectInit.c
//======================================================================
MemCopy(&ramtable_loadstart, &ramtable_loadend, &ramtable_runstart);
MemCopy(&RamfuncsLoadStart, &RamfuncsLoadEnd, &RamfuncsRunStart);
InitFlash(); //In DSP2806_Gpio.c
//======================================================================
InitCpuTimers(); //In DSP2806_CpuTimes.c
InitAdc(); //In DSP2806_ADC.c
// InitECan(); //In DSP2806_eCAN.c
// InitI2C(); //In DSP2806_I2C.c
InitSci(); //In DSP2806_SCI.c
InitSpi(); //In DSP2806_SPI.c
XIntCtrl(); //In DSP2806_XIntCtrl.c
InitEQep(); //In DSP2806_eQEP.c
InitECap(); //In DSP2806_eCAP.c
EALLOW;
SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 0;
EDIS;
InitEPwm(); //In DSP2806_ePWM.c
EALLOW;
SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 1;
EDIS;
BLOCK();
InitEPwmGpio();
//======================================================================
ReadAWord(&verToEEP, 800);
if(verToEEP != SOFT_VER)
{
WriteWords(0, pFacValue, paraNum);
verToEEP = SOFT_VER;
WriteAWord(800, verToEEP);
}
SELEEPROM();
BoardSpiState = EEPIdleE;
DELAY_MS(5);
InitPanel();
PrarIndexAndMaxCarryFCal(P.driveType); //参数表索引计算最大载频计算
//PType080625
BaseValueCalc(); //基值计算
FullScaleCalc(); //满幅值计算
CoeffOnlineCal(); //一些系数的计算
CoeffOfTcCal();
ParaToUsedCalc();
LmSatCalc();
fsHzUlti = MIN_CARRIER_F; //ysh090223
adType = DISP_b;//注：根据机型种类更改此显示值。
modbusStruct.setRefSpeed = 0;
digRefSpd = P.innerSpdVal0;
innerSpdVal0Old = P.innerSpdVal0;
powOnSelfRun = P.powOnSelfRunEn;
tmpMop32 = (long)P.mopValSave *1000 * 10;
Ad.iuAdSum = 0;
Ad.ivAdSum = 0;
Ad.iwAdSum = 0;
Ad.vdcAdSum = 0;
Ad.vuvAdSum = 0;
Ad.vvwAdSum = 0;
Ad.nAdSum = 0;
//=======================================================================
EALLOW;
//PieVectTable.TINT0 = &CpuTimer0Isr; //1ms中断
PieVectTable.ADCINT = &AdcIsr; // ADC中断
PieVectTable.XINT1 = &Xint1Isr; //外部中断1
PieVectTable.EPWM1_INT = &EPwm1Isr;
PieVectTable.ECAP1_INT = &Ecap1Isr;
PieVectTable.EQEP1_INT = &EQep1Isr;
EDIS;
//=======================================================================
AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1 = 1; // Enable SEQ1 interrupt (every EOS)
AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1; //起动AD转换
XIntruptRegs.XINT1CR.bit.ENABLE = 1; //使能XINT1中断
EQep1Regs.QEINT.bit.UTO = 1; //enable the UTO interrupt
//=======================================================================
//0113 ConfigCpuTimer0(1);
//=======================================================================
IER |= E_INT1 + E_INT3 + E_INT4 + E_INT5;
PieCtrlRegs.PIEACK.all = PIEACK_GROUP1 + PIEACK_GROUP3 + PIEACK_GROUP4 + PIEACK_GROUP5;
//----------------------------------------------------------------------
//开放XINT10,ADCINT,TINT中断
PieCtrlRegs.PIEIER1.all = E_INT4 + E_INT6;
//开放Epwm1中断
PieCtrlRegs.PIEIER3.all = E_INT1;
//开放Ecap1中断
PieCtrlRegs.PIEIER4.all = E_INT1;
//开放EQEP1中断
PieCtrlRegs.PIEIER5.all = E_INT1;
//-----------------------------------------------------------------------
EnableDog();
EINT; // Enable Global interrupt INTM
asm(" CLRC OVC");
asm(" CLRC TC,C,SXM,OVM");
//===================================================
//通讯专用主控制字赋初值
modbusStruct.mainContrlWord.bit.onOff1 = 0;
modbusStruct.mainContrlWord.bit.off2 = 1;
modbusStruct.mainContrlWord.bit.emergencyStop = 1;
modbusStruct.mainContrlWord.bit.reserved2 = 0;
modbusStruct.mainContrlWord.bit.refDir = 0;
modbusStruct.mainContrlWord.bit.reserved3 = 0;
modbusStruct.mainContrlWord.bit.extErrIn = 0;
modbusStruct.mainContrlWord.bit.reset = 0;
modbusStruct.mainContrlWord.bit.fwdJog = 0;
modbusStruct.mainContrlWord.bit.revJog = 0;
modbusStruct.mainContrlWord.bit.extendOut1 = 0;
modbusStruct.mainContrlWord.bit.reserved6 = 0;
modbusStruct.mainContrlWord.bit.reserved7 = 0;
modbusStruct.mainContrlWord.bit.mopUp = 0;
modbusStruct.mainContrlWord.bit.mopDn = 0;
modbusStruct.mainContrlWord.bit.virtualTerm = 0;
//======================================================
for(;;)
{
MainCycle(); //主循环函数
}
}
//===========================================================================
//1ms任务
//===========================================================================
void MsTask(void)
{
long tmpL;
Uint16 tmpU;
Uint32 tmpU32;
Uint16 tmpMaxRunF;
Uint16 maxOutFTmp;
Uint16 i;
Uint16 k;
long wei900;
k++;
weik =iu;
if(k ==900)
{
k =0;
}
tmpMaxRunF = SpeedToF(P.maxRunSpd);
if(P.speedHiResolEn == 1)
{
tmpMaxRunF = tmpMaxRunF / 10;
}
maxOutFTmp = tmpMaxRunF;
//======================================================================
if(innerSpdVal0Old != P.innerSpdVal0)
{
digRefSpd = P.innerSpdVal0;
}
innerSpdVal0Old = P.innerSpdVal0; //ysh
ModBusInit(); //ysh
timer1ms++;
//======================================================================
MiscClock();
runClock();
//定时函数
//TimeSlice(&timer1ms, &timer10ms);
Timer32Inc(&powOnTimer);
Timer32Inc(&timeSinceStop);
//Timer16Inc(&freeStopTimer);
Timer32Inc(&noKeyDownTimer);
Timer32Inc(&dcBrakeStopTimer);
Timer16Inc(&twinkleTimer);
Timer16Inc(&eepSaveDispTimer);
Timer16Inc(&plcDOTime);
Timer32Inc(&sCurveTimer);
Timer32Inc(&resetItvlTimer);
Timer32Inc(&measureTimer);
Timer16Inc(&displaydelayTimer);//ld-09-06-03
//Timer16Inc(&preMagTimer);
if((P.motorDriveMode == 2) && (fRampRef == 0) && (fCur != 0) && (driveStat == StoppingE))
{//用于SLVC停机，防止不能停机的情况
Timer16Inc(&stopTimer);
}
//--------------------------------------------------------------------
UnitRampV();
if(powOnTimer > READY_TIME)
{
ECap1Regs.ECCTL1.bit.CAPLDEN = 1; // Enable CAP1-CAP4 register loads
}
MotPolesCal();
//--------------------------------------------------------------------
RandomUint16();
revWobFSynInOld = diFuncSel.bit.revWobFSynIn;
extFaultResetOld = diFuncSel.bit.extErrRst;
forceCmdToTermOld = diFuncSel.bit.forceToDI;
triThreadStopOld = diFuncSel.bit.triRunStop;
virtualFwdOld = diFuncSel.bit.driveRun;
virtualRevOld = diFuncSel.bit.runDirCtrl;
// change posErrClearOld = diFuncSel.bit.posCntClear;
ctrlSpdOrTorqOld = diFuncSel.bit.modeSwitch;
//pidDisOld = diFuncSel.bit.pidDis;
//由串口通道切换出来时，清除相关命令
if(runCmdChan < CmdSerial1E)
{
modbusStruct.mainContrlWord.bit.onOff1 = 0;
modbusStruct.mainContrlWord.bit.off2 = 1;
modbusStruct.mainContrlWord.bit.emergencyStop = 1;
modbusStruct.mainContrlWord.bit.reserved2 = 0;
modbusStruct.mainContrlWord.bit.refDir = 0;
modbusStruct.mainContrlWord.bit.reserved3 = 0;
modbusStruct.mainContrlWord.bit.extErrIn = 0;
modbusStruct.mainContrlWord.bit.reset = 0;
modbusStruct.mainContrlWord.bit.fwdJog = 0;
modbusStruct.mainContrlWord.bit.revJog = 0;
modbusStruct.mainContrlWord.bit.extendOut1 = 0;
modbusStruct.mainContrlWord.bit.reserved6 = 0;
modbusStruct.mainContrlWord.bit.reserved7 = 0;
modbusStruct.mainContrlWord.bit.mopUp = 0;
modbusStruct.mainContrlWord.bit.mopDn = 0;
modbusStruct.mainContrlWord.bit.virtualTerm = 0;
MainCtlonOff1 = 0;
MainCtlOff2 = 1;
MainCtlEmergencyStop = 1;
MainCtlRunDir = 0;
MainCtlFwdJog = 0;
MainCtlRevJog = 0;
MainCtlMopUp = 0;
MainCtlMopDown = 0;
MainCtlVirtualTerm = 0;
}
off3 = (diFuncSel.bit.emergencyStop ^ 1) && MainCtlEmergencyStop;
//======================================================================
if(powOnTimer > READY_TIME + CTRL_DELAY + P.diFilterT)
{
keyFilter();
}
//======================================================================
if(powOnTimer > READY_TIME && paraCmd == noHandleE)
{
if(MainCtlVirtualTerm == 0)
{
//虚拟端子无效
ClearDIFuncSel();
DIRead();
DIFilter();
DIFunction();
}
else if(MainCtlVirtualTerm == 1)
{
//虚拟端子有效
for(i = 5; i <= 7; i++)
{
diFuncSel.diFuncArrayi = 0;
}
DIRead();
DIFilter();
if((P.x1FuncSel >= 5) && (P.x1FuncSel <= 7))
{
diFuncSel.diFuncArrayP.x1FuncSel = diState.bit.X1 ^ ONES(P.diLogicSet1);
}
if((P.x2FuncSel >= 5) && (P.x2FuncSel <= 7))
{
diFuncSel.diFuncArrayP.x2FuncSel = diState.bit.X2 ^ TENS(P.diLogicSet1);
}
if((P.x3FuncSel >= 5) && (P.x3FuncSel <= 7))
{
diFuncSel.diFuncArrayP.x3FuncSel = diState.bit.X3 ^ HUNS(P.diLogicSet1);
}
if((P.x4FuncSel >= 5) && (P.x4FuncSel <= 7))
{
diFuncSel.diFuncArrayP.x4FuncSel = diState.bit.X4 ^ KILOS(P.diLogicSet1);
}
if((P.x5FuncSel >= 5) && (P.x5FuncSel <= 7))
{
diFuncSel.diFuncArrayP.x5FuncSel = diState.bit.X5 ^ TENKILOS(P.diLogicSet1);
}
if((P.x6FuncSel >= 5) && (P.x6FuncSel <= 7))
{
diFuncSel.diFuncArrayP.x6FuncSel = diState.bit.X6 ^ ONES(P.diLogicSet2);
}
if((P.x7FuncSel >= 5) && (P.x7FuncSel <= 7))
{
diFuncSel.diFuncArrayP.x7FuncSel = diState.bit.X7 ^ TENS(P.diLogicSet2);
}
if((P.x8FuncSel >= 5) && (P.x8FuncSel <= 7))
{
diFuncSel.diFuncArrayP.x8FuncSel = diState.bit.X8 ^ HUNS(P.diLogicSet2);
}
}
}
Modbus();
//======================================================================
if(isRunning == 1)
{
if(P.motorDriveMode <= 1)
{
Timer32Inc(&startingTimer);
}
else
{
if(P.startMode == 0)
{
if(startFHoldFlag == 1)
{
Timer32Inc(&startingTimer);
}
}
else
{
Timer32Inc(&startingTimer);
}
}
}
else
{
ReadyRunProcess();
}
//---------------------------------------------------------------------
//复位已复位次数
if(resetItvlTimer > RESET_ITVL_TIME)
{
resetTimes = 0;
}
//---------------------------------------------------------------------
if(diFuncSel.bit.extErrIn == 1)
{
AE_UPDATE(EEEFE);
// ErrorHead = errE;
}
//参数写EEP完成
if(paraCmd == noHandleE && AWordToSave == 0)
{
ramSaveToEep();
}
if(AWordToSave == 1)
{
(*pWriteToEepwriteToEepProcess)(writeAWordAddress, (Uint16)writeAWordValue);
if(writeToEepProcess == WriteToEepIdleE)
{
MenuLevel = eepSaveEndE;
if(eepSaveDispTimer > EEP_DISP_TIME)
{
if(varPointer == (&P.userPwd - pVar))
{
MenuLevel = noMenuE;
}
else if(writeAWordAddress == (Uint16)((Uint16*) &P.mopValSave - pVar))
{//进行MOP存储时保持当前显示不变sy081103
MenuLevel = noMenuE;
}
else
{
twinkleBit = onesE;
MenuLevel = sonMenuE;
sonMenuPointer++;
if(sonMenuPointer > menuNummainMenuPointer - 1)
{
sonMenuPointer = 0;
}
varPointer = VarPointerCalu();
}
AWordToSave = 0;
}
}
}
else
{
writeToEepProcess = WriteToEepIdleE;
eepSaveDispTimer = 0;
}
//======================================================================
if(PanelSpiState == EEPIdleE)
{
PanelDriver();
}
//======================================================================
//参数上传或者下载完成时候的处理
if(paraCmdActOld > paraCmdAct && paraCmdOld < faultLoghandleE && paraCmd == noHandleE)
// && ErrorCode == noErrorE
{
MenuLevel = sonMenuE;
twinkleBit = onesE;
sonMenuPointer++;
}
else if(paraCmdActOld > paraCmdAct && paraCmdOld >= faultLoghandleE && paraCmd == noHandleE)
// && ErrorCode == noErrorE
{
MenuLevel = noMenuE;
}
//======================================================================
paraCmdActOld = paraCmdAct;
//======================================================================
FanControl();
//======================================================================
//充电继电器
if(powOnTimer > SHORT_DLY_MS)
{
ShortControl();
}
//======================================================================
if(((KeyUse.all == ONLY_STOP_RESET) && (KeyUseOld.all == NO_KEY_DOWN)) || (diFuncSel.bit.extErrRst > extFaultResetOld))
{
reset = 1;
}
else
{
reset = 0;
}
if((reset == 1) && (ErrorCode != noErrorE))
//ysh
{
modbusStruct.mainContrlWord.bit.onOff1 = 0;
modbusStruct.mainContrlWord.bit.off2 = 1;
modbusStruct.mainContrlWord.bit.emergencyStop = 1;
modbusStruct.mainContrlWord.bit.extErrIn = 0;
modbusStruct.mainContrlWord.bit.reset = 0;
MainCtlonOff1 = 0;
MainCtlOff2 = 1;
MainCtlEmergencyStop = 1;
}
PanelResponse();
//======================================================================
FastModify();
Display();
//======================================================================
//保存参数到主控板EEP,参数拷贝,恢复出厂值时不显示单位
if(PanelSpiState == EEPBusyE)
// || BoardSpiState == EEPBusyE
{
ClearUnit();
}
Seperate();
if(powOnTimer > DISP_ALL_TIME)//sy0906
{
HandleTwinkle();
}
if(ErrorCode != noErrorE)
{
if(ErrorCode == AECFEE)
{
if(reset == 1)
{
ErrorCode = noErrorE;
ErrorHead = alarmE;
sciaTimeoutTimer = 0;
}
}
else if(ErrorCode == AEEEPE)
{
if(reset == 1)
{
ErrorCode = noErrorE;
ErrorHead = alarmE;
}
}
if(ErrorCode == AEPnLE && alamFreeStop == 0)
{
if(panelResumeTimer > PANEL_RESUME_TIME)
{
ErrorCode = noErrorE;
ErrorHead = alarmE;
}
}
else if(ErrorCode == AEPLoE && alamFreeStop == 0)
{
if(timerOutPL >= (T_CHECK_OUT_PL - 100))
{
ErrorCode = noErrorE;
ErrorHead = alarmE;
}
}
else if(ErrorCode == AEPGoE && alamFreeStop == 0)
{
if(reset == 1)
{
ErrorCode = noErrorE;
ErrorHead = alarmE;
}
}
else if(ErrorHead == alarmE && alamFreeStop == 0)
{
ErrorCode = noErrorE;
ErrorHead = alarmE;
}
}
if(powOnTimer > READY_TIME)
{
Timer(&P.timer1InSel); //定时器1
Timer(&P.timer2InSel); //定时器2
//--------------------------------------------------------------------
LogicUint(&P.logicU1In1Sel); //逻辑单元1
LogicUint(&P.logicU2In1Sel); //逻辑单元2
LogicUint(&P.logicU3In1Sel); //逻辑单元3
LogicUint(&P.logicU4In1Sel); //逻辑单元4
//--------------------------------------------------------------------
Compare(); //比较器
//--------------------------------------------------------------------
Counter(); //计数器
//--------------------------------------------------------------------
CalUint(&P.calU1In1); //算术单元1
CalUint(&P.calU2In1); //算术单元2
}
//======================================================================
//载频计算及载频自动调整
CarryFToTBPRDCal();
//======================================================================
//散热器温度处理
LpfInMs(&P.heatSink1Temp, &heatSink1Temp32, td1Raw, T_DISP_FLT);
//======================================================================
//Vdc滤波for AVR
LpfInMs(&vdcAvrFlt,&vdcAvrFlt32, vdc, T_VDC_FLT);
////sy20081102 if(P.spdValSetMode != 2)
////sy20081102 {
////sy20081102 tmpMop32 = (long)P.mopValSave *1000 * 10;
////sy20081102 }
////sy20081102 else if(P.spdValSetMode == 2)
//ysh
////sy20081102 {
MopModify();
////sy20081102 }
//保存频率给定通道值
refFChanOld = refFChan;
RunCmdChanSel(); //运行命令通道
RefFChanSel(); //速度给定通道选择.
if((isRunning == 1) && (P.ctrlMode == 1) && (diFuncSel.bit.pidDis == 0)
&& ((P.motorDriveMode >= 2 && preMagTimer > preMagTime) || (P.motorDriveMode < 2))) //ysh0908
{//PIDimprove
PidCtrl();
if((P.pidFbOverLimCtl == 1) || ((P.pidFbOverLimCtl == 0) && (PidStartT >= (Uint32)P.pidStartDelayT)))
{
if(((pidFb / 10) >= P.pidFbUpLim) || ((pidFb / 10) <= P.pidFbLoLim))
{
Timer32Inc(&pidFbOverLimT);
}
else
{
pidFbOverLimT = 0;
}
}
else
{
pidFbOverLimT = 0;
}
Timer32Inc(&PidStartT);
}
else
{
pidErr = 0;
runTimer = 1;
fbErrCnt = 0;
P.pidFb = 0;
P.pidRef = 0;
P.pidErr = 0;
P.pidOut = 0;
pidOut = 0; //PIDimprove
pidFbOverLimT = 0; //PIDimprove
PidStartT = 0; //PIDimprove
}
if(innerSpdVal0Old != P.innerSpdVal0)
{
digRefSpd = P.innerSpdVal0;
}
RunMode();
//======================================================================
// if(disSCurve == 1 || isRunning == 0)//(disSCurve == 1 || isRunning == 0)
// {
AccDecTSel(); //加减速时间的选择
// }
Disp.bit.RUN = 0;
Disp.bit.REV = 0;
//---------------------------------------------------------------------
//操作盘的LED刷新
StatusLedHandle();
//--------------------------------------------------------------------
AIFunction(&P.ai1TypeSel);
AIFunction(&P.ai2TypeSel);
pfiSel();
//控制信号生成
MainStatusWordRefresh(); //ysh
ExpStatusWordRefresh(); //ysh
ProcessStatMs();
//======================================================================
//脉冲封锁的刷新
isRunningOld = isRunning;
isRunning = (driveStat == ReadyRunE || driveStat == FaultE) ? 0 : 1;
enPulseOld = enPulse;
enPulse = isRunning &enPulseStarting &enPulseDcBrake &enPulseLowFRef; //// &enPulseRevDeatT
//---------------------------------------------------------------------
if(enPulseOld < enPulse)
{
DISBLOCK();
}
else if(enPulse == 0)
{
BLOCK();
}
StallAvoid();
WobbleFunc();
//---------------------------------------------------------------------
//故障检出函数
TimeScheduling();
InputPhaseLoss();
OutputPhaseLoss();
HandlePwrLost();
FaultPolling();
motOverLoad();
PreOverLoadChkOut();
UnderLoadChkOut();
MotorTempCheck();
pgMotor();
ErrorCodeHandle();
//---------------------------------------------------------------------
//制动单元控制
BrakeUnit();
//---------------------------------------------------------------------
//给定频率的计算（反转有效）
fRefPosNegOld = fRefPosNeg; //用于跳频
fRefPosNeg = sumRefF << Q15;
if(P.speedHiResolEn == 1)
{
fRefPosNeg = fRefPosNeg / 10;
}
AllCritFreqJump();
//ysh0904
//fSharpRef = (1L - enSteadyStall) *fDigRefAfterStopMux;
fSharpRef = fDigRefAfterStopMux;
//-----------------------------------------------------------------
wcSyncCur = P.synFFltSet << WC_SYNC_CUR_Q;
//-----------------------------------------------------------------
//当前频率选择和显示滤波
fCurLpfMsOld = fCurLpfMs; //用于故障记录
fCurLpfMs = fCurLpf;
fStatorMsOld = fStatorMs; //用于故障记录
fStatorMs = fStator;
outVMsOld = outVMs; //用于故障记录
outVAmp = AmpCal(vsAl, vsBe);
outVMs = PhaseToLine(PeakToRms(puToReal((short)((long)outVAmp *vdc / vdcAvr), V_Q, vBase, V_BASE_Q, 10)));
//---------------------------------------------------------------------
//速度显示 , ysh
tmpL = WToF(wrFbk);
LpfLInMs(&fFbkLpf, tmpL, T_F_FBK_DISP_FLT);
if(measureStep > RsMeasureLowCurE && measureStep < IdleLoadE)
{
fCur = 0;
fCurLpf = 0;
}
else if(measureStep >= IdleLoadE)
{
fCur = fRun;
fCurLpf = fRun;
}
else
{
if(P.motorDriveMode >= 1)
{
if(P.motorDriveMode == 2)
{//无感矢量,预励磁时应把速度显示为零,零速运行时也显示为零 ysh090223
if(preMagTimer <= preMagTime)
{
fCur = 0;
fCurLpf = 0;
}
else if((driveStat==StartingE || driveStat==RunningE) && (wAsrRef == 0)
&& (preMagTimer > preMagTime) && (isTorqCtrl == 0))
{
fCur = 0;
fCurLpf = 0;
}
else
{
fCur = tmpL;
fCurLpf = fFbkLpf;
}
}
else
{
fCur = tmpL;
fCurLpf = fFbkLpf;
}
}
else
{
fCur = fRun;
fCurLpf = fRun;
}
}
//--------------------------------------------------------------------
tmpU = P.accDecMode;
statusRampOld = statusRamp;
if(tmpU == 0 || (tmpU == 1 && disSCurve == 1))
{
fRampRefOld = fRampRef;
Ramp((short*)(&statusRamp), &fRampRef, fSharpRef, (long)maxOutFTmp *(1L << Q15), tAcc, tDec, controlRamp);
}
else if(tmpU == 1 && disSCurve == 0)
{
SCurve((short*)(&statusRamp), controlRamp);
}
else
//加减速方式为自动加速,直线减速时的情况
{
}
//--------------------------------------------------------------------
//转矩显示滤波
{
outTorqLpfOld = outTorqLpf;
}
//========================================================================
//用于ASR
wAsrRefOld = wAsrRef;
//tmpL = fRampRef - Droop(torqRef);
if((P.ctrlMode == 1) && (P.pidCtrlSet == 3) && (driveStat != StoppingE) && (PidStartT >= (Uint32)P.pidStartDelayT))
{//PID对加减速斜坡后的速度修正 ysh0908
tmpL = SAT(fRampRef + ((long)fPidTrim << Q15)); //加直接修正
}
else
{
tmpL = fRampRef;
}
tmpL = FToW(SAT32(tmpL, (long)maxOutFTmp << F100_Q));
if(P.runDirLock == 1)
{
tmpL = DN_LIM_ZERO32(tmpL);
}
else if(P.runDirLock == 2)
{
tmpL = UP_LIM_ZERO32(tmpL);
}
wRampRef = tmpL;
//-----------------------------------------------------------------
//转矩控制相关
RefTorqSel(); //ysh 08-10-21
//ST切换延迟
if (ctrlSpdOrTorqDelay == diFuncSel.bit.modeSwitch)
{//ysh 08-09-16
spdTorqSwitchTimer = 0;
}
else
{
Timer16Inc(&spdTorqSwitchTimer);
}
if ((spdTorqSwitchTimer) >= P.S_TSwitchDelayT)
{
ctrlSpdOrTorqDelay = diFuncSel.bit.modeSwitch;
}
//-----------------------------------------------------------
//--------------------------------------------------------------
if(P.motorDriveMode >= 1 && P.motorDriveMode <= 3 && measureStep == RsMeasureInitE) //ysh0214
{//"有PG速度控制"或"无PG但为矢量控制"
if(P.motorDriveMode != 2)
{//带PG,用实测速度
wrFbk = WrfdFlt*(motPoles>>1);
}
else
{//无PG矢量控制,反馈速度为计算的转子转速
wrFbk = wrCalFlt;
}
//速度调节器
if((driveStat==StartingE || driveStat==RunningE || driveStat==StoppingE || driveStat==EmStoppingE) && (preMagTimer>=preMagTime))
{
TorqLimCalc();
LineAsrParaCalcu();
wAsrRef = wRampRef;
//------------------------------------------------------------------
if(P.motorDriveMode >= 2) //yshDebug
{//矢量控制
////////////////////////////////////////////////////////////////////////////////
//SensorlessWake(); //ysh0908
TorqCtrl();
if (needTorqCtrl == 0)
{//命令为非转矩控制
wAsrRef = wRampRef;
}
else
{//命令为转矩控制
if (fHiLim == 1)
{//转矩控制发生超限，ASR给定为速度极限
//--------------------------------------
//ysh design 增加一个专用速度斜坡函数 08-10-16
if(needTorqCtrlOld < needTorqCtrl || isTorqCtrlOld > isTorqCtrl)
{
fRampRefSpdLim = fCur;
}
RampSpdLim(&fRampRefSpdLim, (tmpFwdSpdLim << F100_Q), (long)maxOutFTmp *(1L << Q15), tAcc, tDec);
wAsrRef = FToW(fRampRefSpdLim);
//---------------------------------------
}
else if (fLoLim == 1)
{//转矩控制发生超限，ASR给定为速度极限
//------------------------------------------
//ysh design 增加一个专用速度斜坡函数 08-10-16
if(needTorqCtrlOld < needTorqCtrl || isTorqCtrlOld > isTorqCtrl)
{
fRampRefSpdLim = fCur;
}
RampSpdLim(&fRampRefSpdLim, (tmpRevSpdLim << F100_Q), (long)maxOutFTmp *(1L << Q15), tAcc, tDec);
wAsrRef = FToW(fRampRefSpdLim);
//-------------------------------------------
}
fRampShadow = WToF(wrFbk); //ysh 08-12-25
}
if (isTorqCtrlOld > isTorqCtrl)
{//切换转矩控制到速度控制
asrInteg = torqRefRampL;
wErrLpfInner = 0;
fRampShadow = WToF(wrFbk);
}
else if (isTorqCtrlOld < isTorqCtrl)
{//切换速度控制到转矩控制
torqRefRampL = (long)torqRef << 16;
}
TorqRamp(&torqRefRampL, (TorqSharpRef << 16), tAccTorq, tDecTorq); //ysh 08-10-21
TorqBiasCtrl();
////////////////////////////////////////////////////////////////////////////////
if (isTorqCtrl == 0)
{//速度控制
Asr(asrKp, asrTi, wAsrRef, wAsrRefOld, wrFbk, (Uint32)torqLim);
tmpL = (long)asrOut+(long)torqBias*10; //torqBias为零, 暂时保留
tmpL = __sat32(tmpL,LONG_MAX-torqLim*10);
if(labs(tmpL)>=torqLim*10)
{
doFuncSel.bit.torqLimiting = 1;
}
else
{
doFuncSel.bit.torqLimiting = 0;
}
}
else if (isTorqCtrl == 1)
{//转矩控制
asrOut = 0;
tmpL = (long)(HIGH16(torqRefRampL));
tmpL = __sat32(tmpL, LONG_MAX - torqLim * 10);
if (labs(tmpL) >= torqLim *10)
{
torqRefRampL = __sat32(torqRefRampL, LONG_MAX - ((long)torqLim *(10L << 16)));
doFuncSel.bit.torqLimiting = 1;
}
else
{
doFuncSel.bit.torqLimiting = 0;
}
}
torqRef = (long)tmpL*torqNPu/(100*100);
}
else if(P.motorDriveMode == 1) //yshDebug
{//有PG的VF控制
tmpU32 = ((Uint32)P.asrOutFLim *maxOutFTmp)/(Uint32)(WToF(wSlipN)>>F100_Q); //(×1000)
Asr(asrKp, asrTi, wAsrRef, wAsrRefOld, wrFbk, tmpU32);
torqRef = __sat32((long)asrOut*torqNPu/(100*100),LONG_MAX-SHRT_MAX);
doFuncSel.bit.torqLimiting = 0;
}
}
else
{
asrOut = 0;
asrInteg = 0;
wErr = 0;
wErrLpfInner = 0;
fRampShadow = WToF(wrFbk);//转矩偏置运行向速度控制切换的处理 ysh
}
}
else
{
asrOut = 0;
wAsrRef = 0;
torqRef = 0;
wErr = 0;
wErrLpfInner = 0;
doFuncSel.bit.torqLimiting = 0;
}
//-----------------------------------------------------------------
Timer16Inc(&preMagTimer);
//-----------------------------------------------------------------
//计算转矩电流
if(P.motorDriveMode >= 2)
{
wcSyncCur = P.vcSynFFltSet<<WC_SYNC_CUR_Q;
//功率限制
PowerLimit();
//预励磁
if(preMagTimer<(long)preMagTime ||(P.startMode == 2 && driveStat==StartingE)) //09-07-22
{
isqRef=0;
asrInteg=0;
fRampShadow=WToF(wrFbk); //ysh
}
else
{
//转矩电流计算及限幅
tmpL = IsqRefCal(torqRef, fluxrOpn);
if(driveStat != DcBrakeStopE)
{//ysh 08-09-22
isqRef = __sat32(tmpL, LONG_MAX -((1L<<I_Q)/100)*P.driveMaxCurLim);
}
}
//弱磁
FluxWeak();
}
else
{
wcSyncCur = P.synFFltSet<<WC_SYNC_CUR_Q;
}
//=======================================================================
//转矩显示及滤波
outTorqCent = torq * 100L * 10L / torqNPu;
if(P.motorDriveMode >= 1)
{// ysh: for 14_14 display
LpfInMs(&asrOutLpf,&asrOutLpf32, asrOut,T_DISP_FLT);
}
if(P.motorDriveMode >= 2)
{//ysh: for 14_02, 14_12, 14_13 display
torq=TorqCal(1,isq,fluxr);
LpfInMs(&outTorqLpf,&outTorqLpf32, outTorqCent,T_DISP_FLT);
LpfInMs(&isqLpf,&isqLpf32, isq,T_DISP_FLT);
LpfInMs(&isdLpf,&isdLpf32, isd,T_DISP_FLT);
}
else
{
torq = torqEm;
outTorqLpf = torqEmLpf*100L*10L/torqNPu;
outTorqLpf32 = 0;
}
//--------------------------------------------------------------------
//电流显示换算和滤波
curRmsOld = (Uint16)curRms;
curRms = puToReal(PeakToRms(curAmp), I_Q, iBase, I_BASE_Q, 10);
LpfInMs(&curRmsFlt, &curRmsFlt32, curRms, T_CUR_DISP_FLT);
//--------------------------------------------------------------------
//母线电压显示滤波
vdcMsOld = vdcMs;
vdcMs = vdc;
LpfInMs(&vdcFlt, &vdcFlt32, vdc, T_VDC_DISP_FLT);
//--------------------------------------------------------------------
//输出电压/输出功率/给定转矩的显示滤波
torqRefCent = (long)torqRef *100L * 10L / torqNPu;
LpfInMs(&outVLpf, &outVLpf32, (short)outVMs, T_DISP_FLT);
// LpfInMs(&outPwLpf, &outPwLpf32, (short)((PDispCal(outVLpf, curRmsFlt))/(2L * (long)P.motorRatedP)), T_DISP_FLT);
// LpfInMs(&outPwLpf, &outPwLpf32, (short)(((long)p *powBase >> (P_Q - P_BASE_NEGQ)) / (100 / 10)), 1000);
LpfInMs(&outPwLpf, &outPwLpf32, (short)((PDispCal(outVLpf, curRmsFlt))/(2L * (long)P.motorRatedP)), T_DISP_FLT);
// LpfInMs(&outPwLpf, &outPwLpf32, DN_LIMIT((short)(((long)p *powBase >> (P_Q - P_BASE_NEGQ)) / (100 / 10)), 0), 1000);
LpfInMs(&torqRefLpf, &torqRefLpf32, torqRefCent, T_DISP_FLT);
//--------------------------------------------------------------------
//PG检测转速的显示滤波
PgDetSpeed = 60L *((WToF(labs(WrfdFlt)) + (1L << (F100_Q - 1))) >> F100_Q);
if(P.pgUseMode == 0 || P.pgUseMode == 1)
{
PgDetSpeed = PgDetSpeed * SIGN_PN32(WrfdFlt);
}
LpfLInMs(&PgDetSpeedFlt, PgDetSpeed, T_F_FBK_DISP_FLT);
//----------------------------------------------------------------------
//减速AVR操作
if(statusRamp == RampDecE)
{
GeneralRamp(&avrRampInteg, SHRT_MAX, (Uint32)(P.outVRecoT *(100 / 6)));
}
else
{
GeneralRamp(&avrRampInteg, 0, (Uint32)(P.outVRecoT *(100)));
}
//------------------------------------------------------------------------
//curAmp = AmpCal(isAl, isBe); //ysh0904
pOld = p;
p = PCal(vsAl, vsBe, isAl, isBe);
q = QCal(vsAl, vsBe, isAl, isBe);
//--------------------------------------------------------------------
UpdateParaValue();
AdSignProcess();
AOFunction(P.ao1FuncSel, &P.ao1TypeSel);
AOFunction(P.ao2FuncSel, &P.ao2TypeSel);
AOFuncUpdate();
pfo();
//======================================================================
if(powOnTimer > READY_TIME)
{
PartDoTerm();
DOFunction();
}
//=================================================
// for eQEP
tmpPgUseModeOld = tmpPgUseMode;
tmpPgUseMode = P.pgUseMode;
if(tmpPgUseModeOld != tmpPgUseMode)
{
if(P.pgUseMode == 0 || P.pgUseMode == 1)
{
EQep1Regs.QDECCTL.bit.QSRC = 0; //Quadrature-count mode
}
else if(P.pgUseMode == 2)
{
EQep1Regs.QDECCTL.bit.QSRC = 2; //direct count mode:up count mode
}
}
//------------------------------------------------------
}
//===========================================================================
//===========================================================================
//EQep1中断(ms)
//===========================================================================
interrupt void EQep1Isr(void)
{
DirMeas = EQep1Regs.QEPSTS.bit.QDF;
//------------------------------------------------------------
IER |= E_INT1 + E_INT3 + E_INT4;
EINT;
//------------------------------------------------------------
KickDog();
if(pgLostTimer > P.pgMisDetT*100)
{//断线检测
Wrfd = 0;
WrfdTmp = 0;
WrfdFlt = 0;
PGLostAct();
}
else
{
if(P.pgUseMode == 0 || P.pgUseMode == 1)
{//正交编码器
if(EQep1Regs.QFLG.bit.QDC | EQep1Regs.QFLG.bit.PHE | EQep1Regs.QFLG.bit.PCO | EQep1Regs.QFLG.bit.PCU)
{
EQep1Regs.QCLR.bit.QDC = 1;
EQep1Regs.QCLR.bit.PHE = 1;
EQep1Regs.QCLR.bit.PCO = 1;
EQep1Regs.QCLR.bit.PCU = 1;
EQep1Regs.QCLR.bit.UTO = 1;
EQep1Regs.QCLR.bit.INT = 1;
}
else
{
eQepTmpL = (DirMeas == 1) ? (long)EQep1Regs.QPOSLAT : (long)(EQep1Regs.QPOSMAX - EQep1Regs.QPOSLAT);
Wrfd = eQepTmpL*1000L*(1L<<Wr_Q-13-2+1)/(long)P.numOfPGPulse*(long)(PI*(1L<<13));
if(Wrfd != 0)
{
pgLostTimer = 0;
}
if(P.pgUseMode == 1)
{
DirMeas = DirMeas^1;
}
if(DirMeas == 0)
{
WrfdTmp = -Wrfd;
}
if(DirMeas == 1)
{
WrfdTmp = Wrfd;
}
}
}
else if(P.pgUseMode == 2)
{//单通道编码器
if(EQep1Regs.QFLG.bit.PCO | EQep1Regs.QFLG.bit.PCU)
{
EQep1Regs.QCLR.bit.PCO = 1;
EQep1Regs.QCLR.bit.PCU = 1;
EQep1Regs.QCLR.bit.UTO = 1;
EQep1Regs.QCLR.bit.INT = 1;
}
else
{
eQepTmpL = (long)EQep1Regs.QPOSLAT;
Wrfd = (long)eQepTmpL*1000L*(1L<<Wr_Q-13-2+2)/(long)P.numOfPGPulse*(long)(PI*(1L<<13));
if(Wrfd != 0)
{
pgLostTimer = 0;
}
WrfdTmp = Wrfd;
}
}
}
MsTask();
EQep1Regs.QCLR.bit.UTO = 1; //clear the UTO interrupt flag
EQep1Regs.QCLR.bit.INT = 1; //clear the global interrupt flag and enables further interrupts
PieCtrlRegs.PIEACK.all = PIEACK_GROUP5;
}
//==========================================================================
//==========================================================================
//主循环函数
//==========================================================================
void MainCycle(void)
{
extern Uint16 tdAd;
Uint16 tmpU = 0;
//温度检测
KickDog(); //now
if(powOnTimer > READY_TIME + CTRL_DELAY)
{
PwrOffToSave();
}
td1Raw = TempFromSensitive(tdAd, P.TD1Zf, P.TD1Scale); //AdcRegs.ADCRESULT4
if(powOnTimer > READY_TIME)
{
if(P.heatSink1Temp >= P.heatSink1ProtTemp)
{
AE_UPDATE(EoHIE); //过热故障
// ErrorHead = errE;
}
}
if((paraCmd != noHandleE || paraCopySerialCmd != noHandleE) && isRunning == 0 && BoardSpiState == EEPIdleE)
{
if(paraCmd == clean2InfoE)
{
BoardSpiState = EEPBusyE;
Clean2Info();
tmpU = (Uint16)((Uint16*) &P.mopValSave - pVar); //torqWrapStartT
paraCmdAct = paraCmdActtingE;
WriteWords(tmpU, (Uint16*) &P.mopValSave, 5); //torqWrapStartT
}
else if(paraCmd == clean12InfoE)
{
BoardSpiState = EEPBusyE;
Clean12Info();
tmpU = &P.lastErrType - pVar;
MenuLevel = recoveryingE;
paraCmdAct = paraCmdActtingE;
WriteWords(tmpU, &P.lastErrType, 10);
}
else if(paraCmd == resumeFacValueE)
{
BoardSpiState = EEPBusyE;
MenuLevel = recoveryingE;
paraCmdAct = paraCmdActtingE;
ResumeFacValue(P.driveType);
}
else if((paraCmd == paraUpLoadE || paraCopySerialCmd == paraUpLoadE) && PanelState == TransmitE)
{
BoardSpiState = EEPBusyE;
MenuLevel = upLoadingE;
paraCmdAct = paraCmdActtingE;
ParaUpLoading();
paraCopySerialCmd = noHandleE;
}
else if((paraCmd == partParaDownLoadE || paraCopySerialCmd == partParaDownLoadE) && PanelState == TransmitE)
{
BoardSpiState = EEPBusyE;
MenuLevel = downLoadingE;
paraCmdAct = paraCmdActtingE;
ParaDownLoading();
paraCopySerialCmd = noHandleE;
}
else if((paraCmd == paraDownLoadE || paraCopySerialCmd == paraDownLoadE) && PanelState == TransmitE)
{
BoardSpiState = EEPBusyE;
MenuLevel = downLoadingE;
paraCmdAct = paraCmdActtingE;
ParaDownLoading();
paraCopySerialCmd = noHandleE;
}
else if(paraCmd == driveModelSetE)
{
BoardSpiState = EEPBusyE;
MenuLevel = recoveryingE;
paraCmdAct = paraCmdActtingE;
ResumeFacValue(P.driveModel);
}
else if(paraCmd == motTypeParaSetE)
{
BoardSpiState = EEPBusyE;
paraCmdAct = paraCmdActtingE;
WriteWords(motTypeParaNum, &P.motorRatedP, 13);
}
else if(paraCmd == facOperate1E)
{
BoardSpiState = EEPBusyE;
MenuLevel = recoveryingE;
paraCmdAct = paraCmdActtingE;
WriteWords(0, pFacValue, paraNum);
}
else if(paraCmd == faultLoghandleE)
{
BoardSpiState = EEPBusyE;
paraCmdAct = paraCmdActtingE;
WriteWords((&P.lastErrType - pVar), &P.lastErrType, 10);
}
if(ErrorCode == AEEEPE || ErrorCode == EcoPE)
{
BoardSpiState = EEPBusyE;
errToDisplay = displayE;
}
paraCmdOld = paraCmd;
paraCmd = noHandleE;
paraCmdAct = noParaCmdActE;
BoardSpiState = EEPIdleE;
}
//--------------------------------------------------------------------
zfAl = ((long)P.alDcComp *realCarrierF + FS_DC_CALI / 2) / FS_DC_CALI;
zfBe = ((long)P.beDcComp *realCarrierF + FS_DC_CALI / 2) / FS_DC_CALI;
//---------------------------------------------------------------------
//设定死区时间
if(P.deadT >= 30)
{
EPwm1Regs.DBRED = P.deadT * 5;
EPwm2Regs.DBRED = P.deadT * 5;
EPwm3Regs.DBRED = P.deadT * 5;
EPwm1Regs.DBFED = P.deadT * 5;
EPwm2Regs.DBFED = P.deadT * 5;
EPwm3Regs.DBFED = P.deadT * 5;
}
else
{
EPwm1Regs.DBRED = 150;
EPwm2Regs.DBRED = 150;
EPwm3Regs.DBRED = 150;
EPwm1Regs.DBFED = 150;
EPwm2Regs.DBFED = 150;
EPwm3Regs.DBFED = 150;
}
//--------------------------------------------------------------------
BaseValueCalc(); //基值计算
FullScaleCalc(); //满幅值计算
CoeffOnlineCal(); //一些系数的计算
ParaToUsedCalc();
//=================================================
//设置硬件过流保护点
OCRefGenerate(P.hwOCProtectP);
//=================================================
}