[参考译文] CC1310：具有自定义引导加载程序的 AES

是否在退出引导加载程序之前关闭加密驱动程序？ 这会立即关闭加密加速器并清除密钥存储。 当应用程序再次打开驱动程序时、它应找到处于预期状态的加密加速器。

通常、您应该在离开引导加载程序之前关闭所有驱动程序、因为这样。

引导加载程序中没有加密驱动程序。 并且在打开任何驱动程序前、我执行跳转到主代码：

void main(void)
{
    uint32_t i,j,k;

    uint8_t tempChar;
    if(IsExecUserCode())
        {
            //ExecUserCode();
        asm(" MOV R0, #0x5000 ");     // The .resetVecs or .intvecs for the app are
                                               // are placed at the constant #0xXXXX address
           asm(" LDR SP, [R0, #0x0] ");  // Load the initial stack pointer
           asm(" LDR R1, [R0, #0x4] ");  // Load the Reset vector address
           asm(" BX R1 ");               // Jump to the application Reset vector
        }
    Watchdog_init();
    Watchdog_Params_init(&wd_params);
    wd_params.resetMode = Watchdog_RESET_ON;

我曾尝试在主程序中关闭 AES 域、没有效果

int main(void)
{

  

    HWREG(PRCM_BASE + PRCM_O_PDCTL0PERIPH) = 0;
    HWREG(PRCM_BASE + PRCM_O_PDCTL0RFC) = 0;

    HWREG(PRCM_BASE + PRCM_O_PDCTL0PERIPH) = 1;
    HWREG(PRCM_BASE + PRCM_O_PDCTL0RFC) = 1;

    PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE|PRCM_DOMAIN_PERIPH)  ;

    CRYPTOIntClear  (CRYPTO_DMA_IN_DONE|CRYPTO_RESULT_RDY   );
    
    
    /* Call driver init functions */
    Board_initGeneral();

    GPIO_init();

引导加载程序激活前会发生什么情况？ MCU 是来自上电复位还是看门狗复位？

现在、在硬件复位测试期间、可能还有一些 POR 情况。 通常 ，程序会  在镜像加载到外部闪存中后调用 SysCtrlSystemReset()。 复位之后和之前接收到的代码相同-加密密钥相同且不更改。 我找到这个。 当 我更改二进制映像时、例如使用优化设置时、收到的代码会在 使用引导加载程序二进制文件时发生变化、如果它是主代码、则不会发生变化。 看起来像 CryptoCC26XX_allocateKey (crypto_handle、CRYPTOCC26XX_KEY_any、(const uint32_t *)"qwertyuiop[]asd"))使用引导加载程序 ROM 中的密钥常量指针？？？？

我不明白你在说什么。 但请记住,SysCtrlSystemReset()不会执行正确的重置。 AFAIK 根本不涉及硬件外设。 因此、

1) 1)来自您的旧应用程序

2) 2)跳转到引导加载程序

3)跳转到新的应用程序

我可以想象、加密硬件加速器未正确初始化。 如果确保在离开旧应用程序之前关闭所有驱动程序句柄，则可以检查问题是否消失。

或者、我建议使用看门狗计时器以执行正确的复位。

但也许其他人可以为您指明一种在运行时重置加密加速器的方法。 我不知道上面的电源代码是否正确和足够。

硬件复位后、甚至在关闭电源后、问题也会出现。 对于测试、我删除了除加密和 EasyLink_Transmit 任务以及带有初始化过程的 main ()之外的所有应用程序代码。 测试代码的运行方式如下：

1 . 硬件复位。

2.带 ASM 代码的引导加载程序头-跳转至应用部分。  

3. App main - uart 和 crypto init。 传输任务开始。

4、传输和加密任务- while (1)循环。

在 launchpad 上接收到 EasyLink 数据包、进行解密并记录到 UART。  

当我从 flash_base =0000和标准.cfg 中构建和启动没有引导加载程序的应用程序代码时、都可以。 当我使用 flash_Base =5000和修改的.cfg 构建应用程序代码、以及使用 CCS "run"运行它时-一切正常。 接收器收到数据包、将其解密、并收到正确的消息-"1234567890"。当我加载 bootloader 并执行硬件重置或关机时、出现问题。 接收器每次收到不同的数据包、然后错误地解密。 如果我通过更改优化选项来更改引导加载程序二进制文件、加载它、执行重置、数据包也会发生变化-看起来像使用新密钥进行加密。  

可能.cfg 的存储器配置段中存在问题…  标准映射已被代码作者(在本项目中、我不是第一个)取代、开始地址移动以运行引导加载程序。  

您好、Victor：

1.您使用的是哪个版本的 SimpleLimk CC13x0 SDK？

2.根据您的描述,可能会出现指针等方面的问题。 您是否单步执行了代码并检查了各个阶段的缓冲区？

3.您说 接收器收到了不同的数据包,这是否意味着 Rx 也有问题? 还是仅加密？

谢谢、

M·H

您好、Marie！

1 . 最新。 …μ A。

2.我要做这个。 我认为旧项目中链接器配置的某个位置存在问题。 昨天我做了一些测试-我 用 launchpad 构建了一个新项目 -一切正常、加密/解密正常。 我将 main.c、.cfg、.cmd 放入到旧工程中(所有较旧的文件都被删除)-解密错误。  
3. 接收/发送正常。 加密问题。 看起来使用了错误的密钥。 我们将执行一些测试、以找到问题并  

为什么不逐个更改这3个文件来重建和测试项目、以查看项目失败的时间或关注这些文件之间的差异？

确切地说、这将是我要做的第一个测试

部分结果：

调试程序：AllocateKey 函数接收指向右键的指针。 转储内存区域、检查它-好的、内存中的关键字是"qwerty…ó n"。 -正确。

另一次检查错误序列：

1.使用 standard.cfg 构建并且 cmd flash_BASE =0000、加载–全部正常。

2.使用自定义 cfg 和 cmd FLASH base=5000构建、并使用 CCS "run"运行-确定

3.加载 BOOLLOADER -加密返回 错误的加密字符串,结果代码正常

4.在 FLASH_BASE =5000的情况下加载并运行代码、同时 CCS 再次"运行"-错误的字符串。 硬件复位-结果相同。

5.加载代码 FLASH_BASE 0。 一切都好。

您好、Victor：

当您使用引导加载程序运行时、您是否在链接器命令文件(.cmd)中做了必要的调整？  

也许你可以使用一个内存断点来查看是否有什么东西正在写入存储了你的密钥的内存？

您是否还能检查存储加密/解密负载的缓冲区？

谢谢、

M·H

你好，Marie！ 感谢您的帮助！ 我会在一些消息中回答、以使其更易于使用

首先、下面是 测试示例的完整代码、要在 Launchpad 上运行：

/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/runtime/Assert.h>
#include <xdc/runtime/Error.h>

#include <stdio.h>
#include <string.h>
/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
#include <ti/sysbios/knl/Semaphore.h>
#include <ti/sysbios/knl/Clock.h>
#include <ti/devices/cc13x0/driverlib/sys_ctrl.h>

/* TI-RTOS Header files */
#include <ti/drivers/PIN.h>

/* Board Header files */
#include "Board.h"
#include <ti/drivers/crypto/CryptoCC26XX.h>
/* EasyLink API Header files */
#include "easylink/EasyLink.h"

/***** Defines *****/

/* Undefine to remove address filter and async mode */
#define RFEASYLINKTX_ASYNC
#define RFEASYLINKRX_ASYNC
#define RFEASYLINKRX_ADDR_FILTER

#define RFEASYLINKEX_TASK_STACK_SIZE    1024
#define RFEASYLINKTX_TASK_STACK_SIZE    1024
#define RFEASYLINKEX_TASK_PRIORITY      2
#define RFEASYLINKTX_TASK_PRIORITY      2
#define TXPAYLOAD_LENGTH                100
#define RFEASYLINKTX_BURST_SIZE         10

//crypto

#define MAC_LENGHT           (4)
#define NONCE_LENGHT         (12)
#define HDR_LENGHT           (8)

UART_Handle uart;
UART_Params uartParams;

char buf[400];

/***** Variable declarations *****/

static Task_Params rxTaskParams;
Task_Struct rxTask;
static uint8_t rxTaskStack[RFEASYLINKEX_TASK_STACK_SIZE];

char str[400];

EasyLink_TxPacket txPacket =  { {0}, 0, 0, {0} };

// *******************   crypto ************************

CryptoCC26XX_Handle             crypto_handle;
CryptoCC26XX_AESCCM_Transaction crypto_trans;
volatile uint8_t  AES128_key[16] = "qwertyuiop[]asd" ;//16 bytes key - 15 bytes and zero at the end
int32_t   crypto_keyIndex;

static void rfEasyLinkRxFnx(UArg arg0, UArg arg1)
{
    EasyLink_init(EasyLink_Phy_Custom);
    EasyLink_setRfPwr(12);
    int16_t i;
    EasyLink_Status status;

    while(1)
    {
        memcpy(txPacket.payload,"12345678901111",14);//plain text 10 bytes and 4 bytes for MAC
        memcpy(&txPacket.payload[14],"123456789011",12);//nonce 12 bytes
        txPacket.len=26;

        UART_write(uart, "text:\n\r", 7);
        for (i=0;i<txPacket.len;i++)
        {
          sprintf (&str[i*3]," %02x",txPacket.payload[i]);
        }
        sprintf (&str[i*3],"\n\r");
        UART_write(uart, str, txPacket.len*3+2);

        if((crypto_keyIndex = CryptoCC26XX_allocateKey(crypto_handle, CRYPTOCC26XX_KEY_ANY, (const uint32_t *) AES128_key))== CRYPTOCC26XX_STATUS_ERROR)  UART_write(uart, "alloc err", 9);

        CryptoCC26XX_Transac_init((CryptoCC26XX_Transaction *) &crypto_trans, CRYPTOCC26XX_OP_AES_CCM_ENCRYPT);

        crypto_trans.keyIndex   = crypto_keyIndex;
        crypto_trans.authLength = MAC_LENGHT;
        crypto_trans.nonce  = (char *) txPacket.payload[txPacket.len-(NONCE_LENGHT)];//nonce

        crypto_trans.fieldLength  = 3;
        crypto_trans.msgInLength  = txPacket.len-NONCE_LENGHT-MAC_LENGHT;
        crypto_trans.headerLength = 0;//HDR_LENGHT;
        crypto_trans.msgIn  = (char *) txPacket.payload;                // Message is encrypted in place
        crypto_trans.msgOut = (char *) &(txPacket.payload[txPacket.len-NONCE_LENGHT-MAC_LENGHT]);  // MAC will be written to this position

        if( CryptoCC26XX_transact(crypto_handle, (CryptoCC26XX_Transaction *) &crypto_trans) != CRYPTOCC26XX_STATUS_SUCCESS)  UART_write(uart, "  crypterr\n\r", 12);
        if(CryptoCC26XX_releaseKey(crypto_handle, &crypto_keyIndex) != CRYPTOCC26XX_STATUS_SUCCESS )  UART_write(uart, "releseerr", 9);

        UART_write(uart, "ENcrypted:\n\r", 12);
        for (i=0;i<txPacket.len;i++)
        {
            sprintf (&str[i*3]," %02x",txPacket.payload[i]);
        }
        sprintf (&str[i*3],"\n\r");
        UART_write(uart, str, txPacket.len*3+2);

        status=EasyLink_transmit(&txPacket);

        if ((status == EasyLink_Status_Success))
        {
          GPIO_toggle(Board_GPIO_LED0);

          UART_write(uart, "send\n\r", 6);
        //  rxPacket.payload[3]

        }

        if((crypto_keyIndex = CryptoCC26XX_allocateKey(crypto_handle, CRYPTOCC26XX_KEY_ANY, (const uint32_t *) AES128_key))== CRYPTOCC26XX_STATUS_ERROR)  UART_write(uart, "alloc err", 9);

        CryptoCC26XX_Transac_init((CryptoCC26XX_Transaction *) &crypto_trans, CRYPTOCC26XX_OP_AES_CCMINV);

        crypto_trans.keyIndex   = crypto_keyIndex;
        crypto_trans.authLength = MAC_LENGHT;
        crypto_trans.nonce  = (char *) txPacket.payload[txPacket.len-(NONCE_LENGHT)];//нонс 12 байт размещаются в конце пакета

        crypto_trans.fieldLength  = 3;
        crypto_trans.msgInLength  = txPacket.len-NONCE_LENGHT;
        crypto_trans.headerLength = 0;//HDR_LENGHT;
        crypto_trans.msgIn  = (char *) txPacket.payload;                // Message decrypted
        crypto_trans.msgOut = (char *) buf;  // for output MAC - it must not the same with input MAC

        if( CryptoCC26XX_transact(crypto_handle, (CryptoCC26XX_Transaction *) &crypto_trans) != CRYPTOCC26XX_STATUS_SUCCESS)  UART_write(uart, "  crypterr\n\r", 12);
        if(CryptoCC26XX_releaseKey(crypto_handle, &crypto_keyIndex) != CRYPTOCC26XX_STATUS_SUCCESS )  UART_write(uart, "releseerr", 9);

        UART_write(uart, "decrypted:\n\r", 12);
        for (i=0;i<txPacket.len;i++)
        {
            sprintf (&str[i*3]," %02x",txPacket.payload[i]);
        }
        sprintf (&str[i*3],"\n\r");
        UART_write(uart, str, txPacket.len*3+2);

        Task_sleep(300000);

  }
}

//======== main ========

int main(void)
{

    /* Call driver init functions */
    Board_initGeneral();

    GPIO_init();
    UART_init();
    UART_Params_init(&uartParams);
    uartParams.writeDataMode = UART_DATA_BINARY;
    uartParams.readDataMode = UART_DATA_BINARY;
    uartParams.readReturnMode = UART_RETURN_FULL;
    uartParams.readEcho = UART_ECHO_OFF;
        //uartGSMParams.readEcho = UART_ECHO_ON;
    uartParams.baudRate = 115200;
        //uartGSMParams.baudRate = 9600;
    uartParams.readTimeout = 1000000;

    uart = UART_open(Board_UART0, &uartParams);
    if (uart == NULL) {
        /* UART_open() failed */
        while (1);
    }

    Task_Params_init(&rxTaskParams);
    rxTaskParams.stackSize = RFEASYLINKEX_TASK_STACK_SIZE;
    rxTaskParams.priority = 1;
    rxTaskParams.stack = &rxTaskStack;
    Task_construct(&rxTask, (Task_FuncPtr)rfEasyLinkRxFnx, &rxTaskParams, NULL);

    // Initialize Crypto driver structures
    CryptoCC26XX_init();
    crypto_handle=CryptoCC26XX_open(Board_CRYPTO0, true, NULL);

    /* Start BIOS */
    BIOS_start();

    return (0);
}

标准命令

/*
 *  ======== CC1310_LAUNCHXL.cmd ========
 */

--stack_size=1024   /* C stack is also used for ISR stack */

HEAPSIZE = 0x1000;  /* Size of heap buffer used by HeapMem */

/* Override default entry point.                                             */
--entry_point ResetISR
/* Allow main() to take args                                                 */
--args 0x8
/* Suppress warnings and errors:                                             */
/* - 10063: Warning about entry point not being _c_int00                     */
/* - 16011, 16012: 8-byte alignment errors. Observed when linking in object  */
/*   files compiled using Keil (ARM compiler)                                */
--diag_suppress=10063,16011,16012

/* The starting address of the application.  Normally the interrupt vectors  */
/* must be located at the beginning of the application.                      */
#define FLASH_BASE              0x0
#define FLASH_SIZE              0x20000
#define RAM_BASE                0x20000000
#define RAM_SIZE                0x5000

/* System memory map */

MEMORY
{
    /* Application stored in and executes from internal flash */
    FLASH (RX) : origin = FLASH_BASE, length = FLASH_SIZE
    /* Application uses internal RAM for data */
    SRAM (RWX) : origin = RAM_BASE, length = RAM_SIZE
}

/* Section allocation in memory */

SECTIONS
{
    .text           :   >> FLASH
    .TI.ramfunc     : {} load=FLASH, run=SRAM, table(BINIT)
    .const          :   >> FLASH
    .constdata      :   >> FLASH
    .rodata         :   >> FLASH
    .cinit          :   > FLASH
    .pinit          :   > FLASH
    .init_array     :   > FLASH
    .emb_text       :   >> FLASH
    .ccfg           :   > FLASH (HIGH)

    .data           :   > SRAM
    .bss            :   > SRAM
    .sysmem         :   > SRAM
    .nonretenvar    :   > SRAM

    /* Heap buffer used by HeapMem */
    .priheap   : {
        __primary_heap_start__ = .;
        . += HEAPSIZE;
        __primary_heap_end__ = .;
    } > SRAM align 8

    .stack          :   > SRAM (HIGH)
}

UART 日志：

文本：
31 32 33 34 35 36 37 38 39 30 31 31 31 31 31 31 32 33 34 35 36 37 38 39 30 31 31
已加密：
23 69 90 E6 18 E9 c0 7b 3a BA 52 65 2e aa 31 32 33 34 35 36 37 38 39 30 31
发送
解密：
31 32 33 34 35 36 37 38 39 30 52 65 2e aa 31 32 33 34 35 36 37 38 39 30 31 31

如你所见-一切都好。

第二：

引导加载程序代码：

#include "Board.h"

void main(void)
{
    HWREG(NVIC_VTABLE) = 0x00005000;

            // Load the stack pointer from the application's vector table
            __asm("    ldr     r1, [r0]\n"
                  "    mov     sp, r1");

            // Load the initial PC from the application's vector table and branch to the application's entry point
            __asm("    ldr     r0, [r0, #4]\n"
                  "    bx      r0\n");
 }

引导加载程序命令：

/*
 *  ======== CC1310_LAUNCHXL_NoRTOS.cmd ========
 */

--retain=g_pfnVectors

--stack_size=1024   /* C stack is also used for ISR stack */

--heap_size=256

/* Override default entry point.                                             */
--entry_point resetISR
/* Allow main() to take args                                                 */
--args 0x8
/* Suppress warnings and errors:                                             */
/* - 10063: Warning about entry point not being _c_int00                     */
/* - 16011, 16012: 8-byte alignment errors. Observed when linking in object  */
/*   files compiled using Keil (ARM compiler)                                */
--diag_suppress=10063,16011,16012

/* The starting address of the application.  Normally the interrupt vectors  */
/* must be located at the beginning of the application.                      */
#define FLASH_BASE              0x0
#define FLASH_SIZE              0x20000
#define RAM_BASE                0x20000000
#define RAM_SIZE                0x5000

/* System memory map */

MEMORY
{
    /* Application stored in and executes from internal flash */
    FLASH (RX) : origin = FLASH_BASE, length = FLASH_SIZE
    /* Application uses internal RAM for data */
    SRAM (RWX) : origin = RAM_BASE, length = RAM_SIZE
}

/* Section allocation in memory */

SECTIONS
{
    .intvecs        :   > FLASH_BASE
    .text           :   > FLASH
    .TI.ramfunc     : {} load=FLASH, run=SRAM, table(BINIT)
    .const          :   > FLASH
    .constdata      :   > FLASH
    .rodata         :   > FLASH
    .cinit          :   > FLASH
    .pinit          :   > FLASH
    .init_array     :   > FLASH
    .emb_text       :   > FLASH
    .ccfg           :   > FLASH (HIGH)

    .vtable_ram     :   > SRAM
    .data           :   > SRAM
    .bss            :   > SRAM
    .sysmem         :   > SRAM
    .nonretenvar    :   > SRAM

    .stack          :   > SRAM (HIGH)
}

主代码 cmd：

/*
 *  ======== CC1310_LAUNCHXL.cmd ========
 */

--stack_size=1024   /* C stack is also used for ISR stack */

HEAPSIZE = 0x800;  /* Size of heap buffer used by HeapMem */

/* Override default entry point.                                             */
--entry_point ResetISR
/* Allow main() to take args                                                 */
--args 0x8
/* Suppress warnings and errors:                                             */
/* - 10063: Warning about entry point not being _c_int00                     */
/* - 16011, 16012: 8-byte alignment errors. Observed when linking in object  */
/*   files compiled using Keil (ARM compiler)                                */
--diag_suppress=10063,16011,16012

/* The starting address of the application.  Normally the interrupt vectors  */
/* must be located at the beginning of the application.                      */
#define FLASH_BASE              0x05000
#define FLASH_SIZE              0x01B000
#define RAM_BASE                0x20000000
#define RAM_SIZE                0x5000

/* System memory map */

MEMORY
{
    /* Application stored in and executes from internal flash */
  //  FLASH (RX) : origin = FLASH_BASE, length = FLASH_SIZE
  FLASH (RX) : origin = 0x05000, length = 0x01B000
    /* Application uses internal RAM for data */
    SRAM (RWX) : origin = RAM_BASE, length = RAM_SIZE
}

/* Section allocation in memory */

SECTIONS
{
    .text           :   >> FLASH
    .TI.ramfunc     : {} load=FLASH, run=SRAM, table(BINIT)
    .const          :   >> FLASH
    .constdata      :   >> FLASH
    .rodata         :   >> FLASH
    .cinit          :   > FLASH
    .pinit          :   > FLASH
    .init_array     :   > FLASH
    .emb_text       :   >> FLASH
    .ccfg           :   > FLASH (HIGH)

//	.binit			:	> FLASH
	.vtable_ram		:   > SRAM
    .data           :   > SRAM
    .bss            :   > SRAM
    .sysmem         :   > SRAM
    .nonretenvar    :   > SRAM

    /* Heap buffer used by HeapMem */
    .priheap   : {
        __primary_heap_start__ = .;
        . += HEAPSIZE;
        __primary_heap_end__ = .;
    } > SRAM align 8

    .stack          :   > SRAM (HIGH)
}

日志 UART：
文本：
31 32 33 34 35 36 37 38 39 30 31 31 31 31 31 31 32 33 34 35 36 37 38 39 30 31 31
已加密：
59 87 f1 ff 17 db EC A6 da A4 8a 直流4b F4 31 32 33 34 35 36 37 38 39 30 31
发送
解密：
31 32 33 34 35 36 37 38 39 30 8 a 直流4b F4 31 32 33 34 35 36 37 38 39 30 31 31

解密文本与输入字符串相等-解密正确。 但加密字符串与第一条消息不同。

结论：输入字符串使用未知密钥加密。 但解密使用相同的密钥、结果也是正确的。 

现在:调试

我跟踪了代码：

RES = CRYPTOAesLoadKey ((uint32_t*) keySrc、keyIndex)；  

在"cryptoCC26XX.c"

在函数进入点之前：

KeySrc = 0x20001D9C｛19252337｝

内存转储：

@20001D9C
71 77 65 72 74 79 75 69 6F 70 5B 5D 61 73 64 00

或

qwertyuiop[]asd   + zero at the end

进入函数后、调试程序写了"在/project/exports/cc13xx_cha_2_0_ext/driverlib/bin/ccs/./../../../driverlib/crypto.c 找不到源文件、找不到。

当函数返回时-内存转储相同、一切正常、没有任何变化。

结果-我的思想被打破了。

您好、Victor：

 "无法在...中找到源文件" 很常见。 在此找到 crypto.c、您应该能够浏览并选择它： C：\ti\simplelink_cc13x0_sdk_4_20_02_07\source\ti\devices\cc13x0\driverlib\crypto.c。

关于 cmd 文件：flash_size 或 flash_range 不应在引导加载程序与应用程序之间重叠。 同时、引导加载程序需要控制最后一个闪存页上的 CCFG。 您可以在 TI 15.4-Stack bim (引导加载程序映像管理器)项目中看到我们是如何解决此问题的：(文件： c：\ti\simplelink_cc13x0_sdk_4_20_02_07\source\ti\common\ccs\cc13x0_Bim_offchip.cmd)

/* The starting address of the application.  Normally the interrupt vectors  */
/* must be located at the beginning of the application.                      */
#define FLASH_PAGE0_START       0x00000000
#define FLASH_PAGE31_START      0x0001F000
#define PAGE_SIZE               0x1000
#define RAM_BASE                0x20000000
#define RAM_SIZE                0x5000

/* Flash Range of BIM */
#if defined(KEEP_INTVECS)
  #define FLASH_RANGE           FLASH_PAGE0 | FLASH_PAGE31
#else /* !KEEP_INTVECS */
  #define FLASH_RANGE           FLASH_PAGE31
#endif /* KEEP_INTVECS */

然后、应用程序在第二页开始其闪存范围：(file： \ti\simplelink_cc13x0_sdk_4_20_02_07\examples\rtos\CC1310_LAUNCHXL\ti154stack\sensor_oad\cc13x0lp_oad.cmd)

#define FLASH_APP_BASE          0x00001000

谢谢、

M·H

您好、Marie！

我已经尝试分离存储器-如本例中的示例 https://github.com/TexasInstruments/ble_examples/blob/ble_examples-2.2/src util/serial_bootloader/bl_flash.cmd

我使用以下 cmd 重新编译引导加载程序： 

#define FLASH_BASE              0x0
#define FLASH_SIZE              0x5000
#define FLASH_SECTOR_SIZE       0x1000
#define RAM_BASE                0x20000000
#define RAM_SIZE                0x5000

MEMORY
{
    /* Application stored in and executes from internal flash */
    FLASH_PG0 (RX) : origin = FLASH_BASE, length = FLASH_SIZE
    FLASH_PG31 (RX) : origin = 0x01f000, length = FLASH_SECTOR_SIZE
    /* Application uses internal RAM for data */
    SRAM (RWX) : origin = RAM_BASE, length = RAM_SIZE
}

/* Section allocation in memory */

SECTIONS
{
    .intvecs        :   > FLASH_BASE
    .text           :   > FLASH_PG0
    .const          :   > FLASH_PG0
    .constdata      :   > FLASH_PG0
    .rodata         :   > FLASH_PG0
    .binit          :   > FLASH_PG0
    .cinit          :   > FLASH_PG0
    .pinit          :   > FLASH_PG0
    .init_array     :   > FLASH_PG0
    .emb_text       :   > FLASH_PG0
    .ccfg           :   > FLASH_PG31 (HIGH)

    .vtable         :   > SRAM
    .vtable_ram     :   > SRAM
     vtable_ram     :   > SRAM
    .data           :   > SRAM
    .bss            :   > SRAM
    .sysmem         :   > SRAM
    .stack          :   > SRAM (HIGH)
    .nonretenvar    :   > SRAM
    //.gpram          :   > GPRAM

}

/* Create global constant that points to top of stack */
/* CCS: Change stack size under Project Properties    */
__STACK_TOP = __stack + __STACK_SIZE;


Ccfg 放在第31页中、将 ROM 各段分开 
没有影响。 

您好、Marie！  

调试结果：

  在其中一个驱动程序中发现错误或类似的内容：

在 crypto.c 中

uint32_t
CRYPTOAesLoadKey(uint32_t *pui32AesKey,
                 uint32_t ui32KeyLocation)
{
    uint32_t returnStatus = AES_KEYSTORE_READ_ERROR;

    // Check the arguments.
    ASSERT((ui32KeyLocation == CRYPTO_KEY_AREA_0) |
           (ui32KeyLocation == CRYPTO_KEY_AREA_1) |
           (ui32KeyLocation == CRYPTO_KEY_AREA_2) |
           (ui32KeyLocation == CRYPTO_KEY_AREA_3) |
           (ui32KeyLocation == CRYPTO_KEY_AREA_4) |
           (ui32KeyLocation == CRYPTO_KEY_AREA_5) |
           (ui32KeyLocation == CRYPTO_KEY_AREA_6) |
           (ui32KeyLocation == CRYPTO_KEY_AREA_7));

    // Disable the external interrupt to stop the interrupt form propagating
    // from the module to the System CPU.
    IntDisable(INT_CRYPTO_RESULT_AVAIL_IRQ);

    // Clear any previously written key at the keyLocation
    HWREG(CRYPTO_BASE + CRYPTO_O_KEYWRITTENAREA) = (0x00000001 << ui32KeyLocation);

    // Enable internal interrupts.
    HWREG(CRYPTO_BASE + CRYPTO_O_IRQTYPE) = CRYPTO_IRQTYPE_LEVEL;

ui32KeyLocation 在此操作期间的更改(crypto.c 中的102个字符串)  

HWREG (CRYPTO_BASE + CRYP_O_KEYWRITTENAREA)=(0x00000001 << ui32KeyLocation)；

 5岁之前、 1073889284岁之后

根据我的理解、crypto.c 代码是 XDC 包、调试器可能会 错误地显示可执行代码行。  此处会发生一些情况

但这可能是调试器干扰、因为在 运行良好的程序上   ui32KeyLocation 也会更改

您好、Victor：

您可以仅为该函数设置优化、看看这是否能让您更好地理解：

https://dev.ti.com/tirex/explore/content/simplelink_cc13x0_sdk_4_20_02_07/docs/proprietary-rf/proprietary-rf-users-guide/proprietary-rf-guide/debugging-index.html#optimizations

谢谢、

M·H

您好、Marie！

我已经在调试期间关闭了优化。 ui32KeyLocation 放置在 R5中、它在 crypto.c 中的第一个 HWREG 宏字符串102之后发生更改。 我不知道为什么  

我进行了一些路径更改、并直接将 crypto.c 包含在我的项目中、现在变量可以了。 恢复调试