logo elektroda
logo elektroda
X
logo elektroda
Adblock/uBlockOrigin/AdGuard mogą powodować znikanie niektórych postów z powodu nowej reguły.

Układ RTL8019 i ATMEGA w C

u2_ 22 Lis 2009 20:50 2261 6
  • #1 7296055
    u2_
    Poziom 11  
    Witam! Czy ma ktoś działający kod obsługi RTL8019 dla ATMEGA w C i mógłby się nim podzielić? Testuję układ, napisałem własny sterownik na podstawie http://www.pg.gda.pl/~zbczaja/pdf/wyk_ti_msTCPIP.pdf i niestety nie działa ono. Chciałbym sprawdzić, czy urządzenie jest sprawne i czy warto dalej nad nim siedzieć?
  • #2 7297635
    marekos
    Poziom 16  
    Ja również korzystałem z tego źródła jak pisałem swoje oprogramowanie na RTL8019 i działało bezbłędnie, tylko że używałem ATMEGA128 i sprzętowego kontrolera pamięci SRAM.
  • #3 7298856
    u2_
    Poziom 11  
    marekos napisał:
    Ja również korzystałem z tego źródła jak pisałem swoje oprogramowanie na RTL8019 i działało bezbłędnie, tylko że używałem ATMEGA128 i sprzętowego kontrolera pamięci SRAM.
    A mógłbyś się podzielić swoim kodem (tylko do testów, i tylko część dotycząca drivera)? Ja działam na ATMEGA8.
  • #4 7299288
    marekos
    Poziom 16  
    W moim przypadku właściwie to sam driver sprowadza się tylko do zapisu konkretnych wartości pod konkretny adres. Adres wynika z założonego adresu podstawowego w przestrzeni adresowej, a wartości brałem z tego opracowania które podałeś w pierwszym poście.

    A tak w ogóle to co Ci nie działa, układ RTL8019 odpowiada? Zapalił diody LED, one zaczną działać dopiero po poprawnym zainicjowaniu układu?

    Przede wszystkim to zastanawiałeś się czy ATmegą8 da się obsłużyć Ethernet, bo według mnie to nie?
  • #5 7299379
    u2_
    Poziom 11  
    Diody się zapaliły się od razu po podłączeniu zasilania. Układ się zainicjował, gdyż przeszedł procedurę RTLinit(). Zawiesił się w funkcji RTLreceive_packet(). Co do realizacji Ethernetu to myślę, że jest to możliwe, ale nie można obsługiwać obszernych ramek. Ja przyjąłem rozmiar ramki na 128bajtów, stąd modyfikacja kodu z opracowania.
  • #6 7308479
    u2_
    Poziom 11  
    Oto mój kod.

    #ifndef RTL8019AS_H
    #define RTL8019AS_H
    
    #include <avr/io.h>
    #include <util/delay.h>
    
    //magistrala adresowa
    #define RTL_ADDRESS_PORT 		PORTB
    #define RTL_ADDRESS_DDR			DDRB
    
    //magistrala danych
    #define RTL_DATA_PORT			PORTD
    #define RTL_DATA_DDR			DDRD
    #define RTL_DATA_PIN			PIND
    
    //magistrala odczytu/zapisu
    #define RTL_CONTROL_PORT		PORTC
    #define RTL_CONTROL_DDR			DDRC
    #define RTL_CONTROL_READPIN		PC1
    #define RTL_CONTROL_WRITEPIN		PC0
    
    
    //zabawa pinami
    #define RTL_CLEAR_READ			RTL_CONTROL_PORT &= ~(1<<RTL_CONTROL_READPIN)
    #define RTL_SET_READ			RTL_CONTROL_PORT |=  (1<<RTL_CONTROL_READPIN)
    #define RTL_CLEAR_WRITE			RTL_CONTROL_PORT &= ~(1<<RTL_CONTROL_WRITEPIN)
    #define RTL_SET_WRITE			RTL_CONTROL_PORT |=  (1<<RTL_CONTROL_WRITEPIN)
    
    //reset
    #define RTL_RESET_PORT			PORTC
    #define RTL_RESET_DDR			DDRC
    #define RTL_RESET_PIN			PC2
    
    //rejestry
    #define CR					0x00
    #define PSTART					0x01
    #define PAR0					0x01
    #define CR9346					0x01
    #define PSTOP					0x02
    #define BNRY					0x03
    #define TSR					0x04
    #define TPSR					0x04
    #define TBCR0					0x05
    #define NCR					0x05
    #define TBCR1					0x06
    #define ISR					0x07
    #define CURR					0x07
    #define RSAR0					0x08
    #define CRDA0					0x08
    #define RSAR1					0x09
    #define CRDA1					0x09
    #define RBCR0					0x0A
    #define RBCR1					0x0B
    #define RSR					0x0C
    #define RCR					0x0C
    #define TCR					0x0D
    #define CNTR0					0x0D
    #define DCR					0x0E
    #define CNTR1					0x0E
    #define IMR					0x0F
    #define CNTR2					0x0F
    #define RDMAPORT				0x10
    #define RSTPORT					0x18
    
    #define ISR_PRX					0
    #define	ISR_PTX					1
    #define ISR_OVW					4
    #define ISR_RDC					6
    #define ISR_RST					7
    
    //adresy w pamiec
    #define TXSTART_INIT				0x40
    #define RXSTART_INIT				0x46
    #define RXSTOP_INIT				0x60
    
    //romiary pakietu, naglowkow, itd...
    #define ETHERNET_MIN_PACKET_LEN			0x3C //60 bajtow
    #define ETHERNET_HEADER_LEN			0x0E //14 bajtow
    
    #define IP_TCP_HEADER_LEN			0x28 //40 bajtow
    #define TOTAL_HEADER_LEN			(IP_TCP_HEADER_LEN | ETHERNET_HEADER_LEN)
    
    unsigned char EthFrame[128];
    unsigned int  currentRetreiveAddress;
    unsigned char currentPacketPtr;
    unsigned char nextPacketPtr;
    unsigned int  PacketSize;
    
    void RTLsetup_ports()
    {	
        RTL_ADDRESS_DDR = 0xFF;
    	RTL_DATA_PORT	= 0xFF;
    	
    	RTL_CONTROL_DDR |= (1<<RTL_CONTROL_READPIN);
    	RTL_CONTROL_DDR |= (1<<RTL_CONTROL_WRITEPIN);
    	RTL_CONTROL_PORT |= (1<<RTL_CONTROL_READPIN);
    	RTL_CONTROL_PORT |= (1<<RTL_CONTROL_WRITEPIN);
    
    	RTL_RESET_DDR |= (1<<RTL_RESET_PIN);
    }
    
    void RTLhw_reset()
    {
    	RTL_RESET_PORT |= (1<<RTL_RESET_PIN);
    	_delay_ms(10);
    	RTL_RESET_PORT &= ~(1<<RTL_RESET_PIN);
    	_delay_ms(10);
    }
    
    void RTLwrite(unsigned char address, unsigned char data)
    {
    	RTL_ADDRESS_PORT = address;
    	RTL_DATA_DDR = 0xFF;
    	RTL_DATA_PORT = data;
    	RTL_CLEAR_WRITE;
    	RTL_SET_WRITE;
    	RTL_DATA_DDR = 0x00;
    	RTL_DATA_PORT = 0xFF;
    }
    
    unsigned char RTLread(unsigned char address)
    {
    	unsigned char byte;
    	
    	RTL_ADDRESS_PORT = address;
    	
    	asm volatile("nop\n\t"::);
    	
    	RTL_CLEAR_READ;
    	
    	asm volatile("nop\n\t"::);
    	
    	byte = RTL_DATA_PIN;
    	RTL_SET_READ;
    	
    	return byte;
    }
    
    
    void RTLinit(void)
    {
    	RTLsetup_ports();
    	RTLhw_reset();
    	RTLwrite(RSTPORT, 0x00);
    	_delay_ms(30);
    
    	RTLwrite(CR, 0x41);
    	_delay_ms(2);
    
    	RTLwrite(CURR, RXSTART_INIT);
    	RTLwrite(PAR0+0, 0x01);
    	RTLwrite(PAR0+1, 0x01);
    	RTLwrite(PAR0+2, 0x01);
    	RTLwrite(PAR0+3, 0x01);
    	RTLwrite(PAR0+4, 0x01);
    	RTLwrite(PAR0+5, 0x01);
    
    	RTLwrite(CR, 0x21);
    	_delay_ms(2);
    
    	RTLwrite(DCR, 0x58);
    	
    	RTLwrite(RCR, 0x04);
    
    	RTLwrite(TCR, 0x02);
    
    	RTLwrite(RBCR0, 0x00);
    	RTLwrite(RBCR1, 0x00);
    
    	RTLwrite(TPSR, TXSTART_INIT);
    	RTLwrite(PSTART, RXSTART_INIT);
    	RTLwrite(BNRY, RXSTART_INIT);
    	RTLwrite(PSTOP, RXSTOP_INIT);
    
    	RTLwrite(ISR, 0xFF);
    	RTLwrite(IMR, 0x11);
    
    	RTLwrite(TCR, 0x00);
    	RTLwrite(CR, 0x22);
    
    }
    
    void RTLsend_packet()
    {
    unsigned int i;
    	
    	RTLwrite(CR,0x22);
    	
    	while( RTLread(CR) & 0x04 );
    	
    	RTLwrite(TPSR,TXSTART_INIT);
    	RTLwrite(RSAR0,0x00);
    	RTLwrite(RSAR1,TXSTART_INIT);
    	RTLwrite(ISR,(1<<ISR_PTX));
    	RTLwrite(RBCR0, 0xEA);
    	RTLwrite(RBCR1, 0x05);
    	RTLwrite(CR,0x12);
    	for(i=0; i<PacketSize; i++)
    		{
    		RTLwrite(RDMAPORT, EthFrame[i]);
    		}
    	
    	while(PacketSize<60)
    		{
    		RTLwrite(RDMAPORT, 0);
    		PacketSize++;
    		}
    
    	RTLwrite(TBCR0, (unsigned char)(PacketSize));
    	RTLwrite(TBCR1, (unsigned char)((PacketSize)>>8));
    	RTLwrite(CR,0x24);
    	RTLwrite(ISR, (1<<ISR_RDC));
    
    }
    
    unsigned char RTLreceive_empty_check()
    {
    unsigned char curr;
    
    	RTLwrite(CR,0x62);
    	curr = RTLread(CURR);
    	RTLwrite(CR,0x22);
    
    return ( curr == RTLread(BNRY) );
    }
    
    void RTLend_retreive()
    {
    unsigned char i = 0x00;
    
    	RTLwrite(CR, 0x22);
    	
    	for(i = 0; i <= 20; i++)
    		if(RTLread(ISR) & 1<<6)
    			break;
    	
    	RTLwrite(ISR, 1<<6);
    	RTLwrite(BNRY, nextPacketPtr);
    
    }
    
    unsigned char RTLreceive_packet()
    {
    unsigned int i;
    	
    	if ( RTLreceive_empty_check() ) 
    		return 0;
    
    	RTLwrite(CR, 0x22);
    
    	currentPacketPtr = RTLread(BNRY);
    	currentRetreiveAddress = (currentPacketPtr<<8) + 4;
    
    	RTLwrite(ISR, (1<<ISR_PRX));
    	
    	if( (currentPacketPtr >= RXSTOP_INIT) || (currentPacketPtr < RXSTART_INIT) )
    		{
    		RTLwrite(BNRY, RXSTART_INIT);
    		RTLwrite(CR, 0x62);
    		RTLwrite(CURR, RXSTART_INIT);
    		RTLwrite(CR, 0x22);
    		return 0;
    		}
    
    	RTLwrite(RBCR0, 4 + ETHERNET_HEADER_LEN);
    
    	RTLwrite(RBCR1, 0);
    	RTLwrite(RSAR0, 0);
    	RTLwrite(RSAR1, currentPacketPtr);
    	RTLwrite(CR, 0x0A);
    	
    	RTLread(RDMAPORT);
    	
    	nextPacketPtr = RTLread(RDMAPORT);
    	
    	if( (nextPacketPtr >= RXSTOP_INIT) || (nextPacketPtr < RXSTART_INIT) )
    		return 0;
    	
    	PacketSize = RTLread(RDMAPORT);
    	PacketSize |= ((unsigned int)RTLread(RDMAPORT)) << 8;
    	
    	if (PacketSize > 4)
    		PacketSize -= 4;
    	else
    		{
    		RTLend_retreive();
    		return 0;
    		}
    
    	if( PacketSize > 128)
    		{
    		RTLend_retreive();
    		return 0;
    		}
    
    	EthFrame[0]=RTLread(RDMAPORT);
    	EthFrame[1]=RTLread(RDMAPORT);
    	EthFrame[2]=RTLread(RDMAPORT);
    	EthFrame[3]=RTLread(RDMAPORT);
    	EthFrame[4]=RTLread(RDMAPORT);
    	EthFrame[5]=RTLread(RDMAPORT);
    	EthFrame[6]=RTLread(RDMAPORT);
    	EthFrame[7]=RTLread(RDMAPORT);
    	EthFrame[8]=RTLread(RDMAPORT);
    	EthFrame[9]=RTLread(RDMAPORT);
    	EthFrame[10]=RTLread(RDMAPORT);
    	EthFrame[11]=RTLread(RDMAPORT);
    	EthFrame[12]=RTLread(RDMAPORT);
    	EthFrame[13]=RTLread(RDMAPORT);
    	
    	currentRetreiveAddress += 6+6+2;
    	RTLwrite(CR, 0x22);
    	for(i = 0; i <= 20; i++)
    		if(RTLread(ISR) & 1<<6)
    			break;
    	
    	RTLwrite(ISR, 1<<6);
    	RTLwrite(RBCR0, (unsigned char)PacketSize);
    	RTLwrite(RBCR1, (unsigned char)(PacketSize>>8));
    	RTLwrite(RSAR0, (unsigned char)currentRetreiveAddress);
    	RTLwrite(RSAR1, (unsigned char)(currentRetreiveAddress>>8));
    	RTLwrite(CR, 0x0A);
    	
    	for(i=0;i<PacketSize;i++)
    		EthFrame[14+i] = RTLread(RDMAPORT);
    		
    	currentRetreiveAddress += PacketSize;
    
    	if( currentRetreiveAddress >= 0x6000 )
    		currentRetreiveAddress = currentRetreiveAddress - (0x6000-0x4600) ;
    
    	RTLend_retreive();
    	
    	return 1;
    }
    #endif
  • #7 7380781
    u2_
    Poziom 11  
    problem rozwiązany... jakby na przyszłość ktoś potrzebowa inicjalizację dla atmega88/168 to załączam kod

    
    #ifndef RTL8019AS_H 
    #define RTL8019AS_H 
    
    #include "uServer.h"
    
    #define nop()  __asm__ __volatile__ ("nop" ::)
    
    //magistrala adresowa 
    #define RTL_ADDRESS_PORT      PORTC 
    #define RTL_ADDRESS_DDR       DDRC 
    
    #define RTL_A0				  PC0
    #define RTL_A1				  PC1
    #define RTL_A2				  PC2
    #define RTL_A3				  PC3
    #define RTL_A4				  PC4
    
    #define RTL_ADDR_OUT()		  RTL_ADDRESS_DDR |= ((1<<RTL_A0) | (1<<RTL_A1) | (1<<RTL_A2) | (1<<RTL_A3) | (1<<RTL_A4))
    
    //magistrala danych 
    #define RTL_D0_PIN			  PB0
    #define RTL_D1_PIN			  PB1
    #define RTL_D2_PIN			  PB2
    #define RTL_D3_PIN			  PB3
    #define RTL_D4_PIN			  PB4
    #define RTL_D5_PIN			  PB5
    #define RTL_D6_PIN			  PC5
    #define RTL_D7_PIN			  PD7
    
    #define RTL_DATA_SETHIGH()	  PORTB |= (1<<RTL_D0_PIN) | (1<<RTL_D1_PIN) | (1<<RTL_D2_PIN) | (1<<RTL_D3_PIN) | (1<<RTL_D4_PIN) | (1<<RTL_D5_PIN); PORTC |= (1<<RTL_D6_PIN); PORTD |= (1<<RTL_D7_PIN)	
    #define RTL_DATA_PORT_OUT()	  DDRB |= (1<<RTL_D0_PIN) | (1<<RTL_D1_PIN) | (1<<RTL_D2_PIN) | (1<<RTL_D3_PIN) | (1<<RTL_D4_PIN) | (1<<RTL_D5_PIN); DDRC |= (1<<RTL_D6_PIN); DDRD |= (1<<RTL_D7_PIN)	
    #define RTL_DATA_PORT_IN()	  DDRB &= ~(1<<RTL_D0_PIN) & ~(1<<RTL_D1_PIN) & ~(1<<RTL_D2_PIN) & ~(1<<RTL_D3_PIN) & ~(1<<RTL_D4_PIN) & ~(1<<RTL_D5_PIN); DDRC &= ~(1<<RTL_D6_PIN); DDRD &= ~(1<<RTL_D7_PIN)	
    
    
    //magistrala odczytu/zapisu 
    #define RTL_CONTROL_PORT      PORTD
    #define RTL_CONTROL_DDR       DDRD 
    #define RTL_CONTROL_READPIN   PD2 
    #define RTL_CONTROL_WRITEPIN  PD3 
    #define RTL_CONTROL_RESETPIN  PD5
    
    
    //zabawa pinami 
    #define RTL_READ_ON()         RTL_CONTROL_PORT &=   ~(1<<RTL_CONTROL_READPIN) 
    #define RTL_READ_OFF()        RTL_CONTROL_PORT |=    (1<<RTL_CONTROL_READPIN) 
    #define RTL_READ_PINOUT()     RTL_CONTROL_DDR  |=    (1<<RTL_CONTROL_READPIN) 
    
    #define RTL_WRITE_ON()        RTL_CONTROL_PORT &=   ~(1<<RTL_CONTROL_WRITEPIN) 
    #define RTL_WRITE_OFF()       RTL_CONTROL_PORT |=    (1<<RTL_CONTROL_WRITEPIN) 
    #define RTL_WRITE_PINOUT()    RTL_CONTROL_DDR  |=    (1<<RTL_CONTROL_WRITEPIN) 
    
    #define RTL_RESET_ON()        RTL_CONTROL_PORT &=   ~(1<<RTL_CONTROL_RESETPIN) 
    #define RTL_RESET_OFF()       RTL_CONTROL_PORT |=    (1<<RTL_CONTROL_RESETPIN) 
    #define RTL_RESET_PINOUT()	  RTL_CONTROL_DDR  |=    (1<<RTL_CONTROL_RESETPIN) 
    
    #define OUT					  0xFF
    #define IN					  0x00
    
    //rejestry RTL
    #define RTL_REG_OFFSET			0x60
    #define CR						RTL_REG_OFFSET+0x00
    #define PSTART					RTL_REG_OFFSET+0x01
    #define PAR0					RTL_REG_OFFSET+0x01                                          
    #define PSTOP					RTL_REG_OFFSET+0x02
    #define BNRY					RTL_REG_OFFSET+0x03
    #define TPSR					RTL_REG_OFFSET+0x04
    #define TBCR0					RTL_REG_OFFSET+0x05
    #define TBCR1					RTL_REG_OFFSET+0x06
    #define ISR_REG					RTL_REG_OFFSET+0x07
    #define CURR					RTL_REG_OFFSET+0x07                                       
    #define RSAR0					RTL_REG_OFFSET+0x08
    #define CRDA0					RTL_REG_OFFSET+0x08
    #define RSAR1					RTL_REG_OFFSET+0x09	
    #define CRDAl					RTL_REG_OFFSET+0x09
    #define RBCR0					RTL_REG_OFFSET+0x0A
    #define RBCR1					RTL_REG_OFFSET+0x0B
    #define RSR						RTL_REG_OFFSET+0x0C
    #define RCR						RTL_REG_OFFSET+0x0C
    #define TCR						RTL_REG_OFFSET+0x0D
    #define CNTR0					RTL_REG_OFFSET+0x0D
    #define DCR						RTL_REG_OFFSET+0x0E
    #define CNTR1					RTL_REG_OFFSET+0x0E
    #define IMR						RTL_REG_OFFSET+0x0F
    #define CNTR2					RTL_REG_OFFSET+0x0F
    #define RDMAPORT				RTL_REG_OFFSET+0x10
    #define RSTPORT					RTL_REG_OFFSET+0x18
    
    //RTL8019AS Initial
    #define RCRVAL					0x04
    #define TCRVAL					0x00
    #define DCRVAL					0x58
    
    //PXR and OVW
    #define IMRVAL					0x11
    #define TXSTART					0x40
    #define RXSTART					0x46
    #define RXSTOP					0x60
    
    //RTL8019AS ISR
    #define PRX						0	//BIT 0 0x01
    #define	PTX						1	//BIT 1 0x02
    #define	RXE						2	//BIT 2 0x04
    #define	TXE						3	//BIT 3 0x08
    #define	OVW						4	//BIT 4 0x10
    #define	CNT						5	//BIT 5 0x20
    #define	RDC						6	//BIT 6 0x40
    #define	RST						7	//BIT 7 0x80
    
    //RTL8019AS CR
    #define STP						0	//BIT 0 0x01
    #define	STA						1	//BIT 1 0x02
    #define	TXP						2	//BIT 2 0x04
    #define	RD0						3	//BIT 3 0x08
    #define	RD1						4	//BIT 4 0x10
    #define	RD2						5	//BIT 5 0x20
    #define	PS0						6	//BIT 6 0x40
    #define	PS1						7	//BIT 7 0x80
    
    
    unsigned char RTLdecodeAddr(unsigned char address)
    {
    unsigned char decoded = 0x00;
    
    	if (address & 0x01)
    	   decoded |= 0x01;
    	if (address & 0x02)
    	   decoded |= 0x02;
    	if (address & 0x04)
    	   decoded |= 0x04;
    	if (address & 0x08)
    	   decoded |= 0x08;
    	if (address & 0x10)
    	   decoded |= 0x10;
    
    return decoded;
    }
    
    void RTLsetup_ports() 
    {    
    #ifdef _DEBUG
    	printf ("RTLsetup_ports()\r\n");
    #endif
    
    	//tryb wyjścia dla magistrali adresowej 
        RTL_ADDR_OUT();
    					    
    	//tryb wyjścia dla magistrali danych
        RTL_DATA_PORT_OUT();
    
    	//piny RD/WR/RST nieaktywne
        RTL_READ_OFF();
        RTL_WRITE_OFF();
        RTL_RESET_OFF();
    
    	nop();
        
    	//piny RD/WR/RST w trybie wyjscia
    	RTL_READ_PINOUT();
        RTL_WRITE_PINOUT();
        RTL_RESET_PINOUT();
    
    	nop();
    
    #ifdef _DEBUG
    	printf ("Done\r\n");
    #endif
    } 
    
    void RTLhw_reset() 
    { 
    #ifdef _DEBUG
       printf ("RTLhw_reset()\r\n");
    #endif
    
       //reset aktywny
       RTL_RESET_ON();
    
       #ifndef _DEBUG_AVRSTUDIO
    	   _delay_ms(100);
       #endif
    
       //reset nieaktywny    
       RTL_RESET_OFF();
    
       #ifndef _DEBUG_AVRSTUDIO
           _delay_ms(100);
       #endif
    
    #ifdef _DEBUG
       printf ("Done\r\n"); 
    #endif
    } 
    
    void RTLwrite(unsigned char address, unsigned char data) 
    { 
    #ifdef _DEBUG
       printf ("RTLwrite()\r\n");  
    #endif
       
       //przekazanie danej do zapisu na magistrale
       if (data & 0x01)	
    	  PORTB |=  (1<<RTL_D0_PIN);	
       else
    	  PORTB &= ~(1<<RTL_D0_PIN);		
    
       if (data & 0x02)	
    	  PORTB |=  (1<<RTL_D1_PIN);		
       else
    	  PORTB &= ~(1<<RTL_D1_PIN);		
    
       if (data & 0x04)	
    	  PORTB |=  (1<<RTL_D2_PIN);		
       else
    	  PORTB &= ~(1<<RTL_D2_PIN);		
    
       if (data & 0x08)	
    	  PORTB |=  (1<<RTL_D3_PIN);		
       else
    	  PORTB &= ~(1<<RTL_D3_PIN);		
    
       if (data & 0x10)	
    	  PORTB |=  (1<<RTL_D4_PIN);		
       else
    	  PORTB &= ~(1<<RTL_D4_PIN);		
    
       if (data & 0x20)	
    	  PORTB |=  (1<<RTL_D5_PIN);		
       else
    	  PORTB &= ~(1<<RTL_D5_PIN);		
    
       if (data & 0x40)	
    	  PORTD |=  (1<<RTL_D6_PIN);		
       else
    	  PORTD &= ~(1<<RTL_D6_PIN);		
    
       if (data & 0x80)	
    	  PORTC |=  (1<<RTL_D7_PIN);		
       else
    	  PORTC &= ~(1<<RTL_D7_PIN);	
    
       //magistrala danych w trybie wyjścia
       RTL_DATA_PORT_OUT();    
    
       //przekazanie adresu na magistrale
       RTL_ADDRESS_PORT = RTLdecodeAddr(address); 
       
       //zapis
       RTL_WRITE_ON();
    
       //dla synchronizacji
       nop();
       nop();
       nop();
    
       //koniec zapisu
       RTL_WRITE_OFF();
    
    #ifdef _DEBUG
       printf ("Done\r\n");  
    #endif
    } 
    
    unsigned char RTLread(unsigned char address) 
    { 
       unsigned char byte = 0x00; 
    
    #ifdef _DEBUG    
       printf ("RTLread()\r\n");  
    #endif
    
       //adres na magistrale adresowa
       RTL_ADDRESS_PORT = RTLdecodeAddr(address);
    
       //magistrala danych w trybie wejściowym
       RTL_DATA_PORT_IN(); 
    
       //początek odczytu
       RTL_READ_ON(); 
    
       //dla synchronizacji
       nop();
       nop();
       nop();
    
       //zczytuje dane z magistrali
       if (PINB & 0x01)
       	  byte |= 0x01;
       if (PINB & 0x02)
       	  byte |= 0x02;
       if (PINB & 0x04)
       	  byte |= 0x04;
       if (PINB & 0x08)
       	  byte |= 0x08;
       if (PINB & 0x10)
       	  byte |= 0x10;
       if (PINB & 0x20)
       	  byte |= 0x20;
       if (PIND & 0x80)
       	  byte |= 0x40;
       if (PINC & 0x20)
       	  byte |= 0x80;
    
       //koniec odczytu
       RTL_READ_OFF();
    
    #ifdef _DEBUG    
       printf ("Done\r\n");  
    #endif
    
    	//zwracam wynik
       return byte; 
    } 
    
    
    void RTLinit(void) 
    {
    
    #ifdef _DEBUG     
       printf ("RTLinit()\r\n");  
    #endif
    
       RTLsetup_ports(); 
       
       //etap 1 porty
       TEST_LED0_ON();   
       
       RTLhw_reset(); 
    
       //etap 2 reset
       TEST_LED1_ON();
    
       RTLread  (RSTPORT);
       RTLwrite (RSTPORT, 0xFF);
       
       #ifndef _DEBUG_AVRSTUDIO
           _delay_ms(2);
       #endif
    
       RTLwrite (CR, ((1<<STP)|(1<<RD2)));
    
       #ifndef _DEBUG_AVRSTUDIO
           _delay_ms(2);
       #endif
    
       RTLwrite (DCR, 		DCRVAL);
       RTLwrite (RBCR0, 	0x00);
       RTLwrite (RBCR1, 	0x00);
       RTLwrite (RCR, 		0x04);
       RTLwrite (TPSR, 		RXSTART);
       RTLwrite (TCR, 		0x02);
       RTLwrite (PSTART,	RXSTART);
       RTLwrite (BNRY, 		RXSTART);
       RTLwrite (PSTOP, 	RXSTOP);
       RTLwrite (CR,		((1<<STP)|(1<<RD2)|(1<<PS0)));
    
       #ifndef _DEBUG_AVRSTUDIO
           _delay_ms(2);
       #endif
       
       RTLwrite (CURR, 		RXSTART);
    
       //zapis adresu MAC	
       for (int iMac = 0; iMac < 6; iMac++)
           {
    	   RTLwrite ((PAR0 + iMac) , iMac); 	
    	   }
    
        RTLwrite (CR , (1<<STP| 1<<RD2));
        RTLwrite (DCR , DCRVAL);
        RTLwrite (CR , (1<<STA| 1<<RD2));
        RTLwrite (ISR_REG ,(1<<PRX|1<<PTX|1<<RXE|1<<TXE|1<<OVW|1<<CNT|1<<RDC|1<<RST));
        RTLwrite (IMR , IMRVAL);
        RTLwrite (TCR , TCRVAL);
    	
    #ifdef _DEBUG     
       printf ("Done\r\n");  
    #endif
    	
    	RTLwrite (CR,	((1<<STA)|(1<<RD2)));
    
        RTL_DATA_SETHIGH();  
    } 
    
    #endif
    
    
REKLAMA