tp_sender.cpp

/*
 *                   Copyright 2026 by KVASER AB, SWEDEN
 *
 *                        WWW: https://www.kvaser.com
 *
 * This software is furnished under a license and may be used and copied
 * only in accordance with the terms of such license.
 *
 */
 
#include <kvj1939lib.h>
 
#include <chrono>
#include <cstring>
#include <functional>
#include <iostream>
#include <memory>
#include <thread>
#include <vector>
 
// J1939 null address constant
static constexpr uint8_t J1939_NULL_ADDRESS = 254;
 
// J1939 channel class that wraps the J1939 C API.
//
// This class manages the lifetime of the channel handle and supports
// registering C++ lambda callbacks for channel events.
class J1939Channel {
private:
    J1939Channel() { }
 
    // Delete copy and move operations to prevent accidental handle duplication
    J1939Channel(const J1939Channel&) = delete;
    J1939Channel& operator=(const J1939Channel&) = delete;
    J1939Channel(J1939Channel&&) = delete;
    J1939Channel& operator=(J1939Channel&&) = delete;
 
public:
    // Define C++ callback signatures
    using OnAddressClaimedParams
        = std::function<void(uint8_t address, bool valid)>;
    using OnTxCompleteParams
        = std::function<void(uint32_t request_handle, bool success)>;
 
    ~J1939Channel()
    {
        if (_channel_handle != 0) {
            // Destroy (and close) channel when object is destroyed
            j1939_destroy_channel(_channel_handle);
        }
    }
 
    // Create a channel
    static std::unique_ptr<J1939Channel> create(int can_channel_index,
                                                int bitrate)
    {
        std::unique_ptr<J1939Channel> channel(new J1939Channel());
        J1939ChannelParams params;
        params.channel = can_channel_index;
        params.support_virtual = true;
        params.bit_rate = bitrate;
 
        J1939ChannelResult result = j1939_create_channel(params);
        if (result.result != J1939_STATUS_OK) {
            std::cerr << "Failed to create channel. Error code: "
                      << result.result << std::endl;
            return nullptr;
        }
        channel->_channel_handle = result.hnd;
 
        J1939Result res
            = j1939_register_callbacks(channel->_channel_handle, channel.get(),
                                       nullptr, tx_cb_wrapper, ac_cb_wrapper);
        if (res != J1939_STATUS_OK) {
            std::cerr << "Failed to register callbacks. Error code: " << res
                      << std::endl;
            return nullptr;
        }
 
        return channel;
    }
 
    // Open channel
    bool open()
    {
        if (_is_open) {
            return true;
        }
        J1939Result res = j1939_open_channel(_channel_handle);
        if (res != J1939_STATUS_OK) {
            std::cerr << "Failed to open channel. Error code: " << res
                      << std::endl;
            return false;
        }
        _is_open = true;
        if (_address != J1939_NULL_ADDRESS) {
            j1939_claim_address(_channel_handle, _address, _name);
        }
        return true;
    }
 
    // Close channel
    bool close()
    {
        if (!_is_open) {
            return true;
        }
        J1939Result res = j1939_close_channel(_channel_handle);
        if (res != J1939_STATUS_OK) {
            std::cerr << "Failed to close channel. Error code: " << res
                      << std::endl;
            return false;
        }
        _is_open = false;
        return true;
    }
 
    // Set address to be claimed
    void claim_address(uint8_t address, uint64_t name)
    {
        _address = address;
        _name = name;
        if (_is_open) {
            j1939_claim_address(_channel_handle, _address, _name);
        }
    }
 
    // Send a message from the claimed address
    uint32_t send_message(uint32_t pgn, uint8_t dest, uint8_t prio,
                          const std::vector<uint8_t>& data)
    {
        J1939WriteParams params;
        params.id.pgn = pgn;
        params.id.priority = prio;
        params.id.src_addr = _address;
        params.id.dest_addr = dest;
        params.payload = data.data();
        params.payload_length = (uint32_t)data.size();
        params.request_handle = ++_tx_handle_counter;
 
        J1939Result res = j1939_write(_channel_handle, params);
        if (res != J1939_STATUS_OK) {
            std::cerr << "j1939_write failed: " << res << std::endl;
            return 0;
        }
        // Return the request handle
        return params.request_handle;
    }
 
    // Register user-provided lambda hooks
    void register_on_address_claimed(OnAddressClaimedParams cb)
    {
        _ac_callback = cb;
    }
    void register_on_tx_complete(OnTxCompleteParams cb) { _tx_callback = cb; }
 
private:
    J1939ChannelHandle _channel_handle = 0;
    bool _is_open = false;
    uint32_t _tx_handle_counter = 0;
    uint8_t _address = J1939_NULL_ADDRESS;
    uint64_t _name = 0;
    OnAddressClaimedParams _ac_callback;
    OnTxCompleteParams _tx_callback;
 
    // Static callback wrappers
    static void tx_cb_wrapper(J1939ChannelHandle channel, void* context,
                              uint32_t request_handle, J1939Identifier id,
                              uint64_t timestamp, bool error)
    {
        auto* ch = static_cast<J1939Channel*>(context);
        if (ch && ch->_tx_callback) {
            ch->_tx_callback(request_handle, !error);
        }
    }
    static void ac_cb_wrapper(J1939ChannelHandle channel, void* context,
                              uint8_t address, bool valid)
    {
        auto* ch = static_cast<J1939Channel*>(context);
        if (ch && ch->_ac_callback) {
            ch->_ac_callback(address, valid);
        }
    }
};
 
// Prints out the help message for the command line options
void print_help()
{
    printf(
        "Usage: tp_sender [options]\n"
        "Options:\n"
        "  --channel <channel>, -c <channel>     Set CAN channel (default: 0)\n"
        "  --bit-rate <bit_rate>, -b <bit_rate>  Set CAN bit rate (default: "
        "250000)\n"
        "  --help, -h                            Show this help message\n");
}
 
// Example application demonstrating address claiming and sending a multi-frame
// J1939 message using the Kvaser J1939 library.
//
// This function creates a J1939 channel, claims address 0x80, and sends a
// multi-frame BAM message once the address claim is successful. C++ lambda
// functions are used to handle channel events asynchronously.
int main(int argc, char** argv)
{
    unsigned int channel_no = 0;
    unsigned int bit_rate = 250000;
 
    // Parse command line arguments
    for (int i = 1; i < argc; ++i) {
        if ((strcmp(argv[i], "--channel") == 0 || strcmp(argv[i], "-c") == 0)
            && i + 1 < argc) {
            channel_no = (unsigned int)strtoul(argv[++i], NULL, 0);
        } else if ((strcmp(argv[i], "--bit-rate") == 0
                    || strcmp(argv[i], "-b") == 0)
                   && i + 1 < argc) {
            bit_rate = (unsigned int)strtoul(argv[++i], NULL, 0);
        } else {
            print_help();
            return 0;
        }
    }
 
    auto channel = J1939Channel::create(channel_no, bit_rate);
 
    if (!channel) {
        std::cerr << "Failed to create J1939 channel." << std::endl;
        return 1;
    }
 
    // Set address which will be claimed when channel is opened
    channel->claim_address(0x80, 0x123456789ABCDEF0);
 
    // Prepare message
    struct message_t {
        uint32_t pgn;
        uint8_t dest;
        std::vector<uint8_t> data;
    } message = {
        0x00F400,
        0xFF,
        { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
          0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
          0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20 },
    };
    uint32_t my_tx_handle = 0;
 
    // Address claim callback
    // Will send the message when address claim is completed
    channel->register_on_address_claimed([&](uint8_t address, bool valid) {
        if (valid) {
            std::cout << "[Callback] Address " << (int)address
                      << " claimed successfully." << std::endl;
            my_tx_handle = channel->send_message(message.pgn, message.dest, 7,
                                                 message.data);
        } else {
            std::cout << "[Callback] Address claim failed for " << (int)address
                      << "." << std::endl;
            std::exit(1);
        }
    });
 
    // TX Complete callback
    // Will exit the application when our message has been sent
    channel->register_on_tx_complete([&](uint32_t tx_handle, bool success) {
        if (tx_handle == my_tx_handle) {
            if (success) {
                std::cout << "[Callback] Message successfully sent!"
                          << std::endl;
                std::exit(0);
            } else {
                std::cout << "[Callback] Failed to send message!" << std::endl;
                std::exit(1);
            }
        }
    });
 
    // Open channel (will trigger address claim)
    std::cout << "Opening J1939 channel..." << std::endl;
    if (!channel->open()) {
        std::cerr << "Failed to open J1939 channel." << std::endl;
        return 1;
    }
 
    std::cout << "Waiting for events..." << std::endl;
 
    std::this_thread::sleep_for(std::chrono::milliseconds(5000));
    std::cerr << "Timeout while waiting for events." << std::endl;
    return 1;
}