306 lines
6.8 KiB
C
306 lines
6.8 KiB
C
/* nazwa pliku: key.c
|
|
opis: Miernik C02
|
|
Odczyt klawiszy
|
|
*/
|
|
|
|
#include "keys.h"
|
|
#include "gpio.h"
|
|
#include "../error.h"
|
|
#include "stm32f10x.h"
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#ifdef USE_RTOS
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
#endif
|
|
|
|
//------------------------definicje--------------------------------//
|
|
#define DEBOUNCE_DELAY 5 //0,5ms
|
|
#define NUM_INPUTS 4
|
|
#define KEY_LONG_PRESS_TIME 30000
|
|
#define KEY_SHORT_PRESS_TIME 100
|
|
#define ENCODER1_DIVIDER 2
|
|
#define ENCODER2_DIVIDER 2
|
|
|
|
enum
|
|
{
|
|
STATE_KEY1,
|
|
STATE_KEY2,
|
|
STATE_ENC1,
|
|
STATE_ENC2,
|
|
};
|
|
|
|
|
|
//------------------------zmienne globalne-------------------------//
|
|
static int8_t inputs_state_tmp1[NUM_INPUTS], inputs_state_tmp2[NUM_INPUTS], inputs_state[NUM_INPUTS], prev_inputs_state[NUM_INPUTS];
|
|
static uint8_t key,new_key;
|
|
static uint32_t timestamp;
|
|
//tablica ma przełożyć fizyczny kod klawisza(wynikający z konstrukcji klawiatury), na ten zdefiniowany w key.h
|
|
|
|
//--------------------------Zmienne zewnętrzne zue------------------------//
|
|
#ifdef USE_RTOS
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
#define TICK xTaskGetTickCount()
|
|
#else
|
|
extern uint32_t tick; // z systick.c
|
|
#define TICK tick
|
|
#endif
|
|
|
|
//------------------deklaracje funkcji prywatnych-------------------//
|
|
uint8_t CalculateKeyCode(void);
|
|
void Debounce (void);
|
|
void ReadInputsState (void );
|
|
|
|
//-----------------------------Funkcje------------------------------//
|
|
|
|
/* KEY_init
|
|
* \opis Konfiguracja początkowa klawiatury
|
|
*/
|
|
void keys_Initialize(void)
|
|
{
|
|
GPIO_InitTypeDef GPIO_Conf;
|
|
#ifdef USE_KEY
|
|
//włącz zegar GPIOC
|
|
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOE, ENABLE);
|
|
|
|
//klawisze i enkodery - wejście + pullup
|
|
GPIO_Conf.GPIO_Pin=KEY1|ENC1A|ENC1B;
|
|
GPIO_Conf.GPIO_Mode=GPIO_Mode_IPU;
|
|
GPIO_Conf.GPIO_Speed=GPIO_Speed_50MHz;
|
|
GPIO_Init(GPIOE,&GPIO_Conf);
|
|
GPIO_Conf.GPIO_Pin=KEY2|ENC2A|ENC2B;
|
|
GPIO_Init(GPIOB,&GPIO_Conf);
|
|
|
|
//TEST
|
|
/*
|
|
GPIO_Conf.GPIO_Pin = IN1;
|
|
GPIO_Conf.GPIO_Mode = GPIO_Mode_Out_PP;
|
|
GPIO_Conf.GPIO_Speed = GPIO_Speed_50MHz;
|
|
GPIO_Init(GPIOB, &GPIO_Conf);
|
|
GPIO_Reset(GPIOB,IN1);
|
|
*/
|
|
|
|
//brak naciśniętych klawiszy
|
|
new_key=0;
|
|
key=0;
|
|
ReadInputsState();
|
|
#else
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
/* KEY_Poll
|
|
* \opis funkcja sprawdza stan klawiszy
|
|
*/
|
|
|
|
void keys_Poll (void)
|
|
{
|
|
|
|
#ifdef USE_KEY
|
|
|
|
//GPIO_Set(GPIOB,IN1);
|
|
ReadInputsState();
|
|
//GPIO_Reset(GPIOB,IN1);
|
|
|
|
Debounce();
|
|
key = CalculateKeyCode();
|
|
|
|
if(key)
|
|
{
|
|
new_key=1;
|
|
}
|
|
|
|
#else
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
/* KEY_get
|
|
* \opis Funkcja zwraca użytkownikowi kod naciśniętego klawisza, lub 0 gdy żaden nie został naciśnięty
|
|
\return - kod klawisza lub 0
|
|
*/
|
|
|
|
uint8_t keys_GetKeyCode (void)
|
|
{
|
|
if(new_key)
|
|
{
|
|
return key;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/* KEY_clear_event
|
|
* \opis Informacja zwrotna od użytkownika - kod klawisza został obsłużony
|
|
*/
|
|
|
|
void keys_ClearEvent (void)
|
|
{
|
|
new_key=0;
|
|
}
|
|
|
|
|
|
void ReadInputsState (void )
|
|
{
|
|
static uint16_t encoder1_state, encoder1_prev_state, encoder2_state, encoder2_prev_state;
|
|
|
|
|
|
//odczyt
|
|
if( (GPIO_Read(GPIOE) & KEY1) == 0)
|
|
inputs_state_tmp1[STATE_KEY1] = 1;
|
|
else
|
|
inputs_state_tmp1[STATE_KEY1] = 0;
|
|
|
|
if( (GPIO_Read(GPIOB) & KEY2) == 0)
|
|
inputs_state_tmp1[STATE_KEY2] = 1;
|
|
else
|
|
inputs_state_tmp1[STATE_KEY2] = 0;
|
|
|
|
inputs_state_tmp1[STATE_ENC1] = 0;
|
|
if (GPIO_Read(GPIOE) & ENC1A)
|
|
inputs_state_tmp1[STATE_ENC1] |= 0x01;
|
|
if (GPIO_Read(GPIOE) & ENC1B)
|
|
inputs_state_tmp1[STATE_ENC1] |= 0x02;
|
|
|
|
inputs_state_tmp1[STATE_ENC2] = 0;
|
|
if (GPIO_Read(GPIOB) & ENC2A)
|
|
inputs_state_tmp1[STATE_ENC2] |= 0x01;
|
|
if (GPIO_Read(GPIOB) & ENC2B)
|
|
inputs_state_tmp1[STATE_ENC2] |= 0x02;
|
|
}
|
|
|
|
void Debounce (void)
|
|
{
|
|
uint8_t i;
|
|
|
|
for (i = 0; i < NUM_INPUTS; i++)
|
|
if(inputs_state_tmp1[i] != inputs_state_tmp2[i])
|
|
{
|
|
timestamp = TICK;
|
|
inputs_state_tmp2[i] = inputs_state_tmp1[i];
|
|
}
|
|
|
|
if (TICK - timestamp >= DEBOUNCE_DELAY)
|
|
for(i = 0; i < NUM_INPUTS; i++)
|
|
{
|
|
prev_inputs_state[i] = inputs_state[i];
|
|
inputs_state[i] = inputs_state_tmp2[i];
|
|
}
|
|
}
|
|
|
|
|
|
uint8_t CalculateKeyCode(void)
|
|
{
|
|
|
|
static uint8_t key1_code_sent, key2_code_sent;
|
|
static portTickType ts_key1, ts_key2;
|
|
static int8_t encoder1_cntr, encoder2_cntr;
|
|
|
|
// KEY1
|
|
if(inputs_state[STATE_KEY1] && prev_inputs_state[STATE_KEY1] == 0)
|
|
{
|
|
ts_key1 = TICK;
|
|
key1_code_sent = 0;
|
|
}
|
|
|
|
if( (inputs_state[STATE_KEY1] == 0) &&
|
|
(prev_inputs_state[STATE_KEY1] ) &&
|
|
(key1_code_sent == 0) &&
|
|
(TICK - ts_key1 >= KEY_SHORT_PRESS_TIME ) )
|
|
{
|
|
key1_code_sent = 1;
|
|
return KEYCODE_KEY1_SHORT;
|
|
}
|
|
|
|
if( (inputs_state[STATE_KEY1]) &&
|
|
(prev_inputs_state[STATE_KEY1]) &&
|
|
(key1_code_sent == 0) &&
|
|
(TICK - ts_key1 >= KEY_LONG_PRESS_TIME ) )
|
|
{
|
|
key1_code_sent = 1;
|
|
return KEYCODE_KEY1_LONG;
|
|
}
|
|
|
|
// KEY2
|
|
if(inputs_state[STATE_KEY2] && prev_inputs_state[STATE_KEY2] == 0)
|
|
{
|
|
ts_key2 = TICK;
|
|
key2_code_sent = 0;
|
|
}
|
|
|
|
if( (inputs_state[STATE_KEY2] == 0) &&
|
|
(prev_inputs_state[STATE_KEY2] ) &&
|
|
(key2_code_sent == 0) &&
|
|
(TICK - ts_key2 >= KEY_SHORT_PRESS_TIME ) )
|
|
{
|
|
key2_code_sent = 1;
|
|
return KEYCODE_KEY2_SHORT;
|
|
}
|
|
|
|
if( (inputs_state[STATE_KEY2]) &&
|
|
(prev_inputs_state[STATE_KEY2]) &&
|
|
(key2_code_sent == 0) &&
|
|
(TICK - ts_key2 >= KEY_LONG_PRESS_TIME ) )
|
|
{
|
|
key2_code_sent = 1;
|
|
return KEYCODE_KEY2_LONG;
|
|
}
|
|
|
|
// ENC1
|
|
if(inputs_state[STATE_KEY1] == 0)
|
|
{
|
|
if(prev_inputs_state[STATE_ENC1] == 0x03 && inputs_state[STATE_ENC1] ==0x02)
|
|
{
|
|
encoder1_cntr ++;
|
|
if(encoder1_cntr >= 1*ENCODER1_DIVIDER)
|
|
{
|
|
encoder1_cntr = 0;
|
|
return KEYCODE_ENC1R;
|
|
}
|
|
}
|
|
else if(prev_inputs_state[STATE_ENC1] == 0x03 && inputs_state[STATE_ENC1] ==0x01)
|
|
{
|
|
encoder1_cntr --;
|
|
if(encoder1_cntr <= -1*ENCODER1_DIVIDER)
|
|
{
|
|
encoder1_cntr = 0;
|
|
return KEYCODE_ENC1L;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ENC2
|
|
if ( inputs_state[STATE_KEY2] == 0)
|
|
{
|
|
if(prev_inputs_state[STATE_ENC2] == 0x03 && inputs_state[STATE_ENC2] ==0x02)
|
|
{
|
|
encoder2_cntr ++;
|
|
if(encoder2_cntr >= 1*ENCODER2_DIVIDER)
|
|
{
|
|
encoder2_cntr = 0;
|
|
return KEYCODE_ENC2R;
|
|
}
|
|
}
|
|
else if(prev_inputs_state[STATE_ENC2] == 0x03 && inputs_state[STATE_ENC2] ==0x01)
|
|
{
|
|
encoder2_cntr --;
|
|
if(encoder2_cntr <= -1*ENCODER2_DIVIDER)
|
|
{
|
|
encoder2_cntr = 0;
|
|
return KEYCODE_ENC2L;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|