#include <mega328p.h>
#include <delay.h>
#include <stdlib.h>

//заменили названия портов микроконтроллера названиями контактов платы, к которым ведут порты
#define E PORTB.4
#define D PORTC.5
#define W PORTD.4
#define Q PORTD.5

#define A5 PORTC.0
#define A6 PORTC.1
#define A9 PORTC.2
#define A8 PORTC.3
#define A7 PORTC.4

#define A4 PORTB.5
#define A3 PORTB.0
#define A2 PORTB.1
#define A1 PORTB.2
#define A0 PORTB.3


#define A11 PORTD.6
#define A10 PORTD.7



#define ACmp(Value) if(Value != 0){\
    Value = 1;\
}

//процедура для побитового выставления адреса в каждый из портов адреса
#define A(offset) A0 = offset & 0b00000000000000000000000000000001; ACmp(A0); \
   A1 = offset & 0b00000000000000000000000000000010; ACmp(A1); \
    A2 = offset & 0b00000000000000000000000000000100; ACmp(A2); \
    A3 = offset & 0b00000000000000000000000000001000; ACmp(A3); \
    A4 = offset & 0b00000000000000000000000000010000; ACmp(A4); \
    A5 = offset & 0b00000000000000000000000000100000; ACmp(A5); \
    A6 = offset & 0b00000000000000000000000001000000; ACmp(A6); \
    A7 = offset & 0b00000000000000000000000010000000; ACmp(A7); \             
    A8 = offset & 0b00000000000000000000000100000000; ACmp(A8); \
    A9 = offset & 0b00000000000000000000001000000000; ACmp(A9); \
   A10 = offset & 0b00000000000000000000010000000000; ACmp(A10); \
   A11 = offset & 0b00000000000000000000100000000000; ACmp(A11);   
   
#define DELAY(maxValue)  for(delayVar = 0; delayVar < maxValue; delayVar++);  //Макрос для задержек, меньших 1мс

#define BLINK(range) for (counter = 0; counter < range * 2; counter++) { \  //Макрос для моргания светодиодом. BLINK(1) - одно моргание(вкл + выкл)                                                                           
        delay_ms(500); \
        PORTB.5 = PORTB.5 ^ 1; } 


unsigned  delayVar;

void writeCycle(const unsigned value, const unsigned diapasonStart, const unsigned diapasonEnd) { //Запись в память с offset = diapasonStart по offset = diapasonEnd значения = Value
    unsigned dataOffset = diapasonStart; //dataOffset хранит адрес текущей ячейки памяти   
    D = value;
    E = 0;    
    
    while (dataOffset <= diapasonEnd) { //записываем, пока смещение не дойдет до нужной ячейки
        E = 1;                  //  \
                                 //   \
        W = 1;                  //    \
                                //     \
                                  //      - значения на портах E,D,Q,W выставляются в соответствии с временной диаграммой
        A(dataOffset)           //     /
        E = 0;                  //    /
                                  //   /
        W = 0;                  //  /
    
        
        dataOffset = dataOffset + 1; //увеличиваем смещение на 1, dataOffset хранит адрес следующей ячейки
    }
}

unsigned checkIsCorrect(const unsigned value,  unsigned diapasonStart, unsigned diapasonEnd) { //Все ли значения равны заданному value, возвращает количество ошибок
                                                                                              //( 0 - нет ошибок, все значения ячеек сошлись)
    unsigned errorCounterPTR = 0; //переменная для подсчета количества ошибок
    unsigned dataOffset = diapasonStart; //dataOffset хранит адрес текущей ячейки памяти       
    E = 0;
    W = 1;

    while (dataOffset <= diapasonEnd) {  //считываем, пока смещение не дойдет до нужной ячейки
        E = 1;
        DELAY(100);
        A(dataOffset)  
        DELAY(100);           
        E = 0;             
        DELAY(1000);
        
        if (Q != value) //если значение на порте входа данных не сходится с тем, что проверяем
                        //(Например, если на Q сигнал 0, а мы проверяем на value = 1, то увеличиваем счетчик ошибок на 1)
            errorCounterPTR = errorCounterPTR + 1;
                           
        DELAY(100);
        dataOffset = dataOffset + 1;
        DELAY(100); 
    }
    return errorCounterPTR;
}

void main(void)
{
    unsigned numberOfErrors; //указатель на число для хранения количества ошибок 
    unsigned counter; //счетчик, используемый в BLINK()  
        
        
// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=(1<<CLKPCE);
CLKPR=(0<<CLKPCE) | (0<<CLKPS3) | (0<<CLKPS2) | (0<<CLKPS1) | (0<<CLKPS0);
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Input/Output Ports initialization
// Port B initialization
// Function: Bit7=Out Bit6=Out Bit5=Out Bit4=Out Bit3=Out Bit2=Out Bit1=Out Bit0=Out 
DDRB=(1<<DDB7) | (1<<DDB6) | (1<<DDB5) | (1<<DDB4) | (1<<DDB3) | (1<<DDB2) | (1<<DDB1) | (1<<DDB0);
// State: Bit7=0 Bit6=0 Bit5=0 Bit4=0 Bit3=0 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=Out Bit5=Out Bit4=Out Bit3=Out Bit2=Out Bit1=Out Bit0=Out 
DDRC=(1<<DDC6) | (1<<DDC5) | (1<<DDC4) | (1<<DDC3) | (1<<DDC2) | (1<<DDC1) | (1<<DDC0);
// State: Bit6=0 Bit5=0 Bit4=0 Bit3=0 Bit2=0 Bit1=0 Bit0=0 
PORTC=(0<<PORTC6) | (0<<PORTC5) | (0<<PORTC4) | (0<<PORTC3) | (0<<PORTC2) | (0<<PORTC1) | (0<<PORTC0);

// Port D initialization
// Function: Bit7=Out Bit6=Out Bit5=In Bit4=Out Bit3=Out Bit2=Out Bit1=Out Bit0=Out 
DDRD=(1<<DDD7) | (1<<DDD6) | (0<<DDD5) | (1<<DDD4) | (1<<DDD3) | (1<<DDD2) | (1<<DDD1) | (1<<DDD0);
// State: Bit7=0 Bit6=0 Bit5=T 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: Timer 0 Stopped
// Mode: Normal top=0xFF
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=(0<<COM0A1) | (0<<COM0A0) | (0<<COM0B1) | (0<<COM0B0) | (0<<WGM01) | (0<<WGM00);
TCCR0B=(0<<WGM02) | (0<<CS02) | (0<<CS01) | (0<<CS00);
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;

// 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
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=(0<<EXCLK) | (0<<AS2);
TCCR2A=(0<<COM2A1) | (0<<COM2A0) | (0<<COM2B1) | (0<<COM2B0) | (0<<WGM21) | (0<<WGM20);
TCCR2B=(0<<WGM22) | (0<<CS22) | (0<<CS21) | (0<<CS20);
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;

// Timer/Counter 0 Interrupt(s) initialization
TIMSK0=(0<<OCIE0B) | (0<<OCIE0A) | (0<<TOIE0);

// Timer/Counter 1 Interrupt(s) initialization
TIMSK1=(0<<ICIE1) | (0<<OCIE1B) | (0<<OCIE1A) | (0<<TOIE1);

// Timer/Counter 2 Interrupt(s) initialization
TIMSK2=(0<<OCIE2B) | (0<<OCIE2A) | (0<<TOIE2);

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// Interrupt on any change on pins PCINT0-7: Off
// Interrupt on any change on pins PCINT8-14: Off
// Interrupt on any change on pins PCINT16-23: Off
EICRA=(0<<ISC11) | (0<<ISC10) | (0<<ISC01) | (0<<ISC00);
EIMSK=(0<<INT1) | (0<<INT0);
PCICR=(0<<PCIE2) | (0<<PCIE1) | (0<<PCIE0);

// USART initialization
// USART disabled
UCSR0B=(0<<RXCIE0) | (0<<TXCIE0) | (0<<UDRIE0) | (0<<RXEN0) | (0<<TXEN0) | (0<<UCSZ02) | (0<<RXB80) | (0<<TXB80);

// Analog Comparator initialization
// Analog Comparator: Off
// The Analog Comparator's positive input is
// connected to the AIN0 pin
// The Analog Comparator's negative input is
// connected to the AIN1 pin
ACSR=(1<<ACD) | (0<<ACBG) | (0<<ACO) | (0<<ACI) | (0<<ACIE) | (0<<ACIC) | (0<<ACIS1) | (0<<ACIS0);
ADCSRB=(0<<ACME);
// Digital input buffer on AIN0: On
// Digital input buffer on AIN1: On
DIDR1=(0<<AIN0D) | (0<<AIN1D);

// ADC initialization
// ADC disabled
ADCSRA=(0<<ADEN) | (0<<ADSC) | (0<<ADATE) | (0<<ADIF) | (0<<ADIE) | (0<<ADPS2) | (0<<ADPS1) | (0<<ADPS0);

// 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);   
    
    
    //c 0 по 10 ячейки пишем 0, с 11 по 20 пишем
    writeCycle(0, 0, 10);
    writeCycle(1, 11, 20);                      
        //подсчитываем, сколько раз данные в ячейках не сошлись с ожидаемыми
    // В данном случае проверяем на 0, должно бытть 10 ошибок(т.к. с 11 по 20 ячейки записаны единицы) 
    numberOfErrors = checkIsCorrect(1, 0, 20);
                                
    //моргаем светодиодом столько раз, сколько было ошибок  
    BLINK(numberOfErrors);
}