AVR Arduino W5100 empfängt zu viele Bytes

[thomas (Gast)]

Moin,
ich kaue gerade an einem Problem mit einem Arduino Mega mit W5100 im 
ModBus-Modus:
Bei einer TCP-Übertragung werden 10 Bytes gesendet und 65000 Bytes 
kommen an (sagt der W5100).

Ein Arduino sendet über W5100 und Ethernet an einen anderen AVR mit 
W5100.
Wenn der Sender: Client.write(EinByte) mit einem delay versehen wird, 
packt der Arduino ein(ige) EinByte in einen TCP-Frame und schickt es ab.
So kommt das Array mit 10 Bytes in mehreren TCP-Frames an und wird beim 
Empfänger wieder auf die 10 Bytes zusammen gesetzt. Das geht perfekt, 
auch vom PC (ClinetSocket oder Indy) oder mit dem Arduino als normaler 
Ethernet-Client. Auch wenn nur ein Frame gesendet wird.

Ohne das delay meint der empfangende W5100 aber, dass 65291 Bytes (oder 
auch mal 65038) angekommen sind anstatt der 10 gesendeten. Womit er 
definitiv unrecht hat da der Socket-Buffer im W5100 auf 2048 eingestellt 
ist. Im W5100-Buffer steht dann eine Menge Müll, darunter auch irgendwo 
die gesendeten 10 Bytes.

Der Effekt lässt sich bis auf das return (SPDR); herunterbrechen.


Die Funktion

W5100_rx_size[Asocket]= w5100_read_int16(W5sRXRSR(Asocket));

packt den Wert 65xxx in W5100_rx_size[Asocket].

Da da jemand eine Idee?
...und vielen Dank für die Tips.
Thomas



Ich habe den Code mal etwas übersichtlicher geschrieben:

Sender: (Arduino Mega mit W5100)

//YxModbus.h:
#include "Arduino.h"
#include <SPI.h>
#include <Ethernet.h>

//YxModbus.cpp:
#include "YxModbus.h"
EthernetClient Client;

     for(int i=0; i<10; i++)   
      { Client.write(ByteArray[i]); 
//      delay(10);
      }

Empfänger: (AVR mit W5100)

uint8 W5100_TxRx(uint8 cData)
{  uint16 n;

  n=0;
  cli();
  SPDR = cData;                    // data in TX-register
  while(!(SPSR & (1<<SPIF)) && (n++ < gcTxTimeout));      //warte auf transfer ende
  sei();
  return (SPDR);                    // data aus rx-register
}


bool W5100_Tx(uint8 cData)
{  uint16 n;

  n=0;
  cli();
  SPDR = cData;                    // data in TX-register
  while(!(SPSR & (1<<SPIF)) && (n++ < gcTxTimeout));    //warte auf transfer ende
  sei();

  return (n<gcTxTimeout);
}


uint8 w5100_read_byte(uint16 addr)
{  uint8 inbyte;
  
  ISR_DISABLE();
  CLEARBIT(WIZ_PORT,WIZ_SCS);          //enable W5100
  inbyte=0;

  if (W5100_Tx(0x0F))              //OPcode read 0x0F 
  {  if (W5100_Tx((addr & 0xFF00) >> 8))    //adresse hi
    {  if (W5100_Tx(addr & 0x00FF))      //adresse lo
      {  inbyte=W5100_TxRx(0);      //dummy zum shiften
      }
    }
  }

      SETBIT(WIZ_PORT,WIZ_SCS);      //disable W5100
  ISR_ENABLE();
  return(inbyte);
}


uint16 w5100_read_int16(uint16 addr)
{  uint8  hibyte, lobyte;
  uint16   intvalue=0;
  
  hibyte=w5100_read_byte(addr);
  lobyte=w5100_read_byte(addr+1);
  intvalue = make16(hibyte,lobyte);

  return (intvalue);
}


#define W5sR(r,n)  ((r)+(n)*0x100)  //  r=register-base-adr, n=socket
#define W5sRXRSR(n)  W5sR(0x0426,n)  // 2b - Rx received size
Asocket=1;

bla...
W5100_rx_size[Asocket]= w5100_read_int16(W5sRXRSR(Asocket));
bla...



//=================================================================================
//Interrupt vom W5100
//W5100_INTERRUPT=INT2_vect  INT2 an PB2(vector No.4)
ISR(W5100_INTERRUPT)
{  uint8_t int_val, i, n, sreg;  
  
  sreg = SREG;                      //Save global interrupt flag
  cli();
  W5100_INTERRUPT_DISABLE();            //disable INT2
  int_val = w5100_read_byte(W5IR);        //read Interrupt Register: bits gesetzt
  W5100_IntMode=im_Leer;              //W5100 Leer-INT
  if (int_val & IR_CONFLICT)  {W5100_IntMode=im_IR_CONFLICT;}  //IR_CONFLICT
  if (int_val & IR_UNREACH)  {W5100_IntMode=im_IR_UNREACH;}  //IR_UNREACH
  w5100_write_byte(W5IR, 0xf0);         //W5100-interrupt clear
  n=0;
  do 
  {  for (i=0; i<MAX_SOCK_NUM; i++)                //check socket-int
    {  if (int_val & IR_SOCK(i))                //check socket interrupt No
      {  INT_STATUS[i] |= w5100_read_byte(W5sIR(i));      //save interrupt value, Sn_IR (Socket n Interrupt Register) 
        w5100_write_byte(W5sIR(i), INT_STATUS[i]);      //lösche "1"-bits durch writing "1"
        W5100_IntMode |= 1<<i;                //W5100 socket-INT
        if (INT_STATUS[i]) {LineActionEth=1;};        //=1: Ethernet-Char in Buffer, da kommt etwas rein...        
      }
    }
    int_val = w5100_read_byte(W5IR);              //re-read interrupt value
  } while ((int_val != 0) && (n++ < gcIntTimeOut));          //if exist, contiue to process  

  W5100_INTERRUPT_ENABLE();
  SREG = sreg;                      //Restore global interrupt flag  und Enable Ints  
}

[The D. (thedaz)]

Eventuell die Längenangaben byte swappen ?