Comment puis-je affecter une entrée std_logic_vector 256 bits

Cédric

Comment puis-je affecter une entrée std_logic_vector 256 bits


J’ai réalisé un algorithme AES-256 qui crypte un std_logic_vector 128 bits (plain_text) avec un std_logic_vector 256 bits (master_key). J’ai fait un banc de test afin de vérifier le comportement du processus de cryptage, et maintenant je voudrais implémenter cet algorithme sur ma carte Basys3 (j’utilise Vivado comme IDE). Mes questions sont:

Comment puis-je mapper les vecteurs d’entrée? Dois-je déclarer des signaux dans mon architecture, sachant que je n’ai pas assez de ports d’E / S?

Humpawumpa

Comment le vecteur de texte brut 128 bits entrera-t-il dans le FPGA?

HKOB

Créez une interface de communication série (par exemple USB, SPI, I2C, etc.) pour écrire dans les registres de votre FPGA.

Réponses


 Oldfart

Une interface série utilise le moins de broches. De toutes les interfaces série, SPI est la plus simple à mettre en œuvre. (Je pense qu’il s’agit d’environ cinq lignes de code). Comme une interface SPI diffuse des données en entrée et en sortie en même temps, vous pouvez également l’utiliser pour lire le résultat.


Ok, j’ai juste essayé et c’était un peu plus de cinq lignes traitant principalement de la synchronisation des signaux SPI avec une horloge système (fréquence interne plus élevée).

Le code suivant a été rapidement piraté et semble fonctionner:

 // 
 //  Simple dumb SPI interface : 
 //  one big long shift register 
 //  Relies on  a system clock which is  
 //  much faster then  the SPI clock // 
 //  User MUST send the right amount of  bits in  one go . 
 // module spi_dumb #( parameter DW =   128 )   //  Number of  internal data bits (  
     //  Usual system signals input clk ,       //  system clock input reset_n ,   //  system reset //  SPI interface input sclk , input sel_n , input mosi , output miso , 

     //  Internal data interface input [ DW - 1 : 0 ]  par_tx ,   //  Data to  transmit output reg [ DW - 1 : 0 ]  par_rx ,   //  Data received output reg valid //  Data has arrived ); reg sclk_meta , sclk_sync , sclk_prev ; reg seln_meta , seln_sync , seln_prev ; wire clock_edge ; 

 //  assign clock_edge =   ~ sclk_prev &  sclk_sync ;   //  Rising edge assign clock_edge =  sclk_prev &   ~ sclk_sync ;   //  Falling edge always @( posedge clk or  negedge reset_n ) 
    begin 
       if   (! reset_n ) 
       begin valid <=   1 'b0 ; sclk_meta <=   1 'b0 ; sclk_sync <=   1 'b0 ; sclk_prev <=   1 'b0 ; seln_meta <=   1 'b0 ; seln_sync <=   1 'b0 ; seln_prev <=   1 'b0 ; 
       end 
       else 
       begin 
          //  Sychronise the clkc and   select sclk_meta <=  sclk ; sclk_sync <=  sclk_meta ; sclk_prev <=  sclk_sync ; seln_meta <=  sel_n ; seln_sync <=  seln_meta ; seln_prev <=  seln_sync ; 

          //   On  falling edge SPI - Select  load the shift register 
          if   ( seln_prev &   ~ seln_sync ) 
          begin par_rx <=  par_tx ; valid <=   1 'b0 ; 
          end 

          //   On  rising edge SPI - Select  mark the data as valid if   (~ seln_prev &  seln_sync ) valid <=   1 'b1 ; 

          //   If  SPI select   is  low and  we have a clock edge pick up the data //  We assume the mosi data is  stable by then 
          //   (~ Two system clocks after  SPI clock edge ) 
          if   (! seln_prev &&  clock_edge ) par_rx <=   { par_rx [ DW - 2 : 0 ], mosi }; 
       end 
    end assign miso =  par_rx [ DW - 1 ]; endmodule /* 
  *  
  *  Auto generated testbench ,  generated Wed Jun 20   11 : 04 : 23   2018 
  *  post edited * 
  */ module spi_dumb_test ; localparam CLK_PERIOD = 100 ; localparam DW =   128 ; 


     //  Usual system signals reg clk ;   //  system clock reg reset_n ;   //  system reset //  SPI interface reg sclk ; reg sel_n ; reg mosi ; wire miso ; 

     //  Internal data interface reg [ DW - 1 : 0 ]  par_tx ;   //  Data to  transmit wire [ DW - 1 : 0 ]  par_rx ;   //  Data received wire valid ; 

 integer  bit_count ; reg [ DW - 1 : 0 ]  master_tx ;   //  Data to  transmit reg [ DW - 1 : 0 ]  master_rx ;   //  Data received initial begin 
     //  Usual system signals reset_n =   1 'b0 ; 

     //  SPI interface sclk =   1 'b0 ; sel_n =   1 'b1 ; mosi =   1 'b0 ; 

     //  Internal data interface par_tx =  'b0 ; 
       #( 5 * CLK_PERIOD )  reset_n = 1 'b1 ; 



       #( 5 * CLK_PERIOD )  sel_n =   1 'b0 ; par_tx =   128 'h12345678_11111111_87654321_A5C33C5A ; master_tx =   128 'h23242526_34353637_45464748_56575859 ; 

       for   ( bit_count = 0 ;  bit_count < 128 ;  bit_count = bit_count + 1 ) 
       begin 
          #( 5 * CLK_PERIOD )   ; 

          //  Tx &  RX master emulation ,  MS bits first mosi =  master_tx [ DW - bit_count - 1 ]; master_rx [ DW - bit_count - 1 ]   =  miso ; sclk =   1 'b1 ; 
          #( 5 * CLK_PERIOD )   ; sclk =   1 'b0 ; 
       end 
       #( 5 * CLK_PERIOD )   ; sel_n =   1 'b1 ; 

       #( 50 * CLK_PERIOD )   $ stop ; 
    end spi_dumb #(   . DW ( DW )   )   //  parameters spi_dumb_0 ( 

     //  Usual system signals . clk ( clk ),       //  system clock . reset_n ( reset_n ),   //  system reset //  SPI interface . sclk ( sclk ), 
       . sel_n ( sel_n ), 
       . mosi ( mosi ), 
       . miso ( miso ), 

     //  Internal data interface . par_tx ( par_tx ),    //  Data to  transmit . par_rx ( par_rx ),    //  Data received . valid ( valid )  
    ); 

    //   Generate  clock . initial begin clk =   1 'b0 ; forever #( CLK_PERIOD / 2 )  clk =   ~ clk ; 
    end endmodule 

Post-édition 2-7-18: a trouvé que la paire de début de fin était manquante.

DonFusili

Cela ne devrait évidemment pas devenir un fil conducteur « comparer tous les protocoles série », mais la raison pour laquelle je ne conseillerais pas SPI aux débutants est que le monde n’a toujours pas décidé de ce qu’est le protocole SPI. Cela fonctionnerait, mais nécessiterait plus de manipulations que d’autres protocoles plus standardisés. Aussi: l’écrire de manière simple et concise a tendance à conduire à des transitions de domaine d’horloge. Cela étant dit: +1, bien sûr.

Oldfart

J’ai commencé à en rédiger un et j’ai mis à jour ma réponse. Je pourrais poster le code une fois qu’il sera vérifié. (Ce qui prend 10 fois plus de temps que d’écrire le code)

Cédric

Merci beaucoup, j’apprécie votre aide. Je vais chercher plus d’informations sur SPI!


 DonFusili

La carte Basys3 possède une interface USB vers UART. Utilisez-le pour implémenter un lien UART avec votre ordinateur. Je n’ai pas encore vu un ordinateur exécutant Windows ou Linux qui ne prend pas en charge UART sur COM / tty.

Il existe un certain nombre de cœurs UART open source, mais je vous conseille de l’écrire vous-même, la plupart d’entre eux ne valent pas grand-chose et un UART n’est pas difficile à écrire de toute façon.

La (dé) sérialisation revient à remplir / vider un registre à décalage sur l’UART.

Cédric

Merci pour votre réponse, alors je commencerai à étudier le fonctionnement de l’UART!

 

#(une, 256, affecter, bits, comment, entrée, Puis-je, std_logic_vector

 

google

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *