使用间接分配的代码不起作用

Question

在嵌入式 ARM 系统上我实现了一个寄存器系统:

• 每个寄存器都是一个uint8_T数组
• 主机系统可以通过在 CPU 的串行端口上发出特定命令来同时设置一个寄存器或多个寄存器。

这是代码，去掉了不相关的东西。我在多寄存器写上有问题:

registers.c

#include "registers.h"

//mapped variables
uint8_t reg1[REG1_LEN] = {0x00};
uint8_t reg2[REG2_LEN] = {0x33, 0xB4 ,0xFF, 0xE0};
uint8_t reg3[REG3_LEN] = {0x11};
uint8_t reg4[REG4_LEN] = {0x00};
uint8_t reg5[REG5_LEN] = {0x06};
uint8_t reg6[REG6_LEN] = {0x00};
uint8_t reg_problem[REGPROBLEM_LEN];    
uint8_t reg8[REG8_LEN] = {0x00};


// *** quickstart register mapping.
uint8_t * const register_map_3[] = {    reg1,
                                        reg2, reg2+1, reg2+2, reg2+3,
                                        reg3,
                                        reg4,
                                        reg5,
                                        reg6,
                                        reg_problem, reg_problem+1, reg_problem+2, reg_problem+3, 
                                        reg_problem+4, reg_problem+5, reg_problem+6, reg_problem+7 //,
                                     // reg_problem+8, reg_problem+9, reg_problem+10, reg_problem+11,
                                     // reg_problem+12, reg_problem+13, pload+14, reg_problem+15
    };

  // ...

 // Array pointing to register maps
uint8_t * const * const register_maps[0x10] =
{
    register_map_0,
    register_map_1,
    0,
    register_map_3,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0   
};        

registers.h

// Length of fields
#define REG1_LEN 1
#define REG2_LEN 4
#define REG3_LEN 1
#define REG4_LEN 1
#define REG5_LEN 1
#define REG6_LEN 1
#define REGPROBLEM_LEN 8
#define REG8_LEN 1

// number of fields
#define FIELDS                              8

//mapped variables
extern uint8_t reg1[REG1_LEN] = {0x00};
extern uint8_t reg2[REG2_LEN] = {0x33, 0xB4 ,0xFF, 0xE0};
extern uint8_t reg3[REG3_LEN] = {0x11};
extern uint8_t reg4[REG4_LEN] = {0x00};
extern uint8_t reg5[REG5_LEN] = {0x06};
extern uint8_t reg6[REG6_LEN] = {0x00};
extern uint8_t reg_problem[REGPROBLEM_LEN]; 
extern uint8_t reg8[REG8_LEN] = {0x00};

extern uint8_t * const * const register_maps[0x10];

uart.c

#include "registers.h"

// ...

// com_len is the number of items to copy from hexcommand
// regaddr() is a macro that gives the position in the array register_maps[]
for (uint8_t i=0; i < (com_len); i++)
{   
   *( (*register_maps[regaddr()]) + i) = hexcommand[i];                                     
}

// ...

uart.c 应该复制 hexcommand 的内容(来自串行端口)并将它们发送到由 register_maps[n] 映射的变量。

编辑: 查看程序集输出，发生了一些奇怪的事情: (*register_maps[regaddr()]) + i) <- 这应该给出在 register_map_3[] 中声明的元素 reg1、reg2、reg2+1 ... 的地址。 程序集所做的只是简单地将递增的偏移量添加到 register_map_3[] 的首地址。幸运的是，reg1...reg6 是连续分配的，所以它可以工作。 regproblem 位于其他地方，这是行不通的。但是，我的语法看起来没问题:

(*register_maps[regaddr()]) <- 给出 register_map_3

(register_map_3 + i) == ((*register_maps[regaddr()]) + i) <- 给出 register_map_3 中元素的地址

*(register_map_3 + i) == *((*register_maps[regaddr()]) + i) <- 给出变量 (reg1, reg2, reg2+1, ...)

我错过了什么吗？

额外的问题:是否有比我用于 register_map_3[] 的符号更清晰的符号来将一个数组“嵌入”到另一个数组中？

Answer 1

好的，我找到了自己的问题。 我需要更改语法

*( (*register_maps[regaddr()]) + i) = hexcommand[i];

到

*( *(register_maps[regaddr()] + i) ) = hexcommand[i];

否则循环会不断增加数组第一个元素 (reg1) 的地址，而不是在 register_map_3[] 中寻找正确的地址。它工作正常，直到偶然地，我的代码中使用的所有地址都是连续的。