AVR Freaks

Umm your code does not make much sense does it?

For example:

#define		baud_4800				0xCF	// UBRR Value used in USART_Setup Switch Statement
#define		baud_9600				0x67	// UBRR Value USART_Setup Switch Statement
#define		baud_19200				0x33	// UBRR Value USART_Setup Switch Statement
#define		baud_28800				0x21	// UBRR Value USART_Setup Switch Statement

then:

		switch (Speed)
		{

			case 0xCF:
			UBRR0H =  (uint8_t) (baud_4800>>8);
			UBRR0L = baud_4800;
			break;
			case 0x67:
			UBRR0H =  (uint8_t) (baud_9600>>8);
			UBRR0L = baud_9600;
			break;
			case 0x33:
			UBRR0H =  (uint8_t) (baud_19200>>8);
			UBRR0L = baud_19200;
			break;
			case 0x21:
			UBRR0H =  (uint8_t) (baud_28800>>8);
			UBRR0L = baud_28800;
			break;

but baud_4800, baud_9600 etc that you use there are 0xCF, 0x67 ect. So this code basically says:

		switch (Speed)
		{

			case 0xCF:
			UBRR0H =  (uint8_t) (0xCF>>8);
			UBRR0L = 0xCF;
			break;
			case 0x67:
			UBRR0H =  (uint8_t) (0x67>>8);
			UBRR0L = 0x67;
			break;
			case 0x33:
			UBRR0H =  (uint8_t) (0x33>>8);
			UBRR0L = 0x33;
			break;
			case 0x21:
			UBRR0H =  (uint8_t) (0x21>>8);
			UBRR0L = 0x21;
			break;
etc etc

So why not simply replace the entire switch/case with:

			UBRR0H =  (uint8_t) (Speed>>8);
			UBRR0L = Speed;

but even that is more complex than it needs to be because "UBRR0" is a 16 bit register that combines "UBRR0L" and "UBRR0H" into one. So:

			UBRR0 =  Speed;

That one line replaces the entire:

		switch (Speed)
		{

			case 0xCF:
			UBRR0H =  (uint8_t) (baud_4800>>8);
			UBRR0L = baud_4800;
			break;
			case 0x67:
			UBRR0H =  (uint8_t) (baud_9600>>8);
			UBRR0L = baud_9600;
			break;
			case 0x33:
			UBRR0H =  (uint8_t) (baud_19200>>8);
			UBRR0L = baud_19200;
			break;
			case 0x21:
			UBRR0H =  (uint8_t) (baud_28800>>8);
			UBRR0L = baud_28800;
			break;
			case 0x19:
			UBRR0H =  (uint8_t) (baud_38400>>8);
			UBRR0L = baud_38400;
			break;
			case 0x10:
			UBRR0H =  (uint8_t) (baud_57600>>8);
			UBRR0L = baud_57600;
			break;
			case 0x0C:
			UBRR0H =  (uint8_t) (baud_76800>>8);
			UBRR0L = baud_76800;
			break;
			case 0x07:
			UBRR0H =  (uint8_t) (baud_230400>>8);
			UBRR0L = baud_230400;
			break;
			case 0x03F:
			UBRR0H =  (uint8_t) (baud_4800>>8);
			UBRR0L = baud_4800;
			break;
			default:
			break;
		}

BTW you may want to rethink this anyway. Things like uart_4800 being fixed at 0xCF (207) is only valid for:

What if you want to run the AVR at 8MHz or 1Mhz or 3.6864MHz etc etc ?

Oh and:

#define MyUCSRnC						06			//      0b11001110  (from above)
#define MyUCSRnB						00			//      0b00000100  (from above)

You got away with it this time but do you know what happens in C if you start a number with a leading '0' and it is not then followed by either 'x' or 'b' ? If you don't know you probably want to look it up but if you had tried to use 09 you would probably have found out already !

As noted, you didn't post the complete  code - so impossible to say what might happen in the complete code.

But you asked:

and that has certainly been answered!

Give us the smallest, cut down AS7 project that still shows the issue you think you have and we can all try it in our own simulators.

Also before that set your build options to -Og and see if that helps (usually these things come down to over-agrresive optimisation which makes following a linear flow in the sim hard).

Oh and just an idea. If you want a function where you pass an "index number" to pick a given UART to be set then the word "index" in that should ring a bell! Suppose you had a structure like:

volatile uint16_t * ubrrs[] = { &UBRR0, UBRR1, &UBRR2, &UBRR3);

now is you say:

*ubrrs[2] = 0xCF;

then this will set the UBRR for UART2 (from 0..3).

In fact you could take this one step further:

typedef struct {
    volatile uint16_t * ubrr;
    volatile uint8_t * ucsra;
    volatile uint8_t * ucsrb;
    volatile uint8_t * ucsrc;
} uart_layout_t;

uart_layout_t uarts[] {
    { &UBBRR0, &UCSR0A, &UCSR0B, &UCSR0C },
    { &UBBRR1, &UCSR1A, &UCSR1B, &UCSR1C },
    { &UBBRR2, &UCSR2A, &UCSR2B, &UCSR2C },
    { &UBBRR3, &UCSR3A, &UCSR3B, &UCSR3C }
};

Now if you have some kind of:

uart_set_baud(int uart_num, uint16_t baud) {
    *uarts[uart_num].ubrr = baud;
}

The same function can set the baud for any of UART 0,1,2,3.

You don't need some dreadful great switch/case statement as sure UBRR0, UBRR1, UBRR2 and UBRR3 might all have very different addresses - but you just index into the lookup table to access the right one.

You are going to love Xmega (which also means AVR-0, AVR-1, AVR-Dx, etc) when you get to them as Atmel already grouped all the UART registers (and the same for all peripherals) into a struct so to address a particular UART (or whatever) you only need to know the base address of the register block.

Each time you start over you will learn from all your mistakes and get 30% better--so why wait?  You can't beat that return on investment!

Thanks for feeding back.

Rather than a switch on the port number, couldn't you just use an array of Port addresses - as clawson suggested in #9 ?

*ubrrs[Port] = BaudArry[Speed];

You do that by marking the solution - see Tip #5 in my signature, below: