Господа, что-то не понимаю следующего:

Даю описание структуры

typedef struct SettingMenu
{
unsigned int
P1,
P2,
...
...
P100;
} Setup;

Где-то в модуле(да неважно где) создаем новую структуру типа Setup

Setup LocalSetup;

Требуется заполнить поля структуры какими-нибудь значениями. Так как количество полей большое, резонно использовать косвенную адресацию.
Берем адрес структуры и в цикле запихиваем в структуру данные.

Setup LocalSetup;// Создаем структуру типа Setup
Setup *sptr;// Указатель
...
...

sptr = & LocalSetup;// Определяем адрес структуры

for (c=0; c<100; c++)
{
*sptr = c; // Записываем по адресу некое значение
sptr++; // Увеличиваем адрес
}

Это классический пример С, значения пишутся во все поля без проблем

В Keil-е номер не проходит - ругается на разные типы данных строки *sptr = c, хотя теоретически я получил в качестве адреса структуры адрес первого поля этой структуры.
Как бы это правильно разрулить???

насчет классики не уверен, особенно в том месте, где Вы указываете имя структуры сперва в стандарте С++ (после struct), а потом еще и в classic - после закрывающей скобки, но в принципе любой уважающий себя современный компилятор не должен разрешать подобные вольности.
1. переменная sptr имеет тип Setup *, соответственно, *sptr - типа Setup, а Вы пытаетесь инициализировать ее с помощью переменной типа (предположительно) int
2. даже если приведенную Вами конструкцию скомпилировать путем явного приведения типа (то есть, написав

все равно инструкция sptr++ выполнится неправильно (Вы, очевидно, ожидаете инкремента на размер int, а получите - на размер Setup)
Не могу сказать, что это пример хорошего кода, но очевидно Вы в классическом примере упустили тот факт, что там, думаю, было написано так:

в этом случае программа соберется и будет работать примерно так, как Вы рассчитываете

Хотите массив - используйте!!!
typedef struct SettingMenu
{
unsigned int P[100];
} Setup;

Спасибо sergik_vrn , попробую...
А насчет массива:
имеется добрая сотня значений меню, и в теле программы помнить какой элемент массива за что отвечает - нереально!!! Надо иметь бумажку, где все эти элементы сопоставляются - короче, гемороище...
Проще указать каждой переменной адрес, где она будет лежать в RAM, а не использовать массив.

Спасибо за ответы...

1. тот вариант, что я привел - вовсе не оптимальный, просто в нем исправлены Ваши ошибки
2. адрес элемента массива это <имя_массива>+<номер элемента>
3. также настоятельно рекомендую воспользоваться массивом и не заниматься ерундой. судя из того, что я понял по приведенному исходнику, Вам массив и нужен, причем даже без всякой обрамляющей структуры

пассаж насчет указания адресов "лежания" для переменных до моего понимания не дошел

Я так понял, что Andrei_S говорит о том, что в структуре каждой переменной он может задать осмысленное имя, в то время как для массива потребуется некий список на "бумажке", чтоб знать какой элемент что означает.

Пояснение по адресам "лежания":
имеется установочное меню, включающее в себя несколько десятков пунктов. Каждому пункту меню соответствует своя переменная. В процессе работы используются значения этих переменных.
Если будет сделан массив, как Вы предлагаете, то мне придется помнить, какой из элементов массива за что отвечает.
Да, будет очень удобно в этот массив переписывать данные, например, из ПЗУ в одном единственном цикле
,
но в программе помнить о том, какая ячейка чему соответствует - весьма тяжело, и не исключены ошибки.
Используя прямую адресацию в RAM, типа



я смогу в одном цикле выполнить действия аналогичные примеры выше, но только с косвенной адресацией



Значения из Eprom автоматом перепишутся по нужным адресам.
Только для этого я предполагаю явное указание адреса.
А в теле программы читать и писать, например, пункт меню Baud_Rate гораздо понятнее и приятнее чем, например, Array[64]

присоединяюсь к sergik_vrn

Структура, все элементы которой имеют одинаковый тип, явно напрашивается на то, чтобы быть массивом. Тем более, автор сам использует цикл для перебора элементов.

Сложно запомнить? Хорошо. А для чего тогда используются комментарии?

Комирование структуртоже никто не отменял

Интересно, ну и что Вы хотели этим пояснить:



Это не скомпилиться без явного приведения типа в нормальном компиляторе:

если P1x - структура.

Почитайте про перечислимый тип (enum).
Именно он напрашивается в качестве индекса массива. Вы получите и массив, допускающий последовательный перебор, и мнемонические имена элементов этого массива.

Согласитесь, что работать всеже удобнее, когда имя переменной сразу дает полное представление о ней без необходимости плодить пачками комментарии возле строк типа:


К тому же в случае необходимости есть возможность легко ввести в структуру данные других типов.

Пардон, скомпилилось без вопросов...

Ага, только работать не будет (int по адресу 0x40003002).
Честное слово, не могу понять, что Вам нужно получить в результате - структуру меню с возможностью загрузки из EEPROM? Зачем эти фиксированные адреса и прочие извращения?

Пардон, почему то решил что P1x ранее объявлена как некая структура. Но не понял зачем Вы так делаете, что мешает просто объявить


и работать с указателем на нее, чем укладывать все в определенном месте RAM, а потом все арвно придется создавать указатель типа структуры на этот адрес

убедился, что все понял правильно, просто формулировка про адреса меня смутила.
посмотрите в треде Вам кто-то уже советовал использовать enum, присоединяюсь. наиболее правильно собирать однотипные элементы в массив, а для адресации на уровне идентификатора использовать enum

Имеется большое количество переменных. Я хочу как можно сильней упростить их перезапись (в том числе и в ПЗУ).

Например писать:
BaudRate = Read_Eprom(10);
StopBit = Read_Eprom(11); и так сто раз весьма утомительно.

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

Если уж все элементы однотипные, то чем тогда не подходит предложенное простое решение - объявите их как массив, а для индекса используйте перечисление с "говорящими" названиями.

как я понимаю, фактически Вы хотите кешировать в ОЗУ некий набор параметров, хранящийся в NVRAM.
в таком случае если структура конфигурации сложная, то необходимо оформить ее в виде структуры, и читатьиз NVRAM блоком примерно как Вы и собирались (путем приведения типа указателя), только я бы оформил такое чтение отдельной функцией. если же параметры конфигурации однотипные, и Вы всего лишь желаете их поименовать по-разному, объявляйте массив и адресуйте его элементы через enum.

Вовсе нет. Смотрите:Здесь Size_X и Size_Y имеют такой же тип, что и члены следующего за ними массива, но включать их в этот массив было бы очень ненаглядно.
Как я понял, автор вопроса хранит в структуре данные, которые хоть и имеют один и тот же интегральный тип, но логически не эквивалентны. Если я не прав, то красивым и верным будет решение, предложенное vmp, если же я прав, то подход автора в осмысленным именовании каждого члена безусловно правильный, а для удобства на каких-то операциях работать со структурой как с массивом можно использовать union:использование здесь массива размером 1 является некоторым хаком чтобы не именовать структуру. При проверке индекса массива нужно использовать sizeof() от union. Если структуре дать имя, тогда можно в качестве размера массива задать sizeof() структуры, но в коде при доступе к членам появляется в общем-то ненужное имя структуры.

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

Простите за серость, но адресацию элементов через enum я еще не делал...
Pls, не подскажете ли конструкцию???

если разные, делайте как делали, это правильно
по поводу enum:

union {
unsigned char mass[10];
struct
{
unsigned char Num;
unsigned char Rate;
unsigned char Baud;
unsigned char Led;
unsigned char P4;
unsigned char P5;
unsigned char P6;
unsigned char P7;
unsigned char P8;
struct {
unsigned char bit0:1;
unsigned char bit1:2;
unsigned char bit2:3;
} bits;
} rec;
} eeprom;

eeprom.rec.Num=0;
for(u=0;u<sizeof(eeprom);u++)
eeprom.mass[u]=0;

Большое спасибо всем!
Буду пробовать...

по поводу enum:

не хорошо, так как заставляет сами заниматься преобразование типов



/* Читаем из flash все в память */
void ReadFlashToRam(void)
{
unsigned int i;
unsigned char *data;

data=(unsigned char *)&Flash;
for(i=0;i<sizeof(Flash);i++)
data[i]=EEpromRead(i);
};

Я всегда делал так.

memset(&LocalSetup, 0, sizeof(Setup)) тогда уж.

А если такая ситуация


P.S. А првельней мне кажеться

Итак, общими усилиями получилось следующее:
имеется некая структура типа setup (все-таки структура а не массив, т.к. типы данных разные )




Работает отлично, заморочек с чтением/записью разных типов данных нет. Большое спасибо!!

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

Указано явно:


Такой вопрос: как это сделать не с явным указанием, а по номеру элемента структуры
например, ReadSinglePar(LocalSetup,5), где 5 - пятый элемент структуры, т.е. Parametr5 ?

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

я бы на Вашем месте еще оформил чтение блока памяти как функцию, тогда программа приобрела бы законченый вид. типа, Read_EEPROM((u8 *)&config, MEM_ADDR, sizeof(config));


для этого есть макросы sizeof() и offsetof()
например:
Read_EEPROM((u8 *)&config.info_1, MEM_ADDR + offsetof(Config_Type, info_1), sizeof(config.info_1));

Уже сделал, большое спасибо!

...как вариант

#define BAUD_RATE 2


unsigned int Settings[64];


....


Settings[BAUD_RATE] = 9600;

В принципе, ничего, и ремарки не нужны... Но годится в случае одного типа переменных.

Цитата

..как вариант#define BAUD_RATE 2

и до этого доходили аж 3 страницы

Но а все-таки, а как уйти от названия элементов структуры к порядковому номеру элемента этой структуры?

Хотелось бы вместо названия поля info_1 писать номер этого поля, например 1

Например, я последовательно вывожу на индикацию эти 100 параметров структуры:
N1 120
N2 300
....
и т.д.

При нажатии кнопок я могу изменять значения и перезаписывать их в ПЗУ
Если я, например, изменил один из параметров, то для записи в ПЗУ я должен сначала сопоставить значение переменной N и название соответствующего поля типа:


Можно ли это модифицировать?

Как пользоваться - OFFSET(тип_структуры, имя_элемента) выдаст смещение от начала структуры до указанного элемента. Размер элемента можно получить по sizeof(type.field).



Тогда я бы сделал еще одну табличку с дескрипторами полей. Например, массив структур с описателями параметров. В него заносил бы тип поля, смещение от начала, размер, формат вывода, строку с именем, минимальное и максимальное значения и т.д. А индекс этого массива для читабельности описал как enum.

Если типов данных сравнительно немного, сделайте отдельные массивы на отдельные типы, а потом адресуйтесь по define по смещениям