/**@brief Timer callback used for controlling board LEDs to represent application state. * */ static void blink_timeout_handler(iot_timer_time_in_ms_t wall_clock_value) { UNUSED_PARAMETER(wall_clock_value); switch (m_display_state) { case LEDS_INACTIVE: { LEDS_OFF((LED_ONE | LED_TWO)); break; } case LEDS_BLE_ADVERTISING: { LEDS_INVERT(LED_ONE); LEDS_OFF(LED_TWO); break; } case LEDS_IPV6_IF_DOWN: { LEDS_ON(LED_ONE); LEDS_INVERT(LED_TWO); break; } case LEDS_IPV6_IF_UP: { LEDS_OFF(LED_ONE); LEDS_ON(LED_TWO); break; } default: { break; } } }
static void coap_response_handler(uint32_t status, void * arg, coap_message_t * p_response) { if (status == NRF_SUCCESS) { if (coap_message_opt_present(p_response, COAP_OPT_OBSERVE) == NRF_SUCCESS) { // It is an notification or result of a GET response LEDS_ON(LED_FOUR); } else { LEDS_OFF(LED_FOUR); } APPL_LOG("[APPL]: Response Code : %d\r\n", p_response->header.code); if (p_response->header.code == COAP_CODE_205_CONTENT) { switch (p_response->p_payload[0]) { case STATUS_ON: LEDS_ON(LED_THREE); break; case STATUS_OFF: LEDS_OFF(LED_THREE); break; default: break; } } } }
void gptimer1_handler(int id) { uint32_t irq = reg32r(GPTIMER1_BASE, GPT_TISR); { static int blink = 0; if (blink & (1<<2)) { LEDS_OFF(LED0); LEDS_ON(LED1); } else { LEDS_ON(LED0); LEDS_OFF(LED1); } blink++; } // check for overflow int if (irq & OVF_IT_FLAG) { Remove(&thistask->Node); AddTail(&tasks, &thistask->Node); thistask = (struct task *)tasks.Head; irq_new_task(tcb_to_sp(&thistask->tcb)); } // clear ints reg32w(GPTIMER1_BASE, GPT_TISR, ~0); }
/**@brief Timer callback used for controlling board LEDs to represent application state. * */ static void blink_timeout_handler(iot_timer_time_in_ms_t wall_clock_value) { UNUSED_PARAMETER(wall_clock_value); #ifdef COMMISSIONING_ENABLED static bool id_mode_previously_enabled; #endif // COMMISSIONING_ENABLED switch (m_display_state) { case LEDS_INACTIVE: { LEDS_OFF((LED_ONE | LED_TWO)); break; } case LEDS_CONNECTABLE_MODE: { LEDS_INVERT(LED_ONE); LEDS_OFF(LED_TWO); break; } case LEDS_IPV6_IF_DOWN: { LEDS_ON(LED_ONE); LEDS_INVERT(LED_TWO); break; } case LEDS_IPV6_IF_UP: { LEDS_OFF(LED_ONE); LEDS_ON(LED_TWO); break; } default: { break; } } #ifdef COMMISSIONING_ENABLED if ((id_mode_previously_enabled == false) && (m_identity_mode_active == true)) { LEDS_OFF(LED_THREE | LED_FOUR); } if ((id_mode_previously_enabled == true) && (m_identity_mode_active == true)) { LEDS_INVERT(LED_THREE | LED_FOUR); } if ((id_mode_previously_enabled == true) && (m_identity_mode_active == false)) { LEDS_OFF(LED_THREE | LED_FOUR); } id_mode_previously_enabled = m_identity_mode_active; #endif // COMMISSIONING_ENABLED }
/**@brief Timer callback used for controlling board LEDs to represent application state. * * @param[in] p_context Pointer used for passing context. No context used in this application. */ static void blink_timeout_handler(void * p_context) { switch (m_display_state) { case LEDS_INACTIVE: { LEDS_OFF((LED_ONE | LED_TWO)); break; } case LEDS_BLE_ADVERTISING: { LEDS_INVERT(LED_ONE); LEDS_OFF(LED_TWO); break; } case LEDS_IPV6_IF_DOWN: { LEDS_ON(LED_ONE); LEDS_INVERT(LED_TWO); break; } case LEDS_TX_ECHO_RESPONSE: { LEDS_ON(LED_ONE); LEDS_OFF(LED_TWO); break; } case LEDS_TX_UDP_PACKET: { LEDS_ON(LED_TWO); if (LED_IS_ON(LED_ONE) == 0) { if (m_udp_tx_occured) { // If UDP transmission stops, LED_ONE should stop blinking in off state. LEDS_ON(LED_ONE); m_udp_tx_occured = false; } } else { LEDS_OFF(LED_ONE); } break; } default: { break; } } }
/**@brief Timer callback used for controlling board LEDs to represent application state. * */ static void blink_timeout_handler(iot_timer_time_in_ms_t wall_clock_value) { UNUSED_PARAMETER(wall_clock_value); switch (m_display_state) { case LEDS_INACTIVE: { LEDS_OFF(ALL_APP_LED); break; } case LEDS_BLE_ADVERTISING: { LEDS_INVERT(LED_ONE); LEDS_OFF((LED_TWO | LED_THREE | LED_FOUR)); break; } case LEDS_IPV6_IF_DOWN: { LEDS_INVERT(LED_TWO); LEDS_OFF((LED_ONE | LED_THREE | LED_FOUR)); break; } case LEDS_IPV6_IF_UP: { LEDS_ON(LED_ONE); LEDS_OFF((LED_TWO | LED_THREE | LED_FOUR)); break; } case LEDS_CONNECTED_TO_BROKER: { LEDS_ON(LED_TWO); LEDS_OFF((LED_ONE | LED_THREE | LED_FOUR)); m_display_state = LEDS_PUBLISHING; break; } case LEDS_PUBLISHING: { LEDS_OFF(LED_ONE); LEDS_ON(LED_TWO); break; } default: { break; } } }
/**@brief Publishes LED state to MQTT broker. * * @param[in] led_state LED state being published. */ static void app_mqtt_publish(bool led_state) { mqtt_topic_t topic; mqtt_data_t data; char topic_desc[] = "led/state"; topic.p_topic = (uint8_t *)topic_desc; topic.topic_len = strlen(topic_desc); data.data_len = 1; data.p_data = (uint8_t *)&led_state; uint32_t err_code = mqtt_publish(&m_app_mqtt_id,&topic, &data); APPL_LOG("[APPL]: mqtt_publish result 0x%08lx\r\n", err_code); if (err_code == MQTT_SUCCESS) { LEDS_INVERT(LED_FOUR); m_led_state = !m_led_state; } else { // Flash LED_THREE if error occurs. LEDS_ON(LED_THREE); err_code = app_timer_start(m_led_blink_timer, LED_BLINK_INTERVAL, NULL); APP_ERROR_CHECK(err_code); } }
static void nfc_callback(void * p_context, nfc_t2t_event_t event, const uint8_t * p_data, size_t data_length) { (void) p_context; uint32_t err_code; switch (event) { case NFC_T2T_EVENT_FIELD_ON: { NRF_LOG_INFO("NFC_EVENT_FIELD_ON\r\n"); LEDS_ON(BSP_LED_3_MASK); /* Start advertising to become connectable. */ if (!m_advertising_flag) { m_advertising_flag = 1; advertising_enable(); err_code = ble_advertising_start(BLE_ADV_MODE_FAST); APP_ERROR_CHECK(err_code); } } break; case NFC_T2T_EVENT_FIELD_OFF: NRF_LOG_INFO("NFC_EVENT_FIELD_OFF\r\n"); LEDS_OFF(BSP_LED_3_MASK); break; default: break; } return; }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(wget_process, ev, data) { PROCESS_BEGIN(); PRINTF("wget: fetching %s\n", file); #if STATS fetch_counter = 0; fetch_started = clock_time(); #endif /* STATS */ LEDS_ON(LEDS_YELLOW); if(webclient_get(server, port, file) == 0) { PRINTF("wget: failed to connect\n"); LEDS_OFF(LEDS_YELLOW); fetch_running = 0; call_done(WGET_CONNECT_FAILED); } else { while(fetch_running) { PROCESS_WAIT_EVENT(); if(ev == tcpip_event) { webclient_appcall(data); } } } PROCESS_END(); }
/**@brief Function for error handling, which demonstrates usage of the ANT debug * module to output debug information over the debug channel on an assertion * * @param[in] error_code Error code supplied to the handler. * @param[in] line_num Line number where the handler is called. * @param[in] p_file_name Pointer to the file name. */ void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info) { #if defined(INCLUDE_DEBUG_CHANNEL) error_info_t * p_error_info = (error_info_t *)info; char file_name[2]; uint32_t file_name_len = strlen((char *)p_error_info->p_file_name); file_name[0] = '\0'; file_name[1] = '\0'; for (uint32_t i = 0; i < file_name_len; i++) { if ((p_error_info->p_file_name[i] != '.') && (p_error_info->p_file_name[i] != '/') && (p_error_info->p_file_name[i] != '\\')) { file_name[0] = p_error_info->p_file_name[i + 1]; file_name[1] = p_error_info->p_file_name[i]; break; } } ad_force_error_page((uint8_t)p_error_info->err_code, (uint16_t)p_error_info->line_num, file_name); #endif LEDS_ON(LEDS_MASK); for (;;) { // No implementation needed. } }
void vBlinkerRequest(uint8_t cmd) { switch (cmd & CMD_MASK) { case CMD_LED_ON: switch (cmd & LED_MASK) { case LED_RED: LED_RED_ON(); break; case LED_GREEN: LED_GREEN_ON(); break; case LED_BLUE: LED_BLUE_ON(); break; case LED_ALL: LEDS_ON(); break; } break; case CMD_LED_OFF: switch (cmd & LED_MASK) { case LED_RED: LED_RED_OFF(); break; case LED_GREEN: LED_GREEN_OFF(); break; case LED_BLUE: LED_BLUE_OFF(); break; case LED_ALL: LEDS_OFF(); break; } break; case CMD_LED_TOGGLE: switch (cmd & LED_MASK) { case LED_RED: LED_RED_TOGGLE(); break; case LED_GREEN: LED_GREEN_TOGGLE(); break; case LED_BLUE: LED_BLUE_TOGGLE(); break; case LED_ALL: LED_RED_TOGGLE(); LED_GREEN_TOGGLE(); LED_BLUE_TOGGLE(); break; } break; } }
int main(void) { int i; set_mcu_speed_xt2_mclk_8MHz_smclk_1MHz(); uart0_init(UART0_CONFIG_1MHZ_115200); LEDS_INIT(); LEDS_ON(); delay(DELAY); LEDS_OFF(); led_state = 0; while (1) { for (i=0; i<99; i++) { printf("Salam Aleikoum\n"); uart0_getchar_polling(); led_change(); } } }
/*---------------------------------------------------------------------------*/ int cc2420_off(void) { /* Don't do anything if we are already turned off. */ if(receive_on == 0) { return 1; } /* If we are called when the driver is locked, we indicate that the radio should be turned off when the lock is unlocked. */ if(locked) { /* printf("Off when locked (%d)\n", locked);*/ LEDS_ON(LEDS_GREEN + LEDS_BLUE); lock_off = 1; return 1; } GET_LOCK(); /* If we are currently receiving a packet (indicated by SFD == 1), we don't actually switch the radio off now, but signal that the driver should switch off the radio once the packet has been received and processed, by setting the 'lock_off' variable. */ if(status() & BV(CC2420_TX_ACTIVE)) { lock_off = 1; } else { off(); } RELEASE_LOCK(); return 1; }
/**@brief Function for application main entry. Does not return. */ int main(void) { utils_setup(); softdevice_setup(); ant_channel_tx_broadcast_setup(); // Main loop. for (;;) { #ifdef CPU_LOAD_TRACE // Disabling interrupts in this way is highly not recommended. It has an impact on the work // of the softdecive and it is used only in order to show CPU load. __disable_irq(); LEDS_OFF(BSP_LED_0_MASK); __WFI(); LEDS_ON(BSP_LED_0_MASK); __enable_irq(); #else // Put CPU in sleep if possible. uint32_t err_code = sd_app_evt_wait(); APP_ERROR_CHECK(err_code); #endif // CPU_LOAD_TRACE } }
/**@brief Function for toggling LEDS based on received notifications. * * @param[in] p_ble_evt Event to handle. */ static void on_evt_hvx(ble_evt_t * p_ble_evt, client_t * p_client, uint32_t index) { if ((p_client != NULL) && (p_client->state == STATE_RUNNING)) { if ( ( p_ble_evt->evt.gattc_evt.params.hvx.handle == p_client->srv_db.services[0].charateristics[p_client->char_index].characteristic.handle_value ) && (p_ble_evt->evt.gattc_evt.params.hvx.len == 1) ) { if(index < LEDS_NUMBER) { uint8_t leds[] = LEDS_LIST; if (p_ble_evt->evt.gattc_evt.params.hvx.data[0] == 0) { LEDS_OFF(1<<leds[index]); } else { LEDS_ON(1<<leds[index]); } } } } }
/**@brief Function for error handling, which is called when an error has occurred. * * @warning This handler is an example only and does not fit a final product. You need to analyze * how your product is supposed to react in case of error. * * @param[in] error_code Error code supplied to the handler. * @param[in] line_num Line number where the handler is called. * @param[in] p_file_name Pointer to the file name. */ void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name) { LEDS_ON((LED_ONE | LED_TWO | LED_THREE | LED_FOUR)); APPL_LOG("[** ASSERT **]: Error 0x%08lX, Line %ld, File %s\r\n", error_code, line_num, p_file_name); // Variables used to retain function parameter values when debugging. static volatile uint8_t s_file_name[MAX_LENGTH_FILENAME]; static volatile uint16_t s_line_num; static volatile uint32_t s_error_code; strncpy((char *)s_file_name, (const char *)p_file_name, MAX_LENGTH_FILENAME - 1); s_file_name[MAX_LENGTH_FILENAME - 1] = '\0'; s_line_num = line_num; s_error_code = error_code; UNUSED_VARIABLE(s_file_name); UNUSED_VARIABLE(s_line_num); UNUSED_VARIABLE(s_error_code); // This call can be used for debug purposes during application development. // @note CAUTION: Activating this code will write the stack to flash on an error. // This function should NOT be used in a final product. // It is intended STRICTLY for development/debugging purposes. // The flash write will happen EVEN if the radio is active, thus interrupting // any communication. // Use with care. Un-comment the line below to use. // ble_debug_assert_handler(error_code, line_num, p_file_name); // On assert, the system can only recover on reset. //NVIC_SystemReset(); for(;;) { // Infinite loop. } }
static void lock_control_handler(ble_doorlock_t * p_doorlock, uint8_t state) { uint32_t err_code; if (state) { // Open door LEDS_ON((BSP_LED_3_MASK)); // Start timer if (m_lock_timer_id != 0xFFFFFFFF) { err_code = app_timer_stop(m_lock_timer_id); APP_ERROR_CHECK(err_code); } else { err_code = app_timer_create(&m_lock_timer_id, APP_TIMER_MODE_SINGLE_SHOT, lock_timeout_handler); APP_ERROR_CHECK(err_code); } err_code = app_timer_start(m_lock_timer_id, APP_TIMER_TICKS(APP_CFG_CHAR_LOCK_TIMEOUT, APP_TIMER_PRESCALER), NULL); APP_ERROR_CHECK(err_code); } else { // Lock door LEDS_OFF((BSP_LED_3_MASK)); } }
int main(void) { ret_code_t err_code; err_code = NRF_LOG_INIT(); APP_ERROR_CHECK(err_code); NRF_LOG_PRINTF("[APP]: Multilink Example\r\n"); leds_init(); APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, NULL); buttons_init(); ble_stack_init(); db_discovery_init(); lbs_c_init(); // Start scanning for peripherals and initiate connection to devices which // advertise. scan_start(); // Turn on the LED to signal scanning. LEDS_ON(CENTRAL_SCANNING_LED); for (;;) { // Wait for BLE events. power_manage(); } }
int main(void) { int i; WDTCTL = WDTPW + WDTHOLD; P1IE = 0x00; // Interrupt enable P2IE = 0x00; // 0:disable 1:enable LEDS_INIT(); LEDS_ON(); delay(DELAY); LEDS_OFF(); led_state = 0; while (1) { for (i=0; i<99; i++) { led_change(); delay(DELAY >> 2); } } }
/**@brief Function for handling the Application's BLE Stack events. * * @param[in] p_ble_evt Bluetooth stack event. */ static void on_ble_peripheral_evt(ble_evt_t * p_ble_evt) { uint32_t err_code; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: LEDS_OFF(PERIPHERAL_ADVERTISING_LED); LEDS_ON(PERIPHERAL_CONNECTED_LED); m_conn_handle_peripheral = p_ble_evt->evt.gap_evt.conn_handle; break; case BLE_GAP_EVT_DISCONNECTED: LEDS_OFF(PERIPHERAL_CONNECTED_LED); m_conn_handle_peripheral = BLE_CONN_HANDLE_INVALID; break; case BLE_GAP_EVT_SEC_PARAMS_REQUEST: // Pairing not supported err_code = sd_ble_gap_sec_params_reply(m_conn_handle_peripheral, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL); APP_ERROR_CHECK(err_code); break; case BLE_GATTS_EVT_SYS_ATTR_MISSING: err_code = sd_ble_gatts_sys_attr_set(m_conn_handle_peripheral, NULL, 0, BLE_GATTS_SYS_ATTR_FLAG_SYS_SRVCS); APP_ERROR_CHECK(err_code); break; default: // No implementation needed. break; } }
/*lint -save -e14 */ __WEAK void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name) { // On assert, the system can only recover with a reset. #ifndef DEBUG NVIC_SystemReset(); #else #ifdef BSP_DEFINES_ONLY LEDS_ON(LEDS_MASK); #else UNUSED_VARIABLE(bsp_indication_set(BSP_INDICATE_FATAL_ERROR)); // This call can be used for debug purposes during application development. // @note CAUTION: Activating this code will write the stack to flash on an error. // This function should NOT be used in a final product. // It is intended STRICTLY for development/debugging purposes. // The flash write will happen EVEN if the radio is active, thus interrupting // any communication. // Use with care. Uncomment the line below to use. //ble_debug_assert_handler(error_code, line_num, p_file_name); #endif // BSP_DEFINES_ONLY m_error_code = error_code; m_line_num = line_num; m_p_file_name = p_file_name; UNUSED_VARIABLE(m_error_code); UNUSED_VARIABLE(m_line_num); UNUSED_VARIABLE(m_p_file_name); __disable_irq(); while(1) ; #endif // DEBUG }
int main(void) { LEDS_CONFIGURE(LEDS_MASK); LEDS_OFF(LEDS_MASK); nrf_gpio_cfg_output(WAVE_ON_PIN_NUMBER); // on this pin 2Hz wave will be generated #ifdef BSP_BUTTON_0 // configure pull-up on first button nrf_gpio_cfg_input(BSP_BUTTON_0, NRF_GPIO_PIN_PULLUP); #endif APP_GPIOTE_INIT(1); uart_config(); lpcomp_init(); printf("\n\rLPCOMP driver usage example\r\n"); while (true) { print_statistics(); LEDS_ON(BSP_LED_1_MASK); NRF_GPIO->OUTCLR = (1 << WAVE_ON_PIN_NUMBER); nrf_delay_ms(100); // generate 100 ms pulse on selected pin print_statistics(); LEDS_OFF(BSP_LED_1_MASK); NRF_GPIO->OUTSET = (1 << WAVE_ON_PIN_NUMBER); nrf_delay_ms(400); } }
static void show_error(void) { LEDS_ON(LEDS_MASK); while(1) { // Do nothing. } }
/**@brief Function for starting advertising. */ static void advertising_start(void) { uint32_t err_code; err_code = sd_ble_gap_adv_start(&m_adv_params); APP_ERROR_CHECK(err_code); LEDS_ON(ADVERTISING_LED); }
void set_led(int led, int value) { if (led < LEDS_NUMBER) { if (value) { LEDS_ON(1 << leds_list[led]); } else { LEDS_OFF(1 << leds_list[led]); } } }
/*---------------------------------------------------------------------------*/ static void on(void) { if(xmac_is_on && radio_is_on == 0) { radio_is_on = 1; NETSTACK_RADIO.on(); LEDS_ON(LEDS_RED); } }
void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info) { #ifdef DEBUG app_error_print(id, pc, info); #endif LEDS_ON(LEDS_MASK); while(1); }
/**@brief Function to start scanning. */ static void scan_start(void) { ble_gap_whitelist_t whitelist; ble_gap_addr_t * p_whitelist_addr[BLE_GAP_WHITELIST_ADDR_MAX_COUNT]; ble_gap_irk_t * p_whitelist_irk[BLE_GAP_WHITELIST_IRK_MAX_COUNT]; uint32_t err_code; uint32_t count; // Verify if there is any flash access pending, if yes delay starting scanning until // it's complete. err_code = pstorage_access_status_get(&count); APP_ERROR_CHECK(err_code); if (count != 0) { m_memory_access_in_progress = true; return; } // Initialize whitelist parameters. whitelist.addr_count = BLE_GAP_WHITELIST_ADDR_MAX_COUNT; whitelist.irk_count = 0; whitelist.pp_addrs = p_whitelist_addr; whitelist.pp_irks = p_whitelist_irk; // Request creating of whitelist. err_code = dm_whitelist_create(&m_dm_app_id,&whitelist); APP_ERROR_CHECK(err_code); if (((whitelist.addr_count == 0) && (whitelist.irk_count == 0)) || (m_scan_mode != BLE_WHITELIST_SCAN) || (m_whitelist_temporarily_disabled)) { // No devices in whitelist, hence non selective performed. m_scan_param.active = 0; // Active scanning set. m_scan_param.selective = 0; // Selective scanning not set. m_scan_param.interval = SCAN_INTERVAL;// Scan interval. m_scan_param.window = SCAN_WINDOW; // Scan window. m_scan_param.p_whitelist = NULL; // No whitelist provided. m_scan_param.timeout = 0x0000; // No timeout. } else { // Selective scanning based on whitelist first. m_scan_param.active = 0; // Active scanning set. m_scan_param.selective = 1; // Selective scanning not set. m_scan_param.interval = SCAN_INTERVAL;// Scan interval. m_scan_param.window = SCAN_WINDOW; // Scan window. m_scan_param.p_whitelist = &whitelist; // Provide whitelist. m_scan_param.timeout = 0x001E; // 30 seconds timeout. } err_code = sd_ble_gap_scan_start(&m_scan_param); APP_ERROR_CHECK(err_code); LEDS_ON(CENTRAL_SCANNING_LED); }
/**@brief Function for starting connectable mode. */ static void connectable_mode_enter(void) { uint32_t err_code = ipv6_medium_connectable_mode_enter(m_ipv6_medium.ipv6_medium_instance_id); APP_ERROR_CHECK(err_code); APPL_LOG("[APPL]: Physical layer in connectable mode.\r\n"); LEDS_OFF(LED_TWO); LEDS_ON(LED_ONE); }
/**@brief Timer callback used for controlling board LEDs to represent application state. * * @param[in] p_context Pointer used for passing context. No context used in this application. */ static void blink_timeout_handler(void * p_context) { uint32_t err_code; switch (m_display_state) { case LEDS_INACTIVE: { LEDS_OFF(ALL_APP_LED); break; } case LEDS_BLE_ADVERTISING: { LEDS_INVERT(LED_ONE); LEDS_OFF((LED_TWO | LED_THREE | LED_FOUR)); err_code = app_timer_start(m_led_blink_timer, LED_BLINK_INTERVAL, NULL); APP_ERROR_CHECK(err_code); break; } case LEDS_IPV6_IF_DOWN: { LEDS_INVERT(LED_TWO); LEDS_OFF((LED_ONE | LED_THREE | LED_FOUR)); err_code = app_timer_start(m_led_blink_timer, LED_BLINK_INTERVAL, NULL); APP_ERROR_CHECK(err_code); break; } case LEDS_IPV6_IF_UP: { LEDS_ON(LED_ONE); LEDS_OFF((LED_TWO | LED_THREE | LED_FOUR)); break; } case LEDS_CONNECTED_TO_BROKER: { LEDS_ON(LED_TWO); LEDS_OFF((LED_ONE | LED_THREE)); break; } default: { break; } } }