[ISK2010 0]

Использую Keil....

 

Есть переменная a. Теперь каким-то образом хочу указатель на int "b" не просто определить как адрес переменной "а", а используя некое константное выражение:

 

u32 a;

u32 *b = (u32*)(((u32)(&a) - 0x40000000)*32 + 0x42000000);

 

Но компилятор выдает ошибку типа "не константное выражение". Но я то знаю, что константное.

 

Что делать? Вариант проинициализировать этот указатель b перед использованием отпадает, т.к. он уже используется)

 

P.S. Это мне нужно для побитовых операций с некоторыми переменными в STM32F1xx.

 

 

 

 

 

[GetSmart 0]

Что делать? Вариант проинициализировать этот указатель b перед использованием отпадает, т.к. он уже используется)

Непонятно, как уже используется?

[xemul 0]

Но компилятор выдает ошибку типа "не константное выражение". Но я то знаю, что константное.

Вы можете на этапе компиляции сказать, по какому адресу живёт a? Вот и компилятор не может.

Вариант проинициализировать этот указатель b перед использованием отпадает, т.к. он уже используется)

"П-п-прведи". (С)

Если что-то до такой степени мешает инициализировать b перед первым использованием, напишите свой init().

 

[777777 0]

Есть переменная a. Теперь каким-то образом хочу указатель на int "b" не просто определить как адрес переменной "а", а используя некое константное выражение:

<...>

Ничченепонимаю. Ты можешь словами объяснить, куда должен указывать b?

[ISK2010 0]

Непонятно, как уже используется?

Я вас запутал. Имел в виду, что вариант этот уже используется.

 

Вы можете на этапе компиляции сказать, по какому адресу живёт a? Вот и компилятор не может.

Я не могу, а keil может. Например, определение: "u32 *b = (u32*)(((u32)(&a) - 0x40000000) + 0x42000000);" работает. А вот стоит добавить что-то сложнее вычитания или сложения, то ошибка.

"П-п-прведи". (С) Если что-то до такой степени мешает инициализировать b перед первым использованием, напишите свой init().

Я свой инит итак использую, но это не по феншую, и я думаю, что есть более хитрое решение.

 

 

Ничченепонимаю. Ты можешь словами объяснить, куда должен указывать b?

b должен указывать туда, куда мы определим с помощью мегаформулы из адреса &а. Если конкретно, то в моем случае b указывает на начало a в битбенд области ОЗУ.

[sigmaN 0]

u32 *b = (u32*)(((u32)(&a) - 0x40000000)*32 + 0x42000000);

Мисье знает толк в извращениях )))

 

Вы может быть более конкретно бы описали суть решаемой Вами задачи? может быть окажется, что и не нужно всё это....

[alexeyv 0]

А вот стоит добавить что-то сложнее вычитания или сложения, то ошибка.

 

Почитайте стандарт (или любую книжку по Си).

С указазателями можно выполнять ТОЛЬКО следущие операции:

• & - взятие адреса
• * - взятие значения
• присвоение указателей
• сложение/вычитание указателя и целого числа
• сравнение указателей
• присвоение нуля и сравнение с ним
• Может что еще забыл!?!?

 

И ВСЕ!!!!

В этом списке нету ни умножения, ни деления, ни даже возведения в степень.

А теперь посмотрите на свой код и скажите какая операция лишняя??

[GetSmart 0]

В рунтайме любые операции работают. На этапе компиляции ограниченное кол-во.

[Палыч 9]

В рунтайме любые операции работают. На этапе компиляции ограниченное кол-во.

Какие операции "не работают" на этапе компиляции в примере ТС ? Я понимаю, что значение адреса переменной на этапе компиляции неизвестно, будет определено позже линковщиком, а в примере ТС значение этого адреса на что-то там умножается... В общем, я бы с Вами согласился, о том, что не все операции "работают" при компиляции, но (!) давайте упростим пример ТС до такого

u32 * b = (u32 *)( (u32)(&a) );

Что мы видим? Компилятор считает это неконстантным выражением. Пробуем найти: какая часть этого выражения - "не константа" с точки зрения компилятора?

u32   c = (u32)(&a);

Здесь всё нормально. Выходит, что преобразование u32 в указатель делает выражение неконстантным? Пробуем:

u32 * d= (u32 *)( 0x200UL );

Тоже - всё нормально. Так почему же не "работает" u32 * b = (u32 *)( (u32)(&a) ) ? Кто может объяснить?

 

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

[ISK2010 0]

Какие операции "не работают" на этапе компиляции в примере ТС ? Я понимаю, что значение адреса переменной на этапе компиляции неизвестно, будет определено позже линковщиком, а в примере ТС значение этого адреса на что-то там умножается... В общем, я бы с Вами согласился, о том, что не все операции "работают" при компиляции, но (!) давайте упростим пример ТС до такого

u32 * b = (u32 *)( (u32)(&a) );

Что мы видим? Компилятор считает это неконстантным выражением. Пробуем найти: какая часть этого выражения - "не константа" с точки зрения компилятора?

 

Не работает умножение 32. А пример u32 * b = (u32 *)( (u32)(&a) ); работает в keil.

 

 

С помощью этой формулы я получаю адрес начала структуры флагов в битбенд области ОЗУ. И обращаюсь к каждому флагу в отдельности. На данный момент это очень оказалось кстати. Например, раньше я работал с флагами через маски или флаги делал 8битными. И к этом флагам добавлял флаги "занятости флагов", дабы не произошло ошибок чтения-модификации-записи. А с битбендом отказался от всего этого. Никаких масок и проблем.

 

Сейчас адрес начала флагов в битбенд области ОЗУ расчитываю в функции инициализации флагов. и к любому флагу обращаюсь так:

 *(u32*)((u32)Addr_BB_Flags + NumberOfFlag<<2) = 1; //установка флага
*(u32*)((u32)Addr_BB_Flags + NumberOfFlag<<2) = 0; //сброс

и все замечательно работает.

 

Думал, что есть какая-нибудь фишка keil, так сказать какой-нибудь атрибут или прагма, чтобы можно было без всякой инициализации определить этот указатель

Изменено 3 сентября, 2011 пользователем ISK2010

[alexeyv 0]

Тоже - всё нормально. Так почему же не "работает" u32 * b = (u32 *)( (u32)(&a) ) ? Кто может объяснить?

 

У меня все работает. Компилируется без ошибок. Правда не в Keil.

И синтаксически это правильное выражение.

 

Для ТС.

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

 

 

Изменено 3 сентября, 2011 пользователем alexeyv

[ISK2010 0]

Нашел еще одно решение) Тупо заставил запихнуть мои флаги по конкретному адресу ОЗУ 0x20004000 и на калькуляторе рассчитал адрес зеркала в бидбенд области = 0x220C8000. Но это опять не по феншую

[alexeyv 0]

У вас в начале топика в корне не правильная формула расчета

 

д.б. примерно так:

// в  начале файла, если этипеременные глобальные:
u32 a;
u32 *b;

// в теле какой-либо функции, перед использованием b:
b = (u32 *)( 0x22000000 + ((u32)(&a)- 0x20000000)*32);

 

Дело в том что на этапе компиляции, еще не известны все адреса и компилятор не может вычислить такое сложное выражение

Но в теле какой-либо функции можно схитрить, вычислив адрес как простое арифметическое выражение и преобразовать его в адрес.

 

Если же вы хотите задать значение "b" на этапе компиляции, то возможно вам надо расположить "a" по строго определенному адресу. Для этого изучайте директивы линковщика и компилятора.

 

A mapping formula shows how to reference each word in the alias region to a corresponding

bit in the bit-band region. The mapping formula is:

bit_word_addr = bit_band_base + (byte_offset x 32) + (bit_number × 4)

where:

bit_word_addr is the address of the word in the alias memory region that maps to the

targeted bit.

bit_band_base is the starting address of the alias region

byte_offset is the number of the byte in the bit-band region that contains the targeted bit

bit_number is the bit position (0-7) of the targeted bit.

Example:

The following example shows how to map bit 2 of the byte located at SRAM address

0x20000300 in the alias region:

0x22006008 = 0x22000000 + (0x300*32) + (2*4).

Writing to address 0x22006008 has the same effect as a read-modify-write operation on bit

2 of the byte at SRAM address 0x20000300.

Reading address 0x22006008 returns the value (0x01 or 0x00) of bit 2 of the byte at SRAM

address 0x20000300 (0x01: bit set; 0x00: bit reset).

Изменено 3 сентября, 2011 пользователем alexeyv

[skripach 5]

А пример u32 * b = (u32 *)( (u32)(&a) ); работает в keil.

Я бы на месте компилятора такое глотать не стал :), хотя в IAR тоже работает, вернее компилится, а работает или нет не проверял.

[ReAl 0]

Дело в том что на этапе компиляции, еще не известны все адреса и компилятор не может вычислить такое сложное выражение

Это, вообще говоря, не компиляторово дело, а линкерово. Компилятор и &a может только записать как «а туда затолкай адрес вон того» (особенно при extern u32 a).

Если линкер не позволяет задать ему сложные выражения (из известных на этапе линковки величин!), то ничего и не выйдет.

 

Но в теле какой-либо функции можно схитрить, вычислив адрес как простое арифметическое выражение и преобразовать его в адрес.

В режиме С++ катит и строка из корневого сообщения -- компилятор просто создаст функцию-инициализатор для b и затолкает её в таблицы на правах конструктора.