Subversion Repositories shark

///////////////////////////////////////////////////

// app.c                -Lex Nahumury 2006

// 

// This would be the Closed Source User Application part.

// The ELF object itself contains no GPL code.

// The references to GPL code are resolved

// by the Dynamic Linker after the kernel has loaded.

//

//////////////////////////////////////////////////

/*

Usage example:

# For booting SHARK image from HD

title  S.H.A.R.K + Boot Modules from HD 0,0

kernel (hd0,0)/boot/os   mount root=/dev/hda1

module (hd0,0)/boot/sh_app.bin

module (hd0,0)/boot/data.bin

*/

#include "kernel/kern.h"

#include <kernel/func.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <math.h>

#include "ll/i386/cons.h"

#include <drivers/shark_keyb26.h>

#include "../../ports/dynalink/dynalink.h"

extern void call_shutdown_task(void *arg);

extern DWORD get_tick();

struct params

{

        int task_nr;

        int row;

        int count;

        int cycles;

};

TASK periodic_task(void *arg)

{

        int ani=0;

        char c[2];

        struct params* p = (struct params*)(arg);

        int row = p->row;

        char txt[4];

        p->count=0;

        while(p->count < p->cycles)

        {

                switch(ani)

                {

                case 0:

                        ani=1;  sprintf(c,"%s", "\\");

                        break;

                case 1:

                        ani=2;  sprintf(c,"/");

                        break;                 

                case 2:

                        ani=0;  sprintf(c,"-");

                        break;                                 

                }              

                puts_xy(12,row,YELLOW, c );

                ++p->count;

                sprintf(txt,"%02d", p->count);

                puts_xy(8,row,YELLOW, txt);    

                task_endcycle();

        }

        cprintf("Task #%d end.\n", p->task_nr);

        if(p->task_nr==4) call_shutdown_task(0);

        return 0;

};

// This is the main user application entry point.

int main_module_entry(void* arg)

{      

        struct dynalink_module_list* dml = (struct dynalink_module_list*)arg;  

        // make char pointer to text data module,..

        char* txt = (char*)(dml->dat[0].start);

        // ... and print out it's data content

        cprintf("%s", txt);    

        keyb_getch(BLOCK);

        clear();       

        SOFT_TASK_MODEL msoft; 

        PID p1,p2,p3,p4;

        int yrow = 1;

        puts_xy(0,yrow,  7,"Task#1:[  ]");

        puts_xy(0,yrow+1,7,"Task#2:[  ]");

        puts_xy(0,yrow+2,7,"Task#3:[  ]");

        puts_xy(0,yrow+3,7,"Task#4:[  ]");     

        place(0,7);

        // Init shared soft task model

        soft_task_default_model(msoft);

        soft_task_def_met(msoft,10000);

        soft_task_def_group(msoft, 1);  

        soft_task_def_periodic(msoft);

        soft_task_def_level(msoft, 2);

        int cycles = 4;

        // init Task 1 

        float task_periode = 1.0;       // 1sec 

        int tick = get_tick();          // 1000 usec = 1 ms

        int per = (int)( task_periode *1000.0 * tick);

        struct params pp1;

        pp1.task_nr = 1;

        pp1.row         = yrow;

        pp1.cycles      = cycles;

        soft_task_def_period(msoft, per);                       // set period

        soft_task_def_arg(msoft, (void*)(&pp1) );       // set arguments

        p1 = task_create("save", periodic_task, &msoft, NULL);

        if (p1 == NIL)

        {

          sys_shutdown_message("Can't create task1 ...\n");

          exit(1);

        }

        // init Task 2

        task_periode = task_periode*0.5;        // twice as fast as task1

        tick = get_tick();              // 1000 usec = 1 ms

        per = (int)( task_periode *1000.0 * tick);

        struct params pp2;

        pp2.task_nr     = 2;

        pp2.row         = yrow+1;

        pp2.cycles      = cycles*2;

        soft_task_def_period(msoft, per);

        soft_task_def_arg(msoft, (void*)(&pp2) );

        p2 = task_create("skip", periodic_task, &msoft, NULL);

        if (p2 == NIL)

        {

          sys_shutdown_message("Can't create task2...\n");

          exit(1);

        }

        // init Task 3

        task_periode = task_periode*0.5;        // twice as fast as previous task

        tick = get_tick();              // 1000 usec = 1 ms

        per = (int)( task_periode *1000.0 * tick);

        struct params pp3;

        pp3.task_nr     = 3;

        pp3.row         = yrow+2;

        pp3.cycles      = cycles*4;

        soft_task_def_period(msoft, per);

        soft_task_def_arg(msoft, (void*)(&pp3) );

        p3 = task_create("skip", periodic_task, &msoft, NULL);

        if(p3 == NIL)

        {

          sys_shutdown_message("Can't create task3...\n");

          exit(1);

        }      

        // init Task 4

        task_periode = task_periode*0.5;        // twice as fast as previous task

        tick = get_tick();              // 1000 usec = 1 ms

        per = (int)( task_periode *1000.0 * tick);

        struct params pp4;

        pp4.task_nr     = 4;

        pp4.row         = yrow+3;

        pp4.cycles      = cycles*8;

        soft_task_def_period(msoft, per);

        soft_task_def_arg(msoft, (void*)(&pp4) );

        p4 = task_create("skip", periodic_task, &msoft, NULL);

        if(p4 == NIL)

        {

          sys_shutdown_message("Can't create task4...\n");

          exit(1);

        }

        group_activate(1);

  return 0;

};