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


.

App inventor 2 en español
Cómo programar los teléfonos móviles con Android.
Bluetooth, Arduino y App inventor 2 - Juan Antonio Villalpando

-- Tutorial de iniciación de App Inventor 2 en español --

Volver al índice del tutorial

___________________________

9L3.- Enviar archivo por Bluetooth clásico a ESP32. Tarjeta SdCard.

- Se trata de enviar un archivo, en este caso una imagen.jpg a ESP32 por Bluetooth clásico. La imagen se guardará en una tarjeta SdCard insertada en un lector SdCard de Arduino.

- En este tutorial lo vimos para hacerlo con Arduino UNO y Bluetooth HC06: 9L2_enviar_archivo_BT.htm

- Los archivos de imagen tienen caracteres especiales que dan errores al enviarlos por Bluetooth. Para corregirlo se pasa todo el archivo a un código denominado Base64, que codifica el archivo y convierte todos los caracteres en "enviables" por Bluetooth.

- Vamos a ver el proceso poco a poco...

- Trabajaremos con esta imagen: pozo_grande.jpg (pulsa)

- Resulta que esa imagen es bastante grande, ocupa 553 KB, vamos a reducirle el tamaño hasta los 3 KB, además también reduciremos sus dimensiones a 200 x 150 pixels, será más pequeñas y con peor resolución, pero será más fácil de enviar.

- Aquí la tenemos pozo.jpg, tamaño 3 KB (4037 bytes), dimensiones 200x150

- Para cambiar su tamaño podemos utilizar la siguiente web:

https://www.imgonline.com.ua/eng/compress-image-size.php

- SdCard:

http://kio4.com/arduino/9130f.htm

____________________________
1.- Convertir una imagen.jpg a Base64 y enviarla mediante Bluetooth al ESP32. Ver la información en el Monitor Serie.

p9L3_Bluetooth_Base64ESP32_1.aia

- Vamos a convertir la imagen a Base64 y enviarla por Bluetooth al Arduino. Visualizaremos los códigos en el Monitor Serie.

- El buffer de Bluetooth del ESP32 admite hasta 260 caracteres, así que debemos trocear los envíos en paquetes de 260 caracteres, o menos.

____________________________
- Diseño.

____________________________
- Bloques.

- He puesto 5 archivos: de 4k, 20k, 50k y 200k para realizar pruebas de subida.

- Como indiqué anteriormente, el Bluetooth del ESP32 trabaja con un buffer de 260 bytes, por lo cual no podemos enviar toda la información de una vez. Debemos enviar información de ese tamaño o menor.

- Mediante el bloque de segmentación de texto, la dividimos en paquetes de 100 bytes. Tendremos paquetes enteros de 100 bytes y un trozo incompleto.

- En el caso del pozo_4.jpg, tendremos un tamaño de archivo en Base64 de 5241. Si lo dividimos en paquetes de 100, obtendremos 52 paquetes enteros y un paquete incompleto de 41 bytes.

- Enviamos esos paquetes cada 100 milisegundos del Reloj.

- Prueba otros tamaños de paquetes (hasta 260) y otros intervalos de Reloj.

_______________________
- Código del ESP32.

- En el Monitor Serie obtendremos los 5241 bytes que componen el código Base64 de esta imagen.

- El Monitor Serie realiza cambios de líneas, en este caso 69 cambios de líneas, que sumados a los 5241 dará unos 5310 caracteres.

ESP32.ino

#include "BluetoothSerial.h"

char rx_byte = 0;

#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif

BluetoothSerial SerialBT;

void setup() {
  Serial.begin(115200);
  SerialBT.begin("ESP32test"); //Bluetooth device name
  Serial.println("The device started, now you can pair it with bluetooth!");
}

void loop() { 
  if(SerialBT.available()) {
    rx_byte = SerialBT.read(); // Toma el caracter.
          Serial.print(rx_byte);
         }
  delay(1);
}

____________________________
2.- Convertir una imagen.jpg a Base64 y enviarla mediante Bluetooth al ESP32. Guardarlo en un archivo. SdCard.

p9L3_Bluetooth_Base64ESP32_2.aia

- Vamos a convertir la imagen a Base64 y enviarla por Bluetooth al Arduino. Guardaremos la información en una SdCard.

- Con 200 ms de Reloj y paquete de 100 Bytes, el archivo pozo_50.jpg tardó 130 segundos.

- Con 100 ms de Reloj y paquete de 100 Bytes, tardó 70 segundos. Con 59 ms tardo 70 segundos.

____________________________
- Diseño.

____________________________
- Bloques.

- El código crea paquetes de 100 bytes, además agrega un asterisco al final de cada uno de esos paquetes.

- El último paquete será incompleto (no tendrá esos 100 bytes).

 

____________________________
- Conexión ESP32 y lector de SdCard. Tarjeta SdCard.

- Información sobre ESP32 y SdCard: arduino/130_Wemos_PaginaWebSdCard.htm

____________________________
- Código ESP32.

- Va agregando al String paquete, los bytes que van llegando.

- Cuando llega el *, lo agrega, entra en el IF y lo quita. Además guarda todo ese paquete en el archivo.

- Reinicia el paquete = 0;

ESP32_Bluetooth_SdCard.ino

// Juan A. Villalpando

#include "BluetoothSerial.h"
#include "FS.h"
#include "SD.h"
#include "SPI.h"

char rx_byte = 0;
String paquete = "";

#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif

BluetoothSerial SerialBT;

void setup() {
  Serial.begin(115200);
  SerialBT.begin("ESP32test"); //Bluetooth device name
  Serial.println("The device started, now you can pair it with bluetooth!");
  
  if(!SD.begin()){
        Serial.println("Card Mount Failed");
        return;
    }
    uint8_t cardType = SD.cardType();

    if(cardType == CARD_NONE){
        Serial.println("No SD card attached");
        return;
    }

    Serial.print("SD Card Type: ");
    if(cardType == CARD_MMC){
        Serial.println("MMC");
    } else if(cardType == CARD_SD){
        Serial.println("SDSC");
    } else if(cardType == CARD_SDHC){
        Serial.println("SDHC");
    } else {
        Serial.println("UNKNOWN");
    }

    uint64_t cardSize = SD.cardSize() / (1024 * 1024);
    Serial.printf("SD Card Size: %lluMB\n", cardSize);
}

void loop() { 
  if(SerialBT.available()) {
    rx_byte = SerialBT.read(); // Toma el caracter.
    paquete = paquete + (String) rx_byte;
     if (rx_byte == '*'){
      paquete = paquete.substring(0, paquete.length()-1); // Quita el *
      appendFile(SD, "/hola.txt", paquete);
      paquete="";
                       }
                 }
           }

///////////// Añadir a archivo //////////////
void appendFile(fs::FS &fs, const char* path, String message){
 File file = fs.open(path, FILE_APPEND);
    if(!file){
        Serial.println("Failed to open file for appending");
        return;
    }
   
    if(file.print(message)){
       // Serial.println("Message appended");
    } else {
        Serial.println("Append failed");
    }
    file.close();
}			

____________________________
3.- ESP32 envía un archivo Base64 por Bluetooth, la App lo recibe, lo decodifica en Base64 y muestra la imagen en un componente Imagen.

 

 

 

 

 

 

 

 

BORRADOR

 

___________________________________________________________
3.- Enviar código Base64 por Bluetooth al Arduino y guardar esa información en un archivo mediante una tarjeta y lector SdCard.

p9L2_Bluetooth_Base64_2.aia

- La información Base64 que llega al Arduino la vamos a guardar en un archivo en una tarjeta SdCard.

- Convertiremos el archivo a Base64, enviamos su string por Bluetooth como EnviarTexto.

- El Arduino irá tomando cada uno de los caracteres y los irá guardando en el archivo pozo_4.txt

- Cuando reciba el asterisco *, indicará que ha acabado el grabación del archivo.

- IMPORTANTE: es necesario que inicies el Monitor Serie del Arduino cada vez que vayas a grabar un archivo.

- El archivo quedará pozo_4.txt quedará guardado en la SdCard en formato Base64. No se podrá leer como imagen. Si lo quieres leer como imagen, debes decodificarlo en Base64, por ejemplo con esta página:

https://www.motobit.com/util/base64-decoder-encoder.asp

- Una vez decodificado en Base64, le cambias la extensión base64.bin a imagen.jpg y podrás volver a ver la imagen.

____________________________
- Diseño.

- He puesto 4 archivos: de 4k, 20k y 50k para realizar pruebas de subida.

____________________________
- Bloques.

- La aplicación es similar a la anterior, he añadido un asterisco *, al final del texto para indicar fin del envío:

____________________________
- Arduino. Lector de SdCard.

- Necesitaremos un lector de SdCard y una tarjeta SdCard.

- Consulta este tutorial: Arduino y tarjeta SdCard.

_________________
- Conexiones.

-

 

_________________
- Código del Arduino.

- Según van llegando los caracteres se van guardando en el archivo pozo_4.txt.

- Va recibiendo caracteres hasta que llegue el asterisco *, indicando fin del archivo.

enviar_base64_codigo_2.ino

// Juan A. Villalpando
// http://kio4.com/arduino/9L2_enviar_archivo_BT.htm

#include <SD.h>
// const int CS = D8; // Para el NodeMcu
const int CS = 4; // Para el Arduino y Wemos ESP32
File miarchivo;
char rx_byte = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("Iniciando SdCard...");
  if (!SD.begin(CS)) {
    Serial.println("Error al iniciar.");
    return;
  }
    Serial.println("SdCard iniciada.");
    miarchivo = SD.open("pozo_4.txt", FILE_WRITE); // Abre el archivo.
}

void loop() {
  if(Serial.available()) {
    rx_byte = Serial.read(); // Toma el caracter.
         if (rx_byte != '*') {
          miarchivo.print(rx_byte); // Guarda caracter.
         } else {
          miarchivo.close(); // Cierra el archivo.
          Serial.println("Grabado.");
         }
  }
}

- Así tendríamos los archivos subidos a la SdCard.

  Tamaño del archivo en .jpg

Tamaño del archivo Base64 en .txt

Tiempo que tardan en subir...
pozo_4.jpg
3.879
5.241
9 segundos
pozo_20.jpg
18.192
24.576
50 segundos
pozo_50.jpg
42.983
58.067
120 segundos

________________________________
- Otro código para probar:

- En este código van llegando caracteres hasta alcanzar el número de 200, en ese momento se guardan en el archivo escribir.txt eso 200 caracteres, reinicia la k = 0 y vuelve a captar otros 200 caracteres, así hasta que llegue el asterisco.

enviar_base64_codigo_2.ino

// Juan A. Villalpando
// http://kio4.com/arduino/9L2_enviar_archivo_BT.htm

#include <SD.h>
// const int CS = D8; // Para el NodeMcu
const int CS = 4; // Para el Arduino y Wemos ESP32
File miarchivo;
int k =0;			
void setup() {
Serial.begin(9600);

  Serial.println("Iniciando SdCard...");
  if (!SD.begin(CS)) {
    Serial.println("Error al iniciar.");
    return;
  }
    Serial.println("SdCard iniciada.");
    miarchivo = SD.open("pozo_4.txt", FILE_WRITE); // Abre el archivo.

}

char rx_byte = 0;
String rx_str = "";

void loop() {
if(Serial.available()) {
    k = k + 1;
    rx_byte = Serial.read(); // Toma el caracter.
    rx_str += rx_byte; // Va uniendo los caracteres escritos.
    
    if (k == 200 || rx_byte == '*') {
         if (rx_byte == '*') {
          rx_str = rx_str.substring(0, rx_str.length()-1); // Quita el *
         }
           miarchivo.print(rx_str);
           rx_str = ""; 
           k = 0;
}
}

if (rx_byte == '*') {
miarchivo.close(); // Cierra el archivo.
Serial.println("Grabado.");
rx_byte = 0;
}

___________________________________________________________
4.- Tenemos en la Sdcard un archivo en Base64, queremos enviarlo a la aplicación por Bluetooth. En la aplicación se descodificará y se mostrará la imagen.

p9L2_Bluetooth_Base64_3.aia

- Esto es, tenemos en la SdCard el archivo POZO_4.TXT, que está codificado en Base64. Lo vamos a enviar por Bluetooth a la aplicación.

- También puedes realizarlo con POZO_20.TXT y POZO_50.TXT, para ello deberás modificar esos nombres en el código del Arduino.

- Cuando llegue a la aplicación, se descodificara (mediante una extensión), se guardará en un archivo en /mnt/sdcard del móvil y se mostrará en un componente Imagen.

- El siguiente Diseño lo he realizado ampliando la aplicación anterior, he añadido un Botón para obtener el archivo y un componente Imagen2 para visualizar la imagen.

- Para realizar la prueba, suponemos que existe un archivo llamado POZO_4.TXT en la SdCard del Arduino y que contiene la codificación Base64 de una imagen.

- Al pulsar el Botón de obtener, se enviará el caracter k. Cuando el Arduino reciba ese caracter enviará a la aplicación los códigos Base64 del archivo POZO_4.TXT.

- La aplicación recibirá esos códigos y los convertirá a archivo en /mnt/sdcard/el_pozo.jpg

- El Arduino enviará como último caracter el asterisco *

- Serial.print("*");

- Esto le indicará a la aplicación que ya ha terminado de enviar todo el archivo.

- En App Inventor, en las Propiedades del Bluetooth, debemos poner ByteDelimitador = 42, ya que el 42 es el código del asterisco *. Esto indicará que cuando llegue el asterisco habrá terminado de recibir el archivo completo.

____________________________
- Diseño.

____________________________
- Bloques.

____________________________
- Código del Arduino.

- Observa que envía el asterisco como último caracter, para indicarle a la App que ha llegado al fin de archivo.

- En la App, en la Propiedades del Bluetooth, debemos poner ByteDelimitador = 42, ya que ese número es el código del asterisco *.

enviar_base64_codigo_3.ino

// Juan A. Villalpando
// http://kio4.com/arduino/9L2_enviar_archivo_BT.htm

#include <SD.h>
// const int CS = D8; // Para el NodeMcu
const int CS = 4; // Para el Arduino y Wemos ESP32
File miarchivo;
char caracter;
     
void setup() {
Serial.begin(9600);

  Serial.println("Iniciando SdCard...");
  if (!SD.begin(CS)) {
    Serial.println("Error al iniciar.");
    return;
  }
    Serial.println("SdCard iniciada.");
}

void loop() {
   if(Serial.available()) {
   caracter = Serial.read();
   if(caracter == 'k'){
   miarchivo = SD.open("pozo_4.txt"); // Abre el archivo lectura. 
            if (miarchivo) {
              while (miarchivo.available()) {
                Serial.write(miarchivo.read());
                delay(2);
              }
                Serial.print("*");
                miarchivo.close();
            }
            else {
              Serial.println("Error al abrir el archivo.");
            }
          }
   }
}

___________________________________________________________
5.- Codificar y decodificar Base64 en Arduino.

- Podemos utilizar los siguientes códigos para codificar y decodificar Base64 en Arduino:

https://platformio.org/lib/show/582/Base64/examples

- Con la librería <Base64.h>, podemos codificar y decodificar en Base64.

- Pero hay un problema importante: codifica String, es decir cadena de caracteres, no codifica directamente archivos. Tendríamos que pasar todo el archivo a String y luego codificar ese String.

- Pero continua el problema: el tamaño de memoria del Arduino. Los String en Arduino UNO tienen un límite de unos 2048 bytes, por lo cual no podemos pasar un archivo grande, de por ejemplo 3KB, a String. Lo mismo ocurre en la decodificación.

- Aquí tenemos otra librería <base64.hpp>, pero tiene el mismo problema que la anterior, codifica String.

<base64.hpp>

https://www.arduinolibraries.info/libraries/base64

unsigned char binary[] = {133, 244, 117, 206, 178, 195};
unsigned char base64[9];
unsigned int base64_length = encode_base64(binary, 6, base64);
Serial.println(base64_length); // Prints "8"
Serial.println((char *) base64); // Prints "hfR1zrLD"
////////////////////////////////////////////
unsigned char base642[] = "hfR1zrLD";
unsigned char binary2[6];
unsigned int binary_length = decode_base64(base642, binary2);
Serial.println(binary2[1]);
// Prints "[133, 244, 117, 206, 178, 195]"
Serial.println(binary_length); // Prints "6"

_________________
-
Comentarios.

- Otras posibilidades:

- En vez de utilizar el Arduino UNO, podemos utilizar la tarjeta D1 R32 ESP32, que tiene más velocidad y más memoria, además dispone de Bluetooth.

- Observa la comparativa:

_________________
-
Propuesta.

- Cambia el tamaño de los archivos en los ejemplos que hemos visto, para comprobar el tiempo de finalización del proceso.

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

__________________________________

- 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