The Analog-to-Digital Converter (ADC)

const uint8_t POT_PIN = A0;

void setup() {
  DDRB = 0x3F;                                  // pins 8...13: the 6-LED bar
}

void loop() {
  uint16_t raw = analogRead(POT_PIN);           // 0...1023
  float voltage = raw * 5.0 / 1024.0;           // convert back to volts
  uint8_t percent = map(raw, 0, 1023, 0, 100);

  // We do not have the serial monitor yet (lab 6). We show the result in
  // binary, on the 6 most significant bits: shifting by 4 leaves 0...63.
  PORTB = raw >> 4;

  delay(200);
}

void adcInit() {
  ADMUX  = (1 << REFS0);                                  // AVCC reference (5 V)
  ADCSRA = (1 << ADEN)                                    // turn on the converter
         | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);    // prescaler 128 -> 125 kHz
}

uint16_t adcRead(uint8_t channel) {
  ADMUX = (ADMUX & 0xF0) | (channel & 0x0F);   // select the channel, keep the reference
  ADCSRA |= (1 << ADSC);                       // start the conversion
  while (ADCSRA & (1 << ADSC));                // wait for it to finish
  return ADC;                                  // read the 10-bit result
}

void setup() {
  DDRB = 0x3F;             // 6-LED bar on pins 8...13
  adcInit();
  adcRead(0);              // the first conversion takes longer - discard it
}

void loop() {
  PORTB = adcRead(0) >> 4;   // the 6 most significant bits, on the bar
  delay(100);
}

const uint8_t PIN = A0;
const uint8_t N   = 16;          // a power of 2 -> division becomes a shift

uint16_t averagedRead() {
  uint32_t sum = 0;
  for (uint8_t i = 0; i < N; i++) sum += analogRead(PIN);
  return sum / N;
}

void setup() {
  DDRB = 0x3F;                   // bar on pins 8...13 = the RAW value
  DDRD |= 0b11111100;            // pins 2...7        = the FILTERED value
}

void loop() {
  static uint16_t filtered = 0;

  uint16_t raw      = analogRead(PIN);
  uint16_t averaged = averagedRead();

  // exponential filter, integers only
  filtered = filtered + ((int16_t)(averaged - filtered) / 8);

  // Compare the two bars: the raw one jitters, the filtered one moves smoothly.
  PORTB = raw      >> 4;
  PORTD = (PORTD & 0x03) | ((filtered >> 4) << 2);

  delay(50);
}

const uint8_t SENSOR_PIN = A1;

void setup() {
  DDRB = 0x3F;                   // thermometer bar on pins 8...13
  DDRD |= (1 << PD7);            // alarm LED on pin 7
  analogReference(INTERNAL);     // internal 1.1 V reference
  delay(10);
  analogRead(SENSOR_PIN);        // discard the first reading after the change
}

void loop() {
  uint32_t sum = 0;
  for (uint8_t i = 0; i < 16; i++) { sum += analogRead(SENSOR_PIN); delay(2); }
  uint16_t raw = sum / 16;

  // integer version: temperature in tenths of a degree
  // (1100 mV / 1024 steps, and the LM35 gives 10 mV per degree -> mV = tenths of a degree)
  int16_t tempTenths = (int32_t)raw * 1100 / 1024;
  int16_t tempC = tempTenths / 10;

  // bar thermometer: one LED for every 10 degrees
  uint8_t nrLeds = tempC / 10;
  if (nrLeds > 6) nrLeds = 6;
  PORTB = (1 << nrLeds) - 1;

  if (tempC > 40) PORTD |=  (1 << PD7);
  else            PORTD &= ~(1 << PD7);

  delay(500);
}

const uint8_t LDR_PIN = A0;
const uint8_t LED_PIN = 9;        // PWM pin
const uint16_t LOWER_THRESHOLD = 300;
const uint16_t UPPER_THRESHOLD = 700;

void setup() {
  pinMode(LED_PIN, OUTPUT);
  DDRB |= 0b00111101;             // status bar (except pin 9, used by PWM)
}

void loop() {
  uint16_t light = analogRead(LDR_PIN);

  // the darker it is, the brighter the LED shines
  uint8_t duty = map(constrain(light, LOWER_THRESHOLD, UPPER_THRESHOLD),
                     LOWER_THRESHOLD, UPPER_THRESHOLD, 255, 0);
  analogWrite(LED_PIN, duty);

  delay(100);
}