The EEPROM interface is a crucial feature in the ATmega328 microcontroller, providing 1024 bytes of non-volatile memory for storing configuration data, calibration values, and other persistent information that must survive power cycles. Unlike RAM, EEPROM retains data without power, making it ideal for saving user settings, device parameters, sensor calibration data, and system logs. This repository covers the register-level configuration, practical usage examples, and important considerations for implementing reliable EEPROM operations in embedded systems.
|
Tip If you're looking to better understand how to navigate and use my GitHub repositories — including exploring their structure, downloading or cloning projects, submitting issues, and asking questions, |
|
|
|
Important Begin your embedded systems journey with clarity and purpose. This episode outlines a structured roadmap for mastering microcontrollers, communication protocols, hardware design, and project development. |
|
|
|
Caution It is absolutely critical that you carefully read every single word of this document, line by line, to ensure you don't miss any details. Nothing can be overlooked. |
||
✅ Unsigned integers: uint8_t, uint16_t, uint32_t
✅ Signed integers: int8_t, int16_t, int32_t
✅ Floating-point: float (IEEE 754 single-precision)
✅ Byte arrays: Block read/write operations
✅ Update functions that compare before writing
✅ Extends EEPROM lifespan by avoiding unnecessary write cycles
✅ Critical for applications with frequent data updates
✅ Atomic erase-and-write operations (hardware controlled)
✅ Little-endian byte order for multi-byte values
✅ Protection against partial writes during power loss
✅ Direct write for initial programming
✅ Smart update for runtime modifications
✅ Block operations for efficient array storage
✅ Format function to reset EEPROM to blank state
| Parameter | Value |
|---|---|
| Memory Size | 1024 bytes (1 KB) |
| Address Range | 0x0000 to 0x03FF (0 to 1023) |
| Write Time | ~3.3 ms per byte (typical at 25°C) |
| Write Endurance | 100,000 cycles minimum per location |
| Data Retention | 20 years at 85°C, 100 years at 25°C |
| Byte Order | Little-endian (LSB first) |
| Operation Mode | Atomic erase-and-write |
| Read Speed | ~4 CPU cycles (fast) |
Here you'll find a collection of useful links and videos related to the topic of AVR microcontrollers.
EEPROM Overview
├── [API_Reference]
│ ├─ Files — e2prom.h / e2prom.c
│ ├─ Write Functions — uint8, uint16, uint32, float, int8, int16, int32, block
│ ├─ Read Functions — uint8, uint16, uint32, float, int8, int16, int32, block
│ ├─ Update Functions — Wear-leveling versions of write (compare before write)
│ ├─ Utility — Format (erase entire EEPROM)
│ └─ Purpose — High-level EEPROM interface for storing multiple data types
│ with automatic wear-leveling and endurance optimization
|
└── Registers
├─ [EEAR / EEARH / EEARL] — EEPROM Address Register — 10-bit address (0-1023)
├─ [EEDR] — EEPROM Data Register — 8-bit data for read/write operations
└─ [EECR] — EEPROM Control Register — Controls operations and modes
├─ EERE — EEPROM Read Enable
├─ EEPE — EEPROM Program Enable (write trigger)
├─ EEMPE — EEPROM Master Program Enable (safety mechanism)
├─ EERIE — EEPROM Ready Interrupt Enable
└─ EEPM1:EEPM0 — Programming mode selection (erase+write, erase, write)
Tip
The resources are detailed in the sections below.
To access any of them, simply click on the corresponding blue link.
-
Comprehensive documentation covering all EEPROM control registers (EEAR, EEDR, EECR), programming modes, write/read operation sequences, timing requirements, atomic access considerations, interrupt handling, data protection strategies, and wear-leveling techniques. Includes timing diagrams, practical examples, and troubleshooting guidelines.
-
This section provides detailed descriptions of the functions in the
e2prom.hande2prom.cfiles for handling EEPROM operations on the ATmega328 microcontroller. Each function is designed to store and retrieve different data types (unsigned integers, signed integers, floats, and byte arrays) with support for wear-leveling through update functions. These APIs simplify EEPROM management by providing type-safe interfaces for reading, writing, and updating persistent data, making it easier to implement configuration storage, data logging, and calibration value retention in your projects.
AVR, EEPROM
├── [aKaReZa 131 - AVR, EEPROM - PART A]
│ ├─ Concept — AVR internal EEPROM structure and use cases.
│ ├─ Registers — EEAR, EEDR, EECR bit-by-bit review.
│ ├─ Functions — uint8_write(), uint16_write(), uint32_write().
│ ├─ Endianness — Storage order considerations.
│ ├─ Type Punning — Advantages and safe usage.
│ └─ Project — Building and testing EEPROM write routines.
│
└── [aKaReZa 134 - AVR, EEPROM - PART B]
├─ Float — Implementing float_Write() for floating‑point storage.
├─ Block — Writing arrays and strings with block_Write().
├─ Read — Functions for reading multiple data types.
├─ Update — Smart update functions to reduce wear.
├─ Timing — Execution‑time analysis and comparisons.
├─ Signed — Write/Read/Update for signed data types.
└─ Format — Erasing the entire EEPROM memory.
|
Explore the internal EEPROM of AVR microcontrollers—a powerful feature for permanent data storage across resets and power cycles. This tutorial provides a bit-by-bit review of EEAR, EEDR, and EECR registers, and guides you through writing functions like |
|
|
Continue exploring advanced EEPROM data storage on AVR. This episode covers writing floats and arrays, reading multiple data types, implementing smart Update functions to reduce wear, analyzing execution time, and adding full‑memory formatting. A solid foundation for building efficient and reliable data‑persistence systems in embedded projects. |
|
To access the repository files and save them on your computer, there are two methods available:
-
Using Git Bash and Cloning the Repository
- This method is more suitable for advanced users and those familiar with command-line tools.
- By using this method, you can easily receive updates for the repository.
-
Downloading the Repository as a ZIP file
- This method is simpler and suitable for users who are not comfortable with command-line tools.
- Note that with this method, you will not automatically receive updates for the repository and will need to manually download any new updates.
First, open Git Bash :
- Open the folder in File Explorer where you want the library to be stored.
- Right-click inside the folder and select the option "Open Git Bash here" to open Git Bash in that directory.
Note
If you do not see the "Open Git Bash here" option, it means that Git is not installed on your system.
You can download and install Git from this link.
For a tutorial on how to install and use Git, check out this video.
- Once Git Bash is open, run the following command to clone the repository:
git clone https://github.com/aKaReZa75/AVR_e2prom- You can copy the above command by either:
- Clicking on the Copy button on the right of the command.
- Or select the command text manually and press Ctrl + C to copy.
- To paste the command into your Git Bash terminal, use Shift + Insert.
- Then, press Enter to start the cloning operation and wait for the success message to appear.
Important
Please keep in mind that the numbers displayed in the image might vary when you perform the same actions.
This is because repositories are continuously being updated and expanded. Nevertheless, the overall process remains unchanged.
Note
Advantage of Cloning the Repository:
- Receiving Updates: By cloning the repository, you can easily and automatically receive new updates.
- Version Control: Using Git allows you to track changes and revert to previous versions.
- Team Collaboration: If you are working on a project with a team, you can easily sync changes from team members and collaborate more efficiently.
If you prefer not to use Git Bash or the command line, you can download the repository directly from GitHub as a ZIP file.
Follow these steps:
-
Navigate to the GitHub repository page and Locate the Code button:
- On the main page of the repository, you will see a green Code button near the top right corner.
-
Download the repository:
- Click the Code button to open a dropdown menu.
- Select Download ZIP from the menu.
-
Save the ZIP file:
- Choose a location on your computer to save the ZIP file and click Save.
-
Extract the ZIP file:
- Navigate to the folder where you saved the ZIP file.
- Right-click on the ZIP file and select Extract All... (Windows) or use your preferred extraction tool.
- Choose a destination folder and extract the contents.
-
Access the repository:
- Once extracted, you can access the repository files in the destination folder.
Important
- No Updates: Keep in mind that downloading the repository as a ZIP file does not allow you to receive updates.
If the repository is updated, you will need to download it again manually. - Ease of Use: This method is simpler and suitable for users who are not comfortable with Git or command-line tools.
If you have any questions or issues, you can raise them through the "Issues" section of this repository. Here's how you can do it:
- Navigate to the "Issues" tab at the top of the repository page.
- Click on the "New Issue" button.
-
In the Title field, write a short summary of your issue or question.
-
In the "Description" field, detail your question or issue as thoroughly as possible. You can use text formatting, attach files, and assign the issue to someone if needed. You can also use text formatting (like bullet points or code snippets) for better readability.
-
Optionally, you can add labels, type, projects, or milestones to your issue for better categorization.
-
Click on the "Submit new issue" button to post your question or issue.
I will review and respond to your issue as soon as possible. Your participation helps improve the repository for everyone!
Tip
- Before creating a new issue, please check the "Closed" section to see if your question has already been answered.
- Write your question clearly and respectfully to ensure a faster and better response.
- While the examples provided above are in English, feel free to ask your questions in Persian (فارسی) as well.
- There is no difference in how they will be handled!
Note
Pages and interfaces may change over time, but the steps to create an issue generally remain the same.
To contribute to this repository, please follow these steps:
- Fork the Repository
- Clone the Forked Repository
- Create a New Branch
- Make Your Changes
- Commit Your Changes
- Push Your Changes to Your Forked Repository
- Submit a Pull Request (PR)
Note
Please ensure your pull request includes a clear description of the changes you’ve made. Once submitted, I will review your contribution and provide feedback if necessary.
If you found this repository useful:
- Subscribe to my YouTube Channel.
- Share this repository with others.
- Give this repository and my other repositories a star.
- Follow my GitHub account.
This project is licensed under the GPL-3.0 License. This license grants you the freedom to use, modify, and distribute the project as long as you:
- Credit the original authors: Give proper attribution to the original creators.
- Disclose source code: If you distribute a modified version, you must make the source code available under the same GPL license.
- Maintain the same license: When you distribute derivative works, they must be licensed under the GPL-3.0 too.
- Feel free to use it in your projects, but make sure to comply with the terms of this license.
Feel free to reach out to me through any of the following platforms: