PIC: 25XX320

25XX320 corresponde as memórias eeprom's (25AA320, 25LC320, 25C320) de 32Kb da Microchip. Comunica-se via SPI, utilizando apenas 4 fios (CLK, SDO, SDI, CS).

Características

• Tensão de alimentação: 5V;
• 4096 x 8 bit;
• Tempo de escrita: 5ms;
• Proteção de memória;

Funcionamento

Para realizar a escrita:

1. Habilitar o dispositivo (CS = 0);
2. Enviar a instrução de escrita;
3. Enviar um endereço de 16 bits. Enviar os 8 bits mais significativos, depois os 8 bits menos significativos.
4. Enviar o dado (1 byte) que será gravado no endereço.
5. Desabilitar o dispositivo (CS = 1);

Antes de cada operação de escrita é necessário enviar o comando que dá a permição de escrita e após a operação de escrita é necessário enviar o comando que revoga a permissão de escrita.

Para realizar a leitura:

1. Habilitar o dispositivo (CS = 0);
2. Enviar a instrução de leitura;
3. Enviar um endereço de 16 bits. Enviar os 8 bits mais significativos, depois os 8 bits menos significativos.
4. Realizar a leitura de 1 byte do endereço.
5. Desabilitar o dispositivo (CS = 1);

O dispositivo possui o seguinte registro de STATUS:

WPEN: Habilita/Desabilita a proteção de escrita. Trabalha em conjunto com o pino externo WP. Para mais detalhes, veja a tabela 3-3 do datasheet.
BP1-BP0: Protege um bloco de memória. 00 - nenhum bloco está protegido; 01 - 0x0C00 até 0x0FFF está protegido; 10 - 0x0800 até 0x0FFF está protegido. 11 - todos os blocos estão protegidos.
WEL: Indica se está autorizado a realizar uma operação de escrita.
WIP: Indica se está ocorrendo uma operação de escrita.

Biblioteca

	/*
	25XX320 - Memoria EEPROM SPI 32Kb
	Autor: Tiago Melo
	Blog: Microcontrolandos
	Compilador: MikroC PRO PIC
	Bibliotecas: Soft_SPI
	*/
	// Pinos do 25AA320.
	sbit SoftSpi_SDI at RB2_bit;
	sbit SoftSpi_SDO at RB1_bit;
	sbit SoftSpi_CLK at RB0_bit;
	sbit E25XX320_CS at RB3_bit;
	sbit SoftSpi_SDI_Direction at TRISB2_bit;
	sbit SoftSpi_SDO_Direction at TRISB1_bit;
	sbit SoftSpi_CLK_Direction at TRISB0_bit;
	sbit E25XX320_CS_Direction at TRISB3_bit;
	// Comandos.
	#define E25XX320_CMD_READ 0b00000011
	#define E25XX320_CMD_WRITE 0b00000010
	#define E25XX320_CMD_WRDI 0b00000100
	#define E25XX320_CMD_WREN 0b00000110
	#define E25XX320_CMD_RDSR 0b00000101
	#define E25XX320_CMD_WRSR 0b00000001
	typedef union {
	char WIP : 1; // Write-In-Process - Indica se há um escrita ocorrendo.
	char WEL : 1; // Write Enable Latch - Indica se é permitido a escrita na memória.
	char BP : 2; // Block Protection - Protege um bloco de memória contra escrita.
	char : 3;
	char WPEN : 1; // Write-Protect Enable - Habilia a proteção da memória.
	} E25XX320_Status;
	void E25XX320_Init() {
	E25XX320_CS_Direction = 0; // Pino de saída.
	E25XX320_CS = 1;
	}
	//Protege ou desprotege contra escrita.
	void E25XX320_Write_Enable(char enable) {
	E25XX320_CS = 0;
	Soft_SPI_Write(enable ? E25XX320_CMD_WREN : E25XX320_CMD_WRDI);
	E25XX320_CS = 1;
	}
	//Realiza a leitura de 1 byte de um determinado endereço.
	char E25XX320_Read(unsigned address) {
	char byte;
	// Habilitamos a comunicação.
	E25XX320_CS = 0;
	// Enviamos o comando de leitura.
	Soft_SPI_Write(E25XX320_CMD_READ);
	// Enviamos os 2 bytes de endereço.
	Soft_SPI_Write(((char*)&address)[1]); // MSB.
	Soft_SPI_Write(((char*)&address)[0]); // LSB.
	// Lê o byte.
	byte = Soft_SPI_Read(0);
	// Encerra a comunicação.
	E25XX320_CS = 1;
	return byte;
	}
	void E25XX320_Write(unsigned address, char value) {
	// Habilitamos a escrita.
	E25XX320_Write_Enable(1);
	// Habilitamos a comunicação.
	E25XX320_CS = 0;
	// Enviamos o comando de escrita.
	Soft_SPI_Write(E25XX320_CMD_WRITE);
	// Enviamos os 2 bytes de endereço.
	Soft_SPI_Write(((char*)&address)[1]); // MSB.
	Soft_SPI_Write(((char*)&address)[0]); // LSB.
	// Enviamos o valor.
	Soft_SPI_Write(value);
	// Encerra a comunicação.
	E25XX320_CS = 1;
	// Aguarda o fim do ciclo de escrita.
	Delay_ms(5);
	// Desabilitamos a escrita.
	E25XX320_Write_Enable(0);
	}
	// Escreve 32 bytes em uma determinada página.
	void E25XX320_Page_Write(unsigned page, char * bytes) {
	char length = 32;
	char address = page << 6; // O endereço é: página * 32 bytes.
	// Habilitamos a escrita.
	E25XX320_Write_Enable(1);
	// Habilitamos a comunicação.
	E25XX320_CS = 0;
	// Enviamos o comando de escrita.
	Soft_SPI_Write(E25XX320_CMD_WRITE);
	// Enviamos os 2 bytes de endereço.
	Soft_SPI_Write(((char*)&address)[1]); // MSB.
	Soft_SPI_Write(((char*)&address)[0]); // LSB.
	// Enviamos os 32 bytes.
	while(length--) Soft_SPI_Write(*bytes++);
	// Encerra a comunicação.
	E25XX320_CS = 1;
	// Aguarda o fim do ciclo de escrita.
	Delay_ms(5);
	// Desabilitamos a escrita.
	E25XX320_Write_Enable(0);
	}
	E25XX320_Status E25XX320_Get_Status() {
	E25XX320_Status status;
	// Habilitamos a comunicação.
	E25XX320_CS = 0;
	// Enviamos o comando de leitura do status.
	Soft_SPI_Write(E25XX320_CMD_RDSR);
	// Lê 1 byte do status.
	*((char*)&status) = Soft_SPI_Read(0);
	// Encerra a comunicação.
	E25XX320_CS = 1;
	return status;
	}
	void E25XX320_Set_Status(E25XX320_Status status) {
	// Habilitamos a escrita.
	E25XX320_Write_Enable(1);
	// Habilitamos a comunicação.
	E25XX320_CS = 0;
	// Enviamos o comando de escrita no status.
	Soft_SPI_Write(E25XX320_CMD_WRSR);
	// Escreve 1 byte no status.
	Soft_SPI_Write(*(char*)&status);
	// Encerra a comunicação.
	E25XX320_CS = 1;
	// Aguarda o fim do ciclo de escrita.
	Delay_ms(5);
	}
	void main() {
	char byte;
	Soft_SPI_Init();
	E25XX320_Init();
	// Escreve o valor 45 no endereço 4095.
	E25XX320_Write(4095, 45);
	// Realiza a leitura do endereço 4095.
	byte = E25XX320_Read(4095);
	}

view raw E25xx320.c hosted with ❤ by GitHub