UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD DE INGENIERÍA EN SISTEMAS, ELECTRÓNICA E INDUSTRIAL

CARRERA DE INGENIERÍA ELECTRÓNICA Y COMUNICACIONES

Trabajo
Área Académica
Física y Electrónica

Línea de Investigación
Tecnologías de comunicación

Ciclo Académico y Paralelo

Sexto Electrónica A

Alumnos:
Juan Carlos Cherres
Ricardo Crespo

Módulo:
Instrumentación y procesos de control

Docente:
Ing. Luis Pomaquero
TEMA:

TRANSMISIÓN DE DATOS SERIALES UTILIZANDO EL PROTOCOLO TCP/IP EN LABVIEW

OBJETIVOS

OBJETIVO GENERAL

Transmitir datos seriales formando una red que cuente con un servidor y diversos clientes usando
el programa labview

OBJETIVOS ESPECÍFICOS

 Establecer conexión mediante una red usando el programa Labview.

 Enviar y recibir datos tanto en el servidor como en el cliente por medio del uso de
sensores y leds.
 Verificar el correcto envío de datos por medio de la inexistencia de retraso dentro de la
red.

RESUMEN

Nuestra transmisión de datos se basa en una red formada por un servidor y dos clientes en donde
se podrá enviar y recibir datos de servidor a clientes y viceversa, en tiempo real, es decir, sin
ningún retraso en el envío.

El sensor que se utilizó fue el DTH22 que tiene una doble funcionalidad como sensor, sensa y nos
da el valor de la temperatura a la que nos encontremos y también nos da el valor de la humedad
del aire.

También para verificar el correcto envío de datos se conectarán leds en los circuitos
correspondientes del servidor y de los 2 clientes.
 PROCEDIMIENTO
ARMAR LA RED

El servidor debe estar conectado a un router con acceso a internet por medio de cable de red.

Las 2 computadoras que serán los clientes deben estar conectados al mismo router del servidor,
pero los clientes deberán estar conectados por medio de la red wifi del router.

Vemos las configuraciones del router:

Una vez que estén las computadoras conectados como se mencionó anteriormente, se procede a
observar sus direcciones ip para comprobar que haya conectividad.
Vemos la dirección ip del servidor:

Es la 192.168.0.104

Y de igual manera vemos las direcciones en los clientes:

Como podemos observar la dirección ip es la 192.168.0.103

Vemos la dirección ip del otro cliente:

Observamos que la dirección es la 192.168.0.102

Entonces para comprobar la conectividad mandamos un ping desde la 192.168.0.103 a la

192.168.0.104 que es el servidor:
Entonces para comprobar la conectividad mandamos un ping desde la 192.168.0.103 a la
192.168.0.102 que es el otro cliente:

Como observamos si existe conectividad entre las máquinas, y hacemos el mismo proceso entre
todas las máquinas para comprobar la conectividad.

También es importante mencionar que hay que desactivar el firewall y el antivirus de la

computadora para evitar inconvenientes en la comunicación de datos.
PROGRAMACIÓN DEL SERVIDOR

Primero observamos que las computadoras estén en red en el programa Labview para poder crear
y compartir las variables de red:

A continuación se va a explicar detalladamente en que consiste la programación realizada en el

servidor.
En la imagen anterior podemos notar los controles de temperatura (termómetro) y de la humedad
del aire en los cuales según manipulemos al sensor los valores en dichos controles irán cambiando.

El indicador de voltaje nos permite obtener el dato desde un cliente hacia el servidor con ello
transmitimos datos de retorno al servidor.

También notamos los botones de los clientes, los cuales nos permitirá recibir un dato desde cada
cliente hasta cada el servidor.
Al lado derecho de igual manera están 4 leds, los cuales nos indicarán el momento en el que el
servidor los active esos 4 leds que físicamente estarán conectados en el circuito de un cliente.

Ahora vamos a revisar la sección de la programación de bloques.

La vista general de toda la programación es esta:

A continuación se explica que hace cada parte de la programación:

Comenzamos abriendo el puerto por donde va a existir la comunicación serial, en este caso el
COM 12

En esta parte el VISA READ es el que lee cabe la redundancia la lectura serial, a esto se le agrega
una constante (20) que es el valor de la longitud del buffer.

Recepción de los datos boleanos enviados por los clientes.

Procesamiento de datos para enviar a la tarjeta arduino y accionar el control ON-OFF de los leds

Los datos procesados en el paso anterior ahora van a ser concadenados mediante un
“Concatenate strings” para luego ir a un VISA Write

Lectura del buffer

En esta parte se separa el buffer según su necesidad.

Ej: se coge el primer dato hasta el cuarto dato

Separación de los Datos de Temp y Hum separados del buffer PRINCIPAL

Conversión de string a números fraccionarios, además de coger solo su valor absoluto

Envio de los datos de TEMP y HUM a sus respectivos indicadores y variables shared
Al igual que el indicador del voltaje desde el cliente

Separación del buffer que controlan las variables boleanas separados del buffer principal.

Se compara con el carácter programado en alto para que tenga la misma lógica booleana.
Temporizador

Pata cerrar el puerto

Parada del programa

PROGRAMACIÓN DEL CLIENTE

Ahora vamos a explicar la parte del servidor.

En la imagen anterior podemos observar los controles en donde se vizualizarán los datos enviados
por el servidor.

Controles de temperatura y de la humedad del aire.

De igual manera tenemos en donde se visualizará numéricamente los valores de temperatura y
humedad.

También el envió y recibo de los datos booleanos por medio de la señal de leds

Ahora la programación por bloques:

Esta es la vista general de la programación realizada en el cliente:

Ahora se explica la programación por partes.

Comenzamos abriendo el puerto por donde va a existir la comunicación serial, en este caso el
COM 9

En esta parte el VISA READ es el que lee cabe la redundancia la lectura serial, a esto se le agrega
una constante (8) que es el valor de la longitud del buffer.
Recepción de datos boleanos del servidor

Procesamiento de datos para enviar a la tarjeta arduino y accionar el control ON-OFF de los leds

Concadenar los datos a ser enviados

Temporizador
Recibimiento y visualización de los datos recibidos, tanto de temperatura como de la humedad del
aire.

Y del voltaje

Botón de paro

Cerrar el puerto
Finalmente se explica la programación en arduino.

Programación en el servidor:

#include "DHT.h" //librería sensor

#define DHTPIN 10 ///pin sensor
#define DHTTYPE DHT22 //tipo de sensor
DHT dht(DHTPIN, DHTTYPE);
char buffer[20], dato[2]; //buffer de datos envió y recepción

// declaración de pines
int ouPin = 5;
int ouPin1 = 4;
int inPin = 6;
int inPin1 = 7;
int inPin2 = 8;
int inPin3 = 9;// pin de ingreso para el interruptor
int val = 0; // variable que lee la entrada del pin
int led ;
int val1 = 0; // variable que lee la entrada del pin
int led1 ;
int val2 = 0; // variable que escribe la entrada del pin int led2 ;
int val3 = 0; // variable que escribe la entrada del pin
int led3 ;
void setup() {
//configuración de velocidad
Serial.begin(9600); //Inicia la velocidad en 9600 baudios
/////////declara los pines
pinMode(inPin, INPUT);
pinMode(inPin1, INPUT);
pinMode(inPin2, INPUT);
pinMode(inPin3, INPUT);
pinMode(ouPin, OUTPUT);
pinMode(ouPin1, OUTPUT);
dht.begin();//INICIO EL SENSOR
}
//METODO MEDIR TEMPERATURA
float lectura_Temp()
{
float t = dht.readTemperature(); //Se lee la temperatura
return t;
}
//METODO MEDIR HUMEDAD
float lectura_Hum()
{
float h = dht.readHumidity(); //Se lee la humedad
return h;
}
void loop() {
//ingreso de los dip swtich para los leds
val = digitalRead(inPin); // lectura de ingreso del valor
if (val == HIGH) { // estado de la entrada para la condición if
led = 1;
} else {
led = 2;
}
val1 = digitalRead(inPin1); // lectura de ingreso del valor
if (val1 == HIGH) { // estado de la entrada para la condición if
led1 = 3;
} else {
led1 = 4;
}
val2 = digitalRead(inPin2); // lectura de ingreso del valor
if (val2 == HIGH) { // estado de la entrada para la condición if
led2 = 5;
} else {
led2 = 6;
}
val3 = digitalRead(inPin3); // lectura de ingreso del valor
if (val3 == HIGH) { // estado de la entrada para la condición if
led3 = 7;
} else {
led3 = 8;
}
//recepción de datos de temperatura y humedad sensor procesamiento para el envío
float tempf = lectura_Temp();
int temp = lectura_Temp();
// float humf = lectura_Hum();
int hum = lectura_Hum();
//int hums = (humf - hum)*10;
int temps = (tempf - temp) * 10;
///este es el orden que debe ir para recibirse en la aplicación
// generación de buffer para el envío según el orden deseado
sprintf(buffer, "%d,%d,%d,%d,%d,%d,%d", temp, temps, hum, led, led1, led2, led3); //concadena varias variables
diferentes como int, char en una sola cadena, aprovecho la coma para dividir en labview los datos
Serial.println(buffer);
delay(10);
//lectura del puerto serial si ahi datos
if (Serial.available() > 0) {
//lectura por bytes
Serial.readBytes(dato, Serial.available());
// compracion delos datos por posición para realizar las acciones
switch (dato[0]) {
case 'a':
digitalWrite(ouPin, HIGH);
break;
case 'b':
digitalWrite(ouPin, LOW);
break;
case 'c':
digitalWrite(ouPin1, HIGH);
break;
case 'd':
digitalWrite(ouPin1, LOW);
break;
}
switch (dato[1]) {
 case 'a':
digitalWrite(ouPin, HIGH);
break;
case 'b':
digitalWrite(ouPin, LOW);
break;
case 'c':
digitalWrite(ouPin1, HIGH);
break;
case 'd':
digitalWrite(ouPin1, LOW);
break;
}

}
}

Programación del cliente:

#include <LiquidCrystal.h> //declara el lcd libreria
LiquidCrystal lcd(8, 7, 6, 5, 4, 3); //pines lcd
//uffer datos envio y recpcion
char buffer[20], dato[8];
//declaracion de pines para la conexion
int inPin = 9;
int val = 0;
int led ;
int LED1 = 11;
int LED2 = 10;
float volt;
int volt1;
int volt2;
//variables string para la recepcion del dato para los lcd
String string1 = "";
String string2 = "";
String string3 = "";
String string4 = "";
String string5 = "";
String string6 = "";
void setup() {
// velocdad del puerto
Serial.begin(9600);
//string.reserve(200);

//declaracion de los pines

pinMode(LED1, OUTPUT);
pinMode(inPin, INPUT);
pinMode(LED2, OUTPUT);

//inicin del lcd

lcd.begin(16, 2);
//inicio lcd
lcd.setCursor(0, 0); // col fila
lcd.print(" UTA-FISEI");
lcd.setCursor(0, 1); // col fila
lcd.print(" INSTRU-6AE");
delay(4000);
 lcd.clear();
}

void loop() {
//ingreso el dipsswitch para los leds
val = digitalRead(inPin); // read input value
if (val == HIGH) { // check if the input is HIGH (button released)
led = 1;
} else {
led = 2;
}

//dato analogico
int potvalue = analogRead(1); //entrada dato analogico
float volt = (potvalue * 5.0) / 1023; //conversion de analogico a voltaje
int volt1 = volt; //conversion float a enterp
volt2 = (volt - volt1) * 10; //dato decimal para enviar dos enteros ej 1.6 se envia 1 6 dos datos enteros
//generacion de buffer para el envio
sprintf(buffer, "%d,%d,%d", led, volt1, volt2); //concadena varias variables diferentes como int, char en una sola
cadena, para dividir en labview los datos
Serial.println(buffer); //envio del buffer
delay(50); //pausa
//lectura del puerto si ahi datos disponibles
if (Serial.available() > 0) {
//lecutra del dato po bytes
Serial.readBytes(dato, Serial.available());
//porcesamientos delos datoas para el lcd por posiciones para su uso deacuerdo al envio desde labview en este caso
los string 1 al 4 son temp y string 4 al 5 hum
string1 = dato[2];
string2 = dato[3];
string3 = dato[4];
string4 = dato[5];
string5 = dato[6];
string6 = dato[7];
//compracion de dato por posicion para enceder los leds
switch (dato[0]) {
case 'a':
digitalWrite(LED1, HIGH);
break;
case 'b':
digitalWrite(LED1, LOW);
break;
}
switch (dato[1]) {
case 'c':
digitalWrite(LED2, HIGH);
break;
case 'd':
digitalWrite(LED2, LOW);
break;
}
}
//impresion de los datos en los lcd para coroborar los datos del HMI de labview
lcd.setCursor(0, 0);//col fila
lcd.print("Temp = ");
lcd.print(" ");
lcd.print(string1);
lcd.print(string2);
lcd.print(string3);
 lcd.print(string4);
lcd.print(" ");
lcd.print("oC");

lcd.setCursor(0, 1); //col fila

lcd.print("Hum = ");
lcd.print(" ");
lcd.print(string5);
lcd.print(string6);
lcd.print(" ");
lcd.print("%");