-
Notifications
You must be signed in to change notification settings - Fork 3
/
ucos_iix.h
1148 lines (908 loc) · 45.9 KB
/
ucos_iix.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
*********************************************************************************************************
* uC/OS-II
* The Real-Time Kernel
*
* (c) Copyright 1992-2002, Jean J. Labrosse, Weston, FL
* All Rights Reserved
*
* File : uCOS_II.H
* By : Jean J. Labrosse
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* MISCELLANEOUS
*********************************************************************************************************
*/
#define OS_VERSION 252 /* Version of uC/OS-II (Vx.yy mult. by 100) */
#ifdef OS_GLOBALS
#define OS_EXT
#else
#define OS_EXT extern
#endif
#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif
#define OS_PRIO_SELF 0xFF /* Indicate SELF priority */
#if OS_TASK_STAT_EN > 0
#define OS_N_SYS_TASKS 2 /* Number of system tasks */
#else
#define OS_N_SYS_TASKS 1
#endif
#define OS_STAT_PRIO (OS_LOWEST_PRIO - 1) /* Statistic task priority */
#define OS_IDLE_PRIO (OS_LOWEST_PRIO) /* IDLE task priority */
#define OS_EVENT_TBL_SIZE ((OS_LOWEST_PRIO) / 8 + 1) /* Size of event table */
#define OS_RDY_TBL_SIZE ((OS_LOWEST_PRIO) / 8 + 1) /* Size of ready table */
#define OS_TASK_IDLE_ID 65535 /* I.D. numbers for Idle and Stat tasks */
#define OS_TASK_STAT_ID 65534
#define OS_EVENT_EN (((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0) || (OS_SEM_EN > 0) || (OS_MUTEX_EN > 0))
/*$PAGE*/
/*
*********************************************************************************************************
* TASK STATUS (Bit definition for OSTCBStat)
*********************************************************************************************************
*/
#define OS_STAT_RDY 0x00 /* Ready to run */
#define OS_STAT_SEM 0x01 /* Pending on semaphore */
#define OS_STAT_MBOX 0x02 /* Pending on mailbox */
#define OS_STAT_Q 0x04 /* Pending on queue */
#define OS_STAT_SUSPEND 0x08 /* Task is suspended */
#define OS_STAT_MUTEX 0x10 /* Pending on mutual exclusion semaphore */
#define OS_STAT_FLAG 0x20 /* Pending on event flag group */
/*
*********************************************************************************************************
* OS_EVENT types
*********************************************************************************************************
*/
#define OS_EVENT_TYPE_UNUSED 0
#define OS_EVENT_TYPE_MBOX 1
#define OS_EVENT_TYPE_Q 2
#define OS_EVENT_TYPE_SEM 3
#define OS_EVENT_TYPE_MUTEX 4
#define OS_EVENT_TYPE_FLAG 5
/*
*********************************************************************************************************
* EVENT FLAGS
*********************************************************************************************************
*/
#define OS_FLAG_WAIT_CLR_ALL 0 /* Wait for ALL the bits specified to be CLR (i.e. 0) */
#define OS_FLAG_WAIT_CLR_AND 0
#define OS_FLAG_WAIT_CLR_ANY 1 /* Wait for ANY of the bits specified to be CLR (i.e. 0) */
#define OS_FLAG_WAIT_CLR_OR 1
#define OS_FLAG_WAIT_SET_ALL 2 /* Wait for ALL the bits specified to be SET (i.e. 1) */
#define OS_FLAG_WAIT_SET_AND 2
#define OS_FLAG_WAIT_SET_ANY 3 /* Wait for ANY of the bits specified to be SET (i.e. 1) */
#define OS_FLAG_WAIT_SET_OR 3
#define OS_FLAG_CONSUME 0x80 /* Consume the flags if condition(s) satisfied */
#define OS_FLAG_CLR 0
#define OS_FLAG_SET 1
/*
*********************************************************************************************************
* Possible values for 'opt' argument of OSSemDel(), OSMboxDel(), OSQDel() and OSMutexDel()
*********************************************************************************************************
*/
#define OS_DEL_NO_PEND 0
#define OS_DEL_ALWAYS 1
/*
*********************************************************************************************************
* OS???PostOpt() OPTIONS
*
* These #defines are used to establish the options for OSMboxPostOpt() and OSQPostOpt().
*********************************************************************************************************
*/
#define OS_POST_OPT_NONE 0x00 /* Post to highest priority task waiting */
#define OS_POST_OPT_BROADCAST 0x01 /* Broadcast message to ALL tasks waiting */
#define OS_POST_OPT_FRONT 0x02 /* Post to highest priority task waiting */
/*
*********************************************************************************************************
* TASK OPTIONS (see OSTaskCreateExt())
*********************************************************************************************************
*/
#define OS_TASK_OPT_STK_CHK 0x0001 /* Enable stack checking for the task */
#define OS_TASK_OPT_STK_CLR 0x0002 /* Clear the stack when the task is create */
#define OS_TASK_OPT_SAVE_FP 0x0004 /* Save the contents of any floating-point registers */
/*
*********************************************************************************************************
* ERROR CODES
*********************************************************************************************************
*/
#define OS_NO_ERR 0
#define OS_ERR_EVENT_TYPE 1
#define OS_ERR_PEND_ISR 2
#define OS_ERR_POST_NULL_PTR 3
#define OS_ERR_PEVENT_NULL 4
#define OS_ERR_POST_ISR 5
#define OS_ERR_QUERY_ISR 6
#define OS_ERR_INVALID_OPT 7
#define OS_ERR_TASK_WAITING 8
#define OS_TIMEOUT 10
#define OS_TASK_NOT_EXIST 11
#define OS_MBOX_FULL 20
#define OS_Q_FULL 30
#define OS_PRIO_EXIST 40
#define OS_PRIO_ERR 41
#define OS_PRIO_INVALID 42
#define OS_SEM_OVF 50
#define OS_TASK_DEL_ERR 60
#define OS_TASK_DEL_IDLE 61
#define OS_TASK_DEL_REQ 62
#define OS_TASK_DEL_ISR 63
#define OS_NO_MORE_TCB 70
#define OS_TIME_NOT_DLY 80
#define OS_TIME_INVALID_MINUTES 81
#define OS_TIME_INVALID_SECONDS 82
#define OS_TIME_INVALID_MILLI 83
#define OS_TIME_ZERO_DLY 84
#define OS_TASK_SUSPEND_PRIO 90
#define OS_TASK_SUSPEND_IDLE 91
#define OS_TASK_RESUME_PRIO 100
#define OS_TASK_NOT_SUSPENDED 101
#define OS_MEM_INVALID_PART 110
#define OS_MEM_INVALID_BLKS 111
#define OS_MEM_INVALID_SIZE 112
#define OS_MEM_NO_FREE_BLKS 113
#define OS_MEM_FULL 114
#define OS_MEM_INVALID_PBLK 115
#define OS_MEM_INVALID_PMEM 116
#define OS_MEM_INVALID_PDATA 117
#define OS_MEM_INVALID_ADDR 118
#define OS_ERR_NOT_MUTEX_OWNER 120
#define OS_TASK_OPT_ERR 130
#define OS_ERR_DEL_ISR 140
#define OS_ERR_CREATE_ISR 141
#define OS_FLAG_INVALID_PGRP 150
#define OS_FLAG_ERR_WAIT_TYPE 151
#define OS_FLAG_ERR_NOT_RDY 152
#define OS_FLAG_INVALID_OPT 153
#define OS_FLAG_GRP_DEPLETED 154
/*$PAGE*/
/*
*********************************************************************************************************
* EVENT CONTROL BLOCK
*********************************************************************************************************
*/
#if (OS_EVENT_EN > 0) && (OS_MAX_EVENTS > 0)
typedef struct {
INT8U OSEventType; /* Type of event control block (see OS_EVENT_TYPE_???) */
INT8U OSEventGrp; /* Group corresponding to tasks waiting for event to occur */
INT16U OSEventCnt; /* Semaphore Count (not used if other EVENT type) */
void *OSEventPtr; /* Pointer to message or queue structure */
INT8U OSEventTbl[OS_EVENT_TBL_SIZE]; /* List of tasks waiting for event to occur */
} OS_EVENT;
#endif
/*
*********************************************************************************************************
* EVENT FLAGS CONTROL BLOCK
*********************************************************************************************************
*/
#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
typedef struct { /* Event Flag Group */
INT8U OSFlagType; /* Should be set to OS_EVENT_TYPE_FLAG */
void *OSFlagWaitList; /* Pointer to first NODE of task waiting on event flag */
OS_FLAGS OSFlagFlags; /* 8, 16 or 32 bit flags */
} OS_FLAG_GRP;
typedef struct { /* Event Flag Wait List Node */
void *OSFlagNodeNext; /* Pointer to next NODE in wait list */
void *OSFlagNodePrev; /* Pointer to previous NODE in wait list */
void *OSFlagNodeTCB; /* Pointer to TCB of waiting task */
void *OSFlagNodeFlagGrp; /* Pointer to Event Flag Group */
OS_FLAGS OSFlagNodeFlags; /* Event flag to wait on */
INT8U OSFlagNodeWaitType; /* Type of wait: */
/* OS_FLAG_WAIT_AND */
/* OS_FLAG_WAIT_ALL */
/* OS_FLAG_WAIT_OR */
/* OS_FLAG_WAIT_ANY */
} OS_FLAG_NODE;
#endif
/*
*********************************************************************************************************
* MESSAGE MAILBOX DATA
*********************************************************************************************************
*/
#if OS_MBOX_EN > 0
typedef struct {
void *OSMsg; /* Pointer to message in mailbox */
INT8U OSEventTbl[OS_EVENT_TBL_SIZE]; /* List of tasks waiting for event to occur */
INT8U OSEventGrp; /* Group corresponding to tasks waiting for event to occur */
} OS_MBOX_DATA;
#endif
/*
*********************************************************************************************************
* MEMORY PARTITION DATA STRUCTURES
*********************************************************************************************************
*/
#if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
typedef struct { /* MEMORY CONTROL BLOCK */
void *OSMemAddr; /* Pointer to beginning of memory partition */
void *OSMemFreeList; /* Pointer to list of free memory blocks */
INT32U OSMemBlkSize; /* Size (in bytes) of each block of memory */
INT32U OSMemNBlks; /* Total number of blocks in this partition */
INT32U OSMemNFree; /* Number of memory blocks remaining in this partition */
} OS_MEM;
typedef struct {
void *OSAddr; /* Pointer to the beginning address of the memory partition */
void *OSFreeList; /* Pointer to the beginning of the free list of memory blocks */
INT32U OSBlkSize; /* Size (in bytes) of each memory block */
INT32U OSNBlks; /* Total number of blocks in the partition */
INT32U OSNFree; /* Number of memory blocks free */
INT32U OSNUsed; /* Number of memory blocks used */
} OS_MEM_DATA;
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* MUTUAL EXCLUSION SEMAPHORE DATA
*********************************************************************************************************
*/
#if OS_MUTEX_EN > 0
typedef struct {
INT8U OSEventTbl[OS_EVENT_TBL_SIZE]; /* List of tasks waiting for event to occur */
INT8U OSEventGrp; /* Group corresponding to tasks waiting for event to occur */
INT8U OSValue; /* Mutex value (0 = used, 1 = available) */
INT8U OSOwnerPrio; /* Mutex owner's task priority or 0xFF if no owner */
INT8U OSMutexPIP; /* Priority Inheritance Priority or 0xFF if no owner */
} OS_MUTEX_DATA;
#endif
/*
*********************************************************************************************************
* MESSAGE QUEUE DATA
*********************************************************************************************************
*/
#if OS_Q_EN > 0
typedef struct os_q { /* QUEUE CONTROL BLOCK */
struct os_q *OSQPtr; /* Link to next queue control block in list of free blocks */
void **OSQStart; /* Pointer to start of queue data */
void **OSQEnd; /* Pointer to end of queue data */
void **OSQIn; /* Pointer to where next message will be inserted in the Q */
void **OSQOut; /* Pointer to where next message will be extracted from the Q */
INT16U OSQSize; /* Size of queue (maximum number of entries) */
INT16U OSQEntries; /* Current number of entries in the queue */
} OS_Q;
typedef struct {
void *OSMsg; /* Pointer to next message to be extracted from queue */
INT16U OSNMsgs; /* Number of messages in message queue */
INT16U OSQSize; /* Size of message queue */
INT8U OSEventTbl[OS_EVENT_TBL_SIZE]; /* List of tasks waiting for event to occur */
INT8U OSEventGrp; /* Group corresponding to tasks waiting for event to occur */
} OS_Q_DATA;
#endif
/*
*********************************************************************************************************
* SEMAPHORE DATA
*********************************************************************************************************
*/
#if OS_SEM_EN > 0
typedef struct {
INT16U OSCnt; /* Semaphore count */
INT8U OSEventTbl[OS_EVENT_TBL_SIZE]; /* List of tasks waiting for event to occur */
INT8U OSEventGrp; /* Group corresponding to tasks waiting for event to occur */
} OS_SEM_DATA;
#endif
/*
*********************************************************************************************************
* TASK STACK DATA
*********************************************************************************************************
*/
#if OS_TASK_CREATE_EXT_EN > 0
typedef struct {
INT32U OSFree; /* Number of free bytes on the stack */
INT32U OSUsed; /* Number of bytes used on the stack */
} OS_STK_DATA;
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* TASK CONTROL BLOCK
*********************************************************************************************************
*/
typedef struct os_tcb {
OS_STK *OSTCBStkPtr; /* Pointer to current top of stack */
#if OS_TASK_CREATE_EXT_EN > 0
void *OSTCBExtPtr; /* Pointer to user definable data for TCB extension */
OS_STK *OSTCBStkBottom; /* Pointer to bottom of stack */
INT32U OSTCBStkSize; /* Size of task stack (in number of stack elements) */
INT16U OSTCBOpt; /* Task options as passed by OSTaskCreateExt() */
INT16U OSTCBId; /* Task ID (0..65535) */
#endif
struct os_tcb *OSTCBNext; /* Pointer to next TCB in the TCB list */
struct os_tcb *OSTCBPrev; /* Pointer to previous TCB in the TCB list */
#if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0) || (OS_SEM_EN > 0) || (OS_MUTEX_EN > 0)
OS_EVENT *OSTCBEventPtr; /* Pointer to event control block */
#endif
#if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0)
void *OSTCBMsg; /* Message received from OSMboxPost() or OSQPost() */
#endif
#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
#if OS_TASK_DEL_EN > 0
OS_FLAG_NODE *OSTCBFlagNode; /* Pointer to event flag node */
#endif
OS_FLAGS OSTCBFlagsRdy; /* Event flags that made task ready to run */
#endif
INT16U OSTCBDly; /* Nbr ticks to delay task or, timeout waiting for event */
INT8U OSTCBStat; /* Task status */
INT8U OSTCBPrio; /* Task priority (0 == highest, 63 == lowest) */
INT8U OSTCBX; /* Bit position in group corresponding to task priority (0..7) */
INT8U OSTCBY; /* Index into ready table corresponding to task priority */
INT8U OSTCBBitX; /* Bit mask to access bit position in ready table */
INT8U OSTCBBitY; /* Bit mask to access bit position in ready group */
#if OS_TASK_DEL_EN > 0
BOOLEAN OSTCBDelReq; /* Indicates whether a task needs to delete itself */
#endif
} OS_TCB;
/*$PAGE*/
/*
*********************************************************************************************************
* GLOBAL VARIABLES
*********************************************************************************************************
*/
OS_EXT INT32U OSCtxSwCtr; /* Counter of number of context switches */
#if (OS_EVENT_EN > 0) && (OS_MAX_EVENTS > 0)
OS_EXT OS_EVENT *OSEventFreeList; /* Pointer to list of free EVENT control blocks */
OS_EXT OS_EVENT OSEventTbl[OS_MAX_EVENTS];/* Table of EVENT control blocks */
#endif
#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
OS_EXT OS_FLAG_GRP OSFlagTbl[OS_MAX_FLAGS]; /* Table containing event flag groups */
OS_EXT OS_FLAG_GRP *OSFlagFreeList; /* Pointer to free list of event flag groups */
#endif
#if OS_TASK_STAT_EN > 0
OS_EXT INT8S OSCPUUsage; /* Percentage of CPU used */
OS_EXT INT32U OSIdleCtrMax; /* Max. value that idle ctr can take in 1 sec. */
OS_EXT INT32U OSIdleCtrRun; /* Val. reached by idle ctr at run time in 1 sec. */
OS_EXT BOOLEAN OSStatRdy; /* Flag indicating that the statistic task is rdy */
OS_EXT OS_STK OSTaskStatStk[OS_TASK_STAT_STK_SIZE]; /* Statistics task stack */
#endif
OS_EXT INT8U OSIntNesting; /* Interrupt nesting level */
OS_EXT INT8U OSIntExitY;
OS_EXT INT8U OSLockNesting; /* Multitasking lock nesting level */
OS_EXT INT8U OSPrioCur; /* Priority of current task */
OS_EXT INT8U OSPrioHighRdy; /* Priority of highest priority task */
OS_EXT INT8U OSRdyGrp; /* Ready list group */
OS_EXT INT8U OSRdyTbl[OS_RDY_TBL_SIZE]; /* Table of tasks which are ready to run */
OS_EXT BOOLEAN OSRunning; /* Flag indicating that kernel is running */
OS_EXT INT8U OSTaskCtr; /* Number of tasks created */
OS_EXT volatile INT32U OSIdleCtr; /* Idle counter */
OS_EXT OS_STK OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE]; /* Idle task stack */
OS_EXT OS_TCB *OSTCBCur; /* Pointer to currently running TCB */
OS_EXT OS_TCB *OSTCBFreeList; /* Pointer to list of free TCBs */
OS_EXT OS_TCB *OSTCBHighRdy; /* Pointer to highest priority TCB R-to-R */
OS_EXT OS_TCB *OSTCBList; /* Pointer to doubly linked list of TCBs */
OS_EXT OS_TCB *OSTCBPrioTbl[OS_LOWEST_PRIO + 1];/* Table of pointers to created TCBs */
OS_EXT OS_TCB OSTCBTbl[OS_MAX_TASKS + OS_N_SYS_TASKS]; /* Table of TCBs */
#if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
OS_EXT OS_MEM *OSMemFreeList; /* Pointer to free list of memory partitions */
OS_EXT OS_MEM OSMemTbl[OS_MAX_MEM_PART];/* Storage for memory partition manager */
#endif
#if (OS_Q_EN > 0) && (OS_MAX_QS > 0)
OS_EXT OS_Q *OSQFreeList; /* Pointer to list of free QUEUE control blocks */
OS_EXT OS_Q OSQTbl[OS_MAX_QS]; /* Table of QUEUE control blocks */
#endif
#if OS_TIME_GET_SET_EN > 0
OS_EXT volatile INT32U OSTime; /* Current value of system time (in ticks) */
#endif
extern INT8U const OSMapTbl[]; /* Priority->Bit Mask lookup table */
extern INT8U OSUnMapTbl[]; /* Priority->Index lookup table */
/*$PAGE*/
/*
*********************************************************************************************************
* FUNCTION PROTOTYPES
* (Target Independent Functions)
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* EVENT FLAGS MANAGEMENT
*********************************************************************************************************
*/
#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
#if OS_FLAG_ACCEPT_EN > 0
OS_FLAGS OSFlagAccept(OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT8U *err);
#endif
OS_FLAG_GRP *OSFlagCreate(OS_FLAGS flags, INT8U *err);
#if OS_FLAG_DEL_EN > 0
OS_FLAG_GRP *OSFlagDel(OS_FLAG_GRP *pgrp, INT8U opt, INT8U *err);
#endif
OS_FLAGS OSFlagPend(OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err);
OS_FLAGS OSFlagPost(OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U operation, INT8U *err);
#if OS_FLAG_QUERY_EN > 0
OS_FLAGS OSFlagQuery(OS_FLAG_GRP *pgrp, INT8U *err);
#endif
#endif
/*
*********************************************************************************************************
* MESSAGE MAILBOX MANAGEMENT
*********************************************************************************************************
*/
#if OS_MBOX_EN > 0
#if OS_MBOX_ACCEPT_EN > 0
void *OSMboxAccept(OS_EVENT *pevent);
#endif
OS_EVENT *OSMboxCreate(void *msg);
#if OS_MBOX_DEL_EN > 0
OS_EVENT *OSMboxDel(OS_EVENT *pevent, INT8U opt, INT8U *err);
#endif
void *OSMboxPend(OS_EVENT *pevent, INT16U timeout, INT8U *err);
#if OS_MBOX_POST_EN > 0
INT8U OSMboxPost(OS_EVENT *pevent, void *msg);
#endif
#if OS_MBOX_POST_OPT_EN > 0
INT8U OSMboxPostOpt(OS_EVENT *pevent, void *msg, INT8U opt);
#endif
#if OS_MBOX_QUERY_EN > 0
INT8U OSMboxQuery(OS_EVENT *pevent, OS_MBOX_DATA *pdata);
#endif
#endif
/*
*********************************************************************************************************
* MEMORY MANAGEMENT
*********************************************************************************************************
*/
#if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
OS_MEM *OSMemCreate(void *addr, INT32U nblks, INT32U blksize, INT8U *err);
void *OSMemGet(OS_MEM *pmem, INT8U *err);
INT8U OSMemPut(OS_MEM *pmem, void *pblk);
#if OS_MEM_QUERY_EN > 0
INT8U OSMemQuery(OS_MEM *pmem, OS_MEM_DATA *pdata);
#endif
#endif
/*
*********************************************************************************************************
* MUTUAL EXCLUSION SEMAPHORE MANAGEMENT
*********************************************************************************************************
*/
#if OS_MUTEX_EN > 0
#if OS_MUTEX_ACCEPT_EN > 0
INT8U OSMutexAccept(OS_EVENT *pevent, INT8U *err);
#endif
OS_EVENT *OSMutexCreate(INT8U prio, INT8U *err);
#if OS_MUTEX_DEL_EN > 0
OS_EVENT *OSMutexDel(OS_EVENT *pevent, INT8U opt, INT8U *err);
#endif
void OSMutexPend(OS_EVENT *pevent, INT16U timeout, INT8U *err);
INT8U OSMutexPost(OS_EVENT *pevent);
#if OS_MUTEX_QUERY_EN > 0
INT8U OSMutexQuery(OS_EVENT *pevent, OS_MUTEX_DATA *pdata);
#endif
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* MESSAGE QUEUE MANAGEMENT
*********************************************************************************************************
*/
#if (OS_Q_EN > 0) && (OS_MAX_QS > 0)
#if OS_Q_ACCEPT_EN > 0
void *OSQAccept(OS_EVENT *pevent);
#endif
OS_EVENT *OSQCreate(void **start, INT16U size);
#if OS_Q_DEL_EN > 0
OS_EVENT *OSQDel(OS_EVENT *pevent, INT8U opt, INT8U *err);
#endif
#if OS_Q_FLUSH_EN > 0
INT8U OSQFlush(OS_EVENT *pevent);
#endif
void *OSQPend(OS_EVENT *pevent, INT16U timeout, INT8U *err);
#if OS_Q_POST_EN > 0
INT8U OSQPost(OS_EVENT *pevent, void *msg);
#endif
#if OS_Q_POST_FRONT_EN > 0
INT8U OSQPostFront(OS_EVENT *pevent, void *msg);
#endif
#if OS_Q_POST_OPT_EN > 0
INT8U OSQPostOpt(OS_EVENT *pevent, void *msg, INT8U opt);
#endif
#if OS_Q_QUERY_EN > 0
INT8U OSQQuery(OS_EVENT *pevent, OS_Q_DATA *pdata);
#endif
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* SEMAPHORE MANAGEMENT
*********************************************************************************************************
*/
#if OS_SEM_EN > 0
#if OS_SEM_ACCEPT_EN > 0
INT16U OSSemAccept(OS_EVENT *pevent);
#endif
OS_EVENT *OSSemCreate(INT16U cnt);
#if OS_SEM_DEL_EN > 0
OS_EVENT *OSSemDel(OS_EVENT *pevent, INT8U opt, INT8U *err);
#endif
void OSSemPend(OS_EVENT *pevent, INT16U timeout, INT8U *err);
INT8U OSSemPost(OS_EVENT *pevent);
#if OS_SEM_QUERY_EN > 0
INT8U OSSemQuery(OS_EVENT *pevent, OS_SEM_DATA *pdata);
#endif
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* TASK MANAGEMENT
*********************************************************************************************************
*/
#if OS_TASK_CHANGE_PRIO_EN > 0
INT8U OSTaskChangePrio(INT8U oldprio, INT8U newprio);
#endif
#if OS_TASK_CREATE_EN > 0
INT8U OSTaskCreate(void (*task)(void *pd), void *pdata, OS_STK *ptos, INT8U prio);
#endif
#if OS_TASK_CREATE_EXT_EN > 0
INT8U OSTaskCreateExt(void (*task)(void *pd),
void *pdata,
OS_STK *ptos,
INT8U prio,
INT16U id,
OS_STK *pbos,
INT32U stk_size,
void *pext,
INT16U opt);
#endif
#if OS_TASK_DEL_EN > 0
INT8U OSTaskDel(INT8U prio);
INT8U OSTaskDelReq(INT8U prio);
#endif
#if OS_TASK_SUSPEND_EN > 0
INT8U OSTaskResume(INT8U prio);
INT8U OSTaskSuspend(INT8U prio);
#endif
#if OS_TASK_CREATE_EXT_EN > 0
INT8U OSTaskStkChk(INT8U prio, OS_STK_DATA *pdata);
#endif
#if OS_TASK_QUERY_EN > 0
INT8U OSTaskQuery(INT8U prio, OS_TCB *pdata);
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* TIME MANAGEMENT
*********************************************************************************************************
*/
void OSTimeDly(INT16U ticks);
#if OS_TIME_DLY_HMSM_EN > 0
INT8U OSTimeDlyHMSM(INT8U hours, INT8U minutes, INT8U seconds, INT16U milli);
#endif
#if OS_TIME_DLY_RESUME_EN > 0
INT8U OSTimeDlyResume(INT8U prio);
#endif
#if OS_TIME_GET_SET_EN > 0
INT32U OSTimeGet(void);
void OSTimeSet(INT32U ticks);
#endif
void OSTimeTick(void);
/*
*********************************************************************************************************
* MISCELLANEOUS
*********************************************************************************************************
*/
void OSInit(void);
void OSIntEnter(void);
void OSIntExit(void);
#if OS_SCHED_LOCK_EN > 0
void OSSchedLock(void);
void OSSchedUnlock(void);
#endif
void OSStart(void);
void OSStatInit(void);
INT16U OSVersion(void);
/*$PAGE*/
/*
*********************************************************************************************************
* INTERNAL FUNCTION PROTOTYPES
* (Your application MUST NOT call these functions)
*********************************************************************************************************
*/
#if OS_TASK_DEL_EN > 0
void OS_Dummy(void);
#endif
#if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0) || (OS_SEM_EN > 0) || (OS_MUTEX_EN > 0)
INT8U OS_EventTaskRdy(OS_EVENT *pevent, void *msg, INT8U msk);
void OS_EventTaskWait(OS_EVENT *pevent);
void OS_EventTO(OS_EVENT *pevent);
void OS_EventWaitListInit(OS_EVENT *pevent);
#endif
#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
void OS_FlagInit(void);
void OS_FlagUnlink(OS_FLAG_NODE *pnode);
#endif
#if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
void OS_MemInit(void);
#endif
#if OS_Q_EN > 0
void OS_QInit(void);
#endif
void OS_Sched(void);
void OS_TaskIdle(void *data);
#if OS_TASK_STAT_EN > 0
void OS_TaskStat(void *data);
#endif
INT8U OS_TCBInit(INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT32U stk_size, void *pext, INT16U opt);
/*$PAGE*/
/*
*********************************************************************************************************
* FUNCTION PROTOTYPES
* (Target Specific Functions)
*********************************************************************************************************
*/
#if OS_VERSION >= 204
void OSInitHookBegin(void);
void OSInitHookEnd(void);
#endif
void OSIntCtxSw(void);
void OSStartHighRdy(void);
void OSTaskCreateHook(OS_TCB *ptcb);
void OSTaskDelHook(OS_TCB *ptcb);
#if OS_VERSION >= 251
void OSTaskIdleHook(void);
#endif
void OSTaskStatHook(void);
OS_STK *OSTaskStkInit(void (*task)(void *pd), void *pdata, OS_STK *ptos, INT16U opt);
void OSTaskSwHook(void);
#if OS_VERSION >= 204
void OSTCBInitHook(OS_TCB *ptcb);
#endif
void OSTimeTickHook(void);
/*
*********************************************************************************************************
* FUNCTION PROTOTYPES
* (Compiler Specific ISR prototypes)
*********************************************************************************************************
*/
#ifndef OS_ISR_PROTO_EXT
void OSCtxSw(void);
void OSTickISR(void);
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* LOOK FOR MISSING #define CONSTANTS
*
* This section is used to generate ERROR messages at compile time if certain #define constants are
* MISSING in OS_CFG.H. This allows you to quickly determine the source of the error.
*
* You SHOULD NOT change this section UNLESS you would like to add more comments as to the source of the
* compile time error.
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* EVENT FLAGS
*********************************************************************************************************
*/
#ifndef OS_FLAG_EN
config_error "OS_CFG.H, Missing OS_FLAG_EN: Enable (1) or Disable (0) code generation for Event Flags"
#else
#ifndef OS_MAX_FLAGS
config_error "OS_CFG.H, Missing OS_MAX_FLAGS: Max. number of Event Flag Groups in your application"
#else
#if OS_MAX_FLAGS == 0
config_error "OS_CFG.H, OS_MAX_FLAGS must be > 0"
#endif
#if OS_MAX_FLAGS > 255
config_error "OS_CFG.H, OS_MAX_FLAGS must be <= 255"
#endif
#endif
#ifndef OS_FLAG_WAIT_CLR_EN
config_error "OS_CFG.H, Missing OS_FLAG_WAIT_CLR_EN: Include code for Wait on Clear EVENT FLAGS"
#endif
#ifndef OS_FLAG_ACCEPT_EN
config_error "OS_CFG.H, Missing OS_FLAG_ACCEPT_EN: Include code for OSFlagAccept()"
#endif
#ifndef OS_FLAG_DEL_EN
config_error "OS_CFG.H, Missing OS_FLAG_DEL_EN: Include code for OSFlagDel()"
#endif
#ifndef OS_FLAG_QUERY_EN
config_error "OS_CFG.H, Missing OS_FLAG_QUERY_EN: Include code for OSFlagQuery()"
#endif
#endif
/*
*********************************************************************************************************
* MESSAGE MAILBOXES
*********************************************************************************************************
*/
#ifndef OS_MBOX_EN
config_error "OS_CFG.H, Missing OS_MBOX_EN: Enable (1) or Disable (0) code generation for MAILBOXES"
#else
#ifndef OS_MBOX_ACCEPT_EN
config_error "OS_CFG.H, Missing OS_MBOX_ACCEPT_EN: Include code for OSMboxAccept()"
#endif
#ifndef OS_MBOX_DEL_EN
config_error "OS_CFG.H, Missing OS_MBOX_DEL_EN: Include code for OSMboxDel()"
#endif
#ifndef OS_MBOX_POST_EN
config_error "OS_CFG.H, Missing OS_MBOX_POST_EN: Include code for OSMboxPost()"
#endif
#ifndef OS_MBOX_POST_OPT_EN
config_error "OS_CFG.H, Missing OS_MBOX_POST_OPT_EN: Include code for OSMboxPostOpt()"
#endif
#ifndef OS_MBOX_QUERY_EN
config_error "OS_CFG.H, Missing OS_MBOX_QUERY_EN: Include code for OSMboxQuery()"
#endif
#endif
/*
*********************************************************************************************************
* MEMORY MANAGEMENT
*********************************************************************************************************
*/
#ifndef OS_MEM_EN
config_error "OS_CFG.H, Missing OS_MEM_EN: Enable (1) or Disable (0) code generation for MEMORY MANAGER"
#else
#ifndef OS_MAX_MEM_PART
config_error "OS_CFG.H, Missing OS_MAX_MEM_PART: Max. number of memory partitions"
#else
#if OS_MAX_MEM_PART == 0
config_error "OS_CFG.H, OS_MAX_MEM_PART must be > 0"
#endif
#if OS_MAX_MEM_PART > 255
config_error "OS_CFG.H, OS_MAX_MEM_PART must be <= 255"
#endif
#endif
#ifndef OS_MEM_QUERY_EN
config_error "OS_CFG.H, Missing OS_MEM_QUERY_EN: Include code for OSMemQuery()"
#endif
#endif
/*
*********************************************************************************************************
* MUTUAL EXCLUSION SEMAPHORES
*********************************************************************************************************
*/
#ifndef OS_MUTEX_EN
config_error "OS_CFG.H, Missing OS_MUTEX_EN: Enable (1) or Disable (0) code generation for MUTEX"
#else
#ifndef OS_MUTEX_ACCEPT_EN
config_error "OS_CFG.H, Missing OS_MUTEX_ACCEPT_EN: Include code for OSMutexAccept()"
#endif
#ifndef OS_MUTEX_DEL_EN
config_error "OS_CFG.H, Missing OS_MUTEX_DEL_EN: Include code for OSMutexDel()"
#endif
#ifndef OS_MUTEX_QUERY_EN
config_error "OS_CFG.H, Missing OS_MUTEX_QUERY_EN: Include code for OSMutexQuery()"
#endif
#endif
/*
*********************************************************************************************************
* MESSAGE QUEUES
*********************************************************************************************************
*/
#ifndef OS_Q_EN
config_error "OS_CFG.H, Missing OS_Q_EN: Enable (1) or Disable (0) code generation for QUEUES"
#else
#ifndef OS_MAX_QS
config_error "OS_CFG.H, Missing OS_MAX_QS: Max. number of queue control blocks"
#else
#if OS_MAX_QS == 0
config_error "OS_CFG.H, OS_MAX_QS must be > 0"
#endif
#if OS_MAX_QS > 255
config_error "OS_CFG.H, OS_MAX_QS must be <= 255"
#endif
#endif
#ifndef OS_Q_ACCEPT_EN
config_error "OS_CFG.H, Missing OS_Q_ACCEPT_EN: Include code for OSQAccept()"
#endif
#ifndef OS_Q_DEL_EN
config_error "OS_CFG.H, Missing OS_Q_DEL_EN: Include code for OSQDel()"
#endif
#ifndef OS_Q_FLUSH_EN
config_error "OS_CFG.H, Missing OS_Q_FLUSH_EN: Include code for OSQFlush()"