c - 如何在 C 中启动两个数组，每个数组存储 16 位，并通过前两个数组的异或创建第三个数组？

Question

我正在构建鼓机，我想要两个 16 位数组来定义机器的状态。一个数组“current_led”在对应于当前正在演奏的第 16 个音符的索引处设置了 1。

当用户编程要播放的声音时，例如在步骤 1 和 4 中，我希望一个 16 位数组“selected_steps”在索引 0 和 3 处设置为 1。

所以我希望，在由每分钟节拍定义的每个步骤更新中，“current_led”移动该位，但“selected_steps”是静态的。

我想要一个由

构造的最终数组“led_array”

led_array = XOR(selected_steps,current_led)

这样我就可以使用移位寄存器在每一步更新时点亮正确的 LED。

但是由于我在 C 语言中定义和使用位和数组时遇到一些麻烦，我不明白如何正确初始化数组并使用它们。

我想要的东西是这样的

  int current_led[16];
  int selected_steps[16];
  int led_array[16];

  //Function is called every 0.5 s if BPM 120.
  void step(void) {
  step_number = step_number < 15 ? step_number +1 : 0;
  }

我使用 2 个 PISO 移位寄存器将 16 个按钮的输入传输到我的微 Controller 。我将并行负载引脚不断设置为高电平，这样每当用户按下按钮时，移位寄存器上的相应引脚就会设置为 1。因此，我每次都会读取每个 16 个引脚，看看用户是否按下了任何按钮按钮。

  //Check which steps are selected by the user. This function is called every 1 ms
  void scan_buttons() {
  for (int j = 0; j<16 ; j++) {
      if (PIND & 0b01000000){
            selected_steps[j] = 1;
            } else {
            selected_steps[j] = 0;
        }


  void update_led(void) {
     current_led = (1 << step_number);
     led_array = current_led^selected_steps;

     for (int j = 15; j>=0 ; j--) {
        if (led_array[j] == 1) {
           do something...
        } else {
           do something else...
        }
     }
  } 

为了清楚起见，下面是 LED 应如何表示该状态的示例。如果 BPM 设置为 120，并且我们有 16 个步长(4 个节拍)，则步长应每 60/BPM 秒(0.5 秒)增加一次。当前步骤由明亮的 LED 指示。我还通过始终让 LED 在当前步骤亮起来向用户指示他/她已将声音设置为打开的步骤。

第 1 步:step_number = 0

LED: [1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

第 2 步:step_number = 1

LED: [0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

第 3 步:step_number = 2，selected_step[7] = 1，selected_step[11] = 1，

(用户在步骤8和12中选择通过按按钮8和12输入声音)

LED: [0 0 1 0 0 0 0 1 0 0 0 1 0 0 0 0]

第 4 步:step_number = 3，selected_step[7] = 1，selected_step[11] = 1，

(自上一步以来用户未按下任何按钮)

LED: [0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0]

但我不明白如何声明数组，以及如何编写正确的代码来正确设置位并执行异或运算。

Answer 1

以下是如何设置和清除 uint16_t 中的位(对于任何无符号整数也是如此，只需相应地更改类型即可)

我已经很长时间没有进行任何位操作了，所以你应该仔细检查一下在使用之前，没有时间自己动手。

/* 
   `set_bits`, `unset_bits` and `flip_bits` modifies multiple bits in v.

    The bits you want to modify are selected by setting the corresponding bit
    in `mask` to 1.
*/

uint16_t set_bits(uint16_t v, uint16_t mask)
{
   return v | mask;
}

uint16_t unset_bits(uint16_t v, uint16_t mask)
{
   return v & ~mask;
}

uint16_t flip_bits(uint16_t v, uint16_t mask)
{
   return v | ((~v) & mask)
}

/* 
 `set_bit`, `unset_bit`, `flip_bit`, `overwrite_bit` modifies a single bit in `v`.
 The bit to modify is given by the index `i`
*/

uint16_t set_bit(uint16_t v, int i)
{
   return set_bits(v, 1 << i);
}

uint16_t unset_bit(uint16_t v, int i)
{
   return unset_bits(v, 1 << i);
}

uint16_t flip_bit(uint16_t v, int i)
{
   return flip_bits(v, 1 << i);
}

uint16_t overwrite_bit(uint16_t v, int i, int new_val)
{
   /* ensure `new_val` is either 0 or 1 */
   new_val = new_val ? 1 : 0;

   uint16_t mask = 1 << i;
   uint16_t mask_x = ~mask; 

   uint16_t nv = new_val << i;

   return v & (mask_x | nv);
}

int read_bit(uint16_t v, int i)
{
   uint16_t mask = 1 << i;
   return (v & mask) ? 1 : 0;
}  


/* How to initialize all the bits in `selected_steps` to zero */
selected_steps = 0;

/* How to initialize all the bits in `selected_steps` to 1 */
selected_steps = 0xffff;  /* or  = 0b1111111111111111 */ 


/* How to read the value of bit 8 in `selected_step` */

int val = read_bit(selected_steps, 8);

/* How to set the value of bit 8 to 1 */
selected_steps = set_bit(selected_steps, 8);
/* or */
selected_steps = overwrite_bit(selected_steps, 8, 1);
/* or */
selected_steps = set_bits(selected_steps, 0b100000000);


/* How to set the value of bit 8 to 0 */
selected_steps = unset_bit(selected_steps, 8);
/* or */
selected_steps = overwrite_bit(selected_steps, 8, 0);
/* or */
selected_steps = unset_bits(selected_steps, 0b100000000);

/* Setting bits 1 and 4 to 1 */
selected_steps = set_bits(selected_steps, 0b10010);
/* or */
selected_steps = set_bits(selected_steps, (1<<4) | (1<<1));

/* Calculating xor of two bitsets */
uint16_t xor_a_b = a ^ b;

根据您的用例，您可以选择将这些函数定义为静态内联。将 step_number 转换为掩码而不是索引也可能有意义。