Уважаемые гуру помогите мне разобраться? в IAR нет функций преобразования bin2dec и обратно. Помогите уважаемы с кодом для С. Прошу не пинать сильно

Вам это нужно для вывода значения на индикатор? Тогда что-то такое:

Десятичные цифры в массиве будут лежать "наоборот": D[0]-самая младшая (единицы), D[1]-десятки, и тд.
Если нужно делать это быстро, то вычитанием десятков тысяч, единиц тысяч, сотен, и тд (воспользуйтесь поиском - это уже не раз обсуждалось).

Есть способы и быстрее. Правда, требуют аппаратного умножителя.

Да, я опрашиваю DS1307 и вывожу значения на LCD на основе ks0108. Беда оказалась в том, что после того как секунды отсчитали 9 следующее значение было уже 16, после 24 сразу же 32 и т.д. Где-то наткнулся, что неправильно преобразованы числа, но готовой функции в IAR не нашел, как в CV вот и решил обратиться, т.к. кодов не нашел

Дык это совсем другое дело, там же BCD. Каждый байт в символьный десятичный вид преобразуется банально:

а что такое bcd? я что-то не совсем понял гугл

Двоично-десятичный код

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

Раз уж вы использовали умножение, то видимо и деление не будет извратом. Используйте операцию % - получение остатка от целочисленного деления.

Люди, Вы наверное будите смеяться, но у меня снова получился полный бред, вот код:

Конечно бред. Вот код. Может не эстетично, зато дешево надежно и практично И без умножений-делений, которые требуют соответствующих библиотек, увеличивающих конечный код. Актуально для МК с небольшим количеством набортной Flash.

Естественно аргумент функции не должен превышать значения 9999.

странно конечно, но правильно не работает... может проблема в переменных, которые я поставил, вместо uintl6_t и предположит, что это unsigned int

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

Что именно не работает? На входе бинарное число, на выходе бинарно-десятичное. Т.е. каждый полубайт (4 бита) содержит число, не превышающее основания 10 (от 0 до 9). Допустим на входе число 1234=0x04D2, на выходе получаем 0x1234. После этого достаточно выделить каждый из полубайтов, прибавить к нему ASCII-код символа '0'=0x30 и можно выводить на экран число в привычном десятичном виде.
В стандарте Си нет конкретной размерности у типов переменных. Размерность типов переменных задается в стандартном хедере limits.h и может отличаться на разных кристаллах и компиляторах. А стандарт лишь гарантирует их отношение char ≤ short int ≤ int ≤ long int. Чтобы избежать неоднозначности я использовал конкретный тип uint16_t, который соответствует 16-и битному unsigned int.

Простите за глупый вопрос, но как выделить полубайт?


Ну мне надо вывести значения в десятичной системе, которые выдает мне DS1307

Накладыванием маски и сдвигами.

Я вот тут книгу читал:

Информация устарела? (книга старая)

Дык вы не просто читайте, а еще и в смысл прочитанного вникайте
Написано же Потому что эти типы описаны в стандарте С99 (раздел 7.18 Integer types) и являются стандартными. Для использования их достаточно подключить хедер stdint.h.

Вот так. После чего будет: bcd_l = 2, а bcd_h = 1.

Куда вывести? На дисплей? В символьном виде? Если да - то я Вам еще вот в этом посте написал. Что не ясно?

Оооо, дошло наконец! Автор имел ввиду не использовать - т.е. не определять своих имен, оканчивающихся на "_t" или начинающихся с "_"

Ну а по делу:
Ув. топикстартер, мне кажется Вам нужно заново перечитать все ответы и ЧЕТКО сформулировать проблему, которая сейчас преграждает вам путь к победе.
Прямо не стесняясь, от начала и до конца. Что уже сделано, что не понятно, что уже хоть как-то работает и как оно работает.
И тогда, возможно, кто-нибудь вам поможет.

Возьмем хотя-бы этот совет rezident: С этим всё ясно? Потому что может так случиться, что смысл Вами до конца был не понят, а от того, что дважды спросить одно и то-же бывает неудобно - вы можете остановиться на пол пути.

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

Честно говоря, Вы правы, я толком не могу понять, что значит наложить маску... я так понимаю, что сдвигая часть бит, маска как бы восполняет недостающие биты, причем в нужном мне порядке, верно? например 00001111 сдвигаем влево на 4 бита - получаем 11110000 и добавляем маску 00001111, то получится 11111111 верно?

Отлично. Начнем.
Предположим, из порта(или откуда-то ещё) мы считали значение 01110011 и нам нужен младший полу-байт(т.е. 4бита) Понятно, что правильный ответ = 0011, но как заставить машину отбросить 4старших байта и оставить 4младших.
Тут нап придется вспомнить логические операции AND, OR, XOR, NOT.. и хотя-бы приблизительно помнить таблицу истинности для этих операций.
Так вот, поскольку процессор может выполнять эти операции за один такт - то можно достаточно эффективно получить интересующие нас 4бита.
Для этого я предлагаю воспользоваться логической операцией AND(лог. умножение). Так вот, то значение, НА КОТОРОЕ мы будем умножать значение переменной, считанной с порта - мы будем называть маской.
Так вот. По таблице истинности лог операции AND видно, что в ней "всегда побеждает" ноль(это я так запоминал в детстве). Но сейчас мы можем понять, что умножение на 0 даёт 0:)
Чтобы выделить младшие 4 бита я выберу маску 00001111.
Посмотрим что это нам даст:
01110011
AND
00001111
equal
00000011
Верхняя строка - исходное значение. Ниже - маска. В самом низу результат. Как видим, операции эти потому и называются bitwise, потому что выполняются над битами операндов

Почему rezident упомянул про сдвиг?
Рассмотрим случай, когда нужно получить значение старшего полубайта. Маска будет, соответственно 11110000.
Имеем:
01110011
AND
11110000
equal
01110000
Т.е. младший полубайт мы как-бы обнулили и осталось сдвинуть всё это дело на 4 бита вправо.
01110000 >> 4 == 00000111

Это я привел пример, когда размер переменной == 8бит, а нам нужно 4. Но бывает так, что переменная 16бит, а нам нужно из них, скажем, биты с 10 по 13.
Тогда выбираем маску, с установленными в 1 битами с 10 по 13, а остальные 0. Маска, естественно, должна быть тоже 16битная. Но потом, чтобы значение этих байтов можно было применить как значение(к примеру в операции сравнения) нам нужно подвинуть их так, чтобы бит, стоящий на позиции 10 занял позицию 0. Т.е. нужен сдвиг на 10 вправо.
Для наглядности, предположим что в документации на МК было указано, что биты с 10 по 13 в регистре таком-то, показывают сколько байтов сейчас можно считать из буфера FIFO.
Так вот после описанных мною операций мы получим число байт в буфере

Ну и т.д.
Для закрепления материала задам задачку: нужно УСТАНОВИТЬ бит 5 какого-то(8ми битного) регистра в 0. Что для этого нужно? Какая маска и какая логическая операция должна быть использована?

Кажется до меня дошло!!!!!!!!! Сейчас попробую!!!

Вот что получилось! Отлично работает!
А вот с обратным преобразованием как-то не получилось, вот код


Что я не так сделал? Я хотя бы правильным путем пошел?

Не прочитали статью в википедии, рекомендованную Вам на первой странице треда:

Neytrino В функции dec2bcd в глаза бросается неинициализированная (нулём) переменная(w) . На вид правильно. Но для надёжности стоит различать ещё "+" от "|" . Если уйти от "оптимизации", то функцию можно переписать одной строчкой. на предыдущей странице rezident давал пример того же самого только немного красивее.

rezident Неужели библиотечные "целое/целое" и "%" массивнее самописных? Ведь алгоритм прозрачен и сделать по другому сложно. Разве что вызовы вместо "инлайна" ... Или есть ещё что-то, что я не учитываю?

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

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

Проще всего делать bcd-преобразование непосредственно перед выводом на экран или сразу после ввода значения (если есть ввод). А вычисления делать в обычном бинарном формате, не заморачиваясь десятичной коррекцией.

В стандартном BCD (с весами битов 8-4-2-1) каждая десятичная цифра однозначно представляется 4-мя битами (тетрадой):
0 - 0000
1 - 0001
2 - 0010
...
9 - 1001
Остальные 6 комбинаций (1010, ... , 1111) являются недопустимыми. (угадайте, почему коррекция выполняется именно на 6?)
Если расписать (на бумажке), н-р, сложение двух BCD-чисел

Вычитание - аналогично.
Да и для любого произвольного основания системы счисления тоже аналогично.
Как уже сказал rezident, развлекаться арифметикой непосредственно в BCD смысла нет - проще BCD перевести в обычный двоичный формат, выполнить необходимые вычисления, и перевести результат обратно в BCD.
В конфе уже не раз обсуждались способы BIN->BCD. Самое неприятное в таких преобразованиях (на контроллерах без аппаратного деления) - деление на 10. Для целочисленной арифметики жизнь можно облегчить, н-р, таким образом:

Так, кажется понял буду пробовать, о результатах отпишусь!