اموزش DSP

[ali833]

پاسخ : اموزش DSP

سلام دوستان. من برگشتم بابت وقفه دو سه روزه هم شرمنده.
خوب می سراغ ادامه دستورات ADD .برای بقیه دستورات ADD تاثیر پذیری پرچم ها رو توضیح نمیدم چون همشون تقریبا مثل همدیگن البته برای اطلاع دقیقتر می تونید به منابع موجود مراجعه کنید.
ADD ACC,LOC16<<T :
عملوند رجیستر ACC می باشدو T نیز 16بیت بالای رجیستر XT می باشد
شرح دستور:مقدار اشاره شده به وسیله LOC 16 بعد از شیفت به رجیستر ACCاضافه می شود.مقدار شیفت به وسیله چهار بیت کم ارزشتر رجیستر T مشخص می شود.بیتهای بالای رجیستر T نادیده گرفته می شود.مقدار شیفت داده شده اگر SXM=1 باشد شامل گسترش بیت علامت می شود و اگر فعال نباشد مقدار شیفت داده شده به وسیله صفر پر می شود.

if(SXM=1)
ACC=ACC+S:[loc16]<<T(3:0(;
else
ACC=ACC+0:[loc16]<<T(3:0);

مثال:
جمع دو مقدار علامت دارACC=(VarA<<SB)+(VarB<<SB)

SETC SXM

فعال کردن بیت گسترش علامت

MOV T,@SA

بار کردن T با مقدار شیفت از متغیر SA

MOV ACC,@VarA<<T

بار کردن مقدار شیفت داده شده رجیستر VarA در رجیستر ACC

MOV T,@SB

بار کردن رجیستر T با مقدار شیفت از متغیر SB

ADD ACC,@VarB<<T
اضافه کردن مقدار شیفت داده شده متغیرVarB به رجیستر ACC

ADD ACC,loc16<<1..15:
خوب می ریم سراغ دستور ADD بعدی دیگه فکر کنم خودتون می تونید عملوند یا مد ادرس دهی و این چیزارو تشخیص بدید .پس من برای خلاصه کردن مبحث دیگه این چیزا رو توضیح نمیدم مگر اینکه چیز جدیدی باشه.
این دستور مقدار شیفت داده شده محتوای مکان اشاره شده را به رجیستر ACC اضافه می کند.
عملکرد بیت SXM مانند دستورات قبلی می باشد.

if (SXM=1)
ACC=ACC+S:[loc16]<< shift value;
else
ACC=ACC+0:[loc16]<< shift value;

ADD AX,loc16 :
محتوای امکان اشاره شده به رجیستر AX اضافه می کند و نتیجه را در رجیستر AX ذخیره می کند.

AX=AX+[loc16]

ADD loc16,AX :
محتوای رجیستر AX را با محتوای مکان اشاره شده به وسیله loc16 اضافه می کند و نتیجه را در loc16 ذخیره می کند.

; Add the contents of VarA to index register AR0:
MOV AL,@VarA ; Load AL with contents of VarA
ADD @AR0,AL ; AR0 = AR0 + AL
; Add the contents of VarB to VarC:
MOV AH,@VarB ; Load AH with contents of VarB
ADD @VarC,AH ; VarC = VarC + AH

ADD loc16,#16bitSigned :
مقدار علامت دار ثابت 16 بیتی را با محتوای علامت دار اشاره شده به وسیله loc16 جمع می کند و حاصل را در مکان اشاره شده به وسیله loc16 ذخیره می کند.

[loc16]=[loc16]+16bitSigned;

; Calculate:
; VarA = VarA + 10
; VarB = VarB − 3
ADD @VarA,#10 ; VarA = VarA + 10
ADD @VarB,#−3 ; VarB = VarB − 3

ADDB ACC,#8bit
یک مقدار ثابت 8 بیتی را با رجیستر ACC جمع می کند.
ACC=ACC + 0:8bit;

; Increment contents of 32-bit location VarA:
MOVL ACC,@VarA ; Load ACC with contents of VarA
ADDB ACC,#1 ; Add 1 to ACC
MOVL @VarA,ACC ; Store result back into VarA

ADD AX,#8bitSigned
مقدار ثابت 8 بیتی علامت دار را با رجیستر AX جمع می کند و نتیجه را در AX ذخیره می کند.
AX=AX + S:8bit;

; Add 2 to VarA and subtract 3 from VarB:
MOV AL,@VarA ; Load AL with contents of VarA
ADDB AL,#2 ; Add to AL the value 0x0002 (2)
MOV @VarA,AL ; Store result in VarA
MOV AL,@VarB ; Load AL with contents of VarB
ADDB AL,#−3 ; Add to AL the value 0xFFFD (−3)
MOV @VarB,AL ; Store result in VarB

ADD SP,#7bit
یک مقدار ثابت 7 بیتی را به SP اضافه می کند
SP=SP + 0:7bit;

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

ADDB XARn,#7bit
یک مقدار ثابت 7 بیتی را به رجیستر XARn اضافه می کند.
XARn= XARn +0:7bit;

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

[ali833]

پاسخ : اموزش DSP

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

[ali833]

پاسخ : اموزش DSP

خوب می ریم سراغ دستور AND .
AND ACC,#16bit<<#0..15
AND ACC,#16bit<#16
این دستورات برای شما یک AND بیتی بین رجیستر ACC و مقدار ثابت شیفت داده شده به چپ انجام می دهد.نتیجه در رجیستر ACC ذخیره می شود.

ACC =ACC AND (0:16bit<<shift value)

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

AND ACC,loc16 :
یک AND بیتی بین رجیستر ACC و محتوای ادرس اشاره شده که بیت علامت ان با صفر پر شده است انجام و نتیجه را در ACC قرار می دهد.
[ACC = ACC AND 0:[loc16

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

AND AX,loc16,#16bit :
این دستور یک AND بیتی بین مقدار ثابت 16 بیتی و مقدار اشاره شده به وسیله loc16 انجام می دهد و نتیجه را در رجیستر AX ذخیره می کند.
;AX = [loc16] AND 16bit

; Branch if either of Bits 2 and 7 of VarA are non-zero:
AND AL,@VarA,#0x0084 ; AL = VarA AND 0x0084
SB Dest,NEQ ; Branch if result is non-zero
; Merge Bits 0,1,2 of VarA with Bits 8,9,10 of VarB and store in
; VarC in bit locations 0,1,2,3,4,5:
AND AL,@VarA,#0x0007 ; Keep bits 0,1,2 of VarA
AND AH,@VarB,#0x0700 ; Keep bits 8,9,10 of VarB
LSR AH,#5 ; Scale back bits 8,9,10 to bits 3,4,5
OR AL,@AH ; Merge bits
MOV @VarC,AL ; Store result in VarC

AND IER,#16bit :
با انجام AND بیتی بین رجیستر IER و مقدار ثابت 16 بیتی وقفه های موردنظر را غیر فعال می کند.
IER= IER AND #16bit

; Disable INT1 and INT6 only. Do not modify state of other
; interrupts enable:
AND IER,#0xFFBE ; Disable INT1 and INT6

AND loc16,#16bitSigned :
این دستور یک AND بیتی بین مقدار ثابت 16 بیتی علامت دار و محتوای ادرس اشاره شده انجام می دهد.
[loc16] = [loc16] AND 16bit]

; Clear Bits 3 and 11 of VarA:
; VarA = VarA AND #~(1 << 3 | 1 << 11)
AND @VarA,#~(1 << 3 | 1 << 11) ; Clear bits 3 and 11 of VarA

ANDB AX,8bit :
یک AND بیتی بین رجیستر AL یا AH و یک مقدار ثابت 8 بیتی انجام می دهد و نتیجه را در رجیستر AX ذخیره می کند.
AX = AX AND 0:8bit

; Add VarA to VarB, keep LSByte and store result in VarC:
MOV AL,@VarA ; Load AL with contents of VarA
ADD AL,@VarB ; Add to AL contents of VarB
ANDB AL,#0xFF ; AND contents of AL with 0x00FF
MOV @VarC,AL ; Store result in VarC

[ali833]

پاسخ : اموزش DSP

سلام دوستان.در ادامه اشنایی با زبان اسمبلی F2812 به دستورات شیفت حسابی می رسیم.

ASR AX,#1..16 :
این دستور محتوای رجیستر AX را به اندازه مقدار ثابت 1..16 به راست شیفت می دهد.در طی عمل شیفت مقدار شامل گسترش بیت علامت می شود و اخرین بیتی که از رجیستر به بیرون شیفت داده می شود در بیت پرچم وضعیت کری ذخیره می شود.

; Calculate signed value: VarC = (VarA + VarB) >> 2
MOV AL,@VarA ; Load AL with contents of VarA
ADD AL,@VarB ; Add to AL contents of VarB
ASR AL,#2 ; Scale result by 2
MOV @VarC,AL ; Store result in VarC

ASR AX,T :
این دستور نیز یک شیفت حسابی به سمت راست انجام می دهد با این تفاوت که مقدار شیفت توسط 4 بیت کم ارزشتر رجیستر T تعیین می شود.این دستور شامل گسترش بیت علامت می شود و اخرین بیت خارج شده نیز در پرچم کری قرار می گیرد.

; Calculate signed value: VarC = VarA >> VarB;
MOV T,@VarB ; Load T with contents of VarB
MOV AL,@VarA ; Load AL with contents of VarA
ASR AL,T ; Scale AL by value in T bits 0 to 3
MOV @VarC,AL ; Store result in VarC

ASR64 ACC:P,#1..16 :
این دستور یک شیفت حسابی به سمت راست رو یک مقدار 64 بیتی که به طور مشترک در رجیستر های ACCو P قرار دارد انجام می دهد.

; Arithmetic shift right the 64-bit Var64 by 10:
MOVL ACC,@Var64+2 ; Load ACC with high 32 bits of Var64
MOVL P,@Var64+0 ; Load P with low 32 bits of Var64
ASR64 ACC:P,#10 ; Arithmetic shift right ACC:P by 10
MOVL @Var64+2,ACC ; Store high 32-bit result into Var64
MOVL @Var64+0,P ; Store low 32-bit result into Var64

ASR64 ACC:P,T :
این دستور نیز مانند دستور قبلی می باشد با این تفاوت که مقدار شیفت توسط 6 بیت کم ارزشتر رجیستر T تعیین می شود.

; Arithmetic shift right the 64-bit Var64 by contents of Var16:
MOVL ACC,@Var64+2 ; Load ACC with high 32 bits of Var64
MOVL P,@Var64+0 ; Load P with low 32 bits of Var64
MOV T,@Var16 ; Load T with shift value from Var16
ASR64 ACC:P,T ; Arithmetic shift right ACC:P by T(5:0)
MOVL @Var64+2,ACC ; Store high 32-bit result into Var64
MOVL @Var64+0,P ; Store low 32-bit result into Var64

ASRL ACC,T :
این دستور محتوای رجیستر ACC را به اندازه مقدار تعیین شده توسط 5 بیت کم ارزشتر رجیستر T به سمت راست شیفت می دهد.

; Arithmetic shift right contents of VarA by VarB:
MOVL ACC,@VarA ; ACC = VarA
MOV T,@VarB ; T = VarB (shift value)
ASRL ACC,T ; Arithmetic shift right ACC by T(4:0)
MOVL @VarA,ACC ; Store result into VarA

[ali833]

پاسخ : اموزش DSP

خوب دستورات شیفت به راست حسابی را توضیح دادم شیفت حسابی به سمت چپ هم که نداریم می رم سراغ شیفت منطقی به چپ.

LSL ACC,#1..16 :
این دستور محتوای رجیستر ACC را به سمت چپ به اندازه تعیین شده در فیلد مقدار شیفت می دهد.در طی عمل شیفت دادن پایین مرتبه ترین بیت با مقدار صفر پر می شود و اخرین بیت خارج شده درون پرچم کری قرار می گیرد.

; Logical shift left contents of VarA by 4:
MOVL ACC,@VarA ; ACC = VarA
LSL ACC,#4 ; Logical shift left ACC by 4
MOVL @VarA,ACC ; Store result into VarA

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

; Logical shift left contents of VarA by VarB:
MOVL ACC,@VarA ; ACC = VarA
MOV T,@VarB ; T = VarB (shift value)
LSL ACC,T ; Logical shift left ACC by T(3:0)
MOVL @VarA,ACC ; Store result into VarA

LSL AX,#1..16
LSL AX,T
این دو دستور هم مثل دستور قبلی می باشند فقط به جای ACC از AX استفاده شده.
LSL64 ACC:P#1..16 :
این دستور یک شیفت منطقی به سمت چپ روی یک مقدار 64 بیتی که به طور مشترک در رجیسترهای ACC وP قرار دارد انجام می دهد.مقدار شیفت توسط مقدار دهی فوری تعیین می شود.

; Logical shift left the 64-bit Var64 by 10:
MOVL ACC,@Var64+2 ; Load ACC with high 32 bits of Var64
MOVL P,@Var64+0 ; Load P with low 32 bits of Var64
LSL64 ACC:P,#10 ; Logical shift left ACC:P by 10
MOVL @Var64+2,ACC ; Store high 32-bit result into Var64
MOVL @Var64+0,P ; Store low 32-bit result into Var64

LSL64 ACC:P,T :
طرز کار این دستورو خودتون باید بتونید حدس بزنید.
LSLL ACC,T :
اینم همینطور فقط یه راهنمایی مقدار شیفت حداکثر 32 بیته.
دستورات شیفت منطقی به راست هم مانند شیفت به چپ می باشد فقط به جای استفاده از LSL باید از دستورLSR استفاده کنید.
اینم یک مثال از شیفت منطقی به راست.
LSR AX.#1..16 :
این دستور یک شیفت منطقی به راست روی محتوای 16بیتی رجیستر AX انجام می دهد.در طی عمل شیفت بیتهای با مرتبه بالاتر با صفر پر می شوند و اخرین بیت خارج شده از رجیستر در بیت پرچم کری قرار می گیرد.

; Divide index register AR0 by 2:
MOV AL,@AR0 ; Load AL with contents of AR0
LSR AL,#1 ; Scale result by 1 (/2)
MOV @AR0,AL ; Store result back in AR0

good luck

[ali833]

پاسخ : اموزش DSP

سلام دوستان.حالا می خوام برم سراغ چندتا دستور انشعاب.

B 16bitOffset,COND :
مقدار offset یک مقدار 16 بیتی علامت دار می باشد.
کدهای شرط به صورت زیر می باشد.

COND Syntax Description Flags Tested
0000 NEQ Not Equal To Z = 0
0001 EQ Equal To Z = 1
0010 GT Greater Then Z = 0 AND N = 0
0011 GEQ Greater Then Or Equal To N = 0
0100 LT Less Then N = 1
0101 LEQ Less Then Or Equal To Z = 1 OR N = 1
0110 HI Higher C = 1 AND Z = 0
0111 HIS, C Higher Or Same, Carry Set C = 1
1000 LO, NC Lower, Carry Clear C = 0
1001 LOS Lower Or Same C = 0 OR Z = 1
1010 NOV No Overflow V = 0
1011 OV Overflow V = 1
1100 NTC Test Bit Not Set TC = 0
1101 TC Test Bit Set TC = 1
1110 NBIO BIO Input Equal To Zero BIO = 0
1111 UNC Unconditional −

این دستور به این صورت عمل می کند که اگر شرط موردنظر اتفاق بیافتد مقدار ثابت 16 بیتی به مقدار شمارنده برنامه اضافه می شوددر غیر این صور برنامه بدون انشعاب ادامه می یابد.

--BANZ 16bitOffset,ARn:
در این دستور اگر محتوای 16 بیتی رجیستر کمکی برابر صفر نباشد مقدار 16بیتی علامت دار offset به شمارنده بذنامه اضافه می شود.مقدار 16 بیتی offset با گسترش بیت علامت قبل از اضافه شدن 22 بیتی می شود.سپس مقدار رجیستر کمکی یک واحد کاهش می یابد..16 بیت بالای رجیستر کمکی در مقایسه استفاده نمی شود و هنگام کاهش نیز تحت تاثیر قرار نمی گیرد.

; Copy the contents of Array1 to Array2:
; int32 Array1[N];
; int32 Array2[N];
; for(i=0; i < N; i++)
; Array2[i] = Array1[i];
MOVL XAR2,#Array1 ; XAR2 = pointer to Array1
MOVL XAR3,#Array2 ; XAR3 = pointer to Array2
MOV @AR0,#(N−1) ; Repeat loop N times
Loop:
MOVL ACC,*XAR2++ ; ACC = Array1[i]
MOVL *XAR3++,ACC ; Array2[i] = ACC
BANZ Loop,AR0−− ; Loop if AR0 != 0, AR0−−

BAR 16bitOffset,ARn,ARm,EQ :
BAR 16bitOffset,ARn,ARm,NEQ :

Syntax Description Condition Tested
NEQ Not Equal To ARn != ARm
EQ Equal To ARn = ARm

این دستور محتوای دو رجیستر ARn وARm را مقایسه می کند درصورت درستی شرایط یک انشعاب اتفاق می افتد.

If (tested condition = true) PC = PC + signed 16-bit offset;
If (tested condition = false) PC = PC + 2;

; String compare:
MOVL XAR2,#StringA ; XAR2 points to StringA
MOVL XAR3,#StringB ; XAR3 points to StringB
MOV @AR4,#0 ; AR4 = 0
Loop:
MOVZ AR0,*XAR2++ ; AR0 = StringA[i]
MOVZ AR1,*XAR3++ ; AR1 = StringB[i], i++
BAR Exit,AR0,AR4,EQ ; Exit if StringA[i] = 0
BAR Loop,AR0,AR1,EQ ; Loop if StringA[i] = StringB[i]
NotEqual: ; StringA and B not the same
.
Exit: ; StringA and B the same

BF 16bitOffset,COND :

COND Syntax Description Flags Tested
0000 NEQ Not Equal To Z = 0
0001 EQ Equal To Z = 1
0010 GT Greater Then Z = 0 AND N = 0
0011 GEQ Greater Then Or Equal To N = 0
0100 LT Less Then N = 1
0101 LEQ Less Then Or Equal To Z = 1 OR N = 1
0110 HI Higher C = 1 AND Z = 0
0111 HIS, C Higher Or Same, Carry Set C = 1
1000 LO, NC Lower, Carry Clear C = 0
1001 LOS Lower Or Same C = 0 OR Z = 1
1010 NOV No Overflow V = 0
1011 OV Overflow V = 1
1100 NTC Test Bit Not Set TC = 0
1101 TC Test Bit Set TC = 1
1110 NBIO BIO Input Equal To Zero BIO = 0
1111 UNC Unconditional

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

[ali833]

پاسخ : اموزش DSP

خوب می ریم سراغ ادامه دستورات انشعاب و فراخوانی توابع.
FFC XAR7,22bit :
این دستور یک فراخوانی تابع سریع می باشد.ادرس برگشت در رجیستر XAR7 ذخیره می شود و ادرس مقصد به داخل PC بار می شود.

XAR7(21:0)=PC +2;
XAR7(31:22)=0;
PC= 22 bit;

; Fast function call of FuncA:
FFC XAR7,FuncA ; Call FuncA, return address in XAR7
.
.
FuncA: ; Function A:
.
.
LB *XAR7 ; Return: branch to address in XAR7

IRET :
بازگشت از یک وقفه.دستور IRET مقدار شمارنده و رجیسترهای دیگر که در هنگام وقفه به صورت خودکار ذخیره شده است را بر می گرداند.ترتیب بازخوانی مقادیر عکس روش ذخیره انها می باشد.همه مقادیر بااستفاده از عملیات 32 بیتی باز خوانی می شوند.

SP = SP – 2;
PC = [SP];
SP = SP – 2;
DBGSTAT:IER = [SP];
SP = SP − 2;
DP:ST1 = [SP];
SP = SP – 2;
AR1:AR0 = [SP];
SP = SP – 2;
PH:PL = [SP];
SP = SP – 2;
AH:AL = [SP];
SP = SP – 2;
T:ST0 = [SP];
SP = SP – 1;

عملیات حالت همه پرچمها و مدهای رجیستر ST0 را در هنگام وقوع وقفه باز می گرداند.

; Full interrupt context Save and Restore:
; Vector table:
INTx: .long INTxService ; INTx interrupt vector
.
.
.
; Interrupt context save:
INTxService: ; ACC, P, T, ST0, ST1, DP, AR0,
; AR1, IER, DPGSTAT registers saved
; on stack.
; Return PC saved on stack.
; IER bit corresponding to INTx
; is disabled.
; ST1(EALLOW bit = 0).
; ST1(LOOP bit = 0).
; ST1(DBGM bit = 1).
; ST1(INTM bit = 1).
PUSH AR1H:AR0H ; Save remaining registers.
PUSH XAR2
PUSH XAR3
PUSH XAR4
PUSH XAR5
PUSH XAR6
PUSH XAR7
PUSH XT
; Interrupt user code:
.
.
.
; Interrupt context restore:
POP XT ; Restore registers.
POP XAR7
POP XAR6
POP XAR5
POP XAR4
POP XAR3
POP XAR2
POP AR1H:AR0H
IRET ; Return from interrupt.

LB *XAR7 :
انشعاب بلند غیر مستقیم.شمارنده برنامه با 22 بیت کم ارزشتر رجیستر XAR7 پر می شود.

; Branch to subroutines in SwitchTable selected by Switch value:
SwitchTable: ; Switch address table:
.long Switch0 ; Switch0 address
.long Switch1 ; Switch1 address
.
.
MOVL XAR2,#SwitchTable ; XAR2 = pointer to SwitchTable
MOVZ AR0,@Switch ; AR0 = Switch index
MOVL XAR7,*+XAR2[AR0] ; XAR7 = SwitchTable[Switch]
LB *XAR7 ; Indirect branch using XAR7
SwitchReturn:
.
.
Switch0: ; Function A:
.
.
LB SwitchReturn ; Return: long branch
Switch1: ; Function B:
.
.
LB SwitchReturn ; Return: long branch

LB 22bit :
انشعاب بلند.شمارنده برنامه با ادرس 22 بیتی برنامه بار می شود.

; Branch to subroutines in SwitchTable selected by Switch
; value:
SwitchTable: ; Switch address table:
.long Switch0 ; Switch0 address
.long Switch1 ; Switch1 address
.
.
MOVL XAR2,#Switch-
Table
; XAR2 = pointer to SwitchTable
MOVZ AR0,@Switch ; AR0 = Switch index
MOVL XAR7,*+XAR2[AR0] ; XAR7 = SwitchTable[Switch]
LB *XAR7 ; Indirect branch using XAR7
SwitchReturn:
.
.
Switch0: ; Function A:
.
.
LB SwitchReturn ; Return: long branch
Switch1: ; Function B:
.
.
LB SwitchReturn ; Return: long branch

LC *XAR7 :
فراخوانی بلند غیر مستقیم.ادرس برگشت در دو عملیات 16 بیتی به داخل پشته نرم افزاری می رود.سپس ادرس مقصد که در رجیستر XAR7 ذخیره شده به داخل PC بار می شود.

; Call to subroutines in SwitchTable selected by Switch value:
SwitchTable: ; Switch address table:
.long Switch0 ; Switch0 address
.long Switch1 ; Switch1 address
.
.
MOVL XAR2,#SwitchTable ; XAR2 = pointer to SwitchTable
MOVZ AR0,@Switch ; AR0 = Switch index
MOVL XAR7,*+XAR2[AR0] ; XAR7 = SwitchTable[Switch]
LC *XAR7 ; Indirect call using XAR7
.
.
Switch0: ; Subroutine 0:
.
.
LRET ; Return
Switch1: ; Subroutine 1:
.
.
LRET ; Return

LC 22bit :
فراخوانی تابع بلند.مقدار PC در پشته ذخیره می شود و سپس ادرس مقصد به داخل شمارنده بار می شود.

; Standard function call of FuncA:
LC FuncA ; Call FuncA, return address on stack
.
.
FuncA: ; Function A:
.
.
LRET ; Return from address on stack

LCR #22bit :
دستور فراخوانی بلند که برای برگشت ازرجیستر RPC استفاده می کند.مقدار جاری RPC به داخل پشته می رود و سپس RPC با ادرس برگشت بار می شود.سپس ادرس 22 بیتی مقصد در داخل PC قرار می گیرد.این دستور از دستور قبلی سریعتر می باشد.

; RPC call of FuncA:
LCR FuncA ; Call FuncA, return address in RPC
.
.
FuncA: ; Function A:
.
.
LRETR ; RPC return

LCR #XARn :
دستور فراخوانی غیر مستقیم با استفاده از RPC برای ذخیره ادرس بازگشت.

; Call to subroutines in SwitchTable selected by Switch value:
SwitchTable: ; Switch address table:
.long Switch0 ; Switch0 address
.long Switch1 ; Switch1 address
.
MOVL XAR2,#SwitchTable ; XAR2 = pointer to SwitchTable
MOVZ AR0,@Switch ; AR0 = Switch index
MOVL XAR6,*+XAR2[AR0] ; XAR6 = SwitchTable[Switch]
LCR *XAR6 ; Indirect RPC call using XAR6
.
Switch0: ; Subroutine 0:
.
.
LRETR ; RPC Return
Switch1: ; Subroutine 1:
.
LRETR ; RPC Return

LOOPNZ loc16,#16bit :

while([LOC16] &16bit !=0);

دستور LOOPNZ از یک AND بیتی برای مقایسه مقدار ارجاع داده شده با مد ادرس دهی "loc16" و مقدار پوشش 16 بیتی استفاده می کند.دستور این مقایسه را تا هنگامیکه نتیجه مقایسه برابر صفر نباشد انجام می دهد.فرایند دستور به صورت زیر می باشد
1-بیت LOOP در رجیستر ST1 ست می شود.
2-ادرس مقدار اشاره شده به وسیله مد ادرس "loc16" تولید می شود.
3-اگر "loc16" یک عملوند ادرس دهی غیر مستقیم باشد تنظیمات ویژه اشاره گر پشته یا رجیستر کمکی مخصوص یا/و اشاره گر ARPn انجام می شود.
4-مقایسه مقدار ادرس دهی شده و مقدار پوشش به وسیله یک AND بیتی انجام می شود.
5-اگر نتیجه صفر باشدبیت LOOP پاک می شود و PC 2 واحد افزایش می یابد در غیر اینصورت به مرحله 1 باز می گردد.
حلقه ایجاد شده به وسیله مراحل یک تا پنج می تواند به وسیله وقفه سخت افزاری دچار وقفه شود.هنگامیکه یک وقفه ایجاد می شود،اگر دستور LOOPNZ هنوز فعال باشد ادرس بازگشت در پشته اشاره شده به وسیله دستور LOOPNZ ذخیره می شود.بنابراین به محض باز گشت از وقفه دستور LOOPNZ مجددا واکشی می شود.
تا زمانیکه عملیات AND مخالف صفر است،دستور LOOPNZ هر پنج سیکل در فاز دو کد گشایی خط لوله اجرا می شود.بنابراین مکان حافظه یا رجیستر هر پنج سیکل یک بار خوانده می شود.اگر شما از مد ادرس دهی غیر مستقیم استفاده می کنید شما می توانید یک افزایش یا کاهش برای اشاره گر تعریف کنید.اگر شما این کار را انجام دهید،اشاره گر هر بار در فاز دو کدگشایی خط لوله اپدیت می شود.با این کار شما می توانید مقدار پوشش را هر بار بایک مقدار جدید مقایسه کنید.
دستور LOOPNZ دستورات پیش واکشی شده را از خط لوله حذف نمی کند.اما اگر یک وقفه روی دهد دستورات پیش واکشی شده از بین می روند.
هنگامیکه وقفه ای روی می دهد حالت جاری بیت LOOP که در ST1 ذخیره شده به داخل پشته می رود.بیت LOOPدر ST1 به وسیله وقفه پاک می شود.بیت LOOP یک بیت وضعیت پسیو می باشد.دستور LOOPNZبیت LOOP را تغییر می دهد،امابیتLOOP روی دستور اثری ندارد.
شما می توانید در طی اجرای روتین سرویس وقفه دستور LOOPNZ را نادیده بگیرید.بیت LOOP درپشته ذخیره می شود.اگر ست باشد شما می توانید ادرس بازگشت ذخیره شده در پشته را دو واحد افزایش دهید.به محض باز گشت از وقفه این ادرس افزایش یافته در شمارنده برنامه قرار می گیرد و دستور بعد از LOOPNZ اجرا می شود.

; Wait until bit 3 in RegA is cleared before writing to RegB:
LOOPNZ @RegA,#0x0004 ; Loop while (RegA AND 0x0004 != 0)
MOV @RegB,#0x8000 ; RegB = 0x8000

LOOPZ loc16,#16bit :
این دستور نیز مانند دستور قبلی می باشد با این فرق که تا هنگامیکه نتیجه AND برابر صفر می باشد دستور تکرار می شود.

while ([loc16] & 16bit = 0);

; Wait until bit 3 in RegA is set before writing to RegB:
LOOPZ @RegA,#0x0004 ; Loop while (RegA AND 0x0004 = 0)
MOV @RegB,#0x8000 ; RegB = 0x8000

ادامه دارد...

[شهناز]

پاسخ : اموزش DSP

با سلام من حدود سه ماهه که روی سری c6000 کار می کنم می خواستم توی این سایت هم یه چیزایی یاد بگیرم و هم اگه تونستم یه چیزایی یاد بدم :agree:

[pooyafaroka]

پاسخ : اموزش DSP

سلام
خیلی خوش آمدید. اگر در زمینه CCS مطالبی دارید خوشحال می شویم یاد بگیریم.

با سلام من حدود سه ماهه که روی سری c6000 کار می کنم می خواستم توی این سایت هم یه چیزایی یاد بگیرم و هم اگه تونستم یه چیزایی یاد بدم :agree:

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

پیروز و سربلند باشید.

[ali833]

پاسخ : اموزش DSP

سلام دوستان.اول از همه فرارسیدن ماه رمضان را خدمت دوستان گرامی تبریک می گم.بعدم شرمنده یه مدت نبودم این adsl مشکل داشت با dial up اصلا حسش نبود که بیام تو نت به هر حال مشکل حل شد .سعی می کنم در عرض یک هفته باقی مانده دستورات اسمبلی را تموم کنم که بعد بریم سراغ ccs v3.3.

[ali833]

پاسخ : اموزش DSP

خوب می رم سراغ ادامه دستورات مربوط به فراخوانی ها و انشعابها.
LRET :
بازگشت بلند،این دستور ادرس بازگشت را از پشته نرم افزاری به داخل PC وارد می کند.

; Standard function call of FuncA:
LC FuncA ; Call FuncA, return address on stack
.
.
FuncA: ; Function A:
.
.
LRET ; Return from address on stack

LRETE :
بازگشت بلند و فعال سازی وقفه.ادرس بازگشت از پشته نرم افزاری خوانده شده و پرچم وقفه سراسری(INTM) پاک می شود.
LRETR :
بازگشت بلند با استفاده از اشاره گر بازگشت PC .ادرس بازگشت که در رجیستر RPC ذخیره شده است به داخل PC بار می شود.

[ali833]

پاسخ : اموزش DSP

خوب حالا می رم سراغ دستورات MOV .تعدادشون زیاده ولی همشون تقریبا مثل هم هستن.
MOV AR6/7,loc16 :
این دستور رجیسترهای کمکی 6 یا 7 را با محتوای 16 بیتی مکان اشاره شده پر می کند و 16 بیت بالای XAR6 وXAR7 را بدون تغییر می گذارد.
MOV loc16,ARn :
مکان 16 بیتی مورد اشاره را با محتوای ARn پر می کند.

MOV @AL, AR3
MOV @AR4,AR3
MOV *SP++,AR3
MOV *XAR4++,AR4
MOV *−−XAR5,AR5
; Load AL with the 16-bit contents of
; AR3. If bit 15 of AL is 1, set the
; N flag, else clear it.
; If AL is 0, set the Z flag.
; Load AR4 with the value in AR3.
; Upper 16 bits of XAR4 are
; unchanged.
; Push the contents of AR3 onto the
; stack. Post increment SP.
; Store contents of AR4 into location
; specified by XAR4. Post-increment
; the contents of XAR4.
; Pre-decrement the contents of XAR5.
; Store the contents of AR5 into the
; location specified by XAR5.

MOV XARn,PC :
این دستور رجیستر XARn را با محتوای PC بار می کند.

TableA:
.long CONST1
.long CONST2
.long CONST3
.
FuncA:
MOV XAR5,PC
SUBB XAR5,#($−TableA)
MOVL ACC,*+XAR5[2]
MOVL @VarA,ACC
; Location of TableA is relative to
; the current program
; XAR5 = current PC location
; XAR5 = TableA start location
; Load ACC with CONST2
; Store CONST2 in VarA

MOVB XARn,#8bit :
این دستور یک مقدار 8 بیتی بدون علامت را به داخل رجیستر XARn بار می کند.
MOVL XARn,loc32 :
این دستور رجیستر XARn را با محتوای 32 بیتی ادرس داده شده پر می کند.

MOVL XAR0,@ACC ; Move the 32-bit contents of ACC into
; XAR0
MOVL XAR2,*XAR0++ ; Move the 32-bit value pointed to by
; XAR0 into XAR2. Post increment XAR0
; by 2
MOVL XAR3,*XAR3++ ; Move the 32-bit value pointed to by
; XAR3 into XAR3. Address modification
; of XAR3 is ignored.
MOVL XAR4,*−−XAR4 ; Predecrement the contents of XAR4.
; Move the 32-bit value pointed to by
; XAR4 into XAR4.

MOVZ ARn,loc16 :
رجیستر ARn با محتوای 16 بیتی ادرس اشاره شده بار می شود و ARnH نیز پاک می شود.

MOVL XAR7, #ArrayA ; Initialize XAR2 pointer
MOVZ AR0, *+XAR2[0] ; Load 16-bit value pointed to by XAR2
; into AR0. XAR0(31:16) = 0.
MOVZ AR7, *−SP[1] ; Load the first 16-bit value off of the
; stack into AR7. XAR7(31:16) = 0.

MOV DP,#10bit :
این دستور رجیستر صفحه داده را با یک مقدار ثابت 10 بیتی بار می کند و 6 بیت بالایی را بدون تغییر نگه می دارد.

MOV DP,#VarA
; Load DP with the data page that
; contains VarA. Assumes VarA is in
; the lower 0x0000 FFC0 of memory.
; DP(15:10) is left unchanged.

MOVW DP,#16bit :
این دستور رجیستر DP را با یک مقدار 16 بیتی پر می کند.

MOVW DP, #VarA ; Load DP with the data page that
; contains VarA. Assumes VarA is in the
; lower 0x003F FFC0 of memory
MOVW DP, #0F012h ; Load DP with data page number 0xF012

MOVZ DP,#10bit:
این دستور رجیستر DP را با یک مقدار 10 بیتی بار می کند و6 بیت بالا ان را نیز پاک می کند.

[ali833]

پاسخ : اموزش DSP

سلام دوستان.در ادامه دستورات MOV به سری دستوراتی می رسیم که از رجیستر AX به عنوان عملوند استفاده می کند.
MOV AX,loc16 :
این دستور رجیستر پایین اکومولاتورAL یا رجیستر بالای ان AH را با محتوای مکان اشاره شده به وسیله مد ادرس دهی "loc16" پر می کند.
این دستور پرچمهای N وZ را تحت تاثیر قرار می دهد.

MOV AH, *+XAR0[0] ; Load AH with the 16-bit contents
; of location pointed to by XAR0.
; AL is unchanged.
SB NotZero,NEQ ; Branch if contents of AH were non
; zero.

MOV loc16,AX :
این دستور مقدار AX را در مکان اشاره شده به وسیله loc16 ذخیره می کند.

; Initialize all Array1 elements with the value 0xFFFF:
MOV AH,#0xFFFF ; Load AH with the value 0xFFFF
MOVL XAR2,#Array1 ; Load XAR2 with address of Array1
RPT #9
|| MOV *XAR2++, AH
; Repeat next instruction 10 times.
; Store contents of AH into location
; pointed by XAR2 and post-increment
; XAR2.

MOV loc16,AX,COND :
اگر COND=TRUE این دستور اجرا می شود.

COND Syntax Description Flags Tested
0000 NEQ Not Equal To Z = 0
0001 EQ Equal To Z = 1
0010 GT Greater Then Z = 0 AND N = 0
0011 GEQ Greater Then Or Equal To N = 0
0100 LT Less Then N = 1
0101 LEQ Less Then Or Equal To Z = 1 OR N = 1
0110 HI Higher C = 1 AND Z = 0
0111 HIS, C Higher Or Same, Carry Set C = 1
1000 LO, NC Lower, Carry Clear C = 0
1001 LOS Lower Or Same C = 0 OR Z = 1
1010 NOV No Overflow V = 0
1011 OV Overflow V = 1
1100 NTC Test Bit Not Set TC = 0
1101 TC Test Bit Set TC = 1
1110 NBIO BIO Input Equal To Zero BIO = 0
1111 UNC Unconditional

; Swap the contents of VarA and VarB if VarB is higher then VarA:
MOV AL,@VarA ; AL = VarA, XAR2 points to VarB
MOV AH,@VarB ; AH = VarB, XAR2 points to VarA
CMP AH,@AL ; Compare AH and AL
MOV @VarA,AH,HI ; Store AH in VarA if higher
MOV @VarB,AL,HI ; Store AL in VarB if higher

MOVB AX,#8bit :
این دستور یک مقدار 8 بیتی را به داخل AL یا AX بار می کند.

MOVB AL, #0xF0 ; Load AL with the value 0x00F0.
CMP AL,*+XAR0[0] ; Compare contents pointed to by XAR0
; with AL.
SB Dest,EQ ; Branch if values are equal.

MOV AX.LSB,loc16 :
این دستور بایت کم ارزشتر رجیستر AX را با 8 بیت از داده اشاره شده به وسیله loc16 پر می کند.شکل عملوند loc16 تعیین می کند که کدام 8 بیت به داخل AX.LSB بار شود.
(

if(loc16=*+XARn[offset]
{
(if(offset is an even number
AX.LSB=[loc16.LSB];
if(offset is an odd value)
AX.LSB=[loc16.MSB];
}
else
AX.LSB=[loc16.LSB];
AX.MSB=0x00;

; Swap the byte order in the 32-bit ”Var32” location.
; Before operation: Var32 = B3 | B2 | B1 | B0
; After operation: Var32 = B0 | B1 | B2 | B3
MOVL XAR2,#Var32 ; Load XAR2 with address of ”Var32”
MOVB AL.LSB,*+XAR2[3] ; ACC(B0) = Var32(B3), ACC(B1) = 0
MOVB AH.LSB,*+XAR2[1] ; ACC(B2) = Var32(B1), ACC(B3) = 0
MOVB AL.MSB,*+XAR2[2] ; ACC(B1) = Var32(B2), ACC(B1) = unch
MOVB AH.MSB,*+XAR2[0] ; ACC(B3) = Var32(B0), ACC(B1) = unch
MOVL @Var32,ACC ; Store swapped result in ”Var32”

MOVB AX.MSB,loc16 :
این دستور نیز مانند دستور قبلی می باشد.
MOVB loc16,AX.LSB :

if(loc16 = *+XARn[offset])
{
if(offset is an even value)
[loc16.LSB] = AX.LSB;
[loc16.MSB] = unchanged;
if(offset is an odd value)
[loc16.LSB] = unchanged;
[loc16.MSB] = AX.LSB;
}
else
[loc16.LSB] = AX.LSB;
[loc16.MSB] = unchanged;

MOV loc16,AX.MSB:
با توجه به دستورات قبلی عملکرد این دستور نیز کاملا روشن است.

if(loc16 = *+XARn[offset])
{
if( offset is an even number )
[loc16.LSB] = AX.MSB;
[loc16.MSB] = unchanged;
if( offset is an odd number )
[loc16.LSB] = unchanged;
[loc16.MSB] = AX.MSB;
}
else
[loc16.LSB] = AX.MSB;
[loc16.MSB] = unchanged;

خوب حالا می رم سراغ دستوراتی که عملوندشون رجیستر ACC می باشد.
MOV ACC.loc16<<#0
MOV ACC,loc16<<#1..15
MOV ACC,loc16<<#16:
این دستور مقدار موجود در مکان اشاره شده به وسیله loc16 بعد از شیفت به چپ درون رجیستر ACC بار می کند.

if(SXM = 1) // sign extension mode enabled
ACC = S:[loc16] << shift value;
else // sign extension mode disabled
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
ADD ACC,@VarB << #6 ; Add VarB left shifted by 6 to ACC

MOV loc16,ACC<<1
MOV loc16,ACC<<2..8 :
این دستور مکان اشاره شده به وسیله loc16 را با کلمه پایین ACC بعد از شیفت به چپ پر می کند.

; Multiply two Q15 numbers (VarA and VarB) and store result in
; VarC as a Q15 number:
MOV T,@VarA ; T = VarA (Q15)
MPY ACC,T,@VarB ; ACC = VarA * VarB (Q30)
MOVH @VarC,ACC << 1 ; VarC = ACC >> (16−1) (Q15)
; VarC as a Q31 number:
MOV T,@VarA ; T = VarA (T = Q14)
MPY ACC,T,@VarB ; ACC = VarA * VarB (ACC = Q28)
MOV @VarC+0,ACC << 3 ; VarC low = ACC << 3
MOVH @VarC+1,ACC << 3 ; VarC high = ACC >> (16−1) (VarC = Q31)

MOV ACC,loc16<<T :
این دستور هم مانند دستور قبلی می باشد با این تفاوت که مقدار شیفت توسط 4 بیت کم ارزشتر رجیستر T تعیین می شود.

; 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
ADD ACC,@VarB << T ; Add to ACC shifted contents of VarB

MOVB ACC,#8bit:
یک مقدار ثابت 8 بیتی را در ACC بار می کند.

; Increment contents of 32-bit location VarA:
MOVB ACC,#1 ; Load ACC with the value 0x0000 0001
ADDL ACC,@VarA ; Add to ACC the contents of VarA
MOVL @VarA,ACC ; Store result back into VarA

MOVH loc16,ACC<<1 :
این دستورکلمه بالای رجیستر ACC را بعد از شیفت به چپ در ادرس اشاره شده ذخیره می کند.
MOVU ACC,loc16 :
این دستور نیمه پایین رجیستر ACC را با محتوای 16 بیتی ادرس اشاره شده پر می کند و نیمه بالا با صفر پر می شود.

; Add three 32-bit unsigned variables by 16-bit parts:
MOVU ACC,@VarAlow ; AH = 0, AL = VarAlow
ADD ACC,@VarAhigh << 16 ; AH = VarAhigh, AL = VarAlow
ADDU ACC,@VarBlow ; ACC = ACC + 0:VarBlow
ADD ACC,@VarBhigh << 16 ; ACC = ACC + VarBhigh << 16
ADDCU ACC,@VarClow ; ACC = ACC + VarClow + Carry
ADD ACC,@VarChigh << 16 ; ACC = ACC + VarChigh << 16

[ali833]

پاسخ : اموزش DSP

سلام دوستان . یه چند تا دستور mov دیگه مونده که تو این پست تمومش می کنم بعد فقط می مونه دستورات مربوط به عملیات ضرب و تفریق و چند تا تک دستور بعد دیگه میریم سراغ CCS V.3.3 .

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

MOV PH,loc16 :
این دستور 16 بیت بالای رجیستر را با محتوای ادرس اشاره شده پر می کند و 16 بیت پایین را بدون تغییر رها می کند.

; Swap the contents of AH and AL:
MOV PH,@AL ; Load PH with AL
MOV PL,@AH ; Load PL with AH
MOV ACC,@P ; Load ACC with P (AH and AL swapped)

MOV PL,loc16 :
این دستور همان عمل گفته شده در بالا را روی 16 بیت پایین انجام می دهد.

MOV loc16,P :
محتوای رجیستر ح به مقدار تعیین شده در رجیسترمد شیفت ضرب PM شیفت پیدا می کند و نیمه پایین مقدار شیفت داده شده در محل اشاره شده به وسیله ادرس ذخیره می شود.

[loc16] = P<<PM ;

علامت PM نوع شیفت را تعیین می کند اگر مثبت باشد شیفت منطقی به چپ و اگر منفی باشد به راست انجام می شود.

; Calculate Y32 = M16*X16 >> 6
MOV T,@M16 ; T = M
MPY P,T,@X16 ; P = T * X
SPM −6 ; Set product shift to >> 6
MOV @Y32+0,P ; Y32 = P >> 6
MOVH @Y32+1,P

MOV T,loc16 :
رجیستر T با محتوای 16 بیتی ادرس اشاره شده پر می شود.

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

MOV loc16,T :
محتوای رجیستر T را در ادرس اشاره شده ذخیره می کند.

MOV TL,#0 :
این دستور نیمه پایین رجیستر مضروب را با صفر پر می کند و نیمه بالایی را بدون تغییر رها می کند.

MOVA T,loc16 :
این دستور رجیستر T را با محتوای 16 بیتی اشاره شده توسط ادرس پر می کند.همچنین محتوای رجیستر که به اندازه مقدار PM شیفت داده شده است به محتوای رجیستر ACC اضافه می شود.

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

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

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

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

MOVDL XT,loc16 :
این دستور رجیستر XT را با محتوای 32 بیتی ادرس داده شده پر می کند و سپس مکان 32 بیتی ادرس بالا تر را با محتوای رجیستر XT پر می کند.

XT = [loc32];
[loc32 + 2] = XT ;

; Calculate using 32-bit multiply, retaining high result:
; Y = (X0*C0) >> 2) + (X1*C1 >> 2) + (X2*C2 >> 2)
; X2 = X1
; X1 = X0
SPM −2 ; Set product shift to >> 2
ZAPA ; Zero ACC, P, OVC
MOVL XT,@X2 ; XT = X2
QMPYL P,XT,@C2 ; P = XT*C2
MOVDL XT,@X1 ; XT = X1, ACC = X2*C2>>2, X2 = X1
QMPYAL P,XT,@C1 ; P = XT*C1
MOVDL XT,@X0 ; XT = X0, ACC = X1*C1>>2 + X2*C2>>2, X1 = X0
QMPYAL P,XT,@C0 ; P = XT*C0
ADDL ACC,P << PM ; ACC = X0*C0>>2 + X1*C1>>2 + X2*C2>>2
MOVL @Y,ACC ; Store result into Y

MOVH loc16,P :
محتوای رجیستر P به اندازه مقدار رجیستر PM شیفت داده می شود و نیمه بالایی مقدار شیفت داده شده در ادرس اشاره شده ذخیره می شود.

; Calculate Y32 = M16*X16 >> 6
MOV T,@M16 ; T = M
MPY P,T,@X16 ; P = T * X
SPM −6 ; Set product shift to >> 6
MOV @Y32+0,P ; Y32 = P >> 6
MOVH @Y32+1,P

MOVL P,loc32 :
این دستور رجیستر P رابا محتوای 32 بیتی ادرس اشاره شده پر می کند.

; Add 64-bit VarA, VarB and VarC, and store result in VarD:
MOVL P,@VarA+0 ; Load P with low 32 bits of VarA
MOVL ACC,@VarA+2 ; Load ACC with high 32 bits of VarA
ADDUL P,@VarB+0 ; Add to P unsigned low 32 bits of VarB
ADDCL ACC,@VarB+2 ; Add to ACC with carry high 32 bits of VarB
ADDUL P,@VarC+0 ; Add to P unsigned low 32 bits of VarC
ADDCL ACC,@VarC+2 ; Add to ACC with carry high 32 bits of VarC
MOVL @VarD+0,P ; Store low 32-bit result into VarD
MOVL @VarD+2,ACC ; Store high 32-bit result into VarD

MOVL loc32,P :
این دستور محتوای رجیستر P را در ادرس اشاره شده ذخیره می کند.
MOVL XT,loc32 :
MOVL loc32,XT :
این دو دستور نیز مانند دستور قبل می باشند .

; Calculate using 32-bit multiply, retaining high result:
; Y = (X0*C0) >> 2) + (X1*C1 >> 2) + (X2*C2 >> 2)
; X2 = X1
; X1 = X0
SPM −2 ; Set product shift to >> 2
ZAPA ; Zero ACC, P, OVC
MOVL XT,@X2 ; XT = X2
QMPYL P,XT,@C2 ; P = XT*C2
MOVL XT,@X1 ; XT = X1, ACC = X2*C2 >> 2
QMPYAL P,XT,@C1 ; P = XT*C1
MOVL @X2,XT ; X2 = X1
MOVL XT,@X0 ; XT = X0, ACC = X1*C1 >> 2 + X2*C2 >> 2
QMPYAL P,XT,@C0 ; P = XT*C0
MOVL @X1,XT ; X1 = X0
ADDL ACC,P << PM ; ACC = X0*C0 >> 2 + X1*C1 >> 2 + X2*C2 >> 2
MOVL @Y,ACC ; Store result into Y

MOVP T,loc16 :
محتوای 16 بیتی ادرس داده شده در رجیستر T ذخیره می شود .همچنین محتوای رجیستر P پس از شیفت به داخل ACC بار می شود.

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

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

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

MOVX TL,loc16 :
این دستور16 بیت پایین رجیستر مضروب TL را با محتوای 16 بیتی ادرس داده شده پر می کند و 16 بیت بالای رجیستر XT را با بیت علامت TL پر می کند.

; Calculate and keep low 32-bit result: Y32 = M32*X16
MOVX TL,@X16 ; XT = S:X16
IMPYL P,XT,@M32 ; P = XT * M32 (low 32 bits of result)
MOVL @Y32,P ; Store result into Y32

خوب دستورات MOV تا اینجا کافیه این چندتا دستور MOV اخری یکم پیچیده ولی کاربردی بودن.در ادامه می خوام برم سراغ دستورات ضرب .موفق باشید.

[ali833]

پاسخ : اموزش DSP

سلام .بدون مقدمه می رم سراغ دستورات ضرب.

DMAC ACC:P,loc32,*XAR7 :
ت++DMAC ACC:P,loc32,*XAR7 :
ضرب و جمع 16 بیتی دوگانه.اولین عمل ضرب بین کلمه بالای مکان اشاره شده به وسیله loc32 و XAR7/++ و ضرب دوم بین کلمات پایین انها انجام می شود.

بعد از عمل ضرب ACC شامل نتیجه ضرب و جمع کلمه بالای عملوندهای ادرس دهی شده می باشد.همچنین رجیستر P نیز با نتیجه جمع و ضرب کلمه پایین عملوندها پر می شود.

XT =[loc32];
TEMP =Prog[*XAR7 or XAR7++];
ACC = ACC + (XT.MSW*TEMP.MSW) << PM;
P = P + (XT.LSW * TEMP.LSW ) << PM;

; Calculate sum of product using dual 16-bit multiply:
; int16 X[N] ; Data information
; int16 C[N] ; Coefficient information (located in low 4M)
; ; Data and Coeff must be aligned to even address
; ; N must be an even number
; sum = 0;
; for(i=0; i < N; i++)
; sum = sum + (X[i] * C[i]) >> 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/2)−1 ; Repeat next instruction N/2 times
||DMAC P,*XAR2++,*XAR7++ ; ACC = ACC + (X[i+1] * C[i+1]) >> 5
; P = P + (X[i] * C[i]) >> 5 i++
ADDL ACC,@P ; Perform final accumulate
MOVL @sum,ACC ; Store final result into sum

MAC P,loc16,0:pma :
این دستور:
1-مقدار عمل ضرب قبلی که به اندازهPM شیفت داده شده است را به ACC اضافه می کند.
2-رجیستر T را با محتوای ادرس اشاره شده به وسیله loc16 پر می کند.
3-سپس محتوای 16 بیتی علامت دار رجیستر T را در محتوای علامت دار ادرس برنامه اشاره شده ضرب می کند و نتیجه را در رجیستر P ذخیره می کند.

ACC = ACC +P <<PM;
T = [loc16];
P = signed T*signed prog[0x00:PMA];

; Calculate sum of product using 16-bit multiply:
; int16 X[N] ; Data information
; int16 C[N] ; Coefficient information, located in low 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
||MAC P,*XAR2++,0:C ; ACC = ACC + P >> 5,
; P = *XAR2++ * *C++
ADDL ACC,P << PM ; Perform final accumulate
MOVL @sum,ACC ; Store final result into sum

MAC P,loc16,*XAR7 :
MAC P,loc16,*XAR7++ :
این دستور نیز مانند دستور قبل می باشد با این تفاوت که فضای بیشتری از حافظه را می توان ادرس دهی کرد.

ACC = ACC + P << PM;
T = [loc16];
P = signed T * signed Prog[*XAR7 or *XAR7++];

; Calculate sum of product using 16-bit multiply:
; int16 X[N] ; Data information
; int16 C[N] ; Coefficient information (located in low 4M)
; sum = 0;
; for(i=0; i < N; i++)
; sum = sum + (X[i] * C[i]) >> 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
||MAC P,*XAR2++,*XAR7++ ; ACC = ACC + P >> 5,
; P = *XAR2++ * *XAR7++
ADDL ACC,P << PM ; Perform final accumulate
MOVL @sum,ACC ; Store final result into sum

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

P = signed T * signed [loc16];

MPY P,loc16,#16bit :
این دستور محتوای ادرس اشاره شده به وسیله loc16 را در مقدار ثابت علامت دار مشخص شده ضرب می کند و نتیجه را در رجیستر P می ریزد.

P = signed [loc16] * signed 16bit;

; ; Calculate using 16-bit multiply:
; Y = (X0*C0) >> 2) + (X1*C1 >> 2) + (X2*C2 >> 2),
; C0, C1 and C2 are constants
SPM −2 ; Set product shift to >> 2
MOVB ACC,#0 ; Zero ACC
MPY P,@X2,#C2 ; P = X2*C2
MPYA P,@X1,#C1 ; ACC = X2*C2>>2, P = X1*C1
MPYA P,@X0,#C0 ; ACC = X1*C1>>2 + X2*C2>>2, P = X0*C0
ADDL ACC,P << PM ; ACC = X0*C0>>2 + X1*C1>>2 + X2*C2>>2
MOVL @Y,ACC ; Store result into Y

MPY ACC,T,loc16:
MPY ACC,loc16,#16bit :
این دو دستور مانند دو دستور قبلی می باشند با این تفاوت که نتیجه در رجیستر ACC ذخیره می شود.

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

; Calculate signed using 16-bit multiply:
; Y32 = Y32 + X16 * 2000
MPY ACC,@X16,#2000 ; T = X16, ACC = X16 * 2000
ADDL @Y32,ACC ; Y32 = Y32 + ACC

MPYA P,loc16,#16bit ک
این دستور نتیجه ضرب قبلی موجود در رجیستر P را بعد از شیفت به رجیستر ACC اضافه می کند.سپس رجیستر T را با محتوای ادرس اشاره شده پر می کند و سپس رجیستر T را در مقدار ثابت داده شده ضرب می کند و نتیجه را در رجیستر P قرار می دهد. جالب بدونید که کل این عملیات تو 1 سیکل ماشین انجام می شود.اگه می خواستید این عملیا تو با میکرو انجام بدین حساب کنید چقدر زمان می گرفت. :surprised:

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

; Calculate using 16-bit multiply:
; Y = (X0*C0) >> 2) + (X1*C1 >> 2) + (X2*C2 >> 2),
; C0, C1 and C2 are constants
SPM −2 ; Set product shift to >> 2
MOVB ACC,#0 ; Zero ACC
MPY P,@X2,#C2 ; P = X2*C2
MPYA P,@X1,#C1 ; ACC = X2*C2>>2, P = X1*C1
MPYA P,@X0,#C0 ; ACC = X1*C1>>2 + X2*C2>>2, P = X0*C0
ADDL ACC,P << PM ; ACC = X0*C0>>2 + X1*C1>>2 + X2*C2>>2
MOVL @Y,ACC ; Store result into Y

MPYA P,T,loc16 :
این دستور نیز مانند قبلی می باشد فقط به جای مقدار ثابت از ادرس دهی و به جای عملوند اول از رجیستر T استفاده شده است.

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 P,T,#8bit :
این دستور محتوای 16 بیتی علامت دار رجیستر T را در مقدار ثابت بدون علامت 8 بیتی ضرب می کند و نتیجه را در رجیستر P قرار می دهد.

P = signed T * 0:8bit;

; Calculate: Y32 = X16 * 5;
MOV T,@X16 ; T = X16
MPYB P,T,#5 ; P = T * #5
MOVL @Y,P ; Store result into Y32

...TO BE CONTINUE