AVRを使ったコンデンサー容量計の製作

#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <math.h>

#include "lcd.h"

#define cbi(addr, bit)     addr &= ~(1<<bit)
#define sbi(addr, bit)     addr |=  (1<<bit)

void delay_ms(unsigned int t) {    while(t--)  _delay_ms(1); }

FILE *fp;
double cap;                // capacitance
volatile unsigned long int cnt;        // total timer count
unsigned long int refcnt_l, refcnt_h;    // refarence capacitor timer count
unsigned int ocnt_l, ocnt_h;        // open cirkit capacitance timer count
unsigned int t1cnt;            // timer1 overflow count
unsigned int lt_max;            // limit timer1 overflow count
unsigned char nt, mes_go, mes_err;    // flags
unsigned char mode;            // Hi/Lo mode flag
unsigned char cal_ok;            // calibration check flag


ISR(TIMER1_CAPT_vect)
{
    if(nt > 0) {
        cnt = t1cnt * 65536 + ICR1;
        sbi(PORTD, PD5);
        mes_go = 0;
        sbi(PORTC, PC3);
    } else {
        ADMUX = 1;
        nt++;
        t1cnt = 0;
        TCNT1 = 0x0000;
    }
}

ISR(TIMER1_OVF_vect)
{
    t1cnt++;
    if(mes_go) {
        if(t1cnt > lt_max) {
            mes_err = 1;
            sbi(PORTD, PD5);
            mes_go = 0;
        }
    }
}

void measure()        // measuring capacitance
{
    cbi(PORTC, PC3);
    if(mode == 0) {            // Low mode
        ADMUX = 0;
        nt = 0;
        lt_max = 1200;        // timer1 limit 1200 * 65536 * 0.05us = 3.9s  
        sbi(PORTD, PD2);
    } else {            // High mode
        ADMUX = 1;
        nt = 1;
        lt_max = 12000;        // timer1 limit 12000 * 65536 * 0.05us = 39s
        cbi(PORTD, PD2);
    }
    t1cnt = 0;
    mes_go = 1;
    mes_err = 0;
    cnt = 0;
    TCNT1 = 0x0000;
    cbi(PORTD, PD5);
}

void lcd_write()
{
    lcd_cls();
    lcd_goto(0, 0);
    if(mode)
        fprintf(fp, "Hi mode");
    else 
        fprintf(fp, "Lo mode");
    lcd_goto(1, 0);
    if(mes_err) {
        fprintf(fp, "Error");
    } else {
        if(cap < 0.01) {
            fprintf(fp, "%6.1fpF", cap * 1000000);
        } else {
            if(cap > 10000)
                fprintf(fp, "%6duF", cap);
            else if(cap > 1000)
                fprintf(fp, "%6.1fuF", cap);
            else if(cap > 100)
                fprintf(fp, "%6.2fuF", cap);
            else if(cap > 10)
                fprintf(fp, "%6.3fuF", cap);
            else
                fprintf(fp, "%6.4fuF", cap);
        }
    }
}
void cal_err()
{
    lcd_cls();
    lcd_goto(0, 0);
    fprintf(fp, "Cal Err!");
}

void calibration()
{
    unsigned char tmp_mode;

    tmp_mode = mode;
    cbi(PORTC, PC4);

    mode = 0;
    measure();        // measuring to Low mode open cirkit capacitance
    loop_until_bit_is_set(PIND, PD5);
    delay_ms(200);
    if((cnt > 300) || mes_err) {    // measuring terminal not open 
        cal_err();
        cal_ok = 0;
        return;
    }
    ocnt_l = cnt;
    sbi(PORTD, PD3);        // Low mode refarence capacitor ON 
    delay_ms(200);
    measure();
    loop_until_bit_is_set(PIND, PD5);
    delay_ms(200);
    cbi(PORTD, PD3);
    delay_ms(1);
    refcnt_l = cnt;
    delay_ms(200);

    mode = 1;
    measure();        // measuring to High mode open cirkit capacitance
    loop_until_bit_is_set(PIND, PD5);
    delay_ms(200);
    ocnt_h = cnt;
    sbi(PORTD, PD4);
    delay_ms(200);
    measure();        // High mode refarence capacitor ON 
    loop_until_bit_is_set(PIND, PD5);
    delay_ms(200);
    cbi(PORTD, PD4);
    delay_ms(1);
    refcnt_h = cnt;
    delay_ms(200);

    lcd_cls();
    lcd_goto(1, 0);
    fprintf(fp, "Cal OK"); 
    lcd_goto(0, 0);
    if(tmp_mode == 1)
        fprintf(fp, "Hi mode");
    else
        fprintf(fp, "Lo mode");

    mode = tmp_mode;
    cal_ok = 1;
    sbi(PORTC, PC4);
    sbi(PORTC, PC3);
}

int main()
{
    unsigned char sw1_state, sw2_state, sw3_state;
     
     DDRB = 0b11111111;    // LCD
    DDRC = 0b00011000;    // PC3-4 LED, PC5 SW-input 
    DDRD = 0b00111100;    // PD2-5 output, PD0-1 SW-input

    PORTD = 0b00000011;    // PD0-1 pull up
    PORTC = 0b00100000;    // PC5 pull up

    ADCSRB |= _BV(ACME);    // AIN0 -> ADC0-ADC7
    ADCSRA &= ~_BV(ADEN);    // Disable A/D Conv

    TCCR1A = 0;            // Timer1
    TCCR1B = _BV(ICES1)|_BV(CS10);    // Timer1 InputCapture Edge Select
                    //   and no prescaler
    TIMSK1 = _BV(ICIE1)|_BV(TOIE1);    // Timer1 InputCapture Enable
                    //   and Counter Overflow Enable
    ACSR = _BV(ACIC)|_BV(ACIS1)|_BV(ACIS0);    // Analog Comparator Status Register
    DIDR1 = 3;

    lcd_init();
    lcd_cls();
    fp = fdevopen(lcd_putch, NULL);
    lcd_goto(0, 0);
    fprintf(fp, "CapMeter");
    lcd_goto(1, 0);
    fprintf(fp, "Ver 1.0a");

    sw1_state = sw2_state = sw3_state = 0;
    mes_go = 0;
    mode = 0;
    cal_ok = 0;

    sbi(PORTD, PD5);

    sei();

    delay_ms(1500);

    calibration();

    while(1) {
        if(mes_go) {
            if(t1cnt > lt_max) {    // timer1 timeout chekch
                mes_err = 1;
                sbi(PORTD, PD5);
                mes_go = 0;
            }
        }
        if(bit_is_clear(PINC, PC5)) {
            sw3_state = 1;            
            delay_ms(10);
        }
        if(sw3_state && bit_is_set(PINC, PC5)) {
            sw3_state = 0;
            calibration();
        }
        if(bit_is_clear(PIND, PD0)) {
            sw2_state = 1;            
            delay_ms(10);
        }
        if(sw2_state && bit_is_set(PIND, PD0)) {
            sw2_state = 0;
            lcd_cls();
            lcd_goto(0, 0);
            if(mode == 0) {
                mode = 1;
                fprintf(fp, "Hi mode");
            } else {
                mode = 0;
                fprintf(fp, "Lo mode");
            }
        }
        if(bit_is_clear(PIND, PD1)) {
            sw1_state = 1;            
            delay_ms(10);
        }
        if(sw1_state && bit_is_set(PIND, PD1)) {
            sw1_state = 0;
            if(cal_ok) {
                sbi(PORTD, PD5);
                delay_ms(10);
                measure();
                loop_until_bit_is_set(PIND, PD5);
                if(mode == 0) {
                    if(cnt <= ocnt_l)
                        cap = 0.0;
                    else 
                        cap = (cnt - ocnt_l) / (double)(refcnt_l - ocnt_l) * 0.0001;
                } else {
                    if(cnt <= ocnt_h)
                        cap = 0.0;
                    else
                        cap = (cnt - ocnt_h) / (double)(refcnt_h - ocnt_h) * 0.01;
                }
                lcd_write();
            } else {
                cal_err();
            }
        }
        delay_ms(10);
    }
}