1-Digit 0.56 inch LED, 7-segments, common-anode (pack 5 pcs) Angle Front

Leonardo ETH, ATmega32U4 Ethernet W5500 (V2)

Nano V3 Ethernet Shield - W5500 (V3) with Passive PoE

Nano V3 Ethernet Shield - W5500 (V3) with Passive PoE

MEGA 2560 ETH, R3, with PoE, ATmega2560+W5500, Micro-SD card reader, USB-UART CP2104

RobotDyn MEGA 2560 ETH R3 is an excellent choice for a controlled-over-the-Net device or a multi-functional data collector.


Availability: Out of stock

Product Overview

If you’re looking to build a network-connected device, RobotDyn MEGA 2560 ETH R3 with LAN and additional Wi-Fi connection, is the best solution use Arduino Mega 2560 R3 and Ethernet controller W5500 and with Wi-Fi module ESP-01!

RobotDyn MEGA 2560 ETH R3 is a fully featured Ethernet-connected device via LAN or Wi-Fi. Depending on your use case, it can act as a server or a net member. In a server role, it will receive requests from other devices and services in local network and internet, and respond or react accordingly. In a net member role, the RobotDyn MEGA 2560 ETH R3 can collect data from different devices or industrial equipment and send it through the local network or Internet. It can also receive data from local network and internet, and control connected devices and equipment. The RobotDyn MEGA 2560 ETH R3 can also act as stand-alone unit, providing autonomous reaction based on the defined algorithm in response to network changes or other triggers.

RobotDyn MEGA 2560 ETH R3 features 5 devices on one board:

  1. Mega 2560 based on an ATmega2560 with 70 I/O.
  2. Ethernet controller based on WizNet W5500 TCP/IP.
  3. Optional PoE function (receiving power directly through the Ethernet cable). Can select passive PoE or active (intellect) PoE.
  4. Micro SD card module.
  5. Additional Wi-Fi module ESP-01, based on ESP8266 microcontroller.

Ports and buses

RobotDyn MEGA 2560 ETH R3 has 70 input/output ports, 12 of which can be used for PWM, and 16 analog ports with 10-bits resolution (0 — 1023). The board is equipped with an RJ45, micro USB, DC power jack, and a reset button.

W5500 Ethernet

WizNet W5500 is a TCP/IP embedded LAN Ethernet controller. It provides TCP/IP Stack, 10BaseT/100BaseTX Ethernet with full or half-duplex, MAC and PHY. W5500 is using a highly efficient SPI protocol, with 80 MHz clocks for high-speed connectivity to Atmega2560. For lower energy consumption, W5500 provides WOL (Wake on LAN) and Power Off modes.

ESP-01 Wi-Fi

On board have socket for connecting Wi-Fi ESP-01 module. Wi-Fi module connecting to Serial3 interface via RX3(D15)/TX3(D14) I/O.

In Arduino code, for control a Wi-Fi module need to use Serial3 port.

Micro-SD card rider

The board also features the Micro SD card socket. The micro SD card can be used to save and store the data, which can later be transferred over the network. Digital port D4 (CS-CS2) of the ATmega2560 is dedicated to work with the micro SD. For card detect used D9, but you can cut off soldering pads for disconnect this function.

** Digital port D10 (SS-CS2) is used by WizNet W5500. The Ethernet controller and microSD card are connected through the SPI bus.

Programming in Arduino IDE

RobotDyn MEGA 2560 ETH R3 can be programmed via an Arduino IDE. Select Arduino Mega 2560 in the «Boards» menu, and use Ethernet3 / Ethernet4 library.

Power supply

RobotDyn MEGA 2560 ETH R3 can be powered via:

  • USB port (5V, 500mA);
  • DC-IN jack, PWC 2.1mm, (supporting 7-24V DC input voltage);
  • Through an Ethernet cable using PoE (Power over Ethernet) — requires PoE-enabled switch or a PoE injector.
    Note: PoE module is optional. There are several PoE options available, depending on the PoE equipment you use.

The Active PoE is compliant with 802.3af or 802.3at. It will check the power coming in, and, if it doesn’t meet the device requirements, it just won’t power up.

The Passive PoE is a simplified version that does not perform a handshake, so it is important to know what PoE voltage your device supplies requires before plugging in the Ethernet cable and powering it up. If you connect the wrong voltage you may cause permanent electrical damage to the device.

Make sure to select the correct board option with relevant PoE module.

Write Your Own Review
Only registered users can write reviews. Please Sign in or create an account
Fill in your delivery details to check available shipping options and calculate rates for this product. Total delivery fee for your order, you can find in cart.


MEGA 2560 ETH R3 with ATmega2560 & W5500

Input Voltage (VIN/DCВ jack) 7~12V
PowerВ IN (USB) 5V-limit 500mAВ 
PoE Type No PoE/Active PoE/Passive PoE
PowerВ IN (PoE) Optional module, 48V(Input), 9V(Output)
Digital I/O 54
PWM Output 12
Analog I/O 16
Reserved Pins
  • D4В is used forВ SD card select;
  • D10В is used for W5500 CS;
  • *Optional: D8В is used for W5500В interrupting, D7В is used for W5500 initialization, D9В is used forВ SD card detect
USB socket Micro-USB
Ethernet socket RJ45
PCB Size 53.35Г—101.61mm
Card Reader Micro SDВ card, with logic level convertor
Weight 63g

Mega MCU

Microcontroller ATmega2560(AVR 8-bit)
Operating Voltage 5VВ 
Memory Size 256KB
Clock Speed 16MHz

Ethernet MCU

Microcontroller Wiznet W5500
PHY compliance 10BaseT/100BaseTX Ethernet. Full and half duplexВ 
Operating Voltage 3.3V
Memory Internal 32Kbytes Memory for Tx/Rx Buffers
PHY Clock Speed 25MHz

Passive PoE(optional)

Ethernet Power (IN) 12~48V DC
Output DCВ 9V В 

Active PoE(optional)

Ethernet Power (IN) 12~48V DC
Output DCВ 12V


WiFI module ESP-01(ESP8266)
Reserved Pins
  • D14/TX3
  • D15/RX3

I/O defines on Mega ETH

For Ethernet W5500 Chipset:

  • D10 — SS (CS1)
  • D51 — MOSI
  • D50 — MISO
  • D52 — SCK
  • D8 — INT (select D8 with W5500-INT pin jumper, pin solder jumper at bottom layer, default: not connected)
  • D7/3.3V — RST (select D7 with W5500-RST pin solder jumper at the bottom layer, default: connected to 3.3V)

For SD card reader:

  • D4 — CS(CS2)
  • D9 – Card detect (pin solder jumper at bottom layer, default: not connected)
  • D51 — MOSI/DI
  • D50 — MISO/DO
  • D52 — SCK/CLK

NOTE: Both W5500 and SD card communicate with ATmega2560 via SPI bus. Pin D10 and pin D4 are chip Selection pins for W5500 and SD slot. They cannot be used as general I/O.


Steps for Arduino IDE:

  1. Select port: 


  1. Select board: 

  1. Please install the libraries:
    • SD.h — SD Library
    • SPI.h — SPI library
    • Ethernet.h/Ethernet2.h/ Ethernet3.h — Ethernet / Ethernet2 / Ethernet3 libraries

Copy below code into the sketch and then upload: 

  1. #include <Ethernet3.h>
  2. #include <SPI.h>
  4. #include <EEPROM.h>
  5. #include <SD.h>
  6. #define SS 10 //W5500 CS
  7. #define RST 7 //W5500 RST
  8. #define CS 4 //SD CS pin
  10. // enter MAC-address and IP-address of your controller below;
  11. // IP-address depends on your local network:
  12. byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
  13. char macstr[18];
  14. IPAddress ip(192,168,1,111);
  16. // initialize Ethernet Server library by designating a port
  17. // (default port for HTTP is «80»):
  18. EthernetServer server(80);
  20. // specifying a contact and default state for LED:
  21. String LED1State = "Off";
  22. const int LED = 13;
  24. // specifying variables for the client:
  25. char linebuf[80];
  26. int charcount=0;
  28. void eeprom_read()
  29. {
  30. if (EEPROM.read(1) == '#')
  31. {
  32. for (int i = 2; i < 6; i++)
  33. {
  34. mac[i] = EEPROM.read(i);
  35. }
  36. }
  37. }
  39. void eeprom_write()
  40. {
  41. EEPROM.write(1, '#');
  42. snprintf(macstr, 18, "%02x:%02x:%02x:%02x:%02x:%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
  43. }
  45. void setup() {
  46. // preparing LED-module:
  48. pinMode(LED_BUILTIN, OUTPUT);
  49. digitalWrite(LED_BUILTIN, HIGH);
  50. pinMode(SS, OUTPUT);
  51. pinMode(RST, OUTPUT);
  52. pinMode(CS, OUTPUT);
  53. digitalWrite(SS, LOW);
  54. digitalWrite(CS, HIGH);
  55. /* If you want to control Reset function of W5500 Ethernet controller */
  56. digitalWrite(RST,HIGH);
  58. pinMode(LED, OUTPUT);
  59. digitalWrite(LED, HIGH);
  61. // opening a sequential communication with 9600 baud speed:
  62. Serial.begin(9600);
  64. eeprom_read();
  65. eeprom_write();
  67. // initialising Ethernet-communication and server:
  68. Ethernet.begin(mac, ip);
  69. server.begin();
  70. Serial.print("server is at "); // "server at "
  71. Serial.println(Ethernet.localIP());
  72. Serial.println(Ethernet.macAddressReport());
  73. }
  75. // Displaying a webpage with a «ON/OFF» button for LED:
  76. void dashboardPage(EthernetClient &client) {
  77. client.println("<!DOCTYPE HTML><html><head>");
  78. client.println("<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"></head><body>");
  79. client.println("<h3>Arduino Web Server - <a href=\"/\">Refresh</a></h3>");
  80. client.println("<h3>local IP<h3>");
  81. client.println(Ethernet.localIP());
  82. client.println("<h3>");
  83. client.println("<h3>mac Address<h3>");
  84. client.println(Ethernet.macAddressReport());
  85. client.println("<h3>");
  86. client.println("<h3>TEXT<h3>");
  87. client.println("<section id=\"contact\"><div class=\"content\"><div id=\"form\"><form action=""id=\"contactForm\"method=\"GET\"><textarea class=\"message\"placeholder=\"Enter your message\"tabindex=4></textarea><input type=\"submit\"name=\"submit\"value=\"Send to Serial\"class=\"submit\"tabindex=5></form></div></section>");
  88. // generating a button to control LED:
  89. client.println("<h4>LED 13 - State: " + LED1State + "</h4>");
  90. // if LED is off, Displaying an «ON» button:
  91. if(LED1State == "Off"){
  92. client.println("<a href=\"/LED13on\"><button>ON</button></a>");
  93. }
  94. // if LED is on, Displaying an «OFF» button:
  95. else if(LED1State == "On"){
  96. client.println("<a href=\"/LED13off\"><button>OFF</button></a>");
  97. }
  98. client.println("</body></html>");
  99. }
  102. void loop() {
  103. // reading the incoming clients:
  104. EthernetClient client = server.available();
  105. if (client) {
  106. //Serial.print (client.read());
  107. //Serial.println("new client"); // "new client"
  108. memset(linebuf,0,sizeof(linebuf));
  109. charcount=0;
  110. // HTTP-request is ending with blank line:
  111. boolean currentLineIsBlank = true;
  112. while (client.connected()) {
  113. if (client.available()) {
  114. char c = client.read();
  115. // reading a HTTP-request, one symbol at a time:
  116. linebuf[charcount]=c;
  117. if (charcount<sizeof(linebuf)-1) charcount++;
  118. // if you reached the end of the line (i.e. if you recieved
  119. // symbol form a new line), it means that
  120. // HTTP-request is completed, and you can send the answer:
  122. if (c == '\n' && currentLineIsBlank) {
  123. dashboardPage(client);
  124. break;
  125. }
  127. if (c == '\n') {
  128. if (strstr(linebuf,"GET /id=") > 0)Serial.println(linebuf);
  129. if (strstr(linebuf,"GET /LED13off") > 0){
  130. digitalWrite(LED, HIGH);
  131. LED1State = "Off";
  132. }
  133. else if (strstr(linebuf,"GET /LED13on") > 0){
  134. digitalWrite(LED, LOW);
  135. LED1State = "On";
  136. }
  137. // if you recieved a symbol form a new line
  138. currentLineIsBlank = true;
  139. memset(linebuf,0,sizeof(linebuf));
  140. charcount=0;
  141. }
  142. else if (c != '\r') {
  143. // if you recieved any other symbol
  144. currentLineIsBlank = false;
  145. }
  146. }
  147. }
  148. // providing a time for a borwser to recieve the data:
  149. delay(1);
  150. // closing the connection:
  151. client.stop();
  152. //Serial.println("client disonnected"); // "Client is disconnected"
  153. }
  154. }



Dimensional drawing (DIM)

Size  MEGA 2560 ETH R3 with ATmega2560 & W5500 (Arduino-compatible board) Dimensional drawing (DIM)  MEGA 2560 ETH R3 with ATmega2560 & W5500 (Arduino-compatible board)

Input and Output (I/O) diagram

Input and Output (I/O) diagram I/O  MEGA 2560 ETH R3 with ATmega2560 & W5500 (Arduino-compatible board) Input and Output (I/O) diagram I/O  MEGA 2560 ETH R3 with ATmega2560 & W5500 (Arduino-compatible board)


Schematics  MEGA 2560 ETH R3 with ATmega2560 & W5500 (Arduino-compatible board)

Arduino Lib Ethernet3

Arduino Lib Ethernet3