mip_interface.c

Go to the documentation of this file.

 
#include "mip_interface.h"
 
#include "mip_field.h"
 
#include "definitions/descriptors.h"
 
#include <assert.h>
 
#include <stdio.h>
 
 
 
 
void mip_interface_init(
    mip_interface* device, uint8_t* parse_buffer, size_t parse_buffer_size,
    mip_timeout parse_timeout, mip_timeout base_reply_timeout,
    mip_send_callback send, mip_recv_callback recv,
    mip_update_callback update, void* user_pointer)
{
    mip_parser_init(&device->_parser, parse_buffer, parse_buffer_size, &mip_interface_parse_callback, device, parse_timeout);
 
    device->_max_update_pkts = MIPPARSER_UNLIMITED_PACKETS;
    device->_send_callback   = send;
    device->_recv_callback   = recv;
    device->_update_callback = update;
    device->_user_pointer    = user_pointer;
 
    mip_cmd_queue_init(&device->_queue, base_reply_timeout);
 
    mip_dispatcher_init(&device->_dispatcher);
}
 
 
//
// Accessors
//
 
 
void mip_interface_set_send_function(mip_interface* device, mip_send_callback callback)
{
    device->_send_callback = callback;
}
 
mip_send_callback mip_interface_send_function(const mip_interface* device)
{
    return device->_send_callback;
}
 
 
void mip_interface_set_recv_function(mip_interface* device, mip_recv_callback callback)
{
    device->_recv_callback = callback;
}
 
mip_recv_callback mip_interface_recv_function(const mip_interface* device)
{
    return device->_recv_callback;
}
 
 
void mip_interface_set_update_function(mip_interface* device, mip_update_callback callback)
{
    device->_update_callback = callback;
}
 
 
mip_update_callback mip_interface_update_function(const mip_interface* device)
{
    return device->_update_callback;
}
 
 
void mip_interface_set_user_pointer(mip_interface* device, void* pointer)
{
    device->_user_pointer = pointer;
}
 
void* mip_interface_user_pointer(const mip_interface* device)
{
    return device->_user_pointer;
}
 
 
unsigned int mip_interface_max_packets_per_update(const mip_interface* device)
{
    return device->_max_update_pkts;
}
 
void mip_interface_set_max_packets_per_update(mip_interface* device, unsigned int max_packets)
{
    device->_max_update_pkts = max_packets;
}
 
 
mip_parser* mip_interface_parser(mip_interface* device)
{
    return &device->_parser;
}
 
mip_cmd_queue* mip_interface_cmd_queue(mip_interface* device)
{
    return &device->_queue;
}
 
 
//
// Communications
//
 
 
bool mip_interface_send_to_device(mip_interface* device, const uint8_t* data, size_t length)
{
    return device->_send_callback && device->_send_callback(device, data, length);
}
 
bool mip_interface_recv_from_device(mip_interface* device, uint8_t* buffer, size_t max_length, mip_timeout wait_time, size_t* length_out, mip_timestamp* timestamp_out)
{
    return device->_recv_callback && device->_recv_callback(device, buffer, max_length, wait_time, length_out, timestamp_out);
}
 
 
bool mip_interface_update(struct mip_interface* device, mip_timeout wait_time)
{
    if( !device->_update_callback )
        return false;
 
    return device->_update_callback(device, wait_time);
}
 
 
bool mip_interface_default_update(struct mip_interface* device, mip_timeout wait_time)
{
    if( !device->_recv_callback )
        return false;
 
    uint8_t* ptr;
    mip_parser* parser = mip_interface_parser(device);
    size_t max_count   = mip_parser_get_write_ptr(parser, &ptr);
 
    size_t        count     = 0;
    mip_timestamp timestamp = 0;
    if ( !mip_interface_recv_from_device(device, ptr, max_count, wait_time, &count, &timestamp) )
        return false;
 
    assert(count <= max_count);
 
    mip_parser_process_written(parser, count, timestamp, 0);
 
    mip_cmd_queue_update(mip_interface_cmd_queue(device), timestamp);
 
    return true;
}
 
 
size_t mip_interface_receive_bytes(mip_interface* device, const uint8_t* data, size_t length, mip_timestamp timestamp)
{
    return mip_parser_parse(&device->_parser, data, length, timestamp, device->_max_update_pkts);
}
 
void mip_interface_process_unparsed_packets(mip_interface* device)
{
    mip_parser_parse(&device->_parser, NULL, 0, mip_parser_last_packet_timestamp(&device->_parser), device->_max_update_pkts);
}
 
void mip_interface_receive_packet(mip_interface* device, const mip_packet* packet, mip_timestamp timestamp)
{
    mip_cmd_queue_process_packet(&device->_queue, packet, timestamp);
    mip_dispatcher_dispatch_packet(&device->_dispatcher, packet, timestamp);
}
 
bool mip_interface_parse_callback(void* device, const mip_packet* packet, mip_timestamp timestamp)
{
    mip_interface_receive_packet(device, packet, timestamp);
 
    return true;
}
 
 
//
// Command and data processing
//
 
 
enum mip_cmd_result mip_interface_wait_for_reply(mip_interface* device, mip_pending_cmd* cmd)
{
    enum mip_cmd_result status;
    while( !mip_cmd_result_is_finished(status = mip_pending_cmd_status(cmd)) )
    {
        if( !mip_interface_update(device, true) )
        {
            // When this function returns the pending command may be deallocated and the
            // queue will have a dangling pointer. Therefore, the command must be manually
            // errored out and de-queued.
            //
            // Note: This fix can still cause a race condition in multithreaded apps if the
            // update thread happens to run right before the cmd is dequeued. The user is
            // advised to not fail the update callback when another thread is handling
            // reception, unless that thread is not running. Generally such updates shouldn't
            // fail as long as the other thread is working normally anyway.
 
            mip_cmd_queue_dequeue(mip_interface_cmd_queue(device), cmd);
            cmd->_status = MIP_STATUS_ERROR;
 
            return MIP_STATUS_ERROR;
        }
    }
    return status;
}
 
enum mip_cmd_result mip_interface_run_command(mip_interface* device, uint8_t descriptor_set, uint8_t cmd_descriptor, const uint8_t* cmd_data, uint8_t cmd_length)
{
    return mip_interface_run_command_with_response(device, descriptor_set, cmd_descriptor, cmd_data, cmd_length, MIP_INVALID_FIELD_DESCRIPTOR, NULL, NULL);
}
 
enum mip_cmd_result mip_interface_run_command_with_response(mip_interface* device,
    uint8_t descriptor_set, uint8_t cmd_descriptor, const uint8_t* cmd_data, uint8_t cmd_length,
    uint8_t response_descriptor, uint8_t* response_buffer, uint8_t* response_length_inout)
{
    assert((response_descriptor == MIP_INVALID_FIELD_DESCRIPTOR) || ((response_buffer != NULL) && (response_length_inout != NULL)) );
 
    uint8_t buffer[MIP_PACKET_LENGTH_MAX];
 
    mip_packet packet;
    mip_packet_create(&packet, buffer, sizeof(buffer), descriptor_set);
    mip_packet_add_field(&packet, cmd_descriptor, cmd_data, cmd_length);
    mip_packet_finalize(&packet);
 
    mip_pending_cmd cmd;
    const uint8_t response_length = response_length_inout ? *response_length_inout : 0;
    mip_pending_cmd_init_with_response(&cmd, descriptor_set, cmd_descriptor, response_descriptor, response_buffer, response_length);
 
    enum mip_cmd_result result = mip_interface_run_command_packet(device, &packet, &cmd);
 
    if( response_length_inout )
        *response_length_inout = mip_pending_cmd_response_length(&cmd);
 
    return result;
}
 
enum mip_cmd_result mip_interface_run_command_packet(mip_interface* device, const mip_packet* packet, mip_pending_cmd* cmd)
{
    if( !mip_interface_start_command_packet(device, packet, cmd) )
        return MIP_STATUS_ERROR;
 
    return mip_interface_wait_for_reply(device, cmd);
}
 
bool mip_interface_start_command_packet(mip_interface* device, const mip_packet* packet, mip_pending_cmd* cmd)
{
    mip_cmd_queue_enqueue(mip_interface_cmd_queue(device), cmd);
 
    if( !mip_interface_send_to_device(device, mip_packet_pointer(packet), mip_packet_total_length(packet)) )
    {
        mip_cmd_queue_dequeue(mip_interface_cmd_queue(device), cmd);
        return false;
    }
 
    return true;
}
 
void mip_interface_register_packet_callback(
    mip_interface* device, mip_dispatch_handler* handler,
    uint8_t descriptor_set, bool after_fields, mip_dispatch_packet_callback callback, void* user_data)
{
    mip_dispatch_handler_init_packet_handler(handler, descriptor_set, after_fields, callback, user_data);
    mip_dispatcher_add_handler(&device->_dispatcher, handler);
}
 
 
void mip_interface_register_field_callback(
    mip_interface* device, mip_dispatch_handler* handler,
    uint8_t descriptor_set, uint8_t field_descriptor, mip_dispatch_field_callback callback, void* user_data)
{
    mip_dispatch_handler_init_field_handler(handler, descriptor_set, field_descriptor, callback, user_data);
    mip_dispatcher_add_handler(&device->_dispatcher, handler);
}
 
void mip_interface_register_extractor(
    mip_interface* device, mip_dispatch_handler* handler,
    uint8_t descriptor_set, uint8_t field_descriptor,
    mip_dispatch_extractor extractor, void* field_ptr)
{
    mip_dispatch_handler_init_extractor(handler, descriptor_set, field_descriptor, extractor, field_ptr);
    mip_dispatcher_add_handler(&device->_dispatcher, handler);
}