SADE en C Sharp

Agregar la librería de SADE a tu proyecto

IMPORTANTE: Los archivos LibMetodosSADE.dll y LibMetodosSADE.XML deben encontrarse en la misma carpeta.

  1. Crear un proyecto nuevo (File > New > Project…) y seleccionamos Windows Form Application. Le ponemos un nombre y una ruta al proyecto.

 

  1. En la pestaña Project seleccionamos Add Reference…

 

  1. Damos clic en Browse y agregamos el archivo LibMetodosSADE.dll. Pulsamos OK para cerrar la ventana.

  1. Accedemos al código fuente presionando la tecla F7. Dentro del código nos dirigimos a la parte donde están declaradas las librerías y escribimos  using LibMetodosSADE;

  1. Creamos el objeto y lo instanciamos dentro de la clase Form1 : Form.

  1. Los métodos cuentan con una pequeña descripción para facilitar su uso.

Realizar comunicación en C Sharp

  1. Dentro de la pestaña de diseño agregamos un ComboBox que contendrá los nombres de los puertos COM y un botón.

 

  1. Se pueden cambiar algunas propiedades, por ejemplo, cambiar el nombre del botón por “Abrir” y que aparezca en el botón el texto “Abrir puerto”. De igual forma con el ComboBox.

 

  1. A continuación se muestra el código para abrir el puerto COM.

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étodos de SADE en C Sharp

1) bool AbrirPuertoSADE(string NombrePuerto)

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

 

2) void LEDs(byte Valor_LEDs)

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

 

3)  byte SW()

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” 

 

4) byte Pin_In(byte PinFPGA)

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

 

5) void Pin_Out(byte PinFPGA, bool Valor)

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

 

6) void PWM(int PeriodoPWM, int CicloPWM, byte PinFPGA)

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 )

 

7) byte BiPort_In()

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”

 

8) void BiPort_Out(byte Valor_BiPort)

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

 

9) 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 = 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.

 

10) void DAC(byte ValorDAC)

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

 

11) void I2C_Write(byte Slave_Address, byte Reg_Address, byte Reg_Data)

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

 

12) byte I2C_Read(byte Slave_Address, byte Reg_Address)

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”

 

13) 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 = 0x55;//Byte a enviar
SADE.RS232_SADE_Write(dato);//Mandamos por RS232

 

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 = 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.

 

15) int Leer_Ultrasonico(byte PinTrigger, 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 = 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”

 

16) bool Timer_Modo1(byte Timer, int Tiempo, string Escala_Tiempo, bool Reset)

(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.

17) void Reset_Timer_Modo1(byte Timer)

(No compatible con Symbhia X4)

Resetea el Timer especificado.

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

 

18) bool 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.

 

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.

19) void Reset_Timer_Modo2(byte PinFPGA)

(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

 

20) byte[] Timer_Modo3(byte PinFPGA, int Tiempo, string Escala_Tiempo, int Anchostring 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 = 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”;
}

 

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.

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.

22) int Calcular_Fs(int FrecuenciaHz)

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

 

23) int Calcular_Muestras(int FrecuenciaHz)

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

 

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

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
}

 
[fusion_table]

[/fusion_table]
Menú