Page 1

‫اﻟﺠﻤﻬﻮرﻳﺔ اﻟﻌﺮﺑﻴﺔ اﻟﺴﻮرﻳﺔ‬ ‫وزارة اﻟﺘﻌﻠﻴﻢ اﻟﻌﺎﻟﻲ‬ ‫ﺟﺎﻣﻌﺔ ﺣﻠﺐ – آﻠﻴﺔ اﻟﻬﻨﺪﺳﺔ اﻟﻜﻬﺮﺑﺎﺋﻴﺔ واﻻﻟﻜﺘﺮوﻧﻴﺔ‬ ‫ﻗﺴﻢ هﻨﺪﺳﺔ اﻟﺤﻮاﺳﻴﺐ – ﻣﺨﺒﺮ اﻟﺤﺎﺳﺒﺎت‬ ‫إﻋﺪاد اﻟﻤﻬﻨﺪس ‪ :‬أﺳﺎﻣﺔ ﻋﺰﻳﺰ‬

‫ﻣﻠﺨﺺ اﻟﺠﻠﺴﺔ اﻟﺴﺎدﺳﺔ ﻟﻄﻼب اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ ‪ :‬ﺣﺎﺳﺒﺎت ‪ +‬اﻟﻜﺘﺮون‬ ‫اﻟﺸﻴﻔﺮة اﻟﺘﺘﺎﺑﻌﻴﺔ ‪Sequential Code‬‬

‫اﻟﻔﺼﻞ اﻟﺪراﺳﻲ اﻷول‬ ‫‪٢٠١٠ - ٢٠٠٩‬‬


‫اﻟﺠﻠﺴﺔ اﻟﺴﺎدﺳﺔ ‪ :‬اﻟﺸﻴﻔﺮة اﻟﺘﺘﺎﺑﻌﻴﺔ‬ ‫آﻤ ﺎ ﻧﻮهﻨ ﺎ ﻓ ﻲ اﻟﺠﻠﺴ ﺔ اﻟﺴ ﺎﺑﻘﺔ ﻓ ﺈن ﺷ ﻴﻔﺮة ‪ VHDL‬ه ﻲ ﺗﺰاﻣﻨﻴ ﺔ ﺑﺸ ﻜﻞ أﺳﺎﺳ ﻲ ‪. Inherently Concurrent‬‬ ‫اﻟﻤﻌﺎﻟﺠ ﺎت ‪ Processes‬واﻟﺘﻮاﺑ ﻊ ‪ Functions‬و اﻹﺟﺮاﺋﻴ ﺎت ‪ Procedures‬ه ﻲ ﻓﻘ ﻂ ﻣﻘ ﺎﻃﻊ اﻟﻜ ﻮد اﻟﺘ ﻲ ﺗﻨﻔ ﺬ‬ ‫ﺑﺸ ﻜﻞ ﺗﺘ ﺎﺑﻌﻲ ‪ . Executed Sequentially‬ﻣ ﻊ ذﻟ ﻚ ‪ ،‬ﻓ ﺈن ه ﺬﻩ اﻟﻜﺘ ﻞ ﺑﺎﻹﺟﻤ ﺎل ﺗﺒﻘ ﻰ ﺗﺰاﻣﻨﻴ ﺔ ﻣ ﻊ أﻳ ﺔ ﺗﻌﻠﻴﻤ ﺎت‬ ‫أﺧﺮى ﻣﺘﻮﺿﻌﺔ ﺧﺎرﺟﻬﺎ ‪.‬‬ ‫ﻧﺎﺣﻴ ﺔ أﺧ ﺮى هﺎﻣ ﺔ ﻟﻠﻜ ﻮد اﻟﺘﺘ ﺎﺑﻌﻲ وه ﻲ أﻧ ﻪ ﻏﻴ ﺮ ﻣﻘﺼ ﻮر ﻋﻠ ﻰ اﻟﻤﻨﻄ ﻖ اﻟﺘﺘ ﺎﺑﻌﻲ ‪ .Sequential Logic‬ﻓ ﻲ‬ ‫اﻟﻮاﻗ ﻊ ‪ ،‬ﺑﻮاﺳ ﻄﺔ اﻟﻜ ﻮد اﻟﺘﺘ ﺎﺑﻌﻲ ﻳﻤﻜﻨﻨ ﺎ ﺑﻨ ﺎء دارات ﺗﺘﺎﺑﻌﻴ ﺔ ‪ Sequential Circuits‬و دارات ﺗﺮآﻴﺒﻴ ﺔ‬ ‫‪ . Combinational Circuits‬ﻳﺪﻋﻰ اﻟﻜﻮد اﻟﺘﺘﺎﺑﻌﻲ أﻳﻀًﺎ ﺑﺎﺳﻢ اﻟﻜﻮد اﻟﺴﻠﻮآﻲ ‪. Behavioral Code‬‬ ‫اﻟﺘﻌﻠﻴﻤﺎت اﻟﺘﻲ ﺳﺘﻌﺮض ﻓ ﻲ ه ﺬﻩ اﻟﺠﻠﺴ ﺔ ه ﻲ آﺎﻓ ﺔ ﺗﺘﺎﺑﻌﻴ ﺔ أي أﻧﻬ ﺎ ﻣﺴ ﻤﻮﺣﺔ ﻓﻘ ﻂ داﺧ ﻞ اﻟﻤﻌﺎﻟﺠ ﺎت ‪Processes‬‬ ‫واﻟﺘﻮاﺑﻊ ‪ Functions‬و اﻹﺟﺮاﺋﻴﺎت ‪ . Procedures‬هﺬﻩ اﻟﺘﻌﻠﻴﻤﺎت هﻲ ‪ IF :‬و ‪ WAIT‬و ‪ CASE‬و ‪.LOOP‬‬ ‫اﻟﻤﺘﻐﻴﺮات ‪ /‬اﻟﻤﺘﺤﻮﻻت ‪ VARIABLES‬هﻲ أﻳﻀًﺎ ﻣﻘﺼﻮرة اﻻﺳﺘﺨﺪام أﻳﻀًﺎ ﺿﻤﻦ اﻟﻜﻮد اﻟﺘﺘ ﺎﺑﻌﻲ ) أي ﺿ ﻤﻦ‬ ‫اﻟﻤﻌﺎﻟﺠ ﺎت أو اﻟﺘﻮاﺑ ﻊ أو اﻹﺟﺮاﺋﻴ ﺎت ( ‪ .‬ﺑﺎﻟﻨﺘﻴﺠ ﺔ ‪ ،‬ﻋﻠ ﻰ ﻋﻜ ﺲ ﺣﺎﻟ ﺔ اﻹﺷ ﺎرة ‪ SIGNAL‬ﻓ ﺈن اﻟﻤﺘﻐﻴ ﺮ‬ ‫ﻼ ( ‪ Global‬وﺑﺎﻟﺘ ﺎﻟﻲ ﻓ ﺈن ﻗﻴﻤﺘ ﻪ ﻻ ﻳﻤﻜ ﻦ أن ﻳ ﺘﻢ ﺗﻤﺮﻳﺮه ﺎ‬ ‫‪ VARIABLE‬ﻻ ﻳﻤﻜ ﻦ أن ﻳﻜ ﻮن أﺑ ﺪًا ﻋﺎﻣ ًﺎ ) ﺷ ﺎﻣ ً‬ ‫ﻣﺒﺎﺷﺮة إﻟﻰ اﻟﺨﺎرج ) ﺧﺎرج ﻣﻨﻄﻘﺔ اﻟﻜﻮد اﻟﺘﺘﺎﺑﻌﻲ ( ‪.‬‬ ‫ﺳﻮف ﻧﺮآﺰ ﻓﻲ هﺬﻩ اﻟﺠﻠﺴﺔ ﻋﻠﻰ اﻟﻤﻌﺎﻟﺠﺎت ‪ Processes‬وﺑﺎﻟﺮﻏﻢ ﻣﻦ أن اﻟﺘﻮاﺑﻊ و اﻹﺟﺮاﺋﻴ ﺎت ه ﻲ ﻣﺸ ﺎﺑﻬﺔ ﺟ ﺪًا‬ ‫ﻟﺤﺎﻟﺔ اﻟﻤﻌﺎﻟﺠﺎت إﻻ أن هﺎﺗﻴﻦ اﻷﺧﻴ ﺮﺗﻴﻦ ﻣﺨﺼﺼ ﺘﺎن ﻟﻠﺘﺼ ﻤﻴﻢ ﻋﻠ ﻰ ﻣﺴ ﺘﻮى اﻟﻨﻈ ﺎم ‪System-Level Design‬‬ ‫وﺑﺎﻟﺘﺎﻟﻲ ﻟﻦ ﺗﻌﺮﺿﺎ ﻓﻲ هﺬا اﻟﻤﻨﻬﺎج ‪.‬‬ ‫‪ -١-٦‬اﻟﻤﻌﺎﻟﺠﺎت ‪Processes‬‬ ‫اﻟﻤﻌﺎﻟﺠ ﺔ ‪ Process‬ه ﻲ ﻣﻘﻄ ﻊ ﺗﺘ ﺎﺑﻌﻲ ﻣ ﻦ آ ﻮد ‪ . VHDL‬ﺗﺘﻤﻴ ﺰ اﻟﻤﻌﺎﻟﺠ ﺔ ﻋ ﺎد ًة ﺑﻮﺟ ﻮد إﺣ ﺪى ﺗﻌﻠﻴﻤ ﺎت ‪IF,‬‬ ‫‪ WAIT, CASE, LOOP‬وﺑﻮﺟ ﻮد ﻻﺋﺤ ﺔ اﻟﺤﺴﺎﺳ ﻴﺔ ‪ ) Sensitivity List‬ﺑﺎﺳ ﺘﺜﻨﺎء ﺣﺎﻟ ﺔ اﺳ ﺘﺨﺪام اﻟﺘﻌﻠﻴﻤ ﺔ‬ ‫‪ . ( WAIT‬إن اﻟﻤﻌﺎﻟﺠﺔ ﻳﺠﺐ أن ﻳﺘﻢ ﺗﻮﺿﻴﻌﻬﺎ ﻓ ﻲ اﻟﻜ ﻮد اﻟﺮﺋﻴﺴ ﻲ ‪ Main Code‬وه ﻲ ﺗﻨﻔ ﺬ ﻓ ﻲ آ ﻞ ﻣ ﺮة ﺗﺘﻐﻴ ﺮ‬ ‫ﻓﻴﻬ ﺎ ﻗﻴﻤ ﺔ إﺣ ﺪى اﻹﺷ ﺎرات اﻟﻤﻮﺟ ﻮدة ﻓ ﻲ ﻻﺋﺤ ﺔ اﻟﺤﺴﺎﺳ ﻴﺔ ) أو ﻳﻜ ﻮن ﻓﻴﻬ ﺎ اﻟﺸ ﺮط اﻟﻤﺘﻌﻠ ﻖ ﺑﺘﻌﻠﻴﻤ ﺔ ‪WAIT‬‬ ‫ﻣﺤﻘﻘًﺎ (‪ .‬اﻟﺼﻴﻐﺔ اﻟﻘﻮاﻋﺪﻳﺔ ‪ Syntax‬ﻟﻠﻤﻌﺎﻟﺠﺔ ‪ Process‬ﻣﻮﺿﺤﺔ ﻓﻴﻤﺎ ﻳﻠﻲ ‪:‬‬ ‫) ‪[label:] PROCESS ( sensitivity list‬‬ ‫]];‪[VARIABLE name : type [range] [:= initial_value‬‬ ‫‪BEGIN‬‬ ‫)‪(sequential code‬‬ ‫;]‪END PROCESS [label‬‬ ‫إن اﻟﻤﺘﻐﻴﺮات هﻲ اﺧﺘﻴﺎرﻳﺔ ‪ . Optional‬ﻋﻨﺪ اﻟﺤﺎﺟﺔ إﻟﻰ اﺳﺘﺨﺪاﻣﻬﺎ ﻳﺠﺐ أن ﻳﺼﺮح ﻋﻨﻬ ﺎ ﻓ ﻲ اﻟﻘﺴ ﻢ اﻟﺘﺼ ﺮﻳﺤﻲ‬ ‫ﻣﻦ اﻟﻤﻌﺎﻟﺠﺔ ‪ ) Declarative Part of the Process‬ﻗﺒﻞ اﻟﻜﻠﻤ ﺔ اﻟﻤﺤﺠ ﻮزة ‪ BEGIN‬اﻟﺨﺎﺻ ﺔ ﺑﺎﻟﻤﻌﺎﻟﺠ ﺔ آﻤ ﺎ‬ ‫ه ﻮ ﻣﺒ ﻴﻦ ﻓ ﻲ اﻟﺼ ﻴﻐﺔ اﻟﻘﻮاﻋﺪﻳ ﺔ اﻟ ﻮاردة أﻋ ﻼﻩ ( ‪ .‬إن اﻟﻘﻴﻤ ﺔ اﻻﺑﺘﺪاﺋﻴ ﺔ ‪ Initial Value‬ه ﻲ ﻏﻴ ﺮ ﻗﺎﺑﻠ ﺔ ﻟﻠﺘﺮآﻴ ﺐ‬ ‫‪ Not Synthesizable‬وﺑﺎﻟﺘﺎﻟﻲ ﻓﻬﻲ ﺗﺆﺧﺬ ﺑﻌﻴﻦ اﻻﻋﺘﺒﺎر ﻓﻘﻂ أﺛﻨﺎء ﻋﻤﻠﻴﺎت اﻟﻤﺤﺎآﺎة ‪. Simulation‬‬ ‫اﺳ ﺘﺨﺪام اﻟﻼﻓﺘ ﺔ ‪ Label‬ﻗﺒ ﻞ اﻟﻤﻌﺎﻟﺠ ﺔ ه ﻮ أﻳﻀ ًﺎ اﺧﺘﻴ ﺎري ‪ .‬اﻟﻐﺎﻳ ﺔ ﻣ ﻦ ه ﺬﻩ اﻟﻼﻓﺘ ﺔ ) ﻓ ﻲ ﺣﺎﻟ ﺔ اﺳ ﺘﺨﺪاﻣﻬﺎ ( ه ﻮ‬ ‫ﺗﺤﺴ ﻴﻦ ﻗﺎﺑﻠﻴ ﺔ اﻟﻘ ﺮاءة ﻟﻠﻜ ﻮد ‪ . Code Readability‬ﻳﻤﻜ ﻦ أن ﺗﻜ ﻮن اﻟﻼﻓﺘ ﺔ أﻳ ﺔ آﻠﻤ ﺔ ﻣ ﺎ ﻋ ﺪا آﻠﻤ ﺎت ‪VHDL‬‬ ‫اﻟﻤﺤﺠﻮزة ) اﻟﻤﻌﺮوﺿﺔ ﺳﺎﺑﻘًﺎ ﻓﻲ اﻟﺠﻠﺴﺔ اﻟﺜﺎﻧﻴﺔ ( ‪.‬‬ ‫ﻼ‪.‬‬ ‫ﻟﺒﻨﺎء دارة ﻣﺘﻮاﻗﺘﺔ ‪ Synchronous Circuit‬ﺗﻠﺰﻣﻨﺎ إﺷﺎرة ﺿﺒﻂ ) أو ﻣﺮاﻗﺒ ﺔ ( آﻨﺒﻀ ﺎت اﻟﺴ ﺎﻋﺔ ‪ Clock‬ﻣ ﺜ ً‬ ‫إن إﺣ ﺪى اﻟﻄ ﺮق اﻟﺸ ﺎﺋﻌﺔ ﻟﻜﺸ ﻒ ﺗﻐﻴ ﺮ ﻗﻴﻤ ﺔ إﺷ ﺎرة ﻣ ﺎ ﺗﺘﻤﺜ ﻞ ﻓ ﻲ اﺳ ﺘﺨﺪام اﻟﺨﺎﺻ ﺔ ‪ EVENT‬اﻟﺘ ﻲ ) اﻟﺘ ﻲ ﺳ ﺒﻖ‬ ‫ﻋﺮﺿ ﻬﺎ ﻓ ﻲ اﻟﺠﻠﺴ ﺔ اﻟﺮاﺑﻌ ﺔ (‪ .‬ﻋﻠ ﻰ ﺳ ﺒﻴﻞ اﻟﻤﺜ ﺎل ‪ ،‬إذا آﺎﻧ ﺖ ‪ clk‬ه ﻲ إﺷ ﺎرة اﻟﻀ ﺒﻂ ) اﻟﻤﺮاﻗﺒ ﺔ ( ﻓ ﺈن‬ ‫‪ clk'EVENT‬ﻋﻨﺪهﺎ ﺳﻮف ﺗﻌﻴﺪ اﻟﻘﻴﻤﺔ ‪ TRUE‬ﻋﻨﺪﻣﺎ ﻳﻄﺮأ ﺗﻐﻴﺮ ﻋﻠ ﻰ اﻹﺷ ﺎرة ‪ ) clk‬ﺟﺒﻬ ﺔ ﺻ ﺎﻋﺪة ‪Rising‬‬ ‫‪ Edge‬أو ﺟﺒﻬ ﺔ هﺎﺑﻄ ﺔ ‪ . ( Falling Edge‬اﻟﻤﺜ ﺎل اﻟﺘ ﺎﻟﻲ اﻟﻤﻌ ﺮوض أدﻧ ﺎﻩ ﻳﺼ ﻮر آﻴﻔﻴ ﺔ اﺳ ﺘﺨﺪام اﻟﺨﺎﺻ ﺔ‬ ‫‪ EVENT‬ﺿﻤﻦ ﻣﻌﺎﻟﺠﺔ ‪. PROCESS‬‬ ‫‪١‬‬


‫اﻟﻤﺜﺎل )‪ : (١-٦‬ﻗﻼب ‪ D‬ﻣﻊ ﻣﺪﺧﻞ ﺗﺼﻔﻴﺮ ﻏﻴﺮ ﻣﺘﻮاﻗﺖ )‪DFF With Asynchronous Reset #1 (١‬‬ ‫ﻳﻌﺘﺒ ﺮ اﻟﻘ ﻼب ﻣ ﻦ ﻧ ﻮع ‪ D‬واﻟﻤﺒ ﻴﻦ ﻓ ﻲ اﻟﺸ ﻜﻞ )‪ (١-٦‬آﺘﻠ ﺔ اﻟﺒﻨ ﺎء اﻷآﺜ ﺮ أهﻤﻴ ﺔ ﻓ ﻲ اﻟ ﺪارات اﻟﻤﻨﻄﻘﻴ ﺔ اﻟﺘﺘﺎﺑﻌﻴ ﺔ‬ ‫‪ . Sequential Logic Circuits‬ﻓ ﻲ ه ﺬا اﻟﻘ ﻼب ‪ ،‬ﻳﺠ ﺐ أن ﻳﻜ ﻮن اﻟﺨ ﺮج ﻧﺴ ﺨﺔ ﻣﻄﺎﺑﻘ ﺔ ﻟﻠ ﺪﺧﻞ ﻋﻨ ﺪ اﻻﻧﺘﻘ ﺎل‬ ‫اﻟﻤﻮﺟﺐ أو ﻋﻨﺪ اﻻﻧﺘﻘﺎل اﻟﺴﺎﻟﺐ ﻹﺷﺎرة ﻧﺒﻀﺎت اﻟﺴ ﺎﻋﺔ ‪ ) Clock Signal‬أي ﻋﻨ ﺪ اﻟﺤﺎﻓ ﺔ ‪ /‬اﻟﺠﺒﻬ ﺔ اﻟﺼ ﺎﻋﺪة أو‬ ‫ﻋﻨﺪ اﻟﺤﺎﻓﺔ ‪ /‬اﻟﺠﺒﻬﺔ اﻟﻬﺎﺑﻄﺔ ( ‪.‬‬

‫اﻟﺸﻜﻞ )‪ : (١-٦‬ﻗﻼب ﻣﻦ ﻧﻮع ‪ D‬ﻣﻊ ﻣﺪﺧﻞ ﺗﺼﻔﻴﺮ ﻏﻴﺮ ﻣﺘﻮاﻗﺖ ) اﻟﻤﺜﺎل ‪(١-٦‬‬ ‫ﻓﻲ اﻟﻜﻮد اﻟﻤﻌ ﺮوض أدﻧ ﺎﻩ ‪ ،‬ﺗ ﻢ اﺳ ﺘﺨﺪام اﻟﺘﻌﻠﻴﻤ ﺔ ‪ ) IF‬اﻟﺘ ﻲ ﺳ ﻮف ﺗﻌ ﺮض ﺑﺎﻟﺘﻔﺼ ﻴﻞ ﺑﻌ ﺪ ﻗﻠﻴ ﻞ ﻓ ﻲ اﻟﻔﻘ ﺮة ‪(٣-٦‬‬ ‫ﻟﺘﺼ ﻤﻴﻢ ﻗ ﻼب ﻣ ﻦ اﻟﻨ ﻮع ‪ D‬ﻣ ﻊ ﻣ ﺪﺧﻞ ﺗﺼ ﻔﻴﺮ ﻏﻴ ﺮ ﻣﺘﻮاﻗ ﺖ ‪ .‬إذا آﺎﻧ ﺖ '‪ rst = '1‬ﻓ ﺈن اﻟﺨ ﺮج ﻋﻨ ﺪهﺎ ﻳﺠ ﺐ أن‬ ‫ﻳﺴﺎوي اﻟﺼﻔﺮ '‪ ) q = '0‬اﻟﺴﻄﺮان ‪ 14‬و ‪ ( 15‬ﺑﻐﺾ اﻟﻨﻈﺮ ﻋﻦ ﺣﺎﻟ ﺔ اﻹﺷ ﺎرة ‪ . clk‬ﻣ ﻦ اﻟﻨﺎﺣﻴ ﺔ اﻷﺧ ﺮى ‪ ،‬ﻓ ﺈن‬ ‫اﻟﺨ ﺮج ﻳﺠ ﺐ أن ﻳﻜ ﻮن ﻧﺴ ﺨﺔ ﻣﻄﺎﺑﻘ ﺔ ﻟﻠ ﺪﺧﻞ ) أي ‪ ( q = d‬ﻋﻨ ﺪ اﻟﺤﺎﻓ ﺔ اﻟﻤﻮﺟﺒ ﺔ ) اﻟﺼ ﺎﻋﺪة ( ﻟﻺﺷ ﺎرة ‪clk‬‬ ‫) اﻟﺴ ﻄﺮان ‪ 16‬و‪ . ( 17‬ﻓ ﻲ اﻟﺴ ﻄﺮ ‪ 16‬ﺗ ﻢ اﺳ ﺘﺨﺪام اﻟﺨﺎﺻ ﺔ ‪ EVENT‬ﻟﻜﺸ ﻒ اﻻﻧﺘﻘ ﺎل اﻟﻄ ﺎرئ ﻋﻠ ﻰ إﺷ ﺎرة‬ ‫ﻧﺒﻀﺎت اﻟﺴﺎﻋﺔ ‪ . clk‬اﻟﻤﻌﺎﻟﺠﺔ ‪ ) PROCESS‬اﻟﺘ ﻲ ﺗﺒ ﺪأ ﻓ ﻲ اﻟﺴ ﻄﺮ ‪ 12‬وﺗﻨﺘﻬ ﻲ ﻓ ﻲ اﻟﺴ ﻄﺮ ‪ ( 19‬ﺗﻨﻔ ﺬ ﻓ ﻲ آ ﻞ‬ ‫ﻣﺮة ﺗﺘﻐﻴﺮ ﻓﻴﻬﺎ ﻗﻴﻤﺔ أﻳﺔ إﺷﺎرة ﻣﻦ اﻹﺷﺎرات اﻟﺘﻲ ﺗﻈﻬﺮ ﻓﻲ ﻻﺋﺤﺔ اﻟﺤﺴﺎﺳﻴﺔ ‪ ) Sensitivity List‬ﻓ ﻲ ﻣﺜﺎﻟﻨ ﺎ ه ﺬا‬ ‫ﺗﻀ ﻢ ﻻﺋﺤ ﺔ اﻟﺤﺴﺎﺳ ﻴﺔ اﻹﺷ ﺎرﺗﻴﻦ ‪ rst‬و‪ clk‬ﻓﻘ ﻂ آﻤ ﺎ ه ﻮ واﺿ ﺢ ﻓ ﻲ اﻟﺴ ﻄﺮ ‪ . ( 12‬ﻧﺘ ﺎﺋﺞ اﻟﻤﺤﺎآ ﺎة اﻟﺘ ﻲ ﺗﺆآ ﺪ‬ ‫وﻇﺎﺋﻔﻴﺔ اﻟﺪارة اﻟﻤﺮآﺒﺔ ‪ Functionality of the Synthesized Circuit‬ﻣﻌﺮوﺿﺔ ﻓﻲ اﻟﺸﻜﻞ )‪. (٢-٦‬‬ ‫‪1 ------------------------------------------------------------------‬‬‫;‪2 LIBRARY ieee‬‬ ‫;‪3 USE ieee.std_logic_1164.all‬‬ ‫‪4 ------------------------------------------------------------------‬‬‫‪5 ENTITY dff IS‬‬ ‫‪6‬‬ ‫;‪PORT (d, clk, rst : IN STD_LOGIC‬‬ ‫‪7‬‬ ‫;)‪q : OUT STD_LOGIC‬‬ ‫;‪8 END dff‬‬ ‫‪9 ------------------------------------------------------------------‬‬‫‪10 ARCHITECTURE behavior OF dff IS‬‬ ‫‪11 BEGIN‬‬ ‫‪12‬‬ ‫) ‪PROCESS ( rst, clk‬‬ ‫‪13‬‬ ‫‪BEGIN‬‬ ‫‪14‬‬ ‫‪IF ( rst= '1' ) THEN‬‬ ‫‪15‬‬ ‫;'‪q <= '0‬‬ ‫‪16‬‬ ‫‪ELSIF ( clk'EVENT AND clk= '1' ) THEN‬‬ ‫‪17‬‬ ‫;‪q <= d‬‬ ‫‪18‬‬ ‫;‪END IF‬‬ ‫‪19‬‬ ‫;‪END PROCESS‬‬ ‫;‪20 END behavior‬‬ ‫‪21 -----------------------------------------------------------------‬‬‫‪٢‬‬


‫اﻟﺸﻜﻞ )‪ : (٢-٦‬ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻟﻠﻤﺜﺎل )‪(١-٦‬‬ ‫‪ -٢-٦‬اﻹﺷﺎرات واﻟﻤﺘﻐﻴﺮات ) اﻟﻤﺘﺤﻮﻻت ( ‪Signals and Variables :‬‬ ‫إن اﻹﺷ ﺎرات ‪ Signals‬واﻟﻤﺘﻐﻴ ﺮات ) اﻟﻤﺘﺤ ﻮﻻت ( ‪ Variables‬ﺳ ﺘﺪرس ﺑﺎﻟﺘﻔﺼ ﻴﻞ ﻓ ﻲ اﻟﺠﻠﺴ ﺔ اﻟﻘﺎدﻣ ﺔ ‪ .‬ﻣ ﻊ‬ ‫ذﻟﻚ ‪ ،‬ﻣﻦ اﻟﻤﺴﺘﺤﻴﻞ ﻣﻨﺎﻗﺸﺔ ﻣﻮﺿﻮع اﻟﻜﻮد اﻟﺘﺘﺎﺑﻌﻲ دون ﻣﻌﺮﻓﺔ اﻟﻤﻤﻴﺰات اﻷآﺜﺮ أهﻤﻴﺔ ﻟﻜﻞ ﻣﻨﻬﻤﺎ ﻋﻠﻰ اﻷﻗﻞ ‪.‬‬ ‫ﻓ ﻲ ﻟﻐ ﺔ ‪ VHDL‬ﻃﺮﻳﻘﺘ ﺎن ﻟﺘﻤﺮﻳ ﺮ اﻟﻘ ﻴﻢ ﻏﻴ ﺮ اﻟﺜﺎﺑﺘ ﺔ ‪ : Non-Static Values‬ﺑﻮاﺳ ﻄﺔ إﺷ ﺎرة ‪ SIGNAL‬أو‬ ‫ﺑﻮاﺳ ﻄﺔ ﻣﺘﻐﻴ ﺮ ‪ /‬ﻣﺘﺤ ﻮل ‪ . VARIABLE‬إن اﻹﺷ ﺎرة ‪ SIGNAL‬ﻳﻤﻜ ﻦ أن ﻳﺼ ﺮح ﻋﻨﻬ ﺎ ﻓ ﻲ ﺣﺰﻣ ﺔ‬ ‫‪ PACKAGE‬أو ﻓ ﻲ اﻟﻜﻴ ﺎن ‪ ENTITY‬أو ﻓ ﻲ اﻟﺒﻨﻴ ﺔ ‪ ) ARCHITECTURE‬ﺿ ﻤﻦ ﻗﺴ ﻤﻬﺎ اﻟﺘﺼ ﺮﻳﺤﻲ (‪.‬‬ ‫ﻓ ﻲ ﺣ ﻴﻦ أن اﻟﻤﺘﻐﻴ ﺮ ‪ /‬اﻟﻤﺘﺤ ﻮل ‪ VARIABLE‬ﻳﻤﻜ ﻦ أن ﻳﺼ ﺮح ﻋﻨ ﻪ ﻓﻘ ﻂ داﺧ ﻞ ﻗﻄﻌ ﺔ ﻣ ﻦ آ ﻮد ﺗﺘ ﺎﺑﻌﻲ ) أي‬ ‫ﺿ ﻤﻦ ﻣﻌﺎﻟﺠ ﺔ ‪ PROCESS‬ﻋﻠ ﻰ ﺳ ﺒﻴﻞ اﻟﻤﺜ ﺎل ( ‪ .‬ﺑﺎﻟﺘ ﺎﻟﻲ ‪ ،‬ﻓ ﻲ ﺣ ﻴﻦ أن ﻗﻴﻤ ﺔ اﻹﺷ ﺎرة ﻳﻤﻜ ﻦ أن ﺗﻜ ﻮن ﻋﺎﻣ ﺔ‬ ‫) ﺷﺎﻣﻠﺔ ( ‪ Global‬ﻓﺈن ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ هﻲ دوﻣًﺎ ﻣﺤﻠﻴﺔ ) ﻣﻮﺿﻌﻴﺔ ( ‪. Local‬‬ ‫إن ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ VARIABLE‬ﻻ ﻳﻤﻜﻦ أن ﺗﻤﺮر أﺑﺪًا ﺑﺸﻜﻞ ﻣﺒﺎﺷﺮ ﺧﺎرج اﻟﻤﻌﺎﻟﺠﺔ ‪ .‬ﻓﻲ ﺣﺎﻟﺔ اﻟﻀﺮورة ‪ ،‬ﻳﻤﻜﻦ‬ ‫إﺳﻨﺎد ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ VARIABLE‬إﻟ ﻰ إﺷ ﺎرة ﻣ ﺎ ‪ . SIGNAL‬ﻣ ﻦ ﻧﺎﺣﻴ ﺔ أﺧ ﺮى ‪ ،‬ﻓ ﺈن ﺗﺤ ﺪﻳﺚ ‪ Update‬ﻗﻴﻤ ﺔ‬ ‫اﻟﻤﺘﻐﻴﺮ ‪ VARIABLE‬ﺁﻧﻲ ) ﻓﻮري ( ‪ Immediate‬أي أﻧﻪ ﺑﺈﻣﻜﺎﻧﻨﺎ اﻻﻋﺘﻤ ﺎد ﺑﺸ ﻜﻞ ﻓ ﻮري ﻋﻠ ﻰ ﻗﻴﻤﺘ ﻪ اﻟﺠﺪﻳ ﺪة‬ ‫ﻓ ﻲ اﻟﺴ ﻄﺮ اﻟﺘ ﺎﻟﻲ ﻣ ﻦ اﻟﻜ ﻮد ‪ .‬ﻓ ﻲ ﺣﺎﻟ ﺔ اﻹﺷ ﺎرة ‪ SIGNAL‬اﻷﻣ ﺮ ﻣﺨﺘﻠ ﻒ ) ﻋﻨ ﺪ اﺳ ﺘﺨﺪاﻣﻬﺎ داﺧ ﻞ ﻣﻌﺎﻟﺠ ﺔ‬ ‫‪ ( PROCESS‬وذﻟﻚ ﻷن اﻟﻘﻴﻤﺔ اﻟﺠﺪﻳﺪة ﻟﻺﺷﺎرة ﻻ ﻳﻤﻜﻦ ﺿﻤﺎن ﺟﺎهﺰﻳﺘﻬﺎ ﻟﻼﺳﺘﺨﺪام ﻋﻤﻮﻣًﺎ إﻻ ﺑﻌﺪ اﻻﻧﺘﻬﺎء ﻣ ﻦ‬ ‫اﻟﺘﻨﻔﻴﺬ اﻟﺤﺎﻟﻲ ﻟﻠﻤﻌﺎﻟﺠﺔ ‪.‬‬ ‫أﺧﻴﺮًا ‪ ،‬ﻧﺬآﺮ ﻣﻦ اﻟﺠﻠﺴﺔ اﻟﺮاﺑﻌﺔ ﺑﺄن ﻣﻌﺎﻣﻞ اﻹﺳﻨﺎد ﻣﻦ أﺟﻞ اﻹﺷﺎرة هﻮ " =< " ) ﻣﺜﺎل ‪ ( sig <= 5; :‬ﻓﻲ ﺣﻴﻦ‬ ‫أن ﻣﻌﺎﻣﻞ اﻹﺳﻨﺎد ﻣﻦ أﺟﻞ اﻟﻤﺘﻐﻴﺮ هﻮ " =‪ ) " :‬ﻣﺜﺎل ‪. ( var := 5; :‬‬ ‫‪ -٣-٦‬اﻟﺘﻌﻠﻴﻤﺔ ‪: IF‬‬ ‫آﻤ ﺎ ﻧﻮهﻨ ﺎ ﻣﺴ ﺒﻘًﺎ ﻓ ﺈن ﺗﻌﻠﻴﻤ ﺎت ‪ IF‬و ‪ WAIT‬و ‪ CASE‬و ‪ LOOP‬ه ﻲ اﻟﺘﻌﻠﻴﻤ ﺎت اﻟﻤﺨﺼﺼ ﺔ ﻣ ﻦ أﺟ ﻞ اﻟﻜ ﻮد‬ ‫اﻟﺘﺘﺎﺑﻌﻲ ‪ . Sequential Code‬ﺑﺎﻟﺘﺎﻟﻲ ﻓﺈن هﺬﻩ اﻟﺘﻌﻠﻴﻤﺎت ﻳﻤﻜﻦ أن ﺗﺴ ﺘﺨﺪم ﻓﻘ ﻂ داﺧ ﻞ ﻣﻌﺎﻟﺠ ﺔ ‪ PROCESS‬أو‬ ‫ﺗﺎﺑﻊ ‪ FUNCTION‬أو إﺟﺮاﺋﻴﺔ ‪. PROCEDURE‬‬ ‫إن اﻟﻤﻴﻞ اﻟﻄﺒﻴﻌﻲ ﻟﻠﻤﺼﻤﻤﻴﻦ ﻳﺘﻮﺟﻪ ﻧﺤﻮ اﺳﺘﺨﺪام ﺗﻌﻠﻴﻤﺔ ‪ IF‬أآﺜﺮ ﻣﻦ أﻳﺔ ﺗﻌﻠﻴﻤﺔ أﺧﺮى ‪ .‬ﺑﺎﻟﺮﻏﻢ ﻣﻦ أن ه ﺬا ﻳﻤﻜ ﻦ‬ ‫ ﻣﻦ ﺣﻴﺚ اﻟﻤﺒﺪأ ‪ -‬أن ﻳﻜﻮن ﻟﻪ ﻧﺘﺎﺋﺞ ﺳﻠﺒﻴﺔ ) ﻷن ﺗﻌﻠﻴﻤﺔ ‪ IF / ELSE‬ﻳﻤﻜﻦ أن ﺗﺴﺒﺐ ﺑﻨﺎء ﻓﺎك ﺷ ﻴﻔﺮة ذي أوﻟﻮﻳ ﺔ‬‫ﻏﻴﺮ ﺿﺮوري ‪ ( Unnecessary Priority Decoder‬إﻻ أن اﻟﻤﺮآﺐ ‪ Synthesizer‬ﺳ ﻮف " ﻳﺆﻣﺜ ﻞ " اﻟﺒﻨﻴ ﺔ‬ ‫وﻳﺘﺠﻨﺐ اﻟﻌﺘﺎد اﻹﺿﺎﻓﻲ ‪ .‬اﻟﺼﻴﻐﺔ اﻟﻘﻮاﻋﺪﻳﺔ ﻟﺘﻌﻠﻴﻤﺔ ‪ IF‬ﻣﻌﺮوﺿﺔ ﻓﻴﻤﺎ ﻳﻠﻲ ‪:‬‬ ‫;‪IF conditions THEN assignments‬‬ ‫;‪ELSIF conditions THEN assignments‬‬ ‫‪.....‬‬ ‫;‪ELSE assignments‬‬ ‫;‪END IF‬‬ ‫ﻣﺜﺎل ‪Example :‬‬ ‫;"‪IF (x < y ) THEN temp := "11111111‬‬ ‫;"‪ELSIF ( x = y AND w = '0' ) THEN temp := "11110000‬‬ ‫;) '‪ELSE temp := ( OTHERS => '0‬‬ ‫‪٣‬‬


‫اﻟﻤﺜﺎل )‪ : (٢-٦‬ﻋﺪاد ذي ﺧﺎﻧﺔ واﺣﺪة )‪One-Digit Counter #1 (١‬‬ ‫اﻟﻜﻮد اﻟﻤﻌﺮوض أدﻧﺎﻩ ﻳﻨﺠﺰ ﻋﺪادًا ﻋﺸﺮﻳًﺎ ﺗﻌﺎﻗﺒﻴًﺎ ذا ﺧﺎﻧ ﺔ ﻋﺸ ﺮﻳﺔ واﺣ ﺪة ‪( Progressive 1-Digit Decimal‬‬ ‫) ‪ Counter‬وهﻮ ﻳﻌﺪ ﻣﻦ اﻟﻘﻴﻤﺔ ‪ 0‬إﻟﻰ اﻟﻘﻴﻤﺔ ‪ 9‬وﻣﻦ ﺛﻢ ﻳﻜﺮر دورة اﻟﻌﺪ اﺑﺘﺪا ًء ﻣﻦ اﻟﻘﻴﻤ ﺔ ‪ . 0‬ﻳﺒ ﻴﻦ اﻟﺸ ﻜﻞ )‪(٣-٦‬‬ ‫ﻣﺨﻄﻂ اﻟﻤﺴﺘﻮى اﻷﻋﻠﻰ ﻟﻠﺪارة ‪. Top-Level Diagram of the Circuit‬‬

‫اﻟﺸﻜﻞ )‪ : (٣-٦‬ﻋﺪاد اﻟﻤﺜﺎل )‪(٢-٦‬‬ ‫ﻼ ﺑﻌ ﺮض ﺧﺎﻧ ﺔ واﺣ ﺪة وه ﻮ اﻟﻤ ﺪﺧﻞ ) ‪ ( clk‬آﻤ ﺎ أن ﻟﻬ ﺎ ﻣﺨﺮﺟ ًﺎ ﺑﻌ ﺮض أرﺑ ﻊ ﺧﺎﻧ ﺎت وه ﻮ‬ ‫ﺗﻤﻠ ﻚ اﻟ ﺪارة ﻣ ﺪﺧ ً‬ ‫اﻟﻤﺨﺮج ) ‪ . ( digit‬ﺗﻢ اﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻤﺔ ‪ IF‬ﻓﻲ هﺬا اﻟﻤﺜ ﺎل آﻤ ﺎ ﺗ ﻢ اﺳ ﺘﺨﺪام ﻣﺘﻐﻴ ﺮ ‪ VARIABLE‬اﺳ ﻤﻪ ‪temp‬‬ ‫ﻟﺨﻠ ﻖ اﻟﻘﻼﺑ ﺎت اﻷرﺑ ﻊ اﻟﻀ ﺮورﻳﺔ ﻟﺘﺨ ﺰﻳﻦ إﺷ ﺎرة اﻟﺨ ﺮج رﺑﺎﻋﻴ ﺔ اﻟﺨﺎﻧ ﺎت ‪ .‬ﻧﺘ ﺎﺋﺞ اﻟﻤﺤﺎآ ﺎة اﻟﺘ ﻲ ﺗﺆآ ﺪ اﻷداء‬ ‫اﻟﺼﺤﻴﺢ ﻟﻠﺪارة اﻟﻤﺮآﺒﺔ ﻣﻌﺮوﺿﺔ ﻓﻲ اﻟﺸﻜﻞ )‪. (٤-٦‬‬ ‫‪1 ----------------------------------------------------------------------------‬‬‫;‪2 LIBRARY ieee‬‬ ‫;‪3 USE ieee.std_logic_1164.all‬‬ ‫‪4 ----------------------------------------------------------------------------‬‬‫‪5 ENTITY counter IS‬‬ ‫‪6‬‬ ‫;‪PORT ( clk : IN STD_LOGIC‬‬ ‫‪7‬‬ ‫;) ‪digit : OUT INTEGER RANGE 0 TO 9‬‬ ‫;‪8 END counter‬‬ ‫‪9 ----------------------------------------------------------------------------‬‬‫‪10 ARCHITECTURE counter OF counter IS‬‬ ‫‪11 BEGIN‬‬ ‫‪12‬‬ ‫) ‪count: PROCESS ( clk‬‬ ‫‪13‬‬ ‫;‪VARIABLE temp : INTEGER RANGE 0 TO 10‬‬ ‫‪14‬‬ ‫‪BEGIN‬‬ ‫‪15‬‬ ‫‪IF ( clk'EVENT AND clk = '1' ) THEN‬‬ ‫‪16‬‬ ‫;‪temp := temp + 1‬‬ ‫‪17‬‬ ‫;‪IF ( temp = 10 ) THEN temp := 0‬‬ ‫‪18‬‬ ‫;‪END IF‬‬ ‫‪19‬‬ ‫;‪END IF‬‬ ‫‪20‬‬ ‫;‪digit <= temp‬‬ ‫‪21‬‬ ‫;‪END PROCESS count‬‬ ‫;‪22 END counter‬‬ ‫‪23 ---------------------------------------------------------------------------‬‬‫ﺗﻌﻠﻴﻖ ‪Comment :‬‬ ‫ﻧﻼﺣ ﻆ أن اﻟﻜ ﻮد أﻋ ﻼﻩ ﻻ ﻳﻤﺘﻠ ﻚ ﻣ ﺪﺧﻞ ﺗﺼ ﻔﻴﺮ ‪ Reset Input‬وﻻ ﻳﻤﺘﻠ ﻚ ﻗﻴﻤ ﺔ اﺑﺘﺪاﺋﻴ ﺔ داﺧﻠﻴ ﺔ ﻣ ﻦ أﺟ ﻞ اﻟﻤﺘﻐﻴ ﺮ‬ ‫‪ ) temp‬وﻻ ﻣﻦ أﺟﻞ اﻟﻤﺨﺮج ‪ digit‬ﺑﺎﻟﻨﺘﻴﺠﺔ ( ‪ .‬ﺑﺎﻟﺘﺎﻟﻲ ﻓﺈن اﻟﻘﻴﻤﺔ اﻻﺑﺘﺪاﺋﻴﺔ ‪ Initial Value‬ﻟﻠﻤﺘﻐﻴ ﺮ ‪ temp‬ﻓ ﻲ‬ ‫اﻟﺪارة اﻟﻔﻴﺰﻳﺎﺋﻴﺔ ﻳﻤﻜﻦ أن ﺗﻜﻮن أﻳﺔ ﻗﻴﻤﺔ ) ﺑﻌﺮض ‪ ٤‬ﺧﺎﻧﺎت ( ‪ .‬إذا آﺎﻧﺖ هﺬﻩ اﻟﻘﻴﻤﺔ أﺻﻐﺮ ﻣﻦ ‪ ) 10‬اﻧﻈﺮ اﻟﺴﻄﺮ‬ ‫‪٤‬‬


‫‪ ( 17‬ﻓﺈن اﻟﺪارة ﺳﻮف ﺗﻌﺪ ﺑﺸﻜﻞ ﺻﺤﻴﺢ اﺑﺘﺪا ًء ﻣﻦ ﺗﻠﻚ اﻟﻘﻴﻤﺔ ‪ .‬ﻣﻦ ﻧﺎﺣﻴﺔ أﺧﺮى ‪ ،‬إذا آﺎﻧﺖ اﻟﻘﻴﻤﺔ ﻓ ﻮق اﻟﻌ ﺪد ‪10‬‬ ‫ﻓﺈن ﻋﺪدًا ﻣﻦ ﻧﺒﻀﺎت اﻟﺴﺎﻋﺔ ﺳﻮف ﺗﺴﺘﺨﺪم ﺣﺘﻰ ﺗﺼﻞ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ temp‬إﻟ ﻰ ﻗﻴﻤ ﺔ اﻟﻌ ﺪ اﻷﻋﻈﻤﻴ ﺔ ) أي اﻟﻘﻴﻤ ﺔ‬ ‫‪ 15‬أو "‪ ( " 1111‬ﺣﻴﺚ ﻳﺘﻢ ﺗﺼﻔﻴﺮ ﻗﻴﻤ ﺔ ‪ temp‬ﺑﺸ ﻜﻞ ﺁﻟ ﻲ و ﺗﺒ ﺪأ اﻟ ﺪارة ﺑﺎﻟﺘ ﺎﻟﻲ ﻣ ﻦ ﺗﻠ ﻚ اﻟﻠﺤﻈ ﺔ ﺑﺎﻟﻌﻤ ﻞ ﺑﺸ ﻜﻞ‬ ‫ﺻﺤﻴﺢ ‪ .‬إن إﻣﻜﺎﻧﻴﺔ هﺪر ﺑﻀﻌﺔ ﻧﺒﻀﺎت ﺳﺎﻋﺔ ﻓﻲ ﺑﺪاﻳﺔ ﻋﻤﻞ اﻟﻌﺪاد ﻟﻴﺴﺖ ﻣﺸﻜﻠﺔ ﻋﻤﻮﻣًﺎ ‪ .‬ﻣ ﻊ ذﻟ ﻚ ‪ ،‬إذا آﻨ ﺎ ﻧﺮﻳ ﺪ‬ ‫ﺗﺠﺎوز هﺬﻩ اﻟﻈﺎهﺮة ﻓﺈن اﻟﻤﻘﺎرﻧﺔ ‪ temp = 10‬ﻓﻲ اﻟﺴﻄﺮ ‪ 17‬ﻳﻤﻜ ﻦ أن ﺗﻐﻴ ﺮ إﻟ ﻰ اﻟﻤﻘﺎرﻧ ﺔ ‪ temp >= 10‬وﻟﻜ ﻦ‬ ‫هﺬا ﺳﻮف ﻳﺰﻳ ﺪ ﻣ ﻦ ﺗﻌﻘﻴ ﺪ اﻟﻌﺘ ﺎد ‪ . Hardware‬ﻋﻠ ﻰ آ ﻞ ﺣ ﺎل ‪ ،‬إذا آ ﺎن اﻟﺒ ﺪء ﻣ ﻦ اﻟﻘﻴﻤ ﺔ ‪ 0‬ﺿ ﺮورﻳًﺎ دوﻣ ًﺎ ﻓ ﺈن‬ ‫ﻣﺪﺧﻞ ﺗﺼﻔﻴﺮ ‪ Reset Input‬ﻳﺠﺐ أن ﻳﻀﻤﻦ آﻤﺎ هﻮ اﻟﺤﺎل ﻓﻲ اﻟﻤﺜﺎل )‪. (٧-٦‬‬

‫اﻟﺸﻜﻞ )‪ : (٤-٦‬ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻟﻠﻤﺜﺎل )‪(٢-٦‬‬ ‫ﻧﻼﺣﻆ ﻓﻲ اﻟﻜﻮد اﻟﻤﻌﺮوض أﻋﻼﻩ أﻧﻨﺎ ﻧﺰﻳﺪ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ temp‬وﻣﻦ ﺛﻢ ﻧﻘﺎرن ﻗﻴﻤﺘ ﻪ ﻣ ﻊ اﻟﻌ ﺪد ‪ 10‬ﺑﻬ ﺪف ﺗﺼ ﻔﻴﺮ‬ ‫ﻗﻴﻤﺘﻪ ﻋﻨﺪ وﺻﻮﻟﻬﺎ إﻟﻰ اﻟﻘﻴﻤﺔ ‪ . 10‬هﺬﻩ ﻃﺮﻳﻘ ﺔ ﻧﻤﻮذﺟﻴ ﺔ ﺗﺴ ﺘﺨﺪم ﻋ ﺎد ًة ﻓ ﻲ اﻟﻌ ﺪادات ‪ . Counters‬إن اﻟﻘﻴﻤ ﺔ ‪10‬‬ ‫هﻨ ﺎ ه ﻲ ﻗﻴﻤ ﺔ ﺛﺎﺑﺘ ﺔ ‪ Constant‬وﺑﺎﻟﺘ ﺎﻟﻲ ﻓ ﺈن ﻣﻘﺎرﻧ ًﺎ ﻣ ﻊ ﻗﻴﻤ ﺔ ﺛﺎﺑﺘ ﺔ ﺳ ﻮف ﻳﺸ ﻜﻞ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺘ ﺮﺟﻢ ‪Compiler‬‬ ‫واﻟﺬي ﻳﻜﻮن ﻋﺎد ًة دارة ﺑﺴﻴﻄﺔ ﻧﺴﺒﻴًﺎ ﻣﻦ ﺣﻴﺚ اﻟﺒﻨﻴﺔ ‪ .‬ﻋﻠﻰ آﻞ ﺣﺎل ‪ ،‬إذا آﻨﺎ ﻧﺮﻳﺪ اﺳ ﺘﺨﺪام ﺑ ﺎراﻣﺘﺮ ﻗﺎﺑ ﻞ ﻟﻠﺒﺮﻣﺠ ﺔ‬ ‫ﻼ ‪ Full Comparator‬ﻳﺠﺐ أن ﻳﻨﺠﺰ واﻟﺬي ﻳﺘﻄﻠﺐ ﻋ ﺎد ًة ﻣﻜﻮﻧ ﺎت ﻣﻨﻄﻘﻴ ﺔ‬ ‫ﻋﻮﺿًﺎ ﻋﻦ ﻗﻴﻤﺔ ﺛﺎﺑﺘﺔ ﻓﺈن ﻣﻘﺎرﻧًﺎ آﺎﻣ ً‬ ‫أآﺜﺮ ﺑﺸﻜﻞ ﻣﻌﺘﺒﺮ ﻣﻦ ﺣﺎﻟﺔ ﻣﻘﺎرن ﻣﻊ ﻗﻴﻤﺔ ﺛﺎﺑﺘ ﺔ ‪ .‬ﻓ ﻲ ه ﺬﻩ اﻟﺤﺎﻟ ﺔ ‪ ،‬ﻓ ﺈن اﻟﺤ ﻞ اﻷﻓﻀ ﻞ ﻳﺘﻤﺜ ﻞ ﻓ ﻲ ﺗﺤﻤﻴ ﻞ اﻟﻤﺘﻐﻴ ﺮ‬ ‫‪ temp‬ﺑﻘﻴﻤﺔ هﺬا اﻟﺒﺎراﻣﺘﺮ وﻣﻦ ﺛﻢ اﻟﻌﻤﻞ ﻋﻠﻰ إﻧﻘﺎص ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ temp‬ﺑﺸﻜﻞ ﺗﺪرﻳﺠﻲ ﺣﺘﻰ ﻳﺼ ﻞ إﻟ ﻰ اﻟﺼ ﻔﺮ‬ ‫وﻣﻦ ﺛﻢ إﻋﺎدة ﺗﺤﻤﻴﻞ ‪ temp‬ﺑﻨﻔﺲ ﻗﻴﻤﺔ اﻟﺒﺎراﻣﺘﺮ وهﻜﺬا دواﻟﻴ ﻚ ‪ .‬ﻓ ﻲ ه ﺬﻩ اﻟﺤﺎﻟ ﺔ ‪ ،‬ﻓ ﺈن اﻟﻤﻘ ﺎرن اﻟﻤﻄﻠ ﻮب ﺳ ﻮف‬ ‫ﻳﻘ ﺎرن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ‪ temp‬ﻣ ﻊ اﻟﺼ ﻔﺮ ) ﻗﻴﻤ ﺔ ﺛﺎﺑﺘ ﺔ ( وه ﺬا ﻣ ﺎ ﺳ ﻮف ﻳﺤ ﻮل دون ﺗﻮﻟﻴ ﺪ ﻣﻘ ﺎرن آﺎﻣ ﻞ ﻣ ﻦ ﻗﺒ ﻞ‬ ‫اﻟﻤﺘﺮﺟﻢ ‪.‬‬ ‫اﻟﻤﺜﺎل )‪ : (٣-٦‬ﻣﺴﺠﻞ إزاﺣﺔ ‪Shift Register‬‬ ‫ﻳﺒ ﻴﻦ اﻟﺸ ﻜﻞ )‪ (٥-٦‬ﻣﺴ ﺠﻞ إزاﺣ ﺔ ﺑﻌ ﺮض أرﺑ ﻊ ﺧﺎﻧ ﺎت ‪ . 4-bit Shift Register‬ﺧﺎﻧ ﺔ اﻟﺨ ﺮج ) ‪ ( q‬ﻳﺠ ﺐ أن‬ ‫ﺗﻜﻮن ﻣﺘﺄﺧﺮة ﺑﻤﻘﺪار أرﺑﻊ ﺟﺒﻬﺎت ﺻﺎﻋﺪة ﻣﺘﺘﺎﻟﻴﺔ ﻟﻨﺒﻀﺎت اﻟﺴﺎﻋﺔ ﻋ ﻦ ﺧﺎﻧ ﺔ اﻟ ﺪﺧﻞ ) ‪ . ( d‬اﻟﻤﺴ ﺠﻞ ﻳﻤﺘﻠ ﻚ أﻳﻀ ًﺎ‬ ‫ﻣﺪﺧﻞ ﺗﺼﻔﻴﺮ ﻏﻴﺮ ﻣﺘﻮاﻗﺖ ‪ Asynchronous Reset‬واﻟﺬي ﻳﺠﺐ أن ﻳﺼﻔﺮ ﻣﺨﺎرج آﺎﻓﺔ اﻟﻘﻼﺑ ﺎت ﻋﻨ ﺪ ﺗﻔﻌﻴﻠ ﻪ ‪.‬‬ ‫ﻓﻲ هﺬا اﻟﻤﺜﺎل ‪ ،‬ﺗﻢ اﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻤﺔ ‪ IF‬أﻳﻀًﺎ ‪.‬‬

‫اﻟﺸﻜﻞ )‪ : (٥-٦‬ﻣﺴﺠﻞ اﻹزاﺣﺔ ﻟﻠﻤﺜﺎل )‪(٣-٦‬‬ ‫ﻼ ﻣﺘ ﺄﺧﺮة ﺑﻤﻘ ﺪار أرﺑ ﻊ ﺟﺒﻬ ﺎت‬ ‫ﻧﺘ ﺎﺋﺞ اﻟﻤﺤﺎآ ﺎة ﻣﺒﻴﻨ ﺔ ﻓ ﻲ اﻟﺸ ﻜﻞ )‪ . (٦-٦‬آﻤ ﺎ ه ﻮ واﺿ ﺢ ﻟﻠﻌﻴ ﺎن ﻓ ﺈن ‪ q‬ه ﻲ ﻓﻌ ً‬ ‫ﺻﺎﻋﺪة ﻣﺘﺘﺎﻟﻴﺔ ﻟﻨﺒﻀﺎت اﻟﺴﺎﻋﺔ ﻋﻦ ‪. d‬‬ ‫‪٥‬‬


1 -------------------------------------------------------------------------------------------2 LIBRARY ieee; 3 USE ieee.std_logic_1164.all; 4 -------------------------------------------------------------------------------------------5 ENTITY shiftreg IS 6 GENERIC ( n : INTEGER := 4 ); ----------- # of stages 7 PORT ( d, clk, rst : IN STD_LOGIC; 8 q : OUT STD_LOGIC ); 9 END shiftreg; 10 ------------------------------------------------------------------------------------------11 ARCHITECTURE behavior OF shiftreg IS 12 SIGNAL internal : STD_LOGIC_VECTOR ( n-1 DOWNTO 0 ); 13 BEGIN 14 PROCESS ( clk, rst ) 15 BEGIN 16 IF ( rst = '1' ) THEN 17 internal <= ( OTHERS => '0' ); 18 ELSIF ( clk'EVENT AND clk = '1' ) THEN 19 internal <= d & internal( internal'LEFT DOWNTO 1); 20 END IF; 21 END PROCESS; 22 q <= internal(0); 23 END behavior; 24 -------------------------------------------------------------------------------------------

(٣-٦) ‫ ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻟﻤﺜﺎل‬: (٦-٦) ‫اﻟﺸﻜﻞ‬ : WAIT ‫ اﻟﺘﻌﻠﻴﻤﺔ‬-٤-٦ ‫ ﻓﺈﻧﻪ ﻳﻮﺟﺪ أآﺜﺮ ﻣﻦ ﺷ ﻜﻞ ﻣﺘ ﺎح ﻟﻠﺘﻌﻠﻴﻤ ﺔ‬، ‫ ﻋﻠﻰ آﻞ ﺣﺎل‬. IF ‫ ﻳﺸﺎﺑﻪ أﺣﻴﺎﻧًﺎ ﻋﻤﻞ اﻟﺘﻌﻠﻴﻤﺔ‬WAIT ‫إن ﻋﻤﻞ اﻟﺘﻌﻠﻴﻤﺔ‬ LOOP ‫ أو‬CASE ‫ أو‬IF ‫ وﻋﻠﻰ ﻋﻜ ﺲ اﻟﺤﺎﻟ ﺔ اﻟﺘ ﻲ ﻳ ﺘﻢ ﻓﻴﻬ ﺎ اﺳ ﺘﺨﺪام اﻟﺘﻌﻠﻴﻤ ﺎت‬، ‫ ﺑﺎﻹﺿﺎﻓﺔ إﻟﻰ ذﻟﻚ‬. WAIT ‫ ﻋﻨ ﺪﻣﺎ ﺗﺴ ﺘﺨﺪم اﻟﺘﻌﻠﻴﻤ ﺔ‬Sensitivity List ‫ ﻻ ﻳﻤﻜ ﻦ أن ﺗﻤﺘﻠ ﻚ ﻻﺋﺤ ﺔ ﺣﺴﺎﺳ ﻴﺔ‬PROCESS ‫ﻓ ﺈن اﻟﻤﻌﺎﻟﺠ ﺔ‬ : ‫ ) واﻟﺘﻲ ﺗﻤﺘﻠﻚ ﺛﻼﺛﺔ أﺷﻜﺎل ﻣﺨﺘﻠﻔﺔ ( ﻣﻮﺿﺤﺔ ﻓﻴﻤﺎ ﻳﻠﻲ‬WAIT ‫ اﻟﺼﻴﻐﺔ اﻟﻘﻮاﻋﺪﻳﺔ ﻟﻠﺘﻌﻠﻴﻤﺔ‬. WAIT 1. First Form : WAIT UNTIL signal_condition; 2. Second Form : WAIT ON signal1 [, signal2, ... ]; 3. Third Form : WAIT FOR time; ٦


‫إن اﻟﺸﻜﻞ ‪ WAIT UNTIL‬ﻟﻠﺘﻌﻠﻴﻤﺔ ‪ WAIT‬ﻳﻘﺒﻞ ﻓﻘﻂ إﺷ ﺎرة وﺣﻴ ﺪة وﺑﺎﻟﺘ ﺎﻟﻲ ﻓﻬ ﻮ ﻣﻨﺎﺳ ﺐ أآﺜ ﺮ ﻣ ﻦ أﺟ ﻞ آ ﻮد‬ ‫ﻣﺘﻮاﻗ ﺖ ﻣﻘﺎرﻧ ﺔ ﻣ ﻊ ﺣﺎﻟ ﺔ آ ﻮد ﻏﻴ ﺮ ﻣﺘﻮاﻗ ﺖ ‪ .‬ﺑﻤ ﺎ أن اﻟﻤﻌﺎﻟﺠ ﺔ ‪ PROCESS‬ﻻ ﺗﻤﺘﻠ ﻚ ﻻﺋﺤ ﺔ ﺣﺴﺎﺳ ﻴﺔ‬ ‫‪ Sensitivity List‬ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ﻓﺈن اﻟﺘﻌﻠﻴﻤﺔ ‪ WAIT UNTIL‬ﻳﺠ ﺐ أن ﺗﻜ ﻮن اﻟﺘﻌﻠﻴﻤ ﺔ اﻷوﻟ ﻰ ﻓ ﻲ اﻟﻤﻌﺎﻟﺠ ﺔ‬ ‫‪ . PROCESS‬ﺑﺎﻟﺘﺎﻟﻲ ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬ اﻟﻤﻌﺎﻟﺠﺔ ﻓﻲ آﻞ ﻣﺮة ﻳﺘﻢ ﻓﻴﻬﺎ ﺗﺤﻘﻖ ﺷﺮط اﻟﺘﻌﻠﻴﻤﺔ ‪. WAIT‬‬ ‫ﻣﺜﺎل ‪ :‬ﻣﺴﺠﻞ ﺑﻌﺮض ﺛﻤﺎن ﺧﺎﻧﺎت ﻣﻊ ﺗﺼﻔﻴﺮ ﻣﺘﻮاﻗﺖ ‪8-bit Register With Synchronous Reset‬‬ ‫‪PROCESS‬‬ ‫‪------------- no sensitivity list‬‬ ‫‪BEGIN‬‬ ‫;) '‪WAIT UNTIL ( clk'EVENT AND clk ='1‬‬ ‫‪IF ( rst= '1' ) THEN‬‬ ‫;"‪output <= "00000000‬‬ ‫‪ELSIF ( clk'EVENT AND clk = '1' ) THEN‬‬ ‫;‪output <= input‬‬ ‫;‪END IF‬‬ ‫;‪END PROCESS‬‬ ‫ﻣ ﻦ ﺟﻬ ﺔ أﺧ ﺮى ‪ ،‬ﻓ ﺈن اﻟﺸ ﻜﻞ ‪ WAIT ON‬ﻟﻠﺘﻌﻠﻴﻤ ﺔ ‪ WAIT‬ﺗﻘﺒ ﻞ ﻋ ﺪة إﺷ ﺎرات ‪ . Multiple Signals‬ﺗﻜ ﻮن‬ ‫اﻟﻤﻌﺎﻟﺠﺔ ‪ PROCESS‬ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ﻣﻌﻠﻘﺔ ) ﺧﺎﻣﻠﺔ ( ﺣﺘﻰ ﺗﺘﻐﻴﺮ ﻗﻴﻤ ﺔ إﺣ ﺪى ه ﺬﻩ اﻹﺷ ﺎرات ‪ .‬ﻓ ﻲ اﻟﻤﺜ ﺎل اﻟﺘ ﺎﻟﻲ‬ ‫ﺳﻮف ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻟﻤﻌﺎﻟﺠﺔ ﻋﻨﺪﻣﺎ ﻳﻄﺮأ ﺗﻐﻴﺮ ﻣﺎ ﻋﻠﻰ ﻗﻴﻤﺔ اﻹﺷﺎرة ‪ rst‬أو ﻋﻠﻰ ﻗﻴﻤﺔ اﻹﺷﺎرة ‪. clk‬‬ ‫ﻣﺜﺎل ‪ :‬ﻣﺴﺠﻞ ﺑﻌﺮض ﺛﻤﺎن ﺧﺎﻧﺎت ﻣﻊ ﺗﺼﻔﻴﺮ ﻏﻴﺮ ﻣﺘﻮاﻗﺖ ‪8-bit Register With Asynchronous Reset‬‬ ‫‪PROCESS‬‬ ‫‪------------- no sensitivity list‬‬ ‫‪BEGIN‬‬ ‫;‪WAIT ON clk, rst‬‬ ‫‪IF ( rst= '1' ) THEN‬‬ ‫;"‪output <= "00000000‬‬ ‫‪ELSIF ( clk'EVENT AND clk = '1' ) THEN‬‬ ‫;‪output <= input‬‬ ‫;‪END IF‬‬ ‫;‪END PROCESS‬‬ ‫‪--------------------------------------------------------------------------------------------------‬‬‫اﻟﻤﺜﺎل )‪ : (٤-٦‬ﻗﻼب ‪ D‬ﻣﻊ ﻣﺪﺧﻞ ﺗﺼﻔﻴﺮ ﻏﻴﺮ ﻣﺘﻮاﻗﺖ )‪DFF With Asynchronous Reset #2 (٢‬‬ ‫ﻼ ﻣﻦ‬ ‫اﻟﻜﻮد اﻟﻤﻌﺮوض أدﻧ ﺎﻩ ﻳﻨﺠ ﺰ ﻧﻔ ﺲ اﻟﻘ ﻼب ﻣ ﻦ ﻧ ﻮع ‪ ) D‬واﻟ ﺬي ﺳ ﺒﻖ ﻋﺮﺿ ﻪ ﻓ ﻲ اﻟﻤﺜ ﺎل )‪ : (١-٦‬اﻧﻈ ﺮ آ ً‬ ‫اﻟﺸﻜﻠﻴﻦ )‪ (١-٦‬و )‪ . ( (٢-٦‬ﻟﻜﻦ ﻓﻲ هﺬﻩ اﻟﺤﺎﻟ ﺔ ﺗ ﻢ اﺳ ﺘﺨﺪام اﻟﺸ ﻜﻞ ‪ WAIT ON‬ﻟﻠﺘﻌﻠﻴﻤ ﺔ ‪ WAIT‬ﻋﻮﺿ ًﺎ ﻋ ﻦ‬ ‫اﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻤﺔ ‪ IF‬ﻓﻘﻂ ﻓﻲ ﻣﻌﺎﻟﺠﺔ ذات ﻻﺋﺤﺔ ﺣﺴﺎﺳﻴﺔ ﺗﻘﻠﻴﺪﻳﺔ ‪.‬‬ ‫‪1 -----------------------------------------------------------------------‬‬‫;‪2 LIBRARY ieee‬‬ ‫;‪3 USE ieee.std_logic_1164.all‬‬ ‫‪4 -----------------------------------------------------------------------‬‬‫‪5 ENTITY dff IS‬‬ ‫‪6‬‬ ‫;‪PORT ( d, clk, rst : IN STD_LOGIC‬‬ ‫‪7‬‬ ‫;) ‪q : OUT STD_LOGIC‬‬ ‫;‪8 END dff‬‬ ‫‪9 -----------------------------------------------------------------------‬‬‫‪10 ARCHITECTURE dff OF dff IS‬‬ ‫‪11 BEGIN‬‬ ‫‪12‬‬ ‫‪PROCESS‬‬ ‫‪13‬‬ ‫‪BEGIN‬‬ ‫‪٧‬‬


14 WAIT ON rst, clk; 15 IF ( rst= '1' ) THEN 16 q <= '0'; 17 ELSIF ( clk'EVENT AND clk = '1' ) THEN 18 q <= d; 19 END IF; 20 END PROCESS; 21 END dff; 22 ----------------------------------------------------------------------One-Digit Counter #2 (٢) ‫ ﻋﺪاد ذي ﺧﺎﻧﺔ واﺣﺪة‬: (٥-٦) ‫اﻟﻤﺜﺎل‬ Progressive 1-Digit ‫اﻟﻜﻮد اﻟﻤﻌﺮوض أدﻧﺎﻩ ﻳﻨﺠﺰ ﻧﻔﺲ اﻟﻌﺪاد اﻟﻌﺸﺮي اﻟﺘﻌ ﺎﻗﺒﻲ ذي اﻟﺨﺎﻧ ﺔ اﻟﻌﺸ ﺮﻳﺔ اﻟﻮاﺣ ﺪة‬ ‫ ﻟﻜ ﻦ‬. ( (٤-٦) ‫( و‬٣-٦) ‫ﻼ ﻣ ﻦ اﻟﺸ ﻜﻠﻴﻦ‬ ً ‫ اﻧﻈﺮ آ‬: (٢-٦) ‫ ) واﻟﺬي ﺳﺒﻖ ﻋﺮﺿﻪ ﻓﻲ اﻟﻤﺜﺎل‬Decimal Counter ‫ ﻓﻘ ﻂ ﻓ ﻲ‬IF ‫ ﻋﻮﺿ ًﺎ ﻋ ﻦ اﺳ ﺘﺨﺪام اﻟﺘﻌﻠﻴﻤ ﺔ‬WAIT ‫ ﻟﻠﺘﻌﻠﻴﻤ ﺔ‬WAIT UNTIL ‫ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ﺗﻢ اﺳﺘﺨﺪام اﻟﺸﻜﻞ‬ . ‫ﻣﻌﺎﻟﺠﺔ ذات ﻻﺋﺤﺔ ﺣﺴﺎﺳﻴﺔ ﺗﻘﻠﻴﺪﻳﺔ‬ 1 --------------------------------------------------------------------------------------2 LIBRARY ieee; 3 USE ieee.std_logic_1164.all; 4 --------------------------------------------------------------------------------------5 ENTITY counter IS 6 PORT ( clk : IN STD_LOGIC; 7 digit : OUT INTEGER RANGE 0 TO 9 ); 8 END counter; 9 --------------------------------------------------------------------------------------10 ARCHITECTURE counter OF counter IS 11 BEGIN 12 PROCESS ------ no sensitivity list 13 VARIABLE temp : INTEGER RANGE 0 TO 10; 14 BEGIN 15 WAIT UNTIL ( clk'EVENT AND clk = '1' ); 16 temp := temp + 1; 17 IF ( temp = 10 ) THEN temp := 0; 18 END IF; 19 digit <= temp; 20 END PROCESS; 21 END counter; 22 -------------------------------------------------------------------------------------: CASE ‫ اﻟﺘﻌﻠﻴﻤﺔ‬-٥-٦ ‫ و‬LOOP ‫ و‬IF ‫ هﻲ ﺗﻌﻠﻴﻤﺔ أﺧﺮى ﻣﻌﺪة ﺣﺼﺮﻳًﺎ ﻣﻦ أﺟ ﻞ اﻟﻜ ﻮد اﻟﺘﺘ ﺎﺑﻌﻲ ) ﺗﻤﺎﻣ ًﺎ ﻣﺜ ﻞ اﻟﺘﻌﻠﻴﻤ ﺎت‬CASE ‫ﺗﻌﻠﻴﻤﺔ‬ : ‫ ﻣﻮﺿﺤﺔ ﻓﻴﻤﺎ ﻳﻠﻲ‬CASE ‫ اﻟﺼﻴﻐﺔ اﻟﻘﻮاﻋﺪﻳﺔ ﻟﻠﺘﻌﻠﻴﻤﺔ‬. ( WAIT CASE identifier IS WHEN value => assignments; WHEN value => assignments; .... END CASE; ٨


‫ﻣﺜﺎل ‪Example :‬‬ ‫‪CASE control IS‬‬ ‫;‪WHEN "00" => x <= a; y <= b‬‬ ‫;‪WHEN "01" => x <= b; y <= c‬‬ ‫;"‪WHEN OTHERS => x <= "0000"; y <= "ZZZZ‬‬ ‫;‪END CASE‬‬ ‫إن اﻟﺘﻌﻠﻴﻤ ﺔ ‪ ) CASE‬اﻟﺘﺘﺎﺑﻌﻴ ﺔ ( ه ﻲ ﻣﺸ ﺎﺑﻬﺔ ﺟ ﺪًا ﻟﺘﻌﻠﻴﻤ ﺔ ‪ ) WHEN‬اﻟﺘﺮآﻴﺒﻴ ﺔ (‪ .‬هﻨ ﺎ أﻳﻀ ًﺎ آﺎﻓ ﺔ اﻻﺣﺘﻤ ﺎﻻت‬ ‫) اﻟﺘﺒﺪﻳﻼت ( ‪ Permutations‬ﻳﺠﺐ أن ﺗﺨﺘﺒﺮ وﺑﺎﻟﺘﺎﻟﻲ ﻓﺈن اﻟﻜﻠﻤﺔ اﻟﻤﻔﺘﺎﺣﻴﺔ اﻟﻤﺤﺠ ﻮزة ‪ OTHERS‬ﺗﻜ ﻮن ﻏﺎﻟﺒ ًﺎ‬ ‫ﻣﻔﻴ ﺪة ﻓ ﻲ ه ﺬا اﻟﺴ ﻴﺎق ‪ .‬آﻠﻤ ﺔ ﻣﻔﺘﺎﺣﻴ ﺔ أﺧ ﺮى هﺎﻣ ﺔ هﻨ ﺎ ه ﻲ اﻟﻜﻠﻤ ﺔ ‪ ) NULL‬اﻟﻤﻨ ﺎﻇﺮة ﻟﻠﻜﻠﻤ ﺔ‬ ‫‪ ( UNAFFECTED‬واﻟﺘﻲ ﻳﺠﺐ أن ﺗﺴﺘﺨﺪم ﻋﻨﺪﻣﺎ ﻻ ﻳﻮﺟﺪ أي إﺟ ﺮاء ﻟﻠﺘﻨﻔﻴ ﺬ ﻣ ﻦ أﺟ ﻞ ﺣﺎﻟ ﺔ ﻣ ﺎ ﻣ ﻦ اﻟﺤ ﺎﻻت ‪.‬‬ ‫;‪WHEN OTHERS => NULL‬‬ ‫ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل ‪:‬‬ ‫ﻣ ﻦ ﺟﻬ ﺔ ﺛﺎﻧﻴ ﺔ ‪ ،‬ﺗﺘ ﻴﺢ ﺗﻌﻠﻴﻤ ﺔ ‪ CASE‬ﻋ ﺪة ﻋﻤﻠﻴ ﺎت إﺳ ﻨﺎد ﻣ ﻦ أﺟ ﻞ آ ﻞ ﺷ ﺮط اﺧﺘﺒ ﺎري ﻣ ﻦ ﺷ ﺮوﻃﻬﺎ ) آﻤ ﺎ ه ﻮ‬ ‫واﺿ ﺢ ﻓ ﻲ اﻟﻤﺜ ﺎل اﻟﺴ ﺎﺑﻖ أﻋ ﻼﻩ ( ﻓ ﻲ ﺣ ﻴﻦ أن اﻟﺘﻌﻠﻴﻤ ﺔ ‪ WHEN‬ﺗﺘ ﻴﺢ ﻋﻤﻠﻴ ﺔ إﺳ ﻨﺎد وﺣﻴ ﺪة ﻣ ﻦ أﺟ ﻞ آ ﻞ ﺷ ﺮط‬ ‫اﺧﺘﺒﺎري ) آﻞ ﺣﺎﻟﺔ ﻣﻦ اﻟﺤﺎﻻت اﻟﻤﻤﻜﻨﺔ ( ‪.‬‬ ‫آﻤﺎ هﻮ اﻟﺤﺎل ﻓﻲ اﻟﺘﻌﻠﻴﻤﺔ ‪ ) WHEN‬راﺟ ﻊ اﻟﻔﻘ ﺮة ‪ ( ٣-٥‬ﻓ ﺈن اﻟﻘﻴﻤ ﺔ " ‪ " WHEN Value‬ﻳﻤﻜ ﻦ أن ﺗﺄﺧ ﺬ هﻨ ﺎ‬ ‫أﻳﻀًﺎ إﺣﺪى ﺛﻼﺛﺔ أﺷﻜﺎل ‪:‬‬ ‫‪WHEN value‬‬ ‫‪-- single value‬‬ ‫‪WHEN value1 to value2‬‬ ‫‪-- range, for enumerated data types only‬‬ ‫‪WHEN value1 | value2 | . . .‬‬ ‫‪-- value1 or value2 or . . .‬‬ ‫اﻟﻤﺜﺎل )‪ : (٦-٦‬ﻗﻼب ‪ D‬ﻣﻊ ﻣﺪﺧﻞ ﺗﺼﻔﻴﺮ ﻏﻴﺮ ﻣﺘﻮاﻗﺖ )‪DFF With Asynchronous Reset #3 (٣‬‬ ‫اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﻳﻨﺠﺰ ﻧﻔﺲ اﻟﻘﻼب ﻣﻦ اﻟﻨﻮع ‪ D‬اﻟﺬي ﺳﺒﻖ ﺗﺼﻤﻴﻤﻪ ﻓﻲ اﻟﻤﺜ ﺎل )‪ ] (١-٦‬اﻟﺸ ﻜﻼن )‪ (١-٦‬و )‪. [ (٢-٦‬‬ ‫ﻟﻜﻦ هﻨﺎ ﺗﻢ اﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻤﺔ ‪ CASE‬ﻋﻮﺿًﺎ ﻋﻦ اﻟﺘﻌﻠﻴﻤﺔ ‪ . IF‬ﻧﻼﺣﻆ هﻨ ﺎ أن ﺑﻀ ﻌﺔ ﺗﺼ ﺮﻳﺤﺎت و إﺿ ﺎﻓﺎت ﻏﻴ ﺮ‬ ‫ﺿﺮورﻳﺔ ﻗﺪ ﺗﻢ ﺗﻀﻤﻴﻨﻬﺎ ﻓﻲ اﻟﻜﻮد ﻋﻤﺪًا ﻟﺘﻮﺿﻴﺢ آﻴﻔﻴﺔ اﺳﺘﺨﺪاﻣﻬﺎ ‪.‬‬ ‫‪1 ---------------------------------------------------------------------------------------------------------------------‬‬‫;‪2 LIBRARY ieee‬‬ ‫‪-- Unnecessary declaration because‬‬ ‫;‪3 USE ieee.std_logic_1164.all‬‬ ‫‪-- BIT was used instead of STD_LOGIC‬‬ ‫‪4 ---------------------------------------------------------------------------------------------------------------------‬‬‫‪5 ENTITY dff IS‬‬ ‫‪6‬‬ ‫;‪PORT ( d, clk, rst : IN BIT‬‬ ‫‪7‬‬ ‫;) ‪q : OUT BIT‬‬ ‫;‪8 END dff‬‬ ‫‪9 ---------------------------------------------------------------------------------------------------------------------‬‬‫‪10 ARCHITECTURE dff3 OF dff IS‬‬ ‫‪11 BEGIN‬‬ ‫‪12‬‬ ‫) ‪PROCESS ( clk, rst‬‬ ‫‪13‬‬ ‫‪BEGIN‬‬ ‫‪14‬‬ ‫‪CASE rst IS‬‬ ‫‪15‬‬ ‫;'‪WHEN '1' => q <= '0‬‬ ‫‪16‬‬ ‫>= '‪WHEN '0‬‬ ‫‪17‬‬ ‫‪IF ( clk'EVENT AND clk = '1' ) THEN‬‬ ‫‪18‬‬ ‫;‪q <= d‬‬ ‫‪19‬‬ ‫;‪END IF‬‬ ‫‪20‬‬ ‫;‪WHEN OTHERS => NULL‬‬ ‫‪-- Unnecessary, rst is of type BIT‬‬ ‫‪21‬‬ ‫;‪END CASE‬‬ ‫‪22‬‬ ‫;‪END PROCESS‬‬ ‫;‪23 END dff3‬‬ ‫‪24 --------------------------------------------------------------------------------------------------------------------‬‬

‫‪٩‬‬


‫اﻟﻤﺜﺎل )‪ : (٧-٦‬ﻋﺪاد ذي ﺧﺎﻧﺘﻴﻦ ﻋﺸﺮﻳﺘﻴﻦ ﻣﻊ ﻣﺨﺎرج ﻣﻮﺻﻮﻟﺔ إﻟﻰ ﻟﻮﺣﺘﻲ إﻇﻬﺎر ذات اﻟﻘﻄﻊ اﻟﺴﺒﻊ‬ ‫‪Example (6-7) : Two-Digit Counter With Seven-Segment Display ( SSD ) Output‬‬ ‫اﻟﻜﻮد اﻟﻤﻌﺮوض أدﻧﺎﻩ ﻳﻨﺠﺰ ﻋﺪادًا ﻋﺸﺮﻳًﺎ ﺗﺼﺎﻋﺪﻳًﺎ ذا ﺧ ﺎﻧﺘﻴﻦ ﻋﺸ ﺮﻳﺘﻴﻦ ﺑﺤﻴ ﺚ ﻳﻌ ﺪ ﻣ ﻦ ‪ 0‬إﻟ ﻰ ‪ 99‬وﻣ ﻦ ﺛ ﻢ ﻳﻌ ﻮد‬ ‫إﻟﻰ اﻟﻘﻴﻤﺔ ‪ 0‬ﻟﻴﻜﺮر اﻟﺪورة ﻣﻦ ﺟﺪﻳﺪ ‪ .‬ﻟﻬﺬا اﻟﻌﺪاد ﻣﺪﺧﻞ ﺗﺼﻔﻴﺮ ﻏﻴﺮ ﻣﺘﻮاﻗﺖ ﺧﺎرﺟﻲ ﺑﺎﻹﺿﺎﻓﺔ إﻟﻰ ﻣﻴ ﺰة اﻟﺘﺤﻮﻳ ﻞ‬ ‫ﻣﻦ ﺻﻴﻐﺔ اﻷﻋﺪاد اﻟﻌﺸ ﺮﻳﺔ اﻟﻤﺮﻣ ﺰة ﺛﻨﺎﺋﻴ ًﺎ ‪ ( Binary-Coded Decimal ) BCD‬إﻟ ﻰ ﺷ ﻴﻔﺮة ﻟﻮﺣ ﺔ اﻹﻇﻬ ﺎر‬ ‫ذات اﻟﻘﻄﻊ اﻟﺴﺒﻊ ‪. ( Seven-Segment Display ) SSD‬‬ ‫ﻣﺨﻄﻄ ﺎت اﻟ ﺪارة وﻟﻮﺣ ﺎت اﻹﻇﻬ ﺎر ذات اﻟﻘﻄ ﻊ اﻟﺴ ﺒﻊ ﻣﺒﻴﻨ ﺔ ﻓ ﻲ اﻟﺸ ﻜﻞ )‪ .(٧-٦‬ﺗ ﻢ اﺳ ﺘﺨﺪام اﻟﺘﻌﻠﻴﻤ ﺔ ‪CASE‬‬ ‫) اﻷﺳ ﻄﺮ ﻣ ﻦ ‪ 31‬وﺣﺘ ﻰ ‪ ( 56‬ﻟﺘﺤﺪﻳ ﺪ إﺷ ﺎرات اﻟﺨ ﺮج اﻟﺘ ﻲ ﺳ ﻮف ﺗﻐ ﺬي ﻟ ﻮﺣﺘﻲ اﻹﻇﻬ ﺎر ذات اﻟﻘﻄ ﻊ اﻟﺴ ﺒﻊ‬ ‫‪ .SSDs‬ﻻﺣﻆ هﻨﺎ أﻧﻪ ﻗﺪ ﺗﻢ اﺧﺘﻴﺎر اﻟﺘﻮﺻﻴﻞ اﻟﺘﺎﻟﻲ ﺑﻴﻦ اﻟﺪارة وﻟﻮﺣﺔ اﻹﻇﻬﺎر ذات اﻟﻘﻄﻊ اﻟﺴﺒﻊ ‪:‬‬ ‫‪xabcdefg‬‬ ‫) أي أن اﻟﺨﺎﻧ ﺔ اﻷآﺜ ﺮ أهﻤﻴ ﺔ ‪ MSB‬ﺗﻐ ﺬي اﻟﻨﻘﻄ ﺔ اﻟﻌﺸ ﺮﻳﺔ ‪ Decimal Point‬ﻓ ﻲ ﺣ ﻴﻦ أن اﻟﺨﺎﻧ ﺔ اﻷﻗ ﻞ أهﻤﻴ ﺔ‬ ‫ﺗﻐﺬي اﻟﻘﻄﻌﺔ ‪ g‬ﻣﻦ اﻟﻠﻮﺣﺔ ( ‪.‬‬

‫اﻟﺸﻜﻞ )‪ : (٧-٦‬اﻟﻌﺪاد اﻟﻌﺸﺮي ذو اﻟﺨﺎﻧﺘﻴﻦ ﻟﻠﻤﺜﺎل )‪(٧-٦‬‬ ‫آﻤﺎ هﻮ واﺿﺢ ﻟﻠﻌﻴﺎن ‪ ،‬ﻓﺈن هﺬﻩ اﻟﺪارة هﻲ ﺑﻤﺜﺎﺑ ﺔ اﻣﺘ ﺪاد ﻣﺒﺎﺷ ﺮ ﻟﻠ ﺪارة اﻟﻤﻌﺮوﺿ ﺔ ﻓ ﻲ اﻟﻤﺜ ﺎل )‪ (٢-٦‬ﻣ ﻊ اﻟﻔ ﺎرق‬ ‫ﻻ ﻣﻦ ﺧﺎﻧﺔ واﺣﺪة ﻓ ﻲ اﻟ ﺪارة اﻟﺴ ﺎﺑﻘﺔ وأن اﻟﻤﺨ ﺎرج هﻨ ﺎ ﻳﺠ ﺐ‬ ‫اﻟﻤﺘﻤﺜﻞ ﻓﻲ ﺣﻘﻴﻘﺔ أن اﻟﺪارة اﻟﺤﺎﻟﻴﺔ ﺗﺘﻄﻠﺐ ﺧﺎﻧﺘﻴﻦ ﺑﺪ ً‬ ‫أن ﺗﻮﺻ ﻞ إﻟ ﻰ وﺣ ﺪات إﻇﻬ ﺎر ﻣ ﻦ ﻧ ﻮع ‪ . SSD‬ﻳﻤﻜ ﻦ اﻟﺘﺤﻘ ﻖ ﻣ ﻦ ﺻ ﺤﺔ أداء اﻟ ﺪارة ﻣ ﻦ ﺧ ﻼل ﻧﺘ ﺎﺋﺞ اﻟﻤﺤﺎآ ﺎة‬ ‫اﻟﻤﺒﻴﻨﺔ ﻓﻲ اﻟﺸﻜﻞ )‪. (٨-٦‬‬

‫اﻟﺸﻜﻞ )‪ : (٨-٦‬ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻟﻠﻤﺜﺎل )‪(٧-٦‬‬ ‫‪1 ------------------------------------------------------------------------------------------------‬‬‫;‪2 LIBRARY ieee‬‬ ‫;‪3 USE ieee.std_logic_1164.all‬‬ ‫‪4 ------------------------------------------------------------------------------------------------‬‬‫‪5 ENTITY counter IS‬‬ ‫‪6‬‬ ‫;‪PORT ( clk, reset : IN STD_LOGIC‬‬ ‫‪7‬‬ ‫;))‪digit1, digit2 : OUT STD_LOGIC_VECTOR (6 DOWNTO 0‬‬ ‫;‪8 END counter‬‬ ‫‪١٠‬‬


9 ------------------------------------------------------------------------------------------------10 ARCHITECTURE counter OF counter IS 11 BEGIN 12 PROCESS ( clk, reset ) 13 VARIABLE temp1: INTEGER RANGE 0 TO 10; 14 VARIABLE temp2: INTEGER RANGE 0 TO 10; 15 BEGIN 16 -------------------- counter : ---------------------17 IF ( reset = '1' ) THEN 18 temp1 := 0; 19 temp2 := 0; 20 ELSIF ( clk'EVENT AND clk = '1' ) THEN 21 temp1 := temp1 + 1; 22 IF ( temp1 = 10 ) THEN 23 temp1 := 0; 24 temp2 := temp2 + 1; 25 IF ( temp2 = 10 ) THEN 26 temp2 := 0; 27 END IF; 28 END IF; 29 END IF; 30 ----------------- BCD to SSD conversion : -----------------31 CASE temp1 IS 32 WHEN 0 => digit1 <= "1111110"; --7E H 33 WHEN 1 => digit1 <= "0110000"; --30 H 34 WHEN 2 => digit1 <= "1101101"; --6D H 35 WHEN 3 => digit1 <= "1111001"; --79 H 36 WHEN 4 => digit1 <= "0110011"; --33 H 37 WHEN 5 => digit1 <= "1011011"; --5B H 38 WHEN 6 => digit1 <= "1011111"; --5F H 39 WHEN 7 => digit1 <= "1110000"; --70 H 40 WHEN 8 => digit1 <= "1111111"; --7F H 41 WHEN 9 => digit1 <= "1111011"; --7B H 42 WHEN OTHERS => NULL; 43 END CASE; 44 CASE temp2 IS 45 WHEN 0 => digit2 <= "1111110"; --7E H 46 WHEN 1 => digit2 <= "0110000"; --30 H 47 WHEN 2 => digit2 <= "1101101"; --6D H 48 WHEN 3 => digit2 <= "1111001"; --79 H 49 WHEN 4 => digit2 <= "0110011"; --33 H 50 WHEN 5 => digit2 <= "1011011"; --5B H 51 WHEN 6 => digit2 <= "1011111"; --5F H 52 WHEN 7 => digit2 <= "1110000"; --70 H 53 WHEN 8 => digit2 <= "1111111"; --7F H 54 WHEN 9 => digit2 <= "1111011"; --7B H 55 WHEN OTHERS => NULL; 56 END CASE; 57 END PROCESS; 58 END counter; 59 ------------------------------------------------------------------------------------------------

١١


‫ﺗﻌﻠﻴﻖ ‪Comment :‬‬ ‫ﻧﻼﺣ ﻆ ﻓ ﻲ اﻟﻜ ﻮد اﻟﺴ ﺎﺑﻖ أن ﻧﻔ ﺲ اﻟ ﺮوﺗﻴﻦ ‪ The Same Routine‬ﻗ ﺪ آ ﺮر ﻣ ﺮﺗﻴﻦ ) ﺑﺎﺳ ﺘﺨﺪام ﺗﻌﻠﻴﻤ ﺎت‬ ‫‪ .( CASE‬ﺳ ﻮف ﻧ ﺮى ﻓ ﻲ وﻗ ﺖ ﻻﺣ ﻖ آﻴﻔﻴ ﺔ آﺘﺎﺑ ﺔ وﺗﺮﺟﻤ ﺔ ﻗﻄ ﻊ اﻟﻜ ﻮد اﻟﻤﺴ ﺘﺨﺪﻣﺔ ﺑﺸ ﻜﻞ ﺷ ﺎﺋﻊ وﺗﻨﻈﻴﻤﻬ ﺎ ﻓ ﻲ‬ ‫اﻟﻤﻜﺘﺒﺎت اﻟﺨﺎﺻﺔ ﺑﺎﻟﻤﺼﻤﻢ ) ﻣﺎ ﻳﻌﺮف ﺑﺎﺳ ﻢ ‪ ( User-Defined Libraries‬وﺑﺎﻟﺘ ﺎﻟﻲ ﻓ ﺈن ﻋﻤﻠﻴ ﺎت ﺗﻜ ﺮار آﻬ ﺬﻩ‬ ‫ﻳﻤﻜﻦ ﺗﺠﺎوزهﺎ أو اﻟﺘﺨﻠﺺ ﻣﻨﻬﺎ ‪.‬‬ ‫‪ -٦-٦‬اﻟﺘﻌﻠﻴﻤﺔ ‪: LOOP‬‬ ‫إن ﺗﻌﻠﻴﻤﺔ اﻟﺤﻠﻘﺔ ‪ ) LOOP‬وآﻤﺎ هﻮ واﺿﺢ ﻣﻦ اﺳﻤﻬﺎ ( ﻣﻔﻴﺪة ﻋﻨﺪﻣﺎ ﻳﻠﺰم ﺗﻜﺮار ﻗﻄﻌﺔ ﻣﻦ اﻟﻜﻮد ﻋﺪة ﻣﺮات‪ .‬آﻤﺎ‬ ‫هﻮ اﻟﺤﺎل ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺘﻌﻠﻴﻤﺎت ‪ IF‬و ‪ WAIT‬و ‪ CASE‬ﻓﺈن اﻟﺘﻌﻠﻴﻤﺔ ‪ LOOP‬ﻣﻌﺪة ﺣﺼ ﺮﻳًﺎ ﻟﻼﺳ ﺘﺨﺪام ﺿ ﻤﻦ آ ﻮد‬ ‫ﺗﺘ ﺎﺑﻌﻲ وﺑﺎﻟﺘ ﺎﻟﻲ ﻓﺈﻧﻬ ﺎ ﻳﻤﻜ ﻦ أن ﺗﺴ ﺘﺨﺪم ﻓﻘ ﻂ داﺧ ﻞ ﻣﻌﺎﻟﺠ ﺔ ‪ PROCESS‬أو ﺗ ﺎﺑﻊ ‪ FUNCTION‬أو إﺟﺮاﺋﻴ ﺔ‬ ‫‪. PROCEDURE‬‬ ‫هﻨﺎك ﻋﺪة ﻃﺮق ﻻﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻤﺔ ‪ LOOP‬آﻤﺎ هﻮ ﻣﻮﺿﺢ ﻓﻲ اﻟﺼﻴﻎ اﻟﻘﻮاﻋﺪﻳﺔ اﻟﺘﺎﻟﻴﺔ ‪:‬‬ ‫‪ : FOR / LOOP‬ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ﻓﺈن اﻟﺤﻠﻘﺔ ﺗﻜﺮر ﻋﺪدًا ﻣﺤﺪدًا وﺛﺎﺑﺘًﺎ ﻣﻦ اﻟﻤﺮات ‪.‬‬ ‫‪[label:] FOR identifier IN range LOOP‬‬ ‫)‪(sequential statements‬‬ ‫;]‪END LOOP [label‬‬ ‫‪ : WHILE / LOOP‬ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ﻓﺈن اﻟﺤﻠﻘﺔ ﺗﻜﺮر ﻃﺎﻟﻤﺎ أن ﺷﺮط اﺳﺘﻤﺮار ﺗﻨﻔﻴﺬ اﻟﺤﻠﻘﺔ ﻣﺤﻘﻖ ‪.‬‬ ‫‪[label:] WHILE condition LOOP‬‬ ‫)‪(sequential statements‬‬ ‫;]‪END LOOP [label‬‬ ‫‪ : EXIT‬ﺗﺴﺘﺨﺪم اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ EXIT‬ﻣﻦ أﺟﻞ إﻧﻬﺎء ﺗﻨﻔﻴﺬ اﻟﺤﻠﻘﺔ واﻟﺨﺮوج ﻣﻨﻬﺎ ‪.‬‬ ‫;]‪[label:] EXIT [label] [WHEN condition‬‬ ‫‪ : NEXT‬ﺗﺴﺘﺨﺪم اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ NEXT‬ﻟﺘﺨﻄﻲ ﺧﻄﻮات اﻟﺤﻠﻘﺔ ‪. Loop Steps‬‬ ‫;]‪[label:] NEXT [loop_label] [WHEN condition‬‬ ‫ﻣﺜﺎل ﻋﻠﻰ اﻟﺸﻜﻞ ‪: FOR / LOOP‬‬ ‫‪FOR i IN 0 TO 5 LOOP‬‬ ‫;)‪x(i) <= enable AND w(i+2‬‬ ‫;)‪y(0, i) <= w(i‬‬ ‫;‪END LOOP‬‬ ‫ﻓﻲ اﻟﻜﻮد أﻋﻼﻩ ﺳﻮف ﺗﻨﻔ ﺬ اﻟﺤﻠﻘ ﺔ ) ﻳﺘﻜ ﺮر ﺗﻨﻔﻴ ﺬ اﻟﺘﻌﻠﻴﻤ ﺎت اﻟﻤﻮﺟ ﻮدة ﺑ ﺪاﺧﻠﻬﺎ ( ﺑﺸ ﻜﻞ ﻏﻴ ﺮ ﻣﺸ ﺮوط ﺣﺘ ﻰ ﺗﺼ ﻞ‬ ‫ﻗﻴﻤﺔ ﻋﺪاد اﻟﺤﻠﻘﺔ ‪ i‬إﻟﻰ اﻟﻘﻴﻤﺔ ‪ ) 5‬أي ﻣﻦ اﻟﻘﻴﻤﺔ ‪ 0‬وﺣﺘﻰ اﻟﻘﻴﻤﺔ ‪ 5‬وﺑﺎﻟﺘﺎﻟﻲ ‪ 6‬ﻣﺮات ( ‪.‬‬ ‫ﻣﻼﺣﻈ ﺔ هﺎﻣ ﺔ ﺗﺘﻌﻠ ﻖ ﺑﺎﻟﺸ ﻜﻞ ‪ ) FOR / LOOP‬واﻟﺘ ﻲ ﺗﺸ ﺒﻪ اﻟﺤﺎﻟ ﺔ اﻟﻤﻤﺎﺛﻠ ﺔ اﻟﺘ ﻲ رأﻳﻨﺎه ﺎ أﺛﻨ ﺎء دراﺳ ﺔ اﻟﺘﻌﻠﻴﻤ ﺔ‬ ‫‪ GENERATE‬ﻓ ﻲ اﻟﺠﻠﺴ ﺔ اﻟﺴ ﺎﺑﻘﺔ ( ﻣﻔﺎده ﺎ أن آ ﻼ اﻟﺤ ﺪﻳﻦ ﻟﻠﻤﺠ ﺎل ﻳﺠ ﺐ أن ﻳﻜﻮﻧ ﺎ ﻗﻴﻤﺘ ﻴﻦ ﺛ ﺎﺑﺘﺘﻴﻦ ‪Static‬‬ ‫‪ .Values‬ﺑﺎﻟﺘ ﺎﻟﻲ ﻓ ﺈن ﺗﺼ ﺮﻳﺤًﺎ ﻣ ﻦ اﻟﻨ ﻮع " ‪ " FOR i IN 0 TO choice LOOP‬ﺣﻴ ﺚ أن ‪ choice‬ه ﻮ‬ ‫ﻋﺒ ﺎرة ﻋ ﻦ ﺑ ﺎراﻣﺘﺮ دﺧ ﻞ ‪ ) input‬ﻗﻴﻤ ﺔ ﻏﻴ ﺮ ﺛﺎﺑﺘ ﺔ ( ﻳﻜ ﻮن ﻋﻤﻮﻣ ًﺎ ﻏﻴ ﺮ ﻗﺎﺑ ﻞ ﻟﻠﺘﺮآﻴ ﺐ ‪Generally Not‬‬ ‫‪. Synthesizable‬‬ ‫ﻣﺜﺎل ﻋﻠﻰ اﻟﺸﻜﻞ ‪: WHILE / LOOP‬‬ ‫ﻓﻲ هﺬا اﻟﻤﺜﺎل ‪ ،‬ﺳﻮف ﻳﺴﺘﻤﺮ ﺗﻨﻔﻴﺬ اﻟﺤﻠﻘﺔ ﻃﺎﻟﻤﺎ أن اﻟﺸﺮط ‪ i < 10‬ﻣﺤﻘﻖ ‪:‬‬ ‫‪WHILE ( i < 10 ) LOOP‬‬ ‫;'‪WAIT UNTIL clk'EVENT AND clk = '1‬‬ ‫)‪(other statements‬‬ ‫;‪END LOOP‬‬ ‫ﻣﺜﺎل ﻋﻠﻰ اﻟﺘﻌﻠﻴﻤﺔ ‪: EXIT‬‬ ‫ﻓﻲ اﻟﻜﻮد اﻟﻤﺒﻴﻦ ﻓﻴﻤﺎ ﻳﻠﻲ ﻓﺈن اﻟﺘﻌﻠﻴﻤ ﺔ ‪ EXIT‬ﻻ ﺗﻌﻨ ﻲ ﺗﺠ ﺎوز ﺗﻨﻔﻴ ﺬ اﻟﻤﺴ ﺢ اﻟﺤ ﺎﻟﻲ ﻟﻠﺤﻠﻘ ﺔ ‪Current Iteration‬‬ ‫‪ Of The Loop‬وإﻧﻤ ﺎ ﺗﻌﻨ ﻲ ﺧﺮوﺟ ًﺎ ﻧﻬﺎﺋﻴ ًﺎ ﻣ ﻦ اﻟﺤﻠﻘ ﺔ ) أي أﻧ ﻪ ﺣﺘ ﻰ وﻟ ﻮ آ ﺎن ﻋ ﺪاد اﻟﺤﻠﻘ ﺔ ‪ i‬ﻣ ﺎ ﻳ ﺰال ﺿ ﻤﻦ‬ ‫اﻟﻤﺠﺎل اﻟﻤﺤﺪد ﻟﻠﺤﻠﻘ ﺔ ﻓ ﺈن اﻟﺤﻠﻘ ﺔ ﺳ ﻮف ﺗﻌﺘﺒ ﺮ ﻣﻨﺘﻬﻴ ﺔ اﻟﺘﻨﻔﻴ ﺬ ( ‪ .‬ﻓ ﻲ ه ﺬﻩ اﻟﺤﺎﻟ ﺔ ﺑﺎﻟ ﺬات ) اﻟﻤﺜ ﺎل اﻟﻤﻌﻄ ﻰ ﺑ ﺎﻟﻜﻮد‬ ‫‪١٢‬‬


‫اﻟﺘ ﺎﻟﻲ ( ﻓ ﺈن اﻟﺤﻠﻘ ﺔ ﺳ ﻮف ﺗﻨﺘﻬ ﻲ ﺑﻤﺠ ﺮد أن ﻳ ﺘﻢ إﻳﺠ ﺎد ﻗﻴﻤ ﺔ ﻣﻐ ﺎﻳﺮة ﻟﻠﺼ ﻔﺮ ﺿ ﻤﻦ ﺷ ﻌﺎع اﻟﻤﻌﻄﻴ ﺎت ‪ ) data‬أي‬ ‫ﺑﻤﺠﺮد أن ﻳﺘﺤﻘﻖ اﻟﺸﺮط '‪. ( data(i) ≠ '0‬‬ ‫‪FOR i IN data'RANGE LOOP‬‬ ‫‪CASE data(i) IS‬‬ ‫;‪WHEN '0' => count := count + 1‬‬ ‫;‪WHEN OTHERS => EXIT‬‬ ‫;‪END CASE‬‬ ‫;‪END LOOP‬‬ ‫ﻣﺜﺎل ﻋﻠﻰ اﻟﺘﻌﻠﻴﻤﺔ ‪: NEXT‬‬ ‫ﻓﻲ اﻟﻤﺜﺎل اﻟﻤﺒﻴﻦ ﻓﻴﻤﺎ ﻳﻠﻲ ﺳﻮف ﺗﺴﺒﺐ اﻟﺘﻌﻠﻴﻤﺔ ‪ NEXT‬ﺗﺠﺎوز ﺗﻨﻔﻴﺬ ﺗﻌﻠﻴﻤﺎت اﻟﺤﻠﻘﺔ ﻋﻨﺪﻣﺎ ﻳﺘﺤﻘﻖ اﻟﺸﺮط اﻟﺘﺎﻟﻲ ‪:‬‬ ‫‪ i = skip‬وﺑﺎﻟﺘﺎﻟﻲ ﻳﺘﻢ اﻻﻧﺘﻘﺎل إﻟﻰ اﻟﻤﺴﺢ اﻟﺘﺎﻟﻲ ﻟﺠﺴﻢ اﻟﺤﻠﻘﺔ ‪.‬‬ ‫‪FOR i IN 0 TO 15 LOOP‬‬ ‫;‪NEXT WHEN i = skip‬‬ ‫‪-- jumps to next iteration‬‬ ‫)‪(...‬‬ ‫;‪END LOOP‬‬ ‫ﻓﻴﻤﺎ ﻳﻠﻲ ﺳﻮف ﻳﺘﻢ ﻋﺮض ﻋﺪة أﻣﺜﻠﺔ ﺗﺼﻤﻴﻤﻴﺔ ﻣﻜﺘﻤﻠﺔ ﺗﻮﺿﺢ اﻟﺘﻄﺒﻴﻘﺎت اﻟﻤﺨﺘﻠﻔﺔ ﻟﺘﻌﻠﻴﻤﺔ اﻟﺤﻠﻘﺔ ‪. LOOP‬‬ ‫اﻟﻤﺜﺎل )‪ : (٨-٦‬ﺟﺎﻣﻊ اﻟﺤﻤﻞ اﻟﺰاﺣﻒ ‪Carry Ripple Adder‬‬ ‫ﻳﺒ ﻴﻦ اﻟﺸ ﻜﻞ )‪ (٩-٦‬ﺟ ﺎﻣﻊ ﺣﻤ ﻞ زاﺣ ﻒ ﻏﻴ ﺮ ﻣﺆﺷ ﺮ ذي ﺛﻤ ﺎن ﺧﺎﻧ ﺎت ‪8-bit Unsigned Carry Ripple‬‬ ‫‪ . Adder‬ﻣﺨﻄﻂ اﻟﻤﺴﺘﻮى اﻷﻋﻠ ﻰ ‪ Top-Level Diagram‬ﻳﺒ ﻴﻦ ﻣ ﺪاﺧﻞ وﻣﺨ ﺎرج اﻟ ﺪارة ‪ a :‬و ‪ b‬هﻤ ﺎ ﺷ ﻌﺎﻋﺎ‬ ‫اﻟﺪﺧﻞ اﻟﻤﺮاد ﺟﻤﻌﻬﻤﺎ ‪ .Input Vectors to be Added‬اﻹﺷﺎرة ‪ cin‬ه ﻲ ﺧﺎﻧ ﺔ ﺣﻤ ﻞ اﻟ ﺪﺧﻞ ‪. Carry-In Bit‬‬ ‫‪ S‬ه ﻲ ﺷ ﻌﺎع اﻟﻤﺠﻤ ﻮع ‪ Sum Vector‬و ‪ cout‬ه ﻲ ﺧﺎﻧ ﺔ ﺣﻤ ﻞ اﻟﺨ ﺮج ‪ . Carry-Out Bit‬ﻣﺨﻄ ﻂ اﻟﻤﺴ ﺘﻮى‬ ‫اﻷﺧﻔ ﺾ ﻣﺒﺎﺷ ﺮ ًة ﻣ ﻦ اﻟﻤﺴ ﺘﻮى اﻷﻋﻠ ﻰ ‪ The One-Level-Below-Top Diagram‬ﻳﺒ ﻴﻦ آﻴﻔﻴ ﺔ اﻧﺘﺸ ﺎر‬ ‫) زﺣﻒ ( ﺧﺎﻧﺎت اﻟﺤﻤﻞ ‪. Carry Bits Propagate‬‬

‫اﻟﺸﻜﻞ )‪ : (٩-٦‬ﺟﺎﻣﻊ اﻟﺤﻤﻞ اﻟﺰاﺣﻒ ﺛﻤﺎﻧﻲ اﻟﺨﺎﻧﺎت ﻟﻠﻤﺜﺎل )‪(٨-٦‬‬ ‫إن آ ﻞ ﻣﻘﻄ ﻊ ‪ Section‬ﻣ ﻦ اﻟﻤﺨﻄ ﻂ اﻷﺧﻴ ﺮ ه ﻮ ﻋﺒ ﺎرة ﻋ ﻦ وﺣ ﺪة ﺟ ﺎﻣﻊ آﺎﻣ ﻞ ذي ﺧﺎﻧ ﺔ واﺣ ﺪة ‪1-bit Full‬‬ ‫‪ Adder‬وﺑﺎﻟﺘﺎﻟﻲ ﻓﺈن ﻣﺨﺎرج هﺬﻩ اﻟﻤﻘﺎﻃﻊ ﻳﻤﻜﻦ أن ﺗﺤﺘﺴﺐ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻓﻴﻤ ﺎ ﻳﻠ ﻲ ﺳ ﻨﻌﺮض ﺣﻠ ﻴﻦ ﻣﺨﺘﻠﻔ ﻴﻦ ‪ ،‬أﺣ ﺪهﻤﺎ ﻋﻤ ﻮﻣﻲ ‪ ) Generic‬أي ﻣ ﻦ أﺟ ﻞ أي ﻋ ﺪد آ ﺎن ﻟﺨﺎﻧ ﺎت اﻟ ﺪﺧﻞ (‬ ‫واﻵﺧ ﺮ ﺧ ﺎص ﺑﺤﺎﻟ ﺔ اﻷﻋ ﺪاد ﺛﻤﺎﻧﻴ ﺔ اﻟﺨﺎﻧ ﺎت ) اﻷﻋ ﺪاد ﺑﻌ ﺮض ‪ 8‬ﺧﺎﻧ ﺎت ( ‪ .‬ﻳﺒ ﻴﻦ اﻟﺤ ﻞ اﻷول آﻴﻔﻴ ﺔ اﺳ ﺘﺨﺪام‬ ‫اﻷﺷﻌﺔ ‪ Vectors‬ﻣﻊ اﻟﺘﻌﻠﻴﻤﺔ ‪ FOR / LOOP‬ﻓﻲ ﺣ ﻴﻦ أن اﻟﺤ ﻞ اﻵﺧ ﺮ ﻳﺒ ﻴﻦ آﻴﻔﻴ ﺔ اﺳ ﺘﺨﺪام اﻷﻋ ﺪاد اﻟﺼ ﺤﻴﺤﺔ‬ ‫ﻣﻊ اﻟﺘﻌﻠﻴﻤﺔ ‪ . IF‬ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻟﻜﻞ ﻣﻦ اﻟﺤﺎﻟﺘﻴﻦ ﻣﺒﻴﻨﺔ ﻓﻲ اﻟﺸﻜﻞ )‪. (١٠-٦‬‬ ‫ﻣﻼﺣﻈﺔ ‪ :‬ﺳﻮف ﻧﺮى اﻟﻤﺰﻳﺪ ﺣﻮل اﻟﺠﻮاﻣﻊ ﻓﻲ اﻟﺠﻠﺴﺔ اﻷﺧﻴﺮة ) اﻟﺠﻠﺴﺔ اﻟﻌﺎﺷﺮة ( ‪.‬‬ ‫‪١٣‬‬


(٨-٦) ‫ ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻟﻠﻤﺜﺎل‬: (١٠-٦) ‫اﻟﺸﻜﻞ‬ 1 -------------------------- Solution 1 : Generic, with VECTORS --------------------------2 LIBRARY ieee; 3 USE ieee.std_logic_1164.all; 4 ---------------------------------------------------------------------------------------------------5 ENTITY adder IS 6 GENERIC ( length : INTEGER := 8 ); 7 PORT ( a, b : IN STD_LOGIC_VECTOR ( length-1 DOWNTO 0 ); 8 cin : IN STD_LOGIC; 9 s : OUT STD_LOGIC_VECTOR ( length-1 DOWNTO 0 ); 10 cout : OUT STD_LOGIC ); 11 END adder; 12 --------------------------------------------------------------------------------------------------13 ARCHITECTURE adder OF adder IS 14 BEGIN 15 PROCESS ( a, b, cin ) 16 VARIABLE carry : STD_LOGIC_VECTOR ( length DOWNTO 0 ); 17 BEGIN 18 carry(0) := cin; 19 FOR i IN 0 TO length-1 LOOP 20 s(i) <= a(i) XOR b(i) XOR carry(i); 21 carry(i+1) := (a(i) AND b(i)) OR (a(i) AND 22 carry(i)) OR (b(i) AND carry(i)); 23 END LOOP; 24 cout <= carry( length ); 25 END PROCESS; 26 END adder; 27 --------------------------------------------------------------------------------------------------1 ------------------------- Solution 2 : non-generic, with INTEGERS ----------------------2 LIBRARY ieee; 3 USE ieee.std_logic_1164.all; 4 ---------------------------------------------------------------------------------------------------5 ENTITY adder IS 6 PORT ( a, b : IN INTEGER RANGE 0 TO 255; 7 c0 : IN STD_LOGIC; ١٤


8 s : OUT INTEGER RANGE 0 TO 255; 9 c8 : OUT STD_LOGIC ); 10 END adder; 11 --------------------------------------------------------------------------------------------------12 ARCHITECTURE adder OF adder IS 13 BEGIN 14 PROCESS ( a, b, c0 ) 15 VARIABLE temp : INTEGER RANGE 0 TO 511; 16 BEGIN 17 IF (c0 = '1' ) THEN temp:=1; 18 ELSE temp:=0; 19 END IF; 20 temp := a + b + temp; 21 IF ( temp > 255 ) THEN 22 c8 <= '1'; 23 temp := temp - 256; 24 ELSE c8 <= '0'; 25 END IF; 26 s <= temp; 27 END PROCESS; 28 END adder; 29 --------------------------------------------------------------------------------------------------Simple Barrel Shifter ‫ ﻣﺰﻳﺢ " ﺑﺎرﻳﻞ " ﺑﺴﻴﻂ‬: (٩-٦) ‫اﻟﻤﺜﺎل‬ ‫ ﻓ ﻲ ه ﺬﻩ اﻟﺤﺎﻟ ﺔ ﻳﺘﻮﺟ ﺐ ﻋﻠ ﻰ اﻟ ﺪارة أن ﺗﻘ ﻮم ﺑﺈزاﺣ ﺔ‬. ‫( ﻣﺨﻄﻄًﺎ ﻟﻤﺰﻳﺢ " ﺑﺎرﻳ ﻞ " ﺑﺴ ﻴﻂ ﺟ ﺪًا‬١١-٦) ‫ﻳﺒﻴﻦ اﻟﺸﻜﻞ‬ ‫ ﻋﻨ ﺪﻣﺎ ﺗﻜ ﻮن هﻨ ﺎك‬. ‫ ﺧﺎﻧ ﺔ ﻧﺤ ﻮ اﻟﻴﺴ ﺎر‬1 ‫ أو‬0 ‫ ﺑﻤﻘ ﺪار‬8-bit Input Vector ‫ﺷ ﻌﺎع اﻟ ﺪﺧﻞ ذي اﻟﺜﻤ ﺎن ﺧﺎﻧ ﺎت‬ ‫' ) وه ﺬا واﺿ ﺢ ﻓ ﻲ اﻟﺰاوﻳ ﺔ‬0' ‫ ﻳﺠ ﺐ أن ﺗﻌﻄ ﻰ اﻟﻘﻴﻤ ﺔ‬LSB ‫ ( ﻓﺈن اﻟﺨﺎﻧ ﺔ اﻷﻗ ﻞ أهﻤﻴ ﺔ‬shift = 1 ) ‫إزاﺣﺔ ﻓﻌﻠﻴﺔ‬ ‫ ﻓ ﺈن اﻟﺨ ﺮج ﻳﻜ ﻮن ﻣﻄﺎﺑﻘ ًﺎ‬shift = 0 ‫ ﻓ ﻲ ﺣﺎﻟ ﺔ آ ﻮن‬.( (١١-٦) ‫اﻟﺴ ﻔﻠﻴﺔ اﻟﻴﻤﻴﻨﻴ ﺔ ﻣ ﻦ اﻟﻤﺨﻄ ﻂ اﻟﻤﺒ ﻴﻦ ﻓ ﻲ اﻟﺸ ﻜﻞ‬ ‫ ﻣ ﻦ‬outp(i) = inp(i-1) ‫ و‬outp(0) = '0' ‫ ﻓ ﺈن‬shift = 1 ‫ أﻣ ﺎ ﻓ ﻲ ﺣﺎﻟ ﺔ آ ﻮن‬outp = inp : ‫ﻟﻠ ﺪﺧﻞ أي أن‬ . 1 ≤ i ≤ 7 : ‫ ﺿﻤﻦ اﻟﻤﺠﺎل‬i ‫أﺟﻞ ﻗﻴﻢ‬ . FOR / LOOP ‫ آﺎﻣ ﻞ ﻟﺘﻮﺻ ﻴﻒ دارة اﻹزاﺣ ﺔ ه ﺬﻩ وه ﻮ ﻳﺒ ﻴﻦ آﻴﻔﻴ ﺔ اﺳ ﺘﺨﺪام اﻟﺘﻌﻠﻴﻤ ﺔ‬VHDL ‫ﻓﻴﻤﺎ ﻳﻠﻲ آ ﻮد‬ .(١٢-٦) ‫ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻣﺒﻴﻨﺔ ﻓﻲ اﻟﺸﻜﻞ‬ ‫ ﺗﻤﺜ ﻞ‬n ‫ ﻣ ﻊ آ ﻮن‬shift = 0 to n-1 ‫ ) ﺣﻴ ﺚ‬Complete Barrel Shifter ‫ ﻣ ﺰﻳﺢ " ﺑﺎرﻳ ﻞ " آﺎﻣ ﻞ‬: ‫ﻣﻼﺣﻈ ﺔ‬ ‫ ( ﺳ ﻮف ﻳﻌ ﺮض ﻓ ﻲ اﻟﺠﻠﺴ ﺔ اﻷﺧﻴ ﺮة ) اﻟﺠﻠﺴ ﺔ‬The Size of the Input Vector ‫ﻋ ﺪد ﺧﺎﻧ ﺎت ﺷ ﻌﺎع اﻟ ﺪﺧﻞ‬ .( ‫اﻟﻌﺎﺷﺮة‬ 1 ------------------------------------------------------------------------------------------------2 LIBRARY ieee; 3 USE ieee.std_logic_1164.all; 4 ------------------------------------------------------------------------------------------------5 ENTITY barrel IS 6 GENERIC ( n : INTEGER := 8 ); 7 PORT ( inp : IN STD_LOGIC_VECTOR ( n-1 DOWNTO 0 ); 8 shift : IN INTEGER RANGE 0 TO 1; 9 outp : OUT STD_LOGIC_VECTOR ( n-1 DOWNTO 0 )); 10 END barrel; 11 -----------------------------------------------------------------------------------------------١٥


‫‪12 ARCHITECTURE RTL OF barrel IS‬‬ ‫‪13 BEGIN‬‬ ‫‪14‬‬ ‫) ‪PROCESS ( inp, shift‬‬ ‫‪15‬‬ ‫‪BEGIN‬‬ ‫‪16‬‬ ‫‪IF ( shift = 0 ) THEN‬‬ ‫‪17‬‬ ‫;‪outp <= inp‬‬ ‫‪18‬‬ ‫‪ELSE‬‬ ‫‪19‬‬ ‫;'‪outp(0) <= '0‬‬ ‫‪20‬‬ ‫‪FOR i IN 1 TO inp'HIGH LOOP‬‬ ‫‪21‬‬ ‫;)‪outp(i) <= inp(i-1‬‬ ‫‪22‬‬ ‫;‪END LOOP‬‬ ‫‪23‬‬ ‫;‪END IF‬‬ ‫‪24‬‬ ‫;‪END PROCESS‬‬ ‫;‪25 END RTL‬‬ ‫‪26 ------------------------------------------------------------------------------------------------‬‬

‫اﻟﺸﻜﻞ )‪ : (١١-٦‬ﻣﺰﻳﺢ " ﺑﺎرﻳﻞ " ﺑﺴﻴﻂ ﻟﻠﻤﺜﺎل )‪(٩-٦‬‬

‫اﻟﺸﻜﻞ )‪ : (١٢-٦‬ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻟﻠﻤﺜﺎل )‪(٩-٦‬‬ ‫اﻟﻤﺜﺎل )‪ : (١٠-٦‬اﻷﺻﻔﺎر اﻟﺮﺋﻴﺴﻴﺔ ‪Leading Zeros‬‬ ‫اﻟﺘﺼ ﻤﻴﻢ اﻟﺘ ﺎﻟﻲ ﻳﺤﺼ ﻲ ﻋ ﺪد اﻷﺻ ﻔﺎر اﻟﺮﺋﻴﺴ ﻴﺔ ﻓ ﻲ ﺷ ﻌﺎع ﺛﻨ ﺎﺋﻲ ‪ Binary Vector‬ﺑ ﺪءًا ﻣ ﻦ اﻟﺠﻬ ﺔ اﻟﻴﺴ ﺮى‬ ‫ﻟﻠﺸﻌﺎع ‪ .‬اﻟﺤﻞ اﻟﻤﻌﺮوض ﻳﻮﺿﺢ اﺳ ﺘﺨﺪام اﻟﺘﻌﻠﻴﻤﺘ ﻴﻦ ‪ . LOOP / EXIT‬ﻧ ﺬآﺮ هﻨ ﺎ أن اﻟﺘﻌﻠﻴﻤ ﺔ ‪ EXIT‬ﻻ ﺗﻌﻨ ﻲ‬ ‫ﺗﺠﺎوز ﺗﻨﻔﻴﺬ اﻟﻤﺴ ﺢ اﻟﺤ ﺎﻟﻲ ﻟﻠﺤﻠﻘ ﺔ ‪ Current Iteration Of The Loop‬وإﻧﻤ ﺎ ﺗﻌﻨ ﻲ ﺧﺮوﺟ ًﺎ ﻧﻬﺎﺋﻴ ًﺎ ﻣ ﻦ اﻟﺤﻠﻘ ﺔ‬ ‫) أي أﻧ ﻪ ﺣﺘ ﻰ وﻟ ﻮ آ ﺎن ﻋ ﺪاد اﻟﺤﻠﻘ ﺔ ‪ i‬ﻣ ﺎ ﻳ ﺰال ﺿ ﻤﻦ اﻟﻤﺠ ﺎل اﻟﻤﺤ ﺪد ﻟﻠﺤﻠﻘ ﺔ ﻓ ﺈن اﻟﺤﻠﻘ ﺔ ﺳ ﻮف ﺗﻌﺘﺒ ﺮ ﻣﻨﺘﻬﻴ ﺔ‬ ‫اﻟﺘﻨﻔﻴﺬ ( ‪ .‬ﻓﻲ هﺬا اﻟﻤﺜﺎل ‪ ،‬ﺳﻮف ﻳﻨﺘﻬﻲ ﺗﻨﻔﻴﺬ اﻟﺤﻠﻘﺔ ﺑﻤﺠﺮد اﻟﻌﺜ ﻮر ﻋﻠ ﻰ أول ﺧﺎﻧ ﺔ ﻗﻴﻤﺘﻬ ﺎ '‪ '1‬ﺿ ﻤﻦ ﺷ ﻌﺎع اﻟ ﺪﺧﻞ‬ ‫‪ . data‬وﺑﺎﻟﺘﺎﻟﻲ ﻓﺈن هﺬا ﻳﻮاﻓﻖ إﺣﺼﺎء ﻋﺪد اﻷﺻﻔﺎر اﻟﺘﻲ ﺗﺴﺒﻖ اﻟﻮاﺣﺪ اﻷول ‪. The First One‬‬

‫‪١٦‬‬


‫ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة اﻟﺘﻲ ﺗﺆآﺪ ﺻﺤﺔ وﻇﺎﺋﻔﻴﺔ اﻟﺪارة ﻣﺒﻴﻨ ﺔ ﻓ ﻲ اﻟﺸ ﻜﻞ )‪ . (١٣-٦‬ﻓ ﻲ ﺣﺎﻟ ﺔ "‪ data = "00000000‬أي‬ ‫اﻟﻘﻴﻤﺔ اﻟﻌﺸ ﺮﻳﺔ ‪ 0‬ﻓ ﺈن ﺛﻤﺎﻧﻴ ﺔ أﺻ ﻔﺎر ﻗ ﺪ ﺗ ﻢ آﺸ ﻔﻬﺎ ﻓ ﻲ ﺣ ﻴﻦ أﻧ ﻪ ﻋﻨ ﺪﻣﺎ ﺗﻜ ﻮن "‪ data = "00000001‬أي اﻟﻘﻴﻤ ﺔ‬ ‫اﻟﻌﺸﺮﻳﺔ ‪ 1‬ﻓﺈن ﺳﺒﻌﺔ أﺻﻔﺎر ﻗﺪ ﺗﻢ آﺸﻔﻬﺎ وهﻜﺬا دواﻟﻴﻚ ‪.‬‬

‫اﻟﺸﻜﻞ )‪ : (١٣-٦‬ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻟﻠﻤﺜﺎل )‪(١٠-٦‬‬ ‫‪1 ------------------------------------------------------------------------------------------------‬‬‫;‪2 LIBRARY ieee‬‬ ‫;‪3 USE ieee.std_logic_1164.all‬‬ ‫‪4 ------------------------------------------------------------------------------------------------‬‬‫‪5 ENTITY LeadingZeros IS‬‬ ‫‪6‬‬ ‫;)‪PORT ( data : IN STD_LOGIC_VECTOR (7 DOWNTO 0‬‬ ‫‪7‬‬ ‫;)‪zeros : OUT INTEGER RANGE 0 TO 8‬‬ ‫;‪8 END LeadingZeros‬‬ ‫‪9 ------------------------------------------------------------------------------------------------‬‬‫‪10 ARCHITECTURE behavior OF LeadingZeros IS‬‬ ‫‪11 BEGIN‬‬ ‫‪12‬‬ ‫)‪PROCESS (data‬‬ ‫‪13‬‬ ‫;‪VARIABLE count : INTEGER RANGE 0 TO 8‬‬ ‫‪14‬‬ ‫‪BEGIN‬‬ ‫‪15‬‬ ‫;‪count := 0‬‬ ‫‪16‬‬ ‫‪FOR i IN data'RANGE LOOP‬‬ ‫‪17‬‬ ‫‪CASE data(i) IS‬‬ ‫‪18‬‬ ‫;‪WHEN '0' => count := count + 1‬‬ ‫‪19‬‬ ‫;‪WHEN OTHERS => EXIT‬‬ ‫‪20‬‬ ‫;‪END CASE‬‬ ‫‪21‬‬ ‫;‪END LOOP‬‬ ‫‪22‬‬ ‫;‪zeros <= count‬‬ ‫‪23‬‬ ‫;‪END PROCESS‬‬ ‫;‪24 END behavior‬‬ ‫‪25 -----------------------------------------------------------------------------------------------‬‬‫‪ -٧-٦‬اﻟﺘﻌﻠﻴﻤﺔ ‪ CASE‬ﻣﻘﺎﺑﻞ اﻟﺘﻌﻠﻴﻤﺔ ‪CASE Versus IF : IF‬‬ ‫ﺑ ﺎﻟﺮﻏﻢ ﻣ ﻦ أن وﺟ ﻮد ‪ ELSE‬ﻓ ﻲ اﻟﺘﻌﻠﻴﻤ ﺔ ‪ IF / ELSE‬ﻳﻤﻜ ﻦ أن ﻳﺴ ﺒﺐ ﻣ ﻦ ﺣﻴ ﺚ اﻟﻤﺒ ﺪأ ﺗﻮﻟﻴ ﺪ ﻓ ﺎك ﺷ ﻴﻔﺮة ذي‬ ‫أوﻟﻮﻳﺔ ‪ ) Priority Decoder‬اﻷﻣﺮ اﻟﺬي ﻻ ﻳﺤﺪث ﻣﻄﻠﻘًﺎ ﻋﻨﺪ اﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻤ ﺔ ‪ ( CASE‬إﻻ أن ذﻟ ﻚ ﻋﻤﻮﻣ ًﺎ ﻻ‬ ‫ﻳﺘﻢ ﻓﻌﻠﻴًﺎ ‪ .‬ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل ‪ ،‬ﻋﻨﺪﻣﺎ ﻳﺘﻢ اﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻤﺔ ‪ ) IF‬وهﻲ ﺗﻌﻠﻴﻤﺔ ﺗﺘﺎﺑﻌﻴﺔ ﺑﺎﻟﻄﺒﻊ ( ﻟﺘﺼﻤﻴﻢ دارة ﺗﺮآﻴﺒﻴ ﺔ‬ ‫ﻻ ﻣﻦ‬ ‫ﺑﺸﻜﻞ آﻠﻲ ‪ Fully Combinational Circuit‬ﻓ ﺈن ﻧﺎﺧﺒ ًﺎ ‪ Multiplexer‬ﻳﻤﻜ ﻦ أن ﻳُﺴ ﺘﻨﺒَﻂ ﻣ ﻦ اﻟﻜ ﻮد ﺑ ﺪ ً‬ ‫ﻓﺎك اﻟﺸﻴﻔﺮة ذي اﻷوﻟﻮﻳ ﺔ ‪ .‬وﺑﺎﻟﺘ ﺎﻟﻲ ﺑﻌ ﺪ ﻋﻤﻠﻴ ﺔ اﻷﻣﺜﻠ ﺔ ) أو اﻟﺘﺤﺴ ﻴﻦ ( ‪ Optimization‬ﻓ ﺈن اﻟﻨﺘﻴﺠ ﺔ اﻟﻌﺎﻣ ﺔ ﻣ ﻦ‬ ‫أﺟﻞ دارة ﻣﺮآﺒﺔ اﻧﻄﻼﻗًﺎ ﻣﻦ آﻮد ‪ VHDL‬ﻣﻌﺘﻤﺪ ﻋﻠ ﻰ اﻟﺘﻌﻠﻴﻤ ﺔ ‪ IF‬ﻟ ﻦ ﺗﺨﺘﻠ ﻒ ﻋ ﻦ اﻟﻨﺘﻴﺠ ﺔ اﻟﺘ ﻲ ﺳﻨﺤﺼ ﻞ ﻋﻠﻴﻬ ﺎ‬ ‫ﻣﻦ آﻮد ‪ VHDL‬ﻣﻌﺘﻤﺪ ﻋﻠﻰ اﻟﺘﻌﻠﻴﻤﺔ ‪. CASE‬‬ ‫ﻣﺜﺎل ‪Example :‬‬ ‫ﻣﻘﻄﻌﺎ اﻟﻜﻮد اﻟﺘﺎﻟﻴﻴﻦ ﺳﻴﻨﺘﺠﺎن دارة اﻟﻨﺎﺧﺐ اﻟﻔﻴﺰﻳﺎﺋﻴﺔ ﻧﻔﺴﻬﺎ ‪.‬‬ ‫‪١٧‬‬


--------------------------- With IF: ------------------------------IF ( sel = "00" ) THEN x <= a; ELSIF ( sel= "01" ) THEN x <= b; ELSIF (sel = "10" ) THEN x <= c; ELSE x <= d; -------------------------- With CASE: ---------------------------CASE sel IS WHEN "00" => x <= a; WHEN "01" => x <= b; WHEN "10" => x <= c; WHEN OTHERS => x <= d; END CASE; ---------------------------------------------------------------------CASE Versus WHEN : WHEN ‫ ﻣﻘﺎﺑﻞ اﻟﺘﻌﻠﻴﻤﺔ‬CASE ‫ اﻟﺘﻌﻠﻴﻤﺔ‬-٨-٦ ‫ وه ﻲ‬Concurrent ‫ ﻣﺘﺸ ﺎﺑﻬﺘﺎن آﺜﻴ ﺮًا وﻟﻜ ﻦ ﻓ ﻲ ﺣ ﻴﻦ أن إﺣ ﺪاهﻤﺎ ﺗﺰاﻣﻨﻴ ﺔ‬WHEN ‫ و‬CASE ‫إن اﻟﺘﻌﻠﻴﻤﺘ ﻴﻦ‬ ‫ إن أوﺟﻪ اﻟﺘﺸﺎﺑﻪ و أوﺟﻪ اﻻﺧﺘﻼف‬. CASE ‫ وهﻲ اﻟﺘﻌﻠﻴﻤﺔ‬Sequential ‫ ﻓﺈن اﻷﺧﺮى ﺗﺘﺎﺑﻌﻴﺔ‬WHEN ‫اﻟﺘﻌﻠﻴﻤﺔ‬ . (١-٦) ‫اﻟﺮﺋﻴﺴﻴﺔ ﺑﻴﻦ هﺎﺗﻴﻦ اﻟﺘﻌﻠﻴﻤﺘﻴﻦ ﻣﻠﺨﺼﺔ ﻓﻲ اﻟﺠﺪول‬

CASE ‫ و‬WHEN ‫ ﻣﻘﺎرﻧﺔ ﺑﻴﻦ اﻟﺘﻌﻠﻴﻤﺘﻴﻦ‬: (١-٦) ‫اﻟﺠﺪول‬ Example : ‫ﻣﺜﺎل‬ . ‫ﻣﻦ وﺟﻬﺔ ﻧﻈﺮ وﻇﻴﻔﻴﺔ ﻓﺈن ﻣﻘﻄﻌﻲ اﻟﻜﻮد اﻟﺘﺎﻟﻴﻴﻦ ﻣﺘﻜﺎﻓﺌﺎن‬ ------------------------------- With WHEN : ----------------------------WITH sel SELECT x <= a WHEN "000", b WHEN "001", c WHEN "010", UNAFFECTED WHEN OTHERS; -------------------------------- With CASE : -----------------------------CASE sel IS WHEN "000" => x <= a; WHEN "001" => x <= b; WHEN "010" => x <= c; WHEN OTHERS => NULL; END CASE; ------------------------------------------------------------------------------١٨


‫‪ -٩-٦‬اﺳﺘﺨﺪام ﻧﺒﻀﺎت اﻟﺴﺎﻋﺔ ﺑﺸﻜﻞ ﺳﻴﺊ ‪Bad Clocking :‬‬ ‫إن اﻟﻤﺘﺮﺟﻢ ‪ The Compiler‬ﻟﻦ ﻳﻜﻮن ﻋﻤﻮﻣًﺎ ﻗﺎدرًا ﻋﻠﻰ ﺗﺮآﻴﺐ ‪ Synthesize‬ﺷﻴﻔﺮات ﺗﺘﻀﻤﻦ ﻋﻤﻠﻴ ﺎت إﺳ ﻨﺎد‬ ‫إﻟﻰ ﻧﻔﺲ اﻹﺷ ﺎرة ﻋﻨ ﺪ آ ﻼ اﻻﻧﺘﻘ ﺎﻟﻴﻦ ﻹﺷ ﺎرة ﻧﺒﻀ ﺎت اﻟﺴ ﺎﻋﺔ اﻟﻤﺮﺟﻌﻴ ﺔ ‪ ) Reference Clock‬أي ﻋﻨ ﺪ اﻟﺠﺒﻬ ﺔ‬ ‫اﻟﺼ ﺎﻋﺪة وﻋﻨ ﺪ اﻟﺠﺒﻬ ﺔ اﻟﻬﺎﺑﻄ ﺔ ( ‪ .‬إن ه ﺬا ﻳﻜ ﻮن ﺻ ﺤﻴﺤًﺎ ﺑﺸ ﻜﻞ ﺧ ﺎص ﻋﻨ ﺪﻣﺎ ﺗﻜ ﻮن اﻟﺘﻘﻨﻴ ﺔ اﻟﻬ ﺪف ‪Target‬‬ ‫‪ Technology‬ﺗﺘﻀﻤﻦ ﻓﻘﻂ ﻗﻼﺑﺎت أﺣﺎدﻳﺔ اﻟﺠﺒﻬﺔ ) أي ﻗﻼﺑﺎت ﺗﻌﻤﻞ ﻋﻨﺪ إﺣﺪى اﻟﺠﺒﻬﺘﻴﻦ ﻓﻘﻂ ( ‪Single-Edge‬‬ ‫‪ Flip-Flops‬آﻤﺎ ﻓﻲ ﺣﺎﻟﺔ أﺟﻬﺰة ‪ CPLDs‬اﻟﺘﻲ رأﻳﻨﺎهﺎ ﻓﻲ اﻟﺠﻠﺴﺔ اﻷوﻟﻰ ‪ .‬ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ‪ ،‬ﻓﺈن اﻟﻤﺘ ﺮﺟﻢ ﻳﻤﻜ ﻦ‬ ‫أن ﻳﻌ ﺮض رﺳ ﺎﻟ ًﺔ ﻣ ﻦ اﻟﻨ ﻮع ‪ " Signal does not hold value after clock edge " :‬أو رﺳ ﺎﻟﺔ ﻣﺸ ﺎﺑﻬﺔ‬ ‫ﻟﻬﺎ ‪.‬‬ ‫آﻤﺜﺎل ‪ ،‬ﻟﻨﻌﺘﺒﺮ ﺣﺎﻟﺔ ﻋﺪاد ‪ Counter‬اﻟﺬي ﻳﺠﺐ أن ﻳﻌ ﺪ ) ﻳﺰﻳ ﺪ ﻗﻴﻤ ﺔ اﻟﻌ ﺪ ( ﻋﻨ ﺪ آ ﻞ ﺗﻐﻴ ﺮ ﻹﺷ ﺎرة ﻧﺒﻀ ﺔ اﻟﺴ ﺎﻋﺔ‬ ‫‪ ) clock‬أي ﻋﻨﺪ آﻞ ﻣﻦ اﻟﺠﺒﻬﺘﻴﻦ ‪ :‬اﻟﺼﺎﻋﺪة واﻟﻬﺎﺑﻄﺔ ( ‪ .‬إن أﺣﺪ اﻻﺣﺘﻤﺎﻻت ﻳﻤﻜﻦ أن ﻳﻜﻮن اﻟﺘﺎﻟﻲ ‪:‬‬ ‫)‪PROCESS (clk‬‬ ‫‪BEGIN‬‬ ‫‪IF( clk'EVENT AND clk = '1' ) THEN‬‬ ‫;‪counter <= counter + 1‬‬ ‫‪ELSIF( clk'EVENT AND clk = '0' ) THEN‬‬ ‫;‪counter <= counter + 1‬‬ ‫;‪END IF‬‬ ‫‪...‬‬ ‫;‪END PROCESS‬‬ ‫ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ‪ ،‬ﺑﺎﻹﺿﺎﻓﺔ إﻟﻰ اﻟﺮﺳﺎﺋﻞ اﻟﻤﻮﺻﻮﻓﺔ ﺳﺎﺑﻘًﺎ ﻓﺈن اﻟﻤﺘﺮﺟﻢ ﻳﻤﻜ ﻦ أن ﻳﻌﺘﺒ ﺮ أﻳﻀ ًﺎ أن اﻹﺷ ﺎرة ‪counter‬‬ ‫ﻣﻘﺎدة ﺑﺄآﺜﺮ ﻣﻦ ﻣﺼﺪر ‪ . Multiply Driven‬ﻋﻠﻰ أﻳﺔ ﺣ ﺎل ‪ ،‬ﻓ ﺈن ﻋﻤﻠﻴ ﺔ اﻟﺘﺮﺟﻤ ﺔ ﺳ ﺘﺘﻮﻗﻒ وﻟ ﻦ ﻳﻜﻤ ﻞ اﻟﻤﺘ ﺮﺟﻢ‬ ‫ﻋﻤﻠﻪ !!!‬ ‫ﻧﺎﺣﻴﺔ أﺧﺮى هﺎﻣﺔ ﺗﺘﻌﻠﻖ ﺑﺎﻟﺨﺎﺻ ﻴﺔ ‪ ) EVENT‬اﻟﺘ ﻲ رأﻳﻨﺎه ﺎ ﻓ ﻲ اﻟﺠﻠﺴ ﺔ اﻟﺮاﺑﻌ ﺔ ( اﻟﺘ ﻲ ﻳﺠ ﺐ أن ﺗ ﺮﺗﺒﻂ ﺑﺸ ﺮط‬ ‫اﺧﺘﺒﺎري ‪ . Test Condition‬ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل ‪ ،‬اﻟﻜﺘﺎﺑﺔ اﻟﺘﺎﻟﻴ ﺔ ‪ IF ( clk'EVENT AND clk = '1' ) :‬ه ﻲ‬ ‫ﺻ ﺤﻴﺤﺔ وﻟﻜ ﻦ اﻟﻜﺘﺎﺑ ﺔ اﻟﺘﺎﻟﻴ ﺔ ‪ IF ( clk'EVENT ) :‬ﺳ ﻴﻨﺠﻢ ﻋﻨﻬ ﺎ أﺣ ﺪ اﺣﺘﻤ ﺎﻟﻴﻦ ‪ :‬إﻣ ﺎ أن ﻳﻌﺘﻤ ﺪ اﻟﻤﺘ ﺮﺟﻢ ﻗﻴﻤ ﺔ‬ ‫ﺷ ﺮط اﺧﺘﺒ ﺎري ﺗﻠﻘﺎﺋﻴ ﺔ ‪ ) Default Test Value‬ﻋﻠ ﻰ ﺳ ﺒﻴﻞ اﻟﻤﺜ ﺎل ‪ ( " AND clk = '1' " :‬أو أن ﻳﺼ ﺪر‬ ‫رﺳ ﺎﻟ ًﺔ ﻣ ﻦ اﻟﻨ ﻮع " ‪ . " clock not locally stable‬آﻤﺜ ﺎل ﻟﻨﻌﺘﺒ ﺮ ﻣ ﺮة أﺧ ﺮى ﺣﺎﻟ ﺔ اﻟﻌ ﺪاد اﻟ ﺬي ﻳﺠ ﺐ أن ﻳﻌ ﺪ‬ ‫ﻼ‪:‬‬ ‫) ﻳﺰﻳﺪ ﻗﻴﻤﺔ اﻟﻌﺪ ( ﻋﻨﺪ آﻞ ﻣﻦ اﻟﺠﺒﻬﺔ اﻟﺼﺎﻋﺪة واﻟﺠﺒﻬﺔ اﻟﻬﺎﺑﻄﺔ ﻟﻨﺒﻀﺎت اﻟﺴﺎﻋﺔ ‪ . clk‬هﻨﺎ ﻳﻤﻜﻦ أن ﻧﻜﺘﺐ ﻣﺜ ً‬ ‫)‪PROCESS (clk‬‬ ‫‪BEGIN‬‬ ‫‪IF( clk'EVENT ) THEN‬‬ ‫;‪counter := counter + 1‬‬ ‫;‪END IF‬‬ ‫‪...‬‬ ‫;‪END PROCESS‬‬ ‫ﺑﻤﺎ أن اﻟﻤﻌﺎﻟﺠﺔ ‪ PROCESS‬أﻋ ﻼﻩ ﻳﻔﺘ ﺮض ﺑﻬ ﺎ أن ﺗُﻨ ّﻔ ﺬ ﻓ ﻲ آ ﻞ ﻣ ﺮة ﺗﺘﻐﻴ ﺮ ﻓﻴﻬ ﺎ ﻗﻴﻤ ﺔ اﻹﺷ ﺎرة ‪ clk‬ﻓ ﺈن اﻟﻤ ﺮء‬ ‫ﻳﻤﻜﻦ أن ﻳﺘﻮﻗﻊ أن ﻳﻌﺪ اﻟﻌﺪاد ﻋﺪﺗﻴﻦ ﺧﻼل دور واﺣ ﺪ ﻟﻺﺷ ﺎرة ‪ . clk‬ﻟﻜ ﻦ آﻤ ﺎ رأﻳﻨ ﺎ ﻗﺒ ﻞ ﻗﻠﻴ ﻞ ﻓ ﺈن ه ﺬا ﻟ ﻦ ﻳﺤ ﺪث‬ ‫ﻟﻠﺴﺒﺐ اﻟﻤﺬآﻮر أﻋﻼﻩ ‪ .‬إذا آﺎن اﻟﻤﺘﺮﺟﻢ ﻳﻌﺘﻤ ﺪ ﻗﻴﻤ ﺔ اﻓﺘﺮاﺿ ﻴﺔ ﺑﺸ ﻜﻞ ﺗﻠﻘ ﺎﺋﻲ ﻓ ﺈن دارة ﺧﺎﻃﺌ ﺔ ﺳ ﻮف ﻳ ﺘﻢ ﺗﺮآﻴﺒﻬ ﺎ‬ ‫ﻷن ﺟﺒﻬﺔ واﺣﺪة ﻓﻘﻂ ﺳﻮف ﺗﺆﺧﺬ ﺑﻌﻴﻦ اﻻﻋﺘﺒﺎر أﻣﺎ إذا ﻟﻢ ﺗُﻌﺘﻤﺪ أﻳﺔ ﻗﻴﻤ ﺔ اﻓﺘﺮاﺿ ﻴﺔ ) أي ﻟ ﻢ ﺗﻌﺘﻤ ﺪ ﺟﺒﻬ ﺔ ﻣ ﺎ ﻋﻠ ﻰ‬ ‫أﻧﻬﺎ اﻟﺠﺒﻬﺔ اﻟﻔﻌﺎﻟﺔ ( ﻓﺈﻧﻨﺎ ﺳﻨﺤﺼﻞ ﻋﻠﻰ رﺳﺎﻟﺔ ﺧﻄﺄ وﻻ ﻳﻤﻜﻨﻨﺎ ﺗﻮﻗﻊ ﻋﻤﻠﻴﺔ ﺗﺮﺟﻤﺔ ﻧﺎﺟﺤﺔ ‪.‬‬ ‫أﺧﻴﺮًا ‪ ،‬إذا ﻇﻬﺮت إﺷﺎرة ﻣﺎ ﻓﻲ ﻻﺋﺤﺔ اﻟﺤﺴﺎﺳﻴﺔ ‪ Sensitivity List‬وﻟﻜﻨﻬﺎ ﻟﻢ ﺗﻈﻬﺮ ﻓﻲ أي ﻣﻦ ﻋﻤﻠﻴ ﺎت اﻹﺳ ﻨﺎد‬ ‫‪ Assignments‬اﻟﺘﻲ ﺗﺤﻮﻳﻬﺎ اﻟﻤﻌﺎﻟﺠ ﺔ ‪ PROCESS‬ﻓ ﺈن اﻟﻤﺘ ﺮﺟﻢ ﻋﻠ ﻰ اﻷﻏﻠ ﺐ ﺳ ﻮف ﻳﺘﺠﺎهﻠﻬ ﺎ ﺑﺒﺴ ﺎﻃﺔ ‪ .‬ه ﺬا‬ ‫اﻷﻣﺮ ﻳﻤﻜﻦ أن ﻳﻮﺿﺢ ﺑﺎﺳﺘﺨﺪام ﻣﺜﺎل اﻟﻌﺪاد اﻟﺬي ﻳﺠﺐ أن ﻳﻌﺪ ﻋﻨﺪ آﻞ ﻣ ﻦ اﻟﺠﺒﻬﺘ ﻴﻦ اﻟﺼ ﺎﻋﺪة واﻟﻬﺎﺑﻄ ﺔ ﻟﻨﺒﻀ ﺎت‬ ‫اﻟﺴﺎﻋﺔ واﻟﺬي ﺳﺒﻖ ﻟﻨﺎ ﻋﺮض ﻣﺤﺎوﻟﺘﻴﻦ ﻟﺘﻮﺻﻴﻔﻪ دون ﻧﺠﺎح ﺣﺘﻰ اﻵن !!!‬ ‫ﻟﻨﻘﻞ اﻵن أﻧﻨﺎ ﺳﻨﺴﺘﺨﺪم اﻟﻜﻮد اﻟﺘﺎﻟﻲ ‪:‬‬ ‫‪١٩‬‬


‫)‪PROCESS (clk‬‬ ‫‪BEGIN‬‬ ‫;‪counter := counter + 1‬‬ ‫‪...‬‬ ‫;‪END PROCESS‬‬ ‫إن هﺬا اﻟﻜﻮد ﻳﺸﺪد ﻋﻠﻰ اﻟﺮﻏﺒﺔ ﻓﻲ أن ﻳﺘﻢ زﻳﺎدة ﻗﻴﻤﺔ اﻹﺷﺎرة ‪ counter‬ﻋﻨ ﺪﻣﺎ ﻳﻄ ﺮأ ﺣ ﺪث ﻣ ﺎ ﻋﻠ ﻰ اﻹﺷ ﺎرة ‪clk‬‬ ‫) ﺟﺒﻬﺔ ﺻ ﺎﻋﺪة أو ﺟﺒﻬ ﺔ هﺎﺑﻄ ﺔ ( وﻟﻜ ﻦ رﺳ ﺎﻟﺔ ﻣ ﻦ اﻟﻨ ﻮع ‪ " Ignored Unnecessary Pin clk " :‬ﻳﻤﻜ ﻦ أن‬ ‫ﺗﻜﻮن هﻲ اﻟﻨﺘﻴﺠﺔ ﻣﻊ ﻋﺪم اﻟﺤﺼﻮل ﻋﻠﻰ اﻟﻨﺘﻴﺠﺔ اﻟﻤﻄﻠﻮﺑﺔ ‪.‬‬ ‫ﻣﺜﺎل ‪Example :‬‬ ‫ﻋﻠ ﻰ ﻋﻜ ﺲ اﻟﺤ ﺎﻻت اﻟﻤﻮﺻ ﻮﻓﺔ أﻋ ﻼﻩ ﻓ ﺈن اﻟﻜ ﻮد اﻟﺘ ﺎﻟﻲ واﻟ ﺬي ﻳﺘﻀ ﻤﻦ ﻣﻌ ﺎﻟﺠﺘﻴﻦ اﺛﻨﺘ ﻴﻦ ﺳ ﻮف ﻳ ﺘﻢ ﺗﺮآﻴﺒ ﻪ‬ ‫) ﺗﺮﺟﻤﺘﻪ ( ﺑﺸﻜﻞ ﺻﺤﻴﺢ ﻣﻦ ﻗﺒﻞ أي ﻣﺘﺮﺟﻢ ‪ .‬ﻋﻠﻰ آﻞ ﺣﺎل ‪ ،‬ﻧﻨ ﻮﻩ هﻨ ﺎ إﻟ ﻰ أﻧﻨ ﺎ اﺳ ﺘﺨﺪﻣﻨﺎ إﺷ ﺎرة ﻣﺨﺘﻠﻔ ﺔ ﻓ ﻲ آ ﻞ‬ ‫ﻣﻌﺎﻟﺠﺔ ﻣﻦ اﻟﻤﻌﺎﻟﺠﺘﻴﻦ ) اﻹﺷﺎرة ‪ x‬ﻓﻲ اﻟﻤﻌﺎﻟﺠﺔ اﻷوﻟﻰ واﻹﺷﺎرة ‪ y‬ﻓﻲ اﻟﻤﻌﺎﻟﺠﺔ اﻟﺜﺎﻧﻴﺔ ( ‪.‬‬ ‫‪------------------------------------------------‬‬‫)‪PROCESS (clk‬‬ ‫‪BEGIN‬‬ ‫‪IF( clk'EVENT AND clk = '1' ) THEN‬‬ ‫;‪x <= d‬‬ ‫;‪END IF‬‬ ‫;‪END PROCESS‬‬ ‫‪------------------------------------------------‬‬‫)‪PROCESS (clk‬‬ ‫‪BEGIN‬‬ ‫‪IF( clk'EVENT AND clk = '0' ) THEN‬‬ ‫;‪y <= d‬‬ ‫;‪END IF‬‬ ‫;‪END PROCESS‬‬ ‫‪------------------------------------------------‬‬‫اﻵن ‪ ،‬ﻳﻔﺘﺮض أن اﻟﻄﺎﻟ ﺐ ﻳﻌﻠ ﻢ ﻣ ﺎ ﻳﻤﻜ ﻦ أن ﻳﻘ ﻮم ﺑ ﻪ وﻣ ﺎ ﻻ ﻳﻨﺒﻐ ﻲ أن ﻳﻔﻌﻠ ﻪ وﺑﺎﻟﺘ ﺎﻟﻲ ﻳﻤﻜﻨ ﻪ ﻣﺤﺎوﻟ ﺔ ﺣ ﻞ اﻟﻤﺴ ﺄﻟﺔ‬ ‫اﻟﺘﺎﻟﻴﺔ ‪:‬‬ ‫ﻋﺪاد أﺣﺪاث ‪Events Counter :‬‬ ‫ﺻ ﻤﻢ دارة ﻗ ﺎدرة ﻋﻠ ﻰ إﺣﺼ ﺎء ﻋ ﺪد اﻷﺣ ﺪاث اﻟﺘ ﻲ ﺗﻄ ﺮأ ﻋﻠ ﻰ ﻧﺒﻀ ﺎت اﻟﺴ ﺎﻋﺔ ) اﻟﺠﺒﻬ ﺎت اﻟﺼ ﺎﻋﺪة واﻟﺠﺒﻬ ﺎت‬ ‫اﻟﻬﺎﺑﻄﺔ ( آﻤﺎ هﻮ ﻣﻮﺿﺢ ﻓﻲ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪:‬‬

‫اﻟﻤﺜﺎل )‪ : (١١-٦‬ذاآﺮة وﺻﻮل ﻋﺸﻮاﺋﻲ ) ذاآﺮة ﻣﻌﻄﻴﺎت أو ذاآﺮة ﻗﺮاءة وآﺘﺎﺑﺔ ( ‪RAM‬‬ ‫ﻓﻴﻤ ﺎ ﻳﻠ ﻲ ﻣﺜ ﺎل ﺁﺧ ﺮ ﺗ ﻢ ﻓﻴ ﻪ اﺳ ﺘﺨﺪام اﻟﻜ ﻮد اﻟﺘﺘ ﺎﺑﻌﻲ وﺧﺎﺻ ًﺔ اﻟﺘﻌﻠﻴﻤ ﺔ ‪ . IF‬ﺳ ﻨﻌﺮض ﻓ ﻲ ه ﺬا اﻟﻤﺜ ﺎل ﺗﻨﺠﻴ ﺰ‬ ‫‪ Implementation‬ﻟﺬاآﺮة وﺻﻮل ﻋﺸﻮاﺋﻲ ‪ . ( Random Access Memory ) RAM‬آﻤﺎ هﻮ واﺿ ﺢ ﻓ ﻲ‬ ‫اﻟﺸ ﻜﻞ )‪-١٤-٦‬أ( ﻓ ﺈن اﻟ ﺪارة ﺗﻤﺘﻠ ﻚ ﻣﻤ ﺮ ﻣﻌﻄﻴ ﺎت اﻟ ﺪﺧﻞ ‪ Data Input Bus‬وه ﻮ اﻟﻤﻨﻔ ﺬ ‪ data_in‬آﻤ ﺎ ﺗﻤﺘﻠ ﻚ‬ ‫ﻣﻤﺮ ﻣﻌﻄﻴ ﺎت اﻟﺨ ﺮج ‪ Data Output Bus‬وه ﻮ اﻟﻤﻨﻔ ﺬ ‪ data_out‬وه ﻲ ﺗﻤﺘﻠ ﻚ أﻳﻀ ًﺎ ﻣﻤ ﺮ ﻋﻨﻮﻧ ﺔ ‪Address‬‬ ‫‪ Bus‬وهﻮ اﻟﻤﻨﻔﺬ ‪ addr‬وأﺧﻴﺮًا ﻓﺈن اﻟﺪارة ﺗﻤﺘﻠﻚ ﻣ ﺪﺧﻞ ﻧﺒﻀ ﺎت اﻟﺴ ﺎﻋﺔ ‪ Clock‬وه ﻮ اﻟﻤﻨﻔ ﺬ ‪ clk‬وﻣ ﺪﺧﻞ ﺗﻤﻜ ﻴﻦ‬ ‫اﻟﻜﺘﺎﺑﺔ ‪ Write Enable‬وهﻮ اﻟﻤﻨﻔﺬ ‪. wr_ena‬‬ ‫ﻋﻨﺪ ﺗﻔﻌﻴ ﻞ اﻟﻤ ﺪﺧﻞ ‪ wr_ena‬ﻓﺈﻧ ﻪ وﻋﻨ ﺪ اﻟﺠﺒﻬ ﺔ اﻟﺼ ﺎﻋﺪة اﻟﺘﺎﻟﻴ ﺔ ﻹﺷ ﺎرة ﻧﺒﻀ ﺎت اﻟﺴ ﺎﻋﺔ ‪ clk‬ﻳﻠ ﺰم ﺗﺨ ﺰﻳﻦ ﻗﻴﻤ ﺔ‬ ‫اﻟﺸ ﻌﺎع اﻟﻤﻄﺒ ﻖ ﻋﻠ ﻰ اﻟﻤ ﺪﺧﻞ ‪ data_in‬ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬاآﺮي اﻟﻤﺤ ﺪد ﻣ ﻦ ﺧ ﻼل ﻣﻤ ﺮ اﻟﻌﻨﻮﻧ ﺔ ‪ . addr‬ﻣ ﻦ اﻟﺠﻬ ﺔ‬ ‫‪٢٠‬‬


‫اﻷﺧ ﺮى ﻓ ﺈن اﻟﻤﺨ ﺮج ‪ data_out‬ﻳﺠ ﺐ أن ﻳﻌ ﺮض ﺑﺸ ﻜﻞ داﺋ ﻢ ) ﺑﺎﺳ ﺘﻤﺮار ( اﻟﻤﻌﻄﻴ ﺎت اﻟﻤﺨﺰﻧ ﺔ ﻓ ﻲ اﻟﻤﻮﻗ ﻊ‬ ‫اﻟﺬاآﺮي اﻟﻤﻌﻨﻮن ﺑﻮاﺳﻄﺔ ﻣﻤﺮ اﻟﻌﻨﻮﻧﺔ ‪. addr‬‬

‫اﻟﺸﻜﻞ )‪-١٤-٦‬أ( ‪ :‬دارة اﻟﺬاآﺮة ﻣﻦ ﻧﻮع ‪ RAM‬ﻟﻠﻤﺜﺎل )‪(١١-٦‬‬ ‫ﻣ ﻦ وﺟﻬ ﺔ ﻧﻈ ﺮ " ﻣﺴ ﺠﻠﻴﺔ " ‪ Register Point-of-View‬ﻓ ﺈن اﻟ ﺪارة ﻳﻤﻜ ﻦ اﺧﺘﺼ ﺎرهﺎ آﻤ ﺎ ه ﻮ ﻣﻮﺿ ﺢ ﻓ ﻲ‬ ‫اﻟﺸﻜﻞ )‪-١٤-٦‬ب( ‪.‬‬

‫اﻟﺸﻜﻞ )‪-١٤-٦‬ب( ‪ :‬ﺧﻠﻴﺔ ذاآﺮﻳﺔ ﺑﺤﺠﻢ ﺧﺎﻧﺔ وﺣﻴﺪة ﻣﻦ ﻣﺜﺎل اﻟﺬاآﺮة ‪RAM‬‬ ‫ﻻ إﻟﻰ ﻣﺪﺧﻠﻪ ﻓﻲ ﺣﻴﻦ ﻳﻜﻮن اﻟﻄ ﺮف‬ ‫ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﻟﻤﺪﺧﻞ ‪ wr_ena‬ﺑﺤﺎﻟﺔ ‪ Low‬ﻓﺈن ﺧﺮج اﻟﻘﻼب ‪ q‬ﻳﻜﻮن ﻣﻮﺻﻮ ً‬ ‫‪ d‬ﻣﻔﺘﻮﺣًﺎ وﺑﺎﻟﺘﺎﻟﻲ ﻓﻠﻦ ﺗُﻜﺘ ﺐ أﻳ ﺔ ﻣﻌﻄﻴ ﺎت ﺟﺪﻳ ﺪة ﻓ ﻲ اﻟ ﺬاآﺮة ‪ .‬ﺑﺎﻟﻤﻘﺎﺑ ﻞ ‪ ،‬ﻋﻨ ﺪﻣﺎ ﻳﺼ ﺒﺢ اﻟﻤ ﺪﺧﻞ ‪ wr_ena‬ﺑﺤﺎﻟ ﺔ‬ ‫‪ High‬ﻓ ﺈن اﻟﻄ ﺮف ‪ d‬ﺳﻴﻮﺻ ﻞ إﻟ ﻰ ﻣ ﺪﺧﻞ اﻟﻘ ﻼب ) اﻟﻤﺴ ﺠﻞ ﻓ ﻲ اﻟﺤﺎﻟ ﺔ اﻟﻌﺎﻣ ﺔ ( وﺑﺎﻟﺘ ﺎﻟﻲ ﻓﺈﻧ ﻪ وﻋﻨ ﺪ اﻟﺠﺒﻬ ﺔ‬ ‫اﻟﺼﺎﻋﺪة اﻟﺘﺎﻟﻴﺔ ﻟﻨﺒﻀﺔ اﻟﺴﺎﻋﺔ ‪ clk‬ﺳﺘﻜﺘﺐ اﻟﻘﻴﻤﺔ اﻟﺠﺪﻳﺪة ﻟﻠﻤﺪﺧﻞ ‪ d‬ﻓﻲ اﻟﻤﺴﺠﻞ ‪.‬‬ ‫ﻓﻴﻤﺎ ﻳﻠﻲ ﺷﻴﻔﺮة ‪ VHDL‬ﺗﻨﺠ ﺰ دارة اﻟﺸ ﻜﻞ )‪ . (١٤-٦‬اﻟﺴ ﻌﺔ اﻟﻤﺨﺘ ﺎرة ﻟﻬ ﺬﻩ اﻟ ﺬاآﺮة ‪ RAM‬ه ﻲ ﻋﺒ ﺎرة ﻋ ﻦ ‪16‬‬ ‫آﻠﻤ ﺔ وآ ﻞ آﻠﻤ ﺔ ه ﻲ ﺑﻌ ﺮض ‪ 8‬ﺧﺎﻧ ﺎت ‪ .‬ﻧﻨ ﻮﻩ هﻨ ﺎ إﻟ ﻰ ﺿ ﺮورة ﻣﻼﺣﻈ ﺔ أن اﻟﻜ ﻮد ه ﻮ ﻋﻤ ﻮﻣﻲ ﺑﺸ ﻜﻞ آﺎﻣ ﻞ‬ ‫‪. Totally Generic‬‬ ‫‪1 ------------------------------------------------------------------------------------------------‬‬‫;‪2 LIBRARY ieee‬‬ ‫;‪3 USE ieee.std_logic_1164.all‬‬ ‫‪4 ------------------------------------------------------------------------------------------------‬‬‫‪5 ENTITY ram IS‬‬ ‫;‪6 GENERIC ( bits : INTEGER := 8‬‬ ‫‪-- # of bits per word‬‬ ‫‪7‬‬ ‫;) ‪words : INTEGER := 16‬‬ ‫‪-- # of words in the memory‬‬ ‫‪8‬‬ ‫;‪PORT ( wr_ena, clk : IN STD_LOGIC‬‬ ‫‪9‬‬ ‫;‪addr : IN INTEGER RANGE 0 TO words-1‬‬ ‫‪10‬‬ ‫;) ‪data_in : IN STD_LOGIC_VECTOR ( bits-1 DOWNTO 0‬‬ ‫‪11‬‬ ‫;)) ‪data_out : OUT STD_LOGIC_VECTOR ( bits-1 DOWNTO 0‬‬ ‫;‪12 END ram‬‬ ‫‪13 -----------------------------------------------------------------------------------------------‬‬‫‪٢١‬‬


‫‪14 ARCHITECTURE ram OF ram IS‬‬ ‫‪15‬‬ ‫‪TYPE vector_array IS ARRAY ( 0 TO words-1 ) OF‬‬ ‫‪16‬‬ ‫;) ‪STD_LOGIC_VECTOR ( bits-1 DOWNTO 0‬‬ ‫‪17‬‬ ‫;‪SIGNAL memory : vector_array‬‬ ‫‪18 BEGIN‬‬ ‫‪19‬‬ ‫) ‪PROCESS ( clk, wr_ena‬‬ ‫‪20‬‬ ‫‪BEGIN‬‬ ‫‪21‬‬ ‫‪IF ( wr_ena='1' ) THEN‬‬ ‫‪22‬‬ ‫‪IF ( clk'EVENT AND clk = '1' ) THEN‬‬ ‫‪23‬‬ ‫;‪memory(addr) <= data_in‬‬ ‫‪24‬‬ ‫;‪END IF‬‬ ‫‪25‬‬ ‫;‪END IF‬‬ ‫‪26‬‬ ‫;‪END PROCESS‬‬ ‫‪27‬‬ ‫;) ‪data_out <= memory( addr‬‬ ‫;‪28 END ram‬‬ ‫‪29 -----------------------------------------------------------------------------------------------‬‬‫ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻣﻦ اﻟﺪارة اﻟﻤﺮآﺒﺔ ﺑﻮاﺳﻄﺔ اﻟﻜﻮد اﻟﻤﻌﺮوض أﻋﻼﻩ ﻣﺒﻴﻨﺔ ﻓﻲ اﻟﺸﻜﻞ )‪ (١٥-٦‬اﻟﺘﺎﻟﻲ ‪:‬‬

‫اﻟﺸﻜﻞ )‪ : (١٥-٦‬ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻟﻠﻤﺜﺎل )‪(١١-٦‬‬ ‫‪ -١٠-٦‬اﺳﺘﺨﺪام اﻟﻜﻮد اﻟﺘﺘﺎﺑﻌﻲ ﻟﺘﺼﻤﻴﻢ اﻟﺪارات اﻟﺘﺮآﻴﺒﻴﺔ ‪:‬‬ ‫‪Using Sequential Code To Design Combinational Circuits‬‬ ‫رأﻳﻨ ﺎ ﺳ ﺎﺑﻘًﺎ أﻧ ﻪ ﻳﻤﻜ ﻦ اﺳ ﺘﺨﺪام اﻟﻜ ﻮد اﻟﺘﺘ ﺎﺑﻌﻲ ﻟﺘﻨﺠﻴ ﺰ ‪ To Implement‬آ ﻞ ﻣ ﻦ اﻟ ﺪارات اﻟﺘﺘﺎﺑﻌﻴ ﺔ و اﻟ ﺪارات‬ ‫اﻟﺘﺮآﻴﺒﻴﺔ ‪ .‬ﻓﻲ اﻟﺤﺎﻟﺔ اﻷوﻟ ﻰ ‪ ،‬ﻳﻠ ﺰم اﺳ ﺘﺨﺪام ﻣﺴ ﺠﻼت ‪ Registers‬وﺑﺎﻟﺘ ﺎﻟﻲ ﻓﺈﻧﻬ ﺎ ﺳ ﻮف ﺗُﻮّﻟ ﺪ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺘ ﺮﺟﻢ‬ ‫‪ . Inferred By The Compiler‬ﺑﺎﻟﻤﻘﺎﺑ ﻞ ﻓ ﺈن ه ﺬا ﻳﺠ ﺐ أﻻ ﻳﺤ ﺪث ﻓ ﻲ اﻟﺤﺎﻟ ﺔ اﻷﺧ ﺮى ) ﺣﺎﻟ ﺔ اﻟ ﺪارات‬ ‫اﻟﺘﺮآﻴﺒﻴ ﺔ ( ‪ .‬ﺑﺎﻹﺿ ﺎﻓﺔ إﻟ ﻰ ذﻟ ﻚ ‪ ،‬إذا آ ﺎن اﻟﻜ ﻮد ﻣﻌ ﺪًا ﻣ ﻦ أﺟ ﻞ دارة ﺗﺮآﻴﺒﻴ ﺔ ﻓ ﺈن ﺟ ﺪول اﻟﺤﻘﻴﻘ ﺔ اﻟﻜﺎﻣ ﻞ‬ ‫‪ Complete Truth Table‬ﻳﺠﺐ أن ﻳﻜﻮن ﻣﺤﺪدًا ﺑﺸﻜﻞ واﺿﺢ ﻓﻲ اﻟﻜﻮد ‪.‬‬ ‫ﻣﻦ أﺟﻞ ﺿﻤﺎن اﻟﻘﻴﺪ اﻟﻤﺬآﻮر أﻋﻼﻩ ﻓﺈن اﻟﻘﺎﻋﺪﺗﻴﻦ اﻟﺘﺎﻟﻴﺘﻴﻦ ﻳﺠﺐ أن ﺗﺆﺧﺬا ﺑﻌﻴﻦ اﻻﻋﺘﺒﺎر ‪:‬‬ ‫اﻟﻘﺎﻋ ﺪة اﻷوﻟ ﻰ ‪ :‬ﻳﺠ ﺐ اﻟﺘﺄآ ﺪ ﻣ ﻦ أن آﺎﻓ ﺔ إﺷ ﺎرات اﻟ ﺪﺧﻞ اﻟﻤﺴ ﺘﺨﺪﻣﺔ ) اﻟﻤﻘ ﺮوءة ( ﺿ ﻤﻦ اﻟﻤﻌﺎﻟﺠ ﺔ ‪Process‬‬ ‫ﺗﻈﻬﺮ ﻓﻲ ﻻﺋﺤﺔ اﻟﺤﺴﺎﺳﻴﺔ ﻟﻬﺬﻩ اﻟﻤﻌﺎﻟﺠﺔ ‪.‬‬ ‫اﻟﻘﺎﻋ ﺪة اﻟﺜﺎﻧﻴ ﺔ ‪ :‬ﻳﺠ ﺐ اﻟﺘﺄآ ﺪ ﻣ ﻦ أن آﺎﻓ ﺔ اﻻﺣﺘﻤ ﺎﻻت ) اﻟﺘﺮآﻴﺒ ﺎت ( ‪ All Combinations‬ﻹﺷ ﺎرات اﻟ ﺪﺧﻞ ‪/‬‬ ‫اﻟﺨﺮج ﻣﻀﻤﻨﺔ ﻓﻲ اﻟﻜﻮد أي ﻳﺠ ﺐ اﻟﺘﺄآ ﺪ أﻧ ﻪ وﻣ ﻦ ﺧ ﻼل اﻟﻨﻈ ﺮ إﻟ ﻰ اﻟﻜ ﻮد ﻓﺈﻧ ﻪ ﺑﺎﻹﻣﻜ ﺎن اﺳ ﺘﻨﺘﺎج ﺟ ﺪول اﻟﺤﻘﻴﻘ ﺔ‬ ‫اﻟﻜﺎﻣﻞ ) ﻓﻲ اﻟﻮاﻗﻊ إن هﺬا اﻟﺸﺮط ﻳﺠﺐ أن ﻳﻜﻮن ﻣﺤﻘﻘًﺎ ﻓ ﻲ آﻠﺘ ﺎ اﻟﺤ ﺎﻟﺘﻴﻦ ‪ :‬اﺳ ﺘﺨﺪام آ ﻮد ﺗﺘ ﺎﺑﻌﻲ أو اﺳ ﺘﺨﺪام آ ﻮد‬ ‫ﺗﺰاﻣﻨﻲ (‪.‬‬ ‫إن ﻋﺪم ﺗﺤﻘﻖ اﻟﻘﺎﻋﺪة اﻷوﻟﻰ ﺳ ﻮف ﻳ ﺪﻓﻊ اﻟﻤﺘ ﺮﺟﻢ ﻋﻤﻮﻣ ًﺎ وﺑﻜ ﻞ ﺑﺴ ﺎﻃﺔ إﻟ ﻰ إﺻ ﺪار ﺗﺤ ﺬﻳﺮ ‪ Warning‬ﻣﻔ ﺎدﻩ أن‬ ‫إﺷﺎرة دﺧﻞ ﻣﻌﻴﻨﺔ ﻟﻢ ﻳﺘﻢ ﺗﻀﻤﻴﻨﻬﺎ ﻓﻲ ﻻﺋﺤﺔ اﻟﺤﺴﺎﺳﻴﺔ وﺑﺎﻟﺘﺎﻟﻲ ﺳﻮف ﻳﺘﺎﺑﻊ اﻟﻤﺘﺮﺟﻢ اﻟﻌﻤﻞ آﻤﺎ ﻟﻮ أن اﻹﺷﺎرة ﻗﺪ ﺗﻢ‬ ‫ﺗﻀﻤﻴﻨﻬﺎ ﻓﻲ ﻻﺋﺤﺔ اﻟﺤﺴﺎﺳﻴﺔ ‪ .‬ﺑﺎﻟﺮﻏﻢ ﻣ ﻦ أﻧ ﻪ ﻟ ﻦ ﺗﺤ ﺪث أﺿ ﺮار ﻣ ﺆﺛﺮة ﻓ ﻲ اﻟﺘﺼ ﻤﻴﻢ ﻓ ﻲ ه ﺬﻩ اﻟﺤﺎﻟ ﺔ إﻻ أن أﺧ ﺬ‬ ‫اﻟﻘﺎﻋﺪة اﻷوﻟﻰ ﺑﻌﻴﻦ اﻻﻋﺘﺒﺎر دوﻣًﺎ ﻳﻌﺘﺒﺮ ﻣﻦ اﻟﻌﺎدات اﻟﺘﺼﻤﻴﻤﻴﺔ اﻟﺠﻴﺪة ‪.‬‬

‫‪٢٢‬‬


‫ﻓﻴﻤ ﺎ ﻳﺨ ﺺ اﻟﻘﺎﻋ ﺪة اﻟﺜﺎﻧﻴ ﺔ ﺑﺎﻟﻤﻘﺎﺑ ﻞ ﻓ ﺈن اﻟﻨﺘ ﺎﺋﺞ ﻳﻤﻜ ﻦ أن ﺗﻜ ﻮن أآﺜ ﺮ ﺟﺪﻳ ﺔ وﺧﻄ ﻮرة ﻷن ﺗﺤﺪﻳ ﺪات ﻏﻴ ﺮ آﺎﻣﻠ ﺔ‬ ‫ﻹﺷﺎرات اﻟﺨﺮج ‪ Incomplete Specifications Of The Output Signals‬ﻳﻤﻜ ﻦ أن ﺗ ﺪﻓﻊ اﻟﻤﺮآ ﺐ ‪The‬‬ ‫‪ Synthesizer‬ﻟﺘﻮﻟﻴﺪ ﻣﺎﺳﻜﺎت أو ﻗﻼﺑﺎت ‪ Latches Or Flip-Flops‬ﻟﻤﺴﻚ اﻟﻘﻴﻢ اﻟﺴﺎﺑﻘﺔ ﻹﺷﺎرات اﻟﺨ ﺮج‪ .‬ه ﺬا‬ ‫اﻷﻣﺮ ﻣﺒﻴﻦ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪.‬‬ ‫اﻟﻤﺜﺎل )‪ (١٢-٦‬ﺗﺼﻤﻴﻢ دارة ﺗﺮآﻴﺒﻴﺔ ﺑﺸﻜﻞ ﺳﻴﺊ ‪Bad Combinational Design :‬‬ ‫ﻟﻨﻌﺘﺒ ﺮ اﻟ ﺪارة اﻟﻤﻮﺿ ﺤﺔ ﻓ ﻲ اﻟﺸ ﻜﻞ )‪-١٦-٦‬أ( واﻟﺘ ﻲ ﻣ ﻦ أﺟﻠﻬ ﺎ ﺗﻌﻄ ﻰ اﻟﻤﻮاﺻ ﻔﺎت اﻟﺘﺎﻟﻴ ﺔ ‪ :‬اﻹﺷ ﺎرة ‪ x‬ﻳﺠ ﺐ أن‬ ‫ﺗﺴﻠﻚ ﺳﻠﻮك ﻣﺨﺮج ﻧﺎﺧﺐ ‪ Multiplexer‬أي أﻧﻬﺎ ﻳﺠﺐ أن ﺗﺴﺎوي ﻗﻴﻤ ﺔ اﻟﻤ ﺪﺧﻞ اﻟﻤﻨﺘﺨ ﺐ ﺑﻮاﺳ ﻄﺔ إﺷ ﺎرة اﻟ ﺪﺧﻞ‬ ‫‪ . sel‬ﻣﻦ اﻟﺠﻬﺔ اﻷﺧﺮى ‪ ،‬ﻓﺈن إﺷﺎرة اﻟﺨﺮج ‪ y‬ﻳﺠﺐ أن ﺗﺴﺎوي اﻟﻘﻴﻤﺔ '‪ '0‬ﻋﻨﺪﻣﺎ ﺗﻜﻮن ﻗﻴﻤ ﺔ إﺷ ﺎرة اﻟ ﺪﺧﻞ = ‪sel‬‬ ‫"‪ "00‬أو ﻳﺠﺐ أن ﺗﺴﺎوي اﻟﻘﻴﻤﺔ '‪ '1‬ﻋﻨﺪﻣﺎ ﺗﻜﻮن "‪ . sel = "01‬هﺬﻩ اﻟﻤﻮاﺻ ﻔﺎت ‪ Specifications‬ﻣﻠﺨﺼ ﺔ ﻓ ﻲ‬ ‫ﺟﺪول اﻟﺤﻘﻴﻘﺔ اﻟﻤﺒﻴﻦ ﻓﻲ اﻟﺸﻜﻞ )‪-١٦-٦‬ب(‪.‬‬

‫اﻟﺸﻜﻞ )‪ : (١٦-٦‬دارة اﻟﻤﺜﺎل )‪) : (١٢-٦‬أ( ﻣﺨﻄﻂ اﻟﻤﺴﺘﻮى اﻷﻋﻠﻰ )ب( اﻟﻤﻮاﺻﻔﺎت اﻟﻤﺰودة )ج( ﺟﺪول‬ ‫اﻟﺤﻘﻴﻘﺔ اﻟﻤﻨﺠﺰ )د( اﻟﻤﻨﻬﺞ اﻟﺘﺼﻤﻴﻤﻲ اﻟﺼﺤﻴﺢ‬ ‫ﻧﻼﺣﻆ هﻨﺎ أن اﻟﺪارة هﻲ دارة ﺗﺮآﻴﺒﻴﺔ وﻟﻜﻦ اﻟﻤﻮاﺻ ﻔﺎت ) أو اﻟﺨﺼ ﺎﺋﺺ ( ‪ Specifications‬اﻟﻤ ﺰودة ﻣ ﻦ أﺟ ﻞ‬ ‫إﺷﺎرة اﻟﺨﺮج ‪ y‬هﻲ ﻏﻴﺮ آﺎﻣﻠﺔ آﻤﺎ هﻮ واﺿﺢ ﻓﻲ اﻟﺸﻜﻞ )‪-١٦-٦‬ب( ‪ .‬ﺑﺎﺳﺘﺨﺪام هﺬﻩ اﻟﻤﻮاﺻﻔﺎت ﻓﻘ ﻂ ﻓ ﺈن اﻟﻜ ﻮد‬ ‫ﻳﻤﻜﻦ أن ﻳﻜﺘﺐ آﻤﺎ ﻳﻠﻲ ‪:‬‬ ‫‪1 ------------------------------------------------------------------------------------------------‬‬‫;‪2 LIBRARY ieee‬‬ ‫;‪3 USE ieee.std_logic_1164.all‬‬ ‫‪4 ------------------------------------------------------------------------------------------------‬‬‫‪5 ENTITY example IS‬‬ ‫‪6‬‬ ‫;‪PORT ( a, b, c, d : IN STD_LOGIC‬‬ ‫‪7‬‬ ‫;) ‪sel : IN STD_LOGIC_VECTOR( 1 DOWNTO 0‬‬ ‫‪8‬‬ ‫;) ‪x, y : OUT STD_LOGIC‬‬ ‫;‪9 END example‬‬ ‫‪10 -----------------------------------------------------------------------------------------------‬‬‫‪11 ARCHITECTURE example OF example IS‬‬ ‫‪12 BEGIN‬‬ ‫‪13‬‬ ‫) ‪PROCESS ( a, b, c, d, sel‬‬ ‫‪14‬‬ ‫‪BEGIN‬‬ ‫‪15‬‬ ‫‪IF ( sel = "00" ) THEN‬‬ ‫‪16‬‬ ‫;‪x <= a‬‬ ‫‪17‬‬ ‫;'‪y <= '0‬‬ ‫‪18‬‬ ‫‪ELSIF ( sel = "01" ) THEN‬‬ ‫‪٢٣‬‬


‫‪19‬‬ ‫;‪x <= b‬‬ ‫‪20‬‬ ‫;'‪y <= '1‬‬ ‫‪21‬‬ ‫‪ELSIF ( sel = "10" ) THEN‬‬ ‫‪22‬‬ ‫;‪x <= c‬‬ ‫‪23‬‬ ‫‪ELSE‬‬ ‫‪24‬‬ ‫;‪x <= d‬‬ ‫‪25‬‬ ‫;‪END IF‬‬ ‫‪26‬‬ ‫;‪END PROCESS‬‬ ‫;‪27 END example‬‬ ‫‪28 -----------------------------------------------------------------------------------------------‬‬‫ﺑﻌﺪ ﺗﺮﺟﻤﺔ هﺬا اﻟﻜﻮد ﻓﺈن ﻣﻠﻒ ﺗﻘﺮﻳﺮ اﻟﻤﺘﺮﺟﻢ ‪ Compiler Report File‬ﻳﺒﻴﻦ أﻧﻪ ﻟ ﻢ ﺗﺴ ﺘﺨﺪم أﻳ ﺔ ﻗﻼﺑ ﺎت ) آﻤ ﺎ‬ ‫هﻮ ﻣﺘﻮﻗﻊ ( ‪ .‬ﻟﻜﻦ وﻋﻨﺪ اﻟﺘﺪﻗﻴﻖ ﻓﻲ ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة اﻟﻤﺒﻴﻨﺔ ﻓﻲ اﻟﺸﻜﻞ )‪ (١٧-٦‬ﻓﺈﻧﻨ ﺎ ﻧﻼﺣ ﻆ ﺷ ﻴﺌًﺎ ﻏﺮﻳﺒ ًﺎ ﺑﺨﺼ ﻮص‬ ‫إﺷﺎرة اﻟﺨﺮج ‪. y‬‬

‫اﻟﺸﻜﻞ )‪ : (١٧-٦‬ﻧﺘﺎﺋﺞ اﻟﻤﺤﺎآﺎة ﻟﻠﻤﺜﺎل )‪(١٢-٦‬‬ ‫ﻟﻨﺪﻗﻖ ﻓﻲ ذﻟﻚ ‪ :‬ﻣﻦ أﺟﻞ ﻧﻔﺲ اﻟﻘﻴﻤﺔ ﻹﺷﺎرة اﻟﺪﺧﻞ ‪ ( sel = 3 = "11" ) sel‬ﻓﺈن ﻧﺘﻴﺠﺘﻴﻦ ﻣﺨﺘﻠﻔﺘ ﻴﻦ ﺗ ﻢ اﻟﺤﺼ ﻮل‬ ‫ﻋﻠﻴﻬﻤﺎ ﻣﻦ أﺟﻞ ﻗﻴﻤﺔ إﺷﺎرة اﻟﺨﺮج ‪ ) y‬ﻋﻨﺪﻣﺎ ‪ sel = 3‬ﻣﺴﺒﻮﻗﺔ ﺑﺎﻟﺤﺎﻟﺔ ‪ sel = 0‬ﻓﺈن '‪ y = '0‬ﻓﻲ ﺣ ﻴﻦ أﻧ ﻪ ﻋﻨ ﺪﻣﺎ‬ ‫‪ sel = 3‬ﻣﺴ ﺒﻮﻗﺔ ﺑﺎﻟﺤﺎﻟ ﺔ ‪ sel = 1‬ﻓ ﺈن '‪ .( y = '1‬إن ه ﺬا ﻳﻌﻨ ﻲ أن ﻧﻮﻋ ًﺎ ﻣ ﺎ ﻣ ﻦ اﻟ ﺬاآﺮة ﻗ ﺪ ﺗ ﻢ ﺑﺎﻟﻔﻌ ﻞ ﺗﻨﺠﻴ ﺰﻩ‬ ‫ﺑﻮاﺳ ﻄﺔ اﻟﻤﺘ ﺮﺟﻢ ‪ .‬ﻓ ﻲ اﻟﻮاﻗ ﻊ إذا ﻧﻈﺮﻧ ﺎ إﻟ ﻰ اﻟﻤﻌ ﺎدﻻت اﻟﻤﺴ ﺘﻨﺒﻄﺔ ) اﻟﻤﺤﺼ ﻮل ﻋﻠﻴﻬ ﺎ ( ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺘ ﺮﺟﻢ ﻓ ﻲ‬ ‫اﻟﺒﺮﻣﺠﻴﺔ ‪ ) Quartus II‬ﻣﻦ ﺷﺮآﺔ ‪ ( ALTERA‬ﻓﺈﻧﻨﺎ ﻧﺴﺘﻄﻴﻊ اﻟﺘﺤﻘﻖ ﻣﻦ أن ﻗﻴﻤﺔ إﺷﺎرة اﻟﺨﺮج ﻗﺪ ﺗﻢ اﺣﺘﺴ ﺎﺑﻬﺎ‬ ‫وﻓﻖ اﻟﻤﻌﺎدﻟﺔ اﻟﻤﻨﻄﻘﻴﺔ اﻟﺘﺎﻟﻴﺔ ‪:‬‬ ‫)‪y = (sel(0) AND sel(1)) OR (sel(0) AND y) OR (sel(1) AND y‬‬ ‫وﺑﺎﻟﺘﺎﻟﻲ ﻓﺈن ﻣﺎﺳﻜًﺎ ) ﺑﺎﺳﺘﺨﺪام ﺑﻮاﺑﺎت ‪ ( AND / OR‬ﻗﺪ ﺗﻢ ﺗﻨﺠﻴﺰﻩ واﻟﺬي ﻳﻤﺜﻞ ﺟﺪول اﻟﺤﻘﻴﻘﺔ اﻟﻤﺒ ﻴﻦ ﻓ ﻲ اﻟﺸ ﻜﻞ‬ ‫)‪-١٦-٦‬ج( ‪.‬‬ ‫ﻟﺘﺠﻨﺐ اﻟﻌﺘﺎد اﻟﻤﻨﻄﻘﻲ اﻹﺿﺎﻓﻲ اﻟﻤﻄﻠﻮب ﻣﻦ أﺟﻞ اﻟﻤﺎﺳﻚ ﻓﺈن اﻟﻤﻮاﺻﻔﺎت اﻟﻤﺒﻴﻨﺔ ﻓﻲ اﻟﺸ ﻜﻞ )‪-١٦-٦‬د( ﻳﺠ ﺐ أن‬ ‫ﺗﺴ ﺘﺨﺪم ‪ ) .‬اﻟﻘﻴﻤ ﺔ '‪ 'X‬ﻗ ﺪ ﺗ ﻢ اﺳ ﺘﺨﺪاﻣﻬﺎ ﻓ ﻲ اﻟﺠ ﺪول اﻟﻤﻮﺿ ﺢ ﻓ ﻲ اﻟﺸ ﻜﻞ )‪-١٦-٦‬د( ﻣ ﻦ أﺟ ﻞ آﺎﻓ ﺔ اﻟﻘ ﻴﻢ ﻏﻴ ﺮ‬ ‫اﻟﻤﻌﻠﻮﻣ ﺔ أو ﻏﻴ ﺮ اﻟﻬﺎﻣ ﺔ ‪ .(All Unknown Or Don't Care Values‬ﺑﺎﻟﻨﺘﻴﺠ ﺔ ﻓ ﺈن اﻹﺳ ﻨﺎد ‪y <= 'X'; :‬‬ ‫ﻳﺠﺐ أن ﻳﺘﻢ ﺗﻀﻤﻴﻨﻪ ﻓﻲ اﻟﻜﻮد اﻟﺴﺎﺑﻖ أﻋﻼﻩ ﻣﺒﺎﺷﺮ ًة أﺳ ﻔﻞ آ ﻞ ﻣ ﻦ اﻟﺴ ﻄﺮﻳﻦ ‪ 22‬و ‪ 24‬ﻋﻠ ﻰ اﻟﺘﺮﺗﻴ ﺐ وهﻜ ﺬا ﻓ ﺈن‬ ‫ﻣﻌﺎدﻟﺔ ‪ y‬ﺳﺘﺼﺒﺢ اﻵن آﻤﺎ ﻳﻠﻲ ‪. y = sel(0) :‬‬

‫= = = = = ﻧﻬﺎﻳﺔ اﻟﺠﻠﺴﺔ اﻟﺴﺎدﺳﺔ = = = = =‬

‫‪٢٤‬‬

VHDL 05  

Sequential Code in VHDL

Read more
Read more
Similar to
Popular now
Just for you