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

Subversion Repositories wb_lcd

[/] [wb_lcd/] [trunk/] [myhdl/] [wb_lcd_workspace_ramless/] [workspace/] [.metadata/] [.plugins/] [org.eclipse.core.resources/] [.history/] [ea/] [104d25ec632a001e17c6eddde04c8549] - Blame information for rev 2

Details | Compare with Previous | View Log


from myhdl import *
 
t_TxState = enum('tx_high_setup', 'tx_high_hold', 'tx_oneus', 'tx_low_setup', 'tx_low_hold', 'tx_fortyus', 'tx_done');
t_State = enum('display_init', 'init_fifteenms', 'init_one', 'init_two', 'init_three', 'init_four', 'init_five', 'init_six', 'init_seven', 'init_eight', 'display_function_set', 'display_entry_set', 'display_set_display', 'display_clr_display', 'display_pause_setup', 'display_pause', 'display_done', 'display_set_addr', 'display_char_write')
 
def delayCounter(clk, reset, count, load, done, width = 13):
 
    counter = Signal(intbv(0)[width:0])
 
    @always_comb
    def done_logic():
        done.next = (counter == 0)
 
    @always(clk.posedge)
    def countdown_logic():
        if load:
            counter.next = count
        else: #elif not done:
            counter.next = counter - 1
 
    return instances()
 
 
 
def lcd(clk, reset, dat, addr, we, busy, SF_D, LCD_E, LCD_RS, LCD_RW):
 
 
    state = Signal(t_State.display_init)
    tx_state = Signal(t_TxState.tx_done)
    tx_byte = Signal(intbv(0)[8:0])
    tx_init = Signal(bool())
    tx_done = Signal(bool())
    LCD_E0 = Signal(bool())
    SF_D0 = Signal(intbv(0)[4:0])
    LCD_E1 = Signal(bool())
    SF_D1 = Signal(intbv(0)[4:0])
    wr_dat = Signal(intbv(0)[7:0])
    wr_addr = Signal(intbv(0)[7:0])
 
    @always_comb
    def busy_and_rw_handlers():
        busy.next = (state != t_State.display_done)
        LCD_RW.next = 0
 
    #Delay counter
    main_delay_load = Signal(bool())
    main_delay_value = Signal(intbv(0)[20:0])
 
    tx_delay_load = Signal(bool())
    main_delay_load = Signal(bool())
    delay_load = Signal(bool())
 
    tx_delay_value = Signal(intbv(0)[20:0])
    main_delay_value = Signal(intbv(0)[20:0])
    delay_value = Signal(intbv(0)[20:0])
 
    delay_done = Signal(bool())
    output_selector  = Signal(bool())
    counter = delayCounter(clk, reset, delay_value, delay_load, delay_done, width = 21)
 
    @always_comb
    def conunter_sharing_load():
        delay_load.next = tx_delay_load or main_delay_load
 
    @always_comb
    def conunter_sharing_value():
        if tx_delay_load:
            delay_value.next = tx_delay_value
        else:
            delay_value.next = main_delay_value
 
 
    # SF_D and LCD_E management for sharing between Init and TX phases.
    @always_comb
    def output_tx_or_init_select(): # 0 tx; 1 init
        output_selector.next = (state == t_State.display_init) | (state == t_State.init_fifteenms) | (state == t_State.init_one) | (state == t_State.init_two) | (state == t_State.init_three) | (state == t_State.init_four) | (state == t_State.init_five) | (state == t_State.init_six) | (state == t_State.init_seven) | (state == t_State.init_eight)
 
    @always_comb
    def output_tx_or_init_mux():
        if output_selector: # Init
            SF_D.next = SF_D1
            LCD_E.next = LCD_E1
        else: # TX
            SF_D.next = SF_D0
            LCD_E.next = LCD_E0
 
 
    @always_comb
    def init_transmissions():
        tx_init.next = (~tx_done) & ((state == t_State.display_function_set) | (state == t_State.display_entry_set) | (state == t_State.display_set_display) | (state == t_State.display_clr_display) | (state == t_State.display_set_addr) | (state == t_State.display_char_write))
        LCD_RS.next = ~(bool(state == t_State.display_function_set) | (state == t_State.display_entry_set) | (state == t_State.display_set_display) | (state == t_State.display_clr_display) | (state == t_State.display_set_addr))
 
    @always(clk.posedge, reset.posedge)
    def DisplayFSM():
        if reset == 1:
            state.next = t_State.display_init
            main_delay_load.next = 0
            main_delay_value.next = 0
            SF_D1.next = 0
            LCD_E1.next = 0
            tx_byte.next = 0
        else:
            main_delay_load.next = 0;
            main_delay_value.next = 0;
            if state == t_State.display_init:
                tx_byte.next = 0 #00000000
 
                state.next = t_State.init_fifteenms
                main_delay_load.next = 1
                main_delay_value.next = 750000
 
            elif state == t_State.init_fifteenms:
                main_delay_load.next = 0
 
                if delay_done:
                    state.next = t_State.init_one;
                    main_delay_load.next = 1
                    main_delay_value.next = 11
 
            elif state == t_State.init_one:
                main_delay_load.next = 0
                SF_D1.next = 3
                LCD_E1.next = 1
 
                if delay_done:
                    state.next = t_State.init_two;
                    main_delay_load.next = 1
                    main_delay_value.next = 205000
 
            elif state == t_State.init_two:
                main_delay_load.next = 0
                LCD_E1.next = 0
 
                if delay_done:
                    state.next = t_State.init_three;
                    main_delay_load.next = 1
                    main_delay_value.next = 11
 
            elif state == t_State.init_three:
                main_delay_load.next = 0
                SF_D1.next = 3
                LCD_E1.next = 1
 
                if delay_done:
                    state.next = t_State.init_four;
                    main_delay_load.next = 1
                    main_delay_value.next = 5000
 
            elif state == t_State.init_four:
                main_delay_load.next = 0
                LCD_E1.next = 0
 
                if delay_done:
                    state.next = t_State.init_five;
                    main_delay_load.next = 1
                    main_delay_value.next = 11
 
 
            elif state == t_State.init_five:
                main_delay_load.next = 0
                SF_D1.next = 3
                LCD_E1.next = 1
 
                if delay_done:
                    state.next = t_State.init_six;
                    main_delay_load.next = 1
                    main_delay_value.next = 2000
 
            elif state == t_State.init_six:
                main_delay_load.next = 0
                LCD_E1.next = 0
 
                if delay_done:
                    state.next = t_State.init_seven;
                    main_delay_load.next = 1
                    main_delay_value.next = 11
 
            elif state == t_State.init_seven:
                main_delay_load.next = 0
                SF_D1.next = 2
                LCD_E1.next = 1
 
                if delay_done:
                    state.next = t_State.init_eight;
                    main_delay_load.next = 1
                    main_delay_value.next = 2000
 
            elif state == t_State.init_eight:
                main_delay_load.next = 0
                LCD_E1.next = 0
 
                if delay_done:
                    state.next = t_State.display_function_set;
 
            elif state == t_State.display_function_set:
                tx_byte.next = 40 #00101000
                if tx_done:
                    state.next = t_State.display_entry_set
 
            elif state == t_State.display_entry_set:
                tx_byte.next = 6 #00000110
                if tx_done:
                    state.next = t_State.display_set_display
 
            elif state == t_State.display_set_display:
                tx_byte.next = 12 #00001100
                if tx_done:
                    state.next = t_State.display_clr_display
 
            elif state == t_State.display_clr_display:
                tx_byte.next = 1 #00000001
                if tx_done:
                    state.next = t_State.display_pause #_setup
                    main_delay_load.next = 1
                    main_delay_value.next = 82000
 
            elif state == t_State.display_pause_setup:
                state.next = t_State.display_pause
 
            elif state == t_State.display_pause:
                tx_byte.next = 0 #00000000
 
                if delay_done:
                    state.next = t_State.display_done;
 
            elif state == t_State.display_done:
                tx_byte.next = 0 #00000000
 
                if we:
                    state.next = t_State.display_set_addr
                    wr_addr.next = addr
                    wr_dat.next = dat
                else:
                    state.next = t_State.display_done
 
            elif state == t_State.display_set_addr:
                tx_byte.next = 128+wr_addr #10000000 + addr[6:0]
                if tx_done:
                    state.next = t_State.display_char_write
 
            elif state == t_State.display_char_write:
                tx_byte.next = wr_dat
                if tx_done:
                    state.next = t_State.display_done;
           # else:
               # raise ValueError("Undefined Display state")
 
 
 
    @always(clk.posedge, reset.posedge)
    def TxFSM():
        if reset == 1:
            tx_state.next = t_TxState.tx_done
            SF_D0.next = 0
            LCD_E0.next = 0
        else:
            tx_delay_load.next = 0;
            tx_delay_value.next = 0;
            if tx_state == t_TxState.tx_high_setup:
                LCD_E0.next = 0
                SF_D0.next = tx_byte[8 : 4]
                tx_delay_load.next = 0
                if delay_done:
                    tx_state.next = t_TxState.tx_high_hold
                    tx_delay_load.next = 1
                    tx_delay_value.next = 12
 
            elif tx_state == t_TxState.tx_high_hold:
                LCD_E0.next = 1
                SF_D0.next = tx_byte[8 : 4]
                tx_delay_load.next = 0
                if delay_done:
                    tx_state.next = t_TxState.tx_oneus
                    tx_delay_load.next = 1
                    tx_delay_value.next = 50
 
            elif tx_state == t_TxState.tx_oneus:
                LCD_E0.next = 0
                tx_delay_load.next = 0
                if delay_done:
                    tx_state.next = t_TxState.tx_low_setup
                    tx_delay_load.next = 1
                    tx_delay_value.next = 2
 
            elif tx_state == t_TxState.tx_low_setup:
                LCD_E0.next = 0
                SF_D0.next = tx_byte[4 : 0]
                tx_delay_load.next = 0
                if delay_done:
                    tx_state.next = t_TxState.tx_low_hold
                    tx_delay_load.next = 1
                    tx_delay_value.next = 12
 
            elif tx_state == t_TxState.tx_low_hold:
                LCD_E0.next = 1
                SF_D0.next = tx_byte[4 : 0]
                tx_delay_load.next = 0
                if delay_done:
                    tx_state.next = t_TxState.tx_fortyus
                    tx_delay_load.next = 1
                    tx_delay_value.next = 2000
 
            elif tx_state == t_TxState.tx_fortyus:
                LCD_E0.next = 0
                tx_delay_load.next = 0
                if delay_done:
                    tx_state.next = t_TxState.tx_done
                    tx_done.next = 1
 
            elif tx_state == t_TxState.tx_done:
                LCD_E0.next = 0
                tx_done.next = 0
                tx_delay_load.next = 0
                if tx_init:
                    tx_state.next = t_TxState.tx_high_setup
                    tx_delay_load.next = 1
                    tx_delay_value.next = 2
           # else:
           #     raise ValueError("Undefined TX state")
 
    return instances()
 
def main():
    width = 20
 
    count = Signal(intbv(0)[width:0])
    clk, reset, we, busy, LCD_E, LCD_RS, LCD_RW = [Signal(bool(0)) for i in range(7)]
    dat = Signal(intbv(0)[32:0])
    addr = Signal(intbv(0)[7:0])
    SF_D = Signal(intbv(0)[4:0])
 
    toVerilog(lcd, clk, reset, dat, addr, we, busy, SF_D, LCD_E, LCD_RS, LCD_RW)
    toVHDL(lcd, clk, reset, dat, addr, we, busy, SF_D, LCD_E, LCD_RS, LCD_RW)
 
if __name__ == '__main__':
    main()
 

Browse

Tools

Subversion Repositories wb_lcd

[/] [wb_lcd/] [trunk/] [myhdl/] [wb_lcd_workspace_ramless/] [workspace/] [.metadata/] [.plugins/] [org.eclipse.core.resources/] [.history/] [ea/] [104d25ec632a001e17c6eddde04c8549] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	jvillar	`from myhdl import *`
2
3			`t_TxState = enum('tx_high_setup', 'tx_high_hold', 'tx_oneus', 'tx_low_setup', 'tx_low_hold', 'tx_fortyus', 'tx_done');`
4			`t_State = enum('display_init', 'init_fifteenms', 'init_one', 'init_two', 'init_three', 'init_four', 'init_five', 'init_six', 'init_seven', 'init_eight', 'display_function_set', 'display_entry_set', 'display_set_display', 'display_clr_display', 'display_pause_setup', 'display_pause', 'display_done', 'display_set_addr', 'display_char_write')`
5
6			`def delayCounter(clk, reset, count, load, done, width = 13):`
7
8			`counter = Signal(intbv(0)[width:0])`
9
10			`@always_comb`
11			`def done_logic():`
12			`done.next = (counter == 0)`
13
14			`@always(clk.posedge)`
15			`def countdown_logic():`
16			`if load:`
17			`counter.next = count`
18			`else: #elif not done:`
19			`counter.next = counter - 1`
20
21			`return instances()`
22
23
24
25			`def lcd(clk, reset, dat, addr, we, busy, SF_D, LCD_E, LCD_RS, LCD_RW):`
26
27
28			`state = Signal(t_State.display_init)`
29			`tx_state = Signal(t_TxState.tx_done)`
30			`tx_byte = Signal(intbv(0)[8:0])`
31			`tx_init = Signal(bool())`
32			`tx_done = Signal(bool())`
33			`LCD_E0 = Signal(bool())`
34			`SF_D0 = Signal(intbv(0)[4:0])`
35			`LCD_E1 = Signal(bool())`
36			`SF_D1 = Signal(intbv(0)[4:0])`
37			`wr_dat = Signal(intbv(0)[7:0])`
38			`wr_addr = Signal(intbv(0)[7:0])`
39
40			`@always_comb`
41			`def busy_and_rw_handlers():`
42			`busy.next = (state != t_State.display_done)`
43			`LCD_RW.next = 0`
44
45			`#Delay counter`
46			`main_delay_load = Signal(bool())`
47			`main_delay_value = Signal(intbv(0)[20:0])`
48
49			`tx_delay_load = Signal(bool())`
50			`main_delay_load = Signal(bool())`
51			`delay_load = Signal(bool())`
52
53			`tx_delay_value = Signal(intbv(0)[20:0])`
54			`main_delay_value = Signal(intbv(0)[20:0])`
55			`delay_value = Signal(intbv(0)[20:0])`
56
57			`delay_done = Signal(bool())`
58			`output_selector = Signal(bool())`
59			`counter = delayCounter(clk, reset, delay_value, delay_load, delay_done, width = 21)`
60
61			`@always_comb`
62			`def conunter_sharing_load():`
63			`delay_load.next = tx_delay_load or main_delay_load`
64
65			`@always_comb`
66			`def conunter_sharing_value():`
67			`if tx_delay_load:`
68			`delay_value.next = tx_delay_value`
69			`else:`
70			`delay_value.next = main_delay_value`
71
72
73			`# SF_D and LCD_E management for sharing between Init and TX phases.`
74			`@always_comb`
75			`def output_tx_or_init_select(): # 0 tx; 1 init`
76			`output_selector.next = (state == t_State.display_init) \| (state == t_State.init_fifteenms) \| (state == t_State.init_one) \| (state == t_State.init_two) \| (state == t_State.init_three) \| (state == t_State.init_four) \| (state == t_State.init_five) \| (state == t_State.init_six) \| (state == t_State.init_seven) \| (state == t_State.init_eight)`
77
78			`@always_comb`
79			`def output_tx_or_init_mux():`
80			`if output_selector: # Init`
81			`SF_D.next = SF_D1`
82			`LCD_E.next = LCD_E1`
83			`else: # TX`
84			`SF_D.next = SF_D0`
85			`LCD_E.next = LCD_E0`
86
87
88			`@always_comb`
89			`def init_transmissions():`
90			`tx_init.next = (~tx_done) & ((state == t_State.display_function_set) \| (state == t_State.display_entry_set) \| (state == t_State.display_set_display) \| (state == t_State.display_clr_display) \| (state == t_State.display_set_addr) \| (state == t_State.display_char_write))`
91			`LCD_RS.next = ~(bool(state == t_State.display_function_set) \| (state == t_State.display_entry_set) \| (state == t_State.display_set_display) \| (state == t_State.display_clr_display) \| (state == t_State.display_set_addr))`
92
93			`@always(clk.posedge, reset.posedge)`
94			`def DisplayFSM():`
95			`if reset == 1:`
96			`state.next = t_State.display_init`
97			`main_delay_load.next = 0`
98			`main_delay_value.next = 0`
99			`SF_D1.next = 0`
100			`LCD_E1.next = 0`
101			`tx_byte.next = 0`
102			`else:`
103			`main_delay_load.next = 0;`
104			`main_delay_value.next = 0;`
105			`if state == t_State.display_init:`
106			`tx_byte.next = 0 #00000000`
107
108			`state.next = t_State.init_fifteenms`
109			`main_delay_load.next = 1`
110			`main_delay_value.next = 750000`
111
112			`elif state == t_State.init_fifteenms:`
113			`main_delay_load.next = 0`
114
115			`if delay_done:`
116			`state.next = t_State.init_one;`
117			`main_delay_load.next = 1`
118			`main_delay_value.next = 11`
119
120			`elif state == t_State.init_one:`
121			`main_delay_load.next = 0`
122			`SF_D1.next = 3`
123			`LCD_E1.next = 1`
124
125			`if delay_done:`
126			`state.next = t_State.init_two;`
127			`main_delay_load.next = 1`
128			`main_delay_value.next = 205000`
129
130			`elif state == t_State.init_two:`
131			`main_delay_load.next = 0`
132			`LCD_E1.next = 0`
133
134			`if delay_done:`
135			`state.next = t_State.init_three;`
136			`main_delay_load.next = 1`
137			`main_delay_value.next = 11`
138
139			`elif state == t_State.init_three:`
140			`main_delay_load.next = 0`
141			`SF_D1.next = 3`
142			`LCD_E1.next = 1`
143
144			`if delay_done:`
145			`state.next = t_State.init_four;`
146			`main_delay_load.next = 1`
147			`main_delay_value.next = 5000`
148
149			`elif state == t_State.init_four:`
150			`main_delay_load.next = 0`
151			`LCD_E1.next = 0`
152
153			`if delay_done:`
154			`state.next = t_State.init_five;`
155			`main_delay_load.next = 1`
156			`main_delay_value.next = 11`
157
158
159			`elif state == t_State.init_five:`
160			`main_delay_load.next = 0`
161			`SF_D1.next = 3`
162			`LCD_E1.next = 1`
163
164			`if delay_done:`
165			`state.next = t_State.init_six;`
166			`main_delay_load.next = 1`
167			`main_delay_value.next = 2000`
168
169			`elif state == t_State.init_six:`
170			`main_delay_load.next = 0`
171			`LCD_E1.next = 0`
172
173			`if delay_done:`
174			`state.next = t_State.init_seven;`
175			`main_delay_load.next = 1`
176			`main_delay_value.next = 11`
177
178			`elif state == t_State.init_seven:`
179			`main_delay_load.next = 0`
180			`SF_D1.next = 2`
181			`LCD_E1.next = 1`
182
183			`if delay_done:`
184			`state.next = t_State.init_eight;`
185			`main_delay_load.next = 1`
186			`main_delay_value.next = 2000`
187
188			`elif state == t_State.init_eight:`
189			`main_delay_load.next = 0`
190			`LCD_E1.next = 0`
191
192			`if delay_done:`
193			`state.next = t_State.display_function_set;`
194
195			`elif state == t_State.display_function_set:`
196			`tx_byte.next = 40 #00101000`
197			`if tx_done:`
198			`state.next = t_State.display_entry_set`
199
200			`elif state == t_State.display_entry_set:`
201			`tx_byte.next = 6 #00000110`
202			`if tx_done:`
203			`state.next = t_State.display_set_display`
204
205			`elif state == t_State.display_set_display:`
206			`tx_byte.next = 12 #00001100`
207			`if tx_done:`
208			`state.next = t_State.display_clr_display`
209
210			`elif state == t_State.display_clr_display:`
211			`tx_byte.next = 1 #00000001`
212			`if tx_done:`
213			`state.next = t_State.display_pause #_setup`
214			`main_delay_load.next = 1`
215			`main_delay_value.next = 82000`
216
217			`elif state == t_State.display_pause_setup:`
218			`state.next = t_State.display_pause`
219
220			`elif state == t_State.display_pause:`
221			`tx_byte.next = 0 #00000000`
222
223			`if delay_done:`
224			`state.next = t_State.display_done;`
225
226			`elif state == t_State.display_done:`
227			`tx_byte.next = 0 #00000000`
228
229			`if we:`
230			`state.next = t_State.display_set_addr`
231			`wr_addr.next = addr`
232			`wr_dat.next = dat`
233			`else:`
234			`state.next = t_State.display_done`
235
236			`elif state == t_State.display_set_addr:`
237			`tx_byte.next = 128+wr_addr #10000000 + addr[6:0]`
238			`if tx_done:`
239			`state.next = t_State.display_char_write`
240
241			`elif state == t_State.display_char_write:`
242			`tx_byte.next = wr_dat`
243			`if tx_done:`
244			`state.next = t_State.display_done;`
245			`# else:`
246			`# raise ValueError("Undefined Display state")`
247
248
249
250			`@always(clk.posedge, reset.posedge)`
251			`def TxFSM():`
252			`if reset == 1:`
253			`tx_state.next = t_TxState.tx_done`
254			`SF_D0.next = 0`
255			`LCD_E0.next = 0`
256			`else:`
257			`tx_delay_load.next = 0;`
258			`tx_delay_value.next = 0;`
259			`if tx_state == t_TxState.tx_high_setup:`
260			`LCD_E0.next = 0`
261			`SF_D0.next = tx_byte[8 : 4]`
262			`tx_delay_load.next = 0`
263			`if delay_done:`
264			`tx_state.next = t_TxState.tx_high_hold`
265			`tx_delay_load.next = 1`
266			`tx_delay_value.next = 12`
267
268			`elif tx_state == t_TxState.tx_high_hold:`
269			`LCD_E0.next = 1`
270			`SF_D0.next = tx_byte[8 : 4]`
271			`tx_delay_load.next = 0`
272			`if delay_done:`
273			`tx_state.next = t_TxState.tx_oneus`
274			`tx_delay_load.next = 1`
275			`tx_delay_value.next = 50`
276
277			`elif tx_state == t_TxState.tx_oneus:`
278			`LCD_E0.next = 0`
279			`tx_delay_load.next = 0`
280			`if delay_done:`
281			`tx_state.next = t_TxState.tx_low_setup`
282			`tx_delay_load.next = 1`
283			`tx_delay_value.next = 2`
284
285			`elif tx_state == t_TxState.tx_low_setup:`
286			`LCD_E0.next = 0`
287			`SF_D0.next = tx_byte[4 : 0]`
288			`tx_delay_load.next = 0`
289			`if delay_done:`
290			`tx_state.next = t_TxState.tx_low_hold`
291			`tx_delay_load.next = 1`
292			`tx_delay_value.next = 12`
293
294			`elif tx_state == t_TxState.tx_low_hold:`
295			`LCD_E0.next = 1`
296			`SF_D0.next = tx_byte[4 : 0]`
297			`tx_delay_load.next = 0`
298			`if delay_done:`
299			`tx_state.next = t_TxState.tx_fortyus`
300			`tx_delay_load.next = 1`
301			`tx_delay_value.next = 2000`
302
303			`elif tx_state == t_TxState.tx_fortyus:`
304			`LCD_E0.next = 0`
305			`tx_delay_load.next = 0`
306			`if delay_done:`
307			`tx_state.next = t_TxState.tx_done`
308			`tx_done.next = 1`
309
310			`elif tx_state == t_TxState.tx_done:`
311			`LCD_E0.next = 0`
312			`tx_done.next = 0`
313			`tx_delay_load.next = 0`
314			`if tx_init:`
315			`tx_state.next = t_TxState.tx_high_setup`
316			`tx_delay_load.next = 1`
317			`tx_delay_value.next = 2`
318			`# else:`
319			`# raise ValueError("Undefined TX state")`
320
321			`return instances()`
322
323			`def main():`
324			`width = 20`
325
326			`count = Signal(intbv(0)[width:0])`
327			`clk, reset, we, busy, LCD_E, LCD_RS, LCD_RW = [Signal(bool(0)) for i in range(7)]`
328			`dat = Signal(intbv(0)[32:0])`
329			`addr = Signal(intbv(0)[7:0])`
330			`SF_D = Signal(intbv(0)[4:0])`
331
332			`toVerilog(lcd, clk, reset, dat, addr, we, busy, SF_D, LCD_E, LCD_RS, LCD_RW)`
333			`toVHDL(lcd, clk, reset, dat, addr, we, busy, SF_D, LCD_E, LCD_RS, LCD_RW)`
334
335			`if __name__ == '__main__':`
336			`main()`
337