SADE en JAVA

  1. Inicio
  2. chevron_right
  3. SADE en JAVA

Agregar el Template a tu proyecto

  1. Crea un proyecto nuevo: File > New > Java Project, asígnale un nombre (Main por ejemplo) y da clic en Finish.

 

  1. Arrastra los archivo .java a la carpeta Source (scr) y el archivo libIntescRS232.dll a la carpeta Main. De preferencia crea una copia de los archivos seleccionando la opción Copy Files cuando te lo pregunte.

 

  1. Para editar la ventana de tu aplicación da clic derecho a Main.java selecciona  Open With > WindowBuilder Editor.

 

  1. En la pestaña Design puedes ver los elementos que están por default un ComboBox, un botón y un Label. Puedes ejecutar la aplicación y abrir el puerto para verificar que la aplicación funcione correctamente.

Si no sabes cual puerto COM elegir entonces dirígete al Administrador de dispositivos y verifica en la pestaña  Puertos (COM y LPT) . Tu tarjeta debe estar conectada y encendida.

Programación en JAVA

El template de JAVA cuenta con 7 clases, cada una para realizar una función específica y una librería (libIntescRS232.dll) que se encarga de hacer la interacción con los puertos.

grafico.java: En esta clase podemos crear la parte gráfica de nuestra aplicación. Se pueden agregar lineas, figuras geométricas e inclusive imágenes.

HexToDec.java: Se utiliza para hacer una conversión de hexadecimal a decimal.

Hilo.java: En esta clase escribiremos el código que estará ejecutándose en segundo plano utilizando Threads.

LibRS232.java:  Contiene los métodos necesarios para configurar y abrir el puerto COM, como por ejemplo buscar los puertos disponibles, abrir puerto, configurar los baudios, etc.

SADERevA: Contiene los métodos para utilizar los recursos de SADE.

Para obtener los métodos dentro de la clase SADERevA.java se debe crear un objeto e instanciarlo. Por ejemplo, se creó un objeto llamado comando.

SADERevA comando = new SADERevA();

Al desplegar el menú de contenido (presionando Ctrl + Espacio) se mostrará la descripción de cada método.

 Algunos métodos piden ciertos parámetros:

byte -> Valor tipo byte, por ejemplo: (byte)0xAA

int -> Valor tipo entero, por ejemplo:  int x = 1; int valor = 123;

Boolean -> Valor de tipo booleano, por ejemplo: true, false

Métodos de SADE en JAVA

1)  void LEDS(byte VALOR_A_LEDS)

Método que manda un byte a los LEDs de la tarjeta.

byte valor = 0x55; //Dato de tipo byte.
comando.LEDS(valor);//Mandamos a los LEDs

 

2) byte SW()

Método que realiza una lectura a los switches y devuelve un byte con la información.

byte valor_sw = comando.SW(); //Leemos los switches y guardamos la información en “valor_sw”

 

3) void PWM(int PERIODO_PWM, int CICLO_PWM, byte PIN_FPGA)

Con este método utilizamos como PWM uno de los pines de la tarjeta. Sólo se deben especificar el periodo del PWM, el ciclo de trabajo y el pin de la tarjeta. El pin seleccionado quedará funcionando como PWM hasta que no se le asigne una nueva función.

Pines en Symbhia: G1, F1, E1, F3, B3, A3, A4, B5, A5, A6, C6, A7, B7.

Pines en Avanxe verde: M15, N16, P16, R16, P15, R12, N12, P12, M16, C16, D16, E12, E13, E15, F13, F14.

Pines en Avanxe azul: A6, C7, B8, C9, F9, A9, D11, E10, C13, D12, B12, A11, E15, A14, F16, F15.

int periodo = 10000; //Periodo del PWM (200 us)
int ciclo = 100; //Ciclo de trabajo del PWM (2 us)
comando.PWM(periodo, ciclo, comando.C9_AvA); //Seleccionamos el pin C9 de la tarjeta para utilizarlo como PWM

Fórmulas:

PeriodoPWM = (Tiempo del periodo [S]) * (50,000,000)

CicloDeTrabajoPWM = (Tiempo del ciclo [S]) *(50,000,000)

 

4) void Pin_Out(byte PIN_FPGA, boolean VALOR)

Método para utilizar un pin de la tarjeta como salida. Cuando VALOR = true se manda un ‘1’ lógico y VALOR = false se manda un ‘0’ lógico.

Pines en Symbhia: G1, F1, E1, F3, B3, A3, A4, B5, A5, A6, C6, A7, B7.

Pines en Avanxe verde: M15, N16, P16, R16, P15, R12, N12, P12, M16, C16, D16, E12, E13, E15, F13, F14.

Pines en Avanxe azul: A6, C7, B8, C9, F9, A9, D11, E10, C13, D12, B12, A11, E15, A14, F16, F15.

comando.Pin_Out(comando.C9_AvA, true); //Configuramos el pin C9 de la tarjeta como salida y mandamos un ‘1’ lógico

 

5) byte Pin_In(byte PIN_FPGA)

Selecciona un pin de la tarjeta y lo configura como entrada. El método devuelve un byte aunque únicamente toma dos valores: 0x00 y 0x01.

byte v_pin = comando.Pin_In(comando.C7_AvA); //Configuramos el pin C7 como entrada y la información la guardamos en “v_pin”

 

6) void BiPort_Out(byte BYTE_A_ESCRIBIR)

Manda un byte a través del puerto bidireccional.

byte dato = 0x55; //Dato a enviar
comando.BiPort_Out(dato); //Mandamos “dato” por el puerto bidireccional

 

7) byte Biport_In()

Método que hace una lectura del puerto bidireccional y devuelve un byte con la información.

byte v_puerto = comando.BiPort_In(); //Leemos el puerto bidireccional y la información la guardamos en “v_puerto”

 

8) void I2C_Write(byte SLAVE_ADDRESS, byte REG_ADDRESS, byte REG_DATA)

Con éste método mandamos a escribir a un registro de un dispositivo mediante protocolo I2C, sólo se requieren de los siguientes parámetros: SLAVE_ADDRESS – Dirección esclava del dispositivo sin bit R/W, REG-ADDRESS – Dirección del registro a escribir, REG_DATA – Dato a escribir en el registro.

Pines en Symbhia: SDA -D4, SCL – C4.

Pines en Avanxe verde: SDA – G12, SCL – E16.

Pines en Avanxe azul: SDA – H15, SCL – J16.

byte dir_esclava = 0x1D; //Dirección del dispositivo sin bit R/W
byte dir_registro = 0x2A; //Dirección del registro a escribir
byte dato = 0x2B; //Dato a escribir
comando.I2C_Write(dir_esclavadir_registrodato); //Mandamos toda la información por I2C

 

9) byte I2C_Read(byte SLAVE_ADDRESS, byte REG_ADDRESS)

Método para realizar una lectura de un dispositivo mediante protocolo I2C. Los parámetros que se piden son: SLAVE_ADDRESS – Dirección esclava del dispositivo sin bit R/W, REG_ADDRESS – Dirección del registro a leer. El método devuelve un byte con la información.

Pines en Symbhia: SDA -D4, SCL – C4.

Pines en Avanxe verde: SDA – G12, SCL – E16.

Pines en Avanxe azul: SDA – H15, SCL – J16.

IMPORTANTE: Siempre se estará recibiendo un dato del registro.

byte dir_esclava = 0x1D; //Dirección del dispositivo sin bit R/W
byte dir_registro = 0x2A; //Dirección del registro a escribir
byte dato = comando.I2C_Read(dir_esclavadir_registro); //Leemos por I2C y la información la guardamos en “dato”

 

10) void RS232_SADE_Write(byte DATO)

Envía un byte mediante protocolo RS232 cuya velocidad de transmisión es de 9600 baudios.

Pines en Symbhia: TX – F10, RX – B9, bit de interrupción de recepción –  A9.

Pines en Avanxe verde: TX – F15, RX – G16, bit de interrupción de recepción – G14.

Pines en Avanxe azul: TX – J14, RX – K16, bit de interrupción de recepción – L16.

byte dato = 0x0F; //Dato a enviar
comando.RS232_Write(dato); //Mandamos por RS232

 

11) byte RS232_SADE_Read()

Recepción de un byte mediante protocolo RS232 cuya velocidad de recepción es de 9600 baudios.

Pines en Symbhia: TX – F10, RX – B9, bit de interrupción de recepción –  A9.

Pines en Avanxe verde: TX – F15, RX – G16, bit de interrupción de recepción – G14.

Pines en Avanxe azul: TX – J14, RX – K16, bit de interrupción de recepción – L16.

byte dato comando.RS232_Read(); //Recibimos byte y lo guardamos en “dato”

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

 

12) byte ADC(int CANAL)

Método que realiza una conversión Analógica-Digital seleccionando el canal analógico (del 1 al 4). Este método devuelve un byte con el valor de la conversión. El voltaje de entrada debe ir de 0 a 3.3V.

byte valor_adc = comando.ADC(1); //Seleccionamos el canal analógico 1 y el valor que devuelve lo guardamos en “valor_adc”
comando.LEDS(valor_adc); //Mandamos a los LEDs

NOTA: En Symbhia es importante mandar a tierra los canales que no se utilicen para evitar ruido entre las entradas (Crosstalking).

NOTA 2: En Symbhia disponemos de 4 canales. En avanxe sólo hay un canal por lo que “Canal” siempre debe ser 1.

 

13) void DAC(byte VALOR_DAC)

Método para utilizar el convertidor Digital-Analógico del PSoC.

byte valor_digital = 0x0A; //Valor digital que convertiremos a analógico
comando.DAC(valor_digital); //Hacemos la conversión D/A

Fórmula para utilizar el DAC:

En Symbhia:

Voltaje de salida = (Valor digital) * (0.011)

Donde: Voltaje de salida va de 400mV a Vcc; Valor digital va de 0 a 255

En Avanxe:

Voltaje de salida = (Valor digital) * (0.016)

Donde: Voltaje de salida va de 0V a 4.08V; Valor digital va de 0 a 255

 

14) byte RS232_SADE_Read()

Recepción de un byte mediante protocolo RS232 cuya velocidad de recepción es de 9600 baudios.

Pines en Symbhia: TX – F10, RX – B9, bit de interrupción de recepción –  A9.

Pines en Avanxe verde: TX – F15, RX – G16, bit de interrupción de recepción – G14.

Pines en Avanxe azul: TX – J14, RX – K16, bit de interrupción de recepción – L16.

byte dato_rec = comando.RS232_SADE_Read(); //Recibimos un byte y lo guardamos en “dato_rec”

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

 

15) int Leer_Ultrasonico(byte Pin_Trigger, byte Pin_Eco)

(No compatible con Symbhia X4)

Método que devuelve un byte con la distancia en centímetros que detecta un sensor HC-SR04. En Symbhia podemos trabajar con máximo 2 sensores y en Avanxe hasta con 4. Cada sensor requiere de 2 pines de control: Trigger y Eco.

Pines en Symbhia: G1, F1, E1, F3.

Pines en Avanxe verde: M15, N16, P16, R16, P15, R12, N12, P12.

Pines en Avanxe azul: A6, C7, B8, C9, F9, A9, D11, E10.

int distancia = comando.Leer_Ultrasonico(comando.G1_Sy, comando.F1_Sy);//Declaramos al pin G1 para que trabaje como Trigger y el pin F1 para que trabaje como Eco, la distancia medida la guardamos en “distancia”

 

16) boolean Timer_Modo1(byte Timer, int Tiempo, String Escala_Tiempo)

(No compatible con Symbhia X4)

Método para configurar 1 de los 4 Timers controlados por Hardware y cuando cuando ya haya transcurrido el tiempo especificado devuelve una notificación de tipo booleano con valor true. Se deben especificar los siguientes parámetros: Timer – Especifica con cual Timer se va a trabajar (disponemos de 4), Tiempo – Especifica el tiempo en el que el Timer mandará la notificación, Escala_Tiempo – Especifica la escala de Tiempo ya sea microsegundos “us”, milisegundos “ms” o segundos “s”.

Tiempo mínimo = 13 microsegundos (Tiempo que tarda en enviar la información por el puerto COM)

Tiempo máximo = 85 segundos

int tiempo = 5;//Tiempo
comando.Timer_Modo1(comando.Timer1, tiempo“s”);//Configuramos el Timer 1 y nos enviará una notificación cuando hayan transcurrido 5 segundos

NOTA: El código deberá preguntar por la notificación en todo momento.

 

17) void Reseet_Timer_Modo1(byte Timer)

(No compatible con Symbhia X4)

Resetea el Timer especificado.

comando.Timer_Modo1(comando.Timer1);//Reset Timer 1

NOTA: A diferencia de C# y LabVIEW, JAVA trabaja con una máquina virtual lo que provoca que a veces ignore éste método si se invoca desde un botón.

18) boolean Timer_Modo2(byte PinFPGA, int Tiempo, String Escala_Tiempo)

(No compatible con Symbhia X4)

Se configura uno de los pines disponibles como Timer y la notificación se envía tanto por Software como por Hardware a través del pin seleccionado.

Tiempo mínimo = 13 microsegundos (Tiempo que tarda en enviar la información por el puerto COM)

Tiempo máximo = 85 segundos

Pines en Symbhia: B3, A3, A4, B5.

Pines en Avanxe verde: M16, C16, D16, E12.

Pines en Avanxe azul: C13, D12, B12, A11.

comando.Timer_Modo2(comando.B3_Sy, 3, “s”);//Configuramos al pin B3 como Timer para que se muestre la notificación transcurridos 3 segundos

NOTA: El código deberá preguntar por la notificación de Software en todo momento.

NOTA2: Para la notificación que sale del Pin no es necesario que el código se esté ejecutando.

 

19) void Reset_Timer_Modo2(byte PinFPGA)

(No compatible con Symbhia X4)

Resetea el Timer del Pin seleccionado.

comando.Reset_Timer_Modo2(comando.B3_Sy);//Reset al Timer del pin B3

NOTA: A diferencia de C# y LabVIEW, JAVA trabaja con una máquina virtual lo que provoca que a veces ignore éste método si se invoca desde un botón.

20) byte[] Timer_Modo3(byte PinFPGA, int Tiempo, String Escala_Tiempo, int Ancho, String Escala_Ancho)

(No compatible con Symbhia X4)

Timer controlado por Hardware el cual inicia cuando se detecta un ‘1’ en el pin de disparo externo y la notificación se muestra tanto en Software como en Hardware. El byte[1] se pone a 1 cuando detecte el disparo externo y el byte[0] cuando el Timer ya haya finalizado. Se puede configurar el tiempo en el que permanecerá activa la notificación, una ves transcurrido ese tiempo el Timer se reinicia y espera de nuevo a la notificación externa.

Tiempo mínimo = 13 microsegundos (Tiempo que tarda en enviar la información por el puerto COM)

Tiempo máximo = 85 segundos

Pines en Symbhia:

  • DISPARO EXTERNO – A5 -> NOTIFICACIÓN – B3
  • DISPARO EXTERNO – A6 -> NOTIFICACIÓN – A3
  • DISPARO EXTERNO – C6 -> NOTIFICACIÓN – A4
  • DISPARO EXTERNO – A7 -> NOTIFICACIÓN – B5

Pines en Avanxe verde:

  • DISPARO EXTERNO – E13 -> NOTIFICACIÓN – M16
  • DISPARO EXTERNO – E15 -> NOTIFICACIÓN – C16
  • DISPARO EXTERNO – F13 -> NOTIFICACIÓN – D16
  • DISPARO EXTERNO – F14 -> NOTIFICACIÓN – E12

Pines en Avanxe azul:

  • DISPARO EXTERNO – E15 -> NOTIFICACIÓN – C13
  • DISPARO EXTERNO – A14 -> NOTIFICACIÓN – D12
  • DISPARO EXTERNO – F16 -> NOTIFICACIÓN – B12
  • DISPARO EXTERNO – F15 -> NOTIFICACIÓN – A11

byte[] x = comando.Timer_Modo3(comando.A5_Sy, 2, “s”, 3, “s”); /*Configuramos el Timer para que al transcurrir 2 segundos mande la notificación que durará 3 segundos antes de reiniciarse y espere al siguiente disparo externo. Estamos utilizando el pin A5 como disparador externo por lo que la notificación se mostrará en el pin B3 y en x[1]. La notificación se encuentra en x[0]. */
if(x[1] == 1)//Si detecta el disparo externo
{
label3.setText(“Disparo externo = true”);//Mandamos a una etiqueta un texto
}
else
{
label3.setText(“Disparo externo = false”);
}
if (x[0] == 1)//Si ya terminó el Timer de contar
{
label4.setText(“Timer fin = true”);//Mandamos a otra etiqueta un texto
}
else
{
label4.setText(“Timer fin = false”);
}

 

21) void Generador_Funciones(String Onda, int Frecuencia_Hz)

Método que utiliza al DAC como generador de funciones para crear una onda Senoidal, Triangular, Cuadrada o Diente de Sierra.

comando.Generador_Funciones(comando.Onda_Senoidal100);//Generamos una onda Senoidal a 100Hz

NOTA: El método sólo debe ser ejecutado una vez, por lo que no deberá ir dentro de ningún ciclo de repetición.

 

22) int Calcular_Fs(int Frecuencia_Hz)

Calcula el número de muestras a partir de la frecuencia de la señal a generar.

int fs = comando.Calcular_fs(1000); //Caculamos la frecuencia de muestreo para generar una señal de 1KHz

 

23) int Calcular_Muestras(int Frecuencia_Hz)

Métodos que se utilizan para generar una onda creada por el usuario. IniFuncion() inicializa la operación para empezar a mandar las muestras. Utiliza el método MandarMuestras() para ir mandando las muestras de tu señal a generar, las cuales deben ir de 0 a 3.3.

int num_muestras = comando.Calcular_Muestras(500); //Caclulamos el número de muestras para generar una señal de 500Hz

 

24) void IniFuncion(int Frecuencia_Hz) y void MandarMuestras(double Muestra)

Calcula la frecuencia de muestreo a partir de la frecuencia de la señal a generar.

//Se quiere generar una señal de 100Hz mediante una ecuación matemática
double Muestra = 0;//Variable de tipo double en la que se guardará una muestra
int fs = comando.Calcular_Fs(100); //Calculamos la frecuencia de muestreo
comando.IniFuncion(100); //Inicializamos el DAC
//Mandamos las muestras mediante un ciclo for
for (int i = 0; i < comando.Calcular_Muestras(100); i++) {
Muestra = 0.8*(1.76+(Math.sin((4*Math.PI*100*i)/fs))+Math.cos((2*Math.PI*100*i)/fs));//Generamos la muestra
comando.MandarMuestras(Muestra);//Enviamos la muestra
}

 
[fusion_table]

[/fusion_table]
Menú