↑ ↓

ASM hazır kütüphane çalışmaları

Başlatan alikeskinkilic, 27 Ocak 2023, 00:44:06

Yazdır
Aşağı git Sayfa 1 2 3
Kullanıcı Eylemleri

alikeskinkilic

#30
18 Şubat 2023, 10:43:57 Son düzenlenme: 18 Şubat 2023, 14:32:14 alikeskinkilic 
;////////////////////////////////FOR-NEXT DÖNGÜSÜ///////////////////////////////
;KULLANIMI            
;            FOR 0,255        ; 256 TAKRAR YAPARAK FOR NEXT ARASINDAKİ KODU ÇALIŞTIRIR
;            KODLAR
;            ......
;            NEXT
;*******************************************************************************
FOR    MACRO    R0,R2
;        BCF      INTCON ,7      ; KESMELER KAPATILMAK İSTENİRSE YORUMU KALDIRABİLİRSİNİZ
        MOVLW    R2    
        MOVWF    R4
        MOVLW    R0    
        SUBWF    R4    ,F
FOR1:
        ENDM
        
NEXT    MACRO    
        DECFSZ    R4    ,F
        GOTO        FOR1
;      BSF      INTCON ,7  ;kesmeler çevrim boyunca kapatıldıysa çıkışta açılabilir
        ENDM    
;///////////////////////////////////////////////////////////////////////////////
;******************************************************************************
8 bit derinliğinde for next döngüsü için makro. kullanımı pic basic ile benzer.
Hep meraktan

alikeskinkilic

#31
24 Şubat 2023, 21:42:10 Son düzenlenme: 24 Şubat 2023, 23:16:07 alikeskinkilic
Map fonksiyonu için makro bildiğimiz arduino map fonksiyonu ile aynı çalışıyor hayırlı olsun :)
ufak bir hata yapmışım düzeltip tekrar yayınlarım
Hep meraktan

alikeskinkilic

#32
27 Şubat 2023, 15:18:36 Son düzenlenme: 27 Şubat 2023, 15:20:56 alikeskinkilic
MAP Fonksiyonunu düzelttim bölme makrosunun değişmesi gerekiyordu önceden 32 bit bölemiyordu şu an işaretli 32 bit bölme yapabiliyor.
MAP    MACRO    R0,R0+1,VAR,VAR1,VAR2,VAR3,ADDRESS
 ;{
;return ((value - fS) * (tE - tS)) / ((fE - fS) + tS);
;map(value,fS, fE, tS,tE)
;map(512, 0, 1023,0, 2000)            ((512-0)*(2000-0)/(1023-0)+0)
    BANKSEL ADDRESS
    movlw     ADDRESS ;
    movwf     FSR                    ;fsr ye adresi yükler
    movlw     VAR & H'FF'            ;;en değersiz byte filtrelenip yazılır
    movwf     INDF                ;fsr nin işaretlediği adrese değeri yazar
    movlw     VAR >>8 & H'FF'        ;; Var 8 bit kaydırılır filtrelenip fsr 1 arttırılır(bir sonraki ram bölgesi yazılır)
    incf     FSR        ,F
    movwf     INDF

    MOVLW    VAR1 &0XFF
    INCF        FSR        ,F
    MOVWF    INDF
    MOVLW    VAR1>>8 & 0XFF
    INCF        FSR        ,F
    MOVWF    INDF
    
    MOVLW    VAR2 & 0XFF
    INCF        FSR        ,F
    MOVWF    INDF
    MOVLW    VAR2 >> 8 &0XFF
    INCF        FSR        ,F
    MOVWF    INDF

    MOVLW    VAR3 & 0XFF
    INCF        FSR        ,F
    MOVWF    INDF
    MOVLW    VAR3 >> 8 &0XFF
    INCF        FSR        ,F
    MOVWF    INDF
;*******************************************************************FONKSİYONLAR**************************    
    MOVF        R1        ,W
    SUBWF    R0        ,F
    BTFSS    STATUS    ,C
    INCF        R1+1        ,F    ;VALUE-FS
    MOVF        R1+1        ,W    ;SONUC    R0 
    SUBWF    R0+1        ,F
;///////////////////////////////
    MOVF        R3        ,W
    SUBWF    R4        ,W
    MOVWF    R5
    BTFSS    STATUS    ,C
    INCF        R3+1        ,F    ;TE-TS
    MOVF        R3+1        ,W    ;SONUC    R5 
    SUBWF    R4+1        ,W
    MOVWF    R5+1
;********************************
    MULL32    R5,R5+1,R0,R0+1            ;((value - fS) * (tE - tS))   ;SONUC= XSL-XSH    32BİT
    
    MOVF        R1        ,W                ;    60   62 64  66  68            ADRESLER
    SUBWF    R2        ,W
    MOVWF    R5                        ;         R0   R1 R2  R3   R4            DEĞİŞKENLER
    BTFSS    STATUS    ,C                ;    MAP    SAYI,0,1023,800,2200,R1        HARİTA
    INCF        R1+1        ,F                ;    (1023-0)+800                    İŞLEM
    MOVF        R1+1        ,W                ;    map(value,fS, fE, tS,tE)
    SUBWF    R2+1        ,W
    MOVWF    R5+1                        ;  R2 - R1 + R3
                                    ;((fE - fS) + tS);
    CLRF        R6                                ;SONUÇ = R2
    CLRF        R6+1
    BOL    XSL,XSL+1,XSH,XSH+1,R5,R5+1,R6,R6+1
    MOVF        R3        ,W
    ADDWF    XSL        ,F
    MOVF        R3+1        ,W
    BTFSC    STATUS    ,C
    INCF        XSL+1        ,F
    ADDWF    XSL+1        ,F
    BTFSC    STATUS    ,C
    INCFSZ    XSH
    GOTO    $+2
    INCF        XSH+1
    MOVF        XSL        ,W
    MOVWF    MAP_SNC
    MOVF        XSL+1    ,W
    MOVWF    MAP_SNC+1    
    MOVF        XSH    ,W
    MOVWF    MAP_SNC+2    
    MOVF        XSH    ,W
    MOVWF    MAP_SNC+3        
    ENDM     
fonksiyon içinde kullanılan makrolar güncellendi aşağıdadır
MULL32  MACRO   X1,X1+1,X2,X2+1

        
 
MUL3:       
     
        MOVLW       .16              ; For 16 shifts
            MOVWF       XX
           CLRF       XSH + 1
            CLRF        XSH
mulloop: 
        BCF        STATUS, C
        RRF         X1 + 1, F
           RRF         X1, F
            BTFSS       STATUS, C        ;
            GOTO        mull1               ; Skip add
            MOVF        X2, W           ; 16-bit add with carry out
            ADDWF       XSH, F
            MOVF        X2 + 1, W
            BTFSC       STATUS, C
            INCFSZ      X2 + 1, W
            ADDWF       XSH + 1, F
mull1: 
        RRF        XSH + 1, F
           RRF         XSH    ,F
            RRF         XSL + 1,F
            RRF         XSL    ,F  
            DECFSZ      XX    ,F
            GOTO        mulloop
DONE:   
          CLRF        X1
          CLRF        X1+1
          CLRF        X2
          CLRF        X2+1
 
          ENDM

               
;****************************************************************
;* DIV        : 16 x 16 (31 x 15) divide                        *
;*                                                              *
;* Input      : R0 / R1                                         *
;* Output     : R0, R0+1  =     bolüm                           * 
;*                : R2 = remainder            kalan                     *
;*                                                              *
;* Notes      : R2 = R0 MOD R1                                  *
;****************************************************************
;        ----BÖLÜNEN---     ----BÖLEN----
;*** 32 BIT SIGNED DIVIDE ***
;REGA / REGB -> REGA
;Remainder in REGC
;Return carry set if overflow or division by zero
;*** 32 BIT SIGNED DIVIDE ***
;REGA / REGB -> REGA
;Remainder in REGC
;Return carry set if overflow or division by zero
BOL    MACRO    D0,D1,D2,D3,B0,B1,B2,B3
divide:
    clrf        DD1        ;Reset sign flag
    call    absa        ;Make dividend (REGA) positive
    skpc
    call    absb        ;Make divisor (REGB) positive
    skpnc
    return                ;Overflow
    clrf        DR0        ;Clear remainder
    clrf        DR1
    clrf        DR2
    clrf        DR3
    movlw    D'32'        ;Loop counter
    movwf    DD
    ;call    slac                ;Purge sign bit

dvloop:
    call    slac        ;Shift dividend (REGA) msb into remainder (REGC)
    movf        B3,w        ;Test if remainder (REGC) >= divisor (REGB)
    subwf    DR3,w
    skpz
    goto    dtstgt
    movf        B2,w
    subwf    DR2,w
    skpz
    goto    dtstgt
    movf        B1,w
    subwf    DR1,w
    skpz
    goto    dtstgt
    movf        B0,w
    subwf    DR0,w
dtstgt:    
    skpc            ;Carry set if remainder >= divisor
    goto    dremlt
    movf        B0,w        ;Subtract divisor (REGB) from remainder (REGC)
    subwf    DR0,f
    movf        B1,w
    skpc
    incfsz    B1,w
    subwf    DR1,f
    movf        B2,w
    skpc
    incfsz    B2,w
    subwf    DR2,f
    movf        B3,w
    skpc
    incfsz    B3,w
    subwf    DR3,f
    clrc
    bsf        D0,0        ;Set quotient bit

dremlt:
    decfsz    DD,f    ;Next
    goto    dvloop
    btfsc    DD1,0        ;Check result sign
    call    negatea        ;Negative
    GOTO    DIVCIK
;/////////////////////////////////////////////////////////////////    
absa:
    rlf        D3,w
    skpc
    return            ;Positive
negatea:
    movf        D3,w        ;Save sign in w
    andlw    0x80

    comf        D0,f        ;2's complement
    comf        D1,f
    comf        D2,f
    comf        D3,f
    incfsz    D0,f
    goto    nega1
    incfsz    D1,f
    goto    nega1
    incfsz    D2,f
    goto    nega1
    incf        D3,f
nega1:
    incf        DD1,f        ;flip sign flag
    addwf    D3,w        ;Return carry set if -2147483648
    return
;/////////////////////////////////////////////////////////////////
absb:
    rlf        B3,w
    skpc
    return                ;Positive
negateb:
    movf        B3,w        ;Save sign in w
    andlw    0x80
    comf        B0,f        ;2's complement
    comf        B1,f
    comf        B2,f
    comf        B3,f
    incfsz    B0,f
    goto    negb1
    incfsz    B1,f
    goto    negb1
    incfsz    B2,f
    goto    negb1
    incf        B3,f
negb1
    incf        DD1,f        ;flip sign flag
    addwf    B3,w        ;Return carry set if -2147483648
    return
;///////////////////////////////////////////////////////////
slac:
    rlf        D0,f
    rlf        D1,f
    rlf        D2,f
    rlf        D3,f
slc:
    rlf        DR0,f
    rlf        DR1,f
    rlf        DR2,f
    rlf        DR3,f
    return
DIVCIK:
    ENDM
buda örnek kod
    __CONFIG    0x0024
    LIST P = PIC16F690
    INCLUDE "p16f690.inc"
   list r=dec 
    INCLUDE "KTPNE.INC"

    #define _C STATUS,0
    #define _Z STATUS,2
    #DEFINE    OSC_8
  ; #DEFINE PWM 0X60
 ;    #DEFINE    KP
;udata    

    CBLOCK 0X20
SAYI    :2    
KERE    :2
MAP_SNC:4    
    ENDC
R0        EQU        0X60
R1        EQU        0X62
R2        EQU        0X64 
R3        EQU        0X66
R4        EQU        0X68 
R5        EQU        0X6A 
R6        EQU        0X6C
R7        EQU        0X6E    
;BÖLME DEĞİŞLENKERLİ
    CBLOCK    0X50
D0    
D1    
D2    
D3
B0
B1
B2
B3
DR0
DR1    
DR2    
DR3            ;0X5B
DD
DD1            ;0X5D
    ENDC
;ÇARPMA DEĞİŞKENLERİ
    CBLOCK    0X70
X1    :2
X2    :2        
XSL    :2
XSH    :2
XX
    ENDC

       ORG        0X00
        GOTO        AYAR
        ORG            0X04

        
AYAR:
    BANKSEL    TRISA
        MOVLW         0x00
        MOVWF       TRISA
        MOVLW        0xFF
       MOVWF        TRISC
        MOVLW        0x00
        MOVWF        TRISB
        MOVLW        0x82
        MOVWF        OPTION_REG
        MOVLW        0x70
        MOVWF        OSCCON
        BCF            STATUS,    RP0                        ;BANK0
        MOVLW        0x00
        MOVWF        ADCON0
        MOVLW        0x00
        MOVWF        PORTA
        MOVWF        PORTB
        MOVWF        PORTC
        BSF            STATUS,RP1                        ;BANK2
        MOVLW        0x00
        MOVWF        ANSEL
        MOVLW        0x00
        MOVWF        ANSELH
        BCF            CM1CON0,7
        BCF            CM2CON0,7
        CLRF        WPUB
        BSF        IOCB    ,7
        BANKSEL    PSTRCON
        CLRF        PSTRCON
        BCF            STATUS,RP1
        BCF            STATUS,RP0                        ;BANK0
     MOVLW    0X00
     MOVWF    INTCON
    
     CLRF        PORTA
     CLRF        PORTB
     CLRF        PORTC

BASLA:
    PAKET16    512,SAYI
    MAP    SAYI,,0,1023,0,2000,R1
    GOTO BASLA
    END
işlem sonucunu MAP_SNC değişkenine 32 bit şeklinde yazar
Hep meraktan

alikeskinkilic

#33
02 Mart 2023, 14:20:45 Son düzenlenme: 02 Mart 2023, 14:21:50 alikeskinkilic
bölme makrosunu değiştirdim artık 32 bitin tamamını her seferde kaydır çıkar yapmak zorunda değil en üst bitte 1 bulana kadar sadece kaydırarak sayının büyüklüğüne göre küçük sayılarda iki kat hızlandı neredeyse.makro adı ve kullanımını da değiştirdim daha bir kullanıcı dostu oldu hayırlı olsun
DIV32        MACRO     ;? == A,A+1,A+2,A+3
                         ;?0== B,B+1,B+2,B+3

divide:
    clrf        DD1        ;Reset sign flag
    call    absa        ;Make dividend (REGA) positive
    skpc
    call    absb        ;Make divisor (REGB) positive
    skpnc
    return                ;Overflow
    movlw    D'33'        ;Loop counter
    movwf    DD
BASAMAK:
    CALL    TEST
    SKPC    
    GOTO BASAMAK
    CALL    GERIAL    
    
    clrf        DR0        ;Clear remainder
    clrf        DR1
    clrf        DR2
    clrf        DR3
;    movlw    D'32'        ;Loop counter
;    movwf    DD
    ;call    slac                ;Purge sign bit

dvloop:
    call        slac        ;Shift dividend (REGA) msb into remainder (REGC)
    movf        ?0+3,w        ;Test if remainder (REGC) >= divisor (REGB)
    subwf        DR3,w
    skpz
    goto        dtstgt
    movf        ?0+2,w
    subwf        DR2,w
    skpz
    goto        dtstgt
    movf        ?0+1,w
    subwf        DR1,w
    skpz
    goto        dtstgt
    movf        ?0,w
    subwf        DR0,w
dtstgt:    
    skpc            ;Carry set if remainder >= divisor
    goto        dremlt
    movf        ?0,w        ;Subtract divisor (REGB) from remainder (REGC)
    subwf        DR0,f
    movf        ?0+1,w
    skpc
    incfsz        ?0+1,w
    subwf        DR1,f
    movf        ?0+2,w
    skpc
    incfsz        ?0+2,w
    subwf        DR2,f
    movf        ?0+3,w
    skpc
    incfsz        ?0+3,w
    subwf        DR3,f
    clrc
    bsf            ? , 0        ;Set quotient bit

dremlt:
    decfsz        DD,f    ;Next
    goto        dvloop
    btfsc        DD1,0        ;Check result sign
    call        negatea        ;Negative
    GOTO        DIVCIK
;/////////////////////////////////////////////////////////////////    
absa:
    rlf            ?+3,w
    skpc
    return            ;Positive
negatea:
    movf        ?+3,w        ;Save sign in w
    andlw    0x80

    comf        ?        ,f        ;2's complement
    comf        ?+1        ,f
    comf        ?+2        ,f
    comf        ?+3,f
    incfsz        ?    ,f
    goto        nega1
    incfsz        ?+1,f
    goto        nega1
    incfsz        ?+2,f
    goto        nega1
    incf        ?+3,f
nega1:
    incf        DD1,f        ;flip sign flag
    addwf        ?+3    ,w        ;Return carry set if -2147483648
    return
;/////////////////////////////////////////////////////////////////
absb:
    rlf        ?0+3,w
    skpc
    return                ;Positive
negateb:
    movf        ?0+3,w        ;Save sign in w
    andlw    0x80
    comf        ?0    ,f        ;2's complement
    comf        ?0+1,f
    comf        ?0+2,f
    comf        ?0+3,f
    incfsz        ?0,f
    goto    negb1
    incfsz        ?0+1,f
    goto    negb1
    incfsz        ?0+2,f
    goto    negb1
    incf        ?0+3,f
negb1
    incf        DD1,f        ;flip sign flag
    addwf        ?0+3,w        ;Return carry set if -2147483648
    return
;///////////////////////////////////////////////////////////
slac:
    rlf        ?,f
    rlf        ?+1,f
    rlf        ?+2,f
    rlf        ?+3,f
slc:
    rlf        DR0,f
    rlf        DR1,f
    rlf        DR2,f
    rlf        DR3,f
    return
TEST:
    DECF    DD    ,F
    rlf        ?,f
    rlf        ?+1,f
    rlf        ?+2,f
    rlf        ?+3,f
    RETURN
GERIAL:
    RRF        ?+3,f
    RRF        ?+2,f
    RRF        ?+1,f
    RRF        ?    ,f
    RETURN
DIVCIK:
    ENDM
program içerisinde kullanımı ise
    CBLOCK 0X20
A    :4    
B    :4
        endc
BASLA:
        DIV32 A,B
        GOTO BASLA
END
işlem sonucunu gene A ya yazar
Hep meraktan

alikeskinkilic

#34
19 Mart 2023, 19:30:42
kütüphaneye yeni soluk geldi :)
Hep meraktan

alikeskinkilic

#35
22 Mart 2023, 09:11:24
Hep meraktan

alikeskinkilic

#36
26 Ağustos 2023, 00:55:06 Son düzenlenme: 26 Ağustos 2023, 01:05:02 alikeskinkilic
eprom bölgesinin verimli ve uzun ömürlü kullanılması için kaydedilen verilerin kaç kez kaydedildiğini tutup istediğimiz kayıt sayısına ulaşınca (ben 254 yaptım)tutulan veri miktarı kadar adresi ileri taşıyarak yazmaya oradan devam eden tüm bölgeler yazıldıktan sonra da tekrar ilk adresten yazmaya başlayıp aynı süreci takip eden bir algoritmadır.kodun işleyişini program içinde yorum olarak yazdım okuması kolay olsun diye
ilgili makroları (yazma ve okuma)aşağıda ayrıca attım
EEPROM:
 VERI_AL:;/////////////////// EPROMM OKU///////////////////
             ;ilk başlangıçta eeproma kayıtlı limit değeri 
        ;alınıp program içinde kullanılan değişkenlere atanır
        MOVLW    0                        ;epromun ilk adresinden itibaren 0xFF harici veriyi arıyoruz
        MOVWF    ADR1                    ;o veri bizim en son kayıtlarımızı yaptığımız adresin başlangıcı .
           CALL    EEPROM_OKU                ;bu yüzden ilk adresimizin 0xFF e ulaşmayacak şekilde ayarladığım 
           XORLW    0XFF                    ;kayıt sayısını 254 e sınırlayıp yazıyorum.
           BTFSS    STATUS    ,Z
           GOTO    $+3
           INCF    ADR1    ,F
           GOTO    $-5
           MOVFF    ADR1,ADR2                ;adresimizi bulduk şimdi başlangıcı ADR2 ye yedekliyoruz
        CALL    EEPROM_OKU                ;ki ADR1 program içerisinde sürekli değişecek referansımız ADR2 olacak
        MOVWF    KAYIT_SAYISI            ;ADRES1 = KAYIT ADEDİ 1 byte (aynı aderse kaç kayıt yapıldığını tutar)
        INCF    ADR1        ,F
        CALL    EEPROM_OKU                ;ADRES2 = mod 1 BYTE DEĞERİNİ TUTAR
        MOVWF    MODE    
        INCF    ADR1                    ;setu =2 byte yer tutuyor toplamda 4 byte alan kullanıyoruz
        CALL    EEPROM_OKU
        MOVWF    SETU
        INCF    ADR1
        CALL    EEPROM_OKU
        MOVWF    SETU+1
        MOVFF    ADR2,ADR1
        BTFSC    PORTA ,2
        GOTO     START
        BTFSC    PORTA ,1
        GOTO     START
        MOVFF    ADR2,ADR1
        INCF    ADR1
        TOGGLE    MODE    ,0
        MOVFF    MODE,EE                                            
        CALL    EEPROM_YAZ
        MOVFF    ADR2,ADR1
        GOTO    START                ;programda kullanılacak epromdaki veriler alınıp ilgili değişkenlere atandı
                                    ;kapatılıp açılmadıkça bura ile işimiz bitti daha uğramayacak
 ;////////////////////////*****************************///////////////////////////
EEPROM_YAZ:                            ;karaını program içerisinde verdiğimiz (örn bir tuşa basmak yada bir kesme olması)
          EWRITE    ADR1,EE                ;eproma kayıt yapar
          MOVFF    ADR2,ADR1                            ;İLK ADRESİ GÜNCELLE
        MOVLW    0XFE                ;kayıt sayısı 254 oldu ise adres değiştirmeye gidiyor 
        XORWF    KAYIT_SAYISI ,W        ; değilse kayıt sayısını 1 artırıp devam ediyor
        BTFSS    STATUS    ,Z                            ;İlk ADRESTEKİ KAYIT SAYISINI BİR ARRTIR VE GÜNCELLE
          GOTO    XXX
                                                  ;254 KAYIT SAYISI OLDUYSA
          GOTO    ADRES_DEGIS
XXX:                                             ;ADRES DEĞİŞ
          MOVFF    KAYIT_SAYISI ,EE    
          EWRITE  ADR1,EE                
          GOTO    DEVAM
  ;///////////////////////ADRES DEĞİŞ/////////////////
ADRES_DEGIS:                         ;Değişecek olan adreslerdeki verileri değişkenlere yedekliyoruz
        MOVFF    ADR2,ADR1                         ;İLK ADRESİ AL( KAYIT SAYISI)    
        CALL    EEPROM_OKU    
        MOVWF    KAYIT_SAYISI
        INCF    ADR1        ,F                    ; verileri sıra ile AL
        CALL    EEPROM_OKU
        MOVWF    MODE                
        INCF    ADR1        ,F
        CALL    EEPROM_OKU
        MOVWF    SETU                
;        MOVWF    SETUA
        INCF    ADR1        ,F
        CALL    EEPROM_OKU
        MOVWF    SETU+1                
;        MOVWF    SETUA+1       
        MOVFF    ADR2,ADR1                
          MOVLW    0XFF                    ;ADRES TUTUCUDAKİ ADRES BAŞLANGIÇ SAYISINI VERİ SAYISI KADAR ARTTIR
          MOVWF    EE
          MOVLW    .4                ;ÖNCEKİ ADRESLERE 0XFF YAZ 4 byte yer tuttuğu için 4 tekrar yapıyor her seferinde adresi 1 artırıp
          MOVWF    _TMP0
      ;    MOVFF    ADR2,ADR1
          CALL    EPROMYAZ
          INCF    ADR1    ,F                        ;MODE
          DECFSZ    _TMP0
          GOTO    $-3
          MOVF    ADR2        ,W            ;adres 248 oldu ise adresi 0 dan tekrar başlat(limit değeri veri miktarımızın katı olmak zorunda yoksa ADR2 limitimizi geçer haberimiz olmaz)
          XORLW    0XF8                    ;ADR2 de tuttuğumuz adres başlangıcının değeri istediğimiz limite ulaştı ise        
          BTFSS    STATUS    ,Z
          GOTO    YZX
YYY:
          CLRF    ADR2                    ;eprom en başından başlayarak tekrar yazmaya başlar
          CLRW                            ;ADR2 sıfırlanır
          GOTO    XYZ
YZX:
          MOVLW    4                        ;eğer limite ulaşmadı ise mevcut adrese ADR2 ye 4 eklenir(veri sayısı )    
          MOVWF    _TMP0    
XYZ:
          ADDWF    ADR2                    ;ve değişkenlere yedeklerini aldığımız tüm veriler 
          MOVFF    ADR2,ADR1                ;yeni adreslerine yazılır.
          CLRF    KAYIT_SAYISI
          MOVFF    KAYIT_SAYISI,EE                ;KAKYIT_SAYISI        ;KAYDEDİLEN VERİLER 3 ADET
          CALL    EPROMYAZ                    
          INCF    ADR1                                    
          MOVFF    MODE,EE                        
          CALL    EPROMYAZ                    
          INCF    ADR1
          MOVFF    SETU,EE
          CALL    EPROMYAZ
          INCF    ADR1
          MOVFF    SETU+1,EE
          CALL    EPROMYAZ
          MOVFF    ADR2,ADR1
          GOTO    DEVAM    
EPROMYAZ:
          EWRITE    ADR1,EE                ;eeprom yazma makrosu
          
 ;         INCF    ADR1        ,F
          RETURN                    
DEVAM:
          
         RETURN
EEPROM_OKU:
        EREAD    ADR1                ;eeprom okuma makrosu
        RETURN

START:
EEPROM okuma ve yazma makroları
;/////////////////////////////////////////////////////////////////    
    ;EEPROM YAZMA
;/////////////////////////////////////////////////////////////////
EWRITE    MACRO ?3,?1                ;WRITE ADRES , DATA
    BCF        INTCON    ,GIE        ;KESMELERİ KAPAR (ÖNEMLİ KESME OLMAMALI YAZMA ESNASINDA)
    BCF        PIR2        ,EEIF    ;BAYRAĞI İNDİR
    MOVF    ?3        ,W        ;
    BANKSEL    EEADR
    MOVWF    EEADR            ;BELİRTTİĞİMİZ ADRESİ EEADR E YAZ(YAZILACAK ADRESİ SEÇ)
    BANKSEL    ?1
    MOVF    ?1        ,W        ;
    BANKSEL    EEDAT
    MOVWF    EEDAT            ;VERİYİ ADRESE YAZ
    BANKSEL    EECON1
    BCF        EECON1    ,EEPGD    ;eeprom veya program hafızası seçilebilir.burada eeprom seçili
    BSF        EECON1    ,WREN    ;yazmayı aç
    MOVLW    0X55
    MOVWF    EECON2            ;yazma için rutin olan h55 ve hAA komutları eecon2 ye sırası ile yazılmalı
    MOVLW    0XAA
    MOVWF    EECON2            ;eecon2 ye sırası ile yazılmalı
    BSF        EECON1    ,WR        ;yazmaya başla
    BTFSC    EECON1     ,WR
    GOTO        $-1                 ;bitene kadar takıl
    BANKSEL    PIR2        
    BTFSS    PIR2         ,EEIF    ;TAMAMLANINCA BAYRAK KALKAR DEVAM
    GOTO        $-1
    BANKSEL    EECON1
    BCF        EECON1    ,WREN    ;yazmayı kapat
    BCF        STATUS    ,RP1
    BCF        STATUS    ,RP0            ;Bank 0
    BCF        PIR2    ,EEIF    ;BAYRAĞI İNDİR
;    BSF        INTCON    ,GIE
    ENDM

;////////////////////////////////////////////////////////////////
    ;EEPROM OKUMA
;////////////////////////////////////////////////////////////////
EREAD    MACRO    ?
    MOVF     ?, W;
    BANKSEL     EEADR
    MOVWF    EEADR        ;Data Memory ;Address to read
    BANKSEL     EECON1
    BCF        EECON1, EEPGD    ;Point to DATA memory
    BSF        EECON1, RD    ;EE Read
    BTFSC    EECON1, RD
    GOTO        $-1
    BANKSEL     EEDAT
    MOVF        EEDAT, W        ;W = EEDAT
    BANKSEL PORTA
    ENDM
Hep meraktan

alikeskinkilic

#37
21 Ocak 2024, 12:15:58 Son düzenlenme: 21 Ocak 2024, 13:08:51 alikeskinkilic
evet devam kendi yazdığım makrolarda hız sağlam oldu fakat birbiri ile ilişkilendirme konusunda kusurları var her program için uyum sağlayamadım bende http://www.piclist.com/techref/microchip/math/index.htm sitesinde paylaşılan math kütüphanelerini kullanarak makro oluşturma kararı aldım biraz daha fazla zaman harcıyorlar ama en azından her seferinde stabil çalışıyorlar.makro ve sub asm dosyası halinde paylaşıyorum kullanımları kodların içinde yapmaya çalıştım. örnek ana program
    __CONFIG     0x30E4
    radix    dec
       LIST P = PIC16f690  
       INCLUDE "p16f690.inc"
;       INCLUDE "EPROM.INC"    
       INCLUDE "MATH.INC"
;    INCLUDE "fload.inc"

       RADIX    DEC
    extern  REGA0,REGB0,REGC0,subtract,add,multiply,divide,clrba,sqrt,DCOUNT,DCOUNT
;
    ;    GLOBAL    MAPS
;    EXTERN ;FLO1624,INT2416,FPM24,FLO2424;R0,R1,R2,R3,R4,DIZ0,DIZ1,R6,R7,R8,R9,R10,R11,R12,R13,R14,R15,R16,R17;,D0,D1,D2,D3,DS,DR,M0,M1,M2,MS,IF0,IF1,F0,F1,DIV32L

;        ENDC
VAR UDATA 0X20
X   RES 4  
Y   RES 4
ZB  RES 4 
DIG RES 10
_TMP0   EQU 0X70
_TMP1   EQU 0X71
_TMP2   EQU 0X72
        ORG    0X00
        GOTO    AYAR
        ORG    0X04
AYAR:
PAKET32 301 ,X
PAKET32 302  ,Y
BASLA:
   ; TOPLA32   X,Y,ZB;
   ;DIV32  X,Y,ZB
   ;KAREKOK X,ZB
;   MULL32 X,Y,ZB
;   BCD  X,DIG
;   DIV32 ZB,Y,ZB
EGER    X,"Z",Y
    GOTO $+2
HESAP:
    

        GOTO BASLA
    GOTO BASLA




        END 
       
burada farkettinizmi bilmiyorum kullanılan komutlar (makrolar) sayesinde neredeyse farklı bir dil oluşmaya başlıyor amacım da tam olarak bu sadece makrolar kullanılarak çok basit herkesin komutun ne iş yaptığını anlayacağı makrolar oluşturarak işlemcinin tüm ayarlarının yapılabildiği alt işlemlerin tek satırda yazılabildiği,takılan harici donanımların ve seri iletişim aygıtlarının halledilebildiği bir dil oluşturmak böylelikle C nin bıkkınlık veren her seferinde yazmak zorunda olduğumuz  { vs |  gibi kafa karıştıran işaretlemeleri yerine daha sade bir dil oluşması tabiki sadece PIC işlemciler için bu

21 Ocak 2024, 12:16:59
math kütüphanesi (math.asm) subasm alt dosya
       INCLUDE "p16f690.inc"
INCLUDE "MATH.INC"
UDATA 0X56
REGA0   RES 1                ;lsb
REGA1   RES 1 
REGA2   RES 1
REGA3    RES 1            ;msb
REGB0    RES 1            ;lsb
REGB1   RES 1
REGB2   RES 1
REGB3    RES 1                ;msb
REGC0    RES 1            ;lsb
REGC1   RES 1
REGC2   RES 1
REGC3    RES 1            ;msb
DSIGN    RES 1            ;Digit Sign. 0=positive,1=negative
;DIGIT1    RES 1            ;MSD
;DIGIT2  RES 1
;DIGIT3  RES 1
;DIGIT4  RES 1
;DIGIT5    RES 1                ;Decimal (BCD) digits
;DIGIT6  RES 1
;DIGIT7  RES 1
;DIGIT8  RES 1
;DIGIT9  RES 1
;DIGIT10    RES 1            ;LSD
MTEMP   RES 1
MCOUNT  RES 1
DCOUNT  RES 1

;*** 32 BIT SIGNED SUTRACT ***
;REGA - REGB -> REGA
;Return carry set if overflow
    GLOBAL REGA0,REGB0,REGC0,subtract,add,multiply,divide,clrba,sqrt,DCOUNT,DCOUNT 
CODE
subtract:
    call    negateb        ;Negate REGB
    skpnc
    return            ;Overflow

;*** 32 BIT SIGNED ADD ***
;REGA + REGB -> REGA
;Return carry set if overflow

add:
    movf    REGA3,w        ;Compare signs
    xorwf    REGB3,w
    movwf    MTEMP

    call    addba        ;Add REGB to REGA

    clrc            ;Check signs
    movf    REGB3,w        ;If signs are same
    xorwf    REGA3,w        ;so must result sign
    btfss    MTEMP,7        ;else overflow
    addlw    0x80
    return
;*** 32 BIT SIGNED MULTIPLY ***
;REGA * REGB -> REGA
;Return carry set if overflow
multiply:
    clrf    MTEMP        ;Reset sign flag
    call    absa        ;Make REGA positive
    skpc
    call    absb        ;Make REGB positive
    skpnc
    return                ;Overflow

    call    movac        ;Move REGA to REGC
    call    clra        ;Clear product

    movlw    D'31'        ;Loop counter
    movwf    MCOUNT

muloop:    
    call    slac        ;Shift left product and multiplicand
    
    rlf    REGC3,w            ;Test MSB of multiplicand
    skpnc                ;If multiplicand bit is a 1 then
    call    addba        ;add multiplier to product

    skpc                ;Check for overflow
    rlf    REGA3,w
    skpnc
    return

    decfsz    MCOUNT,f    ;Next
    goto    muloop

    btfsc    MTEMP,0        ;Check result sign
    call    negatea        ;Negative
    return


;*** 32 BIT SIGNED DIVIDE ***
;REGA / REGB -> REGA
;Remainder in REGC
;Return carry set if overflow or division by zero

divide:
    clrf    MTEMP        ;Reset sign flag
    movf    REGB0,w        ;Trap division by zero
    iorwf    REGB1,w
    iorwf    REGB2,w
    iorwf    REGB3,w
    sublw    0
    skpc
    call    absa        ;Make dividend (REGA) positive
    skpc
    call    absb        ;Make divisor (REGB) positive
    skpnc
    return                ;Overflow

    clrf    REGC0        ;Clear remainder
    clrf    REGC1
    clrf    REGC2
    clrf    REGC3
    call    slac        ;Purge sign bit

    movlw    D'31'        ;Loop counter
    movwf    MCOUNT

dvloop:
    call    slac        ;Shift dividend (REGA) msb into remainder (REGC)

    movf    REGB3,w        ;Test if remainder (REGC) >= divisor (REGB)
    subwf    REGC3,w
    skpz
    goto    dtstgt
    movf    REGB2,w
    subwf    REGC2,w
    skpz
    goto    dtstgt
    movf    REGB1,w
    subwf    REGC1,w
    skpz
    goto    dtstgt
    movf    REGB0,w
    subwf    REGC0,w
dtstgt:
    skpc                ;Carry set if remainder >= divisor
    goto    dremlt

    movf    REGB0,w        ;Subtract divisor (REGB) from remainder (REGC)
    subwf    REGC0,f
    movf    REGB1,w
    skpc
    incfsz    REGB1,w
    subwf    REGC1,f
    movf    REGB2,w
    skpc
    incfsz    REGB2,w
    subwf    REGC2,f
    movf    REGB3,w
    skpc
    incfsz    REGB3,w
    subwf    REGC3,f
    clrc
    bsf    REGA0,0        ;Set quotient bit

dremlt:
    decfsz    MCOUNT,f    ;Next
    goto    dvloop

    btfsc    MTEMP,0        ;Check result sign
    call    negatea        ;Negative
    return

;*** ROUND RESULT OF DIVISION TO NEAREST INTEGER ***

round:
    clrf    MTEMP        ;Reset sign flag
    call    absa        ;Make positive
    clrc
    call    slc        ;Multiply remainder by 2
    movf    REGB3,w        ;Test if remainder (REGC) >= divisor (REGB)
    subwf    REGC3,w
    skpz
    goto    rtstgt
    movf    REGB2,w
    subwf    REGC2,w
    skpz
    goto    dtstgt
    movf    REGB1,w
    subwf    REGC1,w
    skpz
    goto    rtstgt
    movf    REGB0,w
    subwf    REGC0,w
rtstgt:
    skpc            ;Carry set if remainder >= divisor
    goto    rremlt
    incfsz    REGA0,f        ;Add 1 to quotient
    goto    rremlt
    incfsz    REGA1,f
    goto    rremlt
    incfsz    REGA2,f
    goto    rremlt
    incf    REGA3,f
    skpnz
    return            ;Overflow,return carry set
rremlt:
    btfsc    MTEMP,0        ;Restore sign
    call    negatea
    return


;*** 32 BIT SQUARE ROOT ***
;sqrt(REGA) -> REGA
;Return carry set if negative

sqrt:
    rlf    REGA3,w        ;Trap negative values
    skpnc
    return

    call    movac        ;Move REGA to REGC
    call    clrba        ;Clear remainder (REGB) and root (REGA)

    movlw    D'16'        ;Loop counter
    movwf    MCOUNT

sqloop:
    rlf    REGC0,f        ;Shift two msb's
    rlf    REGC1,f        ;into remainder
    rlf    REGC2,f
    rlf    REGC3,f
    rlf    REGB0,f
    rlf    REGB1,f
    rlf    REGB2,f
    rlf    REGC0,f
    rlf    REGC1,f
    rlf    REGC2,f
    rlf    REGC3,f
    rlf    REGB0,f
    rlf    REGB1,f
    rlf    REGB2,f

    setc            ;Add 1 to root
    rlf    REGA0,f        ;Align root
    rlf    REGA1,f
    rlf    REGA2,f

    movf    REGA2,w        ;Test if remdr (REGB) >= root (REGA)
    subwf    REGB2,w
    skpz
    goto    ststgt
    movf    REGA1,w
    subwf    REGB1,w
    skpz
    goto    ststgt
    movf    REGA0,w
    subwf    REGB0,w
ststgt:
    skpc            ;Carry set if remdr >= root
    goto    sremlt

    movf    REGA0,w        ;Subtract root (REGA) from remdr (REGB)
    subwf    REGB0,f
    movf    REGA1,w
    skpc
    incfsz    REGA1,w
    subwf    REGB1,f
    movf    REGA2,w
    skpc
    incfsz    REGA2,w
    subwf    REGB2,f
    bsf    REGA0,1        ;Set current root bit

sremlt:
    bcf    REGA0,0        ;Clear test bit
    decfsz    MCOUNT,f    ;Next
    goto    sqloop

    clrc
    rrf    REGA2,f        ;Adjust root alignment
    rrf    REGA1,f
    rrf    REGA0,f
    return


;*** 32 BIT SIGNED BINARY TO DECIMAL ***
;REGA -> DIGITS 1 (MSD) TO 10 (LSD) & DSIGN
;DSIGN = 0 if REGA is positive, 1 if negative
;Return carry set if overflow
;Uses FSR register

;bin2dec:    
;    clrf    MTEMP        ;Reset sign flag
;    call    absa        ;Make REGA positive
;    skpnc
;    return                ;Overflow
;    call    clrdig        ;Clear all digits
;    movlw    D'32'        ;Loop counter
;    movwf    MCOUNT
;b2dloop:    
;    rlf    REGA0,f        ;Shift msb into carry
;    rlf    REGA1,f
;    rlf    REGA2,f
;    rlf    REGA3,f
;    movlw    DIGIT10
;    movwf    FSR        ;Pointer to digits
;    movlw    D'10'        ;10 digits to do
;    movwf    DCOUNT
;adjlp:
;    rlf    INDF,f        ;Shift digit and carry 1 bit left
;    movlw    D'10'
;    subwf    INDF,w        ;Check and adjust for decimal overflow
;    skpnc
;    movwf    INDF
;    decf    FSR,f        ;Next digit
;    decfsz    DCOUNT,f
;    goto    adjlp
;    decfsz    MCOUNT,f    ;Next bit
;    goto    b2dloop
;    btfsc    MTEMP,0        ;Check sign
;    bsf    DSIGN,0        ;Negative
;    clrc
;    return
;
;
;;*** 32 BIT SIGNED DECIMAL TO BINARY ***
;;Decimal DIGIT1 thro DIGIT(X) & DSIGN -> REGA
;;Set DSIGN = 0 for positive, DSIGN = 1 for negative values
;;Most significant digit in DIGIT1
;;Enter this routine with digit count in w register
;;Return carry set if overflow
;;Uses FSR register
;
;dec2bin:    
;    movwf    MTEMP        ;Save digit count
;    movlw    D'32'        ;Outer bit loop counter
;    movwf    MCOUNT
;
;d2blp1:    
;    movlw    DIGIT1-1    ;Set up pointer to MSD
;    movwf    FSR
;    movf    MTEMP,w        ;Inner digit loop counter
;    movwf    DCOUNT
;
;    movlw    D'10'
;    clrc            ;Bring in '0' bit into MSD
;
;d2blp2:    
;    incf    FSR,f
;    skpnc
;    addwf    INDF,f        ;Add 10 if '1' bit from prev digit
;    rrf    INDF,f        ;Shift out LSB of digit
;
;    decfsz    DCOUNT,f    ;Next L.S. Digit
;    goto    d2blp2
;
;    rrf    REGA3,f        ;Shift in carry from digits
;    rrf    REGA2,f
;    rrf    REGA1,f
;    rrf    REGA0,f
;
;    decfsz    MCOUNT,f    ;Next bit
;    goto    d2blp1
;
;    movf    INDF,w        ;Check for overflow
;    addlw    0xFF
;    skpc
;    rlf    REGA3,w
;    skpnc
;    return
;
;    btfsc    DSIGN,0        ;Check result sign
;    call    negatea        ;Negative
;    return
;
;
;UTILITY ROUTINES


;Add REGB to REGA (Unsigned)
;Used by add, multiply,

addba:    
    movf    REGB0,w        ;Add lo byte
    addwf    REGA0,f

    movf    REGB1,w        ;Add mid-lo byte
    skpnc            ;No carry_in, so just add
    incfsz    REGB1,w        ;Add carry_in to REGB
    addwf    REGA1,f        ;Add and propagate carry_out

    movf    REGB2,w        ;Add mid-hi byte
    skpnc
    incfsz    REGB2,w
    addwf    REGA2,f

    movf    REGB3,w        ;Add hi byte
    skpnc
    incfsz    REGB3,w
    addwf    REGA3,f
    return


;Move REGA to REGC
;Used by multiply, sqrt

movac:    
    movf    REGA0,w
    movwf    REGC0
    movf    REGA1,w
    movwf    REGC1
    movf    REGA2,w
    movwf    REGC2
    movf    REGA3,w
    movwf    REGC3
    return


;Clear REGB and REGA
;Used by sqrt

clrba:    
    clrf    REGB0
    clrf    REGB1
    clrf    REGB2
    clrf    REGB3

;Clear REGA
;Used by multiply, sqrt

clra:    
    clrf    REGA0
    clrf    REGA1
    clrf    REGA2
    clrf    REGA3
    return


;Check sign of REGA and convert negative to positive
;Used by multiply, divide, bin2dec, round

absa:    
    rlf    REGA3,w
    skpc
    return            ;Positive

;Negate REGA
;Used by absa, multiply, divide, bin2dec, dec2bin, round

negatea:    
    movf    REGA3,w        ;Save sign in w
    andlw    0x80

    comf    REGA0,f        ;2's complement
    comf    REGA1,f
    comf    REGA2,f
    comf    REGA3,f
    incfsz    REGA0,f
    goto    nega1
    incfsz    REGA1,f
    goto    nega1
    incfsz    REGA2,f
    goto    nega1
    incf    REGA3,f
nega1:
    incf    MTEMP,f        ;flip sign flag
    addwf    REGA3,w        ;Return carry set if -2147483648
    return


;Check sign of REGB and convert negative to positive
;Used by multiply, divide

absb:    
    rlf    REGB3,w
    skpc
    return            ;Positive

;Negate REGB
;Used by absb, subtract, multiply, divide

negateb:    
    movf    REGB3,w        ;Save sign in w
    andlw    0x80

    comf    REGB0,f        ;2's complement
    comf    REGB1,f
    comf    REGB2,f
    comf    REGB3,f
    incfsz    REGB0,f
    goto    negb1
    incfsz    REGB1,f
    goto    negb1
    incfsz    REGB2,f
    goto    negb1
    incf    REGB3,f
negb1:
    incf    MTEMP,f        ;flip sign flag
    addwf    REGB3,w        ;Return carry set if -2147483648
    return


;Shift left REGA and REGC
;Used by multiply, divide, round

slac:    
    rlf    REGA0,f
    rlf    REGA1,f
    rlf    REGA2,f
    rlf    REGA3,f
slc:        
    rlf    REGC0,f
    rlf    REGC1,f
    rlf    REGC2,f
    rlf    REGC3,f
    return


;Set all digits to 0
;Used by bin2dec
;
;clrdig:    
;    clrf    DSIGN
;    clrf    DIGIT1
;    clrf    DIGIT2
;    clrf    DIGIT3
;    clrf    DIGIT4
;    clrf    DIGIT5
;    clrf    DIGIT6
;    clrf    DIGIT7
;    clrf    DIGIT8
;    clrf    DIGIT9
;    clrf    DIGIT10
;    return
    END
BCD kısmını kapattım isteyen açabilir

21 Ocak 2024, 12:20:40
math.inc dosyası makrolar var içinde .
;//////////////// RAM ADRESİNDEN RAM ADRESİNE VERİ TRANSFERİ TAŞIMA ////////////////
;1 BYTE KULLANIMI= MOVFF A,B 
;2 BYTE KULLANIMI= MIVFF16 A,B
;4 BYTE KULLANIMI= MIVFF32 A,B
;MOVFFL MAKROSU FARKLI BANKLARDA BULUNAN REGİSTERLER ARASINDA TAŞIMA YAPAR
MOVFF MACRO ?0,?1                                         
    MOVF    ?0    ,W
    MOVWF    ?1
    ENDM
MOVFF16 MACRO ?0,?1
    MOVF    ?0    ,W
    MOVWF    ?1
    MOVF    (?0+1) ,W
    MOVWF    ?1+1
    ENDM
MOVFF32 MACRO ?0,?1
    MOVF    ?0    ,W
    MOVWF    ?1
    MOVF    ?0+1 ,W
    MOVWF    ?1+1
    MOVF    ?0+2 ,W
    MOVWF    ?1+2
    MOVF    ?0+3 ,W
    MOVWF    ?1+3
    ENDM 
MOVFFL MACRO ?0,?1
    BANKSEL ?0
    MOVF    ?0  ,W
    BANKSEL ?1
    MOVWF   ?1
    BANKSEL ?0
    ENDM
MOVFF16L MACRO ?0,?1
    BANKSEL ?0
    MOVF    ?0  ,W
    BANKSEL ?1
    MOVWF   ?1
    BANKSEL ?0
    MOVF    ?0+1 ,W
    BANKSEL ?1
    MOVWF   ?1+1
    BANKSEL ?0
    ENDM
MOVFF32L MACRO ?0,?1
    BANKSEL ?0
    MOVF    ?0  ,W
    BANKSEL ?1
    MOVWF   ?1
    BANKSEL ?0
    MOVF    ?0+1 ,W             ;26 KOMUT
    BANKSEL ?1
    MOVWF   ?1+1
    BANKSEL ?0
    MOVF    ?0+2    ,W
    BANKSEL ?1
    MOVWF   ?1+2
    BANKSEL ?0
    MOVF    ?0+3    ,W
    BANKSEL ?1    
    MOVWF   ?1+3
    BANKSEL ?0
    ENDM

 ;///////////////////////////32 BİT İARETLİ SABİT YAZMA//////////////////
;ÖRNEK= PAKET32 12345678,Out0 ; PAKET32 -12345678,Out0 yazıldığında da negatif değeri yazabilir adreslere
;RADIX DEC YAPILMALI DESİMAL SAYILAR İÇİN
;///////////////////////////////////////////////////////////////////////////////////////////////
PAKET32 MACRO Var, Address ;Address meblab ide için Cblock yada udata kullanıldığında ram başlangıç adresidir(otm)
    BANKSEL Address 
    movlw         Address ;
    movwf         FSR                    ;fsr ye adresi yükler
    movlw         Var & H'FF'            ;;en değersiz byte filtrelenip yazılır
    movwf         INDF                ;fsr nin işaretlediği adrese değeri yazar
    movlw         Var >>8 & H'FF'        ;; Var 8 bit kaydırılır filtrelenip fsr 1 arttırılır(bir sonraki ram bölgesi yazılır)
    incf         FSR,F
    movwf         INDF
    movlw         Var >>16 & H'FF'
    incf         FSR,F
    movwf         INDF 
    movlw         Var >>24 & H'FF'
    incf         FSR,F 
    movwf         INDF 
    ENDM  
;////////////////////16 BİT PAKET DEĞİŞKENLERE YAZILMASI///////////////////////////////////////////////
PAKET16    MACRO    VAR,ADDRESS
    BANKSEL     ADDRESS 
    movlw         ADDRESS ;
    movwf         FSR                    ;fsr ye adresi yükler
    movlw        VAR & H'FF'            ;;en değersiz byte filtrelenip yazılır
    movwf         INDF                ;fsr nin işaretlediği adrese değeri yazar
    movlw        VAR >>8 & H'FF'        ;; Var 8 bit kaydırılır filtrelenip fsr 1 arttırılır(bir sonraki ram bölgesi yazılır)
    incf         FSR,F
    movwf         INDF
    ENDM
;/////////////////////////////////MATEMATİK İŞLEMLERİ (4 İŞLEM)///////////////////////////////////
;//////////////////////////////KULLANIMI İÇİN MATH.ASM TANITILMALI////////////////////////////////
;///////////////KULLANIMI TOPLA A,B,C ŞEKLİNDE A İLE B TOPLANIR C YE YAZILIR//////////////////////
;BÖLME İŞLEMİNDE KALAN HATILATICI OLARAK KULLANILAN REGC DE TUTULUT SONUÇ İSE GENE A/B=C ŞEKLİNDEDİR
;//////32BİT İŞARETLİ TOPLAMA////    
TOPLA32 MACRO ?0,?1,?2
MOVFF32 ?0,REGA0
MOVFF32 ?1,REGB0
CALL    add
MOVFF32 REGA0,?2
;CALL    clrba
    ENDM
;//////32BİT ÇARPMA İŞARETLİ/////
MULL32 MACRO ?0,?1,?2
MOVFF32 ?0,REGA0
MOVFF32 ?1,REGB0
CALL   multiply
MOVFF32 REGA0,?2
ENDM
;///////32BİT İŞARETLİ BÖLME////
DIV32 MACRO ?0,?1,?2
MOVFF32 ?0,REGA0
MOVFF32 ?1,REGB0
    CALL    divide
MOVFF32 REGA0,?2
    ENDM
;///////KAREKÖK alma/////////
KAREKOK MACRO ?0,?2
MOVFF32 ?0,REGA0
    CALL    sqrt
MOVFF32 REGA0,?2
ENDM    
;////////BCD ÇEVİRİCİ/////////////
BCD MACRO ?0,?1
MOVFF32 ?0,REGA0
CALL bin2dec
ENDM
;////////////////////////////////////////////////////////////////////////////
;//////////////////////////////////////////////////////////////////////////////
;///////////////////////////BİR BİTİ TERSLER/////////////////////////////
;ÖRNEK= TOGGLE    PORTA,5
;/////////////////////////////////////////////////////////////////////
TOGGLE    MACRO    PORT? ,?0
        MOVLW    0X01<<?0
        XORWF    PORT? ,F
           ENDM
;////////////////////////////////FOR-NEXT DÖNGÜSÜ///////////////////////////////
;KULLANIMI    "FOR 0,255"        ; 255 TAKRAR YAPARAK FOR NEXT ARASINDAKİ KODU ÇALIŞTIRIR
;            KODLAR
;            ......
;            NEXT
;*******************************************************************************
FOR    MACRO    ?0,?1  ;R10,R11
        MOVLW    ?1 ;R11     
        MOVWF    R12
        MOVLW    ?0 ;R10    
        SUBWF    R12 ,F
        MOVF    PCL    ,W
        MOVWF    R13
        ENDM        
NEXT    MACRO          
        MOVF    R13 ,W
        DECFSZ  R12    
        MOVWF   PCL 
 
        ENDM
;//////////////////////////////IF-THEN KOŞULLARI////////////////////////////////////
;KULLANIMI (EGER A,"<",B) KOMUT KARŞILIĞINDA KOŞUL DOĞRU İSE İKİ ALT SATIRA YANLIŞSA BİR ALT SATIRA GİDER
;          (EGER A,"Z",B) A KÜÇÜK EŞİTSE ( Z İŞARETİ KÜÇÜK EŞİT İŞARETİNE EN ÇOK BENZEDİĞİ İÇİN SEÇİLDİ)
;          (EGER A,"=",B) A VE B EŞİTSE
;///////////////////DEĞER KIYASLAMASI//////////////////////////////////
;KULLANIMI= KARŞILAŞTIRILACAK HER BİR "WORD" DEĞERİ ARDIŞIK RAM BÖLGELERİNDE TUTULMALI 
;R15 VE R16 DEĞERLERİNİ ASCII DEĞERLER OLARAK İLGİLİ İŞARETLER OLARAK SEÇTİM 
;MAKRODA "=" SENBOLÜ KABUL EDİLMEDİĞİ İÇİN DEC KARŞILIĞI YAZILDI
;AMA ANA PROGRAMDA KULLANILABİLİR OLDU
;BOŞ BIRAKILAN SEMBOL YERİNE ASCII BOŞLUK BIRAKILMALI
;R6 ADRESİNİN İLK BİTİ TRUE/FALSE DÖNDÜRÜR 
;MAKRO ÇIKIŞI "R4" , 0 BİTİ KONTROL EDİLEREK İŞLEM YAPILIR
;" > " YADA "?" İŞARETİ İÇİN AYRI BİR İŞLEME GEREK YOK MEVCUT İŞLEMLERİN TERSİ OLDUĞUNDAN SADECE DEĞİŞKEN YERİ DEĞİŞECEK    
EGER    MACRO    ?0,?2,?1;,?2
        BCF        STATUS    ,C
        BCF        STATUS    ,Z
;        MOVF    ?0        ,W
;        MOVWF    R15         ;R0
;        MOVF    ?0+1    ,W
;        MOVWF    R15+1       ;R0+1    
;        MOVF    ?1        ,W
;        MOVWF    R16         ;R3    
;        MOVF    ?1+1    ,W
;        MOVWF    R16+1       ;R3+1

        IF    ?2=="<"                            ;????????
        MOVF        ?0+1   ,W  ;R0+1        ,W            ;IF Y <= ART THEN GOTO KAPA
        SUBWF        ?1+1   ,W  ;R3+1    ,W            ;
        BTFSS        STATUS    ,C            ;
        GOTO        $+6    
        BTFSS       STATUS  ,Z
        GOTO        $+5                
        MOVF        ?0     ,W  ;R0            ,W                                
        SUBWF        ?1     ,W  ;R3            ,W
        BTFSS        STATUS    ,C

        ELSE
;        IF   R1 == "<" && R2 == .32
        IF    ?2=="Z" 
        MOVF        ?0+1    ,W            ;IF Y < ART THEN 
        SUBWF        ?1+1    ,W            ;
        BTFSS        STATUS    ,C            ;
        GOTO        $+8                
        BTFSS        STATUS    ,Z
        GOTO        $+7                
        MOVF        ?0        ,W                                
        SUBWF        ?1        ,W
        BTFSC        STATUS    ,Z
        GOTO        $+3
        BTFSS        STATUS    ,C
        ELSE

        IF    ?2=="="
;        IF    R1 == .61 && R2 == .32
        MOVF        ?0+1    ,W
        XORWF        ?1+1    ,W
        BTFSS        STATUS    ,Z
        GOTO        $+5
        MOVF        ?0        ,W
        XORWF        ?1        ,W
        BTFSC        STATUS    ,Z
        GOTO         $+2
        ENDIF
        ENDIF
        ENDIF
        ENDM
MOVFF32L Şeklinde olan makrolar farklı banklardaki değerleri birbiri üzerine taşımak için ayrı yaptım normalde tek makro ile olabilirdi ama her seferinde bank değiştirmek zaman alıyor o yüzden gerekirse kullanılsın diye böyle yaptım kafalar karışmasın
Hep meraktan

alikeskinkilic

#38
21 Ocak 2024, 12:46:26
Alıntı yapılan: alikeskinkilic - 22 Mart 2023, 09:11:24

for nex döngüsü için makro içinde pcl kullanmıştım makroyu birden fazla kullanımda iki kere yazma sorunu olmaması için fakat gerek te yokmuş makro içerisinde kullandığımız lable ve değişkenleri "local for1,for2
şeklinde makro başlangıcında tanımladığımızda her makro için farklı adresi lokal olarak tanımlıyormuş yani
FOR	MACRO	?0,?1  ;R10,R11
    local for1
		MOVLW	?1 ;R11 	
		MOVWF	R12
		MOVLW	?0 ;R10	
		SUBWF	R12 ,F
		;MOVF	PCL	,W
		;MOVWF	R13
for1:
		ENDM		
NEXT	MACRO		  
		MOVF	R13 ,W
		DECFSZ  R12	
	    goto for1;MOVWF   PCL 
 
		ENDM
şeklinde yazarsak da ardarda kullanımlarda sorun olmayacaktır
Hep meraktan

alikeskinkilic

#39
21 Ocak 2024, 13:26:23
yeni bir dil oluşturma çabalarımı biraz uçuk bulabilirsiniz tabiki anlarım ama örnek olarak 
;///////////////////////////////////////////////////////////////////////////////
;///////////////////////UART_SET/////////////////////////////////////////////
; UART_SET BAUD,9OR8,TERS-DÜZ
;	UART_SET 9600,8,0
UART_SET MACRO	VAR,VAR1,VAR2
        BANKSEL TXSTA  
        BCF	TRISB		,7 ;tx
        BSF	TRISB		,5	
        MOVLW  0X24      		 ; TXEN,BRGH
        MOVWF  TXSTA   
        IF	VAR2>0 
        BANKSEL	BAUDCTL
        MOVLW	0X18			;İNVERTED
        MOVWF	BAUDCTL
        ELSE
        BANKSEL	BAUDCTL
        MOVLW	0X08
        MOVWF	BAUDCTL
      ;  CLRF	BAUDCTL			;NONİNVERTED
        ENDIF    	 ;
        BANKSEL RCSTA       	;
        MOVLW 0X80			;SPEN,CREN
        MOVWF RCSTA
        BANKSEL TRISA
        
        IFDEF	OSC_8
		IF VAR==9600
        MOVLW  .207      		;
        MOVWF  SPBRG
        BANKSEL	PORTA 
        ENDIF
        IF	VAR==10417
         MOVLW  .191   		;
        MOVWF  SPBRG
        BANKSEL	PORTA 
        ENDIF   
        IF	VAR==19200
         MOVLW  .103      		;
        MOVWF  SPBRG 
        BANKSEL	PORTA 
        ENDIF  
        IF	VAR==57600
         MOVLW  .34    		;
        MOVWF  SPBRG 
        BANKSEL	PORTA 
        ENDIF
        IF	VAR==115200
         MOVLW  .16   		;
        MOVWF  SPBRG 
        BANKSEL	PORTA                 
		ENDIF
		IF	VAR==230400
         MOVLW  .8 		;
        MOVWF  SPBRG  
        BANKSEL	PORTA               
		ENDIF
		IF	VAR1==8
		BCF	RCSTA	,RX9
		ENDIF
		IF	VAR1==9
		BSF	RCSTA	,RX9
		ENDIF
		ENDIF
		ENDM
;//////////////////////////////PRİNTF///////////////////UART HABERLEŞME SERİ GÖNDERME
PRINTF	MACRO	?0
		BANKSEL	PORTA
		BCF		R9		,0	
		BTFSC	INTCON	,GIE
		GOTO	$+2
		GOTO	$+3
		BCF		INTCON	,7
		BSF		R9		,0
	
		MOVF	?0,W
		MOVWF	TXREG
		BSF		STATUS	,RP0
		BTFSS	TXSTA	,TRMT
		GOTO	$-1
		BCF		STATUS	,RP0
	
		MOVF	?0+1,W
		MOVWF	TXREG
		BSF		STATUS	,RP0
		BTFSS	TXSTA	,TRMT
		GOTO	$-1
		BCF		STATUS	,RP0
		
;		MOVLW	.10
;		MOVWF	TXREG
;		BSF		STATUS	,RP0
;		BTFSS	TXSTA	,TRMT
;		GOTO	$-1
;		BCF		STATUS	,RP0
;				
;		MOVLW	.13
;		MOVWF	TXREG
;		BSF		STATUS	,RP0
;		BTFSS	TXSTA	,TRMT
;		GOTO	$-1
;		BCF		STATUS	,RP0
		
		BTFSC	R9	,0
		BSF		INTCON	,7

		ENDM
;////////////////////////////ASCİİ  GÖNDERME//////////////////////////////
PRINTA	MACRO	?0
		BCF		R9		,0	
		BANKSEL	PORTA
		BTFSC	INTCON	,GIE
		GOTO	$+2
		GOTO	$+3
		BCF		INTCON	,7
		BSF		R9		,0
		
	
		MOVLW	?0
		MOVWF	TXREG
		BSF		STATUS	,RP0
		BTFSS	TXSTA	,TRMT
		GOTO	$-1
		BCF		STATUS	,RP0			
		BTFSC	R9	,0
		BSF		INTCON	,7
ENDM
bu tarz kısaltmalar işlemcinin her aşamasında her bir işleminde uygulanabilmekte bir adxl345 için yada herhangi bir telekominikasyon formatı içinde kütüphane yazması sadece zaman alıcı ama imkanlar dahilinde oluyor tabi biraz da takviye şart
Hep meraktan

alikeskinkilic

#40
22 Ocak 2024, 15:39:49 Son düzenlenme: 22 Ocak 2024, 15:41:56 alikeskinkilic
nasıl adlandırılıyor bilmiyorum ama  bir değişkeni sıra ile boyutunu kendimizin belirlediği adette bir dizi değişkene yazma ilgili  bir makrodur.ben genellikle adxl tarzı bir sensörden okuduğum verileri ard arda dizip ortalamasını almak için yada dataloger yapmak için kayıt yapmakta kullanıyorum.
kullanımı "DIZ A,DIZI,10" Şeklindedir A bizim sensörden okuduğumuz değeri tutan değişken DIZI burada 10 byte uzunluğunda bir alanın ilk adresini temsil ediyor. komut sonrasında eğer DIZI registeri tamamen doldurulmuşsa iki satır alta sıçrar eğer henüz belirttiğimiz sayıda kayıt yapılmamışsa bir alt satıra gider BTFSS gibi yani Örnek:
CBLOCK;Yada UDATA
DIZI :10 ;10 Byte uzunluğunda değişken
endc
SAYAC EQU 0X73 ;Her banktan ulaşılabilir olması için sayaç değişkenleri 0x70 üstüne yazılıyor
ADXL_OKU:
......
movwf A
DIZ A,DIZI,10
GOTO ADXL_OKU
GOTO OKUMA_TAMAM
 
Macro kodu ise :
DIZ MACRO  ?0,?1,?2          ;?2 = kayıt sayısı
                             ;?1 = kayıt yapılan dizi değişkeni ilk adresi yada adı
        MOVLW   ?1           ;?0 = kaydedeceğimiz değişken
        ADDWF   SAYAC ,W 
        MOVWF   FSR
        MOVFF   ?0,INDF
        INCF    SAYAC ,F
        MOVF    SAYAC ,W
        XORLW   ?2  
        BTFSS   STATUS ,Z
        GOTO    $+3
        CLRF    SAYAC
        GOTO    $+2
        
        ENDM
       
Hep meraktan

alikeskinkilic

#41
22 Ocak 2024, 16:51:17
aynı makronun 2 byte versiyonu.
DIZ16 MACRO ?0,?1,?2
        MOVLW   ?1
        ADDWF   SAYAC   ,W
        MOVWF   FSR
        MOVFF   ?0,INDF
        INCF    FSR ,F
        MOVFF   ?0+1,INDF
        INCF    SAYAC
        INCF    SAYAC
        MOVF    SAYAC   ,W
        XORLW   ?2
        BTFSS   STATUS ,Z
        GOTO    $+3
        CLRF    SAYAC
        GOTO    $+2        
        ENDM
kayıt sayısı veri boyutu 2 byte olduğundan yarıya düşecek ona göre dizi değişkeni boyutunu ve kayıt sayısını 2 kat fazla ayarlayın sonra olmadı demeyin.
Hep meraktan

alikeskinkilic

#42
23 Ocak 2024, 14:45:27 Son düzenlenme: 23 Ocak 2024, 15:09:00 alikeskinkilic
yeni makro MEDIAN filtre(bir dizi değerin orta noktasını bulma) uygulamalarında kullanabileceğiniz bir dizi değişkendeki tüm değerleri karşılaştırıp en küçük değeri en başa taşıyan bir makrodur dizi boyutuna bağlı olarak ard arda çalıştırıldığında tüm listeyi küçükten büyüğe sıralar.makro içerisindeki for next döngüsünü işlem içerisinde çalışabilmesi için modifiyeli halini de attım onu da farklı bir makro yaptım diğer türlü çevrime sokamadım bu hali ile iyi çalışıyor daha kısa bir yolunu bulamadım henüz .örnek kod
    __CONFIG     0x30E4
    radix    dec
       LIST P = PIC16f690  
       INCLUDE "p16f690.inc"
;       INCLUDE "EPROM.INC"    
       INCLUDE "MATH.INC"
;    INCLUDE "fload.inc"

       RADIX    DEC
    extern  REGA0,REGB0,REGC0,subtract,add,multiply,divide,clrba,sqrt,DCOUNT,DCOUNT,subtract
;
    ;    GLOBAL    SAYAC
;    EXTERN FLO1624,INT2416,FPM24,FLO2424;R0,R1,R2,R3,R4,DIZ0,DIZ1,R6,R7,R8,R9,R10,R11,R12,R13,R14,R15,R16,R17,D0,D1,D2,D3,DS,DR,M0,M1,M2,MS,IF0,IF1,F0,F1,DIV32L

;        ENDC
VAR UDATA 0X20
X   RES 4  
Y   RES 4
ZB  RES 4 
DIG RES 20
_TMP0   EQU 0X70
_TMP1   EQU 0X71
_TMP2   EQU 0X72
SAYAC   EQU 0X73
RAM0    EQU 0X74
RAM1    EQU 0X75
RAM2    EQU 0X76
RAM3    EQU 0X77
RAM4    EQU 0X78
RAM5    EQU 0X79
RAM6    EQU 0X7A
RAM7    EQU 0X7B
        ORG    0X00
        GOTO    AYAR
        ORG    0X04
AYAR:
PAKET32 200 ,X
PAKET32 302  ,Y
SELF:
DECF    X   ,F
BASLA:
;   TOPLA32   X,Y,ZB;
;   DIV32  X,Y,ZB
;   KAREKOK X,ZB
;   MULL32 X,Y,ZB
;   BCD  X,DIG
;   DIV32 ZB,Y,ZB
;   EGER    X,"Z",Y
;   CIKAR32 X,Y,X
DIZ X,DIG,5     ;x in değerini her seferinde bir azaltarak sıra ile DIG in ilk 5 adresine yazar 


    GOTO SELF
    SIRALA DIG,5        ; ilk değeri diğer tüm değerler arasından en küçüğü ile değişir
    SIRALA DIG+1,4      ; ikinci değeri kalan değerler arasından en küçüğü ile değişir
    SIRALA DIG+2,3      ; öylece devam eder
    SIRALA DIG+3,2

HESAP:
    

        GOTO $
    GOTO BASLA




        END

23 Ocak 2024, 14:46:44
makrosu:
SIRALA MACRO   ?0,?1       ; ?0 DİZİ DEĞİŞKENİ BAŞLANGIÇ ADRESİ
         LOCAL KAR,TARA,AYRIL,BITIR,SONRAKI
         MOVLW  1
         MOVWF  RAM4
         MOVLW ?0                   ; SIRALANACAK BYTE SAYISI  
         MOVWF  FSR 
         MOVLW   ?1-1  
         MOVWF  RAM3   
 TARA:   
         FORR 0,RAM3
         MOVFF  INDF,RAM0
         MOVFW  RAM4
         ADDWF  FSR ,F
         MOVFF  INDF,RAM1
         EGER RAM0,"<",RAM1
         CALL   KAR
         CALL   SONRAKI      
         NEXT
         GOTO   BITIR   
 KAR:   
        MOVFF RAM0,INDF 
        MOVFW   RAM4
        SUBWF   FSR ,F  
        MOVFF RAM1,INDF 
        RETURN
 SONRAKI:
        INCF    RAM4,F
        DECFSZ  RAM3,F
        RETURN   
  BITIR:       
        ENDM       

23 Ocak 2024, 14:48:07
for makrosu için extra next makrosuna gerek yok diğerininkini ortak kullanabiliyor
FORR    MACRO    ?0,?1  ;R10,R11
    ;LOCAL R12,R13
        MOVFW    ?1 ;R11     
        MOVWF    0X7A
        MOVLW    ?0 ;R10    
        SUBWF    0X7A ,F
        MOVF    PCL    ,W
        MOVWF    0X7B
        ENDM
sadece for next makrosundaki R11 gibi değişkenler yerine tüm banklardan erişilebilir 0x7a ve 0x7b değişkenlerini kullandım diğerinde de değiştirirseniz sorunsuz ikisi de çalışır
Hep meraktan

alikeskinkilic

#43
23 Ocak 2024, 15:00:26 
NEXT	MACRO		  
		MOVF	0X7B ,W
		DECFSZ  0X7A	
	    MOVWF   PCL 
		ENDM
   
Hep meraktan

alikeskinkilic

#44
23 Ocak 2024, 15:39:38 Son düzenlenme: 23 Ocak 2024, 16:02:20 alikeskinkilic
işlevi resimlerde daha rahat görünebilir

Not sırala komutu sadece iki değeri karşılaştırmaz listenin tümünü karşılaştırır bu yüzden de birazcık zaman alır işlenmesi listenin büyüklüğüne bağlı olarak.
basic karşılığı "if a>b call yerdedıs
                "if a>c call yerdegıs
                 .....n  şeklinde devam eder
        yerdegıs: r= a
                  a=b
                  b=r
return"
olabilir
Hep meraktan
Yazdır
Yukarı git Sayfa 1 2 3
Kullanıcı Eylemleri
▲