OOSMOS | API Reference

An active OOSMOS object is an object that has reactive behavior but does not have the complexity to warrant using a full OOSMOS state machine object.
To establish your object as an active object, you must register it with OOSMOS like this: create a subroutine for OOSMOS to call (line 118), then create an oosmos_sActiveObject member in your object (line 54) and then finally call oosmos_ActiveObjectInit (line 66).

1
2
3

void oosmos_ActiveObjectInit(void * pObject, oosmos_sActiveObject * pActiveObject, oosmos_tActiveObjectFunc pFunc);

Prototype

pObject	Pointer to your active object.
pActiveObject	Pointer to the `oosmos_sActiveObject` object member.
pFunction	Address of the function to call each time through the `OOSMOS` main loop.
See Also	`sActiveObject`

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
//	[GPLv2]
// OOSMOS sw Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#ifndef swMaxSwitches	[...]
#define swMaxSwitches 20
#endif

#ifndef swMaxCloseSubscribers
#define swMaxCloseSubscribers 1
#endif

#ifndef swMaxOpenSubscribers
#define swMaxOpenSubscribers 1
#endif

//===================================

#include "oosmos.h"
#include "pin.h"
#include "sw.h"
#include <stdbool.h>
#include <stddef.h>

typedef enum {
Unknown_State = 1,
Open_State,
Closed_State
} eStates;

struct swTag
{
pin * m_pPin;
eStates m_State;

oosmos_sActiveObject m_ActiveObject;
oosmos_sSubscriberList m_CloseEvent[swMaxCloseSubscribers];
oosmos_sSubscriberList m_OpenEvent[swMaxOpenSubscribers];
};

extern sw * swNewDetached(pin * pPin)
{
oosmos_Allocate(pSwitch, sw, swMaxSwitches, NULL);

pSwitch->m_pPin = pPin;
pSwitch->m_State = Unknown_State;

oosmos_ActiveObjectInit(pSwitch, m_ActiveObject, swRunStateMachine);

oosmos_SubscriberListInit(pSwitch->m_CloseEvent);
oosmos_SubscriberListInit(pSwitch->m_OpenEvent);

return pSwitch;
}

extern sw * swNew(pin * pPin)	[...]
{
sw * pSwitch = swNewDetached(pPin);
return pSwitch;
}

extern void swSubscribeCloseEvent(sw * pSwitch, oosmos_sQueue * pQueue, int CloseEventCode, void * pContext)
{
oosmos_POINTER_GUARD(pSwitch);

oosmos_SubscriberListAdd(pSwitch->m_CloseEvent, pQueue, CloseEventCode, pContext);
}

extern void swSubscribeOpenEvent(sw * pSwitch, oosmos_sQueue * pQueue, int OpenEventCode, void * pContext)
{
oosmos_POINTER_GUARD(pSwitch);

oosmos_SubscriberListAdd(pSwitch->m_OpenEvent, pQueue, OpenEventCode, pContext);
}

static eStates PhysicalSwitchState(const sw * pSwitch)
{
oosmos_POINTER_GUARD(pSwitch);

return pinIsOn(pSwitch->m_pPin) ? Closed_State : Open_State;
}

extern bool swIsOpen(const sw * pSwitch)
{
return !swIsClosed(pSwitch);
}

extern bool swIsClosed(const sw * pSwitch)
{
oosmos_POINTER_GUARD(pSwitch);

if (pSwitch->m_State == Unknown_State) {
return PhysicalSwitchState(pSwitch) == Closed_State;
}
else {
return pSwitch->m_State == Closed_State;
}
}

extern void swRunStateMachine(void * pObject)
{
oosmos_POINTER_GUARD(pObject);

sw * pSwitch = (sw *) pObject;

switch (pSwitch->m_State) {
case Open_State: {
if (pinIsOn(pSwitch->m_pPin)) {
pSwitch->m_State = Closed_State;
oosmos_SubscriberListNotify(pSwitch->m_CloseEvent);
}

break;
}
case Closed_State: {
if (pinIsOff(pSwitch->m_pPin)) {
pSwitch->m_State = Open_State;
oosmos_SubscriberListNotify(pSwitch->m_OpenEvent);
}

break;
}
case Unknown_State: {
pSwitch->m_State = pinIsOn(pSwitch->m_pPin) ? Closed_State : Open_State;
break;
}
}
}

oosmos/Classes/sw.c

oosmos_Allocate is a macro that returns a pointer to an unused object from a fixed number of statically preallocated objects. The static preallocation is done automatically within the macro. Once allocated, objects cannot be returned to the pool. See the example on line 82.
If you need dynamic memory, use malloc in place of this function and then create a complementary toggleDelete function and then do a free to release it.

1
2
3

Type * oosmos_Allocate(Pointer, Type, Elements, pOutOfMemory);

Prototype

Pointer	The name of the variable that will hold the pointer to the allocated object. You'll use this to initialize your object's members, including the state machine (if the object has one). You must return this pointer to the caller. (See `toggle.c` line 97 below.)
Type	The data type of the object. (See line 29 of `toggle.h` below.)
Elements	The number of objects to pre-allocate. You can specify a number here, but it would be better to use the macro technique used in lines 23-25 of the `toggle.c` where you specify a default amount that can be overridden on the compilation command line. This is commonly done with most compilers like this: `-D` `toggleMax=10`.
pOutOfMemory	The address of a subroutine to call if all preallocated objects have been exhausted. See type `oosmos_tOutOfMemory` for information about how to implement the called routine. If `NULL`, `oosmos_Allocate` will loop forever when all objects of this type are exhausted.
See Also	`AllocateVisible`

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
//	[GPLv2]
// OOSMOS toggle Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#ifndef toggle_h	[...]
#define toggle_h

#include "pin.h"
#include <stdint.h>

typedef struct toggleTag toggle;

extern toggle * toggleNew(pin * pPin, uint32_t TimeOnMS, uint32_t TimeOffMS);

#endif

oosmos/Classes/toggle.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
//	[GPLv2]
// OOSMOS toggle Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#ifndef toggleMAX
#define toggleMAX 5
#endif

//===================================	[...]

#include "oosmos.h"
#include "toggle.h"
#include "pin.h"
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>

struct toggleTag
{
oosmos_sObjectThread m_ObjectThread;

pin * m_pPin;
uint32_t m_TimeOnMS;
uint32_t m_TimeOffMS;
};

static void ToggleThread(const toggle * pToggle, oosmos_sState * pState)
{
oosmos_POINTER_GUARD(pToggle);
oosmos_POINTER_GUARD(pState);

oosmos_ThreadBegin();
for (;;) {
pinOn(pToggle->m_pPin);
oosmos_ThreadDelayMS(pToggle->m_TimeOnMS);

pinOff(pToggle->m_pPin);
oosmos_ThreadDelayMS(pToggle->m_TimeOffMS);
}
oosmos_ThreadEnd();
}

extern toggle * toggleNew(pin * pPin, uint32_t TimeOnMS, uint32_t TimeOffMS)
{
oosmos_Allocate(pToggle, toggle, toggleMAX, NULL);

oosmos_ObjectThreadInit(pToggle, m_ObjectThread, ToggleThread, true);

pToggle->m_pPin = pPin;
pToggle->m_TimeOnMS = TimeOnMS;
pToggle->m_TimeOffMS = TimeOffMS;

return pToggle;
}

oosmos/Classes/toggle.c

oosmos_AllocateVisible is functionally the same as oosmos_Allocate but allows the user to allocate the array of objects in an outer scope thereby allowing access to that array by other parts of the implementation of the object. (See line 83 of the example below.)

1
2
3

Type * oosmos_AllocateVisible(Pointer, Type, List, Count, Elements, pOutOfMemory);

Prototype

Pointer	The name of the variable that will hold the pointer to the allocated object. You'll use this to initialize your object's members, including the state machine (if the object has one). You must return this pointer to the caller (see line 90).
Type	The data type of the object. (See line 32 of `Interrupt.c`.)
List	The address of the array of objects you pre-allocated. (See line 46.)
Count	The number of objects that have been returned from `oosmos_AllocateVisible`. (See line 47.)
Elements	The number of objects to pre-allocate.
pOutOfMemory	The address of a subroutine to call if all preallocated objects have been exhausted. See type `oosmos_tOutOfMemory` for information about how to implement the called routine. If `NULL` is specified, `oosmos_AllocateVisible` will loop forever when all objects of this type are exhausted.
See Also	`Allocate`

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
//	[GPLv2]
// OOSMOS - Interrupt structure example on Windows
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdbool.h>
#include <stdio.h>
#include <stdint.h>

//
// Demonstrates structure of how to react to interrupts using OOSMOS.
//

typedef struct uartTag uart;

struct uartTag	struct uartTag {...}
{
uint8_t m_UartId;

oosmos_sQueue m_ReceiveDataQueue;
uint8_t m_ReceiveDataQueueData[10];

oosmos_sActiveObject m_ActiveObject;
};

#define MAX_UARTS 5

static uart UartList[MAX_UARTS];
static unsigned UartCount = 0;

static void ReceiverStateMachine(void * pObject)	static void ReceiverStateMachine(...) {...}
{
uart * pUART = (uart *) pObject;
uint8_t Byte;

//DisableInterrupt(pUART);
const bool PopSuccess = oosmos_QueuePop(&pUART->m_ReceiveDataQueue, &Byte, sizeof(Byte));
//EnableInterrupt(pUART);

if (!PopSuccess) {
return;
}

printf("Received %d\n", Byte);
}
	static void ISR(...) {...}
static void ISR(const int UartId)
{
uart * pUART = UartList;

for (unsigned Count = 0; Count < UartCount; pUART++, Count++) {
if (UartId != pUART->m_UartId) {
continue;
}

const uint8_t Byte = (uint8_t) UartId;
oosmos_QueuePush(&pUART->m_ReceiveDataQueue, &Byte, sizeof(Byte));

return;
}
}

extern uart * uartNew(unsigned UartId)
{
oosmos_AllocateVisible(pUART, uart, UartList, UartCount, MAX_UARTS, NULL);

pUART->m_UartId = (uint8_t) UartId;

oosmos_QueueConstruct(&pUART->m_ReceiveDataQueue, pUART->m_ReceiveDataQueueData);
oosmos_ActiveObjectInit(pUART, m_ActiveObject, ReceiverStateMachine);

return pUART;
}

extern int main(void)
{	extern int main(void) {...}
(void) uartNew(1);
(void) uartNew(3);
(void) uartNew(7);

// Simulate random interrupts...

ISR(3);
oosmos_RunStateMachines();
ISR(7);
oosmos_RunStateMachines();
ISR(1);
oosmos_RunStateMachines();

return 0;
}

oosmos/Examples/Interrupt/Windows/Interrupt.c

Scales a value from a point within one range to the proportionate point in a different range. This function uses a floating point type to guarantee the most accurate result. If speed is more important than accuracy, use oosmos_AnalogMapFast.
See example on line 36, below.

1
2
3

double oosmos_AnalogMapAccurate(double Value, double InMin, double InMax, double OutMin, double OutMax);

Prototype

Value	The value to be scaled.
InMin	The low end of the source range.
InMax	The high end of the source range.
OutMin	The low end of the target range.
OutMax	The high end of the target range.
RETURN	Returns the scaled number as a floating point value.
See Also	`AnalogMapFast`

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
//	[GPLv2]
// OOSMOS AnalogMap Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <stdio.h>	[...]
#include <stdint.h>
#include "oosmos.h"

#define ITERATIONS 25

/lint -e728 Suppress "Not explicitly initialized" /
static int FastDistribution[ITERATIONS+1];
/lint -e728 Suppress "Not explicitly initialized" /
static int AccurateDistribution[ITERATIONS+1];

static void TestAccurate(double Value, double InMin, double InMax, double OutMin, double OutMax)
{
const double Result = oosmos_AnalogMapAccurate(Value, InMin, InMax, OutMin, OutMax);

printf("Value:%f, InMin:%f, InMax:%f, OutMin:%f, OutMax:%f, Result:%f\n", Value, InMin, InMax, OutMin, OutMax, Result);

const long IntResult = (long) (Result + .5f);
AccurateDistribution[IntResult]++;
}

static void TestFast(int32_t Value, int32_t InMin, int32_t InMax, int32_t OutMin, int32_t OutMax)	[...]
{
const int32_t Result = oosmos_AnalogMapFast(Value, InMin, InMax, OutMin, OutMax);
printf("Value:%ld, InMin:%ld, InMax:%ld, OutMin:%ld, OutMax:%ld, Result:%ld\n",
(long) Value, (long) InMin, (long) InMax, (long) OutMin, (long) OutMax, (long) Result);

FastDistribution[Result]++;
}

extern int main(void)
{
const int32_t Min = 1;
const int32_t Max = 1000;

//
// Test accurate implementation...
//
for (unsigned I = Min; I <= Max; I++) {
TestAccurate((double) I, (double) Min, (double) Max, 1.0, 25.0);
}

for (unsigned I = 1; I <= ITERATIONS; I++) {
printf("%d\n", AccurateDistribution[I]);
}

//
// Test fast implementation...
//
for (int32_t I = Min; I <= Max; I++) {
TestFast(I, Min, Max, 1, 25);
}

for (unsigned I = 1; I <= ITERATIONS; I++) {
printf("%d\n", FastDistribution[I]);
}

return 0;
}

oosmos/Examples/AnalogMap/Windows/AnalogMap.c

Scales a value from a point within one range to the proportionate point in a different range. This function uses a long integral data type in order to calculate the result quickly. If accuracy is more important thqan speed, use oosmos_AnalogMapAccurate.
See example on line 46, below.

1
2
3

int32_t oosmos_AnalogMapFast(int32_t Value, int32_t InMin, int32_t InMax, int32_t OutMin, int32_t OutMax));

Prototype

Value	The value to be scaled.
InMin	The low end of the source range.
InMax	The high end of the source range.
OutMin	The low end of the target range.
OutMax	The high end of the target range.
RETURN	Returns the scaled number as a long integral value.
See Also	`AnalogMapAccurate`

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
//	[GPLv2]
// OOSMOS AnalogMap Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <stdio.h>	[...]
#include <stdint.h>
#include "oosmos.h"

#define ITERATIONS 25

/lint -e728 Suppress "Not explicitly initialized" /
static int FastDistribution[ITERATIONS+1];
/lint -e728 Suppress "Not explicitly initialized" /
static int AccurateDistribution[ITERATIONS+1];

static void TestAccurate(double Value, double InMin, double InMax, double OutMin, double OutMax)
{
const double Result = oosmos_AnalogMapAccurate(Value, InMin, InMax, OutMin, OutMax);

printf("Value:%f, InMin:%f, InMax:%f, OutMin:%f, OutMax:%f, Result:%f\n", Value, InMin, InMax, OutMin, OutMax, Result);

const long IntResult = (long) (Result + .5f);
AccurateDistribution[IntResult]++;
}

static void TestFast(int32_t Value, int32_t InMin, int32_t InMax, int32_t OutMin, int32_t OutMax)
{
const int32_t Result = oosmos_AnalogMapFast(Value, InMin, InMax, OutMin, OutMax);
printf("Value:%ld, InMin:%ld, InMax:%ld, OutMin:%ld, OutMax:%ld, Result:%ld\n",
(long) Value, (long) InMin, (long) InMax, (long) OutMin, (long) OutMax, (long) Result);

FastDistribution[Result]++;
}

extern int main(void)	[...]
{
const int32_t Min = 1;
const int32_t Max = 1000;

//
// Test accurate implementation...
//
for (unsigned I = Min; I <= Max; I++) {
TestAccurate((double) I, (double) Min, (double) Max, 1.0, 25.0);
}

for (unsigned I = 1; I <= ITERATIONS; I++) {
printf("%d\n", AccurateDistribution[I]);
}

//
// Test fast implementation...
//
for (int32_t I = Min; I <= Max; I++) {
TestFast(I, Min, Max, 1, 25);
}

for (unsigned I = 1; I <= ITERATIONS; I++) {
printf("%d\n", FastDistribution[I]);
}

return 0;
}

oosmos/Examples/AnalogMap/Windows/AnalogMap.c

oosmos_ASSERT works just like the standard C assert, but instead of aborting the program (which doesn't mean much on an embedded system), it will loop endlessly.

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
//	[GPLv2]
// OOSMOS reg Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "reg.h"	[...]
#include "oosmos.h"
#include <stdint.h>

struct regTag
{
float m_Intercept;
float m_Slope;
};

static float MeanOfX(const regSample * pSamples, uint32_t Samples)
{
float Sum = 0.0f;

for (uint32_t SampleIndex = 0; SampleIndex < Samples; SampleIndex++) {
Sum += pSamples[SampleIndex].X;
}

return Sum / Samples;
}

static float MeanOfY(const regSample * pSamples, uint32_t Samples)
{
float Sum = 0.0f;

for (uint32_t SampleIndex = 0; SampleIndex < Samples; SampleIndex++) {
Sum += pSamples[SampleIndex].Y;
}

return Sum / Samples;
}

extern reg * regNew(void)
{
static reg Reg[1];
reg * pReg = &Reg[0];

return pReg;
}

extern void regSamples(reg * pReg, const regSample * pSamples, uint32_t Samples)
{
const float MeanX = MeanOfX(pSamples, Samples);
const float MeanY = MeanOfY(pSamples, Samples);

float SumXY = 0.0f;
float SumXX = 0.0f;

for (uint32_t SampleIndex = 0; SampleIndex < Samples; SampleIndex++) {
const regSample * pSample = &pSamples[SampleIndex];

const float XiMinusMeanX = pSample->X - MeanX;
const float YiMinusMeanY = pSample->Y - MeanY;

SumXY += XiMinusMeanX * YiMinusMeanY;
SumXX += XiMinusMeanX * XiMinusMeanX;
}

oosmos_ASSERT(SumXX > 0.0f);

pReg->m_Slope = SumXY / SumXX;
pReg->m_Intercept = MeanY - pReg->m_Slope * MeanX;
}

extern float regPredictY(const reg * pReg, float X)	[...]
{
return pReg->m_Slope * X + pReg->m_Intercept;
}

oosmos/Classes/reg.c

oosmos_ClockSpeedInMHz tells OOSMOS the speed of the processor as configured externally. This call only applies to the PIC32 architecture.

1
2
3

void oosmos_ClockSpeedInMHz(uint32_t ClockSpeedMHz);

Prototype

oosmos_COMPLETE is one of the six predefined event macros. This event is generated when the final states within all orthogonal regions have been entered. See The User's Guide for more information.

See Also

DEFAULT, EXIT, POLL, TIMEOUT

oosmos_CompositeInit initializes an oosmos_sComposite state.
See line 122 of the code snippet below for an example.

1
2
3

void oosmos_CompositeInit(pObject, CompositeState, ParentState, DefaultState, pCode);

Prototype

pObject	The address of the object that contains the state machine.
CompositeState	The name of the composite state.
ParentState	The name of the parent state.
DefaultState	The name of the default state.
pCode	Pointer to event handler function.

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
//	[GPLv2]
// OOSMOS Final Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdio.h>
#include <stdbool.h>

//<<<EVENTS
//>>>EVENTS

typedef struct testTag test;

struct testTag
{
//>>>DECL
oosmos_sStateMachineNoQueue(ROOT);
oosmos_sComposite A_State;
oosmos_sLeaf A_Choice1_State;
oosmos_sLeaf A_Left_State;
oosmos_sLeaf A_Right_State;
oosmos_sFinal A_Final1_State;
oosmos_sLeaf B_State;
//<<<DECL
};

static bool IsLeft(void)
{
return true;
}

static void Default(void)
{
printf("In Default\n");
}

//>>>CODE
static bool A_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_DEFAULT: {
Default();
return true;
}
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, B_State);
}
}

return false;
}

static bool A_Choice1_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

if (oosmos_EventCode(pEvent) == oosmos_ENTER) {
if (IsLeft()) {
return oosmos_Transition(pTest, pState, A_Left_State);
}
else {
return oosmos_Transition(pTest, pState, A_Right_State);
}
}

return false;
}

static bool A_Left_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, A_Final1_State);
}
}

return false;
}

static bool A_Right_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, A_Final1_State);
}
}

return false;
}
//<<<CODE

static test * testNew(void)
{
oosmos_Allocate(pTest, test, 1, NULL);

//>>>INIT
oosmos_StateMachineInitNoQueue(pTest, ROOT, NULL, A_State);
oosmos_CompositeInit(pTest, A_State, ROOT, A_Choice1_State, A_State_Code);
oosmos_LeafInit(pTest, A_Choice1_State, A_State, A_Choice1_State_Code);
oosmos_LeafInit(pTest, A_Left_State, A_State, A_Left_State_Code);
oosmos_LeafInit(pTest, A_Right_State, A_State, A_Right_State_Code);
oosmos_FinalInit(pTest, A_Final1_State, A_State, NULL);
oosmos_LeafInit(pTest, B_State, ROOT, NULL);

oosmos_Debug(pTest, NULL);
//<<<INIT

return pTest;
}

extern int main(void)	[...]
{
test * pTest = (test *) testNew();

for (;;) {
oosmos_RunStateMachines();

if (oosmos_IsInState(pTest, &pTest->B_State)) {
printf("SUCCESS.\n");
break;
}

oosmos_DelayMS(1);
}
}

oosmos/Examples/Basic/Windows/Final.c

oosmos_Days2Hours is a macro that converts days to hours.

1
2
3

oosmos_Days2Hours(Days)

Macro

See Also

Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Days2Minutes is a macro that converts days to minutes.

1
2
3

oosmos_Days2Minutes(Days)

Macro

See Also

Days2Hours, Days2MS, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Days2MS is a macro that converts days to milliseconds.

1
2
3

oosmos_Days2MS(Days)

Macro

See Also

Days2Hours, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Days2Seconds is a macro that converts days to seconds.

1
2
3

oosmos_Days2Seconds(Days)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Days2US is a macro that converts days to microseconds.

1
2
3

oosmos_Days2US(Days)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

A call to oosmos_Debug is generated by the OOSMOS code generator when the debug option is specified in your .json generator configuration file. oosmos_Debug enables debug output indicating when transitions are made into and out of states and when events occur. See line 168 in the code snippet below for an example.

1
2
3

oosmos_Debug(oosmos_sStateMachine * pStateMachine, const char * (*pNameTable)(int));

Prototype

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Completion.c: ==> Ortho_State
Completion.c: ==> Ortho_Region2_Idle_State
Completion.c: ==> Ortho_Region1_Idle_State
Completion.c: EVENT: evA (1)
Completion.c: Ortho_Region1_Idle_State -->
Completion.c: --> Ortho_Region1_Moving_State
Completion.c: EVENT: evB (2)
Completion.c: Ortho_Region2_Idle_State -->
Completion.c: --> Ortho_Region2_Moving_State
Completion.c: EVENT: evStop (3)
Completion.c: Ortho_Region2_Moving_State -->
Completion.c: --> Ortho_Region2_Final2_State
Completion.c: Ortho_Region1_Moving_State -->
Completion.c: --> Ortho_Region1_Final1_State
Completion.c: ((( Ortho_State Complete )))
Completion.c: Ortho_Region2_Final2_State -->
Completion.c: Ortho_Region1_Final1_State -->
Completion.c: Ortho_State -->
Completion.c: --> Complete_State

--Goal State Achieved--
SUCCESS

Output from running Completion.exe

pStateMachine	The address of the object's state machine.
pNameTable	This argument specifies the address of a function that returns the string representation of an event code.

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
//	[GPLv2]
// OOSMOS Completion Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdbool.h>
#include <stdio.h>

//>>>EVENTS
enum {
evA = 1,
evB = 2,
evStop = 3
};

#ifdef oosmos_DEBUG
static const char * OOSMOS_EventNames(int EventCode)
{
switch (EventCode) {
case evA: return "evA";
case evB: return "evB";
case evStop: return "evStop";
default: return "";
}
}
#endif
//<<<EVENTS

typedef struct testTag test;

typedef union {
oosmos_sEvent Base;
} uEvents;

struct testTag
{
//>>>DECL
oosmos_sStateMachine(ROOT, uEvents, 3);
oosmos_sOrtho Ortho_State;
oosmos_sOrthoRegion Ortho_Region1_State;
oosmos_sLeaf Ortho_Region1_Moving_State;
oosmos_sLeaf Ortho_Region1_Idle_State;
oosmos_sFinal Ortho_Region1_Final1_State;
oosmos_sOrthoRegion Ortho_Region2_State;
oosmos_sLeaf Ortho_Region2_Idle_State;
oosmos_sLeaf Ortho_Region2_Moving_State;
oosmos_sFinal Ortho_Region2_Final2_State;
oosmos_sLeaf Complete_State;
//<<<DECL
};

//>>>CODE
static bool Ortho_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, Complete_State);
}
}

return false;
}

static bool Ortho_Region1_Moving_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evStop: {
return oosmos_Transition(pTest, pState, Ortho_Region1_Final1_State);
}
}

return false;
}

static bool Ortho_Region1_Idle_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evA: {
return oosmos_Transition(pTest, pState, Ortho_Region1_Moving_State);
}
}

return false;
}

static bool Ortho_Region2_Idle_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evB: {
return oosmos_Transition(pTest, pState, Ortho_Region2_Moving_State);
}
}

return false;
}

static bool Ortho_Region2_Moving_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evStop: {
return oosmos_Transition(pTest, pState, Ortho_Region2_Final2_State);
}
}

return false;
}

static bool Complete_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
printf("\n--Goal State Achieved--\n");
return true;
}
}

oosmos_UNUSED(pObject);
oosmos_UNUSED(pState);
return false;
}
//<<<CODE

static test * testNew(void)
{
oosmos_Allocate(pTest, test, 1, NULL);

//>>>INIT
oosmos_StateMachineInit(pTest, ROOT, NULL, Ortho_State);
oosmos_OrthoInit(pTest, Ortho_State, ROOT, Ortho_State_Code);
oosmos_OrthoRegionInit(pTest, Ortho_Region1_State, Ortho_State, Ortho_Region1_Idle_State, NULL);
oosmos_LeafInit(pTest, Ortho_Region1_Moving_State, Ortho_Region1_State, Ortho_Region1_Moving_State_Code);
oosmos_LeafInit(pTest, Ortho_Region1_Idle_State, Ortho_Region1_State, Ortho_Region1_Idle_State_Code);
oosmos_FinalInit(pTest, Ortho_Region1_Final1_State, Ortho_Region1_State, NULL);
oosmos_OrthoRegionInit(pTest, Ortho_Region2_State, Ortho_State, Ortho_Region2_Idle_State, NULL);
oosmos_LeafInit(pTest, Ortho_Region2_Idle_State, Ortho_Region2_State, Ortho_Region2_Idle_State_Code);
oosmos_LeafInit(pTest, Ortho_Region2_Moving_State, Ortho_Region2_State, Ortho_Region2_Moving_State_Code);
oosmos_FinalInit(pTest, Ortho_Region2_Final2_State, Ortho_Region2_State, NULL);
oosmos_LeafInit(pTest, Complete_State, ROOT, Complete_State_Code);

oosmos_Debug(pTest, OOSMOS_EventNames);
//<<<INIT

return pTest;
}

static void QueueEvent(const test * pTest, int EventCode)	[...]
{
oosmos_PushEventCode(pTest, EventCode);
oosmos_RunStateMachines();
}

extern int main(void)
{
test * pTest = testNew();

QueueEvent(pTest, evA);
QueueEvent(pTest, evB);
QueueEvent(pTest, evStop);

if (oosmos_IsInState(pTest, &pTest->Complete_State))
printf("SUCCESS\n");
else
printf("FAILURE\n");

return 0;
}

oosmos/Examples/Ortho/Windows/Completion.c

oosmos_DebugPrint

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
//	[GPLv2]
// OOSMOS EventDemo example, control object
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include "control.h"
#include "motor.h"
#include "pump.h"
#include "pin.h"
#include "sw.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>


//>>>EVENTS
enum {
evMovePressed = 1,
evOption1Pressed = 2,
evOption2Pressed = 3,
evPumpPressed = 4,
evQuitPressed = 5,
evStopPressed = 6,
evStopReleased = 7
};

#ifdef oosmos_DEBUG
static const char * OOSMOS_EventNames(int EventCode)
{
switch (EventCode) {
case evMovePressed: return "evMovePressed";
case evOption1Pressed: return "evOption1Pressed";
case evOption2Pressed: return "evOption2Pressed";
case evPumpPressed: return "evPumpPressed";
case evQuitPressed: return "evQuitPressed";
case evStopPressed: return "evStopPressed";
case evStopReleased: return "evStopReleased";
default: return "";
}
}
#endif
//<<<EVENTS

typedef union {
oosmos_sEvent Event;
} uEvents;

struct controlTag
{
motor * m_pMotor;
pump * m_pPump;
bool m_Option1;
bool m_Option2;

//>>>DECL
oosmos_sStateMachine(ROOT, uEvents, 3);
oosmos_sLeaf StartingUp_State;
oosmos_sOrtho Operational_State;
oosmos_sOrthoRegion Operational_Region1_State;
oosmos_sLeaf Operational_Region1_Moving_State;
oosmos_sLeaf Operational_Region1_Idle_State;
oosmos_sOrthoRegion Operational_Region2_State;
oosmos_sLeaf Operational_Region2_Idle_State;
oosmos_sLeaf Operational_Region2_Pumping_State;
oosmos_sLeaf StopPressed_State;
oosmos_sLeaf Terminated_State;
//<<<DECL
};

static void ToggleOption1(control * pControl)
{
pControl->m_Option1 = !(pControl->m_Option1);
oosmos_DebugPrint("Option1: %d\n", pControl->m_Option1);
}

static void ToggleOption2(control * pControl)
{
pControl->m_Option2 = !(pControl->m_Option2);
oosmos_DebugPrint("Option2: %d\n", pControl->m_Option1);
}

//>>>CODE	[...]
static bool StartingUp_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
control * pControl = (control *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
return oosmos_StateTimeoutSeconds(pState, (uint32_t) 1);
}
case oosmos_TIMEOUT: {
return oosmos_Transition(pControl, pState, Operational_State);
}
}

return false;
}

static bool Operational_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
control * pControl = (control *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evStopPressed: {
return oosmos_Transition(pControl, pState, StopPressed_State);
}
case evQuitPressed: {
return oosmos_Transition(pControl, pState, Terminated_State);
}
}

return false;
}

static bool StopPressed_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
control * pControl = (control *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evOption1Pressed: {
ToggleOption1(pControl);
return true;
}
case evOption2Pressed: {
ToggleOption2(pControl);
return true;
}
case evStopReleased: {
return oosmos_Transition(pControl, pState, Operational_State);
}
}

return false;
}

static bool Operational_Region1_Moving_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
control * pControl = (control *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
motorOn(pControl->m_pMotor);
return true;
}
case oosmos_EXIT: {
motorOff(pControl->m_pMotor);
return true;
}
case evMovePressed: {
return oosmos_Transition(pControl, pState, Operational_Region1_Idle_State);
}
}

return false;
}

static bool Operational_Region1_Idle_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
control * pControl = (control *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evMovePressed: {
return oosmos_Transition(pControl, pState, Operational_Region1_Moving_State);
}
}

return false;
}

static bool Terminated_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
exit(1);
}
}

oosmos_UNUSED(pObject);
oosmos_UNUSED(pState);
return false;
}

static bool Operational_Region2_Idle_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
control * pControl = (control *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evPumpPressed: {
return oosmos_Transition(pControl, pState, Operational_Region2_Pumping_State);
}
}

return false;
}

static bool Operational_Region2_Pumping_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
control * pControl = (control *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
pumpOn(pControl->m_pPump);
return true;
}
case oosmos_EXIT: {
pumpOff(pControl->m_pPump);
return true;
}
case evPumpPressed: {
return oosmos_Transition(pControl, pState, Operational_Region2_Idle_State);
}
}

return false;
}
//<<<CODE

extern control * controlNew(void)
{
oosmos_Allocate(pControl, control, 1, NULL);

oosmos_sQueue * const pControlEventQueue = &pControl->m_EventQueue;

pin * pStopPin = pinNew('s', pinActiveHigh);
sw * pStopSwitch = swNew(pStopPin);
swSubscribeCloseEvent(pStopSwitch, pControlEventQueue, evStopPressed, NULL);
swSubscribeOpenEvent(pStopSwitch, pControlEventQueue, evStopReleased, NULL);

pin * pMovePin = pinNew('m', pinActiveHigh);
sw * pMoveSwitch = swNew(pMovePin);
swSubscribeCloseEvent(pMoveSwitch, pControlEventQueue, evMovePressed, NULL);

pin * pQuitPin = pinNew('q', pinActiveHigh);
sw * pQuitSwitch = swNew(pQuitPin);
swSubscribeCloseEvent(pQuitSwitch, pControlEventQueue, evQuitPressed, NULL);

pin * pPumpPin = pinNew('p', pinActiveHigh);
sw * pPumpSwitch = swNew(pPumpPin);
swSubscribeCloseEvent(pPumpSwitch, pControlEventQueue, evPumpPressed, NULL);

pin * pOption1Pin = pinNew('1', pinActiveHigh);
sw * pOption1Switch = swNew(pOption1Pin);
swSubscribeCloseEvent(pOption1Switch, pControlEventQueue, evOption1Pressed, NULL);

pin * pOption2Pin = pinNew('2', pinActiveHigh);
sw * pOption2Switch = swNew(pOption2Pin);
swSubscribeCloseEvent(pOption2Switch, pControlEventQueue, evOption2Pressed, NULL);

pin * pUpPin = pinNew('u', pinActiveHigh);
sw * pUpSwitch = swNew(pUpPin);

pin * pDownPin = pinNew('d', pinActiveHigh);
sw * pDownSwitch = swNew(pDownPin);

pControl->m_pMotor = motorNew();
pControl->m_pPump = pumpNew(pUpSwitch, pDownSwitch);
pControl->m_Option1 = false;
pControl->m_Option2 = false;

//>>>INIT
oosmos_StateMachineInit(pControl, ROOT, NULL, StartingUp_State);
oosmos_LeafInit(pControl, StartingUp_State, ROOT, StartingUp_State_Code);
oosmos_OrthoInit(pControl, Operational_State, ROOT, Operational_State_Code);
oosmos_OrthoRegionInit(pControl, Operational_Region1_State, Operational_State, Operational_Region1_Idle_State, NULL);
oosmos_LeafInit(pControl, Operational_Region1_Moving_State, Operational_Region1_State, Operational_Region1_Moving_State_Code);
oosmos_LeafInit(pControl, Operational_Region1_Idle_State, Operational_Region1_State, Operational_Region1_Idle_State_Code);
oosmos_OrthoRegionInit(pControl, Operational_Region2_State, Operational_State, Operational_Region2_Idle_State, NULL);
oosmos_LeafInit(pControl, Operational_Region2_Idle_State, Operational_Region2_State, Operational_Region2_Idle_State_Code);
oosmos_LeafInit(pControl, Operational_Region2_Pumping_State, Operational_Region2_State, Operational_Region2_Pumping_State_Code);
oosmos_LeafInit(pControl, StopPressed_State, ROOT, StopPressed_State_Code);
oosmos_LeafInit(pControl, Terminated_State, ROOT, Terminated_State_Code);

oosmos_Debug(pControl, OOSMOS_EventNames);
//<<<INIT

return pControl;
}

oosmos/Examples/EventDemo/Windows/control.c

oosmos_DEFAULT is one of the six predefined event macros. This event is sent to the state once, before the state is entered, to allow the user the opportunity to execute initialization code. See line 61 in the code snippet below for an example.

See Also

COMPLETE, EXIT, POLL, TIMEOUT

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
//	[GPLv2]
// OOSMOS Final Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdio.h>
#include <stdbool.h>

//<<<EVENTS
//>>>EVENTS

typedef struct testTag test;

struct testTag
{
//>>>DECL
oosmos_sStateMachineNoQueue(ROOT);
oosmos_sComposite A_State;
oosmos_sLeaf A_Choice1_State;
oosmos_sLeaf A_Left_State;
oosmos_sLeaf A_Right_State;
oosmos_sFinal A_Final1_State;
oosmos_sLeaf B_State;
//<<<DECL
};

static bool IsLeft(void)
{
return true;
}

static void Default(void)
{
printf("In Default\n");
}

//>>>CODE
static bool A_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_DEFAULT: {
Default();
return true;
}
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, B_State);
}
}

return false;
}
	[...]
static bool A_Choice1_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

if (oosmos_EventCode(pEvent) == oosmos_ENTER) {
if (IsLeft()) {
return oosmos_Transition(pTest, pState, A_Left_State);
}
else {
return oosmos_Transition(pTest, pState, A_Right_State);
}
}

return false;
}

static bool A_Left_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, A_Final1_State);
}
}

return false;
}

static bool A_Right_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, A_Final1_State);
}
}

return false;
}
//<<<CODE

static test * testNew(void)
{
oosmos_Allocate(pTest, test, 1, NULL);

//>>>INIT
oosmos_StateMachineInitNoQueue(pTest, ROOT, NULL, A_State);
oosmos_CompositeInit(pTest, A_State, ROOT, A_Choice1_State, A_State_Code);
oosmos_LeafInit(pTest, A_Choice1_State, A_State, A_Choice1_State_Code);
oosmos_LeafInit(pTest, A_Left_State, A_State, A_Left_State_Code);
oosmos_LeafInit(pTest, A_Right_State, A_State, A_Right_State_Code);
oosmos_FinalInit(pTest, A_Final1_State, A_State, NULL);
oosmos_LeafInit(pTest, B_State, ROOT, NULL);

oosmos_Debug(pTest, NULL);
//<<<INIT

return pTest;
}

extern int main(void)
{
test * pTest = (test *) testNew();

for (;;) {
oosmos_RunStateMachines();

if (oosmos_IsInState(pTest, &pTest->B_State)) {
printf("SUCCESS.\n");
break;
}

oosmos_DelayMS(1);
}
}

oosmos/Examples/Basic/Windows/Final.c

oosmos_DelayMS suspends all processing for a specified number of milliseconds. oosmos_DelayMS is a thread blocker, not an object blocker. If you want to suspend only the current object, use the oosmos_TimeoutInMS or oosmos_ThreadDelayMS (inside of a thread group) instead. See line 29 of the snippet below for an example.

1
2
3

void oosmos_DelayMS(uint32_t Milliseconds);

Prototype

See Also

DelaySeconds, DelayUS, ThreadDelayMS, ThreadDelaySeconds, ThreadDelayUS, TimeoutInMS, TimeoutInSeconds, TimeoutInUS

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
//	[GPLv2]
// OOSMOS DelayMS Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <stdio.h>
#include "oosmos.h"

extern int main(void)
{
for (unsigned LoopCount = 1; LoopCount <= 5; LoopCount++) {
oosmos_DelayMS(500);
printf("Work...\n");
}

printf("SUCCESS\n");

return 0;
}

DelayMS.c

oosmos_DelaySeconds suspends all processing for a specified number of seconds. See line 29 of the snippet below for an example.
oosmos_DelaySeconds is a thread blocker, not an object blocker. If you want to suspend only the current object, use the oosmos_TimeoutInSeconds or oosmos_ThreadDelayMS inside of a thread group instead.

1
2
3

void oosmos_DelaySeconds(uint32_t Seconds);

Prototype

See Also

DelayMS, DelayUS, ThreadDelayMS, ThreadDelaySeconds, ThreadDelayUS, TimeoutInMS, TimeoutInSeconds, TimeoutInUS

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
//	[GPLv2]
// OOSMOS DelaySeconds Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <stdio.h>
#include "oosmos.h"

extern int main(void)
{
for (unsigned LoopCount = 1; LoopCount <= 5; LoopCount++) {
oosmos_DelaySeconds(1);
printf("Work...\n");
}

printf("SUCCESS\n");

return 0;
}

DelaySeconds.c

oosmos_DelayUS suspends all processing for a specified number of microseconds. See line 29 of the snippet below for an example.
If you want to suspend only the current object, use the oosmos_TimeoutInUS instead.
Note that oosmos_DelayUS is not implemented on Windows.

1
2
3

void oosmos_DelayUS(uint32_t Microseconds);

Prototype

See Also

DelayMS, DelaySeconds, ThreadDelayMS, ThreadDelaySeconds, ThreadDelayUS, TimeoutInMS, TimeoutInSeconds, TimeoutInUS

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
//	[GPLv2]
// OOSMOS DelayUS Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <stdio.h>
#include "oosmos.h"

extern int main(void)
{
for (unsigned LoopCount = 1; LoopCount <= 5; LoopCount++) {
oosmos_DelayUS(1000 * 1000);
printf("Work...\n");
}

printf("SUCCESS\n");

return 0;
}

DelayUS.c

oosmos_Divide_Integral_Rounded is a macro that is used internally by the time unit conversion APIs, but it is externalized for your use.

1
2
3

oosmos_Divide_Integral_Rounded(Dividend, Divisor)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_EndProgram exits the program on platforms where that makes sense, like Windows and Linux. On other platforms, it is implemented as an endless loop, effectively stopping the program.

oosmos_ENTER is one of the six predefined event macros. This event is generated when the state is being entered. See line 53 in the code snippet below for an example.

See Also

COMPLETE, DEFAULT, EXIT, POLL, TIMEOUT

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
//	[GPLv2]
// OOSMOS toggle Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include "toggle.h"
#include "pin.h"
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>

#ifndef toggleMAX
#define toggleMAX 4
#endif

struct toggleTag
{
//>>>DECL
oosmos_sStateMachineNoQueue(ROOT);
oosmos_sLeaf Off_State;
oosmos_sLeaf On_State;
//<<<DECL

pin * m_pPin;
uint32_t m_TimeOnMS;
uint32_t m_TimeOffMS;
};

//>>>CODE
static bool Off_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
toggle * pToggle = (toggle *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
return oosmos_StateTimeoutMS(pState, (uint32_t) pToggle->m_TimeOffMS);
}
case oosmos_TIMEOUT: {
return oosmos_Transition(pToggle, pState, On_State);
}
}

return false;
}

static bool On_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)	[...]
{
toggle * pToggle = (toggle *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
pinOn(pToggle->m_pPin);
return oosmos_StateTimeoutMS(pState, (uint32_t) pToggle->m_TimeOnMS);
}
case oosmos_EXIT: {
pinOff(pToggle->m_pPin);
return true;
}
case oosmos_TIMEOUT: {
return oosmos_Transition(pToggle, pState, Off_State);
}
}

return false;
}
//<<<CODE

extern toggle * toggleNew(pin * pPin, uint32_t TimeOnMS, uint32_t TimeOffMS)
{
oosmos_Allocate(pToggle, toggle, toggleMAX, NULL);

//>>>INIT
oosmos_StateMachineInitNoQueue(pToggle, ROOT, NULL, On_State);
oosmos_LeafInit(pToggle, Off_State, ROOT, Off_State_Code);
oosmos_LeafInit(pToggle, On_State, ROOT, On_State_Code);
//<<<INIT

pToggle->m_pPin = pPin;
pToggle->m_TimeOnMS = TimeOnMS;
pToggle->m_TimeOffMS = TimeOffMS;

return pToggle;
}

oosmos/Classes/toggle_state.c (State machine version)

oosmos_EventCode is a macro that accesses the event code from within an OOSMOS event structure to improve readability of the generated code.
See line 52 for an example.

See Also

sState

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
//	[...]
// OOSMOS toggle Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"
#include "toggle.h"
#include "pin.h"
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>

#ifndef toggleMAX
#define toggleMAX 4
#endif

struct toggleTag
{
//>>>DECL
oosmos_sStateMachineNoQueue(ROOT);
oosmos_sLeaf Off_State;
oosmos_sLeaf On_State;
//<<<DECL

pin * m_pPin;
uint32_t m_TimeOnMS;
uint32_t m_TimeOffMS;
};

//>>>CODE
static bool Off_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
toggle * pToggle = (toggle *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
return oosmos_StateTimeoutMS(pState, (uint32_t) pToggle->m_TimeOffMS);
}
case oosmos_TIMEOUT: {
return oosmos_Transition(pToggle, pState, On_State);
}
}

return false;
}
	[...]
static bool On_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
toggle * pToggle = (toggle *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
pinOn(pToggle->m_pPin);
return oosmos_StateTimeoutMS(pState, (uint32_t) pToggle->m_TimeOnMS);
}
case oosmos_EXIT: {
pinOff(pToggle->m_pPin);
return true;
}
case oosmos_TIMEOUT: {
return oosmos_Transition(pToggle, pState, Off_State);
}
}

return false;
}
//<<<CODE

extern toggle * toggleNew(pin * pPin, uint32_t TimeOnMS, uint32_t TimeOffMS)
{
oosmos_Allocate(pToggle, toggle, toggleMAX, NULL);

//>>>INIT
oosmos_StateMachineInitNoQueue(pToggle, ROOT, NULL, On_State);
oosmos_LeafInit(pToggle, Off_State, ROOT, Off_State_Code);
oosmos_LeafInit(pToggle, On_State, ROOT, On_State_Code);
//<<<INIT

pToggle->m_pPin = pPin;
pToggle->m_TimeOnMS = TimeOnMS;
pToggle->m_TimeOffMS = TimeOffMS;

return pToggle;
}

oosmos/Classes/toggle_state.c (State machine version)

oosmos_EXIT is one of the six predefined event macros. This event is generated when the state is being exited as part of a transition to another state. See line 73 in the code snippet below for an example.

See Also

COMPLETE, DEFAULT, POLL, TIMEOUT

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
//	[GPLv2]
// OOSMOS toggle Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include "toggle.h"
#include "pin.h"
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>

#ifndef toggleMAX
#define toggleMAX 4
#endif

struct toggleTag
{
//>>>DECL
oosmos_sStateMachineNoQueue(ROOT);
oosmos_sLeaf Off_State;
oosmos_sLeaf On_State;
//<<<DECL

pin * m_pPin;
uint32_t m_TimeOnMS;
uint32_t m_TimeOffMS;
};

//>>>CODE
static bool Off_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
toggle * pToggle = (toggle *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
return oosmos_StateTimeoutMS(pState, (uint32_t) pToggle->m_TimeOffMS);
}
case oosmos_TIMEOUT: {
return oosmos_Transition(pToggle, pState, On_State);
}
}

return false;
}

static bool On_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
toggle * pToggle = (toggle *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
pinOn(pToggle->m_pPin);
return oosmos_StateTimeoutMS(pState, (uint32_t) pToggle->m_TimeOnMS);
}
case oosmos_EXIT: {
pinOff(pToggle->m_pPin);
return true;
}
case oosmos_TIMEOUT: {
return oosmos_Transition(pToggle, pState, Off_State);
}
}

return false;
}
//<<<CODE	[...]

extern toggle * toggleNew(pin * pPin, uint32_t TimeOnMS, uint32_t TimeOffMS)
{
oosmos_Allocate(pToggle, toggle, toggleMAX, NULL);

//>>>INIT
oosmos_StateMachineInitNoQueue(pToggle, ROOT, NULL, On_State);
oosmos_LeafInit(pToggle, Off_State, ROOT, Off_State_Code);
oosmos_LeafInit(pToggle, On_State, ROOT, On_State_Code);
//<<<INIT

pToggle->m_pPin = pPin;
pToggle->m_TimeOnMS = TimeOnMS;
pToggle->m_TimeOffMS = TimeOffMS;

return pToggle;
}

oosmos/Classes/toggle_state.c (State machine version)

Initializes a Final state. See line 126 for an example.

1
2
3

void oosmos_FinalInit(pObject, StateName, Parent, pCode);

Prototype

pObject	Pointer to the object that holds the state machine.
StateName	State name of the `Final` element.
Parent	The name of this state's parent state.
pCode	Pointer to event handler function. NULL if there is no function to call.

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
//	[GPLv2]
// OOSMOS Final Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdio.h>
#include <stdbool.h>

//<<<EVENTS
//>>>EVENTS

typedef struct testTag test;

struct testTag
{
//>>>DECL
oosmos_sStateMachineNoQueue(ROOT);
oosmos_sComposite A_State;
oosmos_sLeaf A_Choice1_State;
oosmos_sLeaf A_Left_State;
oosmos_sLeaf A_Right_State;
oosmos_sFinal A_Final1_State;
oosmos_sLeaf B_State;
//<<<DECL
};

static bool IsLeft(void)
{
return true;
}

static void Default(void)
{
printf("In Default\n");
}

//>>>CODE
static bool A_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_DEFAULT: {
Default();
return true;
}
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, B_State);
}
}

return false;
}

static bool A_Choice1_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

if (oosmos_EventCode(pEvent) == oosmos_ENTER) {
if (IsLeft()) {
return oosmos_Transition(pTest, pState, A_Left_State);
}
else {
return oosmos_Transition(pTest, pState, A_Right_State);
}
}

return false;
}

static bool A_Left_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, A_Final1_State);
}
}

return false;
}

static bool A_Right_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, A_Final1_State);
}
}

return false;
}
//<<<CODE

static test * testNew(void)
{
oosmos_Allocate(pTest, test, 1, NULL);

//>>>INIT
oosmos_StateMachineInitNoQueue(pTest, ROOT, NULL, A_State);
oosmos_CompositeInit(pTest, A_State, ROOT, A_Choice1_State, A_State_Code);
oosmos_LeafInit(pTest, A_Choice1_State, A_State, A_Choice1_State_Code);
oosmos_LeafInit(pTest, A_Left_State, A_State, A_Left_State_Code);
oosmos_LeafInit(pTest, A_Right_State, A_State, A_Right_State_Code);
oosmos_FinalInit(pTest, A_Final1_State, A_State, NULL);
oosmos_LeafInit(pTest, B_State, ROOT, NULL);

oosmos_Debug(pTest, NULL);
//<<<INIT

return pTest;
}

extern int main(void)	[...]
{
test * pTest = (test *) testNew();

for (;;) {
oosmos_RunStateMachines();

if (oosmos_IsInState(pTest, &pTest->B_State)) {
printf("SUCCESS.\n");
break;
}

oosmos_DelayMS(1);
}
}

oosmos/Examples/Basic/Windows/Final.c

oosmos_FOREVER loops forever. Useful to stop a program once a problem has been programmatically identified.

See Also

POINTER_GUARD, UNUSED

oosmos_GetFreeRunningUS returns the number of microseconds since program start. Returning a uint32_t, the maximum number of microseconds that can be represented is 4,294,967,295, which is a little over 1 hour. Therefore, this value will wrap around to 0 about once an hour. The OOSMOS timeout capabilities handle the wrap around correctly, as does the accum class.

1
2
3

uint32_t oosmos_GetFreeRunningUS(void)

Prototype

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Hours2Days_Rounded is a macro that converts hours to days with the result being rounded for better precision. If speed is more important than accuracy, see the truncated version of this macro.

1
2
3

oosmos_Hours2Days_Rounded(Hours)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Hours2Days_Truncated is a macro that converts hours to days with the result being truncated due to default integral division behavior. If precision is important, see the rounded version of this macro.

1
2
3

oosmos_Hours2Days_Truncated(Hours)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Hours2Minutes is a macro that converts hours to minutes.

1
2
3

oosmos_Hours2Minutes(Hours)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Hours2MS is a macro that converts hours to milliseconds.

1
2
3

oosmos_Hours2MS(Hours)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Hours2Seconds is a macro that converts hours to seconds.

1
2
3

oosmos_Hours2Seconds(Hours)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Hours2US is a macro that converts hours to microseconds.

1
2
3

oosmos_Hours2US(Hours)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_IsInState returns true if the object is in state pState or any of its substates, false otherwise. See line 142 of the code snippet below for an example.

1
2
3

bool oosmos_IsInState(const oosmos_sStateMachine * pStateMachine, const oosmos_sState * pState);

Prototype

pStateMachine	The address of the state machine within the object.
pState	The address of the state within the current object.
RETURN	Returns `true` if the object is in the state specified by `pState` or any of its subordinate states, `false` otherwise.

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
//	[GPLv2]
// OOSMOS Final Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdio.h>
#include <stdbool.h>

//<<<EVENTS
//>>>EVENTS

typedef struct testTag test;

struct testTag
{
//>>>DECL
oosmos_sStateMachineNoQueue(ROOT);
oosmos_sComposite A_State;
oosmos_sLeaf A_Choice1_State;
oosmos_sLeaf A_Left_State;
oosmos_sLeaf A_Right_State;
oosmos_sFinal A_Final1_State;
oosmos_sLeaf B_State;
//<<<DECL
};

static bool IsLeft(void)
{
return true;
}

static void Default(void)
{
printf("In Default\n");
}

//>>>CODE
static bool A_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_DEFAULT: {
Default();
return true;
}
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, B_State);
}
}

return false;
}

static bool A_Choice1_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

if (oosmos_EventCode(pEvent) == oosmos_ENTER) {
if (IsLeft()) {
return oosmos_Transition(pTest, pState, A_Left_State);
}
else {
return oosmos_Transition(pTest, pState, A_Right_State);
}
}

return false;
}

static bool A_Left_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, A_Final1_State);
}
}

return false;
}

static bool A_Right_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, A_Final1_State);
}
}

return false;
}
//<<<CODE

static test * testNew(void)
{
oosmos_Allocate(pTest, test, 1, NULL);

//>>>INIT
oosmos_StateMachineInitNoQueue(pTest, ROOT, NULL, A_State);
oosmos_CompositeInit(pTest, A_State, ROOT, A_Choice1_State, A_State_Code);
oosmos_LeafInit(pTest, A_Choice1_State, A_State, A_Choice1_State_Code);
oosmos_LeafInit(pTest, A_Left_State, A_State, A_Left_State_Code);
oosmos_LeafInit(pTest, A_Right_State, A_State, A_Right_State_Code);
oosmos_FinalInit(pTest, A_Final1_State, A_State, NULL);
oosmos_LeafInit(pTest, B_State, ROOT, NULL);

oosmos_Debug(pTest, NULL);
//<<<INIT

return pTest;
}

extern int main(void)
{
test * pTest = (test *) testNew();

for (;;) {
oosmos_RunStateMachines();

if (oosmos_IsInState(pTest, &pTest->B_State)) {
printf("SUCCESS.\n");
break;
}

oosmos_DelayMS(1);
}
}

oosmos/Examples/Basic/Windows/Final.c

oosmos_LeafInit initializes an oosmos_sLeaf state.
See line 92 in the code snippet below for an example.

1
2
3

void oosmos_LeafInit(pObject, LeafState, ParentState, pCode);

Prototype

pObject	The address of the object that contains the state machine.
LeafState	The name of the leaf state.
ParentState	The name of the parent state.
pCode	The address of the event code function or NULL.

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
//	[GPLv2]
// OOSMOS toggle Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include "toggle.h"
#include "pin.h"
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>

#ifndef toggleMAX
#define toggleMAX 4
#endif

struct toggleTag
{
//>>>DECL
oosmos_sStateMachineNoQueue(ROOT);
oosmos_sLeaf Off_State;
oosmos_sLeaf On_State;
//<<<DECL

pin * m_pPin;
uint32_t m_TimeOnMS;
uint32_t m_TimeOffMS;
};

//>>>CODE
static bool Off_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
toggle * pToggle = (toggle *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
return oosmos_StateTimeoutMS(pState, (uint32_t) pToggle->m_TimeOffMS);
}
case oosmos_TIMEOUT: {
return oosmos_Transition(pToggle, pState, On_State);
}
}

return false;
}

static bool On_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
toggle * pToggle = (toggle *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
pinOn(pToggle->m_pPin);
return oosmos_StateTimeoutMS(pState, (uint32_t) pToggle->m_TimeOnMS);
}
case oosmos_EXIT: {
pinOff(pToggle->m_pPin);
return true;
}
case oosmos_TIMEOUT: {
return oosmos_Transition(pToggle, pState, Off_State);
}
}

return false;
}
//<<<CODE

extern toggle * toggleNew(pin * pPin, uint32_t TimeOnMS, uint32_t TimeOffMS)
{
oosmos_Allocate(pToggle, toggle, toggleMAX, NULL);

//>>>INIT
oosmos_StateMachineInitNoQueue(pToggle, ROOT, NULL, On_State);
oosmos_LeafInit(pToggle, Off_State, ROOT, Off_State_Code);
oosmos_LeafInit(pToggle, On_State, ROOT, On_State_Code);
//<<<INIT

pToggle->m_pPin = pPin;
pToggle->m_TimeOnMS = TimeOnMS;
pToggle->m_TimeOffMS = TimeOffMS;

return pToggle;
}

oosmos/Classes/toggle_state.c

oosmos_Minutes2Days_Rounded is a macro that converts minutes to days with the result being rounded for better precision. If speed is more important than accuracy, see the truncated version of this macro.

1
2
3

oosmos_Minutes2Days_Rounded(Minutes)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Minutes2Days_Truncated is a macro that converts minutes to days with the result being truncated due to default integral division behavior. If precision is important, see the rounded version of this macro.

1
2
3

oosmos_Minutes2Days_Truncated(Minutes)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Minutes2Hours_Rounded is a macro that converts minutes to hours with the result being rounded for better precision. If speed is more important than accuracy, see the truncated version of this macro.

1
2
3

oosmos_Minutes2Hours_Rounded(Minutes)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Minutes2Hours_Truncated is a macro that converts minutes to hours with the result being truncated due to default integral division behavior. If precision is important, see the rounded version of this macro.

1
2
3

oosmos_Minutes2Hours_Truncated(Minutes)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Minutes2MS is a macro that converts minutes to milliseconds.

1
2
3

oosmos_Minutes2MS(Minutes)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Minutes2Seconds is a macro that converts minutes to seconds.

1
2
3

oosmos_Minutes2Seconds(Minutes)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_Minutes2US is a macro that converts minutes to microseconds.

1
2
3

oosmos_Minutes2US(Minutes)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_MS2Days_Rounded is a macro that converts milliseconds to days with the result being rounded for better precision. If speed is more important than accuracy, see the truncated version of this macro.

1
2
3

oosmos_MS2Days_Rounded(Hours)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_MS2Days_Truncated is a macro that converts milliseconds to days with the result being truncated due to default integral division behavior. If precision is important, see the rounded version of this macro.

1
2
3

oosmos_MS2Days_Truncated(Hours)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_MS2Hours_Rounded is a macro that converts milliseconds to hours with the result being rounded for better precision. If speed is more important than accuracy, see the truncated version of this macro.

1
2
3

oosmos_MS2Hours_Rounded(Hours)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_MS2Hours_Truncated is a macro that converts milliseconds to hours with the result being truncated due to default integral division behavior. If precision is important, see the rounded version of this macro.

1
2
3

oosmos_MS2Hours_Truncated(Hours)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_MS2Minutes_Rounded is a macro that converts milliseconds to minutes with the result being rounded for better precision. If speed is more important than accuracy, see the truncated version of this macro.

1
2
3

oosmos_MS2Minutes_Rounded(Milliseconds)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_MS2Minutes_Truncated is a macro that converts milliseconds to minutes with the result being truncated due to default integral division behavior. If precision is important, see the rounded version of this macro.

1
2
3

oosmos_MS2Minutes_Truncated(Milliseconds)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Seconds_Rounded, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_MS2Seconds_Rounded is a macro that converts milliseconds to seconds with the result being rounded for better precision. If speed is more important than accuracy, see the truncated version of this macro.

1
2
3

oosmos_MS2Seconds_Rounded(Milliseconds)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Truncated, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_MS2Seconds_Truncated is a macro that converts milliseconds to seconds with the result being truncated due to default integral division behavior. If precision is important, see the rounded version of this macro.

1
2
3

oosmos_MS2Seconds_Truncated(Milliseconds)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2US, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

oosmos_MS2US is a macro that converts milliseconds to microseconds.

1
2
3

oosmos_MS2US(Milliseconds)

Macro

See Also

Days2Hours, Days2MS, Days2Minutes, Days2Seconds, Days2US, Divide_Integral_Rounded, Hours2Days_Rounded, Hours2Days_Truncated, Hours2MS, Hours2Minutes, Hours2Seconds, Hours2US, MS2Days_Rounded, MS2Days_Truncated, MS2Hours_Rounded, MS2Hours_Truncated, MS2Minutes_Rounded, MS2Minutes_Truncated, MS2Seconds_Rounded, MS2Seconds_Truncated, Minutes2Days_Rounded, Minutes2Days_Truncated, Minutes2Hours_Rounded, Minutes2Hours_Truncated, Minutes2MS, Minutes2Seconds, Minutes2US, Seconds2Days_Rounded, Seconds2Days_Truncated, Seconds2Hours_Rounded, Seconds2Hours_Truncated, Seconds2MS, Seconds2Minutes_Rounded, Seconds2Minutes_Truncated, Seconds2US, US2Days_Rounded, US2Days_Truncated, US2Hours_Rounded, US2Hours_Truncated, US2MS_Rounded, US2MS_Truncated, US2Minutes_Rounded, US2Minutes_Truncated, US2Seconds_Rounded, US2Seconds_Truncated

Creates an Object Thread. See line 38 for an example of the declaration and line 65 for an example of its creation. See lines 45-59 for the thread itself.

1
2
3

void oosmos_ObjectThreadInit(pObject, pObjectThread, pFunc, bRunning);

Macro

pObject	Pointer to the object.
ObjectThread	The name of the object member of type `oosmos_sObjectThread`.
pFunc	The thread function.
bRunning	Indicates whether the thread should start right away. If `false`, then use `oosmos_ObjectThreadStart()` and `oosmos_ObjectThreadStop()` to start and stop the thread.
See Also	`ObjectThreadStart`, `ObjectThreadStop`, `sObjectThread`

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
//	[GPLv2]
// OOSMOS toggle Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#ifndef toggleMAX
#define toggleMAX 5
#endif

//===================================

#include "oosmos.h"
#include "toggle.h"
#include "pin.h"
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>

struct toggleTag
{
oosmos_sObjectThread m_ObjectThread;

pin * m_pPin;
uint32_t m_TimeOnMS;
uint32_t m_TimeOffMS;
};

static void ToggleThread(const toggle * pToggle, oosmos_sState * pState)
{
oosmos_POINTER_GUARD(pToggle);
oosmos_POINTER_GUARD(pState);

oosmos_ThreadBegin();
for (;;) {
pinOn(pToggle->m_pPin);
oosmos_ThreadDelayMS(pToggle->m_TimeOnMS);

pinOff(pToggle->m_pPin);
oosmos_ThreadDelayMS(pToggle->m_TimeOffMS);
}
oosmos_ThreadEnd();
}

extern toggle * toggleNew(pin * pPin, uint32_t TimeOnMS, uint32_t TimeOffMS)
{
oosmos_Allocate(pToggle, toggle, toggleMAX, NULL);

oosmos_ObjectThreadInit(pToggle, m_ObjectThread, ToggleThread, true);

pToggle->m_pPin = pPin;
pToggle->m_TimeOnMS = TimeOnMS;
pToggle->m_TimeOffMS = TimeOffMS;

return pToggle;
}

oosmos/Classes/toggle.c

Starts a previously created Object Thread.

1
2
3

void oosmos_ObjectThreadStart(oosmos_ObjectThread * pObject);

Prototype

pObject	Pointer to the object.
See Also	`ObjectThreadInit`, `ObjectThreadStop`, `sObjectThread`

Stops an Object Thread. Use oosmos_ObjectThreadStart to restart it.

1
2
3

void oosmos_ObjectThreadStop(oosmos_ObjectThread * pObject);

Prototype

pObject	Pointer to the object.
See Also	`ObjectThreadInit`, `ObjectThreadStart`, `sObjectThread`

oosmos_ORTHO is a preprocessor macro that, when defined, compiles in all the OOSMOS orthogonal state machine features.
The default is #undef which will compile the smallest possible footprint. Of course if you use orthogonal states in any object in your build, you will have to #define it during compilation.
You can either define it on the compilation command line (usually -Doosmos_ORTHO), or add a #define oosmos_ORTHO at the top of both oosmos.h and oosmos.c.

See Also

OrthoInit, OrthoRegionInit, sOrtho, sOrthoRegion

oosmos_OrthoInit initializes an oosmos_sOrtho state.
See line 157 of the code snippet below for an example.

1
2
3

void oosmos_OrthoInit(pObject, OrthoState, ParentState, pCode)

Prototype

pObject	The address of the object that contains the state machine.
OrthoState	The name of the Ortho state.
ParentState	The name of the parent state.
pCode	The address of the event code function or NULL.

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
//	[GPLv2]
// OOSMOS Completion Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdbool.h>
#include <stdio.h>

//>>>EVENTS
enum {
evA = 1,
evB = 2,
evStop = 3
};

#ifdef oosmos_DEBUG
static const char * OOSMOS_EventNames(int EventCode)
{
switch (EventCode) {
case evA: return "evA";
case evB: return "evB";
case evStop: return "evStop";
default: return "";
}
}
#endif
//<<<EVENTS

typedef struct testTag test;

typedef union {
oosmos_sEvent Base;
} uEvents;

struct testTag
{
//>>>DECL
oosmos_sStateMachine(ROOT, uEvents, 3);
oosmos_sOrtho Ortho_State;
oosmos_sOrthoRegion Ortho_Region1_State;
oosmos_sLeaf Ortho_Region1_Moving_State;
oosmos_sLeaf Ortho_Region1_Idle_State;
oosmos_sFinal Ortho_Region1_Final1_State;
oosmos_sOrthoRegion Ortho_Region2_State;
oosmos_sLeaf Ortho_Region2_Idle_State;
oosmos_sLeaf Ortho_Region2_Moving_State;
oosmos_sFinal Ortho_Region2_Final2_State;
oosmos_sLeaf Complete_State;
//<<<DECL
};

//>>>CODE
static bool Ortho_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, Complete_State);
}
}

return false;
}

static bool Ortho_Region1_Moving_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evStop: {
return oosmos_Transition(pTest, pState, Ortho_Region1_Final1_State);
}
}

return false;
}

static bool Ortho_Region1_Idle_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evA: {
return oosmos_Transition(pTest, pState, Ortho_Region1_Moving_State);
}
}

return false;
}

static bool Ortho_Region2_Idle_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evB: {
return oosmos_Transition(pTest, pState, Ortho_Region2_Moving_State);
}
}

return false;
}

static bool Ortho_Region2_Moving_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evStop: {
return oosmos_Transition(pTest, pState, Ortho_Region2_Final2_State);
}
}

return false;
}

static bool Complete_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
printf("\n--Goal State Achieved--\n");
return true;
}
}

oosmos_UNUSED(pObject);
oosmos_UNUSED(pState);
return false;
}
//<<<CODE

static test * testNew(void)
{
oosmos_Allocate(pTest, test, 1, NULL);

//>>>INIT
oosmos_StateMachineInit(pTest, ROOT, NULL, Ortho_State);
oosmos_OrthoInit(pTest, Ortho_State, ROOT, Ortho_State_Code);
oosmos_OrthoRegionInit(pTest, Ortho_Region1_State, Ortho_State, Ortho_Region1_Idle_State, NULL);
oosmos_LeafInit(pTest, Ortho_Region1_Moving_State, Ortho_Region1_State, Ortho_Region1_Moving_State_Code);
oosmos_LeafInit(pTest, Ortho_Region1_Idle_State, Ortho_Region1_State, Ortho_Region1_Idle_State_Code);
oosmos_FinalInit(pTest, Ortho_Region1_Final1_State, Ortho_Region1_State, NULL);
oosmos_OrthoRegionInit(pTest, Ortho_Region2_State, Ortho_State, Ortho_Region2_Idle_State, NULL);
oosmos_LeafInit(pTest, Ortho_Region2_Idle_State, Ortho_Region2_State, Ortho_Region2_Idle_State_Code);
oosmos_LeafInit(pTest, Ortho_Region2_Moving_State, Ortho_Region2_State, Ortho_Region2_Moving_State_Code);
oosmos_FinalInit(pTest, Ortho_Region2_Final2_State, Ortho_Region2_State, NULL);
oosmos_LeafInit(pTest, Complete_State, ROOT, Complete_State_Code);

oosmos_Debug(pTest, OOSMOS_EventNames);
//<<<INIT

return pTest;
}

static void QueueEvent(const test * pTest, int EventCode)	[...]
{
oosmos_PushEventCode(pTest, EventCode);
oosmos_RunStateMachines();
}

extern int main(void)
{
test * pTest = testNew();

QueueEvent(pTest, evA);
QueueEvent(pTest, evB);
QueueEvent(pTest, evStop);

if (oosmos_IsInState(pTest, &pTest->Complete_State))
printf("SUCCESS\n");
else
printf("FAILURE\n");

return 0;
}

oosmos/Examples/Ortho/Windows/Completion.c

oosmos_OrthoRegionInit initializes an oosmos_sOrthoRegion state.
See line 100 of the code snippet below for an example.

1
2
3

void oosmos_OrthoRegionInit(pObject, LeafState, ParentState, DefaultState, pCode);

Prototype

pObject	The address of the object that contains state machine.
OrthoState	The name of the ortho state.
ParentState	The name of the parent state.
DefaultState	The name of the default state.
pCode	The address of the event code function or NULL.

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
//	[GPLv2]
// OOSMOS EnterExit Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdbool.h>
#include <stdio.h>

//>>>EVENTS
enum {
evTweak = 1
};

#ifdef oosmos_DEBUG
static const char * OOSMOS_EventNames(int EventCode)
{
switch (EventCode) {
case evTweak: return "evTweak";
default: return "";
}
}
#endif
//<<<EVENTS

typedef struct testTag test;

typedef union {
oosmos_sEvent Base;
} uEvents;

struct testTag
{
//>>>DECL
oosmos_sStateMachine(ROOT, uEvents, 3);
oosmos_sOrtho Active_State;
oosmos_sOrthoRegion Active_Region1_State;
oosmos_sLeaf Active_Region1_Moving_State;
oosmos_sOrthoRegion Active_Region2_State;
oosmos_sComposite Active_Region2_Outer_State;
oosmos_sLeaf Active_Region2_Outer_Inner_State;
oosmos_sOrthoRegion Active_Region3_State;
oosmos_sLeaf Active_Region3_Leaf_State;
oosmos_sLeaf Active_Region3_Running_State;
//<<<DECL
};

//>>>CODE
static bool Active_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evTweak: {
return oosmos_Transition(pTest, pState, Active_Region2_Outer_State);
}
}

return false;
}

static bool Active_Region3_Leaf_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, Active_Region3_Running_State);
}
}

return false;
}
//<<<CODE

static test * testNew(void)
{
oosmos_Allocate(pTest, test, 1, NULL);

//>>>INIT
oosmos_StateMachineInit(pTest, ROOT, NULL, Active_State);
oosmos_OrthoInit(pTest, Active_State, ROOT, Active_State_Code);
oosmos_OrthoRegionInit(pTest, Active_Region1_State, Active_State, Active_Region1_Moving_State, NULL);
oosmos_LeafInit(pTest, Active_Region1_Moving_State, Active_Region1_State, NULL);
oosmos_OrthoRegionInit(pTest, Active_Region2_State, Active_State, Active_Region2_Outer_State, NULL);
oosmos_CompositeInit(pTest, Active_Region2_Outer_State, Active_Region2_State, Active_Region2_Outer_Inner_State, NULL);
oosmos_LeafInit(pTest, Active_Region2_Outer_Inner_State, Active_Region2_Outer_State, NULL);
oosmos_OrthoRegionInit(pTest, Active_Region3_State, Active_State, Active_Region3_Leaf_State, NULL);
oosmos_LeafInit(pTest, Active_Region3_Leaf_State, Active_Region3_State, Active_Region3_Leaf_State_Code);
oosmos_LeafInit(pTest, Active_Region3_Running_State, Active_Region3_State, NULL);

oosmos_Debug(pTest, OOSMOS_EventNames);
//<<<INIT

return pTest;
}

static void QueueEventRoutine(const test * pTest, int EventCode)	[...]
{
oosmos_PushEventCode(pTest, EventCode);
oosmos_RunStateMachines();
}

extern int main(void)
{
test * pTest = testNew();
QueueEventRoutine(pTest, evTweak);

if (oosmos_IsInState(pTest, &pTest->Active_Region2_Outer_Inner_State))
printf("SUCCESS\n");
else
printf("FAILURE\n");

return 0;
}

oosmos/Examples/Ortho/Windows/EnterExit.c

oosmos_POINTER_GUARD guarantees that the passed argument is not NULL. See line 47 in the code snippet below for an example.

See Also

FOREVER, UNUSED

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
//	[GPLv2]
// OOSMOS toggle Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#ifndef toggleMAX	[...]
#define toggleMAX 5
#endif

//===================================

#include "oosmos.h"
#include "toggle.h"
#include "pin.h"
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>

struct toggleTag
{
oosmos_sObjectThread m_ObjectThread;

pin * m_pPin;
uint32_t m_TimeOnMS;
uint32_t m_TimeOffMS;
};

static void ToggleThread(const toggle * pToggle, oosmos_sState * pState)
{
oosmos_POINTER_GUARD(pToggle);
oosmos_POINTER_GUARD(pState);

oosmos_ThreadBegin();
for (;;) {
pinOn(pToggle->m_pPin);
oosmos_ThreadDelayMS(pToggle->m_TimeOnMS);

pinOff(pToggle->m_pPin);
oosmos_ThreadDelayMS(pToggle->m_TimeOffMS);
}
oosmos_ThreadEnd();
}
	[...]
extern toggle * toggleNew(pin * pPin, uint32_t TimeOnMS, uint32_t TimeOffMS)
{
oosmos_Allocate(pToggle, toggle, toggleMAX, NULL);

oosmos_ObjectThreadInit(pToggle, m_ObjectThread, ToggleThread, true);

pToggle->m_pPin = pPin;
pToggle->m_TimeOnMS = TimeOnMS;
pToggle->m_TimeOffMS = TimeOffMS;

return pToggle;
}

oosmos/Classes/toggle.c (thread version)

oosmos_POLL is one of the six predefined event macros. This event is generated each time the state machine is executed and this is the current active state. See line 150 in the code snippet below for an example.

See Also

COMPLETE, DEFAULT, EXIT, TIMEOUT

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
//	[GPLv2]
// OOSMOS Poll Test
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdbool.h>
#include <stdio.h>

//>>>EVENTS
//<<<EVENTS

typedef struct testTag test;

const unsigned TargetCount = 3;

struct testTag
{
//>>>DECL
oosmos_sStateMachineNoQueue(ROOT);
oosmos_sLeaf TestingNullTransitionWithoutPoll_State;
oosmos_sOrtho Ortho_State;
oosmos_sOrthoRegion Ortho_Region1_State;
oosmos_sComposite Ortho_Region1_A1_State;
oosmos_sComposite Ortho_Region1_A1_B1_State;
oosmos_sLeaf Ortho_Region1_A1_B1_C1_State;
oosmos_sOrthoRegion Ortho_Region2_State;
oosmos_sComposite Ortho_Region2_A2_State;
oosmos_sComposite Ortho_Region2_A2_B2_State;
oosmos_sLeaf Ortho_Region2_A2_B2_C2_State;
oosmos_sLeaf TestNullTransitionWithPoll_State;
oosmos_sLeaf Done_State;
//<<<DECL

unsigned m_Ortho;

unsigned m_A1_Count;
unsigned m_B1_Count;
unsigned m_C1_Count;

unsigned m_A2_Count;
unsigned m_B2_Count;
unsigned m_C2_Count;
};

static bool CheckCounts(const test * pTest)
{
return pTest->m_Ortho > TargetCount &&
pTest->m_A1_Count > TargetCount && pTest->m_B1_Count > TargetCount && pTest->m_C1_Count > TargetCount &&
pTest->m_A2_Count > TargetCount && pTest->m_B2_Count > TargetCount && pTest->m_C2_Count > TargetCount;
}

static void TestNullThread(test * pTest, oosmos_sState * pState)
{
oosmos_UNUSED(pTest);

oosmos_ThreadBegin();
printf("DELAY 50ms\n");
oosmos_ThreadDelayMS(50);

printf("DELAY 100ms\n");
oosmos_ThreadDelayMS(100);
oosmos_ThreadEnd();
}

static void OrthoPoll(test * pTest)
{
printf("Poll Ortho\n");
pTest->m_Ortho++;
}

static void A1Thread(test * pTest, oosmos_sState * pState)
{
oosmos_ThreadBegin();
for (;;) {
printf("Poll A1: %u\n", pTest->m_A1_Count);
pTest->m_A1_Count++;
oosmos_ThreadDelayMS(20);
}
oosmos_ThreadEnd();
}

static void B1Poll(test * pTest)
{
printf("Poll B1: %u\n", pTest->m_B1_Count);
pTest->m_B1_Count++;
}

static void C1Poll(test * pTest)
{
printf("Poll C1: %u\n", pTest->m_C1_Count);
pTest->m_C1_Count++;
}

static void A2Poll(test * pTest)
{
printf("Poll A2: %u\n", pTest->m_A2_Count);
pTest->m_A2_Count++;
}

static void B2Poll(test * pTest)
{
printf("Poll B2: %u\n", pTest->m_B2_Count);
pTest->m_B2_Count++;
}

static void C2Poll(test * pTest)
{
printf("Poll C2: %u\n", pTest->m_C2_Count);
pTest->m_C2_Count++;
}


//>>>CODE
static bool TestingNullTransitionWithoutPoll_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, Ortho_State);
}
}

return false;
}

static bool Ortho_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
OrthoPoll(pTest);
if (CheckCounts(pTest)) {
return oosmos_Transition(pTest, pState, TestNullTransitionWithPoll_State);
}
return true;
}
}

return false;
}

static bool Ortho_Region1_A1_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)	[...]
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
A1Thread(pTest, pState);
return true;
}
}

return false;
}

static bool Ortho_Region1_A1_B1_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
B1Poll(pTest);
return true;
}
}

oosmos_UNUSED(pState);
return false;
}

static bool Ortho_Region1_A1_B1_C1_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
C1Poll(pTest);
return true;
}
}

oosmos_UNUSED(pState);
return false;
}

static bool Ortho_Region2_A2_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
A2Poll(pTest);
return true;
}
}

oosmos_UNUSED(pState);
return false;
}

static bool Ortho_Region2_A2_B2_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
B2Poll(pTest);
return true;
}
}

oosmos_UNUSED(pState);
return false;
}

static bool Ortho_Region2_A2_B2_C2_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
C2Poll(pTest);
return true;
}
}

oosmos_UNUSED(pState);
return false;
}

static bool TestNullTransitionWithPoll_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
TestNullThread(pTest, pState);
return true;
}
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, Done_State);
}
}

return false;
}

static bool Done_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
printf("SUCCESS!\nTerminating program.\n");
oosmos_EndProgram(1);
return true;
}
}

oosmos_UNUSED(pObject);
oosmos_UNUSED(pState);
return false;
}
//<<<CODE

static test * testNew(void)
{
oosmos_Allocate(pTest, test, 1, NULL);

//>>>INIT
oosmos_StateMachineInitNoQueue(pTest, ROOT, NULL, TestingNullTransitionWithoutPoll_State);
oosmos_LeafInit(pTest, TestingNullTransitionWithoutPoll_State, ROOT, TestingNullTransitionWithoutPoll_State_Code);
oosmos_OrthoInit(pTest, Ortho_State, ROOT, Ortho_State_Code);
oosmos_OrthoRegionInit(pTest, Ortho_Region1_State, Ortho_State, Ortho_Region1_A1_State, NULL);
oosmos_CompositeInit(pTest, Ortho_Region1_A1_State, Ortho_Region1_State, Ortho_Region1_A1_B1_State, Ortho_Region1_A1_State_Code);
oosmos_CompositeInit(pTest, Ortho_Region1_A1_B1_State, Ortho_Region1_A1_State, Ortho_Region1_A1_B1_C1_State, Ortho_Region1_A1_B1_State_Code);
oosmos_LeafInit(pTest, Ortho_Region1_A1_B1_C1_State, Ortho_Region1_A1_B1_State, Ortho_Region1_A1_B1_C1_State_Code);
oosmos_OrthoRegionInit(pTest, Ortho_Region2_State, Ortho_State, Ortho_Region2_A2_State, NULL);
oosmos_CompositeInit(pTest, Ortho_Region2_A2_State, Ortho_Region2_State, Ortho_Region2_A2_B2_State, Ortho_Region2_A2_State_Code);
oosmos_CompositeInit(pTest, Ortho_Region2_A2_B2_State, Ortho_Region2_A2_State, Ortho_Region2_A2_B2_C2_State, Ortho_Region2_A2_B2_State_Code);
oosmos_LeafInit(pTest, Ortho_Region2_A2_B2_C2_State, Ortho_Region2_A2_B2_State, Ortho_Region2_A2_B2_C2_State_Code);
oosmos_LeafInit(pTest, TestNullTransitionWithPoll_State, ROOT, TestNullTransitionWithPoll_State_Code);
oosmos_LeafInit(pTest, Done_State, ROOT, Done_State_Code);

oosmos_Debug(pTest, NULL);
//<<<INIT

pTest->m_Ortho = 0;

pTest->m_A1_Count = 0;
pTest->m_B1_Count = 0;
pTest->m_C1_Count = 0;

pTest->m_A2_Count = 0;
pTest->m_B2_Count = 0;
pTest->m_C2_Count = 0;

return pTest;
}

extern int main(void)
{
(void) testNew();

for (;;) {
oosmos_RunStateMachines();
printf("---\n");
oosmos_DelayMS(1);
}
}

oosmos/Tests/Poll.c (thread version)

Allows you to push a complex event onto the object's event queue. Useful for pushing complex events. That is, events that hold more than just an event code.

1
2
3

oosmos_PushEvent(pObject, Event)

Macro

pObject	Pointer to the object pointer.
Event	Event object to push onto the object's event queue.
See Also	`PushEventCode`

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
//	[GPLv2]
// OOSMOS ThreadEvents Test
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdbool.h>
#include <stdio.h>

//>>>EVENTS
enum {
evTestEvent = 1
};

#ifdef oosmos_DEBUG
static const char * OOSMOS_EventNames(int EventCode)
{
switch (EventCode) {
case evTestEvent: return "evTestEvent";
default: return "";
}
}
#endif
//<<<EVENTS

typedef struct {
oosmos_sEvent Event;
unsigned Value;
} sTestEvent;

typedef union {
oosmos_sEvent Event;
sTestEvent TestEvent;
} uEvents;

typedef struct testTag test;

struct testTag
{
//>>>DECL
oosmos_sStateMachine(ROOT, uEvents, 3);
oosmos_sOrtho A1_State;
oosmos_sOrthoRegion A1_Region1_State;
oosmos_sLeaf A1_Region1_B1_State;
oosmos_sOrthoRegion A1_Region2_State;
oosmos_sLeaf A1_Region2_EventDriver_State;
oosmos_sLeaf Done_State;
//<<<DECL

};

static void A1Thread(oosmos_sState * pState)
{
const sTestEvent * pTestEvent;

oosmos_ThreadBegin();
oosmos_ThreadWaitEvent(evTestEvent);
pTestEvent = (sTestEvent *) oosmos_GetCurrentEvent(pState);
printf("ThreadA1: Received evTestEvent, Value %u %s\n", pTestEvent->Value, pTestEvent->Value == 998 ? "SUCCESS" : "FAILURE");

oosmos_ThreadWaitEvent(evTestEvent);
pTestEvent = (sTestEvent *) oosmos_GetCurrentEvent(pState);
printf("ThreadA1: Received evTestEvent, Value %u %s\n", pTestEvent->Value, pTestEvent->Value == 999 ? "SUCCESS" : "FAILURE");
oosmos_ThreadEnd();
}

static void EventDriverThread(const test * pTest, oosmos_sState * pState)
{
static const sTestEvent TestEvent998 = { { evTestEvent, NULL }, 998 };
static const sTestEvent TestEvent999 = { { evTestEvent, NULL }, 999 };

oosmos_ThreadBegin();
printf("EventDriverThread: Enter\n");
oosmos_ThreadDelayMS(1000);

printf("EventDriverThread: Push 998\n");
oosmos_PushEvent(pTest, TestEvent998);

printf("EventDriverThread: Push 999\n");
oosmos_PushEvent(pTest, TestEvent999);
oosmos_ThreadEnd();
}

//>>>CODE	[...]
static bool A1_Region1_B1_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
A1Thread(pState);
return true;
}
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, Done_State);
}
}

return false;
}

static bool Done_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
switch (oosmos_EventCode(pEvent)) {
case oosmos_ENTER: {
oosmos_EndProgram(1);
return true;
}
}

oosmos_UNUSED(pObject);
oosmos_UNUSED(pState);
return false;
}

static bool A1_Region2_EventDriver_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
EventDriverThread(pTest, pState);
return true;
}
}

return false;
}
//<<<CODE

static test * testNew(void)
{
oosmos_Allocate(pTest, test, 1, NULL);

//>>>INIT
oosmos_StateMachineInit(pTest, ROOT, NULL, A1_State);
oosmos_OrthoInit(pTest, A1_State, ROOT, NULL);
oosmos_OrthoRegionInit(pTest, A1_Region1_State, A1_State, A1_Region1_B1_State, NULL);
oosmos_LeafInit(pTest, A1_Region1_B1_State, A1_Region1_State, A1_Region1_B1_State_Code);
oosmos_OrthoRegionInit(pTest, A1_Region2_State, A1_State, A1_Region2_EventDriver_State, NULL);
oosmos_LeafInit(pTest, A1_Region2_EventDriver_State, A1_Region2_State, A1_Region2_EventDriver_State_Code);
oosmos_LeafInit(pTest, Done_State, ROOT, Done_State_Code);

oosmos_Debug(pTest, OOSMOS_EventNames);
//<<<INIT

return pTest;
}

extern int main(void)
{
(void) testNew();

for (;;) {
oosmos_RunStateMachines();
oosmos_DelayMS(1);
}
}

oosmos/Tests/ThreadEvents.c

oosmos_PushEventCode sends an event to an OOSMOS object. (It actually pushes the event to the object's event queue.) If the event is handled by the current state or any of its parent states, then the appropriate action is taken in that state. If the current active state (or its parents) do not handle the event, it will be popped from the queue and no action will take place.
See line 127 for an example.

1
2
3

bool oosmos_PushEventCode(void * pObject, int EventCode);

Prototype

pObject	Pointer to the object that will react to the event.
EventCode	The event code to send. Will always be an event defined inside the implementation's `.c` file.
RETURN	Always returns `true`.

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
//	[GPLv2]
// OOSMOS - EventDemo example, motor object
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include "motor.h"
#include <stdbool.h>
#include <stdio.h>

//>>>EVENTS
enum {
evStart = 1,
evStop = 2
};

#ifdef oosmos_DEBUG
static const char * OOSMOS_EventNames(int EventCode)
{
switch (EventCode) {
case evStart: return "evStart";
case evStop: return "evStop";
default: return "";
}
}
#endif
//<<<EVENTS

typedef union {
oosmos_sEvent Event;
} uEvents;

struct motorTag
{
//>>>DECL
oosmos_sStateMachine(ROOT, uEvents, 3);
oosmos_sLeaf Idle_State;
oosmos_sLeaf Moving_State;
//<<<DECL
};

#ifndef motorMAX
#define motorMAX 3
#endif

static void MovingThread(oosmos_sState * pState)
{
oosmos_ThreadBegin();
for (;;) {
printf("motor: MOVING...\n");
oosmos_ThreadDelayMS(500);
}
oosmos_ThreadEnd();
}

//>>>CODE
static bool Idle_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
motor * pMotor = (motor *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evStart: {
return oosmos_Transition(pMotor, pState, Moving_State);
}
}

return false;
}

static bool Moving_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
motor * pMotor = (motor *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_POLL: {
MovingThread(pState);
return true;
}
case evStop: {
return oosmos_Transition(pMotor, pState, Idle_State);
}
}

return false;
}
//<<<CODE

extern motor * motorNew(void)
{
oosmos_Allocate(pMotor, motor, motorMAX, NULL);

//>>>INIT
oosmos_StateMachineInit(pMotor, ROOT, NULL, Idle_State);
oosmos_LeafInit(pMotor, Idle_State, ROOT, Idle_State_Code);
oosmos_LeafInit(pMotor, Moving_State, ROOT, Moving_State_Code);

oosmos_Debug(pMotor, OOSMOS_EventNames);
//<<<INIT

return pMotor;
}

extern void motorOn(const motor * pMotor)
{
oosmos_PushEventCode(pMotor, evStart);
}

extern void motorOff(const motor * pMotor)
{
oosmos_PushEventCode(pMotor, evStop);
}

oosmos/Examples/EventDemo/Windows/motor.c

Constructs a queue of type oosmos_sQueue.
See lines 248 and 250 in the code snippet below for examples.

1
2
3

bool oosmos_QueueConstruct(oosmos_sQueue * pQueue, void * pQueueData);

Prototype

pQueue	Pointer to a `oosmos_sQueue` item that holds the meta data for the queue.
pQueueData	A pointer to an array that will hold the data for the queue. `oosmos_QueueConstruct` is a macro that requires that the memory area be an array in order to properly calculate queue limits.
See Also	`QueuePop`, `QueuePush`, `sQueue`

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
//	[GPLv2]
// OOSMOS uart Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include "uart.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdarg.h>

typedef enum
{
sendAwaitingCharToSend_State,
sendAwaitingReady_State,
sendAwaitingComplete_State
} eSendStates;

struct uartTag
{
oosmos_sActiveObject m_ActiveObject;

oosmos_sQueue m_SendDataQueue;
uint8_t m_SendDataQueueData[200];
eSendStates m_SendState;
uint8_t m_CharToSend;

oosmos_sQueue m_ReceiveDataQueue;
uint8_t m_ReceiveDataQueueData[10];
oosmos_sSubscriberList m_ReceivedByteEventSubscribers[1];

uint8_t m_PlibUartID;
uint8_t m_UartModule;
};

#if defined _UART6
#define MaxUARTS 6
#elif defined _UART5
#define MaxUARTS 5
#elif defined _UART4
#define MaxUARTS 4
#elif defined _UART3
#define MaxUARTS 3
#elif defined _UART2
#define MaxUARTS 2
#elif defined _UART1
#define MaxUARTS 1
#endif

static uart UartList[MaxUARTS];
static unsigned UartCount;

static const unsigned UartIndex_to_PlibUartId[] =
{
#ifdef _UART1
UART1,
#endif
#ifdef _UART2
UART2,
#endif
#ifdef _UART3
UART3,
#endif
#ifdef _UART4
UART4,
#endif
#ifdef _UART5
UART5,
#endif
#ifdef _UART6
UART6,
#endif
};

static void EnableInterrupt(uart * pUART)
{
INTEnable(INT_SOURCE_UART_RX(pUART->m_PlibUartID), INT_ENABLED);
}

static void DisableInterrupt(uart * pUART)
{
INTEnable(INT_SOURCE_UART_RX(pUART->m_PlibUartID), INT_DISABLED);
}

static uint16_t GetPriorityBits(const unsigned PriorityNumber)
{
switch (PriorityNumber) {
case 1: return INT_PRIORITY_LEVEL_1;
case 2: return INT_PRIORITY_LEVEL_2;
case 3: return INT_PRIORITY_LEVEL_3;
case 4: return INT_PRIORITY_LEVEL_4;
case 5: return INT_PRIORITY_LEVEL_5;
case 6: return INT_PRIORITY_LEVEL_6;
case 7: return INT_PRIORITY_LEVEL_7;
default: oosmos_FOREVER();
}
}

static void RunReceiverStateMachine(void * pObject)
{
uart * pUART = (uart *) pObject;
uint8_t Byte;

DisableInterrupt(pUART);
const bool PopSuccess = oosmos_QueuePop(&pUART->m_ReceiveDataQueue, &Byte, sizeof(Byte));
EnableInterrupt(pUART);

if (PopSuccess) {
uart_sReceivedByteEvent ReceivedByteEvent = { oosmos_EMPTY_EVENT, Byte };
oosmos_SubscriberListNotifyWithArgs(pUART->m_ReceivedByteEventSubscribers, ReceivedByteEvent);
}
}

static void RunSenderStateMachine(void * pObject)
{
uart * pUART = (uart *) pObject;

switch (pUART->m_SendState) {
case sendAwaitingCharToSend_State: {
const bool PopSuccess = oosmos_QueuePop(&pUART->m_SendDataQueue, &pUART->m_CharToSend, sizeof(pUART->m_CharToSend));

if (PopSuccess)
pUART->m_SendState = sendAwaitingReady_State;

break;
}
case sendAwaitingReady_State: {
if (UARTTransmitterIsReady(pUART->m_PlibUartID)) {
UARTSendDataByte(pUART->m_PlibUartID, pUART->m_CharToSend);
pUART->m_SendState = sendAwaitingComplete_State;
}

break;
}
case sendAwaitingComplete_State: {
if (UARTTransmissionHasCompleted(pUART->m_PlibUartID))
pUART->m_SendState = sendAwaitingCharToSend_State;

break;
}
}
}

static void RunStateMachine(void * pObject)
{
RunSenderStateMachine(pObject);
RunReceiverStateMachine(pObject);
}

static void ISR(const unsigned UartModule)
{
uart * pUART = UartList;

for (unsigned Count = 1; Count <= UartCount; pUART++, Count++) {
if (UartModule <= pUART->m_UartModule) {
break;
}
}

const unsigned PlibUartId = pUART->m_PlibUartID;

if (INTGetFlag(INT_SOURCE_UART_RX(PlibUartId))) {
while (UARTReceivedDataIsAvailable(PlibUartId)) {
const uint8_t Byte = UARTGetDataByte(PlibUartId);
oosmos_QueuePush(&pUART->m_ReceiveDataQueue, &Byte, sizeof(Byte));
}

INTClearFlag(INT_SOURCE_UART_RX(PlibUartId));
}
}

static uint32_t GetPeripheralClock(void)
{
return (oosmos_GetClockSpeedInMHz()*1000000) / (1 << OSCCONbits.PBDIV);
}

extern void uartPrintf(uart * pUART, const char * pFormat, ...)
{
char Buffer[100];
va_list ArgList;

va_start(ArgList, pFormat);
vsprintf(Buffer, pFormat, ArgList);
uartSendString(pUART, Buffer);
}

extern void uartSendChar(uart * pUART, const char Char)
{
oosmos_QueuePush(&pUART->m_SendDataQueue, &Char, sizeof(Char));
}

extern void uartSendString(uart * pUART, const char * pString)
{
uint8_t Char;

while (Char = *pString++, Char) {
uartSendChar(pUART, Char);
}
}

extern void uartStart(uart * pUART)
{
const unsigned PlibUartId = pUART->m_PlibUartID;

UARTEnable(PlibUartId, UART_ENABLE_FLAGS(UART_PERIPHERAL \| UART_RX \| UART_TX));
EnableInterrupt(pUART);
}

//
// 'UartModule' is 1, 2, etc.
//
extern uart * uartNew(const unsigned UartModule, const unsigned BaudRate)
{
oosmos_AllocateVisible(pUART, uart, UartList, UartCount, MaxUARTS, NULL);

pUART->m_UartModule = UartModule;

const unsigned PlibUartID = UartIndex_to_PlibUartId[UartModule-1];
pUART->m_PlibUartID = PlibUartID;

UARTConfigure(PlibUartID, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(PlibUartID, UART_INTERRUPT_ON_TX_NOT_FULL \| UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(PlibUartID, UART_DATA_SIZE_8_BITS \| UART_PARITY_NONE \| UART_STOP_BITS_1);
UARTSetDataRate(PlibUartID, GetPeripheralClock(), BaudRate);

const unsigned Priority = 1;
INTSetVectorPriority(INT_VECTOR_UART(PlibUartID), GetPriorityBits(Priority));
INTSetVectorSubPriority(INT_VECTOR_UART(PlibUartID), INT_SUB_PRIORITY_LEVEL_0);

oosmos_QueueConstruct(&pUART->m_SendDataQueue, pUART->m_SendDataQueueData);

oosmos_QueueConstruct(&pUART->m_ReceiveDataQueue, pUART->m_ReceiveDataQueueData);
oosmos_SubscriberListInit(pUART->m_ReceivedByteEventSubscribers);

oosmos_ActiveObjectInit(pUART, m_ActiveObject, RunStateMachine);

return pUART;
}
	[...]
extern void uartSubscribe(uart * pUART, oosmos_sQueue * pQueue, const int EventCode, void * pContext)
{
oosmos_SubscriberListAdd(pUART->m_ReceivedByteEventSubscribers, pQueue, EventCode, pContext);
}

#define uartVector(N) void __ISR(_UART_##N##_VECTOR) IntUart##N##Handler() { ISR(N); }

#ifdef _UART1
uartVector(1)
#endif

#ifdef _UART2
uartVector(2)
#endif

#ifdef _UART3
uartVector(3)
#endif

#ifdef _UART4
uartVector(4)
#endif

#ifdef _UART5
uartVector(5)
#endif

#ifdef _UART6
uartVector(6)
#endif

oosmos/Classes/PIC32/uart.c

If the queue is not empty, oosmos_QueuePop will pop an element off the queue and copy it into an item that you allocate.
See lines 123 and 138 in the code snippet below for examples.

1
2
3

bool oosmos_QueuePop(oosmos_sQueue * pQueue, void * pPoppedItem, size_t ElementSize);

Prototype

pQueue	Pointer to a `oosmos_sQueue` item that holds the meta data for the queue.
pPoppedItem	A pointer to an item of `ElementSize` size into which the queue item will be popped.
ElementSize	Size of one element of the queue.
RETURN	Returns `true` if an item was popped off the queue, `false` otherwise.
See Also	`QueueConstruct`, `QueuePush`, `sQueue`

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
//	[GPLv2]
// OOSMOS uart Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include "uart.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdarg.h>

typedef enum
{
sendAwaitingCharToSend_State,
sendAwaitingReady_State,
sendAwaitingComplete_State
} eSendStates;

struct uartTag
{
oosmos_sActiveObject m_ActiveObject;

oosmos_sQueue m_SendDataQueue;
uint8_t m_SendDataQueueData[200];
eSendStates m_SendState;
uint8_t m_CharToSend;

oosmos_sQueue m_ReceiveDataQueue;
uint8_t m_ReceiveDataQueueData[10];
oosmos_sSubscriberList m_ReceivedByteEventSubscribers[1];

uint8_t m_PlibUartID;
uint8_t m_UartModule;
};

#if defined _UART6
#define MaxUARTS 6
#elif defined _UART5
#define MaxUARTS 5
#elif defined _UART4
#define MaxUARTS 4
#elif defined _UART3
#define MaxUARTS 3
#elif defined _UART2
#define MaxUARTS 2
#elif defined _UART1
#define MaxUARTS 1
#endif

static uart UartList[MaxUARTS];
static unsigned UartCount;

static const unsigned UartIndex_to_PlibUartId[] =
{
#ifdef _UART1
UART1,
#endif
#ifdef _UART2
UART2,
#endif
#ifdef _UART3
UART3,
#endif
#ifdef _UART4
UART4,
#endif
#ifdef _UART5
UART5,
#endif
#ifdef _UART6
UART6,
#endif
};

static void EnableInterrupt(uart * pUART)
{
INTEnable(INT_SOURCE_UART_RX(pUART->m_PlibUartID), INT_ENABLED);
}

static void DisableInterrupt(uart * pUART)
{
INTEnable(INT_SOURCE_UART_RX(pUART->m_PlibUartID), INT_DISABLED);
}

static uint16_t GetPriorityBits(const unsigned PriorityNumber)
{
switch (PriorityNumber) {
case 1: return INT_PRIORITY_LEVEL_1;
case 2: return INT_PRIORITY_LEVEL_2;
case 3: return INT_PRIORITY_LEVEL_3;
case 4: return INT_PRIORITY_LEVEL_4;
case 5: return INT_PRIORITY_LEVEL_5;
case 6: return INT_PRIORITY_LEVEL_6;
case 7: return INT_PRIORITY_LEVEL_7;
default: oosmos_FOREVER();
}
}

static void RunReceiverStateMachine(void * pObject)
{
uart * pUART = (uart *) pObject;
uint8_t Byte;

DisableInterrupt(pUART);
const bool PopSuccess = oosmos_QueuePop(&pUART->m_ReceiveDataQueue, &Byte, sizeof(Byte));
EnableInterrupt(pUART);

if (PopSuccess) {
uart_sReceivedByteEvent ReceivedByteEvent = { oosmos_EMPTY_EVENT, Byte };
oosmos_SubscriberListNotifyWithArgs(pUART->m_ReceivedByteEventSubscribers, ReceivedByteEvent);
}
}

static void RunSenderStateMachine(void * pObject)
{
uart * pUART = (uart *) pObject;

switch (pUART->m_SendState) {
case sendAwaitingCharToSend_State: {
const bool PopSuccess = oosmos_QueuePop(&pUART->m_SendDataQueue, &pUART->m_CharToSend, sizeof(pUART->m_CharToSend));

if (PopSuccess)
pUART->m_SendState = sendAwaitingReady_State;

break;
}
case sendAwaitingReady_State: {
if (UARTTransmitterIsReady(pUART->m_PlibUartID)) {
UARTSendDataByte(pUART->m_PlibUartID, pUART->m_CharToSend);
pUART->m_SendState = sendAwaitingComplete_State;
}

break;
}
case sendAwaitingComplete_State: {
if (UARTTransmissionHasCompleted(pUART->m_PlibUartID))
pUART->m_SendState = sendAwaitingCharToSend_State;

break;
}
}
}

static void RunStateMachine(void * pObject)	[...]
{
RunSenderStateMachine(pObject);
RunReceiverStateMachine(pObject);
}

static void ISR(const unsigned UartModule)
{
uart * pUART = UartList;

for (unsigned Count = 1; Count <= UartCount; pUART++, Count++) {
if (UartModule <= pUART->m_UartModule) {
break;
}
}

const unsigned PlibUartId = pUART->m_PlibUartID;

if (INTGetFlag(INT_SOURCE_UART_RX(PlibUartId))) {
while (UARTReceivedDataIsAvailable(PlibUartId)) {
const uint8_t Byte = UARTGetDataByte(PlibUartId);
oosmos_QueuePush(&pUART->m_ReceiveDataQueue, &Byte, sizeof(Byte));
}

INTClearFlag(INT_SOURCE_UART_RX(PlibUartId));
}
}

static uint32_t GetPeripheralClock(void)
{
return (oosmos_GetClockSpeedInMHz()*1000000) / (1 << OSCCONbits.PBDIV);
}

extern void uartPrintf(uart * pUART, const char * pFormat, ...)
{
char Buffer[100];
va_list ArgList;

va_start(ArgList, pFormat);
vsprintf(Buffer, pFormat, ArgList);
uartSendString(pUART, Buffer);
}

extern void uartSendChar(uart * pUART, const char Char)
{
oosmos_QueuePush(&pUART->m_SendDataQueue, &Char, sizeof(Char));
}

extern void uartSendString(uart * pUART, const char * pString)
{
uint8_t Char;

while (Char = *pString++, Char) {
uartSendChar(pUART, Char);
}
}

extern void uartStart(uart * pUART)
{
const unsigned PlibUartId = pUART->m_PlibUartID;

UARTEnable(PlibUartId, UART_ENABLE_FLAGS(UART_PERIPHERAL \| UART_RX \| UART_TX));
EnableInterrupt(pUART);
}

//
// 'UartModule' is 1, 2, etc.
//
extern uart * uartNew(const unsigned UartModule, const unsigned BaudRate)
{
oosmos_AllocateVisible(pUART, uart, UartList, UartCount, MaxUARTS, NULL);

pUART->m_UartModule = UartModule;

const unsigned PlibUartID = UartIndex_to_PlibUartId[UartModule-1];
pUART->m_PlibUartID = PlibUartID;

UARTConfigure(PlibUartID, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(PlibUartID, UART_INTERRUPT_ON_TX_NOT_FULL \| UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(PlibUartID, UART_DATA_SIZE_8_BITS \| UART_PARITY_NONE \| UART_STOP_BITS_1);
UARTSetDataRate(PlibUartID, GetPeripheralClock(), BaudRate);

const unsigned Priority = 1;
INTSetVectorPriority(INT_VECTOR_UART(PlibUartID), GetPriorityBits(Priority));
INTSetVectorSubPriority(INT_VECTOR_UART(PlibUartID), INT_SUB_PRIORITY_LEVEL_0);

oosmos_QueueConstruct(&pUART->m_SendDataQueue, pUART->m_SendDataQueueData);

oosmos_QueueConstruct(&pUART->m_ReceiveDataQueue, pUART->m_ReceiveDataQueueData);
oosmos_SubscriberListInit(pUART->m_ReceivedByteEventSubscribers);

oosmos_ActiveObjectInit(pUART, m_ActiveObject, RunStateMachine);

return pUART;
}

extern void uartSubscribe(uart * pUART, oosmos_sQueue * pQueue, const int EventCode, void * pContext)
{
oosmos_SubscriberListAdd(pUART->m_ReceivedByteEventSubscribers, pQueue, EventCode, pContext);
}

#define uartVector(N) void __ISR(_UART_##N##_VECTOR) IntUart##N##Handler() { ISR(N); }

#ifdef _UART1
uartVector(1)
#endif

#ifdef _UART2
uartVector(2)
#endif

#ifdef _UART3
uartVector(3)
#endif

#ifdef _UART4
uartVector(4)
#endif

#ifdef _UART5
uartVector(5)
#endif

#ifdef _UART6
uartVector(6)
#endif

oosmos/Classes/PIC32/uart.c

Pushes a single item of size ElementSize onto the queue specified by pQueue.
If the queue is already full at the time of this call, the program will loop forever.
See lines 183 and 207 in the code snippet below for examples.

1
2
3

void oosmos_QueuePush(oosmos_sQueue * pQueue, const void * pItemToPush, size_t ElementSize);

Prototype

pQueue	Pointer to a `oosmos_sQueue` item that holds the meta data for the queue.
pItemToPush	A pointer to an item of `ElementSize` size that will be pushed (i.e. copied) onto the queue.
ElementSize	Size of one element of the queue.
See Also	`QueueConstruct`, `QueuePop`, `sQueue`

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
//	[GPLv2]
// OOSMOS uart Class
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include "uart.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdarg.h>

typedef enum
{
sendAwaitingCharToSend_State,
sendAwaitingReady_State,
sendAwaitingComplete_State
} eSendStates;

struct uartTag
{
oosmos_sActiveObject m_ActiveObject;

oosmos_sQueue m_SendDataQueue;
uint8_t m_SendDataQueueData[200];
eSendStates m_SendState;
uint8_t m_CharToSend;

oosmos_sQueue m_ReceiveDataQueue;
uint8_t m_ReceiveDataQueueData[10];
oosmos_sSubscriberList m_ReceivedByteEventSubscribers[1];

uint8_t m_PlibUartID;
uint8_t m_UartModule;
};

#if defined _UART6
#define MaxUARTS 6
#elif defined _UART5
#define MaxUARTS 5
#elif defined _UART4
#define MaxUARTS 4
#elif defined _UART3
#define MaxUARTS 3
#elif defined _UART2
#define MaxUARTS 2
#elif defined _UART1
#define MaxUARTS 1
#endif

static uart UartList[MaxUARTS];
static unsigned UartCount;

static const unsigned UartIndex_to_PlibUartId[] =
{
#ifdef _UART1
UART1,
#endif
#ifdef _UART2
UART2,
#endif
#ifdef _UART3
UART3,
#endif
#ifdef _UART4
UART4,
#endif
#ifdef _UART5
UART5,
#endif
#ifdef _UART6
UART6,
#endif
};

static void EnableInterrupt(uart * pUART)
{
INTEnable(INT_SOURCE_UART_RX(pUART->m_PlibUartID), INT_ENABLED);
}

static void DisableInterrupt(uart * pUART)
{
INTEnable(INT_SOURCE_UART_RX(pUART->m_PlibUartID), INT_DISABLED);
}

static uint16_t GetPriorityBits(const unsigned PriorityNumber)
{
switch (PriorityNumber) {
case 1: return INT_PRIORITY_LEVEL_1;
case 2: return INT_PRIORITY_LEVEL_2;
case 3: return INT_PRIORITY_LEVEL_3;
case 4: return INT_PRIORITY_LEVEL_4;
case 5: return INT_PRIORITY_LEVEL_5;
case 6: return INT_PRIORITY_LEVEL_6;
case 7: return INT_PRIORITY_LEVEL_7;
default: oosmos_FOREVER();
}
}

static void RunReceiverStateMachine(void * pObject)
{
uart * pUART = (uart *) pObject;
uint8_t Byte;

DisableInterrupt(pUART);
const bool PopSuccess = oosmos_QueuePop(&pUART->m_ReceiveDataQueue, &Byte, sizeof(Byte));
EnableInterrupt(pUART);

if (PopSuccess) {
uart_sReceivedByteEvent ReceivedByteEvent = { oosmos_EMPTY_EVENT, Byte };
oosmos_SubscriberListNotifyWithArgs(pUART->m_ReceivedByteEventSubscribers, ReceivedByteEvent);
}
}

static void RunSenderStateMachine(void * pObject)
{
uart * pUART = (uart *) pObject;

switch (pUART->m_SendState) {
case sendAwaitingCharToSend_State: {
const bool PopSuccess = oosmos_QueuePop(&pUART->m_SendDataQueue, &pUART->m_CharToSend, sizeof(pUART->m_CharToSend));

if (PopSuccess)
pUART->m_SendState = sendAwaitingReady_State;

break;
}
case sendAwaitingReady_State: {
if (UARTTransmitterIsReady(pUART->m_PlibUartID)) {
UARTSendDataByte(pUART->m_PlibUartID, pUART->m_CharToSend);
pUART->m_SendState = sendAwaitingComplete_State;
}

break;
}
case sendAwaitingComplete_State: {
if (UARTTransmissionHasCompleted(pUART->m_PlibUartID))
pUART->m_SendState = sendAwaitingCharToSend_State;

break;
}
}
}

static void RunStateMachine(void * pObject)
{
RunSenderStateMachine(pObject);
RunReceiverStateMachine(pObject);
}

static void ISR(const unsigned UartModule)
{
uart * pUART = UartList;

for (unsigned Count = 1; Count <= UartCount; pUART++, Count++) {
if (UartModule <= pUART->m_UartModule) {
break;
}
}

const unsigned PlibUartId = pUART->m_PlibUartID;

if (INTGetFlag(INT_SOURCE_UART_RX(PlibUartId))) {
while (UARTReceivedDataIsAvailable(PlibUartId)) {
const uint8_t Byte = UARTGetDataByte(PlibUartId);
oosmos_QueuePush(&pUART->m_ReceiveDataQueue, &Byte, sizeof(Byte));
}

INTClearFlag(INT_SOURCE_UART_RX(PlibUartId));
}
}
	[...]
static uint32_t GetPeripheralClock(void)
{
return (oosmos_GetClockSpeedInMHz()*1000000) / (1 << OSCCONbits.PBDIV);
}

extern void uartPrintf(uart * pUART, const char * pFormat, ...)
{
char Buffer[100];
va_list ArgList;

va_start(ArgList, pFormat);
vsprintf(Buffer, pFormat, ArgList);
uartSendString(pUART, Buffer);
}

extern void uartSendChar(uart * pUART, const char Char)
{
oosmos_QueuePush(&pUART->m_SendDataQueue, &Char, sizeof(Char));
}
	[...]
extern void uartSendString(uart * pUART, const char * pString)
{
uint8_t Char;

while (Char = *pString++, Char) {
uartSendChar(pUART, Char);
}
}

extern void uartStart(uart * pUART)
{
const unsigned PlibUartId = pUART->m_PlibUartID;

UARTEnable(PlibUartId, UART_ENABLE_FLAGS(UART_PERIPHERAL \| UART_RX \| UART_TX));
EnableInterrupt(pUART);
}

//
// 'UartModule' is 1, 2, etc.
//
extern uart * uartNew(const unsigned UartModule, const unsigned BaudRate)
{
oosmos_AllocateVisible(pUART, uart, UartList, UartCount, MaxUARTS, NULL);

pUART->m_UartModule = UartModule;

const unsigned PlibUartID = UartIndex_to_PlibUartId[UartModule-1];
pUART->m_PlibUartID = PlibUartID;

UARTConfigure(PlibUartID, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(PlibUartID, UART_INTERRUPT_ON_TX_NOT_FULL \| UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(PlibUartID, UART_DATA_SIZE_8_BITS \| UART_PARITY_NONE \| UART_STOP_BITS_1);
UARTSetDataRate(PlibUartID, GetPeripheralClock(), BaudRate);

const unsigned Priority = 1;
INTSetVectorPriority(INT_VECTOR_UART(PlibUartID), GetPriorityBits(Priority));
INTSetVectorSubPriority(INT_VECTOR_UART(PlibUartID), INT_SUB_PRIORITY_LEVEL_0);

oosmos_QueueConstruct(&pUART->m_SendDataQueue, pUART->m_SendDataQueueData);

oosmos_QueueConstruct(&pUART->m_ReceiveDataQueue, pUART->m_ReceiveDataQueueData);
oosmos_SubscriberListInit(pUART->m_ReceivedByteEventSubscribers);

oosmos_ActiveObjectInit(pUART, m_ActiveObject, RunStateMachine);

return pUART;
}

extern void uartSubscribe(uart * pUART, oosmos_sQueue * pQueue, const int EventCode, void * pContext)
{
oosmos_SubscriberListAdd(pUART->m_ReceivedByteEventSubscribers, pQueue, EventCode, pContext);
}

#define uartVector(N) void __ISR(_UART_##N##_VECTOR) IntUart##N##Handler() { ISR(N); }

#ifdef _UART1
uartVector(1)
#endif

#ifdef _UART2
uartVector(2)
#endif

#ifdef _UART3
uartVector(3)
#endif

#ifdef _UART4
uartVector(4)
#endif

#ifdef _UART5
uartVector(5)
#endif

#ifdef _UART6
uartVector(6)
#endif

oosmos/Classes/PIC32/uart.c

This API is experimental and may change. See example on line 222 in the code snippet.

1
2
3

void oosmos_RunStateMachine(oosmos_sStateMachine * pStateMachine);

Prototype

pStateMachine	Address of the state machine within the object.
See Also	`RunStateMachines`

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
//	[GPLv2]
// OOSMOS motion Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdbool.h>
#include <stdio.h>

//>>>EVENTS
enum {
evDownCommand = 1,
evLowerLimitSwitchClosed = 2,
evLowerLimitSwitchOpen = 3,
evStopCommand = 4,
evUpCommand = 5,
evUpperLimitSwitchClosed = 6,
evUpperLimitSwitchOpen = 7
};

#ifdef oosmos_DEBUG
static const char * OOSMOS_EventNames(int EventCode)
{
switch (EventCode) {
case evDownCommand: return "evDownCommand";
case evLowerLimitSwitchClosed: return "evLowerLimitSwitchClosed";
case evLowerLimitSwitchOpen: return "evLowerLimitSwitchOpen";
case evStopCommand: return "evStopCommand";
case evUpCommand: return "evUpCommand";
case evUpperLimitSwitchClosed: return "evUpperLimitSwitchClosed";
case evUpperLimitSwitchOpen: return "evUpperLimitSwitchOpen";
default: return "";
}
}
#endif
//<<<EVENTS

typedef struct motionTag motion;

typedef union {
oosmos_sEvent Base;
} uEvents;

struct motionTag
{
//>>>DECL
oosmos_sStateMachine(ROOT, uEvents, 3);
oosmos_sOrtho Active_State;
oosmos_sOrthoRegion Active_Region1_State;
oosmos_sComposite Active_Region1_Limits_State;
oosmos_sLeaf Active_Region1_Limits_AtUpperLimit_State;
oosmos_sLeaf Active_Region1_Limits_InBounds_State;
oosmos_sLeaf Active_Region1_Limits_Choice1_State;
oosmos_sLeaf Active_Region1_Limits_AtLowerLimit_State;
oosmos_sOrthoRegion Active_Region2_State;
oosmos_sComposite Active_Region2_Moving_State;
oosmos_sLeaf Active_Region2_Moving_Up_State;
oosmos_sLeaf Active_Region2_Moving_Down_State;
oosmos_sLeaf Active_Region2_Stopped_State;
//<<<DECL
};

static int Failures = 0;

static bool IsUpperLimitSwitchOpen(void) {
return true;
}

static bool IsLowerLimitSwitchOpen(void) {
return false;
}

//>>>CODE
static bool Active_Region1_Limits_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
motion * pMotion = (motion *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evUpperLimitSwitchOpen: {
return oosmos_Transition(pMotion, pState, Active_Region1_Limits_AtUpperLimit_State);
}
case evUpperLimitSwitchClosed: {
return oosmos_Transition(pMotion, pState, Active_Region1_Limits_InBounds_State);
}
case evLowerLimitSwitchClosed: {
return oosmos_Transition(pMotion, pState, Active_Region1_Limits_InBounds_State);
}
case evLowerLimitSwitchOpen: {
return oosmos_Transition(pMotion, pState, Active_Region1_Limits_AtLowerLimit_State);
}
}

return false;
}

static bool Active_Region1_Limits_Choice1_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
motion * pMotion = (motion *) pObject;

if (oosmos_EventCode(pEvent) == oosmos_ENTER) {
if (IsUpperLimitSwitchOpen()) {
return oosmos_Transition(pMotion, pState, Active_Region1_Limits_AtUpperLimit_State);
}
else if (IsLowerLimitSwitchOpen()) {
return oosmos_Transition(pMotion, pState, Active_Region1_Limits_AtLowerLimit_State);
}
else {
return oosmos_Transition(pMotion, pState, Active_Region1_Limits_InBounds_State);
}
}

return false;
}

static bool Active_Region2_Moving_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
motion * pMotion = (motion *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evStopCommand: {
return oosmos_Transition(pMotion, pState, Active_Region2_Stopped_State);
}
}

return false;
}

static bool Active_Region2_Stopped_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
motion * pMotion = (motion *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evUpCommand: {
return oosmos_Transition(pMotion, pState, Active_Region2_Moving_Up_State);
}
case evDownCommand: {
return oosmos_Transition(pMotion, pState, Active_Region2_Moving_Down_State);
}
}

return false;
}

static bool Active_Region2_Moving_Up_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
motion * pMotion = (motion *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evDownCommand: {
return oosmos_Transition(pMotion, pState, Active_Region2_Moving_Down_State);
}
case evUpperLimitSwitchOpen: {
return oosmos_Transition(pMotion, pState, Active_Region2_Stopped_State);
}
}

return false;
}

static bool Active_Region2_Moving_Down_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
motion * pMotion = (motion *) pObject;

switch (oosmos_EventCode(pEvent)) {
case evUpCommand: {
return oosmos_Transition(pMotion, pState, Active_Region2_Moving_Up_State);
}
case evLowerLimitSwitchOpen: {
return oosmos_Transition(pMotion, pState, Active_Region2_Stopped_State);
}
}

return false;
}
//<<<CODE

static motion * motionNew(void)
{
oosmos_Allocate(pMotion, motion, 2, NULL);

//>>>INIT
oosmos_StateMachineInit(pMotion, ROOT, NULL, Active_State);
oosmos_OrthoInit(pMotion, Active_State, ROOT, NULL);
oosmos_OrthoRegionInit(pMotion, Active_Region1_State, Active_State, Active_Region1_Limits_State, NULL);
oosmos_CompositeInit(pMotion, Active_Region1_Limits_State, Active_Region1_State, Active_Region1_Limits_Choice1_State, Active_Region1_Limits_State_Code);
oosmos_LeafInit(pMotion, Active_Region1_Limits_AtUpperLimit_State, Active_Region1_Limits_State, NULL);
oosmos_LeafInit(pMotion, Active_Region1_Limits_InBounds_State, Active_Region1_Limits_State, NULL);
oosmos_LeafInit(pMotion, Active_Region1_Limits_Choice1_State, Active_Region1_Limits_State, Active_Region1_Limits_Choice1_State_Code);
oosmos_LeafInit(pMotion, Active_Region1_Limits_AtLowerLimit_State, Active_Region1_Limits_State, NULL);
oosmos_OrthoRegionInit(pMotion, Active_Region2_State, Active_State, Active_Region2_Stopped_State, NULL);
oosmos_CompositeInit(pMotion, Active_Region2_Moving_State, Active_Region2_State, Active_Region2_Moving_Up_State, Active_Region2_Moving_State_Code);
oosmos_LeafInit(pMotion, Active_Region2_Moving_Up_State, Active_Region2_Moving_State, Active_Region2_Moving_Up_State_Code);
oosmos_LeafInit(pMotion, Active_Region2_Moving_Down_State, Active_Region2_Moving_State, Active_Region2_Moving_Down_State_Code);
oosmos_LeafInit(pMotion, Active_Region2_Stopped_State, Active_Region2_State, Active_Region2_Stopped_State_Code);

oosmos_Debug(pMotion, OOSMOS_EventNames);
//<<<INIT

return pMotion;
}

static void QueueEvent(motion * pMotion, int EventCode)
{
oosmos_PushEventCode(pMotion, EventCode);
oosmos_RunStateMachine(pMotion);
}

static void TestState(const motion * pMotion, const void * pState)	[...]
{
if (!oosmos_IsInState(pMotion, pState)) {
printf("FAILURE.\n");
Failures += 1;
}
}

extern int main(void)
{
motion * pMotion = motionNew();

QueueEvent(pMotion, evUpCommand);
TestState(pMotion, &pMotion->Active_Region2_Moving_Up_State);

QueueEvent(pMotion, evUpperLimitSwitchOpen);
TestState(pMotion, &pMotion->Active_Region2_Stopped_State);
TestState(pMotion, &pMotion->Active_Region1_Limits_AtUpperLimit_State);

QueueEvent(pMotion, evDownCommand);
TestState(pMotion, &pMotion->Active_Region2_Moving_Down_State);

QueueEvent(pMotion, evLowerLimitSwitchClosed);
TestState(pMotion, &pMotion->Active_Region1_Limits_InBounds_State);

QueueEvent(pMotion, evUpCommand);
TestState(pMotion, &pMotion->Active_Region2_Moving_Up_State);

QueueEvent(pMotion, evStopCommand);
TestState(pMotion, &pMotion->Active_Region2_Stopped_State);

if (Failures > 0) {
printf("%d FAILURES\n", Failures);
}
else {
printf("\n");
printf("SUCCESS!\n");
}

return 0;
}

oosmos/Examples/Ortho/Windows/Motion.c

oosmos_RunStateMachines runs all OOSMOS state machine objects as well as all registered Active Objects (see oosmos_ActiveObjectInit.)
See line 42 in the code snippet below for an example.

1
2
3

void oosmos_RunStateMachines();

Prototype

See Also

ActiveObjectInit, RunStateMachine, StateMachineInit, StateMachineInitNoQueue

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
//	[GPLv2]
// OOSMOS Blink Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"
#include "pin.h"
#include "toggle.h"

static void SetupToggle(int Pin, int OnTimeMS, int OffTimeMS)
{
pin * pPin = pinNew(Pin, pinOut, pinActiveHigh);
toggleNew(pPin, OnTimeMS, OffTimeMS);
}

extern void setup()
{
SetupToggle(13, 50, 500);
SetupToggle(12, 2000, 2000);
SetupToggle(11, 50, 1500);
}

extern void loop()
{
oosmos_RunStateMachines();
}

oosmos/Examples/Blink/Arduino/BlinkExample/BlinkExample.ino

See oosmos_ActiveObjectInit.

oosmos_sComposite declares a composite state in an OOSMOS state machine object.
See line 36 in the code snippet below for an example.

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
//	[GPLv2]
// OOSMOS Final Example
//
// Copyright (C) 2014-2020 OOSMOS, LLC
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2 of the License ("GPLv2").
//
// This software may be used without the GPLv2 restrictions by entering
// into a commercial license agreement with OOSMOS, LLC.
// See <https://www.oosmos.com/licensing/>.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include "oosmos.h"	[...]
#include <stdio.h>
#include <stdbool.h>

//<<<EVENTS
//>>>EVENTS

typedef struct testTag test;

struct testTag
{
//>>>DECL
oosmos_sStateMachineNoQueue(ROOT);
oosmos_sComposite A_State;
oosmos_sLeaf A_Choice1_State;
oosmos_sLeaf A_Left_State;
oosmos_sLeaf A_Right_State;
oosmos_sFinal A_Final1_State;
oosmos_sLeaf B_State;
//<<<DECL
};

static bool IsLeft(void)	[...]
{
return true;
}

static void Default(void)
{
printf("In Default\n");
}

//>>>CODE
static bool A_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

switch (oosmos_EventCode(pEvent)) {
case oosmos_DEFAULT: {
Default();
return true;
}
case oosmos_COMPLETE: {
return oosmos_Transition(pTest, pState, B_State);
}
}

return false;
}

static bool A_Choice1_State_Code(void * pObject, oosmos_sState * pState, const oosmos_sEvent * pEvent)
{
test * pTest = (test *) pObject;

if (oosmos_EventCode(pEvent) == oosmos_ENTER) {
if (IsLeft()) {
return oosmos_Transition(pTest, pState, A_Left_State);
}
else {
return oosmos_Transition(pTest, pState, A_Right_State);
}
}

oosmos_ActiveObjectInit

oosmos_Allocate

oosmos_AllocateVisible

oosmos_AnalogMapAccurate

oosmos_AnalogMapFast

oosmos_ASSERT

oosmos_ClockSpeedInMHz

oosmos_COMPLETE

oosmos_CompositeInit

oosmos_Days2Hours

oosmos_Days2Minutes

oosmos_Days2MS

oosmos_Days2Seconds

oosmos_Days2US

oosmos_Debug

oosmos_DebugPrint

oosmos_DEFAULT

oosmos_DelayMS

oosmos_DelaySeconds

oosmos_DelayUS

oosmos_Divide_Integral_Rounded

oosmos_EndProgram

oosmos_ENTER

oosmos_EventCode

oosmos_EXIT

oosmos_FinalInit

oosmos_FOREVER

oosmos_GetFreeRunningUS

oosmos_Hours2Days_Rounded

oosmos_Hours2Days_Truncated

oosmos_Hours2Minutes

oosmos_Hours2MS

oosmos_Hours2Seconds

oosmos_Hours2US

oosmos_IsInState

oosmos_LeafInit

oosmos_Minutes2Days_Rounded

oosmos_Minutes2Days_Truncated

oosmos_Minutes2Hours_Rounded

oosmos_Minutes2Hours_Truncated

oosmos_Minutes2MS

oosmos_Minutes2Seconds

oosmos_Minutes2US

oosmos_MS2Days_Rounded

oosmos_MS2Days_Truncated

oosmos_MS2Hours_Rounded

oosmos_MS2Hours_Truncated

oosmos_MS2Minutes_Rounded

oosmos_MS2Minutes_Truncated

oosmos_MS2Seconds_Rounded

oosmos_MS2Seconds_Truncated

oosmos_MS2US

oosmos_ObjectThreadInit

oosmos_ObjectThreadStart

oosmos_ObjectThreadStop

oosmos_ORTHO

oosmos_OrthoInit

oosmos_OrthoRegionInit

oosmos_POINTER_GUARD

oosmos_POLL

oosmos_PushEvent

oosmos_PushEventCode

oosmos_QueueConstruct

oosmos_QueuePop

oosmos_QueuePush

oosmos_RunStateMachine

oosmos_RunStateMachines

oosmos_sActiveObject

oosmos_sComposite