#include <avr/io.h>

#include <util/delay.h>

#include <avr/interrupt.h>

#include <stdlib.h>

#define USART_TX_BUF_LEN 128

void initUSART();

void initTimer();

void USART_print(const char* str);

struct {

unsigned char buf[USART_TX_BUF_LEN];

uint8_t start;

uint8_t end;

} USART_TX_BUF;

char tmp_str[6];

uint32_t count = 0;

void blinkLed(int times)

{

while(times) {

PORTB ^= (1 << PINB0);

_delay_ms(50);

PORTB ^= (1 << PINB0);

_delay_ms(50);

--times;

}

}

void main()

{

// Pin to measure impulse time

//DDRB |= (0 << PINB0);

//PORTB = (0 << PINB0);

// LED pin

DDRD |= (1 << PIND7);

PORTD |= (0 << PIND7);

// Trig pin

PORTD |= (1 << PIND6);

DDRD |= (1 << PIND6);

blinkLed(5);

initUSART();

initTimer();

USART_print("Main started\n");

while(1) {

PORTD |= 1 << PIND6;

_delay_us(12);

PORTD &= ~(1 << PIND6);

_delay_ms(2000);

}

}

void initUSART()

{

// Configure UART

// Define baud rate

int baud = 25;

UBRRH = (unsigned char) baud >> 8;

UBRRL = (unsigned char) baud;

// Set async mode

UCSRC &= ~(1 << UMSEL);

// Enable TX and RX

UCSRB = (1 << RXEN) | (1 << TXEN);

UCSRC = (1<<URSEL) | (1<<USBS) | (3<<UCSZ0);

// Enable RX interrupts

UCSRB |= 1 << RXCIE;

// UDRIE in UCSRA needs to be set to 0 according to documentation

UCSRA &= ~(1 << UDRIE);

// Enable global interrupts

SREG |= 1 << SREG_I;

USART_TX_BUF.start = 0;

USART_TX_BUF.end = 0;

USART_TX_BUF.buf[USART_TX_BUF.start] = 0;

USART_print("USART initialized.\n");

}

void initTimer()

{

// Enable interrupts

SREG |= 1 << SREG_I;

// Set prescaler

//TCCR1B |= (1 << CS10) | (1 << CS11);

TCCR1B |= 1<<CS10;

// Set timer mode

// Set CTC mode

//TCCR1B |= 1 << WGM12;

// Set compare number

//OCR1A = 15624;

// Enable timer interrupts

//TIMSK |= 1 << OCIE1A;

TIMSK |= 1 << TICIE1;

// Activate Input Capture Noise Canceler

TCCR1B |= 1 << ICNC1;

// Set rising edge detect

TCCR1B |= 1 << ICES1;

USART_print("Timer initialized\n");

}

ISR(USART_RXC_vect)

{

unsigned char receivedData = UDR;

//blinkLed(1);

// Wait while TX is ready

while(! (UCSRA & (1 << UDRE)));

UDR = receivedData;

switch(receivedData) {

case 13: // carriage returm

while(! (UCSRA & (1 << UDRE)));

UDR = 10; // send newline in case carriage return is received

break;

case 8: // backspace

while(! (UCSRA & (1 << UDRE)));

UDR = 127; // send newline in case carriage return is received

break;

default:

break;

}

}

ISR(USART_UDRE_vect)

{

++USART_TX_BUF.end;

if(USART_TX_BUF.end >= USART_TX_BUF_LEN)

USART_TX_BUF.end = 0;

if(USART_TX_BUF.end != USART_TX_BUF.start) {

UDR = USART_TX_BUF.buf[USART_TX_BUF.end];

} else {

UCSRB &= ~(1 << UDRIE);

}

}

/*

ISR(TIMER1_COMPA_vect)

{

++count;

PORTD ^= 1 << PIND7;

itoa(count, tmp_str, 10);

USART_print("Timer tick: " );

USART_print(tmp_str);

USART_print("\n");

}

*/

/*

ISR(TIMER1_CAPT_vect)

{

// Disable interrupts

PORTD ^= 1 << PIND7;

char cm[5];

cli();

uint16_t tmp = ICR1;

// Enable interrupts

sei();

if(TCCR1B & (1 << ICES1)) {

// It is rising edge

TCNT1 = 0;

// Set interrupt for failing edge

TCCR1B &= ~(1 << ICES1);

} else {

uint8_t result = tmp / 58;

USART_print("Result: ");

USART_print(itoa(result, cm, 10));

USART_print(" cm.\n");

TCCR1B |= 1 << ICES1;

}

}

*/

void USART_print(const char* str)

{

while(*str) {

USART_TX_BUF.buf[USART_TX_BUF.start] = *str;

++USART_TX_BUF.start;

if(USART_TX_BUF.start >= USART_TX_BUF_LEN)

USART_TX_BUF.start = 0;

if(*str == 10) {

USART_TX_BUF.buf[USART_TX_BUF.start] = 13;

++USART_TX_BUF.start;

if(USART_TX_BUF.start >= USART_TX_BUF_LEN)

USART_TX_BUF.start = 0;

}

++str;

}

if(! (UCSRB & (1 << UDRIE))) {

// Wwait until UDR is empty

while(! (UCSRA & (1 << UDRE)));

UDR = USART_TX_BUF.buf[USART_TX_BUF.end];

// Enable UDRE interrupt

UCSRB |= 1 << UDRIE;

}

}

// TICIE1 = 1 -- enable Input Capture interrupt

// when event comes to ICR pin, ICF1 flag is set, TCNT1 is written to ICR1 register

//