blocksend.c File Reference

Sending a continuous data stream over TCP. More...

#include <BoardSupport/inc/stdtypes.h>
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <inttypes.h>
#include <time.h>
#include <string.h>
#include <Libs/NETlib/net.h>
#include <BoardSupport/inc/BoardSpecific.h>
#include <Common/Common.h>
#include <Common/uartio.h>
#include <Common/timer.h>
#include <Common/CPrintf.h>
#include <BoardSupport/config/netconfig.c>

Macros
#define	LOCAL_TCP_PORT   5031

Functions
int32_t	tcp_echo_cb (SOCKET *so, void *data, uint32_t len, uint32_t ec)
SOCKET *	open_tcp_server (void)
uint16_t	my_monitor_link_status (tpOutputFunc pLog)
int	main (void)

Variables
char *	program_name = "blocksend"
far char *	domain_name
static unsigned char	data_buffer [TCP_SEND_BUFFER_SIZE]
uint8_t	_link_mode
uint32_t	transmitting = FALSE
uint32_t	dhcp_active = FALSE
SOCKET *	tcp_server = INVALID_SOCKET
static char	buffer [100]
timeval	connect_stamp1

Detailed Description

                          _         _             _
                       __| |    ___(_) ____ _ __ | |_
                      / _` |   / __| |/ _` | '_ \| __|
                     | (_| | _ \__ \ | (_| | | | | |_
                      \__,_|(_) ___/_|\__, |_| |_|\__|
                     Signalprocessing |___/ Technology

Author

D.SignT GmbH & Co. KG, Claus Hermbusche

Date

2019-06-03

To verify this program, first 'ping' the DSP:

>ping 192.168.168.200

or, if configured for DHCP

>ping mydemo

If the settings and network connections are correct, the pings will be replied.

Establish a TCP connection on port 5031:

>nc 192.168.168.200 5031 > test.dat

or

>nc mydemo 5031 > test.dat

A continuous data stream will be written into test.dat until the connection is closed.

Macro Definition Documentation

#define LOCAL_TCP_PORT   5031

Examples:

Blocksend.c.

Function Documentation

int32_t tcp_echo_cb	(	SOCKET *	so,
		void *	data,
		uint32_t	len,
		uint32_t	ec
	)

Examples:

Blocksend.c, and Echo.c.

{
    /***************************************************************************
     locals
    ***************************************************************************/
    int32_t data_length;      // net_recv_event_handler() return parameter

    /***************************************************************************
     suppress unused parameter warning
    ***************************************************************************/
    UNREFERENCED_PARAMETER(data); // replaced by bctl-> Buf[].Data
    // UNREFERENCED_PARAMETER(ec);   // handled in net_recv_event_handler()
    UNREFERENCED_PARAMETER(len);  // len is ignored, data_len is used instead

    /***************************************************************************
     Check events
     If NULL is passed as pLog parameter, no message is printed to output.
     Use net_recv_event_handler() to determine the data length waiting in the
     receive buffer
    ***************************************************************************/
    data_length = net_recv_event_handler (so, CPrintf); /* with messages      */
 // data_length = net_recv_event_handler (so, NULL);    /* without messages   */

    /***************************************************************************
     net_recv_event_handler() returns the amount of data waiting in the buffer
    ***************************************************************************/
    if (data_length)
    {
        // CPrintf ("received %"PRId32" bytes\r\n", data_length);

    }

    /***************************************************************************
     use this callback to detect a timeout
    ***************************************************************************/
    switch ( ec & SO_ERROR_MASK )
    {
        case SO_TIMED_OUT: // timeout detected, shutdown connection
            shutdown (tcp_server, 0);
        break;

        default:
        break;
    }

    /***************************************************************************
     Return true, if socket was not closed before
    ***************************************************************************/
    return (SOCKET_CB_OK);
}

SOCKET* open_tcp_server

(

void

)

Examples:

Blocksend.c.

{
    /***************************************************************************
     locals
    ***************************************************************************/
    SOCKET *so = INVALID_SOCKET;

    so = socket_open (ANY_ADDRESS,
                      ANY_PORT,
                      LOCAL_TCP_PORT,
                      DATATYPE_CHAR,
                      TCP_INIT_FUNC);
    if ( so == INVALID_SOCKET )
    {
        prg_exit ("socket_open() error");       /* possibly insufficient heap */
    }

    /***************************************************************************
     set keep alive time 5 seconds (three unanswered packets within 5 seconds)
    ***************************************************************************/
    tcp_set_keep_alive_time (so, KA_TIMEOUT(5));

    /***************************************************************************
     install callback function
    ***************************************************************************/
    socket_define_callback (so, tcp_echo_cb, buffer, sizeof(buffer));

    /***************************************************************************
      increase unacknowledged segment size
    ***************************************************************************/
    tcp_set_option( so, TCP_UNA_SEG, 8*TCP_MAX_PACKET_SIZE);

    /***************************************************************************
      set lower re-transmit delay
    ***************************************************************************/
    // tcp_set_option( so, TCP_RETRANS_DELAY, 0x20);  //default 0x40

    return (so);

}

uint16_t my_monitor_link_status

(

tpOutputFunc

pLog

)

Examples:

Blocksend.c.

{
    /***************************************************************************
     locals
    ***************************************************************************/
    static uint8_t _link_mode_old = 0xff;

    if (_link_mode_old != _link_mode)
    {
        _link_mode_old = _link_mode;
        if (pLog) pLog ("\n\r Link status changed: ");
        switch (_link_mode)
        {
            case 0xff:
                LED_off (2);

                /***************************************************************
                 shutdown connection and close socket
                ***************************************************************/
                shutdown (tcp_server, 0);
                socket_close (tcp_server);
                tcp_server = INVALID_SOCKET;

                if (pLog) pLog ("No Link\r\n");
                break;

            default:
                LED_on (2);

                /***************************************************************
                 if not configured for DHCP, open a new TCP server socket
                ***************************************************************/
                if (!dhcp_active)
                {
                    tcp_server = open_tcp_server ();
                }

                if (pLog) pLog ("Linked at %d Mbit %s duplex\r\n",
                        (_link_mode & SPEED_100) ? 100:10,
                        (_link_mode & FULL_DUPLEX) ? "full":"half");
                break;
        }
        return (1);
    }
    return (0);
}

int main

(

void

)

{
    /***************************************************************************
      locals
    ***************************************************************************/
    int main_loop = 1;        /* main loop switch, set to 0 to exit           */
    char conversion_buffer[16];
    struct tm *local_time;         /* structure to hold time and date         */
    timeval stamp2, delta;         /* used to determine session time          */
    static timeval CurrentTimeStamp;

    /***************************************************************************
      initialize application (e.g. timer clocks, PLL settings, EMIF etc.)
       (ref. \Common\Common.c)
    ***************************************************************************/
    AppInit (GET_CLOCK);

    /***************************************************************************
      select output device for CPrintf  (ref. \Common\cprintf.c)
      possible settings:
        CPRINTF_UART_OUTPUT                       -> output to UART
        CPRINTF_CCS_OUTPUT                        -> output to CCS
        CPRINTF_UART_OUTPUT | CPRINTF_CCS_OUTPUT  -> output to UART and CCS
    ***************************************************************************/
    CPrintf_select_output (CPRINTF_DEFAULT_OUTPUT);  /* default outputs       */

    /***************************************************************************
     print a start up message
    ***************************************************************************/
    START_UP_MESSAGE (BLANK_REV NETLIB_REV);

    /**************************************************************************/
    // CPrintfProgress (" Heap check ");
    // at least 0x2000 bytes required for this app
    /**************************************************************************/
    ASSERT_HEAP (initial_heap_size, 0x2000);
    // CPrintfProgressSuccess();

    /**************************************************************************/
     CPrintfProgress (" Setup system time ");
    /**************************************************************************/
    SetupSystemTime ( SYSTEM_TIMER_INT, SYSTEM_TIMER, RES_MSECONDS);
    CPrintfProgressSuccess();
    CPrintf ("   *** timer %d mapped to CPU int %d ***\r\n",
             SystemTimerDev, SYSTEM_TIMER_INT);

    /**************************************************************************/
     CPrintfProgress (" Enable interrupts ");
    /**************************************************************************/
    BoardEnableInterrupts();
    CPrintfProgressSuccess();

    /**************************************************************************/
     CPrintfProgress (" Start system timer ");
    /**************************************************************************/
    StartSystemTimer ();
    CPrintfProgressSuccess();
    CPrintf ("   *** timer %d running at %"PRId32" Hz ***\r\n", SystemTimerDev, RES_SECONDS/GetSystemTimerRes());

    /**************************************************************************/
     CPrintfProgress (" Initialize network ");
    /**************************************************************************/
    InitializeNetwork ( 64); // 64 bytes for ping
    CPrintfProgressSuccess();

    /***************************************************************************
     detect if program was configured for DHCP
    ***************************************************************************/
    if (!((eth.ip[0]-'0')<=9))
    {
        dhcp_active = TRUE;
    }
    else
    {
        tcp_server = open_tcp_server ();
    }

    /***************************************************************************
     main program loop: set main_loop to 0 to exit loop
    ***************************************************************************/
    CPuts ("\r\n Entering main loop ...");
    while ( main_loop )
    {
        /***********************************************************************
         process net_isq()
        ***********************************************************************/
        net_isq ();  // process ISQ

        /***********************************************************************
         monitor link status
        ***********************************************************************/
        my_monitor_link_status (CPrintf);

        /***********************************************************************
         try to detect IP assignment
          if DHCP is used, the assigned IP address may change
        ***********************************************************************/
        if (monitor_ip_address (CPrintf))
        {
            /*******************************************************************
             in case of DHCP open a new TCP server after IP assignment
            *******************************************************************/
            if (dhcp_active)
            {
                tcp_server = open_tcp_server ();
            }

            /*******************************************************************
             print what to do next
            *******************************************************************/
            CPrintf (" Establish a TCP connection on port %d:\r\n", tcp_server-> src_port);

            if (domain_name)  CPrintf (">nc %s.%s %d > test.dat\r\n or\r\n",
                                       eth.ip,
                                       domain_name,
                                       tcp_server-> src_port);
            CPrintf (">nc %s %d > test.dat\r\n",
                     inet_ntoa(get_ip_address(0), conversion_buffer),
                     tcp_server-> src_port);

            CPuts (" A continuous data stream will be written into test.dat\r\n until the connection is closed.\r\n");
        }

        /***********************************************************************
         TCP output
        ***********************************************************************/
        if ( accept (tcp_server) && (_link_mode != 0xff))  /* if connection established              */
        {
            /*******************************************************************
             if TCP connection established but transmitting flag not set, a new
             connection has started.
            *******************************************************************/
            if (transmitting == FALSE)
            {
                transmitting = TRUE;    /* set flag for transmission          */

                /***************************************************************
                 take time stamp when the connection started
                ***************************************************************/
                connect_stamp1 = GetTimeStamp();
            }
            else
            {
                /***************************************************************
                 show that the program is running, print connection time
                ***************************************************************/
                if ( tv_elapsed (&CurrentTimeStamp, UINT32_C(1), UINT32_C(0), TRUE) )
                {
                    /***********************************************************
                     get current time
                    ***********************************************************/
                    stamp2 = GetTimeStamp();

                    /***********************************************************
                     calculate elapsed time
                    ***********************************************************/
                    tv_interval (&delta, &connect_stamp1, &stamp2);
                    local_time = localtime ((const time_t *)&delta);
                    CPrintf (CLRLINE" %02d:%02d:%02d",
                             local_time->tm_hour, local_time->tm_min, local_time->tm_sec );
                }
            }

            /*******************************************************************
             check data currently in transmission (wait for completion was not
             used in net_send_safe() below)
             two approaches:
                1. use tcp_tx_complete()
                2. determine pending data with tcp_pending_window() and decide
                   if sending new data is safe
            *******************************************************************/
            if ( tcp_tx_complete (tcp_server) )
            // if ( tcp_pending_window (tcp_server) < TCP_MAX_PACKET_SIZE )
            {
                /***************************************************************
                 process buffer, generate new data
                ***************************************************************/
                /* ... */

                /***************************************************************
                 send data block
                 no need to wait for completion here because tcp_pending_window()
                 is used above to prevent net_send_safe() being called while
                 data is pending.
                ***************************************************************/
                if (net_send_safe (tcp_server,
                                   data_buffer,
                                   TCP_SEND_BUFFER_SIZE,
                                   TCP_NOWAIT) == 0)
                {
                    /***********************************************************
                     fatal error occurred, stop transmission
                    ***********************************************************/
                    shutdown (tcp_server, 0);
                }
            }
            else
            {
                /***************************************************************
                 more than one packet is pending, don't touch the buffer!
                ***************************************************************/
            } // if
        }
        else
        {
            if (transmitting)
            {
                /***************************************************************
                 connection stopped
                ***************************************************************/
                transmitting = FALSE;     /* clear transmission flag          */
                shutdown (tcp_server, 0);

                /***************************************************************
                 get current time
                ***************************************************************/
                stamp2 = GetTimeStamp();

                /***************************************************************
                 calculate elapsed time
                ***************************************************************/
                tv_interval (&delta, &connect_stamp1, &stamp2);
                local_time = localtime ((const time_t *)&delta);
                CPrintf (" connection duration [hh:mm:ss]: ");
                CPrintf (VT100_RED
                         " %02d:%02d:%02d\r\n"
                         VT100_DEFAULT,
                         local_time->tm_hour, local_time->tm_min, local_time->tm_sec );
            }

            /*******************************************************************
             show that the program is running
            *******************************************************************/
            if ((get_ip_address (0)) != UINT32_C(0))
            {
                CPrintProgressBarText  ('<', 500000, 1,  " waiting for connection ");
            }
        }
    }

    /***************************************************************************
      exit program, shut down peripherals
    ***************************************************************************/
    return (0);
}

Variable Documentation

char* program_name = "blocksend"

far char* domain_name

unsigned char data_buffer[TCP_SEND_BUFFER_SIZE]

static

uint8_t _link_mode

use Operation Mode parameter to detect link mode FULL_DUPLEX 0x01 SPEED_100 0x04 SPEED_1000 0x20

uint32_t transmitting = FALSE

Examples:

Blocksend.c.

uint32_t dhcp_active = FALSE

Examples:

Blocksend.c.

SOCKET* tcp_server = INVALID_SOCKET

char buffer[100]

static

Examples:

Blocksend.c, BoardSpecific.c, DHCPTest.c, DNSTest.c, Echo.c, FTPServer.c, Multicast.c, NetTest.c, Send.c, and Telnet.c.

timeval connect_stamp1

Examples:

Blocksend.c.