5 впечатляющих проектов с ультразвуковыми датчиками для Arduino

#define TRIG_PIN 9
#define ECHO_PIN 10

void setup() {
  Serial.begin(9600);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
}

void loop() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  
  long duration = pulseIn(ECHO_PIN, HIGH);
  float distance = (duration * 0.034) / 2;
  
  Serial.print("Расстояние: ");
  Serial.print(distance);
  Serial.println(" см");
  
  delay(500);
}

#define TRIG_PIN 9
#define ECHO_PIN 10
#define BUZZER_PIN 8
#define RED_PIN 3
#define GREEN_PIN 5
#define BLUE_PIN 6

// Пороговые значения для предупреждений
const int SAFE_DISTANCE = 150; // в см
const int WARNING_DISTANCE = 100;
const int DANGER_DISTANCE = 50;

void setup() {
  Serial.begin(9600);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
}

void loop() {
  long duration, distance;
  
  // Отправка ультразвукового импульса
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  
  // Получение эха и расчет расстояния
  duration = pulseIn(ECHO_PIN, HIGH);
  distance = (duration * 0.034) / 2;
  
  Serial.print("Расстояние: ");
  Serial.print(distance);
  Serial.println(" см");
  
  // Логика работы парктроника
  if (distance > SAFE_DISTANCE) {
    // Безопасное расстояние – зеленый цвет, нет сигнала
    setColor(0, 255, 0);
    noTone(BUZZER_PIN);
  } else if (distance > WARNING_DISTANCE) {
    // Предупреждающее расстояние – синий цвет, редкие гудки
    setColor(0, 0, 255);
    beepPattern(500, 500); // 0.5с звук, 0.5с пауза
  } else if (distance > DANGER_DISTANCE) {
    // Опасное расстояние – желтый цвет, частые гудки
    setColor(255, 255, 0);
    beepPattern(200, 200); // 0.2с звук, 0.2с пауза
  } else {
    // Критическое расстояние – красный цвет, непрерывный гудок
    setColor(255, 0, 0);
    tone(BUZZER_PIN, 1000);
  }
  
  delay(100);
}

// Функция управления RGB светодиодом
void setColor(int red, int green, int blue) {
  analogWrite(RED_PIN, red);
  analogWrite(GREEN_PIN, green);
  analogWrite(BLUE_PIN, blue);
}

// Функция для создания звуковых сигналов с паузами
void beepPattern(int onTime, int offTime) {
  static unsigned long previousMillis = 0;
  static bool buzzerState = false;
  
  unsigned long currentMillis = millis();
  
  if (buzzerState && (currentMillis – previousMillis >= onTime)) {
    noTone(BUZZER_PIN);
    buzzerState = false;
    previousMillis = currentMillis;
  } else if (!buzzerState && (currentMillis – previousMillis >= offTime)) {
    tone(BUZZER_PIN, 1000);
    buzzerState = true;
    previousMillis = currentMillis;
  }
}

#include <Servo.h>

// Пины ультразвукового датчика
#define TRIG_PIN 9
#define ECHO_PIN 10

// Пины сервопривода
#define SERVO_PIN 11

// Пины драйвера моторов
#define IN1 2
#define IN2 3
#define IN3 4
#define IN4 5
#define ENA 6
#define ENB 7

// Константы
#define MIN_DISTANCE 30 // Минимальное безопасное расстояние в см
#define MOTOR_SPEED 150 // Скорость моторов (0-255)

Servo servoMotor; // Создаем объект сервопривода

void setup() {
  Serial.begin(9600);
  
  // Настраиваем пины ультразвукового датчика
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  
  // Настраиваем пины драйвера моторов
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  pinMode(ENA, OUTPUT);
  pinMode(ENB, OUTPUT);
  
  // Подключаем сервопривод
  servoMotor.attach(SERVO_PIN);
  servoMotor.write(90); // Устанавливаем в среднее положение
  
  // Начальная пауза для подготовки
  delay(2000);
}

void loop() {
  int distance = measureDistance();
  Serial.print("Расстояние: ");
  Serial.print(distance);
  Serial.println(" см");
  
  if (distance > MIN_DISTANCE) {
    moveForward(); // Если путь свободен, едем вперед
  } else {
    stopMotors(); // Останавливаемся
    delay(500);
    
    // Сканируем пространство
    int leftDistance = lookLeft();
    delay(500);
    int rightDistance = lookRight();
    delay(500);
    servoMotor.write(90); // Возвращаем сервопривод в центр
    
    // Выбираем направление с большим свободным пространством
    if (leftDistance > rightDistance) {
      turnLeft();
    } else {
      turnRight();
    }
  }
}

// Функция измерения расстояния
int measureDistance() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  
  long duration = pulseIn(ECHO_PIN, HIGH);
  int distance = (duration * 0.034) / 2;
  
  return distance;
}

// Функция взгляда налево
int lookLeft() {
  servoMotor.write(180); // Поворачиваем сервопривод влево
  delay(500); // Ждем, пока сервопривод повернется
  int distance = measureDistance(); // Измеряем расстояние
  return distance;
}

// Функция взгляда направо
int lookRight() {
  servoMotor.write(0); // Поворачиваем сервопривод вправо
  delay(500); // Ждем, пока сервопривод повернется
  int distance = measureDistance(); // Измеряем расстояние
  return distance;
}

// Функции управления движением
void moveForward() {
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
  analogWrite(ENA, MOTOR_SPEED);
  analogWrite(ENB, MOTOR_SPEED);
}

void turnLeft() {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
  analogWrite(ENA, MOTOR_SPEED);
  analogWrite(ENB, MOTOR_SPEED);
  delay(700); // Время поворота (настройте экспериментально)
  stopMotors();
}

void turnRight() {
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, HIGH);
  analogWrite(ENA, MOTOR_SPEED);
  analogWrite(ENB, MOTOR_SPEED);
  delay(700); // Время поворота (настройте экспериментально)
  stopMotors();
}

void stopMotors() {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);
  analogWrite(ENA, 0);
  analogWrite(ENB, 0);
}

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

// Настройка пинов
#define TRIG_PIN 9
#define ECHO_PIN 10
#define BUZZER_PIN 8
#define RED_PIN 3
#define GREEN_PIN 5
#define BLUE_PIN 6

// Настройка дисплея (адрес, столбцы, строки)
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Параметры бака
const int TANK_DEPTH = 30; // Глубина бака в см
const int SENSOR_HEIGHT = 5; // Высота установки датчика над верхним краем бака
const int TOTAL_DISTANCE = TANK_DEPTH + SENSOR_HEIGHT; // Общее расстояние от датчика до дна

// Пороговые значения для предупреждений
const int LOW_LEVEL = 20; // % – предупреждение о низком уровне
const int HIGH_LEVEL = 80; // % – предупреждение о высоком уровне

void setup() {
  Serial.begin(9600);
  
  // Настройка пинов
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
  
  // Инициализация дисплея
  lcd.init();
  lcd.backlight();
  lcd.print("Система готова");
  delay(2000);
  lcd.clear();
}

void loop() {
  // Измерение расстояния
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  
  long duration = pulseIn(ECHO_PIN, HIGH);
  float distance = (duration * 0.034) / 2; // Расстояние в см
  
  // Проверка на корректность измерения
  if (distance <= 0 || distance > TOTAL_DISTANCE + 10) {
    Serial.println("Ошибка измерения!");
    lcd.clear();
    lcd.print("Ошибка измерения!");
    setColor(255, 0, 0); // Красный – ошибка
    beep(3); // Тройной сигнал об ошибке
    delay(1000);
    return;
  }
  
  // Расчет уровня жидкости
  int level_cm = TOTAL_DISTANCE – distance; // Уровень в см
  if (level_cm < 0) level_cm = 0;
  
  float level_percent = ((float)level_cm / TANK_DEPTH) * 100.0;
  if (level_percent > 100) level_percent = 100;
  
  // Вывод информации на дисплей
  lcd.clear();
  lcd.print("Уровень: ");
  lcd.print((int)level_percent);
  lcd.print("%");
  
  lcd.setCursor(0, 1);
  lcd.print("Высота: ");
  lcd.print(level_cm);
  lcd.print(" см");
  
  // Визуальная и звуковая индикация
  if (level_percent < LOW_LEVEL) {
    // Низкий уровень – красный
    setColor(255, 0, 0);
    if (level_percent < 10) beep(1); // Сигнал при очень низком уровне
  } else if (level_percent > HIGH_LEVEL) {
    // Высокий уровень – синий
    setColor(0, 0, 255);
    if (level_percent > 90) beep(2); // Двойной сигнал при очень высоком уровне
  } else {
    // Нормальный уровень – зеленый
    setColor(0, 255, 0);
  }
  
  // Отладочная информация в Serial Monitor
  Serial.print("Расстояние до поверхности: ");
  Serial.print(distance);
  Serial.println(" см");
  
  Serial.print("Уровень жидкости: ");
  Serial.print(level_cm);
  Serial.print(" см (");
  Serial.print(level_percent);
  Serial.println("%)");
  
  delay(1000); // Пауза между измерениями
}

// Функция установки цвета RGB светодиода
void setColor(int red, int green, int blue) {
  analogWrite(RED_PIN, red);
  analogWrite(GREEN_PIN, green);
  analogWrite(BLUE_PIN, blue);
}

// Функция для звукового сигнала
void beep(int times) {
  for (int i = 0; i < times; i++) {
    digitalWrite(BUZZER_PIN, HIGH);
    delay(200);
    digitalWrite(BUZZER_PIN, LOW);
    delay(200);
  }
}

// Пины для первого датчика (контроль высоты)
#define TRIG_PIN1 2
#define ECHO_PIN1 3

// Пины для второго датчика (контроль громкости)
#define TRIG_PIN2 4
#define ECHO_PIN2 5

// Пин для пьезодинамика
#define BUZZER_PIN 8

// Параметры для генерации звука
int minDistance = 10; // Минимальное расстояние в см
int maxDistance = 60; // Максимальное расстояние в см
int minFreq = 100; // Минимальная частота в Гц
int maxFreq = 2000; // Максимальная частота в Гц

// Музыкальная гамма для дискретного режима
int notes[] = {262, 294, 330, 349, 392, 440, 494, 523}; // До, Ре, Ми, Фа, Соль, Ля, Си, До

// Режимы работы
#define MODE_CONTINUOUS 0 // Непрерывное изменение частоты
#define MODE_DISCRETE 1 // Дискретные ноты (гамма)
int currentMode = MODE_CONTINUOUS;

void setup() {
  Serial.begin(9600);
  
  // Настройка пинов ультразвуковых датчиков
  pinMode(TRIG_PIN1, OUTPUT);
  pinMode(ECHO_PIN1, INPUT);
  pinMode(TRIG_PIN2, OUTPUT);
  pinMode(ECHO_PIN2, INPUT);
  
  // Настройка пина пьезодинамика
  pinMode(BUZZER_PIN, OUTPUT);
  
  // Инициализация
  Serial.println("Интерактивная musical установка готова!");
  Serial.println("Датчик 1: контроль высоты ноты");
  Serial.println("Датчик 2: контроль громкости");
}

void loop() {
  // Измерение расстояния для первого датчика (высота ноты)
  int distance1 = measureDistance(TRIG_PIN1, ECHO_PIN1);
  
  // Измерение расстояния для второго датчика (громкость)
  int distance2 = measureDistance(TRIG_PIN2, ECHO_PIN2);
  
  // Проверка на корректность измерения
  if (distance1 < 0 || distance1 > 400 || distance2 < 0 || distance2 > 400) {
    noTone(BUZZER_PIN); // Остановка звука при ошибке
    return;
  }
  
  // Отображение данных в монитор порта
  Serial.print("Расстояние 1 (высота): ");
  Serial.print(distance1);
  Serial.print(" см, Расстояние 2 (громкость): ");
  Serial.print(distance2);
  Serial.println(" см");
  
  // Генерация звука в зависимости от режима
  if (distance1 >= minDistance && distance1 <= maxDistance) {
    // Определение частоты в зависимости от расстояния
    int frequency;
    
    if (currentMode == MODE_CONTINUOUS) {
      // Линейное отображение расстояния на частоту
      frequency = map(distance1, maxDistance, minDistance, minFreq, maxFreq);
    } else {
      // Дискретные ноты (гамма)
      int noteIndex = map(distance1, maxDistance, minDistance, 0, 7);
      noteIndex = constrain(noteIndex, 0, 7);
      frequency = notes[noteIndex];
    }
    
    // Регулировка громкости через длительность импульсов
    // (более продвинутый вариант требовал бы ШИМ или внешнего усилителя)
    if (distance2 >= minDistance && distance2 <= maxDistance) {
      tone(BUZZER_PIN, frequency);
      
      // Для демонстрации регулировки громкости через Serial
      int volume = map(distance2, maxDistance, minDistance, 0, 100);
      Serial.print("Частота: ");
      Serial.print(frequency);
      Serial.print(" Гц, Громкость: ");
      Serial.print(volume);
      Serial.println("%");
    } else {
      // Если рука вне зоны второго датчика – нет звука
      noTone(BUZZER_PIN);
    }
  } else {
    // Если рука вне зоны первого датчика – нет звука
    noTone(BUZZER_PIN);
  }
  
  delay(50); // Небольшая задержка для стабильности
}

// Функция измерения расстояния
int measureDistance(int trigPin, int echoPin) {
  // Очистка trigPin
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  
  // Отправка ультразвукового импульса
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Чтение echoPin, получение времени путешествия звукового импульса в микросекундах
  long duration = pulseIn(echoPin, HIGH, 30000); // Таймаут 30 мс
  // Если таймаут сработал, вернуть ошибку
  if (duration == 0) return -1;
  
  // Расчет расстояния
  int distance = (duration * 0.034) / 2;
  return distance;
}