__task void main_task(void) { // State processing uint16_t flags = 0; // LED gpio_led_state_t hid_led_value = GPIO_LED_ON; gpio_led_state_t cdc_led_value = GPIO_LED_ON; gpio_led_state_t msc_led_value = GPIO_LED_ON; // USB uint32_t usb_state_count = USB_BUSY_TIME; // thread running after usb connected started uint8_t thread_started = 0; // button state main_reset_state_t main_reset_button_state = MAIN_RESET_RELEASED; // Initialize settings config_init(); // Initialize our serial mailbox os_mbx_init(&serial_mailbox, sizeof(serial_mailbox)); // Get a reference to this task main_task_id = os_tsk_self(); // leds gpio_init(); // Turn off LED gpio_set_hid_led(GPIO_LED_ON); gpio_set_cdc_led(GPIO_LED_ON); gpio_set_msc_led(GPIO_LED_ON); // do some init with the target before USB and files are configured prerun_target_config(); // Update versions and IDs info_init(); // USB usbd_init(); vfs_user_enable(true); usbd_connect(0); usb_state = USB_CONNECTING; usb_state_count = USB_CONNECT_DELAY; // Start timer tasks os_tsk_create_user(timer_task_30mS, TIMER_TASK_30_PRIORITY, (void *)stk_timer_30_task, TIMER_TASK_30_STACK); // Target running target_set_state(RESET_RUN); while(1) { os_evt_wait_or( FLAGS_MAIN_RESET // Put target in reset state | FLAGS_MAIN_90MS // 90mS tick | FLAGS_MAIN_30MS // 30mS tick | FLAGS_MAIN_POWERDOWN // Power down interface | FLAGS_MAIN_DISABLEDEBUG // Disable target debug | FLAGS_MAIN_PROC_USB // process usb events ,NO_TIMEOUT); // Find out what event happened flags = os_evt_get(); if (flags & FLAGS_MAIN_PROC_USB) { USBD_Handler(); } if (flags & FLAGS_MAIN_RESET) { target_set_state(RESET_RUN); } if (flags & FLAGS_MAIN_POWERDOWN) { // Disable debug target_set_state(NO_DEBUG); // Disconnect USB usbd_connect(0); // Turn off LED gpio_set_hid_led(GPIO_LED_OFF); gpio_set_cdc_led(GPIO_LED_OFF); gpio_set_msc_led(GPIO_LED_OFF); // TODO: put the interface chip in sleep mode while(1); } if (flags & FLAGS_MAIN_DISABLEDEBUG) { // Disable debug target_set_state(NO_DEBUG); } if (flags & FLAGS_MAIN_90MS) { // Update USB busy status vfs_user_periodic(90); // FLAGS_MAIN_90MS // Update USB connect status switch (usb_state) { case USB_DISCONNECTING: usb_state = USB_DISCONNECTED; usbd_connect(0); break; case USB_CONNECTING: // Wait before connecting if (DECZERO(usb_state_count) == 0) { usbd_connect(1); usb_state = USB_CHECK_CONNECTED; } break; case USB_CHECK_CONNECTED: if(usbd_configured()) { if (!thread_started) { os_tsk_create_user(hid_process, DAP_TASK_PRIORITY, (void *)stk_dap_task, DAP_TASK_STACK); serial_task_id = os_tsk_create_user(serial_process, SERIAL_TASK_PRIORITY, (void *)stk_serial_task, SERIAL_TASK_STACK); thread_started = 1; } usb_state = USB_CONNECTED; } break; case USB_CONNECTED: case USB_DISCONNECTED: default: break; } } // 30mS tick used for flashing LED when USB is busy if (flags & FLAGS_MAIN_30MS) { // handle reset button without eventing switch (main_reset_button_state) { default: case MAIN_RESET_RELEASED: if (0 == gpio_get_sw_reset()) { main_reset_button_state = MAIN_RESET_PRESSED; target_forward_reset(true); } break; case MAIN_RESET_PRESSED: // ToDo: add a counter to do a mass erase or target recovery after xxx seconds of being held if (1 == gpio_get_sw_reset()) { main_reset_button_state = MAIN_RESET_TARGET; } break; case MAIN_RESET_TARGET: target_forward_reset(false); main_reset_button_state = MAIN_RESET_RELEASED; break; } if (hid_led_usb_activity && ((hid_led_state == MAIN_LED_FLASH) || (hid_led_state == MAIN_LED_FLASH_PERMANENT))) { // Flash DAP LED ONCE if (hid_led_value) { hid_led_value = GPIO_LED_OFF; } else { hid_led_value = GPIO_LED_ON; // Turn on if (hid_led_state == MAIN_LED_FLASH) { hid_led_usb_activity = 0; } } // Update hardware gpio_set_hid_led(hid_led_value); } if (msc_led_usb_activity && ((msc_led_state == MAIN_LED_FLASH) || (msc_led_state == MAIN_LED_FLASH_PERMANENT))) { // Flash MSD LED ONCE if (msc_led_value) { msc_led_value = GPIO_LED_OFF; } else { msc_led_value = GPIO_LED_ON; // Turn on if (msc_led_state == MAIN_LED_FLASH) { msc_led_usb_activity = 0; } } // Update hardware gpio_set_msc_led(msc_led_value); } if (cdc_led_usb_activity && ((cdc_led_state == MAIN_LED_FLASH) || (cdc_led_state == MAIN_LED_FLASH_PERMANENT))) { // Flash CDC LED ONCE if (cdc_led_value) { cdc_led_value = GPIO_LED_OFF; } else { cdc_led_value = GPIO_LED_ON; // Turn on if (cdc_led_state == MAIN_LED_FLASH) { cdc_led_usb_activity = 0; } } // Update hardware gpio_set_cdc_led(cdc_led_value); } } } }
__task void main_task(void) { // State processing uint16_t flags; // LED uint8_t dap_led_value = 1; uint8_t cdc_led_value = 1; uint8_t msd_led_value = 1; // USB uint32_t usb_state_count; // thread running after usb connected started uint8_t thread_started = 0; // button state char button_activated; // string containing unique ID uint8_t * id_str; // Get a reference to this task main_task_id = os_tsk_self(); // leds gpio_init(); usbd_init(); swd_init(); // Turn on LED gpio_set_dap_led(1); gpio_set_cdc_led(1); gpio_set_msd_led(1); // Setup reset button gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET); button_activated = 1; // USB usbd_connect(0); usb_busy = USB_IDLE; usb_busy_count = 0; usb_state = USB_CONNECTING; usb_state_count = USB_CONNECT_DELAY; // Update HTML version information file update_html_file(); // Start timer tasks os_tsk_create_user(timer_task_30mS, TIMER_TASK_30_PRIORITY, (void *)stk_timer_30_task, TIMER_TASK_30_STACK); // Target running target_set_state(RESET_RUN_WITH_DEBUG); // start semihost task semihost_init(); semihost_enable(); while(1) { os_evt_wait_or( FLAGS_MAIN_RESET // Put target in reset state | FLAGS_MAIN_90MS // 90mS tick | FLAGS_MAIN_30MS // 30mS tick | FLAGS_MAIN_POWERDOWN // Power down interface | FLAGS_MAIN_DISABLEDEBUG // Power down interface | FLAGS_MAIN_USB_DISCONNECT, // Disable target debug NO_TIMEOUT); // Find out what event happened flags = os_evt_get(); if (flags & FLAGS_MAIN_USB_DISCONNECT) { usb_busy = USB_IDLE; // USB not busy usb_state_count = 4; usb_state = USB_DISCONNECT_CONNECT; // disconnect the usb } if (flags & FLAGS_MAIN_RESET) { cdc_led_state = LED_OFF; gpio_set_cdc_led(0); //usbd_cdc_ser_flush(); if (send_uID) { // set the target in reset to not receive char on the serial port target_set_state(RESET_HOLD); // send uid id_str = get_uid_string(); USBD_CDC_ACM_DataSend(id_str, strlen((const char *)id_str)); send_uID = 0; } // Reset target target_set_state(RESET_RUN); cdc_led_state = LED_FLASH; gpio_set_cdc_led(1); button_activated = 0; } if (flags & FLAGS_MAIN_POWERDOWN) { // Stop semihost task semihost_disable(); // Disable debug target_set_state(NO_DEBUG); // Disconnect USB usbd_connect(0); // Turn off LED gpio_set_dap_led(0); gpio_set_cdc_led(0); gpio_set_msd_led(0); // TODO: put the interface chip in sleep mode while (1) { } } if (flags & FLAGS_MAIN_DISABLEDEBUG) { // Stop semihost task semihost_disable(); // Disable debug target_set_state(NO_DEBUG); } if (flags & FLAGS_MAIN_90MS) { if (!button_activated) { gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET); button_activated = 1; } // Update USB busy status switch (usb_busy) { case USB_ACTIVE: if (DECZERO(usb_busy_count) == 0) { usb_busy=USB_IDLE; } break; case USB_IDLE: default: break; } // Update USB connect status switch (usb_state) { case USB_DISCONNECTING: // Wait until USB is idle before disconnecting if (usb_busy == USB_IDLE) { usbd_connect(0); usb_state = USB_DISCONNECTED; } break; case USB_DISCONNECT_CONNECT: // Wait until USB is idle before disconnecting if ((usb_busy == USB_IDLE) && (DECZERO(usb_state_count) == 0)) { usbd_connect(0); usb_state = USB_CONNECTING; // Update HTML file update_html_file(); } break; case USB_CONNECTING: // Wait before connecting if (DECZERO(usb_state_count) == 0) { usbd_connect(1); usb_state = USB_CHECK_CONNECTED; } break; case USB_CHECK_CONNECTED: if(usbd_configured()) { if (!thread_started) { os_tsk_create_user(hid_process, DAP_TASK_PRIORITY, (void *)stk_dap_task, DAP_TASK_STACK); serial_task_id = os_tsk_create_user(serial_process, SERIAL_TASK_PRIORITY, (void *)stk_serial_task, SERIAL_TASK_STACK); thread_started = 1; } usb_state = USB_CONNECTED; } break; case USB_CONNECTED: case USB_DISCONNECTED: default: break; } } // 30mS tick used for flashing LED when USB is busy if (flags & FLAGS_MAIN_30MS) { if (dap_led_usb_activity && ((dap_led_state == LED_FLASH) || (dap_led_state == LED_FLASH_PERMANENT))) { // Flash DAP LED ONCE if (dap_led_value) { dap_led_value = 0; } else { dap_led_value = 1; // Turn on if (dap_led_state == LED_FLASH) { dap_led_usb_activity = 0; } } // Update hardware gpio_set_dap_led(dap_led_value); } if (msd_led_usb_activity && ((msd_led_state == LED_FLASH) || (msd_led_state == LED_FLASH_PERMANENT))) { // Flash MSD LED ONCE if (msd_led_value) { msd_led_value = 0; } else { msd_led_value = 1; // Turn on if (msd_led_state == LED_FLASH) { msd_led_usb_activity = 0; } } // Update hardware gpio_set_msd_led(msd_led_value); } if (cdc_led_usb_activity && ((cdc_led_state == LED_FLASH) || (cdc_led_state == LED_FLASH_PERMANENT))) { // Flash CDC LED ONCE if (cdc_led_value) { cdc_led_value = 0; } else { cdc_led_value = 1; // Turn on if (cdc_led_state == LED_FLASH) { cdc_led_usb_activity = 0; } } // Update hardware gpio_set_cdc_led(cdc_led_value); } } } }
__task void main_task(void) { // State processing uint16_t flags; // LED uint8_t dap_led_value = 1; uint8_t cdc_led_value = 1; uint8_t msd_led_value = 1; // USB uint32_t usb_state_count; // thread running after usb connected started uint8_t thread_started = 0; // button state char button_activated; // string containing unique ID uint8_t * id_str; // Initialize our serial mailbox os_mbx_init(&serial_mailbox, sizeof(serial_mailbox)); // Get a reference to this task main_task_id = os_tsk_self(); // leds gpio_init(); // Turn off LED gpio_set_dap_led(1); gpio_set_cdc_led(1); gpio_set_msd_led(1); #ifdef BOARD_UBLOX_C027 PORT_SWD_SETUP(); // wait until reset output to the target is pulled high while (!PIN_nRESET_IN()) { /* wait doing nothing */ } os_dly_wait(4); // if the reset input from button is low then enter isp programming mode if (!(LPC_GPIO->B[19/*RESET_PIN*/ + (1/*RESET_PORT*/ << 5)] & 1)) { enter_isp(); } #endif usbd_init(); swd_init(); // Setup reset button gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET); button_activated = 1; // USB usbd_connect(0); usb_busy = USB_IDLE; usb_busy_count = 0; usb_state = USB_CONNECTING; usb_state_count = USB_CONNECT_DELAY; // Update HTML version information file update_html_file(); // Start timer tasks os_tsk_create_user(timer_task_30mS, TIMER_TASK_30_PRIORITY, (void *)stk_timer_30_task, TIMER_TASK_30_STACK); #ifndef BOARD_UBLOX_C027 // Target running //target_set_state(RESET_RUN_WITH_DEBUG); #endif #ifdef BOARD_NRF51822AA // Target running target_set_state(RESET_RUN); #endif // start semihost task semihost_init(); semihost_enable(); while(1) { os_evt_wait_or( FLAGS_MAIN_RESET // Put target in reset state | FLAGS_MAIN_90MS // 90mS tick | FLAGS_MAIN_30MS // 30mS tick | FLAGS_MAIN_POWERDOWN // Power down interface | FLAGS_MAIN_DISABLEDEBUG // Power down interface #ifdef USE_USB_EJECT_INSERT | FLAGS_MAIN_USB_DISCONNECT // Disable target debug | FLAGS_MAIN_USB_MEDIA_EJECT, // Eject file system #else | FLAGS_MAIN_USB_DISCONNECT, // Disable target debug #endif NO_TIMEOUT); // Find out what event happened flags = os_evt_get(); if (flags & FLAGS_MAIN_USB_DISCONNECT) { usb_busy = USB_IDLE; // USB not busy usb_state_count = 4; usb_state = USB_DISCONNECT_CONNECT; // disconnect the usb } #ifdef USE_USB_EJECT_INSERT if (flags & FLAGS_MAIN_USB_MEDIA_EJECT) { EjectInsertMediaMode = EJECT_INSERT_WAIT_TO_EJECT; EjectInsertMediaCounter = EJECT_INSERT_DELAY_500MS; } #endif if (flags & FLAGS_MAIN_RESET) { cdc_led_state = LED_OFF; gpio_set_cdc_led(0); //usbd_cdc_ser_flush(); if (send_uID) { // set the target in reset to not receive char on the serial port target_set_state(RESET_HOLD); // send uid id_str = get_uid_string(); USBD_CDC_ACM_DataSend(id_str, strlen((const char *)id_str)); send_uID = 0; } // Reset target target_set_state(RESET_RUN); cdc_led_state = LED_FLASH; gpio_set_cdc_led(1); button_activated = 0; } if (flags & FLAGS_MAIN_POWERDOWN) { // Stop semihost task semihost_disable(); // Disable debug target_set_state(NO_DEBUG); // Disconnect USB usbd_connect(0); // Turn off LED gpio_set_dap_led(0); gpio_set_cdc_led(0); gpio_set_msd_led(0); // TODO: put the interface chip in sleep mode while (1) { } } if (flags & FLAGS_MAIN_DISABLEDEBUG) { // Stop semihost task semihost_disable(); // Disable debug target_set_state(NO_DEBUG); } if (flags & FLAGS_MAIN_90MS) { if (!button_activated) { gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET); button_activated = 1; } #ifdef USE_USB_EJECT_INSERT if (EjectInsertMediaMode == EJECT_INSERT_WAIT_TO_EJECT) { if (--EjectInsertMediaCounter == 0) { // Have waited ~0.5 second, time to eject media EjectInsertMediaMode = EJECT_INSERT_WAIT_TO_INSERT; EjectInsertMediaCounter = EJECT_INSERT_DELAY_500MS; USBD_MSC_MediaReady = __FALSE; } } if ((EjectInsertMediaMode == EJECT_INSERT_WAIT_TO_INSERT) && !USBD_MSC_MediaReadyEx) { // The host computer have questioned the state and received // the message that the media has been removed if (--EjectInsertMediaCounter == 0) { // Have waited ~0.5 seconds after ejecting, time to insert media EjectInsertMediaMode = EJECT_INSERT_INACTIVE; USBD_MSC_MediaReady = __TRUE; } } #endif // Update USB busy status switch (usb_busy) { case USB_ACTIVE: if (DECZERO(usb_busy_count) == 0) { usb_busy=USB_IDLE; } break; case USB_IDLE: default: break; } // Update USB connect status switch (usb_state) { case USB_DISCONNECTING: // Wait until USB is idle before disconnecting if (usb_busy == USB_IDLE) { usbd_connect(0); usb_state = USB_DISCONNECTED; } break; case USB_DISCONNECT_CONNECT: // Wait until USB is idle before disconnecting if ((usb_busy == USB_IDLE) && (DECZERO(usb_state_count) == 0)) { usbd_connect(0); usb_state = USB_CONNECTING; // Update HTML file update_html_file(); // Delay the connecting state before reconnecting to the host - improved usage with VMs usb_state_count = 10; //(90ms * 10 = 900ms) } break; case USB_CONNECTING: // Wait before connecting if (DECZERO(usb_state_count) == 0) { usbd_connect(1); usb_state = USB_CHECK_CONNECTED; } break; case USB_CHECK_CONNECTED: if(usbd_configured()) { if (!thread_started) { os_tsk_create_user(hid_process, DAP_TASK_PRIORITY, (void *)stk_dap_task, DAP_TASK_STACK); serial_task_id = os_tsk_create_user(serial_process, SERIAL_TASK_PRIORITY, (void *)stk_serial_task, SERIAL_TASK_STACK); thread_started = 1; } usb_state = USB_CONNECTED; } break; case USB_CONNECTED: case USB_DISCONNECTED: default: break; } } // 30mS tick used for flashing LED when USB is busy if (flags & FLAGS_MAIN_30MS) { if (dap_led_usb_activity && ((dap_led_state == LED_FLASH) || (dap_led_state == LED_FLASH_PERMANENT))) { // Flash DAP LED ONCE if (dap_led_value) { dap_led_value = 0; } else { dap_led_value = 1; // Turn on if (dap_led_state == LED_FLASH) { dap_led_usb_activity = 0; } } // Update hardware gpio_set_dap_led(dap_led_value); } if (msd_led_usb_activity && ((msd_led_state == LED_FLASH) || (msd_led_state == LED_FLASH_PERMANENT))) { // Flash MSD LED ONCE if (msd_led_value) { msd_led_value = 0; } else { msd_led_value = 1; // Turn on if (msd_led_state == LED_FLASH) { msd_led_usb_activity = 0; } } // Update hardware gpio_set_msd_led(msd_led_value); } if (cdc_led_usb_activity && ((cdc_led_state == LED_FLASH) || (cdc_led_state == LED_FLASH_PERMANENT))) { // Flash CDC LED ONCE if (cdc_led_value) { cdc_led_value = 0; } else { cdc_led_value = 1; // Turn on if (cdc_led_state == LED_FLASH) { cdc_led_usb_activity = 0; } } // Update hardware gpio_set_cdc_led(cdc_led_value); } } } }
/** * @brief Task which handles all UI including keypad, LCD and all user power outputs. * Responds to events caused by other tasks and ISRs * @param None * @retval Should never exit */ __task void ui (void) { uint16_t event_flag = 0; uint8_t key; int i; uint64_t entry_code = 0; lcd_init(); keypad_init(); lcd_backlight(1); buzzer_init(); pwr_sw_init(); usb_outputs_init(); dc_outputs_init(); lcd_clear(); lcd_write_string(" e.quinox "); lcd_goto_XY(0,1); lcd_write_string(" izuba.box "); //2 second timeout os_dly_wait(200); if ( get_unlock_days () >= 0 ) { ui_state = STATE_NORM; } if( local_ee_data.lvdc_flag == 1 ) { ui_state = STATE_LVDC; } reset_display(); reset_outputs(); while(1) { //Wait for any task event or timeout after 1 second if ( os_evt_wait_or(0xFFFF, 100) == OS_R_EVT ) { //Find which event event_flag = os_evt_get(); if ( event_flag & UI_BOX_SETUP ) { ui_state = STATE_SETUP; lcd_clear(); reset_display(); reset_outputs(); } if ( (event_flag & UI_LVDC) ) { if ( (ui_state != STATE_LVDC) && (ui_state != STATE_OFF) ) { ui_state = STATE_LVDC; local_ee_data.lvdc_flag = 1; update_lvdc(1); //Turn off outputs reset_outputs(); lcd_power(1); lcd_clear(); lcd_write_string_XY(0, 0, " Battery Empty "); lcd_write_string_XY(0, 1, " Turning Off "); //Delay and Buzz //20 Seconds for ( i = 0; i < 5; i++) { buzz(1); //4 second wait os_dly_wait(400); } //Turn off Screen lcd_power(0); } } if ( event_flag & UI_PWR_SW ) { if ( ui_state != STATE_OFF) { //Turn off all outputs and UI devices //Wait only for UI_PWR_SW tasks lcd_power(0); ui_state = STATE_OFF; reset_outputs(); } else { //Re-init LCD lcd_clear(); lcd_power(1); check_display_debug(); lcd_splash_screen(2); if(get_soc() >= CHARGED) { local_ee_data.lvdc_flag = 0; update_lvdc(0); } if(local_ee_data.lvdc_flag == 1) { ui_state = STATE_LVDC; } if(ui_state != STATE_LVDC) { if (get_unlock_days () >= 0 ) ui_state = STATE_NORM; else ui_state = STATE_AWAIT_PAYMENT; } reset_outputs(); reset_display(); } //1 second delay os_dly_wait(100); EXTI_ClearITPendingBit(EXTI_Line0); } if ( event_flag & UI_EVT_USB_OC ) { os_dly_wait(100); if(EXTI_GetITStatus(EXTI_Line5) != RESET || EXTI_GetITStatus(EXTI_Line6) != RESET) { if(EXTI_GetITStatus(EXTI_Line5) != RESET) USB1_DISABLE(); if(EXTI_GetITStatus(EXTI_Line6) != RESET) USB2_DISABLE(); lcd_clear(); lcd_write_string_XY(0, 0, " USB "); lcd_write_string_XY(0, 1, " error! "); //2s wait os_dly_wait(200); reset_display(); } } if ( event_flag & (UI_EVT_KEYPAD_1 | UI_EVT_KEYPAD_2 | UI_EVT_KEYPAD_3) ) { if ( (ui_state == STATE_AWAIT_PAYMENT) || (ui_state == STATE_NORM) || (ui_state == STATE_SETUP) ) { //Read which key is pressed i = 0; do { key = keypad_get_key(); i++; os_dly_wait(1); if ( i > 20) break; } while (key == KEY_NONE); if (key != KEY_NONE) { lcd_backlight(1); buzz(1); } if (ui_state == STATE_SETUP) { //If 5 digits and tick then set box_id if (key == KEY_CROSS) { //'X' Pressed //LCDWriteString("x"); display_str[0] = '\0'; digit_count = 0; local_ee_data.box_id = 0; reset_display(); } else if (key == KEY_NONE) { //Do nothing } else if ( key == KEY_TICK ) { if(digit_count == 5){ os_dly_wait(50); //Send message to payment control task os_evt_set(PC_SET_BOX_ID, payment_control_t); ui_state = STATE_AWAIT_PAYMENT; display_str[0] = '\0'; digit_count = 0; reset_display(); reset_outputs(); } }else{ if(digit_count <5){ //Add the keypad value to the box id display_str[0] = '\0'; local_ee_data.box_id = (local_ee_data.box_id * 10) + key; utoa_b(display_str, local_ee_data.box_id, 10, digit_count); lcd_write_string_XY(7, 0, display_str); lcd_goto_XY((8 + digit_count), 0); reset_display(); } else { // do nothing } digit_count++; } } else if (ui_state == STATE_AWAIT_PAYMENT) { if (key == KEY_CROSS) { //'X' Pressed //LCDWriteString("x"); display_str[0] = '\0'; digit_count = 0; entry_code = 0; lcd_write_string_XY(6, 0, "__________"); lcd_goto_XY(6, 0); //key = KEY_NONE; } else if (key == KEY_TICK) { //Tick Pressed //LCDWriteString("./"); } else if (key == KEY_NONE) { //Tick Pressed //LCDWriteString("./"); } else { //Add the keypad to the entry code entry_code = (entry_code * 10) + key; //Make the display_str[0] = '\0'; utoa_b(display_str, entry_code, 10, digit_count); lcd_write_string_XY(6, 0, display_str); lcd_goto_XY((7 + digit_count), 0); if (digit_count++ == 9) { os_dly_wait(50); //Send code to payment control task // but send (uint32_t)entry_code if ( check_unlock_code((uint32_t)entry_code)) { TRACE_INFO("2,1,%s\n", display_str); ui_state = STATE_NORM; // Edited Code lcd_clear(); lcd_write_string_XY(0, 0, " Valid "); lcd_write_string_XY(0, 1, " code! "); entry_code = 0; digit_count = 0; display_str[0] = '\0'; //2s wait os_dly_wait(200); // End of Edit reset_display(); reset_outputs(); } else { TRACE_INFO("2,0,%s\n", display_str); // Edited Code lcd_clear(); lcd_write_string_XY(0, 0, " Wrong "); lcd_write_string_XY(0, 1, " code! "); //2s wait os_dly_wait(200); // End of Edit entry_code = 0; digit_count = 0; display_str[0] = '\0'; reset_display(); reset_outputs(); } } } } else { switch (key) { case KEY_NONE: //No Action break; //Special Key Cases case KEY_TICK: TRACE_DEBUG("Key: ./ \n"); break; case KEY_CROSS: TRACE_DEBUG("Key: X \n"); break; default: //Print the key number TRACE_DEBUG("Key: %i \n", key); } } //Wait for release of key (with time-out) i = 0; while( keypad_get_key() != KEY_NONE ) { i++; os_dly_wait(1); if ( i > 20) break; } } } if(local_ee_data.lvdc_flag == 0) { if ( event_flag & UI_PAYMENT_INVALID ) { ui_state = STATE_AWAIT_PAYMENT; lcd_clear(); reset_display(); reset_outputs(); } } if(local_ee_data.lvdc_flag == 1) { lcd_clear(); lcd_write_string_XY(0, 0, " Battery Low "); lcd_batt_level( get_soc(), get_charging_rate() ); if(get_soc() >= CHARGED) { local_ee_data.lvdc_flag = 0; update_lvdc(0); } } //clear event flags os_evt_clr(event_flag, ui_t); } /* Debugging Info on LCD sprintf(str, "P=%.2f", get_adc_voltage(ADC_SOL_V)*get_adc_voltage(ADC_SOL_I)); lcd_goto_XY(0,0); lcd_write_string(str); str[0] = NULL; sprintf(str, "T=%.2f", get_adc_voltage(ADC_TEMP)); lcd_goto_XY(8,0); lcd_write_string(str); str[0] = NULL; sprintf(str, "V=%.2f", get_adc_voltage(ADC_BATT_V)); lcd_goto_XY(0,1); lcd_write_string(str); str[0] = NULL; sprintf(str, "I=%.2f", get_adc_voltage(ADC_BATT_I)); lcd_goto_XY(8,1); lcd_write_string(str); str[0] = NULL; */ //Update battery levels, days remaining and if normal state then time/date if(local_ee_data.lvdc_flag == 1) { lcd_write_string_XY(0, 0, " Battery Low "); lcd_batt_level( get_soc(), get_charging_rate() ); if(get_soc() >= CHARGED) { local_ee_data.lvdc_flag = 0; update_lvdc(0); if(get_unlock_days () >= 0 ) { ui_state = STATE_NORM; } else { ui_state = STATE_AWAIT_PAYMENT; } reset_display(); reset_outputs(); } } if ( (ui_state == STATE_NORM) || (ui_state == STATE_AWAIT_PAYMENT) ) { lcd_batt_level( get_soc(), get_charging_rate() ); } if (ui_state == STATE_NORM) { //Update remaining days if(local_ee_data.full_unlock == EE_FULL_UNLOCK_CODE){ lcd_write_string_XY(0, 1, " Unlocked"); lcd_batt_level( get_soc(), get_charging_rate() ); } else{ lcd_write_string_XY(0, 1, " days"); lcd_write_int_XY(10, 1, get_unlock_days() ); lcd_batt_level( get_soc(), get_charging_rate() ); } } } }
uint32_t osThreadFlagsWait(uint32_t flags, uint32_t options, uint32_t timeout) { os_evt_wait_or(flags, timeout); return os_evt_get(); }