Código fuente del sistema inmobiliario
1Clase de excepción VxError
Primero, encapsule la clase de excepción VxError. Cuando ocurre una excepción en el programa, se lanza un objeto de esta clase al llamador externo, y el llamador usa la cláusula try-catch para capturar el objeto de excepción y manejar la excepción.
Debido a que esta clase es para excepciones generadas cuando el sistema se está ejecutando, se considera derivada de la clase runtime_error en la clase de excepción estándar de C++. El kernel de VxWorks registra errores durante la operación del sistema configurando la variable global errno, por lo que configurar int? Como variable miembro de esta clase, errNum se utiliza para registrar el valor de errno cuando ocurre una excepción. El código fuente es el siguiente:
#Contiene? & ltstdexcept & gt
#¿Contiene? " errnoLib.h "
¿Clase? ¿VxRunTimeError? :?¿público? runtime_error? {
Protegido:
int? errNum
Público:
VxRunTimeError(const?String?MSG?=?"")?:?runtime_error(mensaje),? errNum(errnoGet?())
{
}
int? getErrNum(void)
{
¿Devolver? errNum
}
};2 Clase de tarea VxTask
La clase de tarea VxTask se utiliza para encapsular tareas de VxWorks. Inicialmente, la función de entrada de la tarea se considera una función miembro virtual pura de la clase. Los usuarios pueden implementar sus propias tareas de VxWorks sobrecargando funciones virtuales puras en clases derivadas de esta clase. Sin embargo, debido a que el tipo de parámetro de la función de entrada de taskSpawn() es FUNCPTR(typedef?Int (*FUNCPTR)(...)), y el tipo de puntero que apunta a la función miembro de la clase VxTask es int (vxtask:: * ptr )(... El compilador no admite la conversión de tipos forzada entre estos dos tipos, por lo que solo podemos cambiar la idea: usar una clase llamada Runnable para encapsular la función de entrada de la tarea y proporcionar una función miembro estática para completar. la función de entrada Llamada, función miembro estática. Implementar llamadas al sistema sobre tareas en la clase VxTask.
Parte del código fuente es el siguiente:
¿Clase? ¿Ejecutable? {
Protegido:
¿Virtual? ¿Vacío? correr()? =?0;
Público:
¿Electricidad estática? ¿Vacío? Entrada (¿Ejecutable?*?Ejecutar)
{
Ejecutar->run();
}
¿Virtual? ~Runnable()
{
}
};
¿Clase? ¿VxTask? {
Protegido:
¿Carácter? *Nombre;
int? tid
Público:
VxTask(char*?Name,?int?Arg1?,?FUNCPTR?Entry?=?(FUNCPTR)Runnable::entry,?int?Pri? =?150,?int?=?VX_FP_TASK?=?2000000,?int?Arg4?=?0,?int?=?0,?int?int?Arg10?=?0)?:?Nombre(nombre )
{
Si (¿entrada?==?NULL)? {
throw(VxRunTimeError("¿Tarea? ¿Crear? Error:? ¿Empezando? ¿No puedo? ¿Sí? ¡NULL!"));
}
tid= taskSpawn(Nombre, Pri, Opt, StackSize, Entrada, Arg1, Arg2,? Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9, arg 10);
If (tid?== ?Error )? {
throw(VxRunTimeError("¿Tarea? ¿Generar? ¡Error!"));
}
}
~VxTask()
{
if(taskDelete(tid)?==?Error)? {
throw(VxRunTimeError("¿Tarea? ¿Eliminar? Error:? ¿Tarea? ¿Eliminar? ¡Error!"));
}
}
¿Anulado? suspender()
{
if(taskSuspend(tid)?==?Error)? {
throw(VxRunTimeError("¿Tarea? ¿En pausa? Error:? ¿Tarea? ¿En pausa? ¡Error!"));
}
}
¿Anulado? Currículum()
{
if(taskResume(tid)?==?Error)? {
throw(VxRunTimeError("¿Tarea? ¿Reanudar? Error:? ¿Tarea? ¿Reanudar? ¡Error!"));
}
}
int? getTid()
{
¿Devolver? tid
}
}; Al usarlo, primero derive una subclase de Runnable, sobrecargue su función miembro run() y luego asigne el puntero de objeto de esta subclase a VxTask Constructor. se ejecutará la tarea del usuario:
¿Clase? ¿No puedo correr? :?¿público? Perseguible
{
¿Anulado? correr()? {
¿Y (1)? {
cout & lt& lt"¿Hola? ¿VxWorks? ¿Tarea? ¡Mundo!"& lt& ltendl
retraso de tarea(sysClkRateGet());
}
}
};
¿Anulado? mi
Main()
{
¿No puedo ejecutar? Myron;
¿VxTask? task("tMyRun", (int)&Myron);
¿Y (1)? {
task delay(sysClkRateGet());
}
} sp myMain puede ver el efecto esperado en el shell, pero si es de myMain() Eliminar el último bucle while(1), y solo verás el mundo de tareas Hello VxWorks una vez en la ventana de salida. producción. ¿Por qué? (Pista: ¡El destructor de VxTask!)
3 Clase de interrupción VxInt
La clase de interrupción VxInt es similar a VxTask. También utiliza una clase derivada de Runnable para encapsular la función de entrada. y la clase VxInt implementa el sistema de interrupción Llamada:
typedefvoid? (**VOIDFUNCPTRPTR)? (...);
¿Clase? ¿VxInt? {
Protegido:
int? intNum
Público:
VxInt(int?IntNum,?int?Arg?=?0,?VOIDFUNCPTR?Entry?=?(VOIDFUNCPTR)Runnable::entry)? :?integer(entero)
{
if(int connect((VOIDFUNCPTRPTR)INUM _ TO _ IVEC(int num),? entrada,?Arg)?==? error )? {
throw(VxRunTimeError("¿Interrumpida? ¿Conexión? ¡Error!"));
}
}
} con la tarea De manera diferente, las funciones que pueden estar bloqueadas no se pueden llamar en una rutina de servicio de interrupción (ISR). Esto debe tenerse en cuenta al sobrecargar la función miembro run() en una clase derivada Runnable.
4 Clase de perro guardián VxWatchDog
El perro guardián en VxWorks en realidad usa la interrupción del reloj del sistema para ejecutar una función con regularidad, por lo que la función ejecutada por el perro guardián está en el contexto de la interrupción. en el contexto de la tarea, en lugar de en el contexto de la tarea, por lo que las funciones con funciones de bloqueo no se pueden llamar en esta función.
Entonces, ¿la implementación de VxWatchDog es similar a la clase de interrupción VxInt:
? ¿VxWatchDog? {
¿WDOG_ID? identificación;
int? Retraso;
Público:
VxWatchDog(int? Retraso, ? ¿Ejecutable? *EntryObj)? :?Retraso (retraso)
{
id? =?wd create();
Si (id?==?NULL)? {
throw(VxRunTimeError("¿Watch? ¿Perro? ¿Crear? ¡Fallo!"));
}
if(wdStart(id, retraso,?( FUNCPTR)Ejecutable::entrada,(int)EntryObj)? {
throw(VxRunTimeError("¿Watch? ¿Perro? ¿Iniciar? ¡Error!"));
}
}
¿No es válido? Cancelar()
{
if(wdCancel(id)?!=?OK)? {
throw(VxRunTimeError("¿Watch? ¿Perro? ¿Cancelar? ¡Fallo!"));
}
}
WDOG_ID? getId()
{
Devolver (id);
}
~VxWatchDog()
{
if(wdDelete(id)?!=?OK)? {
throw(VxRunTimeError("¿Watch? ¿Perro? ¿Eliminar? ¡Error!"));
}
}
}; WdStart (wdog_id id, intdelay, functrPtr, intpara) solo hará que la función Ptr se ejecute una vez después de un tic de retraso. Para ejecutar ptr periódicamente, es necesario llamar a wdstart() de forma recursiva en Ptr. ¿Se puede implementar así:
Clase? ¿WdRun? :?¿público? ¿Ejecutable? {
Protegido:
¿No válido? correr()? {
logMsg("¿Hola? ¿Mirar? ¿Perro? ¡Mundo!",0,0,0,0,0,0);
¿VxWatchDog? wtDog(sysClkRateGet(),? this);
}
}; El programa anterior intenta generar un objeto de la clase VxWatchDog en la función de entrada e inicializar el objeto con este puntero para que La función de entrada se ejecuta cada segundo. Pero no olvide que la función de entrada se ejecuta en el contexto de una interrupción y no permite la creación o eliminación dinámica de objetos, por lo que no es factible implementar la ejecución periódica de trabajos utilizando este método.
Para llamar a wdStart() en la función de entrada y evitar generar objetos VxWatchDog dinámicamente, debe incluir un puntero VxWatchDog en la variable miembro de la clase derivada Runnable y llamar a wdStart() de la función de entrada. objeto a través de este puntero.
Para hacer esto, necesita agregar funciones miembro a la clase VxWatchDog:
VxWatchDog? * ¿VxWatchDog(int? retraso)? :?id(wdCreate()),? Retraso (Extensión)
{
¿Si (id?==?NULL)? {
throw(VxRunTimeError("¿Watch? ¿Perro? ¿Crear? ¡Fallo!"));
}
}
¿No es válido? ¿VxWatchDog? *Inicio(ejecutable?*EntryObj)
{
if(wdStart(id, retraso, ?(FUNCPTR)Runnable::entry, ?(int)EntryObj)?!= ? DE ACUERDO)? {
throw(VxRunTimeError("¿Observar? ¿Perro? ¿Iniciar? ¡Error!"));
}
}
¿Clase? ¿WdRun? :?¿público? ¿Ejecutable? {
Protegido:
VxWatchDog? *perro;
¿Virtual? ¿Vacío? correr()? {
logMsg("¿Hola? ¿Mirar? ¿Perro? ¡Mundo!",0,0,0,0,0,0);
Perro->
}
Público:
WdRun(VxWatchDog? *perro)? :?Perro(perro)
{
}
};
¿Anulado? myMain()
{
VxWatchDog? wtDog(sysClkRateGet());
WdRun? ejecutar(& ampwtDog);
wtdog . iniciar(& amp;ejecutar);
Y (1)? {
retraso de tarea(sysClkRateGet());
cout & lt& lt"¿Estás ahí? ¡Señor!"& lt& ltendl
}
}Ingrese sp myMain en el shell y podrá ver el resultado esperado.
5 Clase de semáforo VxSem
Los semáforos VxWorks incluyen semáforos mutuamente excluyentes, semáforos binarios y semáforos de conteo. Las interfaces de estos tres semáforos son las mismas excepto que llaman a sus propias funciones de creación cuando se crean. Por lo tanto, consideramos utilizar la clase VxSem como clase base del semáforo para proporcionar una interfaz de operación de semáforo unificada.
Las clases derivadas VxSemM, VxSemB y VxSemC encapsulan respectivamente las funciones de creación de tres semáforos:
¿Clase? ¿VxSem? {
Protegido:
¿SEM_ID? id;
Público:
VxSem(SEM_ID?Id)? :?DNI (DNI)
{
}
¿Virtual? ~VxSem()
{
if(semDelete(id)?==?Error)? {
throw(VxRunTimeError("¿Semáforo? ¿Eliminación? ¡Error!"));
}
}
¿No es válido? take(int? timeout?=?wait_forever)
{
if(semTake(id, WAIT_FOREVER)?==?error)? {
throw(VxRunTimeError("¿Semáforo? ¿Obtener? ¡Error!"));
}
}
¿No es válido? dar()
{
if(semGive(id)?==?Error)? {
throw(VxRunTimeError("¿Semáforo? ¿Pagar? ¡Error!"));
}
}
¿No es válido? Flush()
{
if(semFlush(id)?==?Error)? {
throw(VxRunTimeError("¿Semáforo? ¿Lavado? ¡Fallo!"));
}
}
¿SEM_ID? getId()
{
¿Regresión? id;
}
};
¿Clase? ¿VxSemB? :?¿público? ¿VxSem? {
Público:
VxSemB(int?Opts?=?SEM_Q_FIFO,?SEM_B_STATE?State?=?SEM_EMPTY)? :?VxSem(semBCreate?(Opts,?State))
{
If (id?==?0)?{
throw(VxRunTimeError( "¿Binario? ¿Semáforo? ¿Crear? ¡Fracaso!"));
}
}
};
¿Clase? ¿VxSemM? :?¿público? ¿VxSem? {
Público:
VxSemM(int?Opts?=?SEM_Q_PRIORITY?|?SEM_INVERT_SAFE?|?SEM_DELETE_SAFE)? :?VxSem(semMCreate?(Opts))
{
If (id?==?0)?{
throw(VxRunTimeError("Mutuamente excluyentes ? ¿Semáforo? ¡Fracaso!”);
}
¿Clase? ¿VxSemC? :?¿público? ¿VxSem? {
Público:
VxSemC(int?Opts,?int?Cnt)? :?VxSem(semCCreate?(Opts,?Cnt))
{
If (id?==?0)?{
throw(VxRunTimeError( "¿Contar? ¿Semáforo? ¿Crear? ¡Fracaso!"));
}
}
};