将 C 字符串转换为二进制值数组，然后逐位传输数组

Question

我想从 AVR 向 FPGA 逐位发送一个 128 位值。 FPGA 期望发生以下事务:
1)RST信号清除FPGA的128位寄存器。走高，然后走低。 “CLOCK”信号设置为低电平。
2) 一个 ENABLE 位被设置为高表明传输正在进行中。
3) INPUT 位设置为 arrayOfBinaryValues[i] 的值。
4a) CLOCK 信号变高。在前沿，INPUT 的值存储在 FPGA 的位置 i。
4b) CLOCK 信号变低。
4c) INPUT 位设置为 arrayOfBinaryValues[i] 的下一个值
[重复 4a-4c 直到发送整个数组]

因此，我编写了一个函数来完成这项工作。它分阶段发生。第 1 步，用户输入一个 32 个字符的值，该值存储为 c 字符串。由于这些是字符，我必须将它们转换为相应的十六进制值:

void transmitToFPGA(unsigned char hash[32]) {
    // convert the characters to their corresponding hex values
    unsigned char hash_hex[32];
    unsigned char j = 0;

    SET_BIT(FPGA_DDR,MD5_RST); // sets reset bit high

    for (unsigned char i=0; i<32; i++) {
        switch (hash[i]) {
            case '0': hash_hex[i] = 0x00; break;
            case '1': hash_hex[i] = 0x01; break;
            case '2': hash_hex[i] = 0x02; break;
            case '3': hash_hex[i] = 0x03; break;
            case '4': hash_hex[i] = 0x04; break;
            case '5': hash_hex[i] = 0x05; break;
            case '6': hash_hex[i] = 0x06; break;
            case '7': hash_hex[i] = 0x07; break;
            case '8': hash_hex[i] = 0x08; break;
            case '9': hash_hex[i] = 0x09; break;
            case 'A': hash_hex[i] = 0x0a; break;
            case 'B': hash_hex[i] = 0x0b; break;
            case 'C': hash_hex[i] = 0x0c; break;
            case 'D': hash_hex[i] = 0x0d; break;
            case 'E': hash_hex[i] = 0x0e; break;
            case 'F': hash_hex[i] = 0x0f; break;
            default:  hash_hex[i] = 0x00; break;
        }
    }

然后我尝试将相应的位转换为二进制值数组，如下所示:

   unsigned char hash_bin[128];
    for (unsigned char i=0; i<32; i++) {
        hash_bin[j] = hash_hex[i] & 0x01; j++;
        hash_bin[j] = hash_hex[i] & 0x02; j++;
        hash_bin[j] = hash_hex[i] & 0x04; j++;
        hash_bin[j] = hash_hex[i] & 0x08; j++;
    }

然后我执行传输

    // conduct transmission
    CLR_BIT(FPGA_DDR,MD5_RST);  // clear reset
    delay_ms(1);
    CLR_BIT(FPGA_DDR,AVR_CLK);         // AVR_CLK = 0
    delay_ms(1);
    CLR_BIT(FPGA_DDR,AVR_EN);          // AVR_EN = 0
    delay_ms(1);
    CLR_BIT(FPGA_DDR,AVR_IN);        // AVR_IN = 0
    delay_ms(1);
    for (unsigned char i=0; i<128; i++) {
        CLR_BIT(FPGA_DDR,AVR_CLK);     // AVR_CLK = 0
        delay_ms(1);
        SET_BIT(FPGA_DDR,AVR_EN);      // AVR_EN = 1
        delay_ms(1);
        if (hash_bin[i] == 0) {         // AVR_IN = hash_bin[i]
            CLR_BIT(FPGA_DDR,AVR_IN);
        } else {
            SET_BIT(FPGA_DDR,AVR_IN);
        }
        delay_ms(1);
  t      SET_BIT(FPGA_DDR,AVR_EN);      // AVR_CLK = 1
        delay_ms(1);
    }
}

不幸的是，这似乎不起作用，我也不完全确定为什么。我怀疑我执行转换的方式不正常。有没有人有任何见解？

编辑:这是此代码与之通信的 VHDL 模块:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity SPI_Slave is
    Port ( AVR_IN   :   in      STD_LOGIC;
           AVR_CLK  :  in   STD_LOGIC;
           RST      :   in      STD_LOGIC;
              ENABLE        :   in  STD_LOGIC;
              READY         :   out     STD_LOGIC;
           HASH_OUT     :   out     STD_LOGIC_VECTOR (127 downto 0) := x"00000000000000000000000000000000" );
end SPI_Slave;

architecture Behavioral of SPI_Slave is

    shared variable count : integer := 0;
    signal hash : std_logic_vector(127 downto 0);   

begin

    PROCESS(AVR_CLK, ENABLE)
    BEGIN
        IF (ENABLE = '1') THEN                  -- If ENABLE is HIGH
            IF (rising_edge(AVR_CLK)) THEN  -- If CLK goes HIGH
                IF (RST = '1') THEN             -- If RST is HIGH
                    hash <= x"00000000000000000000000000000000"; -- then zero HASH_OUT and count
                    count := 0;
                    READY <= '0';               
                ELSE                                -- Otherwise, if RST is LOW
                    IF (count > 126) THEN
                        hash(count) <= AVR_IN;
                        HASH_OUT <= hash (127 downto 0);
                        READY <= '1';
                        count := count + 1;
                    ELSE 
                        hash(count) <= AVR_IN;
                        count := count + 1;
                        READY <= '0';
                    END IF;
                END IF;
            END IF;
        END IF;
    END PROCESS;





end Behavioral;

Answer 1

如果我是你，我会编写函数，使其采用二进制形式的 128 位。

此外，我怀疑您的位设置不正确(在撰写此答案时)。我试图在代码的注释中解释我的逻辑:

#include <stdint.h>
#include <errno.h>

#define FPGA_LONG_DELAY() delay_ms(1)
#define FPGA_DELAY()      delay_ms(1)

int fpga_write_128bit(const uint8_t data[16])
{
    int i;

    if (!data)
        return EINVAL;

    /* Ensure non-active state. */
    CLR_BIT(FPGA_DDR, AVR_EN);
    CLR_BIT(FPGA_DDR, AVR_CLK);
    CLR_BIT(FPGA_DDR, MD5_RST);
    CLR_BIT(FPGA_DDR, AVR_IN);
    FPGA_LONG_DELAY();

    /* Prepare for reset on rising clock edge. */
    SET_BIT(FPGA_DDR, AVR_EN);
    SET_BIT(FPGA_DDR, MD5_RST);
    FPGA_DELAY();

    /* Pulse clock (rising and trailing edges). */
    SET_BIT(FPGA_DDR, AVR_CLK);
    FPGA_DELAY();
    CLR_BIT(FPGA_DDR, AVR_CLK);

    /* Set reset low, and prepare for sending the data bits. */
    CLR_BIT(FPGA_DDR, MD5_RST);

    for (i = 0; i < 128; i++) {

        /* AVR_CLK is low and AVR_EN high at this point. */

        /* Set data; LSB of first byte first. */
        if ((data[i / 8] & (1U << (i & 7))))
            SET_BIT(FPGA_DDR, AVR_IN);
        else
            CLR_BIT(FPGA_DDR, AVR_IN);

        /* Ensure data bit state is stable before rising edge of clock. */
        FPGA_DELAY();

        /* Clock pulse (both rising and trailing edges) */
        SET_BIT(FPGA_DDR, AVR_CLK);
        FPGA_DELAY();
        CLR_BIT(FPGA_DDR, AVR_CLK);
    }

    /* All bits transferred, clock is low. */

    CLR_BIT(FPGA_DDR, AVR_IN);   /* Irrelevant, but let's leave a known state behind */
    CLR_BIT(FPGA_DDR, AVR_EN);

    return 0;
}

您可能注意到我在其中使用了两个宏，FPGA_LONG_DELAY() 和 FPGA_DELAY()。正如现在定义的那样，发送一个 128 位值需要 259 毫秒，或四分之一秒多一点。您可以将两者都定义为空字符串；如果不是，至少比 1 毫秒短得多。

测试上面的函数是否按你的需要工作。

如果您仍然想要一个将 128 位字作为字符串的函数，只需创建一个解析十六进制值的包装函数，然后调用上述函数即可。

上述函数首先发送第一个字节的最低有效位。如果我们将十六进制字符串视为单个 128 位数字，那么我们需要从右到左解析它，第一个(最右边)字符表示最低有效半字节(四位)。

如果您希望 VHDL HASH_OUT 状态为

HASH_OUT(   0 ) = 0
HASH_OUT(   1 ) = 0
HASH_OUT(   2 ) = 0
HASH_OUT(   3 ) = 0
HASH_OUT(   4 ) = 0
HASH_OUT(   5 ) = 0
HASH_OUT(   6 ) = 0
HASH_OUT(   7 ) = 0

HASH_OUT(   8 ) = 1
HASH_OUT(   9 ) = 0
HASH_OUT(  10 ) = 0
HASH_OUT(  11 ) = 0
HASH_OUT(  12 ) = 0
HASH_OUT(  13 ) = 0
HASH_OUT(  14 ) = 0
HASH_OUT(  15 ) = 0

HASH_OUT(  16 ) = 0
HASH_OUT(  17 ) = 1
HASH_OUT(  18 ) = 0
HASH_OUT(  19 ) = 0
HASH_OUT(  20 ) = 0
HASH_OUT(  21 ) = 0
HASH_OUT(  22 ) = 0
HASH_OUT(  23 ) = 0

HASH_OUT(  24 ) = 1
HASH_OUT(  25 ) = 1
HASH_OUT(  26 ) = 0
HASH_OUT(  27 ) = 0
HASH_OUT(  28 ) = 0
HASH_OUT(  29 ) = 0
HASH_OUT(  30 ) = 0
HASH_OUT(  31 ) = 0

以此类推，直到

HASH_OUT( 120 ) = 1
HASH_OUT( 121 ) = 1
HASH_OUT( 122 ) = 1
HASH_OUT( 123 ) = 1
HASH_OUT( 124 ) = 0
HASH_OUT( 125 ) = 0
HASH_OUT( 126 ) = 0
HASH_OUT( 127 ) = 0

你可以使用下面的宏和data数组:

#define PACKBYTE(b0, b1, b2, b3, b4, b5, b6, b7) \
                (  (uint8_t)(!!(b0))       \
                | ((uint8_t)(!!(b1)) << 1) \
                | ((uint8_t)(!!(b2)) << 2) \
                | ((uint8_t)(!!(b3)) << 3) \
                | ((uint8_t)(!!(b4)) << 4) \
                | ((uint8_t)(!!(b5)) << 5) \
                | ((uint8_t)(!!(b6)) << 6) \
                | ((uint8_t)(!!(b7)) << 7) )

const uint8_t data[16] = {
     PACKBYTE( 0, 0, 0, 0, 0, 0, 0, 0 ),
     PACKBYTE( 1, 0, 0, 0, 0, 0, 0, 0 ),
     PACKBYTE( 0, 1, 0, 0, 0, 0, 0, 0 ),
     PACKBYTE( 1, 1, 0, 0, 0, 0, 0, 0 ),
     PACKBYTE( 0, 0, 1, 0, 0, 0, 0, 0 ),
     /* 10 PACKBYTE() lines omitted for brevity */
     PACKBYTE( 1, 1, 1, 1, 0, 0, 0, 0 )
};

请注意，宏中的 !! 只是两个非运算符。如果 x 为零，则 !!x 的计算结果为 0，如果 x 为非零，则为 1。与通常情况不同，最左边的位是最不重要的，因此上面的数组的位顺序与 VHDL 中的 HASH_OUT 相同。

对于十六进制字符串版本，我建议使用函数将字符转换为十进制:

static uint8_t hex_digit(const char c)
{
    switch (c) {
    case '0':           return  0U;
    case '1':           return  1U;
    case '2':           return  2U;
    case '3':           return  3U;
    case '4':           return  4U;
    case '5':           return  5U;
    case '6':           return  6U;
    case '7':           return  7U;
    case '8':           return  8U;
    case '9':           return  9U;
    case 'A': case 'a': return 10U;
    case 'B': case 'b': return 11U;
    case 'C': case 'c': return 12U;
    case 'D': case 'd': return 13U;
    case 'E': case 'e': return 14U;
    case 'F': case 'f': return 15U;
    default:            return 255U; /* Invalid value. */
    }
}

int fpga_write_hex_string(const char *const hex)
{
    uint8_t data[16], hi, lo;
    int     i;

    if (!hex)
        return EINVAL;

    for (i = 0; i < 16; i++) {

        /* Note: we parse the input string in pairs of
                 characters, leftmost first, so that if
                 it happens to be short, we won't try
                 to access it past its end. */

        hi = hex_digit(hex[2*i]);
        if (hi > 15U)
            return EINVAL;

        lo = hex_digit(hex[2*i + 1]);
        if (lo > 15U)
            return EINVAL;

        /* The i'th pair of hex digits form the
           (15-i)'th byte value. */
        data[15 - i] = lo | (hi << 4);
    }

    return fpga_write_128bit(data);
}

您当然可以只接受二进制字符串(由 128 个字符 0 或 1 组成，顺序与 VHDL HASH_OUT):

int fpga_write_bin_string(const char *const bin)
{
    uint8_t data[16] = {0};
    int     i;

    if (!bin)
        return EINVAL;

    for (i = 0; i < 128; i++)
        if (bin[i] == '1')
            data[i/8] |= 1U << (i & 7);
        else
        if (bin[i] != '0')
            return EINVAL;

    return fpga_write_128bit(data);
}

我希望我有其中之一(AVR 或带有 FPGA 的 ARM)来玩自己。因此，显然，以上所有代码都未经测试。您可以随意使用它(它属于公共(public)领域)，但如果它损坏了您的电路板，请不要怪我。