URL https://opencores.org/ocsvn/virtual_rs232_terminal_with_lvds_lcd/virtual_rs232_terminal_with_lvds_lcd/trunk

Subversion Repositories virtual_rs232_terminal_with_lvds_lcd

[/] [virtual_rs232_terminal_with_lvds_lcd/] [trunk/] [rtl/] [main.v] - Blame information for rev 2

Details | Compare with Previous | View Log


`timescale 1ns / 1ps
///////////////////////////////////////////////////////////////////////////////
// Company: EnergyLabs Brasil
// Engineer: Lucas Teske
// 
// Create Date:         16:11:50 02/04/2011 
// Design Name:                 LVDS LCD Virtual Terminal
// Module Name:         main 
// Project Name:        LVDS LCD Virtual Terminal
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Revision 0.02 - Circuito Funcionando, ainda com alguns bugs.
// Revision 0.03 - Reescrito descri��es, c�digo organizado
// Additional Comments: 
//
//////////////////////////////////////////////////////////////////////////////
module main(
                                 input  clk,
                                 output         [2:0] dataouta_p,
                                 output         [2:0] dataouta_n,
                                 output         clkouta1_p,
                                 output         clkouta1_n,
                                 output         led1,
                                 output         led2,
                                 output         led3,
                                 output         led4,
                                 output         TxD,
                                 input  RxD,
                                 input  PS2clk,
                                 input  PS2data
    );
 
 
//Multiplicador de Clock (DCM)
//Tenho um clock de 16MHz na entrada, periodo 62.5ns
//Multiplico ele por 4 para obter 64MHz, a tela pecisa de 60Mhz para fazer 60Hz + ou -
 
wire clo,clk4x;
DCM_SP #(
        .CLKIN_PERIOD   ("62.5"),
        .CLKFX_MULTIPLY (4)
        )
dcm_main (
        .CLKIN          (clk),
        .CLKFB          (clo),
        .RST            (1'b0),
        .CLK0           (clo),
        .CLKFX          (clk4x)
);
defparam dcm_main.CLKIN_PERIOD = 62.5;
defparam dcm_main.CLKFX_MULTIPLY = 4;
defparam dcm_main.CLKFX_DIVIDE = 1;
 
//Parametros para o tamanho da tela
 
parameter ScreenX = 1024;
parameter ScreenY = 768;
 
//Registradores para a cor
 
reg [5:0] DataBlue = 0;
reg [5:0] DataRed = 0;
reg [5:0] DataGreen = 0;
 
//Contador de colunas e linhas
//Com esses valores voc� pode desenhar na tela
reg [10:0] ContadorX = 0; // Contador de colunas
reg [10:0] ContadorY = 0; // Contador de linhas
 
//Sincronia Horizontal e Vertical
//S�o sinais que atuam na descida, ent�o padr�o deles � 1
reg HSync = 1;
reg VSync = 1;
//Ativa a grava��o de dados no LCD.
//Atente-se que o data_enable � recebido pelo LCD,
//Ele atua entre uma linha e outra ou entre uma tela e outra
reg data_enable = 1;
 
//Esse registrador � usado para fazer o fundo se mover. A cada vsync ele � incrementado.
//Somo esse registrador nos valores de R, G e B para rodar o fundo.
reg [5:0] Parallax = 0;
 
 
//Tamanho do Console Virtual e Registradores de Controle
 
//Esses registradores s�o usados na leitura
reg [6:0] ColunaChar = 1;
reg [5:0] LinhaChar = 1;
reg LineLock = 0;
reg CharLock = 0;
 
//Esses Registradores s�o usados na grava��o
reg [6:0] ColunaW = 0;
reg [5:0] RefLine = 59;
reg [6:0] RefChar = 0;
 
//Defini��o do tamanho do console.
//Note que s�o apenas wires para a detec��o do fim
//das colunas e linhas. H� outras altera��es al�m 
//daqui para se aumentar o console.
 
wire MaxChars = (ColunaChar == 79);
wire MaxLines = (LinhaChar == 59);
 
//Limites do console virtual
wire OutOfBondary = ((ContadorY < 144) | (ContadorY >= 624) | (ContadorX >= 835) | (ContadorX <= 192));
 
reg [2:0] PixelChar = 7;
wire [7:0] CharByte;
wire [7:0] ActualChar;
reg Point = 0;
 
//Operadores da RAM
 
reg charwrote = 0;
reg ReadScroll = 0;
reg ReadEnable = 1;
reg [12:0] ContadorChar  = 4720; // Registrador para Grava��o do caracter na RAM
reg [7:0] DataWrite;
reg WriteLocked = 0;
reg WorkLocked = 0;
reg [1:0] ScreenWork = 0;
reg CharErased = 0;
reg CharWrited = 0;
reg Scrolling = 0;
wire [17:0] LogoByte;
reg [5:0] LinhaShift = 0;
reg [5:0] LinhaRead = 0;
 
//Serial Write Data
reg WE;
wire [7:0] SerialByte;
wire SerialReady;
wire SerialIdle;
 
 
//Wires para ligar os sub-circuitos
wire [20:0] lcddata;
wire [27:0] serializerdata;
wire serial_write, TxD_busy;
wire [7:0] serial_data;
wire mod_led;
 
//Transmissor Serial
async_transmitter SerialTX(
        .clk(clk4x),
        .TxD(TxD),
        .TxD_start(serial_write),
        .TxD_data(serial_data),
        .TxD_busy(TxD_busy)
        );
 
//Receptor Serial
async_receiver SerialRX (
    .clk(clk4x),
    .RxD(RxD),
    .RxD_data_ready(SerialReady),
    .RxD_data(SerialByte),
    .RxD_idle(SerialIdle)
    );
 
//Controlador do Teclado PS2
PS2 Keyboard (
    .clk(clk4x),
    .ps2clk(PS2clk),
    .ps2data(PS2data),
    .write(serial_write),
    .dataout(serial_data),
         .mod_led(mod_led)
    );
 
//Serializador LVDS
 
top4_tx serializador (
        .clkint(clk4x),
    .datain(serializerdata),
    .rstin(1'b1),
    .dataouta_p(dataouta_p),
         .dataouta_n(dataouta_n),
    .clkouta1_p(clkouta1_p),
    .clkouta1_n(clkouta1_n)
    );
 
 
//ROM com Logo da EnergyLabs Brasil
LogoROM LogoROM (
        .clka(clk4x),
        .ena( (((ContadorX <= 128)|(ContadorX >= (ScreenX-128))) & (ContadorY <= 128))),
        .addra({ContadorY[6:1],ContadorX[6:1]}),
        .douta(LogoByte));
 
//ROM com a fonte IBM PC
fontrom  FONT_ROM (
        .clka(clk4x),
        .addra({ContadorY[2:0],ActualChar[7:0]}),
        .douta(CharByte));
 
//RAM para Buffer dos caracteres na tela
textram CharRam (
        .clka(clk4x),
        .ena(WE),
        .wea(WE),
        .addra(ContadorChar),
        .dina(DataWrite),
        .clkb(clk4x),
        .enb(ReadEnable | ReadScroll),
        .addrb({(LinhaRead)*80+ColunaChar}),
        .doutb(ActualChar));
 
//Fun��o da recep��o de dados na Serial
always @(posedge clk4x)
begin
        //Trabalhos
        if(WorkLocked)
        begin
                        case(ScreenWork)
                                2'b01: //BackSpace
                                begin
                                                if(~CharErased)
                                                begin
                                                                ContadorChar    <= ContadorChar -1;
                                                                if(RefChar == 0)
                                                                begin
                                                                                RefChar         <= 79;
                                                                                if(RefLine == 0)
                                                                                        RefLine         <= 59;
                                                                                else
                                                                                        RefLine         <= RefLine - 1;
                                                                end
                                                                else
                                                                                RefChar         <= RefChar - 1;
                                                                DataWrite       <= 0;
                                                                WE                      <= 1;
                                                                WorkLocked      <= 1;
                                                                CharErased      <= 1;
                                                end
                                                else
                                                begin
                                                                DataWrite       <='h00;
                                                                WE                      <= 0;
                                                                WorkLocked      <= 0;
                                                                CharErased      <= 0;
                                                end
                                end
                                2'b10: //ClearScreen
                                begin
                                                if(ContadorChar != 4799)
                                                begin
                                                                DataWrite       <= 'h00;
                                                                WE                      <= 1;
                                                                ContadorChar <= ContadorChar +1;
                                                                if(RefChar == 79)
                                                                begin
                                                                                RefChar         <= 0;
                                                                                if(RefLine == 59)
                                                                                        RefLine <= 0;
                                                                                else
                                                                                        RefLine <= RefLine + 1;
                                                                end
                                                                else
                                                                                RefChar <= RefChar + 1;
                                                end
                                                else
                                                begin
                                                                WE                              <= 0;
                                                                ContadorChar    <= 4720;
                                                                WorkLocked              <= 0;
                                                                RefChar                         <= 0;
                                                                RefLine                         <= 59;
                                                                LinhaShift              <= 0;
                                                end
                                end
                                2'b11: //Scroll Screen UP
                                begin
                                                if(Scrolling == 0)
                                                begin
                                                                Scrolling               <=      1;
                                                                WE                              <= 0;
                                                                if(LinhaShift == 59)
                                                                        ContadorChar <= 0;
                                                                else
                                                                        ContadorChar <= (LinhaShift+1)  * 80; // Ponto de grava��o
                                                                ReadScroll              <= 0;
                                                                ColunaW                         <= 0;
                                                                if(LinhaShift == 59)
                                                                        LinhaShift      <= 0;
                                                                else
                                                                        LinhaShift      <=      LinhaShift      +       1;
                                                end
                                                else
                                                begin
                                                                if(charwrote)
                                                                begin
                                                                                //Ciclo de Posicionamento
                                                                                charwrote       <= 0;
                                                                                WE                      <= 0;
                                                                                if(ColunaW == 79)
                                                                                begin
                                                                                                Scrolling               <= 0;
                                                                                                WorkLocked              <=      0;
                                                                                                RefLine                         <= 59;
                                                                                                RefChar                         <= 0;
                                                                                                ColunaW                         <= 0;
                                                                                                ContadorChar    <= LinhaShift * 80; // Ponto de grava��o
                                                                                end
                                                                                else
                                                                                begin
                                                                                                ColunaW                         <= ColunaW      +       1;
                                                                                                ContadorChar    <= ContadorChar + 1;
                                                                                end
                                                                end
                                                                else
                                                                begin
                                                                                //Ciclo de Grava��o
                                                                                charwrote       <= 1;
                                                                                DataWrite       <= 0;
                                                                                WE                      <= 1;
                                                                end
                                                end
/*
                        Aqui � a rotina antiga de shift do conte�do da tela
                        Ele reescrevia todas as linhas no endere�o anterior da atual
                        Muito lento, por isso refiz apenas com um registrador de deslocamento
                                                if(Scrolling == 0)
                                                begin
                                                                Scrolling <= 1;
                                                                LinhaW <= 1;
                                                                ColunaW <= 0;
                                                                ContadorChar <= 0;
                                                                charwrote <= 0;
                                                end
                                                else
                                                begin
                                                                if(charwrote)
                                                                begin //Ciclo de sele��o
                                                                                charwrote <= 0;
                                                                                charread <= 0;
                                                                                WE <= 0;
                                                                                ReadScroll <= 1;
                                                                                if(ColunaW == 79)
                                                                                begin
                                                                                                ColunaW <= 0;
                                                                                                if(LinhaW == 60)
                                                                                                begin
                                                                                                                Scrolling <= 0;
                                                                                                                LinhaW <= 0;
                                                                                                                WorkLocked <=0;
                                                                                                                RefLine <= 59;
                                                                                                                RefChar <= 0;
                                                                                                                ContadorChar <= 4720; // 59 * 80 = 4720
                                                                                                end
                                                                                                else
                                                                                                begin
                                                                                                                ContadorChar <= LinhaW * 80;
                                                                                                                LinhaW <= LinhaW +1;
                                                                                                end
                                                                                end
                                                                                else
                                                                                begin
                                                                                                ContadorChar <= ContadorChar +2;
                                                                                                ColunaW <= ColunaW + 1;
                                                                                end
                                                                end
                                                                else
                                                                begin //Ciclo de Grava��o
                                                                                if(charread)
                                                                                begin
                                                                                                WE <= 1;
                                                                                                charwrote <= 1;
                                                                                                ReadScroll <= 0;
                                                                                                charread <= 0;
                                                                                end
                                                                                else
                                                                                begin
                                                                                                DataWrite <= ActualChar;
                                                                                                charread <= 1;
                                                                                                ContadorChar <= ContadorChar -1;
                                                                                end
 
 
                                                                end
                                                end
                                */
                                end
                        endcase
        end
        if(SerialReady & ~WriteLocked & ~WorkLocked)
        begin
                        WriteLocked <= 1;
                        //Checagem de BYTE recebido
                        //Aqui h� um pequeno problema, o Windows envia \r\n e o Linux apenas \n.
                        //N�o deveria dar problema, o maximo que iria acontecer � pular duas linhas.
                        //Mas n�o funciona. Para o Windows, comente todas as linhas no Carriage Return
 
                        case (SerialByte)
                                'h0A: // Nova linha \n
                                        begin
                                                        WorkLocked      <= 1;
                                                        ScreenWork      <= 2'b11;
                                        end
                                'h08: // BackSpace
                                        begin
                                                        WorkLocked      <= 1;
                                                        ScreenWork      <= 1; //BackSpace
                                        end
                                'h09: //Horizontal Tab, acertado pra 5 espa�os.
                                        begin
                                                        //N�o dar Tab se a linha n�o tiver menos do que 5 caracteres dispon�veis no caso, 75 ocupados.
                                                        if( ((RefLine * 80) - ContadorChar) < 74)
                                                        begin
                                                                        ContadorChar    <= ContadorChar + 5;
                                                                        RefChar                         <= RefChar + 5;
                                                        end
 
                                        end
                                'h0D: // Carriage Return, retornar para  coluna 1, \r
                                        begin
                                                        ContadorChar    <= RefLine * 80;
                                                        RefChar                         <= 0;
                                        end
 
                                'h0C: //Frame Feed - Apagar a tela e retornar ao caracter 0x0 da tela.
                                        begin
                                                        WorkLocked              <=1;
                                                        ScreenWork              <= 2; //Erase Screen
                                                        ContadorChar    <= 0;
                                        end
                                default: //Caso n�o seja nenhum dos listados acima
                                begin
                                                DataWrite       <= SerialByte;
                                                WE                      <= 1;
                                                CharWrited      <=1;
                                end
                        endcase
        end
 
        if(CharWrited)
        begin
                        //Caso o caractere j� tenha sido gravado na RAM
                        //Aqui ele posicionar� o gravador um caracter 
                        //adiante. Ele tamb�m ir� atualizar RefLine e RefChar
                        if( (ContadorChar == 4799) | (RefChar == 79) )
                        begin
                                        WorkLocked              <= 1;
                                        ScreenWork              <= 2'b11;
                                        if(RefChar == 79)
                                        begin
                                                RefChar <= 0;
                                                if(RefLine == 59)
                                                        RefLine <= 0;
                                                else
                                                        RefLine <= RefLine + 1;
                                        end
                        end
                        else
                        begin
                                        ContadorChar    <= ContadorChar         +       1;
                                        RefChar                         <= RefChar                      +       1;
                        end
                        CharWrited <= 0;
                        WE <= 0;
        end
 
        if(SerialIdle)
        begin
                        WriteLocked <=  0;
                        if(~WorkLocked)
                                        WE      <= 0;
        end
end
 
//Ciclo de Imagem
always @(posedge clk4x)
begin
                //Como a RAM de Buffer s� escreve ou l�, mas nunca os dois ao mesmo tempo,
                //Definimos aqui, que caso esteja fazendo algum trabalho, na memoria
                //O ReadEnable ser� 0, caso n�o, ser� o valor do data_enable
                if(WorkLocked != 1)
                                ReadEnable <= data_enable;
                else
                                ReadEnable <= 0;
 
                //Detectamos aqui se estamos dentro da �rea do console
                //Se n�o estamos trabalhando e apagando a tela
                if(~OutOfBondary & ~((ScreenWork == 2'b11) & (WorkLocked == 1)) )
                begin
                                if((ContadorX[2:0] == 0) & ~CharLock)
                                begin
                                                CharLock        <= 1;
                                                if(MaxChars)
                                                                ColunaChar      <= 0;
                                                else
                                                                ColunaChar      <= ColunaChar +1;
                                end
                                if(ContadorX[2:0] != 0)
                                        CharLock        <= 0;
 
                                if(ContadorY[2:0] == 0 & ~LineLock)
                                begin
                                                LineLock        <= 1;
                                                if(MaxLines)
                                                begin
                                                                LinhaChar       <=0;
                                                                LinhaRead       <= LinhaShift;
                                                end
                                                else
                                                begin
                                                                LinhaChar       <= LinhaChar +1;
                                                                if((LinhaShift+LinhaChar+1) >= 60)
                                                                        LinhaRead       <= (LinhaShift+LinhaChar+1)-59;
                                                                else
                                                                        LinhaRead       <= LinhaShift+LinhaChar+1;
                                                end
                                end
 
                                if(ContadorY[2:0] != 0)
                                        LineLock        <=      0;
 
                                if(ContadorX[2:0] == 2)
                                begin
                                                PixelChar       <= 7;
                                                Point           <= CharByte[PixelChar];
                                end
                                else
                                begin
                                                PixelChar       <= PixelChar -1;
                                                Point           <= CharByte[PixelChar];
                                end
                                if(Point)
                                begin
                                                DataBlue        <= 6'b111111;
                                                DataGreen       <= 6'b111111;
                                                DataRed                 <= 6'b111111;
                                end
                                else
                                begin
                                                DataRed                 <= 6'b000000;
                                                DataBlue        <= 6'b000000;
                                                DataGreen       <= 6'b000000;
                                end
                        end
                        else
                        begin
                                if(~((ScreenWork == 2'b11) & (WorkLocked == 1)))
                                begin
                                                if((ContadorX >= 835) | (ContadorX <= 190))
                                                begin
                                                                CharLock        <=      1;
                                                                ColunaChar      <= 0;
                                                end
                                                if((ContadorY < 144) | (ContadorY >= 624))
                                                begin
                                                                LinhaChar       <= 0;
                                                                if(LinhaShift == 59)
                                                                        LinhaRead       <= 0;
                                                                else
                                                                        LinhaRead       <= LinhaShift+1;
                                                                LineLock        <= 1;
                                                end
                                                DataBlue        <= 0;
                                                DataGreen       <= 0;
                                                DataRed                 <= 0;
                                end
                                else
                                begin
                                                LinhaChar       <= 0;
                                                LinhaRead       <= 0;
                                                ColunaChar      <= 0;
                                end
                        end
 
                        if(((ContadorX < 128) | (ContadorX > (ScreenX-128))) & (ContadorY < 128) & ~( ( ( (LogoByte[17:12] <= 4) | (LogoByte[5:0] <= 4) ) ) & (LogoByte[11:6] == 63)))
                        begin
                                        DataRed                 <= LogoByte[17:12];
                                        DataGreen       <= LogoByte[11:6];
                                        DataBlue        <= LogoByte[5:0];
                        end
                        else
                        begin
 
                                if((ContadorY < 140) | (ContadorX > 835) | (ContadorX < 190) | (ContadorY > 623) )
                                begin
                                                DataRed                 <= ( ( (ContadorY[5:0]+Parallax) ^ (ContadorX[5:0]+Parallax)      ) * 2   );
                                                DataBlue        <= ( ( (ContadorY[5:0]+Parallax) ^ (ContadorX[5:0]+Parallax)      ) * 3 );
                                                DataGreen       <= ( ( (ContadorY[5:0]+Parallax) ^ (ContadorX[5:0]+Parallax)      ) * 4 );
                                end
                                if( ( (ContadorY == 140) & (ContadorX >= 191) & (ContadorX <= 623) ) | ( (ContadorY == 623) & (ContadorX >= 191) & (ContadorX <= 623) ) | ( (ContadorX == 835) & (ContadorY >= 140) & (ContadorY <= 623) ) | ( (ContadorX == 191) & (ContadorY >= 140) & (ContadorY <= 623) ) )
                                begin
                                                DataBlue        <= 6'b111111;
                                                DataGreen       <= 6'b111111;
                                                DataRed                 <= 6'b111111;
                                end
                                if( (ContadorY >= 141) & (ContadorY <= 143) & (ContadorX >= 191) & (ContadorX <= 623) )
                                begin
                                                DataBlue        <= 6'b000000;
                                                DataGreen       <= 6'b000000;
                                                DataRed                 <= 6'b000000;
                                end
                        end
 
                        //Sync Generator
 
                        ContadorX <= ContadorX + 1;
 
                        if((ContadorX == 0) & (ContadorY < ScreenY))
                                        data_enable     <= 1;
 
                        if(ContadorX == ScreenX)
                        begin
                                        data_enable     <= 0;
                                        DataBlue                <= 0;
                                        DataRed                         <= 0;
                                        DataGreen               <= 0;
                                        HSync                   <= 0;
                        end
 
                        if(ContadorX == (ScreenX+280))
                                        HSync                   <= 1;
 
                        if(ContadorX == (ScreenX+300))
                        begin
                                        if(ContadorY == ScreenY)
                                        begin
                                                        VSync           <= 0;
                                                        data_enable <= 0;
                                        end
                                        if(ContadorY == (ScreenY+35))
                                        begin
                                                        VSync           <= 1;
                                                        Parallax        <= Parallax - 1;
                                                        ContadorY       <= 0;
                                                        ContadorX       <= 0;
                                        end
                                        else
                                                        ContadorY <= ContadorY +1;
                        end
 
                        if(ContadorX == (ScreenX+320))
                                        ContadorX       <= 0;
end
 
 
 
//Designa��es de pinos e leds.
assign DE               = data_enable;
assign led1    = mod_led;
assign led2             = SerialReady;
assign led3             = ~PS2clk;
assign led4             = WorkLocked;
 
 
//Aqui fiz um pequeno jogo. O XAPP486 da Xilinx envia os dados assim:
//                      0,      4,      8,      12,     16,     20,     24 - Canal 0
//                      1,      5,      9,      13,     17,     21,     25 - Canal 1
//                      2,      6,      10,     14,     18,     22,     26 - Canal 2
//                      3,      7,      11,     15,     19,     23,     27 - Canal 3
//
//Por�m, o LCD precisa deles assim:
//                              6,              5,              4,              3,              2,              1,              0        - Canal 0
//                              13,     12,     12,     10,     9,              8,              7       - Canal 1
//                              20,     19,     18,     17,     16,     15,     14      - Canal 2
//                              X,              X,              X,              X,              X,              X,              X       - Canal 3
// Nota: X <= Irrelevante
//Ent�o fiz aqui uma associa��o da maneira que eu precisava.
 
assign serializerdata[0]         = lcddata[6];  //
assign serializerdata[4]        = lcddata[5];   //
assign serializerdata[8]        = lcddata[4];   //
assign serializerdata[12]       = lcddata[3];  // Canal 0 
assign serializerdata[16]       = lcddata[2];   //
assign serializerdata[20]       = lcddata[1];   //
assign serializerdata[24]       = lcddata[0];    //
 
assign serializerdata[1]        = lcddata[13]; //
assign serializerdata[5]        = lcddata[12]; //
assign serializerdata[9]        = lcddata[11]; //
assign serializerdata[13]       = lcddata[10]; //       Canal 1
assign serializerdata[17]       = lcddata[9];  //
assign serializerdata[21]       = lcddata[8];  //
assign serializerdata[25]       = lcddata[7];  //
 
assign serializerdata[2]        = lcddata[20]; //
assign serializerdata[6]        = lcddata[19]; //
assign serializerdata[10]       = lcddata[18]; //
assign serializerdata[14]       = lcddata[17]; //       Canal 3
assign serializerdata[18]       = lcddata[16]; //
assign serializerdata[22]       = lcddata[15]; //
assign serializerdata[26]       = lcddata[14]; //
 
assign serializerdata[3]        = 1'b0;                 //
assign serializerdata[7]        = 1'b0;                 //
assign serializerdata[11]       = 1'b0;                 //
assign serializerdata[15]       = 1'b0;                 //      Canal 4 - Por�m irrelevante
assign serializerdata[19]       = 1'b0;                 //
assign serializerdata[23]       = 1'b0;                 //
assign serializerdata[27]       = 1'b0;                 //
 
// A ordem destes bits no LCD �: Data Enable, Sincronia Vertical, Sincronia Horizontal
assign lcddata [20:18]  = { DE , VSync, HSync};
 
//A ordem de cores no LCD �: AZUL, VERDE, VERMELHO
assign lcddata [17:0] = {DataBlue, DataGreen, DataRed};
 
endmodule

Browse

Tools

Subversion Repositories virtual_rs232_terminal_with_lvds_lcd

[/] [virtual_rs232_terminal_with_lvds_lcd/] [trunk/] [rtl/] [main.v] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	racerxdl	`timescale 1ns / 1ps
2			`///////////////////////////////////////////////////////////////////////////////`
3			`// Company: EnergyLabs Brasil`
4			`// Engineer: Lucas Teske`
5			`//`
6			`// Create Date: 16:11:50 02/04/2011`
7			`// Design Name: LVDS LCD Virtual Terminal`
8			`// Module Name: main`
9			`// Project Name: LVDS LCD Virtual Terminal`
10			`// Target Devices:`
11			`// Tool versions:`
12			`// Description:`
13			`//`
14			`// Dependencies:`
15			`//`
16			`// Revision:`
17			`// Revision 0.01 - File Created`
18			`// Revision 0.02 - Circuito Funcionando, ainda com alguns bugs.`
19			`// Revision 0.03 - Reescrito descri��es, c�digo organizado`
20			`// Additional Comments:`
21			`//`
22			`//////////////////////////////////////////////////////////////////////////////`
23			`module main(`
24			`input clk,`
25			`output [2:0] dataouta_p,`
26			`output [2:0] dataouta_n,`
27			`output clkouta1_p,`
28			`output clkouta1_n,`
29			`output led1,`
30			`output led2,`
31			`output led3,`
32			`output led4,`
33			`output TxD,`
34			`input RxD,`
35			`input PS2clk,`
36			`input PS2data`
37			`);`
38
39
40			`//Multiplicador de Clock (DCM)`
41			`//Tenho um clock de 16MHz na entrada, periodo 62.5ns`
42			`//Multiplico ele por 4 para obter 64MHz, a tela pecisa de 60Mhz para fazer 60Hz + ou -`
43
44			`wire clo,clk4x;`
45			`DCM_SP #(`
46			`.CLKIN_PERIOD ("62.5"),`
47			`.CLKFX_MULTIPLY (4)`
48			`)`
49			`dcm_main (`
50			`.CLKIN (clk),`
51			`.CLKFB (clo),`
52			`.RST (1'b0),`
53			`.CLK0 (clo),`
54			`.CLKFX (clk4x)`
55			`);`
56			`defparam dcm_main.CLKIN_PERIOD = 62.5;`
57			`defparam dcm_main.CLKFX_MULTIPLY = 4;`
58			`defparam dcm_main.CLKFX_DIVIDE = 1;`
59
60			`//Parametros para o tamanho da tela`
61
62			`parameter ScreenX = 1024;`
63			`parameter ScreenY = 768;`
64
65			`//Registradores para a cor`
66
67			`reg [5:0] DataBlue = 0;`
68			`reg [5:0] DataRed = 0;`
69			`reg [5:0] DataGreen = 0;`
70
71			`//Contador de colunas e linhas`
72			`//Com esses valores voc� pode desenhar na tela`
73			`reg [10:0] ContadorX = 0; // Contador de colunas`
74			`reg [10:0] ContadorY = 0; // Contador de linhas`
75
76			`//Sincronia Horizontal e Vertical`
77			`//S�o sinais que atuam na descida, ent�o padr�o deles � 1`
78			`reg HSync = 1;`
79			`reg VSync = 1;`
80			`//Ativa a grava��o de dados no LCD.`
81			`//Atente-se que o data_enable � recebido pelo LCD,`
82			`//Ele atua entre uma linha e outra ou entre uma tela e outra`
83			`reg data_enable = 1;`
84
85			`//Esse registrador � usado para fazer o fundo se mover. A cada vsync ele � incrementado.`
86			`//Somo esse registrador nos valores de R, G e B para rodar o fundo.`
87			`reg [5:0] Parallax = 0;`
88
89
90			`//Tamanho do Console Virtual e Registradores de Controle`
91
92			`//Esses registradores s�o usados na leitura`
93			`reg [6:0] ColunaChar = 1;`
94			`reg [5:0] LinhaChar = 1;`
95			`reg LineLock = 0;`
96			`reg CharLock = 0;`
97
98			`//Esses Registradores s�o usados na grava��o`
99			`reg [6:0] ColunaW = 0;`
100			`reg [5:0] RefLine = 59;`
101			`reg [6:0] RefChar = 0;`
102
103			`//Defini��o do tamanho do console.`
104			`//Note que s�o apenas wires para a detec��o do fim`
105			`//das colunas e linhas. H� outras altera��es al�m`
106			`//daqui para se aumentar o console.`
107
108			`wire MaxChars = (ColunaChar == 79);`
109			`wire MaxLines = (LinhaChar == 59);`
110
111			`//Limites do console virtual`
112			`wire OutOfBondary = ((ContadorY < 144) \| (ContadorY >= 624) \| (ContadorX >= 835) \| (ContadorX <= 192));`
113
114			`reg [2:0] PixelChar = 7;`
115			`wire [7:0] CharByte;`
116			`wire [7:0] ActualChar;`
117			`reg Point = 0;`
118
119			`//Operadores da RAM`
120
121			`reg charwrote = 0;`
122			`reg ReadScroll = 0;`
123			`reg ReadEnable = 1;`
124			`reg [12:0] ContadorChar = 4720; // Registrador para Grava��o do caracter na RAM`
125			`reg [7:0] DataWrite;`
126			`reg WriteLocked = 0;`
127			`reg WorkLocked = 0;`
128			`reg [1:0] ScreenWork = 0;`
129			`reg CharErased = 0;`
130			`reg CharWrited = 0;`
131			`reg Scrolling = 0;`
132			`wire [17:0] LogoByte;`
133			`reg [5:0] LinhaShift = 0;`
134			`reg [5:0] LinhaRead = 0;`
135
136			`//Serial Write Data`
137			`reg WE;`
138			`wire [7:0] SerialByte;`
139			`wire SerialReady;`
140			`wire SerialIdle;`
141
142
143			`//Wires para ligar os sub-circuitos`
144			`wire [20:0] lcddata;`
145			`wire [27:0] serializerdata;`
146			`wire serial_write, TxD_busy;`
147			`wire [7:0] serial_data;`
148			`wire mod_led;`
149
150			`//Transmissor Serial`
151			`async_transmitter SerialTX(`
152			`.clk(clk4x),`
153			`.TxD(TxD),`
154			`.TxD_start(serial_write),`
155			`.TxD_data(serial_data),`
156			`.TxD_busy(TxD_busy)`
157			`);`
158
159			`//Receptor Serial`
160			`async_receiver SerialRX (`
161			`.clk(clk4x),`
162			`.RxD(RxD),`
163			`.RxD_data_ready(SerialReady),`
164			`.RxD_data(SerialByte),`
165			`.RxD_idle(SerialIdle)`
166			`);`
167
168			`//Controlador do Teclado PS2`
169			`PS2 Keyboard (`
170			`.clk(clk4x),`
171			`.ps2clk(PS2clk),`
172			`.ps2data(PS2data),`
173			`.write(serial_write),`
174			`.dataout(serial_data),`
175			`.mod_led(mod_led)`
176			`);`
177
178			`//Serializador LVDS`
179
180			`top4_tx serializador (`
181			`.clkint(clk4x),`
182			`.datain(serializerdata),`
183			`.rstin(1'b1),`
184			`.dataouta_p(dataouta_p),`
185			`.dataouta_n(dataouta_n),`
186			`.clkouta1_p(clkouta1_p),`
187			`.clkouta1_n(clkouta1_n)`
188			`);`
189
190
191			`//ROM com Logo da EnergyLabs Brasil`
192			`LogoROM LogoROM (`
193			`.clka(clk4x),`
194			`.ena( (((ContadorX <= 128)\|(ContadorX >= (ScreenX-128))) & (ContadorY <= 128))),`
195			`.addra({ContadorY[6:1],ContadorX[6:1]}),`
196			`.douta(LogoByte));`
197
198			`//ROM com a fonte IBM PC`
199			`fontrom FONT_ROM (`
200			`.clka(clk4x),`
201			`.addra({ContadorY[2:0],ActualChar[7:0]}),`
202			`.douta(CharByte));`
203
204			`//RAM para Buffer dos caracteres na tela`
205			`textram CharRam (`
206			`.clka(clk4x),`
207			`.ena(WE),`
208			`.wea(WE),`
209			`.addra(ContadorChar),`
210			`.dina(DataWrite),`
211			`.clkb(clk4x),`
212			`.enb(ReadEnable \| ReadScroll),`
213			`.addrb({(LinhaRead)*80+ColunaChar}),`
214			`.doutb(ActualChar));`
215
216			`//Fun��o da recep��o de dados na Serial`
217			`always @(posedge clk4x)`
218			`begin`
219			`//Trabalhos`
220			`if(WorkLocked)`
221			`begin`
222			`case(ScreenWork)`
223			`2'b01: //BackSpace`
224			`begin`
225			`if(~CharErased)`
226			`begin`
227			`ContadorChar <= ContadorChar -1;`
228			`if(RefChar == 0)`
229			`begin`
230			`RefChar <= 79;`
231			`if(RefLine == 0)`
232			`RefLine <= 59;`
233			`else`
234			`RefLine <= RefLine - 1;`
235			`end`
236			`else`
237			`RefChar <= RefChar - 1;`
238			`DataWrite <= 0;`
239			`WE <= 1;`
240			`WorkLocked <= 1;`
241			`CharErased <= 1;`
242			`end`
243			`else`
244			`begin`
245			`DataWrite <='h00;`
246			`WE <= 0;`
247			`WorkLocked <= 0;`
248			`CharErased <= 0;`
249			`end`
250			`end`
251			`2'b10: //ClearScreen`
252			`begin`
253			`if(ContadorChar != 4799)`
254			`begin`
255			`DataWrite <= 'h00;`
256			`WE <= 1;`
257			`ContadorChar <= ContadorChar +1;`
258			`if(RefChar == 79)`
259			`begin`
260			`RefChar <= 0;`
261			`if(RefLine == 59)`
262			`RefLine <= 0;`
263			`else`
264			`RefLine <= RefLine + 1;`
265			`end`
266			`else`
267			`RefChar <= RefChar + 1;`
268			`end`
269			`else`
270			`begin`
271			`WE <= 0;`
272			`ContadorChar <= 4720;`
273			`WorkLocked <= 0;`
274			`RefChar <= 0;`
275			`RefLine <= 59;`
276			`LinhaShift <= 0;`
277			`end`
278			`end`
279			`2'b11: //Scroll Screen UP`
280			`begin`
281			`if(Scrolling == 0)`
282			`begin`
283			`Scrolling <= 1;`
284			`WE <= 0;`
285			`if(LinhaShift == 59)`
286			`ContadorChar <= 0;`
287			`else`
288			`ContadorChar <= (LinhaShift+1) * 80; // Ponto de grava��o`
289			`ReadScroll <= 0;`
290			`ColunaW <= 0;`
291			`if(LinhaShift == 59)`
292			`LinhaShift <= 0;`
293			`else`
294			`LinhaShift <= LinhaShift + 1;`
295			`end`
296			`else`
297			`begin`
298			`if(charwrote)`
299			`begin`
300			`//Ciclo de Posicionamento`
301			`charwrote <= 0;`
302			`WE <= 0;`
303			`if(ColunaW == 79)`
304			`begin`
305			`Scrolling <= 0;`
306			`WorkLocked <= 0;`
307			`RefLine <= 59;`
308			`RefChar <= 0;`
309			`ColunaW <= 0;`
310			`ContadorChar <= LinhaShift * 80; // Ponto de grava��o`
311			`end`
312			`else`
313			`begin`
314			`ColunaW <= ColunaW + 1;`
315			`ContadorChar <= ContadorChar + 1;`
316			`end`
317			`end`
318			`else`
319			`begin`
320			`//Ciclo de Grava��o`
321			`charwrote <= 1;`
322			`DataWrite <= 0;`
323			`WE <= 1;`
324			`end`
325			`end`
326			`/*`
327			`Aqui � a rotina antiga de shift do conte�do da tela`
328			`Ele reescrevia todas as linhas no endere�o anterior da atual`
329			`Muito lento, por isso refiz apenas com um registrador de deslocamento`
330			`if(Scrolling == 0)`
331			`begin`
332			`Scrolling <= 1;`
333			`LinhaW <= 1;`
334			`ColunaW <= 0;`
335			`ContadorChar <= 0;`
336			`charwrote <= 0;`
337			`end`
338			`else`
339			`begin`
340			`if(charwrote)`
341			`begin //Ciclo de sele��o`
342			`charwrote <= 0;`
343			`charread <= 0;`
344			`WE <= 0;`
345			`ReadScroll <= 1;`
346			`if(ColunaW == 79)`
347			`begin`
348			`ColunaW <= 0;`
349			`if(LinhaW == 60)`
350			`begin`
351			`Scrolling <= 0;`
352			`LinhaW <= 0;`
353			`WorkLocked <=0;`
354			`RefLine <= 59;`
355			`RefChar <= 0;`
356			`ContadorChar <= 4720; // 59 * 80 = 4720`
357			`end`
358			`else`
359			`begin`
360			`ContadorChar <= LinhaW * 80;`
361			`LinhaW <= LinhaW +1;`
362			`end`
363			`end`
364			`else`
365			`begin`
366			`ContadorChar <= ContadorChar +2;`
367			`ColunaW <= ColunaW + 1;`
368			`end`
369			`end`
370			`else`
371			`begin //Ciclo de Grava��o`
372			`if(charread)`
373			`begin`
374			`WE <= 1;`
375			`charwrote <= 1;`
376			`ReadScroll <= 0;`
377			`charread <= 0;`
378			`end`
379			`else`
380			`begin`
381			`DataWrite <= ActualChar;`
382			`charread <= 1;`
383			`ContadorChar <= ContadorChar -1;`
384			`end`
385
386
387			`end`
388			`end`
389			`*/`
390			`end`
391			`endcase`
392			`end`
393			`if(SerialReady & ~WriteLocked & ~WorkLocked)`
394			`begin`
395			`WriteLocked <= 1;`
396			`//Checagem de BYTE recebido`
397			`//Aqui h� um pequeno problema, o Windows envia \r\n e o Linux apenas \n.`
398			`//N�o deveria dar problema, o maximo que iria acontecer � pular duas linhas.`
399			`//Mas n�o funciona. Para o Windows, comente todas as linhas no Carriage Return`
400
401			`case (SerialByte)`
402			`'h0A: // Nova linha \n`
403			`begin`
404			`WorkLocked <= 1;`
405			`ScreenWork <= 2'b11;`
406			`end`
407			`'h08: // BackSpace`
408			`begin`
409			`WorkLocked <= 1;`
410			`ScreenWork <= 1; //BackSpace`
411			`end`
412			`'h09: //Horizontal Tab, acertado pra 5 espa�os.`
413			`begin`
414			`//N�o dar Tab se a linha n�o tiver menos do que 5 caracteres dispon�veis no caso, 75 ocupados.`
415			`if( ((RefLine * 80) - ContadorChar) < 74)`
416			`begin`
417			`ContadorChar <= ContadorChar + 5;`
418			`RefChar <= RefChar + 5;`
419			`end`
420
421			`end`
422			`'h0D: // Carriage Return, retornar para coluna 1, \r`
423			`begin`
424			`ContadorChar <= RefLine * 80;`
425			`RefChar <= 0;`
426			`end`
427
428			`'h0C: //Frame Feed - Apagar a tela e retornar ao caracter 0x0 da tela.`
429			`begin`
430			`WorkLocked <=1;`
431			`ScreenWork <= 2; //Erase Screen`
432			`ContadorChar <= 0;`
433			`end`
434			`default: //Caso n�o seja nenhum dos listados acima`
435			`begin`
436			`DataWrite <= SerialByte;`
437			`WE <= 1;`
438			`CharWrited <=1;`
439			`end`
440			`endcase`
441			`end`
442
443			`if(CharWrited)`
444			`begin`
445			`//Caso o caractere j� tenha sido gravado na RAM`
446			`//Aqui ele posicionar� o gravador um caracter`
447			`//adiante. Ele tamb�m ir� atualizar RefLine e RefChar`
448			`if( (ContadorChar == 4799) \| (RefChar == 79) )`
449			`begin`
450			`WorkLocked <= 1;`
451			`ScreenWork <= 2'b11;`
452			`if(RefChar == 79)`
453			`begin`
454			`RefChar <= 0;`
455			`if(RefLine == 59)`
456			`RefLine <= 0;`
457			`else`
458			`RefLine <= RefLine + 1;`
459			`end`
460			`end`
461			`else`
462			`begin`
463			`ContadorChar <= ContadorChar + 1;`
464			`RefChar <= RefChar + 1;`
465			`end`
466			`CharWrited <= 0;`
467			`WE <= 0;`
468			`end`
469
470			`if(SerialIdle)`
471			`begin`
472			`WriteLocked <= 0;`
473			`if(~WorkLocked)`
474			`WE <= 0;`
475			`end`
476			`end`
477
478			`//Ciclo de Imagem`
479			`always @(posedge clk4x)`
480			`begin`
481			`//Como a RAM de Buffer s� escreve ou l�, mas nunca os dois ao mesmo tempo,`
482			`//Definimos aqui, que caso esteja fazendo algum trabalho, na memoria`
483			`//O ReadEnable ser� 0, caso n�o, ser� o valor do data_enable`
484			`if(WorkLocked != 1)`
485			`ReadEnable <= data_enable;`
486			`else`
487			`ReadEnable <= 0;`
488
489			`//Detectamos aqui se estamos dentro da �rea do console`
490			`//Se n�o estamos trabalhando e apagando a tela`
491			`if(~OutOfBondary & ~((ScreenWork == 2'b11) & (WorkLocked == 1)) )`
492			`begin`
493			`if((ContadorX[2:0] == 0) & ~CharLock)`
494			`begin`
495			`CharLock <= 1;`
496			`if(MaxChars)`
497			`ColunaChar <= 0;`
498			`else`
499			`ColunaChar <= ColunaChar +1;`
500			`end`
501			`if(ContadorX[2:0] != 0)`
502			`CharLock <= 0;`
503
504			`if(ContadorY[2:0] == 0 & ~LineLock)`
505			`begin`
506			`LineLock <= 1;`
507			`if(MaxLines)`
508			`begin`
509			`LinhaChar <=0;`
510			`LinhaRead <= LinhaShift;`
511			`end`
512			`else`
513			`begin`
514			`LinhaChar <= LinhaChar +1;`
515			`if((LinhaShift+LinhaChar+1) >= 60)`
516			`LinhaRead <= (LinhaShift+LinhaChar+1)-59;`
517			`else`
518			`LinhaRead <= LinhaShift+LinhaChar+1;`
519			`end`
520			`end`
521
522			`if(ContadorY[2:0] != 0)`
523			`LineLock <= 0;`
524
525			`if(ContadorX[2:0] == 2)`
526			`begin`
527			`PixelChar <= 7;`
528			`Point <= CharByte[PixelChar];`
529			`end`
530			`else`
531			`begin`
532			`PixelChar <= PixelChar -1;`
533			`Point <= CharByte[PixelChar];`
534			`end`
535			`if(Point)`
536			`begin`
537			`DataBlue <= 6'b111111;`
538			`DataGreen <= 6'b111111;`
539			`DataRed <= 6'b111111;`
540			`end`
541			`else`
542			`begin`
543			`DataRed <= 6'b000000;`
544			`DataBlue <= 6'b000000;`
545			`DataGreen <= 6'b000000;`
546			`end`
547			`end`
548			`else`
549			`begin`
550			`if(~((ScreenWork == 2'b11) & (WorkLocked == 1)))`
551			`begin`
552			`if((ContadorX >= 835) \| (ContadorX <= 190))`
553			`begin`
554			`CharLock <= 1;`
555			`ColunaChar <= 0;`
556			`end`
557			`if((ContadorY < 144) \| (ContadorY >= 624))`
558			`begin`
559			`LinhaChar <= 0;`
560			`if(LinhaShift == 59)`
561			`LinhaRead <= 0;`
562			`else`
563			`LinhaRead <= LinhaShift+1;`
564			`LineLock <= 1;`
565			`end`
566			`DataBlue <= 0;`
567			`DataGreen <= 0;`
568			`DataRed <= 0;`
569			`end`
570			`else`
571			`begin`
572			`LinhaChar <= 0;`
573			`LinhaRead <= 0;`
574			`ColunaChar <= 0;`
575			`end`
576			`end`
577
578			`if(((ContadorX < 128) \| (ContadorX > (ScreenX-128))) & (ContadorY < 128) & ~( ( ( (LogoByte[17:12] <= 4) \| (LogoByte[5:0] <= 4) ) ) & (LogoByte[11:6] == 63)))`
579			`begin`
580			`DataRed <= LogoByte[17:12];`
581			`DataGreen <= LogoByte[11:6];`
582			`DataBlue <= LogoByte[5:0];`
583			`end`
584			`else`
585			`begin`
586
587			`if((ContadorY < 140) \| (ContadorX > 835) \| (ContadorX < 190) \| (ContadorY > 623) )`
588			`begin`
589			`DataRed <= ( ( (ContadorY[5:0]+Parallax) ^ (ContadorX[5:0]+Parallax) ) * 2 );`
590			`DataBlue <= ( ( (ContadorY[5:0]+Parallax) ^ (ContadorX[5:0]+Parallax) ) * 3 );`
591			`DataGreen <= ( ( (ContadorY[5:0]+Parallax) ^ (ContadorX[5:0]+Parallax) ) * 4 );`
592			`end`
593			`if( ( (ContadorY == 140) & (ContadorX >= 191) & (ContadorX <= 623) ) \| ( (ContadorY == 623) & (ContadorX >= 191) & (ContadorX <= 623) ) \| ( (ContadorX == 835) & (ContadorY >= 140) & (ContadorY <= 623) ) \| ( (ContadorX == 191) & (ContadorY >= 140) & (ContadorY <= 623) ) )`
594			`begin`
595			`DataBlue <= 6'b111111;`
596			`DataGreen <= 6'b111111;`
597			`DataRed <= 6'b111111;`
598			`end`
599			`if( (ContadorY >= 141) & (ContadorY <= 143) & (ContadorX >= 191) & (ContadorX <= 623) )`
600			`begin`
601			`DataBlue <= 6'b000000;`
602			`DataGreen <= 6'b000000;`
603			`DataRed <= 6'b000000;`
604			`end`
605			`end`
606
607			`//Sync Generator`
608
609			`ContadorX <= ContadorX + 1;`
610
611			`if((ContadorX == 0) & (ContadorY < ScreenY))`
612			`data_enable <= 1;`
613
614			`if(ContadorX == ScreenX)`
615			`begin`
616			`data_enable <= 0;`
617			`DataBlue <= 0;`
618			`DataRed <= 0;`
619			`DataGreen <= 0;`
620			`HSync <= 0;`
621			`end`
622
623			`if(ContadorX == (ScreenX+280))`
624			`HSync <= 1;`
625
626			`if(ContadorX == (ScreenX+300))`
627			`begin`
628			`if(ContadorY == ScreenY)`
629			`begin`
630			`VSync <= 0;`
631			`data_enable <= 0;`
632			`end`
633			`if(ContadorY == (ScreenY+35))`
634			`begin`
635			`VSync <= 1;`
636			`Parallax <= Parallax - 1;`
637			`ContadorY <= 0;`
638			`ContadorX <= 0;`
639			`end`
640			`else`
641			`ContadorY <= ContadorY +1;`
642			`end`
643
644			`if(ContadorX == (ScreenX+320))`
645			`ContadorX <= 0;`
646			`end`
647
648
649
650			`//Designa��es de pinos e leds.`
651			`assign DE = data_enable;`
652			`assign led1 = mod_led;`
653			`assign led2 = SerialReady;`
654			`assign led3 = ~PS2clk;`
655			`assign led4 = WorkLocked;`
656
657
658			`//Aqui fiz um pequeno jogo. O XAPP486 da Xilinx envia os dados assim:`
659			`// 0, 4, 8, 12, 16, 20, 24 - Canal 0`
660			`// 1, 5, 9, 13, 17, 21, 25 - Canal 1`
661			`// 2, 6, 10, 14, 18, 22, 26 - Canal 2`
662			`// 3, 7, 11, 15, 19, 23, 27 - Canal 3`
663			`//`
664			`//Por�m, o LCD precisa deles assim:`
665			`// 6, 5, 4, 3, 2, 1, 0 - Canal 0`
666			`// 13, 12, 12, 10, 9, 8, 7 - Canal 1`
667			`// 20, 19, 18, 17, 16, 15, 14 - Canal 2`
668			`// X, X, X, X, X, X, X - Canal 3`
669			`// Nota: X <= Irrelevante`
670			`//Ent�o fiz aqui uma associa��o da maneira que eu precisava.`
671
672			`assign serializerdata[0] = lcddata[6]; //`
673			`assign serializerdata[4] = lcddata[5]; //`
674			`assign serializerdata[8] = lcddata[4]; //`
675			`assign serializerdata[12] = lcddata[3]; // Canal 0`
676			`assign serializerdata[16] = lcddata[2]; //`
677			`assign serializerdata[20] = lcddata[1]; //`
678			`assign serializerdata[24] = lcddata[0]; //`
679
680			`assign serializerdata[1] = lcddata[13]; //`
681			`assign serializerdata[5] = lcddata[12]; //`
682			`assign serializerdata[9] = lcddata[11]; //`
683			`assign serializerdata[13] = lcddata[10]; // Canal 1`
684			`assign serializerdata[17] = lcddata[9]; //`
685			`assign serializerdata[21] = lcddata[8]; //`
686			`assign serializerdata[25] = lcddata[7]; //`
687
688			`assign serializerdata[2] = lcddata[20]; //`
689			`assign serializerdata[6] = lcddata[19]; //`
690			`assign serializerdata[10] = lcddata[18]; //`
691			`assign serializerdata[14] = lcddata[17]; // Canal 3`
692			`assign serializerdata[18] = lcddata[16]; //`
693			`assign serializerdata[22] = lcddata[15]; //`
694			`assign serializerdata[26] = lcddata[14]; //`
695
696			`assign serializerdata[3] = 1'b0; //`
697			`assign serializerdata[7] = 1'b0; //`
698			`assign serializerdata[11] = 1'b0; //`
699			`assign serializerdata[15] = 1'b0; // Canal 4 - Por�m irrelevante`
700			`assign serializerdata[19] = 1'b0; //`
701			`assign serializerdata[23] = 1'b0; //`
702			`assign serializerdata[27] = 1'b0; //`
703
704			`// A ordem destes bits no LCD �: Data Enable, Sincronia Vertical, Sincronia Horizontal`
705			`assign lcddata [20:18] = { DE , VSync, HSync};`
706
707			`//A ordem de cores no LCD �: AZUL, VERDE, VERMELHO`
708			`assign lcddata [17:0] = {DataBlue, DataGreen, DataRed};`
709
710			`endmodule`