void main(){

    // Declaración de variables
    char cont = 32;

    // Configuración de puertos
    
    TRISB = 2;                  // Puerto B como salida, excepto RB1
                                // que es Rx y debe ser configurado como entrada
    ANSELB = 0;                 // Puerto B Digital

    // Configuración de comunicación

    BAUDCON = 72;               // Generador de Baudios a 16 bits, bandera de recepción en desocupado
                                // Operación de recepción normal
    RCSTA = 144;                // Recepcion continua habilitada, Puerto serial habilitado
    TXSTA = 38;                 // Bit de transmisión vacia, habilitamos la trasnmisión
                                // y ponemos en 1 el bit BRGH.
    SPBRGL = 103;               // El valor 103 viene de la siguiente formula:
    SPBRGH = 0;

    /*

     Usar el Generador de baudios a 16 bits nos permite tener un margen de error menor

     Baudios deseados = (Frecuencia Oscilador / ( 4 * (SPBRGH:SPBRGL + 1))

     Donde SPBRGH:SPBRGL es el dato de 16 bits formado por ambas variables

     El 4 de configurar la comunicación en modo asincrono, el generador de baudios a 16 bits
     y el BRGH de TXSTA en 1 (La tabla se encuentra en la pagina 298 del datasheet - Table 26-3).

    Entonces :

    Baudios deseados = (4000000 / ( 4 * (103 + 1))
    Baudios deseados = 9615 Baudios similar a 9600 Baudios

    */
    inicio_lcd();
    irapos_lcd(0);                    // Nos ubicamos en la primera linea posición 0
    cadena_lcd("   Com RS232    ");   // Envio el mensaje a la primera linea
    irapos_lcd(64);                   // Nos ubicamos en la primera linea posición 0
    cadena_lcd("  Conteo en ");       // Envio el mensaje a la segunda linea
    while(1){                         // Programa que se ejecura continuamente
        cont = obtener_caracter();    // Almacenamos en cont el resultado de leer el puerto serial
        irapos_lcd(76);               // Nos ubicamos en la posición 76 de la segunda linea
        caracter_lcd(cont + 48);      // Escribimos el valor recibido en el LCD, sumandole 48 puesto que
                                      // se trata de un caracter ASCII
    }
}
Esempio n. 2
0
/*--------------------------------------------------------------------------*/
static int sys_leer(void)
{
    char far * buffer;
    char c;
    int i, resto;				/* indice del buffer */
    long cociente;
    int fd = current->contexto->dx; /* ahoramos codigo */

    buffer = (char far *)(((long)current->contexto->es << 16) +
                          current->contexto->bx);

    /* 1.- lectura de terminal fd de fichero 0 */
    if (fd == 0)
    {
        while (!(c = obtener_caracter()))
        {
            current->estado = BLOQ_TECLADO;
            ceder_CPU();
        }

        *buffer = c;

        /* Devolvemos el total de caracteres leídos */
        return 1;
    }

    /* 2.- para los fdes destinados a ficheros */
    else if ((fd > 2) && (fd <= MAX_FICH))
    {
        current->estado = PROCESO_SYSCALL;

        /* si el descriptor está libre fuera */
        if(current->fichero[fd].estado == DESC_LIBRE) {
            current->estado = PROCESO_RUN;
            return -1;  /* descriptor no abierto */
        }

        /* si el modo es solo escritura tambien fuera */
        if(current->fichero[fd].modo == WRITEONLY) {
            current->estado = PROCESO_RUN;
            return -1;
        }

        /* si la longitud es igual al puntero estamos colocados
         * al final del fichero y debemos devolver un 0 */
        if(current->fichero[fd].tama ==
                current->fichero[fd].puntero) {
            current->estado = PROCESO_RUN;
            return 0;
        }


        for (i=0; current->contexto->cx > i; i++)
        {
            /* debemos ver si el puntero actual está dentro del
             * cluster actual */

            /* utilizamos la division */
            divisionLong512(current->fichero[fd].puntero,
                            &cociente, &resto);

            if (current->fichero[fd].numcluster!=cociente)
            {
                /* debemos cargar el siguiente cluster en
                 * memoria, como maximo deberemos cargar
                 * el cluster siguiente ya que avanzamos
                 * de uno en uno */

                /* si el cluster ha sido modificado debemos
                 * escribirlo */
                if (current->fichero[fd].estado ==
                        DESC_MODIFICADO)
                {
                    dispositivo_escribircluster(disquete,
                                                current->
                                                fichero[fd].
                                                clusterACTUAL,
                                                current->fichero[fd].
                                                buffer);
                }


                current->fichero[fd].clusterACTUAL =
                    siguiente_cluster(disquete,
                                      current->fichero[fd].clusterACTUAL);

                current->fichero[fd].numcluster++;

                dispositivo_leercluster(disquete,
                                        current->fichero[fd].clusterACTUAL,
                                        current->fichero[fd].buffer);

                current->fichero[fd].estado =
                    DESC_BUFFER;

            }

            /* ahora leemos de verdad de uno en uno!! */

            if (current->fichero[fd].puntero ==
                    current->fichero[fd].tama )
            {
                current->estado = PROCESO_RUN;
                return i;
            }

            buffer[i] = current->fichero[fd].buffer[resto];
            current->fichero[fd].puntero++;

        }
        current->estado = PROCESO_RUN;
        return i;
    }

    /* 3.- error en el descriptor de fichero */
    else
    {
        current->estado = PROCESO_RUN;
        return -1;
    }
}