srcp.c

Go to the documentation of this file.

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
    #define     SRCP_C


// ////////////////////////////////////////////////////////////////////////////
// Includes
// ////////////////////////////////////////////////////////////////////////////

    #include    "srcp.h"
    #include    "stringtable.h"
    #include    "dialog.h"
    #include    "sralloc.h"
    #include    "error.h"


// ////////////////////////////////////////////////////////////////////////////
// Local Defines
// ////////////////////////////////////////////////////////////////////////////

// Maximum SRCP device, which can be configured in parallel (eWicht cache)
#define MAX_SRCP_DEVICES            6

// Entries in the server cache (currently only for GLs)
#define SERVER_CACHE_ENTRIES        11


#define DEVICE_PRM_PTR(deviceptr)  ((BYTE *)(&deviceptr[1]))
#define DEVICE_PROTO_PTR(devptr)   ((BYTE *)(DEVICE_PRM_PTR(devptr) + offsetof(sGL, au8Proto)))
#define DEVICE_NAME_PTR(devptr)    ((BYTE *)(DEVICE_PRM_PTR(devptr) + offsetof(sGL, au8Name)))


// ////////////////////////////////////////////////////////////////////////////
// Local enumerator typedefs
// ////////////////////////////////////////////////////////////////////////////

// SRCP Handshake return codes
typedef enum
{
    SRCP_HR_ERROR = 0,
    SRCP_HR_IN_PROGRESS,
    SRCP_HR_FINISHED
} SRCP_HANDSHAKE_RETCODE;


// States of SRCP in "Operating Mode"
typedef enum
{
    SRCP_STARTUP = 0,
    SRCP_MAIN,
    SRCP_PREPARE_MAIN,
    SRCP_SELECT_EEPROM_SET_TO_SAVE,
    SRCP_ENTER_NAME,
    SRCP_SELECT_PROTOCOL,
    SRCP_PROTOCOL_SELECTED,
    SRCP_SELECT_DEVICE_ADDRESS,
    SRCP_SELECT_SERVER_CACHE,
    SRCP_SELECT_EEPROMSET,
    SRCP_INIT_DEVICE,
    SRCP_WAIT_FOR_IDLE_DEVICE,
    SRCP_INIT_POWER,
    SRCP_WAIT_FOR_IDLE_POWER_DEVICE,
    SRCP_ERROR,
    SRCP_ACK_ERROR
} SRCP_SM;


// States of SRCP in the "Handshaking Mode"
typedef enum
{
    SRCP_HS_WAIT_FOR_WELCOME = 0,
    SRCP_HS_SET_VERSION,
    SRCP_HS_WAIT_VERSION,
    SRCP_HS_SET_MODE,
    SRCP_HS_WAIT_MODE,
    SRCP_HS_GO,
    SRCP_HS_WAIT_GO,
    SRCP_HS_GOING,
    SRCP_HS_ERROR
} SRCP_HANDSHAKE_SM;


// SRCP device groups
typedef enum
{
    SRCP_DT_NOT_DEFINED = 0,
    SRCP_DT_GL,
    SRCP_DT_SM,
    SRCP_DT_GA,
    SRCP_DT_FB,
    SRCP_DT_TIME,
    SRCP_DT_POWER,
    SRCP_DT_SERVER,
    SRCP_DT_SESSION,
    SRCP_DT_LOCK,
    SRCP_DT_DESCRIPTION
} SRCP_DEVTYPE;


// SRCP commands
typedef enum
{
    SRCP_CMD_INFO = 0,
    SRCP_CMD_GET,
    SRCP_CMD_SET,
    SRCP_CMD_INIT,
    SRCP_CMD_TERM,
    SRCP_CMD_CHECK,
    SRCP_CMD_WAIT,
    SRCP_CMD_RESET,
    SRCP_CMD_VERIFY,
    SRCP_CMD_GETDESC
} SRCP_COMMANDS;


// Enumerator for system device states
typedef enum
{
// The unsynchronized states:
    SRCP_DS_DISABLED = 0,   // Doing nothing.
    SRCP_DS_UNKNOWN,        // Initial state of each new device.

// The synchronized states:
    SRCP_DS_NOT_DEFINED,    // Server does not know anything.
    SRCP_DS_IDLE            // The destination state!
} SRCP_DEVICESTATE;


typedef enum 
{
    SRCPC_SM_CONNECT_COMMAND = 0,
    SRCPC_SM_CONNECT_WAIT_COMMAND,
    SRCPC_SM_CONNECTED_COMMAND,
    SRCPC_SM_CONNECT_WAIT_INFO,
    SRCPC_SM_CONNECTED_INFO,
    SRCPC_SM_CONNECTED,
    SRCPC_SM_DELAY_CLOSING,
    SRCPC_SM_CLOSING,
    SRCPC_SM_WAIT_FOR_CLOSING,
    SRCPC_SM_ERROR_CONNECT,
    SRCPC_SM_CLOSED
} SM_SRCP_CONNECTING;


// ////////////////////////////////////////////////////////////////////////////
// Local structure typedefs
// ////////////////////////////////////////////////////////////////////////////

typedef struct __attribute__((__packed__)) srcpsocket_struct
{
    BYTE        u8Socket;
    BOOL        bCommand;
} SSRCPSOCKET;


typedef struct __attribute__((__packed__)) _srcpnet_state
{
    SSRCPSOCKET sCommand;
    SSRCPSOCKET sInfo;
} SSRCPSTATE;


typedef struct __attribute__((__packed__))
{
    BYTE u8Bus;
    SRCP_DEVTYPE eDevType;

    union
    {
        struct
        {
            DWORD u32Addr;
            BYTE au8Proto[4];
            BYTE u8Port;
        } sGA;

        struct
        {
            DWORD u32Addr;
            BYTE au8Proto[4];
            SHORT s16MaxV;
            BYTE u8MaxSteps;
            BYTE u8NrFunc;
            DWORD u32FuncAllocMask;
        } sGL;

        struct
        {
            DWORD u32Addr;
            SRCP_DEVTYPE eDevType;
        } sLock;
    } uStat;

    union
    {
        BOOL bPowerState;   // TRUE means ON, FALSE means OFF
        struct
        {
            BYTE u8Value;
                #define     GAPORT_INACTIVE 0x00
                #define     GAPORT_ACTIVE   0x01
        } sGA;

        struct
        {
            BYTE u8Dir;
                #define     DIR_BACKWARD    0x00
                #define     DIR_FORWARD     0x01
                #define     DIR_ESTOP       0x02
                #define     DIR_UNCHANGED   0x03
            SHORT s16ActV;
            DWORD u32FuncBitField;
            BYTE u8FuncGroup;   // The displayed function group (0=1-4,1=5-8,2=9-12)
            SHORT s16ServerV;   // This value indicates the servers speed.
        } sGL;

        struct
        {
            DWORD u32SessionId;
        } sLock;
    } uDyn;
} SRCP_PRM;


typedef struct __attribute__((__packed__))
{
    DWORD   u32Seconds;
    WORD    u16Milliseconds;
} SRCP_TIME;


typedef struct __attribute__((__packed__))
{
    SRCP_DEVTYPE eDevType;
    SRCP_DEVICESTATE eDevState;
    WORD u16LastErrorCode;
    SRCP_TIME sLastUpdate;
    struct
    {
        BYTE bNewData : 1;
    } sFlags;
    BYTE u8Bus;
    // Device specific (sPower, sLock, sGA, sGL) 
    // structure starts here.
} SRCP_DEVICE;


typedef struct __attribute__((__packed__))
{
    BOOL bPowerState;   // TRUE means ON, FALSE means OFF
} sPower;


typedef struct __attribute__((__packed__))
{
    DWORD u32Addr;  // This field is fixed to this position!!!
    DWORD u32Duration;
    DWORD u32SessionId;
    SRCP_DEVTYPE eDevType;
} sLock;


typedef struct __attribute__((__packed__))
{ 
    DWORD u32Addr;  // This field is fixed to this position!
    BYTE au8Proto[SRCP_PROTO_MAXLEN+1];// This field is fixed to this position!
    BYTE au8Name[SRCP_NAME_MAXLEN+1]; // This field is fixed to this position!
    BYTE u8MinPort;
    BYTE u8MaxPort;
    BYTE u8Port;
    DWORD s32Delay;
    BYTE u8Value;
        #define     GAPORT_INACTIVE 0x00
        #define     GAPORT_ACTIVE   0x01
} sGA;


typedef struct __attribute__((__packed__))
{ 
    DWORD u32Addr;  // This field is fixed to this position!
    BYTE au8Proto[SRCP_PROTO_MAXLEN+1];// This field is fixed to this position!
    BYTE au8Name[SRCP_NAME_MAXLEN+1]; // This field is fixed to this position!
    BYTE u8MaxSteps;
    BYTE u8NrFunc;
    SHORT s16MaxV;
    struct
    {
        BYTE u5Res : 5;
        BYTE bUnit : 1;
        BYTE u2Dir : 2;
            #define     DIR_BACKWARD    0x00
            #define     DIR_FORWARD     0x01
            #define     DIR_ESTOP       0x02
            #define     DIR_UNCHANGED   0x03
    } sGLFlags;

    SHORT s16ActV;
    DWORD u32FuncBitField;
    DWORD u32FuncAllocMask;
    DWORD u32FuncToggleMask;
    BYTE u8FuncGroup;   // The displayed function group (0=1-4,1=5-8,2=9-12)
    SHORT s16ServerV;   // This value indicates the servers speed.
} sGL;


typedef struct __attribute__((__packed__))
{
    BYTE    u8BusNr;
    DWORD   u32Address;
    BYTE    au8Proto[SRCP_PROTO_MAXLEN+1];
    BYTE    u8MaxSteps;
    BYTE    u8NrFunc;
} sServerCacheEntry;


typedef struct __attribute__((__packed__))
{
    BYTE    u8BusNr;
    DWORD   u32Address;
    BYTE    au8Proto[SRCP_PROTO_MAXLEN+1];
    BYTE    au8Name[SRCP_NAME_MAXLEN+1];

    union
    {
        struct
        {
            BYTE u8MaxSteps;
            BYTE u8NrFunc;
            WORD u16MaxV;
            DWORD u32FunctionToggleMask;
        } sGLSpec;
        
        struct
        {
            BYTE u8MinP;
            BYTE u8MaxP;
            long s32Delay;
        } sGASpec;
    } uSpec;
} sStaticDeviceData;


// ////////////////////////////////////////////////////////////////////////////
// Local variables
// ////////////////////////////////////////////////////////////////////////////

static SSRCPSTATE _sSRCPState;

static SRCP_SM _eSRCPsm;

static SRCP_COMMANDS _eLastSentCommand;

static SM_SRCP_CONNECTING _eSRCPCsm;

// This variable stores the index (for _apsDevices) of the device which has 
// sent the last command.
static SRCP_DEVICE * _pLastCommandDevice;

SRCP_DEVICE * _apsDevices[MAX_SRCP_DEVICES];

static BOOL _bSrvReqIsInProgress;
static DWORD _bServerRequestTime;

static SRCP_DEVICE * _psNewDevice;
static BYTE _u8LastEEPROMSetIdx;

static SRCP_DEVICE * _psActualDevice;

static SRCP_HANDSHAKE_SM _eHSState; // State for handshaking

static BYTE _u8LastSelectedProtoId;
static sStaticDeviceData _sNewDeviceStaticData;

static BYTE _au8ActiveProtos[MAX_PROTO_SLOTS+2]; // One more for server cache.
static sServerCacheEntry * _apsSelectCache;
static BYTE * _pActiveEEPROMSetList;

#pragma udata SRCPGLCache
static sServerCacheEntry _asServerCache[SERVER_CACHE_ENTRIES];
#pragma udata


// ////////////////////////////////////////////////////////////////////////////
// Local function prototypes
// ////////////////////////////////////////////////////////////////////////////

// Connection and handshake functions
void _startHandShake(void);
SRCP_HANDSHAKE_RETCODE _eHandShake(SSRCPSOCKET * hSRCP);


// View functions
static void _updateView(SRCP_DEVICE * pDev);
static void _displayNoData(void);
static void _displayGLData(SRCP_DEVICE * pDev);
static void _displayGAData(SRCP_DEVICE * pDev);
static void _displayPower(SRCP_DEVICE * pDev);
static void _showServerError(WORD u16Code);


// Input functions
static void _updateInput(SRCP_DEVICE * pDev);
static BOOL _bGetGLInput(sGL * pGL);
static BOOL _bGetGAInput(SRCP_DEVICE * pPrm);


// SRCP message functions
static BOOL _startParsing(BYTE u8Socket, SRCP_TIME * psTime, WORD * pu16Code);
static BOOL _bParseLine(BYTE u8Socket, WORD u16Code, SRCP_PRM * pPrm);
static BOOL _bTCPDevType(WORD u16Code, SRCP_DEVTYPE * pDev, BYTE * au8Buf);
static void _answerReceived(SRCP_DEVICE* pDev, WORD u16Code, SRCP_TIME* pTime);
static BOOL _bSendSRCPMessage(SRCP_COMMANDS eCommand, SRCP_DEVICE * pDev);
static BOOL _bDevTypeTCP(SRCP_DEVTYPE eDevType, SRCP_COMMANDS eCommand);
static BOOL _bLookForEnd(BYTE u8Socket);
static BOOL _bGetNextWord(BYTE u8Socket, BYTE * pu8Buf, BYTE u8BufSize, 
                                                                  BOOL * bEnd);

// Device functions
static void _deviceSM(SRCP_DEVICE * pDev);
static BOOL _bIsDeviceMatching(SRCP_DEVICE * psDevice, SRCP_PRM * pPrm);
static SRCP_DEVICE * _pGetPowerDevice(BYTE u8Bus);
static void _updateData(SRCP_DEVICE * pDev, WORD u16Code, SRCP_PRM * pNewPrm);
static SRCP_DEVICE* _psAddDevice(SRCP_DEVTYPE eDevType, BYTE u8Bus, void*pPrm);
static BOOL _bIsInitAllowed(SRCP_DEVTYPE eDevType);
static SHORT _s16computeRealSpeed(SHORT s16MaxV, SHORT s16ServerMaxV, 
                                                         SHORT s16ServerSpeed);
static SRCP_DEVICE * _psInitializeNewDevice(SRCP_DEVTYPE eDevType, BYTE u8Bus,
                                            void * pPrm);
static DWORD _u32GetAddress(SRCP_DEVICE * psDevice);
static void _refreshDeviceList(void);
static SRCP_DEVICE * _pTakeOverDevice(SRCP_DEVICE * pDevice);
static SRCP_DEVICE * _pGetLatestGL(void);
static SRCP_DEVICE * _pGetLatestGA(void);
static void _fillPrmGL(sGL * psNewGL, sStaticDeviceData * psStaticData);
static void _fillPrmGA(sGA * psNewGA, sStaticDeviceData * psStaticData);
static void _getInitData(SRCP_DEVICE * pDev, char * pString);


// Protocol parameter functions
static void _getProtoName(BYTE u8ProtoId, BYTE * pString);
static void _getProtoMinMax(BYTE u8ProtoId, WORD* pu16MinAdd, 
                                                             WORD* pu16MaxAdd);
static BYTE _u8GenerateActiveProtoList(BOOL bGL, BYTE u8Default);
static void _getProtoFromEEPROM(BYTE u8ProtoId, SPPROTOCOL * psProto);
static BOOL _bGetStaticParameterFromProto(BYTE u8ProtoId, sStaticDeviceData * psPrm);


// EEPROM set functions
static BYTE _u8AddEntryToEEPROM(BYTE u8RawQuickIdx, SRCP_DEVICE * pDevice);
static BOOL _bCheckForSelectedSet(sStaticDeviceData * psDeviceData, BOOL bEncoder);
static void _storeNameToEEPROM(BYTE u8EEPROMSetIdx, BYTE *pName);
static BYTE _prepareEEPROMSetInput(BOOL bGL);
static void _destructEEPROMSet(void);


// Server cache functions
static void _UpdateServerCache(SRCP_PRM * pPrm, BOOL bAdd);
static BOOL _bPrepareServerCacheInput(void);
static BOOL _bGetStaticParameterFromCache(BYTE u8CacheId, sStaticDeviceData * psPrm);
static void _destructServerCache(void);


// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCP_CancelInputProtoDialog(void)
{
    if ((_eSRCPsm == SRCP_SELECT_PROTOCOL)||
        (_eSRCPsm == SRCP_SELECT_DEVICE_ADDRESS))
    {
        InputButtonReset(ALL_BTN);
        _eSRCPsm = SRCP_PREPARE_MAIN;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCP_CancelInputSetDialog(void)
{
    if (_eSRCPsm == SRCP_SELECT_EEPROMSET)
    {
        InputButtonReset(ALL_BTN);
        _eSRCPsm = SRCP_PREPARE_MAIN;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCPRestoreToFactory(void)
{
    SPPROTOCOL lococonf;
    BYTE i = 0;
    SPSET eepromset;
    WORD address;


    // ////////////////////////////////////////////////////////////////////////
    // Restoring srcp configuration data:
    memset((void *)&sPSRCPConfig, 0, sizeof(SPSRCPCONFIG));
    // The server cache is standard:
    sPSRCPConfig.u8DefaultGLProtoId = SRCP_SERVERCACHE_ID; 
    sPSRCPConfig.u8DefaultGAProtoId = MAX_PROTO_SLOTS;
    sPSRCPConfig.sFlags.bGAAskForProto = TRUE;
    sPSRCPConfig.sFlags.bGLAskForProto = TRUE;
    sPSRCPConfig.s32GADelay = 500;  // in milliseconds.

    XEEWriteArray(SRCP_CONFIG_EEPROM_ADD, (BYTE *)&sPSRCPConfig, sizeof(SPSRCPCONFIG));


    // ////////////////////////////////////////////////////////////////////////
    // Restoring loco protocol specific data:

    strcpypgm2ram(lococonf.au8Desc, (ROM char *)"Old Motorola");
    strcpypgm2ram(lococonf.au8Proto, (ROM char *)"M 1");
    lococonf.sFlags.bGL = TRUE;
    lococonf.sFlags.bActive = TRUE;
    lococonf.u8Bus = 1;
    lococonf.u16MinAdd = 1; 
    lococonf.u16MaxAdd = 80;
    lococonf.uSpec.sGL.u8MaxSteps = 14;
    lococonf.uSpec.sGL.u8NrFunc = 1;
    XEEWriteArray(EEPROM_GLS, (BYTE *)&lococonf, sizeof(SPPROTOCOL));


    strcpypgm2ram(lococonf.au8Desc, (ROM char *)"New Motorola 1");
    strcpypgm2ram(lococonf.au8Proto, (ROM char *)"M 2");
    lococonf.sFlags.bGL = TRUE;
    lococonf.sFlags.bActive = TRUE;
    lococonf.u8Bus = 1;
    lococonf.u16MinAdd = 1; 
    lococonf.u16MaxAdd = 255;
    lococonf.uSpec.sGL.u8MaxSteps = 28;
    lococonf.uSpec.sGL.u8NrFunc = 5;
    XEEWriteArray(EEPROM_GLS + 1*sizeof(SPPROTOCOL), (BYTE *)&lococonf, sizeof(SPPROTOCOL));


    strcpypgm2ram(lococonf.au8Desc, (ROM char * )"NMRA Base");
    strcpypgm2ram(lococonf.au8Proto, (ROM char * )"N 1");
    lococonf.sFlags.bGL = TRUE;
    lococonf.sFlags.bActive = TRUE;
    lococonf.u8Bus = 2;
    lococonf.u16MinAdd = 1; 
    lococonf.u16MaxAdd = 99;
    lococonf.uSpec.sGL.u8MaxSteps = 14;
    lococonf.uSpec.sGL.u8NrFunc = 0;
    XEEWriteArray(EEPROM_GLS + 2*sizeof(SPPROTOCOL), (BYTE *)&lococonf, sizeof(SPPROTOCOL));


    strcpypgm2ram(lococonf.au8Desc, (ROM char *) "NMRA Extended 2");
    strcpypgm2ram(lococonf.au8Proto, (ROM char *) "N 1");
    lococonf.sFlags.bGL = TRUE;
    lococonf.sFlags.bActive = TRUE;
    lococonf.u8Bus = 2;
    lococonf.u16MinAdd = 1; 
    lococonf.u16MaxAdd = 99;
    lococonf.uSpec.sGL.u8MaxSteps = 28;
    lococonf.uSpec.sGL.u8NrFunc = 5;
    XEEWriteArray(EEPROM_GLS + 3*sizeof(SPPROTOCOL), (BYTE *)&lococonf, sizeof(SPPROTOCOL));


    // Delete the other protocol slots.
    memset(&lococonf, 0, sizeof(SPPROTOCOL));
    lococonf.sFlags.bGL = TRUE;

    for (i = 4; i < MAX_PROTO_SLOTS; i++)
    {
        XEEWriteArray(EEPROM_GLS + i*sizeof(SPPROTOCOL), (BYTE *)&lococonf, sizeof(SPPROTOCOL));
    }


    // ////////////////////////////////////////////////////////////////////////
    // Restoring accessory protocol specific data:
    strcpypgm2ram(lococonf.au8Desc, (ROM char *) "Motorola");
    strcpypgm2ram(lococonf.au8Proto, (ROM char *) "M");
    lococonf.sFlags.bGL = FALSE;
    lococonf.sFlags.bActive = TRUE;
    lococonf.u8Bus = 5;
    lococonf.u16MinAdd = 1; 
    lococonf.u16MaxAdd = 324;
    lococonf.uSpec.sGA.u8MinP = 0;
    lococonf.uSpec.sGA.u8MaxP = 1;
    XEEWriteArray(EEPROM_GAS, (BYTE *)&lococonf, sizeof(SPPROTOCOL));

    strcpypgm2ram(lococonf.au8Desc, (ROM char *) "NMRA-DCC");
    strcpypgm2ram(lococonf.au8Proto, (ROM char *) "N");
    lococonf.sFlags.bGL = FALSE;
    lococonf.sFlags.bActive = TRUE;
    lococonf.u8Bus = 6;
    lococonf.u16MinAdd = 1; 
    lococonf.u16MaxAdd = 511;
    lococonf.uSpec.sGA.u8MinP = 0;
    lococonf.uSpec.sGA.u8MaxP = 1;

    XEEWriteArray(EEPROM_GAS + sizeof(SPPROTOCOL), (BYTE *)&lococonf, sizeof(SPPROTOCOL));

    // Delete the other protocol slots.
    memset(&lococonf, 0, sizeof(SPPROTOCOL));

    for (i = 2; i < MAX_PROTO_SLOTS; i++)
    {
        XEEWriteArray(EEPROM_GAS + i*sizeof(SPPROTOCOL), (BYTE *)&lococonf, sizeof(SPPROTOCOL));
    }


    // Prepare the quick set area.
    memset(&eepromset, 0, sizeof(SPSET));
    eepromset.sFlags.bGL = TRUE;
    address = SRCP_SETS_EEPROM_ADD;
    for (i = 0; i < SRCP_GLEEPROMSET_COUNT; i++)
    {
        XEEWriteArray(address, (BYTE *)&eepromset, sizeof(SPSET));
        address += sizeof(SPSET);
    }

    eepromset.sFlags.bGL = FALSE;
    for (i = 0; i < SRCP_GAEEPROMSET_COUNT; i++)
    {
        XEEWriteArray(address, (BYTE *)&eepromset, sizeof(SPSET));
        address += sizeof(SPSET);
    }

}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCPLocoDirModeHasChanged(void)
{
    if ((_psActualDevice) && (_psActualDevice->eDevType == SRCP_DT_GL))
    {
        _psActualDevice->sFlags.bNewData = TRUE;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCPInitialInit(void)
{
    // Get configuration data from EEPROM...
    XEEReadArray(SRCP_CONFIG_EEPROM_ADD, (BYTE*)&sPSRCPConfig, sizeof(SPSRCPCONFIG));

    _sSRCPState.sCommand.u8Socket = INVALID_SOCKET;
    _sSRCPState.sInfo.u8Socket = INVALID_SOCKET;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL SRCPMain(void)
{
    // Check for Command and Info messages and feed the device state machine.

    SRCP_TIME time;
    WORD code;
    BYTE i = 0;


    // ////////////////////////////////////////////////////////////////////////
    // Checking for a hanging server communication...
    if ((_bSrvReqIsInProgress == TRUE)&&(_bServerRequestTime < TickGet()))
    {
        _bSrvReqIsInProgress = FALSE;
    }


    // ////////////////////////////////////////////////////////////////////////
    // Check the command socket!
    if (TCPWasReset(_sSRCPState.sCommand.u8Socket))
    {
        _sSRCPState.sCommand.u8Socket = INVALID_SOCKET;
        SRCPStartDisconnect();
        return FALSE;
    }

    if (TCPIsGetReady(_sSRCPState.sCommand.u8Socket))
    {
        if (_pLastCommandDevice && _startParsing(_sSRCPState.sCommand.u8Socket, &time, &code))
        {
            SRCP_PRM prm;
            BOOL ret;

            // We are pretty sure, that the incoming packet belongs to the 
            // device the last command was sent to. This will not be  
            // checked here!
            _bSrvReqIsInProgress = FALSE;  // Acknowledge the sent command.
            _answerReceived(_pLastCommandDevice, code, &time);

            if (_bParseLine(_sSRCPState.sCommand.u8Socket,code, &prm))
            {
                // Update the data.
                _updateData(_pLastCommandDevice, code, &prm);
            }
        }
    
        // Only one command answer is expected. Throw away the rest of the 
        // frame.
        TCPDiscard(_sSRCPState.sCommand.u8Socket);
    }


    // ////////////////////////////////////////////////////////////////////////
    // Check the info socket!
    if(TCPWasReset(_sSRCPState.sInfo.u8Socket))
    {
        _sSRCPState.sInfo.u8Socket = INVALID_SOCKET;
        SRCPStartDisconnect();
        return FALSE;
    }
    while (TCPIsGetReady(_sSRCPState.sInfo.u8Socket))
    {
        // Check all the lines which are included in the received frame.

        // Obtain the time and the code!
        if (_startParsing(_sSRCPState.sInfo.u8Socket, &time, &code))
        {
            SRCP_PRM prm;
            if (_bParseLine(_sSRCPState.sInfo.u8Socket, code, &prm))
            {
                // Update the internal list cache of server devices.
                if (code == 101)
                {
                    // Add to cache.
                    _UpdateServerCache(&prm, TRUE);
                }
                else if (code == 102)
                {
                    // Remove from cache.
                    _UpdateServerCache(&prm, FALSE);
                }

                // Search for a matching device in the device list.
                for(i = 0; i < MAX_SRCP_DEVICES; i++)
                {
                    if (_bIsDeviceMatching(_apsDevices[i], &prm))
                    {
                        _answerReceived(_apsDevices[i], code, &time);
                        _updateData(_apsDevices[i], code, &prm);
                    }
                }
            }
        }
    }


    // ////////////////////////////////////////////////////////////////////////
    // Execute all the state machines of the devices if we can send new 
    // commands.
    i = 0;
    while((_bSrvReqIsInProgress == FALSE)&&(i < MAX_SRCP_DEVICES))
    {
        _deviceSM(_apsDevices[i++]);
    }


    // ////////////////////////////////////////////////////////////////////////
    // Check for the power device. This view and input is independent from the
    // SRCP state machine. So the power state can be controlled also in error
    // states and in the input dialog states.
    if (_psActualDevice)
    {
        SRCP_DEVICE * pPowerDev = _pGetPowerDevice(_psActualDevice->u8Bus);

        if (pPowerDev==NULL)
        {
            // The power device was disabled! The actual device is strongly
            // linked to this power device and can only be used with a well
            // configured power device. Disable the actual device.

            _psActualDevice->eDevState = SRCP_DS_DISABLED;
        }
        else
        {
            sPower * pPwr = (sPower*)(&pPowerDev[1]);
            _updateView(pPowerDev);

            if (pPowerDev->eDevState == SRCP_DS_DISABLED)
            {
                // The power device was disabled! The actual device is strongly
                // linked to this power device and can only be used with a well
                // configured power device. Disable the actual device.
    
                _psActualDevice->eDevState = SRCP_DS_DISABLED;
            }
            else if (bInputButtonPushed(PWR_BTN) == TRUE)
            {
                // Toggle the power state.
                pPwr->bPowerState = !(pPwr->bPowerState);
                if (_bSendSRCPMessage(SRCP_CMD_SET, pPowerDev) == TRUE)
                {
                    InputButtonReset(PWR_BTN);
                }

                // Retoggle the power state to stay synchronized with the view.
                // The new state comes via an INFO message and updates the 
                // view.
                pPwr->bPowerState = !(pPwr->bPowerState);
            }
        }
    }


    // ////////////////////////////////////////////////////////////////////////
    // The Global SRCP Input and View State Machine
    switch (_eSRCPsm)
    {
    case SRCP_STARTUP:
        // This state is only called once after connect and handshake.
        InputButtonReset(ALL_BTN);
        OutSwitchOffAllLEDs();
        _eSRCPsm = SRCP_MAIN;
        break;

    case SRCP_MAIN:
        if (_psActualDevice)
        {
            if ((_psActualDevice->eDevType == SRCP_DT_GL) && bInputButtonPushedLong(SEL_BTN))
            {
                // The loco select button was pushed for a long time, the user
                // wants to store the loco as a quick or loco db set in eeprom.
                InputButtonReset(ALL_BTN);
                InputEncoderInit(4, 0, SRCP_GLEEPROMSET_COUNT-1, 0);
                _eSRCPsm = SRCP_SELECT_EEPROM_SET_TO_SAVE;
                break;
            }
            else if ((_psActualDevice->eDevType == SRCP_DT_GA) && bInputButtonPushedLong(ACC_BTN))
            {
                // The accessory select button was pushed for a long time, the user
                // wants to store the acc at a quick set in eeprom.
                InputButtonReset(ALL_BTN);
                InputEncoderInit(0, 0, SRCP_GAEEPROMSET_COUNT-1, 0);
                _eSRCPsm = SRCP_SELECT_EEPROM_SET_TO_SAVE;
                break;
            }
        }

        if (bInputButtonPushed(SEL_BTN) == TRUE)
        {
            BYTE protoCount;

            // Reset the button for new inputs:
            InputButtonReset(ALL_BTN);
            OutSetLED(LED_SEL, LED_ON);

            if (_psActualDevice && (_psActualDevice->eDevType==SRCP_DT_GA))
            {
                // Switch over to the last known GL set.
                if (_pGetLatestGL())
                {
                    _psNewDevice = _pGetLatestGL();
                    _eSRCPsm = SRCP_WAIT_FOR_IDLE_DEVICE;
                    break;
                }
            }

            protoCount = _u8GenerateActiveProtoList(TRUE, sPSRCPConfig.u8DefaultGLProtoId);
            if (protoCount==0)
            {
                // We never should come in here (at least the server cache is
                // selectable).
                OutSetLED(LED_SEL, LED_OFF);
                break;
            }

            if ((sPSRCPConfig.sFlags.bGLAskForProto == TRUE) && (protoCount>1))
            {
                InputEncoderInit(0, 0, protoCount-1, 0);
                InputButtonReset(ENC_BTN);
                _eSRCPsm = SRCP_SELECT_PROTOCOL;
            }
            else
            {
                _u8LastSelectedProtoId = sPSRCPConfig.u8DefaultGLProtoId;
                _eSRCPsm = SRCP_PROTOCOL_SELECTED;
            }

            break;
        }
        else if (bInputButtonPushed(ACC_BTN) == TRUE)
        {   
            BYTE protoCount;

            // Reset the button for new inputs:
            InputButtonReset(ALL_BTN);
            OutSetLED(LED_ACC, LED_ON);

            if (_psActualDevice && (_psActualDevice->eDevType==SRCP_DT_GL))
            {
                // Switch over to the last known GA set.
                if (_pGetLatestGA())
                {
                    _psNewDevice = _pGetLatestGA();
                    _eSRCPsm = SRCP_WAIT_FOR_IDLE_DEVICE;
                    break;
                }
            }

            protoCount = _u8GenerateActiveProtoList(FALSE, sPSRCPConfig.u8DefaultGAProtoId);
            if (protoCount == 0)
            {
                // No entry in the protocol list! Finish up! 
                OutSetLED(LED_ACC, LED_OFF);
                break;
            }

            if ((sPSRCPConfig.sFlags.bGAAskForProto == TRUE) && (protoCount>1))
            {
                InputEncoderInit(0, 0, protoCount-1, 0);
                InputButtonReset(ENC_BTN);
                _eSRCPsm = SRCP_SELECT_PROTOCOL;
            }
            else
            {
                _u8LastSelectedProtoId = sPSRCPConfig.u8DefaultGAProtoId;
                _eSRCPsm = SRCP_PROTOCOL_SELECTED;
            }

            break;
        }


        // Is there a configured device for view?
        if (_psActualDevice == NULL)
        {
            break;
        }

        if (_psActualDevice->eDevState == SRCP_DS_DISABLED)
        {
            // The device is disabled (terminated)!
            _displayNoData();
            _psActualDevice = NULL;
            break;
        }

        // Check for changed view of the actual device.
        _updateView(_psActualDevice);

        _updateInput(_psActualDevice);

        break;

    case SRCP_SELECT_EEPROM_SET_TO_SAVE:
        _u8LastEEPROMSetIdx = 0xFF;
        if (bInputButtonPushed(F1_BTN) == TRUE)
        {
            _u8LastEEPROMSetIdx = 0;
        }
        else if (bInputButtonPushed(F2_BTN) == TRUE)
        {
            _u8LastEEPROMSetIdx = 1;
        }
        else if (bInputButtonPushed(F3_BTN) == TRUE)
        {
            _u8LastEEPROMSetIdx = 2;
        }
        else if (bInputButtonPushed(F4_BTN) == TRUE)
        {
            _u8LastEEPROMSetIdx = 3;
        }
        else if (bInputButtonPushedOnce(ENC_BTN) == TRUE)
        {
            _u8LastEEPROMSetIdx = (BYTE) s16InputEncoderGetValue();
        }

        if (_u8LastEEPROMSetIdx != 0xFF)
        {
            BOOL ret;

            ret = bInitInputDialog(DEVICE_NAME_PTR(_psActualDevice), 
                                   DIALOG_ALL_LETTERS, 0,
                                   SRCP_NAME_MAXLEN,
                                   DIALOG_ESC_FLAG | DIALOG_DESCRIPTION_FLAG |
                                   DIALOG_NEXT_FLAG | DIALOG_BACKSPACE_FLAG);
            
            if (ret == TRUE)
            {
                _eSRCPsm = SRCP_ENTER_NAME;
            }
            else
            {
                _eSRCPsm = SRCP_MAIN;
            }
        }
        else if (bInputEncoderValueChanged() == TRUE)
        {
            BYTE setidx = s16InputEncoderGetValue();
            lcd_addr1 = 0;
            StrTbl_GetString(lcdram_row1, STRTBLID_DATABASE);
            // The second row is for the set id.
            sprintf(lcdram_row2, StrTbl_cau8GetStringPointer(STRTBLID_POSITION_X), setidx+1);
            lcd_addr2 = 0;
            lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_ROW2_MASK;
        }
        break;      

    case SRCP_ENTER_NAME:
        if (bHandleInputDialog()==TRUE)
        {
            BYTE * pName = DEVICE_NAME_PTR(_psActualDevice);
            if (FiniDialog(pName) == DIALOG_FINI_OK)
            {
                // Store the current device into the quick storage.
                _u8LastEEPROMSetIdx = _u8AddEntryToEEPROM(_u8LastEEPROMSetIdx, _psActualDevice);
                
                // Remember the new name.
                _storeNameToEEPROM(_u8LastEEPROMSetIdx, pName);
            }
            _eSRCPsm = SRCP_PREPARE_MAIN;
        }
        break;

    case SRCP_SELECT_PROTOCOL:
        // Thats the protocol dialog. The user chooses one of the preconfigured
        // protocols.
        if (_bCheckForSelectedSet(&_sNewDeviceStaticData, FALSE) == TRUE)
        {
            // Quick select (via the FX-buttons):
            _eSRCPsm = SRCP_INIT_DEVICE;
        }       
        else if (bInputButtonPushed(ENC_BTN) == TRUE)
        {
            _u8LastSelectedProtoId = _au8ActiveProtos[s16InputEncoderGetValue()];
            _eSRCPsm = SRCP_PROTOCOL_SELECTED;
        }   
        else if (bInputEncoderValueChanged() == TRUE)
        {
            BYTE selected = s16InputEncoderGetValue();
            lcd_addr1 = 0;
            StrTbl_GetString(lcdram_row1, STRTBLID_PROTOCOL);
            // The second row is for the protocol name
            if (_au8ActiveProtos[selected]==SRCP_SERVERCACHE_ID)
            {
                StrTbl_GetString(lcdram_row2, STRTBLID_SERVER_CACHE);
            }
            else if (_au8ActiveProtos[selected]==SRCP_EEPROMSET_ID)
            {
                StrTbl_GetString(lcdram_row2, STRTBLID_DATABASE);
            }
            else
            {
                _getProtoName(_au8ActiveProtos[selected], lcdram_row2);
            }
            lcd_addr2 = 0;
            lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_ROW2_MASK;
        }
        else if (bInputButtonPushed(ACC_BTN) == TRUE)
        {
            if (OutGetLEDMode(LED_ACC) == LED_ON)
            {
                InputButtonReset(ACC_BTN);
            }
            _eSRCPsm = SRCP_PREPARE_MAIN;
        }
        else if (bInputButtonPushed(SEL_BTN) == TRUE)
        {
            if (OutGetLEDMode(LED_SEL) == LED_ON)
            {
                InputButtonReset(SEL_BTN);
            }
            _eSRCPsm = SRCP_PREPARE_MAIN;
        }
        break;

    case SRCP_PROTOCOL_SELECTED:
        switch(_u8LastSelectedProtoId)
        {
        case SRCP_SERVERCACHE_ID:
            if (_bPrepareServerCacheInput() == TRUE)
            {
                _eSRCPsm = SRCP_SELECT_SERVER_CACHE;
            }
            else
            {
                // \todo For test: Force to get into this state!
                _eSRCPsm = SRCP_ERROR;
            }
            break;

        case SRCP_EEPROMSET_ID:
        {
            BOOL bGL = FALSE;
            BYTE entries;
            if (OutGetLEDMode(LED_SEL) == LED_ON)
            {
                bGL = TRUE;
            }

            entries = _prepareEEPROMSetInput(bGL);

            if (entries == 0)
            {
                _eSRCPsm = SRCP_ERROR;
            }
            else
            {
                // Initialize the encoder.
                InputButtonReset(ENC_BTN);
                InputEncoderInit(0, 0, entries-1, 0);
                _eSRCPsm = SRCP_SELECT_EEPROMSET;
            }

            break;
        }

        default:
            if (_bGetStaticParameterFromProto(_u8LastSelectedProtoId, &_sNewDeviceStaticData) == TRUE)
            {
                // Fetch the address from user.
                WORD min, max;
                _getProtoMinMax(_u8LastSelectedProtoId, &min, &max);
                InputEncoderInit(1, min, max, 0);
        
                lcd_addr1 = 0;
                StrTbl_GetString(lcdram_row1, STRTBLID_ADDRESS);
                lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK;

                InputButtonReset(ENC_BTN);
                _eSRCPsm = SRCP_SELECT_DEVICE_ADDRESS;
            }
            else
            {
                // \todo For test: Force to get into this state!
                _eSRCPsm = SRCP_ERROR;
            }
        }
        break;


    case SRCP_SELECT_DEVICE_ADDRESS:
        // Thats the address setting dialog!
        if (_bCheckForSelectedSet(&_sNewDeviceStaticData, FALSE) == TRUE)
        {
            // One of the quick buttons was pushed!
            _eSRCPsm = SRCP_INIT_DEVICE;
        }
        else if (bInputButtonPushedOnce(ENC_BTN) == TRUE)
        {
            // Selection!
            _sNewDeviceStaticData.u32Address = s16InputEncoderGetValue();
            _eSRCPsm = SRCP_INIT_DEVICE;
        }
        else if (bInputEncoderValueChanged() == TRUE)
        {
            sprintf(lcdram_row2, (ROM char *) "%5hu", s16InputEncoderGetValue());
            lcd_status |= LCD_ROW2_MASK;
        }
        else if (bInputButtonPushed(ACC_BTN) == TRUE)
        {
            if (OutGetLEDMode(LED_ACC) == LED_ON)
            {
                InputButtonReset(ACC_BTN);
            }
            _eSRCPsm = SRCP_PREPARE_MAIN;
        }
        else if (bInputButtonPushed(SEL_BTN) == TRUE)
        {
            if (OutGetLEDMode(LED_SEL) == LED_ON)
            {
                InputButtonReset(SEL_BTN);
            }
            _eSRCPsm = SRCP_PREPARE_MAIN;
        }
        break;


    case SRCP_SELECT_EEPROMSET:
        if (_bCheckForSelectedSet(&_sNewDeviceStaticData, TRUE) == TRUE)
        {
            // Quick select (via the FX or the Encoder-buttons):
            _eSRCPsm = SRCP_INIT_DEVICE;
        }
        else if (bInputEncoderValueChanged() == TRUE)
        {
            SPSET set;
            BYTE setidx = _pActiveEEPROMSetList[s16InputEncoderGetValue()];

            // The first row indicates what should be input.
            lcd_addr1 = 0;
            StrTbl_GetString(lcdram_row1, STRTBLID_DATABASE);

            // The second row is for eeprom set name.
            XEEReadArray(SRCP_SETS_EEPROM_ADD + (sizeof(SPSET) * setidx), (BYTE *)&set, sizeof(SPSET));

            strncpy(lcdram_row2, set.au8Name, LCD_CHARS_IN_A_ROW);
            lcdram_row2[LCD_CHARS_IN_A_ROW] = 0;
            lcd_addr2 = 0;
            lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_ROW2_MASK;
        }
        else if (bInputButtonPushed(ACC_BTN) == TRUE)
        {
            if (OutGetLEDMode(LED_ACC) == LED_ON)
            {
                InputButtonReset(ACC_BTN);
            }
            _eSRCPsm = SRCP_PREPARE_MAIN;
        }
        else if (bInputButtonPushed(SEL_BTN) == TRUE)
        {
            if (OutGetLEDMode(LED_SEL) == LED_ON)
            {
                InputButtonReset(SEL_BTN);
            }
            _eSRCPsm = SRCP_PREPARE_MAIN;
        }

        if (_eSRCPsm != SRCP_SELECT_EEPROMSET)
        {
            // Leaving this state? Destructing the list.
            _destructEEPROMSet();
        }
        break;


    case SRCP_SELECT_SERVER_CACHE:
        if (_bCheckForSelectedSet(&_sNewDeviceStaticData, FALSE) == TRUE)
        {
            // Quick select (via the FX-buttons):
            _eSRCPsm = SRCP_INIT_DEVICE;
        }
        else if (bInputButtonPushed(ENC_BTN) == TRUE)
        {
            // Copy the cache data to the initialization structure.
            _bGetStaticParameterFromCache(s16InputEncoderGetValue(),&_sNewDeviceStaticData);
            _eSRCPsm = SRCP_INIT_DEVICE;
        }
        else if (bInputEncoderValueChanged() == TRUE)
        {
            BYTE idx = s16InputEncoderGetValue();

            // The first row indicates what should be input.
            lcd_addr1 = 0;
            StrTbl_GetString(lcdram_row1, STRTBLID_BUS_ADDRESS);

            // The second row is for the address and bus number.
            sprintf(lcdram_row2, (ROM char *) "%-3hhu        %5lu", _apsSelectCache[idx].u8BusNr, _apsSelectCache[idx].u32Address);
            lcd_addr2 = 0;
            lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_ROW2_MASK;
        }
        else if (bInputButtonPushed(ACC_BTN) == TRUE)
        {
            if (OutGetLEDMode(LED_ACC) == LED_ON)
            {
                InputButtonReset(ACC_BTN);
            }
            _eSRCPsm = SRCP_PREPARE_MAIN;
        }
        else if (bInputButtonPushed(SEL_BTN) == TRUE)
        {
            if (OutGetLEDMode(LED_SEL) == LED_ON)
            {
                InputButtonReset(SEL_BTN);
            }
            _eSRCPsm = SRCP_PREPARE_MAIN;
        }

        if (_eSRCPsm != SRCP_SELECT_SERVER_CACHE)
        {
            // Leaving this state? Destructing the cache.
            _destructServerCache();
        }
        break;


    case SRCP_INIT_DEVICE:
        if (OutGetLEDMode(LED_ACC) == LED_ON)
        {
            sGA newGA;
            _fillPrmGA(&newGA, &_sNewDeviceStaticData);
            _psNewDevice = _psAddDevice(SRCP_DT_GA, _sNewDeviceStaticData.u8BusNr, (void *)&newGA);
        }
        else
        {
            sGL newGL;
            _fillPrmGL(&newGL, &_sNewDeviceStaticData);
            _psNewDevice = _psAddDevice(SRCP_DT_GL, _sNewDeviceStaticData.u8BusNr, (void *)&newGL);
        }

        if (_psNewDevice == NULL)
        {
            PrintCommonError(COMMON_ERROR_OUT_OF_MEMORY);
            _eSRCPsm = SRCP_ERROR;
            break;
        }

        _eSRCPsm = SRCP_WAIT_FOR_IDLE_DEVICE;
        // Intended fall through.


    case SRCP_WAIT_FOR_IDLE_DEVICE:
        if (_psNewDevice->u16LastErrorCode)
        {
            _showServerError(_psNewDevice->u16LastErrorCode);       
            // Acknowledge the error:
            _psNewDevice->u16LastErrorCode = 0;
            _psNewDevice->eDevState = SRCP_DS_DISABLED;
            _eSRCPsm = SRCP_ERROR;
            break;
        }
        else if (_psNewDevice->eDevState != SRCP_DS_IDLE)
        {
            break;
        }
        
        _eSRCPsm = SRCP_INIT_POWER;
        // Intended fall through.
        

    case SRCP_INIT_POWER:
    {
        // After we know the protocol and the SRCP bus number (as protocol
        // parameter), we can check for a configured POWER device on that bus.
        sPower prm;
        prm.bPowerState = FALSE;

        // Append the power device to the device list (the function 
        // _psAddDevice automatically checks for already configured power 
        // device).
        if (_psAddDevice(SRCP_DT_POWER, _psNewDevice->u8Bus, (void*)&prm) == NULL)
        {
            PrintCommonError(COMMON_ERROR_OUT_OF_MEMORY);
            _eSRCPsm = SRCP_ERROR;
            break;
        }
        
        _eSRCPsm = SRCP_WAIT_FOR_IDLE_POWER_DEVICE;
        // Intented fall through.
    }
    

    case SRCP_WAIT_FOR_IDLE_POWER_DEVICE:
    {
        // Check whether the power device is already idle (initialized).
        SRCP_DEVICE * pPowerDev;


        // Step 1: Fetch the power device from the device list.
        pPowerDev = _pGetPowerDevice(_psNewDevice->u8Bus);
        if (pPowerDev==NULL)
        {
            // We never should come in here!
            PrintCommonError(COMMON_ERROR_SRCP_NO_POWER_DEVICE);
            _eSRCPsm = SRCP_ERROR;
            break;
        }


        // Step 2: Check for errors on the power device.
        if (pPowerDev->u16LastErrorCode)
        {
            _showServerError(pPowerDev->u16LastErrorCode);
            pPowerDev->u16LastErrorCode = 0;    // Acknowledge the error.
            _eSRCPsm = SRCP_ERROR;
            pPowerDev->eDevState = SRCP_DS_DISABLED;
            _psNewDevice->eDevState = SRCP_DS_DISABLED;
            break;
        }


        // Step 3:
        // Check the state of power device (should become idle in short time).
        if (pPowerDev->eDevState == SRCP_DS_IDLE)
        {
            // We can switch from the old to this new device.
            _psActualDevice = _pTakeOverDevice(_psNewDevice);
            _eSRCPsm = SRCP_PREPARE_MAIN;
        }

        break;
    }


    case SRCP_ERROR:
        InputButtonReset(ALL_BTN);
        _eSRCPsm = SRCP_ACK_ERROR;
        break;


    case SRCP_ACK_ERROR:
        if (bInputButtonPushed(ALL_BTN)==FALSE)
        {
            break;
        }
        // Intented fall through.

        
    case SRCP_PREPARE_MAIN:
        if (_psActualDevice == NULL)
        {
            _displayNoData();
        }
        else
        {
            OutSetLED(LED_ACC | LED_SEL, LED_OFF);

            lcd_addr1 = 0;
            strncpy(lcdram_row1, DEVICE_NAME_PTR(_psActualDevice), LCD_CHARS_IN_A_ROW);
            lcdram_row1[LCD_CHARS_IN_A_ROW] = 0;        
            lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK;
            lcdram_row2[0] = 0;

            if (_psActualDevice->eDevType == SRCP_DT_GA)
            {
                sGA * pGA = (sGA *)(&_psActualDevice[1]);
                InputEncoderInit(pGA->u8Port, pGA->u8MinPort, pGA->u8MaxPort, ENC_ENDSTOP_MASK);
            }
            else if (_psActualDevice->eDevType == SRCP_DT_GL)
            {
                sGL * pGL = (sGL *)(&_psActualDevice[1]);
                pGL->s16ActV = pGL->s16ServerV;
            }

            // Mark for new data to ensure updating the view.
            _psActualDevice->sFlags.bNewData = TRUE;
        }

        _eSRCPsm = SRCP_MAIN;
        if (bInputButtonPushed(SEL_BTN) || bInputButtonPushed(ACC_BTN))
        {
            // The user wants to configure a new device. Go straight to the
            // dialog.
            break;
        }

        InputButtonReset(ALL_BTN);
        break;
    }

    // All SRCP stuff was handled correctly. Show to application with a TRUE
    // return value.
    return TRUE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static SHORT _s16computeRealSpeed(SHORT s16MaxV, SHORT s16ServerMaxV, SHORT s16ServerSpeed)
{
    if (s16MaxV == s16ServerMaxV)
    {
        return s16ServerSpeed;
    }
    else
    {
        return (SHORT)(((float)s16ServerSpeed / s16ServerMaxV) * s16MaxV);
    }
}


// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bGetNextWord(BYTE u8Socket, BYTE * au8Buf, BYTE u8BufSize, BOOL * bEnd)
{
    BYTE i = 0;
    BYTE data = 0;
    u8BufSize = u8BufSize-1;    // Leave space for the termination character.

    if (*bEnd == TRUE)
    {
        return FALSE;
    }

    // Step 1: Throw away all prepending whitespaces (semicolon, space, tab)
    // characters.
    do
    {
        if (TCPGet(u8Socket, &data) == FALSE)
        {
            return FALSE;
        }
    } while(data==';' || data==' ' || data==9);


    // Step 2: Get the word to the next whitespace or line end.
    do
    {
        if (data == '\n')
        {
            if (i && au8Buf[i-1] == 92)
            {
                // Is the line end escaped, than handle this character group
                // (\CRLF or \LF) as whitespace!
                i = i-1;
            }
            else
            {
                // We have reached the end of the line:
                *bEnd = TRUE;
            }

            // Maybe after this line is another line!
            break;
        }

        if ((i < u8BufSize)&&(data>=32)&&(data<=127))
        {
            // Store the data if buffer space is left.
            au8Buf[i++] = data;
        }

        if (TCPGet(u8Socket, &data) == FALSE)
        {
            return FALSE;
        }
        
    } while(data != ';' && data != ' ' && data != 9); 

    au8Buf[i] = 0;      // end as string

    return TRUE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bLookForEnd(BYTE u8Socket)
{
    BYTE data;

    while (TCPGet(u8Socket, &data))
    {
        if (data == 92)
        {
            // Backslash found!
            // Handle the following (CR)LF as whitespace.
            if(TCPGet(u8Socket, &data))
            {
                if (data==0x0d)
                {
                    if (TCPGet(u8Socket, &data) == FALSE)
                    {
                        return FALSE;
                    }
                }
            }
            else
            {
                return FALSE;
            }
        }
        else if (data == 0x0a)
        {
            return TRUE;
        }
    }

    return FALSE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCP_GetProtoFromEEPROM(BYTE u8ProtoId, SPPROTOCOL * psProto)
{
    XEEReadArray(SRCP_PROTOS_EEPROM_ADD + (sizeof(SPPROTOCOL) * u8ProtoId), (BYTE *)psProto, sizeof(SPPROTOCOL));
}


// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCP_WriteSetToEEPROM(BYTE u8SetIdx, SPSET * psSet)
{
    XEEWriteArray(SRCP_SETS_EEPROM_ADD + (sizeof(SPSET) * u8SetIdx), (BYTE *)psSet, sizeof(SPSET));
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCP_GetSetFromEEPROM(BYTE u8SetIdx, SPSET * psSet)
{
    XEEReadArray(SRCP_SETS_EEPROM_ADD + (sizeof(SPSET) * u8SetIdx), (BYTE *)psSet, sizeof(SPSET));
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _getProtoFromEEPROM(BYTE u8ProtoId, SPPROTOCOL * psProto)
{
    // For the internal access only the content data will be used.
    XEEReadArray(SRCP_PROTOS_EEPROM_ADD + (sizeof(SPPROTOCOL) * u8ProtoId), (BYTE *)psProto, sizeof(SPPROTOCOL));
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCP_WriteProtoToEEPROM(BYTE u8ProtoId, SPPROTOCOL * psProto)
{
    SPPROTOCOL proto;
    SRCP_GetProtoFromEEPROM(u8ProtoId, &proto);

    if (memcmp((void *)&proto, (void*)psProto, sizeof(SPPROTOCOL)))
    {
        XEEWriteArray(SRCP_PROTOS_EEPROM_ADD+(sizeof(SPPROTOCOL) * u8ProtoId), (BYTE *)psProto, sizeof(SPPROTOCOL));
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _displayNoData(void)
{
    StrTbl_GetString(lcdram_row1, STRTBLID_NO_DEVICE);
    lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK;
    OutSwitchOffAllLEDs();
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _displayGLData(SRCP_DEVICE * pDev)
{
    BYTE i = 0;
    BYTE tmplcd[17];
    sGL * pGL = (sGL *)(&pDev[1]);

    if (pGL->u8FuncGroup == 0)
    {
        SHORT min = 0;
        SHORT speed = pGL->s16ActV;

        if (pGL->s16MaxV != pGL->u8MaxSteps)
        {
            speed = _s16computeRealSpeed(pGL->s16MaxV, pGL->u8MaxSteps, pGL->s16ActV);
        }

        sprintf(tmplcd, (ROM char *) "%-5lu       %3hd", pGL->u32Addr, speed);

        if (pGL->s16ActV != pGL->s16ServerV)
        {
            if (pGL->s16ActV > pGL->s16ServerV)
            {
                tmplcd[15] = 0x05;
            }
            else 
            {
                tmplcd[15] = 0x06;
            }
        }
        else
        {
            tmplcd[15] = 0x20;
        }
    
        if (pGL->sGLFlags.u2Dir == DIR_FORWARD)
        {
            tmplcd[7] = 0x01;
        }
        else if (pGL->sGLFlags.u2Dir == DIR_BACKWARD)
        {
            tmplcd[7] = 0x02;
        }

        tmplcd[16] = 0;


        if (IsEncoderTurning() == FALSE)
        {
            speed = pGL->s16ActV;
            if (sPApplConfig.sFlags.bToggleLocoDirMode == TOGGLEDIRMODE_ZERO)
            {
                if (pGL->sGLFlags.u2Dir == DIR_BACKWARD)
                {
                    speed = -(speed);
                }
                min = pGL->u8MaxSteps;
                min = -min;
            }
        
            InputEncoderInit(speed, min, pGL->u8MaxSteps, ENC_NOCHANGE_MASK | ENC_ENDSTOP_MASK);
        }
    }
    else if (pGL->u8FuncGroup == 1)
    {
        strcpypgm2ram(tmplcd, (ROM char *)"F5              ");
        if (pGL->u8NrFunc > 6)
        {
            tmplcd[5] = 'F';
            tmplcd[6] = '6';
        }
        if (pGL->u8NrFunc > 7)
        {
            tmplcd[9] = 'F';
            tmplcd[10] = '7';
        }
        if (pGL->u8NrFunc > 8)
        {
            tmplcd[14] = 'F';
            tmplcd[15] = '8';
        }
    }
    else
    {
        strcpypgm2ram(tmplcd, (ROM char *)"F9              ");
        if (pGL->u8NrFunc > 10)
        {
            tmplcd[5] = 'F';
            tmplcd[6] = '1';
            tmplcd[7] = '0';
        }
        if (pGL->u8NrFunc > 11)
        {
            tmplcd[9] = 'F';
            tmplcd[10] = '1';
            tmplcd[11] = '1';
        }
        if (pGL->u8NrFunc > 12)
        {
            tmplcd[13] = 'F';
            tmplcd[14] = '1';
            tmplcd[15] = '2';
        }
    }


    if (strcmp(tmplcd, lcdram_row2))
    {
        lcd_addr2 = 0;
        lcd_status |= LCD_ROW2_MASK;
        strcpy(lcdram_row2, tmplcd);
    }


    // Function mask (group dependent)
    {
        DWORD funcs = pGL->u32FuncBitField & pGL->u32FuncAllocMask;

        // F0 is always displayed at the F0 button:
        BYTE led = funcs & 0x01;

        // F1-F4 alternate function group dependent.
        if (pGL->u8FuncGroup == 0)
        {
            led |= funcs & 0x1E;
        }
        else if (pGL->u8FuncGroup == 1)
        {
            led |= (funcs >> 4) & 0x1E;
        }
        else
        {
            led |= (funcs >> 8) & 0x1E;
        }

        OutSetLEDMask(LED_FL | LED_F1 | LED_F2 | LED_F3 | LED_F4, led);
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _displayGAData(SRCP_DEVICE * pDev)
{
    sGA * pGA = (sGA *)(&pDev[1]);

    lcd_addr2 = 0;
    sprintf(lcdram_row2, (ROM char *) "%-5lu        %3hhu", pGA->u32Addr, pGA->u8Port);
    lcd_status |= LCD_ROW2_MASK;

    InputEncoderSetValue(pGA->u8Port, FALSE);

    if (pGA->u8Value == 0)
    {
        lcdram_row2[7] = 0x03;
    }
    else
    {
        lcdram_row2[7] = 0x04;
    }

    OutSetLED(LED_FL|LED_F1|LED_F2|LED_F3|LED_F4, LED_OFF);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _displayPower(SRCP_DEVICE * pDev)
{
    sPower * pPwr = (sPower *)(&pDev[1]);

    if ((OutGetLEDMode(LED_PWR) != LED_BLINK)&&(pPwr->bPowerState==FALSE))
    {
        OutSetLED(LED_PWR, LED_BLINK);
    }
    else if ((OutGetLEDMode(LED_PWR) != LED_ON)&&(pPwr->bPowerState))
    {
        OutSetLED(LED_PWR, LED_ON);
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bGetGLInput(sGL * pGL)
{
    BOOL bChanged = FALSE;
    DWORD functionActive = pGL->u32FuncBitField;    // Get the current function flag field.
    DWORD functionToggle = pGL->u32FuncToggleMask;
    DWORD functionMask;


    if (pGL == NULL)
    {
        return FALSE;
    }

    if (bInputEncoderValueChanged() == TRUE)
    {
        SHORT val = s16InputEncoderGetValue();

        if (sPApplConfig.sFlags.bToggleLocoDirMode == TOGGLEDIRMODE_ZERO)
        {
            if (pGL->s16ActV == 0)
            {
                if ((InputEncoderGetDirection() == FALSE) && (pGL->sGLFlags.u2Dir == DIR_BACKWARD))
                {
                    pGL->sGLFlags.u2Dir = DIR_FORWARD;
                    val = 0;
                }
                else if ((InputEncoderGetDirection() == TRUE) && (pGL->sGLFlags.u2Dir == DIR_FORWARD))
                {
                    pGL->sGLFlags.u2Dir = DIR_BACKWARD;
                    val = 0;
                }
            }
            
            if (val < 0)
            {
                val = -(val);
            }
        }

        pGL->s16ActV = val;
        bChanged = TRUE;
    }
    if (bInputButtonPushedOnce(ENC_BTN) == TRUE)
    {
        if (sPApplConfig.sFlags.bToggleLocoDirMode == TOGGLEDIRMODE_CLICK)
        {
            // Change the direction of the loco:
            switch (pGL->sGLFlags.u2Dir)
            {
            case DIR_FORWARD:
                pGL->sGLFlags.u2Dir = DIR_BACKWARD;
                break;

            case DIR_BACKWARD:
                pGL->sGLFlags.u2Dir = DIR_FORWARD;
                break;
            }
        }

        pGL->s16ActV = 0;
        bChanged = TRUE;
        InputButtonReset(ENC_BTN);  
    }


    // Preparing the toggle mask for the actual function group.
    functionActive &= ~functionToggle;  // Mask out the toggle bits.
    functionMask = 0x02;

    if (pGL->u8FuncGroup==1)
    {
        functionMask = functionMask << 4;
    }
    else if (pGL->u8FuncGroup == 2)
    {
        functionMask = functionMask << 8;
    }


    // Function F1
    if ((functionToggle & functionMask) && bInputButtonPressed(F1_BTN))
    {
        functionActive |= functionMask;
        InputButtonReset(F1_BTN);
    }
    else if (((functionToggle & functionMask) == 0) && bInputButtonPushed(F1_BTN))
    {
        functionActive ^= functionMask;
        InputButtonReset(F1_BTN);
    }
    functionMask = functionMask << 1;



    // Function F2
    if ((functionToggle & functionMask) && bInputButtonPressed(F2_BTN))
    {
        functionActive |= functionMask;
        InputButtonReset(F2_BTN);
    }
    else if (((functionToggle & functionMask) == 0) && bInputButtonPushed(F2_BTN))
    {
        functionActive ^= functionMask;
        InputButtonReset(F2_BTN);
    }
    functionMask = functionMask << 1;



    // Function F3
    if ((functionToggle & functionMask) && bInputButtonPressed(F3_BTN))
    {
        functionActive |= functionMask;
        InputButtonReset(F3_BTN);
    }
    else if (((functionToggle & functionMask) == 0) && bInputButtonPushed(F3_BTN))
    {
        functionActive ^= functionMask;
        InputButtonReset(F3_BTN);
    }
    functionMask = functionMask << 1;



    // Function F4
    if ((functionToggle & functionMask) && bInputButtonPressed(F4_BTN))
    {
        functionActive |= functionMask;
        InputButtonReset(F4_BTN);
    }
    else if (((functionToggle & functionMask) == 0) && bInputButtonPushed(F4_BTN))
    {
        functionActive ^= functionMask;
        InputButtonReset(F4_BTN);
    }


    // Function F0
    if (bInputButtonPushed(FL_BTN) == TRUE)
    {
        if ((bInputButtonPushedLong(FL_BTN) == TRUE)&&(pGL->u8NrFunc > 5)&&
            (pGL->u8FuncGroup == 0))
        {
            // Change the function view!
            pGL->u8FuncGroup = 1;
        }
        else if (pGL->u8FuncGroup == 1)
        {
            if (pGL->u8NrFunc > 9)
            {
                pGL->u8FuncGroup = 2;
            }
            else
            {
                pGL->u8FuncGroup = 0;
            }
        }
        else if (pGL->u8FuncGroup == 2)
        {
            pGL->u8FuncGroup = 0;
        }
        else
        {
            functionActive ^= 0x01;
        }

        InputButtonReset(FL_BTN);
        bChanged = TRUE;
    }

    if (pGL->u32FuncBitField != functionActive)
    {
        pGL->u32FuncBitField = functionActive;
        pGL->u32FuncBitField &= pGL->u32FuncAllocMask;
        bChanged = TRUE;
    }

    return bChanged;
}


static BOOL _bGetGAInput(SRCP_DEVICE * pDev)
{
    BOOL bChanged = FALSE;
    sGA * pGA = (sGA *)(&pDev[1]);

    if (bInputButtonPushedOnce(ENC_BTN) == TRUE)
    {
        // Change the port value of the GA:
        pGA->u8Value = !(pGA->u8Value);
        InputButtonReset(ENC_BTN);
        bChanged = TRUE;
    }
    if (bInputEncoderValueChanged() == TRUE)
    {
        SRCP_PRM prm;
        BYTE i = 0;

        // Switch to another port!
        pGA->u8Port = (BYTE) s16InputEncoderGetValue();
        pDev->eDevState = SRCP_DS_UNKNOWN;
        pDev->sFlags.bNewData = TRUE;
    }

    return bChanged;
}


static void _showServerError(WORD u16Code)
{
    StrTbl_GetString(lcdram_row1, STRTBLID_SERVER_REPORTS);
    sprintf(lcdram_row2, 
            StrTbl_cau8GetStringPointer(STRTBLID_ERRORCODE),
            u16Code);
    lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                 LCD_ROW2_MASK | LCD_CENTER2_MASK;

    OutSwitchOffAllLEDs();
}


static BOOL _bSendSRCPMessage(SRCP_COMMANDS eCommand, SRCP_DEVICE * pDev)
{
    BYTE buf[50];
    BOOL bAddress = FALSE;

    if (pDev==NULL)
    {
        return FALSE;
    }

    // Check for undefined messages and devices.... 
    if ((eCommand==SRCP_CMD_INFO)||(pDev->eDevType==SRCP_DT_NOT_DEFINED))
    {
        return FALSE;
    }

    // Is there already a SRCP message in progress?
    if (_bSrvReqIsInProgress==TRUE)
    {
        return FALSE;
    }

    // Check for a free TCP channel.
    if (!TCPIsPutReady(_sSRCPState.sCommand.u8Socket))
    {
        return FALSE;
    }

    // Step 1: Transfer the message string.
    switch(eCommand)
    {
        case SRCP_CMD_GET:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"GET");
            break;

        case SRCP_CMD_SET:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"SET");
            break;

        case SRCP_CMD_INIT:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"INIT");
            break;

        case SRCP_CMD_TERM:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"TERM");
            break;

        case SRCP_CMD_CHECK:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"CHECK");
            break;

        case SRCP_CMD_WAIT:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"WAIT");
            break;

        case SRCP_CMD_RESET:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"RESET");
            break;
    }


    // Step 2: Transfer the bus number.
    sprintf(buf, (ROM char *) " %hhu ", pDev->u8Bus);
    TCPPutString(_sSRCPState.sCommand.u8Socket, buf);


    // Step 3: Transfer the device type string.
    bAddress = _bDevTypeTCP(pDev->eDevType, eCommand);

    
    // Step 4: Check for the lock device and transfer the device type to lock.
    if (pDev->eDevType == SRCP_DT_LOCK)
    {
        sLock * pLock = (sLock *)(&pDev[1]);
        TCPPut(_sSRCPState.sCommand.u8Socket, ' ');
        bAddress = _bDevTypeTCP(pLock->eDevType, eCommand);
    }


    // Step 5: Transfer the address.
    if (bAddress == TRUE)
    {
        // The address is always located at the same field position regardless
        // of the device type.
        sprintf(buf, (ROM char *) " %lu", _u32GetAddress(pDev));
        TCPPutString(_sSRCPState.sCommand.u8Socket, buf);
    }


    // Step 6: Generate a parameter list (if necessary).
    buf[0] = 0;     // Clear the working buffer. 
    switch(pDev->eDevType)
    {
        case SRCP_DT_GL:
        {
            sGL * pGL = (sGL *)(&pDev[1]);
            if (eCommand==SRCP_CMD_INIT)
            {
                _getInitData(pDev, buf);
            }
            else if ((eCommand==SRCP_CMD_CHECK)||(eCommand==SRCP_CMD_SET))
            {
                DWORD mask = pGL->u32FuncBitField;
                BYTE i = pGL->sGLFlags.u2Dir;
                BYTE bufindex = sprintf(buf, (ROM char *) "%hhu %hu %hu", i, pGL->s16ActV, pGL->u8MaxSteps);
    
                for (i=0; i < pGL->u8NrFunc; i++)
                {
                    if (mask &0x01)
                    {
                        strcpypgm2ram(&buf[bufindex], (ROM char *)" 1");
                    }
                    else
                    {
                        strcpypgm2ram(&buf[bufindex], (ROM char *)" 0");
                    }
                    mask = mask >> 1;
                    bufindex+=2;
                }
            }
            break;
        }

        case SRCP_DT_GA:
        {
            sGA * pGA = (sGA *)(&pDev[1]);
            if (eCommand == SRCP_CMD_INIT)
            {
                _getInitData(pDev, buf);
            }
            else if (eCommand==SRCP_CMD_GET)    
            {
                sprintf(buf, (ROM char *) "%hhu", pGA->u8Port);
            }
            else if ((eCommand==SRCP_CMD_CHECK)||(eCommand==SRCP_CMD_SET))  
            {
                LONG delay = 1;
                if (pGA->u8Value)
                {
                    delay = pGA->s32Delay;
                }

                sprintf(buf, (ROM char *)"%hhu %hhu %ld", pGA->u8Port, pGA->u8Value, delay);
            }
            break;
        }

        case SRCP_DT_POWER:
            if (eCommand == SRCP_CMD_SET)
            {
                sPower * pPwr = (sPower*)(&pDev[1]);
                if (pPwr->bPowerState == TRUE)
                {
                    strcpypgm2ram(buf, (ROM char *)"ON");
                }
                else
                {
                    strcpypgm2ram(buf, (ROM char *)"OFF");
                }
            }
            break;

        case SRCP_DT_LOCK:
            if (eCommand == SRCP_CMD_SET)
            {
                sLock * pLock = (sLock *)(&pDev[1]);
                sprintf(buf, (ROM char *) " %u", pLock->u32Duration);
            }
            break;

        // ToDo:
        // Add the parameter lists for other devices like FB and SM.
    }


    if (strlen(buf))
    {
        TCPPut(_sSRCPState.sCommand.u8Socket, ' ');
        TCPPutString(_sSRCPState.sCommand.u8Socket, buf);
    }



    // Step 7: Complete the transfer with linefeed and flush.
    TCPPut(_sSRCPState.sCommand.u8Socket, '\n');
    TCPFlush(_sSRCPState.sCommand.u8Socket);
    
    // Remember the last sent command (which command from which device)
    _eLastSentCommand = eCommand;
    _pLastCommandDevice = pDev;
    _bSrvReqIsInProgress = TRUE;
    _bServerRequestTime = TickGet() + 2 * TICKS_PER_SECOND;

    return TRUE;
}


static BOOL _bDevTypeTCP(SRCP_DEVTYPE eDevType, SRCP_COMMANDS eCommand)
{
    if (eCommand == SRCP_CMD_GETDESC)
    {
        TCPPutROMString(_sSRCPState.sCommand.u8Socket, 
                        (ROM char *)"DESCRIPTION");
    }

    switch(eDevType)
    {
        case SRCP_DT_GL:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char*)"GL");
            return TRUE;    // Address is needed.

        case SRCP_DT_GA:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"GA");
            return TRUE;    // Address is needed.

        case SRCP_DT_POWER:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"POWER");
            break;

        case SRCP_DT_LOCK:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"LOCK");
            break;

        case SRCP_DT_SM:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"SM");
            if ((eCommand == SRCP_CMD_SET)||
                (eCommand == SRCP_CMD_CHECK)||
                (eCommand == SRCP_CMD_GET)||
                (eCommand == SRCP_CMD_VERIFY))
            {
                return TRUE;    // Address is needed.
            }
            break;

        case SRCP_DT_FB:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"FB");
            if ((eCommand == SRCP_CMD_WAIT)||
                (eCommand == SRCP_CMD_GET))
            {
                return TRUE;    // Address is needed.
            }
            break;

        case SRCP_DT_TIME:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, (ROM char *)"TIME");
            break;

        case SRCP_DT_SERVER:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket,(ROM char *)"SERVER");
            break;

        case SRCP_DT_SESSION:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket,(ROM char*)"SESSION");
            return TRUE;    // Address is needed.

        case SRCP_DT_DESCRIPTION:
            TCPPutROMString(_sSRCPState.sCommand.u8Socket, 
                                                    (ROM char *)"DESCRIPTION");
            break;
    }

    return FALSE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

/*
When calling this function, the caller must ensure that received packet is
definitly for this device! That is not checked here!
This function processes the packet and handles the state transitions caused
due the packet code.
*/
static void _answerReceived(SRCP_DEVICE *pDev, WORD u16Code, SRCP_TIME * pTime)
{
    if ((pDev == NULL) || (pDev->eDevState == SRCP_DS_DISABLED))
    {
        return;
    }


    // If the time of the message is older than the last update than we are 
    // doing nothing.
    if (pDev->sLastUpdate.u32Seconds > pTime->u32Seconds)
    {
        return;
    }

    if ((pDev->sLastUpdate.u32Seconds == pTime->u32Seconds) &&
        (pDev->sLastUpdate.u16Milliseconds > pTime->u16Milliseconds))
    {
        return;
    }

    // Remember the time of this message 
    pDev->sLastUpdate.u32Seconds = pTime->u32Seconds;
    pDev->sLastUpdate.u16Milliseconds = pTime->u16Milliseconds;

    switch(u16Code)
    {
        // 100 (After INIT), 101 
        // This INFO codes has the meaning of an existing device. The server
        // knows the (initialized) device and sends the parameters of this 
        // device. The device state machine is always IDLE than.
        case 100:
        case 101:
            pDev->eDevState = SRCP_DS_IDLE;
            break;

        // 102 (After TERM). The server does not know this device anymore.
        case 102:
            pDev->eDevState = SRCP_DS_DISABLED;
            break;

        // 200 (After any successful executed command). 
        case 200:
            // If it is OK to a TERM command, than the device is in an 
            // uninitialized state.
            if(_eLastSentCommand == SRCP_CMD_TERM)
            {
                pDev->eDevState = SRCP_DS_DISABLED;
            }
            // If it is OK to a INIT command, than the device is in the 
            // idle (initialized) state.
            else if(_eLastSentCommand == SRCP_CMD_INIT)
            {
                pDev->sFlags.bNewData = TRUE;   // To ensure that the view is refreshed.
                pDev->eDevState = SRCP_DS_IDLE;
            }
            break;

        case 416:
            // ERROR no data
            // no information at all is available.
            if (_eLastSentCommand == SRCP_CMD_GET)
            {
                pDev->eDevState = SRCP_DS_NOT_DEFINED;
                break;
            }

        default:
            // Action:
            // Store this error in the structure.
            pDev->u16LastErrorCode = u16Code;
            pDev->eDevState = SRCP_DS_DISABLED;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _deviceSM(SRCP_DEVICE * pDev)
{
    // This state machine includes no state transitions.
    // All the actions are done state related.
    // Precondition for calling this function: The command socket must be free!

    if (pDev == NULL)
    {
        return;
    }

    switch(pDev->eDevState)
    {
    case SRCP_DS_UNKNOWN:
        _bSendSRCPMessage(SRCP_CMD_GET, pDev);
        // The answer to this message results in a state change processed by
        // the function _answerReceived.
        break;

    case SRCP_DS_NOT_DEFINED:
        // Synchronized with server, the server does not know anything about
        // this device... Try to initialize the device.
        if (_bIsInitAllowed(pDev->eDevType)&&(pDev->u16LastErrorCode==0))
        {
            _bSendSRCPMessage(SRCP_CMD_INIT, pDev);
        }
        break;

    case SRCP_DS_IDLE:
        // Add some generic idle handler code here.
        break;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _updateData(SRCP_DEVICE * pDev, WORD u16Code, SRCP_PRM * pNewPrm)
{
    BYTE size;

    if (pDev == NULL)
    {
        return;
    }

    // Only INFO (GET replies) messages will be checked here.
    if (u16Code != 100)
    {
        return;
    }

    switch(pDev->eDevType)
    {
    case SRCP_DT_GL:
    {
        sGL * pGL = (sGL *)(&pDev[1]); 
        DWORD mask;
        DWORD funcmask;

        // Speed handling...

        // Set the local maximum speed step to that from server.
        pGL->u8MaxSteps = pNewPrm->uStat.sGL.s16MaxV;

        // The element 's16ServerV' is always consistent with the server.
        pGL->s16ServerV = pNewPrm->uDyn.sGL.s16ActV;
        
        if (IsEncoderTurning() == FALSE)
        {
            pGL->s16ActV = pGL->s16ServerV;
        }

        if (pGL->sGLFlags.u2Dir != (pNewPrm->uDyn.sGL.u8Dir & 0x03))
        {
            pGL->sGLFlags.u2Dir = pNewPrm->uDyn.sGL.u8Dir & 0x03;
        }

        mask = pGL->u32FuncAllocMask & pNewPrm->uStat.sGL.u32FuncAllocMask;

        funcmask=mask&(pGL->u32FuncBitField^pNewPrm->uDyn.sGL.u32FuncBitField);

        if (mask & (pGL->u32FuncBitField ^ pNewPrm->uDyn.sGL.u32FuncBitField))
        {
            pGL->u32FuncBitField &= ~mask;
            pGL->u32FuncBitField |= mask & pNewPrm->uDyn.sGL.u32FuncBitField;
        }
        
        pDev->sFlags.bNewData = TRUE;

        break;
    }

    case SRCP_DT_GA:
        {
            sGA * pGA = (sGA *)(&pDev[1]); 
            if (pGA->u8Value != pNewPrm->uDyn.sGA.u8Value)
            {
                pDev->sFlags.bNewData = TRUE;
                pGA->u8Value = pNewPrm->uDyn.sGA.u8Value;
            }
            break;
        }
    case SRCP_DT_POWER:
        {
            sPower * pPwr = (sPower *)(&pDev[1]);
            if (pPwr->bPowerState != pNewPrm->uDyn.bPowerState)
            {
                pDev->sFlags.bNewData = TRUE;
                pPwr->bPowerState = pNewPrm->uDyn.bPowerState;
            }
            break;
        }
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bIsDeviceMatching(SRCP_DEVICE * psDevice, SRCP_PRM * pPrm)
{
    BYTE size;
    void * pSrcPrm;

    if ((psDevice == NULL) || (pPrm == NULL))
    {
        return FALSE;
    }

    if (psDevice->eDevType != pPrm->eDevType)
    {
        return FALSE;
    }

    if (psDevice->u8Bus != pPrm->u8Bus)
    {
        return FALSE;
    }

    if (psDevice->eDevState == SRCP_DS_DISABLED)
    {
        return FALSE;
    }

    // Check the device dependent parameters.
    if (pPrm->eDevType == SRCP_DT_POWER)
    {
        return TRUE;
    }

    pSrcPrm = (void *)(&psDevice[1]); 

    switch(pPrm->eDevType)
    {
    case SRCP_DT_LOCK:
        {
            sLock * pLockSrc = (sLock *)pSrcPrm;

            if (pPrm->uStat.sLock.eDevType != pLockSrc->eDevType)
            {
                return FALSE;
            }

            if (pPrm->uStat.sLock.u32Addr != pLockSrc->u32Addr)
            {
                return FALSE;
            }
        }
        break;

    case SRCP_DT_GA:
        {
            sGA * pGASrc = (sGA *)pSrcPrm;

            if (pPrm->uStat.sGA.u8Port != pGASrc->u8Port)
            {
                return FALSE;
            }

            if (pPrm->uStat.sGA.u32Addr != pGASrc->u32Addr)
            {
                return FALSE;
            }
        }
        break;

    case SRCP_DT_GL:
        {
            sGL * pGLSrc = (sGL *)pSrcPrm;

            if (pPrm->uStat.sGL.u32Addr != pGLSrc->u32Addr)
            {
                return FALSE;
            }
        }
        break;
    }

    return TRUE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static SRCP_DEVICE * _pGetPowerDevice(BYTE u8Bus)
{
    BYTE i;
    for (i = 0; i < MAX_SRCP_DEVICES; i++)
    {
        if (_apsDevices[i] && (u8Bus == _apsDevices[i]->u8Bus) &&
            (SRCP_DT_POWER == _apsDevices[i]->eDevType))
        {
            return _apsDevices[i];
        }
    }
    
    // Not found!
    return NULL;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

#define FREQUENT_SRCP_DEVICE_OFFSET     2

static SRCP_DEVICE* _psAddDevice(SRCP_DEVTYPE eDevType, BYTE u8Bus, void* pPrm)
{
    BYTE i, j;
    DWORD checkAddress = 0;

    if(pPrm == NULL)
    {
        return NULL;
    }

    _refreshDeviceList();

    if ((eDevType == SRCP_DT_GL)||(eDevType == SRCP_DT_GA)||(eDevType == SRCP_DT_LOCK))
    {
        checkAddress = *((DWORD *)(pPrm));
    }


    // Step 1: Check if the device is already in the list!
    for (i = FREQUENT_SRCP_DEVICE_OFFSET; i < MAX_SRCP_DEVICES; i++)
    {
        if (_apsDevices[i] == NULL)
        {
            // Empty device slot found, after refreshing the list it is the
            // last one!
            break;
        }
        if (_apsDevices[i]->u8Bus != u8Bus)
        {
            continue;
        }
        if (_apsDevices[i]->eDevType != eDevType)
        {
            continue;
        }
        if (_u32GetAddress(_apsDevices[i]) != checkAddress)
        {
            continue;
        }

        // Device found! 
        // Younger this device to prevent removing from device
        // list. Update the stack positions of all other devices.

        if (i>FREQUENT_SRCP_DEVICE_OFFSET)
        {
            // Temporary store the pointer:
            SRCP_DEVICE * pDev = _apsDevices[i];

            // Older all devices which were before the found device.
            for (j = i; j > FREQUENT_SRCP_DEVICE_OFFSET; j--)
            {
                _apsDevices[j] = _apsDevices[j-1];
            }

            _apsDevices[j] = pDev;
        }   
        
        return _apsDevices[j];
    }


    // Step 2: Free the oldest device in list.
    if (_apsDevices[MAX_SRCP_DEVICES-1])
    {
        SRAMfree((BYTE *)_apsDevices[MAX_SRCP_DEVICES-1]);
        _apsDevices[MAX_SRCP_DEVICES-1] = NULL;
    }


    // Step 3: Older all devices which were before the found device.
    for (j = (MAX_SRCP_DEVICES-1); j > FREQUENT_SRCP_DEVICE_OFFSET; j--)
    {
        _apsDevices[j] = _apsDevices[j-1];
    }

    
    // Step 4: Get a new device structure.
    _apsDevices[j] = _psInitializeNewDevice(eDevType, u8Bus, pPrm);

    return _apsDevices[j];
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _startParsing(BYTE u8Socket, SRCP_TIME * psTime, WORD * pu16Code)
{
    BYTE wb[16];
    BOOL end = FALSE;

    if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
    {
        // Get the time...
        char * pDot = strrchr(wb, '.');
        if (pDot)
        {
            *pDot++ = 0;
            psTime->u32Seconds = (DWORD) atol(wb);
            psTime->u16Milliseconds = (WORD) atoi(pDot);
        }
        else
        {
            goto _startParsingError;
        }
    }
    else
    {
        goto _startParsingError;
    }

    if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
    {
        *pu16Code = atoi(wb);
        if (*pu16Code == 110)
        {
            *pu16Code = 100;
        }
    }
    else
    {
        goto _startParsingError;
    }

    // Throw away the message classification string. We just use the code
    // for checking the device states.
    if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
    {
        return TRUE;
    }


_startParsingError:
    if (end==FALSE)
    {
        // The end of line was not found. Look for the line end (or the frame 
        // end) in the remaining frame data. Maybe other lines will follow up.
        _bLookForEnd(u8Socket);
    }
    return FALSE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bParseLine(BYTE u8Socket, WORD u16Code, SRCP_PRM * pPrm)
{
    BYTE wb[16];
    BOOL end = FALSE;
    BOOL valid = FALSE;
    BOOL address = FALSE;
    memset(pPrm, 0, sizeof(SRCP_PRM));

    // Only INFO messages store device related data.
    if (u16Code >= 200)
    {
        goto _parseForLineEnd;
    }


    // Step 1: Fetch the bus number from the received message.
    if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
    {
        pPrm->u8Bus = (BYTE) atoi(wb);
    }
    else
    {
        goto _parseForLineEnd;
    }


    // Step 2: Fetch the device type string from the received message.
    if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end)==FALSE)
    {
        goto _parseForLineEnd;
    }

    address = _bTCPDevType(u16Code, &pPrm->eDevType, wb);

    if (pPrm->eDevType == SRCP_DT_NOT_DEFINED)
    {
        goto _parseForLineEnd;
    }


    // Step 3: Get the device if locked.
    if (pPrm->eDevType == SRCP_DT_LOCK)
    {
        if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end)==FALSE)
        {
            goto _parseForLineEnd;
        }

        address = _bTCPDevType(u16Code, &pPrm->uStat.sLock.eDevType, wb);
    
        if (pPrm->eDevType == SRCP_DT_NOT_DEFINED)
        {
            goto _parseForLineEnd;
        }
    }


    // Step 4: Parse for the address.
    if (address==TRUE)
    {
        if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end)==FALSE)
        {
            goto _parseForLineEnd;
        }

        // All address parameters are at the same field position.
        pPrm->uStat.sGL.u32Addr = (DWORD) atol(wb);
    }


    // Step 5: Fetch the device type specific static and dynamic data from the
    // received message.
    if (u16Code == 101)
    {
        // Device is initialized! Maybe its worth parsing the line for our 
        // server cache.
        if (pPrm->eDevType != SRCP_DT_GL)
        {
            // Only GL devices are currently stored in the cache.
            valid = TRUE;
            goto _parseForLineEnd;  
        }
        
        // Get the protocol specifier:
        if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
        {
            // Only M and N protocols are supported at the moment.
            if ((wb[0] != 'N') && (wb[0] != 'M'))
            {
                goto _parseForLineEnd;
            }

            pPrm->uStat.sGL.au8Proto[0] = wb[0];
            pPrm->uStat.sGL.au8Proto[1] = ' ';
        }

        // Get the protocol version:
        if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
        {
            // Protocol version is not checked here!
            pPrm->uStat.sGL.au8Proto[2] = wb[0];
        }

        // Get the number of decoder speed steps:
        if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
        {
            pPrm->uStat.sGL.u8MaxSteps = atob(wb);
        }

        // Get the number of decoder functions:
        if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
        {
            pPrm->uStat.sGL.u8NrFunc = atob(wb);
        }
    }
    
    if (u16Code != 100)
    {
        valid = TRUE;
        goto _parseForLineEnd;
    }


    switch(pPrm->eDevType)
    {
        case SRCP_DT_GL:
        {
            DWORD mask = 0x01;
            BYTE i;
    
            // Get the drive mode.
            if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
            {
                pPrm->uDyn.sGL.u8Dir = atob(wb);
            }

            // Get the actual speed.
            if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
            {
                pPrm->uDyn.sGL.s16ActV = atoi(wb);
            }
    
            // Get the maximum speed.
            if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
            {
                pPrm->uStat.sGL.s16MaxV = atoi(wb);
            }
    
            // Get the function values.
            for (i = 0; i < MAX_SRCP_FUNCTIONS; i++, mask=mask<<1)
            {
                if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
                {
                    if (wb[0] == '=')
                    {
                        continue;
                    }
                    if (wb[0] == '1')
                    {
                        pPrm->uDyn.sGL.u32FuncBitField |= mask;
                    }
                    pPrm->uStat.sGL.u32FuncAllocMask |= mask;
                }
                else
                {
                    break;
                }
            }
            break;
        }

        case SRCP_DT_GA:
            if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
                pPrm->uStat.sGA.u8Port = atob(wb);

            if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end))
                pPrm->uDyn.sGA.u8Value = atob(wb);
            break;
    
        case SRCP_DT_POWER:
            if (_bGetNextWord(u8Socket, wb, sizeof(wb), &end)==FALSE)
                goto _parseForLineEnd;

            if (strncmppgm2ram(wb,(ROM char *)"ON",sizeof(wb)-1)==0)
                pPrm->uDyn.bPowerState = TRUE;
            else
                pPrm->uDyn.bPowerState = FALSE;
            break;
    }

    valid = TRUE;
    
_parseForLineEnd:
    if (end==FALSE)
    {
        // The end of line was not found. Look for the line end (or the frame 
        // end) in the remaining frame data.
        _bLookForEnd(u8Socket);
    }
    return valid;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bTCPDevType(WORD u16Code, SRCP_DEVTYPE * pDev, BYTE * au8Buf)
{
    if (strcmppgm2ram(au8Buf,(ROM char *)"FB")==0)
    {
        *pDev = SRCP_DT_FB;
        if (u16Code==100)
            return TRUE;
    }
    else if (strcmppgm2ram(au8Buf,(ROM char *)"GA")==0) 
    {
        *pDev = SRCP_DT_GA;
        return TRUE;
    }
    if (strcmppgm2ram(au8Buf, (ROM char *) "GL")== 0)
    {
        *pDev = SRCP_DT_GL;
        return TRUE;
    }
    else if (strcmppgm2ram(au8Buf,(ROM char *)"SM")==0)
    {
        *pDev = SRCP_DT_SM;
        if (u16Code==100)
            return TRUE;
    }
    else if (strcmppgm2ram(au8Buf,(ROM char *)"LOCK")==0)
        *pDev = SRCP_DT_LOCK;
    else if (strcmppgm2ram(au8Buf,(ROM char *)"POWER")==0)
        *pDev = SRCP_DT_POWER;
    else if (strcmppgm2ram(au8Buf,(ROM char *)"SESSION")==0)
    {
        *pDev = SRCP_DT_SESSION;
        return TRUE;
    }
    else if (strcmppgm2ram(au8Buf,(ROM char *)"DESCRIPTION")==0)
        *pDev = SRCP_DT_DESCRIPTION;
    else if (strcmppgm2ram(au8Buf,(ROM char *)"TIME")==0)
        *pDev = SRCP_DT_TIME;
    else if (strcmppgm2ram(au8Buf,(ROM char *)"SERVER")==0)
        *pDev = SRCP_DT_SERVER;

    return FALSE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _getProtoName(BYTE u8ProtoId, BYTE * pString)
{
    // Get data from EEPROM!
    SPPROTOCOL conf;
    _getProtoFromEEPROM(u8ProtoId, &conf);
    strncpy(pString, conf.au8Desc, SRCP_NAME_MAXLEN);
    conf.au8Desc[SRCP_NAME_MAXLEN] = 0;
    OutConvertNameForDisplay(pString);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BYTE _u8GenerateActiveProtoList(BOOL bGL, BYTE u8Default)
{
    BYTE i = 0;
    BYTE protostart, protomax;
    BYTE count = 0;
    SPPROTOCOL conf;


    // Step 1: Get the device dependent margins for protocol.
    if (bGL == TRUE)
    {
        protostart = 0;
        protomax = MAX_PROTO_SLOTS;
    }
    else
    {
        protostart = MAX_PROTO_SLOTS;
        protomax = MAX_PROTO_SLOTS * 2;
    }


    // Step 2: Looking for the default protocol and add it to the list. 
    if ((bGL == TRUE) && (u8Default == SRCP_SERVERCACHE_ID))
    {
        _au8ActiveProtos[count++] = SRCP_SERVERCACHE_ID;
    }
    else if (u8Default == SRCP_EEPROMSET_ID)
    {
        _au8ActiveProtos[count++] = SRCP_EEPROMSET_ID;
    }
    else
    {
        // Get data from EEPROM!
        _getProtoFromEEPROM(u8Default, &conf);
        if (conf.sFlags.bActive == TRUE)
        {
            _au8ActiveProtos[count++] = u8Default;
        }
    }


    if (u8Default != SRCP_EEPROMSET_ID)
    {
        _au8ActiveProtos[count++] = SRCP_EEPROMSET_ID;
    }

    if ((bGL==TRUE)&&(u8Default != SRCP_SERVERCACHE_ID))
    {
        _au8ActiveProtos[count++] = SRCP_SERVERCACHE_ID;
    }


    for (i = protostart; i < protomax; i++)
    {
        if (u8Default == i)
        {
            // The default protocol is already in the list. 
            continue;
        }

        // Get data from EEPROM!
        _getProtoFromEEPROM(i, &conf);

        if (conf.sFlags.bActive == TRUE)
        {
            _au8ActiveProtos[count++] = i;
        }
    }

    return count;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _getProtoMinMax(BYTE u8ProtoId, WORD* pu16MinAdd, WORD* pu16MaxAdd)
{
    // Get data from EEPROM!
    SPPROTOCOL conf;
    _getProtoFromEEPROM(u8ProtoId, &conf);
    *pu16MinAdd = conf.u16MinAdd;
    *pu16MaxAdd = conf.u16MaxAdd;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bGetStaticParameterFromCache(BYTE u8CacheId, sStaticDeviceData * psPrm)
{
    if (_apsSelectCache == NULL)
    {
        PrintCommonError(COMMON_ERROR_NULL_POINTER);
        return FALSE;
    }

    memset((void*)psPrm, 0, sizeof(sStaticDeviceData));


    // Copy proto data.
    strncpy(psPrm->au8Proto, _apsSelectCache[u8CacheId].au8Proto, SRCP_PROTO_MAXLEN);
    psPrm->u8BusNr = _apsSelectCache[u8CacheId].u8BusNr;
    psPrm->u32Address = _apsSelectCache[u8CacheId].u32Address;
    psPrm->uSpec.sGLSpec.u8MaxSteps = _apsSelectCache[u8CacheId].u8MaxSteps;
    psPrm->uSpec.sGLSpec.u8NrFunc = _apsSelectCache[u8CacheId].u8NrFunc;

    return TRUE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _destructServerCache(void)
{
    if (_apsSelectCache)
    {
        SRAMfree((BYTE*)_apsSelectCache);
        _apsSelectCache = NULL;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bGetStaticParameterFromProto(BYTE u8ProtoId, sStaticDeviceData * psPrm)
{
    SPPROTOCOL conf;

    // Get data from EEPROM!
    _getProtoFromEEPROM(u8ProtoId, &conf);

    if ((conf.sFlags.bActive == FALSE)||(psPrm == NULL))
    {
        PrintCommonError(COMMON_ERROR_LOADING_SRCP_PROTOCOL);
        return FALSE;
    }

    memset((void*)psPrm, 0, sizeof(sStaticDeviceData));

    // Copy proto data.
    strncpy(psPrm->au8Proto, conf.au8Proto, SRCP_PROTO_MAXLEN);
    psPrm->u8BusNr = conf.u8Bus;

    if (conf.sFlags.bGL == TRUE)
    {
        psPrm->uSpec.sGLSpec.u8MaxSteps = conf.uSpec.sGL.u8MaxSteps;
        psPrm->uSpec.sGLSpec.u8NrFunc = conf.uSpec.sGL.u8NrFunc;
    }
    else
    {
        psPrm->uSpec.sGASpec.u8MinP = conf.uSpec.sGA.u8MinP;
        psPrm->uSpec.sGASpec.u8MaxP = conf.uSpec.sGA.u8MaxP;
    }

    return TRUE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _fillPrmGL(sGL * psNewGL, sStaticDeviceData * psStaticData)
{
    if ((psNewGL == NULL) || (psStaticData == NULL))
    {
        return;
    }

    memset(psNewGL, 0, sizeof(sGL));

    // Copy the proto data into the device structure:
    strncpy(psNewGL->au8Proto, psStaticData->au8Proto, SRCP_PROTO_MAXLEN);
    strncpy(psNewGL->au8Name, psStaticData->au8Name, SRCP_NAME_MAXLEN);
    psNewGL->u32Addr = psStaticData->u32Address;
    psNewGL->u8MaxSteps = psStaticData->uSpec.sGLSpec.u8MaxSteps;
    psNewGL->u8NrFunc = psStaticData->uSpec.sGLSpec.u8NrFunc;
    psNewGL->s16MaxV = psStaticData->uSpec.sGLSpec.u16MaxV;

    // Prepare other stuff like function mask and so on.
    {
        BYTE i = 0;
        DWORD mask = 0x01;

        for (i = 0; i < MAX_SRCP_FUNCTIONS, i < psNewGL->u8NrFunc; i++, mask=mask<<1)
        {
            psNewGL->u32FuncAllocMask |= mask;
        }

        psNewGL->u32FuncToggleMask = psStaticData->uSpec.sGLSpec.u32FunctionToggleMask;
    }
    
    if (psNewGL->s16MaxV == 0)
    {
        psNewGL->s16MaxV = psNewGL->u8MaxSteps;
    }
    else
    {
        // Show a unit if a maximum speed is configured.
        psNewGL->sGLFlags.bUnit = TRUE;
    }

    psNewGL->sGLFlags.u2Dir = DIR_FORWARD;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _fillPrmGA(sGA * psNewGA, sStaticDeviceData * psStaticData)
{
    if ((psNewGA == NULL) || (psStaticData == NULL))
    {
        return;
    }

    memset(psNewGA, 0, sizeof(sGA));

    // Copy the proto data into the device structure:
    strncpy(psNewGA->au8Name, psStaticData->au8Name, SRCP_NAME_MAXLEN);
    strncpy(psNewGA->au8Proto, psStaticData->au8Proto, SRCP_PROTO_MAXLEN);
    psNewGA->u32Addr = psStaticData->u32Address;
    psNewGA->u8MinPort = psStaticData->uSpec.sGASpec.u8MinP;
    psNewGA->u8MaxPort = psStaticData->uSpec.sGASpec.u8MaxP;

    if (psStaticData->uSpec.sGASpec.s32Delay == 0)
    {
        psNewGA->s32Delay = sPSRCPConfig.s32GADelay;
    }
    else
    {
        psNewGA->s32Delay = psStaticData->uSpec.sGASpec.s32Delay;
    }

    psNewGA->u8Port = psNewGA->u8MinPort;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _getInitData(SRCP_DEVICE * pDev, char * pString)
{
    if (pDev == NULL)
    {
        pString[0] = 0;
        return;
    }

    if (pDev->eDevType == SRCP_DT_GA)
    {
        sGA * pGA = (sGA *)(&pDev[1]);
        strcpy(pString, pGA->au8Proto);
    }
    else if (pDev->eDevType == SRCP_DT_GL)
    {
        sGL * pGL = (sGL *)(&pDev[1]);
        strcpy(pString, pGL->au8Proto);

        if (strrchr(pString,'M') || strrchr(pString,'N'))
        {
            // Add parameters (max speed steps and number of functions) to the 
            // initialization string if it is a NMRA or Motorola Decoder like 
            // described in the SRCP Spec.      
            sprintf(&pString[strlen(pString)],(ROM char *)" %hhu %hhu", pGL->u8MaxSteps, pGL->u8NrFunc);
        }
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void _startHandShake(void)
{
    _eHSState = SRCP_HS_WAIT_FOR_WELCOME;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

SRCP_HANDSHAKE_RETCODE _eHandShake(SSRCPSOCKET * hSRCP)
{
    BYTE socket = hSRCP->u8Socket;
    WORD code = 0;
    SRCP_TIME time;

    switch (_eHSState)
    {
    case SRCP_HS_WAIT_FOR_WELCOME:

        // For the welcome message we can not use the SRCP parse functions 
        // because the message format is completly different.

        if (TCPIsGetReady(socket))
        {
            // received a frame...
            BYTE buf[11];
            BOOL end = FALSE;
            BOOL valid = FALSE;

            // We still wait for the welcome message with the supported 
            // SRCP versions of the server.
            while (_bGetNextWord(socket,buf,sizeof(buf),&end))
            {
                // Looking for the keyword SRCP or SRCPOTHER. The value of 
                // this key (the following SRCP word) is the supported 
                // version.
                if ((strncmppgm2ram(buf, (ROM char *) "SRCP", 10)==0)||
                    (strncmppgm2ram(buf, (ROM char *) "SRCPOTHER", 10)==0))
                {
                    if(_bGetNextWord(socket,buf,10,&end)==FALSE)
                    {
                        break;
                    }

                    // eWicht only supports SRCP version 0.8 at this 
                    // time. Add more code here for other versions.
                    if (strncmppgm2ram(buf,(ROM char *)"0.8",3)==0)
                    {
                        valid = TRUE;   
                        break;              
                    }   
                }
            }
    
            if (valid == TRUE)
            {
                // eWicht supports this server version, got to the next
                // state.
                _eHSState = SRCP_HS_SET_VERSION;
            }
            else
            {
                // Unsupported SCRP version, close this session.
                StrTbl_GetString(lcdram_row1, STRTBLID_SERVERVERSION);
                StrTbl_GetString(lcdram_row2, STRTBLID_UNKNOWN);
                lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                             LCD_ROW2_MASK | LCD_CENTER2_MASK;
                _eHSState = SRCP_HS_ERROR;
            }

            TCPDiscard(socket);
        }
        break;

    case SRCP_HS_SET_VERSION:
        if (TCPIsPutReady(socket))
        {
            // Send the SRCP version to server. As we have seen in the welcome
            // message, the server supports it, but we explicitly send the set
            // message to prevent errors.
            TCPPutROMString(socket, (ROM char *) "SET PROTOCOL SRCP 0.8\n");
            TCPFlush(socket);

            _eHSState = SRCP_HS_WAIT_VERSION;
        }
        break;

    case SRCP_HS_SET_MODE:
        if (TCPIsPutReady(socket))
        {
            // Send the SRCP connection mode to server. 
            // It depends on the socket given to this function.

            TCPPutROMString(socket, (ROM char*) "SET CONNECTIONMODE SRCP ");
            if (hSRCP->bCommand == TRUE)
                TCPPutROMString(socket, (ROM char*) "COMMAND\n");
            else
                TCPPutROMString(socket, (ROM char*) "INFO\n");          
            TCPFlush(socket);

            _eHSState = SRCP_HS_WAIT_MODE;
        }
        break;

    case SRCP_HS_GO:
        if (TCPIsPutReady(hSRCP->u8Socket))
        {
            TCPPutROMString(hSRCP->u8Socket, (ROM char *) "GO\n");
            TCPFlush(hSRCP->u8Socket);

            _eHSState = SRCP_HS_WAIT_GO;
        }
        break;

    case SRCP_HS_WAIT_VERSION:
    case SRCP_HS_WAIT_MODE:
    case SRCP_HS_WAIT_GO:
    {
        BOOL ret;
        if (TCPIsGetReady(socket)==0)
            break;

        // received a frame...
        ret = _startParsing(socket, &time, &code);
        TCPDiscard(socket);
        if (ret==FALSE)
            break;

        switch(code)
        {
            case 200:
                _eHSState = SRCP_HS_GOING;          
                break;
            
            case 201:
                _eHSState = SRCP_HS_SET_MODE;
                break;

            case 202:
                _eHSState = SRCP_HS_GO;
                break;

            case 400:
                // Oops! The server says in its welcome message, that
                // he supports this SRCP version but than the server 
                // NAKs the explicitly version set?! Sounds like an 
                // implementation error in the server...
                StrTbl_GetString(lcdram_row1, STRTBLID_SRVVERSION);
                StrTbl_GetString(lcdram_row2, STRTBLID_UNKNOWN);
                lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                             LCD_ROW2_MASK | LCD_CENTER2_MASK;
                _eHSState = SRCP_HS_ERROR;
                break;

            case 401:
                StrTbl_GetString(lcdram_row1, STRTBLID_SRVMODE);
                StrTbl_GetString(lcdram_row2, STRTBLID_UNKNOWN);
                lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                             LCD_ROW2_MASK | LCD_CENTER2_MASK;
                _eHSState = SRCP_HS_ERROR;
                break;

            case 402:
                StrTbl_GetString(lcdram_row1, STRTBLID_SRVUNSUFFICIENT_DATA1);
                StrTbl_GetString(lcdram_row2, STRTBLID_SRVUNSUFFICIENT_DATA2);
                lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                             LCD_ROW2_MASK | LCD_CENTER2_MASK;
                _eHSState = SRCP_HS_ERROR;
                break;

            case 403:
                StrTbl_GetString(lcdram_row1, STRTBLID_SRVUNKNOWN_COMMAND1);
                StrTbl_GetString(lcdram_row2, STRTBLID_SRVUNKNOWN_COMMAND2);
                lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                             LCD_ROW2_MASK | LCD_CENTER2_MASK;
                _eHSState = SRCP_HS_ERROR;
                break;

            case 500:
                StrTbl_GetString(lcdram_row1, STRTBLID_SRVNO_RESSOURCES1);
                StrTbl_GetString(lcdram_row2, STRTBLID_SRVNO_RESSOURCES2);
                lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                             LCD_ROW2_MASK | LCD_CENTER2_MASK;
                _eHSState = SRCP_HS_ERROR;
                break;
        }
        break;
    }

    case SRCP_HS_ERROR:
        return SRCP_HR_ERROR;
    
    case SRCP_HS_GOING:
        return SRCP_HR_FINISHED;
    }

    return SRCP_HR_IN_PROGRESS;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bIsInitAllowed(SRCP_DEVTYPE eDevType)
{
    if ((eDevType==SRCP_DT_SESSION)||
        (eDevType==SRCP_DT_SERVER)||
        (eDevType==SRCP_DT_DESCRIPTION)||
        (eDevType==SRCP_DT_LOCK))
    {
        return FALSE;
    }

    return TRUE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _updateInput(SRCP_DEVICE * pDev)
{
    // Is there a configured device for input?
    if (pDev == NULL)
    {
        return;     // No!
    }

    if (pDev->eDevState == SRCP_DS_DISABLED)
    {
        return;
    }

    // Is a server request already running?
    if (_bSrvReqIsInProgress == TRUE)
    {
        return;
    }

    if (pDev->eDevType == SRCP_DT_GL)
    {
        sGL tmp;
        sGL * pGL = (sGL *)(&pDev[1]);

        // Temporary save the server consistent data.
        memcpy((void*)&tmp, (void*)pGL, sizeof(sGL));

        if (_bGetGLInput(pGL) == TRUE)
        {
            tmp.s16ActV = pGL->s16ActV;
            tmp.u8FuncGroup = pGL->u8FuncGroup;

            _bSendSRCPMessage(SRCP_CMD_SET, pDev);

            // Restore the old data to stay consistent with the server.
            // The recently sent data will processed by the server and comes
            // back via an INFO message.
            memcpy((void*)pGL, (void*)&tmp, sizeof(sGL));
        }
    }
    else if (pDev->eDevType == SRCP_DT_GA)
    {
        sGA tmp;
        sGA * pGA = (sGA *)(&pDev[1]);

        // Temporary save the server consistent data.
        memcpy((void*)&tmp, (void*)pGA, sizeof(sGA));

        if (_bGetGAInput(pDev) == TRUE)
        {
            _bSendSRCPMessage(SRCP_CMD_SET, pDev);

            // Restore the old data to stay consistent with the server.
            // The recently sent data will processed by the server and comes
            // back via an INFO message.
            memcpy((void*)pGA, (void*)&tmp, sizeof(sGA));
        }
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _updateView(SRCP_DEVICE * pDev)
{
    // Is there a configured device for view?
    if (pDev == NULL)
    {
        return;     // No!
    }

    if (pDev->eDevState == SRCP_DS_DISABLED)
    {
        // The device is not idle anymore. That means, that the server or
        // another client has terminated the device.
        StrTbl_GetString(lcdram_row1, STRTBLID_SERVER_HAS);
        StrTbl_GetString(lcdram_row2, STRTBLID_DEVICE_TERMINATED);
        lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                     LCD_ROW2_MASK | LCD_CENTER2_MASK;

        // Set the device state to disabled.
        pDev->eDevState = SRCP_DS_DISABLED;
    }
    
    if (pDev->u16LastErrorCode)
    {
        _showServerError(pDev->u16LastErrorCode);
        pDev->u16LastErrorCode = 0;     // Acknowledge the error.
        _eSRCPsm = SRCP_ERROR;
        pDev->eDevState = SRCP_DS_DISABLED;
    }


    // New data for the view!
    if (pDev->sFlags.bNewData == TRUE)
    {
        switch(pDev->eDevType)
        {
            case SRCP_DT_GL:
                _displayGLData(pDev);
                break;
    
            case SRCP_DT_GA:
                _displayGAData(pDev);
                break;
    
            case SRCP_DT_POWER:
                _displayPower(pDev);
                break;
        }

        pDev->sFlags.bNewData = FALSE;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BYTE _u8AddEntryToEEPROM(BYTE u8RawQuickIdx, SRCP_DEVICE * pDevice)
{
    SPSET eepromSet;
    BYTE idx = u8RawQuickIdx & SRCP_EEPROMSET_IDX_MASK;
    DWORD newAdd = 0;

    if (pDevice == NULL)
    {
        return 0xFF;
    }   

    // Step 1: Load the quick setting from eeprom:
    if (pDevice->eDevType == SRCP_DT_GA)
    {
        idx |= SRCP_EEPROMSET_GA_MASK;
    }

    XEEReadArray(SRCP_SETS_EEPROM_ADD+(sizeof(SPSET) * idx), (BYTE *)&eepromSet, sizeof(SPSET));


    // Step 2: Check the device type and write new settings to quick structure.
    if (pDevice->eDevType == SRCP_DT_GA)
    {
        sGA * pGA = (sGA *)(&pDevice[1]);
        eepromSet.uSpec.sGA.u8MinP = pGA->u8MinPort;
        eepromSet.uSpec.sGA.u8MaxP = pGA->u8MaxPort;
    }
    else if (pDevice->eDevType == SRCP_DT_GL)
    {
        sGL * pGL = (sGL *)(&pDevice[1]);
        eepromSet.uSpec.sGL.u8MaxSteps = pGL->u8MaxSteps;
        eepromSet.uSpec.sGL.u8NrFunc = pGL->u8NrFunc;
    }
    else
    {
        // This device type is not supported for quick set.
        return 0xFF;
    }
    
    newAdd = _u32GetAddress(pDevice);
    strncpy(eepromSet.au8Proto, DEVICE_PROTO_PTR(pDevice), SRCP_PROTO_MAXLEN);
    eepromSet.au8Proto[SRCP_PROTO_MAXLEN] = 0;

    // Step 3: Compare current settings with new settings:
    if ((eepromSet.u32Address!=newAdd) || (eepromSet.u8BusNr!=pDevice->u8Bus))
    {
        // This is a completly new entry!
        // Default string "SX"
        eepromSet.au8Name[0] = 'S';
        eepromSet.au8Name[1] = '1' + u8RawQuickIdx;
        eepromSet.au8Name[2] = 0;
    }

    // Step 4: Write new settings to EEPROM:
    eepromSet.u32Address = newAdd;
    eepromSet.u8BusNr = pDevice->u8Bus;
    eepromSet.sFlags.bActive = TRUE;

    XEEWriteArray(SRCP_SETS_EEPROM_ADD+(sizeof(SPSET) * idx), (BYTE *)&eepromSet, sizeof(SPSET));


    // Step 5: Copy the EEPROM set name to the device
    {
        BYTE * pName = DEVICE_NAME_PTR(pDevice);
        strncpy(pName, eepromSet.au8Name, SRCP_NAME_MAXLEN);
        pName[SRCP_NAME_MAXLEN] = 0;
    }

    // Return the stored EEPROM set index:
    return idx;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bCheckForSelectedSet(sStaticDeviceData* psDeviceData, BOOL bEncoder)
{
    SPSET set;
    BYTE tmpidx;

    if (psDeviceData == NULL)
    {
        return FALSE;
    }

    if (_pActiveEEPROMSetList && (bEncoder == TRUE) && (bInputButtonPushed(ENC_BTN) == TRUE))
    {
        tmpidx = _pActiveEEPROMSetList[s16InputEncoderGetValue()];
    }
    else if (u8InputButtonQuickPushed() != 0xFF)
    {
        tmpidx =  u8InputButtonQuickPushed();
    }
    else
    {
        return FALSE;
    }

    tmpidx &= SRCP_EEPROMSET_IDX_MASK;
    if (OutGetLEDMode(LED_ACC) == LED_ON)
    {
        // GA is selected.
        tmpidx |= SRCP_EEPROMSET_GA_MASK;
    }

    // Read the quick data from EEPROM.
    XEEReadArray(SRCP_SETS_EEPROM_ADD+(sizeof(SPSET) * tmpidx), (BYTE *)&set, sizeof(SPSET));

    if (set.sFlags.bActive == TRUE)
    {
        // This quick position is occupied.
        memset((void*)psDeviceData, 0, sizeof(sStaticDeviceData));

        psDeviceData->u8BusNr = set.u8BusNr;
        psDeviceData->u32Address = set.u32Address;
        strncpy(psDeviceData->au8Proto, set.au8Proto, SRCP_PROTO_MAXLEN);
        strncpy(psDeviceData->au8Name, set.au8Name, SRCP_NAME_MAXLEN);

        if (tmpidx & SRCP_EEPROMSET_GA_MASK)
        {
            psDeviceData->uSpec.sGASpec.u8MinP = set.uSpec.sGA.u8MinP;
            psDeviceData->uSpec.sGASpec.u8MaxP = set.uSpec.sGA.u8MaxP;
            psDeviceData->uSpec.sGASpec.s32Delay = set.uSpec.sGA.s32Delay;
        }
        else
        {
            psDeviceData->uSpec.sGLSpec.u8MaxSteps = set.uSpec.sGL.u8MaxSteps;
            psDeviceData->uSpec.sGLSpec.u8NrFunc = set.uSpec.sGL.u8NrFunc;
            psDeviceData->uSpec.sGLSpec.u16MaxV = set.uSpec.sGL.u16MaxV;
            psDeviceData->uSpec.sGLSpec.u32FunctionToggleMask = set.uSpec.sGL.u32FuncToggleMask;
        }

        return TRUE;
    }

    return FALSE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _storeNameToEEPROM(BYTE u8EEPROMSetIdx, BYTE *pName)
{
    SPSET eepromdata;

    if ((pName == NULL)||(u8EEPROMSetIdx == 0xFF))
    {
        return;
    }

    XEEReadArray(SRCP_SETS_EEPROM_ADD+(sizeof(SPSET) * u8EEPROMSetIdx), (BYTE *)&eepromdata, sizeof(SPSET));
    strncpy(eepromdata.au8Name, pName, SRCP_NAME_MAXLEN);
    eepromdata.au8Name[SRCP_NAME_MAXLEN] = 0;
    XEEWriteArray(SRCP_SETS_EEPROM_ADD+(sizeof(SPSET) * u8EEPROMSetIdx), (BYTE *)&eepromdata, sizeof(SPSET));
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _UpdateServerCache(SRCP_PRM * pPrm, BOOL bAdd)
{
    short i = 0;

    // Step 1: Look for an appropriate entry in the cache list.
    // Only GLs are currently supported.
    if (pPrm->eDevType != SRCP_DT_GL)
    {
        return;
    }

    for (i = 0; i < SERVER_CACHE_ENTRIES; i++)
    {
        if ((pPrm->u8Bus == _asServerCache[i].u8BusNr) && 
            (pPrm->uStat.sGL.u32Addr == _asServerCache[i].u32Address))
        {
            // Entry is already in the list.
            if (bAdd == TRUE)
            {
                return;
            }

            break;
        }
    }


    // Step 2: Reorder Cache.
    if (bAdd == TRUE)
    {
        // Add the device!
        for (i = (SERVER_CACHE_ENTRIES-2); i >= 0; i--)
        {
            if (_asServerCache[i].u8BusNr == 0)
            {
                // Entry is empty, skip this step.
                continue;
            }

            // Move down in cache
            memcpy((void *)&_asServerCache[i+1], (void*)&_asServerCache[i], sizeof(sServerCacheEntry));
        }
    
    
        // Step 3: Store new entry in the list.
        _asServerCache[0].u8BusNr = pPrm->u8Bus;
        _asServerCache[0].u32Address = pPrm->uStat.sGL.u32Addr;
        strcpy(_asServerCache[0].au8Proto, pPrm->uStat.sGL.au8Proto);
        _asServerCache[0].u8MaxSteps = pPrm->uStat.sGL.u8MaxSteps;
        _asServerCache[0].u8NrFunc = pPrm->uStat.sGL.u8NrFunc;
    }
    else
    {
        if (SERVER_CACHE_ENTRIES == i)
        {
            // Not found in cache!
            return;
        }

        // Remove the device!
        _asServerCache[i++].u8BusNr = 0;

        for (; i < SERVER_CACHE_ENTRIES; i++)
        {
            // The end of cache?
            if (_asServerCache[i].u8BusNr == 0)
            {
                break;
            }

            // Move up in cache
            memcpy((void *)&_asServerCache[i-1], (void*)&_asServerCache[i], sizeof(sServerCacheEntry));

            // Free the last index
            _asServerCache[i].u8BusNr = 0;
        }
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bPrepareServerCacheInput(void)
{
    BYTE entries;

    // Step 1: Check wether the cache is empty:
    if (_asServerCache[0].u8BusNr == 0)
    {
        // Server cache is empty. Give an error message to the user and abort
        // the preparation.
        lcd_addr1 = 0;
        lcd_addr2 = 0;
        StrTbl_GetString(lcdram_row1, STRTBLID_SERVER_CACHE);
        StrTbl_GetString(lcdram_row2, STRTBLID_IS_EMPTY);
        lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                        LCD_ROW2_MASK | LCD_CENTER2_MASK;
        return FALSE;
    }


    // Step 2: Get the server cache count:
    for (entries = 1; entries < SERVER_CACHE_ENTRIES; entries++)
    {
        if (_asServerCache[entries].u8BusNr == 0)
        {
            break;
        }
    }


    // Step 3: Get a local copy of the server cache which is stable for the 
    // time of input.
    _apsSelectCache = (sServerCacheEntry *)(SRAMalloc((sizeof(sServerCacheEntry))*entries));

    if (_apsSelectCache == NULL)
    {
        PrintCommonError(COMMON_ERROR_OUT_OF_MEMORY);
        return FALSE;
    }

    memcpy((void*)_apsSelectCache,(void*)_asServerCache,(sizeof(sServerCacheEntry))*entries);


    // Step 4: Initialize the encoder.
    InputButtonReset(ENC_BTN);
    InputEncoderInit(0, 0, entries-1, 0);


    // Done.
    return TRUE;    
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCPPrepareConnection(void)
{
    // Prepare SRCP-Sockets:
    _sSRCPState.sCommand.u8Socket = INVALID_SOCKET;
    _sSRCPState.sCommand.bCommand = TRUE;
    _sSRCPState.sInfo.u8Socket = INVALID_SOCKET;
    _sSRCPState.sInfo.bCommand = FALSE;

    // Prepare state machine stuff:
    _eSRCPCsm = SRCPC_SM_CONNECT_COMMAND;
    _eSRCPsm = SRCP_STARTUP;

    _bSrvReqIsInProgress = FALSE;
    _psActualDevice = NULL;

    memset(_au8ActiveProtos, 0, sizeof(_au8ActiveProtos));

    memset(_asServerCache, 0 , sizeof(_asServerCache));
    _apsSelectCache = NULL;

    memset(_apsDevices, 0, sizeof(_apsDevices));
    SRAMInitHeap();
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

APPL_CONNECTING_RETCODE SRCPHandleServerConnection(void)
{
    switch(_eSRCPCsm)
    {
    case SRCPC_SM_CONNECT_COMMAND:
    {
        _sSRCPState.sCommand.u8Socket = TCPConnect(ApplGetServerNodeInfo(), ApplGetServerPort().Val);
        
        if (_sSRCPState.sCommand.u8Socket == INVALID_SOCKET)
        {
             _eSRCPCsm = SRCPC_SM_ERROR_CONNECT;
        }
        else
        {
             _eSRCPCsm = SRCPC_SM_CONNECT_WAIT_COMMAND;
        }
        break;
    }

    case SRCPC_SM_CONNECT_WAIT_COMMAND:
        if (TCPWasReset(_sSRCPState.sCommand.u8Socket) || (bInputButtonPushed(ENC_BTN) == TRUE))
        {
            _sSRCPState.sCommand.u8Socket = INVALID_SOCKET;
            _eSRCPCsm = SRCPC_SM_CLOSING;
        }
        else if (TCPIsConnected(_sSRCPState.sCommand.u8Socket))
        {
            OutSwitchOffAllLEDs();
            _startHandShake();
            _eSRCPCsm = SRCPC_SM_CONNECTED_COMMAND;
        }
        break;

    case SRCPC_SM_CONNECTED_COMMAND:
        if (TCPWasReset(_sSRCPState.sCommand.u8Socket) || (bInputButtonPushed(ENC_BTN) == TRUE))
        {
            _sSRCPState.sCommand.u8Socket = INVALID_SOCKET;
            _eSRCPCsm = SRCPC_SM_CLOSING;
        }
        else
        {
            SRCP_HANDSHAKE_RETCODE ret = _eHandShake(&_sSRCPState.sCommand);

            if (ret == SRCP_HR_ERROR)
            {
                // Errors occurred during the handshake. Display the error 
                // message to the user (initiated in the Hand Shake Function) 
                // and close all open connections.
                u8ApplTimer = 200;
                _eSRCPCsm = SRCPC_SM_DELAY_CLOSING;
            }
            else if (ret == SRCP_HR_FINISHED)
            {
                // Connect to the INFO socket.
                _sSRCPState.sInfo.u8Socket = TCPConnect(ApplGetServerNodeInfo(), ApplGetServerPort().Val);

                if (_sSRCPState.sInfo.u8Socket == INVALID_SOCKET)
                {
                    _eSRCPCsm = SRCPC_SM_CLOSING;
                }
                else
                {
                    _eSRCPCsm = SRCPC_SM_CONNECT_WAIT_INFO;
                }
            }
        }
        break;

    case SRCPC_SM_CONNECT_WAIT_INFO:
        if(bInputButtonPushed(ENC_BTN) == TRUE)
        {
            _eSRCPCsm = SRCPC_SM_CLOSING;
        }
        else if (TCPIsConnected(_sSRCPState.sInfo.u8Socket))
        {
            _startHandShake();
            _eSRCPCsm = SRCPC_SM_CONNECTED_INFO;
        }       
        break;

    case SRCPC_SM_CONNECTED_INFO:
        if (bInputButtonPushed(ENC_BTN) == TRUE)
        {
            _eSRCPCsm = SRCPC_SM_CLOSING;
        }
        else if (TCPWasReset(_sSRCPState.sCommand.u8Socket))
        {
            _sSRCPState.sCommand.u8Socket = INVALID_SOCKET;         
            _eSRCPCsm = SRCPC_SM_CLOSING;
        }
        else if (TCPWasReset(_sSRCPState.sInfo.u8Socket))
        {
            _sSRCPState.sInfo.u8Socket = INVALID_SOCKET;            
            _eSRCPCsm = SRCPC_SM_CLOSING;
        }
        else
        {
            SRCP_HANDSHAKE_RETCODE ret = _eHandShake(&_sSRCPState.sInfo);

            if (ret == SRCP_HR_ERROR)
            {
                // Errors occurred during the handshake. Display the error 
                // message to the user (initiated in the Hand Shake Function) 
                // and close all open connections.
                u8ApplTimer = 200;
                _eSRCPCsm = SRCPC_SM_DELAY_CLOSING;
            }
            else if (ret == SRCP_HR_FINISHED)
            {
                _eSRCPCsm = SRCPC_SM_CONNECTED;
            }
        }
        break;

    case SRCPC_SM_DELAY_CLOSING:
        if (u8ApplTimer == 0)
        {
            _eSRCPCsm = SRCPC_SM_CLOSING;
        }
        break;

    case SRCPC_SM_CLOSING:
        if (_sSRCPState.sCommand.u8Socket != INVALID_SOCKET)
        {
            TCPDisconnect(_sSRCPState.sCommand.u8Socket);
        }
        if (_sSRCPState.sInfo.u8Socket != INVALID_SOCKET)
        {
            TCPDisconnect(_sSRCPState.sInfo.u8Socket);
        }

        _eSRCPCsm = SRCPC_SM_WAIT_FOR_CLOSING;
    
        // Intented fall through.

    case SRCPC_SM_WAIT_FOR_CLOSING:
        if ((_sSRCPState.sCommand.u8Socket != INVALID_SOCKET) && TCPWasReset(_sSRCPState.sCommand.u8Socket))
        {
            _sSRCPState.sCommand.u8Socket = INVALID_SOCKET;
        }
        if ((_sSRCPState.sInfo.u8Socket != INVALID_SOCKET) && TCPWasReset(_sSRCPState.sInfo.u8Socket))
        {
            _sSRCPState.sInfo.u8Socket = INVALID_SOCKET;
        }

        if ((_sSRCPState.sCommand.u8Socket == INVALID_SOCKET) && (_sSRCPState.sInfo.u8Socket == INVALID_SOCKET))
        {
            _eSRCPCsm = SRCPC_SM_CLOSED;
        }            
        break;
    
    case SRCPC_SM_CLOSED:
        return APPL_CR_CLOSED;      

    case SRCPC_SM_CONNECTED:
        return APPL_CR_CONNECTED;

    case SRCPC_SM_ERROR_CONNECT:
        return APPL_CR_ERROR;
    }

    return APPL_CR_IN_PROGRESS;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL SRCPIsConnected(void)
{
    if ((_sSRCPState.sCommand.u8Socket != INVALID_SOCKET) && 
        (_sSRCPState.sInfo.u8Socket != INVALID_SOCKET))
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void SRCPStartDisconnect(void)
{
    // Clean up the srcp module before completly disconnecting (destructor).
    FiniDialog(NULL);

    _eSRCPCsm = SRCPC_SM_CLOSING;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static SRCP_DEVICE * _psInitializeNewDevice(SRCP_DEVTYPE eDevType, BYTE u8Bus,
                                            void * pPrm)
{
    BYTE size;
    SRCP_DEVICE * pDev = NULL;

    // Step 1: Determine the size of the requested device structure.
    switch(eDevType)
    {
        case SRCP_DT_POWER:
            size = sizeof(sPower);
            break;

        case SRCP_DT_LOCK:
            size = sizeof(sLock);
            break;

        case SRCP_DT_GL:
            size = sizeof(sGL);
            break;

        case SRCP_DT_GA:
            size = sizeof(sGA);
            break;
    }

    size += sizeof(SRCP_DEVICE);


    // Step 2: Allocate and initialize the device structure.

    pDev = (SRCP_DEVICE*)SRAMalloc(size);
    if (pDev == NULL)
    {
        return NULL;
    }

    memset(pDev, 0, size);
    pDev->eDevType = eDevType;
    pDev->eDevState = SRCP_DS_UNKNOWN;
    pDev->u8Bus = u8Bus;

    if (pPrm)
    {
        size -= sizeof(SRCP_DEVICE);
        memcpy((void *)&pDev[1], pPrm, size);
    }

    return pDev;
}   

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static DWORD _u32GetAddress(SRCP_DEVICE * psDevice)
{
    // The address is always located at the same field position regardless
    // of the device type.

    if (psDevice == NULL)
    {
        return 0;
    }

    if ((psDevice->eDevType == SRCP_DT_GL)||
        (psDevice->eDevType == SRCP_DT_GA)||
        (psDevice->eDevType == SRCP_DT_LOCK))
    {
        return (*((DWORD *)(&psDevice[1])));
    }
    else
    {
        return 0;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _refreshDeviceList(void)
{
    BYTE i, j;
    BOOL bListIsEmpty = TRUE;

    // Step 1: Check for double pointers in the list and remove them.
    for (i = 0; i < MAX_SRCP_DEVICES; i++)
    {
        if (_apsDevices[i] == NULL)
        {
            continue;
        }

        bListIsEmpty = FALSE;
        for (j = 0; j < MAX_SRCP_DEVICES; j++)
        {
            if ((i!=j) && (_apsDevices[i] == _apsDevices[j]))
            {
                _apsDevices[j] = NULL;
            }
        }
    }

    if (bListIsEmpty == TRUE)
    {
        return;
    }

    // Step 2: Remove disabled devices from the device list.
    for (i = 0; i < MAX_SRCP_DEVICES; i++)
    {
        if (_apsDevices[i] == NULL)
        {
            continue;
        }

        if (_apsDevices[i]->eDevState == SRCP_DS_DISABLED)
        {
            if (_psActualDevice == _apsDevices[i])
            {
                _psActualDevice = NULL;
            }
            SRAMfree((BYTE *)(_apsDevices[i]));
            _apsDevices[i] = NULL;
        }
    }


    // Step 3: Move all NULL pointers to the end of the list.
    for (i = FREQUENT_SRCP_DEVICE_OFFSET; i < MAX_SRCP_DEVICES; i++)
    {
        if (_apsDevices[i] != NULL)
        {
            continue;
        }
        
        // Find a valid pointer after this NULL position.
        for (j = i+1; j < MAX_SRCP_DEVICES; j++)
        {
            if (_apsDevices[j] != NULL)
            {
                // Move the valid pointer to the NULL position:
                _apsDevices[i] = _apsDevices[j];
                _apsDevices[j] = NULL;
                break;
            }
        }
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static SRCP_DEVICE * _pTakeOverDevice(SRCP_DEVICE * pDevice)
{
    SRCP_DEVICE * pLastDevice = NULL;
    BYTE mainDeviceIdx = 0;

    if (pDevice == NULL)
    {
        return NULL;
    }

    // Check the device type (only GA and GL can be main devices).
    if (pDevice->eDevType == SRCP_DT_GA)
    {
        mainDeviceIdx = 1;
    }
    else if (pDevice->eDevType != SRCP_DT_GL)
    {
        return NULL;
    }

    // Is the device already stored as frequently used device?
    if (pDevice == _apsDevices[mainDeviceIdx])
    {
        return pDevice;
    }


    // Delete the last main device of the appropriate category.
    if (_apsDevices[mainDeviceIdx])
    {
        // Delete the last device!
        SRAMfree((BYTE *)_apsDevices[mainDeviceIdx]);
    }

    // Move the new device to the main position.
    _apsDevices[mainDeviceIdx] = pDevice;

    _refreshDeviceList();

    return pDevice;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static SRCP_DEVICE * _pGetLatestGL(void)
{
    return _apsDevices[0];
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static SRCP_DEVICE * _pGetLatestGA(void)
{
    return _apsDevices[1];
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BYTE _prepareEEPROMSetInput(BOOL bGL)
{
    BYTE listsize, listoffset;
    BYTE i, entries;
    WORD address;

    // Step 1: Initialize the device dependent margins for eeprom access.
    if (bGL == TRUE)
    {
        listoffset = 0;
        listsize = SRCP_GLEEPROMSET_COUNT;
    }
    else
    {
        listoffset = SRCP_GLEEPROMSET_COUNT;
        listsize = SRCP_GAEEPROMSET_COUNT;
    }


    // Step 2: Allocate the EEPROM set list.
    _pActiveEEPROMSetList = SRAMalloc(listsize);

    if (_pActiveEEPROMSetList == NULL)
    {
        PrintCommonError(COMMON_ERROR_OUT_OF_MEMORY);
        return 0;
    }


    // Step 3: Iterate through the eeprom set and find active sets.
    address = SRCP_SETS_EEPROM_ADD + (listoffset * sizeof(SPSET));
    for (i = listoffset, entries = 0; i < (listsize + listoffset); i++)
    {
        SPSET set;
        XEEReadArray(address, (BYTE *)&set, sizeof(SPSET));
        if (set.sFlags.bActive == TRUE)
        {
            _pActiveEEPROMSetList[entries++] = i;
        }
        address += sizeof(SPSET);
    }


    // Step 4: Evaluate the amount of sets.
    if (entries == 0)
    {
        lcd_addr1 = 0;
        lcd_addr2 = 0;
        StrTbl_GetString(lcdram_row1, STRTBLID_DATABASE);
        StrTbl_GetString(lcdram_row2, STRTBLID_IS_EMPTY);
        lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                        LCD_ROW2_MASK | LCD_CENTER2_MASK;
        return 0;
    }

    return entries;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _destructEEPROMSet(void)
{
    if (_pActiveEEPROMSetList)
    {
        SRAMfree(_pActiveEEPROMSetList);
        _pActiveEEPROMSetList = NULL;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

---