Subversion Repositories shark

/*

 * Project: S.Ha.R.K.

 *

 * Coordinators:

 *   Giorgio Buttazzo    <giorgio@sssup.it>

 *   Paolo Gai           <pj@gandalf.sssup.it>

 *

 * Authors     :

 *   Paolo Gai           <pj@gandalf.sssup.it>

 *   Massimiliano Giorgi <massy@gandalf.sssup.it>

 *   Luca Abeni          <luca@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: control.c,v 1.1.1.1 2002-09-02 09:37:42 pj Exp $

 File:        $File$

 Revision:    $Revision: 1.1.1.1 $

 Last update: $Date: 2002-09-02 09:37:42 $

 ------------

**/

/*

 * Copyright (C) 2000 Marco Dallera and Marco Fiocca

 *

 * 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

 *

 */

/*

 *              AUTO

 *

 * Another Unuseful Track simulatOr

 *

 * Authors: Marco Dallera

 *          Marco Fiocca

 *

 */

/* ------------- */

/*  Car control  */

/* ------------- */

#include "include/auto.h"

#include "include/const.h"

#include "include/utils.h"

#define TURN_QUANTUM    2

#define KM     18.0             // pixel

#define HOUR 3600.0             // seconds

#define KPH  (KM/HOUR)          // 0.005 pixel/second

#define HIGHWAY_LIMIT  6

#define MAZE_LIMIT    45

#define CURVE_LIMIT     25      // il limite della curva per cui imposta la traiettoria

#define BORDER_LIMIT  ((1.0 / params.rage) * 2.0)

#define STEERING_LIMIT  3       // limite di sterzata

/* Road state */

#define HIGHWAY         1

#define MIXED           2

#define MAZE            3

#define CENTER     10

#define TOO_LEFT   11

#define TOO_RIGHT  12

/* Opponents relationship */

#define ATTACK                  20

#define DEFENSE                 21

#define SUPERATTACK             22

/* Car parameters */

#define MAX_SPEED       (300 * KPH)

#define MIN_SPEED       (10 * KPH)

#define MIN_ACC         (-0.1)

#define MAX_ACC      (0.02)

extern sem_t grx_mutex;

char track_img[TRACK_WIDTH*TRACK_HEIGHT];

char sprite[18][CAR_WIDTH*CAR_HEIGHT];

/* Display functions */

void put_transimage(int x1, int y1, int x2, int y2, BYTE *img,int car_color, int color);

void draw_car(point_f old_pos, car_status cs, int car_color, int fumo);

void put_trackbox(int x1, int y1, int x2, int y2);

void show_display(int, int, float, float, float, float);

void car_crash(PID sp, PID cp, point_f old_pos, int free);

/* ------------------------------------------------------------------ */

TASK control(int index) {

  int i = 0;                            // general purpose counter

  car_status old_car_status;            // the previous car state

  car_status actual_car_status;         // the actual car state

  road_info actual_road_info;           // the actual road informations

  int road_state;                       // the state of the road: HIGHWAY, MIXED; MAZE

  int car_align;                        // the car alignment with respect to road limits

  int opps_state;                       // the relationship with other cars

  float old_speed = 0;                  // the previous car speed value

  float actual_speed = 0;               // the actual car speed value

  float old_acc = 0;                    // the previous acceleration value

  float acc = 0;                        // the new acceleration

  point polepos;

  // Variabili che dipendono dal tipo di macchina

  float max_speed;                      // maximum car speed

  float min_acc;                        // minimum acceleration

  float max_acc;                        // maximum acceleration

  int killed = 0;                       // flag for killed cars

  int crashed = 0;                      // flag for crashed cars

  /* Timing variables */

  float t = 0;

  float dt = (float)CONTROL_PERIOD/100000.0;  // time quantum

  time ts = int2time(t);

  float crash_t = 0;

  time crash_ts = int2time(crash_t);

  float bestlap = 999999999.9;

  time bestlap_s = int2time(bestlap);

  int bestlap_done = 0;

  int laps = 0;

  /* Display vars */

  point spd_p, acc_p, time_p, drv_p;

  char *txt;

  /* Car data */

  car_params params;    // car data structure

  /* ----------------------------------------------------- */

  txt = (char *)malloc(15*sizeof(char));

  params = cars[index];

  max_speed = params.max_speed * MAX_SPEED;             // maximum car speed

  min_acc   = params.min_acc * MIN_ACC;                 // minimum acceleration

  max_acc   = params.max_acc * MAX_ACC;                 // maximum acceleration

  /* Get track data */

  while (track_list[i].selected == 0)

    i++;

  /* Same pole for all */

  polepos.x = track_list[i].pole_pos.x;

  polepos.y = track_list[i].pole_pos.y;

  actual_car_status.pos.x  = polepos.x;

  actual_car_status.pos.y  = polepos.y;

  actual_car_status.orient = track_list[i].pole_orient;

  set_car_status(actual_car_status, params.car_status_cab);

  /* Initialize old values */

  old_car_status = actual_car_status;

  old_acc = acc;

  old_speed = actual_speed;

  /* POWER IS NOTHING WITHOUT CONTROL */

  while(1) {

    if (crashed) {

      crash_t += dt;

      crash_ts = int2time(crash_t);

      if (crash_ts.sec > 2) {

        car_crash(params.sensor_pid,params.control_pid,

                  old_car_status.pos, 1);

        killed=1;

      }

    }

    else {

      /* Reads road informations */

      actual_road_info = get_road_info(params.road_status_cab);

      /* Defines the state of the road */

      if (fabs(actual_road_info.curve) < HIGHWAY_LIMIT  ||

          actual_road_info.distance > 0.9*TEL_HEIGHT) {

        road_state = HIGHWAY;

      } else if (fabs(actual_road_info.curve) > MAZE_LIMIT ||

                 actual_road_info.distance < 0.1*TEL_HEIGHT) {

        road_state = MAZE;

      } else {

        road_state = MIXED;

      }

      /* Defines the car position whitin road borders */

      if (actual_road_info.left_border < BORDER_LIMIT)

        car_align = TOO_LEFT;

      else if (actual_road_info.right_border < BORDER_LIMIT)

        car_align = TOO_RIGHT;

      else car_align = CENTER;

      /* Sets the power percentage */

      switch (road_state)

        {

        case HIGHWAY:

          acc = max_acc;                // tarella!!!!

          break;

        case MIXED:

          actual_speed = params.rage * (((float)actual_road_info.distance/(float)TEL_HEIGHT) /

                                        (fabs(actual_road_info.curve)/90.0)) * max_speed;

          acc = (actual_speed - old_speed) / dt;

          break;

        case MAZE:

          actual_speed = params.rage * (1.0 - (fabs(actual_road_info.curve)/90.0)) * max_speed;

          acc = (actual_speed - old_speed) / dt;

          break;

        default:

          acc = 0.0;

        }

      /* Can't go off road */

      /* When car is near a border, it steers to come in */

      switch (car_align)

        {

        case TOO_LEFT:

          actual_car_status.orient -= TURN_QUANTUM;

          break;

        case TOO_RIGHT:

          actual_car_status.orient += TURN_QUANTUM;

          break;

        }

      if (road_state != HIGHWAY) {

        // C'e' una curva vicina.

        // Se la curva e' a destra si tiene vicino al bordo di sinistra

        // per impostare la traiettoria migliore e viceversa

        if (actual_road_info.curve < 0 && actual_road_info.left_border > BORDER_LIMIT

            && fabs(actual_road_info.curve) > CURVE_LIMIT)

          actual_car_status.orient += TURN_QUANTUM;

        else if (actual_road_info.curve > 0 && actual_road_info.right_border > BORDER_LIMIT

                 && fabs(actual_road_info.curve) > CURVE_LIMIT)

          actual_car_status.orient -= TURN_QUANTUM;

        // Fa la curva dolcemente

        if (actual_road_info.distance < ((1.0/params.rage) * (TEL_HEIGHT * 0.25))) {

          actual_car_status.orient += actual_road_info.curve * (params.rage/8.0);

                                //actual_car_status.orient += actual_road_info.curve / 4.0;

        }

      }

      /* Defines the state of interactions with other cars */

      if (actual_road_info.opps_number > 0)

        {

          if (road_state == HIGHWAY && actual_road_info.opps_list[0].y > (TEL_HEIGHT/3.0))

            opps_state = ATTACK;

          else if (road_state == MAZE && actual_road_info.opps_list[0].y < (TEL_HEIGHT/3.0))

            opps_state = DEFENSE;

          else if (actual_road_info.opps_list[0].y < (TEL_HEIGHT/6.0) &&

                   actual_road_info.opps_list[0].x != 0 &&

                   (abs(actual_road_info.opps_list[0].x) < CAR_W/2)) {

            // Defends and steers to avoid opponents

            opps_state = DEFENSE;

            acc *= -((TEL_HEIGHT/6.0) / (actual_road_info.opps_list[0].y));

            actual_car_status.orient -= ((actual_road_info.opps_list[0].x) /

                                         abs(actual_road_info.opps_list[0].x)) * TURN_QUANTUM/2;

          }

          else if (actual_road_info.opps_list[0].y < (TEL_HEIGHT/3.0) &&

                   actual_road_info.opps_list[0].x != 0 &&

                   abs(actual_road_info.opps_list[0].x) < CAR_W/2) {

            // Attacks and steers to override the opponent

            opps_state = ATTACK;

            actual_car_status.orient -= ((actual_road_info.opps_list[0].x) /

                                         abs(actual_road_info.opps_list[0].x)) * TURN_QUANTUM;

          }

          else

            opps_state = DEFENSE;

          // Response to opponents positions

          if (opps_state == ATTACK)

            acc = max_acc;

          else if (opps_state == DEFENSE)

            acc *= 0.5;

        }

      /* Checking car position: road/offroad */

      if (actual_road_info.left_border * actual_road_info.right_border < 0)

        acc = 0.5 * min_acc;

      if (actual_road_info.flag != ROAD_OK) {

        switch (actual_road_info.flag) {

        case LEFT_ONLY:

          if (actual_road_info.left_border < 0)

            actual_car_status.orient -= TURN_QUANTUM;

          acc = 0.5 * max_acc;

          break;

        case RIGHT_ONLY:

          if (actual_road_info.right_border < 0)

            actual_car_status.orient += TURN_QUANTUM;

          acc = 0.5 * max_acc;

          break;

        case NO_ROAD:

          crashed = 1;

          car_crash(params.sensor_pid,params.control_pid,

                    old_car_status.pos, 0);

          break;

        }

      }

      /* Checking collisions... */

      if (actual_road_info.collision != NO_COLL) {

        switch(actual_road_info.collision) {

        case COLLISION_LEFT:

          actual_car_status.orient -= TURN_QUANTUM;

          acc *= (0.5 * params.rage);

          break;

        case COLLISION_RIGHT:

          actual_car_status.orient += TURN_QUANTUM;

          acc *= (0.5 * params.rage);

          break;

        }

      }

      /* Checking acceleration range... */

      acc = max(min(max_acc,acc),min_acc);

      actual_speed = old_speed + acc*dt;

      /* Checking speed range... */

      actual_speed = min(max(actual_speed,MIN_SPEED),max_speed);

      /* Checking steering angle ... */

      if (fabs(actual_car_status.orient - old_car_status.orient) >

          STEERING_LIMIT) {

        if ((actual_car_status.orient - old_car_status.orient) > 0)

          actual_car_status.orient = old_car_status.orient + STEERING_LIMIT;

        else

          actual_car_status.orient = old_car_status.orient - STEERING_LIMIT;

      }

      /* Setting new car position... */

      actual_car_status.pos.x += actual_speed * cos(degree_to_rad(actual_car_status.orient));

      actual_car_status.pos.y -= actual_speed * sin(degree_to_rad(actual_car_status.orient));

      /* Checking track limits... */

      if (actual_car_status.pos.x < MIN_CAR_X)

        actual_car_status.pos.x = MIN_CAR_X;

      if (actual_car_status.pos.x > MAX_CAR_X)

        actual_car_status.pos.x = MAX_CAR_X;

      if (actual_car_status.pos.y < MIN_CAR_Y)

        actual_car_status.pos.y = MIN_CAR_Y;

      if (actual_car_status.pos.y > MAX_CAR_Y)

        actual_car_status.pos.y = MAX_CAR_Y;

      /* Sends new status to car_status_cab */

      set_car_status(actual_car_status, params.car_status_cab);

      if (!crashed) {

        /* Updates car */

        if (acc == min_acc)

          draw_car(old_car_status.pos,actual_car_status, params.color, 1);

        else

          draw_car(old_car_status.pos,actual_car_status, params.color, 0);

      }

      /* Sets display points */

      spd_p.x = TRACK_X1 + TRACK_WIDTH + TEL_HEIGHT + TEL_WIDTH + 9;

      spd_p.y = TEL_HEIGHT*index + 1 + index + 1;

      bar_display(spd_p, 70, 4, GREEN, actual_speed, max_speed, LIGHTGRAY, "Spd");

      acc_p.x = spd_p.x;

      acc_p.y = spd_p.y + 24;

      bidir_bar_display(acc_p, 70, 4, GREEN, acc, max(fabs(min_acc), max_acc), LIGHTGRAY, "Acc");

      sem_wait(&grx_mutex);

      /* Displays driver's name */

      drv_p.x = spd_p.x + 80;

      drv_p.y = spd_p.y;

      grx_text(params.driver, drv_p.x, drv_p.y, params.color, BLACK);

      /* Displays timer */

      time_p.x = spd_p.x + 80;

      time_p.y = spd_p.y + 8;

      if( (!bestlap_done) || (bestlap_done && t > 50))

        {

          /* Mins */

          txt = itoa(ts.min, txt);

          grx_text(txt, time_p.x,     time_p.y, WHITE, BLACK);

          grx_text(":", time_p.x + 8, time_p.y, WHITE, BLACK);

          /* Secs */

          txt = itoa(ts.sec, txt);

          if (ts.sec < 10) {

            grx_text("0", time_p.x+16, time_p.y, WHITE, BLACK);

            grx_text(txt, time_p.x+24, time_p.y, WHITE, BLACK);

          }

          else

            grx_text(txt, time_p.x+16, time_p.y, WHITE, BLACK);

          /* Decs */

          grx_text(":", time_p.x+32, time_p.y, WHITE, BLACK);

          txt = itoa(ts.dec, txt);

          grx_text(txt, time_p.x+40, time_p.y, WHITE, BLACK);

        }

      /* Displays the best lap */

      if(bestlap_done == 1)

        {

          time_p.x = spd_p.x + 80;

          time_p.y = spd_p.y + 16;

          /* Mins */

          txt = itoa(bestlap_s.min, txt);

          grx_text(txt, time_p.x,     time_p.y, YELLOW, BLACK);

          grx_text(":", time_p.x + 8, time_p.y, YELLOW, BLACK);

          /* Secs */

          txt = itoa(bestlap_s.sec, txt);

          if (bestlap_s.sec < 10) {

            grx_text("0", time_p.x+16, time_p.y, YELLOW, BLACK);

            grx_text(txt, time_p.x+24, time_p.y, YELLOW, BLACK);

          }

          else

            grx_text(txt, time_p.x+16, time_p.y, YELLOW, BLACK);

          /* Decs */

          grx_text(":", time_p.x+32, time_p.y, YELLOW, BLACK);

          txt = itoa(bestlap_s.dec, txt);

          grx_text(txt, time_p.x+40, time_p.y, YELLOW, BLACK);

        }

      /* Displays lap number */

      time_p.x = spd_p.x + 80;

      time_p.y = spd_p.y + 24;

      grx_text("Lap ", time_p.x, time_p.y, LIGHTGRAY, BLACK);

      txt = itoa(laps, txt);

      grx_text(txt, time_p.x+32, time_p.y, LIGHTGRAY, BLACK);

      sem_post(&grx_mutex);

      /* Control the best lap */

      t += dt;

      ts = int2time(t);

      /* Finish line */

      if ((track_list[i].lap == CLOCK &&

           (actual_car_status.pos.x >= polepos.x) && (old_car_status.pos.x < polepos.x)

           && (actual_car_status.pos.y > polepos.y-20) && (actual_car_status.pos.y < polepos.y+20)) ||

          (track_list[i].lap == ANTICLOCK &&

           (actual_car_status.pos.x <= polepos.x) && (old_car_status.pos.x > polepos.x)

           && (actual_car_status.pos.y > polepos.y-20) && (actual_car_status.pos.y < polepos.y+20))) {

        laps++;         // increases lap number

        bestlap = min(bestlap,t);

        bestlap_s = int2time(bestlap);

        bestlap_done = 1;

        t = 0;

        ts = int2time(t);

      }

      /* Updates old values */

      old_car_status = actual_car_status;

      old_acc = acc;

      old_speed = actual_speed;

    }  // end crashed

    task_endcycle();

    // Esce se e' morto

    if (killed) return 0;

  }

}

/* ------------------------------------------------------------------ */

void car_crash(PID sp, PID cp, point_f old_pos, int free)

{

  point p1, p2;

  p1.x = round(old_pos.x) - CAR_WIDTH/2 - 1;

  p1.y = round(old_pos.y) - CAR_HEIGHT/2 - 1;

  p2.x = p1.x + CAR_WIDTH + 1;

  p2.y = p1.y + CAR_HEIGHT + 1;

  sem_wait(&grx_mutex);

  /* Find the track box to redraw */

  put_trackbox(p1.x,p1.y,p2.x,p2.y);

  if (free == 0) {

    // Draw the explosion

    put_transimage(p1.x+1,p1.y+1,p2.x-1,p2.y-1,&sprite[16][0],0,0);

  }

  else if (free == 1) {

    // Delete the explosion

    put_trackbox(p1.x,p1.y,p2.x,p2.y);

    task_kill(sp);

    task_kill(cp);

  }

  sem_post(&grx_mutex);

}

/* ------------------------------------------------------------------ */

void draw_car(point_f old_pos, car_status cs, int car_color, int fumo)

{

  int index;

  point p1, p2;

  p1.x = round(old_pos.x) - CAR_WIDTH/2 - 1;

  p1.y = round(old_pos.y) - CAR_HEIGHT/2 - 1;

  p2.x = p1.x + CAR_WIDTH + 1;

  p2.y = p1.y + CAR_HEIGHT + 1;

  sem_wait(&grx_mutex);

  /* Find the track box to redraw */

  put_trackbox(p1.x,p1.y,p2.x,p2.y);

  p1.x = round(cs.pos.x) + (CAR_WIDTH/2  * cos(degree_to_rad(cs.orient)));

  p1.y = round(cs.pos.y) - (CAR_HEIGHT/2 * sin(degree_to_rad(cs.orient)));

  p2.x = round(cs.pos.x) - (CAR_WIDTH/2  * cos(degree_to_rad(cs.orient)));

  p2.y = round(cs.pos.y) + (CAR_HEIGHT/2 * sin(degree_to_rad(cs.orient)));

  index = ((((int)cs.orient%360)+360)%360);

  index = (int)(index + 11.25)%360;

  index /= 22.5;

  put_transimage(round(cs.pos.x) - CAR_WIDTH/2 + 1,round(cs.pos.y) - CAR_HEIGHT/2 + 1,

                 round(cs.pos.x) + CAR_WIDTH/2 ,round(cs.pos.y) + CAR_HEIGHT/2,

                 &sprite[index][0], car_color, 0);

  if (fumo)

    put_transimage(round(cs.pos.x) - CAR_WIDTH/2 + 1,round(cs.pos.y) - CAR_HEIGHT/2 + 1,

                   round(cs.pos.x) + CAR_WIDTH/2 ,round(cs.pos.y) + CAR_HEIGHT/2,

                   &sprite[17][0], car_color, 0);

  sem_post(&grx_mutex);

}

/* ------------------------------------------------------------------ */

/* Copy a box of track_image to screen */

void put_trackbox(int x1, int y1, int x2, int y2)

{

  int y;

  int tx1,ty1,tx2,ty2;

  BYTE *addr;

  tx1 = x1-TRACK_X1+1;

  ty1 = y1-TRACK_Y1;

  tx2 = x2-TRACK_X1+1;

  ty2 = y2-TRACK_Y1;

  if (tx1 < 0)  tx1 = 0;

  if (ty1 < 0)  ty1 = 0;

  if (tx2 > TRACK_WIDTH-1)      tx2 = TRACK_WIDTH-1;

  if (ty2 > TRACK_HEIGHT-1)     ty2 = TRACK_HEIGHT-1;

  tx1 = max(tx1,0);

  ty1 = max(ty1,0);

  tx2 = min(tx2,TRACK_WIDTH-1);

  ty2 = min(ty2,TRACK_HEIGHT-1);

  addr = &track_img[0] + tx1 + TRACK_WIDTH * ty1;

  x1 = max(0,x1);

  y1 = max(0,y1);

  for (y = y1; y <= y2; y++) {

    grx_putimage(x1+1, y, x2, y, addr);

    addr += TRACK_WIDTH;

  }

}

/* ------------------------------------------------------------------ */

void put_transimage(int x1, int y1, int x2, int y2, BYTE *img, int car_color,

                    int color)

{

  int x,y;

  BYTE *addr;

  addr = img;

  for (y = y1; y < y2; y++) {

    for ( x = x1; x < x2; x++, addr++) {

      if (*addr != color) {

        if (*addr == 26)

          grx_plot(x,y,car_color);

        else

          grx_plot(x,y,*addr);

      }

    }

    addr++;

  }

}

/* ------------------------------------------------------------------ */

void show_display(int rs, int ca, float speed, float max_speed,

                  float acc, float max_acc) {

  point hw, mx, mz;     // three road states

  point tl, ct, tr;     // three car alignments

  point sp1, sp2;               // speed display coordinates

  point ap1, ap2;               // acceleration display coordinates

  int s_amp = 0;

  int a_amp = 0;

  /* Leds coordinates */

  hw.x = 10;

  hw.y = SCREEN_HEIGHT-50;

  mx.x = 25;

  mx.y = SCREEN_HEIGHT-50;

  mz.x = 40;

  mz.y = SCREEN_HEIGHT-50;

  tl.x = 10;

  tl.y = SCREEN_HEIGHT-35;

  ct.x = 25;

  ct.y = SCREEN_HEIGHT-35;

  tr.x = 40;

  tr.y = SCREEN_HEIGHT-35;

  sp1.x = 10;

  sp1.y = SCREEN_HEIGHT-75;

  sp2.x = 110;

  sp2.y = SCREEN_HEIGHT-65;

  ap1.x = 10;

  ap1.y = SCREEN_HEIGHT-90;

  ap2.x = 110;

  ap2.y = SCREEN_HEIGHT-80;

  sem_wait(&grx_mutex);

  /* Writes out controller titles */

  grx_text("Road",  mz.x+15, mz.y, YELLOW, BLACK);

  grx_text("Curve", tr.x+15, tr.y, YELLOW, BLACK);

  switch (rs)

    {

    case HIGHWAY:

      grx_box(hw.x, hw.y, hw.x+10, hw.y+10, GREEN);

      grx_box(mx.x, mx.y, mx.x+10, mx.y+10, BLACK);

      grx_box(mz.x, mz.y, mz.x+10, mz.y+10, BLACK);

      break;

    case MIXED:

      grx_box(hw.x, hw.y, hw.x+10, hw.y+10, BLACK);

      grx_box(mx.x, mx.y, mx.x+10, mx.y+10, YELLOW);

      grx_box(mz.x, mz.y, mz.x+10, mz.y+10, BLACK);

      break;

    case MAZE:

      grx_box(hw.x, hw.y, hw.x+10, hw.y+10, BLACK);

      grx_box(mx.x, mx.y, mx.x+10, mx.y+10, BLACK);

      grx_box(mz.x, mz.y, mz.x+10, mz.y+10, RED);

      break;

    }

  switch (ca)

    {

    case TOO_LEFT:

      grx_box(tl.x, tl.y, tl.x+10, tl.y+10, RED);

      grx_box(ct.x, ct.y, ct.x+10, ct.y+10, BLACK);

      grx_box(tr.x, tr.y, tr.x+10, tr.y+10, BLACK);

      break;

    case TOO_RIGHT:

      grx_box(tl.x, tl.y, tl.x+10, tl.y+10, BLACK);

      grx_box(ct.x, ct.y, ct.x+10, ct.y+10, BLACK);

      grx_box(tr.x, tr.y, tr.x+10, tr.y+10, BLUE);

      break;

    default:

      grx_box(tl.x, tl.y, tl.x+10, tl.y+10, BLACK);

      grx_box(ct.x, ct.y, ct.x+10, ct.y+10, WHITE);

      grx_box(tr.x, tr.y, tr.x+10, tr.y+10, BLACK);

    }

  /* Draws speed display */

  grx_text("Speed", sp1.x+120, sp1.y, YELLOW, BLACK);

  grx_rect(sp1.x-1, sp1.y-1, sp2.x+1, sp2.y+1, GREEN);

  /* Updates speed display */

  grx_box(sp1.x, sp1.y, sp2.x, sp2.y, BLACK);

  s_amp = round( (speed * (float)(sp2.x-sp1.x)) / max_speed );

  grx_box(sp1.x, sp1.y, sp1.x+s_amp, sp2.y, LIGHTGRAY);

        /* Draws acceleration display */

  grx_text("Acceleration", ap1.x+120, ap1.y, YELLOW, BLACK);

  grx_rect(ap1.x-1, ap1.y-1, ap2.x+1, ap2.y+1, GREEN);

  /* Updates acceleration display */

  grx_box(ap1.x, ap1.y, ap2.x, ap2.y, BLACK);

  a_amp = round( (float)acc * (float)((ap2.x-ap1.x)/2) / (float)max_acc );

  if (a_amp >= 0)

    grx_box((ap1.x+ap2.x)/2, ap1.y, ((ap1.x+ap2.x)/2)+a_amp, ap2.y, LIGHTGRAY);

  else

    grx_box((ap1.x+ap2.x)/2+a_amp, ap1.y, ((ap1.x+ap2.x)/2), ap2.y, LIGHTGRAY);

  grx_line((ap1.x+ap2.x)/2, ap1.y-2, (ap1.x+ap2.x)/2, ap2.y+2, WHITE);

  sem_post(&grx_mutex);

}