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     /*
00069      * Since deepsleep() may shut down the UART peripheral, we wait for 10ms
00070      * to allow for hardware serial buffers to completely flush.
00071 
00072      * This should be replaced with a better function that checks if the
00073      * hardware buffers are empty. However, such an API does not exist now,
00074      * so we'll use the wait_ms() function for now.
00075      */
00076     wait_ms(10);
00077 
00078     ticker_set_handler(lp_ticker_data, cb_done);
00079     ticker_remove_event(lp_ticker_data, &delay_event);
00080     delay_ts = lp_ticker_read() + 1000000;
00081 
00082     /*
00083      * We use here lp_ticker_read() instead of us_ticker_read() for start and
00084      * end because the microseconds timer might be disable during deepsleep.
00085      */
00086     timestamp_t start = lp_ticker_read();
00087     ticker_insert_event(lp_ticker_data, &delay_event, delay_ts, (uint32_t)&delay_event);
00088     deepsleep();
00089     while (!complete);
00090     timestamp_t end = lp_ticker_read();
00091 
00092     TEST_ASSERT_UINT32_WITHIN(LONG_TIMEOUT, 1000000, end - start);
00093     TEST_ASSERT_TRUE(complete);
00094 }
00095 
00096 void lp_ticker_1s_sleep()
00097 {
00098     complete = false;
00099     uint32_t delay_ts;
00100 
00101     ticker_set_handler(lp_ticker_data, cb_done);
00102     ticker_remove_event(lp_ticker_data, &delay_event);
00103     delay_ts = lp_ticker_read() + 1000000;
00104 
00105     timestamp_t start = us_ticker_read();
00106     ticker_insert_event(lp_ticker_data, &delay_event, delay_ts, (uint32_t)&delay_event);
00107     sleep();
00108     while (!complete);
00109     timestamp_t end = us_ticker_read();
00110 
00111     TEST_ASSERT_UINT32_WITHIN(LONG_TIMEOUT, 1000000, end - start);
00112     TEST_ASSERT_TRUE(complete);
00113 }
00114 #endif /* DEVICE_SLEEP */
00115 
00116 void lp_ticker_500us(void)
00117 {
00118     lp_ticker_delay_us(500, SHORT_TIMEOUT);
00119 }
00120 
00121 void lp_ticker_1ms(void)
00122 {
00123     lp_ticker_delay_us(1000, SHORT_TIMEOUT);
00124 }
00125 
00126 void lp_ticker_1s(void)
00127 {
00128     lp_ticker_delay_us(1000000, LONG_TIMEOUT);
00129 }
00130 
00131 void lp_ticker_5s(void)
00132 {
00133     lp_ticker_delay_us(5000000, LONG_TIMEOUT);
00134 }
00135 
00136 status_t  greentea_failure_handler(const Case *const source, const failure_t reason) {
00137     greentea_case_failure_abort_handler(source, reason);
00138     return STATUS_CONTINUE;
00139 }
00140 
00141 Case cases[] = {
00142     Case("500us lp_ticker", lp_ticker_500us, greentea_failure_handler),
00143     Case("1ms lp_ticker", lp_ticker_1ms, greentea_failure_handler),
00144     Case("1s lp_ticker", lp_ticker_1s, greentea_failure_handler),
00145     Case("5s lp_ticker", lp_ticker_5s, greentea_failure_handler),
00146 #if DEVICE_SLEEP
00147     Case("1s lp_ticker sleep", lp_ticker_1s_sleep, greentea_failure_handler),
00148     Case("1s lp_ticker deepsleep", lp_ticker_1s_deepsleep, greentea_failure_handler),
00149 #endif /* DEVICE_SLEEP */
00150 };
00151 
00152 status_t  greentea_test_setup(const size_t number_of_cases) {
00153     GREENTEA_SETUP(20, "default_auto");
00154     lp_ticker_data->interface->init();
00155     return greentea_test_setup_handler(number_of_cases);
00156 }
00157 
00158 Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
00159 
00160 int main() {
00161     Harness::run(specification);
00162 }