Subversion Repositories HomeAutomation

#define THIS_IS_TIMESYNC

#include "..\Include\DNS.h"

#include "..\Include\Helpers.h"

#include "..\Include\TCP.h"

#include "..\Include\ARPTsk.h"

#include "..\Include\ARP.h"

#include "..\Include\UART.h"

#include "..\Include\StackTsk.h"

#include "..\Include\TimeSync.h"

#if defined(STACK_USE_TIMESYNC)

    typedef enum _timeState

    {

        SM_START=0,

        SM_ARP_RESOLVE,

        SM_ARP_RESOLVED,

        SM_CONNECT,

        SM_CONNECT_WAIT,

        SM_CONNECTED,

        SM_RECEIVE,

        SM_DISCONNECT,

        SM_ABORT,

        SM_DONE

    } timeState;

timeState smTS = SM_START;

DWORD lastSync = 0;

DWORD timeNow = 0;

//#define TIMESYNC_DEBUG

void timeSync(void)

{

    BYTE i;

    signed char j; 

    static TICK         Timer;

    static TICK perodicTick = 0;

    static TICK t = 0;

    static TCP_SOCKET   MySocket = INVALID_SOCKET;

    static NODE_INFO    Server;

    static int arp_tries = 0;

    static int tcp_tries = 0;

    BYTE rcnt=0;

    BYTE ncnt=0;

    char foundData=0;

    if ((tickGet()-t) >= TICK_1S )

    {

        t = tickGet();

        timeNow++;

    }

    switch(smTS)

    {

        case SM_START:

            #if defined(TIMESYNC_DEBUG)

            putrsUART("Start!\r\n");

            #endif

            // Set IP adress to connect to.

            Server.IPAddr.v[0]=193;

            Server.IPAddr.v[1]=11;

            Server.IPAddr.v[2]=249;

            Server.IPAddr.v[3]=54;

            arp_tries = 0;

            tcp_tries = 0;

            smTS = SM_ARP_RESOLVE;

        break;

        case SM_ARP_RESOLVE:

            #if defined(TIMESYNC_DEBUG)

            putrsUART("Resolve..\r\n");

            #endif

            // If ARP is redy..

            if (ARPIsTxReady())

            {

                // Resolve the IP adress..

                ARPResolve(&Server.IPAddr);

                arp_tries++;

                Timer = tickGet();

                smTS = SM_ARP_RESOLVED;

            }

        break;

        case SM_ARP_RESOLVED:

            #if defined(TIMESYNC_DEBUG)

            putrsUART("Resolved..\r\n");

            #endif

            // If IP adress is resolved, go to next state

            if (ARPIsResolved(&Server.IPAddr, &Server.MACAddr))

            {

                smTS = SM_CONNECT;

            }

            // If not resolved and spent long time here,

            // Go back to previous state and re-resolve.

            else if (tickGet()-Timer > 1*TICK_1S)

            {

                smTS = SM_ARP_RESOLVE;

            }

            else if (arp_tries>=MAX_ARP_TRIES)

            {

                //Abort

                smTS = SM_ABORT;

            }

        break;

        case SM_CONNECT:

            #if defined(TIMESYNC_DEBUG)

            putrsUART("Connect..\r\n");

            #endif

            // We have an sucessfull ARP, connect..

            MySocket = TCPConnect(&Server, ServerPort);

            tcp_tries++;   

            if(MySocket == INVALID_SOCKET)

            {

                // Do something.

            }

            Timer = tickGet();

            smTS = SM_CONNECT_WAIT;

        break;

        case SM_CONNECT_WAIT:

            #if defined(TIMESYNC_DEBUG)

            putrsUART("Connect wait..\r\n");

            #endif

            // Wait for connection..

            if (TCPIsConnected(MySocket))

            {

                smTS = SM_CONNECTED;

            }

            // If not connected and spent long time here,

            // Go back to previous state and re-connect.

            else if (tickGet()-Timer > 5*TICK_1S)

            {

                TCPDisconnect(MySocket);

                MySocket = INVALID_SOCKET;

                smTS = SM_CONNECT;

            }

            else if (tcp_tries>=MAX_TCP_TRIES)

            {

                //Abort

                TCPDisconnect(MySocket);

                MySocket = INVALID_SOCKET;

                smTS = SM_ABORT;

            }

        break;

        case SM_CONNECTED:

            #if defined(TIMESYNC_DEBUG)

            putrsUART("Connected..\r\n");

            #endif

            // Send data.

            Timer = tickGet();

            if(TCPIsPutReady(MySocket))

            {

                TCPPut(MySocket, 'G');

                TCPPut(MySocket, 'E');

                TCPPut(MySocket, 'T');

                TCPPut(MySocket, ' ');

                TCPPut(MySocket, '/');

                TCPPut(MySocket, 't');

                TCPPut(MySocket, 'i');

                TCPPut(MySocket, 'm');

                TCPPut(MySocket, 'e');

                TCPPut(MySocket, '.');

                TCPPut(MySocket, 'p');

                TCPPut(MySocket, 'h');

                TCPPut(MySocket, 'p');

                TCPPut(MySocket, ' ');

                TCPPut(MySocket, 'H');

                TCPPut(MySocket, 'T');

                TCPPut(MySocket, 'T');

                TCPPut(MySocket, 'P');

                TCPPut(MySocket, '/');

                TCPPut(MySocket, '1');

                TCPPut(MySocket, '.');

                TCPPut(MySocket, '0');

                TCPPut(MySocket, '\r');

                TCPPut(MySocket, '\n');

                TCPPut(MySocket, '\r');

                TCPPut(MySocket, '\n');

                // Send the packet

                TCPFlush(MySocket);

                smTS = SM_RECEIVE;

            }

        break;

        case SM_RECEIVE:

            #if defined(TIMESYNC_DEBUG)

            putrsUART("Receive..\r\n");

            #endif

            // Client disconnected.

            if(!TCPIsConnected(MySocket))

            {

                smTS = SM_ABORT;

                break;

            }              

            if(TCPIsGetReady(MySocket))

            {

                while(TCPGet(MySocket, &i))

                {

                    if (i==CR) rcnt++;

                    else if(i==LF) ncnt++;

                    else

                    {

                        rcnt=0;

                        ncnt=0;

                    }

                    if (foundData==1)

                    {

                        if (j>=0)

                        {  

                            timeNow=timeNow+(((DWORD)i)<<(8*j--));

                            #if defined(TIMESYNC_DEBUG)

                            while(BusyUART()); WriteUART(i);

                            #endif

                        }

                    }

                    if(rcnt>1 && ncnt>1) {j=3; timeNow=0; foundData=1;}

                }

                smTS = SM_DISCONNECT;  

            }

        break;

        case SM_DISCONNECT:

            #if defined(TIMESYNC_DEBUG)

            putrsUART("\r\nDisconnect\r\n");

            #endif

            foundData=0;

            t = tickGet();

            lastSync = timeNow;

            perodicTick=tickGet();

            TCPDisconnect(MySocket);

            MySocket = INVALID_SOCKET;

            smTS = SM_DONE;

        break;

        case SM_ABORT:

            #if defined(TIMESYNC_DEBUG)

            putrsUART("Abort...\r\n");

            #endif

            smTS = SM_START;

        break;

        case SM_DONE:

            if (tickGet()-perodicTick > SYNC_INTERVAL*TICK_1S)

            {

                #if defined(TIMESYNC_DEBUG)

                putrsUART("GO!\r\n");

                #endif

                smTS = SM_START;

            }

        break;

        default: smTS = SM_START; break;

    }

}

DWORD getTime(timeClock tc)

{

    DWORD c;

    if (tc==CURRENT) c = timeNow;

    if (tc==LAST) c = lastSync;

    if (lastSync>0)

        return c;

    return 0;

}

DWORD getTimeStr(timeClock tc,char *str)

{

    DWORD c;

    char i;

    c = getTime(tc);

    dwordToHex(c,str);

    return c;

}

#endif