Hola,
después de estar varios días mirando tutoriales por Internet y consultando todo tipo de soluciones e información, cada vez tengo más dudas sobre el tema. Os lo explico detalladamente:
OBJETIVO: enviar un archivo a un servidor FTP mediante WIFI.
HARDWARE:
-Arduino UNO
-Módulo WIFI ESP01
-Módulo de alimentación MB102, para proporcionar 3,3v independientes al ESP01.
PROGRAMA: Básicamente será algo similar al ejemplo que se incluye en la librería ESP32_FTPClient y que incluiré al final de este post.
La duda es sobre cómo conectar la ESP01 a la placa de Arduino, y es que dependiendo del tutorial que haya consultado en algunos conectan el TX de la ESP01 con el TX del Arduino (y el RX con el RX), pero en otros unen el TX con el RX y viceversa. Otros en lugar de conectar al TX y RX del Arduino los llevan a otras entradas digitales. También en algunos ejemplos dichos pines los conectan directos y en otros a través de resitencias para hacer un divisor de tensión. El valor de estas resistencias en algunos casos es p. ej. de 1K y 2K y en otros de 10K, 20K. Algunos ejemplos también incluyen pulsadores de reseteo, etc, etc.
Resumiendo, tengo un cacao mental bastante importante. Como he dicho al principio yo no necesito programar la ESP, ni mandar comandos AT, ni nada de eso, simplemente quiero mandar un archivo mediante la WIFI.
¿Alguien puede decirme como conectar cada una de las patillas del ESP01 (igual tampoco se necesitan conectar todas las patillas, que son 1-GND, 2-GPIO2, 3-GPIO0, 4-RXD, 5-TXD, 6-CH_PD, 7-RESET, 8-Vcc).
Muchas gracias de antemano. Os pongo el ejemplo de Sketch:
/******************************************************************************
FTPClient_UploadImage.ino
FTP Client for Generic boards using SD, FS, etc.
Based on and modified from
1) esp32_ftpclient Library https://github.com/ldab/ESP32_FTPClient
Built by Khoi Hoang https://github.com/khoih-prog/FTPClient_Generic
******************************************************************************/
#include "Arduino.h"
#include "defines.h"
#include <FTPClient_Generic.h>
#include "octocat.h"
#define USING_VSFTP_SERVER true
#if USING_VSFTP_SERVER
// Change according to your FTP server
char ftp_server[] = "192.168.2.112";
char ftp_user[] = "ftp_test";
char ftp_pass[] = "ftp_test";
char dirName[] = "/home/ftp_test";
char newDirName[] = "/home/ftp_test/NewDir";
#else
// Change according to your FTP server
char ftp_server[] = "192.168.2.241";
char ftp_user[] = "teensy4x";
char ftp_pass[] = "ftp_test";
char dirName[] = "/";
char newDirName[] = "/NewDir";
#endif
FTPClient_Generic ftp (ftp_server, ftp_user, ftp_pass, 60000);
void setup()
{
Serial.begin( 115200 );
while (!Serial && millis() < 5000);
delay(500);
Serial.print(F("\nStarting FTPClient_UploadImage on "));
Serial.print(BOARD_NAME);
Serial.print(F(" with "));
Serial.println(SHIELD_TYPE);
Serial.println(FTPCLIENT_GENERIC_VERSION);
WiFi.begin( WIFI_SSID, WIFI_PASS );
Serial.print("Connecting WiFi, SSID = ");
Serial.println(WIFI_SSID);
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(".");
}
Serial.print("\nIP address: ");
Serial.println(WiFi.localIP());
#if (ESP32)
Serial.print("Max Free Heap: ");
Serial.println(ESP.getMaxAllocHeap());
#endif
ftp.OpenConnection();
//Change directory
ftp.ChangeWorkDir(dirName);
// Get the file size
String list[128];
// Get the directory content in order to allocate buffer
// my server response => type=file;modify=20190101000010;size=18; helloworld.txt
ftp.InitFile(COMMAND_XFER_TYPE_ASCII);
ftp.ContentListWithListCommand("", list);
for (uint16_t i = 0; i < sizeof(list); i++)
{
if (list[i].length() > 0)
Serial.println(list[i]);
else
break;
}
#if !(ESP8266)
// Make a new directory
Serial.print("Writing octocat.jpg, size = ");
Serial.println(sizeof(octocat_pic));
ftp.InitFile(COMMAND_XFER_TYPE_BINARY);
ftp.NewFile("octocat.jpg");
ftp.WriteData( octocat_pic, sizeof(octocat_pic) );
ftp.CloseFile();
// Create the file new and write a string into it
Serial.println("Writing hello_world.txt");
ftp.InitFile(COMMAND_XFER_TYPE_ASCII);
ftp.NewFile("hello_world.txt");
ftp.Write("Hello World");
ftp.CloseFile();
#endif
ftp.CloseConnection();
}
void loop()
{
}
Claro, tienes dos opciones: programar el ESP-01 (lo cual es bastante obsoleto) usando el entorno de Espressif y crear una API para comunicarte con el código de Arduino para el FTP, o usar comandos AT a través de la interfaz serie.
¿Por qué no pruebas con un ESP32? Será mucho más fácil tener solo un chip para programar y es mucho más capaz que tu UNO + ESP-01.
Lo de usar Arduino+ESP01 es porque ya dispongo de ese material y no necesito comprar nada. Pero mi pregunta es ¿una vez programada la ESP01(¿por cierto necesitaría programarla para hacer lo que yo digo?) cómo se conecta exactamente el modulo?
Gracias
Con un sistema operativo que gestione el lenguaje de comandos AT, en cuyo caso no es necesario programar nada en el ESP-01, ya que es el Arduino el que debe enviar los comandos AT correctos a través del puerto serie para hacer lo que deseas. Los comandos AT son de bajo nivel, por lo que gestionar estos comandos con una correcta gestión de errores es bastante laborioso.
Con un sistema operativo más avanzado que permite programar el ESP como un Arduino, con acceso a las pines, puerto serie, etc. En este caso, desarrollas un programa que se ejecuta en este sistema operativo y que se comunica con el código que hayas cargado específicamente en tu UNO para intercambiar información. Esto requiere desarrollar dos programas y un protocolo de comunicación entre los dos microcontroladores.
En ambos casos, hay bastante trabajo y, en mi opinión, será más sencillo volver a desarrollar el programa que tienes en el UNO directamente en un ESP32 en lugar de intentar desarrollar esta comunicación entre las dos placas.
Lo más sencillo es encontrar un módulo dedicado para el ESP-01 que se encargue de la adaptación del nivel de tensión para la comunicación serie. Luego, las pines a conectar dependen de si quieres poder programar el ESP-01 o si lo usas directamente en modo "Comandos AT".
Vaya, no pensaba que fuera tan complicado. Voy a estudiar las 2 opciones que comentas. De todas formas si alguien me puede indicar cual sería el conexionado (suponiendo que el ESP01 lo tenga ya programado) se lo agradecería.
Gracias, pero todos esos tutoriales (y muchos más) ya me los he leído y no me aclaran nada (en este p. ej. conecta directamente el módulo al Arduino, cuando la mayoría de gente recomienda una alimentación exterior de 3,3v y todo lo que he comentado al principio de los pines TX , RX, de las resistencias, etc, etc). En fin no me quiero repetir.
El ESP-01 está a 3.3V, pero a veces los pines resisten hasta 5V, al menos durante un tiempo determinado. Por eso, en algunos tutoriales se ve una conexión directa entre el Tx del UNO y el Rx del ESP. Pero, por supuesto, esto no es una buena idea. Para cumplir con la especificación, es necesario adaptar la tensión para bajar los 5V a 3.3V, y la forma más sencilla de hacerlo es con un puente de resistencias. También se puede usar un circuito "adaptador de voltaje".
El pin Tx del ESP emite información a 0V o 3.3V. Si lo conectas a un pin del Arduino UNO, como soporta hasta 5V, no es un problema, y 3.3V es suficiente para que el UNO reconozca un HIGH, por lo que la comunicación en ese sentido funcionará.
Para que ambos MCUs estén de acuerdo con el potencial de referencia, es necesario conectar sus GND.
En resumen:
UNO Tx --> adaptación de tensión --> ESP Rx
UNO Rx --> ESP Tx
UNO GND --> ESP GND
Estas son las 3 interconexiones necesarias para permitir la comunicación a través de UART.
Por supuesto, el ESP necesita ser alimentado con una fuente de 3.3V adecuada. El módulo ESP-01 típicamente consume entre 70 y 250 mA durante su funcionamiento normal, con una corriente pico de hasta 400 mA durante las transmisiones Wi-Fi. Así que asegúrate de que la fuente de alimentación pueda entregar esta corriente y añade un condensador entre Vcc y GND para tener algo de energía disponible en caso de una demanda repentina.
GPIO0 se usa para la selección del modo de arranque y la programación de flash si estás cargando un código personalizado en el ESP01.
Para reducir una señal de 5V a 3.3V, utiliza una relación de división de 3.3/5 = 0.66. No tiene que ser 100% exacto. Si usas 2.2KΩ y 3.3KΩ, está lo suficientemente cerca.
J-M-L. Muchas gracias por el interés y el tiempo dedicado, has sido de gran ayuda. De momento dejo abierto el hilo para comentar los progresos que voy consiguiendo.
Yo creo que simplemente todas las dudas se responden con la práctica. No esperes encontrar las respuestas que SOLO TU TIENES viendo tutoriales porque internet esta plagado de A y -A. Como nadie cuestiona un tutorial el que esta mal perdura y si además quieres sacar a flote algo tan obsoleto como un ESP01 que ya nadie usa, te basarás en tutoriales de 3 a 5 o mas años.
Siempre siempre, el TX de un dispositivo se conecta al RX del otro y vice versa.
Okay? No hay mas discusión.
Como ya te dijeron necesitas al menos para la entrada RX del ESP01 que es de 3.3V un divisor resistivo. Yo lo hago con 1k donde @J-M-L puse la imagen del resistor de 2k2 y 2 resistencias en serie de 1k donde la imagen dice 3k3.
Entonces 3 resistores, todos en serie entre si. Y uno comunica el TX del UNO al RX del ESP01.
Para programar el ESP01 debes poner el pin GPIO0 a GND y entonces alimentarlo, no alimentarlo y poner el pin indicado a GND, no va entrar en modo programming.
Entonces puedes subir el sketch.
Repito ahora lo cuento fácil pero me llevó tiempo encontrar la forma de hacerlo fácil. Mientras me frustré mucho con el ESP01, terminé usando otros mas simples, el nodemcu o sea el ESP8266-12F y luego el ESP32 y hoy no uso otra cosa.
Muchas gracias por la información, Surbyte. Más que nada era por utilizar material que ya tenía y no tener que comprar nada nuevo. Tendré en cuenta tus sugerencias.
Acá en el foro se ha respondido muchas veces como conectar el ESP-01 revisa arriba derecha en la lupa.
Algo mas, no alimentes el ESP con los 3.3V del UNO. Usa una fuente DC DC desde los 5V, es mejor incluso que usar un AMS1117 que es un regulador LDO de 3.3V de salida.
