Download Biblioteca para JAVA

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.