WebSVN - shark - Rev 1655 - /unsupported/trunk/telesco/tel.c

/*
* Project: S.Ha.R.K.
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors :
* Bera Marco mbera@libero.it
* Varasio Gabriele varasio@odino.unipv.it
*
* Universita' degli studi di Pavia
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*/

/**
------------
CVS : $Id: tel.c,v 1.1.1.1 2004-05-24 18:03:39 giacomo Exp $

File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2004-05-24 18:03:39 $
------------
**/

/*
* Copyright (C) 2000 Paolo Gai and Giorgio Buttazzo
*
* 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
*
*/

/****************************************************************/
/* PERIODIC PROCESS TEST */
/****************************************************************/

#include <ll/i386/x-dos.h>
#include <kernel/kern.h>
#include <modules/cabs.h>
#include <drivers/glib.h>
#include <drivers/keyb.h>
#include <math.h>
#include <semaphore.h>
#include <stdlib.h>
#include "moon.h"

#define N_MAX_TELESCOPI 5
#define X0 10
#define pi 3.14
#define ex 2.71
#define NCAB N_MAX_TELESCOPI+1
#define dim_msg 8
#define dim_x 49
#define dim_y 49
#define radius 9
#define Y_TELESCOPI 300
/* task periods */
#define PERIOD_T1 80000
#define PERIOD_T4 100000
#define PERIOD_T5 100000
#define WCET_T 5000
int period_t1=0;
#define SOGLIA 8

char *cname[NCAB] = {"cab1", "cab2", "cab3", "cab4","cab5","cab6"};

// posizioni dei telescopi e rispettivi poli

int x[5] = {100, 200, 300, 400,500};
//double poli[5]={-50,-30,-1, -20, -5};
double poli[5];
// guadagno proporzionale
double kp=0.0;
// flag per rilevare la pressione del tasto spazio
int numero_telescopi=0;
int flag=0;
KEY_EVT move_tasto;
// Immagini ausiliarie per il disegno della luna
BYTE lunabkg[900];
BYTE lunadest[900];

/* A semaphore used to access Video Cards in mutual exclusion */
sem_t mutex;
sem_t mutex_tasto;

/***************************************************************/

// cab necessari allo scambio delle coordinate dell'oggetto e delle
// immagini dei rispettivi telescopi

CAB cid[NCAB];

// vettori per memorizzare le immagini
BYTE videobuf[dim_x*dim_y];
BYTE videobuf1[dim_x*dim_y];
BYTE videobuf2[dim_x*dim_y];
BYTE videobuf3[dim_x*dim_y];
BYTE videobuf4[dim_x*dim_y];
BYTE videobuf5[dim_x*dim_y];

// Variabili per il disegno delle stelle sullo sfondo
int num_p;
int y_p[7];
int x_p[7];
int dim_p[7];
int col_p[7];

TASK media(void *arg)
{
char *p;

int i=0;
int j=0;
while(1)
{
p = cab_getmes(cid[1]);
memcpy(videobuf,p,dim_x*dim_y*sizeof(BYTE));
cab_unget(cid[1], p);
p = cab_getmes(cid[2]);
memcpy(videobuf1,p,dim_x*dim_y*sizeof(BYTE));
cab_unget(cid[2], p);
p = cab_getmes(cid[3]);
memcpy(videobuf2,p,dim_x*dim_y*sizeof(BYTE));
cab_unget(cid[3], p);
p = cab_getmes(cid[4]);
memcpy(videobuf4,p,dim_x*dim_y*sizeof(BYTE));
cab_unget(cid[4], p);

p = cab_getmes(cid[5]);
memcpy(videobuf5,p,dim_x*dim_y*sizeof(BYTE));
cab_unget(cid[5], p);

// calcolo media

for (i=0;i<dim_x;i++)

{
for(j=0;j<dim_y;j++)
{
videobuf3[i*dim_x+j]=(double)(videobuf[i*dim_x+j]+videobuf1[i*dim_x+j]+videobuf2[i*dim_x+j]+videobuf4[i*dim_x+j]+videobuf5[i*dim_x+j])/numero_telescopi;
}
}

// visualizza immagine mediata
sem_wait(&mutex);
grx_putimage(570,10,570+dim_x-1,10+dim_y-1,videobuf3);
sem_post(&mutex);
task_endcycle();
}
}

TASK move(void *arg)
{
//int i = (int)arg;
char *p;
int x_object=300; // posizione dell'oggetto da rilevare
int y_object=200;
// variabile contatore
int z=0;
char coord_x[dim_msg];
p = cab_reserve(cid[0]);
sprintf(coord_x,"%d %d",x_object,y_object);
memcpy(p,coord_x,dim_msg*sizeof(char));
cab_putmes(cid[0], p);

//Normalizzazione
for(z=0;z<900;z++)
{
if (luna[z]>0)
{
luna[z]=((luna[z])*16.0/255.0)+16;
}

}

task_endcycle();
while (1)
{

// Cancellazione Luna
sem_wait(&mutex);
grx_box(x_object-15,y_object-15,x_object+14,y_object+14,0);
sem_post(&mutex);
if (keyb_getcode(&move_tasto,NON_BLOCK))
{
if (move_tasto.ascii=='4')
x_object=x_object-5;
if (move_tasto.ascii=='6')
x_object=x_object+5;
if (move_tasto.ascii=='2')
y_object=y_object+5;
if (move_tasto.ascii=='8')
y_object=y_object-5;
if (move_tasto.ascii=='9'){
y_object=y_object-5;
x_object=x_object+5; }
if (move_tasto.ascii=='1'){
y_object=y_object+5;
x_object=x_object-5; }
if (move_tasto.ascii=='7'){
y_object=y_object-5;
x_object=x_object-5; }
if (move_tasto.ascii=='3'){
y_object=y_object+5;
x_object=x_object+5;}
if (move_tasto.ascii==' '){
sem_wait(&mutex_tasto);
flag=1;
if(numero_telescopi<N_MAX_TELESCOPI)
{
numero_telescopi++;
}
sem_post(&mutex_tasto);
}
//CONTROLLI SULLA POSIZIONE
if(y_object<(dim_y/2+70)) y_object=dim_y/2+70;
if(y_object>(240-dim_y/2)) y_object=(240-dim_y/2);
if(x_object<(dim_x/2+20 )) x_object=dim_x/2+20;
if(x_object>(630-dim_x/2-10)) x_object=(630-dim_x/2-10);
}
p = cab_reserve(cid[0]);
sprintf(coord_x,"%d %d",x_object,y_object);
memcpy(p,coord_x,dim_msg*sizeof(char));
cab_putmes(cid[0], p);

for(z=0;z<7;z++)
{
if (sqrt(pow((x_object-x_p[z]),2)+pow((y_object-y_p[z]),2))<20+dim_p[z]+radius)
grx_disc(x_p[z],y_p[z],dim_p[z],col_p[z]);
}

sem_wait(&mutex);
// Gestione sfondo
grx_getimage(x_object-15,y_object-15,x_object+14, y_object+14,lunabkg);
for(z=0;z<900;z++)
{
if( luna[z]==0 && lunabkg!=0 )
{
lunadest[z]=lunabkg[z];
}
else
{
lunadest[z]=luna[z];
}
}
grx_putimage(x_object-15,y_object-15,x_object+14, y_object+14,lunadest);
sem_post(&mutex);
task_endcycle();
}
}

TASK tele(void *arg)
{
int i = (int)arg;
int passi;
char s[100];
int x_object=300; // posizione dell'oggetto da rilevare
int y_object=200;
int x_start=500; // posizione iniziale dei telescopi
int y_start=190;
int x_current=x_start; // posizione corrente dei telescopi
int y_current=y_start;
int x_current_d[9];
int y_current_d[9];
int y= Y_TELESCOPI; // coordinata y dei telescopi
double alpha_new=atan((y-(double)y_current)/((x[i]-(double)x_current)));
double alpha=alpha_new;
double distance=0.0;
double alpha_target=0.0;
double tc=0.1;
double u=0.0;
double u_old=0.0;
double errore=0.0;
double delta_x=0;
double delta_y=0;

char *p;
//int j=0;
// indice matrice per aggiunta di rumore
int k=0;
int q=0;
double polo=poli[i];
int val=0;

BYTE videobuf[dim_x*dim_y];

passi = 0;
//srand(i);
//srand(i+sys_gettime(NULL));
alpha_target=atan((y-(double)y_object)/((double)x_object-x[i]));

sem_wait(&mutex);
grx_text("targ",4,340,12,0);
sprintf(s,"%f",poli[i]);
grx_text(s,x[i],y+60,12,0);
grx_text("polo",4,y+60,12,0);
grx_text("new",4,y+50,12,0);
sprintf(s,"%1.6f",alpha_target);
grx_text(s, x[i]-25,y+50,12,0);
grx_rect(x[i]-40,y+25,x[i]+40,y+85,2);
grx_rect(x[i]-40,y+90,x[i]+40,y+150,2);
sem_post(&mutex);

// Disegno telescopio
grx_disc(x[i],y,19,i+1);
grx_box( x[i]-19,y,x[i]+19,y+20,i+1);

task_endcycle();

while (1) {
// legge di controllo
passi++;
//sprintf(s,"%d",passi);
//grx_text(s, 50,110,12,0);
p = cab_getmes(cid[0]);
sscanf(p,"%d %d",&val,&y_object);
cab_unget(cid[0], p);
x_object=val;
alpha_target=atan((y-(double)y_object)/((double)x_object-x[i]));
if (alpha_target <0)
{
alpha_target=3.14+alpha_target;
}

errore=alpha_target-alpha_new;
u=u_old+kp*tc*errore;
//alpha_new=0.13*alpha+0.87*u;
alpha_new=(exp(polo*tc))*alpha+(1-exp(polo*tc))*u;
u_old=u;
alpha=alpha_new;

// implementazione dei limiti degli attuattori
if (alpha_new > 3.14)
alpha_new=3.14;
if (alpha_new <0)
alpha_new=0;

distance=sqrt(((y-y_object)*(y-y_object))+((x_object-x[i])*(x_object-x[i])));

sem_wait(&mutex);
// Cancello braccio telescopio
if (passi>1)
{
for (k=0; k<9 ; k++)
{
grx_line(delta_x,delta_y,x_current_d[k],y_current_d[k],0);
}
}
x_current=x[i]+distance*cos(alpha_new);
y_current=300-distance*sin(alpha_new);

// lettura immagine

grx_getimage(x_current-(dim_x/2),y_current-(dim_y/2),x_current+(dim_x/2),y_current+(dim_y/2),videobuf);

//aggiunta rumore

sem_post(&mutex);
for (k=0;k<dim_x;k++)
{
for(q=0;q<dim_y;q++)
{
int num=0;
num=rand();
num=(num%10)+1;
if (num>SOGLIA)
{
videobuf[k*dim_x+q]=videobuf[k*dim_x+q]+1;
}
}
}
sem_wait(&mutex);

grx_putimage(x[i]-25,y+92,x[i]-25+dim_x-1,y+92+dim_y-1,videobuf);

sprintf(s,"%3.4f",(180*(alpha_target/pi)));
grx_text(s, x[i]-25,y+40,12,0);
sprintf(s,"%3.4f",180*(alpha_new/pi));
grx_text(s, x[i]-25,y+50,12,0);

delta_x=x[i]+20*cos(alpha_new);
delta_y=y-20*sin(alpha_new);

for ( k=0; k<9 ; k++) {
x_current_d[k]=x[i]+50*cos(alpha_new+(k-4)*0.01);
y_current_d[k]=300-50*sin(alpha_new+(k-4)*0.01); }

// Disegno braccio telescopio
for(k=0 ; k<9 ; k++)
grx_line(delta_x,delta_y,x_current_d[k],y_current_d[k],i+1);

sem_post(&mutex);

// scrive immagine nel cab
p = cab_reserve(cid[i+1]);
memcpy(p,videobuf,dim_x*dim_y*sizeof(BYTE));
cab_putmes(cid[i+1], p);

task_endcycle();

}

}

/****************************************************************/

/* This is the exception handler. It is called when an exception
is raised.
It exits from the graphical mode, then it prints a message and
shutdown the kernel using sys_abort()
*/

void demo_exc_handler(int signo, siginfo_t *info, void *extra)
{
struct timespec t;

grx_close();

/* Default action for an kern exception is */
kern_cli();
ll_gettime(TIME_EXACT, &t),
kern_printf("\nS.Ha.R.K. Exception raised!!!"
"\nTime (s:ns) :%ld:%ld"
"\nException number:%d (numbers in include/bits/errno.h)"
"\nPID :%d\n",
t.tv_sec, t.tv_nsec, info->si_value.sival_int,
info->si_task);
sys_abort(1);
}

/******************************************************************/

/* This function is called when Alt-X is pressed.
It simply shutdown the system using sys_end.
Note that the byebye() function is called only if we exit from
the system using sys_end()!!!!
*/
void my_end(KEY_EVT* e)
{
sys_end();
}

/******************************************************************/

/* This function is called when the system exit correctly after Alt-X.
It exits from the graphic mode and then it prints a small greeting.
Note that:
- The function calls grx_exit, so it must be registered using
RUNLEVEL_BEFORE_EXIT (RUNLEVEL_AFTER_EXIT does not work because
at that point the kernel is already returned in real mode!!!)
- When an exception is raised, the exception handler is called.
Since the exception handler already exits from the graphic mode,
this funcion has not to be called. For this reason:
. we registered byebye using the flag NO_AT_ABORT
. the exception handler exits using sys_abort; in that way byebye is
NOT called
*/

void byebye(void *arg)
{
grx_close();
kern_printf("Bye Bye!\n");
}

/****************************** MAIN ******************************/

int main(int argc, char **argv)
{
PID pid1, pid4,pid5;
KEY_EVT emerg;
int i=0;
int z=0; // contatore per disegno dei pianeti
HARD_TASK_MODEL m1, m4,m5;
//FILE *fp;

struct sigaction action;

cid[0] = cab_create(cname[0], dim_msg, 5);
cid[1] = cab_create(cname[1], dim_x*dim_y, 3);
cid[2] = cab_create(cname[2], dim_x*dim_y, 3);
cid[3] = cab_create(cname[3], dim_x*dim_y, 3);
cid[4] = cab_create(cname[4], dim_x*dim_y, 4);
cid[5] = cab_create(cname[5], dim_x*dim_y, 3);
cid[6] = cab_create(cname[6], dim_x*dim_y, 3);

/*fp=fopen("file.txt","r");
fscanf(fp,"%d",a);
fclose(fp);
*/

/* Init the standard S.Ha.R.K. exception handler */
action.sa_flags = SA_SIGINFO; /* Set the signal action */
action.sa_sigaction = demo_exc_handler;
action.sa_handler = 0;
sigfillset(&action.sa_mask); /* we block all the other signals... */

if (sigaction(SIGHEXC, &action, NULL) == -1) { /* set the signal */
perror("Error initializing signals...");
sys_end();
}

/* Set the closing function */
sys_atrunlevel(byebye, NULL, RUNLEVEL_BEFORE_EXIT|NO_AT_ABORT);

/* Initializes the semaphore */
sem_init(&mutex,0,1);

/* graphic card Initialization */
if (grx_init() < 1) {
sys_abort(1);
}

if (grx_open(640, 480, 8) < 0) {
kern_printf("GRX Err\n");
sys_abort(1);
}
kern_printf("Video card ok!\n");

/* set the keyboard handler to exit correctly */
emerg.ascii = 'x';
emerg.scan = KEY_X;
emerg.flag = ALTL_BIT;
keyb_hook(emerg,my_end);

srand(i+sys_gettime(NULL));

emerg.ascii = 'x';
emerg.scan = KEY_X;
emerg.flag = ALTR_BIT;
keyb_hook(emerg,my_end);
sem_wait(&mutex);
/* a small banner */
grx_clear(0);

grx_text("REALTIME TELESCOPES di Marco Bera e Gabriele Varasio",8,8,WHITE,0);
grx_text("Premere Spazio per creare un telescopio",8,22,WHITE,0);
grx_text("Premere Alt-X per uscire",8,32,WHITE,0);
grx_text("Usare il tastierino numerico per muovere l'oggetto",8,42,WHITE,0);

// DISEGNARE BORDI
grx_rect(1,1,638,478,2);
grx_rect(558,1,638,61,2);
grx_rect(1,1,638,61,2);

// Disegno sfondo
for(z=0;z<7;z++)
{
num_p=rand();
y_p[z]=100+((num_p%130)+1);
x_p[z]=50+((num_p%540)+1);
dim_p[z]=2+((num_p%5)+1);
col_p[z]=((num_p%10)+1);
grx_disc(x_p[z],y_p[z],dim_p[z],col_p[z]);
}
sem_post(&mutex);

hard_task_default_model(m4);
hard_task_def_ctrl_jet (m4);
hard_task_def_arg (m4, (void *)3);
hard_task_def_wcet (m4, 19000);
hard_task_def_mit (m4, PERIOD_T4);
hard_task_def_group (m4,1);
pid4 = task_create("move", move, &m4, NULL);
if (pid4 == NIL) {
grx_close();
perror("Could not create task <move>");
sys_abort(1);
}
task_activate(pid4);
hard_task_default_model(m5);
hard_task_def_ctrl_jet (m5);
hard_task_def_arg (m5, (void *)3);
hard_task_def_wcet (m5, 19000);
hard_task_def_mit (m5, PERIOD_T5);
hard_task_def_group (m5,1);
pid5 = task_create("media", media, &m5, NULL);

if (pid5 == NIL) {
grx_close();
perror("Could not create task <move>");
sys_abort(1);
}
task_activate(pid5);
/* and finally we activate the three threads... */

do {
int val_flag=0;
sem_wait(&mutex_tasto);
val_flag=flag;
sem_post(&mutex_tasto);

if ((val_flag==1) && (i < N_MAX_TELESCOPI))
{
flag=0;
hard_task_default_model(m1);
hard_task_def_ctrl_jet (m1);
hard_task_def_arg (m1, (void *)i);
hard_task_def_wcet (m1, WCET_T);
// hard_task_def_mit (m1, PERIOD_T1);
hard_task_def_mit (m1, period_t1);

hard_task_def_group (m1,1);
pid1 = task_create("tele1", tele, &m1, NULL);
if (pid1 == NIL)
{
grx_close();
perror("Could not create task <tele1>");
sys_abort(1);
}
task_activate(pid1);
i++;
}
} while (1);

/*
now the task main ends, but the system does not shutdown because
there are others.

The demo will finish if a Alt-X key is pressed.
*/

return 0;
}
/*********** lettura da file ********************/
void read_cfg_file(int argc, char **argv)
{
int err;
DOS_FILE *fp;
char myfilebuf[1000];
int myfilebuf_length;

if (2)
{
fp = DOS_fopen("dati.cnf","r");

if (fp)
{
/* read up to 1000 chars */
myfilebuf_length = DOS_fread(&myfilebuf,1,1000,fp);

/* check for errors */
err = DOS_error();

cprintf("Read %d bytes...\n", myfilebuf_length);

if (err)
{
cprintf("Error %d reading file...Using default values\n", err);
}
else
{
//geti(myfilebuf, &pos, &NMouses); // Number of Mouses
sscanf(myfilebuf,"%lf %lf %lf %lf %lf %lf %d",&poli[0],&poli[1],&poli[2],&poli[3],&poli[4],&kp,&period_t1);
}

DOS_fclose(fp);
return;

}
else {
/* error!! */
err = DOS_error();
/* note that if you call DOS_error() here, it return 0!!! */
cprintf("Error %d opening myfile.txt...Using default values\n", err);
}

}
else {
cprintf("Wrong number of arguments...\n");
l1_exit(0);
}
}

/****************************************************************/

Subversion Repositories shark

(root)/unsupported/trunk/telesco/tel.c - Rev 1655