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

/*********************************************************************
 *
 *      Announce Client and Server
 *  Module for Microchip TCP/IP Stack
 *       -Provides device hostname and IP address discovery on a local 
 *    Ethernet subnet (same broadcast domain)
 *       -Reference: None.  Hopefully AN833 in the future.
 *
 *********************************************************************
 * FileName:        Announce.c
 * Dependencies:    UDP.h
 * Processor:       PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
 * Complier:        Microchip C18 v3.02 or higher
 *                                      Microchip C30 v2.01 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     10/7/04 Original
 * Howard Schlunder             2/9/05  Simplified MAC address to text 
 *                                                              conversion logic
 * Howard Schlunder             2/14/05 Fixed subnet broadcast calculation
 * Howard Schlunder             10/3/06 Fixed a remoteNode saving bug
 ********************************************************************/
#define __ANNOUNCE_C

#include "TCPIP Stack/TCPIP.h"

#if defined(STACK_USE_ANNOUNCE)

#define ANNOUNCE_PORT   30303


extern NODE_INFO remoteNode;

/*********************************************************************
 * Function:        void AnnounceIP(void)
 *
 * PreCondition:    Stack is initialized()
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        AnnounceIP opens a UDP socket and transmits a 
 *                                      broadcast packet to port 30303.  If a computer is
 *                                      on the same subnet and a utility is looking for 
 *                                      packets on the UDP port, it will receive the 
 *                                      broadcast.  For this application, it is used to 
 *                                      announce the change of this board's IP address.
 *                                      The messages can be viewed with the MCHPDetect.exe
 *                                      program.
 *
 * Note:            A UDP socket must be available before this 
 *                                      function is called.  It is freed at the end of 
 *                                      the function.  MAX_UDP_SOCKETS may need to be 
 *                                      increased if other modules use UDP sockets.
 ********************************************************************/
void AnnounceIP(void)
{
        UDP_SOCKET      MySocket;
        BYTE            i;
        
        // Open a UDP socket for outbound broadcast transmission
        MySocket = UDPOpen(2860, NULL, ANNOUNCE_PORT);
        
        // Abort operation if no UDP sockets are available
        // If this ever happens, incrementing MAX_UDP_SOCKETS in 
        // StackTsk.h may help (at the expense of more global memory 
        // resources).
        if(MySocket == INVALID_UDP_SOCKET)
                return;
        
        // Make certain the socket can be written to
        while(!UDPIsPutReady(MySocket));
        
        // Begin sending our MAC address in human readable form.
        // The MAC address theoretically could be obtained from the 
        // packet header when the computer receives our UDP packet, 
        // however, in practice, the OS will abstract away the useful
        // information and it would be difficult to obtain.  It also 
        // would be lost if this broadcast packet were forwarded by a
        // router to a different portion of the network (note that 
        // broadcasts are normally not forwarded by routers).
        UDPPutArray((BYTE*)AppConfig.NetBIOSName, sizeof(AppConfig.NetBIOSName)-1);
        UDPPut('\r');
        UDPPut('\n');

        // Convert the MAC address bytes to hex (text) and then send it
        i = 0;
        while(1)
        {
                UDPPut(btohexa_high(AppConfig.MyMACAddr.v[i]));
            UDPPut(btohexa_low(AppConfig.MyMACAddr.v[i]));
            if(++i == 6u)
                break;
            UDPPut('-');
        }

        // Send some other human readable information.
        UDPPutROMString((ROM BYTE*)"\r\nDHCP/Power event occurred");

        // Send the packet
        UDPFlush();
        
        // Close the socket so it can be used by other modules
        UDPClose(MySocket);
}

void DiscoveryTask(void)
{
        static enum {
                DISCOVERY_HOME = 0,
                DISCOVERY_LISTEN,
                DISCOVERY_REQUEST_RECEIVED,
                DISCOVERY_DISABLED
        } DiscoverySM = DISCOVERY_HOME;

        static UDP_SOCKET       MySocket;
        BYTE                            i;
        
        switch(DiscoverySM)
        {
                case DISCOVERY_HOME:
                        // Open a UDP socket for inbound and outbound transmission
                        // Since we expect to only receive broadcast packets and 
                        // only send unicast packets directly to the node we last 
                        // received from, the remote NodeInfo parameter can be anything
                        MySocket = UDPOpen(ANNOUNCE_PORT, NULL, ANNOUNCE_PORT);

                        if(MySocket == INVALID_UDP_SOCKET)
                                return;
                        else
                                DiscoverySM++;
                        break;

                case DISCOVERY_LISTEN:
                        // Do nothing if no data is waiting
                        if(!UDPIsGetReady(MySocket))
                                return;
                        
                        // See if this is a discovery query or reply
                        UDPGet(&i);
                        UDPDiscard();
                        if(i != 'D')
                                return;

                        // We received a discovery request, reply when we can
                        DiscoverySM++;

                        // Change the destination to the unicast address of the last received packet
                memcpy((void*)&UDPSocketInfo[MySocket].remoteNode, (const void*)&remoteNode, sizeof(remoteNode));
                        
                        // No break needed.  If we get down here, we are now ready for the DISCOVERY_REQUEST_RECEIVED state

                case DISCOVERY_REQUEST_RECEIVED:
                        if(!UDPIsPutReady(MySocket))
                                return;

                        // Begin sending our MAC address in human readable form.
                        // The MAC address theoretically could be obtained from the 
                        // packet header when the computer receives our UDP packet, 
                        // however, in practice, the OS will abstract away the useful
                        // information and it would be difficult to obtain.  It also 
                        // would be lost if this broadcast packet were forwarded by a
                        // router to a different portion of the network (note that 
                        // broadcasts are normally not forwarded by routers).
                        UDPPutArray((BYTE*)AppConfig.NetBIOSName, sizeof(AppConfig.NetBIOSName)-1);
                        UDPPut('\r');
                        UDPPut('\n');
                
                        // Convert the MAC address bytes to hex (text) and then send it
                        i = 0;
                        while(1)
                        {
                                UDPPut(btohexa_high(AppConfig.MyMACAddr.v[i]));
                            UDPPut(btohexa_low(AppConfig.MyMACAddr.v[i]));
                            if(++i == 6u)
                                break;
                            UDPPut('-');
                        }
                        UDPPut('\r');
                        UDPPut('\n');

                        // Send the packet
                        UDPFlush();

                        // Listen for other discovery requests
                        DiscoverySM = DISCOVERY_LISTEN;
                        break;

                case DISCOVERY_DISABLED:
                        break;
        }       

}


#endif //#if defined(STACK_USE_ANNOUNCE)
1	/*********************************************************************
2	*
3	* Announce Client and Server
4	* Module for Microchip TCP/IP Stack
5	* -Provides device hostname and IP address discovery on a local
6	* Ethernet subnet (same broadcast domain)
7	* -Reference: None. Hopefully AN833 in the future.
8	*
9	*********************************************************************
10	* FileName: Announce.c
11	* Dependencies: UDP.h
12	* Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
13	* Complier: Microchip C18 v3.02 or higher
14	* Microchip C30 v2.01 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 10/7/04 Original
52	* Howard Schlunder 2/9/05 Simplified MAC address to text
53	* conversion logic
54	* Howard Schlunder 2/14/05 Fixed subnet broadcast calculation
55	* Howard Schlunder 10/3/06 Fixed a remoteNode saving bug
56	********************************************************************/
57	#define __ANNOUNCE_C
58
59	#include "TCPIP Stack/TCPIP.h"
60
61	#if defined(STACK_USE_ANNOUNCE)
62
63	#define ANNOUNCE_PORT 30303
64
65
66
67	extern NODE_INFO remoteNode;
68
69	/*********************************************************************
70	* Function: void AnnounceIP(void)
71	*
72	* PreCondition: Stack is initialized()
73	*
74	* Input: None
75	*
76	* Output: None
77	*
78	* Side Effects: None
79	*
80	* Overview: AnnounceIP opens a UDP socket and transmits a
81	* broadcast packet to port 30303. If a computer is
82	* on the same subnet and a utility is looking for
83	* packets on the UDP port, it will receive the
84	* broadcast. For this application, it is used to
85	* announce the change of this board's IP address.
86	* The messages can be viewed with the MCHPDetect.exe
87	* program.
88	*
89	* Note: A UDP socket must be available before this
90	* function is called. It is freed at the end of
91	* the function. MAX_UDP_SOCKETS may need to be
92	* increased if other modules use UDP sockets.
93	********************************************************************/
94	void AnnounceIP(void)
95	{
96	UDP_SOCKET MySocket;
97	BYTE i;
98
99	// Open a UDP socket for outbound broadcast transmission
100	MySocket = UDPOpen(2860, NULL, ANNOUNCE_PORT);
101
102	// Abort operation if no UDP sockets are available
103	// If this ever happens, incrementing MAX_UDP_SOCKETS in
104	// StackTsk.h may help (at the expense of more global memory
105	// resources).
106	if(MySocket == INVALID_UDP_SOCKET)
107	return;
108
109	// Make certain the socket can be written to
110	while(!UDPIsPutReady(MySocket));
111
112	// Begin sending our MAC address in human readable form.
113	// The MAC address theoretically could be obtained from the
114	// packet header when the computer receives our UDP packet,
115	// however, in practice, the OS will abstract away the useful
116	// information and it would be difficult to obtain. It also
117	// would be lost if this broadcast packet were forwarded by a
118	// router to a different portion of the network (note that
119	// broadcasts are normally not forwarded by routers).
120	UDPPutArray((BYTE*)AppConfig.NetBIOSName, sizeof(AppConfig.NetBIOSName)-1);
121	UDPPut('\r');
122	UDPPut('\n');
123
124	// Convert the MAC address bytes to hex (text) and then send it
125	i = 0;
126	while(1)
127	{
128	UDPPut(btohexa_high(AppConfig.MyMACAddr.v[i]));
129	UDPPut(btohexa_low(AppConfig.MyMACAddr.v[i]));
130	if(++i == 6u)
131	break;
132	UDPPut('-');
133	}
134
135	// Send some other human readable information.
136	UDPPutROMString((ROM BYTE*)"\r\nDHCP/Power event occurred");
137
138	// Send the packet
139	UDPFlush();
140
141	// Close the socket so it can be used by other modules
142	UDPClose(MySocket);
143	}
144
145	void DiscoveryTask(void)
146	{
147	static enum {
148	DISCOVERY_HOME = 0,
149	DISCOVERY_LISTEN,
150	DISCOVERY_REQUEST_RECEIVED,
151	DISCOVERY_DISABLED
152	} DiscoverySM = DISCOVERY_HOME;
153
154	static UDP_SOCKET MySocket;
155	BYTE i;
156
157	switch(DiscoverySM)
158	{
159	case DISCOVERY_HOME:
160	// Open a UDP socket for inbound and outbound transmission
161	// Since we expect to only receive broadcast packets and
162	// only send unicast packets directly to the node we last
163	// received from, the remote NodeInfo parameter can be anything
164	MySocket = UDPOpen(ANNOUNCE_PORT, NULL, ANNOUNCE_PORT);
165
166	if(MySocket == INVALID_UDP_SOCKET)
167	return;
168	else
169	DiscoverySM++;
170	break;
171
172	case DISCOVERY_LISTEN:
173	// Do nothing if no data is waiting
174	if(!UDPIsGetReady(MySocket))
175	return;
176
177	// See if this is a discovery query or reply
178	UDPGet(&i);
179	UDPDiscard();
180	if(i != 'D')
181	return;
182
183	// We received a discovery request, reply when we can
184	DiscoverySM++;
185
186	// Change the destination to the unicast address of the last received packet
187	memcpy((void)&UDPSocketInfo[MySocket].remoteNode, (const void)&remoteNode, sizeof(remoteNode));
188
189	// No break needed. If we get down here, we are now ready for the DISCOVERY_REQUEST_RECEIVED state
190
191	case DISCOVERY_REQUEST_RECEIVED:
192	if(!UDPIsPutReady(MySocket))
193	return;
194
195	// Begin sending our MAC address in human readable form.
196	// The MAC address theoretically could be obtained from the
197	// packet header when the computer receives our UDP packet,
198	// however, in practice, the OS will abstract away the useful
199	// information and it would be difficult to obtain. It also
200	// would be lost if this broadcast packet were forwarded by a
201	// router to a different portion of the network (note that
202	// broadcasts are normally not forwarded by routers).
203	UDPPutArray((BYTE*)AppConfig.NetBIOSName, sizeof(AppConfig.NetBIOSName)-1);
204	UDPPut('\r');
205	UDPPut('\n');
206
207	// Convert the MAC address bytes to hex (text) and then send it
208	i = 0;
209	while(1)
210	{
211	UDPPut(btohexa_high(AppConfig.MyMACAddr.v[i]));
212	UDPPut(btohexa_low(AppConfig.MyMACAddr.v[i]));
213	if(++i == 6u)
214	break;
215	UDPPut('-');
216	}
217	UDPPut('\r');
218	UDPPut('\n');
219
220	// Send the packet
221	UDPFlush();
222
223	// Listen for other discovery requests
224	DiscoverySM = DISCOVERY_LISTEN;
225	break;
226
227	case DISCOVERY_DISABLED:
228	break;
229	}
230
231	}
232
233
234	#endif //#if defined(STACK_USE_ANNOUNCE)