Receive.c File Reference

Receiving UDP packets. 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 <Common/xdump.h>
#include <BoardSupport/config/netconfig.c>

Macros
#define	INC_XDUMP
#define	DSP_PORT   5031
#define	MAXDATA_SIZE   4
#define	CHAR_SOCKET   1
#define	DATATYPE   DATATYPE_CHAR /* data type 8 bits */
#define	DATATYPE_t   char /* data type 8 bits */

Functions
int32_t	udp_call_back (SOCKET *so, void *data, uint32_t len, uint32_t ec)
int	main (void)

Variables
char *	program_name = "receive"
SOCKET *	udp_socket
DATATYPE_t *	udp_data

Detailed Description

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

Author

D.SignT GmbH & Co. KG, Claus Hermbusche

Date

2019-06-03

Simple DSP program for receiving UDP - packets. The received data is used to switch the LED's on and off.

Macro Definition Documentation

#define INC_XDUMP

include hex dump module: xdump.h

#define DSP_PORT   5031

Examples:

Receive.c.

#define MAXDATA_SIZE   4

Examples:

Receive.c.

#define CHAR_SOCKET   1

#define DATATYPE   DATATYPE_CHAR /* data type 8 bits */

Examples:

Receive.c.

#define DATATYPE_t   char /* data type 8 bits */

Examples:

Receive.c.

Function Documentation

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

Examples:

Receive.c.

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

    /***************************************************************************
     suppress unused parameter warning
    ***************************************************************************/
    UNREFERENCED_PARAMETER(so);
    UNREFERENCED_PARAMETER(len);  // len is ignored, data_length is used instead
    UNREFERENCED_PARAMETER(ec);   // handled in net_recv_event_handler()

    /***************************************************************************
     Check events
     Use net_recv_event_handler() to determine the data length waiting in the
     receive buffer
     If NULL is passed as pLog parameter, no message is printed to output.
     CPrintf is used here for demonstration purpose only. You shouldn't use
     long blocking operation in callback functions.
    ***************************************************************************/
    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 is used here for demonstration purpose only. You shouldn't use
         long blocking operation in callback functions.
        ***********************************************************************/
        CPrintf(" len = %"PRId32"\r\n", data_length);

        /***********************************************************************
         dump the data
         void xd (void *mem, uint32_t bufl, int16_t dochar, uint32_t address, size_t size);

         Parameter
            mem     - Address of buffer to dump.
            bufl    - Buffer length in bytes.
            dochar  -  If non-zero, show ASCII/ISO characters
                       as well as hexadecimal.
            address - address-offset
            size    - size of buffer element
        ***********************************************************************/
        xd (data, len, TRUE, (uint32_t)data, DATATYPE);
    }

    /***************************************************************************
     return true, if message processed
    ***************************************************************************/
    return (SOCKET_CB_OK);
}

int main

(

void

)

Examples:

Receive.c.

{
    /***************************************************************************
     locals
    ***************************************************************************/
    int main_loop = 1;                /* main loop switch, set to 0 to exit   */
    timeval stamp1, stamp2, delta;    /* used to determine startup time       */

    /***************************************************************************
      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       */
    xd_config_output ((void *)CPrintf);

    /***************************************************************************
     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();

    /***************************************************************************
     malloc space for data
    ***************************************************************************/
    CPrintfProgress (" Try to allocate data buffer ");
    udp_data = (DATATYPE_t*) malloc (MAXDATA_SIZE * sizeof(DATATYPE_t));
    if ( udp_data == NULL )
    {
        prg_exit ("out of memory error");
    }
    CPrintfProgressSuccess();

    /**************************************************************************/
     CPrintfProgress (" Setup system time ");
     // 1 milli seconds resolution
    /**************************************************************************/
    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());

    /***************************************************************************
      measure network initialization time
    ***************************************************************************/
    stamp1 = GetTimeStamp();

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


    /***************************************************************************
     open socket
    ***************************************************************************/
    udp_socket = socket_open (ANY_ADDRESS,        /* all addresses            */
                              ANY_PORT,           /* destination port         */
                              DSP_PORT,           /* source port              */
                              DATATYPE,           /* data type char, int16_t or int32_t */
                              UDP_INIT_FUNC);     /* udp protocol             */
    if ( udp_socket == INVALID_SOCKET )
    {
        prg_exit ("socket_open() error");       /* possibly insufficient heap */
    } // if

    /***************************************************************************
      define callback function for received UDP packets
    ***************************************************************************/
    socket_define_callback (udp_socket, udp_call_back, udp_data, MAXDATA_SIZE);
    CPrintfProgressSuccess();

    stamp2 = GetTimeStamp();

    tv_interval (&delta, &stamp1, &stamp2);
    CPuts (" network startup time [sec]: ");
    CPrintf (VT100_RED
             "%"PRId32".%03"PRId32"\r\n"
             VT100_DEFAULT,
              delta.tv_sec,
              delta.tv_usec/1000);


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

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

        /***********************************************************************
         try to detect IP assignment
          if DHCP is used, the assigned IP address may change
        ***********************************************************************/
        monitor_ip_address (CPrintf);

        /***********************************************************************
         show that the program is running, perform symbol animation
        ***********************************************************************/
        CPrintAnimatedSymbol ( sym_animate, 200000, ANIMATE_SYMBOLS_COUNT);
    }

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

Variable Documentation

char* program_name = "receive"

Examples:

Receive.c.

SOCKET* udp_socket

Examples:

Receive.c.

DATATYPE_t* udp_data

Examples:

Receive.c.