Ламерские вопросы по Си, перехожу с асма Опции

[Alt.F4]

Добрый день.
Копаю интернет, но все как-то безуспешно.
Хочу написать функцию передачи строки по UART, работающую по прерыванию. Причем строка может быть как константа (храниться во флэш), так и переменная (храниться в СОЗУ).

Код

#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);    // Если все передали, то выкл.прерывание
}
/*==============================*/

Пишу send_UART0("12345");, но эти 12345 сохраняются в СОЗУ.
Вопрос: как передать в функцию строку, чтобы она сохранилась во флэш?
Спасибо.

Сообщение отредактировал Alt.F4 - May 19 2012, 06:36

[Dog Pawlowa]

Если нужно флэш, то как-то так:
__flash char my_string[]="12345";
send_UART0(my_string);

Волшебное слово __flash зависит от компилятора.

Но с универсальной функцией придется еще пободаться.
Разберитесь с типом передаваемого указателя.

[ReAl]

Хм... Я не силён в терминологии разряда «цветовой дифференциации штанов», но в моём понимании «ламер» означает человека, который не просто не знает чего-то (все чего-то не знают *) ), а и не желает разобраться и при этом ещё пробует учить других. «ламерский вопрос» при этом редкость и обычно сам он своим уровнем хорошо показывает, что в предыдущих своих сообщениях человек с умным видом рассуждал о том, чего совершенно не знает.
«нуб», в отличие от «ламера», хочет что-от узнать.
Один и тот же вопрос может быть «ламерским» или «чайниковским» в зависимости от того, кто его задал (от предистории).
Ну да не важно.

Судя по тому, что соседний вопрос был по AVR Studio, используется avr-gcc.
У него до версии 4.7 не поддерживаются разные пространства памяти и соответствующие модификаторы указателей (да и в 4.7, если я правильно понял, это есть в C frontend, но нет в C++).
Так что нужно использовать атрибут размещения из avr/pgmspace.h
Универсальную функцию написать можно, сначала придумав, как передавать признак ОЗУ/флеш.
Две специальных написать проще и результат не хуже. И это будет выглядеть как-то так:

CODE

#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") ); // эта строка не попадёт в ОЗУ

____________
*) Не знать — не стыдно. Стыдно не хотеть узнать.

[demiurg_spb]

Но с универсальной функцией придется еще пободаться.

да, можно её и так боднуть:-)
http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gc...r-Builtins.html

Универсальную функцию написать можно, сначала придумав, как передавать признак ОЗУ/флеш.

А зачем передавать, можно на ходу макрос разворачивать и определять PGM_P она или нет.

[Alt.F4]

Две специальных написать проще и результат не хуже. И это будет выглядеть как-то так: ...

Спасибо большое!!!
У себя реализовал так:

Код

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);    // Если все передали, то выкл.прерывание
}

Сообщение отредактировал Alt.F4 - May 20 2012, 11:21

[defunct]

Строки наверное удобней выводить printf'ом. format str размещать во флеш, а %s - для вывода строк формируемых в run-time в ОЗУ...
WinAVR поддерживает макросы с переменным числом аргументов

Код

#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);

[Alt.F4]

Возник новый вопрос. Прочел, что хорошим тоном является при написании макросов, в том числе многострочных, заключать их в do{...}while(0)
Но вот беда, когда я заключаю в этот цикл while следующий макрос, он компилируется хрен знает каким образом.
Исходный вариант:

Код

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

В цикле while:

Код

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

Макрос вставляю в case инструкции switch. В дизасемблере второй макрос выполняет два раза index_RX0+, затем джамп и перед ret обнуляет index_RX0!!!
Если do{...}while(0) убрать, то все работает как надо.
Что это может быть?
Спасибо.

Сообщение отредактировал Alt.F4 - May 23 2012, 03:12

[Сергей Борщ]

Что это может быть?

Во втором случае break выходит из do{}while(), а не из case().

P.S. на будущее - заключайте X внутри макроса в скобки. В месте вызова он может оказаться не переменной, а выражением.

[Alt.F4]

Сергей Борщ, спасибо большое!!!

[ReAl]

Строки наверное удобней выводить printf'ом. format str размещать во флеш, а %s - для вывода строк формируемых в run-time в ОЗУ...
WinAVR поддерживает макросы с переменным числом аргументов

А строки из флеша (в частности, выбранные по индексу или полученные как поле структуры) — форматом %S

[Alt.F4]

Имеем массив в EEPROM и указатель на него:

Код

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

Подскажите пожалуйста, как правильно объявить указатель?
Спасибо.

Сообщение отредактировал Alt.F4 - Jun 2 2012, 15:14

[_Артём_]

Имеем массив в EEPROM и указатель на него:

Код

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;

[mempfis_]

Имеем массив в EEPROM и указатель на него:

Код

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

Подскажите пожалуйста, как правильно объявить указатель?
Спасибо.

У Вас array объявлен как EEMEM char а указатель на тип данных int.
Указатель должен соответсвовать типу данных или приводится к нему.
в IAR прокатила бы такая такая запись

Код

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

[Alt.F4]

или так можно:

Код

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

Разницы от исходника компилятор не заметил, т.е. типы не совпадают.

Думаю что так:

Код

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

Если делать так, то варнинг несовпадения типов выскакивает уже напротив: EEAR = addr_EE;

Указатель должен соответсвовать типу данных или приводится к нему.

Каким образом привести тип указателя, чтобы его значение можно было записать в EEAR и в тоже время в этот указатель можно записать адрес массива?

Сообщение отредактировал Alt.F4 - Jun 2 2012, 15:48

[_Артём_]

Если делать так, то варнинг несовпадения типов выскакивает уже напротив: EEAR = addr_EE;адрес массива?

Тогда так:

Код

EEAR = (unsigned short)addr_EE;

[Alt.F4]

EEAR = (unsigned short)addr_EE;

Варнинг исчез! Спасибо большое!

Сообщение отредактировал Alt.F4 - Jun 2 2012, 16:14

[Alt.F4]

Delete.

Сообщение отредактировал Alt.F4 - Jun 3 2012, 12:58

[Alt.F4]

Здравствуйте.
Столкнулся с новой проблемой, проклятый "undefined reference to" уже заманал.
Как avr-gcc подключает и компилирует вставки #include "ffff.h" мне видимо не понять.

В файле qqq.c стоит вызов функции с передачей в нее нескольких параметров, эта функция описана в www.c, а ее объявление в www.h
В qqq.c добавляю инклуд www.h с этой объявленной функцией.
Что ему не нравиться?
Спасибо.

[aaarrr]

Изложите проблему менее абстрактно: что именно написано в www.c, www.h, qqq.c и какое сообщение выдает дословно?

[Alt.F4]

aaarrr, ё-мана, это оказывается в Source Files (AVR Studio 4) надо добавлять все файлы с расширением *.c, я думал компилятор все сам подключит.
Блин, полдня убил зря

[MrYuran]

Как avr-gcc подключает и компилирует вставки #include "ffff.h" мне видимо не понять.

Так же, как и любой другой компилятор.
Тупо вставляет содержимое подключаемого файла туда, где вы укажете директивой #include

[_Pasha]

ё-мана, это оказывается в Source Files (AVR Studio 4) надо добавлять все файлы с расширением *.c, я думал компилятор все сам подключит.

Ы, откуда он (компилятор) узнает, что именно ему надо компилировать? Как раз-таки из содержимого файла проекта. Чистологика и никакого обману
Есть люди, которые любят написать makefile типа раз и навсегда, в т.ч. предусмотреть, чтобы компилилось всё, что находится в папке проекта *.S, *.c, *.cpp
Лично мне такое не нравится, но их тоже понять можно: а нефиг посторонним исходникам делать в проекте! Так что выбирайте себе концепцию по душе.

Сообщение отредактировал _Pasha - Aug 6 2012, 12:35

[maksimp]

но их тоже понять можно: а нефиг посторонним исходникам делать в проекте!

Чтобы ограничить потери случайно испортив файл, часто делаю его копии в ту же папку. В проводнике "Копировать" и сразу "Вставить". В папке есть "www.c", "Копия www.c", "Копия (2) www.c" и т.д.

[Сергей Борщ]

В проводнике "Копировать" и сразу "Вставить". В папке есть "www.c", "Копия www.c", "Копия (2) www.c" и т.д.

В Far-подобном файловом менеджере Shift-F6, End, _ Файл получает расширение .cpp_, все проблемы исключаются. Зато не нужно вручную прописывать в makefile каждый новый файл исходника - его достаточно просто создать. И Эклипса не путается при индексировании исходников.

[dxp]

В Far-подобном файловом менеджере Shift-F6, End, _ Файл получает расширение .cpp_, все проблемы исключаются. Зато не нужно вручную прописывать в makefile каждый новый файл исходника - его достаточно просто создать.

+1!

[AHTOXA]

В Far-подобном файловом менеджере Shift-F6, End, _

Если копировать, то Shift+F5. Хотя зачем копировать, когда есть svn - не очень понятно.
А я для временного исключения файла из проекта делаю папку unused и перемещаю файл туда (эклипсе говорю, чтоб не трогала эту папку).

[Alt.F4]

Подскажите, пожалуйста, как описать массив структур FontTable, все время ругается на несовместимость типа указателя?
Спасибо.

Код

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};

Сообщение отредактировал Alt.F4 - Oct 4 2012, 07:51

[MrYuran]

Подскажите, пожалуйста, как описать массив структур FontTable, все время ругается на несовместимость типа указателя?
Спасибо.

Вот так:

Код

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

Имя массива - уже указатель.

[Alt.F4]

MrYuran, компилятор пишет: ../font.h:1362:3: warning: initialization from incompatible pointer type

[_Артём_]

Подскажите, пожалуйста, как описать массив структур FontTable, все время ругается на несовместимость типа указателя?
Спасибо.

Потому что

Код

uint8_t *

- указатель на байт в ОЗУ,
а font_0x31

Код

PROGMEM

то есть во flash находится.

[xemul]

Правильно пишет.
uint8_t * index
uint8_t font_0x31[6] PROGMEM

[Alt.F4]

А как тогда объявить указатель на массив во флэш?
з.ы. Ради интереса удалил PROGMEM, ничего не поменялось.
Пишет: ../font.h:1660:3: warning: initialization discards qualifiers from pointer target type

Добавлено:
Удалил "static const" перед uint8_t font_0x31[6] PROGMEM и варнинг пропал, но по прежнему выдает какую-то ошибку и она почему-то не отображается в билдере...

Добавлено еще раз:
Фув, наконец-то скомпилировалось. Вчера полдня и сегодня до обеда сходил с ума

Сообщение отредактировал Alt.F4 - Oct 4 2012, 08:43

[MrYuran]

MrYuran, компилятор пишет: ../font.h:1362:3: warning: initialization from incompatible pointer type

Так это ж не ругается, так, под нос бухтит

Может, так попробовать:
static const* uint8_t font_0x31 PROGMEM = {0x00,0x81,0xff,0x80,0x00,0x00};

[_Артём_]

з.ы. Ради интереса удалил PROGMEM, ничего не поменялось.
Пишет: ../font.h:1660:3: warning: initialization discards qualifiers from pointer target type

Напишите так

Код

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}};

- без static const и без &.

[demiurg_spb]

Код

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}
};

А в остальном у вас всё изначально правильно и static const к месту и PROGMEM.
Правда FontTable тоже во флешь можно разместить...

[Alt.F4]

Правда FontTable тоже во флешь можно разместить...

Да, попозже наверное так и сделаю, пока надоело бодаться с этим компилятором, придирается ко всяким мелочам.

[_Артём_]

Да, попозже наверное так и сделаю, пока надоело бодаться с этим компилятором, придирается ко всяким мелочам.

Я так понял, что const uint8_t * может и к flash, и к eeprom, и к озу обращаться?
Удобно, IAR так не позволяет.

[demiurg_spb]

Не совсем так. В avr-gcc const uint8_t* ptr при простом разыменовывании указателя всегда обращается к ОЗУ,
а чтобы читать из флеша или eeprom нужно через макросы мыкаться: pgm_read_byte(ptr) и eeprom_read_byte(ptr).
Что как раз не так удобно как в IAR.
Но и в avr-gcc 4.7.0 тоже появилась аналогичная IARу фича: ключевое слово __flash и теперь стало возможно

Код

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;

[Alt.F4]

а чтобы читать из флеша или eeprom нужно через макросы мыкаться: pgm_read_byte(ptr) и eeprom_read_byte(ptr).

Миллионным перебором вариантов стал объявлять адрес для ЕЕ как void* adrr;
А для чтения свой макрос написал (не знал, что есть eeprom_read_byte()):

Код

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

Для тренировки ответьте себе на следующий вопрос, чем отличаются следующие указатели:

Вроде бы так:
char* p1; - переменный указатель на массив типа char
const char* p2; - указатель константа на массив типа char (хотя он все равно будет размещен в ОЗУ как и первый)
char* const p3; - тоже самое
const char* const p4; - тоже самое

Сообщение отредактировал Alt.F4 - Oct 5 2012, 09:47

[demiurg_spb]

Вроде бы так:

Нет не так. Отсюда и все проблемы..
char* p1; - указатель на char
const char* p2; - указатель на const char
char* const p3; - константный указатель на char
const char* const p4; - константный указатель на const char

Пока вы азы языка Си не поймёте, так и будете ходить по граблям, занимаясь подбором-перебором и изобретая очередные грабли.
Остановитесь, почитайте азы - сразу увидите как всё станет понятно и красиво.

А для чтения свой макрос написал (не знал, что есть eeprom_read_byte())

Зря... Достаточно
#include <avr/eeprom.h>
и в путь.
В avrlibc очень оптимально написано, что касается eeprom, да многое другое тоже.

[demiurg_spb]

.

[_Артём_]

Не совсем так. В avr-gcc const uint8_t* ptr при простом разыменовывании указателя всегда обращается к ОЗУ,
а чтобы читать из флеша или eeprom нужно через макросы мыкаться: pgm_read_byte(ptr) и eeprom_read_byte(ptr).

Сделал так:

Код

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];

Но похоже GCC просто соптимизировал чтение.
Если массивы объявить не как const, работать не будет.

[demiurg_spb]

Да оптимизировал и не читал (constant propagation в действии).
Вы их (test1,2,3) как volatile const объявите или как extern из других единиц трансляции (не из main.c)...