DHT22 (sensor) to Pachube via Arduino with Ethernet shield error

I'm trying to connect a DHT22 sensor to the Pachube online service. I am understanding the code and have everything wired up correctly but I get this error:

DHT22 Library Demo
Requesting data at 6335
Sync Timeout 

What does sync timeout mean? Is is a network problem? How could I fix this?

Here is my code anyway:

    /* Feed temperature and humidity to Pachube.
       Based on the following examples:
         Sample code from nethoncho's DHT22 library: 
           https://github.com/nethoncho/Arduino-DHT22
         Tom Igoe's PachubeClient: 
           http://arduino.cc/en/Tutorial/PachubeCient
     */
    #include <DHT22.h>
    #include <SPI.h>
    #include <Ethernet.h>

    // Data wire is plugged into port 7 on the Arduino
    // Connect a 4.7K resistor between VCC and the data pin (strong pullup)
    #define DHT22_PIN 2

    // Setup a DHT22 instance
    DHT22 myDHT22(DHT22_PIN);

    static unsigned long lWaitMillis;

    // assign a MAC address for the ethernet controller.
    // fill in your address here:
    byte mac[] = { 
      0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
    // assign an IP address for the controller:
    byte ip[] = { 
      192,168,0,30 };
    byte gateway[] = {
      192,168,1,2}; 
    byte subnet[] = { 
      255, 255, 255, 0 };

    //  The address of the server you want to connect to (pachube.com):
    byte server[] = { 
      173,203,98,29 };

    // initialize the library instance:
    Client client(server, 80);

    boolean lastConnected = false;      // state of the connection last time through the main loop
    const long postingInterval = 180000;  //delay between updates to Pachube.com

    int backoff = 0;

    void setup(void)
    {
      // start serial port
      Serial.begin(9600);
      Serial.println("DHT22 Library Demo");

      // start the ethernet connection:
      Ethernet.begin(mac, ip);

      // give the ethernet module time to boot up:
      delay(1000);

      lWaitMillis = mi开发者_开发问答llis() + 5000;
    }


    void loop() {

      // if there's incoming data from the net connection.
      // send it out the serial port.  This is for debugging
      // purposes only:
      if (client.available()) {
        char c = client.read();
        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) {
        Serial.println();
        Serial.println("disconnecting.");
        client.stop();
        while(client.status() != 0) {
          Serial.print("Client status: ");
          Serial.println(client.status());
          delay(5);
        } 
      }

      // if you're not connected, and ten seconds have passed since
      // your last connection, then connect again and send data:
      if(!client.connected() &&  (long)( millis() - lWaitMillis ) >= 0  ) {
        if (readData()) {
          int temp = myDHT22.getTemperatureC();
          int humidity = myDHT22.getHumidity() + .5;
          sendData(temp, humidity);
        }
        lWaitMillis += postingInterval;
        if (lWaitMillis < millis()) {
          lWaitMillis = millis() + postingInterval;
        }
        Serial.print("Next attempt at ");
        Serial.println(lWaitMillis);
        Serial.println();
      }

      // store the state of the connection for next time through
      // the loop:
      lastConnected = client.connected();

    }


    boolean readData()
    { 
      DHT22_ERROR_t errorCode;

      Serial.print("Requesting data at ");
      Serial.println(millis());
      errorCode = myDHT22.readData();
      switch(errorCode)
      {
      case DHT_ERROR_NONE:
        Serial.print("Got Data ");
        Serial.print(myDHT22.getTemperatureC());
        Serial.print("C ");
        Serial.print(myDHT22.getHumidity());
        Serial.println("%");
        return true;
        break;
      case DHT_ERROR_CHECKSUM:
        Serial.print("check sum error ");
        Serial.print(myDHT22.getTemperatureC());
        Serial.print("C ");
        Serial.print(myDHT22.getHumidity());
        Serial.println("%");
        break;
      case DHT_BUS_HUNG:
        Serial.println("BUS Hung ");
        break;
      case DHT_ERROR_NOT_PRESENT:
        Serial.println("Not Present ");
        break;
      case DHT_ERROR_ACK_TOO_LONG:
        Serial.println("ACK time out ");
        break;
      case DHT_ERROR_SYNC_TIMEOUT:
        Serial.println("Sync Timeout ");
        break;
      case DHT_ERROR_DATA_TIMEOUT:
        Serial.println("Data Timeout ");
        break;
      case DHT_ERROR_TOOQUICK:
        Serial.println("Polled too quick ");
        break;
      }
      return false;
    }


    // this method makes a HTTP connection to the server:
    void sendData(int temp, int humidity) {

      // if there's a successful connection:
      if (client.connect()) {

        backoff = 0;
        Serial.println("connecting...");
        // send the HTTP PUT request. 
        // fill in your feed address here:
        client.print("PUT /v2/feeds/36800.csv HTTP/1.1\n");
        client.print("Host: api.pachube.com\n");
        // fill in your Pachube API key here:
        client.print("X-PachubeApiKey: a6714b6a217827edadfd003843c03c259a08add554eda3871b844612eddc6819\n");
        client.print("Content-Length: ");

        // calculate the length of the sensor reading in bytes:
        int thisLength = 2 + getLength(temp) + 2 + 2 + getLength(humidity);
        client.println(thisLength, DEC);

        // last pieces of the HTTP PUT request:
        client.print("Content-Type: text/csv\n");
        client.println("Connection: close\n");

        // here's the actual content of the PUT request:
        client.print(0, DEC);
        client.print(",");
        client.println(temp, DEC);
        client.print(1, DEC);
        client.print(",");
        client.println(humidity, DEC);

      } 
      else {
        // if you couldn't make a connection:
        Serial.println("connection failed, resetting.");
        Ethernet.begin(mac, ip);
        delay(1000);
        client.stop();
        delay(1000);
      }
    }
    // This method calculates the number of digits in the
    // sensor reading.  Since each digit of the ASCII decimal
    // representation is a byte, the number of digits equals
    // the number of bytes:

    int getLength(int someValue) {
      // there's at least one byte:
      int digits = 1;
      // continually divide the value by ten, 
      // adding one to the digit count for each
      // time you divide, until you're at 0:
      int dividend = someValue /10;
      while (dividend > 0) {
        dividend = dividend /10;
        digits++;
      }
      // return the number of digits:
      return digits;
    }

You're running into DHT_ERROR_SYNC_TIMEOUT sensor error, that means that the DHT sensor is running into some sync problem, I guess.

What arduino are you using? Is your board's frequence 8 or 16Mhz?

Give a try to the edit described here, too. If it still doesn't work, I would try using sensor itself (i.e. without connecting to patchube) with some test sketch you can easily find for DHT22, just to make sure the sensor is working properly.

I had similar problem when using Arduino Nano v3.0 + ENC28J60 Ethernet shield. I tried to connect RF receiver to digital PIN #2 but this never worked.

Then I used different pin for the RF module (PIN #4 in my case) and everything worked fine.