Хитрые, необычные алгоритмы и код

[Gudd-Head]

Хм... Тут и так дофига прилепленых тем.

[kolobok0]

51 asm

порой необходимо сохранять на стэке регистры r0-r7.
код при этом типа такой.

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

   mov   a,r0
   push   a

;бла-бла-бла
   
   pop    a
   mov   r0,a

если в МК данные регистры банки отображаются на память(обычно это так), и банки не переключаются, то можно
1) объявить повыше

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

BR0   equ   000h
BR1   equ   001h
BR2   equ   002h
BR3   equ   003h
BR4   equ   004h
BR5   equ   005h
BR6   equ   006h
BR7   equ   007h

2) написать в коде типа

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

   push   BR0

;бла-бла-бла

   pop    BR0

(круглый)

[ILYAUL]

Хм... Тут и так дофига прилепленых тем.

Так может , можно что-то и открепить

[avreal]

51 asm
...

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

   push   BR0

;бла-бла-бла

   pop    BR0

А Вы гляньте внимательнее на свой инструмент. Я довольно много пользовался ассемблерами для mcs51 от AVOCET (это где-то в середине 90-ых) и Keil. У обоих уже были предопределены AR0..AR7 (Absolute Register), причём они зависели от директивы USING, которая указывала, какой сейчас банк регистров используется. Асмом 2500A.D. я пользовался некоторое время до AVOCET ASM51/C51 и сейчас не уверен, но, кажется, у него тоже такая возможность была.
Итого я спокойно писал

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

    USING 1
TF1_isr:
    _push   <PSW,ACC,AR0> ; Тут AR0 равно 8, так как объявлен банк 1.
    ...
    _pop <AR0,ACC,PSW>
    reti

[akl]

...Для преобразования в BCD на asm применял такой код...

Здравствуйте. В качестве пятничной развлекухи прогнал в студии Ваш код. Преобразование занимает 2254 такта. Затем сделал тоже самое по алгоритму, предложенному здесь уважаемым umup. Преобразование занимает 798 тактов.

Спойлер

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

; Преобразователь BIN24-BCD8 

        .INCLUDE "2313def.inc"
   .CSEG

START:
   LDS   R16,$70
   LDS   R17,$71
   LDS   R18,$72

   CLR   R28      ; BCD OUT 10'000'000,1'000'000
   CLR   R29      ; BCD OUT 100'000,10'000
   CLR   R30      ; BCD OUT 1'000,100
   CLR   R31      ; BCD OUT 10,1

   LDI   R24,24
bin24bcd8:
   subi r31,-0x33   ;add 0x33
   sbrs r31, 3   ;if carry to bit 3
   subi r31, 3   ;subtract 3
   sbrs r31, 7   ;if carry to bit 7
   subi r31, 0x30   ;subtract 0x30

   subi r30,-0x33      ; \n" /*add 0x33*/
   sbrs r30, 3         ; \n" /*if carry to bit 3,*/
   subi r30, 3         ; \n" /*subtract 3*/
   sbrs r30, 7         ; \n" /*if carry to bit 7,*/
   subi r30, 0x30      ; \n" /*subtract 0x30*/

   subi r29,-0x33       ;\n" /*add 0x33*/
   sbrs r29, 3          ;\n" /*if carry to bit 3,*/
   subi r29, 3          ;\n" /*subtract 3*/
   sbrs r29, 7          ;\n" /*if carry to bit 7,*/
   subi r29, 0x30       ;\n" /*subtract 0x30*/

   subi r28,-0x33       ;\n" /*add 0x33*/
   sbrs r28, 3          ;\n" /*if carry to bit 3,*/
   subi r28, 3          ;\n" /*subtract 3*/
   sbrs r28, 7          ;\n" /*if carry to bit 7,*/
   subi r28, 0x30       ;\n" /*subtract 0x30*/

; по совету avreal!!!!!

   lsl R18
   rol R17      ;shift input*/
   rol R16
   
   rol r31
   rol r30
   rol r29
   rol r28
   
   dec R24      ;\n"
   brne bin24bcd8   ;repeat for all bits*/
; опционально. Распаковка упакованного BCD по регистрам   
   MOV   R20,R28
   SWAP   R20
   ANDI   R20,$0F
   ANDI   R28,$0F
   MOV   R21,R28

   MOV   R22,R29
   SWAP   R22
   ANDI   R22,$0F
   ANDI   R29,$0F
   MOV   R23,R29

   MOV   R24,R30
   SWAP   R24
   ANDI   R24,$0F
   ANDI   R30,$0F
   MOV   R25,R30

   MOV   R26,R31
   SWAP   R26
   ANDI   R26,$0F
   ANDI   R31,$0F
   MOV   R27,R31

   RJMP   START

За время 2097 тактов этим алгоритмом можно преобразовать bin40->bcd13

Спойлер

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

; Преобразователь BIN40-BCD13 
;
; 02.01.2008
; 02.01.2008

        .INCLUDE "8515def.inc"

   .CSEG
;************************************************
START:
   LDS   R16,$70
   LDS   R17,$71
   LDS   R18,$72
   LDS   R19,$73      ; HEX IN
   LDS   R20,$74

   CLR   R25      ; BCD OUT 10'000'000'000'000,1'000'000'000'000
   CLR   R26      ; BCD OUT 100'000'000'000,10'000'000'000
   CLR   R27      ; BCD OUT 1'000'000'000,100'000'000
   CLR   R28      ; BCD OUT 10'000'000,1'000'000
   CLR   R29      ; BCD OUT 100'000,10'000
   CLR   R30      ; BCD OUT 1'000,100
   CLR   R31      ; BCD OUT 10,1

   LDI   R24,40
bin40bcd13:
   subi r31,-0x33   ;add 0x33
   sbrs r31, 3   ;if carry to bit 3
   subi r31, 3   ;subtract 3
   sbrs r31, 7   ;if carry to bit 7
   subi r31, 0x30   ;subtract 0x30

   subi r30,-0x33      ; \n" /*add 0x33*/
   sbrs r30, 3         ; \n" /*if carry to bit 3,*/
   subi r30, 3         ; \n" /*subtract 3*/
   sbrs r30, 7         ; \n" /*if carry to bit 7,*/
   subi r30, 0x30      ; \n" /*subtract 0x30*/

   subi r29,-0x33       ;\n" /*add 0x33*/
   sbrs r29, 3          ;\n" /*if carry to bit 3,*/
   subi r29, 3          ;\n" /*subtract 3*/
   sbrs r29, 7          ;\n" /*if carry to bit 7,*/
   subi r29, 0x30       ;\n" /*subtract 0x30*/

   subi r28,-0x33       ;\n" /*add 0x33*/
   sbrs r28, 3          ;\n" /*if carry to bit 3,*/
   subi r28, 3          ;\n" /*subtract 3*/
   sbrs r28, 7          ;\n" /*if carry to bit 7,*/
   subi r28, 0x30       ;\n" /*subtract 0x30*/

   subi r27,-0x33       ;\n" /*add 0x33*/
   sbrs r27, 3          ;\n" /*if carry to bit 3,*/
   subi r27, 3          ;\n" /*subtract 3*/
   sbrs r27, 7          ;\n" /*if carry to bit 7,*/
   subi r27, 0x30       ;\n" /*subtract 0x30*/

   subi r26,-0x33       ;\n" /*add 0x33*/
   sbrs r26, 3          ;\n" /*if carry to bit 3,*/
   subi r26, 3          ;\n" /*subtract 3*/
   sbrs r26, 7          ;\n" /*if carry to bit 7,*/
   subi r26, 0x30       ;\n" /*subtract 0x30*/

   subi r25,-0x33       ;\n" /*add 0x33*/
   sbrs r25, 3          ;\n" /*if carry to bit 3,*/
   subi r25, 3          ;\n" /*subtract 3*/
   sbrs r25, 7          ;\n" /*if carry to bit 7,*/
   subi r25, 0x30       ;\n" /*subtract 0x30*/

; по совету avreal!!!!!

   lsl R20
   rol R19
   rol R18
   rol R17      ;shift input*/
   rol R16

   rol r31
   rol r30
   rol r29
   rol r28      ; \n" /*shift out buffer*/
   rol r27
   rol r26
   rol r25
   
   dec R24      ;\n"
   brne bin40bcd13   ;repeat for all bits*/

   RJMP   START

Может кому ещё, кроме меня, пригодится.
Изменил по совету avreal!

почему процесс ждет прерывание , а не прерывание процесс?

[avreal]

А почему не обычное в таких местах

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

   lsl R18
   rol R17
   rol R16   ; r16 bit 7 in C
   rol r31   ; shift into LSB of output
   rol r30
   rol r29
   rol r28

вместо

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

   lsl r31
   rol r30
   rol r29
   rol r28
   
   sbrc R16, 7   ;skip if msbit of input =0*/
   ori  R31, 1        ;set lsb of output*/

   lsl R18
   rol R17      ;shift input*/
   rol R16

[akl]

Да, так лучше.

[Ser60]

При выводе текстовых строк на дисплей очень часто многие строки используются лишь один раз в программе (например при выводе строк меню). Было-бы очень удобно написать как в языках высокого уровня что-то типа PrintString(“Hello World!”), где выводимая строка и место в программе где она выводятся (вызов функции вывода) расположены рядом в программе. Этого можно добиться на ассемблере, поместив выводимую строку сразу после вызова функции PrintString. Идея эта не новая, но я не видел ее имплементации в микроконтроллерах, поэтому привожу свою имплементацию на примере архитектуры MSP430.

Итак, мы будем выводить строку следующим образом:

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

   call   #PrintString      ; output procedure call
   DB   "Hello World!"      ; trailing zero is added
   EVEN
   clr.w   R5         ; next instruction in code

Первая строчка в этом коде – собственно вызов функции вывода строки текста, описанная ниже. Сама текстовая строка определена во второй строчке кода. При заключении текста для вывода в двойные кавычки IAR IDE автоматически добавит в конец строки 0, используемый как критерий окончания строки. Последняя строчка кода – это продолжение программы, я просто поместил туда какую-то команду (clr.w R5) для теста. Наконец, директива EVEN говорит компилятору разместить эту команду начиная с четного адреса. В MSP430 каждая машинная команда должна размещаться по четному адресу в памяти.

Таким образом, сама строка для вывода в функцию PrintString явно не передается и у этой строки даже нет имени. Однако, ее начальный адрес есть не что иное, как адрес инструкции следующей после вызова функции, т.е. адрес возврата из функции, который помещается в стек командой call. После вывода текстовой строки нам надо вернуться не на ее начало для продолжения кода, а на инструкцию после нее (в нашем примере на команду clr.w R5). Следовательно, нужно будет скорректировать адрес возврата в стеке. В процедуре вывода я опустил сам вывод и оставил лишь инструкции для извлечения символов строки для памяти. Прошу прощения за нарушения табуляции - не знаю как здесь с этим бороться - в редакторе IDE все выглядит красиво.

Спойлер

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

PrintString:
   mov.w   @SP, R4         ; pointer to string character
ps1:   mov.b   @R4+, R5      ; character to output
   inc.w   0(SP)         ; update the return address
   tst.b   R5         ; end of string?
   jz   ps2         ; YES - break the loop
        
   ; put here instructions for character processing

   jmp   ps1         ; loop back

ps2:   bit.w   #1, 0(SP)      ; move to the next even address
   jz   ps3         ;  if needed
   inc.w   0(SP)         ; even alignment of the return address
ps3:   ret

Процедура начинается с копирования адреса первого символа текстовой строки в R4 (этот адрес как отмечено выше равен адресу возврата из функции). Таким образом, R4 будет поинтер на выводимый символ в строке, который извлекается из памяти и помещается в R5. После этого адрес возврата в стеке увеличивается на 1 и происходит проверка на окончание строки, т.е. на равенство R5 нулю. Если полученный символ не 0, мы его выводим и переходим на начало цикла с меткой ps1. В противном случае выходим из цикла на метку ps2. Там текущий адрес возврата в стеке проверятся на четность, и если он оказался нечетным, то к нему добавляется 1 (последствия директивы EVEN).

Функцию можно сделать более универсальной, чтобы иметь возможность работать со строками размещенными непосредственно за ней или передаваемых функции в качестве параметра через стек. В стек при этом следует заносить адрес начала строки для вывода, а в теле функции добавится еще одна точка входа. В нижеприведенном коде точки входа в функцию помечены метками PrintString2 и PrintString3. При этом вызовы можно осуществить следующим образом:

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

; первый вариант вызова с передачей параметра через стек
   push.w   #hi         ; passing parameter string
   call   #PrintString2      ; using another entry point

; второй вариант вызова с размещением строки сразу под вызовом функции
   call   #PrintString3      ; output procedure call
   DB   "Hello World!"      ; trailing zero is added
   EVEN
   clr.w   R5         ; next instruction in code

В первой строчке этого кода функции передается адрес текстовой строки для вывода. Сама строка определена где-то в другом месте программы, например как

hi: DB "Hi, there"

Во втором варианте вызова функции строку для вывода следует разместить в коде сразу после вызова как и раньше.

Таким образом, при первом способе передачи параметра через стек адрес возврата в стеке изменять не нужно, в то время как при втором способе вызова нужно увеличивать его на 1 после обработки каждого символа. Для этого в регистр R6 помещается либо число 0 либо 1, и значение этого регистра прибавляется к адресу возврата в стеке в любом случае.

При входе в функцию PrintString2 адрес возврата находится на вершине стека, а адрес строки для вывода непосредственно под ним. Сначала адрес возврата извлекается из стека и копируется в R6. Таким образом, адрес строки для вывода оказывается на вершине стека и он помещается в R4. После копирования адреса начала строки в R4 он больше не нужен в стеке и он заменяется на адрес возврата, хранимый в R6. Это позволяет в основной программе избавиться от удаления адреса строки в стеке после вызова функции.

Спойлер

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

PrintString2:      
   pop.w   R6         ; load return address in R6
   mov.w   @SP, R4         ; load string address in R4
   mov.w   R6, 0(SP)      ; put return address in stack
   clr.w   R6         ; do not update the return address
   jmp   ps4
   
PrintString3:
   mov.w   #1, R6         ; add 1 to the return address
   mov.w   @SP, R4         ; pointer to string character
ps4:   mov.b   @R4+, R5      ; character to output
   add.w   R6, 0(SP)      ; update the return address
   tst.b   R5         ; end of string?
   jz   ps5         ; YES - break the loop
        
   ; put here instructions for character processing

   jmp   ps4         ; loop back

ps5:   bit.w   #1, 0(SP)      ; move to the next even address
   jz   ps6         ;  if needed
   add.w   R6, 0(SP)      ; even alignment of the return address
ps6:   ret

Эти примеры можно легко адаптировать на случай если нужно сохранять рабочие регистры (или другие данные) в стеке при работе функции или если происходит работа с 20-битными адресами в архитектуре MSP430X.

[avreal]

При выводе текстовых строк на дисплей очень часто многие строки используются лишь один раз в программе (например при выводе строк меню). Было-бы очень удобно написать как в языках высокого уровня что-то типа PrintString(“Hello World!”), где выводимая строка и место в программе где она выводятся (вызов функции вывода) расположены рядом в программе. Этого можно добиться на ассемблере, поместив выводимую строку сразу после вызова функции PrintString. Идея эта не новая, но я не видел ее имплементации в микроконтроллерах, поэтому привожу свою имплементацию на примере архитектуры MSP430.
Итак, мы будем выводить строку следующим образом:

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

   call   #PrintString      ; output procedure call
   DB   "Hello World!"      ; trailing zero is added
   EVEN
   clr.w   R5         ; next instruction in code

Чтобы тут не повторяться, вон там было то же самое для AVR

[Ser60]

Вот еще трюк для деления 4-значного десятичного числа (т.е. не превышающего 9999) на 10. Для этого его надо просто умножить на "магическую константу" 6554 и отбросить младшие 16 бит результата. Иными словами, справедливо равенство

[х / 10] = (x * 6554) >> 16

где [x/10] - целая часть от деления. Основанием для этого является школьная формула для суммы геометрической прогрессии степеней 1/4:

1 - 1/4 + 1/16 - 1/64 + ... = 1/(1 + 1/4) = 4/5

Если поделить обе части на 8, получим

1/8 - 1/32 + 1/128 - ... = 1/10

Таким образом, x/10 = х/8 - х/32 + x/128 - ...
и после имножения обеих частей на 2^16, окончательно получим

х/10 * 2^16 = x*(2^13 - 2^11 + 2^9 - 2^7 + 2^5 - 2^3 + 2^1 - ...)

Вопрос сколько членов (бесконечного) знакочередующегося ряда следует взять для достижения требуемой точности? Оказалось, что при х < 16384 достаточно взять указанные выше 7 членов ряда, которые в сумме дают то самое число 6554. Реализация этого способа особенно эффективна на МК с аппаратным 16х16 перемножителем, например MSP430 или PIC24. Для первого из них, например, программа деления числа в R4 занимает 4 операции и выполняется за 11 циклов:

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

mov.w   #6554,&MPY      ; load the "magic" constant
mov.w   R4, &OP2      ; compute R4 *= 6554
nop
mov.w   &RES1, R4      ; R4 = R4 / 10

Для чисел превосходящих 16384 начинает накапливаться погрешность и результат оказывается неточным. Однако, положение можно легко исправить добавлением еще двух членов ряда и умножением результата на 2^20. Магическая константа в этом случае будет иной:

[x / 10] = (x * 104858) >> 20

Эта формула справедлива для любых 16-битных чисел. Однако, для ее эффективной реализации желательно иметь 32х32 аппаратный перемножитель, поскольку магическая константа 17-битная и результат умножения может быть максимум 33-битным. Опять-же для архитектуры MSP430X с аппаратным перемножителем MPY32 программа будет аналогична предыдущей.

Этот алгоритм был применен в программе вычисления цифр у чисел с 4 десятичными знаками. Полный текст программы ниже. По сравнению со стандартным алгоритмом, основанным на схеме Хорнера, этот чуть медленнее (около 100 циклов против 81). Однако, мне нужно было иметь каждую цифру в отдельности, а не BCD представление, получаемое в схеме Хорнера, чтобы потом не вырезать из него цифры. В процессе алгоритма еще вычисляется и остаток от деления на 10, но это пока не так красиво и основано на специальной таблице, поэтому от комментов я здесь воздержусь.

Спойлер

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

   mov.b   #4, R7         ; digit counter
   clr.b   R8         ; pointer correction for
   cmp.w   #8192, R4      ; the 2nd part of table
   jl   d2b         ; it is needed for numbers
   mov.b   #16, R8         ; exceeding 8192

   mov.w   #6554,&MPY      ; load the "magic" constant
d2b:   mov.w   R4, &OP2      ; compute R4 *= 6554
   nop
   mov.w   &RES1, R4      ; R4 = R4 / 10
   mov.w   &RES0, R5      ; computing R4 % 10
   swpb   R5
   rram.w   #4, R5
   and.b   #0x0F, R5
   add.b   R8, R5
   mov.b   table(R5), R5      ; R5 = remainder
   clr.b   R8
   dec.b   R7
   jnz   d2b
table:
   DB   0, 1, 1, 2, 3, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 9
   DB   0, 1, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7, 8, 9, 9

Вот для полноты картины алгоритм преобразования числа в R10 в BCD по схеме Хорнера:

Спойлер

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

        clr.w   R4                      ; storage for 4-digit BCD
        mov.b   #16, R5                 ; loop cnt = # of bits        
dp0:    rla.w   R10                     ; use decimal addition
        dadd.w  R4, R4                  ; operation to convert R4
        dec.b   R5                      ; into BCD
        jnz     dp0

[akl]

"Магические" константы, по мне, получаются гораздо проще X/10=X*K/65536 или K=65536/10=6553,6~6554. Для 20-разрядного числа X/10=X*L/2^20 или L=1048576/10=104857,6~104858.
Перед отбрасыванием младшего слова значение старшего бита этого слова прибавить к результату. Получается правильное математическое округление.

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

;результат умножения в R16...R19 в формате старший-младший
   CLR   ZH
   LSL   R18 ; старший бит, имеющий вес 0.5  в С-флаг
   ADC   R17,ZH
   ADC   R16,ZH

[avreal]

Так, мелочь, даже на эту тему не тянет.
Но я предпочитаю в качестве рабочей пары регистров использовать не R16, R17, а R24, R25 (которые обзываю WL, WH соответственно). С этой парой работают adiw/sbiw и вышеприведенный фрагмент будет таким (R22..R25 -- младший-старший).

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

   SBRC R23, 7
   ADIW R24, 1

Понятно, что при этом я держу младший байт данных в регистре с меньшим номером, но это и более естественно для AVR, и совместимо с С-компиляторами.

[Gudd-Head]

AVR. Задержка на 2 такта одним машинным словом:

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

rjmp PC+1;

вместо двух слов

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

nop;
nop;

[avreal]

AVR. Задержка на 2 такта одним машинным словом:

Именно этот вариант показан в регулируемой задержке в этой же теме. Там же для однословной 3-тактовой задержки в случае наличия регистра, который можно испортить, использован LPM. Ещё когда-то обсуждалось, что в прерывани Z при этом можно не сохранять
В регулируемой задержке уже есть всё равно испорченный регистр, поэтому LPM R, Z. Если регистр R0 свободный в этом месте кода, то можно просто LPM.

Также 2-тактовую задержку сделает

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

    adiw  R24, 0 ; или другая пара

но при наличии rjmp . использовать как задержку смысла нет, зато как однословную проверку регистровой пары на 0 - запросто.

[Ser60]

Опять извечная проблема: преобразование 16-битного беззнакового целого числа в строку (BCD).

Приводимый ниже рекордно быстрый алгоритм годится только для архитектуры MSP430X. В ней имеется таймер реального времени RTC_B, в состав которого входит регистр BIN2BCD. Странно, что в документации slau272a и slau208k на семействa F5xx/F6xx и FR57xx, соответственно, об этом регистре нет ни слова в тексте. Есть лишь краткое упоминание этого регистра в составе регистров RTC, где ему посвящено лишь одно предложение, поэтому его очень легко не заметить. Согласно ДШ, в этот регистр следует сначала записать 12-битное число, а при чтении из него получите 16-битное BCD этого числа. Проще не бывает. Вот пример преобразования 12-битного числа в R4 в BCD в R5. Процедура занимает всего 6 циклов !!!

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

    mov.w   R4, &BIN2BCD
    mov.w   &BIN2BCD, R5

Почему в документации упомянуты лишь 12-битные исходные числа? Ведь максимальное 12-битное число - это 4095, а четырех BCD знаков в 16-битном регистре достаточно для представления чисел вплоть до 9999. Это для меня осталось загадкой. Я попробовал переводить числа вплоть до 9999 - все действительно работает! Более того, оказалось, что при записи в этот регистр чисел от 10000 до 16383 (т.е. 14-битных) в регистре остается лишь последние 4 цифры BCD, а для чисел от 16384 до 65535 процессор оставляет лишь 14 младших бит числа и переводит полученный результат в BCD. Отмечу, что работа этого регистра не эмулируется в симуляторе IAR, по крайней мере я не знаю как его заставить. Однако, посмотреть регистр в работе можно с помощью внутрисхемного отладчика. Я проверял его на процессоре MSP430FR5728.

На основе этого регистра можно сделать быструю процедуру перевода 16-битных беззнаковых целых в R4 в BCD в R5. Процедура использует расширенный набор инструкций MSP430X для работы с 20-битными регистрами и занимает лишь 19 циклов процессора!!!

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

    rrcm.a    #3, R4
    mov.w     R4, &BIN2BCD
    mov.w     &BIN2BCD, R5
    daddx.a   R5, R5
    rlax.a    R4
    daddx.a   R5, R5
    rlax.a    R4
    daddx.a   R5, R5

Работает этот код так: исходное 16-битное число N в 20-битном регистре R4 сдвигается циклически на 3 бита вправо через бит С. При этом в 16 младших битах R4 получается N/8, которое не превосходит 8191, т.е. может быть непосредственно переведено в BCD двумя следующими инструкциями. Эти инструкции не изменяют бит С, который все еще содержит бит 2 числа N, а его биты с номером 1 и 0 после сдвига находятся соответственно в битах 19 и 18 регистра R4. После этого выполняются 3 операции 20-битной десятичной арифметики сложения R5 с самим собой и битом С. Фактически, производятся 3 итерации схемы Хорнера. В результате 5 символов BCD представления получаются в 20-битном регистре R5. Если нужно восстановить исходное число в R4 после работы алгоритма, в конец кода следует добавить инструкцию "rlax.a R4".

Отмечу, что в состав RTC_B также входит регистр BCD2BIN для преобразования BCD в двоичный код, но о нем как-нибудь в другой раз.

[YS]

В ней имеется таймер реального времени RTC_B, в состав которого входит регистр BIN2BCD.

Странно, что в документации slau272a и slau208k на семействa F5xx/F6xx и FR57xx, соответственно, об этом регистре нет ни слова в тексте.

Есть еще в Real-Time Clock (RTC) Overview, стр. 563. Собственно, а что там еще описывать? Записал - прочел, вся работа.

[Ser60]

Еще одна извечная проблема: реализация деления 32-битных чисел с плавающей точкой, представленных в формате IEEE-754 (С-тип float). Цель – скорость. Архитектура – 16-битные МК семейства RL78 фирмы Renesas.

Выше я описал алгоритм быстрого обращения числа, который имеет смысл для процессоров, не имеющих аппаратной поддержки деления. В противном случае есть шанс выполнить операцию быстрее. Семейство RL78 оснащено аппаратным 32/32 делителем целых чисел, вычисляющим для 32-битных чисел 32-битную целую часть и 32-битный остаток от деления за 16 циклов. Этот делитель оформлен как периферийный модуль, независимый от процессора. “Хитрость” алгоритма в том, что пока делитель занят вычислением результата, процессор одновременно можно загрузить еще чем-то полезным для алгоритма. Таким образом получится что-то типа параллельных вычислений. Приводимый алгоритм использует 3 операции аппаратного деления и гарантированно работает только для нормализованных чисел и вычисляет частное за 97 - 110 циклов в зависимости от данных.

Напомню, что в формате IEEE-754 число с плавающей точкой представленно 23-битной мантиссой и 8-битным порядком. Для вычисления частного нужно грубо говоря вычесть порядки и поделить мантиссы. Грубо – потому что для результата меньшего 1 потребуется еще нормализация результата, а к разности порядков нужно добавить bias в соответствии со стандартом. Кроме того, следует учесть возможное переполнение порядка и специальные случаи представления чисел типа 0 или бесконечности. Приведенная ниже программа делит число с символьным именем dev, расположенное в RAM (точнее в ее области, соответствующей saddrp в терминологии адресации RL78), на число под именен der, расположенное там-же. Результат помещается в RAM под именем res.

Перед делением из чисел вырезаются мантиссы и дополняются целой частью, которая для нормализованных чисел всегда равна 1. Фактически, принудительно ставится единица в бите 23 мантиссы каждого из чисел. Полученные мантиссы делимого и делителя сравниваются и если первая не меньше второй, то делимое сдвигается на 7 бит влево. В противном случае оно сдвигается на 8 бит влево (в этом случае из порядка результата следует вычесть 1). Затем полученное 31- или 32-битное делимое делится на 24-битный делитель аппаратным делителем МК. Таким образом, получаем старшие 8 бит мантиссы окончательного результата, включая целую часть. Нетрундо видеть, что старший из полученных 8 бит всегда равен 1. Этот бит равен целой части нормализованного результата, при условии что нет проблем с порядком, например переполнения. На втором шаге остаток от деления (получаемый в 16-битных регистрах MDCH:MDCL) сдвигается на 8 бит влево и загружается в 16-битные регистры делимого (MDAH:MDAL). Сдвиг производится за 11 циклов путем пересылки байтов. Содержимое регистров делителя (MDBH:MDBL) при этом не меняется. После второго деления получаем следуюшие 8 бит результата. Затем опять сдвигаем остаток на 8 бит влево и производим третье деление на делитель, в результате чего получаются последние 8 (из 24) бит мантиссы результата.

Пока производится первое деление мантисс, процессор вычисляет порядок результата. Это занимает 10 циклов из 16 необходимых для деления. В программе ниже я не привел обработку специальных случаев переполнения или “недополнения” (underflow) порядков, при необходимости это легко сделать по усмотрению пользователя. Во время второго деления процессор помещает результат первого деления в регистры результата res, а также вычисляет и помещает туда-же знак частного. Это тоже занимает 10 циклов из 16. Во время третьего деления процессор помещает в регистры res вычисленные ранее вторые 8 бит результата. Это также занимает менее 16 циклов, требуемых для деления, так что остается достаточно времени на обработку специальных случаев (в приводимой тестовой программе эта обработка отсутствует).

В алгоритме имеется резерв по точности. Я имею в виду, что после 3 делений можно получить до 27 бит результата (точнее 26 или 27 в зависимости от нормализации на первом шаге). Дополнительные 2-3 бита можно использовать, например, для повышения точности или округления 24-битной мантиссы. Для этого перед вторым и третьим делениями мантиссу делимого следует сдвигать на 9 бит влево а не на 8 (при этом ее бит целой части попадет в бит 31 регистра делимого). В этом случае после второго и третьего делений будем получать по 9 бит результата (а не по 8 как ранее).

Отмечу, что в имеющейся на момет написания версии системы IAR Kickstart отсутствует эмуляция аппаратного делителя/перемножителя в симуляторе. Отладка алгоритма производилась живьем (внутрисхемно) на МК R5F1006A подсемейства RL78G13. Кроме того, для этого процессора в составе его регистров в IAR отсутствуют MDAH и MDAL (?!) Для подсемейства R78G14 имеется шанс по небольшому ускорению алгоритма за счет того, что регистры данных перемножителя/делителя совмещены с регистрами общего назначения МК.

Спойлер

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

#include "ior5f1006a.h"         
#include "ior5f1006a_ext.h"

#define SCL   0
#define   SDA    1

        RSEG    CSTACK          ; stack segment definition
   RSEG   SADDR_N      ; data segment
dev:    DS 4         ; devidend
der:   DS 4         ; divisor
res:   DS 4         ; result
tmp:   DS 2

        ASEGN   RCODE:CODE, 0   ; vector table
        ORG     RST_vect
        DW      RESET           ; Reset vector

   ORG   0xC0      ; option byte 
   DB   0x6E      ; disable watchdog
   DB   0x1F      ; LVD off 
   DB   0xAA      ; 8 MHz LS mode 
   DB   0x85      ; enable on-chip debugging

        RSEG    CODE            ; code segment
RESET:    movw    SP,    #SFE(CSTACK)
   mov   CMC,    #0x04   ; input mode on X1 pins
   mov   HOCODIV, #0x02   ; set 8 MHz system clock
   set1   PER0.7      ; enable RTC operation
   mov   OSMC,    #0x90   ; select LFO as s/system clock

; setup data
   movw   AX,   #0x70A4   ; setup dividend 0x414570A4 = 12.34
   movw   dev,   AX
   movw   AX,   #0x4145
   movw   dev+2,    AX

   movw   AX,   #0x3333   ; setup divisor 0x40233333 = 2.55
   movw   der,    AX
   movw   AX,   #0x4023
   movw   der+2,    AX

   mov   MDUC,    #0xC0   ; division setup, no interrupt
   mov   A,   der+2
   set1   A.7      ; add hidden 1
   mov   B,   A
   xch   A,   X   
   clrb   A
   movw   MDBH,   AX   ; load divisor MSW
   movw   AX,   der
   movw   MDBL,    AX   ; load divisor LSW   
   
   mov   H,    #127   ; bias
   mov   A,   dev+2
   set1   A.7      ; add hidden 1
   mov   X,   dev+1
   
   cmp   A,   B   
   bh   sh7      ; dividend > divisor
   bnz   sh8      ; dividend < divisor
   movw   BC,   AX   ; preserve AX
   movw   AX,   dev   ; MSB(dividend) = MSB(divider)
   cmpw   AX,   der
   movw   AX,   BC   ; restore AX
   bh   sh8      ; dividend > divisor
   bnz   sh7      ; dividend < divisor
   
sh8:   movw   MDAH,   AX   ; shift dividend 8 bits left
   mov   A,    dev   ; compose LSW(dividend)
   clrb   X
   dec   H      ; adjust the bias   
   br   ft0

sh7:   shrw   AX,   1   ; shift dividend 7 bits left
   movw   MDAH,   AX   ; load dividend MSW      
   mov   A,   dev
   clrb   X
   rorc   A,   1
   xch   A,   X
   mov1   A.7,   CY
   xch   A,    X
ft0:   movw   MDAL,    AX   ; load dividend MSW

;----------
   set1   MDUC.0      ; first division
   movw   BC,   der+2   ; compute the order
   shlw   BC,   1   ; B = divisor order (biased)
   movw   AX,   dev+2 
   shlw   AX,    1   ; A = dividend order (biased)
   sub   A,   B   ; subtract the orders
   add   A,    H   ; add the bias   
   clrb   X
   shrw   AX,   1
   movw   res+2,    AX   ; order   
   
ft1:   mov   A,    MDUC
   bt   A.0,   ft1   ; wait for completion

   movw   AX,   MDAL   ; get 8 bits of result
   movw   BC,   AX   ; save it temporarily

   movw   AX,   MDCL   ; dividend = remainder shifted
   movw   tmp,   AX
   movw   AX,   MDCH
   xch   A,   X
   mov   X,   tmp+1
   movw   MDAH,   AX   ; new devidend MSW
   mov   A,   tmp
   clrb   X
   movw   MDAL,   AX   ; new devidend LSW
   
;----------   
   set1   MDUC.0      ; second division
   movw   AX,    BC   ; get back the first quotient   
   xch   A,   X   ; A = result bits
   clr1   A.7      ; remove hidden 1
   or   A,   res+2
   mov   res+2,    A   ; first byte of result + order   
   
   mov   A,   der+3   ; compose the sign
   xor   A,   dev+3   ; msb(A) = sign bit
   and   A,    #0x80
   or   A,   res+3
   mov   res+3,   A   ; sign + order
   
ft2:   mov   A,    MDUC
   bt   A.0,   ft2   ; wait for completion

   movw   AX,   MDAL   ; get 8 bits of result
   movw   BC,   AX

   movw   AX,   MDCL   ; dividend = remainder shifted
   movw   tmp,   AX
   movw   AX,   MDCH
   xch   A,   X
   mov   X,   tmp+1
   movw   MDAH,   AX   ; new devidend MSW
   mov   A,   tmp
   clrb   X
   movw   MDAL,   AX   ; new devidend LSW
   
;----------   
   set1   MDUC.0      ; third division
   movw   AX,   BC   ; get back the second quotient
   xch   A,   X   
   mov   res+1,    A   ; second byte of result 
ft3:   mov   A,    MDUC
   bt   A.0,   ft3   ; wait for completion

   movw   AX,   MDAL   ; get 8 bits of result
   xch   A,   X   
   mov   res,    A   ; third byte of result
        nop
        END 

[Kavka]

К вопросу о хитрых алгоритмах.
Полезная книга: Генри Уоррен "Алгоритмические трюки для программистов" (оригинальное название "Hacker's Delight" ).
Есть сайт посвящённый этой книге - http://www.hackersdelight.org/ (Google-Перевод)

Спойлер

Книга в Сундуке Кота

[Rimsky]

Очень удобные макросы от уважаемого Чена (AVR ассемблер)

[Kavka]

Язык программирования Си, препроцессор, макросы, 8-bit AVR

Далеко не все в должной степени уделяют внимание препроцессору. И потом появляются обсуждения подобные этому.
Всё бы ничего, но утверждение, что для работы с ножками МК нужно три define-а, IMHO, показывает недостаточное знание темы.
Никого ругать и переубеждать не собираюсь. Как говориться "на вкус и цвет...".

Я взял из своих исходников некоторые макросы.
"Причесал" их и собрал в один файл. (Надеюсь нигде не ошибся.)
Возможно они не идеальны , но работают.
Примеры в комментариях и под спойлером.

Спойлер

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

#include <avr/io.h>

#include "avr_io_macros.h"

#define LED1 B, 1
#define LED2 B, 2

void main()
{
  char a;
  
  PIN_INIT_AS_INPUT(LED1);
  PIN_PULLUP_ON(LED1);
  a = PIN_GET(LED1);
  PIN_PULLUP_OFF(LED1);
    
  PIN_INIT_AS_OUTPUT(LED1);
  PIN_INIT_AS_OUTPUT(LED2);

  PIN_CLR(LED1);
  PIN_CLR(LED2);

  while (1)
  {
    PIN_NEG(LED1);
    PIN_NEG(LED2);
  }
}

Сама по себе тема макросов банальна.
Поэтому прошу - хватит с макросами для ассемблера и Си (достаточно примеров от Чана и этих).
Кому интересно посмотрит, почитает документацию - разберётся.