/*
 * *      esr.c  ... firmware for an ESR-meter based on atmega MCU
 * *
 * *      Copyright (C) 2010 Jiri Pittner <jiri@pittnerovi.com>
 * *
 * *      This program 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.
 * *
 * *      This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 * *
 * *
 * */
#include "backward.h"
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <setjmp.h>
#include <avr/sleep.h>
#include <stdlib.h>

//this bridge configuration does not seem to be a proper circuit for capacity measurement
//this is also not feasible due to anharmonic signal - everything works only for negligible Xc
//phase shifts at the bridge are wrongly evaluated by this circuit which compares both bridge halves at a given time
//it can be used ONLY when Xc is completely negligible with respect to R 
//-> user has to set manually appropriate measurement frequency according to the capacitance value
//But VERY big capaciors, like 10000uF with very small ESR below about 0R2 will not be measured accurately too
//Nevertheless, it is good enough to identify bad capacitors for repair work

//ATmega8L at 7.3728 MHz
//!!!! brownout off - fuse L =0xef
//PB0 - switching of power
//PB1=oc1a - signal generation
//PD5 RS
//PD6 RW
//PD7 E
//PC0-PC3=DB4-7 display
//PD2=int0= right button
//PC4 = voltage battery
//PC5= measurement
//reserved for future gain control: PD3,PD4,PB2



void printP (PGM_P string){
        char c;
        c=pgm_read_byte(string);
                   while (c) {
                   loop_until_bit_is_set(UCSRA, UDRE);
                   UDR = c;
                   c=pgm_read_byte(++string);
                   }
                   return;
                 }



void print (char *string){                                     
                   while (*string) {                                            
                   loop_until_bit_is_set(UCSRA, UDRE);                            
                   UDR = *string++;
                   }                                                            
                   return;                                                      
                 }                                                              


void scan(char *string){
char c;
	do 	{
		do {
			loop_until_bit_is_set(UCSRA, RXC);	
			c =UDR;
			} while bit_is_set(UCSRA, FE);	
		*string++ = c;
		//echo the character
		loop_until_bit_is_set(UCSRA, UDRE);
		UDR = c;
		} while ( c != '\r' );
	loop_until_bit_is_set(UCSRA, UDRE);
        UDR = '\n';
	string[-1]=0;
	}

#define UCR UCSRB
#define UART_INIT(baud) { \
UBRRH=0; \
UBRRL= (XTAL/baud+15)/16-1; \
UCSRB=(1<<TXEN)|(1<<RXEN); \
UCSRC=(1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1)|(1<<USBS); }


#define itoa10(N,S) itoa(N,S,10)

uint8_t voltage(void) //integer, in 0.1 V, after voltage drop on diode and PNP transistor
{
uint32_t v;
//enable A/D converter in single conversion mode
ADMUX= 4;
ADCSRA= (1<<ADEN)|(1<<ADIF)|(1<<ADSC)|7; 
loop_until_bit_is_set(ADCSRA,ADIF);
v=ADCL;
v|= (ADCH<<8);
//disable ADC again to save power consumption
ADCSRA=0;
//v*=5.0/1023*183/33*10
v*=1110;
return (v+2048)>>12;
}

uint32_t measure(uint16_t nrep) 
{
uint16_t v;
uint32_t vv=0;
//enable A/D converter in single conversion mode
ADMUX= 5;
while(nrep-- > 0)
	{
	ADCSRA= (1<<ADEN)|(1<<ADIF)|(1<<ADSC)|7; 
	loop_until_bit_is_set(ADCSRA,ADIF);
	v=ADCL;
	v|= (ADCH<<8);
	vv += v;
	}
//disable ADC again to save power consumption
ADCSRA=0;
return vv;
}


void delay_xs(uint16_t xs) //xs takes 4 clocks time
{
        asm volatile (
        "\n"
        "L_dl1%=:" "\n\t"
        "sbiw %0, 1" "\n\t"
        "brne L_dl1%=" "\n\t"
        : "=&w" (xs)
        );
        return;
}
__attribute__((noinline));

void delay_ms(uint16_t ms) //ms takes 1/1000 s
{
while(ms--) delay_xs(XTAL/4/1000);
}


//lcd routines !!! nonstandard pins used !!!

#define lcd_delay 50

void lcd_w4bit(uint8_t rs, uint8_t x)
{
sbi(PORTD,PD7); //E
if(rs) sbi(PORTD,PD5); else cbi(PORTD,PD5);
cbi(PORTC,PC0); cbi(PORTC,PC1); cbi(PORTC,PC2); cbi(PORTC,PC3);
delay_xs(lcd_delay);
PORTC |= x&0x0f;
delay_xs(lcd_delay);
cbi(PORTD,PD7); //E
delay_xs(lcd_delay);
sbi(PORTD,PD7);
delay_xs(lcd_delay);
}


void lcd_init4bit(void)
{
sbi(DDRC,PC0);
sbi(DDRC,PC1);
sbi(DDRC,PC2);
sbi(DDRC,PC3);
sbi(DDRD,PD5);
sbi(DDRD,PD6);
sbi(DDRD,PD7);

delay_xs(20000);
lcd_w4bit(0,3);
delay_xs(10000);
lcd_w4bit(0,3);
delay_xs(500);
lcd_w4bit(0,3);
lcd_w4bit(0,2);
}

void lcd_wbyte(uint8_t rs, uint8_t x)
{
lcd_w4bit(rs,x>>4);
lcd_w4bit(rs,x);
}

void lcd_clear(void)
{
lcd_wbyte(0,0x01);
delay_xs(30000);
}

void lcd_init(void)
{
lcd_init4bit();
lcd_wbyte(0,0x28);
lcd_wbyte(0,0x08);
lcd_clear();
lcd_wbyte(0,0x06);
lcd_wbyte(0,0x0c);
}

void lcd_print(char *t)
{
while(*t) if(*t=='\n') {++t; lcd_wbyte(0,0xc0);} else lcd_wbyte(1,*t++);
}

void lcd_printP(char *t)
{
char c=pgm_read_byte(t);
while(c) if(c=='\n') {c=pgm_read_byte(++t); lcd_wbyte(0,0xc0);} else {lcd_wbyte(1,c); c=pgm_read_byte(++t);}
}

void lcd_print8(char *t)
{
uint8_t l=0;
while(*t) {lcd_wbyte(1,*t++); ++l;}
while(l<8) {lcd_wbyte(1,' '); ++l;}
}

void lcd_cursor(uint8_t r, uint8_t c)
{
lcd_wbyte(0,0x80+c+(r<<6));
}


//start signal generation at x kilohertz
void siggen(uint32_t x)
{
if(x==0)
	{
	cbi(DDRB,PB1);
	TCCR1B=0;
	TCCR1A=0;
	return;
	}
sbi(DDRB,PB1);
TCNT1=0;
OCR1A= XTAL/(2*x);
TCCR1A= (1<<COM1A0)|(1<<WGM10)|(1<<WGM11);
TCCR1B= (1<<WGM13) | (1<<WGM12)| CK;
return;
}


void poweroff(void)
{
siggen(0);
cbi(PORTB,PB0); sbi(DDRB,PB0);
delay_ms(10000);
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
}

static volatile uint8_t freqindex=4;
#define N_freqs 9
static int32_t freqs[N_freqs]={200000,100000,50000,20000,10000,5000,2000,1000,500};

//ADC readout at disconnected probes <= UNBALLANCE<<LOGNREP
#define UNBALLANCE 40L
#define LOGNREP 11
//results of the fits - to be calibrated
static uint32_t Acoef[N_freqs]={237538,298380,321480,332250,334720,335810,335679,335234,341219};
static uint32_t Bcoef[N_freqs]={75235977,174898100,241015600,267660370,273247180,275929590,279636137,284624622,297318978};
//this is actually redundant with Acoef, but it is not obtained from fits, but as read-out value with shorted probes after Acoef and Bcoef have been fixed
static uint32_t Ccoef[N_freqs]={200,120,70,20,10,0,0,0,23}; //zero calibration in milliohm

uint32_t adc2milliohm(uint32_t adc, uint8_t i, uint8_t shift) 
{
uint64_t tmp=Bcoef[i]; //we avoid floating point to save flash size
uint32_t r= (tmp<<shift)/adc; 
if(r<Acoef[i]) return 0; else r -= Acoef[i];
r>>= 4;
if(r<Ccoef[i]) return 0; else r -= Ccoef[i];
return r;
}

void printfreq(int32_t f, char *t)
{
if(f<0)
        {
        strcpy(t,"N/A");
        return;
        }
strcpy(t,"   . kHz");
uint16_t ff=f/100;
t[4]= '0' + ff%10; ff/=10;
t[2]= '0' + ff%10; ff/=10;
if(ff) t[1]= '0' + ff%10; ff/=10;
if(ff) t[0]= '0' + ff%10; ff/=10;
}

void printvoltage(uint8_t f, char *t)
{
strcpy(t,"   . V ");
t[4]= '0' + f%10; f/=10;
t[2]= '0' + f%10; f/=10;
if(f) t[1]= '0' + f%10; f/=10;
}

void printmilliohm(uint32_t ff, char *t) //in tenths
{
if(ff < 100000)
{
strcpy(t,"R=  .   ");
t[7]= '0' + ff%10; ff/=10;
t[6]= '0' + ff%10; ff/=10;
t[5]= '0' + ff%10; ff/=10;
t[3]= '0' + ff%10; ff/=10;
if(ff) t[2]= '0' + ff%10; ff/=10;
}
else
{
ff/=10;
strcpy(t,"R=   .  ");
t[7]= '0' + ff%10; ff/=10;
t[6]= '0' + ff%10; ff/=10;
t[4]= '0' + ff%10; ff/=10;
if(ff) t[3]= '0' + ff%10; ff/=10;
if(ff) t[2]= '0' + ff%10; ff/=10;
}
}


static volatile uint8_t buttonpressed=0;
INTERRUPT(SIG_INTERRUPT0)
{
buttonpressed+=1;
if(buttonpressed>=2) cbi(GIMSK,INT0);
}


int main(void)
{
char c[20];
UART_INIT(115200);
printP(PSTR("Start!\n"));

cbi(DDRD,PD2); sbi(PORTD,PD2); //right button
sbi(SREG,7);
cbi(MCUCR,ISC01); sbi(MCUCR,ISC00); //fall edge interrupt
sbi(GIMSK,INT0);

siggen(freqs[freqindex]);

lcd_init(); 
strcpy(c,"Battery \n");
printvoltage(voltage(),c+9);
lcd_print(c);
delay_ms(2000);
lcd_clear();
delay_ms(100);
printfreq(freqs[freqindex],c); lcd_cursor(1,0); lcd_print(c);


uint16_t ii=0;
while(1)
	{
	++ii; //about twice a second
	uint8_t i;
	uint32_t v=measure(1<<LOGNREP);
	sprintf(c,"%ld\n",v); print(c);
	if(v>UNBALLANCE*(1L<<LOGNREP))
		{ ii=0; 
		uint32_t mohm=adc2milliohm(v,freqindex,LOGNREP); printmilliohm(mohm,c);
		}
	else
		{
		strcpy(c,"R= inf  ");
		}
	print(c);print("\n");
	lcd_cursor(0,0);
	lcd_print(c);
	if(buttonpressed>=2)
		{
		freqindex = (freqindex+1)%N_freqs;
		if(freqindex==0) lcd_init();
		siggen(freqs[freqindex]);
		delay_ms(300);
		buttonpressed=0;
		sbi(GIMSK,INT0);
		printfreq(freqs[freqindex],c); lcd_cursor(1,0); lcd_print(c);
		}
	if(ii>=120) break; //poweroff if unused for about a minute
	}

poweroff();
};