OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [doc/] [html/] [ref/] [compat-uitron-configuration-faq.html] - Blame information for rev 174

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 28 unneback 
<!-- Copyright (C) 2003 Red Hat, Inc.                                -->
2 
<!-- This material may be distributed only subject to the terms      -->
3 
<!-- and conditions set forth in the Open Publication License, v1.0  -->
4 
<!-- or later (the latest version is presently available at          -->
5 
<!-- http://www.opencontent.org/openpub/).                           -->
6 
<!-- Distribution of the work or derivative of the work in any       -->
7 
<!-- standard (paper) book form is prohibited unless prior           -->
8 
<!-- permission is obtained from the copyright holder.               -->
9 
<HTML
10 
><HEAD
11 
><TITLE
12 
>µITRON Configuration FAQ</TITLE
13 
><meta name="MSSmartTagsPreventParsing" content="TRUE">
14 
<META
15 
NAME="GENERATOR"
16 
CONTENT="Modular DocBook HTML Stylesheet Version 1.76b+
17 
"><LINK
18 
REL="HOME"
19 
TITLE="eCos Reference Manual"
20 
HREF="ecos-ref.html"><LINK
21 
REL="UP"
22 
TITLE="µITRON API"
23 
HREF="compat-uitron-microitron-api.html"><LINK
24 
REL="PREVIOUS"
25 
TITLE="   Network Support Functions"
26 
HREF="compat-uitron-network-support-functions.html"><LINK
27 
REL="NEXT"
28 
TITLE="TCP/IP Stack Support for eCos"
29 
HREF="net-common-tcpip.html"></HEAD
30 
><BODY
31 
CLASS="SECT1"
32 
BGCOLOR="#FFFFFF"
33 
TEXT="#000000"
34 
LINK="#0000FF"
35 
VLINK="#840084"
36 
ALINK="#0000FF"
37 
><DIV
38 
CLASS="NAVHEADER"
39 
><TABLE
40 
SUMMARY="Header navigation table"
41 
WIDTH="100%"
42 
BORDER="0"
43 
CELLPADDING="0"
44 
CELLSPACING="0"
45 
><TR
46 
><TH
47 
COLSPAN="3"
48 
ALIGN="center"
49 
>eCos Reference Manual</TH
50 
></TR
51 
><TR
52 
><TD
53 
WIDTH="10%"
54 
ALIGN="left"
55 
VALIGN="bottom"
56 
><A
57 
HREF="compat-uitron-network-support-functions.html"
58 
ACCESSKEY="P"
59 
>Prev</A
60 
></TD
61 
><TD
62 
WIDTH="80%"
63 
ALIGN="center"
64 
VALIGN="bottom"
65 
>Chapter 32. &micro;ITRON API</TD
66 
><TD
67 
WIDTH="10%"
68 
ALIGN="right"
69 
VALIGN="bottom"
70 
><A
71 
HREF="net-common-tcpip.html"
72 
ACCESSKEY="N"
73 
>Next</A
74 
></TD
75 
></TR
76 
></TABLE
77 
><HR
78 
ALIGN="LEFT"
79 
WIDTH="100%"></DIV
80 
><DIV
81 
CLASS="SECT1"
82 
><H1
83 
CLASS="SECT1"
84 
><A
85 
NAME="COMPAT-UITRON-CONFIGURATION-FAQ">&micro;ITRON Configuration FAQ</H1
86 
><P
87 
><SPAN
88 
CLASS="emphasis"
89 
><I
90 
CLASS="EMPHASIS"
91 
>Q: How are &micro;ITRON objects created?</I
92 
></SPAN
93 
></P
94 
><P
95 
>For each type of uITRON object (tasks, semaphores, flags, mboxes, mpf, mpl)
96 
these two quantities are controlled by configuration:</P
97 
><P
98 
></P
99 
><UL
100 
><LI
101 
><P
102 
>The <SPAN
103 
CLASS="emphasis"
104 
><I
105 
CLASS="EMPHASIS"
106 
>maximum</I
107 
></SPAN
108 
> number of this type of object.</P
109 
></LI
110 
><LI
111 
><P
112 
>The number of these objects which exist <SPAN
113 
CLASS="emphasis"
114 
><I
115 
CLASS="EMPHASIS"
116 
>initially</I
117 
></SPAN
118 
>.</P
119 
></LI
120 
></UL
121 
><P
122 
>This is assuming that for the relevant object type,
123 
<SPAN
124 
CLASS="emphasis"
125 
><I
126 
CLASS="EMPHASIS"
127 
>create</I
128 
></SPAN
129 
> and <SPAN
130 
CLASS="emphasis"
131 
><I
132 
CLASS="EMPHASIS"
133 
>delete</I
134 
></SPAN
135 
>
136 
operations are enabled; enabled is the default.  For example, the option
137 
<TT
138 
CLASS="LITERAL"
139 
>CYGPKG_UITRON_MBOXES_CREATE_DELETE</TT
140 
>
141 
controls whether the functions
142 
<TT
143 
CLASS="FUNCTION"
144 
>cre_mbx()</TT
145 
>
146 
and
147 
<TT
148 
CLASS="FUNCTION"
149 
>del_mbx()</TT
150 
>
151 
exist in the API.  If not, then the maximum number of
152 
mboxes is the same as the initial number of mboxes, and so on for all
153 
&micro;ITRON object types.</P
154 
><P
155 
>Mboxes have no initialization, so there are only a few, simple
156 
configuration options:</P
157 
><P
158 
></P
159 
><UL
160 
><LI
161 
><P
162 
><TT
163 
CLASS="LITERAL"
164 
>CYGNUM_UITRON_MBOXES</TT
165 
>
166 
is the total number of mboxes that you can have in the
167 
system.  By default this is 4, so you can use mboxes 1,2,3 and 4.  You
168 
cannot create mboxes outside this range; trying to
169 
<TT
170 
CLASS="FUNCTION"
171 
>cre_mbx(5,...)</TT
172 
>
173 
will return an error.</P
174 
></LI
175 
><LI
176 
><P
177 
><TT
178 
CLASS="LITERAL"
179 
>CYGNUM_UITRON_MBOXES_INITIALLY</TT
180 
>
181 
is the number of mboxes created
182 
automatically for you, during startup.  By default this is 4, so all 4
183 
mboxes exist already, and an attempt to create one of these
184 
eg. <TT
185 
CLASS="FUNCTION"
186 
>cre_mbx(3,...)</TT
187 
>
188 
will return an error because the mbox in quesion already
189 
exists.  You can delete a pre-existing mbox, and then re-create it.</P
190 
></LI
191 
></UL
192 
><P
193 
>If you change
194 
<TT
195 
CLASS="LITERAL"
196 
>CYGNUM_UITRON_MBOXES_INITIALLY</TT
197 
>,
198 
for example to 0, no mboxes
199 
are created automatically for you during startup.  Any attempt to use an
200 
mbox without creating it will return E_NOEXS because the mbox does not
201 
exist.  You can create an mbox, say <TT
202 
CLASS="FUNCTION"
203 
>cre_mbx(3,...)</TT
204 
>
205 
and then use it, say
206 
<TT
207 
CLASS="FUNCTION"
208 
>snd_msg(3,&amp;foo)</TT
209 
>, and all will be well.</P
210 
><P
211 
><SPAN
212 
CLASS="emphasis"
213 
><I
214 
CLASS="EMPHASIS"
215 
>Q: How are &micro;ITRON objects initialized?</I
216 
></SPAN
217 
></P
218 
><P
219 
>Some object types have optional initialization.  Semaphores are an
220 
example.  You could have
221 
<TT
222 
CLASS="LITERAL"
223 
>CYGNUM_UITRON_SEMAS</TT
224 
>=10 and
225 
<TT
226 
CLASS="LITERAL"
227 
>CYGNUM_UITRON_SEMAS_INITIALLY</TT
228 
>=5
229 
which means you can use semaphores 1-5
230 
straight off, but you must create semaphores 6-10 before you can use them.
231 
If you decide not to initialize semaphores, semaphores 1-5 will have an
232 
initial count of zero.  If you decide to initialize them, you must supply
233 
a dummy initializer for semaphores 6-10 also.  For example,
234 
in terms of the configuration output in
235 
<TT
236 
CLASS="FILENAME"
237 
>pkgconf/uitron.h</TT
238 
>:</P
239 
><TABLE
240 
BORDER="5"
241 
BGCOLOR="#E0E0F0"
242 
WIDTH="70%"
243 
><TR
244 
><TD
245 
><PRE
246 
CLASS="PROGRAMLISTING"
247 
>   #define CYGDAT_UITRON_SEMA_INITIALIZERS \
248 
        CYG_UIT_SEMA(  1 ),     \
249 
        CYG_UIT_SEMA(  0 ),     \
250 
        CYG_UIT_SEMA(  0 ),     \
251 
        CYG_UIT_SEMA( 99 ),     \
252 
        CYG_UIT_SEMA(  1 ),     \
253 
        CYG_UIT_SEMA_NOEXS,     \
254 
        CYG_UIT_SEMA_NOEXS,     \
255 
        CYG_UIT_SEMA_NOEXS,     \
256 
        CYG_UIT_SEMA_NOEXS,     \
257 
        CYG_UIT_SEMA_NOEXS</PRE
258 
></TD
259 
></TR
260 
></TABLE
261 
><P
262 
>Semaphore 1 will have initial count 1, semaphores 2 and 3 will be zero,
263 
number 4 will be 99 initially, 5 will be one and numbers 6 though 10 do not
264 
exist initially.</P
265 
><P
266 
>Aside: this is how the definition of the symbol would appear in the
267 
configuration header file <TT
268 
CLASS="FILENAME"
269 
>pkgconf/uitron.h</TT
270 
> &#8212;
271 
unfortunately editing such a long, multi-line definition is somewhat
272 
cumbersome in the GUI config tool in current releases.  The macros
273 
<TT
274 
CLASS="LITERAL"
275 
>CYG_UIT_SEMA()</TT
276 
>
277 
&#8212; to create a semaphore initializer &#8212; and
278 
<TT
279 
CLASS="LITERAL"
280 
>CYG_UIT_SEMA_NOEXS</TT
281 
>
282 
&#8212; to invoke a dummy initializer &#8212;
283 
are provided in in the environment to help with this.  Similar macros are
284 
provided for other object types.  The resulting #define symbol is used in
285 
the context of a C++ array initializer, such as:
286 
<TABLE
287 
BORDER="5"
288 
BGCOLOR="#E0E0F0"
289 
WIDTH="70%"
290 
><TR
291 
><TD
292 
><PRE
293 
CLASS="PROGRAMLISTING"
294 
>Cyg_Counting_Semaphore2 cyg_uitron_SEMAS[ CYGNUM_UITRON_SEMAS ] = {
295 
        CYGDAT_UITRON_SEMA_INITIALIZERS
296 
};</PRE
297 
></TD
298 
></TR
299 
></TABLE
300 
>
301 
which is eventually macro-processed to give
302 
<TABLE
303 
BORDER="5"
304 
BGCOLOR="#E0E0F0"
305 
WIDTH="70%"
306 
><TR
307 
><TD
308 
><PRE
309 
CLASS="PROGRAMLISTING"
310 
>Cyg_Counting_Semaphore2 cyg_uitron_SEMAS[ 10 ] = {
311 
        Cyg_Counting_Semaphore2( ( 1 ) ),
312 
        Cyg_Counting_Semaphore2( ( 0 ) ),
313 
        Cyg_Counting_Semaphore2( ( 0 ) ),
314 
        Cyg_Counting_Semaphore2( ( 99 ) ),
315 
        Cyg_Counting_Semaphore2( ( 1 ) ),
316 
        Cyg_Counting_Semaphore2(0),
317 
        Cyg_Counting_Semaphore2(0),
318 
        Cyg_Counting_Semaphore2(0),
319 
        Cyg_Counting_Semaphore2(0),
320 
        Cyg_Counting_Semaphore2(0),
321 
};</PRE
322 
></TD
323 
></TR
324 
></TABLE
325 
>
326 
so you can see how it is necessary to include the dummy entries in that
327 
definition, otherwise the resulting code will not compile correctly.</P
328 
><P
329 
>If you choose
330 
<TT
331 
CLASS="LITERAL"
332 
>CYGNUM_UITRON_SEMAS_INITIALLY</TT
333 
>=0
334 
it is meaningless to initialize them, for they must be created and so
335 
initialized then, before use.</P
336 
><P
337 
><SPAN
338 
CLASS="emphasis"
339 
><I
340 
CLASS="EMPHASIS"
341 
>Q: What about &micro;ITRON tasks?</I
342 
></SPAN
343 
></P
344 
><P
345 
>Some object types require initialization.  Tasks are an example of this.
346 
You must provide a task with a priority, a function to enter when the task
347 
starts, a name (for debugging purposes), and some memory to use for the stack.
348 
For example (again in terms of the resulting
349 
definitions in <TT
350 
CLASS="FILENAME"
351 
>pkgconf/uitron.h</TT
352 
>):</P
353 
><TABLE
354 
BORDER="5"
355 
BGCOLOR="#E0E0F0"
356 
WIDTH="70%"
357 
><TR
358 
><TD
359 
><PRE
360 
CLASS="PROGRAMLISTING"
361 
>#define CYGNUM_UITRON_TASKS 4           // valid task ids are 1,2,3,4
362 
#define CYGNUM_UITRON_TASKS_INITIALLY 4 // they all exist at start
363 
 
364 
#define CYGDAT_UITRON_TASK_EXTERNS              \
365 
extern "C" void startup( unsigned int );        \
366 
extern "C" void worktask( unsigned int );       \
367 
extern "C" void lowtask( unsigned int );        \
368 
static char stack1[ CYGNUM_UITRON_STACK_SIZE ], \
369 
            stack2[ CYGNUM_UITRON_STACK_SIZE ], \
370 
            stack3[ CYGNUM_UITRON_STACK_SIZE ], \
371 
            stack4[ CYGNUM_UITRON_STACK_SIZE ];
372 
 
373 
#define CYGDAT_UITRON_TASK_INITIALIZERS \
374 
 CYG_UIT_TASK("main task", 8, startup,  &amp;stack1, sizeof( stack1 )), \
375 
 CYG_UIT_TASK("worker 2" , 9, worktask, &amp;stack2, sizeof( stack2 )), \
376 
 CYG_UIT_TASK("worker 3" , 9, worktask, &amp;stack3, sizeof( stack3 )), \
377 
 CYG_UIT_TASK("low task" ,20, lowtask,  &amp;stack4, sizeof( stack4 )), \&#13;</PRE
378 
></TD
379 
></TR
380 
></TABLE
381 
><P
382 
>So this example has all four tasks statically configured to exist, ready to
383 
run, from the start of time.  The &#8220;main task&#8221; runs a routine
384 
called <TT
385 
CLASS="FUNCTION"
386 
>startup()</TT
387 
> at priority 8.  Two
388 
&#8220;worker&#8221; tasks run both a priority 9, and a &#8220;low
389 
priority&#8221; task runs at priority 20 to do useful non-urgent background
390 
work.</P
391 
><TABLE
392 
BORDER="5"
393 
BGCOLOR="#E0E0F0"
394 
WIDTH="70%"
395 
><TR
396 
><TD
397 
><PRE
398 
CLASS="SCREEN"
399 
>Task ID | Exists at | Function | Priority | Stack   | Stack
400 
 number |  startup  |  entry   |          | address | size
401 
--------+-----------+----------+----------+---------+----------
402 
   1    |    Yes    |  startup |    8     | &amp;stack1 | CYGNUM...
403 
   2    |    Yes    | worktask |    9     | &amp;stack2 | CYGNUM...
404 
   3    |    Yes    | worktask |    9     | &amp;stack3 | CYGNUM...
405 
   4    |    Yes    |  lowtask |   20     | &amp;stack4 | CYGNUM...
406 
--------+-----------+----------+----------+---------+----------</PRE
407 
></TD
408 
></TR
409 
></TABLE
410 
><P
411 
><SPAN
412 
CLASS="emphasis"
413 
><I
414 
CLASS="EMPHASIS"
415 
>Q: How can I create &micro;ITRON tasks in the program?</I
416 
></SPAN
417 
></P
418 
><P
419 
>You must provide free slots in the task table in which to create new tasks,
420 
by configuring the number of tasks existing initially to be smaller than
421 
the total.
422 
For a task ID which does not initially exist, it will be told what routine
423 
to call, and what priority it is, when the task is created.  But you must
424 
still set aside memory for the task to use for its stack, and give it a
425 
name during initialization.  For example:</P
426 
><TABLE
427 
BORDER="5"
428 
BGCOLOR="#E0E0F0"
429 
WIDTH="70%"
430 
><TR
431 
><TD
432 
><PRE
433 
CLASS="PROGRAMLISTING"
434 
>#define CYGNUM_UITRON_TASKS 4           // valid task ids are 1-4
435 
#define CYGNUM_UITRON_TASKS_INITIALLY 1 // only task #1 exists
436 
 
437 
#define CYGDAT_UITRON_TASK_EXTERNS \
438 
extern "C" void startup( unsigned int ); \
439 
static char stack1[ CYGNUM_UITRON_STACK_SIZE ], \
440 
            stack2[ CYGNUM_UITRON_STACK_SIZE ], \
441 
            stack3[ CYGNUM_UITRON_STACK_SIZE ], \
442 
            stack4[ CYGNUM_UITRON_STACK_SIZE ];
443 
 
444 
#define CYGDAT_UITRON_TASK_INITIALIZERS \
445 
   CYG_UIT_TASK( "main", 8, startup, &amp;stack1, sizeof( stack1 ) ), \
446 
   CYG_UIT_TASK_NOEXS( "slave",      &amp;stack2, sizeof( stack2 ) ), \
447 
   CYG_UIT_TASK_NOEXS( "slave2",     &amp;stack3, sizeof( stack3 ) ), \
448 
   CYG_UIT_TASK_NOEXS( "slave3",     &amp;stack4, sizeof( stack4 ) ), \&#13;</PRE
449 
></TD
450 
></TR
451 
></TABLE
452 
><P
453 
>So tasks numbered 2,3 and 4 have been given their stacks during startup,
454 
though they do not yet exist in terms of <TT
455 
CLASS="FUNCTION"
456 
>cre_tsk()</TT
457 
> and
458 
<TT
459 
CLASS="FUNCTION"
460 
>del_tsk()</TT
461 
> so you can create tasks 2&#8211;4 at
462 
runtime.</P
463 
><TABLE
464 
BORDER="5"
465 
BGCOLOR="#E0E0F0"
466 
WIDTH="70%"
467 
><TR
468 
><TD
469 
><PRE
470 
CLASS="SCREEN"
471 
>Task ID | Exists at | Function | Priority | Stack   | Stack
472 
 number |  startup  |  entry   |          | address | size
473 
--------+-----------+----------+----------+---------+----------
474 
   1    |    Yes    |  startup |    8     | &amp;stack1 | CYGNUM...
475 
   2    |    No     |   N/A    |   N/A    | &amp;stack2 | CYGNUM...
476 
   3    |    No     |   N/A    |   N/A    | &amp;stack3 | CYGNUM...
477 
   4    |    No     |   N/A    |   N/A    | &amp;stack4 | CYGNUM...
478 
--------+-----------+----------+----------+---------+----------</PRE
479 
></TD
480 
></TR
481 
></TABLE
482 
><P
483 
>(you must have at least one task at startup in order that the system can
484 
 actually run; this is not so for other uITRON object types)</P
485 
><P
486 
><SPAN
487 
CLASS="emphasis"
488 
><I
489 
CLASS="EMPHASIS"
490 
>Q: Can I have different stack sizes for &micro;ITRON tasks?</I
491 
></SPAN
492 
></P
493 
><P
494 
>Simply set aside different amounts of memory for each task to use for its
495 
stack.  Going back to a typical default setting for the &micro;ITRON tasks,
496 
the definitions in <TT
497 
CLASS="FILENAME"
498 
>pkgconf/uitron.h</TT
499 
> might look like this:</P
500 
><TABLE
501 
BORDER="5"
502 
BGCOLOR="#E0E0F0"
503 
WIDTH="70%"
504 
><TR
505 
><TD
506 
><PRE
507 
CLASS="PROGRAMLISTING"
508 
>#define CYGDAT_UITRON_TASK_EXTERNS \
509 
extern "C" void task1( unsigned int ); \
510 
extern "C" void task2( unsigned int ); \
511 
extern "C" void task3( unsigned int ); \
512 
extern "C" void task4( unsigned int ); \
513 
static char stack1[ CYGNUM_UITRON_STACK_SIZE ], \
514 
            stack2[ CYGNUM_UITRON_STACK_SIZE ], \
515 
            stack3[ CYGNUM_UITRON_STACK_SIZE ], \
516 
            stack4[ CYGNUM_UITRON_STACK_SIZE ];
517 
 
518 
#define CYGDAT_UITRON_TASK_INITIALIZERS \
519 
  CYG_UIT_TASK( "t1", 1, task1, &amp;stack1, CYGNUM_UITRON_STACK_SIZE ), \
520 
  CYG_UIT_TASK( "t2", 2, task2, &amp;stack2, CYGNUM_UITRON_STACK_SIZE ), \
521 
  CYG_UIT_TASK( "t3", 3, task3, &amp;stack3, CYGNUM_UITRON_STACK_SIZE ), \
522 
  CYG_UIT_TASK( "t4", 4, task4, &amp;stack4, CYGNUM_UITRON_STACK_SIZE )&#13;</PRE
523 
></TD
524 
></TR
525 
></TABLE
526 
><P
527 
>Note that
528 
<TT
529 
CLASS="LITERAL"
530 
>CYGNUM_UITRON_STACK_SIZE</TT
531 
>
532 
is used to control the size of the stack
533 
objects themselves, and to tell the system what size stack is being provided.</P
534 
><P
535 
>Suppose instead stack sizes of 2000, 1000, 800 and 800 were required:
536 
this could be achieved by using the GUI config tool to edit these
537 
options, or editting the <TT
538 
CLASS="FILENAME"
539 
>.ecc</TT
540 
> file to get these
541 
results in <TT
542 
CLASS="FILENAME"
543 
>pkgconf/uitron.h</TT
544 
>:</P
545 
><TABLE
546 
BORDER="5"
547 
BGCOLOR="#E0E0F0"
548 
WIDTH="70%"
549 
><TR
550 
><TD
551 
><PRE
552 
CLASS="PROGRAMLISTING"
553 
>#define CYGDAT_UITRON_TASK_EXTERNS \
554 
extern "C" void task1( unsigned int ); \
555 
extern "C" void task2( unsigned int ); \
556 
extern "C" void task3( unsigned int ); \
557 
extern "C" void task4( unsigned int ); \
558 
static char stack1[ 2000 ], \
559 
            stack2[ 1000 ], \
560 
            stack3[  800 ], \
561 
            stack4[  800 ];
562 
 
563 
#define CYGDAT_UITRON_TASK_INITIALIZERS \
564 
      CYG_UIT_TASK( "t1", 1, task1, &amp;stack1, sizeof( stack1 ) ), \
565 
      CYG_UIT_TASK( "t2", 2, task2, &amp;stack2, sizeof( stack2 ) ), \
566 
      CYG_UIT_TASK( "t3", 3, task3, &amp;stack3, sizeof( stack3 ) ), \
567 
      CYG_UIT_TASK( "t4", 4, task4, &amp;stack4, sizeof( stack4 ) )</PRE
568 
></TD
569 
></TR
570 
></TABLE
571 
><P
572 
>Note that the sizeof() operator has been used to tell the system what size
573 
stacks are provided, rather than quoting a number (which is difficult for
574 
maintenance) or the symbol
575 
<TT
576 
CLASS="LITERAL"
577 
>CYGNUM_UITRON_STACK_SIZE</TT
578 
>
579 
(which is wrong).</P
580 
><P
581 
>We recommend using (if available in your release) the stacksize symbols
582 
provided in the architectural HAL for your target, called
583 
<TT
584 
CLASS="LITERAL"
585 
>CYGNUM_HAL_STACK_SIZE_TYPICAL</TT
586 
>
587 
and
588 
<TT
589 
CLASS="LITERAL"
590 
>CYGNUM_HAL_STACK_SIZE_MINIMUM</TT
591 
>.
592 
So a better (more portable) version of the above might be:</P
593 
><TABLE
594 
BORDER="5"
595 
BGCOLOR="#E0E0F0"
596 
WIDTH="70%"
597 
><TR
598 
><TD
599 
><PRE
600 
CLASS="PROGRAMLISTING"
601 
>#define CYGDAT_UITRON_TASK_EXTERNS \
602 
extern "C" void task1( unsigned int ); \
603 
extern "C" void task2( unsigned int ); \
604 
extern "C" void task3( unsigned int ); \
605 
extern "C" void task4( unsigned int ); \
606 
static char stack1[ CYGNUM_HAL_STACK_SIZE_TYPICAL + 1200 ], \
607 
            stack2[ CYGNUM_HAL_STACK_SIZE_TYPICAL +  200 ], \
608 
            stack3[ CYGNUM_HAL_STACK_SIZE_TYPICAL        ], \
609 
            stack4[ CYGNUM_HAL_STACK_SIZE_TYPICAL        ];
610 
 
611 
#define CYGDAT_UITRON_TASK_INITIALIZERS \
612 
      CYG_UIT_TASK( "t1", 1, task1, &amp;stack1, sizeof( stack1 ) ), \
613 
      CYG_UIT_TASK( "t2", 2, task2, &amp;stack2, sizeof( stack2 ) ), \
614 
      CYG_UIT_TASK( "t3", 3, task3, &amp;stack3, sizeof( stack3 ) ), \
615 
      CYG_UIT_TASK( "t4", 4, task4, &amp;stack4, sizeof( stack4 ) )</PRE
616 
></TD
617 
></TR
618 
></TABLE
619 
></DIV
620 
><DIV
621 
CLASS="NAVFOOTER"
622 
><HR
623 
ALIGN="LEFT"
624 
WIDTH="100%"><TABLE
625 
SUMMARY="Footer navigation table"
626 
WIDTH="100%"
627 
BORDER="0"
628 
CELLPADDING="0"
629 
CELLSPACING="0"
630 
><TR
631 
><TD
632 
WIDTH="33%"
633 
ALIGN="left"
634 
VALIGN="top"
635 
><A
636 
HREF="compat-uitron-network-support-functions.html"
637 
ACCESSKEY="P"
638 
>Prev</A
639 
></TD
640 
><TD
641 
WIDTH="34%"
642 
ALIGN="center"
643 
VALIGN="top"
644 
><A
645 
HREF="ecos-ref.html"
646 
ACCESSKEY="H"
647 
>Home</A
648 
></TD
649 
><TD
650 
WIDTH="33%"
651 
ALIGN="right"
652 
VALIGN="top"
653 
><A
654 
HREF="net-common-tcpip.html"
655 
ACCESSKEY="N"
656 
>Next</A
657 
></TD
658 
></TR
659 
><TR
660 
><TD
661 
WIDTH="33%"
662 
ALIGN="left"
663 
VALIGN="top"
664 
>Network Support Functions</TD
665 
><TD
666 
WIDTH="34%"
667 
ALIGN="center"
668 
VALIGN="top"
669 
><A
670 
HREF="compat-uitron-microitron-api.html"
671 
ACCESSKEY="U"
672 
>Up</A
673 
></TD
674 
><TD
675 
WIDTH="33%"
676 
ALIGN="right"
677 
VALIGN="top"
678 
>TCP/IP Stack Support for eCos</TD
679 
></TR
680 
></TABLE
681 
></DIV
682 
></BODY
683 
></HTML
684 
>

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.