Comment générer un retard dans verilog pour la synthèse?

Je Veux Concevoir un code Verilog pour l'Interfaçage 16*2 écran LCD. Comme dans l'écran LCD pour donner de la "commande" ou "données" nous devons donner de l'écran LCD Activer le code pin d'un "Haut vers le bas d'Impulsion d'impulsion qui signifie

**E=1;
Delay();//Must be 450ns wide delay
E=0;**

Ce l'endroit où je confonds, je signifie en Verilog pour la synthèse # ne sont pas autorisées, alors comment puis-je donner de retard ici, j'ai joint mon code ci-dessous. Il doit être noté que j'essaie de donner de retard dans mon code mais je pense que pas de retard les travaux, de sorte s'il vous plaît aidez-moi à me débarrasser de ce problème de retard......

             ///////////////////////////////////////////////////////////////////////////////////
             ////////////////////LCD Interfacing with Xilinx FPGA///////////////////////////////
             ////////////////////Important code for 16*2/1 LCDs/////////////////////////////////
             //////////////////Coder-Shrikant Vaishnav(M.Tech VLSI)/////////////////////////////
             ///////////////////////////////////////////////////////////////////////////////////

 module lcd_fpgashri(output reg [7:0]data,output reg enb,output reg rs,output reg rw ,input CLK);
        reg [15:0]hold;
        reg [13:0]count=0;
        //Code Starts from here like C's Main......
        always@(posedge CLK)
        begin
        count=count+1; //For Delay

       //For LCD Initialization   
        lcd_cmd(8'b00111000);
        lcd_cmd(8'b00000001);
        lcd_cmd(8'b00000110);
        lcd_cmd(8'b00001100);

       //This is a String "SHRI" that I want to display
        lcd_data(8'b01010011);//S
        lcd_data(8'b01001000);//H
        lcd_data(8'b01010010);//R
        lcd_data(8'b01001001);//I
        end


        //Task For Command

       task lcd_cmd(input reg [7:0]value); 
          begin
         data=value;
         rs=1'b0;
         rw=1'b0;
         enb=1'b1;        //sending high to low pulse
         hold=count[13]; //This is the place where I try to design delay
         enb=1'b0;
        end
        endtask


   //Task for Data      

    task lcd_data(input reg [7:0]value1);
        begin
         data=value1;
         rs=1'b1;
         rw=1'b0;
         enb=1'b1;        //sending high to low pulse  
         hold=count[13]; //This is the place where I try to design delay
         enb=1'b0;
        end 
        endtask


        endmodule
Regardez cette avant de vous écrire tout HDL: youtube.com/watch?v=rdAPXzxeaxs

OriginalL'auteur Shrikant Vaishnav | 2013-10-07

  1. 5

    Vous semblez être coincé dans un logiciel de programmation d'état d'esprit basé sur votre code, vous allez avoir à changer les choses autour de un peu, si vous voulez réellement décrire un contrôleur de HDL.

    Malheureusement pour vous il n'y a pas moyen de simplement insérer l'arbitraire d'un retard dans une "routine" comme vous l'avez écrit là.

    Lorsque vous écrivez un programme logiciel, il est parfaitement raisonnable d'écrire un programme comme 

    doA();
doB();
doC();

    Où chaque ligne exécute une à une, de façon séquentielle. HDL ne fonctionne pas de cette façon. Vous avez besoin de ne pas penser en termes de tâches, et commencer à penser en termes de pendules et l'état des machines.

    Rappelez-vous que lorsque vous avez toujours bloquer, l'ensemble du bloc s'exécute en parallèle sur chaque cycle d'horloge. Lorsque vous avez un énoncé comme cela à toujours bloquer:

        lcd_cmd(8'b00111000);
    lcd_cmd(8'b00000001);
    lcd_cmd(8'b00000110);
    lcd_cmd(8'b00001100);

    Cela ne vous rien de bon, parce que tous les quatre de ces exécuter simultanément sur un front montant de l'horloge, et non de manière séquentielle. Ce que vous devez faire est de créer un machine d'état, tel qu'il avance et effectue une action au cours d'une période d'horloge.

    Si je devais essayer de reproduire ces quatre lcd_cmd est de manière séquentielle, il pourrait ressembler à quelque chose comme ça.

    always @(posedge clk)
    case(state_f)
       `RESET: begin
           state_f <= `INIT_STEP_1;
           data = 8'b00111000;
       end
       `INIT_STEP_1: begin
           state_f <= `INIT_STEP_2;
           data = 8'b00000001;
       end
       `INIT_STEP_2: begin
           state_f <= `INIT_STEP_3;
           data = 8'b00000110;
       end
       `INIT_STEP_3: begin
           state_f <= `INIT_STEP_4;
           data =8'b00111000;
       end
       `INIT_STEP_4: begin
           state_f <= ???; //go to some new state
           data = 8'b00000110;
       end
    endcase
end

    Maintenant avec ce code, vous avancez à travers quatre états en quatre cycles d'horloge, de sorte que vous pouvez commencer à voir comment vous pouvez les gérer de l'écriture d'une séquence d'événements que les avances sur chaque cycle d'horloge.

    Cette réponse n'a pas obtenir de vous tout le long du chemin, comme il n'y a pas de "délai" entre ces comme vous le vouliez. Mais on pourrait imaginer d'avoir une machine à état où après avoir défini les données vous vous déplacez dans un DÉLAI d'état, où l'on pouvait définir un compteur qui compte assez de cycles d'horloge vous avez besoin pour répondre à vos contraintes de temps avant de passer à l'état suivant.

    +1 pour as there is no 'delay' in between these as you wanted. Mais pourquoi les données affectée à l'aide d'un blocage de l'affectation ?
    Vous avez raison, il devrait probablement être non-blocage, j'ai juste jeté certains pseudo-code et ne l'ai pas relu suffisamment.
    Mais monsieur Tout ce qui nous écrire à l'intérieur de la "Séquentiel Blocs" qui est "Commencer" de Fin de travaux dans l'ordre Séquentiel.....j'ai donc chose de ses œuvres de manière séquentielle...Si je me trompe alors s'il vous plaît dites-moi.....
    Les instructions à l'intérieur d'un bloc sont évalués de façon séquentielle, mais il n'y a pas de délai inhérent entre les évaluations. Dans un testbench vous pouvez insérer des retards fixes dans ces déclarations, mais ils ne sont pas synthesizable. Vous devez commencer à penser en termes de matériel, pas les logiciels.
    Sir, Mais je ne sais toujours pas comment générer un retard Selon Tim Sir Numérique, de la conception de Retard est généré à l'aide de "Contre", mais je sais pas comment faire le code pour la lutte contre.......Je veux dire, puis-je placer la déclaration de ce type " N<=N+1;" dans le même toujours bloquer cela me confond.... tellement....

    OriginalL'auteur Tim

  2. 2

    La meilleure façon d'introduire le retard est d'utiliser un compteur comme Tim l'a mentionné.
    Trouver le nombre de cycles d'horloge vous avez besoin d'attendre pour obtenir le délai requis (ici 450ns) w.r.t votre période d'horloge.

    Permet de prendre le nombre de cycles d'horloge calculé est de compter. Dans ce cas, le morceau de code suivant peut vous obtenir le délai requis. Vous pouvez cependant avoir besoin de modifier la logique de votre but.

    always @ (posedge clk) begin
  if (N == count) begin
    N <= 0;
    E = ~E;
  end else begin
    N <= N +1;    
  end 
end

    Assurez-vous d'initialiser N et E à zéro.

    Monsieur, je suis confondre à l'utilisation de "contre" pour la génération de "retard" dans votre code, je sais compteur sont utilisées pour la génération de retard, mais ne savez pas comment l'utiliser selon les besoins ......Je veux dire pourquoi vous utilisez le si et d'autre condition, comme un flip-flop et pourquoi vous utilisez le "E".....Je veux dire pourquoi ne pas utiliser simplement et toujours à l'intérieur de ce lieu "N<=N+1;"........
    Lorsque vous utilisez seulement il y a toujours un retard de jeu, mais comment voulez-vous obtenir dans votre logique ? Ici, "E" peut être considéré comme un activer/clock_enable pour votre logique. Donc, chaque fois que le nombre est atteint, je.e, vous délai requis est atteint l'activer/clock_enable bascule. J'ai utilisé "E", car dans votre condition vous l'avais mentionné que la même. voir ci-dessous. E=0 <Retard> E=1
    Sir puis-je utiliser comme ça ....Permettez-nous de considérer 1 count=1ns alors pour 450ns j'ai besoin de 450 chefs d'accusation alors, selon vous, cela peut-il travaille toujours@(posedge clk)begin "mylogic le" compteur<=count+1; if(count==450)commencer désactiver fin fin.......

    OriginalL'auteur Vineeth VS