Arduino Ethernet w5100 Probleme mit DHCP

Wer einen Arduino mit Ethernet Shield w5100 betreibt kann in die Situation kommen das bei DHCP durch den Router keine IP vergeben wird.  

Ein Auslesen per seriellen Monitor gibt oft die Meldung IP 0.0.0.0 zurück.

Einer der häufigsten Fehler der mir unter die Finger kommt, sind Router oder Switch die nicht mir der Arduino MAC klar kommen.

Mehr hierzu gibt es wie üblich in der Wiki.

Der Arduino und das Ethernet Shield

Inhaltsverzeichnis WordPress

Von Haus aus kommt der Arduino Uno ohne eine Netzwerklösung daher. Dies kann man recht einfach mit einem Arduino Ethernet Shield aendern. Einfach aufstecken und der Arduino hat eine LAN Anschluss.

Damit nun der Arduino in deinem Netzwerk funktioniert bedarf es noch einem Sketch.

Dank dem gut Dokumentierten Arduino Projekt gibt es auch gute Ethernet Libray’s.

Arduino LAN Sketch

/*
 Web Server
  */
 
// Diese beide Libraries sind erforderlich
#include <SPI.h>
#include <Ethernet.h>
 
/*
Hier die MAC Adresse des Shields eingeben
Meistens gibt es einen Aufkleber auf der Rückseite des Shields
*/
byte mac[] = { 
 0x90, 0xA2, 0xDA, 0x00, 0xFB, 0x80 };
 
/*
Nun noch eine freie IP auf aus deinem Netzwerk angeben. Dazu
ist es am einfachsten die IP des Rechners auszulesen.
ifconfig ist hier das Stichwort.
*/ 
IPAddress ip(192,168,1,177);
 
// Ethernet Library als Server initialisieren
// Verwendet IPAdress und den Port 80 für http
EthernetServer server(80);
 
void setup() {
 /*
Serielle Kommunikation starten 
*/
 Serial.begin(9600);
 
 // Ethernet Verbindung und Server starten
 Ethernet.begin(mac, ip);
 server.begin();
 Serial.print("Server gestartet. IP: ");
 // IP des Arduino-Servers ausgeben
 Serial.println(Ethernet.localIP());
}
 
 
void loop() {
/*
server.available() schaut, ob ein Client verfügbar ist und Daten
an den Server schicken möchte. Gibt dann eine Client-Objekt zurück, sonst false
*/
 EthernetClient client = server.available();
 
// Wenn es einen Client gibt, dann...
 if (client) {
 Serial.println("Neuer Client");

/*
Jetzt solange Zeichen lesen, bis eine leere Zeile empfangen wurde
HTTP Requests enden immer mit einer leeren Zeile 
*/
 boolean currentLineIsBlank = true;
 // Solange Client verbunden 
 while (client.connected()) {
 // client.available() gibt die Anzahl der Zeichen zurück, die zum Lesen
 // verfügbar sind
 if (client.available()) {
 // Ein Zeichen lesen und am seriellen Monitor ausgeben
 char c = client.read();
 Serial.write(c);
 // In currentLineIsBlank merken wir uns, ob diese Zeile bisher leer war.
/*
Wenn die Zeile leer ist und ein Zeilenwechsel (das \n) kommt,
dann ist die Anfrage zu Ende und wir können antworten
*/
 if (c == '\n' && currentLineIsBlank) {
 // HTTP Header 200 an den Browser schicken
 client.println("HTTP/1.1 200 OK");
 client.println("Content-Type: text/html");
 client.println("Connection: close"); // Verbindung wird nach Antwort beendet
 client.println("Refresh: 2"); // Seite alle 25 Sekunden neu abfragen
 client.println();
 // Ab hier berginnt der HTML-Code, der an den Browser geschickt wird
 client.println("<!DOCTYPE HTML>");
 client.println("<html>");
 client.print("Analogpin 0: <b>");
 client.print(analogRead(A0));
 client.println("</b><br />"); 
 client.println("</html>");
 break;
 }
 if (c == '\n') {
 // Zeilenwechsel, also currentLineIsBlack erstmal auf True setzen
 currentLineIsBlank = true;
 } 
 else if (c != '\r') {
 // Zeile enthält Zeichen, also currentLineIsBlack auf False setzen
 currentLineIsBlank = false;
 }
 }
 }
 // Kleine Pause
 delay(1);
 // Verbindung schliessen
 client.stop();
 Serial.println("Verbindung mit Client beendet.");
 Serial.println("");
 }
}

Ein Arduino sendet PUSH Nachrichten

Wenn man einem Arduino ein Ethernet Shield spendiert ist dieser im Netzwerk ansprechbar. Aber außer ein par Sensoren zu betreiben und LEDs an und aus zu schalten kann er auch PUSH Meldungen senden.



Als erstes benötigt man einen Account bei einem PUSH Dienst. In meinem Beispiel verwende ich den Dienst pushingbox.com.

Weil es den Rahmen hier sprengen würde die vielen Möglichkeiten des Dienstes zu erklären hier ein kleines Video für den „Erstkontakt“.

Nun kann man im Bereich API sich den Sketch für einen Arduino ansehen.

https://www.pushingbox.com/api.php

Hier nun mal der Sketch von pushingbox.com (Stand 2018)

////
//
// General code from http://www.pushingbox.com for Arduino + Ethernet Shield (official) v1.2
//
////

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

  /////////////////
 // MODIFY HERE //
/////////////////
byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x19 };   // Be sure this address is unique in your network

//Your secret DevID from PushingBox.com. You can use multiple DevID  on multiple Pin if you want
char DEVID1[] = "Your_DevID_Here";        //Scenario : "The mailbox is open"

//Numeric Pin where you connect your switch
uint8_t pinDevid1 = 3; // Example : the mailbox switch is connect to the Pin 3

// Debug mode
boolean DEBUG = true;
  //////////////
 //   End    //
//////////////


char serverName[] = "api.pushingbox.com";
boolean pinDevid1State = false;                // Save the last state of the Pin for DEVID1
boolean lastConnected = false;                 // State of the connection last time through the main loop


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

void setup() {
  Serial.begin(9600);
  pinMode(pinDevid1, INPUT);
  
  // start the Ethernet connection:
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // no point in carrying on, so do nothing forevermore:
    while(true);
  }
  else{
    Serial.println("Ethernet ready");
    // print the Ethernet board/shield's IP address:
    Serial.print("My IP address: ");
    Serial.println(Ethernet.localIP());
  }
  // give the Ethernet shield a second to initialize:
  delay(1000);
}

void loop()
{
      ////
      // Listening for the pinDevid1 state
      ////
      if (digitalRead(pinDevid1) == HIGH && pinDevid1State == false) // switch on pinDevid1 is ON 
      {
        if(DEBUG){Serial.println("pinDevid1 is HIGH");}
        pinDevid1State = true;
        //Sending request to PushingBox when the pin is HIGH
        sendToPushingBox(DEVID1);
      }
       if (digitalRead(pinDevid1) == LOW && pinDevid1State == true) // switch on pinDevid1 is OFF
      {
        if(DEBUG){Serial.println("pinDevid1 is LOW");}
        pinDevid1State = false;
        //Sending request to PushingBox when the pin is LOW
        //sendToPushingBox(DEVID1);    //Here you can run an other scenario by creating a DEVID2 variable
      }
      
      
      //DEBUG part
      // this write the respons from PushingBox Server.
      // You should see a "200 OK"
      if (client.available()) {
        char c = client.read();
        if(DEBUG){Serial.print(c);}
      }
      
      // if there's no net connection, but there was one last time
      // through the loop, then stop the client:
      if (!client.connected() && lastConnected) {
        if(DEBUG){Serial.println();}
        if(DEBUG){Serial.println("disconnecting.");}
        client.stop();
      }
      lastConnected = client.connected();
}


//Function for sending the request to PushingBox
void sendToPushingBox(char devid[]){
  client.stop();
  if(DEBUG){Serial.println("connecting...");}

  if (client.connect(serverName, 80)) {
    if(DEBUG){Serial.println("connected");}

    if(DEBUG){Serial.println("sendind request");}
    client.print("GET /pushingbox?devid=");
    client.print(devid);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.println(serverName);
    client.println("User-Agent: Arduino");
    client.println();
  } 
  else {
    if(DEBUG){Serial.println("connection failed");}
  }
}

So, nun nur noch deine „Your_DevID_Here“ ändern. Diese kannst du unter „My Service“ neu anlegen.

In meinem Beispiel twittert nun der Arduino bei einem Ereigniss am PIN3.
Natürlich kann man auch einen entsprechenden Dienst aussuchen um eine PUSH Nachricht auf dein Handy zu bekommen.

So einfach ….