Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1667 → Rev 1665

/unsupported/trunk/uiuc/pong/pong.c
220,6 → 220,7
hard_task_def_usemath (m);
pid = task_create("ball", ball, &m, NULL);
if (pid == NIL) {
grx_close();
sys_shutdown_message("Could not create task <ball> errno=%d", errno);
sys_abort(errno);
}
379,6 → 380,13
}
 
///////////////////////////////////////
// called when the system exits
void byebye(void *arg) {
grx_close();
cprintf("Thanks for playing!\n");
}
 
///////////////////////////////////////
int main(int argc, char **argv) {
HARD_TASK_MODEL m;
PID pid;
387,6 → 395,9
TIME seme; // used to init the random seed
PI_mutexattr_t a; // for PI mutex init
 
// Set the closing function
sys_atrunlevel(byebye, NULL, RUNLEVEL_BEFORE_EXIT);
 
// initialize global variables
setglobals();
 
395,6 → 406,15
mutex_init(&draw_mutex, &a);
mutex_init(&list_mutex, &a);
 
// graphic card Initialization
if (grx_init() < 1) {
sys_abort(errno);
}
if (grx_open(640, 480, 8) < 0) {
cprintf("GRX Error\n");
sys_abort(errno);
}
 
// Draw initial screen layout and menu
grx_rect(XMIN-RAD-1, YMIN-RAD-1, XMAX+RAD+1, YMAX+RAD+1, yellow);
grx_text("Scores:", XMIN-RAD-1, 10, magenta, black);
430,6 → 450,7
hard_task_def_usemath (m);
pid = task_create("paddle1", paddle1, &m, NULL);
if (pid == NIL) {
grx_close();
sys_shutdown_message("Could not create task <paddle1> errno=%d", errno);
sys_abort(errno);
}
436,7 → 457,6
 
hard_task_default_model(m);
hard_task_def_ctrl_jet (m);
hard_task_def_level (m,1);
hard_task_def_wcet (m, P_WCET);
hard_task_def_mit (m, P_PER);
hard_task_def_group (m, PGROUP);
443,6 → 463,7
hard_task_def_usemath (m);
pid = task_create("p2ai", p2ai, &m, NULL);
if (pid == NIL) {
grx_close();
sys_shutdown_message("Could not create task <p2ai> errno=%d", errno);
sys_abort(errno);
}
449,7 → 470,6
 
hard_task_default_model(m);
hard_task_def_ctrl_jet (m);
hard_task_def_level (m,1);
hard_task_def_wcet (m, P_WCET);
hard_task_def_mit (m, P_PER);
hard_task_def_group (m, PGROUP);
456,6 → 476,7
hard_task_def_usemath (m);
pid = task_create("paddle2", paddle2, &m, NULL);
if (pid == NIL) {
grx_close();
sys_shutdown_message("Could not create task <paddle2> errno=%d", errno);
sys_abort(errno);
}
469,7 → 490,6
 
hard_task_default_model(m);
hard_task_def_ctrl_jet (m);
hard_task_def_level (m,1);
hard_task_def_wcet (m, BALL_WCET);
hard_task_def_mit (m, BALL_PER);
hard_task_def_group (m, BALLGROUP);
476,6 → 496,7
hard_task_def_usemath (m);
pid = task_create("countmon", countmon, &m, NULL);
if (pid == NIL) {
grx_close();
sys_shutdown_message("Could not create task <countmonitor> errno=%d", errno);
sys_abort(errno);
}
/unsupported/trunk/uiuc/pong/initfile.c
1,92 → 1,68
/*
* Project: S.Ha.R.K.
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors :
* Giacomo Guidi <giacomo@gandalf.sssup.it>
* (see the web pages for full authors list)
*
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*/
//////////////////////////////////////////////////////////////////
// Pong
// Written for CS 324, UIUC
// Spencer Hoke
// James Kim
// Tao Luo
//
// Last Modified: April 29, 2004
//
// System initialization file
//
// This file contains the 2 functions needed to initialize the system.
//
// These functions register the following levels:
//
// an EDF (Earliest Deadline First) level
// a RR (Round Robin) level
// a CBS (Costant Bandwidth Server) level
// a Dummy level
//
// It can accept these task models:
//
// HARD_TASK_MODEL (wcet+mit) at level 0
// SOFT_TASK_MODEL (met, period) at level 1
// NRT_TASK_MODEL at level 2
//
// This file is similar to the configuration of in demos/base
//
// TICK is set to 0 (one-shot timer is used)
 
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
 
#include "kernel/kern.h"
#include "modules/intdrive.h"
#include "modules/edf.h"
#include "modules/hardcbs.h"
#include "modules/cbs.h"
#include "modules/rr.h"
#include "modules/dummy.h"
 
#include "modules/sem.h"
#include "modules/pi.h"
#include "modules/hartport.h"
#include "modules/cabs.h"
#include "modules/pi.h"
 
#include <drivers/shark_linuxc26.h>
#include <drivers/shark_pci26.h>
#include <drivers/shark_input26.h>
#include <drivers/shark_keyb26.h>
#include <drivers/shark_fb26.h>
#include "drivers/keyb.h"
 
#define FRAME_BUFFER_DEVICE 0
 
/*+ sysyem tick in us +*/
// sysyem tick in us
#define TICK 0
 
/*+ RR tick in us +*/
//#define RRTICK 10000
#define RRTICK 2000
 
/*+ Interrupt Server +*/
#define INTDRIVE_Q 1000
#define INTDRIVE_T 10000
#define INTDRIVE_FLAG 0
 
void call_shutdown_task(void *arg);
int device_drivers_init();
int device_drivers_close();
void set_shutdown_task();
TASK shutdown_task_body(void *arg);
 
PID shutdown_task_PID = -1;
 
TIME __kernel_register_levels__(void *arg)
{
struct multiboot_info *mb = (struct multiboot_info *)arg;
 
INTDRIVE_register_level(INTDRIVE_Q,INTDRIVE_T,INTDRIVE_FLAG);
EDF_register_level(EDF_ENABLE_ALL);
HCBS_register_level(HCBS_ENABLE_ALL, 1);
EDF_register_level(EDF_ENABLE_WCET_CHECK);
CBS_register_level(CBS_ENABLE_ALL, 0);
RR_register_level(RRTICK, RR_MAIN_YES, mb);
dummy_register_level();
 
SEM_register_module();
SEM_register_module(); // needed for keyboard
CABS_register_module();
PI_register_module();
 
CABS_register_module();
 
return TICK;
}
 
94,108 → 70,16
{
struct multiboot_info *mb = (struct multiboot_info *)arg;
 
KEYB_PARMS kparms = BASE_KEYB;
 
HARTPORT_init();
 
/* Create the shutdown task. It will be activated at RUNLEVEL
SHUTDOWN */
set_shutdown_task();
keyb_def_ctrlC(kparms, NULL);
keyb_def_map(kparms,itaMap);
KEYB_init(&kparms);
 
/* Init the drivers */
device_drivers_init();
 
/* Set the shutdown task activation */
sys_atrunlevel(call_shutdown_task, NULL, RUNLEVEL_SHUTDOWN);
 
__call_main__(mb);
 
return (void *)0;
}
 
void set_shutdown_task() {
 
/* WARNING: the shutdown task is a background thread. It cannot execute
if the system is overloaded */
NRT_TASK_MODEL nrt;
 
nrt_task_default_model(nrt);
nrt_task_def_system(nrt);
 
shutdown_task_PID = task_create("Shutdown Task",shutdown_task_body,&nrt,NULL);
if (shutdown_task_PID == NIL) {
sys_shutdown_message("Error: Cannot create shutdown task\n");
sys_end();
}
 
}
 
int device_drivers_init() {
 
int res;
KEYB_PARMS kparms = BASE_KEYB;
LINUXC26_register_module();
 
PCI26_init();
 
INPUT26_init();
 
keyb_def_ctrlC(kparms, NULL);
 
KEYB26_init(&kparms);
 
FB26_init();
res = FB26_open(FRAME_BUFFER_DEVICE);
if (res) {
cprintf("Error: Cannot open graphical mode\n");
KEYB26_close();
INPUT26_close();
sys_end();
}
FB26_use_grx(FRAME_BUFFER_DEVICE);
FB26_setmode(FRAME_BUFFER_DEVICE,"640x480-16");
return 0;
 
}
 
int device_drivers_close() {
FB26_close(FRAME_BUFFER_DEVICE);
KEYB26_close();
INPUT26_close();
return 0;
}
 
#define SHUTDOWN_TIMEOUT_SEC 3
 
void call_shutdown_task(void *arg)
{
struct timespec t;
 
sys_gettime(&t);
t.tv_sec += SHUTDOWN_TIMEOUT_SEC;
 
/* Emergency timeout to exit from RUNLEVEL_SHUTDOWN */
kern_event_post(&t,(void *)((void *)sys_abort_shutdown),(void *)0);
 
task_activate(shutdown_task_PID);
}
 
TASK shutdown_task_body(void *arg) {
 
device_drivers_close();
 
sys_shutdown_message("-- S.Ha.R.K. Closed --\n");
 
sys_abort_shutdown(0);
 
return NULL;
 
}
/unsupported/trunk/uiuc/pong/jetctrl.c
154,7 → 154,7
PID p3, p4, p5;
 
soft_task_default_model(m3);
soft_task_def_level(m3,2);
soft_task_def_level(m3,1);
soft_task_def_period(m3, PERIOD_JETCTRL);
soft_task_def_met(m3, WCET_JETCTRL);
soft_task_def_ctrl_jet(m3);
161,12 → 161,13
soft_task_def_group(m3, JET_GROUP);
p3 = task_create("jctrl", jetctrl_task, &m3, NULL);
if (p3 == -1) {
grx_close();
sys_shutdown_message("Could not create task <jetcontrol> errno=%d", errno);
sys_end();
}
 
soft_task_default_model(m4);
soft_task_def_level(m4,2);
soft_task_def_level(m4,1);
soft_task_def_period(m4, PERIOD_JETDUMMY);
soft_task_def_met(m4, WCET_JETDUMMY);
soft_task_def_group(m4, JET_GROUP);
174,12 → 175,13
soft_task_def_ctrl_jet(m4);
p4 = task_create("jdmy", jetdummy_task, &m4, NULL);
if (p4 == -1) {
grx_close();
sys_shutdown_message("Could not create task <jetdummy> errno=%d", errno);
sys_end();
}
 
soft_task_default_model(m5);
soft_task_def_level(m5,2);
soft_task_def_level(m5,1);
soft_task_def_period(m5, PERIOD_JETSLIDE);
soft_task_def_met(m5, WCET_JETSLIDE);
soft_task_def_group(m5, JET_GROUP);
187,6 → 189,7
soft_task_def_ctrl_jet(m5);
p5 = task_create("jsli", jetslide_task, &m5, NULL);
if (p5 == -1) {
grx_close();
sys_shutdown_message("Could not create task <jetslide> errno=%d", errno);
sys_end();
}
/unsupported/trunk/uiuc/pong/pong.h
17,8 → 17,8
#include <kernel/func.h>
#include <kernel/types.h>
#include <kernel/descr.h>
#include <drivers/shark_fb26.h>
#include <drivers/shark_keyb26.h>
#include <drivers/glib.h>
#include <drivers/keyb.h>
#include <modules/pi.h>
#include <stdlib.h>
#include <ll/ll.h>
49,24 → 49,22
#define JET_SLIDE_WIDTH 120
#define JET_SLIDE_X 510
 
#define black vga16color[0] // some colors for 8-bit graphics
#define green vga16color[2]
#define ltblue vga16color[3]
#define red vga16color[4]
#define purple vga16color[5]
#define orange vga16color[6]
#define gray vga16color[7]
#define dkgray vga16color[8]
#define blue vga16color[9]
#define lime vga16color[10]
#define bluegreen vga16color[11]
#define redorange vga16color[12]
#define magenta vga16color[13]
#define yellow vga16color[14]
#define white vga16color[15]
#define black 0 // some colors for 8-bit graphics
#define green 2
#define ltblue 3
#define red 4
#define purple 5
#define orange 6
#define gray 7
#define dkgray 8
#define blue 9
#define lime 10
#define bluegreen 11
#define redorange 12
#define magenta 13
#define yellow 14
#define white 15
 
extern int vga16color[16];
 
void init_jetcontrol(); // init functions for jetcontrol
void scenario_jetcontrol();
 
98,6 → 96,8
#define BALL_PER 40000 // task period
#define BALL_WCET 750 // task wcet
 
#define ESC 27 // ASCII code of ESCAPE key
 
int p_speed; // # pixels to move each keypress
#define P_THICKNESS 3 // pixel thickness of paddles
#define P_DLENGTH 5 // delta length for paddles
/unsupported/trunk/uiuc/pong/makefile
1,5 → 1,5
ifndef BASE
BASE=../../..
BASE=../..
endif
include $(BASE)/config/config.mk
 
8,5 → 8,5
include $(BASE)/config/example.mk
 
pong:
make -f $(SUBMAKE) APP=pong BASE=$(BASE) INIT= OTHEROBJS="initfile.o jetctrl.o" OTHERINCL= SHARKOPT="__LINUXC26__ __INPUT__ __PCI__ __FB__ __NET__"
make -f $(SUBMAKE) APP=pong INIT= OTHEROBJS="initfile.o jetctrl.o" OTHERINCL= SHARKOPT="__OLDCHAR__ __GRX__"