ResolVBus.h

Go to the documentation of this file.

#ifndef __RESOLVBUS_H__
#define __RESOLVBUS_H__
 
//
//  ResolVBus.h
//  resol-vbus
//
//
//  Copyright (C) 2022, Daniel Wippermann. All rights reserved.
//
 
 
//---------------------------------------------------------------------------
// PUBLIC INCLUDES
//---------------------------------------------------------------------------
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
 
 
//---------------------------------------------------------------------------
// PUBLIC DEFINES
//---------------------------------------------------------------------------
 
#define RESOLVBUS_CONTAINEROF(__Pointer__, __Type__, __Member__) \
    ((__Type__ *) (((uint8_t *) (__Pointer__)) - ((uint8_t *) (&((__Type__ *) 0)->__Member__))))
 
 
#define RESOLVBUS_COUNTOF(__Array__) \
    (sizeof (__Array__) / sizeof ((__Array__) [0]))
 
 
#define RESOLVBUS_PACKETFRAMECOUNTOF(__Type__) \
    ((sizeof (__Type__) + 3) >> 2)
 
 
#define RESOLVBUS_LIVEENCODER_INITIALIZER { .BufferLength = 0, }
#define RESOLVBUS_LIVEDECODER_INITIALIZER { .BufferIndex = 0, }
#define RESOLVBUS_LIVETRANSCEIVEROPTIONS_INITIALIZER { .Tries = 0, }
#define RESOLVBUS_LIVETRANSCEIVER_INITIALIZER { .ActionTries = 0, }
 
 
 
//---------------------------------------------------------------------------
// PUBLIC TYPEDEFS
//---------------------------------------------------------------------------
 
typedef enum RESOLVBUS_RESULT {
    RESOLVBUS_OK = 0,
    RESOLVBUS_WOULDBLOCK = 1,
 
    RESOLVBUS_ERROR_UNKNOWN = 2,
    RESOLVBUS_ERROR_NYI = 3,
    RESOLVBUS_ERROR_NULLPOINTER = 4,
    RESOLVBUS_ERROR_UNSUPPORTEDPROTOCOL = 5,
    RESOLVBUS_ERROR_INDEXOUTOFBOUNDS = 6,
    RESOLVBUS_ERROR_INVALIDARGUMENT = 7,
    RESOLVBUS_ERROR_INVALIDCHECKSUM = 8,
    RESOLVBUS_ERROR_INVALIDSTATE = 9,
    RESOLVBUS_ERROR_SUSPENDED = 10,
} RESOLVBUS_RESULT;
 
 
typedef enum RESOLVBUS_LIVEENCODEREVENTTYPE {
    RESOLVBUS_LIVEENCODEREVENTTYPE_IDLE,
 
    RESOLVBUS_LIVEENCODEREVENTTYPE_TRANSMIT,
} RESOLVBUS_LIVEENCODEREVENTTYPE;
 
 
typedef enum RESOLVBUS_LIVEENCODERPHASE {
    RESOLVBUS_LIVEENCODERPHASE_IDLE = 0,
 
    RESOLVBUS_LIVEENCODERPHASE_TRANSMITTING = 1,
 
    RESOLVBUS_LIVEENCODERPHASE_GAININGENERGY = 2,
 
    RESOLVBUS_LIVEENCODERPHASE_SUSPENDED = 3,
 
    RESOLVBUS_LIVEENCODERPHASE_SUSPENDEDWITHTIMEOUT = 4,
} RESOLVBUS_LIVEENCODERPHASE;
 
 
typedef enum RESOLVBUS_LIVEDECODEREVENTTYPE {
    RESOLVBUS_LIVEDECODEREVENTTYPE_PACKETHEADER,
 
    RESOLVBUS_LIVEDECODEREVENTTYPE_PACKETFRAME,
 
    RESOLVBUS_LIVEDECODEREVENTTYPE_PACKETEND,
 
 
    RESOLVBUS_LIVEDECODEREVENTTYPE_DATAGRAM,
 
 
    RESOLVBUS_LIVEDECODEREVENTTYPE_TELEGRAMHEADER,
 
    RESOLVBUS_LIVEDECODEREVENTTYPE_TELEGRAMFRAME,
 
    RESOLVBUS_LIVEDECODEREVENTTYPE_TELEGRAMEND,
} RESOLVBUS_LIVEDECODEREVENTTYPE;
 
 
typedef enum RESOLVBUS_LIVETRANSCEIVEREVENTTYPE {
    RESOLVBUS_LIVETRANSCEIVEREVENTTYPE_ACTION,
 
    RESOLVBUS_LIVETRANSCEIVEREVENTTYPE_TIMEOUT,
 
    RESOLVBUS_LIVETRANSCEIVEREVENTTYPE_ENCODER,
 
    RESOLVBUS_LIVETRANSCEIVEREVENTTYPE_DECODER,
} RESOLVBUS_LIVETRANSCEIVEREVENTTYPE;
 
 
typedef struct RESOLVBUS_LIVEENCODEREVENT RESOLVBUS_LIVEENCODEREVENT;
typedef struct RESOLVBUS_LIVEENCODER RESOLVBUS_LIVEENCODER;
typedef struct RESOLVBUS_LIVEDECODEREVENT RESOLVBUS_LIVEDECODEREVENT;
typedef struct RESOLVBUS_LIVEDECODER RESOLVBUS_LIVEDECODER;
typedef struct RESOLVBUS_LIVETRANSCEIVEREVENT RESOLVBUS_LIVETRANSCEIVEREVENT;
typedef struct RESOLVBUS_LIVETRANSCEIVEROPTIONS RESOLVBUS_LIVETRANSCEIVEROPTIONS;
typedef struct RESOLVBUS_LIVETRANSCEIVER RESOLVBUS_LIVETRANSCEIVER;
 
 
 
//---------------------------------------------------------------------------
// PUBLIC CALLBACKS
//---------------------------------------------------------------------------
 
typedef RESOLVBUS_RESULT (*RESOLVBUS_LIVEENCODERHANDLER)(RESOLVBUS_LIVEENCODER *Encoder, const RESOLVBUS_LIVEENCODEREVENT *Event);
typedef RESOLVBUS_RESULT (*RESOLVBUS_LIVEENCODERCALLBACK)(RESOLVBUS_LIVEENCODER *Encoder, void *Context);
typedef RESOLVBUS_RESULT (*RESOLVBUS_LIVEDECODERHANDLER)(RESOLVBUS_LIVEDECODER *Decoder, const RESOLVBUS_LIVEDECODEREVENT *Event);
typedef RESOLVBUS_RESULT (*RESOLVBUS_LIVETRANSCEIVERHANDLER)(RESOLVBUS_LIVETRANSCEIVER *Transceiver, const RESOLVBUS_LIVETRANSCEIVEREVENT *Event);
 
 
 
//---------------------------------------------------------------------------
// PUBLIC DATA TYPES
//---------------------------------------------------------------------------
 
struct RESOLVBUS_LIVEENCODEREVENT {
    RESOLVBUS_LIVEENCODEREVENTTYPE EventType;
 
    const void *TransmitBytes;
 
    size_t TransmitLength;
};
 
 
struct RESOLVBUS_LIVEENCODER {
    uint8_t *Buffer;
 
    size_t BufferLength;
 
    size_t BufferWriteIndex;
 
    size_t BufferReadIndex;
 
    int Baudrate;
 
    int MaxEnergy;
 
    int EnergyLossPerByte;
 
    int EnergyGainPerUs;
 
    int CurrentEnergy;
 
    bool SuspendRequested;
 
    bool SuspendWithTimeoutRequested;
 
    uint32_t SuspendTimeoutUs;
 
    RESOLVBUS_LIVEENCODERCALLBACK SuspendCallback;
 
    void *SuspendCallbackContext;
 
    RESOLVBUS_LIVEENCODERPHASE Phase;
 
    uint32_t PhaseTimeoutUs;
 
    uint8_t ProtocolVersion;
 
    RESOLVBUS_LIVEENCODERHANDLER Handler;
};
 
 
struct RESOLVBUS_LIVEDECODEREVENT {
    RESOLVBUS_LIVEDECODEREVENTTYPE EventType;
 
    uint16_t DestinationAddress;
 
    uint16_t SourceAddress;
 
    uint8_t ProtocolVersion;
 
    uint8_t MajorVersion;
 
    uint16_t Command;
 
    uint8_t FrameCount;
 
    uint8_t FrameIndex;
 
    uint8_t FrameData [7];
 
    size_t FrameDataLength;
 
    void *FrameDataBuffer;
 
    size_t FrameDataBufferLength;
 
    uint16_t Param16;
 
    uint32_t Param32;
};
 
 
struct RESOLVBUS_LIVEDECODER {
    uint8_t Buffer [32];
 
    size_t BufferIndex;
 
    RESOLVBUS_LIVEDECODERHANDLER Handler;
 
    RESOLVBUS_LIVEDECODEREVENT Event;
};
 
 
struct RESOLVBUS_LIVETRANSCEIVEREVENT {
    RESOLVBUS_LIVETRANSCEIVEREVENTTYPE EventType;
 
    const RESOLVBUS_LIVEENCODEREVENT *EncoderEvent;
 
    const RESOLVBUS_LIVEDECODEREVENT *DecoderEvent;
};
 
 
struct RESOLVBUS_LIVETRANSCEIVEROPTIONS {
    int Tries;
 
    uint32_t InitialTimeout;
 
    uint32_t TimeoutIncrement;
};
 
 
struct RESOLVBUS_LIVETRANSCEIVER {
    RESOLVBUS_LIVEENCODER Encoder;
 
    RESOLVBUS_LIVEDECODER Decoder;
 
    RESOLVBUS_LIVETRANSCEIVERHANDLER Handler;
 
    uint16_t SelfAddress;
 
    bool ActionSet;
 
    RESOLVBUS_LIVETRANSCEIVERHANDLER ActionHandler;
 
    int ActionTries;
 
    uint32_t ActionNextTimeout;
 
    uint32_t ActionTimeoutIncr;
 
    uint32_t ActionTimeout;
 
    RESOLVBUS_LIVETRANSCEIVERHANDLER ActionCommitHandler;
 
    uint16_t ActionPeerAddress;
 
    uint16_t ActionCommand;
 
    uint16_t ActionParam16;
 
    uint32_t ActionParam32;
 
    uint16_t ActionExpectedCommand1;
 
    uint16_t ActionExpectedCommand2;
 
    uint16_t ActionExpectedCommand3;
 
    bool ActionHasExpectedParam16;
 
    uint16_t ActionExpectedParam16;
 
    bool ActionHasExpectedParam32;
 
    uint32_t ActionExpectedParam32;
};
 
 
 
//---------------------------------------------------------------------------
// PUBLIC CONSTANTS
//---------------------------------------------------------------------------
 
 
 
//---------------------------------------------------------------------------
// PUBLIC VARIABLES
//---------------------------------------------------------------------------
 
 
 
//---------------------------------------------------------------------------
// PUBLIC METHODS
//---------------------------------------------------------------------------
 
#if RESOLVBUS_DEBUG > 0
void ResolVBus_ResetBacktrace(const char *Message, const char *Expression, const char *File, int Line, const char *Func);
 
void ResolVBus_AddBacktrace(const char *Expression, const char *File, int Line, const char *Func);
 
const char *ResolVBus_GetBacktrace(void);
 
void ResolVBus_PrintBacktrace(void);
 
void ResolVBus_DebugLog(const char *File, int Line, const char *Func, const char *Format, ...);
#endif
 
 
uint16_t ResolVBus_ReadUInt16LE(const uint8_t *Buffer);
 
void ResolVBus_WriteUInt16LE(uint8_t *Buffer, uint16_t Value);
 
uint32_t ResolVBus_ReadUInt32LE(const uint8_t *Buffer);
 
void ResolVBus_WriteUInt32LE(uint8_t *Buffer, uint32_t Value);
 
 
RESOLVBUS_RESULT ResolVBus_CalcCrcV0(const uint8_t *Buffer, size_t Length, uint8_t *pCrc);
 
RESOLVBUS_RESULT ResolVBus_CalcCrc(uint8_t ProtocolVersion, const uint8_t *Buffer, size_t Length, uint8_t *pCrc);
 
RESOLVBUS_RESULT ResolVBus_CalcAndSetCrc(uint8_t ProtocolVersion, uint8_t *Buffer, size_t Length);
 
RESOLVBUS_RESULT ResolVBus_CalcAndCompareCrc(uint8_t ProtocolVersion, const uint8_t *Buffer, size_t Length, bool *pCrcIsValid);
 
RESOLVBUS_RESULT ResolVBus_InjectSeptett(const uint8_t *Source, uint8_t *Destination, size_t Length);
 
RESOLVBUS_RESULT ResolVBus_ExtractSeptett(const uint8_t *Source, uint8_t *Destination, size_t Length);
 
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_Initialize(RESOLVBUS_LIVEENCODER *Encoder, uint8_t *Buffer, size_t Length, RESOLVBUS_LIVEENCODERHANDLER Handler);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_GetTimeout(RESOLVBUS_LIVEENCODER *Encoder, uint32_t *pMicroseconds);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_HandleTimer(RESOLVBUS_LIVEENCODER *Encoder, uint32_t Microseconds);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_Suspend(RESOLVBUS_LIVEENCODER *Encoder);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_SuspendWithTimeout(RESOLVBUS_LIVEENCODER *Encoder, uint32_t Microseconds);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_SuspendWithTimeoutAndCallback(RESOLVBUS_LIVEENCODER *Encoder, uint32_t Microseconds, RESOLVBUS_LIVEENCODERCALLBACK Callback, void *Context);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_Resume(RESOLVBUS_LIVEENCODER *Encoder);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_QueuePacketHeader(RESOLVBUS_LIVEENCODER *Encoder, uint16_t DestinationAddress, uint16_t SourceAddress, uint8_t MinorVersion, uint16_t Command, uint8_t FrameCount);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_QueuePacketFrame(RESOLVBUS_LIVEENCODER *Encoder, const uint8_t *FourBytes);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_QueuePacketFrames(RESOLVBUS_LIVEENCODER *Encoder, const void *Bytes, size_t Length);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_QueueDatagram(RESOLVBUS_LIVEENCODER *Encoder, uint16_t DestinationAddress, uint16_t SourceAddress, uint8_t MinorVersion, uint16_t Command, uint16_t Param16, uint32_t Param32);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_QueueTelegramHeader(RESOLVBUS_LIVEENCODER *Encoder, uint16_t DestinationAddress, uint16_t SourceAddress, uint8_t MinorVersion, uint8_t Command, uint8_t FrameCount);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_QueueTelegramFrame(RESOLVBUS_LIVEENCODER *Encoder, const uint8_t *SevenBytes);
 
RESOLVBUS_RESULT ResolVBus_LiveEncoder_QueueTelegramFrames(RESOLVBUS_LIVEENCODER *Encoder, const void *Bytes, size_t Length);
 
 
RESOLVBUS_RESULT ResolVBus_LiveDecoder_Initialize(RESOLVBUS_LIVEDECODER *Decoder, void *FrameDataBuffer, size_t FrameDataBufferLength, RESOLVBUS_LIVEDECODERHANDLER Handler);
 
RESOLVBUS_RESULT ResolVBus_LiveDecoder_Decode(RESOLVBUS_LIVEDECODER *Decoder, const uint8_t *Bytes, size_t Length);
 
 
RESOLVBUS_RESULT ResolVBus_LiveTransceiver_Initialize(RESOLVBUS_LIVETRANSCEIVER *Transceiver, uint8_t *EncoderBuffer, size_t EncoderBufferLength, void *DecoderBuffer, size_t DecoderBufferLength, RESOLVBUS_LIVETRANSCEIVERHANDLER Handler);
 
 
RESOLVBUS_RESULT ResolVBus_LiveTransceiver_GetTimeout(RESOLVBUS_LIVETRANSCEIVER *Transceiver, uint32_t *pMicroseconds);
 
 
RESOLVBUS_RESULT ResolVBus_LiveTransceiver_HandleTimer(RESOLVBUS_LIVETRANSCEIVER *Transceiver, uint32_t Microseconds);
 
 
RESOLVBUS_RESULT ResolVBus_LiveTransceiver_GetEncoder(RESOLVBUS_LIVETRANSCEIVER *Transceiver, RESOLVBUS_LIVEENCODER **pEncoder);
 
 
RESOLVBUS_RESULT ResolVBus_LiveTransceiver_Decode(RESOLVBUS_LIVETRANSCEIVER *Transceiver, const uint8_t *Bytes, size_t Length);
 
 
RESOLVBUS_RESULT ResolVBus_LiveTransceiver_WaitForFreeBus(RESOLVBUS_LIVETRANSCEIVER *Transceiver, const RESOLVBUS_LIVETRANSCEIVEROPTIONS *CustomOptions, RESOLVBUS_LIVETRANSCEIVERHANDLER Handler);
 
 
RESOLVBUS_RESULT ResolVBus_LiveTransceiver_ReleaseBus(RESOLVBUS_LIVETRANSCEIVER *Transceiver, uint16_t PeerAddress, const RESOLVBUS_LIVETRANSCEIVEROPTIONS *CustomOptions, RESOLVBUS_LIVETRANSCEIVERHANDLER Handler);
 
 
RESOLVBUS_RESULT ResolVBus_LiveTransceiver_GetValueById(RESOLVBUS_LIVETRANSCEIVER *Transceiver, uint16_t PeerAddress, uint16_t ValueId, uint8_t ValueSubIndex, const RESOLVBUS_LIVETRANSCEIVEROPTIONS *CustomOptions, RESOLVBUS_LIVETRANSCEIVERHANDLER Handler);
 
 
RESOLVBUS_RESULT ResolVBus_LiveTransceiver_SetValueById(RESOLVBUS_LIVETRANSCEIVER *Transceiver, uint16_t PeerAddress, uint16_t ValueId, uint8_t ValueSubIndex, uint32_t Value, const RESOLVBUS_LIVETRANSCEIVEROPTIONS *CustomOptions, RESOLVBUS_LIVETRANSCEIVERHANDLER Handler);
 
 
RESOLVBUS_RESULT ResolVBus_LiveTransceiver_GetValueIdByIdHash(RESOLVBUS_LIVETRANSCEIVER *Transceiver, uint16_t PeerAddress, uint32_t ValueIdHash, const RESOLVBUS_LIVETRANSCEIVEROPTIONS *CustomOptions, RESOLVBUS_LIVETRANSCEIVERHANDLER Handler);
 
 
 
#endif // __RESOLVBUS_H__