src/temperature/temperature.c

Go to the documentation of this file.

/*
 * temperature.c
 *
 * Copyright 2011 Pieter Agten
 *
 * This file is part of Yarf.
 *
 * Yarf is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Yarf is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Yarf.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "temperature.h"

#include "yarf.h"
#include "thermistor_table.h"
#include "scheduling/periodic.h"
#include "util/math.h"
#include "pid.h"

#include <stdint.h>
#include <avr/interrupt.h> 
#include <util/atomic.h> 

#define INITIAL_TARGET_TEMP_C 0


struct heater {
  pid_t pid;                     
  float max_temp;                
  void (*set_power)(uint8_t dc); 
  volatile uint16_t current_adc; 
  volatile float current_temp;   
  uint8_t current_power;         
};

static struct heater nozzle;

static struct heater printbed;

static volatile enum {
  IDLE,              
  READING_NOZZLE,    
  READING_PRINTBED   
} adc_state;


static periodic_task_t temperature_task;


static void
set_nozzle_duty_cycle(uint8_t dc)
{
  NOZZLE_HEATER_PWM_REG = MIN(dc,NOZZLE_HEATER_MAX_DUTY_CYCLE);
}

static inline void
set_printbed_duty_cycle(uint8_t dc)
{
  PRINTBED_HEATER_PWM_REG = MIN(dc,PRINTBED_HEATER_MAX_DUTY_CYCLE);
}

static inline void
adc_init(void)
{
  /* Disable digital inputs on ADC pins for reducing power consumption */
  DIDR0 = _BV(TEMP1_PIN) | _BV(TEMP2_PIN);
  
  /* Set voltage reference */
  ADMUX = (1 << REFS0);

  /*@brief  The temperature component manages the temperature of the nozzle 
 *         and the printbed. Set ADC prescaler and enable ADC */
  ADCSRA = _BV(ADEN) | _BV(ADIE) | (7 << ADPS0);
}

static inline void
pwm_init(void)
{
  /* Disable all timer 0 interrupts */
  TIMSK0 = 0;

  /* Set duty cycle to 0 */
  OCR0A = 0;
  OCR0B = 0;

  /* Select Compare Output Mode, 1024 prescaler, phase correct PWM */
  TCCR0A = (2 << COM0A0) | (2 << COM0B0) | (1 << WGM00);
  TCCR0B = (5 << CS00);
  // PWM freq = F_CPU/1024/255/2
}

static void
manage_heater_power(struct heater *heater)
{
  uint8_t power;
  if (heater->current_temp < heater->max_temp) {
    power = pid_next(&(heater->pid), heater->current_temp);
  } else {
    power = 0;
  }
  heater->set_power(power);
  heater->current_power = power;
}

static inline float
nozzle_temperature(uint16_t adc)
{
  return pgm_read_float(&(NOZZLE_THERMISTOR_TABLE[adc]));
}

static inline float
printbed_temperature(uint16_t adc)
{
  return pgm_read_float(&(PRINTBED_THERMISTOR_TABLE[adc]));
}

ISR(ADC_vect,ISR_NOBLOCK)
{
  uint16_t adc_value;
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    adc_value = ADCL;
    adc_value |= (ADCH << 8);
  }
  switch (adc_state) {
    case READING_NOZZLE:
      nozzle.current_adc = adc_value;
      nozzle.current_temp = nozzle_temperature(adc_value);
      manage_heater_power(&nozzle);

      /* Select the printbed thermistor pin */
      ADMUX = (ADMUX & ~(0x1F << MUX0)) | (PRINTBED_THERMISTOR_PIN << MUX0);

      /* Start the ADC conversion (asynchronously) */
      adc_state = READING_PRINTBED;
      ADCSRA |= _BV(ADSC);
      break;
    case READING_PRINTBED:
      printbed.current_adc = adc_value;
      printbed.current_temp = printbed_temperature(adc_value);
      manage_heater_power(&printbed);

      adc_state = IDLE;
      break;
    default:
      break;
  }
}

static void
temp_periodic(void)
{
  /* Make sure the previous adc conversion has been completed */
  if (adc_state != IDLE) {
    /* ADC can't keep up! */
    return;
  }

  /* Select the nozzle thermistor pin */
  ADMUX = (ADMUX & ~(0x1F << MUX0)) | (NOZZLE_THERMISTOR_PIN << MUX0);

  /* Start the ADC conversion (asynchronously) */
  adc_state = READING_NOZZLE;
  ADCSRA |= _BV(ADSC);
}


//TODO: improve this method
static inline bool
temperature_reached(struct heater *h)
{
  return h->pid.target_temp == 0 ||
         fabs(h->current_temp - h->pid.target_temp) < 2;
}

void
temp_init(void)
{
  adc_init();
  pwm_init();

  nozzle.max_temp = NOZZLE_HEATER_MAX_TEMP;
  nozzle.set_power = set_nozzle_duty_cycle;
  pid_init(&nozzle.pid, NOZZLE_PID_ENVELOPE, NOZZLE_PID_P_GAIN, NOZZLE_PID_I_GAIN, NOZZLE_PID_D_GAIN);
  pid_set_target(&nozzle.pid, INITIAL_TARGET_TEMP_C);
  
  printbed.max_temp = PRINTBED_HEATER_MAX_TEMP;
  printbed.set_power = set_printbed_duty_cycle;
  pid_init(&printbed.pid, PRINTBED_PID_ENVELOPE, PRINTBED_PID_P_GAIN, PRINTBED_PID_I_GAIN, PRINTBED_PID_D_GAIN);
  pid_set_target(&printbed.pid, INITIAL_TARGET_TEMP_C);

  periodic_task_set(&temperature_task, temp_periodic, (int)(1000.0/HEATER_MANAGEMENT_FREQUENCY_HZ));
  periodic_add(&temperature_task);
}


/* ********** Nozzle ********** */
void
temp_set_nozzle_target(float c)
{
  pid_set_target(&nozzle.pid, c);
}


float
temp_get_nozzle_temp(void)
{
  return nozzle.current_temp;
}


uint16_t
temp_get_nozzle_adc(void)
{
  return nozzle.current_adc;
}


uint8_t
temp_get_nozzle_power(void)
{
  return nozzle.current_power;
}

bool
temp_nozzle_temperature_reached(void)
{
  return temperature_reached(&nozzle);
}

void
temp_nozzle_temperature_wait(void)
{
  while (! temp_nozzle_temperature_reached()) {
  }
}

/* ********** Printbed ********** */
void
temp_set_printbed_target(float c)
{
  pid_set_target(&printbed.pid, c);
}


float
temp_get_printbed_temp(void)
{
  return printbed.current_temp;
}


uint8_t
temp_get_printbed_power(void)
{
  return printbed.current_power;
}

bool
temp_printbed_temperature_reached(void)
{
  return temperature_reached(&printbed);
}

void
temp_printbed_temperature_wait(void)
{
  while (! temp_printbed_temperature_reached()) {
  }
}