/*! \fn guiDisplayGoingToSleep(void) * \brief Going to sleep code */ void guiDisplayGoingToSleep(void) { oledClear(); oledPutstrXY(10, 24, OLED_CENTRE, readStoredStringToBuffer(ID_STRING_GOINGTOSLEEP)); oledBitmapDrawFlash(2, 17, BITMAP_ZZZ, 0); oledDisplayOtherBuffer(); }
/*! \fn guiDisplaySmartcardUnlockedScreen(uint8_t* username) * \brief Display the smartcard unlocked screen * \param username The username (if there's one) */ void guiDisplaySmartcardUnlockedScreen(uint8_t* username) { #if defined(MINI_VERSION) uint8_t temp_Y = THREE_LINE_TEXT_SECOND_POS; // Clear screen, check that the username is valid oledClear(); if ((username[0] != 0) && (username[0] != 0xFF)) { temp_Y = THREE_LINE_TEXT_FIRST_POS; miniOledPutCenteredString(THREE_LINE_TEXT_SECOND_POS, readStoredStringToBuffer(ID_STRING_YOUR_USERNAME)); miniOledPutCenteredString(THREE_LINE_TEXT_THIRD_POS, (char*)username); } miniOledPutCenteredString(temp_Y, readStoredStringToBuffer(ID_STRING_CARD_UNLOCKED)); //oledBitmapDrawFlash(2, 17, BITMAP_INFO, 0); miniOledFlushEntireBufferToDisplay(); #elif defined(HARDWARE_OLIVIER_V1) uint8_t temp_Y = 24; // Clear screen, check that the username is valid oledClear(); if ((username[0] != 0) && (username[0] != 0xFF)) { temp_Y -= 16; oledPutstrXY(10, 24, OLED_CENTRE, readStoredStringToBuffer(ID_STRING_YOUR_USERNAME)); oledPutstrXY(10, 40, OLED_CENTRE, (const char*)username); } oledPutstrXY(10, temp_Y, OLED_CENTRE, readStoredStringToBuffer(ID_STRING_CARD_UNLOCKED)); oledBitmapDrawFlash(2, 17, BITMAP_INFO, 0); oledDisplayOtherBuffer(); #endif }
/*! \fn guiDisplayTextInformationOnScreen(char* text) * \brief Display text information on screen * \param text Text to display */ void guiDisplayTextInformationOnScreen(char* text) { oledClear(); #if defined(HARDWARE_OLIVIER_V1) // No LEDs touchDetectionRoutine(0xFF); oledPutstrXY(10, 24, OLED_CENTRE, text); oledBitmapDrawFlash(2, 17, BITMAP_INFO, 0); oledDisplayOtherBuffer(); #elif defined(MINI_VERSION) miniOledPutCenteredString(THREE_LINE_TEXT_SECOND_POS, text); //oledPutstrXY(0, 10, OLED_CENTRE, text); //oledBitmapDrawFlash(2, 17, BITMAP_INFO, 0); miniOledFlushEntireBufferToDisplay(); #endif }
/*! \fn guiGetPinFromUser(volatile uint16_t* pin_code, uint8_t stringID) * \brief Ask the user to enter a PIN * \param pin_code Pointer to where to store the pin code * \param stringID String ID * \return If the user approved the request */ RET_TYPE guiGetPinFromUser(volatile uint16_t* pin_code, uint8_t stringID) { // If we don't need a pin code, send default one #if defined(NO_PIN_CODE_REQUIRED) || defined(HARDWARE_V1) || defined(V2_DEVELOPERS_BOTPCB_BOOTLOADER_SETUP) *pin_code = SMARTCARD_DEFAULT_PIN; return RETURN_OK; #endif RET_TYPE ret_val = RETURN_NOK; uint8_t selected_digit = 0; uint8_t finished = FALSE; uint8_t current_pin[4]; RET_TYPE temp_rettype; int8_t temp_int8; // Set current pin to 0000 memset((void*)current_pin, 0, 4); // Draw pin entering bitmap oledClear(); oledBitmapDrawFlash(0, 0, BITMAP_YES_NO, 0); oledBitmapDrawFlash(83, 51, BITMAP_PIN_LINES, 0); oledBitmapDrawFlash(238, 23, BITMAP_RIGHT_ARROW, 0); oledPutstrXY(0, 0, OLED_CENTRE, readStoredStringToBuffer(stringID)); oledDisplayOtherBuffer(); oledSetFont(FONT_PROFONT_24); oledWriteActiveBuffer(); // Display current pin on screen guiDisplayPinOnPinEnteringScreen(current_pin, selected_digit); // While the user hasn't entered his pin while(!finished) { // Still process the USB commands usbProcessIncoming(USB_CALLER_PIN); // Detect key touches temp_rettype = touchDetectionRoutine(0); // Send it to the touch wheel interface logic temp_int8 = touchWheelIntefaceLogic(temp_rettype); // Position increment / decrement if (temp_int8 != 0) { if ((current_pin[selected_digit] == 0x0F) && (temp_int8 == 1)) { current_pin[selected_digit] = 0xFF; } else if ((current_pin[selected_digit] == 0) && (temp_int8 == -1)) { current_pin[selected_digit] = 0x10; } current_pin[selected_digit] += temp_int8; guiDisplayPinOnPinEnteringScreen(current_pin, selected_digit); } if ((isSmartCardAbsent() == RETURN_OK) || (hasTimerExpired(TIMER_USERINT, TRUE) == TIMER_EXPIRED)) { // Smartcard removed, no reason to continue ret_val = RETURN_NOK; finished = TRUE; } if (temp_rettype & RETURN_LEFT_PRESSED) { if (selected_digit == 1) { oledFillXY(0, 23, 18, 18, 0x00); oledBitmapDrawFlash(0, 24, BITMAP_CROSS, 0); } if (selected_digit > 0) { // When going back set pin digit to 0 current_pin[selected_digit] = 0; current_pin[--selected_digit] = 0; } else { ret_val = RETURN_NOK; finished = TRUE; } guiDisplayPinOnPinEnteringScreen(current_pin, selected_digit); oledBitmapDrawFlash(238, 23, BITMAP_RIGHT_ARROW, 0); } else if (temp_rettype & RETURN_RIGHT_PRESSED) { if (selected_digit == 2) { oledFillXY(238, 23, 18, 18, 0x00); oledBitmapDrawFlash(240, 24, BITMAP_TICK, 0); } if (selected_digit < 3) { selected_digit++; } else { ret_val = RETURN_OK; finished = TRUE; } guiDisplayPinOnPinEnteringScreen(current_pin, selected_digit); oledBitmapDrawFlash(0, 23, BITMAP_LEFT_ARROW, 0); } } // Reset default font oledSetFont(FONT_DEFAULT); oledWriteInactiveBuffer(); // Store the pin *pin_code = (uint16_t)(((uint16_t)(current_pin[0]) << 12) | (((uint16_t)current_pin[1]) << 8) | (current_pin[2] << 4) | current_pin[3]); // Set current pin to 0000 memset((void*)current_pin, 0, 4); // Prevent touches until the user lifts his finger touchInhibitUntilRelease(); // Return success status return ret_val; }
/*! \fn guiAskForLoginSelect(pNode* p, cNode* c, uint16_t parentNodeAddress) * \brief Ask for user login selection / approval * \param p Pointer to a parent node * \param c Pointer to a child node * \param parentNodeAddress Address of the parent node * \param bypass_confirmation Bool to bypass authorisation request * \return Valid child node address or 0 otherwise */ uint16_t guiAskForLoginSelect(pNode* p, cNode* c, uint16_t parentNodeAddress, uint8_t bypass_confirmation) { uint16_t first_child_address, temp_child_address; uint16_t picked_child = NODE_ADDR_NULL; uint16_t addresses[4]; uint8_t led_mask; int8_t i, j; // Check parent node address if (parentNodeAddress == NODE_ADDR_NULL) { return NODE_ADDR_NULL; } // Read the parent node readParentNode(p, parentNodeAddress); // Read its first child address first_child_address = p->nextChildAddress; // Check if there are stored credentials if (first_child_address == NODE_ADDR_NULL) { guiDisplayInformationOnScreenAndWait(ID_STRING_NO_CREDS); return NODE_ADDR_NULL; } // Read child node readChildNode(c, first_child_address); // Check if there's only one child, that's a confirmation screen if (c->nextChildAddress == NODE_ADDR_NULL) { confirmationText_t temp_conf_text; // Prepare asking confirmation screen temp_conf_text.lines[0] = readStoredStringToBuffer(ID_STRING_CONFACCESSTO); temp_conf_text.lines[1] = (char*)p->service; temp_conf_text.lines[2] = readStoredStringToBuffer(ID_STRING_WITHTHISLOGIN); temp_conf_text.lines[3] = (char*)c->login; // Prompt user for confirmation, flash the screen if ((bypass_confirmation == TRUE) || (guiAskForConfirmation(0xF0 | 4, &temp_conf_text) == RETURN_OK)) { picked_child = first_child_address; } } else { temp_child_address = first_child_address; uint8_t action_chosen = FALSE; while (action_chosen == FALSE) { // Draw asking bitmap oledBitmapDrawFlash(0, 0, BITMAP_LOGIN, 0); // Write domain name on screen char temp_string[INDEX_TRUNCATE_SERVICE_CENTER+1]; memcpy(temp_string, (char*)p->service, sizeof(temp_string)); temp_string[INDEX_TRUNCATE_SERVICE_CENTER] = 0; oledPutstrXY(0, 24, OLED_CENTRE, temp_string); // Clear led_mask led_mask = 0; i = 0; // List logins on screen while ((temp_child_address != NODE_ADDR_NULL) && (i != 4)) { // Read child node to get login readChildNode(c, temp_child_address); // Print Login at the correct slot displayCredentialAtSlot(i, (char*)c->login, INDEX_TRUNCATE_LOGIN_FAV); // Store address in array, fetch next address addresses[i] = temp_child_address; temp_child_address = c->nextChildAddress; i++; } // If nothing after, hide right arrow if ((i != 4) || (c->nextChildAddress == NODE_ADDR_NULL)) { oledFillXY(177, 25, 16, 14, 0x00); led_mask |= LED_MASK_RIGHT; } // Light only the available choices for (j = i; j < 4; j++) { led_mask |= (1 << j); } // Display picture oledDisplayOtherBuffer(); // Get touched quarter j = getTouchedPositionAnswer(led_mask); // Check its validity, knowing that by default we will return NODE_ADDR_NULL if (j == -1) { // Time out action_chosen = TRUE; } else if (j < i) { picked_child = addresses[j]; action_chosen = TRUE; } else if (j == TOUCHPOS_LEFT) { // If there is a previous children, go back 4 indexes if (addresses[0] != first_child_address) { c->prevChildAddress = addresses[0]; for (i = 0; i < 5; i++) { temp_child_address = c->prevChildAddress; readChildNode(c, temp_child_address); } } else { // otherwise, return action_chosen = TRUE; } } else if ((j == TOUCHPOS_RIGHT) && (i == 4) && (c->nextChildAddress != NODE_ADDR_NULL)) { // If there are more nodes to display, let it loop // temp_child_address = c->nextChildAddress; } else { // Wrong position temp_child_address = addresses[0]; } } } return picked_child; }
/*! \fn loginSelectionScreen(void) * \brief Screen displayed to let the user choose/find a login * \return Valid child node address or 0 otherwise */ uint16_t loginSelectionScreen(void) { char currentText[SEARCHTEXT_MAX_LENGTH+1]; uint8_t displayRefreshNeeded = TRUE; uint16_t ret_val = NODE_ADDR_NULL; uint8_t wasWheelReleased = TRUE; uint16_t tempParentAddresses[5]; uint8_t currentStringIndex = 0; uint8_t nbMatchedParents= 0; uint8_t finished = FALSE; RET_TYPE temp_rettype; uint8_t led_mask = 0; int8_t temp_int8; // Set current text to a last_matching_parent_addr = NODE_ADDR_NULL; last_matching_parent_number = 0; memcpy(currentText, "a\x00\x00\x00\x00", sizeof(currentText)); // Draw bitmap, display it and write active buffer oledBitmapDrawFlash(0, 0, BITMAP_LOGIN_FIND, 0); oledDisplayOtherBuffer(); oledWriteActiveBuffer(); // While the user hasn't chosen a credential while(!finished) { if (displayRefreshNeeded == TRUE) { nbMatchedParents = displayCurrentSearchLoginTexts(currentText, tempParentAddresses, currentStringIndex); displayRefreshNeeded = FALSE; // Light only the available choices and right arrow led_mask = 0; for (temp_int8 = nbMatchedParents; temp_int8 < 5; temp_int8++) { led_mask |= (1 << temp_int8); } } // Detect key touches temp_rettype = touchDetectionRoutine(led_mask); // Algo to differentiate a tap from a scroll if ((temp_rettype & RETURN_WHEEL_PRESSED) && (wasWheelReleased == TRUE)) { // We use the timer dedicated to touch inhibit for min activateTimer(TIMER_TOUCH_INHIBIT, TAP_MIN_DEL); // We use the timer dedicated to caps detect for max activateTimer(TIMER_CAPS, TAP_MAX_DEL); // This works because we use the same clearing flags wasWheelReleased = FALSE; } else if (temp_rettype & RETURN_WHEEL_RELEASED) { // Check if it's a tap and that the selected domain is valid if ((hasTimerExpired(TIMER_CAPS, FALSE) == TIMER_RUNNING) && (hasTimerExpired(TIMER_TOUCH_INHIBIT, FALSE) == TIMER_EXPIRED) && (getWheelTouchDetectionQuarter() < nbMatchedParents)) { ret_val = tempParentAddresses[getWheelTouchDetectionQuarter()]; finished = TRUE; } wasWheelReleased = TRUE; } // Send it to the touch wheel interface logic temp_int8 = touchWheelIntefaceLogic(temp_rettype); // Position increment / decrement if (temp_int8 != 0) { if ((currentText[currentStringIndex] == 0x7A) && (temp_int8 == 1)) { // z->0 wrap currentText[currentStringIndex] = 0x2F; } if ((currentText[currentStringIndex] == 0x39) && (temp_int8 == 1)) { // 9->a wrap currentText[currentStringIndex] = 0x60; } else if ((currentText[currentStringIndex] == 0x30) && (temp_int8 == -1)) { // 0->z wrap currentText[currentStringIndex] = 0x7B; } else if ((currentText[currentStringIndex] == 0x61) && (temp_int8 == -1)) { // a->9 wrap currentText[currentStringIndex] = 0x3A; } currentText[currentStringIndex] += temp_int8; displayRefreshNeeded = TRUE; } if ((isSmartCardAbsent() == RETURN_OK) || (hasTimerExpired(TIMER_USERINT, TRUE) == TIMER_EXPIRED)) { // Smartcard removed or no interaction for a while finished = TRUE; } else if (temp_rettype & RETURN_LEFT_PRESSED) { // Change search index if (currentStringIndex > 0) { currentText[currentStringIndex--] = 0; displayRefreshNeeded = TRUE; } else { finished = TRUE; } } else if ((temp_rettype & RETURN_RIGHT_PRESSED) && (nbMatchedParents > 4)) { // Change search index only if we need to... currentText[++currentStringIndex] = 'a'; displayRefreshNeeded = TRUE; } } // Set inactive buffer write by default oledWriteInactiveBuffer(); return ret_val; }
/*! \fn favoriteSelectionScreen(pNode* p, cNode* c) * \brief Screen displayed to let the user choose a favorite * \param p Pointer to a parent node * \param c Pointer to a child node * \return Valid child node address or 0 otherwise */ uint16_t favoriteSelectionScreen(pNode* p, cNode* c) { uint16_t picked_child = NODE_ADDR_NULL; uint16_t parentAddresses[USER_MAX_FAV]; uint16_t childAddresses[USER_MAX_FAV]; uint16_t tempparaddr, tempchildaddr; uint8_t action_chosen = FALSE; uint8_t nbFavorites = 0; uint8_t offset = 0; uint8_t led_mask; int8_t i, j; // Browse through the favorites for (i = 0; i < USER_MAX_FAV; i++) { // Read favorite, check that it is valid readFav(i, &tempparaddr, &tempchildaddr); // If so, store it in our know addresses if (tempparaddr != NODE_ADDR_NULL) { parentAddresses[nbFavorites] = tempparaddr; childAddresses[nbFavorites++] = tempchildaddr; } } // If no favorite, return if (nbFavorites == 0) { guiDisplayInformationOnScreenAndWait(ID_STRING_NOSTOREDFAV); return NODE_ADDR_NULL; } // Loop until the user chooses smth while (action_chosen != TRUE) { // Draw asking bitmap oledBitmapDrawFlash(0, 0, BITMAP_LOGIN, 0); // Clear led_mask led_mask = 0; i = 0; // List logins on screen while (((offset + i) < nbFavorites) && (i != 4)) { // Read child node to get login readChildNode(c, childAddresses[offset+i]); readParentNode(p, parentAddresses[offset+i]); // Print service / login on screen displayCredentialAtSlot(i+((i&0x02)<<2), (char*)c->login, INDEX_TRUNCATE_LOGIN_FAV); displayCredentialAtSlot(i+((~i&0x02)<<2), (char*)p->service, INDEX_TRUNCATE_LOGIN_FAV); // Increment i i++; } // If nothing after, hide right arrow if ((i != 4) || ((offset+i) == nbFavorites)) { oledFillXY(177, 25, 16, 14, 0x00); led_mask |= LED_MASK_RIGHT; } // Light only the available choices for (j = i; j < 4; j++) { led_mask |= (1 << j); } // Display picture oledDisplayOtherBuffer(); // Get touched quarter j = getTouchedPositionAnswer(led_mask); // Check its validity, knowing that by default we will return NODE_ADDR_NULL if (j == -1) { action_chosen = TRUE; // Time out } else if (j < i) { // Valid choice, load parent node as it will be used later readParentNode(p, parentAddresses[offset+j]); picked_child = childAddresses[offset+j]; action_chosen = TRUE; } else if (j == TOUCHPOS_LEFT) { if (offset > 0) { offset -= 4; } else { // User wants to go back action_chosen = TRUE; } } else if ((j == TOUCHPOS_RIGHT) && (i == 4) && ((offset+i) != nbFavorites)) { // If there are more nodes to display offset += 4; } } // Return selected child return picked_child; }
/*! \fn guiAskForConfirmation(const char* string) * \brief Ask for user confirmation for different things * \param nb_args Number of text lines (must be either 1 2 or 3/4 (depending on the MP version)) * \param text_object Pointer to the text object if more than 1 line, pointer to the string if not * \return User confirmation or not */ RET_TYPE guiAskForConfirmation(uint8_t nb_args, confirmationText_t* text_object) { uint8_t flash_flag = FALSE; // Check if we want to flash the screen if ((nb_args & 0xF0) != 0) { nb_args = nb_args & 0x0F; // Check that the user didn't disable it if (getMooltipassParameterInEeprom(FLASH_SCREEN_PARAM) != FALSE) { flash_flag = TRUE; } } #if defined(HARDWARE_OLIVIER_V1) // Temp string for truncating char string_tbd[31]; string_tbd[30] = 0; // Draw asking bitmap oledClear(); oledBitmapDrawFlash(0, 0, BITMAP_YES_NO_INT_L, 0); oledBitmapDrawFlash(222, 0, BITMAP_YES_NO_INT_R, 0); // If more than one line if (nb_args == 1) { // Yeah, that's a bit dirty oledPutstrXY(0, 24, OLED_CENTRE, (char*)text_object); } else { while (nb_args--) { // Truncate and then display string memcpy(string_tbd, text_object->lines[nb_args], 30); oledPutstrXY(0, 2 + (nb_args << 4), OLED_CENTRE, string_tbd); } } // Display result oledDisplayOtherBuffer(); #elif defined(MINI_VERSION) // Variables for scrolling uint8_t string_y_indexes[3]; uint8_t string_extra_chars[3]; uint8_t string_offset_cntrs[3] = {0,0,0}; // Display variables uint8_t approve_selected = TRUE; // Draw asking bitmap oledClear(); miniOledSetMaxTextY(SSD1305_OLED_WIDTH-15); oledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_APPROVE, 0); // Display lines. // Note: line are truncated at the oled driver level when miniOledTextWritingYIncrement is set to FALSE if (nb_args == 1) { miniOledPutCenteredString(THREE_LINE_TEXT_SECOND_POS, (char*)text_object); } else if (nb_args == 2) { string_y_indexes[0] = TWO_LINE_TEXT_FIRST_POS; string_y_indexes[1] = TWO_LINE_TEXT_SECOND_POS; } else { string_y_indexes[0] = THREE_LINE_TEXT_FIRST_POS; string_y_indexes[1] = THREE_LINE_TEXT_SECOND_POS; string_y_indexes[2] = THREE_LINE_TEXT_THIRD_POS; } // For loop to display lines when there is more than one arg if (nb_args > 1) { for (uint8_t i = 0; i < nb_args; i++) { string_extra_chars[i] = strlen(text_object->lines[i]) - miniOledPutCenteredString(string_y_indexes[i], text_object->lines[i]); } } miniOledFlushEntireBufferToDisplay(); miniOledResetMaxTextY(); #endif // In case the display inverted, set it correctly if (flash_flag == TRUE) { activityDetectedRoutine(); oledInvertedDisplay(); timerBased500MsDelay(); oledNormalDisplay(); timerBased500MsDelay(); oledInvertedDisplay(); timerBased500MsDelay(); oledNormalDisplay(); } // Wait for user input #if defined(HARDWARE_OLIVIER_V1) if(getTouchedPositionAnswer(LED_MASK_WHEEL) == TOUCHPOS_RIGHT) { return RETURN_OK; } else { return RETURN_NOK; } #elif defined(MINI_VERSION) RET_TYPE input_answer = MINI_INPUT_RET_NONE; // Switch on lights activityDetectedRoutine(); // Clear possible remaining detection miniWheelClearDetections(); // Arm timer for scrolling (caps timer that isn't relevant here) activateTimer(TIMER_CAPS, SCROLLING_DEL); // Loop while no timeout occurs or no button is pressed while (input_answer == MINI_INPUT_RET_NONE) { input_answer = getYesNoAnswerInput(FALSE); // Text scrolling if ((hasTimerExpired(TIMER_CAPS, TRUE) == TIMER_EXPIRED) && (nb_args > 1)) { miniOledDrawRectangle(0, 0, SSD1305_OLED_WIDTH-15, SSD1305_OLED_HEIGHT, FALSE); activateTimer(TIMER_CAPS, SCROLLING_DEL); miniOledSetMaxTextY(SSD1305_OLED_WIDTH-15); for (uint8_t i = 0; i < nb_args; i++) { if (string_extra_chars[i] > 0) { miniOledPutCenteredString(string_y_indexes[i], (text_object->lines[i]) + string_offset_cntrs[i]); if (string_offset_cntrs[i]++ == string_extra_chars[i]) { string_offset_cntrs[i] = 0; } } else { miniOledPutCenteredString(string_y_indexes[i], text_object->lines[i]); } } miniOledFlushEntireBufferToDisplay(); miniOledResetMaxTextY(); } // Approve / deny display change if (getWheelCurrentIncrement() != 0) { if(approve_selected == FALSE) { oledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_APPROVE, 0); } else { oledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_DENY, 0); } approve_selected = !approve_selected; miniOledFlushEntireBufferToDisplay(); } } if ((input_answer == MINI_INPUT_RET_YES) && (approve_selected != FALSE)) { return RETURN_OK; } else { return RETURN_NOK; } #endif }
/*! \fn guiMainLoop(void) * \brief Main user interface loop */ void guiMainLoop(void) { RET_TYPE input_interface_result; uint8_t screenSaverOnCopy; uint8_t isScreenOnCopy; #if defined(HARDWARE_OLIVIER_V1) // Set led mask depending on our current screen switch(getCurrentScreen()) { case SCREEN_DEFAULT_NINSERTED : currentLedMask = LED_MASK_LEFT|LED_MASK_RIGHT|LED_MASK_WHEEL; break; case SCREEN_DEFAULT_INSERTED_LCK : currentLedMask = LED_MASK_LEFT|LED_MASK_RIGHT|LED_MASK_WHEEL; break; case SCREEN_DEFAULT_INSERTED_NLCK : currentLedMask = LED_MASK_LEFT|LED_MASK_RIGHT; break; case SCREEN_DEFAULT_INSERTED_INVALID : currentLedMask = LED_MASK_LEFT|LED_MASK_RIGHT|LED_MASK_WHEEL; break; case SCREEN_SETTINGS : currentLedMask = LED_MASK_LEFT|LED_MASK_RIGHT; break; case SCREEN_MEMORY_MGMT : currentLedMask = LED_MASK_LEFT|LED_MASK_RIGHT|LED_MASK_WHEEL; break; default: break; } #endif // Make a copy of the screen on & screensaver on bools screenSaverOnCopy = screenSaverOn; isScreenOnCopy = oledIsOn(); #if defined(HARDWARE_OLIVIER_V1) // Launch touch detection routine to check for interactions input_interface_result = touchDetectionRoutine(currentLedMask); #elif defined(MINI_VERSION) input_interface_result = miniGetWheelAction(FALSE, FALSE); #endif #if defined(HARDWARE_OLIVIER_V1) // No activity, switch off LEDs and activate prox detection if (hasTimerExpired(TIMER_LIGHT, TRUE) == TIMER_EXPIRED) { setPwmDc(0x0000); areLightsOn = FALSE; activateProxDetection(); } #endif // No activity, switch off screen if (hasTimerExpired(TIMER_SCREEN, TRUE) == TIMER_EXPIRED) { guiDisplayGoingToSleep(); userViewDelay(); if (getMooltipassParameterInEeprom(SCREENSAVER_PARAM) != FALSE) { screenSaverOn = TRUE; oledWriteInactiveBuffer(); oledClear(); oledDisplayOtherBuffer(); oledClear(); } else { oledDisplayOtherBuffer(); oledOff(); } } #if defined(HARDWARE_OLIVIER_V1) // If there was some activity and we are showing the screen saver if ((input_interface_result & TOUCH_PRESS_MASK) && (screenSaverOnCopy == TRUE)) { guiGetBackToCurrentScreen(); } // If the screen just got turned on, don't call the guiScreenLoop() function if ((input_interface_result & TOUCH_PRESS_MASK) && (((isScreenOnCopy != FALSE) && (screenSaverOnCopy == FALSE)) || (getCurrentScreen() == SCREEN_DEFAULT_INSERTED_LCK))) { guiScreenLoop(input_interface_result); } #elif defined(MINI_VERSION) // If there was some activity and we are showing the screen saver if ((input_interface_result != WHEEL_ACTION_NONE) && (screenSaverOnCopy == TRUE)) { guiGetBackToCurrentScreen(); } if ((input_interface_result != WHEEL_ACTION_NONE) && (((isScreenOnCopy != FALSE) && (screenSaverOnCopy == FALSE)) || (getCurrentScreen() == SCREEN_DEFAULT_INSERTED_LCK))) { guiScreenLoop(input_interface_result); } #endif }