Code: Select all
Serial.print("This is my debugging string");Code: Select all
Serial.print(F("This is my debugging string"));Code: Select all
/*
Modificado por asesorplaza1 en las diferentes fechas indicadas
Las primeras pruebas y cambios del código, se iniciaron en 2.016, debido a la cantidad de modificaciones
A partir de ahora 30/01/2020, se ponen las fechas y los cambios en la descripción del proyecto
Para facilitar la búsqueda de errores en los diferentes cambios del código
30/01/2020 ya se han comentado todas las líneas de control de la cámara y del LCD
Le añado 2 DHT22 y así estarán los 3 que me hacen falta
He borrado varias líneas de control de la cámara que no se va a utilizar
01/02/2020 le añado los controles del giroscopio facilitados por Dea de www.cambatronics.com
02/02/2020 no hace falta modificar nada porque ya viene desde el Esclavo solo 1 lectura del sensor X segundo
04/02/2020 modifico las líneas de lectura de los sensores, porque hasta ahora solo me imprime en Monitor Serie el texto, no los datos
06/02/2020 se depura un poco el código, y se modifica el encabezado del código
08/02/2020 se corrige el error de lectura en los sensores, y se corrige la escritura del Monitor Serie
12/02/2020 para poder añadir cualquier código hay que seguir unas reglas especificas de programación
Se modifica la estructura del código siguiendo esas órdenes de programación, según la información obtenida y guardada en la carpeta 01_UNIR_2_CODIGOS
Se crean varios bloques en el void loop, para el funcionamiento de cada uno de los sensores, eliminando los delay()
Se añade el sensor de distancia infrarrojo E18-D80NK, sin errores
13/02/2020 se incluye la lectura del sensor de temperatura DS18B20
16/02/2020 Se añade la lectura del sensor de distancia infrarrojo E18-D80NK, sin errores
y consigo adaptar un código para leer el sensor de presión SKU237545
08/03/2020 se conecta un relé en el pin 12 del Arduino Esclavo, para encender los focos de luz externos, no hace falta cambiar el código
26/03/2020 Se arregla el envío de datos, separando los datos del Monitor Serie, y los datos que hay que enviar al Arduino Maestro,
Iniciando dos puertos serie con las órdenes
Serial.begin(57600); // Puerto Serie USB ***
Serial3.begin(57600); // Puerto Serie en los pines 14 y 15 ***
ETin.begin(details(rxdata), &Serial3); // Comienza la recepción de datos a través de Serial, en los pines 18 y 19 ***
ETout.begin(details(txdata), &Serial3); // Comienza el envío de datos a través de Serial, en los pines 18 y 19 ***
En el Esclavo se incluye una librería específica para el giroscopio MPU6050
28/03/2020 Se incluyen el envío de todas las instrucciones del mando, para tener todos los botones operativos
03/04/2020 Se incluye la parte nueva del Giroscopio MPU6050, que muestra los 3 ejes de inclinación, más la temperatura del Giroscopio.
y se arreglan y ordenan los Serial.print
11/04/2020 Corrijo el código según las instrucciones de mi amigo Atilano Belinchón
13/04/2020 Corrijo las lecturas y envío de datos del sensor de infrarrojos E18D80NK
18/04/2020 Se cambian algunos " if ", por " else if ", para darle agilidad al código
Entre el día 24/03/2020 y el día 28/04/2020, se hacen varios cambios en el código para mejorarlo y conseguir que el mando funcione,
siguiendo las instrucciones de bigbadbob en las publicaciones del foro
http://www.homebuiltrovs.com/rovforum/viewtopic.php?f=18&t=1908
A partir de la página 4
28/04/2020 Se corrige la ortografia de todo le texto que no son órdenes
03/05/2020 Secambian las asignaciones de los pines, segun el codigo de Github
Las nuevas asignaciones de pines son:
Salida de 3.3V a PIN rojo PS2
Pin 24 a PIN amarillo PS2 + resistencia 1k
Pin 23 a PIN naranja PS2
Pin 25 a PIN marrón PS2 + resistencia 1k
Pin 22 a PIN azul PS2
se arregla el codigo para que me salga enel Maestro el estado de los focos, encendidos / apagados
La versión original tomada como punto de partida es la siguiente
ROVPS2Control_Master8.ino
Hamish Trolove - 30 de marzo de 2016
www.techmonkeybusiness.com
Y toma comandos de control de un mando PS2 y transmite los
Comandos que utilizan la Biblioteca EasyTransfer de Bill Porter en un serial de 9600 baudios
Enlace (100m de ateo).
Este boceto está diseñado para un Arduino Nano con un solo puerto serie.
Aunque yo lo estoy usando en un Mega 2560 y funciona
Indicador de disparo de foto de pin D2 a cámara LED (anulado en el código de asesorplaza1)
Indicador de grabación de cámara de pin D3 a LED (anulado en el código de asesorplaza1)
Para la transmisión del video asesorplaza1 utilizara una Raspberry Pi 3 plus, una cámara USB, y el programa VCL Media Player
Indicador de luces principales de Pin D4 a LED
Sensor D5 a LED ROV Batería De bajo voltaje Advertencia
Pin D6 a LED ROV Advertencia interior de alta temperatura
Comunicaciones cambiado por Asesorplaza1, el 26/03/2020, para separar los datos que se envían de un Arduino a otro, de los datos del Monitor Serie
Conexión serie: Parte superior 19 (TX) a ROV 18 (RX)
Conexión serie: Parte superior 18 (RX) a ROV 19 (TX)
Conecte el GND en ambos
Una pantalla LCD de 16x2 está conectada de la siguiente manera (anulado en el código de asesorplaza1)
VSS a GND (anulado en el código de asesorplaza1)
Salida de VDD a 5V del regulador MC78T05CT (anulado en el código de asesorplaza1)
VO para barrer el brazo de la resistencia variable de 10kohm (anulado en el código de asesorplaza1)
RS a Arduino Nano pin A0 (anulado en el código de asesorplaza1)
RW a GND (anulado en el código de asesorplaza1)
E a Arduino Nano pin A1 (anulado en el código de asesorplaza1)
D4 a Arduino Nano pin A2 (anulado en el código de asesorplaza1)
D5 a Arduino Nano pin A3 (anulado en el código de asesorplaza1)
D6 a Arduino Nano pin A4 (anulado en el código de asesorplaza1)
D7 a Arduino Nano pin A5 (anulado en el código de asesorplaza1)
Salida de A a 5V del regulador MC78T05CT (anulado en el código de asesorplaza1)
K a GND a través de una resistencia de 330ohm (anulado en el código de asesorplaza1)
La pantalla LCD de 16x2, se cambiara por una pantalla Nextion básica de 5"
5V se suministra desde un regulador a las resistencias de tracción 1Kohm
Para PS2, así como la pantalla LCD y su luz de fondo
La codificación tira de la biblioteca PSX desarrollada por Bill Porter.
Vea www.billporter.info para consultar lo último de Bill Porter y descargar las bibliotecas.
Los controles para el ROV son;
Stick izquierdo - Eje X - Rodar, Eje Y - Arriba/abajo
Stick derecho - Eje X - Yaw, Eje Y - adelante/atrás
Almohadilla de botón de dirección a la izquierda - LED Luces principales Interruptor de encendido/apagado
Botón de dirección hacia arriba - gire la cámara hacia arriba (anulado en el código de asesorplaza1)
Botón de dirección hacia abajo - girar la cámara hacia abajo (anulado en el código de asesorplaza1)
Teclado de botón de dirección a la derecha - Cambiar la lectura en la pantalla (anulado en el código de asesorplaza1)
Triángulo: Grabación de vídeo de inicio/parada (anulado en el código de asesorplaza1)
Círculo - Tomar foto (anulado en el código de asesorplaza1)
*/
#include <PS2X_lib.h> // Librería PS2 de Bill Porter
#include <EasyTransfer.h> // Librería Easy Transfer de Bill Porter
PS2X ps2x; // Crea la clase del controlador PS2
int error = 0; // Crea la clase de error del mando
byte type = 0; // Crea el tipo de error del mando
byte vibrate = 0; // Crea la vibracion del mando
EasyTransfer ETin, ETout; //Cree los objetos de EasyTransfer para la comunicación bidireccional
const int grnLEDpin = 30; // LED verde esta encendido en pin Digital 4
const int redLEDpin = 31; // LED rojo esta encendido en pin Digital 3
const int yelLEDpin = 32; // LED amarillo esta encendido en pin Digital 2
const int VwarnLEDpin = 33; // LED de advertencia de voltaje esta encendido en el Pin digital D5
const int TwarnLEDpin = 34; // LED de advertencia de temperatura esta encendido en el pin D6
const int pinLedColision = 35; // LED de advertencia de peligro colisión en el pin 27
const int LowBatVolts10 = 96; // esto es para mantener el valor de advertencia de voltaje de bateria bajo en el umbral de x10.
int ForwardVal = 0; // valor leído en palo PS2 derecho arriba/abajo
int YawLeftVal = 0; // valor leído en palo PS2 derecho derecha/izquierda
int UpVal = 0; // valor leído en palo PS2 izquierdo arriba/abajo
int RollLeftVal = 0; // valor leído en palo PS2 izquierdo derecha/izquierda
boolean PSB_PAD_UPstate = false; // Genera variable para guardar y mandar los datos del botón Izquierda arriba al Esclavo
boolean PSB_PAD_DOWNstate = false; // Genera variable para guardar y mandar los datos del botón Izquierda abajo al Esclavo
boolean PSB_PAD_LEFTstate = false; // Genera variable para guardar y mandar los datos del botón Izquierda izquierdo al Esclavo
boolean PSB_PAD_RIGHTstate = false; // Genera variable para guardar y mandar los datos del botón Izquierda derecho al Esclavo
boolean PSB_BLUEstate = false; // Genera variable para guardar y mandar los datos del botón Cruz azul al Esclavo
boolean PSB_GREENstate = false; // Genera variable para guardar y mandar los datos del botón Triangulo verde al Esclavo
boolean PSB_PINKstate = false; // Genera variable para guardar y mandar los datos del botón Cuadrado rosa al Esclavo
boolean PSB_REDstate = false; // Genera variable para guardar y mandar los datos del botón Circulo rojo al Esclavo
boolean PSB_L1state = false; // Genera variable para guardar y mandar los datos del botón Izquierda delante arriba al Esclavo
boolean PSB_L2state = false; // Genera variable para guardar y mandar los datos del botón Izquierda delante abajo al Esclavo
boolean PSB_L3state = false; // Genera variable para guardar y mandar los datos del botón Palo izquierdo abajo al Esclavo
boolean PSB_R1state = false; // Genera variable para guardar y mandar los datos del botón Derecha delante arriba al Esclavo
boolean PSB_R2state = false; // Genera variable para guardar y mandar los datos del botón Derecha delante abajo al Esclavo
boolean PSB_R3state = false; // Genera variable para guardar y mandar los datos del botón Palo derecho abajo al Esclavo
float ROVTMP = 0; // Variable para recibir los datos de la temperatura interior del ROV
float ROVTMP1 = 0; // Variable para recibir los datos de la temperatura motor derecho del ROV
float ROVTMP2 = 0; // Variable para recibir los datos de la temperatura motor izquierdo del ROV
float ROVDHThumid; // Variable para recibir los datos de la humedad interior del ROV
float ROVDHThumid1; // Variable para recibir los datos de la humedad del motor derecho del ROV
float ROVDHThumid2; // Variable para recibir los datos de la humedad del motor izquierde del ROV
float AccX, AccY, AccZ, Temp, GyroX, GyroY, GyroZ; // Variable para recibir los datos del Giroscopio del ROV
float E18D80NK; // Variable para recibir los datos del sensor E18D80NK del ROV
float sensorDS18B20; // Variable para recibir los datos del sensor DS18B20 del ROV
float pressure_bar; // Variable para recibir los datos del sensor de presion interior SKU237545 en Bares del ROV
float pressure_psi; // Variable para recibir los datos del sensor de presion interior SKU237545 en PSI del ROV
float pressure_bar1; // Variable para recibir los datos del sensor de presion exterior SKU237545 en Bares del ROV
float pressure_psi1; // Variable para recibir los datos del sensor de presion interior SKU237545 en PSI del ROV
float ROVDepth; // Variable para recibir los datos de la profundidad a la que se encuentra el ROV
float ROVHDG; // Variable para recibir los datos de la direccion del ROV en grados
struct RECEIVE_DATA_STRUCTURE { // estructura de mensaje de datos recibidos de los sensores
int BattVolt; // Recibe mensaje de voltaje de batería
int t; // Recibe mensaje de temperatura interior del ROV
int t1; // Recibe mensaje de temperatura del motor derecho
int t2; // Recibe mensaje de temperatura del motor izquierdo
int ROVDepth; // Recibe mensaje de lectura de profundidad de ROV (m)
int ROVHDG; // Recibe mensaje de Dirección del ROV (grados)
int h; // Recibe mensaje de humedad del interior del ROV
int h1; // Recibe mensaje de humedad del motor derecho
int h2; // Recibe mensaje de humedad del motor izquierdo
int AccX; // Recibe mensaje de datos de inclinación del eje X
int AccY; // Recibe mensaje de datos de inclinación del eje Y
int AccZ; // Recibe mensaje de datos de inclinación del eje Z
int Temp; // Recibe mensaje de datos de temperatura del giroscopio
int GyroX; // Recibe mensaje de datos de aceleración en el eje X
int GyroY; // Recibe mensaje de datos de aceleración en el eje Y
int GyroZ; // Recibe mensaje de datos de aceleración en el eje Z
int E18D80NK; // Recibe mensaje de lectura del sensor infrarrojo E18-D80NK
int pinLedColision; // Recibe mensaje de encender alarma de colisión
int sensorDS18B20; // Recibe mensaje de lectura del sensor de temperatura DS18B20
int pressure_bar; // Recibe mensaje de lectura del sensor de presión SKU237545 en Bares
int pressure_psi; // Recibe mensaje de lectura del sensor de presión SKU237545 en PSI
int pressure_bar1; // Recibe mensaje de lectura del sensor de presión SKU237545 Interno en Bares
int pressure_psi1; // Recibe mensaje de lectura del sensor de presión SKU237545 Interno en PSI
};
struct SEND_DATA_STRUCTURE { // estructura de mensaje de datos enviados
int upLraw = 0; //Variables para transportar los datos reales sin procesar de los ESCs
int upRraw = 0;
int HLraw = 0;
int HRraw = 0;
volatile boolean PSB_PAD_UPstate; // Manda lectura del botón Izquierda arriba al Esclavo
volatile boolean PSB_PAD_DOWNstate; // Manda lectura del botón Izquierda abajo al Esclavo
volatile boolean PSB_PAD_RIGHTstate; // Manda lectura del botón Izquierda derecho al Esclavo
volatile boolean PSB_PAD_LEFTstate; // Manda lectura del botón Izquierda Izquierda al Esclavo
volatile boolean PSB_BLUEstate; // Manda lectura del botón Cruz azul al Esclavo
volatile boolean PSB_GREENstate; // Manda lectura del botón Triangulo verde al Esclavo
volatile boolean PSB_PINKstate; // Manda lectura del botón Cuadrado rosa al Esclavo
volatile boolean PSB_REDstate; // Manda lectura del botón Circulo rojo al Esclavo
volatile boolean PSB_L1state; // Manda lectura del botón Izquierda delante arriba al Esclavo
volatile boolean PSB_L2state; // Manda lectura del botón Izquierda delante abajo al Esclavo
volatile boolean PSB_L3state; // Manda lectura del botón Palo izquierdo abajo al Esclavo
volatile boolean PSB_R1state; // Manda lectura del botón Derecha delante arriba al Esclavo
volatile boolean PSB_R2state; // Manda lectura del botón Derecha delante abajo al Esclavo
volatile boolean PSB_R3state; // Manda lectura del botón Palo derecho abajo al Esclavo
volatile boolean LEDHdlts; // Manda que hacer con los Focos, encendidos/apagados
};
//dar un nombre al grupo de datos
RECEIVE_DATA_STRUCTURE rxdata;
SEND_DATA_STRUCTURE txdata;
void setup()
{
Serial.begin(9600); // Comienza la Comunicacion en Serie para hablar con el ordenador a 9600 Baudios
Serial1.begin(57600); // Comienza la comunicación Serie en el puerto 1, pines 18 y 19, para hablar con el Arduino Esclavo
Serial1.flush(); // Depura la información del Puerto Serie
ETin.begin(details(rxdata), &Serial1); // Comienza la recepción de datos a través de Serial, en los pines 18 y 19
ETout.begin(details(txdata), &Serial1); // Comienza el envío de datos a través de Serial, en los pines 18 y 19
pinMode(grnLEDpin, OUTPUT); //se establece grnLEDpin como salida
pinMode(redLEDpin, OUTPUT); //se establece redLEDpin como salida
pinMode(yelLEDpin, OUTPUT); //se establece yelLEDpin como salida
pinMode(VwarnLEDpin, OUTPUT); //se establece el pin de advertencia de batería baja como salida
pinMode(TwarnLEDpin, OUTPUT); //se establece el pin de sobre temperatura como salida
// Pines y ajustes de configuración: GamePad(clock, command, attention, data, Pressures?, Rumble?)
error = ps2x.config_gamepad(22, 23, 24, 25, true, true);
if (error == 0)
{
Serial.println("\n Controlador encontrado y configurado con exito");
// Serial.println("\n Pruebe todos los botones, X hara vibrar el mando, mas rapido a medida que que presione mas;");
// Serial.println("\n Si mantiene presionado L1 o R1 imprimirá los valores analogicos del palo");
// Serial.println("\n Valla a www.billporter.info para actualizaciones y para reportar errores.");
}
else if (error == 1)
Serial.println(" \n No se encontro el controlador, verifique el cableado, consulte readme.txt para habilitar la depuracion. Visite www.billporter.info para obtener sujerencias para la solución de problemas");
else if (error == 2)
Serial.println(" \n El controlador se encontró, pero no admite comandos. Consulte readme.txt para habilitar la depuracion. Visite www.billporter.info para obtener sujerencias para la solución de problemas");
else if (error == 3)
Serial.println(" \n El controlador se niega a ingresar en el modo de presiones, puede que no lo admita");
// Controlador DualShock
ps2x.read_gamepad(true, true);
//esto debe llamarse al menos 1 vez por segundo para obtener datos del controlador
// Serial.print(ps2x.Analog(1), HEX);
type = ps2x.readType();
switch (type)
{
case 0:
Serial.println("\n Tipo de controlador desconocido");
break;
case 1:
Serial.println(" \n Controlador DualShock Encontrado");
break;
case 2:
Serial.println(" Controlador GuitarHero encontrado");
break;
}
delay (200);
}
void loop()
{
ETin.receiveData(); // Recibe el mensaje al puerto serie para el Arduino del ROV
//lecturas analogicas del palo
ForwardVal = ps2x.Analog(PSS_RY);
YawLeftVal = ps2x.Analog(PSS_RX);
UpVal = ps2x.Analog(PSS_LY);
RollLeftVal = ps2x.Analog(PSS_LX);
//traduce las lecturas del palo al las instrucciones del servo
//las lecturas de los palos del controlador PS2 son de 0 a 255
//con el neutro en 128. las posiciones cero son
//a la izquierda para movimientos del eje X y arriba para los movimientos del eje Y
// Lectura de todos los botones del mando
// Esto sera verdad hasta que algun botón cambie de estado, (activado / desactivado)
if (ps2x.NewButtonState())
{
if (ps2x.Button(PSB_PAD_UP)) // Lee el valor del botón Izquierda arriba al Esclavo
{
PSB_PAD_UPstate = (!PSB_PAD_UPstate); // Guarda el dato en su variable
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_PAD_UPstate = (PSB_PAD_UPstate); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_PAD_DOWN)) // Lee el valor del botón Izquierda abajo al Esclavo
{
PSB_PAD_DOWNstate = (!PSB_PAD_DOWNstate);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el led amarillo
}
txdata.PSB_PAD_DOWNstate = (PSB_PAD_DOWNstate); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_PAD_RIGHT)) // Lee el valor del botón Izquierda derecho al Esclavo
{
PSB_PAD_RIGHTstate = (!PSB_PAD_RIGHTstate);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el led amarillo
}
txdata.PSB_PAD_RIGHTstate = (PSB_PAD_RIGHTstate); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_PAD_LEFT)) // Lee el valor del botón Izquierda Izquierda al Esclavo
{
PSB_PAD_LEFTstate = (!PSB_PAD_LEFTstate); // Lectura del estado del botón
txdata.LEDHdlts = !txdata.LEDHdlts; // Guarda que hacer con el estado de los focos, encendido / apagado
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
(txdata.LEDHdlts > 0); // Si el valor recibido del botón es mayor que cero
Serial.print("\n Focos apagados"); // Imprime la frase "Focos apagados"
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el led amarillo
(txdata.LEDHdlts < 0); // Si el valor recibido del boton es menor que cero
Serial.print("\n Focos encendidos"); // Imprime la frase " Focoa encendidos"
}
txdata.PSB_PAD_LEFTstate = (PSB_PAD_LEFTstate); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_BLUE)) // Lee el valor del botón Cruz azul al Esclavo
{
PSB_BLUEstate = (!PSB_BLUEstate);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_BLUEstate = (PSB_BLUEstate); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_GREEN)) // Lee el valor del botón Triangulo verde al Esclavo
{
PSB_GREENstate = (!PSB_GREENstate);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_GREENstate = (PSB_GREENstate); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_PINK)) // Lee el valor del botón Cuadrado rosa al Esclavo
{
PSB_PINKstate = (!PSB_PINKstate);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_PINKstate = (PSB_PINKstate); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_RED)) // Lee el valor del botón Circulo rojo al Esclavo
{
PSB_REDstate = (!PSB_REDstate);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_REDstate = (PSB_REDstate); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_L3)) // Lee el valor del botón Palo izquierdo abajo al Esclavo
{
PSB_L3state = (!PSB_L3state);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_L3state = (PSB_L3state); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_R1)) // Lee el valor del botón Derecha delanta arriba al Esclavo
{
PSB_R1state = (!PSB_R1state);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_R1state = (PSB_R1state); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_R2)) // Lee el valor del botón Derecha delante abajo al Esclavo
{
PSB_R2state = (!PSB_R2state);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_R2state = (PSB_R2state); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_R3)) // Lee el valor del botón Palo derecho abajo al Esclavo
{
PSB_R3state = (!PSB_R3state);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_R3state = (PSB_R3state); // Manda el estado del botón al Esclavo
}
// Esto solo será verdad, mientras este pulsado el boton
if (ps2x.Button(PSB_L1)) // Lee el valor del botón Izquierda delante arriba al Esclavo
{
PSB_L1state = (!PSB_L1state);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_L1state = (PSB_L1state); // Manda el estado del botón al Esclavo
if (ps2x.Button(PSB_L2)) // Lee el valor del botón Izquierda delante abajo al Esclavo
{
PSB_L2state = (!PSB_L2state);
digitalWrite(yelLEDpin, HIGH); // Enciende el Led Amarillo
}
else
{
digitalWrite(yelLEDpin, LOW); // Apaga el Led Amarillo
}
txdata.PSB_L2state = (PSB_L2state); // Manda el estado del botón al Esclavo
//variables para transportar los datos en bruto reales para los ESCs y servos
txdata.upLraw = (128 - UpVal) - (128 - RollLeftVal) / 2; //esto será hasta un valor de 192
txdata.upRraw = (128 - UpVal) + (128 - RollLeftVal) / 2; //esto será hasta un valor de 192
txdata.HLraw = -(128 - ForwardVal) + (128 - YawLeftVal); //esto será hasta un valor de 256
txdata.HRraw = -(128 - ForwardVal) - (128 - YawLeftVal); //esto será hasta un valor de 256
//escala los valores para que sean adecuados para los ESCs y para los Servos
//estos valores podrán escribirse directamente en los ESCs y en los Servos
txdata.upLraw = map(txdata.upLraw, -193, 193, 0, 179);
txdata.upRraw = map(txdata.upRraw, -193, 198, 0, 179);
txdata.HLraw = map(txdata.HLraw, -256, 256, 0, 179);
txdata.HRraw = map(txdata.HRraw, -256, 256, 0, 179);
if (rxdata.BattVolt < LowBatVolts10)
// el factor de 10 se incluye para coincidir con el factor 10 utilizado en el valor informado que es un int multiplicado
// Por 10 para dar una precisión de 0.1 al valor. Tiene sentido
{
digitalWrite(VwarnLEDpin, HIGH);
//si el voltaje de la batería es demasiado bajo, enciende el LED de advertencia
}
else
{
digitalWrite(VwarnLEDpin, LOW);
//de lo contrario, si el voltaje está por encima del umbral de bajo voltaje definido
//deje el LED apagado
}
ROVTMP = (rxdata.t); // Recibe los datos del Esclavo
ROVTMP1 = (rxdata.t1); // Recibe los datos del Esclavo
ROVTMP2 = (rxdata.t2); // Recibe los datos del Esclavo
//convierte el valor de datos 0-1024 en temperatura
if (ROVTMP > 50 || ROVTMP1 > 50 || ROVTMP2 > 50)
{
// Si la temperatura de cualquiera de los sensores DHT22 es demasiado alta (más de 50 grados C)
// enciende el LED de advertencia
digitalWrite(TwarnLEDpin, HIGH);
Serial.print(" \n TEMPERATURA ELEVADA !");
}
else
{
digitalWrite(TwarnLEDpin, LOW);
Serial.print(" \n Temperatura Normal");
// De lo contrario, si la temperatura interior está en un nivel aceptable
// Deje el LED apagado y deje el relé de la bomba de refrigeración apagado
}
ROVDHThumid = (rxdata.h); // Recibe los datos del Esclavo
ROVDHThumid1 = (rxdata.h1); // Recibe los datos del Esclavo
ROVDHThumid2 = (rxdata.h2); // Recibe los datos del Esclavo
if (rxdata.E18D80NK > 0) // Si la entrada del E18D80NK es baja, no hay ningún objeto
{
digitalWrite(pinLedColision, LOW); // Apague el LED si no se detecta objeto
Serial.print(" \n Todo Despejado !"); // manda imprimir al Monitor Serie la frase
}
else // por el contrario, si la entrada del E18D80NK es alta
{
digitalWrite(pinLedColision, HIGH); // encienda el LED de Peligro Colisión
Serial.print(" \n PELIGRO Obstaculo detectado !"); // manda imprimir la frase
}
ROVDepth = (rxdata.ROVDepth); // Recibe lectura de profundidad de ROV (m)
ROVHDG = (rxdata.ROVHDG); // Recibe lectura de Dirección del ROV (grados)
AccX = (rxdata.AccX); // Recibe lectura de datos de inclinación del eje X
AccY = (rxdata.AccY); // Recibe lectura de datos de inclinación del eje Y
AccZ = (rxdata.AccZ); // Recibe lectura de datos de inclinación del eje Z
Temp = (rxdata.Temp); // Recibe lectura de datos de temperatura del giroscopio
GyroX = (rxdata.GyroX); // Recibe lectura de datos de aceleración en el eje X
GyroY = (rxdata.GyroY); // Recibe lectura de datos de aceleración en el eje Y
GyroZ = (rxdata.GyroZ); // Recibe lectura de datos de aceleración en el eje Z
// pinLedColision = (rxdata.pinLedColision); // Recibe lectura de encender alarma de colisión
sensorDS18B20 = (rxdata.sensorDS18B20); // Recibe lectura de lectura del sensor de temperatura DS18B20
pressure_bar = (rxdata.pressure_bar); // Recibe lectura de lectura del sensor de presión SKU237545 en Bares
pressure_psi = (rxdata.pressure_psi); // Recibe lectura de lectura del sensor de presión SKU237545 en PSI
pressure_bar1 = (rxdata.pressure_bar1); // Recibe lectura de lectura del sensor de presión SKU237545 Interno en Bares
pressure_psi1 = (rxdata.pressure_psi1); // Recibe lectura de lectura del sensor de presión SKU237545 Interno en PSI
E18D80NK = (rxdata.E18D80NK); // Recibe estado del sensor de infrarrojos
// #if DEBUG1 // CUIDADO CON ESTO, des comentar y cambiar 1 si imprime en Monitor Serie, 0 cero no imprime
{
// A partir de aquí repito las ordenes de lcd, cambiándolas por Serial
Serial.print("\n Voltaje del ROV = ");
Serial.print(float(rxdata.BattVolt) / 10, 1);
//factor 10 utilizado para obtener precisión adicional del valor entero y luego se muestra con 1 decimal
Serial.print(" \n Temperatura del casco = ");
Serial.print(ROVTMP);
Serial.print(" *C ");
Serial.print(" \n Temperatura motor DR = ");
Serial.print(ROVTMP1);
Serial.print(" *C1 ");
Serial.print(" \n Temperatura motor IZ = ");
Serial.print(ROVTMP2);
Serial.print(" *C2 ");
Serial.print(" \n Humedad en el interior del Casco = ");
Serial.print(ROVDHThumid);
Serial.print(" %\t");
Serial.print(" \n Humedad en el motor DR = ");
Serial.print(ROVDHThumid1);
Serial.print(" %\t");
Serial.print(" \n Humedad en el motor IZ = ");
Serial.print(ROVDHThumid2);
Serial.print(" %\t");
Serial.print(" \n Inclinación del eje X del ROV = ");
Serial.print(AccX);
Serial.print(" \n Inclinación del eje Y del ROV = ");
Serial.print(AccY);
Serial.print(" \n Inclinación del eje Z del ROV = ");
Serial.print(AccZ);
Serial.print(" \n Temperatura del Giro MPU6050 = ");
Serial.print(Temp / 340.00 + 36.53);
Serial.print(" \n Aceleración en el eje X del Giro MPU6050 = ");
Serial.print(GyroX);
Serial.print(" \n Aceleración en el eje Y del Giro MPU6050 = ");
Serial.print(GyroY);
Serial.print(" \n Aceleración en el eje Z del Giro MPU6050 = ");
Serial.print(GyroZ);
Serial.print(" \n Profundidad = ");
Serial.print(ROVDepth); // muestra en el Display la profundidad del ROV en metros
Serial.print(" \n Direccion del ROV = ");
Serial.print(ROVHDG); // muestra la dirección del ROV en una brújula
Serial.print(" \n Temperatura sensor DS18B20 = ");
Serial.print(sensorDS18B20);
Serial.print(" ºC");
Serial.print(" \n Valor del Sensor de Presión Interno = ");
Serial.print(" Presión en Bar = ");
Serial.print(pressure_bar);
Serial.print(" bars");
Serial.print(" || Presión en PSI = ");
Serial.print(pressure_psi);
Serial.print(" psi");
Serial.print(" \n Valor del Sensor de Presión Externo = ");
Serial.print(" Presión en Bar = ");
Serial.print(pressure_bar1);
Serial.print(" bars");
Serial.print(" || Presión en PSI = ");
Serial.print(pressure_psi1);
Serial.print(" psi");
Serial.print("\n");
}
// #endif // des comentar cuando NO quiera imprimir los Serial.print
// Enviar el mensaje al puerto serie para el Arduino del ROV
ETout.sendData();
delay (200);
}Code: Select all
/*
Modificado por asesorplaza1 en las diferentes fechas indicadas
Las primeras pruebas y cambios del código, se iniciaron en 2.016, debido a la cantidad de modificaciones
A partir de ahora 30/01/2020, se ponen las fechas y los cambios en la descripción del proyecto
Para facilitar la búsqueda de errores en los diferentes cambios del código
30/01/2020 ya se han comentado todas las líneas de control de la cámara y del LCD
Le añado 2 DHT22 y así estarán los 3 que me hacen falta
He borrado varias líneas de control de la cámara que no se va a utilizar
01/02/2020 le añado los controles del giroscopio facilitados por Dea de www.cambatronics.com
02/02/2020 le añado la orden para leer solo 1 vez X segundo el DHT22, truco de Jose Luis de
www.cambatronics.com
y se borran las líneas correspondientes al control de la cámara de video
no utilizadas por asesorplaza1, en esta modificación del proyecto original
04/02/2020 modifico las líneas de lectura de los sensores, porque hasta ahora solo me imprime en Monitor Serie el texto, no los datos
06/02/2020 se depura un poco el código, y se modifica el encabezado del código
08/02/2020 se corrige el error de lectura en los sensores, y se corrige la escritura del Monitor Serie
12/02/2020 para poder añadir cualquier código hay que seguir unas reglas especificas de programación
Se modifica la estructura del código siguiendo esas órdenes de programación, según la información obtenida y guardada
En la carpeta 01_UNIR_2_CODIGOS
Se crean varios bloques en el void loop, para el funcionamiento de cada uno de los sensores, eliminando los delay()
13/02/2020 se incluye el sensor de temperatura DS18B20, ayudado por DEA de www.cambatronics.com
16/02/2020 Se añade el sensor de distancia infrarrojo E18-D80NK, sin errores
y consigo adaptar un código para leer el sensor de presión SKU237545
08/03/2020 se conecta un relé en el pin 12 del Arduino Esclavo, para encender los focos de luz externos, no hace falta cambiar el código
26/03/2020 Se incluye la librería MPU6050, para controlar el giroscopio
Se arregla el envió de datos, separando los datos del Monitor Serie, y los datos que hay que enviar al Arduino Maestro,
iniciando dos puertos serie con las ordenes
Serial.begin(57600); // Puerto Serie USB ***
Serial1.begin(57600); // Puerto Serie en los pines 18 y 19 ***
ETin.begin(details(rxdata), &Serial1); // Comienza la recepcion de datos a través de Serial, en los pines 18 y 19 ***
ETout.begin(details(txdata), &Serial1); // Comienza el envío de datos a través de Serial, en los pines 18 y 19 ***
28/03/2020 Se incluyen el envió de todas las instrucciones del mando, para tener todos los botones operativos (no funciona)
03/04/2020 Se incluye la parte nueva del Giroscopio MPU6050, que muestra los 3 ejes de inclinación, más la temperatura del Giroscopio.
Se incluye el segundo sensor de presión
05/04/2020 se cambia el código del sensor infrarrojo E18D80NK, por uno mejor
11/04/2020 Corrijo el código según las instrucciones de mi amigo Atilano Belinchón
13/04/2020 Corrijo las lecturas y envió de datos del sensor de infrarrojos E18D80NK
15/04/2020 Se incluye el servo de dirección para accionarlo con los botones R1 y R2 del mando
segun informacion obtenida de la pagina
https://arduparatodos.blogspot.com/2017/02/controlar-servomotor-con-arduino-varios.html
18/04/2020 Se cambian algunos " if ", por " else if ", para darle agilidad al código, siguiendo las instrucciones de DEA de www.cambatronics.com
Entre el día 24/03/2020 y el día 28/04/2020, se hacen varios cambios en el código para mejorarlo y conseguir que el mando funcione,
siguiendo las instrucciones de bigbadbob en las publicaciones del foro
http://www.homebuiltrovs.com/rovforum/viewtopic.php?f=18&t=1908
A partir de la página 4
28/04/2020 Se corrige la ortografia de todo le texto que no son órdenes
03/05/2020 Secambian las asignaciones de los pines, segun el codigo de Github
Las nuevas asignaciones de pines son:
Salida de 3.3V a PIN rojo PS2
Pin 24 a PIN amarillo PS2 + resistencia 1k
Pin 23 a PIN naranja PS2
Pin 25 a PIN marrón PS2 + resistencia 1k
Pin 22 a PIN azul PS2
se arregla el codigo para que me salga enel Maestro el estado de los focos, encendidos / apagados
La versión original tomada como punto de partida es la siguiente
ROVPS2Control_Slavev8.ino
Hamish Trolove - 30 de marzo de 2016
www.techmonkeybusiness.com
Este boceto toma los comandos que se le envían desde la unidad maestra con el controlador PS2 conectado y lo convierte en comandos de motor,
Servo comandos, controles de luz, etc. Los datos se envían desde el Arduino (maestro) al ROV (esclavo) utilizando la biblioteca EasyTransfer de Bill Porter a través de un enlace en serie de 9600 baudios (anclaje de 100 m). La biblioteca MS5803_14 es de Luke Miller http://github.com/millerlp
Los datos enviados desde el maestro son configuraciones sin formato para el control ESC.
Este boceto está diseñado para un Arduino Nano con un solo puerto serie.
Yo lo estoy usando en un Mega 2560, y funciona
Las asignaciones de pin son;
D13 = pin LED ROJO.
D12 = Control de faros
D11 = Pasador de puente
D8 = ESC Vertical Izquierda
D7 = ESC Vertical Derecha
D6 = ESC Horizontal Izquierda
D5 = ESC Horizontal Derecha
D4 = Servo de paso de cámara (anulado en el código de asesorplaza1)
D3 = Disparador de video (anulado en el código de asesorplaza1)
D2 = Disparador de foto (anulado en el código de asesorplaza1)
Para la transmisión del video asesorplaza1 utilizara una Raspberry Pi 3 plus, una cámara USB, y el programa VCL Media Player
A7 = Conexión del divisor de voltaje
A6 = Pin de salida del sensor de temperatura TMP36 (se cambia este sensor por obsoleto, se usan los sensores DHT22)
Pines GND del bus i2c en los sensores MS5803-14BA y BMP180 a pines Nano GND Pines Vcc en los sensores MS5803-14BA y BMP180 a pines Nano 3.3V pines
SDA en los sensores MS5803-14BA y BMP180 a pines Nano A4 pines SCL en MS5803-14BA y BMP180 sensores para pin Nano A5
Se cambian estos sensores por obsoletos, se usan los sensores DHT22 y el giroscopio MPU6050
5V = Suministro al sensor de temperatura TMP36. (Se cambia este sensor por obsoleto, se usan los sensores DHT22)
Conexión serial de comunicaciones: modificado por Asesorplaza1, el 26/03/2020, para separar los datos mandados entre Arduinos, de los datos a mandar al Monitor serie
19 superior (TX) a ROV 18 (RX) Conexión serial: 18 superior (RX) a ROV 19 (TX)
Conecte el GND en ambos
Tenga en cuenta que los ESC ya se habrán programado en este punto del proyecto.
Los datos de voltaje interno, rumbo, profundidad y temperatura interna se envían a través del enlace serie de regreso al maestro
Para su visualización en una pantalla LCD de 16x2.
La pantalla LCD de 16x2, se cambiara por una pantalla Nextion básica de 5"
El encabezado es de una brújula digital HMC5883L (dirección i2c 0x1E)
Y la profundidad de un sensor de alta presión MS5803-14BA (dirección i2c 0x76)
(Se cambia este sensor por obsoleto, se usa el giroscopio MPU 6050)
Ver también como se desarrolla el proyecto original con los siguientes códigos:
HoryzonTrigger.ino, ROVPS2Control_Masterv0.ino,
ROVDoNothing.ino, ROVSubBv0.ino, DigitalCompassv2.ino,
PTLoggerv4.ino y TMP36_Temperature_Sensor.ino.
En la página www.techmonkeybusiness.com
*/
// Se ponen todas las librerías juntas
#include <Servo.h> // librería para gestionar los servos y los ESC
#include <EasyTransfer.h> // librería Easy Transfer de Bill Porter
#include <Adafruit_Sensor.h> // librería para gestionar el sensor de temperatura DHT22
#include <DHT.h> // librería para el sensor DHT 22
#include <OneWire.h> // librería para el sensor de temperatura DS18B20
#include <DallasTemperature.h> // Librería para el sensor de temperatura DS18B20
#include <MPU6050.h> // librería i2c para el Giroscopio ***
#include <PS2X_lib.h> // Librería para el mando PS2
#include <ESC.h> // Librería para los ESC
PS2X ps2x; // Genera un objeto llamado ps2x
EasyTransfer ETin, ETout; // Genera los dos objetos de transferencia fácil para Comunicación bidireccional
const int pinDatosDQ = 28; // Pin donde se conecta el bus 1-Wire para los sensores de temperatura
OneWire oneWireObjeto(pinDatosDQ); // Instancia a las clases OneWire y DallasTemperature
DallasTemperature sensorDS18B20(&oneWireObjeto); // Instancia a las clases OneWire y DallasTemperature
// Se pone toda la identificación de los DHT22 junta
DHT dht(22, DHT22); // Seleccionamos el pin y tipo de sensor del casco
DHT dht1(24, DHT22); // Seleccionamos el pin y tipo de sensor del motor derecho
DHT dht2(26, DHT22); // Seleccionamos el pin y tipo de sensor del motor izquierdo
// Se pone toda la identificación de los ESC y los Servos junta
ESC ESCVL(8, 1000, 2000, 500); // Genera objeto ESC vertical izquierdo en el pin 8, con el minimo en 1000, maximo en 2000, y armado en 500
ESC ESCVR(7, 1000, 2000, 500); // Genera objeto ESC vertical derecho en el pin 7, con el minimo en 1000, maximo en 2000, y armado en 500
ESC ESCHL(6, 1000, 2000, 500); // Genera Objeto ESC Horizontal Izquierdo en el pin 6, con el minimo en 1000, maximo en 2000, y armado en 500
ESC ESCHR(5, 1000, 2000, 500); // Genera objeto ESC Horizontal Derecho, en el pin 5, con el minimo en 1000, maximo en 2000, y armado en 500
Servo ServoInmersion; // Genera un objeto llamado ServoDireccion
int angulo = 90; // Variable para el ángulo, inicia en 90º
// Se pone toda la identificación de los LED indicadores de batería junta
const int RedLEDpin = 13; // El pin del indicador LED es 13.
const int HeadLts = 34; // El control de los faros está en el pin 34
const int Voltpin = A7; // pin analógico utilizado para leer el voltaje de la batería
const int yelLEDpin = 38; // Pin utilizado como chivato de recibir datos del mando
// Se pone toda la identificación del sistema de refrigeración junta
const int Refrigeracion = 34; // el pin utilizado para encender la bomba de refrigeración es el 34
const int TwarnLEDpin = 36; // El pin utilizado para el LED de alarma de temperatura es el 36
// Se pone toda la identificación del MPU6050 junta
const int MPU6050_addr = 0x68; // Direction I2C del MPU6050 ****
int16_t AccX, AccY, AccZ, Temp, GyroX, GyroY, GyroZ;
// Se pone toda la parte de lectura de la batería junta
int volts; // variable para leer el voltaje del pin analógico
const float RefVolts = 5.0; // Voltaje de referencia de la placa de 5 voltios en Nano
const float ResistFactor = 319.68; // Calculado a partir de 1023.0 * (R2 / (R1 + R2)
// Donde R1 = 2200 ohmios y R2 = 1000 ohmios para un voltaje máximo de 15 V.
// Se pone toda la parte del sensor E18D80NK
int pinSensorE18D80NK = 30; // Se genera el sensor E18D80NK en el pin 30
int pinLedColision = 31; // Se genera el LED de aviso de peligro colisión en el pin 31
boolean objectDetect = false; // Marca para mostrar si se ha detectado un objeto
// Se generan todos los botones del mando
boolean PSB_PAD_UPstate = false; // Genera el botón Izquierda arriba al Esclavo
boolean PSB_PAD_DOWNstate = false; // Genera el botón Izquierda abajo al Esclavo
boolean PSB_PAD_LEFTstate = false; // El botón Izquierda izquierdo ya esta usado para encender los focos
boolean PSB_PAD_RIGHTstate = false; // Genera el botón Izquierda derecho al Esclavo
boolean PSB_BLUEstate = false; // Genera el botón Cruz azul al Esclavo
boolean PSB_GREENstate = false; // Genera el botón Triangulo verde al Esclavo
boolean PSB_PINKstate = false; // Genera el botón Cuadrado rosa al Esclavo
boolean PSB_REDstate = false; // Genera el botón Circulo rojo al Esclavo
boolean PSB_L1state = false; // Genera el botón Izquierda delante arriba al Esclavo
boolean PSB_L2state = false; // Genera el botón Izquierda delante abajo al Esclavo
boolean PSB_L3state = false; // Genera el botón Palo izquierdo abajo al Esclavo
boolean PSB_R1state = false; // Genera el botón Derecha delante arriba al Esclavo
boolean PSB_R2state = false; // Genera el botón Derecha delante abajo al Esclavo
boolean PSB_R3state = false; // Genera el botón Palo derecho abajo al Esclavo
// Se genera un pin de entrada de datos para el sensor de presión SKU237545
int SensorSKU237545_I = 32; // Sensor de presión Interno
int SensorSKU237545_E = 33; // Sensor de presión Externo
int intervalodatos = 1000; // Hace que solo se envíen los valores 1 vez por segundo
// int auxMillis = 0; // Indica el valor del intervalo de tiempo
// Se pone toda la estructura de recepción de datos junta
struct RECEIVE_DATA_STRUCTURE {
int upLraw = 0; // Variables para transportar los datos sin procesar reales de los ESC
int upRraw = 0;
int HLraw = 0;
int HRraw = 0;
volatile boolean PSB_PAD_UPstate; // Recibe lectura del botón Izquierda arriba del Maestro
volatile boolean PSB_PAD_DOWNstate; // Recibe lectura del botón Izquierda abajo del Maestro
volatile boolean PSB_PAD_RIGHTstate; // Recibe lectura del botón Izquierda derecha del Maestro
volatile boolean PSB_PAD_LEFTstate; // Recibe lectura del botón Izquierda Izquierda del Maestro
volatile boolean PSB_BLUEstate; // Recibe lectura del botón Cruz azul del Maestro
volatile boolean PSB_GREENstate; // Recibe lectura del botón Triangulo verde del Maestro
volatile boolean PSB_PINKstate; // Recibe lectura del botón Cuadrado rosa del Maestro
volatile boolean PSB_REDstate; // Recibe lectura del botón Circulo rojo del Maestro
volatile boolean PSB_L1state; // Recibe lectura del botón Delante izquierda arriba del Maestro
volatile boolean PSB_L2state; // Recibe lectura del botón Delante izquierda abajo del Maestro
volatile boolean PSB_L3state; // Recibe lectura de presión Palo izquierda del Maestro
volatile boolean PSB_R1state; // Recibe lectura del botón Delante derecha arriba del Maestro
volatile boolean PSB_R2state; // Recibe lectura del botón Delante derecha abajo del Maestro
volatile boolean PSB_R3state; // Recibe lectura de presión Palo izquierdo del Maestro
volatile boolean LEDHdlts; // Luces LED encendidas / apagadas
};
// Se pone toda la identificación del envío de datos junta
struct SEND_DATA_STRUCTURE {
int BattVolt; // Manda mensaje de datos de voltaje de batería al maestro.
int t; // Manda mensaje de datos de temperatura interior del ROV al Maestro
int t1; // Manda mensaje de datos de temperatura del motor derecho al Maestro
int t2; // Manda mensaje de datos de temperatura del motor izquierdo al Maestro
int ROVDepth; // Manda mensaje de datos de lectura de profundidad de ROV (m)
int ROVHDG; // Manda mensaje de Dirección del ROV (grados)
int h; // Manda mensaje de humedad al Maestro
int h1; // Manda mensaje de humedad al Maestro del motor derecho
int h2; // Manda mensaje de humedad al Maestro del motor izquierdo
int AccX; // Manda mensaje de datos de inclinación del eje X al Maestro
int AccY; // Manda mensaje de datos de inclinación del eje Y al Maestro
int AccZ; // Manda mensaje de datos de de inclinación del eje Z al Maestro
int Temp; // Manda mensaje de datos de temperatura del giroscopio al Maestro
int GyroX; // Manda mensaje de datos de aceleracíon en el eje X al Maestro
int GyroY; // Manda mensaje de datos de aceleración en el eje Y al Maestro
int GyroZ; // Manda mensaje de datos de aceleracion en el eje Z al Maestro
int E18D80NK; // Manda mensaje de lectura del sensor infrarrojo E18-D80NK
int pinLedColision; // Manda mensaje de encender alarma de colisión
int sensorDS18B20; // Manda mensaje de lectura del sensor de temperatura DS18B20
int pressure_bar; // Manda mensaje de lectura del sensor de presión SKU237545 Interno en Bares
int pressure_psi; // Manda mensaje de lectura del sensor de presión SKU237545 Interno en PSI
int pressure_bar1; // Manda mensaje de lectura del sensor de presión SKU237545 Interno en Bares
int pressure_psi1; // Manda mensaje de lectura del sensor de presión SKU237545 Interno en PSI
};
RECEIVE_DATA_STRUCTURE rxdata; // Dar un nombre al grupo de datos recibidos
SEND_DATA_STRUCTURE txdata; // Dar un nombre al grupo de datos enviados
void setup()
{
// Se pone todo lo referente a la comunicación junta
Wire.begin (); // Comienza la comunicación i2c
Serial.begin(9600); // Comienza la Comunicacion Serie para hablar con el ordenador a 9600 baudios
Serial1.begin(57600); // Comienza la Comunicación Serie en el puerto 1, pines 18 y 19, para hablar con el Arduino Maestro
Serial1.flush(); // Depura la información del Puerto Serie
ETin.begin(details(rxdata), & Serial1); // Comienza la recepción de datos a través de Serial, en los pines 18 y 19
ETout.begin(details(txdata), & Serial1); // Comienza el envío de datos a través de Serial, en los pines 18 y 19
sensorDS18B20.begin(); // Comienza el trabajo del sensor DS18B20
// Se define el inicio del LED y de los Focos
pinMode(RedLEDpin, OUTPUT);
pinMode(HeadLts, OUTPUT);
digitalWrite(HeadLts, LOW); // Establezca los faros en Off
digitalWrite(RedLEDpin, LOW);
// Se inician los ESC y se define en que pin actúa cada uno
ESCVL.arm(); // Inicia el ESCVL
ESCVR.arm(); // Inicia el ESCVR
ESCHL.arm(); // Inicia el ESCHL
ESCHR.arm(); // Inicia el ESCHR
// Esto hay que comprobarlo
// Debido a problemas con el ESC que reconoce el máximo posición en la configuración predeterminada, las cifras después de
// El número de pin son las señales de microsegundos para el mínimo y máximo que el ESC reconocerá, 600 y 2250 trabajo.
ServoInmersion.attach(4); // Adjunte el servo de dirección al pin 4 ***
ServoInmersion.write(90); // Posiciona el servo inicialmente en la mitad (90°)
// Se inician y se manda a imprimir la prueba de funcionamiento de los sensores DHT22
dht.begin(); // Inicia el trabajo del sensor DHT22 del casco
Serial.println(" \n Probando sensor DHT22 casco!");
dht1.begin(); // Inicia el trabajo del sensor DHT22 del motor derecho
Serial.println(" \n Probando sensor DHT22 motor DR!");
dht2.begin(); // Inicia el trabajo del sensor DHT22 del motor izquierdo
Serial.println(" \n Probando sensor DHT22 motor IZ!");
// Se inician los pines del sensor y de la alarma
pinMode(pinSensorE18D80NK, INPUT_PULLUP); // Definir pin como sensor de entrada
pinMode(pinLedColision, OUTPUT); // Definir pin como SALIDA para ACTION
// Se inicia el pin del sensor de presión SKU237545 Interno
pinMode (SensorSKU237545_I, INPUT);
// Se inicia el pin del sensor de presión SKU237545 Externo
pinMode (SensorSKU237545_E, INPUT);
// Proceso para iniciar el giroscopio MPU6050
Wire.begin();
Wire.beginTransmission(MPU6050_addr);
Wire.write(0x6B);
Wire.write(0);
Wire.endTransmission(true);
delay (200);
}
void loop ()
{
while (!ETin.receiveData()) // Recibe los datos al puerto serie para el ROV
{
Serial.print("\n Datos recibidos del Meastro..");
return;
}
loop_ESC(); // Bloque de trabajo de los ESC de los motores
loop_Luces(); // Bloque de trabajo de los focos
loop_Voltaje(); // Bloque de trabajo para medir el voltaje de la batería
loop_DHT22(); // Bloque de trabajo de los sensores de temperatura y humedad DHT22
loop_MPU6050(); // Bloque de trabajo del Giroscopio
loop_SensorE18D80NK(); // Bloque de trabajo del sensor de infrarrojos
loop_DS18B20(); // Bloque de trabajo del sensor de temperatura DS18B20
loop_SKU237545_I(); // Bloque de trabajo del sensor de presión interno
loop_SKU237545_E(); // Bloque de trabajo del sensor de presión externo
loop_ServoInmersion(); // Bloque de trabajo del servo
PSB_PAD_UPstate = (rxdata.PSB_PAD_UPstate); // Recibe lectura del botón Izquierda arriba al Esclavo
PSB_PAD_DOWNstate = (rxdata.PSB_PAD_DOWNstate); // Recibe lectura del botón Izquierda abajo al Esclavo
PSB_PAD_LEFTstate = (rxdata.PSB_PAD_LEFTstate); // Recibe lectura del botón Izquierda Izquierda al Esclavo
PSB_PAD_RIGHTstate = (rxdata.PSB_PAD_RIGHTstate); // Recibe lectura del botón Izquierda derecho al Esclavo
PSB_BLUEstate = (rxdata.PSB_BLUEstate); // Recibe lectura del botón Cruz azul al Esclavo
PSB_GREENstate = (rxdata.PSB_GREENstate); // Recibe lectura del botón Triangulo verde al Esclavo
PSB_PINKstate = (rxdata.PSB_PINKstate); // Recibe lectura del botón Cuadrado rosa al Esclavo
PSB_REDstate = (rxdata.PSB_REDstate); // Recibe lectura del botón Circulo rojo al Esclavo
PSB_L1state = (rxdata.PSB_L1state); // Recibe lectura del botón Izquierda delante arriba al Esclavo
PSB_L2state = (rxdata.PSB_L2state); // Recibe lectura del botón Izquierda delante abajo al Esclavo
PSB_L3state = (rxdata.PSB_L3state); // Recibe lectura del botón Palo izquierdo abajo al Esclavo
PSB_R1state = (rxdata.PSB_R1state); // Recibe lectura del botón Derecha delante arriba al Esclavo
PSB_R2state = (rxdata.PSB_R2state); // Recibe lectura del botón Derecha delante abajo al Esclavo
PSB_R3state = (rxdata.PSB_R3state); // Recibe lectura del botón Palo derecho abajo al Esclavo
// No me deja generar un bloque de trabajo para los botones del mando
// Por eso los pongo dentro del void loop genérico
if (rxdata.PSB_PAD_UPstate)
// Si presionamos el botón izquierda arriba
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_PAD_DOWNstate)
// Si presionamos el botón izquierda abajo
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_PAD_RIGHTstate)
// Si presionamos el botón izquierda derecha
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_GREENstate)
// Si presionamos triangulo verde
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_REDstate)
// Si presionamos el círculo rojo
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_BLUEstate)
// Si presionamos el cruz azul
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_PINKstate)
// Si presionamos el cuadrado rosa
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_L1state)
// Si presionamos el botón L1
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_L2state)
// Si presionamos el botón L2
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_R1state)
// Si presionamos el botón R1
{
// enciende / apaga las luces
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_R2state)
// Si presionamos el botón R2
{
// enciende / apaga las luces
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_L3state)
// Si presionamos el joystick izquierdo hacia abajo
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el Led Amarillo
}
if (rxdata.PSB_R3state)
// Si presionamos el joystick derecho hacia abajo
{
digitalWrite(yelLEDpin, HIGH);
// Enciende el LED Amarillo
}
}
void loop_ESC() { // Bloque de trabajo de los ESC de los motores
// Haremos algo correctamente con los datos devueltos en un
ESCVL.speed(rxdata.upLraw); // Establezca la señal ESCVL en la posición del acelerador definida.
ESCVR.speed(rxdata.upRraw); // Establezca la señal ESCVR en la posición del acelerador definida.
ESCHL.speed(rxdata.HLraw); // Establezca la señal ESCHL en la posición del acelerador definida.
ESCHR.speed(rxdata.HRraw); // Establezca la señal ESCHR en la posición del acelerador definida.
}
void loop_ServoInmersion() { // Bloque de trabajo del Servo de Inmersión
if (rxdata.PSB_R1state == LOW)
// Aumenta el ángulo mientras se mantenga presionado
{
angulo++;
if (angulo >= 180)
{
angulo = 180;
// El ángulo no aumenta mas allá de 180 grados
Serial.print (" \n Subiendo ROV a superficie ");
}
}
else if (rxdata.PSB_R2state == LOW)
// Disminuye el ángulo mientras se mantenga presionado
{
angulo--;
if (angulo <= 0)
{
angulo = 0;
// El ángulo no disminuye mas allá de 0 grados
Serial.print ("\n Inmersion ROV a profundidad ");
}
}
ServoInmersion.write(angulo);
// Manda el ángulo al servo dependiendo del pulsador presionado
// delay(10);
}
void loop_Luces() { // Bloque de trabajo de los focos
digitalWrite(HeadLts, rxdata.LEDHdlts);
// Enciende los faros en función del retraso de los datos del mensaje
if (rxdata.LEDHdlts > 0) {
Serial.print(" \n Focos apagados ");
}
else {
(rxdata.LEDHdlts < 0);
Serial.print(" \n Focos encendidos ");
}
}
void loop_Voltaje() { // Bloque de trabajo de medición de voltaje de la batería
volts = analogRead(Voltpin) / ResistFactor * RefVolts * 10; // Lee el voltaje
// De la batería a través del divisor de voltaje. Factor de 10 utilizado
// Para ayudar a lograr un número entero con una precisión de 0.1V.
// Factor 10 utilizado para obtener precisión adicional del valor entero y luego se muestra con 1 decimal
txdata.BattVolt = volts; // Enviar de vuelta el voltaje de la batería a bordo.
Serial.print(" \n Voltaje del ROV = ");
Serial.print(volts);
}
void loop_DHT22() { // Bloque de trabajo de los sensores DHT22
float h = dht.readHumidity();
// Lectura de Humedad desde el sensor DHT22 del interior del ROV
float t = dht.readTemperature();
// Lectura de Temperatura desde el sensor DHT22 del interior del ROV
float h1 = dht1.readHumidity();
// Lectura de Humedad desde el sensor DHT22 del motor derecho
float t1 = dht1.readTemperature();
// Lectura de Temperatura desde el sensor DHT22 del motor derecho
float h2 = dht2.readHumidity();
// Lectura de Humedad desde el sensor DHT22 del motor izquierdo
float t2 = dht2.readTemperature();
// Lectura de Temperatura desde el sensor DHT22 del motor izquierdo
int intervaloMedidas = 1000;
// Hace que solo se lean los valores 1 vez por segundo
unsigned long auxMillis = 0;
// Indica el valor del intervalo de tiempo
// Comprueba si hay fallo en todas las lecturas y sale rápido y prueba otra vez
if (isnan(h) || isnan(t)) {
Serial.print(" \n Fallo de lectura desde el sensor DHT del Casco!");
return;
}
else if (isnan(h1) || isnan(t1)) {
Serial.print(" \n Fallo de lectura desde el sensor DHT del motor DR!");
return;
}
else if (isnan(h2) || isnan(t2)) {
Serial.print(" \n Fallo de lectura desde el sensor DHT del motor IZ!");
return;
}
else if (( millis() - auxMillis) > intervaloMedidas) {
txdata.t = t; // Envía al Maestro la temperatura leída en el casco
txdata.h = h; // Envía al Maestro la humedad leída en el casco
txdata.t1 = t1; // Envía al Maestro la temperatura leída en el motor derecho
txdata.h1 = h1; // Envía al Maestro la humedad leída en el motor derecho
txdata.t2 = t2; // Envía al Maestro la temperatura leída en el motor izquierdo
txdata.h2 = h2; // Envía al Maestro la humedad leída en el motor izquierdo
auxMillis = millis();
}
else if (t > 40 || t1 > 40 || t2 > 40)
{
// Si la temperatura de cualquiera de los sensores DHT22 es demasiado alta (más de 40 grados C)
// Enciende el LED de advertencia
digitalWrite(TwarnLEDpin, HIGH);
// Enciende la bomba de refrigeración
digitalWrite(Refrigeracion, HIGH);
// Escribe el texto
Serial.print(" \n TEMPERATURA ELEVADA !");
}
Serial.print(" \n Temperatura en el casco = ");
Serial.print(t);
Serial.print(" *C ");
Serial.print(" \n Temperatura en el motor DR = ");
Serial.print(t1);
Serial.print(" *C1 ");
Serial.print(" \n Temperatura en el motor IZ = ");
Serial.print(t2);
Serial.print(" *C2 ");
Serial.print(" \n Humedad en el Casco = ");
Serial.print(h);
Serial.print(" %\t");
Serial.print(" \n Humedad en el motor DR = ");
Serial.print(h1);
Serial.print(" %\t");
Serial.print(" \n Humedad en el motor IZ = ");
Serial.print(h2);
Serial.print(" %\t");
}
void loop_MPU6050() { // Bloque de trabajo del giroscopio ***
Wire.beginTransmission(MPU6050_addr);
Wire.write(0x3B);
Wire.endTransmission(false);
Wire.requestFrom(MPU6050_addr, 14, true);
AccX = Wire.read() << 8 | Wire.read();
AccY = Wire.read() << 8 | Wire.read();
AccZ = Wire.read() << 8 | Wire.read();
Temp = Wire.read() << 8 | Wire.read();
GyroX = Wire.read() << 8 | Wire.read();
GyroY = Wire.read() << 8 | Wire.read();
GyroZ = Wire.read() << 8 | Wire.read();
txdata.AccX = AccX;
txdata.AccY = AccY;
txdata.AccZ = AccZ;
txdata.Temp = Temp;
txdata.GyroX = GyroX;
txdata.GyroY = GyroY;
txdata.GyroZ = GyroZ;
Serial.print(" \n Inclinación del eje X del ROV = ");
Serial.print(AccX);
Serial.print(" \n Inclinación del eje Y del ROV = ");
Serial.print(AccY);
Serial.print(" \n Inclinación del eje Z del ROV = ");
Serial.print(AccZ);
Serial.print(" \n Temperatura del Giro MPU6050 = ");
Serial.print(Temp / 340.00 + 36.53);
Serial.print(" \n Aceleración del Giro MPU6050 = ");
Serial.print(GyroX);
Serial.print(" \n Aceleración del Giro MPU6050 = ");
Serial.print(GyroY);
Serial.print(" \n Aceleración del Giro MPU6050 = ");
Serial.print(GyroZ);
// Serial.print(" \n Dirección del ROV = ");
// Serial.print(rxdata.ROVHDG); // muestra la dirección del ROV en una brújula
Wire.endTransmission(MPU6050_addr); // ***
}
void loop_SensorE18D80NK() { // Bloque de trabajo del sensor infrarrojo
int E18D80NK = digitalRead(pinSensorE18D80NK); // leer el Sensor
if (E18D80NK > 0) {
Serial.println(" \n Todo despejado");
digitalWrite(pinLedColision, LOW); // encender el LED de peligro
}
else {
Serial.println(" \n Peligro Objeto detectado");
digitalWrite(pinLedColision, HIGH); // Apagar el LED de peligro
}
txdata.E18D80NK = E18D80NK;
}
void loop_DS18B20() { // Bloque de trabajo del sensor de temperatura DS18B20
sensorDS18B20.requestTemperatures();
Serial.print("\n Temperatura sensor DS18B20 = ");
Serial.print(sensorDS18B20.getTempCByIndex(0));
Serial.print(" ºC");
txdata.sensorDS18B20 = sensorDS18B20.getTempCByIndex(0);
}
void loop_SKU237545_I() { // Bloque de trabajo del sensor de presión interno
SensorSKU237545_I = analogRead(32);
float voltage = (SensorSKU237545_I * 5.0) / 1024.0;
float pressure_pascal = (3.0 * ((float)voltage - 0.475)) * 1000000.0; //calibrar aquí
float pressure_bar = pressure_pascal / 10e5;
float pressure_psi = pressure_bar * 14.5038;
Serial.print(" \n Valor del Sensor de Presión Interno = ");
Serial.print(SensorSKU237545_I);
Serial.print(" \n Presión en Bar = ");
Serial.print(pressure_bar);
Serial.print(" bars");
Serial.print(" \n Presión en PSI = ");
Serial.print(pressure_psi);
Serial.print(" psi");
txdata.pressure_bar = pressure_bar;
txdata.pressure_psi = pressure_psi;
}
void loop_SKU237545_E() { // bloque de trabajo del sensor de presión externo
SensorSKU237545_E = analogRead(32);
float voltage1 = (SensorSKU237545_E * 5.0) / 1024.0;
float pressure_pascal1 = (3.0 * ((float)voltage1 - 0.475)) * 1000000.0; //calibrar aquí
float pressure_bar1 = pressure_pascal1 / 10e5;
float pressure_psi1 = pressure_bar1 * 14.5038;
Serial.print(" \n Valor del Sensor de Presión Externo = ");
Serial.print(SensorSKU237545_E);
Serial.print(" Presión en Bar = ");
Serial.print(pressure_bar1);
Serial.print(" bars");
Serial.print(" \n Presión en PSI = ");
Serial.print(pressure_psi1);
Serial.print(" psi");
Serial.print(" \n Profundidad = ");
txdata.pressure_bar1 = pressure_bar1;
txdata.pressure_psi1 = pressure_psi1;
// Serial.print(rxdata.ROVDepth);
// Muestra en el Display la profundidad del ROV en metros
ETout.sendData (); // Envía los datos al puerto serie para el ROV Arduino
delay (200);
}
Code: Select all
Sketch uses 11990 bytes (4%) of the program storage space. The maximum is 253952 bytes.
Global variables use 2148 bytes (26%) dynamic memory, leaving 6044 bytes for local variables. The maximum is 8192 bytes.
Code: Select all
Sketch uses 15750 bytes (6%) of the program storage space. The maximum is 253952 bytes.
Global variables use 2084 bytes (25%) dynamic memory, leaving 6108 bytes for local variables. The maximum is 8192 bytes.
