C언어로 실시간 시스템의 상태 머신 구현하기

typedef enum {
    STATE_IDLE,
    STATE_PROCESSING,
    STATE_ERROR,
    STATE_COMPLETE
} State;

typedef enum {
    EVENT_START,
    EVENT_SUCCESS,
    EVENT_FAILURE,
    EVENT_RESET
} Event;

typedef struct {
    State currentState;
    Event event;
    State nextState;
} StateTransition;

StateTransition stateTable[] = {
    {STATE_IDLE, EVENT_START, STATE_PROCESSING},
    {STATE_PROCESSING, EVENT_SUCCESS, STATE_COMPLETE},
    {STATE_PROCESSING, EVENT_FAILURE, STATE_ERROR},
    {STATE_ERROR, EVENT_RESET, STATE_IDLE},
    {STATE_COMPLETE, EVENT_RESET, STATE_IDLE}
};

State handleEvent(State currentState, Event event) {
    for (int i = 0; i < sizeof(stateTable) / sizeof(StateTransition); i++) {
        if (stateTable[i].currentState == currentState && stateTable[i].event == event) {
            return stateTable[i].nextState;
        }
    }
    return currentState; // 전환이 없으면 현재 상태 유지
}

void performAction(State state) {
    switch (state) {
        case STATE_IDLE:
            printf("System is idle.\n");
            break;
        case STATE_PROCESSING:
            printf("Processing...\n");
            break;
        case STATE_ERROR:
            printf("Error occurred!\n");
            break;
        case STATE_COMPLETE:
            printf("Process complete.\n");
            break;
        default:
            break;
    }
}

int main() {
    State currentState = STATE_IDLE;

    // 이벤트 시뮬레이션
    Event events[] = {EVENT_START, EVENT_SUCCESS, EVENT_RESET};
    for (int i = 0; i < sizeof(events) / sizeof(Event); i++) {
        currentState = handleEvent(currentState, events[i]);
        performAction(currentState);
    }

    return 0;
}

typedef struct {
    State currentState;
    Event event;
    State nextState;
    void (*action)(void); // 전환 시 수행할 동작
} StateTransition;

void actionStart() { printf("Starting process...\n"); }
void actionComplete() { printf("Completing process...\n"); }
void actionError() { printf("Error occurred!\n"); }

StateTransition stateTable[] = {
    {STATE_IDLE, EVENT_START, STATE_PROCESSING, actionStart},
    {STATE_PROCESSING, EVENT_SUCCESS, STATE_COMPLETE, actionComplete},
    {STATE_PROCESSING, EVENT_FAILURE, STATE_ERROR, actionError},
    {STATE_ERROR, EVENT_RESET, STATE_IDLE, NULL},
    {STATE_COMPLETE, EVENT_RESET, STATE_IDLE, NULL}
};

State handleEvent(State currentState, Event event) {
    for (int i = 0; i < sizeof(stateTable) / sizeof(StateTransition); i++) {
        if (stateTable[i].currentState == currentState && stateTable[i].event == event) {
            if (stateTable[i].action != NULL) {
                stateTable[i].action(); // 전환 시 동작 실행
            }
            return stateTable[i].nextState;
        }
    }
    printf("No transition defined for current state and event.\n");
    return currentState; // 정의되지 않은 전환 시 현재 상태 유지
}

void addStateTransition(State current, Event event, State next, void (*action)(void)) {
    StateTransition newTransition = {current, event, next, action};
    // 새로운 전환을 테이블에 추가 (메모리 관리 필요)
    // 실제 프로젝트에서는 동적 배열이나 리스트 사용
}

int main() {
    State currentState = STATE_IDLE;

    // 시뮬레이션된 이벤트 배열
    Event events[] = {EVENT_START, EVENT_SUCCESS, EVENT_RESET};
    int numEvents = sizeof(events) / sizeof(Event);

    for (int i = 0; i < numEvents; i++) {
        printf("Current State: %d\n", currentState);
        currentState = handleEvent(currentState, events[i]);
        printf("Next State: %d\n\n", currentState);
    }

    return 0;
}

#define MAX_EVENTS 10

typedef struct {
    Event events[MAX_EVENTS];
    int front;
    int rear;
} EventQueue;

// 이벤트 큐 초기화
void initQueue(EventQueue *queue) {
    queue->front = 0;
    queue->rear = 0;
}

// 큐에 이벤트 추가
int enqueue(EventQueue *queue, Event event) {
    if ((queue->rear + 1) % MAX_EVENTS == queue->front) {
        printf("Event Queue is full!\n");
        return -1;
    }
    queue->events[queue->rear] = event;
    queue->rear = (queue->rear + 1) % MAX_EVENTS;
    return 0;
}

// 큐에서 이벤트 제거
int dequeue(EventQueue *queue, Event *event) {
    if (queue->front == queue->rear) {
        printf("Event Queue is empty!\n");
        return -1;
    }
    *event = queue->events[queue->front];
    queue->front = (queue->front + 1) % MAX_EVENTS;
    return 0;
}

void eventLoop(EventQueue *queue, State *currentState) {
    Event event;
    while (1) {
        if (dequeue(queue, &event) == 0) {
            *currentState = handleEvent(*currentState, event);
            performAction(*currentState);
        }
    }
}

// 인터럽트에서 이벤트 생성 예제
void onTimerInterrupt(EventQueue *queue) {
    enqueue(queue, EVENT_RESET); // 타이머 인터럽트 발생 시 이벤트 추가
}

typedef struct {
    Event event;
    int priority;
} PriorityEvent;

// 우선순위 큐에 따라 이벤트 처리
int processPriorityQueue(PriorityEvent *queue, int size) {
    // 우선순위가 높은 순으로 정렬
    qsort(queue, size, sizeof(PriorityEvent), comparePriority);

    for (int i = 0; i < size; i++) {
        handleEvent(currentState, queue[i].event);
    }
    return 0;
}

int main() {
    EventQueue queue;
    initQueue(&queue);

    State currentState = STATE_IDLE;

    // 이벤트 추가 (예제)
    enqueue(&queue, EVENT_START);
    enqueue(&queue, EVENT_SUCCESS);

    // 이벤트 루프 실행
    eventLoop(&queue, &currentState);

    return 0;
}

void logStateTransition(State currentState, Event event, State nextState) {
    printf("Transition: %d -> %d on Event: %d\n", currentState, nextState, event);
}

State handleEvent(State currentState, Event event) {
    for (int i = 0; i < sizeof(stateTable) / sizeof(StateTransition); i++) {
        if (stateTable[i].currentState == currentState && stateTable[i].event == event) {
            logStateTransition(currentState, event, stateTable[i].nextState);
            return stateTable[i].nextState;
        }
    }
    printf("No valid transition for state %d with event %d\n", currentState, event);
    return currentState;
}

void simulateStateMachine() {
    State currentState = STATE_IDLE;
    Event testEvents[] = {EVENT_START, EVENT_SUCCESS, EVENT_FAILURE, EVENT_RESET};
    for (int i = 0; i < sizeof(testEvents) / sizeof(Event); i++) {
        currentState = handleEvent(currentState, testEvents[i]);
        performAction(currentState);
    }
}

// 상태 전환 누락 방지 예제
if (currentState == STATE_IDLE && event == EVENT_START) {
    nextState = STATE_PROCESSING;
} else {
    printf("Unhandled state or event: %d, %d\n", currentState, event);
}

// 무한 루프 방지
assert(currentState != nextState || "State did not change, check transition logic!");

State currentState = STATE_IDLE; // 올바른 초기 상태 설정

#include <time.h>

void measureExecutionTime(void (*func)(void)) {
    clock_t start = clock();
    func();
    clock_t end = clock();
    printf("Execution Time: %lf ms\n", (double)(end - start) * 1000 / CLOCKS_PER_SEC);
}

void testStateMachine() {
    assert(handleEvent(STATE_IDLE, EVENT_START) == STATE_PROCESSING);
    assert(handleEvent(STATE_PROCESSING, EVENT_SUCCESS) == STATE_COMPLETE);
    assert(handleEvent(STATE_PROCESSING, EVENT_FAILURE) == STATE_ERROR);
}

#include <stdlib.h>
#include <string.h>

typedef struct {
    State currentState;
    Event event;
    State nextState;
} StateTransition;

typedef struct {
    StateTransition *transitions;
    int size;
} HashMap;

State findNextState(HashMap *map, State currentState, Event event) {
    for (int i = 0; i < map->size; i++) {
        if (map->transitions[i].currentState == currentState &&
            map->transitions[i].event == event) {
            return map->transitions[i].nextState;
        }
    }
    return currentState; // 기본적으로 상태 유지
}

State cachedNextState[STATE_MAX][EVENT_MAX] = { [0 ... STATE_MAX - 1][0 ... EVENT_MAX - 1] = INVALID_STATE };

// 초기화 시 캐싱
void cacheStateTransitions() {
    for (int i = 0; i < sizeof(stateTable) / sizeof(StateTransition); i++) {
        cachedNextState[stateTable[i].currentState][stateTable[i].event] = stateTable[i].nextState;
    }
}

// 캐시 기반 전환
State getCachedNextState(State currentState, Event event) {
    return cachedNextState[currentState][event];
}

#define MAX_EVENTS 32
typedef struct {
    Event events[MAX_EVENTS];
    int front;
    int rear;
} FixedEventQueue;

typedef struct {
    Event event;
    int priority;
} PriorityEvent;

void sortPriorityQueue(PriorityEvent *queue, int size) {
    // 우선순위가 높은 순서로 정렬
    qsort(queue, size, sizeof(PriorityEvent), comparePriority);
}

if (currentState == STATE_IDLE || currentState == STATE_WAITING) {
    performIdleActions();
}

#include <unistd.h>

void processEventsWithTimer(EventQueue *queue) {
    while (1) {
        // 타이머에 맞춰 이벤트 처리
        usleep(1000); // 1ms 간격
        if (!isQueueEmpty(queue)) {
            Event event = dequeue(queue);
            currentState = handleEvent(currentState, event);
            performAction(currentState);
        }
    }
}

typedef enum {
    STATE_IDLE,
    STATE_ON,
    STATE_OFF,
    STATE_ERROR
} State;

typedef enum {
    EVENT_USER_TOGGLE,
    EVENT_TIMER_EXPIRE,
    EVENT_ERROR_DETECTED,
    EVENT_RESET
} Event;

StateTransition stateTable[] = {
    {STATE_IDLE, EVENT_USER_TOGGLE, STATE_ON, actionTurnOn},
    {STATE_ON, EVENT_USER_TOGGLE, STATE_OFF, actionTurnOff},
    {STATE_OFF, EVENT_USER_TOGGLE, STATE_ON, actionTurnOn},
    {STATE_ON, EVENT_TIMER_EXPIRE, STATE_OFF, actionTurnOff},
    {STATE_ON, EVENT_ERROR_DETECTED, STATE_ERROR, actionHandleError},
    {STATE_ERROR, EVENT_RESET, STATE_IDLE, actionResetSystem}
};

void eventLoop(EventQueue *queue, State *currentState) {
    Event event;
    while (1) {
        if (dequeue(queue, &event) == 0) {
            *currentState = handleEvent(*currentState, event);
            performAction(*currentState);
        }
    }
}

void actionTurnOn() { printf("Turning on the light.\n"); }
void actionTurnOff() { printf("Turning off the light.\n"); }
void actionHandleError() { printf("Error detected! Switching to error state.\n"); }
void actionResetSystem() { printf("Resetting system to idle state.\n"); }

void onCloudCommandReceived(EventQueue *queue, const char *command) {
    if (strcmp(command, "toggle") == 0) {
        enqueue(queue, EVENT_USER_TOGGLE);
    } else if (strcmp(command, "reset") == 0) {
        enqueue(queue, EVENT_RESET);
    }
}

void processSensorData(EventQueue *queue, int motionDetected) {
    if (motionDetected) {
        enqueue(queue, EVENT_USER_TOGGLE);
    }
}

int main() {
    EventQueue queue;
    initQueue(&queue);

    State currentState = STATE_IDLE;

    // 클라우드 명령 및 센서 데이터 시뮬레이션
    onCloudCommandReceived(&queue, "toggle");
    processSensorData(&queue, 1);

    // 이벤트 루프 실행
    eventLoop(&queue, &currentState);

    return 0;
}