ADC -> PWM

adc_to_pwm.c

#include <stdint.h> 
#include <avr/interrupt.h> 
#include <avr/io.h> 
#include <avr/pgmspace.h>

// Uncomment to enable debugging messages and values
#define DEBUG

uint16_t adc_readings[8];
uint8_t digital_output = 11; // (PCINT22/OC0A/AIN0)PD6, Arduino Digital Pin 11

uint16_t sample_0;
uint16_t sample_1;
uint16_t sinewave_length = 501;

uint32_t sinewave_data[] PROGMEM = { 0x80, 0x81, 0x83, 0x84, 0x86, 0x88, 0x89, 0x8B, 0x8C, 0x8E, 0x8F, 0x91, 0x93, 0x94, 0x96, 0x97, 0x99, 0x9B, 0x9C, 0x9E, 0x9F, 0xA1, 0xA2, 0xA4, 0xA5, 0xA7, 0xA8, 0xAA, 0xAB, 0xAD, 0xAE, 0xB0, 0xB1, 0xB3, 0xB4, 0xB6, 0xB7, 0xB9, 0xBA, 0xBC, 0xBD, 0xBE, 0xC0, 0xC1, 0xC2, 0xC4, 0xC5, 0xC7, 0xC8, 0xC9, 0xCA, 0xCC, 0xCD, 0xCE, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEE, 0xEF, 0xF0, 0xF1, 0xF1, 0xF2, 0xF3, 0xF4, 0xF4, 0xF5, 0xF5, 0xF6, 0xF7, 0xF7, 0xF8, 0xF8, 0xF9, 0xF9, 0xFA, 0xFA, 0xFB, 0xFB, 0xFB, 0xFC, 0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFD, 0xFD, 0xFD, 0xFC, 0xFC, 0xFC, 0xFB, 0xFB, 0xFB, 0xFA, 0xFA, 0xF9, 0xF9, 0xF8, 0xF8, 0xF7, 0xF7, 0xF6, 0xF5, 0xF5, 0xF4, 0xF4, 0xF3, 0xF2, 0xF1, 0xF1, 0xF0, 0xEF, 0xEE, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE9, 0xE8, 0xE7, 0xE6, 0xE5, 0xE4, 0xE3, 0xE2, 0xE1, 0xE0, 0xDF, 0xDE, 0xDC, 0xDB, 0xDA, 0xD9, 0xD8, 0xD7, 0xD6, 0xD4, 0xD3, 0xD2, 0xD1, 0xD0, 0xCE, 0xCD, 0xCC, 0xCA, 0xC9, 0xC8, 0xC7, 0xC5, 0xC4, 0xC2, 0xC1, 0xC0, 0xBE, 0xBD, 0xBC, 0xBA, 0xB9, 0xB7, 0xB6, 0xB4, 0xB3, 0xB1, 0xB0, 0xAE, 0xAD, 0xAB, 0xAA, 0xA8, 0xA7, 0xA5, 0xA4, 0xA2, 0xA1, 0x9F, 0x9E, 0x9C, 0x9B, 0x99, 0x97, 0x96, 0x94, 0x93, 0x91, 0x8F, 0x8E, 0x8C, 0x8B, 0x89, 0x88, 0x86, 0x84, 0x83, 0x81, 0x80, 0x7E, 0x7C, 0x7B, 0x79, 0x77, 0x76, 0x74, 0x73, 0x71, 0x70, 0x6E, 0x6C, 0x6B, 0x69, 0x68, 0x66, 0x64, 0x63, 0x61, 0x60, 0x5E, 0x5D, 0x5B, 0x5A, 0x58, 0x57, 0x55, 0x54, 0x52, 0x51, 0x4F, 0x4E, 0x4C, 0x4B, 0x49, 0x48, 0x46, 0x45, 0x43, 0x42, 0x41, 0x3F, 0x3E, 0x3D, 0x3B, 0x3A, 0x38, 0x37, 0x36, 0x35, 0x33, 0x32, 0x31, 0x2F, 0x2E, 0x2D, 0x2C, 0x2B, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x21, 0x20, 0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x11, 0x10, 0x0F, 0x0E, 0x0E, 0x0D, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A, 0x09, 0x08, 0x08, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x0A, 0x0A, 0x0B, 0x0B, 0x0C, 0x0D, 0x0E, 0x0E, 0x0F, 0x10, 0x11, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x31, 0x32, 0x33, 0x35, 0x36, 0x37, 0x38, 0x3A, 0x3B, 0x3D, 0x3E, 0x3F, 0x41, 0x42, 0x43, 0x45, 0x46, 0x48, 0x49, 0x4B, 0x4C, 0x4E, 0x4F, 0x51, 0x52, 0x54, 0x55, 0x57, 0x58, 0x5A, 0x5B, 0x5D, 0x5E, 0x60, 0x61, 0x63, 0x64, 0x66, 0x68, 0x69, 0x6B, 0x6C, 0x6E, 0x70, 0x71, 0x73, 0x74, 0x76, 0x77, 0x79, 0x7B, 0x7C, 0x7E, 0x7F };

// Interrupt service routine called to grab ADC readings
ISR(TIMER0_COMPA_vect)
{
    // Start ADC conversion
    ADCSRA |= (1 << ADSC);
}

// Interrupt service routine called to generate PWM compare values
ISR(TIMER1_COMPA_vect)
{
    uint32_t sensor_value_0 = adc_readings[0];
    uint32_t sample_value_0 = pgm_read_byte(&sinewave_data[sample_0]);
    uint32_t sine_0 = (sample_value_0 * sensor_value_0) >> 10;

    uint32_t sensor_value_1 = 1024;
    uint32_t sample_value_1 = pgm_read_byte(&sinewave_data[sample_1]);
    uint32_t sine_1 = (sample_value_1 * sensor_value_1) >> 10;

    OCR2A = (sine_0 + sine_1) >> 1;

    sample_0 += 2;
    sample_1 += 3;

    if (sample_0 >= sinewave_length) {
        sample_0 = 0;
    }

    if (sample_1 >= sinewave_length) {
        sample_1 = 0;
    }
} // END - Interrupt service routine called to generate PWM compare values

// ADC Conversion Complete interrupt service routine
ISR(ADC_vect)
{
    static uint8_t firstTime = 1;
    static uint8_t low_val, high_val;
    uint8_t current_pin;

    low_val = ADCL;
    high_val = ADCH;
   
    if (firstTime == 1) {
        firstTime = 0;

    } else {
        // Get current reading from MUX
        current_pin = (ADMUX & 0xF);
        // Store reading in readings array
        adc_readings[current_pin] = (high_val << 8) | low_val;
        // Clear MUX bits
        ADMUX &= 0xF0;

        // Unless we're at the top pin, increment the MUX unit, otherwise leave it cleared at 0
        if (current_pin < 7) {
            ADMUX |= (current_pin + 1);
        }

#ifdef DEBUG
        // Toggle LED pin
        PORTD ^= (1 << 7);
#endif

    }
} // END - ADC Conversion Complete interrupt service routine


void setup()
{
    // Setup digital_output for PWM output
    DDRD |= _BV(6);

    // Clear ADC reading array
    memset(adc_readings, 0, sizeof(adc_readings));

    // Disable global interrupts
    cli();

#ifdef DEBUG
    // Setup serial port for printing debug messages
    Serial.begin(9600);

    // Setup LED pin (PD7, Arduino Digital Pin 7) for testing
    DDRD |= _BV(7);
    // Set LED pin high
    PORTD |= _BV(7);
#endif

/***************************************************************************
 ** Timer/Counter0 Configuration (used for triggering ADC)           **
 ***************************************************************************/

    // Setup Timer/Counter0 Control Registers (TCCR0) with the following options:
    //    Timer/Counter Mode of Operation  |  CTC
    //                                TOP  |  OCRA
    //                 Update of OCR1x at  |  Immediate
    //                   TOV1 Flag Set on  |  MAX
    TCCR0A = (TCCR0A & ~_BV(WGM00)) | _BV(WGM01);
    TCCR0B &= ~_BV(WGM02);

    // Setup clock prescaler for TCCR0 as clk_IO/1024
    TCCR0B = (TCCR0B & ~_BV(CS01)) | _BV(CS02) | _BV(CS00);

    // Set compare value (OCR0A) to value equivalent to:
    //    C      = Compare value
    //    F_CPU  = Core clock rate  
    //    F_S    = Desired ADC sampling rate (in Hertz)
    //    PS     = Prescaler value
    //    N      = Number of ADC channels
    //    C = F_CPU / (F_S * N * PS)
    OCR0A = F_CPU / (50 * 8 * 1024); // 50Hz x 8 channels x 1024 prescaler

    // Enable Timer/Counter0 Output Compare A Match Interrupt
    TIMSK0 |= _BV(OCIE0A);

/***************************************************************************
 ** END - Timer/Counter0 Configuration                                    **
 ***************************************************************************/

/***************************************************************************
 ** Timer/Counter1 Configuration (used for setting PWM compare values)    **
 ***************************************************************************/

    // Setup Timer/Counter1 Control Registers (TCCR1) with the following options:
    //    Timer/Counter Mode of Operation  |  CTC
    //                                TOP  |  OCR1A
    //                 Update of OCR1x at  |  Immediate
    //                   TOV1 Flag Set on  |  MAX
    TCCR1A &= ~(_BV(WGM11) | _BV(WGM10)); // Clear bits WGM11 and WGM10 in TCCR1A
    TCCR1B = (TCCR1B & ~_BV(WGM13)) | _BV(WGM12); // Clear bit WGM13 and set bit WGM12 in TCCR1B

    // Setup clock prescaler for TCCR1 as clk_IO/8
    TCCR1B = (TCCR1B & ~(_BV(CS12) | _BV(CS10))) | _BV(CS11);

    // Set compare value (OCR1A) to value equivalent to:
    //    C     = Compare value
    //    PS    = Prescaler value
    //    N     = Number of samples in wavetable read by interrupt routine
    //    B     = Base frequency gained by reading one sample from wavetable per call of interrupt routine
    /     F_CPU = Core clock frequency
    //    C = F_CPU / (PS * B * N)
    uint8_t base_frequency = 100;
    uint16_t tccr1_prescaler = 8;
    // Clock Speed / Target Interrupt Frequency (4kHz)
    OCR1A = F_CPU / ((uint32_t) tccr1_prescaler * (uint32_t) base_frequency * (uint32_t) sinewave_length); 

    // Enable Timer/Counter1 Output Compare A Match Interrupt
    TIMSK1 |= _BV(OCIE1A);

    sample_0 = 0;

/***************************************************************************
 ** END - Timer/Counter1 Configuration                                    **
 ***************************************************************************/

/***************************************************************************
 ** Timer/Counter2 Configuration (used for generating PWM)       **
 ***************************************************************************/

    // Setup Timer/Counter2 Control Registers (TCCR2) with the following options:
    //                          Mode  |  Fast PWM
    //                           TOP  |  0xFF
    //    Update of compare register  |  BOTTOM
    //               TOV Flag Set on  |  MAX
    TCCR2A |= _BV(WGM21) | _BV(WGM20); // Set WGM21 and WGM20 bits in TCCR2A
    TCCR2B &= ~_BV(WGM22);             // Clear bit WGM22 in TCCR2B

    // Setup Timer/Counter2 Control Registers (TCCR2) in Compare Output Mode with the following options:
    //    Clear OC2A on Compare Match, set OC2A at BOTTOM, (non-inverting mode).
    TCCR2A = (TCCR2A | _BV(COM2A1)) & ~_BV(COM2A0);  // Set COM2A1 and clear COM2A0 bit in TCCR2A

    // Setup Timer/Counter2 Control Registers (TCCR2) in Compare Output Mode with the following options:
    //    Normal port operation, OC2B disconnected.
    TCCR2A &= ~(_BV(COM2B1) | _BV(COM2B0));  // Clear COM2B0 and COM2B1 bits in TCCR2A

    // Setup clock prescaler for Timer 2 (TCCR2) as clk_IO/8
    //     The highest frequency generated by our wavetable (in the future) is planned to be 500Hz.
    //     Thus, PWM base frequency / PWM resolution (255) must be at least 1kHz.
    TCCR2B = (TCCR2B & ~(_BV(CS22) | _BV(CS20))) | _BV(CS21);

    OCR2A = pgm_read_byte(&sinewave_data[0]);

/***************************************************************************
 ** END - Timer/Counter2 Configuration                                    **
 ***************************************************************************/

/***************************************************************************
 ** ADC Configuration                                                     **
 ***************************************************************************/

    // Set ADC reference to AVCC
    ADMUX |= _BV(REFS0);
    // Initialise ADC pointing to channel 2
    ADMUX |= _BV(MUX1);

    // Enable ADC conversion complete interrupt (ADC_vect)
    ADCSRA |= _BV(ADIE);
    // Set ADC prescaler to 128 - 125kHz sample rate @ 16MHz, 62.5kHz sample rate @ 8MHz
    ADCSRA |= _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0);

    // Enable ADC
    ADCSRA |= _BV(ADEN);
    // Start an initial ADC conversion
    ADCSRA |= _BV(ADSC);

    // Wait for conversion to complete, then clear interrupt flag
    while(ADCSRA & _BV(ADSC));
    ADCSRA |= _BV(ADIF);

/***************************************************************************
 ** END - ADC Configuration                                               **
 ***************************************************************************/

    // Enable global interrupts
    sei();
}

void loop() {}