TCP/IP Simulink not receiving data

Question

I’m trying to send data from a C++ program to Simulink for further processing. For testing purposes, I’m doing it on the same computer to expand this further to send the data to another computer. I tried doing this over a TCP connection. To receive the data in Simulink, I'm using a TCP/IP Client Receive block Unfortunately, I can’t get the block working to receive any data.

To double-check the connection, I used the program Wireshark and the data is being sent from C++ successfully. First, I tried to send a string with 3 comma-separated coordinates. After this, I sent only a double but this also is not working. I tried to check the status of The Simulink block and only got False, so the block does not receive any data. For the string, maybe the parsing is the problem but I also can’t get the double working. Does anyone have a clue how to proceed?

This is a snippet of C++ code Im using to send the information.

// Initialize the endpoint to the loopback IP address and a specific port number
remote_endpoint = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("127.0.0.1"), 9999);

std::cout << "Socket opened successfully" << std::endl;
std::cout << "Connecting to: " << remote_endpoint.address() << ":" << remote_endpoint.port() << std::endl;

try {
    tcp_socket.connect(remote_endpoint);
} catch (const boost::system::system_error& e) {
    std::cout << "Failed to connect: " << e.what() << std::endl;
}

//tcp_socket.connect(remote_endpoint);
std::cout << "Connected successfully" << std::endl;

A print of the string seperated with a comma:

975000,518.000000,287.000000
980000,518.000000,287.000000
985000,518.000000,287.000000
990000,518.000000,287.000000
995000,518.000000,287.000000

This is the Simulink setup:

Simulink Block and Simulink Data types

Update

This is the code that I tried to use:

  // Pack the timestamp into a double
        double data = static_cast<double>(ts);

        // Print the timestamp
        std::cout << "Timestamp: " << data << std::endl;

        // Send the data over TCP
        boost::system::error_code error;
        boost::endian::big_to_native_inplace(data);
        boost::asio::write(tcp_socket, boost::asio::buffer(&data, sizeof(data)), error);

        // Error handling
        if(!error) {
            std::cout << "Data sent successfully!" << std::endl;
        } else {
            std::cout << "Send failed: " << error.message() << std::endl;
        }

I suspect that the datasize attribute in the Simulink block is misconfigured and I don’t exactly know what it represents. I initially thought it is the byte amount received but I found the Simulink documentation quite vague.

Answer 1

You never show the code that actually sends. So, we don't know what you're sending nor how.

My best guess is you need to keep in mind the fact that Simulink expects big-endian data. Compare:

#include <boost/endian/conversion.hpp>
#include <boost/asio.hpp>
#include <iostream>

namespace asio = boost::asio;
using asio::ip::tcp;

int main() {
    tcp::socket tcp_socket(asio::system_executor{});
    tcp_socket.connect({{}, 9999});
    std::cout << "Connected: " << tcp_socket.remote_endpoint() << "\n";

    std::vector<double> dd{
        975000, 518.000000, 287.000000, //
        980000, 518.000000, 287.000000, //
        985000, 518.000000, 287.000000, //
        990000, 518.000000, 287.000000, //
        995000, 518.000000, 287.000000,
    };

    write(tcp_socket, asio::buffer(dd));

    for (auto& d : dd)
        boost::endian::big_to_native_inplace(d);

    write(tcp_socket, asio::buffer(dd));
}

When testing against netcat e.g.

nc -lp 9999 | od --endian=big =tf8

May print (assuming little-endian architecture, like on my linux box):

Clearly, only after the endianness conversion the data are correct

BONUS!

Consider automatic conversions and domain type. The tuples in your string representation suggest a point type, like:

Live On Coliru

#include <boost/asio.hpp>
#include <boost/endian/arithmetic.hpp>
#include <iostream>

template <typename Real> struct Point {
    Real x, y, z;
    friend std::ostream& operator<<(std::ostream& os, Point p) {
        return os << "{ " << p.x << ", " << p.y << ", " << p.z << " }";
    }
};

using NetPoint = Point<boost::endian::big_float64_t>;
static_assert(std::is_trivially_copyable_v<NetPoint>);
static_assert(std::is_standard_layout_v<NetPoint>);
static_assert(sizeof(double) * 3 == sizeof(NetPoint));

namespace asio = boost::asio;
using asio::ip::tcp;

int main() {
    tcp::socket tcp_socket(asio::system_executor{});
    tcp_socket.connect({{}, 9999});
    std::cout << "Connected: " << tcp_socket.remote_endpoint() << "\n";

    std::vector<NetPoint> dd{
        {975000, 518.000000, 287.000000}, 
        {980000, 518.000000, 287.000000},
        {985000, 518.000000, 287.000000},
        {990000, 518.000000, 287.000000},
        {995000, 518.000000, 287.000000},
    };

    write(tcp_socket, asio::buffer(dd));
}

With similar output