Introduccin a VxWorks 6.

Introduccin a

VxWorks 6.6

Jos Manuel Rodrguez Ascariz

Jmra 2008

Introduccin a VxWorks 6.6

Introduccin
VxWoks es un sistema operativo multitarea en tiempo real (RTOS) orientado a sistemas empotrados. Un RTOS
de altas prestaciones que proporciona multitud de servicios (multitarea, gestin memoria, sistemas de ficheros,
red, ) y que est disponible para mltiples arquitecturas de procesadores y computadores industriales.
Es un sistema operativo escalable, muy fiable y ampliamente utilizado en sectores muy especializados como
defense, industria aeroespacial, sistemas mdicos de precisin, comunicaciones, etc.
Despus de 25 aos en el mercado, VxWorks es un sistema maduro, muy robusto y profundamente depurado.

Arquitectura de VxWorks

BSP: Board support package: Fundamental para cada target.

Jmra 2008

Introduccin a VxWorks 6.6

Arquitectura de red de VxWorks

Desde sus comienzos, VxWorks se caracteriza por sus potentes capacidades de comunicaciones y networking.

Entorno Workbench 3.0 (VxWorks 6.6 con interface Eclipse)

Actualmente las aplicaciones para VxWorks se desarrollan en entorno Workbench 3.0. Un Entorno muy
moderno basado en Eclipse. De ahora en adelante se ver de forma prctica como desarrollar bajo este entorno
de programacin. Lets go:
Arrancar Workbench y seleccionar el workspace:

Jmra 2008

Introduccin a VxWorks 6.6

Creacin de un proyecto en Workbench 3.0 para VxWorks 6.6.

Existen varios tipos de proyectos para ser creados por Workbench-VxWorks; los ms comunes son:
1. VxWorks Downloadable Kernel Module Project.
2. VxWorks Image Project.
Comenzamos con VxWorks Downloadable Kernel Module Project. Estos mdulos cargables se compilan y se
descargan en el target, en el que ya est instalado VxWorks.
El linkado del mdulo cargable se produce de forma dinmica al ser descargado en el target. Para ello VxWorks
hace uso de su tabla de smbolos as como de la tabla de smbolos del mdulo recin creado.
Veamos un ejemplo de proyecto de mdulo cargable:

Jmra 2008

Introduccin a VxWorks 6.6

Aadir cdigo fuente (ficheros *.c) al proyecto:

Jmra 2008

Introduccin a VxWorks 6.6

Jmra 2008

Introduccin a VxWorks 6.6

Compilar el proyecto (build target):

Conectar con el target (en este caso simulador vxsim):

Jmra 2008

Introduccin a VxWorks 6.6

VxSim arranca:

Se descarga el mdulo VxWorks que se acaba de compilar (fichero *.out) al simulador:

Jmra 2008

Introduccin a VxWorks 6.6

Se ejecuta dicho mdulo en el target:

Jmra 2008

Introduccin a VxWorks 6.6

Workbench pregunta por el target concreto y el punto de entrada al mdulo (module entry point):

En el botn Browse del dilogo anterior:

Jmra 2008

10

Introduccin a VxWorks 6.6

Run:

Otro ejemplo muy simple:

Jmra 2008

11

Introduccin a VxWorks 6.6

Veamos algo ms acerca de la tarea Shell de VxWorks:

Jmra 2008

12

Introduccin a VxWorks 6.6

Se puede interactuar con el Shell de VxWorks. Veamos algn ejemplo:

-> v0=sysClkRateGet();
New symbol "v0" added to kernel symbol table.
v0 = 0x103d7c88: value = 60 = 0x3c = '<'
-> v1=tickGet();
New symbol "v1" added to kernel symbol table.
v1 = 0x103d7cc8: value = 21710 = 0x54ce
->
->
-> printf("Hola VxWorks, el tick es: %d\n",sysClkRateGet());
Hola VxWorks, el tick es: 60
value = 29 = 0x1d
->

En el ejemplo anterior se ha llamado a las funciones sysClkRateGet y tickGet, dos funciones fundamentales que
nos informan del tick del sistema y del valor actual del contador de ticks. sysClkRateGet devuelve 60, es decir, el
tick del sistema es de 1/60 segundos.
En muchos kernel de tiempo real es comn utilizar un tick de 10 ms. Para modificar el tick existe la funcin
sysClkRateSet. Por su parte, para modificar el contador de ticks, existe la funcin tickSet.
Estas funciones se pueden llamar desde un programa:

Jmra 2008

13

Introduccin a VxWorks 6.6

En la consola (Shell) de VxWorks puede comprobarse el resultado:

Establecido VxWorks tick: 100 por segundo
Tiempo empleado por retardo soft: 2 ticks

VxWorks proporciona la librera timexLib para medida de tiempos de ejecucin. El ejemplo anterior podra
haber utilizado la funcin timex() de timexLib:

Resultado en la consola VxWorks:

Establecido VxWorks tick: 100 por segundo
Tiempo empleado por retardo soft: 4 ticks
timex: time of execution = 40000 +/- 10000 (25%) microsecs

Jmra 2008

14

Introduccin a VxWorks 6.6

Tareas en VxWorks: taskLib.

Una tarea se crea con la llamada taskSpawn de taskLib. Otras system calls proporcionadas por taskLib son:
taskOpen( ) - open a task
taskClose( ) - close a task
taskUnlink( ) - unlink a task
taskSpawn( ) - spawn a task
taskCreate( ) - allocate and initialize a task without activation
taskExit( ) - exit a task
taskActivate( ) - activate a task that has been created without activation
taskDelete( ) - delete a task
taskDeleteForce( ) - delete a task without restriction
taskSuspend( ) - suspend a task
taskResume( ) - resume a task
taskRestart( ) - restart a task
taskPrioritySet( ) - change the priority of a task
taskPriorityGet( ) - examine the priority of a task
taskPriNormalGet( ) - examine the normal priority of a task
taskRtpLock( ) - disable task rescheduling
taskRtpUnlock( ) - enable task rescheduling
taskSafe( ) - make the calling task safe from deletion
taskUnsafe( ) - make the calling task unsafe from deletion
taskIdSelf( ) - get the task ID of a running task
taskIdVerify( ) - verify the existence of a task
_taskOpen( ) - open a task (system call)
taskDelay( ) - delay calling task from executing (system call)
taskCtl( ) - perform a control operation against a task (system call)

Veamos un ejemplo sencillo (en este ejemplo, adems, se demuestra como interactuar desde la shell):

Jmra 2008

15

Introduccin a VxWorks 6.6

Jmra 2008

16

Introduccin a VxWorks 6.6

Semforos en VxWorks: semLib.

Los semforos son mecanismos fundamentales de todo RTOS para acceso en exclusin mutua a recursos
compartidos y comunicacin entre tareas. En VxWorks, las llamadas al sistema para trabajar con semforos
estn disponible en semLib. He aqu las llamadas al sistema proporcionadas por semLib:
semBCreate( ) - create and initialize a binary semaphore
semCCreate( ) - create and initialize a counting semaphore
semMCreate( ) - create and initialize a mutual-exclusion semaphore
semOpen( ) - open a named semaphore
semClose( ) - close a named semaphore
semUnlink( ) - unlink a kernel named semaphore
semDelete( ) - delete a semaphore
semFlush( ) - unblock every task pended on a semaphore
semGive( ) - give a semaphore
semTake( ) - take a semaphore
semExchange( ) - atomically give and take a pair of semaphores
Jmra 2008

17

Introduccin a VxWorks 6.6

_semOpen( ) - open a kernel semaphore (system call)

_semTake( ) - take a kernel semaphore (system call)
_semGive( ) - give a kernel semaphore (system call)
semCtl( ) - perform a control operation against a kernel semaphore (system call)

Ejemplo completo de mdulo cargable en VxWorks:

El siguiente mdulo simula una estacin meteorolgica muy simple. Tres tareas se encargan de simular la lectura
de los sensores (temperatura, humedad y velocidad y direccin del viento), de calcular valores medios y de
presentar los resultados en la consola. Se puede comprobar que hay variables globales accedidas por dos tareas
(recursos compartidos) y no se necesario procedido a exclusin mutua.

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

"vxWorks.h"
/* Siempre este .h primero
"stdio.h"
"sysLib.h" /* sysClkRateSet, sysClkRateGet */
"tickLib.h"
/* tickSet, tickGet
"timexLib.h"
"taskLib.h"
"xbdBlkDev.h"
"virtualDiskLib.h"
"fsMonitor.h"
"dosFsLib.h"

#define NUM_ELEM_ARRAY
#define
#define
#define
#define
#define

*/

/* numero de adquisiciones recientes para medias */

PRIOR_SIM_SENS
15
/* prioridad de tarea
PRIOR_SENSORS
20
/* prioridad de tarea
PRIOR_PRESRES
25
/* prioridad de tarea
BYTES_STACK 1000 /* tamao de stack
en bytes
PRIMER_PARAMETRO 10
/* ejemplo de paso de

int idSensor,idPresRes,idSimSens;
int
int
int
int
int

*/

(0=max)
*/
(0=max)
*/
(0=max)
*/
*/
parametro*/

/* para IDs de tasks

*/

Temperat[NUM_ELEM_ARRAY];
/* almacena las adquisiciones mas recientes */
Humedad[NUM_ELEM_ARRAY];
VelViento[NUM_ELEM_ARRAY];
DirViento[NUM_ELEM_ARRAY];
TemMedia,HumMedia,VelMedia,DirMedia;

unsigned
unsigned
unsigned
unsigned

char
char
char
char

ADC_Temperatura;
ADC_Humedad;
ADC_Velocidad;
ADC_Direccion;

/********************************************************************************/
/* Task para simular la adquisicion de datos de los diferentes sensores
*/
/********************************************************************************/
int SimulaSensores()
{
while(1){
ADC_Temperatura = rand() % 255; /* simula lectura sensor */
ADC_Humedad = rand() % 255; /* simula lectura sensor */
ADC_Velocidad = rand() % 255; /* simula lectura sensor */
ADC_Direccion = rand() % 255; /* simula lectura sensor */
taskDelay(5);
/* simular adquisicion datos cada 50 ms
}
}

*/

/********************************************************************************/
/* Task para acondicionamiento y calculo de magnitudes fisicas
*/
/********************************************************************************/
Jmra 2008

18

Introduccin a VxWorks 6.6

int Sensores()
{
int k,numMedida=0;
while(1){
Temperat[numMedida]
Humedad[numMedida]
VelViento[numMedida]
DirViento[numMedida]

=
=
=
=

(int)ADC_Temperatura;
(int)ADC_Humedad;
(int)ADC_Velocidad;
(int)ADC_Direccion;

/* lee ultima adquisicion */

numMedida++;
if(numMedida==NUM_ELEM_ARRAY)
numMedida = 0;
TemMedia=0;
/* calcular media de las adquisiciones */
HumMedia=0;
VelMedia=0;
DirMedia=0;
for(k=0;k<NUM_ELEM_ARRAY;k++){
TemMedia += (int)Temperat[k];
HumMedia += (int)Humedad[k];
VelMedia += (int)VelViento[k];
DirMedia += (int)DirViento[k];
}
TemMedia /=NUM_ELEM_ARRAY*10;
HumMedia /=NUM_ELEM_ARRAY*10;
VelMedia /=NUM_ELEM_ARRAY*10;
DirMedia /=NUM_ELEM_ARRAY*10;
taskResume(idPresRes);
taskDelay(200);

/* reanuda presentacion
/* medias cada 2 s

*/
*/

}
}
/********************************************************************************/
/* Task para presentacion de datos meteorologicos
*/
/********************************************************************************/
int PresentaResultado()
{
while(1){
printf(" +++++
Estacion meteorologica VxWorks
+++++\n");
printf(" =================================================\n");
printf(" Temperatura Humedad
Veloc.Viento
Dir.Viento\n");
printf("
%3d
%3d
%3d
%3d\n",
TemMedia,HumMedia,VelMedia,DirMedia);
printf("\n\n");
taskSuspend(0);
}
}
/********************************************************************************/
/* Funcion de entrada al modulo VxWorks
*/
/********************************************************************************/
void mymain(void)
{
int k;
BLK_DEV * vdBlkDev;
device_t xbd;
STATUS status;
FILE * fd;
sysClkRateSet(100);
Jmra 2008

19

Introduccin a VxWorks 6.6

idSimSens = taskSpawn("simSens",PRIOR_SIM_SENS,0,BYTES_STACK,SimulaSensores,\
0,0,0,0,0,0,0,0,0,0);
idSensor = taskSpawn("Sensors",PRIOR_SENSORS,0,BYTES_STACK,Sensores,\
0,0,0,0,0,0,0,0,0,0);
idPresRes =taskSpawn("PresRes",PRIOR_PRESRES,0,BYTES_STACK,PresentaResultado,\
0,0,0,0,0,0,0,0,0,0);
/* si no hay nada, implicitamente se llama a taskExit()

*/

Comunicacin entre Tareas en VxWorks: msgQlib y rngLib.

Dos de los mecanismos clsicos en RTOS para comunicacin entre tareas son las colas de mensajes y los
bufferes circulares. En VxWorks estos mecanismos los ofrecen las libreras msgQlib y rngLib respectivamente.
En msgQLib se encuentran las llamadas al sistema:
msgQOpen( ) - open a message queue
msgQClose( ) - close a named message queue
msgQUnlink( ) - unlink a named message queue
msgQCreate( ) - create and initialize a message queue
msgQDelete( ) - delete a message queue
msgQNumMsgs( ) - get the number of messages queued to a message queue
_msgQOpen( ) - open a message queue (system call)
msgQSend( ) - send a message to a message queue (system call)
msgQReceive( ) - receive a message from a message queue (system call)

En rngLib se encuentran las llamadas al sistema:

rngCreate( ) - create an empty ring buffer
rngDelete( ) - delete a ring buffer
rngFlush( ) - make a ring buffer empty
rngBufGet( ) - get characters from a ring buffer
rngBufPut( ) - put bytes into a ring buffer
rngIsEmpty( ) - test if a ring buffer is empty
rngIsFull( ) - test if a ring buffer is full (no more room)
rngFreeBytes( ) - determine the number of free bytes in a ring buffer
rngNBytes( ) - determine the number of bytes in a ring buffer
rngPutAhead( ) - put a byte ahead in a ring buffer without moving ring pointers
rngMoveAhead( ) - advance a ring pointer by n bytes

Ejercicio:
Modificar el ejemplo de estacin meteorolgica usando un buffer circular para el paso de datos desde la tarea
simulaSensores a la tarea sensores y una cola de mensajes para envo de resultados a la tarea de presentacin.

Un vistazo rpido a System Viewer

El entorno Workbench 3.0 ofrece una herramienta para tracear grficamente VxWorks y la aplicacin en
ejecucin. En el laboratorio se ver prcticamente como configurar y arrancar esta herramienta llamada System
Viewer.

Jmra 2008

20

Introduccin a VxWorks 6.6

Adems de las tareas de la apliacin en ejecucin, se pueden ver las interrupciones del sistema. En el manual de
Vxsim se puede ver:
Table 3-4 :Interrupt Assignments (Windows Simulators)
Interrupt Vectors

Description

0x0000

system clock interrupt

0x0001

auxiliary clock interrupt

0x0002

timestamp rollover interrupt

Creacin de proyecto Imagen VxWorks

Hasta ahora se ha trabajado con mdulos cargables. Cuando se est desarrollando una aplicacin los mdulos
cargable resultan muy cmodos ya que solamente es necesario recompilar aquellas partes que estn siendo
desarrolladas para luego cargarlas y ejecutarlas (o depurarlas) dinmicamente con ayuda de la shell de VxWorks.
Cuando la aplicacin ha sido correctamente depurada y se dispone de la versin definitiva se integra con
VxWorks (BSP y kernel) para formar una imagen bootable. Esta imagen se carga en la memoria flash del target
desde la cual arranca el microprocesador/microcontrolador (en algunos casos esa imagen puede estar en disco o
en memoria SD/Compact Flash, etc; en esos casos la memoria flash del target contendr un bootloader para
arrancar la imagen VxWorks-aplicacin desde disco o memoria SD).
Para crear la imagen VxWorks-Aplicacin de usuario, es necesario incluir en el cuerpo de la rutina usrAppInit
(fichero usrAppInit.c) el cdigo de usuario que hasta ahora constitua la rutina de entrada (entry point) al mdulo
cargable.
Jmra 2008

21

Introduccin a VxWorks 6.6

Un ejemplo trivial es el que se muestra a continuacin (observar que ahora el tipo de proyecto es VxWorks 6.6
Image Project y no un Downloadable module). Simplemente se ejecuta un printf desde la rutina usrAppInit:

Una vez recompilada (rebuild) la imagen de VxWorks hay que indicarle a Vxsim la nueva imagen ejecutar.
En este ejemplo el workspace es el directorio \Jmra\VxWorks6.6 y el nombre del proyecto mii, as que la imagen
generada estar en \Jmra\VxWorks6.6\mii\default\vxWorks
El comando completo es:

Esa nueva imagen de VxWorks arranca y:

Jmra 2008

22

Introduccin a VxWorks 6.6

Ms opciones de arranque de VxSim pueden consultarse en el apartado 2.4.1 del manual de vxsim.

La estacin meteorologica como imagen arrancable: todo el codigo en el fichero

usrAppInit.c. Veamos:

usrAppInit.c
#include <vxWorks.h>
#if defined(PRJ_BUILD)
#include "prjParams.h"
#endif /* defined PRJ_BUILD */
#include <stdio.h>
#include
#include
#include
#include
#include
#include

<stdlib.h> /* srand()
<sysLib.h> /* sysClkRateSet, sysClkRateGet
<tickLib.h>
/* tickSet, tickGet
<timexLib.h>
<taskLib.h>
<semLib.h>

#define NUM_ELEM_ARRAY
#define
#define
#define
#define
#define

*/

/* numero de adquisiciones recientes para medias */

PRIOR_SIM_SENS
15
/* prioridad de tarea
PRIOR_SENSORS
20
/* prioridad de tarea
PRIOR_PRESRES
25
/* prioridad de tarea
BYTES_STACK 1000
/* tamao de stack en bytes
PRIMER_PARAMETRO 10
/* ejemplo de paso de

int
idTskSensor,idTskPresRes,idTskSimSens;
SEM_ID idSemADCs;
int
int
int
int
int

*/
*/

(0=max)
(0=max)
(0=max)
*/
parametro

*/
*/
*/
*/

/* para IDs de tasks

*/

Temperat[NUM_ELEM_ARRAY]; /* almacena las adquisiciones mas recientes */

Humedad[NUM_ELEM_ARRAY];
VelViento[NUM_ELEM_ARRAY];
DirViento[NUM_ELEM_ARRAY];
TemMedia,HumMedia,VelMedia,DirMedia;
Jmra 2008

23

Introduccin a VxWorks 6.6

unsigned
unsigned
unsigned
unsigned

char
char
char
char

ADC_Temperatura;
ADC_Humedad;
ADC_Velocidad;
ADC_Direccion;

/********************************************************************************/
/* Task para simular la adquisicion de datos de los diferentes sensores
*/
/********************************************************************************/
int SimulaSensores()
{
while(1){
semTake(idSemADCs,WAIT_FOREVER);
ADC_Temperatura = rand() % 255; /* simula lectura sensor */
ADC_Humedad = rand() % 255; /* simula lectura sensor */
ADC_Velocidad = rand() % 255; /* simula lectura sensor */
ADC_Direccion = rand() % 255; /* simula lectura sensor */
semGive(idSemADCs);
taskDelay(5);

/* simular adquisicion datos cada 50 ms

*/

}
}

/********************************************************************************/
/* Task para acondicionamiento y calculo de magnitudes fisicas
*/
/********************************************************************************/
int Sensores()
{
int k,numMedida=0;
while(1){
semTake(idSemADCs,WAIT_FOREVER);
Temperat[numMedida] = (int)ADC_Temperatura;
Humedad[numMedida]
= (int)ADC_Humedad;
VelViento[numMedida] = (int)ADC_Velocidad;
DirViento[numMedida] = (int)ADC_Direccion;
semGive(idSemADCs);

/* lee ultima adquisicion */

numMedida++;
if(numMedida==NUM_ELEM_ARRAY)
numMedida = 0;
TemMedia=0;
/* calcular media de las adquisiciones */
HumMedia=0;
VelMedia=0;
DirMedia=0;
for(k=0;k<NUM_ELEM_ARRAY;k++){
TemMedia += (int)Temperat[k];
HumMedia += (int)Humedad[k];
VelMedia += (int)VelViento[k];
DirMedia += (int)DirViento[k];
}
TemMedia /=NUM_ELEM_ARRAY*10;
HumMedia /=NUM_ELEM_ARRAY*10;
VelMedia /=NUM_ELEM_ARRAY*10;
DirMedia /=NUM_ELEM_ARRAY*10;
taskResume(idTskPresRes); /* reanuda presentacion
taskDelay(200);
/* medias cada 2 s

*/
*/

}
}
/********************************************************************************/
/* Task para presentacion de datos meteorologicos
*/
/********************************************************************************/
Jmra 2008

24

Introduccin a VxWorks 6.6

int PresentaResultado()
{
while(1){
printf(" +++++
Estacion meteorologica VxWorks
+++++\n");
printf(" =================================================\n");
printf(" Temperatura Humedad
Veloc.Viento
Dir.Viento\n");
printf("
%3d
%3d
%3d
%3d\n",
TemMedia,HumMedia,VelMedia,DirMedia);
printf("\n\n");
taskSuspend(0);
}
}
/********************************************************************************/
/* Funcion de entrada al modulo VxWorks
*/
/********************************************************************************/
/******************************************************************************
*
* usrAppInit - initialize the users application
*/
void usrAppInit (void)
{
#ifdef USER_APPL_INIT
USER_APPL_INIT;
#endif

/* for backwards compatibility */

sysClkRateSet(100);
idSemADCs

= semMCreate(SEM_Q_PRIORITY);

idTskSimSens = taskSpawn("tskSimSens",PRIOR_SIM_SENS,0,BYTES_STACK,SimulaSensores,\
0,0,0,0,0,0,0,0,0,0);
idTskSensor = taskSpawn("tskSensors",PRIOR_SENSORS,0,BYTES_STACK,Sensores,\
0,0,0,0,0,0,0,0,0,0);
idTskPresRes = taskSpawn("tskPresrlt",PRIOR_PRESRES,0,BYTES_STACK,PresentaResultado,\
0,0,0,0,0,0,0,0,0,0);
taskSuspend(0);
/* si no hay nada, implicitamente se llama a taskExit()

*/

RESULTADO:

Jmra 2008

25

Introduccin a VxWorks 6.6

Una nueva imagen de VxWorks puede ser arrancada directamente desde el entorno Workbench. Para ello solo
hay que cambiar las propiedades del target simulado:

Jmra 2008

26

Introduccin a VxWorks 6.6

Sistema de ficheros en VxWorks

VxWorks proporciona un sistema de ficheros con las llamadas standard de UNIX. Soporta varios tipos de
sistemas de ficheros, entre ellos el de DOS.
Es necesario configurar y recompilar la imagen de VxWorks para incluir el soporte de cada sistema de ficheros
deseado.
A continuacin vamos a ver paso a paso un ejemplo de creacin de un disco virtual (formato DOS con FAT12)
en la raz del disco duro del host (PC utilizado para desarrollo) y posteriormente la creacin de un fichero con las
llamadas standard de UNIX (que son las mismas de VxWorks).
Para este ejemplo se crean dos proyectos:
1. Imagen de VxWorks con soporte para dosFs (sistema de ficheros de DOS) y XBD (Extended Block
Device Driver Model).
2. Mdulo cargable con la aplicacin de creacin de disco y fichero.

1. Creacin de la Imagen de VxWorks con soporte dosFs y XBD:

Jmra 2008

27

Introduccin a VxWorks 6.6

2. Cdigo del mdulo cargable:

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

"vxWorks.h"
/* Siempre este .h primero
"stdio.h"
"sysLib.h"
/* sysClkRateSet, sysClkRateGet */
"tickLib.h"
/* tickSet, tickGet
"timexLib.h"
"taskLib.h"
"xbdBlkDev.h"
"virtualDiskLib.h"
"fsMonitor.h"
"dosFsLib.h"

*/

*/

/********************************************************************************/
/* Dos posibles funciones de entrada (entry points): jmdisk y jmfile
*/
/********************************************************************************/
void jmfile()
{
FILE * fd;
fd = fopen("/Q/Hola.txt", "w+");
fwrite ("Hola desde VxWorks\n\n",sizeof("Hola desde VxWorks\n\n"), 1, fd);
fclose (fd);
}

void jmdisk()
{
BLK_DEV * vdBlkDev;
device_t xbd;
STATUS status;
Jmra 2008

28

Introduccin a VxWorks 6.6

sysClkRateSet(100);
virtualDiskInit ();
vdBlkDev = virtualDiskCreate ("C:/JmDisk", 512, 32, 32*200);
fsmNameInstall("/Q:0", "/Q");
xbd = xbdBlkDevCreateSync(vdBlkDev, "/Q");
status = dosFsVolFormat("/Q", DOS_OPT_QUIET | DOS_OPT_BLANK, NULL);
}

Compilar (rebuild) ambos proyectos, arrancar la imagen de VxWorks que se acaba de generar, descargar el
mdulo cargable y ejecutarlo (primero con la entrada jmdisk para crear el disco y luego jmfile para crear el
fichero):
Checking License ...OK
Virtual Base Address: 0x10000000
Virtual Top Address: 0x50000000
Virtual Size: 0x40000000 (1024Mb)
Physical Base Address: 0x10000000
Physical Top Address: 0x12000000
Physical Size: 0x02000000 (32Mb)
Loading...
0x171b1c + 0x1cb48 + (0x17574)
Loading symbol table from host:C:/Jmra/VxWorks6.6/Exmp10/default/vxWorks.sym ...done

]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]] ]]]]
]]]]]]]]]]
]]
]]]]
(R)
]
]]]]]]]]] ]]]]]]
]]]]]]]]
]]
]]]]
]]
]]]]]]] ]]]]]]]]
]]]]]] ]
]]
]]]]
]]]
]]]]] ]
]]] ]
]]]] ]]]
]]]]]]]]] ]]]] ]] ]]]] ]]
]]]]]
]]]]
]]] ]]
] ]]]
]] ]]]]] ]]]]]]
]] ]]]]]]] ]]]] ]]
]]]]
]]]]]
] ]]]]
]]]]]
]]]]]]]] ]]]]
]] ]]]]
]]]]]]]
]]]]
]]]]]]
]]]]]
]]]]]]
] ]]]]] ]]]]
]] ]]]]
]]]]]]]]
]]]]
]]]]]]]
]]]]] ]
]]]]]] ]
]]]
]]]]
]] ]]]]
]]]] ]]]]
]]]]
]]]]]]]] ]]]]] ]]]
]]]]]]]
]
]]]]]]] ]]]]
]]]] ]]]] ]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
Development System
]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]
VxWorks 6.6
]]]]]]]]]]]]]]]]]]]]]]]]]]
KERNEL: WIND version 2.11
]]]]]]]]]]]]]]]]]]]]]]]]]
Copyright Wind River Systems, Inc., 1984-2007
CPU: Windows 5.1 Service Pack 2. Processor #3.
Memory Size: 0x1f00000. BSP version 2.0/3.
Created: Apr 23 2008, 19:55:08
ED&R Policy Mode: Deployed
WDB Comm Type: WDB_COMM_PIPE
WDB: Ready.
-> Formatting /Q for DOSFS
Instantiating /Q as rawFs, device = 0x10001
Formatting...OK.
-> cmd
[vxWorks *]# set config
RTP_CREATE_STOP=off,RTP_CREATE_ATTACH=on,VXE_PATH=.;/romfs,RTP_CREATE_IO=off,LINE_EDIT_MODE=vi,LINE_LEN
GTH=256,STRING_FREE=manual,INTERPRETER=Cmd,EXC_PRINT=on,BP_PRINT=on,CPLUS_SYM_MATCH=off
[vxWorks *]# set config LINE_EDIT_MODE=emacs
[vxWorks *]# cd "/Q"
[vxWorks *]# ls
[vxWorks *]# i > dump.txt
[vxWorks *]# ls
dump.txt
[vxWorks *]# cat dump.txt
NAME
---------tJobTask
tExcTask
tLogTask
tNbioLog
tShell0
tWdbTask
tErfTask
tAioIoTask>

ENTRY
-----------1006b980
1006ac00
logTask
1006c630
shellTask
wdbTask
1002ff30
aioIoTask

TID
PRI
STATUS
PC
SP
ERRNO DELAY
-------- --- ---------- -------- -------- ------- ----103c7260
0 PEND
10101f50 105cffa8
0
0
101ab128
0 PEND
10101f50 101b4364
0
0
103cb1d8
0 PEND
100ffebd 1060ff24
0
0
103cf710
0 PEND
10101f50 1064ff54
0
0
10509a50
1 READY
10109210 1090ee24
0
0
10486000
3 PEND
10101f50 108bff4c
0
0
103ef498 10 PEND
10102602 1074ff98
0
0
103ea8d0 50 PEND
10102602 106cff8c
0
0

Jmra 2008

29

Introduccin a VxWorks 6.6

tAioIoTask> aioIoTask
tNet0
ipcomNetTask
ipcom_sysl> 1011e0e0
ipnetd
10122120
tXbdServic> 10063690
tAioWait
aioWaitTask
tMymain
mymain
[vxWorks *]#

103edd00 50
104082d0 50
1040fb08 50
1046e388 50
1040c838 50
103e73b0 51
1040c1a8 100

PEND
PEND
PEND
PEND
READY
PEND
SUSPEND

10102602
10101f50
10102602
10101f50
10101cde
10101f50
101067aa

1070ff8c
1078ff74
1080fea0
1087ff90
109aff3c
1068ff18
1096ff74

0
0
0
6
3d0004
0
c40006

0
0
0
0
0
0
0

El fichero en el disco de Windows (formato DOS con FAT12) :

BOOT

1 FAT12

2 FAT12

ROOT

DATA

Crear un fichero en /Q utilizando Stdio:

. . .
. . .
BLK_DEV * vdBlkDev;
device_t xbd;
STATUS status;
FILE * fd;
sysClkRateSet(100);
virtualDiskInit ();
vdBlkDev = virtualDiskCreate ("C:/DiscoVirtualVxWorks", 512, 32, 32*200);
fsmNameInstall("/Q:0", "/Q");
xbd = xbdBlkDevCreateSync(vdBlkDev, "/Q");
status = dosFsVolFormat("/Q", DOS_OPT_QUIET | DOS_OPT_BLANK, NULL);
fd = fopen("/Q/Hola.txt", "w+");
fwrite ("Hola desde VxWorks",sizeof("Hola desde VxWorks"), 1, fd);
fclose (fd);
. . .
. . .

En la consola de VxWorks:
Formatting /Q for DOSFS
Instantiating /Q as rawFs, device = 0x30001
Formatting...OK.
[vxWorks *]#
[vxWorks *]#
[vxWorks *]# cat "/Q/Hola.txt"

Jmra 2008

30

Introduccin a VxWorks 6.6

Hola desde VxWorks
[vxWorks *]#

Fin de la introduccin a Workbench 3.0 / VxWorks 6.6

Jmra 2008

31