/[H8]/trunk/PIC/Demo trimmet/TFTPcDemo.c
ViewVC logotype

Diff of /trunk/PIC/Demo trimmet/TFTPcDemo.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 91 by hedin, Tue May 8 09:37:15 2007 UTC revision 105 by hedin, Sun May 27 16:32:30 2007 UTC
# Line 1  Line 1 
 /*********************************************************************  
  *  
  *                  TFTP Client Demo App for Microchip TCP/IP Stack  
  *  
  *********************************************************************  
  * FileName:        TFTPcDemo.c  
  * Dependencies:    tftpc.h  
  *                  stacktsk.h  
  *                  xlcd.h  
  *                  tick.h  
  * Processor:       PIC18  
  * Complier:        MCC18 v1.00.50 or higher  
  *                  HITECH PICC-18 V8.10PL1 or higher  
  * Company:         Microchip Technology, Inc.  
  *  
  * Software License Agreement  
  *  
  * The software supplied herewith by Microchip Technology Incorporated  
  * (the “Company”) for its PICmicro® Microcontroller is intended and  
  * supplied to you, the Company’s customer, for use solely and  
  * exclusively on Microchip PICmicro Microcontroller products. The  
  * software is owned by the Company and/or its supplier, and is  
  * protected under applicable copyright laws. All rights are reserved.  
  * Any use in violation of the foregoing restrictions may subject the  
  * user to criminal sanctions under applicable laws, as well as to  
  * civil liability for the breach of the terms and conditions of this  
  * license.  
  *  
  * THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,  
  * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED  
  * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A  
  * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,  
  * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR  
  * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.  
  *  
  * Author               Date    Comment  
  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
  * Nilesh Rajbharti     8/7/03  Original        (Rev 1.0)  
  *  
  *  
  * This demo application demonstartes Microchip TFTP client module usage  
  * See TFTPDemo(), TFTPWrite() and TFTPRead() for actual implementation.  
  *  
  * This application monitors RB5 switch. On first push it  
  * writes 'tftpwr.bin' file to server.  tftpwr.bin file is made up of  
  * first 16KB of program memory.  
  * On second push, it reads 'tftprd.txt' file from server.  
  *  
  * Server IP address is set in "Board Setup" mode using Hyperterminal.  
  *  
  * It displays rotating '-' to indicate command in progress.  
  * 'Y' to indicate success  
  * 'N' for failure  
  * 'T' for timeout  
  * 'E' for error.  
  *  
  *  
  * If running this applicaton on PICDEM.net use  
  * HS Oscillator  
  * Debug disabled  
  * Low Voltage Disabled  
  * Watchdog timer disabled  
  ********************************************************************/  
 /*  
  * Following define uniquely deines this file as main  
  * entry/application In whole project, there should only be one such  
  * definition and application file must define AppConfig variable as  
  * described below.  
  */  
1  #define THIS_IS_STACK_APPLICATION  #define THIS_IS_STACK_APPLICATION
2    
3  #include "stacktsk.h"  #include "stacktsk.h"
4  #include "dhcp.h"  #include "dhcp.h"
 #include "xlcd.h"  
5  #include "tick.h"  #include "tick.h"
6  #include "delay.h"  #include "delay.h"
7  #include "udp.h"  #include "udp.h"
8  #include "arp.h"  #include "arp.h"
9  #include "arptsk.h"  #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.  // All TFTP command statuts display will be done on first line of LCD.
18  #define TFTP_COMMAND_DISPLAY_LINE       0  //#define TFTP_COMMAND_DISPLAY_LINE       0
19    
20  // Result will be displayed at y = 15.  // Result will be displayed at y = 15.
21  #define TFTP_COMMAND_RESULT_POSITION    15  #define TFTP_COMMAND_RESULT_POSITION    15
22    
23    
24  #define STARTUP_MSG "G1_Build_0x00"  /*#define STARTUP_MSG "G1_Build_0x00"
25    
26  ROM char StartupMsg[] = STARTUP_MSG;  ROM char StartupMsg[] = STARTUP_MSG;
27    
# Line 97  ROM char DHCPMsg[] = "DHCP/Gleaning..."; Line 32  ROM char DHCPMsg[] = "DHCP/Gleaning...";
32  ROM char SetupMsg[] = "Board Setup...";  ROM char SetupMsg[] = "Board Setup...";
33    
34  //                         1234567890123456  //                         1234567890123456
35  ROM char blankLCDLine[] = "                ";  //ROM char blankLCDLine[] = "                ";
36    */
37  /*  /*
38   * This is used by other stack elements.   * This is used by other stack elements.
39   * Main application must define this and initialize it with   * Main application must define this and initialize it with
# Line 134  __CONFIG(2, PWRTEN & BORDIS & WDTDIS); Line 69  __CONFIG(2, PWRTEN & BORDIS & WDTDIS);
69   */   */
70  static void InitAppConfig(void);  static void InitAppConfig(void);
71  static void InitializeBoard(void);  static void InitializeBoard(void);
 static void DisplayIPValue(IP_ADDR *IPVal, BOOL bToLCD);  
72  static void SetConfig(void);  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)  void main(void)
459  {  {
460      // Tick to blink SYSTEM led.      // Tick to blink SYSTEM led.
461      static TICK t = 0;      static TICK t = 0;
462      UDP_SOCKET usock1;      TCP_SOCKET usock1;
463      NODE_INFO rnode;      char sock_state = 0;
     char sock_open = 0;  
464      char is_resolved = 0;      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.       * Initialize any application specific hardware.
# Line 165  void main(void) Line 487  void main(void)
487      InitAppConfig();      InitAppConfig();
488    
489      StackInit();      StackInit();
490        
491        network_init();
492    
 #if defined(STACK_USE_DHCP) || defined(STACK_USE_IP_GLEANING)  
     if ( AppConfig.Flags.bIsDHCPEnabled )  
     {  
         XLCDGoto(1, 0);  
         XLCDPutROMString(DHCPMsg);  
     }  
     else  
     {  
         /*  
          * Force IP address display update.  
          */  
         myDHCPBindCount = 1;  
 #if defined(STACK_USE_DHCP)  
         DHCPDisable();  
 #endif  
     }  
 #endif  
493    
494    
495      /*      /*
# Line 204  void main(void) Line 511  void main(void)
511          rnode.IPAddr.v[1] = 168;          rnode.IPAddr.v[1] = 168;
512          rnode.IPAddr.v[2] = 1;          rnode.IPAddr.v[2] = 1;
513          rnode.IPAddr.v[3] = 20;          rnode.IPAddr.v[3] = 20;
         /*rnode.MACAddr.v[0] = 0x00;  
         rnode.MACAddr.v[1] = 0x16;  
         rnode.MACAddr.v[2] = 0x76;  
         rnode.MACAddr.v[3] = 0x9F;  
         rnode.MACAddr.v[4] = 0xFE;  
         rnode.MACAddr.v[5] = 0xDA;*/  
           
           
514    
       
515      while(1)      while(1)
516      {      {
517                unsigned char antal = 8;
518                unsigned char stregkode[] = "12345678";
519          /*          /*
520           * Blink SYSTEM LED every second.           * Blink SYSTEM LED every second.
521           */           */
# Line 237  void main(void) Line 537  void main(void)
537           * configuration since last reset.           * configuration since last reset.
538           */           */
539                    
540          if ( DHCPBindCount != myDHCPBindCount )          
541          {                      network_send_hello( 0x01 );
542              DisplayIPValue(&AppConfig.MyIPAddr, TRUE);                      
543              myDHCPBindCount = DHCPBindCount;                      strncpy(global_network_char, "12345678", 8);
544                            network_send_scan_frame( 1, 8 ); //1x vare, stregkodelængde=8
545              if ( AppConfig.Flags.bIsDHCPEnabled )                          
546              {                          strncpy(global_network_char, "87654444", 8);
547                  XLCDGoto(1, 14);                          network_send_scan_frame( 1, 8 ); //1x vare, stregkodelængde=8
548                  if ( myDHCPBindCount < 0x0a )                          
549                      XLCDPut(myDHCPBindCount + '0');                          network_send_calc_total();
550                  else                          
551                      XLCDPut(myDHCPBindCount + 'A');                          network_send_cash_payed(50000);
552              }                          
553          }                          network_send_cancel_last();
554                                    
555          if (DHCPIsBound())                          network_send_cancel_all();
556          {                                                  
557                  RA3 =0;                          network_send_goodbye();
                 if (sock_open == 0)  
                 {  
                         if (ARPIsTxReady())  
                         {  
                                 if (is_resolved == 0)  
                                 {  
                                         ARPResolve( &rnode.IPAddr);  
                                         is_resolved = 1;  
                                 }  
                                 else  
                                 {  
                                         if (ARPIsResolved( &rnode.IPAddr, &rnode.MACAddr))  
                                         {  
                                                 usock1=UDPOpen(2000,&rnode,3000); // socket to send UDP  
                                                 sock_open=1;  
                                         }  
                                 }  
   
   
                                           
                         }  
                 }  
                   
                 if (UDPIsPutReady(usock1))  
                 {  
                         UDPPut( rnode.MACAddr.v[0] );  
                         UDPPut( rnode.MACAddr.v[1] );  
                         UDPPut( rnode.MACAddr.v[2] );  
                         UDPPut( rnode.MACAddr.v[3] );  
                         UDPPut( rnode.MACAddr.v[4] );  
                         UDPPut( rnode.MACAddr.v[5] );  
                         UDPPut('D');  
                         UDPPut('a');  
                         UDPPut('w');  
                         UDPPut(0);  
                         UDPFlush();  
                 }  
         }  
558      }      }
559  }  }
560    
561  #if defined(MCHP_C18)  void interrupt HighISR(void)
     #pragma interrupt HighISR save=section(".tmpdata")  
     void HighISR(void)  
 #elif defined(HITECH_C18)  
     #if defined(STACK_USE_SLIP)  
         extern void MACISR(void);  
     #endif  
     void interrupt HighISR(void)  
 #endif  
562  {  {
563      TickUpdate();      TickUpdate();
 /*  
 #if defined(STACK_USE_SLIP)  
     MACISR();  
 #endif  
 */  
564  }  }
565    
566  #if defined(MCHP_C18)  #if defined(MCHP_C18)
# Line 323  void HighVector (void) Line 572  void HighVector (void)
572  #pragma code /* return to default code section */  #pragma code /* return to default code section */
573  #endif  #endif
574    
 static void DisplayIPValue(IP_ADDR *IPVal, BOOL bToLCD)  
 {  
     char IPDigit[8];  
   
     if ( bToLCD )  
     {  
         /*  
          * Erase second line.  
          */  
         XLCDGoto(1, 0);  
         XLCDPutROMString(blankLCDLine);  
   
     }  
   
     /*  
      * Rewrite the second line.  
      */  
     XLCDGoto(1, 0);  
   
     itoa(IPVal->v[0], IPDigit);  
     if ( bToLCD )  
     {  
         XLCDPutString(IPDigit);  
         XLCDPut('.');  
     }  
   
     itoa(IPVal->v[1], IPDigit);  
     if ( bToLCD )  
     {  
         XLCDPutString(IPDigit);  
         XLCDPut('.');  
     }  
   
     itoa(IPVal->v[2], IPDigit);  
     if ( bToLCD )  
     {  
         XLCDPutString(IPDigit);  
         XLCDPut('.');  
     }  
   
     itoa(IPVal->v[3], IPDigit);  
     if ( bToLCD )  
         XLCDPutString(IPDigit);  
 }  
   
575  /*********************************************************************  /*********************************************************************
576   * Function:        void InitializeBoard(void)   * Function:        void InitializeBoard(void)
577   *   *
# Line 395  static void InitializeBoard(void) Line 599  static void InitializeBoard(void)
599      /*      /*
600       * LCD is enabled using RA5.       * LCD is enabled using RA5.
601       */       */
602      PORTA_RA5 = 0;          // Disable LCD.  //    PORTA_RA5 = 0;          // Disable LCD.
603    
604      /*      /*
605       * Turn off the LED's.       * Turn off the LED's.
# Line 409  static void InitializeBoard(void) Line 613  static void InitializeBoard(void)
613       */       */
614      INTCON2_RBPU = 0;      INTCON2_RBPU = 0;
615    
     XLCDInit();  
     XLCDGoto(0, 0);  
     XLCDPutROMString(StartupMsg);  
   
616      T0CON = 0;      T0CON = 0;
617      INTCON_GIEH = 1;      INTCON_GIEH = 1;
618      INTCON_GIEL = 1;      INTCON_GIEL = 1;
# Line 496  BOOL StringToIPAddress(char *str, IP_ADD Line 696  BOOL StringToIPAddress(char *str, IP_ADD
696      return (byteIndex == 3);      return (byteIndex == 3);
697  }  }
698    
   
 void XLCDDelay15ms(void)  
 {  
     DelayMs(15);  
 }  
 void XLCDDelay4ms(void)  
 {  
     DelayMs(4);  
 }  
   
 void XLCDDelay100us(void)  
 {  
     INTCON_GIEH = 0;  
     Delay10us(1);  
     INTCON_GIEH = 1;  
 }  
Legend:
Removed from v.91  
changed lines
  Added in v.105
  ViewVC Help
Powered by ViewVC 1.1.20