Ардуированная кофемашина

Берем Arduino Uno и начинаем автоматизировать. Нам потребуется:
— Датчик уровня воды в резервуаре кофемашины;
— Насос подачи воды из бутыли в резервуар;
— Датчик уровня воды в резервуаре стоков.
Логика проста:
ЕСЛИ уровень в резервуаре кофемашины ниже минимума -> включить насос;
ЕСЛИ уровень в резервуаре кофемашины выше максимума -> остановить насос;
ЕСЛИ уровень в резервуаре стоков выше максимума — вопить.
Казалось бы логика проста, но при реализации оказалось что не все так просто, все подробности в разделе программирования.

Также потребуется блок питания 220В->12Вольт им запитаем, и Arduino, и насос. Управлять насосом будем с помощью реле ардуино (подойдет любой модуль реле с управляющим напряжением 5 Вольт и не более 20мА, вы можете его сделать сами, а можете просто купить реле от Ардуино).

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

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

Итого что нам потребуется (какое то «пока все дома»...):
1) 2 бутылки 19 литров;
2) Arduino Uno;
3) Блок питания 12 Вольт;
4) Насос погружной BI0002156;
5) Ультразвуковой датчик расстояния HC-SR04 (буду называть сонаром);
6) Поплавковый уровень прямой;
7) Кнопка для взаимодействия с человеком;
8) Реле на 5 Вольт;
9) Пьезопищалка;
10) Корпус;
11) До кучи перемычек папа-мама, мама-мама;

Из инструментов: изолента, нож, герметик, сверла, дрель, паяльник со всеми причитающимся.

Общая схема изображена ниже.

Собираем по «принципиальной» схеме ниже всю конструкцию. GND от каждого элемента тянем на любой GND выход Arduino, та же история с +5V. Следование номеру каналов даст вам преимущество не переделывать номера пинов в программе, которая будет ниже.

Хотелось бы отметить:
1. Я решал проблему с нехваткой разъемов GND и 5В тем, что припаял проводку к этим выводам и нужные мне датчики запитал от клемников WAGA, куда можно 5 проводов подцепить.

2. Сонар удобно крепится резинками к крышке бачка. Постарайтесь добиться перпендикуляторности излучателя к поверхности воды.

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

4. Отвод капель из поддона я сделал через распечатанный на 3D принтере штуцер. В низшей точке сливного поддона кофемашины сверлим отверстие 9 мм под него, вставляем его туда и герметизируем соединение. Модель для штуцера под шланг диаметров 8/10 мм ниже по ссылке.

Штуцер / Choke by slimercorp on Sketchfab

Спасибо Chupakabra303 за статью на GeekTimes! Без таймеров, детекторов фронтов сигнала не справился бы с программированием. Честно говоря, очень тяжело работать с Arduino, который изначально не заточен под псевдопараллельность задач как настоящие ПЛК.

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

Общается Arduino следующим способом. При ошибке он пищит N раз с паузой 10 секунд, N — номер ошибки.

N писков:
1 – переполнение бутыли для слива или обрыв в линии связи датчика в этой бутыли с контроллером.
2 – проблема с ультразвуковым датчиком уровня (сонар), он либо утоплен, либо отошел какой-либо из проводов.
3 – не подается вода при попытке ее налить. Проблемы: нет воды в бутылке чистой воды, насос, реле, питание, провода.

Чтобы квитировать ошибку (жест «я понял»), человек жмет на кнопку 1 раз, Arduino высоко пищит в течении 1 секунды, говорит что принято, я молчу. Человек в это время принимает меры для исправления проблемы, Arduino в этом режиме пищит 1 раз в 1 минуту, напоминая о себе. После исправления проблемы человек жмет 2 раза кнопку в течении 3 секунд (жест «проверь систему»), далее Arduino либо снова выдаст ошибку писком, либо 1 раз высоко пропищит, сказав что все хорошо, «работаю дальше».

Помимо этого реализовано:
— debug информация по COM порту, для отладки системы, например, отлаживать положение сонара, чтобы он выдавал нужный уровень;
— писк пищалкой без останова исполнения программы (соответственно с контролем нажатий кнопки).

Исходный код:

#include <Ultrasonic.h>
#include <plcStandardLib_1.h>
//=============================================================
//Формальное объявление необходимых триггеров и переменных
R_TRIG R_TRIG1;
R_TRIG R_TRIG2;
R_TRIG R_TRIG3;
R_TRIG R_TRIG4;
F_TRIG F_TRIG1;

bool TrashFull; //Высокий уровень в отходах
bool igotit; //Обратная связь от человека, что он ошибку понял
bool check_pls; //Признак запроса на проверку состояния системы
bool PumpUp; // Начать качать воду в резервуар чистой воды
bool NoFlow; //Признак отсутствия потока воды от насоса
bool Pressed; //Признак того что кнопка нажата
bool beep_pause_superlong; //Признак супер долгой паузы писка
bool beep_pause_superlong_end; // Признак окончания супер долгой паузы писка
bool beep_pause_long; //Признак долгой паузы писка
bool beep_pause_long_end; //Признак окончания долгой паузы писка
bool beep_pause_short; //Признак короткой паузы писка
bool beep_pause_short_end; //Признак окончания паузы писка
bool beep_on; //Признак присутствия писка на выходе пьезопищалки
bool beep_duration_end; //признак окончания писка
bool beep_granted; //Признак разрешения на писк
bool Pressed_now; //кнопка нажата только что
bool UnPressed_now; //кнопка отжата только что
bool time_end; //время контрольное кончилось
bool reset; // сброс контроля по уровню

int mode; //режим программы
int error; //вид ошибки
int n_pressed; //количество нажатий вовремя интервала 2 секунды
int k_beep; //количество писков за контрольный интервал
float us_level_raw; //расстояние от датчика до воды, сырое значение с датчика
float us_level_filt; ////расстояние от датчика до воды, сырое значение с датчика фильтрованный сигнал
float level; //уровень в баке
float level0; //уровень в баке в момент включения насоса
long t0; //Момент времени при котором начался контроль за нажатием кнопки
long time_to_destroy; //Подсчет времени до разрушения контроля за количеством нажатий кнопок в интервале 2 секунды
//=============================================================

//=============================================================
//Настройка железа
Ultrasonic ultrasonic(4, 3); // 3 - Echo, 4 - Trig
const int LevelTrashPin = 2; //Вход для дискретного датчика в сливе
const int RelayPin = 5; // Выход управления реле
const int BeepPin =  6; // Выход пищалки
const int ButtonPin = 7; //Вход кнопки
//=============================================================


//=============================================================
//Настройка таймеров
//мусорка антидребезг на аварию
TON TON1(50); // таймер на 50мс, инициализация 

//кнопка антидребезг на зажатие и отжатие
TON TON2(50); // таймер на 50мс, инициализация кнопка
TOF TOF1(50); // таймер на 50мс, инициализация

TON TON3(10000); // таймер на 10 секунд, инициализация КОНТРОЛЬНОЕ ВРЕМЯ ПРОВЕРКИ РАБОТЫ НАСОСА

TON TON4(1500); // таймер на 1.5с, инициализация ДЛИТЕЛЬНОСТЬ ПИСКА
TON TON5(1500); // таймер на 1.5с, инициализация ДЛИТЕЛЬНОСТЬ КОРОТКОЙ ПАУЗЫ
TON TON6(10000); // таймер на 10 секунд, инициализация  ДЛИТЕЛЬНОСТЬ ДЛИННОЙ ПАУЗЫ
TON TON7(60000); // таймер на 1 минуту, инициализация ДЛИТЕЛЬНОСТЬ СУПЕРДЛИННОЙ ПАУЗЫ

TON TON8(1000); // таймер на 1 секунду, инициализация ПЕРИОД DEBUG INFO
TON TON9(500); // таймер на 1 секунду, инициализация ПЕРИОД измерений уровня
//=============================================================

//=============================================================
//Настройка констант, параметров системы
const int f_mode=500; //Частота в Гц при подтверждении принятия желания человека
const int f_error=100; //Частота в Гц для ошибок
const int t_nc=5000; //Время отсутствия контроля за ошибками после старта ардуино в мс (time_no_control)
const int dLevel_cp=3; //Уровень должен подняться на столько см за контрольный период (cp - control period)
const int button_cp=3000; //Контрольный период нажатия кнопки в мс
const int t_beep_cm=1000; //Длительности писка уведомления о переходе между режимами, в мс

const float w_level=0.3; //Вес фильтра сонара
const float us_level_filt_fault=0.1; //Значение уровня при котором и ниже считаем датчик в аварии
const float HeightTank = 20; //Высота резервуара в см
const float HighLevel = 15; //Уровень высокий в см
const float LowLevel = 3; //Уровень низкий в см

const bool debug_on=true; //включить ли отладку по Serial
//=============================================================

void setup() {
Serial.begin(9600); // Это команда для Ардуино : задействовать COM порт для передачи данных.
pinMode(LevelTrashPin, INPUT_PULLUP);
pinMode(RelayPin, OUTPUT);
pinMode(BeepPin, OUTPUT);
pinMode(ButtonPin,INPUT_PULLUP);


igotit=false;
check_pls=false;
NoFlow=false;
beep_pause_long=false;
beep_pause_short=false; 
beep_on=false;
beep_pause_superlong=false;
beep_pause_long=false;
beep_pause_short=false;
beep_on=false;

k_beep=0;
t0=millis();
mode=1;
tone(BeepPin,f_mode,1000); //пищим что все ок, инициализация завершена
}

void loop() {
//=============================================================
//Секция считывания данных
//Полный - высокий уровень, Пустой - низкий уровень, Обрыв - высокий уровень.
//антидребезг появления признака переполнения, смена состояния с ПОЛНОГО на ПУСТОЙ происходит без задержки
  TrashFull=TON1.Run((digitalRead(LevelTrashPin))); 
  
//антидребезг появления признака нажатия и отжатия
//кнопка нормально разомкнута, вход с подтягиванием, один конец на земле поэтому
//никто не нажимает - уровень высокий  на входе
//кто то нажал - уровень низкий на входе
//никто не нажимает на кнопку, но прошелся кот и выдернул провод - обрыв
//обрыв - уровень высокий на входе, диагностировать линию в данной конфигурации нельзя,
//но не очень то и нужно (с) Путин
//не очень то и хотелось (с) Таня

  if (TOF1.Run((digitalRead(ButtonPin)))==false) {Pressed=true;}
  if (TON2.Run((digitalRead(ButtonPin)))==true) {Pressed=false;}

//фильтрация значений с датчика уровня
  if (TON9.Run(!TON9.Q)) {us_level_raw=ultrasonic.distanceRead();};
  us_level_filt=(1-w_level)*us_level_filt+w_level*us_level_raw;
  //Уровень в бачке кофемашины от 0 до HeightTank в см;
  level=constrain((HeightTank-us_level_filt), 0, HeightTank) ; 
//=============================================================


//=============================================================
//Секция интерпретирования поведения системы
//NoFlow,igotit,check_pls
  //при нормальной работе за контрольное время работы уровень поднимается на dLevel_cp см и больше.
  //Если такое не происходит, значит у нас либо не работает насос, либо нет воды в бачке
  time_end=TON3.Run(PumpUp && !reset);
  if ((R_TRIG1.Run(PumpUp)==true) | (reset==true)) {level0=level;} //запоминаем уровень при старте насоса
  if ((time_end==true) && (level-level0<dLevel_cp)) {NoFlow=true;} else {NoFlow=false;} //после контрольного времени смотрим изменение уровня
  
  if ((time_end==true) && (NoFlow==false)) {reset=true;} else {reset=false;} //сбрасываем контрольное время и заново контролим уровень
  
//В режиме ошибки и ожидания наблюдаем за нажатиями на кнопку. Считаем сколько раз нажали за контрольный интервал
  Pressed_now=R_TRIG2.Run(Pressed); //Контроль момента нажатия кнопки
  UnPressed_now=F_TRIG1.Run(Pressed); //Контроль момента отжатия кнопки

  if ((mode==2) | (mode==3))
    {
      time_to_destroy=(button_cp-(millis()-t0)); //от button_cp сек через 0 и до минус бесконечность
      if ((Pressed_now==true) && (n_pressed==0) && (time_to_destroy<0)) {t0=millis();} //сбрасываем таймер разрушения только когда пройдет контроль предыдущего отрезка времени
      if ((UnPressed_now==true) && (time_to_destroy>=0))  {n_pressed=n_pressed+1;} //считываем сколько раз отпустили кнопку
      if (time_to_destroy<0) {n_pressed=0;}
    }
    
  //Считываем жест человека - "i got it"/я понял. Это означает что человек подтвердил сообщение о неисправности
  //и принял в работу для исправления, пищать больше не нужно. Человек показывает это следующим действием:
  //нажимает кнопку 1 раз за 2 секунды
  if ((mode==2) && (n_pressed==1)) {igotit=true; n_pressed==0;}

  //Считываем жесть человека - "check_pls"/проверь пожалуйста. Это означает что человек предпринял меры для устранения
  //неисправности или провел необходимые работы по пополнению бутыли исходной воды и слива отработанной воды и предлагает
  //вернуться к работе. Человек показывает это следующим действием:
  //нажимает кнопку 2 раза за 2 секунды
  if ((mode==3) && (n_pressed==2)) {check_pls=true; n_pressed==0;}
//=============================================================




//=============================================================
//Секция переключения режимов
  //Если появился признак переполнения в бутыли слива или обрыва датчика, то переходим в режим ошибки и сообщаем код ошибки 1
  if ((mode==1) && (TrashFull==true) && (millis()>t_nc)) {mode=2; error=1;}
  //Если появился признак обрыва до датчика или утопление самого датчика, то переходим в режим ошибки и сообщаем код ошибки 2
  if ((mode==1) && (us_level_filt<us_level_filt_fault) && (millis()>t_nc)) {mode=2; error=2;}
  //Если появился признак отсутствия подачи воды от насоса, то переходим в режим ошибки и сообщаем код ошибки 3
  if ((mode==1) && (NoFlow==true) && (millis()>t_nc)) {mode=2; error=3;}

  //Если у нас есть ошибка и человек подтвердил - переход в режим ожидания и сбрасываем код ошибки
  if ((mode==2) && (igotit==true)) {mode=3; error=0; igotit=false;}
  
  //Если мы в режиме ожидания и нас попросили проверить все ли ок с системой то переходим в нормальным режим и сбрасываем запрос проверки
  if ((mode==3) && (check_pls==true)) {mode=1; check_pls=false;} 
//=============================================================



//=============================================================
//Основная логика работы в зависимости от режима
   //статус программы: 1 - ВСЕ ОК, работаем; 2 - ОШИБКА, не подтвержденная; 3 - ОШИБКА подтверждена, ожидаем отмашки от человека;
  if (mode==1)
  {
    //Проверяем уровень
    if (level<=LowLevel) {PumpUp=true;} //Уровень ниже минимума - включаем насос
    if (level>HighLevel) {PumpUp=false;} //Уровень выше максимума - выключаем насос
   }

  if ((mode==2) | (mode==3)) {PumpUp=false;} //тут же выключаем насос  чтобы не перегрелся
//=============================================================


//=============================================================
//Секция действий по результату работы программы (Digital Output)
//включаем и отключаем насос по признаку
if (PumpUp==true) {digitalWrite(RelayPin, LOW);} else {digitalWrite(RelayPin, HIGH);}

//Нижестоящий код реализован для писка без delay, который тормозил бы программу и делал бы ее неработоспособной

//При переходе в режим 1-ый делаем секундный писк, что все ок, я перешел
if (R_TRIG3.Run(mode==1)==true) {tone(BeepPin,f_mode,1000); beep_on=false; beep_pause_short=false; beep_pause_long=false; beep_pause_superlong=false; k_beep=0;}


beep_duration_end=TON4.Run(beep_on); //отсчет длительности писка
beep_pause_short_end=TON5.Run(beep_pause_short); //отсчет длительности короткой паузы
beep_pause_long_end=TON6.Run(beep_pause_long); //отсчет длительности длинной паузы
beep_pause_superlong_end=TON7.Run(beep_pause_superlong); //отсчет длительности супер длинной паузы

//пищим в режиме 2-ом, количество писков соответствует номеру ошибки
if (mode==2)
{
  //блокировки писка:
  beep_granted=!beep_pause_long && !beep_pause_short && (k_beep<error);   
  //включаем писк если дали разрешение
  if (beep_granted==true) {tone(BeepPin, f_error); beep_on=true;} 

  //когда длительность писка закончилась, включаем паузу, короткую или длинную, в зависимости от кол-во озвученных писков и номера ошибки
  if (beep_duration_end==true)
  {
    noTone(BeepPin);
    k_beep=k_beep+1; //кол-во озвученных писков
    beep_on=false; //выключаем признак писка
    if  (error>k_beep) {beep_pause_short=true; beep_pause_long=false;} else {beep_pause_long=true; beep_pause_short=false;}
  }
  //когда закончилась короткая пауза, выключаем признак
  if (beep_pause_short_end==true) {beep_pause_short=false;}

  //когда закончилась длинная пауза, выключаем признак
  if (beep_pause_long_end==true) {beep_pause_long=false; k_beep=0;}
}

//при переходе в другой режим, пищим высоко и инициализируем переменые писков
if (R_TRIG4.Run(mode==3)==true) {tone(BeepPin,f_mode,1000); beep_on=false; beep_pause_short=false; beep_pause_long=false; beep_pause_superlong=true;}

//пищим если мы в режиме ожидание, пищим раз в супердолгий интервал
if (mode==3)
{
  beep_granted=!beep_pause_superlong; //не пищим если только у нас есть пауза длительностью в 1 минуту  
  if (beep_granted==true) {tone(BeepPin, f_error); beep_on=true;} 
  //когда длительность писка закончилась, включаем паузу супердолгую
  if (beep_duration_end==true)
    {
      noTone(BeepPin);
      beep_on=false; //выключаем признак писка
      beep_pause_superlong=true;
    }
  //когда закончилась супердлинная пауза, выключаем признак
  if (beep_pause_superlong_end==true) {beep_pause_superlong=false;}
}
//=============================================================


//=============================================================
//Секция Debug, активируется из секции констант
if ((debug_on==true) && (TON8.Run(!TON8.Q)))
{
 //Чистим окно у клиента 
  Serial.write(27);
  Serial.print("[2J"); // clear screen
  Serial.write(27);
  Serial.print("[H"); // cursor to home
 //И начинаем писать всякую информацию о состоянии системы
  Serial.println("=================Debug info of ArduOsch=================");
  Serial.println("=================DicreteInputs==========================");
  Serial.print("LevelTrashPin="); Serial.print((digitalRead(LevelTrashPin)));  Serial.print("| ButtonPin="); Serial.print(digitalRead(ButtonPin)); Serial.print("| US_raw="); Serial.print(us_level_raw); Serial.print("| US_filtered="); Serial.println(us_level_filt); 
  Serial.println("=================DicreteInputs after processing=========");
  Serial.print("TrashFull="); Serial.print(TrashFull);  Serial.print("| ButtonPressed="); Serial.print(Pressed); Serial.print("| Level="); Serial.println(level);
  Serial.println("=================NoFlow condition=======================");
  Serial.print("PumpUp="); Serial.print(PumpUp); Serial.print(" Time_end="); Serial.print(time_end); Serial.print(" Reset="); Serial.print(reset);  Serial.print("| Level0==="); Serial.print(level0); Serial.print("| TON3_EST="); Serial.print(TON3.PT-TON3.ET); Serial.print("| NoFlow="); Serial.println(NoFlow);
  Serial.println("=================How mush was man clicked on button?====");
  Serial.print("TimeToDestroy="); Serial.print(time_to_destroy); Serial.print("| t0="); Serial.print(t0); Serial.print("| n_pressed="); Serial.println(n_pressed);
  Serial.println("=================What is the system state?==============");
  Serial.print("Mode="); Serial.print(mode); Serial.print("| error="); Serial.println(error); 
  Serial.println("=================Beep code==============");
  Serial.print("beep_granted="); Serial.print(beep_granted); Serial.print("| beep_pause_superlong="); Serial.print(beep_pause_superlong); Serial.print("| beep_pause_long="); Serial.print(beep_pause_long); Serial.print("| beep_pause_short="); Serial.println(beep_pause_short);
  Serial.print("k_beep="); Serial.print(k_beep); Serial.print("| beep_on="); Serial.println(beep_on);
}
//=============================================================

}