Question

我正在尝试使用简单的完整步骤控制步进电机。这意味着我正在输出一系列值，如下所示：

我认为这样做的一个简单方法就是取我的4位值，然后在每一步之后执行右旋操作。 “代码”显然不遵循任何语法，它只是用来说明我的想法：

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个可能的值，您将使用包含9个元素的表：

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 );

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

方便地，传递一个无效值，将返回零，所以你可以编写一个get函数，该函数也是下一个断言！= 0.你还应该断言值＆lt; 9将值传递给数组之前。

Answer 2

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

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

Answer 3

这个算法非常简单，它总是比表格方法更快：

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}，那么您可以将它们分成两个函数，一个“递增”索引，另一个实际计算值：

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

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

Answer 4

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 5

您可以使用10001000b和mod 10000b

您可以重复01000100b 00100010b 00010001b 10001000b。

例如：

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

Answer 6

如果我使用8位无符号整数，我最终将1关闭到MSB

因此，当值变为零时，使用移位并重新初始化所需的位。 C无论如何都没有旋转操作，所以你必须至少做两个班次。（我想C ++也没有旋转。）

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

简单，写作简短，而且显而易见。是的，它将编译成一个分支（除非处理器有一个条件移动操作），但是直到你有分析器输出来告诉你这很重要，你只需要花费更多的时间来考虑它，而不是那些处理器周期。

Answer 7

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

每次＆＃34;轮换＆＃34;取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 8

我会使用您需要的值创建一个数组，并从数组中加载正确的值。这需要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 9

您只需要输出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

按位向右旋转4位值

9 个答案: