|     Inicio    |   |         |  |   FOROS      |  |      |      
   Elastix - VoIP B4A (Basic4Android) App inventor 2 PHP - MySQL
  Estación meteorológica B4J (Basic4Java) ADB Shell - Android Arduino
  AutoIt (Programación) Visual Basic Script (VBS) FireBase (BD autoactualizable) NodeMCU como Arduino
  Teleco - Emisora de A.M. Visual Basic Cosas de Windows Webs interesantes
T Búsqueda en este sitio:


.

Arduino en español
Circuitos con Arduino - Juan Antonio Villalpando

-- Tutorial de iniciación a Arduino --

Volver al índice del tutorial

____________________________

49BL.- Teclado 4x4, bus I2C. Pantalla LCD. Sensor de humedad y temperatura. Infrarojo. RadioFrecuencia. Reloj. Lluvia. I2C. INT. ArduinoI2C-Humo. LDR-PWM. Motores y Bluetooth.

- Nuestro proyecto va así:

- Teclado 4x4 con módulo I2C.
- Pantalla LCD.
- Sensor de Temperatura y Humedad.
- Infrarojo.
- Radio Frecuencia. Emisor y Receptor.
- Sensor de ultrasonido.
- Sensor de lluvia.
- Módulo I2C con sensores de inclinación, magnetismo y movimiento.
- Sensor de efecto Hall con interrupción.
- Sensor de Humo con envío de información mediante I2C
- LDR para PWM.
- Ahora le pondremos Bluetooth, motores y Android.

 

- Vamos a añadir a nuestro proyecto un motorcito de continua para poderlo hacer funcionar desde un teléfono móvil con Android y Bluetooth.

- Esto ya lo vimos en el tutorial: 29C.- Motor de continua. y el proyecto Cochecito.

- El menú del teclado sigue siendo el mismo:

_______________________
- Teclados y LED.

'A' - 'B' Modifica la temperatura máxima para encender el LED13 LED13
'B' Visualiza la Humedad en LCD. LED13
'C' Visualiza la Temperatura en LCD. LED13
'#' Fin de entrada de datos para la opción 'A'  
Mando de infrarojo Teclas '1' y '2' del mando de infrarojo. LED7
'D' Distancia ultrasonido por Radio Frecuencia en LCD.  
PulsadorA
PulsadorB
  LED5
LED6
'*' Visualiza la hora en LCD.  
'A' - 'C' Modifica la lluvia máxima para encender el LED4 LED4
'0' Visualiza la lluvia en LCD.  
  Sensor de inclinación, el magnético o el de movimiento. (I2C) LED12
  Sensor de efecto Hall (Interrupción) LED7 (repetido en infrarojo)
'1' Visualiza humo en LCD. (I2C)  
'2' Visualiza valor LDR-PWM LED10 PWM

- El motor funcionará desde el móvil con este teclado: (solo funcionará el motor A)

______________________________________________________
- Conexionado.

- Podríamos haber utilizado un Arduino Mega o Due, ya que éstos tienen más terminales y conectar esta etapa en ese Arduino, pero debido a que ya apenas disponemos de terminales haremos las conexiones en nuestro segundo Arduino.

- Consulta 64.- Arduino DUE. Generador sinusoidal, diente de sierra, triangular.

------------------------------------------------------------------------------------------------------------------------

- Conexionado al segundo Arduino.

- En este caso conectaré los motores al segundo Arduino, pero debido a la falta de terminales solo conectaré el motor A.

- Aunque en el código contemple la conexión del motor B.

Los terminales In1 y In2, van a entradas digitales del Arduino, en este caso van a la 13 y 12.
El terminal EnA deben ir a terminales PWM de Arduino, en este caso irá al ~6, ya que con estos terminales vamos a controlar la velocidad de los motores mediante PWM.

ATENCION: parece que el terminal ~9 no funciona con los EnA y EnB, no utilices el ~9 con estas entradas.

- El driver que controla a los motores lo alimentamos con unas pilas que crean una tensión de 9 V.

- Es muy importante que la GND del módulo driver y la GND del Arduino deben estar conectados como indico en la figura.

- Ahora vamos a conectar el módulo Bluetooth, sería conveniente echarle un vistazo a este tutorial:

http://kio4.com/arduino/29Cmotordecontinua.htm

- Pero vamos a realizar algunos cambios.

1.- En vez de comprobar si hay alguna llegada de datos del Bluetooth mediante el bucle loop y el
if(Serial.available()) {
val = Serial.read();

Vamos a utilizar un INTERRUPCIÓN, ya que la continua comprobación de datos median el bucle loop y el if(Serial.avaliable) enlentece tanto al resto del código que no llega a funcionar eficientemente.

Con la INTERRUPCIÓN, no hace falta comprobar la llegada de datos mediante el bucle loop, ya que el microcontrolador del Arduino, estará pendiente de la entrada 2, que es una entrada de INTERRUPCIÓN, y cuando cambie esa entrada tomará el valor enviado por Bluetooth.

- Esto de las INTERRUPCIONES lo vimos en el tutorial: 18.- Interrupciones. Consulta ese tutorial.

2.- Otro asunto más complicado. Resulta que normalmente se conecta el módulo Bluetooth a los terminales 0 y 1 del Arduino, que son los terminales Serie.

- Pero en este caso nos conviene conectarlos a los terminales 2 y 3, por algo relacionado con las INTERRUPCIONES,

- Para poder conectar el módulo Bluetooth a otros terminales que no sean el 0 y 1, necesitamos incluir la librería:

// BLuetooth
#include <SoftwareSerial.h>
SoftwareSerial I2CBT(2,3);
// El TX del módulo BT va al pin 2 del Arduino
// El RX del módulo BT va al pin 3 del Arduino

- Consulta el tutorial: 9A.- Dónde conectar el módulo Bluetooth. RX/TX. Serial. Importante.

3.- Otro asunto más. Al escribir el código de los motores, obtenemos un código muy largo en el archio .ino.

- En vez de utilizar un archivo .ino, vamos a utilizar dos. Uno para el código principal y otro en donde estará la parte del motor.

- Eso de tener dos archivos lo vimos en el tutorial: 39.- La aplicación en dos archivos.

4.- Otro más. Antes hemos hablado de las INTERRUPCIONES, pero ¿Cómo provoca el módulo Bluetooth la INTERRUPCIÓN?¿Qué terminal utiliza?

Aquí voy a poner un pequeño truco, conecto el TX del módulo Bluetooth al terminal 2 del Arduino, este terminal 2, es además una entrada de INTERRUPCIÓN, así que mato dos pájaros de un tiro, he cambido el módulo Bluetooth de lugar y además aprovecho el terminal 2 como entrada de INTERRUPCIÓN.

¿Cómo se provoca la INTERRUPCIÓN?, pues cada vez que llegue un dato desde el módulo Bluetooth, enviada por su salida TX, llegará al terminal 2, terminal 2 acusará ese cambio de nivel de entrada y provocará la INTERRUPCIÓN. Para ello previamente hemos indicado en el código del Arduino que la entrada 2 va a funcionar como entrada de INTERRUPCIÓN.
Las INTERRUPCIONES se obtienen cuando en el terminal 2 del Arduino hay un cambio de nivel.
attachInterrupt(0, int_bluetooth, CHANGE);

______________________________________________________
- Código.

- En este código deberíamos insertar el código correspondiente para gestionar el funcionamiento del driver de los motores según la señal que venga desde Bluetooth.

- Si insertamos ese código en este, resultaría demasiado largo para su lectura y comprensión.

- Así que vamos a poner el código del Bluetooth en otro archivo.

- Para utilizar los dos archivos éstos deben estar en la misma carpeta, es decir algo parecido a esto:

Teclado_LCD_humedad_ir_rfe_BT.ino

// Juan Antonio Villalpando
// juana1991@yahoo.com
// kio4.com

#include <VirtualWire.h>
#include <Wire.h>
// Bluetooth
#include <SoftwareSerial.h>
SoftwareSerial I2CBT(2,3);
// El TX del módulo BT va al pin 2 del Arduino
// El RX del módulo BT va al pin 3 del Arduino
// Ultrasonido.
int Trigger = 11;
int Echo = 10;
long microsegundos;
long duracion;
#define pulsadorA  4
#define pulsadorB  5
 int valorA, valorB;
 char A, B;
 int distancia;
 String str="";
 // Humo
const int pin_humo = A2;
String humo;
String enviar_humo;
// RF
 const int pin_de_transmision = 7; // RF
 /// Bluetooth
 char val;
 // Conexiones del Motor A
int enA = 6; //9; // El terminal 9 da problemas en enA y enB
int in1 = 13;
int in2 = 12;

// Conexiones del Motor B
// NO CONECTAR ESTOS TERMINALES
int enB = 6; 
int in3 = 0; //5;
int in4 = 1; //4;

void setup()
{
 // Bluetooth interrupcion.
  I2CBT.begin(9600);
  attachInterrupt(0, int_bluetooth, CHANGE); // 0 es la interrupción 0, es decir el terminal 2
// Inicializa IO y ISR
vw_set_tx_pin(pin_de_transmision);
vw_setup(2000); // Bits por segundo
pinMode(pulsadorA, INPUT); 
pinMode(pulsadorB, INPUT); 
pinMode(Trigger, OUTPUT);
pinMode(Echo, INPUT);
Serial.begin(9600);
// Bus I2C otro Arduino.
Wire.begin(2);                // Este Esclavo es el número 2
Wire.onRequest(requestEvent); // Cuando el Maestro le hace una petición,
                             // realiza el requestEvent
//// Bluetooth
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  analogWrite(enA, 90);
  analogWrite(enB, 90);                        
}

void loop()
{
bluetooth_comprueba();
ultrasonido();
sensor_humo();
delay(20);
valorA = digitalRead(pulsadorA);
valorB = digitalRead(pulsadorB);

// A y B son los valores de los botones.
if (valorA == HIGH) { 
  A='0';
} else {
  A='1';
}

if (valorB == HIGH) { 
  B='0';
} else {
  B='1';
} 

// str es el valor de la distancia con 4 caracteres.
//  String str="";
  str = "0000" + String(distancia); // Pasa el entero a String
  str = str.substring(str.length()-4); // Siempre 4 caracteres

  char msg[6] = {A, B, str[0], str[1],str[2], str[3]};
  vw_send((uint8_t *)msg, 6); // Send: Aquí envía 6 elementos.
  // Si está A y B en alto y la distancia en 546, enviará:
  // 1 1 0 5 4 6
  vw_wait_tx(); // Espera que termine el mensaje
  delay(100);

}
/////////////////////////////////////////////
///////////FUNCION ULTRASONIDO //////////////
void ultrasonido(){
digitalWrite(Trigger, LOW);
delayMicroseconds(2);
digitalWrite(Trigger, HIGH);
delayMicroseconds(10);
digitalWrite(Trigger, LOW);
delayMicroseconds(2);

duracion = pulseIn(Echo, HIGH);
distancia = duracion / 29 / 2;

//Serial.println(String(distancia));
delay(20);

}
/////////////////////////////////////////////
///////////////// HUMO ///////////
void sensor_humo(){
int lee_humo = analogRead(pin_humo);
enviar_humo = "000" + String(map(lee_humo, 100, 500, 0, 10));
//// Funcion enviar datos por I2C al otro Arduino.
// Esto es lo que envía cuando le hace la petición.
}
void requestEvent()
{   
 // Wire.write(str.substring(str.length()-3).c_str()); // Envía 3 bytes
 Wire.write(enviar_humo.substring(enviar_humo.length()-3).c_str()); // Envía 3 bytes                
}
/////////////////////////////////////////////
///// Interrupcion Bluetooth
void int_bluetooth() {
  val=I2CBT.read();
}

- Código bluetooth_comprueba.

- Este es el código para el control de los motores, creo que es sencillo de entender.

- En el tutorial indicado anteriormente tienes más información: 29C.- Motor de continua.

bluetooth_comprueba.ino

void bluetooth_comprueba() {
//if( Serial.available() ) {
//val = Serial.read();

// Avanza Motor A
if( val == '1' )
{ 
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
}

// Avanza Motor A y B
if( val == '2' )
{ 
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
  digitalWrite(in3, HIGH);
  digitalWrite(in4, LOW);
}

// Avanza Motor B
if( val == '3' )
{ 
  digitalWrite(in3, HIGH);
  digitalWrite(in4, LOW);
}

// Parar A
if( val == '4' )
{ 
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW); 
} 

// Parar A y B
if( val == '5' )
{ 
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW);  
  digitalWrite(in3, LOW);
  digitalWrite(in4, LOW);
} 

// Parar B
if( val == '6' )
{ 
  digitalWrite(in3, LOW);
  digitalWrite(in4, LOW);
} 

// Retrocede A
if( val == '7' )
{ 
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
} 

// Retrocede A y B
if( val == '8' )
{ 
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);  
  digitalWrite(in3, LOW);
  digitalWrite(in4, HIGH); 
} 

// Retrocede B
if( val == '9' )
{  
  digitalWrite(in3, LOW);
  digitalWrite(in4, HIGH); 
} 

if( val == 'A' )
{ 
analogWrite(enA, 100);
analogWrite(enB, 100);
} 
if( val == 'B' )
{ 
analogWrite(enA, 110);
analogWrite(enB, 110);
} 
if( val == 'C' )
{ 
analogWrite(enA, 150);
analogWrite(enB, 150);
} 
if( val == 'D' )
{ 
analogWrite(enA, 200);
analogWrite(enB, 200);
} 
if( val == 'E' )
{ 
analogWrite(enA, 250);
analogWrite(enB, 250);
} 
//} 
}

______________________________________________________
- Comentarios.

- Observa como parte del código está en el archivo bluetooth_comprueba.ino

______________________________________________________
________________________________

 

 

- Mi correo:
juana1991@yahoo.com
- KIO4.COM - Política de cookies. Textos e imágenes propiedad del autor:
© Juan A. Villalpando
No se permite la copia de información ni imágenes.
Usamos cookies propias y de terceros que entre otras cosas recogen datos sobre sus hábitos de navegación y realizan análisis de uso de nuestro sitio.
Si continúa navegando consideramos que acepta su uso. Acepto    Más información