main.#1

C8051F120单片机TCP协议栈,主体眶架,从美国人LIB库中导出

//------------------------------------------------------------------------------
// main.c
//------------------------------------------------------------------------------
// Copyright (C) 2005 Silicon Laboratories, Inc.
//
// Date: 05/15/06 17:21:33
// Target: C8051F12x 
// Version: 1.31
//
// Description:
//
//    This is a TCP example.
//    This code runs on a C8051F120 connected to a CP2200 via AB4 board.
//
// 	This file contains the main routine, MCU initialization code, and 
//    callback functions used by the TCP/IP Library.
//
// Steps for running this example code:
//
//    1. To run the example as a TCP Echo Server, set SERVER_MODE in main.c to 1.
//       To run the example as a TCP Echo Client, set SERVER_MODE to 0.
//
//    2. If running in Client mode, place the IP address of the  PC which will
//       be running the test application (TCP_SVR.exe) in IP_DEST_ADDR in
//       mn_userconst.h.
//
//    3. Place the IP address of the embedded Ethernet controller (C8051F120
//       and CP2200) in IP_SRC_ADDR in mn_userconst.h.
//
//    4. Connect to the C8051F120.
//
//    5. Compile and build the project code.
//
//    6. Download the code to the C8051F120.
//
//    7. If running in Client mode, run TCP_SVR.exe on the PC receiving the
//       call. Then press "Go." Once the Ethernet controller has initialized,
//       TCP_SVR.exe will wait for the embedded Ethernet controller to send
//       a string, then echo the received string back. The embedded Ethernet
//       controller will then take the string from TCP_SVR.exe and send it
//       back, and so forth.
//
//    8. If running in Server mode, press "Go." Then run TCP_CLI.exe on the PC.
//       By default, TCP_CLI.exe will send data to 216.233.5.26. If the
//       embedded Ethernet controller is using a different IP address,
//       execute TCP_CLI.exe from the command line using this syntax:
//
//       TCP_CLI.exe XXX.XXX.XXX.XXX
//
//       where XXX.XXX.XXX.XXX is the IP address of the embedded Ethernet controller.
//       TCP_CLI.exe will send out a string and wait for the embedded Ethernet
//       controller to echo it back. TCP_CLI.exe will then take the received string
//       and send it to the embedded Ethernet controller, and so forth.
//
//    9. Once the TCP example has terminated, the user may ping the C8051F120
//       at the IP address defined in IP_DEST_ADDR.
//

#include "mn_userconst.h"                      // TCP/IP Library Constants
#include "mn_stackconst.h"                     // TCP/IP Library Constants
#include "mn_errs.h"                           // Library Error Codes
#include "mn_defs.h"                           // Library Type definitions
#include "mn_funcs.h"                          // Library Function Prototypes
#include <c8051F120.h>                         // Device-specific SFR Definitions
#include <string.h>


//------------------------------------------------------------------------------
// Function Prototypes
//------------------------------------------------------------------------------

// Initialization Routines
void PORT_Init (void);
void SYSCLK_Init (void);
void EMIF_Init(void);
int establish_network_connection();

// Application Functions
void TCP(void);

//-----------------------------------------------------------------------------
// Constant Definitions 

#define DATA_BUFF_LEN    100


byte data_buff[DATA_BUFF_LEN];


//-----------------------------------------------------------------------------
// Main Routine
//-----------------------------------------------------------------------------
void main(void)
{
   int retval;

   // Disable watchdog timer
   WDTCN = 0xde;
   WDTCN = 0xad;

   // Initialize the MCU
   PORT_Init();
   SYSCLK_Init();
   EMIF_Init();

   while(1)
   {
      // Initialize the TCP/IP stack.
      if (mn_init() < 0)
      {
         // If code execution enters this while(1) loop, the stack failed to initialize.
         // Verify that all boards are connected and powered properly.
         while(1);
      }

      // Connect to the network
      establish_network_connection();

      // Run the TCP example
      TCP();

      // Start the Application Layer Services
      // If this routine exits, check the return value for an error code.
      retval = mn_server();

   }
}

//-----------------------------------------------------------------------------
// establish_network_connection
//-----------------------------------------------------------------------------
//
// This function calls mn_ether_init() to initialize the CP2200 and attach to
// the network.
//
// If there is a network connection, the function returns 1.
//
// In the call to mn_ether_init(), NUM_AUTONEG_ATTEMPTS is set to 0, so the
// function will not return until it successfully auto-negotiates.
//
// mn_ether_init() will not be a blocking call if NUM_AUTONEG_ATTEMPTS is set
// to a value greater than 0.
//
int establish_network_connection()
{
   int retval;

   do
   {
      // mn_ether_init() initializes the Ethernet controller.
      // AUTO_NEG indicates that the controller will auto-negotiate.
      retval = mn_ether_init(AUTO_NEG, 0, 0);

      // If there is no link, poll link_status until it sets or the
      // CP2200 resets and then call mn_ether_init() again.
      if (retval == LINK_FAIL)
      {
         while(!link_status && !ether_reset);
      }

      // If retval is less than zero and is not LINK_FAIL, there is a 
      // hardware error.
      else if (retval < 0)
      {
         // Verify that the Ethernet controller is connected and powered properly.
         // Verity that the EMIF has been configured at a speed compatible with the
         //    Ethernet controller.
         while(1);
      }

   }while(retval < 0);

   return (1);

}

//-----------------------------------------------------------------------------
// Application Functions
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// TCP
//-----------------------------------------------------------------------------
//
void TCP(void)
{
 
   SCHAR socket_no;
   PSOCKET_INFO socket_ptr;
   byte data_buf[100]={0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
   word16 data_len=100;
   int err=0;




   // When dest_ip is null_addr any IP address is allowed to connect
   //socket_no = mn_open(null_addr,ECHO_PORT,0,PASSIVE_OPEN,PROTO_TCP,\
                  //     STD_TYPE,data_buff,DATA_BUFF_LEN);

//	socket_no = mn_open(ip_dest_addr,DEFAULT_PORT,ECHO_PORT,ACTIVE_OPEN,PROTO_TCP,\
                //       STD_TYPE,data_buff,DATA_BUFF_LEN);
	socket_no = mn_open(ip_dest_addr,DEFAULT_PORT,ECHO_PORT,NO_OPEN,PROTO_UDP,\
                       STD_TYPE,data_buff,DATA_BUFF_LEN);


   if (socket_no < 0)
   {
      return;
   }

   socket_ptr = MK_SOCKET_PTR(socket_no);        // get pointer to the socket

   while(1)
   {
     // status = 0;

      /* mn_send sends the data and waits for an ACK. Some echo servers will
         return the ACK and the data in the same packet, so we need to handle
         that case.   */
    //  if (data_ptr != PTR_NULL)
     // {
     //    status = mn_send(socket_no,data_ptr,data_len);
	  //
      //   if (status > 0 && socket_ptr->recv_len > 0)
     //    {
         //   data_ptr = socket_ptr->recv_ptr;
       //     data_len = socket_ptr->recv_len;
      //      continue;
  //       }
  //    }

   //   if (status < 0 || socket_ptr->tcp_state == TCP_CLOSED)
    //  {
       //  break;
		 
   //   }
     // do
    //  {
         
		 err = mn_send(socket_no,data_buf,data_len);

  //   }while (status == NEED_TO_LISTEN);

      if (err < 0)
      {  
	         
		 mn_abort(socket_no); 
		 return;
      }

      // if we got something, send back what we got
 

		if(err==0)
		{
		 continue;
		}


		if(err>0)
		{


		 if(socket_ptr->recv_len>0)status=1;





		 continue;
		}
      

   }

   return;














}


//-----------------------------------------------------------------------------
// Initialization Routines
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// PORT_Init
//-----------------------------------------------------------------------------
//
// Configure the Interrupts, Crossbar and GPIO ports
//
void PORT_Init (void)
{
   char SFRPAGE_SAVE = SFRPAGE;     // Save Current SFR page

   SFRPAGE = CONFIG_PAGE;           // set SFR page
   P1MDOUT |= 0x40;                 // Set P1.6(TB_LED) to push-pull
   P2MDOUT |= 0x08;                 // Set P2.2(AB4_LED1)
   // all pins used by the external memory interface are in push-pull mode
   P4MDOUT =  0xDF;
   P5MDOUT =  0xFF;
   P6MDOUT =  0xFF;
   P7MDOUT =  0xFF;
   P4 = 0xC0;                       // /WR, /RD, are high, RESET is low
   P5 = 0xFF;
   P6 = 0xFF;                       // P5, P6 contain the address lines
   P7 = 0xFF;                       // P7 contains the data lines

   TCON &= ~0x01;                   // Make /INT0 level triggered

   // Enable UART0, CP0, and /INT0. This puts /INT0 on P0.3.
   XBR0 = 0x84;
   XBR1 = 0x04;
   XBR2 = 0x40;
   SFRPAGE = SFRPAGE_SAVE;       // Restore SFR page

}

//-----------------------------------------------------------------------------
// EMIF_Init
//-----------------------------------------------------------------------------
//
// Configure the External Memory Interface for both on and off-chip access.
//
void EMIF_Init (void)
{
   char SFRPAGE_SAVE = SFRPAGE;  // Save Current SFR page

   SFRPAGE = LEGACY_PAGE;

   EMI0CF = 0xFB;             // Split-mode, non-multiplexed on P0 - P3

   EMI0TC = EMIF_TIMING;      // This constant may be modified
                              // according to SYSCLK to meet the
                              // timing requirements for the CP2200

   EMI0CN = BASE_ADDRESS;     // Page of XRAM accessed by EMIF
   SFRPAGE = SFRPAGE_SAVE;    // Restore SFR page

}

//-----------------------------------------------------------------------------
// SYSCLK_Init
//-----------------------------------------------------------------------------
//
// This routine initializes the system clock.
//
void SYSCLK_Init (void)
{
   int i;                           // software timer

   char SFRPAGE_SAVE = SFRPAGE;     // Save Current SFR page

   SFRPAGE = CONFIG_PAGE;           // set SFR page

   OSCICN = 0x83;                   // set internal oscillator to run
                                    // at its maximum frequency

   CLKSEL = 0x00;                   // Select the internal osc. as
                                    // the SYSCLK source
   //Turn on the PLL and increase the system clock by a factor of M/N
   PLL0CN  = 0x00;                  // Set internal osc. as PLL source
   SFRPAGE = LEGACY_PAGE;
   FLSCL   = 0x30;                  // Set FLASH read time for 100 MHz clk
   SFRPAGE = CONFIG_PAGE;

   PLL0CN |= 0x01;                  // Enable Power to PLL

   PLL0DIV = 0x01;                  // Set Pre-divide value to N (N = 1)
   PLL0MUL = 0x04;                  // Multiply SYSCLK by M (M=4)
   PLL0FLT = 0x01;                  // Set the PLL filter register for
                                    // a reference clock from 12.2 - 19.5 MHz
                                    // and an output clock from 65 - 100 MHz
   for (i=0; i < 256; i++) ;        // Wait at least 5us
   PLL0CN  |= 0x02;                 // Enable the PLL
   while(!(PLL0CN & 0x10));         // Wait until PLL frequency is locked
   CLKSEL  = 0x02;                  // Select PLL as SYSCLK source

   SFRPAGE = SFRPAGE_SAVE;          // Restore SFR page

}

//-----------------------------------------------------------------------------
// ether_reset_low
//-----------------------------------------------------------------------------
//
// This routine drives the reset pin of the ethernet controller low.
//
void ether_reset_low()
{

   unsigned char SFRPAGE_Save;

   SFRPAGE_Save = SFRPAGE;    // Save Current SFR page
   SFRPAGE = CONFIG_PAGE;     // Switch to ports SFR page

   P4 &= ~0x20;               // Pull reset low

   SFRPAGE = SFRPAGE_Save;    // Restore SFR page

}

//-----------------------------------------------------------------------------
// ether_reset_high
//-----------------------------------------------------------------------------
//
// This routine places the reset pin in High-Z allowing it to be pulled up 
// using the external pull-up resistor.
//
// Additionally, this routine waits for the reset pin to read high before
// exiting.
//
void ether_reset_high (void)
{

   unsigned char SFRPAGE_Save;

   SFRPAGE_Save = SFRPAGE;    // Save Current SFR page
   SFRPAGE = CONFIG_PAGE;     // Switch to ports SFR page

   P4 |= 0x20;               // Allow /RST to rise
   while(!(P4 & 0x20));      // Wait for /RST to go high

   SFRPAGE = SFRPAGE_Save;    // Restore SFR page


}