massima dimensione del buffer Ethernet::buffer[];

Salve ... sono alle prese con un altro problema relativo alla libreria ethercard e l'ENC28J60

.... ho sviluppato buona parte del progetto sul 328 ed ho raggiunto il limite dei 1500 byte del buffer

byte Ethernet::buffer[1500];

quindi sono passato al mega per ultimare e sviluppare le ultime cosa .. prima di trasferire tutto sul 644 ..

sul mega utilizzo il 5% delle risorse disponibili per i programmi ed il 23% di memoria dinamica ... eppure se supero i 1500 (circa) byte del buffer non funziona più ...

è una bella delusione ... non ho capito l'origine di questo limite.

non utilizzo la SD ... mi date la vostra opinione al riguardo???.. grazie

Mmmm ... se ricordo bene (verifica nelle specifiche del TCP/Ethernet), la massima lunghezza per la MTU (Maximum Transmission Unit) è di 1500 bytes, quindi ... mi sa che NON è un problema di Arduino ma di protocollo/Ethernet.

Come puoi leggere dalla pagina linkata ...

Il concetto di MTU si ripresenta a diversi livelli e assumendo diversi nomi, ma il termine MTU indica propriamente la dimensione massima del pacchetto in IP. IP viene molto spesso trasportato su Ethernet, che ha normalmente uno spazio massimo di 1500 byte per il campo dati, a cui si aggiungono 26 byte [22 byte di intestazione Ethernet + 4 byte di Cyclic Redundancy Check (CRC)] portando la dimensione massima del frame Ethernet a 1526 byte. La MTU tipica su Internet è quindi di 1500 byte. Di questi, 20 sono normalmente occupati dallo header IP. Se viene utilizzato il protocollo TCP, questo occupa normalmente altri 20 byte per i propri header. Il payload (o carico utile) di un pacchetto TCP è quindi tipicamente di 1460 byte. TCP possiede un meccanismo per negoziare il "Maximum Segment Size" (dimensione massima del segmento, o MSS). Normalmente, MSS = MTU - 40.

Guglielmo

... cavolo!!! ...

... cmq grazie Guglielmo ....

ma sarà prevista la possibilita di inviare due o piu pacchetti nella libreria ethercard???

devo stampare solo altri 12 numeri

http://94.39.240.69/?mn=6

menu 4, devo aggiungere altri 12 num e la pagina è finita …

come posso fare ad inviare almeno due pacchetti da 1500 byte per costruire la pagina???

E' previsto il multipacket .. devo solo capire come fare ... tnx Guglielmo

Se sei su una Mega lascia perdere Ethercard e passa a arduino_uip. Ethercard non credo supporti il multipacket.

@sukko

negli esempi ho trovato questo .. con la libreria ethercard .... ne deduco che è previsto. L'esempio si chiama proprio multipacket

void loop(){
    word pos = ether.packetLoop(ether.packetReceive());
    // check if valid tcp data is received
    if (pos) {
        char* data = (char *) Ethernet::buffer + pos;
        if (strncmp("GET / ", data, 6) == 0) {
            ether.httpServerReplyAck(); // send ack to the request
            
            memcpy_P(ether.tcpOffset(), pageA, sizeof pageA); // send first packet and not send the terminate flag
            ether.httpServerReply_with_flags(sizeof pageA - 1,TCP_FLAGS_ACK_V);
            
            memcpy_P(ether.tcpOffset(), pageB, sizeof pageB); // send second packet and not send the terminate flag
            ether.httpServerReply_with_flags(sizeof pageB - 1,TCP_FLAGS_ACK_V);
            
            memcpy_P(ether.tcpOffset(), pageC, sizeof pageC); // send thirdt packet and not send the terminate flag
            ether.httpServerReply_with_flags(sizeof pageC - 1,TCP_FLAGS_ACK_V);
            
            memcpy_P(ether.tcpOffset(), pageD, sizeof pageD); // send fourth packet and not send the terminate flag
            ether.httpServerReply_with_flags(sizeof pageD - 1,TCP_FLAGS_ACK_V);
            
            memcpy_P(ether.tcpOffset(), pageE, sizeof pageE); // send fiveth packet and send the terminate flag
            ether.httpServerReply_with_flags(sizeof pageE - 1,TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V); }
        else
        {
            ether.httpServerReplyAck(); // send ack to the request
            memcpy_P(ether.tcpOffset(), pageA, sizeof pageA);//only the first part will sended 
            ether.httpServerReply_with_flags(sizeof pageA - 1,TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
        }
  }

solo che non so come fare ---- per sempio per dividere questi due blocchi header e menu che io invio in un unico pacchetto ...

 bfill = ether.tcpOffset();
bfill.emit_p(PSTR("$F $F"), header, menu);

come faccio a dividerli .. giusto per fare un esempio:

Non ne ho idea, Ethercard ha un'interfaccia a dir poco orribile.

Risolto.
non cambia quasi nulla rispetto al singolo pachetto …
invio il contenuto del buffer ogni volta che mi avvicino al limite così:

                bfill = ether.tcpOffset();
                bfill.emit_p(PSTR("$F"), header); 
                ether.httpServerReply_with_flags(bfill.position() - 1, TCP_FLAGS_ACK_V); //invia primo pacchetto

                bfill = ether.tcpOffset();
                bfill.emit_p(PSTR("$F"), menu); 
                ether.httpServerReply_with_flags(bfill.position() - 1, TCP_FLAGS_ACK_V); //invia secondo pacchetto
                    
                faiPagina(mn, az, sb, up); //costruisce pagina: altro pacchetto:

                bfill = ether.tcpOffset();
                bfill.emit_p(PSTR("$F"), piede); 
                ether.httpServerReply_with_flags(bfill.position()- 1, TCP_FLAGS_ACK_V | TCP_FLAGS_FIN_V ); // ultimo pacchetto

attenzione a riportare indietro il puntatore del buffer prima di riempire di nuovo … la differenza sta nell’usare ether.httpServerReply_with_flags, riportare indietro il puntatore di una posizione, ed aggiungere il flag giusto (non di fine invio). Il fine invio viene inviato solo nell’ultimo pacchetto

nella fuznione faiPagina che corre il rischio di generare troppi caratteri suddivido ulteriormente
così:

    case 5: case 6: case 7:
    bfill = ether.tcpOffset();
    bfill.emit_p(PSTR(
        "<table>\n"
        "<tr><td><H1>4</H1></td><td>\n"
             "<table border='1'>\n"
               "<tr bgcolor='#ACFF78'><td></td><td>sql</td><td>ptt</td><td>rit</td><td>blocco 1</td><td>blocco 2</td><td>blocco 3</td><td></td></tr>\n" 
               //                                     sql        ptt        rit        az1        az2        az3
               "<tr><td  bgcolor='#A0bb78'>$D</td> <td>$S</td><td>$S</td><td>$S</td><td>$S</td><td>$S</td><td>$S</td><td><a href='\?mn=4'> indietro </a></td></tr>\n"  
               "</table>\n"
        "</td></tr>"     
        "</table>\n"),
        pg-4,
        riga[pg-5].sql, riga[pg-5].ptt, riga[pg-5].rit, riga[pg-5].az1, riga[pg-5].az2, riga[pg-5].az3);
        ether.httpServerReply_with_flags(bfill.position()-1,TCP_FLAGS_ACK_V);

        bfill = ether.tcpOffset();
        for( int i = 1; i <= 32 ; i++){
        bfill.emit_p(PSTR(
        "<a href='\?az=$D'>x</a>\n"), i);
        };
        ether.httpServerReply_with_flags(bfill.position()-1,TCP_FLAGS_ACK_V);
        break;

bene … bene … continuamo …
ciao

Errata corrige ....

portare indietro il puntatore del buffer è sbagliato ....

.... ether.httpServerReply_with_flags(bfill.position()-1,TCP_FLAGS_ACK_V); ...

il -1 è sbagliato!!!!