Пример #1
0
void ui_process(uint16_t framenumber)
{
	bool b_btn_state;
	static bool btn0_last_state = false;
	static bool btn1_last_state = false;
	static uint8_t cpt_sof = 0;

	if ((framenumber % 1000) == 0) {
		LED_On(LED0_GPIO);
	}
	if ((framenumber % 1000) == 500) {
		LED_Off(LED0_GPIO);
	}
	// Scan process running each 40ms
	cpt_sof++;
	if (cpt_sof < 40) {
		return;
	}
	cpt_sof = 0;

	// Scan buttons on switch 0 and 1
	b_btn_state = (!gpio_pin_is_high(GPIO_PUSH_BUTTON_1)) ? true : false;
	if (b_btn_state != btn0_last_state) {
		ui_hid_report[0]=b_btn_state;
		udi_hid_generic_send_report_in(ui_hid_report);
		btn0_last_state = b_btn_state;
	}
	b_btn_state = (!gpio_pin_is_high(GPIO_PUSH_BUTTON_2)) ? true : false;
	if (b_btn_state != btn1_last_state) {
		ui_hid_report[0]=b_btn_state;
		udi_hid_generic_send_report_in(ui_hid_report);
		btn1_last_state = b_btn_state;
	}
}
Пример #2
0
void ui_process(uint16_t framenumber)
{
	static uint8_t cpt_sof = 0;

	if ((framenumber % 1000) == 0) {
		LED_On(LED0_GPIO);
	}
	if ((framenumber % 1000) == 500) {
		LED_Off(LED0_GPIO);
	}
	// Scan process running each 2ms
	cpt_sof++;
	if (cpt_sof < 2) {
		return;
	}
	cpt_sof = 0;

	// Uses buttons to move mouse
	if (!gpio_pin_is_high(GPIO_PUSH_BUTTON_1)) {
		udi_hid_mouse_moveX(-MOUSE_MOVE_RANGE);
	}
	if (!gpio_pin_is_high(GPIO_PUSH_BUTTON_2)) {
		udi_hid_mouse_moveX( MOUSE_MOVE_RANGE);
	}
}
Пример #3
0
void fenix_slave(){
	delay_ms(300);
	gpio_configure_pin(CAN0_TX_PIN, GPIO_DIR_OUTPUT|GPIO_INIT_HIGH);
	gpio_configure_pin(CAN0_RX_PIN, GPIO_DIR_INPUT|GPIO_INIT_LOW);
	
	gpio_configure_pin(CAN1_TX_PIN, GPIO_DIR_OUTPUT|GPIO_INIT_HIGH);
	gpio_configure_pin(CAN1_RX_PIN, GPIO_DIR_INPUT|GPIO_INIT_LOW);
	
	while(gpio_pin_is_low(CAN0_RX_PIN) && gpio_pin_is_low(CAN1_RX_PIN));
	while(gpio_pin_is_high(CAN0_RX_PIN) && gpio_pin_is_high(CAN1_RX_PIN));
	
}
Пример #4
0
static void XPROGTarget_SetTxMode(void)
{
	/* Wait for a full cycle of the clock */
	while(gpio_pin_is_high(PIN_PDIC_GPIO) && TimeoutTicksRemaining);
	while(gpio_pin_is_low(PIN_PDIC_GPIO) && TimeoutTicksRemaining);
	while(gpio_pin_is_high(PIN_PDIC_GPIO) && TimeoutTicksRemaining);
		
	usart_disable_rx(USART_PDI);
	usart_enable_tx(USART_PDI);
	gpio_configure_pin(PIN_PDIDTX_GPIO, PIN_PDIDTX_USART_FLAGS);

	IsSending = true;
}
Пример #5
0
/** Sends an IDLE via the USART to the attached target, consisting of a full frame of idle bits. */
void XPROGTarget_SendIdle(void)
{
	/* Switch to Tx mode if currently in Rx mode */
	if (!(IsSending))
	  XPROGTarget_SetTxMode();

	/* Need to do nothing for a full frame to send an IDLE */
	for (uint8_t i = 0; i < BITS_IN_USART_FRAME; i++)
	{
		/* Wait for a full cycle of the clock */
		while(gpio_pin_is_high(PIN_PDIC_GPIO) && TimeoutTicksRemaining);
		while(gpio_pin_is_low(PIN_PDIC_GPIO) && TimeoutTicksRemaining);
		while(gpio_pin_is_high(PIN_PDIC_GPIO) && TimeoutTicksRemaining);
	}
}
Пример #6
0
void ui_usb_sof_event(void)
{
	bool b_btn_state;
	static bool btn_suspend = false;
	static uint16_t counter_sof = 0;

	if (ui_enum_status == UHC_ENUM_SUCCESS) {
		/* Display device enumerated and in active mode */
		if (++counter_sof > ui_device_speed_blink) {
			counter_sof = 0;
			LED_Toggle(LED1_GPIO);
			if (ui_test_done && !ui_test_result) {
				/* Test fail then blink led */
				LED_Toggle(LED0_GPIO);
			}
		}
		/* Scan button to enter in suspend mode and remote wakeup */
		b_btn_state = (!gpio_pin_is_high(GPIO_PUSH_BUTTON_1)) ?
				true : false;
		if (b_btn_state != btn_suspend) {
			/* Button have changed */
			btn_suspend = b_btn_state;
			if (b_btn_state) {
				/* Button has been pressed */
				LED_Off(LED0_GPIO);
				LED_Off(LED1_GPIO);
				LED_Off(LED2_GPIO);
				ui_enable_asynchronous_interrupt();
				uhc_suspend(true);
				return;
			}
		}
	}
}
Пример #7
0
Файл: ui.c Проект: Mazetti/asf
void ui_device_sof_action(void)
{
	uint16_t framenumber;
	static uint8_t cpt_sof = 0;

	if (!ui_device_b_mouse_enable) {
		return;
	}

	framenumber = udd_get_frame_number();
	if ((framenumber % 1000) == 0) {
		LED_On(LED0);
	}

	if ((framenumber % 1000) == 500) {
		LED_Off(LED0);
	}

	/* Scan process running each 2ms */
	cpt_sof++;
	if (2 > cpt_sof) {
		return;
	}

	cpt_sof = 0;

	/* Look touch sensor activity for the X and Y events */
	if (!gpio_pin_is_high(GPIO_PUSH_BUTTON_1)) {
		udi_hid_mouse_moveX(-MOUSE_MOVE_RANGE);
	}
}
Пример #8
0
/**
 * \brief Pin status for ISO7816 RESET PIN.
 *
 * \return 1 if the Pin RESET is high; otherwise 0.
 */
uint8_t iso7816_get_reset_statuts(void)
{
#if defined(SMART_CARD_USING_GPIO)
	return gpio_pin_is_high(gs_ul_rst_pin_idx);
#elif defined(SMART_CARD_USING_IOPORT)
	return (ioport_get_pin_level(gs_ul_rst_pin_idx) == IOPORT_PIN_LEVEL_HIGH);
#endif
}
Пример #9
0
void sim900_power_on(void)
{
	const bool status = gpio_pin_is_high(GPRS_STATUS);
	if(true!=status) {
		debug_string_P(NORMAL,PSTR("(sim900_power_on) module is OFF so power cycling\r\n"));
		sim900_power_toggle();
	} else {
		debug_string_P(NORMAL,PSTR("(sim900_power_on) module is already ON\r\n"));
	}
}
Пример #10
0
void ui_process(uint16_t framenumber)
{
	static uint8_t cpt_sof = 0;
	bool b_btn_state;
	static bool btn0_last_state = false;
	static bool btn1_last_state = false;

	if ((framenumber % 1000) == 0) {
		LED_On(LED0_GPIO);
	}

	if ((framenumber % 1000) == 500) {
		LED_Off(LED0_GPIO);
	}

	/* Scan process running each 20ms */
	cpt_sof++;
	if (20 > cpt_sof) {
		return;
	}

	cpt_sof = 0;

	/* Use buttons to send measures */
	b_btn_state = !gpio_pin_is_high(GPIO_PUSH_BUTTON_1);
	if (b_btn_state != btn0_last_state) {
		btn0_last_state = b_btn_state;
		if (b_btn_state) {
			ieee11073_skeleton_send_measure_1();
		}
	}

	b_btn_state = !gpio_pin_is_high(GPIO_PUSH_BUTTON_2);
	if (b_btn_state != btn1_last_state) {
		btn1_last_state = b_btn_state;
		if (b_btn_state) {
			ieee11073_skeleton_send_measure_2();
		}
	}
}
Пример #11
0
void ui_process(uint16_t framenumber)
{
	static uint8_t cpt_sof = 0;

	if ((framenumber % 1000) == 0) {
		LED_On(LED0_GPIO);
	}
	if ((framenumber % 1000) == 500) {
		LED_Off(LED0_GPIO);
	}
	// Scan process running each 2ms
	cpt_sof++;
	if (cpt_sof < 2) {
		return;
	}
	cpt_sof = 0;

	// Uses buttons to move mouse
	if (!gpio_pin_is_high(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;
		}
	}
}
Пример #12
0
Файл: ui.c Проект: Dewb/mod
void ui_usb_sof_event(void)
{
    bool b_btn_state;
    static bool btn_suspend = false;
    static uint16_t counter_sof = 0;

    if (ui_enum_status == UHC_ENUM_SUCCESS) {

        /* Display device enumerated and in active mode */
        if (++counter_sof > ui_device_speed_blink) {
            counter_sof = 0;
            if (ui_hid_mouse_plug) {
                LED_Toggle(LED0_GPIO);
            } else {
                LED_Off(LED0_GPIO);
            }
            if (ui_msc_plug) {
                LED_Toggle(LED1_GPIO);
            }
            if (ui_test_done && !ui_test_result) {
                /* Test fail then blink led */
                LED_Toggle(LED2_GPIO);
            }
        }
        /* Power on a LED when mouse move */
        if (ui_x || ui_y || ui_scroll) {
            ui_x = ui_y = ui_scroll = 0;
            LED_On(LED0_GPIO);
        }
        /* Power on a LED when mouse button down */
        if (ui_nb_down) {
            LED_On(LED0_GPIO);
        }
        /* Scan button to enter in suspend mode */
        b_btn_state = (!gpio_pin_is_high(GPIO_PUSH_BUTTON_1)) ?
                      true : false;
        if (b_btn_state != btn_suspend) {
            /* Button have changed */
            btn_suspend = b_btn_state;
            if (b_btn_state) {
                /* Button has been pressed */
                LED_Off(LED0_GPIO);
                LED_Off(LED1_GPIO);
                LED_Off(LED2_GPIO);
                LED_Off(LED3_GPIO);
                ui_enable_asynchronous_interrupt();
                uhc_suspend(true);
                return;
            }
        }
    }
}
Пример #13
0
Файл: ui.c Проект: Mazetti/asf
void ui_host_sof_event(void)
{
	bool b_btn_state;
	static bool btn_suspend_and_remotewakeup = false;
	static uint16_t counter_sof = 0;

	if (ui_host_enum_status == UHC_ENUM_SUCCESS) {
		/* Display device enumerated and in active mode */
		if (++counter_sof == 500) {
			counter_sof = 0;
			LED_Toggle(LED0);
		}

		/* Scan button to enter in suspend mode and remote wakeup */
		b_btn_state = (!gpio_pin_is_high(GPIO_PUSH_BUTTON_1)) ?
				true : false;
		if (b_btn_state != btn_suspend_and_remotewakeup) {
			/* Button have changed */
			btn_suspend_and_remotewakeup = b_btn_state;
			if (b_btn_state) {
				/* Button has been pressed */
				LED_Off(LED0);
				LED_Off(LED1);
				ui_enable_asynchronous_interrupt();
				uhc_suspend(true);
				return;
			}
		}

		/* Power on a LED when the mouse move */
		if (!ui_host_x && !ui_host_y && !ui_host_scroll) {
			LED_Off(LED1);
		} else {
			ui_host_x = ui_host_y = ui_host_scroll = 0;
			LED_On(LED1);
		}
	}
}
Пример #14
0
/**
 * \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;
	}
}
Пример #15
0
// wait for push button...
void debug_wait_for_step()
{
	debug_print("Press push button to continue");
	while (gpio_pin_is_high(GPIO_PUSH_BUTTON_0))
	{}
}
Пример #16
0
/**
 * \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_0)) &&
			!(key_state & KEYBOARD_ENTER_MASK)) {
		// Key pressed
		key_state |= KEYBOARD_ENTER_MASK;
		keybuffer->keycode = KEYBOARD_ENTER;
		keybuffer->type = KEYBOARD_PRESS;
	} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_0))
			&& (key_state & KEYBOARD_ENTER_MASK)) {
		// Key released
		key_state &= ~KEYBOARD_ENTER_MASK;
		keybuffer->keycode = KEYBOARD_ENTER;
		keybuffer->type = KEYBOARD_RELEASE;
	} else if ((gpio_pin_is_low(GPIO_PUSH_BUTTON_1)) &&
			!(key_state & KEYBOARD_UP_MASK)) {
		// Key pressed
		key_state |= KEYBOARD_UP_MASK;
		keybuffer->keycode = KEYBOARD_UP;
		keybuffer->type = KEYBOARD_PRESS;
	} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_1))
			&& (key_state & KEYBOARD_UP_MASK)) {
		// Key released
		key_state &= ~KEYBOARD_UP_MASK;
		keybuffer->keycode = KEYBOARD_UP;
		keybuffer->type = KEYBOARD_RELEASE;
	} else if ((gpio_pin_is_low(GPIO_PUSH_BUTTON_2)) &&
			!(key_state & KEYBOARD_DOWN_MASK)) {
		// Key pressed
		key_state |= KEYBOARD_DOWN_MASK;
		keybuffer->keycode = KEYBOARD_DOWN;
		keybuffer->type = KEYBOARD_PRESS;
	} else if ((gpio_pin_is_high(GPIO_PUSH_BUTTON_2))
			&& (key_state & KEYBOARD_DOWN_MASK)) {
		// Key released
		key_state &= ~KEYBOARD_DOWN_MASK;
		keybuffer->keycode = KEYBOARD_DOWN;
		keybuffer->type = KEYBOARD_RELEASE;

	// touch key
	} else if ((check_touch_key_pressed()) &&
			!(key_state & KEYBOARD_BACK_MASK)) {
		// Touch key pressed
		key_state |= KEYBOARD_BACK_MASK;
		keybuffer->keycode = KEYBOARD_BACK;
		keybuffer->type = KEYBOARD_PRESS;
	} else if ((!check_touch_key_pressed()) &&
			(key_state & KEYBOARD_BACK_MASK)) {
		// Touch key released
		key_state &= ~KEYBOARD_BACK_MASK;
		keybuffer->keycode = KEYBOARD_BACK;
		keybuffer->type = KEYBOARD_RELEASE;
	} 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;
	}
}
Пример #17
0
/*-------------------------------------------------------------------------------------------------
 * @fn          MRFI_SPI_SO_IS_HIGH
 *
 * @brief       HIGH
 *
 * @param       none
 *
 * @return      none
 *
 */
uint8_t SPI_SO_IS_HIGH(void)
{
    return gpio_pin_is_high(SPI0_MISO_GPIO);
}
Пример #18
0
/******************************************************************************
    rn42_init
*//**
    @brief Initializes RN42 driver.

    @brief usart    Pointer to the USART hardware structure the RN42 is on.
    @brief irq      IRQ number to process interrupts on.
    @brief gpio_pin Pin connected to the RN42's status output.
******************************************************************************/
void
rn42_init(
    volatile avr32_usart_t *usart,
    uint32_t irq,
    uint32_t gpio_pin)
{ 
    static usart_options_t usart_options =
    {
        .baudrate     = 115200,
        .charlength   = 8,
        .paritytype   = USART_NO_PARITY,
        .stopbits     = USART_1_STOPBIT,
        .channelmode  = USART_NORMAL_CHMODE
    };

    static pdca_channel_options_t pdca_rx_options =
    {
        .pid = AVR32_PDCA_PID_USART3_RX,
        .addr = NULL,
        .size = 0,
        .r_addr = NULL,
        .r_size = 0,
        .transfer_size = PDCA_TRANSFER_SIZE_BYTE
    };

    static pdca_channel_options_t pdca_tx_options =
    {
        .pid = AVR32_PDCA_PID_USART3_TX,
        .addr = NULL,
        .size = 0,
        .r_addr = NULL,
        .r_size = 0,
        .transfer_size = PDCA_TRANSFER_SIZE_BYTE
    };

    /* Initialize the USART to use hardware handshaking. Without the
       handshaking, the RN42 has trouble keeping up when continuosly sending
       fairly small amounts of data. Note that when hardware handshaking is
       enabled, the PDCA must be used for receiving data.
     */
    rn42_usart = usart;
    usart_serial_init(rn42_usart, &usart_options);
    rn42_usart->mr = (rn42_usart->mr & ~0xf) | 0x02;

    /* Register the ISR for USART's DMA completion IRQs. */
    pdca_init_channel(PDCA_CHANNEL_RX, &pdca_rx_options);
    pdca_init_channel(PDCA_CHANNEL_TX, &pdca_tx_options);
    irq_register_handler(usart_isr, PDCA_IRQ, 0);

    setup_usart_rx_dma(bt_buf, sizeof(command_t));
    usart_irq_enable();
    pdca_enable(PDCA_CHANNEL_RX);
    pdca_enable(PDCA_CHANNEL_TX);

    /* Configure RN42 status GPIO. */
    gpio_configure_pin(gpio_pin, GPIO_DIR_INPUT | GPIO_PULL_DOWN);
    gpio_disable_pin_pull_up(gpio_pin);

    rn42_status_pin = gpio_pin;
}


/******************************************************************************
    rn42_connected
*//**
    @brief Returns whether the RN42 is connected by examining the status GPIO.

    The RN42's status line appears to bounce, so this function takes care of
    debouncing it.
******************************************************************************/
static bool
rn42_connected(void)
{
    bool connected1;
    bool connected2;

    do {
        connected1 = gpio_pin_is_high(rn42_status_pin);
        delay_ms(50);
        connected2 = gpio_pin_is_high(rn42_status_pin);
    } while (connected1 != connected2);

    return connected1 & connected2;
}


/******************************************************************************
    rn42_send_data
*//**
    @brief Transmits data to a Bluetooth peer over the RN42 module.

    @param[in] buf  Pointer to the data that should be sent.
    @param[in] size Number of bytes to send.
******************************************************************************/
void
rn42_send_data(uint8_t *buf, uint32_t size)
{
    uint32_t status;

    setup_usart_tx_dma(buf, size);

    while (true)
    {
        status = pdca_get_transfer_status(PDCA_CHANNEL_TX);

        if (status & PDCA_TRANSFER_COMPLETE)
        {
            break;
        }
    }
}


/******************************************************************************
    send_response
*//**
    @brief Sends a response packet to the host.

    @param[in] cmd_id       The command ID we're responding to.
    @param[in] status       The status code.
    @param[in] data         Pointer to data to send to the PC.
    @param[in] data_length  Number of bytes to send.
******************************************************************************/
static void
send_response(
    uint8_t cmd_id,
    uint8_t status,
    uint8_t *data,
    uint32_t data_length)
{
    response_t response = {
        {'C', 'C', 'M', 'D'},
        cmd_id,
        status,
    };
    storeBigU32(&response.data_length, data_length);

    rn42_send_data((uint8_t*) &response, sizeof(response));
    rn42_send_data(data, data_length);
}
Пример #19
0
int main(void)
{
	uint8_t otmx_mode_index = 0;
	bool btn_released = true;

	/* Usual initializations */
	board_init();
	sysclk_init();
	sleepmgr_init();
	irq_initialize_vectors();
	cpu_irq_enable();

	/* Enables the Timers defined in conf_example.h : TCC4 (1) and TCC5 (2)
	 *in this example */
	tc45_enable(&TCC4);
	tc45_enable(&TCC5);

	/* Configures the interrupt level of CCA and CCB modules of the 2
	 *Timers: low */
	tc45_set_cca_interrupt_level(&TCC4, TC45_INT_LVL_LO);
	tc45_set_ccb_interrupt_level(&TCC4, TC45_INT_LVL_LO);
	tc45_set_cca_interrupt_level(&TCC5, TC45_INT_LVL_LO);
	tc45_set_ccb_interrupt_level(&TCC5, TC45_INT_LVL_LO);

	/* Declares the interrupt functions which will be called when CCA and
	 * CCB
	 * interrupts will occur */
	tc45_set_cca_interrupt_callback(&TCC4,
			example_cca_tcc4_interrupt_callback);
	tc45_set_ccb_interrupt_callback(&TCC4,
			example_ccb_tcc4_interrupt_callback);
	tc45_set_cca_interrupt_callback(&TCC5,
			example_cca_tcc5_interrupt_callback);
	tc45_set_ccb_interrupt_callback(&TCC5,
			example_ccb_tcc5_interrupt_callback);

	/* Configures the Timer periods*/
	tc45_write_period(&TCC4, TIMER_TCC4_PERIOD);
	tc45_write_period(&TCC5, TIMER_TCC5_PERIOD);

	/* Configures the CCA and CCB levels*/
	tc45_write_cc(&TCC4, TC45_CCA, TIMER_TCC4_PERIOD / 2);
	tc45_write_cc(&TCC4, TC45_CCB, TIMER_TCC4_PERIOD / 2);
	tc45_write_cc(&TCC5, TC45_CCA, TIMER_TCC5_PERIOD / 4);
	tc45_write_cc(&TCC5, TC45_CCB, TIMER_TCC5_PERIOD / 4);

	/* Enables the CCA and CCB channels*/
	tc45_enable_cc_channels(&TCC4, TC45_CCACOMP);
	tc45_enable_cc_channels(&TCC4, TC45_CCBCOMP);
	tc45_enable_cc_channels(&TCC5, TC45_CCACOMP);
	tc45_enable_cc_channels(&TCC5, TC45_CCBCOMP);

	/* Configures the waveform genertaor in Dual Slope mode and Top*/
	tc45_set_wgm(&TCC4, TC45_WG_DS_T);
	tc45_set_wgm(&TCC5, TC45_WG_DS_T);

	tc45_set_resolution(&TCC4, TIMER_TCC4_TCC5_RESOLUTION);
	tc45_set_resolution(&TCC5, TIMER_TCC4_TCC5_RESOLUTION);

	 while (1) {
		/* Go to sleep, everything is handled by interrupts. */
		sleepmgr_enter_sleep();

		/* Configures the Output Matrix mode */
		if (gpio_pin_is_high(GPIO_PUSH_BUTTON_0)) {
			/* button released */
			btn_released = true;
			continue;
		}

		/* button pressed */
		if (!btn_released) {
			/* Wait release of button */
			continue;
		}
		btn_released = false;

		/* Change OTMX mode */
		otmx_mode_index++;
		switch (otmx_mode_index) {
		case 0:
			tc45_wex_set_otmx(&WEXC, WEX_OTMX_DEFAULT);
			break;

		case 1:
			tc45_wex_set_otmx(&WEXC, WEX_OTMX_1);
			break;

		case 2:
			tc45_wex_set_otmx(&WEXC, WEX_OTMX_2);
			break;

		case 3:
			tc45_wex_set_otmx(&WEXC, WEX_OTMX_3);
			break;

		case 4:
			tc45_wex_set_otmx(&WEXC, WEX_OTMX_4);
			break;

		default:
			otmx_mode_index = -1;
			break;
		}
	}
}
Пример #20
0
/*-------------------------------------------------------------------------------------------------
 * @fn          Check_Rf_Level
 *
 * @brief       data
 *
 * @param       none
 *
 * @return      none
 *
 */
uint8_t Spi_CheckGpio0(void)
{
    return gpio_pin_is_high(CC1101_GPIO0_GPIO);
}
Пример #21
0
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_GPIO);
    }
    if ((framenumber % 1000) == 500) {
        LED_Off(LED0_GPIO);
    }
    // Scan process running each 2ms
    cpt_sof++;
    if ((cpt_sof % 2) == 0) {
        return;
    }

    // Uses buttons to move mouse
    if (!gpio_pin_is_high(GPIO_PUSH_BUTTON_1)) {
        udi_hid_mouse_moveX(-MOUSE_MOVE_RANGE);
    }
    if (!gpio_pin_is_high(GPIO_PUSH_BUTTON_2)) {
        udi_hid_mouse_moveX( MOUSE_MOVE_RANGE);
    }

    // Both buttons down to send keys sequence
    b_btn_state = (!gpio_pin_is_high(GPIO_PUSH_BUTTON_1)
                   && !gpio_pin_is_high(GPIO_PUSH_BUTTON_2));
    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;
        }
    }
}
Пример #22
0
void monitor(void){
  uint32_t prev_tick=0;

  //allocate memory for buffers and flush them
  cmd_buf = membag_alloc(CMD_BUF_SIZE);
  if(!cmd_buf)
    core_panic();
  memset(cmd_buf,0x0,CMD_BUF_SIZE);
  //initialize the power packet buffers
  tx_pkt = &power_pkts[0];
  cur_pkt = &power_pkts[1];
  //both are empty
  tx_pkt->status = POWER_PKT_EMPTY;
  cur_pkt->status = POWER_PKT_EMPTY;

  //initialize runtime configs
  wemo_config.echo = false;
  wemo_config.debug_level = DEBUG_ERROR;
  wemo_config.collect_data = true; //collect power data

  //check if we are on USB
  if(gpio_pin_is_high(VBUS_PIN)){
    rgb_led_set(LED_LT_BLUE,0); 
    //don't start wifi because we are configuring
    b_wifi_enabled=false;
    //don't collect power data
    wemo_config.collect_data = false;
  }
  //check if the plug is in calibrate mode
  if(wemo_config.calibrate){
    //start the calibration PWM
    pwm_channel_enable_interrupt(PWM,CAL_PWM_CHANNEL,CAL_PWM_CHANNEL);
    pwm_channel_enable(PWM,CAL_PWM_CHANNEL);
    //don't start wifi because we are in calibration mode
    b_wifi_enabled=false;
    wemo_config.standalone = true;
    wemo_config.collect_data = false;
    //indicate cal mode with a purple LED
    rgb_led_set(LED_PURPLE,0);
  }
  //check if reset is pressed
  if(gpio_pin_is_low(BUTTON_PIN)){
    //erase the configs
    memset(wemo_config.nilm_id,0x0,MAX_CONFIG_LEN);
    memset(wemo_config.nilm_ip_addr,0x0,MAX_CONFIG_LEN);
    memset(wemo_config.wifi_ssid,0x0,MAX_CONFIG_LEN);
    memset(wemo_config.wifi_pwd,0x0,MAX_CONFIG_LEN);
    //save the erased config
    fs_write_config();
    core_log("erased config");
    //erase the stored data 
    
    //spin until button is released
    rgb_led_set(LED_ORANGE,500);
    while(gpio_pin_is_low(BUTTON_PIN));
    rgb_led_set(LED_ORANGE,0); //disable blink
  }
  //setup WIFI
  if(b_wifi_enabled){
    if(wifi_init()!=0){
      rgb_led_set(LED_PURPLE,0);
    }
    else{
      //good to go! turn light green
      rgb_led_set(LED_LT_GREEN,0);
    }
  }
  //initialize the wifi_rx buffer and flag
  wifi_rx_buf_full = false;
  memset(wifi_rx_buf,0x0,WIFI_RX_BUF_SIZE);
  while (1) {
    //***** SYS TICK ACTIONS ******
    if(sys_tick!=prev_tick){
      //check if there is a valid wemo sample
      if(wemo_sample.valid==true && wemo_config.collect_data){
	core_log_power_data(&wemo_sample);
      }
      wemo_read_power();
      wdt_restart(WDT);
      prev_tick = sys_tick;
    }
    //check for pending data from the Internet
    if(wifi_rx_buf_full){
      core_process_wifi_data();
      wifi_rx_buf_full=false;
    }
    //see if we have any commands to run
    if(cmd_buf_full){
      runcmd(cmd_buf); //  run it
      //clear the buffer
      cmd_buf_idx = 0;
      memset(cmd_buf,0x0,CMD_BUF_SIZE);
      if(wemo_config.echo)
	printf("\r> "); //print the prompt
      cmd_buf_full=false;
    }
  }
    
}
Пример #23
0
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 sequence_pos = 0;
	uint8_t value;
	static uint16_t cpt_sof = 0;

	if ((framenumber % 1000) == 0) {
		LED_On(LED0_GPIO);
	}
	if ((framenumber % 1000) == 500) {
		LED_Off(LED0_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_high(GPIO_PUSH_BUTTON_1)) ? 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
		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;
		}
	}
}
Пример #24
0
/**
 * Main TWI handler
 */
void twi_handler(void) {
    struct ucinfo_t *info = &ucinfo;

    if (ts_rx_valid == true) {
        /* I must be a slave, I've received something */
        switch (slave_rx_addr) {
        case TWICMD_POWERUP:
            /*
             * Turn on a the power supply. If I'm getting this command, I'm a
             * slave and I must have standby power on, so there must be a power
             * supply on me. Separating this and TWICMD_STARTUP gets power to
             * ALL slaves, even those without power supplies, for when the
             * TWICMD_STARTUP happens.
             */
            info->addressing_complete = false;
            gpio_set_pin_high(SPARE_DOWN);
            gpio_set_pin_high(HAVE_USB);
            power_supply_on();
            break;

        case TWICMD_STARTUP:
            /* restart addressing cycle */
            info->addressing_complete = false;
            gpio_set_pin_high(SPARE_DOWN);
            gpio_set_pin_high(HAVE_USB);
            usb_powerup_request();
            break;

        case TWICMD_POWERDOWN:
            usb_powerdown_request();
            break;

        case TWICMD_ADDRESS:
            if (tmp1 < sizeof(addresses) / sizeof(addresses[0])) {
                addresses[tmp1] = slave_rx_data.b[0];
                su_pin[tmp1] = gpio_pin_is_high(SPARE_UP);
                sd_pin[tmp1] = gpio_pin_is_high(SPARE_DOWN);
                tmp1++;
            }

            if (gpio_pin_is_low(SPARE_UP) && gpio_pin_is_high(SPARE_DOWN)) {
                /* This is MY address! Grab it. */
                my_twi_address = slave_rx_data.b[0];
                my_twi_address_set = true;
                delay_msec(1);
                twi_slave_setup(my_twi_address);
                delay_msec(1);

                if (info->chain_configuration == CC_OPEN_UP) {
                    /*
                     * Send notification back up chain to master.
                     * Last address done
                     */
                    gpio_set_pin_low(HAVE_USB);
                } else {
                    /* Propagate down so next module gets next address. */
                    gpio_set_pin_low(SPARE_DOWN);
                }
            }
            break;

        case TWICMD_ADDRESSING_COMPLETE:
            info->addressing_complete = true;
            gpio_set_pin_high(SPARE_DOWN);
            gpio_set_pin_high(HAVE_USB);
            break;

        case TWICMD_FPGA_ASIC_CTL:
            fpga_reg_write(FA_ASIC_CONTROL,
                    (slave_rx_data.b[0] & F_FORCE_BAUD) ? (slave_rx_data.b[0] & ~F_FORCE_BAUD) : ((slave_rx_data.b[0] & ~F_ASIC_BAUD_MASK) | ucinfo.asic_baud_rate_code));
            break;

        case TWICMD_REBOOT:
            if (slave_rx_nb && slave_rx_data.b[0]) {
                /*
                 * Tell Atmel DFU loader not to start app ever again (harmless
                 * with custom loader).
                 */
                flashc_erase_gp_fuse_bit(31, true);
                flashc_write_gp_fuse_bit(31, true);
                /*
                 * Tell custom bootloader not to start app on this boot
                 * (harmless with Atmel DFU loader).
                 */
                AVR32_PM.gplp[1] = 0x73746179;
            }
            /* never returns */
            self_reset();
            break;

        case TWICMD_FAN_SET:
            set_fan_speed(slave_rx_data.b[0], slave_rx_data.b[1]);
            break;

        case TWICMD_DIE_SETTINGS:
            if (slave_rx_nb) {
                hf_nvram_write_die_settings(0, &slave_rx_data.opSettings);
            }
            break;

        case TWICMD_BAD_CORE_BITMAP:
            if (slave_rx_nb) {
                hf_nvram_write_bad_core_bitmap(0, (((uint16_t) slave_rx_data.b[0]) << 8) | slave_rx_data.b[1]);
            }
            break;

        case TWICMD_MIXED_BAUD:
            set_mixed_slave_baudrate();
            break;

        case TWICMD_VOLTAGE_SET:
            if (slave_rx_nb >= 3) {
                module_voltage_set(0, slave_rx_data.b[0], ((uint16_t) slave_rx_data.b[1] << 8) | slave_rx_data.b[2]);
            }
            break;

        default:
            break;
        }
        ts_rx_valid = false;
    }

    if (info->master == false) {
        if (info->addressing_complete == false) {
            /* propagate HAVE_USB back up chain to master during address cycle */
            if (info->chain_configuration == CC_MIDDLE) {
                if (gpio_pin_is_high(USB_DOWN)) {
                    gpio_set_pin_high(HAVE_USB);
                } else {
                    gpio_set_pin_low(HAVE_USB);
                }
            }
        }
    }

    masterHandler();
}
Пример #25
0
/**
 * \brief Check GPIO1(SOMI) pin is high
 * 
 * \param none.
 * 
 * \return uint8_t SOMI pin is high return 1.
 */
uint8_t SPI_CheckGpio1(void)
{
	return gpio_pin_is_high(SPI0_MISO_GPIO);
}