Eeprom error flag set

Модератор: Шурпа_Коробкин

Вернуться в «Общие вопросы об АКПП»

Internal EEPROM of PIC18F452 Microcontroller: Data EEPROM is used to store data permanently and it even retains data even after powering off a device or microcontroller. Almost all pic microcontrollers provide internal EEPROM to store critical data. In this tutorial, we will learn how to use internal EEPROM of Pic microcontrollers. We will also see example codes in MPLAB XC8 Compiler and MikroC Pro for PIC.

PIC Microcontroller Memory Types

There are three types of memories in a PIC Microcontroller namely, Flash Program Memory, Data Memory (RAM) and EEPROM Data Memory.

Flash Memory

Programs are written in the Flash Program Memory of a microcontroller. Because of this we can program a microcontroller and can change it many times after updating a new program. It has a fast response time.

Data Memory (RAM)

It is used for storing data temporarily during program execution. It is volatile memory and is cleared when the power is off or when CPU resets. RAM Data memory locations are also called General Purpose Registers (GPR). It also has a fast response time.

Internal EEPROM Data Memory

EEPROM stands for Electrically Erasable Programmable Read-Only Memory. EEPROM can be electrically read and write. It can be accessed through a program. It is non-volatile memory but has a slower response time or speed. The data will remain present in the memory until it is electrically erased or reprogrammed.

Now in this article, we will explain how to use internal EEPROM of PIC18F452. Internal EEPROM memory can be used to store data such as sensor data or device parameters and this data should not be lost during power off or when CPU resets. EEPROM is built inside PIC18F452 microcontroller. But internal memory is usually low in size and limited. For instance, PIC18F452 has only 256 bytes of internal EEPROM.

To avoid limitations of limited internal EEPROM, we can interface external EEPROM with Pic microcontroller also. these chips are also available to interface externally with the microcontroller. You can read this article:

• External EEPROM Interfacing with Microcontroller

As mentioned earlier, PIC18F452 supports 256  bytes of internal data EEPROM. A programmer can both read and write data to this memory. This read/write operation can take place during the normal operation of pic microcontroller. Unlike, Pic microcontroller memory banks, this data memory is directly accessed through special function register assigned to internal EEPROM of pic18f452 microcontroller

PIC18F452 Microcontroller Internal EEPROM Registers

The internal EEPROM data memory in PIC microcontroller is not directly mapped in the register file space.It is indirectly addressed through the Special Function Registers (SFR). There are four SFRs used to read and write this memory. These registers are:

• EECON1
• EECON2
• EEDATA
• EEADR

EEPROM EECON1 Register

The important control related with the internal EEPROM is the EECON1 register which is given below. EECON1 is the control register whose five lower order bits are physically implemented. Others are physically unimplemented and used to initiate the read/write.

• Bit7 EEPGD:  Flash Program or Data EEPROM Memory Select bit

EECON1bits.EEPGD = 1;  // Access Flash program memory
EECON1bits.EEPGD = 0; // Access EEPROM data memory , we select this options for data EEPROM

• Bit6 CFGS: Flash Program/Data EEPROM or Configuration Select bit

EECON1bits.CFGS = 1;  // Access Configuration registers
EECON1bits.CFGS = 0;  //Access data EEPROM memory

• Bit5 EEIF: It shows write operation completed ( Flag  interrupt )

EECON1bits.EEIF = 1; // Write operation completed (must be cleared in software)
EECON1bits.EEIF = 0; //Write operation is not completed or not started

• WRERR:   EEPROM Error Flag bit

EECON1bits.WRERR = 1; // Write operation is terminated (by any reset e.g MCLR reset or any WDT reset)
EECON1bits.WRERR = 0;  // Write operation completed

• WREN: EEPROM Write Enable bit

EECON1bits.WREN = 1;  //Allows write into EEPROM
EECON1bits.WREN = 0; // Inhibits write to the data EEPROM

• WR: Write Control bit

EECON1bits.WR = 1; // Initiates an EEPROM write cycle
EECON1bits.WR = 0; // Write cycle to the data EEPROM is complete

• RD:  Read Control bit

EECON1bits.RD = 1; // Initiates an EEPROM read
EECON1bits.RD = 0; // Read cycle to EEPROM is complete

When WREN bit is set, it will allow a write operation. Control bits RD and WR initiate read and write respectively. These bits cannot be cleared and only set in the software. They are cleared in hardware at completion of the read or write operation. This inability to clear the bit in software prevents the accidental or premature termination of a write operation.

On power-up, the WREN bit is clear. The WRERR bit is set when a write operation is interrupted by an MCLR, Reset or a Watchdog time-out Reset during normal operation. When this situation occurs, we can check the WRERR bit and rewrite the location. Interrupt flag bit EEIF is set when a write is complete. It must be cleared in software.

Internal EEPROM EECON2 Register

EECON2 is not a physical register. For Reading, EECON2 register will read all bits as ‘0’. The EECON2 register is used exclusively in the Data EEPROM write sequence.

EEDATA Register

EEDATA Register holds the 8-bit data for read/write operation. EEPROM data memory allows only a single byte to be read and write. When a byte is writing, it automatically erases the location and writes the new data. The EEPROM data memory is rated for high erase/write cycles. The write time is controlled by an on-chip timer.

EEADR Register

EEADR register holds the address of the EEPROM location which is to be accessible. It can access up to 256 locations of Data EEPROM in PIC18F452. The address range always starts at 00h and goes all over the memory available.

PIC Microcontroller EEPROM Code MPLAB XC8 Compiler

In this section, we will see how to configure these register in MPLAB XC8 compiler. How to write and read data from internal EEPROM.

Reading Data from PIC18452 Internal EEPROM

1. The address of the memory location to be read is given to EEADRregister.
2. Select EEPROM data memory by clearing the EEPGD control bit of EECON1 Register.
3. Set the RD bit of EECON1 Register to initiate the read cycle.
4. Then we can read data through EEDATA register.

unsigned char readEEPROM(unsigned char address)
{
EEADR = address; //Address to be read
EECON1bits.EEPGD = 0;//Selecting EEPROM Data Memory
EECON1bits.RD = 1;//Initialise read cycle
return EEDATA; //Returning data
}

It reads data from a specified address. The parameter address is microcontroller dependent. For PIC16 family it is of short type, and for PIC18 family it is of integer type. Here this function’s parameter (int) supports microcontrollers with more than 256 bytes of EEPROM. Give a delay of minimum 20ms between successive use of routines EEPROM_Write and EEPROM_Read. Otherwise, a microcontroller may return an undefined result.

Writing Data to PIC18452 Internal EEPROM

• The address of the memory location where data to be written is given to the EEADR register.
• 8-bit data which is to write is written in the EEDATA register.
• Select EEPROM data memory by clearing the EEPGD control bit of EECON1 Register.
• Set the WREN control bit of EECON1 Register to enable write operations.
• Store the interrupt register INTCON if interrupts are enabled in the program, and then disable them.
• There exists a special instruction sequence using EECON2 register is executed.
• Set the WR bit to initiate an EEPROM write cycle.
• Enable Interrupts if using.
• Disable the write operations by clearing WREN control bit.
• WR control bit is cleared if write cycle to the data EEPROM is complete or EEIF interrupt flag bit is set when write operation is completed. EEIF bit must be cleared in the program.

void writeEEPROM(unsigned char address, unsigned char data)

{
unsigned char INTCON_SAVE;//To save INTCON register value
EEADR = address; //Address to write
EEDATA = data; //Data to write
EECON1.EEPGD = 0; //Selecting EEPROM Data Memory
EECON1.WREN = 1; //Enable writing of EEPROM
INTCON_SAVE=INTCON;//Backup INCON interupt register
INTCON=0; //Diables the interrupt
EECON2=0x55; //Required sequence for write to internal EEPROM
EECON2=0xAA; //Required sequence for write to internal EEPROM
EECON1.WR = 1; //Initialise write cycle
INTCON = INTCON_SAVE;//Enables Interrupt
EECON1.WREN = 0; //To disable write
while(PIR2.EEIF == 0)//Checking for complition of write operation
{
asm nop; //do nothing
}
PIR2.EEIF = 0; //Clearing EEIF bit
}

Internal EEPROM PIC Microcontroller Example

In this example, we connect LEDs with PORTC of PIC18F452 microcontroller. First, we will write data to internal EEPROM. The data will be of a type that will turn on these LEDs sequentially from D1-D7. After writing data, we will read this data from the same addresses and send this data to PORTC.

In this example, we firstly write data to the EEPROM data memory and then it is read through some PORT. We write 00000001 to the first memory location, 00000010 to second, 000000100 to third and then sequentially up to 10000000. After that, it is read sequentially and output through PORTC.

Internal EEPROM Code Example MPLAB XC8

• First, create a new project in the MPLAB XC8 compiler and select microcontroller PIC18F452
• This code also works with other PIC18 series microcontrollers having same register configurations
•  Generate configuration file and select external oscillator from settings
• After that upload this code to pic microcontroller

#include <xc.h>
#include "config.h"
void delayms(unsigned int nMilliseconds)
{
#define CYCLES_PER_MS 100 /* Number of decrement-and-test cycles. */
unsigned long nCycles = nMilliseconds * CYCLES_PER_MS;
while (nCycles--);
}
unsigned char readEEPROM(unsigned char address)
{
EEADR = address; //Address to be read
EECON1bits.EEPGD = 0; //Selecting EEPROM Data Memory
EECON1bits.RD = 1; //Initialise read cycle
return EEDATA; //Returning data
}

void writeEEPROM(unsigned char address, unsigned char data)
{
unsigned char INTCON_SAVE; //To save INTCON register value
EEADR = address; //Address to write
EEDATA = data; //Data to write
EECON1bits.EEPGD = 0; //Selecting EEPROM Data Memory
EECON1bits.WREN = 1; //Enable writing of EEPROM
INTCON_SAVE=INTCON; //Backup INCON interupt register
INTCON=0; //Diables the interrupt
EECON2=0x55; //Required sequence for write to internal EEPROM
EECON2=0xAA; //Required sequence for write to internal EEPROM
EECON1bits.WR = 1; //Initialise write cycle
INTCON = INTCON_SAVE; //Enables Interrupt
EECON1bits.WREN = 0; //To disable write
while(PIR2bits.EEIF == 0); //Checking for complition of write operation
PIR2bits.EEIF = 0; //Clearing EEIF bit
}

void main(void) 
{
unsigned int i, a; //i for address, a for data
TRISC = 0; //PORT C as output port
do
{
for(i=0,a=1;i<8;i++)
{
writeEEPROM(i, a); //writing data to first memory location and then goes upto last location
delayms(20);
a = a<<1;
}

for(i=0;i<8;i++)
{
PORTC = readEEPROM(i); //reading data sequentially and output through PORT C
delayms(1000);
}
}while(1);

return;
}

Internal EEPROM with MikroC Pro for PIC

If you want to use mikroC for the pic compiler, you can use its built-in library. We don’t need to worry about internal configuration of control registers.

EEPROM LIBRARY MikroC Pro

MikroC provides some library function for comfortable work with EEPROM.

EEPROM_READ Function

unsigned short EEPROM_Read(unsigned int address): It Reads data from a specified address. The parameter address is microcontroller dependent. For PIC16 family it is of short type, and for PIC18 family it is of integer type. Here this function’s parameter (int) supports microcontrollers with more than 256 bytes of EEPROM. Give a delay of minimum 20ms between successive use of routines EEPROM_Write and EEPROM_Read, otherwise, a microcontroller may return an undefined result.

EEPROM_Write Function 

unsigned short EEPROM_ Write (unsigned int address): This function Writes data to the specified address. All interrupts should be disabled during the execution of the EEPROM_Write routine.

Internal EEPROM PIC Microcontroller Code MikroC Pro

This code working is the same as the last example with MPLAB XC8 compiler.

void main()
{
unsignedinti, a;                  //i for address, a for data
TRISC  = 0;                            //PORT C as output port
do
   {
for(i=0,a=1;i<8;i++)
      {
     Eeprom_Write(i, a);      //writing data to first memory location and then goes upto last location 
     Delay_ms(20);
       a = a<<1;
      }
for(i=0;i<8;i++)
      {
         PORTC = Eeprom_Read(i);        //reading data sequentially and output through PORT C
         Delay_ms(1000);
      }

}while(1);
}

This is a complete tutorial about how to use EEPROM of pic microcontroller. It is very easy to use and the MikroC compiler makes it very easy due to its built-in libraries. But if you prefer to use MPLAB XC8 compiler, you can use it also.

Where to use Internal EEPROM?

While working on microcontroller projects, you might need to store the state of LEDs, push buttons or some data that you want to use lately for calculations. Instead of using these things in variables, you can store them in data EEPROM, because it will save you program memory and make your code efficient to add more features in your projects.

One another application could be a digital electronic lock. In the electronic lock, we will store the password value in internal EEPROM and whenever use enters the password, we compare uses entered password with the stored password. If both passwords match, the lock will open. Otherwise, remain close. Therefore, in this tutorial, we show you how to write and retrieve data.

What to do Next?

You can try to do these exercise problems to enhance your skills of working with EEPROM:

• How to write and read integer value from EEPROM?
• How to read/write float value?
• Store states of LEDs and Switches

Read and Write Integer/Float/Long/String to Internal EEPROM

In the last section, we have seen internal EEPROM of pic microcontroller (PIC18F452) is organized in byte by byte format. Therefore, we can save only one byte at one location of memory. What if we need to store other data types such as integer, float, double, long double and string? In this section, we will see codes to read and write other data types from the internal EEPROM of pic microcontroller.

Writing Integer value

In the case of PIC18 and PIC16 series, integer data is of 2 bytes. Therefore, we need to divide data into two parts to store in internal electrical erasable memory. write_integer function will write a low byte at a first location and higher byte on the next location. The lo() and hi() are built-in functions in MikroC Pro that are used to extract low and high byte from a given number.

void write_integer(char address, int number)
{
eeprom_write(address, lo(number));   // lo(number) function extracts lower bytes from a number
delay_ms(20);
eeprom_write(address+1,hi(number));
delay_ms(20);
}

Reading Integer value

int read_integer(char address)
{
int th;
lo(th)=eeprom_read(address);
hi(th)=eeprom_read(address+1);
return th;
}

Reading/Writing Float

This write_float writes a float data type.

void write_float(char address, float number){
eeprom_write(address,lo(sayi));
delay_ms(20);
eeprom_write(address+1,hi(number));
delay_ms(20);
eeprom_write(address+2,higher(number));
delay_ms(20);
eeprom_write(address+3,highest(number));
delay_ms(20);
}

This function reads a float data type from on-chip EEPROM

float read_float(char address){
float th;
lo(th)=eeprom_read(address);
hi(th)=eeprom_read(address+1);
higher(th)=eeprom_read(address+2);
highest(th)=eeprom_read(address+3);
return th;
}

Writing/Reading Long

write_long() used to store unsigned long data types in on-chip Data memory.

void write_long(char address, unsigned long value)

{
eeprom_write(address,lo(value));
delay_ms(20);
eeprom_write(address+1,hi(value));
delay_ms(20);
eeprom_write(address+2,higher(value));
delay_ms(20);
eeprom_write(address+3,highest(value));
delay_ms(20);
}

read_long() used to retrieve unsigned long data type from on-chip Data memory.

unsigned long read_long(char address)
{
unsigned long th;
lo(th)=eeprom_read(address);
hi(th)=eeprom_read(address+1);
higher(th)=eeprom_read(address+2);
highest(th)=eeprom_read(address+3);
return th;
}

Очень многие знают, что в контроллерах PIC помимо основной оперативной памяти, а также памяти для хранения прошивки существует ещё и энергонезависимая память типа EEPROM.

Данная память сделана по технологии электрического стирания информации, что в отличие от её предшественника EPROM, в котором стирание производилось только при помощи ультрафиолетовых лучей, позволило использовать данный тип памяти практически повсеместно. Как мы знаем, ещё существует энергонезависимая память типа Flash, которая стоит намного дешевле, но у которой также есть существенный минус. Там невозможно стереть отдельный байт, стирание производится только блоками, что не совсем удобно в некоторых случаях, особенно когда информации требуется хранить немного, и информация данная представляет собой небольшие настроечные параметры. Поэтому нам стоит также остановиться на данном типе памяти. И причем не только из-за того, что он присутствует в контроллере, а из-за того, что это очень удобно для хранения некоторых величин, которые нужны нам будут даже после того, как контроллер потерял питание.

По идее, с данной памятью мы должны были познакомиться в более ранних занятиях, так как в технической документации на наши микроконтроллеры она находится в одной из первых частей, но мне хотелось для лучшего понимания и запоминания материала показать работу с EEPROM как-то наглядно. Мы подключали с вами четырёхразрядный индикатор, но четырёх разрядов для полноценного показа работы с энергонезависимой памятью, я думаю, мягко говоря, недостаточно, но после прошлого занятия, в котором мы изучили работу с 80-символьным дисплеем LCD, мы можем вполне оценить работу с памятью EEPROM.

Работать мы также будем с контроллером PIC16F877A, расположенном на удобной отладочной плате. Судя по технической документации на данный микроконтроллер, памяти EEPROM у него 256 байт. Этого вроде бы по нынешним меркам не так много, но вполне достаточно, чтобы хранить какую-то информацию, которая должна у нас остаться после отключения питания.

Теперь давайте познакомимся со спецификой работы данной памяти у нашего контроллера, а также с регистрами, используемыми для этого.

Существуют два регистра для записи и чтения памяти EEPROM. Это регистр, в котором хранятся данные, — EEDATA, а также регистр, в который мы посылаем адрес перед записью или чтения определённого байта, — EEADR. Также существует регистр управления EECON1, в котором находятся определённые биты настройки работы с памятью EEPROM, а также есть нефизический регистр EECON2, который мы используем для защиты от случайной записи данной памяти.

Также с помощью определённых конфигурационных битов мы можем защитить память EEPROM от стирания и перезаписи программатором.

Теперь немного подробнее про регистр управления EECON1

Теперь о назначении определённых битов данного регистра.

EEPGD — бит доступа к памяти (относится к памяти Flash)

1 — доступ к памяти для программы,

0 — доступ к памяти для данных.

WRERR (EEPROM Error Flag bit) — флаг ошибки записи данных в память EEPROM

1 — операция записи данных прервана (случился сброс либо по сигналу MCLR, либо по переполнению WDT в нормальном режиме),

0 — операция записи данных завершена.

WREN (EEPROM Write Enable bit) — бит разрешения записи данных в память EEPROM

1 — запись данных разрешена,

0 — запись данных запрещена.

WR (Write Control bit) — включение (инициализация) записи данных в память EEPROM

1 — инициализация цикла записи памяти EEPROM. Включается программно,

0 — цикл записи EEPROM закончен. Установка в 0 (сброс) осуществляется только аппаратным путём. Программно данный флаг сбросить невозможно.

RD (Read Control bit) — включение (инициализация) чтение данных из памяти EEPROM.

1 — инициализация цикла чтения памяти EEPROM. Включается программно,

0 — цикл чтения EEPROM закончен. Установка в 0 (сброс) осуществляется только аппаратным путём. Программно данный флаг сбросить также невозможно.

Чтение байта из памяти EEPROM производится следующим образом.

Первым делом мы должны удостовериться, что биты RD и WR регистра EECON1 у нас сброшены, то есть у нас в данный момент все циклы записи/чтения памяти EEPROM завершены. Затем мы записываем в регистр EEADR адрес считываемого байта, затем устанавливаем в 1 бит RD регистра EECON1 и считываем значение регистра EEDATA.

А вот запись байта в память EEPROM в целях безопасности происходит несколько посложнее.

Сначала мы также убеждаемся в сброшенном бите WR, затем разрешаем запись с помощью установки бита WREN регистра EECON1. Затем желательно запретить прерывания с помощью сброса бита GIE регистра INTCON, перед этим сохранив его значение, а то вдруг он уже был сброшен. А вот теперь мы делаем интересную вещь. Мы последовательно передаём байты 0x55 и 0xAA в регистр ЕЕСОN2. И только после этого мы пишем данные в память EEPROM, устанавливая бит инициализации записи WR. Затем мы возвращаем значение бита GIE в регистр INTCON, разрешив тем самым глобальные прерывания, если они до этого были разрешены. Потом мы сбрасываем бит WREN.

Вот и всё.

Чтобы нам теперь данную теорию понять и закрепить, мы должны отработать это на практике.

Поэтому создадим проект с именем EEPROM_LCD на основе проекта прошлого занятия LCD2004_8BIT.

Подключим нашу схему вместе с программатором и дисплеем, блок питания пока в целях безопасности не подключаем.

Откроем данный проект в MPLAB X, зайдём в его настройки и убедимся, что у нас схема не будет питаться от программатора и сохраним настройки проекта.

Теперь мы можем смело подключить блок питания, также попытаться собрать наш проект и прошить его в контроллер. Работоспособность нашего кода мы поймём по появившимся строкам на дисплее

Создадим каркас нашей будущей библиотеки для работы с памятью EEPROM с помощью двух файлов EEPROM.h и EEPROM.c следующего стандартного содержания

EEPROM.h:

#ifndef _EEPROM_H_H

#define _EEPROM_H_H

//——————————————————

#include <xc.h> // include processor files - each processor file is guarded.

#include <stdio.h>

#include <stdlib.h>

//-----------------------------------------------------

//-----------------------------------------------------

#endif /* _EEPROM_H */

EEPROM.c:

#include "EEPROM.h"

//-----------------------------------------------------

Также нашу библиотеку, а заодно и строковую, подключим в файле main.h

#include "lcd.h"

#include "EEPROM.h"

#include <string.h>

Вернёмся в файл EEPROM.c и напишем функцию записи байта в память EEPROM по определённому адресу, руководствуясь объяснению, как это делается, написанному выше. Заодно сразу добавим и функцию чтения байта по определённому адресу

//-----------------------------------------------------

void EEPROM_WriteByte (unsigned char addr, unsigned char dt)

{

  unsigned char status;

  while(WR);

  EEADR = addr;

  EEDATA = dt;

  WREN=1;

  status = GIE;

  GIE = 0;

  EECON2 = 0x55;

  EECON2 = 0xAA;

  WR=1;

  GIE = status;

  WREN=0;

}

//-----------------------------------------------------

unsigned char EEPROM_ReadByte(unsigned char addr)

{

  while(RD || WR);

  EEADR=addr;

  RD = 1;

  return EEDATA;

}

//-----------------------------------------------------

Также нам будет интересно писать и читать данные других типов.

Добавим функции записи и чтения двухбайтовой целочисленной беззнаковой величины в память EEPROM и из неё

//-----------------------------------------------------

void EEPROM_WriteWord(unsigned char addr, unsigned int ucData)

{

  EEPROM_WriteByte(addr, (unsigned char) ucData);

  unsigned char dt = ucData>>8;

  EEPROM_WriteByte(addr+1, dt);

}

//-----------------------------------------------------

unsigned int EEPROM_ReadWord(unsigned char addr)

{

  unsigned int dt = EEPROM_ReadByte(addr+1)*256;

  dt += EEPROM_ReadByte(addr);

  return dt;

}

//-----------------------------------------------------

Здесь у нас всё ещё проще. Мы читаем и пишем раздельно старший и младший байты, пользуясь уже добавленными функциями чтения и записи байтов.

Теперь добавим ещё функции записи и чтения четырёхбайтовых величин (двойных слов)

//-----------------------------------------------------

void EEPROM_WriteDword(unsigned char addr, unsigned long ucData)

{

  EEPROM_WriteWord(addr, (unsigned int) ucData);

  unsigned int dt = ucData>>16;

  EEPROM_WriteWord(addr+2, dt);

}

//-----------------------------------------------------

unsigned long EEPROM_ReadDword(unsigned char addr)

{

  unsigned long dt = EEPROM_ReadWord(addr+2)*65536;

  dt += EEPROM_ReadWord(addr);

  return dt;

}

//-----------------------------------------------------

Функции написаны в аналогичном стиле, только внутри используются функции записи и считывания двухбайтовых величин.

Теперь давайте запишем строку символов по определённому адресу

//-----------------------------------------------------

void EEPROM_WriteString(unsigned char addr, char* str1)

{

  unsigned char n;

  for(n=0;str1[n]!='';n++)

  EEPROM_WriteByte(addr+n,str1[n]);

}

//-----------------------------------------------------

Здесь также всё элементарно. Мы, инкрементируя адрес, постепенно записываем наши байты. И так до встречи с нулём.

Функцию чтения строки по определённому адресу нас написать также не затруднит

//-----------------------------------------------------

void EEPROM_ReadString(unsigned char addr, char* str1, unsigned char sz)

{

  unsigned char i;

  for (i=0;i<sz;i++) str1[i] = EEPROM_ReadByte(addr+i);

  str1[i] = 0;

}

//-----------------------------------------------------

В данной функции мы используем ещё один входящий аргумент — это величина считываемой строки. Можно было также и читать строку до встречи с нулём, но этого я делать не стал, так как вдруг этого нуля мы там не обнаружим, и тогда мы рискуем записать данные в оперативную память за пределы нашего строкового массива, что не очень будет приятно. Поэтому будем считать, что мы знаем длину считываемой строки.

Если есть желание, то вы можете написать функцию именно для считывания строки неизвестной длины, но только знайте, что она там должна обязательно существовать.

Перейдём в файл EEPROM.h и добавим прототипы наших функций

#include <stdlib.h>

//-----------------------------------------------------

void EEPROM_WriteByte(unsigned char addr, unsigned char dt);

unsigned char EEPROM_ReadByte(unsigned char addr);

void EEPROM_WriteWord(unsigned char addr, unsigned int ucData);

unsigned int EEPROM_ReadWord(unsigned char addr);

void EEPROM_WriteDword(unsigned char addr, unsigned long ucData);

unsigned long EEPROM_ReadDword(unsigned char addr);

void EEPROM_WriteString(unsigned char addr, char* str1);

void EEPROM_ReadString(unsigned char addr, char* str1, unsigned char sz);

//-----------------------------------------------------

В следующей части урока мы проверим работу библиотеки для памяти EEPROM на практике, записав в EEPROM различные типы данных (в том числе строковый массив), а также затем отобразив его на дисплее. Также мы научимся настраивать среду программирования так, чтобы память EEPROM при перепрошивке микроконтроллера не стиралась.

Предыдущий урок Программирование МК PIC Следующая часть

Купить программатор (неоригинальный) можно здесь: PICKit3

Купить программатор (оригинальный) можно здесь: PICKit3 original

Отладочную плату PIC Open18F4520-16F877A можно приобрести здесь: PIC Open18F4520-16F877A

Дисплей LCD 20×4 можно приобрести тут: Дисплей LCD 20×4

Смотреть ВИДЕОУРОК (нажмите на картинку)

Post Views:
1 233

Извиняюсь что не выложил в прошлом сообщение код :laughing: с собой просто не было, я делаю вот так:

/************************* Project Include Files *****************************/

#include «stdtypes.h»

#include «mcucfg.h»

#include «s12_eectl.h»

/************************* typedefs ******************************************/

/************************* #Defines ******************************************/

#ifndef ALIGNED_WORD_MASK

#define ALIGNED_WORD_MASK 0x0001

#endif

#ifndef PASS

#define PASS 1

#endif

#ifndef FAIL

#define FAIL 0

#endif

/************************* Global Variables **********************************/

static tEEPROM eeprom @(REG_BASE + 0x110);

/************************* External Variables ********************************/

void

ConfigECLKDIV(void)

{

if(eeprom.eclkdiv.bit.edivld == 0)

{ /* configure EEPROM clock prescaler */

eeprom.eclkdiv.byte = 0x49;

}

return;

}

/******************************************************************************

UINT8

ProgEeprom(UINT16* progAdr, UINT16* bufferPtr, UINT16 size)

{

if(((UINT16)progAdr & ALIGNED_WORD_MASK) != 0)/* Check for aligned word */

{

return(FAIL);

}

/* Clear error flags */

eeprom.estat.byte = (ACCERR | PVIOL);

/* Word to program? */

while(size != 0)

{ /* Is command buffer empty? */

if(eeprom.estat.bit.cbeif == 1)

{

/* Latch data and address */

*progAdr++ = *bufferPtr++;

/* Configure prog command */

eeprom.ecmd.byte = PROG;

/* Launch the command */

eeprom.estat.byte = CBEIF;

/* Was the access error flag set? */

/* Was the protection violation error flags set */

if((eeprom.estat.bit.accerr == 1) ||

(eeprom.estat.bit.pviol == 1))

{

return(FAIL);

}

/* next word */

size—;

}

}

/* Wait for last command to finish */

while(eeprom.estat.bit.ccif != 1)

{

}

/* finished, no errors */

return(PASS);

}

UINT16 ADD = 0x0000;

UINT16 DATA = 0x0000;

byte Res = 0;

void main(void) {

// * put your own code here

ADD = 0xE087F0;

DATA = 0xA5A5;

Res = ProgEeprom((UINT16 *)0x0C00,(UINT16 *)DATA,1);

……..

/******************************************************************************

File Name : s12_eectl.h

******************************************************************************/

#ifndef EECTL_H

#define EECTL_H

/************************* System Include Files ******************************/

/************************* Project Include Files *****************************/

#include «stdtypes.h»

/************************* typedefs ******************************************/

typedef union uECLKDIV

{

UINT8 byte;

struct

{

UINT8 ediv :6; /*clk divider */

UINT8 ediv8 :1; /*clk /8 prescaler enable */

UINT8 edivld :1; /*clock divider loaded flag */

}bit;

}tECLKDIV;

typedef union uECNFG

{

UINT8 byte;

struct

{

UINT8 :4; /*not used */

UINT8 eswai :1; /*eeprom stopped in wait mode */

UINT8 :1; /*not used */

UINT8 ccie :1; /*command complete interrupt enable */

UINT8 cbeie :1; /*command buffer empty interrupt enable*/

}bit;

}tECNFG;

typedef union uEPROT

{

UINT8 byte;

struct

{

UINT8 ep :3; /*protection block size: (ep+1)*64 bytes */

UINT8 epdis :1; /*protection disable */

UINT8 :3; /*contain value of equivalent bits in

protection byte */

UINT8 eopen :1; /*open block for program/erase */

}bit;

}tEPROT;

typedef union uESTAT

{

UINT8 byte;

struct

{

UINT8 :2; /*not used */

UINT8 blank :1; /*blank verify flag */

UINT8 :1; /*not used */

UINT8 accerr :1; /*access error flag */

UINT8 pviol :1; /*protection violation flag */

UINT8 ccif :1; /*command complete interrupt flag */

UINT8 cbeif :1; /*command buffer empty interrupt flag */

}bit;

}tESTAT;

typedef union uECMD

{

UINT8 byte;

struct

{

UINT8 mass :1; /*mass erase enable*/

UINT8 :1; /*not used */

UINT8 erver :1; /*erase verify enable */

UINT8 :2; /*not used */

UINT8 prog :1; /*word programming */

UINT8 erase :1; /*erase control */

UINT8 :1; /*not used */

}bit;

}tECMD;

typedef struct /*eeprom datastructure */

{

volatile tECLKDIV eclkdiv; /*eeprom clock divider register */

UINT8 rsvee1[2]; /*reserved */

volatile tECNFG ecnfg; /*eeprom configuration register */

volatile tEPROT eprot; /*eeprom protection register */

volatile tESTAT estat; /*eeprom status register */

volatile tECMD ecmd; /*eeprom command buffer & status register */

UINT8 rsvee2[5]; /*reserved */

}tEEPROM;

/************************* Extern Variables **********************************/

/************************* #Defines ******************************************/

#define EDIV8 0x40 /*bit masks */

#define EDIVLD 0x80

#define ESWAI 0x10 /*bit masks */

#define CCIE 0x40

#define CCBIE 0x80

#define EP0 0x01 /*bit masks */

#define EP1 0x02

#define EP2 0x04

#define EP 0x07 /*ep block mask */

#define EPDIS 0x08

#define EOPEN 0x80

#define BLANK 0x04 /*bit masks */

#define ACCERR 0x10

#define PVIOL 0x20

#define CCIF 0x40

#define CBEIF 0x80

#define MASS 0x01 /*bit masks */

#define ERVER 0x04

#define PROG 0x20

#define ERASE 0x40

/************************* Prototypes ****************************************/

void ConfigECLKDIV(void);

UINT8 ProgEeprom(UINT16*, UINT16*, UINT16);

#endif /* End of Header file !defined */

/******************************************************************************

File Name : mcucfg.h

******************************************************************************/

#ifndef MCUCFG_H

#define MCUCFG_H

/************************* System Include Files ******************************/

/************************* Project Include Files *****************************/

#include «stdtypes.h»

/************************* typedefs ******************************************/

/************************* Extern Variables **********************************/

/************************* #Defines ******************************************/

/* Oscillator frequency in kHz */

#define OSCCLK_FREQ_KHZ 16000L /* must have «L» appended for

F/ECLK_PRESCALER macro */

/* register values for PLL */

#define REFDV1 15 /* fref = fosc / (REFDV+1) */

#define SYNR1 24 /* fbus = fref*(SYNR+1) */

/* Bus frequency in kHz */

#define BUSCLK_FREQ_KHZ OSCCLK_FREQ_KHZ*(SYNR1+1)/(REFDV1+1)

/* register base address */

#define REG_BASE 0x0000

/************************* Macros ********************************************/

/************************* Prototypes ****************************************/

#endif /* End of Header file !defined */

/******************************************************************************

File Name : $RCSfile: stdtypes.h

******************************************************************************/

#ifndef STDTYPES_H

#define STDTYPES_H /* this file */

/******************************************************************************

These defines allow for easier porting to other compilers. If porting change

these defines to the required values for the chosen compiler.

******************************************************************************/

typedef unsigned char UINT8; /* unsigned 8-bit */

typedef unsigned int UINT16; /* unsigned 16-bit */

typedef unsigned long UINT32; /* unsigned 32-bit */

typedef signed char INT8; /* signed 8-bit */

typedef int INT16; /* signed 16-bit */

typedef long int INT32; /* signed 32-bit */

/******************************************************************************

Standard Definitions

******************************************************************************/

#ifndef FALSE

#define FALSE 0

#endif

#ifndef TRUE

#define TRUE 1

#endif

/******************************************************************************

Standard Enumerations

******************************************************************************/

#endif /* End of Header file !defined */

При записи слова в память EEPROM функция постоянно возвращает ошибку, из за того что после команды записи проверяя бит estat.bit.accerr он равен 1. (The ACCERR flag indicates an illegal access has occurred to the Flash memory)

Подскажите как быть?????