PIC BTC EEPROM Convert: A Step-by-Step Guide Microchip PIC microcontrollers are widely used in industrial automation, automotive systems, and consumer electronics. A common challenge developers face when working with these devices is converting and processing data types—specifically converting Binary-Coded Decimal (BCD) to Binary (or ASCII) for internal storage in the Electrically Erasable Programmable Read-Only Memory (EEPROM).
In many legacy systems, “BTC” refers to Binary-to-BCD/ASCII Conversion routines. This step-by-step guide explains how to convert BCD data into raw binary format and safely store or read it from a PIC microcontroller’s non-volatile EEPROM. Understanding the Concepts
Before diving into the code, it is essential to understand how these data types interact inside the microcontroller.
BCD (Binary-Coded Decimal): A digital encoding method where each decimal digit is represented by a fixed number of bits, usually four (a nibble). For example, the decimal number 42 is represented as 0100 0010 in packed BCD.
Binary: The native format the PIC microcontroller uses for mathematical operations. The decimal number 42 is represented as 0010 1010 in binary.
EEPROM: On-chip, non-volatile memory used to save critical system parameters (like calibration constants or user settings) that must persist when the power is turned off. Step 1: Set Up the Conversion Logic (BTC)
To convert a packed BCD byte coming from an external sensor or Real-Time Clock (RTC) into a standard binary byte for EEPROM optimization, you must separate the high and low nibbles. The Conversion Algorithm Isolate the upper 4 bits (tens place) and multiply by 10. Isolate the lower 4 bits (ones place).
Add the two values together to get the final binary representation. C Code Implementation (MPLAB XC8)
unsigned char BCD_To_Binary(unsigned char bcd_val) { unsigned char tens = (bcd_val >> 4)10; unsigned char ones = bcd_val & 0x0F; return (tens + ones); } Use code with caution. Step 2: Configure the PIC EEPROM Registers
PIC microcontrollers utilize specific Special Function Registers (SFRs) to control EEPROM operations. Depending on your specific PIC family (e.g., PIC16F or PIC18F), these registers typically include: EEADR / EEADRH: Holds the target EEPROM address. EEDATL / EEDATA: Holds the data byte to be read or written. EECON1: Controls the operation (Read, Write, Enable bits).
EECON2: A hidden register used exclusively for the required write unlock sequence. Step 3: Implement the EEPROM Write Function
Writing to EEPROM requires a strict, hardware-enforced unlock sequence to prevent accidental data corruption during power fluctuations. Interrupts must be disabled during this specific sequence.
void EEPROM_Write(unsigned char address, unsigned char data) { // Load address and data EEADR = address; EEDATA = data; // Point to Data EEPROM memory EECON1bits.EEPGD = 0; EECON1bits.CFGS = 0; // Enable write operations EECON1bits.WREN = 1; // Required Unlock Sequence INTCONbits.GIE = 0; // Disable Interrupts EECON2 = 0x55; EECON2 = 0xAA; EECON1bits.WR = 1; // Begin Write INTCONbits.GIE = 1; // Re-enable Interrupts // Wait for write operation to complete while(EECON1bits.WR); // Disable write operations for safety EECON1bits.WREN = 0; } Use code with caution. Step 4: Implement the EEPROM Read Function
Reading data from the EEPROM is simpler than writing, does not require an unlock sequence, and completes within a single clock cycle.
unsigned char EEPROM_Read(unsigned char address) { EEADR = address; // Load target address EECON1bits.EEPGD = 0; // Point to Data EEPROM EECON1bits.CFGS = 0; // Access EEPROM EECON1bits.RD = 1; // Init Read return EEDATA; // Return the data byte } Use code with caution. Step 5: Putting It All Together
The final step connects the BTC conversion module to your system’s data stream and logs the variables to the EEPROM.
void main(void) { // Example input: BCD representation of 42 (0x42) unsigned char bcd_sensor_data = 0x42; unsigned char binary_data; unsigned char stored_data; // Step 1: Convert BCD to Binary binary_data = BCD_To_Binary(bcd_sensor_data); // Step 2: Write the converted binary value to EEPROM address 0x10 EEPROM_Write(0x10, binary_data); // Step 3: Verify by reading it back stored_data = EEPROM_Read(0x10); while(1) { // Main application loop } } Use code with caution. Best Practices for PIC EEPROM Handling
Mind the Endurance: Microchip EEPROMs typically support around 100,000 to 1,000,000 write cycles. Avoid writing data inside tight, continuous loops. Only execute a write command if the new value differs from the currently stored value.
Brown-Out Reset (BOR): Enable BOR in your PIC configuration bits. This prevents the CPU from executing corrupt instructions—and accidentally triggering an EEPROM write sequence—if the voltage drops below operational thresholds.
Keep Interrupts Short: Because interrupts must be disabled during the execution of the 0x55/0xAA unlock sequence, ensure your timing-critical ISRs (Interrupt Service Routines) can tolerate a temporary pause of a few instruction cycles.
If you are working with a specific PIC model or toolchain, let me know the device family (e.g., PIC16F877A, PIC18F4550) or your compiler (XC8, ASM) so I can adapt the register syntax for your hardware.
Leave a Reply