Je souhaite envoyer une valeur de 128 bits à un FPGA, bit par bit, à partir d'un AVR. Le FPGA s'attend à ce que la transaction suivante se produise:
1) Signal RST pour effacer le registre de 128 bits du FPGA. Haut, puis bas. Un signal "CLOCK" est réglé sur bas.
2) Un bit ENABLE est réglé sur haut pour indiquer qu'un transfert est en cours.
3) Un bit INPUT est mis à la valeur de arrayOfBinaryValues [i].
4a) Le signal CLOCK passe à l'état haut. Sur le bord d'attaque, la valeur de INPUT est stockée en position i sur le FPGA.
4b) Le signal CLOCK passe à l'état bas.
4c) bit INPUT réglé sur la valeur suivante arrayOfBinaryValues [i]
[Répéter 4a-4c jusqu'à ce que tout le tableau est envoyé]
Convertir une chaîne de caractères en un tableau de valeurs binaires, puis transmettre le tableau bit par bit
Alors, je l'ai écrit une fonction pour réaliser ce but. Cela se passe par étapes. Étape 1, l'utilisateur entre une valeur de 32 caractères qui est stockée en tant que chaîne de caractères. Puisque ce sont des personnages, je dois les convertir en valeurs hexadécimales correspondantes:
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;
}
}
Puis j'essayé de convertir les bits correspondants dans un tableau de valeurs binaires comme ceci:
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++;
}
Puis-je effectuer la transmission
// 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);
}
}
Malheureusement, cela ne semble pas fonctionner et je ne sais pas exactement pourquoi. Je soupçonne que la façon dont j'effectue la conversion ne fonctionne pas correctement. Quelqu'un a-t-il des idées?
modifier: Ceci est le module VHDL ce code communique avec:
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;
Etes-vous sûr que votre séquence d'horloge est correcte? L'instruction indique que vous devez écrire les données et ensuite faire avancer et descendre l'horloge. –
J'ai testé la séquence d'horloge dans un banc d'essai VHDL et de toutes les apparences c'était correct. Je pourrais réexaminer cet aspect si vous ne voyez aucun problème avec le C tel qu'écrit. Tous les modules personnalisés que j'ai écrits. Prolly aurait pu faire SPI, mais c'est un peu un hack et un exercice personnel. –
Vous n'avez pas ramené l'horloge à la fin de la boucle mais au * départ *. Où la clause 4a) dit "la sortie est écrite ...." cela signifie que "la sortie que vous avez déjà écrite est transmise", et * pas * "c'est quand vous écrivez les données." –