#define THIS_IS_STACK_APPLICATION

#include "stacktsk.h"
#include "dhcp.h"
#include "xlcd.h"
#include "tick.h"
#include "delay.h"
#include "udp.h"
#include "arp.h"
#include "arptsk.h"
#include "tcp.h"


// All TFTP command statuts display will be done on first line of LCD.
#define TFTP_COMMAND_DISPLAY_LINE       0

// Result will be displayed at y = 15.
#define TFTP_COMMAND_RESULT_POSITION    15


#define STARTUP_MSG "G1_Build_0x00"

ROM char StartupMsg[] = STARTUP_MSG;

#if defined(STACK_USE_DHCP) || defined(STACK_USE_IP_GLEANING)
ROM char DHCPMsg[] = "DHCP/Gleaning...";
#endif

ROM char SetupMsg[] = "Board Setup...";

//                         1234567890123456
ROM char blankLCDLine[] = "                ";

/*
 * This is used by other stack elements.
 * Main application must define this and initialize it with
 * proper values.
 */
APP_CONFIG AppConfig;


BYTE myDHCPBindCount = 0;
#if defined(STACK_USE_DHCP)
    extern BYTE DHCPBindCount;
#else
    /*
     * If DHCP is not enabled, force DHCP update.
     */
    BYTE DHCPBindCount = 1;
#endif

/*
 * Set configuration fuses for HITECH compiler.
 * For MCC18 compiler, separately linked config.asm file
 * will set the correct fuses.
 */
#if defined(HITECH_C18)
__CONFIG(1, UNPROTECT & HS);
__CONFIG(2, PWRTEN & BORDIS & WDTDIS);
#endif


/*
 * Private helper functions.
 * These may or may not be present in all applications.
 */
static void InitAppConfig(void);
static void InitializeBoard(void);
static void DisplayIPValue(IP_ADDR *IPVal, BOOL bToLCD);
static void SetConfig(void);

/*void network_send_hello( unsigned char termid )
{
	   if (DHCPIsBound())
        {
        	RA3 =0;
        	if (sock_open == 0)
        	{
	        	if (ARPIsTxReady())
	        	{
		        	if (is_resolved == 0)
		        	{
			        	ARPResolve( &rnode.IPAddr);
			        	is_resolved = 1;
			        }
			        else
			        {
		        		if (ARPIsResolved( &rnode.IPAddr, &rnode.MACAddr))
		        		//if (MyArp( &rnode))
		        		{
	        				usock1=UDPOpen(2000,&rnode,3000); // socket to send UDP
	        				sock_open=1;
	        			}
	        		}	
	        	}
	        }
	        
        	if (UDPIsPutReady(usock1) && datagrams_to_send>0)
        	{
	        	UDPPut( rnode.MACAddr.v[0] );
	       		UDPPut( rnode.MACAddr.v[1] );
	       		UDPPut( rnode.MACAddr.v[2] );
	       		UDPPut( rnode.MACAddr.v[3] );
	       		UDPPut( rnode.MACAddr.v[4] );
	       		UDPPut( rnode.MACAddr.v[5] );
	        	UDPPut('D');
	        	UDPPut('a');
	        	UDPPut('w');
	        	UDPPut(0);
	        	UDPFlush();
	        	datagrams_to_send--;
	        }
		}
}
*/

void WriteTcpStatus(char status)
{
	XLCDGoto(0,0);
	status += 'a';
	XLCDPut(status);
	
}

void main(void)
{
    // Tick to blink SYSTEM led.
    static TICK t = 0;
    TCP_SOCKET usock1;
    NODE_INFO rnode;
    char sock_state = 0;
    char is_resolved = 0;
    char has_arp = 0;
        
    TICK tick;
    TICK lastTick;
	TICK diffTicks;

    /*
     * Initialize any application specific hardware.
     */
    InitializeBoard();

    /*
     * Initialize all stack related components.
     * Following steps must be performed for all applications using
     * PICmicro TCP/IP Stack.
     */
    TickInit();

    /*
     * Initialize Stack and application related NV variables.
     */
    InitAppConfig();

    StackInit();

#if defined(STACK_USE_DHCP) || defined(STACK_USE_IP_GLEANING)
    if ( AppConfig.Flags.bIsDHCPEnabled )
    {
        XLCDGoto(1, 0);
        XLCDPutROMString(DHCPMsg);
    }
    else
    {
        /*
         * Force IP address display update.
         */
        myDHCPBindCount = 1;
#if defined(STACK_USE_DHCP)
        DHCPDisable();
#endif
    }
#endif


    /*
     * Once all items are initialized, go into infinite loop and let
     * stack items execute their tasks.
     * If application needs to perform its own task, it should be
     * done at the end of while loop.
     * Note that this is a "co-operative mult-tasking" mechanism
     * where every task performs its tasks (whether all in one shot
     * or part of it) and returns so that other tasks can do their
     * job.
     * If a task needs very long time to do its job, it must broken
     * down into smaller pieces so that other tasks can have CPU time.
     */
     
 
	// Defines the IP add. on the server machine
	rnode.IPAddr.v[0] = 192;
	rnode.IPAddr.v[1] = 168;
	rnode.IPAddr.v[2] = 1;
	rnode.IPAddr.v[3] = 20;
	/*rnode.MACAddr.v[0] = 0x00;
	rnode.MACAddr.v[1] = 0x16;
	rnode.MACAddr.v[2] = 0x76;
	rnode.MACAddr.v[3] = 0x9F;
	rnode.MACAddr.v[4] = 0xFE;
	rnode.MACAddr.v[5] = 0xDA;*/
	
         

    
    while(1)
    {
        /*
         * Blink SYSTEM LED every second.
         */
        if ( TickGetDiff(TickGet(), t) >= TICK_SECOND/2 )
        {
            t = TickGet();
            LATA4 ^= 1;
        }

        /*
         * This task performs normal stack task including checking
         * for incoming packet, type of packet and calling
         * appropriate stack entity to process it.
         */
        StackTask();

        /*
         * For DHCP information, display how many times we have renewed the IP
         * configuration since last reset.
         */
         
        if ( DHCPBindCount != myDHCPBindCount )
        {
            DisplayIPValue(&AppConfig.MyIPAddr, TRUE);
            myDHCPBindCount = DHCPBindCount;

            if ( AppConfig.Flags.bIsDHCPEnabled )
            {
                XLCDGoto(1, 14);
                if ( myDHCPBindCount < 0x0a )
                    XLCDPut(myDHCPBindCount + '0');
                else
                    XLCDPut(myDHCPBindCount + 'A');
            }
        }
        
        WriteTcpStatus( TCB[usock1].smState );
        
        if (DHCPIsBound())
        {
        	RA3 =0;
        	if (has_arp == 0)
        	{
	        	if (ARPIsTxReady())
	        	{
		        	if (is_resolved == 0)
		        	{
			        	ARPResolve( &rnode.IPAddr);
			        	is_resolved = 1;
			        }
			        else
			        {
		        		if (ARPIsResolved( &rnode.IPAddr, &rnode.MACAddr))
		        		{
							has_arp = 1;
	        			}
	        		}
	
	        	}
	        }
	        
	        if (has_arp == 1)
	        {
	        	if (sock_state == 0)
	        	{
	    	    	usock1=TCPConnect(&rnode,3000);
		        	sock_state = 1;
		        }
	        	if (sock_state ==1 && TCPIsConnected(usock1) && TCPIsPutReady(usock1))
        		{
		        	TCPPut(usock1,'D');
		        	TCPPut(usock1,'a');
	        		TCPPut(usock1,'w');
	        		TCPPut(usock1,0);
	    	    	TCPFlush(usock1);
		        	sock_state = 2;
		        }
	        
	        	if (sock_state == 2 && TCPIsPutReady(usock1))
	    	    {
			        TCPDisconnect(usock1);
			        lastTick = TickGet();
			        sock_state =3;
		    	}
		    	tick = TickGet();
		    	diffTicks = TickGetDiff(tick, lastTick);
		    	
		    	if ( sock_state == 3 && diffTicks > ((TICK)TICK_SECOND * (TICK)2) )
		    		sock_state = 0;
		    		
		    }
        } 
    }
}

#if defined(MCHP_C18)
    #pragma interrupt HighISR save=section(".tmpdata")
    void HighISR(void)
#elif defined(HITECH_C18)
    #if defined(STACK_USE_SLIP)
        extern void MACISR(void);
    #endif
    void interrupt HighISR(void)
#endif
{
    TickUpdate();
/*
#if defined(STACK_USE_SLIP)
    MACISR();
#endif
*/
}

#if defined(MCHP_C18)
#pragma code highVector=0x08
void HighVector (void)
{
    _asm goto HighISR _endasm
}
#pragma code /* return to default code section */
#endif

static void DisplayIPValue(IP_ADDR *IPVal, BOOL bToLCD)
{
    char IPDigit[8];

    if ( bToLCD )
    {
        /*
         * Erase second line.
         */
        XLCDGoto(1, 0);
        XLCDPutROMString(blankLCDLine);

    }

    /*
     * Rewrite the second line.
     */
    XLCDGoto(1, 0);

    itoa(IPVal->v[0], IPDigit);
    if ( bToLCD )
    {
        XLCDPutString(IPDigit);
        XLCDPut('.');
    }

    itoa(IPVal->v[1], IPDigit);
    if ( bToLCD )
    {
        XLCDPutString(IPDigit);
        XLCDPut('.');
    }

    itoa(IPVal->v[2], IPDigit);
    if ( bToLCD )
    {
        XLCDPutString(IPDigit);
        XLCDPut('.');
    }

    itoa(IPVal->v[3], IPDigit);
    if ( bToLCD )
        XLCDPutString(IPDigit);
}

/*********************************************************************
 * Function:        void InitializeBoard(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Initialize board specific hardware.
 *
 * Note:            None
 ********************************************************************/
static void InitializeBoard(void)
{
    /*
     * Setup for PORTA.RA0 as analog input while rests
     * as digital i/o lines.
     */
    ADCON1  = 0b10001110;       // RA0 as analog input, Right justified
    TRISA   = 0x03;

    /*
     * LCD is enabled using RA5.
     */
    PORTA_RA5 = 0;          // Disable LCD.

    /*
     * Turn off the LED's.
     */
    LATA2 = 1;
    LATA3 = 1;

    /*
     * External data EEPROM needs pull-ups, so enable internal
     * pull-ups.
     */
    INTCON2_RBPU = 0;

    XLCDInit();
    XLCDGoto(0, 0);
    XLCDPutROMString(StartupMsg);

    T0CON = 0;
    INTCON_GIEH = 1;
    INTCON_GIEL = 1;

}

/*********************************************************************
 * Function:        void InitAppConfig(void)
 *
 * PreCondition:    MPFSInit() is already called.
 *
 * Input:           None
 *
 * Output:          Write/Read non-volatile config variables.
 *
 * Side Effects:    None
 *
 * Overview:        None
 *
 * Note:            None
 ********************************************************************/
static void InitAppConfig(void)
{
    /*
     * Load default configuration into RAM.
     */
    AppConfig.MyIPAddr.v[0]     = MY_DEFAULT_IP_ADDR_BYTE1;
    AppConfig.MyIPAddr.v[1]     = MY_DEFAULT_IP_ADDR_BYTE2;
    AppConfig.MyIPAddr.v[2]     = MY_DEFAULT_IP_ADDR_BYTE3;
    AppConfig.MyIPAddr.v[3]     = MY_DEFAULT_IP_ADDR_BYTE4;

    AppConfig.MyMask.v[0]       = MY_DEFAULT_MASK_BYTE1;
    AppConfig.MyMask.v[1]       = MY_DEFAULT_MASK_BYTE2;
    AppConfig.MyMask.v[2]       = MY_DEFAULT_MASK_BYTE3;
    AppConfig.MyMask.v[3]       = MY_DEFAULT_MASK_BYTE4;

    AppConfig.MyGateway.v[0]    = MY_DEFAULT_GATE_BYTE1;
    AppConfig.MyGateway.v[1]    = MY_DEFAULT_GATE_BYTE2;
    AppConfig.MyGateway.v[2]    = MY_DEFAULT_GATE_BYTE3;
    AppConfig.MyGateway.v[3]    = MY_DEFAULT_GATE_BYTE4;

    AppConfig.MyMACAddr.v[0]    = MY_DEFAULT_MAC_BYTE1;
    AppConfig.MyMACAddr.v[1]    = MY_DEFAULT_MAC_BYTE2;
    AppConfig.MyMACAddr.v[2]    = MY_DEFAULT_MAC_BYTE3;
    AppConfig.MyMACAddr.v[3]    = MY_DEFAULT_MAC_BYTE4;
    AppConfig.MyMACAddr.v[4]    = MY_DEFAULT_MAC_BYTE5;
    AppConfig.MyMACAddr.v[5]    = MY_DEFAULT_MAC_BYTE6;

#if defined(STACK_USE_DHCP)
    AppConfig.Flags.bIsDHCPEnabled = TRUE;
#else
    AppConfig.Flags.bIsDHCPEnabled = FALSE;
#endif
}

BOOL StringToIPAddress(char *str, IP_ADDR *buffer)
{
    BYTE v;
    char *temp;
    BYTE byteIndex;

    temp = str;
    byteIndex = 0;

    while( v = *str )
    {
        if ( v == '.' )
        {
            *str++ = '\0';
            buffer->v[byteIndex++] = atoi(temp);
            temp = str;
        }
        else if ( v < '0' || v > '9' )
            return FALSE;

        str++;
    }

    buffer->v[byteIndex] = atoi(temp);

    return (byteIndex == 3);
}


void XLCDDelay15ms(void)
{
    DelayMs(15);
}
void XLCDDelay4ms(void)
{
    DelayMs(4);
}

void XLCDDelay100us(void)
{
    INTCON_GIEH = 0;
    Delay10us(1);
    INTCON_GIEH = 1;
}