pastebin - collaborative debugging

// Servo.c
// RabidCicada
// RabidCicada@gmail.com


#define F_CPU 14745600

#include <stdio.h>
#include <math.h>

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

#include "../libnerdkits/delay.h"
#include "../libnerdkits/lcd.h"

uint8_t timer0_clkslct;
uint8_t timer1_clkslct;

uint16_t step;
uint16_t servo_pos_time_period;
uint16_t ADC_val;

 //INitialize the Analog to Digital Converter
 void adc_init(){

        //DIDR0=0;

        //Configure ADC to use external reference voltage (5v) and to use ADC0
        ADMUX = 0;

        //ADCSRA |= (1<<ADEN);

        //Enable ADC and configure the prescale to be 1/128
        //--witha clock of 14745600 this means it will be 115.2khz
        ADCSRB = 0;
        ADCSRA =(1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0) | (1<<ADATE);


        //Kick off the ADC Initializing conversion
        //This causes the hardware logic initialization
        //which takes longer then normal conversions.
        ADCSRA |= (1<<ADSC);

 }

 //Perform a read of the Analog to Digital Converter
 //Assuming a conversion has already been initiated
 //Reads 10 bits worth of unique values(1024)
 uint16_t adc_read(){

        //Spin in circles waiting for a conversion to finish (ADCSC=0)
        //while( ADCSRA & (1<<ADSC) ){

        //}

        //This actually reads from the result registers of the ADC
        uint16_t result = ADCL;
        uint16_t temp = ADCH;
        result = result + (temp<<8);

        //Kickoff the next conversion
        //ADCSRA |= (1<<ADSC);

        return result;

 }

 //Timer initialization of Timer 1
 //Used to control length of control pulse for servo
 //Need the smallest timeslice possible(resolution)
 //for the most accuracy
 //Configure Timer/Counter1 to run at prescale(8)(14745600/8) 1843200Hz
 //Did this because we want smallest resolution possible that fits
 //in 2bytes(16bits)
 void timer1_init(){

        //Timer Counter Control Register 1 (B)
        TCCR1B = (1<<WGM12);
                //Parially set mode to Clear Timer on Counter match (WGM13,12)
                //and incidentally stop timer (0->bits CS1, CS2, and CS3)

        //Timer Counter Control Register 1 (A)
        TCCR1A = 0;     //Finish setting mode to Clear Timer on Counter match (0-> bits WGM11, WGM10)
                                //Sets compare output match mode for both channels(a,b) to not use normal ports
                                //as counter outputs.(disconnected)
                                //In total, what this means is that the timer will count up to it's
                                //limit(OCR1A and OCR1B) then reset to 0.


        timer1_clkslct = ((0<<CS12) | (1<<CS11) | (0<<CS10));
                                //Will be used in timer1_start to set prescaler to 8

 }

  //Timer Initialization of Timer 0
  //Sets up the timer used for maintaining the pulse window that the
  //hobby servo likes (10-20 ms window) We have chosen 15ms
  void timer0_init(){

        //Configure Timer/Counter0 to run at prescale(1024)(14745600/256) 14400Hz
        //Arbitrarily chose a prescale that had a large timeslice (large resolution)
        //So that the number of counter cycles in our window would fit
        //in 8 bits of resolution

        //Due to the way the timer operates the timer prescale will be set
        //in start_timer0 where the clock select is set to the 1024 prescale

        //Timer Counter Control Register 0 (B)
        TCCR0B = 0;
                //Parially set mode to Clear Timer on Counter match (WGM01,00)
                //and incidentally stop timer (0->bits CS1, CS2, and CS3)
                //This allows us to make updates without worrying about the timer.

        timer0_clkslct = ((1<<CS02) | (0<<CS01) | (1<<CS00));
                //Will be used in timer0_start to set prescaler to 1024

        //Timer Counter Control Register 0 (A)
        TCCR0A = (1<<WGM01);    //Finish setting mode to Clear Timer on Counter match (0-> bits WGM11, WGM10)
                                //Sets compare output match mode for both channels(a,b) to not use normal ports
                                //as counter outputs.(disconnected)
                                //In total, what this means is that the timer will count up to it's
                                //limit(OCR1A and OCR1B) then reset to 0.

        //Set the compare register A to the timer fire limit
        //OCR0A = 216; // - number of cycles in 15ms at 1024 prescale
        OCR0A = 250;
        //OCR0A = 288; // - number of cycles in 20ms at 1024 prescale

        //Set the Interrupt enable flag for the compare reg A (OCR0A)
        TIMSK0 = (1<<OCIE0A);

 }

 void timer0_start(){
        //Timer Counter Control Register 0 (B)
        TCCR0B |= timer0_clkslct;
                                //Sets prescaler to 1024
 }

  void timer1_start(){
        //Timer Counter Control Register 1 (B)
        TCCR1B |= timer1_clkslct;
                                //Sets prescaler to 8
 }

 void timer0_stop(){
        TCCR0B &= ~((1<<CS12) | (1<<CS11) | (1<<CS10));
 }

 void timer1_stop(){
        TCCR1B &= ~((1<<CS12) | (1<<CS11) | (1<<CS10));
 }


 void portio_init(){
        //Enable output on pin 4 of port C
        //Inputs on all others
        DDRC = (1<<DDC4);

        //PORTC = (0<<PORTC0);

 }


 //It is critical that this entire routine finish in under the servo
 //actuator window so that it can does not get clipped.
 void poll_adc_and_actuate(){
        uint16_t pot_value = adc_read();
        //ADC_val += 1;//pot_value;
        ADC_val = pot_value;
        //servo_pos +=1;//
        servo_pos_time_period = 2037 + (uint16_t) (pot_value * 1.45);

        //Set Timer upper bound for length of pulse to actuate servo
        //The potentiometer only measures 10 bits worth of distinct
        //values(1024 exactly).  Because of this we must scale the potentiometer value
        //by 1.45 to cover the full range of the number of cycles needed to span
        //.8ms below(1482)

        //Precalculated values based on number of cycles in a given timeframe...
        //Base number of cycles 2037 (1.1 ms) + difference(0-1482 cycles)3519(range of .8ms)
        //This gives actuation signal of 1.1-1.9ms
        OCR1A = servo_pos_time_period;
        TCNT1 = 0;//Clear timer to 0--will count up to limit (OCR1A)

        PORTC|=(1<<PORTC4);     //Set control pulse for servo high
        timer1_start();

        //Wait for timer to be over
        //Check the timer output compare pin to see if a match has occured.
        //OCF1A is set when a compare match occured(timer hit our limit)
        //Spin in circles while timer hasn't hit limit.(1.1ms-1.9ms)
        while(!(TIFR1 & (1<<OCF1A))){
        }

        timer1_stop();
        TIFR1|=(1<<OCF1A);//clear compare match flag.

        //Clear output bit
        PORTC&= ~(1<<PORTC4); //Set control pulse for servo low


 }

 //Interrupts are automatically disabled in this
 ISR(TIMER0_COMPA_vect){
        poll_adc_and_actuate();
 }


//The plan is to use timer based calls for controlling the servo
//The servo expects a pulse every 15-20 milliseconds
//Every time poll_adc_and_actuate is called it will
//kick off the timer for a new poll_adc_and_actuate call,
//do a read of the adc, actuate the servo, then spin in an
//infinite loop waiting for the timer to fire again

 int main(){
        int cnt=0;
        step=0;
        ADC_val=0;
        servo_pos_time_period=0;

        // fire up the LCD
        lcd_init();
        FILE lcd_stream = FDEV_SETUP_STREAM(lcd_putchar, 0, _FDEV_SETUP_WRITE);
        lcd_home();

        // print message to screen
        lcd_write_string(PSTR("  Initializing System    "));
        lcd_line_two();
        lcd_write_string(PSTR("                         "));

        //Initialize ADC
        adc_init();

        //Initialize ports for use
        portio_init();

        //Initialize the timer that repeatedly executes the
        //poll_adc_and_actuate() function
        //This one is our "window" timer for the servo pulses
        timer0_init();

        //Initialize the timer that controls the length of the pulse
        //for each servo actuation
        timer1_init();

        //Enable Interrupts
        sei();

        //Delay for visual confirmation
        delay_ms(3000);
        // print message to screen
        lcd_clear_and_home();
        lcd_write_string(PSTR(" Entering Actuator Loop  "));
        lcd_line_two();
        lcd_write_string(PSTR("                         "));
        delay_ms(3000);

        //Start timer0...This starts our 15ms window loop
        timer0_start();

        //Spin in infinite loop letting interrupt for poll_adc_and_actuate trigger
        while(1){
                //ADC_val = adc_read();
                lcd_home();
                lcd_write_int16(cnt);
                lcd_write_string( PSTR(" ADC Value:   "));
                lcd_write_int16(ADC_val);
                lcd_write_string(PSTR(" of 1024"));
                lcd_line_two();
                lcd_write_string( PSTR(" Servo position: "));
                lcd_write_int16(servo_pos_time_period);
                cnt=!cnt;
                //delay_ms(1000);
        }

        //poll_adc_and_actuate();


 return 0;
 }