int obtenerModoAceleracion(int *modoAceleracion){
static unsigned char sbuf[2];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_OBTENER_MODO_ACELERACION;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("obtenerModoAceleracion: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("obtenerModoAceleracion: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
*modoAceleracion = sbuf[0];
return (0);
}
}
}
int obtenerDatosEnergia(double *voltajeBateria, double *corrienteMotor1, double *corrienteMotor2){
static unsigned char sbuf[3];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_OBTENER_DATOS_ENERGIA;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("obtenerDatosEnergia: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,3, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("obtenerDatosEnergia: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
*voltajeBateria = sbuf[0];
*corrienteMotor1 = sbuf[1]/10;
*corrienteMotor2 = sbuf[2]/10;
return (0);
}
}
}
int obtenerNumeroVersionSoftware(double *versionSoftware){
static unsigned char sbuf[2];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_OBTENER_VERSION_SOFTWARE;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("obtenerNumeroVersion: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("obtenerNumeroVersion: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
*versionSoftware = sbuf[0];
return (0);
}
}
}
int obtenerMedidaSensorUS(int idSensorUS, int *distanciaUS){
static unsigned char sbuf[4];
unsigned long _distanciaUS;
int escribir, leer;
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = OBTENER_MEDIDA_US;
sbuf[2] = idSensorUS;
sbuf[3] = BYTE_FIN_COMANDO;
escribir = escribirDatos(fdPercepcion, 4, sbuf);
if(escribir != 0){
#ifdef PERCEPCION_DEBUG
perror("obtenerMedidaSensorUS: Error al intentar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(50000);
leer = leerDatos(fdPercepcion,2, sbuf);
if(leer != 0){
#ifdef PERCEPCION_DEBUG
perror("obtenerMedidaSensorUS: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
_distanciaUS = sbuf[0];
_distanciaUS = (_distanciaUS<<8)+sbuf[1];
*distanciaUS = (int)_distanciaUS;
return (0);
}
}
}
int obtenerVolajeBateria(double *voltajeBateria){
static unsigned char sbuf[2];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_OBTENER_VOLTAJE_BATERIA;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("obtenerVolajeBateria: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("obtenerVolajeBateria: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
*voltajeBateria = sbuf[0];
return (0);
}
}
}
int obtenerBarridoFrontalIR(int *distanciasIR){
static unsigned char sbuf[6];
int escribir, leer, i;
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = OBTENER_BARRIDO_FRONTAL_IR;
sbuf[3] = BYTE_FIN_COMANDO;
escribir = escribirDatos(fdPercepcion, 3, sbuf);
if(escribir != 0){
#ifdef PERCEPCION_DEBUG
perror("obtenerBarridoFrontalIR: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(1200000);
leer = leerDatos(fdPercepcion,6, sbuf);
if(leer != 0){
#ifdef PERCEPCION_DEBUG
perror("obtenerBarridoFrontalIR: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
for( i = 0; i < 6; ++i ){
distanciasIR[i] = (int)sbuf[i];
}
return (0);
}
}
}
int obtenerBarridoTraseroUS(int *distanciasUST){
static unsigned char sbuf[10];
unsigned long _distanciasUST;
int escribir, leer, i;
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = OBTENER_BARRIDO_TRASERO;
sbuf[2] = BYTE_FIN_COMANDO;
escribir = escribirDatos(fdPercepcion,3,sbuf);
if(escribir != 0){
#ifdef PERCEPCION_DEBUG
perror("obtenerBarridoTraseroUS: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(700000);
leer = leerDatos(fdPercepcion,10, sbuf);
if(leer != 0){
#ifdef PERCEPCION_DEBUG
perror("obtenerBarridoTraseroUS: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
for ( i = 0; i < 5; ++i ) {
_distanciasUST = sbuf[i*2];
_distanciasUST = (_distanciasUST<<8)+sbuf[(i*2)+1];
distanciasUST[i] = (int)_distanciasUST;
}
return (0);
}
}
}
int obtenerCodificadorMotor1(int *codificadorPosicion1){
static unsigned char sbuf[4];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_OBTENER_CODIFICADOR_MOTOR_1;
unsigned long _codificador;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("obtenerCodificadorMotor1: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,4, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("obtenerCodificadorMotor1: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
_codificador = sbuf[0];
_codificador = (_codificador<<8)+sbuf[1];
_codificador = (_codificador<<8)+sbuf[2];
_codificador = (_codificador<<8)+sbuf[3];
*codificadorPosicion1 = (int)_codificador;
return (0);
}
}
}
void Cliente::run() {
mutex.lock();
socket = new QTcpSocket();
qintptr descriptor = socket_descriptor;
// Asignar descriptor al socket
if(!socket->setSocketDescriptor(descriptor)) {
emit error(socket->error());
return;
}
mutex.unlock();
qDebug() << "El cliente" << descriptor << "se ha conectado.";
while (1) {
leerDatos();
// Salir del bucle
QMutexLocker locker(&mutex); // Mis dudas con QMutexLocker AQUI
if (finalizar || socket->state() == QAbstractSocket::UnconnectedState)
break;
}
// Cerrar conexión y salir de run()
mutex.lock(); // ¿Lock y Unlock, o sigue en pie Locker?
socket->disconnectFromHost();
if (socket->state() != QAbstractSocket::UnconnectedState)
if (socket->waitForDisconnected(-1))
qDebug() << "El cliente" << descriptor << "se ha desconectado.";
socket->deleteLater();
qRegisterMetaType<Cliente*>("Cliente");
emit desconectado(this);
mutex.unlock();
}
int obtenerVelocidad2(double *velocidad){
static unsigned char sbuf[2];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_OBTENER_VELOCIDAD_2;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("obtenerVelocidad2: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("obtenerVelocidad2: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
*velocidad = sbuf[0];
return (0);
}
}
}
int obtenerCorrienteMotor2(double *corrienteMotor2){
static unsigned char sbuf[2];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_OBTENER_CORRIENTE_MOTOR_2;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("obtenerCorrienteMotor2: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("obtenerCorrienteMotor2: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
*corrienteMotor2 = sbuf[0]/10;
return (0);
}
}
}
int obtenerMedidaSensorIR(int idSensorIR, int *distanciaIR){
static unsigned char sbuf[4];
int escribir, leer;
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = OBTENER_MEDIDA_IR;
sbuf[2] = idSensorIR;
sbuf[3] = BYTE_FIN_COMANDO;
escribir = escribirDatos(fdPercepcion, 4, sbuf);
if(escribir != 0){
#ifdef PERCEPCION_DEBUG
perror("obtenerMedidaSensorIR: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(50000);
leer = leerDatos(fdPercepcion,1, sbuf);
if(leer != 0){
#ifdef PERCEPCION_DEBUG
perror("obtenerMedidaSensorIR: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
*distanciaIR = (int)sbuf[0];
return (0);
}
}
}
int asignarModoVelocidad(int modoVelocidad){
static unsigned char sbuf[3];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_ASIGNAR_MODO_VELOCIAD;
sbuf[2] = modoVelocidad;
int escribir, leer;
escribir = escribirDatos(fd, 3, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("asignarModoVelocidad:Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("asignarModoAceleracion: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
return (0);
}
}
}
int asignarVelocidad1(double velocidad1){
static unsigned char sbuf[3];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_ASIGNAR_VELOCIDAD_1;
sbuf[2] = velocidad1;
int escribir,leer;
escribir = escribirDatos(fd, 3, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("asignarVelocidad1: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("asignarVelocidad1: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
return (0);
}
}
}
int obtenerError(int *error){
static unsigned char sbuf[2];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_OBTENER_ERROR;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("obtenerError: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("obtenerError: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
if(sbuf[0] == 0){
*error = 0; //no hay ningún error en la controladora MD49.
}
if(sbuf[0] & ERROR_BAJO_VOLTAJE){
*error = -1; //error -1: se detecto bajo voltaje en la alimentación de la MD49.
}
if(sbuf[0] & ERROR_ALTO_VOLTAJE){
*error = -2; //error -2: se detecto alto voltaje en la alimentación de la MD49.
}
if(sbuf[0] & ERROR_CORRIENTE_MOTOR_1){
*error = -3; //error -3: se detecto alto consumo de corriente por parte del motor 1.
}
if(sbuf[0] & ERROR_CORRIENTE_MOTOR_2){
*error = -4; //error -4: se detecto alto consumo de corriente por parte del motor 2.
}
if(sbuf[0] & ERROR_CORTO_MOTOR_1){
*error = -5; //error -5: se detecto corto en el motor 1.
}
if(sbuf[0] & ERROR_CORTO_MOTOR_2){
*error = -6; //error -6: se detecto corto en el motor 2.
}
return (0);
}
}
}
int reinicializarCodificadores(){
static unsigned char sbuf[2];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_REINICIO_CONTADOR_CODIFICADOR;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("reinicializarCodificadores: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("reinicializarCodificadores: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
return (0);
}
}
}
int desactivarTiempoSeguridad(){
static unsigned char sbuf[2];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_DESACTIVAR_TIEMPO_SEGURIDAD;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("desactivarTiempoSeguridad: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("desactivarTiempoSeguridad: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
return (0);
}
}
}
int desactivarRetroalimentacionCodificadores(){
static unsigned char sbuf[2];
sbuf[0] = BYTE_SINCRONIZACION;
sbuf[1] = COMANDO_DESACTIVAR_RETROALIMENTACION;
int escribir, leer;
escribir = escribirDatos(fd, 2, sbuf);
if(escribir != 0){
#ifdef MD49_DEBUG
perror("desactivarRetroalimentacionCodificadores: Error al intenetar escribir el comando.\n");
#endif
return (-1);
}else{
usleep(RETRASO);
leer = leerDatos(fd,1, sbuf);
if(leer != 0){
#ifdef MD49_DEBUG
perror("desactivarRetroalimentacionCodificadores: Error el comando no se ejecuto correctamente.\n");
#endif
return (-2);
}else{
return (0);
}
}
}
/* Funcion Principal */
int main(int argc, char *argv[]){
FILE *fp; // Puntero a archivo que representa nuestro archivo
char archivo[longitudFichero]; // Nombre del archivo
int i, j, numProcesos, numPaginasProceso; // Variable auxiliares
/* Estructuras utilizadas en el ejercicio */
registro t_registros[max_procesos]; // Registro Base/Limite
paginacion t_paginacion; // Paginacion
segmentacion t_segmentacion; // Segmentacion
/* Obtenemos el nombre del fichero de entrada de datos mediante parametros
o pidiendolo por teclado en caso contrario */
if (argc == 1){
printf ("Fichero no introducido por parametros. Introduzca nombre del fichero: ");
gets(archivo);
}
else{
strcpy(archivo,argv[1]);
}
system("cls");
if((fp=fopen(archivo,"r"))==NULL){
system("cls");
printf ("Error. Archivo no encontrado\n");
system("pause");
}
else if (!datosEntradaValidos(fp)){
printf ("--------------------------------------------------------------------------------\n");
printf ("La informacion del fichero no es valida. Debe cumplir el siguiente formato: \n\n");
printf ("Fichero de texto con los datos divididos mediante un salto de linea.\n");
printf ("A su vez cada linea de datos divididos por espacios:\n\n");
printf ("1ª linea -> Numero de procesos.\n");
printf ("2ª linea -> RB y RL de cada proceso.\n");
printf ("3ª linea -> RBTS y RLTS de cada proceso.\n");
printf ("4ª linea -> RB y RL de cada segmento de cada proceso.\n");
printf ("5ª linea -> Tamaño de pagina.\n");
printf ("6ª linea -> Tipo de Paginacion: 0 -> PMT Global, 1 -> PMT por proceso.\n");
printf ("7ª linea -> RBTP y RLTP de cada proceso.\n");
printf ("8ª linea -> Marco de pagina asociado a cada pagina de cada proceso.\n\n");
printf ("--------------------------------------------------------------------------------\n");
system("pause");
}else{
/* Rebobinamos el puntero a fichero despues de haber verificado sus datos */
rewind (fp);
/*******************************/
/* Lectura de datos de fichero */
/*******************************/
leerDatos(fp, &numProcesos, t_registros, &t_paginacion, &t_segmentacion);
/**********************************************************/
/* Salida de la informacion por pantalla - Datos Procesos */
/**********************************************************/
mostrarDatos(archivo, numProcesos, t_registros, t_paginacion, t_segmentacion);
fclose(fp);
fp = NULL;
/*********************************************************************/
/* Salida de la informacion por pantalla - Traduccion de direcciones */
/*********************************************************************/
traducirDirecciones(archivo, numProcesos, t_registros, t_paginacion, t_segmentacion);
}
return 0;
}
