#define size_TX0     10
volatile static int8_t    count_TX0;//кол-во непереданных символов в буфере UART0
volatile static int8_t    index_TX0;//адресация в буфере передачи UART0
volatile static int8_t     bufferTX0[size_TX0];//массив - буфер передачи UART0
/*==============================*/
void send_UART0(char *string)
{
int8_t    i;
for(i=0;*string!='\0';i++)
    {
        bufferTX0[i]=(*string);    //сохраняем строку в буфер
        string++;
        count_TX0++;                //считаем символы
    }
index_TX0=0;                        //обнуляем адресацию в буфере
sbi(UCSR0B,UDRIE0);                    //запускаем прерывание
}
/*==============================*/
ISR(USART0_UDRE_vect)
{
    UDR0 = bufferTX0[index_TX0++];                // Берем данные из буффера.
    if(index_TX0==count_TX0)  cbi(UCSR0B,UDRIE0);    // Если все передали, то выкл.прерывание
}
/*==============================*/

#include <avr/pgmspace.h>

#define size_TX0 10

// беззнаковые счётчики и индексы дают код короче и быстрее
volatile static unt8_t count_TX0; //кол-во непереданных символов в буфере UART0
volatile static unt8_t index_TX0; //адресация в буфере передачи UART0
// char так char, какая нам разница, какой размер и знак у символов
volatile static char bufferTX0[size_TX0];//массив - буфер передачи UART0
...

void wait_UART0()
{
while (UCSR0B & (1<<UDRIE0)) {}
}

void start_UART0()
{
index_TX0 = 0;
UCSR0B |= (1<<UDRIE0);
}

// Строка из ОЗУ
void send_UART0(char *string)
{
char *dst = buffer_TX0;
char ch;

wait_UART0(); // надо ведь дождаться, пока уйдёт предыдущая строка

count_TX0 = 0;

// бесконечный цикл, тут прямо в условие действия затолкать для новичка возможно слишком уж нечитаемо выйдет
for (;;) {
ch = *string++;
// если достигнут конец строки или уже нет местя в буфере — выходим
if (ch == '\0' || ++count_TX0 >= size_TX0) break;
*dst++ = ch;
}

start_UART0();
}

...
// Строка из флеша.
// Увы, нормальной поддержки указатеелй во флеше нет, поэтому проще не обманывать себя
void send_UART0_P(unsigned string_address)
{
char *dst = buffer_TX0;
char ch;

wait_UART0();

count_TX0 = 0;

for (;;) {
ch = pgm_read_byte(string_address);
++string_address;
if ( ch == '\0' || ++count_TX0 >= size_TX0) break;
*dst++ = ch;
}

start_UART0();
}

...
send_UART0_P( PSTR("Temperature: ") ); // эта строка не попадёт в ОЗУ
char tmpbuf[size_TX0];
// к примеру, преобразовали в буфер число
send_UART0( tmpbuf );
send_UART0_P( PSTR("\r\n") ); // эта строка не попадёт в ОЗУ

void  start_UART0_TX()
{
    index_TX0 = 0;            //обнуляем адресацию в буфере передачи
    sbi(UCSR0B,UDRIE0);        //запускаем прерывание
}
/*--------------------------*/
void send_UART0(char *string)
{
    u08    i;
    count_TX0 = 0;
    for(i=0;*string!='\0' && count_TX0<size_TX0;i++)
        {
            bufferTX0[i]=(*string++);    //сохраняем строку в буфер
            count_TX0++;                //считаем символы
        }
    start_UART0_TX();                    //запускаем прерывание
}

void send_UART0_P(const char *string)
{
    u08    i;
    count_TX0 = 0;
    for(i=0;pgm_read_byte(string)!='\0' && count_TX0<size_TX0;i++)
        {
            bufferTX0[i]=pgm_read_byte(string++);    //сохраняем строку в буфер
            count_TX0++;                            //считаем символы
        }
    start_UART0_TX();                                //запускаем прерывание
}
/*--------------------------*/
ISR(USART0_UDRE_vect)
{
    UDR0 = bufferTX0[index_TX0++];                    // Берем данные из буффера.
    if(index_TX0>=count_TX0)  cbi(UCSR0B,UDRIE0);    // Если все передали, то выкл.прерывание
}

#define pgm_printf(x, ...) do {\
    static const char PROGMEM pgm_str[] = x;\
    char pgm_data_buf[sizeof(pgm_str)];\
    __pgm_strcpy( pgm_data_buf, pgm_str);\
    printf( pgm_data_buf, __VA_ARGS__);\
} while(0)

void __pgm_strcpy(char *dst, const char PROGMEM *str)
{
    do
    {
        *dst++ = *str;
    } while (*str++);
}


примеры использования:

pgm_printf("strlen(%s) = %u\n", "hello", strlen("hello"));
pgm_printf("x = %d\n", 123);
pgm_printf("addr_0x%x\n", 0x1000);

#define check_temp(X)\
if(temp==X) {index_RX0++;break;}\
goto start_RX0;

#define check_temp(X)\
do{\
if(temp==X) {index_RX0++;break;}\
goto start_RX0;\
}while(0)

EEMEM char array[10];
unsigned int *addr_EE;
addr_EE = array;   <-- здесь компилятор ругается на несовпадение типов.
EEAR = addr_EE;

EEMEM char array[10];
EEMEM char *addr_EE;

unsigned int addr_EE;
addr_EE = (unsigned int)array;
EEAR = addr_EE;

__eeprom char array[10];
char __eeprom *addr_EE;
addr_EE = array;

EEAR = (unsigned short)addr_EE;

typedef struct
{
    uint8_t      code;                 // код символа ASCII
    uint8_t *    index;                // указатель на массив символа
    uint8_t      width;                // ширина символа
} FontStruct;

const FontStruct FontTable[] = {
  {0x31, &font_0x31,6},
  {0x32, &font_0x32,6},
  {0x33, &font_0x33,6}}

/*---------------------------------------------------------------------------------*/
static const uint8_t font_0x31[6] PROGMEM = {0x00,0x81,0xff,0x80,0x00,0x00};
static const uint8_t font_0x32[6] PROGMEM = {0x82,0xc1,0xa1,0x91,0x8e,0x00};
static const uint8_t font_0x33[6] PROGMEM = {0x42,0x81,0x89,0x89,0x76,0x00};

const FontStruct FontTable[] = {
  {0x31,  font_0x31,6},
  {0x32,  font_0x32,6},
  {0x33,  font_0x33,6}}

uint8_t *

PROGMEM

uint8_t font_0x31[6] = {0x00,0x81,0xff,0x80,0x00,0x00};
uint8_t font_0x32[6] = {0x82,0xc1,0xa1,0x91,0x8e,0x00};
uint8_t font_0x33[6] = {0x42,0x81,0x89,0x89,0x76,0x00};

const FontStruct FontTable[] = {
  {0x31,
  
  
  font_0x31,6},
  {0x32,
  font_0x32,6},
  {0x33,
  font_0x33,6}};

typedef struct
{
  uint8_t        code;
  const uint8_t* index;       // указатель на КОНСТАНТНЫЙ массив (не хватало квалификатора const)
  uint8_t        width;
} FontStruct;

const FontStruct FontTable[] =
{
  {0x31, &font_0x31[0], 6},   // И тут тоже косяк был. Надо либо брать адрес нулевого элемента массива, либо просто имя массива без взятия адреса.
  {0x32, &font_0x32[0], 6},
  {0x33, &font_0x33[0], 6}
};

const __flash uint8_t x1 = 33;
const __flash uint8_t x2 = 36;
const __flash uint8_t* ptr = &x1;
if (*ptr==x2)
{
    ...
}

char* p1;
const char* p2;
char* const p3;
const char* const p4;

#define EE_read {\
cli();\
EEAR = (u16)addr++;\
sbi(EECR,EERE);\
temp = EEDR;\
EEAR = 0;\
sei();}

const uint8_t PROGMEM test[3]={1, 2, 4};
const uint8_t test2[3]={11,12,16};
const uint8_t * ptr;
volatile uint8_t test_copy[9];
__attribute__ ((section (".eeprom"))) const uint8_t  test3[3]={'A','B','m'};
int main()
{
    ptr=test;
    test_copy[0]=ptr[0];
    test_copy[1]=ptr[1];
    test_copy[2]=ptr[2];

    ptr=test2;
    test_copy[3]=ptr[0];
    test_copy[4]=ptr[1];
    test_copy[5]=ptr[2];

    ptr=test3;
    test_copy[6]=ptr[0];
    test_copy[7]=ptr[1];
    test_copy[8]=ptr[2];