avr/main.c

Go to the documentation of this file.

/*      file: main.c
     version: sync with EtherProgs
       state: coding 
  programmer: Sirpdc (Sir Pinto de Castro, sirpdc@gmail.com)
 description: firmware version of etherprogs to implement NE2000 
              device driver and the TCP/IP stack(using uIP)

- changed BAUD to 56700 bps
- put ASSERT on debug.h file (because eclipse was messing with code completion
when arriving on assert definition)
- updated util library to v0.04(added TxHex function)
 */

/********************************************************************
*   ATENÇÃO AO TAMANHO OCUPADO NA RAM!
*
*  - Quando o micro começa a fazer reset's é porque a stack está corrompida
*                 => no nosso caso, ter atenção ao acesso aos vectores
*                                 => ocupação da RAM!!!!!!!!!!!
*

********************************************************************/
#define INFO "Isa ethernet board firmware, version 0071"

#include <config.h>
#include "NE2000.h"
#include "oscp.h"

//******************************************************************
#include <avr/io.h>
#include "util.h"
#include "debug.h"
#include "isa_bus.h"
#include "uip.h"
#include "uip_arp.h"
#include "config.h"

#define BUF ((struct uip_eth_hdr *)&uip_buf[0])


#if UIP_UDP
void uip_udp_listen(u16_t port)
{
  u8_t c;         
  for(c = 0; c < UIP_UDP_CONNS; ++c) {
    if(0==uip_udp_conns[c].lport){
        uip_udp_conns[c].lport = port;
    }
  }
}
#endif /* UIP_UDP */

#define FRAME_HEADER ((struct frame_header *)&uip_appdata[0])
#define FRAME_BUFFER ((unsigned char *)&uip_appdata[sizeof(struct frame_header)])
#define FRAME_CHKSUM *((unsigned char *)&uip_appdata[sizeof(struct frame_header)+FRAME_HEADER->n])

struct frame_header * m_frame_hdr;
struct frame rxframe;   


 
void udp_app(){
                
        if( uip_newdata() ){
                // this should go to initudp_app
                m_frame_hdr = FRAME_HEADER;
                
                // copy header received 
                memcpy( &rxframe,m_frame_hdr, sizeof(struct frame_header));             
                // update data pointer
                rxframe.data = FRAME_BUFFER;
                // update checksum
                rxframe.checksum = FRAME_CHKSUM;
                
                TxFrame(&rxframe);              // tX to the aquisition module
                
                // we should insert a timeout if the aquisition module, 
                // did not responde
                RxFrame(&rxframe);              // rx the response 
                
                // do the inverse
                memcpy( m_frame_hdr, &rxframe, sizeof(struct frame_header));                            
                FRAME_CHKSUM=rxframe.checksum;
                
                uip_udp_send(sizeof(struct frame_header)+m_frame_hdr->n+1 );    // 1 is the checksum
        }
        
}
int main(void)
{

        // configure serial port for debug
        // data size=8, parity even and 1 stop bits
        USART_Init(BAUD,DATA_SIZE8|PARITY_DISABLE|STOP_BITS1);

        // send info
        TxEol();
        TxStr_P(INFO);
        TxEol();

        rtl8019SetupPorts();

        //Reset bus
        SetBits(CNTRL_PORT, RESET_PIN); // reset = 1
        delay(15);                                              // wait 15 ms
        RstBits(CNTRL_PORT, RESET_PIN); // reset = 0

        uint16_t i;
        
#ifdef NE_PROBE 
        if( !ne_probe() ){
                TxStr_P("Error detecting card!");
                while(1) ;
        }
#endif
#ifdef NE_LOOPBACK      
    if(!loopback_test()){
        TxStr_P("Error on Loopback!");
                while(1) ;
    }
#endif

    TxStr_P("Initiating NE2000:...");
    ei_init();
    TxStr_P("Ok!");TxEol();
        
    TxStr_P("Testing memory.");TxEol();
    nic_mem_test();
    TxEol();


        /* Initialize the uIP TCP/IP stack. */
        uip_init();
        
        /* Initiate ARP module*/
        uip_arp_init();
  
        uip_udp_listen(HTONS(486));  
        
        /* This is where the dispacher start's!!!*/
        while(1) {
        /* Let the tapdev network device driver read an entire IP packet
           into the uip_buf. If it must wait for more than 0.5 seconds, it
           will return with the return value 0. If so, we know that it is
           time to call upon the uip_periodic(). Otherwise, the tapdev has
           received an IP packet that is to be processed by uIP. */
        uip_len = ei_poll();
        if(uip_len == 0) {
                // sleep 100ms
                #ifdef LINUX
                        usleep(100000); 
                #else
                        delay(100);
                #endif
                /*
                for(i = 0; i < UIP_CONNS; i++) {
                                uip_periodic(i);
                                // If the above function invocation resulted in data that
                                // should be sent out on the network, the global variable
                                // uip_len is set to a value > 0. 
                                if(uip_len > 0) {
                                        uip_arp_out();
                                        tapdev_send();
                                }
                }      
                
                // Call the ARP timer function every 10 seconds. 
                if(++arptimer == 20) {  
                                uip_arp_timer();
                                arptimer = 0;
                }      
                */
        } else {
                if(BUF->type == htons(UIP_ETHTYPE_IP)) {
                                uip_arp_ipin();
                                uip_input();
                                /* If the above function invocation resulted in data that
                                   should be sent out on the network, the global variable
                                   uip_len is set to a value > 0. */
                                if(uip_len > 0) {
                                        uip_arp_out();
                                        ei_transmit(uip_buf,uip_len);
                                }
                }else if(BUF->type == htons(UIP_ETHTYPE_ARP)) {
                                uip_arp_arpin();
                                /* If the above function invocation resulted in data that
                                should be sent out on the network, the global variable
                                uip_len is set to a value > 0. */       
                                if(uip_len > 0) {       
                                        ei_transmit(uip_buf,uip_len);
                                }
                }
        }    
  }



}

---