stm32f10x_svpwm_1shunt.c

ARM_CORTEX-M3应用实例开发详解光盘

  
    wX = wUBeta;
    wY = (wUBeta + wUAlpha)/2;
    wZ = (wUBeta - wUAlpha)/2;
     
    // Sector calculation from wX, wY, wZ
     if (wY<0)
     {
        if (wZ<0)
        {
          bSector = SECTOR_5;
        }
        else // wZ >= 0
          if (wX<=0)
          {
            bSector = SECTOR_4;
          }
          else // wX > 0
          {
            bSector = SECTOR_3;
          }
     }
     else // wY > 0
     {
       if (wZ>=0)
       {
         bSector = SECTOR_2;
       }
       else // wZ < 0
         if (wX<=0)
         {  
           bSector = SECTOR_6;
         }
         else // wX > 0
         {
           bSector = SECTOR_1;
         }
      }
     
     /* Duty cycles computation */
    switch(bSector)
    {  
      case SECTOR_1:
          dvDutyValues.hTimePhA = (T/8) + ((((T + wX) - wZ)/2)/131072);
          dvDutyValues.hTimePhB = dvDutyValues.hTimePhA + wZ/131072;
          dvDutyValues.hTimePhC = dvDutyValues.hTimePhB - wX/131072;
                  break;
      case SECTOR_2:
          dvDutyValues.hTimePhA = (T/8) + ((((T + wY) - wZ)/2)/131072);
          dvDutyValues.hTimePhB = dvDutyValues.hTimePhA + wZ/131072;
          dvDutyValues.hTimePhC = dvDutyValues.hTimePhA - wY/131072;
          break;
      case SECTOR_3:
          dvDutyValues.hTimePhA = (T/8) + ((((T - wX) + wY)/2)/131072);
          dvDutyValues.hTimePhC = dvDutyValues.hTimePhA - wY/131072;
          dvDutyValues.hTimePhB = dvDutyValues.hTimePhC + wX/131072;
          break;
      case SECTOR_4:
          dvDutyValues.hTimePhA = (T/8) + ((((T + wX) - wZ)/2)/131072);
          dvDutyValues.hTimePhB = dvDutyValues.hTimePhA + wZ/131072;
          dvDutyValues.hTimePhC = dvDutyValues.hTimePhB - wX/131072;
          break;  
      case SECTOR_5:
          dvDutyValues.hTimePhA = (T/8) + ((((T + wY) - wZ)/2)/131072);
          dvDutyValues.hTimePhB = dvDutyValues.hTimePhA + wZ/131072;
          dvDutyValues.hTimePhC = dvDutyValues.hTimePhA - wY/131072;
              break;
      case SECTOR_6:
          dvDutyValues.hTimePhA = (T/8) + ((((T - wX) + wY)/2)/131072);
          dvDutyValues.hTimePhC = dvDutyValues.hTimePhA - wY/131072;
          dvDutyValues.hTimePhB = dvDutyValues.hTimePhC + wX/131072;
          break;
      default:
          break;
    }
    
    if (bDistEnab == 1)
    {
      bStatorFluxPosOld = bStatorFluxPos;
    
/*******************************************************************************
* Function Name  : SVPWM_1GetStatorFluxPos
* Description    :  Compute the stator vector position 
                        REGULAR if stator vector lies in regular region
                        BOUNDARY_1 if stator vector lies in boundary region 1 (two small, one big)
                        BOUNDARY_2 if stator vector lies in boundary region 2 (two big, one small)
                        BOUNDARY_3 if stator vector lies in boundary region 3 (three equal)
* Input           : None
* Output         : None
* Return         : None
*******************************************************************************/
      //bStatorFluxPos = SVPWM_1GetStatorFluxPos(); 
      hDutyV[0] = dvDutyValues.hTimePhA;
      hDutyV[1] = dvDutyValues.hTimePhB;
      hDutyV[2] = dvDutyValues.hTimePhC;
      
      // Sort ascendant
      if (hDutyV[0] > hDutyV[1])
      {
        // Swap [0] [1]
        hDutyV[3] = hDutyV[0];
        hDutyV[0] = hDutyV[1];
        hDutyV[1] = hDutyV[3];
      }
      if (hDutyV[0] > hDutyV[2])
      {
        // Swap [0] [2]
        hDutyV[3] = hDutyV[0];
        hDutyV[0] = hDutyV[2];
        hDutyV[2] = hDutyV[3];
      }
      if (hDutyV[1] > hDutyV[2])
      {
        // Swap [1] [2]
        hDutyV[3] = hDutyV[1];
        hDutyV[1] = hDutyV[2];
        hDutyV[2] = hDutyV[3];
      }
      
      // Compute delta duty
      hDeltaDuty[0] = (s16)(hDutyV[1]) - (s16)(hDutyV[0]);
      hDeltaDuty[1] = (s16)(hDutyV[2]) - (s16)(hDutyV[1]);
      
      // Check region
      if ((hDeltaDuty[1]>TMIN) && (hDeltaDuty[0]<=TMIN))
        bStatorFluxPos = BOUNDARY_2;
      else if ((hDeltaDuty[1]<=TMIN) && (hDeltaDuty[0]>TMIN))
        bStatorFluxPos = BOUNDARY_1;
      else if ((hDeltaDuty[1]>TMIN) && (hDeltaDuty[0]>TMIN))
        bStatorFluxPos = REGULAR;    
      else
        bStatorFluxPos = BOUNDARY_3;
    
/*******************************************************************************
* Function Name  : SVPWM_1PWMDutyAdj
* Description    :  Compute the PWM channel that must be distorted and updates
                    the value od duty cycle registers
                                
* Input           : None
* Output         : None
* Return         : None
*******************************************************************************/    
      //SVPWM_1PWMDutyAdj();
      if (bStatorFluxPos == REGULAR)
      {
              bInverted_pwm_new = INVERT_NONE;
      }
      else if (bStatorFluxPos == BOUNDARY_1) // Adjust the lower
      {
        switch (bSector)
        {
                case SECTOR_5:
                case SECTOR_6:
                        bInverted_pwm_new = INVERT_A;
                        dvDutyValues.hTimePhA -=HTMIN;
                        break;
                case SECTOR_2:
                case SECTOR_1:
                        bInverted_pwm_new = INVERT_B;
                        dvDutyValues.hTimePhB -=HTMIN;
                        break;
                case SECTOR_4:
                case SECTOR_3:
                        bInverted_pwm_new = INVERT_C;
                        dvDutyValues.hTimePhC -=HTMIN;
                        break;
        }
      }
      else if (bStatorFluxPos == BOUNDARY_2) // Adjust the middler
      {
        switch (bSector)
        {
                case SECTOR_4:
                case SECTOR_5: // Inverto sempre B
                        bInverted_pwm_new = INVERT_B;
                        dvDutyValues.hTimePhB -=HTMIN;
                        break;
                case SECTOR_2:
                case SECTOR_3: // Inverto sempre A
                        bInverted_pwm_new = INVERT_A;
                        dvDutyValues.hTimePhA -=HTMIN;
                        break;
                case SECTOR_6:
                case SECTOR_1: // Inverto sempre C
                        bInverted_pwm_new = INVERT_C;
                        dvDutyValues.hTimePhC -=HTMIN;
                        break;
        }
      }
      else if (bStatorFluxPos == BOUNDARY_3)
      {
        if (bStBd3 == 0)
        {
          bInverted_pwm_new = INVERT_A;
          dvDutyValues.hTimePhA -=HTMIN;
          bStBd3 = 1;
        } 
        else
        {
          bInverted_pwm_new = INVERT_B;
          dvDutyValues.hTimePhB -=HTMIN;
          bStBd3 = 0;
        }
      }
      
      if (bInverted_pwm_new != INVERT_NONE)
      {
        // Check for negative values of duty register
        if (dvDutyValues.hTimePhA > 0xEFFF)
          dvDutyValues.hTimePhA = DMABURSTMIN_A;
        if (dvDutyValues.hTimePhB > 0xEFFF)
          dvDutyValues.hTimePhB = DMABURSTMIN_B;
        if (dvDutyValues.hTimePhC > 0xEFFF)
          dvDutyValues.hTimePhC = DMABURSTMIN_C;
        
        // Duty adjust to avoid commutation inside Update Handler
        if ((dvDutyValues.hTimePhA > MINTIMCNTUPHAND) && (dvDutyValues.hTimePhA < MIDTIMCNTUPHAND))
            dvDutyValues.hTimePhA = MINTIMCNTUPHAND;
        if ((dvDutyValues.hTimePhA >= MIDTIMCNTUPHAND) && (dvDutyValues.hTimePhA < MAXTIMCNTUPHAND))
            dvDutyValues.hTimePhA = MAXTIMCNTUPHAND;     
        if ((dvDutyValues.hTimePhB > MINTIMCNTUPHAND) && (dvDutyValues.hTimePhB < MIDTIMCNTUPHAND))
            dvDutyValues.hTimePhB = MINTIMCNTUPHAND;
        if ((dvDutyValues.hTimePhB >= MIDTIMCNTUPHAND) && (dvDutyValues.hTimePhB < MAXTIMCNTUPHAND))
            dvDutyValues.hTimePhB = MAXTIMCNTUPHAND;
        if ((dvDutyValues.hTimePhC > MINTIMCNTUPHAND) && (dvDutyValues.hTimePhC < MIDTIMCNTUPHAND))
            dvDutyValues.hTimePhC = MINTIMCNTUPHAND;
        if ((dvDutyValues.hTimePhC >= MIDTIMCNTUPHAND) && (dvDutyValues.hTimePhC < MAXTIMCNTUPHAND))
            dvDutyValues.hTimePhC = MAXTIMCNTUPHAND;
      }
    
    /*******************************************************************************
* Function Name  : SVPWM_1PWMSetSamplingPoints
* Description    :  Compute the sampling point and the related phase sampled 	
* Input           : None
* Output         : None
* Return         : None
*******************************************************************************/
      //SVPWM_1PWMSetSamplingPoints();
      // Reset error state & sampling before
      bError = 0;
      
      if (bStatorFluxPos == REGULAR) // Regual zone
      {
        // First point
        if ((hDutyV[1] - hDutyV[0] - TDEAD)> MAX_TRTS)
        {
          dvDutyValues.hTimeSmp1 = (hDutyV[0] + hDutyV[1] + TDEAD) >> 1;
        }
        else
        {
          dvDutyValues.hTimeSmp1 = hDutyV[1] - TBEFORE;
        }
        // Second point
        if ((hDutyV[2] - hDutyV[1] - TDEAD)> MAX_TRTS)
        {
          dvDutyValues.hTimeSmp2 = (hDutyV[1] + hDutyV[2] + TDEAD) >> 1;
        }
        else
        {
          dvDutyValues.hTimeSmp2 = hDutyV[2] - TBEFORE;
        }
      }
      else 
      {
        // Adjust hDuty
        hDutyV[0] = dvDutyValues.hTimePhA;
        hDutyV[1] = dvDutyValues.hTimePhB;
        hDutyV[2] = dvDutyValues.hTimePhC;
        
        // Sort ascendant
        if (hDutyV[0] > hDutyV[1])
        {
          // Swap [0] [1]
          hDutyV[3] = hDutyV[0];
          hDutyV[0] = hDutyV[1];
          hDutyV[1] = hDutyV[3];
        }
        if (hDutyV[0] > hDutyV[2])
        {
          // Swap [0] [2]
          hDutyV[3] = hDutyV[0];
          hDutyV[0] = hDutyV[2];
          hDutyV[2] = hDutyV[3];
        }
        if (hDutyV[1] > hDutyV[2])
        {
          // Swap [1] [2]
          hDutyV[3] = hDutyV[1];
          hDutyV[1] = hDutyV[2];
          hDutyV[2] = hDutyV[3];
        }
      }
      
      if (bStatorFluxPos == BOUNDARY_1) // Two small, one big
      {   
        // Check after the distortion for sampling space
        if ((hDutyV[1] - hDutyV[0])< TMIN)
        {
          // After the distortion the first sampling point can't be performed
          // It is necessary to swtch to Boudary 3
          
          // Restore the distorted duty
          if (bInverted_pwm_new == INVERT_A);
            dvDutyValues.hTimePhA +=HTMIN;
          if (bInverted_pwm_new == INVERT_B);
            dvDutyValues.hTimePhB +=HTMIN;
          if (bInverted_pwm_new == INVERT_C);
            dvDutyValues.hTimePhC +=HTMIN;
          
          // Switch to Boudary 3
          bStatorFluxPos = BOUNDARY_3;        
          if (bStBd3 == 0)
          {
            bInverted_pwm_new = INVERT_A;
            dvDutyValues.hTimePhA -=HTMIN;
            bStBd3 = 1;
          } 
          else
          {
            bInverted_pwm_new = INVERT_B;
            dvDutyValues.hTimePhB -=HTMIN;
            bStBd3 = 0;
          }
        }
        
        // First point
        if ((hDutyV[1] - hDutyV[0] - TDEAD)> MAX_TRTS)
        {
          dvDutyValues.hTimeSmp1 = (hDutyV[0] + hDutyV[1] + TDEAD) >> 1;
        }
        else
        {
          dvDutyValues.hTimeSmp1 = hDutyV[1] - TBEFORE;
        }
        // Second point
        dvDutyValues.hTimeSmp2 = PWM_PERIOD - HTMIN + TSAMPLE;
      }
      
      if (bStatorFluxPos == BOUNDARY_2) // Two big, one small