angle.c

一个串口终端解释程序。用于单片机调试串口的超级终端应用。

    if (U.ErrFlag == 0)
    {
        UinErrFlag = 0;
    }

    if (E.ErrFlag == 0)
    {
        EinErrFlag = 0;

        asm (BFSET #0x0300, SR);        //禁用所有可屏蔽中断
        TempEOnePolePeriod =  TempEPeriod / PolePairsNum;
        asm (BFCLR #0x0200, SR);        //开启可屏蔽中断

        TempUI = TempEPeriod - TempEOnePolePeriod * PolePairsNum;
        if (TempUI > PolePairsNum/2)
        {
            TempEOnePolePeriod += 1;
        }

        if (E.OldRisingEdgeBufPtr != TempERisingEdgeWritePtr)    //有新的E数据
        {
            /*****计算内电势绝对角*****/
            RisingEdgeDiffL = TempMainFreqPeriodCounter - TempERisingEdgeCounter;
            if (RisingEdgeDiffL < 0)
            {
                RisingEdgeDiffUL = TempEOnePolePeriod + RisingEdgeDiffL;
            }
            else
            {
                RisingEdgeDiffUL = RisingEdgeDiffL;
            }
            RisingEdgeDiffUL *= 3600;

            asm (BFSET #0x0300, SR);        //禁用所有可屏蔽中断
            UnCompensatedEAbsoluteAngle = RisingEdgeDiffUL / TempEOnePolePeriod;
            asm (BFCLR #0x0200, SR);        //开启可屏蔽中断

            TempUL1 = RisingEdgeDiffUL - UnCompensatedEAbsoluteAngle * TempEOnePolePeriod;
            if (TempUL1 >= TempEOnePolePeriod/2)
            {
                UnCompensatedEAbsoluteAngle += 1;
            }
            CompensatedEAbsoluteAngle = UnCompensatedEAbsoluteAngle + E.CompensateValue;
            for (TempUI=0; TempUI<2; TempUI++)  //将角度值调整到±180度范围内
            {
                if (CompensatedEAbsoluteAngle > 1800)
                {
                    CompensatedEAbsoluteAngle -= 3600;
                }
                else if (CompensatedEAbsoluteAngle < -1800)
                {
                    CompensatedEAbsoluteAngle += 3600;
                }
            }
            EAngleNoEffectFlag = 0;
            
            *EAbsoluteAngleBufPtr = CompensatedEAbsoluteAngle;  //for test
            /*****end of 计算内电势绝对角****/

            /*****计算发电机转速****/
            TempUL1 = OutputPpsPeriod * 60;
            
            asm (BFSET #0x0300, SR);        //禁用所有可屏蔽中断
            RotateSpeed = TempUL1 / TempEPeriod;
            asm (BFCLR #0x0200, SR);        //开启可屏蔽中断

			TempUL2 = TempUL1 - RotateSpeed * TempEPeriod;
			
#ifdef ZOOM_ROTATE_SPEED			
			RotateSpeed *= 10;
            TempUL2 *= 10;
            asm (BFSET #0x0300, SR);        //禁用所有可屏蔽中断
            TempUI = TempUL2 / TempEPeriod;
            asm (BFCLR #0x0200, SR);        //开启可屏蔽中断
            
            RotateSpeed += TempUI;
            TempUL1 = TempUL2 - TempUI * TempEPeriod;
            
            if (TempUL1 > TempEPeriod/2)
            {
                RotateSpeed += 1;
            }            
#else            
            if (TempUL2 > TempEPeriod/2)
            {
                RotateSpeed += 1;
            }
#endif            
            RotateSpeedNoEffectFlag = 0;

            *RotateSpeedBufPtr = RotateSpeed;   //for test
            /*****end of 计算发电机转速****/

            /*****计算发电机功角****/
            if (U.ErrFlag == 0)
            {
                if (U.OldRisingEdgeBufPtr != TempURisingEdgeWritePtr)    //有新的U数据
                {
                    RisingEdgeDiffL = TempURisingEdgeCounter - TempERisingEdgeCounter;
                    if (RisingEdgeDiffL < 0)
                    {
                        RisingEdgeDiffUL = TempEOnePolePeriod + RisingEdgeDiffL;
                    }
                    else
                    {
                        RisingEdgeDiffUL = RisingEdgeDiffL;
                    }
                    RisingEdgeDiffUL *= 3600;

                    asm (BFSET #0x0300, SR);        //禁用所有可屏蔽中断
                    UnCompensatedPowerAngle = RisingEdgeDiffUL / TempEOnePolePeriod;
                    asm (BFCLR #0x0200, SR);        //开启可屏蔽中断

                    TempUL1 = RisingEdgeDiffUL - UnCompensatedEAbsoluteAngle * TempEOnePolePeriod;
                    if (TempUL1 >= TempEOnePolePeriod/2)
                    {
                        UnCompensatedPowerAngle += 1;
                    }

                    CompensatedPowerAngle = UnCompensatedPowerAngle + U.CompensateValue + 900 + E.CompensateValue;
                    for (TempUI=0; TempUI<3; TempUI++)  //将角度值调整到±180度范围内
                    {
                        if (CompensatedPowerAngle > 1800)
                        {
                            CompensatedPowerAngle -= 3600;
                        }
                        else if (CompensatedPowerAngle < -1800)
                        {
                            CompensatedPowerAngle += 3600;
                        }
                    }

                    //for test
                    *PowerAngleBufPtr = CompensatedPowerAngle;
                    if (FirstTimes < 10)
                    {
                        FirstTimes ++;
                    }
                    if (FirstTimes == 10)
                    {
                        AngleDiff = CompensatedPowerAngle - LastPowerAngle;
                        if ((AngleDiff < -10) || (AngleDiff > 10))
                        {
                            if ((AngleDiff > -3500) && (AngleDiff < 3500))
                            {
                                asm(nop);
                                asm(nop);
                            }
                        }
                    }
                    LastPowerAngle = CompensatedPowerAngle;
                    //end for test

                    PowerAngleNoEffectFlag = 0;

                    //计算DA输出值
                    if (CompensatedPowerAngle < 0)
                    {
                        TempUI = (unsigned int)(CompensatedPowerAngle + 3600);
                    }
                    else
                    {
                        TempUI = (unsigned int)CompensatedPowerAngle;
                    }
                    TempUL1 = TempUI * 65536;

                    asm (BFSET #0x0300, SR);        //禁用所有可屏蔽中断
                    DaValue = TempUL1 / 3600;
                    asm (BFCLR #0x0200, SR);        //开启可屏蔽中断

                    if ((TempUL1 - DaValue * 3600) > 1800)
                    {
                        DaValue += 1;
                    }

                    if (TempUI > 2700)  //270度～360度
                    {
                        DaValue -= 49152;   //([phone])
                    }
                    else                //0度～270度
                    {
                        DaValue += 16384;
                    }
                }
            }
            /*****end of 计算发电机功角****/

            //EErrorTimes = 0; for test!!!
        }
        else    //E状态正常，但是没有得到新的数据
        {
            /*for test!!
            if (++EErrorTimes == 2)
            {
                asm(nop);
                asm(nop);
            }
            //for test */
        }
    }

    E.OldRisingEdgeBufPtr = TempERisingEdgeWritePtr;
    U.OldRisingEdgeBufPtr = TempURisingEdgeWritePtr;

    //for test
    if (++EAbsoluteAngleBufPtr >= &EAbsoluteAngleBuf[TEST_BUS_SIZE])
    {
        EAbsoluteAngleBufPtr = &EAbsoluteAngleBuf[0];
    }
    if (++RotateSpeedBufPtr >= &RotateSpeedBuf[TEST_BUS_SIZE])
    {
        RotateSpeedBufPtr = &RotateSpeedBuf[0];
    }
    if (++PowerAngleBufPtr >= &PowerAngleBuf[TEST_BUS_SIZE])
    {
        PowerAngleBufPtr = &PowerAngleBuf[0];
    }
    //end for test
}
/*****end of 计算内电势绝对角和发电机功角*****/


/*****补偿值调节按钮中断子程序，GPIO B0*****/
#pragma interrupt
void AddButtonIsr(void)
{
    if (InitAngleLockCnt == 0)
    {
        if (AddAngleFilterCnt == 0)
        {
            AddAngleFilterCnt = 5;
        }
    }
    *GPIO_B_IESR = 0x0000;
}
/*****end of 补偿值调节按钮中断子程序，GPIO B0*****/


/*****补偿值调节按钮中断子程序，GPIO D0*****/
#pragma interrupt
void SubButtonIsr(void)
{
    if (InitAngleLockCnt == 0)
    {
        if (SubAngleFilterCnt == 0)
        {
            SubAngleFilterCnt = 5;
        }
    }
    *GPIO_D_IESR = 0x0000;
}
/*****end of 补偿值调节按钮中断子程序，GPIO D0*****/


/*****对补偿值按钮调节进行去抖处理*****/
#pragma interrupt
void ButtonFilter(void)
{
    if (AddAngleFilterCnt && SubAngleFilterCnt)
    {
        if ((ADD_ANGLE_BUTTON == 0) && (SUB_ANGLE_BUTTON == 0))
        {
            E.CompensateValue = 0;
            AddAngleFilterCnt = 0;
            SubAngleFilterCnt = 0;
            InitAngleLockCnt = 1;
            AngleAdjustFlag = TRUE;
        }
        else
        {
            if (AddAngleFilterCnt > 0)
            {
                AddAngleFilterCnt--;
            }
            if (SubAngleFilterCnt > 0)
            {
                SubAngleFilterCnt--;
            }

            if ((AddAngleFilterCnt == 0) || (SubAngleFilterCnt == 0))
            {
                FastAngleAdjustFlag = 0;
            }
        }
    }
    else if (AddAngleFilterCnt)
    {
        if (ADD_ANGLE_BUTTON == 0)
        {
            AddAngleFilterCnt ++;
            if ((AddAngleFilterCnt == 35) && (FastAngleAdjustFlag == 0))    //去抖30ms，如果此时正在进行快速调节，则不做0.1度补偿值的增减
            {
                AngleAdjustFlag = TRUE;
                if (E.CompensateValue <= 1799)  //补偿值在-180度～+180度之间
                {
                    E.CompensateValue += 1;         //补偿值增加0.1度
                }
            }
            else if (AddAngleFilterCnt >= 1050)  //去抖1s
            {
                AddAngleFilterCnt = 50;
                FastAngleAdjustFlag = TRUE; //进行快速调节
                AngleAdjustFlag = TRUE;
                if (E.CompensateValue <= 1780)  //补偿值在-180度～+180度之间
                {
                    E.CompensateValue += 20;    //补偿值增加2度
                }
            }
        }
        else
        {
            AddAngleFilterCnt --;
            if (AddAngleFilterCnt == 0)
            {
                FastAngleAdjustFlag = 0;
            }
        }
    }
    else if (SubAngleFilterCnt)
    {
        if (SUB_ANGLE_BUTTON == 0)
        {
            SubAngleFilterCnt ++;
            if ((SubAngleFilterCnt == 35) && (FastAngleAdjustFlag == 0))    //去抖30ms，如果此时正在进行快速调节，则不做0.1度补偿值的增减
            {
                AngleAdjustFlag = TRUE;
                if (E.CompensateValue >= -1799) //补偿值在-180度～+180度之间
                {
                    E.CompensateValue -= 1;     //补偿值减小0.1度
                }
            }
            else if (SubAngleFilterCnt >= 1050)  //去抖1s
            {
                SubAngleFilterCnt = 50;
                FastAngleAdjustFlag = TRUE; //进行快速调节
                AngleAdjustFlag = TRUE;
                if (E.CompensateValue >= -1780)     //补偿值在-180度～+180度之间
                {
                    E.CompensateValue -= 20;    //补偿值减小2度
                }
            }
        }
        else
        {
            SubAngleFilterCnt--;
            if (SubAngleFilterCnt == 0)
            {
                FastAngleAdjustFlag = 0;
            }
        }
    }
    else if (AngleAdjustFlag)
    {
        AngleAdjustFlag = 0;
        AngleAdjustFinishCnt = 1;
    }

    if (AngleAdjustFinishCnt)
    {
        if (++AngleAdjustFinishCnt >= 5000) //若连续5秒调节按钮无动作则将补偿值写入flash
        {
            AngleAdjustFinishCnt = 0;
            WriteFlashStartFlag = TRUE;
        }
    }

    if (InitAngleLockCnt)
    {
        if (++InitAngleLockCnt >= 5000) //补偿值清零后5秒内按钮调节无效
        {
            InitAngleLockCnt = 0;
        }
    }
}
/*****end of 对补偿值按钮调节进行去抖处理*****/