/** @brief Function starting the internal LFCLK XTAL oscillator. */ static void lfclk_config(void) { ret_code_t err_code = nrf_drv_clock_init(); APP_ERROR_CHECK(err_code); nrf_drv_clock_lfclk_request(NULL); }
int main(void) { uint32_t err_code; uint32_t time0, time1; LOG("Starting LFCLK"); err_code = nrf_drv_clock_init(); APP_ERROR_CHECK(err_code); nrf_drv_clock_lfclk_request(NULL); LOG("Starting RTC"); err_code = nrf_drv_rtc_init(&rtc, NULL, &rtc_handler); APP_ERROR_CHECK(err_code); nrf_drv_rtc_tick_enable(&rtc, false); nrf_drv_rtc_enable(&rtc); LOG("Starting RNG"); err_code = nrf_drv_rng_init(NULL); APP_ERROR_CHECK(err_code); while (1) { /* get a random key */ time0 = nrf_drv_rtc_counter_get(&rtc); uECC_make_key(public_key, private_key); time1 = nrf_drv_rtc_counter_get(&rtc); LOG("Key time was %u ", time1 - time0); /* use the key to sign the hash */ time0 = nrf_drv_rtc_counter_get(&rtc); uECC_sign(private_key, hash, signature); time1 = nrf_drv_rtc_counter_get(&rtc); LOG("Sig Time was %u ", time1 - time0); /* verify the signature */ time0 = nrf_drv_rtc_counter_get(&rtc); uECC_verify(public_key, hash, signature); time1 = nrf_drv_rtc_counter_get(&rtc); LOG("Verify Time was %u ", time1 - time0); time0 = nrf_drv_rtc_counter_get(&rtc); uECC_shared_secret(public_key, private_key, secret); time1 = nrf_drv_rtc_counter_get(&rtc); LOG("SS Time was %u ", time1 - time0); time0 = nrf_drv_rtc_counter_get(&rtc); sha256_init(&context); sha256_update(&context, message, 20); sha256_final(&context, shahash); time1 = nrf_drv_rtc_counter_get(&rtc); LOG("SHA Time was %u ", time1 - time0); } return 0; }
int main(void) { ret_code_t err_code; /* Initialize clock driver for better time accuracy in FREERTOS */ err_code = nrf_drv_clock_init(); APP_ERROR_CHECK(err_code); /* Configure LED-pins as outputs */ LEDS_CONFIGURE(LEDS_MASK); LEDS_OFF(LEDS_MASK); /* Create task for LED0 blinking with priority set to 2 */ UNUSED_VARIABLE(xTaskCreate(led_toggle_task_function, "LED0", configMINIMAL_STACK_SIZE + 200, NULL, 2, &led_toggle_task_handle)); /* Start timer for LED1 blinking */ led_toggle_timer_handle = xTimerCreate( "LED1", TIMER_PERIOD, pdTRUE, NULL, led_toggle_timer_callback); UNUSED_VARIABLE(xTimerStart(led_toggle_timer_handle, 0)); /* Activate deep sleep mode */ SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; /* Start FreeRTOS scheduler. */ vTaskStartScheduler(); while (true) { /* FreeRTOS should not be here... FreeRTOS goes back to the start of stack * in vTaskStartScheduler function. */ } }
int main(void) { TaskHandle_t xLed0Handle; /**< Reference to LED0 toggling FreeRTOS task. */ TimerHandle_t xLed1Handle; /**< Reference to LED1 toggling FreeRTOS timer. */ ret_code_t err_code; err_code = nrf_drv_clock_init(NULL); APP_ERROR_CHECK(err_code); // Configure LED-pins as outputs nrf_gpio_cfg_output(BSP_LED_0); nrf_gpio_cfg_output(BSP_LED_1); nrf_gpio_cfg_output(BSP_LED_2); nrf_gpio_cfg_output(BSP_LED_3); nrf_gpio_pin_set(BSP_LED_0); nrf_gpio_pin_set(BSP_LED_1); nrf_gpio_pin_set(BSP_LED_2); nrf_gpio_pin_set(BSP_LED_3); UNUSED_VARIABLE(xTaskCreate( vLed0Function, "L0", configMINIMAL_STACK_SIZE + 200, NULL, 2, &xLed0Handle )); // LED0 task creation xLed1Handle = xTimerCreate( "L1", TIMER_PERIOD, pdTRUE, NULL, vLed1Callback ); // LED1 timer creation UNUSED_VARIABLE(xTimerStart( xLed1Handle, 0 )); // LED1 timer start /* Activate deep sleep mode */ SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; // Start FreeRTOS scheduler. vTaskStartScheduler(); while (true) { // FreeRTOS should not be here... } }
static void clock_init(void) { uint32_t err_code; err_code = nrf_drv_clock_init(); APP_ERROR_CHECK(err_code); nrf_drv_clock_lfclk_request(NULL); }
/**@brief Ladybug_Flash uses an app timer. App timers require the low frequency clock to be ticking. * Initialize the timer module. * \callgraph */ static void timers_init(void){ // Initialize the low frequency clock. uint32_t err_code = nrf_drv_clock_init(NULL); APP_ERROR_CHECK(err_code); nrf_drv_clock_lfclk_request(); // Initialize the timer queue. APP_TIMER_INIT(m_app_timer_prescaler, APP_TIMER_MAX_TIMERS, APP_TIMER_OP_QUEUE_SIZE, false); }
void nrf_drv_clock_on_sd_enable(void) { CRITICAL_REGION_ENTER(); /* Make sure that nrf_drv_clock module is initialized */ if (!m_clock_cb.module_initialized) { (void)nrf_drv_clock_init(); } /* SD is one of the LFCLK requesters, but it will enable it by itself. */ ++(m_clock_cb.lfclk_requests); m_clock_cb.lfclk_on = true; CRITICAL_REGION_EXIT(); }
/** * @brief Function for starting the internal LFCLK XTAL oscillator. * * Note that when using a SoftDevice, LFCLK is always on. * * @return Values returned by @ref nrf_drv_clock_init. */ static ret_code_t clock_config(void) { ret_code_t err_code; err_code = nrf_drv_clock_init(); if (err_code != NRF_SUCCESS) { return err_code; } nrf_drv_clock_lfclk_request(NULL); return NRF_SUCCESS; }
/** * @brief Function for application main entry. */ int main(void) { uint32_t err_code; err_code = nrf_drv_clock_init(); APP_ERROR_CHECK(err_code); setup_example(); while (true) { nrf_delay_ms(1000); nrf_drv_clock_lfclk_request(NULL); nrf_delay_ms(1000); nrf_drv_clock_lfclk_release(); } }
/**@brief Function for application main entry. */ int main(void) { ret_code_t err_code; err_code = nrf_drv_clock_init(); APP_ERROR_CHECK(err_code); // Do not start any interrupt that uses system functions before system initialisation. // The best solution is to start the OS before any other initalisation. // Init a semaphore for the BLE thread. m_ble_event_ready = xSemaphoreCreateBinary(); if (NULL == m_ble_event_ready) { APP_ERROR_HANDLER(NRF_ERROR_NO_MEM); } err_code = NRF_LOG_INIT(NULL); APP_ERROR_CHECK(err_code); // Start execution. if (pdPASS != xTaskCreate(ble_stack_thread, "BLE", 256, NULL, 2, &m_ble_stack_thread)) { APP_ERROR_HANDLER(NRF_ERROR_NO_MEM); } #if NRF_LOG_ENABLED // Start execution. if (pdPASS != xTaskCreate(logger_thread, "LOGGER", 256, NULL, 1, &m_logger_thread)) { APP_ERROR_HANDLER(NRF_ERROR_NO_MEM); } #endif //NRF_LOG_ENABLED /* Activate deep sleep mode */ SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; // Start FreeRTOS scheduler. vTaskStartScheduler(); while (true) { APP_ERROR_HANDLER(NRF_ERROR_FORBIDDEN); } }
void soc_init(void) { ret_code_t err_code; /* Initialize clock driver for better time accuracy in FREERTOS */ err_code = nrf_drv_clock_init(); APP_ERROR_CHECK(err_code); nrf_drv_clock_lfclk_request(NULL); app_timer_init(); /* Configure LED-pins as outputs */ bsp_board_leds_init(); /* Init systick driver */ nrf_drv_systick_init(); /* Activate deep sleep mode */ // SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; }
/** * @brief Function for main application entry. */ int main(void) { uint32_t err_code = NRF_SUCCESS; //BSP configuration for button support: button pushing will feed the dog. err_code = nrf_drv_clock_init(NULL); APP_ERROR_CHECK(err_code); nrf_drv_clock_lfclk_request(); APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_MAX_TIMERS, APP_TIMER_OP_QUEUE_SIZE, false); err_code = bsp_init(BSP_INIT_BUTTONS, APP_TIMER_TICKS(100, APP_TIMER_PRESCALER), bsp_event_callback); APP_ERROR_CHECK(err_code); //Configure all LEDs on board. LEDS_CONFIGURE(LEDS_MASK); LEDS_OFF(LEDS_MASK); //Indicate program start on LEDs. for(uint32_t i = 0; i < LEDS_NUMBER; i++) { nrf_delay_ms(200); LEDS_ON(BSP_LED_0_MASK << i); } err_code = bsp_buttons_enable(); APP_ERROR_CHECK(err_code); //Configure WDT. nrf_drv_wdt_config_t config = NRF_DRV_WDT_DEAFULT_CONFIG; err_code = nrf_drv_wdt_init(&config, wdt_event_handler); APP_ERROR_CHECK(err_code); err_code = nrf_drv_wdt_channel_alloc(&m_channel_id); APP_ERROR_CHECK(err_code); nrf_drv_wdt_enable(); while(1) { __SEV(); __WFE(); __WFE(); } }
int os_tick_init(void) { uint32_t err_code; // Initialize the clock err_code = nrf_drv_clock_init(NULL); assert(err_code == NRF_SUCCESS); nrf_drv_clock_lfclk_request(); // Initialize RTC instance err_code = nrf_drv_rtc_init(&rtc1, NULL, NULL); assert(err_code == NRF_SUCCESS); // Enable tick event & interrupt nrf_drv_rtc_tick_enable(&rtc1, true); // Enable overflow nrf_drv_rtc_overflow_enable(&rtc1, false); // Power on RTC instance nrf_drv_rtc_enable(&rtc1); // Return -1 to prevent RTC touching NVIC return -1; /* Return IRQ number of timer (0..239) */ }
/*====================================================================================================*/ void NRF51_CKOCK_Config( void ) { nrf_drv_clock_init(); }
static void lfclk_config(void) { ret_code_t err_code = nrf_drv_clock_init(); //Initialize the clock source specified in the nrf_drv_config.h file, i.e. the CLOCK_CONFIG_LF_SRC constant APP_ERROR_CHECK(err_code); nrf_drv_clock_lfclk_request(NULL); }
/*====================================================================================================*/ void Clock_Config( void ) { nrf_drv_clock_init(); }
/** @brief Function for main application entry. */ int main(void) { TaskHandle_t compress_task_handle; TimerHandle_t spi_timer_handle; uint32_t err_code; err_code = nrf_drv_clock_init(); APP_ERROR_CHECK(err_code); // Setup bsp module. //bsp_configuration(); //uart initialization const app_uart_comm_params_t comm_params = { RX_PIN_NUMBER, TX_PIN_NUMBER, RTS_PIN_NUMBER, CTS_PIN_NUMBER, APP_UART_FLOW_CONTROL_ENABLED, false, UART_BAUDRATE_BAUDRATE_Baud38400 }; APP_UART_FIFO_INIT(&comm_params, UART_RX_BUF_SIZE, UART_TX_BUF_SIZE, uart_error_handle, APP_IRQ_PRIORITY_LOW, err_code); APP_ERROR_CHECK(err_code); //nrf_drv_gpiote_out_config_t config = GPIOTE_CONFIG_OUT_TASK_HIGH; //config.init_state = true; //err_code = nrf_drv_gpiote_out_init(20, &config); //while(app_uart_put(65) != NRF_SUCCESS); //printf("1 ms = %d\n", pdMS_TO_TICKS(1)); intan_setup(); //while(app_uart_put(65) != NRF_SUCCESS); compression_init(); uesb_config_t uesb_config = UESB_DEFAULT_CONFIG; uesb_config.event_handler = uesb_event_handler; if (uesb_init(&uesb_config)!= UESB_SUCCESS) { printf("ESB init messed up\r\n"); } tx_payload.length = UESB_CORE_MAX_PAYLOAD_LENGTH; tx_payload.pipe = 0; while(app_uart_put(66) != NRF_SUCCESS); //printf("yo\n"); UNUSED_VARIABLE(xTaskCreate(compress_task, "c_task", configMINIMAL_STACK_SIZE + 200, NULL, 1, &compress_task_handle)); if(compress_task_handle == NULL) { printf("compression task init messed up\r\n"); } while(app_uart_put(67) != NRF_SUCCESS); //Test read intan company ID timer //spi_timer_handle = xTimerCreate("s_timer", 1, pdTRUE, NULL, spi_intan_id_handler); // Sample timer spi_timer_handle = xTimerCreate("s_timer", 1, pdTRUE, NULL, spi_data_collection_evt_handler); // LED1 timer creation if(spi_timer_handle == NULL) { printf("SPI timer init messed up\r\n"); } while(app_uart_put(68) != NRF_SUCCESS); if(xTimerStart(spi_timer_handle, 0) != pdPASS) { printf("Timer could not be started\r\n"); } while(app_uart_put(69) != NRF_SUCCESS); /* Activate deep sleep mode */ SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; // Start FreeRTOS scheduler. vTaskStartScheduler(); //timers_init(); //while(app_uart_put(67) != NRF_SUCCESS); //data_collection_timers_start(); //while(app_uart_put(68) != NRF_SUCCESS); for (;;) { printf("Messed up\r\n"); //power_manage(); /*if (m_transfer_completed) { //while(app_uart_put(72) != NRF_SUCCESS); m_transfer_completed = false; intan_convert(m_tx_data_spi, m_rx_data_spi,intan_convert_channel); //while(app_uart_put(73) != NRF_SUCCESS); intan_convert_channel ++; intan_convert_channel = intan_convert_channel % 32; //print m_rx_data_spi results switch_state(); //while(app_uart_put(74) != NRF_SUCCESS); //for (int i; i< RX_MSG_LENGTH; i++){ // while(app_uart_put(m_rx_data_spi[i]) != NRF_SUCCESS); //} nrf_delay_ms(DELAY_MS); //while(app_uart_put(75) != NRF_SUCCESS); }*/ //while(app_uart_put(76) != NRF_SUCCESS); } }