lego9751.C

Ir a la documentación de este archivo.

//===========================================================================
//= lego9751.cc                                              Agosto de 1998 =
//=-------------------------------------------------------------------------=
//= Definiciones de la clase para el control de la interface LEGO9751       =
//=-------------------------------------------------------------------------=
//= ADVERTENCIA: ESTE SOFTWARE NO ESTA CONCEBIDO NI DISENNADO PARA EL USO   =
//= EN EQUIPO DE CONTROL EN LINEA EN ENTORNOS PELIGROSOS QUE REQUIERAN UN   =
//= DESEMPENNO LIBRE DE FALLAS, COMO LA OPERACION DE PLANTAS NUCLEARES,     = 
//= SISTEMAS DE NAVEGACION O COMUNICACION EN AVIONES, TRAFICO AEREO,        =
//= EQUIPO MEDICO DEL CUAL DEPENDAN VIDAS HUMANAS O SISTEMAS DE ARMAMENTO,  =
//= EN LOS CUALES UNA FALLA EN EL SOFTWARE PUEDA IMPLICAR DIRECTAMENTE LA   =
//= MUERTE, DANNOS PERSONALES O DANNOS FISICOS Y/O AMBIENTALES GRAVES       =
//= ("ACTIVIDADES DE ALGO RIESGO").                                         =
//=-------------------------------------------------------------------------=
//= Autor original: Oscar J. Chavarro G.  A.K.A. JEDILINK. Copyright (c),   =
//= 1997 - 2003, oscarchavarro@hotmail.com                                  =
//= AQUYNZA es software libre, y se rige bajo los terminos de la licencia   =
//= LGPL de GNU (http://www.gnu.org). Para mayor informacion respecto a la  =
//= licencia de uso, consulte el archivo ./doc/LICENCIA en la distribucion. =
//= Con la colaboracion de Harold Cruz              ha-cruz@uniandes.edu.co =
//===========================================================================

#if PLATAFORMA == i386_LINUX_GCC || PLATAFORMA == ALPHA || PLATAFORMA == SPARC64_LINUX_GCC
 // OJO: Esto es machete!

#include "toolkits/media/lego9751.h"

#include <string.h>

//===========================================================================
//= Funciones de soporte                                                    =
//===========================================================================

void
leer_lego_callback(void *User_data, int /*accion*/)
{
    LEGO9751 *L = ((LEGO9751*)User_data);
    PUERTO_SERIAL *Com = L->Com;
    char buffer[19];  // La interface enviara maximo 19 bytes
    int bytes_leidos;
    int p;

    bytes_leidos = Com->leer(buffer, 19);

    for ( p = 0; p < bytes_leidos; p++ ) {
        L->input_state[L->accum] = buffer[p];  // OJO: { 0 <= L->accum < 19 }
        if ( L->accum == 18 ) {
            // Nos topamos con un principio de paquete!
            L->accum = -1;
            L->actualizar();
        }
        L->accum++;
    }
}

//===========================================================================
// Clase LEGO9751                                                           =
//===========================================================================

LEGO9751::LEGO9751()
{
    int i;

    accum = 0;
    for ( i = 0; i < 19; i++ ) input_state[i] = 0; 
    for ( i = 0; i < 19; i++ ) data_state[i] = 0;
}

LEGO9751::~LEGO9751()
{
    cerrar();
}

void
LEGO9751::cerrar(void)
{
    if ( Com ) {
        Com->cerrar();
        delete Com;
        Com = 0;
    }
}

WORD
LEGO9751::lea_sensor(int num_sensor)
{
    BYTE msb, lsb;
    int grupo;

    num_sensor--;
    grupo = 3-(num_sensor%4);

    msb = data_state[2 + 2*(2*grupo+num_sensor/4)];
    lsb = data_state[2 + 2*(2*grupo+num_sensor/4)];

    //printf("N = %d [%3d][%3d]\n", num_sensor+1, msb, lsb);
    //fflush(stdout);

    return (WORD)(65535 - ((WORD)msb * 256 + (WORD)lsb));
}

void
LEGO9751::encendido(int actuador)
{
    char c;

    if ( actuador < 1 || actuador > 8 ) return;
    switch ( actuador ) {
      case 1: c = '('; break;
      case 2: c = ')'; break;
      case 3: c = '*'; break;
      case 4: c = '+'; break;
      case 5: c = ','; break;
      case 6: c = '-'; break;
      case 7: c = '.'; break;
      case 8: default: c = '/'; break;
    }
    Com->escribir(&c, 1);
}

void
LEGO9751::apagado(int actuador)
{
    char c;

    if ( actuador < 1 || actuador > 8 ) return;
    switch ( actuador ) {
      case 1: c = '8'; break;
      case 2: c = '9'; break;
      case 3: c = ':'; break;
      case 4: c = ';'; break;
      case 5: c = '<'; break;
      case 6: c = '='; break;
      case 7: c = '>'; break;
      case 8: default: c = '?'; break;
    }
    Com->escribir(&c, 1);
}

void
LEGO9751::fderecha(int actuador)
{
    char c;

    if ( actuador < 1 || actuador > 8 ) return;
    switch ( actuador ) {
      case 1: c = 'H'; break;
      case 2: c = 'I'; break;
      case 3: c = 'J'; break;
      case 4: c = 'K'; break;
      case 5: c = 'L'; break;
      case 6: c = 'M'; break;
      case 7: c = 'N'; break;
      case 8: default: c = 'O'; break;
    }
    Com->escribir(&c, 1);
}

void
LEGO9751::fizquierda(int actuador)
{
    char c;

    if ( actuador < 1 || actuador > 8 ) return;
    switch ( actuador ) {
      case 1: c = '@'; break;
      case 2: c = 'A'; break;
      case 3: c = 'B'; break;
      case 4: c = 'C'; break;
      case 5: c = 'D'; break;
      case 6: c = 'E'; break;
      case 7: c = 'F'; break;
      case 8: default: c = 'G'; break;
    }
    Com->escribir(&c, 1);
}

void
LEGO9751::fpotencia(int actuador, int potencia)
{
    unsigned char buffer[2];

    if ( actuador < 1 || actuador > 7 || potencia < 0 || potencia > 7 ) return;

    buffer[0] = (unsigned char)(0xB0 + potencia);
    switch ( actuador ) {
      case 1: buffer[1] = 0x01; break;
      case 2: buffer[1] = 0x02; break;
      case 3: buffer[1] = 0x04; break;
      case 4: buffer[1] = 0x08; break;
      case 5: buffer[1] = 0x10; break;
      case 6: buffer[1] = 0x20; break;
      case 7: buffer[1] = 0x40; break;
      case 8: default: buffer[1] = 0x80; break;
    }

    Com->escribir((char *)buffer, 2);
}

void
LEGO9751::enviar_latido(void)
{
    char latido = 2;

    Com->escribir(&latido, 1);
}

void
LEGO9751::actualizar(void)
{
    int i;

    for ( i = 0; i < 19; i++ ) {
        data_state[i] = input_state[i];
    }

    static int j = 0;
    if ( j % 150 == 0 ) {
        enviar_latido();
        j = 0;
    }
    j++;
}

BOOLEAN
LEGO9751::busque_controlador(void)
{
    char cad[100];
    int i;

    strcpy(cad, "p\0###Do you byte, when I knock?$$$");
    
    if ( !Com ) {
        return FALSE;
    }

    //- Escriba el comando de inicializacion-
    Com->escribir(cad, sizeof(cad));
    //printf("Envie la cadena de busqueda.\n");
    // OJO: Aqui se le da un rato al modem. Porque toca hacer esto?
    SLEEP_MICROSEC(1000000);

    //- Lea una respuesta, que se espera, sea de 99 o menos caracteres -
    i = Com->leer(cad, 31);
    if ( i < 0 ) i = -i;
    cad[i] = '\0';
    //printf("Recibi como respuesta los siguientes %d bytes:\n%s\n", i, cad);

    return TRUE;
}


BOOLEAN
LEGO9751::inicialice(char *nombre_puerto)
{
    Com = new PUERTO_SERIAL(nombre_puerto);

    if ( !Com ) {
        return FALSE;
    }

    //- Inicializacion del puerto serial -
    Com->configurar(PSV9600, PSP_NONE, PSS_UNO, PSD8, PSF_NONE);
    if ( !Com->abrir() ) {
        delete Com;
        Com = 0;
        return FALSE;
    }
    //Com->imprimir(); // Muestra la configuracion actual del puerto

    if ( !busque_controlador() ) {
        delete Com;
        Com = FALSE;
        return FALSE;
    }

    Com->registro_asincronico(leer_lego_callback, this);

    return TRUE;
}

BOOLEAN
LEGO9751::consultar_variable(const char * /*nombre_variable*/, 
                   int & /*tipo*/, void ** /*ref*/)
{
    return FALSE;
}

#endif

//===========================================================================
//= EOF                                                                     =
//===========================================================================

---

Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.