‫آﻣﻮزش ﺳﺮﻳﻊ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ‪AVR‬‬

‫ﻣﻮﻟﻒ‪ :‬رﺿﺎ ﺳﭙﺎس ﻳﺎر )‪(info@avr.ir‬‬

‫‪www.avr.ir‬‬
 ‫ﻋﻨﻮان ﻣﻄﺎﻟﺐ‬

‫ﻓﻴﻮز ﺑﻴﺖ ﻫﺎ‪ ،‬ﻣﻨﺎﺑﻊ ﻛﻼك و ‪Reset‬‬

‫آﺷﻨﺎﻳﻲ ﺑﺎ زﺑﺎن ‪C‬‬

‫ﭘﺮوژه ‪: 1‬ﻓﻼﺷﺮ ﺳﺎده‬

‫ﭘﺮوژه ‪ :2‬ﻛﺎﻧﺘﺮ ﻳﻚ رﻗﻤﻲ ﺑﺎ ‪7-Segment‬‬

‫ﭘﺮوژه ‪: 3‬ﻧﻤﺎﻳﺸﮕﺮ ﻛﺮﻳﺴﺘﺎل ﻣﺎﻳﻊ )‪(LCD‬‬

‫ﭘﺮوژه ‪ :4‬اﺳﻜﻦ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﻣﺎﺗﺮﻳﺴﻲ‬

‫ﭘﺮوژه ‪ :5‬ﻧﻤﺎﻳﺸﮕﺮﻫﺎي ‪LED Dot Matrix‬‬

‫وﻗﻔﻪ ﻫﺎي ﺧﺎرﺟﻲ‬

‫ﭘﺮوژه ‪ :6‬آﺷﻜﺎر ﺳﺎز ﻋﺒﻮر از ﺻﻔﺮ‬

‫ﺗﺎﻳﻤﺮ‪/‬ﻛﺎﻧﺘﺮ ﺻﻔﺮ‬

‫ﭘﺮوژه ‪ : 7‬ﻓﺮﻛﺎﻧﺲ ﻣﺘﺮ دﻳﺠﻴﺘﺎل‬

‫ﭘﺮوژه ‪ :8‬ﻛﻨﺘﺮل ﻣﻮﺗﻮر ‪ DC‬ﺑﺎ ‪PWM‬‬

‫ﻋﻤﻠﻜﺮد ﺗﺎﻳﻤﺮ دو‬

‫ﭘﺮوژه ‪ :9‬ﺳﺎﻋﺖ ﺑﺎ ‪ RTC‬ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ‬

‫ﺗﺎﻳﻤﺮ‪/‬ﻛﺎﻧﺘﺮ ﻳﻚ‬

‫ﭘﺮوژه ‪ :10‬ﻛﻨﺘﺮل ﺳﺮو‪ ‬ﻣﻮﺗﻮر‬

‫ﭘﺮوژه ‪ :11‬ﺗﻮﻟﻴﺪ ﻣﻮج ﺳﻴﻨﻮﺳﻲ‬

‫ﭘﻮرت ﺳﺮﻳﺎل )‪(RS-232‬‬

‫ﭘﺮوژه ‪ :12‬ﭘﻮرت ﺳﺮﻳﺎل در وﻳﮋوال ﺑﻴﺴﻴﻚ‬

 ‫ﭘﺮوژه ‪ :13‬ارﺗﺒﺎط دﻫﻲ ‪ USB‬ﺑﺎ ‪RS232‬‬

‫)‪I2C Bus (TWI‬‬

‫ﭘﺮوژه ‪ :12‬ارﺗﺒﺎط ﺑﺎ ‪ EEPROM‬ﻫﺎي ‪I2C‬‬

‫ﻣﺒﺪل آﻧﺎﻟﻮگ ﺑﻪ دﻳﺠﻴﺘﺎل‬

‫ﭘﺮوژه ‪ :13‬اﻧﺪازه ﮔﻴﺮي دﻣﺎ ﺑﺎ ﺳﻨﺴﻮر ‪LM35‬‬

‫ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ‬

‫‪SPI Bus‬‬
‫‪Mode‬ﻫﺎي ‪ Sleep‬و ﺗﺎﻳﻤﺮ ‪Watchdog‬‬

‫ﭘﻴﻮﺳﺖ ‪ :1‬ﺗﻨﻈﻴﻤﺎت رﺟﻴﺴﺘﺮﻫﺎي ‪I/O‬‬

‫ﭘﻴﻮﺳﺖ ‪ :2‬ﻧﺤﻮه ي ارﺗﺒﺎط دﻫﻲ ورودي وﺧﺮوﺟﻲ ﻫﺎي ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ‬

‫ﭘﻴﻮﺳﺖ ‪ :3‬ﻣﺸﺨﺼﺎت ﺑﺮﺧﻲ ﻗﻄﻌﺎت ‪AVR‬‬

‫ﭘﻴﻮﺳﺖ ‪ Pinout :4‬ﺑﺮﺧﻲ ﻗﻄﻌﺎت ‪AVR‬‬

‫ﭘﻴﻮﺳﺖ ‪ :5‬ﺧﻼﺻﻪ ي رﺟﻴﺴﺘﺮﻫﺎي‪ATmega16‬‬

‫‪Page |4‬‬
‫‪www.avr.ir‬‬

‫ﻓﻴﻮز ﺑﻴﺖ ﻫﺎ‪ ،‬ﻣﻨﺎﺑﻊ ﻛﻼك و ‪Reset‬‬

‫ﻓﻴﻮز ﺑﻴﺖ ﻫﺎ‬ ‫•‬

‫ﻓﻴﻮز ﺑﻴﺖ ﻫﺎ ﻗﺴﻤﺘﻲ از ﺣﺎﻓﻈﻪ ي ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ‪ AVR‬ﻫﺴﺘﻨﺪ ﻛﻪ اﻣﻜﺎﻧﺎﺗﻲ را در اﺧﺘﻴﺎر ﻛﺎرﺑﺮ ﻗﺮار ﻣﻲ دﻫﻨﺪ و ﺑﺎ‬

‫‪ Erase‬ﺷﺪن ﻣﻴﻜﺮو ﻣﻘﺪار آن ﻫﺎ ﺗﻐﻴﻴﺮ ﻧﻤﻲ ﻛﻨﺪ‪ .‬ﻳﻚ ﺑﻪ ﻣﻌﻨﻲ ﻏﻴﺮ ﻓﻌﺎل ﺑﻮدن و ﺻﻔﺮ ﻓﻌﺎل ﺑﻮدن ﻫﺮ ﺑﻴﺖ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﻗﻄﻌﻪ ي ‪ Mega16‬داراي ‪ 2‬ﺑﺎﻳﺖ ﻓﻴﻮز ﺑﻴﺖ ﻃﺒﻖ ﺟﺪول زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫‪ High Byte‬ﺷﻤﺎره ﺑﻴﺖ‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﭘﻴﺶ ﻓﺮض‬

‫‪0‬‬ ‫‪BOOTRST‬‬ ‫اﻧﺘﺨﺎب ﺑﺮدار ‪ Reset‬ﺑﺨﺶ ‪Boot‬‬ ‫‪1‬‬

‫‪1‬‬ ‫‪BOOTSZ0‬‬ ‫‪0‬‬

‫اﻧﺘﺨﺎب اﻧﺪازه ي ‪Bootloader‬‬
‫‪2‬‬ ‫‪BOOTSZ1‬‬ ‫‪0‬‬

‫‪3‬‬ ‫‪EESAVE‬‬ ‫ﺣﻔﺎﻃﺖ از ‪ EEPROM‬در زﻣﺎن ‪Erase‬‬ ‫‪1‬‬

‫‪4‬‬ ‫‪CKOPT‬‬ ‫اﻧﺘﺨﺎب ﻋﻤﻠﻜﺮد ﻛﻼك‬ ‫‪1‬‬

‫‪5‬‬ ‫‪SPIEN‬‬ ‫ﻓﻌﺎل ﺳﺎز ﭘﺮوﮔﺮام ﺷﺪن از ﻃﺮﻳﻖ ‪SPI‬‬ ‫‪0‬‬

‫‪6‬‬ ‫‪JTAGEN‬‬ ‫ﻓﻌﺎل ﺳﺎز ﭘﻮرت ‪JTAG‬‬ ‫‪0‬‬

‫‪7‬‬ ‫‪OCDEN‬‬ ‫ﻓﻌﺎل ﺳﺎز اﺷﻜﺎل زداﻳﻲ از ﻃﺮﻳﻖ ‪JTAG‬‬ ‫‪1‬‬

‫‬
‫‪Page |5‬‬
‫‪www.avr.ir‬‬
‫ﺷﻤﺎره ﺑﻴﺖ‬ ‫‪Low Byte‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﭘﻴﺶ ﻓﺮض‬

‫‪0‬‬ ‫‪CKSEL0‬‬ ‫‪1‬‬

‫‪1‬‬ ‫‪CKSEL1‬‬ ‫‪0‬‬

‫اﻧﺘﺨﺎب ﻣﻨﺒﻊ ﻛﻼك‬
‫‪2‬‬ ‫‪CKSEL2‬‬ ‫‪0‬‬

‫‪3‬‬ ‫‪CKSEL3‬‬ ‫‪0‬‬

‫‪4‬‬ ‫‪SUT0‬‬ ‫‪0‬‬

‫اﻧﺘﺨﺎب زﻣﺎن ‪Startup‬‬
‫‪5‬‬ ‫‪SUT1‬‬ ‫‪1‬‬

‫‪6‬‬ ‫‪BODEN‬‬ ‫ﻓﻌﺎل ﺳﺎز آﺷﻜﺎر ﺳﺎز ‪Brown-out‬‬ ‫‪1‬‬

‫‪7‬‬ ‫‪BODLEVEL‬‬ ‫ﺗﻨﻈﻴﻢ ﺳﻄﺢ وﻟﺘﺎژ ‪Brown-out‬‬ ‫‪1‬‬

‫‪ :BOOTRST‬اﻧﺘﺨﺎب ﺑﺮدار ري ﺳﺖ ‪ BOOT‬ﻛﻪ در ﺣﺎﻟﺖ ﭘﻴﺶ ﻓﺮض ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﻧﺸﺪه اﺳﺖ و آدرس‬

‫ﺑﺮدار ري ﺳﺖ ‪ 0000‬اﺳﺖ و در ﺻﻮرت ﺑﺮﻧﺎﻣﻪ رﻳﺰي آدرس ﺑﺮدار ‪ Reset‬ﻃﺒﻖ ﺟﺪول زﻳﺮ ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪) .‬ﺑﺮ‬

‫اﺳﺎس ]‪(BOOTSZ[1:0‬‬

‫آدرس ﺑﺮدار ‪ Pages Reset‬اﻧﺪازه ي ‪BOOTSZ1 BOOTSZ0 Boot‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪Word 128‬‬ ‫‪2‬‬ ‫‪$1F80‬‬

‫‪1‬‬ ‫‪0‬‬ ‫‪Word 256‬‬ ‫‪4‬‬ ‫‪$F00‬‬

‫‪0‬‬ ‫‪1‬‬ ‫‪Word 512‬‬ ‫‪8‬‬ ‫‪$E00‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪Word 1024‬‬ ‫‪16‬‬ ‫‪$C00‬‬

‫‬
‫‪Page |6‬‬
‫‪www.avr.ir‬‬

‫‪ :BODEN‬اﻳﻦ ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ‪ Brown-out Detector‬ﺑﻮده و در ﺻﻮرت ﭘﺮوﮔﺮام ﺷﺪن ﻣﻄﺎﺑﻖ وﺿﻌﻴﺖ ﺟﺪول‬

‫زﻳﺮ ﺳﻄﺢ وﻟﺘﺎژ ‪ Brown-out‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪.‬‬

‫ﺳﻄﺢ وﻟﺘﺎژ ‪BODEN BODLEVEL Brown-out‬‬

‫‪1‬‬ ‫‪1‬‬ ‫ﻏﻴﺮ ﻓﻌﺎل‬

‫‪1‬‬ ‫‪0‬‬ ‫ﻏﻴﺮ ﻓﻌﺎل‬

‫‪0‬‬ ‫‪1‬‬ ‫‪Vcc=2.7v‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪Vcc=4.0v‬‬

‫ﻣﻨﺎﺑﻊ ﻛﻼك‬ ‫•‬

‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ در دﻳﺎﮔﺮام زﻳﺮ دﻳﺪه ﻣﻲ ﺷﻮد‪ ،‬اﻳﻦ ﻣﻨﺎﺑﻊ ﺷﺎﻣﻞ‪ :‬اﺳﻴﻼﺗﻮر ‪ RC‬ﻛﺎﻟﻴﺒﺮه ﺷﺪه‪ ،‬اﺳﻴﻼﺗﻮر ﻛﺮﻳﺴﺘﺎﻟﻲ ﻓﺮﻛﺎﻧﺲ‬

‫ﭘﺎﻳﻴﻦ‪ ،‬اﺳﻴﻼﺗﻮر ﻛﺮﻳﺴﺘﺎﻟﻲ‪ ،‬ﻛﻼك ﺧﺎرﺟﻲ‪ ،‬اﺳﻴﻼﺗﻮر ‪ RC‬ﺧﺎرﺟﻲ و اﺳﻴﻼﺗﻮر ﺗﺎﻳﻤﺮ‪/‬ﻛﺎﻧﺘﺮ ﻣﻲ ﺑﺎﺷﻨﺪ‪.‬‬

‫‬
‫‪Page |7‬‬
‫‪www.avr.ir‬‬

‫اﻧﺘﺨﺎب ﻣﻨﺒﻊ ﻛﻼك ﺑﻮﺳﻴﻠﻪ ي ﻓﻴﻮزﺑﻴﺖ ﻫﺎي ‪ CKSEL‬ﺑﻮده و ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض ﺑﻴﺖ‬

‫ﻫﺎي ‪ ،CKSEL‬ﻳﻚ ﺑﻮده و در ﻧﺘﻴﺠﻪ ﻣﻨﺒﻊ ﭘﻴﺶ ﻓﺮض‪ ،‬اﺳﻴﻼﺗﻮر ‪ RC‬داﺧﻠﻲ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫‬
‫‪Page |8‬‬
‫‪www.avr.ir‬‬
‫ﻛﻼك ﺧﺎرﺟﻲ‪ :‬ﺑﺮاي راه اﻧﺪازي وﺳﻴﻠﻪ ﺑﻮﺳﻴﻠﻪ ي ﻣﻨﺒﻊ ﻛﻼك ﺧﺎرﺟﻲ ﺑﺎﻳﺪ ﻣﻄﺎﺑﻖ ﺷـﻜﻞ زﻳـﺮ ﻳـﻚ ﭘـﺎﻟﺲ ﺑـﻪ ﭘـﻴﻦ‬

‫‪ XTAL1‬اﻋﻤﺎل ﺷﻮد‪ .‬ﺑﺮاي ﻗﺮار ﮔﺮﻓﺘﻦ در اﻳﻦ وﺿﻌﻴﺖ ﺑﺎﻳﺪ ﺗﻤﺎم ﺑﻴﺖ ﻫﺎي ‪ CKSEL‬ﭘﺮوﮔﺮام ﺷﺪه )ﺻﻔﺮ ﺷﻮﻧﺪ(‬

‫و ﻛﺎرﺑﺮ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎ ﭘﺮوﮔﺮام ﻛﺮدن ﻓﻴﻮزﺑﻴﺖ ‪ CKOPT‬ﻳﻚ ﺧﺎزن داﺧﻠﻲ ﺑﻪ ﻇﺮﻓﻴﺖ ‪ 36‬ﭘﻴﻜﻮﻓﺎراد را ﺑﻴﻦ ورودي و‬

‫زﻣﻴﻦ ﻗﺮار دﻫﺪ‪.‬‬

‫‪XTAL1‬‬
‫ﻛﻼك ﺧﺎرﺟﻲ‬

‫‪CKOPT‬‬

‫‪XTAL2‬‬
‫‪36 pF‬‬

‫اﺳﻴﻼﺗﻮر ‪ RC‬ﻛﺎﻟﻴﺒﺮه ﺷﺪه ي داﺧﻠﻲ‪ :‬اﻳﻦ ﻣﻨﺒﻊ در ﻓﺮﻛﺎﻧﺲ ﻫﺎي ‪ 4 ،2 ،1‬و ‪ 8‬ﻣﮕﺎﻫﺮﺗﺰ ﻣﻮﺟﻮد ﻣﻲ ﺑﺎﺷـﺪ و ﻣﻘـﺪار‬

‫آن در دﻣﺎي ‪ 25‬درﺟﻪ و وﻟﺘﺎژ ‪ 5‬وﻟﺖ ﻛﺎﻟﻴﺒﺮه ﺷﺪه اﺳﺖ ﻛﻪ در اﻳﻦ وﺿﻌﻴﺖ ﻣﻤﻜﻦ اﺳﺖ ﺗﺎ ‪ 3‬درﺻﺪ در ﻛﻼك اﻳﺠﺎد‬

‫ﺷﺪه وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﻓﺮﻛﺎﻧﺲ ﻧﻮﺳﺎن ﺑﻮﺳﻴﻠﻪ ي ﻓﻴﻮزﺑﻴﺖ ﻫﺎي ‪ CKSEL‬ﺗﻌﻴﻴﻦ ﺷﺪه و ﻣﻄـﺎﺑﻖ ﺟـﺪول زﻳـﺮ ﻣـﻲ‬

‫ﺑﺎﺷﺪ‪ .‬در اﻳﻦ وﺿﻌﻴﺖ ‪ CKOPT‬ﻧﺒﺎﻳﺪ ﭘﺮوﮔﺮام ﺷﻮد‪.‬‬

‫‬
‫‪Page |9‬‬
‫‪www.avr.ir‬‬
‫اﺳﻴﻼﺗﻮر ‪ RC‬ﺧﺎرﺟﻲ‪ :‬در ﻛﺎرﺑﺮدﻫﺎﻳﻲ ﻛﻪ دﻗﺖ ﻛﻼك اﻫﻤﻴﺖ زﻳﺎدي ﻧﺪارد ﻣﻲ ﺗـﻮان از اﻳـﻦ ﻣﻨﺒـﻊ اﺳـﺘﻔﺎده ﻛـﺮد‪.‬‬

‫‪1‬‬
‫= ‪ f‬ﺑﺪﺳﺖ ﻣﻲ آﻳﺪ‪ .‬ﺣﺪاﻗﻞ ﻣﻘﺪار ‪ C‬ﺑﺮاﺑﺮ ‪22‬‬ ‫ﭘﻴﻜﺮﺑﻨﺪي ﻣﻄﺎﺑﻖ ﺷﻜﻞ زﻳﺮ ﺑﻮده و ﻓﺮﻛﺎﻧﺲ ﻧﻮﺳﺎن از راﺑﻄﻪ ي‬
‫‪3 RC‬‬

‫ﭘﻴﻜﻮﻓﺎراد ﺑﻮده و در ﺻﻮرﺗﻲ ﻛﻪ ‪ CKOPT‬ﭘﺮوﮔﺮام ﺷﻮد ﻣﻲ ﺗﻮان ﻣﻘﺪار ‪ 36‬ﭘﻴﻜﻮﻓﺎراد را ﻧﻴﺰ ﻟﺤﺎظ ﻧﻤﻮد‪.‬‬

‫‪R‬‬
‫‪XTAL1‬‬

‫‪C‬‬
‫‪CKOPT‬‬

‫‪XTAL2‬‬ ‫‪36 pF‬‬

‫اﻳﻦ ﻣﻨﺒﻊ ﻧﻮﺳﺎن ﻣﻲ ﺗﻮاﻧﺪ در ﭼﻬﺎر ‪ Mode‬ﻛﺎري ﻋﻤﻞ ﻛﻨﺪ ﻛﻪ ﻫﺮ ﻛﺪام ﺑﺮاي ﻳﻚ ﺑﺎزه ي ﻓﺮﻛﺎﻧﺴﻲ ﺑﻬﻴﻨﻪ ﺷﺪه اﺳﺖ‬

‫و ﺑﻮﺳﻴﻠﻪ ي ﻓﻴﻮزﺑﻴﺖ ﻫﺎي ‪ CKSEL‬ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ اﻧﺘﺨﺎب ﻣﻲ ﺷﻮد‪.‬‬

‫اﺳﻴﻼﺗﻮر ﻛﺮﻳﺴﺘﺎﻟﻲ ﻓﺮﻛﺎﻧﺲ ﭘﺎﻳﻴﻦ‪ :‬اﻳﻦ ﻣﻨﺒﻊ ﻛﻼك ﻣﻲ ﺗﻮاﻧﺪ ﻛﺮﻳﺴﺘﺎل ﻫﺎي ﻓﺮﻛﺎﻧﺲ ﭘﺎﻳﻴﻦ ﻣﺜﻞ ﻛﺮﻳﺴﺘﺎل ﺳﺎﻋﺖ ﺑﺎ‬

‫ﻓﺮﻛﺎﻧﺲ ‪ 32768‬ﻫﺮﺗﺰ ﺑﺎﺷﺪ‪ .‬ﺑﺎ دادن ﻣﻘﺪار ‪ 1001‬ﺑﻪ ﻓﻴﻮزﺑﻴﺖ ﻫﺎي ‪ CKSEL‬ﻣﻨﺒﻊ ﻛﻼك ﻛﺮﻳﺴﺘﺎل ﺧﺎرﺟﻲ ﻓﺮﻛﺎﻧﺲ‬

‫‬
‫‪P a g e | 10‬‬
‫‪www.avr.ir‬‬
‫ﭘﺎﻳﻴﻦ اﻧﺘﺨﺎب ﺷﺪه و در اﻳﻦ وﺿﻌﻴﺖ ﭘﻴﻜﺮﺑﻨﺪي ﻣﻄﺎﺑﻖ ﺷﻜﻞ زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪ .‬در ﺻﻮرت ﭘﺮوﮔﺮام ﻧﻤﻮدن ‪CKOPT‬‬

‫ﻣﻲ ﺗﻮان از ﺧﺎزن ﺧﺎرﺟﻲ ﺻﺮﻓﻨﻈﺮ ﻧﻤﻮد‪.‬‬

‫‪36 pF‬‬

‫‪CKOPT‬‬
‫‪C1‬‬
‫‪XTAL1‬‬

‫‪XTAL‬‬ ‫‪Rf‬‬

‫‪XTAL2‬‬

‫‪C2‬‬
‫‪CKOPT‬‬

‫‪36 pF‬‬

‫ﻛﺮﻳﺴﺘﺎل ﻛﻮارﺗﺰ ﻳﺎ رزوﻧﺎﺗﻮر ﺳﺮاﻣﻴﻜﻲ‪ :‬ﭘﺒﻦ ﻫـﺎي ‪ XTAL1‬و ‪ XTAL2‬ﺑـﻪ ﺗﺮﺗﻴـﺐ ورودي و ﺧﺮوﺟـﻲ ﻳـﻚ‬

‫ﺗﻘﻮﻳﺖ ﻛﻨﻨﺪه ي واروﻧﮕﺮ ﻫﺴﺘﻨﺪ ﻛﻪ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﻪ ﻋﻨﻮان ﻳﻚ اﺳﻴﻼﺗﻮر ‪ On-chip‬ﻣﻄﺎﺑﻖ ﺷﻜﻞ زﻳﺮ ﭘﻴﻜﺮﺑﻨﺪي ﺷﻮﻧﺪ‪.‬‬

‫
‬
‫‪P a g e | 11‬‬
‫‪www.avr.ir‬‬

‫‪C1‬‬
‫‪XTAL1‬‬

‫‪XTAL‬‬ ‫‪Rf‬‬

‫‪XTAL2‬‬

‫‪C2‬‬

‫• ﺑﻪ ﺟﺎي ﻛﺮﻳﺴﺘﺎل ﻛﻮارﺗﺰ ﻣﻲ ﺗﻮان از رزوﻧﺎﺗﻮر ﺳﺮاﻣﻴﻜﻲ اﺳﺘﻔﺎده ﻧﻤـﻮد ﻛـﻪ از دوام ﺑﻴﺸـﺘﺮي در ﻣﻘﺎﺑـﻞ ﺿـﺮﺑﻪ ﺑـﺮ‬

‫ﺧﻮردار اﺳﺖ و زﻣﺎن ‪ Startup‬ﻛﻤﺘﺮي ﻧﻴﺰ دارد و اﻟﺒﺘﻪ ﻧﺴﺒﺖ ﺑﻪ ﻛﺮﻳﺴﺘﺎل ﻛﻮارﺗﺰ دﻗـﺖ ﻛﻤﺘـﺮي داﺷـﺘﻪ و ﭘﺎﻳـﺪاري‬

‫دﻣﺎﻳﻲ آن ﻧﻴﺰ ﻛﻤﺘﺮ اﺳﺖ‪.‬‬

‫• در اﻳﻦ وﺿﻌﻴﺖ ﺧﺎزن ﻫﺎي ‪ 36‬ﭘﻴﻜﻮ ﻓﺎراد ﺣﺬف ﺷﺪه و ﻋﻤﻠﻜﺮد ﻓﻴﻮزﺑﻴﺖ ‪ CKOPT‬ﻧﻴﺰ ﺗﻐﻴﻴﺮ ﻣـﻲ ﻛﻨـﺪ‪ .‬ﺑـﺪﻳﻦ‬

‫ﺗﺮﺗﻴﺐ ﻛﻪ ﺑﺎ ﭘﺮوﮔﺮام ﺷﺪن اﻳﻦ ﺑﻴﺖ داﻣﻨﻪ ي ﺧﺮوﺟﻲ ﺗﻘﻮﻳﺖ ﻛﻨﻨﺪه ي واروﻧﮕﺮ اﻓـﺰاﻳﺶ ﻳﺎﻓﺘـﻪ و ﻣـﻲ ﺗـﻮان از ﭘـﻴﻦ‬

‫‪ XTAL2‬ﺑﻪ ﻋﻨﻮان ﻛﻼك ﺑﺮاي ﻳﻚ وﺳﻴﻠﻪ ي دﻳﮕﺮ اﺳﺘﻔﺎده ﻧﻤﻮد‪ .‬ﻫﻤﭽﻨﻴﻦ ﺑﺎ ﻓﻌﺎل ﻛﺮدن ‪ CKOPT‬در ﻣﺤﻴﻂ ﻫﺎي‬

‫ﻧﻮﻳﺰي ﻋﻤﻠﻜﺮد اﺳﻴﻼﺗﻮر ﺑﻬﺒﻮد ﻣﻲ ﻳﺎﺑﺪ‪.‬‬

‫• ﭼﻨﺎﻧﭽﻪ از رزوﻧﺎﺗﻮر اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ﺑﺮاي ﻓﺮﻛﺎﻧﺲ ﻫﺎي ﺑﺎﻻﺗﺮ از ‪ 8‬ﻣﮕﺎﻫﺮﺗﺰ ﺑﺎﻳﺪ ‪ CKOPT‬ﭘﺮوﮔﺮام ﺷﻮد‪.‬‬

‫اﺳﻴﻼﺗﻮر ﻣﻲ ﺗﻮاﻧﺪ در ﺳﻪ وﺿﻌﻴﺖ ﻣﺘﻔﺎوت ﻧﻮﺳﺎن ﻛﻨﺪ ﻛﻪ ﻫﺮﻛﺪام ﺑﺮاي ﻳﻚ ﻣﺤﺪوده ي ﻓﺮﻛﺎﻧﺴﻲ ﺑﻬﻴﻨﻪ ﺷﺪه اﺳﺖ و‬

‫آن را ﻣﻲ ﺗﻮان ﺑﺎ ﻓﻴﻮز ﺑﻴﺖ ﻫﺎي ‪ CKSEL‬ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ اﻧﺘﺨﺎب ﻧﻤﻮد‪.‬‬

‫ ‬
‫‪P a g e | 12‬‬
‫‪www.avr.ir‬‬

‫
ﺑﺎ ﻫﺮ ﻳﻚ از ﻣﻨﺎﺑﻊ ﻛﻼك اﻧﺘﺨﺎب ﺷﺪه ﺑﻮﺳﻴﻠﻪ ي ﻓﻴﻮزﺑﻴﺖ ﻫﺎي ‪ ،CKSEL‬دو ﺑﻴﺖ ﺑﻪ ﻧﺎم ﻫﺎي ]‪ SUT[1:0‬ﻧﻴﺰ‬

‫وﺟﻮد دارد ﻛﻪ از ﻃﺮﻳﻖ آن ﻣﻲ ﺗﻮان ﺣﺪاﻛﺜﺮ زﻣﺎن ‪ Start-up‬ﻣﻨﺒﻊ ﻛﻼك را ﺑﻪ ﻣﻴﻜﺮو اﻋﻼم ﻧﻤﻮد‪ .‬ﻣﻘﺪار اﻳﻦ ﺑﻴﺖ ﻫﺎ‬

‫ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﻣﺎﻛﺰﻳﻤﻢ زﻣﺎن ‪ Start-up‬را در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد و در ﺻﻮرﺗﻲ ﻛـﻪ ﻧﻴـﺎز اﺳـﺖ ﻣﻘـﺪار آن را ﺗﻐﻴﻴـﺮ‬

‫دﻫﻴﺪ ﻣﻄﺎﺑﻖ ﺟﺪاول ﻣﺮﺑﻮﻃﻪ در ﻓﺼﻞ ‪ System Clock and Clock Options‬در ‪ Datatsheet‬ﻋﻤﻞ ﻛﻨﻴﺪ‪.‬‬

‫ﻣﻨﺎﺑﻊ ‪Reset‬‬ ‫•‬

‫ﺑﺎ ‪ Reset‬ﺷﺪن ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ‪ ،‬ﺗﻤﺎم رﺟﻴﺴﺘﺮﻫﺎي ‪ I/O‬ﺑﻪ ﻣﻘﺪار اوﻟﻴﻪ ﺷﺎن ﺗﻐﻴﻴﺮ ﻣﻲ ﻛﻨﻨﺪ و ‪ CPU‬ﺷﺮوع ﺑﻪ اﺟﺮاي‬

‫دﺳﺘﻮراﻟﻌﻤﻞ ﻫﺎ از ﺑﺮدار ‪ Reset‬ﺧﻮاﻫﺪ ﻛﺮد‪ .‬در ﻗﻄﻌﻪ ي ‪ 5 Mega16‬ﻣﻨﺒﻊ ‪ Reset‬وﺟﻮد دارد ﻛﻪ ﻋﺒﺎرﺗﻨﺪ از‪:‬‬

‫‪1.‬‬ ‫‪Power-on Reset‬‬

‫‪2.‬‬ ‫‪External Reset‬‬
‫‪3.‬‬ ‫‪Brown-out Reset‬‬
‫‪4.‬‬ ‫‪Watchdog Reset‬‬
‫‪5.‬‬ ‫‪JTAG AVR Reset‬‬

‫  ‬
‫‪P a g e | 13‬‬
‫‪www.avr.ir‬‬
‫ﻣﻨﻄﻖ ‪ Reset‬ﻣﻄﺎﺑﻖ دﻳﺎﮔﺮام زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫ﻣﺸﺨﺼﺎت ﻫﺮ ﻳﻚ از ﻣﻨﺎﺑﻊ ‪ Reset‬را در ﺟﺪول زﻳﺮ ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ‪:‬‬

‫  ‬
‫‪P a g e | 14‬‬
‫‪www.avr.ir‬‬

‫‪ :Power-on Reset‬زﻣﺎﻧﻲ ﻓﻌﺎل ﺧﻮاﻫﺪ ﻛﻪ وﻟﺘﺎژ ‪ Vcc‬ﻛﻤﺘﺮ از ﺣﺪ ﺗﻌﻴﻴﻦ ﺷﺪه ﺑﺎﺷﺪ‪ .‬اﻳﻦ ﻣﻨﺒﻊ ﺗﻀـﻤﻴﻦ‬ ‫‪.1‬‬

‫ﻣﻲ ﻛﻨﺪ ﻛﻪ وﺳﻴﻠﻪ در زﻣﺎن راه اﻧﺪازي ‪ Reset‬ﻣﻲ ﺷﻮد‪ .‬ﺑﺎ رﺳﻴﺪن وﻟﺘﺎژ ﺑﻪ ﺣﺪ آﺳﺘﺎﻧﻪ‪ ،‬ﺷﻤﺎرﻧﺪه ي ﺗﺎﺧﻴﺮ راه اﻧـﺪازي‬

‫ﺷﺪه ﻛﻪ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ ﭼﻪ ﻣﺪت وﺳﻴﻠﻪ در وﺿﻌﻴﺖ ‪ Reset‬ﺑﻤﺎﻧﺪ‪ .‬دﻳﺎﮔﺮام زﻣﺎﻧﻲ زﻳﺮ ﺷﺮاﻳﻄﻲ را ﻧﺸﺎن ﻣﻲ دﻫـﺪ ﻛـﻪ‬

‫ﭘﻴﻦ ‪ RESET‬ﺑﻪ ‪ Vcc‬وﺻﻞ ﺷﺪه اﺳﺖ‪) .‬و ﻳﺎ آزاد ﺑﺎﺷﺪ ﭼﻮن اﻳﻦ ﭘﻴﻦ از داﺧﻞ ‪ Pull-up‬ﺷﺪه اﺳﺖ‪(.‬‬

‫و ﻧﻤﻮدار زﻳﺮ ﺷﺮاﻳﻄﻲ اﺳﺖ ﻛﻪ ﺳﻄﺢ ﻣﻨﻄﻘﻲ ﭘﻴﻦ ‪ Reset‬ﺗﺎﺑﻊ ‪ Vcc‬ﻧﻤﻲ ﺑﺎﺷﺪ‪:‬‬

‫  ‬
‫‪P a g e | 15‬‬
‫‪www.avr.ir‬‬

‫‪ :External Reset .2‬اﻳﻦ ‪ Reset‬ﺑﻮﺳﻴﻠﻪ ي ﻳﻚ ﭘﺎﻟﺲ ﺑﺎ ﺳﻄﺢ ﺻﻔﺮ ﻣﻨﻄﻘﻲ روي ﭘﻴﻦ ‪ RESET‬اﻳﺠﺎد ﺷﺪه و‬

‫ﺣﺪاﻗﻞ ﻋﺮض آن ‪ 1.5‬ﻣﻴﻜﺮو ﺛﺎﻧﻴﻪ ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﺑﺎ رﺳﻴﺪن وﻟﺘﺎژ اﻳﻦ ﭘﻴﻦ ﺑﻪ ﻣﻘﺪار آﺳﺘﺎﻧﻪ در ﻟﺒﻪ ﺑﺎﻻ روﻧﺪه‪ ،‬ﺷـﻤﺎرﻧﺪه ي‬

‫ﺗﺎﺧﻴﺮ ﺷﺮوع ﺑﻪ ﻛﺎر ﻛﺮده و ﭘﺲ از اﺗﻤﺎم زﻣﺎن ‪ Time-out‬ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ﻛﺎر ﺧﻮد را ﺷﺮوع ﺧﻮاﻫﺪ ﻛﺮد‪.‬‬

‫‪ :Brown-out Detection‬ﻗﻄﻌـﻪ ي ‪ ATmega16‬داراي ﻳـﻚ ﻣـﺪار ‪Brown-out Detection‬‬ ‫‪.3‬‬

‫داﺧﻠﻲ ﺑﻮده ﻛﻪ ﭘﻴﻮﺳﺘﻪ ﻣﻘﺪار وﻟﺘﺎژ ‪ Vcc‬را ﺑﺎ ﻳﻚ ﻣﻘﺪار ﺛﺎﺑﺖ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﻛﻨﺪ‪ .‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ ﺑﺮاﺑﺮ ‪ 2.7‬وﻟﺖ ﺑـﻮده‬

‫و در ﺻﻮرﺗﻲ ﻛﻪ ﻓﻴﻮزﺑﻴﺖ ‪ BODLEVEL‬ﭘﺮوﮔﺮام ﺷﻮد ﺑﻪ ‪ 4.0‬وﻟﺖ اﻓﺰاﻳﺶ ﻣﻲ ﻳﺎﺑﺪ‪ .‬ﺑﺎ ﻛﻤﺘﺮ ﺷﺪن وﻟﺘـﺎژ ﺗﻐﺬﻳـﻪ‬

‫از اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ وارد ﺣﺎﻟﺖ ‪ Reset‬ﺷﺪه و ﺑﺎ ﻋﺎدي ﺷﺪن وﻟﺘﺎژ‪ ،‬ﭘـﺲ از اﺗﻤـﺎم ﺗـﺎﺧﻴﺮ ﺑـﻪ وﺿـﻌﻴﺖ‬

‫ﻋﺎدي ﺑﺎز ﻣﻲ ﮔﺮدد‪ .‬ﺑﺮاي ﺣﻔﺎﻇﺖ در ﺑﺮاﺑﺮ ‪ Spike‬ﻣﻘﺪار آﺳﺘﺎﻧﻪ داراي ﭘﺴـﻤﺎﻧﺪ ﺑـﻮده و در ﻧﺘﻴﺠـﻪ داراي دو ﻣﻘـﺪار‬

‫  ‬
‫‪P a g e | 16‬‬
‫‪www.avr.ir‬‬
‫ﻣﺜﺒﺖ و ﻣﻨﻔﻲ ﻣﻲ ﺑﺎﺷـﺪ ﻛـﻪ ﺑـﺎ ﺗﻮﺟـﻪ ﺑـﻪ ﻣﻘـﺎدﻳﺮ ﻣﻮﺟـﻮد در ﺟـﺪول از راﺑﻄـﻪ ي ‪ VBOT+ = VBOT + VHYST / 2‬و‬

‫‪ VBOT− = VBOT − VHYST / 2‬ﺑﺪﺳﺖ ﻣﻲ آﻳﺪ‪.‬‬

‫
ﻣﺪار ‪ Brown-out Detection‬در ﺣﺎﻟـﺖ ﻋـﺎدي ﻏﻴـﺮ ﻓﻌـﺎل ﺑـﻮده و ﺑـﺮاي راه اﻧـﺪازي آن ﺑﺎﻳـﺪ ﻓﻴﻮزﺑﻴـﺖ‬

‫‪ BODEN‬ﭘﺮوﮔﺮام )ﺻﻔﺮ( ﺷﻮد‪.‬‬

‫‪ :Watchdog Reset .4‬ﺑﺎ اﺗﻤﺎم زﻣﺎن ﺗﺎﻳﻤﺮ ‪ ،Watchdog‬اﻳﻦ ﺗﺎﻳﻤﺮ ﻳﻚ ﭘﺎﻟﺲ ﺑـﻪ ﻋـﺮض ﻳـﻚ ﺳـﻴﻜﻞ اﻳﺠـﺎد‬

‫ﺧﻮاﻫﺪ ﻛﺮد‪ .‬در ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧﺪه ي اﻳﻦ ﭘﺎﻟﺲ‪ ،‬ﺗﺎﻳﻤﺮ ﺗﺎﺧﻴﺮ ﺷﺮوع ﺑﻪ ﺷﻤﺎرش زﻣﺎن ﺗﺎﺧﻴﺮ ﻛﺮده و ﭘﺲ ازاﺗﻤـﺎم آن‬

‫ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ﻛﺎر ﻋﺎدي ﺧﻮد را اداﻣﻪ ﺧﻮاﻫﺪ داد‪.‬‬

‫  ‬
P a g e | 17
www.avr.ir

MCU Control and Status Register

MCUCSR 7 6 5 4 3 2 1 0
‫ﻧﺎم ﺑﻴﺖ‬ JTD ISC2 - JTRF WDRF BORF EXTRF PORF

‫ ﺷﺪه‬CPU ‫ ﺑﺎﻋﺚ راه اﻧﺪازي ﻣﺠﺪد‬Reset ‫اﻳﻦ رﺟﻴﺴﺘﺮ ﻣﺤﺘﻮي اﻃﻼﻋﺎﺗﻲ اﺳﺖ ﻛﻪ ﻧﺸﺎن ﻣﻲ دﻫﺪ ﻛﺪاﻣﻴﻚ از ﻣﻨﺎﺑﻊ‬

Reset ‫ ﭘﺮﭼﻢ را ﭘﺎك ﻛﻨـﺪ ﺗـﺎ در ﺻـﻮرت‬،‫ ﻧﺮم اﻓﺰار ﭘﺲ از ﺧﻮاﻧﺪن ﻫﺮ ﺑﻴﺖ ﺑﺎﻳﺪ ﺑﺎ ﻧﻮﺷﺘﻦ ﺻﻔﺮ ﺑﺮ روي آن‬.‫اﺳﺖ‬

.‫ وﻗﻮع آن ﻗﺎﺑﻞ ﺗﺸﺨﻴﺺ ﺑﺎﺷﺪ‬،‫ﻣﺠﺪد‬

Bit 0 – PORF: Power-on Reset Flag

Bit 1 – EXTRF: External Reset Flag
Bit 2 – BORF: Brown-out Reset Flag
Bit 3 – WDRF: Watchdog Reset Flag
Bit 4 – JTRF: JTAG Reset Flag

  
‫‪P a g e | 18‬‬
‫‪www.avr.ir‬‬

‫آﺷﻨﺎﻳﻲ ﺑﺎ زﺑﺎن ‪C‬‬

‫• ﻫﺮ ﺑﺮﻧﺎﻣﻪ ي ‪ C‬ﺣﺪاﻗﻞ ﻳﻚ ﺗﺎﺑﻊ )(‪ main‬دارد‪) .‬اﻳﻦ اوﻟﻴﻦ ﺗﺎﺑﻊ اﺟﺮاﻳﻲ اﺳﺖ‪(.‬‬

‫• ﻳﻚ ﺑﺮﻧﺎﻣﻪ ي ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮي در ﺳﺎده ﺗﺮﻳﻦ ﺣﺎﻟﺖ ﺧﻮد ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ‪:‬‬

‫ﺗﻌﺎرﻳﻒ ﻛﻠﻲ‬

‫اﻟﮕﻮي ﺗﻮاﺑﻊ‬

‫)(‪void main‬‬
‫{‬
‫{)‪while(1‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫}‬
‫}‬

‫ﺗﻮاﺑﻊ ﺗﻌﺮﻳﻒ ﺷﺪه‬

‫• ﺑﺮﻧﺎﻣﻪ ي ﺳﺎده ي زﻳﺮ رﺷﺘﻪ ي ‪ Hello World‬را ﺑﻪ ﺧﺮوﺟﻲ اﺳﺘﺎﻧﺪارد ارﺳﺎل ﻣﻲ ﻛﻨﺪ‪.‬‬

‫  ‬
‫‪P a g e | 19‬‬
‫‪www.avr.ir‬‬

‫>‪#include<stdio.h‬‬

‫)(‪void main‬‬
‫{‬
‫;)"!‪printf("Hello World‬‬
‫;)‪while(1‬‬
‫}‬

‫• ﺧﻂ اول از رﻫﻨﻤﻮد ﻫﺎي ﭘﻴﺶ ﭘﺮدازﻧﺪه اﺳﺖ‪.‬‬

‫• )‪ while(1‬اﻳﺠﺎد ﻳﻚ ﺣﻠﻘﻪ ي ﻧﺎﻣﺘﻨﺎﻫﻲ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫• در اﻧﺘﻬﺎي ﻫﺮ ﻋﺒﺎرت ﻳﻚ ﺳﻤﻲ ﻛﺎﻟﻦ ﻣﻲ آﻳﺪ‪.‬‬

‫• ‪ Brace‬اﺑﺘﺪا و اﻧﺘﻬﺎي ﻳﻚ ﺗﺎﺑﻊ و ﻫﻤﭽﻨﻴﻦ ﻳﻚ ﺑﻠﻮك را ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫• از " " ﺑﺮاي ﻣﺸﺨﺺ ﻛﺮدن اﺑﺘﺪا و اﻧﺘﻬﺎي ﻳﻚ رﺷﺘﻪ ي ﻣﺘﻨﻲ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‪.‬‬

‫• از ‪ //‬ﻳﺎ ‪ /* … */‬ﺑﺮاي ﻧﻮﺷﺘﻦ ﺗﻮﺿﻴﺤﺎت اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‪.‬‬

‫• ﺷﻨﺎﺳﻪ ﻫﺎ اﺳﺎﻣﻲ ﻣﺘﻐﻴﺮﻫﺎ‪ ،‬ﺛﻮاﺑﺖ و ﻳﺎ ﺗﻮاﺑﻊ ﻫﺴﺘﻨﺪ‪.‬‬

‫• ﺷﻨﺎﺳﻪ ﻫﺎ ﻧﻤﻲ ﺗﻮاﻧﺪ از ﻛﻠﻤﺎت رزرو ﺷﺪه ﺑﺎﺷﻨﺪ و ﻫﻤﭽﻨﻴﻦ ﻧﻤﻲ ﺗﻮاﻧﻨﺪ ﺑﺎ ﻳﻚ ﻛﺎراﻛﺘﺮ ﻋﺪدي ﺷﺮوع ﺷﻮد و ﻃﻮل‬

‫آن ﻫﺎ ﺑﺎﻳﺪ ﻛﻤﺘﺮ از ‪ 31‬ﻛﺎراﻛﺘﺮ ﺑﺎﺷﺪ‪.‬‬

‫• ‪ C‬ﻳﻚ زﺑﺎن ‪ Case Sensitive‬اﺳﺖ و ﺑﻴﻦ ﺣﺮوف ﻛﻮﭼﻚ و ﺑﺰرگ ﺗﻔﺎوت ﻗﺎﺋﻞ ﻣﻲ ﺷﻮد‪.‬‬

‫• ﻛﻠﻤﺎت رزرو ﺷﺪه ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﺑﺎ ﺣﺮف ﻛﻮﭼﻚ اﺳﺘﻔﺎده ﺷﻮﻧﺪ‪) .‬ﻣﺜﻞ …‪(if, char, while,‬‬

‫  ‬
‫‪P a g e | 20‬‬
‫‪www.avr.ir‬‬

‫ﻣﺘﻐﻴﺮ ﻫﺎ و ﺛﻮاﺑﺖ‬

‫• ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﻳﻌﻨﻲ اﻧﺘﺨﺎب ﻧﺎم ﻣﺴﺘﻌﺎر ﺑﺮاي ﻣﻜﺎﻧﻲ از ﺣﺎﻓﻈﻪ‬

‫; ‪char a‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫; ﻧﺎم ﻣﺘﻐﻴﺮ ﻧﻮع ﻣﺘﻐﻴﺮ‬ ‫• ﻓﺮم ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ‪:‬‬

‫اﻧﻮاع داده ﻫﺎ‪:‬‬

‫‪Type‬‬ ‫)‪Size (Bits‬‬ ‫‪Range‬‬

‫‪bit‬‬ ‫‪1‬‬ ‫‪0,1‬‬

‫‪char‬‬ ‫‪8‬‬ ‫‪-128 to 127‬‬

‫‪unsigned char‬‬ ‫‪8‬‬ ‫‪0 to 255‬‬

‫‪signed char‬‬ ‫‪8‬‬ ‫‪-128 to 127‬‬

‫‪int‬‬ ‫‪16‬‬ ‫‪-32768 to 32767‬‬

‫‪short int‬‬ ‫‪16‬‬ ‫‪-32768 to 32767‬‬

‫‪unsigned int‬‬ ‫‪16‬‬ ‫‪0 to 65535‬‬

‫‪signed int‬‬ ‫‪16‬‬ ‫‪-32768 to 32767‬‬

‫‪long int‬‬ ‫‪32‬‬ ‫‪-2147483648 to 2147483647‬‬

‫‪unsigned long int‬‬ ‫‪32‬‬ ‫‪0 to 4294967295‬‬

‫‪signed long int‬‬ ‫‪32‬‬ ‫‪-2147483648 to 2147483647‬‬

‫‪float‬‬ ‫‪32‬‬ ‫‪±1.175e-38 to ±3.402e38‬‬

‫‪double‬‬ ‫‪32‬‬ ‫‪±1.175e-38 to ±3.402e38‬‬

‫;‪int b@0xA3‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫• ﺑﺮاي ﺗﻌﻴﻴﻦ ﻣﺤﻞ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ از ﻋﻤﻠﮕﺮ @ اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ‪.‬‬

‫• ﺑﺮاي ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ در ﺣﺎﻓﻈﻪ ي ‪ EEPROM‬از ﻛﻠﻤﻪ ي ﻛﻠﻴﺪي ‪ eeprom‬ﻗﺒﻞ از ﻧﺎم ﻣﺘﻐﻴﺮ اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ‪.‬‬

‫;‪eeprom int code‬‬ ‫ﻣﺜﺎل‪:‬‬

‫
 ‬
‫‪P a g e | 21‬‬
‫‪www.avr.ir‬‬
‫;'‪char s = 'a‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫• ﻣﻲ ﺗﻮان در زﻣﺎن ﺗﻌﺮﻳﻒ ﺑﻪ ﻣﺘﻐﻴﺮ ﻣﻘﺪار اوﻟﻴﻪ داد‪.‬‬

‫; ‪const float pi = 3.14‬‬ ‫• ﺗﻌﺮﻳﻒ ﺛﺎﺑﺖ ﺑﺎ ﻛﻠﻤﻪ ي ﻛﻠﻴﺪي ‪ const‬ﻳﺎ ‪ flash‬اﻧﺠﺎم ﻣﻲ ﺷﻮد‪ .‬ﻣﺜﺎل‪:‬‬

‫• ﺑﺎ رﻫﻨﻤﻮد ‪ #define‬ﻣﻲ ﺗﻮان ﻣﺎﻛﺮو ﺗﻌﺮﻳﻒ ﻧﻤﻮد‪ ،‬در اﻳﻦ ﺣﺎﻟﺖ ﻣﻘﺪاري ﻛﻪ ﺑﺮاي ﺛﺎﺑﺖ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮد ﻧﻮع‬

‫داده را ﺗﻌﻴﻴﻦ ﻛﺮده و ﻣﻘﺎدﻳﺮ ﺗﻌﺮﻳﻒ ﺷﺪه‪ ،‬ﺗﻮﺳﻂ ﭘﻴﺶ ﭘﺮدازﻧﺪه ﺑﺎ ﻣﻘﺪار ﺛﺎﺑﺖ ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ ﺷﻮد‪.‬‬

‫; ‪#define code 100‬‬ ‫ﻣﺜﺎل‪:‬‬

‫ﻋﻤﻠﮕﺮﻫﺎي ﺣﺴﺎﺑﻲ و ﺑﻴﺘﻲ‬

‫ﻧﺘﻴﺠﻪ‬ ‫ﻣﺜﺎل‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻋﻤﻠﮕﺮ‬

‫‪6‬‬ ‫‪3*2‬‬ ‫ﺿﺮب‬ ‫*‬

‫‪2.5‬‬ ‫‪5/2‬‬ ‫ﺗﻘﺴﻴﻢ‬ ‫‪/‬‬

‫‪9‬‬ ‫‪3+6‬‬ ‫ﺟﻤﻊ‬ ‫‪+‬‬

‫‪5‬‬ ‫‪8-3‬‬ ‫ﺗﻔﺮﻳﻖ‬ ‫‪-‬‬

‫‪1‬‬ ‫‪10%3‬‬ ‫ﺑﺎﻗﻴﻤﺎﻧﺪه‬ ‫‪%‬‬

‫‪0x00‬‬ ‫‪0xF0 & 0x0F‬‬ ‫‪AND‬‬ ‫&‬

‫‪0x03‬‬ ‫‪0x00 | 0x03‬‬ ‫‪OR‬‬ ‫|‬

‫‪0xF0‬‬ ‫‪0x0F ^ 0xFF‬‬ ‫‪XOR‬‬ ‫^‬

‫‪0x0F‬‬ ‫)‪~(0xF0‬‬ ‫ﻣﻜﻤﻞ ﻳﻚ‬ ‫~‬

‫‪0x0F‬‬ ‫‪0xF0 >> 4‬‬ ‫ﺷﻴﻔﺖ ﺑﻪ راﺳﺖ‬ ‫>>‬

‫‪0xF0‬‬ ‫‪0x0F << 4‬‬ ‫ﺷﻴﻔﺖ ﺑﻪ ﭼﭗ‬ ‫<<‬

‫  ‬
‫‪P a g e | 22‬‬
‫‪www.avr.ir‬‬

‫ﻋﻤﻠﮕﺮﻫﺎي ﻳﻜﺎﻧﻲ‬

‫ﻧﺘﻴﺠﻪ‬ ‫ﻣﺜﺎل‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻋﻤﻠﮕﺮ‬

‫‪a = a × -1‬‬ ‫‪-a‬‬ ‫ﻗﺮﻳﻨﻪ‬ ‫‪-‬‬

‫‪a=a+1‬‬ ‫‪a++‬‬ ‫اﻓﺰاﻳﺶ ﻳﻚ واﺣﺪ‬ ‫‪++‬‬

‫‪a=a-1‬‬ ‫‪a--‬‬ ‫ﻛﺎﻫﺶ ﻳﻚ واﺣﺪ‬ ‫‪--‬‬

‫ﻋﻤﻠﮕﺮﻫﺎي ﻣﻘﺎﻳﺴﻪ اي‬

‫ﻧﺘﻴﺠﻪ‬ ‫ﻣﺜﺎل‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻋﻤﻠﮕﺮ‬

‫‪False‬‬ ‫‪2>3‬‬ ‫ﺑﺰرﮔﺘﺮ‬ ‫>‬

‫‪True‬‬ ‫'‪'m'>'e‬‬ ‫ﻛﻮﭼﻜﺘﺮ‬ ‫<‬

‫‪True‬‬ ‫‪5>=5‬‬ ‫ﺑﺰرﮔﺘﺮ ﻳﺎ ﻣﺴﺎوي‬ ‫=>‬

‫‪True‬‬ ‫‪2.5<=4‬‬ ‫ﻛﻮﭼﻜﺘﺮ ﻳﺎ ﻣﺴﺎوي‬ ‫=<‬

‫‪False‬‬ ‫'‪'A' =='B‬‬ ‫ﺗﺴﺎوي‬ ‫==‬

‫‪True‬‬ ‫‪2!=3‬‬ ‫ﻧﺎﻣﺴﺎوي‬ ‫=!‬

‫  ‬
‫‪P a g e | 23‬‬
‫‪www.avr.ir‬‬

‫ﻋﻤﻠﮕﺮﻫﺎي ﻣﻨﻄﻘﻲ‬

‫ﻧﺘﻴﺠﻪ‬ ‫ﻣﺜﺎل‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻋﻤﻠﮕﺮ‬

‫‪False‬‬ ‫)‪(2>3)&&(1!=3‬‬ ‫‪ AND‬ﻣﻨﻄﻘﻲ‬ ‫&&‬

‫‪True‬‬ ‫)‪('a'<3)||(10‬‬ ‫‪ OR‬ﻣﻨﻄﻘﻲ‬ ‫||‬

‫‪False‬‬ ‫)‪!(7>5‬‬ ‫ﻧﻘﻴﺾ‬ ‫!‬

‫ﻋﻤﻠﮕﺮﻫﺎي اﻧﺘﺴﺎب‬

‫ﻧﺘﻴﺠﻪ‬ ‫ﻣﺜﺎل‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻋﻤﻠﮕﺮ‬

‫‪ab‬‬ ‫‪a=b‬‬ ‫اﻧﺘﺴﺎب‬ ‫=‬

‫‪a=a*b‬‬ ‫‪a*=b‬‬ ‫ﺿﺮب و اﻧﺘﺴﺎب‬ ‫=*‬

‫‪a=a/b‬‬ ‫‪a/=b‬‬ ‫ﺗﻘﺴﻴﻢ و اﻧﺘﺴﺎب‬ ‫=‪/‬‬

‫‪a=a+b‬‬ ‫‪a+= b‬‬ ‫ﺟﻤﻊ و اﻧﺘﺴﺎب‬ ‫=‪+‬‬

‫‪a=a-b‬‬ ‫‪a-=b‬‬ ‫ﺗﻔﺮﻳﻖ و اﻧﺘﺴﺎب‬ ‫=‪-‬‬

‫اﮔﺮ ‪ value‬ﻣﻘﺪار‬

‫ﺻﺤﻴﺢ ﺑﺎﺷﺪ ‪ a‬ﺑﺮاﺑﺮ ‪x‬‬

‫اﻧﺘﺴﺎب ﺷﺮﻃﻲ‬ ‫‪a=(value)?x:y‬‬
‫و در ﻏﻴﺮاﻳﻨﺼﻮرت ﺑﺮاﺑﺮ‬

‫‪ y‬ﻣﻲ ﺷﻮد‪.‬‬

‫  ‬
‫‪P a g e | 24‬‬
‫‪www.avr.ir‬‬

‫آراﻳﻪ ﻫﺎ‬

‫آراﻳﻪ ﻫﺎ ﻣﺠﻤﻮﻋﻪ اي از ﻣﺘﻐﻴﺮﻫﺎي ﻫﻤﻨﻮع ﻫﺴﺘﻨﺪ‪.‬‬

‫; ]ﺗﻌﺪاد ﻋﻨﺎﺻﺮ[اﺳﻢ ﻣﺘﻐﻴﺮ ﻧﻮع ﻣﺘﻐﻴﺮﻫﺎي آراﻳﻪ‬ ‫• ﻓﺮم ﺗﻌﺮﻳﻒ‪:‬‬

‫;]‪int a[5‬‬ ‫• ﻣﺜﺎل‪:‬‬

‫;}‪int a[5] = {1,2,3,4,5‬‬ ‫ﺑﺎ ﻣﻘﺪار اوﻟﻴﻪ‪:‬‬

‫ﻓﺮم ﺗﻌﺮﻳﻒ آراﻳﻪ ﻫﺎي دو ﺑﻌﺪي‪]; :‬ﻋﺪاد ﻋﻨﺎﺻﺮ ﺳﺘﻮن[]ﺗﻌﺪاد ﻋﻨﺎﺻﺮ ﺳﻄﺮ[اﺳﻢ ﻣﺘﻐﻴﺮ ﻧﻮع ﻣﺘﻐﻴﺮﻫﺎ‬ ‫•‬

‫;}}‪int a[2][3]={{1,2,3},{4,5,6‬‬ ‫ﻣﺜﺎل‪:‬‬

‫در زﺑﺎن ‪ C‬اﻧﺪﻳﺲ آراﻳﻪ ﻫﺎ از ﺻﻔﺮ ﺷﺮوع ﻣﻲ ﺷﻮد‪.‬‬ ‫•‬

‫رﺷﺘﻪ ﻫﺎ‬

‫رﺷﺘﻪ ﻫﺎ آراﻳﻪ اي ﻛﺎراﻛﺘﺮﻫﺎ ﻫﺴﺘﻨﺪ‪.‬‬

‫;"‪char name[ ] = "Test‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫•‬

‫;}'‪char name[5]={'T','e','s','t','\0‬‬ ‫ﻳﺎ‪:‬‬

‫• رﺷﺘﻪ ﻫﺎ ﻫﻤﻮاره ﺑﻪ ﻳﻚ ﻛﺎراﻛﺘﺮ ‪ Null‬ﺧﺘﻢ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬

‫  ‬
‫‪P a g e | 25‬‬
‫‪www.avr.ir‬‬

‫ﺗﺼﻤﻴﻢ ﮔﻴﺮي و اﻧﺘﺨﺎب‬

‫ دﺳﺘﻮر ‪:goto‬‬

‫ﭘﺮش ﺑﺪون ﺷﺮط ﺑﻪ ﻳﻚ ﺑﺮﭼﺴﺐ اﻧﺠﺎم ﻣﻲ ﺷﻮد‪.‬‬

‫ ﺳﺎﺧﺘﺎر ‪:if - else‬‬

‫)ط(‪if‬‬
‫{‬
‫;دﺳﺘﻮرات‪1‬‬

‫}‬
‫‪else‬‬
‫{‬
‫;دﺳﺘﻮرات ‪2‬‬

‫}‬
‫در ﺻﻮرﺗﻲ ﻛﻪ دﺳﺘﻮرات ﻳﻚ ﺧﻄﻲ ﺑﺎﺷﻨﺪ ﻣﻲ ﺗﻮان ‪ brace‬را ﺣﺬف ﻧﻤﻮد‪.‬‬ ‫‬

‫اﺳﺘﻔﺎده از ﺑﻼك ‪ else‬اﺧﺘﻴﺎري اﺳﺖ‪.‬‬ ‫‬

‫ﻣﺜﺎل‪:‬‬

‫>‪#include<stdio.h‬‬

‫{)(‪void main‬‬

‫  ‬
P a g e | 26
www.avr.ir

int a;

printf("Enter a Number: ");

scanf("%d",&a);

if(a= =0)
printf("You've entered zero\n");
else if(a>0)
printf("You've entered a positive number\n");
else
printf("You've entered a negative number\n");
}

:Switch - Case ‫ ﺳﺎﺧﺘﺎر‬

switch(‫)ﻣﻘﺪار‬

{
case 1‫ﻣﻘﺪار‬:

1‫;دﺳﺘﻮرات‬

break;
case 2‫ﻣﻘﺪار‬:

2‫;دﺳﺘﻮرات‬

break;
  
P a g e | 27
www.avr.ir
.
.
default:
n ‫;دﺳﺘﻮرات‬

}
:‫ﻣﺜﺎل‬

#include<stdio.h>

void main(){

int a;
printf("Enter Month of your birth: ");
scanf("%d",&a);

switch(a){

case 1:
case 2:
case 3: printf("You've born is spring\n");
break;

case 4:
case 5:
case 6: printf("You've born is summer\n");
break;

case 7:
case 8:
case 9: printf("You've born is autumn\n");

  
P a g e | 28
www.avr.ir
break;

case 10:
case 11:
case 12: printf("You've born is winter\n");
break;

default: printf("Error! Enter a number between 1-

12\n");

‫ﺣﻠﻘﻪ ﻫﺎي ﺗﻜﺮار‬

:While ‫ ﺳﺎﺧﺘﺎر‬

while(‫)ﺷﺮط‬

{
‫;دﺳﺘﻮرات‬

:‫ﻣﺜﺎل‬

#include<stdio.h>

void main(){

  
‫‪P a g e | 29‬‬
‫‪www.avr.ir‬‬

‫;‪char a‬‬

‫;)"‪printf("Enter E to exit\n‬‬
‫;)(‪while(a != 'E') a=getchar‬‬

‫}‬

‫ ﺳﺎﺧﺘﺎر ‪:Do/While‬‬

‫{‪do‬‬
‫;دﺳﺘﻮرات‬

‫)ﺷﺮط(‪} while‬‬

‫ در ﺳﺎﺧﺘﺎر ‪ Do/While‬ﺑﺮ ﺧﻼف ‪ While‬ﺷﺮط در اﻧﺘﻬﺎي ﺣﻠﻘﻪ آزﻣﺎﻳﺶ ﻣﻲ ﺷﻮد‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ دﺳﺘﻮرات داﺧﻞ‬

‫ﺣﻠﻘﻪ‪ ،‬ﺣﺪاﻗﻞ ﻳﻜﺒﺎر اﺟﺮا ﻣﻲ ﺷﻮﻧﺪ‪.‬‬

‫ ﺣﻠﻘﻪ ﻫﺎي ‪:For‬‬

‫)ﮔﺎم ; ﺷﺮط ﭘﺎﻳﺎن ; ﻣﻘﺪار اﺑﺘﺪاي ﺣﻠﻘﻪ(‪for‬‬

‫{‬
‫;دﺳﺘﻮرات‬

‫}‬

‫  ‬
P a g e | 30
www.avr.ir

:‫ﻣﺜﺎل‬

#include<stdio.h>

void main(){

int a,i;
long int fact=1;

printf("Enter a Number: ");

scanf("%d",&a);

if(a<0)
printf("Error! You must Enter a positive number\n");
else if(a==0)
printf("Factorial of 1 is 1\n");
else{
for(i=1;i<=a;i++)
fact*=i;
printf("Factorial of %d is %d\n",a,fact);
}
}

 

‫‪P a g e | 31‬‬
‫‪www.avr.ir‬‬
‫دﺳﺘﻮر ‪ break‬ﺑﺎﻋﺚ ﺧﺮوج ﺑﺪون ﺷﺮط از ﻫﺮ ﺣﻠﻘﻪ اي ﻣﻲ ﺷﻮد‪.‬‬ ‫‬

‫دﺳﺘﻮر ‪ continue‬ﺑﺎﻋﺚ ﻣﻲ ﺷﻮد اﺟﺮاي اداﻣﻪ دﺳﺘﻮرات ﻣﺘﻮﻗﻒ ﺷﺪه و ﺣﻠﻘﻪ از اﺑﺘﺪا آﻏﺎز ﺷﻮد‪.‬‬ ‫‬

‫ﺗﻮاﺑﻊ‬

‫ﺗﻌﺮﻳﻒ ﺗﻮاﺑﻊ ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫ﻧﻮع داده ﺧﺮوﺟﻲ‬ ‫)آرﮔﻮﻣﺎﻧﻬﺎي ﺗﺎﺑﻊ( ﻧﺎم ﺗﺎﺑﻊ‬

‫{‬
‫ﻣﺘﻐﻴﺮﻫﺎي ﻣﺤﻠﻲ‬

‫دﺳﺘﻮرات ﺗﺎﺑﻊ‬

‫}‬

‫
ﺗﻮاﺑﻊ داﺧﻞ ﻳﻜﺪﻳﮕﺮ ﻗﺎﺑﻞ ﺗﻌﺮﻳﻒ ﻧﻤﻲ ﺑﺎﺷﻨﺪ و ﺟﺪا از ﻫﻢ ﺑﺎﻳﺪ ﺗﻌﺮﻳﻒ ﮔﺮدﻧﺪ‪.‬‬

‫ﻣﺜﺎل‪:‬‬

‫>‪#include <stdio.h‬‬

‫;)‪long int cube(int x‬‬

‫{)(‪void main‬‬

‫  ‬
P a g e | 32
www.avr.ir

int a;

printf("Enter a number: ");

scanf("%d",&a);
printf("Cube of %d is %d\n",a,cube(a));

long int cube(int x){

return x*x*x;
}

:‫ﻣﺜﺎل‬

#include<stdio.h>

int _max(int a,int b);

void main(){

int a,b;

printf("Enter Two Numbers: ");

scanf("%d%d",&a,&b);
printf("Maximum of %d and %d is %d\n",a,b,_max(a,b));

  
P a g e | 33
www.avr.ir
}

int _max(int a,int b){

if(a>b)
return a;
else
return b;
}

  
P a g e | 34
www.avr.ir

‫ ﻓﻼﺷﺮ ﺳﺎده‬:1 ‫ﭘﺮوژه‬

/*****************************************************
Project : LED Flasher
Author : Reza Sepas Yar
Company : Pishro Noavaran Kavosh
*****************************************************/

#include<mega16.h>
#include<delay.h>
#define xtal 1000000

int i;

void main (void)

{

DDRA = 0xFF; //.‫ ﻣﺮاﺟﻌﻪ ﻛﻨﻴﺪ‬1 ‫ﺑﺮاي درك ﻋﻤﻠﻜﺮد اﻳﻦ ﻋﺒﺎرت ﺑﻪ ﭘﻴﻮﺳﺖ‬

while(1)
{

for(i = 1; i <= 128; i = i*2)

{
PORTD = i;
delay_ms(100);
}

  
P a g e | 35
www.avr.ir

for(i = 64; i > 1; i = i/2)

{
PORTD = i;
delay_ms(100);
}

  
P a g e | 36
www.avr.ir

7-Segment ‫ ﻛﺎﻧﺘﺮ ﻳﻚ رﻗﻤﻲ ﺑﺎ‬:2 ‫ﭘﺮوژه‬

/*****************************************************
Project : Key Counter
Author : Reza Sepas Yar
Company : Pishro Noavaran Kavosh
*****************************************************/

#include <mega16.h>
#define xtal 4000000

flash char digits[16]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,

0x7D,0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71};
unsigned char p_state;
unsigned char key;
unsigned char i;

void main(void)
{
DDRD = 0xFF;
PORTD = digits[0];
DDRC = 0x00;
PORTC = 0xFF;

while(1)
{

key = PINC & 0b00000001;

  
P a g e | 37
www.avr.ir
delay_ms(10);

if(key==0)
{
if(key!=p_state)
{
if(i==15)
{
i=0;
PORTD=digits[i];
}
else
i++;

PORTD = digits[i];
p_state=0;

};
}
else
p_state=1;
}

  
‫‪P a g e | 38‬‬
‫‪www.avr.ir‬‬

‫ﺟﺪول زﻳﺮ وﺿﻌﻴﺖ ﺳﮕﻤﻨﺖ ﻫﺎي ‪ 7-Seg‬ﻛﺎﺗﺪ ﻣﺸﺘﺮك را ﻧﺸﺎن ﻣﻲ دﻫﺪ‪) .‬ﺑﺮاي ﻧﻮع آﻧﺪ ﻣﺸﺘﺮك اﻋﺪادرا ﻣﻜﻤﻞ‬

‫ﻛﻨﻴﺪ‪(.‬‬

‫ﻛﺎراﻛﺘﺮ‬ ‫‪Dp‬‬ ‫‪g‬‬ ‫‪f‬‬ ‫‪e‬‬ ‫‪d‬‬ ‫‪c‬‬ ‫‪b‬‬ ‫‪a‬‬ ‫‪HEX‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0x3F‬‬

‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0x06‬‬

‫‪2‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0x5B‬‬

‫‪3‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0x4F‬‬

‫‪4‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0x66‬‬

‫‪5‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0x6D‬‬

‫‪6‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0x7D‬‬

‫‪7‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0x07‬‬

‫‪8‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0x7F‬‬

‫‪9‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0x6F‬‬

‫‪A‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0x77‬‬

‫‪b‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0x7C‬‬

‫  ‬
P a g e | 39
www.avr.ir
C 0 0 1 1 1 0 0 1 0x39

d 0 1 0 1 1 1 1 0 0x5E

E 0 1 1 1 1 0 0 1 0x79

F 0 1 1 1 0 0 0 1 0x71

  
P a g e | 40
www.avr.ir

(LCD) ‫ ﻧﻤﺎﻳﺸﮕﺮ ﻛﺮﻳﺴﺘﺎل ﻣﺎﻳﻊ‬:3 ‫ﭘﺮوژه‬

/*****************************************************
Project : LCD Interfacing
Author : Reza Sepas Yar
Company : Pishro Noavaran Kavosh
*****************************************************/

#include <stdio.h>
#include <mega16.h>
#include <delay.h>
#include <lcd.h>
#define xtal 4000000

#asm
.equ __lcd_port=0x1B ;PORTA
#endasm

void main(void)
{
char buffer[10];
unsigned char w;

PORTB=0xFF;
DDRB=0x00;

 

P a g e | 41
www.avr.ir
lcd_init(16);
lcd_clear();

while (1){

w = ~PINB;

if(w!=0x00)
{
lcd_clear();
lcd_gotoxy(0,0);
sprintf(buffer,"Number=%d",w);
lcd_puts(buffer);
delay_ms(100);
}
else
{
lcd_clear();
lcd_putsf("Number=0");
delay_ms(100);
}
}
}

  
P a g e | 42
www.avr.ir

  
P a g e | 43
www.avr.ir

‫ اﺳﻜﻦ ﺻﻔﺤﻪ ﻛﻠﻴﺪ ﻣﺎﺗﺮﻳﺴﻲ‬:4 ‫ﭘﺮوژه‬

/*****************************************************
Project : Keypad Scan
Author : Reza Sepas Yar
Company : Pishro Noavaran Kavosh
*****************************************************/

#include <mega16.h>
#include <delay.h>

#define xtal 4000000

unsigned char key, butnum;

flash unsigned char keytbl[16]={0xee, 0xed, 0xeb, 0xe7,

0xde, 0xdd, 0xdb, 0xd7, 0xbe, 0xbd, 0xbb, 0xb7, 0x7e,
0x7d, 0x7b, 0x77};

void main(void)
{
DDRB = 0xff;
PORTB = 0xff;

while(1)
{
DDRC = 0x0f;

  
P a g e | 44
www.avr.ir
PORTC = 0xf0;
delay_us(5);
key = PINC;

DDRC = 0xf0;
PORTC = 0x0f;
delay_us(5);
key = key | PINC;

delay_ms(10);

if (key != 0xff)
{
for (butnum=0; butnum<16; butnum++)
{
if (keytbl[butnum]==key) break;
}
if (butnum==16) butnum=0;
else butnum++;
}
else butnum=0;

PORTB = ~ butnum ;

}
}

  
P a g e | 45
www.avr.ir

  
P a g e | 46
www.avr.ir

LED Dot Matrix ‫ ﻧﻤﺎﻳﺸﮕﺮﻫﺎي‬:5 ‫ﭘﺮوژه‬

/*****************************************************
Project : Dot Matrix Display
Author : Reza Sepas Yar
Company : Pishro Noavaran Kavosh
*****************************************************/

#include <mega16.h>
#include <delay.h>
#define xtal 4000000

unsigned char k;
flash unsigned char arr[8]={0x18, 0x3C, 0x66, 0x66, 0x7E,
0x66, 0x66, 0x00};

void main(void)
{

DDRA=0xFF;
DDRB=0xFF;

while (1){
for(k=0;k<=7;k++){
PORTA=arr[k];
PORTB=~(1<<k);
delay_us(100);

  
P a g e | 47
www.avr.ir
PORTB=0xFF;
}
}
}

  
P a g e | 48
www.avr.ir

‫وﻗﻔﻪ ﻫﺎي ﺧﺎرﺟﻲ‬

.‫ ﻣﻮرد از آن ﻫﺎ وﻗﻔﻪ ي ﺧﺎرﺟﻲ ﻣﻲ ﺑﺎﺷﻨﺪ‬3 ‫ ﻣﻨﺒﻊ وﻗﻔﻪ ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ‬21 ‫ داراي‬ATmega16 ‫ﻗﻄﻌﻪ ي‬ •

‫ﻧﺎم در‬
‫ﺷﻤﺎره‬ ‫آدرس‬ ‫ﻣﻨﺒﻊ وﻗﻔﻪ‬ ‫ﺗﻮﺿﻴﺢ‬
CodeVision
External Pin, Power-on Reset, Brown-out Reset,
1 $000 RESET
Watchdog Reset, and JTAG AVR Reset
2 EXT_INT0 $002 INT0 External Interrupt Request 0

3 EXT_INT1 $004 INT1 External Interrupt Request 1

4 TIM2_COMP $006 TIMER2 COMP Timer/Counter2 Compare Match

5 TIM2_OVF $008 TIMER2 OVF Timer/Counter2 Overflow

6 TIM1_CAPT $00A TIMER1 CAPT Timer/Counter1 Capture Event

7 TIM1_COMPA $00C TIMER1 COMPA Timer/Counter1 Compare Match A

8 TIM1_COMPB $00E TIMER1 COMPB Timer/Counter1 Compare Match B

9 TIM1_OVF $010 TIMER1 OVF Timer/Counter1 Overflow

10 TIM0_OVF $012 TIMER0 OVF Timer/Counter0 Overflow

11 SPI_STC $014 SPI, STC Serial Transfer Complete

12 USART_RXC $016 USART, RXC USART, Rx Complete

13 USART_DRE $018 USART, UDRE USART Data Register Empty

14 USART_TXC $01A USART, TXC USART, Tx Complete

15 ADC_INT $01C ADC ADC Conversion Complete

16 EE_RDY $01E EE_RDY EEPROM Ready

17 ANA_COMP $020 ANA_COMP Analog Comparator

18 TWI $022 TWI Two-wire Serial Interface

  
‫‪P a g e | 49‬‬
‫‪www.avr.ir‬‬
‫‪19‬‬ ‫‪EXT_INT2‬‬ ‫‪$024‬‬ ‫‪INT2‬‬ ‫‪External Interrupt Request 2‬‬

‫‪20‬‬ ‫‪TIM0_COMP‬‬ ‫‪$026‬‬ ‫‪TIMER0 COMP‬‬ ‫‪Timer/Counter0 Compare Match‬‬

‫‪21‬‬ ‫‪SPM_READY‬‬ ‫‪$028‬‬ ‫‪SPM_RDY‬‬ ‫‪Store Program Memory Ready‬‬

‫• آدرس ﻫﺎي ﭘﺎﻳﻴﻦ ﺗﺮ داراي اوﻟﻮﻳﺖ ﺑﺎﻻﺗﺮي ﻣﻲ ﺑﺎﺷﻨﺪ و در ﺻﻮرت درﺧﻮاﺳﺖ ﻫﻤﺰﻣﺎن دو ﻳﺎ ﭼﻨﺪ وﻗﻔﻪ اﺑﺘﺪا ﺑﻪ‬

‫اوﻟﻮﻳﺖ ﺑﺎﻻﺗﺮ ﭘﺎﺳﺦ داده ﻣﻲ ﺷﻮد و ﭘﺲ از آن ﺑﻪ ﺑﻘﻴﻪ ي وﻗﻔﻪ ﻫﺎ ﺑﺮ ﺣﺴﺐ اوﻟﻮﻳﺖ رﺳﻴﺪﮔﻲ ﻣﻲ ﺷﻮد‪.‬‬

‫ﺑﺮاي ﻓﻌﺎل ﻛﺮدن ﻫﺮ ﻳﻚ از وﻗﻔﻪ ﻫﺎ ﺑﺎﻳﺪ اﺑﺘﺪا ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﻋﻤﻮﻣﻲ وﻗﻔﻪ ﻫﺎ را ﺑﺎ دﺳﺘﻮر اﺳﻤﺒﻠﺮ ‪ SEI‬ﻳﺎ ﻣﻘﺪار دﻫﻲ‬

‫رﺟﻴﺴﺘﺮ ‪ SREG‬ﻓﻌﺎل ﻧﻤﻮد‪:‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪SREG‬‬ ‫‪I‬‬

‫• ﺑﺎ روﻳﺪاد ﻫﺮ وﻗﻔﻪ ي ﺧﺎرﺟﻲ اﻳﻦ ﺑﻴﺖ ﭘﺎك ﺷﺪه و در ﻧﺘﻴﺠﻪ ﺗﻤﺎم وﻗﻔﻪ ﻫﺎي دﻳﮕﺮ ﻏﻴﺮ ﻓﻌﺎل ﻣـﻲ ﺷـﻮﻧﺪ در‬

‫اﻳﻦ ﺣﺎﻟﺖ ﻧﺮم اﻓﺰار ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ روي اﻳﻦ ﺑﻴﺖ آن را ﻣﺠﺪدا ﻓﻌﺎل ﻛﻨﺪ و ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﻫـﺎي‬

‫ﺗﻮ در ﺗﻮ ﺷﻮد‪ .‬ﺑﺎ ﺑﺎزﮔﺸﺖ از ‪ ISR‬اﻳﻦ ﺑﻴﺖ ﻣﺠﺪدا ﻳﻚ ﻣﻲ ﺷﻮد‪.‬‬

‫ﺑﺮاي اﺳﺘﻔﺎده از ﻫﺮﻳﻚ از وﻗﻔﻪ ﻫﺎي ﺧﺎرﺟﻲ ﺑﺎﻳﺪ ﺑﺎ ﻳﻚ ﻛﺮدن ﺑﻴﺖ ﻣﺮﺑﻮﻃﻪ در رﺟﻴﺴﺘﺮ ‪ GICR‬آن را ﻓﻌﺎل ﻧﻤﻮد‪:‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪GICR‬‬ ‫‪INT1‬‬ ‫‪INT0‬‬ ‫‪INT2‬‬

‫  ‬
‫‪P a g e | 50‬‬
‫‪www.avr.ir‬‬
‫• وﻗﻔﻪ ﻫﺎي ﺧﺎرﺟﻲ ‪ 1،0‬و ‪ 2‬ﺑﻪ ﺗﺮﺗﻴﺐ از ﭘﻴﻦ ﻫﺎي ‪ PD3 ،PD2‬و ‪ PB2‬ﺗﺮﻳﮕﺮ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬

‫ﻧﻮع ﺗﺮﻳﮕﺮ ﺷﺪن ﻫﺮﻳﻚ از وﻗﻔﻪ ﻫﺎي ﺧﺎرﺟﻲ ‪ 0‬و ‪ 1‬ﺑﻮﺳﻴﻠﻪ ي ﭼﻬﺎرﺑﻴﺖ اول رﺟﻴﺴﺘﺮ ‪ MCUCR‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪:‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪MCUCSR‬‬ ‫‪ISC11‬‬ ‫‪ISC10‬‬ ‫‪ICS01‬‬ ‫‪ISC00‬‬

‫ﺣﺎﻟﺖ ﻫﺎي ﻣﺨﺘﻠﻒ ﺑﻴﺖ ﻫﺎي ]‪:MCUCR[3:0‬‬

‫‪ISC01‬‬ ‫‪ISC00‬‬ ‫ﻧﻮع ﺗﺮﻳﮕﺮ ﺷﺪن وﻗﻔﻪ ي ﺻﻔﺮ‬

‫‪0‬‬ ‫‪0‬‬ ‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ ﺻﻔﺮ در ﭘﻴﻦ ‪INT0‬‬

‫‪0‬‬ ‫‪1‬‬ ‫ﺗﻐﻴﻴﺮ در ﺳﻄﺢ ﻣﻨﻄﻘﻲ ﭘﻴﻦ ‪INT0‬‬

‫‪1‬‬ ‫‪0‬‬ ‫ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧﺪه در ﭘﻴﻦ ‪INT0‬‬

‫‪1‬‬ ‫‪1‬‬ ‫ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه در ﭘﻴﻦ ‪INT0‬‬

‫‪ISC11‬‬ ‫‪ISC10‬‬ ‫ﻧﻮع ﺗﺮﻳﮕﺮ ﺷﺪن وﻗﻔﻪ ي ﻳﻚ‬

‫‪0‬‬ ‫‪0‬‬ ‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ ﺻﻔﺮ در ﭘﻴﻦ ‪INT1‬‬

‫‪0‬‬ ‫‪1‬‬ ‫ﺗﻐﻴﻴﺮ در ﺳﻄﺢ ﻣﻨﻄﻘﻲ ﭘﻴﻦ ‪INT1‬‬

‫‪1‬‬ ‫‪0‬‬ ‫ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧﺪه در ﭘﻴﻦ ‪INT1‬‬

‫‪1‬‬ ‫‪1‬‬ ‫ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه در ﭘﻴﻦ ‪INT1‬‬

‫
 ‬
‫‪P a g e | 51‬‬
‫‪www.avr.ir‬‬

‫ﻧﻮع ﺗﺮﻳﮕﺮ ﺷﺪن وﻗﻔﻪ ي ‪ 2‬ﺧﺎرﺟﻲ ﺑﻮﺳﻴﻠﻪ ﺑﻴﺖ ‪ 6‬از رﺟﻴﺴﺘﺮ ‪ MCUCSR‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪:‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪MCUCSR‬‬ ‫‪ISC2‬‬

‫• وﻗﻔﻪ ي‪ 2‬ﺧﺎرﺟﻲ ﺑﺮ ﺧﻼف وﻗﻔـﻪ ي ‪ 0‬و ‪ 1‬ﺗﻨﻬـﺎ در دو ﺣﺎﻟـﺖ ﻟﺒـﻪ ي ﺑـﺎﻻ روﻧـﺪه و ﭘـﺎﻳﻴﻦ روﻧـﺪه ﻗﺎﺑـﻞ‬

‫ﭘﻴﻜﺮﺑﻨﺪي اﺳﺖ‪ .‬ﻧﻮﺷﺘﻦ ﺻﻔﺮ در ‪ ISC2‬ﺑﺎﻋﺚ ﺗﺮﻳﮕﺮ ﺷﺪن اﻳﻦ وﻗﻔﻪ ﺑﺎ ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧـﺪه و ﻧﻮﺷـﺘﻦ ﻳـﻚ‬

‫ﺑﺎﻋﺚ ﺗﺮﻳﮕﺮ ﺷﺪن آن ﺑﺎ ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه ﻣﻲ ﺷﻮد‪.‬‬

‫ﻫﺮ ﻳﻚ از وﻗﻔﻪ ﻫﺎي ﺧﺎرﺟﻲ داراي ﻳﻚ ﺑﻴﺖ ﭘﺮﭼﻢ ﻫﺴﺘﻨﺪ ﻛﻪ در ﺻﻮرت ﺗﺮﻳﮕﺮ ﺷﺪن از ﭘﻴﻦ وﻗﻔـﻪ ي ﺧـﺎرﺟﻲ و‬

‫ﻓﻌﺎل ﺑﻮدن ﺑﻴﺖ ﻣﺮﺑﻮﻃﻪ در رﺟﻴﺴﺘﺮ ‪ GICR‬و ﻓﻌﺎل ﺑﻮدن ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز وﻗﻔﻪ )‪ ،(I‬ﻋﻼوه ﺑﺮ ﻳﻚ ﺷﺪن ﭘـﺮﭼﻢ‪ ،‬ﻣـﻲ‬

‫ﺗﻮاﻧﺪ ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﺷﻮد‪ .‬در اﻳﻦ ﺣﺎﻟﺖ ﭘﺲ از اﺟﺮاي ‪ ISR‬ﭘﺮﭼﻢ آن وﻗﻔﻪ ﺑﻪ ﺻﻮرت ﺳﺨﺖ اﻓﺰاري ﭘﺎك ﻣـﻲ‬

‫ﺷﻮد‪.‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪GIFR‬‬ ‫‪INTF1‬‬ ‫‪INTF0‬‬ ‫‪INTF2‬‬

‫روﺗﻴﻦ ﺳﺮوﻳﺲ وﻗﻔﻪ ﻫﺎ در ‪ CodeVision‬ﺑﻪ ﺻﻮرت زﻳﺮ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮد‪:‬‬

‫  ‬
P a g e | 52
www.avr.ir
interrupt [‫]ﺷﻤﺎره ي ﺑﺮدار وﻗﻔﻪ‬ void ‫( ﻧﺎم روﺗﻴﻦ ﺳﺮوﻳﺲ وﻗﻔﻪ‬void)

{
‫ﺑﺮﻧﺎﻣﻪ ي ﺳﺮوﻳﺲ وﻗﻔﻪ‬

‫ ﻣﻲ ﺑﺎﺷﺪ و ﻣﻲ ﺗﻮان از ﻧﺎم ﻣﻌﺎدل آن )ﺟﺪول‬21 ‫ ﺗﺎ‬2 ‫ ﻋﺪدي ﺑﻴﻦ‬ATMEGA16 ‫ﺷﻤﺎره ي ﺑﺮدار وﻗﻔﻪ ي در ﻣﻮرد‬

.‫اﺑﺘﺪاي ﻓﺼﻞ( ﻧﻴﺰ اﺳﺘﻔﺎده ﻛﺮد‬

:1‫ﻣﺜﺎل‬

#include <mega16.h>
#include <delay.h>

interrupt [2] void LED_ON(void)

{
PORTA=0x01;
delay_ms(1000);
PORTA=0x00;
}

void main(void)
{
DDRB=0xFF;
PORTB=0x00;
DDRA=0xFF;
PORTA=0x00;
DDRD=0x00;

  
P a g e | 53
www.avr.ir
PORTD=0xFF;

GICR=0b01000000; // INT0: On
MCUCR=0b00000010; // INT0 Mode: Falling Edge

#asm("sei") // Global enable interrupts

while (1)
{
PORTB=0x01;
delay_ms(500);
PORTB=0x00;
delay_ms(500);
};
}

  
‫‪P a g e | 54‬‬
‫‪www.avr.ir‬‬
‫• اﮔﺮ وﻗﻔﻪ ي ﺧﺎرﺟﻲ ﺑﻪ ﺻﻮرت ﺣﺴﺎس ﺑﻪ ﻟﺒﻪ ﺗﻨﻈﻴﻢ ﺷﺪه ﺑﺎﺷﺪ و در ﺣﺎل اﺟﺮاي ﻳﻜﻲ از وﻗﻔﻪ ﻫﺎ‪ ،‬وﻗﻔﻪ ي‬

‫دﻳﮕﺮي اﺗﻔﺎق ﺑﻴﻔﺘﺪ‪ ،‬ﭘﺲ از ﺧﺮوج از ‪ ISR‬وﻗﻔﻪ ي ﺟﺎري ﺑﻪ آن وﻗﻔﻪ ﻫﺎ ﺑﺮﺣﺴﺐ اوﻟﻮﻳﺖ ﺷﺎن ﭘﺎﺳﺦ داده‬

‫ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫• در ﺻﻮرﺗﻲ ﻛﻪ ﭘﻴﻦ وﻗﻔﻪ ﺑﻪ ﺻﻮرت ﺧﺮوﺟﻲ ﺗﻌﺮﻳﻒ ﺷﻮد‪ ،‬آﻧﭽﻪ روي ﭘﻮرت ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد ﻣﻲ ﺗﻮاﻧﺪ‬

‫ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﺷﻮد‪ ،‬ﺑﻪ اﻳﻦ ﺗﺮﺗﻴﺐ ﻣﻲ ﺗﻮان وﻗﻔﻪ ي ﻧﺮم اﻓﺰاري اﻳﺠﺎد ﻛﺮد‪.‬‬

‫• وﻗﻔﻪ ﻫﺎي ﺣﺴﺎس ﺑﻪ ﺳﻄﺢ در ﭘﻴﻦ ‪ INT0‬و ‪ INT1‬و ﻫﻤﭽﻨﻴﻦ وﻗﻔـﻪ ي ﺣﺴـﺎس ﺑـﻪ ﻟﺒـﻪ در ‪ INT2‬ﺑـﻪ‬

‫ﺻﻮرت آﺳﻨﻜﺮون ﺗﺸﺨﻴﺺ داده ﻣﻲ ﺷﻮﻧﺪ‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ ﻣﻲ ﺗﻮان از آن ﻫﺎ ﺑﺮاي ﺧﺎرج ﻛﺮدن ﻣﻴﻜـﺮو از ﻫﻤـﻪ ي‬

‫‪ Mode‬ﻫﺎي ﻛﻢ ﻣﺼﺮف اﺳﺘﻔﺎده ﻧﻤﻮد‪ .‬ﺣﺪاﻗﻞ ﻋﺮض ﭘﺎﻟﺲ در اﻳﻦ ﺣﺎﻟﺖ ‪ 50‬ﻧﺎﻧﻮ ﺛﺎﻧﻴﻪ ﻣـﻲ ﺑﺎﺷـﺪ و ﺑـﺮاي‬

‫ﻣﻘﺎدﻳﺮ ﻛﻤﺘﺮ ﺗﺸﺨﻴﺺ وﻗﻔﻪ ي ﺧﺎرﺟﻲ ﺗﻀﻤﻴﻦ ﻧﺸﺪه اﺳﺖ‪.‬‬

‫• ﻛﺎﻣﭙﺎﻳﻠﺮ ‪ CodeVision‬ﺑﻪ ﺻﻮرت ﭘﻴﺶ ﻓﺮض ‪ SREG‬و رﺟﻴﺴـﺘﺮﻫﺎﻳﻲ ‪ CPU‬را ﻛـﻪ ﻣﻤﻜـﻦ اﺳـﺖ در‬

‫‪ ISR‬ﺗﻐﻴﻴﺮ ﭘﻴﺪا ﻛﻨﻨﺪ‪ ،‬ﻗﺒﻞ از اﺟﺮاي روﺗﻴﻦ ﺳﺮوﻳﺲ وﻗﻔـﻪ در ‪ Stack‬ذﺧﻴـﺮه )‪ (PUSH‬ﻛـﺮده و ﭘـﺲ از‬

‫ﺑﺎزﮔﺸﺖ از ‪ ISR‬آن ﻫﺎ را ﺑﺎزﻳﺎﺑﻲ )‪ (POP‬ﻣﻲ ﻛﻨﺪ‪ .‬ﺑﺮاي ﻏﻴﺮ ﻓﻌﺎل ﻛﺮدن اﻳﻦ ﻗﺎﺑﻠﻴـﺖ ﻣـﻲ ﺗﻮاﻧﻴـﺪ ﻗﺒـﻞ از‬

‫‪ #-pragma savereg‬اﺳﺘﻔﺎده ﻛﻨﻴﺪ‪.‬‬ ‫روﺗﻴﻦ ﺳﺮوﻳﺲ وﻗﻔﻪ از رﻫﻨﻮد‬

‫  ‬
P a g e | 55
www.avr.ir

‫ آﺷﻜﺎر ﺳﺎز ﻋﺒﻮر از ﺻﻔﺮ‬:6 ‫ﭘﺮوژه‬

/*****************************************************
Project : Zero Cross Detector
Author : Reza Sepas Yar
Company : Pishro Noavaran Kavosh
*****************************************************/

#include <mega16.h>
#include <delay.h>
#define xtal 4000000

interrupt [2] void switch_(void)

{
PORTA=0x01;
delay_ms(1);
PORTA=0x00;
}

void main(void)
{
DDRA=0xFF;
PORTA=0x00;
DDRD=0x00;

  
P a g e | 56
www.avr.ir
PORTD=0xFF;

GICR=0b01000000; // INT0: On
MCUCR=0b00000011; // INT0 Mode: Rising Edge

#asm("sei") // Global enable interrupts

while (1);
}

Output vs. Input:

  
P a g e | 57
www.avr.ir

  
‫‪P a g e | 58‬‬
‫‪www.avr.ir‬‬

‫ﺗﺎﻳﻤﺮ‪/‬ﻛﺎﻧﺘﺮ ﺻﻔﺮ‬

‫ﺗﺎﻳﻤﺮ‪ /‬ﻛﺎﻧﺘﺮ ﺻﻔﺮ ﻳﻚ ﺗﺎﻳﻤﺮ ‪ 8‬ﺑﻴﺘﻲ ﻣﻲ ﺑﺎﺷﺪ ﻛـﻪ داراي ﭼﻬـﺎر ‪ Mode‬ﻛـﺎري ‪ Fast PWM ،CTC ،Normal‬و‬

‫‪ Correct PWM Phase‬ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﭘﻴﻦ ‪ T0‬ﺑﻪ ﻋﻨﻮان ورودي ﻛﺎﻧﺘﺮ و ﭘـﻴﻦ ‪ OC0‬ﺧﺮوﺟـﻲ ﺑﺨـﺶ ﻣﻘﺎﻳﺴـﻪ ي‬

‫ﺗﺎﻳﻤﺮ ﻣﻲ ﺑﺎﺷﺪ‪ .‬اﻳﻦ ﺗﺎﻳﻤﺮ داراي ﺳﻪ رﺟﻴﺴﺘﺮ ﺑﻪ ﻧﺎم ﻫﺎي ‪ TCNT0 ،TCCR0‬و ‪ OCR0‬ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﺑﻪ ﺗﺮﺗﻴـﺐ‬

‫ﺟﻬﺖ ﭘﻴﻜﺮﺑﻨﺪي ﺗﺎﻳﻤﺮ‪ ،‬ﻣﻘﺪار ﺷﻤﺎرﻧﺪه و ﻣﻘﺪار ﻣﻘﺎﻳﺴﻪ اﺳﺘﻔﺎده ﻣـﻲ ﺷـﻮﻧﺪ‪ .‬ﻫﻤﭽﻨـﻴﻦ اﻳـﻦ ﺗـﺎﻳﻤﺮ در رﺟﻴﺴـﺘﺮﻫﺎي‬

‫‪ TIFR‬و ‪ TIMSK‬ﻛﻪ ﺑﻪ ﺗﺮﺗﻴﺐ رﺟﻴﺴﺘﺮﻫﺎي ﭘﺮﭼﻢ و وﻗﻔﻪ ﺗﺎﻳﻤﺮ ﻣﻲ ﺑﺎﺷﻨﺪ ﺑﺎ دﻳﮕﺮ ﺗﺎﻳﻤﺮﻫﺎ ﻣﺸﺘﺮك ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﻣﻬﻢ ﺗﺮﻳﻦ رﺟﻴﺴﺘﺮ ﺗﺎﻳﻤﺮ ‪ TTCR0‬ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﺑﻴﺖ ﻫﺎي ‪ Clock Select‬ﺟﻬﺖ اﻧﺘﺨﺎب ﻣﻨﺒﻊ ﻛﻼك ﺗﺎﻳﻤﺮ و ﺑﻴﺖ‬

‫ﻫﺎي ‪ Wave Generation Mode‬ﺑﺮاي ﺗﻨﻈﻴﻢ ‪ Mode‬ﻛﺎري ﺗﺎﻳﻤﺮ و ﺑﻴﺖ ﻫﺎي ‪Compare Match Output‬‬

‫‪ Mode‬ﭘﻴﻜﺮﺑﻨﺪي ﭘﻴﻦ ‪ OC0‬را ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨﺪ‪ .‬ﻋﻤﻠﻜﺮد ﺑﻴﺖ ‪ FOC0‬ﻧﻴﺰ ﺑﺮرﺳﻲ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫‪TCCR0‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪FOC0 WGM00 COM01 COM00 WGM01 CS02 CS01 CS00‬‬

‫‪ Mode‬ﻋﻤﻠﻜﺮد ﺗﺎﻳﻤﺮ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺑﻴﺖ ﻫﺎي ‪ WGM01‬و ‪ WGM00‬ﺑﻪ اﻳﻦ ﺗﺮﺗﻴﺐ ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪:‬‬

‫  ‬
P a g e | 59
www.avr.ir

Mode WGM01 WGM00 ‫ ﻋﻤﻠﻜﺮد‬Mode

0 0 0 Normal
1 0 1 PWM, Phase Correct
Clear Timer on Compare Match
2 1 0
(CTC)
3 1 1 Fast PWM

Noramal Mode 

‫ ﺑﻴﺘﻲ‬8 ‫ ﻛﺎﻧﺘﺮ ﺳﺎده ي‬/‫ﺗﺎﻳﻤﺮ‬ •

: TIMER0 ‫رﺟﻴﺴﺘﺮﻫﺎي‬

TCCR0 7 6 5 4 3 2 1 0
‫ﻧﺎم ﺑﻴﺖ‬ FOC0 WGM00 COM01 COM00 WGM01 CS02 CS01 CS00

‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ‬ 0 0 0 0 0 X X X

Clock ‫ ﻣﺸﺘﺮك ﺑﻮده وﺿﻌﻴﺖ ﻣﻨﺒﻊ ﻛﻼك ﺑﺎ ﺗﻮﺟﻪ ﺑـﻪ ﺑﻴـﺖ ﻫـﺎي‬Prescaler ‫ﻛﺎﻧﺘﺮ ﺻﻔﺮ و ﻳﻚ داراي ﻳﻚ‬/‫ﺗﺎﻳﻤﺮ‬

:‫ ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‬Select

  
‫‪P a g e | 60‬‬
‫‪www.avr.ir‬‬

‫‪CS02‬‬ ‫‪CS01‬‬ ‫‪CS00‬‬ ‫وﺿﻌﻴﺖ ﻣﻨﺒﻊ ﻛﻼك ﺗﺎﻳﻤﺮ‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫ﺑﺪون ﻛﻼك )ﻣﺘﻮﻗﻒ(‬

‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫ﻛﻼك ﺳﻴﺴﺘﻢ )ﺑﺪون ﺗﻘﺴﻴﻢ(‬

‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪/8‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪/64‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪/256‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪/1024‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧﺪه ي ﭘﺎﻟﺲ ﺧﺎرﺟﻲ )‪(T0‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه ي ﭘﺎﻟﺲ ﺧﺎرﺟﻲ )‪(T0‬‬

‫ﻣﻘﺪار ﺗﺎﻳﻤﺮ در ﻫﺮ ﻟﺤﻈﻪ از ﻃﺮﻳﻖ رﺟﻴﺴﺘﺮ ‪ TCNT‬ﻗﺎﺑﻞ ﺧﻮاﻧﺪن و ﻧﻮﺷﺘﻦ اﺳﺖ‪:‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪TCNT0‬‬ ‫]‪TCNT0[7:0‬‬

‫در زﻣﺎن ﺳﺮرﻳﺰ ﺗﺎﻳﻤﺮ‪ ،‬ﺑﻴﺖ ‪ TOV0‬از رﺟﻴﺴﺘﺮ ‪ TIFR‬ﻳﻚ ﻣﻲ ﺷﻮد‪.‬‬

‫‪TIFR‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪OCF2‬‬ ‫‪TOV2‬‬ ‫‪ICF1‬‬ ‫‪OCF1A‬‬ ‫‪OCF1B‬‬ ‫‪TOV1‬‬ ‫‪OCF0‬‬ ‫‪TOV0‬‬

‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪X‬‬

‫
 ‬
P a g e | 61
www.avr.ir

:( µs T = 512 ‫ )ﺗﻮﻟﻴﺪ ﻣﻮج ﻣﺮﺑﻌﻲ ﺑﺎ‬:1‫ﻣﺜﺎل‬

#include<mega16.h>
#define xtal 8000000

void delay()
{
TCCR0=0B00000010; // Timer Clock = CLK/8
while(!TIFR&0x01); // Wait Until Overflow
TIFR=TIFR|0B00000001; // Clear TOV0
TCCR0=0x00; // Stop Timer0
}

void main()
{
DDRA=0xFF;
PORTA=0x00;
TCCR0=0x00;
TCNT0=0x00;

while(1){
PORTA.0=1;
delay();
PORTA.0=0;
delay();
}

  
P a g e | 62
www.avr.ir

( 400µs ‫ )ﻛﺎﻫﺶ دوره ي ﺗﻨﺎوب ﺑﻪ‬:2‫ﻣﺜﺎل‬

void delay()
{
TCNT0=0x38; //TCNT=55
TCCR0=0B00000010;
while(!TIFR&0x01);
TIFR=TIFR|0B00000001;
TCCR0=0x00;
}

‫ در رﺟﻴﺴﺘﺮ‬TOIE2 ‫ ﻳﺎ‬TOIE0 ‫( ﻓﻌﺎل ﺑﻮده و ﺑﻴﺖ ﻫﺎي‬I) ‫در ﺻﻮرﺗﻲ ﻛﻪ ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﻋﻤﻮﻣﻲ وﻗﻔﻪ‬ 

:‫ از ﺳﺮرﻳﺰ ﺷﺪن ﺗﺎﻳﻤﺮ ﺑﻪ ﻋﻨﻮان وﻗﻔﻪ اﺳﺘﻔﺎده ﻛﺮد‬،‫ ﻳﻚ ﺑﺎﺷﻨﺪ ﻣﻲ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎده از وﻗﻔﻪ‬TIMSK

TIMSK 7 6 5 4 3 2 1 0
‫ﻧﺎم ﺑﻴﺖ‬ OCIE2 TOIE2 TICIE1 OCIE1A OCIE1B TOIE1 OCIE0 TOIE0

‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ‬ 0 0 0 0 0 0 0 X

(‫ ﺑﺎ اﺳﺘﻔﺎده از وﻗﻔﻪ ي ﺳﺮرﻳﺰ ﺗﺎﻳﻤﺮ ﺻﻔﺮ‬T = 400µs ‫ )ﻣﻮج ﻣﺮﺑﻌﻲ‬:3‫ﻣﺜﺎل‬

#include <mega16.h>
#define xtal 8000000

interrupt [TIM0_OVF] void timer0_ovf_isr(void)

{
PORTA^=0xFF;
TCNT0=0x38; //TCNT=55

  
‫‪P a g e | 63‬‬
‫‪www.avr.ir‬‬
‫}‬

‫)‪void main(void‬‬
‫{‬
‫;‪DDRA=0xFF‬‬
‫;‪PORTA=0x00‬‬
‫;‪TCCR0=0B00000010‬‬ ‫‪// Timer Clock = CLK/8‬‬
‫;‪TIMSK=0x01‬‬ ‫‪//Enable TIMER0 Overflow‬‬
‫‪Interrupt‬‬
‫)"‪#asm("sei‬‬ ‫‪// Global enable interrupts‬‬
‫;‪TCNT0=0x38‬‬

‫;)‪while (1‬‬
‫}‬

‫• ﺗﺎﻳﻤﺮ‪ /‬ﻛﺎﻧﺘﺮ ﺑﺎ ﻋﻤﻠﻜﺮد ﻣﻘﺎﻳﺴﻪ‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪OCR0/2‬‬ ‫]‪OCR0[7:0‬‬

‫• ﻣﺤﺘﻮاي رﺟﻴﺴﺘﺮ ‪ OCR0‬ﺑﻪ ﻃﻮر ﭘﻴﻮﺳﺘﻪ ﺑﺎ ﻣﻘﺪار ‪ TCNT0‬ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮد و در ﺻﻮرت ﺑﺮاﺑﺮي ﺑﺎﻋـﺚ‬

‫ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ ﭘﻴﻦ ‪ OC0‬و ﻳﺎ وﻗﻔﻪ ي ﺗﻄﺎﺑﻖ ﻣﻲ ﺷﻮد‪ .‬در ﺣﺎﻟﺖ ﺑﺮاﺑﺮي ﺑﻴﺖ ‪ OCF0‬ﻳﺎ ‪ OCF1‬ﻳﻚ ﺷﺪه‬

‫و ﺑﺎ ﻓﺮاﺧﻮاﻧﻲ ﺳﺎﺑﺮوﺗﻴﻦ وﻗﻔﻪ ﺑﻪ ﺻﻮرت ﺳﺨﺖ اﻓﺰاري ﺻﻔﺮ ﻣﻲ ﺷﻮد‪ .‬در ﺻـﻮرت ﻋـﺪم اﺳـﺘﻔﺎده از وﻗﻔـﻪ‬

‫ﻛﺎرﺑﺮ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ روي اﻳﻦ ﺑﻴﺖ آن را ﭘﺎك ﻛﻨﺪ‪.‬‬

‫‪TIFR‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫  ‬
‫‪P a g e | 64‬‬
‫‪www.avr.ir‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪OCF2‬‬ ‫‪TOV2‬‬ ‫‪ICF1‬‬ ‫‪OCF1A‬‬ ‫‪OCF1B‬‬ ‫‪TOV1‬‬ ‫‪OCF0‬‬ ‫‪TOV0‬‬

‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪X‬‬ ‫‪X‬‬

‫ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ ﭘﻴﻦ ‪ OC0‬ﺑﻮﺳﻴﻠﻪ ﺑﻴﺖ ﻫﺎي ‪ COM00‬و ‪ COM01‬ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫‪TCCR0‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪FOC0‬‬ ‫‪WGM00‬‬ ‫‪COM01‬‬ ‫‪COM00‬‬ ‫‪WGM01‬‬ ‫‪CS02‬‬ ‫‪CS01‬‬ ‫‪CS00‬‬

‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ‬ ‫‪X‬‬ ‫‪0‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪0‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬

‫‪COM01 COM00‬‬ ‫وﺿﻌﻴﺖ ﭘﻴﻦ ‪OC0‬‬

‫‪0‬‬ ‫‪0‬‬ ‫ﻏﻴﺮ ﻓﻌﺎل )‪ I/O‬ﻣﻌﻤﻮﻟﻲ(‬

‫‪0‬‬ ‫‪1‬‬ ‫‪ Toggle‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‬

‫‪1‬‬ ‫‪0‬‬ ‫‪ Clear‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‬

‫‪1‬‬ ‫‪1‬‬ ‫‪ Set‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‬

‫• در ﺻﻮرت ﻳﻚ ﻛﺮدن ﺑﻴﺖ ‪ FOC0‬ﻳﺎ ‪ FOC1‬ﺑﻪ ﺻﻮرت آﻧﻲ ﻣﻘـﺪار رﺟﻴﺴـﺘﺮ ‪ TCNT0‬ﺑـﺎ ﻣﻘـﺪار ‪OCR0‬‬

‫ﻣﻘﺎﻳﺴﻪ ﺷﺪه و در ﺻﻮرت ﺗﻄﺒﻴﻖ ﻣﻘﺎﻳﺴﻪ ﻳﻚ ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ روي ﭘﻴﻦ ‪ OC0‬اﻳﺠﺎد ﻣﻲ ﺷﻮد‪ .‬در اﻳﻦ وﺿـﻌﻴﺖ ﺑﻴـﺖ‬

‫‪ OCF0‬ﻳﺎ ‪ OCF1‬ﻳﻚ ﻧﺸﺪه و ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﻧﻴﺰ ﻧﺨﻮاﻫﺪ ﺷﺪ‪.‬‬

‫• در ﺗﻤﺎم ﺣﺎﻟﺖ ﻫﺎﻳﻲ ﻛﻪ روي ﭘﻴﻦ ﻫﺎي ‪ OC‬ﺷﻜﻞ ﻣﻮج اﻳﺠﺎد ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ اﻳﻦ ﭘﻴﻦ ﺑﻪ ﺻﻮرت ﺧﺮوﺟﻲ ﺗﻌﺮﻳﻒ‬

‫ﺷﺪه ﺑﺎﺷﺪ‪.‬‬

‫  ‬
P a g e | 65
www.avr.ir

(OC0 ‫ روي ﭘﻴﻦ‬µs T = 512 ‫ )اﻳﺠﺎد ﭘﺎﻟﺲ ﻣﺮﺑﻌﻲ ﺑﺎ‬:4‫ﻣﺜﺎل‬

#include<mega16.h>
#define xtal 8000000

void main()
{
DDRB=0xFF;
PORTB=0x00;
TCNT0=0x00;
TCCR0=0B00010010; //toggle OC0 on compare match
OCR0=0x63; //OCR0=99

while(1);
}

Set ‫ ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﻣﻘﺎﻳﺴﻪ ي وﻗﻔﻪ ﻧﻴﺰ‬،‫ﺑﺮاي اﺳﺘﻔﺎده از وﻗﻔﻪ ﺑﺎﻳﺪ ﻋﻼوه ﺑﺮ ﻳﻚ ﺑﻮدن ﻓﻌﺎل ﺳﺎز ﻋﻤﻮﻣﻲ وﻗﻔﻪ ﻫﺎ‬

.‫ﺷﻮد‬

TIMSK 7 6 5 4 3 2 1 0
‫ﻧﺎم ﺑﻴﺖ‬ OCIE2 TOIE2 TICIE1 OCIE1A OCIE1B TOIE1 OCIE0 TOIE0

‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ‬ X X 0 0 0 0 X X

  
‫‪P a g e | 66‬‬
‫‪www.avr.ir‬‬
‫در اﻳﻦ ﺣﺎﻟﺖ ‪ ISR‬ﺑﻪ ﺻﻮرت زﻳﺮ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮد‪:‬‬

‫)‪interrupt [TIM0_COMP] void timer0_comp_isr(void‬‬

‫{‬
‫زﻳﺮ ﺑﺮﻧﺎﻣﻪ ي ﺳﺮوﻳﺲ وﻗﻔﻪ‬

‫}‬

‫ ‪CTC Mode‬‬

‫در اﻳﻦ ‪ Mode‬ﺗﺎﻳﻤﺮ ﻫﻤﺎﻧﻨﺪ وﺿﻌﻴﺖ ﻧﺮﻣﺎل ﺑﺎ ﻋﻤﻠﻜﺮد ﻣﻘﺎﻳﺴﻪ ﻋﻤﻞ ﻣﻲ ﻛﻨﺪ ﺑـﺎ اﻳـﻦ ﺗﻔـﺎوت ﻛـﻪ در زﻣـﺎن ﺗﻄـﺎﺑﻖ‬

‫رﺟﻴﺴﺘﺮﻫﺎي ‪ OCR0‬و ‪ TCNT0‬ﻣﻘﺪار رﺟﻴﺴﺘﺮ ‪ TCNT0‬ﺻﻔﺮ ﺷﺪه و در واﻗﻊ ﺑـﺮ ﺧـﻼف ﺣﺎﻟـﺖ ﻗﺒـﻞ ﻣﻘـﺪار‬

‫ﻣﺎﻛﺰﻳﻤﻢ ‪ TCNT0‬ﻋﺪد ﻣﻮﺟﻮد در رﺟﻴﺴﺘﺮ ‪ OCR0‬ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﻣﻘﺪار ﺑﻴﺖ ﻫﺎي ‪ WGM00‬و ‪ WGM01‬در اﻳﻦ‬

‫‪ Mode‬ﺑﻪ ﺗﺮﺗﻴﺐ ﺑﺮاﺑﺮ ‪ 0‬و ‪ 1‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫‪TCCR0‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪FOC0‬‬ ‫‪WGM00‬‬ ‫‪COM01‬‬ ‫‪COM00‬‬ ‫‪WGM01‬‬ ‫‪CS02‬‬ ‫‪CS01‬‬ ‫‪CS00‬‬

‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ‬ ‫‪X‬‬ ‫‪0‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪1‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬

‫در اﻳﻦ ﺣﺎﻟﺖ ﻓﺮﻛﺎﻧﺲ ﻣﻮج اﻳﺠﺎد ﺷﺪه روي ﭘﻴﻦ ‪ OC0‬از راﺑﻄﻪ ي زﻳﺮ ﺑﺪﺳﺖ ﻣﻲ آﻳﺪ‪:‬‬ ‫•‬

‫‪f CLK _ I / O‬‬

‫= ‪f OC 0‬‬
‫)‪2.N .(1 + OCR0‬‬

‫  ‬
‫‪P a g e | 67‬‬
‫‪www.avr.ir‬‬

‫ﻣﺜﺎل‪) :5‬اﻳﺠﺎد ﻣﻮج ﻣﺮﺑﻌﻲ ﺑﺎ ﻓﺮﻛﺎﻧﺲ ‪ 5KHz‬روي ﭘﻴﻦ ‪:(OC0‬‬

‫>‪#include<mega16.h‬‬
‫‪#define xtal 8000000‬‬

‫)(‪void main‬‬
‫{‬
‫;‪DDRB=0xFF‬‬
‫;‪PORTB=0x00‬‬
‫;‪TCNT0=0x00‬‬
‫‪OCR0=0x63; //OCR0=99‬‬
‫‪TCCR0=0B00011010; //toggle OC0 on compare match‬‬

‫;)‪while(1‬‬
‫}‬

‫‪8000000‬‬
‫= ‪f OC0‬‬ ‫‪= 5000Hz‬‬
‫)‪2.8.(1 + 99‬‬

‫وﺿﻌﻴﺖ ﺑﻴﺖ ﻫﺎي ﻓﻌﺎل ﺳﺎز وﻗﻔﻪ ي ﺳﺮرﻳﺰ و وﻗﻔﻪ ي ﻣﻘﺎﻳﺴﻪ در ‪ CTC Mode‬ﻫﻤﺎﻧﻨﺪ وﺿﻌﻴﺖ ﻧﺮﻣﺎل ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﺑﺎ ﻳﻚ ﺑﻮدن ﺑﻴﺖ ‪ OCIE0‬وﻗﻔﻪ ي ﻣﻘﺎﻳﺴﻪ ﻓﻌﺎل ﻣﻲ ﺑﺎﺷﺪ و ﻣﻲ ﺗﻮان در ‪ ISR‬اﻳﻦ وﻗﻔـﻪ ﻣﻘـﺪار ‪ OCR0‬را ﺗﻐﻴﻴـﺮ‬

‫داد‪.‬‬

‫• ﻣﻘﺪار دﻫﻲ ﺑﻪ رﺟﻴﺴﺘﺮ ‪ OCR0‬ﺑﺎﻳﺪ ﺑﺎ دﻗﺖ اﻧﺠﺎم ﺷﻮد زﻳﺮا در ‪ Mode‬ﻫﺎي ﻏﻴﺮ ‪ PWM‬اﻳﻦ رﺟﻴﺴـﺘﺮ داراي‬

‫ﺑﺎﻓﺮ دوﺑﻞ ﻧﻤﻲ ﺑﺎﺷﺪ‪ .‬وﺟﻮد ﺑﺎﻓﺰ دوﺑﻞ ﺑﺎﻋﺚ ﻣﻲ ﺷﻮد ﻛﻪ اﮔﺮ ‪ OCR0‬ﺑﻪ ﻣﻘـﺪاري ﻛﻤﺘـﺮ از ‪ TCNT0‬ﺗﻐﻴﻴـﺮ ﻛﻨـﺪ‪،‬‬

‫  ‬
P a g e | 68
www.avr.ir
‫ﺑﺮاي از دﺳﺖ ﻧﺮﻓﺘﻦ ﻣﻘﺎﻳﺴﻪ ي ﻓﻌﻠﻲ ﻣﻘﺪار ﺟﺪﻳﺪ در ﺑﺎﻓﺮ دوﺑﻞ ذﺧﻴﺮه ﺷﺪه و ﭘﺲ از ﺳﺮرﻳﺰ اﻳﻦ ﻣﻘﺪار ﺟﺪﻳـﺪ در‬

.‫ ﺑﺎرﮔﺬاري ﺷﻮد‬OCR0

‫ ﻓﺮﻛﺎﻧﺲ ﻣﺘﺮ دﻳﺠﻴﺘﺎل‬:7 ‫ﭘﺮوژه‬

/*****************************************************
Project : Frequency Meter
Author : Reza Sepas Yar
Company : Pishro Noavaran Kavosh
*****************************************************/

#include <mega16.h>
#include <delay.h>
#include <stdio.h>
#include <lcd.h>
#define xtal 8000000

#asm
.equ __lcd_port=0x1B ;PORTA
#endasm

unsigned long int timer0_ov;

unsigned long int in_freq;
unsigned char lcd_buff[20];

interrupt [TIM0_OVF] void timer0_ovf_isr(void)

{
  
P a g e | 69
www.avr.ir
timer0_ov ++;
}

void main(void)
{

// Timer/Counter 0 initialization
// Clock source: T0 pin Falling Edge
// Mode: Normal top=FFh
// OC0 output: Disconnected
TCNT0=0x00;
OCR0=0x00;
TCCR0=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization

TIMSK=0x01;

// LCD module initialization

lcd_init(16);

while (1)
{
TCCR0=0x06; // Start Timer T0 pin Falling Edge

#asm("sei") // Global enable interrupts

delay_ms(1000);

#asm("cli"); // Global disable interrupts

  
P a g e | 70
www.avr.ir
in_freq = timer0_ov * 256 + TCNT0;
sprintf(lcd_buff,"Freqency=%d",in_freq);
lcd_clear();
lcd_puts(lcd_buff);
TCCR0=0x00; //Stopt Timer0
timer0_ov=0; //Prepare for next count
TCNT0=0; //Clear Timer0
};
}

 

‫‪P a g e | 71‬‬
‫‪www.avr.ir‬‬

‫ ‪Fast PWM Mode‬‬

‫اﻳﻦ ﺣﺎﻟﺖ ﻣﺸﺎﺑﻪ ‪ Mode‬ﻧﺮﻣﺎل ﻣﻲ ﺑﺎﺷﺪ ﺑﺎ اﻳـﻦ ﺗﻔـﺎوت ﻛـﻪ ﭘـﻴﻦ ‪ OC0‬ﻓﻘـﻂ در ﺣﺎﻟـﺖ ﺑﺮاﺑـﺮي رﺟﻴﺴـﺘﺮﻫﺎي‬

‫‪TCNT0‬و ‪ OCR0‬ﺗﻐﻴﻴﺮ ﺣﺎﻟﺖ ﻧﻤﻲ دﻫﺪ‪ ،‬ﺑﻠﻜﻪ در زﻣﺎن ﺳﺮرﻳﺰ رﺟﻴﺴﺘﺮ ‪ TCNT0‬ﻧﻴﺰ ﻣﻘﺪار اﻳﻦ ﭘﻴﻦ ﺗﻐﻴﻴﺮ ﻣﻲ‬

‫ﻛﻨﺪ‪.‬‬

‫ﻣﻘﺪار ‪TCNT0‬‬ ‫ﻣﻘﺪار ‪OCR0‬‬

‫ﺧﺮوﺟﻲ ‪PWM‬‬

‫ﻣﻘﺪار ﺑﻴﺖ ﻫﺎي ‪ WGM00‬و ‪ WGM01‬در اﻳﻦ ‪ Mode‬ﺑﺮاﺑﺮ ‪ 1‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪TCCR0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪COM01‬‬ ‫‪COM00‬‬ ‫‪1‬‬ ‫‪CS02‬‬ ‫‪CS01‬‬ ‫‪CS00‬‬

‫در ‪ Mode‬ﻫﺎي ‪ PWM‬ﻋﻤﻠﻜﺮد ﺑﻴﺖ ﻫﺎي ‪ COM00‬و ‪ COM01‬ﻣﺘﻔﺎوت از دو وﺿﻌﻴﺖ ﻗﺒﻠـﻲ و ﺑـﻪ ﺻـﻮرت‬

‫زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫‪COM01‬‬ ‫‪COM00‬‬ ‫وﺿﻌﻴﺖ ﭘﻴﻦ ‪OC0‬‬

‫  ‬
‫‪P a g e | 72‬‬
‫‪www.avr.ir‬‬
‫‪0‬‬ ‫‪0‬‬ ‫ﻏﻴﺮ ﻓﻌﺎل )‪ I/O‬ﻣﻌﻤﻮﻟﻲ(‬

‫‪0‬‬ ‫‪1‬‬ ‫رزرو ﺷﺪه‬

‫‪1‬‬ ‫‪0‬‬ ‫‪ Clear‬دروﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‪ Set ،‬در زﻣﺎن ﺳﺮرﻳﺰ )‪ PWM‬ﻏﻴﺮ ﻣﻌﻜﻮس(‬

‫‪1‬‬ ‫‪1‬‬ ‫‪ Set‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‪ Clear ،‬در زﻣﺎن ﺳﺮرﻳﺰ )‪ PWM‬ﻣﻌﻜﻮس(‬

‫ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ي ﻓﺮﻛﺎﻧﺲ ﻣﻮج ‪ PWM‬ﺗﻮﻟﻴﺪ ﺷﺪه ﻣﻲ ﺗﻮان از ﻓﺮﻣﻮل زﻳﺮ اﺳﺘﻔﺎد ﻧﻤﻮد‪:‬‬

‫‪f clk _ I / O‬‬

‫= ‪f PWM‬‬ ‫‪N = Prescale = 1, 8, 64, 256, 1024‬‬ ‫ﻣﻘﺪار ﺑﺎرﮔﺬاري ﺷﺪه در ﺗﺎﻳﻤﺮ – ‪X = 256‬‬
‫‪N .X‬‬

‫از وﻗﻔﻪ ي ﺳﺮرﻳﺰ ﺗﺎﻳﻤﺮ ﻣﻲ ﺗﻮان ﺑﺮاي ﻣﻘﺪار اوﻟﻴﻪ دادن ﺑﻪ ‪ TCNT0‬و ﻳـﺎ ﺗﻐﻴﻴـﺮ ﻣﻘـﺪار ‪ OCR0‬اﺳـﺘﻔﺎده‬ ‫‬

‫ﻧﻤﻮد‪ ،‬اﮔﺮﭼﻪ ﺑﻬﺘﺮ اﺳﺖ ﻣﻘﺪار ‪ OCR0‬در روﺗﻴﻦ وﻗﻔﻪ ي ﻣﻘﺎﻳﺴﻪ ﺗﻐﻴﻴﺮ داده ﺷﻮد‪.‬‬

‫ﺑﺎ ﻣﻘﺪار اوﻟﻴﻪ دادن ﺑﻪ ‪ TCNT0‬ﻣﻲ ﺗﻮان ﻓﺮﻛﺎﻧﺲ ﻣﻮج ‪ PWM‬را ﺗﻐﻴﻴﺮ داد‪(.‬‬ ‫‬

‫ﻣﺜﺎل‪) :6‬ﺗﻮﻟﻴﺪ ﻣﻮج ‪ PWM‬ﺑﺎ ﻓﺮﻛﺎﻧﺲ ‪ 4KHz‬و زﻣﺎن وﻇﻴﻔﻪ ي ‪ 20‬درﺻﺪ(‬

‫>‪#include <mega16.h‬‬
‫‪#define xtal 8000000‬‬

‫)‪interrupt [TIM0_OVF] void timer0_ovf_isr(void‬‬

‫{‬
‫;‪TCNT0=0x06‬‬
‫}‬

‫)‪void main(void‬‬
‫{‬

‫  ‬
P a g e | 73
www.avr.ir
PORTB=0x00;
DDRB=0x08;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 1000.000 kHz
// Mode: Fast PWM top=FFh
// OC0 output: Non-Inverted PWM
TCCR0=0x6A; //0x7A for inverted PWM
TCNT0=0x06;
OCR0=0x38; //OCR0 = 56

// Timer(s)/Counter(s) Interrupt(s) initialization

TIMSK=0x01;

// Global enable interrupts

#asm("sei")

while (1);

8000000
f PWM = = 4000Hz
8(256 − 6)

OCR0 50
DutyCycle = × 100 % = × 100 % = 20%
250 250

  
‫‪P a g e | 74‬‬
‫‪www.avr.ir‬‬
‫• ﺑﺎ ﻛﻤﺘﺮ ﺷﺪن ‪ OCR0‬زﻣﺎن وﻇﻴﻔﻪ ﻛﻤﺘﺮ ﺷﺪه و ﺗﺎ ﺣﺪي ﻛﻪ ﻣﻘﺪار ﺻﻔﺮ ﻳﻚ ﭘﺎﻟﺲ ﺳﻮزﻧﻲ ﺑﻪ ﻋﺮض ﻳﻚ ﺳﻴﻜﻞ‬

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

‫• ﺑﺎ ﻣﻘﺪاردﻫﻲ ‪ 256‬ﺑﻪ ‪ OCR0‬ﻣﻘﺪار ﻣﻘﺎﻳﺴﻪ و ﺳﺮرﻳﺰ ﺑﺮاﺑﺮ ﺷﺪه و ﭘﺎﻟﺲ ﺧﺮوﺟﻲ ﺑﺴﺘﻪ ﺑﻪ ﻣﻘﺪار ‪ COM00‬و‬

‫‪ COM01‬ﻫﻤﻮاره ﺻﻔﺮ ﻳﺎ ﻳﻚ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬

‫ ‪Phase Correct PWM Mode‬‬

‫اﻳﻦ ‪ Mode‬ﺷﺒﻴﻪ ﺣﺎﻟﺖ ‪ Fast PWM‬ﻣﻲ ﺑﺎﺷﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ ﺗﺎﻳﻤﺮ ﺑﻪ ﺻﻮرت دو ﺷﻴﺒﻪ )‪ (Dual Slope‬ﻋﻤﻞ‬

‫ﺷﻤﺎرش را اﻧﺠﺎم ﻣﻲ دﻫﺪ‪ .‬ﺑﻪ اﻳﻨﺼﻮرت ﻛﻪ ﺗﺎﻳﻤﺮ از ﻋﺪد ﺻﻔﺮ ﺷﺮوع ﺑﻪ ﺷﻤﺎرش ﻛﺮده و ﺑﻪ ﺻﻮرت اﻓﺰاﻳﺸﻲ ﺗﺎ ﻋﺪد‬

‫‪ 0xFF‬اﻓﺰاﻳﺶ ﻣﻲ ﻳﺎﺑﺪ و ﺑﻌﺪ از رﺳﻴﺪن ﺑﻪ اﻳﻦ ﻣﻘﺪار ﻋﺪد ﻣﻮﺟﻮد در ﺑﺎﻓﺮ ‪ OCR0‬در رﺟﻴﺴﺘﺮ ‪ OCR0‬ﺑﺎرﮔﺬاري‬

‫ﻣﻲ ﺷﻮد‪ .‬ﺑﻌﺪ از اﻳﻦ ﻟﺤﻈﻪ ﺟﻬﺖ ﺷﻤﺎرش ﺗﺎﻳﻤﺮ ﻋﻮض ﺷﺪه و ﺑﻪ ﺻﻮرت ﻛﺎﻫﺸﻲ ﺗﺎ ﻋﺪد ﺻﻔﺮ ﻣﻲ ﺷﻤﺎرد ﺑﺎ رﺳﻴﺪن‬

‫ﺑﻪ اﻳﻦ ﻋﺪد ﭘﺮﭼﻢ ﺳﺮرﻳﺰ ﺗﺎﻳﻤﺮ ﻳﻚ ﺷﺪه و در ﺻﻮرت ﻳﻚ ﺑﻮدن ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز وﻗﻔﻪ‪ ،‬ﺑﺮﻧﺎﻣﻪ ﺑﻪ ‪ ISR‬ﺳـﺮرﻳﺰ ﺗـﺎﻳﻤﺮ‬

‫ﻣﻨﺸﻌﺐ ﺷﺪه و ﺑﻴﺖ ﭘﺮﭼﻢ وﻗﻔﻪ ﺑﻮﺳﻴﻠﻪ ﺳﺨﺖ اﻓﺰار ﺻﻔﺮ ﻣﻲ ﺷﻮد‪ .‬ﻣﺴﺌﻠﻪ ي ﻣﻬﻢ اﻳﻦ اﺳﺖ ﻛـﻪ در ﻫـﺮ دو ﺣﺎﻟـﺖ‬

‫ﺷﻤﺎرش اﻓﺰاﻳﺸﻲ و ﻛﺎﻫﺸﻲ ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺑﻴﻦ رﺟﻴﺴـﺘﺮﻫﺎي ‪ TCNT0‬و ‪ OCR0‬اﻧﺠـﺎم ﻣـﻲ ﮔﻴـﺮد و در ﺻـﻮرت‬

‫ﺑﺮاﺑﺮي ﭘﺮﭼﻢ ‪ OCF0‬ﻳﻚ ﺷﺪه و ﺑﺎﻋﺚ ﺗﻐﻴﻴﺮ در ﭘﻴﻦ ‪ OC0‬ﻣﻲ ﺷﻮد‪.‬‬

‫ﻣﻘﺪار ‪OCR0‬‬
‫ﻣﻘﺪار ‪TCNT0‬‬

‫ﺧﺮوﺟﻲ ‪ PWM‬در ﺣﺎﻟﺖ ﻏﻴﺮ ﻣﻌﻜﻮس‬

‫  ‬
‫‪P a g e | 75‬‬
‫‪www.avr.ir‬‬

‫ﺗﻐﻴﻴﺮ ﭘﻴﻦ ‪ OC0‬ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫‪COM01‬‬ ‫‪COM00‬‬ ‫وﺿﻌﻴﺖ ﭘﻴﻦ ‪OC0‬‬

‫‪0‬‬ ‫‪0‬‬ ‫ﻏﻴﺮ ﻓﻌﺎل )‪ I/O‬ﻣﻌﻤﻮﻟﻲ(‬

‫‪0‬‬ ‫‪1‬‬ ‫رزرو ﺷﺪه‬

‫‪ Clear‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‪ ،‬در زﻣﺎن ﺷﻤﺎرش اﻓﺰاﻳﺸﻲ )‪ PWM‬ﻏﻴﺮ ﻣﻌﻜﻮس(‬

‫‪1‬‬ ‫‪0‬‬
‫‪ Set‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‪ ،‬در زﻣﺎن ﺷﻤﺎرش ﻛﺎﻫﺸﻲ‬

‫‪ Set‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‪ ،‬در زﻣﺎن ﺷﻤﺎرش اﻓﺰاﻳﺸﻲ )‪ PWM‬ﻣﻌﻜﻮس(‬

‫‪1‬‬ ‫‪1‬‬
‫‪ Clear‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‪ ،‬در زﻣﺎن ﺷﻤﺎرش ﻛﺎﻫﺸﻲ‬

‫• در ﺻﻮرت ﺗﻐﻴﻴﺮ ﻣﻘﺪار رﺟﻴﺴﺘﺮ ‪ OCR0‬ﻣﻘﺪار ﺟﺪﻳﺪ در ﺑﺎﻓﺮ اﻳﻦ رﺟﻴﺴـﺘﺮ ﻧﻮﺷـﺘﻪ ﻣـﻲ ﺷـﻮد و در زﻣـﺎن‬

‫رﺳﻴﺪن ﺑﻪ ‪ 0xFF‬رﺟﻴﺴﺘﺮ ‪ OCR0‬ﺑﻪ روز ﻣﻲ ﺷﻮد‪.‬‬

‫• ﭘﺮﭼﻢ ﺳﺮرﻳﺰ ﺗﺎﻳﻤﺮ ﺻﻔﺮ زﻣﺎﻧﻲ ﻓﻌﺎل ﻣﻲ ﺷﻮد ﻛﻪ ﻛﻪ رﺟﻴﺴـﺘﺮ ‪ TCNT0‬ﺑﺮاﺑـﺮ ﺻـﻔﺮ ﺷـﻮد و ﻧـﻪ ‪،0xFF‬‬

‫ﺑﻨﺎﺑﺮاﻳﻦ ﺑﺎﻳﺪ دﻗﺖ داﺷﺖ ﻛﻪ اﮔﺮ در زﻣﺎن ﺷﺮوع ﺑﻪ ﻛﺎر ﻣﻘﺪار اﻳﻦ رﺟﻴﺴﺘﺮ ﺻﻔﺮ ﺑﺎﺷﺪ ﭘـﺮﭼﻢ ﺳـﺮرﻳﺰ ﻓﻌـﺎل‬

‫ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫• ﻓﺮﻛﺎﻧﺲ ‪ PWM‬در ﺣﺎﻟﺖ ‪ Phase Correct‬از راﺑﻄﻪ ي زﻳﺮ ﻗﺎﺑﻞ ﻣﺤﺎﺳﺒﻪ اﺳﺖ‪:‬‬

‫‪f clk _ I / O‬‬

‫= ‪f PWM‬‬ ‫‪N = 1, 8, 64, 256, 1024‬‬
‫‪N × 510‬‬

‫• راﺑﻄﻪ ي ﺑﺎﻻ ﻧﺸﺎن ﻣﻲ دﻫﺪ ﻓﺮﻛﺎﻧﺲ ﻣﻮج ‪ PWM‬ﺛﺎﺑﺖ اﺳﺖ و ارﺗﺒﺎﻃﻲ ﺑﻪ رﺟﻴﺴﺘﺮﻫﺎي ‪ OCR0‬و‬

‫‪ TCNT0‬ﻧﺪارد‪.‬‬

‫  ‬
P a g e | 76
www.avr.ir
‫ اﻓﺰاﻳﺶ ﻳﺎﻓﺘﻪ و ﺑﺎ‬PWM ‫ ﻣﻘﺪار ﻣﺘﻮﺳﻂ ﻣﻮج‬OCR0 ‫ ﻏﻴﺮ ﻣﻌﻜﻮس ﺑﺎ اﻓﺰاﻳﺶ ﻣﻘﺪار‬PWM ‫• در ﺣﺎﻟﺖ‬

.‫ ﻋﻜﺲ اﻳﻦ ﻗﻀﻴﻪ ﺻﺤﻴﺢ اﺳﺖ‬،‫ ﻣﻌﻜﻮس‬PWM ‫ﻛﺎﻫﺶ آن ﻣﻘﺪار ﻣﺘﻮﺳﻂ ﻛﺎﻫﺶ ﻣﻲ ﻳﺎﺑﺪ و در ﺣﺎﻟﺖ‬

PWM ‫ ﺑﺎ‬DC ‫ ﻛﻨﺘﺮل ﻣﻮﺗﻮر‬:8 ‫ﭘﺮوژه‬

/*****************************************************
Project : DC Motor Control
Author : Reza Sepas Yar
Company : Pishro Noavaran Kavosh
*****************************************************/

#include <mega16.h>
#define xtal 1000000

char digits[8]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07};
unsigned char;
unsigned char p_state;
unsigned char key;
unsigned char i;

void main(void)
{

PORTB=0x00;
DDRB=0xFF;
DDRD = 0xFF;
PORTD = digits[0];
DDRC = 0x00;

  
P a g e | 77
www.avr.ir
PORTC = 0xFF;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 15.625 kHz
// Mode: Phase correct PWM top=FFh
// OC0 output: Non-Inverted PWM
TCCR0=0x63;
TCNT0=0x00;
OCR0=10;

while (1)
{
if(!PINC.0)
{
if(key!=p_state)
{
if(i==7)
{
i=0;
PORTC=digits[0];
}
else
i++;

PORTD = digits[i];
OCR0 = i*10+10;
p_state=key;
};
}

  
‫‪P a g e | 78‬‬
‫‪www.avr.ir‬‬
‫‪else‬‬
‫;‪p_state=0xFF‬‬

‫;}‬
‫}‬

‫ﺗﻮﺿﻴﺢ‪ :‬ﺑﺮاي آزﻣﺎﻳﺶ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺟﺎي ﻣﻮﺗﻮر ﻣﻲ ﺗﻮان از ‪ LED‬اﺳﺘﻔﺎده ﻧﻤﻮد‪.‬‬

‫  ‬
‫‪P a g e | 79‬‬
‫‪www.avr.ir‬‬

‫ﻋﻤﻠﻜﺮد ﺗﺎﻳﻤﺮ دو‬

‫ﺑﻪ ﻃﻮر ﻛﻠﻲ ﻋﻤﻠﻜﺮد ﺗﺎﻳﻤﺮ ‪ 2‬ﻣﺸﺎﺑﻪ ﺗﺎﻳﻤﺮ ﺻﻔﺮ ﻣﻲ ﺑﺎﺷﺪ و رﺟﻴﺴﺘﺮﻫﺎي ﻣﺮﺑﻮﻃﻪ ﺑﺎ ﻫﻤﺎن ﻧﺎم و داراي ﭘﺴـﻮﻧﺪ ‪ 2‬ﻣـﻲ‬

‫ﺑﺎﺷﻨﺪ‪ ،‬ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ ﺗﺎﻳﻤﺮ‪ 2‬ﺑﺮﺧﻼف ﺗﺎﻳﻤﺮﻫﺎي ﺻﻔﺮ و ﻳﻚ ﻧﻤﻲ ﺗﻮاﻧﺪ از ﭘﺎﻳﻪ ﺧﺎرﺟﻲ ‪ T0‬ﻳﺎ ‪ T1‬ﻛﻼك درﻳﺎﻓﺖ‬

‫ﻛﻨﺪ و در ﻋﻮض ﻣﻲ ﺗﻮان ﺑﺎ وﺻﻞ ﻛﺮدن ﻳﻚ ﻛﺮﻳﺴﺘﺎل ‪ 32.768‬ﻛﻴﻠﻮﻫﺮﺗﺰ ﺑﻪ ﭘﻴﻦ ﻫـﺎي ‪ TOSC1‬و ‪ TOSC2‬از آن‬

‫در وﺿﻌﻴﺖ آﺳﻨﻜﺮون ﺟﻬﺖ ‪ RTC‬اﺳﺘﻔﺎده ﻧﻤﻮد‪ .‬از آﻧﺠﺎﻳﻲ ﻛﻪ ﺗﺎﻳﻤﺮ‪ 2‬داراي ‪ Prescaler‬ﻣﺠـﺰا از دو ﺗـﺎﻳﻤﺮ‪ 0‬و‪1‬‬

‫ﻣﻲ ﺑﺎﺷﺪ ﺑﺎ ﺗﻘﺴﻴﻢ ﻛﺮﻳﺴﺘﺎل ‪ 32768‬ﻫﺮﺗﺰ ﺑﺮ ‪ 128‬ﻣﻲ ﺗﻮان ﺑﻪ زﻣﺎن ﺳﺮرﻳﺰ ‪ 1‬ﺛﺎﻧﻴﻪ ﻛﻪ ﻣﻨﺎﺳﺐ ﺑﺮاي ﻋﻤﻠﻜـﺮد ﺳـﺎﻋﺖ‬

‫اﺳﺖ دﺳﺖ ﭘﻴﺪا ﻛﺮد‪ .‬ﺗﻨﻈﻴﻤﺎت ‪ Prescale‬ﺑﺮاي اﻳﻦ ﺗﺎﻳﻤﺮ ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫‪CS02‬‬ ‫‪CS01‬‬ ‫‪CS00‬‬ ‫وﺿﻌﻴﺖ ﻣﻨﺒﻊ ﻛﻼك ﺗﺎﻳﻤﺮ‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫ﺑﺪون ﻛﻼك )ﻣﺘﻮﻗﻒ(‬

‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫ﻛﻼك ﺳﻴﺴﺘﻢ )ﺑﺪون ﺗﻘﺴﻴﻢ(‬

‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪/8‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪/32‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪/64‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪/128‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪/256‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪/1024‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫ﭘﻴﻜﺮ ﺑﻨﺪي ‪ RTC‬ﺑﺎ رﺟﻴﺴﺘﺮ وﺿﻌﻴﺖ آﺳﻨﻜﺮون ﻳﺎ ‪ ASSR‬اﻧﺠﺎم ﻣﻲ ﺷﻮد‪:‬‬

‫  ‬
‫‪P a g e | 80‬‬
‫‪www.avr.ir‬‬
‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪ASSR‬‬ ‫‪AS0‬‬ ‫‪TCN2UB‬‬ ‫‪OCR2UB‬‬ ‫‪TCR2UB‬‬

‫‪ :Asynchronous Timer/Counter2‬ﺑﺎ ‪ Set‬ﻛﺮدن اﻳﻦ ﺑﻴـﺖ ﻣﻨﺒـﻊ ﻛـﻼك ﺗـﺎﻳﻤﺮ ‪ 2‬از ﻛـﻼك ﺳﻴﺴـﺘﻢ ﺑـﻪ‬

‫ﻛﺮﻳﺴﺘﺎل ﺧﺎرﺟﻲ در ﭘﺎﻳﻪ ﻫﺎي ‪ TOSC1‬و ‪ TOSC2‬ﺗﻐﻴﻴﺮ ﻣﻲ ﻛﻨﺪ‪.‬ﺑﺎ ﺗﻐﻴﻴـﺮ دادن اﻳـﻦ ﺑﻴـﺖ ﻣﻤﻜـﻦ اﺳـﺖ ﻣﻘـﺪار‬

‫رﺟﻴﺴﺘﺮﻫﺎي ‪ OCR2 ،TCNT2‬و ‪ TCCR2‬ﺧﺮاب ﺷﻮد‪.‬‬

‫‪ :Timer/Counter2 Update Busy‬ﺑﺮاي ﺗﻀﻤﻴﻦ ﻋﻤﻠﻜـﺮد ﺻـﺤﻴﺢ در وﺿـﻌﻴﺖ آﺳـﻨﻜﺮون رﺟﻴﺴـﺘﺮﻫﺎي‬

‫ﺗﺎﻳﻤﺮ‪ 2‬ﺑﺮﺧﻼف ﺗﺎﻳﻤﺮ ‪ 0‬و ‪ 1‬ﺑﻪ ﺻﻮرت ﺑﺎﻓﺮ ﺷﺪه ﺑﺮوز ﻣﻴﺸﻮﻧﺪ‪ .‬ﺑﺪﻳﻦ ﺗﺮﺗﻴـﺐ ﻛـﻪ وﻗﺘـﻲ روي رﺟﻴﺴـﺘﺮ ‪TCNT2‬‬

‫ﻣﻘﺪاري ﻧﻮﺷﺘﻪ ﺷﻮد‪ ،‬ﺑﻴﺖ ‪ TCN2UB‬ﻳﻚ ﻣﻲ ﺷـﻮد و ﻣﻘـﺪاري ﻛـﻪ در رﺟﻴﺴـﺘﺮ ﻣـﻮﻗﺘﻲ ذﺧﻴـﺮه ﺷـﺪه اﺳـﺖ ﺑـﻪ‬

‫‪ TCNT2‬ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮد‪ .‬ﺑﺎ اﺗﻤﺎم ﺑﺮوز رﺳﺎﻧﻲ ‪ TCNT2‬اﻳﻦ ﺑﻴﺖ ﺗﻮﺳﻂ ﺳﺨﺖ اﻓﺰار ﺻﻔﺮ ﻣﻲ ﺷﻮد‪ .‬ﺻـﻔﺮ ﺑـﻮدن‬

‫‪ OCR2UB‬ﻧﺸﺎن دﻫﻨﺪه ي آﻣﺎدﮔﻲ ‪ TCNT2‬ﺑﺮاي ﭘﺬﻳﺮﻓﺘﻦ ﻣﻘﺪار ﺟﺪﻳﺪ اﺳﺖ‪.‬‬

‫‪ :Output Compare Register2 Update Busy‬اﻳﻦ ﺑﻴﺖ ﻫﻤﺎﻧﻨﺪ ‪ TCN2UB‬ﺑﻮده ﺑﺎ اﻳﻦ ﺗﻔـﺎوت ﻛـﻪ‬

‫ﺑﺮ روي رﺟﻴﺴﺘﺮ ‪ OCR2‬ﻋﻤﻞ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫‪ :Timer/Counter Control Register2 Update Busy‬اﻳﻦ ﺑﻴﺖ ﻫﻤﺎﻧﻨـﺪ ‪ TCN2UB‬ﺑـﻮده ﺑـﺎ اﻳـﻦ‬

‫ﺗﻔﺎوت ﻛﻪ ﺑﺮ روي رﺟﻴﺴﺘﺮ ‪ TCCR2‬ﻋﻤﻞ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫• در ﺣﺎﻟﺘﻲ ﻛﻪ ﭘﺮﭼﻢ ﻣﺸﻐﻮل ﺑﻮدن ﻳﻚ رﺟﻴﺴﺘﺮ ﻳﻚ ﻣﻲ ﺑﺎﺷﺪ‪ ،‬ﻧﻮﺷﺘﻦ ﺑﺮ روي آن رﺟﻴﺴﺘﺮ ﺑﺎﻋﺚ ﻣﻲ ﺷﻮد ﻛﻪ‬

‫ﻣﻘﺪار ﺑﺮوز ﺷﺪه ﺻﺤﻴﺢ ﻧﺒﺎﺷﺪ و ﻣﻤﻜﻦ اﺳﺖ ﺑﺎﻋﺚ وﻗﻔﻪ ي ﻧﺎﺧﻮاﺳﺘﻪ ﺷﻮد‪.‬‬

‫
 ‬
‫‪P a g e | 81‬‬
‫‪www.avr.ir‬‬
‫• ﻣﻜﺎﻧﻴﺴﻢ ﺧﻮاﻧﺪن اﻳﻦ ﺳﻪ رﺟﻴﺴﺘﺮ ﻣﺘﻔﺎوت ﻣﻲ ﺑﺎﺷﺪ‪ ،‬ﺑﺪﻳﻦ ﺻﻮرت ﻛﻪ زﻣﺎن ﺧﻮاﻧﺪن ‪ TCNT2‬ﻣﻘﺪار ﺧﻮد‬

‫رﺟﻴﺴﺘﺮ ﺧﻮاﻧﺪه ﺷﺪه و ﺑﺎ ﺧﻮاﻧﺪن ‪ OCR2‬و ‪ TCCR2‬ﻣﻘﺪار ﻣﻮﺟﻮد در رﺟﻴﺴﺘﺮ ﻣﻮﻗﺖ ﺧﻮاﻧﺪه ﻣﻲ ﺷﻮد‪.‬‬

‫• ﺗﺎﻳﻤﺮ‪ 2‬در وﺿﻌﻴﺖ آﺳﻨﻜﺮون در ﺣﺎﻟﺖ ‪ Power-Save‬ﻧﻴﺰ ﻓﻌﺎل ﺑـﻮده و ﭘـﺲ از ﺳـﺮرﻳﺰ ﺷـﺪن ﺗـﺎﻳﻤﺮ از‬

‫وﺿﻌﻴﺖ ‪ Power-Save‬ﺧﺎرج ﺷﺪه و در وﺻﺮت ﻓﻌﺎل ﺑﻮدن وﻗﻔﻪ‪ ISR ،‬را اﺟـﺮا ﻧﻤـﻮده و ﻣﺠـﺪدا وارد‬

‫ﺣﺎﻟﺖ ‪ Power-Save‬ﻣﻲ ﺷﻮد‪.‬‬

‫ﭘﺮوژه ‪ :9‬ﺳﺎﻋﺖ ﺑﺎ ‪ RTC‬ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ‬

‫*****************************************************‪/‬‬
‫‪Project : Real Time Clock‬‬
‫‪Author‬‬ ‫‪: Reza Sepas Yar‬‬
‫‪Company : Pishro Noavaran Kavosh‬‬
‫‪*****************************************************/‬‬

‫>‪#include <mega16.h‬‬
‫>‪#include <lcd.h‬‬
‫>‪#include <stdio.h‬‬
‫‪#define xtal 8000000‬‬

‫‪#asm‬‬
‫‪.equ __lcd_port=0x1B ;PORTA‬‬
‫‪#endasm‬‬

‫;‪unsigned char second, minute,hour‬‬

‫;]‪unsigned char lcd_buff[10‬‬

‫  ‬
P a g e | 82
www.avr.ir

interrupt [TIM2_OVF] void timer2_ovf_isr(void)

{
if(second==59)
{
second=0;
if(minute==59)
{
minute=0;
if(hour==23)
hour=0;
else
hour++;
}
else
minute++;
}
else
second++;

sprintf(lcd_buff,"Time = %d:%d:%d",hour, minute,

second);
lcd_clear();
lcd_puts(lcd_buff);
}

void main(void)
{
// Clock source: TOSC1 pin
// Clock value: PCK2/128

  
P a g e | 83
www.avr.ir
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x08;
TCCR2=0x05;
TCNT2=0x00;
OCR2=0x00;
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x40;

lcd_init(16);

#asm("sei") // Global enable interrupts

while (1);
}

  
‫‪P a g e | 84‬‬
‫‪www.avr.ir‬‬

‫ﺗﺎﻳﻤﺮ‪/‬ﻛﺎﻧﺘﺮ ﻳﻚ‬

‫ﺗﺎﻳﻤﺮ ﻳﻚ ﺗﺎﻳﻤﺮي ‪ 16‬ﺑﻴﺘﻲ اﺳﺖ و در آن ﻋﻼوه ﺑﺮ اﻣﻜﺎﻧﺎت ﺗﺎﻳﻤﺮ ﺻﻔﺮ‪ ،‬ﻳﻚ ﺑﺨﺶ دﻳﮕﺮ ﺑﻪ ﻧﺎم ﺑﺨﺶ ‪ Capture‬ﺑﻪ‬

‫آن اﻓﺰوده ﺷﺪه اﺳﺖ‪ .‬اﻳﻦ ﺑﺨﺶ در زﻣﺎن ﻫﺎي ﺧﺎص‪ ،‬ﻋﺪد ﺷﻤﺎرش ﺷﺪه ﺗﻮﺳﻂ ﺗﺎﻳﻤﺮ ﻳﻚ و زﻣـﺎن ﺳـﭙﺮي ﺷـﺪه را‬

‫ﺛﺒﺖ ﻛﺮده و از ﻃﺮﻳﻖ آن اﻣﻜﺎن اﻧﺪازه ﮔﻴﺮي ﻫﺎي زﻣﺎﻧﻲ را ﻓﺮاﻫﻢ ﻣﻲ آورد‪ .‬ﺗﺎﻳﻤﺮ ﻳﻚ داراي ﭘﻨﺞ ‪ Mode‬ﻛـﺎري ﺑـﻪ‬

‫ﻧــﺎم ﻫــﺎي ‪Phase and Mode  Phase Correct PWM Mode Fast PWM ،CTC ،Normal‬‬

‫‪ Frequency Correct‬ﻣﻲ ﺑﺎﺷﺪ‪ Mode .‬ﻫﺎي ‪ PWM‬در ﺗﺎﻳﻤﺮ ‪ 1‬ﺑﺴﻴﺎر ﻣﺘﻨﻮع و داراي ‪ 12‬ﺣﺎﻟﺖ ‪ PWM‬ﻣـﻲ‬

‫ﺑﺎﺷﺪ‪ .‬در اﻳﻦ ﺗﺎﻳﻤﺮ ﭘﻴﻦ ‪ T1‬ﺑﻪ ﻋﻨﻮان ورودي ﻛﺎﻧﺘﺮ و ﭘﻴﻦ ﻫﺎي ‪ OC1A‬و ‪ OC1B‬ﺑﻪ ﻋﻨﻮان ﺧﺮوﺟﻲ ﻣﻘﺎﻳﺴـﻪ ﮔـﺮ‬

‫ﻋﻤﻞ ﻣﻲ ﻛﻨﻨﺪ‪ .‬ﻫﻤﭽﻨﻴﻦ ﭘﻴﻦ ‪ ICP1‬ﺑﺮاي ورودي ﺑﺨﺶ ‪ Capture‬ﺗﺎﻳﻤﺮ ﻳﻚ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﺑﻪ ﻋﻠﺖ ‪ 16‬ﺑﻴﺘﻲ ﺑﻮدن ﺗﺎﻳﻤﺮ‪ ،‬رﺟﻴﺴﺘﺮﻫﺎي ‪ TCNT1‬و ‪ OCR1A‬و ‪ OCR1B‬ﺷﺎﻧﺰده ﺑﻴﺘﻲ ﻣﻲ ﺑﺎﺷﻨﺪ ﻛﻪ ﻫﺮ ﻛﺪام‬

‫داراي دو ﺑﺎﻳﺖ ‪ L‬و ‪ H‬ﻫﺴﺘﻨﺪ‪ .‬ﻫﻤﭽﻨﻴﻦ ﺗﺎﻳﻤﺮ ﻳﻚ داراي دو واﺣﺪ ﻣﻘﺎﻳﺴﻪ ي ﻣﺠﺰا ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﻣﻘـﺪار ﻣﻮﺟـﻮد در‬

‫رﺟﻴﺴﺘﺮﻫﺎي ‪ OCR1A‬و ‪ OCR1B‬را ﺑـﺎ ‪ TCNT1‬ﻣﻘﺎﻳﺴـﻪ ﻛـﺮده و در ﺻـﻮرت ﺑﺮاﺑـﺮي وﺿـﻌﻴﺖ ﭘـﻴﻦ ﻫـﺎي‬

‫‪ OC1A‬و ‪ OC1B‬را ﺗﻐﻴﻴﺮ ﻣﻲ دﻫﻨﺪ‪ .‬ﻫﻤﭽﻨﻴﻦ رﺟﻴﺴﺘﺮ ‪ ICR1‬ﻧﻴﺰ ﻛﻪ رﺟﻴﺴﺘﺮ واﺣﺪ ‪ Capture‬اﺳﺖ رﺟﻴﺴﺘﺮي‬

‫‪ 16‬ﺑﻴﺘﻲ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫
رﺟﻴﺴﺘﺮﻫﺎي ﺷﺎﻧﺰده ﺑﻴﺘﻲ ﺗﺎﻳﻤﺮ‪ OCR1B ،OCR1A ،TCNT1 :1‬و ‪ICR1‬‬

‫  ‬
P a g e | 85
www.avr.ir
:‫ ﻛﻨﺘﺮل ﺗﺎﻳﻤﺮ را ﺑﺮ ﻋﻬﺪه دارﻧﺪ‬TCCR1B ‫ و‬TCCR1A ‫ ﺑﻴﺘﻲ‬8 ‫رﺟﻴﺴﺘﺮﻫﺎي‬

TCCR1A 7 6 5 4 3 2 1 0
‫ﻧﺎم ﺑﻴﺖ‬ COM1A1 COM1A0 COM1B1 COM1B0 FOC1A FOC1B WGM11 WGM10

TCCR1B 7 6 5 4 3 2 1 0
‫ﻧﺎم ﺑﻴﺖ‬ ICNC1 ICES1 - WGM13 WGM12 CS12 CS11 CS10

:‫ ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‬WGM13 ‫ و‬WGM12 ,WGM11 ,WGM10 ‫ ﻛﺎري ﺗﺎﻳﻤﺮ ﺑﻮﺳﻴﻠﻪ ي ﺑﻴﺖ ﻫﺎي‬Mode

WGM13 WGM12 WGM11 WGM10 ‫ ﻛﺎري‬Mode TOP TOV=1

0 0 0 0 0 Normal 0xFFFF 0xFFFF

1 0 0 0 1 PWM, Phase Correct, 8-bit 0x00FF 0

2 0 0 1 0 PWM, Phase Correct, 9-bit 0x01FF 0

3 0 0 1 1 PWM, Phase Correct, 10-bit 0x03FF 0

4 0 1 0 0 CTC OCR1A 0xFFFF

5 0 1 0 1 Fast PWM, 8-bit 0x00FF TOP

6 0 1 1 0 Fast PWM, 9-bit 0x01FF TOP

7 0 1 1 1 Fast PWM, 10-bit 0x03FF TOP

8 1 0 0 0 PWM, Phase and Frequency Correct ICR1 0

9 1 0 0 1 PWM, Phase and Frequency Correct OCR1A 0

10 1 0 1 0 PWM, Phase Correct ICR1 0

11 1 0 1 1 PWM, Phase Correct OCR1A 0

12 1 1 0 0 CTC ICR1 0xFFFF

13 1 1 0 1 ‫رزرو ﺷﺪه‬  

14 1 1 1 0 Fast PWM ICR1 TOP

  
‫‪P a g e | 86‬‬
‫‪www.avr.ir‬‬
‫‪15‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪Fast PWM‬‬ ‫‪OCR1A‬‬ ‫‪TOP‬‬

‫• ﺗﻌﺮﻳﻒ ‪ :TOP‬ﺗﺎﻳﻤﺮ وﻗﺘﻲ ﺑﻪ ﻣﻘﺪار ‪ TOP‬ﻣﻲ رﺳﺪ ﻛﻪ ﺑﺮاﺑﺮ ﺑﺎ ﺑﺎﻻﺗﺮﻳﻦ ﻣﻘﺪار در رﺷﺘﻪ ي ﺷـﻤﺎرش ﺧـﻮد‬

‫اﺳﺖ‪ .‬اﻳﻦ ﻣﻘﺪار ﻣﻲ ﺗﻮاﻧﺪ ﻣﻘﺎدﻳﺮ ﺛﺎﺑﺘﻲ ﻣﺜﻞ‪ 0x01FF ,0x03FF‬و ﻳﺎ ‪ 0x00FF‬ﺑﻮده و ﻳﺎ ﻣﻘﺪار ﻧﮕﻬﺪاري‬

‫ﺷﺪه در ﻳﻜﻲ از رﺟﻴﺴﺘﺮﻫﺎي ‪ OCR1A‬ﻳﺎ ‪ ICR1‬ﺑﺎﺷﺪ‪.‬‬

‫‪ FOC1A‬و ‪ :FOC1B‬ﺑﻴﺖ ﻫﺎي ‪ Force‬ﺑﺨﺶ ﻣﻘﺎﻳﺴﻪ ﮔﺮ ﻛﻪ ﻋﻤﻠﻜﺮد آن ﻫﺎ ﻫﻤﺎﻧﻨﺪ ‪ FOC0‬در ﺗﺎﻳﻤﺮ ﺻـﻔﺮ و‬

‫دو ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﺑﻪ اﻳﻦ ﺗﺮﺗﻴﺐ ﻛﻪ در ‪ Mode‬ﻫﺎي ﻏﻴﺮ ‪ ،PWM‬ﻳﻚ ﻛﺮدن اﻳﻦ ﺑﻴﺖ ﺑﺪون اﻳﻨﻜﻪ وﻗﻔﻪ اي اﻳﺠﺎد ﻛﻨﺪ در‬

‫ﺻﻮرت ﺗﻄﺒﻴﻖ ﻣﻘﺎﻳﺴﻪ‪ ،‬ﺑﺎﻋﺚ ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ ﭘﻴﻦ ﻫﺎي ‪ OC1A‬و ‪ OC1B‬ﻣﻄﺎﺑﻖ ﺑﺎ وﺿﻌﻴﺖ ﺑﻴﺖ ﻫـﺎي ‪ COM‬در‬

‫‪ TCCR1‬ﻣﻲ ﺷﻮد‪.‬‬

‫ﺑﻴﺖ ﻫﺎي ‪ COM1B0 ,COM1A1 ,COM1A0‬و ‪ :COM1B1‬ﺗﻐﻴﻴـﺮ وﺿـﻌﻴﺖ ﭘـﻴﻦ ﻫـﺎي ‪ OC1A‬و‬

‫‪ OC1B‬را در ﺣﺎﻟﺖ ﺗﻄﺒﻴﻖ ﻣﻌﻴﻦ ﻣﻲ ﻛﻨﻨﺪ ﻛﻪ ﻣﻘﺪار آن ﻫﺎ ﺑﺴﺘﻪ ﺑﻪ ‪ Mode‬ﻛﺎري ﻋﻤﻠﻜـﺮد ﻣﺘﻔـﺎوﺗﻲ را اﻳﺠـﺎد ﻣـﻲ‬

‫ﻛﻨﺪ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ در ﺑﺮرﺳﻲ ‪ Mode‬ﻫﺎي ﻣﺨﺘﻠﻒ آن را ﻣﻄﺎﻟﻌﻪ ﺧﻮاﻫﻴﻢ ﻛﺮد‪.‬‬

‫ﺑﻴﺖ ﻫﺎي ‪ CS11 ،CS10‬و ‪ :CS12‬ﺑﺮاي ﺗﻌﻴﻴﻦ ﻣﻨﺒﻊ ﻛﻼك ﺗﺎﻳﻤﺮ ﻣﻲ ﺑﺎﺷﻨﺪ‪:‬‬

‫‪CS02‬‬ ‫‪CS01‬‬ ‫‪CS00‬‬ ‫وﺿﻌﻴﺖ ﻣﻨﺒﻊ ﻛﻼك ﺗﺎﻳﻤﺮ‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫ﺑﺪون ﻛﻼك )ﻣﺘﻮﻗﻒ(‬

‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫ﻛﻼك ﺳﻴﺴﺘﻢ )ﺑﺪون ﺗﻘﺴﻴﻢ(‬

‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪/8‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫  ‬
‫‪P a g e | 87‬‬
‫‪www.avr.ir‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪/64‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪/256‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪/1024‬ﻛﻼك ﺳﻴﺴﺘﻢ‬

‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧﺪه ي ﭘﺎﻟﺲ ﺧﺎرﺟﻲ )‪(T1‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه ي ﭘﺎﻟﺲ ﺧﺎرﺟﻲ )‪(T1‬‬

‫ﺑﻴﺖ ‪ :ICES1‬ﺑﻴﺖ ﺗﻌﻴﻴﻦ ﻟﺒﻪ ي ورودي ﺑﺨﺶ ‪ Capture‬از ﭘﻴﻦ ‪ .ICP1‬ﺑﺎ ﺻﻔﺮ ﺑﻮدن اﻳﻦ ﺑﻴﺖ ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧﺪه‬

‫و ﺑﺎ ﻳﻚ ﺑﻮدن آن ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه ﺑﺎﻋﺚ ﺗﺮﻳﮕﺮ ﻣﻲ ﺷﻮد‪.‬‬

‫ﺑﻴﺖ ‪ :ICNC1‬ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﺣﺬف ﻧﻮﻳﺰ در ورودي ﭘﻴﻦ ‪ICP1‬‬

‫ﻧﺘﺎﻳﺞ ﺣﺎﺻﻞ از ﻛﺎرﻛﺮد ﺗﺎﻳﻤﺮ‪ 1‬در ‪ 4‬ﺑﻴﺖ از رﺟﻴﺴﺘﺮ ‪ TIFR‬ﺑﻪ ﻧﺎم ﻫﺎي ‪) TOV1‬ﭘﺮﭼﻢ ﺳﺮرﻳﺰ( ‪) OCF1A‬ﭘﺮﭼﻢ‬

‫ﺗﻄﺎﺑﻖ ﻣﻘﺎﻳﺴﻪ ﮔﺮ ‪) OCF1B (A‬ﭘﺮﭼﻢ ﺗﻄﺎﺑﻖ ﻣﻘﺎﻳﺴﻪ ﮔﺮ ‪ (B‬و ‪) ICF1‬ﭘﺮﭼﻢ ﺑﺨﺶ ‪ Capture‬ﺗﺎﻳﻤﺮ‪ (1‬ﻣـﻨﻌﻜﺲ‬

‫ﻣﻲ ﺷﻮﻧﺪ‪:‬‬

‫‪TIFR‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪OCF2‬‬ ‫‪TOV2‬‬ ‫‪ICF1‬‬ ‫‪OCF1A‬‬ ‫‪OCF1B‬‬ ‫‪TOV1‬‬ ‫‪OCF0‬‬ ‫‪TOV0‬‬

‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪0‬‬ ‫‪0‬‬

‫ﻳﻚ ﺷﺪن ﻫﺮ ﻳﻚ از اﻳﻦ ﭘﺮﭼﻢ ﻫﺎ در ﺻﻮرت ﻓﻌﺎل ﺑﻮدن ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﻋﻤﻮﻣﻲ )‪ (I‬و ﻓﻌﺎل ﺑﻮدن وﻗﻔﻪ ي ﻣﺮﺑﻮﻃﻪ‬

‫در رﺟﻴﺴﺘﺮ ‪ TIMSK‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎﻋﺚ اﻧﺸﻌﺎب ﺑﺮﻧﺎﻣﻪ ﺑﻪ ‪ ISR‬ﻣﺮﺑﻮط ﺑﻪ آن وﻗﻔﻪ ﺷﻮد‪:‬‬

‫  ‬
‫‪P a g e | 88‬‬
‫‪www.avr.ir‬‬

‫‪TIMSK‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪OCIE2‬‬ ‫‪TOIE2‬‬ ‫‪TICIE1‬‬ ‫‪OCIE1A‬‬ ‫‪OCIE1B‬‬ ‫‪TOIE1‬‬ ‫‪OCIE0‬‬ ‫‪TOIE0‬‬

‫ﺳﻄﺢ ﻣﻨﻄﻘﻲ‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪0‬‬ ‫‪0‬‬

‫ﺑﺎ اﺟﺮا ﺷﺪن ‪ ISR‬ﺑﻪ ﺻﻮرت ﺧﻮدﻛﺎر ﺑﻴﺖ ﭘﺮﭼﻢ وﻗﻔﻪ ﺻﻔﺮ ﺷﺪه و ﻳﺎ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ روي آن ﺑﻮﺳﻴﻠﻪ ي‬

‫ﻧﺮم اﻓﺰار آن را ﭘﺎك ﻛﺮد‪.‬‬

‫ ‪Normal Mode‬‬

‫اﻳﻦ ‪ Mode‬ﻫﻤﺎﻧﻨﺪ ﻣﺸﺎﺑﻪ آن در ﺗﺎﻳﻤﺮ ﺻﻔﺮ ﻣﻲ ﺑﺎﺷﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ ﺗﺎﻳﻤﺮ ﺗﺎ ﻋﺪد ‪ 0xFFFF‬ﺷﻤﺎرش ﻛﺮده و ﺑـﺎ‬

‫رﺳﻴﺪن ﺑﻪ آن ﺗﺎﻳﻤﺮ ﺳﺮرﻳﺰ ﻛﺮده و ﺑﻴﺖ ‪ TOV1‬ﻳﻚ ﺷﺪه و در ﺻﻮرت ﻓﻌﺎل ﺑﻮدن وﻗﻔﻪ ﻣـﻲ ﺗﻮاﻧـﺪ ﺑﺎﻋـﺚ اﺟـﺮاي‬

‫‪ ISR‬ﻣﺮﺑﻮﻃﻪ ﺷﻮد‪ .‬در ‪ Mode‬ﻋﺎدي ﻫﺮ دو ﻣﻘﺎﻳﺴﻪ ﮔﺮ ‪ A‬و ‪ B‬ﻓﻌﺎل ﺑﻮده و ﻫﺮ ﻛﺪام ﺑﻪ ﻃﻮر ﻣﺴﺘﻘﻞ ﻋﻤﻞ ﻣﻘﺎﻳﺴـﻪ‬

‫را روي رﺟﻴﺴﺘﺮ ‪ TCNT1‬و ‪ OCR1A‬و ‪ OCR1B‬اﻧﺠﺎم ﻣﻲ دﻫﻨـﺪ‪ .‬در ﺻـﻮرت ﺑﺮاﺑـﺮي ﺑﻴـﺖ ‪ OCF1A‬ﻳـﺎ‬

‫‪ OCF1B‬ﻳﻚ ﺷﺪه و ﺧﺮوﺟﻲ ‪ OC1A‬ﻳﺎ ‪ OC1B‬ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ داده و در ﺻﻮرت ﻓﻌﺎل ﺑﻮدن‬

‫وﻗﻔﻪ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﺷﻮﻧﺪ‪.‬‬

‫  ‬
‫‪P a g e | 89‬‬
‫‪www.avr.ir‬‬

‫‪COM1A1/COM1B1‬‬ ‫‪COM1A0/COM1B0‬‬ ‫وﺿﻌﻴﺖ ﭘﻴﻦ ‪ OC1A‬ﻳﺎ ‪OC1B‬‬

‫‪0‬‬ ‫‪0‬‬ ‫ﻏﻴﺮ ﻓﻌﺎل )‪ I/O‬ﻣﻌﻤﻮﻟﻲ(‬

‫‪0‬‬ ‫‪1‬‬ ‫‪ Toggle‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‬

‫‪1‬‬ ‫‪0‬‬ ‫‪ Clear‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‬

‫‪1‬‬ ‫‪1‬‬ ‫‪ Set‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ‬

‫• در ﺻﻮرت اﺳﺘﻔﺎده از ‪ OC1A‬ﻳﺎ ‪ OC1B‬ﺑﺮاي ﺗﻮﻟﻴﺪ ﺷﻜﻞ ﻣﻮج‪ ،‬ﺑﺎﻳﺪ اﻳﻦ ﭘﻴﻦ ﻫﺎ ﺑﻪ ﺻﻮرت ﺧﺮوﺟﻲ‬

‫ﭘﻴﻜﺮﺑﻨﺪي ﺷﻮﻧﺪ‪.‬‬

‫ﻣﺜﺎل ‪) :7‬ﺗﻮﻟﻴﺪ دو ﺷﻜﻞ ﻣﻮج ﺑﺎ دوره ﺗﻨﺎوب ‪ 131‬ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ و اﺧﺘﻼف ﻓﺎز ‪ 10‬ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ(‬

‫>‪#include <mega16.h‬‬
‫‪#define xtal 8000000‬‬

‫)‪void main(void‬‬
‫{‬

‫;‪PORTD=0x00‬‬
‫;‪DDRD=0x30‬‬

‫‪// Mode: Normal top=FFFFh‬‬

‫;‪TCCR1A=0x50‬‬ ‫‪//toggle OC1A & OC1B‬‬
‫;‪TCCR1B=0x02‬‬ ‫‪//Clock/8‬‬
‫;‪OCR1AH=0x00‬‬
‫;‪OCR1AL=0xFF‬‬ ‫‪//OCR1A=255‬‬

‫  ‬
‫‪P a g e | 90‬‬
‫‪www.avr.ir‬‬
‫;‪OCR1BH=0x28‬‬
‫;‪OCR1BL=0x0F‬‬ ‫‪//OCR1B=10255‬‬

‫;)‪while (1‬‬

‫}‬

‫‪T = 2 × 216 × 1µs = 131072µs = 131ms‬‬

‫‪ = OCR1B − OCR1A = 10255 − 255 = 10000µs = 10ms‬اﺧﺘﻼف ﻓﺎز‬

‫ ‪CTC Mode‬‬

‫در اﻳﻦ ﺣﺎﻟﺖ ﻣﻘﺪار رﺟﻴﺴﺘﺮ ‪ TCNT1‬ﺑﻪ ﻃﻮر ﭘﻴﻮﺳﺘﻪ ﺑﺎ ﻣﻘﺪار رﺟﻴﺴﺘﺮ ‪ OCR1A‬ﻳﺎ ‪ ICR1‬ﻣﻘﺎﻳﺴﻪ ﻣـﻲ ﺷـﻮد و‬

‫در ﺻﻮرت ﺑﺮاﺑﺮي ﻣﻘﺪار رﺟﻴﺴﺘﺮ ‪ TCNT1‬ﺑﺮاﺑﺮ ﺻﻔﺮ ﻣﻲ ﺷﻮد‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ در اﻳﻦ ﺣﺎﻟﺖ ﻣﻘـﺪار ‪ TOP‬ﺗـﺎﻳﻤﺮ را ﺑـﺎ‬

‫ﺗﻮﺟﻪ ﺑﻪ ﻣﻘﺪار ﻣﻮﺟﻮد در ﺑﻴﺖ ﻫﺎي ‪ WGM‬ﻣﻘﺪار رﺟﻴﺴﺘﺮﻫﺎي ‪ OCR1A‬ﻳﺎ ‪ ICR1‬ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨﺪ‪.‬‬

‫ﺑﺎ رﺳﻴﺪن ﺗﺎﻳﻤﺮ ﺑﻪ ﻣﻘﺪار ‪ TOP‬ﺧﻮد ﺑﺮ ﺣﺴﺐ اﻳﻨﻜﻪ ﻣﻘﺪار ﻣﺎﻛﺰﻳﻤﻢ ‪ OCR1A‬ﻳﺎ ‪ ICR1‬اﻧﺘﺨﺎب ﺷﺪه ﺑﺎﺷـﺪ ﺑـﻪ‬

‫ﺗﺮﺗﻴﺐ ﭘﺮﭼﻢ ﻫﺎي ‪ OCF1A‬ﻳﺎ ‪ ICF1‬ﻳﻚ ﺷﺪه و در ﺻﻮرت ﻓﻌﺎل ﺑﻮدن وﻗﻔﻪ از آن ﻣـﻲ ﺗـﻮان ﺑـﺮاي ﺗﻐﻴﻴـﺮ دادن‬

‫ﻣﻘﺪار ﻣﻘﺎﻳﺴﻪ اﺳﺘﻔﺎده ﻛﺮد‪ .‬اﻳﻦ ﻋﻤﻞ ﺑﺎﻳﺪ ﺑﺎ دﻗﺖ ﺻﻮرت ﮔﻴﺮد زﻳﺮا رﺟﻴﺴـﺘﺮ ﻣﻘﺎﻳﺴـﻪ ي ﺗﺎﻳﻤﺮﻫـﺎ ﻓﻘـﻂ در ‪Mode‬‬

‫ﻫﺎي ‪ PWM‬داراي ﺑﺎﻓﺮ دوﺑﻞ ﻣﻲ ﺑﺎﺷﻨﺪ‪ .‬در اﻳﻦ ﺣﺎﻟﺖ ﻓﺮﻛـﺎﻧﺲ ﻣـﻮج اﻳﺠـﺎد ﺷـﺪه روي ﭘﺎﻳـﻪ ﻫـﺎي ‪ OC1A‬ﻳـﺎ‬

‫‪ OC1B‬ﻣﻄﺎﺑﻖ راﺑﻄﻪ ي زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫‪f CLK _ I / O‬‬

‫= ‪f OC1x‬‬
‫)‪2.N .(1 + OCR1A‬‬

‫
 ‬
P a g e | 91
www.avr.ir

(OC1A ‫ ﻛﻴﻠﻮﻫﺮﺗﺰ روي ﭘﺎﻳﻪ ي‬1 ‫ )ﺗﻮﻟﻴﺪ ﻣﻮج ﻣﺮﺑﻌﻲ ﺑﺎ ﻓﺮﻛﺎﻧﺲ‬:8‫ﻣﺜﺎل‬

#include <mega16.h>
#define xtal 8000000

void main(void)
{

PORTD=0x00;
DDRD=0x30;

// Mode: CTC top=01F3h

TCCR1A=0x40;
TCCR1B=0x0A;
OCR1AH=0x01;
OCR1AL=0xF3; //OCR1A=499

while (1);
}

8000000
f= = 1000 = 1KHz
2 × 8(1 + 499)

  
‫‪P a g e | 92‬‬
‫‪www.avr.ir‬‬

‫ ‪Fast PWM Mode‬‬

‫ﺑﺮ ﺧﻼف ﺗﺎﻳﻤﺮﻫﺎي ﺻﻔﺮ و دو ﻛﻪ در آن ﻣﻮج ﻫﺎي ‪ PWM‬ﺗﻮﻟﻴﺪ ﺷﺪه داراي دﻗﺖ ﺛﺎﺑﺖ ‪ 8‬ﺑﻴﺘـﻲ ﻫﺴـﺘﻨﺪ‪ ،‬ﺗـﺎﻳﻤﺮ ‪1‬‬

‫ﻗﺎدر اﺳﺖ ﺳﻴﮕﻨﺎل ﻫﺎي ‪ PWM‬اي ﺑﺎ دﻗﺖ ﻣﺘﻐﻴﺮ را اراﺋﻪ ﻛﻨﺪ‪ ،‬اﻳﻦ ﻣﺴﺌﻠﻪ ﺑﺎﻋﺚ ﻣﻲ ﺷﻮد ﻛﻪ ﻛﺎرﺑﺮ ﺑﺘﻮاﻧﺪ ﻋـﻼوه ﺑـﺮ‬

‫ﺗﻐﻴﻴﺮ ‪ Duty Cycle‬ﻓﺮﻛﺎﻧﺲ ﻣﻮج را ﺑﻪ ﺻﻮرت ﺳﺨﺖ اﻓﺰاري ﻛﻨﺘﺮل ﻛﻨﺪ )ﺑﺪون ﻣﻘﺪار اوﻟﻴﻪ دادن ﺑﻪ ‪(TCNT1‬‬

‫‪ PWM‬ﺳﺮﻳﻊ داراي ﭘﻨﺞ ‪ Mode‬ﻣﻲ ﺑﺎﺷﺪ‪(WGM1[3:0] = 15 ،14 ،7 ،6 ،5) :‬‬

‫‪ PWM‬ﺳﺮﻳﻊ ‪ 8‬ﺑﻴﺘﻲ )‪(0xFF = TOP‬‬ ‫‪.1‬‬

‫‪ PWM‬ﺳﺮﻳﻊ ‪ 9‬ﺑﻴﺘﻲ )‪(0x1FF = TOP‬‬ ‫‪.2‬‬

‫‪ PWM‬ﺳﺮﻳﻊ ‪ 10‬ﺑﻴﺘﻲ )‪(0x03FF = TOP‬‬ ‫‪.3‬‬

‫‪ PWM‬ﺳﺮﻳﻊ ﺑﺎ ‪ICR1 = TOP‬‬ ‫‪.4‬‬

‫‪ PWM‬ﺳﺮﻳﻊ ﺑﺎ ‪OCR1A = TOP‬‬ ‫‪.5‬‬

‫در اﻳﻦ ‪ Mode‬ﺗﺎﻳﻤﺮ از ﺻﻔﺮ ﺗﺎ ﻣﻘﺪار ‪ TOP‬ﺧﻮد ﺷﺮوع ﺑﻪ ﺷﻤﺎرش ﻛﺮده و ﭘﺲ از از ﺳﺮرﻳﺰ ﻣﺠﺪدا از ﺻﻔﺮ ﺷﺮوع‬

‫ﺑﻪ ﻛﺎر ﻣﻲ ﻛﻨﺪ‪ .‬در ﺻﻮرﺗﻲ ﻛﻪ ﻣﻘﺎﻳﺴﻪ ي ﺧﺮوﺟﻲ در ﺣﺎﻟﺖ ‪ PWM‬ﻏﻴﺮ ﻣﻌﻜﻮس ﺑﺎﺷﺪ در ﺣﺎﻟـﺖ ﺗﻄﺒﻴـﻖ ﻣﻘﺎﻳﺴـﻪ‬

‫ﭘﻴﻦ ‪ OC1x‬ﻳﻚ ﺷﺪه و ﺑﺎ رﺳﻴﺪن ﺑﻪ ﻣﻘﺪار ‪ TOP‬ﭘﺎك ﻣﻲ ﺷﻮد‪ .‬در‬ ‫ﺑﻴﻦ رﺟﻴﺴﺘﺮﻫﺎي ‪ TCNT1‬و ‪OCR1x‬‬

‫ﺻﻮرﺗﻲ ﻛﻪ ﺧﺮوﺟﻲ ‪ PWM‬ﻣﻌﻜﻮس ﺑﺎﺷﺪ وﺿﻌﻴﺘﻲ ﻋﻜﺲ وﺟﻮد ﺧﻮاﻫﺪ داﺷﺖ‪ .‬دﻗﺖ ﻣﻮج ‪ PWM‬ﺧﺮوﺟﻲ ﻣﻲ‬

‫ﺗﻮاﻧﺪ ﻣﻘﺎدﻳﺮ ﺛﺎﺑﺖ ‪ 9 ،8‬ﻳﺎ ‪ 10‬ﺑﻴﺘﻲ داﺷﺘﻪ وﻳﺎ ﺑﻮﺳﻴﻠﻪ ي رﺟﻴﺴﺘﺮﻫﺎي ‪ ICR1‬ﻳﺎ ‪ OCR1A‬ﺑﻪ ﻣﻘﺪار دﻟﺨـﻮاه ﺗﻨﻈـﻴﻢ‬

‫  ‬
‫‪P a g e | 93‬‬
‫‪www.avr.ir‬‬
‫ﺷﻮد‪ .‬در اﻳﻦ ﺣﺎﻟﺖ ﺣﺪاﻗﻞ ﻣﻘﺪار ﻣﺠﺎز ‪ 2‬ﺑﻴﺖ )ﺑﺎ دادن ﻣﻘﺪار ‪ 0x0003‬ﺑﻪ رﺟﻴﺴﺘﺮﻫﺎي ‪ ICR1‬ﻳـﺎ ‪ (OCR1x‬و‬

‫ﺣﺪاﻛﺜﺮ آن ‪ 16‬ﺑﻴﺖ ﻣﻲ ﺑﺎﺷﺪ )ﺑﺎ دادن ﻣﻘﺪار ‪ 0xFFFF‬ﺑﻪ رﺟﻴﺴﺘﺮﻫﺎي ‪ ICR1‬ﻳﺎ ‪.(OCR1x‬‬

‫دﻗﺖ ﻣﻮج ‪ PWM‬ﺑﺮ ﺣﺴﺐ ﻣﻘﺪار ﻣﺎﻛﺰﻳﻤﻢ از راﺑﻄﻪ ي زﻳﺮ ﺑﻪ دﺳﺖ ﻣﻲ آﻳﺪ‪:‬‬

‫)‪log(TOP + 1‬‬
‫= ‪resolution‬‬
‫)‪log(2‬‬

‫ﺑﺎ رﺳﻴﺪن ﺗﺎﻳﻤﺮ ﺑﻪ ﻣﻘﺪار ‪ TOP‬ﭘﺮﭼﻢ ﺳـﺮرﻳﺰ ‪ TOV1‬ﻓﻌـﺎل ﺷـﺪه و ﺑـﺎ ﺗﻄﺒﻴـﻖ ﻣﻘﺎﻳﺴـﻪ ﻧﻴـﺰ ﺑﻴـﺖ ‪ OCF1A‬ﻳـﺎ‬

‫‪ OCF1B‬ﻳﻚ ﻣﻲ ﺷﻮد‪ .‬در اﻳﻦ ﺣﺎﻟﺖ ﻫﺎ اﮔﺮ وﻗﻔﻪ ي ﻣﺮﺑﻮﻃﻪ ﻓﻌﺎل ﺷﺪه ﺑﺎﺷﺪ ﻣﻲ ﺗـﻮان در ‪ ISR‬آن وﻗﻔـﻪ ﻣﻘـﺪار‬

‫ﻣﻘﺎﻳﺴﻪ را ﺗﻐﻴﻴﺮ داد‪ .‬ﺑﺎﻳﺪ ﺗﻮﺟﻪ داﺷﺖ ﻛﻪ ﻣﻘـﺪار رﺟﻴﺴـﺘﺮﻫﺎي ﻣﻘﺎﻳﺴـﻪ ﺑﺎﻳـﺪ از ﻣﻘـﺪار ‪ TOP‬ﻛﻤﺘـﺮ ﺑﺎﺷـﺪ در ﻏﻴـﺮ‬

‫اﻳﻨﺼﻮرت ﻫﻴﭽﮕﺎه ﻣﻘﺎﻳﺴﻪ اي ﺻﻮرت ﻧﻤﻲ ﮔﻴﺮد‪.‬‬

‫ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ ﭘﻴﻦ ﻫﺎي ‪ OC1A‬و ‪ OC1B‬در ﺣﺎﻟﺖ ﺗﻄﺒﻴﻖ ﻣﻘﺎﻳﺴﻪ و ﺳﺮرﻳﺰ ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬

‫‪COM1A1‬‬ ‫‪COM1A0‬‬
‫وﺿﻌﻴﺖ ﭘﻴﻦ ‪ OC1A‬ﻳﺎ ‪OC1B‬‬
‫‪/COM1B1‬‬ ‫‪/COM1B0‬‬

‫‪0‬‬ ‫‪0‬‬ ‫ﻏﻴﺮ ﻓﻌﺎل )‪ I/O‬ﻣﻌﻤﻮﻟﻲ(‬

‫اﮔﺮ ‪ WGM1[3:0] = 15‬ﺑﺎﺷﺪ‪ Toggle :‬ﭘﻴﻦ ‪ OC1A‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ و ‪ OC1B‬ﭘﻴﻦ ‪ I/O‬ﻣﻌﻤﻮﻟﻲ‬
‫‪0‬‬ ‫‪1‬‬
‫ﺑﺮاي دﻳﮕﺮ ﺣﺎﻟﺖ ﻫﺎي ]‪ :WGM1[3:0‬ﻏﻴﺮ ﻓﻌﺎل )‪ I/O‬ﻣﻌﻤﻮﻟﻲ(‬

‫‪1‬‬ ‫‪0‬‬ ‫‪ Clear‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ و ‪ Set‬در وﺿﻌﻴﺖ ‪ PWM) TOP‬ﻏﻴﺮ ﻣﻌﻜﻮس(‬

‫‪1‬‬ ‫‪1‬‬ ‫‪ Set‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ و ‪ Clear‬در وﺿﻌﻴﺖ ‪ PWM) TOP‬ﻣﻌﻜﻮس(‬

‫  ‬
P a g e | 94
www.avr.ir
:‫ ﺣﺎﺻﻞ از راﺑﻄﻪ ي زﻳﺮ ﺑﺪﺳﺖ ﻣﻲ آﻳﺪ‬PWM ‫ﻓﺮﻛﺎﻧﺲ ﻣﻮج‬

f Clk _ I / O
f PWM =
N.(1 + TOP )

(‫ درﺻﺪ‬25 ‫ ﻛﻴﻠﻮ ﻫﺮﺗﺰ و زﻣﺎن وﻇﻴﻔﻪ ي‬1 ‫ ﺑﺎ ﻓﺮﻛﺎﻧﺲ‬PWM ‫ )ﻣﻮج‬:9‫ﻣﺜﺎل‬

#include <mega16.h>
#define xtal 8000000

void main(void)
{

PORTD=0x00;
DDRD=0x20;

// Mode: Fast PWM top=03FFh

// OC1A output: Non-Inv.
// OC1B output: Disconnected
TCCR1A=0x83;
TCCR1B=0x0A; //10 Bit PWM
OCR1AH=0x00;
OCR1AL=0xFF;

while (1);
}

8000000 256
f PWM = = 976 ≈ 1KHz DutyCycle = × 100% = 25%
8.(1 + 1023 ) 1024

  
P a g e | 95
www.avr.ir

:‫ ﻛﻴﻠﻮﻫﺮﺗﺰ رﺳﻴﺪ‬1 ‫ ﻣﻲ ﺗﻮان ﺑﻪ ﻓﺮﻛﺎﻧﺲ دﻗﻴﻖ‬،‫ ﺳﺮرﻳﺰ ﺗﺎﻳﻤﺮ‬ISR ‫ در‬TCNT1 ‫• ﺑﺎ ﻣﻘﺪار اوﻟﻴﻪ دادن ﺑﻪ‬

interrupt [TIM1_OVF] void timer1_ovf_isr(void)

{
TCNT1=24;
}

TIMSK=0x04; //Enable TOV1

#asm("sei") //Enable Interrupts

Phase Correct Mode 

(WGM1[3:0] = 11 ،10 ،3 ،2 ،1) :‫ ﻛﺎري ﻣﻲ ﺑﺎﺷﺪ‬Mode ‫ ﺗﺼﺤﻴﺢ ﻓﺎز داراي ﭘﻨﺞ‬PWM

(0xFF = TOP) ‫ ﺑﻴﺘﻲ‬8 ‫ ﺗﺼﺤﻴﺢ ﻓﺎز‬PWM .1

(0x1FF = TOP) ‫ ﺑﻴﺘﻲ‬9 ‫ ﺗﺼﺤﻴﺢ ﻓﺎز‬PWM .2

(0x03FF = TOP) ‫ ﺑﻴﺘﻲ‬10 ‫ ﺗﺼﺤﻴﺢ ﻓﺎز‬PWM .3

ICR1 = TOP ‫ ﺗﺼﺤﻴﺢ ﻓﺎز ﺑﺎ‬PWM .4

OCR1A = TOP ‫ ﺗﺼﺤﻴﺢ ﻓﺎز ﺑﺎ‬PWM .5

  
‫‪P a g e | 96‬‬
‫‪www.avr.ir‬‬
‫در اﻳﻦ ‪ Mode‬ﺗﺎﻳﻤﺮ ﺑﻪ ﻃﻮر ﭘﻴﻮﺳﺘﻪ از ﻣﻘﺪار ﺻﻔﺮ ﺗﺎ ‪ TOP‬و از ‪ TOP‬ﺗﺎ ﺻﻔﺮ ﻣﻲ ﺷﻤﺎرد‪ .‬در ﺣﺎﻟﺖ ‪ PWM‬ﻏﻴﺮ‬

‫ﻣﻌﻜﻮس در ﺣﺎﻟﻲ ﻛـﻪ ﺗـﺎﻳﻤﺮ ﺑـﻪ ﺻـﻮرت ﺻـﻌﻮدي ﻣـﻲ ﺷـﻤﺎرد در ﻟﺤﻈـﻪ ي ﺑﺮاﺑـﺮي رﺟﻴﺴـﺘﺮﻫﺎي ‪ TCNT1‬و‬

‫‪ OCR1x‬ﭘﻴﻦ ‪ OC1x‬ﺻﻔﺮ ﺷﺪه و در ﺣﺎﻟﺖ ﺷﻤﺎرش ﻧﺰوﻟﻲ ﺑﺎ ﺗﻄﺎﺑﻖ دو رﺟﻴﺴﺘﺮ اﻳﻦ ﭘﻴﻦ ﻳﻚ ﻣﻲ ﺷﻮد‪ .‬در ﺣﺎﻟﺖ‬

‫‪ PWM‬ﻣﻌﻜﻮس‪ ،‬ﻋﻜﺲ اﻳﻦ ﻗﻀﻴﻪ ﺑﺮﻗﺮار اﺳﺖ‪.‬‬

‫دﻗﺖ ﻣﻮج ‪ PWM‬ﺧﺮوﺟﻲ ﻣﻲ ﺗﻮاﻧﺪ ﻣﻘﺎدﻳﺮ ﺛﺎﺑﺖ ‪ 9 ،8‬ﻳﺎ ‪ 10‬ﺑﻴﺘﻲ داﺷﺘﻪ وﻳـﺎ ﺑﻮﺳـﻴﻠﻪ ي رﺟﻴﺴـﺘﺮﻫﺎي ‪ ICR1‬ﻳـﺎ‬

‫‪ OCR1A‬ﺑﻪ ﻣﻘﺪار دﻟﺨﻮاه ﺗﻨﻈﻴﻢ ﺷﻮد‪ .‬در اﻳﻦ ﺣﺎﻟﺖ ﺣﺪاﻗﻞ ﻣﻘﺪار ﻣﺠـﺎز ‪ 2‬ﺑﻴـﺖ )ﺑـﺎ دادن ﻣﻘـﺪار ‪ 0x0003‬ﺑـﻪ‬

‫رﺟﻴﺴﺘﺮﻫﺎي ‪ ICR1‬ﻳﺎ ‪ (OCR1x‬و ﺣﺪاﻛﺜﺮ آن ‪ 16‬ﺑﻴﺖ ﻣﻲ ﺑﺎﺷﺪ )ﺑﺎ دادن ﻣﻘﺪار ‪ 0xFFFF‬ﺑـﻪ رﺟﻴﺴـﺘﺮﻫﺎي‬

‫‪ICR1‬ﻳﺎ ‪.(OCR1x‬‬

‫دﻗﺖ ﻣﻮج ‪ PWM‬ﺑﺮ ﺣﺴﺐ ﻣﻘﺪار ﻣﺎﻛﺰﻳﻤﻢ از راﺑﻄﻪ ي زﻳﺮ ﺑﻪ دﺳﺖ ﻣﻲ آﻳﺪ‪:‬‬

‫)‪log(TOP + 1‬‬
‫= ‪resolution‬‬
‫)‪log(2‬‬

‫ﭘﺮﭼﻢ ﺳﺮرﻳﺰ ﺗﺎﻳﻤﺮ ‪ TOV1‬ﺑﺎ رﺳﻴﺪن ﺗﺎﻳﻤﺮ ﺑﻪ ﻣﻘﺪار ﺻﻔﺮ ﻳﻚ ﺧﻮاﻫﺪ ﺷﺪ و ﺑﺎ ﺗﻄﺒﻴﻖ ﻣﻘﺎﻳﺴﻪ ﻧﻴـﺰ ﺑﻴـﺖ ‪OCF1A‬‬

‫ﻳﺎ ‪ OCF1B‬ﻳﻚ ﻣﻲ ﺷﻮد‪ .‬در اﻳﻦ ﺣﺎﻟﺖ ﻫﺎ اﮔﺮ وﻗﻔﻪ ي ﻣﺮﺑﻮﻃﻪ ﻓﻌﺎل ﺷﺪه ﺑﺎﺷﺪ ﺑﺮﻧﺎﻣﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ‪ ISR‬آن وﻗﻔـﻪ‬

‫ﻣﻨﺸﻌﺐ ﺷﻮد‪ .‬ﻣﻘﺪار ﻣﻘﺎﻳﺴﻪ )‪ (OCRx‬را در ‪ ISR‬ﻳﺎ ﻫﺮ زﻣﺎن دﻳﮕﺮ ﻣـﻲ ﺗـﻮان ﺗﻐﻴﻴـﺮ داد اﻣـﺎ اﻳـﻦ ﻣﻘـﺪار در ﺑـﺎﻓﺮ‬

‫رﺟﻴﺴﺘﺮﻫﺎي ‪ OCR1A‬و ‪ OCR1B‬ذﺧﻴﺮه ﺷﺪه و ﺑﺎ رﺳﻴﺪن ﺗﺎﻳﻤﺮ ﺑﻪ ﻣﻘﺪار ‪ TOP‬در ﺧﻮد رﺟﻴﺴـﺘﺮ ‪ Load‬ﻣـﻲ‬

‫ﺷﻮد ﺑﻨﺎﺑﺮاﻳﻦ ﺗﻐﻴﻴﺮ دادن ﻣﻘﺪار رﺟﻴﺴﺘﺮﻫﺎي ‪ OCR1x‬ﺑﻪ دﻟﻴﻞ ﺗﻐﻴﻴـﺮ آن ﺑـﺎ رﺳـﻴﺪن ﺑـﻪ ‪ TOP‬ﻣـﻲ ﺗﻮاﻧـﺪ ﺑﺎﻋـﺚ‬

‫ﺧﺮوﺟﻲ ‪ PWM‬ﻧﺎ ﻣﺘﻘﺎرن ﺷﻮد‪:‬‬

‫  ‬
‫‪P a g e | 97‬‬
‫‪www.avr.ir‬‬

‫‪TOP‬‬ ‫‪OCR1A=110‬‬

‫‪OCR1A=180‬‬

‫ﻣﺸﻜﻞ ﺑﺎﻻ در ‪ PWM‬ﺗﺼﺤﻴﺢ ﻓﺎز و ﻓﺮﻛﺎﻧﺲ ﺑﺎ ﺑﺮوز ﻛﺮدن رﺟﻴﺴﺘﺮﻫﺎي ‪ OCR1x‬در زﻣﺎن رﺳﻴﺪن ﺑﻪ‬ ‫‬

‫ﺻﻔﺮ‪ ،‬ﺣﻞ ﻣﻲ ﺷﻮد‪.‬‬

‫ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ ﭘﻴﻦ ﻫﺎي ‪ OC1A‬و ‪ OC1B‬در ﺣﺎﻟﺖ ﺗﻄﺒﻴﻖ ﻣﻘﺎﻳﺴﻪ و ﺳﺮرﻳﺰ ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬

‫‪COM1A1‬‬ ‫‪COM1A0‬‬
‫وﺿﻌﻴﺖ ﭘﻴﻦ ‪ OC1A‬ﻳﺎ ‪OC1B‬‬
‫‪/COM1B1‬‬ ‫‪/COM1B0‬‬

‫‪0‬‬ ‫‪0‬‬ ‫ﻏﻴﺮ ﻓﻌﺎل )‪ I/O‬ﻣﻌﻤﻮﻟﻲ(‬

‫اﮔﺮ ‪ WGM1[3:0] = 9, 14‬ﺑﺎﺷﺪ‪ Toggle :‬ﭘﻴﻦ ‪ OC1A‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ و ‪ OC1B‬ﭘﻴﻦ ‪I/O‬‬
‫‪0‬‬ ‫‪1‬‬
‫ﻣﻌﻤﻮﻟﻲ ﺑﺮاي دﻳﮕﺮ ﺣﺎﻟﺖ ﻫﺎي ]‪ :WGM1[3:0‬ﻏﻴﺮ ﻓﻌﺎل )‪ I/O‬ﻣﻌﻤﻮﻟﻲ(‬

‫‪1‬‬ ‫‪0‬‬ ‫‪ Clear‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ و ﺷﻤﺎرش ﺻﻌﻮدي‪ Set .‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ و ﺷﻤﺎرش ﻧﺰوﻟﻲ‬

‫‪1‬‬ ‫‪1‬‬ ‫‪ Set‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ و ﺷﻤﺎرش ﺻﻌﻮدي‪ Clear .‬در وﺿﻌﻴﺖ ﺗﻄﺎﺑﻖ و ﺷﻤﺎرش ﻧﺰوﻟﻲ‬

‫ﻓﺮﻛﺎﻧﺲ ﻣﻮج ‪ PWM‬در ﺣﺎﻟﺖ ﺗﺼﺤﻴﺢ ﻓﺎز ﻧﺼﻒ ﺣﺎﻟﺖ ‪ Fast PWM‬ﺑﻮده و از راﺑﻄﻪ ي زﻳﺮ ﺑﺪﺳﺖ ﻣﻲ آﻳﺪ‪:‬‬

‫‪f Clk _ I / O‬‬

‫= ‪f PWM‬‬
‫) ‪2.N.(1 + TOP‬‬

‫  ‬
‫‪P a g e | 98‬‬
‫‪www.avr.ir‬‬
‫ﻣﺜﺎل ‪ :10‬در ﺑﺮﻧﺎﻣﻪ ي ﻣﺜﺎل ﻗﺒﻞ ‪ Mode‬ﺗﺎﻳﻤﺮ را از ‪ Fast PWM‬ﺑﻪ ‪ Phase Correct PWM‬ﺗﻐﻴﻴﺮ داده و ﻧﺼﻒ‬

‫ﺷﺪن ﻓﺮﻛﺎﻧﺲ ‪ PWM‬ﺧﺮوﺟﻲ را ﻣﺸﺎﻫﺪه ﻛﻨﻴﺪ‪:‬‬

‫;‪TCCR1A=0x83‬‬
‫;‪TCCR1B=0x02‬‬
‫;‪OCR1AL=0xFF‬‬

‫ ‪Phase and Frequency Correct Mode‬‬

‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﮔﻔﺘﻪ ﺷﺪ ﺑﻪ دﻟﻴﻞ ﺑﺮوز ﻛﺮدن رﺟﻴﺴﺘﺮ ‪ OCR1x‬ﺑﺎ رﺳﻴﺪن ﺑﻪ ‪ TOP‬ﻣﻤﻜﻦ اﺳﺖ ﺷﻜﻞ ﻣـﻮج ﺧﺮوﺟـﻲ‬

‫ﻧﺎﻣﺘﻘﺎرن ﺷﻮد ﺑﻨﺎﺑﺮاﻳﻦ ﺑﺮاي ﺣﻞ اﻳﻦ ﻣﺸﻜﻞ ‪ Mode‬ﭘﻨﺠﻢ ﺗﺎﻳﻤﺮ ﻳﻚ اﻳﻦ رﺟﻴﺴﺘﺮ را ﺑﺎ رﺳﻴﺪن ﺑﻪ ﺻﻔﺮ ﺑﺮوز ﻣﻲ ﻛﻨﺪ‪.‬‬

‫ﺗﻔﺎوت دﻳﮕﺮ اﻳﻦ ‪ Mode‬و ﻋﻤﻠﻜﺮد ﻗﺒﻠﻲ در اﻳﻦ اﺳﺖ ﻛـﻪ ﺗـﺎﻳﻤﺮ ﺗﻨﻬـﺎ در دو ﺣﺎﻟـﺖ زﻳـﺮ ﻛـﺎر ﻣـﻲ ﻛﻨـﺪ‪= 9 ،8) :‬‬

‫]‪(WGM1[3:0‬‬

‫‪ PWM‬ﺗﺼﺤﻴﺢ ﻓﺎز و ﻓﺮﻛﺎﻧﺲ ﺑﺎ ‪ICR1 = TOP‬‬ ‫‪.1‬‬

‫‪ PWM‬ﺗﺼﺤﻴﺢ ﻓﺎز و ﻓﺮﻛﺎﻧﺲ ﺑﺎ ‪OCR1A = TOP‬‬ ‫‪.2‬‬

‫  ‬
‫‪P a g e | 99‬‬
‫‪www.avr.ir‬‬

‫واﺣﺪ ‪ Capture‬ﺗﺎﻳﻤﺮ ﻳﻚ‬

‫ﻋﻤﻠﻜﺮد اﻳﻦ واﺣﺪ ﺑﻪ اﻳﻦ ﺻﻮرت اﺳﺖ ﻛﻪ در اﺛﺮ ﺗﺮﻳﮕﺮ ﺷﺪن ورودي ‪ Capture‬از ﭘﻴﻦ ‪ ICP1‬ﻳﺎ ﺧﺮوﺟﻲ ﻣﻘﺎﻳﺴﻪ‬

‫ﮔﺮ آﻧﺎﻟﻮگ ﻣﻘﺪار ﻣﻮﺟﻮد در رﺟﻴﺴﺘﺮ ‪ TCNT1‬در رﺟﻴﺴﺘﺮ ‪ ICR1‬ﻧﻮﺷﺘﻪ ﺷﺪه و ﻫﻤﺰﻣﺎن ﭘﺮﭼﻢ ‪ Capture‬ﺗـﺎﻳﻤﺮ‬

‫ﻳﻚ )‪ (ICF1‬ﻳﻚ ﻣﻲ ﺷﻮد‪ .‬در اﻳﻦ زﻣﺎن در ﺻﻮرت ﻓﻌﺎل ﺑﻮدن ﺑﻴـﺖ ﭘـﺮﭼﻢ ورودي ‪ (TICIE1) Capture‬اﻳـﻦ‬

‫ﺗﺮﻳﮕﺮ ﺷﺪن ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﺷﻮد‪ .‬ﺑﺎ اﺟﺮا ﺷﺪن ‪ ISR‬ﺑﻪ ﻃﻮر ﺧﻮدﻛﺎر ﺑﻴﺖ ‪ ICF1‬ﺻـﻔﺮ ﺷـﺪه و ﻳـﺎ در‬

‫ﺻﻮرت ﻓﻌﺎل ﻧﺒﻮدن وﻗﻔﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ ﺑﺮ روي آن ﭘﺎك ﺷﻮد‪.‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪ICR1H‬‬ ‫]‪ICR1[15:8‬‬
‫‪ICR1L‬‬ ‫]‪ICR1[7:0‬‬

‫• رﺟﻴﺴﺘﺮ ‪ ICR1‬ﺑﻪ ﺟﺰ در ﺣﺎﻟﺘﻲ ﻛﻪ ﺑﻪ ﻋﻨﻮان ‪ TOP‬ﺟﻬﺖ ﻣﻘﺎﻳﺴﻪ ﺑﻪ ﻛﺎر ﻣﻲ رود )‪ Mode‬ﻫﺎي ‪،10 ،8‬‬

‫‪ 12‬و ‪ (14‬ﻳﻚ رﺟﻴﺴﺘﺮ ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ اﺳﺖ‪.‬‬

‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﮔﻔﺘﻪ ﺷﺪ ﺗﺮﻳﮕﺮ ﺷﺪن واﺣﺪ ‪ Capture‬ﻣﻲ ﺗﻮاﻧﺪ از دو ﻣﻨﺒﻊ ﻣﺨﺘﻠﻒ ﺻﻮرت ﮔﻴﺮد ﻛﻪ اﻳﻦ از ﻃﺮﻳﻖ ﺑﻴﺖ‬

‫‪ ACIC‬در رﺟﻴﺴﺘﺮ ‪ ACSR‬ﺻﻮرت ﻣﻲ ﮔﻴﺮد‪ .‬ﺻﻔﺮ ﺑﻮدن اﻳﻦ ﺑﻴﺖ ﭘﻴﻦ ‪ ICP1‬و ﻳﻚ ﺑﻮدن آن ﺧﺮوﺟـﻲ ﻣﻘﺎﻳﺴـﻪ‬

‫ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ را اﻧﺘﺨﺎب ﻣﻲ ﻛﻨﺪ‪ .‬ﻫﻤﭽﻨﻴﻦ ﻧﻮع ﺳﻴﮕﻨﺎل ورودي از ﭘﻴﻦ ‪ ICP1‬ﺑﻮﺳﻴﻠﻪ ﺑﻴﺖ ‪ ICES1‬از رﺟﻴﺴـﺘﺮ‬

‫‪ TCCR1B‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪ ،‬ﺑﻪ اﻳﻦ ﺗﺮﺗﻴﺐ ﻛﻪ ﺻﻔﺮ ﺑﻮدن اﻳﻦ ﺑﻴﺖ ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧﺪه و ﻳـﻚ ﺑـﻮدن آن ﻟﺒـﻪ ي ﺑـﺎﻻ‬

‫روﻧﺪه ي ﺳﻴﮕﻨﺎل ورودي را اﻧﺘﺨﺎب ﻣﻲ ﻛﻨﺪ‪.‬‬

‫  ‬
‫‪P a g e | 100‬‬
‫‪www.avr.ir‬‬

‫‪TCCR1B‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪ICNC1 ICES1 - WGM13 WGM12 CS12 CS11 CS10‬‬

‫ورودي ‪ Capture‬داراي ﻳﻚ واﺣﺪ ﻛﺎﻫﺶ ﻧﻮﻳﺰ ﻧﻴﺰ ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﺑﺎ اﺳﺘﻔﺎده از ﻳﻚ ﻓﻴﻠﺘﺮ دﻳﺠﻴﺘـﺎل اﻳﻤﻨـﻲ ورودي را‬

‫ﺑﻬﺒﻮد ﻣﻲ ﺑﺨﺸﺪ‪ .‬اﻳﻦ واﺣﺪ ﺑﺎ ﻳﻚ ﻛﺮدن ﺑﻴﺖ ‪ ICNC1‬از رﺟﻴﺴﺘﺮ ‪ TCCR1B‬ﻓﻌﺎل ﻣﻲ ﺷﻮد‪ .‬ﺑﺎ ﻓﻌﺎل ﺷـﺪن اﻳـﻦ‬

‫ﻓﻴﻠﺘﺮ ﺑﺎﻳﺪ ﺳﻴﮕﻨﺎل ﻧﻤﻮﻧﻪ ﺑﺮداري ﺷﺪه روي ﭘﺎﻳﻪ ي ‪ ICP1‬ﺑﺮاي ﭼﻬﺎر ﺳﻴﻜﻞ ﻛﻼك ﻣﻌﺘﺒﺮ ﺑﺎﺷﺪ‪.‬‬

‫ﭘﺮوژه ‪ :10‬ﻛﻨﺘﺮل ﺳﺮو‪ ‬ﻣﻮﺗﻮر‬

‫*****************************************************‪/‬‬
‫‪Project : Servo Motor Controller‬‬
‫‪Author‬‬ ‫‪: Reza Sepas Yar‬‬
‫‪Company : Pishro Noavaran Kavosh‬‬
‫‪Chip type‬‬ ‫‪: ATmega16‬‬
‫‪Clock frequency‬‬ ‫‪: 16.000000 MHz‬‬
‫‪*****************************************************/‬‬

‫>‪#include <mega16.h‬‬
‫>‪#include <delay.h‬‬
‫‪#define xtal 16000000‬‬

‫)‪void main(void‬‬
‫{‬

‫;‪PORTD=0x00‬‬
‫

‬
P a g e | 101
www.avr.ir
DDRD=0x20;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 2000.000 kHz
// Mode: Ph. & fr. cor. PWM top=ICR1
// OC1A output: Non-Inv.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
TCCR1A=0x80;
TCCR1B=0x12;
ICR1H=0x4E;
ICR1L=0x20; //ICR=20000
OCR1AH=0x03;
OCR1AL=0xE8; //1000

while (1)
{

for(OCR1A=1000;OCR1A<2000;OCR1A++)
delay_ms(1);

for(OCR1A=2000;OCR1A>1000;OCR1A--)
delay_ms(1);

};
}



P a g e | 102
www.avr.ir

‫ ﺗﻮﻟﻴﺪ ﻣﻮج ﺳﻴﻨﻮﺳﻲ‬:11 ‫ﭘﺮوژه‬

#include <mega16.h>
#define xtal 8000000

flash char sinewave[256]={

0x80,0x83,0x86,0x89,0x8C,0x8F,0x92,0x95,0x99,0x9C,0x9F,0xA2,0xA5,0xA8,0xAB,0xAE,
0xB1,0xB4,0xB6,0xB9,0xBC,0xBF,0xC1,0xC4,0xC7,0xC9,0xCC,0xCE,0xD1,0xD3,0xD6,0xD8,
0xDA,0xDC,0xDF,0xE1,0xE3,0xE5,0xE6,0xE8,0xEA,0xEC,0xED,0xEF,0xF1,0xF2,0xF3,0xF5,
0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFC,0xFD,0xFE,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFE,0xFE,0xFD,0xFC,0xFC,0xFB,0xFA,0xF9,0xF8,0xF7,
0xF5,0xF4,0xF3,0xF2,0xF0,0xEF,0xED,0xEB,0xEA,0xE8,0xE6,0xE4,0xE2,0xE0,0xDE,0xDC,
0xD9,0xD7,0xD5,0xD2,0xD0,0xCE,0xCB,0xC8,0xC6,0xC3,0xC1,0xBE,0xBB,0xB8,0xB5,0xB3,
0xB0,0xAD,0xAA,0xA7,0xA4,0xA1,0x9E,0x9B,0x97,0x94,0x91,0x8E,0x8B,0x88,0x85,0x82,
0x7E,0x7B,0x78,0x75,0x72,0x6F,0x6C,0x69,0x65,0x62,0x5F,0x5C,0x59,0x56,0x53,0x50,
0x4D,0x4B,0x48,0x45,0x42,0x3F,0x3D,0x3A,0x37,0x35,0x32,0x30,0x2D,0x2B,0x29,0x26,
0x24,0x22,0x20,0x1E,0x1C,0x1A,0x18,0x16,0x14,0x13,0x11,0x0F,0x0E,0x0D,0x0B,0x0A,
0x09,0x08,0x06,0x05,0x05,0x04,0x03,0x02,0x02,0x01,0x01,0x01,0x01,0x01,0x01,0x01,


 
P a g e | 103
www.avr.ir
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x02,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,
0x0A,0x0B,0x0D,0x0E,0x0F,0x11,0x13,0x14,0x16,0x18,0x1A,0x1C,0x1E,0x20,0x22,0x24,
0x26,0x29,0x2B,0x2D,0x30,0x32,0x35,0x37,0x3A,0x3D,0x3F,0x42,0x45,0x48,0x4B,0x4D,
0x50,0x53,0x56,0x59,0x5C,0x5F,0x62,0x65,0x69,0x6C,0x6F,0x72,0x75,0x78,0x7B,0x7E
};

char i=0;

interrupt [TIM1_COMPA] void timer1_compa_isr(void)

{
OCR1A=sinewave[i];
i++;
if(i==255)
i=0;
}

void main(void) {

DDRD=0xFF;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 8000.000 kHz
// Mode: Fast PWM top=00FFh
// OC1A output: Non-Inv.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
TCCR1A=0x81;
TCCR1B=0x09;

// Timer(s)/Counter(s) Interrupt(s) initialization


 
P a g e | 104
www.avr.ir
TIMSK=0x10;

//enable global interrups

#asm("sei");

while (1);
}


 
‫‪P a g e | 105‬‬
‫‪www.avr.ir‬‬

‫ﭘﻮرت ﺳﺮﻳﺎل )‪(RS-232‬‬

‫‪ RS-232c‬در اواﺧﺮ دﻫﻪ ‪ 60‬ﻣﻴﻼدي ﺑﻪ ﺻﻮرت اﺳﺘﺎﻧﺪارد ﺗﻌﺮﻳﻒ ﺷﺪ و ﻫﻤﭽﻨﺎن ﻳﻜﻲ از اﺳـﺘﺎﻧﺪاردﻫﺎي ﭘﺮﻛـﺎرﺑﺮد‬

‫در ﻛﺎﻣﭙﻴﻮﺗﺮﻫﺎي ﺷﺨﺼﻲ و ﻛﺎرﺑﺮدﻫﺎي ﺻﻨﻌﺘﻲ اﺳﺖ‪ .‬اﻳﻦ اﺳﺘﺎﻧﺪارد ﻫﻢ ارﺗﺒﺎط ﺳﺮﻳﺎل ﺳـﻨﻜﺮون و ﻫـﻢ آﺳـﻨﻜﺮون را‬

‫ﭘﺸﺘﻴﺒﺎﻧﻲ ﻛﺮده و ﺑﻪ ﺻﻮرت ‪ Full Duplex‬ﻋﻤﻞ ﻣﻲ ﻧﻤﺎﻳﺪ‪ .‬ﻛﺎﻣﭙﻴﻮﺗﺮﻫﺎي ﺷﺨﺼﻲ ﺗﻨﻬﺎ ارﺗﺒﺎط آﺳﻨﻜﺮون را ﭘﺸﺘﻴﺒﺎﻧﻲ‬

‫ﻣﻲ ﻛﻨﻨﺪ و از ﻃﺮﻳﻖ ﭼﻴﭗ ‪ UART‬ﻣﻮﺟﻮد در ﺑﺮد اﺻﻠﻲ‪ ،‬اﻃﻼﻋﺎت را از ﺣﺎﻟﺖ ﻣﻮازي ﺑﻪ ﺳـﺮﻳﺎل ﻳـﺎ از ﺳـﺮﻳﺎل ﺑـﻪ‬

‫ﻣﻮازي ﺗﺒﺪﻳﻞ ﻛﺮده و ﺑﺎ ﺗﻨﻈﻴﻤﺎت زﻣﺎﻧﻲ آن را از ﻃﺮﻳﻖ ﭘﻮرت ﺳﺮﻳﺎل ارﺳﺎل ﻳﺎ درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫ﭘﻮرت ﺳﺮﻳﺎل داراي ﻳﻚ ﻛﺎﻧﻜﺘﻮر ‪ 9‬ﭘﻴﻦ ﻣﻲ ﺑﺎﺷﺪ و از آﻧﺠﺎﻳﻲ ﻛﻪ اﻳﻦ اﺳﺘﺎﻧﺪارد در اﺑﺘﺪا ﺑﺮاي ارﺗﺒﺎط ﺑﺎ ﻣﻮدم ﻃﺮاﺣﻲ‬

‫ﺷﺪه ﺑﻮد‪ ،‬داراي ﭘﻴﻦ ﻫﺎي ‪ Handshaking‬و وﺿﻌﻴﺖ ﻣﻲ ﺑﺎﺷﺪ‪ .‬اﻣﺎ ﻧﻮع ﺧﺎﺻـﻲ از ارﺗﺒـﺎط ﺑـﺎ ‪ RS-232‬ﺑـﻪ ﻧـﺎم‬

‫‪ Null-Modem‬ﻛﻪ ﺗﻨﻬﺎ ﺷﺎﻣﻞ ﭘﻴﻦ ﻫﺎي ارﺳﺎل و درﻳﺎﻓﺖ اﺳﺖ ﺑﺮاي ارﺗﺒﺎط ﺑـﺎ ﻏﻴـﺮ از ﻣـﻮدم اﺳـﺘﻔﺎده ﻣـﻲ ﺷـﻮد‪.‬‬

‫ﺑﻨﺎﺑﺮاﻳﻦ ﺗﻨﻬﺎ دو ﭘﻴﻦ ‪ Rx‬و ‪) Tx‬و اﻟﺒﺘﻪ زﻣﻴﻦ( ﻣﻮرد ﻧﻴﺎز اﺳﺖ‪ .‬در ﺷﻜﻞ زﻳﺮ ﻛﺎﻧﻜﺘﻮر ﭘﻮرت ﺳـﺮﻳﺎل را ﻛـﻪ ‪ D9‬ﻧـﺎم‬

‫دارد ﻣﻼﺣﻈﻪ ﻣﻲ ﻛﻨﻴﺪ‪:‬‬

‫ 
‬
‫‪P a g e | 106‬‬
‫‪www.avr.ir‬‬
‫در ﺟﺪول زﻳﺮ ﻋﻤﻠﻜﺮد ﻫﺮ ﭘﻴﻦ آورده ﺷﺪه اﺳﺖ‪:‬‬

‫‪Pin‬‬ ‫ﻋﻤﻠﻜﺮد‬

‫‪1‬‬ ‫‪Carrier Detect‬‬ ‫آﻳﺎ ﻣﻮدم ﺑﻪ ﻳﻚ ﺧﻂ ﺗﻠﻔﻦ ﻣﺘﺼﻞ اﺳﺖ ؟‬

‫‪2‬‬ ‫‪Receive Data‬‬ ‫ﻛﺎﻣﭙﻴﻮﺗﺮ اﻃﻼﻋﺎت ارﺳﺎل ﺷﺪه ﺗﻮﺳﻂ ﻣﻮدم را درﻳﺎﻓﺖ ﻣﻲ ﻧﻤﺎﻳﺪ‪.‬‬

‫‪3‬‬ ‫‪Transmit Data‬‬ ‫ﻛﺎﻣﭙﻴﻮﺗﺮ اﻃﻼﻋﺎﺗﻲ را ﺑﺮاي ﻣﻮدم ارﺳﺎل ﻣﻲ دارد‪.‬‬

‫‪4‬‬ ‫‪Data Terminal Ready‬‬ ‫ﻛﺎﻣﭙﻴﻮﺗﺮ ﺑﻪ ﻣﻮدم آﻣﺎدﮔﻲ ﺧﻮد را ﺑﺮاي ارﺗﺒﺎط اﻋﻼم ﻣﻲ دارد‪.‬‬

‫‪5‬‬ ‫‪Signal Ground‬‬ ‫زﻣﻴﻦ ﺳﻴﮕﻨﺎل‬

‫‪6‬‬ ‫‪Data Set Ready‬‬ ‫ﻣﻮدم آﻣﺎدﮔﻲ ﺧﻮد را ﺑﺮاي ارﺗﺒﺎط ﺑﻪ ﻛﺎﻣﭙﻴﻮﺗﺮ اﻋﻼم ﻣﻲ دارد‪.‬‬

‫‪7‬‬ ‫‪Request To Send‬‬ ‫ﻛﺎﻣﭙﻴﻮﺗﺮ از ﻣﻮدم در راﺑﻄﻪ ﺑﺎ ارﺳﺎل اﻃﻼﻋﺎت ﺳﻮال ﻣﻲ ﻧﻤﺎﻳﺪ‪.‬‬

‫‪8‬‬ ‫‪Clear To Send‬‬ ‫ﻣﻮدم ﺑﻪ ﻛﺎﻣﭙﻴﻮﺗﺮ اﻋﻼم ﻣﻲ ﻧﻤﺎﻳﺪ ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ اﻃﻼﻋﺎﺗﻲ را ارﺳﺎل دارد‪.‬‬

‫‪9‬‬ ‫‪Ring Indicator‬‬ ‫زﻧﮓ ﺗﻠﻔﻦ ﺗﺸﺨﻴﺺ داده ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫ﺳﻄﺢ ﺳﻴﮕﻨﺎل‪:‬‬

‫در اﺳﺘﺎﻧﺪارد ‪ RS-232‬ﺳﻄﺢ وﻟﺘﺎژ ‪ +3‬ﺗﺎ ‪ +12‬ﻧﻤﺎﻳﺎﻧﮕﺮ وﺿﻌﻴﺖ ‪ Space‬ﻳﺎ ﺻﻔﺮ ﻣﻨﻄﻘﻲ و ﺑﺎزه ي ‪ -3‬ﺗﺎ ‪ -12‬وﻟﺖ‬

‫ﻧﻤﺎﻳﺸﮕﺮ وﺿﻌﻴﺖ ‪ Mark‬ﻳﺎ ﻳﻚ ﻣﻨﻄﻘﻲ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫ 
‬
‫‪P a g e | 107‬‬
‫‪www.avr.ir‬‬

‫اﮔﺮﭼﻪ ﺗﺠﻬﻴﺰات اﺳﺘﺎﻧﺪارد ‪ TTL‬ﺑﺎ ﺳﻄﻮح ﻣﻨﻄﻘﻲ ‪ 0‬و ‪ 5‬وﻟﺖ ﻛﺎر ﻣﻲ ﻛﻨﻨﺪ اﻣﺎ ﻗﺎﻟـﺐ اﻃﻼﻋـﺎت ارﺳـﺎﻟﻲ ﺗﻔـﺎوﺗﻲ‬

‫ﻧﺪارد و ﺑﺎ ﻳﻚ ﻣﺪار ﺗﻐﻴﻴﺮ ﺳﻄﺢ وﻟﺘﺎژ‪ PC ،‬ﻣﻲ ﺗﻮاﻧﺪ ﺑـﺎ ادوات ‪ TTL‬ارﺗﺒـﺎط ﺑﺮﻗـﺮار ﻧﻤﺎﻳـﺪ‪ .‬ﻳﻜـﻲ از ﻣﺒـﺪل ﻫـﺎي‬

‫ﻣﺘﺪاول ﺳﻄﺢ ‪ RS-232‬ﺑﻪ ‪ TTL‬ﻣﺪار ﻣﺠﺘﻤﻊ ‪ MAX232‬و ﻳﺎ ‪ HIN232‬ﻣﻲ ﺑﺎﺷﺪ‪ MAX232 .‬ﻳﻚ ﺗﺮاﺷﻪ ي‬

‫‪ 16‬ﭘﺎﻳﻪ اﺳﺖ ﻛﻪ ﺷﺎﻣﻞ ‪ 2‬ﻓﺮﺳﺘﻨﺪه و ‪ 2‬ﻣﺒﺪل ﻣﺠﺰا اﺳﺖ‪ .‬در زﻳﺮ ﻳﻚ ﻣﺪار ﻧﻤﻮﻧﻪ را ﺑﺮاي ﻛﺎر ﺑﺎ اﻳﻦ ‪ IC‬ﻣﺸﺎﻫﺪه ﻣـﻲ‬

‫ﻛﻨﻴﺪ‪:‬‬

‫ 
‬
‫‪P a g e | 108‬‬
‫‪www.avr.ir‬‬

‫ﻗﺎﻟﺐ اﻃﻼﻋﺎت‪:‬‬

‫در ﻳﻚ ‪ Frame‬اﻃﻼﻋﺎﺗﻲ ﻛﻪ ﺗﻮﺳﻂ ﺑﻴﺖ ﺷﺮوع و ﺑﻴﺖ ﭘﺎﻳﺎن ﻣﺤﺼﻮر ﺷﺪه اﺳﺖ ﻣﻌﻤﻮﻻ ‪ 5‬ﺗﺎ ‪ 8‬ﺑﻴﺖ دﻳﺘـﺎ ﻗـﺮار ﻣـﻲ‬

‫ﮔﻴﺮد و ﻳﻚ ﺑﻴﺖ ﺗﻮازن ﻧﻴﺰ ﺑﻪ ﺻﻮرت اﺧﺘﻴﺎري ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮد‪ .‬ﺑﻴﺖ ﺷﺮوع ﻣﺘﻨﺎﻇﺮ ﺑﺎ ﺻﻔﺮ ﻣﻨﻄﻘﻲ اﺳﺖ و ﺑﻴﺖ ﭘﺎﻳﺎن‬

‫)ﻛﻪ ﻣﻤﻜﻦ اﺳﺖ ‪ 1‬ﻳﺎ ‪ 2‬ﺑﻴﺖ ﺑﺎﺷﺪ‪ (.‬ﺗﻮﺳﻂ ﻳﻚ ﺷﻨﺎﺳﺎﻳﻲ ﻣﻲ ﺷﻮد‪ .‬ﻣﺜﻼ در ﻧﻤﻮدار زﻣﺎﻧﻲ زﻳﺮ ﻳﻚ ‪ Frame‬ﺷﺎﻣﻞ ‪10‬‬

‫ﺑﻴﺖ اﺳﺖ ﻛﻪ ﻫﻔﺖ ﺑﻴﺖ آن ﺷﺎﻣﻞ ‪ Data‬ﻳﻚ ﺑﻴﺖ آﻏﺎزﻳﻦ و ﻳﻚ ﺑﻴﺖ ﭘﺎﻳﺎﻧﻲ و ﻳﻚ ﺑﻴﺖ ﺗﻮازن ﻗﺒﻞ از ﺑﻴﺖ ﭘﺎﻳﺎن ﻣﻲ‬

‫ﺑﺎﺷﺪ‪:‬‬

‫ﻋﻤﻠﻜﺮد ‪ USART‬ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ‪AVR‬‬

‫ﻗﻄﻌﻪ ي ‪ ATmega16‬داراي ﻳﻚ ﻣﺎژول ‪ USART‬ﺑﻮده ﻛـﻪ از اﺳـﺘﺎﻧﺪارد ‪ RS-232‬در دو ﺣﺎﻟـﺖ آﺳـﻨﻜﺮون و‬

‫ﺳﻨﻜﺮون ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ ﻛﻨﺪ‪ .‬دﺳﺘﺮﺳﻲ ﺑﻪ ﭘﻮرت ﺳﺮﻳﺎل ‪ AVR‬از ﻃﺮﻳـﻖ ﺳـﻪ ﭘـﻴﻦ ‪ RXD ،TXD‬و ‪ XCK‬ﻛـﻪ ﺑـﻪ‬

‫ﺗﺮﺗﻴﺐ ﭘﻴﻦ ارﺳﺎل‪ ،‬درﻳﺎﻓﺖ وﻛﻼك ﻣﻲ ﺑﺎﺷﻨﺪ اﻣﻜﺎن ﭘﺬﻳﺮ اﺳﺖ‪) .‬ﭘﻴﻦ ‪ XCK‬ﻓﻘﻂ در ‪ Mode‬ﺳﻨﻜﺮون ﻛﺎرﺑﺮد دارد‪(.‬‬

‫ﻗﺎﻟﺐ اﻃﻼﻋﺎت در ‪ USART‬ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ‪ AVR‬ﻫﻤﺎﻧﻨﺪ ‪ UART‬ﻛﺎﻣﭙﻴﻮﺗﺮﻫﺎي ﺷﺨﺼﻲ ﺷﺎﻣﻞ ﻳﻚ ﺑﻴـﺖ ﺷـﺮوع‪،‬‬

‫ﺑﻴﺖ ﻫﺎي داده‪ ،‬ﺑﻴﺖ اﺧﺘﻴﺎري ﺗﻮازن و ﻳﻚ ﻳﺎ دو ﺑﻴﺖ ﭘﺎﻳﺎن اﺳﺖ‪ ،‬ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ در ‪ AVR‬ﻣﻲ ﺗﻮاﻧﺪ ‪ 5‬ﺗﺎ ‪ 9‬ﺑﻴـﺖ‬

‫ 
‬
‫‪P a g e | 109‬‬
‫‪www.avr.ir‬‬
‫‪ Data‬ﺗﻌﺮﻳﻒ ﺷﻮد‪ .‬ﺑﻴﺖ ﺗﻮازن ﻣـﻲ ﺗﻮاﻧـﺪ ﻓـﺮد ﻳـﺎ زوج ﺑﺎﺷـﺪ و از ﻃﺮﻳـﻖ ﺑﻴـﺖ ﻫـﺎي ]‪ UPM[1:0‬از رﺟﻴﺴـﺘﺮ‬

‫‪ UCSRC‬ﺗﻨﻈﻴﻢ ﻣﻲ ﺷﻮد‪.‬‬

‫رﺟﻴﺴﺘﺮﻫﺎي ‪USART‬‬

‫‪(UDR) USART Data Register‬‬ ‫‪.1‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫)‪UDR (Read‬‬ ‫]‪RXB[7:0‬‬
‫)‪UDR (Write‬‬ ‫]‪TXB[7:0‬‬

‫ﺑﺎﻓﺮ درﻳﺎﻓﺖ و ارﺳﺎل ﭘﻮرت ﺳﺮﻳﺎل داراي ﻳﻚ آدرس ﻣﺸﺘﺮك ﺑﻪ ﻧﺎم ‪ UDR‬در ﻓﻀﺎي ‪ I/O Registers‬ﻣﻲ ﺑﺎﺷﻨﺪ‪.‬‬

‫ﺑﺎﻓﺮ ارﺳﺎل‪ ،‬ﻣﻘﺼﺪ داده ﻫﺎي ﻧﻮﺷﺘﻪ ﺷﺪه در رﺟﻴﺴﺘﺮ‪ UDR‬ﺑﻮده و ﺧﻮاﻧﺪن اﻳﻦ رﺟﻴﺴﺘﺮ ﻣﺤﺘﻮﻳـﺎت ﺑـﺎﻓﺮ درﻳﺎﻓـﺖ را‬

‫ﺑﻪ دﺳﺖ ﻣﻲ دﻫﺪ‪ .‬ﺗﻨﻬﺎ زﻣﺎﻧﻲ ﻣﻲ ﺗـﻮان روي رﺟﻴﺴـﺘﺮ ‪ UDR‬ﻣﻘـﺪاري را ﻧﻮﺷـﺖ ﻛـﻪ ﺑﻴـﺖ ‪ UDRE‬از رﺟﻴﺴـﺘﺮ‬

‫‪ UCSRA‬ﻳﻚ ﺷﺪه ﺑﺎﺷﺪ و در ﻏﻴﺮ اﻳﻨﺼﻮرت دﻳﺘﺎي ارﺳﺎﻟﻲ ﺗﻮﺳﻂ ‪ USART‬ﻧﺎدﻳﺪه ﮔﺮﻓﺘﻪ ﻣـﻲ ﺷـﻮد‪ .‬ﺑـﺎ ارﺳـﺎل‬

‫اﻃﻼﻋﺎت ﺑﻪ ﺑﺎﻓﺮ ارﺳﺎل ‪ USART‬در ﺻﻮرﺗﻲ ﻛﻪ ﺑﻴﺖ ‪ TXEN‬از رﺟﻴﺴـﺘﺮ ‪ UCSRB‬ﻳـﻚ ﺑﺎﺷـﺪ اﻃﻼﻋـﺎت در‬

‫ﺷﻴﻔﺖ رﺟﻴﺴﺘﺮ ﺑﺎرﮔﺬاري ﺷﺪه و ﺑﻴﺖ ﺑﻪ ﺑﻴﺖ از ﭘﻴﻦ ‪ TXD‬ارﺳﺎل ﻣﻲ ﺷﻮد‪.‬‬

‫‪USART Control and Status Register A‬‬ ‫‪.٢‬‬

‫‪UCSR‬‬
‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪A‬‬

‫ 
‬
‫‪P a g e | 110‬‬
‫‪www.avr.ir‬‬
‫‪RX‬‬ ‫‪UDR‬‬ ‫‪U2‬‬ ‫‪MPC‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪TXC‬‬ ‫‪FE DOR PE‬‬
‫‪C‬‬ ‫‪E‬‬ ‫‪X‬‬ ‫‪M‬‬

‫‪ :Multi-processor Communication Mode‬ﻳﻚ ﺷﺪن اﻳﻦ ﺑﻴﺖ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ را ﺑﻪ ﺣﺎﻟﺖ ارﺗﺒﺎﻃﺎت‬

‫ﭼﻨﺪ ﭘﺮدازﻧﺪه اي ﻣﻲ ﺑﺮد‪.‬‬

‫‪ :Double the USART Transmission Speed‬ﺑﺎ ﻳﻚ ﻛﺮدن اﻳـﻦ ﺑﻴـﺖ در ‪ Mode‬آﺳـﻨﻜﺮون ‪Baud‬‬

‫‪ Rate‬دو ﺑﺮاﺑﺮ ﺧﻮاﻫﺪ ﺷﺪ‪ .‬در ‪ Mode‬ﺳﻨﻜﺮون اﻳﻦ ﺑﻴﺖ ﺑﺎﻳﺪ ﺻﻔﺮ ﺑﺎﺷﺪ‪.‬‬

‫‪ :Parity Error‬در ﺻﻮرت ﻓﻌﺎل ﺑﻮدن ﺗﻮﻟﻴﺪ ﺑﻴﺖ ﺗﻮازن از ﻃﺮﻳﻖ ﺑﻴﺖ ﻫﺎي ]‪ ،UPM[1:0‬ﺑﺎ روي دادن ﺧﻄﺎي‬

‫ﺗﻮازن در ﺑﺎﻓﺮ درﻳﺎﻓﺖ‪ ،‬اﻳﻦ ﺑﻴﺖ ﻳﻚ ﻣﻲ ﺷﻮد‪.‬‬

‫‪ :Data Overrun‬ﺑﺎ ﺑﺮوز ‪ Overrun‬اﻳﻦ ﺑﻴﺖ ﻳﻚ ﻣﻲ ﺷﻮد‪ .‬ﺷﺮاﻳﻂ ‪ Overrun‬ﻳﺎ ﻟﺒﺮﻳﺰ وﻗﺘﻲ روي ﻣـﻲ دﻫـﺪ‬

‫ﻛﻪ ﺑﺎﻓﺮ درﻳﺎﻓﺖ ﭘﺮ ﺑﺎﺷﺪ و ﺷﻴﻔﺖ رﺟﻴﺴﺘﺮ ﻧﻴﺰ ﻣﺤﺘﻮي داده ي ﺟﺪﻳـﺪي ﺑﺎﺷـﺪ و داده ي ﺟﺪﻳـﺪي ﻧﻴـﺰ از راه ﺑﺮﺳـﺪ‪،‬‬

‫ﻳﻌﻨﻲ ﻳﻚ ﺑﺎﻳﺖ در ﺑﺎﻓﺮ ﺷﻴﻔﺖ رﺟﻴﺴﺘﺮ ﻣﻨﺘﻈﺮ ﺑﺎﺷﺪ و ﺑﻴﺖ ﺷﺮوع ﺟﺪﻳﺪي درﻳﺎﻓﺖ ﺷـﻮد‪ .‬در اﻳـﻦ ﺣﺎﻟـﺖ اﻃﻼﻋـﺎت‬

‫ﺟﺪﻳﺪ از ﺑﻴﻦ ﻣﻲ رود و ﺑﺎ ﻳﻚ ﺷﺪن ﺑﻴﺖ ‪ DOR‬ﺑﺮوز ﺧﻄﺎ اﻋﻼم ﻣﻲ ﺷﻮد‪.‬‬

‫‪ :Frame Error‬اﮔﺮ در ‪ Frame‬درﻳﺎﻓﺖ ﺷﺪه ﺑﻴﺖ ﭘﺎﻳﺎن ﺻﻔﺮ ﺑﺎﺷﺪ اﻳﻦ ﺑﻴﺖ ﻳﻚ ﺷﺪه و در ﻏﻴﺮ اﻳﻨﺼﻮرت ﺻﻔﺮ‬

‫ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬

‫‪ :USART Data Register Empty‬ﻳﻚ ﺑﻮدن اﻳﻦ ﭘﺮﭼﻢ ﻧﺸﺎن دﻫﻨﺪه ي اﻳﻦ اﺳﺖ ﻛﻪ اﻃﻼﻋـﺎت ﻣﻮﺟـﻮد در‬

‫ﺑﺎﻓﺮ ارﺳﺎل ﺑﺮاي ﺷﻴﻔﺖ رﺟﻴﺴﺘﺮ ارﺳﺎل ﺷﺪه و ﺑﺎﻓﺮ ارﺳﺎل آﻣﺎده ي درﻳﺎﻓﺖ ﻛﺎراﻛﺘﺮ ﺟﺪﻳﺪ اﺳﺖ‪ .‬ﻫﻤﭽﻨﻴﻦ در ﺻﻮرﺗﻲ‬

‫ﻛﻪ ﺑﻴﺖ ‪ UDRIE‬از رﺟﻴﺴﺘﺮ ‪ UCSRB‬ﻳﻚ ﺑﺎﺷﺪ ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﺷﺪه و ﺗﺎ زﻣﺎﻧﻲ ﻛﻪ ﺑﻴﺖ ‪ UDRE‬ﻳﻚ اﺳـﺖ‬

‫
‬
‫‪P a g e | 111‬‬
‫‪www.avr.ir‬‬
‫ﺑﺎ ﺧﺎرج ﺷﺪن از ‪ ISR‬دوﺑﺎره آن را اﺟﺮا ﻣﻲ ﻛﻨﺪ ﺑﺎ ﻧﻮﺷﺘﻦ داده ي ﺟﺪﻳﺪ در ‪ UDR‬ﭘﺮﭼﻢ ‪ UDRE‬ﺻـﻔﺮ ﻣـﻲ‬

‫ﺷﻮد‪ .‬ﺑﻌﺪ از رﻳﺴﺖ ﺷﺪن ﻣﻴﻜﺮو اﻳﻦ ﺑﻴﺖ ﻳﻚ ﻣﻲ ﺷﻮد ﻛﻪ ﺑﻪ ﻣﻌﻨﺎي آﻣﺎده ﺑﻮدن درﻳﺎﻓﺖ ﻛﺎراﻛﺘﺮ ﺟﺪﻳﺪ اﺳﺖ‪.‬‬

‫‪ :USART Transmit Complete‬اﻳﻦ ﭘﺮﭼﻢ زﻣﺎﻧﻲ ﻳﻚ ﻣﻲ ﺷﻮد ﻛﻪ ﺗﻤﺎم اﻃﻼﻋﺎت ﻣﻮﺟﻮد در ﺷﻴﻔﺖ‬

‫رﺟﻴﺴﺘﺮ ﺑﻪ ﺑﻴﺮون ﺷﻴﻔﺖ داده ﺷﺪه و داده ي ﺟﺪﻳﺪي در ﺑﺎﻓﺮ ارﺳﺎل وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﺑﺎ ﻓﻌﺎل ﺑﻮدن ﺑﻴﺖ‬

‫‪ TXCIE‬اﻳﻦ ﭘﺮﭼﻢ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ي ﻛﺎﻣﻞ ﺷﺪن ارﺳﺎل ﺷﻮد و ﺑﺎ اﺟﺮاي ‪ ISR‬ﺑﻴﺖ ‪ TXC‬ﺗﻮﺳﻂ‬

‫ﺳﺨﺖ اﻓﺰار ﭘﺎك ﺷﺪه و در ﻏﻴﺮ اﻳﻨﺼﻮرت ﻧﺮم اﻓﺰار ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ ﺑﺮ روي آن‪ ،‬آن را ﭘﺎك ﻛﻨﺪ‪.‬‬

‫‪ :USART Receive Complete‬اﻳﻦ ﺑﻴﺖ ﺑﺎ ﻛﺎﻣﻞ ﺷﺪن درﻳﺎﻓﺖ ﻳﻚ ‪ Frame‬در ‪ UDR‬ﻳﻚ ﺷﺪه و ﭘﺲ از‬

‫ﺧﻮاﻧﺪن ‪ UDR‬ﺻﻔﺮ ﻣﻲ ﺷﻮد‪.‬‬

‫‪USART Control and Status Register B‬‬ ‫‪.‬‬

‫‪UCSRB‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪RXCIE TXCIE UDRIE RXEN TXEN UCSZ2 RXB8 TXB8‬‬

‫‪ :Transmit Data Bit 8‬در ﺣﺎﻟﺘﻲ ﻛﻪ از ﭘﻮرت ﺳﺮﻳﺎل در ‪ 9 Mode‬ﺑﻴﺘﻲ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد اﻳـﻦ ﺑﻴـﺖ ﻧﻬﻤـﻴﻦ‬

‫ﺑﻴﺖ ﻛﺎراﻛﺘﺮ ارﺳﺎﻟﻲ ﺧﻮاﻫﺪ ﺑﻮد‪ .‬ﺑﺎﻳﺪ ﺗﻮﺟﻪ داﺷﺖ ﻛﻪ ﻗﺒﻞ از ﻧﻮﺷﺘﻦ در ‪ UDR‬ﺑﺎﻳﺪ وﺿﻌﻴﺖ اﻳﻦ ﺑﻴـﺖ را ﻣﺸـﺨﺺ‬

‫ﻛﺮد‪.‬‬

‫‪ :Receive Data Bit 8‬در ﺣﺎﻟﺘﻲ ﻛﻪ از ﭘﻮرت ﺳﺮﻳﺎل در ‪ 9 Mode‬ﺑﻴﺘﻲ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد اﻳﻦ ﺑﻴﺖ ﻧﻬﻤﻴﻦ ﺑﻴـﺖ‬

‫ﻛﺎراﻛﺘﺮ درﻳﺎﻓﺘﻲ ﺧﻮاﻫﺪ ﺑﻮد‪ .‬ﺑﺎﻳﺪ ﺗﻮﺟﻪ داﺷﺖ ﻛﻪ ﻗﺒﻞ از ﺧﻮاﻧﺪن ‪ UDR‬ﺑﺎﻳﺪ اﻳﻦ ﺑﻴﺖ را ﺧﻮاﻧﺪ‪.‬‬

‫ ‬
‫‪P a g e | 112‬‬
‫‪www.avr.ir‬‬
‫‪ :Character Size‬ﺑﺎ ﺗﺮﻛﻴﺐ اﻳﻦ ﺑﻴﺖ و ﺑﻴﺖ ﻫﺎي ]‪ UCSZ[1:0‬در رﺟﻴﺴﺘﺮ ‪ UCSRC‬ﺗﻌﺪاد ﺑﻴﺖ ﻫـﺎي داده‬

‫)اﻧﺪازه ي ﻛﺎراﻛﺘﺮ( را در ﻳﻚ ‪ Frame‬ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫‪ :Transmitter Enable‬ﺑﺎ ﻳﻚ ﻛﺮدن اﻳﻦ ﺑﻴﺖ ﻋﻤﻠﻜﺮد ﻋﺎدي ﭘﻴﻦ ‪ TxD‬ﺑﻪ ارﺳﺎل ﭘﻮرت ﺳﺮﻳﺎل ﺗﻐﻴﻴـﺮ ﺣﺎﻟـﺖ‬

‫داده و ﺑﻌﺪ از آن ﻗﺎﺑﻞ اﺳﺘﻔﺎده ﺑﻪ ﺻﻮرت ‪ I/O‬ﻣﻌﻤﻮﻟﻲ ﻧﻴﺴﺖ‪ .‬ﻏﻴﺮ ﻓﻌﺎل ﻛﺮدن اﻳﻦ ﺑﻴﺖ در ﺣﺎﻟﻴﻜﻪ ‪ UART‬ﺳـﺮﻳﺎل‬

‫ﻣﺸﻐﻮل اﺳﺖ ﺗﺎ اﺗﻤﺎم ارﺳﺎل اﻃﻼﻋﺎت ﺗﺎﺛﻴﺮ ﻧﺨﻮاﻫﺪ ﮔﺮﻓﺖ‪.‬‬

‫‪ :Receiver Enable‬ﺑﺎ ﻳﻚ ﻛﺮدن اﻳﻦ ﺑﻴﺖ ﻋﻤﻠﻜﺮد ﻋﺎدي ﭘﻴﻦ ‪ RxD‬ﺑﻪ درﻳﺎﻓﺖ ﭘﻮرت ﺳﺮﻳﺎل ﺗﻐﻴﻴﺮ ﺣﺎﻟـﺖ داده‬

‫و ﺑﻌﺪ از آن ﻗﺎﺑﻞ اﺳﺘﻔﺎده ﺑﻪ ﺻﻮرت ‪ I/O‬ﻣﻌﻤﻮﻟﻲ ﻧﻴﺴﺖ‪ .‬ﺑﺎ ﺻﻔﺮ ﻛﺮدن اﻳﻦ ﺑﻴﺖ ﺑﺎﻓﺮ ﭘـﻮرت ﺳـﺮﻳﺎل ﺧـﺎﻟﻲ ﺷـﺪه و‬

‫ﻣﻘﺪار ﺑﻴﺖ ﻫﺎي ‪ FE ،DOR‬و ‪ PE‬ﻧﺎﻣﻌﺘﺒﺮ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬

‫‪ :USART Data Register Empty Interrupt Enable‬ﺑﺎ ﻳﻚ ﺷﺪن اﻳﻦ ﺑﻴـﺖ‪ ،‬در ﺻـﻮرﺗﻲ ﻛـﻪ ﺑﻴـﺖ‬

‫ﻓﻌﺎل ﺳﺎز ﻛﻠﻲ وﻗﻔﻪ ﻫﺎ )‪ (I‬ﻳﻚ ﺑﺎﺷﺪ‪ ،‬ﻓﻌﺎل ﺷﺪن ﭘﺮﭼﻢ ﺧﺎﻟﻲ ﺑﻮدن ﺑﺎﻓﺮ ارﺳﺎل )‪ (UDRE‬ﻣﻲ ﺗﻮاﻧـﺪ ﺑﺎﻋـﺚ اﻳﺠـﺎد‬

‫وﻗﻔﻪ ﺷﻮد‪.‬‬

‫‪ :TX Complete Interrupt Enable‬ﺑﺎ ﻳﻚ ﺷﺪن اﻳﻦ ﺑﻴﺖ‪ ،‬در ﺻﻮرﺗﻲ ﻛﻪ ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﻛﻠﻲ وﻗﻔﻪ ﻫﺎ )‪(I‬‬

‫ﻳﻚ ﺑﺎﺷﺪ‪ ،‬ﻓﻌﺎل ﺷﺪن ﭘﺮﭼﻢ اﺗﻤﺎم ارﺳﺎل )‪ (TXC‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﺷﻮد‪.‬‬

‫‪ :RX Complete Interrupt Enable‬ﺑﺎ ﻳﻚ ﺷﺪن اﻳﻦ ﺑﻴﺖ‪ ،‬در ﺻﻮرﺗﻲ ﻛﻪ ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﻛﻠﻲ وﻗﻔﻪ ﻫﺎ )‪(I‬‬

‫ﻳﻚ ﺑﺎﺷﺪ‪ ،‬ﻓﻌﺎل ﺷﺪن ﭘﺮﭼﻢ اﺗﻤﺎم ارﺳﺎل )‪ (RXC‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﺷﻮد‪.‬‬

‫‪USART Control and Status Register C‬‬ ‫‪.‬‬

‫‪UCSRC‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫  ‬
‫‪P a g e | 113‬‬
‫‪www.avr.ir‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪URSEL UMSEL UPM1 UPM0 USBS UCSZ1 UCSZ0 UCPOL‬‬

‫
رﺟﻴﺴﺘﺮﻫﺎي ‪ UCSRC‬و ‪ UBRRH‬داراي آدرس ﻣﺸﺘﺮﻛﻲ در ﻓﻀﺎي ‪ I/O‬ﻫﺴﺘﻨﺪ‪ ،‬ﻛﻪ ﺑﺮاي اﻧﺘﺨﺎب اﻳﻦ دو از‬

‫ﺑﻴﺖ ‪ URSEL‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‪.‬‬

‫‪ :Clock Polarity‬اﻳﻦ ﺑﻴﺖ ﻓﻘﻂ در ‪ Mode‬ﺳﻨﻜﺮون ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲ ﺷﻮد و در ‪ Mode‬آﺳﻨﻜﺮون ﺑﺎﻳﺪ روي آن‬

‫ﺻﻔﺮ ﻧﻮﺷﺘﻪ ﺷﻮد‪ .‬ﻋﻤﻠﻜﺮد اﻳﻦ ﺑﻴﺖ ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ اﺳﺖ‪:‬‬

‫ﻧﻤﻮﻧﻪ ﺑﺮداري از داده ي درﻳﺎﻓﺘﻲ روي ﭘﻴﻦ ‪ RxD‬ﺗﻐﻴﻴﺮ داده ي ارﺳﺎﻟﻲ روي ﭘﻴﻦ ‪UCPOL TxD‬‬

‫
‬ ‫ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه ي ﭘﺎﻟﺲ ‪XCK‬‬ ‫ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧﺪه ي ﭘﺎﻟﺲ ‪XCK‬‬

‫ ‬ ‫ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧﺪه ي ﭘﺎﻟﺲ ‪XCK‬‬ ‫ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه ي ﭘﺎﻟﺲ ‪XCK‬‬

‫]‪ :Character Size[1:0‬اﻳﻦ ﺑﻴﺖ ﺑﻪ ﻫﻤﺮاه ﺑﻴﺖ ‪ UCSZ2‬ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﺗﻌﺪاد ﺑﻴﺖ ﻫﺎي ﻳﻚ ﻛﺎراﻛﺘﺮ را‬

‫ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨﺪ‪ ،‬در ﺣﺎﻟﺖ ﭘﻴﺶ ﻓﺮض اﻳﻦ ﺑﻴﺖ ﻫﺎ اﻧﺪازه ي ‪ 8‬ﺑﻴﺖ را ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨﺪ‪.‬‬

‫‪UCSZ2‬‬ ‫‪UCSZ1‬‬ ‫‪UCSZ0‬‬ ‫اﻧﺪازه ي ﻛﺎراﻛﺘﺮ‬

‫
‬ ‫
‬ ‫
‬ ‫‪ 5‬ﺑﻴﺖ‬

‫  ‬
‫‪P a g e | 114‬‬
‫‪www.avr.ir‬‬
‫
‬ ‫
‬ ‫ ‬ ‫‪ 6‬ﺑﻴﺖ‬

‫
‬ ‫ ‬ ‫
‬ ‫‪ 7‬ﺑﻴﺖ‬

‫
‬ ‫ ‬ ‫ ‬ ‫‪ 8‬ﺑﻴﺖ‬

‫ ‬ ‫
‬ ‫
‬ ‫رزرو ﺷﺪه‬

‫ ‬ ‫
‬ ‫ ‬ ‫رزرو ﺷﺪه‬

‫ ‬ ‫ ‬ ‫
‬ ‫رزرو ﺷﺪه‬

‫ﺑﻴﺖ‪ ،‬ﺗﻌﺪاد ﺑﻴﺖ ﻫﺎي‬ ‫ ‬ ‫ ‬ ‫ ‬ ‫ﺣﺎﻟﺖ ‪ 9‬ﺑﻴﺘﻲ‬ ‫‪ :Stop Bit Select‬اﻳﻦ‬

‫ﭘﺎﻳﺎن را ﻣﻌﻴﻦ ﻣﻲ ﻛﻨﺪ‪ .‬در ﺣﺎﻟﺖ ﭘﻴﺶ ﻓﺮض ﻛﻪ اﻳﻦ ﺑﻴﺖ ﺻﻔﺮ ﻣﻲ ﺑﺎﺷﺪ ﻳﻚ ﺑﻴﺖ ﭘﺎﻳﺎن و در ﺻﻮرت ‪ 1‬ﺷﺪن ‪ 2‬ﺑﻴﺖ‬

‫ﭘﺎﻳﺎن در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬

‫]‪ :Parity Mode[1:0‬اﻳﻦ دو ﺑﻴﺖ ﺗﻨﻈﻴﻤﺎت ﻣﺮﺑﻮط ﺑﻪ ﺑﻴﺖ ﺗﻮازن را ﻣﻄـﺎﺑﻖ ﺟـﺪول زﻳـﺮ اﻧﺠـﺎم ﻣـﻲ دﻫﻨـﺪ‪ .‬در‬

‫ﺻﻮرت ﻓﻌﺎل ﺑﻮدن ﺑﻴﺖ ﺗﻮازن ﻫﻤﺮاه ﻫﺮ ‪ Frame‬اﻳﻦ ﺑﻴﺖ اﻳﺠﺎد ﺷﺪه و در ﮔﻴﺮﻧﺪه ﺑﺮ ﺣﺴﺐ ﻫﻤـﺎن ﺗﻨﻈﻴﻤـﺎت )ﻛـﻪ‬

‫ﺑﺎﻳﺪ در آﻧﺠﺎ ﻧﻴﺰ ﻣﻄﺎﺑﻖ ﺗﻨﻈﻴﻤﺎت ﻓﺮﺳﺘﻨﺪه اﻧﺠﺎم ﺷﻮد‪ (.‬ﻣﻘﺪار ﺑﻴﺖ ﺗﻮازن ﺑﺎ ﻣﻘﺪار درﻳﺎﻓـﺖ ﺷـﺪه ﻣﻘﺎﻳﺴـﻪ ﺷـﺪه و در‬

‫ﺻﻮرت ﺑﺮوز ﺧﻄﺎ ﭘﺮﭼﻢ ‪ PE‬از رﺟﻴﺴﺘﺮ ‪ UCSRA‬ﻳﻚ ﻣﻲ ﺷﻮد‪.‬‬

‫وﺿﻌﻴﺖ ﺑﻴﺖ ﺗﻮازن ‪UPM1 UPM0‬‬

‫‪0‬‬ ‫‪0‬‬ ‫ﻏﻴﺮ ﻓﻌﺎل‬

‫‪0‬‬ ‫‪1‬‬ ‫رزرو ﺷﺪه‬

‫‪1‬‬ ‫‪0‬‬ ‫ﺗﻮازن زوج‬

‫‪1‬‬ ‫‪1‬‬ ‫ﺗﻮازن ﻓﺮد‬

‫  ‬
‫‪P a g e | 115‬‬
‫‪www.avr.ir‬‬
‫‪ UMSEL :USART Mode Select‬ﺣﺎﻟﺖ ﻛﺎر ‪ UART‬را ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ‪ .‬در ﺻﻮرﺗﻲ اﻳﻦ ﺑﻴﺖ ﻳﻚ ﺑﺎﺷﺪ در‬

‫ﺣﺎﻟﺖ آﺳﻨﻜﺮون و ﺑﺎ ﻳﻚ ﻛﺮدن آن در وﺿﻌﻴﺖ ﺳﻨﻜﺮون ﻛﺎر ﻣﻲ ﻛﻨﺪ‪.‬‬

‫‪ :Register Select‬ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﮔﻔﺘﻪ ﺷﺪ دو رﺟﻴﺴﺘﺮ ‪ UCSRC‬و ‪ UBRRH‬داراي آدرس ﻣﺸﺘﺮﻛﻲ )‪(0x40‬‬

‫ﻫﺴﺘﻨﺪ و اﻳﻦ ﺑﻴﺖ ﺑﺮاي اﻧﺘﺨﺎب ﻧﻮﺷﺘﻦ روي ﻳﻜﻲ از اﻳﻦ دو رﺟﻴﺴﺘﺮ ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﺑﻪ اﻳﻦ ﺻﻮرت ﻛﻪ اﮔﺮ ﺑﺨﻮاﻫﻴﻢ روي‬

‫‪ UCSRC‬ﻣﻘﺪاري را ﺑﻨﻮﻳﺴﻴﻢ ﺑﺎﻳﺪ در ﻫﻤﺎن ﺑﺎﻳﺖ ‪ MSB‬ﻳﻚ ﺑﺎﺷﺪ و ﭼﻨﺎﻧﭽﻪ ﺑﺨﻮاﻫﻴﻢ روي ‪ UBRRH‬ﻣﻘﺪاري‬

‫را ﺑﻨﻮﻳﺴﻴﻢ ﺑﺎﻳﺪ ‪ MSB‬ﺻﻔﺮ ﺑﺎﺷﺪ‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮرات زﻳﺮ ﻣﻘﺪار ﺑﻴﺖ ‪ 1‬از ﻫﺮ رﺟﻴﺴﺘﺮ را ﻳﻚ ﻣﻲ ﻛﻨﺪ‪:‬‬

‫;‪UBRRH = 0x02‬‬
‫;‪UCSRC = 0x82‬‬

‫روش ﺧﻮاﻧﺪن اﻳﻦ دو رﺟﻴﺴﺘﺮ ﺑﻪ اﻳﻦ ﺻﻮرت اﺳﺖ ﻛﻪ در ﺻﻮرت ﺧﻮاﻧﺪن ﻣﻘـﺪار آدرس ‪ 0x40‬و ﻳـﺎ ﻫـﺮ ﻳـﻚ از‬

‫اﺳﺎﻣﻲ ﻣﺴﺘﻌﺎر اﻳﻦ آدرس )‪ UCSRC‬ﻳﺎ ‪ (UBRRH‬ﻣﻘﺪار رﺟﻴﺴﺘﺮ ‪ UBRRH‬ﺑﻪ دﺳﺖ ﺧﻮاﻫﺪ آﻣﺪ‪:‬‬

‫;‪a = UBRRH‬‬
‫ﭼﻨﺎﻧﭽﻪ ﺑﺨﻮاﻫﻴﻢ ﻣﻘﺪار رﺟﻴﺴﺘﺮ ‪ UCSRC‬را ﺑﺪﺳﺖ آورﻳﻢ ﺑﺎﻳﺪ در ﺳﻴﻜﻞ ﻛﻼك ﺑﻌﺪي ﻣﻘﺪار ﺧﻮاﻧﺪه ﺷـﺪه را ﺑـﻪ‬

‫ﻋﻨﻮان ﻣﻘﺪار واﻗﻌﻲ ‪ UCSRC‬در ﻧﻈﺮ ﺑﮕﻴﺮﻳﻢ‪ ،‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪:‬‬

‫;‪b = UBRRH‬‬
‫;‪b = UCSRC‬‬

‫ﺑﻬﺘﺮ اﺳﺖ در ﺻﻮرت اﺳﺘﻔﺎده از وﻗﻔـﻪ‪ ،‬ﻗﺒـﻞ از ﭘﺮوﺳـﻪ ي ﺑـﺎﻻ ﺑﻴـﺖ ﻓﻌـﺎل ﺳـﺎز وﻗﻔـﻪ ﻫـﺎ را ﺑـﺎ دﺳـﺘﻮر‬ ‫‬

‫)"‪ #asm("cli‬ﻏﻴﺮ ﻓﻌﺎل ﻛﻨﻴﻢ‪.‬‬

‫ﺑﺎ ﺧﻮاﻧﺪن ‪ UBRRH‬ﺑﻴﺖ ‪ URSEL‬ﺻﻔﺮ ﺧﻮاﻧﺪه ﺷﺪه و ﺑﺎ ﺧﻮاﻧﺪن ‪ UCSRC‬اﻳﻦ ﺑﻴﺖ ﻳﻚ ﺧﻮاﻧﺪه ﻣﻲ‬ ‫‬

‫ﺷﻮد‪.‬‬

‫  ‬
‫‪P a g e | 116‬‬
‫‪www.avr.ir‬‬

‫‪USART Baud Rate Registers‬‬ ‫‪.‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪UBRRH‬‬ ‫‪URSEL‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫]‪UBRR[11:8‬‬

‫‪UBRRL‬‬ ‫]‪UBRR[7:0‬‬

‫‪ :URSEL‬ﻫﻤﺎن ﻃﻮر ﻛﻪ ﮔﻔﺘﻪ ﺷﺪ ﺑﺮاي اﻧﺘﺨﺎب ﺑﻴﻦ ‪ UBRRH‬و ‪ UCSRC‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‪.‬‬

‫]‪ :UBRRH[7:4‬ﺑﺮاي ﻛﺎرﺑﺮدﻫﺎي آﻳﻨﺪه رزرو ﺷﺪه ﻫﺴﺘﻨﺪ و ﺑﺮاي ﺳﺎزﮔﺎري ﺑﺎ ﻗﻄﻌﺎت آﺗﻲ ﺑﺎﻳﺪ روي آن ﻫﺎ ﺻﻔﺮ‬

‫ﻧﻮﺷﺘﻪ ﺷﻮد‪.‬‬

‫]‪ :UBRR[11:0‬اﻳﻦ دوازده ﺑﻴﺖ ﺑﺮاي ﺗﻌﻴﻴﻦ ‪ Baud Rate‬راﺑﻂ ‪ USART‬ﻣﻮرد اﺳﺘﻔﺎده ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ‪ .‬ﺑﻪ اﻳﻦ‬

‫ﻣﻨﻈﻮر ﻣﻲ ﺗﻮان از رواﺑﻂ زﻳﺮ اﺳﺘﻔﺎده ﻧﻤﻮد‪:‬‬

‫‪ Mode‬ﻛﺎري‬ ‫ﻣﺤﺎﺳﺒﻪ ‪ Baud Rate‬از روي ‪UBRR‬‬ ‫ﻣﺤﺎﺳﺒﻪ ‪ UBRR‬از روي ‪Baud Rate‬‬

‫‪f osc‬‬ ‫‪f osc‬‬

‫آﺳﻨﻜﺮون )‪(U2X=0‬‬ ‫= ‪Baud‬‬ ‫= ‪UBRR‬‬ ‫‪−1‬‬
‫)‪16 ( UBRR + 1‬‬ ‫‪16 × Baud‬‬
‫آﺳﻨﻜﺮون ﺑﺎ ﺳﺮﻋﺖ دوﺑﺮاﺑﺮ‬
‫‪f osc‬‬ ‫‪f osc‬‬
‫= ‪Baud‬‬ ‫= ‪UBRR‬‬ ‫‪−1‬‬
‫)‪(U2X=1‬‬ ‫)‪8( UBRR + 1‬‬ ‫‪8 × Baud‬‬

‫‪f osc‬‬ ‫‪f osc‬‬

‫ﻋﻤﻠﻜﺮد ﺳﻨﻜﺮون‬ ‫= ‪Baud‬‬ ‫= ‪UBRR‬‬ ‫‪−1‬‬
‫)‪2( UBRR + 1‬‬ ‫‪2 × Baud‬‬

‫ﻣﻘﺪار ﺧﻄﺎي ﺑﻮﺟﻮد آﻣﺪه از راﺑﻄﻪ ي زﻳﺮ ﺑﺪﺳﺖ ﻣﻲ آﻳﺪ‪:‬‬

‫  ‬
‫‪P a g e | 117‬‬
‫‪www.avr.ir‬‬
‫‪BaudRate ClosestMatch‬‬
‫( = ]‪Error[%‬‬ ‫‪− 1) × 100%‬‬
‫‪BaudRate‬‬

‫ﻣﺜﺎل‪ :1‬ﺑﺎ ﻛﻼك ‪ 8‬ﻣﮕﺎﻫﺮﺗﺰ و ‪ Baud Rate = 2400‬در ‪ Mode‬آﺳﻨﻜﺮون ﻋﺎدي‪ ،‬ﻣﻘﺪار ‪ UBRR‬را ﺑﺪﺳﺖ آورﻳﺪ‪.‬‬

‫‪8000000‬‬
‫= ‪UBRR‬‬ ‫‪− 1 = 207.33 ⇒ UBRR = 207‬‬
‫‪16 × 2400‬‬

‫‪8000000‬‬
‫= ‪BaudRate‬‬ ‫‪= 2404‬‬
‫)‪16(207 + 1‬‬

‫‪2404‬‬
‫( = ]‪Error[%‬‬ ‫‪− 1) × 100% = 0.2%‬‬
‫‪2400‬‬

‫ﺑﺮاي ﺻﻔﺮ ﺷﺪن ﺧﻄﺎ ﻣﻲ ﺗﻮان از ﻛﺮﺳﻴﺘﺎل ‪ 7.3728‬ﻣﮕﺎﻫﺮﺗﺰ اﺳﺘﻔﺎده ﻧﻤﻮد اﮔﺮﭼﻪ ﺣﺪاﻛﺜﺮ ﺧﻄﺎي ﻗﺎﺑﻞ ﻗﺒﻮل ﺑﺮاي‬

‫اﻳﻦ وﺿﻌﻴﺖ ‪ 2‬درﺻﺪ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﻛﺮﻳﺴﺘﺎل ﻫﺎﻳﻲ ﻛﻪ ﻣﻲ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎده از آن ﻫﺎ ﺑﻪ ﺧﻄﺎي ‪ Baud Rate‬ﺻﻔﺮ رﺳﻴﺪ ‪،3.6864 ،1.8432‬‬ ‫‬

‫‪ 14.7456 ،11.0592 ،7.3728‬ﻣﻲ ﺑﺎﺷﻨﺪ‪.‬‬

‫ﻣﻘﺪار ‪ UBRR‬و ﺧﻄﺎﻫﺎي ﺣﺎﺻﻞ در ﻛﻠﻴﻪ ﺣﺎﻟﺖ ﻫﺎ در ﺻﻔﺤﺎت ‪ 166 -169‬از ﺑﺮﮔﻪ ي اﻃﻼﻋﺎﺗﻲ‬ ‫‬

‫‪ ATmega16‬ﻣﻮﺟﻮد ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﺗﻮاﺑﻊ ‪ USART‬در ‪CodeVision‬‬

‫اﻋﻼن اﻳﻦ ﺗﻮاﺑﻊ در ﻓﺎﻳﻞ ‪ stdio.h‬ﻗﺮار دارد و ﻗﺒﻞ از اﺳﺘﻔﺎده از آن ﻫﺎ ﺑﺎﻳﺪ ﺗﻨﻈﻴﻤﺎت اوﻟﻴﻪ ‪ USART‬اﻧﺠﺎم ﺷﻮد‪.‬‬

‫  ‬
‫‪P a g e | 118‬‬
‫‪www.avr.ir‬‬
‫ﺗﺎﺑﻊ )(‪ :getchar‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ روش ‪ Polling‬ﻣﻨﺘﻈﺮ ﻣﻲ ﻣﺎﻧﺪ ﺗﺎ ﭘﺮﭼﻢ ‪ RXC‬ﻳﻚ ﺷﺪه و ﺑﻌﺪ از آن ﻣﻘﺪار‬

‫‪ UDR‬را ﻣﻲ ﺧﻮاﻧﺪ‪.‬‬

‫ﺗﺎﺑﻊ )(‪ :putchar‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ روش ‪ Polling‬ﻣﻨﺘﻈﺮ ﻣﻲ ﻣﺎﻧﺪ ﺗـﺎ ﭘـﺮﭼﻢ ‪ UDRE‬ﻳـﻚ ﺷـﺪه و ﺑﻌـﺪ از آن ﻳـﻚ‬

‫ﻛﺎراﻛﺘﺮ را در ‪ UDR‬ﻛﭙﻲ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫ﻣﺜﺎل‪) :2‬ﻣﻴﻜﺮو اول ﺑﻌﺪ از ‪ 3‬ﺛﺎﻧﻴﻪ ﻋﺪد ‪ 7‬را ﺑﺮاي ﻣﻴﻜﺮو دوم ارﺳﺎل ﻣﻲ ﻛﻨﺪ و در ﻣﺪت اﻳﻦ ﺳﻪ ﺛﺎﻧﻴﻪ ﻣﻴﻜـﺮو دوم ﺑـﻪ‬

‫روش ‪ Polling‬ﻣﻨﺘﻈﺮ درﻳﺎﻓﺖ ﻳﻚ ﻛﺎراﻛﺘﺮ ﻣﻲ ﻣﺎﻧﺪ و ﭘﺲ از درﻳﺎﻓﺖ آن را در ‪ PORTA‬ﻣﻲ رﻳﺰد‪(.‬‬

‫ﺑﺮﻧﺎﻣﻪ ي ﻣﻴﻜﺮو اول‪:‬‬

‫>‪#include <mega16.h‬‬
‫>‪#include <delay.h‬‬
‫>‪#include <stdio.h‬‬
‫‪#define xtal 8000000‬‬

‫)‪void main(void‬‬
‫{‬

‫;‪UCSRA=0x00‬‬
‫‪UCSRB=0x08; // USART Transmitter: On‬‬
‫‪UCSRC=0x86; //8 Data, 1 Stop, No Parity‬‬
‫;‪UBRRH=0x00‬‬
‫‪UBRRL=0x33; // USART Baud rate: 9600‬‬

‫;)‪delay_ms(3000‬‬
‫;)‪putchar(7‬‬
‫;)‪while (1‬‬
‫}‬

‫  ‬
P a g e | 119
www.avr.ir
:‫ﺑﺮﻧﺎﻣﻪ ﻣﻴﻜﺮو دوم‬

#include <mega16.h>
#include <stdio.h>
#define xtal 8000000

void main(void)
{

char a;
DDRA=0xFF;
PORTA=0xFF;

UCSRA=0x00;
UCSRB=0x10; // USART Receiver: On
UCSRC=0x86; //8 Data, 1 Stop, No Parity
UBRRH=0x00;
UBRRL=0x33; // USART Baud rate: 9600

a = getchar(); // Polling RXC

PORTA = a;
while (1);

‫ در ﺻﻮرت ﻧﻴﺎز ﻣـﻲ ﺗـﻮان ﺑـﻪ‬.‫ ﺗﻨﻬﺎ ﺑﺮاي ﺻﺮﻓﻪ ﺟﻮﻳﻲ در وﻗﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ ﺑﺎﺷﻨﺪ‬USART ‫ﺗﻮاﺑﻊ ﺳﻄﺢ ﺑﺎﻻي‬

‫ ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺣﻠﻘﻪ ي اﺻﻠﻲ ﺑﺮﻧﺎﻣﻪ ي ﻣﻴﻜﺮو دوم را ﺑﻪ ﺻﻮرت زﻳﺮ ﻧﻴـﺰ ﻣـﻲ‬.‫ﺻﻮرت ﻣﺴﺘﻘﻴﻢ ﺑﺎ رﺟﻴﺴﺘﺮﻫﺎ ﻛﺎر ﻛﺮد‬

:‫ﺗﻮان ﻧﻮﺷﺖ‬

while(!(UCSRA&0x80));

  
‫‪P a g e | 120‬‬
‫‪www.avr.ir‬‬
‫;‪PORTA=UDR‬‬
‫;)‪while (1‬‬

‫ﺗﻮاﺑﻊ )(‪ puts‬و )(‪ :putsf‬اﻳﻦ ﺗﻮاﺑﻊ ﻳﻚ رﺷﺘﻪ را ﺗﻮﺳﻂ ‪ USART‬ﺑـﻪ ﭘـﻮرت ﺳـﺮﻳﺎل ارﺳـﺎل ﻣـﻲ ﻛﻨﻨـﺪ‪ .‬ﺗـﺎﺑﻊ‬

‫)(‪ puts‬رﺷﺘﻪ اي را ﻛﻪ در ‪ SRAM‬اﺳﺖ و ﺗﺎﺑﻊ )(‪ putsf‬رﺷﺘﻪ اي را ﻛﻪ در ‪ Flash‬اﺳﺖ ﺑﻪ ﺧﺮوﺟﻲ ارﺳﺎل ﻣـﻲ‬

‫ﻛﻨﺪ‪ .‬اﺳﺎس ﺗﻤﺎم ﺗﻮاﺑﻊ ﺳﻄﺢ ﺑﺎﻻي ‪ USART‬ﺗﻮاﺑﻊ )(‪ putchar‬و )(‪ getchar‬ﻣﻲ ﺑﺎﺷﻨﺪ و در اﻳﻨﺠﺎ ﻧﻴﺰ ﺑﺎ اﺳﺘﻔﺎده‬

‫از اﺷــﺎره ﮔــﺮ ‪ ،Y‬ﻛﺎراﻛﺘﺮﻫــﺎ ﭘﺸــﺖ ﺳــﺮ ﻫــﻢ ﺑﻮﺳــﻴﻠﻪ ي اﻳــﻦ ﺗﻮاﺑــﻊ ﺑــﻪ رﺟﻴﺴــﺘﺮ ‪ UDR‬ارﺳــﺎل ﻣــﻲ ﺷــﻮﻧﺪ‪.‬‬

‫اﻳﻦ ﺗﻮاﺑﻊ ﺑﻪ اﻧﺘﻬﺎي رﺷﺘﻪ ﻛﺎراﻛﺘﺮ ‪ (0x10) LF‬را اﺿﺎﻓﻪ ﻣﻲ ﻛﻨﻨﺪ‪.‬‬ ‫‬

‫ﻣﺜﺎل‪) :3‬رﺷﺘﻪ ﻫﺎي "‪ "Kavosh‬و "‪ "AVR‬ﺑﻪ ﭘﻮرت ﺳﺮﻳﺎل ارﺳﺎل ﻣﻲ ﺷﻮﻧﺪ‪(.‬‬

‫>‪#include <mega16.h‬‬
‫>‪#include <delay.h‬‬
‫>‪#include <stdio.h‬‬
‫‪#define xtal 8000000‬‬

‫;"‪flash char string1[7]="Kavosh‬‬

‫;"‪char string2[7]="AVR‬‬

‫)‪void main(void‬‬
‫{‬

‫
 ‬
‫‪P a g e | 121‬‬
‫‪www.avr.ir‬‬
‫;‪UCSRA=0x00‬‬
‫‪UCSRB=0x08; // USART Transmitter: On‬‬
‫‪UCSRC=0x86; //8 Data, 1 Stop, No Parity‬‬
‫;‪UBRRH=0x00‬‬
‫‪UBRRL=0x33; // USART Baud rate: 9600‬‬

‫;)‪putsf(string1‬‬
‫;)‪puts(string2‬‬
‫;)‪while (1‬‬
‫}‬

‫ﺗﺎﺑﻊ )(‪ :gets‬اﻳﻦ ﺗﺎﺑﻊ داراي دو آرﮔﻮﻣﺎن ﻧﺎم ﻣﺘﻐﻴﺮ و ﻃﻮل اﺳﺖ ﻛﻪ ﻣﻨﺘﻈﺮ ﻣﻲ ﻣﺎﻧﺪ ﺗﺎ ﻛﺎراﻛﺘﺮﻫﺎي درﻳﺎﻓﺘﻲ ﺑﻪ‬

‫اﻧﺪازه ي ﻃﻮل ﺷﺪه و ﺳﭙﺲ آن ﻫﺎ را داﺧﻞ ﻣﺘﻐﻴﺮ ﻣﻲ رﻳﺰد‪.‬‬

‫ﻣﺜﺎل ‪) :4‬ﻣﻴﻜﺮو اول ﺑﻌﺪ از ‪ 1‬ﺛﺎﻧﻴﻪ ﻋﺪد رﺷﺘﻪ ي ‪ Kavosh‬را ﺑﺮاي ﻣﻴﻜﺮو دوم ارﺳﺎل ﻣﻲ ﻛﻨﺪ و در ﻣﺪت اﻳﻦ ﻳﻚ‬

‫ﺛﺎﻧﻴﻪ ﻣﻴﻜﺮو دوم ﺑﻪ روش ‪ Polling‬ﻣﻨﺘﻈﺮ درﻳﺎﻓﺖ رﺷﺘﻪ ﻣﻲ ﻣﺎﻧﺪ و ﭘﺲ از درﻳﺎﻓﺖ آن را در ‪ LCD‬ﻧﻤﺎﻳﺶ ﻣﻲ‬

‫دﻫﺪ‪(.‬‬

‫ﺑﺮﻧﺎﻣﻪ ﻣﻴﻜﺮو ‪:1‬‬

‫>‪#include <mega16.h‬‬
‫>‪#include <delay.h‬‬
‫>‪#include <stdio.h‬‬
‫‪#define xtal 8000000‬‬

‫)‪void main(void‬‬
‫{‬

‫  ‬
P a g e | 122
www.avr.ir
UCSRA=0x00;
UCSRB=0x08; // USART Transmitter: On
UCSRC=0x86; //8 Data, 1 Stop, No Parity
UBRRH=0x00;
UBRRL=0x33; // USART Baud rate: 9600

delay_ms(1000);
putsf(" Kavosh ");
while (1);
}

:2 ‫ﺑﺮﻧﺎﻣﻪ ﻣﻴﻜﺮو‬

#include <mega16.h>
#include <stdio.h>
#include <lcd.h>
#define xtal 8000000

#asm
.equ __lcd_port=0x1B ;PORTA
#endasm

char a[10];

void main(void)
{

UCSRA=0x00;

  
‫‪P a g e | 123‬‬
‫‪www.avr.ir‬‬
‫‪UCSRB=0x10; // USART Receiver: On‬‬
‫‪UCSRC=0x86; //8 Data, 1 Stop, No Parity‬‬
‫;‪UBRRH=0x00‬‬
‫‪UBRRL=0x33; // USART Baud rate: 9600‬‬

‫;)‪lcd_init(16‬‬
‫;)(‪lcd_clear‬‬
‫;)"‪lcd_putsf("Waiting...‬‬
‫;)‪gets(a,10‬‬
‫;)(‪lcd_clear‬‬
‫;)‪lcd_puts(a‬‬
‫;)‪while(1‬‬

‫}‬

‫ﺗﺎﺑﻊ )(‪ :printf‬اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ رﺷﺘﻪ ي ﻗﺎﻟﺐ ﺑﻨﺪي ﺷﺪه را ﺑﻪ ﭘﻮرت ﺳﺮﻳﺎل ارﺳﺎل ﻣﻲ ﻛﻨﺪ‪ .‬ﻛﺎراﻛﺘﺮ ﻓﺮﻣﺖ ﻣﻲ ﺗﻮاﻧﺪ‬

‫ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﺑﺎﺷﺪ‪:‬‬

‫ﻧﻮع اﻃﻼﻋﺎت‬ ‫ﻛﺎراﻛﺘﺮ ﻓﺮﻣﺖ‬

‫ﻳﻚ ﻛﺎراﻛﺘﺮ‬ ‫‪%c‬‬

‫ﻋﺪد ﺻﺤﻴﺢ ﻋﻼﻣﺘﺪار در ﻣﺒﻨﺎي ‪10‬‬ ‫‪ %d‬و ‪%i‬‬

‫ﻋﺪد اﻋﺸﺎري ﺑﻪ ﺻﻮرت ﻧﻤﺎد ﻋﻠﻤﻲ‬ ‫‪ %e‬و ‪%E‬‬

‫ﻋﺪد اﻋﺸﺎري‬ ‫‪%f‬‬

‫رﺷﺘﻪ ي ﺧﺘﻢ ﺷﺪه ﺑﻪ ‪ Null‬واﻗﻊ در‬ ‫‪%s‬‬

‫  ‬
P a g e | 124
www.avr.ir
SRAM
‫ واﻗﻊ در‬Null ‫رﺷﺘﻪ ي ﺧﺘﻢ ﺷﺪه ﺑﻪ‬
%p
Flash
10 ‫ﻋﺪد ﺻﺤﻴﺢ ﺑﺪون ﻋﻼﻣﺖ در ﻣﺒﻨﺎي‬ %u

16 ‫ﻋﺪد ﺻﺤﻴﺢ ﺑﺪون ﻋﻼﻣﺖ در ﻣﺒﻨﺎي‬ %X ‫ و‬%x

% ‫ﻛﺎراﻛﺘﺮ‬ %%

(.‫ )ﻳﻚ رﺷﺘﻪ ي ﻗﺎﻟﺐ ﺑﻨﺪي ﺷﺪه را ﺑﻪ ﭘﻮرت ﺳﺮﻳﺎل ارﺳﺎل ﻣﻲ ﻛﻨﺪ‬:5 ‫ﻣﺜﺎل‬

#include <mega16.h>
#include <delay.h>
#include <stdio.h>
#define xtal 8000000

int a = 100;
char b = 'A';
float pi = 3.14;

void main(void)
{

UCSRA=0x00;
UCSRB=0x08; // USART Transmitter: On
UCSRC=0x86; //8 Data, 1 Stop, No Parity
UBRRH=0x00;

  
‫‪P a g e | 125‬‬
‫‪www.avr.ir‬‬
‫‪UBRRL=0x33; // USART Baud rate: 9600‬‬

‫;)‪printf("a=%d b=%c pi=%f",a,b,pi‬‬

‫;)‪while (1‬‬
‫}‬

‫ﺗﺎﺑﻊ )(‪ printf‬اﻳﻦ ﻗﺎﺑﻠﻴﺖ را دارد ﻛﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻃﻮل ﻣﻴﺪان و دﻗﺖ ﭘﺎراﻣﺘﺮ را ﺗﻌﻴﻴﻦ ﻛﻨﺪ ﻛﻪ اﻳﻦ اﻣﻜﺎن ﺑﻪ ﺻﻮرت‬

‫‪ %width.precision‬ﻗﺎﺑﻞ ﺗﻨﻈﻴﻢ ﻣﻲ ﺑﺎﺷﺪ‪ width .‬ﻧﺸﺎن دﻫﻨﺪه ي ﻃﻮل ﻳﻚ ﻋﺪد اﺳﺖ ﻛﻪ در ﻣﻮرد اﻋﺪاد ﺻﺤﻴﺢ‬

‫اﮔﺮ ﺑﻴﺸﺘﺮ از ﺗﻌﺪاد ارﻗﺎم ﺑﺎﺷﺪ ﺑﻪ اﻧﺪازه ي اﺿﺎﻓﻪ ﺟﺎي ﺧﺎﻟﻲ در ﺳﻤﺖ ﭼﭗ ﻋﺪد در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷـﻮد و ﭼﻨﺎﻧﭽـﻪ‬

‫ﻋﺪد اﻋﺸﺎري ﺑﺎﺷﺪ اﻳﻦ ﻣﻘﺪار ﺑﻴﺎﻧﮕﺮ ﻗﺴﻤﺖ ﺻﺤﻴﺢ و "‪ ".‬و ﻗﺴﻤﺖ اﻋﺸﺎري ﻣﻲ ﺑﺎﺷـﺪ‪ precision .‬ﻣﻘـﺪار دﻗـﺖ‬

‫اﻋﺸﺎر را ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ‪ a = 3.145‬ﺑﺎﺷﺪ دﺳﺘﻮر زﻳﺮ ‪ a=3.14‬را ﭼﺎپ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫;)‪printf("a=%4.2",a‬‬

‫ﻣﺸﺨﺼﺎت ﺗﺎﺑﻊ )(‪ printf‬در ﻛﺎﻣﭙﺎﻳﻠﺮ ‪ CodeVision‬را ﻣﻲ ﺗﻮان از ﻃﺮﻳﻖ‪:‬‬

‫‪Project/Configure/C Compiler/(s)printf Features‬‬

‫ﺗﻌﻴﻴﻦ ﻧﻤﻮد‪.‬‬

‫ﺗﺎﺑﻊ )(‪ :scanf‬ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﺪ ﻗﺎﻟﺐ اﻃﻼﻋﺎت درﻳﺎﻓﺘﻲ از ﭘﻮرت ﺳﺮﻳﺎل را ﺗﻌﻴﻴﻦ ﻧﻤﻮد‪ .‬ﻃﺮز ﻛﺎر اﻳﻦ‬

‫ﺗﺎﺑﻊ ﺑﻪ اﻳﻦ ﺻﻮرت اﺳﺖ‪:‬‬

‫  ‬
‫‪P a g e | 126‬‬
‫‪www.avr.ir‬‬
‫;)ﻋﺒﺎرت دوم‪",‬ﻋﺒﺎرت اول"(‪scanf‬‬

‫ﻋﺒﺎرت دوم ﻧﺎم ﻣﺘﻐﻴﺮي اﺳﺖ ﻛﻪ رﺷﺘﻪ ي درﻳﺎﻓﺘﻲ در آن ﻗﺮار ﻣﻲ ﮔﻴﺮد و ﻋﺒﺎرت اول ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﻗﺎﻟﺐ داده ي‬

‫درﻳﺎﻓﺘﻲ ﺑﻪ ﭼﻪ ﺻﻮرت ﺑﺎﺷﺪ‪ .‬ﺑﻪ ﺻﻮرت ﭘﻴﺶ ﻓﺮض ﻃﻮل رﺷﺘﻪ ي درﻳﺎﻓﺘﻲ ‪ 256‬ﻛﺎراﻛﺘﺮ اﺳﺖ اﻣﺎ ﺑـﺎ اﻓـﺰودن ﻃـﻮل‬

‫ﻗﺒﻞ از ﻛﺎراﻛﺘﺮ ﻓﺮﻣﺖ ﻣﻲ ﺗﻮان آن را ﺑﻪ ﻣﻘﺪار دﻟﺨﻮاه ﻛﺎﻫﺶ داد‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪:‬‬

‫)‪scanf("%10d",a‬‬
‫‪ 10‬ﻛﺎراﻛﺘﺮ را از ورودي ﺧﻮاﻧﺪه و در ﻣﺘﻐﻴﺮ ‪ a‬ذﺧﻴﺮه ﻣﻲ ﻛﻨﺪ‪.‬‬

‫ﻣﺸﺨﺼﺎت ﺗﺎﺑﻊ )(‪ scanf‬را ﻫﻤﺎﻧﻨﺪ )(‪ printf‬ﻣﻲ ﺗﻮان از‪:‬‬

‫‪Project/Configure/C Compiler/(s)scanf Features‬‬

‫ﺗﻨﻈﻴﻢ ﻧﻤﻮد‪.‬‬

‫ﺗﻮﺟﻪ‪ :‬ﺗﻮاﺑﻊ )(‪ printf‬و )(‪ scanf‬ﺣﺠﻢ زﻳﺎدي از ﺣﺎﻓﻈﻪ ي ‪ Flash‬را ﻣﺼﺮف ﻛﺮده و ﺳﺮﻋﺖ اﺟﺮاي آن ﻫﺎ‬

‫ﭘﺎﻳﻴﻦ اﺳﺖ‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ ﺗﺎ ﺣﺪ اﻣﻜﺎن از آن ﻫﺎ اﺳﺘﻔﺎده ﻧﻜﺮده و در ﺻﻮرت ﻟﺰوم ﻣﺸﺨﺼﺎت آن ﻫﺎ را ﺑﻪ ﺳﺎده ﺗﺮﻳﻦ‬

‫ﺣﺎﻟﺖ )‪ int‬و ‪ (int, width‬ﺗﻨﻈﻴﻢ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫  ‬
‫‪P a g e | 127‬‬
‫‪www.avr.ir‬‬
‫اﺳﺘﻔﺎده از ﭘﻮرت ﺳﺮﻳﺎل در وﺿﻌﻴﺖ ﺳﻨﻜﺮون‬

‫ﺑﺎ ﻳﻚ ﻛﺮدن ﺑﻴﺖ ‪ UMSEL‬از رﺟﻴﺴﺘﺮ ‪ UCSRC‬ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ در اﻳﻦ ﺣﺎﻟﺖ ﻗﺮار ﻣﻲ ﮔﻴﺮد و اﺗﺼﺎﻻت ﺳﺨﺖ‬

‫اﻓﺰاري ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫‪TxD‬‬ ‫‪TxD‬‬
‫‪RxD‬‬ ‫‪RxD‬‬
‫‪XCK‬‬ ‫‪XCK‬‬

‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﮔﻔﺘﻪ ﺷﺪ ﺑﻮﺳﻴﻠﻪ ي ﺑﻴﺖ ﻫﺎي ‪ UCPOL‬ﻣﻲ ﺗﻮان ﻟﺒﻪ ي ﻧﻤﻮﻧﻪ ﺑﺮداري و ﺗﻐﻴﻴﺮ ﺑﺮ اﺳﺎل ﻛﻼك را ﺗﻌﻴﻴﻦ‬

‫ﻧﻤﻮد‪ .‬ﻣﺴﺌﻠﻪ اي ﻛﻪ ﺑﺎﻳﺪ در ‪ Mode‬ﺳﻨﻜﺮون رﻋﺎﻳﺖ ﺷﻮد اﻳﻦ اﺳﺖ ﻛﻪ داده ﺑﺎﻳﺪ در ﺧﻼف ﻟﺒﻪ اي ﻛـﻪ در ﻓﺮﺳـﺘﻨﺪه‬

‫ارﺳﺎل ﺷﺪه اﺳﺖ‪ ،‬در ﮔﻴﺮﻧﺪه ﻧﻤﻮﻧﻪ ﺑﺮداري ﺷﻮد ﻳﻌﻨﻲ اﮔﺮ داده در ﻟﺒﻪ ي ﭘﺎﻳﻴﻦ روﻧﺪه ارﺳﺎل ﺷﺪه ﺑﺎﺷﺪ در ﻟﺒﻪ ي ﺑﺎﻻ‬

‫روﻧﺪه درﻳﺎﻓﺖ ﺷﻮد‪.‬‬

‫وﺿﻌﻴﺖ ‪Multi-processor‬‬

‫ﺑﺮاي اﻳﺠﺎد ﺷﺒﻜﻪ ﺑﻴﻦ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮﻫﺎ از اﻳﻦ ‪ Mode‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‪ .‬ﻣﻌﻤﻮﻻ ﻳﻚ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ﺑﻪ ﻋﻨﻮان ‪ Master‬و‬

‫ﺑﻘﻴﻪ ﺑﻪ ﻋﻨﻮان ‪ Slave‬اﻳﻔﺎي ﻧﻘﺶ ﻣﻲ ﻛﻨﻨﺪ‪.‬‬

‫  ‬
‫‪P a g e | 128‬‬
‫‪www.avr.ir‬‬

‫‪TxD‬‬

‫‪Master MCU‬‬
‫‪RxD‬‬

‫‪Slave 1‬‬
‫‪Slave 2‬‬
‫‪Slave 3‬‬
‫‪Slave 4‬‬

‫ﺑﺎ ﻳﻚ ﻛﺮدن ﺑﻴﺖ ‪ MPCM‬از رﺟﻴﺴﺘﺮ ‪ UCSRA‬ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ وارد اﻳـﻦ ‪ Mode‬ﺧﻮاﻫـﺪ ﺷـﺪ‪ .‬ﺑـﺮاي ﻣﺒﺎدﻟـﻪ ي‬

‫اﻃﻼﻋﺎت ﺑﻴﻦ ‪ Master‬و ‪ ،Slave‬ﺑﺎﻳﺪ ‪ Slave‬ﺗﻮﺳﻂ ‪ Master‬آدرس دﻫﻲ ﺷﻮد ﻛﻪ ﺑﺪﻳﻦ ﻣﻨﻈﻮر از ﺑﻴﻦ ﻧﻬـﻢ داده‬

‫)‪(TXB8‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‪ .‬آدرس ‪ Slave‬ﻫﺎ ﻗﺒﻼ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺗﻌﻴﻴﻦ ﺷﺪه و ﺗﻤﺎم آن ﻫﺎ ﺑﺎﻳﺪ ﺑﺎ ﻳـﻚ ﺷـﺪن‬

‫ﺑﻴﺖ ‪ MPCM‬در ‪ Mode‬ﭼﻨﺪ ﭘﺮدازﻧﺪه اي ﻗﺮار ﺑﮕﻴﺮﻧﺪ و ﻣﻨﺘﻈﺮ درﻳﺎﻓﺖ آدرس از ‪ Master‬ﺑﻤﺎﻧﻨﺪ‪ .‬ﺑـﺮاي ﺷـﺮوع‬

‫ارﺗﺒﺎط ‪ Master‬ﻳﻚ ﻓﺮﻳﻢ اﻃﻼﻋـﺎﺗﻲ ‪ 9‬ﺑﻴﺘـﻲ ﻛـﻪ ﻫﺸـﺖ ﺑﻴـﺖ آن ﺷـﺎﻣﻞ آدرس و ﺑﻴـﺖ ﻧﻬـﻢ آن ﻳـﻚ اﺳـﺖ ﺑـﻪ‬

‫ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮﻫﺎ ارﺳﺎل ﻣﻲ ﻛﻨﺪ‪ .‬ﻳﻚ ﺑﻮدن ﺑﻴﺖ ﻧﻬﻢ ﺑﺎﻋﺚ ﻣﻲ ﺷﻮد ﻛﻪ رﻓﺘﺎر ‪ Slave‬ﻫﺎ ﺑﺎ داده ي درﻳﺎﻓﺘﻲ ﻫﻤﺎﻧﻨﺪ ﻳﻚ‬

‫آدرس ﺑﻮده و آن را ﺑﺎ آدرس ﺧﻮد ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪ‪ Slave .‬اﻧﺘﺨﺎب ﺷﺪه ﺑﻴﺖ ‪ MPCM‬ﺧﻮد را ﭘـﺎك ﻛـﺮده و ﻣﻨﺘﻈـﺮ‬

‫درﻳﺎﻓﺖ داده ﻣﻲ ﻣﺎﻧﺪ و ﺑﻘﻴﻪ ‪ Slave‬ﻫﺎ ﻛﻪ ﺑﻴﺖ ‪ MPCM‬آن ﻫﺎ ﻳﻚ اﺳﺖ ﻫﻤﭽﻨﺎن ﻣﻨﺘﻈﺮ درﻳﺎﻓﺖ آدرس ﻣﻲ ﻣﺎﻧﻨﺪ‪.‬‬

‫در اﻳﻦ زﻣﺎن ‪ Slave‬اﻧﺘﺨﺎب ﺷﺪه ﺑﺎ ارﺳﺎل ﭘﻴﺎﻣﻲ ﺑﺮاي ‪ Master‬ﺗﺼﺪﻳﻖ ﻣﻲ ﻓﺮﺳﺘﻨﺪ ﺗﺎ ﺑﻴﺖ ﻧﻬﻢ ﺧﻮد را ﺻﻔﺮ ﻛﻨـﺪ‬

‫ﺗﺎ در در ارﺳﺎل ﺑﻌﺪي ﺑﻪ اﺷﺘﺒﺎه ‪ Slave‬دﻳﮕﺮي اﻧﺘﺨﺎب ﻧﺸﻮد‪ .‬ﭘﺲ از اﺗﻤﺎم ارﺳﺎل داده ‪ Master‬ﻣﺠﺪدا ﺑﻪ ﻧﺸﺎﻧﻪ ي‬

‫آدرس دﻫﻲ ﺑﻴﺖ ﻧﻬﻢ ﺧﻮد را ﻳﻚ ﻛﺮده و آدرس دﻳﮕﺮي را ارﺳﺎل ﻣﻲ ﻛﻨﺪ‪ Slave .‬ﻗﺒﻞ ﻛﻪ ﺑﻴﺖ ‪ MPCM‬آن ﺻﻔﺮ‬

‫ﺷﺪه ﺑﻮد ﻣﺠﺪدا اﻳﻦ ﺑﻴﺖ را ﻳﻚ ﻛﺮده و آﻣﺎده ي درﻳﺎﻓﺖ آدرس ﻣﻲ ﺷﻮد‪.‬‬

‫  ‬
‫‪P a g e | 129‬‬
‫‪www.avr.ir‬‬

‫* ﭘﺮوژه ‪ :12‬ﭘﻮرت ﺳﺮﻳﺎل در وﻳﮋوال ﺑﻴﺴﻴﻚ‬

‫ارﺗﺒﺎط ﺑﻴﻦ ﻛﺎﻣﭙﻴﻮﺗﺮ و ‪ PC‬ﺑﻪ ﺻﻮرت ‪ Null-Modem‬ﺑﻮده و ﻫﻤﺎﻧﻄﻮر ﻛﻪ اﺷﺎره ﺷﺪ ﺑﺮاي ﺗﻐﻴﻴﺮ ﺳﻄﺢ ‪RS-‬‬

‫‪ 232‬ﺑﻪ ‪ TTL‬ﻣﻄﺎﺑﻖ ﺷﻤﺎﺗﻴﻚ اﺑﺘﺪاي ﻓﺼﻞ از ﻣﺒﺪل ‪ MAX232‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‪.‬‬

‫ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ ﭘﻮرت ﻫﺎي ‪ COM‬در وﻳﮋوال ﺑﻴﺴﻴﻚ ﻣﻲ ﺗﻮان از ﻛﻨﺘﺮل ‪ MSComm‬ﻛﻪ ﻫﻤﺮاه ﻛﺎﻣﭙﺎﻳﻠﺮ وﺟﻮد‬

‫دارد اﺳﺘﻔﺎده ﻧﻤﻮد‪ .‬اﻳﻦ ﻛﻨﺘﺮل‪ ،‬ارﺗﺒﺎط دﻫﻲ ﭘﻮرت ﺳﺮﻳﺎل را از ﻃﺮﻳﻖ ﻓﺎﻳﻞ ‪ mscomm32.ocx‬ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ‬

‫ﻓﺮاﻫﻢ ﻣﻲ ﻛﻨﺪ‪ .‬ﺑﺮاي آﺷﻨﺎﻳﻲ ﺑﺎ اﻳﻦ ‪ OCX‬ﻣﺮاﺣﻞ زﻳﺮ را اﻧﺠﺎم دﻫﻴﺪ‪:‬‬

‫ﻳﻚ ﭘﺮوژه ي ﺟﺪﻳﺪ از ﻧﻮع ‪ Standard EXE‬ﺑﺴﺎزﻳﺪ‪:‬‬ ‫‪.1‬‬

‫  ‬
‫‪P a g e | 130‬‬
‫‪www.avr.ir‬‬
‫از ﻃﺮﻳﻖ ﻣﻨﻮي اﺻﻠﻲ ﺑﺎ ﻛﻠﻴﻚ ﺑﺮ روي ﮔﺰﻳﻨﻪ ي ‪ Project‬ﻣﻮرد ‪ Component‬را اﻧﺘﺨﺎب ﻛﻨﻴﺪ و در ﻛﺎدر‬ ‫‪.2‬‬

‫ﺣﺎﺻﻞ ﮔﺰﻳﻨﻪ ي ‪ Microsoft Comm Control 6.0‬را ﻋﻼﻣﺖ زده و دﻛﻤﻪ ي ‪ OK‬را ﻛﻠﻴﻚ ﻛﻨﻴﺪ‪.‬‬

‫آﻳﻜﻮن ﻛﻨﺘﺮل ‪ MScomm‬را از ‪ Toolbox‬روي ﻓﺮم ﻗﺮار دﻫﻴﺪ‪:‬‬ ‫‪.3‬‬

‫
 ‬
P a g e | 131
www.avr.ir
.‫ ﻓﺮم ﻗﻄﻌﻪ ﻛﺪ زﻳﺮ را وارد ﻛﻨﻴﺪ‬Load ‫در روﻳﺪاد‬ .6

Private Sub Form_Load()

MSComm1.Settings = "9600,N,8,1"
MSComm1.CommPort = 1
MSComm1.PortOpen = True
MSComm1.Output = "Test" + Chr(16)

End Sub

‫ ﺑﺪون ﺑﻴﺖ‬،Baud Rate=1200 ‫ ﺑﺎ‬Test ‫ رﺷﺘﻪ ي‬.‫ ﺑﺮﻧﺎﻣﻪ را اﺟﺮا ﻛﻨﻴﺪ‬F5 ‫ﺑﺎ ﻓﺸﺮدن دﻛﻤﻪ ي‬ .٧

.‫ ارﺳﺎل ﺧﻮاﻫﺪ ﺷﺪ‬COM1 ‫ ﺑﻴﺖ داده و ﻳﻚ ﺑﻴﺖ ﭘﺎﻳﺎن ﺑﻪ‬8 ،‫ﺗﻮازن‬

  
‫‪P a g e | 132‬‬
‫‪www.avr.ir‬‬

‫ﭘﺮوژه ‪ :13‬ارﺗﺒﺎط دﻫﻲ ‪ USB‬ﺑﺎ ‪RS232‬‬

‫ﺷﻤﺎﺗﻴﻚ‪:‬‬

‫  ‬
‫‪P a g e | 133‬‬
‫‪www.avr.ir‬‬

‫‪ Package‬ﭼﻴﭗ ‪ FT232BM‬از ﻧﻮع ‪ LQFP‬ﺑﻮده و ‪ Pin out‬آن ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫ﭘﺲ از ﭘﻴﻜﺮﺑﻨﺪي ﺳﺨﺖ اﻓﺰاري ﻣﺪار ﻧﻴﺎز ﺑﻪ دراﻳﻮر دارد ﻛﻪ ﺗﻨﻈﻴﻢ آن در ‪ Win XP‬ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪:‬‬

‫دراﻳﻮر ﺳﺨﺖ اﻓﺰار را ﻣﻲ ﺗﻮاﻧﻴﺪ از آدرس زﻳﺮ درﻳﺎﻓﺖ ﻧﻤﺎﻳﻴﺪ‪:‬‬ ‫‪(1‬‬

‫‪http://www.ftdichip.com/Drivers/VCP.htm‬‬

‫ﻓﺎﻳﻞ ﺑﺎرﮔﺬاري ﺷﺪه را در ﻳﻚ ﻣﺴﻴﺮ دﻟﺨﻮاه ‪ Unzip‬ﻛﻨﻴﺪ‪) .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪(E:\CDM 2.00.00 :‬‬ ‫‪(2‬‬

‫  ‬
‫‪P a g e | 134‬‬
‫‪www.avr.ir‬‬
‫ﺳﺨﺖ اﻓﺰار ﺧﻮد را ﺑﻪ ﻳﻜـﻲ از ﻛﺎﻧﻜﺘﻮرﻫـﺎي ‪ USB‬وﺻـﻞ ﻛﻨﻴـﺪ‪ .‬در اﻳـﻦ ﺣﺎﻟـﺖ ﭘﻴـﺎم ‪Found New‬‬ ‫‪(3‬‬

‫‪ Hardware‬ﻇﺎﻫﺮ ﺷﺪه و ﭘﺲ از آن ﻛﺎدر ﻣﺤﺎوره ي ‪ Found New Hardware Wizard‬ﻧﻤﺎﻳﺶ داده ﻣﻲ‬

‫ﺷﻮد‪ .‬ﮔﺰﻳﻨﻪ ي دوم را اﻧﺘﺨﺎب ﻛﺮده و ‪ Next‬را ﻛﻠﻴﻚ ﻛﻨﻴﺪ‪.‬‬

‫در ﻛﺎدر ﺣﺎﺻﻞ ﻣﺴﻴﺮ دراﻳﻮر را وارد ﻛﺮده و ﺑﺮ روي ‪ Next‬ﻛﻠﻴﻚ ﻧﻤﺎﻳﻴﺪ‪.‬‬ ‫‪(4‬‬

‫  ‬
‫‪P a g e | 135‬‬
‫‪www.avr.ir‬‬

‫در ﺻﻮرﺗﻲ ﻛﻪ وﻳﻨﺪوز ﺑﻪ ﻧﺤﻮي ﭘﻴﻜﺮﺑﻨﺪي ﺷﺪه ﺑﺎﺷﺪ ﻛـﻪ در ﺻـﻮرت ﻧﺼـﺐ دراﻳﻮرﻫـﺎي آزﻣـﺎﻳﺶ ﻧﺸـﺪه ﺗﻮﺳـﻂ‬

‫ﻣﺎﻳﻜﺮوﺳﺎﻓﺖ‪ ،‬ﭘﻴﻐﺎﻣﻲ داده ﺷﻮد اﺧﻄﺎر زﻳﺮ اﻳﺠﺎد ﺷﺪه و در اﻳﻦ ﺣﺎﻟﺖ ﺑﺎ ﭼﺸﻢ ﭘﻮﺷﻲ از اﺧﻄﺎر ﺑﺮ روي ‪Continue‬‬

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

‫  ‬
‫‪P a g e | 136‬‬
‫‪www.avr.ir‬‬

‫ﻛﺎدر زﻳﺮ ﻧﻤﺎﻳﺶ داده ﺷﺪه و ﻧﺸﺎن ﻣﻲ دﻫﺪ ﻛﻪ وﻳﻨﺪوز در ﺣﺎل ﻛﭙﻲ ﻧﻤﻮدن ﻓﺎﻳﻞ ﻫﺎي ﻣﻮرد ﻧﻴﺎز ﻣﻲ ﺑﺎﺷﺪ‪.‬‬ ‫‪(5‬‬

‫  ‬
‫‪P a g e | 137‬‬
‫‪www.avr.ir‬‬
‫وﻳﻨﺪوز ﭘﻴﺎﻣﻲ ﻣﺒﻨﻲ ﺑﺮ اﺗﻤﺎم ﻣﻮﻓﻘﻴﺖ آﻣﻴﺰ ﻧﺼﺐ ﺳﺨﺖ اﻓﺰار داده و ﺑﺎ ﻛﻠﻴﻚ ﺑﺮ روي ‪ Finish‬اﻳﻦ ﭘﺮوﺳﻪ‬ ‫‪(6‬‬

‫ﺗﻤﺎم ﻣﻲ ﺷﻮد‪.‬‬

‫‪) Device Manager‬در ﻣﺴﻴﺮ ‪ Control Panel\System‬ﺑﺮ روي زﺑﺎﻧﻪ ي ‪ (Hardware‬را ﺑﺎز ﻛﻨﻴﺪ‬ ‫‪(7‬‬

‫و درﺧﺖ ‪ Port‬را ﺑﺎ ﻛﻠﻴﻚ ﺑﺮ روي ]‪ [+‬ﻛﻨﺎر آن ﺑﺴﻂ دﻫﻴﺪ‪ .‬ﻣﻼﺣﻈﻪ ﻣﻲ ﻛﻨﻴﺪ ﻛﻪ ‪ COM‬ﻣﺠﺎزي ﺑﺎ ﻧﺎم ‪ COMx‬ﺑﻪ‬

‫ﻟﻴﺴﺖ اﻓﺰوده ﺷﺪه اﺳﺖ‪ .‬از اﻳﻦ ﭘﺲ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻣﻄﺎﺑﻖ ﭘﺮوژه ي ‪ 12‬اﻃﻼﻋﺎت را ﺑﻪ ‪ COMx‬ارﺳﺎل ﻳﺎ درﻳﺎﻓﺖ ﻛﺮده‬

‫و اﻃﻼﻋﺎت ارﺳﺎل ﺷﺪه را در ﺧﺮوﺟﻲ ﻣﺪار درﻳﺎﻓﺖ ﻛﻨﻴﺪ‪.‬‬

‫  ‬
P a g e | 138
www.avr.ir

  
‫‪P a g e | 139‬‬
‫‪www.avr.ir‬‬

‫‪(TWI) I2C Bus‬‬

‫اﺳﺘﺎﻧﺪارد ‪ I2C‬در اواﻳﻞ دﻫﻪ ‪ 1980‬ﺗﻮﺳﻂ ﺷﺮﻛﺖ ‪ Philips‬ﻃﺮاﺣﻲ ﺷﺪ‪ .‬در اﺑﺘـﺪا اﻳـﻦ ﭘﺮوﺗﻜـﻞ ﺑـﻪ ﻣﻨﻈـﻮر اﻳﺠـﺎد‬

‫روﺷﻲ ﺳﺎده ﺑﺮاي اﻳﺠﺎد ارﺗﺒﺎط ﭘﺮدازﻧﺪه ﺑﺎ ﺗﺮاﺷﻪ ﻫﺎي ﺟﺎﻧﺒﻲ در ﻳﻚ دﺳﺘﮕﺎه ﺗﻠﻮﻳﺰﻳﻮن اﺑﺪاع ﺷﺪ‪.‬‬

‫‪ I2C‬ﻃﺒﻖ ﺗﻌﺮﻳﻒ ﺷﺮﻛﺖ ﻓﻴﻠﻴﭙﺲ ﻣﺨﻔﻒ ‪ Inter-IC‬ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﺑﻴﺎﻧﮕﺮ ﻫﺪف آن ﻳﻌﻨﻲ ﻓـﺮاﻫﻢ آوردن ﻳـﻚ ﻟﻴﻨـﻚ‬

‫ارﺗﺒﺎﻃﻲ ﺑﻴﻦ ﻣﺪارات ﻣﺠﺘﻤﻊ ﻣﻲ ﺑﺎﺷﺪ‪ .‬اﻣﺮوزه اﻳﻦ ﭘﺮوﺗﻜﻞ ﺑﻪ ﺻـﻮرت ﻋﻤـﻮﻣﻲ در ﺻـﻨﻌﺖ ﭘﺬﻳﺮﻓﺘـﻪ ﺷـﺪه اﺳـﺖ و‬

‫ﻛﺎرﺑﺮد آن از ﺳﻄﺢ ﺗﺠﻬﻴﺰات ﺻﻮﺗﻲ و ﺗﺼﻮﻳﺮي ﻧﻴﺰ ﻓﺮاﺗﺮ رﻓﺘﻪ اﺳﺖ‪ .‬ﺑﻪ ﮔﻮﻧﻪ اي ﻛﻪ اﻣﺮوزه در ﺑـﻴﺶ از ‪ 1000‬ﻧـﻮع‬

‫‪IC‬ﻣﺨﺘﻠﻒ ﺑﻪ ﻛﺎر ﮔﺮﻓﺘﻪ ﺷﺪه اﺳﺖ‪ I2C .‬ﻓﻀﺎ را ﺣﻔﻆ ﻣﻲ ﻛﻨﺪ و ﺑﺎﻋﺚ ﻛﺎﻫﺶ ﭼﺸﻤﮕﻴﺮ ﻫﺰﻳﻨﻪ ي ﻧﻬﺎﻳﻲ ﻣﻲ ﺷـﻮد‪.‬‬

‫دو ﺧﻂ ارﺗﺒﺎﻃﻲ ﺑﻪ ﻣﻌﻨﻲ ‪ Track‬ﻫﺎي ﻣﺴﻲ ﻛﻤﺘﺮ و در ﻧﺘﻴﺠﻪ ﺑﺮد ﻣﺪار ﭼﺎﭘﻲ ﻛﻮﭼﻜﺘﺮ و ﺗﺴﺖ ﻋﻴﺐ ﻳﺎﺑﻲ ﺳﺮﻳﻌﺘﺮ و‬

‫راﺣﺘﺘﺮ ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﻋﻼوه ﺑﺮ اﻳﻦ در اﻏﻠﺐ ﻣﻮارد ﺣﺴﺎﺳﻴﺖ ﻣﺪار اﻟﻜﺘﺮوﻧﻴﻜﻲ ﻧﺴﺒﺖ ﺑﻪ ﺗﺪاﺧﻞ اﻣﻮاج اﻟﻜﺘﺮوﻣﻐﻨﺎﻃﻴﺴـﻲ‬

‫و ﺗﺨﻠﻴﻪ ي اﻟﻜﺘﺮوﺳﺘﺎﺗﻴﻜﻲ ﻛﺎﻫﺶ ﻣﻲ ﻳﺎﺑﺪ‪.‬‬

‫ﺑﺮﺧﻲ از وﻳﮋﮔﻲ ﻫﺎي ﺑﺎس ‪I2C‬‬

‫‪ I2C .1‬ﻳﻚ ﭘﺮوﺗﻜﻞ ﺳﺮﻳﺎل ﺳﻨﻜﺮون ﻣﻲ ﺑﺎﺷﺪ و ﻛﻼك آن ﻣﻲ ﺗﻮاﻧﺪ ﺑﺪون از دﺳﺖ رﻓﺘﻦ اﻃﻼﻋﺎت ﺗﻐﻴﻴﺮ ﻛﻨﺪ‪.‬‬

‫‪ .2‬آدرس دﻫﻲ ‪ 7‬ﺑﻴﺘﻲ )‪ 127‬وﺳﻴﻠﻪ ي ﻣﺘﻔﺎوت ﺑﺮ روي ﺑﺎس( و ﻧﻴﺰ آدرس دﻫـﻲ ‪ 10‬ﺑﻴﺘـﻲ در وﻳـﺮاﻳﺶ ﺟﺪﻳـﺪ اﻳـﻦ‬

‫اﺳﺘﺎﻧﺪارد )‪ 1024‬وﺳﻴﻠﻪ ﺑﺮ روي ﺑﺎس(‪.‬‬

‫  ‬
‫‪P a g e | 140‬‬
‫‪www.avr.ir‬‬
‫‪ .3‬ﺑﺎس ﺗﻨﻬﺎ ﺑﻪ دو ﺧﻂ ‪ SCL‬و ‪ SDA‬ﻧﻴﺎز دارد‪ .‬ﺑﺮ روي ‪ SCL‬ﺗﻮﺳﻂ ‪ Master‬ﻛﻼك اﻳﺠﺎد ﻣـﻲ ﺷـﻮد و ‪SDA‬‬

‫ﺧﻂ ‪ Data‬ي دو ﻃﺮﻓﻪ ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﺟﻬﺖ آن ﺗﻮﺳﻂ ‪ Master‬ﻛﻨﺘﺮل ﻣﻲ ﺷﻮد‪.‬‬

‫‪ .4‬ﺑﺮ روي ﺑﺎس اﻃﻼﻋﺎت ‪ 8‬ﺑﻴﺘﻲ ﺑﻪ ﺻﻮرت دو ﺟﻬﺘﻪ ﺑﺎ ﻧﺮخ ارﺳﺎل ﺣﺪاﻛﺜﺮ ‪ 400‬ﻛﻴﻠﻮﺑﻴﺖ ﺑﺮ ﺛﺎﻧﻴـﻪ‪) .‬و ‪ 3.4‬ﻣﮕﺎﺑﻴـﺖ‬

‫ﺑﺮ ﺛﺎﻧﻴﻪ در وﺿﻌﻴﺖ ‪(High Speed‬‬

‫‪ .5‬ﺗﻮاﻧﺎﻳﻲ دراﻳﻮ ﻧﻤﻮدن ﺗﺎ ‪ 400‬ﭘﻴﻜﻮﻓﺎراد ﻇﺮﻓﻴﺖ ﺧﺎزﻧﻲ ﺗﺎ ﻓﺎﺻﻠﻪ ي ﺣﺪاﻛﺜﺮ ‪ 4‬ﻣﺘﺮ‪.‬‬

‫‪ .6‬ﺣﺬف ‪ Spike‬ﻫﺎي ﻧﺎﺧﻮاﺳﺘﻪ از ﺧﻂ ‪ SDA‬ﺑﺎ اﺳﺘﻔﺎده از ﻓﻴﻠﺘﺮ ﻣﻮﺟﻮد در ﭼﻴﭗ‪ ،‬ﺑﻪ ﻃـﻮري ﻛـﻪ ﺳـﻴﮕﻨﺎل ﻫـﺎي‬

‫ورودي ﻛﻪ ﻋﺮض آن ﻫﺎ ﻛﻤﺘﺮ از ‪ 50‬ﻧﺎﻧﻮﺛﺎﻧﻴﻪ ﺑﺎﺷﺪ‪ ،‬ﺣﺬف ﻣﻲ ﺷﻮﻧﺪ‪.‬‬

‫‪ .7‬ﭘﻴﻦ ﻫﺎي ‪ SDA‬و ‪ SCL‬ﻣﺠﻬﺰ ﺑﻪ ﻛﻨﺘﺮل ﻛﻨﻨﺪه ي ‪ Slew Rate‬ﻣﻲ ﺑﺎﺷﻨﺪ ﻛﻪ ﻛﺎراﻳﻲ ﺑﺎس ‪ I2C‬را در ﻓﺮﻛـﺎﻧﺲ‬

‫ﻫﺎي ﺑﺎﻻ )ﻧﺰدﻳﻚ ‪ 400‬ﻛﻴﻠﻮﻫﺮﺗﺰ( ﺑﻬﺒﻮد ﻣﻲ ﺑﺨﺸﺪ‪ .‬ﻋﻤﻠﻜﺮد ﻛﻨﺘﺮل ﻛﻨﻨﺪه ﺑﻪ اﻳـﻦ ﺻـﻮرت اﺳـﺖ ﻛـﻪ ﻟﺒـﻪ ﻫـﺎي ﺗﻴـﺰ‬

‫ﺳﻴﮕﻨﺎل را ﺗﺎ ﺣﺪودي ﺻﺎف ﻛﺮده و در واﻗﻊ ﺑﺎ ﺣﺬف ﻫﺎرﻣﻮﻧﻴﻚ ﻫﺎي ﺑﺎﻻ ﺑﻪ ﻛﺎﻫﺶ ‪ EMI‬ﻛﻤﻚ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫‪ .8‬ﻋﺪم ﻧﻴﺎز ﺑﻪ ﻃﺮاﺣﻲ ﻣﺪار واﺳﻂ و راه اﻧﺪازي ﺑﺎس ﺗﻨﻬﺎ ﺑﺎ دو ﻣﻘﺎوﻣﺖ زﻳﺮا ﻛﻪ ﻣﺪار ﻛﻨﺘﺮل ﺑﺎس ﺑﻪ ﺻﻮرت ﻣﺠﺘﻤﻊ‬

‫ﺑﺮ روي وﺳﻴﻠﻪ ي ‪ I2C‬ﻗﺮار ﻣﻲ ﮔﻴﺮد‪.‬‬

‫اﺻﻄﻼﺣﺎﺗﻲ در اﻳﻦ اﺳﺘﺎﻧﺪارد‬

‫‪ :Master‬وﺳﻴﻠﻪ اي اﺳﺖ ﻛﻪ ﺷﺮوع ﻛﻨﻨﺪه ي ارﺳﺎل اﻃﻼﻋﺎت و ﺗﻮﻟﻴﺪ ﻛﻨﻨـﺪه ي ﭘـﺎﻟﺲ ﻛـﻼك و ﭘﺎﻳـﺎن دﻫﻨـﺪه ي‬

‫ارﺳﺎل اﻃﻼﻋﺎت ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫‪ :Slave‬وﺳﻴﻠﻪ اي اﺳﺖ ﻛﻪ ﺗﻮﺳﻂ ‪ Master‬آدرس دﻫﻲ ﺷﺪه اﺳﺖ‪.‬‬

‫ﻓﺮﺳﺘﻨﺪه‪ :‬وﺳﻴﻠﻪ اي ﻛﻪ اﻃﻼﻋﺎت را در ﺑﺎس داده ﻗﺮار ﻣﻲ دﻫﺪ‪.‬‬

‫ﮔﻴﺮﻧﺪه‪ :‬وﺳﻴﻠﻪ اي ﻛﻪ اﻃﻼﻋﺎت را از ﺑﺎس ﻣﻲ ﺧﻮاﻧﺪ‪.‬‬

‫
 ‬
‫‪P a g e | 141‬‬
‫‪www.avr.ir‬‬
‫‪ :Arbitration‬ﻣﻜﺎﻧﻴﺴﻤﻲ ﻛﻪ اﻃﻤﻴﻨﺎن ﻣﻲ دﻫﺪ ﻛﻪ اﮔﺮ ﺑﻴﺶ از ﻳﻚ ‪ Master‬ﻫﻤﺰﻣﺎن ﺑﺨﻮاﻫﻨﺪ ﺑﺎس را ﺑﻪ ﻛﻨﺘﺮل‬

‫ﺧﻮد درآورﻧﺪ‪ ،‬ﺗﻨﻬﺎ ﻳﻜﻲ از آن ﻫﺎ ﺑﺪون از دﺳﺖ رﻓﺘﻦ اﻃﻼﻋﺎت ﻣﻮﻓﻖ ﺷﻮد‪.‬‬

‫ﺳﻄﻮح ﺳﻴﮕﻨﺎل در ﺑﺎس ‪I2C‬‬

‫ﺑﻪ ﻃﻮر ﻛﻠﻲ دو ﺳﻄﺢ ﺳﻴﮕﻨﺎل در اﻳﻦ اﺳﺘﺎﻧﺪارد وﺟﻮد دارد‪:‬‬

‫‪1.‬‬ ‫)‪Float High (Logic 1‬‬

‫‪2.‬‬ ‫)‪Drive Low (Logic 0‬‬

‫‪Float High‬‬ ‫‪Drive Low‬‬

‫  ‬
‫‪P a g e | 142‬‬
‫‪www.avr.ir‬‬
‫وﺿﻌﻴﺖ ‪ idle‬ﻳﺎ ﺑﻴﻜﺎري ﺑﺎس ﺑﺎ ﺳﻄﺢ ‪ Float High‬ﻣﺸﺨﺺ ﻣﻲ ﺷﻮد و ﺑﺎ ﺗﻮﺟﻪ ﺑﺎ اﻳﻦ ﻣﺴﺌﻠﻪ ﻧﻘﺶ ﻣﻘﺎوﻣﺖ ﻫﺎي‬

‫‪ Pull-up‬ﻣﺸﺨﺺ ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﻣﻘﺪار ﺗﻘﺮﻳﺒﻲ آن ﻫﺎ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺳﺮﻋﺖ ارﺗﺒﺎط ﺑﻪ ﻃﻮر ﺗﻘﺮﻳﺒﻲ از ﺷﻜﻞ زﻳﺮ ﺑﺪﺳـﺖ‬

‫ﻣﻲ آﻳﺪ‪:‬‬

‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ در ﺗﺼﻮﻳﺮ زﻳﺮ ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ اﺳﺘﻔﺎده از ﻳﻚ ﻣﻘﺎوﻣـﺖ ‪ Pull-up‬ﻣﺸـﺘﺮك ﺑﺎﻋـﺚ اﻳﺠـﺎد ﻳـﻚ ﺑـﺎس‬

‫‪ Wired-AND‬ﻣﻲ ﺷﻮد‪ ،‬ﺑﺪﻳﻦ ﻣﻌﻨﺎ ﻛﻪ ﺑﺮاي ﺻﻔﺮ ﺷﺪن ﺑﺎس ﺗﻨﻬﺎ ﻻزم اﺳﺖ ﻛﻪ ﻳﻜﻲ از وﺳﺎﻳﻞ ﺧﻂ را ‪ Low‬ﻛﻨﺪ‪.‬‬

‫ﻫﺮ ﭼﻨﺪ ﺗﻜﻨﻴﻚ اراﺋـﻪ ﺷـﺪه در ﻣـﻮرد ‪ Open-collector‬ﺑـﻮدن و ﻣﻘﺎوﻣﺘﻬـﺎي ‪ Pull-up‬داراي ﻣﺰﻳـﺖ‪Wired-‬‬

‫‪ AND‬ﻣﻲ ﺑﺎﺷﺪ وﻟﻲ اﻳﻦ ﻣﻮﺿﻮع در ﻣﻮرد ﺧﻄﻮط ﻃﻮﻻﻧﻲ ﻛﻪ داراي ﻳﻚ ﻇﺮﻓﻴﺖ ﺧﺎزﻧﻲ ﻣﻲ ﺑﺎﺷـﻨﺪ ﺑﺎﻋـﺚ اﻳﺠـﺎد‬

‫ﻳﻚ ﺛﺎﺑﺖ زﻣﺎﻧﻲ ‪ RC‬ﻣﻲ ﮔﺮدد ﻛﻪ ﺑﺮاي رﻓﻊ اﻳﻦ ﻣﻮﺿﻮع ﺑﻪ ﺟﺎي ﻣﻘﺎوﻣﺖ ﻣﻲ ﺗﻮان از ‪ Pull-up‬ﻓﻌﺎل و ﻳﺎ ﺑﺎﻓﺮﻫﺎي‬

‫  ‬
‫‪P a g e | 143‬‬
‫‪www.avr.ir‬‬
‫وﻳﮋه اي ﻛﻪ ﺗﻮﺳﻂ ﺷﺮﻛﺖ ﻓﻴﻠﻴﭙﺲ اراﺋﻪ ﺷﺪه اﺳﺖ اﺳﺘﻔﺎده ﻧﻤﻮد‪ .‬ﻛﺎﻫﺶ ﻣﻘﺎوﻣﺖ در ﺳـﻄﺢ ‪ High‬ﺑﻮﺳـﻴﻠﻪ ي ﻳـﻚ‬

‫ﺳﻮﻳﻴﭻ‪ ،‬ﺑﺎﻋﺚ ﺷﺎرژ ﺷﺮﻳﻊ ﺧﺎزن ﭘﺎرازﻳﺘﻲ ﺷﺪه و در ﻧﺘﻴﺠﻪ زﻣﺎن ﺻﻌﻮد و ﻧﺰول ﭘﺎﻟﺲ ﻛﺎﻫﺶ ﻣﻲ ﻳﺎﺑﺪ‪.‬‬

‫وﺿﻌﻴﺖ ﻫﺎي ﺑﺎس ‪I2C‬‬

‫ﺑﺎس ‪ I2C‬داراي ﺗﻌﺪادي وﺿﻌﻴﺖ ﻳﺎ ﻋﻨﺼﺮ ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ اﻳﻦ وﺿﻌﻴﺖ ﻫﺎ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨﺪ ﭼﻪ زﻣﺎﻧﻲ ﻳﻚ اﻧﺘﻘﺎل آﻏﺎز‬

‫ﺷﻮد‪ ،‬ﺧﺎﺗﻤﻪ ﻳﺎﺑﺪ‪ ،‬ﺗﺎﻳﻴﺪﻳﻪ ﮔﺮﻓﺘﻪ ﺷﻮد و ﻏﻴﺮه‪ .‬ﺷﻤﺎي ﻛﻠﻲ اﻳﻦ ﻋﻨﺎﺻﺮ را در ﺗﺼﻮﻳﺮ زﻳﺮ ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ‪:‬‬

‫‪Start‬‬ ‫‪Stop‬‬ ‫‪Restart‬‬ ‫‪Data‬‬ ‫‪ACK/NACK‬‬

‫ﺷﺮاﻳﻂ آﻏﺎز ﻳﺎ ‪ :Start Condition‬از زﻣﺎﻧﻲ ﻛﻪ ﻳﻚ ﺷﺮاﻳﻂ آﻏﺎز اﻳﺠﺎد ﻣﻲ ﺷﻮد ﺗﺎ اﻳﺠﺎد ﻳﻚ ﺷﺮاﻳﻂ ﭘﺎﻳﺎن‪ ،‬ﺑﺎس‬

‫‪ Busy‬ﻣﺤﺴﻮب ﻣﻲ ﺷﻮد‪ .‬ﻧﻤﻮدار زﻣﺎﻧﻲ اﻳﺠﺎد اﻳﻦ وﺿﻌﻴﺖ ﺑﻪ اﻳﻦ ﺻﻮرت ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫  ‬
‫‪P a g e | 144‬‬
‫‪www.avr.ir‬‬

‫ﺷﺮاﻳﻂ ﭘﺎﻳﺎن ﻳﺎ ‪ :Stop Condition‬ﺑﺎ اﻳﺠﺎد ﻳﻚ ﺷﺮاﻳﻂ ﭘﺎﻳﺎن ﺑﺎس آزاد ﺷﺪه و ﻣﻲ ﺗﻮاﻧﺪ ﺗﻮﺳﻂ ﻳﻚ ‪Device‬‬

‫دﻳﮕﺮ ﺣﺎﻟﺖ آﻏﺎز دﻳﮕﺮي اﻳﺠﺎد ﺷﻮد‪:‬‬

‫ﺷﺮاﻳﻂ ﺷﺮوع ﻣﺠﺪد ﻳﺎ ‪ :Restart Condition‬اﻳﻦ وﺿﻌﻴﺖ زﻣﺎﻧﻲ ﻛﺎرﺑﺮد دارد ﻛﻪ وﺳﻴﻠﻪ ﺑﺨﻮاﻫﺪ ﺑﺪون از‬

‫دﺳﺖ دادن ﻛﻨﺘﺮل ﺑﺎس‪ ،‬ﺷﺮاﻳﻂ آﻏﺎز دﻳﮕﺮي اﻳﺠﺎد ﻛﻨﺪ و ارﺗﺒﺎط ﺑﺎ ‪ Slave‬دﻳﮕﺮي را آﻏﺎز ﻛﻨﺪ‪ .‬ﺣﺎﻟﺖ ﺷﺮوع ﻣﺠﺪد‬

‫ﭼﻴﺰي ﺟﺰ ﻳﻚ ﺳﮕﻨﺎل ﺷﺮوع ﻛﻪ ﺑﻌﺪ از ﺳﻴﮕﻨﺎل ﭘﺎﻳﺎن آﻣﺪه اﺳﺖ ﻧﻤﻲ ﺑﺎﺷﺪ‪:‬‬

‫  ‬
‫‪P a g e | 145‬‬
‫‪www.avr.ir‬‬
‫وﺿﻌﻴﺖ ‪ :Data‬در اﻳﻦ ﺣﺎﻟﺖ ‪ 8‬ﺑﻴﺖ اﻃﻼﻋﺎت ﻓﺮﺳﺘﺎده ﻣﻲ ﺷﻮد و ﻫﺮ ﺑﻴﺖ ﺑﺎ ﻳﻚ ﻛﻼك ﻫﻤﺮاﻫﻲ ﻣﻲ ﺷﻮد‪ .‬ﺧﻂ‬

‫‪ SDA‬در ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه ي ﻛﻼك ﻣﻮﺟﻮد در ‪ SCL‬ﻧﻤﻮﻧﻪ ﺑﺮداري ﻣﻲ ﺷﻮد و ﻣﻘﺪار ﺻﻔﺮ ﻳﺎ ﻳﻚ ﻣﻨﻄﻘﻲ از ‪SDA‬‬

‫ﺧﻮاﻧﺪه ﻣﻲ ﺷﻮد‪ .‬ﺑﻪ ﻣﻨﻈﻮر اﻳﻨﻜﻪ ﻣﻘﺪار ﺧﻮاﻧﺪه ﺷﺪه از ‪ SDA‬ﻣﻌﺘﺒﺮ ﺑﺎﺷﺪ ﺑﺎﻳﺪ ﻣﻘﺪار ‪ SDA‬در ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه ي‬

‫‪ SCL‬ﺗﻐﻴﻴﺮ ﻧﻜﻨﺪ و ﺑﻪ ﻃﻮر ﻛﻠﻲ وﺿﻌﻴﺖ ﺧﻂ ‪ SDA‬ﺗﻨﻬﺎ در ﺣﺎﻟﺘﻲ ﻛﻪ ‪ SCL‬ﺻﻔﺮ اﺳﺖ ﻣﺠﺎز ﺑﻪ ﺗﻐﻴﻴﺮ اﺳﺖ‪ ،‬ﺗﻨﻬﺎ‬

‫اﺳﺘﺜﻨﺎ اﻳﻦ ﻗﻀﻴﻪ ﺷﺮاﻳﻂ آﻏﺎز و ﭘﺎﻳﺎن اﺳﺖ‪.‬‬

‫وﺿﻌﻴﺖ ‪ :ACK/NACK‬وﺳﻴﻠﻪ ي ﮔﻴﺮﻧﺪه ﭘﺲ از درﻳﺎﻓﺖ ‪ 8‬ﺑﻴﺖ داده در ﺳﻴﻜﻞ ﻧﻬﻢ ﻛﻼك ﺑﺎ زﻣﻴﻦ ﻛﺮدن ﺧﻂ‬

‫‪ SDA‬ﺑﻪ ﻓﺮﺳﺘﻨﺪه ﭘﺎﺳﺦ ﻳﺎ ‪ Acknowledge‬ﻣﻲ دﻫﺪ‪ .‬ﻳﻚ ﻣﺎﻧﺪن ﺧﻂ ‪ SDA‬در ﻛﻼك ﻧﻬﻢ ﻧﻮﻋﻲ ﻋﺪم ﺗﺼﺪﻳﻖ‬

‫‪ Passive‬ﻣﻲ ﺑﺎﺷﺪ ﭼﺮا ﻛﻪ ﻣﻘﺎوﻣﺖ ‪ Pull-up‬ﺧﻂ داده را ﻳﻚ ﻧﮕﺎه ﻣﻲ دارد‪.‬‬

‫  ‬
‫‪P a g e | 146‬‬
‫‪www.avr.ir‬‬

‫ﻗﺎﻟﺐ آدرس ‪ 7‬ﺑﻴﺘﻲ‬

‫ﭘﺲ از ﻫﺮ ﺷﺮاﻳﻂ آﻏﺎز ‪ 7‬ﺑﻴﺖ آدرس وﺳﻴﻠﻪ ي ﻣﻘﺼﺪ ﻓﺮﺳﺘﺎده ﻣﻲ ﺷﻮد ﻛﻪ ﺑﻌﺪ از ﺑﻴﺖ ﻫﻔﺘﻢ ﻳﻚ ﺑﻴـﺖ ﺧﻮاﻧـﺪن ﻳـﺎ‬

‫ﻧﻮﺷﺘﻦ وﺟﻮد دارد‪ .‬ﺻﻔﺮ ﺑﻮدن اﻳﻦ ﺑﻴﺖ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ ﻛﻪ ‪ Master‬ﻗﺼﺪ ﻧﻮﺷﺘﻦ روي وﺳﻴﻠﻪ را دارد و ﻳﻚ ﺑﻮدن آن‬

‫ﻧﺸﺎن دﻫﻨﺪه ي ﺧﻮاﻧﺪن از وﺳﻴﻠﻪ ي ﻣﻘﺼﺪ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﺑﻪ ﻃﻮر ﻛﻠﻲ وﺳﺎﻳﻞ ‪ I2C‬داراي ﻳﻚ آدرس ‪ 7‬ﺑﻴﺘﻲ ﻣﻲ ﺑﺎﺷﻨﺪ ﻛﻪ اﻣﻜﺎن آدرس دﻫﻲ ‪ 128‬وﺳﻴﻠﻪ ي ﻣﺨﺘﻠﻒ را ﻓﺮاﻫﻢ‬

‫ﻣﻲ ﻛﻨﺪ‪ .‬از اﻳﻦ ﺗﻌﺪاد ‪ 16‬آدرس رزرو ﺷﺪه ﻣﻲ ﺑﺎﺷﻨﺪ و در ﻧﺘﻴﺠﻪ ﺣﺪاﻛﺜﺮ ‪ 112‬وﺳﻴﻠﻪ ﺑﺮ روي ﻳﻚ ﺑﺎس ﻗﺎﺑﻞ آدرس‬

‫دﻫﻲ ﻫﺴﺘﻨﺪ‪ .‬آدرس ﺻﻔﺮ ﻓﺮاﺧﻮاﻧﻲ ﻋﻤﻮﻣﻲ ﺑﻮده و ﭘﺲ از ارﺳﺎل اﻳﻦ آدرس ﺗﻤﺎم ﻣﻴﻜﺮوﻫﺎﻳﻲ ﻛﻪ ﺑﺎ زﻣﻴﻦ ﻛﺮدن‬

‫‪ SDA‬ﺑﻪ ‪ Master‬ﭘﺎﺳﺦ دﻫﻨﺪ‪ ،‬داده ي ‪ 8‬ﺑﻴﺘﻲ را درﻳﺎﻓﺖ ﺧﻮاﻫﻨﺪ ﻛﺮد‪ .‬ﭘﻴﻐﺎﻣﻲ ﻛﻪ ﺑﺮاي ﻫﻤﻪ ‪ Slave‬ﻫﺎ ﻓﺮﺳﺘﺎده‬

‫ﻣﻲ ﺷﻮد ‪ Broadcast‬ﻧﺎﻣﻴﺪه ﻣﻲ ﺷﻮد‪ .‬اﻳﻦ ﻣﻲ ﺗﻮاﻧﺪ ﭘﻴﻐﺎﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﺗﻮﺳﻂ ‪ Master‬ﺑﻪ ﺗﻤﺎﻣﻲ ‪ Slave‬ﻫﺎ دﺳﺘﻮر‬

‫داده ﻣﻲ ﺷﻮد ﻛﻪ آن وﻇﻴﻔﻪ را اﻧﺠﺎم ﻣﻲ دﻫﻨﺪ‪.‬‬

‫ﻋﻼوه ﺑﺮ ﻣﺤﺪودﻳﺖ ‪ 112‬آدرس‪ ،‬ﺗﻌﺪاد وﺳﺎﻳﻞ ﻣﺠﺎز روي ﺑﺎس ﺑﻮﺳﻴﻠﻪ ي ﻇﺮﻓﻴﺖ ﺧﺎزﻧﻲ ‪ 400‬ﭘﻴﻜﻮﻓﺎراد ﻧﻴﺰ ﻣﺤﺪود‬

‫ﻣﻲ ﺷﻮد‪.‬‬

‫  ‬
‫‪P a g e | 147‬‬
‫‪www.avr.ir‬‬

‫ﻳﻚ اﻧﺘﻘﺎل ﺳﺎده‬

‫ﻓﺮض ﻛﻨﻴﺪ ﻛﻪ در ﺗﺼﻮﻳﺮ زﻳﺮ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ‪ Master‬ﻣﻲ ﺑﺎﺷﺪ و ﻣﻲ ﺧﻮاﻫﺪ اﻃﻼﻋﺎﺗﻲ را ﺑﻪ ﻳﻜﻲ از ‪ Slave‬ﻫﺎ‬

‫ارﺳﺎل ﻛﻨﺪ‪:‬‬

‫در اﺑﺘﺪا ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ﻳﻚ وﺿﻌﻴﺖ ﺷﺮوع روي ﺑﺎس اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ‪ ،‬اﻳﻦ ﺳﻴﮕﻨﺎل ﻫﻤﻪ ي ‪ Slave‬ﻫﺎ را ﻣﺘﻮﺟﻪ ﺑﺎس‬

‫ﻣﻲ ﻛﻨﺪ و ﭘﺲ از آن ‪ ،Master‬آدرس ‪ Slave‬اي را ﻛﻪ ﻣﻲ ﺧﻮاﻫﺪ ﺑﺎ آن ارﺗﺒﺎط ﺑﺮﻗﺮار ﻛﻨﺪ را روي ﺑﺎس ﻣﻲ ﻓﺮﺳﺘﺪ‬

‫و در ﺑﻴﺖ ﻫﺸﺘﻢ آن ﻣﺸﺨﺺ ﻣﻲ ﺳﺎزد ﻛﻪ ﻣﻲ ﺧﻮاﻫﺪ اﻃﻼﻋﺎت را از آن ﺑﺨﻮاﻧﺪ ﻳﺎ روي آن ﺑﻨﻮﻳﺴﺪ‪ .‬ﺳﭙﺲ ﺗﻤﺎم‬

‫‪ Slave‬ﻫﺎ آدرس را درﻳﺎﻓﺖ ﻛﺮده و ﺑﺎ آدرس ﺧﻮد ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﻛﻨﻨﺪ و وﺳﻴﻠﻪ اي ﻛﻪ آدرس ﺑﻪ آن ﺗﻌﻠﻖ داﺷﺘﻪ ﺑﺎﺷﺪ‬

‫ﺑﺎ زﻣﻴﻦ ﻛﺮدن ‪ SDA‬در ﻛﻼك ﻧﻬﻢ ﻳﻚ ﺳﻴﮕﻨﺎل ‪ ACK‬اﻳﺠﺎد ﻛﺮده و ﺑﻪ ‪ Master‬ﭘﺎﺳﺦ ﻣﻲ دﻫﺪ‪ .‬ﺑﻪ ﻣﺤﺾ‬

‫درﻳﺎﻓﺖ ﺳﻴﮕﻨﺎل ﺗﺼﺪﻳﻖ ﺗﻮﺳﻂ ‪ Master‬ﺗﺒﺎدل اﻃﻼﻋﺎت ﺑﺎ ‪ Slave‬آﻏﺎز ﺷﺪه و در ﻧﻬﺎﻳﺖ ‪ ،Master‬ﻳﻚ وﺿﻌﻴﺖ‬

‫‪ Stop‬اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ ﻛﻪ ﺑﻪ ﻣﻌﻨﻲ آزاد ﺷﺪن ‪ Bus‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫  ‬
‫‪P a g e | 148‬‬
‫‪www.avr.ir‬‬

‫درﮔﺎه ‪ TWI‬در ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ‪AVR‬‬

‫واﺣﺪ ﺗﻮﻟﻴﺪ ﻧﺮخ ﺑﻴﺖ‬

‫اﻳﻦ ﻣﺎژول دوره ي ﺗﻨﺎوب ﺧﻂ ‪ SCL‬را در ﺣﺎﻟﺘﻲ ﻛﻪ ﺑﻪ ﺻﻮرت ‪ Master‬ﻋﻤﻞ ﻣﻲ ﻛﻨﺪ‪ ،‬ﻛﻨﺘـﺮل ﻣـﻲ ﻧﻤﺎﻳـﺪ‪ .‬اﻳـﻦ‬

‫ﻋﻤﻞ ﺑﻮﺳﻴﻠﻪ ي ﺗﻨﻈﻴﻤﺎت رﺟﻴﺴﺘﺮ ‪ TWBR‬و ﺑﻴﺖ ﻫﺎي ﭘﻴﺶ ﺗﻘﺴﻴﻢ ﻛﻨﻨﺪه در رﺟﻴﺴﺘﺮ ‪ TWSR‬اﻧﺠـﺎم ﻣـﻲ ﺷـﻮد‪.‬‬

‫ﻋﻤﻠﻜﺮد ‪ Slave‬ﺑﺴﺘﮕﻲ ﺑﻪ ﺗﻨﻈﻴﻤﺎت ﻧﺮخ ﺑﻴﺖ و ﭘﻴﺶ ﺗﻘﺴﻴﻢ ﻛﻨﻨﺪه ﻧﺪارد اﻣﺎ ﻓﺮﻛﺎﻧﺲ ‪ CPU‬در ‪ Slave‬ﺑﺎﻳﺪ ﺣﺪاﻗﻞ‬

‫‪ 16‬ﺑﺮاﺑﺮ ﻓﺮﻛﺎﻧﺲ ‪ SCL‬ﺑﺎﺷﺪ ﻛﻪ از راﺑﻄﻪ ي زﻳﺮ ﺑﺪﺳﺖ ﻣﻲ آﻳﺪ‪:‬‬

‫‪CPU Clock Frequency‬‬

‫= ‪f SCL‬‬
‫‪16 + 2(TWBR ) × 4TWPS‬‬

‫ﺗﻮﺟﻪ‪ :‬در ﺣﺎﻟﺘﻲ ﻛﻪ ‪ TWI‬ﺑﻪ ﺻﻮرت ‪ Master‬ﻋﻤﻞ ﻣﻲ ﻛﻨﺪ ﺑﺎﻳﺪ ﻣﻘﺪار ‪ TWBR‬ﺑﺰرﮔﺘﺮ و ﻳﺎ ﻣﺴﺎوي ‪ 10‬ﺑﺎﺷﺪ‪،‬‬

‫در ﻏﻴﺮ اﻳﻨﺼﻮرت ﻣﻤﻜﻦ اﺳﺖ ‪ Master‬ﻛﻼك اﺷﺘﺒﺎه روي ﺧﻂ ‪ SCL‬ﺗﻮﻟﻴﺪ ﻛﻨﺪ‪.‬‬

‫رﺟﻴﺴﺘﺮﻫﺎي ‪TWI‬‬

‫ﺑﺨﺶ ‪ TWI‬داراي ﭘﻨﺞ رﺟﻴﺴﺘﺮ ﺑﻪ ﻧﺎم ﻫﺎي ‪ TWDR ،TWSR ،TWCR ،TWBR‬و ‪ TWAR‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫  ‬
‫‪P a g e | 149‬‬
‫‪www.avr.ir‬‬

‫‪:TWI Bit Rate Register‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪TWBR‬‬ ‫]‪TWBR[7:0‬‬

‫اﻳﻦ رﺟﻴﺴﺘﺮ ﻓﺮﻛﺎﻧﺲ ‪ SCL‬را ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ و ﻣﻘﺪار آن ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ راﺑﻄﻪ ي زﻳﺮ ﺑﺪﺳﺖ ﻣﻲ آﻳﺪ‪:‬‬

‫‪CPU Clock Frequency - 16 × f SCL‬‬

‫= ‪TWBR‬‬
‫‪2 × f SCK × 4TWPS‬‬

‫ﻣﺜﺎل‪) :1‬ﺗﻌﻴﻴﻦ ‪ TWBR‬ﺑﺎ ﻛﺮﻳﺴﺘﺎل ‪ 8‬ﻣﮕﺎﻫﺮﺗﺰ و ﻓﺮﻛﺎﻧﺲ ‪ SCK‬ﺑﺮاﺑﺮ ‪ 100‬ﻛﻴﻠﻮﻫﺮﺗﺰ و ‪(TWPS = 0‬‬

‫‪8000000 − 16 × 100000‬‬
‫= ‪TWBR‬‬ ‫‪= 32‬‬
‫‪2 × 100000 × 40‬‬

‫‪:TWI Control Register‬‬

‫‪TWC‬‬
‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪R‬‬
‫‪TWIN‬‬ ‫‪TWE‬‬ ‫‪TWST‬‬ ‫‪TWST‬‬ ‫‪TWW‬‬ ‫‪TWE‬‬ ‫‪TWI‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪-‬‬
‫‪T‬‬ ‫‪A‬‬ ‫‪A‬‬ ‫‪O‬‬ ‫‪C‬‬ ‫‪N‬‬ ‫‪E‬‬

‫اﻳﻦ رﺟﻴﺴﺘﺮ وﻇﻴﻔﻪ ي ﻛﻨﺘﺮل ‪ TWI‬را ﺑﺮ ﻋﻬﺪه دارد و ﻋﻤﻠﻜﺮد ﺑﻴﺖ ﻫﺎي آن ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪:‬‬

‫  ‬
‫‪P a g e | 150‬‬
‫‪www.avr.ir‬‬

‫‪ :TWI Interrupt Enable‬ﺑﺎ ﻳﻚ ﻛﺮدن اﻳﻦ ﺑﻴﺖ در ﺻﻮرﺗﻲ ﻛﻪ ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﻋﻤﻮﻣﻲ وﻗﻔـﻪ ﻫـﺎ ‪ Set‬ﺷـﺪه‬

‫ﺑﺎﺷﺪ‪ ،‬ﺑﺎ ﻓﻌﺎل ﺷﺪن ﭘﺮﭼﻢ ‪ TWINT‬ﺑﺮﻧﺎﻣﻪ ﺑﻪ روﺗﻴﻦ ﺳﺮوﻳﺲ وﻗﻔﻪ ي ‪ TWI‬ﭘﺮش ﺧﻮاﻫﺪ ﻛﺮد‪.‬‬

‫‪ :TWI Enable Bit‬اﻳﻦ ﺑﻴﺖ ‪ TWI‬را ﻓﻌﺎل ﻛﺮده و ﺑﺎ ﻳﻚ ﺷﺪن آن‪ ،‬ﻣﺎژول ‪ TWI‬ﻛﻨﺘـﺮل ﭘـﻴﻦ ﻫـﺎي ‪ SCL‬و‬

‫‪ SDA‬را ﺑﺮﻋﻬﺪه ﻣﻲ ﮔﻴﺮد‪ .‬در اﻳﻦ ﺣﺎﻟﺖ واﺣﺪ ﻛﻨﺘﺮل ‪ Slew Rate‬و ﻓﻴﻠﺘﺮ ورودي ﻓﻌﺎل ﺷﺪه و ﺑﺎ ﺻﻔﺮ ﺷﺪن اﻳـﻦ‬

‫ﺑﻴﺖ ‪ TWI‬ﻏﻴﺮ ﻓﻌﺎل ﺷﺪه و ﻣﺠﺪدا ﺑﻪ ﺻﻮرت ‪ I/O‬ﻣﻌﻤﻮﻟﻲ در ﻣﻲ آﻳﺪ‪.‬‬

‫‪ :TWI Write Collision Flag‬اﻳﻦ ﺑﻴﺖ ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ زﻣﺎﻧﻲ ﻳـﻚ ﻣـﻲ ﺷـﻮد ﻛـﻪ روي رﺟﻴﺴـﺘﺮ ‪TWDR‬‬

‫ﻣﻘﺪاري ﻧﻮﺷﺘﻪ ﺷﻮد و ﺑﻴﺖ ‪ TWINT‬ﺻﻔﺮ ﺑﺎﺷﺪ‪ .‬ﺑﺎ ﻧﻮﺷﺘﻦ روي رﺟﻴﺴﺘﺮ ‪ TWDR‬در ﺷﺮاﻳﻄﻲ ﻛﻪ ‪ TWINT‬ﻳﻚ‬

‫ﺑﺎﺷﺪ‪ ،‬اﻳﻦ ﭘﺮﭼﻢ ﭘﺎك ﻣﻲ ﺷﻮد‪.‬‬

‫‪ :TWI STOP Condition Bit‬ﻧﻮﺷﺘﻦ ﻳﻚ روي اﻳﻦ ﺑﻴﺖ در وﺿﻌﻴﺖ ‪ Master‬ﺑﺎﻋﺚ اﻳﺠﺎد ﻳﻚ ﺷﺮاﻳﻂ‬

‫ﭘﺎﻳﺎن در ﺑﺎس ‪ I2C‬ﺧﻮاﻫﺪ ﺷﺪ و ﭘﺲ اﺟﺮا ﺷﺪن اﻳﻦ وﺿﻌﻴﺖ ﺑﻴﺖ ‪ TWSTO‬ﺑﻪ ﺻﻮرت ﺧﻮدﻛﺎر ﭘﺎك ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫در وﺿﻌﻴﺖ ‪ ،Slave‬ﻳﻚ ﻛﺮدن اﻳﻦ ﺑﻴﺖ وﺿﻌﻴﺖ ﭘﺎﻳﺎن اﻳﺠﺎد ﻧﺨﻮاﻫﺪ ﻛﺮد اﻣﺎ ﺧﻄﻮط ‪ SDA‬و ‪ SCL‬رﻫﺎ ﺷﺪه و‬

‫ﺑﻪ ﺣﺎﻟﺖ ﺷﻨﺎور ﺑﺮ ﻣﻲ ﮔﺮدﻧﺪ‪ ،‬ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ ﻣﻲ ﺗﻮان از وﺿﻌﻴﺖ ﺧﻄﺎ ﺧﺎرج ﺷﺪ‪.‬‬

‫‪ :TWI START Condition Bit‬ﻧﺮم اﻓﺰار ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ روي اﻳﻦ ﺑﻴﺖ ﺑﺎ ﻫﺪف ‪ Master‬ﺷﺪن‪ ،‬اﻳﺠﺎد ﻳـﻚ‬

‫ﺷﺮاﻳﻂ آﻏﺎز ﻣﻲ ﻛﻨﺪ‪ .‬ﺳﺨﺖ اﻓﺰار ﺑﺎس را ﭼﻚ ﻛﺮده و در ﺻﻮرﺗﻲ ﻛﻪ آزاد ﺑﺎﺷﺪ اﻳﺠﺎد ﻳﻚ ﺷﺮاﻳﻂ آﻏﺎز ﻣﻲ ﻛﻨـﺪ‪ ،‬در‬

‫
 ‬
‫‪P a g e | 151‬‬
‫‪www.avr.ir‬‬
‫ﻏﻴﺮ اﻳﻨﺼﻮرت ﻣﺎژول ‪ TWI‬ﻣﻨﺘﻈﺮ ﺗﺸﺨﻴﺺ ﻳﻚ ﺷﺮاﻳﻂ ﭘﺎﻳﺎن روي ﺑﺎس ﻣﻲ ﺷﻮد و ﭘﺲ از آن ﺑﺎ اﻳﺠﺎد ﻳﻚ ﺷـﺮاﻳﻂ‬

‫آﻏﺎز ﻛﻨﺘﺮل ﺑﺎس را ﺑﻪ دﺳﺖ ﻣﻲ ﮔﻴﺮد‪ .‬ﺑﻴﺖ ‪ TWSTA‬ﺑﺎﻳﺪ ﺑﻌﺪ از اﻳﺠﺎد ﺷﺮاﻳﻂ آﻏﺎز ﺗﻮﺳﻂ ﻧﺮم اﻓﺰار ﭘﺎك ﺷﻮد‪.‬‬

‫‪ TWEA :TWI Enable Acknowledge Bit‬اﻳﺠﺎد ﭘﺎﻟﺲ ﺗﺼﺪﻳﻖ ﻳﺎ ‪ Acknowledge‬را ﻛﻨﺘﺮل ﻣﻲ ﻛﻨﺪ‪.‬‬

‫اﮔﺮ روي اﻳﻦ ﺑﻴﺖ ﻳﻚ ﻧﻮﺷﺘﻪ ﺷﻮد ﭘﺎﻟﺲ ‪ ACK‬در ﺷﺮاﻳﻂ زﻳﺮ اﻳﺠﺎد ﻣﻲ ﺷﻮد‪:‬‬

‫ﭘﺲ از اﻳﻨﻜﻪ ‪ Slave‬آدرس ﻣﺮﺑﻮط ﺑﻪ ﺧﻮدش را درﻳﺎﻓﺖ ﻛﺮده ﺑﺎﺷﺪ‪.‬‬ ‫‪.1‬‬

‫ﻣﺎداﻣﻴﻜﻪ ﺑﻴﺖ ‪ TWGCE‬در ‪ TWAR‬ﻳﻚ ﺑﻮده و ﻳﻚ ﻓﺮاﺧﻮان ﻋﻤﻮﻣﻲ درﻳﺎﻓﺖ ﺷﺪه ﺑﺎﺷﺪ‪.‬‬ ‫‪.2‬‬

‫ﻳﻚ ﺑﺎﻳﺖ داده در ‪ Master‬ﻳﺎ ‪ Slave‬درﻳﺎﻓﺖ ﺷﺪه ﺑﺎﺷﺪ‪.‬‬ ‫‪.3‬‬

‫‪ :TWI Interrupt Flag‬اﻳﻦ ﺑﻴﺖ ﭘﺲ از اﺗﻤﺎم ﻫﺮ ﻳﻚ از وﻇﺎﻳﻒ ‪ TWI‬ﻳﻚ ﺷﺪه و در ﺻﻮرﺗﻲ ﻛـﻪ وﻗﻔـﻪ ي‬

‫ﺳﺮاﺳﺮي و ﺑﻴﺖ ‪ TWIE‬ﻳﻚ ﺑﺎﺷﻨﺪ ﺑﻪ ﺑﺮدار وﻗﻔﻪ ي ‪ TWI‬ﭘﺮش ﻣـﻲ ﻛﻨـﺪ‪ .‬اﻳـﻦ ﺑﻴـﺖ ﭘـﺲ از اﺟـﺮاي ‪ ISR‬ﺑـﻪ‬

‫ﺻﻮرت ﺳﺨﺖ اﻓﺰاري ﭘﺎك ﻧﻤﻲ ﺷﻮد و ﺑﺎﻳﺪ ﺗﻮﺳﻂ ﻧﺮم اﻓﺰار ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ ﭘﺎك ﺷﻮد‪.‬‬

‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﭘﺮﭼﻢ ‪ TWINT‬ﻳﻚ ﺷﻮد‪ ،‬ﻧﺮم اﻓﺰار ﺑﺎﻳﺪ ﻣﺤﺘﻮﻳﺎت ﺗﻤﺎم رﺟﻴﺴﺘﺮﻫﺎﻳﻲ را ﻛﻪ ﺑﺮاي وﻇﻴﻔﻪ ي ﺑﻌﺪي ﻧﻴـﺎز‬

‫اﺳﺖ )ﻣﺜﻞ ‪ (TWDR‬ﺗﻨﻈﻴﻢ ﻛﺮده و ﭘﺲ از آن ﻫﻤﺰﻣﺎن ﺑﺎ ﺗﻨﻈﻴﻤﺎت رﺟﻴﺴـﺘﺮ ‪ ،TWCR‬ﭘـﺮﭼﻢ ‪ TWINT‬را ﭘـﺎك‬

‫ﻛﻨﺪ ﺗﺎ ﻣﺎژول ‪ TWI‬ﺷﺮوع ﺑﻪ اﻧﺠﺎم وﻇﻴﻔﻪ ي ﺑﻌﺪي ﻧﻤﺎﻳـﺪ‪ .‬ﻣﺎداﻣﻴﻜـﻪ ﻛـﻪ ﭘـﺮﭼﻢ ‪ TWINT‬ﻳـﻚ اﺳـﺖ ‪ SCL‬در‬

‫وﺿﻌﻴﺖ ﺻﻔﺮ ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ و ﺗﺎ زﻣﺎﻧﻲ ﻛﻪ اﻳﻦ ﺑﻴﺖ ﭘﺎك ﻧﺸﻮد ‪ TWI‬ﻫﻴﭻ ﻋﻤﻠﻲ اﻧﺠﺎم ﻧﺨﻮاﻫﺪ داد‪.‬‬

‫‪:TWI Status Register‬‬

‫  ‬
‫‪P a g e | 152‬‬
‫‪www.avr.ir‬‬
‫‪TWS‬‬
‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪R‬‬
‫‪TWS‬‬ ‫‪TWS‬‬ ‫‪TWS‬‬ ‫‪TWS‬‬ ‫‪TWS‬‬ ‫‪TWPS‬‬ ‫‪TWPS‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪-‬‬
‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪1‬‬ ‫‪0‬‬

‫]‪ :TWI Prescaler Bits[1:0‬اﻳﻦ ﺑﻴﺖ ﻫﺎ ﻣﻘﺪار ﭘﻴﺶ ﺗﻘﺴﻴﻢ ﻛﻨﻨﺪه را ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﻨﺪ ﻛﻪ ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ‬

‫ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪:‬‬

‫‪TWPS‬‬ ‫‪TWPS‬‬
‫ﻣﻘﺪار ﭘﻴﺶ ﺗﻘﺴﻴﻢ ﻛﻨﻨﺪه‬
‫‪1‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪0‬‬ ‫‪1‬‬ ‫‪4‬‬

‫‪1‬‬ ‫‪0‬‬ ‫‪16‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪64‬‬

‫]‪ :TWI Status[7:3‬اﻳﻦ ﺑﻴﺖ ﻫﺎ ﻧﻤﺎﻳﺎﻧﮕﺮ وﺿﻌﻴﺖ ‪ TWI‬ﻣﻲ ﺑﺎﺷﻨﺪ ﻛﻪ در ﺑﺮرﺳﻲ ‪ Mode‬ﻫﺎي ﻛﺎري ﻋﻤﻠﻜﺮد‬

‫آن ﻫﺎ ﺑﺮرﺳﻲ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫‪:TWI Data Register‬‬

‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪TWDR‬‬ ‫]‪TWDR[7:0‬‬

‫  ‬
‫‪P a g e | 153‬‬
‫‪www.avr.ir‬‬
‫در ﺣﺎﻟﺖ اﻧﺘﻘﺎل‪ TWDR ،‬ﻣﺤﺘﻮي ﺑﺎﻳﺖ ﺑﻌﺪي اﺳﺖ ﻛﻪ ﺑﺎﻳﺪ ارﺳﺎل ﺷﻮد و در ﺣﺎﻟﺖ درﻳﺎﻓﺖ ﺷﺎﻣﻞ آﺧﺮﻳﻦ ﺑﺎﻳﺖ‬

‫درﻳﺎﻓﺘﻲ اﺳﺖ‪ .‬اﻳﻦ رﺟﻴﺴﺘﺮ ﺗﻨﻬﺎ در ﺣﺎﻟﺘﻲ ﻛﻪ ‪ TWI‬در ﺣﺎل اﻧﺘﻘﺎل اﻃﻼﻋﺎت ﻧﺒﺎﺷﺪ و ﭘﺮﭼﻢ ‪ TWINT‬ﻳﻚ ﺷﺪه‬

‫ﺑﺎﺷﺪ‪ ،‬ﻗﺎﺑﻞ ﻧﻮﺷﺘﻦ اﺳﺖ‪.‬‬

‫‪ :TWI (Slave) Address Register‬اﻳﻦ رﺟﻴﺴﺘﺮ آدرس ‪ Slave‬در وﺿﻌﻴﺖ ﻫﺎي ‪ ST‬و ‪ SR‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫‪TWA‬‬
‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪R‬‬
‫‪TWA‬‬ ‫‪TWA‬‬ ‫‪TWA‬‬ ‫‪TWA‬‬ ‫‪TWA‬‬ ‫‪TWA‬‬ ‫‪TWA‬‬ ‫‪TWGC‬‬
‫ﻧﺎم ﺑﻴﺖ‬
‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪E‬‬

‫‪ :TWI General Call Recognition Enable‬آدرس ‪ 0x00‬ﻣﺮﺑﻮط ﺑﻪ ﻓﺮاﺧﻮاﻧﻲ ﻋﻤﻮﻣﻲ ﺑﻮده و ﺗﺸﺨﻴﺺ‬

‫آن ﺗﻮﺳﻂ ﺳﺨﺖ اﻓﺰار ﻣﻨﻮط ﺑﻪ ﻳﻚ ﺑﻮدن ‪ TWGCE‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫]‪ :TWI (Slave) Address[7:1‬اﻳﻦ ‪ 7‬ﺑﻴﺖ آدرس ‪ Slave‬را ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﻨﺪ‪.‬‬

‫ﻧﺎم ﮔﺬاري ﻫﺎي زﻳﺮ ﺑﻪ ﺻﻮرت ﻗﺮارداد در اداﻣﻪ اﺳﺘﻔﺎده ﺧﻮاﻫﻨﺪ ﺷﺪ‪:‬‬

‫‪S:‬‬ ‫‪START condition‬‬

‫‪Rs:‬‬ ‫‪REPEATED START condition‬‬
‫‪R:‬‬ ‫)‪Read bit (high level at SDA‬‬
‫‪W:‬‬ ‫)‪Write bit (low level at SDA‬‬
‫‪ACK:‬‬ ‫)‪Acknowledge bit (low level at SDA‬‬
‫)‪NACK: Not acknowledge bit (high level at SDA‬‬

‫  ‬
‫‪P a g e | 154‬‬
‫‪www.avr.ir‬‬
‫‪Data:‬‬ ‫‪8-bit data byte‬‬
‫‪P:‬‬ ‫‪STOP condition‬‬
‫‪SLA:‬‬ ‫‪Slave Address‬‬

‫‪ Mode‬ﻫﺎي ﻋﻤﻠﻜﺮد ‪:TWI‬‬

‫‪1.‬‬ ‫)‪Master Transmitter (MT‬‬

‫‪2.‬‬ ‫)‪Master Receiver (MR‬‬
‫‪3.‬‬ ‫)‪Slave Transmitter (ST‬‬
‫‪4.‬‬ ‫)‪Slave Receiver (SR‬‬

‫ ‪(MT) Master Transmitter‬‬

‫در اﻳﻦ ‪ Mode‬اﺑﺘﺪا ﺗﻮﺳﻂ ‪ Master‬ﻳﻚ وﺿﻌﻴﺖ ﺷﺮوع اﻳﺠﺎد ﺷﺪه و ﺑﻠﻮك آدرﺳﻲ ﻛﻪ در اداﻣﻪ ﻓﺮﺳﺘﺎده ﻣﻲ ﺷـﻮد‬

‫ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ ﻛﻪ ‪ Master‬ﮔﻴﺮﻧﺪه ﻳﺎ ﻓﺮﺳﺘﻨﺪه اﺳﺖ‪ .‬اﮔـﺮ ﭘـﺲ از اﻳﺠـﺎد ﺣﺎﻟـﺖ ﺷـﺮوع ‪ SLA+W‬ارﺳـﺎل ﮔـﺮدد‬

‫‪ Master‬وارد ﺣﺎﻟﺖ ارﺳﺎل ﺷﺪه و در ﺻﻮرﺗﻲ ﻛﻪ ‪ SLA+R‬ارﺳﺎل ﺷﻮد وارد ﺣﺎﻟﺖ درﻳﺎﻓﺖ ﻣﻲ ﺷﻮد‪.‬‬

‫ﺷﺮاﻳﻂ آﻏﺎز ﺑﺎ ﻣﻘﺪار دﻫﻲ ‪ TWCR‬ﺑﻪ ﺻﻮرت زﻳﺮ اﻳﺠﺎد ﻣﻲ ﮔﺮدد‪:‬‬

‫‪TWC‬‬
‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪R‬‬
‫‪TWIN‬‬ ‫‪TWE‬‬ ‫‪TWST‬‬ ‫‪TWST‬‬ ‫‪TWW‬‬ ‫‪TWE‬‬ ‫‪TWI‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪-‬‬
‫‪T‬‬ ‫‪A‬‬ ‫‪A‬‬ ‫‪O‬‬ ‫‪C‬‬ ‫‪N‬‬ ‫‪E‬‬
‫ﻣﻘﺪار‬ ‫‪1‬‬ ‫‪X‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪X‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪X‬‬

‫  ‬
‫‪P a g e | 155‬‬
‫‪www.avr.ir‬‬
‫‪ TWIE‬ﻓﻌﺎل ﺳﺎز وﻗﻔﻪ ي ‪ TWI‬ﺑﻮده و ﻣﻘﺪار آن اﺧﺘﻴﺎري ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫‪ TWEN‬ﻓﻌﺎل ﺳﺎز ‪ TWI‬ﺑﻮده و در ﻧﺘﻴﺠﻪ ﺑﺎﻳﺪ ﻣﻘﺪار ﻳﻚ داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬

‫‪ TWWC‬ﻛﻪ ﻳﻚ ﺑﻴﺖ ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ اﺳﺖ در اﻳﻦ ﺣﺎﻟﺖ ﺻﻔﺮ ﺧﻮاﻧﺪه ﻣﻲ ﺷﻮد زﻳﺮا ﻧﺮم اﻓﺰار ﻫﻨﻮز ﻣﻘـﺪاري را را‬

‫روي ‪ TWDR‬ﻧﻨﻮﻧﺸﺘﻪ اﺳﺖ و ﺑﻨﺎﺑﺮاﻳﻦ ‪ Collision‬ﻳﺎ ﺗﺼﺎدﻣﻲ ﻧﻴﺰ ﭘﻴﺶ ﻧﻴﺎﻣﺪه اﺳﺖ‪.‬‬

‫‪ TWSTO‬ﺻﻔﺮ ﻣﻲ ﺑﺎﺷﺪ زﻳﺮا در اﻳﻨﺠﺎ ﻧﻤﻲ ﺧﻮاﻫﻴﻢ ﺷﺮاﻳﻂ ﭘﺎﻳﺎن اﻳﺠﺎد ﺷﻮد‪.‬‬

‫‪ TWSA‬ﻳﻚ ﺑﻮده ﺗﺎ ﻣﺎژول ‪ TWI‬در ﺻﻮرت آزاد ﺑﻮدن ﺑﺎس‪ ،‬ﺷﺮاﻳﻂ آﻏﺎز را اﻳﺠـﺎد ﻛـﺮده و در ﻏﻴـﺮ اﻳﻨﺼـﻮرت‬

‫ﻣﻨﺘﻈﺮ ﺗﺸﺨﻴﺺ ﻳﻚ ﺷﺮاﻳﻂ ﭘﺎﻳﺎن ﺑﺎﺷﺪ‪.‬‬

‫‪ TWEA‬ﻣﻘﺪاري ﺑﻲ اﻫﻤﻴﺖ ﻣﻲ ﺑﺎﺷﺪ زﻳﺮا ﺑﺎ ﻓﺮض ‪ Set‬ﻛﺮدن آن در ﺷﺮاﻳﻂ آﻏﺎز ﻫﻴﭻ ﮔـﺎه ‪ ACK‬ﻧﻴـﺎز ﻧﺒـﻮده و‬

‫اﻳﺠﺎد ﻧﻴﺰ ﻧﻤﻲ ﺷﻮد‪.‬‬

‫‪ TWINT‬ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ ﭘﺎك ﻣﻲ ﺷﻮد ﺗﺎ ‪ TWI‬ﺷﺮوع ﺑﻪ اﻧﺠﺎم ﻓﺮﻣﺎن داده ﺷﺪه ﺗﻮﺳﻂ رﺟﻴﺴﺘﺮ ‪ TWCR‬ﻛﻨﺪ‪.‬‬

‫ﭘﺲ از اﺟﺮاي ﺗﻨﻈﻴﻤﺎت ﻓﻮق در ﺻـﻮرت آزاد ﺑـﻮدن ﺑـﺎس ﻣـﺎژول ‪ TWI‬ﺷـﺮاﻳﻂ آﻏـﺎز را اﻳﺠـﺎد ﻛـﺮده و در ﻏﻴـﺮ‬

‫اﻳﻨﺼﻮرت ﻣﻨﺘﻄﺮ آزاد ﺷﺪن ﺑﺎس ﺷﺪه و ﺑﻪ ﻣﺤﺾ ﺗﺸﺨﻴﺺ ﻳﻚ ﺷﺮاﻳﻂ ﭘﺎﻳﺎن ﻛﻨﺘﺮل ﺑﺎس را ﺑﻪ دﺳﺖ ﮔﺮﻓﺘﻪ و ﺷﺮاﻳﻂ‬

‫آﻏﺎز را اﻳﺠﺎد ﻣﻲ ﻧﻤﺎﻳﺪ‪ ،‬ﭘﺲ از آن ﭘﺮﭼﻢ ‪ TWINT‬ﻳﻚ ﺷﺪه و ﻛـﺪ وﺿـﻌﻴﺖ ﻣﻮﺟـﻮد در ‪ TWSR‬ﺑﺮاﺑـﺮ ‪0x08‬‬

‫ﺧﻮاﻫﺪ ﺷﺪ‪ .‬ﺑﺮاي ورود ﺑﻪ وﺿﻌﻴﺖ ‪ MT‬ﺑﺎﻳﺪ روي ‪ TWDR‬ﻣﻘﺪار ‪ SLA+W‬ﻧﻮﺷﺘﻪ ﺷﺪه و ﭘﺲ از آن ﺑﺎ ﻧﻮﺷـﺘﻦ‬

‫ﻳﻚ روي ‪ TWINT‬آن را ﭘﺎك ﻛﺮده ﺗـﺎ ﻣﺮﺣﻠـﻪ ي ﺑﻌـﺪ آﻏـﺎز ﺷـﻮد‪ .‬ﭘـﺲ از ﻧﻮﺷـﺘﻦ ‪ SLA+W‬روي ‪TWDR‬‬

‫ﺗﻨﻈﻴﻤﺎت ‪ TWCR‬ﺑﻪ ﺻﻮرت زﻳﺮ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬

‫‪TWC‬‬
‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪R‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪TWIN‬‬ ‫‪TWE‬‬ ‫‪TWST‬‬ ‫‪TWST‬‬ ‫‪TWW‬‬ ‫‪TWE‬‬ ‫‪-‬‬ ‫‪TWI‬‬

‫  ‬
‫‪P a g e | 156‬‬
‫‪www.avr.ir‬‬
‫‪T‬‬ ‫‪A‬‬ ‫‪A‬‬ ‫‪O‬‬ ‫‪C‬‬ ‫‪N‬‬ ‫‪E‬‬
‫ﻣﻘﺪار‬ ‫‪1‬‬ ‫‪X‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪X‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪X‬‬

‫ﺗﻔﺎوت ﺑﺎ ﻣﺮﺣﻠﻪ ي ﻗﺒﻞ اﻳﻦ اﺳﺖ ﻛﻪ از آﻧﺠﺎﻳﻲ ﻛﻪ ﻧﻴﺎز ﺑﻪ ﺷﺮاﻳﻂ آﻏﺎز وﺟﻮد ﻧﺪارد ﺑﻴﺖ ‪ TWSTA‬ﺻﻔﺮ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﺑﺎ ﻓﺮﺳﺘﺎده ﺷﺪن ‪ SLA+W‬و درﻳﺎﻓﺖ ‪ ACK‬ﻣﺠﺪدا ﺑﻴﺖ ‪ TWINT‬ﻳﻚ ﺷﺪه و در اﻳﻦ ﺷﺮاﻳﻂ ﻳﻜﻲ از ﭼﻨـﺪ ﻛـﺪ‬

‫‪ 0x18 ،0x20‬ﻳﺎ ‪ 0x38‬در ‪ TWSR‬ﻗﺮار ﻣﻲ ﮔﻴﺮد‪ .‬در ﺻﻮرﺗﻲ ﻛﻪ اﻳﻦ ﻣﻘﺪار ﺑﺮاﺑﺮ ‪ 0x18‬ﺑﺎﺷﺪ ﺑﺪﻳﻦ ﻣﻌﻨﺎﺳﺖ ﻛﻪ‬

‫آدرس ارﺳﺎل ﺷﺪه و ‪ ACK‬درﻳﺎﻓﺖ ﺷﺪه اﺳﺖ‪ .‬ﭘﺲ از اﻳﻦ ﺑﺎﻳﺪ ﺑﻠﻮك داده ارﺳﺎل ﺷﻮد‪ .‬ﻫﻤﺎﻧﻨـﺪ ﺣﺎﻟـﺖ ﻗﺒـﻞ اﺑﺘـﺪا‬

‫ﻣﻘﺪار ﻣﻮرد ﻧﻈﺮ در رﺟﻴﺴﺘﺮ ‪ TWDR‬ﻧﻮﺷﺘﻪ ﺷﺪه و ﺑﺎ ﭘﺎك ﻛـﺮدن ﺑﻴـﺖ ‪ TWINT‬داده ي ‪ 8‬ﺑﻴﺘـﻲ ﺗﻮﺳـﻂ ‪TWI‬‬

‫ارﺳﺎل ﺧﻮاﻫﺪ ﺷﺪ‪ .‬در ﺻﻮرﺗﻲ ﻛـﻪ رﺟﻴﺴـﺘﺮ ‪ TWDR‬ﺑﻌـﺪ از ﭘـﺎك ﻛـﺮدن ‪ TWINT‬ﻣﻘـﺪاردﻫﻲ ﺷـﻮد رﺟﻴﺴـﺘﺮ‬

‫‪ TWWC‬ﻳﻚ ﺷﺪه و اﻋﻼم ﻳﻚ ﺣﺎﻟﺖ ﺗﺼﺎدم را ﻣﻲ ﻛﻨﺪ‪ .‬ﺗﻨﻈﻴﻤﺎت ‪ TWCR‬ﻫﻤﺎﻧﻨﺪ ﺣﺎﻟﺖ ﻗﺒﻞ ﺑـﻪ ﺻـﻮرت زﻳـﺮ‬

‫ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬

‫‪TWC‬‬
‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪R‬‬
‫‪TWIN‬‬ ‫‪TWE‬‬ ‫‪TWST‬‬ ‫‪TWST‬‬ ‫‪TWW‬‬ ‫‪TWE‬‬ ‫‪TWI‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪-‬‬
‫‪T‬‬ ‫‪A‬‬ ‫‪A‬‬ ‫‪O‬‬ ‫‪C‬‬ ‫‪N‬‬ ‫‪E‬‬
‫ﻣﻘﺪار‬ ‫‪1‬‬ ‫‪X‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪X‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪X‬‬

‫اﻳﻦ ﻣﺮﺣﻠﻪ ﺗﺎ اﺗﻤﺎم ارﺳﺎل ﺗﻤﺎم ﺑﺎﻳﺖ ﻫﺎي داده ﺗﻜﺮار ﻣﻲ ﺷﻮد و ﺳﺮاﻧﺠﺎم ﺑﺎ اﻳﺠﺎد ﻳﻚ ﺷﺮاﻳﻂ ﭘﺎﻳﺎن ﻳﺎ ﺷﺮوع ﻣﺠـﺪد‬

‫ﭘﺎﻳﺎن ﻣﻲ ﻳﺎﺑﺪ‪ .‬ﺷﺮاﻳﻂ ﭘﺎﻳﺎن ﺑﺎ ﻣﻘﺪاردﻫﻲ رﺟﻴﺴﺘﺮ ‪ TWCR‬ﺑﻪ ﺻﻮرت زﻳﺮ اﻳﺠﺎد ﻣﻲ ﺷﻮد‪:‬‬

‫‪TWC‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫  ‬
‫‪P a g e | 157‬‬
‫‪www.avr.ir‬‬
‫‪R‬‬
‫‪TWIN‬‬ ‫‪TWE‬‬ ‫‪TWST‬‬ ‫‪TWST‬‬ ‫‪TWW‬‬ ‫‪TWE‬‬ ‫‪TWI‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪-‬‬
‫‪T‬‬ ‫‪A‬‬ ‫‪A‬‬ ‫‪O‬‬ ‫‪C‬‬ ‫‪N‬‬ ‫‪E‬‬
‫ﻣﻘﺪار‬ ‫‪1‬‬ ‫‪X‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪X‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪X‬‬

‫و ﺑﺮاي اﻳﺠﺎد ﺷﺮاﻳﻂ ﺷﺮوع ﻣﺠﺪد ﺟﺪول زﻳﺮ را ﺧﻮاﻫﻴﻢ داﺷﺖ‪:‬‬

‫‪TWC‬‬
‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪R‬‬
‫‪TWIN‬‬ ‫‪TWE‬‬ ‫‪TWST‬‬ ‫‪TWST‬‬ ‫‪TWW‬‬ ‫‪TWE‬‬ ‫‪TWI‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪-‬‬
‫‪T‬‬ ‫‪A‬‬ ‫‪A‬‬ ‫‪O‬‬ ‫‪C‬‬ ‫‪N‬‬ ‫‪E‬‬
‫ﻣﻘﺪار‬ ‫‪1‬‬ ‫‪X‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪X‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪X‬‬

‫ﭘﺲ از اﻳﺠﺎد ﺷﺮاﻳﻂ ﭘﺎﻳﺎن ‪ TWINT0‬ﻳﻚ ﻧﻤﻲ ﺷﻮد‪.‬‬ ‫‬

‫ﺑﺎ اﻳﺠﺎد ﻳﻚ ﺣﺎﻟﺖ ﺷﺮوع ﻣﺠﺪد ﻣﻘﺪار رﺟﻴﺴﺘﺮ ‪ TWSR‬ﺑﺮاﺑﺮ ‪ 0x10‬ﺧﻮاﻫﺪ ﺑﻮد و اﻳﻦ ﻗﺎﺑﻠﻴﺖ ﺑﻪ ‪ Master‬اﺟﺎزه‬

‫ﺗﻐﻴﻴﺮ ‪ Slave‬را ﺑﺪون از دﺳﺖ دادن ﻛﻨﺘﺮل ﺑﺎس ﻣﻲ دﻫﺪ‪.‬‬

‫ﻣﻘﺎدﻳﺮ رﺟﻴﺴﺘﺮ ‪ TWSR‬در وﺿﻌﻴﺖ ﻫﺎي ﻣﺨﺘﻠﻒ ﺣﺎﻟﺖ ‪ Master Transmitter‬ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫ﻣﻘﺪار‬ ‫وﺿﻌﻴﺖ ﺑﻌﺪي ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻮﺳﻴﻠﻪ ي ‪ TWI‬اﻧﺠﺎم‬

‫ﻋﻤﻠﻜﺮد‬
‫‪TWSR‬‬ ‫ﺷﻮد‬

‫‪0x08‬‬ ‫وﺿﻌﻴﺖ ﺷﺮوع اﻳﺠﺎد ﺷﺪه اﺳﺖ‪.‬‬ ‫ارﺳﺎل ‪ SLA+W‬و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫ارﺳﺎل ‪ SLA+W‬و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫‪0x10‬‬ ‫وﺿﻌﻴﺖ ﺷﺮوع دوﺑﺎره اﻳﺠﺎد ﺷﺪه اﺳﺖ‪.‬‬
‫ارﺳﺎل ‪ SLA+R‬و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫  ‬
‫‪P a g e | 158‬‬
‫‪www.avr.ir‬‬
‫ارﺳﺎل ﺑﺎﻳﺖ داده و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫‪0x18‬‬ ‫ﺑﺎﻳﺖ ‪ SLA+W‬ارﺳﺎل ﺷﺪه و ‪ ACK‬درﻳﺎﻓﺖ ﺷﺪه اﺳﺖ‪.‬‬ ‫اﻳﺤﺎد ﺣﺎﻟﺖ ﺷﺮوع ﻣﺠﺪد‬

‫اﻳﺠﺎد ﺣﺎﻟﺖ ﭘﺎﻳﺎن‬

‫ﺑﺎﻳﺖ ‪ SLA+W‬ارﺳﺎل ﺷﺪه و ‪ ACK‬درﻳﺎﻓﺖ ﻧﺸﺪه‬ ‫اﻳﺤﺎد ﺣﺎﻟﺖ ﺷﺮوع ﻣﺠﺪد‬

‫‪0x20‬‬
‫اﺳﺖ‪.‬‬ ‫اﻳﺠﺎد ﺣﺎﻟﺖ ﭘﺎﻳﺎن‬

‫ارﺳﺎل ﺑﺎﻳﺖ داده و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫‪0x28‬‬ ‫ﺑﺎﻳﺖ داده ارﺳﺎل ﺷﺪه و ‪ ACK‬درﻳﺎﻓﺖ ﺷﺪه اﺳﺖ‪.‬‬ ‫اﻳﺤﺎد ﺣﺎﻟﺖ ﺷﺮوع ﻣﺠﺪد‬

‫اﻳﺠﺎد ﺣﺎﻟﺖ ﭘﺎﻳﺎن‬

‫ارﺳﺎل ﺑﺎﻳﺖ داده و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫‪0x30‬‬ ‫ﺑﺎﻳﺖ داده ارﺳﺎل ﺷﺪه و ‪ ACK‬درﻳﺎﻓﺖ ﻧﺸﺪه اﺳﺖ‪.‬‬ ‫اﻳﺤﺎد ﺣﺎﻟﺖ ﺷﺮوع ﻣﺠﺪد‬

‫اﻳﺠﺎد ﺣﺎﻟﺖ ﭘﺎﻳﺎن‬

‫‪0x38‬‬ ‫ﻛﻨﺘﺮل ﺑﺎس از دﺳﺖ رﻓﺘﻪ اﺳﺖ‪.‬‬ ‫ارﺳﺎل ﺣﺎﻟﺖ ﺷﺮوع و ﺗﻼش ﺑﺮاي ﻛﻨﺘﺮل ﻣﺠﺪد آن‬

‫ﻣﺜﺎل‪) :2‬ارﺳﺎل ﻋﺪد ‪ 0x77‬ﺑﻪ ‪ Slave‬ﺑﺎ آدرس ‪ 0xA0‬و ﺑﺎ ﻧﺮخ ﺑﻴﺖ ‪ 100‬ﻛﻴﻠﻮﻫﺮﺗﺰ(‬

‫>‪#include <mega16.h‬‬
‫‪#define xtal 8000000‬‬

‫)(‪void main‬‬
‫{‬

‫‪//--- Start Condition and Transmitting SLA+W ----‬‬

‫‪TWBR = 32; // Bit rate = 100Khz‬‬

‫‪TWCR = 0xA4; // Transmit Start Condition‬‬

‫  ‬
P a g e | 159
www.avr.ir

while(TWCR&0x80==0); // Waiting for TWINT flag

if(TWSR&0xF8==0x08) // Start Condition Transmitted?

{
TWDR=0xA0; // SLA+W
TWCR=0x84; // Enable TWI and Clear TWINT
}
else
goto error;

//--------------- Transmitting Data -------------

while(TWCR&0x80==0); // Waiting for TWINT flag

if(TWSR&0xF8==0x18) // SLA+W has been send with ACK?

{
TWDR=0x77; // Data=0x77
TWCR=0x84; // Enable TWI and Clear TWINT
}
else
goto error;

//--------- Transmitting Stop Condition ----------

while(TWCR&0x80==0); // Waiting for TWINT flag

if(TWSR&0xF8==0x28) // Data has been send with ACK?

TWCR=0x94; // Transmit Stop Condition

  
‫‪P a g e | 160‬‬
‫‪www.avr.ir‬‬
‫‪//------------------------------------------------‬‬

‫‪error:‬‬
‫;)‪while(1‬‬

‫}‬

‫ ‪(MR) Master Receiver‬‬

‫در اﻳﻦ وﺿﻌﻴﺖ ‪ Master‬اﻃﻼﻋﺎت را از ‪ Slave‬درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ و ﺑﺮاي اﻳﺠﺎد آن ﺑﺎﻳﺪ ﭘﺲ از اﻳﺠﺎد ﺷـﺮاﻳﻂ آﻏـﺎز‬

‫ﺑﺮ ﺧﻼف ﺣﺎﻟﺖ ﻗﺒﻞ ‪ SLA+R‬ﺑﻪ ‪ Slave‬ﻓﺮﺳﺘﺎده ﺷﻮد‪ .‬در ﺻﻮرﺗﻲ ﻛﻪ ﺷﺮاﻳﻂ آﻏﺎز ﺑﻪ درﺳـﺘﻲ اﻳﺠـﺎد ﺷـﺪه ﺑﺎﺷـﺪ‬

‫ﺑﻴﺖ ‪ TWINT‬ﻳﻚ ﺷﺪه و ﻣﻘﺪار ‪ TWSR‬ﺑﺮاﺑﺮ ‪ 0x08‬ﻣﻲ ﺷـﻮد‪ ،‬ﺑـﺮاي ارﺳـﺎل ‪ SLA+R‬ﺑﺎﻳـﺪ ﻣﻘـﺪار آن را در‬

‫‪ TWDR‬ﺑﺎرﮔﺬاري ﻛﺮده و ﺑﺎ ﭘﺎك ﻛﺮدن ‪ TWINT‬آن را ارﺳﺎل ﻧﻤﻮد‪.‬‬

‫زﻣﺎﻧﻲ ﻛﻪ ‪ SLA+R‬ﻓﺮﺳﺘﺎده ﺷﻮد و ‪ ACK‬درﻳﺎﻓﺖ ﺷﻮد ﺑﻴـﺖ ‪ TWINT‬ﻳـﻚ ﺷـﺪه و در اﻳـﻦ ﺷـﺮاﻳﻂ ﻳﻜـﻲ از‬

‫ﻛﺪﻫﺎي ‪ 0x40 ،0x38‬ﻳﺎ ‪ 0x48‬ﻣﻤﻜﻦ اﺳﺖ در ‪ TWSR‬ﻗﺮار ﮔﻴﺮد‪:‬‬

‫ﻣﻘﺪار‬ ‫وﺿﻌﻴﺖ ﺑﻌﺪي ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻮﺳﻴﻠﻪ ي ‪ TWI‬اﻧﺠﺎم‬

‫ﻋﻤﻠﻜﺮد‬
‫‪TWSR‬‬ ‫ﺷﻮد‬

‫‪0x08‬‬ ‫وﺿﻌﻴﺖ ﺷﺮوع اﻳﺠﺎد ﺷﺪه اﺳﺖ‪.‬‬ ‫ارﺳﺎل ‪ SLA+R‬و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫ارﺳﺎل ‪ SLA+R‬و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫‪0x10‬‬ ‫وﺿﻌﻴﺖ ﺷﺮوع دوﺑﺎره اﻳﺠﺎد ﺷﺪه اﺳﺖ‪.‬‬
‫ارﺳﺎل ‪ SLA+W‬و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫‪0x38‬‬ ‫ﻛﻨﺘﺮل ﺑﺎس از دﺳﺖ رﻓﺘﻪ اﺳﺖ‪.‬‬ ‫ارﺳﺎل ﺣﺎﻟﺖ ﺷﺮوع و ﺗﻼش ﺑﺮاي ﻛﻨﺘﺮل ﻣﺠﺪد آن‬

‫‪0x40‬‬ ‫ﺑﺎﻳﺖ ‪ SLA+R‬ارﺳﺎل ﺷﺪه و ‪ ACK‬درﻳﺎﻓﺖ ﺷﺪه اﺳﺖ‪.‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫ﺑﺎﻳﺖ ‪ SLA+R‬ارﺳﺎل ﺷﺪه و ‪ ACK‬درﻳﺎﻓﺖ ﻧﺸﺪه‬ ‫اﻳﺤﺎد وﺿﻌﻴﺖ ﺷﺮوع ﻣﺠﺪد‬

‫‪0x48‬‬
‫اﺳﺖ‪.‬‬ ‫اﻳﺠﺎد وﺿﻌﻴﺖ ﭘﺎﻳﺎن‬

‫
 ‬
‫‪P a g e | 161‬‬
‫‪www.avr.ir‬‬
‫‪0x50‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ACK‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫اﻳﺤﺎد وﺿﻌﻴﺖ ﺷﺮوع ﻣﺠﺪد‬

‫‪0x58‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪NACK‬‬
‫اﻳﺠﺎد وﺿﻌﻴﺖ ﭘﺎﻳﺎن‬

‫در ﺻﻮرﺗﻲ ﻛﻪ ‪ SLA+R‬ارﺳﺎل ﺷﺪه و ‪ ACK‬درﻳﺎﻓﺖ ﺷﺪه ﺑﺎﺷﺪ ﺑﻌﺪ از ﻳـﻚ ﺷـﺪن ‪ TWINT‬داده ي درﻳﺎﻓـﺖ‬

‫ﺷﺪه در ‪ TWDR‬ﻣﻲ ﺗﻮاﻧﺪ ﺧﻮاﻧﺪه ﺷﻮد‪ .‬اﻳﻦ ﻛﺎر ﺗﺎ درﻳﺎﻓﺖ آﺧﺮﻳﻦ ﺑﺎﻳـﺖ ﺗﻜـﺮار ﺷـﺪه و ﺑﻌـﺪ از آن ‪ Master‬ﺑـﺎ‬

‫ﻓﺮﺳﺘﺎدن ‪ NACK‬ﺑﻪ ‪ Slave‬اﻋﻼم ﻣﻲ ﻛﻨﺪ ﻛﻪ دﻳﮕﺮ ﻗﺼﺪ ﺧﻮاﻧﺪن از آن را ﻧﺪارد و در ﻧﺘﻴﺠـﻪ ﻣـﻲ ﺗـﻮان ﻋﻤﻠﻴـﺎت‬

‫ﺧﻮاﻧﺪن را ﺑﺎ اﻳﺠﺎد ﻳﻚ ﺷﺮاﻳﻂ ﺷﺮوع ﻣﺠﺪد ﻳﺎ ﭘﺎﻳﺎن ﻣﺘﻮﻗﻒ ﻧﻤﻮد‪.‬‬

‫ﻣﺜﺎل ‪) :3‬ﺧﻮاﻧﺪن ‪ 2‬ﺑﺎﻳﺖ داده از ‪ Slave‬ﺑﺎ آدرس ‪ 0xA0‬و ﻧﺮخ ﺑﻴﺖ ‪ 100‬ﻛﻴﻠﻮﻫﺮﺗﺰ(‬

‫>‪#include <mega16.h‬‬
‫‪#define xtal 8000000‬‬

‫;‪char incoming_data‬‬

‫)(‪void main‬‬
‫{‬

‫‪//----------- Sending Start Condition -----------‬‬

‫‪TWBR = 32; // Bit rate = 100Khz‬‬

‫‪TWCR = 0xA4; // Transmit Start Condition‬‬

‫‪while(TWCR&0x80==0); // Waiting for TWINT flag‬‬

‫‪//-------------- Sending SLA + R ----------------‬‬

‫  ‬
P a g e | 162
www.avr.ir

if(TWSR&0xF8==0x08) // Start Condition Transmitted?

{
TWDR=0xA1; // SLA+R
TWCR=0xC4; // Enable TWI and Clear TWINT
}
else
goto error;

//-------- Enable Master Acknowledging ----------

while(TWCR&0x80==0); // Waiting for TWINT flag

if(TWSR&0xF8==0x40) // SLA+R has been send with ACK?

TWCR=0xC4; // Master Acknowledging and clear TWINT

//--------------- Reading 1st byte --------------

while(TWCR&0x80==0); // Waiting for TWINT flag

if(TWSR&0xF8==0x50) // Master has been Received Data?

{
incoming_data = TWDR; // Reading Data
TWCR=0xC4; // Master Acknowledging and clear TWINT
}
else
goto error;

//---- Reading 2nd byte and Stop Condition ------

  
P a g e | 163
www.avr.ir
while(TWCR&0x80==0); // Waiting for TWINT flag

if(TWSR&0xF8==0x50) // Master has been Received Data?

{
Incoming_data=TWDR;
TWCR=0x94; // Master Not Acknowledging and clear
TWINT
}
else
goto error;

TWCR=0x94; // Transmit Stop Condition

//------------------------------------------------

error:
while(1);

(SR) Slave Receiver 

.‫ درﻳﺎﻓـﺖ ﻣـﻲ ﻛﻨـﺪ‬Master Transmitter ‫ ﺑﻮده و اﻃﻼﻋـﺎت را از‬Slave ،‫در اﻳﻦ وﺿﻌﻴﺖ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ﮔﻴﺮﻧﺪه‬

‫ ﻳـﻚ ﺷـﻮد‬LSB ‫ و ﭼﻨﺎﻧﭽـﻪ ﺑﻴـﺖ‬.‫ ﻗـﺮار ﮔﻴـﺮد‬TWAR ‫ ﺑﻴﺖ ﺑـﺎﻻي‬7 ‫ در‬Slave ‫ﺑﺮاي ﺷﺮوع ﺑﻪ ﻛﺎر ﺑﺎﻳﺪ آدرس‬

.‫ ﻗﺎدر ﺑﻪ ﭘﺎﺳﺨﮕﻮﻳﻲ ﻓﺮاﺧﻮاﻧﻲ ﻋﻤﻮﻣﻲ ﻧﻴﺰ ﺧﻮاﻫﺪ ﺑﻮد و در ﻏﻴﺮ اﻳﻨﺼﻮرت آن را ﻧﺎدﻳﺪه ﺧﻮاﻫﺪ ﮔﺮﻓﺖ‬Master

TWAR 7 6 5 4 3 2 1 0
‫ﻧﺎم ﺑﻴﺖ‬ TWAR[7:1] X

  
‫‪P a g e | 164‬‬
‫‪www.avr.ir‬‬

‫‪ TWCR‬ﻣﻄﺎﺑﻖ زﻳﺮ ﻣﻘﺪار دﻫﻲ ﺷﻮد‪:‬‬

‫‪TWC‬‬
‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪R‬‬
‫‪TWIN‬‬ ‫‪TWE‬‬ ‫‪TWST‬‬ ‫‪TWST‬‬ ‫‪TWW‬‬ ‫‪TWE‬‬ ‫‪TWI‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪-‬‬
‫‪T‬‬ ‫‪A‬‬ ‫‪A‬‬ ‫‪O‬‬ ‫‪C‬‬ ‫‪N‬‬ ‫‪E‬‬
‫ﻣﻘﺪار‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪X‬‬

‫ﺑﻴﺖ ‪ TWIE‬ﻳﻚ ﺷﺪه ﺗﺎ ﻣﺎژول ‪ TWI‬ﻓﻌﺎل ﺷﻮد‪.‬‬

‫ﺑﻴﺖ ‪ TWEA‬ﻳﻚ ﺷﺪه ﺗﺎ ارﺳﺎل ‪ ACK‬ﻓﻌﺎل ﺷﻮد‪.‬‬

‫ﺑﻴﺖ ﻫﺎي ‪ TWSTA‬و ‪ TWSTO‬ﺻﻔﺮ ﻣﻲ ﺑﺎﺷﻨﺪ زﻳﺮا اﻳﺠﺎد ﺷﺮاﻳﻂ آﻏﺎز و ﭘﺎﻳﺎن ﺑﺮ ﻋﻬﺪه ي ‪ Master‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﺑﻌﺪ از ﭘﻴﻜﺮﺑﻨﺪي ‪ ،Slave‬ﻣﻨﺘﻈﺮ ﺷﺪه ﺗﺎ ﺗﻮﺳﻂ ‪ Master‬آدرس دﻫﻲ ﺷﺪه و ﻳﺎ ﻳﻚ ﻓﺮاﺧﻮان ﻋﻤﻮﻣﻲ درﻳﺎﻓـﺖ ﻛﻨـﺪ‪.‬‬

‫اﮔﺮ در آدرس درﻳﺎﻓﺖ ﺷﺪه ﺑﻴﺖ ﺟﻬﺖ )‪ (W/R‬ﺻﻔﺮ ﺑﺎﺷﺪ ﻧﺸﺎن دﻫﻨـﺪه ي اﻳـﻦ اﺳـﺖ ﻛـﻪ ‪ Master‬ﻣـﻲ ﺧﻮاﻫـﺪ‬

‫ﻣﻘـﺪاري را ﺑـﻪ ‪ Slave‬ﺑﻔﺮﺳـﺘﺪ ﻛـﻪ در اﻳﻨﺼـﻮرت ‪ Slave‬وارد وﺿـﻌﻴﺖ )‪ Slave Read (SR‬ﺷـﺪه و در ﻏﻴـﺮ‬

‫اﻳﻨﺼﻮرت در ﺣﺎﻟﺖ )‪ Slave Transmiter (ST‬ﻗﺮار ﺧﻮاﻫﺪ ﮔﺮﻓﺖ‪ .‬ﭘﺲ از درﻳﺎﻓﺖ ‪ SLA+W‬ﺑﻴﺖ ‪TWINT‬‬

‫ﻳﻚ ﺷﺪه و وﺿﻌﻴﺖ ﺟﺎري در رﺟﻴﺴﺘﺮ ‪ TWSR‬وﺟﻮد ﺧﻮاﻫﺪ داﺷﺖ‪:‬‬

‫ﻣﻘﺪار ‪TWSR‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫وﺿﻌﻴﺖ ﺑﻌﺪي ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻮﺳﻴﻠﻪ ي ‪ TWI‬اﻧﺠﺎم ﺷﻮد‬

‫‪0x60‬‬ ‫ﺑﺎﻳﺖ ‪ SLA+W‬درﻳﺎﻓﺖ ﺷﺪه و ‪ ACK‬ارﺳﺎل ﺷﺪه اﺳﺖ‪.‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫ﻛﻨﺘﺮل ﺑﺎس در ﺣﻴﻦ ارﺳﺎل ‪ SLA + W‬ﺗﻮﺳﻂ ‪ Master‬از‬

‫‪0x68‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ ACK‬ﻳﺎ ‪NACK‬‬
‫دﺳﺖ رﻓﺘﻪ اﺳﺖ‪.‬‬

‫  ‬
‫‪P a g e | 165‬‬
‫‪www.avr.ir‬‬
‫‪0x70‬‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﻋﻤﻮﻣﻲ رﻳﺎﻓﺖ ﺷﺪه و ‪ ACK‬ارﺳﺎل ﺷﺪه اﺳﺖ‪.‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫ﻛﻨﺘﺮل ﺑﺎس در ﺣﻴﻦ ارﺳﺎل ﻓﺮاﺧﻮاﻧﻲ ﻋﻤﻮﻣﻲ ﺗﻮﺳﻂ ‪Master‬‬

‫‪0x78‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ ACK‬ﻳﺎ ‪NACK‬‬
‫از دﺳﺖ رﻓﺘﻪ اﺳﺖ‪.‬‬

‫‪0x80‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ ACK‬در ﻓﺮاﺧﻮاﻧﻲ اﺧﺘﺼﺎﺻﻲ‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫ﺗﻐﻴﻴﺮ ﺑﻪ ﺣﺎﻟﺖ ﺑﺪون آدرس و ﻳﺎ ارﺳﺎل ﺣﺎﻟﺖ ﺷﺮوع‬

‫‪0x88‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ NACK‬در ﻓﺮاﺧﻮاﻧﻲ اﺧﺘﺼﺎﺻﻲ‬
‫ﺑﺮاي ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ از ‪ Slave‬ﺑﻪ ‪Master‬‬

‫‪0x90‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ ACK‬در ﻓﺮاﺧﻮاﻧﻲ ﻋﻤﻮﻣﻲ‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫ﺗﻐﻴﻴﺮ ﺑﻪ ﺣﺎﻟﺖ ﺑﺪون آدرس و ﻳﺎ ارﺳﺎل ﺣﺎﻟﺖ ﺷﺮوع‬

‫‪0x98‬‬ ‫درﻳﺎﻓﺖ ﺑﺎﻳﺖ داده و ارﺳﺎل ‪ NACK‬در ﻓﺮاﺧﻮاﻧﻲ ﻋﻤﻮﻣﻲ‬
‫ﺑﺮاي ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ از ‪ Slave‬ﺑﻪ ‪Master‬‬

‫ﺗﻐﻴﻴﺮ ﺑﻪ ﺣﺎﻟﺖ ﺑﺪون آدرس و ﻳﺎ ارﺳﺎل ﺣﺎﻟﺖ ﺷﺮوع‬

‫‪0xA0‬‬ ‫درﻳﺎﻓﺖ ﺣﺎﻟﺖ ﭘﺎﻳﺎن و ﻳﺎ ﺷﺮوع دوﺑﺎره‬
‫ﺑﺮاي ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ از ‪ Slave‬ﺑﻪ ‪Master‬‬

‫در ﺻﻮرﺗﻲ ﻛﻪ ﻛﺪ ﺧﻮاﻧﺪه ﺷﺪه ‪ 0x60‬ﺑﺎﺷﺪ آدرس ﺑﺪرﺳﺘﻲ ﺗﻮﺳﻂ ‪ Slave‬درﻳﺎﻓﺖ ﺷﺪه و ﺑﺮاي ‪ Master‬ﺗﺼـﺪﻳﻖ‬

‫)‪ (ACK‬ﻧﻴﺰ ارﺳﺎل ﺷﺪه اﺳﺖ‪ .‬ﭘﺲ از اﻳﻦ ‪ Slave‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎﻳﺖ ﻫﺎي داده را درﻳﺎﻓﺖ ﻛﺮده و ﺗـﺎ زﻣـﺎﻧﻲ ﻛـﻪ ﻳـﻚ‬

‫ﺷﺮاﻳﻂ ﭘﺎﻳﺎن ﻳﺎ ﺷﺮوع ﻣﺠﺪد اﻳﺠﺎد ﺷﻮد اﻳﻦ روﻧﺪ اداﻣﻪ ﺧﻮاﻫﺪ داﺷﺖ ﻛﻪ در اﻳﻦ ﺻﻮرت ﻣﻘـﺪار رﺟﻴﺴـﺘﺮ ‪TWSR‬‬

‫ﺑﺮاﺑﺮ ‪ 0xA0‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫ﻣﺜﺎل ‪) :4‬درﻳﺎﻓﺖ ﻳﻚ ﺑﺎﻳﺖ داده ﺗﻮﺳﻂ ‪ Slave‬ﺑﺎ آدرس ‪ 0x01‬و ﻧﺮخ ﺑﻴﺖ ‪ 100‬ﻛﻴﻠﻮﻫﺮﺗﺰ(‬

‫>‪#include <mega16.h‬‬
‫‪#define xtal 8000000‬‬

‫;‪char incoming_data‬‬

‫)(‪void main‬‬
‫{‬

‫  ‬
P a g e | 166
www.avr.ir

//-------------- Initial Setting ---------------

TWAR = 0x01; // Slave Address

TWBR = 32; // Bit rate = 100Khz
TWCR = 0xC4; // Clear Int, Set TWEA and TWEN

while(TWCR&0x80==0); // Waiting for TWINT flag

//--------- Transmit a Byte to Master ----------

if(TWSR&0xF8==0x60) // SLA+W Received?

{
TWCR = 0xC4; // Clear Int, Set TWEA and TWEN
}
else
goto error;

//------------ Slave Receive a Byte ------------

while(TWCR&0x80==0); // Waiting for TWINT flag

if(TWSR&0xF8==0x80) // Slave has been Receive Byte?

{
incoming_data=TWDR; //Receive incoming data
TWCR=0x84; // Clear TWINT
}
else
goto error;

  
‫‪P a g e | 167‬‬
‫‪www.avr.ir‬‬
‫‪//---------- Receiving Stop Condition ----------‬‬

‫‪while(TWCR&0x80==0); // Waiting for TWINT flag‬‬

‫?‪if ((TWSR & 0xF8)== 0x0A0) //Stop Condition Received‬‬

‫‪TWCR=0x84; // Clear TWINT‬‬

‫‪error:‬‬
‫;)‪while(1‬‬

‫}‬

‫ ‪(ST) Slave Transmitter‬‬

‫اﻳﻦ وﺿﻌﻴﺖ ﻣﺸﺎﺑﻪ ‪ SR‬ﻣﻲ ﺑﺎﺷﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ ﺑﻌﺪ از درﻳﺎﻓﺖ آدرس ﺑﻴﺖ ‪ W/R‬ﻳﻚ ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ‬

‫‪ Master‬اﻋﻼم ﻣﻲ ﻛﻨﺪ ﻛﻪ ﻣﻲ ﺧﻮاﻫﺪ ﻣﻘﺪاري را از ‪ Slave‬ﺑﺨﻮاﻧﺪ و در ﻧﺘﻴﺠﻪ ‪ Slave‬ﻓﺮﺳﺘﻨﺪه ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬

‫ﭘﺲ از درﻳﺎﻓﺖ آدرس ﺑﻴﺖ ‪ TWINT‬ﻳﻚ ﺷﺪه و ﻣﻲ ﺗﻮان ﻛﺪ وﺿﻌﻴﺖ ﺟﺎري را از ‪ TWSR‬ﺑﺪﺳﺖ آورد‪ ،‬ﺑﻌﺪ ار‬

‫ارﺳﺎل ﻫﺮ ﺑﺎﻳﺖ داده از ‪ Master ،Slave‬ﺑﺎ ﻓﺮﺳﺘﺎدن ‪ ACK‬آن را ﺗﺼﺪﻳﻖ ﻣﻲ ﻛﻨﺪ و ﭼﻨﺎﻧﭽﻪ ‪ Master‬ﺑﺨﻮاﻫﺪ‬

‫آﺧﺮﻳﻦ ﺑﺎﻳﺖ را در درﻳﺎﻓﺖ ﻛﻨﺪ ‪ NACK‬ارﺳﺎل ﺧﻮاﻫﺪ ﻧﻤﻮد )‪.(TWSR=0xC0‬‬

‫ﻣﻘﺪار ‪TWSR‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫وﺿﻌﻴﺖ ﺑﻌﺪي ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻮﺳﻴﻠﻪ ي ‪ TWI‬اﻧﺠﺎم ﺷﻮد‬

‫‪0xA8‬‬ ‫ﺑﺎﻳﺖ ‪ SLA+R‬درﻳﺎﻓﺖ ﺷﺪه و ‪ ACK‬ارﺳﺎل ﺷﺪه اﺳﺖ‪.‬‬ ‫ارﺳﺎل ﺑﺎﻳﺖ داده و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫  ‬
‫‪P a g e | 168‬‬
‫‪www.avr.ir‬‬
‫ﻛﻨﺘﺮل ﺑﺎس در ﺣﻴﻦ ارﺳﺎل ‪ SLA + W‬ﺗﻮﺳﻂ ‪ Master‬از‬
‫‪0xB0‬‬ ‫ارﺳﺎل ﺑﺎﻳﺖ داده و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬
‫دﺳﺖ رﻓﺘﻪ اﺳﺖ‪.‬‬

‫‪0xB8‬‬ ‫ارﺳﺎل ﺑﺎﻳﺖ داده و درﻳﺎﻓﺖ ‪ACK‬‬ ‫ارﺳﺎل ﺑﺎﻳﺖ داده و درﻳﺎﻓﺖ ‪ ACK‬ﻳﺎ ‪NACK‬‬

‫ﺗﻐﻴﻴﺮ ﺑﻪ ﺣﺎﻟﺖ ﺑﺪون آدرس و ﻳﺎ ارﺳﺎل ﺣﺎﻟﺖ ﺷﺮوع‬

‫‪0xC0‬‬ ‫ارﺳﺎل ﺑﺎﻳﺖ داده و درﻳﺎﻓﺖ ‪NACK‬‬
‫ﺑﺮاي ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ از ‪ Slave‬ﺑﻪ ‪Master‬‬

‫ﺗﻐﻴﻴﺮ ﺑﻪ ﺣﺎﻟﺖ ﺑﺪون آدرس و ﻳﺎ ارﺳﺎل ﺣﺎﻟﺖ ﺷﺮوع‬

‫‪0xC8‬‬ ‫ارﺳﺎل آﺧﺮﻳﻦ ﺑﺎﻳﺖ داده و درﻳﺎﻓﺖ ‪(TWEA=0) ACK‬‬
‫ﺑﺮاي ﺗﻐﻴﻴﺮ وﺿﻌﻴﺖ از ‪ Slave‬ﺑﻪ ‪Master‬‬

‫ﻣﺜﺎل ‪) :5‬ﺧﻮاﻧﺪن ﻳﻚ ﺑﺎﻳﺖ داده از ‪ Slave‬ﺑﺎ آدرس ‪ 0x01‬و ﻧﺮخ ﺑﻴﺖ ‪ 100‬ﻛﻴﻠﻮﻫﺮﺗﺰ(‬

‫>‪#include <mega16.h‬‬
‫‪#define xtal 8000000‬‬

‫)(‪void main‬‬
‫{‬

‫‪//-------------- Initial Setting ---------------‬‬

‫‪TWAR = 0x01 // Slave Address‬‬

‫‪TWBR = 32; // Bit rate = 100Khz‬‬
‫‪TWCR = 0xC4; // Clear Int, Set TWEA and TWEN‬‬

‫‪while(TWCR&0x80==0); // Waiting for TWINT flag‬‬

‫‪//--------- Transmit a Byte to Master ----------‬‬

‫?‪if(TWSR&0xF8==0xA8) // SLA+R Received‬‬

‫{‬
‫‪TWDR=0x77; // Transmitt 0x77‬‬
‫  ‬
P a g e | 169
www.avr.ir
TWCR = 0xC4; // Clear Int, Set TWEA and TWEN
}
else
goto error;

//------------- Wait for ACK or NACK -----------

while(TWCR&0x80==0); // Waiting for TWINT flag

if(TWSR&0xF8!=0xC0) // Slave has been send NACK?

goto error;

//-----------------Error Sub -------------------

error:
while(1);

}
:‫ﻫﻤﺰﻣﺎن ﺳﺎزي ﭘﺎﻟﺲ ﺳﺎﻋﺖ‬

‫ ﻗﺮار ﻣﻲ دﻫﺪ و‬SCL ‫ ﭘﺎﻟﺲ ﺳﺎﻋﺖ ﺧﻮد را ﺑﺮ روي‬Master ‫ ﻫﺮ‬.‫ ﻫﺎ ﺗﻮﻟﻴﺪ ﻣﻲ ﮔﺮدد‬Master ‫ﭘﺎﻟﺲ ﺳﺎﻋﺖ ﺗﻮﺳﻂ‬

‫ ﺷﺪه و ﺑﺎﻋـﺚ ﺗﻮﻟﻴـﺪ ﻳـﻚ ﭘـﺎﻟﺲ‬AND ‫ ﭘﺎﻟﺲ ﺳﺎﻋﺖ ﻫﺎ ﺑﺎ ﻫﻢ‬I2C ‫ در ﺑﺎس‬wired-AND ‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺧﺎﺻﻴﺖ‬

.‫ﺳﺎﻋﺖ ﻣﺸﺘﺮك ﻣﻲ ﮔﺮدد‬

  
‫‪P a g e | 170‬‬
‫‪www.avr.ir‬‬

‫‪ Arbitration‬در ﺳﻴﺴﺘﻢ ﻫﺎي داراي ﭼﻨﺪ ‪Master‬‬

‫ﻫﺮ ‪ Master‬ﺗﻨﻬﺎ در زﻣﺎﻧﻲ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﺑﺎس دﺳﺘﺮﺳﻲ ﭘﻴﺪا ﻛﻨﺪ ﻛـﻪ ﺧـﻂ ‪ SDA‬آزاد ﺑﺎﺷـﺪ‪ .‬اﻣـﺎ ﭘﺮوﺗﻜـﻞ ‪ I2C‬ﺑـﻪ‬

‫ﺷﻜﻠﻲ ﻃﺮاﺣﻲ ﺷﺪه اﺳﺖ ﻛﻪ در ﺻﻮرﺗﻴﻜﻪ در ﺷﺮاﻳﻂ آزاد ﺑـﻮدن ﺑـﺎس دو ﻳـﺎ ﭼﻨـﺪ ‪ Master‬ﻫﻤﺰﻣـﺎن درﺧﻮاﺳـﺖ‬

‫دﺳﺘﺮﺳﻲ ﺑﻪ ﺑﺎس را داﺷﺘﻪ ﺑﺎﺷﻨﺪ ﺑﺪون از دﺳﺖ رﻓﺘﻦ اﻃﻼﻋﺎت ارﺗﺒﺎط ﺣﻔـﻆ ﺷـﻮد‪ .‬در اﻳﻨﺠـﺎ ﻧﻴـﺰ وﺟـﻮد ﺧﺎﺻـﻴﺖ‬

‫‪ Wired-AND‬ﺑﺎﻋﺚ ﺣﻞ ﻣﺸﻜﻞ ﻣﻲ ﮔﺮدد ﻳﻌﻨﻲ ﭼﻨﺪ ‪ Master‬ﺑﻄﻮر ﻫﻤﺰﻣﺎن داده ﻫﺎﻳﺸﺎن را ﺑﺮ روي ﺧﻂ ‪SDA‬‬

‫ﺑﻪ ﺻﻮرت ﺳﺮﻳﺎل ارﺳﺎل ﻣﻲ دارﻧﺪ ﻛﻪ اﻳﻦ ﺑﻴﺖ ﻫﺎ ﺑﺎ ﻫﻢ ‪ AND‬ﺷﺪه و ﺑﺮ روي ﺑﺎس ﻳﻚ دﻳﺘﺎي واﺣﺪ را اﻳﺠﺎد ﻣـﻲ‬

‫ﻛﻨﺪ‪ ،‬در اوﻟﻴﻦ ﻣﻜﺎﻧﻲ ﻛﻪ ﺧﻂ ‪ SDA‬ﺑﺎ ﺧﻂ داده ﻣﺮﺑﻮط ﺑﻪ ﻳﻚ ‪ Master‬ﻣﻄﺎﺑﻘـﺖ ﻧﺪاﺷـﺖ آن ‪ Master‬ﺧـﻂ داده‬

‫ﺳﺮﻳﺎل را در ﺳﻄﺢ ﻳﻚ ﻣﻨﻄﻘﻲ رﻫﺎ ﻣﻲ ﻛﻨﺪ )ﺣﺎﻟﺖ ﭘﻴﺶ ﻓﺮض ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ وﺟﻮد ‪ Pull-up‬ﺳﻄﺢ ﻳﻚ ﻣﻲ ﺑﺎﺷﺪ( ﺗـﺎ‬

‫ﺑﺮ روي ﻛﺎر دﻳﮕﺮ ‪ Master‬ﻫﺎ اﺧﻼﻟﻲ اﻳﺠﺎد ﻧﻜﻨﺪ‪.‬‬

‫
 ‬
‫‪P a g e | 171‬‬
‫‪www.avr.ir‬‬

‫ﻫﻤﺎن ﻃﻮر ﻛﻪ دﻳﺪه ﻣﻲ ﺷﻮد ﻣﺴﺎﻟﻪ ‪ Arbitration‬ﺗﻨﻬﺎ در ﻣﻮرد ﺣﺎﻟﺘﻲ ﻣﻌﻨﻲ دارد ﻛﻪ ﭼﻨـﺪ ‪ Master‬داﺷـﺘﻪ ﺑﺎﺷـﻴﻢ‬

‫زﻳﺮا‪:‬‬

‫در ﻣﻮرد ‪ Slave‬ﻫﺎ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﻳﻨﻜﻪ در ﻫﺮ زﻣﺎن ﻳﻚ ‪ Slave‬آدرس دﻫـﻲ ﻣـﻲ ﺷـﻮد و ﺣـﻖ دﺳﺘﺮﺳـﻲ ﺑـﻪ‬ ‫‪.١‬‬

‫‪ SDA‬را دارد ﻣﻌﻨﻲ ﻧﺨﻮاﻫﺪ داﺷﺖ‪.‬‬

‫ﻳﻚ ‪ Master‬دﻳﮕﺮ رﻗﻴﺒﻲ ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ ﺧﻂ ‪ SDA‬ﻧﺪارد‪.‬‬ ‫‪.٢‬‬

‫دﺳﺘﺮﺳﻲ ﻧﺮم اﻓﺰاري ﺑﻪ ‪ I2C‬در ‪CodeVision‬‬

‫ﻛﺎﻣﭙﺎﻳﻠﺮ ‪ CodeVision‬ﺑﺎ اراﺋﻪ ي ﻳﻚ ﺳﺮي ﺗﻮاﺑﻊ ﻣﺮﺑﻮط ﺑﻪ ﺑﺎس ‪ ،I2C‬اﻣﻜﺎن اﻳﺠﺎد اﻳﻦ ﭘﺮوﺗﻜﻞ را ﺑﻪ ﺻﻮرت ﻧﺮم‬

‫اﻓﺰاري ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ دﻫﺪ‪ .‬ﭘﻴﻦ ﻫﺎي ‪ SDA‬و ‪ SCL‬ﺑﺎﻳﺪ ﺗﻮﺳﻂ ﻧﺮم اﻓﺰار ﺑﻪ ﺻﻮرت زﻳﺮ ﺗﻌﻴﻴﻦ ﺷﻮﻧﺪ‪:‬‬

‫‪#asm‬‬
‫  ‬
‫‪P a g e | 172‬‬
‫‪www.avr.ir‬‬

‫‪.equ __i2c_port=0x18‬‬
‫‪.equ __sda_bit=3‬‬
‫‪.equ __scl_bit=4‬‬

‫‪#endasm‬‬

‫در اﻳﻦ ﻗﻄﻌﻪ ﻛﺪ ﭘﻴﻦ ﻫﺎي ‪ 3‬و ‪ 4‬از ‪ PORTB‬ﺑﻪ ﻋﻨﻮان ‪ SDA‬و ‪ SCL‬ﺗﻌﻴﻴﻦ ﺷﺪه اﻧﺪ‪.‬‬

‫ﺗﻮاﺑﻊ ‪ I2C‬در ﻛﺎﻣﭙﺎﻳﻠﺮ ‪CodeVision‬‬

‫)(‪:i2c_init‬‬

‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻨﻈﻴﻤﺎت اوﻟﻴﻪ ي ﺑﺎس ‪ I2C‬را اﻧﺠﺎم داده و ﺑﺎﻳﺪ ﻗﺒﻞ از اﺳﺘﻔﺎده از ﺗﻮاﺑﻊ دﻳﮕﺮ ﺑﻪ ﺑﻪ ﻛﺎر ﺑﺮده ﺷﻮد‪.‬‬

‫)(‪:i2c_start‬‬

‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﺷﺮاﻳﻂ آﻏﺎز اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ و در ﺻﻮرﺗﻲ ﻛﻪ ﺑﺎس آزاد ﺑﺎﺷﺪ ﻣﻘﺪار ﻳﻚ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ و در ﻏﺮ اﻳﻦ‬

‫ﺻﻮرت ﺧﺮوﺟﻲ اﻳﻦ ﺗﺎﺑﻊ ﺻﻔﺮ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬

‫)(‪:i2c_stop‬‬

‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﺷﺮاﻳﻂ ﭘﺎﻳﺎن ﺑﺮ روي ﺑﺎس ‪ I2C‬اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ‪.‬‬

‫)(‪:i2c_read‬‬

‫  ‬
‫‪P a g e | 173‬‬
‫‪www.avr.ir‬‬
‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﺑﺎﻳﺖ را از ﺑﺎس ‪ I2C‬ﺧﻮاﻧﺪه و ﺷﻜﻞ ﻛﻠﻲ آن ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫)‪unsigned char i2c_read(unsigned char ack‬‬

‫ﭘﺎراﻣﺘﺮ ‪ ack‬ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ ﻛﻪ آﻳﺎ ﭘﺲ از درﻳﺎﻓﺖ ﻳﻚ ﺑﺎﻳﺖ ‪ acknowledgement‬ارﺳﺎل ﺷﻮد ﻳﺎ ﺧﻴﺮ‪ .‬در ﺻﻮرﺗﻲ‬

‫ﻛﻪ اﻳﻦ ﭘﺎراﻣﺘﺮ ﻳﻚ ﺑﺎﺷﺪ ‪ ACK‬ارﺳﺎل ﺧﻮاﻫﺪ و در ﻏﻴـﺮ اﻳﻨﺼـﻮرت ﺑـﺎ اﻳﺠـﺎد ﻧﻜـﺮدن ‪ ACK‬ﺑـﻪ ﺻـﻮرت ﭘﺴـﻴﻮ‬

‫‪ NACK‬اﻳﺠﺎد ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫)(‪:i2c_write‬‬

‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﺑﺎﻳﺖ را ﺑﻪ ﺑﺎس ‪ I2C‬ارﺳﺎل ﻛﺮده و ﺷﻜﻞ ﻛﻠﻲ آن ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫)‪unsigned char i2c_write(unsigned char data‬‬

‫ﻣﺘﻐﻴﺮ ‪ data‬ﻣﻘﺪار ارﺳﺎﻟﻲ ﺑﻪ ﺑﺎس ﺑﻮده و در ﺻﻮرﺗﻲ ﻛﻪ ‪ ACK ،Slave‬اﻳﺠﺎد ﻛﻨﺪ اﻳﻦ ﺗﺎﺑﻊ ﻣﻘـﺪار ﻳـﻚ و در ﻏﻴـﺮ‬

‫اﻳﻨﺼﻮرت ﻣﻘﺪار ﺻﻔﺮ ﺑﺎز ﻣﻲ ﮔﺮداﻧﺪ‪.‬‬

‫ﭘﺮوژه ‪ :12‬ارﺗﺒﺎط ﺑﺎ ‪ EEPROM‬ﻫﺎي ‪I2C‬‬

‫  ‬
P a g e | 174
www.avr.ir
:‫ﺷﻤﺎﺗﻴﻚ‬

:‫ﻧﺮم اﻓﺰار‬

#include<mega16.h>
#define xtal 1000000

/* the I2C bus is connected to PORTB */

/* the SDA signal is bit 3 */
/* the SCL signal is bit 4 */

#asm

.equ __i2c_port=0x18
.equ __sda_bit=3

  
P a g e | 175
www.avr.ir
.equ __scl_bit=4

#endasm

/* now you can include the I2C Functions */

#include <i2c.h>

/* function declaration for delay_ms */

#include <delay.h>

#define EEPROM_BUS_ADDRESS 0xa0

/* read a byte from the EEPROM */

unsigned char eeprom_read(unsigned char address) {
unsigned char data;
i2c_start();
i2c_write(EEPROM_BUS_ADDRESS);
i2c_write(address);
i2c_start();
i2c_write(EEPROM_BUS_ADDRESS | 1);
data=i2c_read(0);
i2c_stop();
return data;
}

/* write a byte to the EEPROM */

void eeprom_write(unsigned char address, unsigned char
data) {

  
P a g e | 176
www.avr.ir
i2c_start();
i2c_write(EEPROM_BUS_ADDRESS);
i2c_write(address);
i2c_write(data);
i2c_stop();

/* 10ms delay to complete the write operation */

delay_ms(10);
}

void main(void) {
unsigned char i;
DDRD=0xFF;

/* initialize the I2C bus */

i2c_init();

/* write the byte 55h at address 10h */

eeprom_write(0x10,0x55);

/* read the byte from address AAh */

i=eeprom_read(0x10);
PORTD=i;

while (1); /* loop forever */

}

‫ﻣﺒﺪل آﻧﺎﻟﻮگ ﺑﻪ دﻳﺠﻴﺘﺎل‬

  
‫‪P a g e | 177‬‬
‫‪www.avr.ir‬‬

‫ﻋﻤﺪه روش ﻫﺎﻳﻲ ﻛﻪ ﺑﺮاي ﺗﺒﺪﻳﻞ آﻧﺎﻟﻮگ ﺑﻪ دﻳﺠﻴﺘﺎل وﺟﻮد دارﻧﺪ ﻋﺒﺎرﺗﻨﺪ از‪ :‬ﺗﺒﺪﻳﻞ آﻧـﻲ ﻳـﺎ ‪ ،Flash‬روش ﺗﻘﺮﻳـﺐ‬

‫ﻫــﺎي ﻣﺘــﻮاﻟﻲ ﻳــﺎ ‪ ،Successive Approximation‬ﻣﺒــﺪل ﻫــﺎي ‪،Ramp-Compare ،Delta-Encoded‬‬

‫‪ Sigma-Delta ،Pipeline ADC‬و ﻏﻴﺮه ﻛﻪ از اﻳﻦ ﻣﻴﺎن ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮﻫﺎي ‪ AVR‬از روش ﺗﻘﺮﻳﺐ ﻫﺎي ﻣﺘـﻮاﻟﻲ‬

‫اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻨﺪ‪.‬‬

‫اﺻﻮل ﺗﺒﺪﻳﻞ ﺑﺎ روش ﺗﻘﺮﻳﺐ ﻫﺎي ﻣﺘﻮاﻟﻲ‬

‫ﺑﻠﻮك دﻳﺎﮔﺮام ﺳﺎده ﺷﺪه ي اﻳﻦ ﻣﺒﺪل ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪:‬‬

‫‪ :Sample and Hold‬ﻣﺒﺪل آﻧﺎﻟﻮگ ﺑﻪ دﻳﺠﻴﺘﺎل ﺑﺮاي ﺗﺒﺪﻳﻞ ﻳﻚ ﻧﻤﻮﻧﻪ ي آﻧﺎﻟﻮگ ﺑﻪ ﻣﻘﺪار ﺑﺎﻳﻨﺮي ﻣﺘﻨـﺎﻇﺮ ﺑـﺎ آن‬

‫ﻧﻴﺎز ﺑﻪ ﻳﻚ ورودي ‪ Stable‬دارد ﻛﻪ اﻳﻦ ﻃﺮﻳﻖ ﻣﺪار ‪ Sample and Hold‬اﻳﺠﺎد ﻣـﻲ ﺷـﻮد‪ .‬در ﺷـﻜﻞ زﻳـﺮ ﻳـﻚ‬

‫  ‬
‫‪P a g e | 178‬‬
‫‪www.avr.ir‬‬
‫ﻧﻤﻮﻧﻪ ي ﺑﺴﻴﺎر ﺳﺎده از آن را ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ‪ ،‬ﻛﻠﻴﺪ‪ ،‬ﺳﻴﮕﻨﺎل ورودي را ﺑﺎ ﻫﺮ ﻧﻤﻮﻧﻪ ي ﺑﺮداﺷﺘﻪ ﺷﺪه ﺑﻪ ﺧﺎزن وﺻﻞ‬

‫ﻣﻲ ﻛﻨﺪ و ﺧﺎزن ﻧﻴﺰ ﻣﻘﺪار وﻟﺘﺎژ را ﺗﺎ ﻧﻤﻮﻧﻪ ي ﺑﻌﺪي ﺛﺎﺑﺖ ﻧﮕﺎه ﻣﻲ دارد‪.‬‬

‫‪ :Successive Approximation Register‬اﻳﻦ رﺟﻴﺴﺘﺮ ﻣﻘﺪار ﺗﻘﺮﻳﺐ زده ﺷﺪه ي دﻳﺠﻴﺘﺎل را ﺑﺮاي ﻣﻘﺎﻳﺴﻪ‬

‫ﺑﻪ ‪ DAC‬ﻣﻲ دﻫﺪ‪.‬‬

‫اﻟﮕﻮرﻳﺘﻢ ﺗﺒﺪﻳﻞ‪:‬‬

‫اﺑﺘﺪا رﺟﻴﺴﺘﺮ ‪ SAR‬ﺑﺎ ﻋﺪد ﺑﺎﻳﻨﺮي ‪ 10000000‬ﺑﺎرﮔﺬاري ﻣﻲ ﺷﻮد و اﻳﻦ ﻋﺪد ﺗﻮﺳـﻂ ‪ DAC‬ﺑـﺎ ﻣﻘـﺪار آﻧـﺎﻟﻮگ‬

‫ورودي ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮد‪ .‬در ﺻﻮرﺗﻲ ﻛﻪ ﻋﺪد ﻣﻘﺎﻳﺴﻪ ﺷﺪه ﺑﺰرﮔﺘﺮ ﺑﺎﺷﺪ و ﺧﺮوﺟﻲ ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨـﺪه ﺑﺎﻋـﺚ ﻣـﻲ ﺷـﻮد‪،‬‬

‫‪ SAR‬ﺑﻴﺖ ‪ MSB‬را ﭘﺎك ﻛﺮده و ﺑﻴﺖ ﻗﺒﻞ از آن را ﻳﻚ ﻛﻨﺪ و در ﻧﺘﻴﺠﻪ ﻋﺪد ‪ 01000000‬در ‪ DAC‬ﺑﺎرﮔـﺬاري‬

‫ﻣﻲ ﺷﻮد‪ .‬در ﺻﻮرﺗﻲ ﻛﻪ ﻋﺪد ﻣﻘﺎﻳﺴﻪ ﺷﺪه ﻛﻮﭼﻜﺘﺮ ﺑﺎﺷﺪ ﺧﺮوﺟﻲ ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ﺑﺎﻋﺚ ﻣﻲ ﺷﻮد ﺑﻴـﺖ ﻛـﻮﭼﻜﺘﺮ ﻧﻴـﺰ‬

‫ﻳﻚ ﺷﺪه و در ﻧﺘﻴﺠﻪ ﻋﺪد ‪ 11000000‬در ورودي ‪ DAC‬ﺑﺎرﮔﺬاري ﺷﻮد‪ .‬اﻳﻦ ﻋﻤﻞ ﺗﺎ ﭘﻴـﺪا ﺷـﺪن ﻣﻘـﺪار آﻧـﺎﻟﻮگ‬

‫اداﻣﻪ داﺷﺘﻪ و در اﻳﻦ زﻣﺎن ﺑﻴﺖ ‪ End of Conversion‬ﺑﻪ ﻧﺸﺎﻧﻪ ي ﭘﺎﻳﺎن ﺗﺒﺪﻳﻞ ﻳﻚ ﻣﻲ ﺷﻮد‪.‬‬

‫ﺑﺮﺧﻲ از ﻣﺸﺨﺼﺎت ‪ ADC‬ﻗﻄﻌﻪ ي ‪:ATmega16‬‬

‫‪• 10-bit Resolution‬‬

‫  ‬
P a g e | 179
www.avr.ir
• ±2 LSB Absolute Accuracy
• 65 - 260 µs Conversion Time
• Up to 15 kSPS at Maximum Resolution
• 8 Multiplexed Single Ended Input Channels
• 7 Differential Input Channels
• 2 Differential Input Channels with Optional Gain of 10x and 200x
• 0 - VCC ADC Input Voltage Range
• Selectable 2.56V ADC Reference Voltage
• Free Running or Single Conversion Mode
• ADC Start Conversion by Auto Triggering on Interrupt Sources
• Interrupt on ADC Conversion Complete
• Sleep Mode Noise Canceler

‫ اﻋﻤﺎل‬ADC ‫ ﻣﻲ ﺑﺎﺷﻨﺪ ﻛﻪ ﺑﻪ ﺻﻮرت ﻣﺎﻟﺘﻲ ﭘﻠﻜﺲ ﺷﺪه ﺑﻪ‬PORA ‫ ﻋﻤﻠﻜﺮد دوم‬ADC ‫ﭘﻴﻦ ﻫﺎي ورودي‬

‫ و وﻟﺘﺎژ‬AREF ‫ ﭘﻴﻦ‬،AVCC ‫ وﻟﺘﺎژ ورودي ﺑﻴﻦ ﺻﻔﺮ ﺗﺎ وﻟﺘﺎژ ﻣﺮﺟﻊ ﺑﻮده و وﻟﺘﺎژ ﻣﺮﺟﻊ از ﺳﻪ ﻣﻨﺒﻊ‬.‫ﻣﻲ ﺷﻮﻧﺪ‬

‫ ﺗﻐﺬﻳﻪ ي آن ﺑﻪ ﺻﻮرت‬ADC ‫ ﺟﻬﺖ ﻛﺎﻫﺶ ﻧﻮﻳﺰ ﻣﻮﺛﺮ ﺑﺮ روي واﺣﺪ‬.‫ وﻟﺖ ﻗﺎﺑﻞ ﺗﺎﻣﻴﻦ ﻣﻲ ﺑﺎﺷﺪ‬2.56 ‫داﺧﻠﻲ‬

‫ در‬.‫ ﺗﻔﺎوت داﺷﺘﻪ ﺑﺎﺷﺪ‬VCC ‫ وﻟﺖ ﺑﺎ‬0.3 ‫ وﻟﺘﺎژ اﻳﻦ ﭘﻴﻦ ﻧﺒﺎﻳﺪ ﺑﻴﺸﺘﺮ از‬.‫ ﺗﺎﻣﻴﻦ ﻣﻲ ﺷﻮد‬AVCC ‫ﺟﺪاﮔﺎﻧﻪ از ﭘﻴﻦ‬

VCC ‫ اﻳﻦ ﭘﺎﻳﻪ ﺑﻪ‬LC ‫ ﻣﻲ ﺗﻮان ﺑﻮﺳﻴﻠﻪ ي ﻳﻚ ﻓﻴﻠﺘﺮ‬،‫ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‬AVCC ‫ ﺑﻪ ﻋﻨﻮان‬VCC ‫ﺻﻮرﺗﻲ ﻛﻪ از‬

.‫ﻣﺘﺼﻞ ﻧﻤﻮد‬

  
‫‪P a g e | 180‬‬
‫‪www.avr.ir‬‬

‫رﺟﻴﺴﺘﺮﻫﺎي واﺣﺪ ‪ADC‬‬

‫‪ADC Multiplexer Selection Register‬‬

‫‪ADMUX‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪REFS1 REFS0 ADLAR MUX4 MUX3 MUX2 MUX1 MUX0‬‬

‫]‪ :Analog Channel and Gain Selection Bits[4:0‬اﻳﻦ ﺑﻴﺖ ﻫﺎ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨﺪ ﻛﻪ ﭼـﻪ ﺗﺮﻛﻴﺒـﻲ از ‪8‬‬

‫ﻛﺎﻧﺎل ورودي ﺑﻪ واﺣﺪ ‪ ADC‬ﻣﺘﺼﻞ ﺷﺪه و ﻫﻤﭽﻨﻴﻦ ﺑﻬﺮه ورودي ﺗﻔﺎﺿﻠﻲ را ﻧﻴﺰ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨـﺪ‪ .‬در ﺣﺎﻟـﺖ ﻫـﺎي‬

‫‪ Single-ended‬دﻗﺖ ‪ 10 ADC‬ﺑﻴﺘﻲ ﺑﻮده ﻛﻪ در ﺣﺎﻟﺖ ورودي دﻳﻔﺮاﻧﺴﻴﻞ ﺑﺎ ﺑﻬﺮه ي ‪ 1x‬و ‪ 10x‬اﻳﻦ ﻣﻘﺪار ﺑﻪ ‪8‬‬

‫ﺑﻴﺖ و ﺑﺎ ﺑﻬﺮه ي ‪ 200x‬ﺑﻪ ‪ 7‬ﺑﻴﺖ ﻛﺎﻫﺶ ﻣﻲ ﻳﺎﺑﺪ‪.‬‬

‫
 ‬
‫‪P a g e | 181‬‬
‫‪www.avr.ir‬‬
‫در ﺻﻮرﺗﻲ ﻛﻪ ‪ ADC‬ﻣﺸﻐﻮل اﻧﺠﺎم ﻳﻚ ﺗﺒﺪﻳﻞ ﺑﻮده و اﻳﻦ ﺑﻴﺖ ﻫﺎ ﺗﻐﻴﻴﺮ ﻛﻨﻨﺪ ﺗﺎ اﺗﻤﺎم ﺗﺒﺪﻳﻞ ﺟﺎري اﻳﻦ ﺗﻐﻴﻴﺮ اﻧﺠـﺎم‬

‫ﻧﺨﻮاﻫﺪ ﺷﺪ‪.‬ﺗﻨﻈﻴﻤﺎت اﻳﻦ ‪ 4‬ﺑﻴﺖ ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪) :‬ﻋﻤﻠﻜﺮد ﺗﻔﺎﺿـﻠﻲ ﻓﻘـﻂ ﺑـﺮ روي ‪ Package‬ﻫـﺎي‬

‫‪TQFP‬و ‪ MLF‬آزﻣﺎﻳﺶ ﺷﺪه اﺳﺖ‪(.‬‬

‫  ‬
‫‪P a g e | 182‬‬
‫‪www.avr.ir‬‬

‫‪ :ADC Left Adjust Result‬ﺑﻴﺖ ‪ ADLR‬ﺑﺮ ﻧﺤﻮه ﻧﻤﺎﻳﺶ ﻧﺘﻴﺠﻪ ي ﺗﺒﺪﻳﻞ در رﺟﻴﺴﺘﺮ داده ي ‪ ADC‬ﺗﺎﺛﻴﺮ‬

‫  ‬
‫‪P a g e | 183‬‬
‫‪www.avr.ir‬‬
‫ﻣﻲ ﮔﺬارد‪ .‬ﻧﻮﺷﺘﻦ ﻳﻚ در اﻳﻦ ﺑﻴﺖ آن را ﺑﻪ ﺻﻮرت ‪ Left Adjust‬ﺗﻨﻈﻴﻢ ﻣﻲ ﻛﻨﺪ و در ﻏﻴﺮ اﻳﻨﺼـﻮرت ﻧﺘﻴﺠـﻪ ﺑـﻪ‬

‫ﺻﻮرت ‪ Right Adjust‬ﺧﻮاﻫﺪ ﺑﻮد‪ .‬ﺗﻐﻴﻴﺮ اﻳﻦ ﺑﻴﺖ ﺑﻪ ﺻﻮرت آﻧﻲ ﺑﺮ روي رﺟﻴﺴﺘﺮ داده ﺗﺎﺛﻴﺮ ﻣﻲ ﮔﺬارد‪.‬‬

‫]‪ :Reference Selection Bits[1:0‬اﻳﻦ ﺑﻴﺖ ﻫﺎ ﻣﺮﺟﻊ وﻟﺘﺎژ ‪ ADC‬را ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨـﺪ‪ .‬در‬

‫ﺻﻮرﺗﻲ ﻛﻪ اﻳﻦ ﺑﻴﺖ ﻫﺎ در ﺣﻴﻦ ﺗﺒﺪﻳﻞ ﺗﻐﻴﻴﺮ ﻛﻨﻨﺪ ﺗﺎ اﺗﻤﺎم ﺗﺒﺪﻳﻞ ﺗﻐﻴﻴﺮ اﻋﻤﺎل ﻧﺨﻮاﻫﺪ ﺷﺪ‪ .‬در ﺻﻮرﺗﻲ ﻛـﻪ از ﻣﺮﺟـﻊ‬

‫وﻟﺘﺎژ داﺧﻠﻲ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ﻧﺒﺎﻳﺪ وﻟﺘﺎژ ﺧﺎرﺟﻲ ﺑﻪ ﭘﻴﻦ ‪ AREF‬اﻋﻤﺎل ﺷﻮد‪ .‬زﻣﺎﻧﻲ ﻛﻪ ﻳﻜﻲ از دو وﻟﺘﺎژ ‪ AREF‬ﻳﺎ‬

‫‪ 2.56‬وﻟﺖ ﺑﻪ ﻋﻨﻮان ﻣﺮﺟﻊ اﻧﺘﺨﺎب ﺷﺪه ﺑﺎﺷﻨﺪ ﺑﺎ اﺗﺼﺎل ﻳﻚ ﺧﺎزن ‪ 100‬ﻧﺎﻧﻮ ﺑـﻴﻦ ﭘـﻴﻦ ‪ AREF‬و زﻣـﻴﻦ ﻣـﻲ ﺗـﻮان‬

‫ﻣﻘﺪار ﻧﻮﻳﺰ را ﻛﺎﻫﺶ داد‪.‬‬

‫‪REFS1 REFS0‬‬ ‫وﻟﺘﺎژ ﻣﺮﺟﻊ‬

‫‪0‬‬ ‫‪0‬‬ ‫وﻟﺘﺎژ ﭘﺎﻳﻪ ي ‪AREF‬‬

‫‪0‬‬ ‫‪1‬‬ ‫وﻟﺘﺎژ ﭘﺎﻳﻪ ي ‪AVCC‬‬

‫‪1‬‬ ‫‪0‬‬ ‫رزرو ﺷﺪه‬

‫‪1‬‬ ‫‪1‬‬ ‫وﻟﺘﺎژ داﺧﻠﻲ ‪ 2.56‬وﻟﺖ‬

‫‪ADC Control and Status Register A‬‬

‫  ‬
‫‪P a g e | 184‬‬
‫‪www.avr.ir‬‬
‫‪ADCSRA‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫ﻧﺎم ﺑﻴﺖ‬ ‫‪ADEN ADSC ADATE ADIF ADIE ADPS2 ADPS1 ADPS0‬‬

‫]‪ :ADC Prescaler Select Bits[2:0‬اﻳﻦ ﺑﻴﺖ ﻫﺎ ﺿﺮﻳﺐ ﭘﻴﺶ ﺗﻘﺴﻴﻢ ﻛﻨﻨﺪه اي را ﻛﻪ از ﻛﻼك ﺳﻴﺴﺘﻢ ﺑﺮاي‬

‫واﺣﺪ ‪ ADC‬ﻛﻼك ﺗﺎﻣﻴﻦ ﻣﻲ ﻛﻨﺪ را ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫‪ADPS2‬‬ ‫‪ADPS1‬‬ ‫‪ADPS0‬‬ ‫ﺿﺮﻳﺐ ﺗﻘﺴﻴﻢ‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪2‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪2‬‬

‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪4‬‬

‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪8‬‬

‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪16‬‬

‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪32‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪64‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪128‬‬

‫‪ :ADC Interrupt Enable‬در ﺻﻮرت ﻳﻚ ﺑﻮدن ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﻋﻤﻮﻣﻲ وﻗﻔﻪ )‪ (I‬و ﻳﻚ ﺑﻮدن اﻳﻦ ﺑﻴﺖ‪ ،‬اﺗﻤﺎم‬

‫ﻳﻚ ﺗﺒﺪﻳﻞ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﺷﻮد‪.‬‬

‫  ‬
‫‪P a g e | 185‬‬
‫‪www.avr.ir‬‬
‫‪ :ADC Interrupt Flag‬ﺑﺎ اﺗﻤﺎم ﻳﻚ ﺗﺒﺪﻳﻞ اﻳﻦ ﭘﺮﭼﻢ ﻳﻚ ﺷﺪه و در ﺻﻮرت ﻓﻌﺎل ﺑﻮدن وﻗﻔـﻪ‪ ،‬اﺟـﺮاي ‪ISR‬‬

‫ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎﻋﺚ ﭘﺎك ﺷﺪن آن ﺷﻮد و در ﻏﻴﺮ اﻳﻨﺼﻮرت ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ در ﻣﺤﻞ اﻳﻦ ﺑﻴﺖ ﻣﻲ ﺗﻮان آن را ﭘﺎك ﻧﻤﻮد‪.‬‬

‫‪ :ADC Auto Trigger Enable‬ﻋﻤﻠﻴﺎت ﺗﺒﺪﻳﻞ ﺑﻪ دو ﺻﻮرت ﻣﻲ ﺗﻮاﻧﺪ راه اﻧﺪازي ﺷـﻮد‪ Single ،‬و ‪Auto‬‬

‫‪ Trigger‬ﻛﻪ ﺣﺎﻟﺖ اول ﺑﺎ ﻫﺮ ﺑﺎر راه اﻧﺪازي ‪ ADC‬ﻳﻚ ﺗﺒﺪﻳﻞ اﻧﺠﺎم ﺷﺪه و در وﺿﻌﻴﺖ دوم ‪ ADC‬ﺑـﻪ ﺻـﻮرت‬

‫ﺧﻮدﻛﺎر از ﻃﺮﻳﻖ ﻳﻜﻲ ازﻣﻨﺎﺑﻊ داﺧﻠﻲ ﺗﺤﺮﻳﻚ ﻣﻲ ﺷﻮد‪ .‬ﺑﺮاي ﻗﺮار دادن ‪ ADC‬در وﺿﻌﻴﺖ ‪ Auto Trigger‬ﺑﺎﻳـﺪ‬

‫اﻳﻦ ﺑﻴﺖ ﻳﻚ ﺷﻮد‪ .‬ﻧﻮع ﻣﻨﺒﻊ ﺗﺮﻳﮕـﺮ ﻛﻨﻨـﺪه ﺑﻮﺳـﻴﻠﻪ ي ﺑﻴـﺖ ﻫـﺎي ]‪ ADTS[2:0‬از رﺟﻴﺴـﺘﺮ ‪ SFIOR‬اﻧﺘﺨـﺎب‬

‫ﻣﻲ ﺷﻮد‪.‬‬

‫‪ :ADC Start Conversion‬در وﺿﻌﻴﺖ راه اﻧﺪازي ‪ ،Single‬ﺑﺮاي آﻏﺎز ﻫﺮ ﺗﺒﺪﻳﻞ ﺑﺎﻳﺪ اﻳﻦ ﺑﻴﺖ ﻳـﻚ ﺷـﻮد و‬

‫در وﺿﻌﻴﺖ ﺗﺒﺪﻳﻞ ﭘﻴﻮﺳﺘﻪ )‪ (Free Running‬ﻧﻮﺷﺘﻦ ﻳﻚ روي اﻳﻦ ﺑﻴﺖ اوﻟﻴﻦ ﺗﺒﺪﻳﻞ را ﻣﻮﺟﺐ ﻣﻲ ﺷﻮد‪.‬‬

‫‪ :ADC Enable‬اﻳﻦ ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﻣﺎژول ‪ ADC‬ﺑﻮده و ﺑﺎ ﻳﻚ ﻛﺮدن آن ﻣﻲ ﺗﻮان ‪ ADC‬را ﻓﻌﺎل ﻧﻤﻮد‪ .‬ﻧﻮﺷـﺘﻦ‬

‫ﺻﻔﺮ روي اﻳﻦ ﺑﻴﺖ در ﺣﺎﻟﻲ ﻛﻪ ‪ ADC‬ﻣﺸﻐﻮل ﺗﺒﺪﻳﻞ اﺳﺖ ﺑﺎﻋﺚ ﻣﻲ ﺷﻮد ﻛﻪ ﻋﻤﻠﻴﺎت ﺗﺒﺪﻳﻞ ﻧﻴﻤﻪ ﻛﺎره رﻫﺎ ﺷﻮد‪.‬‬

‫‪The ADC Data Register‬‬

‫ﺑﺎ ﭘﺎﻳﺎن ﻋﻤﻠﻴﺎت ﺗﺒﺪﻳﻞ ﻧﺘﻴﺠﻪ در اﻳﻦ رﺟﻴﺴﺘﺮ ﻗﺮار ﻣﻲ ﮔﻴﺮد و در ﺻﻮرﺗﻲ ﻛﻪ ورودي ‪ ADC‬ﺑﻪ ﺻﻮرت دﻳﻔﺮاﻧﺴـﻴﻞ‬

‫ﺑﺎﺷﺪ ﻧﺘﻴﺠﻪ ﺑﻪ ﻓﺮم ﻣﻜﻤﻞ ‪ 2‬ﻧﻤﺎﻳﺶ داده ﻣﻲ ﺷﻮد‪.‬‬

‫  ‬
‫‪P a g e | 186‬‬
‫‪www.avr.ir‬‬
‫ﻣﻄﺎﺑﻖ ﺑﻴﺖ ‪ ADLR‬در رﺟﻴﺴﺘﺮ ‪ ADMUX‬ﺑﻪ دو ﺻﻮرت ‪ LA‬و ‪ RA‬ﻧﻤﺎﻳﺶ داده ﻣﻲ ﺷﻮد‪:‬‬

‫‪ADLR=0‬‬
‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪ADCL ADC7 ADC6 ADC5 ADC4 ADC3 ADC2 ADC1 ADC0‬‬

‫‪ADCH‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪ADC9 ADC8‬‬

‫‪ADLR=1‬‬
‫‪Bit‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪ADCL ADC9 ADC8 ADC7 ADC6 ADC5 ADC4 ADC3 ADC2‬‬

‫‪ADCH ADC1 ADC0‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫‪Special FunctionIO Register‬‬

‫‪SFIOR‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪ADTS2 ADTS1 ADTS0 - ACME PUD PSR2 PSR10‬‬

‫‪ :ADC Auto Trigger Source‬در ﺻﻮرﺗﻲ ﻛﻪ ﺑﻴﺖ ‪ ADATE‬از رﺟﻴﺴﺘﺮ ‪ ADCSRA‬ﻣﻘـﺪار ﻳـﻚ داﺷـﺘﻪ‬

‫ﺑﺎﺷﺪ ﺑﻴﺖ ﻫﺎي ‪ ADTS‬ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨﺪ ﻛﻪ ﻛﺪام ﻣﻨﺒﻊ ﺑﻪ ﺻﻮرت ﺧﻮدﻛﺎر ‪ ADC‬را راه اﻧﺪازي ﻛﻨـﺪ‪ .‬ﻣﻨﺒـﻊ اﻳـﻦ راه‬

‫اﻧﺪازي ﻟﺒﻪ ي ﺑﺎﻻ روﻧﺪه ي ﭘﺮﭼﻢ وﻗﻔﻪ ي آن ﻣﻨﺒﻊ ﻣﻲ ﺑﺎﺷﺪ و در ﺻﻮرﺗﻲ ﻛﻪ ﺑﺨـﻮاﻫﻴﻢ اﺗﻤـﺎم ﺗﺒـﺪﻳﻞ ﺧـﻮد ‪ADC‬‬

‫ﻣﻨﺒﻊ ﺗﺮﻳﮕﺮ ﺑﻌﺪي ﺑﺎﺷﺪ و ‪ ADC‬ﺑﻪ ﺻﻮرت ﭘﻴﻮﺳـﺘﻪ ﻋﻤﻠﻴـﺎت ﺗﺒـﺪﻳﻞ را اﻧﺠـﺎم دﻫـﺪ از ﺣﺎﻟـﺖ ‪Free Running‬‬

‫اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ‪.‬‬

‫  ‬
‫‪P a g e | 187‬‬
‫‪www.avr.ir‬‬
‫‪ADTS2 ADTS1 ADTS0‬‬ ‫ﻣﻨﺒﻊ راه اﻧﺪازي‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪Free Running‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ‬

‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫وﻗﻔﻪ ي ﺧﺎرﺟﻲ ﺻﻔﺮ‬

‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫ﺗﻄﺒﻴﻖ ﻣﻘﺎﻳﺴﻪ ي ﺗﺎﻳﻤﺮ ﺻﻔﺮ‬

‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫ﺳﺮرﻳﺰ ﺗﺎﻳﻤﺮ ﺻﻔﺮ‬

‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫ﺗﻄﺒﻴﻖ ﻣﻘﺎﻳﺴﻪ ي ‪ B‬ﺗﺎﻳﻤﺮ ﻳﻚ‬

‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫ﺳﺮرﻳﺰ ﺗﺎﻳﻤﺮ ﻳﻚ‬

‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪ Capture‬ﺗﺎﻳﻤﺮ ﻳﻚ‬

‫راه اﻧﺪازي ‪ ADC‬ﺑﻪ ﺻﻮرت ﺗﻚ ﺗﺒﺪﻳﻞ و ﺗﺒﺪﻳﻞ ﺧﻮدﻛﺎر‬

‫ﭘﺲ از اﻧﺘﺨﺎب ﻛﺎﻧﺎل ﻣﻮرد ﻧﻈﺮ و وﻟﺘﺎژ ﻣﺮﺟﻊ ﺑﻮﺳﻴﻠﻪ رﺟﻴﺴﺘﺮ ‪ ،ADMUX‬ﺑﺎ در ﻧﻈﺮ ﮔﺮﻓﺘﻦ اﻳﻨﻜـﻪ ﺑﻴـﺖ ‪ADEN‬‬

‫ﻳﻚ ﺑﻮده ﺑﺎﺷﺪ‪ ،‬ﻧﻮﺷﺘﻦ ﻳﻚ ﻣﻨﻄﻘﻲ ﺑﺮ روي ﺑﻴﺖ ‪ ADSC‬ﺷﺮوع ﻳﻚ ﺗﺒﺪﻳﻞ را ﻣﻮﺟﺐ ﺧﻮاﻫﺪ ﺷﺪ‪ .‬اﻳﻦ ﺑﻴﺖ در ﺣﻴﻦ‬

‫اﻧﺠﺎم ﺗﺒﺪﻳﻞ ﻳﻚ ﺑﻮده و ﺑﺎ ﭘﺎﻳﺎن آن ﺑﻮﺳﻴﻠﻪ ي ﺳﺨﺖ اﻓﺰار ﭘﺎك ﻣﻲ ﺷﻮد‪ .‬در ﺻﻮرﺗﻲ ﻛﻪ ﻗﺒﻞ از اﺗﻤﺎم ﺗﺒـﺪﻳﻞ‪ ،‬ﻛﺎﻧـﺎل‬

‫‪ ADC‬ﺗﻐﻴﻴﺮ ﻛﻨﺪ ﺗﺎ ﭘﺎﻳﺎن ﺗﺒﺪﻳﻞ ﺟﺎري اﻳﻦ ﺗﻐﻴﻴﺮ ﺗﺎﺛﻴﺮ ﻧﺨﻮاﻫﺪ ﮔﺬاﺷﺖ‪.‬‬

‫راه دﻳﮕﺮ ﺑﺮاي راه اﻧﺪازي ‪ ADC‬وﺿﻌﻴﺖ ﺗﺤﺮﻳﻚ ﺧﻮدﻛﺎر ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ اﻳﻦ ﺣﺎﻟﺖ ﺑﺎ ﻳﻚ ﻛﺮدن ﺑﻴﺖ ‪ ADATE‬از‬

‫رﺟﻴﺴﺘﺮ ‪ ADCSRA‬آﻏﺎز ﻣﻲ ﺷﻮد‪ .‬ﻣﻨﺒﻊ ﺗﺮﻳﮕﺮ ﺑﻮﺳﻴﻠﻪ ي ﺑﻴﺖ ﻫﺎي ‪ ADTS‬در رﺟﻴﺴﺘﺮ ‪ SFIOR‬اﻧﺘﺨـﺎب ﻣـﻲ‬

‫ﺷﻮﻧﺪ‪ .‬زﻣﺎﻧﻲ ﻛﻪ ﭘﺮﭼﻢ ﻣﻨﺒﻊ ﺗﺮﻳﮕﺮ ﻳﻚ ﻣﻲ ﺷﻮد‪ ،‬ﭘﻴﺶ ﺗﻘﺴﻴﻢ ﻛﻨﻨﺪه ‪ Reset‬ﺷـﺪه و ‪ ADC‬ﺷـﺮوع ﺑـﻪ اﻧﺠـﺎم ﻳـﻚ‬

‫ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﺪ‪ ،‬ﺑﺪﻳﻦ وﺳﻴﻠﻪ ﻣﻲ ﺗﻮان در ﺑﺎزه ﻫﺎي زﻣﺎﻧﻲ ﺛﺎﺑﺖ ‪ ADC‬را ﺗﺮﻳﮕﺮ ﻧﻤﻮد‪.‬‬

‫  ‬
‫‪P a g e | 188‬‬
‫‪www.avr.ir‬‬
‫ﭘﺮﭼﻢ اﺗﻤﺎم ﻳﻚ ﺗﺒﺪﻳﻞ ﺑﻴﺖ ‪ ADIF‬ﻣﻲ ﺑﺎﺷﺪ‪ ،‬در ﺻﻮرﺗﻲ ﻛﻪ ‪ ADC‬در وﺿﻌﻴﺖ ﺗﺤﺮﻳﻚ ﺧﻮدﻛـﺎر ﻗـﺮار ﮔﺮﻓﺘـﻪ و‬

‫اﻳﻦ ﺑﻴﺖ ﺑﻪ ﻋﻨﻮان ﻣﻨﺒﻊ ﺗﺮﻳﮕﺮ اﻧﺘﺨﺎب ﺷﻮد‪ ،‬ﭘﺲ از اﺗﻤﺎم ﻳﻚ ﺗﻴﺪﻳﻞ‪ ،‬ﺗﺒﺪﻳﻞ ﺟﺪﻳﺪي ﺷﺮوع ﺧﻮاﻫﺪ ﺷﺪ‪ .‬ﺑﺮاي رﺳﻴﺪن‬

‫ﺑﻪ اﻳﻦ وﺿﻌﻴﺖ ﺑﺎﻳﺪ ﺑﻴﺖ ﻫﺎي ‪ ADTS‬در ﺣﺎﻟﺖ ‪ Free Running‬ﻗﺮار ﮔﻴﺮﻧﺪ و ﺑﺮاي ﺷﺮوع ﺗﺒﺪﻳﻞ ﺗﻨﻬﺎ ﻳﻚ ﺑـﺎر‬

‫ﻳﻚ ﻛﺮدن ‪ ADSC‬آﻏﺎز ﺷﺪه و ﭘﺲ از آن ﺗﺒﺪﻳﻼت ﻣﺘﻮاﻟﻲ اﻧﺠﺎم ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫ﻫﻤﺎن ﻃﻮر ﻛﻪ ﮔﻔﺘﻪ ﺷﺪ در ﺻﻮرت ﻓﻌﺎل ﺑﻮدن ﺑﻴﺖ ‪ ADIE‬ﺑﺎﻻ رﻓﺘﻦ ﭘﺮﭼﻢ اﺗﻤﺎم ﺗﺒﺪﻳﻞ )‪ (ADIF‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎﻋﺚ‬

‫اﻳﺠﺎد وﻗﻔﻪ ﺷﺪه و ﺑﺎ اﺟﺮاي ‪ ISR‬اﻳﻦ ﺑﻴﺖ ﺗﻮﺳﻂ ﺳـﺨﺖ اﻓـﺰار ﭘـﺎك ﺷـﻮد‪ .‬در ﺻـﻮرﺗﻲ ﻛـﻪ ‪ ADC‬در وﺿـﻌﻴﺖ‬

‫‪ Single Conversion‬ﻳﺎ ﺗﻚ ﺗﺒﺪﻳﻞ ﺑﺎﺷﺪ ﺑﺮاي ﺷﺮوع ﺗﺒﺪﻳﻞ ﺑﻌﺪي ﺑﺎﻳﺪ ﭘﺮﭼﻢ ‪ ADIF‬ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ ﺑﺮ روي آن‬

‫ﭘﺎك ﺷﻮد‪ ،‬در ﺣﺎﻟﻴﻜﻪ وﺿﻌﻴﺖ ‪ Free Running‬اﻧﺘﺨﺎب ﺷﺪه ﺑﺎﺷﺪ ﺑﺪون در ﻧﻈﺮ ﮔﺮﻓﺘﻦ اﻳﻨﻜﻪ ﭘﺮﭼﻢ ‪ ADIF‬ﭘـﺎك‬

‫ﺷﺪه اﺳﺖ ﻳﺎ ﻧﻪ ﺗﺒﺪﻳﻼت ﻣﺘﻮاﻟﻲ اﻧﺠﺎم ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫  ‬
‫‪P a g e | 189‬‬
‫‪www.avr.ir‬‬
‫ﭘﻴﺶ ﺗﻘﺴﻴﻢ ﻛﻨﻨﺪه و زﻣﺎن ﺑﻨﺪي ﺗﺒﺪﻳﻞ‬

‫ﺑﻪ ﺻﻮرت ﭘﻴﺶ ﻓﺮض‪ ،‬ﻣﺪاري ﻛﻪ ﺑﺮ اﺳﺎس ﺗﻘﺮﻳﺐ ﻫﺎي ﻣﺘﻮاﻟﻲ ﺗﺒﺪﻳﻞ آﻧﺎﻟﻮگ ﺑﻪ دﻳﺠﻴﺘﺎل را اﻧﺠﺎم ﻣﻲ دﻫﺪ ﺑﺮاي‬

‫رﺳﻴﺪن ﺑﻪ ﻣﺎﻛﺰﻳﻤﻢ ‪ ،Resolution‬ﻧﻴﺎز ﺑﻪ ﻳﻚ ﻛﻼك ورودي ﺑﺎ ﻓﺮﻛﺎﻧﺴﻲ ﺑﻴﻦ ‪ 50‬ﺗﺎ ‪ 200‬ﻛﻴﻠﻮﻫﺮﺗﺰ دارد‪ .‬ﻣﺎژول‬

‫‪ ADC‬ﺑﺮاي ﺗﺎﻣﻴﻦ ﻛﻼك ﻣﻮرد ﻧﻴﺎز داراي ﻳﻚ ﭘﻴﺶ ﺗﻘﺴﻴﻢ ﻛﻨﻨﺪه ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﻣﻘﺪار آن ﺑﻮﺳﻴﻠﻪ ي ﺑﻴﺖ ﻫﺎي‬

‫‪ ADPS‬از رﺟﻴﺴﺘﺮ ‪ ADCSRA‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪ .‬واﺣﺪ ‪ ADC‬ﺑﺮاي ﻋﻤﻠﻜﺮد ﺻﺤﻴﺢ ﺑﻪ ﻓﺮﻛﺎﻧﺲ ﻛﻼﻛﻲ ﺑﻴﻦ ‪ 50‬ﺗﺎ‬

‫‪ 200‬ﻛﻴﻠﻮﻫﺮﺗﺰ ﻧﻴﺎز دارد و در ﺻﻮرﺗﻲ ﻛﻪ ﻣﻘﺪار آن ﺧﺎرج از اﻳﻦ ﻣﺤﺪوده ﺗﻌﺮﻳﻒ ﺷﻮد ﻣﻤﻜﻦ اﺳﺖ ﻋﻤﻠﻜﺮد‬

‫ﺻﺤﻴﺤﻲ ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬

‫  ‬
‫‪P a g e | 190‬‬
‫‪www.avr.ir‬‬
‫در ﺻﻮرت اﺳﺘﻔﺎده از ‪ Mode‬ﺗﻚ ﺗﺒﺪﻳﻞ ﺑﻪ دﻟﻴﻞ ﺗﻨﻈﻴﻤﺎت اوﻟﻴﻪ ي ‪ ADC‬ﻫﺮ ﺗﺒﺪﻳﻞ ﺣﺪود ‪ 25‬ﺳﻴﻜﻞ ﻛﻼك ﻃـﻮل‬

‫ﻣﻲ ﻛﺸﺪ‪ ،‬درﺣﺎﻟﻴﻜﻪ در وﺿﻌﻴﺖ ‪ Free Running‬ﻫﺮ ﺗﺒﺪﻳﻞ ﺑﺮاي ﻛﺎﻣﻞ ﺷﺪن ﺣﺪود ‪ 13‬ﻛﻼك زﻣﺎن ﻧﻴﺎز دارد‪.‬‬

‫ﻓﻴﻠﺘﺮ ﻛﺎﻫﺶ ﻧﻮﻳﺰ ورودي‬

‫ﻣﺪارات داﺧﻠﻲ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ﺑﺎ اﻳﺠﺎد ﻧﻮﻳﺰ ﺑﺎﻋﺚ ﻛﺎﻫﺶ دﻗﺖ ﻣﻘﺪار ﺧﻮاﻧﺪه ﺷﺪه ﺗﻮﺳـﻂ ‪ ADC‬ﻣـﻲ ﺷـﻮﻧﺪ‪ ،‬ﺑـﺮاي‬

‫ﺑﻬﺒﻮد اﻳﻦ ﻣﺸﻜﻞ ﻣﻲ ﺗﻮان در زﻣﺎن ﺗﺒـﺪﻳﻞ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟـﺮ را ﺑـﻪ ﻳﻜـﻲ از ‪ Mode‬ﻫـﺎي ﻛـﻢ ﺗـﻮان ‪ADC Noise‬‬

‫‪ Reduction‬ﻳﺎ ‪ Idle‬ﺑﺮد ﺗﺎ ﻋﻤﻠﻴﺎت ﺗﺒﺪﻳﻞ ﺑﻌﺪ از ﺧﺎﻣﻮش ﺷﺪن ‪ CPU‬اﻧﺠﺎم ﺷﻮد‪.‬‬

‫ﭘﺮوژه ‪ :13‬اﻧﺪازه ﮔﻴﺮي دﻣﺎ ﺑﺎ ﺳﻨﺴﻮر ‪LM35‬‬

‫*****************************************************‪/‬‬
‫‪Project : Temprature Measurement with LM35‬‬
‫‪Author‬‬ ‫‪: Reza Sepas Yar‬‬
‫‪Company : Pishro Noavaran Kavosh‬‬
‫‪Chip type‬‬ ‫‪: ATmega16‬‬
‫‪Clock frequency‬‬ ‫‪: 1.000000 MHz‬‬
‫‪*****************************************************/‬‬

‫>‪#include <mega16.h‬‬
‫>‪#include <delay.h‬‬
‫>‪#include <stdio.h‬‬
‫‪#define xtal 8000000‬‬

‫‪// Alphanumeric LCD Module functions‬‬

‫‪#asm‬‬
‫‪.equ __lcd_port=0x12 ;PORTD‬‬
‫
 ‬
P a g e | 191
www.avr.ir
#endasm

#include <lcd.h>

#define ADC_VREF_TYPE 0xC0

// Read the AD conversion result
unsigned int read_adc(unsigned char adc_input)
{
ADMUX=adc_input|ADC_VREF_TYPE;
// Start the AD conversion
ADCSRA|=0x40;
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
return ADCW;
}

void main(void)
{

char lcd_buff[10];
int adc_in;
float temp;

PORTA=0x00;
DDRA=0x00;

// ADC initialization
// ADC Clock frequency: 45 kHz
// ADC Voltage Reference: Int., cap. on AREF

  
P a g e | 192
www.avr.ir
// ADC Auto Trigger Source: None
ADMUX=ADC_VREF_TYPE;
ADCSRA=0x86;

// LCD module initialization

lcd_init(16);

while (1)
{

adc_in=read_adc(0);
temp=adc_in/4;
sprintf(lcd_buff,"Temp=%5.1f C",temp);
lcd_clear();
lcd_gotoxy(0,0);
lcd_puts(lcd_buff);
delay_ms(1000);

};
}

  
P a g e | 193
www.avr.ir

:‫ﺷﻤﺎﺗﻴﻚ‬

  
‫‪P a g e | 194‬‬
‫‪www.avr.ir‬‬

‫ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ‬

‫ﻣﺎژول ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ داراي دو ورودي ‪ AIN0‬و ‪ AIN1‬ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ اﻳﻦ دو ﺑﻪ ﺗﺮﺗﻴﺐ ورودي ﻣﺜﺒـﺖ و‬

‫ﻣﻨﻔﻲ واﺣﺪ ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ﺑﻮده ﻛﻪ ﻫﻤﺎﻧﻨﺪ ﻳﻚ ﺗﻘﻮﻳﺖ ﻛﻨﻨﺪه ي ﻋﻤﻠﻴﺎﺗﻲ وﻟﺘﺎژ روي اﻳـﻦ دو ﭘﺎﻳـﻪ را ﻣﻘﺎﻳﺴـﻪ ﻛـﺮده و‬

‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ وﻟﺘﺎژ روي ﭘﺎﻳﻪ ي ‪ AIN0‬ﺑﻴﺸﺘﺮ از وﻟﺘﺎژ ‪ AIN1‬ﺑﺎﺷﺪ ﺧﺮوﺟﻲ آن ﻳﻌﻨﻲ ﺑﻴﺖ ‪ ACO‬ﻳﻚ ﻣﻲ ﺷﻮد‪ .‬اﻳﻦ‬

‫ﺧﺮوﺟﻲ ﻋﻼوه ﺑﺮ ﻛﺎرﺑﺮدﻫﺎي ﻋﺎدي ﻣﻲ ﺗﻮاﻧﺪ ﺑﺮاي ﺗﺮﻳﮕﺮ ﻛﺮدن ورودي ‪ Capture‬ﺗﺎﻳﻤﺮ ﻳﻚ ﻧﻴﺰ ﺑﻪ ﻛﺎر رود‪.‬‬

‫  ‬
‫‪P a g e | 195‬‬
‫‪www.avr.ir‬‬

‫رﺟﻴﺴﺘﺮﻫﺎي ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ‬

‫‪Special Function IO Register‬‬

‫‪SFIOR‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪ADTS2 ADTS1 ADTS0 - ACME PUD PSR2 PSR10‬‬

‫‪ :Analog Comparator Multiplexer Enable‬ﻣﺎژول ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ اﻳﻦ اﻣﻜﺎن را ﻣﻲ دﻫﺪ ﺗﺎ‬

‫ورودي ﻣﻨﻔﻲ از ﻃﺮﻳﻖ ﭘﺎﻳﻪ ﻫﺎي ‪ ADC0‬ﺗﺎ‪ ADC7‬اﻧﺘﺨﺎب ﺷﻮد‪ .‬در ﺻﻮرت ﻳﻚ ﺑﻮدن ﺑﻴﺖ ‪ ACME‬و ﺧـﺎﻣﻮش‬

‫ﺑﻮدن ‪) ADC‬ﺑﻴﺖ ‪ ADEN‬در ‪ ADCSRA‬ﺻﻔﺮ ﺑﺎﺷﺪ(‪ ،‬ﺧﺮوﺟﻲ ﻣﺎﻟﺘﻲ ﭘﻠﻜﺴﺮ ‪ ADC‬ﺑﻪ ﻋﻨـﻮان ورودي ﻣﻨﻔـﻲ‬

‫ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه اﻧﺘﺨﺎب ﻣﻲ ﺷﻮد و در ﻏﻴﺮ اﻳﻨﺼﻮرت ﭘﺎﻳﻪ ‪ AIN1‬ورودي ﻣﻨﻔﻲ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬

‫‪Analog Comparator Control and Status Register‬‬

‫‪ACSR‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪ ACD ACBG ACO ACI ACIE ACIC ACIS1 ACIS0‬ﻧﺎم ﺑﻴﺖ‬

‫]‪ :Analog Comparator Interrupt Mode Select[1:0‬اﻳﻦ ﺑﻴﺖ ﻫﺎ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨـﺪ ﻛـﻪ ﻛـﺪاﻣﻴﻚ از‬

‫روﻳﺪادﻫﺎي ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ وﻗﻔﻪ ي آن را ﺗﺮﻳﮕﺮ ﻣﻲ ﻛﻨﺪ‪.‬‬

‫  ‬
‫‪P a g e | 196‬‬
‫‪www.avr.ir‬‬

‫‪ACIS1‬‬ ‫‪ACIS0‬‬ ‫وﺿﻌﻴﺖ وﻗﻔﻪ‬

‫‪0‬‬ ‫‪0‬‬ ‫وﻗﻔﻪ ي ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه در ‪ Toggle‬ﺧﺮوﺟﻲ‬

‫‪0‬‬ ‫‪1‬‬ ‫رزرو ﺷﺪه‬

‫وﻗﻔﻪ ي ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه در ﻟﺒـﻪ ي ﭘـﺎﻳﻴﻦ روﻧـﺪه ي‬

‫‪1‬‬ ‫‪0‬‬
‫ﺧﺮوﺟﻲ‬

‫وﻗﻔﻪ ي ﻣﻘﺎﻳﺴـﻪ ﻛﻨﻨـﺪه در ﻟﺒـﻪ ي ﺑـﺎﻻ روﻧـﺪه ي‬

‫‪1‬‬ ‫‪1‬‬
‫ﺧﺮوﺟﻲ‬

‫‪ :Analog Comparator Input Capture Enable‬ﺑﺎ ﻳﻚ ﺷﺪن اﻳﻦ ﺑﻴﺖ ورودي ‪ Capture‬ﺗﺎﻳﻤﺮ ﻳﻚ‬

‫از ﻃﺮﻳﻖ ﺧﺮوﺟﻲ ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ﺗﺮﻳﮕﺮ ﻣﻲ ﺷﻮد‪.‬‬

‫‪ :Analog Comparator Interrupt Enable‬در ﺻﻮرﺗﻲ ﻛﻪ اﻳﻦ ﺑﻴﺖ و ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ﻋﻤﻮﻣﻲ وﻗﻔﻪ ﻫـﺎ‬

‫ﻳﻚ ﺑﺎﺷﺪ وﻗﻔﻪ ي ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ ﻓﻌﺎل ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬

‫‪ :Analog Comparator Interrupt Flag‬اﻳﻦ ﭘﺮﭼﻢ زﻣﺎﻧﻲ ﻛﻪ ﻳﻜﻲ از روﻳﺪاد ﻫﺎي ﺗﻌﺮﻳﻒ ﺷـﺪه ﺑﻮﺳـﻴﻠﻪ‬

‫ي ﺑﻴﺖ ﻫﺎي ‪ ACIS1‬و ‪ ACIS0‬روي دﻫﺪ‪ ،‬ﺑﻮﺳﻴﻠﻪ ي ﺳﺨﺖ اﻓﺰار ﻳﻚ ﻣﻲ ﺷﻮد‪ .‬در اﻳﻦ وﺿﻌﻴﺖ اﮔﺮ ‪ ACIE‬و‬

‫ﻓﻌﺎل ﺳﺎز ﻋﻤﻮﻣﻲ وﻗﻔﻪ ﻫﺎ ﻳﻚ ﺑﺎﺷﺪ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ‪ ISR‬ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ﻣﻨﺸﻌﺐ ﺧﻮاﻫﺪ ﺷﺪ و ﺑﻴﺖ ‪ ACI‬ﺗﻮﺳـﻂ ﺳـﺨﺖ‬

‫اﻓﺰار ﭘﺎك ﺧﻮاﻫﺪ ﺷﺪ‪ ،‬در ﻏﻴﺮ اﻳﻨﺼﻮرت ﻧﺮم اﻓﺰار ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ آن را ﭘﺎك ﻛﻨﺪ‪.‬‬

‫‪ :Analog Comparator Output‬اﻳﻦ ﺑﻴﺖ ﺧﺮوﺟﻲ ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه آﻧﺎﻟﻮگ ﺑﻮده و ﺑﺎ ﺗﺎﺧﻴﺮي ﺑﻴﻦ ﻳﻚ ﺗـﺎ دو‬

‫ﺳﻴﻜﻞ ﺳﻨﻜﺮون ﻣﻲ ﺷﻮد‪.‬‬

‫  ‬
‫‪P a g e | 197‬‬
‫‪www.avr.ir‬‬
‫‪ :Analog Comparator Bandgap Select‬ﺑﺎ ﻳﻚ ﺷﺪن اﻳـﻦ ﺑﻴـﺖ وﻟﺘـﺎژ ﻣﺮﺟـﻊ ‪ Bandgap‬ﺟـﺎﻳﮕﺰﻳﻦ‬

‫ورودي ﻣﺜﺒﺖ ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ﺧﻮاﻫﺪ ﺷﺪ‪ .‬در ﺻﻮرت ﺻﻔﺮ ﺑﻮدن ﺑﻴﺖ ‪ ACGB‬ﭘـﻴﻦ ‪ AIN0‬ورودي ﻣﺜﺒـﺖ ﻣﻘﺎﻳﺴـﻪ‬

‫ﻛﻨﻨﺪه ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬

‫‪ :Analog Comparator Disable‬ﺑﺎ ﻳﻚ ﺷﺪن اﻳﻦ ﺑﻴﺖ ﺗﻐﺬﻳﻪ ي ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ ﻗﻄﻊ ﻣﻲ ﺷﻮد‪ .‬اﻳﻦ‬

‫ﻣﺴﺌﻠﻪ ﺑﻪ ﻛﺎﻫﺶ ﺗﻮان ﻣﺼﺮﻓﻲ در ‪ Mode‬ﻫﺎي ﻓﻌﺎل و ﺑﻴﻜﺎري ﻛﻤﻚ ﺧﻮاﻫﺪ ﻛﺮد‪ .‬ﻗﺒـﻞ از ﺗﻐﻴﻴـﺮ دادن ﺑﻴـﺖ ‪ACD‬‬

‫ﺑﺎﻳﺪ وﻗﻔﻪ ي ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ ﺑﺎ ﭘﺎك ﻛﺮدن ﺑﻴﺖ ‪ ACIE‬از ‪ ACSR‬ﻏﻴﺮ ﻓﻌﺎل ﺷـﻮد در ﻏﻴـﺮ اﻳﻨﺼـﻮرت در‬

‫زﻣﺎن ﺗﻐﻴﻴﺮ اﻳﻦ ﺑﻴﺖ ﻣﻲ ﺗﻮاﻧﺪ وﻗﻔﻪ ﺑﻮﺟﻮد آﻳﺪ‪.‬‬

‫ورودي ﻣﺎﻟﺘﻲ ﭘﻠﻜﺲ ﺷﺪه ي ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ‬

‫اﻳﻦ اﻣﻜﺎن وﺟﻮد دارد ﻛﻪ ﻫﺮ ﻳﻚ از ورودي ﻫﺎي ‪ ADC0‬ﺗﺎ ‪ ADC7‬ﺑﻪ ﻋﻨﻮان ورودي ﻣﻨﻔﻲ ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه آﻧﺎﻟﻮگ‬

‫اﻧﺘﺨﺎب ﺷﻮﻧﺪ‪ .‬ﺑﺮاي اﺳﺘﻔﺎده از اﻳﻦ ﻣﺴﺌﻠﻪ ﺑﺎﻳﺪ )ﺑﺎ ﺻﻔﺮ ﺑﻮدن ﺑﻴﺖ ‪ (ADEN‬ﻣﺒﺪل آﻧﺎﻟﻮگ ﺑﻪ دﻳﺠﻴﺘﺎل ﺧﺎﻣﻮش ﺑـﻮده‬

‫و ﺑﻴﺖ ‪ ACME‬از ‪ SFIOR‬ﻳﻚ ﺑﺎﺷﺪ‪ .‬در اﻳﻦ وﺿﻌﻴﺖ ﺑﻴﺖ ﻫﺎي ]‪ MUX[2:0‬از رﺟﻴﺴﺘﺮ ‪ ADMUX‬ورودي‬

‫ﻣﻨﻔﻲ را ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ اﻧﺘﺨﺎب ﻣﻲ ﻛﻨﻨﺪ‪ .‬ﻣﺴﻠﻤﺎ در ﺻﻮرﺗﻲ ﻛﻪ ﺑﻴﺖ ‪ ACME‬ﺻﻔﺮ ﺑﻮده ﻳﺎ ‪ ADEN‬ﻳـﻚ ﺑﺎﺷـﺪ‬

‫ﭘﻴﻦ ‪ AIN1‬ورودي ﻣﻨﻔﻲ ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ي آﻧﺎﻟﻮگ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬

‫ورودي ﻣﻨﻔﻲ ﻣﻘﺎﻳﺴﻪ ﻛﻨﻨﺪه ]‪ACME ADEN MUX[2:0‬‬

‫‪0‬‬ ‫‪x‬‬ ‫‪xxx‬‬ ‫‪AIN1‬‬

‫‪x‬‬ ‫‪1‬‬ ‫‪xxx‬‬ ‫‪AIN1‬‬

‫  ‬
P a g e | 198
www.avr.ir
1 0 000 ADC0

1 0 001 ADC1

1 0 010 ADC2

1 0 011 ADC3

1 0 100 ADC4

1 0 101 ADC5

1 0 110 ADC6

1 0 111 ADC7

(‫ )اﻋﻼم ﻋﺒﻮر ﺧﺮوﺟﻲ ﻳﻚ ﺳﻨﺴﻮر آﻧﺎﻟﻮگ از ﻳﻚ ﺳﻄﺢ ﻣﻌﻴﻦ‬:‫ﻣﺜﺎل‬

#include <mega16.h>

// Analog Comparator interrupt service routine

interrupt [ANA_COMP] void ana_comp_isr(void)
{
PORTA=PORTA^0x01;
}

// Declare your global variables here

void main(void)
{
// Declare your local variables here

  
P a g e | 199
www.avr.ir
PORTA=0x00;
DDRA=0x01;

// Analog Comparator initialization

// Analog Comparator: On
// Interrupt on Output Toggle
// Analog Comparator Input Capture by Timer/Counter 1:
Off
ACSR=0x08;
SFIOR=0x00;

// Global enable interrupts

#asm("sei")

while (1);
}

:‫ﺷﻤﺎﺗﻴﻚ‬

  
P a g e | 200
www.avr.ir


P a g e | 201
www.avr.ir

SPI Bus

‫ ﺑﻮده و ﺑﻮﺳﻴﻠﻪ ﺷـﺮﻛﺖ‬Serial Peripheral Interface ‫ ﻛﻪ ﻳﻚ اﺳﺘﺎﻧﺪارد ﺳﺮﻳﺎل ﺳﻨﻜﺮون ﻣﻲ ﺑﺎﺷﺪ ﺳﺮﻧﺎم‬SPI

‫ اﻳﻦ اﺳﺘﺎﻧﺪارد ﺑﻪ ﻟﺤﺎظ ﭘﺸﺘﻴﺒﺎﻧﻲ از ﺳﺮﻋﺖ ﻫﺎي ﺑﺎﻻ ﻧﻪ ﺗﻨﻬﺎ در ﻛﺎرﺑﺮدﻫﺎي اﻧﺪازه ﮔﻴﺮي‬.‫ﻣﻮﺗﻮروﻻ ﻃﺮاﺣﻲ ﺷﺪه اﺳﺖ‬

‫ ﻧﻴـﺰ ﻣـﻮرد‬... ‫ ﻛﺎﻧﺎل ﻫـﺎي ارﺗﺒـﺎﻃﻲ و‬،‫ ﭘﺮدازش ﺳﻴﮕﻨﺎل دﻳﺠﻴﺘﺎل‬،‫ﺑﻠﻜﻪ در ﻣﻮاردي ﻧﻈﻴﺮ اﻧﺘﻘﺎل ﺣﺠﻢ ﺑﺎﻻي اﻃﻼﻋﺎت‬

‫ ﻗﺎﺑﻞ دﺳﺘﺮﺳﻲ اﺳـﺖ و در ﻧﺘﻴﺠـﻪ اﻣﻜـﺎن‬SPI ‫ ﺳﺮﻋﺖ ﭼﻨﺪ ﻣﮕﺎﺑﻴﺖ ﺑﺮ ﺛﺎﻧﻴﻪ ﺑﻪ راﺣﺘﻲ ﺗﻮﺳﻂ‬.‫اﺳﺘﻔﺎده واﻗﻊ ﻣﻲ ﺷﻮد‬

.‫اﻧﺘﻘﺎل ﺻﻮت ﻓﺸﺮده ﻧﺸﺪه و ﺗﺼﻮﻳﺮ ﻓﺸﺮده ﺷﺪه وﺟﻮد ﺧﻮاﻫﺪ داﺷﺖ‬

:‫ آورده ﺷﺪه اﺳﺖ‬SPI ‫در زﻳﺮ ﻟﻴﺴﺖ ﺑﺮﺧﻲ از وﺳﺎﻳﻞ‬

‫ﻗﻄﻌﻪ‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﺸﺨﺼﺎت‬ ‫ﺷﺮﻛﺖ ﺳﺎزﻧﺪه‬

SSM2163 8x2 Audio Mixer 63dB attenuation in 1dB steps Analog Devices

AD7303 DAC 8Bit clock rate up to 30MHz Analog Devices

AD7811 ADC 10Bit 4/8 channel 300ksps Analog Devices

AD7816 ADC + Temperature Sensor 10Bit Analog Devices

AD7858 ADC 12Bit, 8 channel 200ksps Analog Devices

1/2/4 channel 256 positions

AD8400 Digital Pot Analog Devices
1, 10, 50 100kOhm 10MHz update rate

Low voltage operation 1.8V/2.7V/5.0V

AT25010 EEPROM block write protection 100 years data ATMEL
retention

AT45D011 FLASH 5V 1MBit 5MHz clock rate ATMEL

AT45D021 FLASH 5V 2MBit 10MHz ATMEL

AT45DB021 FLASH 2.7V 2MBit 5MHz clock rate ATMEL

 

P a g e | 202
www.avr.ir
AT45DB041 FLASH 5V 4MBit 10MHz ATMEL

AT45D081 FLASH 5V 8MBit 10MHz ATMEL

AT45DB161 FLASH 2.7V 16MBit 13MHz ATMEL

ADS1210 ADC 24Bit BURR-BROWN

ADS7835 ADC 12Bit low power 500ksps BURR-BROWN

ADS7846 Touch-screen controller 2.2V to 5.25V BURR-BROWN

DS1267 Digital potentiometer Dual 10k, 50k and 100k DALLAS

DS1305 RTC 96-byte User-RAM DALLAS

DS1306 RTC 96-byte User-RAM DALLAS

DS1722 Digital Thermometer -55 °C to 120 °C accuracy +/- 2°C DALLAS

DS1844 Digital Pot 4 channel, linear 64 positions DALLAS

data retention >40 years

NM25C020 EEPROM Fairchild
hard- and software write protection

KP100 Pressure Sensor Range 60 ... 130kPa Infineon

82527 CAN Controller Flexible CPU-interface CAN 2.0 Intel

MAX349 MUX 8-to-1 dual 4-to-1 Maxim

MAX504 DAC 10Bit low power internal reference Maxim

MAX522 DAC 8Bit 5MHz Maxim

MAX535 DAC 13Bit Schmitt-trigger inputs Maxim

MAX3100 UART Up to 230kBaud Schmitt-trigger inputs Maxim

MAX4548 Switch Triple 3x2-crosspoint switch Maxim

MAX4550 Switch Dual 4x2 cross point switch Maxim

MAX4562 Switch Clickless Audio/Video Switch Maxim

MAX4571 Switch Audio/Video Maxim

MAX4588 MUX Dual 4 channel 180MHz bandwidth Maxim

8-digit 10MHz clock rate

MAX7219 LED display driver Maxim
digital/analog brightness control

25AA040 EEPROM 4k max. 3MHz clock data retention >200 Microchip

 
 
P a g e | 203
www.avr.ir
years

MCP3001 ADC 10Bit, 2.7V to 5V 200ksps @ 5V low power Microchip

Programmable Bit rate up tp 1MHz

MCP2510 CAN Controller Microchip
0... 8 Bytes message frame

MC68HC86T1 RTC + RAM 32x8Bit static-RAM Motorola

National
CLC5506 GTA (Gain Trim Amplifier) 600MHz bandwidth control range 16dB
Semiconductor

National
COP472-3 LCD Controller Keine SDO-Leitung
Semiconductor

National
LM74 Temperature Sensor 12Bit + sign 3V to 5V -55 °C to +150 °C
Semiconductor

National
MM5483 LCD Controller 31 segment outputs cascadeable
Semiconductor

High Voltage Display National

MM58342 35V max cascadeable
Driver Semiconductor

National
USBN9602 USB Controller DMA-Support Several FIFOs
Semiconductor

SPI ‫ﻧﺤﻮه ﻋﻤﻠﻜﺮد‬

:‫اﻳﻦ اﺳﺘﺎﻧﺪارد ﺑﺮاي اﻳﺠﺎد ﻳﻚ ارﺗﺒﺎط ﺑﻪ ﭼﻬﺎر ﺧﻂ ارﺗﺒﺎﻃﻲ ﻧﻴﺎز دارد‬

Master Slave

SCK SCK
MOSI MOSI
MISO MISO

SS SS

 
 
‫‪P a g e | 204‬‬
‫‪www.avr.ir‬‬
‫‪ SS‬ﺑﻮده ﻛـﻪ ﺑـﻪ ﺗﺮﺗﻴـﺐ ﺧـﻂ ﻛـﻼك‪،‬‬ ‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﻣﻼﺣﻈﻪ ﻣﻲ ﺷﻮد اﻳﻦ ﭼﻬﺎر ﺧﻂ ‪ MISO ،MOSI ،SCK‬و‬

‫‪ .Master in slave out ،Master out slave in‬و ‪ Slave Select‬ﻣﻲ ﺑﺎﺷـﻨﺪ‪ .‬ﻧﺤـﻮه ي ﺗﻌﺎﻣـﻞ ‪ Master‬و‬

‫‪ Slave‬در ﺷﻜﻞ زﻳﺮ ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪:‬‬

‫ﺳﻴﺴﺘﻢ ﺷﺎﻣﻞ دو ‪ Shift Register‬و ﻳﻚ ﻣﻮﻟﺪ ﻛﻼك ﻣﻲ ﺑﺎﺷﺪ‪ Master .‬ﺑﺎ ﺻﻔﺮ ﻛﺮدن ﺧﻂ ‪ SS‬از ‪ Slave‬ﻣﻮرد‬

‫ﻧﻈﺮ‪ ،‬ﭼﺮﺧـﻪ ي ارﺗﺒـﺎﻃﻲ را آﻣـﺎده ﻣـﻲ ﻛﻨـﺪ‪ Master .‬و ‪ Slave‬داده ي ﻣـﻮرد ﻧﻈـﺮ ﺑـﺮاي ارﺳـﺎل را در ‪Shift‬‬

‫‪ Register‬ﻗﺮار داده و ‪ Master‬ﺑﺎ اﻳﺠﺎد ﻛﻼك در ﺧﻂ ‪ SCK‬ﻣﺒﺎدﻟﻪ ي داده را آﻏﺎز ﻣـﻲ ﻛﻨـﺪ‪ .‬اﻃﻼﻋـﺎت از ﭘـﻴﻦ‬

‫‪ MOSI‬در ‪ Master‬ﺧﺎرج ﺷﺪه و وارد ﭘـﻴﻦ ‪ MOSI‬از ‪ Slave‬ﻣـﻲ ﺷـﻮد‪ .‬در ﻃـﺮف ‪ Slave‬ﻧﻴـﺰ داده از ﭘـﻴﻦ‬

‫‪ MISO‬ﺧﺎرج ﺷﺪه و وارد ‪ MISO‬از ‪ Master‬ﻣﻲ ﺷﻮد‪ .‬ﺑﻌﺪ از اﺗﻤﺎم ارﺳـﺎل ﻳـﻚ ‪ ،Packet‬ﻣﺠـﺪدا ﺧـﻂ ‪SS‬‬

‫ﻣﻲ ﺷﻮد‪.‬‬ ‫ﺗﻮﺳﻂ ‪ Master‬ﻳﻚ ﺷﺪه و ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ ‪ Slave‬ﺑﺎ ‪ Master‬ﺳﻨﻜﺮون‬

‫ 
 ‬
‫‪P a g e | 205‬‬
‫‪www.avr.ir‬‬

‫رﺟﻴﺴﺘﺮﻫﺎي ‪SPI‬‬

‫ﻣﺎژول ‪ SPI‬داراي ﺳﻪ رﺟﻴﺴﺘﺮ ‪ SPSR ،SPDR‬و ‪ SPCR‬ﺑﻮده ﻛﻪ ﺑﻪ ﺗﺮﺗﻴﺐ رﺟﻴﺴﺘﺮﻫﺎي داده‪ ،‬وﺿﻌﻴﺖ و ﻛﻨﺘﺮل‬

‫ﻣﻲ ﺑﺎﺷﻨﺪ‪.‬‬

‫‪SPI Data Register‬‬

‫‪SPDR‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪MSB‬‬ ‫‪LSB‬‬

‫ﻧﻮﺷﺘﻦ ﺑﺮ روي اﻳﻦ رﺟﻴﺴﺘﺮ ﺷﺮوع اﻧﺘﻘﺎل داده را ﻣﻮﺟﺐ ﺧﻮاﻫﺪ ﺷﺪ و ﺧﻮاﻧﺪن آن ﻣﻮﺟﺐ ﺧﻮاﻧـﺪن داده ي ﻣﻮﺟـﻮد‬

‫در ﺑﺎﻓﺮ درﻳﺎﻓﺖ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫‪SPI Status Register‬‬

‫‪SPSR‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪SPIF WCOL‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪SPI2X‬‬

‫‪ :Double SPI Speed Bit‬ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ ﺑﺮ روي اﻳﻦ ﺑﻴﺖ در ﺻـﻮرﺗﻴﻜﻪ ﻣـﺎژول ‪ SPI‬در وﺿـﻌﻴﺖ ‪Master‬‬

‫ﺑﺎﺷﺪ ﻓﺮﻛﺎﻧﺲ ﻛﻼك ﻣﻮﺟﻮد روي ﭘﻴﻦ ‪ SCK‬دو ﺑﺮاﺑﺮ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫ 
 ‬
‫‪P a g e | 206‬‬
‫‪www.avr.ir‬‬

‫‪ :Write COLlision Flag‬اﻳﻦ ﭘﺮﭼﻢ زﻣﺎﻧﻲ ﻳﻚ ﺧﻮاﻫﺪ ﺷﺪ ﻛﻪ در ﺣﻴﻦ اﻧﺘﻘﺎل ﻳـﻚ ﺑﺎﻳـﺖ ﺑـﺮ روي رﺟﻴﺴـﺘﺮ‬

‫‪ SPDR‬ﻣﻘﺪاري ﻧﻮﺷﺘﻪ ﺷﻮد‪ .‬ﺑﺎ اوﻟﻴﻦ ﺧﻮاﻧﺪن رﺟﻴﺴﺘﺮ ‪ SPSR‬اﻳﻦ ﺑﻴﺖ ﭘﺎك ﻣﻲ ﺷﻮد‪.‬‬

‫‪ :SPI Interrupt Flag‬اﻳﻦ ﺑﻴﺖ در دو ﺣﺎﻟﺖ ﻳﻚ ﻣﻲ ﺷﻮد‪ .1 :‬ﺑﺎ اﺗﻤﺎم ارﺳﺎل ﻳﻚ ﺑﺎﻳﺖ اﻳﻦ ﭘﺮﭼﻢ ﻳﻚ ﺷـﺪه و‬

‫در ﺻﻮرﺗﻲ ﻛﻪ ﺑﻴﺖ ‪ SPIE‬و ﻓﻌﺎل ﺳﺎز ﻋﻤﻮﻣﻲ وﻗﻔﻪ ﻫﺎ ﻳﻚ ﺑﺎﺷﻨﺪ اﺗﻤﺎم ﻋﻤﻠﻴﺎت ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎﻋﺚ اﻳﺠﺎد ﻳـﻚ وﻗﻔـﻪ‬

‫ﺷﻮد‪ .2 .‬ﭘﻴﻦ ‪ SS‬از ﺧﺎرج ﺗﻮﺳﻂ ﻳﻚ وﺳﻴﻠﻪ ي دﻳﮕﺮ زﻣﻴﻦ ﺷﻮد‪ ،‬اﻳﻦ ﺑﻪ ﻣﻌﻨﺎي از دﺳﺖ دادن ﺣﺎﻛﻤﺖ ﺑﺎس ﺑـﻮده و‬

‫اﻳﻦ وﺿﻌﻴﺖ ﺑﺎ ﻳﻚ ﺷﺪن ﺑﻴﺖ ‪ SPIF‬اﻋﻼم ﻣﻲ ﺷﻮد‪ .‬ﺑﺎ اﺟﺮاي ‪ ISR‬ﻳﺎ ﺧﻮاﻧﺪن رﺟﻴﺴﺘﺮ وﺿﻌﻴﺖ اﻳﻦ ﺑﻴﺖ ﭘﺎك ﻣﻲ‬

‫ﺷﻮد‪.‬‬

‫‪SPI Control Register‬‬

‫‪SPCR‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪ SPIE SPE DORD MSTR CPOL SPHA SPR1 SPR0‬ﻧﺎم ﺑﻴﺖ‬

‫‪ :SPI Clock Rate Select 1 and 0‬اﻳﻦ دو ﺑﻴﺖ ﻧﺮخ ﻛﻼك ‪ SCK‬را ﻛﻪ ‪ Master‬اﻳﺠﺎد ﻣـﻲ ﻛﻨـﺪ ﻣﻄـﺎﺑﻖ‬

‫ﺟﺪول زﻳﺮ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨﺪ‪.‬‬

‫ 
 ‬
‫‪P a g e | 207‬‬
‫‪www.avr.ir‬‬

‫ﻓﺮﻛﺎﻧﺲ ‪SPI2X SPR1 SPR0 SCK‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪f osc /4‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪f osc /16‬‬

‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪f osc /64‬‬

‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪f osc /128‬‬

‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪f osc /2‬‬

‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪f osc /8‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪f osc /32‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪f osc /64‬‬

‫‪ Clock Phase‬و ‪ :Clock Polarity‬اﻳﻦ دو ﺑﻴﺖ ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ زﻣﺎن ﺑﻨـﺪي اﻧﺘﻘـﺎل و درﻳﺎﻓـﺖ داده روي‬

‫ﺑﺎس ‪ SPI‬را ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨﺪ‪:‬‬

‫ﻟﺒﻪ ي ﻧﻤﻮﻧﻪ ﺑﺮداري ﻟﺒﻪ ي ﺷﻴﻔﺖ ‪CPOL CPHA‬‬

‫‪0‬‬ ‫‪0‬‬ ‫ﭘﺎﻳﻴﻦ روﻧﺪه‬ ‫ﺑﺎﻻ روﻧﺪه‬

‫‪0‬‬ ‫‪1‬‬ ‫ﺑﺎﻻ روﻧﺪه‬ ‫ﭘﺎﻳﻴﻦ روﻧﺪه‬

‫‪1‬‬ ‫‪0‬‬ ‫ﺑﺎﻻ روﻧﺪه‬ ‫ﭘﺎﻳﻴﻦ روﻧﺪه‬

‫‪1‬‬ ‫‪1‬‬ ‫ﭘﺎﻳﻴﻦ روﻧﺪه‬ ‫ﺑﺎﻻ روﻧﺪه‬

‫ 
 ‬
‫‪P a g e | 208‬‬
‫‪www.avr.ir‬‬
‫‪ :Master/Slave Select‬ﺑﺎ ﻳﻚ ﻛﺮدن اﻳﻦ ﺑﻴﺖ ﻣﺎژول ‪ SPI‬در وﺿﻌﻴﺖ ‪ Master‬ﻗﺮار ﻣﻲ ﮔﻴﺮد‪.‬‬

‫‪ :Data Order‬ﺑﺎ ﻳﻚ ﺑﻮدن اﻳﻦ ﺑﻴﺖ اﺑﺘﺪا ‪ MSB‬روي ﺑﺎس ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮد و در ﺻﻮرت ﺻﻔﺮ ﺑﻮدن اﺑﺘﺪا ‪.LSB‬‬

‫‪ :SPI Enable‬ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز ‪SPI‬‬

‫‪ :SPI Interrupt Enable‬ﺑﻴﺖ ﻓﻌﺎل ﺳﺎز وﻗﻔﻪ ي ‪SPI‬‬

‫ﻧﺤﻮه ي اﻧﺘﻘﺎل داده در ‪SPI‬‬

‫وﻗﺘﻲ ﻣﺎژول ‪ SPI‬ﺑﻪ ﻋﻨﻮان ‪ Master‬ﭘﻴﻜﺮﺑﻨﺪي ﺷﺪه اﺳﺖ ﺧﻂ ‪ SS‬را ﺑﺼﻮرت ﺧﻮدﻛﺎر ﻛﻨﺘـﺮل ﻧﻤـﻲ ﻛﻨـﺪ و اﻳـﻦ‬

‫وﻇﻴﻔﻪ ﺑﺎﻳﺪ ﺗﻮﺳﻂ ﻧﺮم اﻓﺰار‪ ،‬ﻗﺒﻞ از آﻏﺎز ﻳﻚ ﭼﺮﺧﻪ ي ارﺗﺒﺎﻃﻲ اﻧﺠﺎم ﺷﻮد‪ .‬ﭘﺲ از ﺻـﻔﺮ ﻛـﺮدن ‪ ، SS‬ﻧﻮﺷـﺘﻦ ﻳـﻚ‬

‫ﺑﺎﻳﺖ در رﺟﻴﺴﺘﺮ داده )‪ (SPDR‬ﺑﺎﻋﺚ اﻳﺠﺎد ﻛﻼك ﺗﻮﺳﻂ واﺣﺪ ﺗﻮﻟﻴﺪ ﻛﻼك ﺧﻮاﻫﺪ ﺷـﺪ و ﺑـﺎ ﻫـﺮ ﭘـﺎﻟﺲ‪ ،‬داده ي‬

‫ﻣﻮﺟﻮد در ‪ Shift Register‬ﻫﺎي ‪ Master‬و ‪ Slave‬ﻳﻚ ﺑﻴﺖ ﺷﻴﻔﺖ داده ﺷﺪه و ﭘﺲ از ‪ 8‬ﭘﺎﻟﺲ ﺳﺎﻋﺖ ﭘـﺮﭼﻢ‬

‫‪ SPIF‬ﺑﻪ ﻧﺸﺎﻧﻪ ي اﺗﻤﺎم ارﺳﺎل ﻳﻚ ﻣﻲ ﺷﻮد‪ .‬ﭘﺲ از اﻳﻦ ‪ Master‬ﻣﻲ ﺗﻮاﻧﺪ ﺑـﺮاي ارﺳـﺎل ﺑﺎﻳـﺖ ﺑﻌـﺪي آن را در‬

‫‪ SPDR‬ﻧﻮﺷﺘﻪ و ﻳﺎ ﺑﻪ ﻧﺸﺎﻧﻪ ي اﺗﻤﺎم ارﺳﺎل ﺧﻂ ‪ SS‬را ﻳﻚ ﻧﮕﺎه دارد‪.‬‬

‫ 
 ‬
‫‪P a g e | 209‬‬
‫‪www.avr.ir‬‬
‫در ﻧﻘﻄﻪ ي ﻣﻘﺎﺑﻞ زﻣﺎﻧﻴﻜﻪ ﻣﺎژول ‪ SPI‬در ﻧﻘﺶ ‪ Slave‬ﭘﻴﻜﺮﺑﻨﺪي ﺷﺪه اﺳﺖ‪ ،‬ﻣﺎداﻣﻴﻜﻪ ﺧـﻂ ‪ SS‬ﻳـﻚ اﺳـﺖ ﭘـﻴﻦ‬

‫‪ MISO‬در وﺿﻌﻴﺖ ‪ tri-stated‬ﻣﻲ ﺑﺎﺷﺪ‪ .‬در اﻳﻦ ﺷﺮاﻳﻂ ﻣﻤﻜﻦ اﺳﺖ ﻛﻪ رﺟﻴﺴﺘﺮ ‪ SPDR‬ﺗﻮﺳـﻂ ‪ Slave‬ﺑـﺮوز‬

‫ﺷﻮد اﻣﺎ ﺗﺎ زﻣﺎﻧﻲ ﻛﻪ ﺧﻂ ‪ SS‬ﺗﻮﺳﻂ ‪ Master‬ﺻﻔﺮ ﻧﺸﻮد اﻧﺘﻘﺎل اﻧﺠـﺎم ﻧﺨﻮاﻫـﺪ ﺷـﺪ‪ .‬ﭘـﺲ از ‪ Low‬ﺷـﺪن ‪ SS‬و‬

‫اﺗﻤﺎم درﻳﺎﻓﺖ ﻳﻚ ﺑﺎﻳﺖ ﭘﺮﭼﻢ ‪ SPIF‬ﻳﻚ ﺷﺪه و در ﺻﻮرت ﻳﻚ ﺑﻮدن ‪ SPIE‬و ﺑﻴـﺖ ‪ ،I‬اﻳـﻦ روﻳـﺪاد ﻣـﻲ ﺗﻮاﻧـﺪ‬

‫ﺑﺎﻋﺚ اﻳﺠﺎد وﻗﻔﻪ ﺷﻮد‪ .‬ﭘﺲ از اﻳﻦ ﻣﻤﻜﻦ اﺳﺖ ‪ Slave‬داده ي ﺟﺪﻳﺪي را در ‪ SPDR‬ﻗﺮار دﻫﺪ ﻣﻨﺘﻬﺎ ﺑﺎﻳﺪ ﻗﺒـﻞ از‬

‫آن داده ي درﻳﺎﻓﺘﻲ را ﺑﺨﻮاﻧﺪ‪.‬‬

‫ارﺗﺒﺎط ﺷﺒﻜﻪ اي در ‪SPI‬‬

‫ﻣﻄﺎﺑﻖ ﺗﺼﻮﻳﺮ زﻳﺮ ﺑﺎ اﺳﺘﻔﺎده از ﭘﻴﻦ ‪ SS‬ﻣﻲ ﺗـﻮان ﺗﻌـﺪادي ‪ Slave‬را ﻛﻨﺘـﺮل ﻧﻤـﻮد‪ Master .‬ﺑﺎﻳـﺪ ﺗﻨﻬـﺎ ﭘـﻴﻦ ‪SS‬‬

‫‪ Slave‬اي را ﻛﻪ ﻣﻲ ﺧﻮاﻫﺪ ﺑﺎ آن ارﺗﺒﺎط ﺑﺮﻗﺮار ﻛﻨﺪ ﺻﻔﺮ ﻛﻨﺪ و ﺑﻘﻴﻪ را ﻳﻚ ﻧﮕﻪ دارد‪.‬‬

‫ 
 ‬
‫‪P a g e | 210‬‬
‫‪www.avr.ir‬‬

‫ﺗﺎﺑﻊ )(‪ spi‬در ‪CodeVision‬‬

‫اﻋﻼن اﻳﻦ ﺗﺎﺑﻊ در ﻓﺎﻳﻞ ‪ spi.h‬ﺑﻮده و ﻧﺤﻮه ي ﻋﻤﻠﻜﺮد آن در ﻓﺎﻳﻞ ‪ spi.lib‬ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫)‪unsigned char spi(unsigned char data‬‬

‫{‬
‫;‪SPDR=data‬‬
‫;)‪while ((SPSR & (1<<SPIF))==0‬‬
‫;‪return SPDR‬‬
‫}‬

‫ﺑﻨﺎﺑﺮاﻳﻦ آﻧﭽﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﻋﻨﻮان آرﮔﻮﻣﺎن درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ روي ﺑﺎس ‪ SPI‬ﻗﺮار ﻣﻲ دﻫﺪ و ﻣﻘﺪار ﺑﺎزﮔﺸﺘﻲ آن ﻣﻘـﺪار‬

‫ﺧﻮاﻧﺪه ﺷﺪه از ﺑﺎس اﺳﺖ‪ .‬ﻗﺒﻞ از اﺳﺘﻔﺎده از اﻳﻦ ﺗﺎﺑﻊ ﺑﺎﻳﺪ ‪ SPI‬ﺑﻮﺳﻴﻠﻪ ي رﺟﻴﺴﺘﺮﻫﺎي ﻛﻨﺘﺮل و وﺿﻌﻴﺖ ﺗﻨﻈﻴﻢ ﺷﺪه‬

‫ﺑﺎﺷﺪ‪.‬‬

‫ﻣﺜﺎل‪) :‬ارﺗﺒﺎط دو ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ از ﻃﺮﻳﻖ ‪(SPI‬‬

‫ﺑﺮﻧﺎﻣﻪ ﻣﻴﻜﺮو ‪:Master‬‬

‫>‪#include <mega16.h‬‬
‫>‪#include <delay.h‬‬

‫‪// SPI functions‬‬

‫>‪#include <spi.h‬‬

‫)‪void main(void‬‬
‫{‬

‫
 ‬
P a g e | 211
www.avr.ir

unsigned char incoming;

// SCK=Out MISO=In MOSI=Out SS=Out

PORTB=0b00000000;
DDRB=0b10110000;

// SPI initialization
// SPI Type: Master
// SPI Clock Rate: 500.000 kHz
// SPI Clock Phase: Cycle Half
// SPI Clock Polarity: Low
// SPI Data Order: MSB First
// SPI Enable: True
SPCR=0x71;

while(1)
{
incoming=spi(0x77);
delay_ms(50);
}
}

:Slave ‫ﺑﺮﻧﺎﻣﻪ ﻣﻴﻜﺮو‬

#include <mega16.h>
#include <delay.h>

  
P a g e | 212
www.avr.ir

// SPI functions
#include <spi.h>

void main(void)
{

unsigned char incoming;

// SCK=In MISO=Out MOSI=In SS=In

DDRB=0b01000000;

// SPI initialization
// SPI Type: Slave
// SPI Clock Rate: 500.000 kHz
// SPI Clock Phase: Cycle Half
// SPI Clock Polarity: Low
// SPI Data Order: MSB First
// SPI Enable: True
SPCR=0x61;

while(1)
{
incoming=spi(0x33);
delay_ms(50);
}
}

   
‫‪P a g e | 213‬‬
‫‪www.avr.ir‬‬

‫‪ Mode‬ﻫﺎي ‪ Sleep‬و ﺗﺎﻳﻤﺮ ‪Watchdog‬‬

‫ﺑﻪ ﻣﻨﻈﻮر ﻣﺪﻳﺮﻳﺖ ﻳﻬﻴﻨﻪ ي ﺗﻮان ﻣﺼﺮﻓﻲ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮﻫﺎي ‪ AVR‬داراي ﺣﺪاﻛﺜﺮ ‪ Mode 6‬ﺧﻮاب ﻣﻲ ﺑﺎﺷﻨﺪ‪ .‬ﺑﺮاي‬

‫ورود ﺑﻪ ﻫﺮﻳﻚ از ‪ 6‬وﺿﻌﻴﺖ ﺧﻮاب ﺑﺎﻳﺪ ﺑﻴﺖ ‪ SE‬از رﺟﻴﺴﺘﺮ ‪ MCUCE‬ﻳﻚ ﺷﺪه و دﺳﺘﻮراﻟﻌﻤﻞ ‪ SLEEP‬اﺟﺮا‬

‫ﺷﻮد‪ .‬ﺑﻴﺖ ﻫﺎي ]‪ SM[2:0‬از اﻳﻦ رﺟﻴﺴﺘﺮ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨـﺪ ﻛـﻪ ﻣﻴﻜﺮوﻛﻨﺘﺮﻟـﺮ وارد ﻛـﺪاﻣﻴﻚ از ‪ Mode‬ﻫـﺎي ﻛـﻢ‬

‫ﻣﺼﺮف ﺷﻮد‪ .‬در ﺣﻴﻦ ﺧﻮاب اﮔﺮ وﻗﻔﻪ اي روي دﻫﺪ ﻣﻴﻜﺮو از اﻳﻦ وﺿﻌﻴﺖ ﺧﺎرج ﺷﺪه و ﺑﻌﺪ از ﮔﺬﺷﺖ ‪ 4‬ﺳـﻴﻜﻞ‬

‫ﺑﻪ ﻋﻼوه ي زﻣﺎن ‪ ،Startup‬روﺗﻴﻦ ﺳﺮوﻳﺲ وﻗﻔﻪ را اﺟﺮا ﻛﺮده و ﭘﺲ از آن دﺳﺘﻮراﻟﻌﻤﻞ ﺑﻌﺪ از ‪ SLEEP‬را اﺟـﺮا‬

‫ﺧﻮاﻫﺪ ﻛﺮد‪.‬‬

‫‪MCU Control Register‬‬

‫‪MCUCR‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪SE SM2 SM1 SM0 ISC11 ISC10 ISC01 ISC00‬‬

‫]‪ :Sleep Mode Select Bits[2:0‬اﻳﻦ ﺑﻴﺖ ﻫﺎ ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﻳﻜﻲ از ‪ 6‬وﺿﻌﻴﺖ ‪ SLEEP‬را اﻧﺘﺨﺎب ﻣﻲ‬

‫ﻛﻨﻨﺪ‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ‪ Mode‬ﻫﺎي ‪ Standby‬و ‪ Extended Standby‬ﻓﻘﻂ ﺑﺎ ﻣﻨﺒﻊ ﻛﻼك ﻛﺮﻳﺴﺘﺎل ﻳﺎ‬

‫رزوﻧﺎﺗﻮر ﺧﺎرﺟﻲ ﻗﺎﺑﻞ اﺳﺘﻔﺎده ﻣﻲ ﺑﺎﻧﺪ‪.‬‬

‫   ‬
‫‪P a g e | 214‬‬
‫‪www.avr.ir‬‬

‫‪SM2 SM1 SM0‬‬ ‫وﺿﻌﻴﺖ ﺧﻮاب‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪Idle‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪ADC Noise Reduction‬‬

‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪Power-down‬‬

‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪Power-save‬‬

‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫رزرو ﺷﺪه‬

‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫رزرو ﺷﺪه‬

‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪Standby‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪Extende Standby‬‬

‫‪ :Sleep Enable‬ﻗﺒﻞ از اﺟﺮاي دﺳﺘﻮر ‪ SLEEP‬ﺑﺎﻳﺪ اﻳﻦ ﺑﻴﺖ ﻳﻚ ﺷﺪه ﺑﺎﺷﺪ‪.‬‬

‫‪ Mode‬ﻫﺎي ﺧﻮاب‬

‫‪ :Idle Mode‬در اﻳﻦ وﺿﻌﻴﺖ ‪ CPU‬ﻣﺘﻮﻗـﻒ ﺷـﺪه اﻣـﺎ ‪ ,SPI, USART‬ﻣﻘﺎﻳﺴـﻪ ﻛﻨﻨـﺪه ي آﻧـﺎﻟﻮگ‪،‬‬ ‫•‬

‫‪ ,ADC, TWI‬ﺗﺎﻳﻤﺮﻫﺎ‪ Watchdog ،‬و ﺳﻴﺴﺘﻢ وﻗﻔﻪ ﺑﻪ ﻛﺎر ﺧﻮد اداﻣﻪ دﻫﻨﺪ‪ .‬اﻳﻦ وﺿﻌﻴﺖ ﺑﺎﻋﺚ ﻣﻲ ﺷﻮد ﻛـﻼك‬

‫‪ CPU‬و ﻛﻼك ‪ Flash‬ﻣﺘﻮﻗﻒ ﺷﺪه اﻣﺎ ﺑﻘﻴﻪ ي ﻣﻨﺎﺑﻊ ﻛﻼك ﺑﻪ ﻛﺎر ﺧﻮد اداﻣﻪ دﻫﻨﺪ‪ .‬ﻣﻨﺎﺑﻊ وﻗﻔﻪ ي داﺧﻠﻲ و ﺧﺎرﺟﻲ‬

‫ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﺎﻋﺚ ﺧﺮوج ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ از وﺿﻌﻴﺖ ﺧﻮاب ﺷﻮﻧﺪ‪.‬‬

‫   ‬
‫‪P a g e | 215‬‬
‫‪www.avr.ir‬‬
‫‪ CPU :ADC Noise Reduction Mode‬ﻣﺘﻮﻗﻒ ﺷﺪه اﻣﺎ ﻣﺎژول ﻫﺎي ‪ ,ADC‬وﻗﻔﻪ ﻫﺎي ﺧﺎرﺟﻲ‪،‬‬ ‫•‬

‫ﺗﺸﺨﻴﺺ آدرس ‪ ,TWI‬ﺗﺎﻳﻤﺮ ‪ 2‬و ‪ Wathdog‬ﺑﻪ ﻛﺎر ﺧﻮد اداﻣﻪ ﻣـﻲ دﻫﻨـﺪ‪ .‬در ﺻـﻮرت ﻓﻌـﺎل ﺑـﻮدن ‪ ADC‬ﺑـﻪ‬

‫ﻣﺤﺾ ورود ﺑﻪ اﻳﻦ ‪ Mode‬اﻧﺠﺎم ﺗﺒﺪﻳﻞ ﺷﺮوع ﺷﺪه و ﺑﺎ اﺗﻤﺎم آن از اﻳﻦ وﺿﻌﻴﺖ ﺧﺎرج ﻣﻲ ﺷـﻮد‪ .‬ﻣﻨـﺎﺑﻊ وﻗﻔـﻪ ي‬

‫ﻣﺎژول ﻫﺎﻳﻲ ﻛﻪ در اﻳﻦ ‪ Mode‬ﻓﻌﺎﻟﻨﺪ و ﻫﻤﭽﻨﻴﻦ ‪ Reset‬ﺧﺎرﺟﻲ‪ Reset ,‬ﺗـﺎﻳﻤﺮ ‪ Wachdog‬و ‪Brown-out‬‬

‫‪ Reset‬ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﺎﻋﺚ ﺧﺮوج از اﻳﻦ ‪ Mode‬ﺷﻮﻧﺪ‪.‬‬

‫‪ :Power-down Mode‬در اﻳﻦ وﺿﻌﻴﺖ اﺳﻴﻼﺗﻮر ﺧﺎرﺟﻲ ﻣﺘﻮﻗﻒ ﺷـﺪه در ﺻـﻮرﺗﻲ ﻛـﻪ وﻗﻔـﻪ ﻫـﺎي‬ ‫•‬

‫ﺧــﺎرﺟﻲ آﺳــﻨﻜﺮون‪ TWI ،‬و ‪ Watchdog‬ﺑــﻪ ﻛــﺎر ﺧــﻮد اداﻣــﻪ ﻣــﻲ دﻫﻨــﺪ‪ Reset .‬ﺧــﺎرﺟﻲ‪ Reset ،‬ﺗــﺎﻳﻤﺮ‬

‫‪ ،Brown-out Reset ،Watchdog‬ﺗﻄﺒﻴــﻖ آدرس ‪ TWI‬و وﻗﻔــﻪ ﻫــﺎي ﺧــﺎرﺟﻲ ﻣــﻲ ﺗﻮاﻧﻨــﺪ ﺑﺎﻋــﺚ ﺧــﺮوج‬

‫ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ از ﺣﺎﻟﺖ ﺧﻮاب ﺷﻮﻧﺪ‪ .‬اﺳﺎﺳﺎ در اﻳﻦ ‪ Mode‬ﺗﻤﺎم ﻛﻼك ﻫﺎ ﻣﺘﻮﻗﻒ ﺷﺪه و ﺗﻨﻬﺎ ﻣﺎژول ﻫﺎي آﺳـﻨﻜﺮون‬

‫ﺑﻪ ﻛﺎر ﺧﻮد اداﻣﻪ ﻣﻲ دﻫﻨﺪ‪.‬‬

‫‪ :Power-save Mode‬اﻳﻦ ‪ Mode‬ﻣﺸﺎﺑﻪ ‪ Power-down‬ﺑﻮده ﺑﺎ اﻳﻦ ﺗﻔـﺎوت ﻛـﻪ اﮔـﺮ ﺗـﺎﻳﻤﺮ ‪ 2‬در‬ ‫•‬

‫‪ Mode‬آﺳﻨﻜﺮون ﻛﺎر ﻛﻨﺪ در ﺣﻴﻦ ﺧﻮاب ﺑﻪ ﻛـﺎر ﺧـﻮد اداﻣـﻪ ﺧﻮاﻫـﺪ داد‪ .‬در ﺻـﻮرﺗﻲ ﻛـﻪ از ﺗـﺎﻳﻤﺮ ‪ 2‬ﺑﺼـﻮرت‬

‫آﺳﻨﻜﺮون اﺳﺘﻔﺎده ﻧﻤﻲ ﺷﻮد ﺑﻬﺘﺮ اﺳﺖ ﺑﺠﺎي اﻳﻦ ‪ Mode‬از ‪ Power-down‬اﺳﺘﻔﺎده ﺷﻮد‪.‬‬

‫‪ :Standby Mode‬اﻳﻦ ‪ Mode‬ﻣﺸﺎﺑﻪ ‪ Power-down‬ﺑﻮده ﺑـﺎ اﻳـﻦ ﺗﻔـﺎوت ﻛـﻪ اﺳـﻴﻼﺗﻮر ﺧـﺎرﺟﻲ‬ ‫•‬

‫ﻣﺘﻮﻗﻒ ﻧﻤﻲ ﺷﻮد و اﮔﺮﭼﻪ از ﺑﺨﺶ ﻫﺎي دﻳﮕﺮ ﺟﺪا ﺷﺪه اﺳﺖ اﻣﺎ ﻫﻤﭽﻨﺎن ﺑﻪ ﻛﺎر ﺧﻮد اداﻣـﻪ ﻣـﻲ دﻫـﺪ‪ .‬در ﻧﺘﻴﺠـﻪ‬

‫زﻣﺎن ‪ Startup‬ﺣﺬف ﺷﺪه و زﻣﺎن ﺑﻴﺪار ﺷﺪن ﻣﻴﻜﺮو ﺑﻪ ‪ 6‬ﺳﻴﻜﻞ ﻛﺎﻫﺶ ﻣﻲ ﻳﺎﺑﺪ‪.‬‬

‫‪ :Extended Standby Mode‬اﻳﻦ ‪ Mode‬ﻣﺸﺎﺑﻪ ‪ Power-save‬ﺑﻮده ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛـﻪ اﺳـﻴﻼﺗﻮر‬ ‫•‬

‫ﺧﺎرﺟﻲ ﻣﺘﻮﻗﻒ ﻧﻤﻲ ﺷﻮد‪.‬‬

‫   ‬
‫‪P a g e | 216‬‬
‫‪www.avr.ir‬‬

‫ﺗﻮاﺑﻊ ﻣﺪﻳﺮﻳﺖ ﺗﻮان در ‪CodeVision‬‬

‫اﻋﻼن اﻳﻦ ﺗﻮاﺑﻊ در ﻓﺎﻳﻞ ‪ sleep.h‬ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﺷﺎﻣﻞ ﻣﻮارد زﻳﺮ ﻣﻲ ﺑﺎﺷﻨﺪ‪.‬‬

‫)(‪ :sleep_enable‬اﻳﻦ ﺗﺎﺑﻊ ﻓﻌﺎل ﺳﺎز ورود ﺑﻪ ‪ Mode‬ﻫﺎي ﺧﻮاب ﺑﻮده و ﻗﺒﻞ از اﺳﺘﻔﺎده از ﺳﺎﻳﺮ ﺗﻮاﺑﻊ ﻣﺪﻳﺮﻳﺖ‬

‫ﺗﻮاﺑﻊ ﺑﺎﻳﺪ اﺟﺮا ﺷﻮد‪.‬‬

‫)(‪ :sleep_disable‬اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﻏﻴﺮ ﻓﻌﺎل ﻛﺮدن ‪ Mode‬ﻫﺎي ﺧﻮاب ﺑﻪ ﻛﺎر ﻣﻲ رود‪.‬‬

‫)(‪ standby() ،powersave() ،powerdown() ،idle‬و )(‪ :extended_standby‬ﺑﺎ اﺟﺮاي ﻫﺮﻳﻚ از اﻳﻦ‬

‫ﺗﻮاﺑﻊ ﻣﻴﻜﺮو وارد ‪ Mode‬ﻛﻢ ﺗﻮان ﻣﺮﺑﻮﻃﻪ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫ﺗﺎﻳﻤﺮ ‪Watchdog‬‬

‫ﺗﺎﻳﻤﺮ ‪ Watchdog‬از ﻳﻚ اﺳﻴﻼﺗﻮر داﺧﻠﻲ ﻣﺠﺰا ﺑﺎ ﻓﺮﻛﺎﻧﺲ ‪ 1‬ﻣﮕﺎﻫﺮﺗﺰ ﻛﻼك درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﺑـﺎ ﺗﻨﻈـﻴﻢ ﭘـﻴﺶ‬

‫ﺗﻘﺴﻴﻢ ﻛﻨﻨﺪه ي ﺗﺎﻳﻤﺮ ‪ ،Watchdog‬ﻓﻮاﺻﻞ ﺑﻴﻦ ﻫﺮ ‪ Reset‬ﺑـﺎ ﺑﻴـﺖ ﻫـﺎي ]‪ WDP[0:2‬ﻗﺎﺑـﻞ ﺗﻨﻈـﻴﻢ اﺳـﺖ‪ .‬ﺑـﺎ‬

‫دﺳﺘﻮراﻟﻌﻤﻞ ‪ WDR‬ﻳﺎ ‪ Reset‬ﺷﺪن ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ﺗﺎﻳﻤﺮ ‪ Reset ,Watchdog‬ﺷﺪه و ﻧﺮم اﻓﺰار ﺑﺎﻳـﺪ در ﻓﻮاﺻـﻞ‬

‫ﻣﻨﺎﺳﺐ ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ دﺳﺘﻮراﻟﻌﻤﻞ ﺗﺎﻳﻤﺮ را ‪ Reset‬ﻛﺮده ﺗﺎ ﻣﺎﻧﻊ ‪ Reset‬ﺷﺪن ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ ﺷﻮد‪ .‬ﺑﻠـﻮك دﻳـﺎﮔﺮام‬

‫ﺗﺎﻳﻤﺮ ‪ Watchdog‬در ﺗﺼﻮﻳﺮ زﻳﺮ دﻳﺪه ﻣﻲ ﺷﻮد‪.‬‬

‫   ‬
P a g e | 217
www.avr.ir

Watchdog Timer Control Register

WDTCR 7 6 5 4 3 2 1 0
‫ﻧﺎم ﺑﻴﺖ‬ - - - WDTOE WDE WDP2 WDP1 WDP0

‫ ﻓﻌﺎل اﺳﺖ اﻳﻦ ﺑﻴﺖ ﻫﺎ ﺿﺮﻳﺐ ﺗﻘﺴﻴﻢ‬Watchdog ‫ زﻣﺎﻧﻲ ﻛﻪ ﺗﺎﻳﻤﺮ‬:Watchdog Timer Prescaler[2:0]

.‫ﺗﺎﻳﻤﺮ را ﻣﻄﺎﺑﻖ ﺟﺪول زﻳﺮ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻨﺪ‬

   
‫‪P a g e | 218‬‬
‫‪www.avr.ir‬‬
‫‪ Watchdog Turn-off Enable‬و ‪ :Watchdog Enable‬ﺑﺎ ﻧﻮﺷﺘﻦ ﻳﻚ روي ﺑﻴﺖ ‪ WDE‬ﺗﺎﻳﻤﺮ‬

‫‪ Watchdog‬ﻓﻌﺎل ﺷﺪه و ﺑﺎ ﭘﺎك ﻛﺮدن آن ﺗﺎﻳﻤﺮ ﻏﻴﺮ ﻓﻌﺎل ﻣﻲ ﺷﻮد‪ .‬اﮔﺮﭼﻪ ﻓﻌﺎل ﻛﺮدن ﺗﺎﻳﻤﺮ ﺑﻪ ﺳﺎدﮔﻲ و ﺑﺎ ﻧﻮﺷﺘﻦ‬

‫ﻳﻚ روي ‪ WDE‬اﻧﺠﺎم ﻣﻲ ﺷﻮد اﻣﺎ ﺑﺮاي ﻏﻴﺮ ﻓﻌﺎل ﻛﺮدن آن ﺑﺎﻳﺪ ﻣﺮاﺣﻞ زﻳﺮ ﺑﻪ ﺗﺮﺗﻴﺐ اﻧﺠﺎم ﺷﻮد‪:‬‬

‫‪ .1‬ﻫﻤﺰﻣﺎن ﺑﻴﺖ ﻫﺎي ‪ WDTOE‬و ‪ WDE‬را ﻳﻚ ﻛﻨﻴﺪ‪) .‬ﺑﻴﺖ ‪ WDE‬ﻋﻠﻴﺮﻏﻢ اﻳﻨﻜﻪ ﻗﺒﻼ ﻳﻚ ﺑﻮده ﺑﺎﺷﺪ ﺑﺎﻳﺪ‬

‫ﻣﺠﺪدا ﻳﻚ ﺷﻮد‪(.‬‬

‫‪ .2‬ﺗﺎ ﭼﻬﺎر ﺳﻴﻜﻞ ﺑﻌﺪ ﻧﺮم اﻓﺰار ﻓﺮﺻﺖ دارد ﺗﺎ ‪ WDE‬را ﭘﺎك ﻛﻨﺪ‪.‬‬

‫   ‬
‫‪P a g e | 219‬‬
‫‪www.avr.ir‬‬

‫ﭘﻴﻮﺳﺖ ‪ :1‬ﺗﻨﻈﻴﻤﺎت رﺟﻴﺴﺘﺮﻫﺎي ‪I/O‬‬

‫ﻫﺮ ﻳﻚ از ﭼﻬﺎر ﭘﻮرت ‪ C ،B ،A‬و ‪ D‬ﻗﻄﻌﻪ ي ‪ ATmega16‬داراي ﺳﻪ رﺟﻴﺴﺘﺮ ‪ PORTx ،DDRx‬و ‪PINx‬‬

‫ﺑﻮده ﻛﻪ ‪ x‬ﺣﺮف ﻣﺮﺑﻮط ﺑﻪ ﭘﻮرت ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل رﺟﻴﺴﺘﺮﻫﺎي اوﻟﻴﻦ ﭘﻮرت‪ PORTA ،DDRA ،‬و‬

‫‪ PINA‬ﺑﻮده ﻛﻪ وﻇﺎﻳﻒ ﻫﺮ ﻳﻚ در ذﻳﻞ آﻣﺪه اﺳﺖ‪:‬‬

‫رﺟﻴﺴﺘﺮ ‪:Data Direction‬‬

‫اﻳﻦ رﺟﻴﺴﺘﺮ ﻫﻤﺎﻧﻄﻮر ﻛﻪ از ﻧﺎم اش ﻣﺸﺨﺺ اﺳﺖ رﺟﻴﺴﺘﺮ ﺟﻬﺖ داده ي ﭘﻮرت ﺑﻮده و ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﭘﻮرت‬

‫ورودي اﺳﺖ ﻳﺎ ﺧﺮوﺟﻲ‪ .‬ﺑﺪﻳﻦ ﺻﻮرت ﻛﻪ اﮔﺮ روي ﻫﺮﻛﺪام از ﺑﻴﺖ ﻫﺎي اﻳﻦ رﺟﻴﺴﺘﺮ ﻳﻚ ﻧﻮﺷﺘﻪ ﺷﻮد ﭘﻴﻦ ﻣﺘﻨﺎﻇﺮ‬

‫آن ﭘﻮرت ﺧﺮوﺟﻲ ﺑﻮده و در ﻏﻴﺮ اﻳﻨﺼﻮرت ورودي ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺎ اﺟﺮاي ﻋﺒﺎرت = ‪DDRA‬‬

‫‪ 0b10111101‬وﺿﻌﻴﺖ ﺑﻴﺖ ﻫﺎي اﻳﻦ رﺟﻴﺴﺘﺮ و ﭘﻴﻦ ﻫﺎي ﻣﺮﺑﻮﻃﻪ ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬

‫‪DDRA‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬

‫ﺟﻬﺖ داده‬ ‫ﺧﺮوﺟﻲ‬ ‫ورودي‬ ‫ﺧﺮوﺟﻲ‬ ‫ﺧﺮوﺟﻲ‬ ‫ﺧﺮوﺟﻲ‬ ‫ﺧﺮوﺟﻲ‬ ‫ورودي‬ ‫ﺧﺮوﺟﻲ‬

‫رﺟﻴﺴﺘﺮ ‪:PORTx‬‬

‫ﻋﻤﻠﻜﺮد اﻳﻦ رﺟﻴﺴﺘﺮ ﺑﺴﺘﮕﻲ ﺑﻪ ﺟﻬﺖ داده ي ﭘﻮرت دارد‪ .‬در ﺻﻮرﺗﻲ ﻛﻪ ﺑﻪ ﻋﻨﻮان ﺧﺮوﺟﻲ ﭘﻴﻜﺮﺑﻨﺪي ﺷﺪه ﺑﺎﺷﺪ‪.‬‬

‫آﻧﭽﻪ روي ﭘﻮرت ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد ﺳﻄﺢ ﻣﻨﻄﻘﻲ آن را ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ و در ﺻﻮرﺗﻲ ﻛﻪ ورودي ﺑﺎﺷﺪ ﺑﺎ ﻳﻚ ﻛﺮدن ﻫﺮ‬

‫   ‬
‫‪P a g e | 220‬‬
‫‪www.avr.ir‬‬
‫ﺑﻴﺖ ﻣﻘﺎوﻣﺖ ‪ Pull-up‬داﺧﻠﻲ ﻣﺮﺑﻮط ﺑﻪ آن ﭘﻴﻦ ﻓﻌﺎل ﻣﻲ ﺷﻮد‪ .‬ﺑﻪ ﻋﻨﻮان ﻧﻤﻮﻧﻪ در اداﻣﻪ ي ﻣﺜﺎل ﻗﺒﻞ در ﺻﻮرﺗﻲ ﻛﻪ‬

‫ﻋﺒﺎرت ‪ PORTA = 0b11010100‬اﺟﺮا ﺷﻮد‪ ،‬وﺿﻌﻴﺖ ﭘﻮرت ﺑﻪ ﺻﻮرت زﻳﺮ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬

‫ﺷﻤﺎره ﺑﻴﺖ‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪DDRA‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬

‫‪PORTA‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬
‫ﺧﺮوﺟﻲ‬ ‫ورودي‬ ‫ﺧﺮوﺟﻲ‬ ‫ﺧﺮوﺟﻲ‬ ‫ﺧﺮوﺟﻲ‬ ‫ﺧﺮوﺟﻲ‬ ‫ورودي‬ ‫ﺧﺮوﺟﻲ‬

‫ﺑﺎ ﺳﻄﺢ‬ ‫ﺑﺎ‬ ‫ﺑﺎ ﺳﻄﺢ‬ ‫ﺑﺎ ﺳﻄﺢ‬ ‫ﺑﺎ ﺳﻄﺢ‬ ‫ﺑﺎ ﺳﻄﺢ‬ ‫ﺑﺪون‬ ‫ﺑﺎ ﺳﻄﺢ‬
‫ﺟﻬﺖ داده‬
‫ﻣﻨﻄﻘﻲ‬ ‫ﻣﻘﺎوﻣﺖ‬ ‫ﻣﻨﻄﻘﻲ‬ ‫ﻣﻨﻄﻘﻲ‬ ‫ﻣﻨﻄﻘﻲ‬ ‫ﻣﻨﻄﻘﻲ‬ ‫ﻣﻘﺎوﻣﺖ‬ ‫ﻣﻨﻄﻘﻲ‬

‫ﻳﻚ‬ ‫‪Pull-up‬‬ ‫ﺻﻔﺮ‬ ‫ﻳﻚ‬ ‫ﺻﻔﺮ‬ ‫ﻳﻚ‬ ‫‪Pull-up‬‬ ‫ﺻﻔﺮ‬

‫رﺟﻴﺴﺘﺮ ‪:PINx‬‬

‫ﺑﺮاي ﺧﻮاﻧﺪن ﻣﻘﺪار ﻫﺮ ﭘﻴﻦ ﺑﺎﻳﺪ ﻣﺤﺘﻮﻳﺎت اﻳﻦ رﺟﻴﺴﺘﺮ ﺧﻮاﻧﺪه ﺷﻮد‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﭼﻨﺎﻧﭽﻪ ‪ PORC‬را ﻗﺒﻼ ﺑﻪ‬

‫ﺻﻮرت ورودي ﭘﻴﻜﺮﺑﻨﺪي ﻛﺮده ﺑﺎﺷﻴﻢ و ﻣﻘﺪار رﺟﻴﺴﺘﺮ ‪ PINC‬ﺑﺮاﺑﺮ ‪ 0b11010000‬ﺑﺎﺷﺪ‪ ،‬ﺳﻄﺢ ﻣﻨﻄﻘﻲ اﻋﻤﺎل‬

‫ﺷﺪه ﺑﻪ ﭘﻴﻦ ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ‪:‬‬

‫‪PINC‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ﻧﺎم ﺑﻴﺖ‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬

‫ﺟﻬﺖ داده‬ ‫ﻳﻚ‬ ‫ﻳﻚ‬ ‫ﺻﻔﺮ‬ ‫ﻳﻚ‬ ‫ﺻﻔﺮ‬ ‫ﺻﻔﺮ‬ ‫ﺻﻔﺮ‬ ‫ﺻﻔﺮ‬

‫
 ‬
‫‪P a g e | 221‬‬
‫‪www.avr.ir‬‬

‫ﭘﻴﻮﺳﺖ ‪ :2‬ﻧﺤﻮه ي ارﺗﺒﺎط دﻫﻲ ورودي وﺧﺮوﺟﻲ ﻫﺎي ﻣﻴﻜﺮوﻛﻨﺘﺮﻟﺮ‬

‫  ‬
P a g e | 222
www.avr.ir

AVR ‫ ﻣﺸﺨﺼﺎت ﺑﺮﺧﻲ ﻗﻄﻌﺎت‬:3 ‫ﭘﻴﻮﺳﺖ‬

Flash EEPROM SRAM Max F.max 16-bit 8-bit PWM 10-bit Ext
Devices Vcc (V) SPI UART TWI Interrupts
(Kbytes) (Kbytes) (Bytes) I/O (MHz) Timers Timer (channels) A/D Interrupts

AT90PWM1 8 0.5 512 19 16 2.7-5.5 1 1 7 1 No -- 8 -- 4

AT90PWM2 8 0.5 512 19 16 2.7-5.5 1 1 7 1 Yes -- 8 -- 4

AT90PWM3 8 0.5 512 27 16 2.7-5.5 1 1 10 1 Yes -- 11 -- 4

ATmega128 128 4 4096 53 16 2.7-5.5 2 2 8 1 2 Yes 8 34 8

ATmega1280 128 4 8192 86 16 1.8-5.5 4 2 16 1 4 Yes 16 57 32

ATmega1281 128 4 8192 54 16 1.8-5.5 4 2 9 1 2 Yes 8 48 17

ATmega16 16 0.5 1024 32 16 2.7-5.5 1 2 4 1 1 Yes 8 20 3

ATmega162 16 0.5 1024 35 16 1.8-5.5 2 2 6 1 2 -- -- 28 3

ATmega164P 16 0.512 1024 32 20 1.8-5.5 1 2 6 1 2 Yes 8 31 32

ATmega165 16 0.5 1024 54 16 1.8-5.5 1 2 4 1 1 USI 8 23 17

ATmega165P 16 0.5 1024 54 16 1.8-5.5 1 2 4 1 1 USI 8 23 17

ATmega168 16 0.5 1024 23 20 1.8-5.5 1 2 6 1 1 Yes 8 26 26

ATmega169 16 0.5 1024 54 16 1.8-5.5 1 2 4 1 1 USI 8 23 17

ATmega169P 16 0.5 1024 54 16 1.8-5.5 1 2 4 1 1 USI 8 23 17

ATmega2560 256 4 8192 86 16 1.8-5.5 4 2 16 1 4 Yes 16 57 32

ATmega2561 256 4 8192 54 16 1.8-5.5 4 2 9 1 2 Yes 8 48 17

ATmega32 32 1 2048 32 16 2.7-5.5 1 2 4 1 1 Yes 8 19 3

ATmega324P 32 1 2048 32 20 1.8-5.5 1 2 6 1 2 Yes 8 31 32

ATmega325 32 1 2048 54 16 1.8-5.5 1 2 4 1 1 USI 8 23 17

ATmega3250 32 1 2048 69 16 1.8-5.5 1 2 4 1 1 USI 8 32 17

ATmega3250P 32 1 2048 69 20 1.8-5.5 1 2 4 1 1 USI 8 32 17

ATmega325P 32 1 2048 54 20 1.8-5.5 1 2 4 1 1 USI 8 23 17

ATmega329 32 1 2048 54 16 1.8-5.5 1 2 4 1 1 USI 8 25 17

ATmega3290 32 1 2048 69 16 1.8-5.5 1 2 4 1 1 USI 8 25 32

ATmega3290P 32 1 2048 69 20 1.8-5.5 1 2 4 1 1 USI 8 25 32

ATmega329P 32 1 2048 54 20 1.8-5.5 1 2 4 1 1 USI 8 25 17

ATmega406 40 0.512 2048 18 1 4-25 1 1 1 -- -- Yes -- 23 4

ATmega48 4 0.256 512 23 20 1.8-5.5 1 2 6 1 1 Yes 8 26 26

ATmega64 64 2 4096 54 16 2.7-5.5 2 2 8 1 2 Yes 8 34 8

ATmega640 64 4 8192 86 16 1.8-5.5 4 2 16 1 4 Yes 16 57 32

ATmega644 64 2 4096 32 20 1.8-5.5 1 2 6 1 1 Yes 8 31 32

ATmega644P 64 2 4096 32 20 1.8-5.5 1 2 6 1 2 Yes 8 31 32

ATmega645 64 2 4096 54 16 1.8-5.5 1 2 4 1 1 USI 8 23 17

  
P a g e | 223
www.avr.ir
ATmega6450 64 2 4096 69 16 1.8-5.5 1 2 4 1 1 USI 8 32 17

ATmega649 64 2 4096 54 16 1.8-5.5 1 2 4 1 1 USI 8 25 17

ATmega6490 64 2 4096 69 16 1.8-5.5 1 2 4 1 1 USI 8 25 32

ATmega8 8 0.5 1024 23 16 2.7-5.5 1 2 3 1 1 Yes 8 18 2

ATmega8515 8 0.5 512 35 16 2.7-5.5 1 1 3 1 1 -- -- 16 3

ATmega8535 8 0.5 512 32 16 2.7-5.5 1 2 4 1 1 Yes 8 20 3

ATmega88 8 0.5 1024 23 20 1.8-5.5 1 2 6 1 1 Yes 8 26 26

ATtiny11 1 -- -- 6 6 2.7-5.5 -- 1 -- -- -- -- -- 4 1

ATtiny12 1 0.064 -- 6 8 1.8-5.5 -- 1 -- -- -- -- -- 5 1

ATtiny13 1 0.064 64B 6 20 1.8-5.5 -- 1 2 -- -- -- 4 9 6

ATtiny15L 1 0.0625 -- 6 1.6 2.7-5.5 -- 2 1 -- -- -- 4 8 1(+5)

ATtiny2313 2 0.128 128 18 20 1.8-5.5 1 1 4 USI 1 USI -- 8 2

ATtiny24 2 0.128 128 12 20 1.8-5.5 1 1 4 USI -- USI 8 17 12

ATtiny25 2 0.128 128 6 20 1.8-5.5 -- 2 4 USI -- USI 4 15 7

ATtiny26 2 0.125 128 16 16 2.7-5.5 -- 2 2 USI -- USI 11 11 1

ATtiny261 2 0.128 128 16 20 1.8-5.5 1 2 2 Yes -- USI 11 19 2

ATtiny28L 2 -- 32 11 4 1.8-5.5 -- 1 -- -- -- -- -- 5 2(+8)

ATtiny44 4 0.256 256 12 20 1.8-5.5 1 1 4 USI -- USI 8 17 12

ATtiny45 4 0.256 256 6 20 1.8-5.5 -- 2 4 USI -- USI 4 15 7

ATtiny461 4 0.256 256 16 20 1.8-5.5 1 2 2 Yes -- USI 11 19 2

ATtiny84 8 0.512 512 12 20 1.8-5.5 1 1 4 USI -- USI 8 17 12

ATtiny85 8 0.512 512 6 20 1.8-5.5 -- 2 4 USI -- USI 4 15 7

ATtiny861 8 0.512 512 16 20 1.8-5.5 1 2 2 Yes -- USI 11 19 2

  
P a g e | 224
www.avr.ir

AVR ‫ ﺑﺮﺧﻲ ﻗﻄﻌﺎت‬Pinout :4 ‫ﭘﻴﻮﺳﺖ‬

ATmega64,ATmega128 ATmega16, ATmega32

ATmega8 ATiny26

  
‫‪P a g e | 225‬‬
‫‪www.avr.ir‬‬

‫ﭘﻴﻮﺳﺖ ‪ :5‬ﺧﻼﺻﻪ ي رﺟﻴﺴﺘﺮﻫﺎي ‪ATmega16‬‬

‫  ‬