Primitivas c

Instituto de Tecnologías Educativas

Funcionamiento Programación Primitivas C 1

PRIMITIVAS EN C PARA LA CONTROLADORA CNICE

Para poder manipular las entradas y salidas de la controladora CNICE se han desarrollado una serie de funciones y procedimientos que forman parte de una librería dinámica para que el usuario que quiera implementar un programa para manejarla no se tenga que preocupar por saber cómo mandar o recibir datos por el puerto paralelo, qué órdenes tiene que escribir para activar/desactivar una salida o entrada, etc.

Es importante destacar que para poder utilizar los puertos del equipo en los sistemas operativos Windows 2000, XP y Vista se necesita la librería dinámica io.dll porque estos sistemas operativos limitan el acceso directo al hardware de la máquina. Esta librería es exactamente la misma que se ha empleado para esta misma función en el lenguaje MSWLogo.

LIBRERÍA DINÁMICA PARA ACCEDER A LOS PUERTOS DEL EQUIPO EN LOS SISTEMAS OPERATIVOS WINDOWS 2000, XP Y VISTA: io.dll

Como ya se ha mencionado, para poder utilizar los puertos del equipo se necesita la librería dinámica io.dll. Como ya se ha mencionado, esta librería es exactamente la misma que se ha empleado para esta misma función en el lenguaje MSWLogo. Esta librería se ha obtenido en la dirección:

http://www.geekhideout.com/iodll.shtml

Para usar la librería io.dll con Dev C++, se tiene que usar las funciones de C LoadLibrary y GetProcAddress. Estas funciones son bastante engorrosas de usar por lo que se una serie de funciones auxiliares (disponibles en los ficheros io.h e io.cpp que se pueden obtener en la misma dirección que la librería io.dll) que simplifican el trabajo al desarrollador. Simplemente hay que incluir estos 2 ficheros en los proyectos que se desarrollen. Estos 2 ficheros se encargan de llamar a la función LoadLibrary y a todas las llamadas a la función GetProcAddress necesarias, facilitando con ello el trabajo. De esta forma el único paso que se requiere es llamar a la función LoadIODLL al principio del programa del usuario. Es muy importante no olvidar esto porque sino el programa no funcionaría.

Resumiendo, donde se tenga el proyecto a desarrollar se deben dejar los ficheros io.h e io.cpp y agregarlos al proyecto. La librería dinámica io.dll se debe dejar bien en la carpeta del sistema C:\WINDOWS\System32 o bien en la carpeta donde se tenga el proyecto. Una vez hecho esto se debe llamar desde el programa a la función LoadIODLL y de esta forma ya tendremos acceso a los puertos del equipo.

Estos 3 archivos (io.dll, io.h e io.cpp) pueden encontrarse en la carpeta IODLL_ C del archivo comprimido primiticas_c.zip.

Interfaz de control de dispositivos externos por ordenador a través de puerto paralelo

El ordenador como elemento de control 2

¿POR QUÉ SE UTILIZA UNA LIBRERÍA DINÁMICA PARA LAS PRIMITIVAS?

Una librería dinámica o dll (Dinamic Link Library) es un archivo con código ejecutable que se carga bajo demanda del programa por parte del sistema operativo. Las ventajas que aporta el uso de las dlls son los siguientes:

• Reducen el tamaño de los archivos ejecutables: gran parte del código puede estar almacenado en bibliotecas y no en el propio ejecutable lo que redunda en una mejor modulación.

• Pueden estar compartidas entre varias aplicaciones: si el código es suficientemente genérico, puede resultar de utilidad para múltiples aplicaciones.

• Facilitan la gestión y aprovechamiento de la memoria del sistema: la carga dinámica permite al sistema operativo aplicar algoritmos que mejoren el rendimiento del sistema cuando se carguen estas bibliotecas. Además, al estar compartidas, basta con mantener una copia en memoria para todos los programas que la utilicen.

• Brindan mayor flexibilidad frente a cambios: es posible mejorar el rendimiento o solucionar pequeños errores distribuyendo únicamente una nueva versión de la biblioteca dinámica. Nuevamente, esta corrección o mejora será aprovechada por todas las aplicaciones que compartan la biblioteca.

Por todo ello, se ha decidido crear una librería dinámica que contenga a las primitivas para manejar la controladora CNICE.

Destacar que el proceso seguido para buscar el fichero .dll es siempre el mismo: • En el directorio que contiene el ejecutable (fichero .exe). • El directorio actual de la aplicación. • El directorio de sistema de Windows (system32). • El directorio de Windows. • Los directorios incluidos en la variable de entorno PATH del Sistema.

LIBRERÍA DINÁMICA QUE CONTIENE A LAS PRIMITIVAS

Una vez que ya se tiene acceso al puerto paralelo del equipo hay que desarrollar una serie de funciones y procedimientos para manejar la controladora y construir la librería dinámica. Esta librería dinámica se llama Primitivas_CNICE_C.dll. Al igual que ocurría con la librería para acceso a los puertos io.dll, se han definido en los archivos Primitivas_CNICE_C.hpp y Primitivas_CNICE_C.cpp una serie de funciones para facilitar el uso de esta librería.

El procedimiento para poder utilizar esta librería es similar al seguido para la librería io.dll. Es decir, lo primero es llamar a la función de carga, en este caso LoadPrimitivasDLL al principio del programa. Luego donde se tenga el proyecto a desarrollar se deben dejar los ficheros Primitivas_CNICE_C.hpp y Primitivas_CNICE_C.cpp y agregarlos al proyecto. La librería dinámica Primitivas_CNICE_C.dll se debe dejar bien en la carpeta del sistema C:\WINDOWS\System32 o bien en la carpeta donde se tenga el proyecto. Luego se podrán utilizar las primitivas simplemente haciendo las llamadas a las funciones o procedimientos con sus parámetros correspondientes. Es importante destacar que al utilizar la librería dinámica que contiene a las primitivas ya se realiza la carga de la librería io.dll, por tanto ya no es necesario que el usuario en su programa haga la llamada a la función LoadIODLL. Solo tendrá que llamar a la función LoadPrimitivasDLL.

Estos 3 archivos (Primitivas_cnice_C.dll, Primitivas_CNICE_C.hpp y Primitivas_CNICE_C.cpp) pueden encontrarse en la carpeta DLL del archivo comprimido primiticas_c.zip.



CÓMO CREAR UN PROYECTO PARA GENERAR UNA LIBRERÍA DINÁMICA. ARCHIVOS FUENTE.

A continuación se va a explicar paso a paso cómo se ha creado el proyecto con el que se ha conseguido la librería dinámica para las primitivas.

Se abre un proyecto nuevo en el menú File New Proyect... Se elige el tipo de proyecto DLL [.dll], el nombre para el proyecto (Primitivas_CNICE) y se pulsa el botón OK.

Se elige el directorio de destino donde se va a crear el proyecto y se pulsa el botón Guardar.



Los proyectos en Dev- C++ tienen la extensión .dev, en este caso se llamará Primitivas_CNICE.dev.

El proyecto se crea inicialmente con los archivos primitivas_cnice.cpp y primitivas_cnice.hpp vacíos. Se han tenido que crear los archivos primitivas_cnice.cpp y primitivas_cnice.hpp (el otro se deja como está). El fichero primitivas_cnice.hpp contiene las definiciones de las funciones que exporta la librería dinámica y el fichero primitivas_cnice.cpp contiene la implementación de cada una de las funciones y procedimientos de la librería.

Una vez creado el esqueleto del proyecto se deben añadir los archivos necesarios, en este caso el archivo io.cpp para importar la librería dinámica que permite el acceso a los puertos del equipo (io.dll). Se recomienda que los archivos que se van a añadir a un proyecto estén situados en la misma carpeta que el proyecto.

Para añadir un archivo existente a un proyecto en Dev-C++ se debe seleccionar con el ratón cualquiera de las archivos que ya forman parte del proyecto y pulsar el botón derecho para que aparezca un menú emergente. En este menú se seleccionará la opción de Add to Project.



Una vez hecho esto se nos mostrará una ventana en la que seleccionaremos el archivo que queremos añadir.



Ya solo queda dejar en la misma carpeta donde se tienen los ficheros del proyecto los archivos Primitivas_CNICE.HPP e io.h que no se añaden al proyecto pero es necesario que estén accesibles.

Para generar la librería dinámica ya sólo queda compilar y construir el proyecto.

Estos archivos se encuentran en la carpeta C\Codigo_Fuente_DLL.

UTILIZACIÓN DE LAS PRIMITIVAS DE LA CONTROLADORA CNICE CON EL LENGUAJE C EN UN PROYECTO

Aunque ya se ha explicado anteriormente, por si todavía no ha quedado claro para utilizar en un programa la librería dinámica que contiene a las primitivas se deben seguir los siguientes pasos:

1. Lo primero es crear un proyecto nuevo en el menú File New Proyect... Se elige el tipo de proyecto Console Application, el modo consola o aplicación gráfica (Windows Application), se marca C Project, se pone el nombre del proyecto y se pulsa el botón OK. Se busca la ruta donde se quiere almacenar el proyecto y por último se pulsa el botón Guardar.

2. Una vez hecho lo anterior se generará un archivo con extensión .dev (proyecto) y otro con extensión .c que es el main de nuestro proyecto.

3. Dejar en la carpeta donde se esté generando el proyecto los archivos: • Primitivas_CNICE_C.hpp • Primitivas_CNICE_C.cpp • Primitivas_CNICE_C.dll (este archivo opcionalmente puede estar en C:\WINDOWS\system32) • io.h • io.cpp • io.dll (esta librería opcionalmente puede estar en C:\WINDOWS\system32)

4. Agregar al proyecto los archivos Primitivas_CNICE_C.cpp e io.cpp.

5. Implementar el programa de usuario. No olvidar que lo primero que se debe hacer es llamar a la función LoadPrimitivasDLL y en los ficheros en los que se utilice las primitivas, incluido el programa principal, se debe incluir el fichero de cabecera Primitivas_CNICE_C.hpp con la instrucción:

#include "Primitivas_CNICE_C.hpp"



DESCRIPCIÓN DE LAS PRIMITIVAS

• M1(cadena);

Salidas digitales

Procedimiento que hace girar o para un motor conectado a las salidas digitales S0-S1. El parámetro cadena es un carácter que indica en qué sentido debe girar el motor (izquierda -I- o derecha -D-) o si debe parar (P).

M1 ('I'); M1 ('D'); M1 ('P');

• M_INT((char*)vector_m);

Procedimiento que rellena el vector de 4 elementos vector_m con el estado de los 4 actuadores/motores (I, D ó P). Para emplear este procedimiento se debe haber reservado memoria para el valor devuelto.

char vector_motores[4]; M_INT((char*)vector_motores); printf("v[0] v[1] v[2] v[3]: %c %c %c %c\n",

vector_motores[0], vector_motores[1], vector_motores[2], vector_motores[3]);

• M((char*) vector_motores);

Procedimiento que permite activar/desactivar todos los motores simultáneamente. El parámetro vector_motores tiene que ser un vector de 4 elementos.

char v_motor[4]; v_motor[0] = 'I'; v_motor[1] = 'D'; v_motor[2] = 'P'; v_motor[3] = 'D'; M((char*)v_motor);

• CONECTADO_INT((char*)vector_motores);

Procedimiento que rellena el vector de 4 elementos vector_motores con el estado de los 4 actuadores/motores (1 si el motor está activado ó 0 si está desactivado). Para emplear este procedimiento se debe haber reservado memoria para el valor devuelto.

char v_motores[4]; CONECTADO_INT((char*)v_motores); printf("v[0] v[1] v[2] v[3]: %i %i %i %i\n", v_motores[0], v_motores[1], v_motores[2], v_motores[3]);



• SALIDA(num); Procedimiento que activa/desactiva individualmente o en conjunto cada una de las 8 salidas digitales. El parámetro num es un número decimal equivalente al número binario que se envía a las salidas digitales.

SALIDA(170);

• EnviaOcteto(dato); Procedimiento similar a la primitiva SALIDA.

EnviaOcteto(85);

• APAGA(n); Procedimiento que desconecta la salida digital que se le indique en el parámetro n que será un número comprendido entre 1 y 8.

APAGA(2);

• SALIDA_INT((int*)v_salidas); Procedimiento que rellena el vector v_salidas con el estado de las ocho salidas digitales (1s ó 0s). Para emplear este procedimiento se debe haber reservado memoria para el valor devuelto .

SALIDA_INT((int*)v_salidas); printf("v[0] v[1] v[2] v[3] v[4] v[5] v[6] v[7]: %i %i %i %i %i %i %i %i\n",

v_salidas[0], v_salidas[1], v_salidas[2], v_salidas[3], v_salidas[4], v_salidas[5], v_salidas[6], v_salidas[7]);

• CONECTA(num); Procedimiento que conecta la salida digital indicada en el parámetro num.

CONECTA(8);

• DESCONECTA(num); Procedimiento que desconecta la salida digital indicada en el parámetro num.

DESCONECTA(8);

• CONECTAR(); Procedimiento que conecta las 8 salidas digitales.

CONECTAR

• DESCONECTAR(); Procedimiento que desconecta las 8 salidas digitales.

DESCONECTAR

• VS_INT(); Función que devuelve un número decimal que indica qué salidas digitales están activadas.

int resultado; resultado = VS_INT(); printf(“Valor de las salidas digitales: %i\n”, resultado);



• segundos(tiempo);

Procedimiento que produce un retardo o espera de tantos segundos como se le indique en el parámetro tiempo. segundos(5.5);

• entrada(n);

Entradas digitales

Función que devuelve True si la entrada digital indicada en n está conectada o False en caso contrario. bool ent; ent = entrada(1); printf("Valor de la entrada digital 1: %b\n",ent);

• VE_INT();

Función que devuelve un número decimal que indica qué entradas digitales están activadas. int entradas; entradas = VE_INT(); printf("Valor de las entradas digitales: %i\n",entradas);

• SD(entrada);

Función que devuelve el valor del sensor digital expresado en el parámetro entrada (0 ó 1). int entrada; entrada = SD(1); printf("Valor de la entrada digital 1: %i\n",entrada);

• SD_INT((int*)v_entradas);

Procedimiento que rellena el vector v_entradas con el estado de los ocho sensores digitales (0s ó 1s). Para emplear este procedimiento se debe haber reservado memoria para el valor devuelto.

int v_entradas[8]; SD_INT((int*)v_entradas); printf("v[0] v[1] v[2] v[3] v[4] v[5] v[6] v[7]: %i %i %i %i %i %i %i %i\n",

v_entradas[0], v_entradas[1], v_entradas[2], v_entradas[3], v_entradas[4], v_entradas[5], v_entradas[6], v_entradas[7]);

• EsperaOn(entrada); Procedimiento que deja el programa a la espera de que se active la entrada digital indicada en el parámetro entrada.

EsperaOn(1);

• EsperaOff(entrada); Procedimiento que deja el programa a la espera de que se desactive la entrada digital indicada en el parámetro entrada.

EsperaOff(1);

• leeanalogica(dato);

Entradas analógicas

Función que devuelve el valor de 8 bits de la entrada analógica especificada en el número dato (1, 2, 3 ó 4). El valor devuelto oscila entre 0 y 255.



int entanalog; entanalog = leeanalogica(1); printf("Valor de la entrada analogica 1: %i\n", entanalog);

• SAW(); Función que devuelve el valor en voltios del sensor analógico conectado a la entrada analógica IN0.

int entanalog; entanalog = SAW(); printf("Valor de la entrada analogica 1: %i\n", entanalog);

• SAX(); Función que devuelve el valor en voltios del sensor analógico conectado a la entrada analógica IN1.

int entanalog; entanalog = SAX(); printf("Valor de la entrada analogica 2: %i\n", entanalog);

• SAY(); Función que devuelve el valor en voltios del sensor analógico conectado a la entrada analógica IN2.

int entanalog; entanalog = SAY(); printf("Valor de la entrada analogica 3: %i\n", entanalog);

• SAZ(); Función que devuelve el valor en voltios del sensor analógico conectado a la entrada analógica IN3.

int entanalog; entanalog = SAZ(); printf("Valor de la entrada analogica 4: %i\n", entanalog);

• SA_INT((int*)v_analogicas); Procedimiento que rellena el vector v_analogicas con el valor (voltios) de los 4 sensores analógicos. Para emplear este procedimiento se debe haber reservado memoria para el valor devuelto.

int v_analogicas[4]; SA_INT((int*)v_analogicas); printf("v[0] v[1] v[2] v[3]: %i %i %i %i\n",

v_analogicas[0], v_analogicas[1], v_analogicas[2], v_analogicas[3]);



DIFERENCIAS ENTRE LAS PRIMITIVAS EN MSWLOGO Y C

MSWLogo C M1 “I M1(‘I‘); M? M_INT((char*)vector_m); M :lista M((char*)vector); CONECTADO? CONECTADO_INT((char*)vector_m) ; SALIDA? SALIDA_INT((int*)vector_s); VS? VS_INT(); SALIDA num APAGA n CONECTAR . . .

SALIDA(num); APAGA(n); CONECTAR(); . . .

entrada :n entrada(n); VE? VE_INT(); SD :entrada SD(entrada); SD? SD_INT((int*)vector_e); leeanalogica :dato leeanalogica(dato); SA? SA_INT((int*)vector_a);

Primitivas c

Documents

Transcript of Primitivas c