Arduino y LabVIEW para control inalámbrico de un automodelo a escala

http://relojcalendariotemyhum.blogspot.com/ Página 0
http://automodeloip.blogspot.com/
1-5-2015
Por: Byron Ganazhapa
ARDUINO
Y
LABVIEW
AUTOMODELO
IP

http://automodeloip.blogspot.com/ Página 1
CONTENIDO
INTRODUCCIÓN..................................................................................................................1
¿QUÉ NECESITAMOS?........................................................................................................1
DESARROLLO....................................................................................................................4
CONFIGURACIÓN DE EQUIPOS ...................................................................................... 4
TRASMISIÓN Y RECEPCIÓN DE DATOS............................................................................ 9
ACONDICIONAMIENTO DE VOLTAJES PARA LECTURA DE BATERÍAS ............................... 13
CONEXIÓN DE PINES DE ENTRADAS Y SALIDAS DEL ARDUINO.......................................... 2
ESQUEMÁTICOS..................................................................................................................1
DISEÑO DE PCB.................................................................................................................1
CODIGO EN ARDUINO................................................................................................1
CODIGO EN LABVIEW...................................................................................................1
IMÁGENES DEL PROYECTO CONCLUIDO.......................................................................2

INTRODUCCIÓN
Un Automodelo IP, es un vehículo a escala desarrollado en Arduino y
controlado desde LabVIEW a través de comunicaciones inalámbricas
wifi, también llamada WLAN o estándares IEEE 802.11.
Este proyecto consiste en el diseño y construcción de un vehículo a
escala en la plataforma Arduino y control en la plataforma LabVIEW
2012 desde cero incluida la tarjeta Arduino, con funcionalidades
similares a un auto a escala mecánica y electrónicamente.
La tarjeta Arduino recibe y transmite la información necesaria para el
cálculo y control respectivo, como por ejemplo: control de velocidades
desde la 1ra hasta la 5ta marcha y reversa, control de direcciones
(izquierda y derecha) con luces intermitentes, control de ventiladores
para los circuitos electrónicos y motor, control de luces delanteras y
traseras, medida de niveles de energía de batería(s), y cálculo de
revoluciones por minuto (RPM).
El programa desarrollado en LabVIEW dispone de una interfaz idéntica a
un tacómetro vehicular, donde visualiza la velocidad actual del
vehículo, RPM, nivel de voltaje de la batería, etc.

¿QUÉ NECESITAMOS?
Para este proyecto es muy indispensable disponer de un conjunto de
herramientas básicas de un laboratorio de electrónica: un soldador,
alambre de estaño, unos alicates de punta de aguja y cables.
Para el desarrollo de nuestro proyecto dispondremos de los siguientes
materiales:
 1x Arduino UNO (o si prefieres puedes desarrollarla desde cero
para que el proyecto sea 100% original)
 Un motor DC de 12 o 24 Voltios
 1x WIZnet Serial-to-Ethernet Gateway - WIZ110SR (o por
preferencia se puede usar un Módulo Ethernet de Arduino).
 1x servomotor
 1x Router
 1x Batería tipo Lipo de 11.1 Voltios a 4000 o 5000 mA
 2x Kit de llantas
 2x ventiladores de 5 Voltios
 2x transitores TIP32, y 4 x TIP31
 2x transitores 2N2222, 1 x BC548, 1 X 2N3906
 1x transistor Mosfet IRF630
 5x diodos 1N4007
 2x diodos BY206
 1x diodo Zener 1N4733A (5.1 Voltios)
 2x Resistencias de 27 Ohms, y 1x 2.2Ohms. 2Watts C/U
 4x Resistencias de 1KOhms, 1 x 100Ohms, 1 x 100KOhms, 3 x
4.7KOhms, 2 x 10KOhms, 2 x 220 Ohms, y 6 x 330Ohms. ¼ Watts C/U

 2x potenciómetros lineales de 50KOhms.
 2x condensadores electrolíticos de 470uF,
 1x condensador poliéster de 470 nF, 3 x 100uF, y 2 x 10uF
 3x condensadores cerámicos de 100nF, 2 x 10nF, y 4 x 20nF
 2x reguladores de voltaje 7805, y 1 x 7808
 2x Leds de alto brillo blanco de 10mm, 2 Rojos de bajo brillo
10mm, y 4 amarillos de bajo brillo de 5mm,
 1x Buzzer.
 Regletas de espadines hembra y macho
 3x Plugs DC
 Moles de 3 y 4 pines (lo que sean necesarios)
 Placa PCB (simple placa y doble)
 Cable de red
Arduino UNO WIZnet WIZ110SR Router
Batería de Lipo Kit de llantas Ventilador de 5V

Transistores Resistencias Potenciómetro lineal
Transistores Diodos
Condensadores
cerámicos
Condensadores
electrolíticos
Reguladores de
voltaje
Diodos LED
Buzzer Espadines hembra y
macho
Plugs DC
motor DC Molex PCB

Servomotor Cable de red
DESARROLLO
CONFIGURACIÓN DE EQUIPOS
Con el objetivo de realizar la comunicación entre el prototipo y una
Laptop es necesario disponer de un módulo convertidor Serial a Ethernet
o Wifi. En este proyecto de usa una configuración entre la tarjeta Wiznet
WIZ110SR y un router para la comunicación entre la PC y la placa
Arduino. Es decir se crea una red LAN para dicha tarea.
A. CONFIGURACIÓN DEL MÓDULO WIZNET
Para realizar la tarea de transmisión de datos es necesario configurar
el módulo WIZ110SR como servidor, de tal manera que, permita a un
cliente conectarse a su red para el intercambiar de información
respectiva y que permita visualizarlos.
Los parámetros de configuración del servidor WIZ110SR son:
 Dirección IP: 192.168.11.2
 Máscara de Subred: 255.255.255.0
 Puerta de enlace: 192.168.11.1
 Dirección MAC: 0x00.0x08.0xDC.0x17.0xCF.0x3F

 Puerto local: 5000
Configuración serial del servidor WIZ110SR:
 Velocidad de transmisión serial: 9600
 Tamaño de bits de datos: 8 bits
 Paridad: ninguna
 Bit de parada: 1 bit

B. CONFIGURACIÓN DEL ROUTER
Se puede usar cualquier router, basta que se pueda configurar para
diseñar la red, en m i caso dispongo de un router Trendnet TEW-6528Rp
de 300Mbps.
El router es configurado como un punto de acceso a la red, de tal
modo que ofrezca direcciones IP dinámicamente para que cualquier
host que pueda conectarse a él.
Tanto para User Name y Password es admin.
Para Wireless la configura es básica: canal, ancho de banda del
canal, y estándar 802.11 b/g/n. Se escoge el canal uno para evitar
interferencias entre otros redes y canales.

Para la red LAN definimos las direcciones IP dinámicamente para que
las entregue a los equipos que se conecten ya sea por cable o por wifi.

C. CONFIGURACIÓN DE LA PC
Ingresamos al Centro de redes y recursos compartidos de la PC para
configurar el adaptador de red inalámbrico
Configuramos en propiedades el protocolo de internet versión 4
(TCP/IPv4).
De tal manera que ingresamos una dirección IP a la PC distinta a las
IP ya ocupadas (192.168.11.3), puerta de enlace que es la dirección IP

del router (192.168.11.1) y la máscara de subred (225.225.225.0) para
estar en la misma red.
Si todo salió excelente podemos verificar la conectividad haciendo
ping desde la PC al módulo Wiznet
TRASMISIÓN Y RECEPCIÓN DE DATOS
Arduino trasmite y recibe información de la red LAN a través del
puerto serial del micro-controlador de para ser visualizada en un host las
variables de RPM y niveles de energía de la(s) batera(s), etc.
Un host se conecta a la red para trasmitir los datos de control al
prototipo como velocidades, direcciones, luces y buzzer mediante un
programa desarrollado en LabVIEW en protocolos TCP/IP disponibles en
las herramientas de la plataforma LabVIEW.
A. TRANSMISIÓN DE DATOS DESDE ARDUINO HACIA UN HOST
Arduino transmite su información por el puerto serial a una velocidad
de 9600 Baudios/s. Ojo es importante configurar el Modulo Wiznet y
Arduino a la misma velocidad, tamaño de datos, paridad, etc.
La trasmisión se la realiza durante cada 500 mili-seg. En una sola
trama de longitud estática como lo indica en la siguiente imagen:

RPM en un tamaño de 3 digitos.
V1 y V2 trasmite el valor de voltaje en las baterías 1 y 2
respectivamente. Batería 1 es usada para energizar los circuitos, y
Bateria 2 es para el motor. Si prefieres puedes usar una sola batería para
conectar todo el proyecto y leer el nivel de voltaje en un solo punto de
la batería. V1 es conectado al puerto analógico 4 del Arduino y V2 al
puerto analógico 5 del Arduino.
V1 y V2 son trasmitidos en tamaños de 4 dígitos.
En importante trasmitir en tamaños de 21 caracteres toda la
información, de tal manera que no exista inestabilidad, desplazamiento
y lectura de datos erróneos al momento de recibir toda la información
en la plataforma LabVIEW.
B. RECEPCIÓN EN ARDUINO
Arduino recibe información desde cualquier host conectado a la red
para el control respectivo del prototipo:
 Recibe el carácter ‘W’ para dar marcha al motor hacia
delante
 Recibe el carácter ‘V’ para neutralizar marchas
 Recibe el carácter ‘S’ para dar marcha al motor hacia tras
(giro reverso del motor).

 Recibe el carácter ‘0’ para realizar el cambio cero o neutral (el
motor no realizara la marcha hacia delante si este está en
cero)
 Recibe el carácter ‘1’ para realizar el primer cambio (el motor
realizara la marcha hacia detente si la 1ra o hasta la 5ta están
activas)
 Recibe el carácter ‘2’ para realizar el segundo cambio para
aumentar la velocidad.
 Recibe el carácter ‘3’ para realizar el tercer cambio para
aumentar a velocidad media.
 Recibe el carácter ‘4’ para realizar el cuarto cambio
 Recibe el carácter ‘5’ para realizar el quinto cambio para
aumentar la velocidad máxima.
 Recibe el carácter ‘A’ para dar giro a la izquierda, este
depende de cómo se conecta el servomotor. Y para la acción
intermitente de luces.
 Recibe el carácter ‘H’ para neutralizar el giro del servomotor.
 Recibe el carácter ‘D’ para dar giro a la derecha, y para la
acción intermitente de luces.
 Recibe el carácter ‘G’ para el encendido de luces delanteras
 Recibe el carácter ‘g’ para el apagado de luces delanteras
 Recibe el carácter ‘F’ para el encendido de luces traseras
 Recibe el carácter ‘f’ para el apagado de luces traseras
 Recibe el carácter ‘T’ para el encendido del Buzzer
 Recibe el carácter ‘t’ para el apagado del Buzzer.
C. TRANSMISIÓN DE DATOS DESDE LABVIEWHACIA UN ARDUINO
LabVIEW trasmite su información para el control del prototipo en el
protocolo TCP/IP disponibles en la paleta de funciones. LabVIEW 2012 o
una versión superior tiene que ser instalada en el computador que se
quiera conectar a la red.

La información trasmitida es la información recibida por la tarjeta
Arduino, por ejemplo:
‘HV0tgf’
Donde ‘H’ es para no girar el vehículo, ‘V’ para neutralizar marchas,
‘0’ para no tener ningún cambio accionado, ‘t’ para apagar el buzzer,
‘g’ para apagar luces delanteras y ‘f’ para mantener apagadas las
luces traseras.
Los caracteres ‘W’, ‘S’, ‘A’ y ‘D’ son accionados por las teclas del
computador
Los caracteres ‘G’, ‘g’, ‘T’ y ’t’ son accionados por las teclas F2 y F3
del computador. F2 controla los caracteres ‘G’ y ‘g’, encendido o
apagado de las luces delanteras y F3 para el encendido y apagado del
buzzer.
Los caracteres ‘0’, ‘1’, ‘2’, ‘3’, ‘4’ y ‘5’ son accionados por las teclas
‘regpág’ y ‘avpág’ en HP o ‘PGUP’ y ‘PGON’ en cualquier computador.
‘regpág’ aumenta y ‘avpág’ decrementa los cambios que se desea.

D. RECEPCIÓN DE DATOS EN LABVIEW
Como se ha mencionado antes, LabVIEW recibe toda la información
en una sola trama de longitud estática, por ejemplo:
RPM:120V1:0674V2:0509
Una vez recibida toda la información se desentrama cada variables
por separado para realizar los cálculos y visualizaciones respectivas
como por ejemplo: cálculo de velocidad actual del vehículo en cm/s,
RPM, niveles de energía en las baterías de 0 a 12V y de 0% al 100% tanto
para el motor como para los circuitos.
ACONDICIONAMIENTO DE VOLTAJES PARA LECTURA DE BATERÍAS
Es importante acondicionar los niveles de voltaje para lectura en los
puertos analógicos del Arduino de 0 a 5V. En nuestro caso se
acondiciona los niveles de voltajes para baterías de 11.5 voltios para 5
voltios de entrada en la tarjeta.
Entonces aplicando la ecuación de división de voltaje se obtendrá el
resultado de los potenciómetros.
𝑉𝑜𝑢𝑡 =
𝑅2
𝑅1 + 𝑅2
𝑉𝑖𝑛
𝑅1 =
( 𝑉𝑖𝑛 − 𝑉𝑜𝑢𝑡 ) 𝑅2
𝑉𝑜𝑢𝑡
𝑅2 = 10𝑘Ω, 𝑉𝑖𝑛 = 11.5𝑉, 𝑉𝑜𝑢𝑡 = 5𝑉
𝑅1 = 13𝑘Ω

En LabVIEW se realiza el proceso inverso para obtener los niveles de
voltaje reales de las baterías, es decir de 5V a 11.5 voltios como nivel
máximo de la batería. Y adicionalmente se realiza un cálculo en
porcentaje de los niveles de energía de las baterías; como niveles
mínimos de las baterías es de 7.5V y máximos de 11.5V, es decir 7.5V =
0% y 11.5V = 100%.
50%
12
3
RV1
50k
R13
10k
50%12
3
RV2
50k
R14
10k
BAT1 BAT2
1
2
BATERIAS
CONN-SIL2
Acondicionamiento de baterias
0%
10%
20%
30%
40%
50%
60%
70%
80%
90%
100%
5 6 7 8 9 10 11 12
Porciento(%)
Voltaje Bateria (V)

Cuya ecuación es: 𝑦 = 25𝑥 − 187.5
CONEXIÓN DE PINES DE ENTRADAS Y SALIDAS DEL ARDUINO
La asignación de los pines de la tarjeta Arduino esa distribuida de la
siguiente manera:
1) Puerto Analógico A4 para batería 1, ya acondicionada
2) Puerto Analógico A2 para batería 2, ya acondicionada
3) Puerto digitales 0 (RX) y 1 (TX) para comunicación serial
4) Puerto D2 entrada para RPM
5) Puerto D3 salida para PWM del motor principal
6) Puerto D4 salida para control del motor en sentido horario
7) Puerto D5 salida para luces frontales

8) Puerto D6 salida para control del motor en sentido anti- horario
9) Puerto D7 salida para control del ventilador 1
10)Puerto D8 salida para control del ventilador 2
11)Puerto D9 salida para control de luces traseras
12)Puerto D10 salida para Buzzer
13)Puerto D11salida para servomotor
14)Puerto D12 salida para luces intermitentes izquierda
15)Puerto D13 salida para luces intermitentes derecha.

ESQUEMÁTICOS
Arduino UNO. (Opcional)
Nota: Si prefieres puedes hacer tu propia tarjeta Arduino en proteus.
PB0/ICP1/CLKO/PCINT0
14
PB1/OC1A/PCINT1
15
PB3/MOSI/OC2A/PCINT3
17
PB2/SS/OC1B/PCINT2
16
PD6/AIN0/OC0A/PCINT22
12
PD5/T1/OC0B/PCINT21
11
PD4/T0/XCK/PCINT20
6
PD3/INT1/OC2B/PCINT19
5
PD2/INT0/PCINT18
4
PD1/TXD/PCINT17
3
PD0/RXD/PCINT16
2
PB4/MISO/PCINT4
18
PB5/SCK/PCINT5
19
PB7/TOSC2/XTAL2/PCINT7
10
PB6/TOSC1/XTAL1/PCINT6
9
PC6/RESET/PCINT14
1
PC5/ADC5/SCL/PCINT13
28
PC4/ADC4/SDA/PCINT12
27
PC3/ADC3/PCINT11
26
PC2/ADC2/PCINT10
25
PC1/ADC1/PCINT9
24
PC0/ADC0/PCINT8
23
AVCC
20
AREF
21
PD7/AIN1/PCINT23
13
ATMEGA
ATMEGA 328
12
BATERIA
9V
R1
22
C2
220uF
D1
1N5399
Vin
C1
100uF
VI
1
VO
3
GND
2
7805
7805
D2
1N4004
C3
100uF
AK
ON
LED-RED
1
6
2
7
3
8
4
9
5
SERIAL (DB-9)
CONN-D9F
Q1
2N3906
R3
10k
R4
10k
R5
4.7k
D4
1N4148
C4
10uF
R6
10k
Q2
BC547
D5
1N4148
R7
1k
R8
10k
1
2
3
4
5
6
ANALOG IN
CONN-SIL6
1
2
3
4
5
6
7
8
DIGITAL 2
CONN-SIL8
1
2
3
4
5
6
7
8
DIGITAL 1
CONN-SIL8
1
2
3
4
5
6
POWER
CONN-SIL6
XTAL1
XTAL2
X1
CRYSTAL
C5
22pF
C6
22pF
XTAL2
XTAL1
R9
10k
1 3
2 4
RESET
SW-DPST
D0
D7
D8
D13
A0
A5
AREF
AREF
C7
100nF
C8
100nF
Vin
reset
reset
MISO
SCK
reset
MOSI
MISO
MOSI
SCK
1
2
3
4
SERIAL (RJ-11)
90325-0004
JUM-TX
JUMPER2
JUM.RX
JUMPER2
TX
RX
R10
1k
R11
1k
AK
TX
LED-YELLOW
AK
RX
LED-YELLOW
RJ11-TXD
RJ11-RXDDB9-RXD
DB9-TXD
TXD
RXD
RJ11-TXD
RJ11-RXD
A-RST
JUMPER
C9
100nF
AUTO-RESET
AUTO-RESET
AUTO-RESET
L1
100uH
R2
1k
1
2
3
IC
CONN-SIL3
1
2
3
SP
CONN-SIL3
RX
TX
DB9-RXD
DB9-TXD
TXD
RXD
RX
TX

Puente H con transistores para motor12
VS1
12V
Q3
TIP31
Q4
TIP31
Q1
TIP32
Q2
TIP32
D1
1N4007
D2
1N4007
D3
1N4007
D4
1N4007
Q5
2N2222A
R1
1k
Q6
2N2222A
R4
1k
12
MOTOR_1
12V
VS1
VS1
1
2
3
4
5
6
7
8
J2
CONN-SIL8
1
2
3
4
5
6
7
8
J1
CONN-SIL8
M_1_L
M_1_R
R5
100
R6
100k
Q9
IRF630
D6
BY206
C1
470n
VS1
D5
BY206
M_1_L M_1_R
PWM_1
PWM_1
1
2
3
4
5
6
ANALOG IN
CONN-SIL6
1
2
3
4
5
6
POWER
CONN-SIL6
R2
27
R3
27

Tarjeta de reguladores de voltaje y ventiladores
12
MOTOR_2
12V
12
MOTOR_3
12V
1
2
3
4
5
6
7
8
J1
CONN-SIL8
1
2
3
4
5
6
7
8
7 6 5 4 3 2 1 0
CONN-SIL8
MOT2
MOT1
1
2
3
4
5
6
ANALOG IN
CONN-SIL6
1
2
3
4
5
6
POWER
CONN-SIL6
12
VWIZNET
VRouter
C1
10nF
D1
1N4007
C4
100nF
R1
2.2
C6
100nF
VI
1
VO
3
GND
2
U2
7805
C7
20nF
C5
100uF
C8
10uF
C9
20nFD2
1N4733A
1
2
WIZNET
WIZNET
12
VROUTER
VWiznet
C10
10nF
C11
100uF
C12
100nF
VI
1
VO
3
GND
2
U4
7805
C14
20nF
C15
10uF
C16
20nF
1
2
ROUTER
ROUTER
VI
1
VO
3
GND
2
U3
7808
C13
100uF
Fuentes para wiznet
Fuente para Router
VW=VR
JUMPER
VWiznet
VRouterVRouter
VWiznet
C2
470u
C3
470u
Q1
TIP31
Q2
TIP31
VR
VR
VR
R2
4.7k
R3
4.7k
MOT1 MOT2
C17
100nF
C18
100nF
Ventilador 1 Ventilador 2

Placas de luces, Buzzer , servo, Fototransistor para PRM y acondicionamiento de voltajes para medir el nivel de voltaje en las baterías
R1
220
AK
LEFT 1
LED-YELLOW
AK
LEFT 2
LED-YELLOW
R3
330
R4
10k
AK FRONT1
LED-BLUE
AK
FRONT2
LED-BLUE
R2
220
AK
RIGHT1
LED-YELLOW
AK
RIGHT2
LED-YELLOW
R5
330
R6
10k
AK
T1
LED-RED
AK
T2
LED-RED
R7
330
R8
10k
Luces Frontales Luces intermitentes de Izquierda Luces intermitentes de Derecha Luces Traseras
Q1
BC548
BUZ1
BUZZER
R9
1.2k
1
2
3
RPM
CONN-SIL3
R10
330
R11
4.7k
Q2
2N3906
R12
1.2k
40%
12
3
RV1
1k
R13
10k
40%12
3
RV2
1k
R14
10k
1
2
3
SERVO
CONN-SIL3
1
2
3
4
FRO1
CONN-SIL4
1
2
3
4
TR1
CONN-SIL4
F
L
R
T
L
F
R
R
T
L
Servo
Servo
Buzz
Buzz
1
2
3
4
DIGITAL
CONN-SIL4
1
2
3
ANALOG/RPM
CONN-SIL3
BAT1 BAT2
RPM
RPM
BAT1
BAT2
1
2
3
4
PLA
CONN-SIL4
1
2
3
4
FRO2
CONN-SIL4
L
F
R
1
2
3
4
TR2
CONN-SIL4
L
T
R
L
F
T
R
1
2
BATERIAS
CONN-SIL2
Buzzer Acondicionamiento de baterias circuito del foto-transistor para RPM
Conexiones de molex

DISEÑO DE PCB
Arduino UNO
Puente H con transistores para motor
Tarjeta de reguladores de voltaje y ventiladores

Placas de luces, Buzzer , servo, Fototransistor para PRM y acondicionamiento de
voltajes para medir el nivel de voltaje en las baterias

CODIGO EN ARDUINO
#include <Servo.h>
//------- Variable para luces intermitentes ---------//
long tiempo_anterior_luces=0;
//------- Variable para transmisión de datos ---------//
long tiempo_anterior_tx=0;
boolean estado = false;
//------- Variables para medir RPM---------//
byte rpmcount;
unsigned int rpm;
unsigned long timeold;
long timer_3=0;
//------- Variables para medir Voltajes---------//
int analogico4 = A4;
int analogico5 = A5;
//------- Variables de control---------//
int datoserial;
const int avanzar = 6;
const int control_motor = 3;
const int retroceder = 4;
const int ventilador_1 = 7;
const int ventilador_2 = 8;
const int luces_delanteras = 5;
const int luces_traceras = 9;
const int luces_intermitentes_izq = 12;
const int luces_intermitentes_der = 13;
const int buzzer = 10;
Servo volante; // PIN 11
int alta_veloc = 0; // para encender ventilador del motor
void rpm_fun() {
rpmcount++;
}
void setup() {
Serial.begin(9600);
volante.attach(11);
pinMode(control_motor, OUTPUT);
pinMode(luces_intermitentes_izq,OUTPUT);
pinMode(luces_intermitentes_der,OUTPUT);
pinMode(luces_delanteras,OUTPUT);
pinMode(luces_traceras,OUTPUT);
pinMode(avanzar,OUTPUT);
pinMode(retroceder,OUTPUT);
pinMode(ventilador_1,OUTPUT);
pinMode(ventilador_2,OUTPUT);
pinMode(buzzer ,OUTPUT);
attachInterrupt(0, rpm_fun, FALLING);
rpmcount = 0;
rpm = 0;
timeold = 0;

}
void loop() {
//---------Lunces intermitentes--------//
long tiempo_actual_luces = millis();
long tiempo_luces = tiempo_actual_luces - tiempo_anterior_luces;
//------------ Calculo de voltajes------------//
int bateria_circuitos = analogRead(analogico4);
int bateria_motor = analogRead(analogico5);
//------------ Encendido de ventiladores ------------//
long tiempo_ventilador = millis();
if (tiempo_ventilador >= 60000) {
digitalWrite(ventilador_1,HIGH);
}
else {
digitalWrite(ventilador_1,LOW);
}
if (alta_veloc == 1) {
digitalWrite(ventilador_2,HIGH);
}
else {
digitalWrite(ventilador_2,LOW);
}
//------------ Calculo de RPM ------------//
long timer_1 = millis();
long timer_2 = timer_1 -timer_3;
if (timer_2 >= 1000){
detachInterrupt(0);
rpm = 60000/(millis() - timeold)*rpmcount;
timeold = millis();
rpmcount = 0;
attachInterrupt(0, rpm_fun, FALLING);
timer_3 = millis();
}
///------------ Transmisión de datos Ethernet------------//
if (estado == true){ // Transmite información cuando recibe
long tiempo_actual_tx = millis();
long tiempo_tx = tiempo_actual_tx - tiempo_anterior_tx;
if (tiempo_tx >=500){ // trasnmision de datos cada 500ms
Serial.print("RPM:");
if (rpm <= 30)Serial.print("0.0");
if ((rpm>30)&&(rpm<=99)){
Serial.print("0");
Serial.print(rpm);
}
if ((rpm>=100)&&(rpm<=999))Serial.print(rpm);
if (rpm>=1000) Serial.print("0.0");
Serial.print("V1:");
if (bateria_circuitos <=9) {
Serial.print("000");
Serial.print(bateria_circuitos);
}
else if ((bateria_circuitos >=10)&&(bateria_circuitos <=99)) {
Serial.print("00");

}
else if ((bateria_circuitos >=100)&&(bateria_circuitos <=999)) {
Serial.print("0");
}
else Serial.print(bateria_circuitos);
Serial.print("V2:");
if (bateria_motor <=9) {
Serial.print("000");
Serial.println(bateria_motor);
}
else if ((bateria_motor >=10)&&(bateria_motor <=99)) {
Serial.print("00");
}
else if ((bateria_motor >=100)&&(bateria_motor <=999)) {
Serial.print("0");
}
else Serial.println(bateria_motor);
tiempo_anterior_tx = millis();
}
}
//------------ Recepción de datos Ethernet------------//
if(Serial.available()>0){
estado = true; // recibe información para despues transmitir
datoserial = Serial.read();
if (datoserial=='W'){ // Marcha delante
digitalWrite(avanzar, HIGH);
digitalWrite(retroceder, LOW);
}
if (datoserial=='V'){ // Marcha neutral
digitalWrite(avanzar, LOW);
digitalWrite(retroceder, LOW);
}
if (datoserial=='S'){ // Marcha retro
digitalWrite(avanzar, LOW);
digitalWrite(retroceder, HIGH);
}
if (datoserial=='0'){ // motor apagado
analogWrite(control_motor, 0);
alta_veloc = 0;
}
if (datoserial=='1'){
analogWrite(control_motor, 250); // motor a 50 de velocidad
alta_veloc = 0;
}
analogWrite(control_motor, 175);// motor a 100 de velocidad
alta_veloc = 0;
}
alta_veloc = 1;
}
alta_veloc= 1;

}
analogWrite(control_motor, 255);// motor a maxima velicidad
alta_veloc = 1;
}
if (datoserial=='A'){ //Dirección al giro izquierdo del vehículo
volante.write(115);
digitalWrite(luces_intermitentes_der, LOW);
if (tiempo_luces <= 500)
digitalWrite(luces_intermitentes_izq, HIGH);
if ((tiempo_luces >= 501)&&(tiempo_luces <
1000))digitalWrite(luces_intermitentes_izq, LOW);
if (tiempo_luces >= 1001) tiempo_anterior_luces = millis();
}
if (datoserial=='H'){ // Dirección neutral del vehículo
volante.write(90);
digitalWrite(luces_intermitentes_der, LOW); // intermitentes
apagadas
digitalWrite(luces_intermitentes_izq, LOW);
}
if (datoserial=='D'){ //Dirección al giro derecha del vehículo
volante.write(65);
digitalWrite(luces_intermitentes_izq, LOW);
if (tiempo_luces <= 500)
digitalWrite(luces_intermitentes_der, HIGH);
if ((tiempo_luces >= 501)&&(tiempo_luces <
1000))digitalWrite(luces_intermitentes_der, LOW);
if (tiempo_luces >= 1001) tiempo_anterior_luces = millis();
}
if (datoserial=='G'){ // encendido de Luces delanteras
digitalWrite(luces_delanteras, HIGH);
}
if (datoserial=='g'){ // apagado de Luces delanteras
digitalWrite(luces_delanteras, LOW);
}
if (datoserial=='F'){ // encendido de Luces traceras
digitalWrite(luces_traceras, HIGH);
}
if (datoserial=='f'){ // apagado de Luces traceras
digitalWrite(luces_traceras, LOW);
}
if (datoserial=='T'){ // encendido de Buzer
digitalWrite(buzzer, HIGH);
}
if (datoserial=='t'){ // apagado de buzer
digitalWrite(buzzer, LOW);
}
}
}

CODIGO EN LABVIEW
Panel Frontal
Diagrama de bloques

IMÁGENES DEL PROYECTO CONCLUIDO

REFERENCIAS
https://sites.google.com/site/controltechnologyperu/home/Tutoriales/tutorial-
labview/comunicacion-por-tcp
http://www.rcelectrico.es/
http://www.automodelismoparatodos.blogspot.com/
Si deseas descargar el proyecto completa visita el siguiente blog:
http://automodeloip.blogspot.com/

Arduino y LabVIEW para control inalámbrico de un automodelo a escala

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Similar a Arduino y LabVIEW para control inalámbrico de un automodelo a escala

Similar a Arduino y LabVIEW para control inalámbrico de un automodelo a escala (20)

Más de Byron Ganazhapa

Más de Byron Ganazhapa (8)

Último

Último (20)

Arduino y LabVIEW para control inalámbrico de un automodelo a escala