#include <SPI.h>
#include <Ethernet.h>

// MAC address for your Ethernet Shield (find on the sticker on the back)
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// Initialize the Ethernet client library
// with the IP address and port of the server (port 80 is default for HTTP):
EthernetClient client;

void setup() {
    // Open serial communications and wait for the port to open:
    Serial.begin(9600);
    while (!Serial) {
        ; // wait for serial port to connect. Needed for native USB port only
    }

    // Start the Ethernet connection:
    Serial.println("Initializing Ethernet...");
    if (Ethernet.begin(mac) == 0) {
        Serial.println("Failed to configure Ethernet using DHCP");
        // No point in carrying on, so do nothing forevermore:
        while (true);
    }
    // Give the Ethernet shield a second to initialize:
    delay(1000);

    // Print the local IP address:
    Serial.print("My IP address: ");
    Serial.println(Ethernet.localIP());
}

void loop() {
    // Your network code here (if needed for further testing)
}

    

Step 3: Monitor the Serial Output

1. Open the Serial Monitor in the Arduino IDE (Tools > Serial Monitor) and set the baud rate to 9600.
2. Once the code runs, the Serial Monitor will display the assigned IP address or an error if the connection fails.
3. If you see the message "My IP address: xxx.xxx.xxx.xxx", where xxx.xxx.xxx.xxx is your local IP address, then your Ethernet shield is successfully connected to the network.

Step 4: Test Network Connectivity

Now, let's extend the test by connecting to a web server. You can try accessing a simple webpage or a network service. Modify the code below to connect to a website or IP address of your choice:

#include <SPI.h>
#include <Ethernet.h>

// MAC address for your Ethernet Shield
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// Server to connect to
char server[] = "www.example.com";  // Change this to a valid server

EthernetClient client;

void setup() {
    Serial.begin(9600);

    // Start Ethernet and request IP from DHCP
    if (Ethernet.begin(mac) == 0) {
        Serial.println("Failed to configure Ethernet using DHCP");
        while (true);
    }
    delay(1000);  // Allow time for Ethernet shield to initialize

    // Print IP Address
    Serial.print("My IP address: ");
    Serial.println(Ethernet.localIP());

    // Connect to server
    Serial.print("Connecting to ");
    Serial.println(server);
    if (client.connect(server, 80)) {
        Serial.println("Connected!");

        // Make a HTTP GET request:
        client.println("GET / HTTP/1.1");
        client.println("Host: www.example.com");
        client.println("Connection: close");
        client.println();
    } else {
        Serial.println("Connection failed.");
    }
}

void loop() {
    // If there are incoming bytes available from the server, read and print them:
    if (client.available()) {
        char c = client.read();
        Serial.print(c);
    }

    // If the server has disconnected, stop the client:
    if (!client.connected()) {
        Serial.println();
        Serial.println("Disconnecting.");
        client.stop();

        // Do nothing forevermore:
        while (true);
    }
}

    

Step 5: Check the Serial Monitor

Once the code is running, check the Serial Monitor. It should display the following:

• The IP address assigned to the Ethernet shield.
• A message indicating that it is attempting to connect to the server.
• If successful, it will display the server's response.
• If the connection fails, it will show "Connection failed".

File myFile;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ; // Wait for Serial port to connect.
  }

  if (!SD.begin(chipSelect)) {
    Serial.println("SD initialization failed!");
    return;
  }
  Serial.println("SD initialization successful.");

  // Open file for writing
  myFile = SD.open("test.txt", FILE_WRITE);

  // Write to the file
  if (myFile) {
    Serial.println("Writing to test.txt...");
    myFile.println("Hello, Arduino SD!");
    myFile.close();
    Serial.println("Writing done.");
  } else {
    Serial.println("Error opening file.");
  }
}
                
            

Reading from the SD Card:

void loop() {
  // Open file for reading
  myFile = SD.open("test.txt");
  if (myFile) {
    Serial.println("Reading from test.txt:");

    while (myFile.available()) {
      Serial.write(myFile.read());
    }
    myFile.close();
  } else {
    Serial.println("Error opening file.");
  }
  delay(5000);
}
                
            

Arduino as a Web Server with Ethernet Shield

Using an Ethernet Shield, you can easily transform your Arduino into a web server. This enables you to host a webpage that can control devices such as LEDs or monitor sensors. Follow this simple guide to set up your Arduino as a web server and access it from anywhere.

Hardware Requirements

• Arduino Uno (or any compatible Arduino model)
• Ethernet Shield
• Ethernet Cable
• LEDs or Sensors (optional)

Step 1: Connect the Ethernet Shield

First, attach the Ethernet Shield to your Arduino. Plug the Ethernet cable into the shield and connect the other end to your router.

Step 2: Write the Arduino Code

Next, upload the following sketch to your Arduino. This code sets up the web server on your Arduino and responds to incoming HTTP requests with a simple webpage.

// Include Ethernet library
#include 
#include 

// MAC address for Ethernet Shield
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
// Set the IP address of the Arduino (modify if necessary)
IPAddress ip(192, 168, 1, 177);

// Create an Ethernet server on port 80
EthernetServer server(80);

void setup() {
  // Start serial communication for debugging
  Serial.begin(9600);

  // Initialize the Ethernet device
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.println("Server is ready. IP address: ");
  Serial.println(Ethernet.localIP());
}

void loop() {
  // Listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("Client connected");
    // Read the HTTP request from the client
    String request = client.readStringUntil('\r');
    Serial.println(request);

    // Prepare and send the response
    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: text/html");
    client.println();
    client.println("");
    client.println("");
    client.println("
Arduino Web Server
");
    client.println("
Control LEDs or read sensor data here.
");
    client.println("");
    client.stop(); // Close the connection
    Serial.println("Client disconnected");
  }
}
  

Step 3: Accessing the Web Page Locally

Once the code is uploaded, open your browser and type in the IP address of your Arduino (e.g., http://192.168.1.177). This will display the simple webpage hosted by your Arduino.

Step 4: Accessing the Web Page Globally

To access your web server from outside your home network, you need to configure port forwarding on your router. Here’s how:

1. Log into your router's admin page by entering its IP address in your browser (usually 192.168.1.1).
2. Go to the port forwarding section.
3. Forward port 80 (or the port your server is running on) to the local IP of your Arduino (e.g., 192.168.1.177).
4. After saving the settings, you can access your Arduino web server by entering your public IP followed by the port number (e.g., http://your-public-ip:80).

You can find your public IP by searching "What is my IP" on Google.

Step 5: Optional - Using a Domain Name

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Upload Code to Arduino</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 20px;
        }
        input[type="file"] {
            margin: 10px 0;
        }
        button {
            padding: 10px 20px;
            font-size: 16px;
        }
    </style>
</head>
<body>
    <h1>Upload Code to Arduino</h1>
    <form id="uploadForm" action="upload.php" method="post" enctype="multipart/form-data">
        <input type="file" name="arduino_code" accept=".ino" required>
        <button type="submit">Upload Code</button>
    </form>
    <div id="status"></div>

    <script>
        const form = document.getElementById('uploadForm');
        form.onsubmit = function(e) {
            e.preventDefault(); // Prevent the default form submission
            const formData = new FormData(form);

            fetch('upload.php', {
                method: 'POST',
                body: formData
            })
            .then(response => response.text())
            .then(data => {
                document.getElementById('status').innerText = data;
            })
            .catch(error => {
                console.error('Error:', error);
                document.getElementById('status').innerText = 'Error uploading code.';
            });
        };
    </script>
</body>
</html>
    

Step 4: Create PHP Script to Handle Upload

Create a file named upload.php in the same directory with the following content:

<?php
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
    if (isset($_FILES['arduino_code']) && $_FILES['arduino_code']['error'] == 0) {
        $fileTmpPath = $_FILES['arduino_code']['tmp_name'];
        $fileName = $_FILES['arduino_code']['name'];
        $fileSize = $_FILES['arduino_code']['size'];
        $fileType = $_FILES['arduino_code']['type'];

        $allowedTypes = ['text/plain', 'application/octet-stream', 'application/x-arduino'];
        if (!in_array($fileType, $allowedTypes)) {
            echo "Error: Invalid file type.";
            exit;
        }

        $uploadFileDir = './uploads/';
        $dest_path = $uploadFileDir . $fileName;

        if (move_uploaded_file($fileTmpPath, $dest_path)) {
            echo "Code uploaded successfully: " . $fileName;
            // Optionally call the Arduino CLI to upload the code to the Arduino Uno over Ethernet.
            // shell_exec("arduino-cli upload -p /dev/ttyUSB0 --fqbn arduino:avr:uno $dest_path");
        } else {
            echo "Error moving the uploaded file.";
        }
    } else {
        echo "Error: " . $_FILES['arduino_code']['error'];
    }
} else {
    echo "Invalid request method.";
}
?>
    

Step 5: Set Up the Upload Directory

Create an uploads directory in your web server document root to store uploaded Arduino code files:

    mkdir /var/www/html/uploads
    sudo chown -R www-data:www-data /var/www/html/uploads
    

Step 6: Invoke Arduino CLI

To upload the code to the Arduino after it's uploaded to the server, use the Arduino CLI to upload the .ino file over Ethernet:

shell_exec("arduino-cli upload -p /dev/ttyUSB0 --fqbn arduino:avr $dest_path");
    

Step 7: Access the Web Interface

Navigate to your web server's IP address or domain name (e.g., http://your-server-ip/index.html) and use the upload form to upload Arduino code to the Uno.

Important Notes

• Ensure your Arduino CLI is properly configured with the correct board and port settings.
• For security, implement user authentication in a production environment.
• Test the process thoroughly before deploying.