Pachube sensor client

Hallo zusammen
habe den Sketch “Pachube sensor client” ausprobiert, funktioniert super im Originalzustand.
Habe dann den Analog sensor an analog in 0 durch einen Dallas I2C ersetzt.
Die Werte werden auch auf Patchube angezeigt, jedoch läuft das Programm jetzt extrem langsam.
Es werden nur alle 3 Minuten Daten gesendet.
Habe auch schon mal drei Dallas montiert, ist das gleiche.
Wenn Seriel Monitor aktiviert, wird etwa ein Zeichen pro Sekunde ausgegeben.

Wo liegt der Fehler

  Pachube sensor client
 This sketch connects an analog sensor to Pachube (
 using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
 the Adafruit Ethernet shield, either one will work, as long as it's got
 a Wiznet Ethernet module on board.
 This example has been updated to use version 2.0 of the API.
 To make it work, create a feed with a datastream, and give it the ID
 sensor1. Or change the code below to match your feed.
 * Analog sensor attached to analog in 0
 * Ethernet shield attached to pins 10, 11, 12, 13
 created 15 March 2010
 modified 9 Apr 2012
 by Tom Igoe with input from Usman Haque and Joe Saavedra
 This code is in the public domain.

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

    #define ONE_WIRE_BUS 2                              //One Wire Bus auf PIN 2
    #define TEMPERATURE_PRECISION 9                      // wird hier vermutlich nicht gebraucht

#define APIKEY         "-----------" // replace your pachube api key here
#define FEEDID         ----------- // replace your feed ID
#define USERAGENT      "----------" // user agent is the project name

    // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
    OneWire oneWire(ONE_WIRE_BUS);

    // Pass our oneWire reference to Dallas Temperature. 
    DallasTemperature sensors(&oneWire);

    DeviceAddress Verdampfer = {0x28, 0x54, 0x7F, 0x2B, 0x04, 0x00, 0x00, 0x94};  //Benennung der Sensoren und Angabe der Adresse

// assign a MAC address for the ethernet controller.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
// fill in your address here:
byte mac[] = {
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// fill in an available IP address on your network here,
// for manual configuration:
IPAddress ip(192,168,3,200);
// initialize the library instance:
EthernetClient client;

// if you don't want to use DNS (and reduce your sketch size)
// use the numeric IP instead of the name for the server:
IPAddress server(216,52,233,122);      // numeric IP for
//char server[] = "";   // name address for pachube API

unsigned long lastConnectionTime = 0;          // last time you connected to the server, in milliseconds
boolean lastConnected = false;                 // state of the connection last time through the main loop
const unsigned long postingInterval = 10*1000; //delay between updates to

void setup() {
 // Open serial communications and wait for port to open:
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only

 // start the Ethernet connection:
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // DHCP failed, so use a fixed IP address:
    Ethernet.begin(mac, ip);

void loop() {
  // read the analog sensor:
     // int sensorReading = analogRead(A0);  
      int verd = sensors.getTempC(Verdampfer);

  // 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 =;

  // if there's no net connection, but there was one last time
  // through the loop, then stop the client:
  if (!client.connected() && lastConnected) {

  // if you're not connected, and ten seconds have passed since
  // your last connection, then connect again and send data:
  if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
  // store the state of the connection for next time through
  // the loop:
  lastConnected = client.connected();

// this method makes a HTTP connection to the server:
void sendData(int thisData) {
  // if there's a successful connection:
  if (client.connect(server, 80)) {
    // send the HTTP PUT request:
    client.print("PUT /v2/feeds/");
    client.println(".csv HTTP/1.1");
    client.print("X-PachubeApiKey: ");
    client.print("User-Agent: ");
    client.print("Content-Length: ");

    // calculate the length of the sensor reading in bytes:
    // 8 bytes for "sensor1," + number of digits of the data:
       int thisLength = 8 + getLength(thisData);

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

    // here's the actual content of the PUT request:
  else {
    // if you couldn't make a connection:
    Serial.println("connection failed");
   // note the time that the connection was made or attempted:
  lastConnectionTime = millis();

// 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 = 4;
  // 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;

War das nicht so, daß der digitale Sensor ca 1 Sekunde für die Messung braucht? und darum die Funktionen
int verd = sensors.getTempC(Verdampfer);
so lange brauchen?
Grüße Uwe