#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include <limits.h>
#include <gfambrtuslv.h>
#include "mbslvapp.h"
#include "inc/hw_memmap.h"
#include "inc/hw_gpio.h"
#include "inc/hw_uart.h"
#include "inc/hw_ints.h"
#include "driverlib/gpio.h"
#include "driverlib/uart.h"
#include "driverlib/sysctl.h"
#include "driverlib/pin_map.h"

#if HW_PLATFORM == HW_PLATFORM_OLS1V
#include "ols1v.h"
#elif HW_PLATFORM == HW_PLATFORM_EAV1V
#include "eav1v.h"
#else
#error Unknown hardware platform!
#endif	//	HW_PLATFORM

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

static uint16_t g_mbRegs[MODBUS_WORD_REGISTER_COUNT];
static HMBRTUSLV g_hMbSlv;

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

static void _OnSlaveStateChanged(GFA_MODBUS_RTU_SLV_STATES newState, GFA_MODBUS_RTU_SLV_STATES oldState)
{
	switch(newState)
	{
	case MB_RTU_SLV_Idle:
//		OlsClearLeds(OLS_LED_MASK);
		break;

	case MB_RTU_SLV_RxSlvID:
//		OlsSetLeds(OLS_LED_GREEN_RIGHT);
		break;

	case MB_RTU_SLV_RxComplete:
//		OlsClearLeds(OLS_LED_GREEN_RIGHT);
		break;

	case MB_RTU_SLV_TxStart:
//		OlsSetLeds(OLS_LED_GREEN_LEFT);
		break;
	}
}

/////////////////////////////////////////////////////////////////////////////
// maps a modbus register address to a physical register address.
// if not implemented the modbus address is interpreted as physical address.

static uint16_t _MapRegisterAddress(uint16_t nAddr)
{
	if(nAddr >= MODBUS_WORD_REGISTER_COUNT)
		return (uint16_t)-1;
	return nAddr;
}

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

static void _PreReadRegisters(uint8_t func, uint16_t nRegStart, uint16_t nRegCount)
{
	float f1 = GfaBufGetUnaligned_float(&g_mbRegs[0]);
	float f2 = GfaBufGetUnaligned_float(&g_mbRegs[2]);

	GfaBufSetUnaligned_float(&g_mbRegs[0], ++f1);
	GfaBufSetUnaligned_float(&g_mbRegs[2], --f2);
}

static void _PostReadRegisters(uint8_t func, uint16_t nRegStart, uint16_t nRegCount)
{
}

static void _PreWriteRegisters(uint8_t func, uint16_t nRegStart, uint16_t nRegCount)
{
}

static void _PostWriteRegisters(uint8_t func, uint16_t nRegStart, uint16_t nRegCount)
{
}

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

static void _InitUARTConfig(LPGFA_UART_CONFIG puc)
{
	memset(puc, 0, sizeof(LPGFA_UART_CONFIG));

	puc->P_UART_BASE		  = UART_BASE;
	puc->P_UART_BASE_SYSCTL   = UART_BASE_SYSCTL;
	puc->P_UART_PORT          = UART_PORT;
	puc->P_UART_PORT_SYSCTL   = UART_PORT_SYSCTL;
	puc->P_UART_RX_PIN        = UART_RX_PIN;
	puc->P_UART_RX_PIN_MUX    = UART_RX_PIN_MUX;
	puc->P_UART_TX_PIN        = UART_TX_PIN;
	puc->P_UART_TX_PIN_MUX    = UART_TX_PIN_MUX;
	puc->P_UART_INT           = UART_INT;
	puc->P_UART_INT_PRIORITY  = MODBUS_RTU_UART_INT_PRIORITY;
	puc->P_EN_485_PORT_SYSCTL = EN_485_PORT_SYSCTL;
	puc->P_EN_485_PORT        = EN_485_PORT;
	puc->P_EN_485_PIN         = EN_485_PIN;
	puc->nBaud                = MODBUS_RTU_BAUDRATE;
	puc->nDatabits            = MODBUS_RTU_DATABITS;
	puc->nStopbits            = MODBUS_RTU_STOPBITS;
	puc->parity               = MODBUS_RTU_PARITY;
	puc->nFifoIndexRx         = 0;
	puc->nFifoIndexTx         = 1;
}

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

bool GfaInitModbusSlaveApp(void)
{
	GFA_UART_CONFIG uartParams;
	g_hMbSlv = NULL;
	_InitUARTConfig(&uartParams);

	if(GfaMbUartInit(&uartParams))
	{
		GFA_MODBUS_RTU_SLAVE_PARAMETERS slvParams;
		memset(&slvParams, 0, sizeof(slvParams));

		slvParams.slaveID					= MODBUS_SLAVE_ID;
		slvParams.hFifoRX					= GfaMbUartGetRxFifo();
		slvParams.hFifoTX					= GfaMbUartGetTxFifo();

		slvParams.regMap.pRegs				= g_mbRegs;
		slvParams.regMap.nCountRegs 		= _countof(g_mbRegs);

		slvParams.appItf.pfnMapRegAddr		= _MapRegisterAddress;
		slvParams.appItf.pfnPreRead			= _PreReadRegisters;
		slvParams.appItf.pfnPostRead		= _PostReadRegisters;
		slvParams.appItf.pfnPreWrite		= _PreWriteRegisters;
		slvParams.appItf.pfnPostWrite		= _PostWriteRegisters;
		slvParams.appItf.pfnStateChanged	= _OnSlaveStateChanged;

		slvParams.appItf.pfnPreTransmit		= NULL;
		slvParams.appItf.pfnPostTransmit	= NULL;

		if(!(g_hMbSlv = GfaModbusRTUSlvCreate(&slvParams)))
			GfaMbUartRelease();
	}

	return !!g_hMbSlv;
}

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

void GfaDoModbusSlaveApp(void)
{
	GfaModbusRTUSlvStateMachine(g_hMbSlv);
}

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