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); } }
/** * \brief Handle start of frame * * Called by USB stack when a start of frame is received, i.e., every * millisecond during normal operation. This function triggers processing * of the user interface if the HID interface has been enabled. */ void main_sof_action(void) { if (!main_b_mouse_enable) { return; } ui_process(udd_get_frame_number()); }
void main_sof_action(void) { if ((!main_b_msc_enable) || (!main_b_cdc_enable)) return; ui_process(udd_get_frame_number()); }
void main_sof_action(void) { static bool btn_last_state = 0; bool btn_state = ui_button(); if (!main_b_generic_enable) return; ui_process(udd_get_frame_number()); if(btn_state!=btn_last_state) { report_to_send[0]=btn_state; udi_hid_generic_send_report_in(report_to_send); } btn_last_state=btn_state; }
void ui_device_sof_action(void) { uint16_t framenumber; static uint8_t cpt_sof = 0; static int32_t move_count = MOUSE_MOVE_COUNT; static uint8_t move_dir = MOVE_UP; if (!ui_device_b_mouse_enable) { return; } framenumber = udd_get_frame_number(); if ((framenumber % 1000) == 0) { LED_On(); } if ((framenumber % 1000) == 500) { LED_Off(); } /* Scan process running each 2ms */ cpt_sof++; if (2 > cpt_sof) { return; } cpt_sof = 0; /* Uses buttons to move mouse */ if (!port_pin_get_input_level(BUTTON_0_PIN)) { 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; } } }
static void udi_cdc_tx_send(uint8_t port) { irqflags_t flags; uint8_t buf_sel_trans; bool b_short_packet; udd_ep_id_t ep; static uint16_t sof_zlp_counter = 0; #if UDI_CDC_PORT_NB == 1 // To optimize code port = 0; #endif if (udi_cdc_tx_trans_ongoing[port]) { return; // Already on going or wait next SOF to send next data } if (udd_is_high_speed()) { if (udi_cdc_tx_sof_num[port] == udd_get_micro_frame_number()) { return; // Wait next SOF to send next data } }else{ if (udi_cdc_tx_sof_num[port] == udd_get_frame_number()) { return; // Wait next SOF to send next data } } flags = cpu_irq_save(); // to protect udi_cdc_tx_buf_sel buf_sel_trans = udi_cdc_tx_buf_sel[port]; if (udi_cdc_tx_buf_nb[port][buf_sel_trans] == 0) { sof_zlp_counter++; if (((!udd_is_high_speed()) && (sof_zlp_counter < 100)) || (udd_is_high_speed() && (sof_zlp_counter < 800))) { cpu_irq_restore(flags); return; } } sof_zlp_counter = 0; if (!udi_cdc_tx_both_buf_to_send[port]) { // Send current Buffer // and switch the current buffer udi_cdc_tx_buf_sel[port] = (buf_sel_trans==0)?1:0; }else{ // Send the other Buffer // and no switch the current buffer buf_sel_trans = (buf_sel_trans==0)?1:0; } udi_cdc_tx_trans_ongoing[port] = true; cpu_irq_restore(flags); b_short_packet = (udi_cdc_tx_buf_nb[port][buf_sel_trans] != UDI_CDC_TX_BUFFERS); if (b_short_packet) { if (udd_is_high_speed()) { udi_cdc_tx_sof_num[port] = udd_get_micro_frame_number(); }else{ udi_cdc_tx_sof_num[port] = udd_get_frame_number(); } }else{ udi_cdc_tx_sof_num[port] = 0; // Force next transfer without wait SOF } // Send the buffer with enable of short packet switch (port) { #define UDI_CDC_PORT_TO_DATA_EP_IN(index, unused) \ case index: \ ep = UDI_CDC_DATA_EP_IN_##index; \ break; MREPEAT(UDI_CDC_PORT_NB, UDI_CDC_PORT_TO_DATA_EP_IN, ~) #undef UDI_CDC_PORT_TO_DATA_EP_IN default: ep = UDI_CDC_DATA_EP_IN_0; break; } udd_ep_run( ep, b_short_packet, udi_cdc_tx_buf[port][buf_sel_trans], udi_cdc_tx_buf_nb[port][buf_sel_trans], udi_cdc_data_sent); }
/*! \brief Main function. Execution starts here. */ int main(void) { uint8_t write_data[PATTERN_TEST_LENGTH]; uint8_t read_data[PATTERN_TEST_LENGTH]; uint32_t file_size = 0,remaining_len = 0;; struct i2c_master_packet tx_buf = { .address = SLAVE_ADDRESS, .data_length = PATTERN_TEST_LENGTH, .data = write_data, .ten_bit_address = false, .high_speed = false, .hs_master_code = 0x0, }; struct i2c_master_packet rx_buf = { .address = SLAVE_ADDRESS, .data_length = 1, .data = read_data, .ten_bit_address = false, .high_speed = false, .hs_master_code = 0x0, }; uint8_t nb_twi_packets_sent; uint16_t cdc_rx_size; irq_initialize_vectors(); cpu_irq_enable(); sleepmgr_init(); system_init(); configure_usart(); ui_init(); ui_powerdown(); udc_start(); printf("Start application\r\n"); while (true) { if (!b_com_port_opened) { continue; } if (b_cdc_data_rx == true) { b_cdc_data_rx = false; cdc_rx_size = udi_cdc_get_nb_received_data(); udi_cdc_read_buf((void *)cdc_data, cdc_rx_size); if (file_size == 0 && cdc_rx_size == 4) { MSB0W(file_size) = cdc_data[0]; MSB1W(file_size) = cdc_data[1]; MSB2W(file_size) = cdc_data[2]; MSB3W(file_size) = cdc_data[3]; printf("File size :%ld\r\n",file_size); } remaining_len += cdc_rx_size; if (cdc_rx_size == TARGET_PAGE_SIZE/2) { if (!b_wait) { memcpy((void *)(write_data), (const void *)cdc_data, cdc_rx_size); b_wait = true; if (file_size + 4 == remaining_len) { tx_buf.data_length = TARGET_PAGE_SIZE/2; while (i2c_master_write_packet_wait(&i2c_master_instance, &tx_buf) != STATUS_OK) ; } } else { memcpy((void *)(write_data + (TARGET_PAGE_SIZE/2)), (const void *)cdc_data, cdc_rx_size); tx_buf.data_length = TARGET_PAGE_SIZE; while (i2c_master_write_packet_wait(&i2c_master_instance, &tx_buf) != STATUS_OK) ; b_wait = false; } } else { if ((cdc_rx_size) <= PATTERN_TEST_LENGTH) { tx_buf.data_length = cdc_rx_size; memcpy((void *)(write_data), (const void *)cdc_data, cdc_rx_size); while (i2c_master_write_packet_wait(&i2c_master_instance, &tx_buf) != STATUS_OK) ; } else { nb_twi_packets_sent = 0; while(cdc_rx_size / PATTERN_TEST_LENGTH) { tx_buf.data_length = PATTERN_TEST_LENGTH; memcpy((void *)(write_data), (const void *)(&cdc_data[(nb_twi_packets_sent++) * (PATTERN_TEST_LENGTH)]), PATTERN_TEST_LENGTH); while (i2c_master_write_packet_wait(&i2c_master_instance, &tx_buf) != STATUS_OK) ; cdc_rx_size -= (PATTERN_TEST_LENGTH); } if(cdc_rx_size) { tx_buf.data_length = cdc_rx_size; memcpy((void *)(write_data), (const void *)(&cdc_data[(nb_twi_packets_sent) * (PATTERN_TEST_LENGTH)]), cdc_rx_size); while (i2c_master_write_packet_wait(&i2c_master_instance, &tx_buf) != STATUS_OK) ; cdc_rx_size = 0; } } } } if (i2c_master_read_packet_wait(&i2c_master_instance, &rx_buf) == STATUS_OK) { udi_cdc_write_buf((const void *)(rx_buf.data),(iram_size_t)read_data[0]); if (file_size + 4 == remaining_len) { printf("File transfer successfully, file size:%ld, transefer size :%ld\r\n",file_size,remaining_len-4); } } } } void main_suspend_action(void) { ui_powerdown(); } void main_resume_action(void) { ui_wakeup(); } void main_sof_action(void) { if (!main_b_cdc_enable) return; ui_process(udd_get_frame_number()); } #ifdef USB_DEVICE_LPM_SUPPORT void main_suspend_lpm_action(void) { ui_powerdown(); } void main_remotewakeup_lpm_disable(void) { ui_wakeup_disable(); } void main_remotewakeup_lpm_enable(void) { ui_wakeup_enable(); } #endif bool main_cdc_enable(uint8_t port) { main_b_cdc_enable = true; configure_i2c_master(); return true; } void main_cdc_disable(uint8_t port) { main_b_cdc_enable = false; b_com_port_opened = false; i2c_master_disable(&i2c_master_instance); }
void main_sof_action(void) { if (!main_b_kbd_enable) return; ui_process(udd_get_frame_number()); }
void main_sof_action(void) { // LCD strings for on-board sensors static uint8_t lcd_txt_light[LCD_TEXT_STRING_SIZE + 2 * LCD_TEST_DISPLAY_SIZE] = "LIGHT SENSOR "; static uint8_t lcd_txt_ntc[LCD_TEXT_STRING_SIZE + 2 * LCD_TEST_DISPLAY_SIZE] = "TEMPERATURE SENSOR "; static uint8_t lcd_txt_pot[LCD_TEXT_STRING_SIZE + 2 * LCD_TEST_DISPLAY_SIZE] = "POTENTIOMETER INPUT "; static uint8_t lcd_txt_ext_v[LCD_TEXT_STRING_SIZE + 2 * LCD_TEST_DISPLAY_SIZE] = "EXTERNAL VOLTAGE "; static uint8_t old_button; if (main_timeout_user_message) { // Currently LCD is busy displaying user message from USB // Wait end of timeout to display again sensor message if (--main_timeout_user_message == 0) { switch (main_sensor_selected) { case LIGHT_SENSOR: ui_display_text(lcd_txt_light, sizeof(lcd_txt_light)); break; case TEMPERATURE_SENSOR: ui_display_text(lcd_txt_ntc, sizeof(lcd_txt_ntc)); break; case POTENTIOMETER_SENSOR: ui_display_text(lcd_txt_pot, sizeof(lcd_txt_pot)); break; case EXT_VOLTAGE_INPUT: ui_display_text(lcd_txt_ext_v, sizeof(lcd_txt_ext_v)); default: break; } } } // Change LOCAL text display when a button is pressed... if (old_button!=ui_button()) { old_button=ui_button(); if (ui_pusb_button_0()) { ui_display_text(lcd_txt_light, sizeof(lcd_txt_light)); main_sensor_selected = LIGHT_SENSOR; } if (ui_pusb_button_1()) { ui_display_text(lcd_txt_ntc, sizeof(lcd_txt_ntc)); main_sensor_selected = TEMPERATURE_SENSOR; } if (ui_pusb_button_2()) { ui_display_text(lcd_txt_pot, sizeof(lcd_txt_pot)); main_sensor_selected = POTENTIOMETER_SENSOR; } if (ui_pusb_button_3()) { ui_display_text(lcd_txt_ext_v, sizeof(lcd_txt_ext_v)); main_sensor_selected = EXT_VOLTAGE_INPUT; } // If hid generic interface is not up and running, do nothing if (!main_b_generic_enable) { return; } } // Prepare new report each HID_SEND_REPORT_MS ms if ((udd_get_frame_number() % HID_SEND_REPORT_MS) == 0) { usb_hid_com_send_report_in(); } // Prepare new ADC samples each ADC_NEW_SAMPLE_MS ms if ((udd_get_frame_number() % ADC_NEW_SAMPLE_MS) == 0) { adc_sensors_start_conversions(); } // Each LCD_SCROLLING_MS ms Performs LCD scrolling if ((udd_get_frame_number() % LCD_SCROLLING_MS) == 0) { ui_scroll_text(); } // Refresh on-board sensors LCD display // each LCD_SENSOR_MS and if no user message is displayed if (((udd_get_frame_number() % LCD_SENSOR_MS) == 0) && (main_timeout_user_message == 0)) { switch (main_sensor_selected) { case LIGHT_SENSOR: ui_display_sensor(adc_sensor_get_light(), UI_UNIT_NONE); break; case TEMPERATURE_SENSOR: ui_display_sensor(adc_sensor_get_temperature(), UI_UNIT_DEGREE_C); break; case POTENTIOMETER_SENSOR: ui_display_sensor(adc_sensor_get_potentiometer(), UI_UNIT_MILIVOLT); break; case EXT_VOLTAGE_INPUT: ui_display_sensor(adc_sensor_get_ext_voltage(), UI_UNIT_MILIVOLT); default: break; } } }