SADE Biblioteca para JAVA SADE (Sistema de Adquisición de Datos flexiblE ) es la aplicación de INTESC la cual facilita el manejo de la tarjeta Avanxe mediante comandos en lenguaje de alto nivel. En el siguiente diagrama se muestran los recursos con los que cuenta SADE.

Descripción: SW: Se puede obtener una lectura de los switches de la tarjeta. LED: Podemos mandar información a los LEDs. IO PIN: SADE cuenta con 13 pines que se pueden configurar como entrada, salida e inclusive como PWM BiPORT: Puerto bidireccional de 8 bits que se puede configurar como entrada o salida. I2C: Protocolo de comunicación I2C para dispositivos que lo requieran. RS232 (PC): La tarjeta Avanxe cuenta con un convertidor USB-RS232 por lo que podemos utilizar los puertos COM de nuestra PC y trabajar con velocidades de transmisión de hasta 3 Megabaudios.

RS232 (SADE): Protocolo RS232 para utilizarlo con dispositivos externos como por ejemplo un módulo bluetooth HC-05, a diferencia del RS232 (PC) con este recurso trabajamos a velocidades más lentas ya que está configurado para trabajar a 9600 baudios. También cuenta con un pin para utilizarlo como interrupción que indica cuando se ha hecho una recepción, es muy útil si queremos tener más control al realizar la comunicación. Avanxe también cuenta con un PSoC (System on Chip) que nos permite hacer uso de sus recursos para ampliar la utilidad de SADE, por lo que podemos utilizar los siguientes recursos: ADC – ADC CHAN: Podemos hacer conversiones analógico-digital DAC: También se pueden realizar conversiones digital-analógico. La siguiente imagen muestra la ubicación de cada recurso.

Esta biblioteca hecha en JAVA tiene como objetivo utilizar los recursos SADE mediante una interfaz creada por el usuario y la utilización de comandos predefinidos. Programación. El template o plantilla de JAVA cuenta con 7 clases, cada una para realiza una función específica y una librería (libIntescRS232.dll) que se encarga de hacer la interacción con los puertos.

Clase “grafico.java”: En esta clase podemos crear nuestra parte gráfica, se pueden agregar lineas, figuras geométricas e inclusive imágenes. Clase “HexToDec.java”: Se utiliza para hacer una conversión de hexadecimal a decimal. Clase “Hilo.java”: En esta clase escribiremos nuestro código que se va a estar ejecutándose constantemente. Clase “LibRS232.java”: Contiene las funciones necesarias para configurar el puerto COM, como por ejemplo buscar los puertos disponibles, abrir puerto, la velocidad de transmisión, envío y recepción de datos. Clase “MAIN.java”: Contiene la interfaz gráfica creada por el usuario. Clase “SADEAvanxeRevA.java”: Contiene los métodos para utilizar los recursos de SADE. Clase “Utils.java”: Esta clase contiene las rutas donde se encuentran las librerías que harán funcionar nuestra aplicación.

A continuación se “SADESAvanxeRevA.java”.

muestra

como

utilizar

los

métodos

dentro

de

la

clase

Para obtener los métodos dentro de la clase “SADEAvanxeRevA.java” se creó un objeto llamado “comando” (el nombre se puede cambiar), el cual hereda dichos métodos para controlar los recursos de SADE: SADEAvanxeRevA comando = new SADEAvanxeRevA(); Al desplegar el menú de contenido (presionando “Ctrl” + “Espacio”), podemos posicionarnos en el método a utilizar y se desplegará un cuadro de diálogo con la descripción de dicho método.

También nos muestra los pines que podemos utilizar como entrada, salida o PWM. En el caso de los pines, un mensaje de ayuda nos indica si es un pin de Avanxe Verde o Avanxe Azul

Algunos comandos piden ciertos parámetros, dependiendo el tipo de variable es lo que se pondrá dentro de los paréntesis: byte → Valor tipo byte, por ejemplo: (byte) 0xaa int → Valor tipo entero, por ejemplo: 1,2,3,…. Boolean → Valor tipo booleano, por ejemplo: true, false IMPORTANTE: Todos los comandos que devuelvan un valor será de tipo byte.

1) LEDS(byte VALOR_A_LEDS) Comando que manda a los LEDs un valor de 8 bits, el cual tiene que ser tipo byte. Este método no devuelve ningún valor. Acá un código de ejemplo: byte valor = 0x55; //Se carga el número 55 (hexadecimal) = 0101 0101 (binario) comando.LEDS(valor);//Lo mandamos a los LEDs

Ubicación LEDs:

2) SW() Se utiliza para leer los Switches de la tarjeta Avanxe. Este comando devuelve un byte. byte valor_sw = comando.SW(); /* Leemos de los switches y el valor que devuelve lo guardamos en la variable “valor_sw” */

Ubicación SW:

3) PWM(int PERIODO_PWM,int CICLO_PWM,byte PIN_FPGA) PINES: M15, N16, P16, R16, P15, R12, N12, P12, M16, C16, D16, E12, E13, E15, F13, F14. Con este método utilizamos como PWM uno de los pines de la tarjeta Avanxe. Sólo se deben especificar los parámetros que se encuentran dentro de los paréntesis. Este comando no devuelve ningún valor. El pin seleccionado quedará funcionando como PWM hasta que no se le asigne una nueva función. int periodo = 10000; //Periodo del PWM (200 us) int ciclo = 100; //Ciclo de trabajo del PWM (2 us) comando.PWM(periodo, ciclo, comando.F14); /*Seleccionamos el pin F14 de la tarjeta para utilizarlo como PWM */

Fórmulas: valor_periodo = (Tiempo_periodo) * (50,000,000) valor_ciclo = (Tiempo_ciclo_trabajo) * (50,000,000)

Ubicación PWM:

4) Pin_Out(byte PIN_FPGA,boolean VALOR) PINES: M15, N16, P16, R16, P15, R12, N12, P12, M16, C16, D16, E12, E13, E15, F13, F14. Se nombra el pin de la tarjeta y lo convierte como salida, cuando VALOR = true se manda un '1' lógico y VALOR = false se manda un '0' lógico. Este comando no devuelve ningún valor. comando.Pin_Out(comando.C16, true); /*Seleccionamos a C16 como pin de salida y mandamos un '1' lógico */ comando.Pin_Out(comando.C16, false); /*Seleccionamos a C16 como pin de salida y mandamos un '0' lógico */

5) Pin_In(byte PIN_FPGA) PINES: M15, N16, P16, R16, P15, R12, N12, P12, M16, C16, D16, E12, E13, E15, F13, F14. Selecciona y convierte un pin de la tarjeta como entrada. Este comando sí devuelve un byte aunque únicamente toma dos valores: 0x00 y 0x01. byte v_pin = comando.Pin_In(comando.M15);/*Seleccionamos a M15 como pin de entrada y el valor lo guardamos en “v_pin” */

Ubicación IO PIN:

6) BiPort_Out(byte BYTE_A_ESCRIBIR) PINES: J14 a L12 Manda un valor de 8 bits a un puerto ya predefinido. Este comando no devuelve ningún valor. byte dato = 0x55; //Dato a mandar comando.BiPort_Out(dato); //Mandamos “dato” en el puerto bidireccional

7) BiPort_In() PINES: J14 a L12 Lee un byte de un puerto predefinido. Este comando regresa un byte. byte v_puerto = comando.BiPort_In(); /* Leemos el puerto y el dato lo guardamos en “v_puerto” */

Ubicación BiPORT:

8) I2C_Write(byte SLAVE_ADDRESS, byte REG_ADDRESS, byte REG_DATA) PINES: SDA – G12, SCL – E16 Con éste comando se manda a escribir a un registro de un dispositivo mediante protocolo I2C, sólo se necesitan poner los siguientes parámetros: “SLAVE_ADRESS” (Dirección esclava del dispositivo), “REG_ADRESS” (Dirección del registro a escribir), “REG_DATA” (Dato a escribir) todos siendo de tipo byte. Este comando no devuelve ningún valor. byte dir_esclava = 0x1d; //Dirección esclava del dispositivo sin bit R/W byte dir_registro = 0x2a; //Dirección del registro a escribir byte dato = 0x2a; //Dato a escribir comando.I2C_Write(dir_esclava, dir_registro, dato); /*Mandamos toda la información por I2C*/

9) I2C_Read(byte SLAVE_ADDRESS, byte REG_ADDRESS) PINES: SDA – G12, SCL – E16 Comando que se utiliza para leer un dato de un dispositivo mediante I2C. Los parámetros que piden son la dirección esclava y la dirección del registro a leer ambos valores de tipo byte. El comando devuelve un byte. NOTA: Siempre se estará recibiendo un dato del registro. byte dir_esclava = 0x1d; //Dirección esclava del dispositivo sin bit R/W byte dir_registro = 0x01; //Dirección del registro a leer byte dato = comando.I2C_Read(dir_esclava, dir_registro); /* Mandamos toda la información por I2C y guardamos el dato recibido en la variable tipo byte “dato” */

IMPORTANTE: La dirección esclava se manda sin considerar el bit R/W Ubicación I2C:

10) RS232_SADE_Write(byte DATO) PINES: G16 – RX, F15 – TX, G14 – Bit de interrupción. Envia un byte mediante protocolo RS232 cuya velocidad de transmisión es de 9600 baudios, es útil para comunicarnos con dispositivos externos que soporten este protocolo. byte DATO = 0x55; //Byte a enviar comando.RS232_SADE_Write(DATO); //Mandamos el byte “DATO”

11) RS232_SADE_Write(byte DATO) PINES: G16 – RX, F15 – TX, G14 – Bit de interrupción. Recepción de un byte mediante protocolo RS232 cuya velocidad de transmisión es de 9600 baudios, byte DATO = comando.RS232_SADE_Read(); //Leemos el byte recibido y lo guardamos en //la variable “DATO”

NOTA: El bit de interrupción puede usarse para saber cuando se ha recibido un dato. Ubicación RS232 de SADE:

12) ADC(int CANAL) Comando que se utiliza para trabajar con el ADC del PSoC. Avanxe cuenta con un sólo canal analógico digital, por lo que el argumento siempre es 1. Una vez que se ha seleccionado el canal, siempre devolverá un byte con el valor de la conversión. El siguiente código de ejemplo muestra como utilizar este comando: byte valor_adc = comando.ADC(1); /*El argumento de entrada siempre es 1 y el valor que devuelve lo guardamos en la variable tipo byte “valor_adc”*/ comando.LEDS(valor_adc); //Mandamos a los LEDs el valor leído por el ADC

Ubicación del canal ADC:

ADC

13) DAC(byte VALOR_DAC) Comando para utilizar el convertidor Digital/analógico del PSoC. Este comando no devuelve ningún valor. byte valor_digital = 0xff; //Valor que convertiremos a analógico comando.DAC(valor_digital); //Hacemos la conversión D/A

Fórmula: Voltaje de salida = Valor_digital*0.016 donde: Voltaje de salida – Rango de 0 a 4.08 V Valor digital – Rango de 0 a 255 Ubicación DAC:

¡Gracias por su interés en SADE! Cualquier duda o información pueden contactarnos en: [email protected] También pueden visitar nuestra página www.intesc.mx para ver otros proyectos.