RK0: The Real-Time Kernel '0'

VOID Task1(VOID* args)
{
    RK_UNUSEARGS
    UINT count = 0;
    while (1)
    {

        logPost("Task1: sleep");
        kSleep(300);
        /* wake here */
        count += 1U;
        if (count >= 5)
        {
            kDelay(25); /* spin */
            count=0;
            /* every 5 activations there will be a drift */
        }
    }
}

0 ms :: Task1: sleep
300 ms :: Task1: sleep  <-- +300
600 ms :: Task1: sleep  <-- +300
900 ms :: Task1: sleep  <-- +300
1200 ms :: Task1: sleep <-- +300
1525 ms :: Task1: sleep <-- +325
1825 ms :: Task1: sleep <-- +300
2125 ms :: Task1: sleep <-- +300
2425 ms :: Task1: sleep
2725 ms :: Task1: sleep
3050 ms :: Task1: sleep
3350 ms :: Task1: sleep
3650 ms :: Task1: sleep
3950 ms :: Task1: sleep
4250 ms :: Task1: sleep
4575 ms :: Task1: sleep

VOID Task(VOID *args)
{
    <initialisation>

    while(1)
    {
        <periodic code>; /* this has an execution time */
        scheduleNext(PERIOD); /* cycle is finished: compute delay to keep PERIOD */
    }
}

/* Task1 has the Highest nominal priority */
/* Task2 has the Medium nominal priority */
/* Task3 has Lowest nominal priority */

/* Note Task3 starts as 1 and 2 are delayed */

RK_DECLARE_TASK(task1Handle, Task1, stack1, STACKSIZE)
RK_DECLARE_TASK(task2Handle, Task2, stack2, STACKSIZE)
RK_DECLARE_TASK(task3Handle, Task3, stack3, STACKSIZE)


RK_MUTEX mutexA;
RK_MUTEX mutexB;

VOID kApplicationInit(VOID)
{
	K_ASSERT(!kCreateTask(&task1Handle, Task1, RK_NO_ARGS, "Task1", stack1, \
		STACKSIZE, 1, RK_PREEMPT));
	K_ASSERT(!kCreateTask(&task2Handle, Task2, RK_NO_ARGS, "Task2", stack2, \
		STACKSIZE, 2, RK_PREEMPT));
	K_ASSERT(!kCreateTask(&task3Handle, Task3, RK_NO_ARGS, "Task3", stack3, \
		STACKSIZE, 3, RK_PREEMPT));

/* mutexes initialised with priority inheritance enabled */
	kMutexInit(&mutexA, RK_INHERIT);
	kMutexInit(&mutexB, RK_INHERIT);
}



VOID Task3(VOID *args)
{
	RK_UNUSEARGS
	while (1)
	{
		printf("@ %lums: [TL] Attempting to LOCK 'A' | Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);

		kMutexLock(&mutexA, RK_WAIT_FOREVER);

		printf("@ %lums: [TL] LOCKED 'A' (in CS) | Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);

		kDelay(60); /* <-- important */

		printf("@%lums: [TL] About to UNLOCK 'A' | Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);

		kMutexUnlock(&mutexA);

		printf("--->");
		printf("@%lums: [TL] Exit CS | Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);

		kSleep(4);
	}
}

VOID Task2(VOID *args)
{
	RK_UNUSEARGS
	while (1)
	{
		kSleep(5);

		printf("@%lums: [TM] Attempting to LOCK 'B' | Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);
		kMutexLock(&mutexB, RK_WAIT_FOREVER);

		printf("@%lums: [TM] LOCKED 'B', now trying to LOCK 'A' | Eff: %d | Nom: %d\r\n",
			   kTickGet(), runPtr->priority, runPtr->prioNominal);
		kMutexLock(&mutexA, RK_WAIT_FOREVER);

		printf("@%lums: [TM] LOCKED 'A' (in CS) | Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);
		kMutexUnlock(&mutexA);

		printf("@%lums: [TM] UNLOCKING 'B' | Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);

		kMutexUnlock(&mutexB);

		printf("--->");

		printf("@%lums: [TM] Exit CS | Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);
	}
}

VOID Task1(VOID *args)
{
	RK_UNUSEARGS
	while (1)
	{
		kSleep(2);

		printf("@%lums: [TH] Attempting to LOCK 'B'| Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);

		kMutexLock(&mutexB, RK_WAIT_FOREVER);

		printf("@%lums: [TH] LOCKED 'B' (in CS)  | Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);

		kMutexUnlock(&mutexB);

		printf("--->");

		printf("@%lums: [TH] Exit CS | Eff: %d | Nom: %d\r\n", kTickGet(),
			   runPtr->priority, runPtr->prioNominal);
	}
}

>>>> TL locks 'A'. Higher priority tasks are sleeping. <<<<

@ 14720ms: [TL] Attempting to LOCK 'A' | Eff: 3 | Nom: 3
@ 14720ms: [TL] LOCKED 'A' (in CS) | Eff: 3 | Nom: 3

@14721ms: [TM] Attempting to LOCK 'B' | Eff: 2 | Nom: 2

>>>> TM acquires 'B' and is blocked by TL on 'A'. TL inherits TM's  priority. <<<<

@14721ms: [TM] LOCKED 'B', now trying to LOCK 'A' | Eff: 2 | Nom: 2

>>>> TH will blocked by TM on 'B': <<<<

@14722ms: [TH] Attempting to LOCK 'B'| Eff: 1 | Nom: 1

>>>> TM inherits TH's priority. TL inherits TH's priority via TM. <<<<

@14780ms: [TL] About to UNLOCK 'A' | Eff: 1 | Nom: 3

>>>> Upon unlocking 'A', TL is preempted by TM. It means TL's priority has been restored, as it is no longer blocking a higher priority task. <<<<


>>>> Now TM acquires 'A' <<<<

@14780ms: [TM] LOCKED 'A' (in CS) | Eff: 1 | Nom: 2

>>>> After releasing 'A', but before releasing 'B', TM's priority is still '1', as it is blocking TH while holding 'B'. <<<<

@14780ms: [TM] UNLOCKING 'B' | Eff: 1 | Nom: 2

>>>> Upon unlocking 'B' TM is preempted by TH. (TM's priority has been restored.) <<<<

@14780ms: [TH] LOCKED 'B' (in CS)  | Eff: 1 | Nom: 1

>>> RESULT: even though priority inversion was enforced, tasks leave the nested lock ordered by their nominal priority. <<<

--->@14780ms: [TH] Exit CS | Eff: 1 | Nom: 1
--->@14780ms: [TM] Exit CS | Eff: 2 | Nom: 2
--->@14780ms: [TL] Exit CS | Eff: 3 | Nom: 3

 --- snippet ---
 while (condition is FALSE)
 {
    /*unlock-wait sequence:*/

     ATOMIC_BEGIN

     unlock(mutex);   /*the atomic unlock-sleep we referred earlier */
     sleep(condition)

     ATOMIC_END

     lock(mutex);
     /* when waking, the while clause is tested again */
 }
 --- snippet ---

                            Entry Queue [][][]–>
         .............................................
         -------------------
         | Internal States |
         |-----------------
         | Total buffers   |
         | Taken buffers   |
         -------------------  |[Active Task]|
         | Sleep Queues    |
         |Sleeping for Data|
         |Sleeping for Room|
         -------------------
                              -> [][][] Exit Queue
        ...............................................

  while(!condition)
  {
    kCondVarWait(&condQueue, &monitorLock, timeout);
  }

/* Application Logger pattern */

/* standard log structure */
struct log
{
    RK_TICK t; /* timestamp */
    CHAR s[LOGLEN]; /*formatted string */
    UINT    level; /* level 0=message, 1=fault */
} K_ALIGN(4);

typedef struct log Log_t;

/* logger mem allocator + mem pool */
static RK_MEM_PARTITION qMem;
static Log_t logBufPool[LOGPOOLSIZ] K_ALIGN(4);

/* backing buffer for the logger queue */
/* (messages are 1-word-size, number equals the pool) */
RK_DECLARE_MESG_QUEUE_BUF(logQBuf, VOID *, LOGPOOLSIZ)

/* logger mail queue */
static RK_MESG_QUEUE logQ;

/* a sender will allocate a buffer write the log
message and enqueue on the mail queue, not-blocking
if the queue is full it returns the buffer immediately
if the memory pool is empty it drops the operation */

```c
/* excerpt of logPost(...) */
VOID logPost(/*formatted string */)
    ---snip---
    Log_t *logPtr = (Log_t*)kMemPartitionAlloc(&qMem);
    RK_BARRIER
    if (logPtr) /* available buffer */
    {

       < fill the buffer >

        /* enqueue address */
        if (kMesgQueueSend(&logQ, &p, RK_NO_WAIT) != RK_ERR_SUCCESS)
        {
            /* queue is full, deallocate buf */
            RK_ERR err = kMemPartitionFree(&qMem, &p);
            K_ASSERT(err==RK_ERR_SUCCESS);
        }

    }
    ---snip---

/* excerpt of the logger task */

static VOID LoggerTask(VOID *args)
{
    RK_UNUSEARGS
    while (1)
    {

        VOID *recvPtr = NULL;

        /* drain the queue: keep receiving while successful */
        while (kMesgQueueRecv(&logQ, &recvPtr, RK_WAIT_FOREVER) == RK_ERR_SUCCESS)
        {
            < print buffer contents >

            /* deallocate */
            RK_ERR err = kMemPartitionFree(&qMem, recvPtr);
            K_ASSERT(err == RK_ERR_SUCCESS);

        }
    }
}

/* Many-to-1 queue channels */

/* Consumer Select queue based on its event
flags, that a succesfull send triggers  */

#define LOG_PRIORITY 4 /* keep logger as lowest-priority user task */
#define STACKSIZE 256

#define NQUEUES 3 /* number of queues */
#define QSIZ 8 /* depth of each queue */

#define Q0_FLAG   RK_EVENT_1 // (1<<0)
#define Q1_FLAG   RK_EVENT_2 // (1<<1)
#define Q2_FLAG   RK_EVENT_3 // (1<<2)
#define QFLAGS   (ULONG)(Q0_FLAG | Q1_FLAG | Q2_FLAG)

typedef struct
{
    RK_TASK_HANDLE producer;
    UINT payload;
} MESG_t;

/* Succesful Send callbacks */
/* each callback follows this pattern */
static inline
VOID sendNotify0(RK_MESG_QUEUE *qPtr)
{
    (VOID)qPtr;
    kTaskEventSet(consumerHandle, Q0_FLAG);
    /* Q1 flag for queue1 and so forth */
}

/* each callback in installed using kMesgQueueInstallSendCbk
on kApplicationInit() */

/* helper to send */
static inline
VOID enqueueSample(RK_MESG_QUEUE *qPtr UINT payload)
{
    MESG_t mesg = {
        .payload = payload,
        .producer = RK_RUNNING_HANDLE,
    };
    RK_ERR err = kMesgQueueSend(qPtr, &mesg, RK_WAIT_FOREVER);
    K_ASSERT(err == RK_ERR_SUCCESS);
}


VOID Prod0Task(VOID *args)
{
    RK_UNUSEARGS
    UINT seq = 0U;

    while (1)
    {
        enqueueSample(&queues[0], seq++);
        kSleepRelease(25); /* fast producer */
    }
}

VOID Prod1Task(VOID *args)
{
    UINT seq = 0U;
    RK_UNUSEARGS

    while (1)
    {
        enqueueSample(&queues[1], seq++);

        /* every fourth sample, also tickle the third queue */
        if ((seq & 0x3U) == 0U)
        {
            enqueueSample(&queues[2], seq);
        }

        kSleepRelease(60);
    }
}

/* Consumer listens on all queues, selecting those on its signal flags. */
VOID ConsumerTask(VOID *args)
{
    RK_UNUSEARGS

    MESG_t recv = {0};
    ULONG flags = 0UL;

    while (1)
    {
        flags = 0UL;
        kTaskEventGet(QFLAGS, RK_EVENT_FLAGS_ANY, &flags,
                           RK_WAIT_FOREVER);

        for (UINT i = 0; i < NQUEUES; ++i)
        {
            if (flags & (1UL << i))
            {
                while (kMesgQueueRecv(&queues[i], (VOID*)&recv, RK_NO_WAIT) ==
                       RK_ERR_SUCCESS)
                {
                    logPost("Q%u <- sender=%s payload=%u", i,
                            RK_TASK_NAME(recv.producer), recv.payload);
                }
            }
        }
    }
}

       0 ms :: Q1 <- sender=Prod1 payload=0
     250 ms :: Q0 <- sender=Prod0 payload=1
     500 ms :: Q0 <- sender=Prod0 payload=2
     600 ms :: Q1 <- sender=Prod1 payload=1
     750 ms :: Q0 <- sender=Prod0 payload=3
    1000 ms :: Q0 <- sender=Prod0 payload=4
    1200 ms :: Q1 <- sender=Prod1 payload=2
    1250 ms :: Q0 <- sender=Prod0 payload=5
    1500 ms :: Q0 <- sender=Prod0 payload=6
    1750 ms :: Q0 <- sender=Prod0 payload=7
    1800 ms :: Q1 <- sender=Prod1 payload=3
    1800 ms :: Q2 <- sender=Prod1 payload=4
    2000 ms :: Q0 <- sender=Prod0 payload=8
    2250 ms :: Q0 <- sender=Prod0 payload=9
    2400 ms :: Q1 <- sender=Prod1 payload=4
    2500 ms :: Q0 <- sender=Prod0 payload=10
    2750 ms :: Q0 <- sender=Prod0 payload=11
    3000 ms :: Q0 <- sender=Prod0 payload=12
    3000 ms :: Q1 <- sender=Prod1 payload=5
    3250 ms :: Q0 <- sender=Prod0 payload=13
    3500 ms :: Q0 <- sender=Prod0 payload=14
    3600 ms :: Q1 <- sender=Prod1 payload=6
    3750 ms :: Q0 <- sender=Prod0 payload=15
    4000 ms :: Q0 <- sender=Prod0 payload=16
    4200 ms :: Q1 <- sender=Prod1 payload=7
    4200 ms :: Q2 <- sender=Prod1 payload=8
    4250 ms :: Q0 <- sender=Prod0 payload=17
    4500 ms :: Q0 <- sender=Prod0 payload=18
    4750 ms :: Q0 <- sender=Prod0 payload=19
    4800 ms :: Q1 <- sender=Prod1 payload=8
    5000 ms :: Q0 <- sender=Prod0 payload=20
    5250 ms :: Q0 <- sender=Prod0 payload=21

/*
 Example: HVAC command protocol over RK_CHANNEL.
 *
 * APDU request frame (client -> server):
 *   INSTRUCTION | PAYLOADSIZE | PAYLOAD | CRC16
 *
 * Response (server -> client):
 *   CRC16
 *
 *
 * Control-system idea:
 * - Multiple clients represent independent control loops (thermostat,
 *   occupancy, air quality).
 * - A single HVAC server task owns the plant state and applies every command.
 * - CHANNEL calls serialise updates, so state transitions are deterministic.
 * - The response CRC is an acknowledgement fingerprint of
 *   {instruction, execution-result, current HVAC state}.
*/

#include <kapi.h>
#include <logger.h>

#define LOG_PRIORITY 5
#define STACKSIZE 256

#define HVAC_CHANNEL_DEPTH 4U /* max number of pending requests */
#define HVAC_APDU_MAX_PAYLOAD 8U /* max payload size in bytes */

/* instructions */
#define HVAC_INS_SET_POWER ((BYTE)0x10U)
#define HVAC_INS_SET_MODE ((BYTE)0x11U)
#define HVAC_INS_SET_TARGET_TEMP ((BYTE)0x12U)
#define HVAC_INS_SET_FAN_PERCENT ((BYTE)0x13U)

/* plant mode */
#define HVAC_MODE_HEAT ((BYTE)0x1U)
#define HVAC_MODE_COOL ((BYTE)0x2U)
#define HVAC_MODE_FAN ((BYTE)0x3U)

/* limits */
#define HVAC_MIN_TEMP_C ((BYTE)16U)
#define HVAC_MAX_TEMP_C ((BYTE)30U)

typedef struct
{
    BYTE instruction;
    BYTE payloadSize;
    BYTE payload[HVAC_APDU_MAX_PAYLOAD];
    USHORT crc;
} HVAC_APDU;

typedef struct
{
    BYTE powerOn;
    BYTE mode;
    BYTE targetTempC;
    BYTE fanPercent;
} HVAC_STATE;

/* control tasks and a single actuator server */
RK_DECLARE_TASK(thermostatHandle, ThermostatTask, thermostatStack, STACKSIZE)
RK_DECLARE_TASK(occupancyHandle, OccupancyTask, occupancyStack, STACKSIZE)
RK_DECLARE_TASK(airQualityHandle, AirQualityTask, airQualityStack, STACKSIZE)
RK_DECLARE_TASK(hvacServerHandle, HvacServerTask, hvacServerStack, STACKSIZE)

/* declare the channel and the buffer to enqueue the requests */
static RK_CHANNEL hvacChannel;
RK_DECLARE_CHANNEL_BUF(hvacChannelBuf, HVAC_CHANNEL_DEPTH)

/* request pool for the channel */
static RK_MEM_PARTITION hvacReqPartition;
static RK_REQ_BUF hvacReqPool[HVAC_CHANNEL_DEPTH] K_ALIGN(4);

/* crc computation */
static USHORT HvacCrc16Ccitt_(BYTE const *const dataPtr, UINT const len)
{
    USHORT crc = (USHORT)0xFFFFU;

    for (UINT i = 0U; i < len; ++i)
    {
        crc ^= (USHORT)((USHORT)dataPtr[i] << 8U);

        for (UINT bit = 0U; bit < 8U; ++bit)
        {
            if ((crc & (USHORT)0x8000U) != 0U)
            {
                crc = (USHORT)((USHORT)(crc << 1U) ^ (USHORT)0x1021U);
            }
            else
            {
                crc = (USHORT)(crc << 1U);
            }
        }
    }

    return (crc);
}

static USHORT HvacBuildApduCrc_(HVAC_APDU const *const apduPtr)
{
    BYTE frame[2U + HVAC_APDU_MAX_PAYLOAD];
    UINT const payloadSize = (UINT)apduPtr->payloadSize;

    K_ASSERT(payloadSize <= HVAC_APDU_MAX_PAYLOAD);

    frame[0] = apduPtr->instruction;
    frame[1] = apduPtr->payloadSize;

    for (UINT i = 0U; i < payloadSize; ++i)
    {
        frame[2U + i] = apduPtr->payload[i];
    }

    return (HvacCrc16Ccitt_(frame, 2U + payloadSize));
}

static USHORT HvacBuildResponseCrc_(BYTE const instruction, RK_BOOL const executed, HVAC_STATE const *const statePtr)
{
    /* Response: CRC over execution status + state. */
    BYTE responseFrame[6U];

    responseFrame[0] = instruction;
    responseFrame[1] = (BYTE)((executed != RK_FALSE) ? 1U : 0U);
    responseFrame[2] = statePtr->powerOn;
    responseFrame[3] = statePtr->mode;
    responseFrame[4] = statePtr->targetTempC;
    responseFrame[5] = statePtr->fanPercent;

    return (HvacCrc16Ccitt_(responseFrame, 6U));
}

static RK_BOOL HvacExecuteInstruction_(HVAC_APDU const *const apduPtr, HVAC_STATE *const statePtr)
{
    /* command dispatcher: validates limits before actuation. */
    UINT const payloadSize = (UINT)apduPtr->payloadSize;

    if (payloadSize > HVAC_APDU_MAX_PAYLOAD)
    {
        return (RK_FALSE);
    }

    switch (apduPtr->instruction)
    {
    case HVAC_INS_SET_POWER:
        if ((payloadSize != 1U) || (apduPtr->payload[0] > 1U))
        {
            return (RK_FALSE);
        }
        statePtr->powerOn = apduPtr->payload[0];
        return (RK_TRUE);

    case HVAC_INS_SET_MODE:
        if (payloadSize != 1U)
        {
            return (RK_FALSE);
        }
        if ((apduPtr->payload[0] != HVAC_MODE_HEAT) &&
            (apduPtr->payload[0] != HVAC_MODE_COOL) &&
            (apduPtr->payload[0] != HVAC_MODE_FAN))
        {
            return (RK_FALSE);
        }
        statePtr->mode = apduPtr->payload[0];
        return (RK_TRUE);

    case HVAC_INS_SET_TARGET_TEMP:
        if (payloadSize != 1U)
        {
            return (RK_FALSE);
        }
        if ((apduPtr->payload[0] < HVAC_MIN_TEMP_C) ||
            (apduPtr->payload[0] > HVAC_MAX_TEMP_C))
        {
            return (RK_FALSE);
        }
        statePtr->targetTempC = apduPtr->payload[0];
        return (RK_TRUE);

    case HVAC_INS_SET_FAN_PERCENT:
        if ((payloadSize != 1U) || (apduPtr->payload[0] > 100U))
        {
            return (RK_FALSE);
        }
        statePtr->fanPercent = apduPtr->payload[0];
        return (RK_TRUE);

    default:
        return (RK_FALSE);
    }
}

static USHORT HvacChannelCall_(BYTE const instruction,
                               BYTE const *const payloadPtr,
                               BYTE const payloadSize)
{
    /* Synchronous command transaction:
     * allocate request envelope, send APDU, block until server completes.
     */
    HVAC_APDU apdu = {0};
    USHORT responseCrc = 0U;

    RK_REQ_BUF *reqBuf = (RK_REQ_BUF*)kMemPartitionAlloc(&hvacReqPartition);
    K_ASSERT(reqBuf != NULL);

    K_ASSERT((UINT)payloadSize <= HVAC_APDU_MAX_PAYLOAD);

    apdu.instruction = instruction;
    apdu.payloadSize = payloadSize;

    for (UINT i = 0U; i < (UINT)payloadSize; ++i)
    {
        apdu.payload[i] = payloadPtr[i];
    }

    apdu.crc = HvacBuildApduCrc_(&apdu);

    reqBuf->size = (ULONG)sizeof(HVAC_APDU);
    reqBuf->reqPtr = &apdu;
    reqBuf->respPtr = &responseCrc;

    RK_ERR err = kChannelCall(hvacServerHandle, reqBuf, RK_WAIT_FOREVER);
    K_ASSERT(err == RK_ERR_SUCCESS);

    return (responseCrc);
}

VOID HvacServerTask(VOID *args)
{
    RK_UNUSEARGS

    /* Single-writer plant model: only this task mutates HVAC_STATE. */
    HVAC_STATE hvacState =
    {
        .powerOn = 0U,
        .mode = HVAC_MODE_COOL,
        .targetTempC = 22U,
        .fanPercent = 40U
    };

    while (1)
    {
        /*
          SERVER EXECUTION FLOW:
          1) Accept command
          2) validate APDU
          3) apply instruction
          4) emit response CRC
          5) complete channel call.
         */
        RK_REQ_BUF *reqBuf = NULL;
        RK_ERR err = kChannelAccept(&hvacChannel, &reqBuf, RK_WAIT_FOREVER);
        K_ASSERT(err == RK_ERR_SUCCESS);

        HVAC_APDU const *apduPtr = (HVAC_APDU const *)reqBuf->reqPtr;
        USHORT *responseCrcPtr = (USHORT *)reqBuf->respPtr;

        K_ASSERT(apduPtr != NULL);
        K_ASSERT(responseCrcPtr != NULL);

        RK_BOOL valid = (RK_BOOL)(reqBuf->size == (ULONG)sizeof(HVAC_APDU));
        RK_BOOL executed = RK_FALSE;

        if (valid != RK_FALSE)
        {
            USHORT expectedCrc = HvacBuildApduCrc_(apduPtr);
            valid = (RK_BOOL)(expectedCrc == apduPtr->crc);
        }

        if (valid != RK_FALSE)
        {
            executed = HvacExecuteInstruction_(apduPtr, &hvacState);
        }

        *responseCrcPtr = HvacBuildResponseCrc_(apduPtr->instruction,
                                                executed,
                                                &hvacState);

        if ((valid != RK_FALSE) && (executed != RK_FALSE))
        {
            logPost("[HVAC-SRV] INS=0x%02x OK PWR=%u MODE=%u T=%uC FAN=%u%% RESP_CRC=0x%04x",
                    (UINT)apduPtr->instruction,
                    (UINT)hvacState.powerOn,
                    (UINT)hvacState.mode,
                    (UINT)hvacState.targetTempC,
                    (UINT)hvacState.fanPercent,
                    (UINT)(*responseCrcPtr));
        }
        else
        {
            logPost("[HVAC-SRV] INS=0x%02x INVALID REQ_CRC=0x%04x RESP_CRC=0x%04x",
                    (UINT)apduPtr->instruction,
                    (UINT)apduPtr->crc,
                    (UINT)(*responseCrcPtr));
        }

        err = kChannelDone(reqBuf);
        K_ASSERT(err == RK_ERR_SUCCESS);
    }
}

VOID ThermostatTask(VOID *args)
{
    RK_UNUSEARGS

    /*  chooses mode and target temperature setpoint. */
    BYTE payload[1U] = {0U};

    while (1)
    {
        payload[0] = HVAC_MODE_HEAT;
        USHORT crcMode = HvacChannelCall_(HVAC_INS_SET_MODE, payload, 1U);
        logPost("[THERMO] SET_MODE=%u RESP_CRC=0x%04x", (UINT)payload[0],
                (UINT)crcMode);

        payload[0] = 24U;
        USHORT crcTemp =
            HvacChannelCall_(HVAC_INS_SET_TARGET_TEMP, payload, 1U);
        logPost("[THERMO] SET_TEMP=%uC RESP_CRC=0x%04x", (UINT)payload[0],
                (UINT)crcTemp);

        kSleep(80U);

        payload[0] = HVAC_MODE_COOL;
        crcMode = HvacChannelCall_(HVAC_INS_SET_MODE, payload, 1U);
        logPost("[THERMO] SET_MODE=%u RESP_CRC=0x%04x", (UINT)payload[0],
                (UINT)crcMode);

        payload[0] = 20U;
        crcTemp = HvacChannelCall_(HVAC_INS_SET_TARGET_TEMP, payload, 1U);
        logPost("[THERMO] SET_TEMP=%uC RESP_CRC=0x%04x", (UINT)payload[0],
                (UINT)crcTemp);

        kSleep(80U);
    }
}

VOID OccupancyTask(VOID *args)
{
    RK_UNUSEARGS

    /* Presence loop: enables/disables HVAC when occupancy changes.
      (number of people on the room)
    */
    BYTE payload[1U] = {1U};

    while (1)
    {
        USHORT crc = HvacChannelCall_(HVAC_INS_SET_POWER, payload, 1U);
        logPost("[OCCUP] SET_POWER=%u RESP_CRC=0x%04x", (UINT)payload[0],
                (UINT)crc);

        payload[0] = (BYTE)((payload[0] == 0U) ? 1U : 0U);
        kSleep(140U);
    }
}

VOID AirQualityTask(VOID *args)
{
    RK_UNUSEARGS

    /* Air-quality loop: adjusts fan throughput demand. */
    BYTE payload[1U] = {30U};

    while (1)
    {
        USHORT crc = HvacChannelCall_(HVAC_INS_SET_FAN_PERCENT, payload, 1U);
        logPost("[AIRQ ] SET_FAN=%u%% RESP_CRC=0x%04x", (UINT)payload[0],
                (UINT)crc);

        payload[0] = (BYTE)(payload[0] + 20U);
        if (payload[0] > 90U)
        {
            payload[0] = 30U;
        }

        kSleep(110U);
    }
}

VOID kApplicationInit(VOID)
{
    RK_ERR err = kCreateTask(&hvacServerHandle, HvacServerTask, RK_NO_ARGS,
                             "HvacSrv", hvacServerStack, STACKSIZE, 4,
                             RK_PREEMPT);
    K_ASSERT(err == RK_ERR_SUCCESS);

    err = kMemPartitionInit(&hvacReqPartition, hvacReqPool, sizeof(RK_REQ_BUF), HVAC_CHANNEL_DEPTH);
    K_ASSERT(err == RK_ERR_SUCCESS);

    err = kChannelInit(&hvacChannel, hvacChannelBuf, HVAC_CHANNEL_DEPTH,hvacServerHandle, &hvacReqPartition);
    K_ASSERT(err == RK_ERR_SUCCESS);

    err = kCreateTask(&thermostatHandle, ThermostatTask, RK_NO_ARGS, "Thermo", thermostatStack, STACKSIZE, 1, RK_PREEMPT);
    K_ASSERT(err == RK_ERR_SUCCESS);

    err = kCreateTask(&occupancyHandle, OccupancyTask, RK_NO_ARGS, "Occpnc", occupancyStack, STACKSIZE, 2, RK_PREEMPT);
    K_ASSERT(err == RK_ERR_SUCCESS);

    err = kCreateTask(&airQualityHandle, AirQualityTask, RK_NO_ARGS, "AirQal", airQualityStack, STACKSIZE, 3, RK_PREEMPT);
    K_ASSERT(err == RK_ERR_SUCCESS);

    logInit(LOG_PRIORITY);
}

       0 ms :: [HVAC-SRV] INS=0x11 OK PWR=0 MODE=1 T=22C FAN=40% RESP_CRC=0xc0ea
       0 ms :: [HVAC-SRV] INS=0x10 OK PWR=1 MODE=1 T=22C FAN=40% RESP_CRC=0xf3fe
       0 ms :: [HVAC-SRV] INS=0x13 OK PWR=1 MODE=1 T=22C FAN=30% RESP_CRC=0x6b8b
       0 ms :: [THERMO] SET_MODE=1 RESP_CRC=0xc0ea
       0 ms :: [OCCUP] SET_POWER=1 RESP_CRC=0xf3fe
       0 ms :: [AIRQ ] SET_FAN=30% RESP_CRC=0x6b8b
       0 ms :: [HVAC-SRV] INS=0x12 OK PWR=1 MODE=1 T=24C FAN=30% RESP_CRC=0x0d24
       0 ms :: [THERMO] SET_TEMP=24C RESP_CRC=0x0d24
     800 ms :: [HVAC-SRV] INS=0x11 OK PWR=1 MODE=2 T=24C FAN=30% RESP_CRC=0x9a94
     800 ms :: [THERMO] SET_MODE=2 RESP_CRC=0x9a94
     800 ms :: [HVAC-SRV] INS=0x12 OK PWR=1 MODE=2 T=20C FAN=30% RESP_CRC=0x1119
     800 ms :: [THERMO] SET_TEMP=20C RESP_CRC=0x1119
    1100 ms :: [HVAC-SRV] INS=0x13 OK PWR=1 MODE=2 T=20C FAN=50% RESP_CRC=0xb157
    1100 ms :: [AIRQ ] SET_FAN=50% RESP_CRC=0xb157
    1400 ms :: [HVAC-SRV] INS=0x10 OK PWR=0 MODE=2 T=20C FAN=50% RESP_CRC=0x0903
    1400 ms :: [OCCUP] SET_POWER=0 RESP_CRC=0x0903
    1600 ms :: [HVAC-SRV] INS=0x11 OK PWR=0 MODE=1 T=20C FAN=50% RESP_CRC=0x15f3
    1600 ms :: [THERMO] SET_MODE=1 RESP_CRC=0x15f3
    1600 ms :: [HVAC-SRV] INS=0x12 OK PWR=0 MODE=1 T=24C FAN=50% RESP_CRC=0x9e7e
    1600 ms :: [THERMO] SET_TEMP=24C RESP_CRC=0x9e7e
    2200 ms :: [HVAC-SRV] INS=0x13 OK PWR=0 MODE=1 T=24C FAN=70% RESP_CRC=0xe5cd
    2200 ms :: [AIRQ ] SET_FAN=70% RESP_CRC=0xe5cd
    2400 ms :: [HVAC-SRV] INS=0x11 OK PWR=0 MODE=2 T=24C FAN=70% RESP_CRC=0x37dd
    2400 ms :: [THERMO] SET_MODE=2 RESP_CRC=0x37dd
    2400 ms :: [HVAC-SRV] INS=0x12 OK PWR=0 MODE=2 T=20C FAN=70% RESP_CRC=0xbc50
    2400 ms :: [THERMO] SET_TEMP=20C RESP_CRC=0xbc50
    2800 ms :: [HVAC-SRV] INS=0x10 OK PWR=1 MODE=2 T=20C FAN=70% RESP_CRC=0x41a4
    2800 ms :: [OCCUP] SET_POWER=1 RESP_CRC=0x41a4
    3200 ms :: [HVAC-SRV] INS=0x11 OK PWR=1 MODE=1 T=20C FAN=70% RESP_CRC=0x5d54
    3200 ms :: [THERMO] SET_MODE=1 RESP_CRC=0x5d54
    3200 ms :: [HVAC-SRV] INS=0x12 OK PWR=1 MODE=1 T=24C FAN=70% RESP_CRC=0xd6d9
    3200 ms :: [THERMO] SET_TEMP=24C RESP_CRC=0xd6d9
    3300 ms :: [HVAC-SRV] INS=0x13 OK PWR=1 MODE=1 T=24C FAN=90% RESP_CRC=0x40c4
    3300 ms :: [AIRQ ] SET_FAN=90% RESP_CRC=0x40c4