Microchip%20TCP_IP%20stack/TCPIP%20Stack/GenericTCPClient.c

/*********************************************************************
 *
 *  Generic TCP Client Example Application
 *  Module for Microchip TCP/IP Stack
 *   -Implements an example HTTP client and should be used as a basis 
 *        for creating new TCP client applications
 *       -Reference: None.  Hopefully AN833 in the future.
 *
 *********************************************************************
 * FileName:        GenericTCPClient.c
 * Dependencies:    TCP.h, DNS.h
 * Processor:       PIC18, PIC24F, PIC24H, dsPIC30, dsPIC33F
 * Complier:        Microchip C18 v3.03 or higher
 *                                      Microchip C30 v2.02 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * Copyright © 2002-2007 Microchip Technology Inc.  All rights 
 * reserved.
 *
 * Microchip licenses to you the right to use, modify, copy, and 
 * distribute: 
 * (i)  the Software when embedded on a Microchip microcontroller or 
 *      digital signal controller product (“Device”) which is 
 *      integrated into Licensee’s product; or
 * (ii) ONLY the Software driver source files ENC28J60.c and 
 *      ENC28J60.h ported to a non-Microchip device used in 
 *      conjunction with a Microchip ethernet controller for the 
 *      sole purpose of interfacing with the ethernet controller. 
 *
 * You should refer to the license agreement accompanying this 
 * Software for additional information regarding your rights and 
 * obligations.
 *
 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT 
 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT 
 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL 
 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR 
 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF 
 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS 
 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE 
 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER 
 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT 
 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
 *
 *
 * Author               Date    Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Howard Schlunder     8/01/06 Original
 ********************************************************************/
#define __GENERICTCPCLIENT_C

#include "TCPIP Stack/TCPIP.h"

#if defined(STACK_USE_GENERIC_TCP_CLIENT_EXAMPLE)


//TODO: Define proper server address here
BYTE ServerName[] =     "www.google.com";
WORD ServerPort = 80;

// This is specific to this HTTP Client example
ROM BYTE RemoteURL[] = "/search?as_q=Microchip&as_sitesearch=microchip.com";


/*********************************************************************
 * Function:        void GenericTCPClient(void)
 *
 * PreCondition:    Stack is initialized()
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        None
 *
 * Note:            None
 ********************************************************************/
void GenericTCPClient(void)
{
        BYTE                            i;
        BYTE                            *StringPtr;
        static TICK                     Timer;
        static TCP_SOCKET       MySocket = INVALID_SOCKET;
        static NODE_INFO        Server;
        static enum _GenericTCPExampleState
        {
                SM_HOME = 0,
                SM_NAME_RESOLVE,
                SM_ARP_START_RESOLVE,
                SM_ARP_RESOLVE,
                SM_SOCKET_OBTAIN,
                SM_SOCKET_OBTAINED,
                SM_PROCESS_RESPONSE,
                SM_DISCONNECT,
                SM_DONE
        } GenericTCPExampleState = SM_DONE;

        switch(GenericTCPExampleState)
        {
                case SM_HOME:
                        // Obtain ownership of the DNS resolution module
                        if(!DNSBeginUsage())
                                break;

                        // Obtain the IP address associated with the common ServerName
                        DNSResolve(ServerName, DNS_TYPE_A);
                        GenericTCPExampleState++;
                        break;

                case SM_NAME_RESOLVE:
                        // Wait for the DNS server to return the requested IP address
                        if(!DNSIsResolved(&Server.IPAddr))
                                break;

                        // Release the DNS module, we no longer need it
                        if(!DNSEndUsage())
                        {
                                // An invalid IP address was returned from the DNS 
                                // server.  Quit and fail permanantly if host is not valid.
                                GenericTCPExampleState = SM_DONE;
                                break;
                        }

                        GenericTCPExampleState++;

                case SM_ARP_START_RESOLVE:
                        // Obtain the MAC address associated with the server's IP address (either direct MAC address on same subnet, or the MAC address of the Gateway machine)
                        ARPResolve(&Server.IPAddr);
                        Timer = TickGet();
                        GenericTCPExampleState++;
                        break;

                case SM_ARP_RESOLVE:
                        // Wait for the MAC address to finish being obtained
                        if(!ARPIsResolved(&Server.IPAddr, &Server.MACAddr))
                        {
                                // Time out if too much time is spent in this state
                                if(TickGet()-Timer > 1*TICK_SECOND)
                                {
                                        // Retransmit ARP request
                                        GenericTCPExampleState--;
                                }
                                break;
                        }
                        GenericTCPExampleState++;

                case SM_SOCKET_OBTAIN:
                        // Connect a socket to the remote TCP server
                        MySocket = TCPConnect(&Server, ServerPort);
                        
                        // Abort operation if no TCP sockets are available
                        // If this ever happens, incrementing MAX_TCP_SOCKETS in 
                        // StackTsk.h may help (at the expense of more global memory 
                        // resources).
                        if(MySocket == INVALID_SOCKET)
                                break;

                        GenericTCPExampleState++;
                        Timer = TickGet();
                        break;

                case SM_SOCKET_OBTAINED:
                        // Wait for the remote server to accept our connection request
                        if(!TCPIsConnected(MySocket))
                        {
                                // Time out if too much time is spent in this state
                                if(TickGet()-Timer > 5*TICK_SECOND)
                                {
                                        // Close the socket so it can be used by other modules
                                        TCPDisconnect(MySocket);
                                        MySocket = INVALID_SOCKET;
                                        GenericTCPExampleState--;
                                }
                                break;
                        }

                        Timer = TickGet();

                        // Make certain the socket can be written to
                        if(!TCPIsPutReady(MySocket))
                                break;
                        
                        // Place the application protocol data into the transmit buffer.  For this example, we are connected to an HTTP server, so we'll send an HTTP GET request.
                        TCPPutROMString(MySocket, (ROM BYTE*)"GET ");
                        TCPPutROMString(MySocket, RemoteURL);
                        TCPPutROMString(MySocket, (ROM BYTE*)" HTTP/1.1\r\nHost: ");
                        TCPPutString(MySocket, ServerName);
                        TCPPutROMString(MySocket, (ROM BYTE*)"\r\n\r\n");

                        // Send the packet
                        TCPFlush(MySocket);
                        GenericTCPExampleState++;

                case SM_PROCESS_RESPONSE:
                        // Check to see if the remote node has disconnected from us or sent us any application data
                        // If application data is available, write it to the UART
                        if(!TCPIsConnected(MySocket))
                        {
                                GenericTCPExampleState++;
                        }
        
                        if(!TCPIsGetReady(MySocket))
                                break;
        
                        // Obtain the server reply
                        while(TCPGet(MySocket, &i))
                        {
                                while(BusyUART());
                                WriteUART(i);
                        }
        
                        break;
        
                case SM_DISCONNECT:
                        // Close the socket so it can be used by other modules
                        // For this application, we wish to stay connected, but this state will still get entered if the remote server decides to disconnect
                        TCPDisconnect(MySocket);
                        MySocket = INVALID_SOCKET;
                        GenericTCPExampleState = SM_DONE;
                        break;
        
                case SM_DONE:
                        // Do nothing unless the user pushes BUTTON1 and wants to restart the whole connection/download process
                        if(BUTTON1_IO == 0u)
                                GenericTCPExampleState = SM_HOME;
                        break;
        }
}

#endif  //#if defined(STACK_USE_GENERIC_TCP_CLIENT_EXAMPLE)
1	hedin	15	/*********************************************************************
2			*
3			* Generic TCP Client Example Application
4			* Module for Microchip TCP/IP Stack
5			* -Implements an example HTTP client and should be used as a basis
6			* for creating new TCP client applications
7			* -Reference: None. Hopefully AN833 in the future.
8			*
9			*********************************************************************
10			* FileName: GenericTCPClient.c
11			* Dependencies: TCP.h, DNS.h
12			* Processor: PIC18, PIC24F, PIC24H, dsPIC30, dsPIC33F
13			* Complier: Microchip C18 v3.03 or higher
14			* Microchip C30 v2.02 or higher
15			* Company: Microchip Technology, Inc.
16			*
17			* Software License Agreement
18			*
19			* Copyright © 2002-2007 Microchip Technology Inc. All rights
20			* reserved.
21			*
22			* Microchip licenses to you the right to use, modify, copy, and
23			* distribute:
24			* (i) the Software when embedded on a Microchip microcontroller or
25			* digital signal controller product (“Device”) which is
26			* integrated into Licensee’s product; or
27			* (ii) ONLY the Software driver source files ENC28J60.c and
28			* ENC28J60.h ported to a non-Microchip device used in
29			* conjunction with a Microchip ethernet controller for the
30			* sole purpose of interfacing with the ethernet controller.
31			*
32			* You should refer to the license agreement accompanying this
33			* Software for additional information regarding your rights and
34			* obligations.
35			*
36			* THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT
37			* WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
38			* LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
39			* PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
40			* MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
41			* CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
42			* PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
43			* BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
44			* THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
45			* SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
46			* (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
47			*
48			*
49			* Author Date Comment
50			*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
51			* Howard Schlunder 8/01/06 Original
52			********************************************************************/
53			#define __GENERICTCPCLIENT_C
54
55			#include "TCPIP Stack/TCPIP.h"
56
57			#if defined(STACK_USE_GENERIC_TCP_CLIENT_EXAMPLE)
58
59
60			//TODO: Define proper server address here
61			BYTE ServerName[] = "www.google.com";
62			WORD ServerPort = 80;
63
64			// This is specific to this HTTP Client example
65			ROM BYTE RemoteURL[] = "/search?as_q=Microchip&as_sitesearch=microchip.com";
66
67
68			/*********************************************************************
69			* Function: void GenericTCPClient(void)
70			*
71			* PreCondition: Stack is initialized()
72			*
73			* Input: None
74			*
75			* Output: None
76			*
77			* Side Effects: None
78			*
79			* Overview: None
80			*
81			* Note: None
82			********************************************************************/
83			void GenericTCPClient(void)
84			{
85			BYTE i;
86			BYTE *StringPtr;
87			static TICK Timer;
88			static TCP_SOCKET MySocket = INVALID_SOCKET;
89			static NODE_INFO Server;
90			static enum _GenericTCPExampleState
91			{
92			SM_HOME = 0,
93			SM_NAME_RESOLVE,
94			SM_ARP_START_RESOLVE,
95			SM_ARP_RESOLVE,
96			SM_SOCKET_OBTAIN,
97			SM_SOCKET_OBTAINED,
98			SM_PROCESS_RESPONSE,
99			SM_DISCONNECT,
100			SM_DONE
101			} GenericTCPExampleState = SM_DONE;
102
103			switch(GenericTCPExampleState)
104			{
105			case SM_HOME:
106			// Obtain ownership of the DNS resolution module
107			if(!DNSBeginUsage())
108			break;
109
110			// Obtain the IP address associated with the common ServerName
111			DNSResolve(ServerName, DNS_TYPE_A);
112			GenericTCPExampleState++;
113			break;
114
115			case SM_NAME_RESOLVE:
116			// Wait for the DNS server to return the requested IP address
117			if(!DNSIsResolved(&Server.IPAddr))
118			break;
119
120			// Release the DNS module, we no longer need it
121			if(!DNSEndUsage())
122			{
123			// An invalid IP address was returned from the DNS
124			// server. Quit and fail permanantly if host is not valid.
125			GenericTCPExampleState = SM_DONE;
126			break;
127			}
128
129			GenericTCPExampleState++;
130
131			case SM_ARP_START_RESOLVE:
132			// Obtain the MAC address associated with the server's IP address (either direct MAC address on same subnet, or the MAC address of the Gateway machine)
133			ARPResolve(&Server.IPAddr);
134			Timer = TickGet();
135			GenericTCPExampleState++;
136			break;
137
138			case SM_ARP_RESOLVE:
139			// Wait for the MAC address to finish being obtained
140			if(!ARPIsResolved(&Server.IPAddr, &Server.MACAddr))
141			{
142			// Time out if too much time is spent in this state
143			if(TickGet()-Timer > 1*TICK_SECOND)
144			{
145			// Retransmit ARP request
146			GenericTCPExampleState--;
147			}
148			break;
149			}
150			GenericTCPExampleState++;
151
152			case SM_SOCKET_OBTAIN:
153			// Connect a socket to the remote TCP server
154			MySocket = TCPConnect(&Server, ServerPort);
155
156			// Abort operation if no TCP sockets are available
157			// If this ever happens, incrementing MAX_TCP_SOCKETS in
158			// StackTsk.h may help (at the expense of more global memory
159			// resources).
160			if(MySocket == INVALID_SOCKET)
161			break;
162
163			GenericTCPExampleState++;
164			Timer = TickGet();
165			break;
166
167			case SM_SOCKET_OBTAINED:
168			// Wait for the remote server to accept our connection request
169			if(!TCPIsConnected(MySocket))
170			{
171			// Time out if too much time is spent in this state
172			if(TickGet()-Timer > 5*TICK_SECOND)
173			{
174			// Close the socket so it can be used by other modules
175			TCPDisconnect(MySocket);
176			MySocket = INVALID_SOCKET;
177			GenericTCPExampleState--;
178			}
179			break;
180			}
181
182			Timer = TickGet();
183
184			// Make certain the socket can be written to
185			if(!TCPIsPutReady(MySocket))
186			break;
187
188			// Place the application protocol data into the transmit buffer. For this example, we are connected to an HTTP server, so we'll send an HTTP GET request.
189			TCPPutROMString(MySocket, (ROM BYTE*)"GET ");
190			TCPPutROMString(MySocket, RemoteURL);
191			TCPPutROMString(MySocket, (ROM BYTE*)" HTTP/1.1\r\nHost: ");
192			TCPPutString(MySocket, ServerName);
193			TCPPutROMString(MySocket, (ROM BYTE*)"\r\n\r\n");
194
195			// Send the packet
196			TCPFlush(MySocket);
197			GenericTCPExampleState++;
198
199			case SM_PROCESS_RESPONSE:
200			// Check to see if the remote node has disconnected from us or sent us any application data
201			// If application data is available, write it to the UART
202			if(!TCPIsConnected(MySocket))
203			{
204			GenericTCPExampleState++;
205			}
206
207			if(!TCPIsGetReady(MySocket))
208			break;
209
210			// Obtain the server reply
211			while(TCPGet(MySocket, &i))
212			{
213			while(BusyUART());
214			WriteUART(i);
215			}
216
217			break;
218
219			case SM_DISCONNECT:
220			// Close the socket so it can be used by other modules
221			// For this application, we wish to stay connected, but this state will still get entered if the remote server decides to disconnect
222			TCPDisconnect(MySocket);
223			MySocket = INVALID_SOCKET;
224			GenericTCPExampleState = SM_DONE;
225			break;
226
227			case SM_DONE:
228			// Do nothing unless the user pushes BUTTON1 and wants to restart the whole connection/download process
229			if(BUTTON1_IO == 0u)
230			GenericTCPExampleState = SM_HOME;
231			break;
232			}
233			}
234
235			#endif //#if defined(STACK_USE_GENERIC_TCP_CLIENT_EXAMPLE)