Регуляторы мощности для ТЭНов (Страница 70 из 87)

#include <EEPROM.h>

#define PinGnd 13 //  будем использвать как GND, так было удобно припаять потенциометр
#define PinPlus 12 // будем использвать как VCC, так было удобно припаять потенциометр
#define PinPoten 14 // аналоговый вход для опроса потенциометра
#define PinImpuls 10 //  для подачи управляющего импульса на оптопару
#define PinSignal 15 // аналоговый вход для измерения напряжения в сети
#define PinReg 9 // для опроса тумблера перехода в режим установки
#define PinGnd1 8 //  будем использвать как GND, так было удобно припаять тумблер

const int regInterval  = 100; // интервал регулирования Берзенхема от 0 с шагом 1 (в нашем случае 0 - 100  это период 1 секунда)
int regValue = 0; // количество включенных преиодов в интервале, в нашем случае это напряжение,%  задается опреторм
int regError;// служебная переменная алгоритма Берзенхема, при изменении количества включений (regValue) устанавливается как 1/2 интервала regInterval

int startRegValue; // количество включенных преиодов в интервале, которое храниться в памяти, записывается при каждом изменении


bool flagBresenham = false; // решение алгоритма Берзенхема о включении/не выключении имульса
bool flagAskBresenham = false; // флаг момента необходимости принимать решение по алгоритму Берзенхема 
bool flagCycle = false; // флаг, указывает, что напряжение в рамках полуцикла падает (максимум пройден) 

int volt; // мгновенное значение измеренного напряжения 
int volt_0; // три измеренных подряд мгновенных значений  напряжения
int volt_1;
int volt_2;
int currentMaxVolt;// текущее амплитудное напряжение 
int oldMaxVolt; // амплитудное напряжение, в соответствии с которым проводилась последняя стабилизация 
int startMaxVolt; // амплитудное напряжение, для которого был выставлен параметр regValue, записывается в память после каждой переустановки 
int maxVolt; // текущее амплитудное значение измеренного за заданный период напряжения 
int const periodVoltMax =2000;// задаем период, мС определения максимума (амплитуда) напряжения 
int const devMaxVolt = 5; // допустимое отклонение амплитудного напряжения (условные единицы), при котором не нужна стабилизация

int adress = 0; // условный адрес энергонезависимой паммяти в который записывается первый байт первого значения
const int resistLoad = 15; //  сопротивление ТЭНа, Ом

float power = 0.; // мощность на выходе в Вт
float powerPercent = 0.;  // мощность на выходе в %

float const kfVoltage = 0.24 ;// константа для пересчета напряжения в Вольты, подбирается опытным путем
float voltage; // напряжение пересчитанное в в Вольты
unsigned long int oldTime; // служебная переменная для осчета времени периода измерений амплитуды

void setup() {

  Serial.begin(9600); 

  pinMode(PinGnd, OUTPUT);
  pinMode(PinGnd1, OUTPUT); 
  pinMode(PinPlus, OUTPUT);
  pinMode(PinImpuls, OUTPUT);
  pinMode(PinReg, INPUT_PULLUP);// включаем подтягивающий резистор

 
  // "допролнительные" GND и VCC
  digitalWrite(PinGnd ,LOW);
  digitalWrite(PinGnd1 ,LOW);
  digitalWrite(PinPlus ,HIGH);
  
  digitalWrite(PinImpuls,LOW); // выключаем управляющий импульс

  
 
 

 
  readMem(); //  читаем из памяти startRegValue  и startMaxVolt
  regValue = startRegValue;
  regError = regValue/2;
 
 
 // оределяем амплитудное напряжение - максимуи за период periodVoltMax, заполняем значение переменных

 oldTime = millis();
 
 while (  (millis () - oldTime) < periodVoltMax) {
 volt  = analogRead (PinSignal);
 volt_0 = volt_1;
 volt_1 = volt_2;
 volt_2 = volt;
 if (volt > maxVolt) maxVolt = volt;
 }
 
 currentMaxVolt = maxVolt; 
 oldMaxVolt = startMaxVolt;
 maxVolt = 0;
 oldTime = millis();
  
// отладка
  Serial.println(startRegValue);  
  Serial.println(startMaxVolt);  
 
 powerPercent =   100.* (  (float)regValue/(float)regInterval) * (  (float)regValue/(float)regInterval);  
 power =    ((float)currentMaxVolt * (float)regValue/(float) regInterval * kfVoltage) * ((float)currentMaxVolt * (float)regValue/(float)regInterval * kfVoltage) / resistLoad;
 
 voltage = currentMaxVolt * kfVoltage;
 // отладка
 Serial.print( "Voltage =  "); Serial.println(voltage); 
 Serial.print( "regValue =  "); Serial.println(regValue); 
 Serial.print( "powerPercent =  "); Serial.println(powerPercent);  
 Serial.print( "power =  "); Serial.println(power);  

}
void loop() {


//опрашиваем тумблер режима установки,если тумблер включен, все бросаем и "крутимся" внутри функции askPotentiometer()
// пока тумблер не будет выключен

askPotentiometer();

// если тумблер не включен
//постоянно измеряем напряжение и храним в переменных три последних величины
//будем использовать для определения: растет или падает напряжение в рамках полуцикла синусоиды
volt  = analogRead (PinSignal);
volt_0 = volt_1;
volt_1 = volt_2;
volt_2 = volt;
//

if (volt > maxVolt) maxVolt = volt; //определяем максимум = амплитудное значение 

// фиксируем максимум = амплитудное значение за periodVoltMax
if (  (millis () - oldTime) > periodVoltMax) {
oldTime = millis();
currentMaxVolt = maxVolt; 
maxVolt = 0;
stub(); // функция стабилизации
if ( currentMaxVolt < 100) Serial.println( "ERR 01  "); // отладка
}

if (  flagCycle & (volt_0 > volt_1) & (volt_1 > volt_2)) {// если напряжение падает и это впервые за полцикла (flagCycle == true) нужно спрашивать Брезенхема 
flagAskBresenham = true;
flagCycle = false; // потом изменим флаг, когда напряжение будет расти
}
if ( (!flagCycle) & ((volt_0 < volt_1) & (volt_1 < volt_2) )) {// если напряжение растет и это впервые за полцикла, нужно  объявить начало нового цикла - flagCycle = true;

flagCycle = true; // потом изменим флаг, когда напряжение будет падать
}
if (flagAskBresenham) {
Bresenham();

if (!flagBresenham){
digitalWrite(PinImpuls,LOW);

}
else {
digitalWrite(PinImpuls,HIGH);

}
flagAskBresenham = false;  // флаг будет изменен когда напряжение будет падать первый раз за полуцикл
}
 // отладка digitalWrite(PinImpuls,HIGH);
}


void Bresenham(){
// Serial.println(imp);
regError = regError - regValue;
if (regError < 0) {
regError = regError + regInterval; 
flagBresenham = true; // импульс включаетcя 
}
else {
flagBresenham = false; //  импульс выключается 
} 
}


void askPotentiometer(){
// крайние точки показаний конкретного плохого потенциометра (у правильного должноо быть 0 - 1023)
int const minPoten = 2 ;
int const maxPoten = 1020;
if ( digitalRead(PinReg)) return; // если тумблер установки не включен, возврашаемся
else  {         //если тумблер установки  включен:
digitalWrite(PinImpuls,LOW); // во-первых  выключаем управляющий импульс
Serial.println("Poten!"); // отладка
while ( !digitalRead(PinReg)) { // если тумблер включен крутимся здесь пока тумблер не будет выключен 
int potValue = analogRead (PinPoten); 
regValue = map(potValue, minPoten, maxPoten, 0, regInterval);
// на всякий случай ограничиваем возможные значения regValue
if (regValue > regInterval) regValue = regInterval;
if (regValue < 0) regValue = 0;
regError = regValue/2;
Serial.print("regValue= "); Serial.println(regValue); // отладка
//Serial.println(potValue); // отладка
powerPercent =   100.* (  (float)regValue/(float)regInterval) * (  (float)regValue/(float)regInterval);  
power =   ((float)currentMaxVolt * (float)regValue/(float) regInterval * kfVoltage) * ((float)currentMaxVolt * (float)regValue/(float)regInterval * kfVoltage) / resistLoad;
voltage = currentMaxVolt * kfVoltage;
Serial.print("powerPercent =  "); Serial.print(powerPercent); Serial.println(" %");
Serial.print("Voltage Stub =  "); Serial.print(roundf (220. *(float)regValue/(float)regInterval )); Serial.println(" V");
Serial.print("Power =  "); Serial.print(roundf (power)); Serial.println(" W");
delay (500);

}
}
// тумблер выключили  - пишем в память новые параметры.
startRegValue = regValue;
startMaxVolt = currentMaxVolt;
writeMem();

Serial.println("WRITE !!!!!!!!!!"); // отладка


Serial.println(startRegValue); // отладка
Serial.println(startMaxVolt); // отладка
}


 void writeMem(){   // пишем в память два целочисленных параметра
  Serial.println("write to ROM"); 
  byte lowByte = ((startRegValue >> 0) & 0xFF);
  byte highByte = ((startRegValue >> 8) & 0xFF);
  EEPROM.write(adress, lowByte);
  EEPROM.write(adress + 1, highByte);
  lowByte = ((startMaxVolt >> 0) & 0xFF);
  highByte = ((startMaxVolt >> 8) & 0xFF);
  EEPROM.write(adress + 2, lowByte);
  EEPROM.write(adress + 3, highByte);
  }
void readMem(){     // читаем из памяти два целочисленных параметра
  byte lowByte = EEPROM.read(adress);
  byte highByte = EEPROM.read(adress + 1);
  startRegValue = ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00);
  lowByte = EEPROM.read(adress +2);
  highByte = EEPROM.read(adress + 3);
  startMaxVolt = ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00);
}


void stub(){
// функция сравнивает текущее амплитудное напряжение currentMaxVolt с предыдущим текущим амплитудным oldMaxVolt, 
//которое запомнили в момент последней стабилизации 
//если разница меньше заданной ранее константы devMaxVolt, ничего не делаем
//если разница больше заданной ранее константы devMaxVolt, нужно пересчитать параметр алгоритма Брезенхема  regValue
// изменение параметра приведет к пропорциональному изменению мощности, например напряжение упало в два раза,
// значит мощность упала в 4 раза - увеличиваем параметр regValue в два раза и мощность увеличивается в 4 раза.
 
 if (  (  (currentMaxVolt > (oldMaxVolt + devMaxVolt))|(currentMaxVolt < (oldMaxVolt - devMaxVolt))) ){
 regValue  = roundf ( ((float) startRegValue * ( (float) startMaxVolt/ (float) currentMaxVolt)));
 
//если нет достаточного запаса - просто включаем на максимум
 if ( regValue > regInterval) regValue = regInterval; 
 regError = regValue/2;
 
oldMaxVolt = currentMaxVolt;
  }
 power =   ((float)currentMaxVolt * (float)regValue/(float) regInterval * kfVoltage) * ((float)currentMaxVolt * (float)regValue/(float)regInterval * kfVoltage) / resistLoad;
 voltage = currentMaxVolt * kfVoltage;
 
 //Serial.print(roundf (voltage)); Serial.print("  "); Serial.print(  roundf( regValue*voltage   / regInterval ));
 //Serial.print(" "); Serial.println(power);  
 }