Управление сушильной машиной

CLF · 25.Июль.2023 17:19:46

Доброго дня, полетели мозги на мой сушилке, хочу оставить силовую часть а мозги сделать на ардуино(не знаю надо ли описывать что там были pic16, stm8s и ESP32). Выбираю пока в сторону Ардуино т.к. силовая устроена по TTL 5 вольт (кроме esp32, у него уровневый преобразователь распаян). Нашел готовый скетч (конечно без вифи модуля), но с нагревом воздух с помощью тэнов, у меня используется компрессор для нагрева/охлаждения воздуха.
Вот скаченный скетч

// E-01   датчик температуры белья за пределами допустимого 
// E-02   температура тэнов выше 100 градусев
// E-03   температура в сушке выше 90 градусев

#include <EEPROM.h>
#include <TM1637.h>
#define CLK 3  // пины дисплея
#define DIO 2  // пины дисплея
TM1637 tm1637(CLK, DIO);

int temperatura=60;
int timeHour=2;
int timeMin=30;


int tb;
bool start=0;                 //0-стоп, 1-старт
int cod=0;
int t,tx;
byte i1,i2,hi,low;
int i=0;
long mst=0;
bool flagS=0;
bool flagVP=0;
bool flagVM=0;
bool flagT=0;
bool doo=0;
byte disp=0;
bool pinled=0;
int8_t Digits[] = {0x00,0x00,0x00,0x00};
long ms=0;
long msc=0;
long mso=0;
long msled=0;
long ml,ml2;
long reservuar=0;           // для периодичности включения сливной помпы
long reservuarwork=0;       // для времени работы сливной помпы
bool pinpump=0;
bool nagatieT=0;
long pausa;


#define motor 4               //   мотор
#define lampa 5               //   лампа
#define ten1  6               //   тэн 1 (мощный)
#define ten2  7               //   тэн 2 (слабый)
#define sliv 8                //   помпа
#define  rele 9               //   общее реле
#define bus 10                //   Динамик
#define  led  11              //  Светодиод СТАРТ/ПАУЗА/СТОП 

#define  ntc A0              //  вход ntc
#define  ntc2 A1             //  датчик на тэнах

#define  door A2             //  концевик двери
#define b_time_plus A3       //   Кнопка время +
#define b_time_minus A4      //   Кнопка время -
#define pusk A5              //   Кнопка СТАРТ/ПАУЗА/СТОП

#define  b_temp 12          //  кнопка установки температуры







void setup() {
 // Serial.begin(9600);
     pinMode(motor, OUTPUT);
     pinMode(lampa, OUTPUT);
     pinMode(ten1, OUTPUT);
     pinMode(ten2, OUTPUT);
     pinMode(bus, OUTPUT);
     pinMode(sliv, OUTPUT);
     pinMode(led, OUTPUT);
     pinMode(rele, OUTPUT);
      
     pinMode(ntc, INPUT);
     pinMode(ntc2, INPUT);                  
     pinMode(b_time_plus, INPUT);
     pinMode(b_time_minus, INPUT);
     pinMode(b_temp, INPUT);
     pinMode(pusk, INPUT);
     pinMode(door, INPUT); 



 //-------------температура-------------------------------
 i1 = EEPROM.read(1);
 i2 = EEPROM.read(2);
 i=word(i1, i2);
 if (i>100 || i<40) {
  temperatura=60;
  
  hi = highByte(temperatura); 
  low = lowByte(temperatura); 
  EEPROM.write(1, hi);  
  EEPROM.write(2, low);
  } 
   else temperatura=i;


//--------------время час--------------------------------   
 i1 = EEPROM.read(3);
 i2 = EEPROM.read(4);
 i=word(i1, i2);
 if (i>100 || i<0) {
  timeHour=2;
  
  hi = highByte(timeHour); 
  low = lowByte(timeHour); 
  EEPROM.write(3, hi);  
  EEPROM.write(4, low);
  } 
   else timeHour=i;

//--------------время мин--------------------------------   
 i1 = EEPROM.read(5);
 i2 = EEPROM.read(6);
 i=word(i1, i2);
 if (i>100 || i<0) {
  timeMin=30;
  
  hi = highByte(timeMin); 
  low = lowByte(timeMin); 
  EEPROM.write(5, hi);  
  EEPROM.write(6, low);
  } 
   else timeMin=i;
       

     
tm1637.clear();
tm1637.brightness(1);
tm1637.point(1);
tm1637.displayClockTwist(timeHour, timeMin,50);  
                                      tone (bus, 3000);
                                      delay(50);
                                      noTone(bus);
                                      tone (bus, 4500);
                                      delay(50);
                                      noTone(bus); 



reservuar=millis();
reservuarwork=millis();
pinpump=1;

}


void loop() {

 
//-----------опрос датчика температуры  один раз в 2 секунды---------------
  
   if (millis()-mst>2000){
      
         tx=analogRead(ntc);
         t=datchik(tx);
         tb=analogRead(ntc2);
         
         cod=0;
         
         if (tx > 1000 || tx < 15) cod=1;
         if (tb > 800) cod=2;
         if (t > 89) cod=3;
         
         
   if (cod>0) {
    stoptens();
    start=0;
    disp=6;
    otobragenie();
    digitalWrite(motor,0);
    
    
    }  
  //  Serial.println(t);
   // Serial.println(disp);
    //Serial.println(timeHour);
   // Serial.println(timeMin);         
      mst=millis();
  }
//----------------------------------------------------------------------------





//-----опорожняем резервуар каждые 30 минут, включая помпу на 30секунд-------------

if (millis()-reservuar>1800000) {
  pinpump=1;reservuar=millis();reservuarwork=millis();
  }

if (pinpump==1 && millis()-reservuarwork<30000) digitalWrite(sliv,pinpump);
if (millis()-reservuarwork>30000) {pinpump=0;digitalWrite(sliv,pinpump);}

//----------------------------------------------------------------------------------------





//-----------------------дверь------------------------------------------------------------
if (digitalRead(door)==0 && doo==1) {doo=0;ml2=millis();}
if (digitalRead(door)==1 && doo==0) {doo=1;ml=millis();}
if (millis()-ml>200 && doo==1) digitalWrite(lampa,1);
if (millis()-ml2>1000 && doo==0) digitalWrite(lampa,0);
 
if (digitalRead(door)==0 && disp==5) {disp=0;otobragenie();}
if (digitalRead(door)==1 && start==1) {
  
  disp=5;
  otobragenie();
  start=0;
  digitalWrite(motor,0);
  delay(300);
  stoptens();
  
  }
  
//---------------------------------------------------------------------------





//------------------светодиод-----------------------------------------------
if(start==1) digitalWrite(led,1);
if (millis()-msled>500 && start==0) {pinled=!pinled; digitalWrite(led,pinled);msled=millis();}
//--------------------------------------------------------------------------





//--------кнопка СТАРТ/СТОП/--------------------------------------------
 if (digitalRead(pusk)==LOW && flagS==0){
tone (bus, 4500);
delay(50);
noTone(bus);
tone (bus, 3000);
delay(50);
noTone(bus);  




if (start==0 && digitalRead(door)==0 && cod==0) {start=1;disp=0;digitalWrite(motor,1);} else  if (start==1 && digitalRead(door)==0){ start=0;

digitalWrite(led,0);
tm1637.point(0);//stop
    tm1637.displayByte(0,0x6d);
    tm1637.displayByte(1,0x78);
    tm1637.displayByte(2,0x5c);
    tm1637.displayByte(3,0x73);

stoptens();  digitalWrite(motor,0);

 i1 = EEPROM.read(1);
 i2 = EEPROM.read(2);
 i=word(i1, i2);
 temperatura=i;
//--------------время час--------------------------------   
 i1 = EEPROM.read(3);
 i2 = EEPROM.read(4);
 i=word(i1, i2);
 timeHour=i;
 //--------------время мин--------------------------------   
 i1 = EEPROM.read(5);
 i2 = EEPROM.read(6);
 i=word(i1, i2);
 timeMin=i;




disp=0;}



if (digitalRead(door)==1) disp=5;
otobragenie();  
mso=millis();
ms=millis();

  flagS=1;
  }
if (digitalRead(pusk)==HIGH && flagS==1) flagS=0;
//---------------------------------------------------------------------------






//-----------охлаждение   3 минуты  ----------------------------------------
if (millis()-msc>180000 && disp==2) {

  digitalWrite(motor,0);
  
  start=0;
  
  disp=3;
  otobragenie();
 
 i1 = EEPROM.read(1);
 i2 = EEPROM.read(2);
 i=word(i1, i2);
 temperatura=i;
//--------------время час--------------------------------   
 i1 = EEPROM.read(3);
 i2 = EEPROM.read(4);
 i=word(i1, i2);
 timeHour=i;
 //--------------время мин--------------------------------   
 i1 = EEPROM.read(5);
 i2 = EEPROM.read(6);
 i=word(i1, i2);
 timeMin=i;
 
  
       

                                      
  }

//--------------------------------------------------------------------------






//--------------Отсчёт времени-----------------------------------------------
if (millis()-ms>=60000 && start==1 && disp!=2){
  
                           timeMin=timeMin-1;
                                       if (timeMin<0) {
                                        
                           timeHour=timeHour-1;
                                        if (timeHour<0) {              //время сушки истекло
                                          timeMin=0;
                                          timeHour=0;
                                                        
                                          
                                          } else timeMin=59;
                                        }
                      if  (timeHour==0 && timeMin==0)  {               //время сушки истекло
                                          disp=2;
                                          stoptens ();
                                          otobragenie();
                                          
                                           
                                          msc=millis();

                                                                                     
                                             }
  ms=millis();
  }

//---------------------------------------------------------------------------




//--------обработка кнопки время + -------------------------------------------
if (digitalRead(b_time_plus)==LOW && start==0 && flagVP==0) {
 

                                       tone (bus, 3000);
                                       delay(50);
                                       noTone(bus); 
  timeMin=timeMin+10;
  if (timeMin>50) {timeHour=timeHour+1;timeMin=0;
                   if (timeHour>3) {timeHour=3;timeMin=50;}
                   
                   }
  disp=0;
  otobragenie();
  hi = highByte(timeHour); 
  
  low = lowByte(timeHour); 
   EEPROM.write(3, hi);  
   EEPROM.write(4, low);
  hi = highByte(timeMin); 
  low = lowByte(timeMin); 
   EEPROM.write(5, hi);  
   EEPROM.write(6, low);

  flagVP=1;
  }

 if (digitalRead(b_time_plus)==HIGH && flagVP==1) flagVP=0;
//---------------------------------------------------------------------






//--------обработка кнопки время - ------------------------------------
if (digitalRead(b_time_minus)==LOW && start==0 && flagVM==0) {
 

                                       tone (bus, 3000);
                                       delay(50);
                                       noTone(bus); 
  timeMin=timeMin-10;
    
  if (timeMin<10 && timeHour<=0) {timeHour=0;timeMin=10;}
  if (timeMin<0) {timeHour=timeHour-1;timeMin=50;
                    if (timeHour<0 ) {timeHour=0;timeMin=10;}
                 }
  disp=0;
  otobragenie();
  hi = highByte(timeHour); 
  low = lowByte(timeHour); 
  EEPROM.write(3, hi);  
  EEPROM.write(4, low);
  hi = highByte(timeMin); 
  low = lowByte(timeMin); 
  EEPROM.write(5, hi);  
  EEPROM.write(6, low);
    flagVM=1;
  }

 if (digitalRead(b_time_minus)==HIGH && flagVM==1) flagVM=0;
//-------------------------------------------------------------------------





//--------обработка кнопки температура ------------------------------------
if (digitalRead(b_temp)==LOW && start==0 && flagT==0) {
 

                                       tone (bus, 3000);
                                       delay(50);
                                       noTone(bus); 


if (nagatieT==1) {
  temperatura=temperatura+10;
  if (temperatura>80) temperatura=40;
  hi = highByte(temperatura); 
  low = lowByte(temperatura); 
  EEPROM.write(1, hi);  
  EEPROM.write(2, low);
                  }
                  else nagatieT=1;
  disp=1;
  otobragenie();
  pausa=millis();

  flagT=1;
  }
  

 if (digitalRead(b_temp)==HIGH && flagT==1) flagT=0;
//---------------------------------------------------------------------




//---------------------------------------------------------------------
if(millis()-pausa>3000 && start==0 && cod==0  && disp!=5 && disp!=2 && disp!=3){
  nagatieT=0;
  disp=0;
  otobragenie();
  }
//---------------------------------------------------------------------


//---------------------контроль температуры----------------------------
 if(start==1 && digitalRead(door)==0 && cod==0 && disp!=2){
  digitalWrite(rele,1);
  if(t>=(temperatura-5)) {digitalWrite(ten2,0);}  //слабый
  if(t>temperatura) {digitalWrite(ten1,0);}       //мощный

  if(t<(temperatura-2)) {digitalWrite(ten2,1);}
  if(t<(temperatura-5)) {digitalWrite(ten1,1);}
  }
//---------------------------------------------------------------------




//-----периодичность отображения при сушке----------------------------
 if(millis()-mso>3000 && start==1 && disp!=2){
  if (disp==0) disp=4; else disp=0;
  otobragenie();
  mso=millis();
  }
//--------------------------------------------------------------------

                            
}


void otobragenie(){
  
  switch (disp){
     case 0:
   tm1637.point(1);
   tm1637.displayClock(timeHour, timeMin);
     break; 
     case 1:
   tm1637.point(0);
   if (temperatura<10) tm1637.displayByte(0,0x00); else {Digits[0] = (byte)(temperatura / 10) % 10; tm1637.display(0,Digits[0]);}
   Digits[1] = (byte)(temperatura) % 10;
   tm1637.display(0,Digits[0]);
   tm1637.display(1,Digits[1]);
   tm1637.displayByte(2,0x63);
   tm1637.displayByte(3,0x00);  
     break;  
     case 2:
    tm1637.point(0);//Cool
    tm1637.displayByte(0,0x39);
    tm1637.displayByte(1,0x5c);
    tm1637.displayByte(2,0x5c);
    tm1637.displayByte(3,0x06);
    
     break; 
     case 3:   //End
    tm1637.point(0);
    tm1637.displayByte(0,0x79);
    tm1637.displayByte(1,0x54);
    tm1637.displayByte(2,0x5e);
    tm1637.displayByte(3,0x00);
     break;
     case 4:
   tm1637.point(0);
   if (t<10) tm1637.displayByte(0,0x00); else {Digits[0] = (byte)(t / 10) % 10; tm1637.display(0,Digits[0]);}
   Digits[1] = (byte)(t) % 10;
   tm1637.display(0,Digits[0]);
   tm1637.display(1,Digits[1]);
   tm1637.displayByte(2,0x63);
   tm1637.displayByte(3,0x00);  
     break;
     case 5:
   tm1637.point(0);//door
    tm1637.displayByte(0,0x5e);
    tm1637.displayByte(1,0x5c);
    tm1637.displayByte(2,0x5c);
    tm1637.displayByte(3,0x50);    
     break;
     case 6:
      tm1637.point(0); // ошибка E-01...E-03
      tm1637.displayInt(cod);
      tm1637.displayByte(2, 0x3f);
      tm1637.displayByte(1, 0x40);
      tm1637.displayByte(0, 0x50);    
     break; 

        }
}


void stoptens(){
      digitalWrite(ten1,0);
      delay(500);
      digitalWrite(ten2,0);
      delay(500);
      digitalWrite(rele,0);
      delay(500);
   }

int datchik (int t){   //калибровка датчика
int temper;
if (t>=863) temper=90;
if (t>=860 && t < 863) temper=89;
if (t>=857 && t < 860) temper=88;
if (t>=853 && t < 857) temper=87;
if (t>=849 && t < 853) temper=86;
if (t>=844 && t < 849) temper=85;
if (t>=839 && t < 844) temper=84;
if (t>=834 && t < 839) temper=83;
if (t>=829 && t < 834) temper=82;
if (t>=823 && t < 829) temper=81;
if (t>=819 && t < 823) temper=80;
if (t>=814 && t < 819) temper=79;
if (t>=809 && t < 814) temper=78;
if (t>=803 && t < 809) temper=77;
if (t>=798 && t < 803) temper=76;
if (t>=792 && t < 798) temper=75;
if (t>=786 && t < 792) temper=74;
if (t>=780 && t < 786) temper=73;
if (t>=773 && t < 780) temper=72;
if (t>=767 && t < 773) temper=71;
if (t>=760 && t < 767) temper=70;
if (t>=754 && t < 760) temper=69;
if (t>=746 && t < 754) temper=68;
if (t>=740 && t < 746) temper=67;
if (t>=733 && t < 740) temper=66;
if (t>=725 && t < 733) temper=65;
if (t>=717 && t < 725) temper=64;
if (t>=710 && t < 717) temper=63;
if (t>=702 && t < 710) temper=62;
if (t>=695 && t < 702) temper=61;
if (t>=687 && t < 695) temper=60;
if (t>=678 && t < 687) temper=59;
if (t>=670 && t < 678) temper=58;
if (t>=662 && t < 670) temper=57;
if (t>=653 && t < 662) temper=56;
if (t>=645 && t < 653) temper=55;
if (t>=636 && t < 645) temper=54;
if (t>=627 && t < 636) temper=53;
if (t>=617 && t < 627) temper=52;
if (t>=608 && t < 617) temper=51;
if (t>=600 && t < 608) temper=50;
if (t>=590 && t < 600) temper=49;
if (t>=580 && t < 590) temper=48;
if (t>=571 && t < 580) temper=47;
if (t>=561 && t < 571) temper=46;
if (t>=552 && t < 561) temper=45;
if (t>=542 && t < 552) temper=44;
if (t>=531 && t < 542) temper=43;
if (t>=522 && t < 531) temper=42;
if (t>=511 && t < 522) temper=41;
if (t>=501 && t < 511) temper=40;
if (t>=491 && t < 501) temper=39;
if (t>=480 && t < 491) temper=38;
if (t>=470 && t < 480) temper=37;
if (t>=460 && t < 470) temper=36;
if (t>=449 && t < 460) temper=35;
if (t>=439 && t < 449) temper=34;
if (t>=429 && t < 439) temper=33;
if (t>=418 && t < 429) temper=32;
if (t>=408 && t < 418) temper=31;
if (t>=394 && t < 408) temper=30;
if (t>=384 && t < 394) temper=29;
if (t>=375 && t < 384) temper=28;
if (t>=367 && t < 375) temper=27;
if (t>=359 && t < 367) temper=26;
if (t>=348 && t < 359) temper=25;
if (t>=331 && t < 348) temper=24;
if (t>=317 && t < 331) temper=23;
if (t>=306 && t < 317) temper=22;
if (t>=297 && t < 306) temper=21;
if (t>=281 && t < 297) temper=20;
if (t>=272 && t < 281) temper=19;
if (t>=259 && t < 272) temper=18;
if (t>=251 && t < 259) temper=17;
if (t>=237 && t < 251) temper=16;
if (t>=228 && t < 237) temper=15;
if (t>=220 && t < 228) temper=14;
if (t>=213 && t < 220) temper=13;
if (t>=204 && t < 213) temper=12;
if (t>=198 && t < 204) temper=11;
if (t>=190 && t < 198) temper=10;
if (t>=183 && t < 190) temper=9;
if (t>=177 && t < 183) temper=8;
if (t>=171 && t < 177) temper=7;
if (t>=164 && t < 171) temper=6;
if (t>=159 && t < 164) temper=5;
if (t>=154 && t < 159) temper=4;
if (t>=150 && t < 154) temper=3;
if (t>=147 && t < 150) temper=2;
if (t>=142 && t < 147) temper=1;
if (t<142) temper=0;
   
  return temper;
  }

и сразу второй

long reservuar=0;           // для периодичности включения сливной помпы
long reservuarwork=0;       // для времени работы сливной помпы
int t;                      //считанное значение с датчика температуры
int start=0;                //0-стоп, 1-работа, 2-пауза
bool pinpump=0;
bool door=0;                //статус открытия двери
long doortime=0;            //время пройденное после открытия или закрытия двери
long vremja=0;              //для отсчета времени
long ms8=0;
long errortime=0;

int timeHour=0;              //время сушки часы текущее
int timeMin=0;              //время сушки минуты текущее
int temperatura=0;          //заданная температура сушки с панели управления
int hist=3;                 // гистерезис

bool pin7=0;
bool pin8=0;
bool error1=0;
bool doorf=0;
 
bool flagstart=0;

long mss=0;
long mst=0;
long drebezgdoor=0; //время на дребезг концевика двери




String a,StringtoSend;


#define ntc A1

void setup(){
  Serial.begin(9600);

pinMode(ntc, INPUT); //аналоговый вход датчика температуры
pinMode(2, INPUT);   //вход от датчика закрытия двери

pinMode(3, OUTPUT); //выход на лампочку внутреннего освещения
pinMode(4, OUTPUT); //выход на сливную помпу
pinMode(5, OUTPUT); //выход на двигатель
pinMode(6, OUTPUT); //выход на главное реле
pinMode(7, OUTPUT); //выход на реле тэна 1
pinMode(8, OUTPUT); //выход на реле тэна 2 (мощное)
  



reservuar=millis();
reservuarwork=millis();
pinpump=1;
}
void loop(){
  if (millis()-mst>500){
     t=analogRead(ntc);
     t=map(t,145,820,92,9);
     if (t>35 && t<55) t=(t*11)/10;
     if (t>76 ) t=(t*21)/20;
    // t=(t*20)/21;
     t=constrain(t, 10, 99);
     mst=millis();
     
  }

  if (t>90) {error1=1;errortime=millis();} else error1=0;
  if (error1==1 && millis()-errortime>2000) {start=2;stoprele();} //остановить сушку если температура выше 90 градусов
  
  if(millis()-mss>200){ SerialREAD ();mss=millis();}



//-----опорожняем резервуар каждые 20 минут, включая помпу на 30секунд-------------

if (millis()-reservuar>1200000) {
  pinpump=1;reservuar=millis();reservuarwork=millis();
  }

if (pinpump==1 && millis()-reservuarwork<30000) digitalWrite(4,pinpump);
if ( millis()-reservuarwork>30000) {pinpump=0;digitalWrite(4,pinpump);}


//----------------------------------------------------------------------------------------









//---------------обработка открытия и закрытия двери---------------------------------------

if (digitalRead(2)==HIGH) door=0;else door=1;
//{doorf=1;drebezgdoor=millis();}
//if (doorf==1 && millis()-drebezgdoor>300) {door=0;doorf=0;} else door=1;

if (millis()-doortime<30000) digitalWrite(3,1); else digitalWrite(3,0);  //включить свет на 30 секунд


if (door==0 && start==1) {                              //открыли дверь при работающей сушке
                           
                           
                           stoprele();                   //отключить все реле
                           start=2;                      //перейти в режим паузы
                          
}

if (door==0 && start==2)                                 //открыли дверь после перехода в режим паузы
                          
                           doortime=millis();            // свет будет гореть пока не закроется дверь и не пройдет 30 секунд
                           
                         

if (door==0 && start==0)                                 //открыли дверь при неработающей сушке
                           
                           doortime=millis();            // свет будет гореть пока не закроется дверь и не пройдет 30 секунд
                           
                         


//-------------------------------------------------------------------------------------







//--------------сушка запущена и идет отсчет времени-------------------------------------

if (start==0)  { stoprele (); pin7=0; pin8=0;}

if (start==1 && millis()-vremja>=60000) {   
                                       
                                       timeMin=timeMin-1;
                                       if (timeMin<0) {
                                        
                                        timeHour=timeHour-1;
                                        if (timeHour<0) {              //время сушки истекло
                                          timeMin=0;
                                          timeHour=0;
                                                        
                                          
                                          } else timeMin=59;
                                        }
                      if  (timeHour==0 && timeMin==0)  {  //время сушки истекло
                                          stoprele ();
                                          timeMin=0;
                                          timeHour=0;
                                          start=5; 
                                          pin7=0;
                                          pin8=0;
                                          flagstart=0;   }
                                          vremja=millis();
                                       }
                                    
//-----------------------------------------------------------------------------------------


//---------------сушку только что запустили-------------------------------

if (start==1 && flagstart==0) {vremja=millis();flagstart=1;}
if (start==2) {flagstart=0;stoprele ();}

//---------------------------------------------------------------------


//----сушка запущена и идет процесс сушки-----------------------------------------------------

if (start==1 && door==1) {
  
              digitalWrite(5,1);                              //включить двигатель
              digitalWrite(6,1);                              //включить главное реле

              
              
            if (t <= temperatura-hist) {pin7=1;if (timeMin>5) pin8=1;}
            if (t >= temperatura+hist) {pin7=0;pin8=0;}
            if (timeMin<5) pin8=0;


              
              digitalWrite(7,pin7);                            //тэн1
              digitalWrite(8,pin8);                            //тэн2 (мощный)
  
                         }
   
//----------------------------------------------------------------------------------------------





//--------------------отправка данных в плату индикации----------------------------------------
 if ( millis()-ms8>500) {
if (start==5) {a='5';start=0;}else a = String(start);
StringtoSend=String(timeHour)+";"+String(timeMin)+";"+String(t)+";"+a+":";
Serial.println(StringtoSend);
//Serial.print("pin7: ");Serial.print(pin7);Serial.print(" pin8: ");Serial.print(pin8);Serial.print(" t: ");Serial.println(t);
 ms8=millis();
                }

//--------------------------------------------------------------------------------------------- 
   
}


void SerialREAD (){

if (!Serial.available()) return;

timeHour= Serial.parseInt ();
timeMin = Serial.parseInt ();
temperatura= Serial.parseInt ();
start= Serial.parseInt ();


}

void stoprele () {
  digitalWrite(8,0);
  delay(30);
  digitalWrite(7,0);
  delay(20);
  digitalWrite(4,0);
  digitalWrite(5,0);
  digitalWrite(6,0);
    
  }

Дальше уже общался с gpt чатом, ох и ругались мы с ним, то он не учтет двигатель барабана, то выключит его просто так, то сделает что он выключится только с розетки) в общем, вроде он смог написать, где я, со своим пониманием, ошибок не нахожу уже. Если кому не лень, можете оценить его работу и будет ли это вообще работать (про калибровку датчиков я пока молчу, думаю справлюсь). Ардуино на чипе atmega168pa, имеется еще свободное stm32f103, но TTL уровни не те. Собственно код gpt:

#include <EEPROM.h>
#include <TM1681.h>
#define CLK 3  // пины дисплея
#define DIO 2  // пины дисплея
TM1681 tm1681(CLK, DIO);

int temperatura = 40; // Заданная температура сушки в градусах Цельсия (не больше 40)
int timeHour = 2;     // Часы для сушки
int timeMin = 30;     // Минуты для сушки

int tb;
bool start = false;   // Флаг состояния сушки: false - стоп, true - старт
int cod = 0;          // Код ошибки сушилки (0 - нет ошибки)

int t, tx;
byte i1, i2, hi, low;
int i = 0;
long mst = 0;
bool flagS = false;
bool flagVP = false;
bool flagVM = false;
bool flagT = false;
bool doo = false;
byte disp = 0;
bool pinled = false;
int8_t Digits[] = {0x00, 0x00, 0x00, 0x00};
long ms = 0;
long msc = 0;
long mso = 0;
long msled = 0;
long ml, ml2;
long reservuar = 0;           // для периодичности включения сливной помпы
long reservuarwork = 0;       // для времени работы сливной помпы
bool pinpump = false;         // Флаг состояния компрессора: false - выключен, true - включен
bool nagatieT = false;        // Флаг для изменения температуры

#define motor 9                // Пин, управляющий мотором (барабаном)
#define compressor 10          // Пин, управляющий компрессором
#define doorSensor A0          // Пин, к которому подключен датчик открытия двери
#define ntc A1                 // Пин, к которому подключен датчик температуры воздуха
#define ntc2 A2                // Пин, к которому подключен датчик температуры на компрессоре

#define motorSpeed 255         // Скорость вращения мотора (максимальная)

#define doorClosed 0           // Состояние датчика открытия двери при закрытой двери
#define doorOpen 1             // Состояние датчика открытия двери при открытой двери

#define motorRotate 0          // Направление вращения мотора - по часовой стрелке
#define motorReverse 1         // Направление вращения мотора - против часовой стрелки

#define tempHysteresis 5       // Гистерезис для температуры (разница между выключением и включением компрессора)

void setup() {
  pinMode(motor, OUTPUT);
  pinMode(compressor, OUTPUT);
  pinMode(doorSensor, INPUT);
  pinMode(ntc, INPUT);
  pinMode(ntc2, INPUT);

  //-------------температура-------------------------------
  i1 = EEPROM.read(1);
  i2 = EEPROM.read(2);
  i = word(i1, i2);
  if (i >= 35 && i <= 40) {
    temperatura = i;
  } else {
    temperatura = 40; // Значение по умолчанию
    hi = highByte(temperatura);
    low = lowByte(temperatura);
    EEPROM.write(1, hi);
    EEPROM.write(2, low);
  }

  //--------------время час--------------------------------
  i1 = EEPROM.read(3);
  i2 = EEPROM.read(4);
  i = word(i1, i2);
  if (i >= 0 && i <= 3) {
    timeHour = i;
  } else {
    timeHour = 2; // Значение по умолчанию
    hi = highByte(timeHour);
    low = lowByte(timeHour);
    EEPROM.write(3, hi);
    EEPROM.write(4, low);
  }

  //--------------время мин--------------------------------
  i1 = EEPROM.read(5);
  i2 = EEPROM.read(6);
  i = word(i1, i2);
  if (i >= 0 && i <= 59) {
    timeMin = i;
  } else {
    timeMin = 30; // Значение по умолчанию
    hi = highByte(timeMin);
    low = lowByte(timeMin);
    EEPROM.write(5, hi);
    EEPROM.write(6, low);
  }

  tm1681.init();
  tm1681.setBrightness(1);
  tm1681.point(1);
  tm1681.displayClockTwist(timeHour, timeMin, 50);
  tone(compressor, 3000);
  delay(50);
  noTone(compressor);
  tone(compressor, 4500);
  delay(50);
  noTone(compressor);

  reservuar = millis();
  reservuarwork = millis();
  pinpump = false;

  stopMotor(); // Убедимся, что мотор остановлен при старте
}

void loop() {
  // Опрос датчика температуры каждые 2 секунды
  if (millis() - mst > 2000) {
    tx = analogRead(ntc);
    t = map(tx, 0, 1023, 0, 100); // Преобразуем сырые данные АЦП в температуру в диапазоне 0-100 градусов
    tb = analogRead(ntc2);
    cod = 0;

    // Проверка датчиков температуры
    if (tx > 1000 || tx < 15) cod = 1; // Датчик температуры воздуха
    if (tb > 800) cod = 2; // Датчик температуры на компрессоре
    if (t > 40) cod = 3; // Температура в сушке выше 40 градусов

    if (cod > 0) {
      stopHeaters();
      start = false;
      disp = 6;
      displayMessage();
      digitalWrite(motor, 0);
    }

    mst = millis();
  }

  // Охлаждение каждые 30 минут
  if (millis() - reservuar > 1800000) {
    startCompressor();
    reservuar = millis();
    reservuarwork = millis();
  }

  if (pinpump && millis() - reservuarwork < 30000) {
    digitalWrite(compressor, pinpump);
  }
  if (millis() - reservuarwork > 30000) {
    pinpump = false;
    digitalWrite(compressor, pinpump);
  }

  // Обработка датчика двери
  if (digitalRead(doorSensor) == doorOpen && doo == true) {
    doo = false;
    ml2 = millis();
  }
  if (digitalRead(doorSensor) == doorClosed && doo == false) {
    doo = true;
    ml = millis();
  }
  if (millis() - ml > 200 && doo == true) {
    digitalWrite(motor, HIGH);
  }
  if (millis() - ml2 > 1000 && doo == false) {
    digitalWrite(motor, LOW);
  }

  // Обработка кнопки СТАРТ/СТОП
  if (digitalRead(startButton) == LOW && flagS == false) {
    tone(compressor, 4500);
    delay(50);
    noTone(compressor);
    tone(compressor, 3000);
    delay(50);
    noTone(compressor);

    if (start == false && digitalRead(doorSensor) == doorClosed && cod == 0) {
      start = true;
      disp = 0;
      digitalWrite(motor, HIGH);
      digitalWrite(compressor, pinpump);
    } else if (start == true && digitalRead(doorSensor) == doorClosed) {
      start = false;
      tm1681.point(0);
      tm1681.displayByte(0, 0x6D); // Отображение "Стоп"
      tm1681.displayByte(1, 0x78);
      tm1681.displayByte(2, 0x5C);
      tm1681.displayByte(3, 0x73);

      stopHeaters();
      digitalWrite(motor, LOW);
      stopCompressor();
      i1 = EEPROM.read(1);
      i2 = EEPROM.read(2);
      temperatura = word(i1, i2);
      i1 = EEPROM.read(3);
      i2 = EEPROM.read(4);
      timeHour = word(i1, i2);
      i1 = EEPROM.read(5);
      i2 = EEPROM.read(6);
      timeMin = word(i1, i2);
      disp = 0;
    }

    if (digitalRead(doorSensor) == doorOpen) {
      disp = 5;
    }
    displayMessage();
    mso = millis();
    ms = millis();
    flagS = true;
  }
  if (digitalRead(startButton) == HIGH && flagS == true) {
    flagS = false;
  }

  // Охлаждение 3 минуты после сушки
  if (millis() - msc > 180000 && disp == 2) {
    digitalWrite(motor, LOW);
    stopCompressor();
    start = false;
    disp = 3;
    displayMessage();
    i1 = EEPROM.read(1);
    i2 = EEPROM.read(2);
    temperatura = word(i1, i2);
    i1 = EEPROM.read(3);
    i2 = EEPROM.read(4);
    timeHour = word(i1, i2);
    i1 = EEPROM.read(5);
    i2 = EEPROM.read(6);
    timeMin = word(i1, i2);
  }

  // Отсчет времени сушки
  if (millis() - ms >= 60000 && start == true && disp != 2) {
    timeMin = timeMin - 1;
    if (timeMin < 0) {
      timeHour = timeHour - 1;
      if (timeHour < 0) {
        timeMin = 0;
        timeHour = 0;
      } else {
        timeMin = 59;
      }
    }
    if (timeHour == 0 && timeMin == 0) {
      disp = 2; // Время сушки истекло
      stopHeaters();
      displayMessage();
      msc = millis();
    }
    ms = millis();
  }

  // Обработка кнопки установки времени +
  if (digitalRead(timePlusButton) == LOW && start == false && flagVP == false) {
    tone(compressor, 3000);
    delay(50);
    noTone(compressor);
    timeMin = timeMin + 10;
    if (timeMin > 50) {
      timeHour = timeHour + 1;
      timeMin = 0;
      if (timeHour > 3) {
        timeHour = 3;
        timeMin = 50;
      }
    }
    disp = 0;
    displayMessage();
    flagVP = true;
  }
  if (digitalRead(timePlusButton) == HIGH && flagVP == true) {
    flagVP = false;
  }

  // Обработка кнопки установки времени -
  if (digitalRead(timeMinusButton) == LOW && start == false && flagVM == false) {
    tone(compressor, 3000);
    delay(50);
    noTone(compressor);
    timeMin = timeMin - 10;
    if (timeMin < 10 && timeHour <= 0) {
      timeHour = 0;
      timeMin = 10;
    }
    if (timeMin < 0) {
      timeHour = timeHour - 1;
      timeMin = 50;
      if (timeHour < 0) {
        timeHour = 0;
        timeMin = 10;
      }
    }
    disp = 0;
    displayMessage();
    flagVM = true;
  }
  if (digitalRead(timeMinusButton) == HIGH && flagVM == true) {
    flagVM = false;
  }

  // Обработка кнопки установки температуры
  if (digitalRead(tempButton) == LOW && start == false && flagT == false) {
    tone(compressor, 3000);
    delay(50);
    noTone(compressor);
    if (nagatieT == false) {
      temperatura = temperatura + 5;
      if (temperatura > 40) {
        temperatura = 35;
      }
      nagatieT = true;
    } else {
      nagatieT = false;
    }
    disp = 1;
    displayMessage();
    mso = millis();
    ms = millis();
    flagT = true;
  }

  if (digitalRead(tempButton) == HIGH && flagT == true) {
    flagT = false;
  }

  // Отображение температуры в сушке каждые 3 секунды
  if (millis() - mso > 3000 && start == true && disp != 2) {
    if (disp == 0) {
      disp = 4;
    } else {
      disp = 0;
    }
    displayMessage();
    mso = millis();
  }
}

void displayMessage() {
  switch (disp) {
    case 0:
      tm1681.point(1);
      tm1681.displayClockTwist(timeHour, timeMin, 50);
      break;
    case 1:
      tm1681.point(0);
      tm1681.displayInt(temperatura);
      tm1681.displayByte(2, 0x63);
      tm1681.displayByte(3, 0x00);
      break;
    case 2:
      tm1681.point(0);
      tm1681.displayByte(0, 0x39); // Охлаждение
      tm1681.displayByte(1, 0x5C);
      tm1681.displayByte(2, 0x5C);
      tm1681.displayByte(3, 0x06);
      break;
    case 3:
      tm1681.point(0);
      tm1681.displayByte(0, 0x79); // Завершено
      tm1681.displayByte(1, 0x54);
      tm1681.displayByte(2, 0x5E);
      tm1681.displayByte(3, 0x00);
      break;
    case 4:
      tm1681.point(0);
      if (t < 10) {
        tm1681.displayByte(0, 0x00);
      } else {
        Digits[0] = (byte)(t / 10) % 10;
        tm1681.display(0, Digits[0]);
      }
      Digits[1] = (byte)(t) % 10;
      tm1681.display(1, Digits[1]);
      tm1681.displayByte(2, 0x63);
      tm1681.displayByte(3, 0x00);
      break;
    case 5:
      tm1681.point(0); // Дверь
      tm1681.displayByte(0, 0x5E);
      tm1681.displayByte(1, 0x5C);
      tm1681.displayByte(2, 0x5C);
      tm1681.displayByte(3, 0x50);
      break;
    case 6:
      tm1681.point(0); // Ошибка E-01...E-03
      tm1681.displayInt(cod);
      tm1681.displayByte(2, 0x3F);
      tm1681.displayByte(1, 0x40);
      tm1681.displayByte(0, 0x50);
      break;
  }
}

void stopHeaters() {
  digitalWrite(compressor, LOW);
}

void startCompressor() {
  pinpump = true;
  digitalWrite(compressor, pinpump);
}

void stopCompressor() {
  pinpump = false;
  digitalWrite(compressor, pinpump);
}

void stopMotor() {
  digitalWrite(motorEnable1, LOW);
  digitalWrite(motorEnable2, LOW);
  digitalWrite(motorEnable3, LOW);
  digitalWrite(motorEnable4, LOW);
  digitalWrite(motorEnable5, LOW);
  analogWrite(motorSpeed, 0);
  digitalWrite(motorRotate, LOW);
  digitalWrite(motorReverse, LOW);
}

ЕвгенийП · 25.Июль.2023 17:27:01

Сбылось пророчество!

CLF · 25.Июль.2023 17:33:36

Так помимо нейросети есть и скетч который работает и написан человеком) если исключить нейросеть, в первых двух скетчах я поменяю скажем вместо тэна нагрева поставлю компрессора, второй тэн не использую, и смена температур работы, этого будет достаточно?

SAB · 25.Июль.2023 17:57:55

Обратиться в сервис сушилки и купить там новую плату. Скорее всего её стоимость будет половина новой сушилки, но точно меньше изобретения на колхозной ардуине.

sadman41 · 25.Июль.2023 18:01:15

А я предлагаю дать код на ревью другому гпт-боту. Например от яндекса. Алиса вон, пусть, подумает над ним - ей все равно в облаках скучно одной сидеть.

CLF · 25.Июль.2023 18:19:34

Изобретение на колхозной ардуино так дорого? я думал что силовая плата с готовой системой управления, только дай команду, уже предназначена для ардуино. По сути, дисплей, пара датчиков, двигатель да компрессор, помпа еще) Я видел куда круче проекты, тут же, даже скетч есть от пользователя Бошь, слегка обновить я думал и все.

CLF · 25.Июль.2023 18:21:00

так а если проигнорировать gpt чат, те коды что скинул вначале, с ошибками? Или его можно использовать.

WladDrakula · 25.Июль.2023 18:22:39

В старые времена в литературных журналах было условие: “Рукописи не возвращаются и не рецензируются”. Это я к тому, что очень оптимистично верить в то, что приведенную выше графоманию хоть кто-то станет читать… и уж тем более проверять!

CLF · 25.Июль.2023 18:27:35

на самом деле очень оптимистичный человек) Чтож, даже если и не будут проверять, людям будет пример скетча, может кому и пригодится) В нынешнее время я столкнулся с проблемой нахождения готового скетча, чтоб скачать данный пришлось юзать UK прокси)

v258 · 25.Июль.2023 18:31:57

Я вам больше скажу, проблема относительно новая. Лет двадцать назад скачать скетч в сети было просто невозможно

WladDrakula · 25.Июль.2023 18:35:11

Родное сердце! Хобби - такая штука, что люди занимаются интересным… им, а не тебе. Заказывать то, что тебе нужно - невыгодно совершенно. Это работа минимум от 20 тысяч рублей, еще и машину свою привезешь исполнителю, а потом заберешь.
Искать человека, который уже когда-то подобным интересовался нужно в большом мире, то есть в англоязычном инете. На Реддите или хотя бы на arduino.cc.

Подобные штуки многие делали, но под свй, конкретный прибор. Меня как-то “торкнуло” сделать себе плату управления отопителем. Кто-то стиралку, кто-то посудомойку или еще что измучил. НО не твой прибор. а свой, конкретный. И человек обычно делал тот, кто в советах не нуждался, а просто “в кубики играл” в свое удовольствие.
Начал понимать. что такое хобби?

sadman41 · 25.Июль.2023 18:35:25

Программ без ошибок не бывает в принципе.

WladDrakula · 25.Июль.2023 18:37:56

“В принципе” - бывают! В жизни - не видел пока.

CLF · 25.Июль.2023 18:38:07

это да) тогда я хотел отучится и попасть в отдел К)

sadman41 · 25.Июль.2023 18:38:18

Как так? А скетчи в журнале “Радио”? Сеть была, правда, не очень глобальная и медленная… Но все же.

sadman41 · 25.Июль.2023 18:39:55

А мертвым безошибочные скетчи не нужны. Наверное. Я не спрашивал, конечно…

v258 · 25.Июль.2023 18:40:28

Двадцать лет назад интернет уже был, даже скоростной. А вот ардуины, вроде бы, еще не было ))

CLF · 25.Июль.2023 18:42:45

Да я прекрасно понимаю) Вам проще увидеть то чего не вижу я, только и всего) я только начал этим заниматься столкнувшись с проблемой, до этого использовал лишь самописные боты для упрощения нынешней работы, и то, костыль костылем погоняя) а тут прям проект) скинул без надежды на чудо прям, вдруг есть явные косяки что в глаза бросаются. А так, есть машинка, есть понимание, загружу ардуинку и пойму на каком этапе косячит, туда и буду уже копать.

andriano · 25.Июль.2023 18:46:01

Дорого не “железо”. Дорого - разработка софта.
Разработка софта вообще намного дороже стоимости единицы продукции и может быть оправдана лишь при необходимости изготовления большой партии этой продукции.

sadman41 · 25.Июль.2023 18:47:43

Подход не очень. Возьмём тех же итальянцев - как стали ардуину пихать везде и всем, получили неприятностей… Теперь то засуха, то потоп, то жара несусветная. Полагаю, что как раз на какой-то сушилке и отлаживаются.