static void run_usb_msc_test(const struct test_case *test) { memories_initialization(); // Start USB stack to authorize VBus monitoring udc_start(); if (!udc_include_vbus_monitoring()) { // VBUS monitoring is not available on this product // thereby VBUS has to be considered as present main_vbus_action(true); } // The main loop manages only the power mode // because the USB management is done by interrupt while (!main_b_msc_read) { if (main_b_msc_enumerated) { if (!udi_msc_process_trans()) { sleepmgr_enter_sleep(); } }else{ sleepmgr_enter_sleep(); } } test_assert_true(test, main_b_msc_enumerated, "MSC enumeration fails"); udc_stop(); }
/*! \brief Main function. Execution starts here. */ int main(void) { irq_initialize_vectors(); cpu_irq_enable(); // Initialize the sleep manager sleepmgr_init(); sysclk_init(); board_init(); ui_init(); ui_powerdown(); memories_initialization(); // Start USB stack to authorize VBus monitoring udc_start(); // The main loop manages only the power mode // because the USB management is done by interrupt while (true) { if (main_b_msc_enable) { if (!udi_msc_process_trans()) { sleepmgr_enter_sleep(); } }else{ sleepmgr_enter_sleep(); } } }
/*! \brief Main function. Execution starts here. */ int main(void) { //Initialize interrupt controller irq_initialize_vectors(); cpu_irq_enable(); // Initialize sleep manager sleepmgr_init(); // Initialize clock tree sysclk_init(); // Initialize hardware board resources board_init(); // Initialize user interface ui_init(); ui_powerdown(); // Sanity check about Silicon revision Vs Firmware build // for Silicon revision A, firmware should be specific if ((!firmware_rev_a) && (nvm_read_device_rev()==0)) { ui_si_revision_error(); while(ui_button()!=1); while(ui_button()!=2); while(ui_button()!=4); while(ui_button()!=8); } // Initialize DATA Flash at45dbx_init(); // Initialize ADC for on-board sensors adc_sensors_init(); // Initialize USB HID report protocol usb_hid_com_init(); // Start USB stack main_build_usb_serial_number(); udc_start(); // The main loop manages only the power mode // because everything else is managed by interrupt. // The USB Start of Frame event manages internal tick events for // on-board sensor updates as well as LCD display update. while (true) { if (main_b_msc_enable) { if (!udi_msc_process_trans()) { sleepmgr_enter_sleep(); } } else { sleepmgr_enter_sleep(); } if (usb_hid_com_is_start_dfu()) { main_start_dfu_session(); } } }
static void main_memories_trans_task(void *pvParameters) { UNUSED(pvParameters); while (true) { // Wait for a semaphore which signals that a transfer is requested if( xSemaphoreTake( main_trans_semphr, portMAX_DELAY ) == pdTRUE ) { udi_msc_process_trans(); } } }
/*! \brief Main function. Execution starts here. */ int main(void) { irq_initialize_vectors(); cpu_irq_enable(); // Initialize the sleep manager sleepmgr_init(); sysclk_init(); board_init(); ui_init(); ui_powerdown(); #if UC3A3 // Init Hmatrix bus sysclk_enable_pbb_module(SYSCLK_HMATRIX); init_hmatrix(); #endif #if (defined AT45DBX_MEM) && (AT45DBX_MEM == ENABLE) at45dbx_init(); #endif #if ((defined SD_MMC_MCI_0_MEM) && (SD_MMC_MCI_0_MEM == ENABLE)) \ || ((defined SD_MMC_MCI_1_MEM) && (SD_MMC_MCI_1_MEM == ENABLE)) // Initialize SD/MMC with MCI PB clock. sysclk_enable_pbb_module(SYSCLK_MCI); sysclk_enable_hsb_module(SYSCLK_DMACA); sd_mmc_mci_resources_init(); #endif // Start USB stack to authorize VBus monitoring udc_start(); if (!udc_include_vbus_monitoring()) { // VBUS monitoring is not available on this product // thereby VBUS has to be considered as present main_vbus_action(true); } // The main loop manages only the power mode // because the USB management is done by interrupt while (true) { sleepmgr_enter_sleep(); if (main_b_msc_enable) { udi_msc_process_trans(); } } }
/*! \brief Main function. Execution starts here. */ int main(void) { //uint8_t i = 0; uint16_t temp_crc; irq_initialize_vectors(); cpu_irq_enable(); // Initialize the sleep manager sleepmgr_init(); sysclk_init(); board_init(); ui_init(); ui_powerdown(); memories_initialization(); // Initialize LCD et024006_Init( FOSC0, FOSC0 ); gpio_set_gpio_pin(ET024006DHU_BL_PIN); //et024006_PrintConsole("Welcome Eric", BLACK, -1); //clear_lcd et024006_DrawFilledRect(1, 1, ET024006_WIDTH, ET024006_HEIGHT, BLACK); // Initialize AES module aes_task(); // Start TC tc_task(); Init_System_Status(); // Initialize crc for fast calculations crcInit(); // Read the stored values from the flash Load_stored_values(); //i = sizeof(stored_values_t) - sizeof(uint16_t); temp_crc = crcFast((const uint8_t *)&Stored_values_ram, 192); //temp_crc1 = crcFast("123456789", 9); if (temp_crc == Stored_values_ram.block_crc) { stSystemStatus.stored_value_crc_status = 1; } //Stored_values_ram.salt[5] = 0x4d68ab23; //Update_stored_values(); // Start USB stack to authorize VBus monitoring udc_start(); if (!udc_include_vbus_monitoring()) { // VBUS monitoring is not available on this product // thereby VBUS has to be considered as present main_vbus_action(true); } // The main loop manages only the power mode // because the USB management is done by interrupt while (true) { if (main_b_msc_enable) { if (!udi_msc_process_trans()) { sleepmgr_enter_sleep(); } } else { sleepmgr_enter_sleep(); } //main_process_mode(); } }
/*! \brief Main function. Execution starts here. */ int main(void) { irq_initialize_vectors(); cpu_irq_enable(); wdt_disable(WDT); // Initialize the sleep manager sleepmgr_init(); // Board initialization sysclk_init(); init_board(); init_pwm(); init_i2c(); // Module initialization init_module_peripherals_bp(); /* Initialize SD MMC stack */ delay_ms(200); sd_mmc_init(); // Start USB stack to authorize VBus monitoring udc_start(); // Init SCPI parser console_init(); // Enable 12V enable_12v(); while (true) { console_process(); if((get_ok_12v_status() == RETURN_OK) && (last_ok_12v_state == false)) { set_user_led_colour(0, 100, 0); last_ok_12v_state = true; } else if((get_ok_12v_status() == RETURN_NOK) && (last_ok_12v_state == true)) { set_user_led_colour(0, 0, 0); last_ok_12v_state = false; } // else if(get_sync_signal_status() == RETURN_OK) // set_user_led_colour(0, 0, 100); // else if(get_ok_12v_status() == RETURN_OK) // set_user_led_colour(100, 0, 0); // else // set_user_led_colour(0, 0, 0); if (main_b_msc_enable) { if (!udi_msc_process_trans()) { //sleepmgr_enter_sleep(); } } else { //sleepmgr_enter_sleep(); } } }
/*! \brief Main function. Execution starts here. */ int main(void) { irq_initialize_vectors(); cpu_irq_enable(); wdt_disable(WDT); // Initialize the sleep manager sleepmgr_init(); // Board initialization sysclk_init(); init_board(); init_pwm(); init_i2c(); // Module initialization init_module_peripherals_bp(); /* Initialize SD MMC stack */ delay_ms(200); sd_mmc_init(); // Start USB stack to authorize VBus monitoring udc_start(); // Init SCPI parser console_init(); // Enable 12v enable_12v(); #ifdef TEST_FW set_user_led_colour(100, 100, 100); #else set_user_led_colour(0, 100, 0); #endif while (true) { console_process(); if((get_ok_12v_status() == RETURN_OK) && (last_ok_12v_state == FALSE)) { #ifdef TEST_FW set_user_led_colour(300, 300, 300); #else set_user_led_colour(0, 100, 0); #endif last_ok_12v_state = TRUE; } else if((get_ok_12v_status() == RETURN_NOK) && (last_ok_12v_state == TRUE)) { set_user_led_colour(0, 100, 0); last_ok_12v_state = FALSE; } if(integrator_flag == TRUE) { integrator_flag = FALSE; ch0_integration_time_counter++; ch1_integration_time_counter++; ch0_counter_integrated += get_counter0_value(); ch1_counter_integrated += get_counter1_value(); if(ch0_integration_time_counter == ch0_integration_time_goal) { ch0_integration_time_counter = 0; if(meas_push_activated) { printf("Counter0 value: %llu\x0D", ch0_counter_integrated); } if(get_countera_en_status() == TRUE) { if(last_countera_en == FALSE) last_countera_en = TRUE; else add_new_countera_measurement_to_queue(ch0_counter_integrated); } else last_countera_en = FALSE; ch0_counter_integrated = 0; } if(ch1_integration_time_counter == ch1_integration_time_goal) { ch1_integration_time_counter = 0; if(meas_push_activated) { printf("Counter1 value: %llu\x0D", ch1_counter_integrated); } if(get_counterb_en_status() == TRUE) { if(last_counterb_en == FALSE) last_counterb_en = TRUE; else add_new_counterb_measurement_to_queue(ch1_counter_integrated); } else last_counterb_en = FALSE; ch1_counter_integrated = 0; } } if(second_flag == TRUE) { second_flag = FALSE; } if (main_b_msc_enable) { if (!udi_msc_process_trans()) { //sleepmgr_enter_sleep(); } } else { //sleepmgr_enter_sleep(); } } }
void app_usb_task(void) { static bool sw0_released = true; static bool usb_running = false; static bool cdc_running = false; static bool toggle = true; if (sw0_released && ioport_pin_is_low(GPIO_PUSH_BUTTON_0)) { /* A new press has been done */ sw0_released = false; /* Switch USB state */ if (usb_running) { udc_stop(); gfx_mono_draw_filled_rect(DISPLAY_USB_STA_POS_X, DISPLAY_USB_STA_POS_Y, DISPLAY_USB_STA_SIZE_X, DISPLAY_USB_STA_SIZE_Y, GFX_PIXEL_CLR); app_microsd_start(); } else { /* Stop FatFS on uSD card if enabled */ app_microsd_stop(); stdio_usb_init(); /* Start USB */ gfx_mono_generic_put_bitmap(&bitmap_usb, DISPLAY_USB_STA_POS_X, DISPLAY_USB_STA_POS_Y); } usb_running = !usb_running; cdc_running = true; } else { /* Wait switch release */ sw0_released = ioport_pin_is_high(GPIO_PUSH_BUTTON_0); } if (!usb_running) { return; } /* USB MSC task */ while (udi_msc_process_trans()) { } if (app_usb_cdc_open && !cdc_running) { printf("\x0CSensor data logs:\r\n"); cdc_running = true; } if (!app_usb_cdc_open && cdc_running) { cdc_running = false; } /* Toggle USB icon */ if ((app_usb_cdc_open && app_usb_rec_toggle) || (toggle && app_usb_rec_toggle)) { app_usb_rec_toggle = false; toggle = !toggle; gfx_mono_draw_rect(DISPLAY_USB_STACDC_POS_X, DISPLAY_USB_STACDC_POS_Y, DISPLAY_USB_STACDC_SIZE_X, DISPLAY_USB_STACDC_SIZE_Y, toggle ? GFX_PIXEL_SET : GFX_PIXEL_CLR); } }