Cámara Bluetooth Arduino (ABC): Conecta tu Móvil vía Bluetooth para Capturar Imágenes

Componentes y Suministros

Componente	Cantidad
Arduino UNO	1
Módulo Bluetooth HC-05	1
Cámara OV7670	1
Shield TFT para Arduino	1

Sobre el Proyecto

Hoy en día, un móvil con cámara y gadgets inalámbricos no sorprende a nadie. Gracias a Arduino, millones han descubierto la electrónica y programación. Hay cientos de tutoriales sobre intercambio de datos entre móvil Android y Arduino por Bluetooth... Pero yo quiero ir un paso más: transmitir imágenes, no solo caracteres y números.

Alguien dirá que es imposible: Arduino es demasiado lento para procesar grandes cantidades de datos con buena velocidad. Y tiene razón. Pero, ¿y si ayudamos a Arduino transfiriendo el trabajo "pesado" a otro dispositivo? ¡Existe tal dispositivo!

Se trata de un shield TFT único para Arduino. Información en artículos previos. En este tutorial demuestro cómo conectar vía Bluetooth Arduino y Android, obtener imagen de la cámara OV7670 en Arduino UNO y enviarla al móvil. Y viceversa: enviar imagen del móvil a Arduino y mostrarla en la pantalla del shield TFT.

Se escribió una app especial para Android.

Características del Shield TFT

• Pantalla 3.5" diagonal
• Resolución 320x240
• 65536 colores (16-bit)
• Pantalla táctil resistiva (controlador XPT2046)
• 5 botones
• RTC DS1307 con batería CR1220 3V
• Ranura para tarjeta micro SD
• Conector 4 pines (2.54mm) para Bluetooth HC-05/HC-06 o WiFi ESP8266
• Conector 20 pines (2.54mm) para cámara OV7670

Lista de Componentes Necesarios

Hardware:

• Arduino UNO
• Shield TFT único
• Adaptador AC-DC 6-12V, >600mA (¡necesario! El USB 500mA no basta)
• Cámara OV7670
• Módulo Bluetooth HC-06 (o HC-05)
• Móvil Android

Software:

• Arduino IDE
• Librería para Shield TFT único
• APK para Android

Preparación

Software

Todos los sketches de demostración están en Arduino IDE. Primero instala Arduino IDE: arduino.cc. Luego instala la librería para el shield TFT: github.com/YATFT/YATFT (descarga, descomprime en carpeta "libraries" de Arduino IDE).

Tras instalar Arduino IDE, programa la placa Arduino UNO. Por simplicidad, recomiendo flashearla por separado, sin el shield TFT:

1. Conecta USB a Arduino UNO
2. Ejecuta Arduino IDE
3. Selecciona puerto correspondiente
4. Descarga sketch ArduinoBluetoothCamera.ino y archivo ov7670_regs.h para inicialización de cámara
5. Pulsa Upload

Si la programación fue exitosa, pasa al siguiente paso.

Sketch ArduinoBluetoothCamera.ino

/**********************************************************************
 * SOFTWARE Y DOCUMENTACIÓN "TAL CUAL" SIN GARANTÍA...
 **********************************************************************/
#include <YATFT.h>
#include <util/yacam.h>
#include <util/yacodec.h>
#include <util/yasrl.h>
#include "ov7670_regs.h"

JPEG_DECODE jpeg_decode;
YATFT tft(0);
INTRFC ifc;
CAM cam;
CODEC codec;
SRL srl;

#define IMG_SizeX 320
#define IMG_SizeY 240
uint8_t mode = 0;
uint8_t last_mode = 0;
uint8_t start_capt = 0;
uint16_t err;

void setup() {
  Serial.begin(115200);
  tft.begin();
  tft.SetColor(BRIGHTRED);
  tft.ClearDevice();
}

void loop() {
  if (Serial.available()) {
    uint8_t temp = Serial.read();
    switch (temp) {
      case 0x10: // Enviar foto única
        mode = 1; start_capt = 1;
        if (last_mode != mode && last_mode != 2) {
          tft.begin(); tft.SetRGB();
          cam.CamInit(&OV7670_QVGA[0][0]);
          cam.CamVideoPreview(0, 0, 1, true);
          codec.JPEGInit(); codec.JPEGSetRegs(IMG_SizeX, IMG_SizeY);
          delay(1000);
        }
        break;
      case 0x20: // Envío continuo
        mode = 2; start_capt = 2;
        if (last_mode != mode && last_mode != 1) {
          tft.begin(); tft.SetRGB();
          cam.CamInit(&OV7670_QVGA[0][0]);
          cam.CamVideoPreview(0, 0, 1, true);
          codec.JPEGInit(); codec.JPEGSetRegs(IMG_SizeX, IMG_SizeY);
        }
        break;
      case 0x30: // Recibir foto única
        mode = 3; start_capt = 3;
        if (last_mode != mode && last_mode != 4) {
          tft.begin(); tft.SetYUV();
        }
        break;
      case 0x40: // Recepción continua
        mode = 4; start_capt = 4;
        if (last_mode != mode && last_mode != 3) {
          tft.begin(); tft.SetYUV();
        }
        break;
      default: break;
    }
  }
  // ... (lógica de modos 1-4: captura, codificación JPEG, envío/recibo por serie)
  // Función CamCapture() maneja captura y envío JPEG por puerto serie
}
uint8_t CamCapture(void) {
  // Captura imagen, codifica JPEG, envía por Serial.write()
  // Retorna 1 si error (tamaño inválido), 0 si OK
}

OV7670_regs.h

#ifndef OV7670_REGS_H
#define OV7670_REGS_H
const uint8_t OV7670_VGA[][2] PROGMEM = { /* ... registros para VGA 640x480 ... */ };
const uint8_t OV7670_QVGA[][2] PROGMEM = { /* ... registros para QVGA 320x240 ... */ };
#endif

Android

En el móvil Android, instala ArduinoTFT.apk. Permite a la app usar Bluetooth y Cámara.

Actualización 26/05/2020: Añadí código fuente de ArduinoTFT.apk. Descarga ArduinoTFT.zip.h, renombra a ArduinoTFT.zip y descomprime.

Actualización 25/07/2020: "Hola, tenía el mismo problema con la app Android que no funcionaba. Solucionado autorizando a la app acceso a la cámara del smartphone. Eso es todo. Adiós".

Módulo Bluetooth

Configura la velocidad del módulo Bluetooth a 115200 (comando AT+UART=115200, 0, 0). Es la velocidad óptima para que Arduino UNO reciba y procese datos. (Teóricamente se puede aumentar optimizando recepción, pero requiere más RAM). Instrucciones detalladas: Instructables.

(¡IMPORTANTE!) El módulo Bluetooth conecta al puerto de depuración de Arduino UNO. Al usar Bluetooth, el puerto de depuración no está disponible. Antes de programar Arduino UNO (con el módulo Bluetooth conectado), desconecta el módulo Bluetooth. Tras programar, vuelve a conectarlo.

Montaje

El montaje es sencillo:

1. Conecta Arduino UNO y Shield TFT.
2. Conecta cámara OV7670 al conector 20 pines del shield (a veces uso adaptador angular 18-20 pines pitch 2.54mm).
3. Conecta módulo Bluetooth HC-06/HC-05 al conector 4 pines etiquetado "Bluetooth" en el shield.
4. Conecta adaptador 6-12V a la entrada de alimentación de Arduino UNO.

Al encender, la pantalla del shield TFT se pone roja. Indica disposición para recibir comandos del móvil Android.

Demostración

En el móvil Android:

1. Inicia la app ArduinoTFT.
2. Pon el móvil en horizontal.
3. Activa Bluetooth, selecciona el módulo detectado (HC-06).

Aparecen dos ventanas y cuatro botones:

• Ventana superior derecha: visor de la cámara del móvil.
• Ventana grande izquierda: imágenes recibidas o enviadas.

Funciones de los botones:

• Enviar imagen única del móvil a Arduino.
• Envío continuo de imágenes del móvil a Arduino.
• Enviar imagen única de Arduino al móvil.
• Envío continuo de imágenes de Arduino al móvil.

Tamaño de imagen: 320x240 píxeles (2-5 kB). Hay video demo en el capítulo.

Si te gusta el artículo, valóralo. Quizás me motive para nuevos artículos. :-)

Gracias por ver!

Artículos previos:

1. Shield TFT Único para Arduino Uno - Inicio
2. Shield TFT Único Arduino - Cámara OV7670

Próximos artículos:

1. Shield TFT para Arduino Nano - Inicio
2. Fotos y video RGB en display SPI TFT
3. Control por Smartphone Robot 4WD por Bluetooth

Actualización 01.04.2021: Hay librería actualizada para serie de pantallas (2 shields y 2 breakout boards). El sketch compila según versión (1 a 4) y tipo de microcontrolador (MegaAVR o ESP-32). Más info en github.com/Ekaburg/EkaTFT.

Código

Librería para Shield TFT

https://github.com/YATFT/YATFT

Piezas Personalizadas y Carcasas