PIC32MX: SPI EEPROM - Revision history

NickMarchuk at 20:17, 1 March 2010

2010-03-01T20:17:20Z

← Older revision		Revision as of 15:17, 1 March 2010
Line 1:		Line 1:
	== Original Assignment ==

	'''Do not erase this section!'''

	Your assignment is to interface to the SPI 25AA1024 EEPROM chip.

	== Overview ==		== Overview ==

Philip Dames: /* Code */

2010-02-16T17:53:40Z

Code

← Older revision		Revision as of 12:53, 16 February 2010
Line 143:		Line 143:


	This section of code is used to read and write strings of data to the EEPROM		This section of code is used to read and write strings of data to the EEPROM

	//this code does string transmission		//this code does string transmission

Philip Dames: /* Code */

2010-02-16T17:53:16Z

Code

Show changes

Philip Dames: /* Code */

2010-02-16T17:48:16Z

Code

← Older revision		Revision as of 12:48, 16 February 2010
Line 36:		Line 36:

	== Code ==		== Code ==
			This first section of code sends and receives a single character (byte) of data

	Where possible, make it a single piece of well-commented cut-and-pastable code, or at least make each function that way, so others can easily copy it. Most comments should be in the code itself; outside the code (on the wiki) should only be explanatory comments that are too cumbersome to include in the code.

	// This code checks the writing and reading of an EEPROM via SPI communication. Note: using this		// This code checks the writing and reading of an EEPROM via SPI communication. Note: using this

Philip Dames: /* Code */

2010-02-16T17:47:27Z

Code

← Older revision		Revision as of 12:47, 16 February 2010
Line 155:		Line 155:

	}		}


			This section of code is used to read and write strings of data to the EEPROM
			//this code does string transmission
			#include "Compiler.h"
			#include "HardwareProfile.h"
			#include <plib.h>
			#include "LCD.h"

			#define chipselect LATCbits.LATC1
			//manipulate /CS of EEPROM. Manipulation of EEPROM cannot be done by //linking /SS of PIC and /CS of ROM. One can check this with a scope: //built-in functions like SpiChnPutc() does not generate corresponding //chipselect signal

			//function declaration
			//void string(char *A,int s);
			//this function does string, int s indicates the size of the string int here;
			int ENA= 0b00000110; //ROM write-enable instruction
			int INS1=0b00000010; //ROM write instruction
			int INS2=0b00000011; //ROM read instruction

			void write(unsigned char *data, int length); //actually address is 3-byte long but the first 7 bit dose not matter, we just make the first 8bit to be all 0s
			void read(unsigned char *edata, int length);

			int main()
			{
			lcd_init();
			mInitAllLEDs();

			LATC \|= 0b0000000000000010; //Use C1 of PIC to toggle /CS of ROM
			TRISC &=0b1111111111111101; //intialize C1 as output

			TRISGbits.TRISG7=1;// set G7 as digital input

			char LCDbuffer[33]; // this will store the string for the LCD

			short addr=0x0000; //initial writing address, first byte is set to zero and not displayed

			IEC0CLR=0x03800000; //disable all interrupts
			SPI2CON = 0; //resets SPI2
			int dump=SPI2BUF; //clears the receive buffer
			IFS0CLR=0x03800000; //clear any existing event
			SPI2STATCLR=0x40; //clears overflow flag

			SpiChnOpen(2,SPI_CON_MSTEN\| SPI_CON_MODE8\|SPI_CON_ON, 1024); // divide fpb by 1024, configure the I/O ports.

			unsigned char string[]="SPI SUCKS!!";
			int size=sizeof(string);
			unsigned char readstring[size];
			//writing block, first enable writing
			Delayus(50);
			chipselect=0; //enable chip. the ROM starts up with /CS high
			SpiChnPutC(2,ENA);
			Delayus(100); //give enough time for the previous instruction to get executed
			chipselect=1; //toggle /CS to properly set write enable, demanded by the ROM
			Delayus(50);
			Delayus(30);
			chipselect=0;
			write(string, size);
			chipselect=1;
			Delayus(5000);
			//delay a long time for those data to get written, internal writ cycle
			/***
			Below is the reading part
			***/

			chipselect=0; //select chip to initiate reading
			read(readstring,size);
			chipselect=1;
			//terminate reading sequence

			sprintf(LCDbuffer, "\f%s", readstring); // make the string 0x50 represents "P" in ASCII
			putsLCD(LCDbuffer); // write the contents of the variable
			}

			//functions

			void write(unsigned char *edata, int length)
			{
			// Send Data to eeprom to program one location

			Delayus(50);
			SpiChnPutC(2,INS1); //enable the chip and write "write" instruction
			SpiChnPutC(2,0x00); //the first 8-bit address
			SpiChnPutC(2,0x11);
			SpiChnPutC(2,0x11);
			while(length)
			{
			SpiChnPutC(2,*edata);
			edata++;
			length--;
			}
			Delayus(20000); // delay long enough for the sequence to be fully executed
			}

			//below is the function that does sequential read
			void read(unsigned char *data, int length)
			{
			// Send Data to eeprom to program one location

			Delayus(50);
			SpiChnPutC(2,INS2); //enable the chip and write "read" instruction
			SpiChnPutC(2,0x00); //the first 8-bit address
			SpiChnPutC(2,0x11);
			SpiChnPutC(2,0x11); //write the starting address

			SpiChnPutC(2,0x00);
			while(SPI2STAT!=0x849){} //wait until the TX buffer is empty, and enable data storage by clearing overflow flag!!!
			SPI2STATCLR = 0x40; //clear overflow flag
			int receive = SPI2BUF; //since overflow is cleared, buffer is read so that new data can come in
			Delayus(500);

			receive = SPI2BUF; //read

			*data=receive;
			data++;
			length--;
			//here=SPI2STAT; //008 here, means transmit buffer is empty

			while(length)
			{
			SpiChnPutC(2,0x00);
			Delayus(500);
			receive = SPI2BUF; //read
			*data=receive;
			data++;
			length--;
			}
			Delayus(5000);
			}

	==Debugging==		==Debugging==

Philip Dames: /* Timing */

2010-02-16T17:37:57Z

Timing

← Older revision		Revision as of 12:37, 16 February 2010
Line 33:		Line 33:
	<math>F_{clock} = \frac{F_{PB}}{2(BRG+1)}</math>		<math>F_{clock} = \frac{F_{PB}}{2(BRG+1)}</math>

	There is a delay of about 50 us when writing using the SpiChnPutC function, otherwise it will send/recieve one bit per clock cycle.		There is a delay of about 50 us when writing using the SpiChnPutC function, otherwise it will send/recieve one bit per clock cycle. Overall timing is limited by the EEPROM's internal write cycle (on the order of 1 ms).

	== Code ==		== Code ==

MeganWelker: /* Overview */

2010-02-16T17:37:01Z

Overview

← Older revision		Revision as of 12:37, 16 February 2010
Line 7:		Line 7:
	== Overview ==		== Overview ==

	EEPROM stands for stands for Electrically Erasable Programmable Read-Only Memory. It is a type of non-volitile memory that can be used to store little bits of data. Data will remain on EEPROM when power is disconnected, (like an external hardrive).		EEPROM stands for stands for Electrically Erasable Programmable Read-Only Memory. It is a type of non-volitile memory that can be used to store little bits of data. Data will remain on EEPROM when power is disconnected, (like an external hardrive). The EEPROM chip must be reprogrammed in its entirety, and has a life span in the tens or hundreds of thousands of read/writes.

	You can use the PIC32 to communicate with an EEPROM chip using SPI. This page refers to the usage of a Serial EEPROM.		You can use the PIC32 to communicate with an EEPROM chip using SPI. This page refers to the usage of a Serial EEPROM.

	To test that the code data was writing and reading correctly, the attached code sends data to the EEPROM through SPI, then from the EEPROM back to the PIC, and out to a LED display screen.		To test that the code data was writing and reading correctly, the attached code sends data to the EEPROM through SPI, then from the EEPROM back to the PIC, and out to a LED display screen.

			EEPROM vs. Flash memory: The EEPROM erases the cell one by one, and only erases the 1's back to zero. Flash erases the whole block at once. Since erasing causes wear to the cell, the EEPROM will have a slightly longer lifetime.

	== Circuit ==		== Circuit ==

Philip Dames: /* Timing */

2010-02-16T17:34:10Z

Timing

← Older revision		Revision as of 12:34, 16 February 2010
Line 30:		Line 30:

	<math>F_{clock} = \frac{F_{PB}}{2(BRG+1)}</math>		<math>F_{clock} = \frac{F_{PB}}{2(BRG+1)}</math>

			There is a delay of about 50 us when writing using the SpiChnPutC function, otherwise it will send/recieve one bit per clock cycle.

	== Code ==		== Code ==

Philip Dames: /* Timing */

2010-02-16T17:32:31Z

Timing

← Older revision		Revision as of 12:32, 16 February 2010
Line 27:		Line 27:
	== Timing ==		== Timing ==

	Communication speed is determined by the clock signal and the Baud rate register.		Communication speed is determined by the clock signal and the Baud rate register (BRG).

	<math>~~F_s_c_k~~ = \frac{~~F_p_b~~}{2(BRG+1)}</math>		<math>F_{clock} = \frac{F_{PB}}{2(BRG+1)}</math>

	== Code ==		== Code ==

Philip Dames: /* Timing */

2010-02-16T17:29:05Z

Timing

← Older revision		Revision as of 12:29, 16 February 2010
Line 28:		Line 28:

	Communication speed is determined by the clock signal and the Baud rate register.		Communication speed is determined by the clock signal and the Baud rate register.

	F_{sck}=\frac{F_{pb}}{2 \times (BRG+1)}
			<math>F_s_c_k = \frac{F_p_b}{2(BRG+1)}</math>

	== Code ==		== Code ==