macro kullanımı ile ilgili bir soru

[camby]

Sayın Doğan İbrahim bir gecikme makrosu yazmış ki şu şekilde:

gecikms		MACRO		miktar
		movlw	HIGH  	miktar		;yüksek baytini oku
		movwf	ysayi			;ysayi da sakla
		movlw	LOW	miktar		;dusuk baytini oku
		movwf	dsayi			;dsayi da sakla
bekle1
.....
.....

macroyu da şu şekilde çağırmış:

......
gecikms		.5000
......

macro .5000 argümanı çağrılmışki burdan anladığım macroya giderken 8bitlik bir register'a mahkum değiliz , Macronun içindeki HIGH ve LOW ile .5000 diye gelen sayı üst ve alt baytlarına ayrılmış durumda , bu mplab'a özgü bir şey mi?
Çok makro kullanma taraftarı değilim ama bu şekilde de kullanımı çok pratikmiş , makroya CALL ile gitmenin yolu var mıdır?

[SpeedyX]

Derleyiciye özgü birşey.

16 bit çalışma ile ilgili bazı makrolar buldum:

; 16BITS.INC      16 bit functions
; This Version    01-FEB-02
;                nolist
; Written by      Chuck McManis (http://www.mcmanis.com/chuck)
; Copyright (c) 2001 Charles McManis, All Rights Reserved
;
; Change Log:
;       06-JAN-02       Created from the MATH16 file. Now
;                       it has a variety of operations.
;       30-DEC-01       Created this file
;
; NOTICE: THIS CODE COMES WITHOUT WARRANTY OF ANY KIND EITHER
;         EXPRESSED OR IMPLIED. USE THIS CODE AT YOUR OWN RISK!
;         I WILL NOT BE HELD RESPONSIBLE FOR ANY DAMAGES, DIRECT 
;         OR CONSEQUENTIAL THAT YOU MAY EXPERIENCE BY USING IT.
;
; * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
; 
; This include file provides some macros for dealing with
; 16 bit quantities. It assumes a little endian format
; where the least significant byte is lower in address than
; the most significant byte.
;
; * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

        
;
; These are the psuedo "registers" used by the 16 BIT operations
;        
_REG_A       EQU     H'007E'
_REG_B       EQU     H'007C'

;
; 16 bit move from SRC to DST
;
MOV16   MACRO   SRC, DST
        MOVF    SRC,W
        MOVWF   DST
        MOVF    SRC+1,W
        MOVWF   DST+1
        ENDM
;
; 16 bit unsigned compare, returns Z and C set appropriately
; Compares the registers "CMP_A" and "CMP_B"
; Flag states and what they mean:
;
;       Z true - X & Y are equal
;       C true - X > Y
;       C false - X < Y
;        
CMP16   MACRO   X, Y
        MOV16   X, _REG_A
        SUB16   _REG_A,Y
        MOVF    _REG_A,W
        IORWF   _REG_A+1,W
        ENDM

;
; Initialize a 16 bit value
;
INIT16  MACRO   VAR, CONST
        MOVLW   low (CONST)
        MOVWF   (VAR)
        MOVLW   high (CONST)
        MOVWF   (VAR)+1
        ENDM        

;
; Initialize a 16 bit value to zero
;
CLR16   MACRO   VAR
        CLRF    VAR
        CLRF    VAR+1
        ENDM
        
;
; Macro to do a logical shift right on a 16 bit value
; (0 is shifted into the MSB)
;
LSR16   MACRO   VAR16
        BCF     STATUS, C       ; Clear carry
        RRF     (VAR16)+1,F     ; Rotate high byte right
        RRF     (VAR16),F       ; Rotate low byte right
        ENDM
        
LSL16   MACRO   VAR16
        BCF     STATUS, C       ; Clear carry
        RLF     (VAR16),F       ; Rotate low byte left
        RLF     (VAR16)+1,F     ; Rotate upper byte left
        ENDM        
                
;
; 16 bit unsigned subtraction with carry out.
; Word format is little endian (LSB at lower address)
; Operation is DST = DST - SRC
;
; (This from the "tips and tricks" seminar handout)
;
; DST is replaced, SRC is preserved, Carry is set correctly
;
;
SUB16   MACRO   DST, SRC
        MOVF    (SRC),W         ; Get low byte of subtrahend
        SUBWF   (DST),F         ; Subtract DST(low) - SRC(low)
        MOVF    (SRC)+1,W       ; Now get high byte of subtrahend
        BTFSS   STATUS,C        ; If there was a borrow, rather than
        INCF    (SRC)+1,W       ; decrement high byte of dst we inc src
        SUBWF   (DST)+1,F       ; Subtract the high byte and we're done
        ENDM
        
SUBI16  MACRO   DST, SB
        MOVLW   LOW (SB)
        SUBWF   (DST), F
        MOVLW   HIGH (SB)
        BTFSS   STATUS, C
        MOVLW   (HIGH (SB))+1
        SUBWF   (DST)+1,F
        ENDM
                

;
; 16 bit unsigned addition with carry out.
; Operation: DST = DST + SRC                       
;
; DST is replaced, SRC is preserved, Carry is set correctly
;
ADD16   MACRO   DST,SRC 
        MOVF    (SRC),W         ; Get low byte
        ADDWF   (DST),F         ; Add to destination
        MOVF    (SRC)+1,W       ; Get high byte
        BTFSC   STATUS,C        ; Check for carry
        INCF    (SRC)+1,W       ; Add one for carry
        ADDWF   (DST)+1,F       ; Add high byte into DST
        ENDM

;
; 16 bit Add Immediate
; Operation: DST = DST + Constant
;
; DST is updated, carry is set correctly.
;
ADDI16  MACRO   DST,AD
        MOVLW   LOW (AD)
        ADDWF   DST,F
        MOVLW   HIGH (AD)
        BTFSC   STATUS,C
        MOVLW   (HIGH (AD)) + 1
        ADDWF   (DST)+1,F
        ENDM
;
; Negate 16 bit value
; Find two's complement value of a 16 bit number
;
NEG16   MACRO   DST
        COMF    (DST)
        COMF    (DST)+1
        INC16   DST
        ENDM
                
;
; Increment 16 bit value, sets Z on exit.
;
; Operation: DST++
;
INC16   MACRO   DST        
        INCFSZ  (DST),W         ; Add one to low byte
        DECF    (DST)+1,F       ; No carry (negates next step)
        INCF    (DST)+1,F       ; Add one to high byte
        MOVWF   (DST)           ; Store updated low byte back.
        IORWF   (DST)+1,W       ; Set Z flag
        ENDM

;
; Decrement 16 bit value, sets Z on exit
;        
; Operation: DST--
;
DEC16   MACRO   DST
        DECF    (DST),F         ; Decrement low byte
        INCFSZ  (DST),W         ; Check for underflow
        INCF    (DST)+1,F       ; Update
        DECF    (DST)+1,F       ; Fixup
        MOVF    (DST),W
        IORWF   (DST)+1,W       ; Set Z bit
        ENDM
        
        list                      

[camby]

Çok makro kullanma taraftarı değilim ama bu şekilde de (gecikms .5000 ) kullanımı çok pratikmiş , ayrıca makroya CALL ile gitmenin yolu var mıdır?

[SpeedyX]

Yoktur.

[F493]

Çok makro kullanma taraftarı değilim ama bu şekilde de (gecikms .5000 ) kullanımı çok pratikmiş , ayrıca makroya CALL ile gitmenin yolu var mıdır?

Selam,

  Neden makro kullanımı taraftarı değilsiniz.  Makrolar CALL ile çagırılmaz nedeni makrolar derleme zamanına ilişkindir. Siz makro ile ilgili ör/ gecikme 500 yazdıgınızda aslında arka planda yukarıdaki (makro) kod parcası sizin gecikme 500 yazdıgınız yere yazılır.  Bununda avantajı arka planda CALL  edilmemesidir. İşte makroları fonksiyonlardan ayıran olay budur, CALL edilmez. Buda Fonksiyona giriş/çıkış zamanlarının ortadan kaldırılması ve aynı zamanda derleyicinin daha mükemmel optimizasyon yapması için bir avantajdır. Şöyleki derleyiciler kodu yukarıdan aşagı derlerler. Sizin kodunuzu derleyici ilk CALL buldugu yere kadar optimize eder. Şimdi oraya kadar optimizasyon yapıldı sonra CALL ile gittiği yer için ayrı bir optimizasyon yapar. Buda verimi  diğerine göre daha aza düşürür. İşte eger bazı  fonksiyonları makro olarak yazarsak orada aslında CALL ifadesi yerine makronun açılımı olacagı için derleyiciler tek parca halkinde daha iyi bir optimizasyonla daha verimli kod üretirler.

Esen kalın.

[camby]

Buda Fonksiyona giriş/çıkış zamanlarının ortadan kaldırılması ve aynı zamanda derleyicinin daha mükemmel optimizasyon yapması için bir avantajdır. Şöyleki derleyiciler kodu yukarıdan aşagı derlerler. Sizin kodunuzu derleyici ilk CALL buldugu yere kadar optimize eder. Şimdi oraya kadar optimizasyon yapıldı sonra CALL ile gittiği yer için ayrı bir optimizasyon yapar. Buda verimi  diğerine göre daha aza düşürür.

Cevabınız için çok teşekkür ederim , fakat optimize etmek derken ne kastettiniz anlayamadım.

Mesela bnm programımda bir alt yordama 5 kez gidilmesi lazım bunu call ile yaptığım zaman programım toplamda 100 satır yer kaplıyor , macro ile yaptığımda aynı kod her seferinde oraya kopyalanıyor ve program 200 satır yer kaplıyor.
işleme süresinde hiçbir değişiklik olmuyor fakat daha fazla kaplıyor. Benim anladığım bu.

[hasangurlek]

Buda Fonksiyona giriş/çıkış zamanlarının ortadan kaldırılması ve aynı zamanda derleyicinin daha mükemmel optimizasyon yapması için bir avantajdır. Şöyleki derleyiciler kodu yukarıdan aşagı derlerler. Sizin kodunuzu derleyici ilk CALL buldugu yere kadar optimize eder. Şimdi oraya kadar optimizasyon yapıldı sonra CALL ile gittiği yer için ayrı bir optimizasyon yapar. Buda verimi  diğerine göre daha aza düşürür.

Cevabınız için çok teşekkür ederim , fakat optimize etmek derken ne kastettiniz anlayamadım.

Mesela bnm programımda bir alt yordama 5 kez gidilmesi lazım bunu call ile yaptığım zaman programım toplamda 100 satır yer kaplıyor , macro ile yaptığımda aynı kod her seferinde oraya kopyalanıyor ve program 200 satır yer kaplıyor.
işleme süresinde hiçbir değişiklik olmuyor fakat daha fazla kaplıyor. Benim anladığım bu.

gecikms      MACRO      miktar
      movlw   HIGH     miktar      ;yüksek baytini oku
      movwf   ysayi         ;ysayi da sakla
      movlw   LOW   miktar      ;dusuk baytini oku
      movwf   dsayi         ;dsayi da sakla
bekle1

yerine

gecikms      MACRO      miktar 
      movlw   HIGH     miktar      ;yüksek baytini oku
      movwf   ysayi         ;ysayi da sakla
      movlw   LOW   miktar      ;dusuk baytini oku
      movwf   dsayi         ;dsayi da sakla
Call bekle1

şeklinde kullanırsanız sebepsiz yere kod tekrarı yapmadan kaynak tüketimini azaltabilirsiniz. Stack yönetimi dışında kod çalışması açısından hiç bir şey değişmez. İnternette TDD (Test Driven Development,Test First Development veya Test Driven Design) diye arama yaparsanız her ne kadar PC yazılımı geliştirmek için anlatılsada kod geliştirme hakkında çok daha pratik fikirler edinebilir, kod yazmaya başlamadan önce olası ihtiyaçları değerlendirip ileride yaşayacağınız muhtemel problemlerin önüne basit düzeltmeler, ilaveler yaparak geçebilirsiniz. Ayrıca Low, high dışında birde UPPER vardır, 3 bayt aynı şekilde kullanılabilir.

[CLR]

Merhaba,

Macro, asm ile program yazarken inanılmaz kolaylıklar sağlar. Aşağıda asm kullanırken benim yazdığım bir macroyu paylaştım. 2*16 lcd'ye istenilen satırdan ve karakter adresinden itibaren string(yazı) yazma örneği var. Macro sayesinde asm, C'ye yaklaştırılır.

1. satır, 1 karakterden itibaren satir1 table'ının içeriği lcd'ye yazdırılır.
LCD_YAZI    satir1,1,1          ; 1. satır, 1 karakterden itibaren

Programın tamamı için ,

http://www.uicroarm.com/3-wire-lcd-ve-macro-kullanimi#more-73

YAZ_BAKALIM:
      LCD_YAZI    satir1,1,1          ; 1. satır, 1 karakterden itibaren
      LCD_YAZI    satir2,2,2          ; 2. satır, 2 karakterden itibaren
      RETURN

;*******************************
satir1:
ADDWF   PCL,F
DT          "MACRO KULLANIMI",0

;******************************* 
satir2:
ADDWF   PCL,F
DT          "ve 3 WIRE LCD",0

;*******************************
; LCD karekter adresleri için macro :
; LCD_ADRES 1,1  için                       ; 1 .satır 1.adrese gider
; LCD_ADRES 1,3  için                       ; 1 .satır 3.adrese gider
; LCD_ADRES 2,1  için                       ; 2 .satır 1.adrese gider

LCD_ADRES MACRO SATIR,ADRES     ;
IF  SATIR==1
MOVLW   7FH           ; 7F+1=80H 1. satır adres başlangıcı
ELSE
MOVLW   0BFH         ; 0BF+1=0C0H 2. satır adres başlangıcı
ENDIF
ADDLW   ADRES      ; 80H  veya 0C0H ile ADRES değerini toplar
CALL    LCD_KOMUT_YAZ
ENDM

;*******************************
; YAZI : Ekrana yazdılacak yazı etiketi
; SATIR : LCD'nin satırı (1 veya 2)
; ADRES : LCD'nin adresi ( 1......16 ya kadar)
LCD_YAZI    MACRO   YAZI,SATIR,ADRES    ;
LCD_ADRES   SATIR,ADRES             ; LCD'de ilgili satıra gitmesini sağlar
LCD_STRING YAZI
ENDM
;******************************* 
LCD_STRING MACRO    STRING
CLRF    TABLE_REG
MOVF    TABLE_REG,W
CALL    STRING
CALL    LCD_STR                 ; bu altprogram,
BTFSS   ZERO_FLAG            ; table'dan 0 geldiyse çık
GOTO    $-4                        ; Call ile table'dan karekter alır.
ENDM

;*******************************
;LCD_STRING macrosunda kullanılır, tüm table'lar için geçerlidir
LCD_STR:
IORLW       0                       ; 0 gelirse gönderme bitmiştir
BTFSC       ZERO_FLAG        ; Table'dan W=0 gelirse geri dön
GOTO        $+3                    ; Yazma işlemi bitmiştir , zero_flag=1'dir
CALL        LCD_DATA_YAZ
INCF        TABLE_REG,F
RETURN

[F493]

Buda Fonksiyona giriş/çıkış zamanlarının ortadan kaldırılması ve aynı zamanda derleyicinin daha mükemmel optimizasyon yapması için bir avantajdır. Şöyleki derleyiciler kodu yukarıdan aşagı derlerler. Sizin kodunuzu derleyici ilk CALL buldugu yere kadar optimize eder. Şimdi oraya kadar optimizasyon yapıldı sonra CALL ile gittiği yer için ayrı bir optimizasyon yapar. Buda verimi  diğerine göre daha aza düşürür.

Cevabınız için çok teşekkür ederim , fakat optimize etmek derken ne kastettiniz anlayamadım.

Mesela bnm programımda bir alt yordama 5 kez gidilmesi lazım bunu call ile yaptığım zaman programım toplamda 100 satır yer kaplıyor , macro ile yaptığımda aynı kod her seferinde oraya kopyalanıyor ve program 200 satır yer kaplıyor.
işleme süresinde hiçbir değişiklik olmuyor fakat daha fazla kaplıyor. Benim anladığım bu.

Selam,

 2 secenek var. Sizin için hız, verim, performans (Yeterli bellek varsa) önemli ise Makroları kullanmalıyız. Yok eger benim bellek sıkıntım var ozaman verim, hız, performanstan vazgeçmemiz gerekir.

Esen kalın..

[camby]

tamam program belleğinde sıkıntımız yok o yüzden macroları kullanıp programlamada kolaylık yapabiliriz , yani bizim daha kolay programlama yapmamızı sağlar , kodu bir bütün halinde daha rahat görürüz falan filan

ama hız verim ve performans açısından macroların bir artısı yok diyorum ben sadece , aynı macroya ana .asm kodun içine yerleştirip call ile de gidilebilir ve hiçbirşey değişmez gibi ( CALL ve return 2şer cycle ) .
Hani derseniz macro ile komutların işleme süresi azalıyor fln , anlarım.

@hasangurler
hocam upper ne işe yarıyor , bunlar matlab help de var mı?

[F493]

Selam,
   Üstad burada kusura bakma ama sence artısı yok diye bir durum yok. Sen kendine göre yorumlayamazsın bu işi. Bu işin kuralı bu. Ben C dilini kullanıyorum ama diger dillerinde fark ettiğini sanmıyorum. Size interface de CALL vb. şekilde gösteriyor olabilir. Ama işin arka planı standarttır.  Kaldıki bir makronun farklı bir proje dosyasında olması durumunda CALL edilmesi anlamına gelmez. Siz yine makroyu yazarsınız derleyici bulur yerine koyar. Bu konuda verim vb.. sonuçlarla ilgili derleyicilerin optimizasyon olaylarını inceleyin. Bu işin kriterleri var. Ancak siz CALL yazıp bişiler yaparsınız ama kullanılan her yöntem dogru anlamına gelmiyor. Amacım sizi rencide etmek değil. Kendinizi koşullamanızı ortadan kaldırmak. Benim bildiğim bu sizede yardımcı olup sorularınıza cevap vermeye çalıştım.

Esen kalın.

[camby]

teşekkür ederim , ne alınması ne güzel tartışıyoruz konuyu.
Kendimi koşullandırmıştım ama artık macroya gereken önemi verecem fakat benim karşı çıktığım nokta şu :

Call değil de macro ile yaparsan daha hızlı çalışır daha verimli olur deniyor..

ne hızı ne verimi , neyden verim? neyin hızı?

Kaynak tüketimi diyorsanız Call ile oluşturulan programlarda daha az program hafızası kullanıldığından , kaynak tüketimi göz önüne alındığında verim daha yüksek olur .

Hız artar deniyor , 1 komut 1 cycle sürede işlenir , bazı komutlar 2 cycle da , bazı 1 cycle lık komutlarda duruma göre 2 cycle da işlenir .

Bu kabullere  göre Call ile hazırlanan örnek bir programda programın ilk satırdan son satıra ulaşması 4000 cycle , aynı call altyordamları macro haline getirilerek yapılan programda ise yine 4000 cycle. Aynı süre aynı hız.

Fakat macro ile programlama yapmak programcı için daha pratik.....

Programcı bir iş için daha az vakit harcıyor daha hızlı programlama yapıyor derseniz eğer zaten farklı verimleri tartışıyoruz demektir.

Pic'in işleyişinde hız , verim , optimizasyon açısından bence Call yada macro hiç bir değişiklik yok.

Varsa eğer şundan şundan dolayı picin hızı artıyor verimi artıyor diye belirtirseniz çok sevinirim.

[Tagli]

Makro kullanmayan biri olarak bu başlığa cevap yazmam ne kadar doğru bilmiyorum ama yine de kendi bildiğim kadarıyla durumu bir özetlemek istedim:

Öncelikle sorunu inceleyelim. Ortada PIC'in programın farklı yerlerinde birden fazla sayıda gerçekleştirmesi gereken bir işlem var. Buna genel ifadeyle alt program diyebiliriz. Bu alt program pek çok assembly komutundan oluşuyor, ve her kullanımı için tekrar yazmak programcı için zahmetli oluyor (Burada kopyala - yapıştır'ı bir seçenek olarak görmüyoruz). Ayrıca olaya bir diğer açıdan bakarsak her seferinde bu kodu yazmak hafıza kullanımı açısından da sorun yaratabiliyor.

İki çözüm yöntemini ayrı ayrı inceleyelim:

CALL Kullanmak: Derleyiciden (daha doğrusu assembler'dan) bağımsız bir çözüm. Kod sadece bir kez yazılıyor, yani hafızada tekrar tekrar yer işgal etmiyor. Ancak C'den (veya diğer yüksek seviyeli dillerden) alıştığımız argüman aktarımı konusunda sıkıntılarımız var. Bu mümkün elbette ama gözümüzün alıştığı tek satırda fonksiyonun ifade edilmesi ve buna bağlı olarak okunaklılığı arttırmak ve yine bunun doğal bir sonucu olan kolay bakım - onarım mümkün değil. Yığında yer işgal ediyor olmamız donanımsal yığını küçük işlemciler için sorun olabilir (çoğumuzun uğraştığı 10, 12 ve 16 serisi PIC'lerde 8 olması), özellikle de bu tür fonksiyonlardan birden çok sayıda varsa ve iç içe kullanılıyorlarsa. Ayrıca CALL kullanımının sebep olduğu atlamalar ufak bir zaman kaybına da neden olacaktır.

Macro Kullanmak: Bu yöntem ise tamamen assembler'ın desteği ile ilgili, yani kullanılan işlemci ile ilgisi yok. Derleme anında macro çağırma satırı, ilgili argümanlar da göz önünde bulundurularak assembly komutlarına dönüştürülüyor. Yazması, okuması, argümanları kullanması kolay. Yığında yer işgal etmiyor, atlama sebepli zaman kaybı yok. Peki ne kaybediyoruz? Program hafızasını. Çünkü assembler macro çağrısını görünce bu satır yerine daha önce tanımladığımız macro kodlarını yerleştiriyor. 100 satırlık bir macroyu 10 yerde kullanırsanız 1000 satır işgal ediyor işlemcinin hafızasında. Bu durumda macroların daha çok küçük kodlar için kullanılması daha doğru gibi görünüyor. MPLAB'ın desteklediği "banksel" ve "pageselw" gibi ifadeler (directive) bir çeşit macro gibi adeta, ki bunları ben de kullanıyorum. Sadece 2 komut yerine geçiyorlar ama argüman vermedeki kolaylık programcının işini ciddi şekilde kolaylaştırıyor.

İkisini Birlikte Kullanmak: Muhtemelen iki yöntemin de güçlü yönlerinden yararlanmak mümkün olabilir. Macro sadece argümanların rahat geçirilmesi için kullanılıp büyük kod parçasına macro içinden call ile ulaşılırsa hem hafıza tasarrufu sağlanır, hem de kodun yazılması ve okunması kolaylaşır. Elbette bu yöntem yığın sorununa bir çözüm getirmiyor.

[hasangurlek]

İyi bir programcı tek bir satır dahi olsa aynı kodu tekrar yazmaz ve derlenme aşamasındada tekrarlamalara izin vermez. Arkadaşımızın yukarıda yazdığı gibi makroları bilinçsiz kullanmak aşırı kaynak tüketimine sebep olur. Her makro direktifi makro içine yazılan kodun derleme öncesinde satırın bulunduğu yere kopyalanmasını sağlar. Yani assembler bizim yerimize kopyala+yapıştır yapar.

Olayı kısaca özetlemek gerekirse "Macro içinde parametreler ayarlandıktan sonra alt rutin çağrılır." Kod yazan kişi tek satırda parametreleri geçirir geri kalan işi derleyici halleder. Parametrelerin ayarlanması dışında aynı kod tekrar tekrar derlenmez. Aynı iş değişkenlere değerleri atanıp veya bellekteki adreslerine yazılıp alt rutini çağırmaklada yapılır ama değişkenlere değer atanması için her seferinde benzer kodların yazılması gerekir, makrolar bizi bu hammallıktan kurtarır.

Stack yığını problemi varsa zaten bir şeyler ters demektir. 8 kb kapasiteye sahip bir işlemcide 8 dönüş adresinin yeterli olmaması gibi bir sorun olamaz. Bu sorun varsa kod geliştirici bir yerlerde mantık hatası yapıyor, pc yazılımı geliştiriyor gibi rahat hareket ediyordur. Yada kullandığı derleyicinin stack yönetimi iyi değildir.

camby, UPPER kullanımı matlabda varmı bilmiyorum ama MPLAB assembler destekliyor. MPLAB help-> Topics -> MPASM Assembler -> Relocatable Objects -> "Low, High and Upper Operators" altında anlatılıyor.

[camby]

@hasangurlek
Önceki mesajınızda gösterdiğiniz mantık ile , MAKRO'da parametreleri belirledikten sonra kalan işlemleri CALL ile yaptım.

Hedeflediğim kadar alanı  kopyala-yapıştırdan kurtararak boşalttım. 8k Word'lük pic için bu kadarlık bir yer kazanmak ( ki çalışması etkilenmediği halde) az olsa da , bu şekilde fazladan yer kaplıyor olması nedense rahatsız ediyordu beni : ) , bu konuda takıntılı hale geldim sanırım..

Ayrıca MAKRO içinde  parametre ayarlamaları yapıldıktan sonra CALL ile gidilen alt-rutinler de makro tekrarlandıkça program hafızasına tekrar kopyalanıyor.

Bu yüzden

gecikms      MACRO      miktar
      movlw   HIGH     miktar      ;yüksek baytini oku
      movwf   ysayi         ;ysayi da sakla
      movlw   LOW   miktar      ;dusuk baytini oku
      movwf   dsayi         ;dsayi da sakla
    ENDM

dedikten sonra makroyu hemen kapatıp , alttaki gecikme döngülerini makro dışına aldım.

Sonuç, makro sadece HIGH,LOW,UPPER özelliğini kullanarak parametre ayarlamaya yaradı.