A 1. DDRA = 0b ; k = PINB; DDRC = 0xf0; PORTC = 0x0f;

Transcript

1 μ : :

2

3 - - A 1 / μ : : : _ _ : 1. μ μμ μ μ VR μ μ (STK200/CodeVision C) μ μ μμ C. _ _ μ - / μ μ μ STK LED. μ LED LEDn 0 Volt., SWn 5 Volt μ μ. μ ATmega , μ 4 (ports) μ μ A,B,C D. μ 8-bit, bit /. μ 3 : 1. M DDRx ( x=a,b,c,d) μ x ( bit 0) ( bit 1). μ, μ DDRA = 0b ; 4 pin (0..3) (4..7). 2. PINx μ,. μ, μ k = PINB; μ k ( μ unsigned char) μ μ bits ( 1 0) PORTx μ. μ, μ μ PULL UP ( 1 bit ). μ, μ DDRC = 0xf0; PORTC = 0x0f; 4 Pin (0..3) C μ μ PULL UP (4..7) μ

4 H Codevision C μ μ bits ( ) 3. μ μ μ : DDRC.2 = 1; PORTC.2 = 0; if (PINB.3 == 0).. O 2 C O 2 C 0 Volt 3 μ μ μ μ μ μ μ, ( 1 0). μ μ,.. μ C 1, μ μ PORTC = 0b ; {, μ PORTC = 255; {, μ PORTC = 0xFF; { μ STK200 (SW0 - SW7) μ D μ, (LED0 LED7) μ B. _ _ CODEVISION C, μ μμ μ AVR μ E : 1. μ μμ CodeVisionAVR. 2. μ μ μ ( File -> New..). 3. μ, μ project μ. 4. μ μ μ μ μ μ μ (CodeWizard) μ Yes. 5. μ. 6. μ μ : Chip (i) Chip μ ATmega16 (ii) Clock μ 4,0 z (iii) Program Type μ Application μ μ - μ μ μ, -, μ STK

5 7. μ μ File «Generate, Save and Exit». μ μ μ «Micro1» μ μ «lab1». 8., CodeVision μ μ μ μ lab1.c μ μ μ CodeWizard. μμ μ μ, μ μ. μ, μ μ μ μ μμ μ. μ, μ μ, μ μ (μ Ctrl-A) μ delete., μ μμ ( ) #include <mega16.h> void main(void) { DDRB = 0b ; PORTB = 0b ; DDRD = 0b ; PORTD = 0b ; #include μ μ μ, μ μ μμ μ μ (0..7) B μ μ 1, LED μ (0..7) D μ pull-up D while(1) μ ( TRUE) { if (PIND.0 == 0) μ SW0 PORTB.0 = 0; - LED0 else (. SW0 μ ) PORTB.0 = 1; - LED0! ( μμ ) 3 1

6 DOWNLOAD 1. LED μ. 2. Board, μ. 3. μ Project CodeVisionAVR Configure. 4. μ μ μ After Make μ μ Program The Chip OK. 5. μ Project CodeVisionAVR Make., μ - μ compile μμ.,, μ Program., μ μ Make. 6. μ Program μμ μ μ μ. 4 1

7 AVRStudio μ μ μ AVRStudio μ μ μμ. μ μ μ μ, μ compiler. μ μμ ( μ μ / ). Codevision, μ compile μ, μ AVRStudio μ μ μ μμ μ AVR Studio, μ μ. μ μ (, μ Alt+5 μ ). μ μ resources (,, /,.) μ μ μ μ μμ / ( μ ). μ Debug, μ, μ. μ Trace into ( F11) μ μ F11 ( μ μ )., resources μ I/O. μ μ μ μ STK200, μ μ μ "Input Pins" PORTD. μ STK200,, μμ, μ. 5 1

8 _STK 200 / _ 6 1

9 _ - _ μ μ μ. 1 μ LED3 μ SW2. 2 while PORTB = PIND. μμ (μ. 2!). 3 μμ LED0 SW0 SW1. 4 μμ LED SW2 SW3. 5 μμ LED{0,1,2 SW2 LED{5,6,7 SW6. 6 μ μμ μ AVR Studio, μ ( μ μ ) 7 1

10 _ - _ 1 μμ LED3 ( μμ ) μ SW3 ( toggle). μ μ μ if/else. bitwise μ ; #include <mega16.h> #include <delay.h> void main(void) { PORTB = 0xFF; DDRB = 0xFF; PORTD = 0x00; DDRD =0x00; while(1) { if (PIND.3 == 0) { // SW3 PORTB.3 = ~PINB.3; // LED3 delay_ms(50); // μ 50ms, debounce while(pind.3 == 0); // μ μ SW3 delay_ms(50); // μ 50ms, debounce 2 μμ, μ toggle SWn LEDn (n=0..7) #include <mega16.h> #include <delay.h> void main(void) { int keystate; PORTB = 0xFF; DDRB = 0xFF; PORTD = 0x00; DDRD = 0x00; while(1) { keystate = ~PIND; if (keystate) { PORTB = PORTB ^ keystate; delay_ms(50); while(~pind); delay_ms(50); 8 1

11 - - A 2 I/O μ : : : _ μμ interrupts, μ μ interrupts. _ _ 1 μμ μ SW4. μ μ μ ( ) 8-bit μ LED STK200. #include <mega16.h> #include <delay.h> void main(void) { unsigned char count = 0; PORTB = 0xFF; PORTD = 0x00; DDRD = 0x00; while(1) { PORTB = ~count; if (PIND.4 == 0) // SW4 { delay_ms(50); // μ 50ms, debounce while(pind.4 == 0); // μ μ SW4 delay_ms(50); // μ 50ms, debounce count = count ++; 1 2

12 2 μμ, μ μ 10, LED 100ms 60.! μμ, μ μ SW4 LED. #include <mega16.h> #include <delay.h> void main(void) { unsigned char count = 0; unsigned char blink = 0; PORTB = 0xFF; PORTD = 0x00; DDRD = 0x00; while(1) { PORTB = ~count; if (PIND.4 == 0) // SW4 { delay_ms(50); // μ 50ms, debounce while(pind.4 == 0); // μ μ SW4 delay_ms(50); count = count ++; blink = 0; if ((count%10 == 0) && (blink<60)) { delay_ms(100); PORTB = 0xFF; delay_ms(100); blink++; // μ 50ms, debounce 2 2

13 μμ : 3 SW0, μ μ : : LED : LED{0,1,2,3,4,5,6 LED sec μμ μ μ μ flag bit, μ. μμ μ. #include <mega16.h> #include <delay.h> void main(void) { int count = 0; bit flag = 0; PORTB = 0xFF; PORTD = 0x00; DDRD = 0x00; while(1) { if (PIND.4 == 0) // SW3 { delay_ms(50); // μ 50ms, debounce while(pind.4 == 0); // μ μ SW4 delay_ms(50); // μ 50ms, debounce flag = ~flag; if (flag == 1) { PORTB.7 =!PORTB.7; delay_ms(250); else PORTB = PIND; 3 2

14 4 2

15 - - H 3 μ : : : _ : 1. μ, μ μ μ μ μ μ. 2. μ μ CodeVision C compiler. _ μ μ μ, μ μ ( ). μ μ μ, μ μ μ μ μ μ. μ μ - (P1 P2), μ. SAW ON OFF POWER SERVICE P1 P2 RET μ 1 μ μ μ μ ( μ 1). ( ) ( FF). μ μ (POWER). 1 3

16 , μ P1 P2 μ μ. : i) μ μ - (SAW) 7sec, μ μ ( μ 1) μμ. ii) μ μ - (RET) 3.5sec, μ. 1000, μ μ μ μ μ μ (SERVICE). μ μ μ μ μ / μ ATmega16. μ μ μ 2, μ μ μ μ ( μ, pin B7 7 B). PIN PIN ON D0 μ SAW B0 OFF D7 μ RET B1 P1 D3 POWER B7 P2 D4 SERVICE B6 μ 2 μ, μ μ μ ( ' μ LED STK200), 0 μ, 1. μ μμ μ 0 Volt ( 0). μ (SAW RET) μ 0, μ

17 _ A _ 1 μμ μ, - μ. μ LED STK200, μ μ μ CodeVision C ( help files) μ,., ( ): #include <mega16.h> #include <delay.h> #define MAXCYCLES 1000 #define ON 0 #define OFF 1 void main(void) { char pow; unsigned int cyclecount=0; PORTB = 0xFF; DDRB = 0xFF; PORTD = 0xFF; DDRD = 0x00; // LED outputs on STK200 // BUTTON inputs on STK200 while (cyclecount<maxcycles) { if ( PIND.0 == ON ) { pow = ON; PORTB.7 = ON; if ( ) { if ( ) { PORTB.7 = PORTB.6 = pow = while(1); 3 3

18 2 μμ μ μ μ μ SRAM, μ μ μ μ μ. 3 M μ μ, μ μμ, μ EEPROM, μ μ ( μ manual CodeVision). 4 μ, μ (μ μ / μμ ), μ μ μ. 4 3

19 - - A 4 E INTERRUPTS μ : : : _ : 1. μ μ μ μ AVR μ μμ μ CodeVision C compiler. 2. μ μ μμ ATmega16. _ O (interrupts) μ μμ μ - μ. O μ μ μ, μ μ. M μ interrupt ( μ μ ), CPU μμ. K μ (interrupt service routine - ISR), μμ μ μ interrupt. (, interrupts.) μ ISR. M ISR, μμ μ interrupt. E μ, μ. μμ μ μ μ μ μ. H interrupts μ : 1. μ μ μ μ μ μ μ μ bits μ. 2. μ μ μ, μ μ μ. Status Register SREG Bit I T H S V N Z C Read/Write R/W R/W R/W R/W R/W R/W R/W R/W Initial Value O SREG (Status register) (μ 1) (μ 0) μ μ, bit 7. M (SEI CLI) μ μ μ μ Global Interrupt Enable bit ( 1 SREG 1 4

20 0 ). A μ μ Assembly, μμ μ μ #asm. O ATmega16 μμ (INT0, INT1 INT2) 16, 17, 3 ( μ ). μ, (μ DDR). μ, STK200 B μ LED, INT2 μ, μμ μ μ μ interrupts INT0 INT1. A mega16 interrupts μ : General Interrupt Control Register GICR Bit INT1 INT0 INT IVSEL IVCE Read/Write R/W R/W R/W R R R R/W R/W Initial Value GICR μ μ μ μμ A mega16 1 μ 0. O, μ μ μ interrupt, μ bits MCUCSR MCUCR. MCU Control Register MCUCR Bit SM2 SE SM1 SM0 ISC11 ISC10 ISC01 ISC00 MCUCR Read/Write R/W R/W R/W R/W R/W R/W R/W R/W Initial Value T bits 0-3 μ interrupts INT0 INT1, μ μ, : Interrupt 0 Sense Control ISC01 ISC μ μ pin INT0 μ 0 1 pin INT0 μ 1 0 μ ( μ μ ) pin INT0 μ 1 1 μ ( μ μ ) pin INT0 μ Interrupt 1 Sense Control ISC11 ISC μ μ Pin INT1 μ 0 1 Pin INT1 μ 1 0 μ ( μ μ ) Pin INT1 μ 1 1 μ ( μ μ ) pin INT1 μ GICR 2 4

21 - I_ 1 μμ project. μμ μ, μ SW2. μ μμ, μ μ. #include <mega16.h> unsigned char count=0; interrupt [EXT_INT0] void ext_int0_isr(void) { count++; PORTB = ~count; void main(void) { PORTB = 0xFF; DDRB = 0xFF; PORTD = 0xFF; DDRD = 0x00; GICR = 0b ; MCUCR = 0b ; #asm("sei") while (1); 2 μ μμ AVR Studio, μ μ μ. MCUCR=0x02; 3 μμ LED μ μ. μ MCUCR=0x03; μ : MCUCR=0x02; 4 μμ LED μ μ 1 ( SW3). μ MCUCR=0x03; μ : MCUCR=0x02; 3 4

22 μμ μ interrupt INT1 : 5 μ INT1, μ μ : : LED{0,1,2,3 μμ LED{4,5,6,7 : LED{0,1,2,3,4,5,6 LED sec μμ μ μ μ flag bit, μ. #include <mega16.h> #include <delay.h> bit flag; interrupt [EXT_INT1] void ext_int1_isr(void) { flag =!flag; if (flag) PORTB = 0xFF; // toggle state flag void main(void) { PORTB = 0xFF; // PORTB is output DDRB = 0xFF; // LEDS switched off DDRD = 0x00; // enable INT1 GICR = 0x80; // PORTD is input MCUCR = 0x08; // INT1 request 1->0 #asm("sei") while (1) { if (flag) { PORTB.7 =!PINB.7; delay_ms(250); Else { PORTB = 0xF0; 4 4

23 - II_ 6 N μμ, interrupt 0 1: A μ μ μμ LED, μ μ INT0 INT1, μ :, μμ LED LED0 ( LED ). μ μ μ μ INT0, μμ LED μ μ. μμ LED LED7, LED0. μ μ μ μ INT1, μμ LED μ μ ( ) LED2. #include <mega16.h> unsigned char LEDpos=0x01; interrupt [EXT_INT0] void ext_int0_isr(void) { if (LEDpos == 0x80) LEDpos = 0x01; else LEDpos = LEDpos<<1; PORT = ~LEDpos; interrupt [EXT_INT1] void ext_int1_isr(void) { LEDpos = 0x04; PORT = ~LEDpos; void main(void) { PORTD=0xFF; DDRD=0x00; DDRB = 0xFF; PORT = ~LEDpos; MCUCR = 0b ; GICR = 0b ; #asm("sei") // Global enable interrupts while (1); 7 N μμ, μ μ μμ LED 0 μ μ. MCUCR = 0b ; 5 4

24 8 N / μμ, μ, μ INT0, : μ μ μ μ INT1, μμ LED μ μ. μμ LED LED0, LED7. SW0, μμ LED μ μ ( ) LED2. #include <mega16.h> unsigned char LEDpos = 0x01; interrupt [EXT_INT0] void ext_int0_isr(void) { if (LEDpos == 0x80) LEDpos = 0x01; else LEDpos = LEDpos<<1; PORT = ~LEDpos; interrupt [EXT_INT1] void ext_int1_isr(void) { if (LEDpos == 0x01) LEDpos = 0x80; else LEDpos = LEDpos>>1; PORT = ~LEDpos; void main(void) { PORTD=0xFF; DDRD=0x00; PORT = ~LEDpos; DDRB=0xFF; MCUCR = 0b ; GICR = 0b ; #asm("sei") // Global enable interrupts while (1) { if (!PIND.0) { LEDpos = 0x04; PORTB = ~LEDpos; 6 4

25 - - H 5 TIMER0 μ : : : _ : 1. Timer0 μ Tmega16 2. A μ μμ μ μ (ISRs). _ TIMER0 O ATmega16 3 / μ, μ μ Timer0, Timer1 Timer2. Timer0 μ 8-bit ( 0x00 0xFF). H μ μ - μ, μ ( ) μ TCNT0. O Timer0, μ μ : Timer/Counter0 Control Register TCCR0 Bit FOC0 WGM00 COM01 COM00 WGM01 CS02 CS01 CS00 Read/Write W R/W R/W R/W R/W R/W R/W R/W Initial Value T bits 3 6 (mode), : TCCR0 Waveform generation mode bits WGM01 WGM μ E μ (Phase Correct PWM) 1 0 M μ T (CTC - Clear Timer on Compare) 1 1 μ E μ (PWM) (fast PWM) T bits 0:2 μ μ μ Timer0, μ : Clock Selection Bits CS02 CS01 CS00 μ A M System Clock (CK) System Clock, prescaler N = 8 (CK/8) System Clock, prescaler N = 64 (CK/64) System Clock, prescaler N = 256 (CK/256) System Clock, prescaler N = 1024 (CK/1024) E μ ( μ μ ) E μ ( μ μ ) 1 5

26 TIMER0 μ TCCR0, μ μ μ f 0 = F CK/N μ 0 μ 1 μ 0xFF. μ μ 0xFF, μ μ, μ TOV0 TIFR 1 μ μ 0 ( ). E interrupt μ, ISR Timer0, μ TOV0 μ 0. H μ μ μ μ, μ TCNT0. μ μ μ μ μ CS00:CS20 = 0 TCCR0. Timer0 μ TIMSK TIFR. Timer/Counter Interrupt Mask Register TIMSK Bit OCIE2 TOIE2 TICIE1 OCIE1A OCIE1B TOIE1 OCIE0 TOIE0 Read/Write R/W R/W R/W R/W R/W R/W R/W R/W Initial Value TIMSK Timer/Counter Interrupt Flag Register TIFR Bit OCF2 TOV2 ICF1 OCF1A OCF1B TOV1 OCF0 TOV0 Read/Write R/W R/W R/W R/W R/W R/W R/W R/W Initial Value bits 0 1 TIMS (μ 1) Y M (Timer0 Overflow 0) T (Timer0 Output Compare Match OCIE0). μ μ (μ 1) flag bits TOV0 OCF0 TIFR. TIFR M (Timer0 Overflow) μ 0xFF 0x00 μ TOV0 1. E bits TOIE0 ( Timer0 Overflow) GIE ( ) 1, ISR, μ μ TOV0 0 μ. _ 1 μ μ μ, STK200, μ F CK = 4,00 MHz, μ, μ μ μ. CS02 CS01 CS00 Prescaler Timer0 μ μ Timer0 μ Timer0 N f0 = FCK/N t0 = 1/F0 T0 = 256/F ,00 MHz 0.25 μsec 64 μsec khz 2 μsec 512 μsec ,5 khz 16 μsec 4,096 msec ,625 khz 64 μsec 16,384 msec ,9063 khz 256 μsec 65,536 msec 2 μ, μ : ; μ F CK = 4 MHz Timer0 μ prescaler = 8 f 0 = F CK /8 μ μ TCNT0 t 0 = 1/F 0 μ 250 TCNT0 T = 250t 0 = 500μsec 2 5

27 3 μμ project ( CodeWizard). μμ μ, μ μμ, μ μ. #include <mega16.h> unsigned char count = 0; unsigned int ovf_count = 0; interrupt [TIM0_OVF] void timer0_ovf_isr(void) { TCNT0=0x06; ovf_count++; if (ovf_count == 2000) { ovf_count = 0; count++; PORTB = ~count; void main(void) { PORTB = 0xFF; DDRB = 0xFF; PORTD = 0xFF; DDRD = 0x00; TCNT0 = 0x06; TIMSK = 0x01; TCCR0 = 0x02; #asm("sei") while (1); 4 μμ μ LED 1. μ... if (++ovf_count == 250)... TCCR0 = 0x03;... 5 μμ (3) μ, μ prescaler = 64. μ CPU ; μ... unsigned long int ovf_count = 0;... if (++ovf_count == 2000*60)

28 6 μμ Timer0 INT0, : 1. μ μμ : : LED, Timer0 μ. : LED7 2 sec, μ Timer0. 2. μ INT0, μ μ ( ) ( ). μμ μ ( ). μμ μ μ μ flag bit, μ. #include <mega16.h> unsigned int ovf_count; bit flag; interrupt [TIM0_OVF] void timer0_ovf_isr(void) { TCNT0 = 0x06; if (++ovf_count==250*2) { PORT.7 = ~P.7; ovf_count = 0; interrupt [EXT_INT0] void ext_int0_isr(void) { flag = ~flag; if (flag) { PORT.7 = ~P.7; TCNT0 = 0x06; TCCR0 = 0x03; ovf_count = 0; else { TCCR0 = 0x00; PORT.7 = 1; void main(void) { // Port initializations PORT = 0xFF; DDR = 0xFF; PORTD = 0xFF; DDRC = 0x00; GICR = 0x40; MCUCR = 0x02; MCUCSR = 0x00; GIFR = 0x40; TCCR0 = 0x00; TCNT0 = 0x00; TIMSK = 0x01; flag = 0; #asm("sei") while (1); 4 5

29 - - A H 6 O TIMER1 μ : : : _ : 1. Timer1 μ Tmega A μ μμ μ μ (ISRs). _ TIMER1 O ATmega16 3 / μ, μ μ Timer0, Timer1 Timer2. Timer1 μ 16-bit ( 0x00 0xFFFF) μ - μ, μ ( ) μ TCNT1. O Timer1, μ μ : Timer/Counter1 Control Register B TCCR1B Bit ICNC1 ICES1 -- WGM13 WGM12 CS12 CS11 CS10 Read/Write W R/W R R/W R/W R/W R/W R/W Initial Value T bits 3 4 (mode), : TCCR1B Waveform generation mode bits WGM13 WGM CTC-OCR1A: M μ T ( μ OCR1A) 1 0 PWM & 1 1 CTC-ICR1: M μ T ( μ ICR1) T bits 0:2 μ μ Timer1, μ : Clock Selection Bits CS12 CS11 CS10 μ A M System Clock (CK) System Clock, prescaler N = 8 (CK/8) System Clock, prescaler N = 64 (CK/64) System Clock, prescaler N = 256 (CK/256) System Clock, prescaler N = 1024 (CK/1024) E μ ( μ μ ) E μ ( μ μ ) 1 6

30 TOY TIMER1 μ TCCR1, μ μ μ f 1 = F CK/N μ 0 μ 1 μ 0xFFFF (65535). H μ μ μ μ μ 16-bit TCNT1. μ μ, μ μ μ μ 0x0000 ( ) interrupt μ, ISR Timer1. CTC-OCR1A TOY TIMER1 CTC-OCR1A μ μ 0 μ μ 16-bit OCR1A. μ, μ 0x0000 interrupt μ, ISR μ OCR1A Timer1. Timer1 μ TIMSK. Timer/Counter Interrupt Mask Register TIMSK Bit OCIE2 TOIE2 TICIE1 OCIE1A OCIE1B TOIE1 OCIE0 TOIE0 Read/Write R/W R/W R/W R/W R/W R/W R/W R/W Initial Value TIMSK bits 2 4 TIMS (μ 1) Y M (Timer1 Overflow 1), T A (Timer1 Output Compare Match OCIE1A) T B (OCIE1B). Y M (Timer1 Overflow) M Timer1 0xFFFF 0x0000 bit 1 TIMSK 1, μ, ISR μ μ μ. A (Timer1 Output Compare) TCNT1 μ OCR1A bit OCIE1A TIMSK 1, μ, ISR μ μ μ. _ 1 μ, μ : ( μ μ!) ; μ F CK = 4 MHz Timer1 μ prescaler = 8 f 1 = F CK/ = 500 khz μ 1 TCNT1 t 1 = 1/f 1 = 2 μsec μ Timer1 T 1 = * t 1= 0,1311 sec 2 μ μ μ, 0,1 sec, μ prescaler N = 8. Q = 0.1/t 1=

31 3 μμ μ μ μ μμ LED, μ, :, μμ LED LED0 ( LED ) 0,1 sec μμ LED μ μ. μμ LED LED7, LED0. μ μ μ Timer1 μ prescaler N = 8 μ M μ T μ μ OCR1A (CTC-OCR1A). μ : interrupt CTC-OCR1A : interrupt [TIM1_COMPA] void timer1_compa_isr(void) #include <mega16.h> unsigned char count = 1; interrupt [TIM1_COMPA] void timer1_compa_isr(void) { if (count==128) count = 1; else count = count<<1; PORTB = ~count; void main(void) { PORTB = ~count; // initially LED0 is on DDRB = 0xFF; TCCR1B = 0x0A; // prescaler = 8, CTC-OCR1A mode OCR1A = 50000; // load OCR1A value for 0.1 sec TCNT1 = 0; // initialize TCNT1 TIMSK = 0x10; // enable Timer1 overflow interrupt #asm("sei") while (1); 4 μ μμ μ o μ μ μ μ LED μ, 0 6 sec, μ μ 0.1 sec. μ μ interrupt 0 1 ( μ ). μ μ 0 sec, μ LED μ, μ μ μ. 3 6

32 #include <mega16.h> unsigned char count = 1; unsigned char N = 1; unsigned ovf_count = 0; interrupt [EXT_INT0] void ext_int0_isr(void) { if (N<60) N++; if (N==1) TCCR1B = TCCR1B 0x02; ovf_count = 0; TCNT1 = 0; interrupt [EXT_INT1] void ext_int1_isr(void) { if (N>0) N--; if (N==0) TCCR1B = TCCR1B & 0b ; ovf_count = 0; TCNT1 = 0; interrupt [TIM1_COMPA] void timer1_compa_isr(void) { if (++ovf_count == N) { if (count==128) count = 1; else count = count<<1; PORTB = ~count; ovf_count = 0; void main(void) { PORTB = ~count; // initially LED0 is on DDRB = 0xFF; TCCR1B = 0x0A; // prescaler = 8, CTC-OCR1A mode OCR1A = 50000; // load OCR1A value for 0.1 sec TCNT1 = 0; // initialize TCNT1 TIMSK = 0x10; // enable Timer1 overflow interrupt GICR = 0xC0; MCUCR = 0x0F; #asm("sei") while (1); 4 6

33 - - A H 7 μ : : : _ : 1. μ μ μ. 2. μ analog to digital (ADC) μ Tmega16. _ ANALOG TO DIGITAL (ADC) H μ ADC ATmega16 μ 10-bit. M μ μ 8 μ μ - (single-ended) μ. A - A μ μ μ GND. O ADC AVR μ μ (successive approximation ADC) μ μ. μ μ μ 10-bit ADC, μ μ 50 khz < F ADC < 200 khz prescaler μ μ ADC μ. μ μ μ ADC, μ : (i) μ μ F CK 200 khz, (ii) μ μ μ μ μ (iii) μ bits ADPS2:0 ADCSRA. ADC bit DEN ADCSRA ADC μ 1. H μ - μ 1 bit ADSC ADCSRA, 0 μ μ μ., bit ADATE ADCSRA 1, μ μ μ μ μ μ, bits ADTS2:0 SFIOR. M μ 13 μ ADC μ μ μ 1 bit ADIF ADCSRA. interrupt ( 1 bit ADIE ADCSRA), ISR μ. T μ μ μ μ ADCW CodeVision C ADCW = 2 10 VIN /VREF V IN μ V REF. T ADCW=0x000 μ (GND) ADCW=0x3FF V REF μ 1 LSB. 1 7

34 ADC Multiplexer Selection Register ADMUX Bit REFS1 REFS0 ADLAR MUX4 MUX3 MUX2 MUX1 MUX0 Read/Write W R/W R R/W R/W R/W R/W R/W Initial Value ADMUX μ n (0 <= n <= 7) bits MUX0:2 μ ( n ). bits REFS1 REFS0 V REF : REFS1 REFS0 0 0 μ AREF 0 1 μ AVCC μ AREF 1 0 ( μ ) 1 1 E 2.56 V μ AREF ADC Control and Status Register ADCSRA Bit ADEN ADSC ADATE ADIF ADIE ADPS2 ADPS1 ADPS0 Read/Write R/W R/W R/W R/W R/W R/W R/W R/W Initial Value ADCSRA bit 7 ( DEN) ADC μ 1. H μ 1 bit 6 (ADSC). interrupt μ μ 1 bit 3 (ADIE) μ - bit 4 (ADIF). μ μ ( 10-bit) μ CodeVision C μ ADCW. μ μ μ μ 0 bit 5 (ADATE). bits 0 2 μ prescaler μ ADC, : ADPS2 ADPS1 ADPS0 Prescaler N _ 1 μ μ, μ : μ μ prescaler ADC μ 10-bit μ ADC μ μ F CK = 4.00 MHz = 32 (4000/200 = 20.0) F ADC = F CK/N = 125 khz T ADC = 13/F CK = 104 μsec 10-bit μ V REF=5Volt V 0= V REF/1024 = 5/1024 = 4.88 mvolt 2 7

35 2 N μμ, μ μ (0-5 Volt). #include <mega16.h> interrupt [ADC_INT] void adc_isr(void) { unsigned char i, outb=0; unsigned int lim, adc_data; adc_data = ADCW; ADCSRA = 0x40; // Read ADC Word // ADC Start conversion lim = 64; for (i=7; i>=0; i--) { if (adc_data>lim) outb = outb (1<<i); else break; lim = lim+128; PORTB = ~outb; void main(void) { PORTB = 0xFF; DDRB = 0xFF; PORTD = 0xFF; DDRD = 0x00; ACSR = 0x80; SFIOR = 0x00; ADMUX = 0x47; ADCSRA = 0x8D; ADCSRA = 0x40; // Analog comparator disable // ADC Voltage Reference: AVCC pin // select channel 7 (PORTA.7) // ADC Start conversion #asm("sei") // Global interrupt enable while (1); 3 VCC 5Volt, μ μ 8- μ μ ; μ 5/8 Volt = 0.625Volt 4 N o μ μ μ μμ. μ μ μ ADC μ μ μ, μ μ μμ Fs = 1/T ADC= ksps (kilo samples per sec) 3 7

36 5 μμ μ μ μ ADC μ 8 LED STK200. μ μ μ 10-bit, 8 μ bits. // ADC interrupt service routine interrupt [ADC_INT] void adc_isr(void) { unsigned char adc_data8; ADCSRA = 0x40; adc_data8 = (ADCW >> 2); PORTB = ~adc_data8; // μ // μ 8 μ 6 μ ; 5/2 8 = mvolt 7 μμ LEDs 10 μ -μ ADC, μ μ 10 μ ( μ 10-bit μ μ ). #include <mega16.h> #define MAXN 10 unsigned char n = 0; unsigned int sumadc = 0; // index variable // 1023*10 fits in 16 bits! // ADC interrupt service routine interrupt [ADC_INT] void adc_isr(void) { unsigned char adc_data8; sumadc += ADCW; ADCSRA = 0x40; // start new conversion if (++n == MAXN) { adc_data8 = ((unsigned int)(sumadc/maxn)) >> 2; PORTB = ~adc_data8; n = 0; sumadc = 0; 4 7