Arduino.ru

Похоже . Наша песня хороша - начинай сначало. Тут код. http://forum.amperka.ru/threads/%D0%94%D0%BE%D0%BB%D0%B3%D0%BE%D0%B5-%D0%BD%D0%B0%D0%B6%D0%B0%D1%82%D0%B8%D0%B5-%D0%BA%D0%BB%D0%B0%D0%B2%D0%B8%D1%88%D0%B8.11903/page-2#post-116171

void setup() 
 { 
 pinMode(13, OUTPUT); 
 digitalWrite(2,HIGH);
 } 

 void loop() 
 { 
 if(digitalRead(2)==LOW)
 { 
 digitalWrite(13,HIGH);
 } 
 else
 { 
 digitalWrite(13,LOW);
 } 
 } 

Ваше требование к задаче нарушает причинно-следсвенные связи в природе

ну да. но оставалась надежда. значит только еще одна кнопка?

А что вы будете делать второй кнопкой? И потом, если при 5-ти секундном нажиме не нужно зажигать, то зачем вообще ее нажимать? Так что меняйте условия задачи

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

if (digitalRead(2)==LOW) eepget(0);

так же в порт приходят некие данные. и если пришли нужные то я хочу их сохранить в еепром. и все это одной кнопкой

if (digitalRead(2)==LOW) eepget(0);

Так с этого и нужно было начинать .... это вопрос к гуру, например - qwone

@_@ . А я причем? Ладно нажатие  чтение из ячейки #0. Но поперли данные вот вот. Куда писать в ячейку #0. Так пока жмут кнопку 5 сек данные уже поменялись.  

ПС:От вас получили багаж:Диван,Чемодан,Саквояж,Картину,Корзину,КартонкуИ маленькую собачонку.ОднакоЗа время путиСобакаМогла подрасти!

получение данных полностью подконтрольно и можно остановить прием хоть на час. 

Так вам что только чтение из ячейки памяти и запись туда же. Данные int?

Да у него написано - если пришли нужные. Этож анализ нужен

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

анализ программный не нужен- я сам выбираю нужное

Неужели так сложно сообразить что нужно при нажатии кнопки сохранить значение милиса в переменную, а при отпускании вычесть сохраненное из текущего милиса. Получим длительность нажатия кнопки. Если она небольшая - делаем одно, если больше 5сек - то то что надо при длинном нажатии. Как дети малые, ейбогу.

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

Ага. Причем есть два пути:

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

2. опрашиваем кнопку раз в 50-100мсек используя подход как в примере блинкбезделея.

/*Cl_Btn_long.ino
*/
class Cl_Sys;// предварительно объявить о создании класса Sys для послед подключения к нему
//-----Cl_Btn-----------------
class Cl_Btn {
    byte pin; // номер ноги на кнопке
    void (* Do1)(), (* Do2)(); // указателb на обработчики короткого и длин нажатия
    bool btn, btn_old;
    bool bounce = 0; // антидребезговый флаг
    uint32_t past = 0 ;
    const uint32_t time = 500 ;
    bool flag = 0;
    uint32_t past_flag = 0 ;
  public:
    // указатель на следующий элемент
    Cl_Btn *pnt = NULL;
    // конструктора
    Cl_Btn() {}
    Cl_Btn(Cl_Sys *Sys, byte _pin, void (* _Do1)(), void (* _Do2)());
    void setup() {
      pinMode(pin, INPUT_PULLUP);// подключить кнопку 1 с подтяжкой
      btn = digitalRead(pin); // прочитать реальное значение на выводе};
    }
    // setup()
    void loop() {
      if (! bounce && btn != digitalRead(pin)) { // если прошел фронт изм на выводн
        bounce = 1;                              // выставить флаг
        past = millis();                         // сделать временую засветку
      }
      else if ( bounce && millis() - past >= 5 ) { // если прошло антидребезговое время
        bounce = 0;                                // то снять флаг
        btn_old = btn ;
        btn = digitalRead(pin) ;                   // прочитать реальное значение на выводе
        if (btn_old && ! btn) {
          flag = 1;
          past_flag = millis();
        }
        if (! btn_old && btn && flag && millis() - past_flag < time  ) {
          flag = 0;
          Do1();
        }
      }
      if (flag && millis() - past_flag >= time ) {
        flag = 0;
        Do2();
      }
    }
};
//-----Cl_Sys-----------------
class Cl_Sys {
  public:
    Cl_Btn *Start_Btn = NULL;
    Cl_Sys() {}
    // setup()
    void setup() {
      for (Cl_Btn *i = Start_Btn; i != NULL; i = i->pnt) i->setup();
    }
    void loop() {
      for (Cl_Btn *i = Start_Btn; i != NULL; i = i->pnt) i->loop();
    }
} Sys;
//---------описание классов------------
Cl_Btn::Cl_Btn(Cl_Sys *Sys, byte _pin, void (* _Do1)(), void (* _Do2)()): pin(_pin), Do1(_Do1), Do2(_Do2) {
  pnt = Sys->Start_Btn;
  Sys->Start_Btn = this;
}
//----------Компоновка---------------------
void Do1_Btn1() {
  Serial.println("Do_Btn1 short");
}
void Do2_Btn1() {
  Serial.println("Do_Btn1 long");
}
Cl_Btn *Btn_1 = new Cl_Btn(&Sys,/*пин*/2,/*обработчик коротк наж*/Do1_Btn1,/*обработчик длин наж*/Do2_Btn1); // создать кнопку Btn_1
//-----------Main()-----------------------
void setup() {
  Serial.begin(9600);
  Sys.setup();
}

void loop() {
  Sys.loop();
}

можно сделать анализ многих СОСТОЯНИЙ кнопки:

"0" - нажата
"1" - отжата

__________________

Также можно запрограммировать (и определять) наличие "фронтов" кнопки:

0 - без изменений (или нажата или отпущена постоянно). Т.е. "фронт" отсутствует
"-1"  - обнаружен факт "нажатия"
"1" - наличие факта "отпускания" кнопки

_______________________________________

далее по событию фронта (положительного или отрицательного)  - запускаем отсчет таймера

Далее по анализу счетчика таймера программируем что там нужно:
- краткое нажатие
- длительное нажатие
- двойное/тройное нажатие....

Т.е. фиксируем состояние переменных (Например):

Push = 0/1    // событие "нажатия кнопки"
Release = 0/1  // событие "отпусканияк нопки

Hold= 0/1     // событите "удержания кнопки больше заданного времени"
Duble = 0/1   // событие "двойного нажатия за заданный промежуток времени"
...

_________________________________

Далее в программе анализирует состояние этих переменных и запускем на выполнение тот или иной код.

Таким образом одной кнопкой можно управлять МНОГИМИ состояниями объекта (например светодиода/светодиодов)

ЗЫ.Не забудьте добавить время по таймеру "нечувствительности" кнопки, для исключения срабатывания на "дребезг" контактов, например 50 мсек

ЗЫ2. Если очень быстрая программная реакция нужна - можно перейти на использование обработки прерываний

bool bounce = 0;
 bool btn, btn_old;
 uint32_t past = 0 ;
 bool flag = 0;
uint32_t past_flag = 0 ;
 const uint32_t time = 3000 ;
void setup() 
 { 
 Serial.begin(9600);
 digitalWrite(2,HIGH);
 } 
void loop() {
      if (! bounce && btn != digitalRead(2)) { // если прошел фронт изм на выводн
        bounce = 1;                              // выставить флаг
        past = millis();                         // сделать временую засветку
      }
      else if ( bounce && millis() - past >= 5 ) { // если прошло антидребезговое время
        bounce = 0;                                // то снять флаг
        btn_old = btn ;
        btn = digitalRead(2) ;                   // прочитать реальное значение на выводе
        if (btn_old && ! btn) {
          flag = 1;
          past_flag = millis();
        }
        if (! btn_old && btn && flag && millis() - past_flag < time  ) {
          flag = 0;
          Serial.println("do1");
        }
      }
      if (flag && millis() - past_flag >= time ) {
        flag = 0;
        Serial.println("do2");
      }
    }

вроде работает как мне надо. спасибо

а можно ваш код вынести в библиотеку ?

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

итого: 2 байт + 2 * 4 байт = 10 байт ++ на каждую кнопку.

*с большим удовольствием реализую их предложение и назову велосипед именем кота автора алгоритма.

Ну, по ссылке ходить лень, так навскидку:

1. Для хранения состояния кнрпки байт не нужен - достаточно бита.

2. Дискретность времени с точки зрения кнопки можно принять 50 мс. Тогда 11 бит будут соответствовать 100 секундам - существено больше, чем лбое вменяемое "длинное" нажатие. 

Итого, достаточно 24 бита АКА 3 байта.

Пух.

*ок. Пух будет отлит в граните мелким почерком.

с битами состояний кнопки было очевидно - спасибо. 

дискретность времени - так себе идея.

кроме факта нажата/отжата кнопка

еще пригодятся (нужно хранить): 
- фронт положительный (нажатия в текущем цикле)

- фронт отрицательный (отжатия в текущем цикле)

всё хранится, поэтому и оперативка жрётся. с битами протупил - каюсь.

Вообще-то это основополагающая идея работы всей цифровой техники.

Я лишь предложил изменить величину этой дискретности с предполагаемой по умолчанию Ардуино 1 мс до более подходящих для конкретной задачи нескольких десятков мс.

ну, не знаю - на данный момент у меня на матрицу 10х10=100 кнопок расходуется 840 байт RAM. если вычесть ~64 байта на отладочный LCD, то ~776 байт чистыми.

ещё я могу слить две служебные переменные в один байт, т.е. будет ещё -100 байт = 676 байт.

но... калечить функционал, что бы получить много недокнопок - не для того всё задумывалось.

Треть памяти 328-го на матрицу кнопок 8))) Да вы это, того.. а програме что останется?!

Хотя продолжайте, чтоб дибилизм идеи стал очевиден надо довести до полного абсурда! Внешнее ОЗУ для кнопок нужно ;)

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

на манеже всё те же...

алё! гараж! - треть бесценной памяти для 100 кнопок.

твоя программа не будет работать без 100 кнопок - какой смысл возмущаться? :D

я тебя просил, вместо эмоциональных воплей, предложить разумную масштабируемую альтернативу моему дибилизму - ты слился #75

ок - прекращаем капитаноочевидность.

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

ага. каждая из них нажата или нет 0 или 1. 100 бит т.е. 12,5байт. Еще столько же для флага что событие произошло только что, понятно если он вобще нужен в проекте. Плюс 5 байт на хранение времени, фазу строба и др издержки. 

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

та, да - общий фильтр дребезга для трёх кнопок.

про 12 1/2 байта - смешно.

зачем?, если у тебя общий фильтр дребезга, то и состояния 100 кнопок храни в одном бите.

для стороннего ползателя, что бы был понятен мой спор с Логиком:

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

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

ПС. Дребезг - проблема дилетантов, опрашивай кнопки раз в 20-100мксек и дребезга не будет в принципе.

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

а, таймеры удержания и неактивности каждой кнопки - тоже, не нужно?

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

**вдогонку - всем ампутировать 9-ть пальцев. достаточно одного, что бы нажать на кнопку - охранника вызвать.

//таймеры удержания и неактивности каждой кнопки - тоже, не нужно?

Конечно не нужен. Ну сколько ты кнопок собираешся удерживать одновременно? 3-5-10? Ну вот столько таймеров и надо. Появилась активность кнопки - получила таймер, отмерила че надо и освободила.

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

 Так что тупиш здесь именно ты. Что в общем понятно, т.к. излагаемое мной - не для неокрепшего ума ;)

т.е., мой анекдот про одну вилку в ресторане - это твоя реальность.

твои анекдоты- твои проблемы. 800 байт на 100 кнопок - анекдот похлеще будет для ценителей. Но я вижу что ты уже на самом деле все понял о задаче  ;)

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

ты же мне пытаешься доказать, что идея в принципе неудачная.

можно сделать вариант класса минималистик - подключать 200 кнопок к нему и 50 к максимальному варианту.

*но выскакивать с воплями - просто тупо.

Код бывает универсальным и неэффективным (те самые 800байт) либо  заточеным и эффективным. Масштабирование ты себе однобоко представляеш. Это не только возможность кол-во кнопок менять, но и функционал их гибко под задачу делать. 

Пиши если хочется, я  ж в #26 уже разрешил ;)

кому и когда я запретил затачивать мой код под свою задачу?

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

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

если у тебя клавиатура, то напиши для клавиатуры.

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

*напишите хоть кто-нибудь что-нибудь - кроме внебрачных внуков Капитана Очевидность и одного склеротика, у которого программы жрут память, а кнопки - нет, я пока никого не наблюдаю.

Мне не зачем писать обработчик клавиатуры. У меня просто нет необходимости ее использовать на Ардуино. 3-5 кнопок за глаза хватет, и даже много бывает. Другое дело кнопки графического дисплея. Они по мере необходимости создаются и по мере ненужности уничтожаюся. Но это обсуждение не в этой теме.

Шо за истерика в субботу в 8 утра ))) Ты чё, всю ночь не спал над кодом думал, так нифига и не придумал?

Так ты вежливо попроси, с тобой кодом и поделятся старшие товарищи ;)

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

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

дед, угомонись - в маразм ты ещё не впал, но в бестолковое критиканство - уже.

С коего поржать над кодом Клапауций стало критиканством? Здоровый смех - заслуженая  оценка дибилизму с 800 байтами ОЗУ под клавиатуру.

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

не "клавиатуру", а 100 кнопок... кнопок, Карл.