TikuOS: Simple. Ubiquitous. Intelligence, Everywhere.

Process & Scheduler

TikuOS uses cooperative, event-driven processes built on protothreads — stackless lightweight threads that occupy only a few bytes of state. Processes communicate via events (posted to a single global queue) and typed channels. The scheduler dispatches one event per iteration and drops into a user-provided idle hook when there is nothing to do.

Headers: kernel/process/tiku_process.h, kernel/process/tiku_proto.h, kernel/process/tiku_lc.h, kernel/scheduler/tiku_sched.h.

Process Management

Header: kernel/process/tiku_process.h

Types

typedef struct tiku_process {
    struct tiku_process *next;      /* Next process in linked list          */
    const char *name;               /* Human-readable process name          */
    PT_THREAD((*thread)(...));      /* Process thread function              */
    struct pt pt;                   /* Protothread control state            */
    uint8_t is_running;             /* Non-zero if process is active        */
    void *local;                    /* Per-process local storage (or NULL)  */
} tiku_process_t;

typedef struct tiku_channel {
    uint8_t *buf;                   /* Pointer to message storage           */
    uint8_t  msg_size;              /* Size of each message in bytes        */
    uint8_t  capacity;              /* Maximum number of messages           */
    volatile uint8_t head;          /* Index of oldest message              */
    volatile uint8_t count;         /* Number of messages in channel        */
} tiku_channel_t;

System Events

Process Declaration Macros

TIKU_PROCESS(name, strname)

Declare and define a process with no local storage.

TIKU_PROCESS(blink_process, "Blink");

TIKU_PROCESS_WITH_LOCAL(name, strname, local_type)

Declare a process with typed local storage. A static instance of local_type is allocated and wired into the process struct at compile time.

struct my_state { uint16_t counter; uint8_t flag; };
TIKU_PROCESS_WITH_LOCAL(my_proc, "my process", struct my_state);

TIKU_PROCESS_TYPED(name, strname, local_type)

Like TIKU_PROCESS_WITH_LOCAL but also generates a type-safe accessor function name_local().

struct sensor_state { uint16_t reading; uint8_t count; };
TIKU_PROCESS_TYPED(sensor_proc, "sensor", struct sensor_state);

TIKU_PROCESS_THREAD(sensor_proc, ev, data) {
    struct sensor_state *s = sensor_proc_local();  /* fully type-safe */
    ...
}

TIKU_LOCAL(type)

Access the current process's local storage with a cast. Place above TIKU_PROCESS_BEGIN().

TIKU_PROCESS_THREAD(my_proc, ev, data) {
    struct my_state *s = TIKU_LOCAL(struct my_state);
    TIKU_PROCESS_BEGIN();
    ...
}

Thread Control Macros

TIKU_AUTOSTART_PROCESSES(...)

Register processes for automatic startup at boot.

TIKU_AUTOSTART_PROCESSES(&proc_a, &proc_b);

Channel Macros

TIKU_CHANNEL_DECLARE(name, type, depth)

Declare a typed, fixed-size message queue with generated inline accessors: name_init(), name_put(&msg), name_get(&msg).

TIKU_CHANNEL_DECLARE(sensor_ch, struct sensor_msg, 4);

sensor_ch_init();
sensor_ch_put(&msg);
sensor_ch_get(&msg);

Functions

Channel Functions

Protothreads

Header: kernel/process/tiku_proto.h

Stackless lightweight threads using only 2 bytes per thread, built on local continuations. Protothreads let you write blocking-style code without a dedicated stack.

Types

struct pt {
    lc_t lc;    /* Local continuation state */
};

Return Codes

Macros

PT_THREAD(my_thread(struct pt *pt, int data))
{
    PT_BEGIN(pt);
    /* thread code */
    PT_END(pt);
}

Local Continuations

Header: kernel/process/tiku_lc.h

Low-level mechanism that captures and restores a function's execution state. Foundation for protothreads — most code should use the protothread API instead of touching LCs directly.

Types

typedef unsigned short lc_t;

Macros

Note: LC_SET cannot be used inside another switch statement. Each LC_SET in a function must be on a different line.

Scheduler

Header: kernel/scheduler/tiku_sched.h

Top-level event loop. Initializes the process system, software timers, and the hardware timer, then dispatches events until stopped. Provides an idle hook for entering low-power modes when the event queue is empty.

Types

typedef void (*tiku_sched_idle_hook_t)(void);

Constants

Functions