Rotation à droite de la valeur de 4 bits

, Avec seulement 4 valeurs possibles vous utilisez une table avec 9 éléments:

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

Lorsque vous avez besoin de la valeur suivante, vous utilisez simplement la valeur actuelle de l'indice:

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

En faisant cela dans une boucle, parcourra les quatre valeurs possibles.

Commodément, en passant une valeur invalide, retournera un zéro, de sorte que vous pouvez écrire une fonction get qui affirme également next != 0. Vous devez également affirmer la valeur

Il suffit d'utiliser un int pour contenir la valeur. Lorsque vous faites la rotation, Copiez le bit le moins significatif sur le bit 4, puis déplacez-le de 1:

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

IMO le moyen le plus simple est:

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

, Vous pouvez utiliser 10001000b et mod 10000b

Et vous pouvez obtenir 01000100b 00100010b 00010001b 10001000b répétez.

Par exemple:

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

Si j'utilise un int non signé 8 bits, je finirai par faire pivoter le 1 vers le MSB

Utilisez donc un décalage et réinitialisez le bit que vous voulez lorsque la valeur passe à zéro. C n'a pas d'opération de rotation de toute façon, vous devrez donc faire au moins deux quarts de travail. (Et je suppose que C++ n'a pas non plus de rotation.)

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

Simple, court à écrire, et évident dans ce qu'il fait. Oui, il compilera dans une branche (sauf si le processeur a une opération de déplacement conditionnelle), mais jusqu'à ce que vous avoir la sortie du profileur pour vous dire que c'est important, vous venez de perdre plus de temps à y penser que ces cycles de processeur ne le feront jamais.

Utilisez un type de données 8 bits (comme par exemple uint8_t). Initialisez-le à zéro. Définissez le bit que vous voulez définir dans les quatre bits inférieurs de l'octet (par exemple value = 0x08).

Pour chaque "rotation", prenez le LSB (bit le moins significatif) et enregistrez-le. Un décalage vers la droite. Écrasez le quatrième bit avec le bit que vous avez enregistré.

Quelque Chose comme ceci:

#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;
}

Démonstration en Direct.

Je ferais un tableau avec les valeurs dont vous avez besoin et chargerais la valeur correcte du tableau. Il vous faudra 4 octets, ce sera rapide et résoudra vos problèmes même si vous commencez à utiliser un type de moteur différent.

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

Il vous suffit de sortir 1, 2, 4 et 8. Vous pouvez donc utiliser un compteur pour marquer le bit à définir haut.

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

Si vous voulez conduire le moteur à demi-pas, vous pouvez utiliser un tableau pour stocker les nombres dont vous avez besoin.

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

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

Et vous pouvez faire pivoter un entier de 4 bits comme ceci.

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