OCEOS Tutorials
Revision as of 17:34, 7 March 2022 by Dtimofejevs (talk | contribs) (→Tutorial 5 – Using dataq with timed action)
Tutorials
Introduction
This section presents some typical real-time tasks and how they can be addressed using OCEOS.
Getting started
Section 9.5 provides guidance on how to structure an OCEOS application. The file asw.c provided with OCEOS is a simple example.
The directives to initialise and start OCEOS are:
- application_init – Initialise fixed data and start system timer(s)
- oceos_task_create - Create task setting priority, no of jobs, ..etc.
- oceos_init_finish – Initilise dynamic data area
- oceos_start – Start the scheduler and pass control to first task
After steps 1 to 4 above tasks implement application functionality. If mutexes, semaphores, or dataqs are required they are also created at step 2.
Note: it is mandatory to create the number of mutexes, semaphores, and dataqs declared otherwise oceos_init_finish() will return an error.
Tutorials
Tutorial 1 – Starting tasks
This exercise demonstrates starting tasks with different priorities.
- Two tasks, one higher priority (i.e. lower priority value), one lower priority (i.e. higher priority value. Each task allowed to have up to two concurrent jobs.
- Each task outputs a message when it starts, another message when it exits.
- Start OCEOS with the low priority task.
- This starts the high priority task and then exits.
- The high priority task starts the low priority tasks and exits.
For code example see below.
tut.h
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #ifndef TUT1_H_
19 #define TUT1_H_
20
21 /* Sample Task names - all here start with t_ to help avoid name confusion */
22 enum TASK_NAME{
23 t_0, // High priority task
24 t_1 // Low priority task
25 };
26
27 char* nullPtr = ""; // Need pointer to pass to oceos_start
28 void (*nullFun)(void *); // Null function
29
30 /*
31 * APPLICATION FUNCTION DECLARATIONS
32 */
33 void fun0(void *);
34 void fun1(void *);
35
36 #endif /* TUT1_H_ */
oceos_config.h
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #ifndef INCLUDE_OCEOS_CONFIG_H_
19 #define INCLUDE_OCEOS_CONFIG_H_
20
21 // 1: Includes OCEOS main header file
22 #include "oceos.h"
23 //----------------------------------------------------------------------------
24 // 2: Number of Log entries.
25 #define NUMBER_OF_LOG_ENTRIES 64 // 16 to 1024, default 64
26 //----------------------------------------------------------------------------
27 // 3: Number of tasks
28 #define NUMBER_OF_TASKS 2 // 1 to 255
29 //----------------------------------------------------------------------------
30 // 4: Number of ready queue entries, 0 to 254, see manual( MUST BE UPDATED BY USER);
31 // Defaults to number of tasks, as each task should have aa least one job;
32 // If Number of ready Q entries larger that number of total jobs => defaults to number of total jobs
33 #define NUMBER_OF_READYQ_ENTRIES NUMBER_OF_TASKS * 2
34 //----------------------------------------------------------------------------
35 // 5: Number of Mutexes
36 #define NUMBER_OF_MUTEXES 0 // 0 to 63
37 //----------------------------------------------------------------------------
38 // 6: Number of Semaphores
39 #define NUMBER_OF_SEMAPHORES 0 // 0 to 63
40 //----------------------------------------------------------------------------
41 // 7: Number of Data Qs
42 #define NUMBER_OF_DATAQS 0 // 0 to 63
43 //----------------------------------------------------------------------------
44 // 8: LOG data array size
45 #define LOG_DATA_ARRAY_SIZE_U32S 0x88// Calculated value. Read manual
46 //----------------------------------------------------------------------------
47 // 9: FIXED data array size
48 #define FIXED_DATA_ARRAY_SIZE_U32S 0x32// Calculated value. Read manual
49 //----------------------------------------------------------------------------
50 // 10: DYNAMIC data array size
51 #define DYN_DATA_ARRAY_SIZE_U32S 0x33// Calculated value. Read manual
52 //----------------------------------------------------------------------------
53 // 11: Timed Actions
54 #define NUMBER_OF_ACTION_ENTRIES 0 // User-modify field
55 //----------------------------------------------------------------------------
56 // 12: Log entries base 2
57 #define CS_LOG_DEF_ENTRIES_BASE2 0
58 //----------------------------------------------------------------------------
59 // 13: OCEOS stack start Address
60 #define OCEOS_STACK_START_ADDRESS 0
61 //----------------------------------------------------------------------------
62 // 14: OCEOS stack end address
63 #define OCEOS_STACK_LOW_BOUND_ADDRESS 0
64 //----------------------------------------------------------------------------
65 /**
66 * Target specific configurations
67 */
68 /*
69 * ARM specific configurations
70 */
71 #ifdef __SAM3X8E__
72 #ifndef BSP_SYSFREQ
73 #define BSP_SYSFREQ 84 // ARM target frequency in Mhz
74 #endif
75 #endif
76 #ifdef __SAMV71Q21__
77 #ifndef BSP_SYSFREQ
78 #define BSP_SYSFREQ 300 // ARM target frequency in Mhz
79 #endif
80 #endif
81 #ifdef __VA41620__
82 #ifndef BSP_SYSFREQ
83 #define BSP_SYSFREQ 100 // ARM target frequency in Mhz
84 #endif
85 #endif
86 //--------------------------------------------------------------------
87 // User defined function to deal with system errors
88 void oceos_on_error(void);
89 //---------------------------------------------------------------------
90 // User defined function to deal with log 2/3 full
91 void oceos_on_full_log(void);
92 //---------------------------------------------------------------------
93 extern U32_t log_data[];
94 extern U32_t fixed_data[];
95 extern U32_t dynamic_data[];
96 extern const unsigned int __oceos_bsp_sysfreq;
97 /**
98 * Initialize OCEOS with user configurations
99 */
100 int application_init(void);
101 #endif /* INCLUDE_OCEOS_CONFIG_H_ */
oceos_config.c
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #include <stdio.h>
19 #include "oceos_config.h"
20
21 /*
22 * OCEOS INTERNAL DATA STORAGE
23 *
24 * This application defines arrays to hold OCEOS internal data.
25 * The array sizes are provided by DMON by running "oceos info" command:</br>
26 * *Set all three arrays to guessed max zise, run application for the first time and exit.</br>
27 * *Run DMON command "oceos info" to get size for each array.</br>
28 * *Update array sizes below
29 */
30 U32_t log_data[LOG_DATA_ARRAY_SIZE_U32S];
31
32 U32_t fixed_data[FIXED_DATA_ARRAY_SIZE_U32S] = {0}; // will be in data segment
33
34 U32_t dynamic_data[DYN_DATA_ARRAY_SIZE_U32S];
35
36 const unsigned int __oceos_bsp_sysfreq = BSP_SYSFREQ * 1000 * 1000;// TODO
37
38 static BOOLE_t log_full_was_called = FALSE;
39
40 /**
41 * Must be defined if Application is using :
42 * Dataq with timeout
43 * Semaphore with timeout
44 * Timed Actions
45 */
46 /*
47 * Set up the application configuration structure and pass it to oceos_init
48 * (done this way the memory used for the structure is returned automatically)
49 */
50
51 int application_init(){
52
53 /*
54 * Create the application configuration structure
55 */
56 struct application_configuration app_config = {0};
57
58 /*
59 * Fill in the application parameters
60 */
61 app_config.log_address = (adrs_t)log_data; // required
62 app_config.fixed_data_address = (adrs_t)fixed_data; // required
63 app_config.dynamic_data_address = (adrs_t)dynamic_data; // required
64
65 app_config.stack_start_address = OCEOS_STACK_START_ADDRESS; // 0 => no check
66 app_config.stack_lower_bound_address = OCEOS_STACK_LOW_BOUND_ADDRESS; // 0 => no check
67
68 app_config.system_error_function = &oceos_on_error; // NULL => ignore
69 app_config.log_full_function = &oceos_on_full_log; // NULL => ignore
70 // used in setting up system log and fixed data array
71 app_config.log_number_of_entries = NUMBER_OF_LOG_ENTRIES; // 0 => use default
72
73 app_config.number_of_tasks = NUMBER_OF_TASKS; // >= 1
74 app_config.number_of_readyQ_entries = NUMBER_OF_READYQ_ENTRIES; // 0 => calculate size
75
76 app_config.number_of_mutexes = NUMBER_OF_MUTEXES;
77 app_config.number_of_counting_semaphores = NUMBER_OF_SEMAPHORES;
78 app_config.number_of_data_queues = NUMBER_OF_DATAQS;
79
80 app_config.timed_actions_queue_size = NUMBER_OF_ACTION_ENTRIES;
81 app_config.CS_log_entries_base2 = CS_LOG_DEF_ENTRIES_BASE2;
82 app_config.use_oceos_system_time = TRUE;
83
84 // initialise OCEOS
85 enum DIRECTIVE_STATUS status;
86 status = oceos_init(app_config);
87
88 if (SUCCESSFUL == status) {
89 return 1;
90 } else {
91 printf("\n oceos_init failure\n");
92 return -1;
93 } // else
94 } // application_init()
95 /**
96 * User to implement in case of system error;
97 * Comment it out if not used and set field system_error_function in app_config to NULL
98 */
99 void oceos_on_error() {
100 return;
101 }
102 /**
103 * User to implement in case of system log is 2/3 full;
104 * Comment it out if not used and set field log_full_function in app_config to NULL
105 */
106 void oceos_on_full_log(){
107 log_full_was_called = TRUE;
108 return;
109 }
tut1.c
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include "tut1.h" // application header
21 #include "oceos_config.h" // OCEOS header
22
23 int main(void) {
24 int status;
25
26 /*
27 * Initialise the application configuration and OCEOS
28 *
29 * This application function creates the application configuration
30 * and passes it to oceos_init(), which initialises the fixed data
31 * and enables the system log
32 */
33 if (!application_init()) {
34 //LOG
35 return -1;
36 }
37
38 // Create Main task to
39 if (oceos_task_create(t_0,// taskID, used as index, must be in range 0 to 254
40 100,// priority, must be in range 1 to 254, lower value is higher priority
41 100, // threshold, must be in range 1 to task priority
42 2, // jobs_max, must be in range 1 to 15
43 0,// FALSE -> floating point hardware not used by task
44 1, // FALSE -> task initially not enabled
45 fun0, // main body of task
46 nullFun, // task end function
47 0,// time_deadline, must finish no later than this after start, 0 => ignore
48 0 // minimum time expected between start requests, 0 => no restriction
49 ) != SUCCESSFUL)
50 return 1;
51
52 if (oceos_task_create(t_1, 200, 200, 2, 0, 1, fun1, nullFun, 0, 0)
53 != SUCCESSFUL)
54 return 2;
55
56 /*
57 * Finish initialising OCEOS and setting up the fixed data
58 */
59 status = oceos_init_finish();
60 if (SUCCESSFUL != status) {
61 return 3;
62 } // if
63
64 /*
65 * Start OCEOS scheduling
66 *
67 * The OCEOS fixed data provides all the information required.
68 *
69 * If a valid task is specified, it is started and passed the pointer.
70 * Otherwise the system is put in sleep mode
71 */
72 status = oceos_start(fixed_data, t_1, (void*) nullPtr); // Start OCEOS with lower prioroty task
73 return status;
74 } // main
75
76 /*
77 * Application code functions, functions declared in asw.h
78 */
79 void fun0(void *ptr) {
80 printf("Entered high priority task\n");
81 oceos_task_start(t_1, ptr);
82 printf("Leaving high priority task\n");
83 return;
84 } // fun0()
85
86 void fun1(void *ptr) {
87 printf("Entered low priority task\n");
88 oceos_task_start(t_0, ptr);
89 printf("Leaving low priority task\n");
90 return;
91 } // fun1()
Tutorial 2 – Using a mutex
This exercise will familiarise the developer with the use a mutexes.
- Two tasks as before.
- One mutex. Note the priority ceiling of the mutex.
- Both tasks output message when they get the mutex and when they return it
- Start OCEOS with the low priority task
- This grabs mutex, then starts high priority task
- Low priority task returns mutex then exits
- High priority task returns mutex, start low priority task and exits
For code example see example below:
tut2.h
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #ifndef TUT2_H_
19 #define TUT2_H_
20
21 /* Sample Task names - all here start with t_ to help avoid name confusion */
22 enum TASK_NAME{
23 t_0, // High priority task
24 t_1 // Low priority task
25 };
26 /* Sample Mutex names - all here start with m_ to help avoid name confusion */
27 enum MUTEX_NAME{
28 m_0
29 };
30 char* nullPtr = ""; // Need pointer to pass to oceos_start
31 void (*nullFun)(void *); // Null function
32
33 /*
34 * APPLICATION FUNCTION DECLARATIONS
35 */
36 void fun0(void *);
37 void fun1(void *);
38
39 #endif /* TUT2_H_ */
oceos_config.h
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #ifndef INCLUDE_OCEOS_CONFIG_H_
19 #define INCLUDE_OCEOS_CONFIG_H_
20
21 // 1: Includes OCEOS main header file
22 #include "oceos.h"
23 //----------------------------------------------------------------------------
24 // 2: Number of Log entries.
25 #define NUMBER_OF_LOG_ENTRIES 64 // 16 to 1024, default 64
26 //----------------------------------------------------------------------------
27 // 3: Number of tasks
28 #define NUMBER_OF_TASKS 2 // 1 to 255
29 //----------------------------------------------------------------------------
30 // 4: Number of ready queue entries, 0 to 254, see manual( MUST BE UPDATED BY USER);
31 // Defaults to number of tasks, as each task should have aa least one job;
32 // If Number of ready Q entries larger that number of total jobs => defaults to number of total jobs
33 #define NUMBER_OF_READYQ_ENTRIES NUMBER_OF_TASKS * 2
34 //----------------------------------------------------------------------------
35 // 5: Number of Mutexes
36 #define NUMBER_OF_MUTEXES 1 // 0 to 63
37 //----------------------------------------------------------------------------
38 // 6: Number of Semaphores
39 #define NUMBER_OF_SEMAPHORES 0 // 0 to 63
40 //----------------------------------------------------------------------------
41 // 7: Number of Data Qs
42 #define NUMBER_OF_DATAQS 0 // 0 to 63
43 //----------------------------------------------------------------------------
44 // 8: LOG data array size
45 #define LOG_DATA_ARRAY_SIZE_U32S 0x88// Calculated value. Read manual
46 //----------------------------------------------------------------------------
47 // 9: FIXED data array size
48 #define FIXED_DATA_ARRAY_SIZE_U32S 0x33// Calculated value. Read manual
49 //----------------------------------------------------------------------------
50 // 10: DYNAMIC data array size
51 #define DYN_DATA_ARRAY_SIZE_U32S 0x34// Calculated value. Read manual
52 //----------------------------------------------------------------------------
53 // 11: Timed Actions
54 #define NUMBER_OF_ACTION_ENTRIES 0 // User-modify field
55 //----------------------------------------------------------------------------
56 // 12: Log entries base 2
57 #define CS_LOG_DEF_ENTRIES_BASE2 0
58 //----------------------------------------------------------------------------
59 // 13: OCEOS stack start Address
60 #define OCEOS_STACK_START_ADDRESS 0
61 //----------------------------------------------------------------------------
62 // 14: OCEOS stack end address
63 #define OCEOS_STACK_LOW_BOUND_ADDRESS 0
64 //----------------------------------------------------------------------------
65 /**
66 * Target specific configurations
67 */
68 /*
69 * ARM specific configurations
70 */
71 #ifdef __SAM3X8E__
72 #ifndef BSP_SYSFREQ
73 #define BSP_SYSFREQ 84 // ARM target frequency in Mhz
74 #endif
75 #endif
76 #ifdef __SAMV71Q21__
77 #ifndef BSP_SYSFREQ
78 #define BSP_SYSFREQ 300 // ARM target frequency in Mhz
79 #endif
80 #endif
81 #ifdef __VA41620__
82 #ifndef BSP_SYSFREQ
83 #define BSP_SYSFREQ 100 // ARM target frequency in Mhz
84 #endif
85 #endif
86 //--------------------------------------------------------------------
87 // User defined function to deal with system errors
88 void oceos_on_error(void);
89 //---------------------------------------------------------------------
90 // User defined function to deal with log 2/3 full
91 void oceos_on_full_log(void);
92 //---------------------------------------------------------------------
93 extern U32_t log_data[];
94 extern U32_t fixed_data[];
95 extern U32_t dynamic_data[];
96 extern const unsigned int __oceos_bsp_sysfreq;
97 /**
98 * Initialize OCEOS with user configurations
99 */
100 int application_init(void);
101 #endif /* INCLUDE_OCEOS_CONFIG_H_ */
oceos_config.c
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #include <stdio.h>
19 #include "oceos_config.h"
20
21 /*
22 * OCEOS INTERNAL DATA STORAGE
23 *
24 * This application defines arrays to hold OCEOS internal data.
25 * The array sizes are provided by DMON by running "oceos info" command:</br>
26 * *Set all three arrays to guessed max zise, run application for the first time and exit.</br>
27 * *Run DMON command "oceos info" to get size for each array.</br>
28 * *Update array sizes below
29 */
30 U32_t log_data[LOG_DATA_ARRAY_SIZE_U32S];
31
32 U32_t fixed_data[FIXED_DATA_ARRAY_SIZE_U32S] = {0}; // will be in data segment
33
34 U32_t dynamic_data[DYN_DATA_ARRAY_SIZE_U32S];
35
36 const unsigned int __oceos_bsp_sysfreq = BSP_SYSFREQ * 1000 * 1000;// TODO
37
38 static BOOLE_t log_full_was_called = FALSE;
39
40 /**
41 * Must be defined if Application is using :
42 * Dataq with timeout
43 * Semaphore with timeout
44 * Timed Actions
45 */
46 /*
47 * Set up the application configuration structure and pass it to oceos_init
48 * (done this way the memory used for the structure is returned automatically)
49 */
50
51 int application_init(){
52
53 /*
54 * Create the application configuration structure
55 */
56 struct application_configuration app_config = {0};
57
58 /*
59 * Fill in the application parameters
60 */
61 app_config.log_address = (adrs_t)log_data; // required
62 app_config.fixed_data_address = (adrs_t)fixed_data; // required
63 app_config.dynamic_data_address = (adrs_t)dynamic_data; // required
64
65 app_config.stack_start_address = OCEOS_STACK_START_ADDRESS; // 0 => no check
66 app_config.stack_lower_bound_address = OCEOS_STACK_LOW_BOUND_ADDRESS; // 0 => no check
67
68 app_config.system_error_function = &oceos_on_error; // NULL => ignore
69 app_config.log_full_function = &oceos_on_full_log; // NULL => ignore
70 // used in setting up system log and fixed data array
71 app_config.log_number_of_entries = NUMBER_OF_LOG_ENTRIES; // 0 => use default
72
73 app_config.number_of_tasks = NUMBER_OF_TASKS; // >= 1
74 app_config.number_of_readyQ_entries = NUMBER_OF_READYQ_ENTRIES; // 0 => calculate size
75
76 app_config.number_of_mutexes = NUMBER_OF_MUTEXES;
77 app_config.number_of_counting_semaphores = NUMBER_OF_SEMAPHORES;
78 app_config.number_of_data_queues = NUMBER_OF_DATAQS;
79
80 app_config.timed_actions_queue_size = NUMBER_OF_ACTION_ENTRIES;
81 app_config.CS_log_entries_base2 = CS_LOG_DEF_ENTRIES_BASE2;
82 app_config.use_oceos_system_time = TRUE;
83
84 // initialise OCEOS
85 enum DIRECTIVE_STATUS status;
86 status = oceos_init(app_config);
87
88 if (SUCCESSFUL == status) {
89 return 1;
90 } else {
91 printf("\n oceos_init failure\n");
92 return -1;
93 } // else
94 } // application_init()
95 /**
96 * User to implement in case of system error;
97 * Comment it out if not used and set field system_error_function in app_config to NULL
98 */
99 void oceos_on_error() {
100 return;
101 }
102 /**
103 * User to implement in case of system log is 2/3 full;
104 * Comment it out if not used and set field log_full_function in app_config to NULL
105 */
106 void oceos_on_full_log(){
107 log_full_was_called = TRUE;
108 return;
109 }
tut2.c
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include "tut2.h" // application header
21
22 /* N.B. Application header is included first */
23 #include "oceos_config.h" // OCEOS header for this application
24 #include "mutex.h"
25
26 int main(void) {
27 int status;
28
29 /*
30 * Initialise the application configuration and OCEOS
31 *
32 * This application function creates the application configuration
33 * and passes it to oceos_init(), which initialises the fixed data
34 * and enables the system log
35 */
36 if (!application_init()) {
37 //LOG
38 return -1;
39 }
40
41 // Create Main task to
42 if (oceos_task_create(t_0,// taskID, used as index, must be in range 0 to 254
43 100,// priority, must be in range 1 to 254, lower value is higher priority
44 100, // threshold, must be in range 1 to task priority
45 2, // jobs_max, must be in range 1 to 15
46 0,// FALSE -> floating point hardware not used by task
47 1, // FALSE -> task initially not enabled
48 fun0, // main body of task
49 nullFun, // task end function
50 0,// time_deadline, must finish no later than this after start, 0 => ignore
51 0 // minimum time expected between start requests, 0 => no restriction
52 ) != SUCCESSFUL)
53 return 1;
54
55 if (oceos_task_create(t_1, 200, 200, 2, 0, 1, fun1, nullFun, 0, 0)
56 != SUCCESSFUL)
57 return 2;
58
59 if (oceos_mutex_create(m_0, 100) != SUCCESSFUL) // Create mutex with ceiling of highest priority task using it
60 return 3;
61
62 /*
63 * Finish initialising OCEOS and setting up the fixed data
64 */
65 status = oceos_init_finish();
66 if (SUCCESSFUL != status) {
67 return 4;
68 } // if
69
70 /*
71 * Start OCEOS scheduling
72 *
73 * The OCEOS fixed data provides all the information required.
74 *
75 * If a valid task is specified, it is started and passed the pointer.
76 * Otherwise the system is put in sleep mode
77 */
78 status = oceos_start(fixed_data, t_1, (void*) nullPtr); // Start OCEOS with lower prioroty task
79 return status;
80 } // main
81
82 /*
83 * Application code functions, functions declared in asw.h
84 */
85 void fun0(void *ptr) {
86 if (oceos_mutex_wait(m_0) != SUCCESSFUL) {
87 printf("Error from high priority task getting mutex\n");
88 } else {
89 printf("high priority task got mutex\n");
90 }
91 oceos_task_start(t_1, ptr); // Start lower priority task
92
93 if (oceos_mutex_signal(m_0) != SUCCESSFUL) {
94 printf("Error from high priority task releasing mutex\n");
95 } else {
96 printf("High priority task released mutex\n");
97 }
98 return;
99 } // fun0()
100
101 void fun1(void *ptr) {
102 if (oceos_mutex_wait(m_0) != SUCCESSFUL) {
103 printf("Error from low priority task getting mutex\n");
104 } else {
105 printf("Low priority task got mutex\n");
106 }
107 oceos_task_start(t_0, ptr); // Start higher priority task
108
109 if (oceos_mutex_signal(m_0) != SUCCESSFUL) {
110 printf("Error from low priority task releasing mutex\n");
111 } else {
112 printf("Low priority task released mutex\n");
113 }
114 return;
115 } // fun1()
Tutorial 3 – Using Semaphores
Semaphores can be used to synchronise task actions as in this exercise.
- Three tasks this time, one high priority and the other two with the same lower priority
- Two counting semaphores, one initially 0, one initially 4, called ‘items’ and ‘spaces’
- First task starts second and third tasks
- Second task loops
- wait_restart spaces
- signal items
- Output ‘item done’ message
- Third task loops
- wait_restart items
- Output ‘got item’ message
- signal spaces
For code example see below:
tut3.h
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #ifndef TUT3_H_
19 #define TUT3_H_
20 /* Sample Task names - all here start with t_ to help avoid name confusion */
21 enum TASK_NAME{
22 t_0, // Task to start other two
23 t_1, // consumer task
24 t_2 // consumer task
25
26 };
27 /* Sample Counting Semaphore names - all here start with s_ to help avoid name confusion */
28 enum SEM_NAME{
29 items, // Semaphore called items
30 spaces // Semaphore called spaces
31 };
32 char* nullPtr = ""; // Need pointer to pass to oceos_start
33 void (*nullFun)(void *); // Null function
34
35 /*
36 * APPLICATION FUNCTION DECLARATIONS
37 */
38 void fun0(void *);
39 void fun1(void *);
40 void fun2(void *);
41
42 #endif /* TUT3_H_ */
oceos_config.h
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #ifndef INCLUDE_OCEOS_CONFIG_H_
19 #define INCLUDE_OCEOS_CONFIG_H_
20
21 // 1: Includes OCEOS main header file
22 #include "oceos.h"
23 //----------------------------------------------------------------------------
24 // 2: Number of Log entries.
25 #define NUMBER_OF_LOG_ENTRIES 64 // 16 to 1024, default 64
26 //----------------------------------------------------------------------------
27 // 3: Number of tasks
28 #define NUMBER_OF_TASKS 3 // 1 to 255
29 //----------------------------------------------------------------------------
30 // 4: Number of ready queue entries, 0 to 254, see manual( MUST BE UPDATED BY USER);
31 // Defaults to number of tasks, as each task should have aa least one job;
32 // If Number of ready Q entries larger that number of total jobs => defaults to number of total jobs
33 #define NUMBER_OF_READYQ_ENTRIES NUMBER_OF_TASKS * 2
34 //----------------------------------------------------------------------------
35 // 5: Number of Mutexes
36 #define NUMBER_OF_MUTEXES 0 // 0 to 63
37 //----------------------------------------------------------------------------
38 // 6: Number of Semaphores
39 #define NUMBER_OF_SEMAPHORES 2 // 0 to 63
40 //----------------------------------------------------------------------------
41 // 7: Number of Data Qs
42 #define NUMBER_OF_DATAQS 0 // 0 to 63
43 //----------------------------------------------------------------------------
44 // 8: LOG data array size
45 #define LOG_DATA_ARRAY_SIZE_U32S 0x88// Calculated value. Read manual
46 //----------------------------------------------------------------------------
47 // 9: FIXED data array size
48 #define FIXED_DATA_ARRAY_SIZE_U32S 0x3a// Calculated value. Read manual
49 //----------------------------------------------------------------------------
50 // 10: DYNAMIC data array size
51 #define DYN_DATA_ARRAY_SIZE_U32S 0x65// Calculated value. Read manual
52 //----------------------------------------------------------------------------
53 // 11: Timed Actions
54 #define NUMBER_OF_ACTION_ENTRIES 0 // User-modify field
55 //----------------------------------------------------------------------------
56 // 12: Log entries base 2
57 #define CS_LOG_DEF_ENTRIES_BASE2 0
58 //----------------------------------------------------------------------------
59 // 13: OCEOS stack start Address
60 #define OCEOS_STACK_START_ADDRESS 0
61 //----------------------------------------------------------------------------
62 // 14: OCEOS stack end address
63 #define OCEOS_STACK_LOW_BOUND_ADDRESS 0
64 //----------------------------------------------------------------------------
65 /**
66 * Target specific configurations
67 */
68 /*
69 * ARM specific configurations
70 */
71 #ifdef __SAM3X8E__
72 #ifndef BSP_SYSFREQ
73 #define BSP_SYSFREQ 84 // ARM target frequency in Mhz
74 #endif
75 #endif
76 #ifdef __SAMV71Q21__
77 #ifndef BSP_SYSFREQ
78 #define BSP_SYSFREQ 300 // ARM target frequency in Mhz
79 #endif
80 #endif
81 #ifdef __VA41620__
82 #ifndef BSP_SYSFREQ
83 #define BSP_SYSFREQ 100 // ARM target frequency in Mhz
84 #endif
85 #endif
86 //--------------------------------------------------------------------
87 // User defined function to deal with system errors
88 void oceos_on_error(void);
89 //---------------------------------------------------------------------
90 // User defined function to deal with log 2/3 full
91 void oceos_on_full_log(void);
92 //---------------------------------------------------------------------
93 extern U32_t log_data[];
94 extern U32_t fixed_data[];
95 extern U32_t dynamic_data[];
96 extern const unsigned int __oceos_bsp_sysfreq;
97 /**
98 * Initialize OCEOS with user configurations
99 */
100 int application_init(void);
101 #endif /* INCLUDE_OCEOS_CONFIG_H_ */
oceos_config.c
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #include <stdio.h>
19 #include "oceos_config.h"
20
21 /*
22 * OCEOS INTERNAL DATA STORAGE
23 *
24 * This application defines arrays to hold OCEOS internal data.
25 * The array sizes are provided by DMON by running "oceos info" command:</br>
26 * *Set all three arrays to guessed max zise, run application for the first time and exit.</br>
27 * *Run DMON command "oceos info" to get size for each array.</br>
28 * *Update array sizes below
29 */
30 U32_t log_data[LOG_DATA_ARRAY_SIZE_U32S];
31
32 U32_t fixed_data[FIXED_DATA_ARRAY_SIZE_U32S] = {0}; // will be in data segment
33
34 U32_t dynamic_data[DYN_DATA_ARRAY_SIZE_U32S];
35
36 const unsigned int __oceos_bsp_sysfreq = BSP_SYSFREQ * 1000 * 1000;// TODO
37
38 static BOOLE_t log_full_was_called = FALSE;
39
40 /**
41 * Must be defined if Application is using :
42 * Dataq with timeout
43 * Semaphore with timeout
44 * Timed Actions
45 */
46 /*
47 * Set up the application configuration structure and pass it to oceos_init
48 * (done this way the memory used for the structure is returned automatically)
49 */
50
51 int application_init(){
52
53 /*
54 * Create the application configuration structure
55 */
56 struct application_configuration app_config = {0};
57
58 /*
59 * Fill in the application parameters
60 */
61 app_config.log_address = (adrs_t)log_data; // required
62 app_config.fixed_data_address = (adrs_t)fixed_data; // required
63 app_config.dynamic_data_address = (adrs_t)dynamic_data; // required
64
65 app_config.stack_start_address = OCEOS_STACK_START_ADDRESS; // 0 => no check
66 app_config.stack_lower_bound_address = OCEOS_STACK_LOW_BOUND_ADDRESS; // 0 => no check
67
68 app_config.system_error_function = &oceos_on_error; // NULL => ignore
69 app_config.log_full_function = &oceos_on_full_log; // NULL => ignore
70 // used in setting up system log and fixed data array
71 app_config.log_number_of_entries = NUMBER_OF_LOG_ENTRIES; // 0 => use default
72
73 app_config.number_of_tasks = NUMBER_OF_TASKS; // >= 1
74 app_config.number_of_readyQ_entries = NUMBER_OF_READYQ_ENTRIES; // 0 => calculate size
75
76 app_config.number_of_mutexes = NUMBER_OF_MUTEXES;
77 app_config.number_of_counting_semaphores = NUMBER_OF_SEMAPHORES;
78 app_config.number_of_data_queues = NUMBER_OF_DATAQS;
79
80 app_config.timed_actions_queue_size = NUMBER_OF_ACTION_ENTRIES;
81 app_config.CS_log_entries_base2 = CS_LOG_DEF_ENTRIES_BASE2;
82 app_config.use_oceos_system_time = TRUE;
83
84 // initialise OCEOS
85 enum DIRECTIVE_STATUS status;
86 status = oceos_init(app_config);
87
88 if (SUCCESSFUL == status) {
89 return 1;
90 } else {
91 printf("\n oceos_init failure\n");
92 return -1;
93 } // else
94 } // application_init()
95 /**
96 * User to implement in case of system error;
97 * Comment it out if not used and set field system_error_function in app_config to NULL
98 */
99 void oceos_on_error() {
100 return;
101 }
102 /**
103 * User to implement in case of system log is 2/3 full;
104 * Comment it out if not used and set field log_full_function in app_config to NULL
105 */
106 void oceos_on_full_log(){
107 log_full_was_called = TRUE;
108 return;
109 }
tut3.c
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #include <stdio.h>
19 #include <stdlib.h>
20
21 /* N.B. Application header is included first */
22 #include "oceos_config.h" // OCEOS header for this application
23 #include "tut3.h" // application header
24 #include "semaphore.h"
25
26 int main(void) {
27 int status;
28 /*
29 * Initialise the application configuration and OCEOS
30 *
31 * This application function creates the application configuration
32 * and passes it to oceos_init(), which initialises the fixed data
33 * and enables the system log
34 */
35 if (!application_init()) {
36 //LOG
37 return -1;
38 }
39 // Create Main task to
40 if (oceos_task_create(t_0,// taskID, used as index, must be in range 0 to 254
41 10, // priority, must be in range 1 to 254, lower value is higher priority
42 10, // threshold, must be in range 1 to task priority
43 1, // jobs_max, must be in range 1 to 15
44 0,// FALSE -> floating point hardware not used by task
45 1, // FALSE -> task initially not enabled
46 fun0, // main body of task
47 nullFun, // task end function
48 0,// time_deadline, must finish no later than this after start, 0 => ignore
49 0 // minimum time expected between start requests, 0 => no restriction
50 ) != SUCCESSFUL)
51 return 1;
52
53 if (oceos_task_create(t_1, 100, 100, 1, 0, 1, fun1, nullFun, 0, 0)
54 != SUCCESSFUL)
55 return 2;
56
57 if (oceos_task_create(t_2, 100, 100, 1, 0, 1, fun2, nullFun, 0, 0)
58 != SUCCESSFUL)
59 return 3;
60
61 if (oceos_sem_create(items, 10, 0, 2, FALSE) != SUCCESSFUL)// items semaphore with max permits of 10, initial permits of 0, max jobs 2
62 return 4;
63
64 if (oceos_sem_create(spaces, 10, 4, 2, FALSE) != SUCCESSFUL) // spaces semaphore with max permits of 10, initial permits of 4, max jobs 2
65 return 4;
66 /*
67 * Finish initialising OCEOS and setting up the fixed data
68 */
69 status = oceos_init_finish();
70 if (SUCCESSFUL != status) {
71 return 6;
72 } // if
73 /*
74 * Start OCEOS scheduling
75 *
76 * The OCEOS fixed data provides all the information required.
77 *
78 * If a valid task is specified, it is started and passed the pointer.
79 * Otherwise the system is put in sleep mode
80 */
81 status = oceos_start(fixed_data, t_0, (void*) nullPtr); // Start OCEOS with task to start other tasks
82 return status;
83 } // main
84
85 /*
86 * Application code functions, functions declared in asw.h
87 */
88 void fun0(void *ptr) {
89 oceos_task_start(t_1, ptr); // Start consumer task
90 oceos_task_start(t_2, ptr); // Start consumer task
91 } // fun0()
92
93 void fun1(void *ptr) {
94 while (1) { // loop forever
95 if (oceos_sem_wait_restart(items) != SUCCESSFUL) {
96 printf("Error from task t_0 task waiting items\n");
97 }
98 printf("Got item\n");
99 if (oceos_sem_signal(spaces) != SUCCESSFUL) {
100 printf("Error from task t_0 signalling spaces\n");
101 }
102 }
103 } // fun0()
104
105 void fun2(void *ptr) {
106 while (1) { // loop forever
107 if (oceos_sem_wait_restart(spaces) != SUCCESSFUL) {
108 printf("Error from task t_1 task waiting spaces\n");
109 }
110 if (oceos_sem_signal(items) != SUCCESSFUL) {
111 printf("Error from task t_1 signalling items\n");
112 } else {
113 printf("Item done\n");
114 }
115 }
116 return;
117 } // fun1()
Tutorial 4 – Timer interrupt starts task
This exercise introduces the use of timer interrupts.
- Create one task
- Set a timer to interrupt every 2 seconds
- Set timer handler to start task
- Task outputs message, then exits
For code example see below:
tut4.h
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #ifndef TUT4_H_
19 #define TUT4_H_
20 /* Sample Task names - all here start with t_ to help avoid name confusion */
21 enum TASK_NAME{
22 t_0, // Task to setup interrupt
23 t_1 // Task to be executed by interrupt routine
24
25 };
26 /*
27 * APPLICATION FUNCTION DECLARATIONS
28 */
29 void fun0(void *);
30 void fun1(void *);
31 void start_task(void *arg, int source);
32 void timer_setup(void);
33
34 #endif /* TUT4_H_ */
oceos_config.h
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #ifndef INCLUDE_OCEOS_CONFIG_H_
19 #define INCLUDE_OCEOS_CONFIG_H_
20
21 // 1: Includes OCEOS main header file
22 #include "oceos.h"
23 //----------------------------------------------------------------------------
24 // 2: Number of Log entries.
25 #define NUMBER_OF_LOG_ENTRIES 64 // 16 to 1024, default 64
26 //----------------------------------------------------------------------------
27 // 3: Number of tasks
28 #define NUMBER_OF_TASKS 2 // 1 to 255
29 //----------------------------------------------------------------------------
30 // 4: Number of ready queue entries, 0 to 254, see manual( MUST BE UPDATED BY USER);
31 // Defaults to number of tasks, as each task should have aa least one job;
32 // If Number of ready Q entries larger that number of total jobs => defaults to number of total jobs
33 #define NUMBER_OF_READYQ_ENTRIES NUMBER_OF_TASKS + 1
34 //----------------------------------------------------------------------------
35 // 5: Number of Mutexes
36 #define NUMBER_OF_MUTEXES 0 // 0 to 63
37 //----------------------------------------------------------------------------
38 // 6: Number of Semaphores
39 #define NUMBER_OF_SEMAPHORES 0 // 0 to 63
40 //----------------------------------------------------------------------------
41 // 7: Number of Data Qs
42 #define NUMBER_OF_DATAQS 0 // 0 to 63
43 //----------------------------------------------------------------------------
44 // 8: LOG data array size
45 #define LOG_DATA_ARRAY_SIZE_U32S 0x88// Calculated value. Read manual
46 //----------------------------------------------------------------------------
47 // 9: FIXED data array size
48 #define FIXED_DATA_ARRAY_SIZE_U32S 0x32// Calculated value. Read manual
49 //----------------------------------------------------------------------------
50 // 10: DYNAMIC data array size
51 #define DYN_DATA_ARRAY_SIZE_U32S 0x29// Calculated value. Read manual
52 //----------------------------------------------------------------------------
53 // 11: Timed Actions
54 #define NUMBER_OF_ACTION_ENTRIES 0 // User-modify field
55 //----------------------------------------------------------------------------
56 // 12: Log entries base 2
57 #define CS_LOG_DEF_ENTRIES_BASE2 0
58 //----------------------------------------------------------------------------
59 // 13: OCEOS stack start Address
60 #define OCEOS_STACK_START_ADDRESS 0
61 //----------------------------------------------------------------------------
62 // 14: OCEOS stack end address
63 #define OCEOS_STACK_LOW_BOUND_ADDRESS 0
64 //----------------------------------------------------------------------------
65 /**
66 * Target specific configurations
67 */
68 /*
69 * ARM specific configurations
70 */
71 #ifdef __SAM3X8E__
72 #ifndef BSP_SYSFREQ
73 #define BSP_SYSFREQ 84 // ARM target frequency in Mhz
74 #endif
75 #endif
76 #ifdef __SAMV71Q21__
77 #ifndef BSP_SYSFREQ
78 #define BSP_SYSFREQ 300 // ARM target frequency in Mhz
79 #endif
80 #endif
81 #ifdef __VA41620__
82 #ifndef BSP_SYSFREQ
83 #define BSP_SYSFREQ 100 // ARM target frequency in Mhz
84 #endif
85 #endif
86 //--------------------------------------------------------------------
87 // User defined function to deal with system errors
88 void oceos_on_error(void);
89 //---------------------------------------------------------------------
90 // User defined function to deal with log 2/3 full
91 void oceos_on_full_log(void);
92 //---------------------------------------------------------------------
93 extern U32_t log_data[];
94 extern U32_t fixed_data[];
95 extern U32_t dynamic_data[];
96 extern const unsigned int __oceos_bsp_sysfreq;
97 /**
98 * Initialize OCEOS with user configurations
99 */
100 int application_init(void);
101 #endif /* INCLUDE_OCEOS_CONFIG_H_ */
oceos_config.c
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #include <stdio.h>
19 #include "oceos_config.h"
20
21 /*
22 * OCEOS INTERNAL DATA STORAGE
23 *
24 * This application defines arrays to hold OCEOS internal data.
25 * The array sizes are provided by DMON by running "oceos info" command:</br>
26 * *Set all three arrays to guessed max zise, run application for the first time and exit.</br>
27 * *Run DMON command "oceos info" to get size for each array.</br>
28 * *Update array sizes below
29 */
30 U32_t log_data[LOG_DATA_ARRAY_SIZE_U32S];
31
32 U32_t fixed_data[FIXED_DATA_ARRAY_SIZE_U32S] = {0}; // will be in data segment
33
34 U32_t dynamic_data[DYN_DATA_ARRAY_SIZE_U32S];
35
36 const unsigned int __oceos_bsp_sysfreq = BSP_SYSFREQ * 1000 * 1000;// TODO
37
38 static BOOLE_t log_full_was_called = FALSE;
39
40 /**
41 * Must be defined if Application is using :
42 * Dataq with timeout
43 * Semaphore with timeout
44 * Timed Actions
45 */
46 /*
47 * Set up the application configuration structure and pass it to oceos_init
48 * (done this way the memory used for the structure is returned automatically)
49 */
50
51 int application_init(){
52
53 /*
54 * Create the application configuration structure
55 */
56 struct application_configuration app_config = {0};
57
58 /*
59 * Fill in the application parameters
60 */
61 app_config.log_address = (adrs_t)log_data; // required
62 app_config.fixed_data_address = (adrs_t)fixed_data; // required
63 app_config.dynamic_data_address = (adrs_t)dynamic_data; // required
64
65 app_config.stack_start_address = OCEOS_STACK_START_ADDRESS; // 0 => no check
66 app_config.stack_lower_bound_address = OCEOS_STACK_LOW_BOUND_ADDRESS; // 0 => no check
67
68 app_config.system_error_function = &oceos_on_error; // NULL => ignore
69 app_config.log_full_function = &oceos_on_full_log; // NULL => ignore
70 // used in setting up system log and fixed data array
71 app_config.log_number_of_entries = NUMBER_OF_LOG_ENTRIES; // 0 => use default
72
73 app_config.number_of_tasks = NUMBER_OF_TASKS; // >= 1
74 app_config.number_of_readyQ_entries = NUMBER_OF_READYQ_ENTRIES; // 0 => calculate size
75
76 app_config.number_of_mutexes = NUMBER_OF_MUTEXES;
77 app_config.number_of_counting_semaphores = NUMBER_OF_SEMAPHORES;
78 app_config.number_of_data_queues = NUMBER_OF_DATAQS;
79
80 app_config.timed_actions_queue_size = NUMBER_OF_ACTION_ENTRIES;
81 app_config.CS_log_entries_base2 = CS_LOG_DEF_ENTRIES_BASE2;
82 app_config.use_oceos_system_time = TRUE;
83
84 // initialise OCEOS
85 enum DIRECTIVE_STATUS status;
86 status = oceos_init(app_config);
87
88 if (SUCCESSFUL == status) {
89 return 1;
90 } else {
91 printf("\n oceos_init failure\n");
92 return -1;
93 } // else
94 } // application_init()
95 /**
96 * User to implement in case of system error;
97 * Comment it out if not used and set field system_error_function in app_config to NULL
98 */
99 void oceos_on_error() {
100 return;
101 }
102 /**
103 * User to implement in case of system log is 2/3 full;
104 * Comment it out if not used and set field log_full_function in app_config to NULL
105 */
106 void oceos_on_full_log(){
107 log_full_was_called = TRUE;
108 return;
109 }
arm_task_src.c
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include "tut4.h"
21 #include "oceos_config.h"
22
23 #if defined(__SAM3X8E__) || defined(__SAMV71Q21__)
24 #include "sam.h"
25
26 #define ENABLE_WAVE_MODE (0x1 << TC_CMR_WAVE_Pos)
27 #define TC_CMR_WAVE_SEL_Pos 13
28 #define SET_WAVE_SELECT (~(0x3 << TC_CMR_WAVE_SEL_Pos)) //00
29 #define TC_CMR_CPCSTOP_Pos 6
30 #define TC_CMR_CPCSTOP (0x1 << TC_CMR_CPCSTOP_Pos)
31
32 static Tc *timer_regs;
33 static TcChannel *tc;
34
35 #endif
36
37 /*
38 * Set up timer and register handler
39 */
40 void timer_setup(){
41
42 #ifdef __SAM3X8E__
43 // Enabling Peripheral Clocks
44 // REmove write protect
45 int pmc_was_enabled = 0;
46 if (0 != (PMC->PMC_WPMR & PMC_WPMR_WPEN)) {
47 PMC->PMC_WPMR = PMC_WPMR_WPKEY_PASSWD;
48 pmc_was_enabled = 1;
49 }
50 // Enable Clock
51 PMC->PMC_PCER0 |= PMC_PCER0_PID28;
52 // Enable write protect
53 if (pmc_was_enabled) {
54 PMC->PMC_WPMR = PMC_WPMR_WPKEY_PASSWD | PMC_WPMR_WPEN;
55 }
56
57 timer_regs = (Tc *)TC0;
58 tc = &(timer_regs->TC_CHANNEL[1]);
59
60 // Enable Wave Mode
61 tc->TC_CMR |= ENABLE_WAVE_MODE;
62 // Set WAVESEL to 00
63 tc->TC_CMR &= (U32_t)SET_WAVE_SELECT;
64 // Set TC_CMR_CPCSTOP and Clock input
65 tc->TC_CMR |= (TC_CMR_CPCSTOP | TC_CMR_TCCLKS_TIMER_CLOCK1); // MCK/8
66
67
68 // Set Block Clock
69 timer_regs->TC_BMR &= (U32_t)(~(1 << 1));
70 // Interrupt Enable
71 // Enable Timer interrupt (RC Compare)
72 tc->TC_IER = TC_IER_CPCS;
73
74 NVIC_EnableIRQ(TC1_IRQn);
75 // Set Highest Priority for interrupt number
76 NVIC_SetPriority(TC1_IRQn, 1);
77 float base_scaler = (float)(__oceos_bsp_sysfreq / 2) / 1000000.0f;
78
79 //tc->TC_RC = base_scaler * 0x3DC6C0;
80 tc->TC_RC = base_scaler * 1349;
81 // Enable clock
82 tc->TC_CCR = TC_CCR_CLKEN;
83
84 // Start clock
85 tc->TC_CCR = TC_CCR_SWTRG;
86 #endif
87 #ifdef __SAMV71Q21__
88 // Enabling Peripheral Clocks
89 // REmove write protect
90 int pmc_was_enabled = 0;
91 if (0 != (PMC->PMC_WPMR & PMC_WPMR_WPEN)) {
92 PMC->PMC_WPMR = PMC_WPMR_WPKEY_PASSWD;
93 pmc_was_enabled = 1;
94 }
95 // Enable Clock
96 PMC->PMC_PCER0 |= PMC_PCER0_PID24;
97 // Enable write protect
98 if (pmc_was_enabled) {
99 PMC->PMC_WPMR = PMC_WPMR_WPKEY_PASSWD | PMC_WPMR_WPEN;
100 }
101 timer_regs = (Tc *)TC0;
102 tc = &(timer_regs->TC_CHANNEL[1]);
103
104 // Enable Wave Mode
105 tc->TC_CMR |= ENABLE_WAVE_MODE;
106 // Set WAVESEL to 00
107 tc->TC_CMR &= (U32_t)SET_WAVE_SELECT;
108 // Set TC_CMR_CPCSTOP and Clock input
109 tc->TC_CMR |= (TC_CMR_CPCSTOP | TC_CMR_TCCLKS_TIMER_CLOCK5_Val); //
110
111 // Set Block Clock
112 timer_regs->TC_BMR &= (U32_t)(~(1 << 1));
113 // Interrupt Enable
114 // Enable Timer interrupt (RC Compare)
115 tc->TC_IER = TC_IER_CPCS;
116
117 NVIC_EnableIRQ(TC1_IRQn);
118 // Set Highest Priority for interrupt number
119 NVIC_SetPriority(TC1_IRQn, 1);
120
121 tc->TC_RC = 0x61a8;// 1s
122
123 // Enable clock
124 tc->TC_CCR = TC_CCR_CLKEN;
125
126 // Start clock
127 tc->TC_CCR = TC_CCR_SWTRG;
128 #endif
129 } // setup_timer()
130
131 void TC1_IRQHandler() {
132 #if defined(__SAM3X8E__) || defined(__SAMV71Q21__)
133 tc->TC_SR;// Read to remove pending bit
134 #endif
135 // Start task
136 oceos_task_start(t_1, NULL);
137
138 #if defined(__SAM3X8E__) || defined(__SAMV71Q21__)
139 tc->TC_CCR = TC_CCR_SWTRG;
140 #endif
141 }
tut4.c
1 /*
2 *********************************************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for
6 * ARM Microcontroller
7 *
8 * Example implementation of OCEOS
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 *
15 * Author: jfk
16 ********************************************************************************************************
17 */
18 #include <stdio.h>
19 #include <stdlib.h>
20
21 /* N.B. Application header is included first */
22 #include "oceos_config.h" // OCEOS header for this application
23 #include "tut4.h" // application header
24
25 volatile U32_t count_task_start = 0;
26
27 int main(void) {
28 int status;
29 /*
30 * Initialise the application configuration and OCEOS
31 *
32 * This application function creates the application configuration
33 * and passes it to oceos_init(), which initialises the fixed data
34 * and enables the system log
35 */
36 if (!application_init()) {
37 //LOG
38 return -1;
39 }
40 // Create Main task to
41 if (oceos_task_create(t_0,// taskID, used as index, must be in range 0 to 254
42 10, // priority, must be in range 1 to 254, lower value is higher priority
43 10, // threshold, must be in range 1 to task priority
44 1, // jobs_max, must be in range 1 to 15
45 0,// FALSE -> floating point hardware not used by task
46 1, // FALSE -> task initially not enabled
47 fun0, // main body of task
48 NULL, // task end function
49 0,// time_deadline, must finish no later than this after start, 0 => ignore
50 0 // minimum time expected between start requests, 0 => no restriction
51 ) != SUCCESSFUL)
52 return 1;
53
54 if (oceos_task_create(t_1, 100, 100, 1, 0, 1, fun1, NULL, 0, 0)
55 != SUCCESSFUL)
56 return 2;
57 /*
58 * Finish initialising OCEOS and setting up the fixed data
59 */
60 status = oceos_init_finish();
61 if (SUCCESSFUL != status) {
62 return 3;
63 } // if
64 /*
65 * Start OCEOS scheduling
66 *
67 * The OCEOS fixed data provides all the information required.
68 *
69 * If a valid task is specified, it is started and passed the pointer.
70 * Otherwise the system is put in sleep mode
71 */
72 status = oceos_start(fixed_data, t_0, NULL); // Start OCEOS
73 return status;
74 } // main
75
76 /*
77 * Task 0 starting point
78 */
79 void fun0(void *ptr) {
80 timer_setup();
81 } // fun0()
82 /**
83 * Task 1 starting point;
84 * Triggered from Timer IRQ handler
85 */
86 void fun1(void *ptr) {
87 printf("Task started : %u times \n", count_task_start);
88 count_task_start++;
89 } // fun1()
Tutorial 5 – Using dataq with timed action
This exercise introduces the use of dataq with timed action.
- Create functions to be used by tasks
- Create one struct – pointer to these will be placed on queues
- Set timeout period T
- Create configuration structure with above configuration values for fields
- Initialize OCEOS using oceos_init()
- Create two tasks
- Create two data queues
For code example see below:
tut5.h
1 /*
2 ******************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for ARM/SPARC
6 * Microcontroller
7 *
8 * Application Software Example Header File
9 *
10 *
11 * (c) Copyright 2021, O.C.E. Technology
12 * All Rights Reserved
13 *
14 * File : asw.h
15 * Author: Deniss Timofejevs <deniss.timofejevs@ocetechnology.com>
16 ******************************************************************************
17 */
18 #ifndef ASW_H
19 #define ASW_H
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <assert.h>
23 #include "oceos_config.h" // OCEOS header
24 #include "oceos_timer.h"
25 #include "system_log.h"
26 #include "dataq.h"
27
28 #define N0 1 // dataq_size
29 #define N1 1 // dataq_size
30 #define JOBS0 1 // pending q size
31 #define JOBS1 1 // pending q size
32 #define TIME_OUT 1000000 // timeout
33
34 /*
35 * APPLICATION FUNCTION DECLARATIONS
36 */
37 enum TASK_NAME{
38 t_consumer , // will have task ID 0
39 t_producer, // will have task ID 1
40 };
41 enum DATAQ_NAME{
42 queue_0, // will have dataq ID 0
43 queue_1, // will have dataq ID 1
44 };
45 void t_consumer_task(void);
46 void t_producer_task(void);
47
48 #endif /* ASW_H */
oceos_config.h
1 /*
2 * app_config.h
3 *
4 * Created on: 17 Feb 2020
5 * Author: Deniss Timofejevs <deniss.timofejevs@ocetechnology.com>
6 */
7
8 #ifndef INCLUDE_OCEOS_CONFIG_H_
9 #define INCLUDE_OCEOS_CONFIG_H_
10
11 // 1: Includes OCEOS main header file
12 #include "oceos.h"
13 //----------------------------------------------------------------------------
14 // 2: Number of Log entries.
15 #define NUMBER_OF_LOG_ENTRIES 16 // 16 to 1024, default 64
16 //----------------------------------------------------------------------------
17 // 3: Number of tasks
18 #define NUMBER_OF_TASKS 2 // 1 to 255
19 //----------------------------------------------------------------------------
20 // 4: Number of ready queue entries, 0 to 254, see manual( MUST BE UPDATED BY USER);
21 // Defaults to number of tasks, as each task should have aa least one job;
22 // If Number of ready Q entries larger that number of total jobs => defaults to number of total jobs
23 #define NUMBER_OF_READYQ_ENTRIES 3
24 //----------------------------------------------------------------------------
25 // 5: Number of Mutexes
26 #define NUMBER_OF_MUTEXES 0 // 0 to 63
27 //----------------------------------------------------------------------------
28 // 6: Number of Semaphores
29 #define NUMBER_OF_SEMAPHORES 0 // 0 to 63
30 //----------------------------------------------------------------------------
31 // 7: Number of Data Qs
32 #define NUMBER_OF_DATAQS 2 // 0 to 63
33 //----------------------------------------------------------------------------
34 // 8: LOG data array size
35 #define LOG_DATA_ARRAY_SIZE_U32S 0x28// Calculated value. Read manual
36 //----------------------------------------------------------------------------
37 // 9: FIXED data array size
38 #define FIXED_DATA_ARRAY_SIZE_U32S 0x34// Calculated value. Read manual
39 //----------------------------------------------------------------------------
40 // 10: DYNAMIC data array size
41 #define DYN_DATA_ARRAY_SIZE_U32S 0x46// Calculated value. Read manual
42 //----------------------------------------------------------------------------
43 // 11: Timed Actions
44 #define NUMBER_OF_ACTION_ENTRIES 0 // User-modify field
45 //----------------------------------------------------------------------------
46 // 12: Log entries base 2
47 #define CS_LOG_DEF_ENTRIES_BASE2 0
48 //----------------------------------------------------------------------------
49 // 13: OCEOS stack start Address
50 #define OCEOS_STACK_START_ADDRESS 0
51 //----------------------------------------------------------------------------
52 // 14: OCEOS stack end address
53 #define OCEOS_STACK_LOW_BOUND_ADDRESS 0
54 //----------------------------------------------------------------------------
55 /**
56 * Target specific configurations
57 */
58 #ifdef __SAM3X8E__
59 #ifndef BSP_SYSFREQ
60 #define BSP_SYSFREQ 84 // ARM target frequency in Mhz
61 #endif
62 #endif
63 #ifdef __SAMV71Q21__
64 #ifndef BSP_SYSFREQ
65 #define BSP_SYSFREQ 300 // ARM target frequency in Mhz
66 #endif
67 #endif
68 #ifdef __VA41620__
69 #ifndef BSP_SYSFREQ
70 #define BSP_SYSFREQ 100 // ARM target frequency in Mhz
71 #endif
72 #endif
73
74 // User defined function to deal with system errors
75 void oceos_on_error(void*);
76 //---------------------------------------------------------------------
77 // User defined function to deal with log 2/3 full
78 void oceos_on_full_log(void*);
79 //---------------------------------------------------------------------
80 extern U32_t log_data[];
81 extern U32_t fixed_data[];
82 extern U32_t dynamic_data[];
83 extern const unsigned int __oceos_bsp_sysfreq;
84 /**
85 * Initialize OCEOS with user configurations
86 */
87 int application_init(void);
88 #endif /* INCLUDE_OCEOS_CONFIG_H_ */
oceos_config.c
1 /*
2 * app_config.c
3 *
4 * Configuration Tamplate for OCEOS
5 *
6 * Created on: 17 Feb 2020
7 * Author: Deniss Timofejevs <deniss.timofejevs@ocetechnology.com>
8 */
9 #include <stdio.h>
10 #include <assert.h>
11 #include "oceos_config.h"
12
13 /*
14 * OCEOS INTERNAL DATA STORAGE
15 *
16 * This application defines arrays to hold OCEOS internal data.
17 * The array sizes are provided by DMON by running "oceos info" command:</br>
18 * *Set all three arrays to guessed max zise, run application for the first time and exit.</br>
19 * *Run DMON command "oceos info" to get size for each array.</br>
20 * *Update array sizes below
21 */
22 U32_t log_data[LOG_DATA_ARRAY_SIZE_U32S];
23
24 U32_t fixed_data[FIXED_DATA_ARRAY_SIZE_U32S] = {0}; // will be in data segment
25
26 U32_t dynamic_data[DYN_DATA_ARRAY_SIZE_U32S];
27
28 const unsigned int __oceos_bsp_sysfreq = BSP_SYSFREQ * 1000 * 1000;// TODO
29
30 static BOOLE_t log_full_was_called = FALSE;
31
32 /*
33 * Set up the application configuration structure and pass it to oceos_init
34 * (done this way the memory used for the structure is returned automatically)
35 */
36
37 int application_init(){
38
39 /*
40 * Create the application configuration structure
41 */
42 struct application_configuration app_config = {0};
43
44 /*
45 * Fill in the application parameters
46 */
47 app_config.log_address = (adrs_t)log_data; // required
48 app_config.fixed_data_address = (adrs_t)fixed_data; // required
49 app_config.dynamic_data_address = (adrs_t)dynamic_data; // required
50
51 app_config.stack_start_address = OCEOS_STACK_START_ADDRESS; // 0 => no check
52 app_config.stack_lower_bound_address = OCEOS_STACK_LOW_BOUND_ADDRESS; // 0 => no check
53
54 app_config.system_error_function = &oceos_on_error; // NULL => ignore
55 app_config.log_full_function = &oceos_on_full_log; // NULL => ignore
56
57 // used in setting up system log and fixed data array
58 app_config.log_number_of_entries = NUMBER_OF_LOG_ENTRIES; // 0 => use default
59
60 app_config.number_of_tasks = NUMBER_OF_TASKS; // >= 1
61 app_config.number_of_readyQ_entries = NUMBER_OF_READYQ_ENTRIES; // 0 => calculate size
62
63 app_config.number_of_mutexes = NUMBER_OF_MUTEXES;
64 app_config.number_of_counting_semaphores = NUMBER_OF_SEMAPHORES;
65 app_config.number_of_data_queues = NUMBER_OF_DATAQS;
66
67 app_config.timed_actions_queue_size = NUMBER_OF_ACTION_ENTRIES;
68 app_config.CS_log_entries_base2 = CS_LOG_DEF_ENTRIES_BASE2;
69 app_config.use_oceos_system_time = TRUE;
70
71 // initialise OCEOS
72 enum DIRECTIVE_STATUS status;
73 status = oceos_init(app_config);
74 assert(SUCCESSFUL == status);
75
76 if (SUCCESSFUL == status) {
77 return 1;
78 } else {
79 printf("\n oceos_init failure\n");
80 return -1;
81 } // else
82 } // application_init()
83 /**
84 * User to implement in case of system error;
85 * Comment it out if not used and set field system_error_function in app_config to NULL
86 */
87 void oceos_on_error(void* ptr) {
88 return;
89 }
90 /**
91 * User to implement in case of system log is 2/3 full;
92 * Comment it out if not used and set field log_full_function in app_config to NULL
93 */
94 void oceos_on_full_log(void* ptr){
95 log_full_was_called = TRUE;
96 return;
97 }
tut5.c
1 /*
2 ******************************************************************************
3 * OCEOS
4 * Real-Time Operating System
5 * for ARM/SPARC
6 * Microcontroller
7 *
8 * Application Software Example
9 *
10 *
11 * (c) Copyright 2022, O.C.E. Technology
12 * All Rights Reserved
13 *
14 * Author: jfk
15 *
16 * Purpose : The test here involves creating two tasks with different priorities,
17 * and two data queues with timed action implimentation.
18 *
19 ******************************************************************************
20 */
21 /* N.B. Application header is included first */
22 #include "tut5.h" // application header
23
24 struct data {
25 int status;
26 char *message;
27 } test_data = {
28 1,
29 "Test Data",
30 };
31 int main(void) {
32
33 /*
34 * Initialise the application configuration and OCEOS
35 *
36 * This application function creates the application configuration
37 * and passes it to oceos_init(), which initialises the fixed data
38 * and enables the system log
39 */
40 if ( !application_init()) {
41 //LOG
42 printf("\nProblem\n");
43 return -1;
44 }
45
46 enum DIRECTIVE_STATUS status;
47 // Task 0: priority 10, threshold 10, max jobs 1, FP_used disabled, initially_enabled TRUE, task start address t_consumer_task, start of task end function NULL, time_deadline 0, time_mininterstart 0
48 status = oceos_task_create(t_consumer, 10, 10, 1, 0, TASK_ENABLED,t_consumer_task, NULL, 0, 0);
49 if(SUCCESSFUL != status){
50 // LOG
51 printf("\nAbandoning, problem creating task t_consumer, resulting return code: %u\n", status);
52 return -1;
53 } // if
54
55 // Task 1: priority 254, threshold 254, max jobs 1, FP_used disabled, initially_enabled TRUE, task start address t_consumer_task, start of task end function NULL, time_deadline 0, time_mininterstart 0
56 status = oceos_task_create(t_producer, 254, 254, 1, 0, TASK_ENABLED,t_producer_task, NULL, 0, 0);
57 if(SUCCESSFUL != status){
58 // LOG
59 printf("\nAbandoning, problem creating task t_producer, resulting return code: %u\n", status);
60 return -1;
61 } // if
62
63 printf("\n Tasks created\n");
64 // no counting semaphores, data queues or user defined traps
65
66 // Creating Data 0, dataq_size 1, pen_q size 1, roll_over FALSE, use_timeout TRUE
67 status = oceos_dataq_create(queue_0, N0, JOBS0, FALSE, TRUE);
68 if(SUCCESSFUL != status){
69 printf("\nProblem creating dataq queue_0, resulting return code: %u\n", status);
70 } // if
71
72 // Creating Data 1, dataq_size 1, pen_q size 1, roll_over FALSE, use_timeout TRUE
73 status = oceos_dataq_create(queue_1, N1, JOBS1, FALSE, TRUE);
74 if(SUCCESSFUL != status){
75 printf("\nProblem creating dataq queue_1, resulting return code: %u\n", status);
76 } // if
77 /*
78 * Finish initialising OCEOS and setting up the fixed data
79 */
80 status = oceos_init_finish();
81 if(SUCCESSFUL != status){
82 printf("\nAbandoning, problem ending OCEOS initialisation, resulting return code: %u\n", status);
83 return -1;
84 } // if
85 //1) Action: Start OCEOS with Task 1 as initial task, null input pointer
86 status = oceos_start(fixed_data, t_producer, NULL);
87
88 return status; // returned as an integer
89
90 } // function waits for specific time interval
91 void test_wait(U32_t interval) {
92 volatile U32_t start_time = oceos_time_sys_get32();
93 volatile U32_t cur_time = 0;
94 while(1) {
95 cur_time = oceos_time_sys_get32();
96 if ((cur_time - start_time) >= interval ) {
97 break;
98 }
99 }
100 }
101 /*
102 * Tasks
103 */
104 void t_consumer_task() {
105 static int case_number = 0;
106 if (case_number == 0) {
107 case_number++;
108 // 2) Action: Task 1 attempts to start Task 0
109 // Check: Task 0 has started, pre-empting Task 1
110 // a. Check: entry message from Task 0
111 // b. Check: queue_0 entries is 0
112 // c. Check: queue_1 entries is 0
113 printf("t_consumer was started\n");
114 if(oceos_dataq_get_size(queue_0)!= 0){
115 printf("\nData queue_0 entries is not equal to 0\n");
116 } // if
117 if(oceos_dataq_get_size(queue_1)!= 0){
118 printf("\nData queue_1 entries is not equal to 0\n");
119 } // if
120
121
122 // 3) Action: Task 0 does read_restart on queue_0
123 oceos_dataq_read_restart_timeout(queue_0, 0);
124 } else if (case_number == 1){
125 case_number++;
126 // 5) Action: Task 1 writes pointer to struct to queue_0
127 // Check: Task 0 has started, pre-empting Task 1
128 // a. Check: entry message from Task 0
129 // b. Check: queue_0 entries count is 1
130 // c. Check: queue_1 entries count is 0
131 printf("t_consumer was started\n");
132 if(oceos_dataq_get_size(queue_0)!= 1){
133 printf("\nData queue_0 entries is not equal to 1\n");
134 } // if
135 if(oceos_dataq_get_size(queue_1)!= 0){
136 printf("\nData queue_1 entries is not equal to 0\n");
137 } // if
138
139 // 6) Action: Task 0 does read_restart on queue 0
140 // Check: Task 0 has succeeded
141 // a. Check: non-null pointer returned
142 // b. Check: queue_0 entries count is 0
143 // c. Check: queue_0 entries count is 0
144 if(oceos_dataq_read_restart_timeout(queue_0, 0) == NULL){
145 printf("\nDataq read restart timeout returned null\n");
146 } // if
147 if(oceos_dataq_get_size(queue_0)!= 0){
148 printf("\nData queue_0 entries is not equal to 0\n");
149 } // if
150 if(oceos_dataq_get_size(queue_1)!= 0){
151 printf("\nData queue_1 entries is not equal to 0\n");
152 } // if
153
154 // 7) Action: Task 0 writes this pointer to queue_1
155 // Check: Task 0 has succeeded
156 // a. Check: queue_0 entries count is 0
157 // b. Check: queue_1 entries count is 1
158 if(oceos_dataq_write(queue_1, &test_data) != SUCCESSFUL){
159 printf("\nDataq write was not succesful\n");
160 } // if
161 if(oceos_dataq_get_size(queue_0)!= 0){
162 printf("\nData queue_0 entries is not equal to 0\n");
163 } // if
164 if(oceos_dataq_get_size(queue_1)!= 1){
165 printf("\nData queue_1 entries is not equal to 1\n");
166 } // if
167
168 // 8) Action: Task 0 does read_restart with timeout on queue_0
169 // Check: Task 0 exits as queues_0 is empty
170 if(oceos_dataq_read_restart_timeout(queue_0, TIME_OUT) != NULL){
171 printf("\nDataq read restart timeout returned not null\n");
172 } // if
173 } else {
174 case_number++;
175 // 10) Action: Task 1 loops for at least twice timeout period T
176 // Check: Task 0 restarts on timeout, pre-empting Task 1
177 // a. Check: entry message from Task 0
178 // b. Check: queue_0 entries count is 0
179 // c. Check: queue_1 entries count is 0
180 printf("t_consumer was started\n");
181 if(oceos_dataq_get_size(queue_0)!= 0){
182 printf("\nData queue_0 entries is not equal to 0\n");
183 } // if
184 if(oceos_dataq_get_size(queue_1)!= 0){
185 printf("\nData queue_1 entries is not equal to 0\n");
186 } // if
187
188 // 11) Action: Task 0 does read_continue on queue_0
189 // Check: Task 0 has succeeded
190 // a. Check: null pointer returned
191 // b. Check: queue_0 entries count is 0
192 // c. Check: queue_1 entries count is 0
193 if(oceos_dataq_read_continue(queue_0) != NULL){
194 printf("\nDataq read continue returned not null\n");
195 } // if
196 if(oceos_dataq_get_size(queue_0)!= 0){
197 printf("\nData queue_0 entries is not equal to 0\n");
198 } // if
199 if(oceos_dataq_get_size(queue_1)!= 0){
200 printf("\nData queue_1 entries is not equal to 0\n");
201 } // if
202
203 // 12) Action: Task 0 exits
204 // Check: Task 0 exit message
205 // a. Check: queue_0 entries count is 0
206 // b. Check: queue_1 entries count is 0
207 printf("t_consumer is exiting\n");
208 if(oceos_dataq_get_size(queue_0)!= 0){
209 printf("\nData queue_0 entries is not equal to 0\n");
210 } // if
211 if(oceos_dataq_get_size(queue_1)!= 0){
212 printf("\nData queue_1 entries is not equal to 0\n");
213 } // if
214 return;
215 }
216 }//END t_consumer_task
217
218 void t_producer_task() {
219 // 1) Action: Start OCEOS with Task 1 as initial task, null input pointer
220 // Check: Task 1 has started
221 // a. Check: Starting message from Task 1
222 // b. Check: queue_0 entries count is 0
223 // c. Check: queue_0 capacity is as created
224 // d. Check: queue_1 entries count is 0
225 // e. Check: queue_1 capacity is as created
226 printf("t_producer was started\n");
227 if(oceos_dataq_get_size(queue_0)!= 0){
228 printf("\nData queue_0 entries is not equal to 0\n");
229 } // if
230 if(oceos_dataq_get_size(queue_1)!= 0){
231 printf("\nData queue_1 entries is not equal to 0\n");
232 } // if
233
234 // 2) Action: Task 1 attempts to start Task 0
235 if(oceos_task_start(t_consumer, NULL)!= SUCCESSFUL){
236 printf("\nFailed starting task t_consumer\n");
237 } // if
238
239 // 3) Action: Task 0 does read_restart on queue_0
240 // Check: Task 0 exits as queue_0 is empty
241 // Check: Task 1 continues
242 // a. Check: continue message from Task 1
243 // b. Check: queue_0 entries count is 0
244 // c. Check: queue_1 entries count is 0
245 printf("t_producer continues \n");
246 if(oceos_dataq_get_size(queue_0)!= 0){
247 printf("\nData queue_0 entries is not equal to 0\n");
248 } // if
249 if(oceos_dataq_get_size(queue_1)!= 0){
250 printf("\nData queue_1 entries is not equal to 0\n");
251 } // if
252
253 // 4) Action: Task 1 does read_continue on queue_1
254 // Check: null pointer returned
255 if(oceos_dataq_read_continue(queue_1) != NULL){
256 printf("\nDataq read continue returned not null\n");
257 } // if
258
259 // 5) Action: Task 1 writes pointer to struct to queue_0
260 if(oceos_dataq_write(queue_0, &test_data) != SUCCESSFUL){
261 printf("\nDataq write failed\n");
262 } // if
263
264 // 8) Action: Task 0 does read_restart with timeout on queue_0
265 // Check: Task 0 exits as queues_0 is empty
266 // Check: Task 1 continues
267 // a. Check: continue message from Task 1
268 // b. Check: queue_0 entries count is 0
269 // c. Check: queue_1 entries count is 1
270 printf("t_producer continues \n");
271 if(oceos_dataq_get_size(queue_0)!= 0){
272 printf("\nData queue_0 entries is not equal to 0\n");
273 } // if
274 if(oceos_dataq_get_size(queue_1)!= 1){
275 printf("\nData queue_1 entries is not equal to 1\n");
276 } // if
277
278 // 9) Action: Task 1 does read_continue on queue_1
279 // Check: Non-null pointer returned
280 // a. Check: pointer to same struct
281 // b. Check: queue_0 entries count is 0
282 // c. Check: queue_1 entries count is 0
283 struct data *temp_data = oceos_dataq_read_continue(queue_1);
284 if(temp_data == NULL){
285 printf("\ntemp_data is null\n");
286 } // if
287 if(test_data.message != temp_data->message){
288 printf("\npointer not to same struct\n");
289 } // if
290 if(oceos_dataq_get_size(queue_0)!= 0){
291 printf("\nData queue_0 entries is not equal to 0\n");
292 } // if
293 if(oceos_dataq_get_size(queue_1)!= 0){
294 printf("\nData queue_1 entries is not equal to 0\n");
295 } // if
296
297 // 10) Action: Task 1 loops for at least three timeout period
298 // Check: Task 0 restarts on timeout, pre-empting Task 1
299 test_wait(TIME_OUT * 3);
300
301 //Task 1 writes pointer to struct on queue_1
302 if(oceos_dataq_write(queue_1, &test_data) != SUCCESSFUL){
303 printf("\nDataq write failed\n");
304 } // if
305 // Data q size check
306 if(oceos_dataq_get_size(queue_1)!= 1){
307 printf("\nData queue_1 entries is not equal to 1\n");
308 } // if
309 // Task 1 does read restart on queue_1
310 if(oceos_dataq_read_restart(queue_1) == NULL){
311 printf("\nDataq read restart failed\n");
312 } // if
313 // Data q size check
314 if(oceos_dataq_get_size(queue_1)!= 0){
315 printf("\nData queue_1 entries is not equal to 0\n");
316 } // if
317 //Task 1 writes pointer to struct on queue_1
318 if(oceos_dataq_write(queue_1, &test_data) != SUCCESSFUL){
319 printf("\nDataq write failed\n");
320 } // if
321 // Data q size check
322 if(oceos_dataq_get_size(queue_1)!= 1){
323 printf("\nData queue_1 entries is not equal to 1\n");
324 } // if
325 // Data q clear
326 if(oceos_dataq_clear(queue_1)!= 0){
327 printf("\nDataq clear failed\n");
328 } // if
329
330 // Data q size check
331 if(oceos_dataq_get_size(queue_1)!= 0){
332 printf("\nData queue_1 entries is not equal to 0\n");
333 } // if
334 // Data pending q size check
335 if(oceos_dataq_penq_get_size(queue_1) != 0){
336 printf("\nDataq pending queue not equal to 0\n");
337 } // if
338
339 // 14) Action: Task 1 terminates
340 // Check: Task 1 exit message
341 printf("t_producer is exiting\n");
342
343
344
345 // 15) Action: CPU placed in sleep mode
346 // Check: Sleep mode starting message
347 if(oceos_exit() != SUCCESSFUL){
348 printf("\nOceos exiting failed\n");
349 } // if
350
351 return;
352 }