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

[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:

MOHCTEP писал(а):

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

Код:

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]

MOHCTEP писал(а):

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

Брр... нет, это я уже загнался на вечер выходного дня. Конечно же умножать не нужно, т.к. 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: Вроде Х-макросы то что нужно.

Последний раз редактировалось Пока_без_кота Вс сен 20, 2020 16:25:40, всего редактировалось 1 раз.

[ПростоНуб]

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

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

ПростоНуб писал(а):

а что мешает ...

Мне помешала зашоренность сознания. Спасибо за умную мысль.

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

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

Решение универсальное.

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

[Gudd-Head]

NStorm писал(а):

Gudd-Head,

Код:

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

Видел я это, в "алгоритмических трюках для программистов". Но есть у меня подозрение, что это только на Сях красиво выглядит. А по факту на 51-м ядре развернётся в огромную простыню. Хотя если компилятор догадается SWAPнуть... Надо проверить.

tonyk писал(а):

Всё эти биты доступны на Си. В Кейле были макросы для команд ротации и сдвига через перенос.

А вот здесь можно подробней? Среда 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, да, только учтите, что так легко выйти за границы массива внутри функции. Поэтому по хорошему еще размерность массива в функцию передавать (до конца сколько осталось). Ну и учитывать, что в функцию передается не копия массива, а указатель на текущий массив. И изменив значения в функции, поменяется и исходный массив.