数控电源的原理是什么

　　话说最近做了一个数控电源
　　首先原理图来一个 看看原理
　　
　　既然讲到数控电源，难免讲解一下数控电源的知识点，升降压 MOS管，
　　我所做的是BUCK降压电路
　　一、Buck电路原理图
　　
　　Buck电路，又称降压电路，其基本特征是DC-DC转换电路，输出电压低于输入电压。输入电流为脉动的，输出电流为连续的
　　二、Buck电路工作原理
　　当开关管Q1驱动为高电平时，开关管导通，储能电感L1被充磁，流经电感的电流线性增加，同时给电容C1充电，给负载R1提供能量。等效电路如图二
　　
　　图二
　　当开关管Q1驱动为低电平时，开关管关断，储能电感L1通过续流二极管放电，电感电流线性减少，输出电压靠输出滤波电容C1放电以及减小的电感电流维持，等效电路如图三
　　
　　图三
　　三、Buck电路的三种工作模式：CCM，BCM，DCM
　　1、CCM Mode：关键点原件波形见图四
　　
　　图四
　　开关管Q1导通时，根据KVL定律：
　　
　　
　　2、BCM Mode：关键点原件波形见图五
　　
　　图五
　　
　　3、DCM Mode：关键点原件波形见图六
　　
　　图六
　　
　　四、外为参数对系统工作模式的影响：
　　
　　图七
　　
　　五、BUCK电路仿真验证：
　　
　　
　　图八
　　
　　
　　2、CCM模式仿真验证：在上述BCM分析的基础上，得出储能电感的电感量80uH为临界点，由系统工作在CCM的条件，可以将储能电感电感量设置为120uH，理论计算：
　　
　　参照图十，可以得出仿真结果，
　　
　　
　　3、DCM模式仿真验证：在上述BCM分析的基础上，得出储能电感的电感量80uH为临界点，由系统工作在DCM的条件，可以将储能电感电感量设置为40uH。重点验证输入输出电压关系以及输出平均电流关系。
　　
　　
　　
　　
　　以上的知识点 是我在其他网站上看到的，觉得很不错，大家可以学习基本的BUCK电路，以此来设计属于自己的电路
　　调压调流 具有过压保护
　　过流保护
　　MOS管的开启关断 ，双闭环控制 输出电压 电流采样
　　输入电压采样 PID 算法
　#include "pid.h"

/**
  * @brief  pidInit
  * @param  None
  * @retval None
  */
void pidInit(PidObject* pid)
{
        pid->ap        = pid->kp * (1 + pid->dt / pid->ki + pid->kd / pid->dt);
        pid->ai        = pid->kp * (1 + 2 * pid->kd / pid->dt);
        pid->ad        = pid->kp * pid->kd / pid->dt;
}

/**
  * @brief  pidUpdate
  * @param  None
  * @retval None
  */
float pidUpdate(PidObject* pid, const float desired, const float now_value)
{
        float output=0.0f;
        
        pid->error = desired - now_value;

        pid->inc = (pid->ap * pid->error) - (pid->ai * pid->prevError1) + (pid->ad * pid->prevError2);
        
        output = pid->inc + pid->outLast1;
        
        if(output > pid->iLimitHigh)
        {
                output = pid->iLimitHigh;
        }
        
        if(output < pid->iLimitLow)
        {
                output = pid->iLimitLow;
        }
        
        pid->prevError2        = pid->prevError1;
        pid->prevError1        = pid->error;
        pid->outLast1        = output;
        
        return output;
}

/**
  * @brief  pid calear
  * @param  None
  * @retval None
  */
void pidClear(PidObject* pid)
{
        pid->error             = 0;
        pid->prevError1 = 0;
        pid->prevError2 = 0;
        
        pid->outLast1        = 0;
        pid->inc                = 0;
}


/**
  * @brief  pidReset
  * @param  None
  * @retval None
  */
void pidReset(PidObject* pid)
{
        pid->error             = 0.0f;
        pid->prevError1 = 0.0f;
        pid->prevError2 = 0.0f;
        pid->outLast1        = 0.0f;
        pid->inc                = 0.0f;
        
        pid->desired = 0.0f;
        pid->iLimitHigh = 0.0f;
        pid->iLimitLow = 0.0f;
        
        pid->dt = 0.0f;
        pid->kp = 0.0f;
        pid->ki = 0.0f;
        pid->kd = 0.0f;
        
        pid->ad = 0.0f;
        pid->ai = 0.0f;
        pid->ap = 0.0f;
        
}
   * @brief  This function ...
  * @param  None
  * @retval None
  */
static uint16_t cnt=0;
void myControlTask(void)
{
float fb_io=0.0f;
float fb_vo=0.0f;
float fb_w=0.0f;
// OLED_ShowChar(16, 2, ':', 16);
if(device.outputState!=0)
{
  
  device.iovp = (power.Vi>PW_VOLTAGV_IN_MAX)?1:0;  //输入过压保护
  device.iuvp = (power.Vi   device.oocp = (power.Io>PW_CURRENT_OUT_MAX)?1:0; //输出过流保护
  device.oovp = (power.Vo>(PW_VOLTAGV_OUT_MAX+0.5f))?1:0; //输出过压保护
  
  if(device.iovp||device.iuvp||device.oocp||device.oovp)
  {
   PWM_Stop();
   device.recoveryCnt = 0;
   LED_OUT_OFF;
   LED_CV_CC_OFF;
  }
  else
  { //故障恢复
   device.recoveryCnt = (device.recoveryCnt>device.faultTime)?device.recoveryCnt:device.recoveryCnt+1;
  }

  fb_io = ((float)power.channel[1] - calib.ioZero) * calib.ioRatio;
  fb_vo = power.channel[2] * calib.voRatio;
  if(fb_io<0)
  {
   fb_io = 0;
  }
  /* 大电流补偿压差 */
  #if _USE_COMPENSATE
  fb_vo -= (fb_io * 0.05f);
  if(fb_vo<0)
  {
   fb_vo = 0;
  }
  #endif
  /*  */
  
  /* 恒功率 */
  #if 1
  fb_w = fb_vo*fb_io;
  if(fb_w>250.0f)
  {
   PWM_Stop();
   device.recoveryCnt = 0;
   LED_OUT_OFF;
   LED_CV_CC_OFF;
  }
  #endif
  /* */

  if(device.recoveryCnt==device.faultTime) //恢复PWM波形输出
  {
   pidClear(&vPID);
   pidClear(&iPID);
   device.controlPWM = 0;
   PWM_Start();
   PWM_Update(device.controlPWM);
   LED_OUT_ON;
  }

  if(device.recoveryCnt>=device.faultTime)
  {
   switch(device.controlMode)
   {
    case CV_MODE:
     device.controlPWM = pidUpdate(&vPID, vPID.desired, fb_vo); //电压环PID计算     
     iPID.outLast1 = device.controlPWM;
     device.controlMode = (fb_io      if(cnt%50==0) { LED_CV_ON; }
     break;
    case CC_MODE:
     device.controlPWM = pidUpdate(&iPID, iPID.desired, fb_io); //电流环PID计算
     vPID.outLast1 = device.controlPWM;
     device.controlMode = (fb_vo>vPID.desired)?CV_MODE:CC_MODE;
     if(cnt%50==0) { LED_CC_ON; }
     break;
    default:
     device.controlMode = CV_MODE;
     break;
   }
   
   PWM_Update(device.controlPWM);
  }

  cnt++;
}
}

了解一下，没有软件基础不行呀