Subversion Repositories ESP8266_P1_Meter

// SPDX-License-Identifier: LGPL-3.0-or-later

// Copyright 2016-2026 Hristo Gochkov, Mathieu Carbou, Emil Muratov, Will Miles

/*

  This example demonstrates how to create 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     "YourSSID"

#define WIFI_PASSWORD "YourPassword"

// This is the main asynchronous server object

AsyncServer *AsyncServerChargen = nullptr;

// This is the pointer to the single connected client

AsyncClient *AsyncClientChargen = nullptr;

// Tracks the current position in the pattern rotation for the Chargen protocol.

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();

  }

}

// Called periodically while the client is connected.

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);

}

// It handles errors that are not normal disconnections.

void handleClientError(void *arg, AsyncClient *client, int error) {

  // The error codes are defined in esp_err.h

  Serial.printf("Client error! Code: %d, Message: %s\n", error, client->errorToString(error));

  // If the client is the one we have stored, clean it up.

  if (AsyncClientChargen == client) {

    Serial.println("Cleaning up global client pointer due to error.");

    AsyncClientChargen = nullptr;

  }

  // We do not need to call "delete client" here because onDisconnect will do it.

  // If the error is critical, we will do it.

  if (client->connected()) {

    client->close();

  }

}

// 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.

  if (AsyncClientChargen == client) {

    AsyncClientChargen = nullptr;

  }

  delete client;

}

// 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.

  // Called when previously sent data is acknowledged by the client.

  // This is the core engine for continuous data transmission (Chargen).

  AsyncClientChargen->onAck(handleClientAck, nullptr);

  // Called periodically by the AsyncTCP task.

  // Serves as a backup to resume transmission if the buffer was full and the ACK wasn't received.

  AsyncClientChargen->onPoll(handleClientPoll, nullptr);

  // Called when a communication error (e.g., protocol failure or timeout) occurs.

  // Essential for cleaning up the global client pointer and preventing resource leaks.

  AsyncClientChargen->onError(handleClientError, nullptr);

  // Called when the client actively closes the connection or if a fatal error occurs.

  // Responsible for resetting the global client pointer and freeing memory.

  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.

}