AVR Freaks

This is no (direct) suggestion to a solution of your problem:, but...: You need to make your code readable. In this case it's about making indentation reflect the structure of your program. Indentation is used to reflect what code is part of a larger block and/or is ddependent on some control statement (if, while, for etc).

You should do this for two reasons:

• Because you need to understand what you yourself has written. Code structure is vital when you return to something you wrote earlier (be that 15 minutes or three years ago).
• Because you ask others to read your code, and they (i.e. we) all rely on this conventional way of structuring code.

There are several indentation styles commonly used. Google "code indentation", possibly in combination with one of these: "kernighan ritchie", "gnu", "linux-style", "1tbs"

Below are examples of  good indentations of your two programs above.

First program:

#include<avr/io.h>
#include<avr/delay.h>
#include <avr/interrupt.h>
#include <string.h>
#define F_CPU 8000000
#define BAUDRATE 2400
#define UBRRVAL ((F_CPU/(BAUDRATE*16UL))-1)
volatile unsigned char rx_data = 0;
volatile unsigned int new_rx_data = 0;
volatile unsigned int skaic[8];
volatile unsigned int sk = 0;

void
USART_Init (void)
{
  UBRRL = (uint8_t) UBRRVAL;
  UBRRH = (UBRRVAL >> 8);
  UCSRC = (1 << URSEL) | (0 << UCSZ2) | (1 << UCSZ1) | (1 << UCSZ0);
  UCSRB = (1 << TXEN) | (1 << RXEN) | (1 << RXCIE);
}

void
USART_simbolis (unsigned char *data)
{
  while ((UCSRA & (1 << UDRE)) == 0);
  UDR = data;
}

void
USART_siuntimas (unsigned char *data)
{
  while (*data != 0)
    {
      while ((UCSRA & (1 << UDRE)) == 0);
      UDR = *data;
      data++;
    }
}

ISR (USART_RXC_vect)
{
  rx_data = UDR;
  new_rx_data = 1;

}

void
main ()
{
  char buffer[8] = { 000000000 };

  int ty;
  USART_Init ();
  sei ();

  while (1)
    {
      if (new_rx_data)
        {
          if (rx_data == 'r')
            {

              skaic[sk] = 'm';
              sk = 0;
              ty = 0;
              char *k = &skaic;
              while (*k != 'm')
                {
                  if ((*k >= '0') && (*k <= '9'))
                    {
                      buffer[ty] = *k;
                      ty++;
                    }
                  k++;
                }
              USART_siuntimas (buffer);
              DDRB = atoi (buffer);
            }
          else
            {
              skaic[sk] = rx_data;
              sk = sk + 1;
            }
          new_rx_data = 0;
        }
    }

}

Second program:

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <string.h>

#define SegDataPort		PORTA
#define SegDataDDR		DDRA

#define SegCntrlPort	PORTC
#define SegCntrlDDR		DDRC

#define F_CPU 8000000
#define BAUDRATE 2400
#define UBRRVAL ((F_CPU/(BAUDRATE*16UL))-1)

volatile uint16_t vienetas = 0;
volatile uint16_t desimt = 0;
volatile uint16_t desimt1 = 0;
volatile uint16_t simtas = 0;
volatile uint16_t simtas1 = 0;
volatile uint16_t tukstantis = 0;
volatile uint16_t tukstantis1 = 0;
volatile uint16_t desimttuks = 0;
volatile uint16_t k = 0;
volatile uint32_t i = 0;
volatile unsigned int u = 0;
volatile unsigned int sk = 0;
volatile unsigned int skaic[8];
volatile unsigned char rx_data = 0;
volatile unsigned int new_rx_data = 0;

//==========================================================

void
USART_Init (void)
{
  UBRRL = (uint8_t) UBRRVAL;
  UBRRH = (UBRRVAL >> 8);
  UCSRC = (1 << URSEL) | (0 << UCSZ2) | (1 << UCSZ1) | (1 << UCSZ0);
  UCSRB = (1 << TXEN) | (1 << RXEN) | (1 << RXCIE);
}

void
USART_simbolis (unsigned char *data)
{
  while ((UCSRA & (1 << UDRE)) == 0);
  UDR = data;
}

void
USART_siuntimas (unsigned char *data)
{
  while (*data != 0)
    {
      while ((UCSRA & (1 << UDRE)) == 0);
      UDR = *data;
      data++;
    }
}

ISR (USART_RXC_vect)
{
  rx_data = UDR;
  new_rx_data = 1;

}

//==========================================================

unsigned char
DigitTo7SegEncoder (int digit, int common)
{
  int SegVal;

  switch (digit)
    {
    case 0:
      if (common == 1)
        SegVal = 0 b01111110;
      else
        SegVal = ~0 b01111110;

      break;
    case 1:
      if (common == 1)
        SegVal = 0 b00011000;
      else
        SegVal = ~0 b00011000;

      break;
    case 2:
      if (common == 1)
        SegVal = 0 b01101101;
      else
        SegVal = ~0 b01101101;
      break;
    case 3:
      if (common == 1)
        SegVal = 0 b00111101;
      else
        SegVal = ~0 b00111101;
      break;
    case 4:
      if (common == 1)
        SegVal = 0 b000011011;
      else
        SegVal = ~0 b000011011;
      break;
    case 5:
      if (common == 1)
        SegVal = 0 b00110111;
      else
        SegVal = ~0 b00110111;
      break;
    case 6:
      if (common == 1)
        SegVal = 0 b01110111;
      else
        SegVal = ~0 b01110111;
      break;
    case 7:
      if (common == 1)
        SegVal = 0 b00011100;
      else
        SegVal = ~0 b00011100;
      break;
    case 8:
      if (common == 1)
        SegVal = 0 b01111111;
      else
        SegVal = ~0 b01111111;
      break;
    case 9:
      if (common == 1)
        SegVal = 0 b00111111;
      else
        SegVal = ~0 b00111111;
      break;
    }

  return SegVal;
}

void
main ()
{
  char buffer[8] = { 000000000 };
  int ty;
  SegDataDDR = 0xFF;
  SegCntrlDDR = 0xFF;
  SegCntrlPort = 0xFF;
  USART_Init ();
  sei ();

  while (1)
    {
      if (new_rx_data)
        {
          if (rx_data == 'r')
            {

              skaic[sk] = 'm';
              sk = 0;
              ty = 0;
              char *k = &skaic;
              while (*k != 'm')
                {
                  if ((*k >= '0') && (*k <= '9'))
                    {
                      buffer[ty] = *k;
                      ty++;
                    }
                  k++;
                }
              USART_siuntimas (buffer);
              DDRB = atoi (buffer);
            }
          else
            {
              skaic[sk] = rx_data;
              sk++;
            }
          new_rx_data = 0;
        }
      SegDataPort = 0;
      SegCntrlPort = 0x00;
      _delay_us (500);
      SegDataPort = DigitTo7SegEncoder (i % 10, 1);
      SegCntrlPort = 0x01;
      _delay_us (3000);
      SegDataPort = 0;
      SegCntrlPort = 0x00;
      _delay_us (500);
      if (i < 100)
        {
          desimt = i / 10;
        }
      if (i >= 100)
        {
          desimt1 = i % 100;
          desimt = desimt1 / 10;
        }
      SegDataPort = DigitTo7SegEncoder (desimt, 1);
      SegCntrlPort = 0x02;
      _delay_us (3000);
      SegDataPort = 0;
      SegCntrlPort = 0x00;
      _delay_us (500);
      if ((i >= 100) && (i < 1000))
        {
          simtas = i / 100;
        }
      if (i >= 1000)
        {
          simtas1 = i / 100;
          simtas = simtas1 % 10;
        }
      SegDataPort = DigitTo7SegEncoder (simtas, 1);
      SegCntrlPort = 0x04;
      _delay_us (3000);
      SegDataPort = 0;
      SegCntrlPort = 0x00;
      _delay_us (500);
      if ((i >= 1000) && (i < 10000))
        {
          tukstantis = i / 1000;
        }
      if (i >= 10000)
        {
          tukstantis1 = i / 1000;
          tukstantis = tukstantis1 % 10;
        }
      SegDataPort = DigitTo7SegEncoder (tukstantis, 1);
      SegCntrlPort = 0x08;
      _delay_us (3000);
      SegDataPort = 0;
      SegCntrlPort = 0x00;
      _delay_us (500);
      SegDataPort = DigitTo7SegEncoder (i / 10000, 1);
      SegCntrlPort = 0x10;
      _delay_us (3000);
    }

  return 0;
}

I hope you can see how much more readable the code is with this indentation.

EDIT: Note: I do not argue that the style I used above is the best. There is no best style, but there are a number of good styles. The important thing is to select one and be consistent with it throughout as project.

I used an automatic tool to fix the structure in your two programs. Things it did that I did not like, but was too lazy to find the correct options to avoid are e.g.:

- Function return types on separate lines

- Space between function name and parameter list parenthesis in function calls

- "Double indentation", i.e. "gullwings" are indented, and then the statements inside the gullwing blocks are indented.

The point is that it is consistent, and one of the universally recognized indentation styles.

No, I will not reveal my preferred indentation style.

No, do not ask which style is the best - it will only lead to an endless argument between people (a.k.a "indentation war").

Let me make that bold so you will notice it!

You have now been warned.

Good luck with your project.

Jim

Did you at all try to locate it yourself? Probably not. 

I will spoil you with the link, but be aware that having the "feed me" attitude  will eventually give you a less-than-good reputation. Taking 15 minutes to sift  through the listing of tutorials will give you an impression of what is available, and will serve you well in the future.

Actually, several links:

https://www.avrfreaks.net/forum/t...

https://www.avrfreaks.net/forum/t...

Also, your laptop will be using a proper crystal to set its baud rate - so your MCU will have the whole error margin to play with.

If you were talking to another MCU, also relying upon its RC, your luck could run out much sooner ...

That's one way.  Many others.  Depends, as usual.

In some cases I 'calibrate' in the app by auto-sensing the baud rate from the other end, and then match that with UBRR.  In others, I'll do the same auto-sensing but then tweak OSCCAL to null the error.  Depends on the range of baud rates I'll want to support, the clock speed I want to run at, etc.

A common way of calibrating is against an external low-frequency crystal on TOSC1/2, if your device supports it.  This can be done once after reset, or periodically if your device will be operating under varying conditions of temperature and Vcc.

There are a number of application notes on the subject of calibrating the RC oscillator:

http://www.atmel.com/products/microcontrollers/avr/default.aspx?tab=documents&Asset_Type=020%20Application%20Note

Just CTRL-F for 'calibrat'