cid.asm

cid file. the prgram is used to get caller id

        R1 = [P_Seg12];
        R1 |= B_Com3;
        [P_Seg12] = R1;
        RETF;

StartParseFsk:
        R1 = 0;
        bp = SW_CidBuf                  //clear CID buffer
?L_ClrCidBufLoop:
        [bp++] = r1
        cmp     bp,SW_CidBuf+CW_LenOfCidBuf
        jb      ?L_ClrCidBufLoop

        bp = FskCidBuf
        r1 = [bp++]
        r2 = r1 lsr 4
        r2 = r2 lsr 4
        r1 &= 0x00ff                    //Get CID type byte

        CMP     R1,0x0090;
        JZ      ?JapanFsk;
        [RW_FskTotalByteCnt] = r2       //Get whole CID byte length

        cmp     r1,0x0004
        jz      ?FSKIsSingle            //It is single format FSK CID
        cmp     r1,0x0006
        jz      ?FSKIsSingle            //It also is single format FSK CID

        CMP     R1,0x0080;
        JNZ     ?ParseFSKOver;
        call    F_ParseMultiFsk;         //Call function of parse multiple
        RETF;

?JapanFsk:
        R1 = 5;
        [RPtr_FskByteIndex] = R1;

        CALL    F_GetOneByte;
        CMP     R1,0x00C0;
        JNZ     ?ParseFSKOver;

        CALL    F_GetOneByte;
//        CMP     R1,0x0090;       //'DLE'
//        JNZ     ?JapanFsk_10;
//        CALL    F_GetOneByte;
//?JapanFsk_10:
        R1 &= 0x007F;
        [RW_FskTotalByteCnt] = R1;
        [RW_FskByteCnt] = R1;

        GoTo    F_ParseJapanFsk;

?FSKIsSingle:
        GoTo    F_ParseSingleFSK;

?ParseFSKOver:
        retf

//-----------------------------------------------------------------------
F_ParseJapanFsk:
        R2 = [RPtr_FskByteIndex];
        CMP     R2,[RW_FskTotalByteCnt];
        JB      ParseJapanFsk_10;
        RETF;

ParseJapanFsk_10:
        CALL    F_GetOneByte;
        R4 = R1;

        CALL    F_GetOneByte;
//        CMP     R1,0x0090;        //'DLE'
//        JNZ     ParseJapanFsk_20;
//        CALL    F_GetOneByte;
//
//        R3 = [RPtr_FskByteIndex];
//        R3 += 1;
//        [RPtr_FskByteIndex] = R3;
//
//ParseJapanFsk_20:
        R3 = R1 AND 0x007F;
        R1 = R4;

        CMP     R1,0x0082;      //number field
        JNZ     F_ParseJapanFsk;
        CALL    F_ParseJapanFskNumber;
        JMP     F_ParseJapanFsk;

ParseJapanFsk_99:
        RETF;

//----------------------------------------------------------------------------*/
// Input  : R3 - loop counter
//----------------------------------------------------------------------------*/
F_ParseJapanFskNumber:
        R1 = 0;
        CMP     R3,14;
        JAE     ParseJapanFskNumber_05;
        R1 = 14;
        R1 -= R3;
ParseJapanFskNumber_05:
        [RPtr_LcdDigit] = R1;

        PUSH    R3,R3 TO [SP];

        CMP     R3,0;
        JZ      ParseJapanFskNumber_99;  // loop counter = 0
ParseJapanFskNumber_10:
        CALL    F_GetOneByte;
        R1 &= 0x007F;
        CMP     R1,' ';
        JZ      ParseJapanFskNumber_35;
//        CMP     R1,'-';
//        JZ      ParseJapanFskNumber_35;

        CMP     R1,0x0039;
        JA      ParseJapanFskNumber_35;  //illegal
        CMP     R1,0x0030;
        JB      ParseJapanFskNumber_35;  //legal

        R1 &= 0x000F;
        JNZ     ParseJapanFskNumber_20;
        R1 = 0x000A;
ParseJapanFskNumber_20:
        BP = [RPtr_LcdDigit];
        R4 = BP;
        BP = BP LSL 4;
        BP -= R4;
        BP += Digit0;
        PUSH    R3 TO [SP];
        CALL    F_ShowDigit;
        POP     R3 FROM [SP];

        BP = [RPtr_LcdDigit];
        BP += 1;
        [RPtr_LcdDigit] = BP;
        CMP     BP,14;
        JAE     ParseJapanFskNumber_99;

ParseJapanFskNumber_35:
        R3 -= 1;
        JNZ     ParseJapanFskNumber_10;
ParseJapanFskNumber_99:

        POP     R3,R3 FROM [SP];
        R2 = [RPtr_FskByteIndex];
        [RPtr_FskByteIndex] = R2 + R3;
        RETF;

//-----------------------------------------------------------------------
F_ParseMultiFsk:
        BP = FskCidBuf;
        R1 = [BP++];
        R1 = R1 LSR 4;
        R1 = R1 LSR 4;
        [RW_FskByteCnt] = R1;

        R1 = 0x0002;
        [RPtr_FskByteIndex] = R1;
ParseMultiFsk_05:
        R1 = [RPtr_FskByteIndex];
        R1 -= 2;
        CMP     R1,[RW_FskTotalByteCnt];
        JAE     ParseMultiFsk_99;

        CALL    F_GetOneByte;
        CMP     R1,0x0001;
        JNZ     ParseMultiFsk_10;
        CALL    F_GetOneByte;
        CMP     R1,8;
        JNZ     SkipThisField_10;

        CALL    F_GetFourBytes;
        [RW_Date] = R4;
        CALL    F_GetFourBytes;
        [RW_Time] = R4;

        CALL    F_ShowMonthDay;

        R1 = [P_ColonSeg];
        R1 |= B_ColonCom;
        [P_ColonSeg] = R1;

        CALL    F_ShowDate;
        CALL    F_ShowTime;
        JMP     ParseMultiFsk_05;

ParseMultiFsk_10:
        CMP     R1,0x0002;
        JNZ     SkipThisField;
        CALL    F_GetOneByte;
        R3 = R1;
        CALL    F_ParseFSKNumber;
        JMP     ParseMultiFsk_05;

SkipThisField:
        CALL    F_GetOneByte;
SkipThisField_10:
        R1 += [RPtr_FskByteIndex];
        [RPtr_FskByteIndex] = R1;
        JMP     ParseMultiFsk_05;

ParseMultiFsk_99:
        RETF;

//-----------------------------------------------------------------------
F_ParseSingleFSK:
        bp =    FskCidBuf
        r1 =    [bp++]
        cmp     r1,0x0306
        jnz     ?NotMessageInformation
        r1 =    [bp++]
        r1&=    0x7f7f
        r2 =    [BP]
        r2&=    0x007f
        cmp     r1,0x4242               //'BB'
        jnz     ?NotMessageWaiting
        cmp     R2,0x0042               //'B'
        jnz     ?L_NoInformation
        call    F_ShowMessageFlag       //message waiting
        jmp     ?L_NoInformation

?NotMessageWaiting:
        cmp     r1,0x6F6F               //'oo'
        jnz     ?L_NoInformation
        cmp     r2,0x006F               //'o'
        jnz     ?L_NoInformation
        call    F_ClrMessageFlag        //message off
?L_NoInformation:
        jmp     ?L_ParseSingOver

//--------------------------------------------------------------
?NotMessageInformation:
        bp =    FskCidBuf
        r1 =    [bp++]                  //Get first word of CID data
        r1 =    r1 lsr 4
        r1 =    r1 lsr 4                //Shift it to get length byte
        cmp     r1,0x0008               //Check if length of CID less
                                        //than 8 bytes
        jl      ?L_ParseSingOver        //Yes, it's without reason,
                                        //not parse it
        [RW_FskByteCnt] = r1            //More than 8 bytes, save length
        r1 =    0x0002
        [RPtr_FskByteIndex]= r1         //Data pointer point to third byte

        r3 =    0x0000
        call    F_GetFourBytes          //Get 4 bytes from CID data buffer,
                                        //translate them into BCD code
                                        //and save then into r4.
        [RW_Date] = r4                  //Those 4 number is date
        call    F_GetFourBytes          //Get 4 bytes
        [RW_Time] = r4                  //Those 4 number is time
        call    F_ShowMonthDay          //Show month flag and day flag on LCD
        r1 =    [P_ColonSeg]
        r1|=    B_ColonCom
        [P_ColonSeg] = r1               //Show ":" between hour and minute on LCD
        call    F_ShowDate              //Show month and day on LCD
        call    F_ShowTime              //Show hour and minute on LCD

        r3 =    [RW_FskByteCnt]
        r3-=    8                       //Is there any byte afer time bytes?
        jz      ?L_SingleOut            //No, Out of area
        r1 =    [FskCidBuf+5]           //Check if this CID out of area or private
        r1&=    0x007f
        cmp     r1,0x0070               //private, 'p'
        jz      ?L_SinglePirvate
        cmp     r1,0x0050               //private, 'P'
        jz      ?L_SinglePirvate
        cmp     r1,0x006F               //out of area, 'o'
        jz      ?L_SingleOut
        cmp     r1,0x004f               //out of area, 'O'
        jnz     ?L_SingleHaveNumber     //either out of area nor private
?L_SingleOut:
        call    F_ShowOutOfAreaFlag     //Out of area, show correspond flag
        jmp     ?L_ParseSingOver

?L_SinglePirvate:
        call    F_ShowPrivateFlag       //Private, show correspond flag
        jmp     ?L_ParseSingOver

?L_SingleHaveNumber:
        call    F_ParseFSKNumber
?L_ParseSingOver:
        retf

//----------------------------------------------------------------------
F_ParseFSKNumber:
        r1 =    0x0000                  //Initial CID display position
        cmp     r3,14                   //Compare CID number's length
                                        //with LCD display number's
        jae     ?L_CIDBufPtrOk          //Above or equal, display from segment 0
        r1 =    14                      //Below, calculate display position
        r1-=    r3
?L_CIDBufPtrOk:
        [RPtr_LcdDigit] = r1            //Save position for display later

?L_ParseByteLoop:
        call    F_GetOneByte            //Get one byte from CID data buffer
        r1&=    0x007f                  //Elimate bit 7
        cmp     r1,0x39                 //Check if it is a valid number
        jg      ?L_FSKNumberOver
        cmp     r1,0x30
        jL      ?L_FSKNumberOver
        r1 &=   0x000f
        jnz     ?L_FSKNotZero
        r1 =    0x000a                  //It is 0, chang to 0xa so that
                                        //it can be display as "0",not " "
?L_FSKNotZero:
        Push    r2,bp to [sp]
        r2 =    [RPtr_LcdDigit] //Get LCD digital position
        bp =    r2 lsl 4                //Calculate digital position information
        bp-=    r2                      //offset
        bp+=    Digit0                  //Calculate absolute address
        call    F_ShowDigit             //Display digit
        r2 =    [RPtr_LcdDigit]
        r2+=    0x0001                  //LCD digital position increase
        [RPtr_LcdDigit] = r2
        pop             r2,bp from [sp]
        //call  F_StoreCIDBuf
        r3-=    0x0001                  //Check if display over
        jnz             ?L_ParseByteLoop//No, display next number
?L_FSKNumberOver:
        r2 =    0x0000                  //Yes, reset display position
        [RPtr_LcdDigit] = r2
        retf

//----------------------------------------------------------------------
F_GetFourBytes:
        call    F_GetOneByte
        r4 =    r1 lsl 4
        r4 =    r4 lsl 4
        r4 =    r4 lsl 4
        call    F_GetOneByte
        r1&=    0x000f
        r1 =    r1 lsl 4
        r1 =    r1 lsl 4
        r4|=    r1
        call    F_GetOneByte
        r1&=    0x000f
        r1 =    r1 lsl 4
        r4|=    r1
        call    F_GetOneByte
        r1 =    r1&0xf
        r4|=    r1
        retf

//----------------------------------------------------------------------
F_GetOneByte:
        r2 =    [RPtr_FskByteIndex]
        bp =    FskCidBuf
        bp+=    r2 lsr 1
        r1 =    [bp]
        test    r2,1
        jz      getonebyte
        r1 =    r1 lsr 4
        r1 =    r1 lsr 4
getonebyte:
        r1&=    0x00ff
        r2+=    1
        [RPtr_FskByteIndex] = r2
        retf

//----------------------------------------------------------------------
//Interrupt Routine
.TEXT
_FIQ:
        push    r1,bp to [sp]
        r1 =    B_Ioc1Int;
        [P_IntClr] = r1         
        pop     r1,bp from [sp]
        reti 
//-----------------------------------------------------------------------
_IRQ0:  
        push    r1,bp to [sp] 
        r1 =    B_Ioc0Int+B_RiInt+B_LineInt;
        [P_IntClr] = r1
        pop     r1,bp from [sp]
        reti
//-----------------------------------------------------------------------
_IRQ1:  
        push    r1,bp to [sp]
        r1 =    B_IoaInt
        [P_IntClr] = r1
        pop     r1,bp from [sp]
        reti 
//-----------------------------------------------------------------------
_IRQ2:  
        push    r1,bp to [sp]
        r1 =    B_TmrAInt
        [P_IntClr] = r1
        pop     r1,bp from [sp]
        reti 
//-----------------------------------------------------------------------
_IRQ3:
        push    r1,bp to [sp]
        r1  =   B_TmrBInt
        [P_IntClr] = r1
        POP     R1,BP from [SP]
        reti 
//-----------------------------------------------------------------------
//_IRQ4:
//      push    r1,bp to [sp]
//      r1 =    B_T32KHzInt
//      [P_IntClr] = r1
//      pop     r1,bp from [sp]
//      reti
//-----------------------------------------------------------------------
_IRQ5:
        push    r1,bp to [sp] 

        R1 = [RW_512HzTmr];
        JZ      TimerIsOver;
        R1 -= 1;
        [RW_512HzTmr] = R1;

TimerIsOver:
        r1 =    B_T2KHzInt 
        [P_IntClr] = r1
        pop     r1,bp from [sp] 
        reti 

//-----------------------------------------------------------------------
_IRQ6:
        push    r1,bp to [sp] 
        r1 =    B_T128HzInt 
        [P_IntClr] = r1
        pop     r1,bp from [sp] 
        reti 
//-----------------------------------------------------------------------
_IRQ7:
        push    r1,bp to [sp]
        r1=     B_T8HzInt
        [P_IntClr] = r1
//      r1 =    [RW_TwoHzTmr]
//      jz      ?L_TwoHzTmrOver
//      r1-=    0x0001
//      [RW_TwoHzTmr] = r1
//?L_TwoHzTmrOver:
        pop     r1,bp from [sp] 
        reti 
//-----------------------------------------------------------------------
_BREAK:
        reti
//-----------------------------------------------------------------------