sbgInterface.h

Go to the documentation of this file.

 
#ifndef SBG_INTERFACE_H
#define SBG_INTERFACE_H
 
//----------------------------------------------------------------------//
//- Header (open extern C block)                                       -//
//----------------------------------------------------------------------//
#ifdef __cplusplus
extern "C" {
#endif
 
/* sbgCommonLib headers */
#include <sbgCommon.h>
 
//----------------------------------------------------------------------//
//- Constant definitions                                               -//
//----------------------------------------------------------------------//
 
#define SBG_IF_NAME_MAX_SIZE        (48)            

#define SBG_IF_TYPE_UNKNOW          (0)             
#define SBG_IF_TYPE_SERIAL          (1)             
#define SBG_IF_TYPE_ETH_UDP         (2)             
#define SBG_IF_TYPE_ETH_TCP_IP      (3)             
#define SBG_IF_TYPE_FILE            (4)             
#define SBG_IF_TYPE_LAST_RESERVED   (999)           
 
//
// Flags for the flush operation.
//
#define SBG_IF_FLUSH_INPUT          ((uint32_t)1 << 0)                          
#define SBG_IF_FLUSH_OUTPUT         ((uint32_t)1 << 1)                          
#define SBG_IF_FLUSH_ALL            (SBG_IF_FLUSH_INPUT | SBG_IF_FLUSH_OUTPUT)  
 
//----------------------------------------------------------------------//
//- Predefinitions                                                     -//
//----------------------------------------------------------------------//

typedef struct _SbgInterface SbgInterface;

typedef void* SbgInterfaceHandle;
 
//----------------------------------------------------------------------//
//- Callbacks definitions                                              -//
//----------------------------------------------------------------------//

typedef SbgErrorCode (*SbgInterfaceDestroyFunc)(SbgInterface *pInterface);

typedef SbgErrorCode (*SbgInterfaceWriteFunc)(SbgInterface *pInterface, const void *pBuffer, size_t bytesToWrite);

typedef SbgErrorCode (*SbgInterfaceReadFunc)(SbgInterface *pInterface, void *pBuffer, size_t *pReadBytes, size_t bytesToRead);

typedef SbgErrorCode (*SbgInterfaceFlushFunc)(SbgInterface *pInterface, uint32_t flags);

typedef SbgErrorCode (*SbgInterfaceSetSpeed)(SbgInterface *pInterface, uint32_t speed);

typedef uint32_t (*SbgInterfaceGetSpeed)(const SbgInterface *pInterface);

typedef uint32_t (*SbgInterfaceGetDelayFunc)(const SbgInterface *pInterface, size_t numBytes);
 
//----------------------------------------------------------------------//
//- Structures definitions                                             -//
//----------------------------------------------------------------------//

struct _SbgInterface
{
    SbgInterfaceHandle             handle;                          
    uint32_t                     type;                              
    char                         name[SBG_IF_NAME_MAX_SIZE];        
 
    SbgInterfaceDestroyFunc       pDestroyFunc;                      
    SbgInterfaceWriteFunc       pWriteFunc;                      
    SbgInterfaceReadFunc         pReadFunc;                            
    SbgInterfaceFlushFunc       pFlushFunc;                      
    SbgInterfaceSetSpeed         pSetSpeedFunc;                        
    SbgInterfaceGetSpeed         pGetSpeedFunc;                        
    SbgInterfaceGetDelayFunc     pDelayFunc;                      
};
 
//----------------------------------------------------------------------//
//- Public methods                                                     -//
//----------------------------------------------------------------------//

SBG_COMMON_LIB_API void sbgInterfaceZeroInit(SbgInterface *pInterface);

SBG_COMMON_LIB_API SbgErrorCode sbgInterfaceDestroy(SbgInterface *pInterface);

SBG_INLINE uint32_t sbgInterfaceTypeGet(const SbgInterface *pInterface)
{
    assert(pInterface);
 
    return pInterface->type;
}

SBG_COMMON_LIB_API const char *sbgInterfaceTypeGetAsString(const SbgInterface *pInterface);

SBG_INLINE const char *sbgInterfaceNameGet(const SbgInterface *pInterface)
{
    assert(pInterface);
 
    return pInterface->name;
}

SBG_COMMON_LIB_API void sbgInterfaceNameSet(SbgInterface *pInterface, const char *pName);

SBG_INLINE SbgErrorCode sbgInterfaceWrite(SbgInterface *pInterface, const void *pBuffer, size_t bytesToWrite)
{
    SbgErrorCode    errorCode;
 
    assert(pInterface);
    assert(pBuffer);
 
    if (pInterface->pWriteFunc)
    {
        errorCode = pInterface->pWriteFunc(pInterface, pBuffer, bytesToWrite);
    }
    else
    {
        errorCode = SBG_INVALID_PARAMETER;
    }
 
    return errorCode;
}

SBG_INLINE SbgErrorCode sbgInterfaceRead(SbgInterface *pInterface, void *pBuffer, size_t *pReadBytes, size_t bytesToRead)
{
    SbgErrorCode    errorCode;
 
    assert(pInterface);
    assert(pBuffer);
    assert(pReadBytes);
 
    if (pInterface->pReadFunc)
    {
        errorCode = pInterface->pReadFunc(pInterface, pBuffer, pReadBytes, bytesToRead);
    }
    else
    {
        *pReadBytes = 0;
        errorCode   = SBG_INVALID_PARAMETER;
    }
 
    return errorCode;
}

SBG_INLINE SbgErrorCode sbgInterfaceFlush(SbgInterface *pInterface, uint32_t flags)
{
    SbgErrorCode         errorCode;
 
    assert(pInterface);
    assert((flags & ~SBG_IF_FLUSH_ALL) == 0);
 
    if (pInterface->pFlushFunc)
    {
        errorCode = pInterface->pFlushFunc(pInterface, flags);
    }
    else
    {
        errorCode = SBG_NO_ERROR;
    }
 
    return errorCode;
}

SBG_INLINE SbgErrorCode sbgInterfaceSetSpeed(SbgInterface *pInterface, uint32_t speed)
{
    assert(pInterface);
    assert(speed > 0);
 
    if (pInterface->pSetSpeedFunc)
    {
        return pInterface->pSetSpeedFunc(pInterface, speed);
    }
    else
    {
        return SBG_NO_ERROR;
    }
}

SBG_INLINE uint32_t sbgInterfaceGetSpeed(const SbgInterface *pInterface)
{
    assert(pInterface);
 
    if (pInterface->pGetSpeedFunc)
    {
        return pInterface->pGetSpeedFunc(pInterface);
    }
    else
    {
        return 0;
    }
}

SBG_INLINE uint32_t sbgInterfaceGetDelay(const SbgInterface *pInterface, size_t numBytes)
{
    assert(pInterface);
 
    if (pInterface->pDelayFunc)
    {
        return pInterface->pDelayFunc(pInterface, numBytes);
    }
    else
    {
        return 0;
    }
}
 
//----------------------------------------------------------------------//
//- Footer (close extern C block)                                      -//
//----------------------------------------------------------------------//
#ifdef __cplusplus
}
#endif
 
#endif // SBG_INTERFACE_H