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.
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.
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é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
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”
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)
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
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”
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
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”
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_esclava, dir_registro, dato); //Mandamos toda la información por I2C
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_esclava, dir_registro); //Leemos por I2C y la información la guardamos en “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
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.
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.
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
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.
(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”
(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.
(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.
(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.
(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.
(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:
Pines en Avanxe verde:
Pines en Avanxe azul:
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”);
}
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_Senoidal, 100);//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.
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
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
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
}