static void handle_descriptor_request(void)
{
uint8_t type, idx;
type = setup_packet.wValue >> 8;
idx = setup_packet.wValue & 0xff;
switch (type) {
case DT_STRING:
switch (idx) {
case 1:
in_data.data = str_manufacturer;
in_data.size = sizeof(str_manufacturer);
break;
case 2:
in_data.data = str_product;
in_data.size = sizeof(str_product);
break;
default:
debug("WARN: unhandled string descriptor 0x");
debug_hex(idx, 0);
debug("\n");
}
break;
default:
debug("WARN: unhandled descriptor type 0x");
debug_hex(type, 0);
debug("\n");
}
}
static void read_out_data(unsigned ep, unsigned sz)
{
unsigned dwords = DIV_ROUND_UP(sz, 4);
uint32_t val;
while (dwords--) {
val = read_ep_fifo(ep);
if (out_data.size >= 4) {
debug("<< 0x");
debug_hex(val, 8);
debug("\n");
*((volatile uint32_t *)out_data.data) = val;
out_data.data += 4;
out_data.size -= 4;
} else while (out_data.size > 0) {
debug("<< 0x");
debug_hex(val & 0xff, 2);
debug("\n");
*((volatile uint8_t *)out_data.data) = val;
val >>= 8;
out_data.data++;
out_data.size--;
}
}
if (out_data.size)
return;
switch (cmd) {
case FW_REQ_MEM_SET:
memset(cmd_data.mem_set.base, cmd_data.mem_set.args.c,
cmd_data.mem_set.args.length);
break;
case FW_REQ_CACHE_FLUSH:
switch (cmd_data.cache_flush.cache) {
case CACHE_D:
flush_dcache(cmd_data.cache_flush.args.base,
cmd_data.cache_flush.args.size);
break;
case CACHE_I:
flush_icache(cmd_data.cache_flush.args.base,
cmd_data.cache_flush.args.size);
break;
}
break;
case FW_REQ_MTC0:
dynamic_mtc0(cmd_data.mtc0.reg, cmd_data.mtc0.sel,
cmd_data.mtc0.value);
break;
}
}
uint8_t matrix_scan(void)
{
if (mcp23018_status) { // if there was an error
if (++mcp23018_reset_loop == 0) {
// since mcp23018_reset_loop is 8 bit - we'll try to reset once in 255 matrix scans
// this will be approx bit more frequent than once per second
print("trying to reset mcp23018\n");
mcp23018_status = init_mcp23018();
if (mcp23018_status) {
print("left side not responding\n");
} else {
print("left side attached\n");
frenchdev_blink_all_leds();
}
}
}
#ifdef DEBUG_MATRIX_SCAN_RATE
matrix_scan_count++;
uint32_t timer_now = timer_read32();
if (TIMER_DIFF_32(timer_now, matrix_timer)>1000) {
print("matrix scan frequency: ");
pdec(matrix_scan_count);
print("\n");
matrix_timer = timer_now;
matrix_scan_count = 0;
}
#endif
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i);
wait_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols(i);
if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
wait_us(1);
// this should be wait_ms(1) but has been left as-is at EZ's request
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
}
}
matrix_scan_quantum();
return 1;
}
uint8_t _matrix_scan(void)
{
// Right hand is stored after the left in the matirx so, we need to offset it
int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
select_row(i);
_delay_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols();
if (matrix_debouncing[i+offset] != cols) {
matrix_debouncing[i+offset] = cols;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
matrix[i+offset] = matrix_debouncing[i+offset];
}
}
}
return 1;
}
uint8_t matrix_scan(void)
{
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i);
_delay_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols();
if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
}
}
return 1;
}
uint8_t matrix_scan(void)
{
for (uint8_t col = 0; col < MATRIX_COLS; col++) { // 0-16
pull_column(col); // output hi on theline
_delay_us(3); // without this wait it won't read stable value.
for (uint8_t row = 0; row < MATRIX_ROWS; row++) { // 0-5
bool prev_bit = matrix[row] & ((matrix_row_t)1<<col);
bool curr_bit = !(*row_pin[row] & row_bit[row]);
if (prev_bit != curr_bit) {
matrix[row] ^= ((matrix_row_t)1<<col);
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); print("\n");
}
debouncing = DEBOUNCE;
}
}
release_column(col);
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
matrix_row_t *tmp = matrix_debounced;
matrix_debounced = matrix;
matrix = tmp;
}
}
return 1;
}
uint8_t matrix_scan(void)
{
if (!debouncing) {
uint8_t *tmp = matrix_prev;
matrix_prev = matrix;
matrix = tmp;
}
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
unselect_rows();
select_row(i);
_delay_us(30); // without this wait read unstable value.
if (matrix[i] != (uint8_t)~read_col()) {
matrix[i] = (uint8_t)~read_col();
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); print("\n");
}
debouncing = DEBOUNCE;
}
}
unselect_rows();
if (debouncing) {
debouncing--;
}
return 1;
}
uint8_t matrix_scan(void)
{
if (!debouncing) {
uint8_t *tmp = matrix_prev;
matrix_prev = matrix;
matrix = tmp;
}
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
unselect_rows();
select_row(i);
_delay_us(30); // without this wait read unstable value.
if ( i == ( MATRIX_ROWS - 1 ) ) { // CHECK CAPS LOCK
if (host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK)) { // CAPS LOCK is ON on HOST
if ( ~read_col(i) & (1<< 4) ) { // CAPS LOCK is still DOWN ( 0bXXX1_XXXX)
matrix[i] = ~read_col(i) & 0b11101111; // change CAPS LOCK as released
} else { // CAPS LOCK in UP
matrix[i] = ~read_col(i) | 0b00010000; // send fake caps lock down
}
} else { // CAPS LOCK is OFF on HOST
if (matrix[i] != (uint8_t)~read_col(i)) {
matrix[i] = (uint8_t)~read_col(i);
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); print("\n");
}
debouncing = DEBOUNCE;
}
}
} else {
if (matrix[i] != (uint8_t)~read_col(i)) {
matrix[i] = (uint8_t)~read_col(i);
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); print("\n");
}
debouncing = DEBOUNCE;
}
}
}
unselect_rows();
if (debouncing) {
debouncing--;
}
return 1;
}
/*
* Erases a page in flash. base_addr must point to the beginning of
* the page.
*/
error_t flash_erase_page(void *base_addr) {
#ifdef TRACE_FLASH
debug_string("Erasing flash page at ");
debug_hex(base_addr, 8);
debug_string(CRLF);
#endif
while(FLASH_SR & FLASH_BSY);
if (FLASH_CR & FLASH_LOCK)
error(ER_BUG, STR_WITH_LEN("Flash is locked"), EA_PANIC);
FLASH_CR |= FLASH_PER;
FLASH_AR = (uint32_t) base_addr;
FLASH_CR |= FLASH_STRT;
error_t error = flash_check_error();
FLASH_CR &= ~FLASH_PER;
if (error) return error;
// Verify
uint16_t *start = (uint16_t*) base_addr;
for (uint16_t *i = start;
i < start + FLASH_PAGE_SIZE/sizeof(uint16_t);
i++) {
if (*i != 0xffff) {
#ifdef TRACE_FLASH
debug_string("Verification failed at ");
debug_hex(i, 8);
debug_string(" with ");
debug_hex(*i, 8);
debug_string(CRLF);
#endif
return E_FLASH_WRITE;
}
}
return E_SUCCESS;
}
uint8_t matrix_scan(void)
{
is_modified = false;
uint8_t code;
code = serial_recv();
if (!code) return 0;
debug_hex(code); debug(" ");
switch (code) {
case 0xFF: // reset success: FF 04
print("reset: ");
_delay_ms(500);
code = serial_recv();
xprintf("%02X\n", code);
if (code == 0x04) {
// LED status
led_set(host_keyboard_leds());
}
return 0;
case 0xFE: // layout: FE <layout>
print("layout: ");
_delay_ms(500);
xprintf("%02X\n", serial_recv());
return 0;
case 0x7E: // reset fail: 7E 01
print("reset fail: ");
_delay_ms(500);
xprintf("%02X\n", serial_recv());
return 0;
case 0x7F:
// all keys up
for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;
return 0;
}
if (code&0x80) {
// break code
if (matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] &= ~(1<<COL(code));
is_modified = true;
}
} else {
// make code
if (!matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] |= (1<<COL(code));
is_modified = true;
}
}
return code;
}
static void handle_standard_request(void)
{
switch (setup_packet.bRequest) {
case REQ_GET_DESCRIPTOR:
handle_descriptor_request();
break;
default:
debug("WARN: unhandled standard request 0x");
debug_hex(setup_packet.bRequest, 2);
debug("\n");
}
}
// Output string
void debug_string(BSP_STRING *str)
{
if (!str)
{
fprintf(stderr, "\n\033[1;36m=== [NOTHING TO OUTPUT] ===\033[0m\n");
return;
}
fprintf(stderr, "\n\033[1;36m=== [Debug string] <%s> <%s> ===\033[0m",
(str->is_const) ? "Const" : "Normal",
(COMPRESS_TYPE_NONE == str->compress_type) ? "Uncompressed" : "Compressed");
debug_hex(STR_STR(str), STR_LEN(str));
return;
}
uint8_t matrix_scan(void)
{
uint8_t layer = biton32(layer_state);
switch (layer) {
case 0:
all_led_off();
break;
case 1:
if (!(host_keyboard_leds() & (1 << USB_LED_CAPS_LOCK))) {
all_led_off();
caps_lock_led_on();
}
break;
case 2:
all_led_off();
num_lock_led_on();
break;
default:
break;
}
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select(i);
uint8_t row = read(i);
if (matrix_debouncing[i] != row) {
matrix_debouncing[i] = row;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
}
}
return 1;
}
/*
* Checks the flash status for errors.
*/
static error_t flash_check_error() {
// Wait for write to finish
// Need to wait one more cycle, see erratum 2.7
__asm("nop");
while (FLASH_SR & FLASH_BSY);
if (FLASH_SR & (FLASH_PGERR | FLASH_WRPRTERR)) {
#ifdef TRACE_FLASH
debug_string("Flash error, FLASH_SR = ");
debug_hex(FLASH_SR, 8);
debug_string(CRLF);
#endif
return E_FLASH_WRITE;
} else {
return E_SUCCESS;
}
}
uint8_t matrix_scan() {
// Update LED states if necessary:
#ifdef LED_CONTROLLER_ENABLE
led_update();
#endif
for ( uint8_t i = 0; i < MATRIX_ROWS; i++ ) {
select_row( i );
_delay_us( 30 ); // without this wait read unstable value.
matrix_row_t cols = read_cols();
if ( matrix_debouncing[ i ] != cols ) {
matrix_debouncing[ i ] = cols;
if ( debouncing ) {
debug("bounce!: ");
debug_hex( debouncing );
debug( "\n" );
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if ( debouncing ) {
if ( --debouncing ) {
_delay_ms( 1 );
} else {
for ( uint8_t i = 0; i < MATRIX_ROWS; i++ ) {
matrix[ i ] = matrix_debouncing[ i ];
}
}
}
return 1;
}
uint8_t matrix_scan(void)
{
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i);
_delay_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols();
if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
}
}
uint8_t layer = biton32(layer_state);
switch (layer) {
case 1:
case 2:
DDRC |= (1<<7);
PORTC |= (1<<7);
break;
case 0:
DDRC &= ~(1<<7);
PORTC &= ~(1<<7);
break;
}
return 1;
}
static uint16 z18infrared_send_data(COMM_TYPE_T *comm,uint16 len)
{
uint16 i;
//debug_string("send data[%d]\n",comm->buflen);
if(comm->use_ext)
{
for(i = 0; i < comm->buflen; ++i)
set_char_1(comm->buffer[i]);
for(i = 0; i < comm->ext_buf_len; ++i)
set_char_1(comm->ext_buffer[i]);
//debug_string("cmd[%d]\n",(uint16)(comm->buflen+comm->ext_buf_len));
//debug_hex(comm->buffer,comm->buflen);
//debug_hex(comm->ext_buffer,comm->ext_buf_len);
}
else
{
// 发送成功
for(i = 0;i < len;++i)
set_char_1(comm->buffer[comm->buf_begin+(uint8)i]);
debug_hex(comm->buffer+comm->buf_begin,len);
}
return i;
}
/**
* Print an address
*
* \param addr pointer to sockaddr struct
*
*/
void debug_address(sockaddr_t *addr)
{
uint8_t i;
uint8_t *ptr;
ptr = addr->address;
switch (addr->addr_type)
{
case ADDR_802_15_4_PAN_LONG:
ptr += 8;
debug_hex(*ptr++);
debug_hex(*ptr++);
debug(" ");
ptr -= 10;
case ADDR_802_15_4_LONG:
ptr += 8;
for (i=0; i<8; i++)
{
debug_hex(*--ptr);
if (i < 7) debug(":");
}
break;
case ADDR_802_15_4_PAN_SHORT:
ptr += 2;
debug_hex(*ptr++);
debug_hex(*ptr++);
debug(" ");
ptr -= 4;
case ADDR_802_15_4_SHORT:
ptr += 2;
for (i=0; i<2; i++)
{
debug_hex(*--ptr);
if (i== 0) debug(":");
}
break;
case ADDR_BROADCAST:
debug("Broadcast");
break;
default:
break;
}
}
/*
* PS/2 Scan Code Set 2: Exceptional Handling
*
* There are several keys to be handled exceptionally.
* The scan code for these keys are varied or prefix/postfix'd
* depending on modifier key state.
*
* References:
* http://www.microsoft.com/whdc/archive/scancode.mspx
* http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/scancode.doc
*
*
* Insert, Delete, Home, End, PageUp, PageDown, Up, Down, Right, Left:
* Num Lock: off
* modifiers | make | break
* ----------+---------------------------+----------------------
* Ohter | <make> | <break>
* LShift | E0 F0 12 <make> | <break> E0 12
* RShift | E0 F0 59 <make> | <break> E0 59
* L+RShift | E0 F0 12 E0 F0 59 <make> | <break> E0 59 E0 12
*
* Num Lock: on
* modifiers | make | break
* ----------+---------------------------+----------------------
* Other | E0 12 <make> | <break> E0 F0 12
* Shift'd | <make> | <break>
*
* Handling: ignore these prefix/postfix codes
*
*
* Keypad-/:
* modifiers | make | break
* ----------+---------------------------+----------------------
* Ohter | <make> | <break>
* LShift | E0 F0 12 <make> | <break> E0 12
* RShift | E0 F0 59 <make> | <break> E0 59
* L+RShift | E0 F0 12 E0 F0 59 <make> | <break> E0 59 E0 12
*
* Handling: ignore these prefix/postfix codes
*
*
* PrintScreen:
* With hoding down modifiers, the scan code is sent as following:
*
* modifiers | make | break
* ----------+--------------+-----------------------------------
* Other | E0 12 E0 7C | E0 F0 7C E0 F0 12
* Shift'd | E0 7C | E0 F0 7C
* Control'd | E0 7C | E0 F0 7C
* Alt'd | 84 | F0 84
*
* Handling: ignore prefix/postfix codes and treat both scan code
* E0 7C and 84 as PrintScreen.
*
* Pause:
* With hoding down modifiers, the scan code is sent as following:
*
* modifiers | make(no break code)
* ----------+--------------------------------------------------
* no mods | E1 14 77 E1 F0 14 F0 77
* Control'd | E0 7E E0 F0 7E
*
* Handling: treat these two code sequence as Pause
*
*/
uint8_t matrix_scan(void)
{
static enum {
INIT,
F0,
E0,
E0_F0,
// states for Pause/Break
E1,
E1_14,
E1_14_77,
E1_14_77_E1,
E1_14_77_E1_F0,
E1_14_77_E1_F0_14,
E1_14_77_E1_F0_14_F0,
} state = INIT;
is_modified = false;
// Pause/Break off(PS/2 has no break for this key)
if (matrix_is_on(ROW(PAUSE), COL(PAUSE))) {
matrix_break(PAUSE);
}
uint8_t code;
while ((code = ps2_host_recv())) {
switch (state) {
case INIT:
switch (code) {
case 0xE0: // 2byte make
state = E0;
break;
case 0xF0: // break code
state = F0;
break;
case 0xE1: // Pause/Break
state = E1;
break;
case 0x83: // F8
matrix_make(F8);
state = INIT;
break;
case 0x84: // PrintScreen
matrix_make(PRINT_SCREEN);
state = INIT;
break;
default: // normal key make
if (code < 0x80) {
matrix_make(code);
} else {
debug("unexpected scan code at INIT: "); debug_hex(code); debug("\n");
}
state = INIT;
}
break;
case E0:
switch (code) {
case 0x12: // postfix/postfix code for exceptional keys
case 0x59: // postfix/postfix code for exceptional keys
// ignore
state = INIT;
break;
case 0x7E: // former part of Control-Pause[E0 7E E0 F0 7E]
matrix_make(PAUSE);
state = INIT;
break;
case 0xF0: // E0 break
state = E0_F0;
break;
default: // E0 make
if (code < 0x80) {
matrix_make(code|0x80);
} else {
debug("unexpected scan code at E0: "); debug_hex(code); debug("\n");
}
state = INIT;
}
break;
case F0:
switch (code) {
case 0x83:
matrix_break(F8);
state = INIT;
break;
case 0x84:
matrix_break(PRINT_SCREEN);
state = INIT;
break;
default:
if (code < 0x80) {
matrix_break(code);
} else {
debug("unexpected scan code at F0: "); debug_hex(code); debug("\n");
}
state = INIT;
}
break;
case E0_F0: // E0 break
switch (code) {
case 0x12: // postfix/postfix code for exceptional keys
case 0x59: // postfix/postfix code for exceptional keys
case 0x7E: // latter part of Control-Pause[E0 7E E0 F0 7E]
// ignore
state = INIT;
break;
default:
if (code < 0x80) {
matrix_break(code|0x80);
} else {
debug("unexpected scan code at E0_F0: "); debug_hex(code); debug("\n");
}
state = INIT;
}
break;
/* Pause */
case E1:
switch (code) {
case 0x14:
state = E1_14;
break;
default:
state = INIT;
}
break;
case E1_14:
switch (code) {
case 0x77:
state = E1_14_77;
break;
default:
state = INIT;
}
break;
case E1_14_77:
switch (code) {
case 0xE1:
state = E1_14_77_E1;
break;
default:
state = INIT;
}
break;
case E1_14_77_E1:
switch (code) {
case 0xF0:
state = E1_14_77_E1_F0;
break;
default:
state = INIT;
}
break;
case E1_14_77_E1_F0:
switch (code) {
case 0x14:
state = E1_14_77_E1_F0_14;
break;
default:
state = INIT;
}
break;
case E1_14_77_E1_F0_14:
switch (code) {
case 0xF0:
state = E1_14_77_E1_F0_14_F0;
break;
default:
state = INIT;
}
break;
case E1_14_77_E1_F0_14_F0:
switch (code) {
case 0x77:
matrix_make(PAUSE);
state = INIT;
break;
default:
state = INIT;
}
break;
default:
state = INIT;
}
phex(code);
}
return 1;
}
static void vbeacon_rfd( void *pvParameters )
{
buffer_t *buffer=0;
uint8_t send=0, *ptr, i, sqn=0;
int16_t byte;
uint16_t count = 0;
pause(200);
debug_init(115200);
pause(300);
stack_event = open_stack_event_bus(); /* Open socket for stack status message */
stack_service_init( stack_event,NULL, 0 , NULL );
if(stack_start(NULL)==START_SUCCESS)
{
debug("Start Ok\r\n");
}
/*****************************************************************************************************/
/****************************************************************************************************/
for (;;)
{
byte = debug_read_blocking(10);
if(byte != -1)
{
switch(byte)
{
case 'm':
ptr=mac_get_mac_pib_parameter(MAC_IEEE_ADDRESS);
if(ptr)
{
ptr +=7;
debug("Devices mac-address: ");
for(i=0; i< 8 ;i++)
{
if(i)
debug(":");
debug_hex(*ptr--);
}
debug("\r\n");
}
break;
case 'b':
debug_int(uxQueueMessagesWaiting(buffers));
debug(" buffers available.\r\n");
break;
case 'c':
ptr=mac_get_mac_pib_parameter(MAC_CURRENT_CHANNEL);
if(ptr)
{
debug("Current channel: ");
debug_int(*ptr);
debug("\r\n");
}
break;
case '\r':
debug("\r\n");
break;
default:
debug_put(byte);
break;
}
}
if(send && data)
{
buffer_t *buf = socket_buffer_get(data);
if (buf)
{
/* Create data packet */
/*buf->buf[buf->buf_end++] = 'S';
buf->buf[buf->buf_end++] = 'e';
buf->buf[buf->buf_end++] = 'n';
buf->buf[buf->buf_end++] = 's';
buf->buf[buf->buf_end++] = 'o';
buf->buf[buf->buf_end++] = 'r';
buf->buf[buf->buf_end++] = '_';
buf->buf[buf->buf_end++] = mac_long.address[1];
buf->buf[buf->buf_end++] = mac_long.address[0];*/
buf->buf[buf->buf_end++] = sqn;
buf->buf[buf->buf_end++] = 0xc2;
buf->buf[buf->buf_end++] = 0x00;
buf->buf[buf->buf_end++] = 0x08;
buf->buf[buf->buf_end++] = 0x00;
buf->buf[buf->buf_end++] = 0x08;
buf->buf[buf->buf_end++] = 0x00;
buf->buf[buf->buf_end++] = 0x10;
buf->buf[buf->buf_end++] = 0x23;
buf->buf[buf->buf_end++] = 0x16;
if (socket_sendto(data, &cord_address, buf) != pdTRUE)
{
debug("Data send failed.\r\n");
socket_buffer_free(buf);
buf=0;
}
if(sqn==0x0f)
sqn=0;
else
sqn++;
send=0;
}
}
if (count++ >= 400)
{
send=1;
count = 0;
}
if(stack_event)
{
buffer=0;
buffer = waiting_stack_event(10);
if(buffer)
{
switch (parse_event_message(buffer))
{
case BROKEN_LINK:
debug("Route broken to ");
debug("\r\n");
debug_address(&(buffer->dst_sa));
debug("\r\n");
break;
case ASSOCIATION_WITH_COORDINATOR:
debug("Assoc ok ");
if(get_coord_address(&cord_address) == pdTRUE)
{
data = socket(MODULE_CUDP, 0); /* Socket for response data from port number 61619 */
if (data)
{
if (socket_bind(data, &cord_address) != pdTRUE)
{
debug("Bind failed.\r\n");
}
}
}
break;
case NOT_ASSOCIATED:
debug("Application design error:\r\n");
debug("RFD try send data before association\r\n");
break;
case ASSOCIATION_LOST:
if(socket_close(data) == pdTRUE)
{
data=0;
scan_network();
}
break;
case TOO_LONG_PACKET:
debug("Payload Too Length, to ");
debug("\r\n");
break;
default:
break;
}
if(buffer)
{
socket_buffer_free(buffer);
buffer = 0;
}
}
}
LED1_ON();
LED1_OFF();
}
}
void print_table_information(void)
{
neighbor_info_t *b;
#ifdef HAVE_ROUTING
uint8_t addres_length=0;
route_info_t *ptr;
#endif
if( xSemaphoreTake( table_lock, ( portTickType ) 10 ) == pdTRUE )
{
uint8_t i, j;
if(neighbor_table.count)
{
debug("Neighbor Info count:");
debug_hex(neighbor_table.count);
debug("\r\n");
debug("Child count:");
debug_hex(neighbor_table.child_count);
debug("\r\n");
for(i=0; i < MAX_NEIGHBOR_COUNT; i++)
{
b=&(neighbor_table.neighbor_info[i]);
if(b->type==ADDR_NONE)
b=0;
if(b)
{
if(b->type== ADDR_802_15_4_PAN_LONG)
{
debug("Long: ");
for(j=0; j < 2 ; j++)
{
if (j) debug_put(':');
debug_hex( b->address[9-j]);
}
debug(" ");
for(j=0; j < 8 ; j++)
{
if (j) debug_put(':');
debug_hex( b->address[7-j]);
}
}
if(b->type == ADDR_802_15_4_PAN_SHORT)
{
debug("Short: ");
for(j=0; j < 2 ; j++)
{
if (j) debug_put(':');
debug_hex( b->address[3-j]);
}
debug(" ");
for(j=0; j < 2 ; j++)
{
if (j) debug_put(':');
debug_hex( b->address[1-j]);
}
}
debug("\r\nrssi: ");
debug_int(b->last_rssi);
debug("\r\nTTL: ");
debug_hex(b->ttl);
debug("\r\n");
pause_us(200);
}
}
}
else
{
debug("No Neighbor info\r\n");
}
#ifdef HAVE_ROUTING
if(routing_table.count)
{
debug("\r\nroute Info count:");
debug_hex(routing_table.count);
debug("\r\n");
for(i=0; i < MAX_ROUTE_INFO_COUNT; i++)
{
ptr = &(routing_table.route_info[i]);
if(ptr->dest_addr_type==ADDR_NONE)
ptr=0;
if(ptr)
{
debug("Dest: ");
if(ptr->dest_addr_type==ADDR_802_15_4_PAN_LONG)
addres_length=8;
else
addres_length=2;
for(j=0; j < addres_length ; j++)
{
if (j) debug_put(':');
debug_hex(ptr->destination[(addres_length-1)-j]);
}
debug("\r\nNext hop: ");
if(ptr->next_hop_addr_type==ADDR_802_15_4_PAN_LONG)
addres_length=10;
else
addres_length=4;
for(j=0; j < addres_length ; j++)
{
if (j) debug_put(':');
debug_hex(ptr->next_hop[(addres_length-1)-j]);
}
debug("\r\nrssi: ");
debug_int(ptr->last_rssi);
debug("\r\nHop count: ");
debug_hex(ptr->hop_count);
debug("\r\nTTL: ");
debug_hex(ptr->ttl);
debug("\r\n");
}
}
}
else
{
debug("No route info\r\n");
}
#else
debug("Routing disable\r\n");
#endif
xSemaphoreGive( table_lock ); /*free lock*/
}
}
uint8_t matrix_scan(void)
{
#if DIODE_DIRECTION == COL2ROW
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i);
_delay_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols();
if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
}
}
#else
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
select_row(i);
_delay_us(30); // without this wait read unstable value.
matrix_row_t rows = read_cols();
if (matrix_reversed_debouncing[i] != rows) {
matrix_reversed_debouncing[i] = rows;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
matrix_reversed[i] = matrix_reversed_debouncing[i];
}
}
}
for (uint8_t y = 0; y < MATRIX_ROWS; y++) {
matrix_row_t row = 0;
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
row |= ((matrix_reversed[x] & (1<<y)) >> y) << x;
}
matrix[y] = row;
}
#endif
return 1;
}
static void handle_iep_interrupt(void)
{
uint16_t intrs = read_otg_daint() & 0xffff;
uint32_t ep_intr, txstatus, short_data;
unsigned ep, xfersize, dwords, xfered;
while (intrs) {
ep = 31 - clz(intrs);
ep_intr = read_diep_int(ep);
intrs &= ~(1 << ep);
if (!(ep_intr & DEP_TXFIFO_EMPTY))
continue;
if (!(read_diep_empmsk() & (1 << ep)))
continue;
xfered = 0;
while (in_data.size) {
xfersize = min_t(unsigned, in_data.size, dwc2_max_packet_size(ep));
dwords = DIV_ROUND_UP(xfersize, 4);
txstatus = read_dtxfsts(ep);
if (txstatus < dwords)
break;
while (xfersize >= 4) {
volatile uint32_t *ptr = (uint32_t *)in_data.data;
uint32_t val = *ptr;
debug(">> 0x");
debug_hex(val, 8);
debug("\n");
write_ep_fifo(ep, val);
in_data.data += 4;
in_data.size -= 4;
xfered += 4;
xfersize -= 4;
}
if (!xfersize)
break;
short_data = 0;
while (xfersize > 0) {
volatile uint8_t *ptr = (uint8_t *)in_data.data;
short_data <<= 8;
short_data |= *ptr;
in_data.data++;
in_data.size--;
xfered++;
xfersize--;
}
debug(">> 0x");
debug_hex(short_data, (xfered % 4) * 2);
debug("\n");
write_ep_fifo(ep, short_data);
}
set_diep_int(ep, DEP_TXFIFO_EMPTY);
if (xfered) {
while (!(read_diep_int(ep) & DEP_XFER_COMP));
set_diep_int(ep, DEP_XFER_COMP);
clear_diep_empmsk(1 << ep);
set_doep_ctl(ep, DEP_ENA_BIT | DEP_CLEAR_NAK);
if (ep_intr & DEP_NAK_INT)
set_diep_int(ep, DEP_NAK_INT);
}
}
}
uint8_t matrix_scan(void)
{
#ifdef ERGODOX_LEFT_LEDS
uint8_t layer = biton32(layer_state);
if (layer == 1) {
ergodox_left_led_1_on();
ergodox_left_led_2_off();
ergodox_left_led_3_off();
} else if (layer == 2) {
ergodox_left_led_1_off();
ergodox_left_led_2_on();
ergodox_left_led_3_off();
} else if (layer == 3) {
ergodox_left_led_1_off();
ergodox_left_led_2_off();
ergodox_left_led_3_on();
} else if (layer == 4) {
ergodox_left_led_1_on();
ergodox_left_led_2_off();
ergodox_left_led_3_on();
} else if (layer == 5) {
ergodox_left_led_1_on();
ergodox_left_led_2_on();
ergodox_left_led_3_off();
} else if (layer == 6) {
ergodox_left_led_1_off();
ergodox_left_led_2_on();
ergodox_left_led_3_on();
} else if (layer == 7) {
ergodox_left_led_1_on();
ergodox_left_led_2_on();
ergodox_left_led_3_on();
} else {
ergodox_left_led_1_off();
ergodox_left_led_2_off();
ergodox_left_led_3_off();
}
// not actually needed because we already calling init_mcp23018() in next line
// ergodox_left_leds_update();
#endif
uint8_t mcp23018_status = init_mcp23018();
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(mcp23018_status, i);
_delay_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols(mcp23018_status, i);
if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows(mcp23018_status);
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
}
}
return 1;
}
/**
* The application task reading ADC values and using the LEDs.
*/
static void vAppTask( int8_t *pvParameters )
{
uint8_t buttons = 0;
uint16_t U1_value = 0;
uint16_t U2_value = 0;
uint8_t count = 0;
pvParameters;
led1_count = 50;
led2_count = 100;
vTaskDelay( 50 / portTICK_RATE_MS );
vTaskDelay( 100 / portTICK_RATE_MS );
debug("NanoSensor N710 Example Application.\r\n");
/* Start an endless task loop, we must sleep most of the time allowing execution of other tasks. */
for (;;)
{
/* Sleep for 500 ms or until button event */
if (xQueueReceive(button_events, &buttons, 500 / portTICK_RATE_MS) == pdTRUE)
{
switch(buttons)
{
case 0x81:
case 0x01:
/* Read the LM60 illumination sensor (U1) */
/* P0.2 */
debug("Reading illumination (U1). ");
if (get_adc_value(N710_LIGHT, &U1_value) == 0)
{
ssi_sensor_update(0, (uint32_t) U1_value);
debug_int(U1_value);
led1_count = 30;
}
else
{
debug("failed.");
led1_count = 300;
}
debug("\r\n");
break;
case 0x82:
case 0x02:
/* Read the EL7900 temperature sensor (U2) */
/* P0.3 */
debug("Reading temp (U2): ");
if (get_adc_value(N710_TEMP, &U2_value) == 0)
{
int32_t calc_int = (int32_t) U2_value;
calc_int /= 4; /* drop insignificant bits */
//calc_int *= 58608; /* 3*160.039*1000*1000/8192 (value with 6 decimals)*/
calc_int *= 24420; /* 1.25*160.039*1000*1000/8192 (value with 6 decimals)*/
calc_int /= 10000; /* adjust to 2 decimals */
calc_int -= 6785;
U2_value = (int16_t) calc_int;
debug_int(U2_value/100);
debug_put('.');
if ((U2_value%100) >= 10)
{
debug_integer(2, 10, (U2_value%100));
}
else
{
debug_hex(U2_value%100);
}
led1_count = 30;
led2_count = 30;
ssi_sensor_update(1, (int32_t) U2_value);
}
else
{
debug("failed.");
led1_count = 300;
led2_count = 300;
}
debug("\r\n");
break;
default:
debug_hex(buttons);
break;
}
count = 0;
}
else
{
if (count++ >= 2)
{
count = 0;
buttons = 0x01;
xQueueSend( button_events, ( void * ) &buttons, (portTickType) 0 );
buttons = 0x02;
xQueueSend( button_events, ( void * ) &buttons, (portTickType) 0 );
}
}
}
}
static void handle_vendor_request(void)
{
uint32_t u32val;
unsigned baud;
cmd = setup_packet.bRequest;
u32val = (uint32_t)setup_packet.wValue << 16;
u32val |= setup_packet.wIndex;
switch (cmd) {
case FW_REQ_GET_CPU_INFO:
in_data.data = cpu_info;
in_data.size = sizeof(cpu_info);
debug("GET_CPU_INFO\n");
break;
case FW_REQ_MEM_READ:
in_data.data = (const void *)u32val;
in_data.size = setup_packet.wLength;
debug("MEM_READ addr=0x");
debug_hex((uint32_t)in_data.data, 8);
debug(" length=0x");
debug_hex(in_data.size, 0);
debug("\n");
break;
case FW_REQ_MEM_WRITE:
out_data.data = (const void *)u32val;
out_data.size = setup_packet.wLength;
debug("MEM_WRITE addr=0x");
debug_hex((uint32_t)out_data.data, 8);
debug(" length=0x");
debug_hex(out_data.size, 0);
debug("\n");
break;
case FW_REQ_MEM_SET:
out_data.data = (void *)&cmd_data.mem_set;
out_data.size = sizeof(cmd_data.mem_set.args);
cmd_data.mem_set.base = (void *)u32val;
debug("MEM_SET addr=0x");
debug_hex((uint32_t)cmd_data.mem_set.base, 8);
debug("\n");
break;
case FW_REQ_CACHE_INIT:
debug("CACHE_INIT");
switch (setup_packet.wValue) {
case CACHE_D:
debug(" DCACHE\n");
init_dcache();
break;
case CACHE_I:
debug(" ICACHE\n");
init_icache();
break;
default:
debug(" unknown=0x");
debug_hex(setup_packet.wValue, 0);
debug("\n");
break;
}
break;
case FW_REQ_CACHE_FLUSH:
debug("CACHE_FLUSH");
out_data.data = (void *)&cmd_data.cache_flush.args;
out_data.size = sizeof(cmd_data.cache_flush.args);
cmd_data.cache_flush.cache = setup_packet.wValue;
switch (setup_packet.wValue) {
case CACHE_D:
debug(" DCACHE\n");
break;
case CACHE_I:
debug(" ICACHE\n");
break;
default:
debug(" unknown=0x");
debug_hex(setup_packet.wValue, 0);
debug("\n");
break;
}
break;
case FW_REQ_MFC0:
debug("MFC0 reg=0x");
debug_hex(setup_packet.wValue, 0);
debug(" sel=0x");
debug_hex(setup_packet.wIndex, 0);
debug("\n");
cmd_data.mfc0.value = dynamic_mfc0(setup_packet.wValue,
setup_packet.wIndex);
in_data.data = &cmd_data.mfc0.value;
in_data.size = sizeof(cmd_data.mfc0.value);
break;
case FW_REQ_MTC0:
debug("MTC0 reg=0x");
debug_hex(setup_packet.wValue, 0);
debug(" sel=0x");
debug_hex(setup_packet.wIndex, 0);
debug("\n");
cmd_data.mtc0.reg = setup_packet.wValue;
cmd_data.mtc0.sel = setup_packet.wIndex;
out_data.data = &cmd_data.mtc0.value;
out_data.size = sizeof(cmd_data.mtc0.value);
break;
case FW_REQ_JUMP:
debug("JUMP addr=0x");
debug_hex(u32val, 8);
debug("\n");
cmd_data.jump.addr = u32val;
break;
case FW_REQ_BULK_LENGTH:
debug("BULK_LENGTH len=0x");
debug_hex(u32val, 8);
debug("\n");
switch (prev_cmd) {
case FW_REQ_MEM_READ:
in_data.size = u32val;
break;
case FW_REQ_MEM_WRITE:
out_data.size = u32val;
break;
default:
debug(" INVALID!\n");
break;
}
break;
case FW_REQ_UART_INIT:
baud = setup_packet.wIndex * 100;
debug("UART_INIT uart=0x");
debug_hex(setup_packet.wValue, 0);
debug(" baud=0x");
debug_hex(baud, 0);
debug("\n");
uart_init(setup_packet.wValue, baud);
break;
case FW_REQ_RESTART:
ci20_fw_reset();
break;
}
}
uint8_t matrix_scan(void)
{
// scan code reading states
static enum {
RESET,
RESET_RESPONSE,
KBD_ID0,
KBD_ID1,
CONFIG,
READY,
F0,
} state = RESET;
is_modified = false;
uint8_t code;
if ((code = ps2_host_recv())) {
debug("r"); debug_hex(code); debug(" ");
}
switch (state) {
case RESET:
debug("wFF ");
if (ps2_host_send(0xFF) == 0xFA) {
debug("[ack]\nRESET_RESPONSE: ");
state = RESET_RESPONSE;
}
break;
case RESET_RESPONSE:
if (code == 0xAA) {
debug("[ok]\nKBD_ID: ");
state = KBD_ID0;
} else if (code) {
debug("err\nRESET: ");
state = RESET;
}
break;
// after reset receive keyboad ID(2 bytes)
case KBD_ID0:
if (code) {
state = KBD_ID1;
}
break;
case KBD_ID1:
if (code) {
debug("\nCONFIG: ");
state = CONFIG;
}
break;
case CONFIG:
debug("wF8 ");
if (ps2_host_send(0xF8) == 0xFA) {
debug("[ack]\nREADY\n");
state = READY;
}
break;
case READY:
switch (code) {
case 0x00:
break;
case 0xF0:
state = F0;
debug(" ");
break;
default: // normal key make
if (code < 0x88) {
matrix_make(code);
} else {
debug("unexpected scan code at READY: "); debug_hex(code); debug("\n");
}
state = READY;
debug("\n");
}
break;
case F0: // Break code
switch (code) {
case 0x00:
break;
default:
if (code < 0x88) {
matrix_break(code);
} else {
debug("unexpected scan code at F0: "); debug_hex(code); debug("\n");
}
state = READY;
debug("\n");
}
break;
}
return 1;
}
/**
* \brief Network state event handler.
* \param event show network start response or current network state.
*
* - ARM_NWK_BOOTSTRAP_READY: Save NVK peristant data to NVM and Net role
* - ARM_NWK_NWK_SCAN_FAIL: Link Layer Active Scan Fail, Stack is Already at Idle state
* - ARM_NWK_IP_ADDRESS_ALLOCATION_FAIL: No ND Router at current Channel Stack is Already at Idle state
* - ARM_NWK_NWK_CONNECTION_DOWN: Connection to Access point is lost wait for Scan Result
* - ARM_NWK_NWK_PARENT_POLL_FAIL: Host should run net start without any PAN-id filter and all channels
* - ARM_NWK_AUHTENTICATION_FAIL: Pana Authentication fail, Stack is Already at Idle state
*/
void app_parse_network_event(arm_event_s *event )
{
arm_nwk_interface_status_type_e status = (arm_nwk_interface_status_type_e)event->event_data;
switch (status)
{
case ARM_NWK_BOOTSTRAP_READY:
/* Network is ready and node is connect to Access Point */
if(access_point_status==0)
{
uint8_t temp_ipv6[16];
tr_debug("Network Connection Ready");
access_point_status=1;
if( arm_nwk_nd_address_read(net_rf_id,&app_nd_address_info) != 0)
{
tr_debug("ND Address read fail");
}
else
{
debug("ND Access Point:");
printf_ipv6_address(app_nd_address_info.border_router);
debug("ND Prefix 64:");
printf_array(app_nd_address_info.prefix, 8);
if(arm_net_address_get(net_rf_id,ADDR_IPV6_GP,temp_ipv6) == 0)
{
debug("GP IPv6:");
printf_ipv6_address(temp_ipv6);
}
}
if( arm_nwk_mac_address_read(net_rf_id,&app_link_address_info) != 0)
{
tr_debug("MAC Address read fail\n");
}
else
{
uint8_t temp[2];
debug("MAC 16-bit:");
common_write_16_bit(app_link_address_info.PANId,temp);
debug("PAN ID:");
printf_array(temp, 2);
debug("MAC 64-bit:");
printf_array(app_link_address_info.mac_long, 8);
debug("IID (Based on MAC 64-bit address):");
printf_array(app_link_address_info.iid_eui64, 8);
}
}
break;
case ARM_NWK_NWK_SCAN_FAIL:
/* Link Layer Active Scan Fail, Stack is Already at Idle state */
tr_debug("Link Layer Scan Fail: No Beacons");
access_point_status=0;
break;
case ARM_NWK_IP_ADDRESS_ALLOCATION_FAIL:
/* No ND Router at current Channel Stack is Already at Idle state */
tr_debug("ND Scan/ GP REG fail");
access_point_status=0;
break;
case ARM_NWK_NWK_CONNECTION_DOWN:
/* Connection to Access point is lost wait for Scan Result */
tr_debug("ND/RPL scan new network");
access_point_status=0;
break;
case ARM_NWK_NWK_PARENT_POLL_FAIL:
access_point_status=0;
break;
case ARM_NWK_AUHTENTICATION_FAIL:
tr_debug("Network authentication fail");
access_point_status=0;
break;
default:
debug_hex(status);
debug("Unknow event");
break;
}
if(access_point_status == 0)
{
//Set Timer for new network scan
eventOS_event_timer_request(1, ARM_LIB_SYSTEM_TIMER_EVENT,node_main_tasklet_id,5000); // 5 sec timer started
}
}
uint8_t matrix_scan(void)
{
if (mcp23018_status) { // if there was an error
if (++mcp23018_reset_loop == 0) {
// since mcp23018_reset_loop is 8 bit - we'll try to reset once in 255 matrix scans
// this will be approx bit more frequent than once per second
print("trying to reset mcp23018\n");
mcp23018_status = init_mcp23018();
if (mcp23018_status) {
print("left side not responding\n");
} else {
print("left side attached\n");
ergodox_blink_all_leds();
}
}
}
#ifdef DEBUG_MATRIX_FREQ
matrix_scan_count++;
uint32_t timer_now = timer_read32();
if (TIMER_DIFF_32(timer_now, matrix_timer)>1000) {
print("matrix scan frequency: ");
pdec(matrix_scan_count);
print("\n");
matrix_timer = timer_now;
matrix_scan_count = 0;
}
#endif
#ifdef KEYMAP_CUB
uint8_t layer = biton32(layer_state);
ergodox_board_led_off();
ergodox_left_led_1_off();
ergodox_left_led_2_off();
ergodox_left_led_3_off();
switch (layer) {
case 1:
// all
ergodox_left_led_1_on();
ergodox_left_led_2_on();
ergodox_left_led_3_on();
break;
case 2:
// blue
ergodox_left_led_2_on();
break;
case 8:
// blue and green
ergodox_left_led_2_on();
// break missed intentionally
case 3:
// green
ergodox_left_led_3_on();
break;
case 6:
ergodox_board_led_on();
// break missed intentionally
case 4:
case 5:
case 7:
// red
ergodox_left_led_1_on();
break;
default:
// none
break;
}
mcp23018_status = ergodox_left_leds_update();
#endif
#ifdef KEYMAP_SIMON
uint8_t layer = biton32(layer_state);
ergodox_board_led_off();
switch (layer) {
case 0:
// none
break;
default:
ergodox_board_led_on();
break;
}
#endif
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i);
matrix_row_t cols = read_cols(i);
if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
}
}
return 1;
}
