#include "stdio.h"
#include <string.h>
#include <math.h>
#include <alloc.h>
#include "..\lib\module1.h"
#include "..\lib\MBTCP.h"
#include "..\lib\io_scan.h"

int iScanCOMPort=1;	// of Modbus Kernel       
unsigned char far iMemory_DI[1000];
unsigned char far iMemory_DO[1000];
int far iMemory_AI[800];
int far iMemory_AO[800];
extern char VCOM3_ModuleName[20];

void UserCount(void)
{
	// user's timer trigger function
	//
	// In this function cannot use any function that will use the hardware signal "clock",
	// Such as:
	//  1. ClockHigh(),ClockLow(), ClockHighLow(),
	//  2. Any EEPROM functions.
	//  3. Any 5DigitLed functions.
	//  4. Any NVRAM function.
	//  5. Any RTC function.(GetTime(),SetTime(),GetDate(),SetDate())
	//
	// refer to demo9 for example code
}
void UserInit(void)
{
/*
	In this function, user CAN:
	1. initialize user's program.
	2. set time interval for calling UserCount().
	3. set initial value of I/O or variables for UserLoopFun().
	4. set initial value of I/O or variables for another functions.
	5. change the default TCP PORT 10000/9999/502 to others value. [after vcom3004.lib]
	   Syntax:
    	Port10000=newport_10000;  for calling UserCmd       (user.c)
    	Port9999=newport_9999;    for calling VcomCmd7000   (v7000.c)
    	Port502=newport_502;      for calling VcomCmdModbus (vModbus.c) [after vcom3002.lib]
	    PortUser=newport_User;    for calling VcomCmdUser   (user.c)    [after vcom3005.lib]
	    
		Default port value:
		Port10000=10000;
		Port9999=9999;
		Port502=502;
		PortUser=0;
		If the port value is 0, Xserver will not 
		listen that port. That means the port will 
		be disable.
*/
	//======= Begin of Modbus Kernel =======
	int i, iRet;
  for(i=0;i<1000;i++)
      iMemory_DO[i]=0;
  for(i=0;i<800;i++)
			iMemory_AO[i]=0;
	iRet=InitModbus(iMemory_DI,iMemory_DO,iMemory_AI,iMemory_AO);
	if(iRet==0)
	{
		// Initial Modbus configuration success.
	}
	else
	{
		// Initial Modbus configuration failure.
	}
  Init_IO_Scan(iMemory_DI,iMemory_DO,iMemory_AI,iMemory_AO);
	//======= End of Modbus Kernel=======
	Port9999=0;	//Disable listening TCP port 9999 to speed up 7188E.
	i=GetNumberOfSlot();
	if(i==4)
	{
		SetModuleName("iP-8441");
	}
	else if(i==8)
	{
		SetModuleName("iP-8841");
	}
}


int iNet_Status=0,iOffset_Status=0;

void UserLoopFun(void)
{
  //======= Begin of Modbus Kernel =======
	UpdateIOModule();
  if(mtModbusPort[iScanCOMPort].EnableMode==_ModbusRTU_Slave)
	    CheckModbusRTURequest(iScanCOMPort);		// Is any request from Modbus/RTU Master ?

	if(mtModbusPort[iScanCOMPort].EnableMode==_ModbusASCII_Slave)
	    CheckModbusASCIIRequest(iScanCOMPort);		// Is any request from Modbus/ASCII Master ?
	    
	if(mtModbusPort[iScanCOMPort].EnableMode==_ModbusRTU_Gateway)
	{
		SendModbusRequest(iScanCOMPort);		// Passes request to modbus slave device.
		CheckResponseTimeout(iScanCOMPort);		// If response timeout, sets iModbusAction
												// to IDLE status.
		CheckModbusResponse(iScanCOMPort);		// Is any response from modbus slave device?
		SendModbusResponse(iScanCOMPort);		// Passes response to Modbus/RTU Master.
	} 
  iScanCOMPort++;
	if(iScanCOMPort>4)
		iScanCOMPort=1;
		
    if(iOffset_Status==0)
	    iNet_Status=SMMI_Net_CheckIn();
	  
	if(iNet_Status==0)    
	    iOffset_Status=SMMI_Offset_CheckIn();  
	//printCom1("Memory left %lu bytes\n\r",(unsigned long)coreleft());		
	//======= End of Modbus Kernel =======
}

int UserCmd(unsigned char *Cmd,unsigned char *Response)
{
	int iRet;	
	//======= Begin Modbus Kernel =======	
	if(Cmd[0]=='!')
	{
		iRet=Configuration(Cmd,Response);
		if(iRet==0)
			return 1;	/* return ok */
		else 
			return 0;	/* return ERROR */
	}
	//======= End Modbus =======	
	else 
		return 1;	/* return ok */
}

int VcomUserBinaryCmd(TCPREADDATA *p)
{
 /* VXCOMM.EXE 2.6.12(09/04/2001) or later will support this function.

		TCP PORT 10000, command 23 will call this function.
		user can get the following message:
		p->ReadUartChar : the buffer store the command data(include "23")
		p->Length : the command data length(include the two byte "23")
		p->Socket : the socket number that receive the command, that is when the user function want
								return message to the client, just use the socket to send data.
								use:  VcomSendSocket(p->Socket,pdata,datalength);
 */
	VcomSendSocket(p->Socket,"User-defined command(23)",24);	// return 24 bytes.
	return 1;	/* any value will be accept */
}

int VcomCmdUser(TCPREADDATA *p)
{
	/*
    VCOM3005 (Feb,22,2002) or later will call this function for PortUser.
    
    When packets received by TCP PORT PortUser(user defined) 
    of 7188E/8000E, Xserver will call this function.
    user can get the following message:
    p->ReadUartChar : the buffer store the command data.
                      Maximum length of p->ReadUartChar is 32767 bytes.
    p->Length : the command data length.
    p->Socket : the socket number that receive the command, that is when the user function wants 
                return message to the client, just use the socket to send data.
                usage:  VcomSendSocket(p->Socket,pdata,datalength);
	*/
  
	/* here just send back the command to the client. */
	VcomSendSocket(p->Socket,p->ReadUartChar,p->Length);
 	return 1;	/* any value will be accept */	
}

void PortUserStart(int skt)
{
    /* 
        XS8_3200.Lib Version 3.2.00 (20,Apr,2004) 
        or later version supports this function.
        When a TCP/IP client connects to the 7188E/8000E via the user's defined port(PortUser), 
        the Xserver calls the function once.
        You can use function VcomSendSocket to send a message to the client 
        when a connection is established.
    For example:
        VcomSendSocket(skt,"Connection is established.",26); //return 26 bytes.
        skt: socket number assigned to the TCP/IP client.
    */
    skt=skt; /*do nothing*/
}

void UserEnd(void)
{

}
void Modbus_Request_Event(char* CommandData,int* CommandLength)
{   
    /*
    Modbus_Request_Event is supported since version 1.6.8 [2007,03,13]. 
    
    char* CommandData: For Modbus/TCP, it includes 6 leading bytes. (needful) 
                       For Modbus/RTU, it includes 6 leading bytes. (needless) 
                       
    int* CommandLength: For Modbus/TCP, it includes 6 leading bytes. 
                        For Modbus/RTU, it includes 6 leading bytes.                      
    */
    /* Example code */
    /*int i;    
    printCom1("FC:%2d  StartAddress:%3d  IOCount:%4d\n\r",iModbusRequest_Fun, iModbusRequest_Addr,iModbusRequest_IOCount);
    printCom1("Modbus Request\n\r    In==>");
	for(i=0;i<*CommandLength;i++)
        printCom1("[%02X] ",CommandData[i]&0xFF);*/
}    

void Modbus_Response_Event(char* ResponseData,int* ResponseLength)
{
    /*
    char* ResponseData: For Modbus/TCP, it includes 6 leading bytes. 
                        For Modbus/RTU, it doesn't include 6 leading bytes
                       
    int* CommandLength: For Modbus/TCP, it includes 6 leading bytes. 
                        For Modbus/RTU, it doesn't include 6 leading bytes 
    */
    //If you want to change the content of the ResponseData, 
    //you have to do 2 steps for Modbus/TCP or Modbus/RTU.
    
    //Step1: Change content (Note:you must know the modbus protocol well)
    //ResponseData[6]=0x19;
    //ResponseData[7]=0x75;
    //ResponseData[8]=0x04;
    //ResponseData[9]=0x01;
    
    //Step2: Update data length
    //*ResponseLength=10;
    //int i;
    //printCom1("\n\r    Out==>");
	//for(i=0;i<*ResponseLength;i++)
    //    printCom1("[%02X] ",ResponseData[i]&0xFF);
    //printCom1("\n\r");  
}