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	#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	#include "tcp.h"
11
12	#include <string.h>
13
14	bit bIsDhcpUp = 0;
15	char netlevel = 0;
16
17	// All TFTP command statuts display will be done on first line of LCD.
18	//#define TFTP_COMMAND_DISPLAY_LINE 0
19
20	// Result will be displayed at y = 15.
21	#define TFTP_COMMAND_RESULT_POSITION 15
22
23
24	/*#define STARTUP_MSG "G1_Build_0x00"
25
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	//ROM char blankLCDLine[] = " ";
36	*/
37	/*
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	/*****************************
75	Enummerations
76	****************************/
77	typedef enum _NetworkState
78	{
79	off,
80	DhcpIsBound,
81	ArpIsTxReady,
82	ArpIsResolved,
83	SockOpening,
84	SockOpen,
85	TcpReadyToSend,
86	TcpSend,
87	HelloDone,
88	StregkodeSendDone,
89	ReadyToRecieve,
90	StregkodeRecieveDone,
91	TotalRequested,
92	TotalRequestedDone,
93	ChangeRequested,
94	ChangeRequestedDone,
95	Acknowledged,
96	CancelDone,
97	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	unsigned long global_network_amount;
113	unsigned char global_network_char[16];
114	unsigned char global_network_charlen;
115
116
117	void network_init(void)
118	{
119	state = off;
120	}
121
122
123	void network_worker(void)
124	{
125	TickGet();
126	StackTask();
127	}
128
129	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	void network_wait(unsigned char n)
142	{
143	int i;
144	for (i=0; i<n; i++)
145	{
146	network_worker();
147	Delay10us(1);
148	}
149	}
150
151	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
173	//Request ID 0
174	char network_send_hello( unsigned char termid )
175	{
176	char gotArp = 0; // if gotArp is 0, the embedded haven't talked to the server since boot.
177	static char isBound = 0;
178
179	while( !DHCPIsBound() && isBound == 0 )
180	network_worker();
181
182	if ( DHCPIsBound() && isBound == 0 ){
183	state = DhcpIsBound;
184	isBound = 1;
185	}
186
187	while( state != HelloDone )
188	{
189	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	state = ArpIsResolved;
202	break;
203
204	case ArpIsResolved:
205	if ( ARPIsResolved(&rnode.IPAddr, &rnode.MACAddr) ){
206	state = SockOpening;
207	}
208	break;
209
210	case SockOpening:
211	tsock1 = TCPConnect (&rnode, 3000);
212	state = SockOpen;
213	break;
214
215	case SockOpen:
216	if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
217	state = TcpSend;
218	break;
219
220	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	}
230	return network_read_ack();
231	}
232
233	//Request ID 1
234	char network_send_scan_frame( unsigned char antal, unsigned char buflen )
235	{
236	char i;
237	char ack;
238
239	while( state != StregkodeSendDone ) //Sender vare-request-info pakke
240	{
241	switch (state)
242	{
243	case TcpReadyToSend:
244	if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
245	state = TcpSend;
246	case TcpSend:
247	TCPPut( tsock1, 0x01 );
248	TCPPut( tsock1, antal );
249	TCPPut( tsock1, buflen );
250	for (i = 0; i < buflen; i++)
251	{
252	TCPPut(tsock1, global_network_char[i] );
253	}
254	TCPFlush(tsock1);
255	state = StregkodeSendDone;
256	break;
257	}
258	network_worker();
259	}
260
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	return 0;
292	}
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	}
337
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	char network_send_goodbye(void)
421	{
422	char ack;
423	while( state != SockClosed)
424	{
425	switch (state)
426	{
427	case TcpReadyToSend:
428	if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
429	state = TcpSend;
430	break;
431
432	case TcpSend:
433	TCPPut( tsock1, 0x06 );
434	TCPFlush( tsock1 );
435	state = SockClosing;
436	break;
437
438	case SockClosing:
439	ack = network_read_ack();
440	TCPDisconnect( tsock1 );
441	state = SockClosed;
442	break;
443	}
444	network_worker();
445	}
446	if( TCPIsConnected(tsock1))
447	return 3; // Didn't close the socket properly;
448	else
449	return ack;
450
451	}
452	void network_wait_for_dhcp()
453	{
454	while (!DHCPIsBound())
455	network_worker();
456	}
457
458	void main(void)
459	{
460	// Tick to blink SYSTEM led.
461	static TICK t = 0;
462	TCP_SOCKET usock1;
463	char sock_state = 0;
464	char is_resolved = 0;
465	char has_arp = 0;
466
467
468	TICK tick;
469	TICK lastTick;
470	TICK diffTicks;
471
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
491	network_init();
492
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	unsigned char antal = 8;
518	unsigned char stregkode[] = "12345678";
519	/*
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
540
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	}
559	}
560
561	void interrupt HighISR(void)
562	{
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	// PORTA_RA5 = 0; // Disable LCD.
603
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