单片机教程网

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

基于proteus的电子负载仿真与Arduino源程序

[复制链接]
跳转到指定楼层
楼主
ID:141133发表于 2018-1-1 08:23|只看该作者|只看大图回帖奖励
附件是基于proteus的电子负载仿真，主控芯片是AVR。
ElectronicLoad-master
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）



Arduino单片机源程序如下:
  1. #define DEBUG

  3. #include< LiquidCrystal.h>
  4. #include< Encoder.h>
  5. #include "variables.h"
  6. #include "lcd.h"
  7. #include "pwm16Bit.h"
  8. #include "iSet.h"
  9. #include "timer2.h"
  10. #include "misc.h"
  11. #include "voltageAndCurrentSensors.h"


  14. void setup() {

  16.   #ifdef DEBUG
  17.    Serial.begin(115200);
  18.   #endif

  20.   //ILOAD_PIN as PWM output
  21.   setupPWM16();

  23.   //Configure TIMER2 so that it calls ISR(TIMER2_COMPA_vect) @ 500Hz (every 2mS)
  24.   //ISR(TIMER2_COMPA_vect) is used to update CC waveforms
  25.   setupTimer2();

  27.   //LCD Setup
  28.   lcd.begin(16, 2);
  29.   lcd.print("ElectronicLoad");
  30.   lcd.setCursor(0,1);
  31.   lcd.print("  [Version 1.07]");
  32.   lcd.createChar(0, ohm);
  33.   lcd.createChar(1, vLoad);
  34.   lcd.createChar(2, iLoad);
  35.   lcd.createChar(3, hi);
  36.   lcd.createChar(4, lo);

  38.   delay(1500);

  40.   //Button and Led pinmode setup
  41.   pinMode(OUTPUT, outputEnabledLed);
  42.   pinMode(INPUT, encBtn);
  43.   digitalWrite(encBtn, HIGH);             //Enable internal pullup
  44.   pinMode(INPUT, modeSelectorBtn);
  45.   digitalWrite(modeSelectorBtn, HIGH);       //Enable internal pullup
  46.   pinMode(INPUT, outputEnableBtn);
  47.   digitalWrite(outputEnableBtn, HIGH);       //Enable internal pullup

  49.   //ISet calibration (Finds a proper ISetOneAmp value where IL=1A)
  50.   //calibrateISet();
  51.   ISetOneAmp=14280;

  53.   resetLcdToDefault();
  54.   lcd.setCursor(0, 0);
  55.   lcd.write("C.Cur:");
  56. }


  59. void loop() {

  61. if(mode == CONSTANT_CURRENT) {
  62.    int encoderPos = getEncoderMovement();     //getEncoderMovement() returns either -1, 0 or 1
  63.    if(encoderPos > 0&& ISetVal< ISET_CC_MAX)   //Encoder incremented
  64.      ISetVal+=ISET_CC_STEP;
  65.    else if (encoderPos< 0&& ISetVal >= ISET_CC_STEP)   //Encoder decremented
  66.      ISetVal-=ISET_CC_STEP;

  68.    lcd.setCursor(0, 1);
  69.    lcdPrintIntWhitespace(ISetVal, 4);
  70.    lcd.print(ISetVal);
  71.    lcd.write("mA");
  72.   }

  74.   
  75. if(mode == CONSTANT_RESISTANCE) {
  76.    byte encoderPos = getEncoderMovement();     //getEncoderMovement() returns either -1, 0 or 1
  77.    if(encoderPos > 0&& ISetVal< ISET_CR_MAX)   //Encoder incremented
  78.      ISetVal+=ISET_CR_STEP;
  79.    else if (encoderPos< 0&& ISetVal >= ISET_CR_MIN)   //Encoder decremented
  80.      ISetVal-=ISET_CR_STEP;
  81.   
  82.    lcd.setCursor(0, 1);
  83.    lcdPrintIntWhitespace(ISetVal, 4);
  84.    lcd.print(ISetVal);
  85.    lcd.write(byte(0)); //ohm char
  86.   }

  88.   
  89. if(mode == CONSTANT_POWER) {
  90.    byte encoderPos = getEncoderMovement();     //getEncoderMovement() returns either -1, 0 or 1
  91.    if(encoderPos > 0&& ISetVal< ISET_CP_MAX)   //Encoder incremented
  92.      ISetVal+=ISET_CP_STEP;
  93.    else if (encoderPos< 0&& ISetVal >= ISET_CP_STEP)   //Encoder decremented
  94.      ISetVal-=ISET_CP_STEP;
  95.   
  96.    lcd.setCursor(0, 1);
  97.    lcdPrintIntWhitespace(ISetVal, 4);
  98.    lcd.print(ISetVal);
  99.    lcd.write("mW");
  100.   }

  102.    if(mode == SQUARE_CURRENT) {
  103.    int encoderPos = getEncoderMovement();     //encoderPos is either -1, 0 or 1
  104.    if(encoderPos != 0) {                 //Encoder changed
  105.      switch(SCCurrentParam) {
  106.      case SC_PARAM_IHI:
  107.        if(encoderPos > 0&& ISetSCIHi< ISET_SC_IMAX)  
  108.        ISetSCIHi += ISET_SC_I_STEP;
  109.        else if(encoderPos< 0&& ISetSCIHi >= ISET_SC_I_STEP&& ISetSCIHi > ISetSCILo)        
  110.        ISetSCIHi -= ISET_SC_I_STEP;  
  111.        break;
  112.      case SC_PARAM_ILO:
  113.        if(encoderPos > 0&& ISetSCILo< ISET_SC_IMAX&& ISetSCILo< ISetSCIHi)  
  114.        ISetSCILo += ISET_SC_I_STEP;
  115.        else if(encoderPos< 0&& ISetSCILo >= ISET_SC_I_STEP)        
  116.        ISetSCILo -= ISET_SC_I_STEP;  
  117.        break;
  118.      case SC_PARAM_THI:
  119.        if(encoderPos > 0&& ISetSCTHi< ISET_SC_TMAX)  
  120.        ISetSCTHi += ISET_SC_T_STEP;
  121.        else if(encoderPos< 0&& ISetSCTHi >= ISET_SC_T_STEP)        
  122.        ISetSCTHi -= ISET_SC_T_STEP;  
  123.        break;
  124.      case SC_PARAM_TLO:
  125.      if(encoderPos > 0&& ISetSCTLo< ISET_SC_TMAX)  
  126.        ISetSCTLo += ISET_SC_T_STEP;
  127.        else if(encoderPos< 0&& ISetSCTLo >= ISET_SC_T_STEP)        
  128.        ISetSCTLo -= ISET_SC_T_STEP;  
  129.        break;
  130.      }
  131.    }

  133.    lcd.setCursor(0, 1);
  134.    switch(SCCurrentParam) {
  135.      case SC_PARAM_IHI:
  136.        lcd.write("I");
  137.        lcd.write(byte(3));
  138.        lcdPrintIntWhitespace(ISetSCIHi, 4);
  139.        lcd.print(ISetSCIHi);
  140.        lcd.write("mA");
  141.        break;
  142.       
  143.      case SC_PARAM_ILO:
  144.        lcd.write("I");
  145.        lcd.write(byte(4));
  146.        lcdPrintIntWhitespace(ISetSCILo, 4);
  147.        lcd.print(ISetSCILo);
  148.        lcd.write("mA");
  149.        break;
  150.       
  151.      case SC_PARAM_THI:
  152.        lcd.write("T");
  153.        lcd.write(byte(3));
  154.        lcdPrintIntWhitespace(ISetSCTHi, 4);
  155.        lcd.print(ISetSCTHi);
  156.        lcd.write("mS");  
  157.        break;
  158.         
  159.      case SC_PARAM_TLO:
  160.        lcd.write("T");
  161.        lcd.write(byte(4));
  162.        lcdPrintIntWhitespace(ISetSCTLo, 4);
  163.        lcd.print(ISetSCTLo);
  164.        lcd.write("mS");
  165.        break;
  166.    }
  167.   }

  169.    if(mode == TRIANGLE_CURRENT) {
  170.    int encoderPos = getEncoderMovement();     //encoderPos is either -1, 0 or 1
  171.    if(encoderPos != 0) {                 //Encoder changed
  172.      switch(TCCurrentParam) {
  173.      case TC_PARAM_IHI:
  174.        if(encoderPos > 0&& ISetTCIHi< ISET_TC_IMAX)  
  175.        ISetTCIHi += ISET_TC_I_STEP;
  176.        else if(encoderPos< 0&& ISetTCIHi >= ISET_SC_I_STEP&& ISetTCIHi > ISetTCILo)        
  177.        ISetTCIHi -= ISET_TC_I_STEP;  
  178.        break;
  179.      case TC_PARAM_ILO:
  180.        if(encoderPos > 0&& ISetTCILo< ISET_TC_IMAX&& ISetTCILo< ISetTCIHi)  
  181.        ISetTCILo += ISET_TC_I_STEP;
  182.        else if(encoderPos< 0&& ISetTCILo >= ISET_TC_I_STEP)        
  183.        ISetTCILo -= ISET_TC_I_STEP;  
  184.        break;
  185.      case TC_PARAM_THI:
  186.        if(encoderPos > 0&& ISetTCTHi< ISET_TC_TMAX)  
  187.        ISetTCTHi += ISET_TC_T_STEP;
  188.        else if(encoderPos< 0&& ISetTCTHi >= ISET_TC_T_STEP)        
  189.        ISetTCTHi -= ISET_TC_T_STEP;  
  190.        break;
  191.      case TC_PARAM_TLO:
  192.      if(encoderPos > 0&& ISetTCTLo< ISET_TC_TMAX)  
  193.        ISetTCTLo += ISET_TC_T_STEP;
  194.        else if(encoderPos< 0&& ISetTCTLo >= ISET_TC_T_STEP)        
  195.        ISetTCTLo -= ISET_TC_T_STEP;  
  196.        break;
  197.      }
  198.    }

  200.    lcd.setCursor(0, 1);
  201.    switch(TCCurrentParam) {
  202.      case TC_PARAM_IHI:
  203.        lcd.write("I");
  204.        lcd.write(byte(3));
  205.        lcdPrintIntWhitespace(ISetTCIHi, 4);
  206.        lcd.print(ISetTCIHi);
  207.        lcd.write("mA");
  208.        break;
  209.       
  210.      case TC_PARAM_ILO:
  211.        lcd.write("I");
  212.        lcd.write(byte(4));
  213.        lcdPrintIntWhitespace(ISetTCILo, 4);
  214.        lcd.print(ISetTCILo);
  215.        lcd.write("mA");
  216.        break;
  217.       
  218.      case TC_PARAM_THI:
  219.        lcd.write("T");
  220.        lcd.write(byte(3));
  221.        lcdPrintIntWhitespace(ISetTCTHi, 4);
  222.        lcd.print(ISetTCTHi);
  223.        lcd.write("mS");  
  224.        break;
  225.         
  226.      case TC_PARAM_TLO:
  227.        lcd.write("T");
  228.        lcd.write(byte(4));
  229.        lcdPrintIntWhitespace(ISetTCTLo, 4);
  230.        lcd.print(ISetTCTLo);
  231.        lcd.write("mS");
  232.        break;
  233.    }

  235.   
  236.   }

  238.    if(mode == SINE_CURRENT) {
  239.   int encoderPos = getEncoderMovement();       //encoderPos is either -1, 0 or 1
  240.    if(encoderPos != 0) {                 //Encoder changed
  241.      switch(SNCCurrentParam) {
  242.      case SNC_PARAM_IHI:
  243.        if(encoderPos > 0&& ISetSNCIHi< ISET_SNC_IMAX)  
  244.        ISetSNCIHi += ISET_SNC_I_STEP;
  245.        else if(encoderPos< 0&& ISetSNCIHi >= ISET_SNC_I_STEP&& ISetSNCIHi > ISetSNCILo)        
  246.        ISetSNCIHi -= ISET_SNC_I_STEP;  
  247.        break;
  248.      case SNC_PARAM_ILO:
  249.        if(encoderPos > 0&& ISetSNCILo< ISET_SNC_IMAX&& ISetSNCILo< ISetSNCIHi)  
  250.        ISetSNCILo += ISET_SNC_I_STEP;
  251.        else if(encoderPos< 0&& ISetSNCILo >= ISET_SNC_I_STEP)        
  252.        ISetSNCILo -= ISET_SNC_I_STEP;  
  253.        break;
  254.      case SNC_PARAM_T:
  255.        if(encoderPos > 0&& ISetSNCT< ISET_SNC_TMAX)  
  256.        ISetSNCT += ISET_SNC_T_STEP;
  257.        else if(encoderPos< 0&& ISetSNCT >= ISET_SNC_T_STEP)        
  258.        ISetSNCT -= ISET_SNC_T_STEP;  
  259.        break;
  260.      }
  261.    }

  263.    lcd.setCursor(0, 1);
  264.    switch(SNCCurrentParam) {
  265.      case SNC_PARAM_IHI:
  266.        lcd.write("I");
  267.        lcd.write(byte(3));
  268.        lcdPrintIntWhitespace(ISetSNCIHi, 4);
  269.        lcd.print(ISetSNCIHi);
  270.        lcd.write("mA");
  271.        break;
  272.       
  273.      case SNC_PARAM_ILO:
  274.        lcd.write("I");
  275.        lcd.write(byte(4));
  276.        lcdPrintIntWhitespace(ISetSNCILo, 4);
  277.        lcd.print(ISetSNCILo);
  278.        lcd.write("mA");
  279.        break;
  280.       
  281.      case SNC_PARAM_T:
  282.        lcd.write("T:");
  283.        lcdPrintIntWhitespace(ISetSNCT, 4);
  284.        lcd.print(ISetSNCT);
  285.        lcd.write("mS");  
  286.        break;

  288.    }

  290.   

  292.   
  293.   }



  297.   //Always update and print VLoad and ILoad
  298.   updateVLoad();
  299.   updateILoad();
  300.   printVLoadAndILoad();



  304.   //Handle Mode change button press
  305.   if(digitalRead(modeSelectorBtn) == LOW)  {
  306.    handleModeSelection();

  308.    //Prevent double triggering?
  309.    delay(400);
  310.   }


  313.   //Handle Output Enable/Disable button press
  314.   if(digitalRead(outputEnableBtn) == LOW)  {
  315.   
  316.    outputEnabled = !outputEnabled;
  317.    if(outputEnabled) {
  318.      digitalWrite(outputEnabledLed, HIGH);
  319.      enableTimer2();
  320.    } else {
  321.      digitalWrite(outputEnabledLed, LOW);
  322.      disableTimer2();
  323.      writeISet(0);
  324.    }
  325.   
  326.    //Prevent double triggering?
  327.    delay(400);
  328.   }


  331.   //Handle Encoder button press (toggle parameter change)
  332.   if(digitalRead(encBtn) == LOW)  {
  333.      if(mode == SQUARE_CURRENT) {
  334.        switch(SCCurrentParam) {
  335.          case SC_PARAM_IHI:
  336.            SCCurrentParam = SC_PARAM_ILO;  break;
  337.          case SC_PARAM_ILO:
  338.            SCCurrentParam = SC_PARAM_THI;  break;
  339.          case SC_PARAM_THI:
  340.            SCCurrentParam = SC_PARAM_TLO;  break;
  341.          case SC_PARAM_TLO:
  342.            SCCurrentParam = SC_PARAM_IHI;  break;
  343.        }
  344.      } else if(mode == TRIANGLE_CURRENT) {
  345.        switch(TCCurrentParam) {
  346.          case TC_PARAM_IHI:
  347.            TCCurrentParam = TC_PARAM_ILO;  break;
  348.          case TC_PARAM_ILO:
  349.            TCCurrentParam = TC_PARAM_THI;  break;
  350.          case TC_PARAM_THI:
  351.            TCCurrentParam = TC_PARAM_TLO;  break;
  352.          case TC_PARAM_TLO:
  353.            TCCurrentParam = TC_PARAM_IHI;  break;
  354.        }
  355.      } else if(mode == SINE_CURRENT) {
  356.        switch(SNCCurrentParam) {
  357.          case SNC_PARAM_IHI:
  358.            SNCCurrentParam = SNC_PARAM_ILO;  break;
  359.          case SNC_PARAM_ILO:
  360.            SNCCurrentParam = SNC_PARAM_T;  break;
  361.          case SNC_PARAM_T:
  362.            SNCCurrentParam = SNC_PARAM_IHI;  break;
  363.        }    
  364.      }

  366.    //Prevent double triggering?
  367.    delay(200);
  368.   }


  371. //A little delay for good luck
  372. delay(100);

  374. }

复制代码

所有资料51hei提供下载:
ElectronicLoad-master.zip(154.42 KB, 下载次数: 61)




评分

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

查看全部评分

沙发
ID:61724发表于 2020-3-10 17:06|只看该作者
谢谢分享  学习一下
板凳
ID:742301发表于 2020-5-19 00:50来自手机|只看该作者
楼主，可以教我一下嘛
地板
ID:250384发表于 2023-5-1 20:46|只看该作者
学习下，在准备DIY个电子负载。
5#
ID:138707发表于 2023-7-29 17:43|只看该作者
楼主，可以教我一下嘛

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

Powered by 单片机教程网