experiment.c

/*
 * experiment.c
 *
 * Created: 01/10/2012 10:59:48 PM
 *  Author: mdryden
 */ 
/**
 * @file experiment.c
 * @author  Michael DM Dryden <mdryden@chem.utoronto.ca>
 * @version 1.0
 *
 *
 * @section DESCRIPTION
 *
 * Contains Functions for performing experiments and adjusting potentiostat settings other than DAC and ADC.
 */

#include "experiment.h"
#include "settings.h"
#include "tcs.h"
#include "config/conf_board.h"
#include "shutter.h"
#include <util/atomic.h>

//Public variable definitions
uint16_t g_gain = POT_GAIN_30k;
uint8_t g_short = 0;
uint8_t autogain_enable = 1;

//Private variables
volatile int32_t voltage = 0;
volatile uint16_t dacindex = 0;
uint16_t dacindex_stop = 0;
volatile int8_t up = 1;
volatile uint16_t iter = 0;
uint16_t* eis_ptr = 0;
volatile uint16_t cycles = 0;
volatile uint16_t samples = 0;
volatile uint16_t tcf0period = 0;
uint32_t skip_samples = 0;

//Private function declarations
//uint16_t set_timer_period(uint32_t period, volatile void *tc);
static void precond_rtc_callback(uint32_t time);
static void porte_int0_lsv(void);
static void tcf0_ovf_callback(void);
static void tce1_ovf_callback_lsv(void);
static void lsv_cca_callback(void);
static void ca_cca_callback(void);
static void portd_int0_ca(void);
static uint8_t _swv_singledir(uint16_t dacindex, uint16_t dacindex_stop, uint16_t dacindex_pulse_height, uint16_t dacindex_step, uint8_t direction);
static uint8_t _dpv_singledir(uint16_t dacindex, uint16_t dacindex_stop, uint16_t dacindex_pulse_height, uint16_t dacindex_step, uint8_t direction);
static void pmt_idle(void);

//interrupt callback setup
typedef void (*port_callback_t) (void);

static port_callback_t portd_int0_callback;
static port_callback_t portd_int1_callback;

void experiment_handler(char command[]){
    static int16_t p1, p2, p3;
    static uint16_t u1, u2, u3, u4, u5, u6;
    static uint8_t p5, o1, o2, o3;
    static int16_t pcv1, pcv2;
    static uint16_t pct1, pct2;
    uint16_t tcs_data[] = {0,0,0,0};
    uint16_t tcs_data1[] = {0,0,0,0};
    double p6;
    
    
    switch (command[0]){
        case 'A': //ADS Buffer/rate/PGA values from ads1255.h
            sscanf(command+1, "%hhx%hhx%hhx",&o1,&o2,&o3);
            printf("#A: %x %x %x\n",o1,o2,o3);
            ads1255_setup(o1, o2, o3);
            break;
            
        case 'G': //Gain
            sscanf(command+1, "%u%hhu",&g_gain, &g_short);
            printf("#G: %u %u\n", g_gain, g_short);
            pot_set_gain(); //uses global g_gain, so no params
            break;
            
        case 'L': //LSV - start, stop, slope
            if (settings.settings.dac_units_true) {
                sscanf(command+1, "%u%u%u%u%u%u%u",&pct1,&pct2,&pcv1,&pcv2,&u1,&u2,&u3);
                precond(pcv1,pct1,pcv2,pct2);
                lsv_experiment(u1,u2,u3,2);
            } else {
                sscanf(command+1, "%u%u%i%i%i%i%u",&pct1,&pct2,&pcv1,&pcv2,&p1,&p2,&u1);
                
                //start
                u2 = ceil(p1*(65536/(double)3000)+32768);
                //stop
                u3 = ceil(p2*(65536/(double)3000)+32768);
                
                precond(pcv1,pct1,pcv2,pct2);
                lsv_experiment(u2,u3,u1,2);
            }
            break;
            
        case 'C': //CV - v1, v2, start, scans, slope
            if (settings.settings.dac_units_true) {
                sscanf(command+1, "%u%u%i%i%u%u%u%hhu%u",&pct1,&pct2,&pcv1,&pcv2,&u1,&u2,&u3,&p5,&u4);
                precond(pcv1,pct1,pcv2,pct2);
                cv_experiment(u1,u2,u3,p5,u4);
            } else {
                sscanf(command+1, "%u%u%i%i%i%i%i%hhu%u",&pct1,&pct2,&pcv1,&pcv2,&p1,&p2,&p3,&p5,&u4);
                
                //v1
                u1 = ceil(p1*(65536/(double)3000)+32768);
                //v2
                u2 = ceil(p2*(65536/(double)3000)+32768);
                //start
                u3 = ceil(p3*(65536/(double)3000)+32768);
                //slope
                u4 = ceil(u4*(65536/(double)3000));
                
                precond(pcv1,pct1,pcv2,pct2);
                cv_experiment(u1,u2,u3,p5,u4);
            }
            break;
            
        case 'S': //SWV - start, stop, step size, pulse_height, frequency, scans
            if (settings.settings.dac_units_true) {
                sscanf(command+1, "%u%u%i%i%u%u%u%u%u%hhu",&pct1,&pct2,&pcv1,&pcv2,&u1,&u2,&u3,&u4,&u5,&p5);
                precond(pcv1,pct1,pcv2,pct2);
                swv_experiment(u1,u2,u3,u4,u5,p5);
            } else {
                sscanf(command+1, "%u%u%i%i%i%i%u%u%u%hhu",&pct1,&pct2,&pcv1,&pcv2,&p1,&p2,&u1,&u2,&u3,&p5);
                
                //start
                uint16_t start = ceil(p1*(65536/(double)3000)+32768);
                //stop
                uint16_t stop = ceil(p2*(65536/(double)3000)+32768);
                //step
                u1 = ceil(u1*(65536/(double)3000));
                //pulse_height
                u2 = ceil(u2*(65536/(double)3000));
                
                precond(pcv1,pct1,pcv2,pct2);
                swv_experiment(start,stop,u1,u2,u3,p5);
            }
            break;
            
        case 'D': //DPV - start, stop, step size, pulse_height, period, width
            if (settings.settings.dac_units_true) {
                sscanf(command+1, "%u%u%i%i%u%u%u%u%u%u",&pct1,&pct2,&pcv1,&pcv2,&u1,&u2,&u3,&u4,&u5,&u6);
                precond(pcv1,pct1,pcv2,pct2);
                dpv_experiment(u1,u2,u3,u4,u5,u6);
            } else {
                sscanf(command+1, "%u%u%i%i%i%i%u%u%u%u",&pct1,&pct2,&pcv1,&pcv2,&p1,&p2,&u1,&u2,&u3,&u4);
                
                //start
                uint16_t start = ceil(p1*(65536/(double)3000)+32768);
                //stop
                uint16_t stop = ceil(p2*(65536/(double)3000)+32768);
                //step
                u1 = ceil(u1*(65536/(double)3000));
                //pulse_height
                u2 = ceil(u2*(65536/(double)3000));
                
                precond(pcv1,pct1,pcv2,pct2);
                dpv_experiment(start,stop,u1,u2,u3,u4);
            }
            break;
            
        case 'M': //PMT idle mode - holds voltage at 0 V with no data output
            pmt_idle();
            break;
            
        #if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR >= 2
        case 'P': //potentiometry - time, OCP/poteniometry
            sscanf(command+1, "%u%hhu",&pct1, &o1);
            pot_experiment(pct1, o1);
            break;
        #endif
            
        case 'R': //CA - steps, step_dac[], step_seconds[]
        {
            sscanf(command+1, "%hhu%hhu",&p5, &o1); //get number of steps
            printf("#INFO: Steps: %u\n", p5);
            
            //allocate arrays for steps
            uint16_t * step_dac = malloc(p5*sizeof(uint16_t));
            uint16_t * step_seconds = malloc(p5*sizeof(uint16_t));
            
            //check for successful allocation
            if (!step_dac || !step_seconds){
                printf("#ERR: Could not allocate memory\n");
                break;
            }
            
            //request additional parameters from computer
            printf("@RQP %u\n", 2*(uint16_t)p5);
            
            uint16_t i;
            uint8_t result;
            
            for (i=0; i<p5; i++){
                while (1) {
                    result = scanf("%u", &step_dac[i]); // get voltage steps (dac units)
                    if (result == 1) {
                        printf("@RCVC %u\n", step_dac[i]);
                        break;
                    }
                    else {
                        printf("@RCVE\n");
                    }
                }
            }
            
            for (i=0; i<p5; i++){
                while (1) {
                    result = scanf("%u", &step_seconds[i]); // get time steps (seconds)
                    if (result == 1) {
                        printf("@RCVC %u\n", step_seconds[i]);
                        break;
                    }
                    else {
                        printf("@RCVE\n");
                    }
                }
            }
            
            printf("@RCP %u\n", 2*(uint16_t)p5);
            
            printf("#INFO: TCS_check: %hhu\n", o1);
            if (o1 > 0) {
                if (settings.settings.tcs_enabled > 0){
                    tcs_readvalues(tcs_data);
                    tcs_readvalues(tcs_data1); // If sensor disconnected, second measurement should be exactly the same (unless 0 or saturated)
                    printf("#INFO: TCS0—%u %u %u %u\n", tcs_data[0], tcs_data[1], tcs_data[2], tcs_data[3]);
                    printf("#INFO: TCS1—%u %u %u %u\n", tcs_data1[0], tcs_data1[1], tcs_data1[2], tcs_data1[3]);
                    if (tcs_data[0] == tcs_data1[0]){
                        if (!(tcs_data[0] == 0 || tcs_data[0] == 65535)) {
                            printf("#ERR: Ambient light sensor seems to be disconnected \n");
                            return;
                        }
                    }
                    if (tcs_data[0] > settings.settings.tcs_clear_threshold){
                        printf("#ERR: Ambient light exceeds threshold %u\n", tcs_data[0]);
                        printf("#INFO: TCS—%u %u %u %u\n", tcs_data[0], tcs_data[1], tcs_data[2], tcs_data[3]);
                        return;
                    }
                }
                else {
                    printf("#ERR: Ambient light sensor disabled.\n");
                    return;
                }
            }
            
            ca_experiment(p5, step_dac, step_seconds);
            
            //free arrays
            free(step_dac);
            free(step_seconds);
            
            break;
          }
            
        case 'Z': //Shutter sync
            sscanf(command+1, "%lg", &p6);
            shutter_cont(p6);
            break;
            
        case 'z':
            shutter_cont_stop();
            break;
            
        case '1':
            shutter_close();
            break;
            
        case '2':
            shutter_open();
            break;
            
        default:
            printf("#ERR: Experiment command %c not recognized\n", command[0]);
    }
}


uint16_t set_timer_period(uint32_t period, volatile void *tc)
{
	/**
	 * Sets a suitable timer source and sets period for a 16-bit timer
	 *
	 * @param period 32-bit period in CPU cycles
	 * @param *tc pointer to timer to set
	 * @return divider used.
	 */
	uint16_t temp_div = ceil((double)period/65536);
	uint16_t divider = 0;
	
	if (temp_div == 1)
	tc_write_clock_source(tc, TC_CLKSEL_DIV1_gc);
	else if (temp_div == 2){
		tc_write_clock_source(tc, TC_CLKSEL_DIV2_gc);
		divider = 2;
	}
	else if (temp_div <= 4){
		tc_write_clock_source(tc, TC_CLKSEL_DIV4_gc);
		divider = 4;
	}
	else if (temp_div <= 8){
		tc_write_clock_source(tc,TC_CLKSEL_DIV8_gc);
		divider = 8;
	}
	else if (temp_div <= 64){
		tc_write_clock_source(tc,TC_CLKSEL_DIV64_gc);
		divider = 64;
	}
	else if (temp_div <= 256){
		tc_write_clock_source(tc,TC_CLKSEL_DIV256_gc);
		divider = 256;
	}
	else if (temp_div <= 1024){
		tc_write_clock_source(tc,TC_CLKSEL_DIV1024_gc);
		divider = 1024;
	}
	else{
		printf("#Frequency/ADC rate is too low\n");
		return 0;
	}
	
	period /= divider;
	tc_write_period(tc, (uint16_t)period);
	return divider;
}

void pot_init(void){
	/**
	 * Initializes AVR port directions and levels
	 *
	 * @return Nothing.
	 */
	#if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR == 1
		ioport_set_port_dir(IOPORT_PORTB, PIN3_bm|PIN4_bm|PIN5_bm|PIN6_bm|PIN7_bm, IOPORT_DIR_OUTPUT);
		ioport_set_port_dir(IOPORT_PORTD, PIN4_bm, IOPORT_DIR_OUTPUT);
		ioport_set_port_level(IOPORT_PORTB, PIN3_bm|PIN4_bm|PIN5_bm|PIN6_bm|PIN7_bm, PIN3_bm|PIN6_bm|PIN7_bm);
		ioport_set_port_level(IOPORT_PORTD, PIN4_bm, PIN4_bm);
	#endif
	#if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR == 2
		ioport_set_port_dir(IOPORT_PORTB, PIN2_bm|PIN3_bm|PIN4_bm|PIN5_bm|PIN6_bm|PIN7_bm, IOPORT_DIR_OUTPUT);
		ioport_set_port_dir(IOPORT_PORTD, PIN4_bm, IOPORT_DIR_OUTPUT);
		ioport_set_port_level(IOPORT_PORTB, PIN2_bm|PIN3_bm|PIN4_bm|PIN5_bm|PIN6_bm|PIN7_bm, PIN6_bm|PIN7_bm);
		ioport_set_port_level(IOPORT_PORTD, PIN4_bm, PIN4_bm);
	#endif
}

void pot_set_gain(void){
	/**
	 * Sets iV gain according to current g_gain value
	 *
	 * @return Nothing.
	 */
	switch (g_gain){
		#if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR == 1
			case POT_GAIN_500M:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, 0);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, 0);
		
				printf("#INFO: 500M\n");
				break;
		
			case POT_GAIN_30M:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN6_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, 0);
				printf("#INFO: 30M\n");
				break;
		
			case POT_GAIN_3M:	
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN7_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, 0);
				printf("#INFO: 3M\n");
				break;
		
			case POT_GAIN_300k:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN6_bm|PIN7_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, 0);
				printf("#INFO: 300k\n");
				break;
		
			case POT_GAIN_30k:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, 0);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, PIN4_bm);
				printf("#INFO: 30k\n");
				break;
		
			case POT_GAIN_3k:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN6_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, PIN4_bm);
				printf("#INFO: 3k\n");
				break;
		
			case POT_GAIN_300:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN7_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, PIN4_bm);
				printf("#INFO: 300\n");
				break;
		
			case POT_GAIN_100:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN6_bm|PIN7_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, PIN4_bm);
				printf("#INFO: 100\n");
				break;
		#endif
		
		#if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR == 2
			case POT_GAIN_100M:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, 0);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, 0);
				printf("#INFO: 100M\n");
				break;
				
			case POT_GAIN_30M:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN6_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, 0);
				printf("#INFO: 30M\n");
				break;
				
			case POT_GAIN_3M:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN7_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, 0);
				printf("#INFO: 3M\n");
				break;
				
			case POT_GAIN_300k:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN6_bm|PIN7_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, 0);
				printf("#INFO: 300k\n");
				break;
				
			case POT_GAIN_30k:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, 0);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, PIN4_bm);
				printf("#INFO: 30k\n");
				break;
				
			case POT_GAIN_3k:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN6_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, PIN4_bm);
				printf("#INFO: 3k\n");
				break;
				
			case POT_GAIN_0:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN7_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, PIN4_bm);
				printf("#INFO: 0\n");
				break;
				
			case POT_GAIN_100:
				ioport_set_port_level(IOPORT_PORTB, PIN6_bm|PIN7_bm, PIN6_bm|PIN7_bm);
				ioport_set_port_level(IOPORT_PORTD, PIN4_bm, PIN4_bm);
				printf("#INFO: 100\n");
				break;
		#endif
		
			default:
				printf("#WAR: Invalid pot gain.\n");
				break;
            
		return;
	}
}

void volt_exp_start(void){
	/**
	 * Connects measurement cell to rest of circuit.
	 */
	#if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR == 1
		ioport_set_port_level(IOPORT_PORTB, PIN3_bm|PIN4_bm|PIN5_bm, PIN3_bm|PIN4_bm);
	#endif
	
	#if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR == 2
        ioport_set_port_level(IOPORT_PORTB, PIN2_bm|PIN3_bm|PIN4_bm|PIN5_bm, PIN2_bm|PIN4_bm);
	#endif
    
    delay_ms(100); // Make sure WE circuit is connected before control voltage applied
    ioport_set_pin_level(PIN_POT_CE, 1);
	
    if (g_short == 1)
        ioport_set_pin_level(PIN_POT_2ELECTRODE, 1);
    else
        ioport_set_pin_level(PIN_POT_2ELECTRODE, 0);
}

void volt_exp_stop(void){
	/**
	 * Disconnects measurement cell.
	 */
	#if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR == 1
		ioport_set_port_level(IOPORT_PORTB, PIN3_bm|PIN5_bm, 0);
	#endif
	#if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR == 2
		ioport_set_port_level(IOPORT_PORTB, PIN2_bm|PIN3_bm|PIN5_bm, 0);
	#endif
    
    delay_ms(100);  // Make sure WE is last to disconnect
    ioport_set_pin_level(PIN_POT_WE, 0);
}

#if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR >= 2
void pot_exp_start(void){
	/**
	 * All switches open.
	 */
	ioport_set_port_level(IOPORT_PORTB, PIN2_bm|PIN3_bm|PIN4_bm|PIN5_bm, 0);

}

void ocp_exp_start(void){
	/**
	 * U3C closed
	 */
	ioport_set_port_level(IOPORT_PORTB, PIN2_bm|PIN3_bm|PIN4_bm|PIN5_bm, PIN4_bm);
}
#endif

void precond(uint16_t v1, uint16_t t1, uint16_t v2, uint16_t t2){ //assumes potentiostat switches are already set
	/**
	 * Performs experiment preconditioning.
	 *
	 * @param v1 First potential (DAC index).
	 * @param t1 First duration (s).
	 * @param v2 Second potential (DAC index).
	 * @param t2 Second duration (s).
	 */
	
	uint16_t time_old = 0;
	
	while (RTC.STATUS & RTC_SYNCBUSY_bm);
	RTC.PER = 65535;
	while (RTC.STATUS & RTC_SYNCBUSY_bm);
	RTC.CTRL = RTC_PRESCALER_DIV1024_gc; //1s tick
	rtc_set_callback((rtc_callback_t)precond_rtc_callback);
	
	up = 1;
	
	//first potential
	if (t1 > 0){
		max5443_set_voltage1(v1);
		rtc_set_alarm(t1);
		RTC.CNT = 0;
		volt_exp_start();
		while (up){
			if (udi_cdc_is_rx_ready()){
				if (getchar() == 'a'){
					precond_rtc_callback(t1);
					printf("##ABORT\n");
					goto aborting;
				}
			}
			if (time_old != RTC.CNT){
				time_old = RTC.CNT;
				printf("#%u\n",time_old);
			}
		}
	}
	
	up = 1;
	time_old = 0;
	
	if (t2 > 0){
		max5443_set_voltage1(v2);
		rtc_set_alarm(t2);
		RTC.CNT = 0;
		volt_exp_start();
		while (up){
			if (udi_cdc_is_rx_ready()){
				if (getchar() == 'a'){
					precond_rtc_callback(t2);
					printf("##ABORT\n");
					goto aborting;
				}
			}
			if (time_old != RTC.CNT){
				time_old = RTC.CNT;
				printf("#%u\n",time_old);
			}
		}
	}
	
	aborting:
		volt_exp_stop();
		return;
}

static void precond_rtc_callback(uint32_t time){
	up = 0;
	RTC.INTCTRL |= RTC_COMPINTLVL_OFF_gc;
}

void cv_experiment(uint16_t v1, uint16_t v2, uint16_t start, uint8_t scans, uint16_t slope){
	/**
	 * Perform a CV experiment.
	 *
	 * Calls lsv_experiment several times to make a CV experiment.
	 * @param v1 Vertex 1 in dac units.
	 * @param v2 Vertex 2 in dac units.
	 * @param start Start voltage in dac units.
	 * @param scans Number of scans.
	 * @param slope Scan rate in dac units/s.
	 */
	// check if start is [v1,v2]
    
	int8_t firstrun = 1;
	
	if((start < v1 && start < v2) || (start > v1 && start > v2)){
		printf("#ERR: Start must be within [v1, v2]\n");
		return;
	}
	
	while(scans > 0){
		if (start != v1){
			if (lsv_experiment(start,v1,slope,firstrun) == 1)
				return;
			firstrun = 0;
		}
        
		if (start == v2 && scans == 1)
			firstrun = -1;
        
		if (lsv_experiment(v1,v2,slope,firstrun) == 1)
			return;
        
		if (scans == 1)
			firstrun = -1;
        
		if (start != v2)
			if(lsv_experiment(v2,start,slope,firstrun) == 1)
				return;
        
		--scans;
		firstrun = 0;
        
        printf("S\n"); //signal end of scan
	}
	
	printf("D\n"); //signal end of experiment
	
	return;
}

uint8_t lsv_experiment(uint16_t start, uint16_t stop, uint16_t slope, int8_t first_run){
	/**
	 * Perform a LSV experiment.
	 *
	 * Uses porte_int0_lsv to output to USB.
	 * @param start Start potential in dac units.
	 * @param stop Stop potential in dac units.
	 * @param slope Scan rate in dac units/s.
	 * @param first_run Keeps track of number of scans so potentiostat isn't initialized twice or disconnected when doing CV. Set to 2 for normal LSV.
	 */
	
	uint8_t ret = 0;
	
	//check experiment limits
	if(start==stop)
	{
		printf("#ERR: Experiment parameters outside limits\n");
		return ret;
	}
	
//	uint16_t dacindex_start = ceil(start*(65536/(double)3000)+32768);
//	dacindex_stop = ceil(stop*(65536/(double)3000)+32768);
	uint32_t timer_period;
	uint16_t temp_div;


	max5443_set_voltage1(start);
	
	if (first_run == 1 || first_run == 2){
		volt_exp_start();
		ads1255_rdatac();
		ads1255_sync();

		tc_enable(&EXP_TC0_0);
        tc_enable(&EXP_TC1_0);
		tc_set_overflow_interrupt_callback(&EXP_TC0_0, tcf0_ovf_callback);
		tc_set_overflow_interrupt_callback(&EXP_TC1_0, tce1_ovf_callback_lsv);
		tc_set_cca_interrupt_callback(&EXP_TC1_0, lsv_cca_callback);
		portd_int0_callback = porte_int0_lsv; //ADC read

		//set EVCH0 event
		EVSYS.CH0MUX = EVSYS_CHMUX_TCD0_OVF_gc;
		EVSYS.CH0CTRL = 0;

		timer_period = ceil(1/(double)slope*(F_CPU));
		temp_div = ceil(timer_period/65536.);
		
		if (temp_div <= 1)
			tc_write_clock_source(&EXP_TC0_0,TC_CLKSEL_DIV1_gc);
		else if (temp_div == 2){
			tc_write_clock_source(&EXP_TC0_0,TC_CLKSEL_DIV2_gc);
			timer_period /= 2;
		}
		else if (temp_div <= 4){
			tc_write_clock_source(&EXP_TC0_0,TC_CLKSEL_DIV4_gc);
			timer_period /= 4;
		}
		else if (temp_div <= 8){
			tc_write_clock_source(&EXP_TC0_0,TC_CLKSEL_DIV8_gc);
			timer_period /= 8;
		}
		else if (temp_div <= 64){
			tc_write_clock_source(&EXP_TC0_0,TC_CLKSEL_DIV64_gc);
			timer_period /= 64;
		}
		else if (temp_div <= 256){
			tc_write_clock_source(&EXP_TC0_0,TC_CLKSEL_DIV256_gc);
			timer_period /= 256;
		}
		else if (temp_div <= 1024){
			tc_write_clock_source(&EXP_TC0_0,TC_CLKSEL_DIV1024_gc);
			timer_period /= 1024;
		}
		else{
			printf("ERR: Frequency/ADC rate is too low\n");
			return ret;
		}

		ads1255_wakeup();
		tc_write_period(&EXP_TC1_0, 0xffff);
		tc_write_period(&EXP_TC0_0, (uint16_t)timer_period);

 	}
	
	EXP_TC1_0.CNT = start;
	
	if (stop > start)
	{
		up = 1;
		tc_set_direction(&EXP_TC1_0, TC_UP);
	}
	else
	{
		up = -1;
		tc_set_direction(&EXP_TC1_0, TC_DOWN);
	}
	
	tc_write_cc(&EXP_TC1_0, TC_CCA, stop);
	tc_enable_cc_channels(&EXP_TC1_0, TC_CCAEN);
	EXP_TC0_0.CNT = 0;
	
	tc_set_cca_interrupt_level(&EXP_TC1_0, TC_INT_LVL_HI); //Stop experiment
	tc_set_overflow_interrupt_level(&EXP_TC0_0, TC_OVFINTLVL_LO_gc); //Set DAC
	PORTD.INTCTRL = PORT_INT0LVL_MED_gc; //ADC read
	
	tc_write_clock_source(&EXP_TC1_0, TC_CLKSEL_EVCH0_gc);
	
	//Experiment run with interrupts
	while (up != 0){
		if (udi_cdc_is_rx_ready()){
			if (getchar()=='a'){
				tce1_ovf_callback_lsv();
				ret = 1;
				goto aborting;
				
			}
		}
	}
	
	if (first_run == -1 || first_run == 2)
	{
		aborting:
			tc_disable(&EXP_TC0_0);
			EXP_TC0_0.CNT = 0x0;
			tc_disable(&EXP_TC1_0);
			volt_exp_stop();
			ads1255_standby();
			return ret;
	}
	
	return ret;
}

static void porte_int0_lsv(void){
	/**
	 * ISR for taking LSV measurements.
	 */
	struct
	{
		uint16_t index;
		int32_t result;
	} data;
	
 	data.result = ads1255_read_fast24();

	static uint16_t last_value = 0;
	uint32_t current = EXP_TC1_0.CNT;
	data.index = (current+last_value)>>1; //DAC value is average of current and last timer - approximation of center of averaging window
	
	printf("B\n");
	udi_cdc_write_buf(&data, 6);
	last_value = (uint16_t)current;
	printf("\n");
	
	return;
}

static void tcf0_ovf_callback(void){
	max5443_set_voltage1(EXP_TC1_0.CNT);
}

static void tce1_ovf_callback_lsv(void){
	PORTD.INTCTRL = PORT_INT0LVL_OFF_gc;
	tc_set_overflow_interrupt_level(&EXP_TC0_0, TC_OVFINTLVL_OFF_gc);
	tc_set_overflow_interrupt_level(&EXP_TC1_0, TC_OVFINTLVL_OFF_gc);
	up = 0;
	return;
}

static void lsv_cca_callback(void){
	PORTD.INTCTRL = PORT_INT0LVL_OFF_gc;
	tc_set_overflow_interrupt_level(&EXP_TC0_0, TC_OVFINTLVL_OFF_gc);
	tc_set_cca_interrupt_level(&EXP_TC1_0, TC_INT_LVL_OFF);
	up = 0;
	return;
}

#if BOARD_VER_MAJOR == 1 && BOARD_VER_MINOR >= 2

void pot_experiment(uint16_t time_seconds, uint8_t exp_type){
	/**
	 * Performs a potentiometry experiment.
	 *
	 * @param time_seconds Time until automatic stop. If 0, can only be canceled by abort signal.
	 * @param exp_type Type of experiment, POT_OCP for OCP, POT_POTENT for potentiometry
	 */
	while (RTC.STATUS & RTC_SYNCBUSY_bm);
	RTC.PER = 999;
	while (RTC.STATUS & RTC_SYNCBUSY_bm);
	RTC.CTRL = RTC_PRESCALER_DIV1_gc; //1ms tick
	RTC.CNT = 0;
	
	EVSYS.CH0MUX = EVSYS_CHMUX_RTC_OVF_gc; //EV CH0 -- RTC overflow 1s
	
	portd_int0_callback = portd_int0_ca; //ADC interrupt
	
	tc_enable(&EXP_TC0_0);
	
	ads1255_mux(ADS_MUX_POT);
	ads1255_rdatac();
	ads1255_wakeup();
	
	tc_write_period(&EXP_TC0_0,0xffff);
	tc_write_clock_source(&EXP_TC0_0, TC_CLKSEL_EVCH0_gc);
	tc_set_direction(&EXP_TC0_0, TC_UP);
	
	up = 1;
	if (time_seconds >= 1){ //only enable interrupt if non-zero timeout specified
		tc_set_cca_interrupt_callback(&EXP_TC0_0, ca_cca_callback);
		tc_write_cc(&EXP_TC0_0, TC_CCA, time_seconds-1);
		tc_enable_cc_channels(&EXP_TC0_0, TC_CCAEN);
		tc_clear_cc_interrupt(&EXP_TC0_0, TC_CCA);
		tc_set_cca_interrupt_level(&EXP_TC0_0, TC_INT_LVL_MED);
	}
	
	if (exp_type == POT_OCP)
	{
		ocp_exp_start();
	}
	else if (exp_type == POT_POTENT)
	{
		pot_exp_start();
	}
		
	RTC.CNT=0;
	PORTD.INTCTRL = PORT_INT0LVL_LO_gc;
	EXP_TC0_0.CNT = 0;
	
	while (up !=0){
		if (udi_cdc_is_rx_ready()){
			if (getchar() == 'a'){
				ca_cca_callback();
				printf("##ABORT\n");
				goto aborting;
			}
		}
	}
	
	aborting:
		tc_set_cca_interrupt_level(&EXP_TC0_0, TC_INT_LVL_OFF);
		tc_write_clock_source(&EXP_TC0_0, TC_CLKSEL_OFF_gc);
		tc_disable(&EXP_TC0_0);
		volt_exp_stop();
		ads1255_standby();

		return;
}
#endif

void pmt_idle(void){
    max5443_set_voltage1(65535);
    ioport_set_pin_level(PIN_POT_2ELECTRODE, 1);
    delay_ms(100);
    ioport_set_pin_level(PIN_POT_CE, 1);
    
    while (1){
        if (udi_cdc_is_rx_ready()){
            if (getchar() == 'a'){
                printf("##ABORT\n");
                // Doesn't disconnect control line to minimize time this is floating
                return;
            }
        }
    }
}

void ca_experiment(uint16_t steps, uint16_t step_dac[], uint16_t step_seconds[]){
	/**
	 * Performs a chronoamperometry experiment.
	 *
	 * @param steps Total number of steps.
	 * @param step_dac[] Array containing DAC indices.
	 * @param step_seconds[] Array containing step durations in seconds.
	 */
	while (RTC.STATUS & RTC_SYNCBUSY_bm);
	RTC.PER = 999;
	while (RTC.STATUS & RTC_SYNCBUSY_bm);
	RTC.CTRL = RTC_PRESCALER_DIV1_gc; //1ms tick
	RTC.CNT = 0;
	
	EVSYS.CH0MUX = EVSYS_CHMUX_RTC_OVF_gc; //EV CH0 -- RTC overflow 1s
	
	portd_int0_callback = portd_int0_ca; //ADC interrupt
	
	tc_enable(&EXP_TC0_0);
	tc_set_cca_interrupt_callback(&EXP_TC0_0, ca_cca_callback);
	
	ads1255_rdatac();
	ads1255_wakeup();
	
	tc_write_period(&EXP_TC0_0,0xffff);
	tc_write_clock_source(&EXP_TC0_0, TC_CLKSEL_EVCH0_gc);
	tc_set_direction(&EXP_TC0_0, TC_UP);
	tc_enable_cc_channels(&EXP_TC0_0, TC_CCAEN);
	tc_set_cca_interrupt_level(&EXP_TC0_0, TC_INT_LVL_MED);
	
	EXP_TC0_0.CNT = 0;
	
	max5443_set_voltage1(step_dac[0]);
	volt_exp_start();
	
	for (uint8_t i = 0; i < steps; ++i)
	{
		up = 1;
		tc_write_cc(&EXP_TC0_0, TC_CCA, EXP_TC0_0.CNT+step_seconds[i]-1);
		RTC.CNT=0;
		max5443_set_voltage1(step_dac[i]);
		printf("#DAC: %u\n", step_dac[i]);
		PORTD.INTCTRL = PORT_INT0LVL_LO_gc;
		while (up !=0){
			if (udi_cdc_is_rx_ready()){
				if (getchar() == 'a'){
					ca_cca_callback();
					printf("##ABORT\n");
					goto aborting;
				}
			}
		}
	}
	
	aborting:
		tc_set_cca_interrupt_level(&EXP_TC0_0, TC_INT_LVL_OFF);
		tc_write_clock_source(&EXP_TC0_0, TC_CLKSEL_OFF_gc);
		tc_disable(&EXP_TC0_0);
		volt_exp_stop();
		ads1255_standby();

		return;
}

static void portd_int0_ca(void){
	struct
	{
		uint16_t time1;
		uint16_t time2;
		int32_t current;
	} data;
	
	data.time1 = EXP_TC0_0.CNT;
	data.time2 = RTC.CNT;
	data.current = ads1255_read_fast24();

	printf("B\n");
	udi_cdc_write_buf(&data, 8);
	printf("\n");
}

static void ca_cca_callback(void){
	/**
	 * Interrupt handler for CA. Triggers when counter matches CC to stop potential step.
	 *
	 */
	PORTD.INTCTRL = PORT_INT0LVL_OFF_gc;