eeprom.h

Go to the documentation of this file.

#ifndef STC15_EEPROMH
#define STC15_EEPROMH
 
#include <sys.h>
#include <bits.h>
#include <power_management.h>
 
 
enum eeprom_operation_t
{
    READ_OP = 0x01,
    WRITE_OP = 0x02,
    ERASE_OP = 0x03,
};
 
typedef enum
{
    CMD_SUCCESS = 0,
    CMD_FAIL_ERROR = 1,
    LOW_VOLTAGE_ERROR = 2,
} eeprom_operation_status_t;
 
 
#define OP_TRIGGER_SEQ_FIRST_BYTE 0x5A
#define OP_TRIGGER_SEQ_SECOND_BYTE 0xA5
 
#define CMD_FAIL_BIT 4
 
#define ERROR_VALUE 0xFF
 
#define eeprom_disable_iap()                    \
do {                                            \
        /* Disable IAP */                       \
        bit_clr(IAP_CONTR, SBIT7);              \
        IAP_CMD = 0x00;                         \
        IAP_TRIG = 0x00;                        \
        IAP_ADDRH = 0xFF;                       \
        IAP_ADDRL = 0xFF;                       \
} while(0)
 
#define get_eeprom_last_operation_result() (test_if_bit_set(IAP_CONTR, CMD_FAIL_BIT) ? CMD_FAIL_ERROR : CMD_SUCCESS)
 
#define eeprom_read_byte(addr_high, addr_low, value_ptr, error_ptr)     \
do {                                                                    \
    if (get_power_low_voltage_flag())                                   \
    {                                                                   \
        *error_ptr = LOW_VOLTAGE_ERROR;                                 \
        *value_ptr = ERROR_VALUE;                                       \
    }                                                                   \
    else                                                                \
    {                                                                   \
        /* Enable IAP */                                                \
        bit_set(IAP_CONTR, SBIT7);                                      \
        /* Set IAP WT2 WT1 WT0 to 011 for eeprom read waiting */        \
        IAP_CONTR &= ~0x07;                                             \
        IAP_CONTR |= 0x03;                                              \
                                                                        \
        /* Set address */                                               \
        IAP_ADDRH = (addr_high);                                        \
        IAP_ADDRL = (addr_low);                                         \
                                                                        \
        /* Set read operation */                                        \
        IAP_CMD = READ_OP;                                              \
                                                                        \
        /* Set start operation sequence */                              \
        IAP_TRIG = OP_TRIGGER_SEQ_FIRST_BYTE;                           \
        IAP_TRIG = OP_TRIGGER_SEQ_SECOND_BYTE;                          \
                                                                        \
        /* Wait for operation to complete */                            \
        NOP();                                                          \
                                                                        \
        /* Read error status from IAP */                                \
        *error_ptr = get_eeprom_last_operation_result();                \
        /* if no operation error read data from IAP otherwise value is ERROR_VALUE */ \
        *value_ptr = (*error_ptr) ? ERROR_VALUE : IAP_DATA;             \
                                                                        \
        eeprom_disable_iap();                                           \
    }                                                                   \
} while (0)
 
#define eeprom_erase_page(sector_start_addr, error_ptr)         \
do {                                                            \
    if (get_power_low_voltage_flag())                           \
    {                                                           \
        *error_ptr = LOW_VOLTAGE_ERROR;                         \
    }                                                           \
    else                                                        \
    {                                                           \
        /* Set address */                                       \
        IAP_ADDRH = (sector_start_addr);                        \
        IAP_ADDRL = 0x00;                                       \
                                                                \
        /* Set erase operation waiting */                       \
        IAP_CONTR &= ~0x07;                                     \
        IAP_CONTR |= 0x03;                                      \
                                                                \
        /* Enable IAP */                                        \
        bit_set(IAP_CONTR, SBIT7);                              \
                                                                \
        /* Set erase operation */                               \
        IAP_CMD = ERASE_OP;                                     \
                                                                \
        /* Set start operation sequence */                      \
        IAP_TRIG = OP_TRIGGER_SEQ_FIRST_BYTE;                   \
        IAP_TRIG = OP_TRIGGER_SEQ_SECOND_BYTE;                  \
                                                                \
        /* Wait for operation to complete */                    \
        NOP();                                                  \
                                                                \
        /* Read error status from IAP */                        \
        *error_ptr = get_eeprom_last_operation_result();        \
                                                                \
        eeprom_disable_iap();                                   \
    }                                                           \
} while(0)
 
#define eeprom_write_byte(addr_high, addr_low, value, error_ptr)    \
do {                                                                \
    if (get_power_low_voltage_flag())                               \
    {                                                               \
        *error_ptr = LOW_VOLTAGE_ERROR;                             \
    }                                                               \
    else                                                            \
    {                                                               \
        /* Set address */                                           \
        IAP_ADDRH = addr_high;                                      \
        IAP_ADDRL = addr_low;                                       \
                                                                    \
        /* Set write operation waiting */                           \
        IAP_CONTR &= ~0x07;                                         \
        IAP_CONTR |= 0x03;                                          \
                                                                    \
        /* Enable IAP */                                            \
        bit_set(IAP_CONTR, SBIT7);                                  \
                                                                    \
        /* Set write operation */                                   \
        IAP_CMD = WRITE_OP;                                         \
                                                                    \
        /* Set data */                                              \
        IAP_DATA = value;                                           \
                                                                    \
        /* Set start operation sequence */                          \
        IAP_TRIG = OP_TRIGGER_SEQ_FIRST_BYTE;                       \
        IAP_TRIG = OP_TRIGGER_SEQ_SECOND_BYTE;                      \
                                                                    \
        /* Wait for operation to complete */                        \
        NOP();                                                      \
                                                                    \
        /* Read error status from IAP */                            \
        *error_ptr = get_eeprom_last_operation_result();            \
                                                                    \
        eeprom_disable_iap();                                       \
    }                                                               \
} while (0)
 
#define eeprom_write_page(addr_high, arr, arr_size, error_ptr)        \
do {                                                                  \
    eeprom_erase_page(addr_high, error_ptr);                          \
    if (*error_ptr)                                                   \
    {                                                                 \
        break;                                                        \
    }                                                                 \
                                                                      \
    for (uint8_t i = 0; i < arr_size; i++)                            \
    {                                                                 \
        eeprom_write_byte(addr_high, i, arr[i], error_ptr);           \
        if (*error_ptr)                                               \
        {                                                             \
            break;                                                    \
        }                                                             \
    }                                                                 \
} while(0)                                                                
 
#endif