Tutorial libreria MultiFTPServer per ESP32, Raspberry Pi Pico, Arduino, RP2040, ESP8266 e STM32

di Renzo Mischianti · Pubblicato 28 Aprile 2025 · Aggiornato 28 Aprile 2025

Spread the love

Finalmente possiamo dare il benvenuto a MultiFTPServer, un successore leggero e plug-and-play di SimpleFTPServer che introduce l’FTP multi-sessione alle board hobbistiche e alle MCU industriali che ami. Con un’unica API unificata puoi ora trasferire file da e verso ESP8266, ESP32, STM32, le classiche schede Arduino e il Raspberry Pi Pico W, tutti contemporaneamente e dallo stesso sketch o firmware. Dietro le quinte la libreria aggiunge un gestore di connessioni event-driven, una gestione della memoria più intelligente e hook di autenticazione, così i tuoi dati rimangono veloci e al sicuro anche su dispositivi con pochi kilobyte a disposizione. Nelle pagine che seguono analizzeremo cosa è cambiato, perché le connessioni parallele contano nei flussi di lavoro IoT reali e come mettere in funzione MultiFTPServer in pochi minuti nel tuo prossimo progetto.

Funzionalità

Sessioni FTP multiple concomitanti (impostate a 2 per impostazione predefinita; prima di aumentare il numero di sessioni controlla la libreria e le specifiche del microcontrollore).
Supporto per molteplici backend di storage, inclusi SD, SPIFFS, LittleFS, FFat, Seeed SD, SdFat e altri.
Compatibilità con varie interfacce di rete: Wi-Fi, Ethernet ed ENC28J60.
Dimensioni del buffer personalizzabili per prestazioni ottimizzate.
Supporto UTF-8 per i nomi dei file.
Callback intuitive per operazioni e trasferimenti.
Esteso supporto di debug.

Perché MultiFTPServer?

La nuova libreria MultiFTPServer supera i limiti di SimpleFTPServer consentendo connessioni multiple simultanee pur mantenendo una struttura di configurazione simile. È quindi la scelta ideale per applicazioni che richiedono una gestione efficiente dei file in rete.

Disponibilità della libreria

La libreria MultiFTPServer è disponibile nell’Arduino Library Manager. Cerca “MultiFTPServer” e installala direttamente nell’IDE.

Puoi anche scaricare il sorgente da GitHub:

Per le MCU con poca potenza e non in grado di gestire sessioni multiple, o comunque se non avete necessità di sessioni multiple fate riferimento alla consolidata SimpleFTPServer.

Opzioni di configurazione

MultiFTPServer supporta vari tipi di storage e configurazioni di rete. Modifica il file FtpServerKey.h per adattare la libreria al tuo progetto. Di seguito alcuni estratti:

/********************************************************************************
 * FtpServer for:
 *  - Arduino
 *  - Arduino SAMD (WiFiNINA)
 *  - esp8266
 *  - esp32
 *  - STM32
 *  - Raspberry Pi Pico W
 *
 * Derived form Jean-Michel Gallego version
 * AUTHOR:  Renzo Mischianti
 *
 * https://www.mischianti.org/category/my-libraries/simple-ftp-server/
 *
 ********************************************************************************/

/*******************************************************************************
 **                                                                            **
 **                         SETTINGS FOR FTP SERVER                            **
 **                                                                            **
 *******************************************************************************/

#ifndef FTP_SERVER_CONFIG_H
#define FTP_SERVER_CONFIG_H

// Uncomment to enable printing out nice debug messages.
// #define FTP_SERVER_DEBUG
// #define FTP_ADDITIONAL_DEBUG

// Define where debug output will be printed.
#define DEBUG_PRINTER Serial

#define STORAGE_SDFAT1 		1 	// Library SdFat version 1.4.x
#define STORAGE_SDFAT2 		2 	// Library SdFat version >= 2.0.2
#define STORAGE_SPIFM  		3 	// Libraries Adafruit_SPIFlash and SdFat-Adafruit-Fork
#define STORAGE_FATFS  		4 	// Library FatFs
#define STORAGE_SD 			5 	// Standard SD library (suitable for Arduino esp8266 and esp32
#define STORAGE_SPIFFS 		6 	// SPIFFS
#define STORAGE_LITTLEFS 	7 	// LITTLEFS
#define STORAGE_SEEED_SD 	8 	// Seeed_SD library
#define STORAGE_FFAT  		9 	// ESP32 FFAT
#define STORAGE_SD_MMC		10 	// SD_MMC library

#define NETWORK_ESP8266_ASYNC 	(1)
#define NETWORK_ESP8266 		(2) 	// Standard ESP8266WiFi
#define NETWORK_ESP8266_242 	(3) 	// ESP8266WiFi before 2.4.2 core
#define NETWORK_W5100 			(4)		// Standard Arduino Ethernet library
#define NETWORK_ETHERNET		(4)		// Standard Arduino Ethernet library
#define NETWORK_ENC28J60 		(5) 	// UIPEthernet library
#define NETWORK_ESP32 			(6) 	// Standard WiFi library
#define NETWORK_RP2040_WIFI		(15) 	// Raspberry Pi Pico W standard WiFi library
#define NETWORK_ESP32_ETH 		(7)		// Standard ETH library
#define NETWORK_WiFiNINA 		(8)		// Standard WiFiNINA library
#define NETWORK_SEEED_RTL8720DN (9) 	// Standard SEED WiFi library
#define NETWORK_ETHERNET_LARGE 	(10)
#define NETWORK_ETHERNET_ENC 	(11)	// EthernetENC library (evolution of UIPEthernet
#define NETWORK_ETHERNET_STM 	(12)
#define NETWORK_UIPETHERNET 	(13)	// UIPEthernet library same of NETWORK_ENC28J60
#define NETWORK_ETHERNET_GENERIC	(14)	// Ethernet generic

// esp8266 configuration
#ifndef DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP8266
	#define DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP8266 	NETWORK_ESP8266
	#define DEFAULT_STORAGE_TYPE_ESP8266 				STORAGE_LITTLEFS
#endif
// esp32 configuration
#ifndef DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP32
	#define DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP32 		NETWORK_ESP32
	#define DEFAULT_STORAGE_TYPE_ESP32 					STORAGE_FFAT
	/**
To use Ethernet.h with esp32 fix would be to change in Ethernet.h the line
class EthernetServer : public Server {
to
class EthernetServer : public Stream {

or

in \esp32\2.0.6\cores\esp32\Server.h
A workaround is to change line 28 of the ESP32 core's Server.h from:
    virtual void begin(uint16_t port=0) =0;
to
    virtual void begin() =0;
However, the last one, that will break anything that uses the ESP32 WiFi library's WebServer class.

https://github.com/arduino-libraries/Ethernet/issues/193
https://github.com/arduino-libraries/Ethernet/issues/88
	 *
	 */
#endif
// Standard AVR Arduino configuration
#ifndef DEFAULT_FTP_SERVER_NETWORK_TYPE_ARDUINO
	#define DEFAULT_FTP_SERVER_NETWORK_TYPE_ARDUINO 	NETWORK_W5100
	#define DEFAULT_STORAGE_TYPE_ARDUINO 				STORAGE_SD
#endif
// STM32 configuration
#ifndef DEFAULT_FTP_SERVER_NETWORK_TYPE_STM32
	#define DEFAULT_FTP_SERVER_NETWORK_TYPE_STM32 		NETWORK_W5100
	#define DEFAULT_STORAGE_TYPE_STM32 					STORAGE_SDFAT2
#endif
// Raspberry Pi Pico (rp2040) configuration
#ifndef DEFAULT_FTP_SERVER_NETWORK_TYPE_RP2040
    #define DEFAULT_FTP_SERVER_NETWORK_TYPE_RP2040 		NETWORK_RP2040_WIFI
	#define DEFAULT_STORAGE_TYPE_RP2040					STORAGE_LITTLEFS
#endif

// Arduino SAMD21 like Arduino MKR Nano 33 IoT or Wio Terminal
#ifndef DEFAULT_FTP_SERVER_NETWORK_TYPE_ARDUINO_SAMD
// Wio Terminal
//	#define DEFAULT_FTP_SERVER_NETWORK_TYPE_SAMD NETWORK_SEEED_RTL8720DN
//	#define DEFAULT_STORAGE_TYPE_SAMD STORAGE_SEEED_SD

// Arduino SAMD
	#define DEFAULT_FTP_SERVER_NETWORK_TYPE_SAMD 		NETWORK_WiFiNINA
	#define DEFAULT_STORAGE_TYPE_SAMD 					STORAGE_SD
#endif

#define UTF8_SUPPORT

//#define SD_CS_PIN 4
// Disconnect client after 5 minutes of inactivity (expressed in seconds)
#ifndef FTP_TIME_OUT
	#define FTP_TIME_OUT  5 * 60
#endif


// Wait for authentication for 10 seconds (expressed in seconds)
#ifndef FTP_AUTH_TIME_OUT
	#define FTP_AUTH_TIME_OUT 10
#endif


// Size of file buffer for read/write
// Transfer speed depends of this value
// Best value depends on many factors: SD card, client side OS, ... 
// But it can be reduced to 512 if memory usage is critical.
#ifndef FTP_BUF_SIZE
	#define FTP_BUF_SIZE 1024 //2048 //1024 // 512
#endif
// Define the maximum number of concurrent sessions
#ifndef FTP_MAX_SESSIONS
    #define FTP_MAX_SESSIONS 2
#endif

#endif // FTP_SERVER_CONFIG_H

Regola queste definizioni in base al tuo hardware.

Ad esempio, la sezione ESP32:

#ifndef DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP32
	#define DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP32 		NETWORK_ESP32
	#define DEFAULT_STORAGE_TYPE_ESP32 					STORAGE_FFAT
#endif

Basta cambiare il valore della macro per selezionare l’interfaccia di rete.

	#define DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP32 		NETWORK_ESP32

Esiste un ampio set di valori, ma solo alcuni sono consentiti per una data famiglia di microcontrollori.

#define NETWORK_ESP8266_ASYNC 	(1)
#define NETWORK_ESP8266 		(2) 	// ESP8266WiFi standard
#define NETWORK_ESP8266_242 	(3) 	// Core < 2.4.2
#define NETWORK_W5100 			(4) 	// Ethernet standard Arduino
#define NETWORK_ETHERNET		(4) 	// Alias
#define NETWORK_ENC28J60 		(5) 	// UIPEthernet
#define NETWORK_ESP32 			(6) 	// WiFi standard
#define NETWORK_RP2040_WIFI		(15) 	// WiFi standard Pico W
#define NETWORK_ESP32_ETH 		(7) 	// ETH standard
#define NETWORK_WiFiNINA 		(8) 	// WiFiNINA
#define NETWORK_SEEED_RTL8720DN (9) 	// WiFi Seeed
#define NETWORK_ETHERNET_LARGE 	(10)
#define NETWORK_ETHERNET_ENC 	(11)	// EthernetENC
#define NETWORK_ETHERNET_STM 	(12)
#define NETWORK_UIPETHERNET 	(13)	// UIPEthernet
#define NETWORK_ETHERNET_GENERIC	(14)	// Ethernet generic

Analoga logica per scegliere il filesystem di riferimento:

	#define DEFAULT_STORAGE_TYPE_ESP32 					STORAGE_FFAT

Di default è FFat, ma puoi optare per uno dei seguenti valori:

#define STORAGE_SDFAT1 		1 	// SdFat 1.4.x
#define STORAGE_SDFAT2 		2 	// SdFat ≥ 2.0.2
#define STORAGE_SPIFM  		3 	// Adafruit_SPIFlash + SdFat-Adafruit-Fork
#define STORAGE_FATFS  		4 	// FatFs
#define STORAGE_SD 			5 	// SD standard (ESP8266/ESP32)
#define STORAGE_SPIFFS 		6 	// SPIFFS
#define STORAGE_LITTLEFS 	7 	// LittleFS
#define STORAGE_SEEED_SD 	8 	// Seeed_SD
#define STORAGE_FFAT  		9 	// FFat ESP32
#define STORAGE_SD_MMC		10 	// SD_MMC

Le alternative più comuni per ESP32 sono LittleFS, SPIFFS (per i core più vecchi) e, naturalmente, SD.

Funzionalità in dettaglio

Supporto multi-sessione

Per abilitare più sessioni imposta FTP_MAX_SESSIONS nel file di configurazione:

#define FTP_MAX_SESSIONS 2

In questo modo sono permesse due sessioni FTP simultanee.

Debug

Abilita il debug per log dettagliati:

#define FTP_SERVER_DEBUG
#define FTP_ADDITIONAL_DEBUG

I messaggi di debug vengono stampati su Serial. Puoi cambiarne l’output ridefinendo DEBUG_PRINTER:

#define DEBUG_PRINTER Serial

Dimensione del buffer

La dimensione del buffer influenza velocità di trasferimento e uso di memoria. Impostala così:

#define FTP_BUF_SIZE 1024

Timeout di autenticazione

Imposta il timeout per l’autenticazione utente:

#define FTP_AUTH_TIME_OUT 10

Timeout di sessione

Definisce il tempo di inattività dopo il quale la sessione viene chiusa:

#define FTP_TIME_OUT 300

Supporto ai nomi UTF-8

I nomi file UTF-8 sono supportati di default. Assicurati che UTF8_SUPPORT sia definito.

#define UTF8_SUPPORT

Esempi

La configurazione di default per ESP32 usa il filesystem FFat; segue un esempio di server FTP.

/*
 * Simple FTP Server Example with FFat on ESP32
 *
 * AUTHOR: Renzo Mischianti
 * URL: https://www.mischianti.org
 *
 * DESCRIPTION:
 * This example demonstrates the use of the MultiFTPServer library
 * with the FFat file system on an ESP32. The sketch connects to a WiFi network,
 * initializes the FFat file system, and sets up an FTP server for file management.
 */

#include <Arduino.h>
#include <FS.h>
#include <FFat.h>
#include <WiFi.h>
#include <MultiFTPServer.h>

// WiFi credentials
const char* WIFI_SSID = "reef-casa-sopra";    // Replace with your WiFi SSID
const char* WIFI_PASSWORD = "aabbccdd77";     // Replace with your WiFi password

// FTP server instance
FtpServer ftpServer;

void setup() {
  // Initialize Serial Monitor
  Serial.begin(115200);
  Serial.println("Initializing...");

  // Connect to WiFi network
  Serial.printf("Connecting to WiFi: %s\n", WIFI_SSID);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  // Wait for WiFi connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected!");
  Serial.printf("Connected to: %s\n", WIFI_SSID);
  Serial.printf("IP Address: %s\n", WiFi.localIP().toString().c_str());

  // Initialize FFat file system
  Serial.println("Initializing FFat file system...");
  if (FFat.begin(true)) { // Auto-format FFat if not already formatted
    Serial.println("FFat initialized successfully!");
    Serial.println("Formatting FFat...");
    FFat.format(); // Optional: Format FFat (use only if needed)
  } else {
    Serial.println("Failed to initialize FFat!");
    return; // Stop further execution if FFat initialization fails
  }

  // Start FTP server
  ftpServer.begin("user", "password"); // Set FTP username and password
  Serial.println("FTP server started!");
  Serial.println("You can now access the FFat file system via FTP.");
}

void loop() {
  // Handle FTP server requests
  ftpServer.handleFTP(); // Continuously process FTP requests
}

FTP Server su ESP32 con SD-card

Di seguito un piccolo sketch per gestire la SD-card via FTP su ESP32.

Per farlo funzionare devi modificare la configurazione così:

#ifndef DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP32
	#define DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP32 		NETWORK_ESP32
	#define DEFAULT_STORAGE_TYPE_ESP32 					STORAGE_SD
#endif

Ecco il codice:

/*
 * Simple FTP Server Example with SD Card on ESP32
 *
 * AUTHOR: Renzo Mischianti
 * URL: https://www.mischianti.org
 *
 * DESCRIPTION:
 * This example demonstrates how to use the MultiFTPServer library
 * with an ESP32 and an SD card module. The ESP32 connects to a WiFi network
 * and initializes an FTP server for file transfers.
 *
 * FEATURES:
 * - WiFi connection to local network
 * - SD card initialization for file storage
 * - FTP server setup for file uploads and downloads
 */

#include <WiFi.h>
#include <MultiFTPServer.h>
#include <SPI.h>
#include <SD.h>

// WiFi credentials
const char* WIFI_SSID = "<YOUR-SSID>";    // Replace with your WiFi SSID
const char* WIFI_PASSWORD = "<YOUR-PASSWD>";     // Replace with your WiFi password

// SD card chip select pin
const int CHIP_SELECT_PIN = SS;               // Default SS pin for SPI

// FTP server instance
FtpServer ftpServer;

void setup() {
  // Initialize Serial Monitor
  Serial.begin(9600);
  while (!Serial) {
    // Wait for serial port to connect (required for native USB ports)
  }

  // Connect to WiFi network
  Serial.println("Connecting to WiFi...");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected!");
  Serial.printf("Connected to: %s\n", WIFI_SSID);
  Serial.printf("IP Address: %s\n", WiFi.localIP().toString().c_str());

  // Wait for a short delay before initializing SD card
  delay(1000);

  // Initialize SD card
  Serial.print("Initializing SD card...");
  while (!SD.begin(CHIP_SELECT_PIN)) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nSD card initialized successfully!");

  // Start FTP server with username and password
  ftpServer.begin("user", "password"); // Replace with your desired FTP credentials
  Serial.println("FTP server started!");
}

void loop() {
  // Handle FTP server operations
  ftpServer.handleFTP(); // Continuously process FTP requests
}

Aggiungere una callback di stato al tuo server FTP

La libreria offre la possibilità di aggiungere callback per monitorare lo stato della connessione o del trasferimento.

Le firme delle funzioni sono:

  void (*_callback)(FtpOperation ftpOperation, unsigned int freeSpace, unsigned int totalSpace){}; 
  void (*_transferCallback)(FtpTransferOperation ftpOperation, const char* name, unsigned int transferredSize){};

Callback principale

La prima viene chiamata quando avviene una di queste operazioni:

FTP_CONNECT: viene stabilita una connessione;
FTP_DISCONNECT: il client si disconnette;
FTP_FREE_SPACE_CHANGE: cambia lo spazio libero.

Altri parametri:

freeSpace: spazio disponibile su SD;
totalSpace: spazio totale della SD.

Callback di trasferimento

La seconda viene chiamata in queste situazioni:

FTP_UPLOAD_START: avvio di un upload;
FTP_UPLOAD: upload in corso;
FTP_DOWNLOAD_START: avvio di un download;
FTP_DOWNLOAD: download in corso;
FTP_DOWNLOAD_STOP o FTP_TRANSFER_STOP: fine download;
FTP_UPLOAD_STOP o FTP_TRANSFER_STOP: fine upload;
FTP_DOWNLOAD_ERROR o FTP_TRANSFER_ERROR: errore in download;
FTP_UPLOAD_ERROR o FTP_TRANSFER_ERROR: errore in upload.

Gli altri parametri sono:

name: nome del file;
transferredSize: dimensione trasferita.

Esempio di sketch con callback

Un possibile sketch con le callback è il seguente:

/*
 * FtpServer with ESP32 and FFat File System
 *
 * AUTHOR: Renzo Mischianti
 *
 * This code sets up an FTP server on an ESP32 using the FFat file system.
 * The server provides basic FTP functionalities, such as uploading and downloading files,
 * with callback functions to monitor connection and transfer events.
 *
 * For detailed information, visit:
 * https://www.mischianti.org/2020/02/08/ftp-server-on-esp8266-and-esp32
 */

#include "FS.h"
#include "FFat.h"
#include <WiFi.h>
#include <MultiFTPServer.h>

// WiFi credentials
const char* ssid = "reef-casa-sopra";
const char* password = "aabbccdd77";

// FTP server instance
FtpServer ftpSrv;

/**
 * Callback function for FTP operations.
 * Provides status updates for FTP connection events.
 */
void ftpOperationCallback(FtpOperation ftpOperation, unsigned int freeSpace, unsigned int totalSpace) {
  switch (ftpOperation) {
    case FTP_CONNECT:
      Serial.println(F("FTP: Client connected!"));
      break;
    case FTP_DISCONNECT:
      Serial.println(F("FTP: Client disconnected!"));
      break;
    case FTP_FREE_SPACE_CHANGE:
      Serial.printf("FTP: Free space changed. Free: %u bytes, Total: %u bytes.\n", freeSpace, totalSpace);
      break;
    default:
      break;
  }
}

/**
 * Callback function for FTP transfers.
 * Provides status updates for file upload and download events.
 */
void ftpTransferCallback(FtpTransferOperation ftpOperation, const char* fileName, unsigned int transferredSize) {
  switch (ftpOperation) {
    case FTP_UPLOAD_START:
      Serial.printf("FTP: Started uploading file: %s\n", fileName);
      break;
    case FTP_UPLOAD:
      Serial.printf("FTP: Uploading file: %s, Transferred: %u bytes\n", fileName, transferredSize);
      break;
    case FTP_DOWNLOAD_START:
      Serial.printf("FTP: Started downloading file: %s\n", fileName);
      break;
    case FTP_DOWNLOAD:
      Serial.printf("FTP: Downloading file: %s, Transferred: %u bytes\n", fileName, transferredSize);
      break;
    case FTP_TRANSFER_STOP:
      Serial.println(F("FTP: Transfer completed successfully."));
      break;
    case FTP_TRANSFER_ERROR:
      Serial.println(F("FTP: Error during file transfer!"));
      break;
    default:
      break;
  }
}

void setup() {
  // Initialize serial communication
  Serial.begin(115200);

  // Connect to WiFi
  Serial.println(F("Connecting to WiFi..."));
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected!");
  Serial.print(F("IP Address: "));
  Serial.println(WiFi.localIP());

  // Initialize FFat file system
  Serial.print(F("Initializing FFat filesystem..."));
  if (FFat.begin(true)) {
    Serial.println(F("done."));
  } else {
    Serial.println(F("failed! Please check FFat setup."));
    while (true) { delay(1000); }
  }

  // Set FTP server callbacks
  ftpSrv.setCallback(ftpOperationCallback);
  ftpSrv.setTransferCallback(ftpTransferCallback);

  // Start FTP server with username and password
  Serial.println(F("Starting FTP server..."));
  ftpSrv.begin("user", "password"); // Username: "user", Password: "password"
}

void loop() {
  // Handle FTP server operations
  ftpSrv.handleFTP();
}

Ecco un esempio di output seriale durante l’upload di un file e la cancellazione di due file:

Connecting to WiFi...
.....
WiFi connected!
IP Address: 192.168.1.57
Initializing FFat filesystem...done.
Starting FTP server...
FTP: Client connected!
FTP: Started uploading file: api-82.jar
FTP: Uploading file: api-82.jar, Transferred: 1024 bytes
FTP: Uploading file: api-82.jar, Transferred: 2048 bytes
FTP: Uploading file: api-82.jar, Transferred: 3072 bytes
FTP: Uploading file: api-82.jar, Transferred: 4096 bytes
FTP: Uploading file: api-82.jar, Transferred: 5120 bytes
FTP: Uploading file: api-82.jar, Transferred: 6144 bytes
FTP: Uploading file: api-82.jar, Transferred: 7168 bytes
FTP: Uploading file: api-82.jar, Transferred: 8192 bytes
FTP: Uploading file: api-82.jar, Transferred: 9216 bytes
FTP: Uploading file: api-82.jar, Transferred: 10240 bytes
FTP: Uploading file: api-82.jar, Transferred: 11264 bytes
FTP: Uploading file: api-82.jar, Transferred: 12288 bytes
FTP: Uploading file: api-82.jar, Transferred: 13312 bytes
FTP: Uploading file: api-82.jar, Transferred: 14336 bytes
FTP: Uploading file: api-82.jar, Transferred: 15360 bytes
FTP: Uploading file: api-82.jar, Transferred: 16384 bytes
FTP: Uploading file: api-82.jar, Transferred: 17408 bytes
FTP: Uploading file: api-82.jar, Transferred: 18432 bytes
FTP: Uploading file: api-82.jar, Transferred: 19456 bytes
FTP: Uploading file: api-82.jar, Transferred: 20480 bytes
FTP: Uploading file: api-82.jar, Transferred: 21504 bytes
FTP: Uploading file: api-82.jar, Transferred: 22528 bytes
FTP: Uploading file: api-82.jar, Transferred: 23552 bytes
FTP: Uploading file: api-82.jar, Transferred: 24576 bytes
FTP: Uploading file: api-82.jar, Transferred: 25478 bytes
FTP: Transfer completed successfully. 
FTP: Free space changed. Free: 1261568 bytes, Total: 10240000 bytes.
FTP: Free space changed. Free: 3510272 bytes, Total: 10240000 bytes.
FTP: Free space changed. Free: 10211328 bytes, Total: 10240000 bytes.

Analizziamo l’output:

riga 7: si collega il client;
dalla 8 alla 35: trasferimento in corso e conclusione;
righe 37-38: variazione dello spazio libero dopo la cancellazione dei file.

Piattaforme supportate

La libreria MultiFTPServer supporta le seguenti piattaforme:

Piattaforma	Tipo di rete	Storage predefinito
ESP8266	Wi-Fi, Ethernet	SPIFFS, SPI Flash, LittleFS, SD
ESP32	Wi-Fi, Ethernet	SPIFFS, SPI Flash, LittleFS, FFat, SD
Arduino	Ethernet, WiFiNINA, Wi-Fi, Wi-Fi esterna	SD, SPI Flash, SdFat1, SdFat2
STM32	Ethernet, Wi-Fi esterna	SPI Flash, SdFat2
Raspberry Pi Pico	Ethernet, Wi-Fi (RP2040), Wi-Fi esterna	LittleFS, SPI Flash, SdFat2, SD

Configura il client

Quando configuri il tuo client, presta attenzione al campo “Numero massimo di connessioni”: deve coincidere con il valore definito nella libreria.

Io uso FileZilla: puoi scaricarlo qui; è semplice da configurare.

Configurazione FileZilla per l’accesso all’ESP8266: seleziona FTP puro

Vai in Gestisci siti → Nuovo sito e imposta questi parametri:

Seleziona FTP come protocollo;
Scegli Usa FTP in chiaro (non sicuro);
Inserisci utente e password (scelti nello sketch);
Nella scheda Impostazioni di trasferimento imposta Numero massimo di connessioni a 1;
Ora collega il client al dispositivo.