TCP/IP Programmierung

 

Eine TCP/IP Verbindung öffnen:

 

Mit ETH_SetConnBuf einen Empfangspuffer anlegen.

Der Aufruf von ETH_ConnectTCP baut eine Verbindung auf und setzt den internen State auf ES_CONNECTING.

Man überwacht mit ETH_GetStateTCP den Zustand der Verbindung. Nach ES_CONNECTING kann der Wert sich auf ES_CONNECTED oder ES_DISCONNECTED ändern. Bei ES_CONNECTED ist die Verbindung aufgebaut, sonst fand eine eine Zeitüberschreitung statt, oder die Gegenstelle hat abgelehnt.

Ist die Verbindung aufgebaut, kann man mit ETH_SendTCP Daten senden.

Gleichzeitig ist mit ETH_CheckReceiveBuf periodisch zu überprüfen ob Daten eingegangen sind, und man muss mit ETH_GetStateTCP überwachen, ob die Verbindung nicht irgendwann in den Zustand ES_DISCONNECTED fällt.

Ein Aufruf von ETH_DisconnectTCP beendet die Verbindung.

 

Auf einem TCP/IP Port auf eine eingehende Verbindung warten:

 

Mit ETH_SetConnBuf einen Empfangspuffer anlegen.

ETH_ListenTCP überwacht einen spezifizierten Port.

Man überprüft mit ETH_CheckReceiveBuf periodisch ob Daten eingegangen sind und damit eine neue Verbindung von außen aufgemacht wurde. Der Zustand von ETH_GetStateTCP hat jetzt den Wert ES_LCONNECTED.

Ist die Verbindung aufgebaut, kann man mit ETH_SendTCP Daten senden.

Man muss mit ETH_GetStateTCP überwachen, ob die Verbindung nicht irgendwann in den Zustand ES_DISCONNECTED fällt.

Ein Aufruf von ETH_DisconnectTCP beendet die Verbindung.

 

 

 Es ist zu empfehlen, sich die Demoprogramme für UDP und TCP/IP anzuschauen.

 

 Es können gleichzeitig bis zu 10 TCP/IP Verbindungen aufgemacht werden, und bei bis zu 3 Ports auf eingehende Verbindungen gelauscht werden.

 

 Als Default sind 4kb für den TCP/IP Stack reserviert. Je nach Nutzung braucht der Stack mehr oder weniger RAM. Der benötigte Speicher ist nur aufwendig zu berechnen, und sollte selbst durch Tests ermittelt werden.

 

 

Beispiele

 

Das Programm baut eine Verbindung zum HTTP Port auf, schickt ein "GET" Kommando ab, und empfängt die Antwort:

 

byte tcp_buf[ETH_BUF(4000,6)], rbuf[1461];
 
void main(void)
{
    word info[4], plen;
    char cmdtxt[50];
    dword ip;
    byte id, state;
 
    ETH_SetConnBuf(tcp_buf, 4000, 6);
    id= ETH_ConnectTCP(IP_ADDR(192,168,0,1), 80);
 
    state= ES_CONNECTING;
    while(state == ES_CONNECTING)
    {
        state= ETH_GetStateTCP(id);
    }
 

    if(state == ES_CONNECTED)

    {
        cmdtxt= "GET / HTTP/1.1\n\n";
        ETH_SendTCP(id, cmdtxt, Str_Len(cmdtxt));
 
        while(1)
        {
            ip= ETH_CheckReceiveBuf(info);
            if(ip)
            {
                plen= info[3];
                if(plen > 1460) plen= 1460;  // auf 1460 bytes begrenzen
                ETH_ReceiveData(rbuf, plen);

            }
        }
    }
}

 

 

Das folgende Beispiel wartet auf eingehende Verbindungen auf Port 23 (Telnet). Die Daten werden in rbuf abgeholt aber nicht weiter verarbeitet:

 

byte tcp_buf[ETH_BUF(4000,6)],  rbuf[200];  // 4000 byte Empfangspuffer
 
void main(void)
{
    word info[4], plen;
    dword ip;

    char text[10];
 
    ETH_SetConnBuf(tcp_buf, 4000, 6);  // 4000 byte Puffer und 6 Connections
    ETH_ListenTCP(23);  // Listen Telnet port
 
    while(1)
    {
        ip= ETH_CheckReceiveBuf(info);
        if(ip)
        {
            plen= info[3];  // 
            if(plen > 200) plen= 200;  // Begrenze auf 200 bytes
            ETH_ReceiveData(rbuf, plen);
            txt= "Cmd:\n";
            ETH_SendTCP(info[0], txt, 5); // Sende Cmd String
        }
    }
 
}