PIC/Demo%20trimmet/network.c


#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 "network.h"


/*****************************
 GLOBAL vars
 ****************************/
NODE_INFO rnode;
NetworkState state;
TCP_SOCKET tsock1;

 
unsigned long global_network_amount;
unsigned char global_network_char[16];
unsigned char global_network_charlen;


/*****************************
 network funktions
 ****************************/


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

1	hedin	106
2			#include "stacktsk.h"
3			#include "dhcp.h"
4			#include "tick.h"
5			#include "delay.h"
6			#include "udp.h"
7			#include "arp.h"
8			#include "arptsk.h"
9			#include "tcp.h"
10			#include "network.h"
11
12
13
14
15			/*****************************
16			GLOBAL vars
17			****************************/
18			NODE_INFO rnode;
19			NetworkState state;
20			TCP_SOCKET tsock1;
21
22
23			unsigned long global_network_amount;
24			unsigned char global_network_char[16];
25			unsigned char global_network_charlen;
26
27
28			/*****************************
29			network funktions
30			****************************/
31
32
33			void network_init(void)
34			{
35			state = off;
36			}
37
38
39			void network_worker(void)
40			{
41			TickGet();
42			StackTask();
43			}
44
45			void network_parse_amount(unsigned char buf[])
46			{
47			global_network_amount = buf[0]<<24 + buf[1]<<16 + buf[2]<<8 + buf[3];
48			}
49
50			void network_read_amount(void)
51			{
52			unsigned char buf[4];
53			TCPGetArray(tsock1, buf,4);
54			network_parse_amount(buf);
55			}
56
57			void network_wait(unsigned char n)
58			{
59			int i;
60			for (i=0; i<n; i++)
61			{
62			network_worker();
63			Delay10us(1);
64			}
65			}
66
67			char network_read_ack(void)
68			{
69			char ack;
70			while(state != Acknowledged)
71			{
72			if (TCPIsGetReady(tsock1))
73			{
74			TCPGet(tsock1, &ack);
75			TCPDiscard(tsock1);
76			state = Acknowledged;
77			}
78			network_worker();
79			}
80
81			state = TcpReadyToSend;
82
83			if (ack == 1)
84			return 0;
85			else
86			return 4;
87			}
88
89			//Request ID 0
90			char network_send_hello( unsigned char termid )
91			{
92			char gotArp = 0; // if gotArp is 0, the embedded haven't talked to the server since boot.
93			static char isBound = 0;
94
95			while( !DHCPIsBound() && isBound == 0 )
96			network_worker();
97
98			if ( DHCPIsBound() && isBound == 0 ){
99			state = DhcpIsBound;
100			isBound = 1;
101			}
102
103			while( state != HelloDone )
104			{
105			switch (state)
106			{
107			case DhcpIsBound:
108			if ( ARPIsTxReady() && gotArp == 0 )
109			state = ArpIsTxReady;
110			else
111			state = ArpIsResolved;
112			break;
113
114			case ArpIsTxReady:
115			ARPResolve(&rnode.IPAddr);
116			gotArp = 1;
117			state = ArpIsResolved;
118			break;
119
120			case ArpIsResolved:
121			if ( ARPIsResolved(&rnode.IPAddr, &rnode.MACAddr) ){
122			state = SockOpening;
123			}
124			break;
125
126			case SockOpening:
127			tsock1 = TCPConnect (&rnode, 3000);
128			state = SockOpen;
129			break;
130
131			case SockOpen:
132			if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
133			state = TcpSend;
134			break;
135
136			case TcpSend:
137			TCPPut( tsock1, 0x00 );
138			TCPPut( tsock1, termid );
139			TCPFlush(tsock1);
140			//TCPDiscard( tsock1 );
141			state = HelloDone;
142			break;
143			}
144			network_worker();
145			}
146			return network_read_ack();
147			}
148
149			//Request ID 1
150			char network_send_scan_frame( unsigned char antal, unsigned char buflen )
151			{
152			char i;
153			char ack;
154
155			while( state != StregkodeSendDone ) //Sender vare-request-info pakke
156			{
157			switch (state)
158			{
159			case TcpReadyToSend:
160			if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
161			state = TcpSend;
162			case TcpSend:
163			TCPPut( tsock1, 0x01 );
164			TCPPut( tsock1, antal );
165			TCPPut( tsock1, buflen );
166			for (i = 0; i < buflen; i++)
167			{
168			TCPPut(tsock1, global_network_char[i] );
169			}
170			TCPFlush(tsock1);
171			state = StregkodeSendDone;
172			break;
173			}
174			network_worker();
175			}
176
177			while( state != StregkodeRecieveDone ) //venter p� svar og parser denne
178			{
179			switch( state )
180			{
181			case StregkodeSendDone:
182			if( TCPIsGetReady(tsock1) )
183			state = ReadyToRecieve;
184			break;
185			case ReadyToRecieve:
186			TCPGet( tsock1, &ack );
187
188			if (ack == 0)
189			{
190			state = TcpReadyToSend;
191			TCPDiscard(tsock1);
192			return 4;
193			}
194
195			network_read_amount();
196			TCPGet( tsock1, &global_network_charlen);
197			TCPGetArray( tsock1, global_network_char, global_network_charlen);
198			TCPDiscard(tsock1);
199
200			state = StregkodeRecieveDone;
201
202			break;
203			}
204			network_worker();
205			}
206			state = TcpReadyToSend;
207			return 0;
208			}
209
210			//Request ID 2
211			char network_send_calc_total(void)
212			{
213			unsigned char ack;
214			while(state != TotalRequested)
215			{
216			switch(state)
217			{
218			case TcpReadyToSend:
219			if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
220			state = TcpSend;
221			break;
222
223			case TcpSend:
224			TCPPut(tsock1, 0x02);
225			TCPFlush(tsock1);
226			state = TotalRequested;
227			break;
228			}
229			network_worker();
230			}
231
232			while (state != TotalRequestedDone)
233			{
234			if (TCPIsGetReady(tsock1))
235			{
236			TCPGet(tsock1, &ack);
237			if (ack == 0)
238			{
239			TCPDiscard(tsock1);
240			state = TcpReadyToSend;
241			return 4;
242			}
243			network_read_amount();
244			TCPDiscard(tsock1);
245			state = TotalRequestedDone;
246			}
247			network_worker();
248			}
249
250			state = TcpReadyToSend;
251			return 0;
252			}
253
254			//Request ID 3
255			char network_send_cash_payed(unsigned long amount)
256			{
257			unsigned char ack;
258			while (state != ChangeRequested)
259			{
260			switch(state)
261			{
262			case TcpReadyToSend:
263			if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
264			state = TcpSend;
265			break;
266			case TcpSend:
267			TCPPut(tsock1, 0x03);
268			TCPPut(tsock1, amount>>24);
269			TCPPut(tsock1, amount>>16);
270			TCPPut(tsock1, amount>>8);
271			TCPPut(tsock1, amount);
272			TCPFlush(tsock1);
273			state = ChangeRequested;
274			break;
275			}
276			network_worker();
277			}
278
279			while (state != ChangeRequestedDone)
280			{
281			if (TCPIsGetReady(tsock1))
282			{
283			TCPGet(tsock1, &ack);
284			if (ack == 0)
285			{
286			TCPFlush(tsock1);
287			state = TcpReadyToSend;
288			return 4;
289			}
290			network_read_amount();
291			TCPFlush(tsock1);
292			state = ChangeRequestedDone;
293
294			}
295			network_worker();
296			}
297			state = TcpReadyToSend;
298			return 0;
299			}
300
301			//request 4+5
302			char network_send_cancel_generic(char id)
303			{
304			while(state != CancelDone)
305			{
306			switch (state)
307			{
308			case TcpReadyToSend:
309			if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
310			state = TcpSend;
311			break;
312			case TcpSend:
313			TCPPut(tsock1, id);
314			TCPFlush(tsock1);
315			state = CancelDone;
316
317			}
318			network_worker();
319			}
320			return network_read_ack();
321			}
322
323			//Request ID 4
324			char network_send_cancel_last(void)
325			{
326			return network_send_cancel_generic(0x04);
327			}
328
329			//Request ID 5
330			char network_send_cancel_all(void)
331			{
332			return network_send_cancel_generic(0x05);
333			}
334
335			//Request ID 6
336			char network_send_goodbye(void)
337			{
338			char ack;
339			while( state != SockClosed)
340			{
341			switch (state)
342			{
343			case TcpReadyToSend:
344			if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
345			state = TcpSend;
346			break;
347
348			case TcpSend:
349			TCPPut( tsock1, 0x06 );
350			TCPFlush( tsock1 );
351			state = SockClosing;
352			break;
353
354			case SockClosing:
355			ack = network_read_ack();
356			TCPDisconnect( tsock1 );
357			state = SockClosed;
358			break;
359			}
360			network_worker();
361			}
362			if( TCPIsConnected(tsock1))
363			return 3; // Didn't close the socket properly;
364			else
365			return ack;
366
367			}
368			void network_wait_for_dhcp()
369			{
370			while (!DHCPIsBound())
371			network_worker();
372			}
373