‫داﻧﺸﮕﺎه ﺗﻬﺮان ‪ -‬داﻧﺸﻜﺪة ﻓﻨﻲ‬
‫ﮔﺮوه ﻣﻬﻨﺪﺳﻲ ﺑﺮق و ﻛﺎﻣﭙﻴﻮﺗﺮ‬
‫ﺧﻮدآﻣﻮز زﺑﺎن ﺗﻮﺻﻴﻒ ﺳﺨﺖاﻓﺰاري‬
‫‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه ‪ :‬ﺳﻌﻴﺪ ﺻﻔﺮي‬
‫اﺳﻔﻨﺪ ‪٧٩‬‬
‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫‪١‬‬
‫‪١-١‬‬
‫ﻣﻔﺎﻫﻴﻢ اوﻟﻴﻪ‬
‫ﻣﺎﺟﻮل‬
‫ﻣـﺎﺟﻮل ﺑﻠـﻮك ﭘﺎﻳـﺔ ‪ Verilog‬اﺳـﺖ‪ .‬ﻳـﻚ ﻣـﺎﺟﻮل ﻣﻲﺗﻮاﻧـﺪ ﻳـﻚ ﻋﻨﺼـﺮ ﻳـﺎ ﻣﺠﻤﻮﻋـﻪاي از ﺑﻠﻮﻛـــﻬﺎي‬
‫ﺳﻄﺢ ﭘــﺎﻳﻴﻦﺗﺮ ﺑﺎﺷـﺪ‪ .‬ﺑﻨـﺎﺑﺮاﻳﻦ ﻣـﺎﺟﻮل ﻋﻤﻠﻜـﺮد ﻣـﻮرد ﻧﻈـﺮ را ﺑـﺮاي ﺑﻠﻮﻛـﻬﺎي ﺳـﻄﺢ ﺑـﺎﻻﺗﺮ ﻓﺮاﻫـﻢ ﻣﻲﻛﻨـﺪ‪ ،‬اﻣـﺎ‬
‫ﭘﻴﺎدهﺳﺎزي داﺧﻞ آﻧـﺮا ﭘﻨـﻬﺎن ﻣﻲﻛﻨـﺪ‪ .‬ﺷـﻜﻞ ‪ ١-١‬ﻧﺤـﻮة ﺗﻌﺮﻳـﻒ ﻣـﺎﺟﻮل را ﺑـﺎ ﻳـﻚ ﻣﺜـﺎل ﺑﻴـﺎن ﻣﻲﻛﻨـﺪ‪ .‬در زﺑـﺎن‬
‫‪ Verilog‬ﻣﻲﺗﻮاﻧﻴﻢ ﻳﻚ ﻣــﺎﺟﻮل را در ﭼـﻬﺎر ﺳـﻄﺢ ﻣﺨﺘﻠـﻒ ﺗﺠﺮﻳـﺪ ﺑﻴـﺎن ﻛﻨﻴـﻢ ‪:‬‬
‫• ﺳﻄﺢ ﮔﻴﺖ ‪ :‬در اﻳﻦ ﺳﻄﺢ ﻣــﺎﺟﻮل ﺑﺼـﻮرت ﮔﻴﺘـﻬﺎي ﻣﻨﻄﻘـﻲ و اﺗﺼـﺎﻻت ﺑﻴـﻦ آﻧـﻬﺎ ﺑﻴـﺎن ﻣﻲﺷـﻮد‪.‬‬
‫• ﺳـﻄﺢ ﺟﺮﻳـﺎن داده )‪ : (Dataflow‬در اﻳـﻦ ﺳـﻄﺢ ﻣـﺎﺟﻮل ﺑﻮﺳـﻴﻠﺔ ﻣﺸـﺨﺺ ﻛـﺮدن ﻧﺤـﻮة ﺟﺮﻳـــﺎن‬
‫اﻃﻼﻋﺎت ﺑﻴﻦ رﺟﻴﺴﺘﺮﻫﺎ و ﻧﻮع ﭘﺮدازﺷــﻲ ﻛـﻪ روي آﻧـﻬﺎ ﺻـﻮرت ﻣـﻲﮔـﻴﺮد‪ ،‬ﺑﻴـﺎن ﻣﻲﺷـﻮد‪.‬‬
‫• ﺳـﻄﺢ رﻓﺘـﺎري )‪ : (Behavioral‬در اﻳـﻦ ﺳـﻄﺢ ﻣـﺎﺟﻮل ﺑﺮﺣﺴـﺐ اﻟﮕﻮرﻳﺘـﻢ ﻃﺮاﺣـﻲ ﺷـﻮد‪ ،‬ﺑــﺪون‬
‫اﻳﻨﻜﻪ ﺟﺰﺋﻴﺎت ﻃﺮاﺣــﻲ ﭘﻴﺎدهﺳـﺎزي ﺳـﺨﺖاﻓﺰاري در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﺷـﻮد‪.‬‬
‫• ﺳﻄﺢ ﺳﻮﺋﻴﭻ ‪ :‬در اﻳﻦ ﺳﻄﺢ ﻣــﺎﺟﻮل ﺑﺼـﻮرت ﺳـﻮﺋﻴﭽﻬﺎ و اﺗﺼـﺎﻻت ﺑﻴـﻦ آﻧـﻬﺎ ﺑﻴـﺎن ﻣﻲﺷـﻮد‪.‬‬
‫‪Declaration of the input/output port‬‬
‫;) ‪module decoder ( A, B, En, D0, D1, D2, D3‬‬
‫;‪input A, B, En‬‬
‫;‪output D0, D1, D2, D3‬‬
‫‪Module body‬‬
‫‪//Functionality of the decoder‬‬
‫‪Descrption of the module‬‬
‫‪endmodule‬‬
‫‪D0‬‬
‫‪A‬‬
‫‪D1‬‬
‫‪D2‬‬
‫‪D3‬‬
‫‪B‬‬
‫‪En‬‬
‫‪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‬‬
‫‪d0‬‬
‫‪d1‬‬
‫‪Circuit‬‬
‫‪d2‬‬
‫‪d3‬‬
‫‪D0‬‬
‫‪D1‬‬
‫‪A‬‬
‫‪B‬‬
‫‪D2‬‬
‫‪D3‬‬
‫‪En‬‬
‫‪The nets are used to model an‬‬
‫‪electrical connection between‬‬
‫‪structural entities such as gates.‬‬
‫‪A wire is one type of net.‬‬
‫‪We instantiated an instance from‬‬
‫‪decoder and called it dcd0. The‬‬
‫‪nets can be used to connect‬‬
‫‪dcd0 to other components.‬‬
‫‪a‬‬
‫‪b‬‬
‫‪Circuit‬‬
‫‪en‬‬
‫;‪module Top‬‬
‫;‪wire a, b, en‬‬
‫;‪wire d0, d1, d2, d3‬‬
‫>‪<Other Components‬‬
‫;) ‪decoder dcd0 ( a, b, en, d0, d1, d2, d3‬‬
‫>‪<Other Components‬‬
‫‪endmodule‬‬
‫ﺷﻜﻞ ‪ -٢-١‬ﻧﺤﻮة ﺳﺎﺧﺖ ﻧﻤﻮﻧﻪ از روي ﻣﺎﺟﻮل دﻳﻜﻮدر‬
‫• در ﺷﻜﻞ زﻳﺮ ﻳﻚ ﻣﻘﺎﻳﺴﻪﮔﺮ ﺑﻴﺘﻲ ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪ .‬ﻳﻚ ﻣﺎﺟﻮل ﺑﻨــﺎم ‪Comparator‬‬
‫ﺗﻌﺮﻳﻒ ﻛﻨﻴﺪ و ﺳﭙﺲ ﻳﻚ ﻧﻤﻮﻧﻪ ﺑﻨﺎم ‪ Comp0‬از روي آن ﺑﺴﺎزﻳﺪ‪ .‬دﻗﺖ ﻛﻨﻴﺪ ﻫﺪف ﻓﻘــﻂ‬
‫ﺗﻌﺮﻳﻒ ﭘﻮرﺗﻬﺎي ﻣﻘﺎﻳﺴﻪﮔﺮ و ﻧﻤﻮﻧﻪﺳﺎزي از روي آن اﺳﺖ‪.‬‬
‫‪Comp0‬‬
‫‪A_GT_B‬‬
‫‪a_gt_b‬‬
‫‪A_EQ_B‬‬
‫‪a_eq_b‬‬
‫‪A_LT_B‬‬
‫‪a_lt_b‬‬
‫‪a‬‬
‫‪A‬‬
‫‪b‬‬
‫‪B‬‬
‫‪gt‬‬
‫‪GT‬‬
‫‪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‬‬
‫ﺑـﺮاي ﻣﺒﻨـﺎي ﺷـﺎﻧﺰده ﺑﻜـﺎر ﻣـﻲرود‪ .‬ﺣـﺎﻟﺖ ﭘﻴﺶﻓـﺮض ﻣﺒﻨـﺎي ده اﺳـﺖ‪ .‬ﺑـﺮاي ﺧﻮاﻧﺎﺗﺮﺷـﺪن اﻋـــﺪاد‬
‫ﻣﻲﺗﻮان از "_" اﺳــﺘﻔﺎده ﻧﻤـﻮد‪.‬‬
‫‪This is a 8 bit binary number‬‬
‫‪This is a 12 bit hex number‬‬
‫‪This is a 12 bit decimal number‬‬
‫‪This is a 4 bit negative decimal number, that stored‬‬
‫‪as 2’s complement of 13‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪8’b1010_1110‬‬
‫‪12’hab6‬‬
‫‪16’D255‬‬
‫‪-4’d13‬‬
‫• ﻋـﺪد ﺑـﺪون اﻧـﺪازه ‪ :‬ﺷـﻜﻞ ﻛﻠـﻲ ﻋـﺪد ﺑـﺪون اﻧـﺪازه ﺑﺼـﻮرت ’>‪ <radix><number‬اﺳـــﺖ‪ .‬در‬
‫اﻳﻦ ﺣﺎﻟﺖ ﻃﻮل ﻋﺪد ﺑﻪ ﻧــﻮع ﭘﻴﺎدهﺳـﺎزي ﺑﺴـﺘﮕﻲ دارد وﻟـﻲ ﺣﺪاﻗـﻞ ‪ ٣٢‬ﺑﻴـﺖ اﺳـﺖ‪.‬‬
‫‪// This is a 32 bit decimal number‬‬
‫‪// This is a 32 bit hex number‬‬
‫‪// This is a 32 bit octal number‬‬
‫‪1234‬‬
‫‪h’62‬‬
‫‪o’255‬‬
‫ﺧﻮدآﻣﻮز زﺑــﺎن ﺗﻮﺻﻴـﻒ ﺳـﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫• اﻋﺪاد ﻣﻨﻔﻲ ﺑﺎ ﻗﺮار دادن ﻳﻚ ﻋﻼﻣﺖ ﻣﻨﻔﻲ )"‪ ("-‬ﻗﺒﻞ از >‪ <size‬ﺑﺪﺳﺖ ﻣﻲآﻳﻨﺪ‪.‬‬
‫• ﻛﺮﻛﺘﺮ ؟ و ‪ x‬ﻣﻌﺎدﻻ ﺑﻜﺎر ﻣﻲروﻧﺪ‪.‬‬
‫• در ‪ Verilog‬دوﻧﻤﺎد ﺑﺮاي ﻣﻘﺎدﻳﺮ ‪ HiZ‬و ﻧﺎﻣﻌﻠﻮم دارﻳﻢ ﻛﻪ ﺑﻪ ﺗﺮﺗﻴﺐ ﻋﺒــﺎرﺗﻨﺪ از‬
‫‪ . x, z‬اﻳﻦ ﻣﻘﺎدﺑﺮ در ﺷﺒﻴﻪﺳﺎزي ﻣﺪارﻫﺎ ﺑﺴﻴﺎر ﻣﻮرد اﺳــﺘﻔﺎده ﻗـﺮار ﻣـﻲﮔـﻴﺮﻧﺪ‪ .‬در‬
‫ﻣﻘﺪاردﻫﻲ ﺑﻪ ﻳﻚ ﻋﺪد درﻣﺒﻨﺎي ﺷﺎﻧﺰده‪ ،‬ﻫﺸﺖ و دو ﻣﻘﺎدﻳﺮ ‪ x, z‬ﺑــﻪﺗﺮﺗﻴﺐ ﻃﻮﻟـﻲ‬
‫ﺑﺮاﺑﺮ ‪ ٤‬و ‪ ٣‬و ‪ ١‬ﺑﻴﺖ دارﻧﺪ‪.‬‬
‫‪12’h13x‬‬
‫??‪4’b10‬‬
‫‪// This is a 12 bit hex number, 4 LSBs unknown‬‬
‫‪// This is a 4 bit binary number equal to 4’b10xx‬‬
‫• ﻣﺸﺨﺺ ﻛﻨﻴﺪ ﻛﻪ ﻛﺪام ﻳﻚ از اﻋﺪاد زﻳﺮ ﻣﻌﺘﺒﺮ ﻫﺴﺘﻨﺪ‪.‬‬
‫‪27_13_45‬‬
‫‪٥-٢‬‬
‫‪8’d-6‬‬
‫‪5’D3‬‬
‫‪12’hx‬‬
‫‪4AF‬‬
‫‪‘h83F‬‬
‫‪659‬‬
‫رﺷﺘﻪ‬
‫ﻣﺠﻤﻮﻋﻪاي اﺳﺖ از ﻛﺮﻛﺘﺮﻫــﺎ ﻛـﻪ ﺑﻮﺳـﻴﻠﻪ ”“ ﻣﺤﺼـﻮر ﺷـﺪهاﻧﺪ‪.‬‬
‫ﺷﻨﺎﺳﻪ و ﻛﻠﻤﻪ ﻛﻠﻴﺪي‬
‫‪٦-٢‬‬
‫ﻛﻠﻤﺎت ﻛﻠﻴــﺪي ﺷﻨﺎﺳـﻪﻫﺎﻳﻲ ﻫﺴـﺘﻨﺪ ﻛـﻪ از ﭘﻴـﺶ ﺑـﺮاي ﺗﻌﺮﻳـﻒ ﺳـﺎﺧﺘﺎر زﺑـﺎن اﺳـﺘﻔﺎده ﺷـﺪهاﻧﺪ‪ .‬ﻛﻠﻤـﺎت‬
‫ﻛﻠﻴﺪي ﺑﺎ ﺣــﺮوف ﻛـﻮﭼـﻚ ﻧﻮﺷـﺘﻪ ﻣﻲﺷـﻮﻧﺪ‪ .‬ﺷﻨﺎﺳـﻪﻫﺎ ﻧﺎﻣـﻬﺎﻳﻲ ﻫﺴـﺘﻨﺪ ﻛـﻪ ﻣـﺎ ﺑـﻪ ﻋﻨـﺎﺻﺮ ﻧﺴـﺒﺖ ﻣﻲدﻫﻴـﻢ ﺗـﺎ‬
‫ﺑﻮﺳﻴﻠﺔ آن ﺑــﻪ آﻧـﻬﺎ رﺟـﻮع ﻛﻨﻴـﻢ‪ .‬ﺷﻨﺎﺳـﻪ ﻣﻲﺗﻮاﻧـﺪ از ﻛﺮﻛﺘﺮﻫـﺎي ﺣﺮﻓـﻲ‪ _ ،‬و ‪ $‬ﺗﺸـﻜﻴﻞ ﺷـﻮد و ﺣﺘﻤـﺎ ﺑـﺎﻳﺪ ﺑـﺎ‬
‫ﻳﻚ ﻛﺮﻛﺘﺮ ﺣﺮﻓﻲ ﺷﺮوع ﺷــﻮد‪ .‬ﺷﻨﺎﺳـﻪﻫﺎ ﺣﺴـﺎس ﺑـﻪ ﻣﺘـﻦ ﻫﺴـﺘﻨﺪ‪.‬‬
‫‪٧-٢‬‬
‫اﻧﻮاع دادهﻫﺎ‬
‫‪١-٧-٢‬‬
‫ﻣﺠﻤﻮﻋﻪ ﻣﻘﺎدﻳﺮ‬
‫‪ Verilog‬ﺑـﺮاي ﻣﺪﻟﺴـﺎزي ﻋﻤﻠﻜـﺮد ﺳـﺨﺖاﻓﺰارﻫﺎي واﻗﻌـﻲ از ‪ ٤‬ﻣﻘـــﺪار و ‪ ٨‬ﺳــﻄﺢ ﻗــﺪرت اﺳــﺘﻔﺎده‬
‫ﻣﻲﻛﻨﺪ‪ .‬ﻣﺠﻤﻮﻋــﺔ ﻣﻘـﺎدﻳﺮ در ﺟـﺪول ‪ ١-١‬و ﺳـﻄﻮح ﻗـﺪرت در ﺟـﺪول ‪ ٢-١‬آﻣـﺪه اﺳـﺖ‪.‬‬
‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫‪Condition in Hardware Circuits‬‬
‫‪Logic Zero, False Condition‬‬
‫‪Logic One, True Condition‬‬
‫‪Unknown value‬‬
‫‪High Impedance, Floating State‬‬
‫‪Value Level‬‬
‫‪0‬‬
‫‪1‬‬
‫‪x‬‬
‫‪z‬‬
‫ﺟﺪول ‪ -١-١‬ﻣﺠﻤﻮﻋﺔ ﻣﻘﺎدﻳﺮ‬
‫‪Degree‬‬
‫‪strongest‬‬
‫‪Weakest‬‬
‫‪Type‬‬
‫‪Driving‬‬
‫‪Driving‬‬
‫‪Driving‬‬
‫‪Storage‬‬
‫‪Driving‬‬
‫‪Storage‬‬
‫‪Storage‬‬
‫‪High Impedance‬‬
‫‪Strength Level‬‬
‫‪supply‬‬
‫‪strong‬‬
‫‪pull‬‬
‫‪large‬‬
‫‪weak‬‬
‫‪medium‬‬
‫‪small‬‬
‫‪highz‬‬
‫ﺟﺪول ‪ -٢-١‬ﺳﻄﻮح ﻗﺪرت‬
‫‪٢-٧-٢‬‬
‫‪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‬اﺳـﺖ‪.‬‬
‫‪// Declare a variable that can be hold its value‬‬
‫‪٤-٧-٢‬‬
‫;‪reg reset‬‬
‫‪Vector‬‬
‫اﻧـﻮاع دادهاي ‪ reg‬و ‪ wire‬ﻣﻲﺗﻮاﻧﻨـﺪ ﺑﺼـﻮرت ﺑـــﺮدار ﺗﻌﺮﻳــﻒ ﺷــﻮﻧﺪ‪ .‬ﺷــﻜﻞ ﻛﻠــﻲ ﺗﻌﺮﻳــﻒ ﺑــﺮدار‬
‫ﺑﺼﻮرت زﻳﺮ اﺳــﺖ ‪:‬‬
‫>‪<vector_type> [ MSB : LSB ] <vector_name‬‬
‫‪// Declare a bus that has 32 bit width‬‬
‫‪// virtual address 41 bits wide‬‬
‫‪٥-٧-٢‬‬
‫;‪wire [31:0] BusA‬‬
‫;‪reg [0:40] Vir_Add‬‬
‫اﻧﻮاع دادهاي ﺻﺤﻴﺢ‪ ،‬ﺣﻘﻴﻘﻲ و زﻣﺎن‬
‫• ﺻﺤﻴـﺢ ‪ :‬ﻳـﻚ ﻧـﻮع دادة رﺟﻴﺴـﺘﺮ ﻫﻤـﻪ ﻣﻨﻈـﻮره اﺳـﺖ ﻛـﻪ ﺑـﺮاي ﭘـﺮدازش ﻣﻘـﺎدﻳﺮ ﺻﺤﻴـﺢ اﺳــﺘﻔﺎده‬
‫ﻣﻲﺷﻮد‪ .‬ﺗﻔــﺎوت اﻳـﻦ ﻧـﻮع ﺑـﺎ ﻧـﻮع ‪ reg‬دراﻳﻨﺴـﺘﻜﻪ در ﻧـﻮع ‪ reg‬دادهﻫـﺎ ﺑﺼـﻮرت ﺑـﺪون ﻋﻼﻣـﺖ در‬
‫ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـﻮﻧﺪ‪ ،‬وﻟـﻲ در ﻧـﻮع ﺻﺤﻴـﺢ دادهﻫـﺎ ﺑﺼـﻮرت ﻋﻼﻣﺘـﺪار در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـــﻮﻧﺪ‪.‬‬
‫ﻧـﻮع دادهاي ﺻﺤﻴـﺢ ﺗﻮﺳـﻂ ﻛﻠﻤـﺔ ﻛﻠﻴـــﺪي ‪ integer‬ﺗﻌﺮﻳــﻒ ﻣﻲﺷــﻮد و ﻃــﻮل آن ﺑﺴــﺘﮕﻲ ﺑــﻪ‬
‫ﭘﻴﺎدهﺳﺎزي دارد وﻟﻲ ﺣﺪاﻗــﻞ ‪ ٣٢‬ﺑﻴـﺖ درﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـﻮد‪.‬‬
‫‪// General purpose variable used as a counter‬‬
‫;‪integer counter‬‬
‫• ﺣﻘﻴﻘـﻲ ‪ :‬ﻳـﻚ ﻧـﻮع دادة رﺟﻴﺴـﺘﺮ ﻫﻤـﻪ ﻣﻨﻈـﻮره اﺳـﺖ ﻛـﻪ ﺑـﺮاي ﭘـﺮدازش ﻣﻘـﺎدﻳﺮ ﺻﺤﻴـﺢ اﺳــﺘﻔﺎده‬
‫ﻣﻲﺷﻮد‪ .‬ﻧــﻮع دادهاي ﺻﺤﻴـﺢ ﺗﻮﺳـﻂ ﻛﻠﻤـﺔ ﻛﻠﻴـﺪي ‪ integer‬ﺗﻌﺮﻳـﻒ ﻣﻲﺷـﻮد‪.‬‬
‫‪// Declare a real variable called delta‬‬
‫;‪real delta‬‬
‫• زﻣـﺎن ‪ :‬در ‪ Verilog‬ﻳـﻚ ﻧـﻮع دادهاي ﺧـﺎص ﺑـــﺮاي ذﺧــﻴﺮه ﻛــﺮدن زﻣــﺎن ﺷﺒﻴﻪﺳــﺎزي اﺳــﺘﻔﺎده‬
‫ﻣﻲﺷﻮد‪ .‬ﻧﻮع دادهاي زﻣــﺎن ﺑﻮﺳـﻴﻠﻪ ﻛﻠﻤـﻪ ﻛﻠﻴـﺪي ‪ time‬ﺗﻌﺮﻳـﻒ ﻣﻲﺷـﻮد‪ .‬ﻃـﻮل ﻣﺘﻐـﻴﺮ از ﻧـﻮع زﻣـﺎن‬
‫ﺑﻪ ﭘﻴﺎدهﺳﺎزي ﺑﺴــﺘﮕﻲ دارد وﻟـﻲ ﺣﺪاﻗـﻞ ‪ ٦٤‬ﺑﻴـﺖ اﺳـﺖ‪.‬‬
‫‪// Define a time variable sim_time‬‬
‫;‪time sim_time‬‬
‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫آراﻳﻪ‬
‫‪٨-٢‬‬
‫در ‪ Verilog‬ﻣﻲﺗـﻮان آراﻳـﻪاي از ﻧﻮﻋـﻬﺎي دادهاي ‪ time, integer, reg‬و ﻳــﺎ آراﻳــﻪاي از ﺑﺮدارﻫــﺎﻳﻲ‬
‫از اﻳﻦ ﻧﻮﻋﻬﺎ ﺗﻌﺮﻳﻒ ﻛــﺮد‪ .‬ﺷـﻜﻞ ﻛﻠـﻲ ﺗﻌﺮﻳـﻒ آراﻳـﻪ ﻋﺒﺎرﺗﺴـﺖ از ‪:‬‬
‫] ‪<array_type> <array_name> [ #first_element : #last_element‬‬
‫‪// An array of 8 integer‬‬
‫;]‪integer count[0:7‬‬
‫• در ‪ Verilog‬آراﻳﻪﻫﺎي ﭼﻨﺪﺑﻌﺪي ﻧﺪارﻳﻢ‪.‬‬
‫• ﺗﻔﺎوت آراﻳﻪ و ﺑﺮدار در اﻳﻨﺴﺘﻜﻪ آراﻳﻪ از ﭼﻨﺪ ﻋﻨﺼﺮ ﺗﺸﻜﻴﻞ ﺷﺪه اﺳﺖ ﻛﻪ ﻫﺮﻳﻚ از‬
‫آﻧﻬﺎ ﻣﻲﺗﻮاﻧﻨﺪ ﻳﻚ ﻳﺎ ﭼﻨﺪ ﺑﻴﺖ ﻃﻮل داﺷﺘﻪ ﺑﺎﺷﻨﺪ‪ ،‬درﺣﺎﻟﻴﻜﻪ ﺑﺮدار ﻳﻚ ﻋﻨﺼــﺮ اﺳـﺖ‬
‫ﻛﻪ ﻃﻮﻟﻲ ﺑﺮاﺑﺮ ‪ n‬دارد‪.‬‬
‫ﺣﺎﻓﻈﻪ‬
‫‪٩-٢‬‬
‫در ‪ Verilog‬ﺣﺎﻓﻈﻪ را ﺑﺼــﻮرت آراﻳـﻪاي از رﺟﻴﺴـﺘﺮﻫﺎ ﺗﻌﺮﻳـﻒ ﻣﻲﻛﻨﻴـﻢ‪.‬‬
‫‪// 1K x 1bit memory‬‬
‫‪// 1K x 8bit memory‬‬
‫‪١٠-٢‬‬
‫;]‪reg membit[0:1023‬‬
‫;]‪reg [7:0] membyte[0:1023‬‬
‫ﭘﺎراﻣﺘﺮ‬
‫ﻣﻲﺗـﻮان در ﻳـﻚ ﻣـﺎﺟﻮل اﻋـﺪاد ﺛـﺎﺑﺘﻲ را ﺑﺼـﻮرت ﭘـﺎراﻣﺘﺮ ﺗﻌﺮﻳـﻒ ﻧﻤـﻮد و از آﻧـﻬﺎ اﺳـﺘﻔﺎده ﻧﻤـﻮد‪ ،‬اﻳــﻦ‬
‫اﻣﺮ ﺗﻮﺳﻂ ﻛﻠﻤــﻪ ﻛﻠﻴـﺪي ‪ parameter‬اﻧﺠـﺎم ﻣﻲﺷـﻮد‪.‬‬
‫‪// Define a constant port_id‬‬
‫‪١١-٢‬‬
‫;‪parameter port_id = 5‬‬
‫رﺷﺘﻪ‬
‫رﺷـﺘﻪﻫﺎ ﻣﻲﺗﻮاﻧﻨـﺪ در ﻳـﻚ ‪ reg‬ذﺧـﻴﺮه ﺷـﻮﻧﺪ‪ .‬ﻃـﻮل ﻣﺘﻐـﻴﺮ ‪ reg‬ﺑـﺎﻳﺪ ﺑـﻪ اﻧـﺪازه ﻛـﺎﻓﻲ ﺑـﺰرگ ﺑﺎﺷـﺪ ﺗــﺎ‬
‫ﺑﺘﻮاﻧﺪ رﺷﺘﻪ را ﻧﮕﺎه دارد‪ .‬ﻫــﺮ ﻛﺮﻛـﺘﺮ در ‪ ٨‬ﺑﻴـﺖ ذﺧـﻴﺮه ﻣﻲﺷـﻮد‪.‬‬
‫‪// Define a variable with 18 bytes‬‬
‫‪١٢-٢‬‬
‫;‪reg [8*18:1] s_val‬‬
‫‪ task‬ﻫﺎي ﺳﻴﺴﺘﻢ‬
‫در ‪ Verilog‬ﺗﻌـﺪادي ‪ task‬ﺑـﻪ ﻣﻨﻈـﻮر ﻧﻤـﺎﻳﺶ اﻃﻼﻋـﺎت روي ﺻﻔﺤـﻪ‪ ،‬ﻣـﺎﻧﻴﺘﻮرﻛﺮدن ﻣﻘـــﺎدﻳﺮ‪ ،‬ﺧﺎﺗﻤــﺔ‬
‫ﺷﺒﻴﻪﺳﺎزي و‪ ...‬ﻓﺮاﻫــﻢ ﺷـﺪه اﺳـﺖ‪ .‬ﻛﻠﻴـﺔ ‪ task‬ﻫـﺎ ﺑﺼـﻮرت >‪ $<task_name‬ﺑﻜـﺎر ﻣﻲروﻧـﺪ‪.‬‬
‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫• ﻧﻤـﺎﻳﺶ اﻃﻼﻋـﺎت ‪ :‬ﻧﻤـﺎﻳﺶ اﻃﻼﻋـﺎت ﺗﻮﺳـــﻂ ‪ $display‬اﻧﺠــﺎم ﻣﻲﺷــﻮد و داراي ﺷــﻜﻞ ﻛﻠــﻲ‬
‫;) ‪ $display( format, p1, p2, ..., pn‬اﺳـﺖ‪ ،‬ﻛـﻪ در آن ‪ pi‬ﻫـﺎ ﻣﻲﺗﻮاﻧﻨـــﺪ ﻧــﺎم ﻣﺘﻐــﻴﺮ‪ ،‬ﻧــﺎم‬
‫ﺳـﻴﮕﻨﺎل و ﻳـﺎ رﺷـﺘﻪ ﺑﺎﺷـﻨﺪ‪ .‬ﺗﻮﺳـﻂ ‪ format‬ﻣﻲﺗـﻮان ﻗـﺎﻟﺐ ﻧﻤـﺎﻳﺶ اﻃﻼﻋـﺎت را ﺑﺼـﻮرت دﻟﺨــﻮاه‬
‫ﺗﻌﻴﻴﻦ ﻧﻤــﻮد‪ .‬ﺑـﺮاي اﻳـﻦ ﻣﻨﻈـﻮر ﻳـﻚ ﺳـﺮي ﻗـﺎﻟﺐ از ﭘﻴـﺶ ﺗﻌﺮﻳـﻒ ﺷـﺪه اﺳـﺖ ﻛـﻪ ﻟﻴﺴـﺖ آﻧـﻬﺎ در‬
‫ﺟﺪول ‪ ٣-١‬آﻣــﺪه اﺳـﺖ‪.‬‬
‫‪Display‬‬
‫‪Display variable in decimal‬‬
‫‪Display variable in binary‬‬
‫‪Display string‬‬
‫‪Display variable in hex‬‬
‫‪Display ASCII character‬‬
‫‪Display strength‬‬
‫‪Display variable in octal‬‬
‫‪Display in current time format‬‬
‫‪Display real number in scientific format‬‬
‫‪Display real number in decimal format‬‬
‫‪Display real number in scientific or decimal format, whichever is‬‬
‫‪shorter‬‬
‫‪Format‬‬
‫‪%d or %D‬‬
‫‪%b or %B‬‬
‫‪%s or %S‬‬
‫‪%h or %H‬‬
‫‪%c or %C‬‬
‫‪%v or %V‬‬
‫‪%o or %O‬‬
‫‪%t or %T‬‬
‫‪%e or %E‬‬
‫‪%f or %F‬‬
‫‪%g or %G‬‬
‫ﺟﺪول ‪ -٣-١‬ﻟﻴﺴﺖ ﻣﺸﺨﺼﺎت ﻗﺎﻟﺒﻬﺎ‬
‫;) ‪$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‬ﺑـﻪ ﻓـﺎﻳﻞ ﺟـﺎري ﺑﻜـﺎر ﻣـﻲرود‪.‬‬
‫‪// Used as `WORD_SIZE in the code‬‬
‫‪// Include the file header.v‬‬
‫‪٣‬‬
‫‪`define WORD_SIZE 32‬‬
‫”‪`include “header.v‬‬
‫ﻣﺎﺟﻮل‬
‫ﻗﺒـﻼ ﻧﺤـﻮة ﺗﻌﺮﻳـﻒ و ﻧﻤﻮﻧﻪﺳـﺎزي ﻣـﺎﺟﻮل را دﻳﺪﻳـﻢ‪ ،‬در اﻳﻨﺠـﺎ ﺑﺼـﻮرت دﻗﻴﻘـﺘﺮ اﺟـﺰا ﻣـﺎﺟﻮل را ﻣــﻮرد‬
‫ﺑﺮرﺳﻲ ﻗــﺮار ﻣﻲدﻫﻴـﻢ‪ .‬در ﺷـﻜﻞ ‪ ٣-١‬اﺟـﺰا ﻣـﺎﺟﻮل ﻣﺸـﺨﺺ ﺷـﺪه اﺳـﺖ‪ .‬ﻗﺴـﻤﺘﻬﺎﻳﻲ ﻛـﻪ ﺑﺼـﻮرت زﻳﺮﺧـﻂدار‬
‫ﻧﻮﺷـﺘﻪ ﺷـﺪهاﻧﺪ‪ ،‬در ﺗﻌﺮﻳـﻒ ﻣـﺎﺟﻮل ﺿـﺮوري و ﺳـﺎﻳﺮ ﻗﺴـﻤﺘﻬﺎ اﺧﺘﻴـﺎري اﺳـﺖ‪ .‬ﻗﺴـﻤﺘﻬﺎﻳﻲ ﻛـﻪ ﺑﺪﻧـﺔ ﻣــﺎﺟﻮل را‬
‫ﺗﺸﻜﻴﻞ ﻣﻲدﻫﻨﺪ‪ ،‬ﻣﻲﺗﻮاﻧﻨﺪ ﺑﺎ ﻫــﺮ ﺗﺮﺗﻴﺒـﻲ در ﺗﻌﺮﻳـﻒ ﻣـﺎﺟﻮل اﺳـﺘﻔﺎده ﺷـﻮﻧﺪ‪.‬‬
‫;) ‪module module_name ( port list‬‬
‫)‪port declarations (if ports present‬‬
‫)‪parameters (optional‬‬
‫‪of wires, regs and other variables‬‬
‫‪Declaration‬‬
‫)‪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‬‬
‫‪sum‬‬
‫‪a‬‬
‫;) ‪module fulladd4 ( sum, cout, a, b, cin‬‬
‫‪b‬‬
‫‪cin‬‬
‫‪cout‬‬
‫ﺷﻜﻞ ‪ -٤-١‬ﺟﻤﻊﻛﻨﻨﺪه ‪ ٤‬ﺑﻴﺘﻲ و ﻧﺤﻮه ﺗﻌﺮﻳﻒ ﭘﻮرﺗﻬﺎي آن‬
‫‪٢-٤‬‬
‫ﺗﻌﺮﻳﻒ ﭘﻮرﺗﻬﺎ‬
‫ﺗﻤﺎم ﭘﻮرﺗﻬﺎي ﻳﻚ ﻣﺎﺟﻮل ﺑﺎﻳﺪ ﺗﻌﺮﻳﻒ ﺷــﻮﻧﺪ‪ .‬اﻳـﻦ ﺗﻌﺮﻳـﻒ ﻃﺒـﻖ ﺟـﺪول ‪ ٤-١‬ﺻـﻮرت ﻣـﻲﮔـﻴﺮد‪.‬‬
‫‪Type of port‬‬
‫‪Input Prt‬‬
‫‪Output Prt‬‬
‫‪Bidirectional Prt‬‬
‫‪Verilog Keyword‬‬
‫‪input‬‬
‫‪output‬‬
‫‪inout‬‬
‫ﺟﺪول ‪ -٤-١‬ﺗﻌﺮﻳﻒ ﭘﻮرﺗﻬﺎ‬
‫• ﻛﻠﻴﺔ ﭘﻮرﺗﻬﺎ ﺑﻄﻮر ﺿﻤﻨﻲ ﺑﺼﻮرت ‪ 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‬‬
‫‪net‬‬
‫‪reg or net‬‬
‫‪output‬‬
‫‪reg or net‬‬
‫‪net‬‬
‫‪input‬‬
‫‪module‬‬
‫ﺷﻜﻞ ‪ -٥-١‬ﻗﻮاﻧﻴﻦ اﺗﺼﺎل ﭘﻮرﺗﻬﺎ‬
‫ﻣﺪﻟﺴﺎزي در ﺳﻄﺢ ﮔﻴﺖ‬
‫‪٥‬‬
‫در ﻣﺪﻟﺴـﺎزي در ﺳـﻄﺢ ﮔﻴـﺖ ﻣـﺪار را ﺑﺼـﻮرت ﻣﺠﻤﻮﻋـﻪاي از ﮔﻴﺘـﻬﺎي ﭘﺎﻳـﻪ ﻛـﻪ ﺑـــﻪ ﻳﻜﺪﻳﮕــﺮ ﻣﺘﺼــﻞ‬
‫ﺷـﺪهاﻧﺪ ﺑﻴـﺎن ﻣﻲﻛﻨﻴـﻢ‪ .‬ﺑـﺮاي اﻳـﻦ ﻣﻨﻈـﻮر ﺑـﺎﻳﺪ اﻧـﻮاع ﮔﻴﺘـﻬﺎي ﭘﺎﻳـﻪاي ﻛـﻪ در ‪ Verilog‬وﺟـﻮد دارﻧـﺪ را ﻣﻌﺮﻓــﻲ‬
‫ﻛﻨﻴـﻢ‪.‬‬
‫ﮔﻴﺘﻬﺎي ﭘﺎﻳﻪ‬
‫‪١-٥‬‬
‫‪١-١-٥‬‬
‫ﮔﻴﺘﻬﺎي ‪and/or‬‬
‫ﺟﺪول ﺻﺤـﺖ ﮔﻴﺘـﻬﺎي ﭘﺎﻳـﺔ ‪ and/or‬در ﺷـﻜﻞ ‪ ٦-١‬آﻣـﺪه اﺳـﺖ‪.‬‬
Verilog ‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري‬
‫ ﺳــﻌﻴﺪ ﺻﻔـﺮي‬:‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‬
‫ ﻳﻚ ﻣﺎﺟﻮل ﻣﻘﺎﻳﺴﻪﮔﺮ ﭼﻬﺎرﺑﻴﺘﻲ ﺑﻨﺎم‬، ‫• ﺑﺎ اﺗﺼﺎل ﭼﻬﺎر ﻣﻘﺎﻳﺴﻪﮔﺮ ﻳﻚ ﺑﻴﺘﻲ ﻣﻄﺎﺑﻖ ﺷﻜﻞ زﻳﺮ‬
Comparator ‫ ﻓﺮض ﻛﻨﻴﺪ ﻛﻪ ﻣﺎﺟﻮل ﻣﻘﺎﻳﺴﻪﮔﺮ ﻳﻚ ﺑﻴﺘﻲ ﺑﻨـﺎم‬.‫ ﺑﺴﺎزﻳﺪ‬Comparator4
.‫ ﻧﺎﻣﮕﺬاري ﻛﻨﻴﺪ‬im8 ‫ ﺗﺎ‬im0 ‫ ﺳﻴﮕﻨﺎﻟﻬﺎي داﺧﻠﻲ ﻣﻮرد ﻧﻴﺎز را از‬.‫ﻣﻮﺟﻮد اﺳﺖ‬
a[3:0]
b[3:0]
a[0]
b[0]
gt
a
a_gt_b
b
a_eq_b
gt
eq
a_lt_b
eq
lt
im0
a[1]
a
b[1]
im1
a_gt_b
b
a_eq_b
gt
im2
eq
lt
a_lt_b
im3
a[2]
b[2]
im4
b
a_gt_b
a_eq_b
gt
im5
eq
lt
Comp0
a
a_lt_b
im6
a[3]
b[3]
im7
a_gt_b
a_gt_b
b
a_eq_b
a_eq_b
gt
im8
eq
lt
Comp1
a
a_lt_b
a_lt_b
lt
Comp2
Comp3
and
0
1
x
z
or
0
1
x
z
xor
0
1
x
z
0
1
0
0
0
1
0
x
0
x
0
1
0
1
1
1
x
1
x
1
0
1
0
1
1
0
x
x
x
x
x
z
0
0
x
x
x
x
x
x
x
z
x
x
1
1
x
x
x
x
x
z
x
x
x
x
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
x
1
x
0
1
1
0
0
0
x
0
x
0
0
1
1
0
0
1
x
x
x
x
x
z
1
1
x
x
x
x
x
x
x
z
x
x
0
0
x
x
x
x
x
z
x
x
x
x
x
x
x
x
and/or ‫ ﺟﺪول ﺻﺤﺖ ﮔﻴﺘﻬﺎي ﭘﺎﻳﺔ‬-٦-١ ‫ﺷﻜﻞ‬
and a1( out, in1, in2 );
or ( z, i1, i2 );
xor ( z1, i1, i2, i3, i4 );
nand nd( o1, i1, i2, i3 );
nor ( out, a, b, c );
xnor ( y, a, b, c, d );
//
//
//
//
//
//
and gate with two inputs
or gate with two inputs
xor gate with four inputs
nand gate with three inputs
nor gate with three inputs
xnor gate with four inputs
‫ ﺑـﻪ اﻳـﻦ ﺗﺮﺗﻴـﺐ‬.‫ ﭘﻮرت ﺧﺮوﺟﻲ و ﺑﻘﻴــﺔ ﭘﻮرﺗـﻬﺎ ورودي ﻫﺴـﺘﻨﺪ‬،‫• ﭘﻮرت اول اﻳﻦ ﮔﻴﺘﻬﺎ‬
.‫ﻣﻲﺗﻮان ﮔﻴﺘﻬﺎﻳﻲ ﺑﺎ ﺗﻌﺪاد ورودﻳﻬﺎي دﻟﺨﻮاه داﺷﺖ‬
‫ ﻣﻲﺗﻮان ﻧﺎم ﻧﻤﻮﻧﻪ را ذﻛﺮ ﻧﻜﺮد ) اﻳﻦ اﻣــﺮ‬،‫• ﺑﻪ ﻫﻨﮕﺎم ﻧﻤﻮﻧﻪﺳﺎزي ) اﺳﺘﻔﺎدة ( از اﻳﻦ ﮔﻴﺘﻬﺎ‬
.( ‫ ﺻﺎدق اﺳﺖ‬Verilog ‫در ﻣﻮرد ﺗﻤﺎم اﻟﻤﺎﻧﻬﺎي از ﭘﻴﺶ ﺳﺎﺧﺘﻪ ﺷﺪة‬
‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫‪٢-١-٥‬‬
‫ﮔﻴﺘﻬﺎي ‪buf/not‬‬
‫ﺟﺪول ﺻﺤــﺖ ﮔﻴﺘـﻬﺎي ﭘﺎﻳـﺔ ‪ buf/not‬در ﺷـﻜﻞ ‪ ٧-١‬آﻣـﺪه اﺳـﺖ‪.‬‬
‫‪ctrl‬‬
‫‪ctrl‬‬
‫‪z‬‬
‫‪L‬‬
‫‪x‬‬
‫‪L‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪z‬‬
‫‪bufif1‬‬
‫‪0‬‬
‫‪z‬‬
‫‪L‬‬
‫‪x‬‬
‫‪L‬‬
‫‪1‬‬
‫‪z‬‬
‫‪0‬‬
‫‪0‬‬
‫‪bufif0‬‬
‫‪0‬‬
‫‪out‬‬
‫‪0‬‬
‫‪buf‬‬
‫‪0‬‬
‫‪H‬‬
‫‪x‬‬
‫‪H‬‬
‫‪x‬‬
‫‪1‬‬
‫‪x‬‬
‫‪z‬‬
‫‪z‬‬
‫‪1‬‬
‫‪x‬‬
‫‪H‬‬
‫‪x‬‬
‫‪H‬‬
‫‪x‬‬
‫‪z‬‬
‫‪z‬‬
‫‪1‬‬
‫‪x‬‬
‫‪1‬‬
‫‪x‬‬
‫‪1‬‬
‫‪x‬‬
‫‪1‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪z‬‬
‫‪z‬‬
‫‪x‬‬
‫‪x‬‬
‫‪z‬‬
‫‪x‬‬
‫‪z‬‬
‫‪x‬‬
‫‪z‬‬
‫‪z‬‬
‫‪x‬‬
‫‪1‬‬
‫‪0‬‬
‫‪notif1‬‬
‫‪z‬‬
‫‪x‬‬
‫‪1‬‬
‫‪0‬‬
‫‪notif0‬‬
‫‪out‬‬
‫‪not‬‬
‫‪H‬‬
‫‪L‬‬
‫‪H‬‬
‫‪L‬‬
‫‪1‬‬
‫‪0‬‬
‫‪z‬‬
‫‪z‬‬
‫‪0‬‬
‫‪1‬‬
‫‪H‬‬
‫‪L‬‬
‫‪H‬‬
‫‪L‬‬
‫‪z‬‬
‫‪z‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪z‬‬
‫‪z‬‬
‫‪x‬‬
‫‪z‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪z‬‬
‫‪z‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪z‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪z‬‬
‫‪ctrl‬‬
‫‪ctrl‬‬
‫ﺷﻜﻞ ‪ -٧-١‬ﺟﺪول ﺻﺤﺖ ﮔﻴﺘﻬﺎي ﭘﺎﻳﺔ ‪buf/not‬‬
‫• ﭘﻮرت آﺧﺮ ﮔﻴﺘﻬﺎي ‪ ، not, buf‬ﭘﻮرت ورودي و ﺑﻘﻴﺔ ﭘﻮرﺗﻬﺎ ﺧﺮوﺟﻲ ﻫﺴــﺘﻨﺪ‪ .‬ﺑـﻪ اﻳـﻦ‬
‫ﺗﺮﺗﻴﺐ ﻣﻲﺗﻮان ﮔﻴﺘﻬﺎﻳﻲ ﺑﺎ ﺗﻌﺪاد ﺧﺮوﺟﻴﻬﺎي دﻟﺨﻮاه داﺷﺖ‪.‬‬
‫• در ﻣﻮرد ﮔﻴﺘﻬﺎي دﻳﮕﺮ ﭘﻮرت اول ﺧﺮوﺟﻲ‪ ،‬ﭘﻮرت ﺑﻌﺪي ورودي و ﭘﻮرت ﺳــﻮم ﻛﻨـﺘﺮل‬
‫اﺳﺖ‪.‬‬
‫• ‪ L‬ﺑﻪ ﻣﻌﻨﺎي ‪ 0‬ﻳﺎ ‪ z‬و ‪ H‬ﺑﻪ ﻣﻌﻨﺎي ‪ 1‬ﻳﺎ ‪ z‬ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫‪// buffer with 2 outputs‬‬
‫‪// not with output control‬‬
‫;) ‪buf b1 ( o1, o2, i1‬‬
‫;) ‪notif1 ( z_bar, in, ctrl‬‬
‫ﺑـﺮاي ﻃﺮاﺣـﻲ ﻣـﺪار در ﺳـﻄﺢ ﮔﻴـﺖ‪ ،‬اﺑﺘـﺪا ﺑـﺎﻳﺪ آﻧـﺮا ﺑﺼـﻮرت ﻣﺠﻤﻮﻋـــﻪاﻳﻲ از ﮔﻴﺘــﻬﺎي ﭘﺎﻳــﻪ درآورد‪،‬‬
‫ﺳﭙﺲ ﺑﺎ ﺗﻌﺮﻳﻒ ‪ 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
i1
y1
i2
y2
i3
y3
out
// Internal wire declaration
wire s0n, s1n, y0, y1, y2, y2;
// Gate instantiations
not ( s1n, s1 );
not ( s0n, s0 );
and
and
and
and
s1
s0
(
(
(
(
y0,
y1,
y2,
y3,
i0,
i1,
i2,
i3,
s1n,
s1n,
s1 ,
s1 ,
s0n
s0
s1n
s0
);
);
);
);
or ( out, y0, y1, y2, y3 );
endmodule
‫ ﻣﺮﺑﻮﻃﻪ‬Verilog ‫ در ﺳﻄﺢ ﮔﻴﺖ و ﻛﺪ‬١ ‫ ﺑﻪ‬٤ ‫ ﻧﻘﺸﺔ ﺷﻤﺎﺗﻴﻚ ﻣﺎﻟﺘﻲﭘﻠﻜﺴﺮ‬-٨-١ ‫ﺷﻜﻞ‬
//Module 1-bit comparator
a
module Comparator( a_gt_b, a_eq_b, a_lt_b,
a, b, gt, eq, lt );
im2
gt
b
im3
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
eq
a_eq_b
im6
im1
im7
im8
lt
im9
a_lt_b
// Gate instantiation
not ( im0, b );
not ( im1, a );
nand ( im2, a, gt );
nand ( im3, gt, im0 );
nand ( im4, a, im0 );
nand ( im5, a, b, eq );
nand ( im6, im0, eq, im1 );
nand ( im7, im1, b );
nand ( im8, im1, lt );
nand ( im9, lt, b );
nand ( a_gt_b, im2, im3, im4 );
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‬در ﻧﻈــﺮ‬
‫ﮔﺮﻓﺘﻪ ﻣﻲﺷــﻮﻧﺪ‪.‬‬
‫‪TFall‬‬
‫‪TRise‬‬
‫‪1‬‬
‫‪1,x,z‬‬
‫‪0,x,z‬‬
‫‪0‬‬
‫‪// Rise=5, Fall=5, Turn-Off=5‬‬
‫‪// Rise=4, Fall=6, Turn-Off=4‬‬
‫‪// Rise=4, Fall=5, Turn-Off=6‬‬
‫‪٢-٢-٥‬‬
‫;) ‪and #(5) ( o1, i1, i2‬‬
‫;) ‪and #(4,6) ( o1, i1, i2‬‬
‫;) ‪and #(4,5,6) ( o1, i1, i2‬‬
‫ﻣﻘﺎدﻳﺮ ‪Min/Typ/Max‬‬
‫در ‪ Verilog‬ﻫـﺮ ﻳـﻚ از ﺗﺎﺧﻴﺮﻫـﺎ داراي ﻳـﻚ ﻣﻘـﺪار ﻣﻴﻨﻴﻤـــﻮم‪ ،‬ﻳــﻚ ﻣﻘــﺪار ﻣﻌﻤﻮﻟــﻲ و ﻳــﻚ ﻣﻘــﺪار‬
‫ﻣﺎﻛﺰﻳﻤﻮم اﺳﺖ‪ .‬اﻳــﻦ ﺗﺎﺧﻴﺮﻫـﺎ داراي ﺷـﻜﻞ ﻛﻠـﻲ ‪ Min : Typ : Max‬ﻫﺴـﺘﻨﺪ‪ .‬اﻧﺘﺨـﺎب ﻳﻜـﻲ از اﻳـﻦ ﺗﺎﺧﻴﺮﻫـﺎ‬
‫در زﻣﺎن اﺟﺮا ﺻــﻮرت ﻣـﻲﮔـﻴﺮد‪ .‬ﻣﺜـﻼ در ﺑﻌﻀـﻲ ﺷﺒﻴﻪﺳـﺎزﻫﺎ وﻗﺘـﻲ اﺟـﺮا ﺑـﺎ ﺳـﻮﺋﻴﭻ ‪ +maxdelay‬اﻧﺠـﺎم ﺷـﻮد‪،‬‬
‫ﺑﺮاي ﺗﻤﺎم ﮔﻴﺘﻬﺎ ﻣﻘــﺪار ﻣـﺎﻛﺰﻳﻤﻮم ﺗﺎﺧﻴﺮﻫـﺎ در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣﻲﺷـﻮد‪.‬‬
‫‪T=Turn-Off Delay‬‬
‫‪F=Fall Dealy‬‬
‫‪// R=Rise Dealy‬‬
‫‪// 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‬‬
‫)‪min(3,5‬‬
‫)‪min(4,6‬‬
‫)‪min(5,7‬‬
‫;)‬
‫= ‪5, T‬‬
‫= ‪6, T‬‬
‫= ‪7, T‬‬
‫‪i1, i2‬‬
‫‪// Two delays are specified‬‬
‫= ‪// if +mindelay, R = 3, F‬‬
‫= ‪// if +typdelay, R = 4, F‬‬
‫= ‪// if +maxdelay, R = 5, F‬‬
‫‪and #( 4:5:6, 5:6:7 ) ( o1,‬‬
‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫;) ‪i1, i2‬‬
‫= ‪T‬‬
‫= ‪T‬‬
‫= ‪T‬‬
‫‪o1,‬‬
‫‪// Three delays are specified‬‬
‫‪// if +mindelay, R = 2, F = 3,‬‬
‫‪// if +typdelay, R = 3, F = 4,‬‬
‫‪// if +maxdelay, R = 4, F = 5,‬‬
‫( ) ‪and #( 2:3:4, 3:4:5, 4:5:6‬‬
‫• ﺗﻮﺟﻪ ﻛﻨﻴﺪ ﻛﻪ ﺗﺎﺧﻴﺮ ﮔﻴﺘﻬﺎ ﻓﻘﻂ ﺑﻪ ﻫﻨﮕﺎم ﺷﺒﻴﻪﺳﺎزي ﻣﺪارﻫﺎ ﻣﻔﻴــﺪ ﻫﺴـﺘﻨﺪ‪ ،‬و‬
‫وﻗﺘﻲ ﻫﺪف ﺳﻨﺘﺰ ﻣﺪار ﻣﻲﺑﺎﺷﺪ ﺑﻪ ﻫﻴﭻوﺟﻪ ﻧﺒﺎﻳﺪ از ﺗﺎﺧﻴﺮ در ﺗﻮﺻﻴــﻒ ﻣـﺪار‬
‫اﺳﺘﻔﺎده ﺷﻮد‪.‬‬
‫ﻣﺪﻟﺴﺎزي در ﺳﻄﺢ ﺟﺮﻳﺎن داده‬
‫‪٦‬‬
‫در ﻣﺪﻟﺴﺎزي در ﺳــﻄﺢ ﺟﺮﻳـﺎن داده ﺑـﻪ ﻧﺤـﻮة اﻧﺘﻘـﺎل اﻃﻼﻋـﺎت ﺑﻴـﻦ ﺛﺒﺎﺗـﻬﺎ و ﭘـﺮدازش اﻃﻼﻋـﺎت اﻫﻤﻴـﺖ‬
‫ﻣﻲدﻫﻴـﻢ‪ .‬در اﻳـﻦ ﻗﺴـﻤﺖ ﺑـﻪ ﭼﮕﻮﻧﮕـــﻲ ﻣﺪﻟﺴــﺎزي در ﺳــﻄﺢ ﺟﺮﻳــﺎن داده در زﺑــﺎن ‪ 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‬‬
‫;‪output o1‬‬
‫;‪input i1, i2‬‬
‫‪i0‬‬
‫‪<5‬‬
‫‪>5‬‬
‫‪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
Type
Arithmetic
Logical
Relational
Equality
Bitwise
Reduction
Shift
Reduction
Conditional
Operator
Symbol
Operation Performed
Number of
Operands
*
/
+
%
!
&&
||
>
<
>=
<=
==
!=
===
!==
~
&
|
^
~^ or ^~
&
~&
|
~|
^
~^ or ^~
>>
<<
{}
{ {} }
?:
multiply
division
add
subtract
modulus
logical negation
logical and
logical or
greater than
less than
greater than or equal
less than or equal
equality
inequality
case equality
case inequality
bitwise negation
bitwise and
bitwise or
bitwise xor
bitwise xnor
reduction and
reduction nand
reduction or
reduction nor
reduction xor
reduction xnor
right shift
left shift
concatenation
replication
conditional
2
2
2
2
2
1
2
2
2
2
2
2
2
2
2
2
1
2
2
2
2
1
1
1
1
1
1
2
2
any number
any number
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‬ﺑﺎﺷــﺪ‬
‫ﻣﻌﺎدل ﻧﺎﻣﻌﻠﻮم ارزﻳﺎﺑﻲ ﻣﻲﺷﻮد‪.‬‬
‫;‪= 0‬‬
‫) ‪Evaluated to 0 ( False‬‬
‫) ‪Evaluated to 1 ( True‬‬
‫) ‪Evaluated to 0 ( False‬‬
‫‪B‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫;‪A = 3‬‬
‫‪A && B‬‬
‫‪A || B‬‬
‫‪!A‬‬
‫‪//--------------------------------------------------------‬‬‫;‪A = 2’bx0‬‬
‫;‪B = 2’b10‬‬
‫) ‪A && B // Evaluated to x ( Unknown‬‬
‫• در ﻣﻮرد اﭘﺮاﺗﻮراﻟﺤﺎق ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬
‫• اﭘﺮﻧﺪﻫﺎ ﺣﺘﻤﺎ ﺑﺎﻳﺪ اﻋﺪاد اﻧﺪازهدار ﺑﺎﺷﻨﺪ ﺗــﺎ ‪ Verilog‬ﻗـﺎدر ﺑـﻪ ﻣﺤﺎﺳـﺒﺔ‬
‫اﻧﺪازة ﻧﺘﻴﺠﻪ ﺑﺎﺷﺪ‪.‬‬
‫• اﭘﺮﻧﺪﻫﺎ ﻣﻲﺗﻮاﻧﻨﺪ ‪ ، reg ، net‬ﺑﺮداري از ‪ reg ، net‬ﻳﺎ اﻋــﺪاد اﻧـﺪازهدار‬
‫ﺑﺎﺷﻨﺪ‪.‬‬
‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫;‪1’b1‬‬
‫;‪B = 2’b00‬‬
‫;‪D = 2’b10‬‬
‫;‪C = 3’b110‬‬
‫;} ‪{ B, C‬‬
‫‪// Result y is 4’b0010‬‬
‫;} ‪{ A, B ,C, D, 3’b001‬‬
‫‪// Result y is 11’b1_00_10_110_001‬‬
‫;} ]‪{ A, b[0], C[1‬‬
‫‪// Result y is 3’b101‬‬
‫=‬
‫=‬
‫=‬
‫=‬
‫‪A‬‬
‫‪y‬‬
‫‪y‬‬
‫‪y‬‬
‫• در ﻣﻮرد اﭘﺮاﺗﻮرﺗﻜﺮار ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬
‫• ﻳﻚ ﺛﺎﺑﺖ ﺗﻜﺮار ﻣﺸﺨﺺ ﻣﻲﻛﻨﺪ ﻛﻪ ﭼﻨﺪﺑﺎر ﻋﺪد داﺧــﻞ }{ ﺑـﺎﻳﺪ ﺗﻜـﺮار‬
‫ﺷﻮد‪.‬‬
‫;‪D = 2’b10‬‬
‫‪// Result y is 4’b1111‬‬
‫‪// Result y is 8’b11110000‬‬
‫‪// Result y is 10’b1111000010‬‬
‫;‪B = 2’b00‬‬
‫;‪A = 1’b1‬‬
‫;} }‪y = { 4{A‬‬
‫;} }‪y = { 4{A}, 2{B‬‬
‫;} ‪y = { 4{A}, 2{B}, C‬‬
‫• در ﻣﻮرد اﭘﺮاﺗﻮر ﺷﺮﻃﻲ ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬
‫• ﻗﺎﻟﺐ اﺳﺘﻔﺎده از اﭘﺮاﺗﻮر ﺷﺮﻃﻲ ﺑﺼﻮرت زﻳﺮ اﺳﺖ ‪:‬‬
‫;‪<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‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫;‪N = 4’b1xxx‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪logical‬‬
‫‪logical‬‬
‫‪x‬‬
‫‪logical‬‬
‫‪logical‬‬
‫‪logical‬‬
‫;‪A = 3‬‬
‫;‪B = 3‬‬
‫;‪X = 4’b1010‬‬
‫;‪Y = 4’b1101‬‬
‫;‪Z = 4’b1xzz‬‬
‫;‪M = 4’b1xzz‬‬
‫‪is‬‬
‫‪is‬‬
‫‪is‬‬
‫‪is‬‬
‫‪is‬‬
‫‪is‬‬
‫‪Result‬‬
‫‪Result‬‬
‫‪Result‬‬
‫‪Result‬‬
‫‪Result‬‬
‫‪Result‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪== B‬‬
‫‪!= B‬‬
‫‪== Z‬‬
‫‪=== M‬‬
‫‪=== N‬‬
‫‪!== M‬‬
‫‪A‬‬
‫‪A‬‬
‫‪X‬‬
‫‪Z‬‬
‫‪Z‬‬
‫‪M‬‬
‫• در ﻣﻮرد اﭘﺮاﺗﻮرﻫﺎي ﻛﺎﻫﺸﻲ )‪ (reduction‬ﺑﺎﻳﺪ ﺑﻪ ﻣﻮارد زﻳﺮ ﺗﻮﺟﻪ داﺷﺖ ‪:‬‬
‫• اﻳﻦ اﭘﺮاﺗﻮرﻫﺎ داراي ﻳﻚ اﭘﺮﻧﺪ ﻫﺴﺘﻨﺪ و ﻋﻤﻠﻴﺎت ﺑﻴﺘﻲ ﻣﺸــﺨﺺ ﺷـﺪه را‬
‫روي ﺗﻚﺗﻚ اﻋﻀﺎي ﺑﺮدار اﭘﺮﻧﺪ آن اﻧﺠــﺎم داده و ﻳـﻚ ﺑﻴـﺖ را ﺑﻌﻨـﻮان‬
‫ﻧﺘﻴﺠﻪ ﺑﺮﻣﻲﮔﺮداﻧﺪ‪.‬‬
‫‪// Equivalent to 1 & 0 & 1 & 0, Result is 1’b0‬‬
‫‪// Equivalent to 1 | 0 | 1 | 0, Result is 1’b0‬‬
‫‪// Equivalent to 1 ^ 0 ^ 1 ^ 0, Result is 1’b0‬‬
‫;‪x = 4’b1010‬‬
‫‪&x‬‬
‫‪|x‬‬
‫‪^x‬‬
‫ﺣـﺎل ﺳـﻌﻲ ﻣﻲﻛﻨﻴـﻢ ﺑـﺎ ذﻛـﺮ ﭼﻨـﺪ ﻣﺜـﺎل ﺑـﻪ ﻧﺤـﻮة ﻣﺪﻟﺴـﺎزي ﻣﺪارﻫـﺎي دﻳﺠﻴﺘـﺎل در ﺳـﻄﺢ ﺟﺮﻳــﺎن داده‬
‫ﺑﭙﺮدازﻳـﻢ‪.‬‬
‫ﻣﺜﺎل‪ : ١‬ﻳﻚ ﻣﺎﻟﺘﻲﭘﻠﻜﺴــﺮ ‪ ٤‬ﺑـﻪ ‪ ١‬ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‪.‬‬
‫‪// 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
assign a_gt_b = ( a & gt ) | ( ~b & gt ) |
assign a_eq_b = ( a & b & eq ) | ( ~a & ~b
assign a_lt_b = ( ~a & lt ) | ( b & lt ) |
comparator
( a & ~b );
& eq );
( ~a & b );
endmodule
‫ ﺑﻴﺘـﻲ را ﻣﺤﺎﺳـﺒﻪ ﻣﻲﻛﻨـﺪ‬٤ ‫ ﻳﻚ ﻋﺪد ﺑــﺎﻳﻨﺮي‬٢ ‫• در ﺷﻜﻞ زﻳﺮ ﻃﺮح ﺷﻤﺎﺗﻴﻚ ﻣﺪاري ﻛﻪ ﻣﻜﻤﻞ‬
.‫ اﻳﻦ ﻣﺪار را در ﺳﻄﺢ ﺟﺮﻳﺎن داده ﺗﻮﺻﻴﻒ ﻛﻨﻴﺪ‬.‫ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‬
a3
a2
a1
a0
E
c2
a* 3
c1
a* 2
c0
a *1
C-1=0
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‬‬
‫‪Statement executed‬‬
‫;‪m = 1’b0‬‬
‫;‪a = 1’b1‬‬
‫;‪x = 1’b0‬‬
‫;‪b = 1’b0‬‬
‫;‪y = 1’b1‬‬
‫;‪$finish‬‬
‫‪Time‬‬
‫‪0‬‬
‫‪5‬‬
‫‪10‬‬
‫‪30‬‬
‫‪35‬‬
‫‪50‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪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‬‬
‫آورده ﻣﻲﺷـﻮد‪ .‬دراﻳﻨﺤـﺎﻟﺖ ﻋﺒـﺎرت ﺳـﻤﺖ راﺳـﺖ در زﻣـﺎن ﻓﻌﻠـﻲ ﻣﺤﺎﺳـﺒﻪ ﺷـﺪه‪ ،‬ﭘـــﺲ از ﮔﺬﺷــﺖ‬
‫زﻣﺎن ﺗﺎﺧﻴﺮ درون ﻋﺒﺎرت ﺳــﻤﺖ ﭼـﭗ ﻗـﺮار ﻣـﻲﮔـﻴﺮد‪.‬‬
‫;‪temp = x + z‬‬
‫‪٢-٣-٧‬‬
‫‪initial‬‬
‫‪begin‬‬
‫;‪x = 0‬‬
‫;‪z = 0‬‬
‫;‪y = #5 x + z‬‬
‫‪end‬‬
‫‪// Is equivalent to‬‬
‫‪initial‬‬
‫‪begin‬‬
‫;‪x = 0‬‬
‫;‪z = 0‬‬
‫;‪#5 y = temp‬‬
‫‪end‬‬
‫ﻛﻨﺘﺮل زﻣﺎن ﻣﺒﺘﻨﻲ ﺑﺮ روﻳﺪاد‬
‫ﻳﻚ روﻳــﺪاد ﺑـﻪ ﻣﻌﻨـﺎي ﺗﻐﻴـﻴﺮ ﻣﻘـﺪار ﻳـﻚ ‪ reg‬ﻳـﺎ ‪ net‬اﺳـﺖ‪ .‬ﭼـﻬﺎرﻧﻮع ﻛﻨـﺘﺮل زﻣـﺎن ﻣﺒﺘﻨـﻲ ﺑـﺮ روﻳـﺪاد‬
‫وﺟــﻮد دارد‪.‬‬
‫•‬
‫ﻛﻨـﺘﺮل روﻳـﺪاد ﺑـﺎ ﻗـﺎﻋﺪه ‪ :‬ﻋﻼﻣـﺖ @ ﺑـﺮاي ﻣﺸـﺨﺺ ﻛـﺮدن ﻛﻨـﺘﺮل روﻳـﺪاد اﺳـﺘﻔﺎده ﻣﻲﺷــﻮد‪.‬‬
‫دﺳﺘﻮرات ﻣﻲﺗﻮاﻧﻨــﺪ ﺑـﺎ ﺗﻐﻴـﻴﺮ ﻣﻘـﺪار ﻳـﻚ ﺳـﻴﮕﻨﺎل‪ ،‬ﺑـﺎ ﻟﺒـﺔ ﺑـﺎﻻروﻧﺪه ﻳـﺎ ﭘـﺎﻳﻴﻦ روﻧـﺪة ﻳـﻚ ﺳـﻴﮕﻨﺎل‬
‫اﺟـﺮا ﺷـﻮﻧﺪ‪ .‬ﻟﺒـﺔ ﺑـﺎﻻروﻧﺪه ﺑـﻪ ﻣﻌﻨـﻲ ﻳﻜـﻲ از ﺗﻐﻴـــﻴﺮات ‪ 0 → 1, x , z; x → 1; z → 1‬و ﻟﺒــﺔ‬
‫ﺑـﺎﻻروﻧﺪه ﺑـﻪ ﻣﻌﻨـﻲ ﻳﻜـﻲ از ﺗﻐﻴـﻴﺮات ‪ 1 → 0, x, z; x → 0; z → 0‬ﻣﻲﺑﺎﺷـــﺪ‪.‬‬
‫‪Triggered with any change in clock‬‬
‫‪Triggered positive edge of clock‬‬
‫‪Triggered negative edge of clock‬‬
‫‪d is evaluated immediately and‬‬
‫‪assigned to q at negative edge of clock‬‬
‫•‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫‪//‬‬
‫;‪@(clock) q = d‬‬
‫;‪@(posedge clock) q = d‬‬
‫;‪@(negedge clock) q = d‬‬
‫;‪q = @(posedge clock) d‬‬
‫ﻛﻨﺘﺮل روﻳﺪاد ﺑﺎ ﻧﺎم ‪ 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‬‬
‫‪٤-٧‬‬
‫دﺳﺘﻮر ﺷﺮﻃﻲ‬
‫‪٥-٧‬‬
‫دﺳﺘﻮر ‪case‬‬
‫) ‪if( expr‬‬
‫‪true_st‬‬
‫‪else‬‬
‫;‪false_st‬‬
‫)‬
‫;‪st1‬‬
‫;‪st2‬‬
‫;‪stn‬‬
‫;‪def_st‬‬
‫‪case ( expr‬‬
‫‪case 1 :‬‬
‫‪case 2 :‬‬
‫‪...‬‬
‫‪case n :‬‬
‫‪defult :‬‬
‫‪endcase‬‬
‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫• ﻋﺒﺎرت ‪ expr‬ﺑﺎ ﺗﻚﺗﻚ ﻣﻮارد ﺑﻴﺖ ﺑﻪ ﺑﻴﺖ ﻣﻘﺎﻳﺴﻪ ﻣﻲﺷﻮد )ﺑﺎ در ﻧﻈﺮﮔﺮﻓﺘﻦ ‪.( x, 1, 0‬‬
‫• اﮔﺮ ﻃﻮل ﻋﺒﺎرت ﺑﺎ ﻣﻮارد ﻣﻮرد ﻣﻘﺎﻳﺴﻪ ﻳﻜﺴﺎن ﻧﺒﺎﺷﺪ‪ ،‬ﺳﻤﺖ ﭼﭗ ﺟﺰء ﻛﻮﭼﻜﺘﺮ ﺑﺎ ‪ ٠‬ﭘﺮ‬
‫ﻣﻲﺷﻮد‪.‬‬
‫• درﺻﻮرت اﺳﺘﻔﺎده از ‪ casex‬ﻣﻘﺎدﻳﺮ ‪ z, x‬ﺑﺼﻮرت ﺑﻲاﻫﻤﻴــﺖ )‪ (d’ont care‬ﺗﻠﻘـﻲ‬
‫ﻣﻲﺷﻮﻧﺪ ﻳﻌﻨﻲ در ﻣﻘﺎﻳﺴﻪ ﻧﻘﺸﻲ ﻧﺪارﻧﺪ‪.‬‬
‫• درﺻﻮرت اﺳﺘﻔﺎده از ‪ casez‬ﻣﻘﺪار ‪ z‬ﺑﺼﻮرت ﺑﻲاﻫﻤﻴﺖ )‪ (d’ont care‬ﺗﻠﻘﻲ ﻣﻲﺷﻮد‬
‫ﻳﻌﻨﻲ در ﻣﻘﺎﻳﺴﻪ ﻧﻘﺸﻲ ﻧﺪارد‪.‬‬
‫‪٦-٧‬‬
‫ﺣﻠﻘﻪﻫﺎ‬
‫‪٧-٧‬‬
‫‪Tasks and Functions‬‬
‫) ‪while( expr‬‬
‫;‪st‬‬
‫‪//--------------------------------------‬‬‫) ‪for( init; end_cond; chang_control_var‬‬
‫;‪st‬‬
‫‪//--------------------------------------‬‬‫) ‪repeat( number_of_iteration‬‬
‫;‪st‬‬
‫‪//--------------------------------------‬‬‫‪forever‬‬
‫;‪st‬‬
‫‪ Task‬و ﺗﺎﺑﻊ داراي ﺗﻔﺎوﺗــﻬﺎﻳﻲ ﻫﺴـﺘﻨﺪ ﻛـﻪ در ﺟـﺪول ‪ ٦-١‬ﻧﺸـﺎن داده ﺷـﺪه اﺳـﺖ‪.‬‬
‫‪Task‬‬
‫‪١-٧-٧‬‬
‫ﺑﻮﺳﻴﻠﺔ ‪ task ... endtask‬ﻣﺸــﺨﺺ ﻣﻲﺷـﻮد‪ .‬ﻣﻌﻤـﻮﻻ در ﻣـﻮارد زﻳـﺮ اﺳـﺘﻔﺎده ﻣﻲﺷـﻮد‪.‬‬
‫•‬
‫در ﭘﺮوﺳﻴﺠﺮ ﺗﺎﺧﻴﺮ‪ ،‬زﻣﺎﻧﺒﻨﺪي و ﻳــﺎ ﻛﻨـﺘﺮل زﻣـﺎن وﺟـﻮد داﺷـﺘﻪ ﺑﺎﺷـﺪ‪.‬‬
‫•‬
‫ﭘﺮوﺳﻴﺠﺮ ﭘﺎراﻣﺘﺮ ﺧﺮوﺟﻲ ﻧﺪاﺷﺘﻪ ﺑﺎﺷــﺪ و ﻳـﺎ ﺑﻴـﺶ از ﻳـﻚ ﭘـﺎراﻣﺘﺮ ﺧﺮوﺟـﻲ داﺷـﺘﻪ ﺑﺎﺷـﺪ‪.‬‬
‫•‬
‫ﭘﺮوﺳﻴﺠﺮ ﻫﻴــﭻ ﭘـﺎراﻣﺘﺮ ورودي ﻧﺪاﺷـﺘﻪ ﺑﺎﺷـﺪ‪.‬‬
‫ﺧﻮدآﻣـﻮز زﺑـﺎن ﺗﻮﺻﻴـﻒ ﺳــﺨﺖاﻓﺰاري ‪Verilog‬‬
‫ﺗﻬﻴﻪ ﻛﻨﻨﺪه‪ :‬ﺳــﻌﻴﺪ ﺻﻔـﺮي‬
‫‪Task‬‬
‫ﻳﻚ ‪ task‬ﻣﻲﺗﻮاﻧﺪ ﺗﻮاﺑﻊ و ‪ task‬ﻫﺎي دﻳﮕﺮ را ﻓﻌﺎل ﻛﻨﺪ‪.‬‬
‫‪Function‬‬
‫ﻳﻚ ﺗﺎﺑﻊ ﻓﻘﻂ ﻣﻲﺗﻮاﻧﺪ ﺗﻮاﺑﻊ دﻳﮕﺮ را ﻓﻌﺎل ﻛﻨﺪ‪.‬‬
‫ﻳﻚ ‪ task‬ﻣﻤﻜﻦ اﺳﺖ در زﻣﺎن ‪ 0‬اﺟﺮا ﻣﻲﺷﻮد‪.‬‬
‫ﻳﻚ ﺗﺎﺑﻊ ﻫﻤﻴﺸﻪ در زﻣﺎن ‪ 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‬‬
‫‪//outputs from the task‬‬
‫‪//inputs to the task‬‬
‫‪// Define task bitwise_oper‬‬
‫;‪task bitwise_oper‬‬
‫;‪output [15:0] ab_and, ab_or, ab_xor‬‬
‫;‪input [15:0] a, b‬‬
‫‪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
`define got1
`define got11
2'd0
2'd1
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
`got1 : cur_state
`got11 : cur_state
endcase
end
)
= x ? `got1 : `init;
= x ? `got11 : `init;
= x ? `got11 : `init;
assign y = (cur_state==`got11 && x==1’b0) ? 1’b1 : 1’b0;
endmodule
.‫ را ﺑـﺎ اﺳـﺘﻔﺎده از ﻣـﺪل ﻫـﺎﻓﻤﻦ ﻣﺪﻟﺴـﺎزي ﻛﻨﻴـﺪ‬٤ ‫ دﻳﺎﮔﺮام ﺣﺎﻟﺖ ﻣﺜــﺎل‬: ٥ ‫ﻣﺜﺎل‬
// Mealy state machine (Hufmann Model)
`define init
`define got1
`define got11
2'd0
2'd1
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
got1
1
0
0
0
0/0
0
1
1
got110
got11
0
1
1
0
// Moore state machine
`define
`define
`define
`define
init
got1
got11
got110
2'd0
2'd1
2'd2
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 =
`got1
: cur_state =
`got11 : cur_state =
`got110 : cur_state =
endcase
end
x
x
x
x
?
?
?
?
`got1
`got11
`got11
`got1
:
:
:
:
`init;
`init;
`got110;
`init;
assign y = (cur_state==`got110) ? 1’b1 : 1’b0;
endmodule
.‫ را ﺑـﺎ اﺳـﺘﻔﺎده از ﻣـﺪل ﻫـﺎﻓﻤﻦ ﻣﺪﻟﺴـﺎزي ﻛﻨﻴـﺪ‬٦ ‫ دﻳﺎﮔﺮام ﺣﺎﻟﺖ ﻣﺜــﺎل‬: ٧ ‫ﻣﺜﺎل‬
// Moore state machine (Hufmann Model)
`define
`define
`define
`define
init
got1
got11
got110
2'd0
2'd1
2'd2
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
begin
case ( present_state )
`init
: next_state
`got1
: next_state
`got11 : next_state
`got110 : next_state
endcase
end
x )
=
=
=
=
x
x
x
x
?
?
?
?
`got1
`got11
`got11
`got1
:
:
:
:
`init;
`init;
`got110;
`init;
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
nmos
0
1
x
z
0
z
z
z
z
1
0
1
x
z
Control
x
L
H
x
z
z
L
H
x
z
nmos
0
1
x
z
0
0
1
x
z
1
z
z
z
z
x
L
H
x
z
Data
z
L
H
x
z
Out
Pcontrol
‫ و ﺟﺪول ﺻﺤﺖ آﻧﻬﺎ‬MOS ‫ ﺳﻮﺋﻴﭽﻬﺎي‬-١١-١ ‫ﺷﻜﻞ‬
nmos n1 ( out, data, control );
pmos ( out, data, control );
cmos c1 ( out, data, ncontrol, pcontrol );
‫ﺳﻮﺋﻴﭽﻬﺎي دوﺳﻮﻳﻪ‬
٢-٨
.‫ ﺳــﻮﺋﭽﻬﺎي دوﺳـﻮﻳﻪ ﻧﻤـﺎﻳﺶ داده ﺷـﺪه اﺳـﺖ‬١٢-١ ‫در ﺷﻜﻞ‬
control
inout1
inout2
tran
inout1
control
inout2
tranif0
inout1
inout2
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‬ﺑـﻪ اﺑﺘـﺪاي ﻧـﺎم ﺳـﻮﺋﻴﭽﻬﺎي ﻣﻌﻤﻮﻟـﻲ ﺑﺪﺳـﺖ ﻣﻲآﻳﻨـﺪ‪.‬‬
‫‪// Resistive nmos,pmos switches‬‬
‫‪// Resistive cmos switch‬‬
‫‪// Resistive tran,tranif0,tranif1 switches‬‬
‫‪Output Strength‬‬
‫‪pull‬‬
‫‪pull‬‬
‫‪weak‬‬
‫‪medium‬‬
‫‪medium‬‬
‫‪small‬‬
‫‪small‬‬
‫‪high‬‬
‫‪rnmos, rpmos‬‬
‫‪rcmos‬‬
‫‪rtran, rtranif0, rtranif1‬‬
‫‪Input Strength‬‬
‫‪supply‬‬
‫‪strong‬‬
‫‪pull‬‬
‫‪weak‬‬
‫‪large‬‬
‫‪medium‬‬
‫‪small‬‬
‫‪high‬‬
‫ﺟﺪول ‪ -٧-١‬ﺟﺪول ﺗﻀﻌﻴﻒ ﺳﻴﮕﻨﺎل ﺳﻮﺋﻴﭽﻬﺎي ﻣﻘﺎوﻣﺘﻲ‬
‫ﻣﺜﺎل ‪ :‬ﻳﻚ ﻣﺎﻟﺘﻲ ﭘﻠﻜﺴــﺮ ‪ ٢‬ﺑـﻪ ‪ ١‬ﻃﺮاﺣـﻲ ﻛﻨﻴـﺪ‪.‬‬
‫;) ‪module mux2_to_1 ( out, i0, i1, s‬‬
‫;‪output out‬‬
‫;‪input s, io, i1‬‬
‫;‪wire sbar‬‬
‫‪i0‬‬
‫‪out‬‬
‫;) ‪not ( sbar, s‬‬
‫;) ‪cmos ( out, i0, sbar, s‬‬
‫;) ‪cmos ( out, i1, s, sbar‬‬
‫‪endmodule‬‬
‫‪i1‬‬
‫‪sbar‬‬
‫‪s‬‬