mbed-rtos test programs for DISCO_F746NG. #Test for thread, mutex, semaphore, signals, queues, mail, ISR
Dependencies: mbed-rtos mbed-src
main.cpp
- Committer:
- mzta
- Date:
- 2015-11-11
- Revision:
- 0:225c1da086a1
File content as of revision 0:225c1da086a1:
#include "mbed.h" #include "test_env.h" #include "rtos.h" /******************** * Switch test case ********************/ #define TEST_84_BASIC //#define TEST_85_MUTEX //#define TEST_86_SEMAPHORE //#define TEST_87_SIGNALS //#define TEST_88_QUEUE //#define TEST_89_MAIL //#define TEST_90_TIMER //#define TEST_91_ISR #if defined(TEST_84_BASIC) /* * The stack size is defined in cmsis_os.h mainly dependent on the underlying toolchain and * the C standard library. For GCC, ARM_STD and IAR it is defined with a size of 2048 bytes * and for ARM_MICRO 512. Because of reduce RAM size some targets need a reduced stacksize. */ #if (defined(TARGET_STM32L053R8) || defined(TARGET_STM32L053C8)) && defined(TOOLCHAIN_GCC) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #elif (defined(TARGET_STM32F030R8) || defined(TARGET_STM32F070RB)) && defined(TOOLCHAIN_GCC) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #elif (defined(TARGET_STM32F030R8)) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #else #define STACK_SIZE DEFAULT_STACK_SIZE #endif void print_char(char c = '*') { printf("%c", c); fflush(stdout); } DigitalOut led1(LED1); DigitalOut led2(LED2); void led2_thread(void const *argument) { while (true) { led2 = !led2; Thread::wait(1000); print_char(); } } int main() { MBED_HOSTTEST_TIMEOUT(15); MBED_HOSTTEST_SELECT(wait_us_auto); MBED_HOSTTEST_DESCRIPTION(Basic thread); MBED_HOSTTEST_START("RTOS_1"); Thread thread(led2_thread, NULL, osPriorityNormal, STACK_SIZE); while (true) { led1 = !led1; Thread::wait(500); } } #elif defined(TEST_85_MUTEX) #define THREAD_DELAY 50 #define SIGNALS_TO_EMIT 100 /* * The stack size is defined in cmsis_os.h mainly dependent on the underlying toolchain and * the C standard library. For GCC, ARM_STD and IAR it is defined with a size of 2048 bytes * and for ARM_MICRO 512. Because of reduce RAM size some targets need a reduced stacksize. */ #if (defined(TARGET_STM32L053R8) || defined(TARGET_STM32L053C8)) && defined(TOOLCHAIN_GCC) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif (defined(TARGET_STM32F030R8) || defined(TARGET_STM32F070RB)) && defined(TOOLCHAIN_GCC) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif defined(TARGET_STM32F334R8) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif defined(TARGET_STM32F030R8) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif defined(TARGET_STM32F070RB) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #elif defined(TARGET_STM32F072RB) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #elif defined(TARGET_STM32F302R8) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #else #define STACK_SIZE DEFAULT_STACK_SIZE #endif void print_char(char c = '*') { printf("%c", c); fflush(stdout); } Mutex stdio_mutex; DigitalOut led(LED1); volatile int change_counter = 0; volatile bool changing_counter = false; volatile bool mutex_defect = false; bool manipulate_protected_zone(const int thread_delay) { bool result = true; stdio_mutex.lock(); // LOCK if (changing_counter == true) { // 'e' stands for error. If changing_counter is true access is not exclusively print_char('e'); result = false; mutex_defect = true; } changing_counter = true; // Some action on protected led = !led; change_counter++; print_char('.'); Thread::wait(thread_delay); changing_counter = false; stdio_mutex.unlock(); // UNLOCK return result; } void test_thread(void const *args) { const int thread_delay = int(args); while (true) { manipulate_protected_zone(thread_delay); } } int main() { MBED_HOSTTEST_TIMEOUT(20); MBED_HOSTTEST_SELECT(default); MBED_HOSTTEST_DESCRIPTION(Mutex resource lock); MBED_HOSTTEST_START("RTOS_2"); const int t1_delay = THREAD_DELAY * 1; const int t2_delay = THREAD_DELAY * 2; const int t3_delay = THREAD_DELAY * 3; Thread t2(test_thread, (void *)t2_delay, osPriorityNormal, STACK_SIZE); Thread t3(test_thread, (void *)t3_delay, osPriorityNormal, STACK_SIZE); while (true) { // Thread 1 action Thread::wait(t1_delay); manipulate_protected_zone(t1_delay); if (change_counter >= SIGNALS_TO_EMIT or mutex_defect == true) { t2.terminate(); t3.terminate(); break; } } fflush(stdout); MBED_HOSTTEST_RESULT(!mutex_defect); return 0; } #elif defined(TEST_86_SEMAPHORE) #define THREAD_DELAY 75 #define SEMAPHORE_SLOTS 2 #define SEM_CHANGES 100 /* * The stack size is defined in cmsis_os.h mainly dependent on the underlying toolchain and * the C standard library. For GCC, ARM_STD and IAR it is defined with a size of 2048 bytes * and for ARM_MICRO 512. Because of reduce RAM size some targets need a reduced stacksize. */ #if (defined(TARGET_STM32L053R8) || defined(TARGET_STM32L053C8)) && defined(TOOLCHAIN_GCC) #define STACK_SIZE DEFAULT_STACK_SIZE/16 #elif (defined(TARGET_STM32F030R8) || defined(TARGET_STM32F070RB)) && defined(TOOLCHAIN_GCC) #define STACK_SIZE DEFAULT_STACK_SIZE/8 #elif defined(TARGET_STM32F334R8) && (defined(TOOLCHAIN_GCC) || defined(TOOLCHAIN_IAR)) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif defined(TARGET_STM32F103RB) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif defined(TARGET_STM32F030R8) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif defined(TARGET_STM32F070RB) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #elif defined(TARGET_STM32F072RB) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #elif defined(TARGET_STM32F302R8) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #else #define STACK_SIZE DEFAULT_STACK_SIZE #endif void print_char(char c = '*') { printf("%c", c); fflush(stdout); } #define ORIGINAL 1 #undef ORIGINAL #if ORIGINAL Semaphore two_slots(SEMAPHORE_SLOTS); #else Semaphore *two_slots; #endif volatile int change_counter = 0; volatile int sem_counter = 0; volatile bool sem_defect = false; void test_thread(void const *delay) { const int thread_delay = int(delay); while (true) { #if ORIGINAL two_slots.wait(); #else two_slots->wait(); #endif sem_counter++; const bool sem_lock_failed = sem_counter > SEMAPHORE_SLOTS; const char msg = sem_lock_failed ? 'e' : sem_counter + '0'; print_char(msg); if (sem_lock_failed) { sem_defect = true; } Thread::wait(thread_delay); print_char('.'); sem_counter--; change_counter++; #if ORIGINAL two_slots.release(); #else two_slots->release(); #endif } } int main (void) { #ifndef ORIGINAL two_slots = new Semaphore(SEMAPHORE_SLOTS); #endif MBED_HOSTTEST_TIMEOUT(20); MBED_HOSTTEST_SELECT(default_auto); MBED_HOSTTEST_DESCRIPTION(Semaphore resource lock); MBED_HOSTTEST_START("RTOS_3"); const int t1_delay = THREAD_DELAY * 1; const int t2_delay = THREAD_DELAY * 2; const int t3_delay = THREAD_DELAY * 3; Thread t1(test_thread, (void *)t1_delay, osPriorityNormal, STACK_SIZE); Thread t2(test_thread, (void *)t2_delay, osPriorityNormal, STACK_SIZE); Thread t3(test_thread, (void *)t3_delay, osPriorityNormal, STACK_SIZE); while (true) { if (change_counter >= SEM_CHANGES or sem_defect == true) { t1.terminate(); t2.terminate(); t3.terminate(); break; } } fflush(stdout); MBED_HOSTTEST_RESULT(!sem_defect); return 0; } #elif defined(TEST_87_SIGNALS) #define SIGNALS_TO_EMIT 100 #define SIGNAL_HANDLE_DELEY 25 #define SIGNAL_SET_VALUE 0x01 /* * The stack size is defined in cmsis_os.h mainly dependent on the underlying toolchain and * the C standard library. For GCC, ARM_STD and IAR it is defined with a size of 2048 bytes * and for ARM_MICRO 512. Because of reduce RAM size some targets need a reduced stacksize. */ #if defined(TARGET_STM32L053R8) || defined(TARGET_STM32L053C8) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif (defined(TARGET_STM32F030R8)) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #else #define STACK_SIZE DEFAULT_STACK_SIZE #endif DigitalOut led(LED1); volatile int signal_counter = 0; void led_thread(void const *argument) { while (true) { // Signal flags that are reported as event are automatically cleared. Thread::signal_wait(SIGNAL_SET_VALUE); led = !led; signal_counter++; } } int main (void) { MBED_HOSTTEST_TIMEOUT(20); MBED_HOSTTEST_SELECT(default_auto); MBED_HOSTTEST_DESCRIPTION(Signals messaging); MBED_HOSTTEST_START("RTOS_4"); Thread thread(led_thread, NULL, osPriorityNormal, STACK_SIZE); bool result = true; while (true) { Thread::wait(2 * SIGNAL_HANDLE_DELEY); thread.signal_set(SIGNAL_SET_VALUE); if (signal_counter == SIGNALS_TO_EMIT) { printf("Handled %d signals\r\n", signal_counter); break; } } MBED_HOSTTEST_RESULT(result); return 0; } #elif defined(TEST_88_QUEUE) typedef struct { float voltage; /* AD result of measured voltage */ float current; /* AD result of measured current */ uint32_t counter; /* A counter value */ } message_t; #define CREATE_VOLTAGE(COUNTER) (COUNTER * 0.1) * 33 #define CREATE_CURRENT(COUNTER) (COUNTER * 0.1) * 11 #define QUEUE_SIZE 16 #define QUEUE_PUT_DELAY 100 /* * The stack size is defined in cmsis_os.h mainly dependent on the underlying toolchain and * the C standard library. For GCC, ARM_STD and IAR it is defined with a size of 2048 bytes * and for ARM_MICRO 512. Because of reduce RAM size some targets need a reduced stacksize. */ #if (defined(TARGET_STM32L053R8) || defined(TARGET_STM32L053C8)) && defined(TOOLCHAIN_GCC) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif (defined(TARGET_STM32F030R8)) && defined(TOOLCHAIN_GCC) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif (defined(TARGET_STM32F030R8)) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #else #define STACK_SIZE DEFAULT_STACK_SIZE #endif MemoryPool<message_t, QUEUE_SIZE> mpool; Queue<message_t, QUEUE_SIZE> queue; /* Send Thread */ void send_thread (void const *argument) { static uint32_t i = 10; while (true) { i++; // Fake data update message_t *message = mpool.alloc(); message->voltage = CREATE_VOLTAGE(i); message->current = CREATE_CURRENT(i); message->counter = i; queue.put(message); Thread::wait(QUEUE_PUT_DELAY); } } int main (void) { MBED_HOSTTEST_TIMEOUT(20); MBED_HOSTTEST_SELECT(default_auto); MBED_HOSTTEST_DESCRIPTION(Queue messaging); MBED_HOSTTEST_START("RTOS_5"); Thread thread(send_thread, NULL, osPriorityNormal, STACK_SIZE); bool result = true; int result_counter = 0; while (true) { osEvent evt = queue.get(); if (evt.status == osEventMessage) { message_t *message = (message_t*)evt.value.p; const float expected_voltage = CREATE_VOLTAGE(message->counter); const float expected_current = CREATE_CURRENT(message->counter); // Check using macros if received values correspond to values sent via queue bool expected_values = (expected_voltage == message->voltage) && (expected_current == message->current); result = result && expected_values; const char *result_msg = expected_values ? "OK" : "FAIL"; printf("%3d %.2fV %.2fA ... [%s]\r\n", message->counter, message->voltage, message->current, result_msg); mpool.free(message); if (result == false || ++result_counter == QUEUE_SIZE) { break; } } } MBED_HOSTTEST_RESULT(result); return 0; } #elif defined(TEST_89_MAIL) typedef struct { float voltage; /* AD result of measured voltage */ float current; /* AD result of measured current */ uint32_t counter; /* A counter value */ } mail_t; #define CREATE_VOLTAGE(COUNTER) (COUNTER * 0.1) * 33 #define CREATE_CURRENT(COUNTER) (COUNTER * 0.1) * 11 #define QUEUE_SIZE 16 #define QUEUE_PUT_DELAY 100 /* * The stack size is defined in cmsis_os.h mainly dependent on the underlying toolchain and * the C standard library. For GCC, ARM_STD and IAR it is defined with a size of 2048 bytes * and for ARM_MICRO 512. Because of reduce RAM size some targets need a reduced stacksize. */ #if (defined(TARGET_STM32L053R8) || defined(TARGET_STM32L053C8)) && defined(TOOLCHAIN_GCC) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif (defined(TARGET_STM32F030R8)) && defined(TOOLCHAIN_GCC) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #elif (defined(TARGET_STM32F030R8)) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #else #define STACK_SIZE DEFAULT_STACK_SIZE #endif Mail<mail_t, QUEUE_SIZE> mail_box; void send_thread (void const *argument) { static uint32_t i = 10; while (true) { i++; // fake data update mail_t *mail = mail_box.alloc(); mail->voltage = CREATE_VOLTAGE(i); mail->current = CREATE_CURRENT(i); mail->counter = i; mail_box.put(mail); Thread::wait(QUEUE_PUT_DELAY); } } int main (void) { MBED_HOSTTEST_TIMEOUT(20); MBED_HOSTTEST_SELECT(default_auto); MBED_HOSTTEST_DESCRIPTION(Mail messaging); MBED_HOSTTEST_START("RTOS_6"); Thread thread(send_thread, NULL, osPriorityNormal, STACK_SIZE); bool result = true; int result_counter = 0; while (true) { osEvent evt = mail_box.get(); if (evt.status == osEventMail) { mail_t *mail = (mail_t*)evt.value.p; const float expected_voltage = CREATE_VOLTAGE(mail->counter); const float expected_current = CREATE_CURRENT(mail->counter); // Check using macros if received values correspond to values sent via queue bool expected_values = (expected_voltage == mail->voltage) && (expected_current == mail->current); result = result && expected_values; const char *result_msg = expected_values ? "OK" : "FAIL"; printf("%3d %.2fV %.2fA ... [%s]\r\n", mail->counter, mail->voltage, mail->current, result_msg); mail_box.free(mail); if (result == false || ++result_counter == QUEUE_SIZE) { break; } } } MBED_HOSTTEST_RESULT(result); return 0; } #elif defined(TEST_90_TIMER) DigitalOut LEDs[4] = { DigitalOut(LED1), DigitalOut(LED2), DigitalOut(LED3), DigitalOut(LED4) }; void print_char(char c = '*') { printf("%c", c); fflush(stdout); } void blink(void const *n) { static int counter = 0; const int led_id = int(n); LEDs[led_id] = !LEDs[led_id]; if (++counter == 75) { print_char(); counter = 0; } } int main(void) { MBED_HOSTTEST_TIMEOUT(15); MBED_HOSTTEST_SELECT(wait_us_auto); MBED_HOSTTEST_DESCRIPTION(Timer); MBED_HOSTTEST_START("RTOS_7"); RtosTimer led_1_timer(blink, osTimerPeriodic, (void *)0); RtosTimer led_2_timer(blink, osTimerPeriodic, (void *)1); RtosTimer led_3_timer(blink, osTimerPeriodic, (void *)2); RtosTimer led_4_timer(blink, osTimerPeriodic, (void *)3); led_1_timer.start(200); led_2_timer.start(100); led_3_timer.start(50); led_4_timer.start(25); Thread::wait(osWaitForever); } #elif defined(TEST_91_ISR) #define QUEUE_SIZE 5 #define THREAD_DELAY 250 #define QUEUE_PUT_ISR_VALUE 128 #define QUEUE_PUT_THREAD_VALUE 127 /* * The stack size is defined in cmsis_os.h mainly dependent on the underlying toolchain and * the C standard library. For GCC, ARM_STD and IAR it is defined with a size of 2048 bytes * and for ARM_MICRO 512. Because of reduce RAM size some targets need a reduced stacksize. */ #if defined(TARGET_STM32L053R8) || defined(TARGET_STM32L053C8) #define STACK_SIZE DEFAULT_STACK_SIZE/4 #elif (defined(TARGET_STM32F030R8)) && defined(TOOLCHAIN_IAR) #define STACK_SIZE DEFAULT_STACK_SIZE/2 #else #define STACK_SIZE DEFAULT_STACK_SIZE #endif Queue<uint32_t, QUEUE_SIZE> queue; DigitalOut myled(LED1); void queue_isr() { queue.put((uint32_t*)QUEUE_PUT_ISR_VALUE); myled = !myled; } void queue_thread(void const *argument) { while (true) { queue.put((uint32_t*)QUEUE_PUT_THREAD_VALUE); Thread::wait(THREAD_DELAY); } } int main (void) { MBED_HOSTTEST_TIMEOUT(20); MBED_HOSTTEST_SELECT(default_auto); MBED_HOSTTEST_DESCRIPTION(ISR (Queue)); MBED_HOSTTEST_START("RTOS_8"); Thread thread(queue_thread, NULL, osPriorityNormal, STACK_SIZE); Ticker ticker; ticker.attach(queue_isr, 1.0); int isr_puts_counter = 0; bool result = true; while (true) { osEvent evt = queue.get(); if (evt.status != osEventMessage) { printf("QUEUE_GET: Status(0x%02X) ... [FAIL]\r\n", evt.status); result = false; break; } else { printf("QUEUE_GET: Value(%u) ... [OK]\r\n", evt.value.v); if (evt.value.v == QUEUE_PUT_ISR_VALUE) { isr_puts_counter++; } if (isr_puts_counter >= QUEUE_SIZE) { break; } } } MBED_HOSTTEST_RESULT(result); return 0; } #endif