/[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 93 by hedin, Wed May 16 15:46:08 2007 UTC revision 98 by hedin, Tue May 22 14:45:39 2007 UTC
# Line 2  Line 2 
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"
# Line 10  Line 9 
9  #include "arptsk.h"  #include "arptsk.h"
10  #include "tcp.h"  #include "tcp.h"
11    
12    bit bIsDhcpUp = 0;
13    
14  // 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.
15  #define TFTP_COMMAND_DISPLAY_LINE       0  //#define TFTP_COMMAND_DISPLAY_LINE       0
16    
17  // Result will be displayed at y = 15.  // Result will be displayed at y = 15.
18  #define TFTP_COMMAND_RESULT_POSITION    15  #define TFTP_COMMAND_RESULT_POSITION    15
# Line 29  ROM char DHCPMsg[] = "DHCP/Gleaning..."; Line 29  ROM char DHCPMsg[] = "DHCP/Gleaning...";
29  ROM char SetupMsg[] = "Board Setup...";  ROM char SetupMsg[] = "Board Setup...";
30    
31  //                         1234567890123456  //                         1234567890123456
32  ROM char blankLCDLine[] = "                ";  //ROM char blankLCDLine[] = "                ";
33    
34  /*  /*
35   * This is used by other stack elements.   * This is used by other stack elements.
# Line 66  __CONFIG(2, PWRTEN & BORDIS & WDTDIS); Line 66  __CONFIG(2, PWRTEN & BORDIS & WDTDIS);
66   */   */
67  static void InitAppConfig(void);  static void InitAppConfig(void);
68  static void InitializeBoard(void);  static void InitializeBoard(void);
 static void DisplayIPValue(IP_ADDR *IPVal, BOOL bToLCD);  
69  static void SetConfig(void);  static void SetConfig(void);
70    
71  /*void network_send_hello( unsigned char termid )  /*****************************
72  {   Enummerations
73             if (DHCPIsBound())   ****************************/
74          {  typedef enum _NetworkState
75                  RA3 =0;  {
76                  if (sock_open == 0)          off,
77                  {          DhcpIsBound,
78                          if (ARPIsTxReady())          ArpIsTxReady,
79                          {          ArpIsResolved,
80                                  if (is_resolved == 0)          SockOpening,
81                                  {          SockOpen,
82                                          ARPResolve( &rnode.IPAddr);          TcpReadyToSend,
83                                          is_resolved = 1;          TcpSend,
84                                  }          SockClosing,
85                                  else          SockClosed
86                                  {  } NetworkState;
87                                          if (ARPIsResolved( &rnode.IPAddr, &rnode.MACAddr))  
88                                          //if (MyArp( &rnode))  /*****************************
89                                          {   GLOBAL INIT
90                                                  usock1=UDPOpen(2000,&rnode,3000); // socket to send UDP   ****************************/
91                                                  sock_open=1;  NODE_INFO rnode;
92                                          }  NetworkState state;
93                                  }        TCP_SOCKET tsock1;
                         }  
                 }  
                   
                 if (UDPIsPutReady(usock1) && datagrams_to_send>0)  
                 {  
                         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();  
                         datagrams_to_send--;  
                 }  
                 }  
 }  
 */  
94    
95  void WriteTcpStatus(char status)  
96  {  /*****************************
97          XLCDGoto(0,0);   network funktions
98          status += 'a';   ****************************/
99          XLCDPut(status);  int net_INT = 13, i;
100    char *net_CHAR = "1234567890123";
101    
102    
103    void network_init(void)
104    {
105            state = off;
106    }      
107    
108    
109    char network_send_hello( unsigned char termid )
110    {
111    char gotArp = 0;                // if gotArp is 0, the embedded haven't talked to the server since boot.
112    static char isBound = 0;
113            if ( DHCPIsBound() && isBound == 0 ){
114                    state = DhcpIsBound;
115                    isBound = 1;
116            }
117            switch (state)
118            {
119                    case DhcpIsBound:
120                            if ( ARPIsTxReady() && gotArp == 0 )
121                                    state = ArpIsTxReady;
122                            else
123                                    state = ArpIsResolved;
124                            return 0;
125                    
126                    case ArpIsTxReady:
127                            ARPResolve(&rnode.IPAddr);
128                            gotArp = 1;
129                            state = ArpIsResolved;
130                            return 0;
131                                            
132                    case ArpIsResolved:
133                            if (ARPIsResolved(&rnode.IPAddr, &rnode.MACAddr) ){
134                                    state = SockOpening;
135                                    return 0;
136                                    }
137                                    else{
138                                            state = ArpIsResolved;
139                                            return 2;                                                                       // no arp resolved
140                                    }
141                    
142                    case SockOpening:
143                            tsock1 = TCPConnect (&rnode, 3000);
144                            state = SockOpen;
145                            return 0;
146                    
147  }                  case SockOpen:
148                            if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
149                            state = TcpSend;
150                            return 0;
151                    
152                    case TcpSend:
153                            TCPPut( tsock1, 0x00 );
154                            TCPPut( tsock1, termid );
155                            TCPFlush(tsock1);
156                            TCPDiscard( tsock1 );
157                            
158    
159                            state = TcpReadyToSend;
160                            return 0;
161            }
162            return 1;
163    }
164    
165    char network_send_scan_frame( unsigned char stregkode, unsigned char buflen )
166    {
167            switch (state)
168            {
169                            TCPPut( tsock1, 0x01 );
170                            for (i = buflen; i >= 0; i--)
171                            {
172                                    TCPPut(tsock1, stregkode );
173                            }
174                            TCPFlush(tsock1);
175                            state = TcpReadyToSend;
176                            return 1;
177            }
178    }      
179    char network_send_goodbye(void)
180    {
181            switch (state)
182            {
183                    case TcpReadyToSend:
184                            if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
185                            state = TcpSend;
186                            
187                    case TcpSend:
188                            TCPPut( tsock1, 0x06 );
189                            TCPFlush( tsock1 );
190                            state = SockClosing;
191                            return 0;
192                    
193                    case SockClosing:
194                            TCPDisconnect( tsock1 );
195                            state = SockClosed;
196                            return 1;
197            }
198            return 3;                               // Didn't close the socket properly;
199    }      
200    
201  void main(void)  void main(void)
202  {  {
203      // Tick to blink SYSTEM led.      // Tick to blink SYSTEM led.
204      static TICK t = 0;      static TICK t = 0;
205      TCP_SOCKET usock1;      TCP_SOCKET usock1;
     NODE_INFO rnode;  
206      char sock_state = 0;      char sock_state = 0;
207      char is_resolved = 0;      char is_resolved = 0;
208      char has_arp = 0;      char has_arp = 0;
209        char a;
210                    
211      TICK tick;      TICK tick;
212      TICK lastTick;      TICK lastTick;
# Line 154  void main(void) Line 230  void main(void)
230      InitAppConfig();      InitAppConfig();
231    
232      StackInit();      StackInit();
233        
234        network_init();
235    
 #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  
236    
237    
238      /*      /*
# Line 193  void main(void) Line 254  void main(void)
254          rnode.IPAddr.v[1] = 168;          rnode.IPAddr.v[1] = 168;
255          rnode.IPAddr.v[2] = 1;          rnode.IPAddr.v[2] = 1;
256          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;*/  
           
           
257    
       
258      while(1)      while(1)
259      {      {
260                unsigned char antal = 8;
261                unsigned char stregkode[] = "12345678";
262          /*          /*
263           * Blink SYSTEM LED every second.           * Blink SYSTEM LED every second.
264           */           */
# Line 225  void main(void) Line 279  void main(void)
279           * For DHCP information, display how many times we have renewed the IP           * For DHCP information, display how many times we have renewed the IP
280           * configuration since last reset.           * configuration since last reset.
281           */           */
           
         if ( DHCPBindCount != myDHCPBindCount )  
         {  
             DisplayIPValue(&AppConfig.MyIPAddr, TRUE);  
             myDHCPBindCount = DHCPBindCount;  
282    
283              if ( AppConfig.Flags.bIsDHCPEnabled )          a = network_send_hello( 0x01 );
284              {  //              a = network_send_scan_frame( stregkode, antal );
285                  XLCDGoto(1, 14);                  a = network_send_goodbye();
286                  if ( myDHCPBindCount < 0x0a )  
                     XLCDPut(myDHCPBindCount + '0');  
                 else  
                     XLCDPut(myDHCPBindCount + 'A');  
             }  
         }  
           
         WriteTcpStatus( TCB[usock1].smState );  
           
         if (DHCPIsBound())  
         {  
                 RA3 =0;  
                 if (has_arp == 0)  
                 {  
                         if (ARPIsTxReady())  
                         {  
                                 if (is_resolved == 0)  
                                 {  
                                         ARPResolve( &rnode.IPAddr);  
                                         is_resolved = 1;  
                                 }  
                                 else  
                                 {  
                                         if (ARPIsResolved( &rnode.IPAddr, &rnode.MACAddr))  
                                         {  
                                                         has_arp = 1;  
                                         }  
                                 }  
           
                         }  
                 }  
                   
                 if (has_arp == 1)  
                 {  
                         if (sock_state == 0)  
                         {  
                         usock1=TCPConnect(&rnode,3000);  
                                 sock_state = 1;  
                         }  
                         if (sock_state ==1 && TCPIsConnected(usock1) && TCPIsPutReady(usock1))  
                         {  
                                 TCPPut(usock1,'D');  
                                 TCPPut(usock1,'a');  
                                 TCPPut(usock1,'w');  
                                 TCPPut(usock1,0);  
                         TCPFlush(usock1);  
                                 sock_state = 2;  
                         }  
                   
                         if (sock_state == 2 && TCPIsPutReady(usock1))  
                     {  
                                 TCPDisconnect(usock1);  
                                 lastTick = TickGet();  
                                 sock_state =3;  
                         }  
                         tick = TickGet();  
                         diffTicks = TickGetDiff(tick, lastTick);  
                           
                         if ( sock_state == 3 && diffTicks > ((TICK)TICK_SECOND * (TICK)2) )  
                                 sock_state = 0;  
                                   
                     }  
         }  
287      }      }
288  }  }
289    
# Line 327  void HighVector (void) Line 314  void HighVector (void)
314  #pragma code /* return to default code section */  #pragma code /* return to default code section */
315  #endif  #endif
316    
 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);  
 }  
   
317  /*********************************************************************  /*********************************************************************
318   * Function:        void InitializeBoard(void)   * Function:        void InitializeBoard(void)
319   *   *
# Line 399  static void InitializeBoard(void) Line 341  static void InitializeBoard(void)
341      /*      /*
342       * LCD is enabled using RA5.       * LCD is enabled using RA5.
343       */       */
344      PORTA_RA5 = 0;          // Disable LCD.  //    PORTA_RA5 = 0;          // Disable LCD.
345    
346      /*      /*
347       * Turn off the LED's.       * Turn off the LED's.
# Line 413  static void InitializeBoard(void) Line 355  static void InitializeBoard(void)
355       */       */
356      INTCON2_RBPU = 0;      INTCON2_RBPU = 0;
357    
     XLCDInit();  
     XLCDGoto(0, 0);  
     XLCDPutROMString(StartupMsg);  
   
358      T0CON = 0;      T0CON = 0;
359      INTCON_GIEH = 1;      INTCON_GIEH = 1;
360      INTCON_GIEL = 1;      INTCON_GIEL = 1;
# Line 500  BOOL StringToIPAddress(char *str, IP_ADD Line 438  BOOL StringToIPAddress(char *str, IP_ADD
438      return (byteIndex == 3);      return (byteIndex == 3);
439  }  }
440    
   
 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.93  
changed lines
  Added in v.98
  ViewVC Help
Powered by ViewVC 1.1.20