RayLivingston:
Actually, on my board it's not. I run I2C at 2MHz. What is the SPI clock rate?
Perhaps you can explain a bit more detailed what you are doing actually.
I'm just using an UNO board, stacked with an Ethernet shield, and use all the default settings.
I've done a short test which shows me (using an UNO and Ethernet Shield):
Bytes sent: 46000
Time used: 0.909 seconds
RayLivingston:
The code I used for testing is about as no-nonsense as it gets - a For loop sending a single 50-character string using EthernetClient.print, and counting how many times it can be sent in 30 seconds.
I got my test result with this code, using the Arduino as a HTTP webserver for testing:
#include <SPI.h>
#include <Ethernet.h>
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};
char testStr[]="The quick brown fox jumps over the lazy dog.\r\n";
// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);
void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
// start the Ethernet connection and the server:
Ethernet.begin(mac);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
}
void loop() {
// listen for incoming clients
EthernetClient client = server.available();
if (client) {
Serial.println("new client");
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == '\n' && currentLineIsBlank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/plain");
client.println("Connection: close"); // the connection will be closed after completion of the response
client.println();
unsigned long time=millis();
for (int x = 0; x< 1000; x++) client.print(testStr);
client.print("Bytes sent: ");
client.println(1000L*strlen(testStr));
client.print("Time used: ");
client.print((millis()-time)/1000.0,3);
client.println(" seconds");
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
}
else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
client.stop();
Serial.println("client disconnected");
}
}
Perhaps your way of doing the timing does slow down the data transfer?
When using a test string which is twice as long, I even can see as a result:
Bytes sent: 92000
Time used: 1.572 seconds
The bigger you can create the network packets (within the maximum allowed network packet length), the less network packets need to be sent and the higher the data rate you can observe.