Lily V2

    #include "Lily_help.h"

    // get a relative time/ms
    int get_time_ms()
    {
        int time;
        // ....
        return time;
    }

    // direct the output stream
    void* std_out(void*arg, char*msg, int len)
    {
        // printf("%.*s", len, msg);
        return NULL;
    }

    // implement a Pipe object
    Pipe std_pipe_handle=NULL;

    int main(int argc, char*argv[])
    {
        lily_millis = get_time_ms;
        // setup your output pipe
        std_pipe_handle = li_new_output_device("std",  NULL, std_out);
        // setup the input pipe to Lily
        Pipe lily_pipe_handle = lily_pipe_io_setup(std_pipe_handle);
        pipe_connect_to(std_pipe_handle, lily_pipe_handle);
        const char* cmd = "echo Hello World";
        // input date to Lily using the Pipe
        pipe_release_data(std_pipe_handle,cmd,strlen(cmd));
        // or you can use 'lily_in()' instead
        
        // ...

        // 
        //call for 'lily_tick()' periodically and define a right 'tick_freq' in 'Lily_config.h', if your want to use features like timers and sleep functions.

        // starts messages loop
        tp_run_tasks();
        return 0;
    }

#ifndef LILY_CONFIG_H
#define LILY_CONFIG_H

// the length of task pool
#define Tasks_LEN 32

// the code name of the module
#define _VersionMsg "Robin"
// the frequency for triggering 'lily_tick()'
#define tick_freq 100
// use debug mode?
#define in_debug

#endif

/* your files: my_module.c */
#include "Lily_help.h"

int cmd1(int argn, char*argv[])
{
    // ...
    return 0;
}

void my_module_init()
{
    public_a_cmd("myCmd",cmd1);
}

load(my_module)

        int printStr(char*s)
        {
            lily_out(s);
            return 0;
        }

        void main()
        {
            // ...
            char*s="hallo";
            tp_addTaskArg((TasksArg_def)printStr,s);
            // ...
            tp_run_tasks();
        }

   void OLED_Clear(){
       //do whatever
   }
   void fun2(float a,float b){
       //do whatever with a,b 
   }
   int cmd1(int argc, char *argv[])
   {
       for(int i=0;i<argc;i++)
           lily_out(argv[i]);
       return 0;
   }


   void main()
   {
       float kp=12;

       public_a_cmd_link("cmd1", cmd1);

       public_a_field_ref_type("kp", &kp, 'f');

       public_a_fun_link_n("clc", OLED_Clear, 0);
       public_a_fun_link_n("clc", fun2, 2);

       // ...
   }

    int shine_cursor()
    {   
        //...
        return 0;
    }

    void main()
    {
        li_new_timer(shine_cursor, Hz(2));
        li_remove_timer(shine_cursor);
        li_new_timer(delay_work, Second(2));
        ...
    }

    int delay_work()
    {
        ...
        remove_timer(delay_work);
        return 0;
    }

    Broadcast timeout_broadcast=NULL;

    int alarm_user(){
        // turn buzzer on
        return 0;
    }

    void main()
    {
        timeout_broadcast = li_new_event("timeout");

        event_register_to(timeout_broadcast, alarm_user);
        // ...
        event_broadcast_from(timeout_broadcast);
        // ...
        event_deregister_from(timeout_broadcast, alarm_user);
    }

Pipe p_in, p_out;
void *out(void*arg,char*msg,int n)
{
    ...
}

void main()
{
    p_in = new_input_device("in");
    p_out = new_output_device("out", NULL, out);

    pipe_connect_to(p_in, p_out);
    const char*msg = "hi, this is a msg";
    pipe_release_data(p_in, msg, strlen(msg));
}