/* ---------- AVR includes ----------*/
#include "avr/io.h"
#include "avr/interrupt.h"

/* ---------- Modbus includes ----------*/
#include "mb.h"
#include "mbport.h"

/* ---------- Defines ----------*/
#define REG_INPUT_START 1000
#define REG_INPUT_NREGS 4

/* ---------- Static variables ----------*/
static USHORT   usRegInputStart = REG_INPUT_START;
static USHORT   usRegInputBuf[REG_INPUT_NREGS];

#define REG_HOLDING_START 1200
#define REG_HOLDING_NREGS 99

static USHORT   usRegHoldingStart = REG_HOLDING_START;
static USHORT   usRegHoldingBuf[REG_HOLDING_NREGS];

#define REG_COILS_START     1100
#define REG_COILS_SIZE      16

static unsigned char ucRegCoilsBuf[REG_COILS_SIZE / 8];

/* ---------- Start implementation ----------*/
int
main( void )
{
    const UCHAR     ucSlaveID[] = { 0xAA, 0xBB, 0xCC };
    eMBErrorCode    eStatus;

    eStatus = eMBInit( MB_RTU, 0x0A, 0, 38400, MB_PAR_EVEN );

    eStatus = eMBSetSlaveID( 0x34, TRUE, ucSlaveID, 3 );
    sei(  );

    /* Enable the Modbus Protocol Stack. */
    eStatus = eMBEnable(  );

    for( ;; )
    {
        ( void )eMBPoll(  );

        /* Here we simply count the number of poll cycles. */
        usRegInputBuf[0]++;
    }
}

eMBErrorCode
eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    int             iRegIndex;

    if( ( usAddress >= REG_INPUT_START )
        && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
    {
        iRegIndex = ( int )( usAddress - usRegInputStart );
        while( usNRegs > 0 )
        {
            *pucRegBuffer++ =
                ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
            *pucRegBuffer++ =
                ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
            iRegIndex++;
            usNRegs--;
        }
    }
    else
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}

eMBErrorCode
 eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs,
                           eMBRegisterMode eMode )
          {
             eMBErrorCode    eStatus = MB_ENOERR;
                int             iRegIndex;

                if( ( usAddress >= REG_HOLDING_START ) &&
                    ( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )
                {
                    iRegIndex = ( int )( usAddress - usRegHoldingStart );
                    switch ( eMode )
                    {
                        /* Pass current register values to the protocol stack. */
                    case MB_REG_READ:
                        while( usNRegs > 0 )
                        {
                            *pucRegBuffer++ = ( UCHAR ) ( usRegHoldingBuf[iRegIndex] >> 8 );
                            *pucRegBuffer++ = ( UCHAR ) ( usRegHoldingBuf[iRegIndex] & 0xFF );
                            iRegIndex++;
                            usNRegs--;
                        }
                        break;

                        /* Update current register values with new values from the
                         * protocol stack. */
                    case MB_REG_WRITE:
                        while( usNRegs > 0 )
                        {
                            usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
                            usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
                            iRegIndex++;
                            usNRegs--;
                        }
                    }
                }
                else
                {
                    eStatus = MB_ENOREG;
                }
                return eStatus;
          }



eMBErrorCode
eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils,
               eMBRegisterMode eMode )
{
    return MB_ENOREG;
}

eMBErrorCode
eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
{
    return MB_ENOREG;
}