单片机教程网

电脑版
提示:原网页已由神马搜索转码, 内容由www.51hei.com提供.
查看:19518|回复:21
打印上一主题下一主题

dsPIC单片机buck-boost拓扑双向DC-DC电源变换器设计(源码+论文+PCB)

 [复制链接]
跳转到指定楼层
楼主
ID:328861发表于 2018-9-3 20:55|只看该作者|只看大图回帖奖励
摘要
为实现电池储能装置的双向DC-DC变换器，本系统以buck-boost拓扑电路为核心，通过DSPICFJ256GP710单片机最小系统控制拓扑的切换，从而进行buck恒流充电和boost恒压放电。充电时效率≥94%，放电时效率≥95.5%，具有过压保护及温度检测等功能。本系统具有效率高、控制简单、稳定性强等优点，满足设计要求。
目录
一、 方案论证与选取
1.1方案的论证
1.2方案的选取
1.3整体设计
2.1总体设计框图        
二、 理论分析与参数计算
2.1 开关场效应管的选择
2.2肖特基二极管的选择
2.3电感参数计算
2.4电容的参数计算
三、 电路与程序设计
3.1硬件部分设计
3.1.1buck-boost主电路模块
3.1.2 boost驱动电路
3.1.3 buck驱动电路
3.1.4 电流采集模块
3.2软件部分设计
3.2.1软件滤波算法
3.2.2软件流程图
四、 测试方案与测试结果
4.1测试仪器（见附件1）
4.2测试步骤及数据
4.2.1充电模式
4.2.2 放电模式
4.3 自由模式
五、 参考文献
六、 附件
6.1附件一 测试仪器
6.2附件二 作品照片
  • 方案论证与选取
1.1方案的论证
方案一：正反激组合式双向DC-DC变换器。它采用正激和反激组合的形式，在变换器的一侧绕组串联，另一侧并联。这种结构的双向变换拓扑解决了电流型一电压型组合式拓扑的开关管电压尖峰问题和启动问题。
方案二：纯硬件buck-boost双向DC-DC变换器。该方案结构简单，电源的实时性调整性比较强。但是不能实现升降压的自动转换，不能轻易实现人机交互，采集显示电路需要外加MCU。
方案三:buck-boost双向DC-DC变换器。用单片机进行控制，以buck恒流给电池充电，boost恒压对电池进行放电。
1.2方案的选取
方案一的电路过于复杂，且该变换器主要适合大功率电路，对于中小功率的电路来说电路损耗过大，且电路需用到变压器和大型散热片，使得整个系统的质量过重，不符合题目要求，所以舍弃。方案二虽然电路简单，但是不能实现升降压的自动转换。方案三利用单片机控制电路的工作模式，使得效率得到提高，符合题目的要求，因此选择此方案。
1.3整体设计

2.1总体设计框图
本系统由buck-boost拓扑电路组成，通过单片机的键盘控制主电路的工作模式，当选中buck模式时，单片机通过控制输出PWM的占空比进行电流调节，从而达到恒流充电；当选中boost模式时，单片机通过控制输出PWM的占空比进行电流调节，从而达到恒压放电。
  • 理论分析与参数计算
2.1 开关场效应管的选择
选择导通电阻小的IRF540作为开关管，其导通电阻仅为77mΩ（VGS=10V, ID=17A）。IRF540击穿电压VDSS为55V ，漏极电流最大值为28A（VGS =10 V， 25°C），允许最大管耗PCM可达50W，完全满足电路要求。
2.2肖特基二极管的选择
选择STC20100肖特基二极管，其导通压降小，通过1 A电流时仅为0.35V，并且恢复时间短。实际使用时为降低导通压降将两个肖特基二极管并联。
2.3电感参数计算
BUCK模式：电感选择应保证在最小电流输出时，电感电流也保持连续。直流电流等于电感电流斜坡峰-峰值dI一半时对应临界连续。Iomin=0.2Ion。又dI=VL*Ton/L,VL近似等于（Vdc-Vo），额定电流Ion=10* Iomin，Ton=Vo/Vdc得：Lp1=5(Vdc-Vo)VoT /Vdc*Ion。取开关频率为30KHz，算得L=400μH。
BOOST模式：根据设计要求可知占空比D=0.4，故Ton=D*T=13.32us，Lp2=Vdc*Ton/Ip=478μH。
综上，电感取两种模式平均值L=439μH，实际绕制的电感值为436μH。选用铂科公司的NPS130060磁环，AL=61nH/N^2，根据L=AL*N^2得出N=85匝。根据1mm^2走3~5A           电流取0.8mm线径。
2.4电容的参数计算
滤波电容的选择必须满足输出纹波的要求。本系统的电容可等效为电阻Ro和电感Lo与其的串联（如图4-2-1）。一般情况下，工作频率在300kHz以下是可以忽略Lo（等效串联电感ESL）。
2.2.4电容等效电路
取纹波电压峰峰值为0.06V，RoCo≈50~80*〖10〗^(-6)ΩF，取平均值65*〖10〗^(-6)ΩF。求得Co=433μF，实际取470μF。
  • 电路与程序设计
3.1硬件部分设计
3.1.1buck-boost主电路模块
为了满足电池储能装置的双向DC-DC变换器，实现电池的充放电功能，主电路采用buck-boost拓扑电路，通过buck恒流对电池充电，boost恒压对电池放电。当工作在充电状态下，此时Q2导通，Q3截止，电流流过电感对电池进行充电。当工作在放电状态下，此时Q3导通，Q2截止，电池进行放电。如图3.1.1所示。
3.1.1 buck-boost主电路
3.1.2boost驱动电路
由霍尔采集电流供给单片机，单片机经过处理后输出PWM，为增加驱动能力，采用推挽结构输出PWM控制主电路mos管的占空比。如图3.1.2所示。
3.1.2 boost驱动电路


3.1.3buck驱动电路
当单片机输入PWM时，经过大功率光耦T1隔离驱动MOS管。如图3.1.3所示。
3.1.3 buck驱动电路
3.1.4 电流采集模块
系统采用霍尔传感器对电路的电流进行采集，经过电流电压转换，由电阻分压后送入单片机进行A/D转换。如图3.1.4所示。

3.1.4 电流采集电路


3.2软件部分设计
3.2.1软件滤波算法
连续取N个采样值进行算术平均运算 N值较大时：信号平滑度较高，但灵敏度较低 N值较小时：信号平滑度较低，但灵敏度较高 N值的选取：一般流量，N=12；压力：N=4；此算法适用于对一般具有随机干扰的信号进行滤波 这样信号的特点是有一个平均值，信号在某一数值范围附近上下波动。
3.2.2软件流程图

3.2.2 软件流程图
  • 测试方案与测试结果
4.1测试仪器（见附件1）
4.2测试步骤及数据
4.2.1充电模式
  • 条件：U2=30V,实现电池恒流充电。要求：I1在1~2A范围可调，步进值不大于0.1A，电流控制精度不低于5%。
表1  I1步进值精度测量
设定值
万用表示数
精度
1
1.005
0.500%
1.1
1.102
0.182%
1.2
1.206
0.500%
1.3
1.305
0.385%
1.4
1.406
0.429%
1.5
1.487
-0.867%
1.6
1.606
0.375%
1.7
1.709
0.529%
1.8
1.805
0.278%
1.9
1.904
0.211%
2.0
2.014
0.700%
  • 条件：I1=2A，调整直流稳压电源输出电压。要求：U2在24~36V范围变化时，充电电流I1的变化率不大于1%。
表2  充电电流I1的电压调整率
U2
I1
电流变化率
24
2.012
0.049%
30.99
2.012
36.09
2.013
  • 条件：I1=2A,U2=30V。要求：变换器的效率η≥90%。
表3  变换器效率
U1
I1
U2
I2
效率
19.69
2.012
29.94
1.393
94.9884%
  • 条件：单片机显示充电电流I1。要求：I1=1~2A范围内测量精度不低于2%。
表4  电流I1测量精度
万用表
单片机
误差百分比
1.012
1
1.200%
1.115
1.1
1.364%
1.213
1.2
1.083%
1.309
1.3
0.692%
1.408
1.4
0.571%
1.512
1.5
0.800%
1.61
1.6
0.625%
1.72
1.71
0.585%
1.815
1.8
0.833%
1.918
1.91
0.419%
2.021
2.06
-1.893%
（5）过充保护：I1=2A时，当U1超过阈值电压后，停止充电。
4.2.2放电模式
  • 条件：断开S1，接通S2，将装置设定为放电模式，保持U2=30±0.5V。要求：变换器效率η≥95%。
表5 boost恒压放电效率
U1
I1
U2
I2
效率
20.81
1.493
30.01
0.994
96.0109%
4.3自由模式
当接通S1、S2，断开S3，调整直流稳压电源输出电压，使Us在32~38范围内变化时，双向buck-boost拓扑电路能够自动转换工作模式并保持U2=30±0.5V。
  • 参考文献
[1] （美）马尼克塔拉著，王志强等译，精通开关电源设计，北京：人民邮电     出版社
[2] 长谷川彰，开关式稳压器的设计技术（第一版），北京科学出版社，1989
[3] 顾亦磊，陈世杰，吕征宇，Boost电路的一种实现方法，电源技术应用，2004
[4] 李爱文，张承惠，现代逆变技术及应用，北京科学出版社，2000
[5] 华成英，童诗白，模拟电子技术基础（第四版），高等教育出版社，2006
  • 附件
6.1附件一 测试仪器
序 号
名称、型号及规格
主要技术指标
数 量
备 注
1
数字万用表vc980+
直流电压：200mV/2V/20V/200 V /1000V——±(0.05%+3)
直流电流：200uA/2mA/20mA/ 200mA/20A——±(0.5%+4)
交流电压：200mV/2V/20V/200 V/750V——±(0.8%+25)
交流电流：200mA/20A——   ±(1.5%+25)
4

2
Tektronix双通道数字存储示波器
200MHz 2GS/S
1

3
Lecroy waveRunner 104mxi数字示波器
1GHz Oscilloscope 10GS/S
1
力科
4
IT8516B可编程直流电子负载
500V/120A/2400W
1
ITECH
5
IT6164S直流可编程电源
60V*20A
1
ITECH
6
高精度实验室电源PS 8000 3U
0…500V/0…30A/0…5000W
1
EA
7
红外测温仪
输出<1mW,波长630-670nm
1

8
HP34411A六位半数字万用表

1
安捷伦
6.2附件二 作品照片



DSPICFJ256GP710单片机源程序如下:
  1. #include "p33FJ256GP710.h"
  2. #include<math.h>
  3. #include "Delay.h"
  4. #include "InitCPU.h"
  5. #include "LCD12864.h"
  6. #include "ADC.h"
  7. #include "KEY.h"
  8. #include "PWM.h"
  9. #include "DS18B20.h"
  10. #define uint unsigned int
  11. #define uchar unsigned char
  12. #define ulint unsigned long int

  14. #define KeyPort PORTE
  15. /*********变量定义***********/
  16. unsigned char KEY_Receive =0;                 //按键扫描结果存储
  17. unsigned int cls=0;                           //清屏指示
  18. unsigned char switchover =0;                 //换屏
  19. unsigned int Duty_one =0,Duty_two=0;       //占空比寄存器
  20. unsigned int I_Set_One =15000;       //1模块和2模块设定电流值（调光）
  21. unsigned int count =0,start=0,start1=0;   //
  22. unsigned char test =0;                           //按键加减寄存器（test =1加；test=2减）
  23. unsigned char BUCK=0,BOOST=0;                           //采集100次标志位
  24. /********************状态标志位************************/
  25. unsigned  char Menu =1;                                           //主菜单标志位
  26. unsigned char Menu_A =0;                                       //一级菜单A（状态A）
  27. unsigned char Menu_B =0;
  28. unsigned char Menu_C =0;                       //一级菜单B（状态B）
  29. unsigned char Cursor =1;                                       //光标状态标志位
  30. unsigned char stateA =0;                                       //A状态标志位（区分正常模式还是过流保护）
  31. unsigned char stateB =0;                                       //B状态标志位
  32. unsigned char stateC =0;

  34. float RE_Ui=0,RE_Uo=0,RE_Ii=0,RE_Io=0;
  35. float RE_Ui_all=0,RE_Uo_all=0,RE_Ii_all=0,RE_Io_all=0;
  36. float Ui_ave=0,Uo_ave=0,Ii_ave=0,Io_ave=0;
  37. float Ui=0,Uo=0,Ii=0,Io=0;
  38. float GETTEMP;
  39. float POWER_factor=0;

  41. unsigned char KeyScan();
  42. void main()
  43. {/*****初始化*****/
  44.        InitCPU();      
  45.        InitLCD();
  46.        Init_ADC();
  47.        Init_PWM();      
  48.        Init_DS18B20();
  49.        _TRISF2=0;//蜂鸣器输出
  50.        _TRISD1=0;
  51.        _TRISD2=0;
  52.        Clear_lcd();
  53.        DelayMs(10);
  54.    DISPLAY_stri(0 ,0 , "模式选择: ");
  55.    DISPLAY_stri(0,1,"->1.充电模块");      
  56.    DISPLAY_stri(0,2,"  2.放电模块");      
  57.    DISPLAY_stri(0,3,"  3.自动模块");
  58.        writ_com(0x0F);      
  59.        writ_com(0x90);      
  60.        while(1)
  61.        {    
  62.          KEY_Receive=KeyScan();
  63.            switch ( KEY_Receive )
  64.            {
  65.                  case 1:             //光标向下移动（+）
  66.                  {                
  67.                            test =1;                       //按键寄存器，加
  68.                            if(Menu==1)
  69.                            {       test=0;
  70.                                  Cursor ++;
  71.                                  Cursor=Cursor>=4?1:Cursor;      
  72.                                  if( Cursor ==1 )
  73.                                  {
  74.                    DISPLAY_stri(0 ,1 , "->1.充电模块");      
  75.                    DISPLAY_stri(0 ,2 , "  2.放电模块");
  76.                    DISPLAY_stri(0 ,3 , "  3.自动模块");
  77.                                    writ_com(0x90);           //光标显示在第一行
  78.                                  }      
  79.                                  if( Cursor ==2 )
  80.                                  {DISPLAY_stri(0 ,1 , "  1.充电模块");      
  81.                  DISPLAY_stri(0 ,2 , "->2.放电模块");
  82.                  DISPLAY_stri(0 ,3 , "  3.自动模块");
  83.                                  writ_com(0x88);           //光标显示在第二行
  84.                                  }      
  85.                  if( Cursor ==3 )
  86.                                  {DISPLAY_stri(0 ,1 , "  1.充电模块");      
  87.                  DISPLAY_stri(0 ,2 , "  2.放电模块");
  88.                  DISPLAY_stri(0 ,3 , "->3.自动模块");
  89.                  writ_com(0x98);//光标显示在第二行
  90.                                }  
  91.                            }
  92.                            break;      
  93.                  }
  94.                  case 2:
  95.                  {
  96.                        //菜单光标，显示2行
  97.                            test =2;                       //按键寄存器，减
  98.                            if( Menu ==1)
  99.                            {       test=0;
  100.                                  Cursor --;
  101.                                  Cursor=Cursor==0?3:Cursor;      
  102.                                  if( Cursor ==1 )
  103.                                  {
  104.                                  DISPLAY_stri(0 ,1 , "->1.充电模块");
  105.                  DISPLAY_stri(0 ,2 , "  2.放电模块");
  106.                  DISPLAY_stri(0 ,3 , "  3.自动模块");
  107.                                  writ_com(0x90);           //光标显示在第一行
  108.                                  }      
  109.                                  if( Cursor ==2 )
  110.                                  {  
  111.                                        DISPLAY_stri(0 ,1 , "  1.充电模块");
  112.                      DISPLAY_stri(0 ,2 , "->2.放电模块");
  113.                      DISPLAY_stri(0 ,3 , "  3.自动模块");
  114.                                        writ_com(0x88);           //光标显示在第二行
  115.                                  }      
  116.                if( Cursor ==3 )
  117.                                  {     DISPLAY_stri(0 ,1 , "  1.充电模块");
  118.                      DISPLAY_stri(0 ,2 , "  2.放电模块");
  119.                      DISPLAY_stri(0 ,3 , "->3.自动模块");
  120.                                        writ_com(0x98);           //光标显示在第二行////////////////
  121.                                  }                                                                                          
  122.                            }
  123.                            break;                
  124.                  }
  125.                  case 3:           //(确定键，进入子状态(执行状态)
  126.                  {  
  127.                            switchover =~switchover;
  128.                            cls=1;                                                
  129.                            if( ( Menu * Cursor ) ==1 )  //BUCK模式
  130.                            {      
  131.                                  _TRISD1=0;
  132.                                  _TRISD2=0;                          
  133.                                  Menu_A =1;
  134.                                  Menu_B =0;
  135.                                  Menu_C =0;
  136.                                  Menu =0;

  138.                                  stateA=1;
  139.                                  stateB=0;
  140.                                  stateC=0;
  141.                                  OC3CONbits.OCM=0B110;
  142.                                  OC2CONbits.OCM=0B110;
  143.                                  Duty_one=10;                 //PWM设置one进行BUCK——PWM调整，two关断
  144.                                  Duty_two=0;

  146.                                  T2CONbits.TON=1;
  147.                                  writ_com(0x0C);                 //关闭游标和游标位置
  148.                                  Clear_lcd();
  149.                            }
  150.                            if(  ( Menu * Cursor ) ==2 )//BOOST模式
  151.                            {
  152.                                  _TRISD2=0;
  153.                                  _TRISD1=0;
  154.                                  Menu_A =0;
  155.                                  Menu_B =1;
  156.                                  Menu_C =0;
  157.                                  Menu =0;
  158.                       
  159.                                  stateA=0;
  160.                                  stateB=1;
  161.                                  stateC=0;
  162.                                  OC3CONbits.OCM=0B110;
  163.                                  OC2CONbits.OCM=0B110;
  164.                                  Duty_one=0;                 ////PWM设置two进行BUCK——PWM调整，one关断
  165.                                  Duty_two=10;

  167.                                  T2CONbits.TON=1;
  168.                                  writ_com(0x0C);                 //关闭游标和游标位置
  169.                                  Clear_lcd();
  170.                            }      
  171.                    if( ( Menu * Cursor ) ==3 )//自动模式
  172.                            {
  173.                                  _TRISD2=0;
  174.                                  _TRISD1=0;
  175.                                  Menu_A =0;
  176.                                  Menu_B =0;
  177.                                  Menu_C =1;
  178.                                  Menu =0;

  180.                                  stateA=0;
  181.                                  stateB=0;
  182.                                  stateC=1;
  183.                                  OC3CONbits.OCM=0B000;
  184.                                  OC2CONbits.OCM=0B000;
  185.                                  BUCK=0;
  186.                                  BOOST=0;
  187.                                  Duty_one=0;                 //PWM设置，刚开始用BUCK
  188.                                  Duty_two=0;

  190.                                  T2CONbits.TON=0;
  191.                                  writ_com(0x0C);                 //关闭游标和游标位置
  192.                                  Clear_lcd();
  193.                            }
  194.                            break;                      
  195.                  }
  196.                  case 4:
  197.                  {
  198.                            if( Menu_A ==1 )      
  199.                            {                          
  200.                                  Menu_A =0;
  201.                                  Menu_B =0;
  202.                                  Menu_C =0;
  203.                                  Menu =1;
  204.                                  Cursor =1;
  205.                                  stateA=0;
  206.                                  stateB=0;
  207.                                  stateC=0;
  208.                                  start=0;
  209.                                  OC3RS=0;      
  210.                                  OC2RS=0;
  211.                                  OC3CONbits.OCM=0B000;
  212.                                  OC2CONbits.OCM=0B000;
  213.                                  _LATD2=0;
  214.                                  _LATD1=0;
  215.                                  _LATF2=0;
  216.                                  T2CONbits.TON=0;
  217.                                  I_Set_One=15000;
  218.                                  Clear_lcd();
  219.                                  DelayMs(10);
  220.                                DISPLAY_stri(0 ,0 , "模式选择: ");
  221.                                  DISPLAY_stri(0 ,1 , "->1.充电模块");      
  222.                                  DISPLAY_stri(0 ,2 , "  2.放电模块");
  223.                  DISPLAY_stri(0 ,3 , "  3.自动模块");      
  224.                                  writ_com(0x90);
  225.                                  writ_com(0x0F);                          
  226.                            }
  227.                            if( Menu_B ==1 )
  228.                            {                          
  229.                                  Menu_A =0;
  230.                                  Menu_B =0;
  231.                                  Menu_C =0;
  232.                                  Menu =1;
  233.                                  Cursor =1;
  234.                                  stateA=0;
  235.                                  stateB=0;
  236.                                  stateC=0;
  237.                                  OC3RS=0;
  238.                                  OC2RS=0;
  239.                                  start1=0;
  240.                                  OC3CONbits.OCM=0B000;
  241.                                  OC2CONbits.OCM=0B000;
  242.                                  _LATD2=0;
  243.                                  _LATD1=0;
  244.                                  T2CONbits.TON=0;
  245.                                  Clear_lcd();
  246.                                  DelayMs(10);
  247.                            DISPLAY_stri(0 ,0 , "模式选择: ");
  248.                                  DISPLAY_stri(0 ,1 , "->1.充电模块");      
  249.                                  DISPLAY_stri(0 ,2 , "  2.放电模块");
  250.                  DISPLAY_stri(0 ,3 , "  3.自动模块");      
  251.                                  writ_com(0x90);
  252.                                  writ_com(0x0F);
  253.                            }
  254.                    if( Menu_C ==1 )
  255.                            {                          
  256.                  Menu_A =0;
  257.                                  Menu_B =0;
  258.                                  Menu_C =0;
  259.                                  Menu=1;
  260.                                  Cursor=1;
  261.                                  stateA=0;
  262.                                  stateB=0;
  263.                                  stateC=0;
  264.                                  OC3RS=0;
  265.                                  OC2RS=0;
  266.                                  _LATD2=0;
  267.                                  _LATD1=0;
  268.                                  OC3CONbits.OCM=0B000;
  269.                                  OC2CONbits.OCM=0B000;
  270.                                  T2CONbits.TON=0;
  271.                                  Clear_lcd();
  272.                                  DelayMs(10);
  273.                                DISPLAY_stri(0 ,0 , "模式选择: ");
  274.                                  DISPLAY_stri(0 ,1 , "->1.充电模块");      
  275.                                  DISPLAY_stri(0 ,2 , "  2.放电模块");
  276.                  DISPLAY_stri(0 ,3 , "  3.自动模块");      
  277.                                  writ_com(0x90);
  278.                                  writ_com(0x0F);
  279.                            }
  280.                            break;                      
  281.                  }
  282.                  default :break;
  283.            }
  284.            switch (stateA)//充电模式
  285.            {
  286.                  case 1:       //采集电压电流
  287.                            RE_Ui=filter(0);      
  288.                            RE_Ii=filter(1);
  289.                            RE_Uo=filter(2);
  290.                            RE_Io=filter(3);
  291.                            Ui=(RE_Ui/1.023)*38.74;
  292.                            Ii=((RE_Ii/1023)*2980-2082)*10000/418;
  293.                            Uo=(RE_Uo/1.023)*25.33;          
  294.                            Io=((RE_Io/1023)*2980-2063)*10000/417;
  295.                           
  296.                        //       POWER_factor=Ui
  297.                            start++;      
  298.                       
  299.                            I_Set_One=test==1?I_Set_One+1000:I_Set_One;
  300.                            I_Set_One=test==2?I_Set_One-1000:I_Set_One;
  301.                            I_Set_One=I_Set_One>20000?10000:I_Set_One;
  302.                            I_Set_One=I_Set_One<10000?20000:I_Set_One;
  303.                            test=0;      
  304.                            if(Io>=I_Set_One)
  305.                            {
  306.                            Duty_one=Duty_one<=10?700:Duty_one-1;
  307.                            }
  308.                            else
  309.                            {
  310.                            Duty_one=Duty_one>=1300?700:Duty_one+1;
  311.                            }
  312.                       
  313.                            if(Uo>=24000)           //过压保护
  314.                            {
  315.                                  DelayMs(2000);
  316.                                  if(Uo>=24000)
  317.                                  {
  318.                                  _LATF2=1;
  319.                                  T2CONbits.TON=0;
  320.                                  OC3CONbits.OCM=0B000;
  321.                                  OC2CONbits.OCM=0B000;
  322.                                  _LATD2=0;
  323.                                  _LATD1=0;
  324.                                  }
  325.                            }
  326.                            if(switchover)           //翻页显示
  327.                            {
  328.                            if(cls==1)
  329.                            {
  330.                            Clear_lcd();
  331.                            DelayMs(10);
  332.                            }
  333.                            cls=0;
  334.                            DISPLAY_stri(0,0,"输入Ui：");
  335.                            DISPLAY_stri(4,0,ADC_deal_U(Ui));
  336.                            DISPLAY_stri(0,1,"输入Ii：");
  337.                            DISPLAY_stri(4,1,ADC_deal_I_1(Ii));
  338.                            DISPLAY_stri(0,2,"输出Uo：");
  339.                            DISPLAY_stri(4,2,ADC_deal_U(Uo));
  340.                            DISPLAY_stri(0,3,"输出Io：");
  341.                            if(start==50)
  342.                            {start=0;
  343.                            GETTEMP=GETTEMP_DS18B20();
  344.                            DISPLAY_stri(4,3,ADC_deal_I_1(Io));
  345.                            }
  346.                            }
  347.                            if(!switchover)
  348.                            {
  349.                            if(cls==1)
  350.                            {
  351.                            Clear_lcd();
  352.                            DelayMs(10);
  353.                            }
  354.                            cls=0;
  355.                            DISPLAY_stri(0,1,"I_set ： ");
  356.                            DISPLAY_stri(4,1,ADC_deal_I_1(I_Set_One));
  357.                            DISPLAY_stri(0,0,"T：  ");
  358.                            DISPLAY_stri(4,0,ADC_deal_U(GETTEMP*100));
  359.                            DISPLAY_stri(0,2,"I_fact：");
  360.                            if(start==50)
  361.                            {
  362.                            start=0;
  363.                            GETTEMP=GETTEMP_DS18B20();
  364.                            DISPLAY_stri(4,2,ADC_deal_I_1(Io));
  365.                            }
  366.                            }
  367.                            stateA=1;          
  368.                            break;
  369.                  default :break;
  370.            }

  372.            switch (stateB)//放电模式
  373.            {
  374.                  case 1:       //采集电压电流
  375.                            RE_Ui=filter(0);      
  376.                            RE_Ii=filter(1);
  377.                            RE_Uo=filter(2);
  378.                            RE_Io=filter(3);
  379.                            Ui=(RE_Ui/1.023)*38.74;
  380.                            Ii=(2082-(RE_Ii/1023)*2980)*10000/418;
  381.                            Uo=(RE_Uo/1.023)*25.33;          
  382.                            Io=(2079-(RE_Io/1023)*2980)*10000/417;
  383.                        //       GETTEMP=GETTEMP_DS18B20();          
  384.                            if(Ui>=30000)           //恒压
  385.                            {
  386.                            Duty_two=Duty_two<10?700:Duty_two-1;
  387.                            }
  388.                            else
  389.                            {
  390.                            Duty_two=Duty_two>1300?700:Duty_two+1;
  391.                            }
  392.                            start1++;      
  393.                            DISPLAY_stri(0,0,"输入Ui：");
  394.                            if(start1==50)
  395.                            {
  396.                            start1=0;
  397.                            DISPLAY_stri(4,0,ADC_deal_U(Ui));
  398.                            }
  399.                            DISPLAY_stri(0,1,"输入Ii：");
  400.                            DISPLAY_stri(4,1,ADC_deal_I_1(Ii));
  401.                            DISPLAY_stri(0,2,"输出Uo：");
  402.                            DISPLAY_stri(4,2,ADC_deal_U(Uo));
  403.                            DISPLAY_stri(0,3,"输出Io：");
  404.                            DISPLAY_stri(4,3,ADC_deal_I_1(Io));
  405.                            stateB=1;          
  406.                            break;
  407.                  default :break;
  408.            }
  409.         
  410.            switch (stateC)//自动模式
  411.            {
  412.                  case 1:      
  413.                            RE_Ui=filter(0);      
  414.                            RE_Uo=filter(2);
  415.                            Ui=(RE_Ui/1.023)*38.74;
  416.                            Uo=(RE_Uo/1.023)*25.33;          
  417.                           
  418.                            if((Ui>30300)&(BUCK!=1))           //BUCK模式  大于30.3       选定BUCK状态
  419.                            {
  420.                            BUCK=1;
  421.                            BOOST=0;
  422.                            OC3CONbits.OCM=0B110;  //BUCK开
  423.                            OC2CONbits.OCM=0B000;       //BOOST关
  424.                            Duty_one=10;
  425.                            T2CONbits.TON=1;      
  426.                            }
  427.                            if((Ui<29700)&(BOOST!=1))           //BOOST模式  小于29.7       选定BOOST状态
  428.                            {
  429.                            BUCK=0;
  430.                            BOOST=1;
  431.                            OC3CONbits.OCM=0B000;  //BUCK关
  432.                            OC2CONbits.OCM=0B110;       //BOOST开
  433.                            Duty_two=10;
  434.                            T2CONbits.TON=1;      
  435.                            }
  436.                            if(BUCK==1)
  437.                            {
  438.                                  if(Ui>=30000)           //恒压
  439.                                  {
  440.                                  Duty_one=Duty_one>1300?10:Duty_one+1;
  441.                                  }
  442.                                  else
  443.                                  {
  444.                                  Duty_one--;
  445.                                  if(Duty_one==4)
  446.                                  {
  447.                                        //Duty_one=0;
  448.                                        //Duty_two=6;
  449.                                        T2CONbits.TON=0;
  450.                                        OC3CONbits.OCM=0B000;  //BUCK关
  451.                                        OC2CONbits.OCM=0B110;       //BOOST开
  452.                                        Duty_one=0;
  453.                                        Duty_two=6;
  454.                                        T2CONbits.TON=1;
  455.                                        BOOST=1;
  456.                                        BUCK=0;
  457.                                  }      
  458.                                  }      
  459.                            }
  460.                            if(BOOST==1)
  461.                            {
  462.                                  if(Ui>=30000)           //恒压
  463.                                  {
  464.                                  Duty_two--;
  465.                                  if(Duty_two==4)
  466.                                  {
  467.                                        T2CONbits.TON=0;
  468.                                        Duty_two=0;
  469.                                        Duty_one=6;
  470.                                        OC3CONbits.OCM=0B110;  //BUCK开
  471.                                        OC2CONbits.OCM=0B000;       //BOOST关
  472.                                        T2CONbits.TON=1;
  473.                                        BOOST=0;
  474.                                        BUCK=1;
  475.                                  }      
  476.                                 
  477.                                  }
  478.                                  else
  479.                                  {
  480.                                  Duty_two=Duty_two>1300?10:Duty_two+1;
  481. ……………………

  483. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码


Altium Designer画的原理图和PCB图如下：(51hei附件中可下载工程文件)




所有资料51hei提供下载（含完整的Word格式设计论文）:
DCDC电源方案.rar(7.51 MB, 下载次数: 489)


评分

黑币 +100
收起理由
+ 100
共享资料的黑币奖励！

查看全部评分

沙发
ID:326785发表于 2018-9-20 17:14|只看该作者
好资料，在设计电源，参考参考
板凳
ID:415476发表于 2018-10-25 21:25|只看该作者
好资料，在设计电源，参考参考
地板
ID:92810发表于 2018-11-12 15:51|只看该作者
学习了，谢谢楼主分享了
5#
ID:302666发表于 2018-12-26 18:46|只看该作者
好资料，多谢啊
6#
ID:503878发表于 2019-4-3 10:33|只看该作者
学习，好资料
7#
ID:225311发表于 2019-4-17 08:15|只看该作者

好资料，正在设计电源，多谢
8#
ID:105634发表于 2019-7-23 13:53|只看该作者
好资料，感谢楼组无私奉献
9#
ID:282095发表于 2019-7-24 09:10|只看该作者
这个不是很清楚 需要学习学习
10#
ID:400026发表于 2020-3-17 11:45|只看该作者
感谢分享良心资源
11#
ID:771287发表于 2020-6-6 16:59|只看该作者
好资料啊，谢谢楼主
12#
ID:362692发表于 2021-4-20 17:35|只看该作者
请问程序  是用什么软件打开的？
13#
ID:216379发表于 2021-7-11 13:28|只看该作者
好资料，51黑有你更精彩!
14#
ID:952621发表于 2021-7-13 15:56|只看该作者
好资料，准备转向搞电源，希望能尽快入手
15#
ID:958920发表于 2021-8-4 22:40|只看该作者
好资料呀，正好再搞双向DC这一块的内容，楼主大佬
16#
ID:430492发表于 2021-8-5 09:11|只看该作者
感谢楼主分享，好资料呀，正好想搞一个双向DC！！！
17#
ID:430492发表于 2021-8-5 09:24|只看该作者
那个霍尔电流传感器啥型号啊？
18#
ID:596338发表于 2021-8-6 06:51|只看该作者
感谢分享的资料，受益匪浅，谢谢了！！
19#
ID:137526发表于 2021-10-7 08:50|只看该作者
求告知霍尔电流传感器啥型号？
20#
ID:58106发表于 2021-10-11 09:26|只看该作者
楼主的万用表阵列很牛
21#
ID:492928发表于 2022-3-27 17:36|只看该作者
好资料，在设计电源，参考参考
22#
ID:402383发表于 2024-5-14 16:06|只看该作者
很好的文章！值得推荐和学习！！！！

手机版|小黑屋|51黑电子论坛|51黑电子论坛6群QQ管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网