example: Simplified version of a TCP Chargen server.

Author: jnovonj

examples/ChargenServer/ChargenServer.ino

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright 2025 Hristo Gochkov, Mathieu Carbou, Emil Muratov, Jorge Novo
+
+/*
+  This example demonstrates how to cretate a TCP Chargen server with the 
+  AsyncTCP library. Run on the remote computer:
+  
+    $ nc <IPAddressforESP32> 19
+  
+  it shows a continuous stream of characters like this:
+
+  #$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij
+  $%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk
+  %&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl
+  &'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm
+  '()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn
+  ()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno
+  )*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop
+  *+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq
+  +,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr
+
+  If the pattern shows broken your ESP32 is probably too busy to serve the
+  data or the network is congested.
+  
+*/
+
+#include <Arduino.h>
+#include <AsyncTCP.h>
+#include <WiFi.h>
+
+// The default TCP Chargen port number is 19, see RFC 864 (Character Generator Protocol)
+#define CHARGEN_PORT 19
+const size_t LINE_LENGTH = 72;
+
+// Full pattern of printable ASCII characters (95 characters)
+const char CHARGEN_PATTERN_FULL[] = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
+const size_t PATTERN_LENGTH_FULL = 95;
+
+#define WIFI_SSID     "Your_SSID"
+#define WIFI_PASSWORD "Your_PASSWORD"
+
+// --- Global state for a SINGLE client ---
+// This is the main asynchronous server object
+AsyncServer* AsyncServerChargen = nullptr;
+// This is the pointer to the single connected client
+AsyncClient* AsyncClientChargen= nullptr;
+// This is the pointer to the stream of data.
+size_t startIndex = 0;
+
+
+void makeAndSendLine();      // Forward declaration
+
+// --- Callback Functions ---
+
+// Called when the client acknowledges receiving data. We use this to send more.
+void handleClientAck(void* arg, AsyncClient* client, size_t len, uint32_t time) {
+    if (!client->disconnected() && client->space() > (LINE_LENGTH + 2)) {
+        makeAndSendLine(); // <--- ¡Aquí está la cadena!
+    }
+}
+
+// Called periodically while the client is connected.
+// This function has the correct signature for onPoll: void(void*, AsyncClient*).
+void handleClientPoll(void* arg, AsyncClient* client) {
+    // We can reuse the same logic as the ACK handler.
+    // Just try to send more data if there's space.
+    handleClientAck(arg, client, 0, 0);
+}
+
+// Called when the client disconnects.
+void handleClientDisconnect(void* arg, AsyncClient* client) {
+    Serial.println("Client disconnected.");
+    // Set the global client pointer to null to allow a new client to connect.
+    AsyncClientChargen = nullptr;
+}
+
+// Called when a new client tries to connect.
+void handleClient(void* arg, AsyncClient* client) {
+    // If there is already a client connected, reject the new one.
+    if (AsyncClientChargen) {
+        Serial.printf("New connection from %s rejected. Server is busy.\n", client->remoteIP().toString().c_str());
+        client->close();
+        return;
+    }
+
+    // Accept the new client.
+    Serial.printf("New client connected from %s\n", client->remoteIP().toString().c_str());
+    AsyncClientChargen = client;
+    startIndex = 0; // Reset pattern for the new client.
+
+    // Set up callbacks for the new client.
+    AsyncClientChargen->onAck(handleClientAck, nullptr);
+    // onPoll is a good backup to send data if the buffer was full.
+    AsyncClientChargen->onPoll(handleClientPoll, nullptr);
+    AsyncClientChargen->onDisconnect(handleClientDisconnect, nullptr);
+
+    // Start sending data immediately.
+    makeAndSendLine();
+}
+
+void makeAndSendLine() {
+    // Check if the client is valid and has enough space in its send buffer.
+    if (AsyncClientChargen && AsyncClientChargen->canSend() && AsyncClientChargen->space() >= (LINE_LENGTH + 2)) {
+        // Buffer for the line (72 characters + \r\n)
+        char lineBuffer[LINE_LENGTH + 2];
+
+        // 1. Construct the 72-character line using the rotating pattern.
+        for (size_t i = 0; i < LINE_LENGTH; i++) {
+            lineBuffer[i] = CHARGEN_PATTERN_FULL[(startIndex + i) % PATTERN_LENGTH_FULL];
+        }
+
+        // 2. Add the standard CHARGEN line terminator (\r\n).
+        lineBuffer[LINE_LENGTH] = '\r';
+        lineBuffer[LINE_LENGTH + 1] = '\n';
+
+        // 3. Write data to the socket.
+        AsyncClientChargen->write(lineBuffer, LINE_LENGTH + 2);
+
+        // 4. Advance the starting index for the next line (rotation).
+        startIndex = (startIndex + 1) % PATTERN_LENGTH_FULL;
+    }
+}
+
+// ---------------------- SETUP & LOOP ----------------------
+
+void setup() {
+    Serial.begin(115200);
+    while (!Serial) {
+        continue;
+    }
+    // Connecting to WiFi...
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    Serial.print("Connecting to WiFi...");
+    while (WiFi.status() != WL_CONNECTED) {
+      delay(500);
+      Serial.print(".");
+    }
+    Serial.println();
+
+    // Create the Async TCP Server
+    AsyncServerChargen = new AsyncServer(CHARGEN_PORT);
+    // Set up the callback for new client connections.
+    AsyncServerChargen->onClient(&handleClient, nullptr);
+    AsyncServerChargen->begin();
+    Serial.printf("Chargen Server (%s) started on port %d\n", WiFi.localIP().toString().c_str(), CHARGEN_PORT);
+}
+
+void loop() {
+    // The async library handles everything in the background.
+    // No code is needed here for the server to run.
+}