nz_appConfig.h

Go to the documentation of this file.

#ifndef NZ_APPCONFIG_H
#define NZ_APPCONFIG_H


/* ************************************************************************************************
=============== Modify firmware upgrading and Netcruzer Bootloader ===============
 - Modify bootloader on PIC, so that at startup it checks if there is any configuration data in external
   Flash. If not, it stays in Bootloader mode until config data is uploaded.
 - Modify "Netcruzer USB Bootloader" with new mode where it will automatically upload firmware and config
   from HEX file as soon as board has been programmed. Add a "Run" button to app that becomes available
   once this has been uploaded to device.

=============== Low cost future version using external FLASH - Currently NOT USED ===============
No EEPROM method for configuration data. Store in external serial Flash. Erase sectors 4k.
Configuration data is stored as Id, Value entries. Flash is devided in blocks of 8 bytes.
Each 8 byte block has following format:
- 0-1: First 2 bytes is ID, length and deleted info
       x--- ---- ---- ---- = Deleted bit
       -xxx x--- ---- ---- = Length, gives multiples of 8 byte blocks used. First block has 6 bytes of data, subsequent
                             blocks 8 bytes. This gives max of 6 + (16 x 8) = 134 bytes
       ---- -xxx xxxx xxxx = ID, max of 2048 settings
- 2-7: Data of 6 bytes. If more is needed, length above is used to assign more 8 byte blocks

Each 4K erase block in flash has following format:
- 64 Bytes = Used bit fields (512 bits = 512 x 8 byte blocks). Bit is cleared if pointed to 8 byte block is used
- 64 Bytes = Deleted bit fields (512 bits = 512 x 8 byte blocks). Bit is cleared if pointed to 8 byte block is
             deleted. This will happen if a setting is updated. In this case the old setting will have it's deleted
             bit cleared, and written to next available position in flash.
- 3968 Bytes = 496 x 8 byte blocks

In internal RAM of CPU, a cach area is reserved. Default is 256 bytes. Will contain latest read Id/Value data.
Is saved in 8 byte format, same as defined above. Implemented as circular buffer. Each time a setting is needed that
is not in cach, it is read from Flash, and added to cach. Entries are deleted from head until enough space is made for
newly read setting to be saved.
************************************************************************************************ */


//  Application Configuration - documentation module
//CFG_BLOCK_XXX Structures are used in CFG_STRUCT. Ensure each CFG_BLOCK_XXX
//structure is smaller than 255 bytes.
//Ensure ((size of block)+4) is a 32 byte multiple. Ensure size is 4 less then 32 byte
//multiple, seeing that each CFG_BLOCK_XXX is preceded by a CFG_BLOCK_HDR (4 bytes long).
//Each block MUST have a 'reserve' member (byte array), even if it is 0.
//
//The only reason all CFG_BLOCKs should be 32 byte multiples, is because EEPROM has
//a page write size of 32. So, if we change a whole CFG_BLOCK, and the boundaries
//are on 32 byte blocks, chances are it will require less "EEPROM block writes". Each
//"EEPROM block write" takes about 5 ms, so this speeds things up a bit. BUT, it will
//not make a big difference if CFG_BLOCKs are 16 byte multiples. Do NOT use less than
//16 byte multiples, because the CFG_BLOCK_HDR.size counts in multiples of 16 bytes!

//Config block ID. The following ranges are reserved:
// - 0x0000 to 0x00ff: Used to mark config blocks as deleted
// - 0xff00 to 0xffff: Used to mark config blocks as free
// - 0x8000 to 0xefff: Used for TABLE_BLOCKS = a constant CFG_BLOCK
#define CFG_BLOCK_INFO_ID           0x0100
#define CFG_BLOCK_NET_ID            0x0101
#define CFG_BLOCK_WIFI_ID           0x0102
#define CFG_BLOCK_SNMP_ID           0x0103
#define CFG_BLOCK_GENERAL_ID        0x0104
#define CFG_BLOCK_NET2_ID           0x0105
#define CFG_BLOCK_SER_0TO7_ID       0x0108
#define CFG_BLOCK_SER_8TO15_ID      0x0109
#define CFG_BLOCK_SER_16TO23_ID     0x010A
#define CFG_BLOCK_SER_24TO31_ID     0x010B
#define CFG_BLOCK_STRING_31X8_ID    0x0110  
#define CFG_BLOCK_UC66_PORT_ID      0x0114  
#define CFG_BLOCK_SBC66_PORT_ID     0x0115  
#define CFG_BLOCK_RESERVE_ID        0xFF00  


typedef struct __attribute__((__packed__))
{
    WORD    id;         
    BYTE    reserved;  
    BYTE    size;
} CFG_BLOCK_HDR;



//The TABLE_STRUCT is a structure defining static constants.
//They can not be change, like the CFG_STRUCT.

//Table block ID, use range 0x8000 to 0xefff.
#define TABLE_BLOCK_UC66_PORT_ID        0x8200  
#define TABLE_BLOCK_SBC66_PORT_ID       0x8220  


typedef struct __attribute__((__packed__))
{
    WORD    id;         
    BYTE    reserved;  
    BYTE    size;
} TABLE_BLOCK_HDR;


#define CFG_BLOCK_SIZE(cfgBlk) (sizeof (((CFG_STRUCT*) 0)->cfgBlk) - sizeof (((CFG_STRUCT*) 0)->cfgBlk.reserve))




typedef struct __attribute__((__packed__))
{
    CFG_BLOCK_HDR   hdr;
    
    //Size of configuration data part of CFG_STRUCT. The last part of CFG_STRUCT is TABLE_BLOCKs, and is
    //not part of the configuration data.
    WORD            confSize;

    BYTE            fillConfUpdated;    //Can maybe use for adding to 'confSize', to make it 24 bits
    volatile BYTE   eeConfUpdated;

    BYTE            reserve[24];            
} CFG_BLOCK_INFO;


typedef struct __attribute__((__packed__))
{
    union {
        struct
        {
            unsigned char bCurr : 2;     //Indicates which is current firmware. 0=Unknown, 1=FirmwareA, 2=FirmwareB
            unsigned char bFill : 6;     //Fill to ensure flags take up a 8-bit WORD
        } bits;
        BYTE val;
    } flags;
} FIRMWARE_FLAGS;
#define CURRENT_FIRMWARE_UNKNOWN 0
#define CURRENT_FIRMWARE_A 1
#define CURRENT_FIRMWARE_B 2

#ifndef THIS_IS_NZ_APPCONFIG_C
    extern FIRMWARE_FLAGS   firmwareFlags;
#endif


//External EEPROM Memory defines. IMPORTANT!!! Ensure all start addresses are on 32 byte boundaries
#define XEEMEM_CFG_STRUCT_SIZE          0x0C00      //3 kBytes

#define XEEMEM_CFG_INFO_START_ADR       0x0000
#define XEEMEM_CFG_INFO_END_ADR         0x001F
#define XEEMEM_CFG_COPY_START_ADR       0x0020
#define XEEMEM_CFG_COPY_END_ADR         0x03FF
#define XEEMEM_CFG_COPY_STOP_ADR        0x0400  /* Address of first byte outside of CFG_COPY area */
#define XEEMEM_CFG_COPY_BLOCKS          ((XEEMEM_CFG_COPY_END_ADR-XEEMEM_CFG_COPY_START_ADR+1)/32)
#define XEEMEM_CFG_STRUCT_START_ADR     0x0400
#define XEEMEM_CFG_STRUCT_END_ADR       (XEEMEM_CFG_STRUCT_START_ADR + XEEMEM_CFG_STRUCT_SIZE - 1)
#define XEEMEM_USER_START_ADR           (XEEMEM_CFG_STRUCT_START_ADR + XEEMEM_CFG_STRUCT_SIZE)
#define XEEMEM_USER_END_ADR             (XEEPROM_SIZE - 1)

#define cfgIncCfgCopyAdr(adr) ((adr>=(XEEMEM_CFG_COPY_STOP_ADR-32)) ? XEEMEM_CFG_COPY_START_ADR : (adr+32))


typedef struct __attribute__((packed))
{
    WORD_VAL    magicNumber;    
    WORD_VAL    cfgVersion;     
    WORD_VAL    cfgChecksum;    
    WORD_VAL    cfgCRC;         
} CFG_INFO;
#define CFG_INFO_MAGIC_NUMBER  0x536A
#define CFG_VERSION_MAJOR       1
#define CFG_VERSION_MINOR       0

#define CFG_COPY_DATA_SIZE 26

typedef struct __attribute__((packed))
{
    BYTE        IncNum;
    WORD        Address;
    BYTE        Size;
    BYTE        CRC;
    BYTE        Data[CFG_COPY_DATA_SIZE];
    BYTE        IncNumPlusOne;
} CFG_COPY;


void cfgInit(BYTE* pCfgStructInfo);

BYTE cfgIsXeepromValid(void);

void cfgInvalidateXeeprom(void);

BYTE cfgGetDfltArray(WORD offset, BYTE* buf, BYTE length);

#define cfgGetDfltStruct(member, struc) cfgGetDfltArray(offsetof(CFG_STRUCT, member), ((BYTE*)&struc), sizeof(struc))

BYTE cfgBlkGetArray(WORD cfgBlkId, WORD offset, BYTE* buf, BYTE length);

BYTE cfgGetArray(WORD offset, BYTE* buf, BYTE length);

#define cfgGetStruct(member, struc) cfgGetArray(offsetof(CFG_STRUCT, member), ((BYTE*)&struc), sizeof(struc))


//#define cfgGetByte(offset) (*(((BYTE*)&cfgStruct) + offset));
#define cfgGetByte(offset) (((BYTE*)&cfgStruct)[offset]);

void cfgSaveByte(WORD offset, BYTE val);

void cfgSaveArray(WORD offsetCfg, BYTE* buf, WORD length);

void cfgSave(void);

#endif