/*******************************************************
Project : U/I PANELMETER "ATM8-DVM-1"
Version : 1.0
Date    : 27.01.2015
Author  : Alexander C. Frank
Company : CHANGPUAK.CH
Comments: 
PCB: DVM-ATMEGA-001.T3001
Codevision V2.60 Advanced

Chip type               : ATmega8L
Program type            : Application
AVR Core Clock frequency: 10.000000 MHz
Memory model            : Small
External RAM size       : 0
Data Stack size         : 256
*******************************************************/

#include <mega8.h>

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


// Declare your global variables here
// Anode
#define SegA PORTD.2
#define SegB PORTD.0
#define SegC PORTD.5
#define SegD PORTD.4
#define SegE PORTD.3
#define SegF PORTD.1
#define SegG PORTD.6
// Cathode
#define Cat1 PORTB.0
#define Cat2 PORTB.1
#define Cat3 PORTB.2
#define Cat4 PORTD.7
// Characters

unsigned char digit ;

unsigned char is_a_thermometer = 0;

unsigned int timer ;    // READ ADC ONLY ONCE PER SECOND
unsigned int i ;        // LOOP COUNTER

float voltage ;


unsigned long int ADC7;
   float correction = 1.0 ;         // DC VOLTAGE
// float correction = 0.25 ;        // DC CURRENT WITH 1 OHM SHUNT
// float correction = 0.707106 ;    // AC VOLTAGE (SINE) EFFECTIVE VOLTAGE       
// float correction = 0.263157 ;    // AC CURRENT WITH 1 OHM SHUNT. WORKS FOR MY 10% SHUNT.

volatile char lcd_buffer[4];

// float to array aka sprintf //////////////////////////////////////////////////////
void array_me(float wert)
{
// digit 0, n*1000 ////////////////
lcd_buffer[0]=48;
while (wert >= 1000) 
{
lcd_buffer[0] = lcd_buffer[0] + 1;
wert = wert - 1000;
};
// digit 1, n*100 ////////////////
lcd_buffer[1]=48;
while (wert >= 100) 
{
lcd_buffer[1] = lcd_buffer[1] + 1;
wert = wert - 100;
};
// digit 2, n*10 ////////////////
lcd_buffer[2]=48;
while (wert >= 10) 
{
lcd_buffer[2] = lcd_buffer[2] + 1;
wert = wert - 10;
}
// digit 3, n*1 ////////////////
lcd_buffer[3]=48;
while (wert >= 1) 
{
lcd_buffer[3] = lcd_buffer[3] + 1;
wert = wert -1;
}
// KILL LEADING ZERO
if (lcd_buffer[0]==48) { lcd_buffer[0] = 32;};


}
// float to array aka sprintf //////////////////////////////////////////////////////




// Timer 0 overflow interrupt service routine 4.992 ms  ///////////////////////////////////////
interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
// Reinitialize Timer 0 value
TCNT0=0x3D;
// Switch all digits OFF to avoid flickering
Cat1 = 0; Cat2 = 0; Cat3 = 0; Cat4 = 0;
SegA = 0; SegB = 0; SegC = 0; SegD = 0; SegE = 0; SegF = 0; SegG = 0;
// Proceed to next digit
digit++;
if (digit > 3) {digit = 0; };

      switch (lcd_buffer[digit]) {
        case 32 : SegA = 0; SegB = 0; SegC = 0; SegD = 0; SegE = 0; SegF = 0; SegG = 0; break;  // SPACE
        case 48 : SegA = 1; SegB = 1; SegC = 1; SegD = 1; SegE = 1; SegF = 1; SegG = 0; break; 
        case 49 : SegA = 0; SegB = 1; SegC = 1; SegD = 0; SegE = 0; SegF = 0; SegG = 0; break; 
        case 50 : SegA = 1; SegB = 1; SegC = 0; SegD = 1; SegE = 1; SegF = 0; SegG = 1; break;
        case 51 : SegA = 1; SegB = 1; SegC = 1; SegD = 1; SegE = 0; SegF = 0; SegG = 1; break;
        case 52 : SegA = 0; SegB = 1; SegC = 1; SegD = 0; SegE = 0; SegF = 1; SegG = 1; break;
        case 53 : SegA = 1; SegB = 0; SegC = 1; SegD = 1; SegE = 0; SegF = 1; SegG = 1; break;
        case 54 : SegA = 1; SegB = 0; SegC = 1; SegD = 1; SegE = 1; SegF = 1; SegG = 1; break;
        case 55 : SegA = 1; SegB = 1; SegC = 1; SegD = 0; SegE = 0; SegF = 0; SegG = 0; break;
        case 56 : SegA = 1; SegB = 1; SegC = 1; SegD = 1; SegE = 1; SegF = 1; SegG = 1; break;
        case 57 : SegA = 1; SegB = 1; SegC = 1; SegD = 1; SegE = 0; SegF = 1; SegG = 1; break;
        case 67 : SegA = 1; SegB = 0; SegC = 0; SegD = 1; SegE = 1; SegF = 1; SegG = 0; break;
        case 69 : SegA = 1; SegB = 0; SegC = 0; SegD = 1; SegE = 1; SegF = 1; SegG = 1; break;
        case 72 : SegA = 0; SegB = 1; SegC = 1; SegD = 0; SegE = 1; SegF = 1; SegG = 1; break;
        case 76 : SegA = 0; SegB = 0; SegC = 0; SegD = 1; SegE = 1; SegF = 1; SegG = 0; break;
        case 80 : SegA = 1; SegB = 1; SegC = 0; SegD = 0; SegE = 1; SegF = 1; SegG = 1; break;
        case 248 : SegA = 1; SegB = 1; SegC = 0; SegD = 0; SegE = 0; SegF = 1; SegG = 1; break;
        default :  SegA = 0; SegB = 0; SegC = 0; SegD = 0; SegE = 0; SegF = 0; SegG = 0;
      }; 
            
// Switch digit ON
if (digit == 0) { Cat1 = 1; };
if (digit == 1) { Cat2 = 1; };
if (digit == 2) { Cat3 = 1; };
if (digit == 3) { Cat4 = 1; };

// Increase "PAUSE" timer
timer++;
}
// Timer 0 overflow interrupt service routine 4.992 ms  ///////////////////////////////////////






#define ADC_VREF_TYPE ((0<<REFS1) | (0<<REFS0) | (0<<ADLAR))

// Read the AD conversion result
unsigned int read_adc(unsigned char adc_input)
{
 
ADMUX=adc_input | ADC_VREF_TYPE;
// Delay needed for the stabilization of the ADC input voltage
delay_us(10);
// Start the AD conversion
ADCSRA|=(1<<ADSC);
// Wait for the AD conversion to complete
while ((ADCSRA & (1<<ADIF))==0);
ADCSRA|=(1<<ADIF);
return ADCW;
 
}

void main(void)
{
// Declare your local variables here

// Input/Output Ports initialization
// Port B initialization
// Function: Bit7=In Bit6=In Bit5=In Bit4=In Bit3=In Bit2=Out Bit1=Out Bit0=Out 
DDRB=(0<<DDB7) | (0<<DDB6) | (0<<DDB5) | (0<<DDB4) | (0<<DDB3) | (1<<DDB2) | (1<<DDB1) | (1<<DDB0);
// State: Bit7=T Bit6=T Bit5=T Bit4=T Bit3=T Bit2=0 Bit1=0 Bit0=0 
PORTB=(0<<PORTB7) | (0<<PORTB6) | (0<<PORTB5) | (0<<PORTB4) | (0<<PORTB3) | (0<<PORTB2) | (0<<PORTB1) | (0<<PORTB0);

// Port C initialization
// Function: Bit6=In Bit5=In Bit4=In Bit3=In Bit2=In Bit1=In Bit0=In 
DDRC=(0<<DDC6) | (0<<DDC5) | (0<<DDC4) | (0<<DDC3) | (0<<DDC2) | (0<<DDC1) | (0<<DDC0);
// State: Bit6=T Bit5=T Bit4=T Bit3=T Bit2=T Bit1=T Bit0=T 
PORTC=(0<<PORTC6) | (0<<PORTC5) | (0<<PORTC4) | (0<<PORTC3) | (0<<PORTC2) | (0<<PORTC1) | (0<<PORTC0);

// Port D initialization
// Function: Bit7=Out Bit6=Out Bit5=Out Bit4=Out Bit3=Out Bit2=Out Bit1=Out Bit0=Out 
DDRD=(1<<DDD7) | (1<<DDD6) | (1<<DDD5) | (1<<DDD4) | (1<<DDD3) | (1<<DDD2) | (1<<DDD1) | (1<<DDD0);
// State: Bit7=0 Bit6=0 Bit5=0 Bit4=0 Bit3=0 Bit2=0 Bit1=0 Bit0=0 
PORTD=(0<<PORTD7) | (0<<PORTD6) | (0<<PORTD5) | (0<<PORTD4) | (0<<PORTD3) | (0<<PORTD2) | (0<<PORTD1) | (0<<PORTD0);

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 39.063 kHz
TCCR0=(1<<CS02) | (0<<CS01) | (0<<CS00);
TCNT0=0x3D;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer1 Stopped
// Mode: Normal top=0xFFFF
// OC1A output: Disconnected
// OC1B output: Disconnected
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=(0<<COM1A1) | (0<<COM1A0) | (0<<COM1B1) | (0<<COM1B0) | (0<<WGM11) | (0<<WGM10);
TCCR1B=(0<<ICNC1) | (0<<ICES1) | (0<<WGM13) | (0<<WGM12) | (0<<CS12) | (0<<CS11) | (0<<CS10);
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer2 Stopped
// Mode: Normal top=0xFF
// OC2 output: Disconnected
ASSR=0<<AS2;
TCCR2=(0<<PWM2) | (0<<COM21) | (0<<COM20) | (0<<CTC2) | (0<<CS22) | (0<<CS21) | (0<<CS20);
TCNT2=0x00;
OCR2=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=(0<<OCIE2) | (0<<TOIE2) | (0<<TICIE1) | (0<<OCIE1A) | (0<<OCIE1B) | (0<<TOIE1) | (1<<TOIE0);

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
MCUCR=(0<<ISC11) | (0<<ISC10) | (0<<ISC01) | (0<<ISC00);

// USART initialization
// USART disabled
UCSRB=(0<<RXCIE) | (0<<TXCIE) | (0<<UDRIE) | (0<<RXEN) | (0<<TXEN) | (0<<UCSZ2) | (0<<RXB8) | (0<<TXB8);

// Analog Comparator initialization
// Analog Comparator: Off
ACSR=(1<<ACD) | (0<<ACBG) | (0<<ACO) | (0<<ACI) | (0<<ACIE) | (0<<ACIC) | (0<<ACIS1) | (0<<ACIS0);

// ADC initialization
// ADC Clock frequency: 625.000 kHz
// ADC Voltage Reference: AREF pin
ADMUX=ADC_VREF_TYPE;
ADCSRA=(1<<ADEN) | (0<<ADSC) | (0<<ADFR) | (0<<ADIF) | (0<<ADIE) | (1<<ADPS2) | (0<<ADPS1) | (0<<ADPS0);
// SFIOR=;  ??? Vermutlich Leiche :-)

// SPI initialization
// SPI disabled
SPCR=(0<<SPIE) | (0<<SPE) | (0<<DORD) | (0<<MSTR) | (0<<CPOL) | (0<<CPHA) | (0<<SPR1) | (0<<SPR0);

// TWI initialization
// TWI disabled
TWCR=(0<<TWEA) | (0<<TWSTA) | (0<<TWSTO) | (0<<TWEN) | (0<<TWIE);

// Global enable interrupts
#asm("sei")

timer = 0;
// IRQ COUNTS UP in 4.9 ms steps

// DISPLAY "PLL"
while (timer < 200) 
{
lcd_buffer[0] = 80;
lcd_buffer[1] = 76;
lcd_buffer[2] = 76;
lcd_buffer[3] = 32;
};

// DISPLAY "2015"
while (timer < 400) 
{
lcd_buffer[0] = 50;
lcd_buffer[1] = 48;
lcd_buffer[2] = 49;
lcd_buffer[3] = 53;
};



while (1)
      {
      // READ THE ADC
      if ((digit==2)&&(timer > 64)&&( is_a_thermometer == 0 )) 
      { 
      i = 0 ;
      voltage = 0 ;

      do  {  
      ADC7 = read_adc(0x07);
      voltage = voltage +  ADC7 ;
      i = i + 1;
      }
      while (i < 20);

      voltage = voltage / 2 ;
      array_me(voltage);
      timer = 0; 
      
      };
      
      // MAXIMUM VALUE IS 1024  (10 Bit)
      if (ADC7 > 1000) 
      {
      lcd_buffer[0] = 72;   // H
      lcd_buffer[1] = 69;   // E
      lcd_buffer[2] = 76;   // L
      lcd_buffer[3] = 80;   // P
      };   
      
      
      // THERMOMETER MODE DEGREE CELSIUS  //////////////////////////////////////////////////////////////////
      if ((digit==2)&&(timer > 1999)&&( is_a_thermometer == 1 )) 
      {  
      ADC7 = read_adc(0x07);          
      voltage = 25 * ADC7 ;  
      // sprintf(lcd_buffer,"%2.0f",voltage);
      array_me(voltage);
      timer = 0; 
      
      lcd_buffer[2] = 248;   // degree
      lcd_buffer[3] = 67;    // C 
 
      };
      // THERMOMETER MODE DEGREE CELSIUS  //////////////////////////////////////////////////////////////////
      

      }
}