Вход Наше всё Теги codebook 无线电组件 Поиск Опросы Закон Понедельник
16 июня

О смысле всего сущего 0xFF Средства и методы разработки Мобильная и беспроводная связь Блошиный рынок Объявления

Микроконтроллеры PLD, FPGA, DSP AVR PIC ARM, RISC-V Технологии Кибернетика, автоматика, протоколы Схемы, платы, компоненты

Микроконтроллеры AVR

380467 Топик полностью

whale (15.01.2013 14:51, просмотров: 318) ответил whale на умножение тоже самое ?

осталось придумать как проще сохранять/инсталировать старший бит

Ответить

- Для AVR сохранять/загружать бит проще всего BST/BLD (если бит T не используется для других целей) - Юрий_СВ(15.01.2013 15:33)
  - интересно ) - whale(15.01.2013 16:49)
- команда ASR - koyodza(15.01.2013 15:02, ссылка)
  - Увы, напрямую он не работает. Хотя до недавнего времени, я был совсем противоположного мнения. Так что, для деления Bill(72 знак., 16.01.2013 13:43)
    - Бр-р-р. Подзаблудился. Отрицательным числом будем считать инвертированное число со старшим битом или в допкоде инвертированное, со старшим битом и прибавленной единицей. - mazur(16.01.2013 21:50)
      - обычно второй вариант - koyodza(16.01.2013 23:42)
        
        И если второй вариант, то asr спокойно работает. Так? - mazur(16.01.2013 23:45)
    - это нормально, -5/2=-2,5, при округлении вниз получается -3, всё работает правильно koyodza(250 знак., 16.01.2013 18:30 - 18:34)
      - Все дело в том, что при сдвигах округления нет. И потом, при делении целых чисел Bill(602 знак., 17.01.2013 08:58)
        
        Вы пьяны? Даже комментировать этот бред не хочется, сами перечитайте. Особенно жжет обратимость операции целочисленного деления :=) И не понятно, почему Вы прибавляете -1, а не 1, как я говорил - koyodza(17.01.2013 11:53 - 12:14)
        
        Потому что по правилам деления знак остатка должен иметь знак делимого. - Bill(17.01.2013 12:36)
        
        если "по правилам деления", то не**й выделываться, а так и пишите: a = b / c, а если уж Вы решили использовать сдвиги, то не**й сюда тащить правила деления - koyodza(17.01.2013 13:17)
      - А с минус 1 что делать? Не проще перевести 2 командами в положит. - сдвиг - обратно отриц. - ilyaul(16.01.2013 19:15)
        
        не проще: поменять знак - это или вычитанием из нуля, или инверсия и прибавление единицы. Если речь идет хотя бы о 16-битном, это уже 8 команд минимум - koyodza(16.01.2013 23:44)
        
        Если речть идет о 16-битном то это 2 команды asm ilyaul(56 знак., 17.01.2013 00:56)
        
        ещё обратно забыли преобразовать. А также добавьте ветвление, потому что для положительных чисел это делать не нужно. В общем ананируйте на ассемблер дальше, не буду мешать :=) - koyodza(17.01.2013 01:03)
        
        Ветление там элементарное , проверяется старший бит , либо пропускается перевод в положит. число, либо нет. ilyaul(142 знак., 17.01.2013 01:20)
        
        начинается "если больше 255" :=) Это ещё сравнение и ветвление. Вот и считайте, сколько у вас команд выйдет. Не забудьте, что все эти действия нужно выполнить в обе стороны - koyodza(17.01.2013 02:09)
        
        а чем -1 отличается? Точно так же -1/2=-0.5, при округлении вниз получается -1 koyodza(103 знак., 16.01.2013 23:40)
    - Можно подробнее? - mazur(16.01.2013 15:36)
      - Можно и подробнее. Возьмем для примера число -5. Bill(730 знак., 16.01.2013 16:50 - 16:54)
        
        не предварительно нужно корректировать, а после. А вообще товарищам явно нечем заняться, как изучать элементарные операции на асме - koyodza(16.01.2013 23:50)
        
        Именно нужна предварительная проверка и коррекция для нечетных чисел. Я же в примере подробно расписал. Или нет? - Bill(17.01.2013 09:01)
        
        нет. Постпроверка логичнее и удобнее, особенно если деление выполняется не на 2, а на большую степень. Коррекцию достаточно выполнить один раз в конце, а в Вашем случае её нужно делать перед каждым сдвигом - koyodza(17.01.2013 11:52)
        
        Так вы возьмите несколько примеров и проверьте. И потом, что именно Bill(164 знак., 17.01.2013 12:01 - 12:23, ссылка)
        
        сами проверьте. Тот бит, который уходит в перенос, если сдвигов более чем один то который последним. Если результат отрицательный, то просто прибавьте уходящий в перенос бит - koyodza(17.01.2013 12:10)
        
        Интересно, как это с одной посткоррекцией ADC поделить -5 на 8 и получить 0? - AD(17.01.2013 12:30)
        
        элементарно. Только выше я ошибся - не последний выдвинутый бит, а логическая сумма (обычно удобно использовать флаг Z) всех выдвинутых битов koyodza(481 знак., 17.01.2013 13:29)
        
        кстати, вариант прибавления только последнего выдвинутого бита даёт арифметическое округление, что часто может оказаться даже удобнее koyodza(2292 знак., 17.01.2013 17:43 - 18:21)
        
        В DSP 100 лет как применяется. Вам не удастся обойти С AD(56 знак., 17.01.2013 17:59)
        
        в DSP много чего применяется, речь не о них. Вы попробуйте свою конструкцию для 8-битника откомпилировать. Свой вариант деления на степень двойки с арифметическим округлением для AVR я показал ниже - koyodza(17.01.2013 18:14, ссылка)
        
        Деление на 16 AD(472 знак., 17.01.2013 18:30)
        
        а теперь то же самое, но для произвольной степени делителя - koyodza(18.01.2013 01:02)
        
        Вот именно, что с одной не получится. С предварительной коррекцией проще и быстрее AD(145 знак., 17.01.2013 13:49)
        
        да не быстрее и не проще: предварительная коррекция по Bill`у нужна перед каждым сдвигом. И не нужно приводить сишных примеров, а то я просто напишу a=b/c и идите лесом. А логическое или всех выдвинутых битов - это просто проверка на 0, которая во koyodza(38 знак., 17.01.2013 13:52 - 13:56)
        
        Кто мешает добавить все единицы одним махом? Сложение - линейная операция. И неужели ассемблерный эквивалент этого кусочка не очевиден? - AD(17.01.2013 13:57)
        
        насчёт "неужели ассемблерный эквивалент этого кусочка не очевиден" последний раз повторяю, идите лесом. Или забудьте про языки высокого уровня в этой ветке, или нам здесь нечего обсуждать - koyodza(17.01.2013 14:06)
        
        в Вашем случае (при пред-коррекции) нужно наложить маску на исходное число, если там не 0, то прибавить константу, а не единицу (попробуйте поделить -5 на 8 своим методом), а это может оказаться сложнее, чем пользоваться сложением с флагом переноса - koyodza(17.01.2013 14:04)
        
        Напишите проще AD(653 знак., 17.01.2013 14:12)
        
        а теперь попробуйте поделить на 128 :=) - koyodza(17.01.2013 14:25)
        
        Какие-то проблемы? Повторяю, напишите проще или хотя бы так же AD(585 знак., 17.01.2013 14:32 - 14:36)
        
        попробую. Для деления с округлением к нулю отрицательного 16-разрядного числа на 2 на AVR получается всего 4 команды. Дополнил для чисел большей разрядности и арифметического округления к ближайшему целому koyodza(1842 знак., 17.01.2013 17:28 - 18:11)
        
        Забавно, получилось хуже, чем С (при делении на 4 и больше), и при этом неправильно. AD(93 знак., 17.01.2013 17:57)
        
        попробуйте сделать то же самое для чисел с большей разрядностью, а также для переменной степени делителя. Пример с делением на 128 видимо не очень удачен, т.к. сдвиги вправо здесь удобнее заменить на сдвиги влево. Я просто хотел показать koyodza(47 знак., 17.01.2013 18:06 - 18:12)
        
        покажите где именно неправильно - koyodza(17.01.2013 17:57)
        
        ASR Rlow/ROR Rhigh, при этом ADIW Rlow - AD(17.01.2013 18:00)
        
        опечатка, спасибо. Конечно же ASR Rhigh затем ROR Rlow. Исправил - koyodza(17.01.2013 18:02)
        
        Еще раз -> - Bill(17.01.2013 12:24, ссылка)
        
        покажите там хоть одну ассемблерную команду. Конечно, в С при сдвиге вправо младший бит теряется, да и старший не копируется. Эти приёмы оптимизированы именно для С, а не для ассемблера - koyodza(17.01.2013 13:22)
        
        интересно, какой компилятор они используют, что результат (n>>31 & 2) у них может быть 2 ? Про (n>>31 & 99) ещё интереснее - koyodza(17.01.2013 13:50)
        
        Ну-у-у, я с отрицательными числами еще не работал, так что мнение бывалых для меня ценно... - mazur(16.01.2013 23:53)
  - для многобайтовых (в том числе 16-битового) нужно сделать ASR для старшего байта, затем ROR для последующих - koyodza(15.01.2013 15:24)
    - при ASR старший бит не меняется чтоли ? - whale(15.01.2013 16:48)
      - я же выше ссылку дал - koyodza(15.01.2013 17:02)
        
        для умножения я так понимаю придеться пользоваться BST/BLD как Юрий предлагал ? - whale(15.01.2013 20:35)
        
        Ну почему, можно, например: set, clt. Соответственно, дальше brtc, brts. Подчеркиваю, например. - mazur(15.01.2013 22:01)
        
        понятно, с умножением не так красиво - whale(16.01.2013 01:18)
      - Нет. - mazur(15.01.2013 16:51)
        
        что нет ? - whale(15.01.2013 20:32)
        
        Он ответил на выше заданный Вами вопрос - ilyaul(15.01.2013 20:45)
        
        что старший бит не меняется нет ? те не меняется ? два слова написать по русски пальцы устают чтоли - whale(15.01.2013 21:08)
        
        нафига, если вы всё равно не читаете ответов? Если бы прочитали, то уже этого вопроса не возникало бы - koyodza(15.01.2013 21:11, ссылка)
        
        я это написал раньше чем вашу ссылку прочитал - whale(16.01.2013 01:16)
- Это называется арифметический сдвиг. Вон в Z80 он был :)) - POV(15.01.2013 15:01)
  - В некоторых процессорах арифметический сдвиг может отсутствовать (например, в AVR), но тогда, обычно, присутствует "сдвиг через бит переноса" (команда RRC). В этом случае: копируем бит знака в перенос, а затем сдвигаем. - Пaлыч(15.01.2013 15:09)
    - Ой, а продай мне хотя бы один AVR с отсутствующей командой ASR - я такие перлы коллекционирую :)) - MBedder(15.01.2013 15:20)
      - Извиняюсь, речь я вёл про МК51... - Пaлыч(15.01.2013 15:47)
        
        "Мы говорим - Ленин, подразумеваем - Партия"(с) :)) - MBedder(15.01.2013 15:50)
        
        :))) - Bill(16.01.2013 14:57)