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

在嵌入式ARM系统上，我实现了一个注册系统：
每个寄存器是一个uint8的数组
主机系统可以通过在CPU的串行端口上发出特定的命令，同时设置一个或多个寄存器。
这是代码，去掉了不相关的东西。我在多寄存器写入时遇到问题：
寄存器.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
};

寄存器.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];

通用异步收发器

#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）程序集所做的只是向寄存器映射3[]的第一个地址添加一个递增的偏移量。幸运的是，reg1…reg6是连续分配的，所以它可以工作。regproblem位于其他地方，这不起作用。但是，我的语法看起来很好：
（*寄存器映射[regaddr（）]）（register_map_3+i）=（（*register_maps[regaddr（）]）+i）*（register_map_3+i）=*（（*register_map[regaddr（）]）+i）我遗漏了什么吗？
附加问题：是否有一个比我用register_map_3[]将数组“嵌入”到另一个数组中更清晰的符号？

最佳答案

好吧，我发现了我自己的问题。
我需要改变

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

到

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

否则，循环将继续增加数组第一个元素（reg1）的地址，而不是在register_map_3[]中查找正确的地址。它工作得很好，直到我的代码中使用的所有地址都是连续的。