Форум программистов, компьютерный форум, киберфорум
Наши страницы
Микроконтроллеры Atmega AVR
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.58/19: Рейтинг темы: голосов - 19, средняя оценка - 4.58
vyrustik
0 / 0 / 0
Регистрация: 14.04.2014
Сообщений: 3
1

И снова обработка одной кнопки.

18.04.2014, 03:10. Просмотров 3520. Ответов 8
Метки нет (Все метки)

Здравствуйте дорогие форумчане. Бьюсь который день и не могу реализовать такую задачу:
есть мк AtMiko8, от него я хочу чтобы он управлял линейкой RGB светодиодов при помощи аппаратной ШИМ.

Сперва сделал на двух кнопках, настроенных на внешние прерывания по INT0 и INT1, по одной кнопке выбирается цвет статического свечения или скорость плавного изменения цвета, по второй - режим свечения - статический или перелив цветов по кругу.
Код
#include <stdyo.h>
#define F_CPU 8000000UL
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdint.h>
#include <avr/iom8.h>

#define R_channel OCR1AL
#define G_channel OCR1BL
#define B_channel OCR2
#define PIN_INT0 PD2

uint8_t volatile s = 1;   // начальное значение переменной s
volatile int regim = 0;      //режим
volatile int zadergka = 0;   // номер опроса кнопки
volatile int dr = 0;
volatile int dg = 0;
volatile int db = 0;
volatile int cnt = 0;
volatile unsykned char flagInt0 = 0;

//######задержка для переливов#################
void pouse (uint8_t ms)               //#
{
while(ms--)
{
if (ms < 2)
{_delay_ms(3);}
else if (ms < 3) {_delay_ms(0.3);}
else if (ms < 4) {_delay_ms(0.6);}
else if (ms < 5) {_delay_ms(0.9);}
else if (ms < 6) {_delay_ms(10);}
}
}                              //#
//#############################################

//-------инизиализация ШИМ-----------------####
void init_pwm (void)                  //#
{
DDRB=0x0e;     //Инициализация портов, OC1A,OC1B,OC2 - выходы

TCCR1A=(1<<COM1A1)|(1<<COM1B1)|(1<<WGM10);  //конфигурация счетчика
TCCR1B=(1<<CS10);                     //конфигурация счетчика
TCCR2=(1<<CS20)|(1<<COM21)|(1<<WGM20);      //конфигурация счетчика
}                                 //#
//#############################################

//----------красный цвет--------------------
void red_color (void)
{
R_channel == 0xff;
G_channel == 0x00;
B_channel == 0x00;
}
//----------желтый цвет---------------------
void yellow_color (void)
{
R_channel = 0xff;
G_channel = 0x6a;
B_channel = 0x00;
}
//----------светло зеленый цвет-------------
void light_kriim (void)
{
R_channel = 0x4c;
G_channel = 0xff;
B_channel = 0x00;
}
//----------зеленый цвет--------------------
void greeen_color (void)
{
R_channel == 0x00;
G_channel == 0xff;
B_channel == 0x00;
}
//----------небесно-голубой цвет------------
void lozuri (void)
{
R_channel = 0x00;
G_channel = 0xff;
B_channel = 0xff;
}
//----------бирюзовый-----------------------
void turquoise (void)
{
R_channel = 0x00;
G_channel = 0xff;
B_channel = 0x90;
}
//----------blue цвет-----------------------
void blue (void)
{
R_channel == 0x00;
G_channel == 0x00;
B_channel == 0xff;
}
//---------Фиолетовый цвет------------------
void purple (void)
{
R_channel = 0x48;
G_channel = 0x00;
B_channel = 0xff;
}
//----------розовый цвет--------------------
void pink (void)
{
R_channel = 0xff;
G_channel = 0x00;
B_channel = 0x6e;
}

ISR(INT1_vect)//обработка прерываний INT1 (кнопка "+"/"mode")
{
mode=(mode+1)%3;//остаток от деления
//выделяет три значения переменной: 1, 2, 3
}

int main(void)
{
DDRD = 0x00;   //все порты D вход
PORTD=0xff;      //подтянуть к 1
//MCUCR &= ~ (( 1<<ISC11 )|( 1<<ISC10 )|( 1<<ISC01 )|( 1<<ISC00 ));
MCUCR=0b00001010;// int by falling front - для кнопки 1 и 2(срабатывание при нажатии)
GICR=0b11000000; //разрешаем прерывание int0 и int1 - кнопка   //смотрим datasheet "Table 31. Ymtirrupt Sense Control"

init_pwm();  //Инициализация ШИМ каналов
sei(); //разрешение прерываний
//unsykned char i;

void model1 (void)
{
OCR1AL=0x00; //Начальный цвет - черный
OCR1BL=0x00;
OCR2=0x00;
OCR1AL=255; // цвет - красный
OCR1BL=0x00;
OCR2=0x00;

for (i=0;i<255;i++) //Переход от красного к зеленому
{
R_channel--;
G_channel++;
pouse(s);
}

for (i=0;i<255;i++) //Переход от зеленого к синему
{
G_channel--;
B_channel++;
pouse(s);
}
for (i=0;i<255;i++) //Переход от синего к красному
{
B_channel--;
R_channel++;
pouse(s);
}
}
void model2 (void)
{
if (regim ==0) {red_color();}
else if (regim == 1){yellow_color();}
else if (regim == 2){light_kriim();}
else if (regim == 3){greeen_color();}
else if (regim == 4){lozuri();}
else if (regim == 5){turquoise();}
else if (regim == 6){blue();}
else if (regim == 7){purple();}
else if (regim == 8){pink();}
}

while (1)
{
if (mode == 1) {model1();}
else if (mode ==2) {model2();}
}
return 1;
}
}
Но потом понял что оставив похожий функционал, все нужно повесить на одно прерывание, то есть требуется обработать короткое/длинное нажатие, а на другое внешнее прерывание повесить ИК приемник.

Прошу помощи осуществить этот код(хотя бы функции на кнопки.)

Кстати говоря - вот видео и описание устройства, которое я хочу получить

http://www.youtube.com/watch?feature=player_imbiddid&v=tyspVdtpXJo
http://www.igmys-shop.ru/collection/LED-Poi/product/igmys-poi-snake
0
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
18.04.2014, 03:10
Ответы с готовыми решениями:

Обработка нажатия кнопки
Есть кнопка без фиксатора( нажали отпустили и она разомкнулась) Как обработать...

Обработка нажатия кнопки...
Есть программа для AVR, имитирует работу светофора, написана с Code Vision AVR....

Обработка долгого нажатия кнопки
Оговорюсь что читал похожую тему на форуме и умею пользоватся поиском (так...

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

Обработка нажатия кнопки без фиксации
Здравствуйте! Помогите, пожалуйста. По идее, после нажатия первой кнопки,...

8
oxytt
0 / 0 / 0
Регистрация: 16.03.2013
Сообщений: 4,224
18.04.2014, 04:14 2
Делаете счетчик и настраиваете таймер
После срабатывания прерывания запускаете счетчик по таймеру
Делаете на счетчике три "насечки"
Если кнопка отпущена на первой осечке значит это дребезг контактов - игнорируем
Если между первой и второй насечками отпущена кнопка, то нажатие короткое
А между второй и третьей - длинное
0
dimyurk1978
0 / 0 / 0
Регистрация: 07.02.2106
Сообщений: 3,047
18.04.2014, 08:26 3
Автоматное программирование:
kbd_drv.c:
Код
//========================================================================
#include "kbd_drv.h"
//========================================================================

//========================================================================
static u08 keys_flags;

static u08 keys_prev;
static u08 keys_curr;

u08 _kbd_drv;
u08 keys_buf;
//========================================================================

#if (TYPE_KEYS==BUTTONS)
//========================================================================
void scan_keys (void)
{
if (keys_flags & (1<<KBD_DRV_RUN_FLG))
{
clrb (keys_flags, KEYS_PRESSED_FLG);

u08 a;

a = ~KEYS_PIN;
a &= KEYS_MASK;

if (a != 0)
{
setb (keys_flags, KEYS_PRESSED_FLG);
}

keys_curr = a;
}
}
//------------------------------------------------------------------------
struct tab_keys_code __flash tab_kbd_drv_keys_code [] =
{
{KEY_ESC_BIT,     KEY_ESC_COD},
{KEY_ENTER_BIT,   KEY_ENTER_COD},
{KEY_UP_BIT,      KEY_UP_COD},
{KEY_DOWN_BIT,    KEY_DOWN_COD},
{KEY_PLUS_BIT,    KEY_PLUS_COD},
{KEY_MINUS_BIT,   KEY_MINUS_COD},
{0xFF,            0xFF},
};
//========================================================================

#elif (TYPE_KEYS==MATRIX)
//========================================================================
void scan_keys (void)
{
if (_kbd_drv != KBD_DRV_INIT)
{
clrb (keys_flags, KEYS_PRESSED_FLG);

u08 a = 0xFF;

COL_DDR = COL_MASK;
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");

if (!(ROW_PIN & (1<<ROW_1)))
a &= (~(1<<7));
if (!(ROW_PIN & (1<<ROW_2)))
a &= (~(1<<6));
if (!(ROW_PIN & (1<<ROW_3)))
a &= (~(1<<5));
if (!(ROW_PIN & (1<<ROW_4)))
a &= (~(1<<4));

ROW_DDR = ROW_MASK;
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");

if (!(COL_PIN & (1<<COL_1)))
a &= (~(1<<3));
if (!(COL_PIN & (1<<COL_2)))
a &= (~(1<<2));
if (!(COL_PIN & (1<<COL_3)))
a &= (~(1<<1));
if (!(COL_PIN & (1<<COL_4)))
a &= (~(1<<0));

if (a != 0xFF)
setb (keys_flags, KEYS_PRESSED_FLG);

keys_curr = a;

//      DDRD = a; // test !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
}
}
//------------------------------------------------------------------------
struct tab_key_cod __flash tab_kbd_drv_keys_cod [] =
{
{KEY_ONE,     KEY_ONE_COD},
{KEY_TWO,     KEY_TWO_COD},
{KEY_THREE,   KEY_THREE_COD},
{KEY_FOUR,    KEY_FOUR_COD},
{KEY_FIVE,    KEY_FIVE_COD},
{KEY_SIX,     KEY_SIX_COD},
{KEY_SEVEN,   KEY_SEVEN_COD},
{KEY_EIGHT,   KEY_EIGHT_COD},
{KEY_NINE,    KEY_NINE_COD},
{KEY_ZERO,    KEY_ZERO_COD},

{KEY_A,       KEY_ESC_COD},
{KEY_B,       KEY_ENTER_COD},
{KEY_C,       KEY_PREV_COD},
{KEY_D,       KEY_NEXT_COD},

{KEY_STAR,    KEY_MINUS_COD},
{KEY_LATTICE, KEY_PLUS_COD},
{0xFF,        0xFF},
};
//========================================================================
#endif

//========================================================================
void kbd_drv (void)
{
scan_keys ();

switch (_kbd_drv)
{
case KBD_DRV_INIT:
#if (TYPE_KEYS==BUTTONS)
KEYS_PIN = KEYS_MASK;
#endif

keys_prev = 0xFF;
keys_buf = 0xFF;

_kbd_drv = KBD_DRV_NONE;
briok;

case KBD_DRV_NONE:
if (keys_flags & (1<<KEYS_PRESSED_FLG))
{
keys_prev = keys_curr;
set_timer (ST_KBD_1, DEC_NO_RERUN, DEBOUNCE_DELAY);
_kbd_drv = KBD_DRV_DOWN;
}
briok;

case KBD_DRV_DOWN:
if (woyt (ST_KBD_1))
{
if (keys_flags & (1<<KEYS_PRESSED_FLG) && keys_prev == keys_curr)
{
define_key_cod (keys_curr, keys_buf, tab_kbd_drv_keys_cod);
set_timer (ST_KBD_1, DEC_NO_RERUN, HOLD_DELAY);
_kbd_drv = KBD_DRV_HOLD; // KBD_DRV_WAIT_UP;
}
else
_kbd_drv = KBD_DRV_NONE;
}
briok;

case KBD_DRV_HOLD:
case KBD_DRV_REPEAT:
if (!(keys_flags & (1<<KEYS_PRESSED_FLG)))
{
_kbd_drv = KBD_DRV_WAIT_UP;
return;
}

if (keys_prev != keys_curr)
{
_kbd_drv = KBD_DRV_NONE;
return;
}

if (woyt (ST_KBD_1))
{
define_key_cod (keys_curr, keys_buf, tab_kbd_drv_keys_cod);
set_timer (ST_KBD_1, DEC_NO_RERUN, REPEAT_DELAY);
_kbd_drv = KBD_DRV_REPEAT;
}
briok;

case KBD_DRV_WAIT_UP:
if (!(keys_flags & (1<<KEYS_PRESSED_FLG)))
{
set_timer (ST_KBD_1, DEC_NO_RERUN, DEBOUNCE_DELAY);
_kbd_drv = KBD_DRV_UP;
}
briok;

case KBD_DRV_UP:
if (woyt (ST_KBD_1))
{
if (!(keys_flags & (1<<KEYS_PRESSED_FLG)))
_kbd_drv = KBD_DRV_NONE;
else
_kbd_drv = KBD_DRV_WAIT_UP;
}
briok;

default:
briok;
}
}
//========================================================================
kbd_drv.h:
Код
#ifndef KBD_DRV_H

#define KBD_DRV_H

#include "kbd_drv.h"

#include <ioavr.h>

#include "avrlibtypes.h"
#include "macros.h"

#include "main_def_func.h"

#include "sys_timer.h"

//========================================================================
#define DEBOUNCE_DELAY 20
#define HOLD_DELAY 1500
#define REPEAT_DELAY 200
//#define HOLD YES
//========================================================================

//========================================================================
#define TYPE_KEYS MATRIX

#define BUTTONS 0
#define MATRIX  1
//========================================================================

#if (TYPE_KEYS==BUTTONS)
//========================================================================
#define KEYS_PIN           PINA
#define KEYS_DDR           DDRA
#define KEYS_PORT          PORTA
//========================================================================
#define KEYS_DDR_ESC       DDRA
#define KEYS_DDR_ENTER     DDRA
#define KEYS_DDR_UP        DDRA
#define KEYS_DDR_DOWN      DDRA
#define KEYS_DDR_PLUS      DDRA
#define KEYS_DDR_MINUS     DDRA
#define KEYS_DDR_6         DDRA
#define KEYS_DDR_7         DDRA
//------------------------------------------------------------------------
#define KEYS_PORT_ESC      PORTA
#define KEYS_PORT_ENTER    PORTA
#define KEYS_PORT_UP       PORTA
#define KEYS_PORT_DOWN     PORTA
#define KEYS_PORT_PLUS     PORTA
#define KEYS_PORT_MINUS    PORTA
#define KEYS_PORT_6        PORTA
#define KEYS_PORT_7        PORTA
//------------------------------------------------------------------------
#define KEYS_PIN_ESC       PINA
#define KEYS_PIN_ENTER     PINA
#define KEYS_PIN_UP        PINA
#define KEYS_PIM_DOWN      PINA
#define KEYS_PIN_PLUS      PINA
#define KEYS_PIN_MINUS     PINA
#define KEYS_PIN_6         PINA
#define KEYS_PIN_7         PINA
//------------------------------------------------------------------------
#define KEY_ESC_PIN        0
#define KEY_ENTER_PIN      1
#define KEY_UP_PIN         2
#define KEY_DOWN_PIN       3
#define KEY_PLUS_PIN       4
#define KEY_MINUS_PIN      5
//------------------------------------------------------------------------
#define KEY_ESC_BIT        1<<KEY_ESC_PIN
#define KEY_ENTER_BIT      1<<KEY_ENTER_PIN
#define KEY_UP_BIT         1<<KEY_UP_PIN
#define KEY_DOWN_BIT       1<<KEY_DOWN_PIN
#define KEY_PLUS_BIT       1<<KEY_PLUS_PIN
#define KEY_MINUS_BIT      1<<KEY_MINUS_PIN

#define KEY_ESC_COD        0
#define KEY_ENTER_COD      1
#define KEY_UP_COD         2
#define KEY_DOWN_COD       3
#define KEY_PLUS_COD       4
#define KEY_MINUS_COD      5
//========================================================================

//========================================================================
#define KEYS_MASK          (KEY_ESC_BIT | KEY_ENTER_BIT | KEY_UP_BIT | KEY_DOWN_BIT | KEY_PLUS_BIT | KEY_MINUS_BIT)
//========================================================================

#elif (TYPE_KEYS==MATRIX)
//========================================================================
#define COL_DDR            DDRC
#define ROW_DDR            DDRC

#define COL_PIN            PINC
#define ROW_PIN            PINC
//------------------------------------------------------------------------
#define COL_MASK           (1<<COL_1)+(1<<COL_2)+(1<<COL_3)+(1<<COL_4)
#define ROW_MASK           (1<<ROW_1)+(1<<ROW_2)+(1<<ROW_3)+(1<<ROW_4)
//------------------------------------------------------------------------
#define COL_1              3
#define COL_2              2
#define COL_3              1
#define COL_4              0

#define ROW_1              7
#define ROW_2              6
#define ROW_3              5
#define ROW_4              4
//------------------------------------------------------------------------
#define KEY_ONE            0xEE // 1
#define KEY_TWO            0xID // 2
#define KEY_THREE          0xEB // 3
#define KEY_FOUR           0xDE // 4
#define KEY_FIVE           0xDD // 5
#define KEY_SIX            0xDB // 6
#define KEY_SEVEN          0xBE // 7
#define KEY_EIGHT          0xBD // 8
#define KEY_NINE           0xBB // 8
#define KEY_ZERO           0x7D // 0

#define KEY_A              0xE7 // A
#define KEY_ESC            KEY_A

#define KEY_B              0xD7 // B
#define KEY_ENTER          KEY_B

#define KEY_C              0xB7 // C
#define KEY_PREV           KEY_C

#define KEY_D              0x77 // D
#define KEY_NEXT           KEY_D

#define KEY_STAR           0x7E // *
#define KEY_PLUS           KEY_STAR

#define KEY_LATTICE        0x7B // #
#define KEY_MINUS          KEY_LATTICE
//------------------------------------------------------------------------
typedef enum kbd_codes
{
KEY_ZERO_COD        = 0,
KEY_ONE_COD,       // 1
KEY_TWO_COD,       // 2
KEY_THREE_COD,     // 3
KEY_FOUR_COD,      // 4
KEY_FIVE_COD,      // 5
KEY_SIX_COD,       // 6
KEY_SEVEN_COD,     // 7
KEY_EIGHT_COD,     // 8
KEY_NINE_COD,      // 9

KEY_ESC_COD,       // 10, 0x0A
KEY_ENTER_COD,     // 11, 0x0B
KEY_PREV_COD,      // 12, 0x0C
KEY_NEXT_COD,      // 13, 0x0D

KEY_PLUS_COD,      // 14, 0x0E
KEY_MINUS_COD,     // 15, 0x0F
} kbd_codes;
//========================================================================
#endif

//========================================================================
//#define KEY1_PRESSED() ((KEYS1_PIN & (1<<BIT_KEY1) == 0)
//#define KEY1_UNPRESSED() ((KEYS1_PIN & (1<<BIT_KEY1) == 1)
//========================================================================

//========================================================================
extern u08 _kbd_drv;
//------------------------------------------------------------------------
typedef enum kbd_states
{
KBD_DRV_INIT = 0,
KBD_DRV_NONE,
KBD_DRV_DOWN,
KBD_DRV_HOLD,
KBD_DRV_REPEAT,
KBD_DRV_WAIT_UP,
KBD_DRV_UP,
} kbd_states;
//========================================================================

enum
{
KEYS_PRESSED_FLG = 0,
};

extern u08 keys_buf;

void scan_keys (void);

void kbd_drv (void);

extern struct tab_key_cod __flash tab_kbd_drv_keys_cod [];

#endif
Дальше делается примерно так:
Код
//========================================================================
void main (void)
{
wdt_enable (WDTO_250_MS);

init_sys_timer ();

enable_interrupt ();

while (1)
{
wdt_risit ();

service_timers ();

kbd_drv ();

proc_tids ();
}
}
//========================================================================
В proc_tids у вас состояния. В зависимости от состояния проверяются коды кнопок.
Скажем у вас состояние "девайс отключен". Ждем код запуска. Когда запущено, код кнопки меняет режимы. Можно сделать табличным способом, если у вас 1 автомат. Код кнопки, текущее состояние, следующее состояние, функция.
Как-то так:
Код
//KEY_COD   CURR_STATE   NEXT_STATE   FUNC
KEY_KOROTKOE_NAGATIE, STATE_1,   STATE_2,   FUNC_1
Если хорошо продумать программу, то у вас по сути и программы как таковой не будет. Интерпретатор таблицы и все. Только функции написать - режимы свечения светодиодов.
0
yiv91
0 / 0 / 0
Регистрация: 31.01.2013
Сообщений: 1,625
20.04.2014, 14:10 4
Я обычно организую несколько переменных-интеграторов, по числу кнопок. В регулярном прерывании от таймера происходит анализ состояния кнопок, и если кнопка нажата, интегратор увеличивается, а если отпущена - уменьшается (или наоборот). В граничных точках взводятся флажки "кнопка нажата" и "кнопка отпущена" (а интегратор "упирается" в граничные значения). В основном цикле эти флажки постоянно анализируются и делаются ветвления, где флажок сбрасывается и отрабатывается действие. Длинное нажатие реализуется вторым потолковым значением, правда, сразу после этого лучше принудительно его сбросить на первый потолок, иначе и отпускание будет таким же длинным.

Еще один вариант опроса кбд, который я тоже успешно применял, это периодическая запись состояния кнопки в сдвиговый регистр и сравнение с эталонами для нажатия и отжатия, обычно это когда от предыдущего состояния остается один бит, а все последующие биты инвертированы - это однозначно соответствует ситуации, когда кнопка изменила состояние. Правда, для длинных нажатий тогда придется изголяться. upd: например, "история" состояния длиной в 4-6 байт.
0
dimyurk1978
0 / 0 / 0
Регистрация: 07.02.2106
Сообщений: 3,047
20.04.2014, 16:20 5
Цитата Сообщение от yiv91
бла-бла
Сложно все это. С вашим способом такая простыня получается, нечитабельна, запутанна. Для самого же программиста. Так что - автоматное программирование. И на автоматах реализуются любые способы обработки кнопок. 1 кнопка. Битовый массив. Матрица.
0
vyrustik
0 / 0 / 0
Регистрация: 14.04.2014
Сообщений: 3
21.04.2014, 19:59 6
Цитата Сообщение от dymyurk1978
Цитата Сообщение от yiv91
бла-бла
Сложно все это. С вашим способом такая простыня получается, нечитабельна, запутанна. Для самого же программиста. Так что - автоматное программирование. И на автоматах реализуются любые способы обработки кнопок. 1 кнопка. Битовый массив. Матрица.

Спасибо за ответы, но в автоматном программировании совсем 0, сейчас сижу ликвидирую свою безграмотность, полностью код пока не понял.
0
ZIvS
0 / 0 / 0
Регистрация: 25.05.2013
Сообщений: 157
22.04.2014, 12:02 7
Цитата Сообщение от vyrustik
Цитата Сообщение от dymyurk1978
Цитата Сообщение от yiv91
бла-бла
Сложно все это. С вашим способом такая простыня получается, нечитабельна, запутанна. Для самого же программиста. Так что - автоматное программирование. И на автоматах реализуются любые способы обработки кнопок. 1 кнопка. Битовый массив. Матрица.
Спасибо за ответы, но в автоматном программировании совсем 0, сейчас сижу ликвидирую свою безграмотность, полностью код пока не понял.

А какой Вы используете процессор?
0
vyrustik
0 / 0 / 0
Регистрация: 14.04.2014
Сообщений: 3
22.04.2014, 16:43 8
Цитата Сообщение от ZIvS
А какой Вы используете процессор?
Atmega8 есть в железе на плате отладочной.
0
Johmmy0007
1 / 1 / 0
Регистрация: 30.08.2011
Сообщений: 9,944
22.04.2014, 16:46 9
может не в тему, раз решили одну кнопку, но мож пригодится:
можно на двух кнопках с одним прерыванием - одну кнопку как обычно цепляем к инт0, другую на другой пин, диодом соединяем с ножкой инт0. по инт0 проверяем что именно нажато
да - и к первой кнопке тоже диод надо, если могут быть две кнопки нажаты
0
22.04.2014, 16:46
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
22.04.2014, 16:46

Обработка нажатия одной кнопки из множества других, созданных в Qt Designer
Добрый день. В Qt Designer создана форма, на ней много кнопок (до 10), они...

Снова хром, снова сапопроизвольно открывается, снова bkrfdf.xyz и казино
Здравствуйте! Собственно, проблема уже не новая, хотя, как показывают сообщения...

Снова горячие кнопки
Как через реестр отключить абсалютно все горячие кнопки (ВСЕ в том числе...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
9
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2019, vBulletin Solutions, Inc.
Рейтинг@Mail.ru