‫داﻧﺸﮕﺎه ﺗﻬﺮان ‪ -‬داﻧﺸﻜﺪة ﻓﻨﻲ‬

‫ﮔﺮوه ﻣﻬﻨﺪﺳﻲ ﺑﺮق و ﻛﺎﻣﭙﻴﻮﺗﺮ‬

‫ﺧﻮدآﻣﻮز زﺑﺎن ﺗﻮﺻﻴﻒ ﺳﺨﺖاﻓﺰاري‬

‫‪Verilog‬‬

‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه ‪ :‬ﺳﻌﻴﺪ ﺻﻔﺮي‬

‫اﺳﻔﻨﺪ ‪٧٩‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫ﻣﻔﺎﻫﻴﻢ اوﻟﻴﻪ‬ ‫‪١‬‬

‫ﻣﺎﺟﻮل‬ ‫‪١-١‬‬
‫ﻣـﺎﺟﻮل ﺑﻠـﻮك ﭘﺎﻳـﺔ ‪ Verilog‬اﺳـﺖ‪ .‬ﻳـﻚ ﻣـﺎﺟﻮل ﻣﻲﺗﻮاﻧـﺪ ﻳـﻚ ﻋﻨﺼـﺮ ﻳـﺎ ﻣﺠﻤﻮﻋـﻪاي از ﺑﻠﻮﻛـــﻬﺎي‬
‫ﺳﻄﺢ ﭘــﺎﻳﻴﻦﺗﺮ ﺑﺎﺷـﺪ‪ .‬ﺑﻨـﺎﺑﺮاﻳﻦ ﻣـﺎﺟﻮل ﻋﻤﻠﻜـﺮد ﻣـﻮرد ﻧﻈـﺮ را ﺑـﺮاي ﺑﻠﻮﻛـﻬﺎي ﺳـﻄﺢ ﺑـﺎﻻﺗﺮ ﻓﺮاﻫـﻢ ﻣﻲﻛﻨـﺪ‪ ،‬اﻣـﺎ‬
‫ﭘﻴﺎدهﺳﺎزي داﺧﻞ آﻧـﺮا ﭘﻨـﻬﺎن ﻣﻲﻛﻨـﺪ‪ .‬ﺷـﻜﻞ ‪ ١-١‬ﻧﺤـﻮة ﺗﻌﺮﻳـﻒ ﻣـﺎﺟﻮل را ﺑـﺎ ﻳـﻚ ﻣﺜـﺎل ﺑﻴـﺎن ﻣﻲﻛﻨـﺪ‪ .‬در زﺑـﺎن‬
‫‪ Verilog‬ﻣﻲﺗﻮاﻧﻴﻢ ﻳﻚ ﻣــﺎﺟﻮل را در ﭼـﻬﺎر ﺳـﻄﺢ ﻣﺨﺘﻠـﻒ ﺗﺠﺮﻳـﺪ ﺑﻴـﺎن ﻛﻨﻴـﻢ ‪:‬‬
‫• ﺳﻄﺢ ﮔﻴﺖ ‪ :‬در اﻳﻦ ﺳﻄﺢ ﻣــﺎﺟﻮل ﺑﺼـﻮرت ﮔﻴﺘـﻬﺎي ﻣﻨﻄﻘـﻲ و اﺗﺼـﺎﻻت ﺑﻴـﻦ آﻧـﻬﺎ ﺑﻴـﺎن ﻣﻲﺷـﻮد‪.‬‬
‫• ﺳـﻄﺢ ﺟﺮﻳـﺎن داده )‪ : (Dataflow‬در اﻳـﻦ ﺳـﻄﺢ ﻣـﺎﺟﻮل ﺑﻮﺳـﻴﻠﺔ ﻣﺸـﺨﺺ ﻛـﺮدن ﻧﺤـﻮة ﺟﺮﻳـــﺎن‬
‫اﻃﻼﻋﺎت ﺑﻴﻦ رﺟﻴﺴﺘﺮﻫﺎ و ﻧﻮع ﭘﺮدازﺷــﻲ ﻛـﻪ روي آﻧـﻬﺎ ﺻـﻮرت ﻣـﻲﮔـﻴﺮد‪ ،‬ﺑﻴـﺎن ﻣﻲﺷـﻮد‪.‬‬
‫• ﺳـﻄﺢ رﻓﺘـﺎري )‪ : (Behavioral‬در اﻳـﻦ ﺳـﻄﺢ ﻣـﺎﺟﻮل ﺑﺮﺣﺴـﺐ اﻟﮕﻮرﻳﺘـﻢ ﻃﺮاﺣـﻲ ﺷـﻮد‪ ،‬ﺑــﺪون‬
‫اﻳﻨﻜﻪ ﺟﺰﺋﻴﺎت ﻃﺮاﺣــﻲ ﭘﻴﺎدهﺳـﺎزي ﺳـﺨﺖاﻓﺰاري در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﺷـﻮد‪.‬‬
‫• ﺳﻄﺢ ﺳﻮﺋﻴﭻ ‪ :‬در اﻳﻦ ﺳﻄﺢ ﻣــﺎﺟﻮل ﺑﺼـﻮرت ﺳـﻮﺋﻴﭽﻬﺎ و اﺗﺼـﺎﻻت ﺑﻴـﻦ آﻧـﻬﺎ ﺑﻴـﺎن ﻣﻲﺷـﻮد‪.‬‬

‫;) ‪module decoder ( A, B, En, D0, D1, D2, D3‬‬

‫‪A‬‬ ‫‪D0‬‬ ‫;‪input A, B, En‬‬ ‫‪Declaration of the input/output port‬‬
‫‪B‬‬ ‫‪D1‬‬ ‫;‪output D0, D1, D2, D3‬‬
‫‪Module body‬‬
‫‪D2‬‬ ‫‪//Functionality of the decoder‬‬ ‫‪Descrption of the module‬‬
‫‪En‬‬ ‫‪D3‬‬
‫‪endmodule‬‬

‫‪Note that the functionality of the module can be‬‬

‫‪described in the following abstract level :‬‬
‫‪1. Gate Level‬‬ ‫‪2. Dataflow Level‬‬
‫‪3. Behavioral Level‬‬ ‫‪4. Switch Level‬‬

‫ﺷﻜﻞ ‪ -١-١‬ﻧﺤﻮة ﺗﻌﺮﻳﻒ ﻣﺎﺟﻮل‬

‫ﻧﻤﻮﻧﻪ‬ ‫‪٢-١‬‬
‫ﻳـﻚ ﻣـﺎﺟﻮل اﻟﮕﻮﻳـﻲ از ﻳـﻚ ﻋﻨﺼـﺮ واﻗﻌـﻲ ﻣﻲﺳـﺎزد‪ ،‬ﻫﻨﮕﺎﻣﻴﻜـــﻪ از اﻳــﻦ ﻣــﺎﺟﻮل اﺳــﺘﻔﺎده ﻣﻲﺷــﻮد‪،‬‬
‫‪ Verilog‬ﻳﻚ ﻧﻤﻮﻧــﻪ از اﻳـﻦ اﻟﮕـﻮ ﻣﻲﺳـﺎزد‪ .‬ﻫـﺮ ﻋﻨﺼـﺮ داراي ﻧـﺎم‪ ،‬ﻣﺘﻐﻴﺮﻫـﺎ و ﭘﺎراﻣﺘﺮﻫـﺎي ﺧـﺎص ﺧـﻮد اﺳـﺖ‪.‬‬
‫ﭘﺮوﺳﺔ اﻳﺠــﺎد ﻳـﻚ ﻧﻤﻮﻧـﻪ از اﻟﮕـﻮي ﻳـﻚ ﻣـﺎﺟﻮل را اﺻﻄﻼﺣـﺎ ‪ Instantiation‬ﻳـﺎ ﻧﻤﻮﻧﻪﺳـﺎزي و اﻳـﻦ ﻋﻨﺼـﺮ را‬
‫‪ Instance‬ﻳـﺎ ﻧﻤﻮﻧـﻪ ﻣﻲﻧـﺎﻣﻨﺪ‪ .‬ﺑﻌﻨـﻮان ﻣﺜـــﺎل در ﺷــﻜﻞ ‪ ٢-١‬ﻧﺤــﻮة ﺳــﺎﺧﺖ ﻳــﻚ ﻧﻤﻮﻧــﻪ از روي ﻣــﺎﺟﻮل‬
‫دﻳﻜﻮدر را ﻣﻲﺑﻴﻨﻴــﻢ‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫‪Top-Level Cicuit‬‬
‫‪dcd0‬‬
‫‪a‬‬ ‫‪d0‬‬
‫‪A‬‬ ‫‪D0‬‬
‫‪b‬‬ ‫‪d1‬‬
‫‪B‬‬ ‫‪D1‬‬
‫‪Circuit‬‬ ‫‪d2‬‬ ‫‪Circuit‬‬
‫‪D2‬‬
‫‪en‬‬ ‫‪d3‬‬
‫‪En‬‬ ‫‪D3‬‬
‫‪The nets are used to model an‬‬
‫‪electrical connection between‬‬
‫‪structural entities such as gates.‬‬
‫;‪module Top‬‬ ‫‪A wire is one type of net.‬‬
‫;‪wire a, b, en‬‬
‫;‪wire d0, d1, d2, d3‬‬

‫>‪<Other Components‬‬ ‫‪We instantiated an instance from‬‬

‫;) ‪decoder dcd0 ( a, b, en, d0, d1, d2, d3‬‬ ‫‪decoder and called it dcd0. The‬‬
‫>‪<Other Components‬‬
‫‪nets can be used to connect‬‬
‫‪endmodule‬‬ ‫‪dcd0 to other components.‬‬

‫ﺷﻜﻞ ‪ -٢-١‬ﻧﺤﻮة ﺳﺎﺧﺖ ﻧﻤﻮﻧﻪ از روي ﻣﺎﺟﻮل دﻳﻜﻮدر‬

‫• در ﺷﻜﻞ زﻳﺮ ﻳﻚ ﻣﻘﺎﻳﺴﻪﮔﺮ ﺑﻴﺘﻲ ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪ .‬ﻳﻚ ﻣﺎﺟﻮل ﺑﻨــﺎم ‪Comparator‬‬
‫ﺗﻌﺮﻳﻒ ﻛﻨﻴﺪ و ﺳﭙﺲ ﻳﻚ ﻧﻤﻮﻧﻪ ﺑﻨﺎم ‪ Comp0‬از روي آن ﺑﺴﺎزﻳﺪ‪ .‬دﻗﺖ ﻛﻨﻴﺪ ﻫﺪف ﻓﻘــﻂ‬
‫ﺗﻌﺮﻳﻒ ﭘﻮرﺗﻬﺎي ﻣﻘﺎﻳﺴﻪﮔﺮ و ﻧﻤﻮﻧﻪﺳﺎزي از روي آن اﺳﺖ‪.‬‬

‫‪Comp0‬‬
‫‪A‬‬ ‫‪a‬‬ ‫‪a_gt_b‬‬ ‫‪A_GT_B‬‬

‫‪B‬‬ ‫‪b‬‬
‫‪a_eq_b‬‬ ‫‪A_EQ_B‬‬
‫‪GT‬‬ ‫‪gt‬‬
‫‪a_lt_b‬‬ ‫‪A_LT_B‬‬
‫‪EQ‬‬ ‫‪eq‬‬

‫‪LT‬‬ ‫‪lt‬‬

‫ﻣﻘﺎﻳﺴﻪﮔﺮ ﺑﻴﺘﻲ‬

‫ﻗﺮاردادﻫﺎي ﻧﺤﻮي‬ ‫‪٢‬‬

‫ﻗﺮدادﻫﺎي ﻧﺤــﻮي ﻛـﻪ ﺑﻮﺳـﻴﻠﺔ ‪ Verilog‬اﺳـﺘﻔﺎده ﻣﻲﺷـﻮد‪ ،‬ﺑﺴـﻴﺎر ﺷـﺒﻴﻪ زﺑـﺎن ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴـﻲ ‪ C‬اﺳـﺖ‪ .‬ﻫـﺮ‬
‫ﺗﻮﻛﻦ ﻣﻲﺗﻮاﻧﺪ ﺗﻮﺿﻴﺢ‪ ،‬ﺟﺪاﻛﻨﻨﺪه‪ ،‬ﻋــﺪد‪ ،‬رﺷـﺘﻪ‪ ،‬ﺷﻨﺎﺳـﻪ و ﻳـﺎ ﻛﻠﻤـﺔ ﻛﻠﻴـﺪي ﺑﺎﺷـﺪ‪ Verilog .‬ﻳـﻚ زﺑـﺎن ﺣﺴـﺎس‬
‫ﺑﻪ ﻣﺘﻦ اﺳﺖ و ﺗﻤﺎم ﻛﻠﻤﺎت ﻛﻠﻴــﺪي آن ﺑـﺎ ﺣـﺮوف ﻛـﻮﭼـﻚ ﻧﻮﺷـﺘﻪ ﻣﻲﺷـﻮﻧﺪ‪.‬‬

‫ﺣﺮوف ﻓﺎﺻﻠﻪ‬ ‫‪١-٢‬‬

‫ﺣـﺮوف ﻓﺎﺻﻠـﻪ در ‪ Verilog‬ﻋﺒـﺎرﺗﻨﺪ از ‪ :‬ﻓﺎﺻﻠـﻪ )‪ (\t) tab ، (\b‬و ﺧﻂﺟﺪﻳــﺪ )‪ .(\n‬اﻳــﻦ ﺣــﺮوف‬
‫ﺗﻮﺳـﻂ ‪ Verilog‬ﻧـﺎدﻳﺪه ﮔﺮﻓﺘـﻪ ﻣﻲﺷـﻮﻧﺪ‪ ،‬ﻣﮕـﺮ اﻳﻨﻜـﻪ ﺑﻌﻨـﻮان ﺟﺪاﻛﻨﻨـﺪه ﺗﻮﻛﻨـﻬﺎ اﺳـﺘﻔﺎده ﺷـﻮﻧﺪ و ﻳـــﺎ در ﻳــﻚ‬
‫رﺷﺘﻪ اﺳﺘﻔﺎده ﺷــﻮﻧﺪ‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫ﺗﻮﺿﻴﺤﺎت‬ ‫‪٢-٢‬‬
‫ﺗﻮﺿﻴﺤـﺎت ﺑـﺮاي ﺧﻮاﻧـﺎﺗﺮ ﻛـﺮدن ﻃـﺮح ﺑﻜـﺎر ﻣﻲروﻧـﺪ و ﺑـــﻪ دوﺻــﻮرت ﻳــﻚ وﭼﻨﺪﺧﻄــﻲ اﺳــﺘﻔﺎده‬
‫ﻣﻲﺷﻮد‪ .‬ﺗﻮﺿﻴﺤﺎت ﻧﻤﻲﺗﻮاﻧﻨــﺪ ﺑﺼـﻮرت ﺗﻮدرﺗـﻮ اﺳـﺘﻔﺎده ﺷـﻮﻧﺪ‪.‬‬

‫‪a = b && c; // This is a single line comment‬‬

‫‪/* This is a multiple line‬‬
‫‪comment */‬‬

‫اﭘﺮاﺗﻮرﻫﺎ‬ ‫‪٣-٢‬‬
‫اﭘﺮاﺗﻮرﻫﺎ ﺑــﻪ ﺳـﻪ دﺳـﺘﻪ ﻳﮕـﺎﻧﻲ‪ ،‬دوﺗـﺎﻳﻲ و ﺳـﻪﺗﺎﻳﻲ ﺗﻘﺴـﻴﻢ ﻣﻲﺷـﻮﻧﺪ و ﺑـﻪ ﺗﺮﺗﻴـﺐ داراي ﻳـﻚ‪ ،‬دو و ﺳـﻪ‬
‫اﭘﺮﻧﺪ ﻫﺴــﺘﻨﺪ‪.‬‬

‫ﻣﺸﺨﺼﺎت اﻋﺪاد‬ ‫‪٤-٢‬‬

‫در ‪ Verilog‬اﻋﺪاد ﺑــﻪ دو ﺻـﻮرت زﻳـﺮ ﻧﻮﺷـﺘﻪ ﻣﻲﺷـﻮﻧﺪ ‪:‬‬
‫• ﻋﺪد اﻧﺪازه دار ‪ :‬در اﻳﻨﺤــﺎﻟﺖ ‪ Verilog‬را ﻣﻘﻴـﺪ ﻣﻲﻛﻨﻴـﻢ ﻳـﻚ ﻋـﺪد را ﺑـﺎ ﻫﻤـﺎن اﻧـﺪازة ﻣﻮردﻧﻈـﺮ ﻣـﺎ‬
‫ﺑﻜـﺎر ﺑـﺒﺮد‪ .‬ﺷـﻜﻞ ﻋـﺪد اﻧـــﺪازهدار ﺑﺼــﻮرت >‪ <size>‘<radix><number‬اﺳــﺖ‪ <size> .‬ﺑــﻪ‬
‫دﺳﻴﻤﺎل ﻧﻮﺷــﺘﻪ ﺷـﺪه و ﺗﻌـﺪاد ﺑﻴﺘـﻬﺎي ﻋـﺪد را ﻣﺸـﺨﺺ ﻣﻲﻛﻨـﺪ‪ <radix> .‬ﻣﺒﻨـﺎي ﻋـﺪد را ﻣﺸـﺨﺺ‬
‫ﻣﻲﻛﻨـﺪ‪ d ،‬ﻳـﺎ ‪ D‬ﺑـﺮاي ﻣﺒﻨـﺎي ده‪ b ،‬ﻳـﺎ ‪ B‬ﺑـﺮاي ﻣﺒﻨـﺎي دو‪ o ،‬ﻳـﺎ ‪ O‬ﺑـﺮاي ﻣﺒﻨـﺎي ﻫﺸـﺖ و ‪ h‬ﻳـــﺎ ‪H‬‬
‫ﺑـﺮاي ﻣﺒﻨـﺎي ﺷـﺎﻧﺰده ﺑﻜـﺎر ﻣـﻲرود‪ .‬ﺣـﺎﻟﺖ ﭘﻴﺶﻓـﺮض ﻣﺒﻨـﺎي ده اﺳـﺖ‪ .‬ﺑـﺮاي ﺧﻮاﻧﺎﺗﺮﺷـﺪن اﻋـــﺪاد‬
‫ﻣﻲﺗﻮان از "_" اﺳــﺘﻔﺎده ﻧﻤـﻮد‪.‬‬

‫‪8’b1010_1110‬‬ ‫‪//‬‬ ‫‪This is a 8 bit binary number‬‬

‫‪12’hab6‬‬ ‫‪//‬‬ ‫‪This is a 12 bit hex number‬‬
‫‪16’D255‬‬ ‫‪//‬‬ ‫‪This is a 12 bit decimal number‬‬
‫‪-4’d13‬‬ ‫‪//‬‬ ‫‪This is a 4 bit negative decimal number, that stored‬‬
‫‪//‬‬ ‫‪as 2’s complement of 13‬‬

‫• ﻋـﺪد ﺑـﺪون اﻧـﺪازه ‪ :‬ﺷـﻜﻞ ﻛﻠـﻲ ﻋـﺪد ﺑـﺪون اﻧـﺪازه ﺑﺼـﻮرت ’>‪ <radix><number‬اﺳـــﺖ‪ .‬در‬
‫اﻳﻦ ﺣﺎﻟﺖ ﻃﻮل ﻋﺪد ﺑﻪ ﻧــﻮع ﭘﻴﺎدهﺳـﺎزي ﺑﺴـﺘﮕﻲ دارد وﻟـﻲ ﺣﺪاﻗـﻞ ‪ ٣٢‬ﺑﻴـﺖ اﺳـﺖ‪.‬‬

‫‪1234‬‬ ‫‪// This is a 32 bit decimal number‬‬

‫‪h’62‬‬ ‫‪// This is a 32 bit hex number‬‬
‫‪o’255‬‬ ‫‪// This is a 32 bit octal number‬‬
 ‫ﺧﻮدآﻣﻮز زﺑــﺎن ﺗﻮﺻﻴـﻒ ﺳـﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫• اﻋﺪاد ﻣﻨﻔﻲ ﺑﺎ ﻗﺮار دادن ﻳﻚ ﻋﻼﻣﺖ ﻣﻨﻔﻲ )"‪ ("-‬ﻗﺒﻞ از >‪ <size‬ﺑﺪﺳﺖ ﻣﻲآﻳﻨﺪ‪.‬‬
‫• ﻛﺮﻛﺘﺮ ؟ و ‪ x‬ﻣﻌﺎدﻻ ﺑﻜﺎر ﻣﻲروﻧﺪ‪.‬‬
‫• در ‪ Verilog‬دوﻧﻤﺎد ﺑﺮاي ﻣﻘﺎدﻳﺮ ‪ HiZ‬و ﻧﺎﻣﻌﻠﻮم دارﻳﻢ ﻛﻪ ﺑﻪ ﺗﺮﺗﻴﺐ ﻋﺒــﺎرﺗﻨﺪ از‬
‫‪ . x, z‬اﻳﻦ ﻣﻘﺎدﺑﺮ در ﺷﺒﻴﻪﺳﺎزي ﻣﺪارﻫﺎ ﺑﺴﻴﺎر ﻣﻮرد اﺳــﺘﻔﺎده ﻗـﺮار ﻣـﻲﮔـﻴﺮﻧﺪ‪ .‬در‬
‫ﻣﻘﺪاردﻫﻲ ﺑﻪ ﻳﻚ ﻋﺪد درﻣﺒﻨﺎي ﺷﺎﻧﺰده‪ ،‬ﻫﺸﺖ و دو ﻣﻘﺎدﻳﺮ ‪ x, z‬ﺑــﻪﺗﺮﺗﻴﺐ ﻃﻮﻟـﻲ‬
‫ﺑﺮاﺑﺮ ‪ ٤‬و ‪ ٣‬و ‪ ١‬ﺑﻴﺖ دارﻧﺪ‪.‬‬

‫‪12’h13x‬‬ ‫‪// This is a 12 bit hex number, 4 LSBs unknown‬‬

‫??‪4’b10‬‬ ‫‪// This is a 4 bit binary number equal to 4’b10xx‬‬

‫• ﻣﺸﺨﺺ ﻛﻨﻴﺪ ﻛﻪ ﻛﺪام ﻳﻚ از اﻋﺪاد زﻳﺮ ﻣﻌﺘﺒﺮ ﻫﺴﺘﻨﺪ‪.‬‬

‫‪659‬‬ ‫‪‘h83F‬‬ ‫‪4AF‬‬ ‫‪12’hx‬‬ ‫‪5’D3‬‬ ‫‪8’d-6‬‬ ‫‪27_13_45‬‬

‫رﺷﺘﻪ‬ ‫‪٥-٢‬‬
‫ﻣﺠﻤﻮﻋﻪاي اﺳﺖ از ﻛﺮﻛﺘﺮﻫــﺎ ﻛـﻪ ﺑﻮﺳـﻴﻠﻪ ”“ ﻣﺤﺼـﻮر ﺷـﺪهاﻧﺪ‪.‬‬

‫ﺷﻨﺎﺳﻪ و ﻛﻠﻤﻪ ﻛﻠﻴﺪي‬ ‫‪٦-٢‬‬

‫ﻛﻠﻤﺎت ﻛﻠﻴــﺪي ﺷﻨﺎﺳـﻪﻫﺎﻳﻲ ﻫﺴـﺘﻨﺪ ﻛـﻪ از ﭘﻴـﺶ ﺑـﺮاي ﺗﻌﺮﻳـﻒ ﺳـﺎﺧﺘﺎر زﺑـﺎن اﺳـﺘﻔﺎده ﺷـﺪهاﻧﺪ‪ .‬ﻛﻠﻤـﺎت‬
‫ﻛﻠﻴﺪي ﺑﺎ ﺣــﺮوف ﻛـﻮﭼـﻚ ﻧﻮﺷـﺘﻪ ﻣﻲﺷـﻮﻧﺪ‪ .‬ﺷﻨﺎﺳـﻪﻫﺎ ﻧﺎﻣـﻬﺎﻳﻲ ﻫﺴـﺘﻨﺪ ﻛـﻪ ﻣـﺎ ﺑـﻪ ﻋﻨـﺎﺻﺮ ﻧﺴـﺒﺖ ﻣﻲدﻫﻴـﻢ ﺗـﺎ‬
‫ﺑﻮﺳﻴﻠﺔ آن ﺑــﻪ آﻧـﻬﺎ رﺟـﻮع ﻛﻨﻴـﻢ‪ .‬ﺷﻨﺎﺳـﻪ ﻣﻲﺗﻮاﻧـﺪ از ﻛﺮﻛﺘﺮﻫـﺎي ﺣﺮﻓـﻲ‪ _ ،‬و ‪ $‬ﺗﺸـﻜﻴﻞ ﺷـﻮد و ﺣﺘﻤـﺎ ﺑـﺎﻳﺪ ﺑـﺎ‬
‫ﻳﻚ ﻛﺮﻛﺘﺮ ﺣﺮﻓﻲ ﺷﺮوع ﺷــﻮد‪ .‬ﺷﻨﺎﺳـﻪﻫﺎ ﺣﺴـﺎس ﺑـﻪ ﻣﺘـﻦ ﻫﺴـﺘﻨﺪ‪.‬‬

‫اﻧﻮاع دادهﻫﺎ‬ ‫‪٧-٢‬‬

‫ﻣﺠﻤﻮﻋﻪ ﻣﻘﺎدﻳﺮ‬ ‫‪١-٧-٢‬‬

‫‪ Verilog‬ﺑـﺮاي ﻣﺪﻟﺴـﺎزي ﻋﻤﻠﻜـﺮد ﺳـﺨﺖاﻓﺰارﻫﺎي واﻗﻌـﻲ از ‪ ٤‬ﻣﻘـــﺪار و ‪ ٨‬ﺳــﻄﺢ ﻗــﺪرت اﺳــﺘﻔﺎده‬
‫ﻣﻲﻛﻨﺪ‪ .‬ﻣﺠﻤﻮﻋــﺔ ﻣﻘـﺎدﻳﺮ در ﺟـﺪول ‪ ١-١‬و ﺳـﻄﻮح ﻗـﺪرت در ﺟـﺪول ‪ ٢-١‬آﻣـﺪه اﺳـﺖ‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫‪Value Level‬‬ ‫‪Condition in Hardware Circuits‬‬

‫‪0‬‬ ‫‪Logic Zero, False Condition‬‬
‫‪1‬‬ ‫‪Logic One, True Condition‬‬
‫‪x‬‬ ‫‪Unknown value‬‬
‫‪z‬‬ ‫‪High Impedance, Floating State‬‬
‫ﺟﺪول ‪ -١-١‬ﻣﺠﻤﻮﻋﺔ ﻣﻘﺎدﻳﺮ‬

‫‪Strength Level‬‬ ‫‪Type‬‬ ‫‪Degree‬‬

‫‪supply‬‬ ‫‪Driving‬‬ ‫‪strongest‬‬
‫‪strong‬‬ ‫‪Driving‬‬
‫‪pull‬‬ ‫‪Driving‬‬
‫‪large‬‬ ‫‪Storage‬‬
‫‪weak‬‬ ‫‪Driving‬‬
‫‪medium‬‬ ‫‪Storage‬‬
‫‪small‬‬ ‫‪Storage‬‬
‫‪highz‬‬ ‫‪High Impedance‬‬ ‫‪Weakest‬‬
‫ﺟﺪول ‪ -٢-١‬ﺳﻄﻮح ﻗﺪرت‬

‫‪Net‬‬ ‫‪٢-٧-٢‬‬
‫ﺑـﺮاي ﺑﺮﻗـﺮار ﻛـﺮدن ارﺗﺒـﺎط ﺑﻴـﻦ اﺟـﺰاء ﺳـﺨﺖاﻓﺰاري ﺑﻜـﺎر ﻣـﻲرود‪ .‬درﺳـﺖ ﻣـﺎﻧﻨﺪ ﻣﺪارﻫـﺎي واﻗﻌـــﻲ‪،‬‬
‫‪ net‬داراي ﻣﻘـﺪاري اﺳـــﺖ ﻛــﻪ ﺑﻮﺳــﻴﻠﺔ ﺧﺮوﺟــﻲ ﻋﻨﺼــﺮ ﻣﺘﺼــﻞ ﺑــﻪ آن روي آن دراﻳــﻮ ﻣﻲﺷــﻮد‪ net .‬در‬
‫‪ Verilog‬ﺗﻮﺳﻂ ﻛﻠﻤــﺔ ﻛﻠﻴـﺪي ‪ wire‬ﺗﻌﺮﻳـﻒ ﻣﻲﺷـﻮد و ﻣﻘـﺪار ﭘﻴـﺶ ﻓـﺮض آن ‪ z‬اﺳـﺖ‪.‬‬

‫‪wire a; // Declare net a‬‬

‫‪wire b=1’b0‬‬ ‫‪// Net b is fixed to logic value 0 at declaration‬‬

‫• ﻧﺤـﻮة ﺑﺮﺧـﻮرد ﺑـﺎ ‪ z‬در ورودﻳـﻬﺎي ﮔﻴﺘـﻬﺎ و ﻋﺒـﺎرات دﻗﻴﻘـﺎ ﻣـﺎﻧﻨﺪ ‪ x‬اﺳـﺖ‪ ،‬ﻓﻘـــﻂ‬
‫ﺗﺮاﻧﺰﻳﺴﺘﻮرﻫﺎي ‪ MOS‬ﺣﺎﻟﺖ ‪ z‬را ازﺧﻮد ﻋﺒﻮر ﻣﻲدﻫﻨﺪ‪.‬‬
‫• ﺳﻄﻮح ﻗﺪرت ﺑﺮاي ﺣﻞ ﺗﺼﺎدم ﺑﻴﻦ دو دراﻳﻮر ﻣﺨﺘﻠﻒ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲﺷﻮد‪.‬‬
‫• اﮔﺮ دو ﺳﻴﮕﻨﺎل ﻧﺎﻣﺴﺎوي ﺑﺎ ﺳﻄﻮح ﻗﺪرت ﻣﺨﺘﻠﻒ ﻳﻚ ﺳﻴﻢ را دراﻳﻮ ﻛﻨﻨﺪ‪ ،‬ﺳﻴﮕﻨﺎل ﻗﻮﻳـﺘﺮ‬
‫ﺑﺮﻧﺪه ﻣﻲﺷﻮد‪.‬‬
‫• اﮔﺮ دو ﺳﻴﮕﻨﺎل ﻧﺎﻣﺴﺎوي ﺑﺎ ﺳﻄﻮح ﻗﺪرت ﻣﺴﺎوي ﻳــﻚ ﺳـﻴﻢ را دراﻳـﻮ ﻛﻨﻨـﺪ‪ ،‬ﺣـﺎﺻﻞ‬
‫ﻧﺎﻣﻌﻠﻮم ﻣﻲﺷﻮد‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫‪Register‬‬ ‫‪٣-٧-٢‬‬
‫ﺑـﺮاي ذﺧـﻴﺮة اﻃﻼﻋـﺎت ﺑﻜـﺎر ﻣـﻲرود‪ .‬رﺟﻴﺴـﺘﺮ ﺗـﺎ وﻗﺘـﻲ ﻣﻘـﺪار ﺟﺪﻳـﺪي روي آن ﻧﻮﺷـﺘﻪ ﻧﺸـﺪه ﻣﻘــﺪار‬
‫ﺧـﻮد را ﻧﮕـﺎه ﻣـﻲدارد‪ .‬ﺑﺮﺧـﻼف ‪ register ، net‬ﺑـﻪ دراﻳـﻮر ﻧﻴـﺎز ﻧـﺪارد‪ register .‬در ‪ Verilog‬ﺗﻮﺳـــﻂ ﻛﻠﻤــﺔ‬
‫ﻛﻠﻴﺪي ‪ reg‬ﺗﻌﺮﻳــﻒ ﻣﻲﺷـﻮد و ﻣﻘـﺪار ﭘﻴﺶﻓـﺮض آن ‪ x‬اﺳـﺖ‪.‬‬

‫;‪reg reset‬‬ ‫‪// Declare a variable that can be hold its value‬‬

‫‪Vector‬‬ ‫‪٤-٧-٢‬‬
‫اﻧـﻮاع دادهاي ‪ reg‬و ‪ wire‬ﻣﻲﺗﻮاﻧﻨـﺪ ﺑﺼـﻮرت ﺑـــﺮدار ﺗﻌﺮﻳــﻒ ﺷــﻮﻧﺪ‪ .‬ﺷــﻜﻞ ﻛﻠــﻲ ﺗﻌﺮﻳــﻒ ﺑــﺮدار‬
‫ﺑﺼﻮرت زﻳﺮ اﺳــﺖ ‪:‬‬
‫>‪<vector_type> [ MSB : LSB ] <vector_name‬‬

‫;‪wire [31:0] BusA‬‬ ‫‪// Declare a bus that has 32 bit width‬‬
‫;‪reg [0:40] Vir_Add‬‬ ‫‪// virtual address 41 bits wide‬‬

‫اﻧﻮاع دادهاي ﺻﺤﻴﺢ‪ ،‬ﺣﻘﻴﻘﻲ و زﻣﺎن‬ ‫‪٥-٧-٢‬‬

‫• ﺻﺤﻴـﺢ ‪ :‬ﻳـﻚ ﻧـﻮع دادة رﺟﻴﺴـﺘﺮ ﻫﻤـﻪ ﻣﻨﻈـﻮره اﺳـﺖ ﻛـﻪ ﺑـﺮاي ﭘـﺮدازش ﻣﻘـﺎدﻳﺮ ﺻﺤﻴـﺢ اﺳــﺘﻔﺎده‬
‫ﻣﻲﺷﻮد‪ .‬ﺗﻔــﺎوت اﻳـﻦ ﻧـﻮع ﺑـﺎ ﻧـﻮع ‪ reg‬دراﻳﻨﺴـﺘﻜﻪ در ﻧـﻮع ‪ reg‬دادهﻫـﺎ ﺑﺼـﻮرت ﺑـﺪون ﻋﻼﻣـﺖ در‬
‫ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـﻮﻧﺪ‪ ،‬وﻟـﻲ در ﻧـﻮع ﺻﺤﻴـﺢ دادهﻫـﺎ ﺑﺼـﻮرت ﻋﻼﻣﺘـﺪار در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـــﻮﻧﺪ‪.‬‬
‫ﻧـﻮع دادهاي ﺻﺤﻴـﺢ ﺗﻮﺳـﻂ ﻛﻠﻤـﺔ ﻛﻠﻴـــﺪي ‪ integer‬ﺗﻌﺮﻳــﻒ ﻣﻲﺷــﻮد و ﻃــﻮل آن ﺑﺴــﺘﮕﻲ ﺑــﻪ‬
‫ﭘﻴﺎدهﺳﺎزي دارد وﻟﻲ ﺣﺪاﻗــﻞ ‪ ٣٢‬ﺑﻴـﺖ درﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـﻮد‪.‬‬

‫;‪integer counter‬‬ ‫‪// General purpose variable used as a counter‬‬

‫• ﺣﻘﻴﻘـﻲ ‪ :‬ﻳـﻚ ﻧـﻮع دادة رﺟﻴﺴـﺘﺮ ﻫﻤـﻪ ﻣﻨﻈـﻮره اﺳـﺖ ﻛـﻪ ﺑـﺮاي ﭘـﺮدازش ﻣﻘـﺎدﻳﺮ ﺻﺤﻴـﺢ اﺳــﺘﻔﺎده‬
‫ﻣﻲﺷﻮد‪ .‬ﻧــﻮع دادهاي ﺻﺤﻴـﺢ ﺗﻮﺳـﻂ ﻛﻠﻤـﺔ ﻛﻠﻴـﺪي ‪ integer‬ﺗﻌﺮﻳـﻒ ﻣﻲﺷـﻮد‪.‬‬

‫;‪real delta‬‬ ‫‪// Declare a real variable called delta‬‬

‫• زﻣـﺎن ‪ :‬در ‪ Verilog‬ﻳـﻚ ﻧـﻮع دادهاي ﺧـﺎص ﺑـــﺮاي ذﺧــﻴﺮه ﻛــﺮدن زﻣــﺎن ﺷﺒﻴﻪﺳــﺎزي اﺳــﺘﻔﺎده‬
‫ﻣﻲﺷﻮد‪ .‬ﻧﻮع دادهاي زﻣــﺎن ﺑﻮﺳـﻴﻠﻪ ﻛﻠﻤـﻪ ﻛﻠﻴـﺪي ‪ time‬ﺗﻌﺮﻳـﻒ ﻣﻲﺷـﻮد‪ .‬ﻃـﻮل ﻣﺘﻐـﻴﺮ از ﻧـﻮع زﻣـﺎن‬
‫ﺑﻪ ﭘﻴﺎدهﺳﺎزي ﺑﺴــﺘﮕﻲ دارد وﻟـﻲ ﺣﺪاﻗـﻞ ‪ ٦٤‬ﺑﻴـﺖ اﺳـﺖ‪.‬‬

‫;‪time sim_time‬‬ ‫‪// Define a time variable sim_time‬‬

 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫آراﻳﻪ‬ ‫‪٨-٢‬‬
‫در ‪ Verilog‬ﻣﻲﺗـﻮان آراﻳـﻪاي از ﻧﻮﻋـﻬﺎي دادهاي ‪ time, integer, reg‬و ﻳــﺎ آراﻳــﻪاي از ﺑﺮدارﻫــﺎﻳﻲ‬
‫از اﻳﻦ ﻧﻮﻋﻬﺎ ﺗﻌﺮﻳﻒ ﻛــﺮد‪ .‬ﺷـﻜﻞ ﻛﻠـﻲ ﺗﻌﺮﻳـﻒ آراﻳـﻪ ﻋﺒﺎرﺗﺴـﺖ از ‪:‬‬
‫] ‪<array_type> <array_name> [ #first_element : #last_element‬‬

‫;]‪integer count[0:7‬‬ ‫‪// An array of 8 integer‬‬

‫• در ‪ Verilog‬آراﻳﻪﻫﺎي ﭼﻨﺪﺑﻌﺪي ﻧﺪارﻳﻢ‪.‬‬

‫• ﺗﻔﺎوت آراﻳﻪ و ﺑﺮدار در اﻳﻨﺴﺘﻜﻪ آراﻳﻪ از ﭼﻨﺪ ﻋﻨﺼﺮ ﺗﺸﻜﻴﻞ ﺷﺪه اﺳﺖ ﻛﻪ ﻫﺮﻳﻚ از‬
‫آﻧﻬﺎ ﻣﻲﺗﻮاﻧﻨﺪ ﻳﻚ ﻳﺎ ﭼﻨﺪ ﺑﻴﺖ ﻃﻮل داﺷﺘﻪ ﺑﺎﺷﻨﺪ‪ ،‬درﺣﺎﻟﻴﻜﻪ ﺑﺮدار ﻳﻚ ﻋﻨﺼــﺮ اﺳـﺖ‬
‫ﻛﻪ ﻃﻮﻟﻲ ﺑﺮاﺑﺮ ‪ n‬دارد‪.‬‬

‫ﺣﺎﻓﻈﻪ‬ ‫‪٩-٢‬‬
‫در ‪ Verilog‬ﺣﺎﻓﻈﻪ را ﺑﺼــﻮرت آراﻳـﻪاي از رﺟﻴﺴـﺘﺮﻫﺎ ﺗﻌﺮﻳـﻒ ﻣﻲﻛﻨﻴـﻢ‪.‬‬

‫;]‪reg membit[0:1023‬‬ ‫‪// 1K x 1bit memory‬‬

‫;]‪reg [7:0] membyte[0:1023‬‬ ‫‪// 1K x 8bit memory‬‬

‫ﭘﺎراﻣﺘﺮ‬ ‫‪١٠-٢‬‬
‫ﻣﻲﺗـﻮان در ﻳـﻚ ﻣـﺎﺟﻮل اﻋـﺪاد ﺛـﺎﺑﺘﻲ را ﺑﺼـﻮرت ﭘـﺎراﻣﺘﺮ ﺗﻌﺮﻳـﻒ ﻧﻤـﻮد و از آﻧـﻬﺎ اﺳـﺘﻔﺎده ﻧﻤـﻮد‪ ،‬اﻳــﻦ‬
‫اﻣﺮ ﺗﻮﺳﻂ ﻛﻠﻤــﻪ ﻛﻠﻴـﺪي ‪ parameter‬اﻧﺠـﺎم ﻣﻲﺷـﻮد‪.‬‬

‫;‪parameter port_id = 5‬‬ ‫‪// Define a constant port_id‬‬

‫رﺷﺘﻪ‬ ‫‪١١-٢‬‬
‫رﺷـﺘﻪﻫﺎ ﻣﻲﺗﻮاﻧﻨـﺪ در ﻳـﻚ ‪ reg‬ذﺧـﻴﺮه ﺷـﻮﻧﺪ‪ .‬ﻃـﻮل ﻣﺘﻐـﻴﺮ ‪ reg‬ﺑـﺎﻳﺪ ﺑـﻪ اﻧـﺪازه ﻛـﺎﻓﻲ ﺑـﺰرگ ﺑﺎﺷـﺪ ﺗــﺎ‬
‫ﺑﺘﻮاﻧﺪ رﺷﺘﻪ را ﻧﮕﺎه دارد‪ .‬ﻫــﺮ ﻛﺮﻛـﺘﺮ در ‪ ٨‬ﺑﻴـﺖ ذﺧـﻴﺮه ﻣﻲﺷـﻮد‪.‬‬

‫;‪reg [8*18:1] s_val‬‬ ‫‪// Define a variable with 18 bytes‬‬

‫‪ task‬ﻫﺎي ﺳﻴﺴﺘﻢ‬ ‫‪١٢-٢‬‬

‫در ‪ Verilog‬ﺗﻌـﺪادي ‪ task‬ﺑـﻪ ﻣﻨﻈـﻮر ﻧﻤـﺎﻳﺶ اﻃﻼﻋـﺎت روي ﺻﻔﺤـﻪ‪ ،‬ﻣـﺎﻧﻴﺘﻮرﻛﺮدن ﻣﻘـــﺎدﻳﺮ‪ ،‬ﺧﺎﺗﻤــﺔ‬
‫ﺷﺒﻴﻪﺳﺎزي و‪ ...‬ﻓﺮاﻫــﻢ ﺷـﺪه اﺳـﺖ‪ .‬ﻛﻠﻴـﺔ ‪ task‬ﻫـﺎ ﺑﺼـﻮرت >‪ $<task_name‬ﺑﻜـﺎر ﻣﻲروﻧـﺪ‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫• ﻧﻤـﺎﻳﺶ اﻃﻼﻋـﺎت ‪ :‬ﻧﻤـﺎﻳﺶ اﻃﻼﻋـﺎت ﺗﻮﺳـــﻂ ‪ $display‬اﻧﺠــﺎم ﻣﻲﺷــﻮد و داراي ﺷــﻜﻞ ﻛﻠــﻲ‬
‫;) ‪ $display( format, p1, p2, ..., pn‬اﺳـﺖ‪ ،‬ﻛـﻪ در آن ‪ pi‬ﻫـﺎ ﻣﻲﺗﻮاﻧﻨـــﺪ ﻧــﺎم ﻣﺘﻐــﻴﺮ‪ ،‬ﻧــﺎم‬
‫ﺳـﻴﮕﻨﺎل و ﻳـﺎ رﺷـﺘﻪ ﺑﺎﺷـﻨﺪ‪ .‬ﺗﻮﺳـﻂ ‪ format‬ﻣﻲﺗـﻮان ﻗـﺎﻟﺐ ﻧﻤـﺎﻳﺶ اﻃﻼﻋـﺎت را ﺑﺼـﻮرت دﻟﺨــﻮاه‬
‫ﺗﻌﻴﻴﻦ ﻧﻤــﻮد‪ .‬ﺑـﺮاي اﻳـﻦ ﻣﻨﻈـﻮر ﻳـﻚ ﺳـﺮي ﻗـﺎﻟﺐ از ﭘﻴـﺶ ﺗﻌﺮﻳـﻒ ﺷـﺪه اﺳـﺖ ﻛـﻪ ﻟﻴﺴـﺖ آﻧـﻬﺎ در‬
‫ﺟﺪول ‪ ٣-١‬آﻣــﺪه اﺳـﺖ‪.‬‬

‫‪Format‬‬ ‫‪Display‬‬
‫‪%d or %D‬‬ ‫‪Display variable in decimal‬‬
‫‪%b or %B‬‬ ‫‪Display variable in binary‬‬
‫‪%s or %S‬‬ ‫‪Display string‬‬
‫‪%h or %H‬‬ ‫‪Display variable in hex‬‬
‫‪%c or %C‬‬ ‫‪Display ASCII character‬‬
‫‪%v or %V‬‬ ‫‪Display strength‬‬
‫‪%o or %O‬‬ ‫‪Display variable in octal‬‬
‫‪%t or %T‬‬ ‫‪Display in current time format‬‬
‫‪%e or %E‬‬ ‫‪Display real number in scientific format‬‬
‫‪%f or %F‬‬ ‫‪Display real number in decimal format‬‬
‫‪%g or %G‬‬ ‫‪Display real number in scientific or decimal format, whichever is‬‬
‫‪shorter‬‬
‫ﺟﺪول ‪ -٣-١‬ﻟﻴﺴﺖ ﻣﺸﺨﺼﺎت ﻗﺎﻟﺒﻬﺎ‬

‫;) ‪$display(“At time %t virtual address is %h”, $time, vir_Adr‬‬

‫• ﻣـﺎﻧﻴﺘﻮرﻛﺮدن اﻃﻼﻋـﺎت ‪ :‬ﻣـﺎﻧﻴﺘﻮرﻛﺮدن اﻃﻼﻋـﺎت ﺗﻮﺳـﻂ ‪ $monitor‬اﻧﺠـﺎم ﻣﻲﺷـﻮد و داراي ﺷـــﻜﻞ ﻛﻠــﻲ‬
‫;) ‪ $monitor( format, p1, p2, ..., pn‬اﺳـﺖ‪ ،‬ﻛـﻪ در آن ‪ pi‬ﻫـﺎ ﻣﻲﺗﻮاﻧﻨـﺪ ﻧـﺎم ﻣﺘﻐـﻴﺮ‪ ،‬ﻧـﺎم ﺳـﻴﮕﻨﺎل و ﻳـﺎ‬
‫رﺷـﺘﻪ ﺑﺎﺷـﻨﺪ‪ .‬ﺗﻔـﺎوت ﻧﻤـﺎﻳﺶ اﻃﻼﻋــﺎت ﺑــﺎ ﻣــﺎﻧﻴﺘﻮرﻛﺮدن اﻃﻼﻋــﺎت در اﻳﻨﺴــﺘﻜﻪ‪ $display ،‬ﺑــﺎ ﻫﺮﺑــﺎر‬
‫ﻓﺮاﺧﻮاﻧـﻲ ﻳـﻚ ﻣﺮﺗﺒـــﻪ ﻣﻘــﺎدﻳﺮ ﭘﺎراﻣﺘﺮﻫــﺎﻳﺶ را ﻧﺸــﺎن ﻣﻲدﻫــﺪ وﻟــﻲ ‪ $monitor‬ﺑﻄــﻮر داﺋــﻢ ﻣﻘــﺎدﻳﺮ‬
‫ﭘﺎراﻣﺘﺮﻫـﺎﻳﺶ را ﻣـﺎﻧﻴﺘﻮر ﻣﻲﻛﻨـﺪ و ﺑـﻪ ﻣﺤـﺾ ﺗﻐﻴـﻴﺮ ﻳﻜـﻲ از ﭘﺎراﻣﺘﺮﻫـﺎي آن‪ ،‬ﻣﻘـﺎدﻳﺮ ﻛﻠﻴـﺔ ﭘﺎراﻣﺘﺮﻫـــﺎﻳﺶ را‬
‫ﻧﺸﺎن ﻣﻲدﻫﺪ‪ .‬ﺑﺎﻳﺪ ﺗﻮﺟﻪ داﺷــﺖ ﻛـﻪ در ﻫﺮﻟﺤﻈـﻪ ﻓﻘـﻂ ﻳـﻚ ‪ $monitor‬ﻣﻲﺗﻮاﻧـﺪ ﻓﻌـﺎل ﺑﺎﺷـﺪ‪ ،‬ﺑﻨـﺎﺑﺮاﻳﻦ اﮔـﺮ‬
‫ﭼﻨﺪﻳـﻦ دﺳـﺘﻮر ‪ $monitor‬داﺷـﺘﻪ ﺑﺎﺷـﻴﻢ‪ ،‬ﻓﻘـﻂ آﺧﺮﻳـﻦ دﺳـﺘﻮر ‪ $monitor‬ﻓﻌـﺎل اﺳـﺖ‪ .‬ﺗﻮﺳـــﻂ دو ‪task‬‬
‫ﺑـﻪ ﻧﺎﻣـﻬﺎي ‪ $monitoron‬و ‪ $monitoroff‬ﻣﻲﺗـﻮان ﻋﻤﻠﻴـﺎت ﻣـﺎﻧﻴﺘﻮر ﻛـﺮدن اﻃﻼﻋـﺎت را ﺑـﻪ ﺗﺮﺗﻴـﺐ ﻓﻌـــﺎل‬
‫و ﻏﻴﺮﻓﻌﺎل ﻧﻤــﻮد‪.‬‬
‫• ﺗﻮﻗﻒ و ﺧﺎﺗﻤــﺔ ﺷﺒﻴﻪﺳـﺎزي ‪ :‬ﺗﻮﺳـﻂ ‪ $stop‬ﻣﻲﺗـﻮان ﻋﻤﻠﻴـﺎت ﺷﺒﻴﻪﺳـﺎزي را ﻣﺘﻮﻗـﻒ ﻧﻤـﻮد و آﻧـﺮا در ﻣـﺪ‬
‫‪ interactive‬ﻗــﺮارداد‪ .‬اﻳــﻦ ﻣــﺪ ﺑــﺮاي ﻋﻴﺐﻳــﺎﺑﻲ ﺑﻜــﺎر ﻣــﻲرود‪ .‬ﺗﻮﺳــﻂ ‪ $finish‬ﻣﻲﺗــﻮان ﻋﻤﻠﻴـــﺎت‬
‫ﺷﺒﻴﻪﺳـﺎزي را ﺧﺎﺗﻤــﻪ داد‪.‬‬

‫راﻫﻨﻤﺎي ﻛﺎﻣﭙﺎﻳﻠﺮ‬ ‫‪١٣-٢‬‬

‫در ‪ Verilog‬راﻫﻨﻤـﺎي ﻛﺎﻣﭙـﺎﻳﻠﺮ داراي ﺷـﻜﻞ ﻛﻠـﻲ >‪ `<keyword‬اﺳـــﺖ‪ .‬دو ﻧــﻮع راﻫﻨﻤــﺎي ﻛﺎﻣﭙــﺎﻳﻠﺮ‬
‫ﻛﻪ ﻣﻮرد اﺳــﺘﻔﺎده ﺑﻴﺸـﺘﺮي دارﻧـﺪ‪ ،‬ﻋﺒـﺎرﺗﻨﺪ از ‪:‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫• ‪ `define‬ﻛﻪ ﺑﺮاي ﺗﻌﺮﻳــﻒ ﻣـﺎﻛﺮو ﺑﻜـﺎر ﻣـﻲرود‪.‬‬

‫• ‪ `include‬ﻛﻪ ﺑﺮاي اﻟﺤﺎق ﻳــﻚ ﻓـﺎﻳﻞ ‪ Verilog‬ﺑـﻪ ﻓـﺎﻳﻞ ﺟـﺎري ﺑﻜـﺎر ﻣـﻲرود‪.‬‬

‫‪`define WORD_SIZE 32‬‬ ‫‪// Used as `WORD_SIZE in the code‬‬

‫”‪`include “header.v‬‬ ‫‪// Include the file header.v‬‬

‫ﻣﺎﺟﻮل‬ ‫‪٣‬‬
‫ﻗﺒـﻼ ﻧﺤـﻮة ﺗﻌﺮﻳـﻒ و ﻧﻤﻮﻧﻪﺳـﺎزي ﻣـﺎﺟﻮل را دﻳﺪﻳـﻢ‪ ،‬در اﻳﻨﺠـﺎ ﺑﺼـﻮرت دﻗﻴﻘـﺘﺮ اﺟـﺰا ﻣـﺎﺟﻮل را ﻣــﻮرد‬
‫ﺑﺮرﺳﻲ ﻗــﺮار ﻣﻲدﻫﻴـﻢ‪ .‬در ﺷـﻜﻞ ‪ ٣-١‬اﺟـﺰا ﻣـﺎﺟﻮل ﻣﺸـﺨﺺ ﺷـﺪه اﺳـﺖ‪ .‬ﻗﺴـﻤﺘﻬﺎﻳﻲ ﻛـﻪ ﺑﺼـﻮرت زﻳﺮﺧـﻂدار‬
‫ﻧﻮﺷـﺘﻪ ﺷـﺪهاﻧﺪ‪ ،‬در ﺗﻌﺮﻳـﻒ ﻣـﺎﺟﻮل ﺿـﺮوري و ﺳـﺎﻳﺮ ﻗﺴـﻤﺘﻬﺎ اﺧﺘﻴـﺎري اﺳـﺖ‪ .‬ﻗﺴـﻤﺘﻬﺎﻳﻲ ﻛـﻪ ﺑﺪﻧـﺔ ﻣــﺎﺟﻮل را‬
‫ﺗﺸﻜﻴﻞ ﻣﻲدﻫﻨﺪ‪ ،‬ﻣﻲﺗﻮاﻧﻨﺪ ﺑﺎ ﻫــﺮ ﺗﺮﺗﻴﺒـﻲ در ﺗﻌﺮﻳـﻒ ﻣـﺎﺟﻮل اﺳـﺘﻔﺎده ﺷـﻮﻧﺪ‪.‬‬

‫;) ‪module module_name ( port list‬‬

‫)‪port declarations (if ports present‬‬
‫)‪parameters (optional‬‬

‫‪Declaration‬‬ ‫‪of wires, regs and other variables‬‬

‫)‪Data flow statemnet (assign‬‬

‫‪Instantiation of lower level module‬‬

‫‪always and initial blocks, all behavioral‬‬

‫‪statements go in these blocks‬‬

‫‪tasks and functions‬‬

‫‪endmodule‬‬

‫ﺷﻜﻞ ‪ -٣-١‬اﺟﺰاء ﺗﺸﻜﻴﻞ دﻫﻨﺪه ﻣﺎﺟﻮل‬

‫ﭘﻮرت‬ ‫‪٤‬‬
‫ﭘﻮرﺗﻬﺎي ﻳﻚ ﻣﺎﺟﻮل‪ ،‬واﺳﻂ ارﺗﺒــﺎﻃﻲ ﻣـﺎﺟﻮل ﺑـﺎ ﺟـﻬﺎن ﺧـﺎرج اﺳـﺖ‪.‬‬

‫ﻟﻴﺴﺖ ﭘﻮرﺗﻬﺎ‬ ‫‪١-٤‬‬

‫ﺑﻪ ﻫﻨﮕﺎم ﺗﻌﺮﻳﻒ ﻣــﺎﺟﻮل دﻳﺪﻳـﻢ ﻛـﻪ ﻟﻴﺴـﺖ ﭘﻮرﺗـﻬﺎ )درﺻـﻮرت وﺟـﻮد( در ﺟﻠـﻮي ﻧـﺎم ﻣـﺎﺟﻮل ﻣﻌﺮﻓـﻲ‬
‫ﻣﻲﺷـﻮﻧﺪ‪ .‬ﺑﻌﻨـﻮان ﻣﺜـﺎل در ﺷـﻜﻞ ‪ ٤-١‬ﻳـﻚ ﺟﻤﻊﻛﻨﻨـﺪة ‪ ٤‬ﺑﻴﺘـﻲ و ﻧﺤـﻮة ﺗﻌﺮﻳـﻒ ﭘﻮرﺗـﻬﺎي آن ﻧﺸـﺎن داده ﺷـــﺪه‬
‫اﺳـﺖ‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫‪fulladd4‬‬
‫‪a‬‬ ‫‪sum‬‬

‫‪b‬‬ ‫;) ‪module fulladd4 ( sum, cout, a, b, cin‬‬

‫‪cin‬‬ ‫‪cout‬‬

‫ﺷﻜﻞ ‪ -٤-١‬ﺟﻤﻊﻛﻨﻨﺪه ‪ ٤‬ﺑﻴﺘﻲ و ﻧﺤﻮه ﺗﻌﺮﻳﻒ ﭘﻮرﺗﻬﺎي آن‬

‫ﺗﻌﺮﻳﻒ ﭘﻮرﺗﻬﺎ‬ ‫‪٢-٤‬‬

‫ﺗﻤﺎم ﭘﻮرﺗﻬﺎي ﻳﻚ ﻣﺎﺟﻮل ﺑﺎﻳﺪ ﺗﻌﺮﻳﻒ ﺷــﻮﻧﺪ‪ .‬اﻳـﻦ ﺗﻌﺮﻳـﻒ ﻃﺒـﻖ ﺟـﺪول ‪ ٤-١‬ﺻـﻮرت ﻣـﻲﮔـﻴﺮد‪.‬‬

‫‪Verilog Keyword‬‬ ‫‪Type of port‬‬

‫‪input‬‬ ‫‪Input Prt‬‬
‫‪output‬‬ ‫‪Output Prt‬‬
‫‪inout‬‬ ‫‪Bidirectional Prt‬‬
‫ﺟﺪول ‪ -٤-١‬ﺗﻌﺮﻳﻒ ﭘﻮرﺗﻬﺎ‬

‫• ﻛﻠﻴﺔ ﭘﻮرﺗﻬﺎ ﺑﻄﻮر ﺿﻤﻨﻲ ﺑﺼﻮرت ‪ wire‬ﺗﻌﺮﻳﻒ ﻣﻲﺷﻮﻧﺪ‪ ،‬ﻣﮕﺮ اﻳﻨﻜــﻪ ﺑﺨﻮاﻫﻴـﻢ‬
‫ﻳﻚ ﺧﺮوﺟﻲ ﻣﻘﺪارش را ﻧﮕﺎهدارد ﻛﻪ در اﻳﻨﺼــﻮرت آﻧـﺮا از ﻧـﻮع ‪ reg‬ﺗﻌﺮﻳـﻒ‬
‫ﻣﻲﻛﻨﻴﻢ‪.‬‬

‫ﺑﻌﻨﻮان ﻣﺜﺎل در ﻣﻮرد ﺟﻤﻊﻛﻨﻨﺪة ﺷــﻜﻞ ‪ ٤-١‬ﺗﻌﺮﻳـﻒ ﭘﻮرﺗـﻬﺎ ﺑﺼـﻮرت زﻳـﺮ اﺳـﺖ‪.‬‬

‫;) ‪module fulladd4( sum, cout, a, b, cin‬‬

‫;‪output [3:0] sum‬‬
‫;‪output cout‬‬

‫;‪input [3:0] a, b‬‬

‫;‪input cin‬‬

‫> ‪< Module Body‬‬

‫‪endmodule‬‬

‫ﻗﻮاﻧﻴﻦ اﺗﺼﺎل ﭘﻮرﺗﻬﺎ‬ ‫‪٣-٤‬‬

‫ﺑﻪ ﻫﻨﮕﺎم اﺗﺼﺎل ﭘﻮرﺗﻬﺎي ﻳﻚ ﻣﺎﺟﻮل ﺑﻪ ﺟــﻬﺎن ﺧـﺎرج ﺑـﺎﻳﺪ ﺑـﻪ ﻧﻜـﺎﺗﻲ ﺗﻮﺟـﻪ داﺷـﺖ ‪:‬‬
‫• ﭘﻮرﺗـﻬﺎي ورودي ﻣـﺎﺟﻮل ﺑـﺎﻳﺪ از ﻧـﻮع ‪ net‬ﺑﺎﺷـﻨﺪ و اﻳـﻦ ﭘﻮرﺗـﻬﺎ ﻣﻲﺗﻮاﻧﻨـﺪ ﺑـﻪ ﻣﺘﻐﻴﺮﻫـــﺎﻳﻲ از ﻧــﻮع‬
‫‪ reg‬و ﻳﺎ ‪ net‬درﺟــﻬﺎن ﺧـﺎرج ﻣﺘﺼـﻞ ﺷـﻮﻧﺪ‪.‬‬
‫• ﭘﻮرﺗﻬﺎي ﺧﺮوﺟﻲ ﻣــﺎﺟﻮل ﻣﻲﺗﻮاﻧﻨـﺪ از ﻧـﻮع ‪ reg‬و ﻳـﺎ ‪ net‬ﺑﺎﺷـﻨﺪ و اﻳـﻦ ﭘﻮرﺗـﻬﺎ ﺑـﺎﻳﺪ ﺑـﻪ ﻣﺘﻐﻴﺮﻫـﺎﻳﻲ‬
‫از ﻧﻮع ‪ net‬درﺟﻬﺎن ﺧــﺎرج ﻣﺘﺼـﻞ ﺷـﻮﻧﺪ‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫• ﭘﻮرﺗـﻬﺎي دوﺳـﻮﻳﺔ ﻣـﺎﺟﻮل ﺑـﺎﻳﺪ از ﻧـﻮع ‪ net‬ﺑﺎﺷـﻨﺪ و اﻳـﻦ ﭘﻮرﺗـﻬﺎ ﻣﻲﺗﻮاﻧﻨـﺪ ﺑـﻪ ﻣﺘﻐﻴﺮﻫـﺎﻳﻲ از ﻧـــﻮع‬
‫‪ reg‬و ﻳﺎ ‪ net‬درﺟــﻬﺎن ﺧـﺎرج ﻣﺘﺼـﻞ ﺷـﻮﻧﺪ‪.‬‬
‫• ﭘﻮرﺗﻬﺎي ﻣﺎﺟﻮل و ﻣﺘﻐﻴﺮﻫﺎي ﺧﺎرﺟﻲ ﻣﺘﺼــﻞ ﺑـﻪ آﻧـﻬﺎ ﺑـﺎﻳﺪ از ﻧﻈـﺮ ﻃـﻮل ﻣﻨﻄﺒـﻖ ﺑﺎﺷـﻨﺪ‪.‬‬
‫در ‪ Verilog‬ﺑﻪ دو ﺻﻮرت ﻣﻲﺗﻮان ارﺗﺒــﺎط ﭘﻮرﺗـﻬﺎ را ﺑـﺎ ﺟـﻬﺎن ﺧـﺎرج ﺑﺮﻗـﺮار ﻧﻤـﻮد ‪:‬‬
‫‪ -١‬اﺗﺼﺎل ﺗﺮﺗﻴﺒـﻲ ‪ :‬در اﻳـﻦ روش ﺑـﻪ ﻫﻨﮕـﺎم ﻧﻤﻮﻧﻪﺳـﺎزي از ﻳـﻚ ﻣـﺎﺟﻮل‪ ،‬ﻣﺘﻐﻴﺮﻫـﺎي ﻣﺘﺼـﻞ ﺑـﻪ ﭘﻮرﺗـﻬﺎ‬
‫را دﻗﻴﻘـﺎ ﺑـﻪ ﻫﻤـﺎن ﺗﺮﺗﻴﺒـﻲ ﻛـﻪ در ﺗﻌﺮﻳـﻒ ﻣـﺎﺟﻮل آﻣﺪهاﻧـﺪ‪ ،‬ﺑﻴـﺎورﻳﻢ‪ .‬در اﻳـﻦ روش اﮔـﺮ ﺑﺨﻮاﻫﻴـﻢ ﻳـﻚ ﭘــﻮرت‬
‫ﺧﺮوﺟﻲ ﺑﻪ ﺟﺎﻳﻲ ﻣﺘﺼــﻞ ﻧﺒﺎﺷـﺪ ﻛﺎﻓﻴﺴـﺖ ﺟـﺎي آن را در ﻟﻴﺴـﺖ ﺧـﺎﻟﻲ ﺑﮕﺬارﻳـﻢ‪.‬‬
‫‪ -٢‬اﺗﺼﺎل از ﻃﺮﻳﻖ ﻧﺎم ‪ :‬در اﻳﻦ روش ﺑــﺮاي اﺗﺼـﺎل ﻫـﺮ ﭘـﻮرت از ﻗـﺎﻟﺐ زﻳـﺮ اﺳـﺘﻔﺎده ﻣﻲﻛﻨﻴـﻢ ‪:‬‬
‫)‪.port_name(external_signal_name‬‬
‫از اﻳﻦ روش وﻗﺘﻲ اﺳﺘﻔﺎده ﻣﻲﻛﻨﻴــﻢ ﻛـﻪ ﺗﻌـﺪاد ﭘﻮرﺗـﻬﺎ زﻳـﺎد ﺑﺎﺷـﺪ و ﺑﺨـﺎﻃﺮ ﺳـﭙﺮدن ﺗﺮﺗﻴـﺐ آﻧـﻬﺎ دﺷـﻮار‬
‫ﺑﺎﺷﺪ‪ .‬در اﻳﻦ روش اﮔﺮ ﺑﺨﻮاﻫﻴﻢ ﻳﻚ ﭘــﻮرت ﺧﺮوﺟـﻲ ﺑـﻪ ﺟـﺎﻳﻲ ﻣﺘﺼـﻞ ﻧﺒﺎﺷـﺪ ﻛﺎﻓﻴﺴـﺖ ﻧـﺎم آن را ﻧﻴـﺎورﻳﻢ‪.‬‬

‫‪//-- First Method --------------------------------------------‬‬

‫;) ‪fulladd4 fa0( s, co, x, y, ci‬‬
‫‪fulladd4 fa0( s,‬‬ ‫;) ‪, x, y, ci‬‬

‫‪//-- Second Method -------------------------------------------‬‬

‫;) )‪fulladd4 fa0( .sum(s), .cout(co), .cin(ci), .a(x), .b(y‬‬
‫;) )‪fulladd4 fa0( .sum(s), .cin(ci), .a(x), .b(y‬‬

‫در ﺷﻜﻞ ‪ ٥-١‬ﻗﻮاﻧﻴﻦ اﺗﺼــﺎل ﭘﻮرﺗـﻬﺎ ﻧﻤـﺎﻳﺶ داده ﺷـﺪه اﺳـﺖ‪.‬‬

‫‪net‬‬

‫‪inout‬‬

‫‪net‬‬
‫‪reg or net‬‬ ‫‪net‬‬ ‫‪reg or net‬‬ ‫‪net‬‬
‫‪input‬‬ ‫‪output‬‬

‫‪module‬‬

‫ﺷﻜﻞ ‪ -٥-١‬ﻗﻮاﻧﻴﻦ اﺗﺼﺎل ﭘﻮرﺗﻬﺎ‬

‫ﻣﺪﻟﺴﺎزي در ﺳﻄﺢ ﮔﻴﺖ‬ ‫‪٥‬‬

‫در ﻣﺪﻟﺴـﺎزي در ﺳـﻄﺢ ﮔﻴـﺖ ﻣـﺪار را ﺑﺼـﻮرت ﻣﺠﻤﻮﻋـﻪاي از ﮔﻴﺘـﻬﺎي ﭘﺎﻳـﻪ ﻛـﻪ ﺑـــﻪ ﻳﻜﺪﻳﮕــﺮ ﻣﺘﺼــﻞ‬
‫ﺷـﺪهاﻧﺪ ﺑﻴـﺎن ﻣﻲﻛﻨﻴـﻢ‪ .‬ﺑـﺮاي اﻳـﻦ ﻣﻨﻈـﻮر ﺑـﺎﻳﺪ اﻧـﻮاع ﮔﻴﺘـﻬﺎي ﭘﺎﻳـﻪاي ﻛـﻪ در ‪ Verilog‬وﺟـﻮد دارﻧـﺪ را ﻣﻌﺮﻓــﻲ‬
‫ﻛﻨﻴـﻢ‪.‬‬

‫ﮔﻴﺘﻬﺎي ﭘﺎﻳﻪ‬ ‫‪١-٥‬‬

‫ﮔﻴﺘﻬﺎي ‪and/or‬‬ ‫‪١-١-٥‬‬

‫ﺟﺪول ﺻﺤـﺖ ﮔﻴﺘـﻬﺎي ﭘﺎﻳـﺔ ‪ and/or‬در ﺷـﻜﻞ ‪ ٦-١‬آﻣـﺪه اﺳـﺖ‪.‬‬
 Verilog ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬

‫ ﻳﻚ ﻣﺎﺟﻮل ﻣﻘﺎﻳﺴﻪﮔﺮ ﭼﻬﺎرﺑﻴﺘﻲ ﺑﻨﺎم‬، ‫• ﺑﺎ اﺗﺼﺎل ﭼﻬﺎر ﻣﻘﺎﻳﺴﻪﮔﺮ ﻳﻚ ﺑﻴﺘﻲ ﻣﻄﺎﺑﻖ ﺷﻜﻞ زﻳﺮ‬
Comparator ‫ ﻓﺮض ﻛﻨﻴﺪ ﻛﻪ ﻣﺎﺟﻮل ﻣﻘﺎﻳﺴﻪﮔﺮ ﻳﻚ ﺑﻴﺘﻲ ﺑﻨـﺎم‬.‫ ﺑﺴﺎزﻳﺪ‬Comparator4
.‫ ﻧﺎﻣﮕﺬاري ﻛﻨﻴﺪ‬im8 ‫ ﺗﺎ‬im0 ‫ ﺳﻴﮕﻨﺎﻟﻬﺎي داﺧﻠﻲ ﻣﻮرد ﻧﻴﺎز را از‬.‫ﻣﻮﺟﻮد اﺳﺖ‬

a[3:0]

b[3:0]
a[0] im0 a[1] im3 a[2] im6 a[3] a_gt_b
a a_gt_b a a_gt_b a a_gt_b a a_gt_b
b[0] b[1] b[2] b[3]
b im1 b im4 b im7 b a_eq_b
a_eq_b a_eq_b a_eq_b a_eq_b
gt
gt gt gt gt
im2 im5 im8 a_lt_b
eq a_lt_b a_lt_b a_lt_b a_lt_b
eq eq eq eq
lt
lt lt lt lt

Comp0 Comp1 Comp2 Comp3

and 0 1 x z or 0 1 x z xor 0 1 x z
0 0 0 0 0 0 0 1 x x 0 0 1 x x
1 0 1 x x 1 1 1 1 1 1 1 0 x x
x 0 x x x x x 1 x x x x x x x
z 0 x x x z x 1 x x z x x x x

nand 0 1 x z nor 0 1 x z xnor 0 1 x z

0 1 1 1 1 0 1 0 x x 0 1 0 x x
1 1 0 x x 1 0 0 0 0 1 0 1 x x
x 1 x x x x x 0 x x x x x x x
z 1 x x x z x 0 x x z x x x x

and/or ‫ ﺟﺪول ﺻﺤﺖ ﮔﻴﺘﻬﺎي ﭘﺎﻳﺔ‬-٦-١ ‫ﺷﻜﻞ‬

and a1( out, in1, in2 ); // and gate with two inputs
or ( z, i1, i2 ); // or gate with two inputs
xor ( z1, i1, i2, i3, i4 ); // xor gate with four inputs
nand nd( o1, i1, i2, i3 ); // nand gate with three inputs
nor ( out, a, b, c ); // nor gate with three inputs
xnor ( y, a, b, c, d ); // xnor gate with four inputs

‫ ﺑـﻪ اﻳـﻦ ﺗﺮﺗﻴـﺐ‬.‫ ﭘﻮرت ﺧﺮوﺟﻲ و ﺑﻘﻴــﺔ ﭘﻮرﺗـﻬﺎ ورودي ﻫﺴـﺘﻨﺪ‬،‫• ﭘﻮرت اول اﻳﻦ ﮔﻴﺘﻬﺎ‬
.‫ﻣﻲﺗﻮان ﮔﻴﺘﻬﺎﻳﻲ ﺑﺎ ﺗﻌﺪاد ورودﻳﻬﺎي دﻟﺨﻮاه داﺷﺖ‬
‫ ﻣﻲﺗﻮان ﻧﺎم ﻧﻤﻮﻧﻪ را ذﻛﺮ ﻧﻜﺮد ) اﻳﻦ اﻣــﺮ‬،‫• ﺑﻪ ﻫﻨﮕﺎم ﻧﻤﻮﻧﻪﺳﺎزي ) اﺳﺘﻔﺎدة ( از اﻳﻦ ﮔﻴﺘﻬﺎ‬
.( ‫ ﺻﺎدق اﺳﺖ‬Verilog ‫در ﻣﻮرد ﺗﻤﺎم اﻟﻤﺎﻧﻬﺎي از ﭘﻴﺶ ﺳﺎﺧﺘﻪ ﺷﺪة‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫ﮔﻴﺘﻬﺎي ‪buf/not‬‬ ‫‪٢-١-٥‬‬

‫ﺟﺪول ﺻﺤــﺖ ﮔﻴﺘـﻬﺎي ﭘﺎﻳـﺔ ‪ buf/not‬در ﺷـﻜﻞ ‪ ٧-١‬آﻣـﺪه اﺳـﺖ‪.‬‬

‫‪ctrl‬‬ ‫‪ctrl‬‬
‫‪buf‬‬ ‫‪out‬‬ ‫‪bufif0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪bufif1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪x‬‬ ‫‪z‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪z‬‬ ‫‪L‬‬ ‫‪L‬‬ ‫‪0‬‬ ‫‪z‬‬ ‫‪0‬‬ ‫‪L‬‬ ‫‪L‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪z‬‬ ‫‪H‬‬ ‫‪H‬‬ ‫‪1‬‬ ‫‪z‬‬ ‫‪1‬‬ ‫‪H‬‬ ‫‪H‬‬
‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬
‫‪z‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪z‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬

‫‪ctrl‬‬ ‫‪ctrl‬‬
‫‪not‬‬ ‫‪out‬‬ ‫‪notif0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪notif1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪x‬‬ ‫‪z‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪z‬‬ ‫‪H‬‬ ‫‪H‬‬ ‫‪0‬‬ ‫‪z‬‬ ‫‪1‬‬ ‫‪H‬‬ ‫‪H‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪z‬‬ ‫‪L‬‬ ‫‪L‬‬ ‫‪1‬‬ ‫‪z‬‬ ‫‪0‬‬ ‫‪L‬‬ ‫‪L‬‬
‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬
‫‪z‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪z‬‬ ‫‪z‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬

‫ﺷﻜﻞ ‪ -٧-١‬ﺟﺪول ﺻﺤﺖ ﮔﻴﺘﻬﺎي ﭘﺎﻳﺔ ‪buf/not‬‬

‫• ﭘﻮرت آﺧﺮ ﮔﻴﺘﻬﺎي ‪ ، not, buf‬ﭘﻮرت ورودي و ﺑﻘﻴﺔ ﭘﻮرﺗﻬﺎ ﺧﺮوﺟﻲ ﻫﺴــﺘﻨﺪ‪ .‬ﺑـﻪ اﻳـﻦ‬
‫ﺗﺮﺗﻴﺐ ﻣﻲﺗﻮان ﮔﻴﺘﻬﺎﻳﻲ ﺑﺎ ﺗﻌﺪاد ﺧﺮوﺟﻴﻬﺎي دﻟﺨﻮاه داﺷﺖ‪.‬‬
‫• در ﻣﻮرد ﮔﻴﺘﻬﺎي دﻳﮕﺮ ﭘﻮرت اول ﺧﺮوﺟﻲ‪ ،‬ﭘﻮرت ﺑﻌﺪي ورودي و ﭘﻮرت ﺳــﻮم ﻛﻨـﺘﺮل‬
‫اﺳﺖ‪.‬‬
‫• ‪ L‬ﺑﻪ ﻣﻌﻨﺎي ‪ 0‬ﻳﺎ ‪ z‬و ‪ H‬ﺑﻪ ﻣﻌﻨﺎي ‪ 1‬ﻳﺎ ‪ z‬ﻣﻲﺑﺎﺷﺪ‪.‬‬

‫;) ‪buf b1 ( o1, o2, i1‬‬ ‫‪// buffer with 2 outputs‬‬

‫;) ‪notif1 ( z_bar, in, ctrl‬‬ ‫‪// not with output control‬‬

‫ﺑـﺮاي ﻃﺮاﺣـﻲ ﻣـﺪار در ﺳـﻄﺢ ﮔﻴـﺖ‪ ،‬اﺑﺘـﺪا ﺑـﺎﻳﺪ آﻧـﺮا ﺑﺼـﻮرت ﻣﺠﻤﻮﻋـــﻪاﻳﻲ از ﮔﻴﺘــﻬﺎي ﭘﺎﻳــﻪ درآورد‪،‬‬
‫ﺳﭙﺲ ﺑﺎ ﺗﻌﺮﻳﻒ ‪ net‬ﻫــﺎي ﻣـﻮرد ﻧﻴـﺎز اﻳـﻦ ﮔﻴﺘـﻬﺎي ﭘﺎﻳـﻪ را ﺑـﻪ ﻳﻜﺪﻳﮕـﺮ ﻣﺘﺼـﻞ ﻧﻤـﻮد‪ ،‬ﺑـﻪ اﻳـﻦ ﻋﻤـﻞ اﺻﻄﻼﺣـﺎ‬
‫‪ Wiring‬ﻳـﺎ ﺳـﻢﺑﻨﺪي ﮔﻔﺘـﻪ ﻣﻲﺷـﻮد‪ .‬اﻛﻨـﻮن ﺑـﺎ ذﻛـﺮ ﭼﻨـﺪ ﻣﺜـﺎل ﻧﺤـﻮة ﻃﺮاﺣـﻲ ﻣـﺪار در ﺳـﻄﺢ ﮔﻴـﺖ را ﺑﻴـــﺎن‬
‫ﻣﻲﻛﻨﻴـﻢ‪.‬‬
‫ﻣﺜﺎل‪ : ١‬ﻳﻚ ﻣﺎﻟﺘﻲﭘﻠﻜﺴــﺮ ‪ ٤‬ﺑـﻪ ‪ ١‬ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‪.‬‬
‫ﺣﻞ ‪ :‬ﻃﺮح ﺷﻤﺎﺗﻴﻚ ﻣــﺪار در ﺳـﻄﺢ ﮔﻴـﺖ و ﻛـﺪ ‪ Verilog‬ﻣﺮﺑـﻮط ﺑـﻪ آن در ﺷـﻜﻞ ‪ ٨-١‬آﻣـﺪه اﺳـﺖ‪.‬‬

‫ﻣﺜﺎل‪ : ٢‬ﻳﻚ ﻣﻘﺎﻳﺴﻪﻛﻨﻨﺪه ﺗﻚ ﺑﻴﺘــﻲ ﻗـﺎﺑﻞ ﺗﻮﺳـﻌﻪ ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‪.‬‬

‫ﺣﻞ ‪ :‬ﻃﺮح ﺷﻤﺎﺗﻴﻚ ﻣــﺪار در ﺳـﻄﺢ ﮔﻴـﺖ و ﻛـﺪ ‪ Verilog‬ﻣﺮﺑـﻮط ﺑـﻪ آن در ﺷـﻜﻞ ‪ ٩-١‬آﻣـﺪه اﺳـﺖ‪.‬‬

‫• ﺑﺎ اﺳﺘﻔﺎده از ﮔﻴﺘﻬﺎي ‪ nand‬ﻳﻚ ﻓﻠﻴﭗﻓﻼپ ﻧﻮع ‪ D‬ﻛﻪ ﺑــﺎ ﻟﺒـﺔ ﺑـﺎﻻروﻧﺪة ‪Clk‬‬
‫ﻋﻤﻞ ﻣﻲﻛﻨﺪ ﺑﺴﺎزﻳﺪ‪ .‬ورودﻳﻬﺎي ﻣﺪار ‪ D, Clk‬و ﺧﺮوﺟﻴﻬﺎي ﻣــﺪار ‪q, q_bar‬‬
‫ﻣﻲﺑﺎﺷﺪ‪.‬‬
 Verilog ‫ﺧﻮدآﻣﻮز زﺑــﺎن ﺗﻮﺻﻴـﻒ ﺳـﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬

// Module 4_to_1 multiplexer.

module mux4_to_1 ( out, io, i1, i2, i3, s1, s0 );
output out;
input io, i1, i2, i3, s1, s0;
i0 y0
s1n
s0n // Internal wire declaration
i1 y1 out wire s0n, s1n, y0, y1, y2, y2;

i2 // Gate instantiations
y2
not ( s1n, s1 );
not ( s0n, s0 );
i3 y3
and ( y0, i0, s1n, s0n );
and ( y1, i1, s1n, s0 );
s1 and ( y2, i2, s1 , s1n );
s0 and ( y3, i3, s1 , s0 );

or ( out, y0, y1, y2, y3 );

endmodule

‫ ﻣﺮﺑﻮﻃﻪ‬Verilog ‫ در ﺳﻄﺢ ﮔﻴﺖ و ﻛﺪ‬١ ‫ ﺑﻪ‬٤ ‫ ﻧﻘﺸﺔ ﺷﻤﺎﺗﻴﻚ ﻣﺎﻟﺘﻲﭘﻠﻜﺴﺮ‬-٨-١ ‫ﺷﻜﻞ‬

//Module 1-bit comparator

a im2 module Comparator( a_gt_b, a_eq_b, a_lt_b,

gt a, b, gt, eq, lt );
im3
b
im0 a_gt_b output a_gt_b, a_eq_b, a_lt_b;
input a, b, gt, eq, lt;
im4
// Internal wire declaration
wire im0,im1,im2,im3,im4,im5,im6,im7,im8,im9;

im5 // Gate instantiation

eq not ( im0, b );
a_eq_b not ( im1, a );
im6 nand ( im2, a, gt );
nand ( im3, gt, im0 );
nand ( im4, a, im0 );
nand ( im5, a, b, eq );
im1
im7 nand ( im6, im0, eq, im1 );
nand ( im7, im1, b );
im8
nand ( im8, im1, lt );
lt
a_lt_b nand ( im9, lt, b );
nand ( a_gt_b, im2, im3, im4 );
im9 nand ( a_eq_b, im5, im6 );
nand ( a_lt_b, im7, im8, im9 );

endmodule

‫ ﻣﺮﺑﻮﻃﻪ‬Verilog ‫ ﻧﻘﺸﺔ ﺷﻤﺎﺗﻴﻚ ﻣﻘﺎﻳﺴﻪﮔﺮ ﺗﻚ ﺑﻴﺘﻲ ﻗﺎﺑﻞ ﺗﻮﺳﻌﻪ در ﺳﻄﺢ ﮔﻴﺖ و ﻛﺪ‬-٩-١ ‫ﺷﻜﻞ‬

‫ﺗﺎﺧﻴﺮ ﮔﻴﺘﻬﺎ‬ ٢-٥

‫ ﻳﻌﻨـﻲ ﺑـﻪ ﻣﺤـﺾ ﺗﻐﻴـﻴﺮ ورودي ﺑـﺪون ﻫﻴـﭻ‬،‫ﺗﺎﻛﻨﻮن ﮔﻴﺘﻬﺎﻳﻲ ﻛــﻪ در ﻧﻈـﺮ ﮔﺮﻓﺘﻴـﻢ ﺣـﺎﻟﺖ اﻳـﺪهآل داﺷـﺘﻨﺪ‬
‫ ﺗﻌﻴﻴـﻦ ﺗــﺎﺧﻴﺮ‬.‫ وﻟـﻲ در ﻣﺪارﻫـﺎي ﻋﻤﻠـﻲ وﺿﻌﻴـﺖ ﺑـﻪ اﻳﻨﺼـﻮرت ﻧﻴﺴـﺖ‬.‫ﺗـﺎﺧﻴﺮي ﺧﺮوﺟـﻲ ﺗﻐﻴـﻴﺮ ﭘﻴـﺪا ﻣﻲﻛـﺮد‬
‫ ﺑـﺎ‬Verilog ‫ ﻣﻘـﺎدﻳﺮ ﺗـﺎﺧﻴﺮ در‬.‫ﺑﺮاي ﮔﻴﺘﻬﺎ اﺟــﺎزه ﻣﻲدﻫـﺪ ﺷﺒﻴﻪﺳـﺎزي ﻣﺪارﻫـﺎ ﺣـﺎﻟﺖ واﻗﻌﻲﺗـﺮي ﺑـﻪﺧﻮد ﺑﮕـﻴﺮد‬
.‫ ﺷــﺮوع ﻣﻲﺷـﻮد‬# ‫ﻋﻼﻣﺖ‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫ﺗﺎﺧﻴﺮﻫﺎي ‪Turn-Off, Fall, Rise‬‬ ‫‪١-٢-٥‬‬

‫• ﻫﺮﮔﻮﻧﻪ ﺗﻐﻴﻴﺮ در ﺧﺮوﺟﻲ ﮔﻴــﺖ از ‪ 0, x, z‬ﺑـﻪ ‪ 1‬ﺑـﺎ ﺗـﺎﺧﻴﺮ ‪ Rise‬اﻧﺠـﺎم ﻣﻲﺷـﻮد‪.‬‬
‫• ﻫﺮﮔﻮﻧﻪ ﺗﻐﻴﻴﺮ در ﺧﺮوﺟﻲ ﮔﻴــﺖ از ‪ 1, x, z‬ﺑـﻪ ‪ 0‬ﺑـﺎ ﺗـﺎﺧﻴﺮ ‪ Fall‬اﻧﺠـﺎم ﻣﻲﺷـﻮد‪.‬‬
‫• ﻫﺮﮔﻮﻧﻪ ﺗﻐﻴﻴﺮ در ﺧﺮوﺟــﻲ ﮔﻴـﺖ ﺑـﻪ ‪ z‬ﺑـﺎ ﺗـﺎﺧﻴﺮ ‪ Turn-Off‬اﻧﺠـﺎم ﻣﻲﺷـﻮد‪.‬‬
‫• اﮔﺮ ﺧﺮوﺟﻲ ﮔﻴﺖ ﺑﻪ ‪ x‬ﺗﻐﻴﻴﺮ وﺿﻌﻴـﺖ ﺑﺪﻫـﺪ‪ ،‬ﻣﻴﻨﻴﻤـﻮم اﻳـﻦ ﺳـﻪ ﺗـﺎﺧﻴﺮ در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـﻮد‪.‬‬
‫• ﺑﻪ ﻫﻨﮕﺎم ﻧﻤﻮﻧﻪﺳــﺎزي از ﮔﻴـﺖ اﮔـﺮ ‪:‬‬
‫• ﻓﻘﻂ ﻳﻚ ﺗﺎﺧﻴﺮ ﻣﺸﺨﺺ ﺷﻮد‪ ،‬اﻳــﻦ ﻣﻘـﺪار ﺑـﺮاي ﺗﻤـﺎم ﺗﺎﺧﻴﺮﻫـﺎ درﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـﻮد‪.‬‬
‫• دوﺗـﺎﺧﻴﺮ ﻣﺸـﺨﺺ ﺷـﻮد‪ ،‬ﺑـﻪ ﺗﺮﺗﻴـﺐ ﺑـﺮاي ﺗﺎﺧﻴﺮﻫـﺎي ‪ Rise‬و ‪ Fall‬در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷــﻮﻧﺪ و‬
‫ﺗﺎﺧﻴﺮ ‪ Turn-Off‬ﺑﺮاﺑﺮ ﻣﻴﻨﻴﻤــﻮم اﻳـﻦ دو ﻣﻘـﺪار در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـﻮد‪.‬‬
‫• ﺳـﻪ ﺗـﺎﺧﻴﺮ ﻣﺸـﺨﺺ ﺷـﻮد‪ ،‬ﺑـﻪ ﺗﺮﺗﻴـﺐ ﺑـــﺮاي ﺗﺎﺧﻴﺮﻫــﺎي ‪ Rise‬و ‪ Fall‬و ‪ Turn-Off‬در ﻧﻈــﺮ‬
‫ﮔﺮﻓﺘﻪ ﻣﻲﺷــﻮﻧﺪ‪.‬‬

‫‪TRise‬‬ ‫‪TFall‬‬
‫‪1‬‬ ‫‪1,x,z‬‬

‫‪0,x,z‬‬ ‫‪0‬‬

‫;) ‪and #(5) ( o1, i1, i2‬‬ ‫‪// Rise=5, Fall=5, Turn-Off=5‬‬
‫;) ‪and #(4,6) ( o1, i1, i2‬‬ ‫‪// Rise=4, Fall=6, Turn-Off=4‬‬
‫;) ‪and #(4,5,6) ( o1, i1, i2‬‬ ‫‪// Rise=4, Fall=5, Turn-Off=6‬‬

‫ﻣﻘﺎدﻳﺮ ‪Min/Typ/Max‬‬ ‫‪٢-٢-٥‬‬

‫در ‪ Verilog‬ﻫـﺮ ﻳـﻚ از ﺗﺎﺧﻴﺮﻫـﺎ داراي ﻳـﻚ ﻣﻘـﺪار ﻣﻴﻨﻴﻤـــﻮم‪ ،‬ﻳــﻚ ﻣﻘــﺪار ﻣﻌﻤﻮﻟــﻲ و ﻳــﻚ ﻣﻘــﺪار‬
‫ﻣﺎﻛﺰﻳﻤﻮم اﺳﺖ‪ .‬اﻳــﻦ ﺗﺎﺧﻴﺮﻫـﺎ داراي ﺷـﻜﻞ ﻛﻠـﻲ ‪ Min : Typ : Max‬ﻫﺴـﺘﻨﺪ‪ .‬اﻧﺘﺨـﺎب ﻳﻜـﻲ از اﻳـﻦ ﺗﺎﺧﻴﺮﻫـﺎ‬
‫در زﻣﺎن اﺟﺮا ﺻــﻮرت ﻣـﻲﮔـﻴﺮد‪ .‬ﻣﺜـﻼ در ﺑﻌﻀـﻲ ﺷﺒﻴﻪﺳـﺎزﻫﺎ وﻗﺘـﻲ اﺟـﺮا ﺑـﺎ ﺳـﻮﺋﻴﭻ ‪ +maxdelay‬اﻧﺠـﺎم ﺷـﻮد‪،‬‬
‫ﺑﺮاي ﺗﻤﺎم ﮔﻴﺘﻬﺎ ﻣﻘــﺪار ﻣـﺎﻛﺰﻳﻤﻮم ﺗﺎﺧﻴﺮﻫـﺎ در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـﻮد‪.‬‬

‫‪// R=Rise Dealy‬‬ ‫‪F=Fall Dealy‬‬ ‫‪T=Turn-Off Delay‬‬

‫‪// One delay is specified‬‬

‫‪// if +mindelay, R = F = T = 4‬‬
‫‪// if +typdelay, R = F = T = 5‬‬
‫‪// if +maxdelay, R = F = T = 6‬‬
‫;) ‪and #(4:5:6) ( o1, i1, i2‬‬

‫‪// Two delays are specified‬‬

‫= ‪// if +mindelay, R = 3, F‬‬ ‫= ‪5, T‬‬ ‫)‪min(3,5‬‬
‫= ‪// if +typdelay, R = 4, F‬‬ ‫= ‪6, T‬‬ ‫)‪min(4,6‬‬
‫= ‪// if +maxdelay, R = 5, F‬‬ ‫= ‪7, T‬‬ ‫)‪min(5,7‬‬
‫‪and #( 4:5:6, 5:6:7 ) ( o1,‬‬ ‫‪i1, i2‬‬ ‫;)‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫‪// Three delays are specified‬‬

‫‪// if +mindelay, R = 2, F = 3,‬‬ ‫= ‪T‬‬ ‫‪4‬‬
‫‪// if +typdelay, R = 3, F = 4,‬‬ ‫= ‪T‬‬ ‫‪5‬‬
‫‪// if +maxdelay, R = 4, F = 5,‬‬ ‫= ‪T‬‬ ‫‪6‬‬
‫( ) ‪and #( 2:3:4, 3:4:5, 4:5:6‬‬ ‫‪o1,‬‬ ‫;) ‪i1, i2‬‬

‫• ﺗﻮﺟﻪ ﻛﻨﻴﺪ ﻛﻪ ﺗﺎﺧﻴﺮ ﮔﻴﺘﻬﺎ ﻓﻘﻂ ﺑﻪ ﻫﻨﮕﺎم ﺷﺒﻴﻪﺳﺎزي ﻣﺪارﻫﺎ ﻣﻔﻴــﺪ ﻫﺴـﺘﻨﺪ‪ ،‬و‬
‫وﻗﺘﻲ ﻫﺪف ﺳﻨﺘﺰ ﻣﺪار ﻣﻲﺑﺎﺷﺪ ﺑﻪ ﻫﻴﭻوﺟﻪ ﻧﺒﺎﻳﺪ از ﺗﺎﺧﻴﺮ در ﺗﻮﺻﻴــﻒ ﻣـﺪار‬
‫اﺳﺘﻔﺎده ﺷﻮد‪.‬‬

‫ﻣﺪﻟﺴﺎزي در ﺳﻄﺢ ﺟﺮﻳﺎن داده‬ ‫‪٦‬‬

‫در ﻣﺪﻟﺴﺎزي در ﺳــﻄﺢ ﺟﺮﻳـﺎن داده ﺑـﻪ ﻧﺤـﻮة اﻧﺘﻘـﺎل اﻃﻼﻋـﺎت ﺑﻴـﻦ ﺛﺒﺎﺗـﻬﺎ و ﭘـﺮدازش اﻃﻼﻋـﺎت اﻫﻤﻴـﺖ‬
‫ﻣﻲدﻫﻴـﻢ‪ .‬در اﻳـﻦ ﻗﺴـﻤﺖ ﺑـﻪ ﭼﮕﻮﻧﮕـــﻲ ﻣﺪﻟﺴــﺎزي در ﺳــﻄﺢ ﺟﺮﻳــﺎن داده در زﺑــﺎن ‪ Verilog‬و ﻣﺰاﻳــﺎي آن‬
‫ﻣﻲﭘﺮدازﻳــﻢ‪.‬‬

‫‪Continuous Assignment‬‬ ‫‪١-٦‬‬

‫ﺗﻮﺳﻂ اﻳﻦ دﺳﺘﻮر ﻣﻲﺗــﻮان ﻳـﻚ ﻣﻘـﺪار را روي ﻳـﻚ ‪ net‬دراﻳـﻮ ﻛـﺮد‪ .‬ﺷـﻜﻞ ﻛﻠـﻲ اﻳـﻦ دﺳـﺘﻮر ﺑﺼـﻮرت‬
‫زﻳﺮ اﺳــﺖ ‪:‬‬
‫;‪assign <signal_strength> <delay> assignment_lists‬‬

‫• در ﻣﻮرد اﻳﻦ دﺳﺘﻮر ﺑﺎﻳﺪ ﺗﻮﺟﻪ داﺷﺖ ﻛﻪ اﻳﻦ دﺳﺘﻮر ﻫﻤﻮاره ﻓﻌﺎل اﺳﺖ و ﻫﺮﮔﺎه ﻳﻜــﻲ از‬
‫اﭘﺮﻧﺪﻫﺎي ﺳﻤﺖ راﺳﺖ دﺳﺘﻮر ﺗﻐﻴﻴﺮ ﻛﻨﺪ‪ ،‬ﻛﻞ ﻋﺒﺎرت ﺳﻤﺖ راﺳﺖ ﻣﺠﺪدا ارزﻳﺎﺑﻲ ﺷﺪه در‬
‫ﻣﺘﻐﻴﺮ ﺳﻤﺖ ﭼﭗ ﻗﺮار ﻣﻲﮔﻴﺮد‪.‬‬
‫• ﺳﻤﺖ ﭼﭗ اﻳﻦ دﺳﺘﻮر ﺑﺎﻳﺪ ﻳﻚ ﻣﺘﻐﻴﺮ ﻳﺎ ﻳﻚ ﺑﺮدار از ﻧﻮع ‪ net‬و ﻳﺎ اﻟﺤﺎﻗﻲ از اﻳﻦ دو ﻧـﻮع‬
‫ﺑﺎﺷﺪ‪.‬‬

‫‪// A dataflow description of a 2 inputs and gate‬‬

‫;) ‪module myand( out, i1, i2‬‬
‫;‪output out‬‬
‫;‪input i1, I2‬‬
‫;‪assign out = i1 & i2‬‬
‫‪endmodule‬‬

‫‪Implicit Continuous Assignment‬‬ ‫‪٢-٦‬‬

‫در اﻳـﻦ روش ﺑﺠـﺎي اﻳﻨﻜـﻪ ﻳـﻚ ﻣﺘﻐـﻴﺮ را از ﺟﻨـﺲ ‪ net‬ﺗﻌﺮﻳـﻒ ﻛﻨﻴـﻢ و ﺳـﭙﺲ ﺗﻮﺳـﻂ دﺳــﺘﻮر ‪assign‬‬
‫ﻳﻚ ﻣﻘﺪار را روي آن دراﻳﻮ ﻛﻨﻴــﻢ‪ ،‬ﻣﻲﺗﻮاﻧﻴـﻢ اﻳـﻦ ﻋﻤـﻞ را در ﻫﻨﮕـﺎم ﺗﻌﺮﻳـﻒ ﻣﺘﻐـﻴﺮ ‪ net‬اﻧﺠـﺎم دﻫﻴـﻢ‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫;‪wire out‬‬
‫;‪assign out = i1 & i2‬‬
‫‪// are same as‬‬
‫;‪wire out = i1 & i2‬‬

‫ﺗﺎﺧﻴﺮﻫﺎ‬ ‫‪٣-٦‬‬
‫ﻫﻤﺎﻧﻄﻮرﻛﻪ در ﺳﻄﺢ ﮔﻴﺖ دﻳﺪﻳــﻢ ﺗﺎﺧﻴﺮﻫـﺎ ﺑـﺮاي اﻳـﻦ اﺳـﺘﻔﺎده ﻣﻲﺷـﻮﻧﺪ ﻛـﻪ ﻋﻤﻠﻜـﺮد ﻣـﺪار ﺑـﻪ واﻗﻌﻴـﺖ‬
‫ﻧﺰدﻳﻜﺘﺮ ﺑﺎﺷﺪ‪ .‬در ﺳﻄﺢ ﺟﺮﻳــﺎن داده ﻧـﻴﺰ ﻣﻲﺗـﻮان ﺑـﺮاي ‪ assignment‬ﻫـﺎ ﺗـﺎﺧﻴﺮ ﻣﺸـﺨﺺ ﻧﻤـﻮد‪.‬‬

‫ﺗﺎﺧﻴﺮ ﺑﺎ ﻗﺎﻋﺪه‬ ‫‪١-٣-٦‬‬

‫در اﻳﻨﺤـﺎﻟﺖ ﻳـﻚ ﺗـﺎﺧﻴﺮ را ﭘـــﺲ از ‪ assign‬و ﻗﺒــﻞ از ‪ net‬ﻣﻲآورﻳــﻢ‪ .‬ﻫــﺮ ﺗﻐﻴــﻴﺮي ﻛــﻪ در ﻳﻜــﻲ از‬
‫ﺳﻴﮕﻨﺎﻟﻬﺎي ﺳﻤﺖ راﺳﺖ رخ دﻫﺪ‪ ،‬ﺑــﺎﻋﺚ ﻣﻲﺷـﻮد ﭘـﺲ از ﮔﺬﺷـﺖ زﻣـﺎن ﺗـﺎﺧﻴﺮ‪ ،‬ﻋﺒـﺎرت ﺳـﻤﺖ راﺳـﺖ ﻣﺠـﺪدا‬
‫ارزﻳﺎﺑﻲ ﺷﻮد و ﺳﭙﺲ در ﻣﺘﻐــﻴﺮ ﺳـﻤﺖ ﭼـﭗ ﻗـﺮار ﮔـﻴﺮد‪ .‬ﺑـﻪ اﻳـﻦ ﺗﺮﺗﻴـﺐ ﺗـﺎﺧﻴﺮي ﻛـﻪ در اﻳﻨﺠـﺎ دارﻳـﻢ‪ ،‬از ﻧـﻮع‬
‫‪ Inertial‬اﺳـﺖ و اﻳـﻦ اﻣـﺮ ﺑـﺎﻋﺚ ﻣﻲﺷـﻮد ﻛـﻪ ﭘﺎﻟﺴـﻬﺎﻳﻲ ﺑـﺎ ﻋـﺮض ﻛﻤـﺘﺮ از ﻣﻘـﺪار ﺗـﺎﺧﻴﺮ ﻣﺸـﺨﺺ ﺷـﺪه ﺑـــﻪ‬
‫ﺧﺮوﺟﻲ ﻣﻨﺘﺸﺮ ﻧﺸﻮد‪ .‬اﻳــﻦ اﻣـﺮ در ﺷـﻜﻞ ‪ ١٠-١‬ﻧﻤـﺎﻳﺶ داده ﺷـﺪه اﺳـﺖ‪.‬‬

‫;) ‪module myand ( o1, i1, i2‬‬ ‫‪i0‬‬

‫;‪output o1‬‬ ‫‪<5‬‬ ‫‪>5‬‬

‫;‪input i1, i2‬‬

‫‪i1‬‬
‫;‪assign #5 o1 = i1 & i2‬‬

‫‪endmodule‬‬
‫‪o1‬‬
‫‪5‬‬

‫ﺷﻜﻞ ‪ -١٠-١‬ﺗﺎﺧﻴﺮ اﻧﺘﺸﺎر ‪Inertial‬‬

‫ﺗﺎﺧﻴﺮ ﺿﻤﻨﻲ‬ ‫‪٢-٣-٦‬‬

‫دراﻳﻨﺤـﺎﻟﺖ ﺗـﺎﺧﻴﺮ و ‪ assignment‬روي ﻳـﻚ ‪ net‬ﺑـﻪ ﻫﻨﮕـﺎم ﺗﻌﺮﻳـﻒ آن ‪ net‬ﻣﺸـﺨﺺ ﻣﻲﺷــﻮد‪.‬‬

‫;‪wire out‬‬
‫;‪assign #5 out = i1 & i2‬‬
‫‪// are same as‬‬
‫;‪wire #5 out = i1 & i2‬‬

‫ﺗﺎﺧﻴﺮ ﺑﻪ ﻫﻨﮕﺎم ﺗﻌﺮﻳﻒ ‪net‬‬ ‫‪٣-٣-٦‬‬

‫دراﻳﻨﺤـﺎﻟﺖ ﺑـﻪ ﻫﻨﮕـﺎم ﺗﻌﺮﻳـﻒ ‪ net‬ﺗـﺎﺧﻴﺮ ﻣـﻮرد ﻧﻈـﺮ را ﺑـــﺮاي آن ﻣﺸــﺨﺺ ﻣﻲﻛﻨﻴــﻢ‪ .‬از اﻳــﻦ ﭘــﺲ‬
‫ﻫﺮﺗﻐﻴﻴﺮي ﻛﻪ روي اﻳﻦ ‪ net‬اﻧﺠﺎم ﺷــﻮد‪ ،‬ﺑـﺎ ﺗـﺎﺧﻴﺮ ﻣﺸـﺨﺺ ﺷـﺪه اﻋﻤـﺎل ﻣﻲﺷـﻮد‪ .‬ﺑـﺎﻳﺪ ﺗﻮﺟـﻪ داﺷـﺖ ﻛـﻪ اﻳـﻦ‬
‫اﻣﺮ در ﻣﻮرد ﻣﺪﻟﺴﺎزي در ﺳﻄﺢ ﮔﻴــﺖ ﻧـﻴﺰ ﻗـﺎﺑﻞ اﺳـﺘﻔﺎده اﺳـﺖ‪.‬‬
 Verilog ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬

wire #5 out;
assign out = i1 & i2;

‫ اﭘﺮاﺗﻮرﻫﺎ و اﭘﺮﻧﺪﻫﺎ‬،‫ﻋﺒﺎرات‬ ٤-٦

.‫ﻳﻚ ﻋﺒـﺎرت از ﺗﺮﻛﻴـﺐ اﭘﺮﻧﺪﻫـﺎ و اﭘﺮاﺗﻮرﻫـﺎ ﺳـﺎﺧﺘﻪ ﻣﻲﺷـﻮد‬ •
.‫ ﺑـﻪ آن اﺷـﺎره ﺷـﺪ‬٢-١ ‫ﻳﻚ اﭘﺮﻧﺪ ﻣﻲﺗﻮاﻧﺪ ﻳﻜــﻲ از اﻧـﻮاع دادهاي ﺑﺎﺷـﺪ ﻛـﻪ در ﺑﺨـﺶ‬ •
‫ ﻟﻴﺴــﺖ‬.‫اﭘﺮاﺗﻮرﻫـﺎ روي اﭘﺮﻧﺪﻫـﺎ ﻋﻤﻠﻴـﺎﺗﻲ را اﻧﺠـﺎم ﻣﻲدﻫﻨـﺪ ﺗـﺎ ﻧﺘﻴﺠـــﺔ ﻣﻄﻠــﻮب ﺑﺪﺳــﺖ آﻳــﺪ‬ •
.‫ آﻣـﺪه اﺳــﺖ‬٥-١ ‫ در ﺟـﺪول‬Verilog ‫اﭘﺮاﺗﻮرﻫـﺎي ﻣﻮﺟـﻮد در‬

Operator Operator Number of

Operation Performed
Type Symbol Operands
* multiply 2
/ division 2
Arithmetic + add 2
- subtract 2
% modulus 2
! logical negation 1
Logical && logical and 2
|| logical or 2
> greater than 2
< less than 2
Relational
>= greater than or equal 2
<= less than or equal 2
== equality 2
!= inequality 2
Equality
=== case equality 2
!== case inequality 2
~ bitwise negation 1
& bitwise and 2
Bitwise | bitwise or 2
^ bitwise xor 2
~^ or ^~ bitwise xnor 2
& reduction and 1
~& reduction nand 1
| reduction or 1
Reduction
~| reduction nor 1
^ reduction xor 1
~^ or ^~ reduction xnor 1
>> right shift 2
Shift
<< left shift 2
{} concatenation any number
Reduction
{ {} } replication any number
Conditional ?: conditional 3
‫ ﺑﺮاي ﻣﺪﻟﺴﺎزي در ﺳﻄﺢ ﺟﺮﻳﺎن داده‬Verilog ‫ ﻟﻴﺴﺖ اﭘﺮاﺗﻮرﻫﺎي‬-٥-١ ‫ﺟﺪول‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫• در ﻣﻮرد اﭘﺮاﺗﻮرﻫﺎي ﺣﺴﺎﺑﻲ ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬

‫• اﮔﺮ ﻫﺮدو اﭘﺮﻧﺪش ﺻﺤﻴﺢ ﺑﺎﺷﺪ‪ ،‬ﺧﺎرجﻗﺴﻤﺖ را ﺑﺮﻣﻲﮔﺮداﻧﺪ‪.‬‬
‫• اﮔﺮﻫﺮﻳﻚ ازاﭘﺮﻧﺪﻫﺎ داراي ﺑﻴﺖ ‪ x‬ﺑﺎﺷﺪ‪ ،‬ﻧﺘﻴﺠﺔ ﻋﻤﻠﻴﺎت ‪ x‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫• ‪ %‬ﺑﺎﻗﻴﻤﺎﻧﺪة ﺗﻘﺴﻴﻢ را ﺑﺮﻣﻲﮔﺮداﻧﺪ و ﻋﻼﻣﺖ ﺣﺎﺻﻞ ﺑﺮاﺑﺮ ﻋﻼﻣﺖ اﭘﺮﻧﺪ اول اﺳﺖ‪.‬‬
‫• ﺑﻬﺘﺮ اﺳﺖ اﻋﺪاد ﻣﻨﻔــﻲ را درﻋﺒـﺎرات ﺑﺼـﻮرت اﻋـﺪاد ﺻﺤﻴـﺢ ﺑﻜـﺎر ﺑـﺮد‪ ،‬زﻳـﺮا در‬
‫ﻏﻴﺮاﻳﻨﺼﻮرت ﺑﻪ ﻣﻜﻤﻞ ‪ ٢‬ﺗﺒﺪﻳﻞ ﻣﻲﺷﻮﻧﺪ ﻛﻪ ﻣﻤﻜﻦ اﺳﺖ ﺑﺎﻋﺚ ﺑﺮوز ﻧﺘﺎﻳﺞ ﻏــﻴﺮﻣﻨﺘﻈﺮه‬
‫ﺷﻮﻧﺪ‪.‬‬

‫;‪A = 4’b0011‬‬ ‫;‪B = 4’b0100‬‬ ‫;‪D = 6‬‬ ‫;‪E = 4‬‬

‫‪A*B‬‬ ‫‪// Evaluated to 4’b1100‬‬
‫‪D/E‬‬ ‫‪// Evaluated to 1‬‬
‫‪A+B‬‬ ‫‪// Evaluated to 4’b0111‬‬
‫‪B-A‬‬ ‫‪// Evaluated to 4’b0001‬‬
‫‪//---------------------------------------------------------‬‬
‫;‪in1 = 4’b101x‬‬ ‫;‪in2 = 4’b1010‬‬
‫;‪sum = in1 + in2‬‬ ‫‪// Evaluated to 4’x‬‬

‫‪//---------------------------------------------------------‬‬
‫‪-7 % 2 // Evaluated to -1, take sign of the first operand‬‬
‫‪7 % -2 // Evaluated to +1, take sign of the first operand‬‬

‫• در ﻣﻮرد اﭘﺮاﺗﻮرﻫﺎي ﻣﻨﻄﻘﻲ ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬

‫• ﻧﺘﻴﺠﺔ اﭘﺮاﺗﻮرﻫﺎي ﻣﻨﻄﻘﻲ ﻳﻚ ﺑﻴﺖ اﺳﺖ ‪ 0 :‬ﻧﺎدرﺳﺖ‪ 1 ،‬درﺳﺖ‪ x ،‬ﻧﺎﻣﻌﻠﻮم‪.‬‬
‫• اﮔﺮ اﭘﺮﻧﺪ ‪ 0‬ﺑﺎﺷﺪ ﻣﻌﺎدل ﻧﺎدرﺳﺖ‪ ،‬اﮔﺮ ‪ 1‬ﺑﺎﺷﺪ ﻣﻌﺎدل درﺳﺖ و اﮔﺮ ‪ x‬ﺑﺎﺷــﺪ‬
‫ﻣﻌﺎدل ﻧﺎﻣﻌﻠﻮم ارزﻳﺎﺑﻲ ﻣﻲﺷﻮد‪.‬‬

‫;‪A = 3‬‬ ‫‪B‬‬ ‫;‪= 0‬‬

‫‪A && B‬‬ ‫‪//‬‬ ‫) ‪Evaluated to 0 ( False‬‬
‫‪A || B‬‬ ‫‪//‬‬ ‫) ‪Evaluated to 1 ( True‬‬
‫‪!A‬‬ ‫‪//‬‬ ‫) ‪Evaluated to 0 ( False‬‬

‫‪//---------------------------------------------------------‬‬
‫;‪A = 2’bx0‬‬ ‫;‪B = 2’b10‬‬
‫) ‪A && B // Evaluated to x ( Unknown‬‬

‫• در ﻣﻮرد اﭘﺮاﺗﻮراﻟﺤﺎق ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬

‫• اﭘﺮﻧﺪﻫﺎ ﺣﺘﻤﺎ ﺑﺎﻳﺪ اﻋﺪاد اﻧﺪازهدار ﺑﺎﺷﻨﺪ ﺗــﺎ ‪ Verilog‬ﻗـﺎدر ﺑـﻪ ﻣﺤﺎﺳـﺒﺔ‬
‫اﻧﺪازة ﻧﺘﻴﺠﻪ ﺑﺎﺷﺪ‪.‬‬
‫• اﭘﺮﻧﺪﻫﺎ ﻣﻲﺗﻮاﻧﻨﺪ ‪ ، reg ، net‬ﺑﺮداري از ‪ reg ، net‬ﻳﺎ اﻋــﺪاد اﻧـﺪازهدار‬
‫ﺑﺎﺷﻨﺪ‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫‪A‬‬ ‫=‬ ‫;‪1’b1‬‬ ‫;‪B = 2’b00‬‬ ‫;‪D = 2’b10‬‬ ‫;‪C = 3’b110‬‬

‫‪y‬‬ ‫=‬ ‫;} ‪{ B, C‬‬ ‫‪// Result y is 4’b0010‬‬
‫‪y‬‬ ‫=‬ ‫;} ‪{ A, B ,C, D, 3’b001‬‬ ‫‪// Result y is 11’b1_00_10_110_001‬‬
‫‪y‬‬ ‫=‬ ‫;} ]‪{ A, b[0], C[1‬‬ ‫‪// Result y is 3’b101‬‬

‫• در ﻣﻮرد اﭘﺮاﺗﻮرﺗﻜﺮار ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬

‫• ﻳﻚ ﺛﺎﺑﺖ ﺗﻜﺮار ﻣﺸﺨﺺ ﻣﻲﻛﻨﺪ ﻛﻪ ﭼﻨﺪﺑﺎر ﻋﺪد داﺧــﻞ }{ ﺑـﺎﻳﺪ ﺗﻜـﺮار‬
‫ﺷﻮد‪.‬‬

‫;‪A = 1’b1‬‬ ‫;‪B = 2’b00‬‬ ‫;‪D = 2’b10‬‬

‫;} }‪y = { 4{A‬‬ ‫‪// Result y is 4’b1111‬‬

‫;} }‪y = { 4{A}, 2{B‬‬ ‫‪// Result y is 8’b11110000‬‬
‫;} ‪y = { 4{A}, 2{B}, C‬‬ ‫‪// Result y is 10’b1111000010‬‬

‫• در ﻣﻮرد اﭘﺮاﺗﻮر ﺷﺮﻃﻲ ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬

‫• ﻗﺎﻟﺐ اﺳﺘﻔﺎده از اﭘﺮاﺗﻮر ﺷﺮﻃﻲ ﺑﺼﻮرت زﻳﺮ اﺳﺖ ‪:‬‬
‫;‪<condition> ? true_exp : false_exp‬‬
‫• ﻋﺒﺎرت ‪ condition‬ﺗﺮزﻳﺎﺑﻲ ﻣﻲﺷﻮد‪ ،‬اﮔــﺮ ﻧﺘﻴﺠـﻪ ﻋﺒـﺎرت ‪ x‬ﺑﺎﺷـﺪ‪ ،‬ﻫـﺮدو‬
‫ﻋﺒﺎرت ‪ true_exp, false_exp‬ﻣﺤﺎﺳﺒﻪ ﺷﺪه و ﺑﻴﺖ ﺑﻪ ﺑﻴﺖ ﺑﺎ ﻫــﻢ ﻣﻘﺎﻳﺴـﻪ‬
‫ﻣﻲﺷﻮﻧﺪ‪ ،‬اﮔﺮ ﺑﻴﺘﻬﺎ ﺑﺎﻫﻢ ﻣﺘﻔــﺎوت ﺑﻮدﻧـﺪ ‪ x‬و درﻏـﻴﺮاﻳﻨﺼﻮرت ﻫﻤـﺎن ﺑﻴـﺖ‬
‫ﺑﺮﮔﺮداﻧﺪه ﻣﻲﺷﻮد‪.‬‬

‫‪// Models functionality of a tri state buffer‬‬

‫;‪assign addr_bus = drive_enable ? addr_out : 32’bz‬‬

‫• در ﻣﻮرد اﭘﺮاﺗﻮرﻫﺎي ﺗﺴﺎوي ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬

‫• ﻧﺘﻴﺠﺔ ‪ a==b‬ﺑﺮاﺑﺮ ‪ 0‬ﻳﺎ ‪ 1‬ﻳﺎ ‪ x‬اﺳﺖ‪ .‬اﮔﺮ ﻳﻚ ﺑﻴﺖ از ﻳﻜﻲ از اﭘﺮﻧﺪﻫﺎ ‪ x‬ﻳﺎ ‪z‬‬
‫ﺑﺎﺷﺪ‪ ،‬ﻧﺘﻴﺠﻪ ‪ x‬ﻣﻲﺷﻮد‪.‬‬
‫• ﻧﺘﻴﺠﺔ ‪ a!=b‬ﺑﺮاﺑﺮ ‪ 0‬ﻳﺎ ‪ 1‬ﻳﺎ ‪ x‬اﺳﺖ‪ .‬اﮔﺮ ﻳﻚ ﺑﻴﺖ از ﻳﻜﻲ از اﭘﺮﻧﺪﻫﺎ ‪ x‬ﻳـﺎ ‪z‬‬
‫ﺑﺎﺷﺪ‪ ،‬ﻧﺘﻴﺠﻪ ‪ x‬ﻣﻲﺷﻮد‪.‬‬
‫• ﻧﺘﻴﺠﺔ ‪ a===b‬ﺑﺮاﺑﺮ ‪ 0‬ﻳﺎ ‪ 1‬اﺳﺖ‪ a .‬و‪ b‬ﺑﻴﺖ ﺑﻪ ﺑﻴﺖ ﺑﺎ ﻫﻢ ﻣﻘﺎﻳﺴﻪ ﻣﻲﺷﻮﻧﺪ‪.‬‬
‫• ﻧﺘﻴﺠﺔ ‪ a!==b‬ﺑﺮاﺑﺮ ‪ 0‬ﻳﺎ ‪ 1‬اﺳﺖ‪ a .‬و‪ b‬ﺑﻴﺖ ﺑﻪ ﺑﻴﺖ ﺑﺎ ﻫﻢ ﻣﻘﺎﻳﺴﻪ ﻣﻲﺷﻮﻧﺪ‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫;‪A = 3‬‬ ‫;‪B = 3‬‬

‫;‪X = 4’b1010‬‬ ‫;‪Y = 4’b1101‬‬
‫;‪Z = 4’b1xzz‬‬ ‫;‪M = 4’b1xzz‬‬ ‫;‪N = 4’b1xxx‬‬

‫‪A‬‬ ‫‪== B‬‬ ‫‪//‬‬ ‫‪Result‬‬ ‫‪is‬‬ ‫‪logical‬‬ ‫‪0‬‬

‫‪A‬‬ ‫‪!= B‬‬ ‫‪//‬‬ ‫‪Result‬‬ ‫‪is‬‬ ‫‪logical‬‬ ‫‪1‬‬
‫‪X‬‬ ‫‪== Z‬‬ ‫‪//‬‬ ‫‪Result‬‬ ‫‪is‬‬ ‫‪x‬‬
‫‪Z‬‬ ‫‪=== M‬‬ ‫‪//‬‬ ‫‪Result‬‬ ‫‪is‬‬ ‫‪logical‬‬ ‫‪1‬‬
‫‪Z‬‬ ‫‪=== N‬‬ ‫‪//‬‬ ‫‪Result‬‬ ‫‪is‬‬ ‫‪logical‬‬ ‫‪0‬‬
‫‪M‬‬ ‫‪!== M‬‬ ‫‪//‬‬ ‫‪Result‬‬ ‫‪is‬‬ ‫‪logical‬‬ ‫‪1‬‬

‫• در ﻣﻮرد اﭘﺮاﺗﻮرﻫﺎي ﻛﺎﻫﺸﻲ )‪ (reduction‬ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬

‫• اﻳﻦ اﭘﺮاﺗﻮرﻫﺎ داراي ﻳﻚ اﭘﺮﻧﺪ ﻫﺴﺘﻨﺪ و ﻋﻤﻠﻴﺎت ﺑﻴﺘﻲ ﻣﺸــﺨﺺ ﺷـﺪه را‬
‫روي ﺗﻚﺗﻚ اﻋﻀﺎي ﺑﺮدار اﭘﺮﻧﺪ آن اﻧﺠــﺎم داده و ﻳـﻚ ﺑﻴـﺖ را ﺑﻌﻨـﻮان‬
‫ﻧﺘﻴﺠﻪ ﺑﺮﻣﻲﮔﺮداﻧﺪ‪.‬‬

‫;‪x = 4’b1010‬‬
‫‪&x‬‬ ‫‪// Equivalent to 1 & 0 & 1 & 0, Result is 1’b0‬‬
‫‪|x‬‬ ‫‪// Equivalent to 1 | 0 | 1 | 0, Result is 1’b0‬‬
‫‪^x‬‬ ‫‪// Equivalent to 1 ^ 0 ^ 1 ^ 0, Result is 1’b0‬‬

‫ﺣـﺎل ﺳـﻌﻲ ﻣﻲﻛﻨﻴـﻢ ﺑـﺎ ذﻛـﺮ ﭼﻨـﺪ ﻣﺜـﺎل ﺑـﻪ ﻧﺤـﻮة ﻣﺪﻟﺴـﺎزي ﻣﺪارﻫـﺎي دﻳﺠﻴﺘـﺎل در ﺳـﻄﺢ ﺟﺮﻳــﺎن داده‬
‫ﺑﭙﺮدازﻳـﻢ‪.‬‬
‫ﻣﺜﺎل‪ : ١‬ﻳﻚ ﻣﺎﻟﺘﻲﭘﻠﻜﺴــﺮ ‪ ٤‬ﺑـﻪ ‪ ١‬ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‪.‬‬

‫‪// Dataflow model of a 4-to-1 multiplexer‬‬

‫;) ‪module mux4_to_1 ( out, i0, i1, i2, i3, s1, s0‬‬
‫;‪output out‬‬
‫;‪input i0, i1, i2, i3, s1, s0‬‬

‫‪// Use nested conditional operator‬‬

‫;) ‪assign out = s1 ? ( s0 ? i3 : i2 ) : ( s0 ? i1 : i0‬‬

‫‪endmodule‬‬

‫ﻣﺜﺎل‪ : ٢‬ﻳﻚ ﺟﻤﻊﻛﻨﻨﺪة ‪ ٤‬ﺑﻴﺘــﻲ ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‪.‬‬

 Verilog ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬

// Dataflow model of a 4-bit full adder

module fulladd4 ( sum, c_out, a, b, c_in );

output [3:0] sum;
output c_out;
input [3:0] a, b;
input c_in;

// Specify the function of a 4-bit full adder

assign { c_out, sum } = a + b + c_in;

endmodule

.‫ ﻳﻚ ﻣﻘﺎﻳﺴﻪﻛﻨﻨﺪه ﺗﻚ ﺑﻴﺘــﻲ ﻗـﺎﺑﻞ ﺗﻮﺳـﻌﻪ ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‬: ٣‫ﻣﺜﺎل‬

// Dataflow model of a cascadable 1-bit comparator

module Comparator ( a_gt_b, a_eq_b, a_lt_b, a, b, gt, eq, lt );

output a_gt_b, a_eq_b, a_lt_b;
input a, b, gt, eq, lt;

// Specify the boolean function of a 1-bit comparator

assign a_gt_b = ( a & gt ) | ( ~b & gt ) | ( a & ~b );
assign a_eq_b = ( a & b & eq ) | ( ~a & ~b & eq );
assign a_lt_b = ( ~a & lt ) | ( b & lt ) | ( ~a & b );

endmodule

‫ ﺑﻴﺘـﻲ را ﻣﺤﺎﺳـﺒﻪ ﻣﻲﻛﻨـﺪ‬٤ ‫ ﻳﻚ ﻋﺪد ﺑــﺎﻳﻨﺮي‬٢ ‫• در ﺷﻜﻞ زﻳﺮ ﻃﺮح ﺷﻤﺎﺗﻴﻚ ﻣﺪاري ﻛﻪ ﻣﻜﻤﻞ‬
.‫ اﻳﻦ ﻣﺪار را در ﺳﻄﺢ ﺟﺮﻳﺎن داده ﺗﻮﺻﻴﻒ ﻛﻨﻴﺪ‬.‫ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‬

a3 a2 a1 a0

c2 c1
c0 C-1=0

a* 3 a* 2 a *1 a* 0
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫ﻣﺪﻟﺴﺎزي در ﺳﻄﺢ رﻓﺘﺎري‬ ‫‪٧‬‬

‫ﺑﻠﻮﻛﻬﺎي ﺳﺎﺧﺖﻳﺎﻓﺘﻪ‬ ‫‪١-٧‬‬

‫در ‪ Verilog‬دو ﺑﻠـﻮك ﺳـﺎﺧﺖﻳﺎﻓﺘﻪ وﺟـﻮد دارد‪ . always, initial ،‬اﻳـــﻦ دﺳــﺘﻮرات ﭘﺎﻳــﺔ ﻣﺪﻟﺴــﺎزي‬
‫در ﺳـﻄﺢ رﻓﺘـﺎري ﻫﺴـﺘﻨﺪ و ﺗﻤـﺎم ﻗﺴـﻤﺘﻬﺎي ﺗﻮﺻﻴـﻒ رﻓﺘـــﺎري ﻣــﺪار در اﻳــﻦ ﺑﻠﻮﻛــﻬﺎي ﺳــﺎﺧﺖﻳﺎﻓﺘﻪ ﻗــﺮار‬
‫ﻣﻲﮔﻴﺮﻧﺪ‪ .‬اﻳﻦ ﺑﻠﻮﻛــﻬﺎ داراي ﺳـﺎﺧﺘﺎر ﺗﺮﺗﻴﺒـﻲ ﻫﺴـﺘﻨﺪ‪.‬‬

‫ﺑﻠﻮك ‪initial‬‬ ‫‪١-١-٧‬‬

‫ﺑﻠـﻮك ‪ initial‬در زﻣـﺎن ‪ 0‬ﺷـﺮوع ﺷـﺪه و ﻓﻘـﻂ ﻳﻜﺒـﺎر در ﺷـﺮوع ﺷﺒﻴﻪﺳـﺎزي اﺟـــﺮا ﻣﻲﺷــﻮد‪ .‬ﭼﻨﺎﻧﭽــﻪ‬
‫ﺑﺨﻮاﻫﻴـﻢ درون ﺑﻠـﻮك ‪ initial‬ﭼﻨﺪﻳـﻦ دﺳـﺘﻮر داﺷـﺘﻪ ﺑﺎﺷـﻴﻢ‪ ،‬ﺑـﺎﻳﺪ ﺑﻮﺳـﻴﻠﺔ ‪ begin end‬آﻧـﻬﺎ را ﺑﻠـــﻮك ﻛﻨﻴــﻢ‪.‬‬
‫ﭼﻨﺎﻧﭽﻪ ﭼﻨﺪﻳــﻦ ﺑﻠـﻮك ‪ initial‬داﺷـﺘﻪ ﺑﺎﺷـﻴﻢ‪ ،‬ﺗﻤـﺎم ﺑﻠﻮﻛـﻬﺎ در زﻣـﺎن ‪ 0‬ﺑﺼـﻮرت ﻫﻤﺰﻣـﺎن اﺟـﺮا ﻣﻲﺷـﻮﻧﺪ و ﻫـﺮ‬
‫ﺑﻠﻮك ﻣﺴﺘﻘﻞ از ﺳﺎﻳﺮ ﺑﻠﻮﻛﻬﺎ ﺧﺎﺗﻤــﻪ ﻣﻲﻳـﺎﺑﺪ‪ .‬اﮔـﺮ ﻗﺒـﻞ از ﻳـﻚ دﺳـﺘﻮر ﺗـﺎﺧﻴﺮي ﻣﺸـﺨﺺ ﺷـﻮد‪ ،‬آن دﺳـﺘﻮر ﭘـﺲ‬
‫از ﺗﺎﺧﻴﺮ ﻣﺸﺨﺺ ﺷﺪه از زﻣــﺎن ﻓﻌﻠـﻲ ﺷﺒﻴﻪﺳـﺎزي اﺟـﺮا ﻣﻲﺷـﻮد‪.‬‬

‫;‪module stimulus‬‬

‫;‪reg a, b, x, y, m‬‬

‫‪initial‬‬
‫;‪m = 1’b0‬‬

‫‪initial‬‬
‫‪begin‬‬
‫;‪#10 x = 1’b0‬‬
‫;‪#10 y = 1’b1‬‬
‫‪end‬‬

‫‪initial‬‬
‫‪begin‬‬
‫;‪#5 a = 1’b1‬‬
‫;‪#10 b = 1’b0‬‬
‫‪end‬‬

‫‪initial‬‬
‫;‪#50 $finish‬‬

‫‪endmodule‬‬

‫‪//‬‬ ‫‪Time‬‬ ‫‪Statement executed‬‬

‫‪//‬‬ ‫‪0‬‬ ‫;‪m = 1’b0‬‬
‫‪//‬‬ ‫‪5‬‬ ‫;‪a = 1’b1‬‬
‫‪//‬‬ ‫‪10‬‬ ‫;‪x = 1’b0‬‬
‫‪//‬‬ ‫‪30‬‬ ‫;‪b = 1’b0‬‬
‫‪//‬‬ ‫‪35‬‬ ‫;‪y = 1’b1‬‬
‫‪//‬‬ ‫‪50‬‬ ‫;‪$finish‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫ﺑﻠﻮك ‪always‬‬ ‫‪٢-١-٧‬‬

‫ﺑﻠـﻮك ‪ always‬در زﻣـﺎن ‪ 0‬ﺷـﺮوع ﺷـﺪه و ﺗﻤـﺎم دﺳـــﺘﻮرات درون آن ﺑﻄــﻮر ﭘﻴﻮﺳــﺘﻪ اﺟــﺮا ﻣﻲﺷــﻮﻧﺪ‬
‫)ﻣـﺎﻧﻨﺪ ﻳـﻚ ﺣﻠﻘـﻪ(‪ .‬اﻳـﻦ دﺳـﺘﻮرات ﺑـﺮاي ﻣﺪﻟﺴـﺎزي ﻳـﻚ ﺑﻠـﻮك از اﻋﻤـﺎل ﻛـﻪ ﻣﺘﻮاﻟﻴـﺎ در ﻳـــﻚ ﻣــﺪار اﻧﺠــﺎم‬
‫ﻣﻲﺷﻮﻧﺪ‪ ،‬ﺑﻜــﺎر ﻣـﻲرود‪.‬‬

‫;‪module clock_gen‬‬

‫;‪reg clk‬‬

‫‪initial‬‬
‫;‪clk = 1’b0‬‬

‫) ‪// Toggle clk every half_cycle ( Period = 20‬‬

‫‪always‬‬
‫;‪#10 clk = ~clk‬‬

‫‪initial‬‬
‫;‪#1000 $finish‬‬

‫‪endmodule‬‬

‫‪Procedural Assignment‬‬ ‫‪٢-٧‬‬

‫اﻳﻦ دﺳﺘﻮر ﻣﻘﺪار ﻳــﻚ ﻣﺘﻐـﻴﺮ ‪ ، reg‬ﺻﺤﻴـﺢ‪ ،‬ﺣﻘﻴﻘـﻲ ﻳـﺎ زﻣـﺎن را ﺗﻐﻴـﻴﺮ ﻣﻲدﻫـﺪ‪ .‬ﻣﻘـﺪار ﺟﺪﻳـﺪ در ﻣﺘﻐـﻴﺮ‬
‫ﺑﺎﻗﻲ ﻣﻲﻣﺎﻧﺪ ﺗﺎ ﻫﻨﮕﺎﻣﻴﻜﻪ ﻳــﻚ دﺳـﺘﻮر دﻳﮕـﺮ ﻣﻘـﺪار آن را ﺗﻐﻴـﻴﺮ دﻫـﺪ‪ .‬ﺳـﻤﺖ ﭼـﭗ اﻳـﻦ ﻋﺒـﺎرت ﻣﻲﺗﻮاﻧـﺪ ﻳﻜـﻲ‬
‫از ﻣﻮارد زﻳﺮ ﺑﺎﺷــﺪ ‪:‬‬
‫ﻳﻚ ﻣﺘﻐﻴﺮ ‪ ، reg‬ﺻﺤﻴﺢ‪ ،‬ﺣﻘﻴﻘــﻲ‪ ،‬زﻣـﺎن ﻳـﺎ ﻋﻨـﺎﺻﺮ ﺣﺎﻓﻈـﻪ‬ ‫•‬
‫ﻳـﻚ ‪ Bit-Select‬از اﻳـﻦ ﻣﺘﻐﻴﺮﻫــﺎ‬ ‫•‬
‫ﻳـﻚ ‪ Part-Select‬از اﻳـﻦ ﻣﺘﻐﻴﺮﻫــﺎ‬ ‫•‬
‫اﻟﺤﺎﻗﻲ از ﻣــﻮارد ﻓـﻮق‬ ‫•‬

‫‪Blocking Assignment‬‬ ‫‪١-٢-٧‬‬

‫اﻳﻦ دﺳﺘﻮرات ﺑﻪ ﻫﻤــﺎن ﺗﺮﺗﻴﺒـﻲ ﻛـﻪ ﻣﺸـﺨﺺ ﺷـﺪهاﻧﺪ اﺟـﺮا ﻣﻲﺷـﻮﻧﺪ‪ ،‬ﻳﻌﻨـﻲ ﺑـﺪون ﻛـﺎﻣﻞ ﺷـﺪن اﺟـﺮاي‬
‫ﻳﻚ دﺳﺘﻮر‪ ،‬دﺳﺘﻮر ﺑﻌﺪي اﺟﺮا ﻧﻤﻲﺷﻮد‪ .‬اﭘﺮاﺗــﻮري ﻛـﻪ ﺑـﺮاي اﻳـﻦ اﻣـﺮ ﺑﻜـﺎر ﻣـﻲرود = اﺳـﺖ‪.‬‬

‫‪initial‬‬
‫‪begin‬‬

‫‪// These statements are executed at time 0 sequentially‬‬

‫;‪x = 0‬‬ ‫;‪y = 1‬‬ ‫;‪z = 1‬‬
‫;‪count = 0‬‬
‫;‪reg_a = 16’h0000; reg_b = reg_a‬‬

‫‪// This statement is executed at time 15‬‬

‫;‪#15 reg_a[2] = 1’b1‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫‪// These statements are executed at time 25 sequentially‬‬

‫;} ‪#10 reg_b[15:13] = { x, y, z‬‬
‫;‪count = count + 1‬‬

‫‪end‬‬

‫‪Nonblocking Assignment‬‬ ‫‪٢-٢-٧‬‬

‫در اﻳﻦ روش ﻛﻠﻴــﺔ دﺳـﺘﻮرات ﺑـﺮاي اﺟـﺮا زﻣـﺎﻧﺒﻨﺪي ﻣﻲﺷـﻮﻧﺪ‪ ،‬ﺑـﺪون اﻳﻨﻜـﻪ ﻣﻨﺘﻈـﺮ ﻛـﺎﻣﻞ ﺷـﺪن اﺟـﺮاي‬
‫ﻳﻚ دﺳﺘﻮر ﺑﺎﺷﻴﻢ‪ .‬اﭘﺮاﺗﻮري ﻛﻪ ﺑــﺮاي اﻳـﻦ اﻣـﺮ ﺑﻜـﺎر ﻣـﻲرود =< اﺳـﺖ‪.‬‬

‫• ﺷﺒﻴﻪﺳﺎز ﻳﻚ دﺳﺘﻮر ‪ Nonblocking‬را ﺑﺮاي اﺟﺮا زﻣﺎﻧﺒﻨﺪي ﻣﻲﻛﻨﺪ‪ ،‬ﺳﭙﺲ ﺑــﻪ دﺳـﺘﻮر‬
‫ﺑﻌﺪي درون ﺑﻠﻮك ﻣﻲﭘﺮدازد‪ ،‬ﺑﺪون اﻳﻨﻜﻪ ﻣﻨﺘﻈﺮ ﻛﺎﻣﻞ ﺷﺪن اﺟﺮاي دﺳﺘﻮر ﻗﺒﻠﻲ ﺷﻮد‪.‬‬
‫• دﺳﺘﻮرات ‪ Nonblocking‬ﻣﻲﺗﻮاﻧﻨﺪ ﺑﺼﻮرت ﻣﺆﺛﺮي ﻫﻤﺰﻣﺎﻧﻲ اﻧﺘﻘﺎل اﻃﻼﻋــﺎت را ﻣـﺪل‬
‫ﻛﻨﻨﺪ‪ ،‬زﻳﺮا ﻧﺘﻴﺠﺔ ﻧﻬﺎﺋﻲ ﺑﻪ ﺗﺮﺗﻴﺐ اﺟﺮاي دﺳﺘﻮرات واﺑﺴﺘﻪ ﻧﻴﺴﺖ‪.‬‬

‫‪initial‬‬
‫‪begin‬‬

‫;‪x = 0‬‬ ‫;‪y = 1‬‬ ‫;‪z = 1‬‬

‫;‪count = 0‬‬
‫;‪reg_a = 16’h0000; reg_b = reg_a‬‬

‫‪// This statement is scheduled to execute after 15 time units‬‬

‫;‪reg_a[2] <= #15 1’b1‬‬

‫‪// This statement is scheduled to execute after 10 time units‬‬

‫;} ‪reg_b[15:13] <= #10 { x, y, z‬‬

‫‪// This statement is scheduled to execute without any delay‬‬

‫;‪count <= count + 1‬‬

‫‪end‬‬

‫ﻛﻨﺘﺮل زﻣﺎن‬ ‫‪٣-٧‬‬

‫در ‪ Verilog‬ﭼﻨﺎﻧﭽــﻪ دﺳــﺘﻮرات ﻛﻨــﺘﺮل زﻣــﺎن ﻣﻮﺟــﻮد ﻧﺒﺎﺷــﺪ‪ ،‬ﺷﺒﻴﻪﺳــﺎزي اﻧﺠــﺎم ﻧﻤﻲﺷــــﻮد‪ .‬در‬
‫‪ Verilog‬ﺳﻪ ﻧــﻮع ﻛﻨـﺘﺮل زﻣـﺎن وﺟـﻮد دارد ‪:‬‬

‫ﻛﻨﺘﺮل زﻣﺎن ﻣﺒﺘﻨﻲ ﺑﺮ ﺗﺎﺧﻴﺮ‬ ‫‪١-٣-٧‬‬

‫در اﻳـﻦ روش ﻳـﻚ ﻋﺒـﺎرت‪ ،‬ﻓﺎﺻﻠـﺔ زﻣـﺎﻧﻲ ﺑﻴـﻦ رﺳـﻴﺪن ﺑـﻪ ﻳـﻚ دﺳـــﺘﻮر ﺗــﺎ اﺟــﺮاي آن را ﻣﺸــﺨﺺ‬
‫ﻣﻲﻛﻨﺪ‪ .‬دو ﻧﻮع ﻛﻨﺘﺮل زﻣﺎن ﻣﺒﺘﻨــﻲ ﺑـﺮ ﺗـﺎﺧﻴﺮ ﻣﻮﺟـﻮد اﺳـﺖ‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫ﻛﻨﺘﺮل ﺗﺎﺧﻴﺮ ﺑﺎ ﻗـﺎﻋﺪه ‪ :‬ﻳـﻚ ﺗـﺎﺧﻴﺮ ﻏـﻴﺮ ﺻﻔـﺮ در ﺳـﻤﺖ ﭼـﭗ دﺳـﺘﻮر آورده ﻣﻲﺷـﻮد‪ .‬دراﻳﻨﺤـﺎﻟﺖ‬ ‫•‬
‫ﻋﺒﺎرت ﺳﻤﺖ راﺳــﺖ ﭘـﺲ از ﮔﺬﺷـﺖ زﻣـﺎن ﺗـﺎﺧﻴﺮ‪ ،‬ﻣﺤﺎﺳـﺒﻪ ﺷـﺪه درون ﻋﺒـﺎرت ﺳـﻤﺖ ﭼـﭗ ﻗـﺮار‬
‫ﻣﻲﮔـﻴﺮد‪.‬‬

‫‪initial‬‬
‫‪begin‬‬
‫;‪x = 0‬‬
‫;‪#10 y = 1‬‬
‫;‪#(4:5:6) q=0‬‬
‫‪end‬‬

‫ﻛﻨـﺘﺮل ﺗـﺎﺧﻴﺮ درون دﺳـﺘﻮر ‪ :‬ﻳـﻚ ﺗـﺎﺧﻴﺮ ﻏـﻴﺮ ﺻﻔـــﺮ در ﺳــﻤﺖ راﺳــﺖ اﭘﺮاﺗــﻮر ‪assignment‬‬ ‫•‬
‫آورده ﻣﻲﺷـﻮد‪ .‬دراﻳﻨﺤـﺎﻟﺖ ﻋﺒـﺎرت ﺳـﻤﺖ راﺳـﺖ در زﻣـﺎن ﻓﻌﻠـﻲ ﻣﺤﺎﺳـﺒﻪ ﺷـﺪه‪ ،‬ﭘـــﺲ از ﮔﺬﺷــﺖ‬
‫زﻣﺎن ﺗﺎﺧﻴﺮ درون ﻋﺒﺎرت ﺳــﻤﺖ ﭼـﭗ ﻗـﺮار ﻣـﻲﮔـﻴﺮد‪.‬‬

‫‪initial‬‬
‫‪begin‬‬
‫;‪x = 0‬‬ ‫;‪z = 0‬‬
‫;‪y = #5 x + z‬‬
‫‪end‬‬
‫‪// Is equivalent to‬‬
‫‪initial‬‬
‫‪begin‬‬
‫;‪x = 0‬‬ ‫;‪z = 0‬‬ ‫;‪temp = x + z‬‬
‫;‪#5 y = temp‬‬
‫‪end‬‬

‫ﻛﻨﺘﺮل زﻣﺎن ﻣﺒﺘﻨﻲ ﺑﺮ روﻳﺪاد‬ ‫‪٢-٣-٧‬‬

‫ﻳﻚ روﻳــﺪاد ﺑـﻪ ﻣﻌﻨـﺎي ﺗﻐﻴـﻴﺮ ﻣﻘـﺪار ﻳـﻚ ‪ reg‬ﻳـﺎ ‪ net‬اﺳـﺖ‪ .‬ﭼـﻬﺎرﻧﻮع ﻛﻨـﺘﺮل زﻣـﺎن ﻣﺒﺘﻨـﻲ ﺑـﺮ روﻳـﺪاد‬
‫وﺟــﻮد دارد‪.‬‬
‫ﻛﻨـﺘﺮل روﻳـﺪاد ﺑـﺎ ﻗـﺎﻋﺪه ‪ :‬ﻋﻼﻣـﺖ @ ﺑـﺮاي ﻣﺸـﺨﺺ ﻛـﺮدن ﻛﻨـﺘﺮل روﻳـﺪاد اﺳـﺘﻔﺎده ﻣﻲﺷــﻮد‪.‬‬ ‫•‬
‫دﺳﺘﻮرات ﻣﻲﺗﻮاﻧﻨــﺪ ﺑـﺎ ﺗﻐﻴـﻴﺮ ﻣﻘـﺪار ﻳـﻚ ﺳـﻴﮕﻨﺎل‪ ،‬ﺑـﺎ ﻟﺒـﺔ ﺑـﺎﻻروﻧﺪه ﻳـﺎ ﭘـﺎﻳﻴﻦ روﻧـﺪة ﻳـﻚ ﺳـﻴﮕﻨﺎل‬
‫اﺟـﺮا ﺷـﻮﻧﺪ‪ .‬ﻟﺒـﺔ ﺑـﺎﻻروﻧﺪه ﺑـﻪ ﻣﻌﻨـﻲ ﻳﻜـﻲ از ﺗﻐﻴـــﻴﺮات ‪ 0 → 1, x , z; x → 1; z → 1‬و ﻟﺒــﺔ‬
‫ﺑـﺎﻻروﻧﺪه ﺑـﻪ ﻣﻌﻨـﻲ ﻳﻜـﻲ از ﺗﻐﻴـﻴﺮات ‪ 1 → 0, x, z; x → 0; z → 0‬ﻣﻲﺑﺎﺷـــﺪ‪.‬‬

‫;‪@(clock) q = d‬‬ ‫‪//‬‬ ‫‪Triggered with any change in clock‬‬

‫;‪@(posedge clock) q = d‬‬ ‫‪//‬‬ ‫‪Triggered positive edge of clock‬‬
‫;‪@(negedge clock) q = d‬‬ ‫‪//‬‬ ‫‪Triggered negative edge of clock‬‬
‫;‪q = @(posedge clock) d‬‬ ‫‪//‬‬ ‫‪d is evaluated immediately and‬‬
‫‪//‬‬ ‫‪assigned to q at negative edge of clock‬‬

‫ﻛﻨﺘﺮل روﻳﺪاد ﺑﺎ ﻧﺎم ‪ Verilog :‬اﻳــﻦ اﻣﻜـﺎن را ﺑـﺮاي ﻣـﺎ ﻓﺮاﻫـﻢ ﺳـﺎﺧﺘﻪ اﺳـﺖ ﻛـﻪ ﻳـﻚ روﻳـﺪاد را‬ ‫•‬
‫ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ و در ﻣﻮﻗــﻊ ﻟـﺰوم آﻧـﺮا ﺗﺮﻳﮕـﺮ ﻛﻨﻴـﻢ‪ .‬ﺗﻌﺮﻳـﻒ روﻳـﺪاد ﺑـﺎ ﻛﻠﻤـﺔ ﻛﻠﻴـﺪي ‪ event‬و ﺗﺮﻳﮕـﺮ‬
‫ﻛﺮدن آن ﺑــﺎ >‪ -‬اﻧﺠـﺎم ﻣﻲﺷـﻮد‪.‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫;‪event rec_data‬‬

‫)‪always @(posedge clock‬‬

‫‪begin‬‬
‫;‪if( last_data_packet ) ->rec_data‬‬
‫‪end‬‬

‫)‪always @(rec_data‬‬
‫;} ]‪data_buf = { data[0] , data[1], data[2], data[3‬‬

‫ﻛﻨﺘﺮل ﭼﻨﺪ روﻳﺪاد ‪ :‬ﮔــﺎﻫﻲ اوﻗـﺎت ﭼﻨـﺪ ﺳـﻴﮕﻨﺎل دارﻳـﻢ ﻛـﻪ ﺗﻐﻴـﻴﺮ در ﻳﻜـﻲ از آﻧـﻬﺎ ﺳـﺒﺐ ﺗﺮﻳﮕـﺮ‬ ‫•‬
‫ﺷﺪن اﺟﺮاي ﻳﻚ ﻣﺠﻤﻮﻋــﻪ از دﺳـﺘﻮرات ﻣﻲﺷـﻮد‪ .‬اﻳـﻦ اﻣـﺮ ﺗﻮﺳـﻂ ‪ or‬ﻛـﺮدن روﻳﺪادﻫـﺎ ﻳـﺎ ﺳـﻴﮕﻨﺎﻟﻬﺎ‬
‫اﻧﺠﺎم ﻣﻲﺷﻮد‪ .‬ﻟﻴﺴﺖ روﻳــﺪادا ﻳـﺎ ﺳـﻴﮕﻨﺎﻟﻬﺎ ﺑـﻪ ‪ Sensitivity List‬ﻣﺸـﻬﻮر اﺳـﺖ‪.‬‬

‫)‪always @(posedge clock or reset‬‬

‫‪begin‬‬
‫;‪if( reset ) q = 0‬‬
‫;‪else q = d‬‬
‫‪end‬‬

‫ﻛﻨﺘﺮل ﺣﺴﺎس ﺑﻪ ﺳﻄﺢ‬ ‫‪٣-٣-٧‬‬

‫‪ Verilog‬داراي اﻳـﻦ ﻗـﺎﺑﻠﻴﺖ اﺳـﺖ ﻛـﻪ اﺟـﺮاي ﻳـﻚ دﺳـﺘﻮر را ﺗـﺎ ﺗﺤﻘـﻖ ﻳـﻚ ﺷـﺮط ﺧﺎص ﺑـﻪ ﺗﻌﻮﻳــﻖ‬
‫ﺑﻴﺎﻧﺪازﻳﻢ‪ ،‬اﻳﻦ اﻣــﺮ ﺗﻮﺳـﻂ دﺳـﺘﻮر ‪ wait‬اﻧﺠـﺎم ﻣﻲﺷـﻮد‪.‬‬

‫‪always‬‬
‫;‪wait( count_enable ) #20 count = count + 1‬‬

‫دﺳﺘﻮر ﺷﺮﻃﻲ‬ ‫‪٤-٧‬‬

‫) ‪if( expr‬‬
‫‪true_st‬‬
‫‪else‬‬
‫;‪false_st‬‬

‫دﺳﺘﻮر ‪case‬‬ ‫‪٥-٧‬‬

‫‪case ( expr‬‬ ‫)‬

‫‪case 1 :‬‬ ‫;‪st1‬‬
‫‪case 2 :‬‬ ‫;‪st2‬‬
‫‪...‬‬
‫‪case n :‬‬ ‫;‪stn‬‬
‫‪defult :‬‬ ‫;‪def_st‬‬
‫‪endcase‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫• ﻋﺒﺎرت ‪ expr‬ﺑﺎ ﺗﻚﺗﻚ ﻣﻮارد ﺑﻴﺖ ﺑﻪ ﺑﻴﺖ ﻣﻘﺎﻳﺴﻪ ﻣﻲﺷﻮد )ﺑﺎ در ﻧﻈﺮﮔﺮﻓﺘﻦ ‪.( x, 1, 0‬‬
‫• اﮔﺮ ﻃﻮل ﻋﺒﺎرت ﺑﺎ ﻣﻮارد ﻣﻮرد ﻣﻘﺎﻳﺴﻪ ﻳﻜﺴﺎن ﻧﺒﺎﺷﺪ‪ ،‬ﺳﻤﺖ ﭼﭗ ﺟﺰء ﻛﻮﭼﻜﺘﺮ ﺑﺎ ‪ ٠‬ﭘﺮ‬
‫ﻣﻲﺷﻮد‪.‬‬
‫• درﺻﻮرت اﺳﺘﻔﺎده از ‪ casex‬ﻣﻘﺎدﻳﺮ ‪ z, x‬ﺑﺼﻮرت ﺑﻲاﻫﻤﻴــﺖ )‪ (d’ont care‬ﺗﻠﻘـﻲ‬
‫ﻣﻲﺷﻮﻧﺪ ﻳﻌﻨﻲ در ﻣﻘﺎﻳﺴﻪ ﻧﻘﺸﻲ ﻧﺪارﻧﺪ‪.‬‬
‫• درﺻﻮرت اﺳﺘﻔﺎده از ‪ casez‬ﻣﻘﺪار ‪ z‬ﺑﺼﻮرت ﺑﻲاﻫﻤﻴﺖ )‪ (d’ont care‬ﺗﻠﻘﻲ ﻣﻲﺷﻮد‬
‫ﻳﻌﻨﻲ در ﻣﻘﺎﻳﺴﻪ ﻧﻘﺸﻲ ﻧﺪارد‪.‬‬

‫ﺣﻠﻘﻪﻫﺎ‬ ‫‪٦-٧‬‬

‫) ‪while( expr‬‬
‫;‪st‬‬

‫‪//---------------------------------------‬‬
‫) ‪for( init; end_cond; chang_control_var‬‬
‫;‪st‬‬

‫‪//---------------------------------------‬‬
‫) ‪repeat( number_of_iteration‬‬
‫;‪st‬‬

‫‪//---------------------------------------‬‬
‫‪forever‬‬
‫;‪st‬‬

‫‪Tasks and Functions‬‬ ‫‪٧-٧‬‬

‫‪ Task‬و ﺗﺎﺑﻊ داراي ﺗﻔﺎوﺗــﻬﺎﻳﻲ ﻫﺴـﺘﻨﺪ ﻛـﻪ در ﺟـﺪول ‪ ٦-١‬ﻧﺸـﺎن داده ﺷـﺪه اﺳـﺖ‪.‬‬

‫‪Task‬‬ ‫‪١-٧-٧‬‬
‫ﺑﻮﺳﻴﻠﺔ ‪ task ... endtask‬ﻣﺸــﺨﺺ ﻣﻲﺷـﻮد‪ .‬ﻣﻌﻤـﻮﻻ در ﻣـﻮارد زﻳـﺮ اﺳـﺘﻔﺎده ﻣﻲﺷـﻮد‪.‬‬
‫در ﭘﺮوﺳﻴﺠﺮ ﺗﺎﺧﻴﺮ‪ ،‬زﻣﺎﻧﺒﻨﺪي و ﻳــﺎ ﻛﻨـﺘﺮل زﻣـﺎن وﺟـﻮد داﺷـﺘﻪ ﺑﺎﺷـﺪ‪.‬‬ ‫•‬
‫ﭘﺮوﺳﻴﺠﺮ ﭘﺎراﻣﺘﺮ ﺧﺮوﺟﻲ ﻧﺪاﺷﺘﻪ ﺑﺎﺷــﺪ و ﻳـﺎ ﺑﻴـﺶ از ﻳـﻚ ﭘـﺎراﻣﺘﺮ ﺧﺮوﺟـﻲ داﺷـﺘﻪ ﺑﺎﺷـﺪ‪.‬‬ ‫•‬
‫ﭘﺮوﺳﻴﺠﺮ ﻫﻴــﭻ ﭘـﺎراﻣﺘﺮ ورودي ﻧﺪاﺷـﺘﻪ ﺑﺎﺷـﺪ‪.‬‬ ‫•‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫‪Function‬‬ ‫‪Task‬‬
‫ﻳﻚ ﺗﺎﺑﻊ ﻓﻘﻂ ﻣﻲﺗﻮاﻧﺪ ﺗﻮاﺑﻊ دﻳﮕﺮ را ﻓﻌﺎل ﻛﻨﺪ‪.‬‬ ‫ﻳﻚ ‪ task‬ﻣﻲﺗﻮاﻧﺪ ﺗﻮاﺑﻊ و ‪ task‬ﻫﺎي دﻳﮕﺮ را ﻓﻌﺎل ﻛﻨﺪ‪.‬‬
‫ﻳﻚ ﺗﺎﺑﻊ ﻫﻤﻴﺸﻪ در زﻣﺎن ‪ 0‬اﺟﺮا ﻣﻲﺷﻮد‪.‬‬ ‫ﻳﻚ ‪ task‬ﻣﻤﻜﻦ اﺳﺖ در زﻣﺎن ‪ 0‬اﺟﺮا ﻣﻲﺷﻮد‪.‬‬
‫ﻳﻚ ﺗﺎﺑﻊ ﻧﻤﻲﺗﻮاﻧﺪ ﺗﺎﺧﻴﺮ‪ ،‬روﻳﺪاد و ﻳﺎﻛﻨﺘﺮل زﻣﺎن داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫ﻳﻚ ‪ task‬ﻣﻲﺗﻮاﻧﺪ ﺗﺎﺧﻴﺮ‪ ،‬روﻳﺪاد و ﻳﺎﻛﻨﺘﺮل زﻣﺎن داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫ﻳﻚ ﺗﺎﺑﻊ ﺣﺪاﻗﻞ ﺑﺎﻳﺪ ﻳﻚ آرﮔﻮﻣﺎن ورودي داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫ﻳﻚ ‪ task‬ﻣﻲﺗﻮاﻧﺪ آرﮔﻮﻣﺎﻧﻬﺎي ورودي‪ ،‬ﺧﺮوﺟﻲ ﻳﺎ دوﺳﻮﻳﻪ‬
‫داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫ﻳﻚ ﺗﺎﺑﻊ ﻫﻤﻴﺸﻪ ﻣﻘﺪار ﺑﺎزﮔﺸﺘﻲ دارد‪.‬‬ ‫ﻳﻚ ‪ task‬ﻧﻤﻲﺗﻮاﻧﺪ ﻣﻘﺪار ﺑﺎزﮔﺸﺘﻲ داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫ﺟﺪول ‪ -٦-١‬ﺗﻔﺎوﺗﻬﺎي ‪ Task‬و ﺗﺎﺑﻊ‬

‫;‪module operation‬‬
‫;‪reg [15:0] A, B‬‬
‫;‪reg [15:0] AB_AND, AB_OR, AB_XOR‬‬

‫‪always @(A or B) //whenever A or B changes in value‬‬

‫;)‪bitwise_oper(AB_AND, AB_OR, AB_XOR, A, B‬‬

‫‪// Define task bitwise_oper‬‬

‫;‪task bitwise_oper‬‬
‫;‪output [15:0] ab_and, ab_or, ab_xor‬‬ ‫‪//outputs from the task‬‬
‫;‪input [15:0] a, b‬‬ ‫‪//inputs to the task‬‬
‫‪begin‬‬
‫;‪#20 ab_and = a & b‬‬
‫;‪ab_or = a | b‬‬
‫;‪ab_xor = a ^ b‬‬
‫‪end‬‬
‫‪endtask‬‬

‫‪endmodule‬‬

‫‪Function‬‬ ‫‪٢-٧-٧‬‬
‫ﺑﻮﺳﻴﻠﺔ ‪ function ... endfunction‬ﻣﺸـﺨﺺ ﻣﻲﺷـﻮد‪ .‬ﻣﻌﻤـﻮﻻ در ﻣـﻮارد زﻳـﺮ اﺳـﺘﻔﺎده ﻣﻲﺷـﻮد‪.‬‬
‫در ﭘﺮوﺳﻴﺠﺮ ﺗﺎﺧﻴﺮ‪ ،‬زﻣﺎﻧﺒﻨﺪي و ﻳــﺎ ﻛﻨـﺘﺮل زﻣـﺎن وﺟـﻮد ﻧﺪاﺷـﺘﻪ ﺑﺎﺷـﺪ‪.‬‬ ‫•‬
‫ﭘﺮوﺳﻴﺠﺮ ﻳﻚ ﭘــﺎراﻣﺘﺮ ﺧﺮوﺟـﻲ داﺷـﺘﻪ ﺑﺎﺷـﺪ‪.‬‬ ‫•‬
‫ﭘﺮوﺳﻴﺠﺮ ﺣﺪاﻗــﻞ ﻳـﻚ ﭘـﺎراﻣﺘﺮ ورودي داﺷـﺘﻪ ﺑﺎﺷـﺪ‪.‬‬ ‫•‬

‫;‪function calc_parity‬‬
‫;‪input [31:0] address‬‬
‫‪begin‬‬

‫‪// set the output value appropriately. Use the implicit‬‬

‫‪// internal register calc_parity.‬‬
‫‪calc_parity = ^address; //Return the ex-or of all address bits.‬‬
‫‪end‬‬
‫‪endfunction‬‬
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫ﻃﺮاﺣﻲ ﻣﺪارﻫﺎي ﺗﺮﻛﻴﺒﻲ در ﺳﻄﺢ رﻓﺘﺎري‬ ‫‪٨-٧‬‬

‫ﺑﺮاي ﻃﺮاﺣــﻲ ﻣﺪارﻫـﺎي ﺗﺮﻛﻴﺒـﻲ در ﺳـﻄﺢ رﻓﺘـﺎري‪ ،‬ﺑـﺎﻳﺪ ﺗﻤـﺎم وروديﻫـﺎي ﻣـﺪار را در ﻟﻴﺴـﺖ ﺣﺴـﺎس‬
‫ﺑﺪﻧﻪي ‪ always‬ذﻛﺮ ﻛﺮد‪ .‬ﺑــﻪ ﻫﻨﮕـﺎم ﺗﻮﺻﻴـﻒ ﻣـﺪار ﺑـﺎﻳﺪ ﺗﻮﺟـﻪ داﺷـﺖ ﻛـﻪ ﺗﻤـﺎم ﺷـﺮطﻫﺎي ‪ if‬ﺑـﺎﻳﺪ داراي ‪else‬‬
‫ﺑﺎﺷﻨﺪ ﺗﺎ از اﻳﺠﺎد ﻣﺪار ﺗﺮﺗﻴﺒــﻲ ﺟﻠـﻮﮔـﻴﺮي ﺷـﻮد‪.‬‬
‫ﻣﺜﺎل ‪ :‬ﻳﻚ ﻣﺎﻟﺘﻲﭘﻠﻜﺴــﺮ ‪ ٤‬ﺑـﻪ ‪ ١‬ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‪.‬‬

‫‪// Behavioral model of a 4-to-1 multiplexer‬‬

‫;) ‪module mux4_to_1 ( out, i0, i1, i2, i3, s1, s0‬‬
‫;‪output out‬‬
‫;‪reg out‬‬
‫;‪input i0, i1, i2, i3, s1, s0‬‬

‫) ‪always @( i0 or i1 or i2 or i3 or s1 or s0‬‬
‫‪begin‬‬
‫} ‪case { s1, s0‬‬
‫;‪2’b00 : out = i0‬‬
‫;‪2’b01 : out = i1‬‬
‫;‪2’b10 : out = i2‬‬
‫;‪2’b11 : out = i3‬‬
‫;‪defualt : out = 1’bx‬‬
‫‪endcase‬‬
‫‪end‬‬

‫‪endmodule‬‬

‫ﻃﺮاﺣﻲ ﻣﺪارﻫﺎي ﺗﺮﺗﻴﺒﻲ در ﺳﻄﺢ رﻓﺘﺎري‬ ‫‪٩-٧‬‬

‫ﻃﺮاﺣﻲ ﻣﺪارﻫﺎي ﺗﺮﺗﻴﺒﻲ را ﺑــﺎ اﺳـﺘﻔﺎده از ﭼﻨـﺪ ﻣﺜـﺎل ﺑﻴـﺎن ﻣﻲﻛﻨﻴـﻢ‪.‬‬
‫ﻣﺜﺎل ‪ : ١‬ﻳﻚ ‪ D-FF‬ﺣﺴﺎس ﺑــﻪ ﻟﺒـﻪي ﺑـﺎﻻروﻧﺪه ﺑـﺎ ‪ reset‬ﺳـﻨﻜﺮون ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‪.‬‬

‫‪// Behavioral model of a d-ff with synchronous reset‬‬

‫;) ‪module d_ff ( d, clk, rst, q‬‬

‫;‪input d, clk, rst‬‬
‫;‪output q‬‬
‫;‪reg q‬‬

‫) ‪always @( posedge clk‬‬

‫‪begin‬‬
‫)‪if (rst‬‬
‫;‪q = 1’b0‬‬
‫‪else‬‬
‫;‪q = d‬‬
‫‪end‬‬

‫‪endmodule‬‬

‫ﻣﺜﺎل ‪ : ٢‬ﻳﻚ ‪ D-FF‬ﺣﺴﺎس ﺑــﻪ ﻟﺒـﻪي ﺑـﺎﻻروﻧﺪه ﺑـﺎ ‪ reset‬آﺳـﻨﻜﺮون ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‪.‬‬
 Verilog ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬

// Behavioral model of a d-ff with asynchronous reset

module d_ff ( d, clk, rst, q );

input d, clk, rst;
output q;
reg q;

always @( posedge clk or posedge rst)

begin
if (rst)
q = 1’b0;
else
q = d;
end

endmodule

‫ آﺳــﻨﻜﺮون ﻃﺮاﺣــﻲ‬rst ‫ و ﭘﺎﻳــﻪي‬ld, u_d ‫ ﺑﻴﺘـﻲ ﺑـﺎ ﭘﺎﻳـﻪﻫﺎي ﺳـﻨﻜﺮون‬٤ ‫ ﻳـﻚ ﺷـﻤﺎرﻧﺪهي‬: ٣ ‫ﻣﺜـﺎل‬
.‫ ﻛـﺎر ﻛﻨـﺪ‬clk ‫ﻛﻨﻴﺪ ﻛﻪ ﺑﺎ ﻟﺒــﻪي ﭘـﺎﻳﻴﻦروﻧﺪهي‬

// Behavioral model of a up/down counter

module counter ( clk, ld, rst, u_d, d_in, q );

input clk, ld, rst, u_d;
input [3:0] d_in;
output [3:0] q;
reg [3:0] q;

always @( negedge clk or posedge rst)

begin
if (rst)
q = 4’b0000;
else if( ld )
q = d_in;
else if( u_d )
q = q + 1;
else
q = q – 1;
end

endmodule

.‫ دﻳـﺎﮔـﺮام ﺣـﺎﻟﺖ زﻳـﺮ را ﻣﺪﻟﺴـﺎزي ﻛﻨﻴـﺪ‬:(mealy ‫ )ﻃﺮاﺣﻲ دﻳﺎﮔﺮام ﺣــﺎﻟﺖ‬٤ ‫ﻣﺜﺎل‬

1/0
0/0 init got1

0/0
1/0

0/1

got11 1/0
 Verilog ‫ﺧﻮدآﻣﻮز زﺑــﺎن ﺗﻮﺻﻴـﻒ ﺳـﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬

// Mealy state machine

`define init 2'd0

`define got1 2'd1
`define got11 2'd2

module seq_detector ( clk, x, rst, y );

input clk, x, rst;
output y;

reg [1:0] cur_state;

always @( posedge clk )

begin
if ( rst )
cur_state = `init;
else case ( cur_state )
`init : cur_state = x ? `got1 : `init;
`got1 : cur_state = x ? `got11 : `init;
`got11 : cur_state = x ? `got11 : `init;
endcase
end

assign y = (cur_state==`got11 && x==1’b0) ? 1’b1 : 1’b0;

endmodule

.‫ را ﺑـﺎ اﺳـﺘﻔﺎده از ﻣـﺪل ﻫـﺎﻓﻤﻦ ﻣﺪﻟﺴـﺎزي ﻛﻨﻴـﺪ‬٤ ‫ دﻳﺎﮔﺮام ﺣﺎﻟﺖ ﻣﺜــﺎل‬: ٥ ‫ﻣﺜﺎل‬

// Mealy state machine (Hufmann Model)

`define init 2'd0

`define got1 2'd1
`define got11 2'd2

module seq_detector ( clk, x, rst, y );

input clk, x, rst;
output y;

reg [1:0] present_state, next_state;

always @( posedge clk )

if(rst)
present_state = `init;
else
present_state = next_state;

always @( present_state or x )
begin
case ( present_state )
`init : next_state = x ? `got1 : `init;
`got1 : next_state = x ? `got11 : `init;
`got11 : next_state = x ? `got11 : `init;
endcase
end

assign y = (present_state==`got11 && x==1’b0) ? 1’b1 : 1’b0;

endmodule
 Verilog ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬

.‫ دﻳـﺎﮔـﺮام ﺣـﺎﻟﺖ زﻳـﺮ را ﻣﺪﻟﺴـﺎزي ﻛﻨﻴـﺪ‬:(moore ‫ )ﻃﺮاﺣﻲ دﻳﺎﮔﺮام ﺣــﺎﻟﺖ‬٦ ‫ﻣﺜﺎل‬

init 1 got1
0
0 0
0/0
0 1
1

got110 0 got11
1
1 0

// Moore state machine

`define init 2'd0

`define got1 2'd1
`define got11 2'd2
`define got110 2'd3

module seq_detector ( clk, x, rst, y );

input clk, x, rst;
output y;

reg [1:0] cur_state;

always @( posedge clk )

begin
if ( rst )
cur_state = `init;
else case ( cur_state )
`init : cur_state = x ? `got1 : `init;
`got1 : cur_state = x ? `got11 : `init;
`got11 : cur_state = x ? `got11 : `got110;
`got110 : cur_state = x ? `got1 : `init;
endcase
end

assign y = (cur_state==`got110) ? 1’b1 : 1’b0;

endmodule

.‫ را ﺑـﺎ اﺳـﺘﻔﺎده از ﻣـﺪل ﻫـﺎﻓﻤﻦ ﻣﺪﻟﺴـﺎزي ﻛﻨﻴـﺪ‬٦ ‫ دﻳﺎﮔﺮام ﺣﺎﻟﺖ ﻣﺜــﺎل‬: ٧ ‫ﻣﺜﺎل‬

// Moore state machine (Hufmann Model)

`define init 2'd0

`define got1 2'd1
`define got11 2'd2
`define got110 2'd3

module seq_detector ( clk, x, rst, y );

input clk, x, rst;
output y;

reg [1:0] present_state, next_state;

always @( posedge clk )

if(rst)
present_state = `init;
else
present_state = next_state;
 Verilog ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬
always @( present_state or x )
begin
case ( present_state )
`init : next_state = x ? `got1 : `init;
`got1 : next_state = x ? `got11 : `init;
`got11 : next_state = x ? `got11 : `got110;
`got110 : next_state = x ? `got1 : `init;
endcase
end

assign y = (present_state==`got110) ? 1’b1 : 1’b0;

endmodule

‫ ﻓـﺮض ﻛﻨﻴـﺪ در ﻳـﻚ ﺳﻴﺴـﺘﻤﻲ ﻳـﻚ ﭘﺮوﺳـﺲ ﺗﻮﻟﻴـﺪ ﻛﻨﻨـﺪه و ﻳـﻚ ﭘﺮوﺳـﺲ ﻣﺼـــﺮف ﻛﻨﻨــﺪه‬: ٨‫ﻣﺜـﺎل‬
‫ ﺳﻴﺴــﺘﻢ ﺑــﻪ‬.‫ ﺑﻴـﻦ اﻳـــﻦ دو ﭘﺮوﺳــﺲ را ﺑــﻪ ﻧﻮﻋــﻲ ﻣﺪﻟﺴــﺎزي ﻛﻨﻴــﻢ‬Handshake ‫ ﻣﻲﺧﻮاﻫﻴـﻢ‬.‫وﺟـﻮد دارد‬
‫ ﭘﺮوﺳـﺲ ﻣﺼـﺮف ﻛﻨﻨـﺪه اﻳــﻦ‬،‫اﻳﻨﺼـﻮرت ﻋﻤـﻞ ﻣﻲﻛﻨـﺪ ﻛـﻪ اﺑﺘـﺪا ﭘﺮوﺳـﺲ ﺗﻮﻟﻴﺪﻛﻨﻨـﺪه دادهاي را ﺗﻮﻟﻴـﺪ ﻣﻲﻛﻨـﺪ‬
‫ ﭘﺮوﺳــﺲ ﺗﻮﻟﻴﺪﻛﻨﻨــﺪه دادة‬،‫ ﻣﺎداﻣﻴﻜـﻪ ﭘﺮوﺳـﺲ ﻣﺼـﺮف ﻛﻨﻨـﺪه داده را ﻣﺼـﺮف ﻧﻜـــﺮده‬.‫داده را ﻣﺼـﺮف ﻣﻲﻛﻨـﺪ‬
.‫ﺑﻌﺪي را ﺗﻮﻟﻴــﺪ ﻧﻤﻲﻛﻨـﺪ‬

module producer( dataOut, prodReady, consReady )

output [7:0] dataOut;
output prodReady;
reg [7:0] dataOut;
reg prodReady;
input consReady;

always
begin
prodReady = 0; // Indicate nothing to transfer
forever
begin
// ... Prduce data and put into temp
// Wait for consumer ready
wait( consReady ) dataOut = $random;

// Indicate ready to transfer

prodReady = 1;
// Finish handshake
wait( !consReady ) prodReady = 0;
end
end

endmodule

module consumer( dataIn, prodReady, consReady )

input [7:0] dataIn;
input prodReady;
output consReady;
reg consReady;

reg [7:0] dataInCopy;

 Verilog ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬

always
begin
consReady = 1; // Indicate nothing to transfer
forever
begin
wait( prodReady ) dataInCopy = dataIn;
// Indicate value consumed
consReady = 0;
// ... munch on data
// Complete handshake
wait( !prodReady ) consReady = 1;
end
end

endmodule

// Top-level Producer-Consumer process

module ProducerConsumer;
wire [7:0] data;
wire pReady, cReady;

producer p( data, pReady, cReady );

consumer c( data, pReady, cReady );

endmodule

‫ ﻫﺎي‬clk ‫• ﻣﺜﺎل ﺗﻮﻟﻴﺪﻛﻨﻨﺪه و ﻣﺼﺮفﻛﻨﻨﺪة ﻓﻮق را ﺑﻪ ﻧﺤﻮي ﺗﻐﻴﻴﺮدﻫﻴﺪ ﻛﻪ در ﻟﺒﺔ ﺑﺎﻻروﻧﺪة‬

‫ﻣﺘﻮاﻟﻲ ﺗﻮﻟﻴﺪﻛﻨﻨﺪه و ﻣﺼﺮفﻛﻨﻨﺪه ﺑﻪ ﺗﺮﺗﻴﺐ داده را ﺗﻮﻟﻴﺪ و ﻣﺼﺮف ﻛﻨﻨﺪ ) ﺷــﻜﻞ زﻳـﺮ را‬
.( ‫ﺑﺒﻴﻨﻴﺪ‬

Producer Writes

Consumer Reads

‫ﻣﺪﻟﺴﺎزي در ﺳﻄﺢ ﺳﻮﺋﻴﭻ‬ ٨

‫ ﻛـــﻪ در‬،‫ ﺑـﺮاي اﻧﺠـﺎم ﻣﺪﻟﺴـﺎزي در ﺳـﻄﺢ ﺳـﻮﺋﻴﭻ ﺳـﺎﺧﺘﺎرﻫﺎﻳﻲ از ﭘﻴـﺶ ﺗﻌﺒﻴـﻪ ﺷـﺪه اﺳـﺖ‬Verilog ‫در‬
.‫اﻳﻦ ﻗﺴﻤﺖ ﺑﻪ آﻧﻬﺎ ﻣــﻲﭘﺮدازﻳـﻢ‬

MOS, CMOS ‫ﺳﻮﺋﻴﭽﻬﺎي‬ ١-٨

.‫ اﻳﻦ ﺳــﻮﺋﻴﭽﻬﺎ و ﺟـﺪول ﺻﺤـﺖ آﻧـﻬﺎ ﻧﻤـﺎﻳﺶ داده ﺷـﺪه اﺳـﺖ‬١١-١ ‫در ﺷﻜﻞ‬
 Verilog ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬

Data Out Data Out

Ncontrol
Control Control

nmos 0 1 x z nmos 0 1 x z Data Out

0 z 0 L L 0 0 z L L
1 z 1 H H 1 1 z H H
x z x x x x x z x x
Pcontrol
z z z z z z z z z z

‫ و ﺟﺪول ﺻﺤﺖ آﻧﻬﺎ‬MOS ‫ ﺳﻮﺋﻴﭽﻬﺎي‬-١١-١ ‫ﺷﻜﻞ‬

nmos n1 ( out, data, control );

pmos ( out, data, control );
cmos c1 ( out, data, ncontrol, pcontrol );

‫ﺳﻮﺋﻴﭽﻬﺎي دوﺳﻮﻳﻪ‬ ٢-٨

.‫ ﺳــﻮﺋﭽﻬﺎي دوﺳـﻮﻳﻪ ﻧﻤـﺎﻳﺶ داده ﺷـﺪه اﺳـﺖ‬١٢-١ ‫در ﺷﻜﻞ‬

control control

inout1 inout2 inout1 inout2 inout1 inout2

tran tranif0 tranif1

‫ و ﺟﺪول ﺻﺤﺖ آﻧﻬﺎ‬MOS ‫ ﺳﻮﺋﻴﭽﻬﺎي‬-١١-١ ‫ﺷﻜﻞ‬

tran t1 ( inout1, inout2 );

tranif0 ( inout1, inout2, control );
tranif1 ( inout1, inout2, control );

‫ﺗﻐﺬﻳﻪ و زﻣﻴﻦ‬ ٣-٨

‫ ﺑـﺮاي اﻳـﻦ ﻣﻨﻈـﻮر‬.‫ ( ﻧﻴـﺎز دارﻳـﻢ‬Vss, Vdd ) ‫ﺑﻪ ﻫﻨﮕﺎم اﺳــﺘﻔﺎده از ﺳـﻮﺋﻴﭽﻬﺎ ﺑـﻪ ﻣﻨﺒـﻊ ﺗﻐﺬﻳـﻪ و زﻣﻴـﻦ‬
.‫ درﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﺷـﺪه اﺳـﺖ‬Vss, Vdd ‫ ﺑــﻪ ﺗﺮﺗﻴـﺐ ﺑـﺮاي‬supply0, supply1 ‫دو ﻛﻠﻤﺔ ﻛﻠﻴﺪي‬

supply1 Vdd;
supply0 Vss;
assign a = Vdd; // Connect a to Vdd
 ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬

‫ﺳﻮﺋﻴﭽﻬﺎي ﻣﻘﺎوﻣﺘﻲ‬ ‫‪٤-٨‬‬

‫درﺣـﺎﻻت ﻗﺒـﻞ ﺳـﻮﺋﻴﭽﻬﺎ اﻳـﺪهآل ﻓـﺮض ﺷـﺪه ﺑﻮدﻧـﺪ‪ ،‬ﻳﻌﻨـﻲ ﻫﻴﭽﮕﻮﻧـﻪ ﺗﻀﻌﻴﻔـﻲ در ﺳـﻴﮕﻨﺎل ﻋﺒــﻮري از‬
‫ﺳﻮﺋﻴﭻ ﻣﺸــﺎﻫﺪه ﻧﻤﻲﺷـﺪ‪ .‬وﻟـﻲ در ﺳـﻮﺋﻴﭽﻬﺎي ﻣﻘـﺎوﻣﺘﻲ ﻗـﺪرت ﺳـﻴﮕﻨﺎل ﻋﺒـﻮري از ﺳـﻮﺋﻴﭻ ﻣﻄـﺎﺑﻖ ﺟـﺪول ‪٧-١‬‬
‫ﺗﻐﻴﻴﺮ ﻣﻲﻛﻨﺪ‪ .‬ﺳﻮﺋﻴﭽﻬﺎي ﻣﻘﺎوﻣﺘﻲ ﺑﺎ اﻓــﺰودن ﻳـﻚ ‪ r‬ﺑـﻪ اﺑﺘـﺪاي ﻧـﺎم ﺳـﻮﺋﻴﭽﻬﺎي ﻣﻌﻤﻮﻟـﻲ ﺑﺪﺳـﺖ ﻣﻲآﻳﻨـﺪ‪.‬‬

‫‪rnmos, rpmos‬‬ ‫‪// Resistive nmos,pmos switches‬‬

‫‪rcmos‬‬ ‫‪// Resistive cmos switch‬‬
‫‪rtran, rtranif0, rtranif1‬‬ ‫‪// Resistive tran,tranif0,tranif1 switches‬‬

‫‪Input Strength‬‬ ‫‪Output Strength‬‬

‫‪supply‬‬ ‫‪pull‬‬
‫‪strong‬‬ ‫‪pull‬‬
‫‪pull‬‬ ‫‪weak‬‬
‫‪weak‬‬ ‫‪medium‬‬
‫‪large‬‬ ‫‪medium‬‬
‫‪medium‬‬ ‫‪small‬‬
‫‪small‬‬ ‫‪small‬‬
‫‪high‬‬ ‫‪high‬‬
‫ﺟﺪول ‪ -٧-١‬ﺟﺪول ﺗﻀﻌﻴﻒ ﺳﻴﮕﻨﺎل ﺳﻮﺋﻴﭽﻬﺎي ﻣﻘﺎوﻣﺘﻲ‬

‫ﻣﺜﺎل ‪ :‬ﻳﻚ ﻣﺎﻟﺘﻲ ﭘﻠﻜﺴــﺮ ‪ ٢‬ﺑـﻪ ‪ ١‬ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‪.‬‬

‫;) ‪module mux2_to_1 ( out, i0, i1, s‬‬

‫‪i0‬‬ ‫;‪output out‬‬
‫;‪input s, io, i1‬‬

‫‪out‬‬ ‫;‪wire sbar‬‬

‫;) ‪not ( sbar, s‬‬

‫‪i1‬‬ ‫;) ‪cmos ( out, i0, sbar, s‬‬
‫;) ‪cmos ( out, i1, s, sbar‬‬

‫‪sbar‬‬ ‫‪endmodule‬‬

‫‪s‬‬