اموزش DSP

[ali833]

پاسخ : اموزش DSP

با سلام. و ادامه دستورات ضرب...

MPYS P,T,loc16 :
این دستور نتیجه ضرب قبلی که در رجیستر P قرار دارد را بعد از شیفت از رجیستر ACC کم می کند به علاوه محتوای علامت دار 16 بیتی رجیستر T را در محتوای ادرس ضرب می کند و نتیجه را در رجیستر P قرار می دهد.

ACC = ACC − P << PM;
P = signed T * signed [loc16];

; Calculate using 16-bit multiply:
; Y = (X0*C0) >> 2) + (X1*C1 >> 2) + (X2*C2 >> 2)
SPM −2 ; Set product shift to >> 2
MOVP T,@X2 ; ACC = P, T = X2
MPYS P,T,@C2 ; ACC = ACC − P = 0, P = T*C2
MOV T,@X1 ; T = X1
MPYA P,T,@C1 ; ACC = X2*C2>>2, P = T*C1
MOV T,@X0 ; T = X0
MPYA P,T,@C0 ; ACC = X1*C1>>2 + X2*C2>>2, P = T*C0
ADDL ACC,P << PM ; ACC = X0*C0>>2 + X1*C1>>2 + X2*C2>>2
MOVL @Y,ACC ; Store result into Y

MPYB ACC,T,#8bit :

این دستور محتوای رجیستر T را در عدد ثابت 8 بیتی بدون علامت ضرب می کند و نتیجه را در ACC قرار می دهد.

ACC = signed T * 0:8bit

; Calculate signed using 16-bit multiply:
; Y32 = Y32 + (X16 * 5)
MOV T,@X16 ; T = X16
MPYB ACC,T,#5 ; ACC = T * 5
ADDL @Y32,ACC ; Y32 = Y32 + ACC

MPYU P,T,loc16 :

این دستور محتوای رجیستر T را در محتوای ادرس اشاره شده ضرب می کند و نتیجه 32 بیتی را در رجیستر P ذخیره می کند.

P = unsigned T * unsigned [loc16];

; Calculate unsigned value: Y32 = X16 * M16;
MOV T,@X16 ; T = X16
MPYU P,T,@M16 ; P = T * M16
MOVL @Y,P ; Store result into Y32

MPYU ACC,T,loc16 :
این دستور مانند دستور قبل می باشد با این تفاوت که نتیجه در رجیستر ACC قرار می گیرد.

ACC = unsigned T * unsigned [loc16];

; Calculate unsigned using 16-bit multiply:
; Y32 = Y32 + X16*M16
MOV T,@X16 ; T = X16
MPYU ACC,T,@M16 ; ACC = T * M16
ADDL @Y32,ACC ; Y32 = Y32 + ACC

MPYXU ACC,T,loc16 :

این دستور محتوای علامت دار رجیستر T را در محتوای بدون علامت ادرس اشاره شده ضرب ونتیجه را در رجیستر ACC قرار می دهد.

ACC = signed T * unsigned [loc16];

[left; Calculate signed using 16-bit multiply:
; Y32 = Y32 + (signed) X16 * (unsigned) M16
MOV T,@X16 ; T = X16
MPYXU ACC,T,@M16 ; ACC = T * M16
ADDL @Y32,ACC ; Y32 = Y32 + ACC][/left]

MPYXU P,T,loc16 :
این دستور نیز مانند دستور قبلی می باشد با این تفاوت که نتیجه در رجیستر P قرار می گیرد.

P = signed T * unsigned [loc16];

; Calculate ”Y32 = X32 * M32” by parts using 16-bit multiply:
MOV T,@X32+0 ; T = unsigned low X32
MPYU ACC,T,@M32+0 ; ACC = T * unsigned low M32
MOV @Y32+0,AL ; Store low result into Y32
MOVU ACC,@AH ; Logical shift right ACC by 16
MOV T,@X32+1 ; T = signed high X32
MPYXU P,T,@M32+0 ; ACC = T * low unsigned M32
MOVA T,@M32+1 ; T = signed high M32, ACC += P
MPYXU P,T,@X32+0 ; ACC = T * low unsigned X32
ADDL ACC,@P ; Add P to ACC
MOV @Y32+1,AL ; Store high result into Y32

[ali833]

پاسخ : اموزش DSP

خوب در ادامه دستورات ضرب می رسیم به دستور مجذور.
SQRA loc16 :
این دستور مقدار موجود قبلی داخل رجیستر P را بعد از شیفت به رجیستر ACC اضافه می کند و سپس محتوای ادرس اشاره شده را به داخل رجیستر T بار می کند و بعد از محاسبه مربع ان نتیجه را داخل رجیستر P ذخیره می کند.

ACC = ACC + P << PM;
T = [loc16];
P = T * [loc16];

; Calculate sum of squares using 16-bit multiply:
; int16 X[N] ; Data information
; sum = 0;
; for(i=0; i < N; i++)
; sum = sum + (X[i] * X[i]) >> 5;
MOVL XAR2,#X ; XAR2 = pointer to X
SPM −5 ; Set product shift to ”>> 5”
ZAPA ; Zero ACC, P, OVC
RPT #N−1 ; Repeat next instruction N times
||SQRA *XAR2++ ; ACC = ACC + P >> 5,
; P = (*XAR2++)^2
ADDL ACC,P << PM ; Perform final accumulate
MOVL @sum,ACC ; Store final result into sum

SQRS loc16 :
این دستور نیز مانند دستور قبلی می باشد با این تفاوت که محتوای رجیستر P از رجیستر ACC کم می شود.

ACC = ACC − P << PM;
T = [loc16];
P = T * [loc16];

; Calculate sum of negative squares using 16-bit multiply:
; int16 X[N] ; Data information
; sum = 0;
; for(i=0; i < N; i++)
; sum = sum − (X[i] * X[i]) >> 5;
MOVL XAR2,#X ; XAR2 = pointer to X
SPM −5 ; Set product shift to ”>> 5”
ZAPA ; Zero ACC, P, OVC
RPT #N−1 ; Repeat next instruction N times
||SQRS *XAR2++ ; ACC = ACC − P >> 5,
; P = (*XAR2++)^2
SUBL ACC,P << PM ; Perform final subtraction
MOVL @sum,ACC ; Store final result into sum

(XMAC p,loc16,*(pma:

این دستورمحتوا قبلی رجیستر P را بعد از شیفت به رجیستر ACC اضافه می کند.سپس رجیستر T را با مقدار اشاره شده به وسیله مد ادرس دهی "loc16" پر می کند.در اخر محتوای 16 بیتی علامت دار رجیستر T را در محتوای ادر حافظه برنامه داده شده ضرب می کند.

ACC = ACC + P << PM;
T = [loc16];
P = signed T * signed Prog[0x3F:pma];

محدوده ادرس قابل اشاره بین 0x3F0000 تا 0x3FFFFF می باشد.

; Calculate sum of product using 16-bit multiply:
; int16 X[N] ; Data information
; int16 C[N] ; Coefficient information, located in high 64K
; sum = 0;
; for(i=0; i < N; i++)
; sum = sum + (X[i] * C[i]) >> 5;
MOVL XAR2,#X ; XAR2 = pointer to X
SPM −5 ; Set product shift to ”>> 5”
ZAPA ; Zero ACC, P, OVC
RPT #N−1 ; Repeat next instruction N times
||XMAC P,*XAR2++,*(C) ; ACC = ACC + P >> 5,
; P = *XAR2++ * *C++
ADDL ACC,P << PM ; Perform final accumulate
MOVL @sum,ACC ; Store final result into sum

(XMACD P,loc16,*(pma :

دستور XMACD مانند دستور XMAC می باشد به اضافه یک انتقال داده.در این دستور ابتدا مقدار قبلی رجیستر P بعد از شیفت به رجیستر ACC اضافه شده سپس رجیستر T با محتوای ادرس اشاره شده پر می شود.و محتوای رجیست T در محتوای ادرس برنامه اشاره شده ضرب شده و نتیجه علامت دار 32 بیتی در رجیستر P قرار می گیرد.در اخر محتوای رجیستر T در ادرس حافظه بالا تر اشاره شده به وسیله "loc16" قرار می گیرد.

ACC = ACC + P << PM;
T = [loc16];
P = signed T * signed Prog[0x3F:pma];
[loc16 + 1] = T;

; Calculate FIR filter using 16-bit multiply:
; int16 X[N] ; Data information
; int16 C[N] ; Coefficient information, located in high 64K
; sum = X[N−1] * C[0];
; for(i=1; i < N; i++)
; {
; sum = sum + (X[N−1−i] * C[i]) >> 5;
; X[N−i] = X[N−1−i];
; }
; X[1] = X[0];
MOVL XAR2,#X+N ; XAR2 = point to end of X array
SPM −5 ; Set product shift to ”>> 5”
ZAPA ; Zero ACC, P, OVC
XMAC P,*−−XAR2,*(C) ; ACC = 0, P = X[N−1] * C[0]
RPT #N−2 ; Repeat next instruction N−1 times
||XMACD P,*−−XAR2,*(C+1) ; ACC = ACC + P >> 5,
; P = X[N−1−i] * C[i],
; i++
MOV *+XAR2[2],T ; X[1] = X[0]
ADDL ACC,P << PM ; Perform final accumulate
MOVL @sum,ACC ; Store final result into sum

[ali833]

پاسخ : اموزش DSP

سلام دوستان دستورات ضرب 16 بیتی ر 16 بیتی تموم شد حالا می رم سراغ 32x32 بیتی.

IMACL P,loc32,*XAR7 :
++IMACL P,loc32,*XAR7:
این دستور ابتدا مقدار قبلی موجود در رجیستر P را بدون شیفت به رجیستر ACC اضافه می کند.سپس محتوای 32 بیتی ادرس اشار شده به وسیله "loc32" را در محتوای ادرس برنامه اشاره شده به وسیله XAR7 ضرب می کند.در این دستور رجیستر PM تعیین می کند که کدام قسمت 38 بیت پایین نتیجه 64 بیتی در رجیستر P ذخیره شود.

ACC = ACC + unsigned P;
temp(37:0) = lower_38 bits(signed [loc32]
* signed Prog[*XAR7 or XAR7++]);
if( PM = +4 shift )
P(31:4) = temp(27:0), P(3:0) = 0;
if( PM = +1 shift )
P(31:1) = temp(30:0), P(0) = 0;
if( PM = 0 shift )
P(31:0) = temp(31:0);
if( PM = −1 shift )
P(31:0) = temp(32:1);
if( PM = −2 shift )
P(31:0) = temp(33:2);
if( PM = −3 shift )
P(31:0) = temp(34:3);
if( PM = −4 shift )
P(31:0) = temp(35:4);
if( PM = −5 shift )
P(31:0) = temp(36:5);
if( PM = −6 shift )
P(31:0) = temp(37:6);

; Calculate sum of product using 32-bit multiply and retain
; 64-bit result:
; int32 X[N]; // Data information
; int32 C[N]; // Coefficient information (located in
// low 4M)
; int64 sum = 0;
; for(i=0; i < N; i++)
; sum = sum + (X[i] * C[i]) >> 5;
; Calculate low 32 bits:
MOVL XAR2,#X ; XAR2 = pointer to X
MOVL XAR7,#C ; XAR7 = pointer to C
SPM −5 ; Set product shift to ”>> 5”
ZAPA ; Zero ACC, P, OVCU
RPT #(N−1) ; Repeat next instruction N times
||IMACL P,*XAR2++,*XAR7++ ; OVCU:ACC = OVCU:ACC + P,
; P = (X[i] * C[i]) << 5,
; i++
ADDUL ACC,@P ; OVCU:ACC = OVCU:ACC + P
MOVL @sum+0,ACC ; Store low 32 bits result into sum
; Calculate high 32 bits:
MOVU @AL,OVC ; ACC = OVCU (carry count)
MOVB AH,#0
MPYB P,T,#0 ; P = 0
MOVL XAR2,#X ; XAR2 = pointer to X
MOVL XAR7,#C ; XAR7 = pointer to C
RPT #(N−1) ; Repeat next instruction N times
||QMACL P,*XAR2++,*XAR7++ ; ACC = ACC + P >> 5,
; P = (X[i] * C[i]) >> 32,
; i++
ADDL ACC,P << PM ; ACC = ACC + P >> 5
MOVL @sum+2,ACC ; Store high 32 bits result into sum

IMPYAL P,XT,loc32 :
مقدار قبلی رجیستر P به ACC اضافه می شود.سپس محتوای XT در محتوای ادرس اشاره شده ضرب می شود.مد شیفت ضرب PM تعیین می کند کدام قسمت از 38 بیت پایین نتیجه 64 بیتی در رجیستر P قرار بگیرد.

ACC = ACC + unsigned P;
temp(37:0) = lower_38 bits(signed XT * signed [loc32]);
if( PM = +4 shift )
P(31:4) = temp(27:0), P(3:0) = 0;
if( PM = +1 shift )
P(31:1) = temp(30:0), P(0) = 0;
if( PM = 0 shift )
P(31:0) = temp(31:0);
if( PM = −1 shift )
P(31:0) = temp(32:1);
if( PM = −2 shift )
P(31:0) = temp(33:2);
if( PM = −3 shift )
P(31:0) = temp(34:3);
if( PM = −4 shift )
P(31:0) = temp(35:4);
if( PM = −5 shift )
P(31:0) = temp(36:5);
if( PM = −6 shift )
P(31:0) = temp(37:6);

; Calculate signed result:
; Y64 = (X0*C0 + X1*C1 + X2*C2) >> 2
SPM −2 ; Set product shift mode to “>> 2”
ZAPA ; Zero ACC, P, OVCU
MOVL XT,@X0 ; XT = X0
IMPYL P,XT,@C0 ; P = low 32 bits of (X0*C0 << 2)
MOVL XT,@X1 ; XT = X1
IMPYAL P,XT,@C1 ; OVCU:ACC = OVCU:ACC + P,
; P = low 32 bits of (X1*C1 << 2)
MOVL XT,@X2 ; XT = X2
IMPYAL P,XT,@C2 ; OVCU:ACC = OVCU:ACC + P,
; P = low 32 bits of (X2*C2 << 2)
ADDUL ACC,@P ; OVCU:ACC = OVCU:ACC + P
MOVL @Y64+0,ACC ; Store low 32-bit result into Y64
MOVU @AL,OVC ; ACC = OVCU (carry count)
MOVB AH,#0
QMPYL P,XT,@C2 ; P = high 32 bits of (X2*C2)
MOVL XT,@X1 ; XT = X1
QMPYAL P,XT,@C1 ; ACC = ACC + P >> 2,
; P = high 32 bits of (X1*C1)
MOVL XT,@X0 ; XT = X0
QMPYAL P,XT,@C0 ; ACC = ACC + P >> 2,
; P = high 32 bits of (X0*C0)
ADDL ACC,P << PM ; ACC = ACC + P >> 2
MOVL @Y64+2,ACC ; Store high 32-bit result into Y64

IMPYL ACC,XT,loc32 :
این دستور محتوای 32 بیتی علامت دار رجیستر XT را در محتوای ادرس اشاره شده ضرب می کند و 32بیت پایین نتیجه را در رجیستر ACC می ریزد.

ACC = signed XT * signed [loc32];

; Calculate result: Y32 = M32*X32 + B32
MOVL XT,@M32 ; XT = M32
IMPYL ACC,XT,@X32 ; ACC = low 32 bits of (M32*X32)
ADDL ACC,@B32 ; ACC = ACC + B32
MOVL @Y32,ACC ; Store result into Y32

IMPYL P,XT,loc32 :
این دستور محتوای رجیستر XT و ادرس اشاره شده را درهم ضرب می کند و مقدار PM تعیین می کند که کدام قسمت از 38 بیت پایین نتیجه 64 بیتی در داخل رجیستر P قرار بگیرد.

temp(37:0) = lower_38 bits(signed XT * signed [loc32]);
if( PM = +4 shift )
P(31:4) = temp(27:0), P(3:0) = 0;
if( PM = +1 shift )
P(31:1) = temp(30:0), P(0) = 0;
if( PM = 0 shift )
P(31:0) = temp(31:0);
if( PM = −1 shift )
P(31:0) = temp(32:1);
if( PM = −2 shift )
P(31:0) = temp(33:2);
if( PM = −3 shift )
P(31:0) = temp(34:3);
if( PM = −4 shift )
P(31:0) = temp(35:4);
if( PM = −5 shift )
P(31:0) = temp(36:5);
if( PM = −6 shift )
P(31:0) = temp(37:6);

; Calculate signed result: Y64 = M32*X32
MOVL XT,@M32 ; XT = M32
IMPYL P,XT,@X32 ; P = low 32 bits of (M32*X32)
QMPYL ACC,XT,@X32 ; ACC = high 32 bits of (M32*X32)
MOVL @Y64+0,P ; Store result into Y64
MOVL @Y64+2,ACC

IMPYSL P,XT,loc32 :
این دستور محتوای رجیستر P را از ACC کم می کند.سپس محتوای XT را در محتوای ادرس اشاره شده ضرب می کند و PM تعیین می کند که کدام قسمت از 38 بیت پایین نتیجه 64 بیتی در رجیستر P قرار بگیرد.

ACC = ACC - unsigned P;
temp(37:0) = lower_38 bits(signed XT * signed [loc32]);
if( PM = +4 shift )
P(31:4) = temp(27:0), P(3:0) = 0;
if( PM = +1 shift )
P(31:1) = temp(30:0), P(0) = 0;
if( PM = 0 shift )
P(31:0) = temp(31:0);
if( PM = −1 shift )
P(31:0) = temp(32:1);
if( PM = −2 shift )
P(31:0) = temp(33:2);
if( PM = −3 shift )
P(31:0) = temp(34:3);
if( PM = −4 shift )
P(31:0) = temp(35:4);
if( PM = −5 shift )
P(31:0) = temp(36:5);
if( PM = −6 shift )
P(31:0) = temp(37:6);

; Calculate signed result:
; Y64 = (−X0*C0 − X1*C1 − X2*C2) >> 2
SPM −2 ; Set product shift mode to “>> 2”
ZAPA ; Zero ACC, P, OVCU
MOVL XT,@X0 ; XT = X0
IMPYL P,XT,@C0 ; P = low 32 bits of (X0*C0 << 2)
MOVL XT,@X1 ; XT = X1
IMPYSL P,XT,@C1 ; OVCU:ACC = OVCU:ACC − P,
; P = low 32 bits of (X1*C1 << 2)
MOVL XT,@X2 ; XT = X2
IMPYSL P,XT,@C2 ; OVCU:ACC = OVCU:ACC − P,
; P = low 32 bits of (X2*C2 << 2)
SUBUL ACC,@P ; OVCU:ACC = OVCU:ACC − P
MOVL @Y64+0,ACC ; Store low 32-bit result into Y64
MOVU @AL,OVC ; ACC = OVCU (borrow count)
MOVB AH,#0
NEG ACC ; Negate borrow
QMPYL P,XT,@C2 ; P = high 32 bits of (X2*C2)
MOVL XT,@X1 ; XT = X1
QMPYSL P,XT,@C1 ; ACC = ACC − P >> 2,|
; P = high 32 bits of (X1*C1)
MOVL XT,@X0 ; XT = X0
QMPYSL P,XT,@C0 ; ACC = ACC − P >> 2,
; P = high 32 bits of (X0*C0)
SUBL ACC,P << PM ; ACC = ACC − P >> 2
MOVL @Y64+2,ACC ; Store high 32-bit result into Y64

IMPYXUL P,XT,loc32 :

این دستور محتوای علامت دار XT را در محتوای 32بیتی بدون علامت ادرس اشاره شده ضرب می کند .PM تعیین می کند که کدام قسمت از 38 بیت پایین نتیجه 64 بیتی در رجیستر P قرار بگیرد.

temp(37:0) = lower_38 bits(signed XT * unsigned [loc32]);
if( PM = +4 shift )
P(31:4) = temp(27:0), P(3:0) = 0;
if( PM = +1 shift )
P(31:1) = temp(30:0), P(0) = 0;
if( PM = 0 shift )
P(31:0) = temp(31:0);
if( PM = −1 shift )
P(31:0) = temp(32:1);
if( PM = −2 shift )
P(31:0) = temp(33:2);
if( PM = −3 shift )
P(31:0) = temp(34:3);
if( PM = −4 shift )
P(31:0) = temp(35:4);
if( PM = −5 shift )
P(31:0) = temp(36:5);
if( PM = −6 shift )
P(31:0) = temp(37:6);

; Calculate result: Y64 = M64*X64 + B64
; Y64 = Y1:Y0, M64 = M1:M0, X64 = X1:X0, B64 = B1:B0
MOVL XT,@X0 ; XT = X0
IMPYL P,XT,@M0 ; P = low 32 bits of (uns M0 * uns X0)
MOVL ACC,@B0 ; ACC = B0
ADDUL ACC,@P ; ACC = ACC + P
MOVL @Y0,ACC ; Store result into Y0
QMPYUL P,XT,@M0 ; P = high 32 bits of (uns M0 * uns X0)
MOVL XT,@X1 ; XT = X1
MOVL ACC,@P ; ACC = P
IMPYXUL P,XT,@M0 ; P = low 32 bits of (uns M0 * sign X1)
MOVL XT,@M1 ; XT = M1
ADDCL ACC,@P ; ACC = ACC + P + carry
IMPYXUL P,XT,@X0 ; P = low 32 bits of (sign M1 * uns X0)
ADDUL ACC,@P ; ACC = ACC + P
ADDUL ACC,@B1 ; ACC = ACC + B1
MOVL @Y1,P ; Store result into Y1

[ali833]

پاسخ : اموزش DSP

با سلام...

QMACL P,loc32,*XAR7 :
OMACL P,loc32,*XAR7++ :

این دستور مقدار قبلی رجیستر P را بعد از شیفت به رجیستر ACC اضافه می کند.سپس محتوای 32 بیتی علامت دار ادرس اشاره شده به وسیله "loc32" را در محتوای ادرس اشاره شده به وسیله XAR7 ضرب می کند و 32بیت بالای نتیجه 64 بیتی را در رجیستر P ذخیره می کند.

ACC = ACC + P << PM;
P = (signed T * signed Prog[*XAR7 or *XAR7++]) >> 32;

; Calculate sum of product using 32-bit multiply and retain
; high result:
; int32 X[N]; // Data information
; int32 C[N]; // Coefficient information (located in low 4M)
; int32 sum = 0;
; for(i=0; i < N; i++)
; sum = sum + ((X[i] * C[i]) >> 32) >> 5;
MOVL XAR2,#X ; XAR2 = pointer to X
MOVL XAR7,#C ; XAR7 = pointer to C
SPM −5 ; Set product shift to ”>> 5”
ZAPA ; Zero ACC, P, OVC
RPT #(N−1) ; Repeat next instruction N times
||QMACL P,*XAR2++,*XAR7++ ; ACC = ACC + P >> 5,
; P = (X[i] * C[i]) >> 32
; i++
ADDL ACC,P << PM ; Perform final accumulate
MOVL @sum,ACC ; Store final result into sum

QMPYAL P,XT,loc32 :
این دستور نیز محتوای P را بعد از شیفت به ACC اضافه می کند .سپس محتوای 32 بیتی علامت دار رجیستر XT را در محتوای ادرس اشاره شده ضرب و 32 بیت بالای نتیجه را در رجیستر P قرار می دهد.

ACC = ACC + P << PM;
P = (signed T * signed [loc32]) >> 32;

; Calculate signed result:
; Y32 = (X0*C0 + X1*C1 + X2*C2) >> (32 + 2)
SPM −2 ; Set product shift mode to “>> 2”
ZAPA ; Zero ACC, P, OVC
MOVL XT,@X0 ; XT = X0
QMPYL P,XT,@C0 ; P = high 32−bits of (X0*C0)
MOVL XT,@X1 ; XT = X0
QMPYAL P,XT,@C1 ; ACC = ACC + P >> 2,
; P = high 32−bits of (X1*C1)
MOVL XT,@X2 ; XT = X0
QMPYAL P,XT,@C2 ; ACC = ACC + P >> 2,
; P = high 32−bits of (X2*C2)
ADDL ACC,P << PM ; ACC = ACC + P >> 2
MOVL @Y32,ACC ; Store result into Y32

QMPYL P,XT,loc32 :
این دستور محتوای رجیستر XT را در ادرس اشاره شده ضرب می کند و 32 بیت بالای نتیجه را در رجیستر P قرار می دهد.

P = (signed XT * signed [loc32]) >> 32;

; Calculate signed result: Y64 = M32*X32 + B64
MOVL XT,@M32 ; XT = M32
IMPYL P,XT,@X32 ; P = low 32−bits of (M32*X32)
MOVL ACC,@B64+2 ; ACC = high 32−bits of B64
ADDUL P,@B64+0 ; P = P + low 32−bits of B64
MOVL @Y64+0,P ; Store low 32-bit result into Y64
QMPYL P,XT,@X32 ; P = high 32−bits of (M32*X32)
ADDCL ACC,@P ; ACC = ACC + P + carry
MOVL @Y64+2,ACC ; Store high 32-bit result into Y64

QMPYL ACC,XT,loc32 :

این دستور نیز مانند دستور قبلی می باشد با این تفاوت که نتیجه در درون رجیستر ACC قرار می گیرد.

ACC = (signed XT * signed [loc32]) >> 32;

; Calculate signed result: Y64 = M32*X32
MOVL XT,@M32 ; XT = M32
IMPYL P,XT,@X32 ; P = low 32−bits of (M32*X32)
QMPYL ACC,XT,@X32 ; ACC = high 32−bits of (M32*X32)
MOVL @Y64+0,P ; Store result into Y64
MOVL @Y64+2,ACC

QPPYSL P,XT,loc32 :
این دستور مقدار قبلی موجود در رجیستر P را بعد از شیفت از رجیستر ACC کم می کند .سپس محتوای 32 بیتی علامت دار رجیستر XT را در محتوای ادر اشاره شده ضرب می کند و 32 بیت بالای نتیجه را در رجیستر P ذخیره می کند.

ACC = ACC − P << PM;
P = (signed T * signed [loc32]) >> 32;

; Calculate signed result:
; Y32 = −(X0*C0 + X1*C1 + X2*C2) >> (32 + 2)
SPM −2 ; Set product shift mode to “>> 2”
ZAPA ; Zero ACC, P, OVC
MOVL XT,@X0 ; XT = X0
QMPYL P,XT,@C0 ; P = high 32−bits of (X0*C0)
MOVL XT,@X1 ; XT = X0
QMPYSL P,XT,@C1 ; ACC = ACC − P >> 2,
; P = high 32−bits of (X1*C1)
MOVL XT,@X2 ; XT = X0
QMPYSL P,XT,@C2 ; ACC = ACC − P >> 2,
; P = high 32−bits of (X2*C2)
SUBL ACC,P << PM ; ACC = ACC − P >> 2
MOVL @Y32,ACC ; Store result into Y32

QMPYUL P,XT,loc32 :
این دستور محتوای بدون علامت رجیستر XT را در محتوای بدون علامت ادرس اشاره شده ضرب می کند و 32 بیت بالای نتیجه را در رجیستر P قرار می دهد.

P = (unsigned XT * unsigned [loc32]) >> 32;

; Calculate unsigned result: Y64 = M32*X32 + B64
MOVL XT,@M32 ; XT = M32
IMPYL P,XT,@X32 ; P = low 32−bits of (M32*X32)
MOVL ACC,@B64+2 ; ACC = high 32−bits of B64
ADDUL P,@B64+0 ; P = P + low 32−bits of B64
MOVL @Y64+0,P ; Store low 32-bit result into Y64
QMPYUL P,XT,@X32 ; P = high 32−bits of (M32*X32)
ADDCL ACC,@P ; ACC = ACC + P + carry
MOVL @Y64+2,ACC ; Store high 32-bit result into Y64

QMPYXUL P,XT,loc32 :

این دستور محتوای 32 بیتی علامت دار رجیستر XT را در محتوای بدون علامت ادرس اشاره شده ضرب می کند و 32 بیت بالای نتیجه را در رجیستر P می ریزد.

P = (signed XT * unsigned [loc32]) >> 32;

; Calculate signed result: Y64 = (M64*X64) >> 64 + B64
; Y64 = Y1:Y0, M64 = M1:M0, X64 = X1:X0, B64 = B1:B0
MOVL XT,@X1 ; XT = X1
QMPYXUL P,XT,@M0 ; P = high 32−bits of (uns M0 * sign X1)
MOV @T,#32 ; T = 32
LSL64 ACC:P,T ; ACC:P = ACC:P << T
ASR64 ACC:P,T ; ACC:P = ACC:P >> T
MOVL @XAR4,P ; XAR5:XAR4 = ACC:P
MOVL @XAR5,ACC
MOVL XT,@M1 ; XT = M1
QMPYXUL P,XT,@X0 ; P = high 32−bits of (sign M1 * uns X0)
MOV @T,#32 ; T = 32
LSL64 ACC:P,T ; ACC:P = ACC:P << T
ASR64 ACC:P,T ; ACC:P = ACC:P >> T
MOVL @XAR6,P ; XAR7:XAR6 = ACC:P
MOVL @XAR7,ACC
IMPYL P,XT,@X1 ; P = low 32−bits of (sign M1 * sign X1)
QMPYL ACC,XT,@X1 ; ACC = high 32−bits of (sign M1 * sign X1)
ADDUL P,@XAR4 ; ACC:P = ACC:P + XAR5:XAR4
ADDCL ACC,@XAR5
ADDUL P,@XAR6 ; ACC:P = ACC:P + XAR7:XAR6
ADDCL ACC,@XAR7
ADDUL P,@B0 ; ACC:P = ACC:P + B64
ADDCL ACC,@B1
MOVL @Y0,P ; Store result into Y64
MOVL @Y1,ACC

خوب دستورات ضرب هم تمام شد در ادامه می خوام چندتا دستور تفریق رو توضیح بدم و بعدش هم چندتا تک دستور که جامونده مثل ROL یا CPM و... در ضمن دارم رو اموزش CCS V3.3 هم فکر می کنم نمی دونم از کجاش شروع کنم به اموزش از ب بسم الله یا فرض براین بزارم که چیزای اولیه رو می دونید.اگه نظرتون بگید ممنون می شم.

[ali833]

پاسخ : اموزش DSP

سلام دیگه کم کم دارم میرسم به اخر اموزش دستورات اسمبلی دوستان خبری ازشون نیست مثل اینکه زیاد علاقه ای به همکاری ندارند به هر حال ما که به کارمون ادامه می دیم ولی در اینده توقعی از ما نداشته باشند.

[ali833]

پاسخ : اموزش DSP

SBRK ,#8bit :
این دستور مقدار ثابت 8 بیتی را از رجیستر XARn که به وسیله ARP به ان اشاره می شود کم می کند.

XAR(ARP) = XAR(ARP) − 0:8bit;

Example .word 0xEEEE
.word 0x0000
TableA: .word 0x1111
.word 0x2222
.word 0x3333
.word 0x4444
FuncA:
MOVL XAR1,#TableA
MOVZ AR2,*XAR1
SBRK #2
MOVZ AR3,*XAR1
; Initialize XAR1 pointer
; Load AR2 with the 16−bit value
; pointed to by XAR1 (0x1111)
; Set ARP = 1
; Decrement XAR1 by 2
; Load AR3 with the 16−bit value
; pointed to by XAR1 (0xEEEE)

SUBB XARn,#7bit :
این دستور مقدار ثابت 7بیتی را از XARn کم می کند.

XARn = XARn − 0:7bit;

MOVL XAR1,#VarA
MOVL XAR2,*XAR1
SUBB XAR2,#10h‘
; Initialize XAR1 pointer with address
; of VarA
; Load XAR2 with contents of VarA
; XAR2 = VarA − 0x10

SUBB SP,#7bit :
این دستور نیز مقدار ثابت 7 بیتی بدون علامت را از رجیستر SP کم میکند.

SP = SP − 0:7bit;

FuncA: ; Function with local variables on
; stack.
ADDB SP,#N ; Reserve N 16−bit words of space for
; local variables on stack:
.
.
.
SUBB SP,#N ; Deallocate reserved stack space.
LRETR ; Return from function.

SUB AX,loc16 :
این دستور محتوای ادرس اشاره شده را از رجیستر AX کم می کند و نتیجه را در AX قرار می دهد.

AX = AX − [loc16];

; Subtract the contents of VarA with VarB and store in VarC
MOV AL,@VarA ; Load AL with contents of VarA
SUB AL,@VarB ; Subtract from AL contents of VarB
MOV @VarC,AL ; Store result in VarC

SUB loc16,AX :
این دستور محتوای رجیستر AX را از محتوای ادرس اشاره شده کم می کند و نتیجه را در همان ادرس اشاره شده قرار می دهد.

[loc16] = [loc16] − AX;

; Subtract the contents of VarA from index register AR0:
MOV AL,@VarA ; Load AL with contents of VarA
SUB @AR0,AL ; AR0 = AR0 − AL
; Subtract the contents of VarB from VarC:
MOV AH,@VarB ; Load AH with contents of VarB
SUB @VarC,AH ; VarC = VarC − AH

SUBR loc16,AX :
این دستور محتوای ادرس اشاره شده را از محتوای رجیستر AX کم می کند ونتیجه را در همان ادرس اشاره شده قرار می دهد.

[loc16] = AX − [loc16]

; Subtract index register AR0 from VarA and store in AR0:
MOV AL,@VarA ; Enable
sign extensio ;
with a left shift of 3
; Load AL with contents of VarA
SUBR @AR0,AL ; AR0 = AL − AR0
; Subtract the contents of VarC from VarB and store in VarC:
MOV AH,@VarB ; Load AH with contents of VarB
SUBR @VarC,AH ; VarC = AH − VarC

SUB ACC,loc16<<T :

این دستور محتوای شیفت داده شده ادرس اشاره شده را از رجیستر ACC کم می کند .مقدار شیفت به وسیله 4 بیت کم ارزشتر رجیستر T تعیین می شود.

if(SXM = 1) // sign extension mode enabled
ACC = ACC − S:[loc16] << T(3:0);
else // sign extension mode disabled
ACC = ACC − 0:[loc16] << T(3:0);

; Calculate signed value: ACC = (VarA << SB) − (VarB << SB)
SETC SXM ; Turn sign extension mode on
MOV T,@SA ; Load T with shift value in SA
MOV ACC,@VarA << T ; Load in ACC shifted contents of VarA
MOV T,@SB ; Load T with shift value in SB
SUB ACC,@VarB << T ; Subtract from ACC shifted contents
; of VarB

SUB ACC,loc16<<#0..16 :

این دستور مانند دستور قبلی می باشد با این تفاوت که مقدار شیفت به صورت مستقیم تعیین می شود.

if(SXM = 1) // sign extension mode enabled
ACC = ACC − S:[loc16] << shift value;
else // sign extension mode disabled
ACC = ACC − 0:[loc16] << shift value;

; Calculate signed value: ACC = (VarA << 10) − (VarB << 6);
SETC SXM ; Turn sign extension mode on
MOV ACC,@VarA << #10 ; Load ACC with VarA left shifted by 10
SUB ACC,@VarB << #6 ; Subtract VarB left shifted by 6 to ACC0

SUB ACC,#16bit<<#0..15 :
این دستور یک مقدار ثابت را بعد از شیفت از رجیستر ACC کم می کند.

if(SXM = 1) // sign extension mode enabled
ACC = ACC − S:16bit << shift value;
else // sign extension mode disabled
ACC = ACC − 0:16bit << shift value;

; Calculate signed value: ACC = (VarB << 10) − (23 << 6);
SETC SXM ; Turn sign extension mode on
MOV ACC,@VarB << #10 ; Load ACC with VarB left shifted by 10
SUB ACC,#23 << #6 ; Subtract from ACC 23 left shifted by 6

SBBU ACC,loc16 :
این دستور محتوای ادرس اشاره شده به همراه مکمل یک بیت کری را از رجیستر ACC کم می کند.

ACC = ACC − 0:[loc16] − ~C;

; Subtract three 32-bit unsigned variables by 16-bit parts:
MOVU ACC,@VarAlow ; AH = 0, AL = VarAlow
ADD ACC,@VarAhigh << 16 ; AH = VarAhigh, AL = VarAlow
SUBU ACC,@VarBlow ; ACC = ACC − 0:VarBlow
SUB ACC,@VarBhigh << 16 ; ACC = ACC − VarBhigh << 16
SBBU ACC,@VarClow ; ACC = ACC − VarClow − ~Carry
SUB ACC,@VarChigh << 16 ; ACC = ACC − VarChigh << 16

[hess]

پاسخ : اموزش DSP

سلام دیگه کم کم دارم میرسم به اخر اموزش دستورات اسمبلی دوستان خبری ازشون نیست مثل اینکه زیاد علاقه ای به همکاری ندارند به هر حال ما که به کارمون ادامه می دیم ولی در اینده توقعی از ما نداشته باشند.

سلام ...................

راستش این تاپیک یه اتفاقه خیلی خوب و البته کم نظیر توی سایته .. همیشه هم کارای تازه؛ تا جا بیوفتن یه مقدار زمان میبره .. این تاپیک دو تا بازدید کننده ی ثابت داره .. یک آقای حسنی و دیگری هم من .. مطمئن باشید شاید (به احتمال یک درصد) الان این تاپیک کم بازدید کننده باشه امــآ فیدبکی که در آینده داره (چه از نظر محتوی و چه از نظر نفس عمل) ارزش این تاپیک رو بیش از پیش افزایش میده .. شما با قدرت به کارتون ادامه بدید .. مطمئن باشید نتیجه ی خیلی خوبی داره کما اینکه تا الان هم داشته .. مرســـی از زحمتی که میکشید .. موفق باشید ..

[abdolla888]

پاسخ : اموزش DSP

سلام دیگه کم کم دارم میرسم به اخر اموزش دستورات اسمبلی دوستان خبری ازشون نیست مثل اینکه زیاد علاقه ای به همکاری ندارند به هر حال ما که به کارمون ادامه می دیم ولی در اینده توقعی از ما نداشته باشند.

سلام

علی جان بابت مباحث آموزشی خوبی که مطرح می فرمایید ممنون
یه جورایی پست من و حسام الدین عزیز همزمان شد.ضمن تایید فرمایشات ایشون،
لطفا ادامه بدید.شاید این قسمت آموزش(دستورات اسمبلی) به دلیل اینکه کلا اسمبلی خیلی طرفدار نداره، یه مقدار کمتر بهش توجه می شه.به جاهای خوبش(CCS و Starter kit و...) که برسه قطعا مباحث جالب تری مطرح خواهد شد.
من به شخصه یه مقدار این مدت درگیر سمینارم هستم ولی هر کجا که احساس کنم سوادم قد میده در خدمت دوستان خواهم بود. :smile:
با اشتیاق فراوان منتظر ادامه ی مباحث آموزشی هستیم :agree:

[ali833]

پاسخ : اموزش DSP

سلام اقای حسنی و حسام الدین عزیز...
امیدوارم اینطور که می فرمایید باشه بهر حال من کارم رو ادامه می دم هدف اول من این بوده که کار با DSP خودم یاد بگیرم و هرچی یاد گرفتم این جا قرار بدم تا هر کی دوست داشت استفاده کنه.دستورات اسمبلی هم کم کم داره تموم میشه منم دارم از روی tutorial نرم افزار کم کم جلو میرم و مطلب که برای خودم جا افتاد تو یک تاپیک جداگانه مطرح می کنم.

[ali833]

پاسخ : اموزش DSP

ادامه دستورات تفریق...........

SUBU ACC,loc16 :

محتوای ادرس اشاره شده از رجیستر ACC کم می شود.

ACC = ACC − 0:[loc16];

; Subtract three 32-bit unsigned variables by 16-bit parts:
MOVU ACC,@VarAlow ; AH = 0, AL = VarAlow
ADD ACC,@VarAhigh << 16 ; AH = VarAhigh, AL = VarAlow
SUBU ACC,@VarBlow ; ACC = ACC − 0:VarBlow
SUB ACC,@VarBhigh << 16 ; ACC = ACC − VarBhigh << 16
SBBU ACC,@VarClow ; ACC = ACC − VarClow − ~Carry
SUB ACC,@VarChigh << 16 ; ACC = ACC − VarChigh << 16

SUBBL ACC,loc32 :

این دستور محتوای 32 بیتی ادرس اشاره شده را به همراه وارون منطقی مقدار مو جود در بیت پرچم کری را از رجیستر ACC کم می کند.

ACC = ACC − [loc32] − ~C;

; Subtract two 64-bit values (VarA and VarB) and store result
; in VarC:
MOVL ACC,@VarA+0 ; Load ACC with contents of the low
; 32-bits of VarA
SUBUL ACC,@VarB+0 ; Subtract from ACC the contents of
; the low 32-bits of VarB
MOVL @VarC+0,ACC ; Store low 32-bit result into VarC
MOVL ACC,@VarA+2 ; Load ACC with contents of the high
; 32-bits of VarA

SUBBL ACC,@VarB+2 ; Subtract from ACC the contents of
; the high 32-bits of VarB with borrow
MOVL @VarC+2,ACC ; Store high 32-bit result into VarC

SUBCU ACC,loc16 :

این دستور یک تفریق 16 بیتی شرطی انجام می دهد که می تواند برای تقسیم بدون علامت استفاده شود.

temp(32:0) = ACC << 1 − [loc16] << 16
if( temp(32:0) >= 0 )
ACC = temp(31:0) + 1
else
ACC = ACC << 1

برای اانجام این عمل تقسیم رجیستر AH صفر می شود و رجیستر AL با صورت کسر پر می شود پیش از عمل تفریق.مقدار اشاره شده به وسیله ادرس شامل مقدار مخرج کسر می باشد.بعد از اینکه دستور تفریق 16 بار اجرا شد رجیستر AH شامل باقیمانده و رجیستر AL شامل خارج قسمت خواهد بود. برای انجام عمل تقسیم علامت دار صورت و مخرج هر دو باید بدون علامت شوند و خارج قسمت باید منفی شود اگر مقادیر صورت و مخرج هم علامت نباشند.

Example 1 ; Calculate unsigned: Quot16 = Num16Den16, Rem16 = Num16%Den16
MOVU ACC,@Num16 ; AL = Num16, AH = 0
RPT #15 ; Repeat operation 16 times
||SUBCU ACC,@Den16 ; Conditional subtract with Den16
MOV @Rem16,AH ; Store remainder in Rem16
MOV @Quot16,AL ; Store quotient in Quot16

; Calculate signed: Quot16 = Num16Den16, Rem16 = Num16%Den16
CLRC TC ; Clear TC flag, used as sign flag
MOV ACC,@Den16 << 16 ; AH = Den16, AL = 0
ABSTC ACC ; Take abs value, TC = sign ^ TC
MOV T,@AH ; Temp save Den16 in T register
MOV ACC,@Num16 << 16 ; AH = Num16, AL = 0
ABSTC ACC ; Take abs value, TC = sign ^ TC
MOVU ACC,@AH ; AH = 0, AL = Num16
RPT #15 ; Repeat operation 16 times
||SUBCU ACC,@T ; Conditional subtract with Den16
MOV @Rem16,AH ; Store remainder in Rem16
MOV ACC,@AL << 16 ; AH = Quot16, AL = 0
NEGTC ACC ; Negate if TC = 1
MOV @Quot16,AH ; Store quotient in Quot16

Example 3 ; Calculate unsigned: Quot32 = Num32/Den16, Rem16 = Num32%Den16
MOVU ACC,@Num32+1 ; AH = 0, AL = high 16-bits of Num32
RPT #15 ; Repeat operation 16 times
||SUBCU ACC,@Den16 ; Conditional subtract with Den16
MOV @Quot32+1,AL ; Store high 16-bit in Quot32
MOV AL,@Num32+0 ; AL = low 16-bits of Num32
RPT #15 ; Repeat operation 16 times
||SUBCU ACC,@Den16 ; Conditional subtract with Den16
MOV @Rem16,AH ; Store remainder in Rem16
MOV @Quot32+0,AL ; Store low 16-bit in Quot32

Example 4 ; Calculate signed: Quot32 = Num32/Den16, Rem16 = Num32%Den16
CLRC TC ; Clear TC flag, used as sign flag
MOV ACC,@Den16 << 16 ; AH = Den16, AL = 0
ABSTC ACC ; Take abs value, TC = sign ^ TC
MOV T,@AH ; Temp save Den16 in T register
MOVL ACC,@Num32 ; ACC = Num32
ABSTC ACC ; Take abs value, TC = sign ^ TC
MOV P,@ACC ; P = Num32
MOVU ACC,@PH ; AH = 0, AL = high 16-bits of Num32
RPT #15 ; Repeat operation 16 times
||SUBCU ACC,@T ; Conditional subtract with Den16
MOV @Quot32+1,AL ; Store high 16-bit in Quot32
MOV AL,@PL ; AL = low 16-bits of Num32
RPT #15 ; Repeat operation 16 times
||SUBCU ACC,@T ; Conditional subtract with Den16
MOV @Rem16,AH ; Store remainder in Rem16
MOV ACC,@AL << 16 ; AH = low 16-bits of Quot32, AL = 0
NEGTC ACC ; Negate if TC = 1
MOV @Quot32+0,AH ; Store low 16-bit in Quot32

[ali833]

پاسخ : اموزش DSP

SUBCUL ACC,loc32 :

این دستور یک عمل تفریق 32 بیتی شرطی را انجام می دهد که از ان می توان برای انجام عمل تقسیم بدون علامت استفاده کرد.

temp(32:0) = ACC << 1 + P(31) − [loc32];
if( temp(32:0) >= 0 )
ACC = temp(31:0);
P = (P << 1) + 1;
else
ACC:P = ACC:P << 1;

برای انجام عمل تقسیم 32 بیتی رجیستر ACC با صفر پر می شود و رجیستر P با مقدار صورت کسر قبل از اجرای دستور پر می شود.ادر اشاره شده به وسیله "loc32" شامل مقدار مخرج کسر می باشد. بعد از 32 بار اجرای دستور رجیستر ACC شامل باقیمانده و رجیستر P شامل خارج قسمت خواهد بود. مقادیر صورت و مخرج قبل از اجرای دستور باید به صورت بدون علامت درایند. خارج قسمت نهایی در صورت هم علامت نبودن صورت و مخرج باید منفی شود.

Example 1 ; Calculate unsigned: Quot32 = Num32/Den32, Rem32 = Num32%Den32
MOVB ACC,#0 ; Zero ACC
MOVL P,@Num32 ; Load P register with Num32
RPT #31 ; Repeat operation 32 times
||SUBCUL ACC,@Den32 ; Conditional subtract with Den32
MOVL @Rem32,ACC ; Store remainder in Rem32
MOVL @Quot32,P ; Store quotient in Quot32

Example 2 ; Calculate signed: Quot32 = Num32/Den32, Rem32 = Num32%Den32
CLRC TC ; Clear TC flag, used as sign flag
MOVL ACC,@Den32 ; Load ACC with contents of Den32
ABSTC ACC ; Take absolute value, TC = sign ^ TC
MOVL XT,@ACC ; Temp save denominator in XT register
MOVL ACC,@Num32 ; Load ACC register with Num32
ABSTC ACC ; Take abs value, TC = sign ^ TC
MOVL P,@ACC ; Load P register with numerator
MOVB ACC,#0 ; Zero ACC
RPT #31 ; Repeat operation 32 times
||SUBCUL ACC,@XT ; Conditional subtract with denominator
MOVL @Rem32,ACC ; Store remainder in Rem32
MOVL ACC,@P ; Load ACC with quotient
NEGTC ACC ; Negate ACC if TC=1 (negative result)
MOVL @Quot32,ACC ; Store quotient in Quot32

Example 3 ; Calculate unsigned: Quot64 = Num64Den32, Rem32 = Num64%Den32
MOVB ACC,#0 ; Zero ACC
MOVL P,@Num64+2 ; Load P with high 32-bits of Num64
RPT #31 ; Repeat operation 32 times
||SUBCUL ACC,@Den32 ; Conditional subtract with Den32
MOVL @Quot64+2,P ; Store high 32 bit quotient in Quot64
MOVL P,@Num64+0 ; Load P with low 32-bits of Num64
RPT #31 ; Repeat operation 32 times
||SUBCUL ACC,@Den32 ; Conditional subtract with Den32
MOVL @Rem32,ACC ; Store remainder in Rem32
MOVL @Quot64+0,P ; Store low 32 bit quotient in Quot64

Example 4 ; Calculate signed: Quot64 = Num364Den32, Rem32 = Num64%Den32
MOVL ACC,@Num64+2 ; Load ACC:P with 64-bit numerator
MOVL P,@Num64+0
TBIT @AH,#15 ; TC = sign of numerator
SBF $10,NTC ; Take absolute value of numerator
NEG64 ACC:P
$10:
MOVL @XAR3,P ; Temp save numerator low in XAR3
MOVL P,@ACC ; Load P register with numerator high
MOVL ACC,@Den32 ; Load ACC with contents of Den32
ABSTC ACC ; Take absolute value, TC = sign ^ TC
MOVL XT,@ACC ; Temp save denominator in XT register
MOVB ACC,#0 ; Zero ACC
RPT #31 ; Repeat operation 32 times
||SUBCUL ACC,@XT ; Conditional subtract with denominator
MOVL @XAR4,P ; Store high quotient in XAR4
MOVL P,@XAR3 ; Load P with low numerator
RPT #31 ; Repeat operation 32 times
||SUBCUL ACC,@XT ; Conditional subtract with denominator
MOVL @Rem32,ACC ; Store remainder in Rem32
MOVL ACC,@XAR4 ; Load ACC with high quotient from XAR4
SBF $20,NTC ; Take absolute value of quotient
NEG64 ACC:P
$20:
MOVL @Quot64+0,P ; Store low quotient into Quot64
MOVL @Quot64+2,ACC ; Store high quotient into Quot64

SUBL ACC,loc32 :
این دستور محتوای ادرس اشاره شده را از رجیستر ACC کم می کند.

ACC = ACC − [loc32];

; Calculate the 32-bit value: VarC = VarA−VarB
MOVL ACC,@VarA ; Load ACC with contents of VarA
SUBL ACC,@VarB ; Subtract from ACC the contents of VarB
MOVL @VarC,ACC ; Store result into VarC

SUBL ACC,P<<PM :

این دستور محتوای رجیستر P را بعد از شیفت از رجیستر ACC کم می کند.

ACC = ACC − P << PM;

; Calculate: Y = ((B << 11) − (M*X >> 4)) >> 10
; Y, M, X, B are Q15 values
SPM −4 ; Set product shift to >> 4
SETC SXM ; Enable sign extension mode
MOV T,@M ; T = M
MPY P,T,@X ; P = M * X
MOV ACC,@B << 11 ; ACC = S:B << 11

SUBL ACC,P << PM ; ACC = (S:B << 11) − (M*X >> 4)
MOVH @Y,ACC << 5 ; Store Q15 result into Y

SUBL loc32,ACC :

این دستور محتوای رجیستر ACC را از مکان اشاره شده به وسیله ادرس کم می کند.

[loc32] = [loc32] − ACC;

; Decrement the 32-bit value VarA:
MOVB ACC,#1 ; Load ACC with 0x00000001
SUBL @VarA,ACC ; VarA = VarA − ACC

SUBRL loc32,ACC :
این دستور محتوای مکان اشاره شده را از رجیستر ACC کم می کند و نتیجه را در همان مکان اشاره شده قرار می دهد.

[loc32] = ACC − [loc32];

; Calculate the 32-bit value: VarA = VarB − VarA
MOVL ACC,@VarB ; Load ACC with contents of VarB
SUBRL @VarA,ACC ; VarA = ACC − VarA

SUBUL ACC,loc32:

این دستور محتوای ادرس اشاره شده را از محتوای رجیستر ACC کم می کند. عمل تفریق همانند یک دستور SUBL بدون علامت رفتار می کند.

ACC = ACC − [loc32]; // unsigned subtraction

نکته:تفاوت بین عمل تفریق علامت دار با بدون علامت 32 بیتی در رفتار شمارنده سرریز می باشد(OVC) .برای یک SUBL علامت دار شمارنده OVC سرریز مثبت یا منفی را نشان می دهد اما یک دستور SUBL بدون علامت شمارنده OVC بدون علامت OVCU قرض گرفتن را نشان می دهد.

; Subtract two 64-bit values (VarA and VarB) and store result
; in VarC:
MOVL ACC,@VarA+0 ; Load ACC with contents of the low
; 32-bits of VarA
SUBUL ACC,@VarB+0 ; Subtract from ACC the contents of
; the low 32-bits of VarB
MOVL @VarC+0,ACC ; Store low 32-bit result into VarC
MOVL ACC,@VarA+2 ; Load ACC with contents of the high
; 32-bits of VarA
SUBBL ACC,@VarB+2 ; Subtract from ACC the contents of
; the high 32-bits of VarB with borrow
MOVL @VarC+2,ACC ; Store high 32-bit result into VarC

SUBUL P,loc32 :

این دستور نیز مانند دستور قبل می باشد فقط به جای رجیستر ACC از رجیستر P استفاده شده است.

P = P − [loc32]; // unsigned subtract

; Subtract 64-bit VarA − VarB and store result in VarC:
MOVL P,@VarA+0 ; Load P with low 32-bits of VarA
MOVL ACC,@VarA+2 ; Load ACC with high 32-bits of VarA
SUBUL P,@VarB+0 ; Sub from P unsigned low 32-bits of VarB
SUBBL ACC,@VarB+2 ; Sub from ACC with borrow high 32-bits of VarB
MOVL @VarC+0,P ; Store low 32-bit result into VarC
MOVL @VarC+2,ACC ; Store high 32-bit result into VarC

[ali833]

پاسخ : اموزش DSP

سلام .یک تعدادی دستورات منطقی با قیمونده که با اتمامشون می رم سراغ CCSV3.3 .انشالله.

OR AX,loc16 :

این دستور بین محتوای ادرس داده شده و رجیستر AX یک OR بیتی انجام می دهد. و نتیجه را در AX قرار می دهد.

AX = AX OR [loc16];

; OR the contents of VarA and VarB and store in VarC:
MOV AL,@VarA ; Load AL with contents of VarA
OR AL,@VarB ; OR AL with contents of VarB
MOV @VarC,AL ; Store result in VarC

OR loc16,AX :

این دستور نیز مانند دستور قبل می باشد با این تفاوت که نتیجه در ادرس مورد اشاره توسط loc16 قرار می گیرد.

[loc16] = [loc16] OR AX;

; OR the contents of VarA with VarB and store in VarB:
MOV AL,@VarA ; Load AL with contents of VarA
OR @VarB,AL ; VarB = VarB OR AL

ORB AX,#8bit :

این دستور بین رجیستر AX و مقدار ثابت 8 بیتی یک OR انجام می دهد.

AX = AX OR 0x00:8bit;

; Set bit 7 of VarA and store result in VarB:
MOV AL,@VarA ; Load AL with contents of VarA
ORB AL,#0x80 ; OR contents of AL with 0x0080
MOV @VarB,AL ; Store result in VarB

OR ACC,loc16 :
این دستور بین رجیستر ACC و ادرس اشاره شده عمل OR را انجام می دهد.

ACC = ACC OR 0:[loc16];

; Calculate the 32-bit value: VarA = VarA OR 0:VarB
MOVL ACC,@VarA ; Load ACC with contents of VarA
OR ACC,@VarB ; OR ACC with contents of 0:VarB
MOVL @VarA,ACC ; Store result in VarA

OR ACC,#16bit<<#0..15 :
OR ACC,#16bit<<#16 :
این دستور بین رجیستر ACC و مقدار ثابت شیفت داده شده یک OR بیتی انجام می دهد.

ACC = ACC OR (0:16bit << shift value);

; Calculate the 32-bit value: VarA = VarA OR 0x08000000
MOVL ACC,@VarA ; Load ACC with contents of VarA
OR ACC,#0x8000 << 12 ; OR ACC with 0x08000000
MOVL @VarA,ACC ; Store result in VarA

OR loc16,#16bit :
این دستور بین ادرس اشاره شده و مقدار ثابت 16 بیتی یک OR بیتی انجام می دهد.

[loc16] = [loc16] OR 16bit;

; Set Bits 4 and 7 of VarA:
; VarA = VarA OR #(1 << 4 | 1 << 7)
OR @VarA,#(1 << 4 | 1 << 7) ; Set bits 4 and 7 of VarA

[ali833]

پاسخ : اموزش DSP

مجموعه دستورات XOR .............

XOR AX,loc16 :
این دستور یک XOR بین رجیستر AX و محتوای ادرس اشاره شده انجام و نتیجه را در رجیستر AX قرار می دهد.

AX = AX XOR [loc16];

; XOR the contents of VarA and VarB and store in VarC:
MOV AL,@VarA ; Load AL with contents of VarA
XOR AL,@VarB ; XOR AL with contents of VarB
MOV @VarC,AL ; Store result in VarC

XOR loc16,AX :

این دستور نیز همانند دستور قبل می باشد با این تفاوت که نتیجه در ادرس اشاره شده به وسیله مد ادرس دهی "loc16" قرار می گیرد.

[loc16] = [loc16] XOR AX;

; XOR the contents of VarA with VarB and store in VarB:
MOV AL,@VarA ; Load AL with contents of VarA
XOR @VarB,AL ; VarB = VarB XOR AL

XOR loc16,#16bit :

این دستور بین محتوای ادرس اشاره شده و مقدار ثابت 16 بیتی یک XOR انجام و نتیجه را در ادرس اشاره شده قرار می دهد.

[loc16] = [loc16] XOR 16bit;

; Toggle Bits 2 and 14 of VarA:
; VarA = VarA XOR #(1 << 2 | 1 << 14)
XOR @VarA,#(1 << 2 | 1 << 14) ; Toggle bits 2 and 11 of VarA

XORB AX,#8bit :

این دستور بین رجیستر AX و مقدار ثابت 8بیتی یک XOR انجام و نتیجه را در رجیستر AX قرار می دهد.

AX = AX XOR 0x00:8bit;

; Toggle bit 7 of VarA and store result in VarB:
MOV AL,@VarA ; Load AL with contents of VarA
XORB AL,#0x80 ; XOR contents of AL with 0x0080
MOV @VarB,AL ; Store result in VarB

XOR ACC,loc16 :

این دستور بین رجیستر ACC و محتوای ادرس اشاره شده یک XORانجام و نتیجه در رجیستر ACC قرار می گیرد.

ACC = ACC XOR 0:[loc16];

; Calculate the 32-bit value: VarA = VarA XOR 0:VarB
MOVL ACC,@VarA ; Load ACC with contents of VarA
XOR ACC,@VarB ; XOR ACC with contents of 0:VarB
MOVL @VarA,ACC ; Store result in VarA

XOR ACC,#16bit<<#0..15 :
XOR ACC,#16bit<<#16 :

این دستور بین رجیستر ACC و مقدار ثابت شیفت داده شده یک XOR انجام و نتیجه را در ACC قرار می دهد.

ACC = ACC XOR (0:16bit << shift value);

; Calculate the 32-bit value: VarA = VarA XOR 0x08000000
MOVL ACC,@VarA ; Load ACC with contents of VarA
XOR ACC,#0x8000 << 12 ; XOR ACC with 0x08000000
MOVL @VarA,ACC ; Store result in VarA

مجموع دستورات مقایسه..........

CMPR 0
CMPR 1
CMPR 2
CMPR 3 :
این دستور محتوای رجیستر AR0 را بارجیستر های کمکی 16 بیتی اشاره شده به وسیله ARP مقایسه می کند.

CMPR 0: if(AR0 = AR[ARP]) TC = 1, else TC = 0
CMPR 1: if(AR0 > AR[ARP]) TC = 1, else TC = 0
CMPR 2: if(AR0 < AR[ARP]) TC = 1, else TC = 0
CMPR 3: if(AR0 != AR[ARP]) TC = 1, else TC = 0

TableA: .word 0x1111
.word 0x2222
FuncA:
MOVL XAR1,#VarA
MOVZ AR0,*XAR1++
MOVZ AR1,*XAR1
CMPR 0
B Equal,TC
CMPR 2
B Less,TC
.
.
; Initialize XAR1 Pointer
; Load AR0 with 0x1111, clear AR0H,
; ARP = 1
; Load AR1 with 0x2222, clear AR1H
; AR0 = AR1? No, clear TC
; Don’t branch
; AR1 > AR2? Yes, set TC
; Branch to “Less”

CMP AX,loc16 :

این دستور محتوای رجیستر AX را با محتوای 16 بیتی ادرس اشاره شده مقایسه می کند.نتیجه AX-[loc16] ارزیابی می شود و پرچمهای وضعیت,N,C,Z, با توجه به نتیجه عملیات تنظیم می شود.محتوای رجیستر AX و ادرس اشاره شده بدون تغییر می مانند.

Set Flags On (AX − [loc16]);

; Branch if VarA is higher then VarB:
MOV AL,@VarA ; Load AL with contents of VarA
CMPB AL,@VarB ; Set Flags On (AL − VarB)
SB Dest,HI ; Branch if VarA higher then VarB

CMP loc16,#16bitSigned :

این دستور محتوای ادرس اشاره شده را با مقدار ثابت 16 بیتی علامت دار مقایسه میکند و پرچمهای وضعیت متناسب با نتیجه تغییر می کنند.

Modify flags on ([loc16] − 16bitSigned);

اگر نتیجه عملیات منفی باشد N یک می شود.در غیر اینصورت پاک می شود.دستور CMP هنگامیکه علامت نتیجه را تعیین می کند دقت را نامحدود فرض می کند.به عنوان مثال تفریق 0x8000-0x0001 را در نظربگیرید.اگر نتیجه عملیات به 16 بیت محدود بود نتیجه یک سرریزبه عدد 0x7FFF را نتیجه می داد و پرچم N باید پاک شود.اما چون دستور CMP دقت را نامحدود فرض می کندوپرچم N را یک می کندبا توجه به اینکه 0x8000-0x0001 یک عدد منفی را نتیجه می دهد.

; Calculate:
; if( VarA > 20 )
; VarA = 0;
CMP @VarA,#20 ; Set flags on (VarA − 20)
MOVB @VarA,#0,GT ; Zero VarA if greater then

CMP64 ACC:P :

این دستور محتوای 64 بیتی این دو رجیستر را با صفر مقایسه می کند و پرچمهای مناسب را ست می کند.

if((V = 1) & (ACC(bit 31) = 1))
N = 0;
else
N = 1;
if((V = 1) & (ACC(bit 31) = 0))
N = 1;
else
N = 0;
if(ACC:P = 0x8000 0000 0000 0000)
Z = 1;
else
Z = 0;
V = 0;

این دستور باید به صورت زیر استفاده شود:

CMP64 ACC:P ; Clear V flag
perform 64-bit operation
CMP64 ACC:P ; Set Z,N flags, V=0
conditionally branch

; If 64-bit VarA > 64-bit VarB, branch:
CMP64 ACC:P ; Clear V flag
MOVL P,@VarA+0 ; Load P with low 32 bits of VarA
MOVL ACC,@VarA+2 ; Load ACC with high 32 bits of VarA
SUBUL P,@VarB+0 ; Sub from P unsigned low 32 bits of VarB
SUBBL ACC,@VarB+2 ; Sub from ACC with borrow high 32 bits of VarB
CMP64 ACC:P ; Set Z,N flags appropriately for ACC:P
SB Dest,GT ; branch if VarA > VarB

CMPB AX,#8bit :

این دستور محتوای رجیستر AX را با مقدار ثابت 8بیتی مقایسه و پرچمهای مناسب را ست می کند.

Set Flags On (AX − 0:8bit);

; Check if VarA is within range 0x80 <= VarA <= 0xF0:
MOV AL,@VarA ; Load AL with contents of VarA
CMPB AL,#0xF0 ; Set Flags On (AL − 0x00F0)
SB OutOfRange,GT ; Branch if VarA greater then 0x00FF
CMPB AL,#0x80 ; Set Flags On (AL − 0x0080)
SB OutOfRange,LT ; Branch if VarA less then 0x0080

CMPL ACC,loc32 :

این دستور محتوای رجیستر ACC و محتوای 32 بیتی ادرس اشاره شده را مقایسه می کند.

Modify flags on (ACC − [loc32]);

; Swap the contents of 32-bit VarA and VarB if VarB is higher:
MOVL ACC,@VarB ; ACC = VarB
MOVL P,@VarA ; P = VarA
CMPL ACC,@P ; Set flags on (VarB - VarA)
MOVL @VarA,ACC,HI ; VarA = ACC if higher
MOVL @P,ACC,HI ; P = ACC if higher
MOVL @VarA,P ; VarA = P

CMPL ACC,P<<PM :

این دستور محتوای رجیستر P را بعد از شیفت با محتوای رجیستر ACC مقایسه می کند.

Modify flags on (ACC − [P << PM]);

; Compare the following (VarA − VarB >> 4):
MOVL ACC,@VarA ; ACC = VarA
SPM −4 ; Set the product shift mode to ”>> 4”
MOVL P,@VarB ; P = VarB
CMPL ACC,P << PM ; Compare (VarA − VarB >> 4)

[ali833]

پاسخ : اموزش DSP

مجموعه دستورات MIN و MAX :

MAX AX,loc16 :

این دستور محتوای علامت دار رجیستر AX را با محتوای ادرس اشاره مقایسه می کند و رجیستر AX را با مقدار بزرگتر پر می کند.

if(AX < [loc16]), AX = [loc16];
if(AX >= [loc16]), AX = unchanged;

; Saturate VarA as follows:
; if(VarA > 2000) VarA = 2000;
; if(VarA < −2000) VarA = −2000;
MOV AL,@VarA ; Load AL with contents of VarA
MOV @AH,#2000 ; Load AH with the value 2000
MIN AL,@AH ; if(AL > AH) AL = AH
NEG AH ; AH = −2000
MAX AL,@AH ; if(AL < AH) AL = AH
MOV @VarA,AL ; Store result into VarA

MIN AX,loc16 :

این دستور محتوای علامت دار رجیستر AX را با محتوای ادرس اشاره شده مقایسه می کند و مقدار کوچکتر را در رجیستر AX می ریزد.

if(AX > [loc16]), AX = [loc16];
if(AX <= [loc16]), AX = unchanged;

; Saturate VarA as follows:
; if(VarA > 2000) VarA = 2000;
; if(VarA < −2000) VarA = −2000;
MOV AL,@VarA ; Load AL with contents of VarA
MOV @AH,#2000 ; Load AH with the value 2000
MIN AL,@AH ; if(AL > AH) AL = AH
NEG AH ; AH = −2000
MAX AL,@AH ; if(AL < AH) AL = AH
MOV @VarA,AL ; Store result into VarA

MAXL ACC,loc32 :

این دستور محتوای رجیستر ACC را با محتوای ادرس اشاره شده مقایسه و مقدار بزرگتر را در رجیستر ACC می ریزد.

if(ACC < [loc32]), ACC = [loc32];
if(ACC >= [loc32]), ACC = unchanged;

این دستور بسته به شرایط روی پرچمهای Z,N,C,V تاثیر می گذارد.

; Saturate VarA as follows:
; if(VarA > MaxPos) VarA = MaxPos
; if(VarA < MaxNeg) VarA = MaxNeg
MOVL ACC,@VarA ; ACC = VarA
MINL ACC,@MaxPos ; if(ACC > MaxPos) ACC = MaxPos
MAXL ACC,@MaxNeg ; if(ACC < MaxNeg) ACC = MaxNeg
MOVL @VarA,ACC ; Store result into VarA

MAXCUL P,loc32 :

بر مبنای حالت پرچمهای N و Z یک مقایسه مشروط بین محتوای بدون علامت رجیستر P و محتوای بدون علامت ادرس اشاره شده انجام می شود و رجیستر P با عدد بزرگتر پر می شود.

if( (N=1) & (Z=0) )
P = [loc32];
if( (N=0) & (Z=1) & (P < [loc32]) )
V=1, P = [loc32];
if( (N=0) & (Z=0) )
P = unchanged;

عملیات P<[loc32] همانند یک مقایسه 32 بیتی می باشد.
این دستور همراه با دستور MAXL یک دستور MAX 64 بیتی را تشکیل می دهند.فرض می شود که پرچمهای N وZ ابتدا با استفاده از دستور MAXL برای مقایسه 32 بیت بالای 64بیت ست شده باشند.دستور MAXCUL سپس برای مقایسه شرطی 32 بیت پایین بر اساس نتیجه مقایسه 32 بیت بالا استفاده می شود.

; Saturate 64-bit Var64 as follows:
; if(Var64 > MaxPos64 ) Var64 = MaxPos64
; if(Var64 < MaxNeg64 ) Var64 = MaxNeg64
MOVL ACC,@Var64+2
MOVL P,@Var64+0
; Load ACC:P with Var64
MINL ACC,@MaxPos64+2 ; if(ACC:P > MaxPos64) ACC:P = MaxPos64
MINCUL P,@MaxPos64+2
SB saturate,OV
MAXL ACC,@MaxNeg64+2 ; if(ACC:P < MaxNeg64) ACC:P = MaxNeg64
MAXCUL P,@MaxNeg64+0

Saturate:
MOVL @Var64+2,ACC ; Store result into Var64
MOVL @Var64,P

MINL ACC,loc32 :

این دستور رجیستر ACC را با محتوای ادرس اشاره شده مقایسه می کند و عدد کوچکتر را در رجیسترACC می ریزد.

if(ACC <= [loc32]), ACC = unchanged;
if(ACC > [loc32]), ACC = [loc32];

; Saturate VarA as follows:
; if(VarA > MaxPos) VarA = MaxPos
; if(VarA < MaxNeg) VarA = MaxNeg
MOVL ACC,@VarA ; ACC = VarA
MINL ACC,@MaxPos ; if(ACC > MaxPos) ACC = MaxPos
MAXL ACC,@MaxNeg ; if(ACC < MaxNeg) ACC = MaxNeg
MOVL @VarA,ACC ; Store result into VarA

MINCUL P,loc32 :

بر اساس حالت پرچمهای N و Z یک مقایسه شرطی بین محتوای بدون علامت رجیستر P و محتوای بدون علامت ادرس اشاره شده انجام می شود و مقدار کوچکتر در رجیستر P قرار می گیرد.

if( (N = 0) & (Z = 0) )
P = [loc32];
if( (N = 0) & (Z = 1) & (P > [loc32]) )
V=1, P = [loc32];
if( (N = 1) & (Z = 0) )
P = unchanged;

; Saturate 64-bit Var64 as follows:
; if(Var64 > MaxPos64 ) Var64 = MaxPos64
; if(Var64 < MaxNeg64 ) Var64 = MaxNeg64
MOVL ACC,@Var64+2 ; Load ACC:P with Var64
MOVL P,@Var64+0
MINL ACC,@MaxPos64+2 ; if(ACC:P > MaxPos64) ACC:P = MaxPos64
MINCUL P,@MaxPos64+0
MAXL ACC,@MaxNeg64+2 ; if(ACC:P < MaxNeg64) ACC:P = MaxNeg64
MAXCUL P,@MaxNeg64+0
MOVL @Var64+2,ACC ; Store result into Var64
MOVL @Var64+0,P

[ali833]

پاسخ : اموزش DSP

اینم یه چندتا دستور کوچیک دیگه.............

NEG ACC :

این دستور محتوای ACC را منفی می کند.

if(ACC = 0x8000 0000)
{
V = 1;
if(OVM = 1)
ACC = 0x7FFF FFFF;
else
ACC = 0x8000 0000;
}
else
ACC = −ACC;
if(ACC = 0x0000 0000)
C = 1;
else
C = 0;

; Negate contents of VarA, make sure value is saturated:
MOVL ACC,@VarA ; Load ACC with contents of VarA
SETC OVM ; Turn overflow mode on
NEG ACC ; Negate ACC and saturate
MOVL @VarA,ACC ; Store result into VarA

NEG AX :
این دستور محتوای رجیستر AX را با منفی ان پر می کند.

if(AX = 0x8000)
{
AX = 0x8000;
V flag = 1;
}
else
AX = −AX;
if(AX = 0x0000)
C flag = 1;
else
C flag = 0;

; Take the absolute value of VarA:
MOV AL,@VarA ; Load AL with contents of VarA
NEG AL ; If Al = 8000h, then V = 1
SB NoOverflow,NOV ; Branch and save −AL if no overflow
MOV @VarA,0x7FFFh ; Save 7FFF if overflow
NoOverflow:
MOV @VarA,AL ; Save NEG AL if no overflow

NEG ACC:P :
این دستور محتوای 64 بیتی رجیستر های ACC و P را منفی می کند.

if(ACC:P = 0x8000 0000 0000 0000)
{
V = 1;
if(OVM = 1)
ACC:P = 0x7FFF FFFF FFFF FFFF;
else
ACC:P = 0x8000 0000 0000 0000;
}
else
ACC:P = −ACC:P;
if(ACC:P = 0x0000 0000 0000 0000)
C = 1;
else
C = 0;

; Negate the contents of the 64-bit Var64 and saturate:
MOVL ACC,@Var64+2 ; Load ACC with high 32-bits of Var64
MOVL P,@Var64+0 ; Load P with low 32-bits of Var64
SETC OVM ; Enable overflow mode (saturate)
NEG64 ACC:P ; Negate ACC:P with saturation
MOVL @Var64+2,ACC ; Store high 32-bit result into Var64
MOVL @Var64+0,P ; Store low 32-bit result into Var64

NEGTC ACC :

این دستور بر اساس حالت بیت TC محتوای رجیستر ACC را با مقدار منفی ان تعویض می کند.

if( TC = 1 )
{
if(ACC = 0x8000 0000)
{
V = 1;
if(OVM = 1)
ACC = 0x7FFF FFFF;
else
ACC = 0x8000 0000
}
else
ACC = −ACC;
if(ACC = 0x0000 0000)
C = 1;
else
C = 0;
}

; Calculate signed: Quot16 = Num16/Den16, Rem16 = Num16%Den16
CLRC TC ; Clear TC flag, used as sign flag
MOV ACC,@Den16 << 16 ; AH = Den16, AL = 0
ABSTC ACC ; Take abs value, TC = sign ^ TC
MOV T,@AH ; Temp save Den16 in T register
MOV ACC,@Num16 << 16 ; AH = Num16, AL = 0
ABSTC ACC ; Take abs value, TC = sign ^ TC
MOVU ACC,@AH ; AH = 0, AL = Num16
RPT #15 ; Repeat operation 16 times
||SUBCU @T ; Conditional subtract with Den16
MOV @Rem16,AH ; Store remainder in Rem16
MOV ACC,@AL << 16 ; AH = Quot16, AL = 0
NEGTC ACC ; Negate if TC = 1
MOV @Quot16,AH ; Store quotient in Quot16

NOT ACC :
این دستور محتوای رجیستر ACC را با مکمل ان تعویض می کند.

ACC = ACC XOR 0xFFFFFFFF;

; Complement the contents of VarA:
MOVL ACC,@VarA ; ACC = VarA
NOT ACC ; Complement ACC contents
MOVL @VarA,ACC ; Store result into VarA

NOT AX :
این دستور محتوای رجیستر AX را با مکمل ان پر می کند.

AX = AX XOR 0xFFFF;

; Complement the contents of VarA:
MOV AL,@VarA ; Load AL with contents of VarA
NOT AL ; Complement contents of AL
MOV @VarA,AL ; Store result in VarA