/*====================================================================================================*/ int main( void ) { u8 i = 0; GPIO_Config(); TIMER_Config(); nrf_gpio_pin_set(LED_0); nrf_gpio_pin_clear(LED_1); while(1) { // nrf_gpio_pin_toggle(LED_0); nrf_gpio_pin_toggle(LED_1); for(i = 0; i<7; i++) { LED_PORT = ~(0x01<<i); Delay_1ms(DELAY_TIME); } // nrf_gpio_pin_toggle(LED_0); nrf_gpio_pin_toggle(LED_1); for(i = 7; i>0; i--) { LED_PORT = ~(0x01<<i); Delay_1ms(DELAY_TIME); } } }
static void termdev_priv_btnPress(void *bD, BTNS_EventType evType) { dbg_debugModule("BTNPress\n"); start_waiting_for_edge(); nrf_gpio_pin_set(12); nrf_gpio_pin_toggle(TRIGGER_GPIO_PIN_NO); nrf_gpio_pin_toggle(LED_GPIO_NO); }
/** @brief: Function for handling the RTC0 interrupts. * Triggered on TICK and COMPARE0 match. */ static void rtc_handler(nrf_drv_rtc_int_type_t int_type) { if (int_type == NRF_DRV_RTC_INT_COMPARE0) { nrf_gpio_pin_toggle(COMPARE_EVENT_OUTPUT); } else if (int_type == NRF_DRV_RTC_INT_TICK) { nrf_gpio_pin_toggle(TICK_EVENT_OUTPUT); } }
/*====================================================================================================*/ int main( void ) { uint8_t Count = 0; uint8_t State = 0; GPIO_Config(); SF595_Config(); SF595_Init(); while(1) { nrf_gpio_pin_toggle(LED_1); nrf_gpio_pin_toggle(LED_2); Delay_10ms(10); Count++; switch(State) { case 0: if (Count == 8) { SF595_Shift(0); State = 1; } else { SF595_Shift(0); } break; case 1: if (Count == 16) { SF595_Shift(1); State = 2; } else { SF595_Shift(1); } break; case 2: for(; State>0; State--) { SF595_SendByte(0x00); Delay_100ms(2); SF595_SendByte(0xFF); Delay_100ms(2); } Count = 0; break; } } }
/** * main function * \return 0. int return type required by ANSI/ISO standard. */ int main(void) { int i; gpio_init(); gpiote_init(); wdt_init(); //Write the value of RESETREAS to pins 9-15 (LEDs 1-7) nrf_gpio_pin_write(LED_1, NRF_POWER->RESETREAS & POWER_RESETREAS_RESETPIN_Msk); //Bit A in RESETREAS nrf_gpio_pin_write(LED_2, NRF_POWER->RESETREAS & POWER_RESETREAS_DOG_Msk); //Bit B in RESETREAS nrf_gpio_pin_write(LED_3, NRF_POWER->RESETREAS & POWER_RESETREAS_SREQ_Msk); //Bit C in RESETREAS nrf_gpio_pin_write(LED_4, NRF_POWER->RESETREAS & POWER_RESETREAS_LOCKUP_Msk); //Bit D in RESETREAS nrf_gpio_pin_write(LED_5, NRF_POWER->RESETREAS & POWER_RESETREAS_OFF_Msk); //Bit E in RESETREAS nrf_gpio_pin_write(LED_6, NRF_POWER->RESETREAS & POWER_RESETREAS_LPCOMP_Msk); //Bit F in RESETREAS nrf_gpio_pin_write(LED_7, NRF_POWER->RESETREAS & POWER_RESETREAS_DIF_Msk); //Bit G in RESETREAS NRF_POWER->RESETREAS = 0xFFFFFFFF; //Clear the RESETREAS register for(i=0;i<STARTUP_TOGGLE_ITERATIONS;i++) { nrf_gpio_pin_toggle(LED_0); nrf_delay_us(DELAY); } while (true) { //Blink LED 0 fast until watchdog triggers reset nrf_gpio_pin_toggle(LED_0); nrf_delay_us(DELAY/3); // If SYSTEM_OFF_BUTTON is pressed.. enter System Off mode if(nrf_gpio_pin_read(SYSTEM_OFF_BUTTON) == BTN_PRESSED) { // Clear PORT 1 (pins 8-15) nrf_gpio_port_clear(NRF_GPIO_PORT_SELECT_PORT1, 0xFF); // Enter system OFF. After wakeup the chip will be reset, and the program will run from the top NRF_POWER->SYSTEMOFF = 1; } // If SOFTWARE_RESET_BUTTON is pressed.. soft-reset if(nrf_gpio_pin_read(SOFTWARE_RESET_BUTTON) == BTN_PRESSED) { NVIC_SystemReset(); } } }
/**@brief Timeout handler that is responsible for toggling the Advertisement LED. * * @details This function will be called each time the timer that was started for the sake of * blinking the Advertisement LED expires. This function toggle the state of the * Advertisement LED. * * @param[in] p_context Pointer used for passing some arbitrary information (context) from the * app_start_timer() call to the timeout handler. */ static void adv_led_blink_timeout_handler(void * p_context) { if (m_is_adv_led_blinking) { bool * p_is_led_on; uint32_t next_timer_interval; uint32_t err_code; APP_ERROR_CHECK_BOOL(p_context != NULL); nrf_gpio_pin_toggle(ADVERTISING_LED_PIN_NO); p_is_led_on = (bool *)(p_context); *p_is_led_on = !(*p_is_led_on); if(*p_is_led_on ) { // The toggle operation above would have resulted in an ON state. So start a timer that // will expire after ADV_LED_ON_TIME. next_timer_interval = ADV_LED_ON_TIME; } else { // The toggle operation above would have resulted in an OFF state. So start a timer that // will expire after ADV_LED_OFF_TIME. next_timer_interval = ADV_LED_OFF_TIME; } err_code = app_timer_start(m_adv_led_blink_timer_id, next_timer_interval, p_is_led_on ); APP_ERROR_CHECK(err_code); } }
bool PingModule::TerminalCommandHandler(string commandName, vector<string> commandArgs) { if(commandArgs.size() >= 2 && commandArgs[1] == moduleName) { //React on commands, return true if handled, false otherwise if(commandName == "pingmod"){ //Get the id of the target node nodeID targetNodeId = atoi(commandArgs[0].c_str()); logt("PINGMOD", "Trying to ping node %u", targetNodeId); nrf_gpio_pin_toggle(18); //Send ping packet to that node connPacketModuleAction packet; packet.header.messageType = MESSAGE_TYPE_MODULE_TRIGGER_ACTION; packet.header.sender = node->persistentConfig.nodeId; packet.header.receiver = targetNodeId; packet.moduleId = moduleId; packet.actionType = PingModuleTriggerActionMessages::TRIGGER_PING; packet.data[0] = 123; cm->SendMessageToReceiver(NULL, (u8*)&packet, SIZEOF_CONN_PACKET_MODULE_ACTION + 1, true); return true; } } //Must be called to allow the module to get and set the config return Module::TerminalCommandHandler(commandName, commandArgs); }
/**@brief Timer callback used for periodic changing of LED state. */ static void iot_timer_client_four_callback(iot_timer_time_in_ms_t elapsed_time) { UNUSED_PARAMETER(elapsed_time); LEDS_INVERT(DISPLAY_LED_3); nrf_gpio_pin_toggle(13); printf("------------------------- %4d ms\r\n", IOT_TIMER_CLIENT_FOUR_CB_INTERVAL); }
/**@brief Function for application main entry. Does not return. */ int main(void) { bool is_test_success; // Configure all LEDs as outputs. nrf_gpio_range_cfg_output(LED_START, LED_STOP); // Set LED_0 high to indicate that the application is running. nrf_gpio_pin_set(LED_0); for (;;) { is_test_success = test_spi_tx_rx(); if (!is_test_success) { // Set LED2 high to indicate that error has occurred. nrf_gpio_pin_set(LED_2); for (;;) { // No implementation needed. } } nrf_gpio_pin_toggle(LED_1); nrf_delay_ms(DELAY_MS); } }
/** * @brief Function for main application entry. */ int main(void) { ret_code_t ret_code; nrf_gpio_cfg_output(LED_1); nrf_gpio_pin_set(LED_1); nrf_gpio_cfg_output(LED_2); nrf_gpio_pin_set(LED_2); uart_config(); printf("\033[2J\033[;H\r\n* Example to find TWI devices connected to \r\n* the TWI bus and their addresses\r\n\r\n"); twi_init(); uint8_t dummy_data = 0x55; // Itterate through all possible 7-bit TWI addresses for(uint8_t i = 0; i <= 0x7F; i++) { device_address = i; // Send dummy data. If a device is present on this particular address a TWI EVT_DONE event is // received in the twi event handler and a message is printed to UART ret_code = nrf_drv_twi_tx(&twi_instance, i, &dummy_data, 1, false); APP_ERROR_CHECK(ret_code); // Delay 10 ms to allow TWI transfer to complete and UART to print messages before starting new transfer nrf_delay_ms(10); } if(device_found) { // Blinke LED_1 rapidly if device is found while(true) { nrf_gpio_pin_toggle(LED_1); nrf_delay_ms(1000); } } else { // Disable LED_1 if device is NOT found nrf_gpio_cfg_default(LED_1); printf("*****************\n\rNO DEVICES FOUND!\r\n*****************\n\r"); while(true) { nrf_gpio_pin_toggle(LED_2); nrf_delay_ms(100);; } } }
/** @brief Function for handling the GPIOTE interrupt which is triggered on pin 0 change. */ void GPIOTE_IRQHandler(void) { // Event causing the interrupt must be cleared. if ((NRF_GPIOTE->EVENTS_IN[0] == 1) && (NRF_GPIOTE->INTENSET & GPIOTE_INTENSET_IN0_Msk)) { NRF_GPIOTE->EVENTS_IN[0] = 0; } nrf_gpio_pin_toggle(8); }
int main(void) { // Configure green LED-pin as output nrf_gpio_cfg_output(BLE_DEV_BOARD_LED_GREEN); while(true) { nrf_gpio_pin_toggle(BLE_DEV_BOARD_LED_GREEN); nrf_delay_ms(100); } }
/**@brief LED0 task entry function. * * @param[in] pvParameter Pointer that will be used as the parameter for the task. */ static void vLed0Function (void *pvParameter) { UNUSED_PARAMETER(pvParameter); for( ;; ) { nrf_gpio_pin_toggle(BSP_LED_0); vTaskDelay(TASK_DELAY); // Delay a task for a given number of ticks // Tasks must be implemented to never return... } }
/** * @brief Function for main application entry. */ int main(void) { // Configure pins 8 to 15 as outputs. nrf_gpio_cfg_output(GPIO_TOGGLE_PIN); while (true) { nrf_gpio_pin_toggle(GPIO_TOGGLE_PIN); // use Timer 0 peripheral to generate 100 ms delay. nrf_timer_delay_ms(TIMER0, TIMER_DELAY_MS); nrf_gpio_pin_toggle(GPIO_TOGGLE_PIN); // use Timer 1 peripheral to generate 100 ms delay. nrf_timer_delay_ms(TIMER1, TIMER_DELAY_MS); nrf_gpio_pin_toggle(GPIO_TOGGLE_PIN); // use Timer 2 peripheral to generate 100 ms delay. nrf_timer_delay_ms(TIMER2, TIMER_DELAY_MS); } }
/** GPIOTE interrupt handler. * Triggered on WATCHDOG_RELOAD_BUTTON change */ void GPIOTE_IRQHandler(void) { // Event causing the interrupt must be cleared if ((NRF_GPIOTE->EVENTS_IN[0] == 1) && (NRF_GPIOTE->INTENSET & GPIOTE_INTENSET_IN0_Msk)) { NRF_GPIOTE->EVENTS_IN[0] = 0; NRF_WDT->RR[0] = WATCHDOG_RELOAD_CONSTANT; nrf_gpio_pin_toggle(LED_0); } }
/** RTC0 interrupt handler. * Triggered on TICK and COMPARE0 match. */ void RTC0_IRQHandler() { if ((NRF_RTC0->EVENTS_TICK != 0) && ((NRF_RTC0->INTENSET & RTC_INTENSET_TICK_Msk) != 0)) { NRF_RTC0->EVENTS_TICK = 0; nrf_gpio_pin_toggle(GPIO_TOGGLE_TICK_EVENT); } if ((NRF_RTC0->EVENTS_COMPARE[0] != 0) && ((NRF_RTC0->INTENSET & RTC_INTENSET_COMPARE0_Msk) != 0)) { NRF_RTC0->EVENTS_COMPARE[0] = 0; nrf_gpio_pin_write(GPIO_TOGGLE_COMPARE_EVENT, 1); } }
/* * Handler to be called when button is pushed. * param[in] pin_no The pin number where the event is genereated * param[in] button_action Is the button pushed or released */ static void button_handler(uint8_t pin_no, uint8_t button_action) { if(button_action == APP_BUTTON_PUSH) { switch(pin_no) { case BUTTON_1: nrf_gpio_pin_toggle(LED_1); break; case BUTTON_2: nrf_gpio_pin_toggle(LED_2); break; case BUTTON_3: nrf_gpio_pin_toggle(LED_3); break; case BUTTON_4: nrf_gpio_pin_toggle(LED_4); break; default: break; } } }
void PingModule::ConnectionPacketReceivedEventHandler(connectionPacket* inPacket, Connection* connection, connPacketHeader* packetHeader, u16 dataLength) { //Must call superclass for handling Module::ConnectionPacketReceivedEventHandler(inPacket, connection, packetHeader, dataLength); //Filter trigger_action messages if(packetHeader->messageType == MESSAGE_TYPE_MODULE_TRIGGER_ACTION){ connPacketModuleAction* packet = (connPacketModuleAction*)packetHeader; //Check if our module is meant and we should trigger an action if(packet->moduleId == moduleId){ //It's a ping message if(packet->actionType == PingModuleTriggerActionMessages::TRIGGER_PING){ nrf_gpio_pin_toggle(18); //Inform the user logt("PINGMOD", "Ping request received with data: %d", packet->data[0]); //Send PING_RESPONSE connPacketModuleAction outPacket; outPacket.header.messageType = MESSAGE_TYPE_MODULE_ACTION_RESPONSE; outPacket.header.sender = node->persistentConfig.nodeId; outPacket.header.receiver = packetHeader->sender; outPacket.moduleId = moduleId; outPacket.actionType = PingModuleActionResponseMessages::PING_RESPONSE; outPacket.data[0] = packet->data[0]; outPacket.data[1] = 111; cm->SendMessageToReceiver(NULL, (u8*)&outPacket, SIZEOF_CONN_PACKET_MODULE_ACTION + 2, true); } } } //Parse Module action_response messages if(packetHeader->messageType == MESSAGE_TYPE_MODULE_ACTION_RESPONSE){ connPacketModuleAction* packet = (connPacketModuleAction*)packetHeader; //Check if our module is meant and we should trigger an action if(packet->moduleId == moduleId) { //Somebody reported its connections back if(packet->actionType == PingModuleActionResponseMessages::PING_RESPONSE){ logt("PINGMOD", "Ping came back from %u with data %d, %d", packet->header.sender, packet->data[0], packet->data[1]); } } } }
/** * @brief Function for application main entry. */ int main(void) { gpio_init(); interrupt_init(); LTC2492_Init(); nrf_gpio_pin_set(LED_1); simple_uart_config(RTS_PIN_NUMBER, TX_PIN_NUMBER, CTS_PIN_NUMBER, RX_PIN_NUMBER, HWFC); int size = 128; double storage[128]; memset(storage, 0, sizeof(*storage) * size); //double * storage = malloc(sizeof(*storage) * size ); int i = 0; while (true) { nrf_delay_ms(150); nrf_gpio_pin_toggle(LED_1); uint32_t output = SPI0_LTC2492_Read(); uint8_t chuncks_8bit[4]; chuncks_8bit[0] = (output & 0xFF000000) >> 24; ; chuncks_8bit[1] = (output & 0x00FF0000) >> 16; chuncks_8bit[2] = (output & 0x0000FF00) >> 8; chuncks_8bit[3] = (output & 0x000000FF) >> 0; int count; for (count = 0; count < 4; count++) { simple_uart_put(chuncks_8bit[count]); } storage[i] = output; i++; if (i == 128) { i = 0; } } }
static void rtc1_handler(nrf_drv_rtc_int_type_t int_type) { // uint32_t err_code; if (int_type == NRF_DRV_RTC_INT_COMPARE0) { // Interrupt from COMPARE0 event. nrf_gpio_pin_set(led_pin1); nrf_drv_rtc_int_enable(&rtc1, RTC_CHANNEL_INT_MASK(0)); } else if (int_type == NRF_DRV_RTC_INT_COMPARE1) { // Interrupt from COMPARE1 event. nrf_gpio_pin_clear(led_pin1); nrf_drv_rtc_int_enable(&rtc1, RTC_CHANNEL_INT_MASK(1)); } else if (int_type == NRF_DRV_RTC_INT_COMPARE2) { // Interrupt from COMPARE2 event. nrf_drv_rtc_counter_clear(&rtc1); nrf_drv_rtc_int_enable(&rtc1, RTC_CHANNEL_INT_MASK(2)); } else if (int_type == NRF_DRV_RTC_INT_TICK) { // Tick off nrf_gpio_pin_toggle(led_pin1); } }
static void rtc1_handler(nrf_drv_rtc_int_type_t int_type) { // uint32_t err_code; NRF_LOG_DEBUG("rtc1_handler %d %u\n\r",int_type,pos); if (int_type == NRF_DRV_RTC_INT_COMPARE0) { // Interrupt from COMPARE0 event. uint16_t temp; nrf_gpio_pin_toggle(led_pin1); if (pos%2==0) { max6675_prepare(&max6675_config); } else { temp=max6675_readcelsius(&max6675_config); NRF_LOG_INFO("rtc1_handler temp \x1B[1;32m%u\x1B[0m,\x1B[1;31m%d\x1B[0m \r",temp>>2,(temp&0x0003)*25); } nrf_drv_rtc_int_enable(&rtc1, RTC_CHANNEL_INT_MASK(0)); nrf_drv_rtc_counter_clear(&rtc1); }
static void inline display_toggle_COM() { // check if VCOM Inversion is inhibited by display write if( !VCOM_inhibit ) { // raise DISP_CS // nrf_gpio_pin_set( PIN_DISP_CS ); // raise EXTCOMIN // nrf_gpio_pin_set( PIN_VCOM ); // wait 2 us // nrf_delay_us( 2 ); // lower EXTCOMIN // lower CS // nrf_gpio_pin_clear( PIN_VCOM ); // nrf_gpio_pin_clear( PIN_DISP_CS ); nrf_gpio_pin_toggle( PIN_VCOM ); } }
/** * @brief Function for application main entry. */ int main(void) { uint8_t pos=0; // setup // Configure LED-pin as outputs and clear. for (pos=0;pos<LEDPINS;pos++) { nrf_gpio_cfg_output(led_pin[pos]); nrf_gpio_pin_clear(led_pin[pos]); } // loop // Toggle LED. pos=0; while (true) { nrf_gpio_pin_toggle(led_pin[pos]); nrf_delay_ms(1000); pos++; if (pos>=LEDPINS) { pos=0; } } }
static void read_all(void) { // Signal on LED that something is going on. nrf_gpio_pin_toggle(READ_ALL_INDICATOR); // [these structures have to be "static" - they cannot be placed on stack // since the transaction is scheduled and these structures most likely // will be referred after this function returns] static app_twi_transfer_t const transfers[] = { LM75B_READ_TEMP(&m_buffer[0]) , MMA7660_READ_XYZ_AND_TILT(&m_buffer[2]) }; static app_twi_transaction_t const transaction = { .callback = read_all_cb, .p_user_data = NULL, .p_transfers = transfers, .number_of_transfers = sizeof(transfers) / sizeof(transfers[0]) }; APP_ERROR_CHECK(app_twi_schedule(&m_app_twi, &transaction)); } static void print_data(char const * name, uint8_t const * p_buffer, uint8_t length) { printf("\r\n%s", name); do { printf(" %02X", *p_buffer++); } while (--length); printf("\r\n\r\n"); }
void LED2_Toggle(void) { nrf_gpio_pin_toggle(LED_1); }
void led_toggle(board_led_obj_t * led_obj) { nrf_gpio_pin_toggle(led_obj->hw_pin); }
/** * @brief Timer routine for fall & step detection. */ void process_step_count(void * p_context) { //timer_stop(m_app_timer_id); reset_wdt(); nrf_gpio_pin_toggle(LED_RESETTING); if (NRF_NVMC->READY == NVMC_READY_READY_Busy) { // Do not interfere if flash write is ongoing. return; } if (SaveSnapshot == 1) { nrf_gpio_pin_set(LED_RESETTING); return; } if (ReadBigSnapshot == 1) return; // store snapshot readSensorsAndStore(); //process activity levels updateAverages(); curr_sv = latestResultant(); if (BLESessionActive == 1) return; if (curr_sv < getPerso()->freefall_threshold) { zero_g_detected = true; } // if ( checkOrientation() == ORIENTATION_STANDING){ // if (curr_sv < getPerso()->freefall_threshold){ // zero_g_detected = true; // } // } // else if (checkOrientation() == ORIENTATION_NOT_STANDING) // { // if (curr_sv < NOT_STANDING_FREEFALL_THRESHOLD_DEFAULT){ // zero_g_detected = true; // } // } else { zero_g_detected = false; } //zero_g_detected = fd_check_zero_g(); if (zero_g_detected == true) { nrf_gpio_pin_write(LED_OTHER,1); // if (count == 0) accel_get_angles(&xAngleBeforeImpact, &yAngleBeforeImpact); count = getPerso()->fall_detection_window; } if (count > 0) { count--; fall_detected = fd_check_for_impact(curr_sv); if (fall_detected == 0xFF) { accel_get_angles(&xAngleAfterImpact, &yAngleAfterImpact); // if (abs(xAngleAfterImpact - xAngleBeforeImpact) >= getPerso()->x_angle_threshold && // abs(yAngleAfterImpact - yAngleBeforeImpact) >= getPerso()->y_angle_threshold) { ClearDataBuffer = ClearSnapshots = SetTimestamp = 0; // backupRawData(); do_post_processing = true; emergencyCall = 1; zero_g_detected = false; fall_detected = 0; count = 0; } } } if (count == 0) nrf_gpio_pin_write(LED_OTHER,0); /* else { // detect if step occurred if (detect_step(xRaw,yRaw,zRaw)==1) { nSteps++; } } */ }
/** * @brief Function for application main entry. */ int main(void) { // Configure pins 8-15 (Port1) as outputs nrf_gpio_range_cfg_output(8, 15); nrf_gpio_port_clear(NRF_GPIO_PORT_SELECT_PORT1, 0XFF); // Configure motion interrupt pin nrf_gpio_cfg_input(MOTION_INTERRUPT_PIN_NUMBER, NRF_GPIO_PIN_PULLDOWN); gpiote_init(); if (adns2080_init() != ADNS2080_OK) { // ADNS2080 init failed, set rightmost LED on. nrf_gpio_pin_write(15, 1); while (true) { // Do nothing. } } // By default, ADNS2080 motion interrupt output is active low, edge sensitive; make it active high. if (adns2080_motion_interrupt_set(ADNS2080_MOTION_OUTPUT_POLARITY_HIGH, ADNS2080_MOTION_OUTPUT_SENSITIVITY_LEVEL) != ADNS2080_OK) { nrf_gpio_pin_write(14, 1); while (true) { // Do nothing. } } // Read out movement to clear ADNS2080 interrupt flags. if (adns2080_is_motion_detected()) { int16_t dummy; adns2080_movement_read(&dummy, &dummy); } // Enable GPIOTE interrupt in Nested Vector Interrupt Controller. NVIC_EnableIRQ(GPIOTE_IRQn); // Enable global interrupts. __enable_irq(); while(true) { if (motion_interrupt_detected) { // Toggle pin 12 to indicate that we've detected motion interrupt. nrf_gpio_pin_toggle(12); motion_interrupt_detected = false; // On our Nordic reference design PCB, the chip orientation is not the same as in the ADNS2080 // datasheet diagram, so X and Y axis are reversed. This is corrected by passing the pointer // parameters in reversed order. */ adns2080_movement_read(&m_delta_y, &m_delta_x); // If movement delta_x is above the threshold, the LEDs light up accordingly. When the mouse is moved // to the left, LEDs 1 through 4 are lit and when the mouse is moved right, LEDs 5 through 8 are lit. if (m_delta_x > MOUSE_MOVEMENT_THRESHOLD) { nrf_gpio_port_write(NRF_GPIO_PORT_SELECT_PORT1, 0xF0); } else if (m_delta_x < (-MOUSE_MOVEMENT_THRESHOLD)) { nrf_gpio_port_write(NRF_GPIO_PORT_SELECT_PORT1, 0x0F); } else { nrf_gpio_port_clear(NRF_GPIO_PORT_SELECT_PORT1, 0xFF); } } } }
static void timer_timeout_handler(void * p_context) { UNUSED_PARAMETER(p_context); nrf_gpio_pin_toggle(BSP_LED_1); nrf_adc_start(); }
void LED1_Toggle(void) { nrf_gpio_pin_toggle(LED_0); }