Arduino.ru

  Прочтите книгу Гололобова "С чего начинаются роботы". Она небольшая, но полезная очень.

Гена! Спасибо, конечно за подсказку, но в данном контексте такие советы уже выглядят как перевод стрелок. Поэтому - продолжу нести чушь по теме...

void setup() {
  pinMode(11, OUTPUT);                    // Конфигурируем пин 11 как выход
  pinMode(12, OUTPUT);                    // Конфигурируем пин 12 как выход
  pinMode(13, OUTPUT);                    // Конфигурируем пин 13 как выход
}

void loop() {

  if (digitalRead(A1)) {                   // Если нажата Кнопка1
    digitalWrite(11, 1);                   // включить цифровой пин 11  
  }                 

  if (digitalRead(A2)) {                   // Если нажата Кнопка2
    digitalWrite(12, 1);                   // включить цифровой пин 12
  }

  if (digitalRead(A3)) {                   // Если нажата Кнопка3
    digitalWrite(13, 1);                   // включить цифровой пин 13
  }
}

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

Это я уже фантазирую. Нужен автор что бы прояснить этот момент и опытный программист что бы подсказать как это осуществить )))))

повезло лёхе с хим.завода )))), ведь у него такой кодер )))

Да да! Зато приколистов - хоть отбавляй! ))))

Так... рассуждаем дальше. Будем сейчас побеждать "millis()". 

Введем  переменные типа "unsigned long" что бы хранить в них какое-то значение "millis()", зафиксированное в момент нажатия той или иной кнопки. И потом будем сравнивать их с реальной "millis()". В общем ход мыслей такой:

unsigned long ts1, ts2, ts3 = 0;
void setup() {
  pinMode(11, OUTPUT);                    // Конфигурируем пин 11 как выход
  pinMode(12, OUTPUT);                    // Конфигурируем пин 12 как выход
  pinMode(13, OUTPUT);                    // Конфигурируем пин 13 как выход
}

void loop() {

  if (digitalRead(A1)) {                   // Если нажата Кнопка1
    ts1 = millis();                       // записываем стартовое время
    digitalWrite(11, 1);                   // включить цифровой пин 11  
  }                 

  if (digitalRead(A2)) {                   // Если нажата Кнопка2
    ts2 = millis();                       // записываем стартовое время
    digitalWrite(12, 1);                   // включить цифровой пин 12
  }

  if (digitalRead(A3)) {                   // Если нажата Кнопка3
    ts3 = millis();                       // записываем стартовое время
    digitalWrite(13, 1);                   // включить цифровой пин 13
  }
// ------------------
                                              // если прошла минута и пин D11 в еденице
  if ((millis() - ts1<=1000) & (digitalRead(11)==1)) { 
     digitalWrite(11, 0);                 // переводим пин D11 в ноль
  }
}

Понятно что последний "if" полный бред... сейчас посмотрим что скажет хотябы компилятор...

Не совсем так понят алгоритм. Да действительно кнопка один отвечает только за посыл импульсов: если я нажал на неё 1 раз в устройство попала какая-то переменная например х=1, два раза нажал х=2 и тд. После получения необходимого количества импульсов например х=3 мы можем нажимать на кнопку 2 или кнопку 3. Нажав на кнопку 2 замыкается реле 1 на 180 сек так как х=3, кнопка 3 замыкаются реле 1 и реле 2 на 90 сек. При этом например из 180 сек прошло 20 и пользователь нажал кнопку 1 один раз время стало 220 секунд. Если устройство проработало в режиме 1 и осталось время например 60 секунд, после этого переключив в режим два остаток времени станет 30 секунд и тд

Очень похоже на алгоритм работы микроволновки...

...или насоса.

или компрессора...

Может похоже на микроволновку но это не микроволновка и даже не насос и не компрессор

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

Блин, не знаю как там с Алексеем дела обстоят, а моих куриных мозгов уже явно не хватает...

Рассуждаем:  

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

2. Кнопка №2, (нажатая после первой, режим №1) запускает первое реле на число минут заданное первой кнопкой.

3. Кнопка №3, (нажатая после первой, режим №2) запускает оба реле, но на время равное половине общего.

4. Если выбран режим №1 заданный второй кнопкой,  первой кнопкой можно увеличивать время работы в режиме №1 прибавляя по 1 минуте за каждое нажатие к оставшемуся времени. Работает одно реле.

5. Если выбран режим №1 заданный второй кнопкой, при нажатии на кнопку 2 общее время работы уменьшается в 2 раза за каждое нажатие от оставшегося и вся система переходит в режим №2. Работают оба реле.

Отсюда вопрос:. Что должно происходить если в режиме №1 нажать Кнопку №1 ?

 

----------------------------------------------------- ЗАДАНИЕ ДЛЯ АВТОРА ------------------------------------------------

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

1. Кнопка 1 отвечает только за наращевание времени но не в минутах, а в единицах. Одно нажатие одна единица. Количество нажатий может быть любое хоть одно хоть два хоть 100 для того чтобы активировать кнопки 2, 3.
2. Все верно. Но 1 минута равна одному нажатию условность. Может одна минута быть кратна 2 нажатия или трём. Но в моём случае одна минута одно нажатие.
3. В моем случае 1 минута режима равна 2 нажатия. Один раз нажали получили 30 сек, два 1минута, три 1минута 30 сек и тд.
4. Можно в любом режиме (режим 1 и режим2) нажатием на кнопку 1 увеличивать количество единиц.

Ну так это классическая задача для ООП.

Создаешь класс, который хранит свое текущее состояние и имеет методы для изменения этого состояния.

 

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

Начни просто с четкой словесной формулироки (по-русски), что и как должно происходить.

 Это Вы мне? Потому что я сам так до конца еще не понял чего хочет ТС: то у него нажатие кнопок прибавляет по минуте, то уже по какой-то условной еденице. Из его предидущего объяснения следовало что кнопка 3 в половину уменьшает время, а теперь, оказывается кнопка3 тоже наращивает условную еденицу, но за 2 нажатия... Короче - нам наверно надо начинать не с языка программирования, а с элементарного русского.

Я не знаю...

Уважаемый АлексейТ! Прежде чем Вы не облечёте свою идею в удобоваримую словесную форму никто и никогда не станет гадать на хрустальных шарах чего дейстивтельно Вам хочется. Вы уже третий раз пытаетесь объяснить свою идею и, лично, я - ничерта не понял! Вполне возможно что это я такой дыбил, но пусть тот кто понял чего Вы хотите, бросит в меня камень.

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

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

вот Вам скетч, как я понял ТЗ от ТС. Вопросы по реле остались, придется корректировать поведение определения текущего режима.

Приведенный код компилится без ошибок в 1.6.8

// тут код класса кнопки от Клапауция
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// класс титановый велосипед для тактовой кнопки.
// фильтр дребезга, отслеживание событий: нажатие, отпускание, двойное нажатие(doubleclick), нажато и удерживается в течении определённого времени, отпущено и неактивно в течении определённого времени.

class BUTTON {
public:
//================================================================
static const byte bounce_              =   50; // длительность отслеживания дребезга.
static const byte doubleclick_         =  200; // длительность отслеживания двойного клика.
static const unsigned long timer_      = 5000; // длительность отслеживания неактивности.
static const unsigned int retention_   = 2000; // длительность отслеживания нажатия и удержания.
//================================================================
boolean click_down;
boolean click_up;
boolean doubleclick;
boolean timer;
boolean retention;
//=================================
unsigned long m;
boolean  p;
boolean  b;
boolean dc;
byte     c;
boolean  t;
boolean  r;
//=================================
byte _pb;
//=================================
BUTTON(byte pb) {
_pb = pb;
pinMode(_pb, INPUT);
digitalWrite(_pb, 1);
//====
click_down      = 0;
click_up        = 0;
doubleclick     = 0;
timer           = 0;
retention       = 0;
//====
m  =      millis();
p  = digitalRead(_pb);
b  =                0;
dc =                0;
c  =                0;
t  =                0;
r  =                0;
//====
}

void read() {
//=======================================================
unsigned long nm =      millis();
boolean       np = digitalRead(_pb);
//=================
boolean nb  = 0;
boolean ndc = 0;
boolean nt  = 0;
boolean nr  = 0;
//================
click_down  = 0;
click_up    = 0;
doubleclick = 0;
timer       = 0;
retention   = 0;
//=================
if (np != p) {p = np; m = nm; }
//=======================================================
if (nm - m > bounce_) {nb = 1;}
if (nm - m > doubleclick_) {ndc = 1;}
if (ndc != dc) {dc = ndc; if (dc == 1) {c = 0;}}
if (nb != b) {b = nb;
if (p == 0 && b == 0) {click_down = 1;
++c;      if (c == 2) {c = 0; doubleclick = 1;}
}
if (p == 1 && b == 1) {click_up = 1;}
}
//=======================================================
if (nm - m > timer_) {nt = 1;}
if (nt != t) {t = nt;
if (p == 1 && t == 1) {timer = 1;}
}
//=======================================================
if (nm - m > retention_) {nr = 1;}
if (nr != r) {r = nr;
if (p == 0 && r == 1) {retention = 1;}
}
//=======================================================
}
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// вот, собственно, НАЧАЛО кода
#define reley1 10
#define reley2 11

BUTTON button1(3);
BUTTON button2(4);
BUTTON button3(5);

void setup() {
  // put your setup code here, to run once:
pinMode(reley1, OUTPUT);
pinMode(reley2, OUTPUT);  
}

void loop() {
  // put your main code here, to run repeatedly:
static int time_slots = 0;
static unsigned long time_ms = 0;
unsigned long ms = millis();
int curr_mod = 0;
static int reley1_state = 0;
static int reley2_state = 0;


button1.read();
button2.read();
button3.read();

if (button1.click_down) time_slots++; // инкремент "импульсов" в терминах ТС

if (time_slots) // если еще есть "импульсы"
   {// блок переключения реле
   if (button2.click_down && reley1_state == 0) {digitalWrite(reley1,HIGH); reley1_state = 1;time_ms=ms;}
   else if (button2.click_down && reley1_state == 1) {digitalWrite(reley1,LOW); reley1_state = 0;}

   if (button3.click_down && reley2_state == 0) {digitalWrite(reley2,HIGH); reley2_state = 1;time_ms=ms;}
   else if (button3.click_down && reley2_state == 1) {digitalWrite(reley2,LOW); reley2_state = 0;}
//тут тоже не ясно: я решил, что интервал декремента (60 или 30 сек) отсчитывается заново при любом нажатии кнопок 2 или 3
// возможно, что только от первого нажатия кнопки 2, тогда переключатель режимов нужно немного переписать

   curr_mod = reley1_state + reley2_state; // я решил, что режим2 - это когда оба реле включены, тут я ТС не понял
                                           // ситуация, когда реле2 включено, а реле1 нет - не описана, или я не заметил
   
   if (ms - time_ms > 60000 && curr_mod == 1) {time_slots--; time_ms = ms;} //собственно декремент "импульсов" в зависимости от режимов
   if (ms - time_ms > 30000 && curr_mod == 2) {time_slots--; time_ms = ms;}
   }
else // импульсы кончились
   {
   digitalWrite(reley1,LOW); reley1_state = 0;
   digitalWrite(reley2,LOW); reley2_state = 0;
   time_ms = ms;
   }

}

 

я просто с похмелья - ОЧЕНЬ добрый. сил нет нахер никого посылать.

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

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

На месте ТС я бы предпочёл знать столько же сколько wdrakula, чем просто заполучить рабочий код, и нифига не понимать как такое вообще возможно.

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

Нет, это для TC.

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

Наверное, вредное производство...

Уже приехал с Москвы? Пойдём сюда - нужно мнение умного человека выслушать же ! Я и днём спрашивал, но форум иногда не отправляет комментарии и я решил подождать до вечера.

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

Я сейчас на работе, на сутках. Ардуины дома остались. Приду домой - доделаю этот твой код под вывод режимов и счетчиков на дисплей. Будет мне еще один рабочий проект - пригодится: мне как раз надо устроить управляемую по времени ВЗ (воздушную заслонку) для карбюратора. Ну там не столько сама заслонка, а и управление дросселем (ДЗ). Очень удобно: обойдётся одним сервоприводом. Вообще-то там специфика намного проще: надо реле включать на определенное время, в смысле - сервопривод. Но главное - надо не тупо остановить весь цикл, а именно проверять не истекло ли время. Можно было, конечно, не заморачиваться уж настолько и задействовать одно из прерываний, но они уже будут заняты спидометром и тахометром. Так что "титановый велосипед" будет как раз кстати!

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

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

Баззер!  К дисплею не вернусь, так как, без документации, это просто гадание. Нужно рыть описание.

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

...

нет, вру, уже 500.... Ваше здоровье!

Вот ты андриано спрашиваешь про ООП. Как тебе сказать?... Почитай холивары Евгения, Логика и Архата. Они, в разных комбинациях, часто ругаются.

Почитай и попробуй представить, что все они правы... вот так вот. Архат не приемлет ООП в програмировании МК. Но бывают проекты, где это очень удобно.Логик часто приводит примеры, где примитивные подходы выигрывают по тактам, по сравнению с классикой из учебников.

Мыслить надо в терминах ООП, тут я с Андриано соглашусь, а вот кодить, особенно для МК - не всегда. Если ты в коде объект один-два раза используешь, то может тне стоит его описывать? Может его проще "в голове" держать?

Та вернись - я всё прощу! )))))

Ну ладно. Пороем завещание... В смысле - описание....

Нет, там объект придётся юзать периодически.

Ну так смотрим по коду: класс - есть, поля - есть, методы - есть. Инкапсуляции правда нифига нет, но это уже вопрос культуры программирования. А так - удовлетворяет.

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

Спасибо Дракуле! Пытаюсь разобраться в коде пока удалось процентов на 20.