Receive.c

Receive.c example details
UDP details

/***************************************************************************//**
@file receive.c
@brief Receiving UDP packets
@verbatim
_ _ _
__| | ___(_) ____ _ __ | |_
/ _` | / __| |/ _` | '_ \| __|
| (_| | _ \__ \ | (_| | | | | |_
\__,_|(_) ___/_|\__, |_| |_|\__|
Signalprocessing |___/ Technology
@endverbatim
@author D.SignT GmbH & Co. KG, Claus Hermbusche
@date 2019-06-03
@anchor RECEIVEEX
@details
Simple DSP program for receiving UDP - packets. The received data is used
to switch the LED's on and off.
@cond Software License Agreement
Copyright (C) 2001-2019 D.SignT GmbH & Co. KG - http://www.dsignt.de
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the
distribution.
Neither the name of D.SignT GmbH & Co. KG nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
Disclaimer
THIS SOFTWARE IS PROVIDED BY D.SIGNT GMBH & CO. KG "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL D.SIGNT GMBH & CO. KG BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@endcond
*******************************************************************************/
/*******************************************************************************
common support functions
*******************************************************************************/
#define INC_XDUMP /**< include hex dump module: xdump.h */
/*******************************************************************************
include stdtypes.h to avoid data type mismatch
*******************************************************************************/
#include <BoardSupport/inc/stdtypes.h>
/*******************************************************************************
include Runtime Source
*******************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <inttypes.h>
#include <time.h>
#include <string.h>
/*******************************************************************************
network support functions
*******************************************************************************/
#include <Libs/NETlib/net.h> /* D.Module network support */
/*******************************************************************************
board specific functions
*******************************************************************************/
#include <BoardSupport/inc/BoardSpecific.h> /* board support functions */
/*******************************************************************************
common support functions
*******************************************************************************/
#include <Common/Common.h> /* on exit function */
#include <Common/uartio.h> /* UART support */
#include <Common/timer.h> /* timer setting */
#include <Common/CPrintf.h> /* CPrintf defines */
#include <Common/xdump.h> /* hex dump */
/*******************************************************************************
network configuration
*******************************************************************************/
#include <BoardSupport/config/netconfig.c> /* network configuration */
#ifdef __cplusplus
extern "C" {
#endif /* !__cplusplus */
/*******************************************************************************
local prototypes
*******************************************************************************/
#pragma CODE_SECTION(udp_call_back , ".commontext")
int32_t udp_call_back (SOCKET *so, void *data, uint32_t len, uint32_t ec);
#ifdef __cplusplus
} // extern "C"
#endif
/*******************************************************************************
* *
* DEFINES *
* *
*******************************************************************************/
/*******************************************************************************
server port
*******************************************************************************/
#define DSP_PORT 5031
/*******************************************************************************
limit the buffer to 4 elements
*******************************************************************************/
#define MAXDATA_SIZE 4
/*******************************************************************************
* *
* GLOBALS *
* *
*******************************************************************************/
/*******************************************************************************
program name
*******************************************************************************/
char *program_name = "receive";
SOCKET *udp_socket; /* socket descriptor */
/*******************************************************************************
select a 8, 16 or 32 bit socket
*******************************************************************************/
#define CHAR_SOCKET 1
// #define SHORT_SOCKET 1
// #define INT_SOCKET 1
#ifdef CHAR_SOCKET
#define DATATYPE DATATYPE_CHAR /* data type 8 bits */
#define DATATYPE_t char /* data type 8 bits */
#endif
#ifdef SHORT_SOCKET
#define DATATYPE_t int16_t /* data type 16 bits */
#define DATATYPE DATATYPE_SHORT /* data type 16 bits */
#endif
#ifdef INT_SOCKET
#define DATATYPE_t int32_t /* data type 32 bits */
#define DATATYPE DATATYPE_INT /* data type 32 bits */
#endif
DATATYPE_t *udp_data; /* data buffer for socket */
/*******************************************************************************
* *
* FUNCTIONS *
* *
*******************************************************************************/
/*******************************************************************************
@brief This function is called each time new data is received
@param so - socket
@param data - pointer to received data
@param len - received data length
@param ec - error code
@return SOCKET_CB_OK - if message processed
@return SOCKET_CB_CLOSED - if socket was closed
*******************************************************************************/
int32_t udp_call_back (SOCKET *so, void *data, uint32_t len, uint32_t ec)
{
/***************************************************************************
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);
}
/*******************************************************************************
@brief Main application
@param -
@return never
*******************************************************************************/
#pragma CODE_SECTION(main , ".commontext");
int main ( void )
{
/***************************************************************************
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);
}