Implement and test a function called `get_elapsed_time` to compute the elapsed time from power-up in an ATMEGA328P microcontroller using C Language on tinkercad.com and an Arduino Uno R3.

Requirements:
- Use a designated 16-bit timer in normal mode with overflow interrupt handling.
- Ensure time calculation accuracy to the nearest timer update "tick".
- Adapt the sample program from "Lecture 9: Implementing Timer Overflow ISR" to create a library function called `get_elapsed_time()`.
- Track elapsed time for a reasonably long period using Timer 1 set in normal operational mode.
- Set Timer 1 to overflow approximately every 0.25 seconds.
- Create a global 32-bit unsigned integer variable called `counter`.
- Implement an interrupt service routine (ISR) that increments `counter` by 1 every time the timer overflows.
- Implement a function `get_elapsed_time()` that returns the elapsed time since program start, accurate to the nearest timer tick, as a double-precision floating-point value.

Implementation Details:
1. Use the test driver to implement and test your function in TinkerCad Circuits before submission.

Code Skeleton:
```c
#include <...> // include necessary libraries

void uart_setup(void);
void uart_put_byte(unsigned char byte_val);
void uart_printf(const char *fmt, ...);

void setup(void) {
// (a) Initialize Timer 1 in normal mode to overflow approximately every 0.25 seconds.
// (b) Enable timer overflow for Timer 1.
// (c) Turn on interrupts.
// (d) Send a debugging message to the serial port using uart_printf.
}

volatile uint32_t counter = 0; // (e) Declare and initialize a global counter variable.

ISR(TIMER1_OVF_vect) {
// (f) Define ISR to process timer overflow interrupts for Timer 1.
counter++;
}

double get_elapsed_time(void) {
// (g) Implement function to return the total elapsed time measured.
}

// Helper functions
char buffer[100];
void uart_setup(void) {
#define BAUD (9600)
#define UBRR (F_CPU / 16 / BAUD - 1)
UBRR0H = UBRR >> 8;
UBRR0L = UBRR & 0b11111111;
UCSR0B = (1 << RXEN0) | (1 << TXEN0);
UCSR0C = (3 << UCSZ00);
}

void uart_printf(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
vsnprintf(buffer, sizeof(buffer), fmt, args);
for (int i = 0; buffer[i]; i++) {
uart_put_byte(buffer[i]);
}
}

#ifndef __AMS__
void uart_put_byte(unsigned char data) {
while (!(UCSR0A & (1 << UDRE0))) { /* Wait */ }
UDR0 = data;
}
#endif

int main() {
uart_setup();
setup();
for (;;) {
double time_now = get_elapsed_time();
uart_printf("Elapsed time = %d.%03d\r\n", (int)time_now, (int)((time_now - (int)time_now) * 1000));
_delay_ms(1000);
}
return 0;
}
```

Notes:
- Do not use the static qualifier for global variables as it causes variables declared at file scope to be private, preventing AMS from marking your submission.