LibrePilot/flight/uavtalk/uavtalk.c

/**
 ******************************************************************************
 * @addtogroup OpenPilotSystem OpenPilot System
 * @{
 * @addtogroup OpenPilotLibraries OpenPilot System Libraries
 * @{
 *
 * @file       uavtalk.c
 * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
 * @brief      UAVTalk library, implements to telemetry protocol. See the wiki for more details.
 *             This library should not be called directly by the application, it is only used by the
 *             Telemetry module.
 * @see        The GNU Public License (GPL) Version 3
 *
 *****************************************************************************/
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include "openpilot.h"
#include "uavtalk_priv.h"

// #define UAV_DEBUGLOG 1

#if defined UAV_DEBUGLOG && defined FLASH_FREERTOS
#define UAVT_DEBUGLOG_PRINTF(...) PIOS_DEBUGLOG_Printf(__VA_ARGS__)
// uncomment and adapt the following lines to filter verbose logging to include specific object(s) only
// #include "flighttelemetrystats.h"
// #define UAVT_DEBUGLOG_CPRINTF(objId, ...) if (objId == FLIGHTTELEMETRYSTATS_OBJID) { UAVT_DEBUGLOG_PRINTF(__VA_ARGS__); }
#endif
#ifndef UAVT_DEBUGLOG_PRINTF
#define UAVT_DEBUGLOG_PRINTF(...)
#endif
#ifndef UAVT_DEBUGLOG_CPRINTF
#define UAVT_DEBUGLOG_CPRINTF(objId, ...)
#endif

// Private functions
static int32_t objectTransaction(UAVTalkConnectionData *connection, uint8_t type, UAVObjHandle obj, uint16_t instId, int32_t timeout);
static int32_t sendObject(UAVTalkConnectionData *connection, uint8_t type, uint32_t objId, uint16_t instId, UAVObjHandle obj);
static int32_t sendSingleObject(UAVTalkConnectionData *connection, uint8_t type, uint32_t objId, uint16_t instId, UAVObjHandle obj);
static int32_t receiveObject(UAVTalkConnectionData *connection, uint8_t type, uint32_t objId, uint16_t instId, uint8_t *data);
static void updateAck(UAVTalkConnectionData *connection, uint8_t type, uint32_t objId, uint16_t instId);
// UavTalk Process FSM functions
static bool UAVTalkProcess_SYNC(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position);
static bool UAVTalkProcess_TYPE(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position);
static bool UAVTalkProcess_OBJID(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position);
static bool UAVTalkProcess_INSTID(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position);
static bool UAVTalkProcess_SIZE(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position);
static bool UAVTalkProcess_TIMESTAMP(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position);
static bool UAVTalkProcess_DATA(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position);
static bool UAVTalkProcess_CS(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position);
/**
 * Initialize the UAVTalk library
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] outputStream Function pointer that is called to send a data buffer
 * \return 0 Success
 * \return -1 Failure
 */
UAVTalkConnection UAVTalkInitialize(UAVTalkOutputStream outputStream)
{
    // allocate object
    UAVTalkConnectionData *connection = pios_malloc(sizeof(UAVTalkConnectionData));

    if (!connection) {
        return 0;
    }
    connection->canari      = UAVTALK_CANARI;
    connection->iproc.rxPacketLength = 0;
    connection->iproc.state = UAVTALK_STATE_SYNC;
    connection->outStream   = outputStream;
    connection->lock = xSemaphoreCreateRecursiveMutex();
    connection->transLock   = xSemaphoreCreateRecursiveMutex();
    // allocate buffers
    connection->rxBuffer    = pios_malloc(UAVTALK_MAX_PACKET_LENGTH);
    if (!connection->rxBuffer) {
        return 0;
    }
    connection->txBuffer = pios_malloc(UAVTALK_MAX_PACKET_LENGTH);
    if (!connection->txBuffer) {
        return 0;
    }
    vSemaphoreCreateBinary(connection->respSema);
    xSemaphoreTake(connection->respSema, 0); // reset to zero
    UAVTalkResetStats((UAVTalkConnection)connection);
    return (UAVTalkConnection)connection;
}

/**
 * Set the communication output stream
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] outputStream Function pointer that is called to send a data buffer
 * \return 0 Success
 * \return -1 Failure
 */
int32_t UAVTalkSetOutputStream(UAVTalkConnection connectionHandle, UAVTalkOutputStream outputStream)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return -1);

    // Lock
    xSemaphoreTakeRecursive(connection->lock, portMAX_DELAY);

    // set output stream
    connection->outStream = outputStream;

    // Release lock
    xSemaphoreGiveRecursive(connection->lock);

    return 0;
}

/**
 * Get current output stream
 * \param[in] connection UAVTalkConnection to be used
 * @return UAVTarlkOutputStream the output stream used
 */
UAVTalkOutputStream UAVTalkGetOutputStream(UAVTalkConnection connectionHandle)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return NULL);
    return connection->outStream;
}

/**
 * Get communication statistics counters
 * \param[in] connection UAVTalkConnection to be used
 * @param[out] statsOut Statistics counters
 */
void UAVTalkGetStats(UAVTalkConnection connectionHandle, UAVTalkStats *statsOut, bool reset)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return );

    // Lock
    xSemaphoreTakeRecursive(connection->lock, portMAX_DELAY);

    // Copy stats
    memcpy(statsOut, &connection->stats, sizeof(UAVTalkStats));

    if (reset) {
        // Clear stats
        memset(&connection->stats, 0, sizeof(UAVTalkStats));
    }

    // Release lock
    xSemaphoreGiveRecursive(connection->lock);
}

/**
 * Get communication statistics counters
 * \param[in] connection UAVTalkConnection to be used
 * @param[out] statsOut Statistics counters
 */
void UAVTalkAddStats(UAVTalkConnection connectionHandle, UAVTalkStats *statsOut, bool reset)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return );

    // Lock
    xSemaphoreTakeRecursive(connection->lock, portMAX_DELAY);

    // Copy stats
    statsOut->txBytes       += connection->stats.txBytes;
    statsOut->txObjectBytes += connection->stats.txObjectBytes;
    statsOut->txObjects     += connection->stats.txObjects;
    statsOut->txErrors      += connection->stats.txErrors;
    statsOut->rxBytes       += connection->stats.rxBytes;
    statsOut->rxObjectBytes += connection->stats.rxObjectBytes;
    statsOut->rxObjects     += connection->stats.rxObjects;
    statsOut->rxErrors      += connection->stats.rxErrors;
    statsOut->rxSyncErrors  += connection->stats.rxSyncErrors;
    statsOut->rxCrcErrors   += connection->stats.rxCrcErrors;

    if (reset) {
        // Clear stats
        memset(&connection->stats, 0, sizeof(UAVTalkStats));
    }

    // Release lock
    xSemaphoreGiveRecursive(connection->lock);
}

/**
 * Reset the statistics counters.
 * \param[in] connection UAVTalkConnection to be used
 */
void UAVTalkResetStats(UAVTalkConnection connectionHandle)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return );

    // Lock
    xSemaphoreTakeRecursive(connection->lock, portMAX_DELAY);

    // Clear stats
    memset(&connection->stats, 0, sizeof(UAVTalkStats));

    // Release lock
    xSemaphoreGiveRecursive(connection->lock);
}

/**
 * Accessor method to get the timestamp from the last UAVTalk message
 */
void UAVTalkGetLastTimestamp(UAVTalkConnection connectionHandle, uint16_t *timestamp)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return );

    UAVTalkInputProcessor *iproc = &connection->iproc;
    *timestamp = iproc->timestamp;
}

/**
 * Request an update for the specified object, on success the object data would have been
 * updated by the GCS.
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] obj Object to update
 * \param[in] instId The instance ID or UAVOBJ_ALL_INSTANCES for all instances.
 * \param[in] timeout Time to wait for the response, when zero it will return immediately
 * \return 0 Success
 * \return -1 Failure
 */
int32_t UAVTalkSendObjectRequest(UAVTalkConnection connectionHandle, UAVObjHandle obj, uint16_t instId, int32_t timeout)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return -1);

    return objectTransaction(connection, UAVTALK_TYPE_OBJ_REQ, obj, instId, timeout);
}

/**
 * Send the specified object through the telemetry link.
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] obj Object to send
 * \param[in] instId The instance ID or UAVOBJ_ALL_INSTANCES for all instances.
 * \param[in] acked Selects if an ack is required (1:ack required, 0: ack not required)
 * \param[in] timeoutMs Time to wait for the ack, when zero it will return immediately
 * \return 0 Success
 * \return -1 Failure
 */
int32_t UAVTalkSendObject(UAVTalkConnection connectionHandle, UAVObjHandle obj, uint16_t instId, uint8_t acked, int32_t timeoutMs)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return -1);

    // Send object
    if (acked == 1) {
        return objectTransaction(connection, UAVTALK_TYPE_OBJ_ACK, obj, instId, timeoutMs);
    } else {
        return objectTransaction(connection, UAVTALK_TYPE_OBJ, obj, instId, timeoutMs);
    }
}

/**
 * Send the specified object through the telemetry link with a timestamp.
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] obj Object to send
 * \param[in] instId The instance ID or UAVOBJ_ALL_INSTANCES for all instances.
 * \param[in] acked Selects if an ack is required (1:ack required, 0: ack not required)
 * \param[in] timeoutMs Time to wait for the ack, when zero it will return immediately
 * \return 0 Success
 * \return -1 Failure
 */
int32_t UAVTalkSendObjectTimestamped(UAVTalkConnection connectionHandle, UAVObjHandle obj, uint16_t instId, uint8_t acked, int32_t timeoutMs)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return -1);

    // Send object
    if (acked == 1) {
        return objectTransaction(connection, UAVTALK_TYPE_OBJ_ACK_TS, obj, instId, timeoutMs);
    } else {
        return objectTransaction(connection, UAVTALK_TYPE_OBJ_TS, obj, instId, timeoutMs);
    }
}

/**
 * Execute the requested transaction on an object.
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] type Transaction type
 *                        UAVTALK_TYPE_OBJ: send object,
 *                        UAVTALK_TYPE_OBJ_REQ: request object update
 *                        UAVTALK_TYPE_OBJ_ACK: send object with an ack
 * \param[in] obj Object
 * \param[in] instId The instance ID of UAVOBJ_ALL_INSTANCES for all instances.
 * \param[in] timeoutMs Time to wait for the ack, when zero it will return immediately
 * \return 0 Success
 * \return -1 Failure
 */
static int32_t objectTransaction(UAVTalkConnectionData *connection, uint8_t type, UAVObjHandle obj, uint16_t instId, int32_t timeoutMs)
{
    int32_t respReceived;
    int32_t ret = -1;

    // Send object depending on if a response is needed
    if (type == UAVTALK_TYPE_OBJ_ACK || type == UAVTALK_TYPE_OBJ_ACK_TS || type == UAVTALK_TYPE_OBJ_REQ) {
        // Get transaction lock (will block if a transaction is pending)
        xSemaphoreTakeRecursive(connection->transLock, portMAX_DELAY);
        // Send object
        xSemaphoreTakeRecursive(connection->lock, portMAX_DELAY);
        // expected response type
        connection->respType   = (type == UAVTALK_TYPE_OBJ_REQ) ? UAVTALK_TYPE_OBJ : UAVTALK_TYPE_ACK;
        connection->respObjId  = UAVObjGetID(obj);
        connection->respInstId = instId;
        ret = sendObject(connection, type, UAVObjGetID(obj), instId, obj);
        xSemaphoreGiveRecursive(connection->lock);
        // Wait for response (or timeout) if sending the object succeeded
        respReceived = pdFALSE;
        if (ret == 0) {
            respReceived = xSemaphoreTake(connection->respSema, timeoutMs / portTICK_RATE_MS);
        }
        // Check if a response was received
        if (respReceived == pdTRUE) {
            // We are done successfully
            xSemaphoreGiveRecursive(connection->transLock);
            ret = 0;
        } else {
            // Cancel transaction
            xSemaphoreTakeRecursive(connection->lock, portMAX_DELAY);
            // non blocking call to make sure the value is reset to zero (binary sema)
            xSemaphoreTake(connection->respSema, 0);
            connection->respObjId = 0;
            xSemaphoreGiveRecursive(connection->lock);
            xSemaphoreGiveRecursive(connection->transLock);
            return -1;
        }
    } else if (type == UAVTALK_TYPE_OBJ || type == UAVTALK_TYPE_OBJ_TS) {
        xSemaphoreTakeRecursive(connection->lock, portMAX_DELAY);
        ret = sendObject(connection, type, UAVObjGetID(obj), instId, obj);
        xSemaphoreGiveRecursive(connection->lock);
    }
    return ret;
}

/**
 * Process an byte from the telemetry stream.
 * \param[in] connectionHandle UAVTalkConnection to be used
 * \param[in] rxbuffer Received buffer
 * \param[in/out] Length in bytes of received buffer
 * \param[in/out] position Next item to be read inside rxbuffer
 * \return UAVTalkRxState
 */
UAVTalkRxState UAVTalkProcessInputStreamQuiet(UAVTalkConnection connectionHandle, uint8_t *rxbuffer, uint8_t length, uint8_t *position)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return -1);

    UAVTalkInputProcessor *iproc = &connection->iproc;

    if (iproc->state == UAVTALK_STATE_ERROR || iproc->state == UAVTALK_STATE_COMPLETE) {
        iproc->state = UAVTALK_STATE_SYNC;
    }

    uint8_t processedBytes = (*position);

    // stop processing as soon as a complete packet is received, error is encountered or buffer is processed entirely
    while ((length > (*position))
           && iproc->state != UAVTALK_STATE_COMPLETE
           && iproc->state != UAVTALK_STATE_ERROR) {
        // Receive state machine
        if ((length > (*position)) && iproc->state == UAVTALK_STATE_SYNC &&
            !UAVTalkProcess_SYNC(connection, iproc, rxbuffer, length, position)) {
            break;
        }

        if ((length > (*position)) && iproc->state == UAVTALK_STATE_TYPE &&
            !UAVTalkProcess_TYPE(connection, iproc, rxbuffer, length, position)) {
            break;
        }

        if ((length > (*position)) && iproc->state == UAVTALK_STATE_SIZE &&
            !UAVTalkProcess_SIZE(connection, iproc, rxbuffer, length, position)) {
            break;
        }

        if ((length > (*position)) && iproc->state == UAVTALK_STATE_OBJID &&
            !UAVTalkProcess_OBJID(connection, iproc, rxbuffer, length, position)) {
            break;
        }

        if ((length > (*position)) && iproc->state == UAVTALK_STATE_INSTID &&
            !UAVTalkProcess_INSTID(connection, iproc, rxbuffer, length, position)) {
            break;
        }

        if ((length > (*position)) && iproc->state == UAVTALK_STATE_TIMESTAMP &&
            !UAVTalkProcess_TIMESTAMP(connection, iproc, rxbuffer, length, position)) {
            break;
        }

        if ((length > (*position)) && iproc->state == UAVTALK_STATE_DATA &&
            !UAVTalkProcess_DATA(connection, iproc, rxbuffer, length, position)) {
            break;
        }

        if ((length > (*position)) && iproc->state == UAVTALK_STATE_CS &&
            !UAVTalkProcess_CS(connection, iproc, rxbuffer, length, position)) {
            break;
        }
    }

    // Done
    processedBytes = (*position) - processedBytes;
    connection->stats.rxBytes += processedBytes;
    return iproc->state;
}

/**
 * Process a buffer from the telemetry stream.
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] rxbuffer Received buffer
 * \param[in] count bytes inside rxbuffer
 * \return UAVTalkRxState
 */
UAVTalkRxState UAVTalkProcessInputStream(UAVTalkConnection connectionHandle, uint8_t *rxbuffer, uint8_t length)
{
    uint8_t position     = 0;
    UAVTalkRxState state = UAVTALK_STATE_ERROR;

    while (position < length) {
        state = UAVTalkProcessInputStreamQuiet(connectionHandle, rxbuffer, length, &position);
        if (state == UAVTALK_STATE_COMPLETE) {
            UAVTalkReceiveObject(connectionHandle);
        }
    }
    return state;
}

/**
 * Send a parsed packet received on one connection handle out on a different connection handle.
 * The packet must be in a complete state, meaning it is completed parsing.
 * The packet is re-assembled from the component parts into a complete message and sent.
 * This can be used to relay packets from one UAVTalk connection to another.
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] rxbyte Received byte
 * \return 0 Success
 * \return -1 Failure
 */
int32_t UAVTalkRelayPacket(UAVTalkConnection inConnectionHandle, UAVTalkConnection outConnectionHandle)
{
    UAVTalkConnectionData *inConnection;

    CHECKCONHANDLE(inConnectionHandle, inConnection, return -1);
    UAVTalkInputProcessor *inIproc = &inConnection->iproc;

    // The input packet must be completely parsed.
    if (inIproc->state != UAVTALK_STATE_COMPLETE) {
        inConnection->stats.rxErrors++;

        return -1;
    }

    UAVTalkConnectionData *outConnection;
    CHECKCONHANDLE(outConnectionHandle, outConnection, return -1);

    if (!outConnection->outStream) {
        outConnection->stats.txErrors++;

        return -1;
    }

    // Lock
    xSemaphoreTakeRecursive(outConnection->lock, portMAX_DELAY);

    outConnection->txBuffer[0] = UAVTALK_SYNC_VAL;
    // Setup type
    outConnection->txBuffer[1] = inIproc->type;
    // next 2 bytes are reserved for data length (inserted here later)
    // Setup object ID
    outConnection->txBuffer[4] = (uint8_t)(inIproc->objId & 0xFF);
    outConnection->txBuffer[5] = (uint8_t)((inIproc->objId >> 8) & 0xFF);
    outConnection->txBuffer[6] = (uint8_t)((inIproc->objId >> 16) & 0xFF);
    outConnection->txBuffer[7] = (uint8_t)((inIproc->objId >> 24) & 0xFF);
    // Setup instance ID
    outConnection->txBuffer[8] = (uint8_t)(inIproc->instId & 0xFF);
    outConnection->txBuffer[9] = (uint8_t)((inIproc->instId >> 8) & 0xFF);
    int32_t headerLength = 10;

    // Add timestamp when the transaction type is appropriate
    if (inIproc->type & UAVTALK_TIMESTAMPED) {
        portTickType time = xTaskGetTickCount();
        outConnection->txBuffer[10] = (uint8_t)(time & 0xFF);
        outConnection->txBuffer[11] = (uint8_t)((time >> 8) & 0xFF);
        headerLength += 2;
    }

    // Copy data (if any)
    if (inIproc->length > 0) {
        memcpy(&outConnection->txBuffer[headerLength], inConnection->rxBuffer, inIproc->length);
    }

    // Store the packet length
    outConnection->txBuffer[2] = (uint8_t)((headerLength + inIproc->length) & 0xFF);
    outConnection->txBuffer[3] = (uint8_t)(((headerLength + inIproc->length) >> 8) & 0xFF);

    // Copy the checksum
    outConnection->txBuffer[headerLength + inIproc->length] = inIproc->cs;

    // Send the buffer.
    int32_t rc = (*outConnection->outStream)(outConnection->txBuffer, headerLength + inIproc->length + UAVTALK_CHECKSUM_LENGTH);

    // Update stats
    outConnection->stats.txBytes += (rc > 0) ? rc : 0;

    // evaluate return value before releasing the lock
    int32_t ret = 0;
    if (rc != (int32_t)(headerLength + inIproc->length + UAVTALK_CHECKSUM_LENGTH)) {
        outConnection->stats.txErrors++;
        ret = -1;
    }

    // Release lock
    xSemaphoreGiveRecursive(outConnection->lock);

    // Done
    return ret;
}

/**
 * Complete receiving a UAVTalk packet.  This will cause the packet to be unpacked, acked, etc.
 * \param[in] connectionHandle UAVTalkConnection to be used
 * \return 0 Success
 * \return -1 Failure
 */
int32_t UAVTalkReceiveObject(UAVTalkConnection connectionHandle)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return -1);

    UAVTalkInputProcessor *iproc = &connection->iproc;
    if (iproc->state != UAVTALK_STATE_COMPLETE) {
        return -1;
    }

    return receiveObject(connection, iproc->type, iproc->objId, iproc->instId, connection->rxBuffer);
}

/**
 * Get the object ID of the current packet.
 * \param[in] connectionHandle UAVTalkConnection to be used
 * \return The object ID, or 0 on error.
 */
uint32_t UAVTalkGetPacketObjId(UAVTalkConnection connectionHandle)
{
    UAVTalkConnectionData *connection;

    CHECKCONHANDLE(connectionHandle, connection, return 0);

    return connection->iproc.objId;
}

/**
 * Receive an object. This function process objects received through the telemetry stream.
 *
 * Parser errors are considered as transmission errors and are not NACKed.
 * Some senders (GCS) can timeout and retry if the message is not answered by an ack or nack.
 *
 * Object handling errors are considered as application errors and are NACked.
 * In that case we want to nack as there is no point in the sender retrying to send invalid objects.
 *
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] type Type of received message (UAVTALK_TYPE_OBJ, UAVTALK_TYPE_OBJ_REQ, UAVTALK_TYPE_OBJ_ACK, UAVTALK_TYPE_ACK, UAVTALK_TYPE_NACK)
 * \param[in] objId ID of the object to work on
 * \param[in] instId The instance ID of UAVOBJ_ALL_INSTANCES for all instances.
 * \param[in] data Data buffer
 * \param[in] length Buffer length
 * \return 0 Success
 * \return -1 Failure
 */
static int32_t receiveObject(UAVTalkConnectionData *connection, uint8_t type, uint32_t objId, uint16_t instId, uint8_t *data)
{
    UAVObjHandle obj;
    int32_t ret = 0;

    // Lock
    xSemaphoreTakeRecursive(connection->lock, portMAX_DELAY);

    // Get the handle to the object. Will be null if object does not exist.
    // Warning :
    // Here we ask for instance ID 0 without taking into account the provided instId
    // The provided instId will be used later when packing, unpacking, etc...
    // TODO the above should be fixed as it is cumbersome and error prone
    obj = UAVObjGetByID(objId);

    // Process message type
    switch (type) {
    case UAVTALK_TYPE_OBJ:
    case UAVTALK_TYPE_OBJ_TS:
        // All instances not allowed for OBJ messages
        if (obj && (instId != UAVOBJ_ALL_INSTANCES)) {
            // Unpack object, if the instance does not exist it will be created!
            if (UAVObjUnpack(obj, instId, data) == 0) {
                // Check if this object acks a pending OBJ_REQ message
                // any OBJ message can ack a pending OBJ_REQ message
                // even one that was not sent in response to the OBJ_REQ message
                updateAck(connection, type, objId, instId);
            } else {
                ret = -1;
            }
        } else {
            ret = -1;
        }
        break;

    case UAVTALK_TYPE_OBJ_ACK:
    case UAVTALK_TYPE_OBJ_ACK_TS:
        UAVT_DEBUGLOG_CPRINTF(objId, "OBJ_ACK %X %d", objId, instId);
        // All instances not allowed for OBJ_ACK messages
        if (obj && (instId != UAVOBJ_ALL_INSTANCES)) {
            // Unpack object, if the instance does not exist it will be created!
            if (UAVObjUnpack(obj, instId, data) == 0) {
                UAVT_DEBUGLOG_CPRINTF(objId, "OBJ ACK %X %d", objId, instId);
                // Object updated or created, transmit ACK
                sendObject(connection, UAVTALK_TYPE_ACK, objId, instId, NULL);
            } else {
                ret = -1;
            }
        } else {
            ret = -1;
        }
        if (ret == -1) {
            // failed to update object, transmit NACK
            UAVT_DEBUGLOG_PRINTF("OBJ NACK %X %d", objId, instId);
            sendObject(connection, UAVTALK_TYPE_NACK, objId, instId, NULL);
        }
        break;

    case UAVTALK_TYPE_OBJ_REQ:
        // Check if requested object exists
        UAVT_DEBUGLOG_CPRINTF(objId, "REQ %X %d", objId, instId);
        if (obj) {
            // Object found, transmit it
            // The sent object will ack the object request on the receiver side
            ret = sendObject(connection, UAVTALK_TYPE_OBJ, objId, instId, obj);
        } else {
            ret = -1;
        }
        if (ret == -1) {
            // failed to send object, transmit NACK
            UAVT_DEBUGLOG_PRINTF("REQ NACK %X %d", objId, instId);
            sendObject(connection, UAVTALK_TYPE_NACK, objId, instId, NULL);
        }
        break;

    case UAVTALK_TYPE_NACK:
        // Do nothing on flight side, let it time out.
        // TODO:
        // The transaction takes the result code of the "semaphore taking operation" into account to determine success.
        // If we give that semaphore in time, its "success" (ack received)
        // If we do not give that semaphore before the timeout it will return failure.
        // What would have to be done here is give the semaphore, but set a flag (for example connection->respFail=true)
        // that indicates failure and then above where it checks for the result code, have it behave as if it failed
        // if the explicit failure is set.
        break;

    case UAVTALK_TYPE_ACK:
        // All instances not allowed for ACK messages
        if (obj && (instId != UAVOBJ_ALL_INSTANCES)) {
            // Check if an ACK is pending
            updateAck(connection, type, objId, instId);
        } else {
            ret = -1;
        }
        break;

    default:
        ret = -1;
    }

    // Unlock
    xSemaphoreGiveRecursive(connection->lock);

    // Done
    return ret;
}

/**
 * Check if an ack is pending on an object and give response semaphore
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] obj Object
 * \param[in] instId The instance ID of UAVOBJ_ALL_INSTANCES for all instances.
 */
static void updateAck(UAVTalkConnectionData *connection, uint8_t type, uint32_t objId, uint16_t instId)
{
    if ((connection->respObjId == objId) && (connection->respType == type)) {
        if ((connection->respInstId == UAVOBJ_ALL_INSTANCES) && (instId == 0)) {
            // last instance received, complete transaction
            xSemaphoreGive(connection->respSema);
            connection->respObjId = 0;
        } else if (connection->respInstId == instId) {
            xSemaphoreGive(connection->respSema);
            connection->respObjId = 0;
        }
    }
}

/**
 * Send an object through the telemetry link.
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] type Transaction type
 * \param[in] objId The object ID
 * \param[in] instId The instance ID or UAVOBJ_ALL_INSTANCES for all instances
 * \param[in] obj Object handle to send (null when type is NACK)
 * \return 0 Success
 * \return -1 Failure
 */
static int32_t sendObject(UAVTalkConnectionData *connection, uint8_t type, uint32_t objId, uint16_t instId, UAVObjHandle obj)
{
    uint32_t numInst;
    uint32_t n;
    int32_t ret = -1;

    // Important note : obj can be null (when type is NACK for example) so protect all obj dereferences.

    // If all instances are requested and this is a single instance object, force instance ID to zero
    if ((obj != NULL) && (instId == UAVOBJ_ALL_INSTANCES) && UAVObjIsSingleInstance(obj)) {
        instId = 0;
    }

    // Process message type
    if (type == UAVTALK_TYPE_OBJ || type == UAVTALK_TYPE_OBJ_TS || type == UAVTALK_TYPE_OBJ_ACK || type == UAVTALK_TYPE_OBJ_ACK_TS) {
        if (instId == UAVOBJ_ALL_INSTANCES) {
            // Get number of instances
            numInst = UAVObjGetNumInstances(obj);
            // Send all instances in reverse order
            // This allows the receiver to detect when the last object has been received (i.e. when instance 0 is received)
            ret     = 0;
            for (n = 0; n < numInst; ++n) {
                ret = sendSingleObject(connection, type, objId, numInst - n - 1, obj);
                if (ret == -1) {
                    break;
                }
            }
        } else {
            ret = sendSingleObject(connection, type, objId, instId, obj);
        }
    } else if (type == UAVTALK_TYPE_OBJ_REQ) {
        ret = sendSingleObject(connection, type, objId, instId, obj);
    } else if (type == UAVTALK_TYPE_ACK || type == UAVTALK_TYPE_NACK) {
        if (instId != UAVOBJ_ALL_INSTANCES) {
            ret = sendSingleObject(connection, type, objId, instId, obj);
        }
    }

    return ret;
}

/**
 * Send an object through the telemetry link.
 * \param[in] connection UAVTalkConnection to be used
 * \param[in] type Transaction type
 * \param[in] objId The object ID
 * \param[in] instId The instance ID (can NOT be UAVOBJ_ALL_INSTANCES, use () instead)
 * \param[in] obj Object handle to send (null when type is NACK)
 * \return 0 Success
 * \return -1 Failure
 */
static int32_t sendSingleObject(UAVTalkConnectionData *connection, uint8_t type, uint32_t objId, uint16_t instId, UAVObjHandle obj)
{
    // IMPORTANT : obj can be null (when type is NACK for example)

    if (!connection->outStream) {
        connection->stats.txErrors++;
        return -1;
    }

    // Setup sync byte
    connection->txBuffer[0] = UAVTALK_SYNC_VAL;
    // Setup type
    connection->txBuffer[1] = type;
    // next 2 bytes are reserved for data length (inserted here later)
    // Setup object ID
    connection->txBuffer[4] = (uint8_t)(objId & 0xFF);
    connection->txBuffer[5] = (uint8_t)((objId >> 8) & 0xFF);
    connection->txBuffer[6] = (uint8_t)((objId >> 16) & 0xFF);
    connection->txBuffer[7] = (uint8_t)((objId >> 24) & 0xFF);
    // Setup instance ID
    connection->txBuffer[8] = (uint8_t)(instId & 0xFF);
    connection->txBuffer[9] = (uint8_t)((instId >> 8) & 0xFF);
    int32_t headerLength = 10;

    // Add timestamp when the transaction type is appropriate
    if (type & UAVTALK_TIMESTAMPED) {
        portTickType time = xTaskGetTickCount();
        connection->txBuffer[10] = (uint8_t)(time & 0xFF);
        connection->txBuffer[11] = (uint8_t)((time >> 8) & 0xFF);
        headerLength += 2;
    }

    // Determine data length
    int32_t length;
    if (type == UAVTALK_TYPE_OBJ_REQ || type == UAVTALK_TYPE_ACK || type == UAVTALK_TYPE_NACK) {
        length = 0;
    } else {
        length = UAVObjGetNumBytes(obj);
    }

    // Check length
    if (length > UAVOBJECTS_LARGEST) {
        connection->stats.txErrors++;
        return -1;
    }

    // Copy data (if any)
    if (length > 0) {
        if (UAVObjPack(obj, instId, &connection->txBuffer[headerLength]) == -1) {
            connection->stats.txErrors++;
            return -1;
        }
    }

    // Store the packet length
    connection->txBuffer[2] = (uint8_t)((headerLength + length) & 0xFF);
    connection->txBuffer[3] = (uint8_t)(((headerLength + length) >> 8) & 0xFF);

    // Calculate and store checksum
    connection->txBuffer[headerLength + length] = PIOS_CRC_updateCRC(0, connection->txBuffer, headerLength + length);

    // Send object
    uint16_t tx_msg_len = headerLength + length + UAVTALK_CHECKSUM_LENGTH;
    int32_t rc = (*connection->outStream)(connection->txBuffer, tx_msg_len);

    // Update stats
    if (rc == tx_msg_len) {
        ++connection->stats.txObjects;
        connection->stats.txObjectBytes += length;
        connection->stats.txBytes += tx_msg_len;
    } else {
        connection->stats.txErrors++;
        // TODO rc == -1 connection not open, -2 buffer full should retry
        connection->stats.txBytes += (rc > 0) ? rc : 0;
        return -1;
    }

    // Done
    return 0;
}

/*
 * Functions that implements the UAVTalk Process FSM. return false to break out of current cycle
 */

static bool UAVTalkProcess_SYNC(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, __attribute__((unused)) uint8_t length, uint8_t *position)
{
    uint8_t rxbyte = rxbuffer[(*position)++];

    if (rxbyte != UAVTALK_SYNC_VAL) {
        connection->stats.rxSyncErrors++;
        return false;
    }

    // Initialize and update the CRC
    iproc->cs = PIOS_CRC_updateByte(0, rxbyte);

    iproc->rxPacketLength = 1;
    iproc->rxCount = 0;

    iproc->type    = 0;
    iproc->state   = UAVTALK_STATE_TYPE;
    return true;
}

static bool UAVTalkProcess_TYPE(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, __attribute__((unused)) uint8_t length, uint8_t *position)
{
    uint8_t rxbyte = rxbuffer[(*position)++];

    if ((rxbyte & UAVTALK_TYPE_MASK) != UAVTALK_TYPE_VER) {
        connection->stats.rxErrors++;
        iproc->state = UAVTALK_STATE_SYNC;
        return false;
    }

    // update the CRC
    iproc->cs    = PIOS_CRC_updateByte(iproc->cs, rxbyte);

    iproc->type  = rxbyte;
    iproc->rxPacketLength++;
    iproc->packet_size = 0;
    iproc->state = UAVTALK_STATE_SIZE;
    return true;
}

static bool UAVTalkProcess_SIZE(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position)
{
    while (iproc->rxCount < 2 && length > (*position)) {
        uint8_t rxbyte = rxbuffer[(*position)++];
        // update the CRC
        iproc->cs = PIOS_CRC_updateByte(iproc->cs, rxbyte);
        iproc->packet_size += rxbyte << 8 * iproc->rxCount;
        iproc->rxCount++;
    }

    if (iproc->rxCount < 2) {
        return false;;
    }

    iproc->rxCount = 0;

    if (iproc->packet_size < UAVTALK_MIN_HEADER_LENGTH || iproc->packet_size > UAVTALK_MAX_HEADER_LENGTH + UAVTALK_MAX_PAYLOAD_LENGTH) {
        // incorrect packet size
        connection->stats.rxErrors++;
        iproc->state = UAVTALK_STATE_ERROR;
        return false;
    }
    iproc->rxPacketLength += 2;
    iproc->objId = 0;
    iproc->state = UAVTALK_STATE_OBJID;
    return true;
}

static bool UAVTalkProcess_OBJID(__attribute__((unused)) UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position)
{
    while (iproc->rxCount < 4 && length > (*position)) {
        uint8_t rxbyte = rxbuffer[(*position)++];
        iproc->cs     = PIOS_CRC_updateByte(iproc->cs, rxbyte);
        iproc->objId += rxbyte << (8 * (iproc->rxCount++));
    }

    if (iproc->rxCount < 4) {
        return false;
    }
    iproc->rxCount = 0;
    iproc->rxPacketLength += 4;
    iproc->instId  = 0;
    iproc->state   = UAVTALK_STATE_INSTID;
    return true;
}

static bool UAVTalkProcess_INSTID(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position)
{
    while (iproc->rxCount < 2 && length > (*position)) {
        uint8_t rxbyte = rxbuffer[(*position)++];
        iproc->cs      = PIOS_CRC_updateByte(iproc->cs, rxbyte);
        iproc->instId += rxbyte << (8 * (iproc->rxCount++));
    }

    if (iproc->rxCount < 2) {
        return false;
    }
    iproc->rxPacketLength += 2;
    iproc->rxCount = 0;

    UAVObjHandle obj = UAVObjGetByID(iproc->objId);

    // Determine data length
    if (iproc->type == UAVTALK_TYPE_OBJ_REQ || iproc->type == UAVTALK_TYPE_ACK || iproc->type == UAVTALK_TYPE_NACK) {
        iproc->length = 0;
        iproc->timestampLength = 0;
    } else {
        iproc->timestampLength = (iproc->type & UAVTALK_TIMESTAMPED) ? 2 : 0;
        if (obj) {
            iproc->length = UAVObjGetNumBytes(obj);
        } else {
            iproc->length = iproc->packet_size - iproc->rxPacketLength - iproc->timestampLength;
        }
    }

    // Check length
    if (iproc->length >= UAVTALK_MAX_PAYLOAD_LENGTH) {
        // packet error - exceeded payload max length
        connection->stats.rxErrors++;
        iproc->state = UAVTALK_STATE_ERROR;
        return false;
    }

    // Check the lengths match
    if ((iproc->rxPacketLength + iproc->timestampLength + iproc->length) != iproc->packet_size) {
        // packet error - mismatched packet size
        connection->stats.rxErrors++;
        iproc->state = UAVTALK_STATE_ERROR;
        return false;
    }

    // Determine next state
    if (iproc->type & UAVTALK_TIMESTAMPED) {
        // If there is a timestamp get it
        iproc->timestamp = 0;
        iproc->state     = UAVTALK_STATE_TIMESTAMP;
    } else {
        // If there is a payload get it, otherwise receive checksum
        if (iproc->length > 0) {
            iproc->state = UAVTALK_STATE_DATA;
        } else {
            iproc->state = UAVTALK_STATE_CS;
        }
    }
    return true;
}

static bool UAVTalkProcess_TIMESTAMP(__attribute__((unused)) UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position)
{
    while (iproc->rxCount < 2 && length > (*position)) {
        uint8_t rxbyte = rxbuffer[(*position)++];
        iproc->cs = PIOS_CRC_updateByte(iproc->cs, rxbyte);
        iproc->timestamp += rxbyte << (8 * (iproc->rxCount++));
    }

    if (iproc->rxCount < 2) {
        return false;;
    }

    iproc->rxCount = 0;
    iproc->rxPacketLength += 2;
    // If there is a payload get it, otherwise receive checksum
    if (iproc->length > 0) {
        iproc->state = UAVTALK_STATE_DATA;
    } else {
        iproc->state = UAVTALK_STATE_CS;
    }
    return true;
}

static bool UAVTalkProcess_DATA(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, uint8_t length, uint8_t *position)
{
    uint8_t toCopy = iproc->length - iproc->rxCount;

    if (toCopy > length - (*position)) {
        toCopy = length - (*position);
    }

    memcpy(&connection->rxBuffer[iproc->rxCount], &rxbuffer[(*position)], toCopy);
    (*position)    += toCopy;

    // update the CRC
    iproc->cs       = PIOS_CRC_updateCRC(iproc->cs, &connection->rxBuffer[iproc->rxCount], toCopy);
    iproc->rxCount += toCopy;

    iproc->rxPacketLength += toCopy;

    if (iproc->rxCount < iproc->length) {
        return false;
    }

    iproc->rxCount = 0;
    iproc->state   = UAVTALK_STATE_CS;
    return true;
}

static bool UAVTalkProcess_CS(UAVTalkConnectionData *connection, UAVTalkInputProcessor *iproc, uint8_t *rxbuffer, __attribute__((unused)) uint8_t length, uint8_t *position)
{
    // Check the CRC byte
    uint8_t rxbyte = rxbuffer[(*position)++];

    if (rxbyte != iproc->cs) {
        // packet error - faulty CRC
        UAVT_DEBUGLOG_PRINTF("BAD CRC");
        connection->stats.rxCrcErrors++;
        connection->stats.rxErrors++;
        iproc->state = UAVTALK_STATE_ERROR;
        return false;;
    }
    iproc->rxPacketLength++;

    if (iproc->rxPacketLength != (iproc->packet_size + UAVTALK_CHECKSUM_LENGTH)) {
        // packet error - mismatched packet size
        connection->stats.rxErrors++;
        iproc->state = UAVTALK_STATE_ERROR;
        return false;;
    }

    connection->stats.rxObjects++;
    connection->stats.rxObjectBytes += iproc->length;

    iproc->state = UAVTALK_STATE_COMPLETE;
    return true;
}


/**
 * @}
 * @}
 */