Subversion Repositories shark

Rev

Rev 1386 | Rev 1547 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1098 pj 1
/*
2
 * Project: S.Ha.R.K.
3
 *
4
 * Coordinators:
5
 *   Giorgio Buttazzo    <giorgio@sssup.it>
6
 *   Paolo Gai           <pj@gandalf.sssup.it>
7
 *
8
 * Authors     :
9
 *   Paolo Gai           <pj@gandalf.sssup.it>
10
 *   (see the web pages for full authors list)
11
 *
12
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
13
 *
14
 * http://www.sssup.it
15
 * http://retis.sssup.it
16
 * http://shark.sssup.it
17
 */
18
 
19
/*
20
 * Copyright (C) 2000 Giorgio Buttazzo, Paolo Gai
21
 *
22
 * This program is free software; you can redistribute it and/or modify
23
 * it under the terms of the GNU General Public License as published by
24
 * the Free Software Foundation; either version 2 of the License, or
25
 * (at your option) any later version.
26
 *
27
 * This program is distributed in the hope that it will be useful,
28
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
30
 * GNU General Public License for more details.
31
 *
32
 * You should have received a copy of the GNU General Public License
33
 * along with this program; if not, write to the Free Software
34
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
35
 *
36
 *
1398 giacomo 37
 * CVS :        $Id: cabs.c,v 1.7 2004-04-23 07:57:33 giacomo Exp $
1098 pj 38
 */
39
 
1085 pj 40
/*--------------------------------------------------------------*/
41
/*                    TEST ON CABS                              */
42
/*--------------------------------------------------------------*/
43
 
44
#include <kernel/kern.h>
45
#include <modules/cabs.h>
46
#include <string.h>
47
 
1377 giacomo 48
#include <drivers/shark_fb26.h>
49
#include <drivers/shark_keyb26.h>
50
 
1085 pj 51
#define NCAB    4               /* max number of CABs   */
52
#define NCAR    26              /* generated characters */
53
 
54
#define YP      32              /* level of arrows      */
55
#define R       20              /* task radius          */
56
#define YY      (YP+R+32)       /* level of writing     */
57
#define DELTA   (2*R+72)        /* total channel hight  */
58
#define X1      120             /* start column for P1  */
59
#define X2      360             /* start column for P2  */
60
 
61
#define XP1     (X1+64)         /* X position of task 1 */
62
#define XP2     (X2+64)         /* X position of task 2 */
63
#define XC      (XP1+96)        /* X position of CAB    */
64
#define L       52              /* CAB rectangle length */
65
 
66
void    my_exit(KEY_EVT *k);
67
void    draw_channel(int i);
68
void    create_channel(int i);
69
void    get_data();
70
 
71
TASK    producer(void *arg);
72
TASK    consumer(void *arg);
73
 
74
char    *cname[NCAB] = {"cab1", "cab2", "cab3", "cab4"};
75
char    *pname1[NCAB] = {"wr1", "wr2", "wr3", "wr4"};
76
char    *pname2[NCAB] = {"rd1", "rd2", "rd3", "rd4"};
77
 
78
CAB     cid[NCAB];              /* CAB identifiers      */
79
PID     p1[NCAB], p2[NCAB];     /* task identifiers     */
80
 
81
/* Task Periods */
82
TIME    t1[NCAB] = {200000, 100000, 300000, 800000};
83
TIME    t2[NCAB] = {400000, 400000, 150000, 200000};
84
 
85
/* Task WCETS */
86
TIME    w1[NCAB] = {10000, 10000, 10000, 10000};
87
TIME    w2[NCAB] = {10000, 10000, 10000, 10000};
88
 
89
/****************************************************************/
90
 
91
/* This function is called when Alt-X is pressed.
92
*/
93
void my_end(KEY_EVT* e)
94
{
1382 giacomo 95
        sys_end();
1085 pj 96
}
97
 
98
/******************************************************************/
99
 
100
/* This function is called when the system exit correctly after Alt-X.
101
   It exits from the graphic mode and then it prints a small greeting.
102
   Note that:
103
   - The function calls grx_exit, so it must be registered using
104
     RUNLEVEL_BEFORE_EXIT (RUNLEVEL_AFTER_EXIT does not work because
105
     at that point the kernel is already returned in real mode!!!)
106
   - When an exception is raised, the exception handler is called.
107
     Since the exception handler already exits from the graphic mode,
108
     this funcion has not to be called. For this reason:
109
     . we registered byebye using the flag NO_AT_ABORT
110
     . the exception handler exits using sys_abort; in that way byebye is
111
       NOT called
112
*/
113
 
114
/*--------------------------------------------------------------*/
115
/* Main task                                                    */
116
/*--------------------------------------------------------------*/
117
 
118
/****************************** MAIN ******************************/
119
 
120
int main(int argc, char **argv)
121
{
122
    char c = 0;         /* character from keyboard      */
123
 
124
    grx_clear(BLACK);
125
 
1386 giacomo 126
    grx_text("Press a key [1-4]", 10, 16, rgb16(255,255,255), 0);
127
    grx_text("to create a pair",  10, 24, rgb16(255,255,255), 0);
128
    grx_text("ESC to exit demo",  10, 48, rgb16(255,255,255), 0);
1085 pj 129
 
130
    while (c != 27) {
131
      c = keyb_getch(BLOCK);
132
      if ((c >= '1') && (c <= '1'+NCAB-1))
133
        create_channel(c-'1');
134
    }
135
 
1382 giacomo 136
    sys_end();
1085 pj 137
 
138
    return 0;
139
}
140
 
141
 
142
/*--------------------------------------------------------------*/
143
/* write data in a cab                                          */
144
/*--------------------------------------------------------------*/
145
 
146
TASK    producer(void *arg)
147
{
148
int     i = (int)arg;
149
char    c;                      /* message character            */
150
char    *p;                     /* pointer to a cab buffer      */
151
char    s[2];                   /* string to display            */
152
int     k = 0;
153
int     x, y;
1386 giacomo 154
int     col = rgb16(0,0,255);
1085 pj 155
int     ybase = YY + i*DELTA;
156
 
157
        x = X1;
158
        y = ybase;
159
        s[1] = 0;
160
 
161
        k = 0;
162
        while (1) {
163
                c = 'A' + k;
164
                p = cab_reserve(cid[i]);
165
                *p = c;
166
                cab_putmes(cid[i], p);
167
 
168
                s[0] = c;
169
                k = (k + 1) % NCAR;
170
                grx_text(s,x,y,col,0);
171
 
172
                x += 8;
173
                if (x >= (X1 + NCAR*8)) {
174
                        x = X1;
175
                        y = y + 8;
176
                        if (y >= ybase+16) {
177
                                y = ybase;
178
                        }
179
                }
180
 
181
                task_endcycle();
182
        }
183
}
184
 
185
/*--------------------------------------------------------------*/
186
/* read data from a cab                                         */
187
/*--------------------------------------------------------------*/
188
 
189
TASK    consumer(void *arg)
190
{
191
int     i = (int)arg;
192
char    *p;
193
char    s[2];
194
int     x, y;
195
int     col = 13;
196
int     ybase = YY + i*DELTA;
197
 
198
        x = X2;
199
        y = ybase;
200
        s[1] = 0;
201
 
202
        while (1) {
203
                p = cab_getmes(cid[i]);
204
                s[0] = *p - 'A' + 'a';
205
                cab_unget(cid[i], p);
206
 
207
                grx_text(s,x,y,col,0);
208
                x += 8;
209
 
210
                if (x >= (X2 + NCAR*8)) {
211
                        x = X2;
212
                        y = y + 8;
213
                        if (y >= ybase+16) {
214
                                y = ybase;
215
                                col = col % 15 + 1;
216
                        }
217
                }
218
                task_endcycle();
219
        }
220
}
221
 
222
/*--------------------------------------------------------------*/
223
/* create the two tasks and a channel                           */
224
/*--------------------------------------------------------------*/
225
 
226
void    create_channel(int i)
227
{
228
        HARD_TASK_MODEL m;
229
 
230
        draw_channel(i);
231
        cid[i] = cab_create(cname[i], 1, 2);
232
 
233
        hard_task_default_model(m);
234
        hard_task_def_ctrl_jet (m);
235
        hard_task_def_arg      (m, (void *)i);
236
        hard_task_def_wcet     (m, w1[i]);
237
        hard_task_def_mit      (m, t1[i]);
238
        hard_task_def_usemath  (m);
239
        p1[i] = task_create(pname1[i], producer, &m, NULL);
240
        if (p1[i] == NIL) {
1377 giacomo 241
          sys_shutdown_message("Could not create task <producer>");
1382 giacomo 242
          sys_end();
1377 giacomo 243
          return;
1085 pj 244
        }
245
        task_activate(p1[i]);
246
 
247
        hard_task_default_model(m);
248
        hard_task_def_ctrl_jet (m);
249
        hard_task_def_arg      (m, (void *)i);
250
        hard_task_def_wcet     (m, w2[i]);
251
        hard_task_def_mit      (m, t2[i]);
252
        hard_task_def_usemath  (m);
253
        p2[i] = task_create(pname2[i], consumer, &m, NULL);
254
        if (p2[i] == NIL) {
1377 giacomo 255
          sys_shutdown_message("Could not create task <consumer>");
1382 giacomo 256
          sys_end();
1377 giacomo 257
          return;
1085 pj 258
        }
259
        task_activate(p2[i]);
260
}
261
 
262
/*--------------------------------------------------------------*/
263
/* Disegna i processi e il canale di comunicazione              */
264
/*--------------------------------------------------------------*/
265
 
266
void    draw_channel(int i)
267
{
268
char    buffer[32];                     /* buffer per sprintf   */
269
int     yc = YP + i*DELTA;              /* altezza del canale   */
270
 
1386 giacomo 271
        grx_circle(XP1,yc,R,rgb16(255,0,0));
272
        grx_text("P1",XP1-8,yc-4,rgb16(255,255,255),0);
1085 pj 273
 
1386 giacomo 274
        grx_circle(XP2,yc,R,rgb16(255,0,0));
275
        grx_text("P2",XP2-8,yc-4,rgb16(255,255,255),0);
1085 pj 276
 
1386 giacomo 277
        grx_rect(XC,yc-R,XC+L,yc+R,rgb16(255,255,255));
278
        grx_text("CAB",XC+16,yc-4,rgb16(255,255,255),0);
1085 pj 279
 
1386 giacomo 280
        grx_line(XP1+R,yc,XC,yc,rgb16(255,255,255));
281
        grx_line(XC+L,yc,XP2-R,yc,rgb16(255,255,255));
1085 pj 282
 
1386 giacomo 283
        grx_text("T1 =          ms",X1+40,yc+R+16,rgb16(255,255,255),0);
1085 pj 284
        sprintf(buffer,"%ld", t1[i]);
1386 giacomo 285
        grx_text(buffer,X1+88,yc+R+16,rgb16(255,255,255),0);
1085 pj 286
 
1386 giacomo 287
        grx_text("T2 =          ms",X2+40,yc+R+16,rgb16(255,255,255),0);
1085 pj 288
        sprintf(buffer,"%ld", t2[i]);
1386 giacomo 289
        grx_text(buffer,X2+88,yc+R+16,rgb16(255,255,255),0);
1085 pj 290
}