dsp.UDPSender

Send UDP packets to network

Description

The UDPSender object sends UDP packets to the network.

To send UDP packets to the network:

  1. Create the dsp.UDPSender object and set its properties.

  2. Call the object with arguments, as if it were a function.

To learn more about how System objects work, see What Are System Objects? (MATLAB).

Creation

Description

udps = dsp.UDPSender returns a UDP sender object, udps, that sends UDP packets to a specified port.

example

udps = dsp.UDPSender(Name,Value) returns a UDP sender object, udps, with each property set to the specified value.

Properties

expand all

Unless otherwise indicated, properties are nontunable, which means you cannot change their values after calling the object. Objects lock when you call them, and the release function unlocks them.

If a property is tunable, you can change its value at any time.

For more information on changing property values, see System Design in MATLAB Using System Objects (MATLAB).

Specify the remote (that is, host) IP address to which the data is sent. The default is '127.0.0.1', which is the local host.

Data Types: char

Specify the port at the remote IP address to which the data is sent. This property is tunable in generated code but not tunable during simulation.

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Specify how to determine the local IP port on the host as Auto or Property. If you specify Auto, the object selects the port dynamically from the available ports. If you specify Property, the object uses the source specified in the LocalIPPort property.

Specify the port from which to send data.

Dependencies

This property applies when you set the LocalIPPortSource property to Auto.

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Usage

Description

example

y = udps(Packet) sends one UDP packet, Packet, to the network.

Input Arguments

expand all

The object sends one UDP packet to the network per call.

Data Types: single | double | int8 | int16 | int32 | uint8 | uint16 | uint32 | logical
Complex Number Support: Yes

Object Functions

To use an object function, specify the System object™ as the first input argument. For example, to release system resources of a System object named obj, use this syntax:

release(obj)

expand all

stepRun System object algorithm
releaseRelease resources and allow changes to System object property values and input characteristics
resetReset internal states of System object

Examples

expand all

Send and receive UDP packets using the dsp.UDPSender and dsp.UDPReceiver System objects. Calculate the number of bytes successfully transmitted.

Note: If you are using R2016a or an earlier release, replace each call to the object with the equivalent step syntax. For example, obj(x) becomes step(obj,x).

Set the RemoteIPPort of UDP sender and the LocalIPPort of the UDP receiver to 31000. Set the length of the data vector to 128 samples, which is less than the value of the MaximumMessageLength property of the receiver. To prevent the loss of packets, call the setup method on the receiver object before the first call to the object algorithm.

udpr = dsp.UDPReceiver('LocalIPPort',31000);
udps = dsp.UDPSender('RemoteIPPort',31000);

setup(udpr); 

bytesSent = 0;
bytesReceived = 0;
dataLength = 128;

In each loop of iteration, send and receive a packet of data. At the end of the loop, use the fprintf function to print the number of bytes sent by the sender and the number of bytes received by the receiver.

for k = 1:20
   dataSent = uint8(255*rand(1,dataLength));
   bytesSent = bytesSent + dataLength;
   udps(dataSent);
   dataReceived = udpr();
   bytesReceived = bytesReceived + length(dataReceived);
end

release(udps);
release(udpr);

fprintf('Bytes sent:     %d\n', bytesSent);
Bytes sent:     2560
fprintf('Bytes received: %d\n', bytesReceived);
Bytes received: 2560

The local IP port number of the dsp.UDPReceiver object and the remote IP port number of the dsp.UDPSender object are tunable in the generated code. Generate a MEX file from the receiver function which contains the algorithm to receive sine wave data over a UDP network. Change the remote IP port number of the UDP receiver without regenerating the MEX file. Verify the number of bytes sent and received over the network.

Note: This example runs only in R2017a or later.

The input to the receiver function is the local IP port number of the dsp.UDPReceiver System object™. The output of this function is the number of bytes received from the UDP network.

type receiver
function [bytesReceived] = receiver(portnumber)

persistent udpRx

if isempty(udpRx) 
    udpRx = dsp.UDPReceiver('MessageDataType','double'); 
end 

udpRx.LocalIPPort = portnumber; 
dataReceived = udpRx();
bytesReceived = length(dataReceived);

The dsp.UDPSender object with remoteIPPort number set to 65000 sends the data over the UDP network. The dsp.UDPReceiver object with LocalIPPort number set to 65000 receives the data from the UDP network. The data is a sine wave containing 250 samples per frame.

portnumber = 65000;
udpSend = dsp.UDPSender('RemoteIPPort',portnumber);
sine = dsp.SineWave('SamplesPerFrame',250);

bytesSent = 0;
bytesReceived = 0;
dataLength = 250;

for i = 1:10
dataSent = sine();
bytesSent = bytesSent + dataLength;
udpSend(dataSent);
bytesReceived = bytesReceived + receiver(portnumber);
end
fprintf('Number of bytes sent: %d', bytesSent);
Number of bytes sent: 2500
fprintf('Number of bytes received: %d', bytesReceived);
Number of bytes received: 2250

The data is sent and received successfully over the UDP network. The initial data is dropped due to overhead.

Generate a MEX file from the receiver.m function.

codegen receiver -args {65000}

Release the sender and change the RemoteIPPort number to 25000. The LocalIPPort number of the receiver continues to be 65000. Since the port numbers are different, the data is not transmitted successfully.

release(udpSend)
portnumberTwo = 25000;
udpSend.RemoteIPPort = portnumberTwo; 
bytesReceived = 0;
bytesSent = 0;
for i = 1:10
dataSent = sine();
bytesSent = bytesSent + dataLength;
udpSend(dataSent);
bytesReceived = bytesReceived + receiver_mex(portnumber);
end
fprintf('Number of bytes sent: %d', bytesSent);
Number of bytes sent: 2500
fprintf('Number of bytes received: %d', bytesReceived);
Number of bytes received: 0

Clear the MEX file and change the local IP port number of the receiver to 25000. Clearing the MEX enables the receiver port number to change without having to regenerate the MEX. The port numbers of the sender and receiver match. Verify if the data is transmitted successfully.

clear mex %#ok
bytesReceived = 0;
bytesSent = 0;
for i = 1:10
dataSent = sine();
bytesSent = bytesSent + dataLength;
udpSend(dataSent);
bytesReceived = bytesReceived + receiver_mex(portnumberTwo);
end
fprintf('Number of bytes sent: %d', bytesSent);
Number of bytes sent: 2500
fprintf('Number of bytes received: %d', bytesReceived);
Number of bytes received: 2250

The data is transmitted successfully over the UDP network. The initial data is dropped due to overhead.

Compute the STFT of a sine wave and transmit the complex STFT data over a UDP network. At the receiver side, compute the ISTFT of the received data. Visualize the data sent and the data received using a time scope.

The dsp.UDPSender object can send complex data. In order to enable the dsp.UDPReceiver object to receive complex data, set the IsMessageComplex property to true.

udps = dsp.UDPSender('RemoteIPPort',31000);
udpr = dsp.UDPReceiver('LocalIPPort',31000,'IsMessageComplex',true,'MessageDataType','double');

setup(udpr); 

bytesSent = 0;
bytesReceived = 0;
dataLength = 128;

Initialize the dsp.STFT and dsp.ISTFT System objects with a periodic hann window of length 120 samples and an overlap length of 60 samples. Set the FFT length to 128.

winLen = 120;
overlapLen = 60;

frameLen = winLen-overlapLen;
stf = dsp.STFT('Window',hann(winLen,'periodic'),'OverlapLength',overlapLen,'FFTLength',128);
istf = dsp.ISTFT('Window',hann(winLen,'periodic'),'OverlapLength',overlapLen,'WeightedOverlapAdd',0);

The input is a sinusoidal signal with a frequency of 100 Hz, a sample rate of 1000 Hz, and with 60 samples per each signal frame.

sine = dsp.SineWave('SamplesPerFrame',winLen-overlapLen,'Frequency',100);

Initialize a dsp.TimeScope object with a sample rate of 1000 Hz and a time span of 0.09. The Delay object corrects the overlap length while comparing the input with the reconstructed output signal.

ts  = dsp.TimeScope('SampleRate',1000,'ShowLegend',true,'YLimits',[-1 1],'TimeSpan',.09,...
    'ChannelNames',{'Input','Reconstructed'});
dly = dsp.Delay('Length',overlapLen);

Transmit complex STFT data of the sine wave over the UDP network. Compute the ISTFT of the received data. Compare the input, x, to the reconstructed output, y. Due to the latency introduced by the objects, the reconstructed output is shifted in time compared to the input. Therefore, to compare, take the norm of the difference between the reconstructed output, y, and the previous input, xprev.

Visualize the signals using a time scope. You can see that the reconstructed signal overlaps very closely with the input signal.

n = zeros(1,1e3);
xprev = 0;
for k = 1:1e3
   x = sine();
   X = stf(x);
   bytesSent = bytesSent + length(X);
   udps(X);
   dataReceived = udpr();
   if (~isempty(dataReceived))
       y = istf(dataReceived);
   end
   n(1,k) = norm(y-xprev);
   xprev = x;
   bytesReceived = bytesReceived + length(dataReceived);
   ts([dly(x),y]);
end

The norm of the difference is very small, indicating that the output signal is a perfectly reconstructed version of the input signal.

max(abs(n))
ans = 5.3870e-14

Release the UDP objects.

release(udps);
release(udpr);

Some of the packets sent can be lost during transmission due to the lossy nature of the UDP protocol. To check for loss, compare the bytes sent to the bytes received.

fprintf('Bytes sent:     %d\n', bytesSent);
Bytes sent:     128000
fprintf('Bytes received: %d\n', bytesReceived);
Bytes received: 128000

Extended Capabilities

Introduced in R2012a