init

Author: JAndrassy

LICENSE

@@ -0,0 +1,81 @@
+
+# Arduino Networking API Helper classes library
+
+A library to support Arduino Networking libraries development. It accompanies the [Arduino Networking API usage guidelines](https://github.com/JAndrassy/Arduino-Networking-API/blob/main/ArduinoNetAPIDev.md).
+
+The purpose of this library is to help networking library developers to ensure that their library can be used as a replacement of existing Arduino networking libraries and to simplify development of the Arduino Networking API in their library.
+
+_This library is still in development_
+
+## MACAddress
+
+The class MACAddress works similar as the well known IPAddress class from Arduino Core.
+
+It is compatible with an uint8_t array, implements Printable, can be parsed from string and formated to string.
+
+Some existing libraries return the byte array with values in reversed order. Method reverse() reverses the order of bytes in an MACAddress object.
+
+## Tests
+
+### Tests for the WiFi object
+
+Every WiFi library should be able to run the WiFiTest and WiFiScanNetworks sketches with no or minimal modifications.
+
+
+### Tests for the Ethernet object
+
+The LegacyEthernetTest has what would be good to have in a classic Ethernet library. But even the Ethernet library dosn't run it without modifications.
+
+A future ModernEtherneTest is will test Ethernet libraries with API aligned with WiFi libraries, especially method `config` for static IP configuration.
+
+### Tests for server implementation
+
+* AdvancedChatServer - example and test for server.accept()
+* PagerServer - example and test for server.available() and print-to-all-clients 
+
+## Server Helpers
+
+### ServerNew
+
+ServerNew is an abstract class template with all pure virtual functions. It helps to code a modern Server class with accept(), begin(port), end() and operator bool. It is not useful at runtime and takes same memory so eventually remove it from the published version of your networking library.
+
+ServerNew is what users ask and old Arduino Server implementations don't have.
+
+Usage:
+```
+#include <ServerNew.h>
+#include "EthernetClient.h"
+
+class EthernetServer
+  : public ServerNew<EthernetClient>
+{
+
+public:
+...
+```
+
+
+### ServerTemplate
+
+ServerTemplate implements method available() and print-to-all-clients using accept() method of a class from which it inherits. It is a template with Server type and Client type as template parameters.
+
+Implement a ServerNew realization, don't inherit it from Server or Print. Name it EthernetServerNew or WiFiServerNew. Then define EthernetServer/WiFiServer in your library as 
+```
+typedef ServerTemplate<EthernetServerNew, EthernetClient> EthernetServer;
+```
+or
+```
+typedef ServerTemplate<WiFiServerNew, WiFiClient> WiFiServer;
+```
+
+This way your library will have a legacy Arduino Server.
+
+ServerTemplate is configurable with some #defines. See the header file for the details.
+
+Note: ServerTemplate requires a proper implementation of the Client class.
+
+### ArduinoWiFiSever/ArduinoEthernetServer
+
+The ArduinoWiFiSever and ArduinoEthernetServer use ServerTemplate to implement server class with proper available() and print-to-all-clients for some existing libraries where the WiFiServer/EthernetServer doesn't have it.
+
+

README.md

@@ -0,0 +1,95 @@
+/*
+ Advanced Chat Server - server.accept() demo/test
+
+ A more advanced server that distributes any incoming messages
+ to all connected clients but the client the message comes from.
+ To use, telnet to your device's IP address and type.
+ You can see the client's input in the serial monitor as well.
+*/
+
+#include <Ethernet.h>
+
+// Enter a MAC address and IP address for your controller below.
+// The IP address will be dependent on your local network.
+// gateway and subnet are optional:
+byte mac[] = {
+  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
+};
+
+// telnet defaults to port 23
+EthernetServer server(23);
+
+EthernetClient clients[8];
+
+void setup() {
+
+  // initialize the Ethernet device
+  Ethernet.init(10);
+  Ethernet.begin(mac);
+
+  // Open serial communications and wait for port to open:
+  Serial.begin(115200);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+  // Check for Ethernet hardware present
+  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
+    Serial.println("Ethernet shield was not found.  Sorry, can't run without hardware. :(");
+    while (true) {
+      delay(1); // do nothing, no point running without Ethernet hardware
+    }
+  }
+  if (Ethernet.linkStatus() == LinkOFF) {
+    Serial.println("Ethernet cable is not connected.");
+  }
+
+  // start listening for clients
+  server.begin();
+
+  Serial.print("Chat server address:");
+  Serial.println(Ethernet.localIP());
+}
+
+void loop() {
+  // check for any new client connecting, and say hello (before any incoming data)
+  EthernetClient newClient = server.accept();
+  if (newClient) {
+    for (byte i=0; i < 8; i++) {
+      if (!clients[i]) {
+        Serial.print("We have a new client #");
+        Serial.println(i);
+        newClient.print("Hello, client number: ");
+        newClient.println(i);
+        // Once we "accept", the client is no longer tracked by EthernetServer
+        // so we must store it into our list of clients
+        clients[i] = newClient;
+        break;
+      }
+    }
+  }
+
+  // check for incoming data from all clients
+  for (byte i=0; i < 8; i++) {
+    if (clients[i] && clients[i].available() > 0) {
+      // read bytes from a client
+      byte buffer[80];
+      int count = clients[i].read(buffer, 80);
+      // write the bytes to all other connected clients
+      for (byte j=0; j < 8; j++) {
+        if (j != i && clients[j].connected()) {
+          clients[j].write(buffer, count);
+        }
+      }
+    }
+  }
+
+  // stop any clients which disconnect
+  for (byte i=0; i < 8; i++) {
+    if (clients[i] && !clients[i].connected()) {
+      Serial.print("disconnect client #");
+      Serial.println(i);
+      clients[i].stop();
+    }
+  }
+}

examples/EthernetAdvancedChatServer/EthernetAdvancedChatServer.ino

@@ -0,0 +1,55 @@
+/*
+  Ethernet Pager Server - - server.available
+  and print-to-all-clients demo/test
+
+  The example is a simple server that echoes any incoming
+  messages to all connected clients. Connect two or more
+  telnet sessions to see how server.available() and
+  server.print() work.
+*/
+
+#include <Ethernet.h>
+
+#if (defined(ARDUINO_ARCH_MBED) && defined(MBEDSOCKETCLASS_H))
+// the EthernetServer in these libraries doesn't have print-to-all-clients and proper available()
+// so we use ArduinoEthernetServer, which configures the ServerTemplate for these platforms
+#include <NetApiHelpers.h>
+#include <ArduinoEthernetServer.h>
+
+ArduinoEthernetServer server(2323);
+
+#else
+
+EthernetServer server(2323);
+#endif
+
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+
+void setup() {
+
+  Serial.begin(115200);
+  while (!Serial);
+
+  Ethernet.begin(mac);
+
+  server.begin();
+
+  IPAddress ip = Ethernet.localIP();
+  Serial.println();
+  Serial.print("To access the server, connect with Telnet client to ");
+  Serial.print(ip);
+  Serial.println(" 2323");
+}
+
+void loop() {
+
+  EthernetClient client = server.available(); // returns first client which has data to read or a 'false' client
+  if (client) {                               // client is true only if it is connected and has data to read
+    String s = client.readStringUntil('\n');  // read the message incoming from one of the clients
+    s.trim();                                 // trim eventual \r
+    Serial.println(s);                        // print the message to Serial Monitor
+    client.print("echo: ");                   // this is only for the sending client
+    server.println(s);                        // send the message to all connected clients
+    server.flush();                           // flush the buffers
+  }
+}