main.cpp

00001 /* mbed Microcontroller Library
00002  * Copyright (c) 2016 ARM Limited
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 #if !DEVICE_LOWPOWERTIMER
00018     #error [NOT_SUPPORTED] Low power timer not supported for this target
00019 #endif
00020 
00021 #include "utest/utest.h"
00022 #include "unity/unity.h"
00023 #include "greentea-client/test_env.h"
00024 
00025 #include "mbed.h"
00026 #include "us_ticker_api.h"
00027 #include "lp_ticker_api.h"
00028 
00029 using namespace utest::v1;
00030 
00031 volatile static bool complete;
00032 static ticker_event_t delay_event;
00033 static const ticker_data_t *lp_ticker_data = get_lp_ticker_data();
00034 
00035 
00036 /* Timeouts are quite arbitrary due to large number of boards with varying level of accuracy */
00037 #define LONG_TIMEOUT (100000)
00038 #define SHORT_TIMEOUT (600)
00039 
00040 void cb_done(uint32_t id) {
00041     complete = true;
00042 }
00043 
00044 void lp_ticker_delay_us(uint32_t delay_us, uint32_t tolerance)
00045 {
00046     complete = false;
00047     uint32_t delay_ts;
00048 
00049     ticker_set_handler(lp_ticker_data, cb_done);
00050     ticker_remove_event(lp_ticker_data, &delay_event);
00051     delay_ts = lp_ticker_read() + delay_us;
00052 
00053     timestamp_t start = us_ticker_read();
00054     ticker_insert_event(lp_ticker_data, &delay_event, delay_ts, (uint32_t)&delay_event);
00055     while (!complete);
00056     timestamp_t end = us_ticker_read();
00057 
00058     TEST_ASSERT_UINT32_WITHIN(tolerance, delay_us, end - start);
00059     TEST_ASSERT_TRUE(complete);
00060 }
00061 
00062 #if DEVICE_SLEEP
00063 void lp_ticker_1s_deepsleep()
00064 {
00065     complete = false;
00066     uint32_t delay_ts;
00067 
00068     ticker_set_handler(lp_ticker_data, cb_done);
00069     ticker_remove_event(lp_ticker_data, &delay_event);
00070     delay_ts = lp_ticker_read() + 1000000;
00071 
00072     /* 
00073      * We use here lp_ticker_read() instead of us_ticker_read() for start and 
00074      * end because the microseconds timer might be disable during deepsleep.
00075      */
00076     timestamp_t start = lp_ticker_read();
00077     ticker_insert_event(lp_ticker_data, &delay_event, delay_ts, (uint32_t)&delay_event);
00078     deepsleep();
00079     while (!complete);
00080     timestamp_t end = lp_ticker_read();
00081 
00082     TEST_ASSERT_UINT32_WITHIN(LONG_TIMEOUT, 1000000, end - start);
00083     TEST_ASSERT_TRUE(complete);
00084 }
00085 
00086 void lp_ticker_1s_sleep()
00087 {
00088     complete = false;
00089     uint32_t delay_ts;
00090 
00091     ticker_set_handler(lp_ticker_data, cb_done);
00092     ticker_remove_event(lp_ticker_data, &delay_event);
00093     delay_ts = lp_ticker_read() + 1000000;
00094 
00095     timestamp_t start = us_ticker_read();
00096     ticker_insert_event(lp_ticker_data, &delay_event, delay_ts, (uint32_t)&delay_event);
00097     sleep();
00098     while (!complete);
00099     timestamp_t end = us_ticker_read();
00100 
00101     TEST_ASSERT_UINT32_WITHIN(LONG_TIMEOUT, 1000000, end - start);
00102     TEST_ASSERT_TRUE(complete);
00103 }
00104 #endif /* DEVICE_SLEEP */
00105 
00106 void lp_ticker_500us(void)
00107 {
00108     lp_ticker_delay_us(500, SHORT_TIMEOUT);
00109 }
00110 
00111 void lp_ticker_1ms(void)
00112 {
00113     lp_ticker_delay_us(1000, SHORT_TIMEOUT);
00114 }
00115 
00116 void lp_ticker_1s(void)
00117 {
00118     lp_ticker_delay_us(1000000, LONG_TIMEOUT);
00119 }
00120 
00121 void lp_ticker_5s(void)
00122 {
00123     lp_ticker_delay_us(5000000, LONG_TIMEOUT);
00124 }
00125 
00126 status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
00127     greentea_case_failure_abort_handler(source, reason);
00128     return STATUS_CONTINUE;
00129 }
00130 
00131 Case cases[] = {
00132     Case("500us lp_ticker", lp_ticker_500us, greentea_failure_handler),
00133     Case("1ms lp_ticker", lp_ticker_1ms, greentea_failure_handler),
00134     Case("1s lp_ticker", lp_ticker_1s, greentea_failure_handler),
00135     Case("5s lp_ticker", lp_ticker_5s, greentea_failure_handler),
00136 #if DEVICE_SLEEP
00137     Case("1s lp_ticker sleep", lp_ticker_1s_sleep, greentea_failure_handler),
00138     Case("1s lp_ticker deepsleep", lp_ticker_1s_deepsleep, greentea_failure_handler),
00139 #endif /* DEVICE_SLEEP */
00140 };
00141 
00142 status_t greentea_test_setup(const size_t number_of_cases) {
00143     GREENTEA_SETUP(20, "default_auto");
00144     lp_ticker_data->interface->init();
00145     return greentea_test_setup_handler(number_of_cases);
00146 }
00147 
00148 Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
00149 
00150 int main() {
00151     Harness::run(specification);
00152 }