jmra_introduccion_VxWoks

Introducción a VxWorks 6.6

Jmra 2008 1

Introducción a

VxWorks 6.6

José Manuel Rodríguez Ascariz


Jmra 2008 2

Introducción 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, gestión memoria, sistemas de ficheros,

red, …) y que está disponible para múltiples 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 médicos de precisión, comunicaciones, etc.

Después de 25 años 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 3

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 práctica como desarrollar bajo este entorno

de programación. Let’s go:

Arrancar Workbench y seleccionar el workspace:


Jmra 2008 4

Creación de un proyecto en Workbench 3.0 para VxWorks 6.6.

Existen varios tipos de proyectos para ser creados por Workbench-VxWorks; los más comunes son:

1. VxWorks Downloadable Kernel Module Project.

2. VxWorks Image Project.

Comenzamos con “VxWorks Downloadable Kernel Module Project”. Estos módulos cargables se compilan y se

descargan en el target, en el que ya está instalado VxWorks.

El linkado del módulo cargable se produce de forma dinámica al ser descargado en el target. Para ello VxWorks

hace uso de su tabla de símbolos así como de la tabla de símbolos del módulo recién creado.

Veamos un ejemplo de proyecto de módulo cargable:


Jmra 2008 5

Añadir código fuente (ficheros *.c) al proyecto:


Jmra 2008 6


Jmra 2008 7

Compilar el proyecto (build target):

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


Jmra 2008 8

VxSim arranca:

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


Jmra 2008 9

Se ejecuta dicho módulo en el target:


Jmra 2008 10

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

En el botón Browse… del diálogo anterior:


Jmra 2008 11

Run:

Otro ejemplo muy simple:


Jmra 2008 12

Veamos algo más acerca de la tarea Shell de VxWorks:


Jmra 2008 13

Se puede interactuar con el Shell de VxWorks. Veamos algún 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 común utilizar un tick de 10 ms. Para modificar el tick existe la función

sysClkRateSet. Por su parte, para modificar el contador de ticks, existe la función tickSet.

Estas funciones se pueden llamar desde un programa:


Jmra 2008 14

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 librería timexLib para medida de tiempos de ejecución. El ejemplo anterior podría

haber utilizado la función 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 15

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, además, se demuestra como interactuar desde la shell):


Jmra 2008 16


Jmra 2008 17

Semáforos en VxWorks: semLib. Los semáforos son mecanismos fundamentales de todo RTOS para acceso en exclusión mutua a recursos

compartidos y comunicación entre tareas. En VxWorks, las llamadas al sistema para trabajar con semáforos

están 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 18

_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 módulo cargable en VxWorks: El siguiente módulo simula una estación meteorológica muy simple. Tres tareas se encargan de simular la lectura

de los sensores (temperatura, humedad y velocidad y dirección 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 exclusión mutua.

#include "vxWorks.h" /* Siempre este .h primero */

#include "stdio.h"

#include "sysLib.h" /* sysClkRateSet, sysClkRateGet */

#include "tickLib.h" /* tickSet, tickGet */

#include "timexLib.h"

#include "taskLib.h"

#include "xbdBlkDev.h"

#include "virtualDiskLib.h"

#include "fsMonitor.h"

#include "dosFsLib.h"

#define NUM_ELEM_ARRAY 5 /* numero de adquisiciones recientes para medias */

#define PRIOR_SIM_SENS 15 /* prioridad de tarea (0=max) */

#define PRIOR_SENSORS 20 /* prioridad de tarea (0=max) */

#define PRIOR_PRESRES 25 /* prioridad de tarea (0=max) */

#define BYTES_STACK 1000 /* tamaño de stack en bytes */

#define PRIMER_PARAMETRO 10 /* ejemplo de paso de parametro*/

int idSensor,idPresRes,idSimSens; /* para IDs de tasks */

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

int Humedad[NUM_ELEM_ARRAY];

int VelViento[NUM_ELEM_ARRAY];

int DirViento[NUM_ELEM_ARRAY];

int TemMedia,HumMedia,VelMedia,DirMedia;

unsigned char ADC_Temperatura;

unsigned char ADC_Humedad;

unsigned char ADC_Velocidad;

unsigned char 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 19

int Sensores()

{

int k,numMedida=0;

while(1){

Temperat[numMedida] = (int)ADC_Temperatura; /* lee ultima adquisicion */

Humedad[numMedida] = (int)ADC_Humedad;

VelViento[numMedida] = (int)ADC_Velocidad;

DirViento[numMedida] = (int)ADC_Direccion;

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); /* reanuda presentacion */

taskDelay(200); /* 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 20

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() */

}

Comunicación entre Tareas en VxWorks: msgQlib y rngLib.

Dos de los mecanismos clásicos en RTOS para comunicación entre tareas son las colas de mensajes y los

bufferes circulares. En VxWorks estos mecanismos los ofrecen las librerías 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 estación meteorológica usando un buffer circular para el paso de datos desde la tarea

simulaSensores a la tarea sensores y una cola de mensajes para envío de resultados a la tarea de presentación.

Un vistazo rápido a System Viewer

El entorno Workbench 3.0 ofrece una herramienta para tracear gráficamente VxWorks y la aplicación en

ejecución. En el laboratorio se verá prácticamente como configurar y arrancar esta herramienta llamada System

Viewer.


Jmra 2008 21

Además de las tareas de la apliación en ejecución, 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

Creación de proyecto Imagen VxWorks

Hasta ahora se ha trabajado con módulos cargables. Cuando se está desarrollando una aplicación los módulos

cargable resultan muy cómodos ya que solamente es necesario recompilar aquellas partes que están siendo

desarrolladas para luego cargarlas y ejecutarlas (o depurarlas) dinámicamente con ayuda de la shell de VxWorks.

Cuando la aplicación ha sido correctamente depurada y se dispone de la versión 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-aplicación desde disco o memoria SD).

Para crear la imagen VxWorks-Aplicación de usuario, es necesario incluir en el cuerpo de la rutina usrAppInit

(fichero usrAppInit.c) el código de usuario que hasta ahora constituía la rutina de entrada (entry point) al módulo

cargable.


Jmra 2008 22

Un ejemplo trivial es el que se muestra a continuación (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 23

Más opciones de arranque de VxSim pueden consultarse en el apartado 2.4.1 del manual de vxsim.

La estación 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 <stdlib.h> /* srand() */

#include <sysLib.h> /* sysClkRateSet, sysClkRateGet */

#include <tickLib.h> /* tickSet, tickGet */

#include <timexLib.h>

#include <taskLib.h>

#include <semLib.h>

#define NUM_ELEM_ARRAY 5 /* numero de adquisiciones recientes para medias */

#define PRIOR_SIM_SENS 15 /* prioridad de tarea (0=max) */

#define PRIOR_SENSORS 20 /* prioridad de tarea (0=max) */

#define PRIOR_PRESRES 25 /* prioridad de tarea (0=max) */

#define BYTES_STACK 1000 /* tamaño de stack en bytes */

#define PRIMER_PARAMETRO 10 /* ejemplo de paso de parametro */

int idTskSensor,idTskPresRes,idTskSimSens; /* para IDs de tasks */

SEM_ID idSemADCs;

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

int Humedad[NUM_ELEM_ARRAY];

int VelViento[NUM_ELEM_ARRAY];

int DirViento[NUM_ELEM_ARRAY];

int TemMedia,HumMedia,VelMedia,DirMedia;


Jmra 2008 24

unsigned char ADC_Temperatura;

unsigned char ADC_Humedad;

unsigned char ADC_Velocidad;

unsigned char 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; /* lee ultima adquisicion */

Humedad[numMedida] = (int)ADC_Humedad;

VelViento[numMedida] = (int)ADC_Velocidad;

DirViento[numMedida] = (int)ADC_Direccion;

semGive(idSemADCs);

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 25

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; /* for backwards compatibility */

#endif

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 26

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 27

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 continuación vamos a ver paso a paso un ejemplo de creación de un disco virtual (formato DOS con FAT12)

en la raíz del disco duro del host (PC utilizado para desarrollo) y posteriormente la creación 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. Módulo cargable con la aplicación de creación de disco y fichero.

1. Creación de la Imagen de VxWorks con soporte dosFs y XBD:


Jmra 2008 28

2. Código del módulo cargable:

#include "vxWorks.h" /* Siempre este .h primero */

#include "stdio.h"

#include "sysLib.h" /* sysClkRateSet, sysClkRateGet */

#include "tickLib.h" /* tickSet, tickGet */

#include "timexLib.h"

#include "taskLib.h"

#include "xbdBlkDev.h"

#include "virtualDiskLib.h"

#include "fsMonitor.h"

#include "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 29

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

módulo 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 ENTRY TID PRI STATUS PC SP ERRNO DELAY

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

tJobTask 1006b980 103c7260 0 PEND 10101f50 105cffa8 0 0

tExcTask 1006ac00 101ab128 0 PEND 10101f50 101b4364 0 0

tLogTask logTask 103cb1d8 0 PEND 100ffebd 1060ff24 0 0

tNbioLog 1006c630 103cf710 0 PEND 10101f50 1064ff54 0 0

tShell0 shellTask 10509a50 1 READY 10109210 1090ee24 0 0

tWdbTask wdbTask 10486000 3 PEND 10101f50 108bff4c 0 0

tErfTask 1002ff30 103ef498 10 PEND 10102602 1074ff98 0 0

tAioIoTask> aioIoTask 103ea8d0 50 PEND 10102602 106cff8c 0 0


Jmra 2008 30

tAioIoTask> aioIoTask 103edd00 50 PEND 10102602 1070ff8c 0 0

tNet0 ipcomNetTask 104082d0 50 PEND 10101f50 1078ff74 0 0

ipcom_sysl> 1011e0e0 1040fb08 50 PEND 10102602 1080fea0 0 0

ipnetd 10122120 1046e388 50 PEND 10101f50 1087ff90 6 0

tXbdServic> 10063690 1040c838 50 READY 10101cde 109aff3c 3d0004 0

tAioWait aioWaitTask 103e73b0 51 PEND 10101f50 1068ff18 0 0

tMymain mymain 1040c1a8 100 SUSPEND 101067aa 1096ff74 c40006 0

[vxWorks *]#

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 31

Hola desde VxWorks

[vxWorks *]#

Fin de la introducción a Workbench 3.0 / VxWorks 6.6

jmra_introduccion_VxWoks

Documents

Transcript of jmra_introduccion_VxWoks