void ui_process(uint16_t framenumber)
{
static uint8_t cpt_sof = 0;
static bool btn_last_state = false;
static bool sequence_running = false;
static uint8_t sequence_pos = 0;
bool b_btn_state, success;
uint8_t value;
if ((framenumber % 1000) == 0) {
LED_On(LED_0_PIN);
}
if ((framenumber % 1000) == 500) {
LED_Off(LED_0_PIN);
}
/* Scan process running each 5ms */
cpt_sof++;
if(button_function) {
if (cpt_sof < 5) {
return;
}
cpt_sof = 0;
/* Uses buttons to move mouse */
if (!port_pin_get_input_level(BUTTON_0_PIN)) {
udi_hid_mouse_moveY(-MOUSE_MOVE_RANGE);
}
} else {
if ((cpt_sof % 2) == 0) {
return;
}
// Scan buttons on switch 0 to send keys sequence
b_btn_state = (!port_pin_get_input_level(BUTTON_0_PIN));
if (b_btn_state != btn_last_state) {
btn_last_state = b_btn_state;
if (btn_wakeup) {
if (!b_btn_state) {
btn_wakeup = false;
}
} else {
sequence_running = true;
}
}
// Sequence process running each period
if (SEQUENCE_PERIOD > cpt_sof) {
return;
}
cpt_sof = 0;
if (sequence_running) {
// Send next key
value = ui_sequence[sequence_pos].value;
if (value!=0) {
if (ui_sequence[sequence_pos].b_modifier) {
if (ui_sequence[sequence_pos].b_down) {
success = udi_hid_kbd_modifier_down(value);
} else {
success = udi_hid_kbd_modifier_up(value);
}
} else {
if (ui_sequence[sequence_pos].b_down) {
success = udi_hid_kbd_down(value);
} else {
success = udi_hid_kbd_up(value);
}
}
if (!success) {
return; // Retry it on next schedule
}
}
// Valid sequence position
sequence_pos++;
if (sequence_pos >=
sizeof(ui_sequence) / sizeof(ui_sequence[0])) {
sequence_pos = 0;
sequence_running = false;
button_function = 1;
}
}
}
}
void ui_process(uint16_t framenumber)
{
bool b_btn_state, success;
static bool btn_last_state = false;
static bool sequence_running = false;
static uint8_t u8_sequence_pos = 0;
uint8_t u8_value;
static uint16_t cpt_sof = 0;
if ((framenumber % 1000) == 0) {
LED_On(LED0);
}
if ((framenumber % 1000) == 500) {
LED_Off(LED0);
}
/* Scan process running each 2ms */
cpt_sof++;
if ((cpt_sof % 2) == 0) {
return;
}
/* Buttons down to send keys sequence */
b_btn_state = (!ioport_get_pin_level(GPIO_PUSH_BUTTON_1));
if (b_btn_state != btn_last_state) {
btn_last_state = b_btn_state;
if (btn_wakeup) {
if (!b_btn_state) {
btn_wakeup = false;
}
} else {
sequence_running = true;
}
}
/* Sequence process running each period */
if (SEQUENCE_PERIOD > cpt_sof) {
return;
}
cpt_sof = 0;
if (sequence_running) {
/* Send next key */
u8_value = ui_sequence[u8_sequence_pos].u8_value;
if (u8_value!=0) {
if (ui_sequence[u8_sequence_pos].b_modifier) {
if (ui_sequence[u8_sequence_pos].b_down) {
success = udi_hid_kbd_modifier_down(u8_value);
} else {
success = udi_hid_kbd_modifier_up(u8_value);
}
} else {
if (ui_sequence[u8_sequence_pos].b_down) {
success = udi_hid_kbd_down(u8_value);
} else {
success = udi_hid_kbd_up(u8_value);
}
}
if (!success) {
return; /* Retry it on next schedule */
}
}
/* Valid sequence position */
u8_sequence_pos++;
if (u8_sequence_pos >=
sizeof(ui_sequence) / sizeof(ui_sequence[0])) {
u8_sequence_pos = 0;
sequence_running = false;
}
}
}
void ui_process(uint16_t framenumber)
{
bool b_btn_state, sucess;
static bool btn_last_state = false;
static bool sequence_running = false;
static uint8_t u8_sequence_pos = 0;
uint8_t u8_value;
static uint16_t cpt_sof = 0;
if ((framenumber % 1000) == 0) {
LED_On(LED1_GPIO);
}
if ((framenumber % 1000) == 500) {
LED_Off(LED1_GPIO);
}
// Scan process running each 2ms
cpt_sof++;
if ((cpt_sof % 2) == 0) {
return;
}
// Scan buttons on switch 0 to send keys sequence
b_btn_state = (gpio_pin_is_low(GPIO_PUSH_BUTTON_0)) ? true : false;
if (b_btn_state != btn_last_state) {
btn_last_state = b_btn_state;
sequence_running = true;
}
// Sequence process running each period
if (SEQUENCE_PERIOD > cpt_sof) {
return;
}
cpt_sof = 0;
if (sequence_running) {
// Send next key
u8_value = ui_sequence[u8_sequence_pos].u8_value;
if (u8_value!=0) {
if (ui_sequence[u8_sequence_pos].b_modifier) {
if (ui_sequence[u8_sequence_pos].b_down) {
sucess = udi_hid_kbd_modifier_down(u8_value);
} else {
sucess = udi_hid_kbd_modifier_up(u8_value);
}
} else {
if (ui_sequence[u8_sequence_pos].b_down) {
sucess = udi_hid_kbd_down(u8_value);
} else {
sucess = udi_hid_kbd_up(u8_value);
}
}
if (!sucess) {
return; // Retry it on next schedule
}
}
// Valid sequence position
u8_sequence_pos++;
if (u8_sequence_pos >=
sizeof(ui_sequence) / sizeof(ui_sequence[0])) {
u8_sequence_pos = 0;
sequence_running = false;
}
}
}
void ui_process(uint16_t framenumber)
{
bool b_btn_state, sucess;
static bool btn_last_state = false;
static bool sequence_running = false;
static uint8_t u8_sequence_pos = 0;
uint8_t u8_value;
static uint16_t cpt_sof = 0;
if ((framenumber % 1000) == 0) {
LED_On(LED0);
}
if ((framenumber % 1000) == 500) {
LED_Off(LED0);
}
/* Scan process running each 2ms */
cpt_sof++;
if ((cpt_sof % 2) == 0) {
return;
}
/* Uses buttons to move mouse */
if (!ioport_get_pin_level(GPIO_PUSH_BUTTON_1)) {
move_count --;
switch(move_dir) {
case MOVE_UP:
udi_hid_mouse_moveY(-MOUSE_MOVE_RANGE);
if (move_count < 0) {
move_dir = MOVE_RIGHT;
move_count = MOUSE_MOVE_COUNT;
}
break;
case MOVE_RIGHT:
udi_hid_mouse_moveX(+MOUSE_MOVE_RANGE);
if (move_count < 0) {
move_dir = MOVE_DOWN;
move_count = MOUSE_MOVE_COUNT;
}
break;
case MOVE_DOWN:
udi_hid_mouse_moveY(+MOUSE_MOVE_RANGE);
if (move_count < 0) {
move_dir = MOVE_LEFT;
move_count = MOUSE_MOVE_COUNT;
}
break;
case MOVE_LEFT:
udi_hid_mouse_moveX(-MOUSE_MOVE_RANGE);
if (move_count < 0) {
move_dir = MOVE_UP;
move_count = MOUSE_MOVE_COUNT;
}
break;
}
}
/* Both buttons down to send keys sequence */
b_btn_state = (!ioport_get_pin_level(GPIO_PUSH_BUTTON_1));
if (b_btn_state != btn_last_state) {
btn_last_state = b_btn_state;
sequence_running = true;
}
/* Sequence process running each period */
if (SEQUENCE_PERIOD > cpt_sof) {
return;
}
cpt_sof = 0;
if (sequence_running) {
/* Send next key */
u8_value = ui_sequence[u8_sequence_pos].u8_value;
if (u8_value!=0) {
if (ui_sequence[u8_sequence_pos].b_modifier) {
if (ui_sequence[u8_sequence_pos].b_down) {
sucess = udi_hid_kbd_modifier_down(u8_value);
} else {
sucess = udi_hid_kbd_modifier_up(u8_value);
}
} else {
if (ui_sequence[u8_sequence_pos].b_down) {
sucess = udi_hid_kbd_down(u8_value);
} else {
sucess = udi_hid_kbd_up(u8_value);
}
}
if (!sucess) {
return; /* Retry it on next schedule */
}
}
/* Valid sequence position */
u8_sequence_pos++;
if (u8_sequence_pos >=
sizeof(ui_sequence) / sizeof(ui_sequence[0])) {
u8_sequence_pos = 0;
sequence_running = false;
}
}
}
/**
* @brief Notify the application when ZID report data is received from the paired device.
*
* @param PairingRef Pairing reference.
* @param num_report_records number of Report records.
* @param *zid_report_data_record_ptr pointer to the report data received.
* @param RxLinkQuality LQI value of the report data frame.
* @param RxFlags Receive flags.
*/
static void zid_report_data_indication(uint8_t PairingRef, uint8_t num_report_records,
zid_report_data_record_t *zid_report_data_record_ptr, uint8_t RxLinkQuality, uint8_t RxFlags)
{
for(uint8_t i=0;i<num_report_records;i++)
{
switch(zid_report_data_record_ptr->report_desc_identifier)
{
case MOUSE:
{
mouse_desc_t *mouse_desc;
mouse_desc = (mouse_desc_t *)zid_report_data_record_ptr->report_data;
udi_hid_mouse_btnleft(mouse_desc->button0);
udi_hid_mouse_btnright(mouse_desc->button1);
if((0x80==(mouse_desc->button2)))
{
udi_hid_mouse_moveScroll((mouse_desc->y_coordinate));
mouse_desc->y_coordinate = 0;
}
else if(0x01==(mouse_desc->button2))
{
udi_hid_mouse_btnmiddle(0x01);
}
udi_hid_mouse_moveX((mouse_desc->x_coordinate));
udi_hid_mouse_moveY((mouse_desc->y_coordinate));
break;
}
case KEYBOARD:
{
if(zid_report_data_record_ptr->report_type == INPUT)
{
keyboard_input_desc_t *keyboard_input_desc;
keyboard_input_desc = (keyboard_input_desc_t *)zid_report_data_record_ptr->report_data;
if(main_b_kbd_enable)
{
if(keyboard_input_desc->modifier_keys)
{
udi_hid_kbd_modifier_down(keyboard_input_desc->modifier_keys);
udi_hid_kbd_modifier_up(keyboard_input_desc->modifier_keys);
}
for(uint8_t j=0;j<4;j++)
{
if(keyboard_input_desc->key_code[j])
{
udi_hid_kbd_down(keyboard_input_desc->key_code[j]);
udi_hid_kbd_up(keyboard_input_desc->key_code[j]);
}
}
uint16_t u_value;
u_value= convert_byte_array_to_16_bit(&(keyboard_input_desc->key_code[4]));
if(u_value)
{
udi_hid_mkbd_modifier_down(u_value);
udi_hid_mkbd_modifier_up(u_value);
}
}
}
else
{
/* Application can implement for other report types.*/
}
break;
}
default:
break;
}
zid_report_data_record_ptr++;
}
RxLinkQuality = RxLinkQuality;
RxFlags = RxFlags;
}
// initializes the SD/MMC memory resources: GPIO, SPI and MMC
//-------------------------------------------------------------------
static void sd_mmc_resources_init(long pba_hz) {
// GPIO pins used for SD/MMC interface
static const gpio_map_t SD_MMC_SPI_GPIO_MAP = {
{SD_MMC_SPI_SCK_PIN, SD_MMC_SPI_SCK_FUNCTION }, // SPI Clock.
{SD_MMC_SPI_MISO_PIN, SD_MMC_SPI_MISO_FUNCTION}, // MISO.
{SD_MMC_SPI_MOSI_PIN, SD_MMC_SPI_MOSI_FUNCTION}, // MOSI.
{SD_MMC_SPI_NPCS_PIN, SD_MMC_SPI_NPCS_FUNCTION} // Chip Select NPCS.
};
// SPI options.
spi_options_t spiOptions = {
.reg = SD_MMC_SPI_NPCS,
.baudrate = SD_MMC_SPI_MASTER_SPEED, // Defined in conf_sd_mmc_spi.h.
.bits = SD_MMC_SPI_BITS, // Defined in conf_sd_mmc_spi.h.
.spck_delay = 0,
.trans_delay = 0,
.stay_act = 1,
.spi_mode = 0,
.modfdis = 1
};
// assign I/Os to SPI.
gpio_enable_module(SD_MMC_SPI_GPIO_MAP,
sizeof(SD_MMC_SPI_GPIO_MAP) / sizeof(SD_MMC_SPI_GPIO_MAP[0]));
// initialize as master.
spi_initMaster(SD_MMC_SPI, &spiOptions);
// set SPI selection mode: variable_ps, pcs_decode, delay.
spi_selectionMode(SD_MMC_SPI, 0, 0, 0);
// enable SPI module.
spi_enable(SD_MMC_SPI);
// Initialize SD/MMC driver with SPI clock (PBA).
sd_mmc_spi_init(spiOptions, pba_hz);
}
// process a USB frame
//-------------------------------------------------------------------
void process_frame(uint16_t framenumber)
{
static uint8_t cpt_sof = 0;
static injectState_t state = state_START_INJECT;
static uint8_t wait = 0;
static uint16_t debounce = 0;
static uint16_t injectToken = 0x0000;
static uint16_t delay = 0;
// scan process running each 2ms
cpt_sof++;
if( 2 > cpt_sof )
return;
cpt_sof = 0;
// pulse led
LED_Set_Intensity( LED0, framenumber >> 1 );
// debounce switch
if( debounce > 0 ) --debounce;
//delay a random amount
if(delay == 0){
// injection state machine
switch(state) {
case state_IDLE:
// check switch
if( gpio_get_pin_value(GPIO_JOYSTICK_PUSH) == GPIO_JOYSTICK_PUSH_PRESSED ) {
// debounce
if( debounce == 0 ) {
state = state_START_INJECT;
debounce = 250;
}
}
break;
case state_START_INJECT:
file_open(FOPEN_MODE_R);
state = state_INJECTING;
break;
case state_INJECTING:
if( file_eof() ) {
file_close();
state = state_IDLE;
break;
}
injectToken = ( file_getc() | ( file_getc() << 8 ) );
if( ( injectToken&0xff ) == 0x00 ) {
wait = injectToken>>8;
state = state_WAIT;
}
else if( ( injectToken>>8 ) == 0x00 ) {
state = state_KEY_DOWN;
}
else {
state = state_MOD_DOWN;
}
break;
case state_KEY_DOWN:
udi_hid_kbd_down(injectToken&0xff);
state = state_KEY_UP;
delay = rand() % MAX_DELAY;
break;
case state_KEY_UP:
udi_hid_kbd_up(injectToken&0xff);
state = state_INJECTING;
delay = rand() % MAX_DELAY;
break;
case state_MOD_DOWN:
udi_hid_kbd_modifier_down(injectToken>>8);
state = state_MOD_KEY_DOWN;
delay = rand() % MAX_DELAY;
break;
case state_MOD_KEY_DOWN:
udi_hid_kbd_down(injectToken&0xff);
state = state_MOD_KEY_UP;
delay = rand() % MAX_DELAY;
break;
case state_MOD_KEY_UP:
udi_hid_kbd_up(injectToken&0xff);
state = state_MOD_UP;
delay = rand() % MAX_DELAY;
break;
case state_MOD_UP:
udi_hid_kbd_modifier_up(injectToken>>8);
state = state_INJECTING;
delay = rand() % 50;
break;
case state_WAIT:
if( --wait == 0 ) {
state = state_INJECTING;
}
break;
default:
state = state_IDLE;
}
/**
* \brief Check the status of the keyboard
*
* \param keybuffer a keyboard_event struct to store keyboard status
*/
void keyboard_get_key_state(struct keyboard_event *keybuffer)
{
// Variable to hold the key mask
static uint8_t key_state;
char key;
if ((gpio_pin_is_low(GPIO_PUSH_BUTTON_UP)) && !(key_state & KEYBOARD_UP_MASK)) {
// Key pressed
key_state |= KEYBOARD_UP_MASK;
keybuffer->keycode = KEYBOARD_UP;
keybuffer->type = KEYBOARD_PRESS;
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_down(HID_UP);
}
} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_UP)) && (key_state & KEYBOARD_UP_MASK)) {
// Key released
key_state &= ~KEYBOARD_UP_MASK;
keybuffer->keycode = KEYBOARD_UP;
keybuffer->type = KEYBOARD_RELEASE;
keybuffer->konami = konami_checker(KEYBOARD_UP);
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_up(HID_UP);
}
} else if ((gpio_pin_is_low(GPIO_PUSH_BUTTON_DOWN)) && !(key_state & KEYBOARD_DOWN_MASK)) {
// Key pressed
key_state |= KEYBOARD_DOWN_MASK;
keybuffer->keycode = KEYBOARD_DOWN;
keybuffer->type = KEYBOARD_PRESS;
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_down(HID_DOWN);
}
} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_DOWN)) && (key_state & KEYBOARD_DOWN_MASK)) {
// Key released
key_state &= ~KEYBOARD_DOWN_MASK;
keybuffer->keycode = KEYBOARD_DOWN;
keybuffer->type = KEYBOARD_RELEASE;
keybuffer->konami = konami_checker(KEYBOARD_DOWN);
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_up(HID_DOWN);
}
} else if ((gpio_pin_is_low(GPIO_PUSH_BUTTON_LEFT)) && !(key_state & KEYBOARD_LEFT_MASK)) {
// Key pressed
key_state |= KEYBOARD_LEFT_MASK;
keybuffer->keycode = KEYBOARD_LEFT;
keybuffer->type = KEYBOARD_PRESS;
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_down(HID_LEFT);
}
} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_LEFT)) && (key_state & KEYBOARD_LEFT_MASK)) {
// Key released
key_state &= ~KEYBOARD_LEFT_MASK;
keybuffer->keycode = KEYBOARD_LEFT;
keybuffer->type = KEYBOARD_RELEASE;
keybuffer->konami = konami_checker(KEYBOARD_LEFT);
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_up(HID_LEFT);
}
} else if ((gpio_pin_is_low(GPIO_PUSH_BUTTON_RIGHT)) && !(key_state & KEYBOARD_RIGHT_MASK)) {
// Key pressed
key_state |= KEYBOARD_RIGHT_MASK;
keybuffer->keycode = KEYBOARD_RIGHT;
keybuffer->type = KEYBOARD_PRESS;
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_down(HID_RIGHT);
}
} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_RIGHT)) && (key_state & KEYBOARD_RIGHT_MASK)) {
// Key released
key_state &= ~KEYBOARD_RIGHT_MASK;
keybuffer->keycode = KEYBOARD_RIGHT;
keybuffer->type = KEYBOARD_RELEASE;
keybuffer->konami = konami_checker(KEYBOARD_RIGHT);
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_up(HID_RIGHT);
}
} else if ((gpio_pin_is_low(GPIO_PUSH_BUTTON_START)) && !(key_state & KEYBOARD_START_MASK)) {
// Key pressed
key_state |= KEYBOARD_START_MASK;
keybuffer->keycode = KEYBOARD_START;
keybuffer->type = KEYBOARD_PRESS;
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_down(HID_ENTER);
}
} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_START)) && (key_state & KEYBOARD_START_MASK)) {
// Key released
key_state &= ~KEYBOARD_START_MASK;
keybuffer->keycode = KEYBOARD_START;
keybuffer->type = KEYBOARD_RELEASE;
keybuffer->konami = konami_checker(KEYBOARD_START);
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_up(HID_ENTER);
}
} else if ((gpio_pin_is_low(GPIO_PUSH_BUTTON_SELECT)) && !(key_state & KEYBOARD_SELECT_MASK)) {
// Key pressed
key_state |= KEYBOARD_SELECT_MASK;
keybuffer->keycode = KEYBOARD_SELECT;
keybuffer->type = KEYBOARD_PRESS;
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_down(HID_SPACEBAR);
}
} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_SELECT)) && (key_state & KEYBOARD_SELECT_MASK)) {
// Key released
key_state &= ~KEYBOARD_SELECT_MASK;
keybuffer->keycode = KEYBOARD_SELECT;
keybuffer->type = KEYBOARD_RELEASE;
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_up(HID_SPACEBAR);
}
} else if ((gpio_pin_is_low(GPIO_PUSH_BUTTON_A)) && !(key_state & KEYBOARD_A_MASK)) {
// Key pressed
key_state |= KEYBOARD_A_MASK;
keybuffer->keycode = KEYBOARD_A;
keybuffer->type = KEYBOARD_PRESS;
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_down(HID_A);
}
} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_A)) && (key_state & KEYBOARD_A_MASK)) {
// Key released
key_state &= ~KEYBOARD_A_MASK;
keybuffer->keycode = KEYBOARD_A;
keybuffer->type = KEYBOARD_RELEASE;
keybuffer->konami = konami_checker(KEYBOARD_A);
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_up(HID_A);
}
} else if ((gpio_pin_is_low(GPIO_PUSH_BUTTON_B)) && !(key_state & KEYBOARD_B_MASK)) {
// Key pressed
key_state |= KEYBOARD_B_MASK;
keybuffer->keycode = KEYBOARD_B;
keybuffer->type = KEYBOARD_PRESS;
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_down(HID_B);
}
} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_B)) && (key_state & KEYBOARD_B_MASK)) {
// Key released
key_state &= ~KEYBOARD_B_MASK;
keybuffer->keycode = KEYBOARD_B;
keybuffer->type = KEYBOARD_RELEASE;
keybuffer->konami = konami_checker(KEYBOARD_B);
if (my_flag_autorize_keyboard_events) {
udi_hid_kbd_up(HID_B);
}
// } else if ((key = cdc_getkey()) != KEYBOARD_NO_KEY) {
// keybuffer->keycode = key;
// keybuffer->type = KEYBOARD_RELEASE;
} else {
keybuffer->keycode = KEYBOARD_NO_KEY;
keybuffer->type = KEYBOARD_NO_EVENT;
}
}
