Arduino.ru

строка почему-то не работает и код идет дальше

 if (pulseIn(5, HIGH, 5000000L) == 0) { // если нет напряжения на фазе 5 секунд пишет ошибку и пытается начать сначала.
    Serial.print("A Fail");
    return;
  }

 if (pulseIn(5, HIGH, 5000000L) == 0) { // если нет напряжения на фазе 5 секунд пишет ошибку и пытается начать сначала.
    Serial.print("A Fail");
    return;
  }

уважаемый, я вам еще 3 страницы назад писал, что pulsein не будет работать на трех фазах. Чтож вы по три раза на одни и те же грабли наступаете???

Он уже не уважаемый, он уже ТТП на этом форуме. 

а все твоя жадность :) - закрыл бы ветку на второй странице...

Шо, опять? :)))))))))))))

Я её только удалить могу, а жалка, вдруг кто зайдёт, поржёт. 

Не опять а снова !!!

Для усвояемости пройденного материала !!!

Видите как много усвоил.

У тебя в голове вообще пусто.
И не усвоил ты нихрена.

Покажи хоть одну строчку конструктивного кода (все Serial'ы не имеют к конструктиву никакого отношения), которую ТЫ написал САМ и которая РАБОТАЕТ .

О. ТС взялся свои посты удалять. :)  

Видимо, чтоб не ржали. 

Вместо того, чтоб учиться? у дебила, прости господи, и методы дебильные...

У кого есть право, закройте ветку.

Админы, добавьте ДедСимену прав на редактирование и закрывание веток на форуме. Думаю, ни  у кого нет сомнений, что кандидат достоин :)))

###

не нужно ничего закрывать и писать тоже не нужно в эту тему, я старался, объяснял... вы тоже пытались это сделать - смеритесь, мы не всемогущие (мучителя). Может кто и поможет ТС - в том смысле, что напишет ему код...

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

Удалил не нужное. Ну что учимся дальше - справитесь !

Вроде того.

Деда, а может указатель ему?

Давно мы его не доставали, запылился уже...

клиент наглеет

Не наглеет а все-таки пытается грызть гранит науки.

Я б ему сперва сертификат пожаловал, а потом бы отправил по указателю. :) 

Разберусь для начала с этим как докумекаю отпишусь , а то ведь всем уже интересно чем все закончится.

 unsigned long tim = CheckPhase(5, &phaseTime);
  if(tim > 0)
  {
  if (tim < 5000 && !printDone)
  {
   printDone = true;
  } 
  if (tim >= 5000 && !print5secDone)
  {
   Serial.print("Фаза 1 - АВАРИЯ ");
   Serial.println(tim);
   print5secDone = true;
  }
  
  }
  else 
  {
  if (printDone && !print5secDone)
  {
  Serial.print("Фаза 1 - фазы не было ");
  Serial.println(lastTim);
  }
  
  printDone = false;
  print5secDone = false;
  }
  lastTim = tim;
} // loop()

Вангую, хоть это здесь и запрещено:  закончится всё сертификатом и указателем. 

Вы хоть скажите что это

увидишь, когда всё закончится. 

Написал - но появились новые непонятные вещи.

Даю задержку в 3 сек по одной фазе - работает нормально и выводит 3 сек. Как только подключаю все три , то вторая пишет задержку иногда 1 сек то третья 2 сек а то и вовсе 1 больше 5 сек (авария).

Почему не работает ? чего-то не учитываю ?

#include "SPI.h"
#include "Adafruit_GFX.h"     // Библиотека обработчика графики
#include "Adafruit_ILI9341.h" // Программные драйвера для дисплеев ILI9341

#define TFT_DC 9              // Пин подключения вывода D/C дисплея
#define TFT_CS 10             // Пин подключения вывода CS дисплея

#define TFT_RST -1            // Если вывод дисплея RESET подключен к питанию или через кнопку RESET на Arduino

//  Mega 2560 Hardware SPI

#define TFT_MOSI 51           // Пин подключения вывода дисплея SDI(MOSI)
#define TFT_CLK 52            // Пин подключения вывода дисплея SCK
#define TFT_MISO 50           // Пин подключения вывода дисплея SDO(MISO)



Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO); 
                                                           // Создаем объект дисплея и сообщаем библиотеке распиновку для работы с графикой

int Size;

byte last_pin_state1=1,last_pin_state2=1, last_pin_state3=1;
unsigned long timer1 = 0,timer2 = 0,timer3 = 0;
unsigned long GlobalTik = millis();
int a,b,c;
//-----------------------------------------------

 void setup(){
Size=2;
  pinMode(5,INPUT);
  pinMode(6,INPUT);
  pinMode(7,INPUT);
 
  
  Serial.begin(9600);
  tft.begin();                                              // Инициализируем начало работы с графическим дисплеем

  tft.setRotation(1);                                       // Переводим дисплей в альбомную ориентацию
  tft.fillScreen(ILI9341_DARKGREY);
 
//-------------------------------------------------
  tft.setTextSize(Size);                                  // Определяем размер шрифта для вывода на дисплей
  tft.fillRect (10, 10, 300, 60, ILI9341_WHITE);          //созадаем стоп и 1 этаж в начале
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(90, 30); 
  tft.println(utf8rus("КОНТРОЛЬ ФАЗ"));
  tft.setTextColor(ILI9341_GREEN);                       // Определяем цвет текста для вывода на экран
  
  tft.fillRect (40, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(53,100);                                 // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("A");                                        // Выводим текст

  tft.fillRect (140, 90, 50, 60, ILI9341_WHITE);
    tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(153,100);                                 // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("B");                                        // Выводим текст

   tft.fillRect (240, 90, 50, 60, ILI9341_WHITE);
   tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(253,100);                                // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("C");                                        // Выводим текст

  tft.setTextSize(Size);                                 // Определяем размер шрифта для вывода на дисплей
  tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);   
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(75, 190); 
 tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
  tft.setTextColor(ILI9341_GREEN);                       // Определяем цвет текста для вывода на экран
//--------------------------------------------------  


}
 
void loop() {


     byte status1 = digitalRead(5);
      
 if(status1 != last_pin_state1)        // состояние пина поменялось
  {
    last_pin_state1 = status1;         // сохраняем текущее
   if(status1 == LOW)                // включили
    {
      timer1 = millis();a =1;               // запоминаем время включения
    }
else                                  // выключили
    {                                       // печатаем продолжительность работы   
     Serial.print("Фаза A - фазы не было: ");
     Serial.println((millis() - timer1)/1000);
     if ((millis()-timer1 < 5000)){
               tft.setTextSize(Size);                                   // Определяем размер шрифта для вывода на дисплей
               tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);              
               tft.setTextColor(ILI9341_GREEN);
               tft.setCursor(75, 180); 
               tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
               tft.setCursor(30, 205); 
               tft.print(utf8rus("фазы A не было : "));
               tft.print((millis() - timer1)/1000);
               tft.print(utf8rus(" сек"));
               tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран        

  tft.fillRect (40, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(53,100);                                     // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5);  
  tft.print("A");                                            // Выводим текст
     }
    if ((millis()-timer1 >= 5000)&&(a==1))
      {Serial.println("Фаза A - АВАРИЯ ФАЗЫ "); 

              tft.setTextSize(Size);                                    // Определяем размер шрифта для вывода на дисплей
              tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);            
              tft.setTextColor(ILI9341_RED);
              tft.setCursor(75, 190); 
              tft.println(utf8rus("АВАРИЯ ФАЗЫ А"));
              tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран

  tft.fillRect (40, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_RED);
  tft.setCursor(53,100);                                      // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("A");  
      
   a=0;
   }
     
    }
  }

   byte status2 = digitalRead(6);
 
 if(status2 != last_pin_state2)        // состояние пина поменялось
  {
    last_pin_state2 = status2;         // сохраняем текущее
   if(status2 == LOW)                // включили
    {
      timer2 = millis();b=1;               // запоминаем время включения
    }
else                                  // выключили
    {                                   // печатаем продолжительность работы
     Serial.print("Фаза B - фазы не было: ");
     Serial.println((millis() - timer2)/1000);
 if ((millis()-timer2 < 5000)){
               tft.setTextSize(Size);                                   // Определяем размер шрифта для вывода на дисплей
               tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);             
               tft.setTextColor(ILI9341_GREEN);
               tft.setCursor(75, 180); 
               tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
               tft.setCursor(30, 205); 
               tft.print(utf8rus("фазы B не было : "));
               tft.print((millis() - timer2)/1000);
               tft.print(utf8rus(" сек"));
               tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран        
              
  tft.fillRect (140, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(153,100);                                   // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("B");                                           // Выводим текст
 }     
      if ((millis()-timer2 >= 5000)&&(b==1))
      {Serial.println("Фаза B - АВАРИЯ ФАЗЫ "); 
  
              tft.setTextSize(Size);                                    // Определяем размер шрифта для вывода на дисплей
              tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               
              tft.setTextColor(ILI9341_RED);
              tft.setCursor(75, 190); 
              tft.println(utf8rus("АВАРИЯ ФАЗЫ В"));
              tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран

  tft.fillRect (140, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_RED);
  tft.setCursor(153,100);                                   // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("B");                                           // Выводим текст
   b=0;
   }
    }
  }

 byte status3 = digitalRead(7);
 
 if(status3 != last_pin_state3)        // состояние пина поменялось
  {
    last_pin_state3 = status3;         // сохраняем текущее
   if(status3 == LOW)                // включили
    {
      timer3 = millis(); c=1;              // запоминаем время включения
    }
else                                  // выключили
    {                                   // печатаем продолжительность работы
     Serial.print("Фаза C - фазы не было: ");
     Serial.println((millis() - timer3)/1000);
 if ((millis()-timer3 < 5000)){
               tft.setTextSize(Size);                                   // Определяем размер шрифта для вывода на дисплей
               tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               
               tft.setTextColor(ILI9341_GREEN);
               tft.setCursor(75, 180); 
               tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
               tft.setCursor(30, 205); 
               tft.print(utf8rus("фазы C не было : "));
               tft.print((millis() - timer3)/1000);
               tft.print(utf8rus(" сек"));
               tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран        

               
  tft.fillRect (240, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(253,100);                                     // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("C");                                             // Выводим текст
 }    
      if ((millis()-timer3 >= 5000)&&(c==1))
      {Serial.println(" Фаза C - АВАРИЯ ФАЗЫ "); 
      

              tft.setTextSize(Size);                                    // Определяем размер шрифта для вывода на дисплей
              tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               
              tft.setTextColor(ILI9341_RED);
              tft.setCursor(75, 190); 
              tft.println(utf8rus("АВАРИЯ ФАЗЫ С"));
              tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран

  tft.fillRect (240, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_RED);
  tft.setCursor(253,100);                                    // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("C");
   c=0;                                           // Выводим текст
   }
    }
   }

  }

   /* Recode russian fonts from UTF-8 to Windows-1251 */

String utf8rus(String source)
{
  int i,k;
  String target;
  unsigned char n;
  char m[2] = { '0', '\0' };
  k = source.length(); i = 0;
  while (i < k) {
    n = source[i]; i++;
    if (n >= 0xBF){
      switch (n) {
        case 0xD0: {
          n = source[i]; i++;
          if (n == 0x81) { n = 0xA8; break; }
          if (n >= 0x90 && n <= 0xBF) n = n + 0x2F;
          break;
        }
       case 0xD1: {
          n = source[i]; i++;
          if (n == 0x91) { n = 0xB7; break; }
          if (n >= 0x80 && n <= 0x8F) n = n + 0x6F;
          break;
        }
      }
    }
    m[0] = n; target = target + String(m);
  }
return target;
}

опять нахреначили в код TFT экран? - я вам на первой странице написал - пока контроль фаз не заработает - экран не добавлять.

Теперь разбирайтесь сами.

По коду - Написать код для одной фазы. а потом размножить его три раза копированием - так только неграмотные индусы пишут. Откройте для себя процедуры и функции.

С функцией тоже самое выходит - с одной работает с тремя нет ерунду выдает.

unsigned long phaseTime=0;
int a;
void setup()
{
pinMode(5, INPUT);
pinMode(6,INPUT);
pinMode(7,INPUT);
Serial.begin(9600);
/*
if (pulseIn(5, HIGH, 5000) == 0) { // если нет напряжения на фазе 5 секунд пишет ошибку и пытается начать сначала.
    Serial.println("A Fail");
    return;
  }
if (pulseIn(6, HIGH, 5000) == 0) { // если нет напряжения на фазе 5 секунд пишет ошибку и пытается начать сначала.
    Serial.println("B Fail");
    return;
  }
if (pulseIn(7, HIGH, 5000) == 0) { // если нет напряжения на фазе 5 секунд пишет ошибку и пытается начать сначала.
    Serial.println("C Fail");
    return;
  }
*/

}  


// Главная функция
void loop()
{
  
//---------------------------------------------------------------------   
  
  static bool printDone_F1 = false;
  static bool print5secDone_F1 = false;
  static uint32_t lastTim_F1 = 0;
 
  unsigned long tim_F1 = CheckPhase(5, &phaseTime);
 
  if(tim_F1 > 0)
  {
  if (tim_F1 < 5000 && !printDone_F1)
  {
 
   printDone_F1 = true;
  } 
  if (tim_F1 >= 5000 && !print5secDone_F1)
  {
   Serial.print("Фаза 1 - АВАРИЯ ");
   Serial.println(tim_F1);
   print5secDone_F1 = true;
  }
  
  }
  else 
  {
  if (printDone_F1 && !print5secDone_F1)
  {
  Serial.print("Фаза 1 - фазы не было ");
  Serial.println(lastTim_F1);
  }
  
  printDone_F1 = false;
  print5secDone_F1 = false;
  }
  lastTim_F1 = tim_F1;
  
//--------------------------------------------------------------------

  static bool printDone_F2 = false;
  static bool print5secDone_F2 = false;
  static uint32_t lastTim_F2 = 0;
 
  unsigned long tim_F2 = CheckPhase(6, &phaseTime);
  
  if(tim_F2 > 0)
  {
  if (tim_F2 < 5000 && !printDone_F2)
  {
 
   printDone_F2 = true;
  } 
  if (tim_F2 >= 5000 && !print5secDone_F2)
  {
   Serial.print("Фаза 3 - АВАРИЯ ");
   Serial.println(tim_F2);
   print5secDone_F2 = true;
  }
  
  }
  else 
  {
  if (printDone_F2 && !print5secDone_F2)
  {
  Serial.print("Фаза 2 - фазы не было ");
  Serial.println(lastTim_F2);
  }
  
  printDone_F2 = false;
  print5secDone_F2 = false;
  }
  lastTim_F2 = tim_F2;
  
//--------------------------------------------------------------------

  static bool printDone_F3 = false;
  static bool print5secDone_F3 = false;
  static uint32_t lastTim_F3 = 0;
 
  unsigned long tim_F3 = CheckPhase(7, &phaseTime);
  
  if(tim_F3 > 0)
  {
  if (tim_F3 < 5000 && !printDone_F3)
  {
 
   printDone_F3 = true;
  } 
  if (tim_F3 >= 5000 && !print5secDone_F3)
  {
   Serial.print("Фаза 3 - АВАРИЯ ");
   Serial.println(tim_F3);
   print5secDone_F3 = true;
  }
  
  }
  else 
  {
  if (printDone_F3 && !print5secDone_F3)
  {
  Serial.print("Фаза 3 - фазы не было ");
  Serial.println(lastTim_F3);
  }
  
  printDone_F3 = false;
  print5secDone_F3 = false;
  }
  lastTim_F3 = tim_F3;

//----------------------------------------------------------------
 
} // loop()

// Проверка фазы
unsigned long CheckPhase(int numPhase, unsigned long *phaseTime)
{ 
   byte state = digitalRead(numPhase);

   if(state == LOW)
   {
      if(*phaseTime == 0)
      {
        *phaseTime = millis();
      } // if
   } else
   {
      *phaseTime = 0;
   } // if-else
  
   if(*phaseTime != 0 )
   {
   
      return millis() - *phaseTime;
     
   } else
   {
         return 0;
   }
} // CheckPhase()

Что не так делаю?

Без дисплея в порт выводит нормально а с ним нет

Всё

А пасторы Шлагги все падали и падали.))))

Закрывать не буду, всеж песочница и ТС, вроде не хамит.

То ТС, а за тертые посты, предупреждение. В следующий раз, тему в небытие.

Понял, спасибо.

Запутался я совсем то с функциями то с флагами (с нормальным алгоритмом беда).

Всего по чуть чуть а в итоге каша получается.

Если в порт выводить вроде работает как только подключаешь дисплей какое-то кикасо получается !

Скажите если одновременно вызвать функцию для трех пинов она будет работать или нет. Стоит ли с этим возиться?

 //unsigned long timer1 = 0,timer2 = 0,timer3 = 0;


// Проверка фазы
unsigned long CheckPhase(int numPhase, unsigned long &phaseTime);

unsigned long  phaseTime=0;

void setup()
{
pinMode(5, INPUT_PULLUP);
pinMode(6,INPUT_PULLUP);
pinMode(7,INPUT_PULLUP);
Serial.begin(9600);

}  


// Главная функция
void loop()
{
  unsigned long tim_F1 = CheckPhase(5, &phaseTime);
 unsigned long tim_F2 = CheckPhase(6, &phaseTime);
 unsigned long tim_F3 = CheckPhase(7, &phaseTime);

  
 
//------------------------------------------------------  
      Serial.print ("A");  
      Serial.println(tim_F1); 
//------------------------------------------------------

//------------------------------------------------------ 
      Serial.print ("B");   
      Serial.println(tim_F2); 
//------------------------------------------------------

//------------------------------------------------------  
      Serial.print ("C");  
      Serial.println(tim_F3);
//------------------------------------------------------

} // loop()



// Проверка фазы
unsigned long CheckPhase(int numPhase, unsigned long *phaseTime)
{ 
   byte state = digitalRead(numPhase);

   if(!state == LOW)
   {
      if(*phaseTime == 0)
      {
        *phaseTime = millis();
      } // if
   } else
   {
      *phaseTime = 0;
   } // if-else
  
   if(*phaseTime != 0)
   {
      return millis() - *phaseTime;
   } else
   {
      return 0;
   }
} // CheckPhase()

Когда первая фаза пропадает остальные тоже обнуляются.

грубо говоря первой нет 2 сек второй 3 третей 4. А выводит по всем только 2 сек.

Написал код с дисплеем и тремя отдельными функциями.

Можно ли его оптимизировать сделать проще ?

#include "SPI.h"
#include "Adafruit_GFX.h"     // Библиотека обработчика графики
#include "Adafruit_ILI9341.h" // Программные драйвера для дисплеев ILI9341

#define TFT_DC 9              // Пин подключения вывода D/C дисплея
#define TFT_CS 10             // Пин подключения вывода CS дисплея

#define TFT_RST -1            // Если вывод дисплея RESET подключен к питанию или через кнопку RESET на Arduino

//  Mega 2560 Hardware SPI

#define TFT_MOSI 51           // Пин подключения вывода дисплея SDI(MOSI)
#define TFT_CLK 52            // Пин подключения вывода дисплея SCK
#define TFT_MISO 50           // Пин подключения вывода дисплея SDO(MISO)



Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO); 
                                                                                                  // Создаем объект дисплея и сообщаем библиотеке распиновку для работы с графикой

int Size;

unsigned long phaseTime_A=0,phaseTime_B=0,phaseTime_C=0;
int a;
void setup()
{
pinMode(5, INPUT_PULLUP);
pinMode(6,INPUT_PULLUP);
pinMode(7,INPUT_PULLUP);
Serial.begin(9600);
Size=2;
//------------------------------------------------------------------------------------------------------------------
 tft.begin();                                              // Инициализируем начало работы с графическим дисплеем

  tft.setRotation(1);                                       // Переводим дисплей в альбомную ориентацию
  tft.fillScreen(ILI9341_DARKGREY);
 
//-------------------------------------------------------------------------------------------------------------------
  tft.setTextSize(Size);                                  // Определяем размер шрифта для вывода на дисплей
  tft.fillRect (10, 10, 300, 60, ILI9341_WHITE);          
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(90, 30); 
  tft.println(utf8rus("КОНТРОЛЬ ФАЗ"));
  tft.setTextColor(ILI9341_GREEN);                       // Определяем цвет текста для вывода на экран
  
  tft.fillRect (40, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(53,100);                                 // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("A");                                        // Выводим текст

  tft.fillRect (140, 90, 50, 60, ILI9341_WHITE);
    tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(153,100);                                 // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("B");                                        // Выводим текст

   tft.fillRect (240, 90, 50, 60, ILI9341_WHITE);
   tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(253,100);                                // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("C");                                        // Выводим текст

  tft.setTextSize(Size);                                 // Определяем размер шрифта для вывода на дисплей
  tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);   
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(75, 190); 
 tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
  tft.setTextColor(ILI9341_GREEN);                       // Определяем цвет текста для вывода на экран
//--------------------------------------------------  

}  


// Главная функция
void loop()
{

 unsigned long tim_F1 = APhase(5, &phaseTime_A);
 unsigned long tim_F2 = BPhase(6, &phaseTime_B);
 unsigned long tim_F3 = CPhase(7, &phaseTime_C);

 /*
//------------------------------------------------------  
      Serial.print ("A  ");  
      Serial.println(tim_F1); 
//------------------------------------------------------

//------------------------------------------------------ 
      Serial.print ("B  ");   
      Serial.println(tim_F2); 
//------------------------------------------------------

//------------------------------------------------------  
      Serial.print ("C  ");  
      Serial.println(tim_F3);
//------------------------------------------------------
*/


//---------------------------------------------------------------------   
 
  static bool printDone_F1 = false;
  static bool print5secDone_F1 = false;
  static uint32_t lastTim_F1 = 0;
 

 
  if(tim_F1 > 0)
  {
  if (tim_F1 < 5000 && !printDone_F1)
  {
 
   printDone_F1 = true;
  } 
  if (tim_F1 >= 5000 && !print5secDone_F1)
  {
 //  Serial.print("Фаза 1 - АВАРИЯ ");
 //  Serial.println(tim_F1);
 //--------------------------------------------------------------------------
              tft.setTextSize(Size);                                        // Определяем размер шрифта для вывода на дисплей
              tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               
              tft.setTextColor(ILI9341_RED);
              tft.setCursor(75, 190); 
              tft.println(utf8rus("АВАРИЯ ФАЗЫ А"));
              tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран

  tft.fillRect (40, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_RED);
  tft.setCursor(53,100);                                                     // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("A");  
 //--------------------------------------------------------------------------
 
   
   print5secDone_F1 = true;
  }
  
  }
  else 
  {
  
  if (printDone_F1 && !print5secDone_F1)
  { 
   
  //Serial.print("Фаза 1 - фазы не было ");
  //Serial.println(lastTim_F1);
  //-----------------------------------------------------------------------------
               tft.setTextSize(Size);                                   // Определяем размер шрифта для вывода на дисплей
               tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               
               tft.setTextColor(ILI9341_GREEN);
               tft.setCursor(75, 180); 
               tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
               tft.setCursor(30, 205); 
               tft.print(utf8rus("фазы A не было : "));
               tft.print(ceil((lastTim_F1)/1000),0);
               tft.print(utf8rus(" сек"));
               tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран        

  tft.fillRect (40, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(53,100);                                     // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5);  
  tft.print("A");                                            // Выводим текст
  //-----------------------------------------------------------------------------
  }
  
  printDone_F1 = false;
  print5secDone_F1 = false;
  }
  lastTim_F1 = tim_F1;
 
//--------------------------------------------------------------------
 
  static bool printDone_F2 = false;
  static bool print5secDone_F2 = false;
  static uint32_t lastTim_F2 = 0;
 

 
  if(tim_F2 > 0)
  {
  if (tim_F2 < 5000 && !printDone_F2)
  {
 
   printDone_F2 = true;
  } 
  if (tim_F2 >= 5000 && !print5secDone_F2)
  {
  // Serial.print("Фаза 2 - АВАРИЯ ");
  // Serial.println(tim_F2);
//--------------------------------------------------------------------------
              tft.setTextSize(Size);                                        // Определяем размер шрифта для вывода на дисплей
              tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               
              tft.setTextColor(ILI9341_RED);
              tft.setCursor(75, 190); 
              tft.println(utf8rus("АВАРИЯ ФАЗЫ В"));
              tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран

  tft.fillRect (140, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_RED);
  tft.setCursor(153,100);                                   // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("B");                                           // Выводим текст
 //--------------------------------------------------------------------------
 
  
   print5secDone_F2 = true;
  }
  
  }
  else 
  {
  
  if (printDone_F2 && !print5secDone_F2)
  { 
   
 // Serial.print("Фаза 2 - фазы не было ");
 // Serial.println(lastTim_F2);
 //--------------------------------------------------------------------------------
               tft.setTextSize(Size);                                   // Определяем размер шрифта для вывода на дисплей
               tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);              
               tft.setTextColor(ILI9341_GREEN);
               tft.setCursor(75, 180); 
               tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
               tft.setCursor(30, 205); 
               tft.print(utf8rus("фазы B не было : "));
               tft.print(ceil(lastTim_F2/1000),0);
               tft.print(utf8rus(" сек"));
               tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран        
              
  tft.fillRect (140, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(153,100);                                   // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("B");                                           // Выводим текст
 //-----------------------------------------------------------------------------------
  }
  
  printDone_F2 = false;
  print5secDone_F2 = false;
  }
  lastTim_F2 = tim_F2;
//--------------------------------------------------------------------
static bool printDone_F3 = false;
  static bool print5secDone_F3 = false;
  static uint32_t lastTim_F3 = 0;
 

 
  if(tim_F3 > 0)
  {
  if (tim_F3 < 5000 && !printDone_F3)
  {
 
   printDone_F3 = true;
  } 
  if (tim_F3 >= 5000 && !print5secDone_F3)
  {
   //Serial.print("Фаза 3 - АВАРИЯ ");
   //Serial.println(tim_F3);
   //------------------------------------------------------------------------------
                 tft.setTextSize(Size);                                    // Определяем размер шрифта для вывода на дисплей
              tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               
              tft.setTextColor(ILI9341_RED);
              tft.setCursor(75, 190); 
              tft.println(utf8rus("АВАРИЯ ФАЗЫ С"));
              tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран

  tft.fillRect (240, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_RED);
  tft.setCursor(253,100);                                    // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("C");
   //------------------------------------------------------------------------------
   print5secDone_F3 = true;
  }
  
  }
  else 
  {
  
  if (printDone_F3 && !print5secDone_F3)
  { 
   
 // Serial.print("Фаза 3 - фазы не было ");
 // Serial.println(lastTim_F3);
 //----------------------------------------------------------------------------
                tft.setTextSize(Size);                                   // Определяем размер шрифта для вывода на дисплей
               tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               
               tft.setTextColor(ILI9341_GREEN);
               tft.setCursor(75, 180); 
               tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
               tft.setCursor(30, 205); 
               tft.print(utf8rus("фазы C не было : "));
               tft.print(ceil(lastTim_F3/1000),0);
               tft.print(utf8rus(" сек"));
               tft.setTextColor(ILI9341_GREEN);                              // Определяем цвет текста для вывода на экран        

               
  tft.fillRect (240, 90, 50, 60, ILI9341_WHITE);
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(253,100);                                     // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("C");                                             // Выводим текст
 //----------------------------------------------------------------------------
  }
  
  printDone_F3 = false;
  print5secDone_F3 = false;
  }
  lastTim_F3 = tim_F3;
//----------------------------------------------------------------
 
} // loop()

// Проверка фазы
unsigned long APhase(int numPhase, unsigned long *phaseTime_A)
{ 
   byte state = digitalRead(numPhase);

   if(state == HIGH)
   {
      if(*phaseTime_A == 0)
      {
        *phaseTime_A = millis();
      } // if
   } else
   {
      *phaseTime_A = 0;
   } // if-else
  
   if(*phaseTime_A != 0 )
   {
   
      return millis() - *phaseTime_A;
     
   } else
   {
         return 0;
   }
} // CheckPhase()

// Проверка фазы
unsigned long BPhase(int numPhase, unsigned long *phaseTime_B)
{ 
   byte state = digitalRead(numPhase);

   if(state == HIGH)
   {
      if(*phaseTime_B == 0)
      {
        *phaseTime_B = millis();
      } // if
   } else
   {
      *phaseTime_B = 0;
   } // if-else
  
   if(*phaseTime_B != 0 )
   {
   
      return millis() - *phaseTime_B;
     
   } else
   {
         return 0;
   }
} // CheckPhase()

// Проверка фазы
unsigned long CPhase(int numPhase, unsigned long *phaseTime_C)
{ 
   byte state = digitalRead(numPhase);

   if(state == HIGH)
   {
      if(*phaseTime_C == 0)
      {
        *phaseTime_C = millis();
      } // if
   } else
   {
      *phaseTime_C = 0;
   } // if-else
  
   if(*phaseTime_C != 0 )
   {
   
      return millis() - *phaseTime_C;
     
   } else
   {
         return 0;
   }
} // CheckPhase()

  /* Recode russian fonts from UTF-8 to Windows-1251 */

String utf8rus(String source)
{
  int i,k;
  String target;
  unsigned char n;
  char m[2] = { '0', '\0' };
  k = source.length(); i = 0;
  while (i < k) {
    n = source[i]; i++;
    if (n >= 0xBF){
      switch (n) {
        case 0xD0: {
          n = source[i]; i++;
          if (n == 0x81) { n = 0xA8; break; }
          if (n >= 0x90 && n <= 0xBF) n = n + 0x2F;
          break;
        }
       case 0xD1: {
          n = source[i]; i++;
          if (n == 0x91) { n = 0xB7; break; }
          if (n >= 0x80 && n <= 0x8F) n = n + 0x6F;
          break;
        }
      }
    }
    m[0] = n; target = target + String(m);
  }
return target;
}

работает?

зачем? если работает...

А если не работает,  то не оптимизировать надо...

да работает. 

Но что-то подсказывает что можно все сделать проще

правильно подсказывает.

Скажите, вы знаете, зачем нужны процедуры? - чтобы не копировать повторяющийся код. А вы что делаете? - написали процедуру для ФазыА - и потом тупо скопировали ее трижды. Ваши процедуры APhase , BPhase,  Cphase - абсолютно одинаковы, нужно оставить одну и вызывать ее для разных фаз.

Тоже самое относится к коду вывода сообщений на экран - три абсолютно одинаковых куска кода по сотне строк, которые отличаются только именем фазы А В или С.

Ну и еще по мелочи - например вы в сетапе аж 7 раз вызываете tft.setTextColor(ILI9341_GREEN); хотя цвет шрифта у вас не меняется.... тоже самое с размером букв...

про процедуры буду читать (я и догадывался что так можно но как реализовать пока не знаю).

Подскажите хоть маленький пример.

А функцию можно одну использовать для трех фаз как-то

процедуры Фаз у вас написаны верно, все зависимые от конкретной фазы величины передаются как параметры  (что-то мне подсказывает. что написано не вами... ну да ладно)

Поэтому можете в строчках 79-81 заменить во всех трех вызовах процедуру на APhase:

unsigned long tim_F1 = APhase(5, &phaseTime_A);
unsigned long tim_F2 = APhase(6, &phaseTime_B);
unsigned long tim_F3 = APhase(7, &phaseTime_C);

После этого сами процедуры BPhase CPhase из кода можно удалить, они не нужны.

С выводом на экран посложнее - там надо написать такую же процедуру, в которую как параметр будет передаваться имя фазы и координаты на экране.

А как же время &phaseTime_A я ведь в функции unsigned long tim_F1 = APhase(5, &phaseTime_A);

его указываю а не &phaseTime_C

когда вы вызываете процедуру для фазы А, вы в нее передаете параметр phaseTime_A, а когда вызываете для фазы С (строка 81) - то и переджаете параметр phaseTime_С, так что все верно.

А как называется параметр внутри функции - phaseTime_A или еще как - значения не имеет, с переменной phaseTime_A в loop() это две совершенно разные переменные

Чтобы не путаться, я бы вам посоветовал переменовать процедуру APhase в просто PHase - ведь эта процедура теперь не завязана только на фазу А. А параметр phaseTime_A внутри процедуры - на phaseTime

Сейчас попробую. Спасибо Вам за совет.

Работает и код стал меньше.

Удивительно сколько еще всякого можно узнать !!!

 unsigned long tim_F1 = Phase(5, &phaseTime_A);
 unsigned long tim_F2 = Phase(6, &phaseTime_B);
 unsigned long tim_F3 = Phase(7, &phaseTime_C);
unsigned long Phase(int numPhase, unsigned long *phaseTime)
{ 
   byte state = digitalRead(numPhase);

   if(state == HIGH)
   {
      if(*phaseTime == 0)
      {
        *phaseTime = millis();
      } // if
   } else
   {
      *phaseTime = 0;
   } // if-else
  
   if(*phaseTime != 0 )
   {
   
      return millis() - *phaseTime;
     
   } else
   {
         return 0;
   }
} // CheckPhase()

и функция одна и считает все три фазы !!!

А вывод на дисплей наверное не получится - непонятно как на экран в разные места выводить?

ну не настолько они и разные. Достаточно передать в процедуру координаты первой строки текста, а в процедуре все вычислять относительно этой точки

Да код значительно уменьшился когда удалил все лишнее по Вашим советам.

#include "SPI.h"
#include "Adafruit_GFX.h"     // Библиотека обработчика графики
#include "Adafruit_ILI9341.h" // Программные драйвера для дисплеев ILI9341

#define TFT_DC 9              // Пин подключения вывода D/C дисплея
#define TFT_CS 10             // Пин подключения вывода CS дисплея

#define TFT_RST -1            // Если вывод дисплея RESET подключен к питанию или через кнопку RESET на Arduino

//  Mega 2560 Hardware SPI

#define TFT_MOSI 51           // Пин подключения вывода дисплея SDI(MOSI)
#define TFT_CLK 52            // Пин подключения вывода дисплея SCK
#define TFT_MISO 50           // Пин подключения вывода дисплея SDO(MISO)



Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO); 
                              // Создаем объект дисплея и сообщаем библиотеке распиновку для работы с графикой                                                                   

int Size;

unsigned long phaseTime_A=0,phaseTime_B=0,phaseTime_C=0,phaseTime=0;
int a;
void setup()
{
pinMode(5, INPUT_PULLUP);
pinMode(6,INPUT_PULLUP);
pinMode(7,INPUT_PULLUP);
Serial.begin(9600);
Size=2;
//------------------------------------------------------------------------------------------------------------------
 tft.begin();                                              // Инициализируем начало работы с графическим дисплеем

  tft.setRotation(1);                                      // Переводим дисплей в альбомную ориентацию
  tft.fillScreen(ILI9341_DARKGREY);
 
//-------------------------------------------------------------------------------------------------------------------
  tft.setTextSize(Size);                                  // Определяем размер шрифта для вывода на дисплей
  tft.fillRect (10, 10, 300, 60, ILI9341_WHITE);          //созадаем стоп и 1 этаж в начале
  tft.setTextColor(ILI9341_GREEN);
  tft.setCursor(90, 30); 
  tft.println(utf8rus("КОНТРОЛЬ ФАЗ"));
                         
  tft.fillRect (40, 90, 50, 60, ILI9341_WHITE); 
  tft.setCursor(53,100);                                 // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("A");                                        // Выводим текст

  tft.fillRect (140, 90, 50, 60, ILI9341_WHITE);
  tft.setCursor(153,100);                                 // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("B");                                        // Выводим текст

  tft.fillRect (240, 90, 50, 60, ILI9341_WHITE);
  tft.setCursor(253,100);                                // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("C");                                        // Выводим текст

  tft.setTextSize(Size);                                 // Определяем размер шрифта для вывода на дисплей для utf8rus
  tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);   
  tft.setCursor(75, 190); 
  tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));                    
//--------------------------------------------------  

}  


// Главная функция
void loop()
{

 unsigned long tim_F1 = Phase(5, &phaseTime_A);
 unsigned long tim_F2 = Phase(6, &phaseTime_B);
 unsigned long tim_F3 = Phase(7, &phaseTime_C);

//---------------------------------------------------------------------   
 
  static bool printDone_F1 = false;
  static bool print5secDone_F1 = false;
  static uint32_t lastTim_F1 = 0;
 
  if(tim_F1 > 0)
  {
  if (tim_F1 < 5000 && !printDone_F1)
  {
 
   printDone_F1 = true;
  } 
  if (tim_F1 >= 5000 && !print5secDone_F1)
  {
   //  Serial.print("Фаза 1 - АВАРИЯ ");
   //  Serial.println(tim_F1);
//--------------------------------------------------------------------------
              tft.setTextSize(Size);                                        // Определяем размер шрифта для вывода на дисплей
              tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               //созадаем стоп и 1 этаж в начале
              tft.setTextColor(ILI9341_RED);
              tft.setCursor(75, 190); 
              tft.println(utf8rus("АВАРИЯ ФАЗЫ А"));
                                       
  tft.fillRect (40, 90, 50, 60, ILI9341_WHITE);
  tft.setCursor(53,100);                                                     // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("A");  
//--------------------------------------------------------------------------
 
   
   print5secDone_F1 = true;
  }
  
  }
  else 
  {
  
  if (printDone_F1 && !print5secDone_F1)
  { 
   
  //Serial.print("Фаза 1 - фазы не было ");
  //Serial.println(lastTim_F1);
  //-----------------------------------------------------------------------------
               tft.setTextSize(Size);                                   // Определяем размер шрифта для вывода на дисплей
               tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);              
               tft.setTextColor(ILI9341_GREEN);
               tft.setCursor(75, 180); 
               tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
               tft.setCursor(30, 205); 
               tft.print(utf8rus("фазы A не было : "));
               tft.print(ceil((lastTim_F1)/1000),0);
               tft.print(utf8rus(" сек"));
                                           
  tft.fillRect (40, 90, 50, 60, ILI9341_WHITE);
  tft.setCursor(53,100);                                     // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5);  
  tft.print("A");                                            // Выводим текст
//-----------------------------------------------------------------------------
  }
  
  printDone_F1 = false;
  print5secDone_F1 = false;
  }
  lastTim_F1 = tim_F1;
 
//--------------------------------------------------------------------
 
  static bool printDone_F2 = false;
  static bool print5secDone_F2 = false;
  static uint32_t lastTim_F2 = 0;
  
  if(tim_F2 > 0)
  {
  if (tim_F2 < 5000 && !printDone_F2)
  {
 
   printDone_F2 = true;
  } 
  if (tim_F2 >= 5000 && !print5secDone_F2)
  {
  // Serial.print("Фаза 2 - АВАРИЯ ");
  // Serial.println(tim_F2);
//--------------------------------------------------------------------------
              tft.setTextSize(Size);                                        // Определяем размер шрифта для вывода на дисплей
              tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               
              tft.setTextColor(ILI9341_RED);
              tft.setCursor(75, 190); 
              tft.println(utf8rus("АВАРИЯ ФАЗЫ В"));
                                                 
  tft.fillRect (140, 90, 50, 60, ILI9341_WHITE);
  tft.setCursor(153,100);                                   
  tft.setTextSize(5); 
  tft.print("B");                                           
//-------------------------------------------------------------------------- 
   print5secDone_F2 = true;
  }  
  }
  else 
  {  
  if (printDone_F2 && !print5secDone_F2)
  { 
// Serial.print("Фаза 2 - фазы не было ");
// Serial.println(lastTim_F2);
//--------------------------------------------------------------------------
               tft.setTextSize(Size);                                        // Определяем размер шрифта для вывода на дисплей
               tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               
               tft.setTextColor(ILI9341_GREEN);
               tft.setCursor(75, 180); 
               tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
               tft.setCursor(30, 205); 
               tft.print(utf8rus("фазы B не было : "));
               tft.print(ceil(lastTim_F2/1000),0);
               tft.print(utf8rus(" сек"));
                                                          
  tft.fillRect (140, 90, 50, 60, ILI9341_WHITE);
  tft.setCursor(153,100);                                   // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("B");                                           // Выводим текст
//-----------------------------------------------------------------------------------
  }
  
  printDone_F2 = false;
  print5secDone_F2 = false;
  }
  lastTim_F2 = tim_F2;
//--------------------------------------------------------------------
  static bool printDone_F3 = false;
  static bool print5secDone_F3 = false;
  static uint32_t lastTim_F3 = 0;
  
  if(tim_F3 > 0)
  {
  if (tim_F3 < 5000 && !printDone_F3)
  {
 
   printDone_F3 = true;
  } 
  if (tim_F3 >= 5000 && !print5secDone_F3)
  {
   //Serial.print("Фаза 3 - АВАРИЯ ");
   //Serial.println(tim_F3);
   //------------------------------------------------------------------------------
              tft.setTextSize(Size);                                    // Определяем размер шрифта для вывода на дисплей
              tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               //созадаем стоп и 1 этаж в начале
              tft.setTextColor(ILI9341_RED);
              tft.setCursor(75, 190); 
              tft.println(utf8rus("АВАРИЯ ФАЗЫ С"));
                                          
  tft.fillRect (240, 90, 50, 60, ILI9341_WHITE);
  tft.setCursor(253,100);                                    // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("C");
   //------------------------------------------------------------------------------
   print5secDone_F3 = true;
  }
  
  }
  else 
  {
  
  if (printDone_F3 && !print5secDone_F3)
  { 
   
 // Serial.print("Фаза 3 - фазы не было ");
 // Serial.println(lastTim_F3);
 //----------------------------------------------------------------------------
               tft.setTextSize(Size);                                   // Определяем размер шрифта для вывода на дисплей
               tft.fillRect (10, 170, 300, 60, ILI9341_WHITE);               //созадаем стоп и 1 этаж в начале
               tft.setTextColor(ILI9341_GREEN);
               tft.setCursor(75, 180); 
               tft.println(utf8rus("ПИТАНИЕ В НОРМЕ"));
               tft.setCursor(30, 205); 
               tft.print(utf8rus("фазы C не было : "));
               tft.print(ceil(lastTim_F3/1000),0);
               tft.print(utf8rus(" сек"));
                                                        
  tft.fillRect (240, 90, 50, 60, ILI9341_WHITE);
  tft.setCursor(253,100);                                     // Определяем координаты верхнего левого угла области вывода
  tft.setTextSize(5); 
  tft.print("C");                                             // Выводим текст
 //----------------------------------------------------------------------------
  }
  
  printDone_F3 = false;
  print5secDone_F3 = false;
  }
  lastTim_F3 = tim_F3;
//----------------------------------------------------------------
 
} // loop()

// Проверка фазы
unsigned long Phase(int numPhase, unsigned long *phaseTime)
{ 
   byte state = digitalRead(numPhase);

   if(state == HIGH)
   {
      if(*phaseTime == 0)
      {
        *phaseTime = millis();
      } // if
   } else
   {
      *phaseTime = 0;
   } // if-else
  
   if(*phaseTime != 0 )
   {
   
      return millis() - *phaseTime;
     
   } else
   {
         return 0;
   }
} // CheckPhase()

  /* Recode russian fonts from UTF-8 to Windows-1251 */

String utf8rus(String source)
{
  int i,k;
  String target;
  unsigned char n;
  char m[2] = { '0', '\0' };
  k = source.length(); i = 0;
  while (i < k) {
    n = source[i]; i++;
    if (n >= 0xBF){
      switch (n) {
        case 0xD0: {
          n = source[i]; i++;
          if (n == 0x81) { n = 0xA8; break; }
          if (n >= 0x90 && n <= 0xBF) n = n + 0x2F;
          break;
        }
       case 0xD1: {
          n = source[i]; i++;
          if (n == 0x91) { n = 0xB7; break; }
          if (n >= 0x80 && n <= 0x8F) n = n + 0x6F;
          break;
        }
      }
    }
    m[0] = n; target = target + String(m);
  }
return target;
}

еще раза в два можно сократить точно

Я еще не знаю как в процедуру  передавать координаты.

Вопрос: когда я задаю пин это же одно и тоже (передаю в процедуру номер пина) ?

Не то наверное

ну вот когда вы вызываете

unsigned long tim_F1 = APhase(5, &phaseTime_A);

- вы передаете в процедуру два параметра, номер пина и таймер. Первый параметр передается по значению, а второй по ссылке

Идею понял но пока даже не могу сообразить - буду искать в интернете

А вообще, вам стоит отложить на денек написание кода, найти учебник и проштудировать главу "процедуры и функции". Там обязательно будет и передача параметров

Понял учим процедуры и функции более детально

Практики нет как карандаш в стакане с ними !!!