Шаговый двигатель Nema34 и три датчика

По вашему совету исправил код

//для управления двигателем
const uint8_t pin_ENA = 2;                // Вывод 2 Arduino подключённый к входу драйвера ENA+.
const uint8_t pin_DIR = 6;                // Вывод 3 Arduino подключённый к входу драйвера DIR+.
const uint8_t pin_PUL = 4;                // Вывод 4 Arduino подключённый к входу драйвера PUL+.
                                          // Вывод GND Arduino соединён с входами драйвера ENA-, DIR-, PUL-.

const uint8_t pin_Datchik_1 = 8;         // Вывод 8 Arduino подключённый к переключателю (емкостному датчику1) - прямой ход
const uint8_t pin_Datchik_2 = 10;        // Вывод 10 Arduino подключённый к переключателю (емкостному датчику2) - обратный ход
const uint8_t pin_Datchik_3 = 12;        // Вывод 12 Arduino подключённый к переключателю (оптическому датчику).

//int spd = A0;                          // потенциометр - регулирует скорость вращения двигателя
                                         // Чем выше частота, тем выше скорость вращения вала.
// LOW  - низкое
// HIGH - высокое 
                                         
boolean Pologenie = HIGH;                // Для определения первоначального положения каретки 
                                         // Если каретка не в начале , то состояние HIGH  , если в начале то состояние LOW


boolean Datchik_1_current;   // Текущее состояние
boolean D_1;                 // Флаг срабатывания Датчика1 


boolean Datchik_2_current;   // Текущее состояние
boolean D_2;                 // Флаг срабатывания Датчика2 


boolean Datchik_3_current;       // Текущее состояние
boolean D_3;                     // Флаг срабатывания Датчика3 

boolean prov = HIGH;    //  Флаг первичной проверки при включении
boolean dvig = HIGH;    //  Флаг движения каретки вперед
                                        
void setup()                              // void setup() – функция, которая выполняется единожды, при загрузке программы  
{                              
  
     pinMode( pin_ENA, OUTPUT );          // Конфигурируем вывод 2 Arduino как выход.
     pinMode( pin_DIR, OUTPUT );          // Конфигурируем вывод 3 Arduino как выход.
     pinMode( pin_PUL, OUTPUT );          // Конфигурируем вывод 4 Arduino как выход.
     

     pinMode( pin_Datchik_3, INPUT_PULLUP );  // Конфигурируем вывод 8 Arduino как вход  (pin8 датчик)
     pinMode( pin_Datchik_1, INPUT_PULLUP );  // Конфигурируем вывод 9 Arduino как вход  (pin9 датчик)
     pinMode( pin_Datchik_2, INPUT_PULLUP );  // Конфигурируем вывод 10 Arduino как вход  (pin10 датчик)
     

}    //void setup()



// void loop() – соответственно функция, которая выполняется постоянно, когда плата подключена к источнику питания 
                                          
void loop()
    {       

// Считываем показания датчиков

     Datchik_1_current = digitalRead(pin_Datchik_1);   //  Считываем актуальное показание Датчика1 
     if (!Datchik_1_current)          //  Сравниваем новое и старое показания
          {
            D_1 = HIGH;         // Датчик1 - сработал 
          }
     else
          {
            D_1 = LOW;         // Датчик1 - не сработал 
          }
     
     Datchik_2_current = digitalRead(pin_Datchik_2);   //  Считываем актуальное показание Датчика2 
     if (!Datchik_2_current)          //  Сравниваем новое и старое показания
          {
            D_2 = HIGH;       // Датчик2 - сработал
          }
     else
          {
            D_2 = LOW;      // Датчик2 - не сработал
          }
     
    Datchik_3_current = digitalRead(pin_Datchik_3);   //  Считываем актуальное показание Датчика3
    if (!Datchik_3_current)
             {
               D_3 = HIGH;       // Датчик3 - сработал
             }
         else
             {
               D_3 = LOW;      // Датчик3 - не сработал
             }
  
  // Условие1 при первом включении  
  //       
      if ( D_1 == LOW && D_2 == LOW && prov == HIGH ) 
            {   
                 // Устанавливаем движение вала в обратном направлении:  
                digitalWrite( pin_ENA, 0 );            // Разрешаем работу двигателя.
                delayMicroseconds(5);                  // Выполняем задержку t1 (5мкс)  
                digitalWrite( pin_DIR, 1 );            // Указываем валу вижение в обратном направлении
                delayMicroseconds(5);                  // Выполняем задержку t2 (5мкс)
                
                // Вал движетсяв обратную сторону пока не сработает емкостной датчик 2
                for(int i=0; i<10 ; i++)
                   {              // Выполняем 100 проходов цикла (1 оборот = 400 тактов).
                     digitalWrite( pin_PUL, 1 );            // Устанавливаем на выводе PUL состояние логической «1».
                     delayMicroseconds(1);                  // Выполняем задержку t3.
                     digitalWrite( pin_PUL, 0 );            // Устанавливаем на выводе PUL состояние логического «0».
                     delayMicroseconds(1);                  // Выполняем задержку t4.
                     Datchik_2_current = digitalRead(pin_Datchik_2);   //  Считываем актуальное показание Датчика2 
                     if (!Datchik_2_current)    //  Сравниваем новое и старое показания
                        {
                          D_2 = HIGH;            // Флаг сработки Датчика2
                          prov = LOW;             // Сбрсываем флаг первой проверки положения каретки
                          
                          break;                    // Оператор break позволяет выйти из цикла
                        }
                    } 
              }


   // Условие2 при первом включении

       if ( D_1 == HIGH && D_2 == LOW && prov == HIGH )            
           {   
                 // Устанавливаем движение вала в обратном направлении:  
                digitalWrite( pin_ENA, 0 );            // Разрешаем работу двигателя.
                delayMicroseconds(5);                  // Выполняем задержку t1 (5мкс)  
                digitalWrite( pin_DIR, 1 );            // Указываем валу вижение в обратном направлении
                delayMicroseconds(5);                  // Выполняем задержку t2 (5мкс)
                
                // Вал движетсяв обратную сторону пока не сработает емкостной датчик 2
                for(int i=0; i<10 ; i++)
                   {              // Выполняем 100 проходов цикла (1 оборот = 400 тактов).
                     digitalWrite( pin_PUL, 1 );            // Устанавливаем на выводе PUL состояние логической «1».
                     delayMicroseconds(1);                  // Выполняем задержку t3.
                     digitalWrite( pin_PUL, 0 );            // Устанавливаем на выводе PUL состояние логического «0».
                     delayMicroseconds(1);                  // Выполняем задержку t4.
                     Datchik_2_current = digitalRead(pin_Datchik_2);   //  Считываем актуальное показание Датчика2 
                     
                     if (!Datchik_2_current)    //  Сравниваем новое и старое показания
                        {
                          D_2 = HIGH;           // Датчика2  сработал
                          prov = LOW;             // Сбрсываем флаг первой проверки положения каретки
                          D_1 = LOW; 
                          
                          break;                    // Оператор break позволяет выйти из цикла
                        }
                    } 
             }
 
 // Условие3 при первом включении
 
        if ( D_2 == HIGH && prov == HIGH )            
            {   
             prov = LOW;             // Сбрсываем флаг первой проверки положения каретки
            } 

// Если Условие1 и Условие2 не сработали и каретка находится в начале (Датчик 2 сработал)- прямое движение каретки по Датчику3

         if (D_3 == HIGH && D_2 == HIGH && dvig == HIGH && prov == LOW )          //  Сравниваем новое и старое показания
                  {
                    // Начинаем движение каретки вперёд
            
                    // Устанавливаем движение вала в обратном направлении:  
                    digitalWrite( pin_ENA, 0 );            // Разрешаем работу двигателя.
                    delayMicroseconds(5);                  // Выполняем задержку t1 (5мкс).  
                    digitalWrite( pin_DIR, 0 );            // Указываем валу вижение в прямом направлении
                    delayMicroseconds(5);                  // Выполняем задержку t2 (5мкс).
                    // Вал движется в прямом направлении пока не сработает емкостной Датчик1
                    for (int i=0; i<100 ; i++)
                       {              
                         digitalWrite( pin_PUL, 1 );            // Устанавливаем на выводе PUL состояние логической «1».
                         delayMicroseconds(1);                  // Выполняем задержку t3.
                         digitalWrite( pin_PUL, 0 );            // Устанавливаем на выводе PUL состояние логического «0».
                         delayMicroseconds(1);                  // Выполняем задержку t4.

                         //Datchik_1_current = digitalRead(pin_Datchik_1);   //  Считываем актуальное показание Датчика2 
                     
                         //if (!Datchik_1_current )    //  Сравниваем новое и старое показания
                       }
                  } 
 
 
}       // void loop()
         

Да, Вы правильно излагаете, но я выше писал , что сработка по датчику1 - этого пока в коде нет. Мотор должен крутиться 100 шагов, но так не происходит. Пока я держу руку у датчика3 мотор крутится, стоит убрать , то мотор сразу же останавливается, а должен крутиться 100 шагов… Но так не получается

// Если Условие1 и Условие2 не сработали и каретка находится в начале (Датчик 2 сработал)- прямое движение каретки по Датчику3

     if (D_3 == HIGH && D_2 == HIGH && dvig == HIGH && prov == LOW )          //  Сравниваем новое и старое показания
              {
                // Начинаем движение каретки вперёд
        
                // Устанавливаем движение вала в обратном направлении:  
                digitalWrite( pin_ENA, 0 );            // Разрешаем работу двигателя.
                delayMicroseconds(5);                  // Выполняем задержку t1 (5мкс).  
                digitalWrite( pin_DIR, 0 );            // Указываем валу вижение в прямом направлении
                delayMicroseconds(5);                  // Выполняем задержку t2 (5мкс).
                // Вал движется в прямом направлении пока не сработает емкостной Датчик1
                for (int i=0; i<100 ; i++)
                   {              
                     digitalWrite( pin_PUL, 1 );            // Устанавливаем на выводе PUL состояние логической «1».
                     delayMicroseconds(1);                  // Выполняем задержку t3.
                     digitalWrite( pin_PUL, 0 );            // Устанавливаем на выводе PUL состояние логического «0».
                     delayMicroseconds(1);                  // Выполняем задержку t4.

                     //Datchik_1_current = digitalRead(pin_Datchik_1);   //  Считываем актуальное показание Датчика2 
                 
                     //if (!Datchik_1_current )    //  Сравниваем новое и старое показания
                   }
              } 

есть код который заточен для другого, для выдвижения чего то на концевиках и 2 моторах, возможно вам проще будет переделать его под себя, но лучше разберитесь в вашем…

// ==============================================
// 1. ОБЪЯВЛЕНИЕ ПИНОВ (аппаратные контакты)
// ==============================================

const int pinStep1 = A0;  // Пин STEP для первого мотора (ось X). 
                          // A0 - аналоговый пин, но используется как цифровой выход.
                          // ШИМ-сигнал на этом пине заставляет мотор делать шаг.

const int pinDir1 = A1;   // Пин DIRECTION для первого мотора (ось X).
                          // Определяет направление вращения: HIGH - одно, LOW - обратное.

const int pinStep2 = A6;  // Пин STEP для второго мотора (ось Y).
                          // Аналоговый пин A6 работает как цифровой.

const int pinDir2 = A7;   // Пин DIRECTION для второго мотора (ось Y).

const int pinEN1 = A2;    // Пин ENABLE для первого мотора (в вашем коде подписан как Y, но путаница).
                          // LOW - мотор включен (активен), HIGH - выключен (свободный ход).

const int pinEN2 = 38;    // Пин ENABLE для второго мотора (подписан как X).
                          // Цифровой пин 38.

// ==============================================
// 2. КНОПКИ (управление)
// ==============================================

const int button1 = 40;   // Первая кнопка (физически подключена к пину 40)
const int button2 = 42;   // Вторая кнопка (пин 42)
const int button3 = 44;   // Третья кнопка (пин 44)

int button_old1 = 0;      // Переменная для хранения предыдущего состояния кнопки 1
int button_old2 = 0;      // Переменная для хранения предыдущего состояния кнопки 2
int button_old3 = 0;      // Переменная для хранения предыдущего состояния кнопки 3
int button_old4 = 0;      // ФЛАГ-переменная (не состояние кнопки, а логический флаг!)
int button_old5 = 0;      // Ещё один флаг (но в коде не используется)

// ==============================================
// 3. ПАРАМЕТРЫ ДВИЖЕНИЯ
// ==============================================

const int move_delay = 1;           // Задержка между шагами в миллисекундах.
                                    // Чем меньше - тем быстрее вращение.
                                    // При 1 мс мотор вращается с максимальной скоростью.

const int steps_rotate_360 = 200;   // Количество шагов для полного оборота (200 = 1.8° на шаг).
                                    // НЕ ИСПОЛЬЗУЕТСЯ в текущем коде, но зарезервировано.

// ==============================================
// 4. ФУНКЦИЯ setup() - выполняется один раз при старте
// ==============================================

void setup() {
    Serial.begin(9600);   // Инициализация последовательного порта для отладки.
                          // Скорость 9600 бод - можно смотреть состояния кнопок в мониторе порта.

    // --- Настройка пинов моторов как ВЫХОДЫ ---
    pinMode(pinStep1, OUTPUT);  // Пин STEP первого мотора - выход (подаём импульсы)
    pinMode(pinDir1, OUTPUT);   // Пин DIR первого мотора - выход (задаём направление)
    pinMode(pinStep2, OUTPUT);  // Пин STEP второго мотора - выход
    pinMode(pinDir2, OUTPUT);   // Пин DIR второго мотора - выход
    pinMode(pinEN1, OUTPUT);    // Пин ENABLE первого мотора - выход (включаем/выключаем)
    pinMode(pinEN2, OUTPUT);    // Пин ENABLE второго мотора - выход

    // --- Настройка кнопок как ВХОДЫ с подтяжкой к питанию ---
    pinMode(button1, INPUT_PULLUP);  // Внутренний резистор подтягивает пин к +5В.
                                     // При нажатии кнопка замыкает на GND -> читаем LOW (0).
    pinMode(button2, INPUT_PULLUP);  // Аналогично для второй кнопки
    pinMode(button3, INPUT_PULLUP);  // Аналогично для третьей кнопки

    // --- Установка начальных состояний на выходах ---
    digitalWrite(pinStep1, HIGH);   // STEP изначально HIGH (но при первом импульсе он станет LOW)
    digitalWrite(pinDir1, LOW);     // Направление первого мотора - LOW (условно "назад")
    digitalWrite(pinStep2, HIGH);   // STEP второго мотора - HIGH
    digitalWrite(pinDir2, LOW);     // Направление второго мотора - LOW (условно "назад")
    digitalWrite(pinEN1, LOW);      // LOW = мотор ВКЛЮЧЕН (драйвер активен)
    digitalWrite(pinEN2, LOW);      // LOW = мотор ВКЛЮЧЕН
}

// ==============================================
// 5. ФУНКЦИЯ loop() - бесконечный цикл
// ==============================================

void loop() {
    // --- Чтение текущих состояний кнопок ---
    button_old1 = digitalRead(button1);   // Читаем состояние кнопки 1 (0 - нажата, 1 - отпущена)
    button_old2 = digitalRead(button2);   // Читаем состояние кнопки 2
    button_old3 = digitalRead(button3);   // Читаем состояние кнопки 3

    // --- Отладка: вывод состояний в Serial-порт ---
    Serial.print(button_old1);   // Выводим состояние первой кнопки (0 или 1)
    Serial.print(' ');           // Разделитель
    Serial.print(button_old2);   // Состояние второй кнопки
    Serial.print(' ');
    Serial.print(button_old3);   // Состояние третьей кнопки
    Serial.println(' ');         // Переход на новую строку

    // ==============================================
    // 6. ЛОГИКА УПРАВЛЕНИЯ ФЛАГАМИ (самое важное!)
    // ==============================================
    
    // ЕСЛИ кнопка 1 нажата (сигнал LOW = 0)
    if (button_old1 == 0) {
        button_old4 = 1;   // Устанавливаем флаг button_old4 в 1
                           // (условно "режим 1 активирован")
    }
    
    // ЕСЛИ кнопка 2 нажата (сигнал LOW = 0)
    if (button_old2 == 0) {
        button_old4 = 0;   // Сбрасываем флаг button_old4 в 0
                           // (условно "режим 2 активирован")
    }

    // ==============================================
    // 7. УПРАВЛЕНИЕ МОТОРАМИ (два режима работы)
    // ==============================================
    
    // --- РЕЖИМ 1: Кнопка 3 НАЖАТА (0) И флаг button_old4 = 0 ---
    // (то есть кнопка 1 НЕ нажата, а кнопка 2 нажата)
    if ((button_old3 == 0) && (button_old4 == 0)) {
        button_old5 = 1;   // Устанавливаем флаг (но он нигде не используется)

        // Устанавливаем направление для ОБОИХ моторов: HIGH
        digitalWrite(pinDir1, HIGH);   // Ось X вращается в одну сторону
        digitalWrite(pinDir2, HIGH);   // Ось Y вращается в ту же сторону

        // --- ОДИН ШАГ для обоих моторов одновременно ---
        digitalWrite(pinStep1, HIGH);  // Подаём HIGH на STEP X
        digitalWrite(pinStep2, HIGH);  // Подаём HIGH на STEP Y
        delay(move_delay);             // Ждём 1 мс (удерживаем сигнал)
        digitalWrite(pinStep1, LOW);   // Опускаем STEP X в LOW
        digitalWrite(pinStep2, LOW);   // Опускаем STEP Y в LOW
        delay(move_delay);             // Ждём 1 мс (пауза до следующего шага)
    }

    // --- РЕЖИМ 2: Кнопка 3 ОТПУЩЕНА (1) И флаг button_old4 = 1 ---
    // (то есть кнопка 1 нажата, а кнопка 2 НЕ нажата)
    if ((button_old3 == 1) && (button_old4 == 1)) {
        // Устанавливаем направление для ОБОИХ моторов: LOW (противоположное)
        digitalWrite(pinDir1, LOW);    // Ось X вращается в другую сторону
        digitalWrite(pinDir2, LOW);    // Ось Y вращается в другую сторону

        // --- ОДИН ШАГ для обоих моторов одновременно ---
        digitalWrite(pinStep1, HIGH);  // Подаём HIGH на STEP X
        digitalWrite(pinStep2, HIGH);  // Подаём HIGH на STEP Y
        delay(move_delay);             // Ждём 1 мс
        digitalWrite(pinStep1, LOW);   // Опускаем STEP X
        digitalWrite(pinStep2, LOW);   // Опускаем STEP Y
        delay(move_delay);             // Ждём 1 мс
    }

    // ==============================================
    // 8. ДОПОЛНИТЕЛЬНАЯ ЗАДЕРЖКА
    // ==============================================
    
    delay(move_delay * 10);   // Задержка 10 мс в конце цикла
                              // Это замедляет опрос кнопок и общую скорость вращения
                              // Фактически шаг делается за 1+1+10 = 12 мс

}  // Конец loop() - всё повторяется заново

если будет просто гудеть, задержка delay(move_delay); слишком маленькая

Спасибо большое за пример, я просмотрю его позже… Сейчас разбираюсь со своим кодом…

Набросал на скорую руку. Проверить уже нет времени. Основная идея - упростить код, и сделать более понятным (для себя). Я , когда был новичком - так примерно писал


const uint8_t pin_ENA = 2;                // Вывод 2 Arduino подключённый к входу драйвера ENA+.
const uint8_t pin_DIR = 6;                // Вывод 3 Arduino подключённый к входу драйвера DIR+.
const uint8_t pin_PUL = 4;                // Вывод 4 Arduino подключённый к входу драйвера PUL+.
                                          // Вывод GND Arduino соединён с входами драйвера ENA-, DIR-, PUL-.

const uint8_t pin_Datchik_1 = 8;         // Вывод 8 Arduino подключённый к переключателю (емкостному датчику1) - прямой ход
const uint8_t pin_Datchik_2 = 10;        // Вывод 10 Arduino подключённый к переключателю (емкостному датчику2) - обратный ход
const uint8_t pin_Datchik_3 = 12;        // Вывод 12 Arduino подключённый к переключателю (оптическому датчику).


void step()
{
  digitalWrite( pin_PUL, 1 );            // Устанавливаем на выводе PUL состояние логической «1».
  delayMicroseconds(1);                  // Выполняем задержку t3.
  digitalWrite( pin_PUL, 0 );            // Устанавливаем на выводе PUL состояние логического «0».
  delayMicroseconds(1);                  // Выполняем задержку t4.
}

void dir_dir()
{
  // Устанавливаем движение вала в пряммом направлении:
  digitalWrite( pin_ENA, 0 );            // Разрешаем работу двигателя.
  delayMicroseconds(5);                  // Выполняем задержку t1 (5мкс)
  digitalWrite( pin_DIR, 0 );            // Указываем валу вижение в прямом направлении
  delayMicroseconds(5);
}

void rev_dir()
{
  // Устанавливаем движение вала в обратном направлении:
  digitalWrite( pin_ENA, 0 );            // Разрешаем работу двигателя.
  delayMicroseconds(5);                  // Выполняем задержку t1 (5мкс)
  digitalWrite( pin_DIR, 1 );            // Указываем валу вижение в обратном направлении
  delayMicroseconds(5);                  // Выполняем задержку t2 (5мкс)
}


void setup()
{
   pinMode( pin_ENA, OUTPUT );          // Конфигурируем вывод 2 Arduino как выход.
     pinMode( pin_DIR, OUTPUT );          // Конфигурируем вывод 3 Arduino как выход.
     pinMode( pin_PUL, OUTPUT );          // Конфигурируем вывод 4 Arduino как выход.
     

     pinMode( pin_Datchik_3, INPUT_PULLUP );  // Конфигурируем вывод 8 Arduino как вход  (pin8 датчик)
     pinMode( pin_Datchik_1, INPUT_PULLUP );  // Конфигурируем вывод 9 Arduino как вход  (pin9 датчик)
     pinMode( pin_Datchik_2, INPUT_PULLUP );  // Конфигурируем вывод 10 Arduino как вход  (pin10 датчик)

  if (digitalRead(pin_Datchik_2))//если каретка не в начале
  {
    rev_dir();
  }
  while (digitalRead(pin_Datchik_2))
  {
    step();
  }
}

void loop()
{
  if (digitalRead(pin_Datchik_1))//если каретка не в конце
  {
    if (!digitalRead((pin_Datchik_3)))//если  сработал D_3
    {
      dir_dir();
      /*                //делаем цикл?
        for (int i = 0; i < 100 ; i++)
        {
         step();
        }
      */
      while (digitalRead(pin_Datchik_1))//пока не сработал D_1
      {
       step();
      }

    }
  }
    else //если каретка в  конце
    {
      if(!digitalRead((pin_Datchik_3)))//если  сработал D_3
      {
      rev_dir();
      }
      while (digitalRead(pin_Datchik_2))//пока не сработал D_2
      {
       step();
      }
    }
  } 

P.S. про pinMode() забыл, второпях - добавил

@Ugluarov , похоже, у Вас терминологическая путаница.
Если датчик имеет два состояния, назовем их, скажем, LOW и HIGH, то в программе может быть предусмотрена реакция на 4 обстоятельства:

  1. Датчик имеет состояние LOW.
  2. Датчик переходит из состояния LOW в состояние HIGH.
  3. Датчик имеет состояние HIGH.
  4. Датчик переходит из состояния HIGH в состояние LOW.

Еще раз, и это важно: у датчика 2 состояния, но программа может реагировать на 4 обстоятельства. Вам нужно понять, что того, на что может понадобиться реакция, у каждого датчика 4, а не 2. И не путать их между собой.

Попытайтесь разобраться для каждого датчика, на какие именно обстоятельства следует реагировать каждому из датчиков.
Составьте полный список состояний всего устройства (исходное состояние, начальное состояние, двигается влево, двигается вправо, остановился в промежуточной точке, конечное состояние…). Возможно несколько групп состояний, например, движение вправо при первоначальной настройке и движение вправо при последующей работе могут оказаться разными состояниями.
Составьте таблицу, в которой будут перечислены все возможные состояния и обозначены все переходы - то есть при каких обстоятельствах происходит переход из одного состояния в другое. В таблице неизбежно будет много пустых клеток - т.е. наборов условий, на которые не предусмотрена реакция. Например, пока каретка не достигла концевика, она двигается к нему вне зависимости ни от каких обстоятельств.

Это потому что вы читаете датчик неправильно.
Подробнее у @andriano выше

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

а d3 там надо ждать пока отпустят или нет ?)))

p.s. не фига не проще, я себе мозгу сломал пытаясь понять)))
проще так, через иф, и елзе, осталось только в код перевести)))

1. Включение:
   - Если D2 НЕ сработал → едем НАЗАД до D2
   - Если D2 сработал → СТОИМ в сетапе

2. Ожидание команды: в лупе
   - Каретка стоит у D2 (в начале)
   - Ждем сигнала от D3

3. D3 сработал (команда):
   - Едем ВПЕРЕД до D1
   - Останавливаемся у D1

4. Ждем новую команду:
   - Каретка стоит у D1 (в конце)
   - Ждем сигнала от D3

5. D3 снова сработал (команда):
   - Едем НАЗАД до D2
   - Останавливаемся у D2

6. Возвращаемся к пункту 2

Исправил ошибку . Скобку стр.84 (из сообщ #27) надо перенести

Спойлер
void loop()
{
  if (digitalRead(pin_Datchik_1))//если каретка не в конце
  {
    if (!digitalRead((pin_Datchik_3)))//если  сработал D_3
    {
      dir_dir();
      /*                //делаем цикл?
        for (int i = 0; i < 100 ; i++)
        {
         step();
        }
      */
      while (digitalRead(pin_Datchik_1))//пока не сработал D_1
      {
        step();

      }

    }
  }
  else //если каретка в  конце
  {
    if (!digitalRead((pin_Datchik_3))) //если  сработал D_3
    {
      rev_dir();

      while (digitalRead(pin_Datchik_2))//пока не сработал D_2
      {
        step();

      }

    }
   
  }
}

Это упрощённый код. Не на чем отладить - в симуляторе нет концевиков.
Будет время, гляну ещё, может как-нибудь выключатели использовать получится. Кнопки без фиксации не вариант.

Берегите себя

спс, но последние изменения внесли вы наверное зря… я дышал только помощью, а теперь… но все же спс за решение)))

Сделал в Wokwi на переключателях. Скорость есс-но уменьшил, чтобы успевать вкл/выкл…))
Вроде работает, хотя долго не гонял, не проверял. Всё же предполагается, что ТС сам пишет, это лишь помощь. Сериал - только для отладки. Логика работы - из сообщ #1.
Посмотреть в Wokwi
Кстати, у вас тайминги мотора занижены ИМХО, я бы увеличил, хотя-бы в 10 раз, а для отладки, можно и того больше.

P.S. Некоторое неудобство в том, что чтобы изменить начальное положение датчиков, сначала надо запустить симуляцию, установить как надо, затем выключить, и включить всё по новой.
P.P.S. Да, скетч рассчитан на то, что датчики без дребезга контактов.
Если есть дребезг - надо ещё дописывать обработку оного.

Всем большое спасибо за советы, попытаюсь за выходные или в начале недели опробовать, пока просто времени катастрофически не хватает, да и с бензином проблема, вчера пол ночи простоял, что бы свою старушку заправить, под утро домой вернулся, сейчас хожу как варенный…
Сейчас один вопрос по одному датчику. Датчик стоит такой - pse-bc10dpb.

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

//для управления двигателем
const uint8_t pin_ENA = 2; // Вывод 2 Arduino подключённый к входу драйвера ENA+.
const uint8_t pin_DIR = 6; // Вывод 3 Arduino подключённый к входу драйвера DIR+.
const uint8_t pin_PUL = 4; // Вывод 4 Arduino подключённый к входу драйвера PUL+.
// Вывод GND Arduino соединён с входами драйвера ENA-, DIR-, PUL-.

const uint8_t pin_Datchik_3 = 12; // Вывод 12 Arduino подключённый к переключателю (оптическому датчику).

boolean Datchik_3_current; // Текущее состояние
boolean D_3; // Флаг срабатывания Датчика3

boolean prov = HIGH; // Флаг первичной проверки при включении
boolean dvig = HIGH; // Флаг движения каретки вперед

void setup() // void setup() – функция, которая выполняется единожды, при загрузке программы
{

 pinMode( pin_ENA, OUTPUT );          // Конфигурируем вывод 2 Arduino как выход.
 pinMode( pin_DIR, OUTPUT );          // Конфигурируем вывод 3 Arduino как выход.
 pinMode( pin_PUL, OUTPUT );          // Конфигурируем вывод 4 Arduino как выход.
 

 pinMode( pin_Datchik_3, INPUT_PULLUP );  // Конфигурируем вывод 8 Arduino как вход  (pin8 датчик)

} //void setup()

// void loop() – соответственно функция, которая выполняется постоянно, когда плата подключена к источнику питания

void loop()
{

// Считываем показания датчиков

Datchik_3_current = digitalRead(pin_Datchik_3);   //  Считываем актуальное показание Датчика3
if (!Datchik_3_current)
         {
           D_3 = HIGH;       // Датчик3 - сработал
         }
     else
         {
           D_3 = LOW;        // Датчик3 - не сработал
         }

// Условие1 при первом включении
//
if ( D_3 == HIGH )
{
// Устанавливаем движение вала в обратном направлении:
digitalWrite( pin_ENA, 0 ); // Разрешаем работу двигателя.
delayMicroseconds(5); // Выполняем задержку t1 (5мкс)
digitalWrite( pin_DIR, 1 ); // Указываем валу вижение в обратном направлении
delayMicroseconds(5); // Выполняем задержку t2 (5мкс)

            // Вал движетсяв обратную сторону пока не сработает емкостной датчик 2
            for(int i=0; i<1000 ; i++)
               {              // Выполняем 100 проходов цикла (1 оборот = 400 тактов).
                 digitalWrite( pin_PUL, 1 );            // Устанавливаем на выводе PUL состояние логической «1».
                 delayMicroseconds(1);                  // Выполняем задержку t3.
                 digitalWrite( pin_PUL, 0 );            // Устанавливаем на выводе PUL состояние логического «0».
                 delayMicroseconds(1);                  // Выполняем задержку t4.
                 
                      
                      break;                    // Оператор break позволяет выйти из цикла
                }
          } 

}

:grinning_face: На пятый раз повезёт!


В телефоне за тремя точками(вроде).

Как написано, так и работает. Пока Datchik_3_current - HIGH, мотор крутится, как только датчик стал LOW - мотор остановился.

Главное что вы делаете не так - беретесь за проект, ВООБЩЕ ничего не понимая в коде. Зачем у вас внутри цикла break ? да еще и с дебильным комментом?

с этим break у вас программа вылетает из цикла после первого же прохода
Если эту строчку убрать, станет чуть лучше, но не намного, потому что вы не понимаете, что делаете. Кривое чтение датчика так и осталось…

@Ugluarov
Ответьте честно, вы в С++ не понимаете ровным словом ничего, ведь так? Все показанные вами куски кода написаны ИИ?

для статистики - это в каком регионе?

Добрый день… Код пишу сам как понимаю…ИИ тут не причем…Я не программист и пишу помощи… у всех разные возможности по ходу задачи пытаюсь разобраться…

Вам бы начать с чтения учебника. Любого базового по С/С++, хотя бы первые страниц 200-300. Операторы, циклы, условия, переменные… Вы плаваете в самых базовых вещах.
Только не надо отговариваться нехваткой времени. Без этих необходимых знаний вы потратите на проект времени столько, что хватило бы прочитать пяток учебников…

По коду - уберите этот break. Он тут не нужен. Break применяется для ДОСРОЧНОГО выхода из цикла. И, кроме того, он всегда применяется по условию, а не сам по себе.

Удалите строчку и попробуйте.

И да, вставьте код в сообщении 38 правильно. Вы же делали это раньше, что тут случилось?

Два раза читал и пытался понять вопрос. Так и не понял, что ТС хочет сделать.

Вот бы ТС ясно и однозначно сформулировал задачу - это было бы уже решение на 50%. А так получается кто и что подскажет то в одном то в другом участке кода не понимая общей задачи.

Определить объекты управления: Мотор

Что нужно мотору? скорость вращения, направление вращения.

Какие датчики имеем? Датчик 1, 2, 3

Разделить понятия состояния датчика = 0, 1, переход с 0 на 1, переход с 1 на 0

Изучить как работает тригер (это как раз ваши переходы 0-1, 1-0)

И записать формулы:

вращение мотора = F(состояния датчика(ов), направление вращения, …)

Направление вращения = F(состояния датчиков, вращения мотора, …)

Сначала записать абстрактно. А затем переходить к коду

И все станет проще. и предположу, что и помощь даже не понадобится :slight_smile:

зы. Управлять шаговыми моторами путем digitalwrite(0/1) это не рабочий вариант.

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