Простая электронная нагрузка на Arduino.

// 2021
//Электронная нагрузка by BSP. 

#include "wiring_private.h"
//================================подключение к Ардуино
#define CurrentSensePin A1
#define VoltageSensePin A2
#define MosfetDrivePin 9 //можно сменить на 10, только на эти пины настроен быстрый ШИМ
#define voltDividerPin A3
//-------------------------------------------НАСТРОЙКА---------------------------------------
#define highDivRatio 20 // 20.7; //Делитель напряжения в измерителе 1:20
#define lowDivRatio 5.025 //Делитель напряжения в измерителе 1:5
float sensorResOhm = 0.1 ;// 0.1 ом токовый шунт
word vref = 1088;//1074;//1100; Измерить данное значение у себя на Ардуино и подставить сюда ( в милливольтах).
float calibrationCurr =1;// измеренный ток будет домножаться на это значение, без необходимости лучше не трогать
int offsetCurr = 0; //25 если ток неверный всегда на одно и то же значение, подставим его сюда. 
//положительное число занижает реальный ток, отрицательное - завышает

bool csvRepStyle = true; //по умолчанию отчёт в режиме CSV
String delim = ";"; //разделитель для CSV 
int reportInterval = 2000;//интервал выдачи показаний на COM порт, мс
float calibrationVolt =1 ;//измеренное напряжение будет домножаться на это значение, без необходимости лучше не трогать
word dischMode =1; //1 для СС режима, 2 для constant power, 3 для constant resistance

//===============================Первоначальная настройка напряжения и тока
word targetCurrent = 150;// mA первоначальный ток разряда, который будет отображаться в меню
word CutOffVoltage = 900 ;//mV Первоначальное напряжение отсечки
word MinVoltThreshold = 500; //mV минимальное первоначальное напряжение, ниже которого разряд не запустится
word targetPower = 4000;
word constRes = 10000;
/////////////////////////////////////////////ПИД-Регулятор///////////////////////////////////////////////////////_____________________________________

float Kp = .1; //без причины лучше не трогать
int Kd = 1; //без причины лучше не трогать

////////////////////////////////////////////////////-----флаги МЕНЮ
byte set = 0;  
bool set2Entered =0;
bool set3Entered =0;
bool set6Entered =0;
bool set7Entered =0;
bool showMainMenu = 1;

////////////////////////// Время
unsigned long currentTime = 0;
unsigned long lastTime = 0; //для интервала репортинга
unsigned long lastMillis = 0;// храним время для интервала подсчёта емкости.
unsigned long dischStart;  //  Время начала разряда
///////////////////////////////////////////////
char valChar[6];
String valString;
float currentValueNow = 0; 
float voltageValueNow = 0; 
float powerValueNow =0;
float mah =0;
float mwh =0;
bool div5VState = false; //отслеживающая состояние делителя 1/5 --true, 1/20-- false

int error; // ошибка для ПД регулятора
int prevErr = 0; 
int dError; 

int power =0; //Это значение подаётся на транзистор через analogWrite
int prevPower =0 ; 
int powerCorrection = 0; //значение - результат вычисления PID, корректирующее ток до таргета.

///////////////////////////////////////////////
float voltageDividerRatio = highDivRatio;
void setup()
{
  analogReference (INTERNAL);
  pinMode(CurrentSensePin, INPUT);
  pinMode(VoltageSensePin, INPUT);
  pinMode(MosfetDrivePin, OUTPUT);
  max5Volt (false);
  analogWrite (MosfetDrivePin,0); 
  Serial.begin(9600); 
  //частота преобразования АЦП - делитель 32
  cbi(ADCSRA, ADPS1);  
  // Пины D9 и D10 - 2 кГц 10bit ШИМ
  TCCR1A = 0b00000011;  // 10bit
  TCCR1B = 0b00001010;  // x8 fast pwm
  }

void loop()
{
  
  if (showMainMenu==1) {    
    currentValueNow = calcCurrentNew (5) ;   
     voltageValueNow = calcVoltageNew (10);
      
    Serial.println ("---------MAIN MENU-------");
    Serial.print ("VoltageValueNow");
    Serial.print ("     ");
    Serial.println (voltageValueNow,0);
    Serial.print ("CurrentValueNow");
    Serial.print ("     ");
    Serial.println (currentValueNow,0);
    switch (dischMode) {
      case 1:
      Serial.print ("Target current (mA):");
      Serial.print ("     ");
      Serial.println (targetCurrent); 
      break;
      case 2:
      Serial.print ("Target Power (mW):");
      Serial.print ("     ");
      Serial.println (targetPower); 
      break;
      case 3:
      Serial.print ("Constant resistance (mOhm):");
      Serial.print ("     ");
      Serial.println (constRes); 
      break;
    }
    
    Serial.print ("Cut Off Voltage(mV):");
    Serial.print ("     ");
    Serial.println (CutOffVoltage);
    
    Serial.println ("     ");
    Serial.println("Press 7 to change discharge mode");
    Serial.println("Press 6 to change to CSV report style");   
    Serial.println("Press 5 to open mosfet (4debug)");   //режим отладки (приоткрываем стразистор)
    Serial.println("Press 4 to see voltage sensor readings (4debug)");   
    Serial.println("Press 3 to set Cut off voltage in mV"); 
    switch (dischMode) {
      case 1:
      Serial.println("Press 2 to set discharge current in mA");
      break;
      case 2:
      Serial.println("Press 2 to set discharge power in mW");
      break;
      case 3:
      Serial.println("Press 2 to set discharge resistance mOhm");
      break;
    }  
                       
    Serial.println("Press 1 to start");                      
    Serial.println("Press 0 to go to main menu");        //выход из режимов

showMainMenu =0;
  }

  if (Serial.available() > 0&& set==0 ) 
 
  {
  int val=Serial.read();                  //прочитать что было послано в порт
    switch(val) 
    {                           
    case 48: analogWrite(MosfetDrivePin, 0); set=0; showMainMenu = 1; break;    //если приняли 0 остановить разряд, выбрать 0 режим и открыть менюшку
    case 49: set=1; break;                //если приняли 1 то запустить режим 1
    case 50: set=2; break;                //если приняли 2 то запустить режим 2
    case 51: set=3; break;                //если приняли 3 то запустить режим 3
    case 52: set =4; break; ////если приняли 4 то запустить режим 3
    case 53: set =5; break;
    case 54: set =6; break;
    case 55: set =7; break;
    }
  }
/////////////////////////////////////////////////////////////////////////////////////////START STOP
  if (set ==1) 
  {
  currentValueNow = calcCurrentNew (5) ;
     voltageValueNow = calcVoltageNew (20);

     if (voltageValueNow <= MinVoltThreshold)
     {
      Serial.print ("No discharge -- Voltage is lower than threshold ");
      Serial.print (MinVoltThreshold);
      Serial.print (" ");
      Serial.println ("mV");
      set = 0;
      showMainMenu =1;
     }
     else 
     {
  Serial.println ("Starting discharge..     ");
  Serial.println (F("time;Current, mA;Voltage,mV;mAh;mwh;mW"));
  int calc = 0;
  mah = 0;
  mwh =0;
  dischStart = millis ();

  if (dischMode ==1 )
    {
    
  
  while ( set ==1 && voltageValueNow > CutOffVoltage)
      {      
     currentValueNow = calcCurrentNew (5) ;//5
     voltageValueNow = calcVoltageNew (5);//3

    if (millis() - lastTime  >  reportInterval ) ///show current readings every interval without stopping PID
    {
      if (csvRepStyle ==true)
      {
        
    mah+= currentValueNow * (millis()-lastTime)/3600000;
    mwh+= (currentValueNow * (millis()-lastTime)/3600000)*voltageValueNow/1000.00;
    
        
    Serial.print((millis() - dischStart) / 1000);
    Serial.print (delim);
    Serial.print (currentValueNow,0);
    Serial.print (delim);
    Serial.print (voltageValueNow,0);
    Serial.print (delim);
    Serial.print (mah);  
    Serial.print (delim);
    Serial.println (mwh);
        
    
    calc = 0;
    lastTime = millis ();
        }
      else 
      {
    Serial.print ("Сurrent:");
    Serial.print (currentValueNow,0);
    Serial.println (" mA");
    Serial.print ("Voltage:");
    Serial.print (voltageValueNow,0);
    Serial.println (" mV");
    mah+= currentValueNow * (millis()-lastTime)/3600000;
    mwh+= (currentValueNow * (millis()-lastTime)/3600000)*voltageValueNow/1000;
    Serial.print ("mah:");
    Serial.println (mah);
    Serial.print ("mwh:");
    Serial.println (mwh);
    
    Serial.print ("Mosfet Power:");
    Serial.println (power);
    Serial.print ("Calcs/interval:");
    Serial.println (calc);
    calc = 0;
    lastTime = millis ();
      }
    }


    error = targetCurrent - currentValueNow; // current error
   dError = error - prevErr;
          
    powerCorrection = error * Kp + dError * Kd ;
     
  if (powerCorrection > 1023) //добавлено как защита от переполнения
    {
      powerCorrection = 1023;//добавлено как защита от переполнения
    }

     if (powerCorrection < -1023)//добавлено как защита от переполнения
    {
      powerCorrection = -1023;//добавлено как защита от переполнения
    }

     power = prevPower  + powerCorrection; // Корректируем текущее значение ШИМ, в зависимости от того, выше таргета ток, или ниже.
    
     if (power > 1023)
    {
      power = 1023;
    }

     if (power < 0)
    {
      power = 0;
    }
    if (power ==255) // мы поправили таймер и он стал  10 битным, однако в ф-ции analogWrite прописано что еслии 255 то digitalWrite 1. 
    //с 10-битным таймером это неверно.
    {
      power = 254;
    }
analogWrite(MosfetDrivePin, power);
  prevPower = power; // Корректируем текущее значение ШИМ, в зависимости от того, выше таргета ток, или ниже.
    
    prevErr = error; 
    
    if (Serial.available() > 0 ) //прерываемся и выходим по нажатию 0
      {
        int val2=Serial.read();
      
        if (val2 ==48) {analogWrite(MosfetDrivePin, 0); set = 0; showMainMenu =1;}
        Serial.println ("Discharge interrupted by user ");
        }
    calc++;
  
    }
  } 
//end dischMode==1
    else if (dischMode ==2 )
    {
      while ( set ==1 && voltageValueNow > CutOffVoltage)
      {      
     currentValueNow = calcCurrentNew (5) ;//5
     voltageValueNow = calcVoltageNew (5);//3
     powerValueNow = currentValueNow * voltageValueNow/1000.00;

    if (millis() - lastTime  >  reportInterval ) ///show current readings every interval without stopping PID
    {
      if (csvRepStyle ==true)
      {
        
    mah+= currentValueNow * (millis()-lastTime)/3600000;
    mwh+= (currentValueNow * (millis()-lastTime)/3600000)*voltageValueNow/1000.00;
    
        
    Serial.print((millis() - dischStart) / 1000);
    Serial.print (delim);
    Serial.print (currentValueNow,0);
    Serial.print (delim);
    Serial.print (voltageValueNow,0);
    Serial.print (delim);
    Serial.print (mah);  
    Serial.print (delim);
    Serial.print (mwh);
    Serial.print (delim);
    Serial.println (powerValueNow);
               
    calc = 0;
    lastTime = millis ();
        }
      else 
      {
    Serial.print ("Сurrent:");
    Serial.print (currentValueNow,0);
    Serial.println (" mA");
    Serial.print ("Voltage:");
    Serial.print (voltageValueNow,0);
    Serial.println (" mV");
    mah+= currentValueNow * (millis()-lastTime)/3600000;
    mwh+= (currentValueNow * (millis()-lastTime)/3600000)*voltageValueNow/1000;    
Serial.print ("mah:");
    Serial.println (mah);
    Serial.print ("mwh:");
    Serial.println (mwh);
    Serial.print ("Power,mW:");
    Serial.println (powerValueNow);
    Serial.print ("Mosfet Power:");
    Serial.println (power);
    Serial.print ("Calcs/interval:");
    Serial.println (calc);
    calc = 0;
    lastTime = millis ();
      }
    }

    targetCurrent = targetPower*1000.00/voltageValueNow;

    error = targetCurrent - currentValueNow; // current error
   dError = error - prevErr;
          
    powerCorrection = error * Kp + dError * Kd ;
     
  if (powerCorrection > 1023) //добавлено как защита от переполнения
    {
      powerCorrection = 1023;//добавлено как защита от переполнения
    }

     if (powerCorrection < -1023)//добавлено как защита от переполнения
    {
      powerCorrection = -1023;//добавлено как защита от переполнения
    }

     power = prevPower  + powerCorrection; // Корректируем текущее значение ШИМ, в зависимости от того, выше таргета ток, или ниже.
    
     if (power > 1023)
    {
      power = 1023;
    }

     if (power < 0)
    {
      power = 0;
    }
    if (power ==255) // мы поправили таймер и он стал  10 битным, однако в ф-ции analogWrite прописано что еслии 255 то digitalWrite 1. 
    //с 10-битным таймером это неверно.
    {
      power = 254;
    }
analogWrite(MosfetDrivePin, power);
  prevPower = power; // Корректируем текущее значение ШИМ, в зависимости от того, выше таргета ток, или ниже.
    
    prevErr = error; 
    
    if (Serial.available() > 0 ) //прерываемся и выходим по нажатию 0
      {
        int val2=Serial.read();
      
        if (val2 ==48) {analogWrite(MosfetDrivePin, 0); set = 0; showMainMenu =1;}
        Serial.println ("Discharge interrupted by user ");
        }
    calc++;
  
    }  
      
    }//end dischMode==2
    else if (dischMode ==3 )
    {
      while ( set ==1 && voltageValueNow > CutOffVoltage)
      {      
     currentValueNow = calcCurrentNew (5) ;//5
     voltageValueNow = calcVoltageNew (5);//3
     powerValueNow = currentValueNow * voltageValueNow/1000.00;

    if (millis() - lastTime  >  reportInterval ) ///show current readings every interval without stopping PID
    {
      if (csvRepStyle ==true)
      {
        
    mah+= currentValueNow * (millis()-lastTime)/3600000;
    mwh+= (currentValueNow * (millis()-lastTime)/3600000)*voltageValueNow/1000.00;
    
        
    Serial.print((millis() - dischStart) / 1000);
    Serial.print (delim);
    Serial.print (currentValueNow,0);
    Serial.print (delim);
    Serial.print (voltageValueNow,0);
    Serial.print (delim);
    Serial.print (mah);  
    Serial.print (delim);
    Serial.print (mwh);
    Serial.print (delim);
    Serial.println (powerValueNow);
    
       
    
    calc = 0;
    lastTime = millis ();
        }
      else 
      {
    Serial.print ("Сurrent:");
    Serial.print (currentValueNow,0);
    Serial.println (" mA");
    Serial.print ("Voltage:");
    Serial.print (voltageValueNow,0);
    Serial.println (" mV");
    mah+= currentValueNow * (millis()-lastTime)/3600000;
    mwh+= (currentValueNow * (millis()-lastTime)/3600000)*voltageValueNow/1000;
    Serial.print ("mah:");
    Serial.println (mah);
    Serial.print ("mwh:");
    Serial.println (mwh);
    
    Serial.print ("Mosfet Power:");
    Serial.println (power);
    Serial.print ("Calcs/interval:");
    Serial.println (calc);
    calc = 0;
    lastTime = millis ();
      }
    }

    targetCurrent = voltageValueNow*1000.00/constRes;

    error = targetCurrent - currentValueNow; // current error
   dError = error - prevErr;
          
    powerCorrection = error * Kp + dError * Kd ;
     
  if (powerCorrection > 1023) //добавлено как защита от переполнения
    {
      powerCorrection = 1023;//добавлено как защита от переполнения
    }

     if (powerCorrection < -1023)//добавлено как защита от переполнения
    {
      powerCorrection = -1023;//добавлено как защита от переполнения
    }

     power = prevPower  + powerCorrection; // Корректируем текущее значение ШИМ, в зависимости от того, выше таргета ток, или ниже.
    
     if (power > 1023)
    {
      power = 1023;
    }

     if (power < 0)
    {
      power = 0;
    }
    if (power ==255) // мы поправили таймер и он стал  10 битным, однако в ф-ции analogWrite прописано что еслии 255 то digitalWrite 1. 
    //с 10-битным таймером это неверно.
    {
      power = 254;
    }
analogWrite(MosfetDrivePin, power);
  prevPower = power; // Корректируем текущее значение ШИМ, в зависимости от того, выше таргета ток, или ниже.
    
    prevErr = error; 
    
    if (Serial.available() > 0 ) //прерываемся и выходим по нажатию 0
      {
        int val2=Serial.read();
      
        if (val2 ==48) {analogWrite(MosfetDrivePin, 0); set = 0; showMainMenu =1;}
        Serial.println ("Discharge interrupted by user ");
        }
    calc++;
  
    }  
      
    }
    
    analogWrite(MosfetDrivePin, 0);
    delay (100);
   Serial.println ("Discharge completed ");
   set = 0;
}
}
//////////////////////////////////////////////////////ПУНКТ2//////////////////////////////////////////////
if (set ==2) //set discharge current in mA
  {
    if (set2Entered ==0) 
    {
      switch (dischMode) {
      case 1:
      Serial.print ("Enter discharge current, mA ");
      Serial.println ("Press 0 to exit to main menu");
      break;
      case 2:
      Serial.print ("Enter discharge power, mW ");
      Serial.println ("Press 0 to exit to main menu");
      break;
      case 3:
      Serial.print ("Enter discharge resistance,mOhm ");
      Serial.println ("Press 0 to exit to main menu");
      break;
    }  
    
    set2Entered =1;
    }
    if (Serial.available() > 0 ) 
      {
        valString = Serial.readStringUntil('\n'); //прочитать всё
       
      int val;
      Serial.println(valString);
      valString.toCharArray(valChar,sizeof(valChar));
      val = atof(valChar);
      valString = "";
       if (val ==0)
        {
        set2Entered =0;
        set = 0;
        showMainMenu =1;
        }
       else {
            switch (dischMode) {
              case 1:
              targetCurrent = val;
              Serial.print ("Target current is set to ");
              Serial.print (targetCurrent);
              Serial.println ("mA");
              break;
              case 2:
              targetPower = val;
              Serial.print ("Target power is set to ");
              Serial.print (targetPower);
              Serial.println ("mW");
              break;
              case 3:
              constRes = val;
              Serial.print ("Constant resistance is set to ");
              Serial.print (constRes);
              Serial.println ("mOmh");
              break; }              
            }
       
       set = 0;
       set2Entered =0;      
       showMainMenu =1;
      }
  }
  
////////////////////////////////////////////////////////////////////////////////////////////////
if (set ==3) //set Cut off voltage in mV
  {
  
      if (set3Entered ==0) 
    {
    Serial.println ("Enter cut-off voltage. Press 0 to exit to main menu");
    set3Entered =1;
    }
    if (Serial.available() > 0 ) 
      {
        valString = Serial.readStringUntil('\n'); //прочитать всё
      
      int val;
      Serial.println(valString);
      valString.toCharArray(valChar,sizeof(valChar));
      val = atof(valChar);
      valString = "";
       if (val ==0)
        {
        set = 0;
        set3Entered =0;
        showMainMenu =1;
        }
       else {CutOffVoltage = val;}
       Serial.print ("Cut-off voltage is set to ");
       Serial.print (CutOffVoltage);
       Serial.println ("mV");
       set = 0;
       set3Entered =0;      
       showMainMenu =1;
      }
  
  }

  
if (set==4)
  {

  while (set==4) 
    {
  
  currentValueNow = calcCurrentNew(3) ;
     voltageValueNow = calcVoltageNew(3);
     
    Serial.print ("Voltage:");
    Serial.print (voltageValueNow);
    Serial.println (" mV");
    Serial.print ("Raw value from DAC ");
    Serial.println (calcVoltageNewDAC (3));
    delay (500);
    if (Serial.available() > 0 ) //прерываемся и выходим по нажатию 0
      {
        int val2=Serial.read();
      
        if (val2 ==48) {analogWrite(MosfetDrivePin, 0);set = 0; showMainMenu =1;}
    
      }
    }
  }

if (set ==5) 
  {
    
    
  while (set==5) 
    {
  analogWrite(MosfetDrivePin, 750);//90ma at 750 @4V
  currentValueNow = calcCurrentNew(5) ;
     voltageValueNow = calcVoltageNew(5);
     Serial.print ("Сurrent:");
    Serial.print (currentValueNow);
    Serial.println (" mA");
    Serial.print ("Voltage:");
    Serial.print (voltageValueNow);
    Serial.println (" mV");
    delay (500);
    if (Serial.available() > 0 ) //прерываемся и выходим по нажатию 0
      {
        int val2=Serial.read();
      
        if (val2 ==48) {analogWrite(MosfetDrivePin, 0); delay (100);set = 0; showMainMenu =1;}
    
      }
    }
  }


if (set ==6) 
 {
 if (set6Entered ==0) 
    {
    Serial.println ("Set Report Style. Press 2 for csv style, 1 for normal style.");
    Serial.println ("Press 0 to exit to main menu");
    set6Entered =1;
    }
    if (Serial.available() > 0 ) 
      {
        valString = Serial.readStringUntil('\n'); //прочитать всё
       
      int val;
      Serial.println(valString);
      valString.toCharArray(valChar,sizeof(valChar));
      val = atof(valChar);
      valString = "";
       if (val ==0)
        {
        set = 0;
        set6Entered =0;
        showMainMenu =1;
        }
       if (val ==1) 
        {
        csvRepStyle = false;
        Serial.println ("Report style was set to normal");
        set = 0;
       set6Entered =0;      
       showMainMenu =1;
        }
       else if (val ==2) 
        {
        csvRepStyle = true;
        Serial.println ("Report style was set to CSV");
        set = 0;
       set6Entered =0;      
       showMainMenu =1;
        }
        else
        {
       Serial.println ("Wrong choice.");   
      
       set6Entered =0;
        }
        }
       
      }

  if (set ==7) //set discharge current in mA
  {
    if (set7Entered ==0) 
    {
    Serial.println ("Enter discharge mode. 1 for CC ,2 for constant Power, 3 for constant Resistance");
    Serial.println ("Press 0 to exit to main menu");
    set7Entered =1;
    }
    if (Serial.available() > 0 ) 
      {
        valString = Serial.readStringUntil('\n'); //прочитать всё
       
      int val;
      Serial.println(valString);
      valString.toCharArray(valChar,sizeof(valChar));
      val = atof(valChar);
      valString = "";
       switch (val){
        case 0:               
          set7Entered =0;
          set = 0;
          showMainMenu =1;
          break;
       case 1:      
        dischMode = val;
        Serial.print ("Discharge mode is set to ");
        Serial.println (dischMode);    
        set = 0;
        set7Entered =0;      
        showMainMenu =1;
        break;
       case 2:
        dischMode = val;
        Serial.print ("Discharge mode is set to ");
        Serial.println (dischMode);    
        set = 0;
        set7Entered =0;      
        showMainMenu =1;
        break;
        case 3:
        dischMode = val;
        Serial.print ("Discharge mode is set to ");
        Serial.println (dischMode);    
        set = 0;
        set7Entered =0;      
        showMainMenu =1;
        break;
        default:
        Serial.println ("Wrong choice.");
        set7Entered =0;
       }
      }
  }
  

         
 }


int calcVoltageNew (int iternum)
{
  int Max =0;
  int Min = 20000;
  int volt_m[iternum-1];
  float volt = 0;
  for (int i = 0;i<iternum;i++)
    {
    volt_m[i]= analogRead(VoltageSensePin);
    if (volt_m[i] >Max) {Max = volt_m[i]; }
    if (volt_m[i] <Min) {Min = volt_m[i]; }
    delay (1);
    volt+= volt_m[i];
    }
    volt = volt - Min;
    volt = volt - Max;
    //1.Если напряжение ниже (250/1023)*vref, и делитель 1:20, включаем повышенную точность (делитель 1:5) со следующей итерации.
    if (div5VState == false && volt<(250 * (iternum-2)))
      {
      volt = volt * vref *calibrationVolt;
       volt = volt/1024;
        volt = volt * voltageDividerRatio ;//mV
        volt = volt/(iternum-2);

      max5Volt(true);
        return volt;
      }
       //2.Если напряжение выше (1022/1023)*vref, и делитель 1:5, включаем делитель 1:20 со следующей итерации.
      if (div5VState == true && volt>=(1022 * (iternum-2)))
      {
      volt = volt * vref *calibrationVolt;
       volt = volt/1024;
        volt = volt * voltageDividerRatio ;//mV
        volt = volt/(iternum-2);
  max5Volt(false);
        return volt;
  
      }
      volt = volt * vref *calibrationVolt;
       volt = volt/1024;
        volt = volt * voltageDividerRatio ;//mV
        volt = volt/(iternum-2);
    return volt;
}

 int calcCurrentNew (int iternum)
{
  word Max =0;
  word Min = 20000;
  int volt_m[iternum-1];
  float curr = 0;
  for (int i = 0;i<iternum;i++)
    {
    volt_m[i]= analogRead(CurrentSensePin);
    if (volt_m[i] >Max) {Max = volt_m[i]; }
    if (volt_m[i] <Min) {Min = volt_m[i]; }
    delay (1);
    curr+= volt_m[i];
    }
    curr = curr - Min;
    curr = curr - Max;
        
  curr = curr * vref * calibrationCurr;
  curr = curr / 1024;
  curr = curr/ sensorResOhm ;//mA
  curr = curr/(iternum-2);
  curr=curr+offsetCurr;//ацп ошибается на это значение вне зависимости от тока, корректируем смещение
  return curr;
  
 }

 int calcVoltageNewDAC (int iternum)
{
  int Max =0;
  int Min = 20000;
  int volt_m[iternum-1];
  float volt = 0;
  for (int i = 0;i<iternum;i++)
    {
    volt_m[i]= analogRead(VoltageSensePin);
    if (volt_m[i] >Max) {Max = volt_m[i]; }
    if (volt_m[i] <Min) {Min = volt_m[i]; }
    delay (1);
    volt+= volt_m[i];
    }
    volt = volt - Min;
    volt = volt - Max;    
    volt = volt/(iternum-2);
  
  return volt;
 }

void max5Volt (bool state)
 {
  if (state == true)
  {
pinMode (voltDividerPin,INPUT);
voltageDividerRatio = lowDivRatio;
div5VState = true;
}
if (state ==false )
{
  pinMode (voltDividerPin,OUTPUT);
  digitalWrite (voltDividerPin,0);
  voltageDividerRatio = highDivRatio;
  div5VState = false;
  }
  }