dtmf_gen.lst

pic16c6x和pic16c7xxx都可以通用

02C5 0186    CLRF   PORTB

02C6 2AC6    GOTO   02C6h            while(1){}           /* done (loop) */

02C7 0008    RETURN               }
                                  #pragma option +l;

                                  /*
                                     MPC14 Library V1.11

                                     These routines may be adapted for any purpose when
                                     used with the MPC Code Development system.  No
                                     warranty is implied or given as to their usability
                                     for any purpose.

                                     Parts of these routines are adapted with permission from
                                     software supplied by Microchip the remainder is a
                                     translation of the standard software routines developed
                                     by Byte Craft Limited for embedded system compiler support.
                                  */

                                  /***********************************************************************
                                     Multiply Divide and Modulus routines for the MPC
                                     Code Development System.  These routines are used by
                                     the compiler as the part of the MPC14.LIB library.

                                          (c) Copyright 1988,1991,1994,1995

                                          Byte Craft Limited
                                          Waterloo, Ontario
                                          Canada N2J 4E4
                                          [phone]

                                          Walter Banks

                                  ************************************************************************/

                                  //-----------------------------------------------------------------------
                                  void __MUL16x16(void)
                                  {
                                    bits R0 @ &_t;
                                    bits R1 @ &_u;

                                    R0 = *(&__longAC) * *(&__longIX);
                                    R1 = FSR;
                                    R1 += (*(&__longAC+1) * (*(&__longIX  )));
                                    R1 += (*(&__longAC  ) * (*(&__longIX+1)));
                                    FSR = R1;            // instead of __FSRImage in 12-bit
                                    WREG = R0;           // instead of __WImage in 12-bit
                                  } // __MUL16x16()
                                  //-----------------------------------------------------------------------
                                  void __MUL8x8(void)
                                  {
                                     bits R @ _r;
                                     bits Q @ _q;

MPC "C" COMPILER BC.193 22-Aug-1995                                     PAGE 21


                                     bits S @ _s;

                                     Q = WREG;
                                     WREG = FSR;
                                     FSR = 0;
                                     S = 0;
                                     R = 0;
                                     R.3 = 1;
                                    do {
                                        STATUS.C  = 0 ;    //  Clear carry bit in the status Reg.
                                        if (Q.0 == 1) FSR += WREG; // High Byte
                                        RRF(FSR);
                                        RRF(S   );
                                        RRF(Q   );
                                    } while (--R);
                                    WREG = S;
                                  } // __MUL8X8(void)
                                  //-----------------------------------------------------------------------
                                  void __DIV8BY8(void)
                                  {
                                    char ACCaLO @ FSR;
                                    char ACCbLO @ _q;
                                    char ACCcLO @ _r;
                                    char ACCdLO @ _s;
                                    char temp   @ _t;

                                    ACCdLO = WREG;

                                    temp = 8;        // for 8 shifts
                                    ACCbLO = 0;
                                    ACCcLO = 0;
                                    do {
                                      STATUS.C=0;
                                      RLF(ACCdLO);
                                      RLF(ACCcLO);
                                      if (ACCaLO <= ACCcLO) {
                                        ACCcLO -= ACCaLO;     // c-a into c
                                        STATUS.C = 1;         // shift a 1 into b (result)
                                      }
                                      RLF(ACCbLO);
                                    } while (--temp);     // loop until all bits checked

                                      FSR=ACCbLO;
                                      WREG=ACCcLO;
                                  } //  __DIV8X8
                                  //-----------------------------------------------------------------------
                                  void __LDIV(void)
                                  {
                                   unsigned long ACCa     @ &__longIX;
                                   char          ACCaLO   @ &__longIX;
                                   char          ACCaHI   @ &__longIX+1;

                                   unsigned long ACCb     @ &__longAC;
                                   char          ACCbLO   @ &ACCb;
                                   char          ACCbHI   @ &ACCb+1;

MPC "C" COMPILER BC.193 22-Aug-1995                                     PAGE 22



                                   unsigned long ACCc     @ &long_q;
                                   char          ACCcLO   @ &ACCc;
                                   char          ACCcHI   @ &ACCc+1;

                                   unsigned long ACCd     @ &long_s;
                                   char          ACCdLO   @ &ACCd;
                                   char          ACCdHI   @ &ACCd+1;

                                   char temp @ _u;

                                   temp = 0x10;                   // for 16 shifts

                                   ACCdHI = *(&__longAC+1);       // move ACCb to ACCd
                                   ACCdLO = *(&__longAC);         //

                                   ACCbHI = 0;
                                   ACCbLO = 0;

                                   ACCcHI = 0;
                                   ACCcLO = 0;

                                   do {
                                     STATUS.C = 0;
                                     RLF(ACCdLO);
                                     RLF(ACCdHI);
                                     RLF(ACCcLO);
                                     RLF(ACCcHI);
                                     if (ACCc >= ACCa) {
                                       ACCc = ACCc - ACCa;        // c-a into c
                                       STATUS.C = 1;              // shift a 1 into b (result)
                                     } // if
                                     RLF(ACCbLO);
                                     RLF(ACCbHI);
                                   } while (--temp);              // loop until all bits checked
                                   FSR = ACCbHI;
                                   WREG = ACCbLO;
                                  } // __LDIV()
                                  //-----------------------------------------------------------------------
                                  unsigned long __RMOD(void)
                                  {
                                    unsigned long ACCc     @ &long_q;

                                    return(ACCc);
                                  }
                                  //-----------------------------------------------------------------------


                                  /*********************************************************************
                                          MPC Code Development System
                                          Delay Library for 14-bit core PIC16CXX V1.11

                                                        DELAY14.LIB

                                          (c) Copyright 1995   Byte Craft Limited

MPC "C" COMPILER BC.193 22-Aug-1995                                     PAGE 23


                                          421 King St.N., Waterloo, ON, Canada, N2J 4E4

                                          Sherif Abdel-Kader
                                  *********************************************************************/


                                  /****************************************************

                                                      Delays in ms

                                  ****************************************************/

                                  //-----------------------------------------------------------------------
                                  /*
                                     Clock Speed = 20MHz
                                     Inst. Clock =  5MHz
                                     Inst. dur.  = 0.2us
                                  */
                                  void Delay_Ms_20MHz(registerw delay)
0000                              {
                                  #asm
02C8 1283                  BCF STATUS, RP0     ;1
02C9 00A1                  MOVWF __WImage      ;1

                        DLMS20M1
                           RADIX DEC  ;Use decimal values
02CA 30F9                  MOVLW 249           ;1
02CB 0084                  MOVWF FSR           ;1

                        DLMS20M2               ;20 cycles
                        DLMS20M__  REPT  17
                           NOP
                        ENDM
02CC 0000  
02CD 00 00 
02CE 00 00 
02CF 00 00 
02D0 00 00 
02D1 00 00 
02D2 00 00 
02D3 00 00 
02D4 00 00 
02D5 00 00 
02D6 00 00 
02D7 00 00 
02D8 00 00 
02D9 00 00 
02DA 00 00 
02DB 00 00 
02DC 00 00 
02DD 84 0B                DECFSZ FSR        ;1
02DE CC 2A                goto  DLMS20M2    ;2

02DF A1 0B              DECFSZ __WImage     ;1
02E0 CA 2A              goto DLMS20M1       ;2

MPC "C" COMPILER BC.193 22-Aug-1995                                     PAGE 24


                               #endasm
02E1 0008    RETURN               }
                                  //-----------------------------------------------------------------------
                                  /*
                                     Clock Speed = 16MHz
                                     Inst. Clock =  4MHz
                                     Inst. dur.  = 0.25us
                                  */
                                  void Delay_Ms_16Hz(registerw delay)
                                  {
                                  #asm
                                     BCF STATUS, RP0     ;1
                                     MOVWF __WImage      ;1

                                  DLMS16M1
                                     RADIX DEC  ;Use decimal values
                                     MOVLW 249           ;1
                                     MOVWF FSR           ;1

                                  DLMS16M2               ;16 cycles
                                  DLMS16M__  REPT  13    ;13
                                       NOP
                                  ENDM
                                       DECFSZ FSR        ;1
                                       goto  DLMS16M2    ;2

                                     DECFSZ __WImage     ;1
                                     goto DLMS16M1       ;2
                                  #endasm
                                  }
                                  //-----------------------------------------------------------------------
                                  /*
                                     Clock Speed = 8MHz
                                     Inst. Clock = 2MHz
                                     Inst. dur.  = 0.5us
                                  */
                                  void Delay_Ms_8MHz(registerw delay)
                                  {
                                  #asm