Referencia de la Clase Rhino

Clase para la gestion del estado del controlador del Servo Robot XR4. Más...

#include <rhino.h>

Lista de todos los miembros.

Métodos públicos

 Rhino ()
 Constructor.
 ~Rhino ()
 Destructor.
int InitMessageVectors (char[MAX_RB_ERROR_CODES][MSG_LENGTH], char[MAX_RC_ERROR_CODES][MSG_LENGTH], char[MAX_RB_STATUS_CODES][MSG_LENGTH], char[MAX_RC_STATUS_CODES][MSG_LENGTH])
 Inicializa los mensajes del sistema.
int set_LogLevel (unsigned int)
 Setea el niven de logueo.
int get_LogLevel (unsigned int *)
 Devuelve el nivel de logueo.
int get_ErrorMsg (char *)
 Devuelve el ultimo mensaje de error.
int get_ErrorMsg (unsigned int, char *)
 Devuelve el mensaje de error para el argumento pasado.
int get_ErrorCode (unsigned int *)
 Devuelve el ultimo codigo de error.
int get_StatusMsg (char *)
 Devuelve el ultimo mensaje de estado.
int get_StatusMsg (unsigned int, char *)
 Devuelve el mensaje de estado para el argumento pasado.
int get_StatusCode (unsigned int *)
 Devuelve el ultimo codigo de estado.
int ProcessCommandToRhino (char *)
 Procesa los comando enviado al controlador.
int ProcessMessageFromRhino (char *)
 Procesa los mensajes devueltos por el controlador.
int ProcessCommandToRhino (char *, unsigned int *)
 Procesa los comando enviado al controlador y devuelve su codigo.
int ProcessMessageFromRhino (unsigned int, char *, unsigned int *, char *)
 Procesa los mensajes devueltos por el controlador y devuelve el mensaje correspondiente.
int CBkMsg (void)
 Indica que hay un mensaje nuevo para la alicacion principal.
int get_CBkMsg (char *)
 Devuelve el mensaje correspondiente.
int LogMessage (int, char *)
 Loguea mensajes.
int DisplayAllErrorMessages (void)
 Visualiza todos los mensajes de error.

Tipos privados

enum  { LMODisplay, LMOFile, LMOCBk }

Métodos privados

int ProcessErrorMsg (unsigned int)
 Procesa codigos de error.
int ProcessStatusMsg (unsigned int)
 Procesa codigos de estado.

Atributos privados

unsigned int uiLogLevel
 Nivel de logueo.
unsigned int uiErrorCode
 Codigo de error.
unsigned int uiStatusCode
 Codigo de estado.
struct {
   unsigned int   uiLastCommandtoRhino
 Enum. del ultimo comando enviado.
   char   LastCommandtoRhino [MSG_LENGTH]
 Cadena enviada.
   char   LastMessageFromRhino [MSG_LENGTH]
 Cadena recibida.
LastCmdAndMsg
FILE * pFile
 Puntero al archivo para el logueo de datos.
char RhinoBotErrorMsg [MAX_RB_ERROR_CODES][MSG_LENGTH]
 Msgs de error.
char RhinoClassErrorMsg [MAX_RC_ERROR_CODES][MSG_LENGTH]
 Msgs de error.
char RhinoBotStatusMsg [MAX_RB_STATUS_CODES][MSG_LENGTH]
 Msgs de estado.
char RhinoClassStatusMsg [MAX_RC_STATUS_CODES][MSG_LENGTH]
 Msgs de estado.
char RhinoMessages [MSG_LENGTH]
 Contenedores auxiliares.
char cErrorMessage [MSG_LENGTH]
 Contenedores auxiliares.
char cStatusMessage [MSG_LENGTH]
 Contenedores auxiliares.
enum Rhino:: { ... }  logType
struct {
   bool   bNewMsg
 Indicador de nuevo mensaje.
   char   sCBkMessage [MSG_LENGTH]
 Mensaje.
CallBack


Descripción detallada

Clase para la gestion del estado del controlador del Servo Robot XR4.

Autor:
Marco Alvarez Reyna mail: marcoalrey@gmail.com
Documentado por: Daniel F. Marchetti mail: marchetti_daniel@hotmail.com

Versión:
2.4
Autor:
Marco Alvarez Reyna, mail: marcoalrey@gmail.com
Fecha:
04/2008

Definición en la línea 43 del archivo rhino.h.


Documentación de las enumeraciones miembro de la clase

anonymous enum [private]

Valores de la enumeración:
LMODisplay  Visualiza el mensage en el display.
LMOFile  Almacena el mensage en un archivo.
LMOCBk  Pasa el mensaje de error por el CallBack.

Definición en la línea 69 del archivo rhino.h.

00069          {
00070         LMODisplay, 
00071         LMOFile,    
00072         LMOCBk      
00073     }logType;


Documentación del constructor y destructor

Rhino::Rhino (  ) 

Constructor.

Parámetros:
Ninguno 
Devuelve:
No retorna valor
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
set_log_level.png

Definición en la línea 29 del archivo rhino.cpp.

00030 {
00031     /* Valores por defecto */
00032     uiErrorCode = 0; 
00033     uiStatusCode = 0; 
00034     uiLogLevel  = 3; 
00035     pFile       = NULL;
00036 
00037     InitMessageVectors(RhinoBotErrorMsg, RhinoClassErrorMsg, RhinoBotStatusMsg, RhinoClassStatusMsg);
00038 }

Rhino::~Rhino (  ) 

Destructor.

Parámetros:
Ninguno 
Devuelve:
No retorna valor
Autor:
Marco Alvarez Reyna
Fecha:
05/2007

Definición en la línea 52 del archivo rhino.cpp.

00053 {
00054     pFile       = NULL;
00055 }


Documentación de las funciones miembro

int Rhino::ProcessErrorMsg ( unsigned int  _uiErrorCode  )  [private]

Procesa codigos de error.

Rutina de procesamiento de errores.

Nota:
FUNCION PRIVADA
Parámetros:
_uiErrorCode 
Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
Process_error_msg.png

Definición en la línea 206 del archivo rhino.cpp.

00208 {
00209     if((_uiErrorCode < 0) || (_uiErrorCode > (MAX_RC_ERROR_CODES + MAX_RB_ERROR_CODES)))
00210     {
00211         ProcessErrorMsg(ERR_CODE);
00212     }
00213     else
00214     {
00215         uiErrorCode = _uiErrorCode;
00216 
00217         get_ErrorMsg(cErrorMessage);
00218         sprintf(RhinoMessages, "RhinoClass->ProcessErrorMsg:\n\túltimo cmd enviado: %s\n\tUltima cadena recibida: %s\n\tcódigo de error: %d\n\tLog Level: %d\n\tMSG: %s\n", LastCmdAndMsg.LastCommandtoRhino, LastCmdAndMsg.LastMessageFromRhino, uiErrorCode, uiLogLevel, cErrorMessage);
00219 
00220         if(uiLogLevel == 0)
00221         {
00222             LogMessage(LMOCBk, RhinoMessages);
00223         }
00224         if(uiLogLevel == 1)
00225         {
00226             LogMessage(LMODisplay, RhinoMessages);
00227         }
00228         if(uiLogLevel == 2)
00229         {
00230             LogMessage(LMOFile, RhinoMessages);
00231         }
00232         if(uiLogLevel == 3)
00233         {
00234             LogMessage(LMODisplay, RhinoMessages);
00235             LogMessage(LMOFile, RhinoMessages);
00236         }
00237     }
00238 
00239     return 0;
00240 }

int Rhino::ProcessStatusMsg ( unsigned int  _uiStatusCode  )  [private]

Procesa codigos de estado.

Rutina de manejo de mensajes de estado del sistema.

Nota:
FUNCION PRIVADA
Parámetros:
_uiStatusCode 
Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
Process_status_msg.png

Definición en la línea 259 del archivo rhino.cpp.

00260 {
00261      if((_uiStatusCode < 0) || (_uiStatusCode > (MAX_RC_STATUS_CODES + MAX_RB_STATUS_CODES)))
00262     {
00263         ProcessErrorMsg(ERR_CODE);
00264     }
00265     else
00266     {
00267         uiStatusCode = _uiStatusCode;
00268 
00269         get_StatusMsg(cStatusMessage);
00270         sprintf(RhinoMessages, "RhinoClass->ProcessStatusMsg:\n\túltimo cmd enviado: %s\n\tUltima cadena recibida: %s\n\tcódigo de estado: %d\n\tLog Level: %d\n\tMSG: %s\n", LastCmdAndMsg.LastCommandtoRhino, LastCmdAndMsg.LastMessageFromRhino, uiStatusCode, uiLogLevel, cStatusMessage);
00271 
00272         if(uiLogLevel == 0)
00273         {
00274             LogMessage(LMOCBk, RhinoMessages);
00275         }
00276         if(uiLogLevel == 1)
00277         {
00278             LogMessage(LMODisplay, RhinoMessages);
00279         }
00280         if(uiLogLevel == 2)
00281         {
00282             LogMessage(LMOFile, RhinoMessages);
00283         }
00284         if(uiLogLevel == 3)
00285         {
00286             LogMessage(LMODisplay, RhinoMessages);
00287             LogMessage(LMOFile, RhinoMessages);
00288         }
00289     }
00290 
00291     return 0;
00292 }

int Rhino::InitMessageVectors ( char  _RhinoBotErrorMsg[MAX_RB_ERROR_CODES][MSG_LENGTH],
char  _RhinoClassErrorMsg[MAX_RC_ERROR_CODES][MSG_LENGTH],
char  _RhinoBotStatusMsg[MAX_RB_STATUS_CODES][MSG_LENGTH],
char  _RhinoClassStatusMsg[MAX_RC_STATUS_CODES][MSG_LENGTH] 
)

Inicializa los mensajes del sistema.

Inicializa los vectores pasando como parámetrolos mensajes de error de la clase.

Parámetros:
_RhinoBotErrorMsg[MAX_RB_ERROR_CODES][MSG_LENGTH] 
_RhinoClassErrorMsg[MAX_RC_ERROR_CODES][MSG_LENGTH] 
_RhinoBotStatusMsg[MAX_RB_STATUS_CODES][MSG_LENGTH] 
_RhinoClassStatusMsg[MAX_RC_STATUS_CODES][MSG_LENGTH] 
Tareas Pendientes:
Falta completar los mensajes del sistemas
Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
InitMessageVectors.png

Definición en la línea 473 del archivo rhino.cpp.

00474              :  "unsigned int uiErrorCode"
00475                  MAX_RB_ERROR_CODES
00476                  MAX_RC_ERROR_CODES
00477                  MSG_LENGTH
00478 
00479    - de "0" a "MAX_RB_ERROR_CODES-1":
00480          Errores pertenecientes al controlador del brazo Rhino.
00481 
00482    - de "MAX_RB_ERROR_CODES" a "MAX_RB_ERROR_CODES + MAX_RC_ERROR_CODES": 
00483          Errores pertenecientes a la clase Rhino.
00484 
00485    -etc...
00486 
00487    - MSG_LENGTH es el largo maximo de los mensajes de error almacenados los 
00488      vectores
00489 */
00490 {
00491     const char RhinoBotErrorMsgSOURCE[MAX_RB_ERROR_CODES][MSG_LENGTH]={
00492         {"      Rhino Controller Error: BE HAPY, NO PROBLEM     "},
00493         {"      Rhino Controller Error: NO ERROR        "},
00494         {"      Rhino Controller Error: NO ERROR        "},
00495         {"      Rhino Controller Error: NO ERROR        "},
00496         {"      Rhino Controller Error: NO ERROR        "},
00497         {"      Rhino Controller Error: NO ERROR        "},
00498         {"      Rhino Controller Error: NO ERROR        "},
00499         {"      Rhino Controller Error: NO ERROR        "},
00500         {"      Rhino Controller Error: NO ERROR        "},
00501         {"      Rhino Controller Error: NO ERROR        "},
00502         {"      Rhino Controller Error: Invalid command.        "},
00503         {"      Rhino Controller Error: Parameter out of bounds.        "},
00504         {"      Rhino Controller Error: Missing parameter.      "},
00505         {"      Rhino Controller Error: Expected delimiter not seen.    "},
00506         {"      Rhino Controller Error: Command string too long.        "},
00507         {"      Rhino Controller Error: NO ERROR        "},
00508         {"      Rhino Controller Error: The teach pendant is active or busy.    "},
00509         {"      Rhino Controller Error: NO ERROR        "},
00510         {"      Rhino Controller Error: NO ERROR        "},
00511         {"      Rhino Controller Error: NO ERROR        "},
00512         {"      Rhino Controller Error: Host input buffer overflow.     "},
00513         {"      Rhino Controller Error: Host USART timed out.   "},
00514         {"      Rhino Controller Error: Host USART error (framing, parity, etc.).       "},
00515         {"      Rhino Controller Error: Teach pendant input buffer overflow.    "},
00516         {"      Rhino Controller Error: Teach pendant USART timed out.  "},
00517         {"      Rhino Controller Error: Teach pendant USART error (framing, parity, etc.).      "},
00518         {"      Rhino Controller Error: Teach pendant USART overrun.    "},
00519         {"      Rhino Controller Error: Host USART overrun.     "},
00520         {"      Rhino Controller Error: NO ERROR        "},
00521         {"      Rhino Controller Error: NO ERROR        "},
00522         {"      Rhino Controller Error: Bad RAM location.       "},
00523         {"      Rhino Controller Error: NO ERROR        "},
00524         {"      Rhino Controller Error: Teach pendant returned diagnostic error.        "},
00525         {"      Rhino Controller Error: NO ERROR        "},
00526         {"      Rhino Controller Error: Teach pendant not present.      "},
00527         {"      Rhino Controller Error: NO ERROR        "},
00528         {"      Rhino Controller Error: NO ERROR        "},
00529         {"      Rhino Controller Error: NO ERROR        "},
00530         {"      Rhino Controller Error: NO ERROR        "},
00531         {"      Rhino Controller Error: NO ERROR        "},
00532         {"      Rhino Controller Error: Missing label.  "},
00533         {"      Rhino Controller Error: No program in memory.   "},
00534         {"      Rhino Controller Error: Insufficient teach pendant memory.      "},
00535         {"      Rhino Controller Error: Insufficient EEPROM memory.     "},
00536         {"      Rhino Controller Error: Can't replace first record.     "},
00537         {"      Rhino Controller Error: A pendant program already exists.       "},
00538         {"      Rhino Controller Error: NO ERROR        "},
00539         {"      Rhino Controller Error: NO ERROR        "},
00540         {"      Rhino Controller Error: NO ERROR        "},
00541         {"      Rhino Controller Error: NO ERROR        "},
00542         {"      Rhino Controller Error: Hard home routine failed.       "},
00543         {"      Rhino Controller Error: Hard home not set.      "},
00544         {"      Rhino Controller Error: Soft home not set.      "},
00545         {"      Rhino Controller Error: Arithmetic overflow.    "},
00546         {"      Rhino Controller Error: Trig function returned error.   "},
00547         {"      Rhino Controller Error: Error stack overflow.   "},
00548         {"      Rhino Controller Error: Still executing a trapezoidal move.     "},
00549         {"      Rhino Controller Error: Inactive motor referenced.      "},
00550         {"      Rhino Controller Error: Insufficient move data (velocity or acceleration = 0).  "},
00551         {"      Rhino Controller Error: Improper motor mode for command.        "},
00552         {"      Rhino Controller Error: Limit switch A not found.       "},
00553         {"      Rhino Controller Error: Limit switch B not found.       "},
00554         {"      Rhino Controller Error: Limit switch C not found.       "},
00555         {"      Rhino Controller Error: Limit switch D not found.       "},
00556         {"      Rhino Controller Error: Limit switch E not found.       "},
00557         {"      Rhino Controller Error: Limit switch F not found.       "},
00558         {"      Rhino Controller Error: Limit switch G not found.       "},
00559         {"      Rhino Controller Error: Limit switch H not found.       "},
00560         {"      Rhino Controller Error: NO ERROR        "},
00561         {"      Rhino Controller Error: Interpolation move out of bounds.       "},
00562         {"      Rhino Controller Error: xvz position out of bounds.     "},
00563         {"      Rhino Controller Error: NO ERROR        "},
00564         {"      Rhino Controller Error: NO ERROR        "},
00565         {"      Rhino Controller Error: NO ERROR        "},
00566         {"      Rhino Controller Error: NO ERROR        "},
00567         {"      Rhino Controller Error: NO ERROR        "},
00568         {"      Rhino Controller Error: NO ERROR        "},
00569         {"      Rhino Controller Error: NO ERROR        "},
00570         {"      Rhino Controller Error: NO ERROR        "},
00571         {"      Rhino Controller Error: NO ERROR        "},
00572         {"      Rhino Controller Error: Limit switch A stuck.   "},
00573         {"      Rhino Controller Error: Limit switch B stuck.   "},
00574         {"      Rhino Controller Error: Limit switch C stuck.   "},
00575         {"      Rhino Controller Error: Limit switch D stuck.   "},
00576         {"      Rhino Controller Error: Lim it switch E stuck.  "},
00577         {"      Rhino Controller Error: Limit switch F stuck.   "},
00578         {"      Rhino Controller Error: Lim it switch G stuck.  "},
00579         {"      Rhino Controller Error: Lim it switch H stuck.  "},
00580         {"      Rhino Controller Error: NO ERROR        "},
00581         {"      Rhino Controller Error: NO ERROR        "},
00582         {"      Rhino Controller Error: NO ERROR        "},
00583         {"      Rhino Controller Error: Invalid robot type specifier.   "},
00584         {"      Rhino Controller Error: Invalid motor specifier.        "},
00585         {"      Rhino Controller Error: NO ERROR        "},
00586         {"      Rhino Controller Error: Invalid pendant mode.   "},
00587         {"      Rhino Controller Error: NO ERROR        "},
00588         {"      Rhino Controller Error: Invalid xyz specifier.  "},
00589         {"      Rhino Controller Error: Invalid xyz parameter.  "},
00590         {"      Rhino Controller Error: NO ERROR        "},
00591         {"      Rhino Controller Error: NO ERROR        "},
00592         {"      Rhino Controller Error: Motor A stalled.        "},
00593         {"      Rhino Controller Error: Motor B stalled.        "},
00594         {"      Rhino Controller Error: Motor C stalled.        "},
00595         {"      Rhino Controller Error: Motor D stalled.        "},
00596         {"      Rhino Controller Error: Motor E stalled.        "},
00597         {"      Rhino Controller Error: Motor F stalled.        "},
00598         {"      Rhino Controller Error: Motor G stalled.        "},
00599         {"      Rhino Controller Error: Motor H stalled.        "},
00600         {"      Rhino Controller Error: NO ERROR        "},
00601         {"      Rhino Controller Error: NO ERROR        "},
00602         {"      Rhino Controller Error: Motor A's current limit circuit was activated.  "},
00603         {"      Rhino Controller Error: Motor B's current limit circuit was activated.  "},
00604         {"      Rhino Controller Error: Motor C's current limit circuit was activated.  "},
00605         {"      Rhino Controller Error: Motor D's current limit circuit was activated.  "},
00606         {"      Rhino Controller Error: Motor E's current limit circuit was activated.  "},
00607         {"      Rhino Controller Error: Motor F's current limit circuit was activated.  "},
00608         {"      Rhino Controller Error: Motor G's current limit circuit was activated.  "},
00609         {"      Rhino Controller Error: Motor H's current limit circuit was activated.  "},
00610         {"      Rhino Controller Error: Aux Port 1's current limit circuit was activated.       "},
00611         {"      Rhino Controller Error: Aux Port 2's current limit circuit was activated.       "},
00612         {"      Rhino Controller Error: NO ERROR        "},
00613         {"      Rhino Controller Error: NO ERROR        "},
00614         {"      Rhino Controller Error: NO ERROR        "},
00615         {"      Rhino Controller Error: NO ERROR        "},
00616         {"      Rhino Controller Error: NO ERROR        "},
00617         {"      Rhino Controller Error: NO ERROR        "},
00618         {"      Rhino Controller Error: NO ERROR        "},
00619         {"      Rhino Controller Error: NO ERROR        "}   
00620     };
00621     
00622     const char RhinoClassErrorMsgSOURCE[MAX_RC_ERROR_CODES][MSG_LENGTH]={
00623         {"      Rhino Class Error:      BE HAPY, NO PROBLEM     "},
00624         {"      Rhino Class Error:      'Error Code' fuera de rango     "},
00625         {"      Rhino Class Error:      'Log Level' fuera de rango      "},
00626         {"      Rhino Class Error:      No se pudo crear el archivo de registro "},
00627         {"      Rhino Class Error:      NO ERROR        "},
00628         {"      Rhino Class Error:      NO ERROR        "},
00629         {"      Rhino Class Error:      NO ERROR        "},
00630         {"      Rhino Class Error:      NO ERROR        "},
00631         {"      Rhino Class Error:      NO ERROR        "},
00632         {"      Rhino Class Error:      NO ERROR        "},
00633         {"      Rhino Class Error:      NO ERROR        "},
00634         {"      Rhino Class Error:      NO ERROR        "},
00635         {"      Rhino Class Error:      NO ERROR        "},
00636         {"      Rhino Class Error:      NO ERROR        "},
00637         {"      Rhino Class Error:      NO ERROR        "},
00638         {"      Rhino Class Error:      NO ERROR        "},
00639         {"      Rhino Class Error:      NO ERROR        "},
00640         {"      Rhino Class Error:      NO ERROR        "},
00641         {"      Rhino Class Error:      NO ERROR        "},
00642         {"      Rhino Class Error:      NO ERROR        "},
00643         {"      Rhino Class Error:      NO ERROR        "},
00644         {"      Rhino Class Error:      NO ERROR        "},
00645         {"      Rhino Class Error:      NO ERROR        "},
00646         {"      Rhino Class Error:      NO ERROR        "},
00647         {"      Rhino Class Error:      NO ERROR        "},
00648         {"      Rhino Class Error:      NO ERROR        "},
00649         {"      Rhino Class Error:      NO ERROR        "},
00650         {"      Rhino Class Error:      NO ERROR        "},
00651         {"      Rhino Class Error:      NO ERROR        "},
00652         {"      Rhino Class Error:      NO ERROR        "},
00653         {"      Rhino Class Error:      NO ERROR        "},
00654         {"      Rhino Class Error:      NO ERROR        "}
00655     };
00656 
00657     for(int i=0; i<MAX_RB_ERROR_CODES; i++)
00658         strcpy(_RhinoBotErrorMsg[i], RhinoBotErrorMsgSOURCE[i]);
00659 
00660     for(int i=0; i<MAX_RC_ERROR_CODES; i++)
00661         strcpy(_RhinoClassErrorMsg[i], RhinoClassErrorMsgSOURCE[i]);
00662 
00663 /*Falta completar los mensajes del sistemas*/
00664     const char RhinoBotStatusMsgSOURCE[MAX_RB_STATUS_CODES][MSG_LENGTH]={
00665         {"      Rhino Controller Status:        BE HAPY, NO PROBLEM     "},
00666         {"      Rhino Controller Status:        At least one motor is performing a trapezoidal move"},
00667         {"      Rhino Controller Status:        A system error has ocurred"},
00668         {"      Rhino Controller Status:        The general purpose delay timer is active       "},
00669         {"      Rhino Controller Status:        At least one wait on input or wait on switch is still pending   "},
00670         {"      Rhino Controller Status:        No teach pedant is connected    "},
00671         {"      Rhino Controller Status:        The teach pedant ENTER key hast been pressed    "},
00672         {"      Rhino Controller Status:        The teach pedant ESCAPER key hast been pressed  "},
00673         {"      Rhino Controller Status:        A teach pedant error has ocurred        "},     
00674         {"      Rhino Controller Status:        Motor A is executing a trapezoidal move "},
00675         {"      Rhino Controller Status:        Motor B is executing a trapezoidal move "},
00676         {"      Rhino Controller Status:        Motor C is executing a trapezoidal move "},
00677         {"      Rhino Controller Status:        Motor D is executing a trapezoidal move "},
00678         {"      Rhino Controller Status:        Motor E is executing a trapezoidal move "},
00679         {"      Rhino Controller Status:        Motor F is executing a trapezoidal move "},
00680         {"      Rhino Controller Status:        Motor G is executing a trapezoidal move "},
00681         {"      Rhino Controller Status:        Motor H is executing a trapezoidal move "},
00682         {"      Rhino Controller Status:        The motor is either stationary or in a mode other than trapezoidal "},
00683         {"      Rhino Controller Status:        NC "}
00684     };
00685     const char RhinoClassStatusMsgSOURCE[MAX_RC_STATUS_CODES][MSG_LENGTH]={
00686         {"      Rhino Class Status:     BE HAPY, NO PROBLEM     "},
00687         {"      Rhino Class Status:     Se asume LogLevel 3 por defecto "},
00688         {"      Rhino Class Status:     Depuracion de comando pendiente "},
00689         {"      Rhino Class Status:     NC      "}
00690     };
00691     
00692     for(int i=0; i<MAX_RB_STATUS_CODES; i++)
00693         strcpy(_RhinoBotStatusMsg[i], RhinoBotStatusMsgSOURCE[i]);
00694     
00695     for(int i=0; i<MAX_RC_STATUS_CODES; i++)
00696         strcpy(_RhinoClassStatusMsg[i], RhinoClassStatusMsgSOURCE[i]);
00697     
00698     return 0;
00699 }

int Rhino::set_LogLevel ( unsigned int  _uiLogLevel  ) 

Setea el niven de logueo.

Setea el nivel de logueo de errores.

Parámetros:
_uiLogLevel 
Nota:
0: El mensaje de error se almacena en una variable de la clase.

1: Se muestran en consola los mensajes de error.

2: Se graban en un archivo los mensajes de error.

3: Los mensajes de error se graban en arch. y se muestran en consola.

Devuelve:
Valor distinto de cero en caso de error
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
set_log_level.png

Definición en la línea 80 del archivo rhino.cpp.

00081 {
00082     if(_uiLogLevel < 0 || _uiLogLevel > MAX_LOG_LEVEL)
00083     {
00084         uiLogLevel = 3; //Default LogLevel
00085         ProcessErrorMsg(LOG_LEV);
00086         ProcessStatusMsg(RC_DEF_LOG_LEV);
00087         return -1;      
00088     }
00089     
00090     uiLogLevel = _uiLogLevel;
00091     return 0;
00092 }

int Rhino::get_LogLevel ( unsigned int *  _uiLogLevel  ) 

Devuelve el nivel de logueo.

Devuelve el nivel de logueo de errores.

Parámetros:
_uiLogLevel 
Devuelve:
Nivel de logueo de errores
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
get_log_level.png

Definición en la línea 109 del archivo rhino.cpp.

00110 {
00111     *_uiLogLevel = uiLogLevel;
00112     return 0; 
00113 }

int Rhino::get_ErrorMsg ( char *  _cTextError  ) 

Devuelve el ultimo mensaje de error.

Devuelve el mensaje de error del último error producido.

Parámetros:
_cTextError 
Devuelve:
Mensaje de error del último error producido
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
get_error_msg.png

Definición en la línea 168 del archivo rhino.cpp.

00169 {
00170     /* Rhino Bot Errors */
00171     if(uiErrorCode >= 0 && uiErrorCode <= MAX_RB_ERROR_CODES)
00172     {
00173         strcpy(_cTextError, RhinoBotErrorMsg[uiErrorCode]);      
00174         return 0;
00175     }
00176 
00177     /* Rhino Class Errors */
00178     if(uiErrorCode > MAX_RB_ERROR_CODES && uiErrorCode <= (MAX_RB_ERROR_CODES + MAX_RC_ERROR_CODES))
00179     {
00180         strcpy(_cTextError, RhinoClassErrorMsg[uiErrorCode-MAX_RB_ERROR_CODES]);
00181         return 0;
00182     }
00183     
00184     ProcessErrorMsg(ERR_CODE);
00185     return -1;
00186 }

int Rhino::get_ErrorMsg ( unsigned int  _uiErrorCode,
char *  _cTextError 
)

Devuelve el mensaje de error para el argumento pasado.

Devuelve el mensaje de error corrspondiente al código de error requerido.

Parámetros:
_uiErrorCode 
_cTextError 
Devuelve:
Mensaje de error corrspondiente al código de error requerido
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
get_error_msg.png

Definición en la línea 132 del archivo rhino.cpp.

00133 {
00134     /* Rhino Bot Errors */
00135     if(_uiErrorCode >= 0 && _uiErrorCode <= MAX_RB_ERROR_CODES)
00136     {
00137         strcpy(_cTextError, RhinoBotErrorMsg[_uiErrorCode]);      
00138         return 0;
00139     }
00140 
00141     /* Rhino Class Errors */
00142     if(_uiErrorCode > MAX_RB_ERROR_CODES && _uiErrorCode <= (MAX_RB_ERROR_CODES + MAX_RC_ERROR_CODES))
00143     {
00144         strcpy(_cTextError, RhinoClassErrorMsg[_uiErrorCode-MAX_RB_ERROR_CODES]);
00145         return 0;
00146     }
00147     
00148     ProcessErrorMsg(ERR_CODE);
00149     return -1;
00150 }

int Rhino::get_ErrorCode ( unsigned int *  _uiErrorCode  ) 

Devuelve el ultimo codigo de error.

Devuelve el código de error del último error producido.

Nota:
FUNCION PRIVADA
Parámetros:
_uiErrorCode 
Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007

Definición en la línea 309 del archivo rhino.cpp.

00310 {
00311     *_uiErrorCode = uiErrorCode;
00312     return 0;
00313 }

int Rhino::get_StatusMsg ( char *  _cTextStatus  ) 

Devuelve el ultimo mensaje de estado.

Devuelve el mensaje de estado del último mensaje generado.

Parámetros:
_cTextStatus 
Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007

Definición en la línea 1081 del archivo rhino.cpp.

01082 {
01083     /* Rhino Bot Status Messages */
01084     if(uiStatusCode >= 0 && uiStatusCode <= MAX_RB_STATUS_CODES)
01085     {
01086         strcpy(_cTextStatus, RhinoBotStatusMsg[uiStatusCode]);      
01087         return 0;
01088     }
01089 
01090     /* Rhino Class Status Messages */
01091     if(uiStatusCode > MAX_RB_STATUS_CODES && uiStatusCode <= (MAX_RB_STATUS_CODES + MAX_RC_STATUS_CODES))
01092     {
01093         strcpy(_cTextStatus, RhinoClassStatusMsg[uiStatusCode-MAX_RB_STATUS_CODES]);
01094         return 0;
01095     }
01096     
01097     ProcessErrorMsg(ERR_CODE);
01098     return -1;
01099 }

int Rhino::get_StatusMsg ( unsigned int  _uiStatusCode,
char *  _cTextStatus 
)

Devuelve el mensaje de estado para el argumento pasado.

Devuelve el mensaje de estado corrspondiente al código de status pasado como parámetro.

Parámetros:
_uiStatusCode 
_cTextStatus 
Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007

Definición en la línea 1116 del archivo rhino.cpp.

01117 {
01118  /* Rhino Bot Status Messages*/
01119     if(_uiStatusCode >= 0 && _uiStatusCode <= MAX_RB_STATUS_CODES)
01120     {
01121         strcpy(_cTextStatus, RhinoBotStatusMsg[_uiStatusCode]);      
01122         return 0;
01123     }
01124 
01125     /* Rhino Class Status Messages*/
01126     if(_uiStatusCode > MAX_RB_STATUS_CODES && _uiStatusCode <= (MAX_RB_STATUS_CODES + MAX_RC_STATUS_CODES))
01127     {
01128         strcpy(_cTextStatus, RhinoClassStatusMsg[_uiStatusCode-MAX_RB_STATUS_CODES]);
01129         return 0;
01130     }
01131     
01132     ProcessErrorMsg(ERR_CODE);
01133     return -1;
01134 }

int Rhino::get_StatusCode ( unsigned int *  _uiStatusCode  ) 

Devuelve el ultimo codigo de estado.

Devuelve el código de status del último mensaje generado.

Parámetros:
_uiStatusCode 
Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007

Definición en la línea 1147 del archivo rhino.cpp.

01148 {
01149     *_uiStatusCode = uiStatusCode;
01150     return 0;
01151 }

int Rhino::ProcessCommandToRhino ( char *  _sCommand  ) 

Procesa los comando enviado al controlador.

Procesa los comandos de estado del sistema.

Parámetros:
_sCommand 
Nota:
parámetros:

[Status cmd I(char *)

I:in O:out

Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
ProcessCommandToRhino.png

Definición en la línea 722 del archivo rhino.cpp.

00723 {
00724     if(!strcmp(_sCommand, "SA") || !strcmp(_sCommand, "sa"))
00725         LastCmdAndMsg.uiLastCommandtoRhino = SA;
00726 //     else if(!strcmp(_sCommand, "SC") || !strcmp(_sCommand, "sc"))
00727 //      LastCmdAndMsg.uiLastCommandtoRhino = SC;
00728     else if(!strcmp(_sCommand, "SE") || !strcmp(_sCommand, "se"))
00729         LastCmdAndMsg.uiLastCommandtoRhino = SE;
00730 //     else if(!strcmp(_sCommand, "SM") || !strcmp(_sCommand, "sm"))
00731 //      LastCmdAndMsg.uiLastCommandtoRhino = SM;
00732 //     else if(!strcmp(_sCommand, "SP") || !strcmp(_sCommand, "sp"))
00733 //      LastCmdAndMsg.uiLastCommandtoRhino = SP;
00734     else if(!strcmp(_sCommand, "SS") || !strcmp(_sCommand, "ss"))
00735         LastCmdAndMsg.uiLastCommandtoRhino = SS;
00736 //     else if(!strcmp(_sCommand, "SU") || !strcmp(_sCommand, "su"))
00737 //      LastCmdAndMsg.uiLastCommandtoRhino = SU;
00738 //     else if(!strcmp(_sCommand, "SV") || !strcmp(_sCommand, "sv"))
00739 //      LastCmdAndMsg.uiLastCommandtoRhino = SV;
00740 //     else if(!strcmp(_sCommand, "SX") || !strcmp(_sCommand, "sx"))
00741 //      LastCmdAndMsg.uiLastCommandtoRhino = SX;
00742 //     else if(!strcmp(_sCommand, "SZ") || !strcmp(_sCommand, "sz"))
00743 //      LastCmdAndMsg.uiLastCommandtoRhino = SZ;
00744     else
00745         LastCmdAndMsg.uiLastCommandtoRhino = NC;
00746    
00747     strcpy(LastCmdAndMsg.LastCommandtoRhino, _sCommand);
00748     strcpy(LastCmdAndMsg.LastMessageFromRhino, "");
00749 
00750     return 0;
00751 /*CODIFICACION PENDIENTE*/
00752 }

int Rhino::ProcessMessageFromRhino ( char *  _StringCode  ) 

Procesa los mensajes devueltos por el controlador.

Procesa la respuesta del Rhino ante petitorios de estado y asocia los mensajes de error y estado correspondientes.

Parámetros:
_StringCode 
Nota:
parámetros:

Rhino message I(char *)

I:in O:out

Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007

Definición en la línea 836 del archivo rhino.cpp.

00837 {
00838     strcpy(LastCmdAndMsg.LastMessageFromRhino, _StringCode);
00839 
00840     if(LastCmdAndMsg.uiLastCommandtoRhino != NC){
00841         
00842         unsigned int _uiCode = atoi(_StringCode);
00843         
00844         switch(LastCmdAndMsg.uiLastCommandtoRhino)
00845         {
00846             case SS:
00847                 uiStatusCode = _uiCode;
00848                 
00849                 if(_uiCode & 128){
00850                     ProcessStatusMsg(RB_MOTOR_MOVE);
00851                 }
00852                 if(_uiCode & 64){
00853                     ProcessStatusMsg(RB_ERROR);
00854                 }
00855                 if(_uiCode & 32){
00856                     ProcessStatusMsg(RB_DTIMER_ACT);
00857                 }
00858                 if(_uiCode & 16){
00859                     ProcessStatusMsg(RB_WAIT_PENDING);
00860                 }
00861                 if(_uiCode & 8){
00862                     ProcessStatusMsg(RB_NO_TP);
00863                 }
00864                 if(_uiCode & 4){
00865                     ProcessStatusMsg(RB_TP_ENTER);
00866                 }
00867                 if(_uiCode & 2){
00868                     ProcessStatusMsg(RB_TP_ESC);
00869                 }
00870                 if(_uiCode & 1){
00871                     ProcessStatusMsg(RB_TP_ERROR);
00872                 }
00873                 if(_uiCode == 0){
00874                     ProcessStatusMsg(RB_STS_NS);
00875                 }
00876                 break;
00877                 
00878             case SA:
00879                 uiStatusCode = _uiCode;
00880                 
00881                 if(_uiCode & 128){
00882                     ProcessStatusMsg(RB_MOTOR_H_TMON);
00883                 }
00884                 if(_uiCode & 64){
00885                     ProcessStatusMsg(RB_MOTOR_G_TMON);
00886                 }
00887                 if(_uiCode & 32){
00888                     ProcessStatusMsg(RB_MOTOR_F_TMON);
00889                 }
00890                 if(_uiCode & 16){
00891                     ProcessStatusMsg(RB_MOTOR_E_TMON);
00892                 }
00893                 if(_uiCode & 8){
00894                     ProcessStatusMsg(RB_MOTOR_D_TMON);
00895                 }
00896                 if(_uiCode & 4){
00897                     ProcessStatusMsg(RB_MOTOR_C_TMON);
00898                 }
00899                 if(_uiCode & 2){
00900                     ProcessStatusMsg(RB_MOTOR_B_TMON);
00901                 }
00902                 if(_uiCode & 1){
00903                     ProcessStatusMsg(RB_MOTOR_A_TMON);
00904                 }
00905                 if(_uiCode == 0){
00906                     ProcessStatusMsg(RB_MOTORS_NOTM);
00907                 }
00908                 break;
00909                 
00910             case SE:
00911                 uiErrorCode = _uiCode;
00912                 ProcessErrorMsg(_uiCode);
00913                 break;
00914                 
00915             default:
00916                 ProcessStatusMsg(RC_DEP_CMD_PENDING);
00917                 break;
00918         }
00919         return 0;   
00920     }
00921     
00922     ProcessStatusMsg(RC_DEP_CMD_PENDING);
00923     return 0;
00924 /*CODIFICACION PENDIENTE*/
00925 }

int Rhino::ProcessCommandToRhino ( char *  _sCommand,
unsigned int *  _iCmdCode 
)

Procesa los comando enviado al controlador y devuelve su codigo.

Procesa los comandos de estado del sistema y devuelve el enumerador correspondiente a ese comando.

Parámetros:
_sCommand 
_iCmdCode 
Nota:
parámetros:

[Status cmd I(char *); Status cmd code O(unsigned int)]

I:in O:out

Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
ProcessCommandToRhino.png

Definición en la línea 777 del archivo rhino.cpp.

00778 {
00779     if(!strcmp(_sCommand, "SA") || !strcmp(_sCommand, "sa")){
00780         LastCmdAndMsg.uiLastCommandtoRhino = SA;
00781         *_iCmdCode = SA;
00782     }
00783 //    else if(!strcmp(_sCommand, "SC") || !strcmp(_sCommand, "sc"))
00784 //      *_iCmdCode = SC;
00785     else if(!strcmp(_sCommand, "SE") || !strcmp(_sCommand, "se")){
00786         LastCmdAndMsg.uiLastCommandtoRhino = SE;
00787         *_iCmdCode = SE;
00788     }
00789 //    else if(!strcmp(_sCommand, "SM") || !strcmp(_sCommand, "sm"))
00790 //      *_iCmdCode = SM;
00791 //    else if(!strcmp(_sCommand, "SP") || !strcmp(_sCommand, "sp"))
00792 //      *_iCmdCode = SP;
00793     else if(!strcmp(_sCommand, "SS") || !strcmp(_sCommand, "ss")){
00794         LastCmdAndMsg.uiLastCommandtoRhino = SS;
00795         *_iCmdCode = SS;
00796     }
00797 //    else if(!strcmp(_sCommand, "SU") || !strcmp(_sCommand, "su"))
00798 //      *_iCmdCode = SU;
00799 //     else if(!strcmp(_sCommand, "SV") || !strcmp(_sCommand, "sv"))
00800 //      *_iCmdCode = SV;
00801 //     else if(!strcmp(_sCommand, "SX") || !strcmp(_sCommand, "sx"))
00802 //      *_iCmdCode = SX;
00803 //     else if(!strcmp(_sCommand, "SZ") || !strcmp(_sCommand, "sz"))
00804 //      *_iCmdCode = SZ;
00805     else{
00806         LastCmdAndMsg.uiLastCommandtoRhino = NC;
00807         *_iCmdCode = NC;
00808     }
00809 
00810     strcpy(LastCmdAndMsg.LastCommandtoRhino, _sCommand);
00811     strcpy(LastCmdAndMsg.LastMessageFromRhino, "");
00812     
00813     return 0;
00814 /*CODIFICACION PENDIENTE*/
00815 }

int Rhino::ProcessMessageFromRhino ( unsigned int  _iStatusCmd,
char *  _StringCode,
unsigned int *  _iCode,
char *  _sMessage 
)

Procesa los mensajes devueltos por el controlador y devuelve el mensaje correspondiente.

Procesa la respuesta del Rhino ante petitorios de estado y asocia los mensajes de error y estado correspondientes.

Parámetros:
_iStatusCmd 
_StringCode 
_iCode 
_sMessage 
Nota:
parámetros:

[Status comd code I(unsigned int); Rhino message I(char *)

Rhino error code O(unsigned int)

Rhino error mesage O(char *)

I:in O:out

Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007

Definición en la línea 956 del archivo rhino.cpp.

00957 {
00958     strcpy(LastCmdAndMsg.LastMessageFromRhino, _StringCode);
00959 
00960     if(LastCmdAndMsg.uiLastCommandtoRhino != NC){
00961         
00962         *_iCode = atoi(_StringCode);
00963         
00964         unsigned int uiCode = *_iCode;
00965         
00966         switch(_iStatusCmd)
00967         {
00968             case SS:
00969                 uiStatusCode = uiCode;
00970                 
00971                 if(uiCode & 128){
00972                     ProcessStatusMsg(RB_MOTOR_MOVE);
00973                     get_StatusMsg(_sMessage);  // :S
00974                 }
00975                 if(uiCode & 64){
00976                     ProcessStatusMsg(RB_ERROR);
00977                     get_StatusMsg(_sMessage);  // :(
00978                 }
00979                 if(uiCode & 32){
00980                     ProcessStatusMsg(RB_DTIMER_ACT);
00981                     get_StatusMsg(_sMessage);
00982                 }
00983                 if(uiCode & 16){
00984                     ProcessStatusMsg(RB_WAIT_PENDING);
00985                     get_StatusMsg(_sMessage);
00986                 }
00987                 if(uiCode & 8){
00988                     ProcessStatusMsg(RB_NO_TP);
00989                     get_StatusMsg(_sMessage);
00990                 }
00991                 if(uiCode & 4){
00992                     ProcessStatusMsg(RB_TP_ENTER);
00993                     get_StatusMsg(_sMessage);
00994                 }
00995                 if(uiCode & 2){
00996                     ProcessStatusMsg(RB_TP_ESC);
00997                     get_StatusMsg(_sMessage);
00998                 }
00999                 if(uiCode & 1){
01000                     ProcessStatusMsg(RB_TP_ERROR);
01001                     get_StatusMsg(_sMessage);
01002                 }
01003                 if(uiCode == 0){
01004                     ProcessStatusMsg(RB_STS_NS);
01005                     get_StatusMsg(_sMessage);  // :D
01006                 }
01007                 break;
01008                 
01009             case SE:
01010                 uiErrorCode = uiCode;
01011                 ProcessErrorMsg(uiCode);
01012                 get_ErrorMsg(_sMessage);
01013                 break;
01014                 
01015             case SA:
01016                 uiStatusCode = uiCode;
01017                 
01018                 if(uiCode & 128){
01019                     ProcessStatusMsg(RB_MOTOR_H_TMON);
01020                     get_StatusMsg(_sMessage);
01021                 }
01022                 if(uiCode & 64){
01023                     ProcessStatusMsg(RB_MOTOR_G_TMON);
01024                     get_StatusMsg(_sMessage);
01025                 }
01026                 if(uiCode & 32){
01027                     ProcessStatusMsg(RB_MOTOR_F_TMON);
01028                     get_StatusMsg(_sMessage);
01029                 }
01030                 if(uiCode & 16){
01031                     ProcessStatusMsg(RB_MOTOR_E_TMON);
01032                     get_StatusMsg(_sMessage);
01033                 }
01034                 if(uiCode & 8){
01035                     ProcessStatusMsg(RB_MOTOR_D_TMON);
01036                     get_StatusMsg(_sMessage);
01037                 }
01038                 if(uiCode & 4){
01039                     ProcessStatusMsg(RB_MOTOR_C_TMON);
01040                     get_StatusMsg(_sMessage);
01041                 }
01042                 if(uiCode & 2){
01043                     ProcessStatusMsg(RB_MOTOR_B_TMON);
01044                     get_StatusMsg(_sMessage);
01045                 }
01046                 if(uiCode & 1){
01047                     ProcessStatusMsg(RB_MOTOR_A_TMON);
01048                     get_StatusMsg(_sMessage);
01049                 }
01050                 if(uiCode == 0){
01051                     ProcessStatusMsg(RB_MOTORS_NOTM);
01052                     get_StatusMsg(_sMessage);
01053                 }
01054                 break;
01055                 
01056             default:
01057                 ProcessStatusMsg(RC_DEP_CMD_PENDING);
01058                 break;
01059         }
01060         return 0;    
01061     }
01062     
01063     ProcessStatusMsg(RC_DEP_CMD_PENDING);
01064     return 0;
01065 /*CODIFICACION PENDIENTE*/
01066 }

int Rhino::CBkMsg ( void   ) 

Indica que hay un mensaje nuevo para la alicacion principal.

Permite saber si hay mensajes pendientes por reportar.

Parámetros:
Ninguno 
Devuelve:
Si hay algun mensaje pendiente por reportar devuelve true
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
CBKMsg.png

Definición en la línea 415 del archivo rhino.cpp.

00416 {
00417     if(CallBack.bNewMsg == true)
00418         return 1;
00419     else 
00420         return 0;
00421 }

int Rhino::get_CBkMsg ( char *  _Message  ) 

Devuelve el mensaje correspondiente.

Devulve el último mensaje reportado por la clase.

Parámetros:
_Message 
Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
Get_CBKMsg.png

Definición en la línea 438 del archivo rhino.cpp.

00439 {
00440     if(CallBack.bNewMsg == true){
00441         strcpy(_Message, CallBack.sCBkMessage);
00442         CallBack.bNewMsg = false;
00443     }
00444     else
00445         strcpy(_Message, "No new message from Rhino Class\n");
00446 
00447     return 0;
00448 }

int Rhino::LogMessage ( int  _LogType,
char *  _Message 
)

Loguea mensajes.

Muestra y almacena mensajes del sistema.

Parámetros:
_LogType 
_Message 
Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
LogMessage.png

Definición en la línea 372 del archivo rhino.cpp.

00373 {
00374     if(_LogType == LMOCBk)
00375     {
00376         strcpy(CallBack.sCBkMessage, _Message);
00377         CallBack.bNewMsg = true;
00378     }
00379 
00380     if(_LogType == LMODisplay)
00381     {
00382         fprintf(stderr, "%s", _Message);
00383     }
00384 
00385     if(_LogType == LMOFile)
00386     {
00387         pFile = fopen("rc_error_log.txt","a+");
00388         if(pFile == NULL){
00389             ProcessErrorMsg(NO_FILE);
00390             return -1;
00391         }
00392         fprintf(pFile,"%s\n", _Message);
00393         fclose(pFile);
00394     }
00395 
00396     return 0;
00397 }

int Rhino::DisplayAllErrorMessages ( void   ) 

Visualiza todos los mensajes de error.

Imprime todos los mensajes de error.

Parámetros:
Ninguno 
Devuelve:
Si retorna 0 la ejecucion fue exitosa. En caso contrario devuelve -1
Autor:
Marco Alvarez Reyna
Fecha:
05/2007
DisplayAllErrorMessages.png

Definición en la línea 330 del archivo rhino.cpp.

00331 {
00332     sprintf(RhinoMessages, "ERROR MESSEGES\n\n");
00333     LogMessage(LMODisplay, RhinoMessages);
00334     int i=0;
00335     
00336     sprintf(RhinoMessages, "RHINO CONTROLLER ERRORS\n");
00337     LogMessage(LMODisplay, RhinoMessages);
00338     for(i=0; i<MAX_RB_ERROR_CODES ; i++)
00339     {
00340         sprintf(RhinoMessages, "CODE:%d %s\n", i, RhinoBotErrorMsg[i]);
00341         LogMessage(LMODisplay, RhinoMessages);
00342     }
00343 
00344     sprintf(RhinoMessages, "\nRHINO CLASS ERRORS\n");
00345     LogMessage(LMODisplay, RhinoMessages);
00346     for(i=0; i<MAX_RC_ERROR_CODES ; i++)
00347     {
00348         sprintf(RhinoMessages, "CODE:%d %s\n", i, RhinoClassErrorMsg[i]);
00349         LogMessage(LMODisplay, RhinoMessages);
00350     }
00351 
00352     return 0;
00353 }


Documentación de los datos miembro

unsigned int Rhino::uiLogLevel [private]

Nivel de logueo.

Definición en la línea 45 del archivo rhino.h.

unsigned int Rhino::uiErrorCode [private]

Codigo de error.

Definición en la línea 46 del archivo rhino.h.

unsigned int Rhino::uiStatusCode [private]

Codigo de estado.

Definición en la línea 47 del archivo rhino.h.

unsigned int Rhino::uiLastCommandtoRhino

Enum. del ultimo comando enviado.

Definición en la línea 51 del archivo rhino.h.

char Rhino::LastCommandtoRhino[MSG_LENGTH]

Cadena enviada.

Definición en la línea 52 del archivo rhino.h.

char Rhino::LastMessageFromRhino[MSG_LENGTH]

Cadena recibida.

Definición en la línea 53 del archivo rhino.h.

struct { ... } Rhino::LastCmdAndMsg [private]

FILE* Rhino::pFile [private]

Puntero al archivo para el logueo de datos.

Definición en la línea 56 del archivo rhino.h.

char Rhino::RhinoBotErrorMsg[MAX_RB_ERROR_CODES][MSG_LENGTH] [private]

Msgs de error.

Definición en la línea 58 del archivo rhino.h.

char Rhino::RhinoClassErrorMsg[MAX_RC_ERROR_CODES][MSG_LENGTH] [private]

Msgs de error.

Definición en la línea 59 del archivo rhino.h.

char Rhino::RhinoBotStatusMsg[MAX_RB_STATUS_CODES][MSG_LENGTH] [private]

Msgs de estado.

Definición en la línea 61 del archivo rhino.h.

char Rhino::RhinoClassStatusMsg[MAX_RC_STATUS_CODES][MSG_LENGTH] [private]

Msgs de estado.

Definición en la línea 62 del archivo rhino.h.

char Rhino::RhinoMessages[MSG_LENGTH] [private]

Contenedores auxiliares.

Definición en la línea 64 del archivo rhino.h.

char Rhino::cErrorMessage[MSG_LENGTH] [private]

Contenedores auxiliares.

Definición en la línea 65 del archivo rhino.h.

char Rhino::cStatusMessage[MSG_LENGTH] [private]

Contenedores auxiliares.

Definición en la línea 66 del archivo rhino.h.

enum { ... } Rhino::logType [private]

bool Rhino::bNewMsg

Indicador de nuevo mensaje.

Definición en la línea 77 del archivo rhino.h.

char Rhino::sCBkMessage[MSG_LENGTH]

Mensaje.

Definición en la línea 78 del archivo rhino.h.

struct { ... } Rhino::CallBack [private]


La documentación para esta clase fué generada a partir de los siguientes ficheros:
Generado el Wed Jun 18 19:42:44 2008 para Documentacion de la clase Rhino por  doxygen 1.5.4