/*! \fn activityDetectedRoutine(void) * \brief What to do when user activity has been detected */ void activityDetectedRoutine(void) { // Activate timers for automatic switch off & user interaction timeout activateTimer(TIMER_LIGHT, LIGHT_TIMER_DEL); activateTimer(TIMER_SCREEN, SCREEN_TIMER_DEL); activateTimer(SLOW_TIMER_LOCKOUT, getMooltipassParameterInEeprom(LOCK_TIMEOUT_PARAM)); activateTimer(TIMER_USERINT, ((uint16_t)controlEepromParameter(getMooltipassParameterInEeprom(USER_INTER_TIMEOUT_PARAM), MIN_USER_INTER_DEL/1000, MAX_USER_INTER_DEL/1000)) << 10); // If the screen was off, turn it on! if (oledIsOn() == FALSE) { oledOn(); screenComingOnDelay(); } // If we are in screen saver mode, exit it! if (screenSaverOn == TRUE) { screenSaverOn = FALSE; } // There are only lights in the Mooltipass standard version #if defined(HARDWARE_OLIVIER_V1) // If the lights were off, turn them on! if (areLightsOn == FALSE) { setPwmDc(MAX_PWM_VAL); activateGuardKey(); areLightsOn = TRUE; } #endif }
/*! \fn activityDetectedRoutine(void) * \brief What to do when user activity has been detected */ void activityDetectedRoutine(void) { #ifdef HARDWARE_V1 return; #endif // Activate timers for automatic switch off activateTimer(TIMER_LIGHT, LIGHT_TIMER_DEL); activateTimer(TIMER_SCREEN, SCREEN_TIMER_DEL); // If the screen was off, turn it on! if (oledIsOn() == FALSE) { oledOn(); screenComingOnDelay(); } // If the lights were off, turn them on! if (areLightsOn == FALSE) { setPwmDc(MAX_PWM_VAL); activateGuardKey(); areLightsOn = TRUE; } }
void QGeoPositionInfoSourceAndroid::updateTimeoutElapsed() { QGeoPositionInfo position; position=m_lastUpdate; if (position.isValid()) { if (m_positionInfoState & QGeoPositionInfoSourceAndroid::RequestActive) { m_requestTimer->stop(); m_positionInfoState &= ~QGeoPositionInfoSourceAndroid::RequestActive; if (m_positionInfoState & QGeoPositionInfoSourceAndroid::Stopped ||!(m_positionInfoState & QGeoPositionInfoSourceAndroid::StartUpdateActive)) { QtLocationJni::disableUpdates(this); } } emit positionUpdated(position); } else { emit updateTimeout(); } activateTimer(); }
void QGeoSatelliteInfoSourceMaemo::requestUpdate(int timeout) { int timeoutForRequest = 0; if (!timeout) { if (LiblocationWrapper::instance()->isActive()) // If GPS is active, assume quick fix. timeoutForRequest = DEFAULT_UPDATE_INTERVAL; else // Otherwise reserve longer time to get a fix. timeoutForRequest = POWERSAVE_POWERON_PERIOD; } else if (timeout < MINIMUM_UPDATE_INTERVAL) { if (satelliteInfoState & QGeoSatelliteInfoSourceMaemo::RequestActive) return; emit requestTimeout(); return; } else { timeoutForRequest = timeout; } satelliteInfoState |= QGeoSatelliteInfoSourceMaemo::RequestActive; if (!(LiblocationWrapper::instance()->isActive())) LiblocationWrapper::instance()->start(); activateTimer(); requestTimer->start(timeoutForRequest); }
void CIntObject::setTimer(int msToTrigger) { if (!(active & TIME)) activateTimer(); toNextTick = timerDelay = msToTrigger; used |= TIME; }
// public slots: void QGeoPositionInfoSourceAndroid::startUpdates() { QtLocationJni::requestUpdates(updateInterval(),this); m_positionInfoState |=QGeoPositionInfoSourceAndroid::Started; m_positionInfoState &=~QGeoPositionInfoSourceAndroid::Stopped; m_positionInfoState |= QGeoPositionInfoSourceAndroid::StartUpdateActive; activateTimer(); }
void QGeoSatelliteInfoSourceMaemo::startUpdates() { startLocationDaemon(); // Ensure that powersave is selected, if stopUpdates() has been called, // but selected update interval is still greater than POWERSAVE_THRESHOLD. if (timerInterval >= POWERSAVE_THRESHOLD) satelliteInfoState |= QGeoSatelliteInfoSourceMaemo::PowersaveActive; activateTimer(); }
/*! \fn getTouchedPositionAnswer(uint8_t led_mask) * \brief Use the capacitive interface to get quarter position * \param led_mask Led mask for the touchdetection routine * \return Number between 0 and 5 for valid pos, -1 otherwise */ int8_t getTouchedPositionAnswer(uint8_t led_mask) { #ifdef HARDWARE_V1 _delay_ms(2000); #endif #if defined(ALWAYS_ACCEPT_REQUESTS) || defined(HARDWARE_V1) // First quarter is discarded, it means we want yes or no! if (led_mask & LED_MASK_WHEEL_TLEFT) { return TOUCHPOS_RIGHT; } else { return TOUCHPOS_WHEEL_TLEFT; } #endif RET_TYPE touch_detect_result; // Switch on lights activityDetectedRoutine(); // Clear possible remaining detection touchDetectionRoutine(led_mask); touchWaitForWheelReleased(); touchClearCurrentDetections(); // Wait for a touch press, delay stored in eeprom (1024 is quite close to 1000 ;-) ) activateTimer(TIMER_USERINT, ((uint16_t)controlEepromParameter(getMooltipassParameterInEeprom(USER_INTER_TIMEOUT_PARAM), MIN_USER_INTER_DEL/1000, MAX_USER_INTER_DEL/1000)) << 10); do { // User interaction timeout or smartcard removed if ((hasTimerExpired(TIMER_USERINT, TRUE) == TIMER_EXPIRED) || (isSmartCardAbsent() == RETURN_OK)) { return -1; } touch_detect_result = touchDetectionRoutine(led_mask) & TOUCH_PRESS_MASK; } while (!touch_detect_result); // Did the user press one of the two touch buttons? if (touch_detect_result & RETURN_LEFT_PRESSED) { return TOUCHPOS_LEFT; } else if (touch_detect_result & RETURN_RIGHT_PRESSED) { return TOUCHPOS_RIGHT; } else { return (int8_t)getWheelTouchDetectionQuarter(); } }
void QGeoSatelliteInfoSourceMaemo::requestTimeoutElapsed() { updateTimer->stop(); emit requestTimeout(); satelliteInfoState &= ~QGeoSatelliteInfoSourceMaemo::RequestActive; if (satelliteInfoState & QGeoSatelliteInfoSourceMaemo::Stopped) if (LiblocationWrapper::instance()->isActive()) LiblocationWrapper::instance()->stop(); activateTimer(); }
void QGeoPositionInfoSourceAndroid::requestTimeoutElapsed() { m_updateTimer->stop(); m_positionInfoState &=~QGeoPositionInfoSourceAndroid::RequestActive; if (m_positionInfoState & QGeoPositionInfoSourceAndroid::Stopped ||!(m_positionInfoState & QGeoPositionInfoSourceAndroid::StartUpdateActive)) { QtLocationJni::disableUpdates(this); } emit updateTimeout(); activateTimer(); }
/*! \fn usbKeyboardSend(void) * \brief Send the contents of keyboard_keys and keyboard_modifier_keys * \return If we managed to send the keyboard keys */ RET_TYPE usbKeyboardSend(void) { uint8_t i, intr_state; if (!usb_configuration) { return RETURN_COM_NOK; } intr_state = SREG; cli(); UENUM = KEYBOARD_ENDPOINT; // Activate timeout timer activateTimer(TIMER_WAIT_FUNCTS, USB_WRITE_TIMEOUT); while (1) { // are we ready to transmit? if (UEINTX & (1<<RWAL)) { break; } SREG = intr_state; // has the USB gone offline? if (!usb_configuration) { return RETURN_COM_NOK; } // have we waited too long? if (hasTimerExpired(TIMER_WAIT_FUNCTS, TRUE) == TIMER_EXPIRED) { return RETURN_COM_TIMEOUT; } // get ready to try checking again intr_state = SREG; cli(); UENUM = KEYBOARD_ENDPOINT; } UEDATX = keyboard_modifier_keys; UEDATX = 0; for (i=0; i<6; i++) { UEDATX = keyboard_keys[i]; } UEINTX = 0x3A; keyboard_idle_count = 0; SREG = intr_state; return RETURN_COM_TRANSF_OK; }
/*! \fn usbRawHidRecv(uint8_t *buffer, uint8_t timeout) * \brief Receive a packet, with timeout * \param buffer Pointer to the buffer to store received data * \return RETURN_COM_TRANSF_OK or RETURN_COM_NOK or RETURN_COM_TIMEOUT */ RET_TYPE usbRawHidRecv(uint8_t *buffer) { uint8_t intr_state; uint8_t i = 0; // if we're not online (enumerated and configured), error if (!usb_configuration) { return RETURN_COM_NOK; } intr_state = SREG; cli(); // Activate timeout timer activateTimer(TIMER_WAIT_FUNCTS, USB_READ_TIMEOUT); UENUM = RAWHID_RX_ENDPOINT; // wait for data to be available in the FIFO while (1) { if (UEINTX & (1<<RWAL)) { break; } SREG = intr_state; if (hasTimerExpired(TIMER_WAIT_FUNCTS, TRUE) == TIMER_EXPIRED) { return RETURN_COM_TIMEOUT; } if (!usb_configuration) { return RETURN_COM_NOK; } intr_state = SREG; cli(); UENUM = RAWHID_RX_ENDPOINT; } for(i = 0; i < RAWHID_RX_SIZE; i++) { *buffer++ = UEDATX; } // release the buffer UEINTX = 0x6B; SREG = intr_state; return RETURN_COM_TRANSF_OK; }
void CIntObject::activate(ui16 what) { if(what & LCLICK) activateLClick(); if(what & RCLICK) activateRClick(); if(what & HOVER) activateHover(); if(what & MOVE) activateMouseMove(); if(what & KEYBOARD) activateKeys(); if(what & TIME) activateTimer(); if(what & WHEEL) activateWheel(); if(what & DOUBLECLICK) activateDClick(); }
void QGeoSatelliteInfoSourceMaemo::satelliteStatus() { QList<QGeoSatelliteInfo> satellitesInView = LiblocationWrapper::instance()->satellitesInView(); QList<QGeoSatelliteInfo> satellitesInUse = LiblocationWrapper::instance()->satellitesInUse(); if (satelliteInfoState & QGeoSatelliteInfoSourceMaemo::RequestActive) { satelliteInfoState &= ~QGeoSatelliteInfoSourceMaemo::RequestActive; requestTimer->stop(); if (satelliteInfoState & QGeoSatelliteInfoSourceMaemo::Stopped) { if (LiblocationWrapper::instance()->isActive()) { LiblocationWrapper::instance()->stop(); } } // Ensure that requested satellite info is emitted even though // powersave is active and GPS would normally be off. if ((satelliteInfoState & QGeoSatelliteInfoSourceMaemo::PowersaveActive) && (satelliteInfoState & QGeoSatelliteInfoSourceMaemo::Stopped)) { if (satellitesInView.length()) { emit satellitesInViewUpdated(satellitesInView); emit satellitesInUseUpdated(satellitesInUse); } } } // Make sure that if update is triggered when waking up, there // is no false position update. if (!((satelliteInfoState & QGeoSatelliteInfoSourceMaemo::PowersaveActive) && (satelliteInfoState & QGeoSatelliteInfoSourceMaemo::Stopped))) { if (satellitesInView.length()) { emit satellitesInViewUpdated(satellitesInView); emit satellitesInUseUpdated(satellitesInUse); } } activateTimer(); }
void QGeoPositionInfoSourceAndroid::requestUpdate(int timeout) { int timeoutForRequest = 0; if (timeout < MINIMUM_UPDATE_INTERVAL) { if (m_positionInfoState & QGeoPositionInfoSourceAndroid::RequestActive) return; emit updateTimeout(); return; } else { timeoutForRequest = timeout; } m_positionInfoState |= QGeoPositionInfoSourceAndroid::RequestActive; QtLocationJni::requestUpdates(updateInterval(),this); activateTimer(); m_requestTimer->start(timeoutForRequest); }
void QGeoSatelliteInfoSourceMaemo::setUpdateInterval(int msec) { bool updateTimerInterval = false; if (satelliteInfoState & QGeoSatelliteInfoSourceMaemo::PowersaveActive) if (satelliteInfoState & QGeoSatelliteInfoSourceMaemo::Stopped) updateTimerInterval = true; timerInterval = (msec < MINIMUM_UPDATE_INTERVAL) ? MINIMUM_UPDATE_INTERVAL : msec; if (timerInterval >= POWERSAVE_THRESHOLD) satelliteInfoState |= QGeoSatelliteInfoSourceMaemo::PowersaveActive; else satelliteInfoState &= ~QGeoSatelliteInfoSourceMaemo::PowersaveActive; // If powersave has been active when new update interval has been set, // ensure that timer is started. if(updateTimerInterval) startLocationDaemon(); // Ensure that new timer interval is taken into use immediately. activateTimer(); }
/*! \fn main(void) * \brief Main function */ int main(void) { uint16_t current_bootkey_val = eeprom_read_word((uint16_t*)EEP_BOOTKEY_ADDR); RET_TYPE flash_init_result; RET_TYPE touch_init_result; RET_TYPE card_detect_ret; uint8_t fuse_ok = TRUE; // Disable JTAG to gain access to pins, set prescaler to 1 (fuses not set) #ifndef PRODUCTION_KICKSTARTER_SETUP disableJTAG(); CPU_PRESCALE(0); #endif // Check fuse settings: boot reset vector, 2k words, SPIEN, BOD 2.6V, programming & ver disabled if ((boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS) != 0xFF) || (boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS) != 0xD8) || (boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS) != 0xFB) || (boot_lock_fuse_bits_get(GET_LOCK_BITS) != 0xFC)) { fuse_ok = FALSE; } // Check if PB5 is low to start electrical test DDRB &= ~(1 << 5); PORTB |= (1 << 5); smallForLoopBasedDelay(); if (!(PINB & (1 << 5))) { // Test result, true by default uint8_t test_result = TRUE; // Leave flash nS off DDR_FLASH_nS |= (1 << PORTID_FLASH_nS); PORT_FLASH_nS |= (1 << PORTID_FLASH_nS); // Set PORTD as output, leave PORTID_OLED_SS high DDRD |= 0xFF; PORTD |= 0xFF; // All other pins are input by default, run our test for (uint8_t i = 0; i < 4; i++) { PORTD |= 0xFF; smallForLoopBasedDelay(); if (!(PINF & (0xC3)) || !(PINC & (1 << 6)) || !(PINE & (1 << 6)) || !(PINB & (1 << 4))) { test_result = FALSE; } PORTD &= (1 << PORTID_OLED_SS); smallForLoopBasedDelay(); if ((PINF & (0xC3)) || (PINC & (1 << 6)) || (PINE & (1 << 6)) || (PINB & (1 << 4))) { test_result = FALSE; } } // PB6 as test result output DDRB |= (1 << 6); // If test successful, light green LED if ((test_result == TRUE) && (fuse_ok == TRUE)) { PORTB |= (1 << 6); } else { PORTB &= ~(1 << 6); } while(1); } // This code will only be used for developers and beta testers #if !defined(PRODUCTION_SETUP) && !defined(PRODUCTION_KICKSTARTER_SETUP) // Check if we were reset and want to go to the bootloader if (current_bootkey_val == BOOTLOADER_BOOTKEY) { // Disable WDT wdt_reset(); wdt_clear_flag(); wdt_change_enable(); wdt_stop(); // Store correct bootkey eeprom_write_word((uint16_t*)EEP_BOOTKEY_ADDR, CORRECT_BOOTKEY); // Jump to bootloader start_bootloader(); } // Check if there was a change in the mooltipass setting storage to reset the parameters to their correct values if (getMooltipassParameterInEeprom(USER_PARAM_INIT_KEY_PARAM) != USER_PARAM_CORRECT_INIT_KEY) { mooltipassParametersInit(); setMooltipassParameterInEeprom(USER_PARAM_INIT_KEY_PARAM, USER_PARAM_CORRECT_INIT_KEY); } #endif // First time initializations for Eeprom (first boot at production or flash layout changes for beta testers) if (current_bootkey_val != CORRECT_BOOTKEY) { // Erase Mooltipass parameters mooltipassParametersInit(); // Set bootloader password bool to FALSE eeprom_write_byte((uint8_t*)EEP_BOOT_PWD_SET, FALSE); } /* Check if a card is inserted in the Mooltipass to go to the bootloader */ #ifdef AVR_BOOTLOADER_PROGRAMMING /* Disable JTAG to get access to the pins */ disableJTAG(); /* Init SMC port */ initPortSMC(); /* Delay for detection */ smallForLoopBasedDelay(); #if defined(HARDWARE_V1) if (PIN_SC_DET & (1 << PORTID_SC_DET)) #elif defined(HARDWARE_OLIVIER_V1) if (!(PIN_SC_DET & (1 << PORTID_SC_DET))) #endif { uint16_t tempuint16; /* What follows is a copy from firstDetectFunctionSMC() */ /* Enable power to the card */ PORT_SC_POW &= ~(1 << PORTID_SC_POW); /* Default state: PGM to 0 and RST to 1 */ PORT_SC_PGM &= ~(1 << PORTID_SC_PGM); DDR_SC_PGM |= (1 << PORTID_SC_PGM); PORT_SC_RST |= (1 << PORTID_SC_RST); DDR_SC_RST |= (1 << PORTID_SC_RST); /* Activate SPI port */ PORT_SPI_NATIVE &= ~((1 << SCK_SPI_NATIVE) | (1 << MOSI_SPI_NATIVE)); DDRB |= (1 << SCK_SPI_NATIVE) | (1 << MOSI_SPI_NATIVE); setSPIModeSMC(); /* Let the card come online */ smallForLoopBasedDelay(); /* Check smart card FZ */ readFabricationZone((uint8_t*)&tempuint16); if ((swap16(tempuint16)) != SMARTCARD_FABRICATION_ZONE) { removeFunctionSMC(); start_bootloader(); } else { removeFunctionSMC(); } } #endif initPortSMC(); // Initialize smart card port initPwm(); // Initialize PWM controller initIRQ(); // Initialize interrupts powerSettlingDelay(); // Let the power settle initUsb(); // Initialize USB controller powerSettlingDelay(); // Let the USB 3.3V LDO rise initI2cPort(); // Initialize I2C interface rngInit(); // Initialize avrentropy library oledInitIOs(); // Initialize OLED input/outputs spiUsartBegin(SPI_RATE_8_MHZ); // Start USART SPI at 8MHz // If offline mode isn't enabled, wait for device to be enumerated if (getMooltipassParameterInEeprom(OFFLINE_MODE_PARAM) == FALSE) { while(!isUsbConfigured()); // Wait for host to set configuration } // Set correct timeout_enabled val mp_timeout_enabled = getMooltipassParameterInEeprom(LOCK_TIMEOUT_ENABLE_PARAM); // Launch the before flash initialization tests #ifdef TESTS_ENABLED beforeFlashInitTests(); #endif // Check if we can initialize the Flash memory flash_init_result = initFlash(); // Launch the after flash initialization tests #ifdef TESTS_ENABLED afterFlashInitTests(); #endif // Set up OLED now that USB is receiving full 500mA. oledBegin(FONT_DEFAULT); // First time initializations for Flash (first time power up at production) if (current_bootkey_val != CORRECT_BOOTKEY) { // Erase everything non graphic in flash eraseFlashUsersContents(); // Erase # of cards and # of users firstTimeUserHandlingInit(); } // Check if we can initialize the touch sensing element touch_init_result = initTouchSensing(); // Enable proximity detection #ifndef HARDWARE_V1 activateProxDetection(); #endif // Launch the after touch initialization tests #ifdef TESTS_ENABLED afterTouchInitTests(); #endif // Test procedure to check that all HW is working #if defined(PRODUCTION_SETUP) || defined(PRODUCTION_KICKSTARTER_SETUP) if (current_bootkey_val != CORRECT_BOOTKEY) { RET_TYPE temp_rettype; // Wait for USB host to upload bundle, which then sets USER_PARAM_INIT_KEY_PARAM //#ifdef PRODUCTION_KICKSTARTER_SETUP while(getMooltipassParameterInEeprom(USER_PARAM_INIT_KEY_PARAM) != 0xF1) { usbProcessIncoming(USB_CALLER_MAIN); } //#endif // Bundle uploaded, start the screen oledBegin(FONT_DEFAULT); oledWriteActiveBuffer(); oledSetXY(0,0); // LEDs ON, to check setPwmDc(MAX_PWM_VAL); switchOnButtonWheelLeds(); guiDisplayRawString(ID_STRING_TEST_LEDS_CH); // Check flash init if (flash_init_result != RETURN_OK) { guiDisplayRawString(ID_STRING_TEST_FLASH_PB); } // Check touch init if (touch_init_result != RETURN_OK) { guiDisplayRawString(ID_STRING_TEST_TOUCH_PB); } // Touch instructions guiDisplayRawString(ID_STRING_TEST_INST_TCH); // Check prox while(!(touchDetectionRoutine(0) & RETURN_PROX_DETECTION)); guiDisplayRawString(ID_STRING_TEST_DET); activateGuardKey(); // Check left while(!(touchDetectionRoutine(0) & RETURN_LEFT_PRESSED)); guiDisplayRawString(ID_STRING_TEST_LEFT); // Check wheel while(!(touchDetectionRoutine(0) & RETURN_WHEEL_PRESSED)); guiDisplayRawString(ID_STRING_TEST_WHEEL); // Check right while(!(touchDetectionRoutine(0) & RETURN_RIGHT_PRESSED)); guiDisplayRawString(ID_STRING_TEST_RIGHT); // Insert card guiDisplayRawString(ID_STRING_TEST_CARD_INS); while(isCardPlugged() != RETURN_JDETECT); temp_rettype = cardDetectedRoutine(); // Check card if (!((temp_rettype == RETURN_MOOLTIPASS_BLANK) || (temp_rettype == RETURN_MOOLTIPASS_USER))) { guiDisplayRawString(ID_STRING_TEST_CARD_PB); } // Display result uint8_t script_return = RETURN_OK; if ((flash_init_result == RETURN_OK) && (touch_init_result == RETURN_OK) && ((temp_rettype == RETURN_MOOLTIPASS_BLANK) || (temp_rettype == RETURN_MOOLTIPASS_USER))) { // Inform script of success usbSendMessage(CMD_FUNCTIONAL_TEST_RES, 1, &script_return); // Wait for password to be set while(eeprom_read_byte((uint8_t*)EEP_BOOT_PWD_SET) != BOOTLOADER_PWDOK_KEY) { usbProcessIncoming(USB_CALLER_MAIN); } // Display test result guiDisplayRawString(ID_STRING_TEST_OK); timerBasedDelayMs(3000); } else { // Set correct bool script_return = RETURN_NOK; // Display test result guiDisplayRawString(ID_STRING_TEST_NOK); // Inform script of failure usbSendMessage(CMD_FUNCTIONAL_TEST_RES, 1, &script_return); while(1) { usbProcessIncoming(USB_CALLER_MAIN); } } } #endif // Stop the Mooltipass if we can't communicate with the flash or the touch interface #if defined(HARDWARE_OLIVIER_V1) #ifdef PRODUCTION_KICKSTARTER_SETUP while ((flash_init_result != RETURN_OK) || (touch_init_result != RETURN_OK) || (fuse_ok != TRUE)); #else while ((flash_init_result != RETURN_OK) || (touch_init_result != RETURN_OK)); #endif #endif // First time initializations done.... write correct value in eeprom if (current_bootkey_val != CORRECT_BOOTKEY) { // Store correct bootkey eeprom_write_word((uint16_t*)EEP_BOOTKEY_ADDR, CORRECT_BOOTKEY); } // Write inactive buffer & go to startup screen oledWriteInactiveBuffer(); guiSetCurrentScreen(SCREEN_DEFAULT_NINSERTED); guiGetBackToCurrentScreen(); // Launch the after HaD logo display tests #ifdef TESTS_ENABLED afterHadLogoDisplayTests(); #endif // Let's fade in the LEDs for (uint16_t i = 0; i < MAX_PWM_VAL; i++) { setPwmDc(i); timerBasedDelayMs(0); } activityDetectedRoutine(); launchCalibrationCycle(); touchClearCurrentDetections(); // Inhibit touch inputs for the first 3 seconds activateTimer(TIMER_TOUCH_INHIBIT, 3000); while (1) { // Process possible incoming USB packets usbProcessIncoming(USB_CALLER_MAIN); // Call GUI routine once the touch input inhibit timer is finished if (hasTimerExpired(TIMER_TOUCH_INHIBIT, FALSE) == TIMER_EXPIRED) { guiMainLoop(); } // Check if a card just got inserted / removed card_detect_ret = isCardPlugged(); // Do appropriate actions on smartcard insertion / removal if (card_detect_ret == RETURN_JDETECT) { // Light up the Mooltipass and call the dedicated function activityDetectedRoutine(); handleSmartcardInserted(); } else if (card_detect_ret == RETURN_JRELEASED) { // Light up the Mooltipass and call the dedicated function activityDetectedRoutine(); handleSmartcardRemoved(); // Set correct screen guiDisplayInformationOnScreen(ID_STRING_CARD_REMOVED); guiSetCurrentScreen(SCREEN_DEFAULT_NINSERTED); userViewDelay(); guiGetBackToCurrentScreen(); } // Two quick caps lock presses wakes up the device if ((hasTimerExpired(TIMER_CAPS, FALSE) == TIMER_EXPIRED) && (getKeyboardLeds() & HID_CAPS_MASK) && (wasCapsLockTimerArmed == FALSE)) { wasCapsLockTimerArmed = TRUE; activateTimer(TIMER_CAPS, CAPS_LOCK_DEL); } else if ((hasTimerExpired(TIMER_CAPS, FALSE) == TIMER_RUNNING) && !(getKeyboardLeds() & HID_CAPS_MASK)) { activityDetectedRoutine(); } else if ((hasTimerExpired(TIMER_CAPS, FALSE) == TIMER_EXPIRED) && !(getKeyboardLeds() & HID_CAPS_MASK)) { wasCapsLockTimerArmed = FALSE; } // If we have a timeout lock if ((mp_timeout_enabled == TRUE) && (hasTimerExpired(SLOW_TIMER_LOCKOUT, TRUE) == TIMER_EXPIRED)) { guiSetCurrentScreen(SCREEN_DEFAULT_INSERTED_LCK); guiGetBackToCurrentScreen(); handleSmartcardRemoved(); } } }
/*! \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 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 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_set = FALSE; uint8_t flash_flag = FALSE; uint8_t flash_sm = 0; // LED animation #ifdef LEDS_ENABLED_MINI miniLedsSetAnimation(ANIM_PULSE_UP_RAMP_DOWN); #endif // Check if we want to flash the screen if ((nb_args & 0xF0) != 0) { flash_flag_set = TRUE; nb_args = nb_args & 0x0F; // Check that the user didn't disable it if (getMooltipassParameterInEeprom(FLASH_SCREEN_PARAM) != FALSE) { flash_flag = TRUE; } } // 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 miniOledClearFrameBuffer(); miniOledSetMaxTextY(SSD1305_OLED_WIDTH-15); miniOledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_APPROVE, 0); // Display lines. // Note: line are truncated at the miniOled driver level when miniOledTextWritingYIncrement is set to FALSE (default) 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(); // Wait for user input RET_TYPE input_answer = MINI_INPUT_RET_NONE; RET_TYPE detect_result; // 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); // Arm timer for flashing activateTimer(TIMER_FLASHING, 500); // Loop while no timeout occurs or no button is pressed while (input_answer == MINI_INPUT_RET_NONE) { // User interaction timeout or smartcard removed if ((hasTimerExpired(TIMER_USERINT, TRUE) == TIMER_EXPIRED) || (isSmartCardAbsent() == RETURN_OK)) { input_answer = MINI_INPUT_RET_TIMEOUT; } // Read usb comms as the plugin could ask to cancel the request if (usbCancelRequestReceived() == RETURN_OK) { input_answer = MINI_INPUT_RET_TIMEOUT; } // Screen flashing logic if ((hasTimerExpired(TIMER_FLASHING, TRUE) == TIMER_EXPIRED) && (flash_flag == TRUE) && (flash_sm < 4)) { // Look at the flash_sm LSb to know what is the display state if ((flash_sm++ & 0x01) != 0x00) { miniOledNormalDisplay(); } else { miniOledInvertedDisplay(); } // Re-arm timer activateTimer(TIMER_FLASHING, 500); } // Check if something has been pressed detect_result = miniGetWheelAction(FALSE, TRUE); if (detect_result == WHEEL_ACTION_SHORT_CLICK) { input_answer = MINI_INPUT_RET_YES; } else if (detect_result == WHEEL_ACTION_LONG_CLICK) { input_answer = MINI_INPUT_RET_BACK; } // Knock to approve #if defined(HARDWARE_MINI_CLICK_V2) if ((scanAndGetDoubleZTap(FALSE) == ACC_RET_KNOCK) && (flash_flag_set != FALSE)) { input_answer = MINI_INPUT_RET_YES; } #else (void)flash_flag_set; #endif // Text scrolling if ((hasTimerExpired(TIMER_CAPS, FALSE) == TIMER_EXPIRED) && (nb_args > 1)) { miniOledClearFrameBuffer(); activateTimer(TIMER_CAPS, SCROLLING_DEL); miniOledSetMaxTextY(SSD1305_OLED_WIDTH-15); if(approve_selected == FALSE) { miniOledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_DENY, 0); } else { miniOledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_APPROVE, 0); } 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) { miniOledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_APPROVE, 0); } else { miniOledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_DENY, 0); } approve_selected = !approve_selected; miniOledFlushEntireBufferToDisplay(); } } // In case display was inverted, set it normally miniOledNormalDisplay(); if ((input_answer == MINI_INPUT_RET_YES) && (approve_selected != FALSE)) { // LED animation #ifdef LEDS_ENABLED_MINI miniLedsSetAnimation(ANIM_NONE); #endif return RETURN_OK; } else if (input_answer == MINI_INPUT_RET_BACK) { // LED animation #ifdef LEDS_ENABLED_MINI miniLedsSetAnimation(ANIM_NONE); #endif return RETURN_BACK; } else { // LED animation #ifdef LEDS_ENABLED_MINI miniLedsSetAnimation(ANIM_NONE); #endif return RETURN_NOK; } }