init

Author: JAndrassy

LICENSE

@@ -0,0 +1,23 @@
+
+## EthernetEspAT library
+
+This library creates standard Arduino Ethernet networking API over ESP8266 or ESP32 AT commands. The Arduino Ethernet networking API was established by Arduino Ethernet library.
+
+EthernetEspAT extends the [WiFiEspAT](https://github.com/JAndrassy/WiFiEspAT) library with Ethernet object and Ethernet named aliases for WiFiClient, WiFiUDP and WiFiServer from WiFiEspAT.
+
+The library is for all Arduino MCU architectures. It enables secure connection (https) over wired network even for 8-bit architecture boards.
+
+### AT firmware with Ethernet support
+
+Standard AT firmware builds by Espressif don't support Ethernet.
+
+ESP32 AT firmware supports Ethernet commands but they have to be [enabled](https://docs.espressif.com/projects/esp-at/en/latest/esp32/Compile_and_Develop/How_to_enable_ESP_AT_Ethernet.html) in build configuration and build from sources.
+
+The ESP32 AT firmware source only supports Ethernet PHY modules: LAN8720, IP101, DP83848 and RTL8201. A modified AT firmware supporting W5500 will be available soon.
+
+ESP8266 AT firmware by Espressif doesn't support Ethernet. Jiri Bilek's [ESP_ATMod firmware](https://github.com/JiriBilek/ESP_ATMod#description) for ESP8266 will support Ethernet with Ethernet chips supported by the ESP8266 Arduino platform.
+
+* [ESP32 AT firmware binaries with Ethernet support](https://github.com/Networking-for-Arduino/EthernetEspAT/wiki/ESP32-firmware)
+* [esp8266 ESP_ATMod sketch with Ethernet support](https://github.com/JAndrassy/ESP_ATMod/tree/ethernet_support)
+
+For installing and testing the AT firmware see the WiFiEspAT [documentation](https://github.com/JAndrassy/WiFiEspAT?tab=readme-ov-file#getting-started).

README.md

@@ -0,0 +1,31 @@
+
+#include <EthernetEspAT.h>
+
+// Emulate Serial1 on pins 6/7 if not present
+#if defined(ARDUINO_ARCH_AVR) && !defined(HAVE_HWSERIAL1)
+#include <SoftwareSerial.h>
+SoftwareSerial Serial1(6, 7); // RX, TX
+#define AT_BAUD_RATE 9600
+#else
+#define AT_BAUD_RATE 115200
+#endif
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial);
+
+  Serial1.begin(AT_BAUD_RATE);
+  if (!Ethernet.init(Serial1)) {
+    Serial.println();
+    Serial.println("Communication with the network module failed!");
+    // don't continue
+    while (true);
+  }
+
+  Ethernet.wifiOff(true);
+
+}
+
+void loop() {
+  Ethernet.maintain();
+}

examples/Tools/PermanentWiFiOff/PermanentWiFiOff.ino

@@ -0,0 +1,93 @@
+/*
+  Web client
+
+ This sketch connects to a website (http://arduino.cc)
+ using the Ethernet module.
+
+ created 13 July 2010
+ by dlf (Metodo2 srl)
+ modified 31 May 2012
+ by Tom Igoe
+ modified in Jul 2019 for WiFiEspAT library
+ modified in Jul 2024 for EthernetEspAT library
+ by Juraj Andrassy https://github.com/jandrassy
+ */
+
+#include <EthernetEspAT.h>
+
+// Emulate Serial1 on pins 6/7 if not present
+#if defined(ARDUINO_ARCH_AVR) && !defined(HAVE_HWSERIAL1)
+#include <SoftwareSerial.h>
+SoftwareSerial Serial1(6, 7); // RX, TX
+#define AT_BAUD_RATE 9600
+#else
+#define AT_BAUD_RATE 115200
+#endif
+
+const char* server = "arduino.tips";
+
+// Set the static IP address to use if the DHCP fails to assign
+IPAddress ip(192, 168, 0, 177);
+
+EthernetClient client;
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial);
+
+  Serial1.begin(AT_BAUD_RATE);
+  Ethernet.init(Serial1);
+
+  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
+    Serial.println();
+    Serial.println("Communication with the network module failed!");
+    // don't continue
+    while (true);
+  }
+
+  // start the Ethernet connection:
+  Serial.println("Initialize Ethernet with DHCP:");
+  if (Ethernet.begin() == 0) {
+    Serial.println("Failed to configure Ethernet using DHCP");
+    if (Ethernet.linkStatus() == LinkOFF) {
+      Serial.println("Ethernet cable is not connected.");
+    }
+    // try to configure using IP address instead of DHCP:
+    Ethernet.begin(ip);
+  } else {
+    Serial.print("  DHCP assigned IP ");
+    Serial.println(Ethernet.localIP());
+  }
+
+  Serial.println("Starting connection to server...");
+  if (client.connect(server, 80)) {
+    Serial.println("connected to server");
+
+    client.println("GET /asciilogo.txt HTTP/1.1");
+    client.print("Host: ");
+    client.println(server);
+    client.println("Connection: close");
+    client.println();
+    client.flush();
+  }
+}
+
+void loop() {
+
+  // if there are incoming bytes available
+  // from the server, read them and print them
+  while (client.available()) {
+    char c = client.read();
+    Serial.write(c);
+  }
+
+  // if the server's disconnected, stop the client
+  if (!client.connected()) {
+    Serial.println();
+    Serial.println("disconnecting from server.");
+    client.stop();
+
+    // do nothing forevermore
+    while (true);
+  }
+}

examples/WebClient/WebClient.ino

@@ -0,0 +1,12 @@
+name=EthernetEspAT
+version=1.0.0
+author=Juraj Andrassy
+maintainer=Juraj Andrassy <[email protected]>
+sentence=Enables wired (secure) network connection with esp8266 or esp32 as network adapter on Serial interface.
+paragraph=This library creates standard Arduino Ethernet networking API over ESP AT commands. It works with WiFiEspAT library and enables to use WiFi and Ethernet in one sketch. Especially for AVR based boards it allows to use secure layer comunication over wired network. The library requires AT firmware built with Ethernet support.
+category=Communication
+url=https://github.com/Networking-for-Arduino/EthernetEspAT
+architectures=*
+includes=EthernetEspAT.h
+dot_a_linkage=true
+depends=WiFiEspAT

library.properties

@@ -0,0 +1,225 @@
+/*
+  This file is part of the EthernetEspAT library for Arduino
+  https://github.com/Networking-for-Arduino/EthernetEspAT
+  Copyright 2024 Juraj Andrassy
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "Ethernet.h"
+#include <utility/EspAtDrv.h>
+
+// these statics are removed by compiler, if not used
+char EthernetClass::fwVersion[15] = {0};
+char EthernetClass::name[33] = {0}; // hostname
+
+EthernetClass::EthernetClass() {
+}
+
+bool EthernetClass::init(Stream& serial, int8_t resetPin) {
+  bool ok = EspAtDrv.init(&serial, resetPin);
+  if (ok) {
+    hwStatus = EthernetHardwareFound;
+  }
+  return ok;
+}
+
+bool EthernetClass::setPersistent(bool persistent) {
+  return EspAtDrv.sysPersistent(persistent);
+}
+
+int EthernetClass::begin(uint8_t *mac, unsigned long timeout) {
+  if (mac != nullptr && !EspAtDrv.ethSetMac(mac))
+    return 0;
+  if (!EspAtDrv.ethEnableDHCP())
+    return false;
+  if (timeout) {
+    const unsigned long start = millis();
+    while ((millis() - start) < timeout) {
+      if (localIP() != INADDR_NONE)
+        return true;
+      delay(200);
+    }
+  }
+  return (localIP() != INADDR_NONE);
+}
+
+bool EthernetClass::begin(uint8_t *mac, IPAddress localIP, IPAddress dnsIP, IPAddress gatewayIP, IPAddress netmask) {
+  (void) mac;
+  if (dnsIP == INADDR_NONE) {
+    dnsIP = localIP;
+    dnsIP[3] = 1;
+  }
+  return EspAtDrv.ethStaticIp(localIP, gatewayIP, netmask) && setDNS(dnsIP);
+}
+
+int EthernetClass::begin(unsigned long timeout) {
+  return begin(nullptr, timeout);
+}
+
+bool EthernetClass::begin(IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet) {
+  return begin(nullptr, ip, dns, gateway, subnet);
+}
+
+int EthernetClass::maintain() {
+  EspAtDrv.maintain();
+  return 0;
+}
+
+void EthernetClass::end() {
+
+}
+
+EthernetLinkStatus EthernetClass::linkStatus() {
+  return EspAtDrv.ethStatus() ? LinkON : LinkOFF;
+}
+
+EthernetHardwareStatus EthernetClass::hardwareStatus() {
+  return hwStatus;
+}
+
+void EthernetClass::MACAddress(uint8_t *mac) {
+  macAddress(mac);
+}
+
+IPAddress EthernetClass::dnsServerIP() {
+  return dnsIP();
+}
+
+void EthernetClass::setDnsServerIP(const IPAddress dns) {
+  setDNS(dns);
+}
+
+bool EthernetClass::setDNS(IPAddress dns_server1, IPAddress dns_server2) {
+  return EspAtDrv.setDNS(dns_server1, dns_server2);
+}
+
+bool EthernetClass::setHostname(const char* name) {
+  return EspAtDrv.setEthHostname(name);
+}
+
+const char* EthernetClass::hostname(char* buffer) {
+  if (!EspAtDrv.ethHostnameQuery(buffer)) {
+    buffer[0] = 0;
+  }
+  return buffer;
+}
+
+uint8_t* EthernetClass::macAddress(uint8_t* mac) {
+  if (!EspAtDrv.ethMacQuery(mac))
+    return nullptr;
+  return mac;
+}
+
+IPAddress EthernetClass::localIP() {
+  IPAddress ip;
+  IPAddress gw;
+  IPAddress mask;
+  EspAtDrv.ethIpQuery(ip, gw, mask);
+  return ip;
+}
+
+IPAddress EthernetClass::gatewayIP() {
+  IPAddress ip;
+  IPAddress gw;
+  IPAddress mask;
+  EspAtDrv.ethIpQuery(ip, gw, mask);
+  return gw;
+}
+
+IPAddress EthernetClass::subnetMask() {
+  IPAddress ip;
+  IPAddress gw;
+  IPAddress mask;
+  EspAtDrv.ethIpQuery(ip, gw, mask);
+  return mask;
+}
+
+IPAddress EthernetClass::dnsIP(int n) {
+  IPAddress dns1;
+  IPAddress dns2;
+  EspAtDrv.dnsQuery(dns1, dns2);
+  switch (n) {
+    case 0:
+      return dns1;
+    case 1:
+      return dns2;
+  }
+  return IPAddress(0, 0, 0, 0);
+}
+
+bool EthernetClass::dhcpIsEnabled() {
+  bool sta;
+  bool ap;
+  bool eth;
+  if (!EspAtDrv.dhcpStateQuery(sta, ap, eth))
+    return false;
+  return eth;
+}
+
+
+bool EthernetClass::startMDNS(const char* hostname, const char* serverName, uint16_t serverPort) {
+  return EspAtDrv.mDNS(hostname, serverName, serverPort);
+}
+
+bool EthernetClass::hostByName(const char* hostname, IPAddress& result) {
+  return EspAtDrv.resolve(hostname, result);
+}
+
+bool EthernetClass::ping(const char* hostname) {
+  return EspAtDrv.ping(hostname);
+}
+
+bool EthernetClass::ping(IPAddress ip) {
+  char s[16];
+  EspAtDrv.ip2str(ip, s);
+  return ping(s);
+}
+
+bool EthernetClass::sntp(const char* server1, const char* server2) {
+  return EspAtDrv.sntpCfg(server1, server2);
+}
+
+unsigned long EthernetClass::getTime() {
+  return EspAtDrv.sntpTime();
+}
+
+const char* EthernetClass::firmwareVersion(char* buffer) {
+  EspAtDrv.firmwareVersion(buffer);
+  return buffer;
+}
+
+EspAtDrvError EthernetClass::getLastDriverError() {
+  return EspAtDrv.getLastErrorCode();
+}
+
+bool EthernetClass::sleepMode(EspAtSleepMode mode) {
+  return EspAtDrv.sleepMode(mode);
+}
+
+bool EthernetClass::deepSleep() {
+  return EspAtDrv.deepSleep();
+}
+
+bool EthernetClass::reset(uint8_t resetPin) {
+  return EspAtDrv.reset(resetPin);
+}
+
+bool EthernetClass::wifiOff(bool save) {
+  return EspAtDrv.wifiOff(save);
+}
+
+
+EthernetClass Ethernet;