4 位值的按位循环右移

Question

我目前正在尝试使用简单的完整步骤来控制步进电机。这意味着我当前正在输出这样的值序列：

我认为一个简单的方法就是取我的 4 位值并在每一步之后执行右循环操作。 "Code" 显然没有遵循任何语法，它只是为了说明我的想法：

step = 1000;
//Looping
Motor_Out(step)
//Rotate my step variable right by 1 bit
Rotate_Right(step, 1)

我的问题是，显然没有任何 4 位简单数据类型可供我使用，如果我使用 8 位无符号整数，我最终会将 1 旋转到 MSB，这表示我真正感兴趣的 4 位值，将在几步后变成 0000。

我读到过可以使用结构和位域来解决这个问题，但是我从这篇文章中读到的大部分内容都告诉我这是一个非常糟糕的主意。

Answer 1

我会用你需要的值创建一个数组，然后从数组中加载正确的值。它会占用你 4 个字节，速度很快，即使你开始使用不同的电机类型也能解决你的问题。

for example:
const char values[4]={1,2,4,8};
int current_value = 0;

....

if(++current_value>=4)current_value=0;
motor = values[current_value];

Answer 2

使用 8 位数据类型（例如 uint8_t）。将其初始化为零。在字节的低四位中设置要设置的位（例如value = 0x08）。

对于每个 "rotation" 取 LSB（最低有效位）并保存。右移一步。用您保存的位覆盖第四位。

像这样：

#include <stdio.h>
#include <stdint.h>

uint8_t rotate_one_right(uint8_t value)
{
    unsigned saved_bit = value & 1;  // Save the LSB
    value >>= 1;  // Shift right
    value |= saved_bit << 3;  // Make the saved bit the nibble MSB
    return value;
}

int main(void)
{
    uint8_t value = 0x08;  // Set the high bit in the low nibble
    printf("%02hhx\n", value);  // Will print 08
    value = rotate_one_right(value);
    printf("%02hhx\n", value);  // Will print 04
    value = rotate_one_right(value);
    printf("%02hhx\n", value);  // Will print 02
    value = rotate_one_right(value);
    printf("%02hhx\n", value);  // Will print 01
    value = rotate_one_right(value);
    printf("%02hhx\n", value);  // Will print 08 again

    return 0;
}

Live demonstration.

Answer 3

如果只有 4 个可能的值，您将使用具有 9 个元素的 table：

unsigned char table_right[] = { [0x1] = 0x8 , [0x2] = 0x1 , [0x4] = 0x2 , [0x8] = 0x4 };

当您需要下一个值时，您只需使用当前值作为索引：

unsigned char current = 0x4;    //value is: 0b0100
unsigned char next = table_right[current];  //returns: 0b0010
assert( next == 0x2 );

循环执行此操作，将遍历所有四个可能的值。

方便地，传递一个无效的值，将 return 一个零，所以你可以写一个 get 函数，它也断言 next != 0。你也应该在将值传递给数组之前断言 value < 9 .

Answer 4

您可以使用 10001000b 和 mod 10000b

你可以得到 01000100b 00100010b 00010001b 10001000b 重复。

例如：

char x = 0x88;
Motor_Out(x & 0xf);
Rotate_Right(step, 1);

Answer 5

IMO 最简单的方法是：

const unsigned char steps[ 4 ] = { 0x08, 0x04, 0x02, 0x01 };
int stepsIdx = 0;
...
const unsigned char step = steps[ stepsIdx++ ];
stepsIdx = stepsIdx % ( sizeof( steps ) / sizeof( steps[ 0 ] ) );

Answer 6

只需使用一个 int 来保存值。当您执行旋转时，将最低有效位复制到位 4，然后将其右移 1:

int rotate(int value)
{
    value |= ((value & 1) << 4); // eg 1001 becomes 11001
    value >>= 1;                 // Now value is 1100
    return value;
}

Answer 7

只需要输出1、2、4、8即可。所以可以用计数器来标记哪位置高。

Motor_Out(8 >> i);
i = (i + 1) & 3;

如果你想半步驱动电机，可以用数组存储你需要的数字。

const unsigned char out[] = {0x8, 0xc, 0x4, 0x6, 0x2, 0x3, 0x1, 0x9};

Motor_out(out[i]);
i = (i + 1) & 7;

并且你可以像这样旋转一个 4 位整数。

((i * 0x11) >> 1) & 0xf

Answer 8

这个算法很简单，它总是比 table 方法更快：

constexpr unsigned rotate_right_4bit ( unsigned value )
{
    return ( value >> 1 ) | ( ( value << 3 ) & 15 );
}

这变成了 5 行无分支 x86 汇编：

lea     eax, [0+rdi*8]
shr     edi
and     eax, 15
or      eax, edi
ret

或者，如果您真的想查看索引 {3, 2, 1, 0}，那么您可以将它们分成 2 个函数，一个 "increments" 索引，另一个实际计算值：

constexpr unsigned decrement_mod4 ( unsigned index )
{
    return ( index - 1 ) & 3;
}

constexpr unsigned project ( unsigned index )
{
    return 1u << index;
}

Answer 9

if I use an 8-bit unsigned int I will eventually rotate the 1 off to the MSB

因此，当值变为零时，使用移位并重新初始化您想要的位。 C 无论如何都没有旋转操作，因此您必须至少进行两次轮班。（而且我想 C++ 也没有旋转。）

x >>= 1;
if (! x) x = 0x08;

简单、易写且功能显而易见。是的，它会编译成一个分支（除非处理器有一个有条件的移动操作），但是在你有分析器输出告诉你它很重要之前，你只是浪费了更多的时间来思考它，而不是那些处理器周期所能达到的。

4 位值的按位循环右移

Bitwise rotate right of 4-bit value

c

bit-manipulation

motordriver