٢

‫آﺷﻨﺎﻳﻲ ﺑﺎ ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎي‬

‫‪ AVR‬و ﻧﺮم اﻓﺰار ‪CodevisionAVR‬‬

‫اﻣﻴﺮ ره اﻓﺮوز‬

‫‪٣‬‬
‫در ﺻﻮرﺗﯽ ﮐﻪ ﻋﻼﻗﻪ ﻣﻨﺪﯾﺪ ﺗﺎ اﻃﻼﻋﺎت ﺟﺎﻣﻌﺘﺮی را در ﻣﻮرد ﻣﯿﮑﺮوﮐﻨﺘﺮوﻟﺮﻫﺎی ‪ AVR‬ﺑﺪﺳﺖ آورﯾﺪ ﻣﯽ ﺗﻮاﻧﯿﺪ ﮐﺘﺎب زﯾﺮ‬
‫را ﺗﻬﯿﻪ ﮐﻨﯿﺪ‪:‬‬

‫ﺑﺮای اﻃﻼﻋﺎت ﺑﯿﺸﺘﺮ ﻣﯽ ﺗﻮاﻧﯿﺪ ﺑﻪ ﺳﺎﯾﺘﻬﺎی زﯾﺮ ﻣﺮاﺟﻌﻪ ﮐﻨﯿﺪ‪:‬‬

‫‪http://profiles.yahoo.com/am_rahafrooz‬‬
‫‪http://bme.aut.ac.ir/arahafrooz‬‬
 ‫ﻋﻼوه ﺑﺮ اﯾﻦ ﺑﺮای ﺗﻤﺎس ﺑﺎ اﯾﻨﺠﺎﻧﺐ ﻣﯽ ﺗﻮاﻧﯿﺪ از آدرﺳﻬﺎی ﭘﺴﺖ اﻟﮑﺘﺮوﻧﯿﮑﯽ زﯾﺮ اﺳﺘﻔﺎده ﮐﻨﯿﺪ‪:‬‬
‫‪arahafrooz@cic.aut.ac.ir‬‬
‫‪am_rahafrooz@yahoo.com‬‬

‫ﻣﻮﻓﻖ ﺑﺎﺷﯿﺪ‪.‬‬
 ‫ﻓﺼﻞ اول‬

‫آﺷﻨﺎﻳﻲ ﺑﺎ ‪AVR‬‬

‫‪AVR‬ﻫﺎ ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎي ‪ ٨‬ﺑﻴﺘﻲ از ﻧﻮع ‪ CMOS‬ﺑﺎ ﺗﻮان ﻣﺼﺮﻓﻲ ﭘﺎﻳﻴﻦ ﻫﺴﺘﻨﺪ ﻛﻪ ﺑــﺮ اﺳـﺎس ﺳـﺎﺧﺘﺎر ﭘﻴﺸـﺮﻓﺘﻪ‬

‫‪ RISC‬ﺳﺎﺧﺘﻪ ﺷﺪهاﻧﺪ‪ .‬ﭘﺲ از ﺳﺎﺧﺖ اوﻟﻴﻦ ﻧﺴﺨﻪﻫﺎي ‪ AVR‬در ﺳـﺎل ‪ ،١٩٩٦‬اﻳـﻦ ﺳـﺮي از ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫـﺎ ﺗﻮاﻧﺴـﺖ ﻧﻈـﺮ‬

‫ﻋﻼﻗﻤﻪﻣﻨﺪان اﻟﻜﺘﺮوﻧﻴﻚ را ﺑﻪ ﺧﻮد ﺟﺬب ﻛﻨﺪ ﺑﻪ ﻃﻮري ﻛﻪ اﻣﺮوزه ﻳﻜﻲ از ﭘﺮﻣﺼﺮﻓﺘﺮﻳﻦ اﻧﻮاع ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎ ﺑﻪ ﺣﺴــﺎب ﻣﻲآﻳـﺪ‪.‬‬

‫ﻫﻤﺎن ﻃﻮر ﻛﻪ ﻣﻲ داﻧﻴﺪ ﻧﻤﻲﺗﻮان ﻫﻴﭻ ﻧﻮع ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮي را ﺑﻪ ﻋﻨﻮان ﺑﻬﺘﺮﻳﻦ ﻣﻌﺮﻓﻲ ﻛﺮد ﭼﺮا ﻛﻪ ﻫﺮ ﻣﻴﻜﺮوﻛﻨــﺘﺮوﻟﺮ‪ ،‬ﻛﺎرﺑﺮﻫـﺎي‬

‫‪٤‬‬
‫ﺧﺎص ﺧﻮد را دارد و ﺑﺮ اﺳﺎس ﺧﺼﻮﺻﻴﺎت داﺧﻠﻲ‪ ،‬ﻣﻲﺗﻮاﻧﺪ ﺗﻨﻬﺎ ﺑﺮاي ﻣﻮارد وﻳﮋهاي ﺑﻪ ﻋﻨﻮان ﺑﻬﺘﺮﻳﻦ اﻧﺘﺨــﺎب ﮔﺮدد‪ ،‬وﻟـﻲ ﺑـﺎ اﻳـﻦ‬

‫ﺣﺎل ﺑﺎ ﻣﻄﺎﻟﻌﺔ ﺻﻔﺤﺎت ﺑﻌﺪي و آﺷﻨﺎﻳﻲ ﺑﺎ اﻣﻜﺎﻧﺎت و ﻧﺮم اﻓﺰارﻫﺎي ﺟﺎﻧﺒﻲ ‪ AVR‬ﻣﺘﻮﺟــﻪ ﺧﻮاﻫﻴـﺪ ﺷـﺪ ﻛـﻪ در ﻛـﻞ اﺳـﺘﻔﺎده از‬

‫‪ AVR‬ﺑﺮ ﺑﻘﻴﻪ ﺗﺮﺟﻴﺢ دارد‪.‬‬

‫‪AVR‬ﻫﺎ ﺑﺎ ﺳﺎﺧﺘﺎر ‪ ،RISC‬دﺳﺘﻮرات را ﺗﻨﻬﺎ در ﻳﻚ ﭘﺎﻟﺲ ﺳﺎﻋﺖ اﺟﺮا ﻣﻲﻧﻤﺎﻳﻨﺪ و ﺑﻪ اﻳﻦ ﺗﺮﺗﻴﺐ ﻣﻲﺗﻮاﻧﻴﻢ ﺗﺎ ﺑـﻪ ازاي‬

‫ﻫﺮ ﻳﻚ ﻣﮕﺎﻫﺮﺗﺰ‪ ،‬ﻳﻚ ﻣﮕﺎدﺳﺘﻮر را در ﺛﺎﻧﻴﻪ)‪ (MIPS‬اﺟﺮا ﻛﺮده و ﺑﺮﻧﺎﻣﻪ را از ﻟﺤﺎظ ﺳﺮﻋﺖ ﭘﺮدازش و ﻧﻴﺰ ﻣﺼﺮف ﺗﻮان ﺑﻬﻴﻨﻪ ﻛﻨﻴﻢ‪.‬‬

‫‪AVR‬ﻫﺎ‪ ٣٢ ،‬رﺟﻴﺴﺘﺮ ﻫﻤﻪ ﻣﻨﻈﻮره )‪ (R0..R31‬و ﻣﺠﻤﻮﻋﻪ دﺳﺘﻮرات ﻗﺪرﺗﻤﻨﺪي را ﺷﺎﻣﻞ ﻣﻲﮔﺮدﻧﺪ‪ .‬ﺗﻤــﺎم اﻳـﻦ ‪٣٢‬‬

‫رﺟﻴﺴﺘﺮ ﻣﺴﺘﻘﻴﻤ ﹰﺎ ﺑﻪ ‪ ALU‬ﻣﺘﺼﻞ ﺷﺪهاﻧﺪ‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ دﺳﺘﺮﺳﻲ ﺑﻪ دو رﺟﻴﺴﺘﺮ در ﻳﻚ ﺳﻴﻜﻞ ﺳﺎﻋﺖ ﻫــﻢ اﻣﻜـﺎنﭘﺬﻳـﺮ اﺳـﺖ‪ .‬اﻳـﻦ‬

‫ﺳﺎﺧﺘﺎر ﻣﻮﺟﺐ ﻣﻲﮔﺮدد ﺗﺎ ﺳﺮﻋﺖ آﻧﻬﺎ ﻧﺴﺒﺖ ﺑﻪ ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎي ‪ CISC‬ﺑﺘﻮاﻧﺪ ﺗﺎ ‪١٠‬ﺑﺮاﺑﺮ ﻫﻢ اﻓﺰاﻳﺶ ﻳﺎﺑﺪ‪.‬‬

‫ﺧﺎﻧﻮاده ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎي ‪ ، AVR‬ﺗﺮاﺷﻪﻫﺎﻳﻲ ﭘﻴﺸﺮﻓﺘﻪ ﺑﺎ اﻣﻜﺎﻧﺎت ﺟﺎﻧﺒﻲ ﻛﺎﻣﻞ ﻫﺴﺘﻨﺪ‪ .‬زﻣﺎﻧﻲ ﻛﻪ ﺷﺮوع ﺑﻪ ﻳــﺎدﮔﻴـﺮي‬

‫ﻣﻔﺎﻫﻴﻢ اﺻﻠﻲ آﻧﻬﺎ ﻧﻤﺎﻳﻴﺪ‪ ،‬ﻟﺬت ﻓﺮاﮔﻴﺮي ﺗﻤﺎم ﺟﺰﺋﻴﺎﺗﺸﺎن آﻏﺎز ﻣﻲﺷﻮد‪.‬‬

‫ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎي ‪ AVR‬ﺑﻪ ﺳﻪ دﺳﺘﻪ ﺗﻘﺴﻴﻢ ﻣﻲﺷﻮﻧﺪ‪:‬‬

‫ﺷﻜﻞ ‪ ١ -١‬اﻧﻮاع ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎي ‪.AVR‬‬

‫‪٥‬‬
 ‫ﺷﻜﻞ ‪ ٢ -١‬اﻧﻮاع ﻣﺨﺘﻠﻒ ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎي ‪ AVR‬از ‪ ٨‬ﭘﺎﻳﻪ ﺗﺎ ‪ ١٦‬ﭘﺎﻳﻪ‬

‫‪Tiny AVR-‬‬
‫‪AVR(classic AVR)-‬‬
‫‪Mega AVR-‬‬
‫ﺗﻔﺎوت ﺑﻴﻦ اﻳﻦ ﺳﻪ ﻧﻮع ﺑﻪ اﻣﻜﺎﻧﺎت ﻣﻮﺟﻮد در آﻧﻬﺎ ﻣﺮﺑﻮط ﻣﻲﺷﻮد‪ Tiny AVR.‬ﻫﺎ ﻏﺎﻟﺒ ﹰﺎ ﺗﺮاﺷﻪﻫﺎﻳﻲ ﺑﺎ ﺗﻌﺪاد ﭘﻴﻦ و ﻣﺠﻤﻮﻋﻪ‬

‫دﺳﺘﻮرات ﻛﻤﺘﺮي ﻧﺴﺒﺖ ﺑﻪ ‪Mega AVR‬ﻫﺎ ﻣﻲﺑﺎﺷــﻨﺪ و ﺑـﻪ ﻋﺒـﺎرﺗﻲ از ﻟﺤـﺎظ ﭘﻴﭽﻴـﺪﮔﻲ ﺣﺪاﻗـﻞ اﻣﻜﺎﻧـﺎت را دارﻧـﺪ‪Maga .‬‬

‫‪AVR‬ﻫﺎ ﺣﺪاﻛﺜﺮ اﻣﻜﺎﻧﺎت را داﺷﺘﻪ و )‪AVR(classic AVR‬ﻫﺎ در ﺑﻴﻦ اﻳﻦ دو ﻧﻮع ﻗﺮار ﻣﻲﮔﻴﺮﻧﺪ‪.‬‬

‫ﺗﻤﺎم ﺗﺮاﺷﻪﻫﺎي ‪ AVR‬ﻣﺠﻤﻮﻋﻪ دﺳﺘﻮرات و ﺳﺎﺧﺘﺎر ﺣﺎﻓﻈﺔ ﻣﺸﺎﺑﻬﻲ دارﻧﺪ و از اﻳﻦ رو ﺗﻐﻴﻴﺮ از ﻳﻚ ﺗﺮاﺷﻪ ﺑﻪ ﺗﺮاﺷــﺔ دﻳـﮕﺮ‬

‫ﻛﺎري ﺑﺴﻴﺎر ﺳﺎده اﺳﺖ‪.‬‬

‫اﻣﻜﺎﻧﺎت ﻛﻠﻲ ﻳﻚ ‪AVR‬‬

‫‪ -‬در ﺣﺪود ‪ ١٣٠‬دﺳﺘﻮر ﻛﻪ اﻛﺜﺮ آﻧﻬﺎ در ﻳﻚ ﺳﻴﻜﻞ ﺳﺎﻋﺖ اﺟﺮا ﻣﻲﺷﻮﻧﺪ‪.‬‬

‫‪ ٣٢ -‬رﺟﻴﺴﺘﺮ ‪ ٨‬ﺑﻴﺘﻲ ﻫﻤﻪ ﻣﻨﻈﻮره‪.‬‬

‫‪ -‬ﺿﺮب ﻛﻨﻨﺪة ﺳﺨﺖ اﻓﺰاري ﺑﺎ زﻣﺎن اﺟﺮاي ‪ ٢‬ﺳﻴﻜﻞ ﺳﺎﻋﺖ‪.‬‬

‫‪ -‬داراي ﺳﻪ ﻧﻮع ﺣﺎﻓﻈﺔ ‪) FLASH‬ﺑﺮاي ﻛﺪﻫﺎي ﺑﺮﻧﺎﻣﻪ(‪.SRAM, EEPROM ،‬‬

‫‪٦‬‬
 ‫‪ -‬ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺗﺮاﺷﻪ در داﺧﻞ ﻣﺪار ﻣﻮردﻧﻈﺮ ﺑﺪون اﺣﺘﻴﺎج ﺑﻪ ﭘﺮوﮔﺮاﻣﺮ)‪.١(ISP‬‬

‫‪ -‬ﺣﻔﺎﻇﺖ از ﻛﺪﻫﺎي ﺑﺮﻧﺎﻣﻪ در ﻣﻘﺎﺑﻞ ﺧﻮاﻧﺪن‪.‬‬

‫‪ -‬ﻗﺎﺑﻠﻴﺖ ﺗﻨﻈﻴﻢ ﻧﻮﺳﺎﻧﮕﺮ ﺑﺮاي ﻛﺎر ﺗﻮﺳﻂ ﻛﺮﻳﺴﺘﺎل ﺧﺎرﺟﻲ‪ ،‬ﻛﺮﻳﺴﺘﺎل ﻓﺮﻛﺎﻧﺲ ﭘﺎﻳﻴﻦ ﺧﺎرﺟﻲ‪ ،‬ﻧﻮﺳﺎﻧﮕﺮ ‪RC‬‬

‫ﺧﺎرﺟﻲ‪ ،‬ﻧﻮﺳﺎﻧﮕﺮ ‪ RC‬داﺧﻠﻲ و ﻓﺮﻛﺎﻧﺲ ﺧﺎرﺟﻲ‪.‬‬

‫‪ -‬ﻣﺠﻬﺰ ﺑﻪ ﭘﺮوﺗﻜﻞ ‪ JTAG‬ﺑﺮاي اﻧﺠﺎم ﻋﻤﻞ دﻳﺒﺎگ‪ ،‬ﺗﺴــﺖ واﺳـﻜﻦ ﻛـﺮدن وﺳـﺎﻳﻞ ﺟـﺎﻧﺒﻲ ﺗﺮاﺷـﻪ و ﻧـﻴﺰ‬

‫ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺣﺎﻓﻈﻪﻫﺎي ‪ FLASH ,EEPROM‬و ﻓﻴﻮزﻫﺎ‪.‬‬

‫‪ -‬ﺷﻤﺎرﻧﺪه و ﺗﺎﻳﻤﺮ ‪ ٨‬ﺑﻴﺘﻲ‪.‬‬

‫‪ -‬ﺷﻤﺎرﻧﺪه و ﺗﺎﻳﻤﺮ ‪ ١٦‬ﺑﻴﺘﻲ‪.‬‬

‫‪ ٢RTC -‬ﺑﺎ ﻧﻮﺳﺎﻧﮕﺮ ﺟﺪاﮔﺎﻧﻪ‪.‬‬

‫‪ -‬ﻛﺎﻧﺎﻟﻬﺎي ‪) PWM‬ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﻳﻤﺮﻫﺎ ﺑﻪ ﺻﻮرت ‪ ٨‬ﺑﻴﺘﻲ و ‪١٦‬ﺑﻴﺘﻲ ﺑﺮاي ﺗﻮﻟﻴﺪ ‪( PWM‬‬

‫‪ -‬اﻣﻜﺎن ﺗﻨﻈﻴﻢ ﺗﺎﻳﻤﺮ ﺑﻪ ﺻﻮرت ‪.٣ CTC‬‬

‫‪٤ADC -‬ﻫﺎي ‪ ١٠‬ﺑﻴﺘﻲ ﺑﺎ ﻳﻚ ورودي و ﻳﺎ ورودي ﺗﻔﺎﺿﻠﻲ ﺑﺎ ﺑﻬﺮة ﻗﺎﺑﻞ ﺗﻨﻈﻴﻢ ‪.٢٠٠ ،١٠ ،١‬‬

‫‪ -‬ﻣﺠﻬﺰ ﺑﻪ ﭘﺮوﺗﻜﻞ ‪ ٥I2C‬ﻳﺎ ‪ ،٦TWI‬ارﺗﺒﺎط دو ﺳﻴﻤﻪ از ﺷﺮﻛﺖ ‪.Philips‬‬

‫‪ -‬ارﺗﺒﺎط ﺳﺮﻳﺎل ‪ ٧USART‬ﺑﺎ ﻗﺎﺑﻠﻴﺖ ﺑﺮﻧﺎﻣﻪرﻳﺰي‪.‬‬

‫‪ -‬ارﺗﺒﺎط ﺳﺮﻳﺎل ‪ ٨SPI‬ﺑﻪ ﺻﻮرت ‪.Master/Slave‬‬

‫‪ -‬ﺗﺎﻳﻤﺮ ﻧﮕﻬﺒﺎن‪ ،٩‬ﻗﺎﺑﻞ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺑﺎ ﻧﻮﺳﺎﻧﮕﺮ ﻣﺠﺰا‪.‬‬

‫‪ -‬ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪة آﻧﺎﻟﻮگ ﺑﺎ اﻣﻜﺎن ﺗﻌﺮﻳﻒ وﻗﻔﻪ ﺑﺮاي آن‪.‬‬

‫‪ RESET -‬ﺷﺪن در زﻣﺎن اﺗﺼﺎل ﺑﻪ ﺑﺮق‪.١٠‬‬

‫‪ Brown-out Detector -‬ﺑﺎ ﻗﺎﺑﻠﻴﺖ ﺑﺮﻧﺎﻣﻪرﻳﺰي‪.‬‬

‫‪١‬‬
‫‪In System Programming‬‬
‫‪٢‬‬
‫‪Real Time Clock‬‬
‫‪٣‬‬
‫‪Clear Timer On Compare Match‬‬
‫‪٤‬‬
‫‪Analog to Digital Converter‬‬
‫‪٥‬‬
‫‪Inter-IC bus‬‬
‫‪٦‬‬
‫‪Two wire Interface‬‬
‫‪٧‬‬
‫‪Universal Synchronous and Asynchronous serial Receiver and Transmitter‬‬
‫‪٨‬‬
‫‪Serial peripheral Interface‬‬
‫‪٩‬‬
‫‪Watch Dog Timer‬‬
‫‪١٠‬‬
‫‪Power On Reset‬‬

‫‪٧‬‬
 ‫‪ -‬ﻣﻨﺎﺑﻊ وﻗﻔﻪ داﺧﻠﻲ و ﺧﺎرﺟﻲ‪.‬‬

‫‪ -‬ﺑﺎ ﺷﺶ ﺣﺎﻟﺖ ﻣﺨﺘﻠﻒ ﺑﺮاي ﻛﺎﻫﺶ ﺗﻮان ﻣﺼﺮﻓﻲ‪.‬‬

‫‪ -‬ﻛﺎر ﺑﺎ وﻟﺘﺎژﻫﺎي‪ ٥,٥-٤,٥‬در ﻣﺪﻟﻬﺎي ﺑﺪون ﭘﺴــﻮﻧﺪ ‪ L‬ﻣﺜـﻞ ‪ ، ATMega32‬و‪ ٥,٥-٢,٧‬در ﻣﺪﻟـﻬﺎي ﺑـﺎ‬

‫ﭘﺴﻮﻧﺪ ‪ L‬ﻣﺜﻞ )‪. ATMega 32(L‬‬

‫ﻣﻤﻜﻦ اﺳﺖ ﺑﻌﻀﻲ از اﻣﻜﺎﻧﺎت ذﻛﺮ ﺷﺪه در ﺑﻌﻀﻲ از اﻧﻮاع ﺳﺎده ‪ AVR‬وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ و ﺣﺠﻢ ﻓﻀﺎﻫــﺎي ‪Sram,Eeprom,‬‬

‫‪ Flash‬ﻫﻢ در آﻧﻬﺎ ﻣﺘﻔﺎوت ﺑﺎﺷﺪ‪ .‬ﻟﺬا ﺑﺮاي اﻧﺘﺨﺎب ﺻﺤﻴﺢ ‪ AVR‬اﮔﺮ ﺷﻤﺎ از ﻟﺤﺎظ ﻣﺎﻟﻲ ﻣﺤﺪودﻳﺖ دارﻳﺪ ﺑﺎﻳﺪ ﻧﻮﻋﻲ از ‪ AVR‬را‬

‫اﻧﺘﺨﺎب ﻛﻨﻴﺪ ﻛﻪ ﺗﻨﻬﺎ اﻣﻜﺎﻧﺎت ﻣﻮرد ﻧﻴﺎز ﺷﻤﺎ را داﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬وﻟﻲ در ﺻﻮرﺗﻲ ﻛﻪ ﻣﺤﺪوﻳﺘﻲ ﻧﺪارﻳﺪ‪ ،‬ﻣﺴﻠﻤ ﹰﺎ ﺑــﺎﻳﺪ ﻗﻮﻳـﺘﺮﻳﻦ ‪AVR‬‬

‫ﻣﻤﻜﻦ را اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪ .‬ﭼﺮا!…‬

‫ﻣﻤﻜﻦ اﺳﺖ از ﺧﻮد ﺑﭙﺮﺳﻴﺪ‪ ،‬ﭼﮕﻮﻧﻪ ﺑﺎﻳﺪ ﻳﺎد ﺑﮕﻴﺮﻳﻢ ﺗﺎ ﻛﺪﻫﺎي ‪ AVR‬را ﺑﻨﻮﻳﺴﻴﻢ!‬

‫ﻳﺎدﮔﻴﺮي ﻳﻚ ﻣﻮﺿﻮع ﺟﺪﻳﺪ ﺟﺎﻟﺐ اﺳﺖ وﻟﻲ ﻣﻲﺗﻮاﻧﺪ ﻛﻤﻲ ﻫﻢ ﻣﺄﻳﻮس ﻛﻨﻨﺪه ﺑﺎﺷﺪ‪ .‬ﺑﺎ اﻳﻦ وﺟﻮد اﻣﻜﺎن ﻓــﺮاﮔﻴـﺮي ‪ AVR‬ﺗﻨـﻬﺎ از‬

‫ﻃﺮﻳﻖ ﻣﻄﺎﻟﻌﻪ ﺑﺮﮔﻪ ﻫﺎي اﻃﻼﻋﺎﺗﻲ آن اﻣﻜﺎنﭘﺬﻳﺮ ﻣﻲﺑﺎﺷﺪ ﻛﻪ روﺷﻲ وﻗﺘﮕﻴﺮ و ﭘﻴﭽﻴﺪه اﺳﺖ‪.‬‬

‫ﻣﺎ راه دﻳﮕﺮي را اراﺋﻪ ﻣﻲﻛﻨﻴﻢ‪:‬‬

‫‪١‬ـ ﻣﻘﺪاري ﺑﺮﻧﺎﻣﻪ از ﭘﻴﺶ ﻧﻮﺷﺘﻪ ﺷﺪه ﭘﻴﺪا ﻛﻨﻴﺪ‪.‬‬

‫‪٢‬ـ ﭼﮕﻮﻧﮕﻲ ﻋﻤﻠﻜﺮد ﻛﺪﻫﺎ را ﺑﻔﻬﻤﻴﺪ‪.‬‬

‫‪٣‬ـ آن را ﺑﻪ ﮔﻮﻧﻪاي ﺗﻐﻴﻴﺮ دﻫﻴﺪ ﻛﻪ ﻧﻴﺎز ﺷﻤﺎ را ﺑﺮآورده ﻛﻨﺪ‪.‬‬

‫ﭼﮕﻮﻧﻪ از ﺑﺮﮔﻪ ﻫﺎي اﻃﻼﻋﺎﺗﻲ ‪ AVR‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ؟‬

‫زﻣﺎﻧﻲ ﻛﻪ ﺑﻪ ﺑﺮﮔﻪ ﻫﺎي اﻃﻼﻋــﺎﺗﻲ ‪ AVR‬ﻧـﮕﺎه ﻛﻨﻴـﺪ اﺣﺘﻤـﺎ ﹰﻻ ﺧﻮاﻫﻴـﺪ ﺗﺮﺳـﻴﺪ‪ ،‬ﺑـﺮاي ﻣﺜـﺎل ﺑـﺮﮔﻪ اﻃﻼﻋـﺎﺗﻲ ﻣﺮﺑـﻮط ﺑـﻪ)‪(L‬‬

‫‪ ATMega128‬ﺗﻘﺮﻳﺒ ﹰﺎ ‪ ٣٥٠‬ﺻﻔﺤﻪ اﺳﺖ و ﻣﻄﺎﻟﻌﺔ ﻛﻞ آن و ﺑﻪ ﻳﺎد ﺳﭙﺮدن ﻣﺤﺘــﻮاي آن ﻛـﺎر ﻣﺸـﻜﻠﻲ اﺳـﺖ‪ .‬ﺧﻮﺷـﺒﺨﺘﺎﻧﻪ ﻻزم‬

‫ﻧﻴﺴﺖ ﺗﺎ اﻳﻦ ﻛﺎر را اﻧﺠﺎم دﻫﻴﺪ‪ .‬ﺑﺮﮔﻪ ﻫﺎي اﻃﻼﻋﺎﺗﻲ‪ ،‬ﻣﺠﻤﻮﻋﻪاي از اﻃﻼﻋﺎت ﻛﺎﻣﻞ و ﺣﺮﻓﻪاي ﻣﻲﺑﺎﺷﻨﺪ و ﺷﻤﺎ ﻣﻲﺗﻮاﻧﻴﺪ در زﻣــﺎﻧﻲ‬

‫ﻛﻪ ﻧﺴﺒﺖ ﺑﻪ ﻋﻤﻠﻜﺮد اﻣﻜﺎﻧﺎت ‪ AVR‬و ﻳﺎ وﺳﺎﻳﻞ ﺟﺎﻧﺒﻲ ﻣﻄﻤﺌﻦ ﻧﻴﺴﺘﻴﺪ از آﻧﻬﺎ ﺑﻪ ﻋﻨﻮان ﻣﺮﺟﻊ اﺳﺘﻔﺎده ﻛﻨﻴﺪ‪.‬‬

‫زﻣﺎﻧﻲ ﻛﻪ ﺷﻤﺎ ﻳﻚ ﺑﺮﮔﻪ ﻫﺎي اﻃﻼﻋﺎﺗﻲ ﻣﺮﺑﻮط ﺑﻪ ﻳﻜﻲ از اﻧﻮاع ‪ AVR‬را ﻣﺸﺎﻫﺪه ﻧﻤﺎﻳﻴﺪ‪ ،‬ﻣﻲﺗﻮاﻧﻴﺪ آن را ﺑﻪ ﻗﺴﻤﺘﻬﺎي زﻳــﺮ‬

‫ﺗﻘﺴﻴﻢ ﻛﻨﻴﺪ‪.‬‬

‫‪١‬ـ اوﻟﻴﻦ ﺻﺤﻔﻪ ﺷﺎﻣﻞ اﻃﻼﻋﺎت ﻛﻠﻴﺪي و ﻟﻴﺴﺖ اﻣﻜﺎﻧﺎت ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮ‪.‬‬

‫‪٢‬ـ ﺧﻼﺻﻪاي از ﺳﺎﺧﺘﺎر‪.AVR‬‬

‫‪٣‬ـ ﺗﻮﺿﻴﺢ وﺳﺎﻳﻞ ﺟﺎﻧﺒﻲ‪.‬‬

‫‪٨‬‬
 ‫‪٤‬ـ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺣﺎﻓﻈﻪ‪.‬‬

‫‪٥‬ـ ﻣﺸﺨﺼﺎت اﻟﻜﺘﺮﻳﻜﻲ‪.‬‬

‫‪٦‬ـ ﺧﻼﺻﻪ رﺟﻴﺴﺘﺮﻫﺎ‪.‬‬

‫‪٧‬ـ ﺧﻼﺻﻪ ﻣﺠﻤﻮﻋﻪ دﺳﺘﻮرات‪.‬‬

‫‪٨‬ـ اﻃﻼﻋﺎت ﻣﺮﺑﻮط ﺑﻪ اﺑﻌﺎد و ﺷﻜﻞ ﻇﺎﻫﺮي ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮ‪.‬‬

‫زﺑﺎن ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴﻲ‪C‬‬
‫اﻣﺮوزه زﺑﺎن ﺳﻄﺢ ﺑﺎﻻي ‪ C‬ﻫﺮ ﭼﻪ ﺑﻴﺸﺘﺮ ﺑﺮاي ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴﻲ ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎ ﻋﻤﻮﻣﻴﺖ ﻳﺎﻓﺘﻪ اﺳﺖ‪ .‬ﻣﺰاﻳﺎي اﺳﺘﻔﺎده از زﺑﺎن ‪C‬‬

‫ﺑﻪ ﺟﺎي زﺑﺎن اﺳﻤﺒﻠﻲ زﻳﺎدﻧﺪ‪ :‬ﻛﺎﻫﺶ زﻣﺎن ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴﻲ‪ ،‬ﻧﮕﻬﺪاري ﺳﺎدهﺗﺮ و ﻗﺎﺑﻠﻴﺖ ﺣﻤﻞ ﺑﻴﺸﺘﺮ‪ ،‬اﺳﺘﻔﺎده ﻣﺠﺪد ازﻛﺪﻫﺎ و ﺳــﺎدهﺗﺮ‬

‫ﺷﺪن ﻓﻬﻢ ﺑﺮﻧﺎﻣﻪ‪ .‬ﻋﻴﺐ آن ﻫﻢ اﻓﺰاﻳﺶ ﺣﺠﻢ ﻛﺪﻫﺎ و در ﻧﺘﻴﺠﻪ ﻛﺎﻫﺶ ﺳﺮﻋﺖ ﺑﺮﻧﺎﻣﻪ ﻣﻲﺑﺎﺷﺪ‪ .‬ﺑﺮاي ﻛــﺎﻫﺶ ﻳـﺎ رﻓـﻊ اﻳـﻦ ﻣﻌـﺎﻳﺐ‬

‫ﺳﺎﺧﺘﺎر ‪ AVR‬ﺑﻪ ﮔﻮﻧﻪاي ﻃﺮاﺣﻲ ﺷﺪه ﺗﺎ دﺳﺘﻮرات ﺗﻮﻟﻴﺪ ﺷﺪه ﺗﻮﺳﻂ ﻛﺎﻣﭙﺎﻳﻠﺮ ‪ C‬را ﺑﻪ ﺻﻮرت ﻣﺆﺛﺮ دﻳﻜﺪ و اﺟﺮ ﻧﻤﺎﻳﺪ‪.‬‬

‫ﻃﺮاﺣﻲ ﻛﺎﻣﭙﺎﻳﻠﺮ ‪ C‬ﻗﺒﻞ از ﺗﻜﻤﻴﻞ ﺳﺎﺧﺘﺎر و ﻣﺠﻤﻮﻋﻪ دﺳﺘﻮرات ‪ AVR‬ﺻﻮرت ﮔﺮﻓﺘﻪ اﺳﺖ‪ .‬ﻧﺘﻴﺠﻪ اﻳﻦ ﻋﻤﻠﻜﺮد ﻫﻤﺰﻣﺎن ﺑﻴﻦ‬

‫ﺗﻴﻤﻬﺎي ﻛﺎﻣﭙﺎﻳﻠﺮ و ‪ ،AVR‬ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮي ﺑﺎ ﻛﺪﻫﺎي ﺗﻮﻟﻴﺪ ﺷﺪه ﺟﻬﺖ اﺳﺘﻔﺎده ﺑﻬﻴﻨﻪ و ﻛﺎراﻳﻲ ﺑﺎﻻ ﻣﻲﺑﺎﺷﺪ‪.‬‬

‫در اﻳﻦ ﻛﺘﺎب ﺑﺮ آﻧﻴﻢ ﺗﺎ اﺑﺘﺪا ﺑﺎ ﻧﺮم اﻓﺰار ‪ CodevisionAVR‬ﺑﺮاي ﻛﺎﻣﭙــﺎﻳﻞ ﻛـﺮدن ﺑﺮﻧﺎﻣـﻪ ﻫـﺎي‪ C‬آﺷﻨﺎﺷـﺪه ‪،‬و ﭼﻨـﺪ ﺑﺮﻧﺎﻣـﻪ‬

‫ﻛﺎرﺑﺮدي را ﺗﻮﺿﻴﺢ داده و اﺟﺮا ﻛﻨﻴﻢ‪.‬در اﻳﻨﺠﺎ از ﺗﺮاﺷﻪ ‪ ATMega32‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ‪ .‬در ﺷﻜﻞ)‪ (٣-١‬ﻛﻠــﻲ ﺗﺮاﺷـﻪ و ﻋﻤﻠﻜـﺮد‬

‫ﭘﺎﻳﻪ ﻫﺎي ﻣﺨﺘﻠﻒ اﻳﻦ ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮ را ﻣﻲ ﺑﻴﻨﻴﺪ‪ .‬در ﻣﻮرد ﺳﺨﺖ اﻓﺰار ﻻزم ﺑﺮاي راه اﻧﺪازي ﺗﺮاﺷﻪ در ﻓﺼــﻞ دوم ﺗﻮﺿﻴـﺢ ﺧﻮاﻫﻴـﻢ‬

‫داد‪.‬‬

‫‪٩‬‬
 ‫ﺷﮑﻞ ‪٣ -١‬‬

‫‪١٠‬‬
 ‫ﻓﺼﻞ دوم‬

‫ﻣﻘﺪﻣﻪ‬
‫دو روش ﻣﺨﺘﻠﻒ ﺟﻬﺖ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺗﺮاﺷﻪﻫﺎي ‪ AVR‬وﺟﻮد دارد ﻛﻪ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻣﻮازي و ﺳﺮﻳﺎل)ﺣــﺎﻟﺖ ‪ (ISP‬ﻧـﺎﻣﻴﺪه‬

‫ﻣﻲﺷﻮﻧﺪ‪ .‬در ﺣﺎﻟﺖ ﻣﻮازي ﺗﺮاﺷﺔ ﻣﻮردﻧﻈﺮ در ﺳﻮﻛﺖ ﭘﺮوﮔﺮاﻣﺮ ﻗﺮار داده ﻣﻲﺷﻮد‪ .‬در اﻳﻦ روش ﻻزم اﺳﺖ ﺗﺎ وﻟﺘﺎژ ‪ +١٢‬وﻟﺖ ﺑﻪ ﭘﺎﻳـﻪ‬

‫‪ RESET‬اﻋﻤﺎل ﮔﺮدد‪ .‬ارﺗﺒﺎط ﺑﻴﻦ ﭘﺮوﮔﺮاﻣﺮ و ﺗﺮاﺷﻪ ﻣﻮردﻧﻈــﺮ ﻧـﻴﺰ ﻫﻤـﺎن ﻃـﻮر ﻛـﻪ از اﺳـﻤﺶ ﭘﻴﺪاﺳـﺖ ﺑـﻪ ﻛﻤـﻚ دﺳـﺘﻮرات‬

‫ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴﻲ ﻣﻮازي ﺑﺮﻗﺮار ﻣﻲﺷﻮد و ﺑﻪ ﻫﻤﻴﻦ دﻟﻴﻞ ﺳــﺮﻋﺖ ﺑﺮﻧﺎﻣـﻪرﻳﺰي در اﻳـﻦ روش دو ﺑﺮاﺑـﺮ ﺳـﺮﻳﻌﺘﺮ از ﺣـﺎﻟﺖ ‪ ISP‬اﺳـﺖ‪.‬‬

‫ﺑﺮﺧﻼف روش ‪ ISP‬ﻛﻪ ﺑﻌﻀﻲ از اﻧﻮاع ‪ AVR‬از آن ﭘﺸﺘﻴﺒﺎﻧﻲ ﻧﻤﻲﻛﻨﻨﺪ‪ ،‬روش ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻣﻮازي ﻣﻲﺗﻮاﻧﺪ ﺑﺮاي اﻧــﻮاع ‪ AVR‬ﺑـﻪ‬

‫ﻛﺎر ﺑﺮده ﺷﻮد‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﺑﻪ ﻃﻮر ﻛﻠﻲ از اﻳﻦ روش در ﻣﻮاردي ﻛﻪ ﺗﻮﻟﻴﺪ اﻧﺒﻮه ﻣﻮردﻧﻈﺮ اﺳﺖ اﺳﺘﻔﺎده ﻣﻲﮔﺮدد‪ ،‬اﻣﺎ آﻧﭽﻪ در اﻳﻦ ﺑﺨﺶ‬

‫ﻣﻮردﻧﻈﺮ ﻣﺎﺳﺖ‪ ،‬ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺳﺮﻳﺎل اﺳﺖ‪.‬‬

‫‪١١‬‬
 ‫ﺷﻜﻞ ‪ ١ -٢‬روﺷﻬﺎي ﻣﺨﺘﻠﻒ ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎي ‪AVR‬‬

‫ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺳﺮﻳﺎل)‪:(ISP‬‬

‫ﻼ ﺑﺮ روي ﺑﻮرد ﻣﻮردﻧﻈﺮ ﻗــﺮار ﮔﺮﻓﺘـﻪ اﺳـﺖ ﺑـﻪ اﻳـﻦ‬

‫از آﻧﺠﺎﻳﻲ ﻛﻪ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺳﺮﻳﺎل زﻣﺎﻧﻲ اﻧﺠﺎم ﻣﻲﺷﻮد ﻛﻪ ﺗﺮاﺷﻪ ﻗﺒ ﹰ‬

‫روش ‪ ١ISP‬ﻣﻲﮔﻮﻳﻨﺪ‪ .‬ﻗﺒﻞ از اﻳﻨﻜﻪ ﺑﻪ ﺗﻮﺿﻴﺢ ﻗﺴﻤﺘﻬﺎي ﻣﺨﺘﻠﻒ در اﻳﻦ روش ﺑﭙﺮدازﻳﻢ ﻻزم اﺳﺖ ﻗﺴﻤﺘﻲ از ﺣﺎﻓﻈــﻪ ‪ ،AVR‬ﺑـﻪ‬

‫‪١‬‬
‫‪In system programming‬‬

‫‪١٢‬‬
‫ﻧﺎم ‪ Boot Loader‬را ﻣﻌﺮﻓﻲ ﻧﻤﺎﻳﻴﻢ‪ .‬در اﻧﻮاﻋﻲ از ‪ AVR‬ﻛﻪ از روش ‪ ISP‬ﺣﻤﺎﻳﺖ ﻣﻲﻛﻨﻨﺪ‪ .‬ﺣﺎﻓﻈﻪ ‪ ،FLASH‬ﺑــﻪ دو ﻗﺴـﻤﺖ‬

‫ﺗﻘﺴﻴﻢ ﻣﻲﺷﻮد ﻛﻪ اوﻟﻴﻦ ﻗﺴﻤﺖ ﻫﻤﺎن ‪ Boot Loader‬اﺳﺖ‪ .‬ﻛﺪﻫﺎي ﻣﻮﺟــﻮد در اﻳـﻦ ﻗﺴـﻤﺖ اﻣﻜـﺎن ‪ ISP‬را ﺑـﺮاي ﻣـﺎ اﻳﺠـﺎد‬

‫ﻣﻲﻧﻤﺎﻳﻨﺪ‪ .‬ﺑﻪ ﻋﺒﺎرﺗﻲ ﺳﺎدهﺗﺮ ﺑــﻪ ﻛﻤـﻚ ﺑﺮﻧﺎﻣـﻪ ﻣﻮﺟـﻮد در اﻳـﻦ ﻗﺴـﻤﺖ ‪ AVR،‬ﻛﺪﻫـﺎي ﺑﺮﻧﺎﻣـﻪ را از ‪ PC‬ﮔﺮﻓﺘـﻪ و ﺧـﻮدش را‬

‫ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻣﻲﻛﻨﺪ‪ .‬ﺟﺎﻟﺐ اﺳﺖ ﺑﺪاﻧﻴﺪ ﻛﻪ اﻳﻦ ﻗﺴﻤﺖ)‪ (Boot Loader‬ﻣﻲﺗﻮاﻧﺪ ﺧﻮدش را ﻫﻢ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻣﺠﺪد ﻧﻤﺎﻳﺪ‪.‬‬

‫ﻫﺪف ﻣﺎ در اﻳﻦ ﻗﺴﻤﺖ ﺗﻮﺿﻴﺢ و ﺳﺎﺧﺖ ﺳﺨﺖ اﻓﺰار واﺳﻄﻲ اﺳﺖ ﻛﻪ اﻣﻜﺎن ﺑﺮﻗﺮاي ارﺗﺒﺎط ﺑﻴﻦ ‪ PC‬و ﺑﺮﻧــﺎﻣﻪ‪Boot‬‬

‫‪ Loader‬ﺑﺮ روي ‪ AVR‬را اﻳﺠﺎد ﻣﻲﻛﻨﺪ‪ .‬اﻳﻦ وﺳﻴﻠﻪ ‪ Programming adapter‬ﻧﺎﻣﻴﺪه ﻣﻲﺷﻮد‪.‬‬

‫ﺑﻪ ﻃﻮر ﻛﻠﻲ در اﻳﻦ ﺑﺨﺶ دو ﭘﺮوﺗﻮﻛﻞ ﻣﺨﺘﻠﻒ وﺟﻮد دارﻧﺪ‪ ،‬ﻛﻪ ﺟﻬﺖ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺑﻪ ﻛﺎر ﻣﻲروﻧﺪ‪ .‬اوﻟﻴﻦ ﭘﺮوﺗﻜﻞ ‪ ١SPI‬و‬

‫دوﻣﻲ ‪ JTAG‬ﻧﺎم دارﻧﺪ‪ .‬در ﻋﻤﻞ آﻧﭽﻪ ﺑﻴﺸﺘﺮ ﺑﻪ ﻛﺎر ﻣﻲرود ﻫﻤﺎن ‪ SPI‬اﺳﺖ‪ .‬اﻟﺒﺘﻪ ﺑﻪ ﻛﻤﻚ ﭘﺮوﺗﻮﻛﻞ ‪ JTAG‬ﻧﻪ ﺗﻨﻬﺎ ﻗﺎدرﻳﻢ ﺗــﺎ‬

‫ﺗﺮاﺷﻪ ﻣﻮردﻧﻈﺮ را ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻛﻨﻴﻢ‪ ،‬ﺑﻠﻜﻪ ﺑﺎ ﺗﺄﻣﻴﻦ ﺳﺨﺖاﻓﺰار و ﻧﺮماﻓﺰار ﻛﺎﻓﻲ ﻣﻲﺗﻮاﻧﻴﻢ ﻋﻤﻞ ‪ Debugging‬را ﻫﻢ اﻧﺠﺎم دﻫﻴــﻢ و‬

‫ﺑﻨﺎﺑﺮاﻳﻦ ﺑﻪ وﺳﺎﻳﻞ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﭘﻴﭽﻴﺪهﺗﺮ ﺑﺎ ﻗﻴﻤﺘﻲ ﺑﺴﻴﺎر ﺑﻴﺸﺘﺮ از ﻳﻚ ارﺗﺒﺎط ﺳﺎده ‪ SPI‬ﻧﻴﺎز ﺧﻮاﻫﺪ ﺑﻮد‪ ،‬ﺑﻪ اﻳﻦ ﺗﺮﺗﻴــﺐ ﺑـﻪ دﻟﻴـﻞ‬

‫ﻗﻴﻤﺖ ﺑﺎﻻي آن در ﻣﻘﺎﻳﺴﻪ ﺑﺎ روش ‪ ،SPI‬اﺻﻮ ﹰﻻ از ‪ JTAG‬ﺑﺮاي ‪ Debugging‬اﺳﺘﻔﺎده ﻣﻲﺷﻮد‪.‬‬

‫ﻋﻼوه ﺑﺮ دو روش ﻗﺒﻞ‪ ،‬روش ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺳﺮﻳﺎﻟﻲ ﺑﺎ اﺳﺘﻔﺎده از وﻟﺘﺎژ ‪١٢‬وﻟﺖ ﻫﻢ وﺟﻮد دارد ﻛﻪ روش ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺳــﺮﻳﺎل‬

‫وﻟﺘﺎژ ﺑﺎﻻ ﻧﺎﻣﻴﺪه ﻣﻲﺷﻮد‪ .‬از آﻧﺠﺎﻳﻲ ﻛﻪ اﻳﻦ روش ﺗﻨﻬﺎ ﺑﺮاي ﺗﺮاﺷﻪﻫﺎي ‪ ٨‬ﭘﺎﻳﻪ ﺑﻪ ﻛﺎر ﻣﻲرود‪ ،‬در اﻳﻨﺠﺎ ﺑﻪ آن اﺷﺎره ﻧﻤﻲﻛﻨﻴﻢ‪.‬‬

‫در روش ‪ ،ISP‬ﺑﺎ اﺳﺘﻔﺎده از ﭘﺮوﺗﻜﻞ ‪ SPI‬ﻣﻲﺗﻮاﻧﻴﻢ ﻋﻼوه ﺑــﺮ ﺑﺮﻧﺎﻣـﻪرﻳﺰي ﺗﺮاﺷـﻪ‪ ،‬ﺻﺤـﺖ ﺑﺮﻧـﺎﻣﻪ ﻧﻮﺷـﺘﻪ ﺷـﺪه را ﻫـﻢ‬

‫ﺗﺸﺨﻴﺺ دﻫﻴﻢ)‪ .(verify‬در اﻳﻦ روش ﺗﻨﻬﺎ ﺑﻪ ﺳﻪ ﺳﻴﮕﻨﺎل اﺣﺘﻴﺎج دارﻳــﻢ‪ ،‬ﻳـﻚ ﺧـﻂ ورودي‪ ،‬ﻳـﻚ ﺧـﻂ ﺧﺮوﺟـﻲ و ﻳـﻚ ﺧـﻂ‬

‫‪ .Clock‬ﻋﻼوه ﺑﺮ اﻳﻦ‪ ،‬ﭘﻴﻦ ‪ RESET‬در ﺗﺮاﺷﻪ ﻫﻢ ﺑﺎﻳﺪ در ﺣﻴﻦ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﭘﺎﻳﻴﻦ)ﺻﻔﺮ ﻣﻨﻄﻘﻲ( ﻧﮕﻪ داﺷﺘﻪ ﺷﻮدﺿﻤﻨﺎ ﺑــﻪ وﻟﺘـﺎژ‬

‫ﻼ از ﻗـﺎﺑﻠﻴﺖ‬
‫‪١٢‬وﻟﺖ ﻫﻢ ﻧﻴﺎزي ﻧﺪارﻳﻢ‪ .‬ﺑﺎ اﻳﻦ ﺣﺎل در ﺑﻌﻀﻲ از ﺗﺮاﺷﻪﻫﺎ اﻣﻜﺎن ﺗﻨﻈﻴﻢ ﻓﻴﻮزﻫﺎ را ﻧﺪارﻳﻢ و ﺣﺘــﻲ ﺑﻌﻀـﻲ از آﻧـﻬﺎ اﺻـ ﹰ‬

‫‪ SPI‬ﺣﻤﺎﻳﺖ ﻫﻢ ﻧﻤﻲﻛﻨﻨﺪ‪ .‬ﭼﻨﻴﻦ ﺗﺮاﺷﻪﻫﺎﻳﻲ ﺑﺎﻳﺪ ﺑﻪ روش ﻣﻮازي ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺷﻮﻧﺪ‪.‬‬

‫واﺳﻄﻪﻫﺎي ‪ISP‬‬

‫‪١‬‬
‫‪Serial Peripheral Interface‬‬

‫‪١٣‬‬
 ‫ﺷﮑﻞ ‪ ٢ -٢‬ﺑﺮﻧﺎﻣﻪ رﻳﺰى ﺑﻪ روش ‪ISP‬‬

‫ﻋﺒﺎراﺗﻲ ﻣﺜﻞ “واﺳﻄﻪﻫﺎي ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺳﺮﻳﺎل و ﻣﻮازي” ﻛﻪ اﻏﻠﺐ ﺑﻪ ﻛﺎر ﻣﻲروﻧﺪ ﻣﻤﻜﻦ اﺳﺖ ﻣﻌﻨــﻲ ﻧﺎدرﺳـﺘﻲ ﺑـﺮاي ﻣـﺎ‬

‫داﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﭼﺮا ﻛﻪ ﺑﻌﻀﻲ از ﻣﻮﻟﺪﻫﺎي واﺳﻂ ‪ ،ISP‬از ﭘﻮرت ﻣﻮازي ﻛﺎﻣﭙﻴﻮﺗﺮ اﺳﺘﻔﺎده ﻣﻲﻛﻨﻨﺪ در ﺻﻮرﺗﻲ ﻛــﻪ ﺑﻘﻴـﻪ ﺑـﻪ ﭘﻮرﺗـﻬﺎي‬

‫ﺳﺮﻳﺎل ﻛﺎﻣﭙﻴﻮﺗﺮ)‪ (COM‬ﻣﺘﺼﻞ ﻣﻲﺷﻮﻧﺪ‪ ،‬وﻟﻲ ﻫﺮ دوي آﻧﻬﺎ از روش ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺳﺮﻳﺎل اﺳﺘﻔﺎده ﻣﻲﻛﻨﻨﺪ‪).‬ﺷﻜﻞ ‪(٢-٢‬‬

‫واﺳﻄﻪﻫﺎي ‪ ISP‬ﺑﺮاي ﭘﻮرت ﻣﻮازي ﺑﺴﻴﺎر ﺳﺎدهﺗﺮ ﻫﺴﺘﻨﺪ‪ .‬ﺑﻌﻀﻲ از اﻧﻮاع آﻧﻬﺎ ﺣﺘﻲ ﻫﻴﭻ اﺣﺘﻴﺎﺟﻲ ﺑﻪ ﻋﻨــﺎﺻﺮ ﻓﻌـﺎل ﻫـﻢ‬

‫ﻧﺪارﻧﺪ وﻟﻲ ﺷﻤﺎ ﻣﻲﺗﻮاﻧﻴﺪ ﺗﺼﻮر ﻛﻨﻴﺪ ﻛﻪ اﺗﺼﺎل ﻣﺴﺘﻘﻴﻢ ﻣﺪار ﺑﻪ ﭘﻮرت ﻣﻮازي ﻣﻤﻜﻦ اﺳﺖ ﺑﺎﻋﺚ اﻳﺠﺎد ﻣﺸﻜﻞ ﺷﻮد‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ اﻛــﺜﺮ‬

‫واﺳﻄﻪﻫﺎ از ﻳﻚ دراﻳﻮ ﺧﻂ اﺳﺘﻔﺎده ﻣﻲﻛﻨﻨﺪ‪ .‬وﻟﻲ ﺑﺎ اﻳﻦ ﺣﺎل ﻫﻨﻮز ﻫﻢ ﭼﻨﺪان اﻳﻤﻦ ﻧﻴﺴﺖ‪ .‬ﭘﻮرت ﻣﻮازي در ﻣﻘﺎﺑﻞ اﺗﺼﺎل ﻛﻮﺗــﺎه و‬

‫ﻳﺎ اﺿﺎﻓﻪ ﺑﺎر ﭼﻨﺪان ﻣﻘﺎوم ﻧﻴﺴﺖ و ﻣﻤﻜﻦ اﺳﺖ ﺑﺎ ﻗﻄﻊ و وﺻﻞ ﺗﻐﺬﻳﻪ ﺑﻮرد‪ ،‬ﭘﻮرت آﺳﻴﺐ ﺑﺒﻴﻨﺪ‪.‬‬

‫در ﻣﻘﺎﺑﻞ ﭘﻮرت ﻣﻮازي‪ ،‬ﭘﻮرت ﺳﺮﻳﺎل ﻛﺎﻣﭙﻴﻮﺗﺮ ﺑﻪ ﺧﻮﺑﻲ ﺣﻔﺎﻇﺖ ﻣﻲﮔﺮدد‪ .‬دو ﻧﻮع ﻣﺪار واﺳﻂ ﺑﺮاي ﭘﻮرت ‪ COM‬وﺟـﻮد‬

‫دارد‪ .‬ﻧﻮع ﺳﺎدهﺗﺮ ﺑﺎ اﺳﺘﻔﺎدة ﻣﺴﺘﻘﻴﻢ از ﺧﻄﻮط ﭘﻮرت‪ ،‬ﭘﺎﻟﺴﻬﺎي ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻻزم را اﻳﺠﺎد ﻣﻲﻛﻨﺪ‪ .‬ﻧﻮع دوم‪ ،‬دﺳﺘﻮرات ﺑﺮﻧﺎﻣﻪرﻳﺰي و‬

‫اﻃﻼﻋﺎت ﺑﺮﻧﺎﻣﻪ را ﺑﻪ ﻣﺪار واﺳﻄﻪاي ﻣﻲﻓﺮﺳﺘﺪ‪ ،‬ﻛﻪ ﻣﺪار واﺳﻂ آﻧﻬﺎ را ﺗﻐﻴﻴﺮ داده و ﭘﺎﻟﺴﻬﺎي ﻻزم را ﺗﻮﻟﻴﺪ ﻣﻲﻛﻨﺪ‪ .‬اﻳﻦ ﻧﻮع از ﻣــﺪار‬

‫واﺳﻂ ﺑﻪ ﻧﻮﻋﻲ ﺗﻮاﻧﺎﻳﻲ ﭘﺮدازش ﻫﻢ ﻧﻴﺎز دارد ﻛﻪ اﺻﻮ ﹰﻻ ﺑﻪ ﻛﻤﻚ ﻳﻚ ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮ ﺗﺄﻣﻴﻦ ﻣﻲﮔﺮدد‪.‬‬

‫از آﻧﺠﺎﻳﻲ ﻛﻪ ﺻﻨﻌﺖ ﻛﺎﻣﭙﻴﻮﺗﺮ ﺑﻪ ﺳﻤﺖ ‪ ١USB‬ﺣﺮﻛﺖ ﻣﻲﻛﻨﺪ ﺑﺎ ﻛﺎﻣﭙﻴﻮﺗﺮﻫــﺎي ﻛﻴﻔـﻲ ﻛـﻪ ﺣﺘـﻲ ﺑـﻪ ﭘﻮرﺗـﻬﺎي‬

‫ﺳﺮﻳﺎل و ﻣﻮازي ﻣﺠﻬﺰ ﻧﺸﺪهاﻧﺪ‪ ،‬اﻳﻦ ارﺗﺒﺎط ﺑﺴﻴﺎر ﻣﻬﻢ ﺧﻮاﻫﺪ ﺑﻮد‪ .‬ﺳﺨﺖاﻓﺰار آﻣﺎده ﺑﺮاي ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺑﻪ ﻛﻤــﻚ ‪ USB‬ﻧـﻴﺰ وﺟـﻮد‬

‫دارد ﻛﻪ راﺟﻊ ﺑﻪ آن ﺻﺤﺒﺘﻲ ﻧﺨﻮاﻫﻴﻢ ﻛﺮد‪.‬‬

‫ﺷﺮﻛﺖ ‪ ،Atmel‬ﭘﺲ از ﺗﻮﻟﻴﺪ ‪ ،AVR‬ﻛﻴﺘﻬﺎي آﻣﺎدهاي را ﺑﺮاي اﻓﺮاد ﺗﺎزه ﻛﺎري ﻛﻪ ﻗﺼــﺪ دارﻧـﺪ ﻛـﺎر ﺑـﺎ ‪ AVR‬را ﻓـﺮا‬

‫ﮔﻴﺮﻧﺪ ﻃﺮاﺣﻲ ﻧﻤﻮد‪ .‬اﻳﻦ ﻛﻴﺘﻬﺎ ﺑﻪ ﮔﻮﻧﻪاي ﻃﺮاﺣﻲ ﺷﺪهاﻧﺪ ﺗﺎ ﻓﺮد ﺑﻪ ﻛﻤﻚ اﻳﻦ ﻛﻴﺘﻬﺎ‪ ،‬اﻣﻜﺎن ﺑﻪ ﻛﺎرﮔﻴﺮي ﺗﻤــﺎم اﻣﻜﺎﻧـﺎت ‪ AVR‬را‬

‫داﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬وﻟﻲ آﻧﭽﻪ در ﻣﻮرد اﻳﻦ ﻛﻴﺘﻬﺎ ﺑﺮاي ﻣﺎ ﻣﻬﻢ اﺳﺖ‪ ،‬ﺗﻨﻬﺎ ﺷﻴﻮه اﺗﺼﺎل آﻧﻬﺎ ﺑﻪ ﻛﺎﻣﭙﻴﻮﺗﺮ اﺳﺖ‪ .‬اﻳﻦ ﻛﻴﺘــﻬﺎ ﺑـﻪ ﭼﻨـﺪ دﺳـﺘﻪ‬

‫ﺗﻘﺴﻴﻢ ﻣﻲﺷﻮﻧﺪ ﻛﻪ ﻫﺮ ﻳﻚ ﺗﻨﻬﺎ ﺑﺮاي ﻛﺎر ﺑﺎ ﺗﻌﺪادي از اﻧﻮاع ﺗﺮاﺷﻪﻫﺎ ﻃﺮاﺣﻲ ﺷﺪهاﻧﺪ‪ .‬در اداﻣﻪ ﭼﻨﺪ ﻣﻮرد از آﻧﻬﺎ را ذﻛﺮ ﻣﻲﻛﻨﻴﻢ‪:‬‬

‫‪Kanda systems STK200+/300‬‬

‫‪١‬‬
‫‪Universal Serial Bus‬‬

‫‪١٤‬‬
 ‫‪Atmel STK500/AVRISP‬‬
‫‪Dentronics DT006‬‬
‫‪Vogel Elektronik VTEC-ISP‬‬
‫‪Futurlec JRAVR‬‬
‫‪Microtronics ATCPU/Mega2000‬‬
‫آﻧﭽﻪ در اﻳﻨﺠﺎ ﻣﺪﻧﻈﺮ ﻣﺎﺳﺖ ﻣﺪار واﺳﻂ ﺑﺮاي ﺑﺮﻗﺮاري ارﺗﺒﺎط ‪ ،ISP‬در ﻧــﻮع ‪ STK200/STK300‬اﺳـﺖ‪STK200 .‬‬

‫ﺑﺮاي ﻛﺎر ﺑﺎ ﭘﺮدازﻧﺪهﻫﺎي ‪ AVR‬و ‪ STK300‬ﺑﺮاي ﻛﺎر ﺑﺎ ﭘﺮدازﻧﺪهﻫﺎي ‪ ATMega‬ﻃﺮاﺣﻲ ﺷﺪهاﻧﺪ‪ .‬اﻳﻦ دو ﺑﻮرد ﺳــﺎﺧﺘﺎر ﺑﺴـﻴﺎر‬

‫ﻣﺸﺎﺑﻬﻲ دارﻧﺪ و ﺗﻨﻬﺎ ﺗﻔﺎوت ﺑﻴﻦ آﻧﻬﺎ در ﻣﺤﻞ ﻗﺮارﮔﻴﺮي ﺳﻴﻢ ﻣﺮﺑﻮط ﺑﻪ ﺷﻨﺎﺳﺎﻳﻲ ﺑﻮرد ﻣﻲﺑﺎﺷﺪ‪ .‬ﻣﺪار ﻣﺮﺑﻮط ﺑﻪ اﻳﻦ ﻣﺪﻟﻬﺎ در ﺷﻜﻞ‬

‫)‪ (٣-٢‬ﻧﺸﺎن داده ﺷﺪه اﺳﺖ ﻛﻪ اﻟﺒﺘﻪ ﭼﻨﺪان ﻫﻢ ﭘﻴﭽﻴﺪه ﻧﻴﺴﺖ‪ .‬ﻣﻤﻜﻦ اﺳﺖ در اوﻟﻴﻦ ﻧﮕﺎه ﻓﺮﻳﺒﻨﺪه ﺑﺎﺷﺪ‪ ،‬ﭼﺮا ﻛﻪ ﺷــﻜﻞ ﺑﻴـﺶ از‬

‫ﺣﺪ ﻧﻴﺎز ﭘﻴﭽﻴﺪه ﺷﺪه اﺳﺖ‪.‬‬

‫‪Minimum Hardware for working with AVRs‬‬

‫‪VCC=+5v‬‬
‫‪ISP Adapter‬‬
‫‪1‬‬
‫‪14‬‬
‫‪2‬‬ ‫‪1‬‬ ‫‪40‬‬
‫‪15‬‬ ‫‪2‬‬ ‫‪18‬‬ ‫‪2‬‬ ‫)‪PB0(XCK-T0) PA0(ADC0‬‬ ‫‪39‬‬
‫‪1A1‬‬ ‫‪1Y1‬‬ ‫‪100k‬‬ ‫)‪PB1(T1‬‬ ‫)‪PA1(ADC1‬‬
‫‪3‬‬ ‫‪4‬‬ ‫‪16‬‬ ‫‪3‬‬ ‫‪38‬‬
‫‪16‬‬ ‫‪6‬‬ ‫‪1A2‬‬ ‫‪1Y2‬‬ ‫‪14‬‬ ‫‪4‬‬ ‫)‪PB2(INT2-AIN0)PA2(ADC2‬‬ ‫‪37‬‬
‫‪4‬‬ ‫‪8‬‬ ‫‪1A3‬‬ ‫‪1Y3‬‬ ‫‪12‬‬ ‫‪5‬‬ ‫)‪PB3(OC0-AIN1)PA3(ADC3‬‬ ‫‪36‬‬
‫‪17‬‬ ‫‪1A4‬‬ ‫‪1Y4‬‬ ‫‪6‬‬ ‫)‪PB4(SS‬‬ ‫)‪PA4(ADC4‬‬ ‫‪35‬‬
‫‪5‬‬ ‫‪11‬‬ ‫‪9‬‬ ‫‪7‬‬ ‫)‪PB5(MOSI‬‬ ‫)‪PA5(ADC5‬‬ ‫‪34‬‬
‫‪18‬‬ ‫‪13‬‬ ‫‪2A1‬‬ ‫‪2Y1‬‬ ‫‪7‬‬ ‫‪8‬‬ ‫)‪PB6(MISO‬‬ ‫)‪PA6(ADC6‬‬ ‫‪33‬‬
‫‪6‬‬ ‫‪15‬‬ ‫‪2A2‬‬ ‫‪2Y2‬‬ ‫‪5‬‬ ‫)‪PB7(SCK‬‬ ‫)‪PA7(ADC7‬‬
‫‪19‬‬ ‫‪17‬‬ ‫‪2A3‬‬ ‫‪2Y3‬‬ ‫‪3‬‬ ‫‪9‬‬
‫‪7‬‬ ‫‪2A4‬‬ ‫‪2Y4‬‬ ‫‪10‬‬ ‫‪RESET‬‬ ‫‪32‬‬
‫‪20‬‬ ‫‪1‬‬ ‫‪11‬‬ ‫‪VCC‬‬ ‫‪AREF‬‬ ‫‪31‬‬
‫‪8‬‬ ‫‪19‬‬ ‫‪1OE‬‬ ‫‪GND‬‬ ‫‪GND‬‬ ‫‪30‬‬
‫‪21‬‬ ‫‪2OE‬‬ ‫‪27pf‬‬ ‫‪12‬‬ ‫‪AVCC‬‬
‫‪9‬‬ ‫‪20‬‬ ‫‪4MHZ‬‬ ‫‪XTAL2‬‬
‫‪22‬‬ ‫‪VCC GND‬‬ ‫‪13‬‬
‫‪10‬‬ ‫‪10‬‬ ‫‪27pf‬‬ ‫‪XTAL1‬‬ ‫‪29‬‬
‫‪23‬‬ ‫‪74HC244‬‬ ‫)‪PC7(TOSC2‬‬ ‫‪28‬‬
‫‪11‬‬ ‫‪14‬‬ ‫)‪PC6(TOSC1‬‬ ‫‪27‬‬
‫‪24‬‬ ‫‪15‬‬ ‫)‪PD0(RXD‬‬ ‫)‪PC5(TDI‬‬ ‫‪26‬‬
‫‪12‬‬ ‫‪16‬‬ ‫)‪PD1(TXD‬‬ ‫)‪PC4(TDO‬‬ ‫‪25‬‬
‫‪25‬‬ ‫‪17‬‬ ‫)‪PD2(INT0‬‬ ‫)‪PC3(TMS‬‬ ‫‪24‬‬
‫‪13‬‬ ‫‪0.1u‬‬ ‫‪18‬‬ ‫)‪PD3(INT1‬‬ ‫)‪PC2(TCK‬‬ ‫‪23‬‬
‫‪19‬‬ ‫)‪PD4(OC1B‬‬ ‫)‪PC1(SDA‬‬ ‫‪22‬‬
‫‪20‬‬ ‫)‪PD5(OC1A‬‬ ‫)‪PC0(SCL‬‬ ‫‪21‬‬
‫‪CONNECTOR DB25‬‬ ‫)‪PD6(ICP‬‬ ‫)‪PD7(OC2‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪ATMega32L‬‬

‫‪VCC=+5v‬‬

‫‪100k‬‬

‫‪SW1‬‬
‫‪0.1u‬‬

‫‪0‬‬
‫‪Reset Circuit‬‬

‫ﺷﮑﻞ ‪ ٣ -٢‬ﺣﺪاﻗﻞ ﺳﺨﺖ اﻓﺰار ﻻزم ﺑﺮاى ﮐﺎر ﺑﺎ ‪AVR‬‬

‫اﻳﻦ واﺳﻄﻪ ﺣﺘﻲ ﻣﻲﺗﻮاﻧﺪ ﺑﺪون ﻫﻴﭻ ﻗﻄﻌﻪ اﻟﻜﺘﺮوﻧﻴﻜﻲ ﻫﻢ ﺳﺎﺧﺘﻪ ﺷﻮد‪ ،‬وﻟﻲ اﮔﺮ آي ﺳﻲ ﺑﺎﻓﺮ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷــﺪ ﺑـﺎﻳﺪ‬

‫ﻣﺮاﻗﺐ ﺑﺎﺷﻴﻢ ﺗﺎ ﭘﻴﻨﻬﺎي ﻣﺮﺑﻮط ﺑﻪ ﺑﺮﻧﺎﻣﻪرﻳﺰي را ﺑﻪ ﻣﺪار دﻳﮕﺮي ﻣﺘﺼﻞ ﻧﻜﻨﻴﻢ‪ .‬اﻟﺒﺘﻪ در ﺻﻮرت اﺳﺘﻔﺎده از اﻳﻦ ﻣﺪار‪ ،‬ﻫﻨﻮز ﻫﻢ ﺑــﺎﻳﺪ‬

‫‪١٥‬‬
‫در ﻣﻮرد ﭘﻴﻨﻬﺎي ‪٢ MISO، ١MOSI‬و ‪ ٣ SCK‬اﺣﺘﻴﺎط ﻧﻤﺎﻳﻴﻢ‪ .‬واﺿﺢ اﺳﺖ ﻛﻪ ﻣﺎ ﺑﺎﻳﺪ در زﻣﺎن ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻣﻄﻤﺌــﻦ ﺷـﻮﻳﻢ ﻛـﻪ‬

‫اﻳﻦ ﭘﻴﻨﻬﺎ ﺗﻮﺳﻂ وﺳﻴﻠﻪﻫﺎي ﺧﺎرﺟﻲ دﻳﮕﺮ ﺑﻪ ‪ GND‬ﻳﺎ ‪ Vcc‬ﻣﺘﺼﻞ ﻧﺸﺪه ﺑﺎﺷﻨﺪ‪.‬‬

‫در زﻣﺎﻧﻲ ﻛﻪ ‪ AVR‬در ﺣﺎﻟﺖ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻧﻴﺴﺖ‪ 74HC244 ،‬ﺑﻪ ﻋﻨﻮان ﻳﻚ ﻣﺪار اﻳﺰوﻟﻪ ﻛﻨﻨﺪه ﻋﻤﻞ ﻣﻲﻛﻨــﺪ‪ .‬در اﻳـﻦ‬

‫ﺣﺎﻟﺖ ﺗﻤﺎم ﺧﺮوﺟﻲﻫﺎ اﻣﭙﺪاﻧﺲ ﺑﺎﻻ ﻣﻲﺷﻮﻧﺪ‪ ،‬ﺑﻪ ﻃﻮري ﻛﻪ ﺑﺮ ﻋﻤﻠﻜﺮد ﺗﺮاﺷﻪ ﺗﺄﺛﻴﺮ ﻧﺨﻮاﻫﻨﺪ ﮔﺬاﺷﺖ‪.‬‬

‫زﻣﺎﻧﻲ ﻛﻪ ﺣﺎﻟﺖ ‪ ISP‬اﻧﺘﺨﺎب ﮔﺮدد‪ ،‬ﻧﻴﻤﺔ ﭘﺎﻳﻴﻦ ‪ 74HC244‬ﻓﻌﺎل ﻣﻲﺷــﻮد و ﺧـﻂ‪ RESET‬از ﺳﻴﺴـﺘﻢ ﻣﻮردﻧﻈـﺮ را‬

‫زﻣﻴﻦ ﻣﻲﻛﻨﺪ‪ .‬اﻳﻦ ﻋﻤﻞ ﺗﻮﺳﻂ ﺳﻪ ﺑﺎﻓﺮ ﺻﻮرت ﻣﻲﮔﻴﺮد و از آﻧﺠﺎﻳﻲ ﻛﻪ ﺑﺎﻳﺪ ﺧﺎزن ﻣﺮﺑﻮط ﺑــﻪ ﻣـﺪار ‪ RESET‬در ﺗﺮاﺷـﻪ دﺷـﺎرژ‬

‫ﮔﺮدد‪ ،‬اﻳﻦ ﻛﺎر ﺑﻪ ﺧﻮﺑﻲ اﻧﺠﺎم ﻣﻲﺷﻮد‪ .‬زﻣﺎﻧﻲ ﻛﻪ ﺗﺮاﺷﻪ در ﺣﺎﻟﺖ ‪ RESET‬ﻗﺮار ﮔﺮﻓﺖ‪ ،‬ﺑﺎ ﻓﺮض اﻳﻦ ﻛﻪ ﺧﻄﻮط ‪MOSI, ،SCK‬‬

‫‪ MISO‬در ﺗﺮاﺷﻪ‪ ،‬ﺗﺤﺖ ﺗﺄﺛﻴﺮ ﻫﻴﭻ ﻣﺪار ﺟﺎﻧﺒﻲ ﻗﺮار ﻧﺪاﺷﺘﻪ ﺑﺎﺷﻨﺪ‪ ،‬زﻣــﺎن آن اﺳـﺖ ﺗـﺎ ﻧﻴـﻤﻪ ﺑـﺎﻻﻳﻲ ‪ 74HC244‬ﻓﻌـﺎل ﮔﺮدد و‬

‫ﺧﻄﻮط ‪ MOSI, MOSI‬را دراﻳﻮ ﻧﻤﺎﻳﺪ‪.‬‬

‫دو اﺗﺼﺎل ﻛﻮﺗﺎه ﻣﻮﺟﻮد درﻛﺎﻧﻜﺘﻮر ﭘﻮرت ﭘﺮﻳﻨﺘﺮ ﺗﻮﺳﻂ ﻛﺎﻣﭙﻴﻮﺗﺮ‪،‬ﺟﻬﺖ ﺷﻨﺎﺳﺎﻳﻲ ﭘﺮوﮔﺮاﻣﺮ اﺳﺘﻔﺎده ﻣﻲﺷﻮﻧﺪ‪ .‬اﺗﺼﺎل ﻛﻮﺗﺎه‬

‫ﭘﻴﻨﻬﺎي ‪ ٢‬و ‪ ١٢‬ﺑﻪ ﻋﻨﻮان ﺧﻂ ﺗﺸﺨﻴﺺ ﺑﺮاي ‪ STK200‬و اﺗﺼﺎل ﻛﻮﺗﺎه ﭘﻴﻨﻬﺎي ‪ ٣‬و ‪١٣‬ﺑﻪ ﻋﻨﻮان ﺧﻂ ﺗﺸﺨﻴﺺ ﺑﺮاي ‪STK300‬‬

‫ﺑﻪ ﻛﺎر ﻣﻲروﻧﺪ و ﻫﺮ دوي آﻧﻬﺎ ﻣﻲﺗﻮاﻧﻨﺪ ﺑﻪ ﻃﻮر ﻫﻤﺰﻣﺎن ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﻫﻢ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﻨﺪ‪.‬‬

‫ﻻزم ﺑﻪ ذﻛﺮ اﺳﺖ‪ ،‬در ﺻﻮرﺗﻲ ﻛﻪ ﻗﺼﺪ دارﻳﺪ ﺗﺎ ﺑﻪ ﺟﺎي ‪ Atmega32L‬از ﺗﺮاﺷﻪ دﻳــﮕﺮي اﺳـﺘﻔﺎده ﻛﻨﻴـﺪ‪،‬ﺑـﺮاي ﺑﺮﻧﺎﻣـﻪ‬

‫رﻳﺰي آن ﺗﻨﻬﺎ ﻛﺎﻓﻲ اﺳﺖ ﺗﺎ ﭘﺎﻳﻪ ﻫﺎي ‪ MOSI, MISO, SCK, RESET‬را ﻫﻤﺎﻧﻨﺪ ﻣﺪار ﻗﺒﻞ ﺑﻪ ﻛﺎﺑﻞ ‪ ISP‬ﻣﺘﺼﻞ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﻼ ﻫﻢ ﮔﻔﺘﻪ ﺷﺪ‪ ،‬زﻣﺎﻧﻲ ﻛﻪ ﻗﺮار اﺳﺖ از ‪ AVR‬در ﻣﺪ ‪ ISP‬اﺳﺘﻔﺎده ﺷــﻮد‪ ،‬ﺑـﻮرد ﻣـﻮرد ﻧﻈـﺮ ﺑـﺎﻳﺪ ﺑـﻪ‬
‫ﻫﻤﺎن ﻃﻮر ﻛﻪ ﻗﺒ ﹰ‬

‫ﮔﻮﻧﻪاي ﻃﺮاﺣﻲ ﺷﻮد ﺗﺎ ﭘﻴﻨﻬﺎي ‪ (MOSI, MISO, SCK, RESET) ISP‬ﺑﺮاي اﻳﻦ ﻋﻤﻞ ذﺧﻴﺮه ﮔﺮدﻧﺪ‪ ،‬ﺑﺎ اﻳﻦ ﺣــﺎل ﻣﻤﻜـﻦ‬

‫اﺳﺖ در ﻋﻤﻞ ﺗﻌﺪاد ﭘﻮرﺗﻬﺎ ﻛﺎﻓﻲ ﻧﺒﺎﺷﺪ‪.‬‬

‫در ﺻﻮرﺗﻲ ﻛﻪ ﻣﻮارد ﻻزم رﻋﺎﻳﺖ ﮔﺮدد ﭘﻴﻨﻬﺎي ‪ ISP‬ﻣﻲﺗﻮاﻧﻨﺪ ﺑﻪ ﺻﻮرت ﻣﺸﺘﺮك ﺑﺮاي ﻋﻤﻞ‪ ISP‬و ﻧﻴﺰ ﺑﻪ ﻋﻨﻮان ‪ I/O‬ﺑﻪ‬

‫ﻛﺎر روﻧﺪ‪ .‬ﺑﺮاي اﻳﻦ ﻣﻨﻈﻮر درﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻣﻮارد زﻳﺮ ﺿﺮوري اﺳﺖ‪).‬ﺷﻜﻞ ‪(٤-٢‬‬

‫‪ -١‬ﻗﺮار دادن ﻳﻚ ﻣﻘﺎوﻣﺖ ﺑﻴﻦ ﭘﻴﻦ ‪ RESET‬و ﻣﺪار ‪ ،RESET‬در اﻳﻦ ﺻﻮرت ﻣﺪار ‪ RESET‬اﺧﺘﻼﻟــﻲ‬

‫اﻳﺠﺎد ﻧﺨﻮاﻫﺪ ﻛﺮد‪.‬‬

‫‪١‬‬
‫‪Master Out Slave In‬‬
‫‪٢‬‬
‫‪Master In Slave Out‬‬
‫‪٣‬‬
‫‪Serial Clock‬‬

‫‪١٦‬‬
 ‫ﺷﻜﻞ ‪ ٤ -٢‬ﻣﻼﺣﻈﺎت ﻻزم ﺑﺮاي ﻣﺪار ‪ISP‬‬

‫‪ -٢‬ﻣﻄﻤﺌﻦ ﺷﻮﻳﺪ ﻛﻪ ﻋﻤﻞ ‪ ،ISP‬ﻫﻴﭻ ﻋﻤﻞ دﻳﮕﺮي را ﺗﺤﺖ ﺗﺄﺛﻴﺮ ﻗﺮار ﻧﻤﻲدﻫﺪ‪.‬‬

‫‪ -٣‬در ﺣﻴﻦ ﻋﻤﻞ ‪ ،ISP‬از دراﻳﻮ ﻛﺮدن ﻣﺪارﻫﺎي ﺧﺮوﺟﻲ ﺧﻮدداري ﻛﻨﻴﺪ و ﻳﺎ ﺑﺎﻳﺪ ازﻳﻚ ﻣﻘــﺎوﻣﺖ اﺳـﺘﻔﺎده‬

‫ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ -٤‬از اﺗﺼﺎل ﺑﺎرﻫﺎي ﺳﻨﮕﻴﻦ ﻛﻪ ﺑﺮ روي ﻋﻤﻞ ‪ ISP‬ﺗﺄﺛﻴﺮ ﻣﻲﮔﺬارﻧﺪ ﺧﻮدداري ﻛﻨﻴﺪ‪.‬‬

‫ﻻزم ﺑﻪ ذﻛﺮ اﺳﺖ‪ ،‬در ﺻﻮرﺗﻲ ﻛﻪ ﻗﺼﺪ دارﻳﺪ ﺗﺎ ‪ ATMega128‬را ﺑــﻪ روش ‪ ISP‬ﺑﺮﻧﺎﻣـﻪرﻳﺰي ﻧﻤـﺎﻳﻴﺪ از آﻧﺠـﺎﻳﻲ ﻛـﻪ‬

‫ﺧﻄﻮط ورودي و ﺧﺮوﺟﻲ ‪ SPI‬ﺑﺎ ﺧﻄﻮط ارﺳﺎل و درﻳﺎﻓﺖ اوﻟﻴﻦ ‪ UART‬در ﺗﺮاﺷﻪ ﻣﺸﺘﺮك ﻫﺴــﺘﻨﺪ‪ .‬ﺑـﺮاي ﺟﻠـﻮﮔﻴـﺮي از ﺑـﺮوز‬

‫ﻣﺸﻜﻞ از ﺳﺨﺖاﻓﺰار ﺑﻴﺸﺘﺮي اﺳﺘﻔﺎده ﻣﻲﺷﻮد و ﭘﻴﻨﻬﺎي آن ﻫﻢ ﺗﻔﺎوت ﻣﻲﻛﻨﺪ ﻛﻪ اﻳﻦ ﻣﻄﻠﺐ ﺑﻪ ﺧﻮاﻧﻨﺪه واﮔﺬار ﻣﻲﺷﻮد‪.‬‬

‫در ﭘﺎﻳﺎن ﻻزم اﺳﺖ ﺑﻪ اﻳﻦ ﻧﻜﺘﻪ ﻫﻢ ﺗﻮﺟﻪ ﻛﻨﻴﺪ؛ در ﺻﻮرﺗﻲ ﻛﻪ ﺷﻤﺎ ﻓﻴﻮزﻫﺎي ‪ AVR‬را ﺑﻪ ﻃﻮر ﻏــﻴﺮﺻﺤﻴﺢ ﺑﺮﻧﺎﻣـﻪرﻳﺰي‬

‫ﻧﻤﺎﻳﻴﺪ ﻣﻤﻜﻦ اﺳﺖ ﻛﺮﻳﺴﺘﺎل و ﻧﻮﺳﺎﻧﮕﺮ داﺧﻠﻲ از ﻛﺎر ﺑﻴﻔﺘﺪ‪ .‬ﻳﻜﻲ از ﺑﺪﺗﺮﻳﻦ ﻛﺎرﻫﺎﻳﻲ ﻛﻪ ﺷﻤﺎ ﻣﻲﺗﻮاﻧﻴﺪ اﻧﺠــﺎم دﻫﻴـﺪ ﺑﺮﻧﺎﻣـﻪرﻳﺰي‬

‫ﻏﻴﺮﺻﺤﻴﺢ ﻓﻴﻮزﻫﺎ و ﻏﻴﺮﻓﻌﺎل ﻛﺮدن اﻣﻜﺎن ‪ JTAG, ISP‬اﺳﺖ‪ .‬در اﻳﻦ ﺣﺎﻟﺖ ﻫﻴﭻ راﻫﻲ ﺟﺰ ﺗﻌﻮﻳﺾ ﺗﺮاﺷﻪ ‪ AVR‬وﺟــﻮد ﻧـﺪارد‪،‬‬

‫اﻟﺒﺘﻪ ﺷﻤﺎ ﻫﻨﻮز ﻫﻢ ﻣﻲﺗﻮاﻧﻴﺪ آن را ﺑﻪ ﺣﺎﻟﺖ اول ﺑﺎزﮔﺮداﻧﻴﺪ وﻟﻲ اﻳﻦ ﻛﺎر ﺗﻨﻬﺎ از ﻃﺮﻳﻖ ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻣﻮازي ﻣﻴﺴــﺮ ﺧﻮاﻫـﺪ ﺑـﻮد ﻛـﻪ‬

‫اﺻﻮ ﹰﻻ ﻛﺎر ﻣﺸﻜﻠﻲ اﺳﺖ و اﻣﻜﺎﻧﺎت ﺧﺎص ﺧﻮد را ﻣﻲﻃﻠﺒﺪ‪.‬‬

‫‪١٧‬‬
 ‫ﻓﺼﻞ ﺳﻮم‬

‫آﺷﻨﺎﻳﻲ ﺑﺎ ‪Codevision AVR‬‬

‫‪ Codevision AVR‬ﻳﻚ ﻛﺎﻣﭙﺎﻳﻠﺮ ‪ ،C‬ﻣﺤﻴﻂ ﺗﻮﺳﻌﻪ ﻳﺎﻓﺘﻪ ﻳﻜﭙﺎرﭼــﻪ)‪ (١IDE‬و ﺗﻮﻟﻴﺪﻛﻨﻨـﺪة ﺧﻮدﻛـﺎر ﻛﺪﻫـﺎي‬

‫ﺑﺮﻧﺎﻣﻪ اﺳﺖ ﻛﻪ ﺑﺮاي ﻛﺎر ﺑﺎ ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫﺎي ‪ AVR‬ﺳﺎﺧﺖ ﺷﺮﻛﺖ ‪ ATMEL‬ﻃﺮاﺣﻲ ﺷﺪه اﺳﺖ‪.‬‬

‫ﺑﺮﻧﺎﻣﻪ ﻃﻮري ﻃﺮاﺣﻲ ﺷﺪه ﻛﻪ در وﻳﻨﺪوزﻫﺎي ‪ Xp,2000,NT, Me, 98, 95‬ﻗﺎﺑﻞ اﺟﺮا ﺑﺎﺷﺪ‪.‬‬

‫اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﻳﻚ ﭘﺮوﮔﺮاﻣﺮ ‪ ISP‬را ﻫﻢ ﺷﺎﻣﻞ ﻣﻲﺷﻮد ﻛﻪ اﻣﻜﺎن اﻧﺘﻘﺎل ﻛﺪﻫﺎي ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻣﻴﻜﺮوﻛﻨﺘﺮوﻟﺮﻫــﺎ را ﺑﻌـﺪ از اﻧﺠـﺎم‬

‫ﻣﻮﻓﻖ ﻋﻤﻞ ﻛﺎﻣﭙﺎﻳﻞ ﻓﺮاﻫﻢ ﻣﻲﻛﻨﺪ‪.‬‬

‫اﻳﻦ ﻧﺮم اﻓﺰار ﻋﻼوه ﺑﺮ ﻛﺘﺎﺑﺨﺎﻧﻪﻫﺎي ‪ C‬اﺳﺘﺎﻧﺪارد‪ ،‬داراي ﻛﺘﺎﺑﺨﺎﻧﻪﻫﺎي دﻗﻴﻘﻲ ﺑﺮاي ﻛﺎر ﺑﺎ ‪LCD‬ﻫــﺎي ﻛـﺎرﻛﺘﺮي‪ ،‬ﺗﻮﻟﻴـﺪ‬

‫وﻗﻔﻪ‪ ،‬ﺗﻨﻈﻴﻢ اﻧﺮژي ﻣﺼﺮﻓﻲ ﺗﺮاﺷﻪ‪ ،‬ﻗﺎﺑﻠﻴﺖ ‪ ، SPI‬ﻗﺎﺑﻠﻴﺖ ‪ ،I2C‬ارﺗﺒﺎط ﻳﻚ ﺳﻴﻤﻪ ‪ ،‬ﻛﺎر ﺑﺎ ﺳﻨﺴﻮرﻫﺎي دﻣــﺎي ‪DS1820 ،LM75‬‬

‫و ‪EEPROM‬ﻫﺎي ﺳﺮﻳﺎل اﺳﺖ‪.‬‬

‫‪١‬‬
‫‪Integrated Development Environment‬‬

‫‪١٨‬‬
 ‫ﺷﻜﻞ ‪ ١ -٣‬ﻧﺮم اﻓﺰار ‪CodevisionAVR‬‬

‫ﻋﻼوه ﺑﺮ اﻳﻦ ‪ ،CodewizardAVR, CodevisionAVR‬ﺗﻮﻟﻴﺪﻛﻨﻨﺪه ﺧﻮدﻛﺎر ﺑﺮﻧﺎﻣــﻪ را ﻫـﻢ ﺷـﺎﻣﻞ ﻣﻲﺷـﻮد‪ .‬اﻳـﻦ‬

‫ﺑﺮﻧﺎﻣﻪ اﻳﻦ اﻣﻜﺎن را ﺑﻪ ﻣﺎ ﻣﻲدﻫﺪ ﺗﺎ ﺑﺮاي ﺗﻨﻈﻴﻢ اﻣﻜﺎﻧﺎت ﻣﺨﺘﻠﻒ ﺗﺮاﺷﻪ از ﻗﺒﻴﻞ ﺗﺎﻳﻤﺮﻫﺎ‪ TWI, SPI, ADC ،‬و ‪ ...‬ﺑﺪون ﻧﻴــﺎز ﺑـﻪ‬

‫ﻧﻮﺷﺘﻦ ﻛﺪ ﺑﺮاي آﻧﻬﺎ ﺑﻪ ﺻﻮرت ﮔﺮاﻓﻴﻜﻲ ﺗﻨﻈﻴﻤﺎت اوﻟﻴﻪ ﻣﻮرد ﻧﻴﺎز را اﻧﺠﺎم دﻫﻴﻢ در اﻳﻦ ﺻــﻮرت ‪ Codewizard‬ﻛﺪﻫـﺎي ﻻزم را‬

‫ﺑﺮاي ﻣﺎ ﺗﻮﻟﻴﺪ ﻣﻲﻛﻨﺪ و ﺑﻪ اﻳﻦ ﺻﻮرت ﻣﻲﺗﻮاﻧﻴﻢ در ﻛﻤﺘﺮﻳﻦ زﻣﺎن ﻣﻤﻜﻦ ﺑﺮﻧﺎﻣﻪﻫﺎي ﺧﻮد را ﺑﻨﻮﻳﺴﻴﻢ‪.‬‬

‫در اﻳﻦ ﺑﺨﺶ ﻗﺼﺪ دارﻳﻢ ﺗﺎ اوﻟﻴﻦ ﺑﺮﻧﺎﻣﻪ ﺧﻮد را ﺑﻨﻮﻳﺴﻴﻢ و آن را اﺟﺮا ﻛﻨﻴﻢ‪ ،‬ﺗﺎ اﻳﻨﺠﺎ ﺷﻤﺎ ﺑﺎﻳﺪ ﻛﺎﺑﻞ ذﻛﺮ ﺷﺪه در ﺑﺨــﺶ‬

‫ﻗﺒﻞ را ﺳﺎﺧﺘﻪ و ﺣﺪاﻗﻞ ﻣﺪار ﻻزم را ﻧﻴﺰ آﻣﺎده ﻛﺮده ﺑﺎﺷﻴﺪ‪).‬ﺷــﻜﻞ ‪ (٣-٢‬ﻋـﻼوه ﺑـﺮ اﻳـﻦ ﺑـﺎﻳﺪ ﻧـﺮم اﻓـﺰار ‪ CodevisionAVR‬و‬

‫‪ AVRstudio‬را ﻫﻢ ﻧﺼﺐ ﻛﺮده ﺑﺎﺷﻴﺪ‪.‬ﺿﻤﻨﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺴﺨﻪ راﻳﮕﺎن ﻧﺮم اﻓﺰار ‪ CodevisionAVR‬را از آدرس اﻳﻨــﺘﺮﻧﺘﻲ زﻳـﺮ‬

‫درﻳﺎﻓﺖ ﻛﻨﻴﺪ‪:‬‬

‫‪http://www.hpinfotech.ro‬‬

‫ﺑﺮاي درﻳﺎﻓﺖ ﻧﺮم اﻓﺰار ‪ AVRStudio‬ﻫﻢ ﺑﻪ ﺳﺎﻳﺖ ﺷﺮﻛﺖ ‪ Atmel‬ﻣﺮاﺟﻌﻪ ﻧﻤﺎﻳﻴﺪ‪:‬‬

‫‪http://www.atmel.com‬‬

‫در اﻳﻦ ﻗﺴﻤﺖ ﻣﻲﺧﻮاﻫﻴﻢ ﺗﺎ ﻛﺎر را ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ ﺑﺮﻧﺎﻣﺔ ﺳﺎده آﻏﺎز ﻛﻨﻴﻢ و ﻳﻚ ‪ LED‬را ﺑﺎ ﻓﺮﻛﺎﻧﺲ ‪2Hz‬‬

‫ﺧﺎﻣﻮش و روﺷﻦ ﻛﻨﻴﻢ‪.‬‬

‫‪١٩‬‬
 ‫اﻳﺠﺎد ﻳﻚ ﭘﺮوژه ﺟﺪﻳﺪ‬
‫اوﻟﻴﻦ ﻛﺎر اﻳﺠﺎد ﭘﺮوژه ﺟﺪﻳﺪي ﺑﺮاي ﺑﺮﻧﺎﻣﺔ ﻣﻮردﻧﻈﺮ اﺳﺖ‪ .‬ﻣﻲﺗﻮاﻧﻴﺪ اﻳﻦ ﻛـﺎر را ﺑـﺎ اﺳـﺘﻔﺎده از ﻣﻨـﻮي ‪ File|New‬و ﻳـﺎ‬

‫ﻓﺸﺎر دادن دﻛﻤﺔ ‪ Create New File‬در ﻧﻮار اﺑﺰار اﻧﺠﺎم دﻫﻴﺪ‪.‬‬

‫ﺑﺎ اﻧﺠﺎم اﻳﻦ ﻛﺎر ﭘﻨﺠﺮهاي ﺑﺎز ﻣﻲﺷﻮد)ﺷﻜﻞ ‪ ،(٢-٣‬ﺷﻤﺎ ﺑﺎﻳﺪ ‪ File type|Project‬را اﻧﺘﺨﺎب ﻧﻤﻮده و دﻛﻤﻪ ‪ OK‬را‬

‫ﻓﺸﺎر دﻫﻴﺪ‪.‬‬

‫ﺷﻜﻞ ‪ ٢ -٣‬ﭘﻨﺠﺮه ‪Create New File‬‬

‫ﺣﺎﻻ ﭘﻨﺠﺮه دﻳﮕﺮي ﺑﺎز ﻣﻲﺷﻮد)ﺷﻜﻞ ‪ (٣-٣‬و از ﺷﻤﺎ ﺳــﺆال ﻣـﻲﮔﺮدد ﻛـﻪ آﻳـﺎ ﻣﻲﺧﻮاﻫﻴـﺪ ﭘـﺮوژه ﺟﺪﻳـﺪ را ﺑـﻪ ﻛﻤـﻚ‬

‫‪ CodewizardAVR‬اﻧﺠﺎم دﻫﻴﺪ‪.‬‬

‫ﺷﻜﻞ ‪ ٣ -٣‬ﭘﻨﺠﺮه ‪Confirm‬‬

‫در اﻳﻦ ﻗﺴﻤﺖ دﻛﻤﻪ ‪ No‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪ .‬ﺑﺎ اﻳﻦ ﻛﺎر ﭘﻨﺠﺮه ‪ Create New Project‬ﺑﺎز ﺧﻮاﻫﺪ ﺷﺪ)ﺷــﻜﻞ ‪ (٤-٣‬ﻛـﻪ‬

‫ﺑﺎﻳﺪ در آن ﻧﺎم ﻓﺎﻳﻞ ﭘﺮوژه و ﻣﺤﻞ آن را ﻣﺸﺨﺺ ﻧﻤﺎﻳﻴﺪ‪ .‬ﻓﺎﻳﻞ ﭘﺮوژه ﺑﺎ ﭘﺴﻮﻧﺪ ‪ ،prj‬ذﺧﻴﺮه ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫‪٢٠‬‬
 ‫ﺷﻜﻞ ‪ ٤ -٣‬ﭘﻨﺠﺮه ‪Create New Project‬‬

‫ﺣﺎﻻ ﭘﻨﺠﺮه ﺟﺪﻳﺪي ﺑﺎز ﻣــﻲ ﺷـﻮد ﻛـﻪ ﻣﺮﺑـﻮط ﺑـﻪ ﺗﻨﻈﻴﻤـﺎت ﻛﺎﻣﭙـﺎﻳﻠﺮ اﺳـﺖ)ﺷـﻜﻞ ‪ ،(٥-٣‬اﺑﺘـﺪا در ﻗﺴـﻤﺖ ‪C‬‬

‫‪ ،Compiler|Code Generation‬ﮔﺰﻳﻨــﺔ ‪ ،Chip‬ﻧـﻮع ﺗﺮاﺷـﺔ ‪ AVR‬را ﺑﺮاﺑـﺮ ‪ Atmega32L‬ﻗـﺮار داده‪ ،‬ﺳـﭙﺲ در ﮔﺰﻳـﻨﻪ‬

‫‪ Clock‬ﻣﻘﺪار ﻛﺮﻳﺴﺘﺎل ﻣﺘﺼﻞ ﺑﻪ ﺗﺮاﺷﻪ را ﺑﺮاﺑﺮ ‪ 4MHz‬اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ و دﻛﻤﻪ ‪ OK‬را ﻓﺸﺎر دﻫﻴﺪ‪).‬ﺷﻜﻞ ‪(٦-٣‬‬

‫‪٢١‬‬
 Files ‫ ﻗﺴﻤﺖ‬Configure Project ‫ ﭘﻨﺠﺮه‬٥ -٣ ‫ﺷﻜﻞ‬

٢٢
 ‫ﺷﮑﻞ ‪ ٦ -٣‬ﭘﻨﺠﺮه ‪ Configure Project‬ﻗﺴﻤﺖ ‪C Compiler‬‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ ﻓﺎﻳﻞ اﺻﻠﻲ ﭘﺮوژه ﻛﻪ ﻛﺪﻫﺎي ﺑﺮﻧﺎﻣﻪ در آن ﻗﺮار دارد را اﻳﺠﺎد ﻛﻨﻴﺪ‪).‬ﺷﻜﻞ ‪ (٧-٣‬ﺑــﺮاي اﻳـﻦ ﻛـﺎر دوﺑـﺎره ﻣﻨـﻮي‬

‫‪ File|New‬و ﻳﺎ دﻛﻤﻪ ‪ Create New File‬در ﻧﻮار اﺑﺰار را اﻧﺘﺨﺎب ﻧﻤﻮده و ﮔﺰﻳﻨﻪ ‪ File Type|Source‬را اﻧﺘﺨـﺎب و دﻛـﻤﻪ‬

‫‪ OK‬را ﻓﺸﺎر دﻫﻴﺪ‪.‬‬

‫ﺷﻜﻞ ‪ ٧ -٣‬ﭘﻨﺠﺮه ‪Create New File‬‬

‫‪٢٣‬‬
 ‫ﺑﺮاي ﻓﺎﻳﻞ ﺟﺪﻳﺪ اﻳﺠﺎد ﺷﺪه ﭘﻨﺠﺮه ﺟﺪﻳﺪي ﻇﺎﻫﺮ ﻣﻲﮔﺮدد‪ .‬ﻧﺎم ﻓﺎﻳﻞ ﺟﺪﻳﺪ ‪ untitled.c‬اﺳﺖ‪ .‬ﺑﺎ اﺳﺘﻔﺎده از ﻣﻨﻮي‬

‫‪ ،File‬ﮔﺰﻳﻨﻪ ‪ Save As‬ﻧﺎم ﻓﺎﻳﻞ را ﺑﻪ ‪ main.c‬ﺗﻐﻴﻴﺮ دﻫﻴﺪ‪.‬‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ ﻛﺪﻫﺎي ﺑﺮﻧﺎﻣﻪ زﻳﺮ را در آن وارد ﻧﻤﺎﻳﻴﺪ‪ .‬ﺑﻌﺪ از اﻧﺠﺎم اﻳﻦ ﻛﺎر ﻣﺤﺘﻮﻳﺎت آن را ذﺧﻴﺮه ﻛﻨﻴﺪ‪.‬‬

‫>‪#include <mega32.h‬‬
‫>‪#include <delay.h‬‬
‫‪/*This is a test program written to flashes‬‬
‫‪the LED on PORTA.0 with a period of 0.5 second*/‬‬
‫)(‪main‬‬
‫{‬
‫‪while(1){/*loop forever*/‬‬
‫;‪PORTA.0=1‬‬
‫;)‪delay_ms(250‬‬
‫;‪PORTA.0=0‬‬
‫;)‪delay_ms(250‬‬
‫}‬
‫}‬
‫دﺳﺘﻮر >‪ #include <mega32.h‬ﻓﺎﻳﻞ ﺳﺮآﻣﺪ ‪ mega32.h‬را ﻛــﻪ ﺷـﺎﻣﻞ ﺗﻌﺮﻳـﻒ رﺟﻴﺴـﺘﺮﻫﺎي ‪ATMega32L‬‬

‫اﺳﺖ‪ ،‬ﺑﻪ ﭘﺮوژه اﺿﺎﻓﻪ ﻣﻲ ﻛﻨﺪ‪.‬زﻣﺎﻧﻲ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ در ﺑﺮﻧﺎﻣﻪ ﺗﺎﺧﻴﺮي اﻳﺠﺎد ﻛﻨﻴﻢ‪ .‬اﺑﺘــﺪا ﺑـﺎﻳﺪ ﻓـﺎﻳﻞ ‪ delay.h‬را ﺑـﻪ ﻛﻤـﻚ دﺳـﺘﻮر‬

‫>‪ #include <delay.h‬ﺑﻪ ﭘﺮوژه اﺿﺎﻓﻪ ﻧﻤﺎﻳﻴﻢ‪.‬ﻗﺴﻤﺖ اﺻﻠﻲ ﻫﺮ ﺑﺮﻧﺎﻣﻪ ﺑﺎ )(‪ main‬آﻏﺎز ﻣﻲ ﺷﻮد‪.‬دﺳﺘﻮر )‪ while(1‬ﺣﻠﻘﻪ اي را‬

‫ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﺷﺮط آن ﻫﻤﻮاره درﺳﺖ اﺳﺖ ودﺳﺘﻮرات داﺧــﻞ آن ﻣـﺪام ﺗﻜـﺮار ﻣـﻲ ﺷـﻮد‪.‬دﺳـﺘﻮر )‪ delay_ms(250‬ﻧـﻴﺰ‬

‫ﺗﺎﺧﻴﺮي ﺑﺮاﺑﺮ ‪ ٢٥٠‬ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ ﺗﻮﻟﻴﺪ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫در ﺻﻮرﺗﻲ ﻛﻪ ﺳﺨﺖ اﻓﺰار ﻣﻮﺟﻮد در ﻓﺼﻞ ﻗﺒﻞ را آﻣــﺎده ﻛـﺮده اﻳـﺪ ﺗﻨـﻬﺎ ﻛـﺎﻓﻲ اﺳـﺖ اﻟﻤﺎﻧـﻬﺎي زﻳـﺮ را ﺑـﻪ آن اﺿﺎﻓـﻪ‬

‫ﻛﻨﻴﺪ‪).‬ﺷﻜﻞ ‪(٨-٣‬‬

‫‪ATMega32L‬‬ ‫‪LED‬‬
‫‪40‬‬
‫)‪PA0(ADC0‬‬

‫‪39‬‬ ‫‪330‬‬
‫)‪PA1(ADC1‬‬

‫‪38‬‬
‫)‪PA2(ADC2‬‬

‫ﺷﻜﻞ ‪ ٨ -٣‬ﻣﺪار ﻣﺮﺑﻮط ﺑﺮاي روﺷﻦ و ﺧﺎﻣﻮش ﻛﺮدن ‪ LED‬در ‪PA0‬‬

‫‪٢٤‬‬
‫ﺣﺎﻻ ﺑﺎﻳﺪ اﻳﻦ ﻓﺎﻳﻞ را ﺑﻪ ﭘﺮوژه اﺿﺎﻓﻪ ﻛﻨﻴﺪ‪ .‬ﺑﺮاي اﻳﻦ ﻛﺎر از ﻣﻨﻮي ‪ ،Project‬ﮔﺰﻳﻨﺔ ‪ Configure‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪ .‬در‬

‫ﻗﺴﻤﺖ ‪ ،Files‬دﻛﻤﻪ ‪ Add‬را ﻓﺸﺎر دﻫﻴﺪ و از ﭘﻨﺠﺮه ﺑﺎز ﺷﺪه ﻓﺎﻳﻞ ‪ main.c‬ﻛﻪ ﻛﺪﻫﺎي ﺑﺮﻧﺎﻣﻪ را ﻗﺒ ﹰ‬
‫ﻼ در آن وارد ﻛﺮدهاﻳﺪ‪،‬‬

‫اﻧﺘﺨﺎب ﻧﻤﻮده و دﻛﻤﻪ ‪ Open‬را ﻓﺸﺎر دﻫﻴﺪ‪ .‬ﺣﺎﻻ ﻓﺎﻳﻞ ‪ main.c‬ﺑﻪ ﭘﺮوژه اﺿﺎﻓﻪ ﺷﺪه اﺳﺖ‪).‬ﺷﻜﻞ ‪(٩-٣‬‬

‫ﺷﻜﻞ ‪ ٩ -٣‬ﭘﻨﺠﺮه ‪ Configure Project‬ﺑﻌﺪ از اﺿﺎﻓﻪ ﻛﺮدن ﻓﺎﻳﻞ ‪main.c‬‬

‫‪٢٥‬‬
 ‫ﺷﮑﻞ ‪ ١١ -٣‬ﻗﺒﻞ از اﺿﺎﻓﻪ ﻛﺮدن ﻓﺎﻳﻞ ﺑﻪ ﭘﺮوژه‬

‫ﺷﮑﻞ ‪ ١٠ -٣‬ﻗﺒﻞ از اﺿﺎﻓﻪ ﻛﺮدن ﻓﺎﻳﻞ ﺑﻪ ﭘﺮوژه‬

‫ﺗﻨﻈﻴﻢ ﻛﺎﻣﭙﺎﻳﻠﺮ‬

‫ﺗﻨﻈﻴﻢ ﭘﺎراﻣﺘﺮﻫﺎي ﻛﺎﻣﭙﺎﻳﻠﺮ ‪ C‬ﺑــﺮاي ﺑﺮﻧـﺎﻣﻪ ﺟـﺎري ﺗﻮﺳـﻂ ﻣﻨـﻮي ‪ ،Project‬ﮔﺰﻳـﻨﻪ ‪ ،Configare‬ﻗﺴـﻤﺖ ‪C‬‬

‫‪ Compiler‬اﻧﺠـﺎم ﻣﻲﺷـﻮد‪ .‬اﺑﺘـﺪا در ﻗﺴــﻤﺖ ‪ ،Code Generation‬ﮔﺰﻳــﻨﻪ ‪ ،Chip‬ﻧــﻮع ﺗــﺮاﺷﻪ ‪ AVR‬را ﺑﺮاﺑــﺮ‬

‫‪ Atmega32L‬ﻗﺮار داده‪ ،‬ﺳﭙﺲ در ﮔﺰﻳﻨﺔ ‪ Clock‬ﻣﻘﺪار ﻛﺮﻳﺴﺘﺎل ﻣﺘﺼﻞ ﺑﻪ ﺗﺮاﺷﻪ را ﺑﺮاﺑﺮ ‪ 4MHz‬اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪ .‬ﻻزم ﺑﻪ‬

‫ذﻛﺮ اﺳﺖ در ﺻﻮرﺗﻲ ﻛﻪ ﻣﻘﺪار آن درﺳﺖ ﺗﻨﻈﻴﻢ ﻧﺸﻮد ﺗﻮاﺑﻊ ﺗﺄﺧﻴﺮ ﻛﺎر ﺧﻮد را درﺳﺖ اﻧﺠﺎم ﻧﺨﻮاﻫﺪ داد‪ .‬اﺣﺘﻴﺎﺟﻲ ﺑﻪ ﺗﻐﻴــﻴﺮ‬

‫ﺑﻘﻴﻪ ﻣﺪار ﻧﻴﺴﺖ‪ .‬ﺑﺪ ﻧﻴﺴﺖ ﺑﺪاﻧﻴﺪ در ﺻﻮرﺗﻲ ﻛﻪ ﭘﺮوژه ﺷﻤﺎ از ﺑﻴﺶ از ﻳﻚ ﻓﺎﻳﻞ ﺗﺸﻜﻴﻞ ﺷﺪه‪ ،‬ﻣﻲﺗﻮاﻧﻴﺪ ﺗﻌﺎرﻳﻒ ﺳﺮاﺳﺮي‪ ١‬را‬

‫در ﻗﺴﻤﺖ ‪ Globally#define‬وارد ﻧﻤﺎﻳﻴﺪ‪).‬ﺷﻜﻞ ‪(١٢-٣‬‬

‫‪١‬‬
‫‪Global‬‬

‫‪٢٦‬‬
 ‫ﺷﻜﻞ ‪ ١٢ -٣‬ﭘﻨﺠﺮه ‪ Configure Project‬ﻗﺴﻤﺖ ‪Globally#define‬‬

‫در ﻗﺴﻤﺖ ‪ paths‬ﻫﻢ ﻣﻲﺗﻮاﻧﻴﺪ ﻣﺴﻴﺮﻫﺎي ﺟﺪﻳﺪي را ﺑﺮاي ﻓﺎﻳﻠﻬﺎي ﺳﺮآﻣﺪ و ﻛﺘﺎﺑﺨﺎﻧﻪاي ﺗﻌﺮﻳﻒ ﻛﻨﻴﺪ‪).‬ﺷﻜﻞ ‪(١٣-٣‬‬

‫‪٢٧‬‬
 ‫ﺷﻜﻞ ‪ ١٣ -٣‬ﭘﻨﺠﺮه ‪ Configure Project‬ﻗﺴﻤﺖ ‪Paths‬‬

‫در اﻳﻨﺠﺎ ﺗﻨﻈﻴﻢ ﻛﺎﻣﭙﺎﻳﻠﺮ ﻫﻢ ﺑﻪ ﭘﺎﻳﺎن رﺳﻴﺪه اﺳﺖ‪ ،‬وﻟﻲ ﻗﺒﻞ از اﻳﻦ ﻛــﻪ ﭘﻨﺠـﺮه را ﺑﺒﻨﺪﻳـﺪ ﻗﺴـﻤﺖ ‪ After Make‬را‬

‫اﻧﺘﺨﺎب ﻛﻨﻴﺪ )ﺷﻜﻞ ‪(١٤-٣‬‬

‫‪٢٨‬‬
 ‫ﺷﻜﻞ ‪ ١٤ -٣‬ﭘﻨﺠﺮه ‪ Configure Project‬ﻗﺴﻤﺖ ‪ After Make‬ﻗﺒﻞ از ﻓﻌﺎل ﻛﺮدن ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺗﺮاﺷﻪ‬

‫و در آن ﮔﺰﻳﻨﻪ ‪ Program the Chip‬را ﻋﻼﻣﺖ ﺑﺰﻧﻴﺪ‪ .‬اﻳﻦ ﻛﺎر ﺑﺎﻋﺚ ﻣﻲﺷﻮد ﺗﺎ ﭘﺲ از ﻛﺎﻣﭙﺎﻳﻞ و اﺳﻤﺒﻞ ﻛﺮدن ﺑﺮﻧﺎﻣــﻪ ﺑﺘﻮاﻧﻴـﺪ‪،‬‬

‫ﻣﺴﺘﻘﻴﻤ ﹰﺎ ﻛﺪﻫﺎ را ﺑﻪ ﺗﺮاﺷﻪ ﺑﻔﺮﺳﺘﻴﺪ و آن را ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻛﻨﻴﺪ‪).‬ﺷﻜﻞ ‪ (١٥-٣‬ﺑﻪ ﻛﻤﻚ ﮔﺰﻳﻨﻪﻫﺎي دﻳﮕﺮ ﻫﻢ ﻣﻲﺗﻮاﻧﻴــﺪ ﺣﺎﻓﻈـﻪﻫﺎ را‬

‫ﻗﻔﻞ ﻧﻤﻮده و ﻓﻴﻮزﻫﺎي ﻣﻮردﻧﻈﺮﺗﺎن در روي ﺗﺮاﺷﻪ را ﻫﻢ ﺗﻨﻈﻴﻢ ﻛﻨﻴﺪ‪ ،‬در ﭘﺎﻳﺎن ﺑﺎ ﻓﺸﺎر دﻛﻤﺔ ‪ OK‬ﭘﻨﺠﺮه را ﺑﺒﻨﺪﻳﺪ‪.‬‬

‫‪٢٩‬‬
 ‫ﺷﻜﻞ ‪ ١٥ -٣‬ﭘﻨﺠﺮه ‪ Configure Project‬ﻗﺴﻤﺖ ‪ After Make‬ﺑﻌﺪ از ﻓﻌﺎل ﻛﺮدن ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺗﺮاﺷﻪ‬

‫ﺗﻨﻈﻴﻤﺎت ﻧﺮم اﻓﺰار‬

‫از آﻧﺠﺎﻳﻲ ﻛﻪ اﻳﻦ اوﻟﻴﻦ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎ ‪ Codevision‬ﻣﻲﺑﺎﺷﺪ ﺑﺎﻳﺪ ﻗﺴﻤﺘﻬﺎي ﻣﺨﺘﻠﻒ آن را ﻧﻴﺰ ﺑﻪ درﺳﺘﻲ ﺗﻨﻈﻴﻢ ﻛﻨﻴﺪ‪.‬‬

‫ﺗﻨﻈﻴﻤﺎت ﻻزم ﺷﺎﻣﻞ ﺗﻌﻴﻴﻦ ‪ Debugger‬و آدرس آن‪ ،‬ﺑﺮاي ﺷﺒﻴﻪ ﺳﺎزي ﺑﺮﻧﺎﻣﻪ و ﺗﻨﻈﻴﻢ ﻧﻮع ﭘﺮوﮔﺮاﻣﺮ و آدرس ﭘﻮرت ﻣﺮﺑــﻮط ﺑـﻪ‬

‫آن ﻣﻲﺑﺎﺷﺪ‪.‬‬

‫ﺑﺮاي ﺗﻨﻈﻴﻢ دﻳﺒﺎﮔﺮ از ﻣﻨﻮي ‪ ،Settings‬ﮔﺰﻳﻨﻪ ‪ Debugger‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪ .‬در ﭘﻨﺠﺮة ﺑﺎز ﺷﺪه)ﺷﻜﻞ ‪ (١٦-٣‬در‬

‫ﻗﺴﻤﺖ ‪ Atmel AVR Studio4 , Debugger‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ و در ﻗﺴﻤﺖ ‪ Directory and Filename‬آدرس ﻧﺮماﻓــﺰار‬

‫ﻼ ﻧﺼﺐ ﻧﻤﻮدهاﻳﺪ را وارد ﻛﺮده و دﻛﻤﻪ ‪ OK‬را ﻓﺸﺎر دﻫﻴﺪ‪.‬‬

‫‪ AVR Studio‬ﻛﻪ ﻗﺒ ﹰ‬

‫‪٣٠‬‬
 ‫ﺷﻜﻞ ‪ ١٦ -٣‬ﭘﻨﺠﺮه ‪Debugger Settings‬‬

‫ﺑﺮاي ﺗﻨﻈﻴﻢ ﭘﺮوﮔﺮاﻣﺮ‪ ،‬از ﻣﻨــﻮي ‪ ،Settings‬ﮔﺰﻳـﻨﻪ ‪ Programmer‬را اﻧﺘﺨـﺎب ﻛﻨﻴـﺪ‪ .‬در اﻳـﻦ ﭘﻨﺠـﺮه)ﺷـﻜﻞ ‪(١٧-٣‬‬

‫ﻣﻲﺗﻮاﻧﻴﺪ ﻧﻮع ﭘﺮوﮔﺮاﻣﺮ ‪ ISP‬و آدرس ﭘﻮرﺗﻲ را ﻛﻪ ﭘﺮوﮔﺮاﻣﺮ از ﻃﺮﻳﻖ آن ﺑﻪ ﻛﺎﻣﭙﻴﻮﺗﺮ ﻣﺘﺼــﻞ ﺷـﺪه اﺳـﺖ را ﻣﺸـﺨﺺ ﻧﻤـﺎﻳﻴﺪ‪ .‬در‬

‫ﻗﺴﻤﺖ ‪ Kanda Systems STK200+/300, AVR Chip Programmer Type‬و در ﻗﺴـﻤﺖ ‪، Printer Port‬‬

‫‪ LPT1:378h,‬را ﻣﺸﺨﺺ ﻛﻨﻴﺪ و دﻛﻤﻪ ‪ OK‬را ﻓﺸﺎر دﻫﻴﺪ‪.‬‬

‫ﺷﻜﻞ ‪ ١٧ -٣‬ﭘﻨﺠﺮه ‪Programmer Settings‬‬

‫اﻳﺠﺎد ﺑﺮﻧﺎﻣﻪ ﻗﺎﺑﻞ اﺟﺮا‬

‫ﺑﺮاي ﻗﺎﺑﻞ اﺟﺮا ﻧﻤﻮدن ﺑﺮﻧﺎﻣﻪ ﻣﻮارد زﻳﺮ ﺑﺎﻳﺪ اﻧﺠﺎم ﮔﺮدد‪:‬‬

‫‪١‬ـ ﻛﺎﻣﭙﺎﻳﻞ ﻛﺮدن ﻓﺎﻳﻞ اﺻﻠﻲ ﭘﺮوژه ﺑﺎ ﭘﺴﻮﻧﺪ ‪ .c‬و ﺗﻮﻟﻴﺪ ﻓﺎﻳﻞ اﺻﻠﻲ ﺑﻪ زﺑﺎن اﺳﻤﺒﻠﻲ‪.‬‬

‫‪٢‬ـ اﺳﻤﺒﻞ ﻛﺮدن ﻓﺎﻳﻞ اﺳﻤﺒﻠﻲ اﻳﺠﺎد ﺷﺪه ﺑﻪ ﻛﻤﻚ اﺳﻤﺒﻠﺮ ‪. AVRASM32‬‬

‫‪٣١‬‬
‫ﺑﺮاي اﻧﺠﺎم ﻣﻮرد ‪ ١‬ﻣﻲﺗﻮاﻧﻴﺪ از ﻣﻨﻮي ‪ Project‬ﮔﺰﻳﻨﻪ ‪ Compile File‬را اﻧﺘﺨﺎب ﻧﻤﻮده‪ ،‬ﻛﻠﻴﺪ ‪ F9‬را ﻓﺸــﺎر داده و ﻳـﺎ‬

‫دﻛﻤﺔ ‪ Compile‬در ﻧﻮار اﺑﺰار را ﻓﺸﺎر دﻫﻴﺪ‪ .‬ﺑﻌﺪ ازﻛﺎﻣﭙﺎﻳﻞ‪،‬ﻓﺎﻳﻠﻲ ﺑﺎ ﭘﺴﻮﻧﺪ ‪ .asm‬ﺗﻮﻟﻴﺪ ﻣﻲ ﺷــﻮد و ﭘﻨﺠـﺮه ‪ Information‬ﻛـﻪ‬

‫ﻧﺘﺎﻳﺞ ﻛﺎﻣﭙﺎﻳﻞ را ﻧﺸﺎن ﻣﻲ دﻫﺪ ﻇﺎﻫﺮ ﻣﻲ ﺷﻮد‪) .‬ﺷﻜﻞ ‪(١٨-٣‬‬

‫ﺷﻜﻞ ‪ ١٨ -٣‬ﭘﻨﺠﺮه ‪ Information‬ﺣﺎوي ﻧﺘﺎﻳﺞ ﺣﺎﺻﻞ از ﻛﺎﻣﭙﺎﻳﻞ‬

‫در ﺻﻮرﺗﻲ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ ﻣﻮارد ‪ ١‬و ‪ ٢‬را اﻧﺠﺎم دﻫﻴﻢ ﺑﺎﻳﺪ از ﻣﻨﻮي ‪ ، Project‬ﮔﺰﻳﻨﻪ ‪ Make File‬را اﻧﺘﺨﺎب ﻧﻤﻮده‪،‬‬

‫ﻛﻠﻴﺪ ‪ F9‬را ﻓﺸﺎر داده و ﻳﺎ دﻛﻤﺔ ‪ Make‬در ﻧﻮار اﺑﺰار را ﻓﺸﺎر دﻫﻴﺪ‪ .‬ﭘﺲ از اﺗﻤﺎم اﻳﻦ ﻣﺮﺣﻠﻪ ﭘﻨﺠﺮه ‪ Information‬ﺑﺎز ﻣﻲﺷﻮد‬

‫ﻛﻪ اﻳﻦ ﺑﺎر از ﺳﻪ ﻗﺴﻤﺖ ﺗﺸﻜﻴﻞ ﺷﺪه اﺳﺖ‪ .‬در ﻗﺴﻤﺖ ‪) Compile‬ﺷﻜﻞ ‪ ،(١٩-٣‬ﺗﻨﻈﻴﻤﺎت ﻣﺮﺑﻮط ﺑﻪ ﻛﺎﻣﭙﺎﻳﻠﺮ و ﻣﻴﺰان اﺳﺘﻔﺎده‬

‫ﺑﺮﻧﺎﻣﻪ از ﺣﺎﻓﻈﻪﻫﺎي ﺗﺮاﺷﻪ ﻣﺸﺨﺺ ﺷﺪه اﺳﺖ‪ .‬در ﻗﺴﻤﺖ ‪) Assembler‬ﺷﻜﻞ ‪ (٢٠-٣‬ﻓﺎﻳﻠﻬﺎي اﻳﺠﺎد ﺷﺪه و ﻣﻴﺰان ﺣﺎﻓﻈﻪ ﻛﺪﻫﺎ‬

‫ﻧﺸﺎن داده ﺷﺪه و ﻗﺴﻤﺖ ‪) Programmer‬ﺷﻜﻞ ‪ (٢١-٣‬ﺗﻨﻬﺎ از ﻳﻚ ﺷﻤﺎرﻧﺪه ﺗﺸﻜﻴﻞ ﺷﺪه ﻛﻪ ﺗﻌﺪاد دﻓﻌﺎت ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺗﺮاﺷﻪ‬

‫ﻣﻮردﻧﻈﺮ را ﻧﺸﺎن ﻣﻲدﻫﺪ ﻛﻪ ﻣﻲﺗﻮاﻧﻴﺪ آن را ﺻﻔﺮ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪٣٢‬‬
Compile ‫ ﻗﺴﻤﺖ‬Information ‫ ﭘﻨﺠﺮه‬١٩ -٣ ‫ﺷﮑﻞ‬

٣٣
 Assembler ‫ ﻗﺴﻤﺖ‬Information ‫ ﭘﻨﺠﺮه‬٢٠ -٣ ‫ﺷﻜﻞ‬

٣٤
 ‫ﺷﻜﻞ ‪ ٢١ -٣‬ﭘﻨﺠﺮه ‪ Information‬ﻗﺴﻤﺖ ‪Programmer‬‬

‫در ﺻﻮرﺗﻲ ﻛﻪ ﭘﺮوژه ﺑﺪون اﻳﺠﺎد ﺧﻄﺎ ﻛﺎﻣﭙﺎﻳﻞ و اﺳﻤﺒﻞ ﺷﺪه ﺑﺎﺷﺪ‪ ،‬ﻛﺎﺑﻞ ‪ ISP‬و ﻣﻨﺒــﻊ ﺗﻐـﺬﻳﻪ آن ﻫـﻢ وﺻـﻞ ﺑﺎﺷـﻨﺪ‪،‬‬

‫ﻣﻲﺗﻮاﻧﻴﺪ دﻛﻤﻪ ‪ Program‬را ﻓﺸﺎر دﻫﻴﺪ‪ .‬ﺑﺎ اﻧﺠﺎم اﻳﻦ ﻛﺎر ﺑﺮﻧﺎﻣﻪرﻳﺰي ﺗﺮاﺷﻪ ﺑﻪ ﺳﺮﻋﺖ آﻏﺎزﻣﻲﮔﺮدد‪ .‬اﺑﺘــﺪا ﺣﺎﻓﻈـﻪ ﻫـﺎي ﺗﺮاﺷـﻪ‬

‫ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﻣﻲ ﺷﻮد‪).‬ﺷﻜﻞ ‪(٢٢-٣‬‬

‫ﺷﻜﻞ ‪ ٢٢ -٣‬ﭘﻨﺠﺮه ‪ Flash Programming‬در زﻣﺎن ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺗﺮاﺷﻪ‬

‫وﺳﭙﺲ ﺻﺤﺖ اﻃﻼﻋﺎت ﻧﻮﺷﺘﻪ ﺷﺪه ﺑﺮرﺳﻲ ﻣﻲ ﮔﺮدد‪).‬ﺷﻜﻞ ‪(٢٣-٣‬‬

‫‪٣٥‬‬
 ‫ﺷﻜﻞ ‪ ٢٣ -٣‬ﭘﻨﺠﺮه ‪ Verify‬ﺑﺮاي اﻃﻤﻴﻨﺎن از ﺻﺤﺖ ﻛﺪﻫﺎي ﻧﻮﺷﺘﻪ ﺷﺪه‬

‫و اﺟﺮاي ﻛﺪﻫﺎ در ﺗﺮاﺷﻪ ﻧﻴﺰ ﺑﻼﻓﺎﺻﻠﻪ ﺑﻌﺪ از آن ﺷﺮوع ﻣﻲ ﺷﻮد‪.‬‬

‫در ﺻﻮرﺗﻲ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ ﺗﺎ ﻗﺒﻞ از ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺗﺮاﺷﻪ ﺑﻪ ﻛﻤﻚ ﺷﺒﻴﻪ ﺳﺎزي ﺑﺮﻧﺎﻣﻪ ازﺻﺤﺖ ﻋﻤﻠﻜﺮد آن ﻣﻄﻤﺌﻦ ﺷــﻮﻳﻢ از‬

‫ﻧﺮم اﻓﺰار ‪ AVRStudio‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ‪.‬در ﺣﻘﻴﻘﺖ ﭘﺲ از اﻧﺠﺎم اﻋﻤﺎل ﻛﺎﻣﭙﺎﻳﻞ واﺳــﻤﺒﻞ ﻛـﺮدن ﺑﺮﻧﺎﻣـﻪ ‪ Codevision‬ﻳـﻚ‬

‫ﻓﺎﻳﻞ ‪ object‬ﺑﺎ ﭘﺴﻮﻧﺪ ‪ COFF‬ﺗﻮﻟﻴﺪ ﻣﻲ ﻛﻨﺪ‪.‬ﻧﺴﺨﻪ ‪ AVRStudio 4.06‬ﻳﺎ ﻧﺴﺨﻪ ﻫــﺎي ﺑﻌـﺪ از آن ﺑـﺎ اﺳـﺘﻔﺎده از اﻳـﻦ ﻓـﺎﻳﻞ‬

‫اﻣﻜﺎن ﺷﺒﻴﻪ ﺳﺎزي ﺑﺮﻧﺎﻣﻪ را ﺑﺮاي ﻣﺎ ﻓﺮاﻫﻢ ﻣﻲ آورﻧﺪ‪.‬‬

‫ﺑﺮاي اﺟﺮاي اﻳﻦ ﻧﺮم اﻓﺰار در ﻣﻨﻮي ‪ Debbugger , Tools‬را اﻧﺘﺨــﺎب ﻛﻨﻴـﺪ و ﻳـﺎ در ﻧـﻮار اﺑـﺰار دﻛﻤـﻪ ‪Run the‬‬

‫‪ debbugger‬را ﻓﺸﺎر دﻫﻴﺪ‪.‬‬

‫ﺷﮑﻞ ‪ ٢٤ -٣‬ﻧﺮم اﻓﺰار ‪AVRStudio‬‬

‫ﺑﺎ اﺟﺮاي ﻧﺮم اﻓﺰار ‪ , AVRStudio‬ﭘﻨﺠﺮه ‪ Welcome to AVR Studio 4‬ﻣﻄﺎﺑﻖ ﺷﻜﻞ)‪ (٢٥-٣‬زﻳﺮ ﺑﺎز ﻣﻲ ﺷﻮد‪.‬‬

‫‪٣٦‬‬
 ‫ﺷﻜﻞ ‪ ٢٥ -٣‬ﭘﻨﺠﺮه ‪ Welcom toAVR Studio 4‬ﺑﺮاي ﺑﺎز ﻛﺮدن ﻓﺎﻳﻞ ‪object‬‬

‫در اﻳﻦ ﭘﻨﺠﺮه ﺑﺮ روي دﻛﻤﻪ ‪ Open‬ﻛﻠﻴﻚ ﻧﻤﺎﻳﻴﺪ‪.‬ﺑﺎ اﻧﺠﺎم اﻳﻦ ﻛﺎر ﭘﻨﺠﺮه دﻳﮕﺮي ﺑﺎز ﻣﻲ ﺷﻮد‪).‬ﺷﻜﻞ ‪(٢٦-٣‬‬

‫ﺷﻜﻞ ‪ ٢٦ -٣‬ﭘﻨﺠﺮه ‪Open ObjectFile‬‬

‫ﺷﻤﺎ ﺑﺎﻳﺪ در اﻳﻦ ﻗﺴﻤﺖ ﻓﺎﻳﻞ ﺑﺎ ﭘﺴﻮﻧﺪ ‪ COFF‬ﻛﻪ ﺑﻪ آن اﺷﺎره ﺷﺪ را ﺑﺎز ﻧﻤﺎﻳﻴﺪ‪.‬ﺑﻨﺎﺑﺮاﻳﻦ ﻛﺎﻓﻲ اﺳﺖ ﺗﺎ روي اوﻟﻴﻦ ﻓـﺎﻳﻞ‬

‫ﻛﻠﻴﻚ ﻛﻨﻴﺪ‪.‬‬

‫ﭘﺲ از اﻧﺘﺨﺎب ﻓﺎﻳﻞ ‪ COFF‬ﺣﺎﻻ وﻗﺖ آن اﺳﺖ ﻛﻪ روش ﺷﺒﻴﻪ ﺳﺎزي و ﻧﻮع ﺗﺮاﺷﻪ را اﻧﺘﺨﺎب ﻛﻨﻴﻢ‪.‬‬

‫‪٣٧‬‬
 ‫ﺷﻜﻞ ‪ ٢٧ -٣‬ﭘﻨﺠﺮه ‪ Welcom to AVR Studio 4‬ﺑﺮاي اﻧﺘﺨﺎب روش ﺷﺒﻴﻪ ﺳﺎزي و ﻧﻮع ﺗﺮاﺷﻪ‬

‫در)ﺷـﻜﻞ ‪ (٢٧-٣‬ﻗﺴـﻤﺖ ‪ AVR Simulator , Debug Platform‬و در ﻗﺴــﻤﺖ ‪ Atmega32 , Device‬را‬

‫اﻧﺘﺨﺎب ﻧﻤﻮده)ﺷﻜﻞ ‪ (٢٨-٣‬و دﻛﻤﻪ ‪ Finish‬را ﻓﺸﺎر دﻫﻴﺪ‪.‬‬

‫ﺷﮑﻞ ‪ ٢٨ -٣‬ﭘﻨﺠﺮه ‪ Welcom to AVR Studio 4‬ﺑﻌﺪ از اﻧﺘﺨﺎب روش ﺷﺒﻴﻪ ﺳﺎزي و ﻧﻮع ﺗﺮاﺷﻪ‬

‫‪٣٨‬‬
 ‫ددر اﻳﻦ ﻣﺮﺣﻠﻪ ‪ , AVRStudio‬ﻓﺎﻳﻞ ‪ COFF‬را ﺑﺎز ﻣﻲ ﻛﻨﺪ و ﺑﺮاي اﻧﺠﺎم ﻋﻤﻞ ﺷﺒﻴﻪ ﺳﺎزي آﻣﺎده ﻣﻲ ﺷﻮد‪).‬ﺷﻜﻞ‬

‫‪(٢٩-٣‬‬

‫ﺷﻜﻞ ‪ ٢٩ -٣‬ﻣﺤﻴﻂ ﻧﺮم اﻓﺰار ‪ AVRStudio‬ﺑﻌﺪ از ﺑﺎز ﻛﺮدن ﻓﺎﻳﻞ ‪object‬‬

‫ﺣﺎﻻ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ ﻗﺮار دادن ﻧﻘﺎط ﺷﻜﺴﺖ )‪ (Break Points‬در ﻗﺴﻤﺘﻬﺎي ﻣﻮرد ﻧﻈﺮ ﺑﺮﻧﺎﻣــﻪ و ﻣﺸـﺎﻫﺪه رﺟﻴﺴـﺘﺮﻫﺎي‬

‫ﻣﺨﺘﻠﻒ در ﭘﻨﺠﺮه ‪ Workspace‬و ﺗﻐﻴﻴﺮ آﻧﻬﺎ از ﺻﺤﺖ ﺑﺮﻧﺎﻣﻪ ﺧﻮد ﻣﻄﻤﺌﻦ ﺷﻮﻳﺪ ﻛﻪ ﺑﻪ دﻟﻴﻞ ﺳﺎدﮔﻲ اﻳﻦ ﻛــﺎر را ﺑـﻪ ﺷـﻤﺎ واﮔﺰار‬

‫ﻣﻲ ﻛﻨﻴﻢ‪.‬‬

‫‪٣٩‬‬
 ‫ﻓﺼﻞ ﭼﻬﺎرم‬
‫آﺷﻨﺎﻳﻲ ﺑﺎ ‪CodewizardAVR‬‬

‫ﺑﻪ دﻟﻴﻞ ﺗﻨﻮع اﻣﻜﺎﻧﺎت و وﺳﺎﻳﻞ ﺟﺎﻧﺒﻲ ‪ ،AVR‬ﺗﻨﻈﻴﻤﺎت ﻣﺮﺑﻮط ﺑﻪ آﻧﻬﺎ ﻣﻤﻜﻦ اﺳﺖ ﻛﺎر ﺑﺴﻴﺎر ﻣﺸﻜﻠﻲ ﺑــﻪ ﻧﻈـﺮ ﺑﺮﺳـﺪ‪.‬‬

‫ﻧﺮم اﻓﺰار ‪ Codewizard‬اﻳﻦ اﻣﻜﺎن را ﺑﻪ ﻣﺎ ﻣﻲ دﻫﺪ ﺗﺎ در اﺑﺘﺪاي ﺑﺮﻧﺎﻣﻪ ﺗﻨﻈﻴﻤﺎت اوﻟﻴﻪ ﻗﺴﻤﺘﻬﺎي ﻣﺨﺘﻠﻒ را ﺑﻪ ﺻﻮرت ﮔﺮاﻓﻴﻜــﻲ‬

‫اﻧﺠﺎم دﻫﻴﻢ ‪ .‬ﭘﺲ از آن‪ ،‬اﻳﻦ ﻧﺮم اﻓﺰار ﺑﻪ ﺻﻮرت ﺧﻮد ﻛﺎر ﻛﺪﻫﺎي ﻣﺮﺑﻮط را ﺑﺮاي ﻣﺎ اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ ‪ .‬ﺑﻪ اﻳﻦ ﺗﺮﺗﻴﺐ ﻋﻼوه ﺑــﺮ ﺻﺮﻓـﻪ‬

‫ﺟﻮﻳﻲ در وﻗﺖ‪ ،‬ﻛﺎر ﺑﺎ ‪ AVR‬ﻫﺎ ﻧﻴﺰ ﺳﺎده ﺗﺮ ﻣﻲ ﺷﻮد ‪.‬‬

‫ﺑﺮاي اﻳﻦ ﻛﻪ در ﻋﻤﻞ ﺑﺎ اﻳﻦ ﻧﺮم اﻓﺰار ﺑﻴﺸﺘﺮ آﺷﻨﺎ ﺷﻮﻳﺪ ‪ .‬ﻛﺎر را ﺑﺎ ﻳﻚ ﻣﺜﺎل اداﻣﻪ ﻣــﻲ دﻫﻴـﻢ ‪ .‬ﻣـﻲ ﺧﻮاﻫﻴـﻢ ﺑﺮﻧﺎﻣـﻪ اي‬

‫ﺑﻨﻮﻳﺴﻴﻢ ﻛﻪ ﻣﻮﻗﻌﻴﺖ ﻛﻠﻴﺪﻫﺎ‪ ،‬در ﭘﻮرت ‪ A‬را ﺧﻮاﻧﺪه و ‪ LED‬ﻫﺎي ﻣﺘﻨﺎﻇﺮ در ﭘﻮرت ‪ B‬را ﺗﻨﻈﻴﻢ ﻧﻤﺎﻳﺪ‪).‬ﺷﻜﻞ ‪(١-٤‬‬

‫‪+5v‬‬

‫‪10K‬‬
‫‪ATMega32L‬‬
‫‪220‬‬
‫‪1‬‬ ‫‪40‬‬ ‫‪1‬‬ ‫‪16‬‬
‫)‪PB0(XCK-T0‬‬ ‫)‪PA0(ADC0‬‬
‫‪2‬‬ ‫‪39‬‬ ‫‪2‬‬ ‫‪15‬‬
‫)‪PB1(T1‬‬ ‫)‪PA1(ADC1‬‬
‫‪3‬‬ ‫‪37‬‬ ‫‪3‬‬ ‫‪14‬‬
‫)‪PB2(INT2-AIN0‬‬ ‫)‪PA3(ADC3‬‬
‫‪4‬‬ ‫‪38‬‬ ‫‪4‬‬ ‫‪13‬‬
‫)‪PB3(OC0-AIN1‬‬ ‫)‪PA2(ADC2‬‬
‫‪5‬‬ ‫‪36‬‬ ‫‪5‬‬ ‫‪12‬‬
‫)‪PB4(SS‬‬ ‫)‪PA4(ADC4‬‬
‫‪6‬‬ ‫‪35‬‬ ‫‪6‬‬ ‫‪11‬‬
‫)‪PB5(MOSI‬‬ ‫)‪PA5(ADC5‬‬
‫‪7‬‬ ‫‪34‬‬ ‫‪7‬‬ ‫‪10‬‬
‫)‪PB6(MISO‬‬ ‫)‪PA6(ADC6‬‬
‫‪8‬‬ ‫‪33‬‬ ‫‪8‬‬ ‫‪9‬‬
‫)‪PB7(SCK‬‬ ‫)‪PA7(ADC7‬‬
‫‪SW DIP-8‬‬

‫ﺷﻜﻞ ‪ ١ -٤‬ﭼﮕﻮﻧﮕﻲ اﺗﺼﺎل ﻫﺸﺖ ﻛﻠﻴﺪ ﺑﻪ ﭘﻮرت ‪ A‬و ﻫﺸﺖ ‪ LED‬ﺑﻪ ﭘﻮرت ‪B‬‬

‫‪٤٠‬‬
 ‫ﺑﺮاي اﻳﺠﺎد ﻳﻚ ﭘﺮوژه ﺟﺪﻳﺪ ﻫﻤﺎﻧﻨﺪ ﻗﺒﻞ از ﻣﻨﻮي ‪ File‬ﻗﺴﻤﺖ ‪ New‬را ﻛﻠﻴﻚ ﻛﺮده و در ﭘﻨﺠﺮه ‪Create،Project‬‬

‫‪ New File‬را اﻧﺘﺨﺎب ﻛﺮده و دﻛﻤﻪ ‪ OK‬را ﻓﺸﺎر دﻫﻴﺪ‪.‬‬

‫ﺷﻜﻞ ‪ ٢ -٤‬ﭘﻨﺠﺮه ‪Create New File‬‬

‫از آﻧﺠﺎﻳﻲ ﻛﻪ ﻗﺼﺪ دارﻳﻢ ﺗﺎ ﭘﺮوژه را ﺑﻪ ﻛﻤﻚ ‪ CodewizardAVR‬اﻧﺠﺎم دﻫﻴﻢ‪ ،‬در ﭘﻨﺠــﺮه ‪ Cofirm‬دﻛﻤـﻪ ‪ Yes‬را‬

‫ﻓﺸﺎر دﻫﻴﺪ‪)،‬ﺷﻜﻞ ‪ (٤-٣‬ﺗﺎ ﻧﺮم اﻓﺰار ‪ CodewizardAVR‬اﺟﺮا ﮔﺮدد‪.‬‬

‫ﺷﮑﻞ ‪٣ -٤‬‬
‫ﻗﺒﻞ از ﻫﺮ ﭼﻴﺰ در ﻗﺴﻤﺖ ‪ ، Chip‬ﻧﻮع ﺗﺮاﺷﻪ )‪ (Atmega32L‬و ﻓﺮﻛﺎﻧﺲ ﻛﺮﻳﺴــﺘﺎل ﻣـﻮرد اﺳـﺘﻔﺎده )‪ (4 MHz‬را‬

‫ﺗﻨﻈﻴﻢ ﻧﻤﺎﻳﻴﺪ‪).‬ﺷﻜﻞ ‪(٤-٤‬‬

‫‪٤١‬‬
 ‫ﺷﻜﻞ ‪ ٤ -٤‬ﭘﻨﺠﺮه ‪ CodewizardAVR‬ﻗﺴﻤﺖ ‪Chip‬‬

‫ﺣﺎﻻ ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﻪ ﻛﻤﻚ ﻗﺴﻤﺖ ‪ ،Ports‬وﺿﻌﻴﺖ اوﻟﻴﻪ ﺗﻤﺎﻣﻲ ﭘﻮرﺗﻬﺎ ﺑﻪ ﺻﻮرت ورودي _ ﺧﺮوﺟﻲ و ﻣﻘﺪار اوﻟﻴــﻪ آﻧـﻬﺎ را‬

‫ﺗﻨﻈﻴﻢ ﻧﻤﺎﻳﻴﻢ‪.‬‬

‫اﺑﺘﺪا ﺑﺎﻳﺪ ﭘﻮرت ‪ A‬را ﺑﻪ ﺻﻮرت ورودي در آورﻳﻢ ‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﻗﺴﻤﺖ ‪ Port A‬ﻣﻲ ﺑﻴﻨﻴﺪ ﺗﻤﺎم ﺑﻴﺘﻬﺎ ورودي اﻧــﺪ ‪.‬‬

‫در ﺟﻠﻮي ﻫﺮ ﻳﻚ از ﺑﻴﺘﻬﺎ ﺣﺮف ‪ T‬ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ‪).‬ﺷﻜﻞ ‪ (٥-٤‬ﺑﺎﻳﺪ ﺑﺮ روي آﻧﻬﺎ ﻛﻠﻴﻚ ﻛﻨﻴﺪ‪ ،‬ﺗﺎ ﺑﻪ ﺣﺮف ‪(Pull up) P‬ﺗﺒﺪﻳﻞ‬

‫ﺷﻮﻧﺪ‪).‬ﺷﻜﻞ ‪(٦-٤‬‬

‫‪٤٢‬‬
‫ﺷﻜﻞ ‪ ٥-٤‬ﭘﻨﺠﺮه ‪ ،Codewizard‬ﭘﻮرت ‪ A‬در ﺣﺎﻟﺖ ﭘﻴﺶ ﻓﺮض‬

‫‪٤٣‬‬
 ‫ﺷﻜﻞ ‪ ٦ -٤‬ﭘﻨﺠﺮه ‪ ،Codewizard‬ﭘﻮرت ‪ A‬ﺑﻌﺪ از ﺗﻨﻈﻴﻢ‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ ﭘﻮرت ‪ B‬را ﺑﻪ ﺻﻮرت ﺧﺮوﺟﻲ درآورﻳﻢ ‪ .‬ﺑﺎ اﻧﺘﺨﺎب ﻗﺴﻤﺖ ‪ Port B‬و ﻛﻠﻴﻚ ﺑﺮ روي ﺣﺮف ‪ ،In‬در ﻣﻘــﺎﺑﻞ ﻫـﺮ‬

‫ﻳﻚ از ﺑﻴﺘﻬﺎ اﻳﻦ ﻋﺒﺎرت ﺑﻪ ‪ Out‬ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮد ‪ .‬ﺿﻤﻨﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻣﻘﺪار اوﻟﻴﻪ ﭘﻮرت را ﺑﻪ ﺻﻮرت ‪ 0‬و ‪ 1‬ﺗﻨﻈﻴﻢ ﻛﻨﻴﺪ‪).‬ﺷﻜﻞ ‪(٧-٤‬‬

‫‪٤٤‬‬
 ‫ﺷﮑﻞ ‪ ٧ -٤‬ﭘﻨﺠﺮه ‪ ،Codewizard‬ﺗﻨﻈﻴﻤﺎت ﭘﻮرت ‪B‬‬

‫در اﻳﻨﺠﺎ ﺗﻨﻈﻴﻤﺎت اوﻟﻴﻪ ﺑﻪ ﭘﺎﻳﺎن رﺳﻴﺪه اﺳﺖ و ﺑﺎﻳﺪ ﻛﺪﻫﺎي ﻣﺮﺑﻮﻃﻪ ﺗﻮﻟﻴﺪ ﺷﻮﻧﺪ ‪ .‬ﺑﺮاي اﻳﻦ ﻛﺎر از ﻣﻨــﻮي ‪ File‬ﻗﺴـﻤﺖ‬

‫‪ Generate , Save and Exit‬را اﻧﺘﺨﺎب ﻣﻲ ﻛﻨﻴﺪ‪).‬ﺷﻜﻞ ‪(٨-٤‬‬

‫ﺷﻜﻞ ‪ ٨ -٤‬ﻣﻨﻮي ‪ File‬در ﺑﺮﻧﺎﻣﻪ ‪CodewizardAVR‬‬

‫ﺑﺎ اﻧﺠﺎم اﻳﻦ ﻋﻤﻞ ﭘﻨﺠﺮه اي ﺑﺎز ﻣﻲ ﺷﻮد و از ﺷﻤﺎ ﻣﻲ ﺧﻮاﻫﺪ ﺗﺎ ﻓﺎﻳﻞ اﺻﻠﻲ ﭘﺮوژه ﺧﻮد را ﻧﺎم ﮔﺬاري ﻛﺮده و آن را ذﺧﻴﺮه‬

‫ﻛﻨﻴﺪ ‪ .‬ﻧﺎم آن را ‪ io‬اﻧﺘﺨﺎب ﻛﻨﻴﺪ دﻛﻤﻪ ‪ Save‬را ﻓﺸﺎر دﻫﻴﺪ‪).‬ﺷﻜﻞ ‪(٩-٤‬‬

‫‪٤٥‬‬
 ‫ﺷﻜﻞ ‪ ٩ -٤‬ذﺧﻴﺮه ﻛﺮدن ﻓﺎﻳﻞ اﺻﻠﻲ ﭘﺮوژه ﺑﻪ زﺑﺎن ‪C‬‬

‫ﺣﺎﻻ ﭘﻨﺠﺮه دﻳﮕﺮي ﺑﺎز ﻣﻲ ﺷﻮد ﻛﻪ ﻓﺎﻳﻞ ﭘﺮوژه را ذﺧﻴﺮه ﺧﻮاﻫﺪ ﻛﺮد ﻧﺎم آن را ﻫﻢ ‪ io‬اﻧﺘــﺨﺎب ﻛﻨﻴـﺪ و دﻛﻤـﻪ ‪ Save‬را‬

‫ﻓﺸﺎر دﻫﻴﺪ)ﺷﻜﻞ ‪(١٠-٤‬‬

‫ﺷﻜﻞ ‪ ١٠ -٤‬ذﺧﻴﺮه ﻛﺮدن ﻓﺎﻳﻞ ﭘﺮوژه‬

‫ﭘﻨﺠﺮه ﺑﻌﺪي ﻓﺎﻳﻞ ﭘﺮوژه ﻣﺮﺑﻮط ﺑﻪ ‪ CodewizardAVR‬را ذﺧﻴﺮه ﻣﻲ ﻛﻨﺪ‪ .‬ﻧﺎم آن را ﻧﻴﺰ ‪ io‬ﻗﺮار دﻫﻴﺪ و آن را ذﺧﻴﺮه‬

‫ﻛﻨﻴﺪ‪).‬ﺷﻜﻞ ‪(١١-٤‬‬

‫‪٤٦‬‬
 ‫ﺷﻜﻞ ‪١١ -٤‬ذﺧﻴﺮه ﻛﺮدن ﻓﺎﻳﻞ ﭘﺮوژه ﻣﺮﺑﻮط ﺑﻪ ‪CodewizardAVR‬‬

‫ﺑﺎ اﻧﺠﺎم اﻳﻦ ﻛﺎر ‪ CodewizardAVR‬ﻛﺪﻫﺎي ﺑﺮﻧﺎﻣﻪ را ﺗﻮﻟﻴﺪ ﻛﺮده و آﻧﻬﺎ را در ﻓﺎﻳﻞ اﺻﻠﻲ ﭘﺮوژه ﻗﺮار ﻣﻲ دﻫــﺪ و آن‬

‫را ﺑﺎز ﻣﻲ ﻧﻤﺎﻳﺪ‪.‬‬

‫ﻫﻤﺎن ﻃﻮر ﻛﻪ ﻣﻲ ﺑﻴﻨﻴﺪ ﻋﻼوه ﺑﺮ ﻛﺪﻫﺎ‪ ،‬در ﻫﺮ ﻗﺴﻤﺖ ﺗﻮﺿﻴﺤﺎﺗﻲ ﻫﻢ اﺿﺎﻓﻪ ﺷﺪه اﻧﺪ ﻛﻪ ﺑﺎﻋﺚ ﺳﺎده ﺗﺮ ﺷﺪن ﻓﻬﻢ ﺑﺮﻧﺎﻣﻪ‬

‫ﻣﻲ ﺷﻮﻧﺪ ‪ .‬ﺣﺎﻻ ﻛﺎﻓﻲ اﺳﺖ ﺗﺎ ﻛﺪﻫﺎي ﺧﻮد را ﺑﻌﺪ از ﻗﺴﻤﺖ ‪ //Place your code here‬اﺿﺎﻓﻪ ﻛﻨﻴﺪ ‪ .‬از آﻧﺠﺎﻳﻲ ﻛﻪ اﻳﻦ ﺑﺮﻧﺎﻣــﻪ‬

‫ﺳﺎده اﺳﺖ ﻛﺎﻓﻲ اﺳﺖ ﺗﺎ در اﻳﻦ ﻗﺴﻤﺖ دﺳﺘﻮر زﻳﺮ را اﺿﺎﻓﻪ ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫;‪PORTB = PINA‬‬

‫ﺣﺎﻻ ﻓﺎﻳﻞ را ذﺧﻴﺮه و ﻛﺎﻣﭙﺎﻳﻞ ﻧﻤﻮده و ﺗﺮاﺷﻪ را ﭘﺮوﮔﺮام ﻛﻨﻴﺪ و ﻧﺘﻴﺠﻪ را ﺑﺒﻴﻨﻴﺪ‪.‬‬

‫‪٤٧‬‬
 ‫‪PWM‬‬
‫ﻣﻲ ﺧﻮاﻫﻴﻢ ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﻳﻤﺮ ﺻﻔﺮ در ﻣﺪ ‪ Fast mode PWM‬ﻳﻚ ﻣﻮج ‪ PWM‬ﺗﻮﻟﻴــﺪ ﻛﻨﻴـﻢ ‪ .‬ﭘـﻬﻨﺎي اﻳـﻦ ﻣـﻮج‬

‫‪ ٢٥٥‬اﺳﺖ و ﻣﺎ ﻣﻲ ﺧﻮاﻫﻴﻢ ﺗﺎ ﻃﻮل ﻗﺴﻤﺖ ﻣﻮﺛﺮ ﺑﻪ ﺻﻮرت ﻣﺘﻨﺎوب از ‪ ٠‬ﺗﺎ ‪ ١٠٠‬و از ‪ ١٠٠‬ﺗﺎ ‪ ٠‬ﺑﺎ ﺗﺎﺧﻴﺮ ‪ ٢٠‬ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ ﺑﻴﻦ ﻫﺮ دو‬

‫ﻋﺪد ﻣﺘﻮاﻟﻲ ﺗﻐﻴﻴﺮ ﻛﻨﺪ‪ .‬در اﻳﻦ ﺻﻮرت اﮔﺮ ﻣﻮج ‪ PWM‬را ﺑﻪ ﻳﻚ ‪ LED‬ﺑﺪﻫﻴﻢ ﻧﻮر آن ﺑﻪ ﺻﻮرت ﺗﺪرﻳﺠﻲ ﻛﻢ و زﻳﺎد ﻣــﻲ ﺷـﻮد و‬

‫ﺑﺮاي ﻧﻮﺷﺘﻦ اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﻫﻤﺎﻧﻨﺪ ﻣﺜﺎل ﻗﺒﻞ ﻳﻚ ﭘﺮوژه اﻳﺠﺎد ﻛﺮده و ﻧﺮم اﻓﺰار ‪ CodewizardAVR‬را اﺟﺮا ﻛﻨﻴﺪ ﭘــﺲ از ﺗﻨﻈﻴـﻢ‬

‫ﻧﻮع ﺗﺮاﺷﻪ و ﻓﺮﻛﺎﻧﺲ ﻛﺮﻳﺴﺘﺎل ﻣﻮرد اﺳﺘﻔﺎده )ﻫﻤﺎﻧﻨﺪ ﻗﺒﻞ(‪ ،‬در ﻗﺴﻤﺖ ‪ , Ports‬ﺑﻴﺖ ﭼﻬﺎرم از ﭘﻮرت ‪ B‬را ﺑﻪ ﺻﻮرت ﺧﺮوﺟــﻲ در‬

‫آورﻳﺪ‪).‬ﺷﻜﻞ ‪(١٢-٤‬‬

‫ﺷﮑﻞ ‪ ١٢ -٤‬ﺗﻨﻈﻴﻢ ﺑﻴﺖ ﭼﻬﺎرم از ﭘﻮرت ‪ B‬ﺑﻪ ﻋﻨﻮان ﺧﺮوﺟﻰ‬

‫‪٤٨‬‬
‫اﻳﻦ ﺑﻴﺖ ﻫﻤﺎن ‪ ١OC0‬اﺳﺖ ﻛﻪ ﺑﺮاي ﺗﻮﻟﻴﺪ ‪ PWM‬ﺗﻮﺳﻂ ﺗﺎﻳﻤﺮ ﺻﻔﺮ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬ﺳﭙﺲ در ﻗﺴﻤﺖ ‪،Timers‬‬

‫ﺑﺨﺶ ‪ ،Timer 0‬ﻗﺴﻤﺖ ‪ System clock , clock source‬را اﻧﺘﺨﺎب ﻛﻨﻴــﺪ و ﺑﻘﻴـﻪ ﻗﺴـﻤﺘﻬﺎ را ﻫـﻢ ﻣﻄـﺎﺑﻖ ﺷـﻜﻞ)‪(١٣-٤‬‬

‫ﺗﻨﻈﻴﻢ ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫ﺷﻜﻞ ‪ ١٣ -٤‬ﺗﻨﻈﻴﻢ ﺗﺎﻳﻤﺮ ﺻﻔﺮ ﺑﺮاي ﺗﻮﻟﻴﺪ ‪PWM‬‬

‫در اﻳﻦ ﺗﻨﻈﻴﻤﺎت ‪ CodewizardAVR‬ﺑﻪ ﭘﺎﻳﺎن ﻣﻲ رﺳﺪ و ﺑﺎﻳﺪ آن را ﺑﻪ ﺻﻮرﺗﻲ ﻛﻪ در ﻣﺜﺎل ﻗﺒﻞ ﮔﻔﺘﻪ ﺷــﺪ ﺑـﻪ ﻛـﺪ‬

‫ﺗﺒﺪﻳﻞ ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫در اﻳﻦ ﻗﺴﻤﺖ ﺑﺎﻳﺪ اﺑﺘﺪا ﺑﻌﺪ از دﺳﺘﻮر >‪ ، # include <mega32.h‬دﺳﺘﻮر >‪ #include <delay.h‬را اﺿﺎﻓﻪ ﻛﻨﻴﺪ‬

‫ﺳﭙﺲ ﺑﻌﺪ از ﺧﻂ ﺗﻮﺿﻴﺢ ‪ //place your code hear‬دﺳﺘﻮرات زﻳﺮ را وارد ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫;‪unsigned char i‬‬

‫)‪for(i=0;i<100;i++‬‬
‫{‬
‫;‪OCR0=i‬‬

‫‪١‬‬
‫‪Output Compare 0‬‬

‫‪٤٩‬‬
 ‫;)‪delay_ms(20‬‬
‫}‬
‫)‪for(i=100;i>1;i--‬‬
‫{‬
‫;‪OCR0=i‬‬
‫;)‪delay_ms(20‬‬
‫}‬

‫ﺣﺎﻻ ﺑﺮﻧﺎﻣﻪ را ﻛﺎﻣﭙﺎﻳﻞ ﻧﻤﻮده و ﺗﺮاﺷﻪ را ﭘﺮوﮔﺮام ﻛﻨﻴﺪ ‪ .‬ﻣﻮج ‪ PWM‬در ﺧﺮوﺟﻲ ‪ OC0‬را ﻣــﻲ ﺗﻮاﻧﻴـﺪ ﺑـﻪ ﻛﻤـﻚ ﻳـﻚ‬

‫اﺳﻴﻠﻮﺳﻜﻮپ ﺣﺎﻓﻈﻪ دار ﻫﻢ ﻣﺸﺎﻫﺪه ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫‪ADC‬‬
‫در اﻳﻦ ﻗﺴﻤﺖ ﻗﺼﺪ دارﻳﻢ‪ ،‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﻢ ﺗﺎ ورودي آﻧﺎﻟﻮگ در ﭘﺎﻳــﻪ )‪ PORTA (ADC0‬را ﺧﻮاﻧـﺪه و آن را ﺑـﻪ‬

‫ﺻﻮرت ‪ ١٦‬ﺑﻴﺘﻲ در ﭘﻮرت ‪ B‬و دو ﺑﻴﺖ ﻛﻢ ارزش ﭘﻮرت ‪ D‬ﺑﻪ ﻛﻤﻚ ‪ LED‬ﻧﺸﺎن دﻫﺪ ‪.‬‬

‫‪ATMega32L‬‬
‫‪220‬‬ ‫‪Vcc‬‬
‫‪1‬‬ ‫‪40‬‬
‫)‪PB0(XCK-T0‬‬ ‫)‪PA0(ADC0‬‬
‫‪2‬‬
‫)‪PB1(T1‬‬
‫‪3‬‬
‫)‪PB2(INT2-AIN0‬‬
‫‪20k‬‬
‫‪4‬‬
‫)‪PB3(OC0-AIN1‬‬
‫‪5‬‬
‫)‪PB4(SS‬‬ ‫‪32‬‬
‫‪6‬‬ ‫‪AREF‬‬
‫)‪PB5(MOSI‬‬ ‫‪31‬‬ ‫‪0.1u‬‬
‫‪7‬‬ ‫‪GND‬‬
‫)‪PB6(MISO‬‬
‫‪8‬‬
‫)‪PB7(SCK‬‬

‫‪14‬‬
‫)‪PD0(RXD‬‬
‫‪15‬‬
‫)‪PD1(TXD‬‬

‫ﺷﮑﻞ ‪١٤ -٤‬‬

‫ﺳﺨﺖ اﻓﺰاري ﻛﻪ ﺑﺮاي اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﺑﺎﻳﺪ ﺑﻪ ﺳﺨﺖ اﻓﺰار اﺻﻠﻲ اﺿﺎﻓﻪ ﮔﺮدد ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪ :‬ﻳﻚ ﺧﺎزن ﺳﺮاﻣﻴﻜﻲ ‪٠,١‬‬

‫ﻣﻴﻜﺮوﻓﺎراد ﺑﻴﻦ ﭘﺎﻳﻪ ‪ AREF‬و زﻣﻴﻦ‪ ،‬ﻳﻚ ﭘﺘﺎﻧﺴﻮﻣﺘﺮ ‪ ٢٠‬ﻛﻴﻠﻮ اﻫﻢ در ‪ ADC0‬و ‪ ١٠‬ﻋــﺪد ‪ LED‬و ﻣﻘـﺎوﻣﺖ ‪ ٢٢٠‬اﻫـﻢ ﻛـﻪ در‬

‫ﺷﻜﻞ)‪ (١٤-٤‬زﻳﺮ ﻧﺸﺎن داده ﺷﺪه اﻧﺪ‬

‫‪٥٠‬‬
‫در اﺑﺘﺪا ﺑﺎﻳﺪ ﻳﻚ ﭘﺮوژه ﺟﺪﻳﺪ اﻳﺠﺎد ﻛﻨﻴﺪ و ﻫﻤﺎﻧﻨﺪ ﻣﺜﺎﻟﻬﺎي ﻗﺒﻞ ﻧﺮم اﻓﺰار ‪ CodewizardAVR‬را اﺟﺮا ﻧﻤــﺎﻳﻴﺪ ‪ .‬ﺑﻌـﺪ‬

‫از ﺗﻨﻈﻴﻢ ﻧﻮع ﺗﺮاﺷﻪ و ﻓﺮﻛﺎﻧﺲ ﻛﺮﻳﺴﺘﺎل‪ ،‬در ﻗﺴﻤﺖ ‪ ، Ports‬ﭘﻮرت ‪ B‬و دو ﺑﻴﺖ ﻛــﻢ ارزش ﭘـﻮرت ‪ D‬را ﺑـﻪ ﺻـﻮرت ﺧﺮوﺟـﻲ در‬

‫آورﻳﺪ‪). .‬ﺷﻜﻠﻬﺎي ‪ ١٥-٤‬و ‪(١٦-٤‬‬

‫ﺷﻜﻞ ‪ ١٥ -٤‬ﺗﻨﻈﻴﻢ ﭘﻮرت ‪ B‬ﺑﻪ ﺻﻮرت ﺧﺮوﺟﻲ‬

‫‪٥١‬‬
 ‫ﺷﻜﻞ ‪ ١٦ -٤‬ﺗﻨﻈﻴﻢ ﭘﻴﻨﻬﺎي ﺻﻔﺮ و ﻳﻚ از ﭘﻮرت ‪ D‬ﺑﻪ ﻋﻨﻮان ﺧﺮوﺟﻲ‬

‫ﺳﭙﺲ در ﻗﺴﻤﺖ ‪) ،ADC‬ﺷﻜﻞ ‪ (١٧-٤‬اﺑﺘﺪا ‪ ADC Enabled‬را ﻋﻼﻣﺖ ﺑﺰﻧﻴﺪ‪ .‬ﺑﺎ اﻧﺠﺎم اﻳﻦ ﻛﺎر ﺗﻨﻈﻴﻤﺎت ﻣﺮﺑﻮط ﺑــﻪ‬

‫‪ ADC‬ﻧﻤﺎﻳﺎن ﻣﻲ ﺷﻮﻧﺪ ‪).‬ﺷﻜﻞ ‪ (١٨-٤‬ﺳﭙﺲ ‪ Interrupt ADC‬را ﻧﻴﺰ ﻋﻼﻣـﺖ زده ‪ Volt. Ref ،‬را ﺑﺮاﺑـﺮ ‪Int, Cap.on‬‬

‫‪ AREF‬و ‪ ADC Clock‬را ﺑﺮاﺑﺮ ‪ 125. 000KHz‬اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪.‬‬

‫‪٥٢‬‬
‫ﺷﻜﻞ ‪ ١٧ -٤‬ﻗﺴﻤﺖ ‪ ADC‬ﻗﺒﻞ از ﻓﻌﺎل ﻛﺮدن آن‬

‫‪٥٣‬‬
 ‫ﺷﻜﻞ ‪ ١٨ -٤‬ﻗﺴﻤﺖ ‪ ADC‬و ﺗﻨﻈﻴﻤﺎت آن‬

‫در اﻳﻦ ﻣﻮﻗﻊ ﻛﻞ ﺗﻨﻈﻴﻤﺎت اوﻟﻴﻪ ﺑﻪ ﭘﺎﻳﺎن رﺳﻴﺪه اﺳﺖ و ﺑﺎﻳﺪ ﻛﺪﻫﺎي ﺑﺮﻧﺎﻣﻪ را ﺗﻮﻟﻴﺪ ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ دﺳﺘﻮراﺗﻲ را ﺑﻪ ﻓﺎﻳﻞ ﺗﻮﻟﻴﺪ ﺷﺪه اﺿﺎﻓﻪ ﻛﻨﻴﺪ ‪ .‬اﺑﺘﺪا در ﺗﺎﺑﻊ ‪ interrupt‬ﺑﻌﺪ از ﻗﺴﻤﺖ ‪// place your code‬‬

‫‪ hear‬دﺳﺘﻮرات زﻳﺮ را وارد ﻛﻨﻴﺪ ‪.‬‬

‫;‪PORTB=ADCL‬‬
‫;‪PORTD.0=ADCH.0‬‬
‫;‪PORTD.1=ADCH.1‬‬
‫;‪ADCSRA|=0x40‬‬
‫ﺳﭙﺲ ﺑﻌﺪ از دﺳﺘﻮر )"‪ ، # asm("sei‬دﺳﺘﻮر ;‪ ADCSRA|= ox40‬را ﺑﻨﻮﻳﺴﻴﺪ ‪ .‬ﺣﺎﻻ ﻣﻲ ﺗﻮاﻧﻴﺪ ‪ ،‬ﭘﺮوژه را ذﺧــﻴﺮه‬

‫و ﻛﺎﻣﭙﺎﻳﻞ ﻛﺮده و ﺗﺮاﺷﻪ را ﭘﺮوﮔﺮام ﻛﻨﻴﺪ‪.‬‬

‫‪٥٤‬‬
 ‫ﻓﺼﻞ ﭘﻨﺠﻢ‬
‫ارﺗﺒﺎط ﺳﺮﻳﺎل و ‪LCD‬‬

‫ارﺗﺒﺎط ﺳﺮﻳﺎل ﺑﺎ ﻛﺎﻣﭙﻴﻮﺗﺮ‬

‫در اﻳﻦ ﻗﺴﻤﺖ ﻣﻲﺧﻮاﻫﻴﻢ ﺑﺮﻧﺎﻣﻪاي ﺑﻨﻮﻳﺴﻴﻢ ﻛﻪ اﻃﻼﻋﺎت را ﺑﻪ ﺻﻮرت ﺳﺮﻳﺎل از ﺗﺮاﺷﻪ ﺑﻪ ﻛﺎﻣﭙﻴﻮﺗﺮ ﺑﻔﺮﺳﺘﺪ‪ .‬ﻣﻲﺧﻮاﻫﻴﻢ‬

‫ﻋﺒﺎرت ” ‪، “Hello World‬ﺑﺎ ﻧﺮخ ارﺳﺎل ‪ ،9600 bit/sec‬ﺑﺪون ‪ ،parity‬ﺑﺎ ﻳﻚ ﺑﻴﺖ ﺗﻮﻗﻒ و ﻫﺸﺖ ﺑﻴﺖ دﻳﺘﺎ ﻓﺮﺳﺘﺎده ﺷﻮد‪.‬‬

‫ﺗﺮﺟﻴﺤ ﹰﺎ ﺑﻬﺘﺮ اﺳﺖ‪ ،‬اﺑﺘﺪا در ﻣﻮرد ﺳﺨﺖاﻓﺰار ﻻزم ﺑﺮاي ﺑﺮﻗﺮاري ارﺗﺒﺎط ﺳﺮﻳﺎل ﺻﺤﺒﺖ ﻛﻨﻴــﻢ‪ .‬ﻣـﺪار آن در ﺷـﻜﻞ)‪(١-٥‬‬

‫ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪.‬‬

‫‪٥٥‬‬
 ‫‪+5v‬‬

‫‪+‬‬ ‫‪1‬‬ ‫‪16‬‬

‫‪1uF‬‬ ‫‪C+‬‬ ‫‪VCC‬‬ ‫‪+‬‬
‫‪+‬‬ ‫‪2‬‬ ‫‪15‬‬
‫‪1uF‬‬
‫‪1uF‬‬ ‫‪V+‬‬ ‫‪GND‬‬
‫‪3‬‬ ‫‪14‬‬
‫‪C1-‬‬ ‫‪T1OUT‬‬
‫‪+‬‬ ‫‪4‬‬ ‫‪13‬‬
‫‪1uF‬‬ ‫‪C2+‬‬ ‫‪R1IN‬‬
‫‪5‬‬ ‫‪12‬‬
‫‪C2-‬‬ ‫‪R1OUT‬‬
‫‪1‬‬ ‫‪+‬‬ ‫‪6‬‬ ‫‪11‬‬
‫‪6‬‬
‫‪1uF‬‬ ‫‪V-‬‬ ‫‪T1IN‬‬
‫‪2‬‬ ‫‪7‬‬ ‫‪10‬‬ ‫‪14‬‬
‫‪7‬‬ ‫‪T2OUT‬‬ ‫‪T2IN‬‬ ‫)‪PD0(RXD‬‬
‫‪3‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪15‬‬
‫‪8‬‬ ‫‪R2IN‬‬ ‫‪R2OUT‬‬ ‫)‪PD1(TXD‬‬
‫‪4‬‬ ‫‪17‬‬
‫‪9‬‬ ‫)‪PD3(INT1‬‬
‫‪5‬‬ ‫‪MAX232‬‬ ‫‪16‬‬
‫)‪PD2(INT0‬‬
‫‪18‬‬
‫)‪PD4(OC1B‬‬
‫‪CONNECTOR DB9‬‬
‫‪19‬‬
‫)‪PD5(OC1A‬‬
‫‪20‬‬
‫)‪PD6(ICP‬‬

‫‪ATMega32L‬‬

‫ﺷﻜﻞ ‪ ١ -٥‬ﺑﺮﻗﺮاري ارﺗﺒﺎط ﺳﺮﻳﺎل‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ ﺑﻪ ﺳﺮاغ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ﺑﺮوﻳﻢ‪ .‬اﺑﺘﺪا ﭘﺮوژه ﺟﺎري را ﺑﺎ اﻧﺘﺨﺎب ﮔﺰﻳﻨﻪ ‪ Close Project‬از ﻣﻨﻮي ‪ File‬ﺑﺒﻨﺪﻳــﺪ‪.‬‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ ﭘﺮوژه ﺟﺪﻳﺪي اﻳﺠﺎد ﻛﻨﻴﺪ‪ .‬ﺑﺮاي اﻧﺠﺎم اﻳﻦ ﻛﺎر از ﻣﻨﻮي ‪ CodewizardAVR ،Tools‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪ .‬ﻫﻤــﺎﻧﻨﺪ ﻗﺒـﻞ‬

‫در اوﻟﻴﻦ ﻣﺮﺣﻠﻪ ﻧﻮع ﺗﺮاﺷﻪ و ﻓﺮﻛﺎﻧﺲ ﻛﺮﻳﺴﺘﺎل ﻣﻮرد اﺳﺘﻔﺎده را ﻣﺸﺨﺺ ﻛﺮده‪ ،‬ﺳﭙﺲ ﻗﺴﻤﺖ ‪ USART‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪).‬ﺷــﻜﻞ‬

‫‪(٢-٥‬‬

‫‪٥٦‬‬
 ‫ﺷﻜﻞ ‪ ٢ -٥‬ﭘﻨﺠﺮه ‪ CodewizardAVR‬ﻗﺴﻤﺖ ‪USART‬‬

‫از آﻧﺠﺎﻳﻲ ﻛﻪ ﻗﺼﺪ دارﻳﻢ در اﻳﻦ ﺑﺮﻧﺎﻣﻪ از ﺗﺮاﺷﻪ ﺑﻪ ﻋﻨﻮان ﻓﺮﺳــﺘﻨﺪه اﺳـﺘﻔﺎده ﻛﻨﻴـﻢ‪ ،‬ﮔﺰﻳﻨـﻪ ‪ Transmiter‬را ﻋﻼﻣـﺖ‬

‫ﺑﺰﻧﻴﺪ‪ .‬ﺑﺎ اﻧﺠﺎم اﻳﻦ ﻛﺎر ﻣﻮارد دﻳﮕﺮي ﺑﻪ ﺻﻔﺤﻪ اﺿﺎﻓﻪ ﻣﻲﺷﻮﻧﺪ‪ ،‬ﻛﺎﻓﻲ اﺳﺖ ﺗﺎ ‪ Baudrate‬را ﺑﺮاﺑـﺮ ‪Communication ،9600‬‬

‫‪ Parameters‬را ﺑﺮاﺑﺮ ‪ 8 Data, 1 Stop, No Parity‬و ‪ Mode‬را ﺑﺮاﺑﺮ ‪ Asynchronous‬اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪).‬ﺷﻜﻞ ‪(٣-٥‬‬

‫‪٥٧‬‬
 ‫ﺷﻜﻞ ‪ ٣ -٥‬ﺗﻨﻈﻴﻢ ‪ USART‬ﺑﻪ ﺻﻮرت ﻓﺮﺳﺘﻨﺪه‬

‫در اﻳﻦ ﺟﺎ ﺗﻨﻈﻴﻤﺎت اوﻟﻴﻪ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﭘﺎﻳﺎن رﺳﻴﺪه اﺳﺖ و ﺑﺎﻳﺪ ﭘﺮوژه اﻳﺠﺎد و ﻛﺪﻫﺎي ﻣﻮردﻧﻈﺮ ﺗﻮﻟﻴﺪ ﺷﻮﻧﺪ‪.‬‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ دﺳﺘﻮرات زﻳﺮ را ﺑﻪ اﻳﻦ ﻓﺎﻳﻞ اﺻﻠﻲ ﭘﺮوژه اﺿﺎﻓﻪ ﻛﻨﻴﺪ‪ .‬ﺑﻌﺪ از ﻋﺒﺎرت ‪///Declar your local Variables‬‬

‫‪ here‬دﺳﺘﻮرات زﻳﺮ را اﺿﺎﻓﻪ ﻛﻨﻴﺪ‪:‬‬

‫;"!‪char message[]="Hello World‬‬

‫;‪int i‬‬

‫اﻳﻦ دو دﺳﺘﻮر‪ ،‬دو ﻣﺘﻐﻴﺮ را ﺗﻌﺮﻳﻒ ﻣﻲﻛﻨﻨﺪ‪ ،‬اوﻟﻲ ﻣﺘﻐﻴﺮ ‪ message‬ﻛﻪ ﻳﻚ آراﻳﺔ رﺷﺘﻪاي اﺳﺖ و ﻫﻤﺎن ﭘﻴﻐــﺎﻣﻲ اﺳـﺖ‬

‫ﻛﻪ ﻣﻲﺧﻮاﻫﻴﻢ ﺑﻪ ﻛﺎﻣﭙﻴﻮﺗﺮ ﺑﻔﺮﺳﺘﻴﻢ و ﻣﺘﻐﻴﺮ دوم‪ ، i ،‬ﻳﻚ ﺷﻤﺎرﻧﺪه اﺳﺖ‪ .‬ﺣﺎﻻ ﺑﺎﻳــﺪ ﻗﺒـﻞ از ﺣﻠﻘـﻪ )‪ ،while(1‬دﺳـﺘﻮرات زﻳـﺮ را‬

‫اﺿﺎﻓﻪ ﻛﻨﻴﺪ‪ .‬اﻳﻦ دﺳﺘﻮرات ﭘﻴﻐﺎم ”‪ “Hello World‬را ﺑﻪ ﻛﺎﻣﭙﻴﻮﺗﺮ ﻣﻲﻓﺮﺳﺘﻨﺪ‪.‬‬

‫)‪for (i=0;i<12;i++‬‬

‫{‬

‫;)]‪putchar(message[i‬‬

‫}‬

‫‪٥٨‬‬
‫در اﻳﻨﺠﺎ ﻧﻮﺷﺘﻦ ﻛﺪﻫﺎي ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﭘﺎﻳﺎن رﺳﻴﺪه اﺳﺖ‪ .‬ﺣﺎﻻ در ﻣﻨﻮي ‪ ،Project‬ﻗﺴﻤﺖ ‪ Configure‬را اﻧﺘﺨﺎب ﻛــﺮده و‬

‫از ﻗﺴﻤﺖ ‪ After make‬ﮔﺰﻳﻨﻪ ‪ Program the Chip‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ و ﺑﺎ ﻓﺸﺎر دادن دﻛﻤــﻪ ‪ OK‬ﭘﻨﺠـﺮه را ﺑﺒﻨﺪﻳـﺪ‪ .‬در اﻳـﻦ‬

‫ﻗﺴﻤﺖ ﺑﺎﻳﺪ ﺗﻨﻈﻴﻤﺎت ﻣﺮﺑﻮط ﺑﻪ ﺑﺮﻧﺎﻣﻪ ‪ Terminal‬را اﻧﺠﺎم دﻫﻴﺪ‪ .‬اﻳﻦ ﺑﺮﻧﺎﻣﻪ اﻣﻜﺎن ﻣﺸــﺎﻫﺪه اﻃﻼﻋـﺎت رﺳـﻴﺪه از ﭘـﻮرت ﺳـﺮﻳﺎل‬

‫ﺗﻮﺳﻂ ﺗﺮاﺷﻪ و ﻳﺎ اﻣﻜﺎن ﻓﺮﺳﺘﺎدن اﻃﻼﻋﺎت ﺑﺮاي آن را ﻓﺮاﻫﻢ ﻣﻲآورد‪.‬‬

‫از ﻣﻨﻮي ‪ Settings‬ﻗﺴــﻤﺖ ‪ Terminal‬را اﻧﺘﺨـﺎب ﻛﻨﻴـﺪ‪ .‬ﺑـﺎ اﻧﺠـﺎم اﻳـﻦ ﻛـﺎر ﭘﻨﺠـﺮه ‪ Terminal Settings‬ﺑـﺎز‬

‫ﻣﻲﺷﻮد‪).‬ﺷﻜﻞ ‪(٤-٥‬‬

‫ﺷﻜﻞ ‪ ٤ -٥‬ﭘﻨﺠﺮه ‪Terminal Settings‬‬

‫در ﻗﺴﻤﺖ ‪ Port‬ﺑﺎﻳﺪ ﻧﺎم ﭘﻮرت ﺳﺮﻳﺎﻟﻲ را ﻛﻪ ﺗﺮاﺷﻪ ﺑﻪ آن ﻣﺘﺼﻞ اﺳﺖ اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪ .‬در ﻗﺴﻤﺖ ‪،9600 ،Baud rate‬‬

‫در ‪ ،Data bits‬ﻋﺪد ‪ 8‬و در ‪ ،Stopbits‬ﻋﺪد ‪ 1‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ و دﻛﻤﺔ ‪ OK‬را ﻓﺸﺎر دﻫﻴﺪ‪ .‬در اداﻣﻪ ﺑﺮﻧﺎﻣﻪ را ﻛﺎﻣﭙﺎﻳﻞ ﻛـﺮده و‬

‫ﺗﺮاﺷﻪ را ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻛﻨﻴﺪ‪.‬‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ ﺑﺮﻧﺎﻣﻪ ‪ Terminal‬را اﺟﺮا ﻛﺮده و ﭼﮕﻮﻧﮕﻲ اﺟﺮا ﺷﺪن ﺑﺮﻧﺎﻣﻪ را ﻣﺸﺎﻫﺪه ﻧﻤﺎﻳﻴﺪ‪ .‬ﺑﺮاي اﻧﺠﺎم اﻳﻦ ﻛــﺎر از ﻣﻨـﻮي‬

‫‪ Terminal ،Tools‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ و ﻳﺎ از ﻧﻮار اﺑﺰار دﻛﻤﻪ ‪ Run the Terminal‬را ﻓﺸﺎر دﻫﻴﺪ‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ اﻧﺘﻈﺎر داﺷــﺘﻴﻢ‬

‫ﻋﺒﺎرت” ‪ “Hello World‬ﻳﻚ ﺑﺎر روي ﺻﻔﺤﻪ ﻧﻮﺷﺘﻪ ﻣﻲﺷﻮد‪).‬ﺷﻜﻞ ‪ (٥-٥‬ﺗﻮﺳﻂ اﻳﻦ ﺑﺮﻧﺎﻣــﻪ ﻣﻲﺗﻮاﻧﻴـﺪ ﺻﻔﺤـﻪ را ﭘـﺎك ﻛـﺮده و‬

‫ﺗﺮاﺷﻪ را ‪ RESET‬ﻛﻨﻴﺪ‪.‬‬

‫‪٥٩‬‬
 ‫ﺷﻜﻞ ‪ ٥ -٥‬ﺑﺮﻧﺎﻣﻪ ‪Terminal‬‬

‫ﺣﺎﻻ اﮔﺮ ﺑﺨﻮاﻫﻴﻢ اﻳﻦ ﻋﺒﺎرت ﺑﻪ ﺻﻮرت ﻣﺘﻮاﻟﻲ ﺑﻪ ﻛﺎﻣﭙﻴﻮﺗﺮ ﻓﺮﺳﺘﺎده ﺷﻮد ﺑﺎﻳﺪ ﺣﻠﻘﻪ)‪ (For‬ﻧﻮﺷﺘﻪ ﺷﺪه در ﻗﺴﻤﺖ ﻗﺒﻞ را‬

‫در داﺧﻞ ﺣﻠﻘﺔ ‪ while‬ﺑﻨﻮﻳﺴﻴﻢ‪ .‬اﻳﻦ ﻛﺎر را اﻧﺠﺎم دﻫﻴﺪ و ﻧﺘﻴﺠﻪ را ﺑﺒﻴﻨﻴﺪ‪.‬‬

‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ دﻳﺪﻳﺪ ﺑﺮﻗﺮاري ارﺗﺒﺎط ﺳﺮﻳﺎل در ﻧﺮم اﻓﺰار ‪ CodevisionAVR‬ﺑﺴﻴﺎر ﺳﺎده اﺳﺖ‪.‬‬

‫‪LCD‬‬

‫در اﻳﻦ ﻗﺴﻤﺖ ﻗﺼﺪ دارﻳﻢ ﺗﺎ ﻛﺎر ﺑﺎ ‪ LCD‬را ﺑﻴﺎﻣﻮزﻳﻢ‪ .‬ﻣﻲﺧﻮاﻫﻴﻢ ﺑﺮﻧﺎﻣﻪاي ﺑﻨﻮﻳﺴﻴﻢ ﻛﻪ ﺑﻪ ﺻﻮرت ﻣﺪاوم از ﺷﻤﺎرة ‪ ١‬ﺗﺎ‬

‫‪ ١٠٠‬را ﺑﺎ ﻓﺎﺻﻠﺔ ‪ ٠,٢‬ﺛﺎﻧﻴﻪ ﺑﺸﻤﺎرد و ﻫﺮ ﺑﺎر ﺑﺎ رﺳﻴﺪن ﺑﻪ ﻣﻘﺪار ‪ ٢ ،١٠٠‬ﺛﺎﻧﻴﻪ ﺻﺒﺮ ﻛﺮده و دوﺑﺎره از ﻋــﺪد ‪ ١‬ﺷـﺮوع ﻛﻨـﺪ‪ .‬در اﻳـﻦ‬

‫ﺑﺮﻧﺎﻣﻪ از ﻳﻚ ‪ LCD‬ﻛﺎرﻛﺘﺮي ‪ 2 × 16‬اﺳﺘﻔﺎده ﻣﻲﻛﻨﻴﻢ‪.‬‬

‫اﺑﺘﺪا ﭘﺮوژه ﺟﺎري را ﺑﺒﻨﺪﻳﺪ و ﻧﺮم اﻓﺰار ‪ CodewizardAVR‬را اﺟﺮا ﻛﻨﻴﺪ‪ .‬ﺑﻌﺪ از ﺗﻨﻈﻴﻢ ﻧﻮع ﺗﺮاﺷﻪ و ﻛﺮﻳﺴــﺘﺎل ﻣـﻮرد‬

‫اﺳﺘﻔﺎده‪ ،‬ﻗﺴﻤﺖ ‪ LCD‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ)ﺷﻜﻞ ‪ (٦-٥‬و در ﻟﻴﺴﺖ اﻧﺘﺨﺎﺑﻲ ‪ PORTC ،LCD Port‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪.‬‬

‫‪٦٠‬‬
‫ﺷﮑﻞ ‪٦ -٥‬‬

‫‪٦١‬‬
 ‫ﺷﻜﻞ ‪ ٧ -٥‬ﺗﻨﻈﻴﻤﺎت ﻣﺮﺑﻮط ﺑﻪ ‪LCD‬‬

‫در ﻗﺴﻤﺖ ‪ Chars./Line‬ﻫﻢ ﻋﺪد ‪ ١٦‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ‪ .‬ﻋﺪد ‪ ١٦‬ﺑﻪ اﻳﻦ ﻣﻌﻨــﺎ اﺳـﺖ ﻛـﻪ ‪ LCD‬ﻣـﻮرد اﺳـﺘﻔﺎده ﻳـﻚ‬

‫‪ LCD‬ﻛﺎرﻛﺘﺮي ‪ 2 × 16‬اﺳﺖ‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﻗﺴﻤﺖ ﭘﺎﻳﻴﻦ ﭘﻨﺠﺮه ﻣﻲﺑﻴﻨﻴــﺪ‪)،‬ﺷـﻜﻞ ‪ (٧-٥‬ﻃﺮﻳﻘـﻪ اﺗﺼـﺎل ﭘﺎﻳـﻪﻫﺎي ﻣﺨﺘﻠـﻒ‬

‫‪ LCD‬ﺑﻪ ﭘﻴﻨﻬﺎي ﭘﻮرت ‪ C‬ﻣﺸﺨﺺ ﺷﺪهاﻧﺪ‪ .‬اﻟﺒﺘﻪ ﻋﻼوه ﺑﺮ اﻳﻦ ﭘﺎﻳﻪﻫﺎ‪ ،‬در ﻋﻤﻞ ﺣﺪاﻗﻞ ﺳﻪ ﭘﺎﻳﻪ دﻳﮕﺮ از ‪ LCD‬ﻫــﻢ ﺑـﺎﻳﺪ ﺗﻨﻈﻴـﻢ‬

‫ﺷﻮﻧﺪ‪ .‬اﻳﻦ ﭘﺎﻳﻪﻫﺎ ﺑﻪ ﻗﺮار زﻳﺮﻧﺪ‪:‬‬

‫ﭘﺎﻳﻪ اول ﺑﻪ زﻣﻴﻦ‪ ،‬ﭘﺎﻳﻪ دوم ﺑﻪ ﻣﻨﺒﻊ ﺗﻐﺬﻳﻪ ‪ +٥‬وﻟﺖ و ﭘﺎﻳﻪ ﺳﻮم ﻫﻢ ﻛﻪ ﺑﺮاي ﻛﻨﺘﺮل ﻛﻨﺘﺮاﺳﺖ اﺳﺘﻔﺎده ﻣﻲﺷﻮد ﺑــﺎﻳﺪ ﺑـﻪ‬

‫زﻣﻴﻦ ﻣﺘﺼﻞ ﮔﺮدد‪.‬‬

‫‪٦٢‬‬
 ‫‪2x16 LCD‬‬

‫‪16‬‬ ‫‪1‬‬
‫‪+5v‬‬

‫‪29‬‬

‫‪28‬‬

‫‪27‬‬

‫‪26‬‬

‫‪25‬‬

‫‪24‬‬

‫‪23‬‬

‫‪22‬‬

‫‪21‬‬
‫‪ATMega32L‬‬
‫)‪PC5(TDI‬‬

‫)‪PC4(TDO‬‬

‫)‪PC1(SDA‬‬

‫)‪PD7(OC2‬‬
‫)‪PC3(TMS‬‬
‫)‪PC7(TOSC2‬‬

‫)‪PC6(TOSC1‬‬

‫)‪PC2(TCK‬‬

‫)‪PC0(SCL‬‬

‫ﺷﻜﻞ ‪ ٨-٥‬اﺗﺼﺎل ‪ LCD‬ﺑﻪ ‪AVR‬‬

‫در اﻳﻨﺠﺎ ﺗﻨﻈﻴﻤﺎت اوﻟﻴﻪ ﺑﻪ ﭘﺎﻳﺎن رﺳﻴﺪه اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﺑﺎﻳﺪ ﭘﺮوژة ﺟﺪﻳﺪي اﻳﺠﺎد و ﻛﺪﻫﺎي ﻣﻮردﻧﻈﺮ را ﺗﻮﻟﻴﺪ ﻛﻨﻴﺪ‪.‬‬

‫ﺣﺎﻻ ﻛﺎﻓﻲ اﺳﺖ ﺗﺎ ﻛﺪﻫﺎﻳﻲ را ﺑﺮاي اﻧﺠﺎم ﻋﻤﻞ ﺷﻤﺎرش و ﻧﻤــﺎﻳﺶ آﻧـﻬﺎ ﺑـﺮ روي ‪ LCD‬ﺑـﻪ ﺑﺮﻧﺎﻣـﻪ اﺿﺎﻓـﻪ ﻛﻨﻴـﻢ‪ .‬ﺑﻌـﺪ‬

‫> ‪ ≠ include < delag.h‬و > ‪ ≠ include < stdio.h‬را اﺿﺎﻓـﻪ ﻛﻨﻴـﺪ‪.‬‬ ‫ازدﺳﺘﻮر‪ ، ≠ include < mega32.h > ،‬دﺳﺘﻮرات‬

‫ﺳﭙﺲ در اول ﺗﺎﺑﻊ ‪ ،main‬ﺑﻌﺪ از ﻋﺒﺎرت ‪ //Declare your local vaniables here‬دو ﻣﺘﻐﻴﺮ را ﺑﻪ ﺻﻮرت زﻳﺮ ﺗﻌﺮﻳﻒ ﻛﻨﻴﺪ‪.‬‬

‫;‪int i=0‬‬

‫;]‪char lcd_buffer[20‬‬

‫ﻣﺘﻐﻴﺮ ‪ i‬ﻳﻚ ﺷﻤﺎرﻧﺪه اﺳﺖ و ﻣﺘﻐﻴﺮ ‪lcd_buffer‬ﻋﺒﺎرﺗﻲ را ﻛــﻪ ﺑـﺎﻳﺪ در ‪ LCD‬ﻧﺸـﺎن داده ﺷـﻮد در ﺑـﺮ ﻣـﻲ ﮔﻴـﺮد‪.‬‬

‫ﻛﺪﻫﺎي اﺻﻠﻲ ﺑﺮﻧﺎﻣﻪ را در درون ﺣﻠﻘﻪ ‪ while‬و ﺑﻌﺪ از ﻋﺒﺎرت ‪ //place your code here‬ﺑﻨﻮﻳﺴﻴﺪ‪:‬‬

‫)‪for(i=0;i<101;i++‬‬

‫{‬

‫;)‪sprintf(lcd_buffer,"Count from 0-100=%-u",i‬‬

‫;)(‪lcd_clear‬‬

‫;)‪lcd_puts(lcd_buffer‬‬

‫;)‪delay_ms(200‬‬

‫‪٦٣‬‬
 ‫}‬

‫;)‪delay_ms(2000‬‬

‫ﺣﺎﻻ ﺑﺮﻧﺎﻣﻪ را ﻛﺎﻣﭙﺎﻳﻞ ﻛﺮده‪ ،‬ﺗﺮاﺷﻪ را ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻛﻨﻴﺪ و ﻧﺘﻴﺠﻪ را ﻣﺸﺎﻫﺪه ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﻻزم ﺑﻪ ذﻛﺮ اﺳﺖ ﻛﻪ در ﺑﺮﻧﺎﻣﻪ ﺑﺎﻻ‪ ،‬ﻫــﺮ ﺑـﺎر ﺗﻮﺳـﻂ دﺳـﺘﻮر) (‪ LCD, lcd_clear‬ﭘـﺎك ﺷـﺪه و ﺑـﻪ ﻛﻤـﻚ دﺳـﺘﻮر‬

‫) (‪ ، lcd_puts‬ﻋﺒﺎرﺗﻲ را در آن ﻣﻲﻧﻮﻳﺴﻴﻢ‪.‬‬

‫‪ LCD‬و ارﺗﺒﺎط ﺳﺮﻳﺎل‬

‫در اﻳﻦ ﺑﺨﺶ ﻣﻲﺧﻮاﻫﻴﻢ ﺑﺮﻧﺎﻣﻪاي ﺑﻨﻮﻳﺴﻴﻢ ﻛﻪ در آن ﺗﺮاﺷﻪ اﻃﻼﻋﺎت را از ﭘﻮرت ﺳﺮﻳﺎل ﺑﮕﻴﺮد و آﻧﻬﺎ را ﺑــﺮ روي ‪LCD‬‬

‫ﻣﺘﺼﻞ ﺷﺪه ﺑﻪ ﭘﻮرت ‪ C‬ﻧﺸﺎن دﻫﺪ‪ .‬ﺳﺨﺖ اﻓﺰار ﻻزم ﺑﺮاي اﻳﻦ ﺑﺮﻧﺎﻣﻪ در دو ﺑﺮﻧﺎﻣﻪ ﻗﺒﻞ ﻣﻮرد ﺗﻮﺟﻪ ﻗــﺮار ﮔﺮﻓـﺖ‪)،‬ﺷـﻜﻠﻬﺎي ‪ ١-٥‬و‬

‫‪ (٨-٥‬ﺑﻨﺎﺑﺮاﻳﻦ در اﻳﻨﺠﺎ ﺗﻨﻬﺎ ﺑﻪ ﻗﺴﻤﺖ ﻧﺮم اﻓﺰاري آن اﺷﺎره ﻣﻲﻛﻨﻴﻢ‪.‬‬

‫ﻫﻤﺎﻧﻨﺪ ﺑﺮﻧﺎﻣﻪﻫﺎي ﻗﺒﻞ اﺑﺘﺪا ﺑﺮﻧﺎﻣﺔ ‪ CodewizardAVR‬را اﺟﺮا ﻛﻨﻴﺪ‪ ،‬ﭘﺲ از ﺗﻨﻈﻴﻢ ﻧــﻮع ﺗﺮاﺷـﻪ و ﻣﻘـﺪار ﻛﺮﻳﺴـﺘﺎل‬

‫ﻣﻮرد اﺳﺘﻔﺎده در ﻗﺴﻤﺖ ‪ ،Chip‬ﻗﺴﻤﺖ ‪ LCD‬را اﻧﺘﺨﺎب ﻛﺮده و در ﻟﻴﺴﺖ اﻧﺘﺨﺎب ‪ PORTC ،LCD Port‬را اﻧﺘﺨـﺎب ﻛﻨﻴـﺪ‪.‬‬

‫ﺳـﭙﺲ ﻗﺴـﻤﺖ ‪ USART‬را اﻧﺘﺨـﺎب ﻧﻤـﺎﻳﻴﺪ‪ .‬از آﻧﺠـﺎﻳﻲ ﻛـﻪ ﻣﻲﺧﻮاﻫﻴـﻢ ﺗـﺎ از ﺗﺮاﺷـﻪ ﺑـﻪ ﻋﻨـﻮان ﮔﻴﺮﻧـــﺪه اﺳــﺘﻔﺎده ﻛﻨﻴــﻢ‪،‬‬

‫ﻗﺴﻤﺖ‪ Receiver‬را ﻋﻼﻣﺖ ﺑﺰﻧﻴﺪ‪ .‬ﺑﺎ اﻧﺠﺎم اﻳﻦ ﻛﺎر ﻣﻮارد دﻳﮕﺮي ﺑﻪ ﺻﻔﺤﻪ اﺿﺎﻓﻪ ﻣﻲﺷﻮﻧﺪ ﻛﻪ ﻣﻲﺗﻮاﻧﻴﺪ در آن ﭘﺎراﻣﺘﺮﻫﺎي ﻣﺮﺑﻮط‬

‫ﺑﻪ ارﺗﺒﺎط ﺳﺮﻳﺎل را ﺗﻨﻈﻴﻢ ﻛﻨﻴﺪ‪).‬ﺷﻜﻞ ‪ (٩-٥‬اﻳﻦ ﭘﺎراﻣﺘﺮﻫﺎ را ﻫﻤﺎﻧﻨﺪ ﻣﺜﺎل ﻗﺒﻠﻲ در ﻣﻮرد ارﺗﺒﺎط ﺳﺮﻳﺎل ﺗﻨﻈﻴﻢ ﻛﻨﻴﺪ‪.‬‬

‫‪٦٤‬‬
 ‫ﺷﻜﻞ ‪ ٩ -٥‬ﺗﻨﻈﻴﻢ ‪ USART‬ﺑﻪ ﺻﻮرت ﮔﻴﺮﻧﺪه‬

‫ﺑﻌﺪ از اﻧﺠﺎم اﻳﻦ ﻣﺮاﺣﻞ‪ ،‬دﻳﮕﺮ ﻛﺎر ﺗﻨﻈﻴﻤﺎت اوﻟﻴﻪ ﺑﻪ ﭘﺎﻳﺎن رﺳﻴﺪه و ﺑﺎﻳﺪ ﭘــﺮوژه ﺟﺪﻳـﺪي اﻳﺠـﺎد و ﻛﺪﻫـﺎي ﻣﻮردﻧﻈـﺮ را‬

‫ﺗﻮﻟﻴﺪ ﻛﻨﻴﺪ‪.‬‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ ﻣﺘﻐﻴﺮﻫﺎي ﻣﻮرد ﻧﻴﺎز در ﺑﺮﻧﺎﻣﻪ را در ﻗﺴﻤﺖ ‪ ، //Declare your local Varibles here‬در اﺑﺘـﺪاي ﺗـﺎﺑﻊ‬

‫‪ main‬ﺑﻪ ﺻﻮرت زﻳﺮ ﺑﻨﻮﻳﺴﻴﺪ‪.‬‬

‫;‪int i‬‬

‫;‪char code‬‬

‫;]‪char lcd_buffer[38‬‬

‫ﻛﻪ در آن ‪ i‬ﻳﻚ ﺷﻤﺎرﻧﺪه اﺳﺖ‪ ،code .‬ﻛﺎرﻛﺘﺮي اﺳﺖ ﻛﻪ ﻫــﺮ ﺑـﺎر از ﻃﺮﻳـﻖ ﭘـﻮرت ﺳـﺮﻳﺎل درﻳـﺎﻓﺖ ﻣﻲﺷـﻮد و آراﻳـﻪ‬

‫‪ ،lcd_buffer‬ﻛﺎرﻛﺘﺮﻫﺎﻳﻲ اﺳﺖ ﻛﻪ ﺑﺎﻳﺪ در ‪ LCD‬ﻧﻮﺷﺘﻪ ﺷﻮﻧﺪ‪.‬‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ ﺧﻄﻮط اﺻﻠﻲ را در داﺧﻞ ﺣﻠﻘﺔ )‪ while(1‬ﺑﻪ ﺻﻮرت زﻳﺮ اﺿﺎﻓﻪ ﻧﻤﺎﻳﻴﻢ‪.‬‬

‫;)(‪code=getchar‬‬

‫‪٦٥‬‬
 ‫)""=!‪if (code‬‬

‫;{‬

‫)‪for (i=0;i==36;i++‬‬

‫{‬

‫;]‪lcd_buffer[i+1]=lcd_buffer[i‬‬

‫}‬

‫;‪lcd_buffer[0]=code‬‬

‫;)‪lcd_puts(lcd_buffer‬‬

‫}‬

‫دﺳﺘﻮر ) (‪ getchar‬در ﻫﺮ ﺑﺎر اﺟﺮاي ﺣﻠﻘﻪ‪ ،‬ﻛﺎرﻛﺘﺮي را از ﭘﻮرت ﺳﺮﻳﺎل ﻣﻲﮔﻴﺮد و آن را در ﻣﺘﻐﻴﺮ ‪ code‬ﻗﺮار ﻣﻲدﻫﺪ‪.‬‬

‫دﺳﺘﻮر ﺷﺮﻃﻲ ‪ if‬ﻣﻮﺟﺐ ﻣﻲﺷﻮد ﺗﺎ اﮔﺮ واﻗﻌ ﹰﺎ ﻛﺎرﻛﺘﺮي از ﻃﺮﻳﻖ ﭘﻮرت ﺳﺮﻳﺎل ﺑﺮاي ﺗﺮاﺷــﻪ ﻓﺮﺳـﺘﺎده ﺷـﺪه آن ﻛـﺎرﻛﺘﺮ را ﺑـﺮ روي‬

‫‪ LCD‬ﺑﻪ ﻫﻤﺮاه ﻛﺎرﻛﺘﺮﻫﺎي ﻗﺒﻠﻲ ﻧﺸﺎن دﻫﺪ و در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻛﺎري اﻧﺠﺎم ﻧﺪﻫﺪ‪ .‬دﺳﺘﻮرات ﻣﻮﺟﻮد در داﺧﻞ ﺣﻠﻘــﻪ ‪ for‬ﻫـﻢ‬

‫ﻣﻮﺟﺐ ﻣﻲﺷﻮﻧﺪ ﺗﺎ ﺑﺎ رﺳﻴﺪن ﻫﺮ ﻛﺎرﻛﺘﺮ‪ ،‬ﻛﺎرﻛﺘﺮﻫﺎي ﻣﺎﻗﺒﻞ ﻳﻚ واﺣﺪ ﺑﻪ ﺳﻤﺖ راﺳﺖ ﺷﻴﻔﺖ ﭘﻴﺪا ﻛﺮده و ﺑﻪ ﻫﻤﺮاه ﻛﺎرﻛﺘﺮ ﺟﺪﻳــﺪ‬

‫ﺑﺮ روي ﺻﻔﺤﻪ ‪ LCD‬ﻧﺸﺎن داده ﺷﻮﻧﺪ‪ .‬در اﻳﻨﺠﺎ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ﺑــﻪ ﭘﺎﻳـﺎن رﺳـﻴﺪه و ﻣﻲﺗﻮاﻧﻴـﺪ آن را ﻛﺎﻣﭙـﺎﻳﻞ ﻧﻤـﻮده و ﺗﺮاﺷـﻪ را‬

‫ﺑﺮﻧﺎﻣﻪرﻳﺰي ﻛﻨﻴﺪ‪.‬‬

‫ﻣﻲﺗﻮاﻧﻴﻢ ﺻﺤﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﺷﺘﻪ ﺷﺪه را در ﻫﻢ ﻋﻤﻞ ﺑﺒﻴﻨﻴﺪ‪ .‬ﺑﺮاي اﻳﻦ ﻣﻨﻈﻮر اﺑﺘﺪا ﻧﺮم اﻓــﺰار ‪ Notepad‬را اﺟـﺮا ﻛـﺮده و‬

‫ﻋﺒﺎرت ”‪ “Hello World‬را در آن ﺗﺎﻳﭗ ﻛﻨﻴﺪ و آن را ﺑﺎ ﻧﺎم دﻟﺨﻮاه ذﺧﻴﺮه ﻧﻤﺎﻳﻨﺪ‪).‬ﺷﻜﻞ ‪(١٠-٥‬‬

‫‪٦٦‬‬