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

Subversion Repositories wbuart32

[/] [wbuart32/] [trunk/] [rtl/] [txuart.v] - Blame information for rev 2

Go to most recent revision | Details | Compare with Previous | View Log


////////////////////////////////////////////////////////////////////////////////
//
// Filename:    txuart.v
//
// Project:     wbuart32, a full featured UART with simulator
//
// Purpose:     Transmit outputs over a single UART line.
//
//      To interface with this module, connect it to your system clock,
//      pass it the 32 bit setup register (defined below) and the byte
//      of data you wish to transmit.  Strobe the i_wr line high for one
//      clock cycle, and your data will be off.  Wait until the 'o_busy'
//      line is low before strobing the i_wr line again--this implementation
//      has NO BUFFER, so strobing i_wr while the core is busy will just
//      cause your data to be lost.  The output will be placed on the o_txuart
//      output line.  If you wish to set/send a break condition, assert the
//      i_break line otherwise leave it low.
//
//      There is a synchronous reset line, logic high.
//
//      Now for the setup register.  The register is 32 bits, so that this
//      UART may be set up over a 32-bit bus.
//
//      i_setup[29:28]  Indicates the number of data bits per word.  This will
//      either be 2'b00 for an 8-bit word, 2'b01 for a 7-bit word, 2'b10
//      for a six bit word, or 2'b11 for a five bit word.
//
//      i_setup[27]     Indicates whether or not to use one or two stop bits.
//              Set this to one to expect two stop bits, zero for one.
//
//      i_setup[26]     Indicates whether or not a parity bit exists.  Set this
//              to 1'b1 to include parity.
//
//      i_setup[25]     Indicates whether or not the parity bit is fixed.  Set
//              to 1'b1 to include a fixed bit of parity, 1'b0 to allow the
//              parity to be set based upon data.  (Both assume the parity
//              enable value is set.)
//
//      i_setup[24]     This bit is ignored if parity is not used.  Otherwise,
//              in the case of a fixed parity bit, this bit indicates whether
//              mark (1'b1) or space (1'b0) parity is used.  Likewise if the
//              parity is not fixed, a 1'b1 selects even parity, and 1'b0
//              selects odd.
//
//      i_setup[23:0]   Indicates the speed of the UART in terms of clocks.
//              So, for example, if you have a 200 MHz clock and wish to
//              run your UART at 9600 baud, you would take 200 MHz and divide
//              by 9600 to set this value to 24'd20834.  Likewise if you wished
//              to run this serial port at 115200 baud from a 200 MHz clock,
//              you would set the value to 24'd1736
//
//      Thus, to set the UART for the common setting of an 8-bit word, 
//      one stop bit, no parity, and 115200 baud over a 200 MHz clock, you
//      would want to set the setup value to:
//
//      32'h0006c8              // For 115,200 baud, 8 bit, no parity
//      32'h005161              // For 9600 baud, 8 bit, no parity
//      
//
// Creator:     Dan Gisselquist, Ph.D.
//              Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of  the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program.  (It's in the $(ROOT)/doc directory, run make with no
// target there if the PDF file isn't present.)  If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License:     GPL, v3, as defined and found on www.gnu.org,
//              http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
//
//
`define TXU_BIT_ZERO    4'h0
`define TXU_BIT_ONE     4'h1
`define TXU_BIT_TWO     4'h2
`define TXU_BIT_THREE   4'h3
`define TXU_BIT_FOUR    4'h4
`define TXU_BIT_FIVE    4'h5
`define TXU_BIT_SIX     4'h6
`define TXU_BIT_SEVEN   4'h7
`define TXU_PARITY      4'h8    // Constant 1
`define TXU_STOP        4'h9    // Constant 1
`define TXU_SECOND_STOP 4'ha
// 4'hb // Unused
// 4'hc // Unused
// `define      TXU_START       4'hd    // An unused state
`define TXU_BREAK       4'he
`define TXU_IDLE        4'hf
//
//
module txuart(i_clk, i_reset, i_setup, i_break, i_wr, i_data, o_uart, o_busy);
        input                   i_clk, i_reset;
        input           [29:0]   i_setup;
        input                   i_break;
        input                   i_wr;
        input           [7:0]    i_data;
        output  reg             o_uart;
        output  wire            o_busy;
 
        wire    [27:0]   clocks_per_baud, break_condition;
        wire    [1:0]    data_bits;
        wire            use_parity, parity_even, dblstop, fixd_parity;
        reg     [29:0]   r_setup;
        assign  clocks_per_baud = { 4'h0, r_setup[23:0] };
        assign  break_condition = { r_setup[23:0], 4'h0 };
        assign  data_bits   = r_setup[29:28];
        assign  dblstop     = r_setup[27];
        assign  use_parity  = r_setup[26];
        assign  fixd_parity = r_setup[25];
        assign  parity_even = r_setup[24];
 
        reg     [27:0]   baud_counter;
        reg     [3:0]    state;
        reg     [7:0]    lcl_data;
        reg             calc_parity, r_busy, zero_baud_counter;
 
        initial o_uart = 1'b1;
        initial r_busy = 1'b1;
        initial state  = `TXU_IDLE;
        initial lcl_data= 8'h0;
        initial calc_parity = 1'b0;
        // initial      baud_counter = clocks_per_baud;//ILLEGAL--not constant
        always @(posedge i_clk)
        begin
                if (i_reset)
                begin
                        o_uart <= 1'b1;
                        r_busy <= 1'b1;
                        state <= `TXU_IDLE;
                        lcl_data <= 8'h0;
                        calc_parity <= 1'b0;
                end else if (i_break)
                begin
                        o_uart <= 1'b0;
                        state <= `TXU_BREAK;
                        calc_parity <= 1'b0;
                        r_busy <= 1'b1;
                end else if (~zero_baud_counter)
                begin // r_busy needs to be set coming into here
                        r_busy <= 1'b1;
                end else if (state == `TXU_BREAK)
                begin
                        state <= `TXU_IDLE;
                        r_busy <= 1'b1;
                        o_uart <= 1'b1;
                        calc_parity <= 1'b0;
                end else if (state == `TXU_IDLE)        // STATE_IDLE
                begin
                        // baud_counter <= 0;
                        r_setup <= i_setup;
                        calc_parity <= 1'b0;
                        if ((i_wr)&&(~r_busy))
                        begin   // Immediately start us off with a start bit
                                o_uart <= 1'b0;
                                r_busy <= 1'b1;
                                case(data_bits)
                                2'b00: state <= `TXU_BIT_ZERO;
                                2'b01: state <= `TXU_BIT_ONE;
                                2'b10: state <= `TXU_BIT_TWO;
                                2'b11: state <= `TXU_BIT_THREE;
                                endcase
                                lcl_data <= i_data;
                                // baud_counter <= clocks_per_baud-28'h01;
                        end else begin // Stay in idle
                                o_uart <= 1'b1;
                                r_busy <= 0;
                                // lcl_data is irrelevant
                                // state <= state;
                        end
                end else begin
                        // One clock tick in each of these states ...
                        // baud_counter <= clocks_per_baud - 28'h01;
                        r_busy <= 1'b1;
                        if (state[3] == 0) // First 8 bits
                        begin
                                o_uart <= lcl_data[0];
                                calc_parity <= calc_parity ^ lcl_data[0];
                                if (state == `TXU_BIT_SEVEN)
                                        state <= (use_parity)?`TXU_PARITY:`TXU_STOP;
                                else
                                        state <= state + 1;
                                lcl_data <= { 1'b0, lcl_data[7:1] };
                        end else if (state == `TXU_PARITY)
                        begin
                                state <= `TXU_STOP;
                                if (fixd_parity)
                                        o_uart <= parity_even;
                                else
                                        o_uart <= calc_parity^((parity_even)? 1'b1:1'b0);
                        end else if (state == `TXU_STOP)
                        begin // two stop bit(s)
                                o_uart <= 1'b1;
                                if (dblstop)
                                        state <= `TXU_SECOND_STOP;
                                else
                                        state <= `TXU_IDLE;
                                calc_parity <= 1'b0;
                        end else // `TXU_SECOND_STOP and default:
                        begin
                                state <= `TXU_IDLE; // Go back to idle
                                o_uart <= 1'b1;
                                // Still r_busy, since we need to wait
                                // for the baud clock to finish counting
                                // out this last bit.
                        end
                end
        end
 
        assign  o_busy = (r_busy);
 
 
        initial zero_baud_counter = 1'b0;
        initial baud_counter = 28'h05;
        always @(posedge i_clk)
        begin
                zero_baud_counter <= (baud_counter == 28'h01);
                if ((i_reset)||(i_break))
                        // Give ourselves 16 bauds before being ready
                        baud_counter <= break_condition;
                else if (~zero_baud_counter)
                        baud_counter <= baud_counter - 28'h01;
                else if (state == `TXU_BREAK)
                        // Give us two stop bits before becoming available
                        baud_counter <= clocks_per_baud<<2;
                else if (state == `TXU_IDLE)
                begin
                        if((i_wr)&&(~r_busy))
                                baud_counter <= clocks_per_baud - 28'h01;
                        else
                                zero_baud_counter <= 1'b1;
                end else
                        baud_counter <= clocks_per_baud - 28'h01;
        end
endmodule
 

Browse

Tools

Subversion Repositories wbuart32

[/] [wbuart32/] [trunk/] [rtl/] [txuart.v] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	dgisselq	`////////////////////////////////////////////////////////////////////////////////`
2			`//`
3			`// Filename: txuart.v`
4			`//`
5			`// Project: wbuart32, a full featured UART with simulator`
6			`//`
7			`// Purpose: Transmit outputs over a single UART line.`
8			`//`
9			`// To interface with this module, connect it to your system clock,`
10			`// pass it the 32 bit setup register (defined below) and the byte`
11			`// of data you wish to transmit. Strobe the i_wr line high for one`
12			`// clock cycle, and your data will be off. Wait until the 'o_busy'`
13			`// line is low before strobing the i_wr line again--this implementation`
14			`// has NO BUFFER, so strobing i_wr while the core is busy will just`
15			`// cause your data to be lost. The output will be placed on the o_txuart`
16			`// output line. If you wish to set/send a break condition, assert the`
17			`// i_break line otherwise leave it low.`
18			`//`
19			`// There is a synchronous reset line, logic high.`
20			`//`
21			`// Now for the setup register. The register is 32 bits, so that this`
22			`// UART may be set up over a 32-bit bus.`
23			`//`
24			`// i_setup[29:28] Indicates the number of data bits per word. This will`
25			`// either be 2'b00 for an 8-bit word, 2'b01 for a 7-bit word, 2'b10`
26			`// for a six bit word, or 2'b11 for a five bit word.`
27			`//`
28			`// i_setup[27] Indicates whether or not to use one or two stop bits.`
29			`// Set this to one to expect two stop bits, zero for one.`
30			`//`
31			`// i_setup[26] Indicates whether or not a parity bit exists. Set this`
32			`// to 1'b1 to include parity.`
33			`//`
34			`// i_setup[25] Indicates whether or not the parity bit is fixed. Set`
35			`// to 1'b1 to include a fixed bit of parity, 1'b0 to allow the`
36			`// parity to be set based upon data. (Both assume the parity`
37			`// enable value is set.)`
38			`//`
39			`// i_setup[24] This bit is ignored if parity is not used. Otherwise,`
40			`// in the case of a fixed parity bit, this bit indicates whether`
41			`// mark (1'b1) or space (1'b0) parity is used. Likewise if the`
42			`// parity is not fixed, a 1'b1 selects even parity, and 1'b0`
43			`// selects odd.`
44			`//`
45			`// i_setup[23:0] Indicates the speed of the UART in terms of clocks.`
46			`// So, for example, if you have a 200 MHz clock and wish to`
47			`// run your UART at 9600 baud, you would take 200 MHz and divide`
48			`// by 9600 to set this value to 24'd20834. Likewise if you wished`
49			`// to run this serial port at 115200 baud from a 200 MHz clock,`
50			`// you would set the value to 24'd1736`
51			`//`
52			`// Thus, to set the UART for the common setting of an 8-bit word,`
53			`// one stop bit, no parity, and 115200 baud over a 200 MHz clock, you`
54			`// would want to set the setup value to:`
55			`//`
56			`// 32'h0006c8 // For 115,200 baud, 8 bit, no parity`
57			`// 32'h005161 // For 9600 baud, 8 bit, no parity`
58			`//`
59			`//`
60			`// Creator: Dan Gisselquist, Ph.D.`
61			`// Gisselquist Technology, LLC`
62			`//`
63			`////////////////////////////////////////////////////////////////////////////////`
64			`//`
65			`// Copyright (C) 2015-2016, Gisselquist Technology, LLC`
66			`//`
67			`// This program is free software (firmware): you can redistribute it and/or`
68			`// modify it under the terms of the GNU General Public License as published`
69			`// by the Free Software Foundation, either version 3 of the License, or (at`
70			`// your option) any later version.`
71			`//`
72			`// This program is distributed in the hope that it will be useful, but WITHOUT`
73			`// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or`
74			`// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
75			`// for more details.`
76			`//`
77			`// You should have received a copy of the GNU General Public License along`
78			`// with this program. (It's in the $(ROOT)/doc directory, run make with no`
79			`// target there if the PDF file isn't present.) If not, see`
80			`// <http://www.gnu.org/licenses/> for a copy.`
81			`//`
82			`// License: GPL, v3, as defined and found on www.gnu.org,`
83			`// http://www.gnu.org/licenses/gpl.html`
84			`//`
85			`//`
86			`////////////////////////////////////////////////////////////////////////////////`
87			`//`
88			`//`
89			`define TXU_BIT_ZERO 4'h0
90			`define TXU_BIT_ONE 4'h1
91			`define TXU_BIT_TWO 4'h2
92			`define TXU_BIT_THREE 4'h3
93			`define TXU_BIT_FOUR 4'h4
94			`define TXU_BIT_FIVE 4'h5
95			`define TXU_BIT_SIX 4'h6
96			`define TXU_BIT_SEVEN 4'h7
97			`define TXU_PARITY 4'h8 // Constant 1
98			`define TXU_STOP 4'h9 // Constant 1
99			`define TXU_SECOND_STOP 4'ha
100			`// 4'hb // Unused`
101			`// 4'hc // Unused`
102			// `define TXU_START 4'hd // An unused state
103			`define TXU_BREAK 4'he
104			`define TXU_IDLE 4'hf
105			`//`
106			`//`
107			`module txuart(i_clk, i_reset, i_setup, i_break, i_wr, i_data, o_uart, o_busy);`
108			`input i_clk, i_reset;`
109			`input [29:0] i_setup;`
110			`input i_break;`
111			`input i_wr;`
112			`input [7:0] i_data;`
113			`output reg o_uart;`
114			`output wire o_busy;`
115
116			`wire [27:0] clocks_per_baud, break_condition;`
117			`wire [1:0] data_bits;`
118			`wire use_parity, parity_even, dblstop, fixd_parity;`
119			`reg [29:0] r_setup;`
120			`assign clocks_per_baud = { 4'h0, r_setup[23:0] };`
121			`assign break_condition = { r_setup[23:0], 4'h0 };`
122			`assign data_bits = r_setup[29:28];`
123			`assign dblstop = r_setup[27];`
124			`assign use_parity = r_setup[26];`
125			`assign fixd_parity = r_setup[25];`
126			`assign parity_even = r_setup[24];`
127
128			`reg [27:0] baud_counter;`
129			`reg [3:0] state;`
130			`reg [7:0] lcl_data;`
131			`reg calc_parity, r_busy, zero_baud_counter;`
132
133			`initial o_uart = 1'b1;`
134			`initial r_busy = 1'b1;`
135			initial state = `TXU_IDLE;
136			`initial lcl_data= 8'h0;`
137			`initial calc_parity = 1'b0;`
138			`// initial baud_counter = clocks_per_baud;//ILLEGAL--not constant`
139			`always @(posedge i_clk)`
140			`begin`
141			`if (i_reset)`
142			`begin`
143			`o_uart <= 1'b1;`
144			`r_busy <= 1'b1;`
145			state <= `TXU_IDLE;
146			`lcl_data <= 8'h0;`
147			`calc_parity <= 1'b0;`
148			`end else if (i_break)`
149			`begin`
150			`o_uart <= 1'b0;`
151			state <= `TXU_BREAK;
152			`calc_parity <= 1'b0;`
153			`r_busy <= 1'b1;`
154			`end else if (~zero_baud_counter)`
155			`begin // r_busy needs to be set coming into here`
156			`r_busy <= 1'b1;`
157			end else if (state == `TXU_BREAK)
158			`begin`
159			state <= `TXU_IDLE;
160			`r_busy <= 1'b1;`
161			`o_uart <= 1'b1;`
162			`calc_parity <= 1'b0;`
163			end else if (state == `TXU_IDLE) // STATE_IDLE
164			`begin`
165			`// baud_counter <= 0;`
166			`r_setup <= i_setup;`
167			`calc_parity <= 1'b0;`
168			`if ((i_wr)&&(~r_busy))`
169			`begin // Immediately start us off with a start bit`
170			`o_uart <= 1'b0;`
171			`r_busy <= 1'b1;`
172			`case(data_bits)`
173			2'b00: state <= `TXU_BIT_ZERO;
174			2'b01: state <= `TXU_BIT_ONE;
175			2'b10: state <= `TXU_BIT_TWO;
176			2'b11: state <= `TXU_BIT_THREE;
177			`endcase`
178			`lcl_data <= i_data;`
179			`// baud_counter <= clocks_per_baud-28'h01;`
180			`end else begin // Stay in idle`
181			`o_uart <= 1'b1;`
182			`r_busy <= 0;`
183			`// lcl_data is irrelevant`
184			`// state <= state;`
185			`end`
186			`end else begin`
187			`// One clock tick in each of these states ...`
188			`// baud_counter <= clocks_per_baud - 28'h01;`
189			`r_busy <= 1'b1;`
190			`if (state[3] == 0) // First 8 bits`
191			`begin`
192			`o_uart <= lcl_data[0];`
193			`calc_parity <= calc_parity ^ lcl_data[0];`
194			if (state == `TXU_BIT_SEVEN)
195			state <= (use_parity)?`TXU_PARITY:`TXU_STOP;
196			`else`
197			`state <= state + 1;`
198			`lcl_data <= { 1'b0, lcl_data[7:1] };`
199			end else if (state == `TXU_PARITY)
200			`begin`
201			state <= `TXU_STOP;
202			`if (fixd_parity)`
203			`o_uart <= parity_even;`
204			`else`
205			`o_uart <= calc_parity^((parity_even)? 1'b1:1'b0);`
206			end else if (state == `TXU_STOP)
207			`begin // two stop bit(s)`
208			`o_uart <= 1'b1;`
209			`if (dblstop)`
210			state <= `TXU_SECOND_STOP;
211			`else`
212			state <= `TXU_IDLE;
213			`calc_parity <= 1'b0;`
214			end else // `TXU_SECOND_STOP and default:
215			`begin`
216			state <= `TXU_IDLE; // Go back to idle
217			`o_uart <= 1'b1;`
218			`// Still r_busy, since we need to wait`
219			`// for the baud clock to finish counting`
220			`// out this last bit.`
221			`end`
222			`end`
223			`end`
224
225			`assign o_busy = (r_busy);`
226
227
228			`initial zero_baud_counter = 1'b0;`
229			`initial baud_counter = 28'h05;`
230			`always @(posedge i_clk)`
231			`begin`
232			`zero_baud_counter <= (baud_counter == 28'h01);`
233			`if ((i_reset)\|\|(i_break))`
234			`// Give ourselves 16 bauds before being ready`
235			`baud_counter <= break_condition;`
236			`else if (~zero_baud_counter)`
237			`baud_counter <= baud_counter - 28'h01;`
238			else if (state == `TXU_BREAK)
239			`// Give us two stop bits before becoming available`
240			`baud_counter <= clocks_per_baud<<2;`
241			else if (state == `TXU_IDLE)
242			`begin`
243			`if((i_wr)&&(~r_busy))`
244			`baud_counter <= clocks_per_baud - 28'h01;`
245			`else`
246			`zero_baud_counter <= 1'b1;`
247			`end else`
248			`baud_counter <= clocks_per_baud - 28'h01;`
249			`end`
250			`endmodule`
251