#pragma config STVREN = ON // Stack overflow reset
#pragma config XINST = OFF // Extended instruction set
#pragma config BOREN = ON // BOR Enabled
#pragma config BORV = 0 // BOR Set to "2.0V" nominal setting
#pragma config CP0 = OFF // Code protect disabled
#pragma config FOSC = FRCPLL // Firmware should also enable active clock tuning for this setting
#pragma config SOSCSEL = LOW // SOSC circuit configured for crystal driver mode
#pragma config CLKOEN = OFF // Disable clock output on RA6
#pragma config IESO = OFF // Internal External (clock) Switchover
#pragma config PLLDIV = NODIV // 4 MHz input (from 8MHz FRC / 2) provided to PLL circuit
#pragma config POSCMD = NONE // Primary osc disabled, using FRC
#pragma config FSCM = CSECMD // Clock switching enabled, fail safe clock monitor disabled
#pragma config WPDIS = WPDIS // Program memory not write protected
#pragma config WPCFG = WPCFGDIS // Config word page of program memory not write protected
#pragma config IOL1WAY = OFF // IOLOCK can be set/cleared as needed with unlock sequence
#pragma config LS48MHZ = SYSX2 // Low Speed USB clock divider
#pragma config WDTCLK = LPRC // WDT always uses INTOSC/LPRC oscillator
#pragma config WDTEN = OFF // WDT disabled; SWDTEN can control WDT
#pragma config WINDIS = WDTSTD // Normal non-window mode WDT.
#pragma config VBTBOR = OFF

#define F_CPU 8000000
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

unsigned int n_count=0;

void preset()
{
    DDRB = 0b11111111; // 0xFF
    PORTB = 0b11111111; // 0x00
    
        DDRD = 0b00001111; // 0xFF
        PORTD = 0b00000000; // 0x00
    
    DDRA = 0b00000000;
    PORTA = 0b11111111; // 0x00
}

void timer_ini(void)    //функция инициализации таймера
{
    TCCR1B |= (1<<WGM12); //установка режима работы CTC (сброс по совпадению)
    TIMSK1 |= (1<<OCIE1A); //устанавливаем бит разрешения прерывания первого счётчика по совпадению с OCIR1A (H и L)
    OCR1AH = 0b00001100; //записываем в регистр OCR1A число 3125 (при работе на частоте 8 МГц это будет давать прерывание каждые 0,1 сек)
    OCR1AL = 0b00110101; //
    TCCR1B |= (1<<CS12); //установка делителя 256
    
}

ISR(TIMER1_COMPA_vect) //Прерывание по достижению таймером значения регистра OCR1A (H и L)
{
n_count++;
if (n_count>=200)    {n_count=0;}
}

int main(void)
{
    preset();
    timer_ini();    
    sei(); //глобальное разрешение прерываний
    
    while(1)
    {
        if ((n_count>0)&&(n_count<100)) {PORTB = 0b11111111;}
else
    if ((n_count>100)&&(n_count<=200)) {PORTB = 0b00000000;};        
    }
}

#define F_CPU 8000000
#include <avr/io.h>
#include <stdlib.h>
#include <math.h>
#include <avr/interrupt.h>



//--------------------------------------------------------------------------------------------------------------глобальные переменные-----------------------------------------------------------------
volatile uint8_t R1=0, R2=0, R3=0, R4=0, R5=0, R6=0, R7=0, R8=0; //Переменные значений разрядов индикатора
volatile int16_t ADC_AI_1, ADC_AI_2; //Текущие значения АЦП без фильтрации
volatile float ADC_AI_1_ff, ADC_AI_2_ff, AI_1, AI_2, AI_1_fv, AI_2_fv;//Текущие значения АЦП после фильтрации, аппроксимированных значений аналоговых входов до коррекции и после
volatile int32_t accu1=0, accu2=0; //переменные для оверсемплинга АЦП
volatile uint8_t accu_count1=0, accu_count2=0; //переменные для оверсемплинга АЦП
volatile int16_t koeff_AI1=1;
volatile int16_t koeff_AI2=1;
volatile uint8_t DI_portD_Mask;
volatile uint8_t DI_portA_Mask_no_opros;
volatile uint8_t DI_portA_Mask;

uint8_t tip_AI1=1;
uint16_t calibr_ADC_min_AI1; // Калибровочное минимальное значение АЦП аналогового входа AI1
uint16_t calibr_ADC_max_AI1; // Калибровочное максимальное значение АЦП аналогового входа AI1
int16_t NPI_AI1; // Нижний предел измерения параметра с аналогового входа AI1
int16_t VPI_AI1; // Верхний предел измерения параметра с аналогового входа AI1
uint16_t koef_A_AI1; // Коэффициент коррекции А для параметра с аналогового входа AI1
int16_t koef_B_AI1; // Коэффициент коррекции B для параметра с аналогового входа AI1
uint8_t koef_filtra_AI1; // Коэффициент фильтрации параметра с AI1

uint8_t tip_AI2=2;
uint16_t calibr_ADC_min_AI2; // Калибровочное минимальное значение АЦП аналогового входа AI2
uint16_t calibr_ADC_max_AI2; // Калибровочное максимальное значение АЦП аналогового входа AI2
int16_t NPI_AI2; // Нижний предел измерения параметра с аналогового входа AI2
int16_t VPI_AI2; // Верхний предел измерения параметра с аналогового входа AI2
uint16_t koef_A_AI2; // Коэффициент коррекции А для параметра с аналогового входа AI2
int16_t koef_B_AI2; // Коэффициент коррекции B для параметра с аналогового входа AI2
uint8_t koef_filtra_AI2; // Коэффициент фильтрации параметра с AI2

//------------------------------------------------------------------------------------------------

void preset()//функция установки портов
{


//инициализация порта В
DDRB = 0b10110000; //конфигурация: 0 - вход. 1 - выход
PORTB = 0b01001111; //1 - включение подтягивающих резисторов для входов. 0 - задание выходам порта начальных значений ("отключено" - высокий уровень, "включено" - низкий уровень).
//инициализация порта C
DDRC = 0b11111111; //конфигурация: 0 - вход. 1 - выход
PORTC = 0b01111111; //1 - включение подтягивающих резисторов для входов. 0 - задание выходам порта начальных значений ("отключено" - высокий уровень, "включено" - низкий уровень).
//инициализация порта D
//конфигурация: 0 - вход:
DDRD &=~(1<<PD7); //Настраиваем ножку PD7 в режим входа
DDRD &=~(1<<PD6); //Настраиваем ножку PD6 в режим входа
DDRD &=~(1<<PD5); //Настраиваем ножку PD5 в режим входа
DDRD &=~(1<<PD4); //Настраиваем ножку PD4 в режим входа
DDRD &=~(1<<PD3); //Настраиваем ножку PD3 в режим входа
DDRD |=(1<<PD2); //Настраиваем ножку PD3 в режим вЫхода
//1 - включение подтягивающих резисторов для входов порта D:
PORTD |= (1<<PD7);
PORTD |= (1<<PD6);
PORTD |= (1<<PD5);
PORTD |= (1<<PD4);
PORTD |= (1<<PD3);
//1 - задание выходу №2 порта D начального значения "отключено" - высокий уровень:
PORTD |= (1<<PD2);
}

void symboll(uint8_t symm) //функция отображения символов на индикаторах
{
switch(symm)
{
case 1: SPDR = 0b10111011; break; //цифра 1
case 2: SPDR = 0b10001100; break; //цифра 2
case 3: SPDR = 0b10101000; break; //цифра 3
case 4: SPDR = 0b00111001; break; //цифра 4
case 5: SPDR = 0b01101000; break; //цифра 5
case 6: SPDR = 0b01001000; break; //цифра 6
case 7: SPDR = 0b10111010; break; //цифра 7
case 8: SPDR = 0b00001000; break; //цифра 8
case 9: SPDR = 0b00101000; break; //цифра 9
case 0: SPDR = 0b00001010; break; //цифра 0

case 11: SPDR = 0b10110011; break; //цифра 1 с точкой
case 12: SPDR = 0b10000100; break; //цифра 2 с точкой
case 13: SPDR = 0b10100000; break; //цифра 3 с точкой
case 14: SPDR = 0b00110001; break; //цифра 4 с точкой
case 15: SPDR = 0b01100000; break; //цифра 5 с точкой
case 16: SPDR = 0b01000000; break; //цифра 6 с точкой
case 17: SPDR = 0b10110010; break; //цифра 7 с точкой
case 18: SPDR = 0b00000000; break; //цифра 8 с точкой
case 19: SPDR = 0b00100000; break; //цифра 9 с точкой
case 10: SPDR = 0b00000010; break; //цифра 0 с точкой

case 20: SPDR = 0b00011000; break; //буква А
case 21: SPDR = 0b01001001; break; //буква B
case 22: SPDR = 0b01001110; break; //буква C
case 23: SPDR = 0b10001001; break; //буква D
case 24: SPDR = 0b01001100; break; //буква E
case 25: SPDR = 0b01001010; break; //буква G
case 26: SPDR = 0b11001110; break; //буква I
case 27: SPDR = 0b00010001; break; //буква K
case 28: SPDR = 0b01001111; break; //буква L
case 29: SPDR = 0b11011001; break; //буква N
case 30: SPDR = 0b11001001; break; //буква O
case 31: SPDR = 0b11000001; break; //буква O с точкой
case 32: SPDR = 0b00011100; break; //буква P
case 33: SPDR = 0b11101111; break; //нижнее подчёркивание
case 34: SPDR = 0b11111101; break; //минус
case 35: SPDR = 0b11111111; break; //ничего
case 36: SPDR = 0b10111110; break; //стрелка вверх
case 37: SPDR = 0b11001111; break; //стрелка вниз
case 38: SPDR = 0b11011101; break; //буква R
case 39: SPDR = 0b11010101; break; //буква R с точкой
case 40: SPDR = 0b01101000; break; //буква S
case 41: SPDR = 0b01100000; break; //буква S с точкой
case 42: SPDR = 0b01001101; break; //буква T
case 43: SPDR = 0b11001011; break; //буква U
case 44: SPDR = 0b00001011; break; //буква V
case 45: SPDR = 0b11110001; break; //буква Z
default: SPDR = 0b11111111; //ничего
}
}

void SPI_init()
{
SPCR = ((1<<SPE)|(1<<MSTR));
}

void ADC_init()
{
ADCSRA |= ((1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)); //Разрешение использования АЦП и делитель 64 (частота опроса 125кГц)
ADMUX=0;
}

void ADC_convert(void) //функция чтения каналов АЦП. Первые 2 канала - это аналогоые входы. Остальные 6 каналов - используются как дискретные входы.
{
uint16_t kod_acp=0;
uint8_t lock_0=0; //чтобы за один вызов функции выполнялось только одно преобразование АЦП, а не 0 и 7 в один раз
static float prom_out1=0, prom_out2=0;
unsigned char savee = SREG;


if (ADMUX==7)
{
ADCSRA |= (1<<ADSC); //Начинаем преобразование
while((ADCSRA & (1<<ADSC))) {}; //проверка закончилось ли аналого-цифровое преобразование
savee =SREG;
cli ();
kod_acp = (unsigned int) ADC;
if (kod_acp<300) {DI_portA_Mask_no_opros |= 0b00100000;} else {DI_portA_Mask_no_opros &= 0b11011111;}
lock_0=1;
SREG= savee;
ADMUX=0;
}

if (ADMUX==6)
{
ADCSRA |= (1<<ADSC); //Начинаем преобразование
while((ADCSRA & (1<<ADSC))) {}; //проверка закончилось ли аналого-цифровое преобразование
savee =SREG;
cli ();
kod_acp = (unsigned int) ADC;
if (kod_acp<300) {DI_portA_Mask_no_opros |= 0b00010000;} else {DI_portA_Mask_no_opros &= 0b11101111;}
SREG= savee;
ADMUX=7;
}

if (ADMUX==5)
{
ADCSRA |= (1<<ADSC); //Начинаем преобразование
while((ADCSRA & (1<<ADSC))) {}; //проверка закончилось ли аналого-цифровое преобразование
savee =SREG;
cli ();
kod_acp = (unsigned int) ADC;
if (kod_acp<300) {DI_portA_Mask_no_opros |= 0b00001000;} else {DI_portA_Mask_no_opros &= 0b11110111;}
SREG= savee;
ADMUX=6;
}

if (ADMUX==4)
{
ADCSRA |= (1<<ADSC); //Начинаем преобразование
while((ADCSRA & (1<<ADSC))) {}; //проверка закончилось ли аналого-цифровое преобразование
savee =SREG;
cli ();
kod_acp = (unsigned int) ADC;
if (kod_acp<300) {DI_portA_Mask_no_opros |= 0b00000100;} else {DI_portA_Mask_no_opros &= 0b11111011;}
SREG= savee;
ADMUX=5;
}

if (ADMUX==3)
{
ADCSRA |= (1<<ADSC); //Начинаем преобразование
while((ADCSRA & (1<<ADSC))) {}; //проверка закончилось ли аналого-цифровое преобразование
savee =SREG;
cli ();
kod_acp = (unsigned int) ADC;
if (kod_acp<300) {DI_portA_Mask_no_opros |= 0b00000010;} else {DI_portA_Mask_no_opros &= 0b11111101;}
SREG= savee;
ADMUX=4;
}

if (ADMUX==2)
{
ADCSRA |= (1<<ADSC); //Начинаем преобразование
while((ADCSRA & (1<<ADSC))) {}; //проверка закончилось ли аналого-цифровое преобразование
savee =SREG;
cli ();
kod_acp = (unsigned int) ADC;
if (kod_acp<300) {DI_portA_Mask_no_opros |= 0b00000001;} else {DI_portA_Mask_no_opros &= 0b11111110;}
SREG= savee;
ADMUX=3;
}

if (ADMUX==1)
{
ADCSRA |= (1<<ADSC); //Начинаем преобразование
while((ADCSRA & (1<<ADSC))) {}; //проверка закончилось ли аналого-цифровое преобразование
savee =SREG;
cli ();
accu2 += (int32_t) ADC;//Оверсемплинг AI2. Было 10 бит, стало 13
accu_count2++;
if (accu_count2>=64)
{
ADC_AI_2=(int16_t)(accu2/8); accu_count2=0; accu2=0;//фильтрация AI2
ADC_AI_2_ff=prom_out2+(ADC_AI_2-prom_out2)/(float)koef_filtra_AI2; //экспоненциальный фильтр
prom_out2=ADC_AI_2_ff;

if (tip_AI2==1)
{
AI_2= ((float)((ADC_AI_2_ff-calibr_ADC_min_AI2)/(calibr_ADC_max_AI2-calibr_ADC_min_AI2)) * (((float)(VPI_AI2-NPI_AI2))/koeff_AI2)+ ((float)(NPI_AI2/koeff_AI2)));//Аппроксимация AI2
AI_2_fv=AI_2*(((float)koef_A_AI2)/1000)+(float)koef_B_AI2/koeff_AI2; //Коррекция AI2
}
else {AI_2=0;AI_2_fv=0;}
}

SREG= savee;
ADMUX=2;
}

if ((ADMUX==0) && (lock_0==0))
{
ADCSRA |= (1<<ADSC); //Начинаем преобразование
while((ADCSRA & (1<<ADSC))) {}; //проверка закончилось ли аналого-цифровое преобразование
savee =SREG;
cli ();
accu1 += (int32_t) ADC; //Оверсемплинг AI1. Было 10 бит, стало 13
accu_count1++;
if (accu_count1>=64)
{
ADC_AI_1=(int16_t)(accu1/8); accu_count1=0; accu1=0;//фильтрация AI1
ADC_AI_1_ff=prom_out1+(ADC_AI_1-prom_out1)/(float)koef_filtra_AI1; //экспоненциальный фильтр
prom_out1=ADC_AI_1_ff;

if ((tip_AI1>0) && (tip_AI1<4))
{
AI_1= ((float)((ADC_AI_1_ff-calibr_ADC_min_AI1)/(calibr_ADC_max_AI1-calibr_ADC_min_AI1)) * (((float)(VPI_AI1-NPI_AI1))/koeff_AI1)+ ((float)(NPI_AI1/koeff_AI1)));//Аппроксимация AI1
AI_1_fv=AI_1*(((float)koef_A_AI1)/1000)+(float)koef_B_AI1/koeff_AI1;//Коррекция AI1
}
else
{AI_1=0;AI_1_fv=0;}
}

SREG= savee;
ADMUX=1;
}
lock_0=0;

}

void indi()
{
static char n_count=1; //Переменная для перебора посылаемых байтов-символов на разряды индикатора

if (n_count==8)
{symboll(R8);
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
SPDR =0b01111111;//выбор индикатора
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
//отрицательный фронт для записи в STORAGE REGISTER
PORTB |= (1<<4); // высокий уровень
PORTB &= ~(1<<4); // низкий уровень
}

if (n_count==7)
{ symboll(R7);
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
SPDR =0b10111111;//выбор индикатора
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
//отрицательный фронт для записи в STORAGE REGISTER
PORTB |= (1<<4); // высокий уровень
PORTB &= ~(1<<4); // низкий уровень
}

if (n_count==6)
{symboll(R6);
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
SPDR =0b11011111;//выбор индикатора
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
//отрицательный фронт для записи в STORAGE REGISTER
PORTB |= (1<<4); // высокий уровень
PORTB &= ~(1<<4); // низкий уровень
}

if (n_count==5)
{symboll(R5);
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
SPDR =0b11101111;//выбор индикатора
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
//отрицательный фронт для записи в STORAGE REGISTER
PORTB |= (1<<4); // высокий уровень
PORTB &= ~(1<<4); // низкий уровень
}

if (n_count==4)
{symboll(R4);
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
SPDR =0b11110111;//выбор индикатора
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
//отрицательный фронт для записи в STORAGE REGISTER
PORTB |= (1<<4); // высокий уровень
PORTB &= ~(1<<4); // низкий уровень
}

if (n_count==3)
{symboll(R3);
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
SPDR =0b11111011;//выбор индикатора
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
//отрицательный фронт для записи в STORAGE REGISTER
PORTB |= (1<<4); // высокий уровень
PORTB &= ~(1<<4); // низкий уровень
}

if (n_count==2)
{symboll(R2);
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
SPDR =0b11111101;//выбор индикатора
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
//отрицательный фронт для записи в STORAGE REGISTER
PORTB |= (1<<4); // высокий уровень
PORTB &= ~(1<<4); // низкий уровень
}

if (n_count==1)
{symboll(R1);
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
SPDR =0b11111110;//выбор индикатора
while (!(SPSR & (1<<SPIF))) {}; //ожидание, пока данные передадутся
//отрицательный фронт для записи в STORAGE REGISTER
PORTB |= (1<<4); // высокий уровень
PORTB &= ~(1<<4); // низкий уровень
}

++n_count;
if (n_count>8) {n_count=1;}

}

int main(void)
{
preset();
SPI_init();
ADC_init();
sei();
while (1)
{

ADC_convert();
R1=7;
R2=7;
R3=7;
R4=7;
R5=7;
R6=7;
R7=7;
R8=7;
indi();
}//КОНЕЦ ОСНОВНОГО ЦИКЛА while
}//КОНЕЦ ОСНОВНОЙ ФУНКЦИИ main