1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79

#include <avr/interrupt.h>
#include <avr/io.h>
#include <stdio.h>

static void avr_init(void);
void uart_putchar(char value);
unsigned char read_adc(unsigned char adc_input);

unsigned char adc_enable;

ISR(SIG_UART_RECV)
{
	unsigned char tmp;
	tmp=UDR;
	if (tmp=='1') adc_enable=1;
	else adc_enable=0;
}

int main(void)
{
	avr_init();
  sei();
	uart_putchar('A');
  for(;;)
  {
    if(adc_enable)
    {
      uart_putchar(read_adc(0x00));
      adc_enable = 0;
    }
  }
  return(0);
}

static void avr_init(void)
{
  PORTB=0b00000000;
  DDRB=0b00001111;

  PORTD=0b00111100;
  DDRD=0b11000011;

  // Baud Rate: 57600
  // Character Size: 8-bit
  // Mode: Asynchronous
  // Parity: Disabled
  // Stop Bit: 1-bit
  // Multi-processor Communication
  UBRRL = 0x0c;
  UBRRH = 0x00;
  UCSRA = 0x01;
  UCSRC = 0x86;
  UCSRB = 0xd8;

  ADMUX=0x60;
  ADCSRA=0xA6;
  SFIOR&=0x0F;
  SFIOR|=0x10;

  return;
}

void uart_putchar(char value)
{
  loop_until_bit_is_set(UCSRA, UDRE);
  UDR = value;
  return;
}

unsigned char read_adc(unsigned char adc_input)
{
  ADMUX=adc_input|0x60;
  // Start the AD conversion
  ADCSRA|=0x40;
  // Wait for the AD conversion to complete
  while ((ADCSRA & 0x10)==0);
  ADCSRA|=0x10;
  return ADCH;
}