PAGE_SIZE      = [FILL IN: Target AVR page size in bytes]
MEM_SIZE       = [FILL IN: Application Section size in bytes]
CRC_ENABLE     = [FILL IN: YES/NO]
KEY1           = FE6807733E9702E34D6759A56A8D4A46078E
KEY2           = 1F555D210E89036971
KEY3           = FE0EE7FD837569EFE4
INITIAL_VECTOR = 789280B50E473F2303EB08E795D5A72F
SIGNATURE      = 8FB5DF40

PAGE_SIZE      = 256
MEM_SIZE       = 256
CRC_ENABLE     = YES

:100000000C946500000000000000000000000000EB
:1000100000000000000000000000000000000000E0
:1000200000000000000000000000000000000000D0
:1000300000000000000000000000000000000000C0
:1000400000000000000000000000000000000000B0
:1000500000000000000000000000000000000000A0
:100060000000000000000000000000000000000090
:100070000000000000000000000000000000000080
:100080000000000000000000000000000000000070
:100090000000000000000000249A2C9A0FEF12E5E7
:1000A00027E0015010402040E1F700C000002C98EC
:1000B0000FEF12E527E0015010402040E1F700C0AB
:1000C0000000EBCF00008895FECF0FE30DBF01E0ED
:1000D0000EBFC0E4D3E00E9473000E944C000E9457
:1000E00062000C94620001E008950000000000002E
:1000F0000000000000000000000000000000000000

:100000000C946500000000000000000000000000EB
:1000100000000000000000000000000000000000E0
:1000200000000000000000000000000000000000D0
:1000300000000000000000000000000000000000C0
:1000400000000000000000000000000000000000B0
:1000500000000000000000000000000000000000A0
:100060000000000000000000000000000000000090
:100070000000000000000000000000000000000080
:100080000000000000000000000000000000000070
:100090000000000000000000249A2C9A0FEF12E5E7
:1000A00027E0015010402040E1F700C000002C98EC
:1000B0000FEF12E527E0015010402040E1F700C0AB
:1000C0000000EBCF00008895FECF0FE30DBF01E0ED
:1000D0000EBFC0E4D3E00E9473000E944C000E9457
:1000E00062000C94620001E008950000000000002E
:0E00F000000000000000000000000000000002

PAGE_SIZE      = 256
MEM_SIZE       = 57344
CRC_ENABLE     = YES
KEY1           = FE6807733E9702E34D6759A56A8D4A46078E
KEY2           = 1F555D210E89036971
KEY3           = FE0EE7FD837569EFE4
INITIAL_VECTOR = 789280B50E473F2303EB08E795D5A72F
SIGNATURE      = 8FB5DF40

CRC_ENABLE     = NO

        #ifdef CRC_CHECK
        // Check that the Application Section contents is undamaged
        // by calculating the CRC of the whole memory.
        {
            unsigned int crc = 0;
            unsigned char APPFLASH *p = (unsigned char APPFLASH *)0x000000;
            unsigned char APPFLASH *n = (unsigned char APPFLASH *)MEM_SIZE;
    
            do
            {
                crc = CRC(crc, *p++);
            }
            while (--n);
    
            // Application Section damaged
            //   -> do not jump to Reset Vector of the Application Section
            if (crc)
                continue;
        }

        #ifdef CRC_CHECK
        // Check that the Application Section contents is undamaged
        // by calculating the CRC of the whole memory.
        {
            unsigned int crc = 0;
            unsigned char APPFLASH *p = (unsigned char APPFLASH *)0x000000;
            unsigned char APPFLASH *n = (unsigned char APPFLASH *)MEM_SIZE;
    
            do
            {
                crc = CRC(crc, *p++);
            }
            while (--n);
    
            // Application Section damaged
            //   -> do not jump to Reset Vector of the Application Section
            if (crc)
                continue;
        }

typedef unsigned int uint16_t;
typedef unsigned char uint8_t;

uint16_t crc_xmodem_update (uint16_t crc, uint8_t data)
{
crc = crc ^ ((uint16_t)data << 8);
for (uint16_t i = 0; i < 8; i++)
{
if (crc & 0x8000)
crc = (crc << 1) ^ 0x1021;
else
crc <<= 1;
}
return crc;
}
//==============================================
void TestChecksum()
{
uint16_t crc = 0;
uint8_t APPFLASH *p = (uint8_t APPFLASH *)0x0000;
for(uint16_t j = 0; j < 16; j++) // test
{
crc = crc_xmodem_update(crc, *p++);
}

busReplyByte(crc >> 8);
busReplyByte(crc & 0xFF);

//37FE-37FF
p = (uint8_t APPFLASH *)0x37FF;
uint16_t crcFlash = (*p << 8);
p = (uint8_t APPFLASH *)0x37FE;
crcFlash |= (*p);

busReplyByte(crcFlash >> 8);
busReplyByte(crcFlash & 0xFF);

if (crc != crcFlash)
{
do {
PORTB ^= (1 << PB4);
__delay_cycles( 7000000 );
} while(1);
}
else
{
do {
PORTB ^= (1 << PB4);
__delay_cycles( 700000 );
} while(1);
}
}

D:\test aes>create -c Config.txt -f flash.hex -o update.enc

create v1.0AES - Copyright (C) 2005 Atmel Corporation

Using the following arguments:
  Config filename: Config.txt
  Flash filename:  flash.hex
  Output filename: update.enc


The following configuration will be used:
  Encryption      = 256-bit AES, cipher block chaining mode
    KEY1          = 0AB4D1381586C8A569D05984D93521440EA1
    KEY2          = 15203DB3CFAECA5793
    KEY3          = 87D069CA109F6E2522
  INITIAL_VECTOR  = 301FEBB0153B76AB8CD9D430645D646F
  SIGNATURE       = 1C1BB801
  PAGE_SIZE       = 256
  MEM_SIZE        = 57344
  CRC_ENABLE      = YES

Read flash.hex!
Error: Overlapping memory assignments in file .

__C_task void loader(void)
{

#if KEY_COUNT > 0
unsigned char chainCipherBlock[16]; // Buffer for Cipher Block
// Unchaining

// Copy Initial Vector to start the cipher block unchaining
{
unsigned char *p = chainCipherBlock;
unsigned char BOOTFLASH *q = initialVector;
unsigned char n = 16;

do
{
*p++ = *q++;
}
while (--n);
}

aesInit( tempbuf ); // Init AES algorithm.
#endif

// Prepare bus for incoming frames...
busPrepare();

// Start the Watchdog Timer (sorry for the mess, there is a bug in
// iom8.h (in version 2.28A) which is informed to IAR).
#if 1
#if !defined(WDTCR) && !defined(__IOM8_H)
#define WDTCR WDTCSR
#endif

#if defined(__IOM16_H) || defined(__IOM32_H)
WDTCR = (7 << WDP0) | (1 << WDE);
#else
#if defined(__IOM8_H)
WDTCR = (1 << WDTOE) | (1 << WDE);
#else
WDTCR = (1 << WDCE) | (1 << WDE);
#endif
WDTCR = (7 << WDP0) | (1 << WDE);
#endif
#endif
PORTD &= ~(1 << PD6); // направление RS-485, на ввод


// Loop forever (the loop is broken by Watchdog when RESET record is
// received)
for (;;)
{
frameindex_t frameSize;
unsigned int crc;

// Get the frame size
frameSize = ((frameindex_t)busReceiveByte() << 8) | busReceiveByte();

// Receive a frame of data from communication interface and calculate
// its CRC
{
unsigned char *p = rxBuffer;
frameindex_t n = frameSize;

crc = 0;
do
{
unsigned char ch;

ch = busReceiveByte();

*p++ = ch;
crc = CRC(crc, ch);

__watchdog_reset();
}
while (--n);

busBusy();
}

// CRC is OK?
if (crc == 0x0000)
{


unsigned char *p = rxBuffer;

// Decrypt 16 bytes, CRC-bytes are ignored.
#if KEY_COUNT > 0
{
unsigned char *p = rxBuffer;

frameSize -= 2;
do
{
__watchdog_reset();
aesDecrypt(p, chainCipherBlock);
p += 16;
}
while (frameSize -= 16);
}
#endif // KEY_COUNT > 0

// Check that the signature is correct
if ((*p++ == (unsigned char)(SIGNATURE >> 24)) &&
(*p++ == (unsigned char)(SIGNATURE >> 16)) &&
(*p++ == (unsigned char)(SIGNATURE >> 8)) &&
(*p++ == (unsigned char)(SIGNATURE >> 0)))
{
unsigned char APPFLASH *address;
unsigned char bits;
frameindex_t size;
unsigned char type;

// Continue parsing the frames until the 'End Of Frame' is
// received
while ((type = *p++) != TYPE_EOF)
{
__watchdog_reset();

// Receive Lock Bits (used in TYPE_LOCKBITS)
bits = *p++;

// Destination Address (note: 'bits' and 'address' overlap)
#pragma diag_suppress=Pe1053 // Suppress warning for conversion from long-type address to flash ptr.
address =
(unsigned char APPFLASH *)((unsigned long)bits << 16);
address = (unsigned char APPFLASH *)
((unsigned long)address | ((unsigned long)*p++ << 8));
address = (unsigned char APPFLASH *)
((unsigned long)address | *p++);
#pragma diag_default=Pe1053 // Back to default.

size = ((unsigned int)*p++ << 8);
size |= *p++;

switch (type)
{

// Erase page
case TYPE_ERASE:

_SPM_ERASE(address);
while(SPMCSR & (1<<0));
//spmErasePage(address);
// Fall-through!

// Prepare for incoming data chunks by copying the page
// contents into the page buffer
case TYPE_PREPARE:
{

unsigned char *q = pageBuffer;
unsigned char APPFLASH *r = address;

do
{
*q++ = *r++;
}
while (--size);
break;
}

// Chunk of data is written into the page buffer
case TYPE_DATA:
{

unsigned char *r =
&pageBuffer[(unsigned long)(address) & 0xffff];

do
{
*r++ = *p++;
}
while (--size);

break;
}

// Program page buffer into flash page
case TYPE_PROGRAM:
{

unsigned int *q = (unsigned int *)pageBuffer;
unsigned char APPFLASH *r = address;

do
{

__watchdog_reset();
//spmWriteWord(r, *q++);
_SPM_FILLTEMP(r, *q++);


r += 2;
}
while (--size);
_SPM_ERASE(address); while(SPMCSR & (1<<0));
//spmErasePage(address);
_SPM_PAGEWRITE(address); while(SPMCSR & (1<<0));
//spmProgramPage(address);

break;
}

// Write a chunk of data into EEPROM
case TYPE_EEPROM:
do
{
__watchdog_reset();
__EEPUT(((unsigned long)address++ & 0xffff), *p++);
// spmEEWriteByte(
// (unsigned long)address++ & 0xffff, *p++
// );
}
while (--size);
break;

// Write Lock Bits
case TYPE_LOCKBITS:
// spmWriteLockBits(bits);
_SPM_LOCKBITS(bits); while(SPMCSR & (1<<0));
break;

// Reset (let the Watchdog Timer expire)!
case TYPE_RESET:

PORTD |= (1 << PD6); // направление RS-485, на вывод
__delay_cycles( 10 );
busReplyByte(ERROR_OK);
__delay_cycles( 4000 );
PORTD &= ~(1 << PD6); // направление RS-485, на ввод

for(;;);

// Nonsense frames, one byte long
default:

PORTD &= ~(1 << PD6); // направление RS-485, на ввод
p -= 5;
break;
}
}
}

PORTD |= (1 << PD6); // направление RS-485, на вывод
__delay_cycles( 10 );
busReplyByte(ERROR_OK);
__delay_cycles( 4000 );
PORTD &= ~(1 << PD6); // направление RS-485, на ввод
}
else
{
PORTB |= (1 << PB4); // светодиод
PORTD |= (1 << PD6); // направление RS-485, на вывод
__delay_cycles( 10 );
busReplyByte(ERROR_CRC);
__delay_cycles( 4000 );
PORTD &= ~(1 << PD6); // направление RS-485, на ввод
PORTB &= ~(1 << PB4); // светодиод
}
}
}

    aesM->scheduleKey(key);

    if (createFlashCRCM && flashM)
    {
        // Calculates the CRC of Application Section and inserts it to the
        // MemoryMap of the flash memory
        unsigned int address;
        unsigned short crcCode = 0;
        DataBuffer crcBuffer;

        for (address = 0; address < memSizeM - 2; address++)
            crcCode = crc(flashM->at(address), crcCode);

        crcCode = crc(0, crcCode);
        crcCode = crc(0, crcCode);

        crcBuffer += (unsigned char)(crcCode >> 8);
        crcBuffer += (unsigned char)(crcCode & 0xff);

        flashM->insert(memSizeM - 2, crcBuffer);
    }