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

在嵌入式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   
};        

寄存器

// 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）<-这应该给出元素reg1，reg2，reg2 + 1的地址， ...如register_map_3 []中所声明。程序集所做的只是将增加的偏移量添加到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 []将一个数组“嵌入”到另一个数组中的表示法？