Arduino.ru

вы можете словами описать чего вы хотите добиться (в целом) и как по вашему мнению это описывает код ? 

Ну чего я хочу добиться? избавиться от delay в коде в местах где он есть. пауза должна произайти но без delay.

Я могу выложить весь проэкт целиком и объяснять на три листа что к чему и как должно работать, но есть ли в этом смысл? Если есть я напишу, мне не сложно.

Что ж в нём такого ужасного и беспощадного?

Т.е. delay в общем-то не мешает, а цель не достичь каких-то результатов, а просто избаиться от delay? Правильно? А для чего от него избавляться? Ради упражнения? Ну, тогда сами упражняйтесь, мы ты Вам зачем?

Или есть какая-то другая цель, которую Вы от нас скрываете?

Нет конечно не в упражнении:))  Цель избавления в том что, пока происходят эти delay замедляется работа программы. Остальной код стоит. А мне нужен мгновенный отклик программы на изменения в датчиках, что бы мгновенно их отобразить на дисплее.

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

--------------

"Избавиться от делей" - фраза бессодержательна вообще.

Потому, как делей не заменяется ни на что. Код без делей совершенно по другому проектируется. Посмотри на "блинк без делей". Тебе нужно понимать, что при проектировании коде без делей, твой МК совершает действия в РАЗНЫЕ входы в функцию loop(). Соответственно завершив одну активность ты должен запонить время и проверять его при каждом входе в loop(), как только прошло нужное - выполнить следующую активность и снова запомнить время. Если активностей много, то проще запомнить номер той, которую планируешь выполнить и время начала отсчета.

Ну, тогда приведите маленький, но полный (чтобы запустить можно было) пример в котором была бы понятна проблема. А то из того, что Вы привели никак не следует наличие какого-то другого кода, и никак непонятно что там за код такой. А от этого во-многом зависит то, как следует поступить. Например, если там всё на прерываниях, то и плевать на делэй с высокого уровня.

Вот общий пример "Как избавиться от трупа delay()" :

//код с delay
void loop() 
{
    {
        activity1;
    }
    delay(dly1);
    {
        activity2;
    }
    delay(dly2);
    {
        activity3;
    }
    delay(dly3);
    {
        activity4;
    }
    delay(dly4);
    {
        activity5;
    }
    delay(dly5);
    }
===============================
//Для "избавления от delay" можно переделать в такое:

void loop()
{
    static byte activityCode = 1;           //начальная активность
    static uint32_t currentDelay = 0;       //начальная задержка
    static uint32_t oldMillis = millis();
    uint32_t currentMillis = millis();

    if (currentMillis - currentDelay > oldMillis)
    {
        switch (activityCode)
        {
        case 1:
            activity1;
            oldMillis = currentMillis;
            currentDelay = dly1; //следующая задержка
            activityCode = 2;    //следующая активность
            break;
        case 2:
            activity2;
            oldMillis = currentMillis;
            currentDelay = dly2;
            activityCode = 3;
            break;
        case 3:
            activity3;
            oldMillis = currentMillis;
            currentDelay = dly3;
            activityCode = 4;
            break;
        case 4:
            activity4;
            oldMillis = currentMillis;
            currentDelay = dly4;
            activityCode = 5;
            break;
        case 5:
            activity5;
            oldMillis = currentMillis;
            currentDelay = dly5;
            activityCode = 1;
            break;
        }
    }
}

Я не програмист и не имею опыта общения с програмистами, наверное просто не умею задавать корректно вопросы по этой теме.

Сейчас ниже выложу программу целиком

Одна из причин почему не стал выкладывать код целиком это то что, боюсь за такой код вы меня просто из интренета удалите)) Понимаю что код не грамотен, но пишу как получается.

Под DUE код.

Установлено в авто, подключено к штатному монитору.

//  monitor switch
//===============================================================================


  if (key == 0)
  {    
    digitalWrite(49,LOW);  //отключаем    YELLOW  ARDUINO
    //delay(50);
    digitalWrite(47,LOW);  //переключаем ORANGE  SYNC
    //delay(50);
    digitalWrite(51,LOW); //включаем   GREEN   HONDA
  }
  if (key == 1)
  {    
    digitalWrite(51,HIGH); //отключаем   GREEN   HONDA
    //delay(50);
    digitalWrite(47,HIGH);  //переключаем ORANGE  SYNC
    //delay(50);
    digitalWrite(49,HIGH);  //включаем    YELLOW  ARDUINO
  }

//===============================================================================

Контроллер переключает источник видео сигнала с помощью реле. Чтобы перключать без помех нужно сначало отключить сигнал, затем переключить сигнал синхронизации и только потом подключить другой сигнал.

Между этими действиями должна быть задержка в 50 милисекунд, обусловленна эта необходимость физической работой реле.

//  Revers, Button
//===============================================================================
  


if (digitalRead(53) == HIGH) 
  {
    revers = 1;               //Revers включен
    delay(700);
    key = 0;
  }
  else
  {
    revers = 0;               //Revers отключен
    
    if (key==0)
    {
      key = beginkey;
      value = analogRead(3);

  if ( value < 1000) {
    button = 1;
    if(key == 0) {
      key = 1;
      beginkey = 1; 
    }
    else {
      key = 0;
      beginkey = 0;
    }
  }
    }
    
    else
    
    {
      value = analogRead(3);

  if ( value < 1000) {
    button = 1;
    if(key == 0) {
      key = 1;
      beginkey = 1; 
    }
    else {
      key = 0;
      beginkey = 0;
    }
  }
    }
  }


//===============================================================================

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

Все так и работает, но мне просто нужно сменить источник сигнала не мгновенно, а пока запустится камера в авто, примерно 700 милисекунд.

Ниже код целиком и схема. 

//===============================================================================
// Подключаем библиотеки
//===============================================================================
#include <VGA.h>

//===============================================================================
//  Константы
//===============================================================================
// Связанные с термистором:

/* Здесь у нас несколько констант, которые упрощают редактирование кода.
   Пройдемся по ним.

   Чтение из АЦП может дать одно значение при одной выборке, а затем немного
   отличающееся значение при следующей выборке. Чтобы избежать влияния шумов,
   мы можем считывать значения с вывода АЦП несколько раз, а затем усреднять
   значения, чтобы получить более постоянное значение. Эта константа используется
   в функции readThermistor. */
const int    SAMPLE_NUMBER      = 10;

/* Чтобы использовать бета уравнение, мы должны знать номинал второго резистора
   в нашем делителе. Если вы используете резистор с большим допуском, например,
   5% или даже 1%, измерьте его и поместите результат в омах сюда. */
const float SERIAL_R           = 10300.0;

// Это помогает вычислять сопротивление термистора (подробности смотрите в статье).
const float MAX_ADC            = 4095.0;

/* Эта константа зависит от термистора и должна быть в техническом описании, или
   смотрите статью, как рассчитать ее, используя бета-уравнение. */
const float B                 = 3448.0;

/* Необходима для уравнения преобразования в качестве "типовой" комнатной
   температуры. */
const float NOMINAL_T         = 40;   // комнатная температура в Кельвинах

/* Термисторы обладают типовым сопротивлением при комнатной температуре,
   укажем его здесь. Опять же, необходимо для уравнения преобразования. */
const float THERMISTOR_R      = 5760.0;

//===============================================================================
//  Переменные
//===============================================================================
// Здесь мы будем хранить текущую температуру
float currentTemperature = 0;
float currentPressure = 0;
float currentRTemperature = 0;
float currentVPressure = 0;

//===============================================================================
//  Объявления выводов
//===============================================================================
// Входы:
int thermistorPin = 1;  // Вход АЦП, выход делителя напряжения
int pressurePin = 2;    // Вход АЦП, выход делителя напряжения

//определяем переменные для хранения измеряего значения
int x, y, a, b, c, d;
int button, keyv, value;
int button_state, button_mem; 
int key = 1;
int beginkey = 1;
int revers = 0;


//OBD

int tmpVal = 0;
int rpmVal = 0;
int speedVal = 0;

char rxData[20];
char rxIndex=0;


char incomingbyte = '-';





//===============================================================================

//  Инициализация
//===============================================================================
void setup() 
{ 
  // Установить скорость порта для отправки сообщений
  SerialUSB.begin(9600);
  Serial3.begin(38400);

  analogReadResolution(12);
  
  VGA.setMonitorFreqRange(16100, 29700, 58, 62);
  //VGA.setMonitorFreqRange(16500, 30000, 60, 64); рабочий вариант 304 240
  VGA.begin(320,238,VGA_COLOUR);
  delay(100);
  
  pinMode(51, OUTPUT);          // GREEN   HONDA   sets the digital pin 51 as output
  pinMode(49, OUTPUT);          // YELLOW  ARDUINO sets the digital pin 49 as output
  pinMode(47, OUTPUT);          // ORANGE  SYNC    sets the digital pin 47 as output

  pinMode(53, INPUT);           // ------  ATPR    sets the digital pin 53 as output

  Serial3.println("ATSP7");
  //Serial3.println("ATZ");
  delay(100);
  Serial3.flush();
}

//===============================================================================

//  Основной цикл
//===============================================================================
void loop()
{
  Serial3.flush();
   // text colour
  VGA.setInk(255);

//===============================================================================
//  Revers, Button
//===============================================================================
  


if (digitalRead(53) == HIGH) 
  {
    revers = 1;               //Revers включен
    delay(700);
    key = 0;
  }
  else
  {
    revers = 0;               //Revers отключен
    
    if (key==0)
    {
      key = beginkey;
      value = analogRead(3);

  if ( value < 1000) {
    button = 1;
    if(key == 0) {
      key = 1;
      beginkey = 1; 
    }
    else {
      key = 0;
      beginkey = 0;
    }
  }
    }
    
    else
    
    {
      value = analogRead(3);

  if ( value < 1000) {
    button = 1;
    if(key == 0) {
      key = 1;
      beginkey = 1; 
    }
    else {
      key = 0;
      beginkey = 0;
    }
  }
    }
  }


//===============================================================================
//  monitor switch
//===============================================================================


  if (key == 0)
  {    
    digitalWrite(49,LOW);  //отключаем    YELLOW  ARDUINO
    //delay(50);
    digitalWrite(47,LOW);  //переключаем ORANGE  SYNC
    //delay(50);
    digitalWrite(51,LOW); //включаем   GREEN   HONDA
  }
  if (key == 1)
  {    
    digitalWrite(51,HIGH); //отключаем   GREEN   HONDA
    //delay(50);
    digitalWrite(47,HIGH);  //переключаем ORANGE  SYNC
    //delay(50);
    digitalWrite(49,HIGH);  //включаем    YELLOW  ARDUINO
  }

//===============================================================================
//  
//===============================================================================


  
  currentTemperature = readThermistor();
  currentPressure = readPressure();


  //Serial.print(", t=");
  //Serial.println(currentTemperature,0);
  //Serial.print(", p=");
  //Serial.println(currentPressure,1);  

  //VGA.drawLine(int x0, int y0, int x1, int y1, int col);
  VGA.drawLine(0, 2, 312, 2, 90);       //горизонтальная верхняя
  VGA.drawLine(0, 234, 312, 234, 90);   // горизонтальная нижняя
  VGA.drawLine(0, 2, 0, 234, 90);       //вертикальная левая
  VGA.drawLine(312, 0, 312, 234, 90);   //вертикальная правая
  
  // text colour
  VGA.setInk(255);

  // VGA.moveCursor(int column, int line);
  VGA.moveCursor(6, 2);
  VGA.print("OIL");
  
  VGA.moveCursor(2, 4);
  VGA.print("Press");
  VGA.moveCursor(3, 6);
  VGA.print("    ");
  VGA.moveCursor(3, 6);
  VGA.print(currentPressure,1);
  
  VGA.moveCursor(9, 4);
  VGA.print("Temp");
  VGA.moveCursor(10, 6);
  VGA.print("    ");
  VGA.moveCursor(10, 6);
  VGA.print(currentTemperature,0);
  
//===============================================================================

//  OIL Pressure
//===============================================================================
  VGA.drawLine(10, 200, 20, 200, 255);  //0
  VGA.drawLine(19, 195, 20, 195, 255);  //0.25
  VGA.drawLine(18, 190, 20, 190, 255);  //0.5
  VGA.drawLine(19, 185, 20, 185, 255);  //0.75
  VGA.drawLine(15, 180, 20, 180, 255);  //1
  VGA.drawLine(15, 162, 20, 162, 255);  //2
  VGA.drawLine(15, 143, 20, 143, 255);  //3
  VGA.drawLine(15, 124, 20, 124, 255);  //4
  VGA.drawLine(10, 104, 20, 104, 255);  //5
  VGA.drawLine(15, 86, 20, 86, 255);  //6
  VGA.drawLine(10, 65, 20, 65, 255);  //7
  

  
  VGA.drawLine(25, 85, 25, 200, 90);
  VGA.drawLine(45, 85, 45, 200, 90);
  VGA.drawLine(25, 65, 25, 85, 224);
  VGA.drawLine(45, 65, 45, 85, 224);
  VGA.drawLine(25, 64, 45, 64, 224);
  
  
  
  if (currentPressure>= 6)
  {
    VGA.fillRect(25, 86, 45, 200, 90); //green
    c = 200 - (currentPressure*19);
    if(c<=65)
    {
      VGA.fillRect(25, 65, 45, 85, 224); //red
    }
    else
    {
      VGA.fillRect(25, c, 45, 85, 224); //red
      VGA.fillRect(26, 65, 44, c, 0);   // black
    }
    
  }
  else
  {
    c = 200 - (currentPressure*19);
    VGA.fillRect(25, c, 45, 200, 90); //green
    d = 199 - (currentPressure*19);
    VGA.fillRect(26, 65, 44, d, 0);   // black
  }
//===============================================================================

//  OIL Temp
//===============================================================================
  VGA.drawLine(62, 200, 72, 200, 255);  //0
  VGA.drawLine(67, 188, 72, 188, 255);  //10
  VGA.drawLine(67, 177, 72, 177, 255);  //20
  VGA.drawLine(67, 166, 72, 166, 255);  //30
  VGA.drawLine(67, 155, 72, 155, 255);  //40
  VGA.drawLine(62, 144, 72, 144, 255);  //50
  VGA.drawLine(67, 133, 72, 133, 255);  //60
  VGA.drawLine(67, 122, 72, 122, 255);  //70
  VGA.drawLine(67, 111, 72, 111, 255);  //80
  VGA.drawLine(67, 100, 72, 100, 255);  //90
  VGA.drawLine(67, 90, 72, 90, 255);  //100
  VGA.drawLine(62, 84, 72, 84, 255);  //105
  VGA.drawLine(67, 78, 72, 78, 255);  //110
  VGA.drawLine(67, 72, 72, 72, 255);  //115
  VGA.drawLine(62, 65, 72, 65, 255);  //120
  
  VGA.drawLine(77, 85, 77, 200, 90);
  VGA.drawLine(97, 85, 97, 200, 90);
  VGA.drawLine(77, 65, 77, 85, 224);
  VGA.drawLine(97, 65, 97, 85, 224);
  VGA.drawLine(77, 64, 97, 64, 224);
  
  
  
  if (currentTemperature>= 105)
  {
    VGA.fillRect(77, 86, 97, 200, 90); //green
    c = 200 - (currentTemperature*1.1);
    VGA.moveCursor(20, 20);
    VGA.print(c,1);
    VGA.print("    ");
    if(c<=65)
    {
      VGA.fillRect(77, 65, 97, 85, 224); //red
    }
    else
    {
      VGA.fillRect(77, c, 97, 85, 224); //red
      VGA.fillRect(78, 65, 96, c, 0);   // black
    }
    
  }
  else
  {
    c = 200 - (currentTemperature*1.1);
    if(c>=200)
    {
     VGA.drawLine(77, 200, 97, 200, 90);
    }
    else
    {
      
      VGA.fillRect(77, c, 97, 200, 90); //green
      d = 199 - (currentTemperature*1.1);
      VGA.fillRect(78, 65, 96, d, 0);   // black
    }
  }
//===============================================================================


  VGA.moveCursor(20, 2);
  VGA.print("Wather");
  
  
  VGA.moveCursor(21, 4);
  VGA.print("Temp");
  VGA.moveCursor(22, 6);
  VGA.print("    ");
  VGA.moveCursor(22, 6);
  VGA.print(tmpVal);
  VGA.waitSync();

  VGA.moveCursor(30, 2);
  VGA.print("Engine");
  
  
  VGA.moveCursor(31, 4);
  VGA.print("RPM");
  VGA.moveCursor(31, 6);
  VGA.print("    ");
  VGA.moveCursor(31, 6);
  VGA.print(rpmVal);
  VGA.waitSync();

  VGA.moveCursor(31, 8);
  VGA.print("Speed");
  VGA.moveCursor(31, 9);
  VGA.print("    ");
  VGA.moveCursor(31, 9);
  VGA.print(speedVal);
  VGA.waitSync();

  
  
  
  

//===============================================================================

//  OBD Temp
//===============================================================================

  Serial3.flush();
  
  if(Serial3.available() > 0)
  {
  incomingbyte =Serial3.read();
  }
  if (incomingbyte== '>')
  {
    Serial3.println("0105");
    getResponse();
    getResponse();
    tmpVal = (strtol(&rxData[6],0,16)-40);

  }
//===============================================================================










    VGA.waitSync();
}

//===============================================================================

//  Функции
//===============================================================================


/////////////////////////////
////// readThermistor ///////
/////////////////////////////
/*
Эта функция считывает значения с аналогового вывода, как показано ниже.
Преобразует входное напряжение в цифровое представление с помощью аналого-цифрового
преобразования. Однако, это выполняется несколько раз, чтобы мы могли
усреднить значение, чтобы избежать ошибок измерения.
Это усредненное значение затем используется для расчета сопротивления термистора.
После этого сопротивление используется для расчета температуры термистора.
Наконец, температура преобразуется в градусы Цельсия. 
*/

float readThermistor() 
{
  // переменные
  float steinhart;                  // Хранит температуру в градусах Цельсия
  float adcAverage  = 0;            // Хранит среднее значение напряжения
  int   adcSamples[SAMPLE_NUMBER];  // Массив для хранения отдельных результатов
                                    // измерений напряжения

  /* Рассчитать среднее сопротивление термистора:
     Как упоминалось выше, мы будем считывать значения АЦП несколько раз,
     чтобы получить массив выборок. Небольшая задержка используется для
     корректной работы функции analogRead. */
  
  for (int i = 0; i < SAMPLE_NUMBER; i++) 
  {
    adcSamples[i] = analogRead(thermistorPin);  // прочитать значение на выводе и сохранить
    delay(3);        // ждем 10 миллисекунд
  }

  /* Затем мы просто усредняем все эти выборки для "сглаживания" измерений. */
  for (int i = 0; i < SAMPLE_NUMBER; i++) 
  {
    adcAverage += adcSamples[i];      // складываем все выборки . . .
  }
  adcAverage /= SAMPLE_NUMBER;        // . . . усредняем их с помощью деления

  /* Здесь мы рассчитываем сопротивление термистора, используя уравнение,
     описываемое в статье. */
    int t =  adcAverage;
    float tr = MAX_ADC / t - 1;
    tr = SERIAL_R / tr;

  /* Здесь используется бета-уравнение, но оно отличается от того, что 
     описывалось в статье. Не беспокойтесь! Оно было перестроено, чтобы
     получить более "красивую" формулу. Попробуйте сами упростить уравнение,
     чтобы поупражняться в алгебре. Или просто используйте показанное здесь
     или то, что приведено в статье. В любом случае всё будет работать! */
    steinhart = tr / THERMISTOR_R; // (R/Ro)
    steinhart = log(steinhart); // ln(R/Ro)
    steinhart /= B; // 1/B * ln(R/Ro)
    steinhart += 1.0 / (NOMINAL_T + 273.15); // + (1/To)
    steinhart = 1.0 / steinhart; // Invert

  /* Я буду использовать градусы Цельсия для отображения температуры.
     Я сделал это, чтобы увидеть типовую комнатную температуру, которая
     составляет 25 градусов Цельсия. */
    steinhart -= 273.15; 

  return steinhart;    // вернуть температуру в градусах Цельсия
}

/////////////////////////////
////// readPressure ///////
/////////////////////////////
/*
Эта функция считывает значения с аналогового вывода, как показано ниже.
Преобразует входное напряжение в цифровое представление с помощью аналого-цифрового
преобразования. Однако, это выполняется несколько раз, чтобы мы могли
усреднить значение, чтобы избежать ошибок измерения.
Это усредненное значение затем используется для расчета сопротивления термистора.
После этого сопротивление используется для расчета температуры термистора.
Наконец, температура преобразуется в градусы Цельсия. 
*/

float readPressure() 
{
  // переменные
  float pressure;                  // Хранит температуру в градусах Цельсия
  float adcAverage  = 0;            // Хранит среднее значение напряжения
  int   adcSamples[SAMPLE_NUMBER];  // Массив для хранения отдельных результатов
                                    // измерений напряжения

  /* Рассчитать среднее сопротивление термистора:
     Как упоминалось выше, мы будем считывать значения АЦП несколько раз,
     чтобы получить массив выборок. Небольшая задержка используется для
     корректной работы функции analogRead. */
  
  for (int i = 0; i < SAMPLE_NUMBER; i++) 
  {
    adcSamples[i] = analogRead(pressurePin);  // прочитать значение на выводе и сохранить
    delay(3);        // ждем 10 миллисекунд
  }

  /* Затем мы просто усредняем все эти выборки для "сглаживания" измерений. */
  for (int i = 0; i < SAMPLE_NUMBER; i++) 
  {
    adcAverage += adcSamples[i];      // складываем все выборки . . .
  }
  adcAverage /= SAMPLE_NUMBER;        // . . . усредняем их с помощью деления

  /* Здесь мы рассчитываем давление, используя уравнение. */
  pressure = adcAverage/4095.0*3300 ;
  pressure = (0.00386 * pressure)- 1.418;
  if (pressure <= 0)
  {
    pressure = 0;
  }
  return pressure;
}



/////////////////////////////
////// readOBD ///////
/////////////////////////////

void getResponse(void){
  char inChar=0;
  while(inChar != '\r'){
    if(Serial3.available() > 0){
      if(Serial3.peek() == '\r'){
        inChar=Serial3.read();
        rxData[rxIndex]='\0';
        rxIndex=0;
      }
      else{
        inChar = Serial3.read();
        rxData[rxIndex++]=inChar;
        //delay(100);
        //SerialUSB.print(inChar);
        //VGA.moveCursor(21, 19);
        //VGA.print(inChar);
        //incomingbyte ='-';
        
        
      }
    }
  }
}

Да, удалят Вас не за это, а за то, что читать не умеете. Я Вам ясно написал

А Вы что привели? Вы не можете написать маленький код, иллюстрирующий проблему? Значит, Вы пока её (проблему) не осознаёте, работайте дальше.

А разбираться в такой простыне ... ну, может найдутся любители.

Я и написал всю суть с самого начала. И написал проблемные куски, подругому я их не могу написать потому что они именно такие. 

Указал отдельно, не устроило, написал целликом, опять не устроило.

Я как должен написать рабочий маленький код когда аппартной части у вас нет?

Прошли бы мимо.

delay (700);
key=0;

unsigned long lastMillis;

void setup() {
}

void loop() {
  ......

  if ((millis()-lastMillis)>= 700) { 
    lastMillis=millis();
    key=0;
  }

...

}

Эту простыню  читать врядли кто станет.

Я тоже, пожалуй, мимо. А ты обращайся к автору этой  херни ...программы.

-------------------

И да, как ты понимаешь свою задержку в 700мс между двумя операторами, которые ничего никуда не выводят? ;))))))))))

Отвечать не нужно.

"Погодите, медведь, не ревите,
объясните, чего вы хотите?
А в ответ, только му да му,
А к чему, почему, непойму.
Повесьте пожалуйста трубку." (с).

А за три года, можно было и блинку без делеев почитать. Считаете, что нахамив Евгению, повысили шансы на помощь?

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

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

Авторитно подхамить это позволительно, а на грубость ответить тем же нельзя.

Я считаю что евгений начал хамить. 

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

Не, не, как и у Дракулы, вопрос риторический был.

Евгений хамит ?! Где? Покажите пальцем.

Евгений, здесь, один из самых вежливых и терпеливых профи.

Постом выше того где якобы я нахамил предложением пройти мимо.

Такое же хамство как и от меня в ответ

Всем кто ответил по делу пытаясь помочь спасибо, я буду читать, изучать, пробовать.

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

//определяем переменные для хранения измеряего значения
int x, y, a, b, c, d;
int button, keyv, value;
int button_state, button_mem; 
int key = 1;
int beginkey = 1;
int revers = 0;






void setup() 
{ 

  
  pinMode(51, OUTPUT);          // GREEN   HONDA   sets the digital pin 51 as output
  pinMode(49, OUTPUT);          // YELLOW  ARDUINO sets the digital pin 49 as output
  pinMode(47, OUTPUT);          // ORANGE  SYNC    sets the digital pin 47 as output

}


void loop()
{
  


if (digitalRead(53) == HIGH) 
  {
    revers = 1;               //Revers включен
    delay(700);
    key = 0;
  }
  else
  {
    revers = 0;               //Revers отключен
    
    if (key==0)
    {
      key = beginkey;
      value = analogRead(3);

  if ( value < 1000) {
    button = 1;
    if(key == 0) {
      key = 1;
      beginkey = 1; 
    }
    else {
      key = 0;
      beginkey = 0;
    }
  }
    }
    
    else
    
    {
      value = analogRead(3);

  if ( value < 1000) {
    button = 1;
    if(key == 0) {
      key = 1;
      beginkey = 1; 
    }
    else {
      key = 0;
      beginkey = 0;
    }
  }
    }
  }


//===============================================================================
//  monitor switch
//===============================================================================


  if (key == 0)
  {    
    digitalWrite(49,LOW);  //отключаем    YELLOW  ARDUINO
    //delay(50);
    digitalWrite(47,LOW);  //переключаем ORANGE  SYNC
    //delay(50);
    digitalWrite(51,LOW); //включаем   GREEN   HONDA
  }
  if (key == 1)
  {    
    digitalWrite(51,HIGH); //отключаем   GREEN   HONDA
    //delay(50);
    digitalWrite(47,HIGH);  //переключаем ORANGE  SYNC
    //delay(50);
    digitalWrite(49,HIGH);  //включаем    YELLOW  ARDUINO
  }


}

Ну, давайте разберемся с 33 строкой delay(700)

//определяем переменные для хранения измеряего значения
int x, y, a, b, c, d;
int button, keyv, value;
int button_state, button_mem;
int key = 1;
int beginkey = 1;
int revers = 0;
unsigned long lastMillis;
boolean flag1;
void setup()

{

 

  pinMode(51, OUTPUT);          // GREEN   HONDA   sets the digital pin 51 as output
  pinMode(49, OUTPUT);          // YELLOW  ARDUINO sets the digital pin 49 as output
  pinMode(47, OUTPUT);          // ORANGE  SYNC    sets the digital pin 47 as output
flag1=false;
}

void loop()

{

if (digitalRead(53) == HIGH)
  {
    revers = 1;               //Revers включен
    if(flag1==false){
flag1=true;
 lastMillis=millis();
}
if((millis()- lastMillis)>=700) key = 0;
  }
  else
  {
    revers = 0;               //Revers отключен
    flag1=false;
}

 Как-то так

Чтобы избавиться от delay... нужно поменять своё мировозрение... "смотреть ширше"... для начала...

У вас же там крутотень атмэловская... с каким-то типа железом... а вы как с детской лопаткой в песочнице...

Такие проблемы решаются при помощи конечных автоматов, прерываний, ОС, программных таймеров и хардварных таймеров... на выбор... Не всё это, правда, вяжется с концепцией ардуины... но это уже вам решать...

//определяем переменные для хранения измеряего значения
int x, y, a, b, c, d;
int button, keyv, value;
int button_state, button_mem;
int key = 1;
int beginkey = 1;
int revers = 0;
unsigned long lastMillis;
boolean flag1;
void setup()

{

 

  pinMode(51, OUTPUT);          // GREEN   HONDA   sets the digital pin 51 as output
  pinMode(49, OUTPUT);          // YELLOW  ARDUINO sets the digital pin 49 as output
  pinMode(47, OUTPUT);          // ORANGE  SYNC    sets the digital pin 47 as output
flag1=false;
}

void loop()

{

if (digitalRead(53) == HIGH)
  {
    revers = 1;               //Revers включен
    if(flag1==false){
flag1=true;
 lastMillis=millis();
}
if((millis()- lastMillis)>=700) key = 0;
  }
  else
  {
    revers = 0;               //Revers отключен
    flag1=false;
}

 Как-то так

сегодня нет возможности проверить код, я правильно понимаю, если между 31 и 33 строкой не пройдёт 700 милисек то получается программа просто пройдёт мимо, а в следующие  проходы программы когда будет 700 она выполнит действие с "key"?

что вы подразумеваете под "смотреть шире"?

как я должен обращаться если я не родился с познаниями программиста и на данный момент не умею иначе?

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

Зря вы про Евгения так !!! Ox зря !!!

 В вашем случае "смотреть шире" - найдите на форуме раздел  "Ищу исполнителя"

зачем фатализировать какую-то мелочную если это можно назвать стычку, ничего такого смертельного никто не сказал. Что за чувствительность то такая? Я не думаю что Евгений хоть как-то обиделся, а заступников нашлось зато сколько. 

Не нашли общего языка, не велика потеря. Не захотели меня понять, не ясно я выражался. Ничего страшного.

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

а комментарий от вас "ищу исполнителя" от глубокого взаимного уважения ко всем участникам? и скажите мне что это не намёк на мою какую-то тупость, мол ты то не разберёшься никогда.

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

Ну, если не хотите менять структуру программы и одновременно боитесь пропустить событие во времы delay(); создайте дополнительную функцию delay_(); и в ней отслеживайте своё событие.

Ну Вы же этого хотели? Написано не оптимально и коллеги здесь Вам советовали концептуально поменять подход к программе. Моя программа - это пример, как можно избежать dalay() в данном конкретном случае. Но Вам все равно придется пересмотреть всю Вашу программу.

Но, надеюсь, направление куда копать я дал.

 ////  ФУНКЦИИ ОПИСАНИЕ // вместо задержки времени через delay  ////////////////////////////////////////
void delay_(int T1)
{
 long Y=millis();
 while(millis()-Y<T1) 
  {
    //тут чудим как хотим
  }
}

 ////  ФУНКЦИИ ОПИСАНИЕ // вместо задержки времени через delay  ////////////////////////////////////////
void delay_(int T1)
{
 long Y=millis();
 while(millis()-Y<T1) 
  {
    //тут чудим как хотим
  }
}

ИМХО - в каких-то конкретных случаях может помочь, но уходит из основного цикла программы на время T1.

Это ежели вдруг надо тремя светодиодами помигать на "разных независимых  скоростях".
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Arduino UNO
//
////////////////////////
//

 int tablA[3]={5,6,7};//массив номеров выводов для подключения светодиодов
 long tablB[3]={0,0,0};//массив хранения моментов времени
 long tablC[3]={100,500,2000};//массив пауз желаемых при переключениях
 int  i=0;




void setup()    
   {
     for(i=0;i<3;i++)
       {
        pinMode(tablA[i], OUTPUT);          
        digitalWrite(tablA[i],0);
       }
   }
       
        
 void loop()
   {
       for(i=0;i<3;i++)
       {
      if(millis()-tablB[i]>tablC[i])
      {tablB[i]=millis();digitalWrite(tablA[i],!digitalRead (tablA[i]));}   
       }
           

    }
    
//
// Конец /

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

Простите, но тогда совершенно непонятно, нафига вы вообще подняли этот вопрос.

Знаете, всегда очень досадно, когда кто-то просит решить проблему, ему начинаешь обьяснять, а он в ответ - "Ну-у-у это слишком сложно... а разбираться мне лень... меня устраивает и так". И зачем вопрос задавал, людей отрывал от дел?

Проблему "замены delay на  millis()" невозможно решить "малой кровью", для этого надо полностью менять логику программы.Вообще, лучше сразу писать программу в расчете на миллис - чтобы потом не переписывать. Если вы ждали какого-то простого рецепта от форума - его не будет, такого рецепта в принципе не существует.

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

Сейчас я уже понимаю что надо иначе делать все, осталось понять как иначе) 

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

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

Пример этого привел уважаемый qwone в одной из обсуждаемых на форуме тем - посмотрите, не поленитесь.

Обязательно посмотрю!