From 212d74ca9443d3bf438f03af4ba1c99756defca4 Mon Sep 17 00:00:00 2001 From: Andrzej Puzdrowski Date: Wed, 12 Apr 2017 11:13:03 +0200 Subject: [PATCH] fix coding style us_ticker.c --- .../TARGET_NRF5_SDK13/us_ticker.c | 77 ++++++------------- 1 file changed, 23 insertions(+), 54 deletions(-) diff --git a/targets/TARGET_NORDIC/TARGET_NRF5_SDK13/us_ticker.c b/targets/TARGET_NORDIC/TARGET_NRF5_SDK13/us_ticker.c index 7d0bcc095b..f716e235bb 100644 --- a/targets/TARGET_NORDIC/TARGET_NRF5_SDK13/us_ticker.c +++ b/targets/TARGET_NORDIC/TARGET_NRF5_SDK13/us_ticker.c @@ -111,8 +111,7 @@ void RTC1_IRQHandler(void); void common_rtc_init(void) { - if (m_common_rtc_enabled) - { + if (m_common_rtc_enabled) { return; } @@ -228,12 +227,10 @@ void common_rtc_set_interrupt(uint32_t us_timestamp, uint32_t cc_channel, uint64_t current_time64 = common_rtc_64bit_us_get(); // [add upper 32 bits from the current time to the timestamp value] uint64_t timestamp64 = us_timestamp + - (current_time64 & ~(uint64_t)0xFFFFFFFF); - + (current_time64 & ~(uint64_t)0xFFFFFFFF); // [if the original timestamp value happens to be after the 32 bit counter // of microsends overflows, correct the upper 32 bits accordingly] - if (us_timestamp < (uint32_t)(current_time64 & 0xFFFFFFFF)) - { + if (us_timestamp < (uint32_t)(current_time64 & 0xFFFFFFFF)) { timestamp64 += ((uint64_t)1 << 32); } // [microseconds -> ticks, always round the result up to avoid too early @@ -248,8 +245,7 @@ void common_rtc_set_interrupt(uint32_t us_timestamp, uint32_t cc_channel, // value is 2 ticks. This guarantees that the compare trigger is properly // setup before the compare condition occurs. uint32_t closest_safe_compare = common_rtc_32bit_ticks_get() + 2; - if ((int)(compare_value - closest_safe_compare) <= 0) - { + if ((int)(compare_value - closest_safe_compare) <= 0) { compare_value = closest_safe_compare; } @@ -314,7 +310,7 @@ static uint32_t previous_tick_cc_value = 0; */ MBED_WEAK uint32_t const os_trv; MBED_WEAK uint32_t const os_clockrate; -MBED_WEAK void OS_Tick_Handler() +MBED_WEAK void OS_Tick_Handler(void) { } @@ -461,14 +457,11 @@ static uint32_t get_next_tick_cc_delta() { uint32_t delta = 0; - if (os_clockrate != 1000) - { + if (os_clockrate != 1000) { // In RTX, by default SYSTICK is is used. // A tick event is generated every os_trv + 1 clock cycles of the system timer. delta = os_trv + 1; - } - else - { + } else { // If the clockrate is set to 1000us then 1000 tick should happen every second. // Unfortunatelly, when clockrate is set to 1000, os_trv is equal to 31. // If (os_trv + 1) is used as the delta value between two ticks, 1000 ticks will be @@ -484,24 +477,19 @@ static uint32_t get_next_tick_cc_delta() // Every five ticks (20%, 200 delta in one second), the delta is equal to 32 // The remaining (32) deltas equal to 32 are distributed using primes numbers. static uint32_t counter = 0; - if ((counter % 5) == 0 || (counter % 31) == 0 || (counter % 139) == 0 || (counter == 503)) - { + if ((counter % 5) == 0 || (counter % 31) == 0 || (counter % 139) == 0 || (counter == 503)) { delta = 32; - } - else - { + } else { delta = 33; } ++counter; - if (counter == 1000) - { + if (counter == 1000) { counter = 0; } } return delta; } - static inline void clear_tick_interrupt() { nrf_rtc_event_clear(COMMON_RTC_INSTANCE, OS_TICK_EVENT); @@ -519,27 +507,18 @@ static inline bool is_in_wrapped_range(uint32_t begin, uint32_t end, uint32_t va { // regular case, begin < end // return true if begin <= val < end - if (begin < end) - { - if (begin <= val && val < end) - { + if (begin < end) { + if (begin <= val && val < end) { return true; - } - else - { + } else { return false; } - } - else - { + } else { // In this case end < begin because it has wrap around the limits // return false if end < val < begin - if (end < val && val < begin) - { + if (end < val && val < begin) { return false; - } - else - { + } else { return true; } } @@ -566,8 +545,7 @@ static void register_next_tick() uint32_t current_counter = nrf_rtc_counter_get(COMMON_RTC_INSTANCE); // If an overflow occur, set the next tick in COUNTER + delta clock cycles - if (is_in_wrapped_range(previous_tick_cc_value, new_compare_value, current_counter + 1) == false) - { + if (is_in_wrapped_range(previous_tick_cc_value, new_compare_value, current_counter + 1) == false) { new_compare_value = current_counter + delta; } nrf_rtc_cc_set(COMMON_RTC_INSTANCE, OS_TICK_CC_CHANNEL, new_compare_value); @@ -633,29 +611,20 @@ uint32_t os_tick_val(void) uint32_t next_tick_cc_value = nrf_rtc_cc_get(COMMON_RTC_INSTANCE, OS_TICK_CC_CHANNEL); // do not use os_tick_ovf because its counter value can be different - if (is_in_wrapped_range(previous_tick_cc_value, next_tick_cc_value, current_counter)) - { - if (next_tick_cc_value > previous_tick_cc_value) - { + if(is_in_wrapped_range(previous_tick_cc_value, next_tick_cc_value, current_counter)) { + if (next_tick_cc_value > previous_tick_cc_value) { return next_tick_cc_value - current_counter; - } - else if (current_counter <= next_tick_cc_value) - { + } else if(current_counter <= next_tick_cc_value) { return next_tick_cc_value - current_counter; - } - else - { + } else { return next_tick_cc_value + (MAX_RTC_COUNTER_VAL - current_counter); } - } - else - { + } else { // use (os_trv + 1) has the base step, can be totally inacurate ... uint32_t clock_cycles_by_tick = os_trv + 1; // if current counter has wrap arround, add the limit to it. - if (current_counter < next_tick_cc_value) - { + if (current_counter < next_tick_cc_value) { current_counter = current_counter + MAX_RTC_COUNTER_VAL; }