IMPORTANTE: Los archivos LibMetodosSADE.dll y LibMetodosSADE.XML deben encontrarse en la misma carpeta.
using System;
using System. Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO.Ports;
using LibMetodosSADE;
namespace Main
{
public partial class Form1 : Form
{
SerialPort sp = new SerialPort(); //Declaramos un objeto de tipo SerialPort
string[] nombre_puertos = SerialPort.GetPortNames();//Obtenemos los nombres de los puertos
public LibMetodosSADE.MetodosSADE ms = new MetodosSADE();//Declaramos el objeto de SADE
public Form1()
{
InitializeComponent();
//Ciclo; for que almacena el nombre de los puertos en el ComboBox
for ( int i = 0; i < nombre_puertos.Length; i++)
{
PuertosCOM.Items.Add(nombre_puertos[i]);
}
}
//Método del botón que abre el puerto
private void Abrir_Click(object sender, EventArgs e)
{
string puerto = PuertosCOM.SelectedItem.ToString();//Elemento seleccionado del ComboBox
if (ms.AbrirPuertoSADE(puerto))//Ejecutamos el método y preguntamos si se pudo abrir el puerto
{
Console.Write(“Puerto abierto”);//Si el puerto se abre mandamos a la consola “Puerto abierto”
}
else
{
Console.Write( “No se pudo abrir”);//Si no se abre mandamos “No se pudo abrir”
}
}
Si no sabes cual puerto COM elegir entonces dirígete al Administrador de dispositivos y verifica en la pestaña Puertos (COM y LPT), siempre se utiliza el puerto COM con el número más grande . Tu tarjeta debe estar conectada y encendida.
Método para abrir el puerto colocando únicamente el nombre del puerto COM. Si la conexión se hizo con éxito se devolverá un True, de lo contrario se devolverá un False.
SADE.AbrirPuertoSADE(“COM4”);//Configuramos y abrimos el puerto COM4
Método que envía un byte a los LEDs de la tarjeta.
byte Valor_LEDs = 0xAA;//Byte en hexadecimal a mostrar en los LEDs SADE.LEDs(Valor_LEDs);//Configuramos y abrimos el puerto COM4
Utilizamos este método para hacer una lectura de los switches de la tarjeta, este método devuelve un byte con la información.
byte Valor_SW = SADE.SW();//Leemos los switches y guardamos la información en “Valor_SW”
Selecciona y convierte un pin de la tarjeta como entrada. Devuelve un byte con dos posibles valores: 0x00 y 0x01.
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. byte Valor_Pin = SADE.Pin_In(SADE.Pin_Sy_A3);//Leemos el pin A3 y guardamos el dato en Valor_Pin
Se nombra el pin de la tarjeta y lo convierte como salida, cuando Valor = true se manda un ‘1’ lógico y Valor = false 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.
SADE.Pin_Out(SADE.Pin_Sy_G1, true);//Mandamos un ‘1’ lógico a través del pin G1 SADE.Pin_Out(SADE.Pin_Sy_B7, false);//Mandamos un ‘0’ lógico a través del pin B7
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 = 10000;//Ciclo de trabajo del PWM (2 us) SADE.PWM(periodo, ciclo, SADE.Pin_Sy_G1);//Seleccionamos el pin G1 para utilizarlo como PWM
Fórmulas:
PeriodoPWM = ( Tiempo del periodo [S] ) * ( 50,000,000 )
CicloPWM = ( Tiempo del ciclo de trabajo [S] ) * ( 50,000,000 )
Lee a través del puerto bidireccional y devuelve un byte con la información.
byte v_puerto = SADE.BiPort_In();//Leemos el puerto y el byte lo guardamos en “v_puerto”
Manda un byte a través del puerto bidireccional.
byte dato = 0x55;//Dato a enviar SADE.BiPort_Out(dato);//Mandamos “Dato” por el puerto bidireccional
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 = SADE.ADC(1);//Seleccionamos el canal analógico 1 y el valor que devuelve lo guardamos en “valor_adc” SADE.LEDs(valor_adc);//Mandamos a los LEDs la información.
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 = 0xAA;//Valor que convertiremos a analógico. SADE.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
Con éste método se manda a escribir a un registro de un dispositivo mediante protocolo I2C, sólo se debe especificar los siguientes parámetros: “Slave_Address” – Dirección esclava sin bit R/W, “Reg_Address” – Dirección del registro a escribir, “Reg_Data” – Dato a guardar 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 esclava del dispositivo sin bit R/W byte dir_registro = 0x2A;//Dirección del registro a escribir byte dato = 0x2A;//Dato a escribir en el registro SADE.I2C_Write(dir_esclava, dir_registro, dato);//Mandamos toda la información por I2C
Método que se utiliza para leer un dato de un dispositivo mediante I2C.
IMPORTANTE: Siempre se estará recibiendo un dato del 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 esclava del dispositivo sin bit R/W byte dir_registro = 0x2A;//Dirección del registro a leer byte dato_rec = SADE.I2C_Read(dir_esclava, dir_registro);//Mandamos toda la información por I2C y guardamos el dato recibido en “dato_rec”
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 = 0x55;//Byte a enviar SADE.RS232_SADE_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_rec = SADE.RS232_SADE_Read();//Recibimos el 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 = SADE.Leer_Ultrasonico(SADE.Pin_Sy_G1, SADE.Pin_Sy_F1);//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 SADE.Timer_Modo1(SADE.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.
SADE.Timer_Modo1(SADE.Timer1);//Reset Timer 1
(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.
SADE.Timer_Modo2(SADE.Pin_Sy_B3, 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.
SADE.Reset_Timer_Modo2(SADE.Pin_Sy_B3);//Reset al Timer del pin B3
(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 = SADE.Timer_Modo3(SADE.Pin_Sy_A5, 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.Text = “Disparo externo = true”;//Mandamos a una etiqueta un texto
}
else
{
label3.Text = “Disparo externo = false”;
}
if (x[0] == 1)//Si ya terminó el Timer de contar
{
label4.Text = “Timer fin = true”;//Mandamos a otra etiqueta un texto
}
else
{
label4.Text = “Timer fin = false”;
}
Método que utiliza al DAC como generador de funciones para crear una onda Senoidal, Triangular, Cuadrada o Diente de Sierra.
SADE.Generador_Funciones(SADE.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 la frecuencia de muestreo a partir de la frecuencia de la señal a generar.
int fs = sade.Calcular_fs(1000); //Caculamos la frecuencia de muestreo para generar una señal de 1KHz
Calcula el número de muestras a partir de la frecuencia de la señal a generar.
int num_muestras = SADE.Calcular_Muestras(500); //Caclulamos el número de muestras para generar una señal de 500Hz
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.
//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 = SADE.Calcular_Fs(100); //Calculamos la frecuencia de muestreo
SADE.IniFuncion(100); //Inicializamos el DAC
//Mandamos las muestras mediante un ciclo for
for (int i = 0; i < SADE.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
SADE.MandarMuestras(Muestra);//Enviamos la muestra
}