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

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) <- 这应该给出元素 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[] 到 "embed" 一个数组到另一个数组的符号更清晰的符号？

Answer 1

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

的语法

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

至

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

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

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

Code using indirect assignment not working

c

pointers

arm