/demos/tags/rel_1_21/orbit/initfile.c |
---|
0,0 → 1,124 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@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 |
*/ |
/* |
------------ |
CVS : $Id: initfile.c,v 1.1.1.1 2002-09-02 09:37:45 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1.1.1 $ |
Last update: $Date: 2002-09-02 09:37:45 $ |
------------ |
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 kernel/init/hartik3.c |
TICK is set to 0 (one-shot timer is used) |
*/ |
/* |
* Copyright (C) 2000 Paolo Gai |
* |
* 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/edf.h" |
#include "modules/cbs.h" |
#include "modules/rr.h" |
#include "modules/dummy.h" |
#include "modules/sem.h" |
#include "modules/hartport.h" |
#include "modules/cabs.h" |
#include "drivers/keyb.h" |
/*+ sysyem tick in us +*/ |
#define TICK 0 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
void read_file(); |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
EDF_register_level(0); |
CBS_register_level(0, 0); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
dummy_register_level(); |
SEM_register_module(); |
CABS_register_module(); |
read_file(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
KEYB_PARMS kparms = BASE_KEYB; |
HARTPORT_init(); |
keyb_def_ctrlC(kparms, NULL); |
keyb_def_map(kparms,itaMap); |
KEYB_init(&kparms); |
__call_main__(mb); |
return (void *)0; |
} |
/demos/tags/rel_1_21/orbit/orbit.dat |
---|
0,0 → 1,21 |
---------------------------------------------------- |
period: 10000 wcet: 100 |
delta: 1. scala: 150. |
G: 6.6e-15 |
r_pianeta: 4 r_Terra: 8 |
X_centro: 320 Y_centro: 240 |
------------------- pianeti ------------------------ |
massa pos.x pos.y vel.x vel.y |
0: 6.0e21 0. 0. 0. 0. |
1: 1.0e21 10000. 8000. -60. 0. |
2: 1.0e8 5000. 0. 0. 80. |
3: 5.0e18 10000. 8000. -50. 0. |
4: 1.0e9 10000. 8000. -40. 20. |
5: 1.0e15 1000. 5000. -80. 0. |
6: 1.0e5 1000. 5000. -80. 0. |
7: 1.0e17 1000. 5000. -80. 0. |
8: 1.0e5 1000. 5000. -80. 0. |
9: 1.0e5 1000. 5000. -80. 0. |
10: 1.0e5 1000. 5000. -80. 0. |
---------------------------------------------------- |
/demos/tags/rel_1_21/orbit/orbit.c |
---|
0,0 → 1,341 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@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 |
*/ |
/* |
------------ |
CVS : $Id: orbit.c,v 1.4 2003-05-01 19:44:07 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.4 $ |
Last update: $Date: 2003-05-01 19:44:07 $ |
------------ |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo and Paolo Gai |
* |
* 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 |
* |
*/ |
/****************************************************************/ |
/* SIMULAZIONE DI MASSE CHE ORBITANO */ |
/****************************************************************/ |
#include <kernel/kern.h> |
#include <drivers/glib.h> |
#include <drivers/keyb.h> |
#include <semaphore.h> |
#include <stdlib.h> |
#include <math.h> |
#define MAX 11 /* numero massimo pianeti */ |
#define ESC 27 /* codice ASCII tasto ESCAPE */ |
#define XMAX 639 /* valore massimo coordinata X */ |
#define YMAX 479 /* valore massimo coordinata Y */ |
struct coord { |
double x; |
double y; |
}; |
char fbuf[1000]; // buffer for reading a file |
int flen; // file length |
double mass[MAX]; /* vettore masse pianeti */ |
struct coord pos[MAX]; /* vettore posizioni attuali */ |
struct coord vel[MAX]; /* vettore velocita' iniziali */ |
int XGS, YGS; /* Coordinate centro spazio */ |
int RP, RT; /* raggio pianeta, raggio Terra */ |
int np; /* numero attuale di pianeti */ |
double G; /* Gravitazione Universale */ |
double tick; /* tick di sistema */ |
double delta; /* incremento temporale */ |
double scala; /* fattore grafico di scala */ |
// ------------------------------------------------------- |
// NOTA: %f o %lf significa double e %nf significa float |
// ------------------------------------------------------- |
PID pid; |
int period; /* task period */ |
int wcet; /* task wcet */ |
sem_t mutex; /* semaforo di mutua esclusione */ |
void get_par(void); |
/*--------------------------------------------------------------*/ |
void my_fine(void *arg) |
{ |
grx_close(); |
} |
/*--------------------------------------------------------------*/ |
int inside(int x, int y) |
{ |
return ((x > RP) && (x < XMAX-RP) && |
(y > RP) && (y < YMAX-RP)); |
} |
/*--------------------------------------------------------------*/ |
TASK massa(void *xxx) |
{ |
int i = (int)xxx; /* parametro del task */ |
int gx, gy; /* coordinate grafiche pallina */ |
int ox, oy; /* vecchia posizione pallina */ |
int j; |
int r, col; /* raggio e colore pianeta */ |
double dt; /* incremento temporale */ |
double dist=0.0, dx, dy; /* distanze pianeta-pianeta */ |
double dist0=0.0; /* distanze pianeta-Terra */ |
double x, y; /* posizione del pianeta */ |
double vx, vy; /* velocita' del pianeta */ |
double ax, ay; /* accelerazione del pianeta */ |
double k; /* variabile ausiliaria */ |
double arg; /* variabile di appoggio */ |
x = pos[i].x; y = pos[i].y; |
vx = vel[i].x; vy = vel[i].y; |
ox = XGS + x / scala; |
oy = YGS + y / scala; |
dt = delta; |
do { |
x = pos[i].x; |
y = pos[i].y; |
ax = ay = 0.0; |
for (j=0; j<np; j++) { |
if (j != i) { |
dx = pos[j].x - x; |
dy = pos[j].y - y; |
arg = dx*dx + dy*dy; |
dist = sqrt(arg); |
if (dist < RP*scala) dist = RP*scala; |
k = G * mass[j] / (dist*dist*dist); |
ax += k * dx; |
ay += k * dy; |
} |
if (j == 0) dist0 = dist - (RP+RT)*scala; |
} |
x += vx*dt + 0.5*ax*dt*dt; |
y += vy*dt + 0.5*ay*dt*dt; |
vx += ax * dt; |
vy += ay * dt; |
gx = XGS + x / scala; |
gy = YGS + y / scala; |
r = RP; |
col = i + 1; |
sem_wait(&mutex); |
grx_disc(ox,oy,r,0); |
grx_disc(gx,gy,r,col); |
sem_post(&mutex); |
pos[i].x = x; pos[i].y = y; |
ox = gx; oy = gy; |
task_endcycle(); |
} while ((dist0 > 0) && inside(gx,gy)); |
sem_wait(&mutex); |
grx_disc(ox,oy,r,0); |
grx_disc(XGS,YGS,RT,12); |
grx_circle(XGS,YGS,RT,14); |
sem_post(&mutex); |
return NULL; |
} |
/*--------------------------------------------------------------*/ |
/* MAIN */ |
/*--------------------------------------------------------------*/ |
int main() |
{ |
HARD_TASK_MODEL m; |
char c; /* carattere letto da tastiera */ |
sys_atrunlevel(my_fine, NULL, RUNLEVEL_BEFORE_EXIT); |
sem_init(&mutex,0,1); |
get_par(); |
keyb_getch(BLOCK); |
grx_init(); |
grx_open(640, 480, 8); |
grx_disc(XGS,YGS,RT,12); |
grx_circle(XGS,YGS,RT,14); |
np = 0; |
do { |
if (np < MAX-1) { |
np++; |
hard_task_default_model(m); |
hard_task_def_arg (m, (void *)np); |
hard_task_def_wcet (m, wcet); |
hard_task_def_mit (m, period); |
hard_task_def_usemath (m); |
pid = task_create("massa", massa, &m, NULL); |
if (pid == NIL) { |
sys_shutdown_message("Could not create task"); |
sys_end(); |
} |
task_activate(pid); |
} |
c = keyb_getch(BLOCK); |
} while (c != ESC); |
sys_end(); |
return 0; |
} |
/*------------------------------------------------------*/ |
/* file reading */ |
/*------------------------------------------------------*/ |
void read_file(void) |
{ |
int err; |
DOS_FILE *fp; |
fp = DOS_fopen("orbit.dat","r"); |
if (!fp) { |
err = DOS_error(); |
cprintf("Error %d opening myfile.txt...\n", err); |
flen = 0; |
return; |
} |
flen = DOS_fread(&fbuf, 1, 1000, fp); |
cprintf("Read %d bytes from orbit.dat\n", flen); |
DOS_fclose(fp); |
} |
/*------------------------------------------------------*/ |
/* get data from buffer */ |
/*------------------------------------------------------*/ |
void get_par(void) |
{ |
int x = 0; |
int i; |
double vx, vy; |
while ((fbuf[x] != ':') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%d", &period); |
cprintf("period = %d\n", period); |
while ((fbuf[x] != ':') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%d", &wcet); |
cprintf("wcet = %d\n", wcet); |
while ((fbuf[x] != ':') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%f", &delta); |
cprintf("delta = %f\n", delta); |
while ((fbuf[x] != ':') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%f", &scala); |
cprintf("scala = %f\n", scala); |
while ((fbuf[x] != ':') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%f", &G); |
cprintf("G = %20.15f\n", G); |
while ((fbuf[x] != ':') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%d", &RP); |
cprintf("RP = %d\n", RP); |
while ((fbuf[x] != ':') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%d", &RT); |
cprintf("RT = %d\n", RT); |
while ((fbuf[x] != ':') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%d", &XGS); |
cprintf("XGS = %d\n", XGS); |
while ((fbuf[x] != ':') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%d", &YGS); |
cprintf("YGS = %d\n", YGS); |
for (i=0; i<MAX; i++) { |
while ((fbuf[x] != ':') && (x < flen)) x++; |
x++; x++; |
sscanf(&fbuf[x], "%f", &mass[i]); |
while ((fbuf[x] != '\t') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%f", &vx); |
while ((fbuf[x] != '\t') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%f", &vy); |
pos[i].x = vx; pos[i].y = vy; |
while ((fbuf[x] != '\t') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%f", &vx); |
while ((fbuf[x] != '\t') && (x < flen)) x++; |
x++; |
sscanf(&fbuf[x], "%f", &vy); |
vel[i].x = vx; vel[i].y = vy; |
cprintf("mass[%d] = %f\t", i, mass[i]); |
cprintf("pos: %f, %f\t", pos[i].x, pos[i].y); |
cprintf("vel: %f, %f\n", vel[i].x, vel[i].y); |
} |
} |
/*--------------------------------------------------------------*/ |
/demos/tags/rel_1_21/orbit/makefile |
---|
0,0 → 1,16 |
# |
# |
# |
ifndef BASE |
BASE=../.. |
endif |
include $(BASE)/config/config.mk |
PROGS= orbit |
include $(BASE)/config/example.mk |
orbit: |
make -f $(SUBMAKE) APP=orbit INIT= OTHEROBJS="initfile.o" OTHERINCL= SHARKOPT="__OLDCHAR__ __GRX__" |
/demos/tags/rel_1_21/simcity/keyboard.c |
---|
0,0 → 1,49 |
/* ------------------ */ |
/* Keyboard handler */ |
/* ------------------ */ |
#include <drivers/keyb.h> |
#include "include/keyfunct.h" |
void keyb_h() { |
KEY_EVT k; |
keyb_set_map(itaMap); |
/* Exit keys: ALT-X, ENTER */ |
k.flag = ALTL_BIT; |
k.scan = KEY_X; |
k.ascii = 'x'; |
keyb_hook(k, endfun); |
k.flag = ALTR_BIT; |
k.scan = KEY_X; |
k.ascii = 'x'; |
keyb_hook(k, endfun); |
k.flag = 0; |
k.scan = KEY_ENT; |
k.ascii = 13; |
keyb_hook(k, endfun); |
/* Create HARD cars */ |
k.flag = 0; |
k.scan = KEY_C; |
k.ascii = 'c'; |
keyb_hook(k, h_car_create); |
/* kill hard cars*/ |
k.flag = 0; |
k.scan = KEY_K; |
k.ascii = 'k'; |
keyb_hook(k, h_car_kill); |
//refresh map |
k.flag=0; |
k.scan = KEY_R; |
k.ascii = 'r'; |
keyb_hook(k, refresh); |
//create soft cars |
k.flag=0; |
k.scan = KEY_S; |
k.ascii = 's'; |
keyb_hook(k, s_car_create); |
//toggle sensors |
k.flag=0; |
k.scan = KEY_D; |
k.ascii = 'd'; |
keyb_hook(k, sensor_switch); |
} |
/demos/tags/rel_1_21/simcity/include/simcity.h |
---|
0,0 → 1,77 |
/********************************simcity.h***************************/ |
// global variables and tasks bodies declaration |
#include <kernel/func.h> |
#include <semaphore.h> |
#ifndef CST |
#include "constant.h" |
#endif |
/*Global stuff*/ |
extern car_data car_data_array[MAX_CAR]; |
extern tl_data tl_data_array[MAX_TL]; |
//car starting points |
extern starting_set starting_set_array[S_POINT]; |
// PID vectors |
extern PID p_table[MAX_CAR]; |
extern PID c_table[MAX_CAR]; |
extern PID g_table[MAX_CAR]; |
extern PID a_table[MAX_CAR]; |
extern char kill_flag[MAX_CAR]; |
//graphic mutex |
extern sem_t mutex; |
//kill_flag mutexes |
extern sem_t kill_mutex[MAX_CAR]; |
//various sprites |
extern DWORD macchine[ROW][COL][NCAR]; |
extern DWORD strada[H][W]; |
extern BYTE street[H*W*2]; |
extern BYTE vbuf[MAX_CAR][ROW*COL*2]; |
extern BYTE clrcam[(ROW+2)*(COL+2)*2]; |
extern BYTE gauge_img[ROW*COL*2]; |
extern BYTE brk_gauge[ROW*COL*2]; |
extern BYTE arrow[3][ROW*COL*2]; |
extern DWORD sprites[ROW][COL][NO_SPRITE]; |
extern BYTE clrscr[800*600*2]; |
extern DWORD faces[2][74][47]; |
extern char sens; |
//sine & cosine look-up tables |
extern float cosine[360],sine[360]; |
//traffic light sprites |
extern DWORD y_sem[4][SH][SW]; |
extern DWORD r_sem[4][SH][SW]; |
extern DWORD g_sem[4][SH][SW]; |
//useful colors |
extern DWORD white; |
extern DWORD black; |
extern DWORD red; |
extern DWORD gray; |
extern DWORD blue; |
extern DWORD green; |
extern DWORD border; |
extern DWORD tl_bg; |
//task chain pointers |
extern car_data *free_n,*busy_n,*free_o,*busy_o; |
// car counter |
extern short maxc; |
/*function declaration */ |
/* task bodies*/ |
TASK car(car_data *); |
TASK traffic_light(tl_data *); |
TASK camera(int); |
TASK gauge_c(int); |
TASK blink_arrow(int); |
TASK refresher(void *); |
TASK killer(void *); |
/demos/tags/rel_1_21/simcity/include/keyfunct.h |
---|
0,0 → 1,10 |
/*******************************keyfunct.h****************************/ |
// keyboard handler functions |
#include <drivers/keyb.h> |
void h_car_create(KEY_EVT *); |
void s_car_create(KEY_EVT *); |
void h_car_kill(KEY_EVT *); |
void endfun(KEY_EVT *); |
void refresh(KEY_EVT *); |
void sensor_switch(KEY_EVT *); |
/demos/tags/rel_1_21/simcity/include/constant.h |
---|
0,0 → 1,99 |
/*************************const.h*******************************/ |
// constants and new types declaration |
#include <kernel/func.h> |
#define CST |
#define NO_SPRITE 8 |
#define GRAPH |
#define SENSOR |
#define MAX_CAR 10 |
#define MAX_TL 3 |
#define S_POINT 4 |
#define PERIOD_CAR 135000 //period for K62 350MHZ |
//#define PERIOD_CAR 87000 //period for PIII 733MHZ |
#define SPERIOD_CAR 13000 |
#define SCAR_WCET 4300 |
#define SECOND 1000000 |
#define TL_WCET 200 |
#define CAM_WCET 200 |
#define GAUGE_WCET 200 |
#define ARROW_WCET 100 |
//#define CAR_WCET 7700 //wcet for PIII 733MHZ |
#define CAR_WCET 12400 //wcet for K62 350MHZ |
#define ROW 30 |
#define COL 30 |
#define NCAR 24 |
#define W 640 |
#define H 480 |
#define SH 12 |
#define SW 12 |
#define MAX_DIST 50.0 |
#define NORM_DIST 15.0 |
#define COLL_DIST 25.0 |
#define MIN_SPEED 0.0 |
#define NORM_SPEED 4.0 |
#define MAX_SPEED 6.0 |
#define MAX_LOOK 50 |
#define LOOK_ANGLE 70 |
#define DIST_ANGLE 90 |
#define CORR_FACT 0.7 |
#define FRANTIC 0.0 |
#define POS_RAND |
#define OBL_START 1 |
#define DEG_TO_RAD(x) ((float)x)/180.0*3.14 |
#define RAD_TO_DEG(x) ((float)x)/3.14*180.0 |
#define RANDDIR (rand()%3-1) |
#define L 0 |
#define R 1 |
#define U 2 |
#define D 3 |
#define DRAW 1 |
#define CANCEL 0 |
#define VERTICAL 1 |
#define HORIZONTAL 0 |
#define STEER_LEFT 1 |
#define STEER_RIGHT -1 |
#define STRAIGHT 0 |
#define CAMX 670 |
#define CAMY 120 |
#define MAPX 8 |
#define MAPY 113 |
#define FREE 0 |
#define STOP 1 |
#define CAR 2 |
/*data types*/ |
typedef struct car_d { |
int number; |
float xpos,ypos; |
int xp,yp; |
float dist_obs,dist_sem; |
float speed,middle,front,rear,somma; |
int angle,sat; |
char collision,boom,correggi,incrocio; |
char dir,running; |
struct car_d *next; |
} car_data; |
typedef struct { |
int x,y; |
} point; |
typedef struct { |
char vpos,hpos,tl_name[8]; |
point l,r,u,d; |
PID pid; |
DWORD period; |
} tl_data; |
typedef struct { |
int xpos,ypos,angles; |
} starting_set; |
/demos/tags/rel_1_21/simcity/include/misc.h |
---|
0,0 → 1,18 |
//*****************************misc.h************************************ |
// miscellaneous useful functions |
#ifndef CST |
#include "constant.h" |
#endif |
int my_rint(float); |
void fill_table(); |
void tl_init(); |
void set_start_point(); |
int returnCarIndex(int); |
int find_col(int,int); |
int find_tl(int,int,int); |
int allinea(int); |
int module(int,int,int,int); |
int normalize(int); |
/demos/tags/rel_1_21/simcity/include/draw.h |
---|
0,0 → 1,14 |
//****************************draw.h******************************* |
// drawing functions |
#ifndef CST |
#include "constant.h" |
#endif |
void drawSprites(int,int,char,char); |
void drawStreet(int,int); |
void get_images(); |
void drawCar(int,int,int,char); |
void bold_rect(WORD,WORD,WORD,WORD,BYTE,BYTE,BYTE); |
void draw_scenario(); |
void draw_tl(int x,int y,DWORD img[SH][SW]); |
void drawFaces(int,int,short); |
/demos/tags/rel_1_21/simcity/include/states.h |
---|
0,0 → 1,21 |
enum stati { |
NORM, |
INC1, |
DX1, |
STR1, |
STR2, |
SX1, |
SX2, |
SX3 |
} ; |
enum sprite_type { |
EXPL, |
GAUGE, |
ARR_OFF, |
ARR_SX, |
ARR_DX, |
VECCHINA, |
V_SPLAT, |
GAUGE_ROTTO |
}; |
/demos/tags/rel_1_21/simcity/include/proc.h |
---|
0,0 → 1,23 |
//***************************proc.h****************************** |
// task management functions |
#ifndef CST |
#include "constant.h" |
#endif |
int add(); |
void del(int); |
void init_struct(); |
int del_o(); |
void gauge_create(char *,int); |
void arrow_create(char *,int); |
void killer_create(); |
void ref_create(); |
void cam_create(char *,int); |
void stl_create(char *,int); |
void h_create(char *,int); |
void s_create(char *,int); |
void killing(int); |
/demos/tags/rel_1_21/simcity/include/car.h |
---|
0,0 → 1,10 |
//*****************************car.h******************************** |
// car management functions |
#ifndef CST |
#include "constant.h" |
#endif |
char collision_sensor(car_data *); |
int sensore(car_data *); |
void ch_spd(car_data *,char); |
/demos/tags/rel_1_21/simcity/initfile.c |
---|
0,0 → 1,106 |
//****************************initfile.c******************************* |
#define PI |
#include "kernel/kern.h" |
#include "modules/edf.h" |
#include "modules/cbs.h" |
#include "modules/rr.h" |
#ifndef PI |
#include "modules/rrsoft.h" |
#endif |
#include "modules/dummy.h" |
#include "modules/sem.h" |
#include "modules/hartport.h" |
#include "modules/cabs.h" |
#include "modules/pi.h" |
#include "modules/pc.h" |
#include "modules/srp.h" |
#include "modules/npp.h" |
#include "modules/nop.h" |
#include <drivers/keyb.h> |
//#include "ll/i386/x-dos.h" |
/*+ sysyem tick in us +*/ |
#define TICK 0 |
/*+ RR tick in us +*/ |
//#define RRTICK 10000 |
#define RRTICK 2000 |
void getCars(void); |
void getRoad(void); |
void getSem(void); |
void getSprites(void); |
void getFaces(void); |
void tl_pos(); |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
EDF_register_level(EDF_ENABLE_ALL); |
CBS_register_level(CBS_ENABLE_ALL, 0); |
// RRSOFT_register_level(RRTICK, RR_MAIN_NO, mb, RRSOFT_ONLY_HARD|RRSOFT_ONLY_SOFT); |
// RRSOFT_register_level(RRTICK, RR_MAIN_NO, mb, RRSOFT_ONLY_SOFT); //cbs |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
dummy_register_level(); |
SEM_register_module(); |
CABS_register_module(); |
PI_register_module(); |
NOP_register_module(); |
getFaces(); |
getCars(); |
getRoad(); |
getSem(); |
getSprites(); |
tl_pos(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
HARTPORT_init(); |
KEYB_init(NULL); |
__call_main__(mb); |
return (void *)0; |
} |
#ifdef PI |
void app_mutex_init(mutex_t *m) |
{ |
PI_mutexattr_t attr; |
PI_mutexattr_default(attr); |
mutex_init(m, &attr); |
} |
#else |
void app_mutex_init(mutex_t *m) |
{ |
NOP_mutexattr_t attr; |
NOP_mutexattr_default(attr); |
mutex_init(m, &attr); |
} |
#endif |
/demos/tags/rel_1_21/simcity/car.c |
---|
0,0 → 1,175 |
#include <drivers/glib.h> |
#include <stdlib.h> |
#include <math.h> |
#include "include/simcity.h" |
#include "include/misc.h" |
#include "include/car.h" |
#include "include/draw.h" |
char collision_sensor(car_data *cd) { |
float i,dx,dx1,dy,dy1,deltax,deltay; |
int colore,colore1; |
int speed_done=0; |
char col=FREE; |
dx=cd->xpos+2.0*cosine[normalize(cd->angle+90)]; |
dy=cd->ypos-2.0*sine[normalize(cd->angle+90)]; |
dx1=cd->xpos-8.0*cosine[normalize(cd->angle+90)]; |
dy1=cd->ypos+8.0*sine[normalize(cd->angle+90)]; |
for (i=0.0;i<MAX_LOOK;i+=0.1) { |
deltax=i*cosine[normalize(cd->angle)]; |
deltay=i*sine[normalize(cd->angle)]; |
sem_wait(&mutex); |
colore=grx_getpixel(my_rint(dx+deltax),my_rint(dy-deltay)); |
colore1=grx_getpixel(my_rint(dx1+deltax),my_rint(dy1-deltay)); |
sem_post(&mutex); |
if (((colore==white)||(colore1==white) || ((colore==red)||(colore1==red)))) { |
if((colore==white)||(colore1==white)) |
col=STOP; |
else |
col=CAR; |
cd->dist_obs=i; |
cd->collision=1; |
speed_done=1; |
} |
if (!speed_done) { |
if (sens) { |
sem_wait(&mutex); |
grx_plot(my_rint(dx+deltax),my_rint(dy-deltay),gray); |
grx_plot(my_rint(dx1+deltax),my_rint(dy1-deltay),gray); |
sem_post(&mutex); |
} |
} |
} |
if (!speed_done) { |
cd->collision=0; |
cd->dist_obs=MAX_LOOK; |
} |
return col; |
} |
int sensore(car_data *cd) { |
int col_front,col_rear,col_middle; |
int done_front=0,done_rear=0,done_middle=0; |
float front,rear,middle,store_middle; |
int angolo; |
float i; |
float x1,y1,x05,y05; |
float xs,ys,xs1,ys1; |
float coordx,coordy,distx,disty; |
cd->front=cd->rear=cd->middle=front=rear=middle=store_middle=NORM_DIST; |
x1=cd->xpos-10.0*cosine[normalize(cd->angle)]; // coordinata sensore dietro |
y1=cd->ypos+10.0*sine[normalize(cd->angle)]; |
x05=cd->xpos-5.0*cosine[normalize(cd->angle)]; // coordinata sensore mezzo |
y05=cd->ypos+5.0*sine[normalize(cd->angle)]; |
for (i=0.0;i<MAX_DIST;i+=0.1) { |
coordx=i*cosine[normalize(cd->angle-LOOK_ANGLE)]; |
coordy=i*sine[normalize(cd->angle-LOOK_ANGLE)]; |
distx=i*cosine[normalize(cd->angle-DIST_ANGLE)]; |
disty=i*sine[normalize(cd->angle-DIST_ANGLE)]; |
col_front=grx_getpixel(my_rint(cd->xpos+coordx),my_rint(cd->ypos-coordy)); |
col_rear=grx_getpixel(my_rint(x1+coordx),my_rint(y1-coordy)); |
col_middle=grx_getpixel(my_rint(x05+distx),my_rint(y05-disty)); |
if ((col_front==border) && !done_front) { |
done_front=1; |
cd->front=front=i; |
} |
if ((col_middle==border) && !done_middle) { |
done_middle=1; |
middle=cd->middle=i; |
} |
if ((col_rear==border) && !done_rear) { |
done_rear=1; |
cd->rear=rear=i; |
} |
if (sens) { |
sem_wait(&mutex); |
if (!done_front) { |
grx_plot(my_rint(cd->xpos+coordx),my_rint(cd->ypos-coordy),gray); |
} |
if (!done_rear) { |
grx_plot(my_rint(x1+coordx),my_rint(y1-coordy),blue); |
} |
if (!done_middle) { |
grx_plot(my_rint(x05+distx),my_rint(y05-disty),green); |
} |
sem_post(&mutex); |
} |
} |
if (!done_front) { |
front=cd->front=MAX_DIST; |
} |
if (!done_rear) { |
rear=cd->rear=MAX_DIST; |
} |
if (!done_middle) { |
cd->middle=middle=MAX_DIST; |
} |
xs=cd->xpos+front*cosine[normalize(cd->angle-LOOK_ANGLE)]; |
xs1=x1+rear*cosine[normalize(cd->angle-LOOK_ANGLE)]; |
ys=cd->ypos-front*sine[normalize(cd->angle-LOOK_ANGLE)]; |
ys1=y1-rear*sine[normalize(cd->angle-LOOK_ANGLE)]; |
if (xs==xs1) { |
angolo=90; |
} else { |
angolo=my_rint(RAD_TO_DEG(atan((-ys1+ys)/(xs1-xs)))); |
} |
if (angolo<0) angolo+=360; |
if (angolo>=360) angolo-=360; |
if ((ys-ys1<0) && (xs1-xs>0)) { |
angolo-=180; |
} |
if ((ys-ys1>=0) && (xs1-xs>0)) { |
angolo+=180; |
} |
if ((xs1-xs==0) && (ys-ys1>0)) { |
angolo=270; |
} |
if (abs(middle-NORM_DIST)>FRANTIC) { |
cd->correggi=1; |
} else { |
cd->somma=0; |
cd->correggi=0; |
} |
if (cd->correggi) { |
if (middle>NORM_DIST) { |
cd->somma-=CORR_FACT; |
} |
if (middle<NORM_DIST) { |
cd->somma+=CORR_FACT; |
} |
} |
angolo+=cd->somma; |
return angolo; |
} |
void ch_spd(car_data *cd,char ob_type) { |
float set_spd=0.0; |
float bf; |
if(cd->collision) { |
if(ob_type==STOP) |
bf=0.001; |
else |
bf=0.7; |
set_spd=cd->speed-(MAX_LOOK-cd->dist_obs)*bf; |
if(set_spd<0) |
set_spd=0; |
} |
else { |
set_spd=cd->speed+0.4; |
if(set_spd>MAX_SPEED) |
set_spd=MAX_SPEED; |
} |
cd->speed=set_spd; |
} |
/demos/tags/rel_1_21/simcity/simcity.c |
---|
0,0 → 1,154 |
/************************** Simcity ************************/ |
// Main,initialization functions and global variables allocation |
#include <kernel/func.h> |
#include <string.h> |
#include <stdlib.h> |
#include <drivers/keyb.h> |
#include <drivers/glib.h> |
#include <kernel/kern.h> |
#include <semaphore.h> |
#include <math.h> |
#include "include/constant.h" |
#include "include/misc.h" |
#include "include/draw.h" |
#include "include/proc.h" |
#define rgb rgb16 |
/* graphic mutex... */ |
sem_t mutex; |
//kill flag mutexes |
sem_t kill_mutex[MAX_CAR]; |
// various sprites to use with grx_putimage().... |
BYTE vbuf[MAX_CAR][ROW*COL*2]; |
BYTE clrscr[800*600*2]; |
BYTE clrcam[(ROW+2)*(COL+2)*2]; |
BYTE gauge_img[ROW*COL*2]; |
BYTE brk_gauge[ROW*COL*2]; |
BYTE arrow[3][ROW*COL*2]; |
BYTE street[H*W*2]; |
//task chain pointers |
car_data *free_n,*free_o,*busy_n,*busy_o; |
// various sprites to plot |
extern DWORD macchine[ROW][COL][NCAR]; |
extern DWORD sprites[ROW][COL][NO_SPRITE]; |
extern DWORD strada[H][W]; |
//resolution to use |
WORD r=600; |
WORD c=800; |
BYTE bpp=16; |
// useful colors... |
DWORD white; |
DWORD black; |
DWORD red; |
DWORD gray; |
DWORD blue; |
DWORD green; |
DWORD border; |
DWORD tl_bg; |
//PID vectors |
PID p_table[MAX_CAR]; |
PID c_table[MAX_CAR]; |
PID g_table[MAX_CAR]; |
PID a_table[MAX_CAR]; |
char kill_flag[MAX_CAR]; |
float cosine[360],sine[360]; |
// data structures |
car_data car_data_array[MAX_CAR]; |
tl_data tl_data_array[MAX_TL]; |
starting_set starting_set_array[S_POINT]; |
void keyb_h(void); |
static void version( void ) |
{ |
cprintf("\n\nDemo presented by\n"); |
cprintf("Aguzzi Marco\n"); |
cprintf(" &\n"); |
cprintf("Ferrari Fabio\n"); |
} |
void my_close(void *arg) |
{ |
grx_close(); |
kern_printf("Shutting down SIMCITY\n"); |
} |
int main(int argc, char **argv) |
{ |
int i; |
char tl_name[4]; |
version(); |
sys_atrunlevel(my_close, NULL, RUNLEVEL_BEFORE_EXIT); |
//resetting kill flags |
for(i=0;i<MAX_CAR;i++) { |
p_table[i]=0; |
kill_flag[i]=0; |
} |
// graphic mode initialization |
#ifdef GRAPH |
if (grx_init() < 1) { |
kern_printf("Error initializing graphics\n"); |
sys_abort(1); |
} |
if (grx_open(c,r,bpp) < 0) { |
kern_printf("GRX Open Err\n"); |
sys_abort(1); |
} |
get_images(); |
#endif |
srand(sys_gettime(NULL)); |
//init the graphic mutex |
sem_init(&mutex,1,1); |
//init kill flag mutexes |
for(i=0;i<MAX_CAR;i++) sem_init(&(kill_mutex[i]),1,1); |
//fill sine & cosine lookup tables |
fill_table(); |
/*init keys*/ |
keyb_h(); |
set_start_point(); |
tl_init(); |
init_struct(); |
/* useful colors ... */ |
white = rgb(255,255,255); |
black = rgb(0,0,0); |
red = rgb(255,0,0); |
gray = rgb(210,210,210); |
blue = rgb(0,0,220); |
green = rgb(0,255,0); |
border= rgb(128,128,128); |
tl_bg= rgb(0,128,0); |
#ifdef GRAPH |
/* paint scenario*/ |
draw_scenario(); |
#endif |
#ifndef GRAPH |
cprintf("Main: max_tl:%d\n",MAX_TL); |
#endif |
//creating refresher,killer and traffic light processes... |
ref_create(); |
killer_create(); |
for(i=0;i<MAX_TL;i++) { |
sprintf(tl_name,"tl%d",i+1); |
#ifndef GRAPH |
cprintf("main:tname=%s",tl_name); |
#endif |
stl_create(tl_name,i); |
} |
return 0; |
} |
/demos/tags/rel_1_21/simcity/tasks.c |
---|
0,0 → 1,409 |
//*******************************tasks.c************************************ |
// task bodies |
#include <drivers/glib.h> |
#include <stdlib.h> |
#include <string.h> |
#include <kernel/func.h> |
#include <drivers/glib.h> |
#include <semaphore.h> |
#include <math.h> |
#include "include/simcity.h" |
#include "include/states.h" |
#include "include/draw.h" |
#include "include/misc.h" |
#include "include/car.h" |
#include "include/proc.h" |
#define rgb rgb16 |
/*extern starting_set starting_set_array[S_POINT]; |
extern short maxc; */ |
TASK killer(void *arg) { |
short i,j=0; |
DWORD col[3]; |
char flag=0; |
col[0]=red; |
col[1]=green; |
col[2]=white; |
while(1) { |
if(maxc>0) { |
for(i=0;i<MAX_CAR;i++) { |
sem_wait(&(kill_mutex[i])); |
if(car_data_array[i].boom && car_data_array[i].running) flag=1; |
else flag=0; |
sem_post(&(kill_mutex[i])); |
if(flag) { |
del(i); |
killing(i); |
} |
} |
} |
j=(j+1)%3; |
sem_wait(&mutex); |
grx_text("Killer active!",CAMX,CAMY+MAX_CAR*46,col[j],black); |
sem_post(&mutex); |
task_endcycle(); |
} |
} |
TASK refresher(void *arg) { |
int i; |
tl_data *d; |
while(1) { |
sem_wait(&mutex); |
grx_putimage(MAPX,MAPY,MAPX+W-1,MAPY+H-1,street); |
for(i=0;i<MAX_TL;i++) { |
d=&(tl_data_array[i]); |
if((d->vpos=='g')) { |
draw_tl(d->u.x,d->u.y,g_sem[U]); |
draw_tl(d->d.x,d->d.y,g_sem[D]); |
draw_tl(d->l.x,d->l.y,r_sem[L]); |
draw_tl(d->r.x,d->r.y,r_sem[R]); |
} else if(d->vpos=='y') { |
draw_tl(d->u.x,d->u.y,y_sem[U]); |
draw_tl(d->d.x,d->d.y,y_sem[D]); |
draw_tl(d->l.x,d->l.y,r_sem[L]); |
draw_tl(d->r.x,d->r.y,r_sem[R]); |
} else if(d->hpos=='g') { |
draw_tl(d->u.x,d->u.y,r_sem[U]); |
draw_tl(d->d.x,d->d.y,r_sem[D]); |
draw_tl(d->l.x,d->l.y,g_sem[L]); |
draw_tl(d->r.x,d->r.y,g_sem[R]); |
} else if(d->hpos=='y') { |
draw_tl(d->u.x,d->u.y,r_sem[U]); |
draw_tl(d->d.x,d->d.y,r_sem[D]); |
draw_tl(d->l.x,d->l.y,y_sem[L]); |
draw_tl(d->r.x,d->r.y,y_sem[R]); |
} |
} |
sem_post(&mutex); |
task_endcycle(); |
} |
} |
TASK blink_arrow(int number) { |
char ld=0,prev=0,dir=0; |
short c; |
BYTE *arrow_img; |
c=number*46; |
while(1) { |
if(kill_flag[number]) { |
return 0; |
} |
if(!car_data_array[number].boom) { |
dir=car_data_array[number].dir+1; |
if(dir==prev) { |
ld=(ld+1)%2; |
if(ld==1) |
arrow_img=arrow[(int)dir]; |
else |
arrow_img=arrow[1]; |
sem_wait(&mutex); |
grx_putimage(CAMX+80,CAMY-1+c,CAMX+80+29,CAMY-1+c+29,arrow_img); |
sem_post(&mutex); |
} else { |
prev=dir; |
ld=0; |
sem_wait(&mutex); |
grx_putimage(CAMX+80,CAMY-1+c,CAMX+80+29,CAMY-1+c+29,arrow[(int)dir]); |
sem_post(&mutex); |
} |
} |
task_endcycle(); |
} |
} |
TASK gauge_c(int number) { |
int c; |
float angle,ro; |
int x,y; |
char vel[5]; |
c=number*46; |
while(1) { |
if(kill_flag[number]) { |
return 0; |
} |
if(!car_data_array[number].boom) { |
angle=180.0*car_data_array[number].speed/MAX_SPEED; |
sprintf(vel,"%.1f",car_data_array[number].speed); |
ro=9.0; |
y=my_rint(ro*sine[my_rint(angle)]); |
x=my_rint(ro*cosine[my_rint(angle)]); |
sem_wait(&mutex); |
grx_putimage(CAMX,CAMY+c,CAMX+29,CAMY+29+c,gauge_img); |
grx_line(CAMX+14,CAMY-1+c+25,CAMX+14-x,CAMY-1+c+25-y,blue); |
grx_text(vel,CAMX,CAMY+c+30,white,black); |
sem_post(&mutex); |
} else { |
sem_wait(&mutex); |
grx_putimage(CAMX,CAMY+c,CAMX+29,CAMY+29+c,brk_gauge); |
sem_post(&mutex); |
} |
task_endcycle(); |
} |
} |
TASK camera(int number) { |
int c; |
c=number*46; |
grx_rect(CAMX+40-1,CAMY-1+c,CAMX+40+30,CAMY+30+c,green); |
while(1) { |
if(kill_flag[number]) { |
return 0; |
} |
sem_wait(&mutex); |
grx_putimage(CAMX+40,CAMY+c,CAMX+40+29,CAMY+c+29,vbuf[number]); |
sem_post(&mutex); |
task_endcycle(); |
} |
} |
TASK traffic_light(tl_data *d) { |
char hpos,vpos,flag; |
flag=0; |
vpos=d->vpos; |
if(vpos=='g') { |
hpos='r'; |
#ifdef GRAPH |
sem_wait(&mutex); |
draw_tl(d->l.x,d->l.y,r_sem[L]); |
draw_tl(d->r.x,d->r.y,r_sem[R]); |
draw_tl(d->u.x,d->u.y,g_sem[U]); |
draw_tl(d->d.x,d->d.y,g_sem[D]); |
sem_post(&mutex); |
#endif |
} else { |
vpos='r'; |
hpos='g'; |
#ifdef GRAPH |
sem_wait(&mutex); |
draw_tl(d->l.x,d->l.y,g_sem[L]); |
draw_tl(d->r.x,d->r.y,g_sem[R]); |
draw_tl(d->u.x,d->u.y,r_sem[U]); |
draw_tl(d->d.x,d->d.y,r_sem[D]); |
sem_post(&mutex); |
#endif |
} |
task_endcycle(); |
while(1) { |
if(vpos=='g') { |
vpos='y'; |
flag=1; |
#ifdef GRAPH |
sem_wait(&mutex); |
draw_tl(d->u.x,d->u.y,y_sem[U]); |
draw_tl(d->d.x,d->d.y,y_sem[D]); |
sem_post(&mutex); |
#endif |
} |
if((vpos=='y')&&(!flag)) { |
vpos='r'; |
hpos='g'; |
flag=1; |
#ifdef GRAPH |
sem_wait(&mutex); |
draw_tl(d->u.x,d->u.y,r_sem[U]); |
draw_tl(d->d.x,d->d.y,r_sem[D]); |
draw_tl(d->l.x,d->l.y,g_sem[L]); |
draw_tl(d->r.x,d->r.y,g_sem[R]); |
sem_post(&mutex); |
#endif |
} |
if((vpos=='r')&&(!flag)) { |
if(hpos=='g') { |
hpos='y'; |
flag=1; |
#ifdef GRAPH |
sem_wait(&mutex); |
draw_tl(d->l.x,d->l.y,y_sem[L]); |
draw_tl(d->r.x,d->r.y,y_sem[R]); |
sem_post(&mutex); |
#endif |
} |
if((hpos=='y')&&(!flag)) { |
hpos='r'; |
vpos='g'; |
#ifdef GRAPH |
sem_wait(&mutex); |
draw_tl(d->l.x,d->l.y,r_sem[L]); |
draw_tl(d->r.x,d->r.y,r_sem[R]); |
draw_tl(d->u.x,d->u.y,g_sem[U]); |
draw_tl(d->d.x,d->d.y,g_sem[D]); |
sem_post(&mutex); |
#endif |
} |
} |
flag=0; |
d->vpos=vpos; |
d->hpos=hpos; |
#ifndef GRAPH |
sem_wait(&mutex); |
cprintf("semaforo %s: verticale:%c orizz.:%c\n",d->tl_name,vpos,hpos); |
sem_post(&mutex); |
#endif |
task_endcycle(); |
} |
} |
TASK car(car_data *cd) { |
char ob_type=FREE; |
int start_point,sat_angle=0; |
int tl=0; |
short stato=NORM,dir_flag=0; |
sem_wait(&(kill_mutex[cd->number])); |
while(kill_flag[cd->number]){ |
cd->running=0; |
sem_post(&(kill_mutex[cd->number])); |
return 0; |
} |
sem_post(&(kill_mutex[cd->number])); |
while(1) { |
sem_wait(&(kill_mutex[cd->number])); |
while(kill_flag[cd->number]){ |
cd->running=0; |
sem_post(&(kill_mutex[cd->number])); |
return 0; |
} |
sem_post(&(kill_mutex[cd->number])); |
if(cd->xp>630||cd->yp>590||cd->xp<18||cd->yp<MAPY+3) { |
start_point=rand()%S_POINT; |
if(start_point==2) |
start_point++; |
cd->xpos=cd->xp=starting_set_array[start_point].xpos; |
cd->ypos=cd->yp=starting_set_array[start_point].ypos; |
cd->angle=starting_set_array[start_point].angles; |
} |
if (!cd->boom) { |
// Control State Machine |
if(stato==NORM) { |
cd->dir=STRAIGHT; |
ob_type=collision_sensor(cd); |
ch_spd(cd,ob_type); |
if(cd->dist_obs<30 && ob_type==STOP) { |
stato=INC1; |
} |
if(ob_type==FREE || cd->dist_obs>=27 || cd->speed>=2.0) { |
cd->angle=sensore(cd); |
cd->angle=normalize(cd->angle); |
} |
} |
if(stato==INC1) { |
tl=find_tl(cd->angle,cd->xp,cd->yp); |
if(!dir_flag) |
cd->dir=rand()%3-1; |
if(find_col(cd->angle,tl)=='g') { |
switch(cd->dir) { |
case STEER_RIGHT: |
stato=DX1; |
break; |
case STRAIGHT: |
case STEER_LEFT: |
stato=STR1; |
break; |
default: |
stato=DX1; |
} |
} else { |
cd->speed=0.0; |
dir_flag=1; |
} |
} |
if(stato==DX1) { |
dir_flag=0; |
cd->speed=4.0; |
cd->angle=sensore(cd); |
if(ob_type!=STOP) |
stato=NORM; |
else { |
ob_type=collision_sensor(cd); |
if(ob_type==CAR) |
ch_spd(cd,ob_type); |
} |
} |
if(stato==STR1) { |
dir_flag=0; |
cd->angle=allinea(cd->angle); |
sensore(cd); |
cd->speed=4.0; |
ob_type=collision_sensor(cd); |
if(ob_type==CAR) |
ch_spd(cd,ob_type); |
if(cd->middle==MAX_DIST) { |
if(cd->dir==STRAIGHT) |
stato=STR2; |
else { |
sat_angle=cd->angle+90; |
stato=SX1; |
} |
} |
} |
if(stato==STR2) { |
cd->speed=4.0; |
sensore(cd); |
ob_type=collision_sensor(cd); |
if(ob_type==CAR) |
ch_spd(cd,ob_type); |
if(abs(cd->front-cd->rear)<0.1 && ((cd->middle-NORM_DIST)<7.0)) |
stato=NORM; |
} |
if(stato==SX1) { |
cd->speed=4.0; |
sensore(cd); |
ob_type=collision_sensor(cd); |
if(ob_type==CAR) |
ch_spd(cd,ob_type); |
else { |
cd->angle+=7; |
if(cd->angle>=sat_angle) { |
cd->angle=sat_angle; |
} |
} |
if(abs(cd->front-cd->rear)<0.1 && ((cd->middle-NORM_DIST)<7.0)) |
stato=NORM; |
} |
} |
if (cd->dist_obs<COLL_DIST && ob_type==CAR) { |
cd->boom=1; |
cd->speed=0.0; |
} |
sem_wait(&mutex); |
grx_getimage(cd->xp-15,cd->yp-15,cd->xp+14,cd->yp+14,vbuf[cd->number]); |
if (cd->boom==0) { |
drawCar(cd->xp,cd->yp,cd->angle,DRAW); |
} |
if (cd->boom==1) { |
drawSprites(cd->xp,cd->yp,0,DRAW); |
} |
sem_post(&mutex); |
task_endcycle(); |
sem_wait(&mutex); |
if (cd->boom==0) { |
grx_putimage(cd->xp-15,cd->yp-15,cd->xp+14,cd->yp+14,vbuf[cd->number]); |
} else { |
drawSprites(cd->xp,cd->yp,0,CANCEL); |
} |
sem_post(&mutex); |
sem_wait(&(kill_mutex[cd->number])); |
while(kill_flag[cd->number]){ |
cd->running=0; |
sem_post(&(kill_mutex[cd->number])); |
return 0; |
} |
sem_post(&(kill_mutex[cd->number])); |
cd->xpos+=cd->speed*cos(DEG_TO_RAD(cd->angle)); |
cd->ypos-=cd->speed*sin(DEG_TO_RAD(cd->angle)); |
cd->xp=my_rint(cd->xpos); |
cd->yp=my_rint(cd->ypos); |
} |
} |
/demos/tags/rel_1_21/simcity/keyfunct.c |
---|
0,0 → 1,85 |
/**************** Functions called by keyboard handler*********/ |
#include <drivers/keyb.h> |
#include <drivers/glib.h> |
#include <drivers/glib.h> |
#include <stdlib.h> |
#include <string.h> |
#include "include/simcity.h" |
#include "include/proc.h" |
short maxc=0; |
char sens=0; |
extern starting_set starting_set_array[S_POINT]; |
void h_car_create(KEY_EVT *k) |
{ |
char name[10]; |
int num; |
if((maxc<MAX_CAR)) { |
num=add(); |
if(num>=0) { |
sprintf(name,"car%d",num); |
h_create(name,num); |
sprintf(name,"camera%d",num); |
cam_create(name,num); |
sprintf(name,"speed%d",num); |
gauge_create(name,num); |
sprintf(name,"arrow%d",num); |
arrow_create(name,num); |
} |
} |
} |
void s_car_create(KEY_EVT *k) |
{ |
char name[10]; |
int num; |
if((maxc<MAX_CAR)) { |
num=add(); |
if(num>=0) { |
sprintf(name,"car%d",num); |
h_create(name,num); |
sprintf(name,"camera%d",num); |
cam_create(name,num); |
sprintf(name,"speed%d",num); |
gauge_create(name,num); |
sprintf(name,"arrow%d",num); |
arrow_create(name,num); |
} |
} |
} |
void h_car_kill(KEY_EVT *k) { |
int num; |
if(maxc>0) { |
num=del_o(); |
if(num>=0) { |
killing(num); |
} |
} |
} |
void endfun(KEY_EVT *k) |
{ |
grx_close(); |
cprintf("Brk command pressed! Ending...\n"); |
sys_end(); |
} |
void refresh(KEY_EVT *k){ |
sem_wait(&mutex); |
//heavy and obsolete..... |
//draw_scenario(); |
grx_putimage(MAPX,MAPY,MAPX+W-1,MAPY+H-1,street); |
sem_post(&mutex); |
} |
void sensor_switch(KEY_EVT *k) { |
if(sens==0) sens=1; |
else sens=0; |
} |
/demos/tags/rel_1_21/simcity/misc.c |
---|
0,0 → 1,215 |
#include <math.h> |
#include "include/misc.h" |
#include "include/simcity.h" |
int my_rint(float num) { |
return (int)floor(num+0.5); |
} |
void fill_table(void) { |
int i; |
for (i=0;i<360;i++) { |
sine[i]=sin(DEG_TO_RAD(i)); |
cosine[i]=cos(DEG_TO_RAD(i)); |
} |
} |
void tl_init() { |
//MAPX,MAPY |
char col[2]; |
short i; |
col[0]='r'; |
col[1]='g'; |
for(i=0;i<MAX_TL;i++) { |
tl_data_array[i].vpos=col[i%2]; |
tl_data_array[i].period=(i+3)*SECOND; |
tl_data_array[i].l.x+=MAPX; |
tl_data_array[i].l.y+=MAPY; |
tl_data_array[i].r.x+=MAPX; |
tl_data_array[i].r.y+=MAPY; |
tl_data_array[i].u.x+=MAPX; |
tl_data_array[i].u.y+=MAPY; |
tl_data_array[i].d.x+=MAPX; |
tl_data_array[i].d.y+=MAPY; |
} |
} |
void set_start_point() { |
//MAPX,MAPY |
starting_set_array[0].xpos=607+MAPX; |
starting_set_array[0].ypos=20+MAPY; |
starting_set_array[0].angles=180; |
starting_set_array[1].xpos=12+MAPX; |
starting_set_array[1].ypos=62+MAPY; |
starting_set_array[1].angles=0; |
starting_set_array[2].xpos=260+MAPX; |
starting_set_array[2].ypos=460+MAPY; |
starting_set_array[2].angles=90; |
starting_set_array[3].xpos=605+MAPX; |
starting_set_array[3].ypos=205+MAPY; |
starting_set_array[3].angles=180; |
} |
int returnCarIndex(int a) { |
int indice=-1; |
int angle; |
angle=normalize(a); |
if (((angle>=0) && (angle<=8)) || ((angle>353) && (angle<360))) { // 0 (+8 ; -7) |
indice=0; |
} |
if ((angle<=23) && (angle>8)) { // 15 |
indice=1; |
} |
if ((angle<=38) && (angle>23)) { // 30 |
indice=2; |
} |
if ((angle<=53) && (angle>38)) { // 45 |
indice=3; |
} |
if ((angle<=68) && (angle>53)) { // 60 |
indice=4; |
} |
if ((angle<=83) && (angle>68)) { // 75 |
indice=5; |
} |
if ((angle<=98) && (angle>83)) { // 90 |
indice=6; |
} |
if ((angle<=113) && (angle>98)) { // 105 |
indice=7; |
} |
if ((angle<=128) && (angle>113)) { // 120 |
indice=8; |
} |
if ((angle<=143) && (angle>128)) { // 135 |
indice=9; |
} |
if ((angle<=158) && (angle>143)) { // 150 |
indice=10; |
} |
if ((angle<=173) && (angle>158)) { // 165 |
indice=11; |
} |
if ((angle<=188) && (angle>173)) { // 180 |
indice=12; |
} |
if ((angle<=203) && (angle>188)) { // 195 |
indice=13; |
} |
if ((angle<=218) && (angle>203)) { // 210 |
indice=14; |
} |
if ((angle<=233) && (angle>218)) { // 225 |
indice=15; |
} |
if ((angle<=248) && (angle>233)) { // 240 |
indice=16; |
} |
if ((angle<=263) && (angle>248)) { // 255 |
indice=17; |
} |
if ((angle<=278) && (angle>263)) { // 270 |
indice=18; |
} |
if ((angle<=293) && (angle>278)) { // 285 |
indice=19; |
} |
if ((angle<=308) && (angle>293)) { // 300 |
indice=20; |
} |
if ((angle<=323) && (angle>308)) { // 315 |
indice=21; |
} |
if ((angle<=338) && (angle>323)) { // 330 |
indice=22; |
} |
if ((angle<=353) && (angle>338)) { // 345 |
indice=23; |
} |
if (angle==360) { |
indice=0; |
} |
return indice; |
} |
int normalize(int angle) { |
if(angle<0) |
return ((angle+360)); |
if(angle>=360) |
return ((angle-360)); |
return angle; |
} |
int module(int x1,int x2,int y1,int y2) { |
int x,y; |
x=x1-x2; |
y=y1-y2; |
x*=x; |
y*=y; |
return x+y; |
} |
int allinea(int angle) { |
int old_angle; |
old_angle=normalize(angle); |
if(old_angle<45) |
old_angle=0; |
else if(old_angle<135) |
old_angle=90; |
else if(old_angle<225) |
old_angle=180; |
else |
old_angle=270; |
return old_angle; |
} |
int find_tl(int angle,int xp,int yp) { |
int a,min_tl,old_min,mins,i; |
a=allinea(angle); |
min_tl=old_min=10000; |
for(mins=i=0;i<MAX_TL;i++) { |
switch(a) { |
case 0: |
min_tl=module( xp,tl_data_array[i].l.x, yp,tl_data_array[i].l.y); |
break; |
case 90: |
min_tl=module( xp,tl_data_array[i].d.x, yp,tl_data_array[i].d.y); |
break; |
case 180: |
min_tl=module( xp,tl_data_array[i].r.x, yp,tl_data_array[i].r.y); |
break; |
case 270: |
min_tl=module( xp,tl_data_array[i].u.x, yp,tl_data_array[i].u.y); |
break; |
default: |
break; |
} |
if(min_tl<old_min) { |
old_min=min_tl; |
mins=i; |
} |
} |
return mins; |
} |
int find_col(int angle,int tl) { |
int min_tl=0,a; |
a=allinea(angle); |
switch(a) { |
case 0: |
case 180: |
min_tl=tl_data_array[tl].hpos; |
break; |
case 90: |
case 270: |
min_tl=tl_data_array[tl].vpos; |
break; |
} |
return min_tl; |
} |
/demos/tags/rel_1_21/simcity/makefile |
---|
0,0 → 1,15 |
# |
# |
# |
ifndef BASE |
BASE=../.. |
endif |
include $(BASE)/config/config.mk |
PROGS= simcity |
include $(BASE)/config/example.mk |
simcity: |
make -f $(SUBMAKE) APP=simcity INIT= OTHEROBJS="initfile.o keyboard.o keyfunct.o tasks.o reading.o misc.o draw.o proc.o car.o" SHARKOPT="__OLDCHAR__ __GRX__" |
/demos/tags/rel_1_21/simcity/sem/green_l.raw |
---|
0,0 → 1,0 |