PIC/Demo%20trimmet/TFTPcDemo.c

#define THIS_IS_STACK_APPLICATION

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

#include <string.h>

bit bIsDhcpUp = 0;
char netlevel = 0;

// 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 SetConfig(void);

/*****************************
 Enummerations 
 ****************************/
typedef enum _NetworkState
{
        off,
        DhcpIsBound,
        ArpIsTxReady,
        ArpIsResolved,
        SockOpening,
        SockOpen,
        TcpReadyToSend,
        TcpSend,
        HelloDone,
        StregkodeSendDone,
        ReadyToRecieve,
        StregkodeRecieveDone,
        TotalRequested,
        TotalRequestedDone,
        ChangeRequested,
        ChangeRequestedDone,
        Acknowledged,
        CancelDone,
        SockClosing,
        SockClosed
} NetworkState;
 
/*****************************
 GLOBAL INIT
 ****************************/
NODE_INFO rnode;
NetworkState state;
TCP_SOCKET tsock1;

 
/*****************************
 network funktions
 ****************************/
unsigned long global_network_amount;
unsigned char global_network_char[16];
unsigned char global_network_charlen;


void network_init(void)
{
        state = off;
}       


void network_worker(void)
{    
        TickGet();
    StackTask();    
}       

void network_parse_amount(unsigned char buf[])
{
        global_network_amount = buf[0]<<24 + buf[1]<<16 + buf[2]<<8 + buf[3];
}       

void network_read_amount(void)
{
        unsigned char buf[4];
        TCPGetArray(tsock1, buf,4);
        network_parse_amount(buf);
}       

void network_wait(unsigned char n)
{
        int i;
        for (i=0; i<n; i++)
        {
                network_worker();
                Delay10us(1);
        }
}       

char network_read_ack(void)
{
        char ack;
        while(state != Acknowledged)
        {
                if (TCPIsGetReady(tsock1))
                {
                        TCPGet(tsock1, &ack);
                        TCPDiscard(tsock1);
                        state = Acknowledged;
                }
                network_worker();
        }
        
        state = TcpReadyToSend;
        
        if (ack == 1)
                return 0;
        else
                return 4;
}       

//Request ID 0
char network_send_hello( unsigned char termid )
{
        char gotArp = 0;                // if gotArp is 0, the embedded haven't talked to the server since boot.
        static char isBound = 0;

        while( !DHCPIsBound() && isBound == 0 )
                network_worker();

        if ( DHCPIsBound() && isBound == 0 ){
                state = DhcpIsBound;
                isBound = 1;
        }
        
        while( state != HelloDone )
        {
                switch (state)
                {
                        case DhcpIsBound:
                                if ( ARPIsTxReady() && gotArp == 0 )
                                        state = ArpIsTxReady;
                                else 
                                        state = ArpIsResolved;
                                break;
                        
                        case ArpIsTxReady:
                                ARPResolve(&rnode.IPAddr);
                                gotArp = 1;
                                state = ArpIsResolved;
                                break;
                                                
                        case ArpIsResolved:
                                if ( ARPIsResolved(&rnode.IPAddr, &rnode.MACAddr) ){
                                        state = SockOpening;
                                }
                                break;
                        
                        case SockOpening:
                                tsock1 = TCPConnect (&rnode, 3000);
                                state = SockOpen;
                                break;
                
                        case SockOpen:
                                if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
                                        state = TcpSend;
                                break;
                        
                        case TcpSend:
                                TCPPut( tsock1, 0x00 );
                                TCPPut( tsock1, termid );
                                TCPFlush(tsock1);
                                //TCPDiscard( tsock1 );
                                state = HelloDone;
                                break;
                }
                network_worker();
        }
        return network_read_ack();
}

//Request ID 1
char network_send_scan_frame( unsigned char antal, unsigned char buflen )
{
        char i;
        char ack;

        while( state != StregkodeSendDone ) //Sender vare-request-info pakke
        {
                switch (state)
                {
                        case TcpReadyToSend:
                                if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
                                state = TcpSend;
                        case TcpSend:
                                TCPPut( tsock1, 0x01 );
                                TCPPut( tsock1, antal );
                                TCPPut( tsock1, buflen );
                                for (i = 0; i < buflen; i++)
                                { 
                                        TCPPut(tsock1, global_network_char[i] );
                                }
                                TCPFlush(tsock1);
                                state = StregkodeSendDone;
                                break;
                }
                network_worker();
        }
        
        while( state != StregkodeRecieveDone ) //venter p� svar og parser denne
        {
                switch( state )
                {
                        case StregkodeSendDone:
                                if( TCPIsGetReady(tsock1) )
                                        state = ReadyToRecieve;
                                break;
                        case ReadyToRecieve:
                                TCPGet( tsock1, &ack );
                                
                                if (ack == 0)
                                {
                                        state = TcpReadyToSend;
                                        TCPDiscard(tsock1);
                                        return 4;
                                }
                                
                                network_read_amount();
                                TCPGet( tsock1, &global_network_charlen);
                                TCPGetArray( tsock1, global_network_char, global_network_charlen);
                                TCPDiscard(tsock1);
                                
                                state = StregkodeRecieveDone;                           
                                        
                                break;
                }
                network_worker();
        }
        state = TcpReadyToSend;
        return 0;
}

//Request ID 2
char network_send_calc_total(void)
{
        unsigned char ack;
        while(state != TotalRequested)
        {
                switch(state)
                {
                        case TcpReadyToSend: 
                                if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
                                        state = TcpSend;
                                break;
                                
                        case TcpSend:
                                TCPPut(tsock1, 0x02);
                                TCPFlush(tsock1);
                                state = TotalRequested;
                                break;
                }
                network_worker();
        }
        
        while (state != TotalRequestedDone)
        {
                if (TCPIsGetReady(tsock1))
                {
                        TCPGet(tsock1, &ack);
                        if (ack == 0)
                        {
                                TCPDiscard(tsock1);
                                state = TcpReadyToSend;
                                return 4;
                        }
                        network_read_amount();
                        TCPDiscard(tsock1);
                        state = TotalRequestedDone;
                }
                network_worker();
        }
        
        state = TcpReadyToSend;
        return 0;
}       

//Request ID 3
char network_send_cash_payed(unsigned long amount)
{
        unsigned char ack;
        while (state != ChangeRequested)
        {
                switch(state)
                {
                        case TcpReadyToSend: 
                                if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
                                        state = TcpSend;
                                break;
                        case TcpSend:
                                TCPPut(tsock1, 0x03);
                                TCPPut(tsock1, amount>>24);
                                TCPPut(tsock1, amount>>16);
                                TCPPut(tsock1, amount>>8);
                                TCPPut(tsock1, amount);
                                TCPFlush(tsock1);
                                state = ChangeRequested;        
                                break;
                }
                network_worker();
        }
        
        while (state != ChangeRequestedDone)
        {
                if (TCPIsGetReady(tsock1))
                {
                        TCPGet(tsock1, &ack);
                        if (ack == 0)
                        {
                                TCPFlush(tsock1);
                                state = TcpReadyToSend;
                                return 4;
                        }
                        network_read_amount(); 
                        TCPFlush(tsock1);
                        state = ChangeRequestedDone;
                        
                }
                network_worker();
        }
        state = TcpReadyToSend;
        return 0;
}

//request 4+5
char network_send_cancel_generic(char id)
{
        while(state != CancelDone)
        {
                switch (state)
                {
                        case TcpReadyToSend: 
                                if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
                                        state = TcpSend;
                                break;
                        case TcpSend:
                                TCPPut(tsock1, id);
                                TCPFlush(tsock1);
                                state = CancelDone;

                }
                network_worker();
        }
        return network_read_ack();
}       

//Request ID 4
char network_send_cancel_last(void)
{
        return network_send_cancel_generic(0x04);       
}

//Request ID 5
char network_send_cancel_all(void)
{
        return network_send_cancel_generic(0x05);
}       

//Request ID 6
char network_send_goodbye(void)
{
        char ack;
        while( state != SockClosed)
        {
                switch (state)
                {
                        case TcpReadyToSend: 
                                if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
                                        state = TcpSend;
                                break;
                                
                        case TcpSend:
                                TCPPut( tsock1, 0x06 );
                                TCPFlush( tsock1 );
                                state = SockClosing;
                                break;
                        
                        case SockClosing:
                                ack = network_read_ack();
                                TCPDisconnect( tsock1 );
                                state = SockClosed;
                                break;
                }
                network_worker();
        }
        if( TCPIsConnected(tsock1))
                return 3;                               // Didn't close the socket properly;
        else
                return ack;
        
}       
void network_wait_for_dhcp()
{
        while (!DHCPIsBound())
                network_worker();
}       

void main(void)
{
    // Tick to blink SYSTEM led.
    static TICK t = 0;
    TCP_SOCKET usock1;
    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();
    
    network_init();


    /*
     * 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;

    while(1)
    {
            unsigned char antal = 8;
            unsigned char stregkode[] = "12345678";
        /*
         * 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.
         */
         
         
                    network_send_hello( 0x01 );
                    
                    strncpy(global_network_char, "12345678", 8);
                        network_send_scan_frame( 1, 8 ); //1x vare, stregkodel�ngde=8
                        
                        strncpy(global_network_char, "87654444", 8);
                        network_send_scan_frame( 1, 8 ); //1x vare, stregkodel�ngde=8
                        
                        network_send_calc_total();
                        
                        network_send_cash_payed(50000);
                        
                        network_send_cancel_last();
                        
                        network_send_cancel_all();
                                                
                        network_send_goodbye();
    }
}

void interrupt HighISR(void)
{
    TickUpdate();
}

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

/*********************************************************************
 * 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;

    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);
}

1	hedin	91	#define THIS_IS_STACK_APPLICATION
2
3			#include "stacktsk.h"
4			#include "dhcp.h"
5			#include "tick.h"
6			#include "delay.h"
7			#include "udp.h"
8			#include "arp.h"
9			#include "arptsk.h"
10	hedin	93	#include "tcp.h"
11	hedin	91
12	hedin	105	#include <string.h>
13
14	hedin	96	bit bIsDhcpUp = 0;
15	hedin	102	char netlevel = 0;
16	hedin	91
17			// All TFTP command statuts display will be done on first line of LCD.
18	hedin	96	//#define TFTP_COMMAND_DISPLAY_LINE 0
19	hedin	91
20			// Result will be displayed at y = 15.
21			#define TFTP_COMMAND_RESULT_POSITION 15
22
23
24	hedin	102	/*#define STARTUP_MSG "G1_Build_0x00"
25	hedin	91
26			ROM char StartupMsg[] = STARTUP_MSG;
27
28			#if defined(STACK_USE_DHCP) \|\| defined(STACK_USE_IP_GLEANING)
29			ROM char DHCPMsg[] = "DHCP/Gleaning...";
30			#endif
31
32			ROM char SetupMsg[] = "Board Setup...";
33
34			// 1234567890123456
35	hedin	96	//ROM char blankLCDLine[] = " ";
36	hedin	102	*/
37	hedin	91	/*
38			* This is used by other stack elements.
39			* Main application must define this and initialize it with
40			* proper values.
41			*/
42			APP_CONFIG AppConfig;
43
44
45			BYTE myDHCPBindCount = 0;
46			#if defined(STACK_USE_DHCP)
47			extern BYTE DHCPBindCount;
48			#else
49			/*
50			* If DHCP is not enabled, force DHCP update.
51			*/
52			BYTE DHCPBindCount = 1;
53			#endif
54
55			/*
56			* Set configuration fuses for HITECH compiler.
57			* For MCC18 compiler, separately linked config.asm file
58			* will set the correct fuses.
59			*/
60			#if defined(HITECH_C18)
61			__CONFIG(1, UNPROTECT & HS);
62			__CONFIG(2, PWRTEN & BORDIS & WDTDIS);
63			#endif
64
65
66			/*
67			* Private helper functions.
68			* These may or may not be present in all applications.
69			*/
70			static void InitAppConfig(void);
71			static void InitializeBoard(void);
72			static void SetConfig(void);
73
74	hedin	96	/*****************************
75			Enummerations
76			****************************/
77			typedef enum _NetworkState
78	hedin	93	{
79	hedin	96	off,
80			DhcpIsBound,
81			ArpIsTxReady,
82			ArpIsResolved,
83			SockOpening,
84			SockOpen,
85			TcpReadyToSend,
86			TcpSend,
87	hedin	102	HelloDone,
88	hedin	105	StregkodeSendDone,
89			ReadyToRecieve,
90			StregkodeRecieveDone,
91			TotalRequested,
92			TotalRequestedDone,
93			ChangeRequested,
94			ChangeRequestedDone,
95			Acknowledged,
96			CancelDone,
97	hedin	96	SockClosing,
98			SockClosed
99			} NetworkState;
100
101			/*****************************
102			GLOBAL INIT
103			****************************/
104			NODE_INFO rnode;
105			NetworkState state;
106			TCP_SOCKET tsock1;
107
108
109			/*****************************
110			network funktions
111			****************************/
112	hedin	105	unsigned long global_network_amount;
113			unsigned char global_network_char[16];
114			unsigned char global_network_charlen;
115	hedin	96
116
117			void network_init(void)
118			{
119			state = off;
120			}
121	hedin	98
122
123	hedin	102	void network_worker(void)
124			{
125			TickGet();
126			StackTask();
127			}
128
129	hedin	105	void network_parse_amount(unsigned char buf[])
130			{
131			global_network_amount = buf[0]<<24 + buf[1]<<16 + buf[2]<<8 + buf[3];
132			}
133
134			void network_read_amount(void)
135			{
136			unsigned char buf[4];
137			TCPGetArray(tsock1, buf,4);
138			network_parse_amount(buf);
139			}
140
141	hedin	102	void network_wait(unsigned char n)
142			{
143			int i;
144			for (i=0; i<n; i++)
145			{
146			network_worker();
147	hedin	105	Delay10us(1);
148	hedin	102	}
149			}
150
151	hedin	105	char network_read_ack(void)
152			{
153			char ack;
154			while(state != Acknowledged)
155			{
156			if (TCPIsGetReady(tsock1))
157			{
158			TCPGet(tsock1, &ack);
159			TCPDiscard(tsock1);
160			state = Acknowledged;
161			}
162			network_worker();
163			}
164
165			state = TcpReadyToSend;
166
167			if (ack == 1)
168			return 0;
169			else
170			return 4;
171			}
172	hedin	102
173	hedin	105	//Request ID 0
174	hedin	96	char network_send_hello( unsigned char termid )
175			{
176	hedin	105	char gotArp = 0; // if gotArp is 0, the embedded haven't talked to the server since boot.
177			static char isBound = 0;
178	hedin	102
179	hedin	105	while( !DHCPIsBound() && isBound == 0 )
180			network_worker();
181	hedin	102
182	hedin	105	if ( DHCPIsBound() && isBound == 0 ){
183			state = DhcpIsBound;
184			isBound = 1;
185	hedin	98	}
186	hedin	105
187	hedin	102	while( state != HelloDone )
188	hedin	96	{
189	hedin	102	switch (state)
190			{
191			case DhcpIsBound:
192			if ( ARPIsTxReady() && gotArp == 0 )
193			state = ArpIsTxReady;
194			else
195			state = ArpIsResolved;
196			break;
197
198			case ArpIsTxReady:
199			ARPResolve(&rnode.IPAddr);
200			gotArp = 1;
201	hedin	96	state = ArpIsResolved;
202	hedin	102	break;
203
204			case ArpIsResolved:
205			if ( ARPIsResolved(&rnode.IPAddr, &rnode.MACAddr) ){
206			state = SockOpening;
207	hedin	96	}
208	hedin	102	break;
209
210			case SockOpening:
211			tsock1 = TCPConnect (&rnode, 3000);
212			state = SockOpen;
213			break;
214	hedin	96
215	hedin	102	case SockOpen:
216			if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
217			state = TcpSend;
218			break;
219	hedin	98
220	hedin	102	case TcpSend:
221			TCPPut( tsock1, 0x00 );
222			TCPPut( tsock1, termid );
223			TCPFlush(tsock1);
224			//TCPDiscard( tsock1 );
225			state = HelloDone;
226			break;
227			}
228			network_worker();
229	hedin	96	}
230	hedin	105	return network_read_ack();
231	hedin	96	}
232	hedin	98
233	hedin	105	//Request ID 1
234			char network_send_scan_frame( unsigned char antal, unsigned char buflen )
235	hedin	96	{
236	hedin	105	char i;
237			char ack;
238
239			while( state != StregkodeSendDone ) //Sender vare-request-info pakke
240	hedin	98	{
241	hedin	102	switch (state)
242			{
243	hedin	105	case TcpReadyToSend:
244	hedin	102	if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
245			state = TcpSend;
246			case TcpSend:
247			TCPPut( tsock1, 0x01 );
248	hedin	105	TCPPut( tsock1, antal );
249			TCPPut( tsock1, buflen );
250	hedin	102	for (i = 0; i < buflen; i++)
251			{
252	hedin	105	TCPPut(tsock1, global_network_char[i] );
253	hedin	102	}
254			TCPFlush(tsock1);
255	hedin	105	state = StregkodeSendDone;
256	hedin	102	break;
257			}
258			network_worker();
259	hedin	98	}
260	hedin	105
261			while( state != StregkodeRecieveDone ) //venter p� svar og parser denne
262			{
263			switch( state )
264			{
265			case StregkodeSendDone:
266			if( TCPIsGetReady(tsock1) )
267			state = ReadyToRecieve;
268			break;
269			case ReadyToRecieve:
270			TCPGet( tsock1, &ack );
271
272			if (ack == 0)
273			{
274			state = TcpReadyToSend;
275			TCPDiscard(tsock1);
276			return 4;
277			}
278
279			network_read_amount();
280			TCPGet( tsock1, &global_network_charlen);
281			TCPGetArray( tsock1, global_network_char, global_network_charlen);
282			TCPDiscard(tsock1);
283
284			state = StregkodeRecieveDone;
285
286			break;
287			}
288			network_worker();
289			}
290			state = TcpReadyToSend;
291	hedin	102	return 0;
292	hedin	105	}
293
294			//Request ID 2
295			char network_send_calc_total(void)
296			{
297			unsigned char ack;
298			while(state != TotalRequested)
299			{
300			switch(state)
301			{
302			case TcpReadyToSend:
303			if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
304			state = TcpSend;
305			break;
306
307			case TcpSend:
308			TCPPut(tsock1, 0x02);
309			TCPFlush(tsock1);
310			state = TotalRequested;
311			break;
312			}
313			network_worker();
314			}
315
316			while (state != TotalRequestedDone)
317			{
318			if (TCPIsGetReady(tsock1))
319			{
320			TCPGet(tsock1, &ack);
321			if (ack == 0)
322			{
323			TCPDiscard(tsock1);
324			state = TcpReadyToSend;
325			return 4;
326			}
327			network_read_amount();
328			TCPDiscard(tsock1);
329			state = TotalRequestedDone;
330			}
331			network_worker();
332			}
333
334			state = TcpReadyToSend;
335			return 0;
336	hedin	98	}
337	hedin	105
338			//Request ID 3
339			char network_send_cash_payed(unsigned long amount)
340			{
341			unsigned char ack;
342			while (state != ChangeRequested)
343			{
344			switch(state)
345			{
346			case TcpReadyToSend:
347			if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
348			state = TcpSend;
349			break;
350			case TcpSend:
351			TCPPut(tsock1, 0x03);
352			TCPPut(tsock1, amount>>24);
353			TCPPut(tsock1, amount>>16);
354			TCPPut(tsock1, amount>>8);
355			TCPPut(tsock1, amount);
356			TCPFlush(tsock1);
357			state = ChangeRequested;
358			break;
359			}
360			network_worker();
361			}
362
363			while (state != ChangeRequestedDone)
364			{
365			if (TCPIsGetReady(tsock1))
366			{
367			TCPGet(tsock1, &ack);
368			if (ack == 0)
369			{
370			TCPFlush(tsock1);
371			state = TcpReadyToSend;
372			return 4;
373			}
374			network_read_amount();
375			TCPFlush(tsock1);
376			state = ChangeRequestedDone;
377
378			}
379			network_worker();
380			}
381			state = TcpReadyToSend;
382			return 0;
383			}
384
385			//request 4+5
386			char network_send_cancel_generic(char id)
387			{
388			while(state != CancelDone)
389			{
390			switch (state)
391			{
392			case TcpReadyToSend:
393			if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
394			state = TcpSend;
395			break;
396			case TcpSend:
397			TCPPut(tsock1, id);
398			TCPFlush(tsock1);
399			state = CancelDone;
400
401			}
402			network_worker();
403			}
404			return network_read_ack();
405			}
406
407			//Request ID 4
408			char network_send_cancel_last(void)
409			{
410			return network_send_cancel_generic(0x04);
411			}
412
413			//Request ID 5
414			char network_send_cancel_all(void)
415			{
416			return network_send_cancel_generic(0x05);
417			}
418
419			//Request ID 6
420	hedin	98	char network_send_goodbye(void)
421			{
422	hedin	105	char ack;
423	hedin	102	while( state != SockClosed)
424	hedin	98	{
425	hedin	102	switch (state)
426			{
427	hedin	105	case TcpReadyToSend:
428	hedin	102	if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
429	hedin	105	state = TcpSend;
430	hedin	102	break;
431
432			case TcpSend:
433			TCPPut( tsock1, 0x06 );
434			TCPFlush( tsock1 );
435			state = SockClosing;
436			break;
437	hedin	98
438	hedin	102	case SockClosing:
439	hedin	105	ack = network_read_ack();
440	hedin	102	TCPDisconnect( tsock1 );
441			state = SockClosed;
442			break;
443			}
444			network_worker();
445	hedin	98	}
446	hedin	105	if( TCPIsConnected(tsock1))
447	hedin	102	return 3; // Didn't close the socket properly;
448			else
449	hedin	105	return ack;
450	hedin	102
451	hedin	98	}
452	hedin	102	void network_wait_for_dhcp()
453			{
454			while (!DHCPIsBound())
455			network_worker();
456			}
457	hedin	93
458	hedin	91	void main(void)
459			{
460			// Tick to blink SYSTEM led.
461			static TICK t = 0;
462	hedin	93	TCP_SOCKET usock1;
463			char sock_state = 0;
464	hedin	91	char is_resolved = 0;
465	hedin	93	char has_arp = 0;
466	hedin	102
467	hedin	91
468	hedin	93	TICK tick;
469			TICK lastTick;
470			TICK diffTicks;
471	hedin	91
472			/*
473			* Initialize any application specific hardware.
474			*/
475			InitializeBoard();
476
477			/*
478			* Initialize all stack related components.
479			* Following steps must be performed for all applications using
480			* PICmicro TCP/IP Stack.
481			*/
482			TickInit();
483
484			/*
485			* Initialize Stack and application related NV variables.
486			*/
487			InitAppConfig();
488
489			StackInit();
490	hedin	96
491			network_init();
492	hedin	91
493
494
495			/*
496			* Once all items are initialized, go into infinite loop and let
497			* stack items execute their tasks.
498			* If application needs to perform its own task, it should be
499			* done at the end of while loop.
500			* Note that this is a "co-operative mult-tasking" mechanism
501			* where every task performs its tasks (whether all in one shot
502			* or part of it) and returns so that other tasks can do their
503			* job.
504			* If a task needs very long time to do its job, it must broken
505			* down into smaller pieces so that other tasks can have CPU time.
506			*/
507
508
509			// Defines the IP add. on the server machine
510			rnode.IPAddr.v[0] = 192;
511			rnode.IPAddr.v[1] = 168;
512			rnode.IPAddr.v[2] = 1;
513			rnode.IPAddr.v[3] = 20;
514
515			while(1)
516			{
517	hedin	98	unsigned char antal = 8;
518			unsigned char stregkode[] = "12345678";
519	hedin	91	/*
520			* Blink SYSTEM LED every second.
521			*/
522			if ( TickGetDiff(TickGet(), t) >= TICK_SECOND/2 )
523			{
524			t = TickGet();
525			LATA4 ^= 1;
526			}
527
528			/*
529			* This task performs normal stack task including checking
530			* for incoming packet, type of packet and calling
531			* appropriate stack entity to process it.
532			*/
533			StackTask();
534
535			/*
536			* For DHCP information, display how many times we have renewed the IP
537			* configuration since last reset.
538			*/
539	hedin	102
540	hedin	105
541			network_send_hello( 0x01 );
542
543			strncpy(global_network_char, "12345678", 8);
544			network_send_scan_frame( 1, 8 ); //1x vare, stregkodel�ngde=8
545
546			strncpy(global_network_char, "87654444", 8);
547			network_send_scan_frame( 1, 8 ); //1x vare, stregkodel�ngde=8
548
549			network_send_calc_total();
550
551			network_send_cash_payed(50000);
552
553			network_send_cancel_last();
554
555			network_send_cancel_all();
556
557			network_send_goodbye();
558	hedin	91	}
559			}
560
561	hedin	102	void interrupt HighISR(void)
562	hedin	91	{
563			TickUpdate();
564			}
565
566			#if defined(MCHP_C18)
567			#pragma code highVector=0x08
568			void HighVector (void)
569			{
570			_asm goto HighISR _endasm
571			}
572			#pragma code /* return to default code section */
573			#endif
574
575			/*********************************************************************
576			* Function: void InitializeBoard(void)
577			*
578			* PreCondition: None
579			*
580			* Input: None
581			*
582			* Output: None
583			*
584			* Side Effects: None
585			*
586			* Overview: Initialize board specific hardware.
587			*
588			* Note: None
589			********************************************************************/
590			static void InitializeBoard(void)
591			{
592			/*
593			* Setup for PORTA.RA0 as analog input while rests
594			* as digital i/o lines.
595			*/
596			ADCON1 = 0b10001110; // RA0 as analog input, Right justified
597			TRISA = 0x03;
598
599			/*
600			* LCD is enabled using RA5.
601			*/
602	hedin	96	// PORTA_RA5 = 0; // Disable LCD.
603	hedin	91
604			/*
605			* Turn off the LED's.
606			*/
607			LATA2 = 1;
608			LATA3 = 1;
609
610			/*
611			* External data EEPROM needs pull-ups, so enable internal
612			* pull-ups.
613			*/
614			INTCON2_RBPU = 0;
615
616			T0CON = 0;
617			INTCON_GIEH = 1;
618			INTCON_GIEL = 1;
619
620			}
621
622			/*********************************************************************
623			* Function: void InitAppConfig(void)
624			*
625			* PreCondition: MPFSInit() is already called.
626			*
627			* Input: None
628			*
629			* Output: Write/Read non-volatile config variables.
630			*
631			* Side Effects: None
632			*
633			* Overview: None
634			*
635			* Note: None
636			********************************************************************/
637			static void InitAppConfig(void)
638			{
639			/*
640			* Load default configuration into RAM.
641			*/
642			AppConfig.MyIPAddr.v[0] = MY_DEFAULT_IP_ADDR_BYTE1;
643			AppConfig.MyIPAddr.v[1] = MY_DEFAULT_IP_ADDR_BYTE2;
644			AppConfig.MyIPAddr.v[2] = MY_DEFAULT_IP_ADDR_BYTE3;
645			AppConfig.MyIPAddr.v[3] = MY_DEFAULT_IP_ADDR_BYTE4;
646
647			AppConfig.MyMask.v[0] = MY_DEFAULT_MASK_BYTE1;
648			AppConfig.MyMask.v[1] = MY_DEFAULT_MASK_BYTE2;
649			AppConfig.MyMask.v[2] = MY_DEFAULT_MASK_BYTE3;
650			AppConfig.MyMask.v[3] = MY_DEFAULT_MASK_BYTE4;
651
652			AppConfig.MyGateway.v[0] = MY_DEFAULT_GATE_BYTE1;
653			AppConfig.MyGateway.v[1] = MY_DEFAULT_GATE_BYTE2;
654			AppConfig.MyGateway.v[2] = MY_DEFAULT_GATE_BYTE3;
655			AppConfig.MyGateway.v[3] = MY_DEFAULT_GATE_BYTE4;
656
657			AppConfig.MyMACAddr.v[0] = MY_DEFAULT_MAC_BYTE1;
658			AppConfig.MyMACAddr.v[1] = MY_DEFAULT_MAC_BYTE2;
659			AppConfig.MyMACAddr.v[2] = MY_DEFAULT_MAC_BYTE3;
660			AppConfig.MyMACAddr.v[3] = MY_DEFAULT_MAC_BYTE4;
661			AppConfig.MyMACAddr.v[4] = MY_DEFAULT_MAC_BYTE5;
662			AppConfig.MyMACAddr.v[5] = MY_DEFAULT_MAC_BYTE6;
663
664			#if defined(STACK_USE_DHCP)
665			AppConfig.Flags.bIsDHCPEnabled = TRUE;
666			#else
667			AppConfig.Flags.bIsDHCPEnabled = FALSE;
668			#endif
669			}
670
671			BOOL StringToIPAddress(char str, IP_ADDR buffer)
672			{
673			BYTE v;
674			char *temp;
675			BYTE byteIndex;
676
677			temp = str;
678			byteIndex = 0;
679
680			while( v = *str )
681			{
682			if ( v == '.' )
683			{
684			*str++ = '\0';
685			buffer->v[byteIndex++] = atoi(temp);
686			temp = str;
687			}
688			else if ( v < '0' \|\| v > '9' )
689			return FALSE;
690
691			str++;
692			}
693
694			buffer->v[byteIndex] = atoi(temp);
695
696			return (byteIndex == 3);
697			}
698