Вопросы по С/С++ (СИ)

[ARV]

для анализа их изменения и оперативного изменения тех самых настроек

micro-SD и FatFS от нашего японского коллеги по имени Чен решают любые проблемы, как с количеством записей, так и с анализом, так и со строками и всем прочим. файловый ввод-вывод - наше всё. для 128-й меги вообще не вопрос.

[MOHCTEP]

Спасибо друзья! Вроде разобрался, благодаря вашей помощи.

[MOHCTEP]

Появились еще вопросы, уважаемые коты. Прошу помочь.
1 Доселе обходился как-то без чисел с плавающей точкой, а тут пришлось их попробовать и нарвался на проблему. Почему-то не хотят они у меня плавать, а норовят в целочисленные превратиться. Пробовал готовить по всякому... Что я не так делаю?

Код: Выделить всё

//float a = (float)((year / 19) - floor(year / 19)); // 0
   float a;
   //a = (float)(year / 19) - (uint8_t)(year / 19); // 0
   a = year / 19;
   num2dec(a * 1000,3);
   uart1_puts(digi_buffer);uart1_puts("\r\n"); // 106.000
   a = (float)(year / 19);
   num2dec(a * 1000,3);
   uart1_puts(digi_buffer);uart1_puts("\r\n");//106.000

2 Это, как бы, продолжение предыдущего разговора. Вот структура:

Код: Выделить всё

typedef struct{
   uint16_t time;   /* 2 bytes */
   uint32_t a;      /* 4 bytes */
   int16_t b[4];   /* 2 * 4 = 8 bytes */
   uint8_t c[4];   /* 1 * 4 = 4 bytes */
   /* total = 18 bytes */
}data_t;

Этими структурами постепенно заполняется ЕЕПРОМ (около 200 штучек). Теперь, мне со всех записей нужно прочесть в массив, допустим значения data_t.b[2] или все data_t.a. Вот как это правильно сделать и чтоб оперативка не сильно тратилась? В идеале бы только на массив нужных, в данное время, данных.

[Reflector]

Код: Выделить всё

float a;
a = year / 19.0f;  // или a = (float)year / 19;

А ты сначала целочисленно делишь а потом результат приводишь к float...

[MOHCTEP]

Reflector, Спасибо! Так действительно работает!
А вариант

Код: Выделить всё

//a = (float)(year / 19)

У меня почему-то не работал правильно.

[NStorm]

Потому что опять же сначала целочисленное деление, а уже потом приведение результата к float. Из-за скобок.
Между

Код: Выделить всё

a = (float)(year / 19);

И

Код: Выделить всё

a = (float)year / 19;

Огромная разница. Во 2ом случае сначала year приводится к float, и потом делится на 19 уже как float.

Добавлено after 6 minutes 28 seconds:
[uquote="MOHCTEP",url="/forum/viewtopic.php?p=3885141#p3885141"]Этими структурами постепенно заполняется ЕЕПРОМ (около 200 штучек). Теперь, мне со всех записей нужно прочесть в массив, допустим значения data_t.b[2] или все data_t.a. Вот как это правильно сделать и чтоб оперативка не сильно тратилась? В идеале бы только на массив нужных, в данное время, данных.[/uquote]

Код: Выделить всё

uint32_t buf;
eeprom_read_block(&buf, sizeof(data_t) * NR_BLOCK + sizeof(data_t.time), sizeof(buf)); // Прочитать с блока NR_BLOCK (порядковый номер) значение .a

Ну т.е. банально вычисляем начало блока, плюс добавляем пропуск того, что идет до нужных данных, т.е. скипаем их. И читаем нужное кол-во байт. Если все блоки надо прочитать - ну проходимся по очереди NR_BLOCK от 1 до N.

[MOHCTEP]

NStorm, Спасибо! С плавающим "флотом" вроде понял суть. А со структурами, вот как мне точно попасть на нужную переменную? Судя по вашему примеру, структура сохраняется в порядке объявления переменных?
И для чтения, к примеру, data_t.с[2] надо вот этакую конструкцию писать?

Код: Выделить всё

eeprom_read_block(&buf, sizeof(data_t) * NR_BLOCK + sizeof(data_t.time) + sizeof(data_t.a) + sizeof(data_t.b) + sizeof(data_t.c[0]) * 2, sizeof(buf));// Прочитать с блока NR_BLOCK (порядковый номер) значение .c[2]

[NStorm]

MOHCTEP, компилятор не меняет порядок в структуре. В каком порядке задали - в таком порядке оно будет в памяти. Т.е. да, "сохраняется в порядке объявления переменных". Единственный момент - как вы структуру в EEPROM писать будете. Если целиком структуру через eeprom_write_block(), то всё будет в таком порядке. Но если вручную как-то - то порядок уже от вас зависеть может.
В вашем примере - да, почти так. Только sizeof(data_t.b) надо еще на 4 умножить, т.к. там у вас массив в примере выше.
Ну и ес-но для удобства, чтобы не писать эту длинную фигню каждый раз, можно определить макрос. Вроде:

Код: Выделить всё

#define DATA_T_SZ sizeof(data_t)
#define DATA_T_C2_OFFSET sizeof(data_t.time) + sizeof(data_t.a) + sizeof(data_t.b) * 4 + sizeof(data_t.c[0]) * 2
...
eeprom_read_block(&buf, DATA_T_SZ * NR_BLOCK + DATA_T_C2_OFFSET, sizeof(buf));

Или написать небольшую функцию, которая будет считать нужны адрес каждый раз. Смотря как много разных элементов структуры вам так отдельно выцеплять надо. Функция будет такты отнимать на расчет адреса, макросы с фиксированными смещениями считаются на этапе компиляции, но будут занимать место во флэше.

[MOHCTEP]

Оппа! А я полагал, что "sizeof(data_t.b)" выдаст мне размер массива, а "sizeof(data_t.c[0])" - размер элемента массива?
За макросы - опять спасибо! Дельная идея, воспользуюсь.

[NStorm]

[uquote="MOHCTEP",url="/forum/viewtopic.php?p=3885789#p3885789"]Оппа! А я полагал, что "sizeof(data_t.b)" выдаст мне размер массива, а "sizeof(data_t.c[0])" - размер элемента массива?[/uquote]
Брр... нет, это я уже загнался на вечер выходного дня. Конечно же умножать не нужно, т.к. sizeof(array) вернет размер целиком массива в байтах. Это я почему-то решил, что берется от одного элемента массива тоже. Вы правы в данном случае.

[MOHCTEP]

NStorm, Ффух! Спасибо! А то у меня уже голова оквадратилась.

[Пока_без_кота]

Доброго времени суток. Имеется код выбора slave через 4-to-16 bit decoder

Спойлер

Код: Выделить всё

switch(peripheral){
				case SPI_PERIPHERAL_0:
					REG_SPI_MR |= SPI_MR_PCS(0b0000);
					break;
				case SPI_PERIPHERAL_1:
					REG_SPI_MR |= SPI_MR_PCS(0b0001);
					break;
				case SPI_PERIPHERAL_2:
					REG_SPI_MR |= SPI_MR_PCS(0b0010);
					break;
				case SPI_PERIPHERAL_3:
					REG_SPI_MR |= SPI_MR_PCS(0b0011);
				break;
				case SPI_PERIPHERAL_4:
					REG_SPI_MR |= SPI_MR_PCS(0b0100);
				break;
				case SPI_PERIPHERAL_5:
					REG_SPI_MR |= SPI_MR_PCS(0b0101);
				break;
				case SPI_PERIPHERAL_6:
					REG_SPI_MR |= SPI_MR_PCS(0b0110);
				break;
				case SPI_PERIPHERAL_7:
					REG_SPI_MR |= SPI_MR_PCS(0b0111);
				break;
				case SPI_PERIPHERAL_8:
					REG_SPI_MR |= SPI_MR_PCS(0b1000);
				break;
				case SPI_PERIPHERAL_9:
					REG_SPI_MR |= SPI_MR_PCS(0b1001);
				break;
				case SPI_PERIPHERAL_10:
					REG_SPI_MR |= SPI_MR_PCS(0b1010);
				break;
				case SPI_PERIPHERAL_11:
					REG_SPI_MR |= SPI_MR_PCS(0b1011);
				break;
				case SPI_PERIPHERAL_12:
					REG_SPI_MR |= SPI_MR_PCS(0b1100);
				break;
				case SPI_PERIPHERAL_13:
					REG_SPI_MR |= SPI_MR_PCS(0b1101);
				break;
				case SPI_PERIPHERAL_14:
					REG_SPI_MR |= SPI_MR_PCS(0b1110);
				break;
				case SPI_PERIPHERAL_15:
					REG_SPI_MR |= SPI_MR_PCS(0b1111);
				break;
			}

который покрывает все возможные варианты. Но он явно избыточный, если я например использую в конкретном проекте только 9 slave-ов. Возможно ли с помощью дефайна и макроса/ов, создать конструкцию, которая сгенерирует за меня только 9 case-ов, не создавая ненужные. Не прошу готового варианта, подскажите хотя бы, что гуглить ?
Up: Вроде Х-макросы то что нужно.

[ПростоНуб]

Пока_без_кота, а что мешает изначально сделать значение peripheral равным значению требуемой маски?
Тогда весь развесистый case сведется к одной строке
REG_SPI_MR |= SPI_MR_PCS(peripheral);

[Пока_без_кота]

[uquote="ПростоНуб",url="/forum/viewtopic.php?p=3895214#p3895214"]а что мешает ...[/uquote]
Мне помешала зашоренность сознания. Спасибо за умную мысль.

[Gudd-Head]

Как на 51-м ядре максимально быстро и компактно (не табличным способом) отзеркалить байт?
Пока приходит в голову только 8 строк подряд

Код: Выделить всё

if (in&0x01) out |= 0x80;
...
if (in&0x80) out |= 0x01;

[NStorm]

Gudd-Head,

Код: Выделить всё

unsigned char reverse(unsigned char b) {
   b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
   b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
   b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
   return b;
}

Взял отсюда: https://stackoverflow.com/questions/260 ... -in-a-byte

[tonyk]

[uquote="NStorm",url="/forum/viewtopic.php?p=3901934#p3901934"]Gudd-Head,

Код: Выделить всё

unsigned char reverse(unsigned char b) {
   b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
   b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
   b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
   return b;
}

Взял отсюда: https://stackoverflow.com/questions/260 ... -in-a-byte[/uquote]
Решение универсальное.

Если же конкретно под 51-ый, то у него есть куча команд обработки битов. Всё эти биты доступны на Си. В Кейле были макросы для команд ротации и сдвига через перенос. Получается очень просто: сдвиг А через перенос, загрузка С в нужный бит В. И так 8 раз. В конце загрузка В в А.

[Gudd-Head]

[uquote="NStorm",url="/forum/viewtopic.php?p=3901934#p3901934"]Gudd-Head,

Код: Выделить всё

   b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
   b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
   b = (b & 0xAA) >> 1 | (b & 0x55) << 1;

[/uquote]
Видел я это, в "алгоритмических трюках для программистов". Но есть у меня подозрение, что это только на Сях красиво выглядит. А по факту на 51-м ядре развернётся в огромную простыню. Хотя если компилятор догадается SWAPнуть... Надо проверить.
[uquote="tonyk",url="/forum/viewtopic.php?p=3901963#p3901963"]Всё эти биты доступны на Си. В Кейле были макросы для команд ротации и сдвига через перенос.[/uquote]
А вот здесь можно подробней? Среда Keil uVision 4.

[waddds]

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

f(int arr[]) {...}

int a[10];
int n;

Варианты вызова функции в программе:

f(a); или f(&a[0]); // если массив обрабатывается с нулевого элемента
f(a+3); или f(&a[3]); // если начинаем с третьего элемента
f(a+n); или f(&a[n]); // если начальный элемент заранее неизвестен

Все ли я правильно написал?

[NStorm]

waddds, да, только учтите, что так легко выйти за границы массива внутри функции. Поэтому по хорошему еще размерность массива в функцию передавать (до конца сколько осталось). Ну и учитывать, что в функцию передается не копия массива, а указатель на текущий массив. И изменив значения в функции, поменяется и исходный массив.